1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/module.h>
25#include <linux/init.h>
26#include <linux/netdevice.h>
27#include <linux/etherdevice.h>
28#include <linux/ethtool.h>
29#include <linux/workqueue.h>
30#include <linux/mii.h>
31#include <linux/usb.h>
32#include <linux/usb/cdc.h>
33#include <linux/usb/usbnet.h>
34
35
36#if defined(CONFIG_USB_NET_RNDIS_HOST) || defined(CONFIG_USB_NET_RNDIS_HOST_MODULE)
37
38static int is_rndis(struct usb_interface_descriptor *desc)
39{
40 return (desc->bInterfaceClass == USB_CLASS_COMM &&
41 desc->bInterfaceSubClass == 2 &&
42 desc->bInterfaceProtocol == 0xff);
43}
44
45static int is_activesync(struct usb_interface_descriptor *desc)
46{
47 return (desc->bInterfaceClass == USB_CLASS_MISC &&
48 desc->bInterfaceSubClass == 1 &&
49 desc->bInterfaceProtocol == 1);
50}
51
52static int is_wireless_rndis(struct usb_interface_descriptor *desc)
53{
54 return (desc->bInterfaceClass == USB_CLASS_WIRELESS_CONTROLLER &&
55 desc->bInterfaceSubClass == 1 &&
56 desc->bInterfaceProtocol == 3);
57}
58
59#else
60
61#define is_rndis(desc) 0
62#define is_activesync(desc) 0
63#define is_wireless_rndis(desc) 0
64
65#endif
66
67static const u8 mbm_guid[16] = {
68 0xa3, 0x17, 0xa8, 0x8b, 0x04, 0x5e, 0x4f, 0x01,
69 0xa6, 0x07, 0xc0, 0xff, 0xcb, 0x7e, 0x39, 0x2a,
70};
71
72
73
74
75
76
77
78int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
79{
80 u8 *buf = intf->cur_altsetting->extra;
81 int len = intf->cur_altsetting->extralen;
82 struct usb_interface_descriptor *d;
83 struct cdc_state *info = (void *) &dev->data;
84 int status;
85 int rndis;
86 bool android_rndis_quirk = false;
87 struct usb_driver *driver = driver_of(intf);
88 struct usb_cdc_mdlm_desc *desc = NULL;
89 struct usb_cdc_mdlm_detail_desc *detail = NULL;
90
91 if (sizeof dev->data < sizeof *info)
92 return -EDOM;
93
94
95
96
97 if (len == 0 && dev->udev->actconfig->extralen) {
98
99
100
101 buf = dev->udev->actconfig->extra;
102 len = dev->udev->actconfig->extralen;
103 dev_dbg(&intf->dev, "CDC descriptors on config\n");
104 }
105
106
107
108
109 if (len == 0) {
110 struct usb_host_endpoint *hep;
111
112 hep = intf->cur_altsetting->endpoint;
113 if (hep) {
114 buf = hep->extra;
115 len = hep->extralen;
116 }
117 if (len)
118 dev_dbg(&intf->dev,
119 "CDC descriptors on endpoint\n");
120 }
121
122
123
124
125 rndis = (is_rndis(&intf->cur_altsetting->desc) ||
126 is_activesync(&intf->cur_altsetting->desc) ||
127 is_wireless_rndis(&intf->cur_altsetting->desc));
128
129 memset(info, 0, sizeof *info);
130 info->control = intf;
131 while (len > 3) {
132 if (buf [1] != USB_DT_CS_INTERFACE)
133 goto next_desc;
134
135
136
137
138
139
140
141
142 switch (buf [2]) {
143 case USB_CDC_HEADER_TYPE:
144 if (info->header) {
145 dev_dbg(&intf->dev, "extra CDC header\n");
146 goto bad_desc;
147 }
148 info->header = (void *) buf;
149 if (info->header->bLength != sizeof *info->header) {
150 dev_dbg(&intf->dev, "CDC header len %u\n",
151 info->header->bLength);
152 goto bad_desc;
153 }
154 break;
155 case USB_CDC_ACM_TYPE:
156
157
158
159 if (rndis) {
160 struct usb_cdc_acm_descriptor *acm;
161
162 acm = (void *) buf;
163 if (acm->bmCapabilities) {
164 dev_dbg(&intf->dev,
165 "ACM capabilities %02x, "
166 "not really RNDIS?\n",
167 acm->bmCapabilities);
168 goto bad_desc;
169 }
170 }
171 break;
172 case USB_CDC_UNION_TYPE:
173 if (info->u) {
174 dev_dbg(&intf->dev, "extra CDC union\n");
175 goto bad_desc;
176 }
177 info->u = (void *) buf;
178 if (info->u->bLength != sizeof *info->u) {
179 dev_dbg(&intf->dev, "CDC union len %u\n",
180 info->u->bLength);
181 goto bad_desc;
182 }
183
184
185
186
187
188 info->control = usb_ifnum_to_if(dev->udev,
189 info->u->bMasterInterface0);
190 info->data = usb_ifnum_to_if(dev->udev,
191 info->u->bSlaveInterface0);
192 if (!info->control || !info->data) {
193 dev_dbg(&intf->dev,
194 "master #%u/%p slave #%u/%p\n",
195 info->u->bMasterInterface0,
196 info->control,
197 info->u->bSlaveInterface0,
198 info->data);
199
200 if (rndis) {
201 android_rndis_quirk = true;
202 goto next_desc;
203 }
204 goto bad_desc;
205 }
206 if (info->control != intf) {
207 dev_dbg(&intf->dev, "bogus CDC Union\n");
208
209
210
211 if (info->data == intf) {
212 info->data = info->control;
213 info->control = intf;
214 } else
215 goto bad_desc;
216 }
217
218
219 if (info->control == info->data)
220 goto next_desc;
221
222
223 d = &info->data->cur_altsetting->desc;
224 if (d->bInterfaceClass != USB_CLASS_CDC_DATA) {
225 dev_dbg(&intf->dev, "slave class %u\n",
226 d->bInterfaceClass);
227 goto bad_desc;
228 }
229 break;
230 case USB_CDC_ETHERNET_TYPE:
231 if (info->ether) {
232 dev_dbg(&intf->dev, "extra CDC ether\n");
233 goto bad_desc;
234 }
235 info->ether = (void *) buf;
236 if (info->ether->bLength != sizeof *info->ether) {
237 dev_dbg(&intf->dev, "CDC ether len %u\n",
238 info->ether->bLength);
239 goto bad_desc;
240 }
241 dev->hard_mtu = le16_to_cpu(
242 info->ether->wMaxSegmentSize);
243
244
245
246 break;
247 case USB_CDC_MDLM_TYPE:
248 if (desc) {
249 dev_dbg(&intf->dev, "extra MDLM descriptor\n");
250 goto bad_desc;
251 }
252
253 desc = (void *)buf;
254
255 if (desc->bLength != sizeof(*desc))
256 goto bad_desc;
257
258 if (memcmp(&desc->bGUID, mbm_guid, 16))
259 goto bad_desc;
260 break;
261 case USB_CDC_MDLM_DETAIL_TYPE:
262 if (detail) {
263 dev_dbg(&intf->dev, "extra MDLM detail descriptor\n");
264 goto bad_desc;
265 }
266
267 detail = (void *)buf;
268
269 if (detail->bGuidDescriptorType == 0) {
270 if (detail->bLength < (sizeof(*detail) + 1))
271 goto bad_desc;
272 } else
273 goto bad_desc;
274 break;
275 }
276next_desc:
277 len -= buf [0];
278 buf += buf [0];
279 }
280
281
282
283
284
285
286
287
288
289 if (rndis && (!info->u || android_rndis_quirk)) {
290 info->control = usb_ifnum_to_if(dev->udev, 0);
291 info->data = usb_ifnum_to_if(dev->udev, 1);
292 if (!info->control || !info->data || info->control != intf) {
293 dev_dbg(&intf->dev,
294 "rndis: master #0/%p slave #1/%p\n",
295 info->control,
296 info->data);
297 goto bad_desc;
298 }
299
300 } else if (!info->header || !info->u || (!rndis && !info->ether)) {
301 dev_dbg(&intf->dev, "missing cdc %s%s%sdescriptor\n",
302 info->header ? "" : "header ",
303 info->u ? "" : "union ",
304 info->ether ? "" : "ether ");
305 goto bad_desc;
306 }
307
308
309
310
311 if (info->data != info->control) {
312 status = usb_driver_claim_interface(driver, info->data, dev);
313 if (status < 0)
314 return status;
315 }
316 status = usbnet_get_endpoints(dev, info->data);
317 if (status < 0) {
318
319 usb_set_intfdata(info->data, NULL);
320 if (info->data != info->control)
321 usb_driver_release_interface(driver, info->data);
322 return status;
323 }
324
325
326 if (info->data != info->control)
327 dev->status = NULL;
328 if (info->control->cur_altsetting->desc.bNumEndpoints == 1) {
329 struct usb_endpoint_descriptor *desc;
330
331 dev->status = &info->control->cur_altsetting->endpoint [0];
332 desc = &dev->status->desc;
333 if (!usb_endpoint_is_int_in(desc) ||
334 (le16_to_cpu(desc->wMaxPacketSize)
335 < sizeof(struct usb_cdc_notification)) ||
336 !desc->bInterval) {
337 dev_dbg(&intf->dev, "bad notification endpoint\n");
338 dev->status = NULL;
339 }
340 }
341 if (rndis && !dev->status) {
342 dev_dbg(&intf->dev, "missing RNDIS status endpoint\n");
343 usb_set_intfdata(info->data, NULL);
344 usb_driver_release_interface(driver, info->data);
345 return -ENODEV;
346 }
347 return 0;
348
349bad_desc:
350 dev_info(&dev->udev->dev, "bad CDC descriptors\n");
351 return -ENODEV;
352}
353EXPORT_SYMBOL_GPL(usbnet_generic_cdc_bind);
354
355void usbnet_cdc_unbind(struct usbnet *dev, struct usb_interface *intf)
356{
357 struct cdc_state *info = (void *) &dev->data;
358 struct usb_driver *driver = driver_of(intf);
359
360
361 if (info->data == info->control)
362 return;
363
364
365 if (intf == info->control && info->data) {
366
367 usb_set_intfdata(info->data, NULL);
368 usb_driver_release_interface(driver, info->data);
369 info->data = NULL;
370 }
371
372
373 else if (intf == info->data && info->control) {
374
375 usb_set_intfdata(info->control, NULL);
376 usb_driver_release_interface(driver, info->control);
377 info->control = NULL;
378 }
379}
380EXPORT_SYMBOL_GPL(usbnet_cdc_unbind);
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395static void dumpspeed(struct usbnet *dev, __le32 *speeds)
396{
397 netif_info(dev, timer, dev->net,
398 "link speeds: %u kbps up, %u kbps down\n",
399 __le32_to_cpu(speeds[0]) / 1000,
400 __le32_to_cpu(speeds[1]) / 1000);
401}
402
403void usbnet_cdc_status(struct usbnet *dev, struct urb *urb)
404{
405 struct usb_cdc_notification *event;
406
407 if (urb->actual_length < sizeof *event)
408 return;
409
410
411 if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) {
412 dumpspeed(dev, (__le32 *) urb->transfer_buffer);
413 return;
414 }
415
416 event = urb->transfer_buffer;
417 switch (event->bNotificationType) {
418 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
419 netif_dbg(dev, timer, dev->net, "CDC: carrier %s\n",
420 event->wValue ? "on" : "off");
421 usbnet_link_change(dev, !!event->wValue, 0);
422 break;
423 case USB_CDC_NOTIFY_SPEED_CHANGE:
424 netif_dbg(dev, timer, dev->net, "CDC: speed change (len %d)\n",
425 urb->actual_length);
426 if (urb->actual_length != (sizeof *event + 8))
427 set_bit(EVENT_STS_SPLIT, &dev->flags);
428 else
429 dumpspeed(dev, (__le32 *) &event[1]);
430 break;
431
432
433
434 default:
435 netdev_err(dev->net, "CDC: unexpected notification %02x!\n",
436 event->bNotificationType);
437 break;
438 }
439}
440EXPORT_SYMBOL_GPL(usbnet_cdc_status);
441
442int usbnet_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
443{
444 int status;
445 struct cdc_state *info = (void *) &dev->data;
446
447 BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data)
448 < sizeof(struct cdc_state)));
449
450 status = usbnet_generic_cdc_bind(dev, intf);
451 if (status < 0)
452 return status;
453
454 status = usbnet_get_ethernet_addr(dev, info->ether->iMACAddress);
455 if (status < 0) {
456 usb_set_intfdata(info->data, NULL);
457 usb_driver_release_interface(driver_of(intf), info->data);
458 return status;
459 }
460
461
462
463
464
465 return 0;
466}
467EXPORT_SYMBOL_GPL(usbnet_cdc_bind);
468
469static const struct driver_info cdc_info = {
470 .description = "CDC Ethernet Device",
471 .flags = FLAG_ETHER | FLAG_POINTTOPOINT,
472
473 .bind = usbnet_cdc_bind,
474 .unbind = usbnet_cdc_unbind,
475 .status = usbnet_cdc_status,
476 .manage_power = usbnet_manage_power,
477};
478
479static const struct driver_info wwan_info = {
480 .description = "Mobile Broadband Network Device",
481 .flags = FLAG_WWAN,
482 .bind = usbnet_cdc_bind,
483 .unbind = usbnet_cdc_unbind,
484 .status = usbnet_cdc_status,
485 .manage_power = usbnet_manage_power,
486};
487
488
489
490#define HUAWEI_VENDOR_ID 0x12D1
491#define NOVATEL_VENDOR_ID 0x1410
492#define ZTE_VENDOR_ID 0x19D2
493#define DELL_VENDOR_ID 0x413C
494#define REALTEK_VENDOR_ID 0x0bda
495
496static const struct usb_device_id products [] = {
497
498
499
500
501
502
503
504
505
506#define ZAURUS_MASTER_INTERFACE \
507 .bInterfaceClass = USB_CLASS_COMM, \
508 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, \
509 .bInterfaceProtocol = USB_CDC_PROTO_NONE
510
511
512
513
514
515{
516 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
517 | USB_DEVICE_ID_MATCH_DEVICE,
518 .idVendor = 0x04DD,
519 .idProduct = 0x8004,
520 ZAURUS_MASTER_INTERFACE,
521 .driver_info = 0,
522},
523
524
525
526
527
528
529{
530 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
531 | USB_DEVICE_ID_MATCH_DEVICE,
532 .idVendor = 0x04DD,
533 .idProduct = 0x8005,
534 ZAURUS_MASTER_INTERFACE,
535 .driver_info = 0,
536}, {
537 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
538 | USB_DEVICE_ID_MATCH_DEVICE,
539 .idVendor = 0x04DD,
540 .idProduct = 0x8006,
541 ZAURUS_MASTER_INTERFACE,
542 .driver_info = 0,
543}, {
544 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
545 | USB_DEVICE_ID_MATCH_DEVICE,
546 .idVendor = 0x04DD,
547 .idProduct = 0x8007,
548 ZAURUS_MASTER_INTERFACE,
549 .driver_info = 0,
550}, {
551 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
552 | USB_DEVICE_ID_MATCH_DEVICE,
553 .idVendor = 0x04DD,
554 .idProduct = 0x9031,
555 ZAURUS_MASTER_INTERFACE,
556 .driver_info = 0,
557}, {
558 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
559 | USB_DEVICE_ID_MATCH_DEVICE,
560 .idVendor = 0x04DD,
561 .idProduct = 0x9032,
562 ZAURUS_MASTER_INTERFACE,
563 .driver_info = 0,
564}, {
565 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
566 | USB_DEVICE_ID_MATCH_DEVICE,
567 .idVendor = 0x04DD,
568
569 .idProduct = 0x9050,
570 ZAURUS_MASTER_INTERFACE,
571 .driver_info = 0,
572},
573
574
575
576
577{
578 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
579 | USB_DEVICE_ID_MATCH_DEVICE,
580 .idVendor = 0x07B4,
581 .idProduct = 0x0F02,
582 ZAURUS_MASTER_INTERFACE,
583 .driver_info = 0,
584},
585
586
587{
588 USB_DEVICE_AND_INTERFACE_INFO(0x1004, 0x61aa, USB_CLASS_COMM,
589 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
590 .driver_info = 0,
591},
592
593
594{
595 USB_DEVICE_AND_INTERFACE_INFO(0x046d, 0xc11f, USB_CLASS_COMM,
596 USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
597 .driver_info = 0,
598},
599
600
601{
602 USB_DEVICE_AND_INTERFACE_INFO(NOVATEL_VENDOR_ID, 0xB001, USB_CLASS_COMM,
603 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
604 .driver_info = 0,
605},
606
607
608{
609 USB_DEVICE_AND_INTERFACE_INFO(NOVATEL_VENDOR_ID, 0x9010, USB_CLASS_COMM,
610 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
611 .driver_info = 0,
612},
613
614
615{
616 USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x8195, USB_CLASS_COMM,
617 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
618 .driver_info = 0,
619},
620
621
622{
623 USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x8196, USB_CLASS_COMM,
624 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
625 .driver_info = 0,
626},
627
628
629{
630 USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x819b, USB_CLASS_COMM,
631 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
632 .driver_info = 0,
633},
634
635
636{
637 USB_DEVICE_AND_INTERFACE_INFO(0x16d5, 0x650a, USB_CLASS_COMM,
638 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
639 .driver_info = 0,
640},
641
642
643{
644 USB_DEVICE_INTERFACE_NUMBER(HUAWEI_VENDOR_ID, 0x14ac, 1),
645 .driver_info = 0,
646},
647
648
649{
650 USB_DEVICE_AND_INTERFACE_INFO(REALTEK_VENDOR_ID, 0x8152, USB_CLASS_COMM,
651 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
652 .driver_info = 0,
653},
654
655
656{
657 USB_DEVICE_AND_INTERFACE_INFO(REALTEK_VENDOR_ID, 0x8153, USB_CLASS_COMM,
658 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
659 .driver_info = 0,
660},
661
662
663
664
665
666
667
668
669
670
671
672
673{
674
675 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
676 | USB_DEVICE_ID_MATCH_PRODUCT
677 | USB_DEVICE_ID_MATCH_INT_INFO,
678 .idVendor = ZTE_VENDOR_ID,
679 .idProduct = 0x1003,
680 .bInterfaceClass = USB_CLASS_COMM,
681 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
682 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
683 .driver_info = (unsigned long)&wwan_info,
684}, {
685
686 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
687 | USB_DEVICE_ID_MATCH_PRODUCT
688 | USB_DEVICE_ID_MATCH_INT_INFO,
689 .idVendor = ZTE_VENDOR_ID,
690 .idProduct = 0x1015,
691 .bInterfaceClass = USB_CLASS_COMM,
692 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
693 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
694 .driver_info = (unsigned long)&wwan_info,
695}, {
696
697 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
698 | USB_DEVICE_ID_MATCH_PRODUCT
699 | USB_DEVICE_ID_MATCH_INT_INFO,
700 .idVendor = ZTE_VENDOR_ID,
701 .idProduct = 0x1173,
702 .bInterfaceClass = USB_CLASS_COMM,
703 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
704 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
705 .driver_info = (unsigned long)&wwan_info,
706}, {
707
708 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
709 | USB_DEVICE_ID_MATCH_PRODUCT
710 | USB_DEVICE_ID_MATCH_INT_INFO,
711 .idVendor = ZTE_VENDOR_ID,
712 .idProduct = 0x1177,
713 .bInterfaceClass = USB_CLASS_COMM,
714 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
715 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
716 .driver_info = (unsigned long)&wwan_info,
717}, {
718
719 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
720 | USB_DEVICE_ID_MATCH_PRODUCT
721 | USB_DEVICE_ID_MATCH_INT_INFO,
722 .idVendor = ZTE_VENDOR_ID,
723 .idProduct = 0x1181,
724 .bInterfaceClass = USB_CLASS_COMM,
725 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
726 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
727 .driver_info = (unsigned long)&wwan_info,
728}, {
729 USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
730 USB_CDC_PROTO_NONE),
731 .driver_info = (unsigned long) &cdc_info,
732}, {
733 USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM,
734 USB_CDC_PROTO_NONE),
735 .driver_info = (unsigned long)&wwan_info,
736
737}, {
738
739 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
740 | USB_DEVICE_ID_MATCH_INT_INFO,
741 .idVendor = HUAWEI_VENDOR_ID,
742 .bInterfaceClass = USB_CLASS_COMM,
743 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
744 .bInterfaceProtocol = 255,
745 .driver_info = (unsigned long)&wwan_info,
746},
747 { },
748};
749MODULE_DEVICE_TABLE(usb, products);
750
751static struct usb_driver cdc_driver = {
752 .name = "cdc_ether",
753 .id_table = products,
754 .probe = usbnet_probe,
755 .disconnect = usbnet_disconnect,
756 .suspend = usbnet_suspend,
757 .resume = usbnet_resume,
758 .reset_resume = usbnet_resume,
759 .supports_autosuspend = 1,
760 .disable_hub_initiated_lpm = 1,
761};
762
763module_usb_driver(cdc_driver);
764
765MODULE_AUTHOR("David Brownell");
766MODULE_DESCRIPTION("USB CDC Ethernet devices");
767MODULE_LICENSE("GPL");
768