usbnet.c

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