LCOV - code coverage report
Current view: top level - drivers/net/usb - cdc_ether.c (source / functions) Hit Total Coverage
Test: Real Lines: 70 151 46.4 %
Date: 2020-10-17 15:46:16 Functions: 0 12 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           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");
    

Generated by: LCOV version 1.14