1/*
   2 * USB Network driver infrastructure
   3 * Copyright (C) 2000-2005 by David Brownell
   4 * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 2 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program; if not, write to the Free Software
  18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21/*
  22 * This is a generic "USB networking" framework that works with several
  23 * kinds of full and high speed networking devices:  host-to-host cables,
  24 * smart usb peripherals, and actual Ethernet adapters.
  25 *
  26 * These devices usually differ in terms of control protocols (if they
  27 * even have one!) and sometimes they define new framing to wrap or batch
  28 * Ethernet packets.  Otherwise, they talk to USB pretty much the same,
  29 * so interface (un)binding, endpoint I/O queues, fault handling, and other
  30 * issues can usefully be addressed by this framework.
  31 */
  32
  33// #define	DEBUG			// error path messages, extra info
  34// #define	VERBOSE			// more; success messages
  35
  36#include <linux/module.h>
  37#include <linux/init.h>
  38#include <linux/netdevice.h>
  39#include <linux/etherdevice.h>
  40#include <linux/ctype.h>
  41#include <linux/ethtool.h>
  42#include <linux/workqueue.h>
  43#include <linux/mii.h>
  44#include <linux/usb.h>
  45#include <linux/usb/usbnet.h>
  46#include <linux/slab.h>
  47#include <linux/kernel.h>
  48#include <linux/pm_runtime.h>
  49
  50#define DRIVER_VERSION		"22-Aug-2005"
  51
  52
  53/*-------------------------------------------------------------------------*/
  54
  55/*
  56 * Nineteen USB 1.1 max size bulk transactions per frame (ms), max.
  57 * Several dozen bytes of IPv4 data can fit in two such transactions.
  58 * One maximum size Ethernet packet takes twenty four of them.
  59 * For high speed, each frame comfortably fits almost 36 max size
  60 * Ethernet packets (so queues should be bigger).
  61 *
  62 * REVISIT qlens should be members of 'struct usbnet'; the goal is to
  63 * let the USB host controller be busy for 5msec or more before an irq
  64 * is required, under load.  Jumbograms change the equation.
  65 */
  66#define RX_MAX_QUEUE_MEMORY (60 * 1518)
  67#define	RX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \
  68			(RX_MAX_QUEUE_MEMORY/(dev)->rx_urb_size) : 4)
  69#define	TX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \
  70			(RX_MAX_QUEUE_MEMORY/(dev)->hard_mtu) : 4)
  71
  72// reawaken network queue this soon after stopping; else watchdog barks
  73#define TX_TIMEOUT_JIFFIES	(5*HZ)
  74
  75// throttle rx/tx briefly after some faults, so khubd might disconnect()
  76// us (it polls at HZ/4 usually) before we report too many false errors.
 
  77#define THROTTLE_JIFFIES	(HZ/8)
  78
  79// between wakeups
  80#define UNLINK_TIMEOUT_MS	3
  81
  82/*-------------------------------------------------------------------------*/
  83
  84// randomly generated ethernet address
  85static u8	node_id [ETH_ALEN];
  86
  87static const char driver_name [] = "usbnet";
  88
  89/* use ethtool to change the level for any given device */
  90static int msg_level = -1;
  91module_param (msg_level, int, 0);
  92MODULE_PARM_DESC (msg_level, "Override default message level");
  93
  94/*-------------------------------------------------------------------------*/
  95
  96/* handles CDC Ethernet and many other network "bulk data" interfaces */
  97int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
  98{
  99	int				tmp;
 100	struct usb_host_interface	*alt = NULL;
 101	struct usb_host_endpoint	*in = NULL, *out = NULL;
 102	struct usb_host_endpoint	*status = NULL;
 103
 104	for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
 105		unsigned	ep;
 106
 107		in = out = status = NULL;
 108		alt = intf->altsetting + tmp;
 109
 110		/* take the first altsetting with in-bulk + out-bulk;
 111		 * remember any status endpoint, just in case;
 112		 * ignore other endpoints and altsettings.
 113		 */
 114		for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
 115			struct usb_host_endpoint	*e;
 116			int				intr = 0;
 117
 118			e = alt->endpoint + ep;
 
 
 
 
 
 119			switch (e->desc.bmAttributes) {
 120			case USB_ENDPOINT_XFER_INT:
 121				if (!usb_endpoint_dir_in(&e->desc))
 122					continue;
 123				intr = 1;
 124				/* FALLTHROUGH */
 125			case USB_ENDPOINT_XFER_BULK:
 126				break;
 127			default:
 128				continue;
 129			}
 130			if (usb_endpoint_dir_in(&e->desc)) {
 131				if (!intr && !in)
 132					in = e;
 133				else if (intr && !status)
 134					status = e;
 135			} else {
 136				if (!out)
 137					out = e;
 138			}
 139		}
 140		if (in && out)
 141			break;
 142	}
 143	if (!alt || !in || !out)
 144		return -EINVAL;
 145
 146	if (alt->desc.bAlternateSetting != 0 ||
 147	    !(dev->driver_info->flags & FLAG_NO_SETINT)) {
 148		tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber,
 149				alt->desc.bAlternateSetting);
 150		if (tmp < 0)
 151			return tmp;
 152	}
 153
 154	dev->in = usb_rcvbulkpipe (dev->udev,
 155			in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
 156	dev->out = usb_sndbulkpipe (dev->udev,
 157			out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
 158	dev->status = status;
 159	return 0;
 160}
 161EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
 162
 163int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
 164{
 165	int 		tmp, i;
 166	unsigned char	buf [13];
 167
 168	tmp = usb_string(dev->udev, iMACAddress, buf, sizeof buf);
 169	if (tmp != 12) {
 
 
 170		dev_dbg(&dev->udev->dev,
 171			"bad MAC string %d fetch, %d\n", iMACAddress, tmp);
 172		if (tmp >= 0)
 173			tmp = -EINVAL;
 174		return tmp;
 175	}
 176	for (i = tmp = 0; i < 6; i++, tmp += 2)
 177		dev->net->dev_addr [i] =
 178			(hex_to_bin(buf[tmp]) << 4) + hex_to_bin(buf[tmp + 1]);
 179	return 0;
 180}
 181EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);
 182
 183static void intr_complete (struct urb *urb);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 184
 185static int init_status (struct usbnet *dev, struct usb_interface *intf)
 186{
 187	char		*buf = NULL;
 188	unsigned	pipe = 0;
 189	unsigned	maxp;
 190	unsigned	period;
 191
 192	if (!dev->driver_info->status)
 193		return 0;
 194
 195	pipe = usb_rcvintpipe (dev->udev,
 196			dev->status->desc.bEndpointAddress
 197				& USB_ENDPOINT_NUMBER_MASK);
 198	maxp = usb_maxpacket (dev->udev, pipe, 0);
 199
 200	/* avoid 1 msec chatter:  min 8 msec poll rate */
 201	period = max ((int) dev->status->desc.bInterval,
 202		(dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3);
 203
 204	buf = kmalloc (maxp, GFP_KERNEL);
 205	if (buf) {
 206		dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);
 207		if (!dev->interrupt) {
 208			kfree (buf);
 209			return -ENOMEM;
 210		} else {
 211			usb_fill_int_urb(dev->interrupt, dev->udev, pipe,
 212				buf, maxp, intr_complete, dev, period);
 
 213			dev_dbg(&intf->dev,
 214				"status ep%din, %d bytes period %d\n",
 215				usb_pipeendpoint(pipe), maxp, period);
 216		}
 217	}
 218	return 0;
 219}
 220
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 221/* Passes this packet up the stack, updating its accounting.
 222 * Some link protocols batch packets, so their rx_fixup paths
 223 * can return clones as well as just modify the original skb.
 224 */
 225void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
 226{
 
 
 227	int	status;
 228
 229	if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
 230		skb_queue_tail(&dev->rxq_pause, skb);
 231		return;
 232	}
 233
 234	skb->protocol = eth_type_trans (skb, dev->net);
 235	dev->net->stats.rx_packets++;
 236	dev->net->stats.rx_bytes += skb->len;
 
 
 
 
 
 237
 238	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
 239		  skb->len + sizeof (struct ethhdr), skb->protocol);
 240	memset (skb->cb, 0, sizeof (struct skb_data));
 
 
 
 
 241	status = netif_rx (skb);
 242	if (status != NET_RX_SUCCESS)
 243		netif_dbg(dev, rx_err, dev->net,
 244			  "netif_rx status %d\n", status);
 245}
 246EXPORT_SYMBOL_GPL(usbnet_skb_return);
 247
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 248
 249/*-------------------------------------------------------------------------
 250 *
 251 * Network Device Driver (peer link to "Host Device", from USB host)
 252 *
 253 *-------------------------------------------------------------------------*/
 254
 255int usbnet_change_mtu (struct net_device *net, int new_mtu)
 256{
 257	struct usbnet	*dev = netdev_priv(net);
 258	int		ll_mtu = new_mtu + net->hard_header_len;
 259	int		old_hard_mtu = dev->hard_mtu;
 260	int		old_rx_urb_size = dev->rx_urb_size;
 261
 262	if (new_mtu <= 0)
 263		return -EINVAL;
 264	// no second zero-length packet read wanted after mtu-sized packets
 265	if ((ll_mtu % dev->maxpacket) == 0)
 266		return -EDOM;
 267	net->mtu = new_mtu;
 268
 269	dev->hard_mtu = net->mtu + net->hard_header_len;
 270	if (dev->rx_urb_size == old_hard_mtu) {
 271		dev->rx_urb_size = dev->hard_mtu;
 272		if (dev->rx_urb_size > old_rx_urb_size)
 
 273			usbnet_unlink_rx_urbs(dev);
 
 
 274	}
 275
 
 
 
 276	return 0;
 277}
 278EXPORT_SYMBOL_GPL(usbnet_change_mtu);
 279
 
 
 
 
 
 
 
 
 
 
 280/*-------------------------------------------------------------------------*/
 281
 282/* some LK 2.4 HCDs oopsed if we freed or resubmitted urbs from
 283 * completion callbacks.  2.5 should have fixed those bugs...
 284 */
 285
 286static void defer_bh(struct usbnet *dev, struct sk_buff *skb, struct sk_buff_head *list)
 
 287{
 288	unsigned long		flags;
 
 
 289
 290	spin_lock_irqsave(&list->lock, flags);
 
 
 291	__skb_unlink(skb, list);
 292	spin_unlock(&list->lock);
 293	spin_lock(&dev->done.lock);
 
 
 
 
 
 294	__skb_queue_tail(&dev->done, skb);
 295	if (dev->done.qlen == 1)
 296		tasklet_schedule(&dev->bh);
 297	spin_unlock_irqrestore(&dev->done.lock, flags);
 
 
 298}
 299
 300/* some work can't be done in tasklets, so we use keventd
 301 *
 302 * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,
 303 * but tasklet_schedule() doesn't.  hope the failure is rare.
 304 */
 305void usbnet_defer_kevent (struct usbnet *dev, int work)
 306{
 307	set_bit (work, &dev->flags);
 308	if (!schedule_work (&dev->kevent))
 309		netdev_err(dev->net, "kevent %d may have been dropped\n", work);
 310	else
 311		netdev_dbg(dev->net, "kevent %d scheduled\n", work);
 312}
 313EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
 314
 315/*-------------------------------------------------------------------------*/
 316
 317static void rx_complete (struct urb *urb);
 318
 319static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
 320{
 321	struct sk_buff		*skb;
 322	struct skb_data		*entry;
 323	int			retval = 0;
 324	unsigned long		lockflags;
 325	size_t			size = dev->rx_urb_size;
 326
 327	if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {
 
 
 
 
 
 
 
 
 
 
 328		netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
 329		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
 330		usb_free_urb (urb);
 331		return -ENOMEM;
 332	}
 333	skb_reserve (skb, NET_IP_ALIGN);
 334
 335	entry = (struct skb_data *) skb->cb;
 336	entry->urb = urb;
 337	entry->dev = dev;
 338	entry->state = rx_start;
 339	entry->length = 0;
 340
 341	usb_fill_bulk_urb (urb, dev->udev, dev->in,
 342		skb->data, size, rx_complete, skb);
 343
 344	spin_lock_irqsave (&dev->rxq.lock, lockflags);
 345
 346	if (netif_running (dev->net) &&
 347	    netif_device_present (dev->net) &&
 
 348	    !test_bit (EVENT_RX_HALT, &dev->flags) &&
 349	    !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {
 350		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {
 351		case -EPIPE:
 352			usbnet_defer_kevent (dev, EVENT_RX_HALT);
 353			break;
 354		case -ENOMEM:
 355			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
 356			break;
 357		case -ENODEV:
 358			netif_dbg(dev, ifdown, dev->net, "device gone\n");
 359			netif_device_detach (dev->net);
 360			break;
 361		case -EHOSTUNREACH:
 362			retval = -ENOLINK;
 363			break;
 364		default:
 365			netif_dbg(dev, rx_err, dev->net,
 366				  "rx submit, %d\n", retval);
 367			tasklet_schedule (&dev->bh);
 368			break;
 369		case 0:
 370			__skb_queue_tail (&dev->rxq, skb);
 371		}
 372	} else {
 373		netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
 374		retval = -ENOLINK;
 375	}
 376	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
 377	if (retval) {
 378		dev_kfree_skb_any (skb);
 379		usb_free_urb (urb);
 380	}
 381	return retval;
 382}
 383
 384
 385/*-------------------------------------------------------------------------*/
 386
 387static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
 388{
 389	if (dev->driver_info->rx_fixup &&
 390	    !dev->driver_info->rx_fixup (dev, skb)) {
 391		/* With RX_ASSEMBLE, rx_fixup() must update counters */
 392		if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE))
 393			dev->net->stats.rx_errors++;
 394		goto done;
 395	}
 396	// else network stack removes extra byte if we forced a short packet
 397
 398	if (skb->len) {
 399		/* all data was already cloned from skb inside the driver */
 400		if (dev->driver_info->flags & FLAG_MULTI_PACKET)
 401			dev_kfree_skb_any(skb);
 402		else
 403			usbnet_skb_return(dev, skb);
 
 
 
 
 404		return;
 405	}
 406
 407	netif_dbg(dev, rx_err, dev->net, "drop\n");
 408	dev->net->stats.rx_errors++;
 409done:
 410	skb_queue_tail(&dev->done, skb);
 411}
 412
 413/*-------------------------------------------------------------------------*/
 414
 415static void rx_complete (struct urb *urb)
 416{
 417	struct sk_buff		*skb = (struct sk_buff *) urb->context;
 418	struct skb_data		*entry = (struct skb_data *) skb->cb;
 419	struct usbnet		*dev = entry->dev;
 420	int			urb_status = urb->status;
 
 421
 422	skb_put (skb, urb->actual_length);
 423	entry->state = rx_done;
 424	entry->urb = NULL;
 425
 426	switch (urb_status) {
 427	/* success */
 428	case 0:
 429		if (skb->len < dev->net->hard_header_len) {
 430			entry->state = rx_cleanup;
 431			dev->net->stats.rx_errors++;
 432			dev->net->stats.rx_length_errors++;
 433			netif_dbg(dev, rx_err, dev->net,
 434				  "rx length %d\n", skb->len);
 435		}
 436		break;
 437
 438	/* stalls need manual reset. this is rare ... except that
 439	 * when going through USB 2.0 TTs, unplug appears this way.
 440	 * we avoid the highspeed version of the ETIMEDOUT/EILSEQ
 441	 * storm, recovering as needed.
 442	 */
 443	case -EPIPE:
 444		dev->net->stats.rx_errors++;
 445		usbnet_defer_kevent (dev, EVENT_RX_HALT);
 446		// FALLTHROUGH
 447
 448	/* software-driven interface shutdown */
 449	case -ECONNRESET:		/* async unlink */
 450	case -ESHUTDOWN:		/* hardware gone */
 451		netif_dbg(dev, ifdown, dev->net,
 452			  "rx shutdown, code %d\n", urb_status);
 453		goto block;
 454
 455	/* we get controller i/o faults during khubd disconnect() delays.
 456	 * throttle down resubmits, to avoid log floods; just temporarily,
 457	 * so we still recover when the fault isn't a khubd delay.
 458	 */
 459	case -EPROTO:
 460	case -ETIME:
 461	case -EILSEQ:
 462		dev->net->stats.rx_errors++;
 463		if (!timer_pending (&dev->delay)) {
 464			mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
 465			netif_dbg(dev, link, dev->net,
 466				  "rx throttle %d\n", urb_status);
 467		}
 468block:
 469		entry->state = rx_cleanup;
 470		entry->urb = urb;
 471		urb = NULL;
 472		break;
 473
 474	/* data overrun ... flush fifo? */
 475	case -EOVERFLOW:
 476		dev->net->stats.rx_over_errors++;
 477		// FALLTHROUGH
 478
 479	default:
 480		entry->state = rx_cleanup;
 481		dev->net->stats.rx_errors++;
 482		netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
 483		break;
 484	}
 485
 486	defer_bh(dev, skb, &dev->rxq);
 
 
 
 
 
 
 
 
 
 
 
 487
 488	if (urb) {
 489		if (netif_running (dev->net) &&
 490		    !test_bit (EVENT_RX_HALT, &dev->flags)) {
 
 491			rx_submit (dev, urb, GFP_ATOMIC);
 
 492			return;
 493		}
 494		usb_free_urb (urb);
 495	}
 496	netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
 497}
 498
 499static void intr_complete (struct urb *urb)
 500{
 501	struct usbnet	*dev = urb->context;
 502	int		status = urb->status;
 503
 504	switch (status) {
 505	/* success */
 506	case 0:
 507		dev->driver_info->status(dev, urb);
 508		break;
 509
 510	/* software-driven interface shutdown */
 511	case -ENOENT:		/* urb killed */
 512	case -ESHUTDOWN:	/* hardware gone */
 513		netif_dbg(dev, ifdown, dev->net,
 514			  "intr shutdown, code %d\n", status);
 515		return;
 516
 517	/* NOTE:  not throttling like RX/TX, since this endpoint
 518	 * already polls infrequently
 519	 */
 520	default:
 521		netdev_dbg(dev->net, "intr status %d\n", status);
 522		break;
 523	}
 524
 525	if (!netif_running (dev->net))
 526		return;
 527
 528	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
 529	status = usb_submit_urb (urb, GFP_ATOMIC);
 530	if (status != 0)
 531		netif_err(dev, timer, dev->net,
 532			  "intr resubmit --> %d\n", status);
 533}
 534
 535/*-------------------------------------------------------------------------*/
 536void usbnet_pause_rx(struct usbnet *dev)
 537{
 538	set_bit(EVENT_RX_PAUSED, &dev->flags);
 539
 540	netif_dbg(dev, rx_status, dev->net, "paused rx queue enabled\n");
 541}
 542EXPORT_SYMBOL_GPL(usbnet_pause_rx);
 543
 544void usbnet_resume_rx(struct usbnet *dev)
 545{
 546	struct sk_buff *skb;
 547	int num = 0;
 548
 549	clear_bit(EVENT_RX_PAUSED, &dev->flags);
 550
 551	while ((skb = skb_dequeue(&dev->rxq_pause)) != NULL) {
 552		usbnet_skb_return(dev, skb);
 553		num++;
 554	}
 555
 556	tasklet_schedule(&dev->bh);
 557
 558	netif_dbg(dev, rx_status, dev->net,
 559		  "paused rx queue disabled, %d skbs requeued\n", num);
 560}
 561EXPORT_SYMBOL_GPL(usbnet_resume_rx);
 562
 563void usbnet_purge_paused_rxq(struct usbnet *dev)
 564{
 565	skb_queue_purge(&dev->rxq_pause);
 566}
 567EXPORT_SYMBOL_GPL(usbnet_purge_paused_rxq);
 568
 569/*-------------------------------------------------------------------------*/
 570
 571// unlink pending rx/tx; completion handlers do all other cleanup
 572
 573static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q)
 574{
 575	unsigned long		flags;
 576	struct sk_buff		*skb, *skbnext;
 577	int			count = 0;
 578
 579	spin_lock_irqsave (&q->lock, flags);
 580	skb_queue_walk_safe(q, skb, skbnext) {
 581		struct skb_data		*entry;
 582		struct urb		*urb;
 583		int			retval;
 584
 585		entry = (struct skb_data *) skb->cb;
 
 
 
 
 
 
 
 586		urb = entry->urb;
 587
 
 
 
 
 
 
 
 
 
 588		// during some PM-driven resume scenarios,
 589		// these (async) unlinks complete immediately
 590		retval = usb_unlink_urb (urb);
 591		if (retval != -EINPROGRESS && retval != 0)
 592			netdev_dbg(dev->net, "unlink urb err, %d\n", retval);
 593		else
 594			count++;
 
 
 595	}
 596	spin_unlock_irqrestore (&q->lock, flags);
 597	return count;
 598}
 599
 600// Flush all pending rx urbs
 601// minidrivers may need to do this when the MTU changes
 602
 603void usbnet_unlink_rx_urbs(struct usbnet *dev)
 604{
 605	if (netif_running(dev->net)) {
 606		(void) unlink_urbs (dev, &dev->rxq);
 607		tasklet_schedule(&dev->bh);
 608	}
 609}
 610EXPORT_SYMBOL_GPL(usbnet_unlink_rx_urbs);
 611
 612/*-------------------------------------------------------------------------*/
 613
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 614// precondition: never called in_interrupt
 615static void usbnet_terminate_urbs(struct usbnet *dev)
 616{
 617	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
 618	DECLARE_WAITQUEUE(wait, current);
 619	int temp;
 620
 621	/* ensure there are no more active urbs */
 622	add_wait_queue(&unlink_wakeup, &wait);
 623	set_current_state(TASK_UNINTERRUPTIBLE);
 624	dev->wait = &unlink_wakeup;
 625	temp = unlink_urbs(dev, &dev->txq) +
 626		unlink_urbs(dev, &dev->rxq);
 627
 628	/* maybe wait for deletions to finish. */
 629	while (!skb_queue_empty(&dev->rxq)
 630		&& !skb_queue_empty(&dev->txq)
 631		&& !skb_queue_empty(&dev->done)) {
 632			schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
 633			set_current_state(TASK_UNINTERRUPTIBLE);
 634			netif_dbg(dev, ifdown, dev->net,
 635				  "waited for %d urb completions\n", temp);
 636	}
 637	set_current_state(TASK_RUNNING);
 638	dev->wait = NULL;
 639	remove_wait_queue(&unlink_wakeup, &wait);
 640}
 641
 642int usbnet_stop (struct net_device *net)
 643{
 644	struct usbnet		*dev = netdev_priv(net);
 645	struct driver_info	*info = dev->driver_info;
 646	int			retval;
 647
 648	clear_bit(EVENT_DEV_OPEN, &dev->flags);
 649	netif_stop_queue (net);
 650
 651	netif_info(dev, ifdown, dev->net,
 652		   "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
 653		   net->stats.rx_packets, net->stats.tx_packets,
 654		   net->stats.rx_errors, net->stats.tx_errors);
 655
 
 
 656	/* allow minidriver to stop correctly (wireless devices to turn off
 657	 * radio etc) */
 658	if (info->stop) {
 659		retval = info->stop(dev);
 660		if (retval < 0)
 661			netif_info(dev, ifdown, dev->net,
 662				   "stop fail (%d) usbnet usb-%s-%s, %s\n",
 663				   retval,
 664				   dev->udev->bus->bus_name, dev->udev->devpath,
 665				   info->description);
 666	}
 667
 668	if (!(info->flags & FLAG_AVOID_UNLINK_URBS))
 669		usbnet_terminate_urbs(dev);
 670
 671	usb_kill_urb(dev->interrupt);
 672
 673	usbnet_purge_paused_rxq(dev);
 674
 
 
 675	/* deferred work (task, timer, softirq) must also stop.
 676	 * can't flush_scheduled_work() until we drop rtnl (later),
 677	 * else workers could deadlock; so make workers a NOP.
 678	 */
 679	dev->flags = 0;
 680	del_timer_sync (&dev->delay);
 681	tasklet_kill (&dev->bh);
 682	if (info->manage_power)
 
 
 
 683		info->manage_power(dev, 0);
 684	else
 685		usb_autopm_put_interface(dev->intf);
 686
 687	return 0;
 688}
 689EXPORT_SYMBOL_GPL(usbnet_stop);
 690
 691/*-------------------------------------------------------------------------*/
 692
 693// posts reads, and enables write queuing
 694
 695// precondition: never called in_interrupt
 696
 697int usbnet_open (struct net_device *net)
 698{
 699	struct usbnet		*dev = netdev_priv(net);
 700	int			retval;
 701	struct driver_info	*info = dev->driver_info;
 702
 703	if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
 704		netif_info(dev, ifup, dev->net,
 705			   "resumption fail (%d) usbnet usb-%s-%s, %s\n",
 706			   retval,
 707			   dev->udev->bus->bus_name,
 708			   dev->udev->devpath,
 709			   info->description);
 710		goto done_nopm;
 711	}
 712
 713	// put into "known safe" state
 714	if (info->reset && (retval = info->reset (dev)) < 0) {
 715		netif_info(dev, ifup, dev->net,
 716			   "open reset fail (%d) usbnet usb-%s-%s, %s\n",
 717			   retval,
 718			   dev->udev->bus->bus_name,
 719			   dev->udev->devpath,
 720			   info->description);
 721		goto done;
 722	}
 723
 
 
 
 724	// insist peer be connected
 725	if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
 726		netif_dbg(dev, ifup, dev->net, "can't open; %d\n", retval);
 727		goto done;
 728	}
 729
 730	/* start any status interrupt transfer */
 731	if (dev->interrupt) {
 732		retval = usb_submit_urb (dev->interrupt, GFP_KERNEL);
 733		if (retval < 0) {
 734			netif_err(dev, ifup, dev->net,
 735				  "intr submit %d\n", retval);
 736			goto done;
 737		}
 738	}
 739
 740	set_bit(EVENT_DEV_OPEN, &dev->flags);
 741	netif_start_queue (net);
 742	netif_info(dev, ifup, dev->net,
 743		   "open: enable queueing (rx %d, tx %d) mtu %d %s framing\n",
 744		   (int)RX_QLEN(dev), (int)TX_QLEN(dev),
 745		   dev->net->mtu,
 746		   (dev->driver_info->flags & FLAG_FRAMING_NC) ? "NetChip" :
 747		   (dev->driver_info->flags & FLAG_FRAMING_GL) ? "GeneSys" :
 748		   (dev->driver_info->flags & FLAG_FRAMING_Z) ? "Zaurus" :
 749		   (dev->driver_info->flags & FLAG_FRAMING_RN) ? "RNDIS" :
 750		   (dev->driver_info->flags & FLAG_FRAMING_AX) ? "ASIX" :
 751		   "simple");
 752
 
 
 
 
 
 753	// delay posting reads until we're fully open
 754	tasklet_schedule (&dev->bh);
 755	if (info->manage_power) {
 756		retval = info->manage_power(dev, 1);
 757		if (retval < 0)
 758			goto done;
 759		usb_autopm_put_interface(dev->intf);
 
 
 
 760	}
 761	return retval;
 762
 763done:
 764	usb_autopm_put_interface(dev->intf);
 765done_nopm:
 766	return retval;
 767}
 768EXPORT_SYMBOL_GPL(usbnet_open);
 769
 770/*-------------------------------------------------------------------------*/
 771
 772/* ethtool methods; minidrivers may need to add some more, but
 773 * they'll probably want to use this base set.
 774 */
 775
 776int usbnet_get_settings (struct net_device *net, struct ethtool_cmd *cmd)
 
 777{
 778	struct usbnet *dev = netdev_priv(net);
 779
 780	if (!dev->mii.mdio_read)
 781		return -EOPNOTSUPP;
 782
 783	return mii_ethtool_gset(&dev->mii, cmd);
 
 
 784}
 785EXPORT_SYMBOL_GPL(usbnet_get_settings);
 786
 787int usbnet_set_settings (struct net_device *net, struct ethtool_cmd *cmd)
 
 788{
 789	struct usbnet *dev = netdev_priv(net);
 790	int retval;
 791
 792	if (!dev->mii.mdio_write)
 793		return -EOPNOTSUPP;
 794
 795	retval = mii_ethtool_sset(&dev->mii, cmd);
 796
 797	/* link speed/duplex might have changed */
 798	if (dev->driver_info->link_reset)
 799		dev->driver_info->link_reset(dev);
 800
 
 
 
 801	return retval;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 802
 
 
 
 
 
 803}
 804EXPORT_SYMBOL_GPL(usbnet_set_settings);
 805
 806u32 usbnet_get_link (struct net_device *net)
 807{
 808	struct usbnet *dev = netdev_priv(net);
 809
 810	/* If a check_connect is defined, return its result */
 811	if (dev->driver_info->check_connect)
 812		return dev->driver_info->check_connect (dev) == 0;
 813
 814	/* if the device has mii operations, use those */
 815	if (dev->mii.mdio_read)
 816		return mii_link_ok(&dev->mii);
 817
 818	/* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */
 819	return ethtool_op_get_link(net);
 820}
 821EXPORT_SYMBOL_GPL(usbnet_get_link);
 822
 823int usbnet_nway_reset(struct net_device *net)
 824{
 825	struct usbnet *dev = netdev_priv(net);
 826
 827	if (!dev->mii.mdio_write)
 828		return -EOPNOTSUPP;
 829
 830	return mii_nway_restart(&dev->mii);
 831}
 832EXPORT_SYMBOL_GPL(usbnet_nway_reset);
 833
 834void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
 835{
 836	struct usbnet *dev = netdev_priv(net);
 837
 838	strncpy (info->driver, dev->driver_name, sizeof info->driver);
 839	strncpy (info->version, DRIVER_VERSION, sizeof info->version);
 840	strncpy (info->fw_version, dev->driver_info->description,
 841		sizeof info->fw_version);
 842	usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
 843}
 844EXPORT_SYMBOL_GPL(usbnet_get_drvinfo);
 845
 846u32 usbnet_get_msglevel (struct net_device *net)
 847{
 848	struct usbnet *dev = netdev_priv(net);
 849
 850	return dev->msg_enable;
 851}
 852EXPORT_SYMBOL_GPL(usbnet_get_msglevel);
 853
 854void usbnet_set_msglevel (struct net_device *net, u32 level)
 855{
 856	struct usbnet *dev = netdev_priv(net);
 857
 858	dev->msg_enable = level;
 859}
 860EXPORT_SYMBOL_GPL(usbnet_set_msglevel);
 861
 862/* drivers may override default ethtool_ops in their bind() routine */
 863static const struct ethtool_ops usbnet_ethtool_ops = {
 864	.get_settings		= usbnet_get_settings,
 865	.set_settings		= usbnet_set_settings,
 866	.get_link		= usbnet_get_link,
 867	.nway_reset		= usbnet_nway_reset,
 868	.get_drvinfo		= usbnet_get_drvinfo,
 869	.get_msglevel		= usbnet_get_msglevel,
 870	.set_msglevel		= usbnet_set_msglevel,
 
 
 
 871};
 872
 873/*-------------------------------------------------------------------------*/
 874
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 875/* work that cannot be done in interrupt context uses keventd.
 876 *
 877 * NOTE:  with 2.5 we could do more of this using completion callbacks,
 878 * especially now that control transfers can be queued.
 879 */
 880static void
 881kevent (struct work_struct *work)
 882{
 883	struct usbnet		*dev =
 884		container_of(work, struct usbnet, kevent);
 885	int			status;
 886
 887	/* usb_clear_halt() needs a thread context */
 888	if (test_bit (EVENT_TX_HALT, &dev->flags)) {
 889		unlink_urbs (dev, &dev->txq);
 890		status = usb_autopm_get_interface(dev->intf);
 891		if (status < 0)
 892			goto fail_pipe;
 893		status = usb_clear_halt (dev->udev, dev->out);
 894		usb_autopm_put_interface(dev->intf);
 895		if (status < 0 &&
 896		    status != -EPIPE &&
 897		    status != -ESHUTDOWN) {
 898			if (netif_msg_tx_err (dev))
 899fail_pipe:
 900				netdev_err(dev->net, "can't clear tx halt, status %d\n",
 901					   status);
 902		} else {
 903			clear_bit (EVENT_TX_HALT, &dev->flags);
 904			if (status != -ESHUTDOWN)
 905				netif_wake_queue (dev->net);
 906		}
 907	}
 908	if (test_bit (EVENT_RX_HALT, &dev->flags)) {
 909		unlink_urbs (dev, &dev->rxq);
 910		status = usb_autopm_get_interface(dev->intf);
 911		if (status < 0)
 912			goto fail_halt;
 913		status = usb_clear_halt (dev->udev, dev->in);
 914		usb_autopm_put_interface(dev->intf);
 915		if (status < 0 &&
 916		    status != -EPIPE &&
 917		    status != -ESHUTDOWN) {
 918			if (netif_msg_rx_err (dev))
 919fail_halt:
 920				netdev_err(dev->net, "can't clear rx halt, status %d\n",
 921					   status);
 922		} else {
 923			clear_bit (EVENT_RX_HALT, &dev->flags);
 924			tasklet_schedule (&dev->bh);
 925		}
 926	}
 927
 928	/* tasklet could resubmit itself forever if memory is tight */
 929	if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
 930		struct urb	*urb = NULL;
 931		int resched = 1;
 932
 933		if (netif_running (dev->net))
 934			urb = usb_alloc_urb (0, GFP_KERNEL);
 935		else
 936			clear_bit (EVENT_RX_MEMORY, &dev->flags);
 937		if (urb != NULL) {
 938			clear_bit (EVENT_RX_MEMORY, &dev->flags);
 939			status = usb_autopm_get_interface(dev->intf);
 940			if (status < 0) {
 941				usb_free_urb(urb);
 942				goto fail_lowmem;
 943			}
 944			if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
 945				resched = 0;
 946			usb_autopm_put_interface(dev->intf);
 947fail_lowmem:
 948			if (resched)
 949				tasklet_schedule (&dev->bh);
 950		}
 951	}
 952
 953	if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
 954		struct driver_info	*info = dev->driver_info;
 955		int			retval = 0;
 956
 957		clear_bit (EVENT_LINK_RESET, &dev->flags);
 958		status = usb_autopm_get_interface(dev->intf);
 959		if (status < 0)
 960			goto skip_reset;
 961		if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
 962			usb_autopm_put_interface(dev->intf);
 963skip_reset:
 964			netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s\n",
 965				    retval,
 966				    dev->udev->bus->bus_name,
 967				    dev->udev->devpath,
 968				    info->description);
 969		} else {
 970			usb_autopm_put_interface(dev->intf);
 971		}
 
 
 
 972	}
 973
 
 
 
 
 
 
 
 974	if (dev->flags)
 975		netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags);
 976}
 977
 978/*-------------------------------------------------------------------------*/
 979
 980static void tx_complete (struct urb *urb)
 981{
 982	struct sk_buff		*skb = (struct sk_buff *) urb->context;
 983	struct skb_data		*entry = (struct skb_data *) skb->cb;
 984	struct usbnet		*dev = entry->dev;
 985
 986	if (urb->status == 0) {
 987		if (!(dev->driver_info->flags & FLAG_MULTI_PACKET))
 988			dev->net->stats.tx_packets++;
 989		dev->net->stats.tx_bytes += entry->length;
 
 
 
 
 990	} else {
 991		dev->net->stats.tx_errors++;
 992
 993		switch (urb->status) {
 994		case -EPIPE:
 995			usbnet_defer_kevent (dev, EVENT_TX_HALT);
 996			break;
 997
 998		/* software-driven interface shutdown */
 999		case -ECONNRESET:		// async unlink
1000		case -ESHUTDOWN:		// hardware gone
1001			break;
1002
1003		// like rx, tx gets controller i/o faults during khubd delays
1004		// and so it uses the same throttling mechanism.
 
1005		case -EPROTO:
1006		case -ETIME:
1007		case -EILSEQ:
1008			usb_mark_last_busy(dev->udev);
1009			if (!timer_pending (&dev->delay)) {
1010				mod_timer (&dev->delay,
1011					jiffies + THROTTLE_JIFFIES);
1012				netif_dbg(dev, link, dev->net,
1013					  "tx throttle %d\n", urb->status);
1014			}
1015			netif_stop_queue (dev->net);
1016			break;
1017		default:
1018			netif_dbg(dev, tx_err, dev->net,
1019				  "tx err %d\n", entry->urb->status);
1020			break;
1021		}
1022	}
1023
1024	usb_autopm_put_interface_async(dev->intf);
1025	urb->dev = NULL;
1026	entry->state = tx_done;
1027	defer_bh(dev, skb, &dev->txq);
1028}
1029
1030/*-------------------------------------------------------------------------*/
1031
1032void usbnet_tx_timeout (struct net_device *net)
1033{
1034	struct usbnet		*dev = netdev_priv(net);
1035
1036	unlink_urbs (dev, &dev->txq);
1037	tasklet_schedule (&dev->bh);
1038
1039	// FIXME: device recovery -- reset?
 
 
 
 
1040}
1041EXPORT_SYMBOL_GPL(usbnet_tx_timeout);
1042
1043/*-------------------------------------------------------------------------*/
1044
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1045netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
1046				     struct net_device *net)
1047{
1048	struct usbnet		*dev = netdev_priv(net);
1049	int			length;
1050	struct urb		*urb = NULL;
1051	struct skb_data		*entry;
1052	struct driver_info	*info = dev->driver_info;
1053	unsigned long		flags;
1054	int retval;
1055
 
 
 
1056	// some devices want funky USB-level framing, for
1057	// win32 driver (usually) and/or hardware quirks
1058	if (info->tx_fixup) {
1059		skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
1060		if (!skb) {
1061			if (netif_msg_tx_err(dev)) {
1062				netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb\n");
1063				goto drop;
1064			} else {
1065				/* cdc_ncm collected packet; waits for more */
1066				goto not_drop;
1067			}
 
1068		}
1069	}
1070	length = skb->len;
1071
1072	if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {
1073		netif_dbg(dev, tx_err, dev->net, "no urb\n");
1074		goto drop;
1075	}
1076
1077	entry = (struct skb_data *) skb->cb;
1078	entry->urb = urb;
1079	entry->dev = dev;
1080	entry->state = tx_start;
1081	entry->length = length;
1082
1083	usb_fill_bulk_urb (urb, dev->udev, dev->out,
1084			skb->data, skb->len, tx_complete, skb);
 
 
 
 
 
1085
1086	/* don't assume the hardware handles USB_ZERO_PACKET
1087	 * NOTE:  strictly conforming cdc-ether devices should expect
1088	 * the ZLP here, but ignore the one-byte packet.
1089	 * NOTE2: CDC NCM specification is different from CDC ECM when
1090	 * handling ZLP/short packets, so cdc_ncm driver will make short
1091	 * packet itself if needed.
1092	 */
1093	if (length % dev->maxpacket == 0) {
1094		if (!(info->flags & FLAG_SEND_ZLP)) {
1095			if (!(info->flags & FLAG_MULTI_PACKET)) {
1096				urb->transfer_buffer_length++;
1097				if (skb_tailroom(skb)) {
1098					skb->data[skb->len] = 0;
1099					__skb_put(skb, 1);
1100				}
 
 
1101			}
1102		} else
1103			urb->transfer_flags |= URB_ZERO_PACKET;
1104	}
 
 
 
 
 
 
 
 
 
 
 
 
 
1105
1106	spin_lock_irqsave(&dev->txq.lock, flags);
1107	retval = usb_autopm_get_interface_async(dev->intf);
1108	if (retval < 0) {
1109		spin_unlock_irqrestore(&dev->txq.lock, flags);
1110		goto drop;
1111	}
 
 
 
 
 
1112
1113#ifdef CONFIG_PM
1114	/* if this triggers the device is still a sleep */
1115	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
1116		/* transmission will be done in resume */
1117		usb_anchor_urb(urb, &dev->deferred);
1118		/* no use to process more packets */
1119		netif_stop_queue(net);
 
1120		spin_unlock_irqrestore(&dev->txq.lock, flags);
1121		netdev_dbg(dev->net, "Delaying transmission for resumption\n");
1122		goto deferred;
1123	}
1124#endif
1125
1126	switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {
1127	case -EPIPE:
1128		netif_stop_queue (net);
1129		usbnet_defer_kevent (dev, EVENT_TX_HALT);
1130		usb_autopm_put_interface_async(dev->intf);
1131		break;
1132	default:
1133		usb_autopm_put_interface_async(dev->intf);
1134		netif_dbg(dev, tx_err, dev->net,
1135			  "tx: submit urb err %d\n", retval);
1136		break;
1137	case 0:
1138		net->trans_start = jiffies;
1139		__skb_queue_tail (&dev->txq, skb);
1140		if (dev->txq.qlen >= TX_QLEN (dev))
1141			netif_stop_queue (net);
1142	}
1143	spin_unlock_irqrestore (&dev->txq.lock, flags);
1144
1145	if (retval) {
1146		netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval);
1147drop:
1148		dev->net->stats.tx_dropped++;
1149not_drop:
1150		if (skb)
1151			dev_kfree_skb_any (skb);
1152		usb_free_urb (urb);
 
 
 
1153	} else
1154		netif_dbg(dev, tx_queued, dev->net,
1155			  "> tx, len %d, type 0x%x\n", length, skb->protocol);
1156#ifdef CONFIG_PM
1157deferred:
1158#endif
1159	return NETDEV_TX_OK;
1160}
1161EXPORT_SYMBOL_GPL(usbnet_start_xmit);
1162
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1163/*-------------------------------------------------------------------------*/
1164
1165// tasklet (work deferred from completions, in_irq) or timer
1166
1167static void usbnet_bh (unsigned long param)
1168{
1169	struct usbnet		*dev = (struct usbnet *) param;
1170	struct sk_buff		*skb;
1171	struct skb_data		*entry;
1172
1173	while ((skb = skb_dequeue (&dev->done))) {
1174		entry = (struct skb_data *) skb->cb;
1175		switch (entry->state) {
1176		case rx_done:
1177			entry->state = rx_cleanup;
1178			rx_process (dev, skb);
1179			continue;
1180		case tx_done:
 
 
1181		case rx_cleanup:
1182			usb_free_urb (entry->urb);
1183			dev_kfree_skb (skb);
1184			continue;
1185		default:
1186			netdev_dbg(dev->net, "bogus skb state %d\n", entry->state);
1187		}
1188	}
1189
1190	// waiting for all pending urbs to complete?
1191	if (dev->wait) {
1192		if ((dev->txq.qlen + dev->rxq.qlen + dev->done.qlen) == 0) {
1193			wake_up (dev->wait);
1194		}
 
 
 
 
1195
1196	// or are we maybe short a few urbs?
1197	} else if (netif_running (dev->net) &&
1198		   netif_device_present (dev->net) &&
1199		   !timer_pending (&dev->delay) &&
1200		   !test_bit (EVENT_RX_HALT, &dev->flags)) {
 
 
1201		int	temp = dev->rxq.qlen;
1202		int	qlen = RX_QLEN (dev);
1203
1204		if (temp < qlen) {
1205			struct urb	*urb;
1206			int		i;
1207
1208			// don't refill the queue all at once
1209			for (i = 0; i < 10 && dev->rxq.qlen < qlen; i++) {
1210				urb = usb_alloc_urb (0, GFP_ATOMIC);
1211				if (urb != NULL) {
1212					if (rx_submit (dev, urb, GFP_ATOMIC) ==
1213					    -ENOLINK)
1214						return;
1215				}
1216			}
1217			if (temp != dev->rxq.qlen)
1218				netif_dbg(dev, link, dev->net,
1219					  "rxqlen %d --> %d\n",
1220					  temp, dev->rxq.qlen);
1221			if (dev->rxq.qlen < qlen)
1222				tasklet_schedule (&dev->bh);
1223		}
1224		if (dev->txq.qlen < TX_QLEN (dev))
1225			netif_wake_queue (dev->net);
1226	}
1227}
1228
 
 
 
 
 
 
 
1229
1230/*-------------------------------------------------------------------------
1231 *
1232 * USB Device Driver support
1233 *
1234 *-------------------------------------------------------------------------*/
1235
1236// precondition: never called in_interrupt
1237
1238void usbnet_disconnect (struct usb_interface *intf)
1239{
1240	struct usbnet		*dev;
1241	struct usb_device	*xdev;
1242	struct net_device	*net;
1243
1244	dev = usb_get_intfdata(intf);
1245	usb_set_intfdata(intf, NULL);
1246	if (!dev)
1247		return;
1248
1249	xdev = interface_to_usbdev (intf);
1250
1251	netif_info(dev, probe, dev->net, "unregister '%s' usb-%s-%s, %s\n",
1252		   intf->dev.driver->name,
1253		   xdev->bus->bus_name, xdev->devpath,
1254		   dev->driver_info->description);
1255
1256	net = dev->net;
1257	unregister_netdev (net);
1258
1259	cancel_work_sync(&dev->kevent);
1260
 
 
1261	if (dev->driver_info->unbind)
1262		dev->driver_info->unbind (dev, intf);
1263
1264	usb_kill_urb(dev->interrupt);
1265	usb_free_urb(dev->interrupt);
 
1266
 
1267	free_netdev(net);
1268	usb_put_dev (xdev);
1269}
1270EXPORT_SYMBOL_GPL(usbnet_disconnect);
1271
1272static const struct net_device_ops usbnet_netdev_ops = {
1273	.ndo_open		= usbnet_open,
1274	.ndo_stop		= usbnet_stop,
1275	.ndo_start_xmit		= usbnet_start_xmit,
1276	.ndo_tx_timeout		= usbnet_tx_timeout,
 
1277	.ndo_change_mtu		= usbnet_change_mtu,
 
1278	.ndo_set_mac_address 	= eth_mac_addr,
1279	.ndo_validate_addr	= eth_validate_addr,
1280};
1281
1282/*-------------------------------------------------------------------------*/
1283
1284// precondition: never called in_interrupt
1285
1286static struct device_type wlan_type = {
1287	.name	= "wlan",
1288};
1289
1290static struct device_type wwan_type = {
1291	.name	= "wwan",
1292};
1293
1294int
1295usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
1296{
1297	struct usbnet			*dev;
1298	struct net_device		*net;
1299	struct usb_host_interface	*interface;
1300	struct driver_info		*info;
1301	struct usb_device		*xdev;
1302	int				status;
1303	const char			*name;
1304	struct usb_driver 	*driver = to_usb_driver(udev->dev.driver);
1305
1306	/* usbnet already took usb runtime pm, so have to enable the feature
1307	 * for usb interface, otherwise usb_autopm_get_interface may return
1308	 * failure if USB_SUSPEND(RUNTIME_PM) is enabled.
1309	 */
1310	if (!driver->supports_autosuspend) {
1311		driver->supports_autosuspend = 1;
1312		pm_runtime_enable(&udev->dev);
1313	}
1314
1315	name = udev->dev.driver->name;
1316	info = (struct driver_info *) prod->driver_info;
1317	if (!info) {
1318		dev_dbg (&udev->dev, "blacklisted by %s\n", name);
1319		return -ENODEV;
1320	}
1321	xdev = interface_to_usbdev (udev);
1322	interface = udev->cur_altsetting;
1323
1324	usb_get_dev (xdev);
1325
1326	status = -ENOMEM;
1327
1328	// set up our own records
1329	net = alloc_etherdev(sizeof(*dev));
1330	if (!net) {
1331		dbg ("can't kmalloc dev");
1332		goto out;
1333	}
1334
1335	/* netdev_printk() needs this so do it as early as possible */
1336	SET_NETDEV_DEV(net, &udev->dev);
1337
1338	dev = netdev_priv(net);
1339	dev->udev = xdev;
1340	dev->intf = udev;
1341	dev->driver_info = info;
1342	dev->driver_name = name;
 
 
 
 
 
1343	dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV
1344				| NETIF_MSG_PROBE | NETIF_MSG_LINK);
 
1345	skb_queue_head_init (&dev->rxq);
1346	skb_queue_head_init (&dev->txq);
1347	skb_queue_head_init (&dev->done);
1348	skb_queue_head_init(&dev->rxq_pause);
1349	dev->bh.func = usbnet_bh;
1350	dev->bh.data = (unsigned long) dev;
1351	INIT_WORK (&dev->kevent, kevent);
1352	init_usb_anchor(&dev->deferred);
1353	dev->delay.function = usbnet_bh;
1354	dev->delay.data = (unsigned long) dev;
1355	init_timer (&dev->delay);
1356	mutex_init (&dev->phy_mutex);
 
 
1357
1358	dev->net = net;
1359	strcpy (net->name, "usb%d");
1360	memcpy (net->dev_addr, node_id, sizeof node_id);
1361
1362	/* rx and tx sides can use different message sizes;
1363	 * bind() should set rx_urb_size in that case.
1364	 */
1365	dev->hard_mtu = net->mtu + net->hard_header_len;
1366#if 0
1367// dma_supported() is deeply broken on almost all architectures
1368	// possible with some EHCI controllers
1369	if (dma_supported (&udev->dev, DMA_BIT_MASK(64)))
1370		net->features |= NETIF_F_HIGHDMA;
1371#endif
1372
1373	net->netdev_ops = &usbnet_netdev_ops;
1374	net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
1375	net->ethtool_ops = &usbnet_ethtool_ops;
1376
1377	// allow device-specific bind/init procedures
1378	// NOTE net->name still not usable ...
1379	if (info->bind) {
1380		status = info->bind (dev, udev);
1381		if (status < 0)
1382			goto out1;
1383
1384		// heuristic:  "usb%d" for links we know are two-host,
1385		// else "eth%d" when there's reasonable doubt.  userspace
1386		// can rename the link if it knows better.
1387		if ((dev->driver_info->flags & FLAG_ETHER) != 0 &&
1388		    ((dev->driver_info->flags & FLAG_POINTTOPOINT) == 0 ||
1389		     (net->dev_addr [0] & 0x02) == 0))
1390			strcpy (net->name, "eth%d");
1391		/* WLAN devices should always be named "wlan%d" */
1392		if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1393			strcpy(net->name, "wlan%d");
1394		/* WWAN devices should always be named "wwan%d" */
1395		if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1396			strcpy(net->name, "wwan%d");
1397
 
 
 
 
1398		/* maybe the remote can't receive an Ethernet MTU */
1399		if (net->mtu > (dev->hard_mtu - net->hard_header_len))
1400			net->mtu = dev->hard_mtu - net->hard_header_len;
1401	} else if (!info->in || !info->out)
1402		status = usbnet_get_endpoints (dev, udev);
1403	else {
1404		dev->in = usb_rcvbulkpipe (xdev, info->in);
1405		dev->out = usb_sndbulkpipe (xdev, info->out);
1406		if (!(info->flags & FLAG_NO_SETINT))
1407			status = usb_set_interface (xdev,
1408				interface->desc.bInterfaceNumber,
1409				interface->desc.bAlternateSetting);
1410		else
1411			status = 0;
1412
1413	}
1414	if (status >= 0 && dev->status)
1415		status = init_status (dev, udev);
1416	if (status < 0)
1417		goto out3;
1418
1419	if (!dev->rx_urb_size)
1420		dev->rx_urb_size = dev->hard_mtu;
1421	dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);
1422
 
 
 
 
1423	if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1424		SET_NETDEV_DEVTYPE(net, &wlan_type);
1425	if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1426		SET_NETDEV_DEVTYPE(net, &wwan_type);
1427
 
 
 
 
 
 
 
 
 
 
 
 
1428	status = register_netdev (net);
1429	if (status)
1430		goto out3;
1431	netif_info(dev, probe, dev->net,
1432		   "register '%s' at usb-%s-%s, %s, %pM\n",
1433		   udev->dev.driver->name,
1434		   xdev->bus->bus_name, xdev->devpath,
1435		   dev->driver_info->description,
1436		   net->dev_addr);
1437
1438	// ok, it's ready to go.
1439	usb_set_intfdata (udev, dev);
1440
1441	netif_device_attach (net);
1442
1443	if (dev->driver_info->flags & FLAG_LINK_INTR)
1444		netif_carrier_off(net);
1445
1446	return 0;
1447
 
 
 
 
1448out3:
1449	if (info->unbind)
1450		info->unbind (dev, udev);
1451out1:
 
 
 
 
 
 
 
 
 
1452	free_netdev(net);
1453out:
1454	usb_put_dev(xdev);
1455	return status;
1456}
1457EXPORT_SYMBOL_GPL(usbnet_probe);
1458
1459/*-------------------------------------------------------------------------*/
1460
1461/*
1462 * suspend the whole driver as soon as the first interface is suspended
1463 * resume only when the last interface is resumed
1464 */
1465
1466int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
1467{
1468	struct usbnet		*dev = usb_get_intfdata(intf);
1469
1470	if (!dev->suspend_count++) {
1471		spin_lock_irq(&dev->txq.lock);
1472		/* don't autosuspend while transmitting */
1473		if (dev->txq.qlen && (message.event & PM_EVENT_AUTO)) {
 
1474			spin_unlock_irq(&dev->txq.lock);
1475			return -EBUSY;
1476		} else {
1477			set_bit(EVENT_DEV_ASLEEP, &dev->flags);
1478			spin_unlock_irq(&dev->txq.lock);
1479		}
1480		/*
1481		 * accelerate emptying of the rx and queues, to avoid
1482		 * having everything error out.
1483		 */
1484		netif_device_detach (dev->net);
1485		usbnet_terminate_urbs(dev);
1486		usb_kill_urb(dev->interrupt);
1487
1488		/*
1489		 * reattach so runtime management can use and
1490		 * wake the device
1491		 */
1492		netif_device_attach (dev->net);
1493	}
1494	return 0;
1495}
1496EXPORT_SYMBOL_GPL(usbnet_suspend);
1497
1498int usbnet_resume (struct usb_interface *intf)
1499{
1500	struct usbnet		*dev = usb_get_intfdata(intf);
1501	struct sk_buff          *skb;
1502	struct urb              *res;
1503	int                     retval;
1504
1505	if (!--dev->suspend_count) {
1506		/* resume interrupt URBs */
1507		if (dev->interrupt && test_bit(EVENT_DEV_OPEN, &dev->flags))
1508			usb_submit_urb(dev->interrupt, GFP_NOIO);
1509
1510		spin_lock_irq(&dev->txq.lock);
1511		while ((res = usb_get_from_anchor(&dev->deferred))) {
1512
1513			skb = (struct sk_buff *)res->context;
1514			retval = usb_submit_urb(res, GFP_ATOMIC);
1515			if (retval < 0) {
1516				dev_kfree_skb_any(skb);
 
1517				usb_free_urb(res);
1518				usb_autopm_put_interface_async(dev->intf);
1519			} else {
1520				dev->net->trans_start = jiffies;
1521				__skb_queue_tail(&dev->txq, skb);
1522			}
1523		}
1524
1525		smp_mb();
1526		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
1527		spin_unlock_irq(&dev->txq.lock);
1528
1529		if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
 
 
 
 
 
 
 
 
1530			if (!(dev->txq.qlen >= TX_QLEN(dev)))
1531				netif_start_queue(dev->net);
1532			tasklet_schedule (&dev->bh);
1533		}
1534	}
 
 
 
 
1535	return 0;
1536}
1537EXPORT_SYMBOL_GPL(usbnet_resume);
1538
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1539
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1540/*-------------------------------------------------------------------------*/
1541
1542static int __init usbnet_init(void)
1543{
1544	/* Compiler should optimize this out. */
1545	BUILD_BUG_ON(
1546		FIELD_SIZEOF(struct sk_buff, cb) < sizeof(struct skb_data));
1547
1548	random_ether_addr(node_id);
1549	return 0;
1550}
1551module_init(usbnet_init);
1552
1553static void __exit usbnet_exit(void)
1554{
1555}
1556module_exit(usbnet_exit);
1557
1558MODULE_AUTHOR("David Brownell");
1559MODULE_DESCRIPTION("USB network driver framework");
1560MODULE_LICENSE("GPL");