xref: /openbmc/linux/drivers/net/usb/cdc_ether.c (revision fb8d6c8d)
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 	return (desc->bInterfaceClass == USB_CLASS_COMM &&
27 		desc->bInterfaceSubClass == 2 &&
28 		desc->bInterfaceProtocol == 0xff);
29 }
30 
31 static int is_activesync(struct usb_interface_descriptor *desc)
32 {
33 	return (desc->bInterfaceClass == USB_CLASS_MISC &&
34 		desc->bInterfaceSubClass == 1 &&
35 		desc->bInterfaceProtocol == 1);
36 }
37 
38 static int is_wireless_rndis(struct usb_interface_descriptor *desc)
39 {
40 	return (desc->bInterfaceClass == USB_CLASS_WIRELESS_CONTROLLER &&
41 		desc->bInterfaceSubClass == 1 &&
42 		desc->bInterfaceProtocol == 3);
43 }
44 
45 static int is_novatel_rndis(struct usb_interface_descriptor *desc)
46 {
47 	return (desc->bInterfaceClass == USB_CLASS_MISC &&
48 		desc->bInterfaceSubClass == 4 &&
49 		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 static void usbnet_cdc_update_filter(struct usbnet *dev)
67 {
68 	struct cdc_state	*info = (void *) &dev->data;
69 	struct usb_interface	*intf = info->control;
70 	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 	if (net->flags & IFF_PROMISC)
80 		cdc_filter |= USB_CDC_PACKET_TYPE_PROMISCUOUS;
81 	if (!netdev_mc_empty(net) || (net->flags & IFF_ALLMULTI))
82 		cdc_filter |= USB_CDC_PACKET_TYPE_ALL_MULTICAST;
83 
84 	usb_control_msg(dev->udev,
85 			usb_sndctrlpipe(dev->udev, 0),
86 			USB_CDC_SET_ETHERNET_PACKET_FILTER,
87 			USB_TYPE_CLASS | USB_RECIP_INTERFACE,
88 			cdc_filter,
89 			intf->cur_altsetting->desc.bInterfaceNumber,
90 			NULL,
91 			0,
92 			USB_CTRL_SET_TIMEOUT
93 		);
94 }
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 int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
102 {
103 	u8				*buf = intf->cur_altsetting->extra;
104 	int				len = intf->cur_altsetting->extralen;
105 	struct usb_interface_descriptor	*d;
106 	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 	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 		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 	if (len == 0) {
132 		struct usb_host_endpoint	*hep;
133 
134 		hep = intf->cur_altsetting->endpoint;
135 		if (hep) {
136 			buf = hep->extra;
137 			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 	rndis = (is_rndis(&intf->cur_altsetting->desc) ||
148 		 is_activesync(&intf->cur_altsetting->desc) ||
149 		 is_wireless_rndis(&intf->cur_altsetting->desc) ||
150 		 is_novatel_rndis(&intf->cur_altsetting->desc));
151 
152 	memset(info, 0, sizeof(*info));
153 	info->control = intf;
154 
155 	cdc_parse_cdc_header(&header, intf, buf, len);
156 
157 	info->u = header.usb_cdc_union_desc;
158 	info->header = header.usb_cdc_header_desc;
159 	info->ether = header.usb_cdc_ether_desc;
160 	if (!info->u) {
161 		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 	info->control = usb_ifnum_to_if(dev->udev, info->u->bMasterInterface0);
171 	info->data = usb_ifnum_to_if(dev->udev, info->u->bSlaveInterface0);
172 	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 		if (rndis) {
181 			android_rndis_quirk = true;
182 			goto skip;
183 		}
184 		goto bad_desc;
185 	}
186 	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 		if (info->data == intf) {
192 			info->data = info->control;
193 			info->control = intf;
194 		} else
195 			goto bad_desc;
196 	}
197 
198 	/* some devices merge these - skip class check */
199 	if (info->control == info->data)
200 		goto skip;
201 
202 	/* a data interface altsetting does the real i/o */
203 	d = &info->data->cur_altsetting->desc;
204 	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 	if (rndis && is_rndis(&intf->cur_altsetting->desc) &&
217 	    header.usb_cdc_acm_descriptor &&
218 	    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 	if (header.usb_cdc_ether_desc && info->ether->wMaxSegmentSize) {
226 		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 	if (header.usb_cdc_mdlm_desc &&
233 	    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 	if (header.usb_cdc_mdlm_detail_desc &&
239 		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 	if (rndis && (!info->u || android_rndis_quirk)) {
256 		info->control = usb_ifnum_to_if(dev->udev, 0);
257 		info->data = usb_ifnum_to_if(dev->udev, 1);
258 		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 	} 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 	if (info->data != info->control) {
278 		status = usb_driver_claim_interface(driver, info->data, dev);
279 		if (status < 0)
280 			return status;
281 	}
282 	status = usbnet_get_endpoints(dev, info->data);
283 	if (status < 0) {
284 		/* ensure immediate exit from usbnet_disconnect */
285 		usb_set_intfdata(info->data, NULL);
286 		if (info->data != info->control)
287 			usb_driver_release_interface(driver, info->data);
288 		return status;
289 	}
290 
291 	/* status endpoint: optional for CDC Ethernet, not RNDIS (or ACM) */
292 	if (info->data != info->control)
293 		dev->status = NULL;
294 	if (info->control->cur_altsetting->desc.bNumEndpoints == 1) {
295 		struct usb_endpoint_descriptor	*desc;
296 
297 		dev->status = &info->control->cur_altsetting->endpoint[0];
298 		desc = &dev->status->desc;
299 		if (!usb_endpoint_is_int_in(desc) ||
300 		    (le16_to_cpu(desc->wMaxPacketSize)
301 		     < sizeof(struct usb_cdc_notification)) ||
302 		    !desc->bInterval) {
303 			dev_dbg(&intf->dev, "bad notification endpoint\n");
304 			dev->status = NULL;
305 		}
306 	}
307 	if (rndis && !dev->status) {
308 		dev_dbg(&intf->dev, "missing RNDIS status endpoint\n");
309 		usb_set_intfdata(info->data, NULL);
310 		usb_driver_release_interface(driver, info->data);
311 		return -ENODEV;
312 	}
313 
314 	return 0;
315 
316 bad_desc:
317 	dev_info(&dev->udev->dev, "bad CDC descriptors\n");
318 	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 int usbnet_ether_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
327 {
328 	int rv;
329 
330 	rv = usbnet_generic_cdc_bind(dev, intf);
331 	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 	usbnet_cdc_update_filter(dev);
340 
341 bail_out:
342 	return rv;
343 }
344 EXPORT_SYMBOL_GPL(usbnet_ether_cdc_bind);
345 
346 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 	if (info->data == info->control)
353 		return;
354 
355 	/* disconnect master --> disconnect slave */
356 	if (intf == info->control && info->data) {
357 		/* ensure immediate exit from usbnet_disconnect */
358 		usb_set_intfdata(info->data, NULL);
359 		usb_driver_release_interface(driver, info->data);
360 		info->data = NULL;
361 	}
362 
363 	/* and vice versa (just in case) */
364 	else if (intf == info->data && info->control) {
365 		/* ensure immediate exit from usbnet_disconnect */
366 		usb_set_intfdata(info->control, NULL);
367 		usb_driver_release_interface(driver, info->control);
368 		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 static 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 
391 void 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 	/* SPEED_CHANGE can get split into two 8-byte packets */
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:	/* tx/rx rates */
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 	/* 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 		netdev_err(dev->net, "CDC: unexpected notification %02x!\n",
424 			   event->bNotificationType);
425 		break;
426 	}
427 }
428 EXPORT_SYMBOL_GPL(usbnet_cdc_status);
429 
430 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 	status = usbnet_ether_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 	return 0;
450 }
451 EXPORT_SYMBOL_GPL(usbnet_cdc_bind);
452 
453 static int usbnet_cdc_zte_bind(struct usbnet *dev, struct usb_interface *intf)
454 {
455 	int status = usbnet_cdc_bind(dev, intf);
456 
457 	if (!status && (dev->net->dev_addr[0] & 0x02))
458 		eth_hw_addr_random(dev->net);
459 
460 	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 static int usbnet_cdc_zte_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
471 {
472 	if (skb->len < ETH_HLEN || !(skb->data[0] & 0x02))
473 		return 1;
474 
475 	skb_reset_mac_header(skb);
476 	ether_addr_copy(eth_hdr(skb)->h_dest, dev->net->dev_addr);
477 
478 	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 static void usbnet_cdc_zte_status(struct usbnet *dev, struct urb *urb)
488 {
489 	struct usb_cdc_notification *event;
490 
491 	if (urb->actual_length < sizeof(*event))
492 		return;
493 
494 	event = urb->transfer_buffer;
495 
496 	if (event->bNotificationType != USB_CDC_NOTIFY_NETWORK_CONNECTION) {
497 		usbnet_cdc_status(dev, urb);
498 		return;
499 	}
500 
501 	netif_dbg(dev, timer, dev->net, "CDC: carrier %s\n",
502 		  event->wValue ? "on" : "off");
503 
504 	if (event->wValue &&
505 	    netif_carrier_ok(dev->net))
506 		netif_carrier_off(dev->net);
507 
508 	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 3 dock (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 	/* TP-LINK UE300 USB 3.0 Ethernet Adapters (based on Realtek RTL8153) */
819 {
820 	USB_DEVICE_AND_INTERFACE_INFO(TPLINK_VENDOR_ID, 0x0601, USB_CLASS_COMM,
821 			USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
822 	.driver_info = 0,
823 },
824 
825 /* Aquantia AQtion USB to 5GbE Controller (based on AQC111U) */
826 {
827 	USB_DEVICE_AND_INTERFACE_INFO(AQUANTIA_VENDOR_ID, 0xc101,
828 				      USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
829 				      USB_CDC_PROTO_NONE),
830 	.driver_info = 0,
831 },
832 
833 /* ASIX USB 3.1 Gen1 to 5G Multi-Gigabit Ethernet Adapter(based on AQC111U) */
834 {
835 	USB_DEVICE_AND_INTERFACE_INFO(ASIX_VENDOR_ID, 0x2790, USB_CLASS_COMM,
836 				      USB_CDC_SUBCLASS_ETHERNET,
837 				      USB_CDC_PROTO_NONE),
838 	.driver_info = 0,
839 },
840 
841 /* ASIX USB 3.1 Gen1 to 2.5G Multi-Gigabit Ethernet Adapter(based on AQC112U) */
842 {
843 	USB_DEVICE_AND_INTERFACE_INFO(ASIX_VENDOR_ID, 0x2791, USB_CLASS_COMM,
844 				      USB_CDC_SUBCLASS_ETHERNET,
845 				      USB_CDC_PROTO_NONE),
846 	.driver_info = 0,
847 },
848 
849 /* USB-C 3.1 to 5GBASE-T Ethernet Adapter (based on AQC111U) */
850 {
851 	USB_DEVICE_AND_INTERFACE_INFO(0x20f4, 0xe05a, USB_CLASS_COMM,
852 				      USB_CDC_SUBCLASS_ETHERNET,
853 				      USB_CDC_PROTO_NONE),
854 	.driver_info = 0,
855 },
856 
857 /* QNAP QNA-UC5G1T USB to 5GbE Adapter (based on AQC111U) */
858 {
859 	USB_DEVICE_AND_INTERFACE_INFO(0x1c04, 0x0015, USB_CLASS_COMM,
860 				      USB_CDC_SUBCLASS_ETHERNET,
861 				      USB_CDC_PROTO_NONE),
862 	.driver_info = 0,
863 },
864 
865 /* WHITELIST!!!
866  *
867  * CDC Ether uses two interfaces, not necessarily consecutive.
868  * We match the main interface, ignoring the optional device
869  * class so we could handle devices that aren't exclusively
870  * CDC ether.
871  *
872  * NOTE:  this match must come AFTER entries blacklisting devices
873  * because of bugs/quirks in a given product (like Zaurus, above).
874  */
875 {
876 	/* ZTE (Vodafone) K3805-Z */
877 	USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1003, USB_CLASS_COMM,
878 				      USB_CDC_SUBCLASS_ETHERNET,
879 				      USB_CDC_PROTO_NONE),
880 	.driver_info = (unsigned long)&wwan_info,
881 }, {
882 	/* ZTE (Vodafone) K3806-Z */
883 	USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1015, USB_CLASS_COMM,
884 				      USB_CDC_SUBCLASS_ETHERNET,
885 				      USB_CDC_PROTO_NONE),
886 	.driver_info = (unsigned long)&wwan_info,
887 }, {
888 	/* ZTE (Vodafone) K4510-Z */
889 	USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1173, USB_CLASS_COMM,
890 				      USB_CDC_SUBCLASS_ETHERNET,
891 				      USB_CDC_PROTO_NONE),
892 	.driver_info = (unsigned long)&wwan_info,
893 }, {
894 	/* ZTE (Vodafone) K3770-Z */
895 	USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1177, USB_CLASS_COMM,
896 				      USB_CDC_SUBCLASS_ETHERNET,
897 				      USB_CDC_PROTO_NONE),
898 	.driver_info = (unsigned long)&wwan_info,
899 }, {
900 	/* ZTE (Vodafone) K3772-Z */
901 	USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1181, USB_CLASS_COMM,
902 				      USB_CDC_SUBCLASS_ETHERNET,
903 				      USB_CDC_PROTO_NONE),
904 	.driver_info = (unsigned long)&wwan_info,
905 }, {
906 	/* Telit modules */
907 	USB_VENDOR_AND_INTERFACE_INFO(0x1bc7, USB_CLASS_COMM,
908 			USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
909 	.driver_info = (kernel_ulong_t) &wwan_info,
910 }, {
911 	/* Dell DW5580 modules */
912 	USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, 0x81ba, USB_CLASS_COMM,
913 			USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
914 	.driver_info = (kernel_ulong_t)&wwan_info,
915 }, {
916 	/* Huawei ME906 and ME909 */
917 	USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x15c1, USB_CLASS_COMM,
918 				      USB_CDC_SUBCLASS_ETHERNET,
919 				      USB_CDC_PROTO_NONE),
920 	.driver_info = (unsigned long)&wwan_info,
921 }, {
922 	/* ZTE modules */
923 	USB_VENDOR_AND_INTERFACE_INFO(ZTE_VENDOR_ID, USB_CLASS_COMM,
924 				      USB_CDC_SUBCLASS_ETHERNET,
925 				      USB_CDC_PROTO_NONE),
926 	.driver_info = (unsigned long)&zte_cdc_info,
927 }, {
928 	/* U-blox TOBY-L2 */
929 	USB_DEVICE_AND_INTERFACE_INFO(UBLOX_VENDOR_ID, 0x1143, USB_CLASS_COMM,
930 				      USB_CDC_SUBCLASS_ETHERNET,
931 				      USB_CDC_PROTO_NONE),
932 	.driver_info = (unsigned long)&wwan_info,
933 }, {
934 	/* U-blox SARA-U2 */
935 	USB_DEVICE_AND_INTERFACE_INFO(UBLOX_VENDOR_ID, 0x1104, USB_CLASS_COMM,
936 				      USB_CDC_SUBCLASS_ETHERNET,
937 				      USB_CDC_PROTO_NONE),
938 	.driver_info = (unsigned long)&wwan_info,
939 }, {
940 	/* Cinterion PLS8 modem by GEMALTO */
941 	USB_DEVICE_AND_INTERFACE_INFO(0x1e2d, 0x0061, USB_CLASS_COMM,
942 				      USB_CDC_SUBCLASS_ETHERNET,
943 				      USB_CDC_PROTO_NONE),
944 	.driver_info = (unsigned long)&wwan_info,
945 }, {
946 	/* Cinterion AHS3 modem by GEMALTO */
947 	USB_DEVICE_AND_INTERFACE_INFO(0x1e2d, 0x0055, USB_CLASS_COMM,
948 				      USB_CDC_SUBCLASS_ETHERNET,
949 				      USB_CDC_PROTO_NONE),
950 	.driver_info = (unsigned long)&wwan_info,
951 }, {
952 	USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
953 			USB_CDC_PROTO_NONE),
954 	.driver_info = (unsigned long) &cdc_info,
955 }, {
956 	USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM,
957 			USB_CDC_PROTO_NONE),
958 	.driver_info = (unsigned long)&wwan_info,
959 
960 }, {
961 	/* Various Huawei modems with a network port like the UMG1831 */
962 	USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_COMM,
963 				      USB_CDC_SUBCLASS_ETHERNET, 255),
964 	.driver_info = (unsigned long)&wwan_info,
965 },
966 	{ },		/* END */
967 };
968 MODULE_DEVICE_TABLE(usb, products);
969 
970 static struct usb_driver cdc_driver = {
971 	.name =		"cdc_ether",
972 	.id_table =	products,
973 	.probe =	usbnet_probe,
974 	.disconnect =	usbnet_disconnect,
975 	.suspend =	usbnet_suspend,
976 	.resume =	usbnet_resume,
977 	.reset_resume =	usbnet_resume,
978 	.supports_autosuspend = 1,
979 	.disable_hub_initiated_lpm = 1,
980 };
981 
982 module_usb_driver(cdc_driver);
983 
984 MODULE_AUTHOR("David Brownell");
985 MODULE_DESCRIPTION("USB CDC Ethernet devices");
986 MODULE_LICENSE("GPL");
987