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 if (event->wValue)
410 netif_carrier_on(dev->net);
411 else
412 netif_carrier_off(dev->net);
413 break;
414 case USB_CDC_NOTIFY_SPEED_CHANGE:
415 netif_dbg(dev, timer, dev->net, "CDC: speed change (len %d)\n",
416 urb->actual_length);
417 if (urb->actual_length != (sizeof *event + 8))
418 set_bit(EVENT_STS_SPLIT, &dev->flags);
419 else
420 dumpspeed(dev, (__le32 *) &event[1]);
421 break;
422
423
424
425 default:
426 netdev_err(dev->net, "CDC: unexpected notification %02x!\n",
427 event->bNotificationType);
428 break;
429 }
430}
431EXPORT_SYMBOL_GPL(usbnet_cdc_status);
432
433int usbnet_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
434{
435 int status;
436 struct cdc_state *info = (void *) &dev->data;
437
438 BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data)
439 < sizeof(struct cdc_state)));
440
441 status = usbnet_generic_cdc_bind(dev, intf);
442 if (status < 0)
443 return status;
444
445 status = usbnet_get_ethernet_addr(dev, info->ether->iMACAddress);
446 if (status < 0) {
447 usb_set_intfdata(info->data, NULL);
448 usb_driver_release_interface(driver_of(intf), info->data);
449 return status;
450 }
451
452
453
454
455
456 return 0;
457}
458EXPORT_SYMBOL_GPL(usbnet_cdc_bind);
459
460static const struct driver_info cdc_info = {
461 .description = "CDC Ethernet Device",
462 .flags = FLAG_ETHER | FLAG_POINTTOPOINT,
463
464 .bind = usbnet_cdc_bind,
465 .unbind = usbnet_cdc_unbind,
466 .status = usbnet_cdc_status,
467 .manage_power = usbnet_manage_power,
468};
469
470static const struct driver_info wwan_info = {
471 .description = "Mobile Broadband Network Device",
472 .flags = FLAG_WWAN,
473 .bind = usbnet_cdc_bind,
474 .unbind = usbnet_cdc_unbind,
475 .status = usbnet_cdc_status,
476 .manage_power = usbnet_manage_power,
477};
478
479
480
481#define HUAWEI_VENDOR_ID 0x12D1
482#define NOVATEL_VENDOR_ID 0x1410
483#define ZTE_VENDOR_ID 0x19D2
484#define DELL_VENDOR_ID 0x413C
485
486static const struct usb_device_id products [] = {
487
488
489
490
491
492
493
494
495
496#define ZAURUS_MASTER_INTERFACE \
497 .bInterfaceClass = USB_CLASS_COMM, \
498 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, \
499 .bInterfaceProtocol = USB_CDC_PROTO_NONE
500
501
502
503
504
505{
506 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
507 | USB_DEVICE_ID_MATCH_DEVICE,
508 .idVendor = 0x04DD,
509 .idProduct = 0x8004,
510 ZAURUS_MASTER_INTERFACE,
511 .driver_info = 0,
512},
513
514
515
516
517
518
519{
520 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
521 | USB_DEVICE_ID_MATCH_DEVICE,
522 .idVendor = 0x04DD,
523 .idProduct = 0x8005,
524 ZAURUS_MASTER_INTERFACE,
525 .driver_info = 0,
526}, {
527 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
528 | USB_DEVICE_ID_MATCH_DEVICE,
529 .idVendor = 0x04DD,
530 .idProduct = 0x8006,
531 ZAURUS_MASTER_INTERFACE,
532 .driver_info = 0,
533}, {
534 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
535 | USB_DEVICE_ID_MATCH_DEVICE,
536 .idVendor = 0x04DD,
537 .idProduct = 0x8007,
538 ZAURUS_MASTER_INTERFACE,
539 .driver_info = 0,
540}, {
541 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
542 | USB_DEVICE_ID_MATCH_DEVICE,
543 .idVendor = 0x04DD,
544 .idProduct = 0x9031,
545 ZAURUS_MASTER_INTERFACE,
546 .driver_info = 0,
547}, {
548 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
549 | USB_DEVICE_ID_MATCH_DEVICE,
550 .idVendor = 0x04DD,
551 .idProduct = 0x9032,
552 ZAURUS_MASTER_INTERFACE,
553 .driver_info = 0,
554}, {
555 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
556 | USB_DEVICE_ID_MATCH_DEVICE,
557 .idVendor = 0x04DD,
558
559 .idProduct = 0x9050,
560 ZAURUS_MASTER_INTERFACE,
561 .driver_info = 0,
562},
563
564
565
566
567{
568 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
569 | USB_DEVICE_ID_MATCH_DEVICE,
570 .idVendor = 0x07B4,
571 .idProduct = 0x0F02,
572 ZAURUS_MASTER_INTERFACE,
573 .driver_info = 0,
574},
575
576
577{
578 USB_DEVICE_AND_INTERFACE_INFO(0x1004, 0x61aa, USB_CLASS_COMM,
579 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
580 .driver_info = 0,
581},
582
583
584{
585 USB_DEVICE_AND_INTERFACE_INFO(0x046d, 0xc11f, USB_CLASS_COMM,
586 USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
587 .driver_info = 0,
588},
589
590
591{
592 USB_DEVICE_AND_INTERFACE_INFO(NOVATEL_VENDOR_ID, 0xB001, USB_CLASS_COMM,
593 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
594 .driver_info = 0,
595},
596
597
598{
599 USB_DEVICE_AND_INTERFACE_INFO(NOVATEL_VENDOR_ID, 0x9010, USB_CLASS_COMM,
600 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
601 .driver_info = 0,
602},
603
604
605{
606 USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x8195, USB_CLASS_COMM,
607 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
608 .driver_info = 0,
609},
610
611
612{
613 USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x8196, USB_CLASS_COMM,
614 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
615 .driver_info = 0,
616},
617
618
619{
620 USB_DEVICE_AND_INTERFACE_INFO(0x16d5, 0x650a, USB_CLASS_COMM,
621 USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
622 .driver_info = 0,
623},
624
625
626
627
628
629
630
631
632
633
634
635
636{
637
638 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
639 | USB_DEVICE_ID_MATCH_PRODUCT
640 | USB_DEVICE_ID_MATCH_INT_INFO,
641 .idVendor = ZTE_VENDOR_ID,
642 .idProduct = 0x1003,
643 .bInterfaceClass = USB_CLASS_COMM,
644 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
645 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
646 .driver_info = (unsigned long)&wwan_info,
647}, {
648
649 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
650 | USB_DEVICE_ID_MATCH_PRODUCT
651 | USB_DEVICE_ID_MATCH_INT_INFO,
652 .idVendor = ZTE_VENDOR_ID,
653 .idProduct = 0x1015,
654 .bInterfaceClass = USB_CLASS_COMM,
655 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
656 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
657 .driver_info = (unsigned long)&wwan_info,
658}, {
659
660 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
661 | USB_DEVICE_ID_MATCH_PRODUCT
662 | USB_DEVICE_ID_MATCH_INT_INFO,
663 .idVendor = ZTE_VENDOR_ID,
664 .idProduct = 0x1173,
665 .bInterfaceClass = USB_CLASS_COMM,
666 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
667 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
668 .driver_info = (unsigned long)&wwan_info,
669}, {
670
671 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
672 | USB_DEVICE_ID_MATCH_PRODUCT
673 | USB_DEVICE_ID_MATCH_INT_INFO,
674 .idVendor = ZTE_VENDOR_ID,
675 .idProduct = 0x1177,
676 .bInterfaceClass = USB_CLASS_COMM,
677 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
678 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
679 .driver_info = (unsigned long)&wwan_info,
680}, {
681
682 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
683 | USB_DEVICE_ID_MATCH_PRODUCT
684 | USB_DEVICE_ID_MATCH_INT_INFO,
685 .idVendor = ZTE_VENDOR_ID,
686 .idProduct = 0x1181,
687 .bInterfaceClass = USB_CLASS_COMM,
688 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
689 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
690 .driver_info = (unsigned long)&wwan_info,
691}, {
692 USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
693 USB_CDC_PROTO_NONE),
694 .driver_info = (unsigned long) &cdc_info,
695}, {
696 USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM,
697 USB_CDC_PROTO_NONE),
698 .driver_info = (unsigned long)&wwan_info,
699
700}, {
701
702 .match_flags = USB_DEVICE_ID_MATCH_VENDOR
703 | USB_DEVICE_ID_MATCH_INT_INFO,
704 .idVendor = HUAWEI_VENDOR_ID,
705 .bInterfaceClass = USB_CLASS_COMM,
706 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
707 .bInterfaceProtocol = 255,
708 .driver_info = (unsigned long)&wwan_info,
709},
710 { },
711};
712MODULE_DEVICE_TABLE(usb, products);
713
714static struct usb_driver cdc_driver = {
715 .name = "cdc_ether",
716 .id_table = products,
717 .probe = usbnet_probe,
718 .disconnect = usbnet_disconnect,
719 .suspend = usbnet_suspend,
720 .resume = usbnet_resume,
721 .reset_resume = usbnet_resume,
722 .supports_autosuspend = 1,
723 .disable_hub_initiated_lpm = 1,
724};
725
726module_usb_driver(cdc_driver);
727
728MODULE_AUTHOR("David Brownell");
729MODULE_DESCRIPTION("USB CDC Ethernet devices");
730MODULE_LICENSE("GPL");
731