usbnet.c 54.1 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * USB Network driver infrastructure
3
 * Copyright (C) 2000-2005 by David Brownell
L
Linus Torvalds 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16
 * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
17
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
L
Linus Torvalds 已提交
18 19 20 21
 */

/*
 * This is a generic "USB networking" framework that works with several
22 23
 * kinds of full and high speed networking devices:  host-to-host cables,
 * smart usb peripherals, and actual Ethernet adapters.
L
Linus Torvalds 已提交
24
 *
25 26 27 28 29 30
 * These devices usually differ in terms of control protocols (if they
 * even have one!) and sometimes they define new framing to wrap or batch
 * Ethernet packets.  Otherwise, they talk to USB pretty much the same,
 * so interface (un)binding, endpoint I/O queues, fault handling, and other
 * issues can usefully be addressed by this framework.
 */
L
Linus Torvalds 已提交
31 32 33 34 35 36 37 38

// #define	DEBUG			// error path messages, extra info
// #define	VERBOSE			// more; success messages

#include <linux/module.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
39
#include <linux/ctype.h>
L
Linus Torvalds 已提交
40 41 42 43
#include <linux/ethtool.h>
#include <linux/workqueue.h>
#include <linux/mii.h>
#include <linux/usb.h>
44
#include <linux/usb/usbnet.h>
45
#include <linux/slab.h>
46
#include <linux/kernel.h>
47
#include <linux/pm_runtime.h>
48 49

#define DRIVER_VERSION		"22-Aug-2005"
L
Linus Torvalds 已提交
50 51 52 53 54 55 56 57 58 59


/*-------------------------------------------------------------------------*/

/*
 * Nineteen USB 1.1 max size bulk transactions per frame (ms), max.
 * Several dozen bytes of IPv4 data can fit in two such transactions.
 * One maximum size Ethernet packet takes twenty four of them.
 * For high speed, each frame comfortably fits almost 36 max size
 * Ethernet packets (so queues should be bigger).
60
 *
61 62 63
 * The goal is to let the USB host controller be busy for 5msec or
 * more before an irq is required, under load.  Jumbograms change
 * the equation.
L
Linus Torvalds 已提交
64
 */
65 66 67
#define	MAX_QUEUE_MEMORY	(60 * 1518)
#define	RX_QLEN(dev)		((dev)->rx_qlen)
#define	TX_QLEN(dev)		((dev)->tx_qlen)
L
Linus Torvalds 已提交
68 69 70 71

// reawaken network queue this soon after stopping; else watchdog barks
#define TX_TIMEOUT_JIFFIES	(5*HZ)

72 73 74
/* throttle rx/tx briefly after some faults, so hub_wq might disconnect()
 * us (it polls at HZ/4 usually) before we report too many false errors.
 */
L
Linus Torvalds 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
#define THROTTLE_JIFFIES	(HZ/8)

// between wakeups
#define UNLINK_TIMEOUT_MS	3

/*-------------------------------------------------------------------------*/

// randomly generated ethernet address
static u8	node_id [ETH_ALEN];

static const char driver_name [] = "usbnet";

/* use ethtool to change the level for any given device */
static int msg_level = -1;
module_param (msg_level, int, 0);
MODULE_PARM_DESC (msg_level, "Override default message level");

/*-------------------------------------------------------------------------*/

/* handles CDC Ethernet and many other network "bulk data" interfaces */
95
int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
L
Linus Torvalds 已提交
96 97 98 99 100 101 102 103 104 105 106 107 108 109
{
	int				tmp;
	struct usb_host_interface	*alt = NULL;
	struct usb_host_endpoint	*in = NULL, *out = NULL;
	struct usb_host_endpoint	*status = NULL;

	for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
		unsigned	ep;

		in = out = status = NULL;
		alt = intf->altsetting + tmp;

		/* take the first altsetting with in-bulk + out-bulk;
		 * remember any status endpoint, just in case;
110
		 * ignore other endpoints and altsettings.
L
Linus Torvalds 已提交
111 112 113 114 115 116 117 118
		 */
		for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
			struct usb_host_endpoint	*e;
			int				intr = 0;

			e = alt->endpoint + ep;
			switch (e->desc.bmAttributes) {
			case USB_ENDPOINT_XFER_INT:
119
				if (!usb_endpoint_dir_in(&e->desc))
L
Linus Torvalds 已提交
120 121 122 123 124 125 126 127
					continue;
				intr = 1;
				/* FALLTHROUGH */
			case USB_ENDPOINT_XFER_BULK:
				break;
			default:
				continue;
			}
128
			if (usb_endpoint_dir_in(&e->desc)) {
L
Linus Torvalds 已提交
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
				if (!intr && !in)
					in = e;
				else if (intr && !status)
					status = e;
			} else {
				if (!out)
					out = e;
			}
		}
		if (in && out)
			break;
	}
	if (!alt || !in || !out)
		return -EINVAL;

144 145
	if (alt->desc.bAlternateSetting != 0 ||
	    !(dev->driver_info->flags & FLAG_NO_SETINT)) {
L
Linus Torvalds 已提交
146 147 148 149 150
		tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber,
				alt->desc.bAlternateSetting);
		if (tmp < 0)
			return tmp;
	}
151

L
Linus Torvalds 已提交
152 153 154 155 156 157 158
	dev->in = usb_rcvbulkpipe (dev->udev,
			in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
	dev->out = usb_sndbulkpipe (dev->udev,
			out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
	dev->status = status;
	return 0;
}
159
EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
L
Linus Torvalds 已提交
160

161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
{
	int 		tmp, i;
	unsigned char	buf [13];

	tmp = usb_string(dev->udev, iMACAddress, buf, sizeof buf);
	if (tmp != 12) {
		dev_dbg(&dev->udev->dev,
			"bad MAC string %d fetch, %d\n", iMACAddress, tmp);
		if (tmp >= 0)
			tmp = -EINVAL;
		return tmp;
	}
	for (i = tmp = 0; i < 6; i++, tmp += 2)
		dev->net->dev_addr [i] =
176
			(hex_to_bin(buf[tmp]) << 4) + hex_to_bin(buf[tmp + 1]);
177 178 179 180
	return 0;
}
EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);

181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
static void intr_complete (struct urb *urb)
{
	struct usbnet	*dev = urb->context;
	int		status = urb->status;

	switch (status) {
	/* success */
	case 0:
		dev->driver_info->status(dev, urb);
		break;

	/* software-driven interface shutdown */
	case -ENOENT:		/* urb killed */
	case -ESHUTDOWN:	/* hardware gone */
		netif_dbg(dev, ifdown, dev->net,
			  "intr shutdown, code %d\n", status);
		return;

	/* NOTE:  not throttling like RX/TX, since this endpoint
	 * already polls infrequently
	 */
	default:
		netdev_dbg(dev->net, "intr status %d\n", status);
		break;
	}

	status = usb_submit_urb (urb, GFP_ATOMIC);
	if (status != 0)
		netif_err(dev, timer, dev->net,
			  "intr resubmit --> %d\n", status);
}
L
Linus Torvalds 已提交
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231

static int init_status (struct usbnet *dev, struct usb_interface *intf)
{
	char		*buf = NULL;
	unsigned	pipe = 0;
	unsigned	maxp;
	unsigned	period;

	if (!dev->driver_info->status)
		return 0;

	pipe = usb_rcvintpipe (dev->udev,
			dev->status->desc.bEndpointAddress
				& USB_ENDPOINT_NUMBER_MASK);
	maxp = usb_maxpacket (dev->udev, pipe, 0);

	/* avoid 1 msec chatter:  min 8 msec poll rate */
	period = max ((int) dev->status->desc.bInterval,
		(dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3);

232
	buf = kmalloc (maxp, GFP_KERNEL);
L
Linus Torvalds 已提交
233
	if (buf) {
234
		dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);
L
Linus Torvalds 已提交
235 236 237 238 239 240
		if (!dev->interrupt) {
			kfree (buf);
			return -ENOMEM;
		} else {
			usb_fill_int_urb(dev->interrupt, dev->udev, pipe,
				buf, maxp, intr_complete, dev, period);
241
			dev->interrupt->transfer_flags |= URB_FREE_BUFFER;
L
Linus Torvalds 已提交
242 243 244 245 246
			dev_dbg(&intf->dev,
				"status ep%din, %d bytes period %d\n",
				usb_pipeendpoint(pipe), maxp, period);
		}
	}
D
David Brownell 已提交
247
	return 0;
L
Linus Torvalds 已提交
248 249
}

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
/* Submit the interrupt URB if not previously submitted, increasing refcount */
int usbnet_status_start(struct usbnet *dev, gfp_t mem_flags)
{
	int ret = 0;

	WARN_ON_ONCE(dev->interrupt == NULL);
	if (dev->interrupt) {
		mutex_lock(&dev->interrupt_mutex);

		if (++dev->interrupt_count == 1)
			ret = usb_submit_urb(dev->interrupt, mem_flags);

		dev_dbg(&dev->udev->dev, "incremented interrupt URB count to %d\n",
			dev->interrupt_count);
		mutex_unlock(&dev->interrupt_mutex);
	}
	return ret;
}
EXPORT_SYMBOL_GPL(usbnet_status_start);

/* For resume; submit interrupt URB if previously submitted */
static int __usbnet_status_start_force(struct usbnet *dev, gfp_t mem_flags)
{
	int ret = 0;

	mutex_lock(&dev->interrupt_mutex);
	if (dev->interrupt_count) {
		ret = usb_submit_urb(dev->interrupt, mem_flags);
		dev_dbg(&dev->udev->dev,
			"submitted interrupt URB for resume\n");
	}
	mutex_unlock(&dev->interrupt_mutex);
	return ret;
}

/* Kill the interrupt URB if all submitters want it killed */
void usbnet_status_stop(struct usbnet *dev)
{
	if (dev->interrupt) {
		mutex_lock(&dev->interrupt_mutex);
		WARN_ON(dev->interrupt_count == 0);

		if (dev->interrupt_count && --dev->interrupt_count == 0)
			usb_kill_urb(dev->interrupt);

		dev_dbg(&dev->udev->dev,
			"decremented interrupt URB count to %d\n",
			dev->interrupt_count);
		mutex_unlock(&dev->interrupt_mutex);
	}
}
EXPORT_SYMBOL_GPL(usbnet_status_stop);

/* For suspend; always kill interrupt URB */
static void __usbnet_status_stop_force(struct usbnet *dev)
{
	if (dev->interrupt) {
		mutex_lock(&dev->interrupt_mutex);
		usb_kill_urb(dev->interrupt);
		dev_dbg(&dev->udev->dev, "killed interrupt URB for suspend\n");
		mutex_unlock(&dev->interrupt_mutex);
	}
}

314 315 316 317 318
/* Passes this packet up the stack, updating its accounting.
 * Some link protocols batch packets, so their rx_fixup paths
 * can return clones as well as just modify the original skb.
 */
void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
L
Linus Torvalds 已提交
319 320 321
{
	int	status;

J
Jussi Kivilinna 已提交
322 323 324 325 326
	if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
		skb_queue_tail(&dev->rxq_pause, skb);
		return;
	}

L
Linus Torvalds 已提交
327
	skb->protocol = eth_type_trans (skb, dev->net);
H
Herbert Xu 已提交
328 329
	dev->net->stats.rx_packets++;
	dev->net->stats.rx_bytes += skb->len;
L
Linus Torvalds 已提交
330

331 332
	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
		  skb->len + sizeof (struct ethhdr), skb->protocol);
L
Linus Torvalds 已提交
333
	memset (skb->cb, 0, sizeof (struct skb_data));
334 335 336 337

	if (skb_defer_rx_timestamp(skb))
		return;

L
Linus Torvalds 已提交
338
	status = netif_rx (skb);
339 340 341
	if (status != NET_RX_SUCCESS)
		netif_dbg(dev, rx_err, dev->net,
			  "netif_rx status %d\n", status);
L
Linus Torvalds 已提交
342
}
343
EXPORT_SYMBOL_GPL(usbnet_skb_return);
L
Linus Torvalds 已提交
344

345 346 347 348 349 350 351 352 353 354
/* must be called if hard_mtu or rx_urb_size changed */
void usbnet_update_max_qlen(struct usbnet *dev)
{
	enum usb_device_speed speed = dev->udev->speed;

	switch (speed) {
	case USB_SPEED_HIGH:
		dev->rx_qlen = MAX_QUEUE_MEMORY / dev->rx_urb_size;
		dev->tx_qlen = MAX_QUEUE_MEMORY / dev->hard_mtu;
		break;
355 356 357 358 359 360 361 362 363
	case USB_SPEED_SUPER:
		/*
		 * Not take default 5ms qlen for super speed HC to
		 * save memory, and iperf tests show 2.5ms qlen can
		 * work well
		 */
		dev->rx_qlen = 5 * MAX_QUEUE_MEMORY / dev->rx_urb_size;
		dev->tx_qlen = 5 * MAX_QUEUE_MEMORY / dev->hard_mtu;
		break;
364 365 366 367 368 369
	default:
		dev->rx_qlen = dev->tx_qlen = 4;
	}
}
EXPORT_SYMBOL_GPL(usbnet_update_max_qlen);

L
Linus Torvalds 已提交
370 371 372 373 374 375 376

/*-------------------------------------------------------------------------
 *
 * Network Device Driver (peer link to "Host Device", from USB host)
 *
 *-------------------------------------------------------------------------*/

377
int usbnet_change_mtu (struct net_device *net, int new_mtu)
L
Linus Torvalds 已提交
378 379
{
	struct usbnet	*dev = netdev_priv(net);
380
	int		ll_mtu = new_mtu + net->hard_header_len;
381 382
	int		old_hard_mtu = dev->hard_mtu;
	int		old_rx_urb_size = dev->rx_urb_size;
L
Linus Torvalds 已提交
383

384
	if (new_mtu <= 0)
L
Linus Torvalds 已提交
385 386
		return -EINVAL;
	// no second zero-length packet read wanted after mtu-sized packets
387
	if ((ll_mtu % dev->maxpacket) == 0)
L
Linus Torvalds 已提交
388 389
		return -EDOM;
	net->mtu = new_mtu;
390 391 392 393 394 395 396 397

	dev->hard_mtu = net->mtu + net->hard_header_len;
	if (dev->rx_urb_size == old_hard_mtu) {
		dev->rx_urb_size = dev->hard_mtu;
		if (dev->rx_urb_size > old_rx_urb_size)
			usbnet_unlink_rx_urbs(dev);
	}

398 399 400
	/* max qlen depend on hard_mtu and rx_urb_size */
	usbnet_update_max_qlen(dev);

L
Linus Torvalds 已提交
401 402
	return 0;
}
403
EXPORT_SYMBOL_GPL(usbnet_change_mtu);
L
Linus Torvalds 已提交
404

405 406 407 408 409 410 411 412 413 414
/* The caller must hold list->lock */
static void __usbnet_queue_skb(struct sk_buff_head *list,
			struct sk_buff *newsk, enum skb_state state)
{
	struct skb_data *entry = (struct skb_data *) newsk->cb;

	__skb_queue_tail(list, newsk);
	entry->state = state;
}

L
Linus Torvalds 已提交
415 416 417 418 419 420
/*-------------------------------------------------------------------------*/

/* some LK 2.4 HCDs oopsed if we freed or resubmitted urbs from
 * completion callbacks.  2.5 should have fixed those bugs...
 */

421 422
static enum skb_state defer_bh(struct usbnet *dev, struct sk_buff *skb,
		struct sk_buff_head *list, enum skb_state state)
L
Linus Torvalds 已提交
423 424
{
	unsigned long		flags;
425 426
	enum skb_state 		old_state;
	struct skb_data *entry = (struct skb_data *) skb->cb;
L
Linus Torvalds 已提交
427

D
David S. Miller 已提交
428
	spin_lock_irqsave(&list->lock, flags);
429 430
	old_state = entry->state;
	entry->state = state;
D
David S. Miller 已提交
431 432 433 434
	__skb_unlink(skb, list);
	spin_unlock(&list->lock);
	spin_lock(&dev->done.lock);
	__skb_queue_tail(&dev->done, skb);
L
Linus Torvalds 已提交
435
	if (dev->done.qlen == 1)
D
David S. Miller 已提交
436 437
		tasklet_schedule(&dev->bh);
	spin_unlock_irqrestore(&dev->done.lock, flags);
438
	return old_state;
L
Linus Torvalds 已提交
439 440 441 442 443 444 445
}

/* some work can't be done in tasklets, so we use keventd
 *
 * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,
 * but tasklet_schedule() doesn't.  hope the failure is rare.
 */
446
void usbnet_defer_kevent (struct usbnet *dev, int work)
L
Linus Torvalds 已提交
447 448
{
	set_bit (work, &dev->flags);
449 450 451 452
	if (!schedule_work (&dev->kevent)) {
		if (net_ratelimit())
			netdev_err(dev->net, "kevent %d may have been dropped\n", work);
	} else {
453
		netdev_dbg(dev->net, "kevent %d scheduled\n", work);
454
	}
L
Linus Torvalds 已提交
455
}
456
EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
L
Linus Torvalds 已提交
457 458 459

/*-------------------------------------------------------------------------*/

460
static void rx_complete (struct urb *urb);
L
Linus Torvalds 已提交
461

462
static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
L
Linus Torvalds 已提交
463 464 465 466 467
{
	struct sk_buff		*skb;
	struct skb_data		*entry;
	int			retval = 0;
	unsigned long		lockflags;
468
	size_t			size = dev->rx_urb_size;
L
Linus Torvalds 已提交
469

470 471 472 473 474 475
	/* prevent rx skb allocation when error ratio is high */
	if (test_bit(EVENT_RX_KILL, &dev->flags)) {
		usb_free_urb(urb);
		return -ENOLINK;
	}

476 477
	skb = __netdev_alloc_skb_ip_align(dev->net, size, flags);
	if (!skb) {
478
		netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
479
		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
L
Linus Torvalds 已提交
480
		usb_free_urb (urb);
481
		return -ENOMEM;
L
Linus Torvalds 已提交
482 483 484 485 486 487 488 489 490 491 492 493
	}

	entry = (struct skb_data *) skb->cb;
	entry->urb = urb;
	entry->dev = dev;
	entry->length = 0;

	usb_fill_bulk_urb (urb, dev->udev, dev->in,
		skb->data, size, rx_complete, skb);

	spin_lock_irqsave (&dev->rxq.lock, lockflags);

494 495
	if (netif_running (dev->net) &&
	    netif_device_present (dev->net) &&
496 497
	    !test_bit (EVENT_RX_HALT, &dev->flags) &&
	    !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {
D
David Brownell 已提交
498
		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {
L
Linus Torvalds 已提交
499
		case -EPIPE:
500
			usbnet_defer_kevent (dev, EVENT_RX_HALT);
L
Linus Torvalds 已提交
501 502
			break;
		case -ENOMEM:
503
			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
L
Linus Torvalds 已提交
504 505
			break;
		case -ENODEV:
506
			netif_dbg(dev, ifdown, dev->net, "device gone\n");
L
Linus Torvalds 已提交
507 508
			netif_device_detach (dev->net);
			break;
509 510 511
		case -EHOSTUNREACH:
			retval = -ENOLINK;
			break;
L
Linus Torvalds 已提交
512
		default:
513 514
			netif_dbg(dev, rx_err, dev->net,
				  "rx submit, %d\n", retval);
L
Linus Torvalds 已提交
515 516 517
			tasklet_schedule (&dev->bh);
			break;
		case 0:
518
			__usbnet_queue_skb(&dev->rxq, skb, rx_start);
L
Linus Torvalds 已提交
519 520
		}
	} else {
521
		netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
L
Linus Torvalds 已提交
522 523 524 525 526 527 528
		retval = -ENOLINK;
	}
	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
	if (retval) {
		dev_kfree_skb_any (skb);
		usb_free_urb (urb);
	}
529
	return retval;
L
Linus Torvalds 已提交
530 531 532 533 534 535 536
}


/*-------------------------------------------------------------------------*/

static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
{
537
	if (dev->driver_info->rx_fixup &&
538 539 540 541 542 543
	    !dev->driver_info->rx_fixup (dev, skb)) {
		/* With RX_ASSEMBLE, rx_fixup() must update counters */
		if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE))
			dev->net->stats.rx_errors++;
		goto done;
	}
L
Linus Torvalds 已提交
544 545
	// else network stack removes extra byte if we forced a short packet

546 547 548 549 550 551 552 553 554 555
	/* all data was already cloned from skb inside the driver */
	if (dev->driver_info->flags & FLAG_MULTI_PACKET)
		goto done;

	if (skb->len < ETH_HLEN) {
		dev->net->stats.rx_errors++;
		dev->net->stats.rx_length_errors++;
		netif_dbg(dev, rx_err, dev->net, "rx length %d\n", skb->len);
	} else {
		usbnet_skb_return(dev, skb);
556
		return;
L
Linus Torvalds 已提交
557
	}
558

559
done:
560
	skb_queue_tail(&dev->done, skb);
L
Linus Torvalds 已提交
561 562 563 564
}

/*-------------------------------------------------------------------------*/

565
static void rx_complete (struct urb *urb)
L
Linus Torvalds 已提交
566 567 568 569 570
{
	struct sk_buff		*skb = (struct sk_buff *) urb->context;
	struct skb_data		*entry = (struct skb_data *) skb->cb;
	struct usbnet		*dev = entry->dev;
	int			urb_status = urb->status;
571
	enum skb_state		state;
L
Linus Torvalds 已提交
572 573

	skb_put (skb, urb->actual_length);
574
	state = rx_done;
L
Linus Torvalds 已提交
575 576 577
	entry->urb = NULL;

	switch (urb_status) {
D
David Brownell 已提交
578 579
	/* success */
	case 0:
L
Linus Torvalds 已提交
580 581
		break;

D
David Brownell 已提交
582 583
	/* stalls need manual reset. this is rare ... except that
	 * when going through USB 2.0 TTs, unplug appears this way.
584
	 * we avoid the highspeed version of the ETIMEDOUT/EILSEQ
D
David Brownell 已提交
585 586 587
	 * storm, recovering as needed.
	 */
	case -EPIPE:
H
Herbert Xu 已提交
588
		dev->net->stats.rx_errors++;
589
		usbnet_defer_kevent (dev, EVENT_RX_HALT);
L
Linus Torvalds 已提交
590 591
		// FALLTHROUGH

D
David Brownell 已提交
592 593 594
	/* software-driven interface shutdown */
	case -ECONNRESET:		/* async unlink */
	case -ESHUTDOWN:		/* hardware gone */
595 596
		netif_dbg(dev, ifdown, dev->net,
			  "rx shutdown, code %d\n", urb_status);
L
Linus Torvalds 已提交
597 598
		goto block;

599
	/* we get controller i/o faults during hub_wq disconnect() delays.
D
David Brownell 已提交
600
	 * throttle down resubmits, to avoid log floods; just temporarily,
601
	 * so we still recover when the fault isn't a hub_wq delay.
D
David Brownell 已提交
602 603 604 605
	 */
	case -EPROTO:
	case -ETIME:
	case -EILSEQ:
H
Herbert Xu 已提交
606
		dev->net->stats.rx_errors++;
L
Linus Torvalds 已提交
607 608
		if (!timer_pending (&dev->delay)) {
			mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
609 610
			netif_dbg(dev, link, dev->net,
				  "rx throttle %d\n", urb_status);
L
Linus Torvalds 已提交
611 612
		}
block:
613
		state = rx_cleanup;
L
Linus Torvalds 已提交
614 615 616 617
		entry->urb = urb;
		urb = NULL;
		break;

D
David Brownell 已提交
618 619
	/* data overrun ... flush fifo? */
	case -EOVERFLOW:
H
Herbert Xu 已提交
620
		dev->net->stats.rx_over_errors++;
L
Linus Torvalds 已提交
621
		// FALLTHROUGH
622

D
David Brownell 已提交
623
	default:
624
		state = rx_cleanup;
H
Herbert Xu 已提交
625
		dev->net->stats.rx_errors++;
626
		netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
L
Linus Torvalds 已提交
627 628 629
		break;
	}

630 631 632 633 634 635 636 637 638 639 640
	/* stop rx if packet error rate is high */
	if (++dev->pkt_cnt > 30) {
		dev->pkt_cnt = 0;
		dev->pkt_err = 0;
	} else {
		if (state == rx_cleanup)
			dev->pkt_err++;
		if (dev->pkt_err > 20)
			set_bit(EVENT_RX_KILL, &dev->flags);
	}

641
	state = defer_bh(dev, skb, &dev->rxq, state);
L
Linus Torvalds 已提交
642 643

	if (urb) {
644
		if (netif_running (dev->net) &&
645 646
		    !test_bit (EVENT_RX_HALT, &dev->flags) &&
		    state != unlink_start) {
L
Linus Torvalds 已提交
647
			rx_submit (dev, urb, GFP_ATOMIC);
648
			usb_mark_last_busy(dev->udev);
L
Linus Torvalds 已提交
649 650 651 652
			return;
		}
		usb_free_urb (urb);
	}
653
	netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
L
Linus Torvalds 已提交
654 655
}

J
Jussi Kivilinna 已提交
656 657 658 659 660
/*-------------------------------------------------------------------------*/
void usbnet_pause_rx(struct usbnet *dev)
{
	set_bit(EVENT_RX_PAUSED, &dev->flags);

661
	netif_dbg(dev, rx_status, dev->net, "paused rx queue enabled\n");
J
Jussi Kivilinna 已提交
662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
}
EXPORT_SYMBOL_GPL(usbnet_pause_rx);

void usbnet_resume_rx(struct usbnet *dev)
{
	struct sk_buff *skb;
	int num = 0;

	clear_bit(EVENT_RX_PAUSED, &dev->flags);

	while ((skb = skb_dequeue(&dev->rxq_pause)) != NULL) {
		usbnet_skb_return(dev, skb);
		num++;
	}

	tasklet_schedule(&dev->bh);

679 680
	netif_dbg(dev, rx_status, dev->net,
		  "paused rx queue disabled, %d skbs requeued\n", num);
J
Jussi Kivilinna 已提交
681 682 683 684 685 686 687 688 689
}
EXPORT_SYMBOL_GPL(usbnet_resume_rx);

void usbnet_purge_paused_rxq(struct usbnet *dev)
{
	skb_queue_purge(&dev->rxq_pause);
}
EXPORT_SYMBOL_GPL(usbnet_purge_paused_rxq);

L
Linus Torvalds 已提交
690 691 692 693 694 695 696
/*-------------------------------------------------------------------------*/

// unlink pending rx/tx; completion handlers do all other cleanup

static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q)
{
	unsigned long		flags;
697
	struct sk_buff		*skb;
L
Linus Torvalds 已提交
698 699 700
	int			count = 0;

	spin_lock_irqsave (&q->lock, flags);
701
	while (!skb_queue_empty(q)) {
L
Linus Torvalds 已提交
702 703 704 705
		struct skb_data		*entry;
		struct urb		*urb;
		int			retval;

706 707 708 709 710 711 712 713
		skb_queue_walk(q, skb) {
			entry = (struct skb_data *) skb->cb;
			if (entry->state != unlink_start)
				goto found;
		}
		break;
found:
		entry->state = unlink_start;
L
Linus Torvalds 已提交
714 715
		urb = entry->urb;

716 717 718 719 720 721 722 723
		/*
		 * Get reference count of the URB to avoid it to be
		 * freed during usb_unlink_urb, which may trigger
		 * use-after-free problem inside usb_unlink_urb since
		 * usb_unlink_urb is always racing with .complete
		 * handler(include defer_bh).
		 */
		usb_get_urb(urb);
724
		spin_unlock_irqrestore(&q->lock, flags);
L
Linus Torvalds 已提交
725 726 727 728
		// during some PM-driven resume scenarios,
		// these (async) unlinks complete immediately
		retval = usb_unlink_urb (urb);
		if (retval != -EINPROGRESS && retval != 0)
729
			netdev_dbg(dev->net, "unlink urb err, %d\n", retval);
L
Linus Torvalds 已提交
730 731
		else
			count++;
732
		usb_put_urb(urb);
733
		spin_lock_irqsave(&q->lock, flags);
L
Linus Torvalds 已提交
734 735 736 737 738
	}
	spin_unlock_irqrestore (&q->lock, flags);
	return count;
}

739 740 741 742 743 744 745 746 747 748 749
// Flush all pending rx urbs
// minidrivers may need to do this when the MTU changes

void usbnet_unlink_rx_urbs(struct usbnet *dev)
{
	if (netif_running(dev->net)) {
		(void) unlink_urbs (dev, &dev->rxq);
		tasklet_schedule(&dev->bh);
	}
}
EXPORT_SYMBOL_GPL(usbnet_unlink_rx_urbs);
L
Linus Torvalds 已提交
750 751 752 753

/*-------------------------------------------------------------------------*/

// precondition: never called in_interrupt
754 755 756 757 758 759
static void usbnet_terminate_urbs(struct usbnet *dev)
{
	DECLARE_WAITQUEUE(wait, current);
	int temp;

	/* ensure there are no more active urbs */
760
	add_wait_queue(&dev->wait, &wait);
761 762 763 764 765 766 767 768
	set_current_state(TASK_UNINTERRUPTIBLE);
	temp = unlink_urbs(dev, &dev->txq) +
		unlink_urbs(dev, &dev->rxq);

	/* maybe wait for deletions to finish. */
	while (!skb_queue_empty(&dev->rxq)
		&& !skb_queue_empty(&dev->txq)
		&& !skb_queue_empty(&dev->done)) {
769
			schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
770
			set_current_state(TASK_UNINTERRUPTIBLE);
771 772
			netif_dbg(dev, ifdown, dev->net,
				  "waited for %d urb completions\n", temp);
773 774
	}
	set_current_state(TASK_RUNNING);
775
	remove_wait_queue(&dev->wait, &wait);
776
}
L
Linus Torvalds 已提交
777

778
int usbnet_stop (struct net_device *net)
L
Linus Torvalds 已提交
779 780
{
	struct usbnet		*dev = netdev_priv(net);
781
	struct driver_info	*info = dev->driver_info;
782
	int			retval, pm;
L
Linus Torvalds 已提交
783

M
Ming Lei 已提交
784
	clear_bit(EVENT_DEV_OPEN, &dev->flags);
L
Linus Torvalds 已提交
785 786
	netif_stop_queue (net);

787
	netif_info(dev, ifdown, dev->net,
788
		   "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
789 790
		   net->stats.rx_packets, net->stats.tx_packets,
		   net->stats.rx_errors, net->stats.tx_errors);
L
Linus Torvalds 已提交
791

792 793
	/* to not race resume */
	pm = usb_autopm_get_interface(dev->intf);
794 795 796 797
	/* allow minidriver to stop correctly (wireless devices to turn off
	 * radio etc) */
	if (info->stop) {
		retval = info->stop(dev);
798 799 800 801 802 803
		if (retval < 0)
			netif_info(dev, ifdown, dev->net,
				   "stop fail (%d) usbnet usb-%s-%s, %s\n",
				   retval,
				   dev->udev->bus->bus_name, dev->udev->devpath,
				   info->description);
804 805
	}

806 807
	if (!(info->flags & FLAG_AVOID_UNLINK_URBS))
		usbnet_terminate_urbs(dev);
L
Linus Torvalds 已提交
808

809
	usbnet_status_stop(dev);
L
Linus Torvalds 已提交
810

J
Jussi Kivilinna 已提交
811 812
	usbnet_purge_paused_rxq(dev);

L
Linus Torvalds 已提交
813 814 815 816 817 818 819
	/* deferred work (task, timer, softirq) must also stop.
	 * can't flush_scheduled_work() until we drop rtnl (later),
	 * else workers could deadlock; so make workers a NOP.
	 */
	dev->flags = 0;
	del_timer_sync (&dev->delay);
	tasklet_kill (&dev->bh);
820 821 822
	if (!pm)
		usb_autopm_put_interface(dev->intf);

823 824
	if (info->manage_power &&
	    !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags))
825 826 827
		info->manage_power(dev, 0);
	else
		usb_autopm_put_interface(dev->intf);
L
Linus Torvalds 已提交
828 829 830

	return 0;
}
831
EXPORT_SYMBOL_GPL(usbnet_stop);
L
Linus Torvalds 已提交
832 833 834 835 836 837 838

/*-------------------------------------------------------------------------*/

// posts reads, and enables write queuing

// precondition: never called in_interrupt

839
int usbnet_open (struct net_device *net)
L
Linus Torvalds 已提交
840 841
{
	struct usbnet		*dev = netdev_priv(net);
842
	int			retval;
L
Linus Torvalds 已提交
843 844
	struct driver_info	*info = dev->driver_info;

845
	if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
846 847 848 849 850 851
		netif_info(dev, ifup, dev->net,
			   "resumption fail (%d) usbnet usb-%s-%s, %s\n",
			   retval,
			   dev->udev->bus->bus_name,
			   dev->udev->devpath,
			   info->description);
852 853 854
		goto done_nopm;
	}

L
Linus Torvalds 已提交
855 856
	// put into "known safe" state
	if (info->reset && (retval = info->reset (dev)) < 0) {
857 858 859 860 861 862
		netif_info(dev, ifup, dev->net,
			   "open reset fail (%d) usbnet usb-%s-%s, %s\n",
			   retval,
			   dev->udev->bus->bus_name,
			   dev->udev->devpath,
			   info->description);
L
Linus Torvalds 已提交
863 864 865
		goto done;
	}

866 867 868
	/* hard_mtu or rx_urb_size may change in reset() */
	usbnet_update_max_qlen(dev);

L
Linus Torvalds 已提交
869 870
	// insist peer be connected
	if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
871
		netif_dbg(dev, ifup, dev->net, "can't open; %d\n", retval);
L
Linus Torvalds 已提交
872 873 874 875 876
		goto done;
	}

	/* start any status interrupt transfer */
	if (dev->interrupt) {
877
		retval = usbnet_status_start(dev, GFP_KERNEL);
L
Linus Torvalds 已提交
878
		if (retval < 0) {
879 880
			netif_err(dev, ifup, dev->net,
				  "intr submit %d\n", retval);
L
Linus Torvalds 已提交
881 882 883 884
			goto done;
		}
	}

885
	set_bit(EVENT_DEV_OPEN, &dev->flags);
L
Linus Torvalds 已提交
886
	netif_start_queue (net);
887 888 889 890 891 892 893 894 895 896
	netif_info(dev, ifup, dev->net,
		   "open: enable queueing (rx %d, tx %d) mtu %d %s framing\n",
		   (int)RX_QLEN(dev), (int)TX_QLEN(dev),
		   dev->net->mtu,
		   (dev->driver_info->flags & FLAG_FRAMING_NC) ? "NetChip" :
		   (dev->driver_info->flags & FLAG_FRAMING_GL) ? "GeneSys" :
		   (dev->driver_info->flags & FLAG_FRAMING_Z) ? "Zaurus" :
		   (dev->driver_info->flags & FLAG_FRAMING_RN) ? "RNDIS" :
		   (dev->driver_info->flags & FLAG_FRAMING_AX) ? "ASIX" :
		   "simple");
L
Linus Torvalds 已提交
897

898 899 900 901 902
	/* reset rx error state */
	dev->pkt_cnt = 0;
	dev->pkt_err = 0;
	clear_bit(EVENT_RX_KILL, &dev->flags);

L
Linus Torvalds 已提交
903 904
	// delay posting reads until we're fully open
	tasklet_schedule (&dev->bh);
905 906
	if (info->manage_power) {
		retval = info->manage_power(dev, 1);
907 908 909 910 911 912
		if (retval < 0) {
			retval = 0;
			set_bit(EVENT_NO_RUNTIME_PM, &dev->flags);
		} else {
			usb_autopm_put_interface(dev->intf);
		}
913
	}
914
	return retval;
L
Linus Torvalds 已提交
915
done:
916 917
	usb_autopm_put_interface(dev->intf);
done_nopm:
L
Linus Torvalds 已提交
918 919
	return retval;
}
920
EXPORT_SYMBOL_GPL(usbnet_open);
L
Linus Torvalds 已提交
921 922 923

/*-------------------------------------------------------------------------*/

924 925 926 927
/* ethtool methods; minidrivers may need to add some more, but
 * they'll probably want to use this base set.
 */

928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952
int usbnet_get_settings (struct net_device *net, struct ethtool_cmd *cmd)
{
	struct usbnet *dev = netdev_priv(net);

	if (!dev->mii.mdio_read)
		return -EOPNOTSUPP;

	return mii_ethtool_gset(&dev->mii, cmd);
}
EXPORT_SYMBOL_GPL(usbnet_get_settings);

int usbnet_set_settings (struct net_device *net, struct ethtool_cmd *cmd)
{
	struct usbnet *dev = netdev_priv(net);
	int retval;

	if (!dev->mii.mdio_write)
		return -EOPNOTSUPP;

	retval = mii_ethtool_sset(&dev->mii, cmd);

	/* link speed/duplex might have changed */
	if (dev->driver_info->link_reset)
		dev->driver_info->link_reset(dev);

953 954 955
	/* hard_mtu or rx_urb_size may change in link_reset() */
	usbnet_update_max_qlen(dev);

956 957 958 959 960 961
	return retval;

}
EXPORT_SYMBOL_GPL(usbnet_set_settings);

u32 usbnet_get_link (struct net_device *net)
L
Linus Torvalds 已提交
962 963 964
{
	struct usbnet *dev = netdev_priv(net);

965
	/* If a check_connect is defined, return its result */
L
Linus Torvalds 已提交
966 967 968
	if (dev->driver_info->check_connect)
		return dev->driver_info->check_connect (dev) == 0;

969 970 971 972
	/* if the device has mii operations, use those */
	if (dev->mii.mdio_read)
		return mii_link_ok(&dev->mii);

973 974
	/* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */
	return ethtool_op_get_link(net);
L
Linus Torvalds 已提交
975
}
976
EXPORT_SYMBOL_GPL(usbnet_get_link);
L
Linus Torvalds 已提交
977

978
int usbnet_nway_reset(struct net_device *net)
L
Linus Torvalds 已提交
979 980 981
{
	struct usbnet *dev = netdev_priv(net);

982 983 984 985
	if (!dev->mii.mdio_write)
		return -EOPNOTSUPP;

	return mii_nway_restart(&dev->mii);
L
Linus Torvalds 已提交
986
}
987
EXPORT_SYMBOL_GPL(usbnet_nway_reset);
L
Linus Torvalds 已提交
988

989
void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
L
Linus Torvalds 已提交
990 991 992
{
	struct usbnet *dev = netdev_priv(net);

993 994 995
	strlcpy (info->driver, dev->driver_name, sizeof info->driver);
	strlcpy (info->version, DRIVER_VERSION, sizeof info->version);
	strlcpy (info->fw_version, dev->driver_info->description,
996 997
		sizeof info->fw_version);
	usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
L
Linus Torvalds 已提交
998
}
999
EXPORT_SYMBOL_GPL(usbnet_get_drvinfo);
L
Linus Torvalds 已提交
1000

1001
u32 usbnet_get_msglevel (struct net_device *net)
1002 1003 1004
{
	struct usbnet *dev = netdev_priv(net);

1005 1006 1007
	return dev->msg_enable;
}
EXPORT_SYMBOL_GPL(usbnet_get_msglevel);
1008

1009 1010 1011 1012 1013
void usbnet_set_msglevel (struct net_device *net, u32 level)
{
	struct usbnet *dev = netdev_priv(net);

	dev->msg_enable = level;
1014
}
1015
EXPORT_SYMBOL_GPL(usbnet_set_msglevel);
1016

1017
/* drivers may override default ethtool_ops in their bind() routine */
1018
static const struct ethtool_ops usbnet_ethtool_ops = {
1019 1020
	.get_settings		= usbnet_get_settings,
	.set_settings		= usbnet_set_settings,
1021
	.get_link		= usbnet_get_link,
1022
	.nway_reset		= usbnet_nway_reset,
1023
	.get_drvinfo		= usbnet_get_drvinfo,
1024 1025
	.get_msglevel		= usbnet_get_msglevel,
	.set_msglevel		= usbnet_set_msglevel,
1026
	.get_ts_info		= ethtool_op_get_ts_info,
1027
};
L
Linus Torvalds 已提交
1028 1029 1030

/*-------------------------------------------------------------------------*/

M
Ming Lei 已提交
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
static void __handle_link_change(struct usbnet *dev)
{
	if (!test_bit(EVENT_DEV_OPEN, &dev->flags))
		return;

	if (!netif_carrier_ok(dev->net)) {
		/* kill URBs for reading packets to save bus bandwidth */
		unlink_urbs(dev, &dev->rxq);

		/*
		 * tx_timeout will unlink URBs for sending packets and
		 * tx queue is stopped by netcore after link becomes off
		 */
	} else {
		/* submitting URBs for reading packets */
		tasklet_schedule(&dev->bh);
	}

1049 1050 1051
	/* hard_mtu or rx_urb_size may change during link change */
	usbnet_update_max_qlen(dev);

M
Ming Lei 已提交
1052 1053 1054
	clear_bit(EVENT_LINK_CHANGE, &dev->flags);
}

L
Linus Torvalds 已提交
1055 1056 1057 1058 1059 1060
/* work that cannot be done in interrupt context uses keventd.
 *
 * NOTE:  with 2.5 we could do more of this using completion callbacks,
 * especially now that control transfers can be queued.
 */
static void
D
David Howells 已提交
1061
kevent (struct work_struct *work)
L
Linus Torvalds 已提交
1062
{
D
David Howells 已提交
1063 1064
	struct usbnet		*dev =
		container_of(work, struct usbnet, kevent);
L
Linus Torvalds 已提交
1065 1066 1067 1068 1069
	int			status;

	/* usb_clear_halt() needs a thread context */
	if (test_bit (EVENT_TX_HALT, &dev->flags)) {
		unlink_urbs (dev, &dev->txq);
1070 1071 1072
		status = usb_autopm_get_interface(dev->intf);
		if (status < 0)
			goto fail_pipe;
L
Linus Torvalds 已提交
1073
		status = usb_clear_halt (dev->udev, dev->out);
1074
		usb_autopm_put_interface(dev->intf);
1075 1076 1077
		if (status < 0 &&
		    status != -EPIPE &&
		    status != -ESHUTDOWN) {
L
Linus Torvalds 已提交
1078
			if (netif_msg_tx_err (dev))
1079
fail_pipe:
1080 1081
				netdev_err(dev->net, "can't clear tx halt, status %d\n",
					   status);
L
Linus Torvalds 已提交
1082 1083
		} else {
			clear_bit (EVENT_TX_HALT, &dev->flags);
1084 1085
			if (status != -ESHUTDOWN)
				netif_wake_queue (dev->net);
L
Linus Torvalds 已提交
1086 1087 1088 1089
		}
	}
	if (test_bit (EVENT_RX_HALT, &dev->flags)) {
		unlink_urbs (dev, &dev->rxq);
1090 1091 1092
		status = usb_autopm_get_interface(dev->intf);
		if (status < 0)
			goto fail_halt;
L
Linus Torvalds 已提交
1093
		status = usb_clear_halt (dev->udev, dev->in);
1094
		usb_autopm_put_interface(dev->intf);
1095 1096 1097
		if (status < 0 &&
		    status != -EPIPE &&
		    status != -ESHUTDOWN) {
L
Linus Torvalds 已提交
1098
			if (netif_msg_rx_err (dev))
1099
fail_halt:
1100 1101
				netdev_err(dev->net, "can't clear rx halt, status %d\n",
					   status);
L
Linus Torvalds 已提交
1102 1103 1104 1105 1106 1107 1108 1109 1110
		} else {
			clear_bit (EVENT_RX_HALT, &dev->flags);
			tasklet_schedule (&dev->bh);
		}
	}

	/* tasklet could resubmit itself forever if memory is tight */
	if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
		struct urb	*urb = NULL;
1111
		int resched = 1;
L
Linus Torvalds 已提交
1112 1113 1114 1115 1116 1117 1118

		if (netif_running (dev->net))
			urb = usb_alloc_urb (0, GFP_KERNEL);
		else
			clear_bit (EVENT_RX_MEMORY, &dev->flags);
		if (urb != NULL) {
			clear_bit (EVENT_RX_MEMORY, &dev->flags);
1119
			status = usb_autopm_get_interface(dev->intf);
1120 1121
			if (status < 0) {
				usb_free_urb(urb);
1122
				goto fail_lowmem;
1123
			}
1124 1125
			if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
				resched = 0;
1126 1127
			usb_autopm_put_interface(dev->intf);
fail_lowmem:
1128 1129
			if (resched)
				tasklet_schedule (&dev->bh);
L
Linus Torvalds 已提交
1130 1131 1132
		}
	}

1133
	if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
1134
		struct driver_info	*info = dev->driver_info;
1135 1136 1137
		int			retval = 0;

		clear_bit (EVENT_LINK_RESET, &dev->flags);
1138 1139 1140
		status = usb_autopm_get_interface(dev->intf);
		if (status < 0)
			goto skip_reset;
1141
		if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
1142 1143
			usb_autopm_put_interface(dev->intf);
skip_reset:
1144 1145 1146 1147 1148
			netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s\n",
				    retval,
				    dev->udev->bus->bus_name,
				    dev->udev->devpath,
				    info->description);
1149 1150
		} else {
			usb_autopm_put_interface(dev->intf);
1151
		}
M
Ming Lei 已提交
1152 1153 1154

		/* handle link change from link resetting */
		__handle_link_change(dev);
1155 1156
	}

M
Ming Lei 已提交
1157 1158 1159
	if (test_bit (EVENT_LINK_CHANGE, &dev->flags))
		__handle_link_change(dev);

L
Linus Torvalds 已提交
1160
	if (dev->flags)
1161
		netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags);
L
Linus Torvalds 已提交
1162 1163 1164 1165
}

/*-------------------------------------------------------------------------*/

1166
static void tx_complete (struct urb *urb)
L
Linus Torvalds 已提交
1167 1168 1169 1170 1171 1172
{
	struct sk_buff		*skb = (struct sk_buff *) urb->context;
	struct skb_data		*entry = (struct skb_data *) skb->cb;
	struct usbnet		*dev = entry->dev;

	if (urb->status == 0) {
1173 1174
		if (!(dev->driver_info->flags & FLAG_MULTI_PACKET))
			dev->net->stats.tx_packets++;
H
Herbert Xu 已提交
1175
		dev->net->stats.tx_bytes += entry->length;
L
Linus Torvalds 已提交
1176
	} else {
H
Herbert Xu 已提交
1177
		dev->net->stats.tx_errors++;
L
Linus Torvalds 已提交
1178 1179 1180

		switch (urb->status) {
		case -EPIPE:
1181
			usbnet_defer_kevent (dev, EVENT_TX_HALT);
L
Linus Torvalds 已提交
1182 1183 1184 1185 1186 1187 1188
			break;

		/* software-driven interface shutdown */
		case -ECONNRESET:		// async unlink
		case -ESHUTDOWN:		// hardware gone
			break;

1189 1190 1191
		/* like rx, tx gets controller i/o faults during hub_wq
		 * delays and so it uses the same throttling mechanism.
		 */
1192 1193 1194
		case -EPROTO:
		case -ETIME:
		case -EILSEQ:
1195
			usb_mark_last_busy(dev->udev);
L
Linus Torvalds 已提交
1196 1197 1198
			if (!timer_pending (&dev->delay)) {
				mod_timer (&dev->delay,
					jiffies + THROTTLE_JIFFIES);
1199 1200
				netif_dbg(dev, link, dev->net,
					  "tx throttle %d\n", urb->status);
L
Linus Torvalds 已提交
1201 1202 1203 1204
			}
			netif_stop_queue (dev->net);
			break;
		default:
1205 1206
			netif_dbg(dev, tx_err, dev->net,
				  "tx err %d\n", entry->urb->status);
L
Linus Torvalds 已提交
1207 1208 1209 1210
			break;
		}
	}

1211
	usb_autopm_put_interface_async(dev->intf);
1212
	(void) defer_bh(dev, skb, &dev->txq, tx_done);
L
Linus Torvalds 已提交
1213 1214 1215 1216
}

/*-------------------------------------------------------------------------*/

1217
void usbnet_tx_timeout (struct net_device *net)
L
Linus Torvalds 已提交
1218 1219 1220 1221 1222
{
	struct usbnet		*dev = netdev_priv(net);

	unlink_urbs (dev, &dev->txq);
	tasklet_schedule (&dev->bh);
1223 1224 1225 1226 1227 1228
	/* this needs to be handled individually because the generic layer
	 * doesn't know what is sufficient and could not restore private
	 * information if a remedy of an unconditional reset were used.
	 */
	if (dev->driver_info->recover)
		(dev->driver_info->recover)(dev);
L
Linus Torvalds 已提交
1229
}
1230
EXPORT_SYMBOL_GPL(usbnet_tx_timeout);
L
Linus Torvalds 已提交
1231 1232 1233

/*-------------------------------------------------------------------------*/

M
Ming Lei 已提交
1234 1235 1236 1237 1238 1239 1240 1241 1242
static int build_dma_sg(const struct sk_buff *skb, struct urb *urb)
{
	unsigned num_sgs, total_len = 0;
	int i, s = 0;

	num_sgs = skb_shinfo(skb)->nr_frags + 1;
	if (num_sgs == 1)
		return 0;

M
Ming Lei 已提交
1243 1244 1245
	/* reserve one for zero packet */
	urb->sg = kmalloc((num_sgs + 1) * sizeof(struct scatterlist),
			  GFP_ATOMIC);
M
Ming Lei 已提交
1246 1247 1248 1249
	if (!urb->sg)
		return -ENOMEM;

	urb->num_sgs = num_sgs;
B
Bjørn Mork 已提交
1250
	sg_init_table(urb->sg, urb->num_sgs + 1);
M
Ming Lei 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266

	sg_set_buf(&urb->sg[s++], skb->data, skb_headlen(skb));
	total_len += skb_headlen(skb);

	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
		struct skb_frag_struct *f = &skb_shinfo(skb)->frags[i];

		total_len += skb_frag_size(f);
		sg_set_page(&urb->sg[i + s], f->page.p, f->size,
				f->page_offset);
	}
	urb->transfer_buffer_length = total_len;

	return 1;
}

1267 1268
netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
				     struct net_device *net)
L
Linus Torvalds 已提交
1269 1270 1271 1272 1273 1274 1275
{
	struct usbnet		*dev = netdev_priv(net);
	int			length;
	struct urb		*urb = NULL;
	struct skb_data		*entry;
	struct driver_info	*info = dev->driver_info;
	unsigned long		flags;
1276
	int retval;
L
Linus Torvalds 已提交
1277

1278 1279
	if (skb)
		skb_tx_timestamp(skb);
1280

L
Linus Torvalds 已提交
1281 1282 1283 1284 1285
	// some devices want funky USB-level framing, for
	// win32 driver (usually) and/or hardware quirks
	if (info->tx_fixup) {
		skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
		if (!skb) {
1286 1287
			/* packet collected; minidriver waiting for more */
			if (info->flags & FLAG_MULTI_PACKET)
1288
				goto not_drop;
1289 1290
			netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb\n");
			goto drop;
L
Linus Torvalds 已提交
1291 1292 1293 1294
		}
	}

	if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {
1295
		netif_dbg(dev, tx_err, dev->net, "no urb\n");
L
Linus Torvalds 已提交
1296 1297 1298 1299 1300 1301 1302 1303 1304
		goto drop;
	}

	entry = (struct skb_data *) skb->cb;
	entry->urb = urb;
	entry->dev = dev;

	usb_fill_bulk_urb (urb, dev->udev, dev->out,
			skb->data, skb->len, tx_complete, skb);
M
Ming Lei 已提交
1305 1306 1307 1308
	if (dev->can_dma_sg) {
		if (build_dma_sg(skb, urb) < 0)
			goto drop;
	}
M
Ming Lei 已提交
1309
	length = urb->transfer_buffer_length;
L
Linus Torvalds 已提交
1310 1311 1312 1313

	/* don't assume the hardware handles USB_ZERO_PACKET
	 * NOTE:  strictly conforming cdc-ether devices should expect
	 * the ZLP here, but ignore the one-byte packet.
1314 1315 1316
	 * NOTE2: CDC NCM specification is different from CDC ECM when
	 * handling ZLP/short packets, so cdc_ncm driver will make short
	 * packet itself if needed.
L
Linus Torvalds 已提交
1317
	 */
1318 1319
	if (length % dev->maxpacket == 0) {
		if (!(info->flags & FLAG_SEND_ZLP)) {
1320
			if (!(info->flags & FLAG_MULTI_PACKET)) {
M
Ming Lei 已提交
1321 1322
				length++;
				if (skb_tailroom(skb) && !urb->num_sgs) {
1323 1324
					skb->data[skb->len] = 0;
					__skb_put(skb, 1);
M
Ming Lei 已提交
1325 1326 1327
				} else if (urb->num_sgs)
					sg_set_buf(&urb->sg[urb->num_sgs++],
							dev->padding_pkt, 1);
1328 1329 1330
			}
		} else
			urb->transfer_flags |= URB_ZERO_PACKET;
1331
	}
M
Ming Lei 已提交
1332
	entry->length = urb->transfer_buffer_length = length;
L
Linus Torvalds 已提交
1333

1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
	spin_lock_irqsave(&dev->txq.lock, flags);
	retval = usb_autopm_get_interface_async(dev->intf);
	if (retval < 0) {
		spin_unlock_irqrestore(&dev->txq.lock, flags);
		goto drop;
	}

#ifdef CONFIG_PM
	/* if this triggers the device is still a sleep */
	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
		/* transmission will be done in resume */
		usb_anchor_urb(urb, &dev->deferred);
		/* no use to process more packets */
		netif_stop_queue(net);
1348
		usb_put_urb(urb);
1349
		spin_unlock_irqrestore(&dev->txq.lock, flags);
1350
		netdev_dbg(dev->net, "Delaying transmission for resumption\n");
1351 1352 1353
		goto deferred;
	}
#endif
L
Linus Torvalds 已提交
1354 1355 1356 1357

	switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {
	case -EPIPE:
		netif_stop_queue (net);
1358
		usbnet_defer_kevent (dev, EVENT_TX_HALT);
1359
		usb_autopm_put_interface_async(dev->intf);
L
Linus Torvalds 已提交
1360 1361
		break;
	default:
1362
		usb_autopm_put_interface_async(dev->intf);
1363 1364
		netif_dbg(dev, tx_err, dev->net,
			  "tx: submit urb err %d\n", retval);
L
Linus Torvalds 已提交
1365 1366 1367
		break;
	case 0:
		net->trans_start = jiffies;
1368
		__usbnet_queue_skb(&dev->txq, skb, tx_start);
L
Linus Torvalds 已提交
1369 1370 1371 1372 1373 1374
		if (dev->txq.qlen >= TX_QLEN (dev))
			netif_stop_queue (net);
	}
	spin_unlock_irqrestore (&dev->txq.lock, flags);

	if (retval) {
1375
		netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval);
L
Linus Torvalds 已提交
1376
drop:
H
Herbert Xu 已提交
1377
		dev->net->stats.tx_dropped++;
1378
not_drop:
L
Linus Torvalds 已提交
1379 1380
		if (skb)
			dev_kfree_skb_any (skb);
M
Ming Lei 已提交
1381 1382 1383 1384
		if (urb) {
			kfree(urb->sg);
			usb_free_urb(urb);
		}
1385 1386 1387
	} else
		netif_dbg(dev, tx_queued, dev->net,
			  "> tx, len %d, type 0x%x\n", length, skb->protocol);
1388 1389 1390
#ifdef CONFIG_PM
deferred:
#endif
1391
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
1392
}
1393
EXPORT_SYMBOL_GPL(usbnet_start_xmit);
L
Linus Torvalds 已提交
1394

1395
static int rx_alloc_submit(struct usbnet *dev, gfp_t flags)
M
Ming Lei 已提交
1396 1397 1398
{
	struct urb	*urb;
	int		i;
1399
	int		ret = 0;
M
Ming Lei 已提交
1400 1401 1402 1403 1404

	/* don't refill the queue all at once */
	for (i = 0; i < 10 && dev->rxq.qlen < RX_QLEN(dev); i++) {
		urb = usb_alloc_urb(0, flags);
		if (urb != NULL) {
1405 1406 1407 1408 1409 1410
			ret = rx_submit(dev, urb, flags);
			if (ret)
				goto err;
		} else {
			ret = -ENOMEM;
			goto err;
M
Ming Lei 已提交
1411 1412
		}
	}
1413 1414
err:
	return ret;
M
Ming Lei 已提交
1415 1416
}

L
Linus Torvalds 已提交
1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
/*-------------------------------------------------------------------------*/

// tasklet (work deferred from completions, in_irq) or timer

static void usbnet_bh (unsigned long param)
{
	struct usbnet		*dev = (struct usbnet *) param;
	struct sk_buff		*skb;
	struct skb_data		*entry;

	while ((skb = skb_dequeue (&dev->done))) {
		entry = (struct skb_data *) skb->cb;
		switch (entry->state) {
D
David Brownell 已提交
1430
		case rx_done:
L
Linus Torvalds 已提交
1431 1432 1433
			entry->state = rx_cleanup;
			rx_process (dev, skb);
			continue;
D
David Brownell 已提交
1434
		case tx_done:
M
Ming Lei 已提交
1435
			kfree(entry->urb->sg);
D
David Brownell 已提交
1436
		case rx_cleanup:
L
Linus Torvalds 已提交
1437 1438 1439
			usb_free_urb (entry->urb);
			dev_kfree_skb (skb);
			continue;
D
David Brownell 已提交
1440
		default:
1441
			netdev_dbg(dev->net, "bogus skb state %d\n", entry->state);
L
Linus Torvalds 已提交
1442 1443 1444
		}
	}

1445 1446 1447
	/* restart RX again after disabling due to high error rate */
	clear_bit(EVENT_RX_KILL, &dev->flags);

1448 1449 1450 1451 1452 1453
	/* waiting for all pending urbs to complete?
	 * only then can we forgo submitting anew
	 */
	if (waitqueue_active(&dev->wait)) {
		if (dev->txq.qlen + dev->rxq.qlen + dev->done.qlen == 0)
			wake_up_all(&dev->wait);
L
Linus Torvalds 已提交
1454 1455

	// or are we maybe short a few urbs?
1456 1457
	} else if (netif_running (dev->net) &&
		   netif_device_present (dev->net) &&
M
Ming Lei 已提交
1458
		   netif_carrier_ok(dev->net) &&
1459 1460
		   !timer_pending (&dev->delay) &&
		   !test_bit (EVENT_RX_HALT, &dev->flags)) {
L
Linus Torvalds 已提交
1461
		int	temp = dev->rxq.qlen;
M
Ming Lei 已提交
1462 1463

		if (temp < RX_QLEN(dev)) {
1464 1465
			if (rx_alloc_submit(dev, GFP_ATOMIC) == -ENOLINK)
				return;
1466 1467 1468 1469
			if (temp != dev->rxq.qlen)
				netif_dbg(dev, link, dev->net,
					  "rxqlen %d --> %d\n",
					  temp, dev->rxq.qlen);
M
Ming Lei 已提交
1470
			if (dev->rxq.qlen < RX_QLEN(dev))
L
Linus Torvalds 已提交
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
				tasklet_schedule (&dev->bh);
		}
		if (dev->txq.qlen < TX_QLEN (dev))
			netif_wake_queue (dev->net);
	}
}


/*-------------------------------------------------------------------------
 *
 * USB Device Driver support
 *
 *-------------------------------------------------------------------------*/
1484

L
Linus Torvalds 已提交
1485 1486
// precondition: never called in_interrupt

1487
void usbnet_disconnect (struct usb_interface *intf)
L
Linus Torvalds 已提交
1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499
{
	struct usbnet		*dev;
	struct usb_device	*xdev;
	struct net_device	*net;

	dev = usb_get_intfdata(intf);
	usb_set_intfdata(intf, NULL);
	if (!dev)
		return;

	xdev = interface_to_usbdev (intf);

1500 1501 1502 1503
	netif_info(dev, probe, dev->net, "unregister '%s' usb-%s-%s, %s\n",
		   intf->dev.driver->name,
		   xdev->bus->bus_name, xdev->devpath,
		   dev->driver_info->description);
1504

L
Linus Torvalds 已提交
1505 1506 1507
	net = dev->net;
	unregister_netdev (net);

1508
	cancel_work_sync(&dev->kevent);
L
Linus Torvalds 已提交
1509

1510 1511
	usb_scuttle_anchored_urbs(&dev->deferred);

L
Linus Torvalds 已提交
1512 1513 1514
	if (dev->driver_info->unbind)
		dev->driver_info->unbind (dev, intf);

1515 1516
	usb_kill_urb(dev->interrupt);
	usb_free_urb(dev->interrupt);
M
Ming Lei 已提交
1517
	kfree(dev->padding_pkt);
1518

L
Linus Torvalds 已提交
1519 1520
	free_netdev(net);
}
1521
EXPORT_SYMBOL_GPL(usbnet_disconnect);
L
Linus Torvalds 已提交
1522

1523 1524 1525 1526 1527 1528 1529 1530 1531
static const struct net_device_ops usbnet_netdev_ops = {
	.ndo_open		= usbnet_open,
	.ndo_stop		= usbnet_stop,
	.ndo_start_xmit		= usbnet_start_xmit,
	.ndo_tx_timeout		= usbnet_tx_timeout,
	.ndo_change_mtu		= usbnet_change_mtu,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
};
L
Linus Torvalds 已提交
1532 1533 1534 1535 1536

/*-------------------------------------------------------------------------*/

// precondition: never called in_interrupt

1537 1538 1539 1540 1541 1542 1543 1544
static struct device_type wlan_type = {
	.name	= "wlan",
};

static struct device_type wwan_type = {
	.name	= "wwan",
};

1545
int
L
Linus Torvalds 已提交
1546 1547 1548
usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
{
	struct usbnet			*dev;
1549
	struct net_device		*net;
L
Linus Torvalds 已提交
1550 1551 1552 1553
	struct usb_host_interface	*interface;
	struct driver_info		*info;
	struct usb_device		*xdev;
	int				status;
1554
	const char			*name;
1555 1556 1557 1558
	struct usb_driver 	*driver = to_usb_driver(udev->dev.driver);

	/* usbnet already took usb runtime pm, so have to enable the feature
	 * for usb interface, otherwise usb_autopm_get_interface may return
1559
	 * failure if RUNTIME_PM is enabled.
1560 1561 1562 1563 1564
	 */
	if (!driver->supports_autosuspend) {
		driver->supports_autosuspend = 1;
		pm_runtime_enable(&udev->dev);
	}
L
Linus Torvalds 已提交
1565

1566
	name = udev->dev.driver->name;
L
Linus Torvalds 已提交
1567 1568
	info = (struct driver_info *) prod->driver_info;
	if (!info) {
1569
		dev_dbg (&udev->dev, "blacklisted by %s\n", name);
L
Linus Torvalds 已提交
1570 1571 1572 1573 1574 1575 1576 1577 1578
		return -ENODEV;
	}
	xdev = interface_to_usbdev (udev);
	interface = udev->cur_altsetting;

	status = -ENOMEM;

	// set up our own records
	net = alloc_etherdev(sizeof(*dev));
1579
	if (!net)
L
Linus Torvalds 已提交
1580 1581
		goto out;

1582 1583 1584
	/* netdev_printk() needs this so do it as early as possible */
	SET_NETDEV_DEV(net, &udev->dev);

L
Linus Torvalds 已提交
1585 1586
	dev = netdev_priv(net);
	dev->udev = xdev;
1587
	dev->intf = udev;
L
Linus Torvalds 已提交
1588
	dev->driver_info = info;
1589
	dev->driver_name = name;
L
Linus Torvalds 已提交
1590 1591
	dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV
				| NETIF_MSG_PROBE | NETIF_MSG_LINK);
1592
	init_waitqueue_head(&dev->wait);
L
Linus Torvalds 已提交
1593 1594 1595
	skb_queue_head_init (&dev->rxq);
	skb_queue_head_init (&dev->txq);
	skb_queue_head_init (&dev->done);
J
Jussi Kivilinna 已提交
1596
	skb_queue_head_init(&dev->rxq_pause);
L
Linus Torvalds 已提交
1597 1598
	dev->bh.func = usbnet_bh;
	dev->bh.data = (unsigned long) dev;
D
David Howells 已提交
1599
	INIT_WORK (&dev->kevent, kevent);
1600
	init_usb_anchor(&dev->deferred);
L
Linus Torvalds 已提交
1601 1602 1603
	dev->delay.function = usbnet_bh;
	dev->delay.data = (unsigned long) dev;
	init_timer (&dev->delay);
1604
	mutex_init (&dev->phy_mutex);
1605 1606
	mutex_init(&dev->interrupt_mutex);
	dev->interrupt_count = 0;
L
Linus Torvalds 已提交
1607 1608 1609 1610 1611

	dev->net = net;
	strcpy (net->name, "usb%d");
	memcpy (net->dev_addr, node_id, sizeof node_id);

1612 1613 1614 1615
	/* rx and tx sides can use different message sizes;
	 * bind() should set rx_urb_size in that case.
	 */
	dev->hard_mtu = net->mtu + net->hard_header_len;
L
Linus Torvalds 已提交
1616 1617 1618
#if 0
// dma_supported() is deeply broken on almost all architectures
	// possible with some EHCI controllers
1619
	if (dma_supported (&udev->dev, DMA_BIT_MASK(64)))
L
Linus Torvalds 已提交
1620 1621 1622
		net->features |= NETIF_F_HIGHDMA;
#endif

1623 1624
	net->netdev_ops = &usbnet_netdev_ops;
	net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
L
Linus Torvalds 已提交
1625 1626 1627 1628 1629 1630
	net->ethtool_ops = &usbnet_ethtool_ops;

	// allow device-specific bind/init procedures
	// NOTE net->name still not usable ...
	if (info->bind) {
		status = info->bind (dev, udev);
1631 1632 1633
		if (status < 0)
			goto out1;

L
Linus Torvalds 已提交
1634 1635 1636
		// heuristic:  "usb%d" for links we know are two-host,
		// else "eth%d" when there's reasonable doubt.  userspace
		// can rename the link if it knows better.
1637
		if ((dev->driver_info->flags & FLAG_ETHER) != 0 &&
1638 1639
		    ((dev->driver_info->flags & FLAG_POINTTOPOINT) == 0 ||
		     (net->dev_addr [0] & 0x02) == 0))
L
Linus Torvalds 已提交
1640
			strcpy (net->name, "eth%d");
1641 1642 1643
		/* WLAN devices should always be named "wlan%d" */
		if ((dev->driver_info->flags & FLAG_WLAN) != 0)
			strcpy(net->name, "wlan%d");
1644 1645 1646
		/* WWAN devices should always be named "wwan%d" */
		if ((dev->driver_info->flags & FLAG_WWAN) != 0)
			strcpy(net->name, "wwan%d");
1647

1648 1649 1650 1651
		/* devices that cannot do ARP */
		if ((dev->driver_info->flags & FLAG_NOARP) != 0)
			net->flags |= IFF_NOARP;

1652 1653 1654
		/* maybe the remote can't receive an Ethernet MTU */
		if (net->mtu > (dev->hard_mtu - net->hard_header_len))
			net->mtu = dev->hard_mtu - net->hard_header_len;
1655 1656
	} else if (!info->in || !info->out)
		status = usbnet_get_endpoints (dev, udev);
L
Linus Torvalds 已提交
1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667
	else {
		dev->in = usb_rcvbulkpipe (xdev, info->in);
		dev->out = usb_sndbulkpipe (xdev, info->out);
		if (!(info->flags & FLAG_NO_SETINT))
			status = usb_set_interface (xdev,
				interface->desc.bInterfaceNumber,
				interface->desc.bAlternateSetting);
		else
			status = 0;

	}
1668
	if (status >= 0 && dev->status)
L
Linus Torvalds 已提交
1669 1670
		status = init_status (dev, udev);
	if (status < 0)
1671
		goto out3;
L
Linus Torvalds 已提交
1672

1673 1674
	if (!dev->rx_urb_size)
		dev->rx_urb_size = dev->hard_mtu;
L
Linus Torvalds 已提交
1675
	dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);
1676

1677 1678 1679 1680
	/* let userspace know we have a random address */
	if (ether_addr_equal(net->dev_addr, node_id))
		net->addr_assign_type = NET_ADDR_RANDOM;

1681 1682 1683 1684 1685
	if ((dev->driver_info->flags & FLAG_WLAN) != 0)
		SET_NETDEV_DEVTYPE(net, &wlan_type);
	if ((dev->driver_info->flags & FLAG_WWAN) != 0)
		SET_NETDEV_DEVTYPE(net, &wwan_type);

1686 1687 1688
	/* initialize max rx_qlen and tx_qlen */
	usbnet_update_max_qlen(dev);

M
Ming Lei 已提交
1689 1690 1691
	if (dev->can_dma_sg && !(info->flags & FLAG_SEND_ZLP) &&
		!(info->flags & FLAG_MULTI_PACKET)) {
		dev->padding_pkt = kzalloc(1, GFP_KERNEL);
1692 1693
		if (!dev->padding_pkt) {
			status = -ENOMEM;
M
Ming Lei 已提交
1694
			goto out4;
1695
		}
M
Ming Lei 已提交
1696 1697
	}

L
Linus Torvalds 已提交
1698 1699
	status = register_netdev (net);
	if (status)
M
Ming Lei 已提交
1700
		goto out5;
1701 1702 1703 1704 1705 1706
	netif_info(dev, probe, dev->net,
		   "register '%s' at usb-%s-%s, %s, %pM\n",
		   udev->dev.driver->name,
		   xdev->bus->bus_name, xdev->devpath,
		   dev->driver_info->description,
		   net->dev_addr);
L
Linus Torvalds 已提交
1707 1708 1709 1710 1711 1712

	// ok, it's ready to go.
	usb_set_intfdata (udev, dev);

	netif_device_attach (net);

1713
	if (dev->driver_info->flags & FLAG_LINK_INTR)
M
Ming Lei 已提交
1714
		usbnet_link_change(dev, 0, 0);
1715

L
Linus Torvalds 已提交
1716 1717
	return 0;

M
Ming Lei 已提交
1718 1719
out5:
	kfree(dev->padding_pkt);
1720 1721
out4:
	usb_free_urb(dev->interrupt);
L
Linus Torvalds 已提交
1722 1723 1724 1725 1726 1727 1728 1729
out3:
	if (info->unbind)
		info->unbind (dev, udev);
out1:
	free_netdev(net);
out:
	return status;
}
1730
EXPORT_SYMBOL_GPL(usbnet_probe);
L
Linus Torvalds 已提交
1731 1732 1733

/*-------------------------------------------------------------------------*/

1734 1735 1736
/*
 * suspend the whole driver as soon as the first interface is suspended
 * resume only when the last interface is resumed
1737
 */
L
Linus Torvalds 已提交
1738

1739
int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
L
Linus Torvalds 已提交
1740 1741
{
	struct usbnet		*dev = usb_get_intfdata(intf);
1742

1743
	if (!dev->suspend_count++) {
1744 1745
		spin_lock_irq(&dev->txq.lock);
		/* don't autosuspend while transmitting */
1746
		if (dev->txq.qlen && PMSG_IS_AUTO(message)) {
1747
			dev->suspend_count--;
1748 1749 1750 1751 1752 1753
			spin_unlock_irq(&dev->txq.lock);
			return -EBUSY;
		} else {
			set_bit(EVENT_DEV_ASLEEP, &dev->flags);
			spin_unlock_irq(&dev->txq.lock);
		}
1754 1755
		/*
		 * accelerate emptying of the rx and queues, to avoid
1756 1757 1758
		 * having everything error out.
		 */
		netif_device_detach (dev->net);
1759
		usbnet_terminate_urbs(dev);
1760
		__usbnet_status_stop_force(dev);
1761

1762 1763 1764 1765 1766
		/*
		 * reattach so runtime management can use and
		 * wake the device
		 */
		netif_device_attach (dev->net);
1767
	}
L
Linus Torvalds 已提交
1768 1769
	return 0;
}
1770
EXPORT_SYMBOL_GPL(usbnet_suspend);
L
Linus Torvalds 已提交
1771

1772
int usbnet_resume (struct usb_interface *intf)
L
Linus Torvalds 已提交
1773 1774
{
	struct usbnet		*dev = usb_get_intfdata(intf);
1775 1776 1777 1778 1779
	struct sk_buff          *skb;
	struct urb              *res;
	int                     retval;

	if (!--dev->suspend_count) {
1780 1781
		/* resume interrupt URB if it was previously submitted */
		__usbnet_status_start_force(dev, GFP_NOIO);
1782

1783 1784 1785 1786 1787 1788 1789
		spin_lock_irq(&dev->txq.lock);
		while ((res = usb_get_from_anchor(&dev->deferred))) {

			skb = (struct sk_buff *)res->context;
			retval = usb_submit_urb(res, GFP_ATOMIC);
			if (retval < 0) {
				dev_kfree_skb_any(skb);
M
Ming Lei 已提交
1790
				kfree(res->sg);
1791 1792 1793 1794 1795 1796 1797
				usb_free_urb(res);
				usb_autopm_put_interface_async(dev->intf);
			} else {
				dev->net->trans_start = jiffies;
				__skb_queue_tail(&dev->txq, skb);
			}
		}
L
Linus Torvalds 已提交
1798

1799 1800 1801
		smp_mb();
		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
		spin_unlock_irq(&dev->txq.lock);
M
Ming Lei 已提交
1802 1803

		if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
1804 1805 1806 1807
			/* handle remote wakeup ASAP
			 * we cannot race against stop
			 */
			if (netif_device_present(dev->net) &&
M
Ming Lei 已提交
1808 1809
				!timer_pending(&dev->delay) &&
				!test_bit(EVENT_RX_HALT, &dev->flags))
O
Oliver Neukum 已提交
1810
					rx_alloc_submit(dev, GFP_NOIO);
M
Ming Lei 已提交
1811

M
Ming Lei 已提交
1812
			if (!(dev->txq.qlen >= TX_QLEN(dev)))
1813
				netif_tx_wake_all_queues(dev->net);
M
Ming Lei 已提交
1814 1815
			tasklet_schedule (&dev->bh);
		}
1816
	}
1817 1818 1819 1820

	if (test_and_clear_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags))
		usb_autopm_get_interface_no_resume(intf);

L
Linus Torvalds 已提交
1821 1822
	return 0;
}
1823
EXPORT_SYMBOL_GPL(usbnet_resume);
L
Linus Torvalds 已提交
1824

1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837
/*
 * Either a subdriver implements manage_power, then it is assumed to always
 * be ready to be suspended or it reports the readiness to be suspended
 * explicitly
 */
void usbnet_device_suggests_idle(struct usbnet *dev)
{
	if (!test_and_set_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags)) {
		dev->intf->needs_remote_wakeup = 1;
		usb_autopm_put_interface_async(dev->intf);
	}
}
EXPORT_SYMBOL(usbnet_device_suggests_idle);
L
Linus Torvalds 已提交
1838

O
Oliver Neukum 已提交
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
/*
 * For devices that can do without special commands
 */
int usbnet_manage_power(struct usbnet *dev, int on)
{
	dev->intf->needs_remote_wakeup = on;
	return 0;
}
EXPORT_SYMBOL(usbnet_manage_power);

1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
void usbnet_link_change(struct usbnet *dev, bool link, bool need_reset)
{
	/* update link after link is reseted */
	if (link && !need_reset)
		netif_carrier_on(dev->net);
	else
		netif_carrier_off(dev->net);

	if (need_reset && link)
		usbnet_defer_kevent(dev, EVENT_LINK_RESET);
M
Ming Lei 已提交
1859 1860
	else
		usbnet_defer_kevent(dev, EVENT_LINK_CHANGE);
1861 1862 1863
}
EXPORT_SYMBOL(usbnet_link_change);

1864
/*-------------------------------------------------------------------------*/
1865 1866
static int __usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
			     u16 value, u16 index, void *data, u16 size)
1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890
{
	void *buf = NULL;
	int err = -ENOMEM;

	netdev_dbg(dev->net, "usbnet_read_cmd cmd=0x%02x reqtype=%02x"
		   " value=0x%04x index=0x%04x size=%d\n",
		   cmd, reqtype, value, index, size);

	if (data) {
		buf = kmalloc(size, GFP_KERNEL);
		if (!buf)
			goto out;
	}

	err = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
			      cmd, reqtype, value, index, buf, size,
			      USB_CTRL_GET_TIMEOUT);
	if (err > 0 && err <= size)
		memcpy(data, buf, err);
	kfree(buf);
out:
	return err;
}

1891 1892 1893
static int __usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
			      u16 value, u16 index, const void *data,
			      u16 size)
1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915
{
	void *buf = NULL;
	int err = -ENOMEM;

	netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
		   " value=0x%04x index=0x%04x size=%d\n",
		   cmd, reqtype, value, index, size);

	if (data) {
		buf = kmemdup(data, size, GFP_KERNEL);
		if (!buf)
			goto out;
	}

	err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
			      cmd, reqtype, value, index, buf, size,
			      USB_CTRL_SET_TIMEOUT);
	kfree(buf);

out:
	return err;
}
1916 1917 1918 1919 1920 1921 1922 1923

/*
 * The function can't be called inside suspend/resume callback,
 * otherwise deadlock will be caused.
 */
int usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
		    u16 value, u16 index, void *data, u16 size)
{
1924 1925 1926 1927 1928 1929 1930 1931
	int ret;

	if (usb_autopm_get_interface(dev->intf) < 0)
		return -ENODEV;
	ret = __usbnet_read_cmd(dev, cmd, reqtype, value, index,
				data, size);
	usb_autopm_put_interface(dev->intf);
	return ret;
1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
}
EXPORT_SYMBOL_GPL(usbnet_read_cmd);

/*
 * The function can't be called inside suspend/resume callback,
 * otherwise deadlock will be caused.
 */
int usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
		     u16 value, u16 index, const void *data, u16 size)
{
1942 1943 1944 1945 1946 1947 1948 1949
	int ret;

	if (usb_autopm_get_interface(dev->intf) < 0)
		return -ENODEV;
	ret = __usbnet_write_cmd(dev, cmd, reqtype, value, index,
				 data, size);
	usb_autopm_put_interface(dev->intf);
	return ret;
1950
}
1951 1952
EXPORT_SYMBOL_GPL(usbnet_write_cmd);

1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
/*
 * The function can be called inside suspend/resume callback safely
 * and should only be called by suspend/resume callback generally.
 */
int usbnet_read_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
			  u16 value, u16 index, void *data, u16 size)
{
	return __usbnet_read_cmd(dev, cmd, reqtype, value, index,
				 data, size);
}
EXPORT_SYMBOL_GPL(usbnet_read_cmd_nopm);

/*
 * The function can be called inside suspend/resume callback safely
 * and should only be called by suspend/resume callback generally.
 */
int usbnet_write_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
			  u16 value, u16 index, const void *data,
			  u16 size)
{
	return __usbnet_write_cmd(dev, cmd, reqtype, value, index,
				  data, size);
}
EXPORT_SYMBOL_GPL(usbnet_write_cmd_nopm);

1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
static void usbnet_async_cmd_cb(struct urb *urb)
{
	struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
	int status = urb->status;

	if (status < 0)
		dev_dbg(&urb->dev->dev, "%s failed with %d",
			__func__, status);

	kfree(req);
	usb_free_urb(urb);
}

1991 1992 1993 1994
/*
 * The caller must make sure that device can't be put into suspend
 * state until the control URB completes.
 */
1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023
int usbnet_write_cmd_async(struct usbnet *dev, u8 cmd, u8 reqtype,
			   u16 value, u16 index, const void *data, u16 size)
{
	struct usb_ctrlrequest *req = NULL;
	struct urb *urb;
	int err = -ENOMEM;
	void *buf = NULL;

	netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
		   " value=0x%04x index=0x%04x size=%d\n",
		   cmd, reqtype, value, index, size);

	urb = usb_alloc_urb(0, GFP_ATOMIC);
	if (!urb) {
		netdev_err(dev->net, "Error allocating URB in"
			   " %s!\n", __func__);
		goto fail;
	}

	if (data) {
		buf = kmemdup(data, size, GFP_ATOMIC);
		if (!buf) {
			netdev_err(dev->net, "Error allocating buffer"
				   " in %s!\n", __func__);
			goto fail_free;
		}
	}

	req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
2024
	if (!req)
2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056
		goto fail_free_buf;

	req->bRequestType = reqtype;
	req->bRequest = cmd;
	req->wValue = cpu_to_le16(value);
	req->wIndex = cpu_to_le16(index);
	req->wLength = cpu_to_le16(size);

	usb_fill_control_urb(urb, dev->udev,
			     usb_sndctrlpipe(dev->udev, 0),
			     (void *)req, buf, size,
			     usbnet_async_cmd_cb, req);
	urb->transfer_flags |= URB_FREE_BUFFER;

	err = usb_submit_urb(urb, GFP_ATOMIC);
	if (err < 0) {
		netdev_err(dev->net, "Error submitting the control"
			   " message: status=%d\n", err);
		goto fail_free;
	}
	return 0;

fail_free_buf:
	kfree(buf);
fail_free:
	kfree(req);
	usb_free_urb(urb);
fail:
	return err;

}
EXPORT_SYMBOL_GPL(usbnet_write_cmd_async);
L
Linus Torvalds 已提交
2057 2058
/*-------------------------------------------------------------------------*/

2059
static int __init usbnet_init(void)
L
Linus Torvalds 已提交
2060
{
2061 2062 2063
	/* Compiler should optimize this out. */
	BUILD_BUG_ON(
		FIELD_SIZEOF(struct sk_buff, cb) < sizeof(struct skb_data));
L
Linus Torvalds 已提交
2064

J
Joe Perches 已提交
2065
	eth_random_addr(node_id);
2066
	return 0;
L
Linus Torvalds 已提交
2067
}
2068
module_init(usbnet_init);
L
Linus Torvalds 已提交
2069

2070
static void __exit usbnet_exit(void)
L
Linus Torvalds 已提交
2071 2072
{
}
2073
module_exit(usbnet_exit);
L
Linus Torvalds 已提交
2074

2075
MODULE_AUTHOR("David Brownell");
2076
MODULE_DESCRIPTION("USB network driver framework");
2077
MODULE_LICENSE("GPL");