LCOV - code coverage report
Current view: top level - drivers/net/usb - usbnet.c (source / functions) Hit Total Coverage
Test: Real Lines: 444 786 56.5 %
Date: 2020-10-17 15:46:16 Functions: 16 60 26.7 %
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                 :            :  * USB Network driver infrastructure
       4                 :            :  * Copyright (C) 2000-2005 by David Brownell
       5                 :            :  * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
       6                 :            :  */
       7                 :            : 
       8                 :            : /*
       9                 :            :  * This is a generic "USB networking" framework that works with several
      10                 :            :  * kinds of full and high speed networking devices:  host-to-host cables,
      11                 :            :  * smart usb peripherals, and actual Ethernet adapters.
      12                 :            :  *
      13                 :            :  * These devices usually differ in terms of control protocols (if they
      14                 :            :  * even have one!) and sometimes they define new framing to wrap or batch
      15                 :            :  * Ethernet packets.  Otherwise, they talk to USB pretty much the same,
      16                 :            :  * so interface (un)binding, endpoint I/O queues, fault handling, and other
      17                 :            :  * issues can usefully be addressed by this framework.
      18                 :            :  */
      19                 :            : 
      20                 :            : // #define      DEBUG                   // error path messages, extra info
      21                 :            : // #define      VERBOSE                 // more; success messages
      22                 :            : 
      23                 :            : #include <linux/module.h>
      24                 :            : #include <linux/init.h>
      25                 :            : #include <linux/netdevice.h>
      26                 :            : #include <linux/etherdevice.h>
      27                 :            : #include <linux/ctype.h>
      28                 :            : #include <linux/ethtool.h>
      29                 :            : #include <linux/workqueue.h>
      30                 :            : #include <linux/mii.h>
      31                 :            : #include <linux/usb.h>
      32                 :            : #include <linux/usb/usbnet.h>
      33                 :            : #include <linux/slab.h>
      34                 :            : #include <linux/kernel.h>
      35                 :            : #include <linux/pm_runtime.h>
      36                 :            : 
      37                 :            : #define DRIVER_VERSION          "22-Aug-2005"
      38                 :            : 
      39                 :            : 
      40                 :            : /*-------------------------------------------------------------------------*/
      41                 :            : 
      42                 :            : /*
      43                 :            :  * Nineteen USB 1.1 max size bulk transactions per frame (ms), max.
      44                 :            :  * Several dozen bytes of IPv4 data can fit in two such transactions.
      45                 :            :  * One maximum size Ethernet packet takes twenty four of them.
      46                 :            :  * For high speed, each frame comfortably fits almost 36 max size
      47                 :            :  * Ethernet packets (so queues should be bigger).
      48                 :            :  *
      49                 :            :  * The goal is to let the USB host controller be busy for 5msec or
      50                 :            :  * more before an irq is required, under load.  Jumbograms change
      51                 :            :  * the equation.
      52                 :            :  */
      53                 :            : #define MAX_QUEUE_MEMORY        (60 * 1518)
      54                 :            : #define RX_QLEN(dev)            ((dev)->rx_qlen)
      55                 :            : #define TX_QLEN(dev)            ((dev)->tx_qlen)
      56                 :            : 
      57                 :            : // reawaken network queue this soon after stopping; else watchdog barks
      58                 :            : #define TX_TIMEOUT_JIFFIES      (5*HZ)
      59                 :            : 
      60                 :            : /* throttle rx/tx briefly after some faults, so hub_wq might disconnect()
      61                 :            :  * us (it polls at HZ/4 usually) before we report too many false errors.
      62                 :            :  */
      63                 :            : #define THROTTLE_JIFFIES        (HZ/8)
      64                 :            : 
      65                 :            : // between wakeups
      66                 :            : #define UNLINK_TIMEOUT_MS       3
      67                 :            : 
      68                 :            : /*-------------------------------------------------------------------------*/
      69                 :            : 
      70                 :            : // randomly generated ethernet address
      71                 :            : static u8       node_id [ETH_ALEN];
      72                 :            : 
      73                 :            : /* use ethtool to change the level for any given device */
      74                 :            : static int msg_level = -1;
      75                 :            : module_param (msg_level, int, 0);
      76                 :            : MODULE_PARM_DESC (msg_level, "Override default message level");
      77                 :            : 
      78                 :            : /*-------------------------------------------------------------------------*/
      79                 :            : 
      80                 :            : /* handles CDC Ethernet and many other network "bulk data" interfaces */
      81                 :          3 : int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
      82                 :            : {
      83                 :            :         int                             tmp;
      84                 :            :         struct usb_host_interface       *alt = NULL;
      85                 :            :         struct usb_host_endpoint        *in = NULL, *out = NULL;
      86                 :            :         struct usb_host_endpoint        *status = NULL;
      87                 :            : 
      88                 :          3 :         for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
      89                 :            :                 unsigned        ep;
      90                 :            : 
      91                 :            :                 in = out = status = NULL;
      92                 :          3 :                 alt = intf->altsetting + tmp;
      93                 :            : 
      94                 :            :                 /* take the first altsetting with in-bulk + out-bulk;
      95                 :            :                  * remember any status endpoint, just in case;
      96                 :            :                  * ignore other endpoints and altsettings.
      97                 :            :                  */
      98                 :          3 :                 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
      99                 :            :                         struct usb_host_endpoint        *e;
     100                 :            :                         int                             intr = 0;
     101                 :            : 
     102                 :          3 :                         e = alt->endpoint + ep;
     103                 :            : 
     104                 :            :                         /* ignore endpoints which cannot transfer data */
     105                 :          3 :                         if (!usb_endpoint_maxp(&e->desc))
     106                 :          0 :                                 continue;
     107                 :            : 
     108                 :          3 :                         switch (e->desc.bmAttributes) {
     109                 :            :                         case USB_ENDPOINT_XFER_INT:
     110                 :          3 :                                 if (!usb_endpoint_dir_in(&e->desc))
     111                 :          0 :                                         continue;
     112                 :            :                                 intr = 1;
     113                 :            :                                 /* FALLTHROUGH */
     114                 :            :                         case USB_ENDPOINT_XFER_BULK:
     115                 :            :                                 break;
     116                 :            :                         default:
     117                 :          0 :                                 continue;
     118                 :            :                         }
     119                 :          3 :                         if (usb_endpoint_dir_in(&e->desc)) {
     120                 :          3 :                                 if (!intr && !in)
     121                 :            :                                         in = e;
     122                 :          3 :                                 else if (intr && !status)
     123                 :            :                                         status = e;
     124                 :            :                         } else {
     125                 :          3 :                                 if (!out)
     126                 :            :                                         out = e;
     127                 :            :                         }
     128                 :            :                 }
     129                 :          3 :                 if (in && out)
     130                 :            :                         break;
     131                 :            :         }
     132                 :          3 :         if (!alt || !in || !out)
     133                 :            :                 return -EINVAL;
     134                 :            : 
     135                 :          3 :         if (alt->desc.bAlternateSetting != 0 ||
     136                 :          2 :             !(dev->driver_info->flags & FLAG_NO_SETINT)) {
     137                 :          3 :                 tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber,
     138                 :            :                                 alt->desc.bAlternateSetting);
     139                 :          3 :                 if (tmp < 0)
     140                 :            :                         return tmp;
     141                 :            :         }
     142                 :            : 
     143                 :          3 :         dev->in = usb_rcvbulkpipe (dev->udev,
     144                 :            :                         in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
     145                 :          3 :         dev->out = usb_sndbulkpipe (dev->udev,
     146                 :            :                         out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
     147                 :          3 :         dev->status = status;
     148                 :          3 :         return 0;
     149                 :            : }
     150                 :            : EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
     151                 :            : 
     152                 :          1 : int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
     153                 :            : {
     154                 :            :         int             tmp = -1, ret;
     155                 :            :         unsigned char   buf [13];
     156                 :            : 
     157                 :          1 :         ret = usb_string(dev->udev, iMACAddress, buf, sizeof buf);
     158                 :          1 :         if (ret == 12)
     159                 :          1 :                 tmp = hex2bin(dev->net->dev_addr, buf, 6);
     160                 :          1 :         if (tmp < 0) {
     161                 :            :                 dev_dbg(&dev->udev->dev,
     162                 :            :                         "bad MAC string %d fetch, %d\n", iMACAddress, tmp);
     163                 :          0 :                 if (ret >= 0)
     164                 :            :                         ret = -EINVAL;
     165                 :          0 :                 return ret;
     166                 :            :         }
     167                 :            :         return 0;
     168                 :            : }
     169                 :            : EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);
     170                 :            : 
     171                 :          2 : static void intr_complete (struct urb *urb)
     172                 :            : {
     173                 :          2 :         struct usbnet   *dev = urb->context;
     174                 :          2 :         int             status = urb->status;
     175                 :            : 
     176                 :          2 :         switch (status) {
     177                 :            :         /* success */
     178                 :            :         case 0:
     179                 :          2 :                 dev->driver_info->status(dev, urb);
     180                 :          2 :                 break;
     181                 :            : 
     182                 :            :         /* software-driven interface shutdown */
     183                 :            :         case -ENOENT:           /* urb killed */
     184                 :            :         case -ESHUTDOWN:        /* hardware gone */
     185                 :            :                 netif_dbg(dev, ifdown, dev->net,
     186                 :            :                           "intr shutdown, code %d\n", status);
     187                 :          2 :                 return;
     188                 :            : 
     189                 :            :         /* NOTE:  not throttling like RX/TX, since this endpoint
     190                 :            :          * already polls infrequently
     191                 :            :          */
     192                 :            :         default:
     193                 :            :                 netdev_dbg(dev->net, "intr status %d\n", status);
     194                 :            :                 break;
     195                 :            :         }
     196                 :            : 
     197                 :          2 :         status = usb_submit_urb (urb, GFP_ATOMIC);
     198                 :          2 :         if (status != 0)
     199                 :          0 :                 netif_err(dev, timer, dev->net,
     200                 :            :                           "intr resubmit --> %d\n", status);
     201                 :            : }
     202                 :            : 
     203                 :          3 : static int init_status (struct usbnet *dev, struct usb_interface *intf)
     204                 :            : {
     205                 :            :         char            *buf = NULL;
     206                 :            :         unsigned        pipe = 0;
     207                 :            :         unsigned        maxp;
     208                 :            :         unsigned        period;
     209                 :            : 
     210                 :          3 :         if (!dev->driver_info->status)
     211                 :            :                 return 0;
     212                 :            : 
     213                 :          3 :         pipe = usb_rcvintpipe (dev->udev,
     214                 :            :                         dev->status->desc.bEndpointAddress
     215                 :            :                                 & USB_ENDPOINT_NUMBER_MASK);
     216                 :          3 :         maxp = usb_maxpacket (dev->udev, pipe, 0);
     217                 :            : 
     218                 :            :         /* avoid 1 msec chatter:  min 8 msec poll rate */
     219                 :          3 :         period = max ((int) dev->status->desc.bInterval,
     220                 :            :                 (dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3);
     221                 :            : 
     222                 :            :         buf = kmalloc (maxp, GFP_KERNEL);
     223                 :          3 :         if (buf) {
     224                 :          3 :                 dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);
     225                 :          3 :                 if (!dev->interrupt) {
     226                 :          0 :                         kfree (buf);
     227                 :          0 :                         return -ENOMEM;
     228                 :            :                 } else {
     229                 :          3 :                         usb_fill_int_urb(dev->interrupt, dev->udev, pipe,
     230                 :            :                                 buf, maxp, intr_complete, dev, period);
     231                 :          3 :                         dev->interrupt->transfer_flags |= URB_FREE_BUFFER;
     232                 :            :                         dev_dbg(&intf->dev,
     233                 :            :                                 "status ep%din, %d bytes period %d\n",
     234                 :            :                                 usb_pipeendpoint(pipe), maxp, period);
     235                 :            :                 }
     236                 :            :         }
     237                 :            :         return 0;
     238                 :            : }
     239                 :            : 
     240                 :            : /* Submit the interrupt URB if not previously submitted, increasing refcount */
     241                 :          3 : int usbnet_status_start(struct usbnet *dev, gfp_t mem_flags)
     242                 :            : {
     243                 :            :         int ret = 0;
     244                 :            : 
     245                 :          3 :         WARN_ON_ONCE(dev->interrupt == NULL);
     246                 :          3 :         if (dev->interrupt) {
     247                 :          3 :                 mutex_lock(&dev->interrupt_mutex);
     248                 :            : 
     249                 :          3 :                 if (++dev->interrupt_count == 1)
     250                 :          3 :                         ret = usb_submit_urb(dev->interrupt, mem_flags);
     251                 :            : 
     252                 :            :                 dev_dbg(&dev->udev->dev, "incremented interrupt URB count to %d\n",
     253                 :            :                         dev->interrupt_count);
     254                 :          3 :                 mutex_unlock(&dev->interrupt_mutex);
     255                 :            :         }
     256                 :          3 :         return ret;
     257                 :            : }
     258                 :            : EXPORT_SYMBOL_GPL(usbnet_status_start);
     259                 :            : 
     260                 :            : /* For resume; submit interrupt URB if previously submitted */
     261                 :          0 : static int __usbnet_status_start_force(struct usbnet *dev, gfp_t mem_flags)
     262                 :            : {
     263                 :            :         int ret = 0;
     264                 :            : 
     265                 :          0 :         mutex_lock(&dev->interrupt_mutex);
     266                 :          0 :         if (dev->interrupt_count) {
     267                 :          0 :                 ret = usb_submit_urb(dev->interrupt, mem_flags);
     268                 :            :                 dev_dbg(&dev->udev->dev,
     269                 :            :                         "submitted interrupt URB for resume\n");
     270                 :            :         }
     271                 :          0 :         mutex_unlock(&dev->interrupt_mutex);
     272                 :          0 :         return ret;
     273                 :            : }
     274                 :            : 
     275                 :            : /* Kill the interrupt URB if all submitters want it killed */
     276                 :          0 : void usbnet_status_stop(struct usbnet *dev)
     277                 :            : {
     278                 :          0 :         if (dev->interrupt) {
     279                 :          0 :                 mutex_lock(&dev->interrupt_mutex);
     280                 :          0 :                 WARN_ON(dev->interrupt_count == 0);
     281                 :            : 
     282                 :          0 :                 if (dev->interrupt_count && --dev->interrupt_count == 0)
     283                 :          0 :                         usb_kill_urb(dev->interrupt);
     284                 :            : 
     285                 :            :                 dev_dbg(&dev->udev->dev,
     286                 :            :                         "decremented interrupt URB count to %d\n",
     287                 :            :                         dev->interrupt_count);
     288                 :          0 :                 mutex_unlock(&dev->interrupt_mutex);
     289                 :            :         }
     290                 :          0 : }
     291                 :            : EXPORT_SYMBOL_GPL(usbnet_status_stop);
     292                 :            : 
     293                 :            : /* For suspend; always kill interrupt URB */
     294                 :          0 : static void __usbnet_status_stop_force(struct usbnet *dev)
     295                 :            : {
     296                 :          0 :         if (dev->interrupt) {
     297                 :          0 :                 mutex_lock(&dev->interrupt_mutex);
     298                 :          0 :                 usb_kill_urb(dev->interrupt);
     299                 :            :                 dev_dbg(&dev->udev->dev, "killed interrupt URB for suspend\n");
     300                 :          0 :                 mutex_unlock(&dev->interrupt_mutex);
     301                 :            :         }
     302                 :          0 : }
     303                 :            : 
     304                 :            : /* Passes this packet up the stack, updating its accounting.
     305                 :            :  * Some link protocols batch packets, so their rx_fixup paths
     306                 :            :  * can return clones as well as just modify the original skb.
     307                 :            :  */
     308                 :          3 : void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
     309                 :            : {
     310                 :          3 :         struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->stats64);
     311                 :            :         unsigned long flags;
     312                 :            :         int     status;
     313                 :            : 
     314                 :          3 :         if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
     315                 :          0 :                 skb_queue_tail(&dev->rxq_pause, skb);
     316                 :          0 :                 return;
     317                 :            :         }
     318                 :            : 
     319                 :            :         /* only update if unset to allow minidriver rx_fixup override */
     320                 :          3 :         if (skb->protocol == 0)
     321                 :          3 :                 skb->protocol = eth_type_trans (skb, dev->net);
     322                 :            : 
     323                 :            :         flags = u64_stats_update_begin_irqsave(&stats64->syncp);
     324                 :          3 :         stats64->rx_packets++;
     325                 :          3 :         stats64->rx_bytes += skb->len;
     326                 :          3 :         u64_stats_update_end_irqrestore(&stats64->syncp, flags);
     327                 :            : 
     328                 :            :         netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
     329                 :            :                   skb->len + sizeof (struct ethhdr), skb->protocol);
     330                 :          3 :         memset (skb->cb, 0, sizeof (struct skb_data));
     331                 :            : 
     332                 :            :         if (skb_defer_rx_timestamp(skb))
     333                 :            :                 return;
     334                 :            : 
     335                 :          3 :         status = netif_rx (skb);
     336                 :            :         if (status != NET_RX_SUCCESS)
     337                 :            :                 netif_dbg(dev, rx_err, dev->net,
     338                 :            :                           "netif_rx status %d\n", status);
     339                 :            : }
     340                 :            : EXPORT_SYMBOL_GPL(usbnet_skb_return);
     341                 :            : 
     342                 :            : /* must be called if hard_mtu or rx_urb_size changed */
     343                 :          3 : void usbnet_update_max_qlen(struct usbnet *dev)
     344                 :            : {
     345                 :          3 :         enum usb_device_speed speed = dev->udev->speed;
     346                 :            : 
     347                 :          3 :         if (!dev->rx_urb_size || !dev->hard_mtu)
     348                 :            :                 goto insanity;
     349                 :          3 :         switch (speed) {
     350                 :            :         case USB_SPEED_HIGH:
     351                 :          2 :                 dev->rx_qlen = MAX_QUEUE_MEMORY / dev->rx_urb_size;
     352                 :          2 :                 dev->tx_qlen = MAX_QUEUE_MEMORY / dev->hard_mtu;
     353                 :          2 :                 break;
     354                 :            :         case USB_SPEED_SUPER:
     355                 :            :         case USB_SPEED_SUPER_PLUS:
     356                 :            :                 /*
     357                 :            :                  * Not take default 5ms qlen for super speed HC to
     358                 :            :                  * save memory, and iperf tests show 2.5ms qlen can
     359                 :            :                  * work well
     360                 :            :                  */
     361                 :          0 :                 dev->rx_qlen = 5 * MAX_QUEUE_MEMORY / dev->rx_urb_size;
     362                 :          0 :                 dev->tx_qlen = 5 * MAX_QUEUE_MEMORY / dev->hard_mtu;
     363                 :          0 :                 break;
     364                 :            :         default:
     365                 :            : insanity:
     366                 :          1 :                 dev->rx_qlen = dev->tx_qlen = 4;
     367                 :            :         }
     368                 :          3 : }
     369                 :            : EXPORT_SYMBOL_GPL(usbnet_update_max_qlen);
     370                 :            : 
     371                 :            : 
     372                 :            : /*-------------------------------------------------------------------------
     373                 :            :  *
     374                 :            :  * Network Device Driver (peer link to "Host Device", from USB host)
     375                 :            :  *
     376                 :            :  *-------------------------------------------------------------------------*/
     377                 :            : 
     378                 :          0 : int usbnet_change_mtu (struct net_device *net, int new_mtu)
     379                 :            : {
     380                 :            :         struct usbnet   *dev = netdev_priv(net);
     381                 :          0 :         int             ll_mtu = new_mtu + net->hard_header_len;
     382                 :          0 :         int             old_hard_mtu = dev->hard_mtu;
     383                 :          0 :         int             old_rx_urb_size = dev->rx_urb_size;
     384                 :            : 
     385                 :            :         // no second zero-length packet read wanted after mtu-sized packets
     386                 :          0 :         if ((ll_mtu % dev->maxpacket) == 0)
     387                 :            :                 return -EDOM;
     388                 :          0 :         net->mtu = new_mtu;
     389                 :            : 
     390                 :          0 :         dev->hard_mtu = net->mtu + net->hard_header_len;
     391                 :          0 :         if (dev->rx_urb_size == old_hard_mtu) {
     392                 :          0 :                 dev->rx_urb_size = dev->hard_mtu;
     393                 :          0 :                 if (dev->rx_urb_size > old_rx_urb_size) {
     394                 :            :                         usbnet_pause_rx(dev);
     395                 :          0 :                         usbnet_unlink_rx_urbs(dev);
     396                 :          0 :                         usbnet_resume_rx(dev);
     397                 :            :                 }
     398                 :            :         }
     399                 :            : 
     400                 :            :         /* max qlen depend on hard_mtu and rx_urb_size */
     401                 :          0 :         usbnet_update_max_qlen(dev);
     402                 :            : 
     403                 :          0 :         return 0;
     404                 :            : }
     405                 :            : EXPORT_SYMBOL_GPL(usbnet_change_mtu);
     406                 :            : 
     407                 :            : /* The caller must hold list->lock */
     408                 :            : static void __usbnet_queue_skb(struct sk_buff_head *list,
     409                 :            :                         struct sk_buff *newsk, enum skb_state state)
     410                 :            : {
     411                 :            :         struct skb_data *entry = (struct skb_data *) newsk->cb;
     412                 :            : 
     413                 :            :         __skb_queue_tail(list, newsk);
     414                 :          3 :         entry->state = state;
     415                 :            : }
     416                 :            : 
     417                 :            : /*-------------------------------------------------------------------------*/
     418                 :            : 
     419                 :            : /* some LK 2.4 HCDs oopsed if we freed or resubmitted urbs from
     420                 :            :  * completion callbacks.  2.5 should have fixed those bugs...
     421                 :            :  */
     422                 :            : 
     423                 :          3 : static enum skb_state defer_bh(struct usbnet *dev, struct sk_buff *skb,
     424                 :            :                 struct sk_buff_head *list, enum skb_state state)
     425                 :            : {
     426                 :            :         unsigned long           flags;
     427                 :            :         enum skb_state          old_state;
     428                 :            :         struct skb_data *entry = (struct skb_data *) skb->cb;
     429                 :            : 
     430                 :          3 :         spin_lock_irqsave(&list->lock, flags);
     431                 :          3 :         old_state = entry->state;
     432                 :          3 :         entry->state = state;
     433                 :            :         __skb_unlink(skb, list);
     434                 :            : 
     435                 :            :         /* defer_bh() is never called with list == &dev->done.
     436                 :            :          * spin_lock_nested() tells lockdep that it is OK to take
     437                 :            :          * dev->done.lock here with list->lock held.
     438                 :            :          */
     439                 :          3 :         spin_lock_nested(&dev->done.lock, SINGLE_DEPTH_NESTING);
     440                 :            : 
     441                 :          3 :         __skb_queue_tail(&dev->done, skb);
     442                 :          3 :         if (dev->done.qlen == 1)
     443                 :          3 :                 tasklet_schedule(&dev->bh);
     444                 :            :         spin_unlock(&dev->done.lock);
     445                 :            :         spin_unlock_irqrestore(&list->lock, flags);
     446                 :          3 :         return old_state;
     447                 :            : }
     448                 :            : 
     449                 :            : /* some work can't be done in tasklets, so we use keventd
     450                 :            :  *
     451                 :            :  * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,
     452                 :            :  * but tasklet_schedule() doesn't.  hope the failure is rare.
     453                 :            :  */
     454                 :          3 : void usbnet_defer_kevent (struct usbnet *dev, int work)
     455                 :            : {
     456                 :          3 :         set_bit (work, &dev->flags);
     457                 :          3 :         if (!schedule_work (&dev->kevent))
     458                 :            :                 netdev_dbg(dev->net, "kevent %d may have been dropped\n", work);
     459                 :            :         else
     460                 :            :                 netdev_dbg(dev->net, "kevent %d scheduled\n", work);
     461                 :          3 : }
     462                 :            : EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
     463                 :            : 
     464                 :            : /*-------------------------------------------------------------------------*/
     465                 :            : 
     466                 :            : static void rx_complete (struct urb *urb);
     467                 :            : 
     468                 :          3 : static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
     469                 :            : {
     470                 :            :         struct sk_buff          *skb;
     471                 :            :         struct skb_data         *entry;
     472                 :            :         int                     retval = 0;
     473                 :            :         unsigned long           lockflags;
     474                 :          3 :         size_t                  size = dev->rx_urb_size;
     475                 :            : 
     476                 :            :         /* prevent rx skb allocation when error ratio is high */
     477                 :          3 :         if (test_bit(EVENT_RX_KILL, &dev->flags)) {
     478                 :          0 :                 usb_free_urb(urb);
     479                 :          0 :                 return -ENOLINK;
     480                 :            :         }
     481                 :            : 
     482                 :          3 :         if (test_bit(EVENT_NO_IP_ALIGN, &dev->flags))
     483                 :          2 :                 skb = __netdev_alloc_skb(dev->net, size, flags);
     484                 :            :         else
     485                 :          1 :                 skb = __netdev_alloc_skb_ip_align(dev->net, size, flags);
     486                 :          3 :         if (!skb) {
     487                 :            :                 netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
     488                 :          0 :                 usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
     489                 :          0 :                 usb_free_urb (urb);
     490                 :          0 :                 return -ENOMEM;
     491                 :            :         }
     492                 :            : 
     493                 :            :         entry = (struct skb_data *) skb->cb;
     494                 :          3 :         entry->urb = urb;
     495                 :          3 :         entry->dev = dev;
     496                 :          3 :         entry->length = 0;
     497                 :            : 
     498                 :          3 :         usb_fill_bulk_urb (urb, dev->udev, dev->in,
     499                 :          3 :                 skb->data, size, rx_complete, skb);
     500                 :            : 
     501                 :          3 :         spin_lock_irqsave (&dev->rxq.lock, lockflags);
     502                 :            : 
     503                 :          3 :         if (netif_running (dev->net) &&
     504                 :          3 :             netif_device_present (dev->net) &&
     505                 :          3 :             test_bit(EVENT_DEV_OPEN, &dev->flags) &&
     506                 :          3 :             !test_bit (EVENT_RX_HALT, &dev->flags) &&
     507                 :            :             !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {
     508                 :          3 :                 switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {
     509                 :            :                 case -EPIPE:
     510                 :          0 :                         usbnet_defer_kevent (dev, EVENT_RX_HALT);
     511                 :          0 :                         break;
     512                 :            :                 case -ENOMEM:
     513                 :          0 :                         usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
     514                 :          0 :                         break;
     515                 :            :                 case -ENODEV:
     516                 :            :                         netif_dbg(dev, ifdown, dev->net, "device gone\n");
     517                 :          0 :                         netif_device_detach (dev->net);
     518                 :          0 :                         break;
     519                 :            :                 case -EHOSTUNREACH:
     520                 :            :                         retval = -ENOLINK;
     521                 :            :                         break;
     522                 :            :                 default:
     523                 :            :                         netif_dbg(dev, rx_err, dev->net,
     524                 :            :                                   "rx submit, %d\n", retval);
     525                 :          0 :                         tasklet_schedule (&dev->bh);
     526                 :          0 :                         break;
     527                 :            :                 case 0:
     528                 :          3 :                         __usbnet_queue_skb(&dev->rxq, skb, rx_start);
     529                 :            :                 }
     530                 :            :         } else {
     531                 :            :                 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
     532                 :            :                 retval = -ENOLINK;
     533                 :            :         }
     534                 :            :         spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
     535                 :          3 :         if (retval) {
     536                 :            :                 dev_kfree_skb_any (skb);
     537                 :          0 :                 usb_free_urb (urb);
     538                 :            :         }
     539                 :          3 :         return retval;
     540                 :            : }
     541                 :            : 
     542                 :            : 
     543                 :            : /*-------------------------------------------------------------------------*/
     544                 :            : 
     545                 :          3 : static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
     546                 :            : {
     547                 :          3 :         if (dev->driver_info->rx_fixup &&
     548                 :          2 :             !dev->driver_info->rx_fixup (dev, skb)) {
     549                 :            :                 /* With RX_ASSEMBLE, rx_fixup() must update counters */
     550                 :          0 :                 if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE))
     551                 :          0 :                         dev->net->stats.rx_errors++;
     552                 :            :                 goto done;
     553                 :            :         }
     554                 :            :         // else network stack removes extra byte if we forced a short packet
     555                 :            : 
     556                 :            :         /* all data was already cloned from skb inside the driver */
     557                 :          3 :         if (dev->driver_info->flags & FLAG_MULTI_PACKET)
     558                 :            :                 goto done;
     559                 :            : 
     560                 :          3 :         if (skb->len < ETH_HLEN) {
     561                 :          0 :                 dev->net->stats.rx_errors++;
     562                 :          0 :                 dev->net->stats.rx_length_errors++;
     563                 :            :                 netif_dbg(dev, rx_err, dev->net, "rx length %d\n", skb->len);
     564                 :            :         } else {
     565                 :          3 :                 usbnet_skb_return(dev, skb);
     566                 :          3 :                 return;
     567                 :            :         }
     568                 :            : 
     569                 :            : done:
     570                 :          0 :         skb_queue_tail(&dev->done, skb);
     571                 :            : }
     572                 :            : 
     573                 :            : /*-------------------------------------------------------------------------*/
     574                 :            : 
     575                 :          3 : static void rx_complete (struct urb *urb)
     576                 :            : {
     577                 :          3 :         struct sk_buff          *skb = (struct sk_buff *) urb->context;
     578                 :            :         struct skb_data         *entry = (struct skb_data *) skb->cb;
     579                 :          3 :         struct usbnet           *dev = entry->dev;
     580                 :          3 :         int                     urb_status = urb->status;
     581                 :            :         enum skb_state          state;
     582                 :            : 
     583                 :          3 :         skb_put (skb, urb->actual_length);
     584                 :            :         state = rx_done;
     585                 :          3 :         entry->urb = NULL;
     586                 :            : 
     587                 :          3 :         switch (urb_status) {
     588                 :            :         /* success */
     589                 :            :         case 0:
     590                 :            :                 break;
     591                 :            : 
     592                 :            :         /* stalls need manual reset. this is rare ... except that
     593                 :            :          * when going through USB 2.0 TTs, unplug appears this way.
     594                 :            :          * we avoid the highspeed version of the ETIMEDOUT/EILSEQ
     595                 :            :          * storm, recovering as needed.
     596                 :            :          */
     597                 :            :         case -EPIPE:
     598                 :          0 :                 dev->net->stats.rx_errors++;
     599                 :          0 :                 usbnet_defer_kevent (dev, EVENT_RX_HALT);
     600                 :            :                 // FALLTHROUGH
     601                 :            : 
     602                 :            :         /* software-driven interface shutdown */
     603                 :            :         case -ECONNRESET:               /* async unlink */
     604                 :            :         case -ESHUTDOWN:                /* hardware gone */
     605                 :            :                 netif_dbg(dev, ifdown, dev->net,
     606                 :            :                           "rx shutdown, code %d\n", urb_status);
     607                 :            :                 goto block;
     608                 :            : 
     609                 :            :         /* we get controller i/o faults during hub_wq disconnect() delays.
     610                 :            :          * throttle down resubmits, to avoid log floods; just temporarily,
     611                 :            :          * so we still recover when the fault isn't a hub_wq delay.
     612                 :            :          */
     613                 :            :         case -EPROTO:
     614                 :            :         case -ETIME:
     615                 :            :         case -EILSEQ:
     616                 :          0 :                 dev->net->stats.rx_errors++;
     617                 :          0 :                 if (!timer_pending (&dev->delay)) {
     618                 :          0 :                         mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
     619                 :            :                         netif_dbg(dev, link, dev->net,
     620                 :            :                                   "rx throttle %d\n", urb_status);
     621                 :            :                 }
     622                 :            : block:
     623                 :            :                 state = rx_cleanup;
     624                 :          2 :                 entry->urb = urb;
     625                 :            :                 urb = NULL;
     626                 :          2 :                 break;
     627                 :            : 
     628                 :            :         /* data overrun ... flush fifo? */
     629                 :            :         case -EOVERFLOW:
     630                 :          0 :                 dev->net->stats.rx_over_errors++;
     631                 :            :                 // FALLTHROUGH
     632                 :            : 
     633                 :            :         default:
     634                 :            :                 state = rx_cleanup;
     635                 :          0 :                 dev->net->stats.rx_errors++;
     636                 :            :                 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
     637                 :          0 :                 break;
     638                 :            :         }
     639                 :            : 
     640                 :            :         /* stop rx if packet error rate is high */
     641                 :          3 :         if (++dev->pkt_cnt > 30) {
     642                 :          3 :                 dev->pkt_cnt = 0;
     643                 :          3 :                 dev->pkt_err = 0;
     644                 :            :         } else {
     645                 :          3 :                 if (state == rx_cleanup)
     646                 :          2 :                         dev->pkt_err++;
     647                 :          3 :                 if (dev->pkt_err > 20)
     648                 :          2 :                         set_bit(EVENT_RX_KILL, &dev->flags);
     649                 :            :         }
     650                 :            : 
     651                 :          3 :         state = defer_bh(dev, skb, &dev->rxq, state);
     652                 :            : 
     653                 :          3 :         if (urb) {
     654                 :          3 :                 if (netif_running (dev->net) &&
     655                 :          3 :                     !test_bit (EVENT_RX_HALT, &dev->flags) &&
     656                 :            :                     state != unlink_start) {
     657                 :          3 :                         rx_submit (dev, urb, GFP_ATOMIC);
     658                 :          3 :                         usb_mark_last_busy(dev->udev);
     659                 :          3 :                         return;
     660                 :            :                 }
     661                 :          0 :                 usb_free_urb (urb);
     662                 :            :         }
     663                 :            :         netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
     664                 :            : }
     665                 :            : 
     666                 :            : /*-------------------------------------------------------------------------*/
     667                 :          0 : void usbnet_pause_rx(struct usbnet *dev)
     668                 :            : {
     669                 :          0 :         set_bit(EVENT_RX_PAUSED, &dev->flags);
     670                 :            : 
     671                 :            :         netif_dbg(dev, rx_status, dev->net, "paused rx queue enabled\n");
     672                 :          0 : }
     673                 :            : EXPORT_SYMBOL_GPL(usbnet_pause_rx);
     674                 :            : 
     675                 :          0 : void usbnet_resume_rx(struct usbnet *dev)
     676                 :            : {
     677                 :            :         struct sk_buff *skb;
     678                 :            :         int num = 0;
     679                 :            : 
     680                 :          0 :         clear_bit(EVENT_RX_PAUSED, &dev->flags);
     681                 :            : 
     682                 :          0 :         while ((skb = skb_dequeue(&dev->rxq_pause)) != NULL) {
     683                 :          0 :                 usbnet_skb_return(dev, skb);
     684                 :            :                 num++;
     685                 :            :         }
     686                 :            : 
     687                 :          0 :         tasklet_schedule(&dev->bh);
     688                 :            : 
     689                 :            :         netif_dbg(dev, rx_status, dev->net,
     690                 :            :                   "paused rx queue disabled, %d skbs requeued\n", num);
     691                 :          0 : }
     692                 :            : EXPORT_SYMBOL_GPL(usbnet_resume_rx);
     693                 :            : 
     694                 :          0 : void usbnet_purge_paused_rxq(struct usbnet *dev)
     695                 :            : {
     696                 :          0 :         skb_queue_purge(&dev->rxq_pause);
     697                 :          0 : }
     698                 :            : EXPORT_SYMBOL_GPL(usbnet_purge_paused_rxq);
     699                 :            : 
     700                 :            : /*-------------------------------------------------------------------------*/
     701                 :            : 
     702                 :            : // unlink pending rx/tx; completion handlers do all other cleanup
     703                 :            : 
     704                 :          2 : static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q)
     705                 :            : {
     706                 :            :         unsigned long           flags;
     707                 :            :         struct sk_buff          *skb;
     708                 :            :         int                     count = 0;
     709                 :            : 
     710                 :          2 :         spin_lock_irqsave (&q->lock, flags);
     711                 :          2 :         while (!skb_queue_empty(q)) {
     712                 :            :                 struct skb_data         *entry;
     713                 :            :                 struct urb              *urb;
     714                 :            :                 int                     retval;
     715                 :            : 
     716                 :          0 :                 skb_queue_walk(q, skb) {
     717                 :            :                         entry = (struct skb_data *) skb->cb;
     718                 :          2 :                         if (entry->state != unlink_start)
     719                 :            :                                 goto found;
     720                 :            :                 }
     721                 :            :                 break;
     722                 :            : found:
     723                 :          2 :                 entry->state = unlink_start;
     724                 :          2 :                 urb = entry->urb;
     725                 :            : 
     726                 :            :                 /*
     727                 :            :                  * Get reference count of the URB to avoid it to be
     728                 :            :                  * freed during usb_unlink_urb, which may trigger
     729                 :            :                  * use-after-free problem inside usb_unlink_urb since
     730                 :            :                  * usb_unlink_urb is always racing with .complete
     731                 :            :                  * handler(include defer_bh).
     732                 :            :                  */
     733                 :          2 :                 usb_get_urb(urb);
     734                 :            :                 spin_unlock_irqrestore(&q->lock, flags);
     735                 :            :                 // during some PM-driven resume scenarios,
     736                 :            :                 // these (async) unlinks complete immediately
     737                 :          2 :                 retval = usb_unlink_urb (urb);
     738                 :          2 :                 if (retval != -EINPROGRESS && retval != 0)
     739                 :            :                         netdev_dbg(dev->net, "unlink urb err, %d\n", retval);
     740                 :            :                 else
     741                 :          2 :                         count++;
     742                 :          2 :                 usb_put_urb(urb);
     743                 :          2 :                 spin_lock_irqsave(&q->lock, flags);
     744                 :            :         }
     745                 :            :         spin_unlock_irqrestore (&q->lock, flags);
     746                 :          2 :         return count;
     747                 :            : }
     748                 :            : 
     749                 :            : // Flush all pending rx urbs
     750                 :            : // minidrivers may need to do this when the MTU changes
     751                 :            : 
     752                 :          0 : void usbnet_unlink_rx_urbs(struct usbnet *dev)
     753                 :            : {
     754                 :          0 :         if (netif_running(dev->net)) {
     755                 :          0 :                 (void) unlink_urbs (dev, &dev->rxq);
     756                 :          0 :                 tasklet_schedule(&dev->bh);
     757                 :            :         }
     758                 :          0 : }
     759                 :            : EXPORT_SYMBOL_GPL(usbnet_unlink_rx_urbs);
     760                 :            : 
     761                 :            : /*-------------------------------------------------------------------------*/
     762                 :            : 
     763                 :          0 : static void wait_skb_queue_empty(struct sk_buff_head *q)
     764                 :            : {
     765                 :            :         unsigned long flags;
     766                 :            : 
     767                 :          0 :         spin_lock_irqsave(&q->lock, flags);
     768                 :          0 :         while (!skb_queue_empty(q)) {
     769                 :            :                 spin_unlock_irqrestore(&q->lock, flags);
     770                 :          0 :                 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
     771                 :          0 :                 set_current_state(TASK_UNINTERRUPTIBLE);
     772                 :          0 :                 spin_lock_irqsave(&q->lock, flags);
     773                 :            :         }
     774                 :            :         spin_unlock_irqrestore(&q->lock, flags);
     775                 :          0 : }
     776                 :            : 
     777                 :            : // precondition: never called in_interrupt
     778                 :          0 : static void usbnet_terminate_urbs(struct usbnet *dev)
     779                 :            : {
     780                 :          0 :         DECLARE_WAITQUEUE(wait, current);
     781                 :            :         int temp;
     782                 :            : 
     783                 :            :         /* ensure there are no more active urbs */
     784                 :          0 :         add_wait_queue(&dev->wait, &wait);
     785                 :          0 :         set_current_state(TASK_UNINTERRUPTIBLE);
     786                 :          0 :         temp = unlink_urbs(dev, &dev->txq) +
     787                 :          0 :                 unlink_urbs(dev, &dev->rxq);
     788                 :            : 
     789                 :            :         /* maybe wait for deletions to finish. */
     790                 :          0 :         wait_skb_queue_empty(&dev->rxq);
     791                 :          0 :         wait_skb_queue_empty(&dev->txq);
     792                 :          0 :         wait_skb_queue_empty(&dev->done);
     793                 :            :         netif_dbg(dev, ifdown, dev->net,
     794                 :            :                   "waited for %d urb completions\n", temp);
     795                 :          0 :         set_current_state(TASK_RUNNING);
     796                 :          0 :         remove_wait_queue(&dev->wait, &wait);
     797                 :          0 : }
     798                 :            : 
     799                 :          0 : int usbnet_stop (struct net_device *net)
     800                 :            : {
     801                 :            :         struct usbnet           *dev = netdev_priv(net);
     802                 :          0 :         const struct driver_info *info = dev->driver_info;
     803                 :            :         int                     retval, pm, mpn;
     804                 :            : 
     805                 :          0 :         clear_bit(EVENT_DEV_OPEN, &dev->flags);
     806                 :            :         netif_stop_queue (net);
     807                 :            : 
     808                 :          0 :         netif_info(dev, ifdown, dev->net,
     809                 :            :                    "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
     810                 :            :                    net->stats.rx_packets, net->stats.tx_packets,
     811                 :            :                    net->stats.rx_errors, net->stats.tx_errors);
     812                 :            : 
     813                 :            :         /* to not race resume */
     814                 :          0 :         pm = usb_autopm_get_interface(dev->intf);
     815                 :            :         /* allow minidriver to stop correctly (wireless devices to turn off
     816                 :            :          * radio etc) */
     817                 :          0 :         if (info->stop) {
     818                 :          0 :                 retval = info->stop(dev);
     819                 :          0 :                 if (retval < 0)
     820                 :          0 :                         netif_info(dev, ifdown, dev->net,
     821                 :            :                                    "stop fail (%d) usbnet usb-%s-%s, %s\n",
     822                 :            :                                    retval,
     823                 :            :                                    dev->udev->bus->bus_name, dev->udev->devpath,
     824                 :            :                                    info->description);
     825                 :            :         }
     826                 :            : 
     827                 :          0 :         if (!(info->flags & FLAG_AVOID_UNLINK_URBS))
     828                 :          0 :                 usbnet_terminate_urbs(dev);
     829                 :            : 
     830                 :          0 :         usbnet_status_stop(dev);
     831                 :            : 
     832                 :            :         usbnet_purge_paused_rxq(dev);
     833                 :            : 
     834                 :          0 :         mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags);
     835                 :            : 
     836                 :            :         /* deferred work (task, timer, softirq) must also stop.
     837                 :            :          * can't flush_scheduled_work() until we drop rtnl (later),
     838                 :            :          * else workers could deadlock; so make workers a NOP.
     839                 :            :          */
     840                 :          0 :         dev->flags = 0;
     841                 :          0 :         del_timer_sync (&dev->delay);
     842                 :          0 :         tasklet_kill (&dev->bh);
     843                 :          0 :         if (!pm)
     844                 :          0 :                 usb_autopm_put_interface(dev->intf);
     845                 :            : 
     846                 :          0 :         if (info->manage_power && mpn)
     847                 :          0 :                 info->manage_power(dev, 0);
     848                 :            :         else
     849                 :          0 :                 usb_autopm_put_interface(dev->intf);
     850                 :            : 
     851                 :          0 :         return 0;
     852                 :            : }
     853                 :            : EXPORT_SYMBOL_GPL(usbnet_stop);
     854                 :            : 
     855                 :            : /*-------------------------------------------------------------------------*/
     856                 :            : 
     857                 :            : // posts reads, and enables write queuing
     858                 :            : 
     859                 :            : // precondition: never called in_interrupt
     860                 :            : 
     861                 :          3 : int usbnet_open (struct net_device *net)
     862                 :            : {
     863                 :            :         struct usbnet           *dev = netdev_priv(net);
     864                 :            :         int                     retval;
     865                 :          3 :         const struct driver_info *info = dev->driver_info;
     866                 :            : 
     867                 :          3 :         if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
     868                 :          0 :                 netif_info(dev, ifup, dev->net,
     869                 :            :                            "resumption fail (%d) usbnet usb-%s-%s, %s\n",
     870                 :            :                            retval,
     871                 :            :                            dev->udev->bus->bus_name,
     872                 :            :                            dev->udev->devpath,
     873                 :            :                            info->description);
     874                 :            :                 goto done_nopm;
     875                 :            :         }
     876                 :            : 
     877                 :            :         // put into "known safe" state
     878                 :          3 :         if (info->reset && (retval = info->reset (dev)) < 0) {
     879                 :          0 :                 netif_info(dev, ifup, dev->net,
     880                 :            :                            "open reset fail (%d) usbnet usb-%s-%s, %s\n",
     881                 :            :                            retval,
     882                 :            :                            dev->udev->bus->bus_name,
     883                 :            :                            dev->udev->devpath,
     884                 :            :                            info->description);
     885                 :            :                 goto done;
     886                 :            :         }
     887                 :            : 
     888                 :            :         /* hard_mtu or rx_urb_size may change in reset() */
     889                 :          3 :         usbnet_update_max_qlen(dev);
     890                 :            : 
     891                 :            :         // insist peer be connected
     892                 :          3 :         if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
     893                 :            :                 netif_dbg(dev, ifup, dev->net, "can't open; %d\n", retval);
     894                 :            :                 goto done;
     895                 :            :         }
     896                 :            : 
     897                 :            :         /* start any status interrupt transfer */
     898                 :          3 :         if (dev->interrupt) {
     899                 :          3 :                 retval = usbnet_status_start(dev, GFP_KERNEL);
     900                 :          3 :                 if (retval < 0) {
     901                 :          0 :                         netif_err(dev, ifup, dev->net,
     902                 :            :                                   "intr submit %d\n", retval);
     903                 :            :                         goto done;
     904                 :            :                 }
     905                 :            :         }
     906                 :            : 
     907                 :          3 :         set_bit(EVENT_DEV_OPEN, &dev->flags);
     908                 :            :         netif_start_queue (net);
     909                 :          3 :         netif_info(dev, ifup, dev->net,
     910                 :            :                    "open: enable queueing (rx %d, tx %d) mtu %d %s framing\n",
     911                 :            :                    (int)RX_QLEN(dev), (int)TX_QLEN(dev),
     912                 :            :                    dev->net->mtu,
     913                 :            :                    (dev->driver_info->flags & FLAG_FRAMING_NC) ? "NetChip" :
     914                 :            :                    (dev->driver_info->flags & FLAG_FRAMING_GL) ? "GeneSys" :
     915                 :            :                    (dev->driver_info->flags & FLAG_FRAMING_Z) ? "Zaurus" :
     916                 :            :                    (dev->driver_info->flags & FLAG_FRAMING_RN) ? "RNDIS" :
     917                 :            :                    (dev->driver_info->flags & FLAG_FRAMING_AX) ? "ASIX" :
     918                 :            :                    "simple");
     919                 :            : 
     920                 :            :         /* reset rx error state */
     921                 :          3 :         dev->pkt_cnt = 0;
     922                 :          3 :         dev->pkt_err = 0;
     923                 :          3 :         clear_bit(EVENT_RX_KILL, &dev->flags);
     924                 :            : 
     925                 :            :         // delay posting reads until we're fully open
     926                 :          3 :         tasklet_schedule (&dev->bh);
     927                 :          3 :         if (info->manage_power) {
     928                 :          3 :                 retval = info->manage_power(dev, 1);
     929                 :          3 :                 if (retval < 0) {
     930                 :            :                         retval = 0;
     931                 :          0 :                         set_bit(EVENT_NO_RUNTIME_PM, &dev->flags);
     932                 :            :                 } else {
     933                 :          3 :                         usb_autopm_put_interface(dev->intf);
     934                 :            :                 }
     935                 :            :         }
     936                 :          3 :         return retval;
     937                 :            : done:
     938                 :          0 :         usb_autopm_put_interface(dev->intf);
     939                 :            : done_nopm:
     940                 :          0 :         return retval;
     941                 :            : }
     942                 :            : EXPORT_SYMBOL_GPL(usbnet_open);
     943                 :            : 
     944                 :            : /*-------------------------------------------------------------------------*/
     945                 :            : 
     946                 :            : /* ethtool methods; minidrivers may need to add some more, but
     947                 :            :  * they'll probably want to use this base set.
     948                 :            :  */
     949                 :            : 
     950                 :          1 : int usbnet_get_link_ksettings(struct net_device *net,
     951                 :            :                               struct ethtool_link_ksettings *cmd)
     952                 :            : {
     953                 :            :         struct usbnet *dev = netdev_priv(net);
     954                 :            : 
     955                 :          1 :         if (!dev->mii.mdio_read)
     956                 :            :                 return -EOPNOTSUPP;
     957                 :            : 
     958                 :          0 :         mii_ethtool_get_link_ksettings(&dev->mii, cmd);
     959                 :            : 
     960                 :          0 :         return 0;
     961                 :            : }
     962                 :            : EXPORT_SYMBOL_GPL(usbnet_get_link_ksettings);
     963                 :            : 
     964                 :          0 : int usbnet_set_link_ksettings(struct net_device *net,
     965                 :            :                               const struct ethtool_link_ksettings *cmd)
     966                 :            : {
     967                 :            :         struct usbnet *dev = netdev_priv(net);
     968                 :            :         int retval;
     969                 :            : 
     970                 :          0 :         if (!dev->mii.mdio_write)
     971                 :            :                 return -EOPNOTSUPP;
     972                 :            : 
     973                 :          0 :         retval = mii_ethtool_set_link_ksettings(&dev->mii, cmd);
     974                 :            : 
     975                 :            :         /* link speed/duplex might have changed */
     976                 :          0 :         if (dev->driver_info->link_reset)
     977                 :          0 :                 dev->driver_info->link_reset(dev);
     978                 :            : 
     979                 :            :         /* hard_mtu or rx_urb_size may change in link_reset() */
     980                 :          0 :         usbnet_update_max_qlen(dev);
     981                 :            : 
     982                 :          0 :         return retval;
     983                 :            : }
     984                 :            : EXPORT_SYMBOL_GPL(usbnet_set_link_ksettings);
     985                 :            : 
     986                 :          3 : void usbnet_get_stats64(struct net_device *net, struct rtnl_link_stats64 *stats)
     987                 :            : {
     988                 :            :         struct usbnet *dev = netdev_priv(net);
     989                 :            :         unsigned int start;
     990                 :            :         int cpu;
     991                 :            : 
     992                 :          3 :         netdev_stats_to_stats64(stats, &net->stats);
     993                 :            : 
     994                 :          3 :         for_each_possible_cpu(cpu) {
     995                 :            :                 struct pcpu_sw_netstats *stats64;
     996                 :            :                 u64 rx_packets, rx_bytes;
     997                 :            :                 u64 tx_packets, tx_bytes;
     998                 :            : 
     999                 :          3 :                 stats64 = per_cpu_ptr(dev->stats64, cpu);
    1000                 :            : 
    1001                 :            :                 do {
    1002                 :            :                         start = u64_stats_fetch_begin_irq(&stats64->syncp);
    1003                 :          3 :                         rx_packets = stats64->rx_packets;
    1004                 :          3 :                         rx_bytes = stats64->rx_bytes;
    1005                 :          3 :                         tx_packets = stats64->tx_packets;
    1006                 :          3 :                         tx_bytes = stats64->tx_bytes;
    1007                 :          3 :                 } while (u64_stats_fetch_retry_irq(&stats64->syncp, start));
    1008                 :            : 
    1009                 :          3 :                 stats->rx_packets += rx_packets;
    1010                 :          3 :                 stats->rx_bytes += rx_bytes;
    1011                 :          3 :                 stats->tx_packets += tx_packets;
    1012                 :          3 :                 stats->tx_bytes += tx_bytes;
    1013                 :            :         }
    1014                 :          3 : }
    1015                 :            : EXPORT_SYMBOL_GPL(usbnet_get_stats64);
    1016                 :            : 
    1017                 :          0 : u32 usbnet_get_link (struct net_device *net)
    1018                 :            : {
    1019                 :            :         struct usbnet *dev = netdev_priv(net);
    1020                 :            : 
    1021                 :            :         /* If a check_connect is defined, return its result */
    1022                 :          0 :         if (dev->driver_info->check_connect)
    1023                 :          0 :                 return dev->driver_info->check_connect (dev) == 0;
    1024                 :            : 
    1025                 :            :         /* if the device has mii operations, use those */
    1026                 :          0 :         if (dev->mii.mdio_read)
    1027                 :          0 :                 return mii_link_ok(&dev->mii);
    1028                 :            : 
    1029                 :            :         /* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */
    1030                 :          0 :         return ethtool_op_get_link(net);
    1031                 :            : }
    1032                 :            : EXPORT_SYMBOL_GPL(usbnet_get_link);
    1033                 :            : 
    1034                 :          0 : int usbnet_nway_reset(struct net_device *net)
    1035                 :            : {
    1036                 :            :         struct usbnet *dev = netdev_priv(net);
    1037                 :            : 
    1038                 :          0 :         if (!dev->mii.mdio_write)
    1039                 :            :                 return -EOPNOTSUPP;
    1040                 :            : 
    1041                 :          0 :         return mii_nway_restart(&dev->mii);
    1042                 :            : }
    1043                 :            : EXPORT_SYMBOL_GPL(usbnet_nway_reset);
    1044                 :            : 
    1045                 :          3 : void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
    1046                 :            : {
    1047                 :            :         struct usbnet *dev = netdev_priv(net);
    1048                 :            : 
    1049                 :          3 :         strlcpy (info->driver, dev->driver_name, sizeof info->driver);
    1050                 :          3 :         strlcpy (info->version, DRIVER_VERSION, sizeof info->version);
    1051                 :          3 :         strlcpy (info->fw_version, dev->driver_info->description,
    1052                 :            :                 sizeof info->fw_version);
    1053                 :          3 :         usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
    1054                 :          3 : }
    1055                 :            : EXPORT_SYMBOL_GPL(usbnet_get_drvinfo);
    1056                 :            : 
    1057                 :          0 : u32 usbnet_get_msglevel (struct net_device *net)
    1058                 :            : {
    1059                 :            :         struct usbnet *dev = netdev_priv(net);
    1060                 :            : 
    1061                 :          0 :         return dev->msg_enable;
    1062                 :            : }
    1063                 :            : EXPORT_SYMBOL_GPL(usbnet_get_msglevel);
    1064                 :            : 
    1065                 :          0 : void usbnet_set_msglevel (struct net_device *net, u32 level)
    1066                 :            : {
    1067                 :            :         struct usbnet *dev = netdev_priv(net);
    1068                 :            : 
    1069                 :          0 :         dev->msg_enable = level;
    1070                 :          0 : }
    1071                 :            : EXPORT_SYMBOL_GPL(usbnet_set_msglevel);
    1072                 :            : 
    1073                 :            : /* drivers may override default ethtool_ops in their bind() routine */
    1074                 :            : static const struct ethtool_ops usbnet_ethtool_ops = {
    1075                 :            :         .get_link               = usbnet_get_link,
    1076                 :            :         .nway_reset             = usbnet_nway_reset,
    1077                 :            :         .get_drvinfo            = usbnet_get_drvinfo,
    1078                 :            :         .get_msglevel           = usbnet_get_msglevel,
    1079                 :            :         .set_msglevel           = usbnet_set_msglevel,
    1080                 :            :         .get_ts_info            = ethtool_op_get_ts_info,
    1081                 :            :         .get_link_ksettings     = usbnet_get_link_ksettings,
    1082                 :            :         .set_link_ksettings     = usbnet_set_link_ksettings,
    1083                 :            : };
    1084                 :            : 
    1085                 :            : /*-------------------------------------------------------------------------*/
    1086                 :            : 
    1087                 :          2 : static void __handle_link_change(struct usbnet *dev)
    1088                 :            : {
    1089                 :          2 :         if (!test_bit(EVENT_DEV_OPEN, &dev->flags))
    1090                 :          2 :                 return;
    1091                 :            : 
    1092                 :          2 :         if (!netif_carrier_ok(dev->net)) {
    1093                 :            :                 /* kill URBs for reading packets to save bus bandwidth */
    1094                 :          2 :                 unlink_urbs(dev, &dev->rxq);
    1095                 :            : 
    1096                 :            :                 /*
    1097                 :            :                  * tx_timeout will unlink URBs for sending packets and
    1098                 :            :                  * tx queue is stopped by netcore after link becomes off
    1099                 :            :                  */
    1100                 :            :         } else {
    1101                 :            :                 /* submitting URBs for reading packets */
    1102                 :          2 :                 tasklet_schedule(&dev->bh);
    1103                 :            :         }
    1104                 :            : 
    1105                 :            :         /* hard_mtu or rx_urb_size may change during link change */
    1106                 :          2 :         usbnet_update_max_qlen(dev);
    1107                 :            : 
    1108                 :          2 :         clear_bit(EVENT_LINK_CHANGE, &dev->flags);
    1109                 :            : }
    1110                 :            : 
    1111                 :          1 : static void usbnet_set_rx_mode(struct net_device *net)
    1112                 :            : {
    1113                 :            :         struct usbnet           *dev = netdev_priv(net);
    1114                 :            : 
    1115                 :          1 :         usbnet_defer_kevent(dev, EVENT_SET_RX_MODE);
    1116                 :          1 : }
    1117                 :            : 
    1118                 :          1 : static void __handle_set_rx_mode(struct usbnet *dev)
    1119                 :            : {
    1120                 :          1 :         if (dev->driver_info->set_rx_mode)
    1121                 :          1 :                 (dev->driver_info->set_rx_mode)(dev);
    1122                 :            : 
    1123                 :          1 :         clear_bit(EVENT_SET_RX_MODE, &dev->flags);
    1124                 :          1 : }
    1125                 :            : 
    1126                 :            : /* work that cannot be done in interrupt context uses keventd.
    1127                 :            :  *
    1128                 :            :  * NOTE:  with 2.5 we could do more of this using completion callbacks,
    1129                 :            :  * especially now that control transfers can be queued.
    1130                 :            :  */
    1131                 :            : static void
    1132                 :          3 : usbnet_deferred_kevent (struct work_struct *work)
    1133                 :            : {
    1134                 :            :         struct usbnet           *dev =
    1135                 :          3 :                 container_of(work, struct usbnet, kevent);
    1136                 :            :         int                     status;
    1137                 :            : 
    1138                 :            :         /* usb_clear_halt() needs a thread context */
    1139                 :          3 :         if (test_bit (EVENT_TX_HALT, &dev->flags)) {
    1140                 :          0 :                 unlink_urbs (dev, &dev->txq);
    1141                 :          0 :                 status = usb_autopm_get_interface(dev->intf);
    1142                 :          0 :                 if (status < 0)
    1143                 :            :                         goto fail_pipe;
    1144                 :          0 :                 status = usb_clear_halt (dev->udev, dev->out);
    1145                 :          0 :                 usb_autopm_put_interface(dev->intf);
    1146                 :          0 :                 if (status < 0 &&
    1147                 :          0 :                     status != -EPIPE &&
    1148                 :            :                     status != -ESHUTDOWN) {
    1149                 :          0 :                         if (netif_msg_tx_err (dev))
    1150                 :            : fail_pipe:
    1151                 :          0 :                                 netdev_err(dev->net, "can't clear tx halt, status %d\n",
    1152                 :            :                                            status);
    1153                 :            :                 } else {
    1154                 :          0 :                         clear_bit (EVENT_TX_HALT, &dev->flags);
    1155                 :          0 :                         if (status != -ESHUTDOWN)
    1156                 :          0 :                                 netif_wake_queue (dev->net);
    1157                 :            :                 }
    1158                 :            :         }
    1159                 :          3 :         if (test_bit (EVENT_RX_HALT, &dev->flags)) {
    1160                 :          0 :                 unlink_urbs (dev, &dev->rxq);
    1161                 :          0 :                 status = usb_autopm_get_interface(dev->intf);
    1162                 :          0 :                 if (status < 0)
    1163                 :            :                         goto fail_halt;
    1164                 :          0 :                 status = usb_clear_halt (dev->udev, dev->in);
    1165                 :          0 :                 usb_autopm_put_interface(dev->intf);
    1166                 :          0 :                 if (status < 0 &&
    1167                 :          0 :                     status != -EPIPE &&
    1168                 :            :                     status != -ESHUTDOWN) {
    1169                 :          0 :                         if (netif_msg_rx_err (dev))
    1170                 :            : fail_halt:
    1171                 :          0 :                                 netdev_err(dev->net, "can't clear rx halt, status %d\n",
    1172                 :            :                                            status);
    1173                 :            :                 } else {
    1174                 :          0 :                         clear_bit (EVENT_RX_HALT, &dev->flags);
    1175                 :          0 :                         tasklet_schedule (&dev->bh);
    1176                 :            :                 }
    1177                 :            :         }
    1178                 :            : 
    1179                 :            :         /* tasklet could resubmit itself forever if memory is tight */
    1180                 :          3 :         if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
    1181                 :            :                 struct urb      *urb = NULL;
    1182                 :            :                 int resched = 1;
    1183                 :            : 
    1184                 :          0 :                 if (netif_running (dev->net))
    1185                 :          0 :                         urb = usb_alloc_urb (0, GFP_KERNEL);
    1186                 :            :                 else
    1187                 :          0 :                         clear_bit (EVENT_RX_MEMORY, &dev->flags);
    1188                 :          0 :                 if (urb != NULL) {
    1189                 :          0 :                         clear_bit (EVENT_RX_MEMORY, &dev->flags);
    1190                 :          0 :                         status = usb_autopm_get_interface(dev->intf);
    1191                 :          0 :                         if (status < 0) {
    1192                 :          0 :                                 usb_free_urb(urb);
    1193                 :          0 :                                 goto fail_lowmem;
    1194                 :            :                         }
    1195                 :          0 :                         if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
    1196                 :            :                                 resched = 0;
    1197                 :          0 :                         usb_autopm_put_interface(dev->intf);
    1198                 :            : fail_lowmem:
    1199                 :          0 :                         if (resched)
    1200                 :          0 :                                 tasklet_schedule (&dev->bh);
    1201                 :            :                 }
    1202                 :            :         }
    1203                 :            : 
    1204                 :          3 :         if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
    1205                 :          2 :                 const struct driver_info *info = dev->driver_info;
    1206                 :            :                 int                     retval = 0;
    1207                 :            : 
    1208                 :          2 :                 clear_bit (EVENT_LINK_RESET, &dev->flags);
    1209                 :          2 :                 status = usb_autopm_get_interface(dev->intf);
    1210                 :          2 :                 if (status < 0)
    1211                 :            :                         goto skip_reset;
    1212                 :          2 :                 if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
    1213                 :          0 :                         usb_autopm_put_interface(dev->intf);
    1214                 :            : skip_reset:
    1215                 :          0 :                         netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s\n",
    1216                 :            :                                     retval,
    1217                 :          0 :                                     dev->udev->bus->bus_name,
    1218                 :          0 :                                     dev->udev->devpath,
    1219                 :            :                                     info->description);
    1220                 :            :                 } else {
    1221                 :          2 :                         usb_autopm_put_interface(dev->intf);
    1222                 :            :                 }
    1223                 :            : 
    1224                 :            :                 /* handle link change from link resetting */
    1225                 :          2 :                 __handle_link_change(dev);
    1226                 :            :         }
    1227                 :            : 
    1228                 :          3 :         if (test_bit (EVENT_LINK_CHANGE, &dev->flags))
    1229                 :          2 :                 __handle_link_change(dev);
    1230                 :            : 
    1231                 :          3 :         if (test_bit (EVENT_SET_RX_MODE, &dev->flags))
    1232                 :          1 :                 __handle_set_rx_mode(dev);
    1233                 :            : 
    1234                 :            : 
    1235                 :            :         if (dev->flags)
    1236                 :            :                 netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags);
    1237                 :          3 : }
    1238                 :            : 
    1239                 :            : /*-------------------------------------------------------------------------*/
    1240                 :            : 
    1241                 :          3 : static void tx_complete (struct urb *urb)
    1242                 :            : {
    1243                 :          3 :         struct sk_buff          *skb = (struct sk_buff *) urb->context;
    1244                 :            :         struct skb_data         *entry = (struct skb_data *) skb->cb;
    1245                 :          3 :         struct usbnet           *dev = entry->dev;
    1246                 :            : 
    1247                 :          3 :         if (urb->status == 0) {
    1248                 :          3 :                 struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->stats64);
    1249                 :            :                 unsigned long flags;
    1250                 :            : 
    1251                 :            :                 flags = u64_stats_update_begin_irqsave(&stats64->syncp);
    1252                 :          3 :                 stats64->tx_packets += entry->packets;
    1253                 :          3 :                 stats64->tx_bytes += entry->length;
    1254                 :          3 :                 u64_stats_update_end_irqrestore(&stats64->syncp, flags);
    1255                 :            :         } else {
    1256                 :          0 :                 dev->net->stats.tx_errors++;
    1257                 :            : 
    1258                 :          0 :                 switch (urb->status) {
    1259                 :            :                 case -EPIPE:
    1260                 :          0 :                         usbnet_defer_kevent (dev, EVENT_TX_HALT);
    1261                 :          0 :                         break;
    1262                 :            : 
    1263                 :            :                 /* software-driven interface shutdown */
    1264                 :            :                 case -ECONNRESET:               // async unlink
    1265                 :            :                 case -ESHUTDOWN:                // hardware gone
    1266                 :            :                         break;
    1267                 :            : 
    1268                 :            :                 /* like rx, tx gets controller i/o faults during hub_wq
    1269                 :            :                  * delays and so it uses the same throttling mechanism.
    1270                 :            :                  */
    1271                 :            :                 case -EPROTO:
    1272                 :            :                 case -ETIME:
    1273                 :            :                 case -EILSEQ:
    1274                 :          0 :                         usb_mark_last_busy(dev->udev);
    1275                 :          0 :                         if (!timer_pending (&dev->delay)) {
    1276                 :          0 :                                 mod_timer (&dev->delay,
    1277                 :            :                                         jiffies + THROTTLE_JIFFIES);
    1278                 :            :                                 netif_dbg(dev, link, dev->net,
    1279                 :            :                                           "tx throttle %d\n", urb->status);
    1280                 :            :                         }
    1281                 :          0 :                         netif_stop_queue (dev->net);
    1282                 :            :                         break;
    1283                 :            :                 default:
    1284                 :            :                         netif_dbg(dev, tx_err, dev->net,
    1285                 :            :                                   "tx err %d\n", entry->urb->status);
    1286                 :            :                         break;
    1287                 :            :                 }
    1288                 :            :         }
    1289                 :            : 
    1290                 :          3 :         usb_autopm_put_interface_async(dev->intf);
    1291                 :          3 :         (void) defer_bh(dev, skb, &dev->txq, tx_done);
    1292                 :          3 : }
    1293                 :            : 
    1294                 :            : /*-------------------------------------------------------------------------*/
    1295                 :            : 
    1296                 :          0 : void usbnet_tx_timeout (struct net_device *net)
    1297                 :            : {
    1298                 :            :         struct usbnet           *dev = netdev_priv(net);
    1299                 :            : 
    1300                 :          0 :         unlink_urbs (dev, &dev->txq);
    1301                 :          0 :         tasklet_schedule (&dev->bh);
    1302                 :            :         /* this needs to be handled individually because the generic layer
    1303                 :            :          * doesn't know what is sufficient and could not restore private
    1304                 :            :          * information if a remedy of an unconditional reset were used.
    1305                 :            :          */
    1306                 :          0 :         if (dev->driver_info->recover)
    1307                 :          0 :                 (dev->driver_info->recover)(dev);
    1308                 :          0 : }
    1309                 :            : EXPORT_SYMBOL_GPL(usbnet_tx_timeout);
    1310                 :            : 
    1311                 :            : /*-------------------------------------------------------------------------*/
    1312                 :            : 
    1313                 :          0 : static int build_dma_sg(const struct sk_buff *skb, struct urb *urb)
    1314                 :            : {
    1315                 :            :         unsigned num_sgs, total_len = 0;
    1316                 :            :         int i, s = 0;
    1317                 :            : 
    1318                 :          0 :         num_sgs = skb_shinfo(skb)->nr_frags + 1;
    1319                 :          0 :         if (num_sgs == 1)
    1320                 :            :                 return 0;
    1321                 :            : 
    1322                 :            :         /* reserve one for zero packet */
    1323                 :          0 :         urb->sg = kmalloc_array(num_sgs + 1, sizeof(struct scatterlist),
    1324                 :            :                                 GFP_ATOMIC);
    1325                 :          0 :         if (!urb->sg)
    1326                 :            :                 return -ENOMEM;
    1327                 :            : 
    1328                 :          0 :         urb->num_sgs = num_sgs;
    1329                 :          0 :         sg_init_table(urb->sg, urb->num_sgs + 1);
    1330                 :            : 
    1331                 :          0 :         sg_set_buf(&urb->sg[s++], skb->data, skb_headlen(skb));
    1332                 :            :         total_len += skb_headlen(skb);
    1333                 :            : 
    1334                 :          0 :         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
    1335                 :            :                 skb_frag_t *f = &skb_shinfo(skb)->frags[i];
    1336                 :            : 
    1337                 :          0 :                 total_len += skb_frag_size(f);
    1338                 :          0 :                 sg_set_page(&urb->sg[i + s], skb_frag_page(f), skb_frag_size(f),
    1339                 :            :                             skb_frag_off(f));
    1340                 :            :         }
    1341                 :          0 :         urb->transfer_buffer_length = total_len;
    1342                 :            : 
    1343                 :          0 :         return 1;
    1344                 :            : }
    1345                 :            : 
    1346                 :          3 : netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
    1347                 :            :                                      struct net_device *net)
    1348                 :            : {
    1349                 :            :         struct usbnet           *dev = netdev_priv(net);
    1350                 :            :         unsigned int                    length;
    1351                 :            :         struct urb              *urb = NULL;
    1352                 :            :         struct skb_data         *entry;
    1353                 :          3 :         const struct driver_info *info = dev->driver_info;
    1354                 :            :         unsigned long           flags;
    1355                 :            :         int retval;
    1356                 :            : 
    1357                 :          3 :         if (skb)
    1358                 :          3 :                 skb_tx_timestamp(skb);
    1359                 :            : 
    1360                 :            :         // some devices want funky USB-level framing, for
    1361                 :            :         // win32 driver (usually) and/or hardware quirks
    1362                 :          3 :         if (info->tx_fixup) {
    1363                 :          2 :                 skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
    1364                 :          2 :                 if (!skb) {
    1365                 :            :                         /* packet collected; minidriver waiting for more */
    1366                 :          0 :                         if (info->flags & FLAG_MULTI_PACKET)
    1367                 :            :                                 goto not_drop;
    1368                 :            :                         netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb\n");
    1369                 :            :                         goto drop;
    1370                 :            :                 }
    1371                 :            :         }
    1372                 :            : 
    1373                 :          3 :         if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {
    1374                 :            :                 netif_dbg(dev, tx_err, dev->net, "no urb\n");
    1375                 :            :                 goto drop;
    1376                 :            :         }
    1377                 :            : 
    1378                 :            :         entry = (struct skb_data *) skb->cb;
    1379                 :          3 :         entry->urb = urb;
    1380                 :          3 :         entry->dev = dev;
    1381                 :            : 
    1382                 :          3 :         usb_fill_bulk_urb (urb, dev->udev, dev->out,
    1383                 :          3 :                         skb->data, skb->len, tx_complete, skb);
    1384                 :          3 :         if (dev->can_dma_sg) {
    1385                 :          0 :                 if (build_dma_sg(skb, urb) < 0)
    1386                 :            :                         goto drop;
    1387                 :            :         }
    1388                 :          3 :         length = urb->transfer_buffer_length;
    1389                 :            : 
    1390                 :            :         /* don't assume the hardware handles USB_ZERO_PACKET
    1391                 :            :          * NOTE:  strictly conforming cdc-ether devices should expect
    1392                 :            :          * the ZLP here, but ignore the one-byte packet.
    1393                 :            :          * NOTE2: CDC NCM specification is different from CDC ECM when
    1394                 :            :          * handling ZLP/short packets, so cdc_ncm driver will make short
    1395                 :            :          * packet itself if needed.
    1396                 :            :          */
    1397                 :          3 :         if (length % dev->maxpacket == 0) {
    1398                 :          1 :                 if (!(info->flags & FLAG_SEND_ZLP)) {
    1399                 :          1 :                         if (!(info->flags & FLAG_MULTI_PACKET)) {
    1400                 :          1 :                                 length++;
    1401                 :          1 :                                 if (skb_tailroom(skb) && !urb->num_sgs) {
    1402                 :          1 :                                         skb->data[skb->len] = 0;
    1403                 :          1 :                                         __skb_put(skb, 1);
    1404                 :          0 :                                 } else if (urb->num_sgs)
    1405                 :          0 :                                         sg_set_buf(&urb->sg[urb->num_sgs++],
    1406                 :          0 :                                                         dev->padding_pkt, 1);
    1407                 :            :                         }
    1408                 :            :                 } else
    1409                 :          0 :                         urb->transfer_flags |= URB_ZERO_PACKET;
    1410                 :            :         }
    1411                 :          3 :         urb->transfer_buffer_length = length;
    1412                 :            : 
    1413                 :          3 :         if (info->flags & FLAG_MULTI_PACKET) {
    1414                 :            :                 /* Driver has set number of packets and a length delta.
    1415                 :            :                  * Calculate the complete length and ensure that it's
    1416                 :            :                  * positive.
    1417                 :            :                  */
    1418                 :          0 :                 entry->length += length;
    1419                 :          0 :                 if (WARN_ON_ONCE(entry->length <= 0))
    1420                 :          0 :                         entry->length = length;
    1421                 :            :         } else {
    1422                 :          3 :                 usbnet_set_skb_tx_stats(skb, 1, length);
    1423                 :            :         }
    1424                 :            : 
    1425                 :          3 :         spin_lock_irqsave(&dev->txq.lock, flags);
    1426                 :          3 :         retval = usb_autopm_get_interface_async(dev->intf);
    1427                 :          3 :         if (retval < 0) {
    1428                 :            :                 spin_unlock_irqrestore(&dev->txq.lock, flags);
    1429                 :            :                 goto drop;
    1430                 :            :         }
    1431                 :          3 :         if (netif_queue_stopped(net)) {
    1432                 :          0 :                 usb_autopm_put_interface_async(dev->intf);
    1433                 :            :                 spin_unlock_irqrestore(&dev->txq.lock, flags);
    1434                 :            :                 goto drop;
    1435                 :            :         }
    1436                 :            : 
    1437                 :            : #ifdef CONFIG_PM
    1438                 :            :         /* if this triggers the device is still a sleep */
    1439                 :          3 :         if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
    1440                 :            :                 /* transmission will be done in resume */
    1441                 :          0 :                 usb_anchor_urb(urb, &dev->deferred);
    1442                 :            :                 /* no use to process more packets */
    1443                 :            :                 netif_stop_queue(net);
    1444                 :          0 :                 usb_put_urb(urb);
    1445                 :            :                 spin_unlock_irqrestore(&dev->txq.lock, flags);
    1446                 :            :                 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
    1447                 :            :                 goto deferred;
    1448                 :            :         }
    1449                 :            : #endif
    1450                 :            : 
    1451                 :          3 :         switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {
    1452                 :            :         case -EPIPE:
    1453                 :            :                 netif_stop_queue (net);
    1454                 :          0 :                 usbnet_defer_kevent (dev, EVENT_TX_HALT);
    1455                 :          0 :                 usb_autopm_put_interface_async(dev->intf);
    1456                 :          0 :                 break;
    1457                 :            :         default:
    1458                 :          0 :                 usb_autopm_put_interface_async(dev->intf);
    1459                 :            :                 netif_dbg(dev, tx_err, dev->net,
    1460                 :            :                           "tx: submit urb err %d\n", retval);
    1461                 :          0 :                 break;
    1462                 :            :         case 0:
    1463                 :            :                 netif_trans_update(net);
    1464                 :          3 :                 __usbnet_queue_skb(&dev->txq, skb, tx_start);
    1465                 :          3 :                 if (dev->txq.qlen >= TX_QLEN (dev))
    1466                 :            :                         netif_stop_queue (net);
    1467                 :            :         }
    1468                 :            :         spin_unlock_irqrestore (&dev->txq.lock, flags);
    1469                 :            : 
    1470                 :          3 :         if (retval) {
    1471                 :            :                 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval);
    1472                 :            : drop:
    1473                 :          0 :                 dev->net->stats.tx_dropped++;
    1474                 :            : not_drop:
    1475                 :          0 :                 if (skb)
    1476                 :            :                         dev_kfree_skb_any (skb);
    1477                 :          0 :                 if (urb) {
    1478                 :          0 :                         kfree(urb->sg);
    1479                 :          0 :                         usb_free_urb(urb);
    1480                 :            :                 }
    1481                 :            :         } else
    1482                 :            :                 netif_dbg(dev, tx_queued, dev->net,
    1483                 :            :                           "> tx, len %u, type 0x%x\n", length, skb->protocol);
    1484                 :            : #ifdef CONFIG_PM
    1485                 :            : deferred:
    1486                 :            : #endif
    1487                 :          3 :         return NETDEV_TX_OK;
    1488                 :            : }
    1489                 :            : EXPORT_SYMBOL_GPL(usbnet_start_xmit);
    1490                 :            : 
    1491                 :          3 : static int rx_alloc_submit(struct usbnet *dev, gfp_t flags)
    1492                 :            : {
    1493                 :            :         struct urb      *urb;
    1494                 :            :         int             i;
    1495                 :            :         int             ret = 0;
    1496                 :            : 
    1497                 :            :         /* don't refill the queue all at once */
    1498                 :          3 :         for (i = 0; i < 10 && dev->rxq.qlen < RX_QLEN(dev); i++) {
    1499                 :          3 :                 urb = usb_alloc_urb(0, flags);
    1500                 :          3 :                 if (urb != NULL) {
    1501                 :          3 :                         ret = rx_submit(dev, urb, flags);
    1502                 :          3 :                         if (ret)
    1503                 :            :                                 goto err;
    1504                 :            :                 } else {
    1505                 :            :                         ret = -ENOMEM;
    1506                 :            :                         goto err;
    1507                 :            :                 }
    1508                 :            :         }
    1509                 :            : err:
    1510                 :          3 :         return ret;
    1511                 :            : }
    1512                 :            : 
    1513                 :            : /*-------------------------------------------------------------------------*/
    1514                 :            : 
    1515                 :            : // tasklet (work deferred from completions, in_irq) or timer
    1516                 :            : 
    1517                 :          3 : static void usbnet_bh (struct timer_list *t)
    1518                 :            : {
    1519                 :          3 :         struct usbnet           *dev = from_timer(dev, t, delay);
    1520                 :            :         struct sk_buff          *skb;
    1521                 :            :         struct skb_data         *entry;
    1522                 :            : 
    1523                 :          3 :         while ((skb = skb_dequeue (&dev->done))) {
    1524                 :            :                 entry = (struct skb_data *) skb->cb;
    1525                 :          3 :                 switch (entry->state) {
    1526                 :            :                 case rx_done:
    1527                 :          3 :                         entry->state = rx_cleanup;
    1528                 :          3 :                         rx_process (dev, skb);
    1529                 :          3 :                         continue;
    1530                 :            :                 case tx_done:
    1531                 :          3 :                         kfree(entry->urb->sg);
    1532                 :            :                         /* fall through */
    1533                 :            :                 case rx_cleanup:
    1534                 :          3 :                         usb_free_urb (entry->urb);
    1535                 :          3 :                         dev_kfree_skb (skb);
    1536                 :          3 :                         continue;
    1537                 :            :                 default:
    1538                 :            :                         netdev_dbg(dev->net, "bogus skb state %d\n", entry->state);
    1539                 :            :                 }
    1540                 :            :         }
    1541                 :            : 
    1542                 :            :         /* restart RX again after disabling due to high error rate */
    1543                 :          3 :         clear_bit(EVENT_RX_KILL, &dev->flags);
    1544                 :            : 
    1545                 :            :         /* waiting for all pending urbs to complete?
    1546                 :            :          * only then can we forgo submitting anew
    1547                 :            :          */
    1548                 :          3 :         if (waitqueue_active(&dev->wait)) {
    1549                 :          0 :                 if (dev->txq.qlen + dev->rxq.qlen + dev->done.qlen == 0)
    1550                 :          0 :                         wake_up_all(&dev->wait);
    1551                 :            : 
    1552                 :            :         // or are we maybe short a few urbs?
    1553                 :          3 :         } else if (netif_running (dev->net) &&
    1554                 :          3 :                    netif_device_present (dev->net) &&
    1555                 :          3 :                    netif_carrier_ok(dev->net) &&
    1556                 :          3 :                    !timer_pending(&dev->delay) &&
    1557                 :          3 :                    !test_bit(EVENT_RX_PAUSED, &dev->flags) &&
    1558                 :            :                    !test_bit(EVENT_RX_HALT, &dev->flags)) {
    1559                 :          3 :                 int     temp = dev->rxq.qlen;
    1560                 :            : 
    1561                 :          3 :                 if (temp < RX_QLEN(dev)) {
    1562                 :          3 :                         if (rx_alloc_submit(dev, GFP_ATOMIC) == -ENOLINK)
    1563                 :          3 :                                 return;
    1564                 :            :                         if (temp != dev->rxq.qlen)
    1565                 :            :                                 netif_dbg(dev, link, dev->net,
    1566                 :            :                                           "rxqlen %d --> %d\n",
    1567                 :            :                                           temp, dev->rxq.qlen);
    1568                 :          3 :                         if (dev->rxq.qlen < RX_QLEN(dev))
    1569                 :          2 :                                 tasklet_schedule (&dev->bh);
    1570                 :            :                 }
    1571                 :          3 :                 if (dev->txq.qlen < TX_QLEN (dev))
    1572                 :          3 :                         netif_wake_queue (dev->net);
    1573                 :            :         }
    1574                 :            : }
    1575                 :            : 
    1576                 :            : 
    1577                 :            : /*-------------------------------------------------------------------------
    1578                 :            :  *
    1579                 :            :  * USB Device Driver support
    1580                 :            :  *
    1581                 :            :  *-------------------------------------------------------------------------*/
    1582                 :            : 
    1583                 :            : // precondition: never called in_interrupt
    1584                 :            : 
    1585                 :          0 : void usbnet_disconnect (struct usb_interface *intf)
    1586                 :            : {
    1587                 :            :         struct usbnet           *dev;
    1588                 :            :         struct usb_device       *xdev;
    1589                 :            :         struct net_device       *net;
    1590                 :            : 
    1591                 :            :         dev = usb_get_intfdata(intf);
    1592                 :            :         usb_set_intfdata(intf, NULL);
    1593                 :          0 :         if (!dev)
    1594                 :          0 :                 return;
    1595                 :            : 
    1596                 :            :         xdev = interface_to_usbdev (intf);
    1597                 :            : 
    1598                 :          0 :         netif_info(dev, probe, dev->net, "unregister '%s' usb-%s-%s, %s\n",
    1599                 :            :                    intf->dev.driver->name,
    1600                 :            :                    xdev->bus->bus_name, xdev->devpath,
    1601                 :            :                    dev->driver_info->description);
    1602                 :            : 
    1603                 :          0 :         net = dev->net;
    1604                 :          0 :         unregister_netdev (net);
    1605                 :            : 
    1606                 :          0 :         cancel_work_sync(&dev->kevent);
    1607                 :            : 
    1608                 :          0 :         usb_scuttle_anchored_urbs(&dev->deferred);
    1609                 :            : 
    1610                 :          0 :         if (dev->driver_info->unbind)
    1611                 :          0 :                 dev->driver_info->unbind (dev, intf);
    1612                 :            : 
    1613                 :          0 :         usb_kill_urb(dev->interrupt);
    1614                 :          0 :         usb_free_urb(dev->interrupt);
    1615                 :          0 :         kfree(dev->padding_pkt);
    1616                 :            : 
    1617                 :          0 :         free_percpu(dev->stats64);
    1618                 :          0 :         free_netdev(net);
    1619                 :            : }
    1620                 :            : EXPORT_SYMBOL_GPL(usbnet_disconnect);
    1621                 :            : 
    1622                 :            : static const struct net_device_ops usbnet_netdev_ops = {
    1623                 :            :         .ndo_open               = usbnet_open,
    1624                 :            :         .ndo_stop               = usbnet_stop,
    1625                 :            :         .ndo_start_xmit         = usbnet_start_xmit,
    1626                 :            :         .ndo_tx_timeout         = usbnet_tx_timeout,
    1627                 :            :         .ndo_set_rx_mode        = usbnet_set_rx_mode,
    1628                 :            :         .ndo_change_mtu         = usbnet_change_mtu,
    1629                 :            :         .ndo_get_stats64        = usbnet_get_stats64,
    1630                 :            :         .ndo_set_mac_address    = eth_mac_addr,
    1631                 :            :         .ndo_validate_addr      = eth_validate_addr,
    1632                 :            : };
    1633                 :            : 
    1634                 :            : /*-------------------------------------------------------------------------*/
    1635                 :            : 
    1636                 :            : // precondition: never called in_interrupt
    1637                 :            : 
    1638                 :            : static struct device_type wlan_type = {
    1639                 :            :         .name   = "wlan",
    1640                 :            : };
    1641                 :            : 
    1642                 :            : static struct device_type wwan_type = {
    1643                 :            :         .name   = "wwan",
    1644                 :            : };
    1645                 :            : 
    1646                 :            : int
    1647                 :          3 : usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
    1648                 :            : {
    1649                 :            :         struct usbnet                   *dev;
    1650                 :            :         struct net_device               *net;
    1651                 :            :         struct usb_host_interface       *interface;
    1652                 :            :         const struct driver_info        *info;
    1653                 :            :         struct usb_device               *xdev;
    1654                 :            :         int                             status;
    1655                 :            :         const char                      *name;
    1656                 :          3 :         struct usb_driver       *driver = to_usb_driver(udev->dev.driver);
    1657                 :            : 
    1658                 :            :         /* usbnet already took usb runtime pm, so have to enable the feature
    1659                 :            :          * for usb interface, otherwise usb_autopm_get_interface may return
    1660                 :            :          * failure if RUNTIME_PM is enabled.
    1661                 :            :          */
    1662                 :          3 :         if (!driver->supports_autosuspend) {
    1663                 :          1 :                 driver->supports_autosuspend = 1;
    1664                 :          1 :                 pm_runtime_enable(&udev->dev);
    1665                 :            :         }
    1666                 :            : 
    1667                 :          3 :         name = udev->dev.driver->name;
    1668                 :          3 :         info = (const struct driver_info *) prod->driver_info;
    1669                 :          3 :         if (!info) {
    1670                 :            :                 dev_dbg (&udev->dev, "blacklisted by %s\n", name);
    1671                 :            :                 return -ENODEV;
    1672                 :            :         }
    1673                 :            :         xdev = interface_to_usbdev (udev);
    1674                 :          3 :         interface = udev->cur_altsetting;
    1675                 :            : 
    1676                 :            :         status = -ENOMEM;
    1677                 :            : 
    1678                 :            :         // set up our own records
    1679                 :          3 :         net = alloc_etherdev(sizeof(*dev));
    1680                 :          3 :         if (!net)
    1681                 :            :                 goto out;
    1682                 :            : 
    1683                 :            :         /* netdev_printk() needs this so do it as early as possible */
    1684                 :          3 :         SET_NETDEV_DEV(net, &udev->dev);
    1685                 :            : 
    1686                 :            :         dev = netdev_priv(net);
    1687                 :          3 :         dev->udev = xdev;
    1688                 :          3 :         dev->intf = udev;
    1689                 :          3 :         dev->driver_info = info;
    1690                 :          3 :         dev->driver_name = name;
    1691                 :            : 
    1692                 :          3 :         dev->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
    1693                 :          3 :         if (!dev->stats64)
    1694                 :            :                 goto out0;
    1695                 :            : 
    1696                 :          3 :         dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV
    1697                 :            :                                 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
    1698                 :          3 :         init_waitqueue_head(&dev->wait);
    1699                 :          3 :         skb_queue_head_init (&dev->rxq);
    1700                 :          3 :         skb_queue_head_init (&dev->txq);
    1701                 :          3 :         skb_queue_head_init (&dev->done);
    1702                 :          3 :         skb_queue_head_init(&dev->rxq_pause);
    1703                 :          3 :         dev->bh.func = (void (*)(unsigned long))usbnet_bh;
    1704                 :          3 :         dev->bh.data = (unsigned long)&dev->delay;
    1705                 :          3 :         INIT_WORK (&dev->kevent, usbnet_deferred_kevent);
    1706                 :          3 :         init_usb_anchor(&dev->deferred);
    1707                 :          3 :         timer_setup(&dev->delay, usbnet_bh, 0);
    1708                 :          3 :         mutex_init (&dev->phy_mutex);
    1709                 :          3 :         mutex_init(&dev->interrupt_mutex);
    1710                 :          3 :         dev->interrupt_count = 0;
    1711                 :            : 
    1712                 :          3 :         dev->net = net;
    1713                 :          3 :         strcpy (net->name, "usb%d");
    1714                 :          3 :         memcpy (net->dev_addr, node_id, sizeof node_id);
    1715                 :            : 
    1716                 :            :         /* rx and tx sides can use different message sizes;
    1717                 :            :          * bind() should set rx_urb_size in that case.
    1718                 :            :          */
    1719                 :          3 :         dev->hard_mtu = net->mtu + net->hard_header_len;
    1720                 :          3 :         net->min_mtu = 0;
    1721                 :          3 :         net->max_mtu = ETH_MAX_MTU;
    1722                 :            : 
    1723                 :          3 :         net->netdev_ops = &usbnet_netdev_ops;
    1724                 :          3 :         net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
    1725                 :          3 :         net->ethtool_ops = &usbnet_ethtool_ops;
    1726                 :            : 
    1727                 :            :         // allow device-specific bind/init procedures
    1728                 :            :         // NOTE net->name still not usable ...
    1729                 :          3 :         if (info->bind) {
    1730                 :          3 :                 status = info->bind (dev, udev);
    1731                 :          3 :                 if (status < 0)
    1732                 :            :                         goto out1;
    1733                 :            : 
    1734                 :            :                 // heuristic:  "usb%d" for links we know are two-host,
    1735                 :            :                 // else "eth%d" when there's reasonable doubt.  userspace
    1736                 :            :                 // can rename the link if it knows better.
    1737                 :          3 :                 if ((dev->driver_info->flags & FLAG_ETHER) != 0 &&
    1738                 :          3 :                     ((dev->driver_info->flags & FLAG_POINTTOPOINT) == 0 ||
    1739                 :          1 :                      (net->dev_addr [0] & 0x02) == 0))
    1740                 :          3 :                         strcpy (net->name, "eth%d");
    1741                 :            :                 /* WLAN devices should always be named "wlan%d" */
    1742                 :          3 :                 if ((dev->driver_info->flags & FLAG_WLAN) != 0)
    1743                 :          0 :                         strcpy(net->name, "wlan%d");
    1744                 :            :                 /* WWAN devices should always be named "wwan%d" */
    1745                 :          3 :                 if ((dev->driver_info->flags & FLAG_WWAN) != 0)
    1746                 :          0 :                         strcpy(net->name, "wwan%d");
    1747                 :            : 
    1748                 :            :                 /* devices that cannot do ARP */
    1749                 :          3 :                 if ((dev->driver_info->flags & FLAG_NOARP) != 0)
    1750                 :          0 :                         net->flags |= IFF_NOARP;
    1751                 :            : 
    1752                 :            :                 /* maybe the remote can't receive an Ethernet MTU */
    1753                 :          3 :                 if (net->mtu > (dev->hard_mtu - net->hard_header_len))
    1754                 :          0 :                         net->mtu = dev->hard_mtu - net->hard_header_len;
    1755                 :          1 :         } else if (!info->in || !info->out)
    1756                 :          1 :                 status = usbnet_get_endpoints (dev, udev);
    1757                 :            :         else {
    1758                 :          0 :                 dev->in = usb_rcvbulkpipe (xdev, info->in);
    1759                 :          0 :                 dev->out = usb_sndbulkpipe (xdev, info->out);
    1760                 :          0 :                 if (!(info->flags & FLAG_NO_SETINT))
    1761                 :          0 :                         status = usb_set_interface (xdev,
    1762                 :          0 :                                 interface->desc.bInterfaceNumber,
    1763                 :          0 :                                 interface->desc.bAlternateSetting);
    1764                 :            :                 else
    1765                 :            :                         status = 0;
    1766                 :            : 
    1767                 :            :         }
    1768                 :          3 :         if (status >= 0 && dev->status)
    1769                 :          3 :                 status = init_status (dev, udev);
    1770                 :          3 :         if (status < 0)
    1771                 :            :                 goto out3;
    1772                 :            : 
    1773                 :          3 :         if (!dev->rx_urb_size)
    1774                 :          1 :                 dev->rx_urb_size = dev->hard_mtu;
    1775                 :          3 :         dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);
    1776                 :            : 
    1777                 :            :         /* let userspace know we have a random address */
    1778                 :          3 :         if (ether_addr_equal(net->dev_addr, node_id))
    1779                 :          1 :                 net->addr_assign_type = NET_ADDR_RANDOM;
    1780                 :            : 
    1781                 :          3 :         if ((dev->driver_info->flags & FLAG_WLAN) != 0)
    1782                 :          0 :                 SET_NETDEV_DEVTYPE(net, &wlan_type);
    1783                 :          3 :         if ((dev->driver_info->flags & FLAG_WWAN) != 0)
    1784                 :          0 :                 SET_NETDEV_DEVTYPE(net, &wwan_type);
    1785                 :            : 
    1786                 :            :         /* initialize max rx_qlen and tx_qlen */
    1787                 :          3 :         usbnet_update_max_qlen(dev);
    1788                 :            : 
    1789                 :          3 :         if (dev->can_dma_sg && !(info->flags & FLAG_SEND_ZLP) &&
    1790                 :            :                 !(info->flags & FLAG_MULTI_PACKET)) {
    1791                 :          0 :                 dev->padding_pkt = kzalloc(1, GFP_KERNEL);
    1792                 :          0 :                 if (!dev->padding_pkt) {
    1793                 :            :                         status = -ENOMEM;
    1794                 :            :                         goto out4;
    1795                 :            :                 }
    1796                 :            :         }
    1797                 :            : 
    1798                 :          3 :         status = register_netdev (net);
    1799                 :          3 :         if (status)
    1800                 :            :                 goto out5;
    1801                 :          3 :         netif_info(dev, probe, dev->net,
    1802                 :            :                    "register '%s' at usb-%s-%s, %s, %pM\n",
    1803                 :            :                    udev->dev.driver->name,
    1804                 :            :                    xdev->bus->bus_name, xdev->devpath,
    1805                 :            :                    dev->driver_info->description,
    1806                 :            :                    net->dev_addr);
    1807                 :            : 
    1808                 :            :         // ok, it's ready to go.
    1809                 :            :         usb_set_intfdata (udev, dev);
    1810                 :            : 
    1811                 :          3 :         netif_device_attach (net);
    1812                 :            : 
    1813                 :          3 :         if (dev->driver_info->flags & FLAG_LINK_INTR)
    1814                 :          2 :                 usbnet_link_change(dev, 0, 0);
    1815                 :            : 
    1816                 :            :         return 0;
    1817                 :            : 
    1818                 :            : out5:
    1819                 :          0 :         kfree(dev->padding_pkt);
    1820                 :            : out4:
    1821                 :          0 :         usb_free_urb(dev->interrupt);
    1822                 :            : out3:
    1823                 :          1 :         if (info->unbind)
    1824                 :          0 :                 info->unbind (dev, udev);
    1825                 :            : out1:
    1826                 :            :         /* subdrivers must undo all they did in bind() if they
    1827                 :            :          * fail it, but we may fail later and a deferred kevent
    1828                 :            :          * may trigger an error resubmitting itself and, worse,
    1829                 :            :          * schedule a timer. So we kill it all just in case.
    1830                 :            :          */
    1831                 :          1 :         cancel_work_sync(&dev->kevent);
    1832                 :          1 :         del_timer_sync(&dev->delay);
    1833                 :          1 :         free_percpu(dev->stats64);
    1834                 :            : out0:
    1835                 :          1 :         free_netdev(net);
    1836                 :            : out:
    1837                 :          1 :         return status;
    1838                 :            : }
    1839                 :            : EXPORT_SYMBOL_GPL(usbnet_probe);
    1840                 :            : 
    1841                 :            : /*-------------------------------------------------------------------------*/
    1842                 :            : 
    1843                 :            : /*
    1844                 :            :  * suspend the whole driver as soon as the first interface is suspended
    1845                 :            :  * resume only when the last interface is resumed
    1846                 :            :  */
    1847                 :            : 
    1848                 :          0 : int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
    1849                 :            : {
    1850                 :            :         struct usbnet           *dev = usb_get_intfdata(intf);
    1851                 :            : 
    1852                 :          0 :         if (!dev->suspend_count++) {
    1853                 :            :                 spin_lock_irq(&dev->txq.lock);
    1854                 :            :                 /* don't autosuspend while transmitting */
    1855                 :          0 :                 if (dev->txq.qlen && PMSG_IS_AUTO(message)) {
    1856                 :          0 :                         dev->suspend_count--;
    1857                 :            :                         spin_unlock_irq(&dev->txq.lock);
    1858                 :          0 :                         return -EBUSY;
    1859                 :            :                 } else {
    1860                 :          0 :                         set_bit(EVENT_DEV_ASLEEP, &dev->flags);
    1861                 :            :                         spin_unlock_irq(&dev->txq.lock);
    1862                 :            :                 }
    1863                 :            :                 /*
    1864                 :            :                  * accelerate emptying of the rx and queues, to avoid
    1865                 :            :                  * having everything error out.
    1866                 :            :                  */
    1867                 :          0 :                 netif_device_detach (dev->net);
    1868                 :          0 :                 usbnet_terminate_urbs(dev);
    1869                 :          0 :                 __usbnet_status_stop_force(dev);
    1870                 :            : 
    1871                 :            :                 /*
    1872                 :            :                  * reattach so runtime management can use and
    1873                 :            :                  * wake the device
    1874                 :            :                  */
    1875                 :          0 :                 netif_device_attach (dev->net);
    1876                 :            :         }
    1877                 :            :         return 0;
    1878                 :            : }
    1879                 :            : EXPORT_SYMBOL_GPL(usbnet_suspend);
    1880                 :            : 
    1881                 :          0 : int usbnet_resume (struct usb_interface *intf)
    1882                 :            : {
    1883                 :            :         struct usbnet           *dev = usb_get_intfdata(intf);
    1884                 :            :         struct sk_buff          *skb;
    1885                 :            :         struct urb              *res;
    1886                 :            :         int                     retval;
    1887                 :            : 
    1888                 :          0 :         if (!--dev->suspend_count) {
    1889                 :            :                 /* resume interrupt URB if it was previously submitted */
    1890                 :          0 :                 __usbnet_status_start_force(dev, GFP_NOIO);
    1891                 :            : 
    1892                 :            :                 spin_lock_irq(&dev->txq.lock);
    1893                 :          0 :                 while ((res = usb_get_from_anchor(&dev->deferred))) {
    1894                 :            : 
    1895                 :          0 :                         skb = (struct sk_buff *)res->context;
    1896                 :          0 :                         retval = usb_submit_urb(res, GFP_ATOMIC);
    1897                 :          0 :                         if (retval < 0) {
    1898                 :            :                                 dev_kfree_skb_any(skb);
    1899                 :          0 :                                 kfree(res->sg);
    1900                 :          0 :                                 usb_free_urb(res);
    1901                 :          0 :                                 usb_autopm_put_interface_async(dev->intf);
    1902                 :            :                         } else {
    1903                 :          0 :                                 netif_trans_update(dev->net);
    1904                 :          0 :                                 __skb_queue_tail(&dev->txq, skb);
    1905                 :            :                         }
    1906                 :            :                 }
    1907                 :            : 
    1908                 :          0 :                 smp_mb();
    1909                 :          0 :                 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
    1910                 :            :                 spin_unlock_irq(&dev->txq.lock);
    1911                 :            : 
    1912                 :          0 :                 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
    1913                 :            :                         /* handle remote wakeup ASAP
    1914                 :            :                          * we cannot race against stop
    1915                 :            :                          */
    1916                 :          0 :                         if (netif_device_present(dev->net) &&
    1917                 :          0 :                                 !timer_pending(&dev->delay) &&
    1918                 :            :                                 !test_bit(EVENT_RX_HALT, &dev->flags))
    1919                 :          0 :                                         rx_alloc_submit(dev, GFP_NOIO);
    1920                 :            : 
    1921                 :          0 :                         if (!(dev->txq.qlen >= TX_QLEN(dev)))
    1922                 :          0 :                                 netif_tx_wake_all_queues(dev->net);
    1923                 :          0 :                         tasklet_schedule (&dev->bh);
    1924                 :            :                 }
    1925                 :            :         }
    1926                 :            : 
    1927                 :          0 :         if (test_and_clear_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags))
    1928                 :          0 :                 usb_autopm_get_interface_no_resume(intf);
    1929                 :            : 
    1930                 :          0 :         return 0;
    1931                 :            : }
    1932                 :            : EXPORT_SYMBOL_GPL(usbnet_resume);
    1933                 :            : 
    1934                 :            : /*
    1935                 :            :  * Either a subdriver implements manage_power, then it is assumed to always
    1936                 :            :  * be ready to be suspended or it reports the readiness to be suspended
    1937                 :            :  * explicitly
    1938                 :            :  */
    1939                 :          0 : void usbnet_device_suggests_idle(struct usbnet *dev)
    1940                 :            : {
    1941                 :          0 :         if (!test_and_set_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags)) {
    1942                 :          0 :                 dev->intf->needs_remote_wakeup = 1;
    1943                 :          0 :                 usb_autopm_put_interface_async(dev->intf);
    1944                 :            :         }
    1945                 :          0 : }
    1946                 :            : EXPORT_SYMBOL(usbnet_device_suggests_idle);
    1947                 :            : 
    1948                 :            : /*
    1949                 :            :  * For devices that can do without special commands
    1950                 :            :  */
    1951                 :          1 : int usbnet_manage_power(struct usbnet *dev, int on)
    1952                 :            : {
    1953                 :          1 :         dev->intf->needs_remote_wakeup = on;
    1954                 :          1 :         return 0;
    1955                 :            : }
    1956                 :            : EXPORT_SYMBOL(usbnet_manage_power);
    1957                 :            : 
    1958                 :          2 : void usbnet_link_change(struct usbnet *dev, bool link, bool need_reset)
    1959                 :            : {
    1960                 :            :         /* update link after link is reseted */
    1961                 :          2 :         if (link && !need_reset)
    1962                 :          2 :                 netif_carrier_on(dev->net);
    1963                 :            :         else
    1964                 :          2 :                 netif_carrier_off(dev->net);
    1965                 :            : 
    1966                 :          2 :         if (need_reset && link)
    1967                 :          0 :                 usbnet_defer_kevent(dev, EVENT_LINK_RESET);
    1968                 :            :         else
    1969                 :          2 :                 usbnet_defer_kevent(dev, EVENT_LINK_CHANGE);
    1970                 :          2 : }
    1971                 :            : EXPORT_SYMBOL(usbnet_link_change);
    1972                 :            : 
    1973                 :            : /*-------------------------------------------------------------------------*/
    1974                 :          2 : static int __usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
    1975                 :            :                              u16 value, u16 index, void *data, u16 size)
    1976                 :            : {
    1977                 :            :         void *buf = NULL;
    1978                 :            :         int err = -ENOMEM;
    1979                 :            : 
    1980                 :            :         netdev_dbg(dev->net, "usbnet_read_cmd cmd=0x%02x reqtype=%02x"
    1981                 :            :                    " value=0x%04x index=0x%04x size=%d\n",
    1982                 :            :                    cmd, reqtype, value, index, size);
    1983                 :            : 
    1984                 :          2 :         if (size) {
    1985                 :          2 :                 buf = kmalloc(size, GFP_KERNEL);
    1986                 :          2 :                 if (!buf)
    1987                 :            :                         goto out;
    1988                 :            :         }
    1989                 :            : 
    1990                 :          2 :         err = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
    1991                 :            :                               cmd, reqtype, value, index, buf, size,
    1992                 :            :                               USB_CTRL_GET_TIMEOUT);
    1993                 :          2 :         if (err > 0 && err <= size) {
    1994                 :          2 :         if (data)
    1995                 :          2 :             memcpy(data, buf, err);
    1996                 :            :         else
    1997                 :            :             netdev_dbg(dev->net,
    1998                 :            :                 "Huh? Data requested but thrown away.\n");
    1999                 :            :     }
    2000                 :          2 :         kfree(buf);
    2001                 :            : out:
    2002                 :          2 :         return err;
    2003                 :            : }
    2004                 :            : 
    2005                 :          2 : static int __usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
    2006                 :            :                               u16 value, u16 index, const void *data,
    2007                 :            :                               u16 size)
    2008                 :            : {
    2009                 :            :         void *buf = NULL;
    2010                 :            :         int err = -ENOMEM;
    2011                 :            : 
    2012                 :            :         netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
    2013                 :            :                    " value=0x%04x index=0x%04x size=%d\n",
    2014                 :            :                    cmd, reqtype, value, index, size);
    2015                 :            : 
    2016                 :          2 :         if (data) {
    2017                 :          2 :                 buf = kmemdup(data, size, GFP_KERNEL);
    2018                 :          2 :                 if (!buf)
    2019                 :            :                         goto out;
    2020                 :            :         } else {
    2021                 :          0 :         if (size) {
    2022                 :          0 :             WARN_ON_ONCE(1);
    2023                 :            :             err = -EINVAL;
    2024                 :            :             goto out;
    2025                 :            :         }
    2026                 :            :     }
    2027                 :            : 
    2028                 :          2 :         err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
    2029                 :            :                               cmd, reqtype, value, index, buf, size,
    2030                 :            :                               USB_CTRL_SET_TIMEOUT);
    2031                 :          2 :         kfree(buf);
    2032                 :            : 
    2033                 :            : out:
    2034                 :          2 :         return err;
    2035                 :            : }
    2036                 :            : 
    2037                 :            : /*
    2038                 :            :  * The function can't be called inside suspend/resume callback,
    2039                 :            :  * otherwise deadlock will be caused.
    2040                 :            :  */
    2041                 :          2 : int usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
    2042                 :            :                     u16 value, u16 index, void *data, u16 size)
    2043                 :            : {
    2044                 :            :         int ret;
    2045                 :            : 
    2046                 :          2 :         if (usb_autopm_get_interface(dev->intf) < 0)
    2047                 :            :                 return -ENODEV;
    2048                 :          2 :         ret = __usbnet_read_cmd(dev, cmd, reqtype, value, index,
    2049                 :            :                                 data, size);
    2050                 :          2 :         usb_autopm_put_interface(dev->intf);
    2051                 :          2 :         return ret;
    2052                 :            : }
    2053                 :            : EXPORT_SYMBOL_GPL(usbnet_read_cmd);
    2054                 :            : 
    2055                 :            : /*
    2056                 :            :  * The function can't be called inside suspend/resume callback,
    2057                 :            :  * otherwise deadlock will be caused.
    2058                 :            :  */
    2059                 :          2 : int usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
    2060                 :            :                      u16 value, u16 index, const void *data, u16 size)
    2061                 :            : {
    2062                 :            :         int ret;
    2063                 :            : 
    2064                 :          2 :         if (usb_autopm_get_interface(dev->intf) < 0)
    2065                 :            :                 return -ENODEV;
    2066                 :          2 :         ret = __usbnet_write_cmd(dev, cmd, reqtype, value, index,
    2067                 :            :                                  data, size);
    2068                 :          2 :         usb_autopm_put_interface(dev->intf);
    2069                 :          2 :         return ret;
    2070                 :            : }
    2071                 :            : EXPORT_SYMBOL_GPL(usbnet_write_cmd);
    2072                 :            : 
    2073                 :            : /*
    2074                 :            :  * The function can be called inside suspend/resume callback safely
    2075                 :            :  * and should only be called by suspend/resume callback generally.
    2076                 :            :  */
    2077                 :          0 : int usbnet_read_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
    2078                 :            :                           u16 value, u16 index, void *data, u16 size)
    2079                 :            : {
    2080                 :          0 :         return __usbnet_read_cmd(dev, cmd, reqtype, value, index,
    2081                 :            :                                  data, size);
    2082                 :            : }
    2083                 :            : EXPORT_SYMBOL_GPL(usbnet_read_cmd_nopm);
    2084                 :            : 
    2085                 :            : /*
    2086                 :            :  * The function can be called inside suspend/resume callback safely
    2087                 :            :  * and should only be called by suspend/resume callback generally.
    2088                 :            :  */
    2089                 :          0 : int usbnet_write_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
    2090                 :            :                           u16 value, u16 index, const void *data,
    2091                 :            :                           u16 size)
    2092                 :            : {
    2093                 :          0 :         return __usbnet_write_cmd(dev, cmd, reqtype, value, index,
    2094                 :            :                                   data, size);
    2095                 :            : }
    2096                 :            : EXPORT_SYMBOL_GPL(usbnet_write_cmd_nopm);
    2097                 :            : 
    2098                 :          2 : static void usbnet_async_cmd_cb(struct urb *urb)
    2099                 :            : {
    2100                 :          2 :         struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
    2101                 :            :         int status = urb->status;
    2102                 :            : 
    2103                 :            :         if (status < 0)
    2104                 :            :                 dev_dbg(&urb->dev->dev, "%s failed with %d",
    2105                 :            :                         __func__, status);
    2106                 :            : 
    2107                 :          2 :         kfree(req);
    2108                 :          2 :         usb_free_urb(urb);
    2109                 :          2 : }
    2110                 :            : 
    2111                 :            : /*
    2112                 :            :  * The caller must make sure that device can't be put into suspend
    2113                 :            :  * state until the control URB completes.
    2114                 :            :  */
    2115                 :          2 : int usbnet_write_cmd_async(struct usbnet *dev, u8 cmd, u8 reqtype,
    2116                 :            :                            u16 value, u16 index, const void *data, u16 size)
    2117                 :            : {
    2118                 :            :         struct usb_ctrlrequest *req = NULL;
    2119                 :            :         struct urb *urb;
    2120                 :            :         int err = -ENOMEM;
    2121                 :            :         void *buf = NULL;
    2122                 :            : 
    2123                 :            :         netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
    2124                 :            :                    " value=0x%04x index=0x%04x size=%d\n",
    2125                 :            :                    cmd, reqtype, value, index, size);
    2126                 :            : 
    2127                 :          2 :         urb = usb_alloc_urb(0, GFP_ATOMIC);
    2128                 :          2 :         if (!urb)
    2129                 :            :                 goto fail;
    2130                 :            : 
    2131                 :          2 :         if (data) {
    2132                 :          2 :                 buf = kmemdup(data, size, GFP_ATOMIC);
    2133                 :          2 :                 if (!buf) {
    2134                 :          0 :                         netdev_err(dev->net, "Error allocating buffer"
    2135                 :            :                                    " in %s!\n", __func__);
    2136                 :          0 :                         goto fail_free;
    2137                 :            :                 }
    2138                 :            :         }
    2139                 :            : 
    2140                 :            :         req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
    2141                 :          2 :         if (!req)
    2142                 :            :                 goto fail_free_buf;
    2143                 :            : 
    2144                 :          2 :         req->bRequestType = reqtype;
    2145                 :          2 :         req->bRequest = cmd;
    2146                 :          2 :         req->wValue = cpu_to_le16(value);
    2147                 :          2 :         req->wIndex = cpu_to_le16(index);
    2148                 :          2 :         req->wLength = cpu_to_le16(size);
    2149                 :            : 
    2150                 :          2 :         usb_fill_control_urb(urb, dev->udev,
    2151                 :          2 :                              usb_sndctrlpipe(dev->udev, 0),
    2152                 :            :                              (void *)req, buf, size,
    2153                 :            :                              usbnet_async_cmd_cb, req);
    2154                 :          2 :         urb->transfer_flags |= URB_FREE_BUFFER;
    2155                 :            : 
    2156                 :          2 :         err = usb_submit_urb(urb, GFP_ATOMIC);
    2157                 :          2 :         if (err < 0) {
    2158                 :          0 :                 netdev_err(dev->net, "Error submitting the control"
    2159                 :            :                            " message: status=%d\n", err);
    2160                 :          0 :                 goto fail_free;
    2161                 :            :         }
    2162                 :            :         return 0;
    2163                 :            : 
    2164                 :            : fail_free_buf:
    2165                 :          0 :         kfree(buf);
    2166                 :            : fail_free:
    2167                 :          0 :         kfree(req);
    2168                 :          0 :         usb_free_urb(urb);
    2169                 :            : fail:
    2170                 :          0 :         return err;
    2171                 :            : 
    2172                 :            : }
    2173                 :            : EXPORT_SYMBOL_GPL(usbnet_write_cmd_async);
    2174                 :            : /*-------------------------------------------------------------------------*/
    2175                 :            : 
    2176                 :          3 : static int __init usbnet_init(void)
    2177                 :            : {
    2178                 :            :         /* Compiler should optimize this out. */
    2179                 :            :         BUILD_BUG_ON(
    2180                 :            :                 FIELD_SIZEOF(struct sk_buff, cb) < sizeof(struct skb_data));
    2181                 :            : 
    2182                 :            :         eth_random_addr(node_id);
    2183                 :          3 :         return 0;
    2184                 :            : }
    2185                 :            : module_init(usbnet_init);
    2186                 :            : 
    2187                 :          0 : static void __exit usbnet_exit(void)
    2188                 :            : {
    2189                 :          0 : }
    2190                 :            : module_exit(usbnet_exit);
    2191                 :            : 
    2192                 :            : MODULE_AUTHOR("David Brownell");
    2193                 :            : MODULE_DESCRIPTION("USB network driver framework");
    2194                 :            : MODULE_LICENSE("GPL");
    

Generated by: LCOV version 1.14