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 d = &info->data->cur_altsetting->desc;
220 if (d->bInterfaceClass != USB_CLASS_CDC_DATA) {
221 dev_dbg(&intf->dev, "slave class %u\n",
222 d->bInterfaceClass);
223 goto bad_desc;
224 }
225 break;
226 case USB_CDC_ETHERNET_TYPE:
227 if (info->ether) {
228 dev_dbg(&intf->dev, "extra CDC ether\n");
229 goto bad_desc;
230 }
231 info->ether = (void *) buf;
232 if (info->ether->bLength != sizeof *info->ether) {
233 dev_dbg(&intf->dev, "CDC ether len %u\n",
234 info->ether->bLength);
235 goto bad_desc;
236 }
237 dev->hard_mtu = le16_to_cpu(
238 info->ether->wMaxSegmentSize);
239
240
241
242 break;
243 case USB_CDC_MDLM_TYPE:
244 if (desc) {
245 dev_dbg(&intf->dev, "extra MDLM descriptor\n");
246 goto bad_desc;
247 }
248
249 desc = (void *)buf;
250
251 if (desc->bLength != sizeof(*desc))
252 goto bad_desc;
253
254 if (memcmp(&desc->bGUID, mbm_guid, 16))
255 goto bad_desc;
256 break;
257 case USB_CDC_MDLM_DETAIL_TYPE:
258 if (detail) {
259 dev_dbg(&intf->dev, "extra MDLM detail descriptor\n");
260 goto bad_desc;
261 }
262
263 detail = (void *)buf;
264
265 if (detail->bGuidDescriptorType == 0) {
266 if (detail->bLength < (sizeof(*detail) + 1))
267 goto bad_desc;
268 } else
269 goto bad_desc;
270 break;
271 }
272next_desc:
273 len -= buf [0];
274 buf += buf [0];
275 }
276
277
278
279
280
281
282
283
284
285 if (rndis && (!info->u || android_rndis_quirk)) {
286 info->control = usb_ifnum_to_if(dev->udev, 0);
287 info->data = usb_ifnum_to_if(dev->udev, 1);
288 if (!info->control || !info->data || info->control != intf) {
289 dev_dbg(&intf->dev,
290 "rndis: master #0/%p slave #1/%p\n",
291 info->control,
292 info->data);
293 goto bad_desc;
294 }
295
296 } else if (!info->header || !info->u || (!rndis && !info->ether)) {
297 dev_dbg(&intf->dev, "missing cdc %s%s%sdescriptor\n",
298 info->header ? "" : "header ",
299 info->u ? "" : "union ",
300 info->ether ? "" : "ether ");
301 goto bad_desc;
302 }
303
304
305
306
307 status = usb_driver_claim_interface(driver, info->data, dev);
308 if (status < 0)
309 return status;
310 status = usbnet_get_endpoints(dev, info->data);
311 if (status < 0) {
312
313 usb_set_intfdata(info->data, NULL);
314 usb_driver_release_interface(driver, info->data);
315 return status;
316 }
317
318
319 dev->status = NULL;
320 if (info->control->cur_altsetting->desc.bNumEndpoints == 1) {
321 struct usb_endpoint_descriptor *desc;
322
323 dev->status = &info->control->cur_altsetting->endpoint [0];
324 desc = &dev->status->desc;
325 if (!usb_endpoint_is_int_in(desc) ||
326 (le16_to_cpu(desc->wMaxPacketSize)
327 < sizeof(struct usb_cdc_notification)) ||
328 !desc->bInterval) {
329 dev_dbg(&intf->dev, "bad notification endpoint\n");
330 dev->status = NULL;
331 }
332 }
333 if (rndis && !dev->status) {
334 dev_dbg(&intf->dev, "missing RNDIS status endpoint\n");
335 usb_set_intfdata(info->data, NULL);
336 usb_driver_release_interface(driver, info->data);
337 return -ENODEV;
338 }
339 return 0;
340
341bad_desc:
342 dev_info(&dev->udev->dev, "bad CDC descriptors\n");
343 return -ENODEV;
344}
345EXPORT_SYMBOL_GPL(usbnet_generic_cdc_bind);
346
347void usbnet_cdc_unbind(struct usbnet *dev, struct usb_interface *intf)
348{
349 struct cdc_state *info = (void *) &dev->data;
350 struct usb_driver *driver = driver_of(intf);
351
352
353 if (intf == info->control && info->data) {
354
355 usb_set_intfdata(info->data, NULL);
356 usb_driver_release_interface(driver, info->data);
357 info->data = NULL;
358 }
359
360
361 else if (intf == info->data && info->control) {
362
363 usb_set_intfdata(info->control, NULL);
364 usb_driver_release_interface(driver, info->control);
365 info->control = NULL;
366 }
367}
368EXPORT_SYMBOL_GPL(usbnet_cdc_unbind);
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383static void dumpspeed(struct usbnet *dev, __le32 *speeds)
384{
385 netif_info(dev, timer, dev->net,
386 "link speeds: %u kbps up, %u kbps down\n",
387 __le32_to_cpu(speeds[0]) / 1000,
388 __le32_to_cpu(speeds[1]) / 1000);
389}
390
391void usbnet_cdc_status(struct usbnet *dev, struct urb *urb)
392{
393 struct usb_cdc_notification *event;
394
395 if (urb->actual_length < sizeof *event)
396 return;
397
398
399 if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) {
400 dumpspeed(dev, (__le32 *) urb->transfer_buffer);
401 return;
402 }
403
404 event = urb->transfer_buffer;
405 switch (event->bNotificationType) {
406 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
407 netif_dbg(dev, timer, dev->net, "CDC: carrier %s\n",
408 event->wValue ? "on" : "off");
409 usbnet_link_change(dev, !!event->wValue, 0);
410 break;
411 case USB_CDC_NOTIFY_SPEED_CHANGE:
412 netif_dbg(dev, timer, dev->net, "CDC: speed change (len %d)\n",
413 urb->actual_length);
414 if (urb->actual_length != (sizeof *event + 8))
415 set_bit(EVENT_STS_SPLIT, &dev->flags);
416 else
417 dumpspeed(dev, (__le32 *) &event[1]);
418 break;
419
420
421
422 default:
423 netdev_err(dev->net, "CDC: unexpected notification %02x!\n",
424 event->bNotificationType);
425 break;
426 }
427}
428EXPORT_SYMBOL_GPL(usbnet_cdc_status);
429
430int usbnet_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
431{
432 int status;
433 struct cdc_state *info = (void *) &dev->data;
434
435 BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data)
436 < sizeof(struct cdc_state)));
437
438 status = usbnet_generic_cdc_bind(dev, intf);
439 if (status < 0)
440 return status;
441
442 status = usbnet_get_ethernet_addr(dev, info->ether->iMACAddress);
443 if (status < 0) {
444 usb_set_intfdata(info->data, NULL);
445 usb_driver_release_interface(driver_of(intf), info->data);
446 return status;
447 }
448
449
450
451
452
453 return 0;
454}
455EXPORT_SYMBOL_GPL(usbnet_cdc_bind);
456
457static const struct driver_info cdc_info = {
458 .description = "CDC Ethernet Device",
459 .flags = FLAG_ETHER | FLAG_POINTTOPOINT,
460
461 .bind = usbnet_cdc_bind,
462 .unbind = usbnet_cdc_unbind,
463 .status = usbnet_cdc_status,
464 .manage_power = usbnet_manage_power,
465};
466
467static const struct driver_info wwan_info = {
468 .description = "Mobile Broadband Network Device",
469 .flags = FLAG_WWAN,
470 .bind = usbnet_cdc_bind,
471 .unbind = usbnet_cdc_unbind,
472 .status = usbnet_cdc_status,
473 .manage_power = usbnet_manage_power,
474};
475
476
477
478#define HUAWEI_VENDOR_ID 0x12D1
479#define NOVATEL_VENDOR_ID 0x1410
480#define ZTE_VENDOR_ID 0x19D2
481#define DELL_VENDOR_ID 0x413C
482#define REALTEK_VENDOR_ID 0x0bda
483
484static const struct usb_device_id products [] = {
485
486
487
488
489
490
491
492
493
494#define ZAURUS_MASTER_INTERFACE \
495 .bInterfaceClass = USB_CLASS_COMM, \
496 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, \
497 .bInterfaceProtocol = USB_CDC_PROTO_NONE
498
499
500
501
502
503{
504 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
505 | USB_DEVICE_ID_MATCH_DEVICE,
506 .idVendor = 0x04DD,
507 .idProduct = 0x8004,
508 ZAURUS_MASTER_INTERFACE,
509 .driver_info = 0,
510},
511
512
513
514
515
516
517{
518 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
519 | USB_DEVICE_ID_MATCH_DEVICE,
520 .idVendor = 0x04DD,
521 .idProduct = 0x8005,
522 ZAURUS_MASTER_INTERFACE,
523 .driver_info = 0,
524}, {
525 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
526 | USB_DEVICE_ID_MATCH_DEVICE,
527 .idVendor = 0x04DD,
528 .idProduct = 0x8006,
529 ZAURUS_MASTER_INTERFACE,
530 .driver_info = 0,
531}, {
532 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
533 | USB_DEVICE_ID_MATCH_DEVICE,
534 .idVendor = 0x04DD,
535 .idProduct = 0x8007,
536 ZAURUS_MASTER_INTERFACE,
537 .driver_info = 0,
538}, {
539 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
540 | USB_DEVICE_ID_MATCH_DEVICE,
541 .idVendor = 0x04DD,
542 .idProduct = 0x9031,
543 ZAURUS_MASTER_INTERFACE,
544 .driver_info = 0,
545}, {
546 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
547 | USB_DEVICE_ID_MATCH_DEVICE,
548 .idVendor = 0x04DD,
549 .idProduct = 0x9032,
550 ZAURUS_MASTER_INTERFACE,
551 .driver_info = 0,
552}, {
553 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
554 | USB_DEVICE_ID_MATCH_DEVICE,
555 .idVendor = 0x04DD,
556
557 .idProduct = 0x9050,
558 ZAURUS_MASTER_INTERFACE,
559 .driver_info = 0,
560},
561
562
563
564
565{
566 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
567 | USB_DEVICE_ID_MATCH_DEVICE,
568 .idVendor = 0x07B4,
569 .idProduct = 0x0F02,
570 ZAURUS_MASTER_INTERFACE,
571 .driver_info = 0,
572},
573
574
575{
576 USB_DEVICE_AND_INTERFACE_INFO(0x1004, 0x61aa, USB_CLASS_COMM,
577 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
578 .driver_info = 0,
579},
580
581
582{
583 USB_DEVICE_AND_INTERFACE_INFO(0x046d, 0xc11f, USB_CLASS_COMM,
584 USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
585 .driver_info = 0,
586},
587
588
589{
590 USB_DEVICE_AND_INTERFACE_INFO(NOVATEL_VENDOR_ID, 0xB001, USB_CLASS_COMM,
591 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
592 .driver_info = 0,
593},
594
595
596{
597 USB_DEVICE_AND_INTERFACE_INFO(NOVATEL_VENDOR_ID, 0x9010, USB_CLASS_COMM,
598 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
599 .driver_info = 0,
600},
601
602
603{
604 USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x8195, USB_CLASS_COMM,
605 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
606 .driver_info = 0,
607},
608
609
610{
611 USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x8196, USB_CLASS_COMM,
612 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
613 .driver_info = 0,
614},
615
616
617{
618 USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x819b, USB_CLASS_COMM,
619 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
620 .driver_info = 0,
621},
622
623
624{
625 USB_DEVICE_AND_INTERFACE_INFO(0x16d5, 0x650a, USB_CLASS_COMM,
626 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
627 .driver_info = 0,
628},
629
630
631{
632 USB_DEVICE_INTERFACE_NUMBER(HUAWEI_VENDOR_ID, 0x14ac, 1),
633 .driver_info = 0,
634},
635
636
637#if defined(CONFIG_USB_RTL8152) || defined(CONFIG_USB_RTL8152_MODULE)
638{
639 USB_DEVICE_AND_INTERFACE_INFO(REALTEK_VENDOR_ID, 0x8152, USB_CLASS_COMM,
640 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
641 .driver_info = 0,
642},
643#endif
644
645
646
647
648
649
650
651
652
653
654
655
656{
657
658 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
659 | USB_DEVICE_ID_MATCH_PRODUCT
660 | USB_DEVICE_ID_MATCH_INT_INFO,
661 .idVendor = ZTE_VENDOR_ID,
662 .idProduct = 0x1003,
663 .bInterfaceClass = USB_CLASS_COMM,
664 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
665 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
666 .driver_info = (unsigned long)&wwan_info,
667}, {
668
669 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
670 | USB_DEVICE_ID_MATCH_PRODUCT
671 | USB_DEVICE_ID_MATCH_INT_INFO,
672 .idVendor = ZTE_VENDOR_ID,
673 .idProduct = 0x1015,
674 .bInterfaceClass = USB_CLASS_COMM,
675 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
676 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
677 .driver_info = (unsigned long)&wwan_info,
678}, {
679
680 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
681 | USB_DEVICE_ID_MATCH_PRODUCT
682 | USB_DEVICE_ID_MATCH_INT_INFO,
683 .idVendor = ZTE_VENDOR_ID,
684 .idProduct = 0x1173,
685 .bInterfaceClass = USB_CLASS_COMM,
686 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
687 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
688 .driver_info = (unsigned long)&wwan_info,
689}, {
690
691 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
692 | USB_DEVICE_ID_MATCH_PRODUCT
693 | USB_DEVICE_ID_MATCH_INT_INFO,
694 .idVendor = ZTE_VENDOR_ID,
695 .idProduct = 0x1177,
696 .bInterfaceClass = USB_CLASS_COMM,
697 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
698 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
699 .driver_info = (unsigned long)&wwan_info,
700}, {
701
702 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
703 | USB_DEVICE_ID_MATCH_PRODUCT
704 | USB_DEVICE_ID_MATCH_INT_INFO,
705 .idVendor = ZTE_VENDOR_ID,
706 .idProduct = 0x1181,
707 .bInterfaceClass = USB_CLASS_COMM,
708 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
709 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
710 .driver_info = (unsigned long)&wwan_info,
711}, {
712 USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
713 USB_CDC_PROTO_NONE),
714 .driver_info = (unsigned long) &cdc_info,
715}, {
716 USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM,
717 USB_CDC_PROTO_NONE),
718 .driver_info = (unsigned long)&wwan_info,
719
720}, {
721
722 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
723 | USB_DEVICE_ID_MATCH_INT_INFO,
724 .idVendor = HUAWEI_VENDOR_ID,
725 .bInterfaceClass = USB_CLASS_COMM,
726 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
727 .bInterfaceProtocol = 255,
728 .driver_info = (unsigned long)&wwan_info,
729},
730 { },
731};
732MODULE_DEVICE_TABLE(usb, products);
733
734static struct usb_driver cdc_driver = {
735 .name = "cdc_ether",
736 .id_table = products,
737 .probe = usbnet_probe,
738 .disconnect = usbnet_disconnect,
739 .suspend = usbnet_suspend,
740 .resume = usbnet_resume,
741 .reset_resume = usbnet_resume,
742 .supports_autosuspend = 1,
743 .disable_hub_initiated_lpm = 1,
744};
745
746module_usb_driver(cdc_driver);
747
748MODULE_AUTHOR("David Brownell");
749MODULE_DESCRIPTION("USB CDC Ethernet devices");
750MODULE_LICENSE("GPL");
751