diff options
Diffstat (limited to 'drivers/net/usb/mcs7830.c')
-rw-r--r-- | drivers/net/usb/mcs7830.c | 534 |
1 files changed, 534 insertions, 0 deletions
diff --git a/drivers/net/usb/mcs7830.c b/drivers/net/usb/mcs7830.c new file mode 100644 index 000000000000..6240b978fe3d --- /dev/null +++ b/drivers/net/usb/mcs7830.c | |||
@@ -0,0 +1,534 @@ | |||
1 | /* | ||
2 | * MosChips MCS7830 based USB 2.0 Ethernet Devices | ||
3 | * | ||
4 | * based on usbnet.c, asix.c and the vendor provided mcs7830 driver | ||
5 | * | ||
6 | * Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de> | ||
7 | * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com> | ||
8 | * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net> | ||
9 | * Copyright (c) 2002-2003 TiVo Inc. | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or modify | ||
12 | * it under the terms of the GNU General Public License as published by | ||
13 | * the Free Software Foundation; either version 2 of the License, or | ||
14 | * (at your option) any later version. | ||
15 | * | ||
16 | * This program is distributed in the hope that it will be useful, | ||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
19 | * GNU General Public License for more details. | ||
20 | * | ||
21 | * You should have received a copy of the GNU General Public License | ||
22 | * along with this program; if not, write to the Free Software | ||
23 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
24 | */ | ||
25 | |||
26 | #include <linux/crc32.h> | ||
27 | #include <linux/etherdevice.h> | ||
28 | #include <linux/ethtool.h> | ||
29 | #include <linux/init.h> | ||
30 | #include <linux/mii.h> | ||
31 | #include <linux/module.h> | ||
32 | #include <linux/netdevice.h> | ||
33 | #include <linux/usb.h> | ||
34 | |||
35 | #include "usbnet.h" | ||
36 | |||
37 | /* requests */ | ||
38 | #define MCS7830_RD_BMREQ (USB_DIR_IN | USB_TYPE_VENDOR | \ | ||
39 | USB_RECIP_DEVICE) | ||
40 | #define MCS7830_WR_BMREQ (USB_DIR_OUT | USB_TYPE_VENDOR | \ | ||
41 | USB_RECIP_DEVICE) | ||
42 | #define MCS7830_RD_BREQ 0x0E | ||
43 | #define MCS7830_WR_BREQ 0x0D | ||
44 | |||
45 | #define MCS7830_CTRL_TIMEOUT 1000 | ||
46 | #define MCS7830_MAX_MCAST 64 | ||
47 | |||
48 | #define MCS7830_VENDOR_ID 0x9710 | ||
49 | #define MCS7830_PRODUCT_ID 0x7830 | ||
50 | |||
51 | #define MCS7830_MII_ADVERTISE (ADVERTISE_PAUSE_CAP | ADVERTISE_100FULL | \ | ||
52 | ADVERTISE_100HALF | ADVERTISE_10FULL | \ | ||
53 | ADVERTISE_10HALF | ADVERTISE_CSMA) | ||
54 | |||
55 | /* HIF_REG_XX coressponding index value */ | ||
56 | enum { | ||
57 | HIF_REG_MULTICAST_HASH = 0x00, | ||
58 | HIF_REG_PACKET_GAP1 = 0x08, | ||
59 | HIF_REG_PACKET_GAP2 = 0x09, | ||
60 | HIF_REG_PHY_DATA = 0x0a, | ||
61 | HIF_REG_PHY_CMD1 = 0x0c, | ||
62 | HIF_REG_PHY_CMD1_READ = 0x40, | ||
63 | HIF_REG_PHY_CMD1_WRITE = 0x20, | ||
64 | HIF_REG_PHY_CMD1_PHYADDR = 0x01, | ||
65 | HIF_REG_PHY_CMD2 = 0x0d, | ||
66 | HIF_REG_PHY_CMD2_PEND_FLAG_BIT = 0x80, | ||
67 | HIF_REG_PHY_CMD2_READY_FLAG_BIT = 0x40, | ||
68 | HIF_REG_CONFIG = 0x0e, | ||
69 | HIF_REG_CONFIG_CFG = 0x80, | ||
70 | HIF_REG_CONFIG_SPEED100 = 0x40, | ||
71 | HIF_REG_CONFIG_FULLDUPLEX_ENABLE = 0x20, | ||
72 | HIF_REG_CONFIG_RXENABLE = 0x10, | ||
73 | HIF_REG_CONFIG_TXENABLE = 0x08, | ||
74 | HIF_REG_CONFIG_SLEEPMODE = 0x04, | ||
75 | HIF_REG_CONFIG_ALLMULTICAST = 0x02, | ||
76 | HIF_REG_CONFIG_PROMISCIOUS = 0x01, | ||
77 | HIF_REG_ETHERNET_ADDR = 0x0f, | ||
78 | HIF_REG_22 = 0x15, | ||
79 | HIF_REG_PAUSE_THRESHOLD = 0x16, | ||
80 | HIF_REG_PAUSE_THRESHOLD_DEFAULT = 0, | ||
81 | }; | ||
82 | |||
83 | struct mcs7830_data { | ||
84 | u8 multi_filter[8]; | ||
85 | u8 config; | ||
86 | }; | ||
87 | |||
88 | static const char driver_name[] = "MOSCHIP usb-ethernet driver"; | ||
89 | |||
90 | static int mcs7830_get_reg(struct usbnet *dev, u16 index, u16 size, void *data) | ||
91 | { | ||
92 | struct usb_device *xdev = dev->udev; | ||
93 | int ret; | ||
94 | |||
95 | ret = usb_control_msg(xdev, usb_rcvctrlpipe(xdev, 0), MCS7830_RD_BREQ, | ||
96 | MCS7830_RD_BMREQ, 0x0000, index, data, | ||
97 | size, msecs_to_jiffies(MCS7830_CTRL_TIMEOUT)); | ||
98 | return ret; | ||
99 | } | ||
100 | |||
101 | static int mcs7830_set_reg(struct usbnet *dev, u16 index, u16 size, void *data) | ||
102 | { | ||
103 | struct usb_device *xdev = dev->udev; | ||
104 | int ret; | ||
105 | |||
106 | ret = usb_control_msg(xdev, usb_sndctrlpipe(xdev, 0), MCS7830_WR_BREQ, | ||
107 | MCS7830_WR_BMREQ, 0x0000, index, data, | ||
108 | size, msecs_to_jiffies(MCS7830_CTRL_TIMEOUT)); | ||
109 | return ret; | ||
110 | } | ||
111 | |||
112 | static void mcs7830_async_cmd_callback(struct urb *urb) | ||
113 | { | ||
114 | struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context; | ||
115 | |||
116 | if (urb->status < 0) | ||
117 | printk(KERN_DEBUG "mcs7830_async_cmd_callback() failed with %d", | ||
118 | urb->status); | ||
119 | |||
120 | kfree(req); | ||
121 | usb_free_urb(urb); | ||
122 | } | ||
123 | |||
124 | static void mcs7830_set_reg_async(struct usbnet *dev, u16 index, u16 size, void *data) | ||
125 | { | ||
126 | struct usb_ctrlrequest *req; | ||
127 | int ret; | ||
128 | struct urb *urb; | ||
129 | |||
130 | urb = usb_alloc_urb(0, GFP_ATOMIC); | ||
131 | if (!urb) { | ||
132 | dev_dbg(&dev->udev->dev, "Error allocating URB " | ||
133 | "in write_cmd_async!"); | ||
134 | return; | ||
135 | } | ||
136 | |||
137 | req = kmalloc(sizeof *req, GFP_ATOMIC); | ||
138 | if (!req) { | ||
139 | dev_err(&dev->udev->dev, "Failed to allocate memory for " | ||
140 | "control request"); | ||
141 | goto out; | ||
142 | } | ||
143 | req->bRequestType = MCS7830_WR_BMREQ; | ||
144 | req->bRequest = MCS7830_WR_BREQ; | ||
145 | req->wValue = 0; | ||
146 | req->wIndex = cpu_to_le16(index); | ||
147 | req->wLength = cpu_to_le16(size); | ||
148 | |||
149 | usb_fill_control_urb(urb, dev->udev, | ||
150 | usb_sndctrlpipe(dev->udev, 0), | ||
151 | (void *)req, data, size, | ||
152 | mcs7830_async_cmd_callback, req); | ||
153 | |||
154 | ret = usb_submit_urb(urb, GFP_ATOMIC); | ||
155 | if (ret < 0) { | ||
156 | dev_err(&dev->udev->dev, "Error submitting the control " | ||
157 | "message: ret=%d", ret); | ||
158 | goto out; | ||
159 | } | ||
160 | return; | ||
161 | out: | ||
162 | kfree(req); | ||
163 | usb_free_urb(urb); | ||
164 | } | ||
165 | |||
166 | static int mcs7830_get_address(struct usbnet *dev) | ||
167 | { | ||
168 | int ret; | ||
169 | ret = mcs7830_get_reg(dev, HIF_REG_ETHERNET_ADDR, ETH_ALEN, | ||
170 | dev->net->dev_addr); | ||
171 | if (ret < 0) | ||
172 | return ret; | ||
173 | return 0; | ||
174 | } | ||
175 | |||
176 | static int mcs7830_read_phy(struct usbnet *dev, u8 index) | ||
177 | { | ||
178 | int ret; | ||
179 | int i; | ||
180 | __le16 val; | ||
181 | |||
182 | u8 cmd[2] = { | ||
183 | HIF_REG_PHY_CMD1_READ | HIF_REG_PHY_CMD1_PHYADDR, | ||
184 | HIF_REG_PHY_CMD2_PEND_FLAG_BIT | index, | ||
185 | }; | ||
186 | |||
187 | mutex_lock(&dev->phy_mutex); | ||
188 | /* write the MII command */ | ||
189 | ret = mcs7830_set_reg(dev, HIF_REG_PHY_CMD1, 2, cmd); | ||
190 | if (ret < 0) | ||
191 | goto out; | ||
192 | |||
193 | /* wait for the data to become valid, should be within < 1ms */ | ||
194 | for (i = 0; i < 10; i++) { | ||
195 | ret = mcs7830_get_reg(dev, HIF_REG_PHY_CMD1, 2, cmd); | ||
196 | if ((ret < 0) || (cmd[1] & HIF_REG_PHY_CMD2_READY_FLAG_BIT)) | ||
197 | break; | ||
198 | ret = -EIO; | ||
199 | msleep(1); | ||
200 | } | ||
201 | if (ret < 0) | ||
202 | goto out; | ||
203 | |||
204 | /* read actual register contents */ | ||
205 | ret = mcs7830_get_reg(dev, HIF_REG_PHY_DATA, 2, &val); | ||
206 | if (ret < 0) | ||
207 | goto out; | ||
208 | ret = le16_to_cpu(val); | ||
209 | dev_dbg(&dev->udev->dev, "read PHY reg %02x: %04x (%d tries)\n", | ||
210 | index, val, i); | ||
211 | out: | ||
212 | mutex_unlock(&dev->phy_mutex); | ||
213 | return ret; | ||
214 | } | ||
215 | |||
216 | static int mcs7830_write_phy(struct usbnet *dev, u8 index, u16 val) | ||
217 | { | ||
218 | int ret; | ||
219 | int i; | ||
220 | __le16 le_val; | ||
221 | |||
222 | u8 cmd[2] = { | ||
223 | HIF_REG_PHY_CMD1_WRITE | HIF_REG_PHY_CMD1_PHYADDR, | ||
224 | HIF_REG_PHY_CMD2_PEND_FLAG_BIT | (index & 0x1F), | ||
225 | }; | ||
226 | |||
227 | mutex_lock(&dev->phy_mutex); | ||
228 | |||
229 | /* write the new register contents */ | ||
230 | le_val = cpu_to_le16(val); | ||
231 | ret = mcs7830_set_reg(dev, HIF_REG_PHY_DATA, 2, &le_val); | ||
232 | if (ret < 0) | ||
233 | goto out; | ||
234 | |||
235 | /* write the MII command */ | ||
236 | ret = mcs7830_set_reg(dev, HIF_REG_PHY_CMD1, 2, cmd); | ||
237 | if (ret < 0) | ||
238 | goto out; | ||
239 | |||
240 | /* wait for the command to be accepted by the PHY */ | ||
241 | for (i = 0; i < 10; i++) { | ||
242 | ret = mcs7830_get_reg(dev, HIF_REG_PHY_CMD1, 2, cmd); | ||
243 | if ((ret < 0) || (cmd[1] & HIF_REG_PHY_CMD2_READY_FLAG_BIT)) | ||
244 | break; | ||
245 | ret = -EIO; | ||
246 | msleep(1); | ||
247 | } | ||
248 | if (ret < 0) | ||
249 | goto out; | ||
250 | |||
251 | ret = 0; | ||
252 | dev_dbg(&dev->udev->dev, "write PHY reg %02x: %04x (%d tries)\n", | ||
253 | index, val, i); | ||
254 | out: | ||
255 | mutex_unlock(&dev->phy_mutex); | ||
256 | return ret; | ||
257 | } | ||
258 | |||
259 | /* | ||
260 | * This algorithm comes from the original mcs7830 version 1.4 driver, | ||
261 | * not sure if it is needed. | ||
262 | */ | ||
263 | static int mcs7830_set_autoneg(struct usbnet *dev, int ptrUserPhyMode) | ||
264 | { | ||
265 | int ret; | ||
266 | /* Enable all media types */ | ||
267 | ret = mcs7830_write_phy(dev, MII_ADVERTISE, MCS7830_MII_ADVERTISE); | ||
268 | |||
269 | /* First reset BMCR */ | ||
270 | if (!ret) | ||
271 | ret = mcs7830_write_phy(dev, MII_BMCR, 0x0000); | ||
272 | /* Enable Auto Neg */ | ||
273 | if (!ret) | ||
274 | ret = mcs7830_write_phy(dev, MII_BMCR, BMCR_ANENABLE); | ||
275 | /* Restart Auto Neg (Keep the Enable Auto Neg Bit Set) */ | ||
276 | if (!ret) | ||
277 | ret = mcs7830_write_phy(dev, MII_BMCR, | ||
278 | BMCR_ANENABLE | BMCR_ANRESTART ); | ||
279 | return ret < 0 ? : 0; | ||
280 | } | ||
281 | |||
282 | |||
283 | /* | ||
284 | * if we can read register 22, the chip revision is C or higher | ||
285 | */ | ||
286 | static int mcs7830_get_rev(struct usbnet *dev) | ||
287 | { | ||
288 | u8 dummy[2]; | ||
289 | int ret; | ||
290 | ret = mcs7830_get_reg(dev, HIF_REG_22, 2, dummy); | ||
291 | if (ret > 0) | ||
292 | return 2; /* Rev C or later */ | ||
293 | return 1; /* earlier revision */ | ||
294 | } | ||
295 | |||
296 | /* | ||
297 | * On rev. C we need to set the pause threshold | ||
298 | */ | ||
299 | static void mcs7830_rev_C_fixup(struct usbnet *dev) | ||
300 | { | ||
301 | u8 pause_threshold = HIF_REG_PAUSE_THRESHOLD_DEFAULT; | ||
302 | int retry; | ||
303 | |||
304 | for (retry = 0; retry < 2; retry++) { | ||
305 | if (mcs7830_get_rev(dev) == 2) { | ||
306 | dev_info(&dev->udev->dev, "applying rev.C fixup\n"); | ||
307 | mcs7830_set_reg(dev, HIF_REG_PAUSE_THRESHOLD, | ||
308 | 1, &pause_threshold); | ||
309 | } | ||
310 | msleep(1); | ||
311 | } | ||
312 | } | ||
313 | |||
314 | static int mcs7830_init_dev(struct usbnet *dev) | ||
315 | { | ||
316 | int ret; | ||
317 | int retry; | ||
318 | |||
319 | /* Read MAC address from EEPROM */ | ||
320 | ret = -EINVAL; | ||
321 | for (retry = 0; retry < 5 && ret; retry++) | ||
322 | ret = mcs7830_get_address(dev); | ||
323 | if (ret) { | ||
324 | dev_warn(&dev->udev->dev, "Cannot read MAC address\n"); | ||
325 | goto out; | ||
326 | } | ||
327 | |||
328 | /* Set up PHY */ | ||
329 | ret = mcs7830_set_autoneg(dev, 0); | ||
330 | if (ret) { | ||
331 | dev_info(&dev->udev->dev, "Cannot set autoneg\n"); | ||
332 | goto out; | ||
333 | } | ||
334 | |||
335 | mcs7830_rev_C_fixup(dev); | ||
336 | ret = 0; | ||
337 | out: | ||
338 | return ret; | ||
339 | } | ||
340 | |||
341 | static int mcs7830_mdio_read(struct net_device *netdev, int phy_id, | ||
342 | int location) | ||
343 | { | ||
344 | struct usbnet *dev = netdev->priv; | ||
345 | return mcs7830_read_phy(dev, location); | ||
346 | } | ||
347 | |||
348 | static void mcs7830_mdio_write(struct net_device *netdev, int phy_id, | ||
349 | int location, int val) | ||
350 | { | ||
351 | struct usbnet *dev = netdev->priv; | ||
352 | mcs7830_write_phy(dev, location, val); | ||
353 | } | ||
354 | |||
355 | static int mcs7830_ioctl(struct net_device *net, struct ifreq *rq, int cmd) | ||
356 | { | ||
357 | struct usbnet *dev = netdev_priv(net); | ||
358 | return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL); | ||
359 | } | ||
360 | |||
361 | /* credits go to asix_set_multicast */ | ||
362 | static void mcs7830_set_multicast(struct net_device *net) | ||
363 | { | ||
364 | struct usbnet *dev = netdev_priv(net); | ||
365 | struct mcs7830_data *data = (struct mcs7830_data *)&dev->data; | ||
366 | |||
367 | data->config = HIF_REG_CONFIG_TXENABLE; | ||
368 | |||
369 | /* this should not be needed, but it doesn't work otherwise */ | ||
370 | data->config |= HIF_REG_CONFIG_ALLMULTICAST; | ||
371 | |||
372 | if (net->flags & IFF_PROMISC) { | ||
373 | data->config |= HIF_REG_CONFIG_PROMISCIOUS; | ||
374 | } else if (net->flags & IFF_ALLMULTI | ||
375 | || net->mc_count > MCS7830_MAX_MCAST) { | ||
376 | data->config |= HIF_REG_CONFIG_ALLMULTICAST; | ||
377 | } else if (net->mc_count == 0) { | ||
378 | /* just broadcast and directed */ | ||
379 | } else { | ||
380 | /* We use the 20 byte dev->data | ||
381 | * for our 8 byte filter buffer | ||
382 | * to avoid allocating memory that | ||
383 | * is tricky to free later */ | ||
384 | struct dev_mc_list *mc_list = net->mc_list; | ||
385 | u32 crc_bits; | ||
386 | int i; | ||
387 | |||
388 | memset(data->multi_filter, 0, sizeof data->multi_filter); | ||
389 | |||
390 | /* Build the multicast hash filter. */ | ||
391 | for (i = 0; i < net->mc_count; i++) { | ||
392 | crc_bits = ether_crc(ETH_ALEN, mc_list->dmi_addr) >> 26; | ||
393 | data->multi_filter[crc_bits >> 3] |= 1 << (crc_bits & 7); | ||
394 | mc_list = mc_list->next; | ||
395 | } | ||
396 | |||
397 | mcs7830_set_reg_async(dev, HIF_REG_MULTICAST_HASH, | ||
398 | sizeof data->multi_filter, | ||
399 | data->multi_filter); | ||
400 | } | ||
401 | |||
402 | mcs7830_set_reg_async(dev, HIF_REG_CONFIG, 1, &data->config); | ||
403 | } | ||
404 | |||
405 | static int mcs7830_get_regs_len(struct net_device *net) | ||
406 | { | ||
407 | struct usbnet *dev = netdev_priv(net); | ||
408 | |||
409 | switch (mcs7830_get_rev(dev)) { | ||
410 | case 1: | ||
411 | return 21; | ||
412 | case 2: | ||
413 | return 32; | ||
414 | } | ||
415 | return 0; | ||
416 | } | ||
417 | |||
418 | static void mcs7830_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *drvinfo) | ||
419 | { | ||
420 | usbnet_get_drvinfo(net, drvinfo); | ||
421 | drvinfo->regdump_len = mcs7830_get_regs_len(net); | ||
422 | } | ||
423 | |||
424 | static void mcs7830_get_regs(struct net_device *net, struct ethtool_regs *regs, void *data) | ||
425 | { | ||
426 | struct usbnet *dev = netdev_priv(net); | ||
427 | |||
428 | regs->version = mcs7830_get_rev(dev); | ||
429 | mcs7830_get_reg(dev, 0, regs->len, data); | ||
430 | } | ||
431 | |||
432 | static struct ethtool_ops mcs7830_ethtool_ops = { | ||
433 | .get_drvinfo = mcs7830_get_drvinfo, | ||
434 | .get_regs_len = mcs7830_get_regs_len, | ||
435 | .get_regs = mcs7830_get_regs, | ||
436 | |||
437 | /* common usbnet calls */ | ||
438 | .get_link = usbnet_get_link, | ||
439 | .get_msglevel = usbnet_get_msglevel, | ||
440 | .set_msglevel = usbnet_set_msglevel, | ||
441 | .get_settings = usbnet_get_settings, | ||
442 | .set_settings = usbnet_set_settings, | ||
443 | .nway_reset = usbnet_nway_reset, | ||
444 | }; | ||
445 | |||
446 | static int mcs7830_bind(struct usbnet *dev, struct usb_interface *udev) | ||
447 | { | ||
448 | struct net_device *net = dev->net; | ||
449 | int ret; | ||
450 | |||
451 | ret = mcs7830_init_dev(dev); | ||
452 | if (ret) | ||
453 | goto out; | ||
454 | |||
455 | net->do_ioctl = mcs7830_ioctl; | ||
456 | net->ethtool_ops = &mcs7830_ethtool_ops; | ||
457 | net->set_multicast_list = mcs7830_set_multicast; | ||
458 | mcs7830_set_multicast(net); | ||
459 | |||
460 | /* reserve space for the status byte on rx */ | ||
461 | dev->rx_urb_size = ETH_FRAME_LEN + 1; | ||
462 | |||
463 | dev->mii.mdio_read = mcs7830_mdio_read; | ||
464 | dev->mii.mdio_write = mcs7830_mdio_write; | ||
465 | dev->mii.dev = net; | ||
466 | dev->mii.phy_id_mask = 0x3f; | ||
467 | dev->mii.reg_num_mask = 0x1f; | ||
468 | dev->mii.phy_id = *((u8 *) net->dev_addr + 1); | ||
469 | |||
470 | ret = usbnet_get_endpoints(dev, udev); | ||
471 | out: | ||
472 | return ret; | ||
473 | } | ||
474 | |||
475 | /* The chip always appends a status bytes that we need to strip */ | ||
476 | static int mcs7830_rx_fixup(struct usbnet *dev, struct sk_buff *skb) | ||
477 | { | ||
478 | u8 status; | ||
479 | |||
480 | if (skb->len == 0) { | ||
481 | dev_err(&dev->udev->dev, "unexpected empty rx frame\n"); | ||
482 | return 0; | ||
483 | } | ||
484 | |||
485 | skb_trim(skb, skb->len - 1); | ||
486 | status = skb->data[skb->len]; | ||
487 | |||
488 | if (status != 0x20) | ||
489 | dev_dbg(&dev->udev->dev, "rx fixup status %x\n", status); | ||
490 | |||
491 | return skb->len > 0; | ||
492 | } | ||
493 | |||
494 | static const struct driver_info moschip_info = { | ||
495 | .description = "MOSCHIP 7830 usb-NET adapter", | ||
496 | .bind = mcs7830_bind, | ||
497 | .rx_fixup = mcs7830_rx_fixup, | ||
498 | .flags = FLAG_ETHER, | ||
499 | .in = 1, | ||
500 | .out = 2, | ||
501 | }; | ||
502 | |||
503 | static const struct usb_device_id products[] = { | ||
504 | { | ||
505 | USB_DEVICE(MCS7830_VENDOR_ID, MCS7830_PRODUCT_ID), | ||
506 | .driver_info = (unsigned long) &moschip_info, | ||
507 | }, | ||
508 | {}, | ||
509 | }; | ||
510 | MODULE_DEVICE_TABLE(usb, products); | ||
511 | |||
512 | static struct usb_driver mcs7830_driver = { | ||
513 | .name = driver_name, | ||
514 | .id_table = products, | ||
515 | .probe = usbnet_probe, | ||
516 | .disconnect = usbnet_disconnect, | ||
517 | .suspend = usbnet_suspend, | ||
518 | .resume = usbnet_resume, | ||
519 | }; | ||
520 | |||
521 | static int __init mcs7830_init(void) | ||
522 | { | ||
523 | return usb_register(&mcs7830_driver); | ||
524 | } | ||
525 | module_init(mcs7830_init); | ||
526 | |||
527 | static void __exit mcs7830_exit(void) | ||
528 | { | ||
529 | usb_deregister(&mcs7830_driver); | ||
530 | } | ||
531 | module_exit(mcs7830_exit); | ||
532 | |||
533 | MODULE_DESCRIPTION("USB to network adapter MCS7830)"); | ||
534 | MODULE_LICENSE("GPL"); | ||