LXR linux/drivers/net/usb/cdc

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

1001        .driver_info = (unsigned long)&wwan_info,
1002}, {
1003        USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
1004                        USB_CDC_PROTO_NONE),
1005        .driver_info = (unsigned long) &cdc_info,
1006}, {
1007        USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM,
1008                        USB_CDC_PROTO_NONE),
1009        .driver_info = (unsigned long)&wwan_info,
1010
1011}, {
1012        /* Various Huawei modems with a network port like the UMG1831 */
1013        USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_COMM,
1014                                      USB_CDC_SUBCLASS_ETHERNET, 255),
1015        .driver_info = (unsigned long)&wwan_info,
1016},
1017        { },            /* END */
1018};
1019MODULE_DEVICE_TABLE(usb, products);
1020
1021static struct usb_driver cdc_driver = {
1022        .name =         "cdc_ether",
1023        .id_table =     products,
1024        .probe =        usbnet_probe,
1025        .disconnect =   usbnet_disconnect,
1026        .suspend =      usbnet_suspend,
1027        .resume =       usbnet_resume,
1028        .reset_resume = usbnet_resume,
1029        .supports_autosuspend = 1,
1030        .disable_hub_initiated_lpm = 1,
1031};
1032
1033module_usb_driver(cdc_driver);
1034
1035MODULE_AUTHOR("David Brownell");
1036MODULE_DESCRIPTION("USB CDC Ethernet devices");
1037MODULE_LICENSE("GPL");
1038