Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * CDC Ethernet based networking peripherals
4 : : * Copyright (C) 2003-2005 by David Brownell
5 : : * Copyright (C) 2006 by Ole Andre Vadla Ravnas (ActiveSync)
6 : : */
7 : :
8 : : // #define DEBUG // error path messages, extra info
9 : : // #define VERBOSE // more; success messages
10 : :
11 : : #include <linux/module.h>
12 : : #include <linux/netdevice.h>
13 : : #include <linux/etherdevice.h>
14 : : #include <linux/ethtool.h>
15 : : #include <linux/workqueue.h>
16 : : #include <linux/mii.h>
17 : : #include <linux/usb.h>
18 : : #include <linux/usb/cdc.h>
19 : : #include <linux/usb/usbnet.h>
20 : :
21 : :
22 : : #if IS_ENABLED(CONFIG_USB_NET_RNDIS_HOST)
23 : :
24 : : static int is_rndis(struct usb_interface_descriptor *desc)
25 : : {
26 : 1 : return (desc->bInterfaceClass == USB_CLASS_COMM &&
27 : 1 : desc->bInterfaceSubClass == 2 &&
28 : 0 : desc->bInterfaceProtocol == 0xff);
29 : : }
30 : :
31 : : static int is_activesync(struct usb_interface_descriptor *desc)
32 : : {
33 : 0 : return (desc->bInterfaceClass == USB_CLASS_MISC &&
34 : 1 : desc->bInterfaceSubClass == 1 &&
35 : 0 : desc->bInterfaceProtocol == 1);
36 : : }
37 : :
38 : : static int is_wireless_rndis(struct usb_interface_descriptor *desc)
39 : : {
40 : 0 : return (desc->bInterfaceClass == USB_CLASS_WIRELESS_CONTROLLER &&
41 : 1 : desc->bInterfaceSubClass == 1 &&
42 : 0 : desc->bInterfaceProtocol == 3);
43 : : }
44 : :
45 : : static int is_novatel_rndis(struct usb_interface_descriptor *desc)
46 : : {
47 : 0 : return (desc->bInterfaceClass == USB_CLASS_MISC &&
48 : 1 : desc->bInterfaceSubClass == 4 &&
49 : 0 : desc->bInterfaceProtocol == 1);
50 : : }
51 : :
52 : : #else
53 : :
54 : : #define is_rndis(desc) 0
55 : : #define is_activesync(desc) 0
56 : : #define is_wireless_rndis(desc) 0
57 : : #define is_novatel_rndis(desc) 0
58 : :
59 : : #endif
60 : :
61 : : static const u8 mbm_guid[16] = {
62 : : 0xa3, 0x17, 0xa8, 0x8b, 0x04, 0x5e, 0x4f, 0x01,
63 : : 0xa6, 0x07, 0xc0, 0xff, 0xcb, 0x7e, 0x39, 0x2a,
64 : : };
65 : :
66 : 1 : static void usbnet_cdc_update_filter(struct usbnet *dev)
67 : : {
68 : : struct cdc_state *info = (void *) &dev->data;
69 : 1 : struct usb_interface *intf = info->control;
70 : 1 : struct net_device *net = dev->net;
71 : :
72 : : u16 cdc_filter = USB_CDC_PACKET_TYPE_DIRECTED
73 : : | USB_CDC_PACKET_TYPE_BROADCAST;
74 : :
75 : : /* filtering on the device is an optional feature and not worth
76 : : * the hassle so we just roughly care about snooping and if any
77 : : * multicast is requested, we take every multicast
78 : : */
79 : 1 : if (net->flags & IFF_PROMISC)
80 : : cdc_filter |= USB_CDC_PACKET_TYPE_PROMISCUOUS;
81 : 1 : if (!netdev_mc_empty(net) || (net->flags & IFF_ALLMULTI))
82 : 1 : cdc_filter |= USB_CDC_PACKET_TYPE_ALL_MULTICAST;
83 : :
84 : 1 : usb_control_msg(dev->udev,
85 : 1 : usb_sndctrlpipe(dev->udev, 0),
86 : : USB_CDC_SET_ETHERNET_PACKET_FILTER,
87 : : USB_TYPE_CLASS | USB_RECIP_INTERFACE,
88 : : cdc_filter,
89 : 1 : intf->cur_altsetting->desc.bInterfaceNumber,
90 : : NULL,
91 : : 0,
92 : : USB_CTRL_SET_TIMEOUT
93 : : );
94 : 1 : }
95 : :
96 : : /* probes control interface, claims data interface, collects the bulk
97 : : * endpoints, activates data interface (if needed), maybe sets MTU.
98 : : * all pure cdc, except for certain firmware workarounds, and knowing
99 : : * that rndis uses one different rule.
100 : : */
101 : 1 : int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
102 : : {
103 : 1 : u8 *buf = intf->cur_altsetting->extra;
104 : 1 : int len = intf->cur_altsetting->extralen;
105 : : struct usb_interface_descriptor *d;
106 : 1 : struct cdc_state *info = (void *) &dev->data;
107 : : int status;
108 : : int rndis;
109 : : bool android_rndis_quirk = false;
110 : : struct usb_driver *driver = driver_of(intf);
111 : : struct usb_cdc_parsed_header header;
112 : :
113 : : if (sizeof(dev->data) < sizeof(*info))
114 : : return -EDOM;
115 : :
116 : : /* expect strict spec conformance for the descriptors, but
117 : : * cope with firmware which stores them in the wrong place
118 : : */
119 : 1 : if (len == 0 && dev->udev->actconfig->extralen) {
120 : : /* Motorola SB4100 (and others: Brad Hards says it's
121 : : * from a Broadcom design) put CDC descriptors here
122 : : */
123 : 0 : buf = dev->udev->actconfig->extra;
124 : : len = dev->udev->actconfig->extralen;
125 : : dev_dbg(&intf->dev, "CDC descriptors on config\n");
126 : : }
127 : :
128 : : /* Maybe CDC descriptors are after the endpoint? This bug has
129 : : * been seen on some 2Wire Inc RNDIS-ish products.
130 : : */
131 : 1 : if (len == 0) {
132 : : struct usb_host_endpoint *hep;
133 : :
134 : 0 : hep = intf->cur_altsetting->endpoint;
135 : 0 : if (hep) {
136 : 0 : buf = hep->extra;
137 : 0 : len = hep->extralen;
138 : : }
139 : : if (len)
140 : : dev_dbg(&intf->dev,
141 : : "CDC descriptors on endpoint\n");
142 : : }
143 : :
144 : : /* this assumes that if there's a non-RNDIS vendor variant
145 : : * of cdc-acm, it'll fail RNDIS requests cleanly.
146 : : */
147 : 1 : rndis = (is_rndis(&intf->cur_altsetting->desc) ||
148 : 1 : is_activesync(&intf->cur_altsetting->desc) ||
149 : 1 : is_wireless_rndis(&intf->cur_altsetting->desc) ||
150 : : is_novatel_rndis(&intf->cur_altsetting->desc));
151 : :
152 : 1 : memset(info, 0, sizeof(*info));
153 : 1 : info->control = intf;
154 : :
155 : 1 : cdc_parse_cdc_header(&header, intf, buf, len);
156 : :
157 : 1 : info->u = header.usb_cdc_union_desc;
158 : 1 : info->header = header.usb_cdc_header_desc;
159 : 1 : info->ether = header.usb_cdc_ether_desc;
160 : 1 : if (!info->u) {
161 : 0 : if (rndis)
162 : : goto skip;
163 : : else /* in that case a quirk is mandatory */
164 : : goto bad_desc;
165 : : }
166 : : /* we need a master/control interface (what we're
167 : : * probed with) and a slave/data interface; union
168 : : * descriptors sort this all out.
169 : : */
170 : 1 : info->control = usb_ifnum_to_if(dev->udev, info->u->bMasterInterface0);
171 : 1 : info->data = usb_ifnum_to_if(dev->udev, info->u->bSlaveInterface0);
172 : 1 : if (!info->control || !info->data) {
173 : : dev_dbg(&intf->dev,
174 : : "master #%u/%p slave #%u/%p\n",
175 : : info->u->bMasterInterface0,
176 : : info->control,
177 : : info->u->bSlaveInterface0,
178 : : info->data);
179 : : /* fall back to hard-wiring for RNDIS */
180 : 0 : if (rndis) {
181 : : android_rndis_quirk = true;
182 : : goto skip;
183 : : }
184 : : goto bad_desc;
185 : : }
186 : 1 : if (info->control != intf) {
187 : : dev_dbg(&intf->dev, "bogus CDC Union\n");
188 : : /* Ambit USB Cable Modem (and maybe others)
189 : : * interchanges master and slave interface.
190 : : */
191 : 0 : if (info->data == intf) {
192 : 0 : info->data = info->control;
193 : 0 : info->control = intf;
194 : : } else
195 : : goto bad_desc;
196 : : }
197 : :
198 : : /* some devices merge these - skip class check */
199 : 1 : if (info->control == info->data)
200 : : goto skip;
201 : :
202 : : /* a data interface altsetting does the real i/o */
203 : 1 : d = &info->data->cur_altsetting->desc;
204 : 1 : if (d->bInterfaceClass != USB_CLASS_CDC_DATA) {
205 : : dev_dbg(&intf->dev, "slave class %u\n", d->bInterfaceClass);
206 : : goto bad_desc;
207 : : }
208 : : skip:
209 : : /* Communcation class functions with bmCapabilities are not
210 : : * RNDIS. But some Wireless class RNDIS functions use
211 : : * bmCapabilities for their own purpose. The failsafe is
212 : : * therefore applied only to Communication class RNDIS
213 : : * functions. The rndis test is redundant, but a cheap
214 : : * optimization.
215 : : */
216 : 1 : if (rndis && is_rndis(&intf->cur_altsetting->desc) &&
217 : 0 : header.usb_cdc_acm_descriptor &&
218 : 0 : header.usb_cdc_acm_descriptor->bmCapabilities) {
219 : : dev_dbg(&intf->dev,
220 : : "ACM capabilities %02x, not really RNDIS?\n",
221 : : header.usb_cdc_acm_descriptor->bmCapabilities);
222 : : goto bad_desc;
223 : : }
224 : :
225 : 1 : if (header.usb_cdc_ether_desc && info->ether->wMaxSegmentSize) {
226 : 1 : dev->hard_mtu = le16_to_cpu(info->ether->wMaxSegmentSize);
227 : : /* because of Zaurus, we may be ignoring the host
228 : : * side link address we were given.
229 : : */
230 : : }
231 : :
232 : 1 : if (header.usb_cdc_mdlm_desc &&
233 : 0 : memcmp(header.usb_cdc_mdlm_desc->bGUID, mbm_guid, 16)) {
234 : : dev_dbg(&intf->dev, "GUID doesn't match\n");
235 : : goto bad_desc;
236 : : }
237 : :
238 : 1 : if (header.usb_cdc_mdlm_detail_desc &&
239 : 0 : header.usb_cdc_mdlm_detail_desc->bLength <
240 : : (sizeof(struct usb_cdc_mdlm_detail_desc) + 1)) {
241 : : dev_dbg(&intf->dev, "Descriptor too short\n");
242 : : goto bad_desc;
243 : : }
244 : :
245 : :
246 : :
247 : : /* Microsoft ActiveSync based and some regular RNDIS devices lack the
248 : : * CDC descriptors, so we'll hard-wire the interfaces and not check
249 : : * for descriptors.
250 : : *
251 : : * Some Android RNDIS devices have a CDC Union descriptor pointing
252 : : * to non-existing interfaces. Ignore that and attempt the same
253 : : * hard-wired 0 and 1 interfaces.
254 : : */
255 : 1 : if (rndis && (!info->u || android_rndis_quirk)) {
256 : 0 : info->control = usb_ifnum_to_if(dev->udev, 0);
257 : 0 : info->data = usb_ifnum_to_if(dev->udev, 1);
258 : 0 : if (!info->control || !info->data || info->control != intf) {
259 : : dev_dbg(&intf->dev,
260 : : "rndis: master #0/%p slave #1/%p\n",
261 : : info->control,
262 : : info->data);
263 : : goto bad_desc;
264 : : }
265 : :
266 : 1 : } else if (!info->header || (!rndis && !info->ether)) {
267 : : dev_dbg(&intf->dev, "missing cdc %s%s%sdescriptor\n",
268 : : info->header ? "" : "header ",
269 : : info->u ? "" : "union ",
270 : : info->ether ? "" : "ether ");
271 : : goto bad_desc;
272 : : }
273 : :
274 : : /* claim data interface and set it up ... with side effects.
275 : : * network traffic can't flow until an altsetting is enabled.
276 : : */
277 : 1 : if (info->data != info->control) {
278 : 1 : status = usb_driver_claim_interface(driver, info->data, dev);
279 : 1 : if (status < 0)
280 : : return status;
281 : : }
282 : 1 : status = usbnet_get_endpoints(dev, info->data);
283 : 1 : if (status < 0) {
284 : : /* ensure immediate exit from usbnet_disconnect */
285 : 0 : usb_set_intfdata(info->data, NULL);
286 : 0 : if (info->data != info->control)
287 : 0 : usb_driver_release_interface(driver, info->data);
288 : 0 : return status;
289 : : }
290 : :
291 : : /* status endpoint: optional for CDC Ethernet, not RNDIS (or ACM) */
292 : 1 : if (info->data != info->control)
293 : 1 : dev->status = NULL;
294 : 1 : if (info->control->cur_altsetting->desc.bNumEndpoints == 1) {
295 : : struct usb_endpoint_descriptor *desc;
296 : :
297 : 1 : dev->status = &info->control->cur_altsetting->endpoint[0];
298 : : desc = &dev->status->desc;
299 : 1 : if (!usb_endpoint_is_int_in(desc) ||
300 : 1 : (le16_to_cpu(desc->wMaxPacketSize)
301 : 1 : < sizeof(struct usb_cdc_notification)) ||
302 : 1 : !desc->bInterval) {
303 : : dev_dbg(&intf->dev, "bad notification endpoint\n");
304 : 0 : dev->status = NULL;
305 : : }
306 : : }
307 : 1 : if (rndis && !dev->status) {
308 : : dev_dbg(&intf->dev, "missing RNDIS status endpoint\n");
309 : : usb_set_intfdata(info->data, NULL);
310 : 0 : usb_driver_release_interface(driver, info->data);
311 : 0 : return -ENODEV;
312 : : }
313 : :
314 : : return 0;
315 : :
316 : : bad_desc:
317 : 0 : dev_info(&dev->udev->dev, "bad CDC descriptors\n");
318 : 0 : return -ENODEV;
319 : : }
320 : : EXPORT_SYMBOL_GPL(usbnet_generic_cdc_bind);
321 : :
322 : :
323 : : /* like usbnet_generic_cdc_bind() but handles filter initialization
324 : : * correctly
325 : : */
326 : 1 : int usbnet_ether_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
327 : : {
328 : : int rv;
329 : :
330 : 1 : rv = usbnet_generic_cdc_bind(dev, intf);
331 : 1 : if (rv < 0)
332 : : goto bail_out;
333 : :
334 : : /* Some devices don't initialise properly. In particular
335 : : * the packet filter is not reset. There are devices that
336 : : * don't do reset all the way. So the packet filter should
337 : : * be set to a sane initial value.
338 : : */
339 : 1 : usbnet_cdc_update_filter(dev);
340 : :
341 : : bail_out:
342 : 1 : return rv;
343 : : }
344 : : EXPORT_SYMBOL_GPL(usbnet_ether_cdc_bind);
345 : :
346 : 0 : void usbnet_cdc_unbind(struct usbnet *dev, struct usb_interface *intf)
347 : : {
348 : : struct cdc_state *info = (void *) &dev->data;
349 : : struct usb_driver *driver = driver_of(intf);
350 : :
351 : : /* combined interface - nothing to do */
352 : 0 : if (info->data == info->control)
353 : 0 : return;
354 : :
355 : : /* disconnect master --> disconnect slave */
356 : 0 : if (intf == info->control && info->data) {
357 : : /* ensure immediate exit from usbnet_disconnect */
358 : : usb_set_intfdata(info->data, NULL);
359 : 0 : usb_driver_release_interface(driver, info->data);
360 : 0 : info->data = NULL;
361 : : }
362 : :
363 : : /* and vice versa (just in case) */
364 : 0 : else if (intf == info->data && info->control) {
365 : : /* ensure immediate exit from usbnet_disconnect */
366 : : usb_set_intfdata(info->control, NULL);
367 : 0 : usb_driver_release_interface(driver, info->control);
368 : 0 : info->control = NULL;
369 : : }
370 : : }
371 : : EXPORT_SYMBOL_GPL(usbnet_cdc_unbind);
372 : :
373 : : /* Communications Device Class, Ethernet Control model
374 : : *
375 : : * Takes two interfaces. The DATA interface is inactive till an altsetting
376 : : * is selected. Configuration data includes class descriptors. There's
377 : : * an optional status endpoint on the control interface.
378 : : *
379 : : * This should interop with whatever the 2.4 "CDCEther.c" driver
380 : : * (by Brad Hards) talked with, with more functionality.
381 : : */
382 : :
383 : 0 : static void dumpspeed(struct usbnet *dev, __le32 *speeds)
384 : : {
385 : 0 : 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 : 0 : }
390 : :
391 : 0 : void usbnet_cdc_status(struct usbnet *dev, struct urb *urb)
392 : : {
393 : : struct usb_cdc_notification *event;
394 : :
395 : 0 : if (urb->actual_length < sizeof(*event))
396 : : return;
397 : :
398 : : /* SPEED_CHANGE can get split into two 8-byte packets */
399 : 0 : if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) {
400 : 0 : dumpspeed(dev, (__le32 *) urb->transfer_buffer);
401 : 0 : return;
402 : : }
403 : :
404 : 0 : event = urb->transfer_buffer;
405 : 0 : 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 : 0 : usbnet_link_change(dev, !!event->wValue, 0);
410 : 0 : break;
411 : : case USB_CDC_NOTIFY_SPEED_CHANGE: /* tx/rx rates */
412 : : netif_dbg(dev, timer, dev->net, "CDC: speed change (len %d)\n",
413 : : urb->actual_length);
414 : 0 : if (urb->actual_length != (sizeof(*event) + 8))
415 : 0 : set_bit(EVENT_STS_SPLIT, &dev->flags);
416 : : else
417 : 0 : dumpspeed(dev, (__le32 *) &event[1]);
418 : : break;
419 : : /* USB_CDC_NOTIFY_RESPONSE_AVAILABLE can happen too (e.g. RNDIS),
420 : : * but there are no standard formats for the response data.
421 : : */
422 : : default:
423 : 0 : netdev_err(dev->net, "CDC: unexpected notification %02x!\n",
424 : : event->bNotificationType);
425 : 0 : break;
426 : : }
427 : : }
428 : : EXPORT_SYMBOL_GPL(usbnet_cdc_status);
429 : :
430 : 1 : int 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 : 1 : status = usbnet_ether_cdc_bind(dev, intf);
439 : 1 : if (status < 0)
440 : : return status;
441 : :
442 : 1 : status = usbnet_get_ethernet_addr(dev, info->ether->iMACAddress);
443 : 1 : if (status < 0) {
444 : 0 : usb_set_intfdata(info->data, NULL);
445 : 0 : usb_driver_release_interface(driver_of(intf), info->data);
446 : 0 : return status;
447 : : }
448 : :
449 : : return 0;
450 : : }
451 : : EXPORT_SYMBOL_GPL(usbnet_cdc_bind);
452 : :
453 : 0 : static int usbnet_cdc_zte_bind(struct usbnet *dev, struct usb_interface *intf)
454 : : {
455 : 0 : int status = usbnet_cdc_bind(dev, intf);
456 : :
457 : 0 : if (!status && (dev->net->dev_addr[0] & 0x02))
458 : 0 : eth_hw_addr_random(dev->net);
459 : :
460 : 0 : return status;
461 : : }
462 : :
463 : : /* Make sure packets have correct destination MAC address
464 : : *
465 : : * A firmware bug observed on some devices (ZTE MF823/831/910) is that the
466 : : * device sends packets with a static, bogus, random MAC address (event if
467 : : * device MAC address has been updated). Always set MAC address to that of the
468 : : * device.
469 : : */
470 : 0 : static int usbnet_cdc_zte_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
471 : : {
472 : 0 : if (skb->len < ETH_HLEN || !(skb->data[0] & 0x02))
473 : : return 1;
474 : :
475 : : skb_reset_mac_header(skb);
476 : 0 : ether_addr_copy(eth_hdr(skb)->h_dest, dev->net->dev_addr);
477 : :
478 : 0 : return 1;
479 : : }
480 : :
481 : : /* Ensure correct link state
482 : : *
483 : : * Some devices (ZTE MF823/831/910) export two carrier on notifications when
484 : : * connected. This causes the link state to be incorrect. Work around this by
485 : : * always setting the state to off, then on.
486 : : */
487 : 0 : static void usbnet_cdc_zte_status(struct usbnet *dev, struct urb *urb)
488 : : {
489 : : struct usb_cdc_notification *event;
490 : :
491 : 0 : if (urb->actual_length < sizeof(*event))
492 : : return;
493 : :
494 : 0 : event = urb->transfer_buffer;
495 : :
496 : 0 : if (event->bNotificationType != USB_CDC_NOTIFY_NETWORK_CONNECTION) {
497 : 0 : usbnet_cdc_status(dev, urb);
498 : 0 : return;
499 : : }
500 : :
501 : : netif_dbg(dev, timer, dev->net, "CDC: carrier %s\n",
502 : : event->wValue ? "on" : "off");
503 : :
504 : 0 : if (event->wValue &&
505 : 0 : netif_carrier_ok(dev->net))
506 : 0 : netif_carrier_off(dev->net);
507 : :
508 : 0 : usbnet_link_change(dev, !!event->wValue, 0);
509 : : }
510 : :
511 : : static const struct driver_info cdc_info = {
512 : : .description = "CDC Ethernet Device",
513 : : .flags = FLAG_ETHER | FLAG_POINTTOPOINT,
514 : : .bind = usbnet_cdc_bind,
515 : : .unbind = usbnet_cdc_unbind,
516 : : .status = usbnet_cdc_status,
517 : : .set_rx_mode = usbnet_cdc_update_filter,
518 : : .manage_power = usbnet_manage_power,
519 : : };
520 : :
521 : : static const struct driver_info zte_cdc_info = {
522 : : .description = "ZTE CDC Ethernet Device",
523 : : .flags = FLAG_ETHER | FLAG_POINTTOPOINT,
524 : : .bind = usbnet_cdc_zte_bind,
525 : : .unbind = usbnet_cdc_unbind,
526 : : .status = usbnet_cdc_zte_status,
527 : : .set_rx_mode = usbnet_cdc_update_filter,
528 : : .manage_power = usbnet_manage_power,
529 : : .rx_fixup = usbnet_cdc_zte_rx_fixup,
530 : : };
531 : :
532 : : static const struct driver_info wwan_info = {
533 : : .description = "Mobile Broadband Network Device",
534 : : .flags = FLAG_WWAN,
535 : : .bind = usbnet_cdc_bind,
536 : : .unbind = usbnet_cdc_unbind,
537 : : .status = usbnet_cdc_status,
538 : : .set_rx_mode = usbnet_cdc_update_filter,
539 : : .manage_power = usbnet_manage_power,
540 : : };
541 : :
542 : : /*-------------------------------------------------------------------------*/
543 : :
544 : : #define HUAWEI_VENDOR_ID 0x12D1
545 : : #define NOVATEL_VENDOR_ID 0x1410
546 : : #define ZTE_VENDOR_ID 0x19D2
547 : : #define DELL_VENDOR_ID 0x413C
548 : : #define REALTEK_VENDOR_ID 0x0bda
549 : : #define SAMSUNG_VENDOR_ID 0x04e8
550 : : #define LENOVO_VENDOR_ID 0x17ef
551 : : #define LINKSYS_VENDOR_ID 0x13b1
552 : : #define NVIDIA_VENDOR_ID 0x0955
553 : : #define HP_VENDOR_ID 0x03f0
554 : : #define MICROSOFT_VENDOR_ID 0x045e
555 : : #define UBLOX_VENDOR_ID 0x1546
556 : : #define TPLINK_VENDOR_ID 0x2357
557 : : #define AQUANTIA_VENDOR_ID 0x2eca
558 : : #define ASIX_VENDOR_ID 0x0b95
559 : :
560 : : static const struct usb_device_id products[] = {
561 : : /* BLACKLIST !!
562 : : *
563 : : * First blacklist any products that are egregiously nonconformant
564 : : * with the CDC Ethernet specs. Minor braindamage we cope with; when
565 : : * they're not even trying, needing a separate driver is only the first
566 : : * of the differences to show up.
567 : : */
568 : :
569 : : #define ZAURUS_MASTER_INTERFACE \
570 : : .bInterfaceClass = USB_CLASS_COMM, \
571 : : .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, \
572 : : .bInterfaceProtocol = USB_CDC_PROTO_NONE
573 : :
574 : : /* SA-1100 based Sharp Zaurus ("collie"), or compatible;
575 : : * wire-incompatible with true CDC Ethernet implementations.
576 : : * (And, it seems, needlessly so...)
577 : : */
578 : : {
579 : : .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
580 : : | USB_DEVICE_ID_MATCH_DEVICE,
581 : : .idVendor = 0x04DD,
582 : : .idProduct = 0x8004,
583 : : ZAURUS_MASTER_INTERFACE,
584 : : .driver_info = 0,
585 : : },
586 : :
587 : : /* PXA-25x based Sharp Zaurii. Note that it seems some of these
588 : : * (later models especially) may have shipped only with firmware
589 : : * advertising false "CDC MDLM" compatibility ... but we're not
590 : : * clear which models did that, so for now let's assume the worst.
591 : : */
592 : : {
593 : : .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
594 : : | USB_DEVICE_ID_MATCH_DEVICE,
595 : : .idVendor = 0x04DD,
596 : : .idProduct = 0x8005, /* A-300 */
597 : : ZAURUS_MASTER_INTERFACE,
598 : : .driver_info = 0,
599 : : }, {
600 : : .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
601 : : | USB_DEVICE_ID_MATCH_DEVICE,
602 : : .idVendor = 0x04DD,
603 : : .idProduct = 0x8006, /* B-500/SL-5600 */
604 : : ZAURUS_MASTER_INTERFACE,
605 : : .driver_info = 0,
606 : : }, {
607 : : .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
608 : : | USB_DEVICE_ID_MATCH_DEVICE,
609 : : .idVendor = 0x04DD,
610 : : .idProduct = 0x8007, /* C-700 */
611 : : ZAURUS_MASTER_INTERFACE,
612 : : .driver_info = 0,
613 : : }, {
614 : : .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
615 : : | USB_DEVICE_ID_MATCH_DEVICE,
616 : : .idVendor = 0x04DD,
617 : : .idProduct = 0x9031, /* C-750 C-760 */
618 : : ZAURUS_MASTER_INTERFACE,
619 : : .driver_info = 0,
620 : : }, {
621 : : .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
622 : : | USB_DEVICE_ID_MATCH_DEVICE,
623 : : .idVendor = 0x04DD,
624 : : .idProduct = 0x9032, /* SL-6000 */
625 : : ZAURUS_MASTER_INTERFACE,
626 : : .driver_info = 0,
627 : : }, {
628 : : .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
629 : : | USB_DEVICE_ID_MATCH_DEVICE,
630 : : .idVendor = 0x04DD,
631 : : /* reported with some C860 units */
632 : : .idProduct = 0x9050, /* C-860 */
633 : : ZAURUS_MASTER_INTERFACE,
634 : : .driver_info = 0,
635 : : },
636 : :
637 : : /* Olympus has some models with a Zaurus-compatible option.
638 : : * R-1000 uses a FreeScale i.MXL cpu (ARMv4T)
639 : : */
640 : : {
641 : : .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
642 : : | USB_DEVICE_ID_MATCH_DEVICE,
643 : : .idVendor = 0x07B4,
644 : : .idProduct = 0x0F02, /* R-1000 */
645 : : ZAURUS_MASTER_INTERFACE,
646 : : .driver_info = 0,
647 : : },
648 : :
649 : : /* LG Electronics VL600 wants additional headers on every frame */
650 : : {
651 : : USB_DEVICE_AND_INTERFACE_INFO(0x1004, 0x61aa, USB_CLASS_COMM,
652 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
653 : : .driver_info = 0,
654 : : },
655 : :
656 : : /* Logitech Harmony 900 - uses the pseudo-MDLM (BLAN) driver */
657 : : {
658 : : USB_DEVICE_AND_INTERFACE_INFO(0x046d, 0xc11f, USB_CLASS_COMM,
659 : : USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
660 : : .driver_info = 0,
661 : : },
662 : :
663 : : /* Novatel USB551L and MC551 - handled by qmi_wwan */
664 : : {
665 : : USB_DEVICE_AND_INTERFACE_INFO(NOVATEL_VENDOR_ID, 0xB001, USB_CLASS_COMM,
666 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
667 : : .driver_info = 0,
668 : : },
669 : :
670 : : /* Novatel E362 - handled by qmi_wwan */
671 : : {
672 : : USB_DEVICE_AND_INTERFACE_INFO(NOVATEL_VENDOR_ID, 0x9010, USB_CLASS_COMM,
673 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
674 : : .driver_info = 0,
675 : : },
676 : :
677 : : /* Dell Wireless 5800 (Novatel E362) - handled by qmi_wwan */
678 : : {
679 : : USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x8195, USB_CLASS_COMM,
680 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
681 : : .driver_info = 0,
682 : : },
683 : :
684 : : /* Dell Wireless 5800 (Novatel E362) - handled by qmi_wwan */
685 : : {
686 : : USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x8196, USB_CLASS_COMM,
687 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
688 : : .driver_info = 0,
689 : : },
690 : :
691 : : /* Dell Wireless 5804 (Novatel E371) - handled by qmi_wwan */
692 : : {
693 : : USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x819b, USB_CLASS_COMM,
694 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
695 : : .driver_info = 0,
696 : : },
697 : :
698 : : /* Novatel Expedite E371 - handled by qmi_wwan */
699 : : {
700 : : USB_DEVICE_AND_INTERFACE_INFO(NOVATEL_VENDOR_ID, 0x9011, USB_CLASS_COMM,
701 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
702 : : .driver_info = 0,
703 : : },
704 : :
705 : : /* HP lt2523 (Novatel E371) - handled by qmi_wwan */
706 : : {
707 : : USB_DEVICE_AND_INTERFACE_INFO(HP_VENDOR_ID, 0x421d, USB_CLASS_COMM,
708 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
709 : : .driver_info = 0,
710 : : },
711 : :
712 : : /* AnyDATA ADU960S - handled by qmi_wwan */
713 : : {
714 : : USB_DEVICE_AND_INTERFACE_INFO(0x16d5, 0x650a, USB_CLASS_COMM,
715 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
716 : : .driver_info = 0,
717 : : },
718 : :
719 : : /* Huawei E1820 - handled by qmi_wwan */
720 : : {
721 : : USB_DEVICE_INTERFACE_NUMBER(HUAWEI_VENDOR_ID, 0x14ac, 1),
722 : : .driver_info = 0,
723 : : },
724 : :
725 : : /* Realtek RTL8152 Based USB 2.0 Ethernet Adapters */
726 : : {
727 : : USB_DEVICE_AND_INTERFACE_INFO(REALTEK_VENDOR_ID, 0x8152, USB_CLASS_COMM,
728 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
729 : : .driver_info = 0,
730 : : },
731 : :
732 : : /* Realtek RTL8153 Based USB 3.0 Ethernet Adapters */
733 : : {
734 : : USB_DEVICE_AND_INTERFACE_INFO(REALTEK_VENDOR_ID, 0x8153, USB_CLASS_COMM,
735 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
736 : : .driver_info = 0,
737 : : },
738 : :
739 : : /* Samsung USB Ethernet Adapters */
740 : : {
741 : : USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, 0xa101, USB_CLASS_COMM,
742 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
743 : : .driver_info = 0,
744 : : },
745 : :
746 : : #if IS_ENABLED(CONFIG_USB_RTL8152)
747 : : /* Linksys USB3GIGV1 Ethernet Adapter */
748 : : {
749 : : USB_DEVICE_AND_INTERFACE_INFO(LINKSYS_VENDOR_ID, 0x0041, USB_CLASS_COMM,
750 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
751 : : .driver_info = 0,
752 : : },
753 : : #endif
754 : :
755 : : /* ThinkPad USB-C Dock (based on Realtek RTL8153) */
756 : : {
757 : : USB_DEVICE_AND_INTERFACE_INFO(LENOVO_VENDOR_ID, 0x3062, USB_CLASS_COMM,
758 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
759 : : .driver_info = 0,
760 : : },
761 : :
762 : : /* ThinkPad Thunderbolt 3 Dock (based on Realtek RTL8153) */
763 : : {
764 : : USB_DEVICE_AND_INTERFACE_INFO(LENOVO_VENDOR_ID, 0x3069, USB_CLASS_COMM,
765 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
766 : : .driver_info = 0,
767 : : },
768 : :
769 : : /* Lenovo Thinkpad USB 3.0 Ethernet Adapters (based on Realtek RTL8153) */
770 : : {
771 : : USB_DEVICE_AND_INTERFACE_INFO(LENOVO_VENDOR_ID, 0x7205, USB_CLASS_COMM,
772 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
773 : : .driver_info = 0,
774 : : },
775 : :
776 : : /* Lenovo USB C to Ethernet Adapter (based on Realtek RTL8153) */
777 : : {
778 : : USB_DEVICE_AND_INTERFACE_INFO(LENOVO_VENDOR_ID, 0x720c, USB_CLASS_COMM,
779 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
780 : : .driver_info = 0,
781 : : },
782 : :
783 : : /* Lenovo USB-C Travel Hub (based on Realtek RTL8153) */
784 : : {
785 : : USB_DEVICE_AND_INTERFACE_INFO(LENOVO_VENDOR_ID, 0x7214, USB_CLASS_COMM,
786 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
787 : : .driver_info = 0,
788 : : },
789 : :
790 : : /* ThinkPad USB-C Dock Gen 2 (based on Realtek RTL8153) */
791 : : {
792 : : USB_DEVICE_AND_INTERFACE_INFO(LENOVO_VENDOR_ID, 0xa387, USB_CLASS_COMM,
793 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
794 : : .driver_info = 0,
795 : : },
796 : :
797 : : /* NVIDIA Tegra USB 3.0 Ethernet Adapters (based on Realtek RTL8153) */
798 : : {
799 : : USB_DEVICE_AND_INTERFACE_INFO(NVIDIA_VENDOR_ID, 0x09ff, USB_CLASS_COMM,
800 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
801 : : .driver_info = 0,
802 : : },
803 : :
804 : : /* Microsoft Surface 2 dock (based on Realtek RTL8152) */
805 : : {
806 : : USB_DEVICE_AND_INTERFACE_INFO(MICROSOFT_VENDOR_ID, 0x07ab, USB_CLASS_COMM,
807 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
808 : : .driver_info = 0,
809 : : },
810 : :
811 : : /* Microsoft Surface Ethernet Adapter (based on Realtek RTL8153) */
812 : : {
813 : : USB_DEVICE_AND_INTERFACE_INFO(MICROSOFT_VENDOR_ID, 0x07c6, USB_CLASS_COMM,
814 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
815 : : .driver_info = 0,
816 : : },
817 : :
818 : : /* Microsoft Surface Ethernet Adapter (based on Realtek RTL8153B) */
819 : : {
820 : : USB_DEVICE_AND_INTERFACE_INFO(MICROSOFT_VENDOR_ID, 0x0927, USB_CLASS_COMM,
821 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
822 : : .driver_info = 0,
823 : : },
824 : :
825 : : /* TP-LINK UE300 USB 3.0 Ethernet Adapters (based on Realtek RTL8153) */
826 : : {
827 : : USB_DEVICE_AND_INTERFACE_INFO(TPLINK_VENDOR_ID, 0x0601, USB_CLASS_COMM,
828 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
829 : : .driver_info = 0,
830 : : },
831 : :
832 : : /* Aquantia AQtion USB to 5GbE Controller (based on AQC111U) */
833 : : {
834 : : USB_DEVICE_AND_INTERFACE_INFO(AQUANTIA_VENDOR_ID, 0xc101,
835 : : USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
836 : : USB_CDC_PROTO_NONE),
837 : : .driver_info = 0,
838 : : },
839 : :
840 : : /* ASIX USB 3.1 Gen1 to 5G Multi-Gigabit Ethernet Adapter(based on AQC111U) */
841 : : {
842 : : USB_DEVICE_AND_INTERFACE_INFO(ASIX_VENDOR_ID, 0x2790, USB_CLASS_COMM,
843 : : USB_CDC_SUBCLASS_ETHERNET,
844 : : USB_CDC_PROTO_NONE),
845 : : .driver_info = 0,
846 : : },
847 : :
848 : : /* ASIX USB 3.1 Gen1 to 2.5G Multi-Gigabit Ethernet Adapter(based on AQC112U) */
849 : : {
850 : : USB_DEVICE_AND_INTERFACE_INFO(ASIX_VENDOR_ID, 0x2791, USB_CLASS_COMM,
851 : : USB_CDC_SUBCLASS_ETHERNET,
852 : : USB_CDC_PROTO_NONE),
853 : : .driver_info = 0,
854 : : },
855 : :
856 : : /* USB-C 3.1 to 5GBASE-T Ethernet Adapter (based on AQC111U) */
857 : : {
858 : : USB_DEVICE_AND_INTERFACE_INFO(0x20f4, 0xe05a, USB_CLASS_COMM,
859 : : USB_CDC_SUBCLASS_ETHERNET,
860 : : USB_CDC_PROTO_NONE),
861 : : .driver_info = 0,
862 : : },
863 : :
864 : : /* QNAP QNA-UC5G1T USB to 5GbE Adapter (based on AQC111U) */
865 : : {
866 : : USB_DEVICE_AND_INTERFACE_INFO(0x1c04, 0x0015, USB_CLASS_COMM,
867 : : USB_CDC_SUBCLASS_ETHERNET,
868 : : USB_CDC_PROTO_NONE),
869 : : .driver_info = 0,
870 : : },
871 : :
872 : : /* WHITELIST!!!
873 : : *
874 : : * CDC Ether uses two interfaces, not necessarily consecutive.
875 : : * We match the main interface, ignoring the optional device
876 : : * class so we could handle devices that aren't exclusively
877 : : * CDC ether.
878 : : *
879 : : * NOTE: this match must come AFTER entries blacklisting devices
880 : : * because of bugs/quirks in a given product (like Zaurus, above).
881 : : */
882 : : {
883 : : /* ZTE (Vodafone) K3805-Z */
884 : : USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1003, USB_CLASS_COMM,
885 : : USB_CDC_SUBCLASS_ETHERNET,
886 : : USB_CDC_PROTO_NONE),
887 : : .driver_info = (unsigned long)&wwan_info,
888 : : }, {
889 : : /* ZTE (Vodafone) K3806-Z */
890 : : USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1015, USB_CLASS_COMM,
891 : : USB_CDC_SUBCLASS_ETHERNET,
892 : : USB_CDC_PROTO_NONE),
893 : : .driver_info = (unsigned long)&wwan_info,
894 : : }, {
895 : : /* ZTE (Vodafone) K4510-Z */
896 : : USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1173, USB_CLASS_COMM,
897 : : USB_CDC_SUBCLASS_ETHERNET,
898 : : USB_CDC_PROTO_NONE),
899 : : .driver_info = (unsigned long)&wwan_info,
900 : : }, {
901 : : /* ZTE (Vodafone) K3770-Z */
902 : : USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1177, USB_CLASS_COMM,
903 : : USB_CDC_SUBCLASS_ETHERNET,
904 : : USB_CDC_PROTO_NONE),
905 : : .driver_info = (unsigned long)&wwan_info,
906 : : }, {
907 : : /* ZTE (Vodafone) K3772-Z */
908 : : USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1181, USB_CLASS_COMM,
909 : : USB_CDC_SUBCLASS_ETHERNET,
910 : : USB_CDC_PROTO_NONE),
911 : : .driver_info = (unsigned long)&wwan_info,
912 : : }, {
913 : : /* Telit modules */
914 : : USB_VENDOR_AND_INTERFACE_INFO(0x1bc7, USB_CLASS_COMM,
915 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
916 : : .driver_info = (kernel_ulong_t) &wwan_info,
917 : : }, {
918 : : /* Dell DW5580 modules */
919 : : USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x81ba, USB_CLASS_COMM,
920 : : USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
921 : : .driver_info = (kernel_ulong_t)&wwan_info,
922 : : }, {
923 : : /* Huawei ME906 and ME909 */
924 : : USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x15c1, USB_CLASS_COMM,
925 : : USB_CDC_SUBCLASS_ETHERNET,
926 : : USB_CDC_PROTO_NONE),
927 : : .driver_info = (unsigned long)&wwan_info,
928 : : }, {
929 : : /* ZTE modules */
930 : : USB_VENDOR_AND_INTERFACE_INFO(ZTE_VENDOR_ID, USB_CLASS_COMM,
931 : : USB_CDC_SUBCLASS_ETHERNET,
932 : : USB_CDC_PROTO_NONE),
933 : : .driver_info = (unsigned long)&zte_cdc_info,
934 : : }, {
935 : : /* U-blox TOBY-L2 */
936 : : USB_DEVICE_AND_INTERFACE_INFO(UBLOX_VENDOR_ID, 0x1143, USB_CLASS_COMM,
937 : : USB_CDC_SUBCLASS_ETHERNET,
938 : : USB_CDC_PROTO_NONE),
939 : : .driver_info = (unsigned long)&wwan_info,
940 : : }, {
941 : : /* U-blox SARA-U2 */
942 : : USB_DEVICE_AND_INTERFACE_INFO(UBLOX_VENDOR_ID, 0x1104, USB_CLASS_COMM,
943 : : USB_CDC_SUBCLASS_ETHERNET,
944 : : USB_CDC_PROTO_NONE),
945 : : .driver_info = (unsigned long)&wwan_info,
946 : : }, {
947 : : /* Cinterion PLS8 modem by GEMALTO */
948 : : USB_DEVICE_AND_INTERFACE_INFO(0x1e2d, 0x0061, USB_CLASS_COMM,
949 : : USB_CDC_SUBCLASS_ETHERNET,
950 : : USB_CDC_PROTO_NONE),
951 : : .driver_info = (unsigned long)&wwan_info,
952 : : }, {
953 : : /* Cinterion AHS3 modem by GEMALTO */
954 : : USB_DEVICE_AND_INTERFACE_INFO(0x1e2d, 0x0055, USB_CLASS_COMM,
955 : : USB_CDC_SUBCLASS_ETHERNET,
956 : : USB_CDC_PROTO_NONE),
957 : : .driver_info = (unsigned long)&wwan_info,
958 : : }, {
959 : : USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
960 : : USB_CDC_PROTO_NONE),
961 : : .driver_info = (unsigned long) &cdc_info,
962 : : }, {
963 : : USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM,
964 : : USB_CDC_PROTO_NONE),
965 : : .driver_info = (unsigned long)&wwan_info,
966 : :
967 : : }, {
968 : : /* Various Huawei modems with a network port like the UMG1831 */
969 : : USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_COMM,
970 : : USB_CDC_SUBCLASS_ETHERNET, 255),
971 : : .driver_info = (unsigned long)&wwan_info,
972 : : },
973 : : { }, /* END */
974 : : };
975 : : MODULE_DEVICE_TABLE(usb, products);
976 : :
977 : : static struct usb_driver cdc_driver = {
978 : : .name = "cdc_ether",
979 : : .id_table = products,
980 : : .probe = usbnet_probe,
981 : : .disconnect = usbnet_disconnect,
982 : : .suspend = usbnet_suspend,
983 : : .resume = usbnet_resume,
984 : : .reset_resume = usbnet_resume,
985 : : .supports_autosuspend = 1,
986 : : .disable_hub_initiated_lpm = 1,
987 : : };
988 : :
989 : 1 : module_usb_driver(cdc_driver);
990 : :
991 : : MODULE_AUTHOR("David Brownell");
992 : : MODULE_DESCRIPTION("USB CDC Ethernet devices");
993 : : MODULE_LICENSE("GPL");
|
