usbnet.c 43.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 * USB Network driver infrastructure
3
 * Copyright (C) 2000-2005 by David Brownell
Linus Torvalds's avatar
Linus Torvalds committed
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 * 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
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * This is a generic "USB networking" framework that works with several
23
24
 * kinds of full and high speed networking devices:  host-to-host cables,
 * smart usb peripherals, and actual Ethernet adapters.
Linus Torvalds's avatar
Linus Torvalds committed
25
 *
26
27
28
29
30
31
 * 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.
 */
Linus Torvalds's avatar
Linus Torvalds committed
32
33
34
35
36
37
38
39

// #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>
40
#include <linux/ctype.h>
Linus Torvalds's avatar
Linus Torvalds committed
41
42
43
44
#include <linux/ethtool.h>
#include <linux/workqueue.h>
#include <linux/mii.h>
#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"
Linus Torvalds's avatar
Linus Torvalds committed
51
52
53
54
55
56
57
58
59
60


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

/*
 * 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).
61
62
63
64
 *
 * REVISIT qlens should be members of 'struct usbnet'; 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.
Linus Torvalds's avatar
Linus Torvalds committed
65
 */
66
67
68
69
70
#define RX_MAX_QUEUE_MEMORY (60 * 1518)
#define	RX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \
			(RX_MAX_QUEUE_MEMORY/(dev)->rx_urb_size) : 4)
#define	TX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \
			(RX_MAX_QUEUE_MEMORY/(dev)->hard_mtu) : 4)
Linus Torvalds's avatar
Linus Torvalds committed
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

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

// throttle rx/tx briefly after some faults, so khubd might disconnect()
// us (it polls at HZ/4 usually) before we report too many false errors.
#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 */
97
int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
Linus Torvalds's avatar
Linus Torvalds committed
98
99
100
101
102
103
104
105
106
107
108
109
110
111
{
	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;
112
		 * ignore other endpoints and altsettings.
Linus Torvalds's avatar
Linus Torvalds committed
113
114
115
116
117
118
119
120
		 */
		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:
121
				if (!usb_endpoint_dir_in(&e->desc))
Linus Torvalds's avatar
Linus Torvalds committed
122
123
124
125
126
127
128
129
					continue;
				intr = 1;
				/* FALLTHROUGH */
			case USB_ENDPOINT_XFER_BULK:
				break;
			default:
				continue;
			}
130
			if (usb_endpoint_dir_in(&e->desc)) {
Linus Torvalds's avatar
Linus Torvalds committed
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
				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;

146
147
	if (alt->desc.bAlternateSetting != 0 ||
	    !(dev->driver_info->flags & FLAG_NO_SETINT)) {
Linus Torvalds's avatar
Linus Torvalds committed
148
149
150
151
152
		tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber,
				alt->desc.bAlternateSetting);
		if (tmp < 0)
			return tmp;
	}
153

Linus Torvalds's avatar
Linus Torvalds committed
154
155
156
157
158
159
160
	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;
}
161
EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
Linus Torvalds's avatar
Linus Torvalds committed
162

163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
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] =
178
			(hex_to_bin(buf[tmp]) << 4) + hex_to_bin(buf[tmp + 1]);
179
180
181
182
	return 0;
}
EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);

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
212
213
214
215
216
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;
	}

	if (!netif_running (dev->net))
		return;

	status = usb_submit_urb (urb, GFP_ATOMIC);
	if (status != 0)
		netif_err(dev, timer, dev->net,
			  "intr resubmit --> %d\n", status);
}
Linus Torvalds's avatar
Linus Torvalds committed
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236

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

237
	buf = kmalloc (maxp, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
238
	if (buf) {
239
		dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
240
241
242
243
244
245
		if (!dev->interrupt) {
			kfree (buf);
			return -ENOMEM;
		} else {
			usb_fill_int_urb(dev->interrupt, dev->udev, pipe,
				buf, maxp, intr_complete, dev, period);
246
			dev->interrupt->transfer_flags |= URB_FREE_BUFFER;
Linus Torvalds's avatar
Linus Torvalds committed
247
248
249
250
251
			dev_dbg(&intf->dev,
				"status ep%din, %d bytes period %d\n",
				usb_pipeendpoint(pipe), maxp, period);
		}
	}
David Brownell's avatar
David Brownell committed
252
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
253
254
}

255
256
257
258
259
/* 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)
Linus Torvalds's avatar
Linus Torvalds committed
260
261
262
{
	int	status;

Jussi Kivilinna's avatar
Jussi Kivilinna committed
263
264
265
266
267
	if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
		skb_queue_tail(&dev->rxq_pause, skb);
		return;
	}

Linus Torvalds's avatar
Linus Torvalds committed
268
	skb->protocol = eth_type_trans (skb, dev->net);
269
270
	dev->net->stats.rx_packets++;
	dev->net->stats.rx_bytes += skb->len;
Linus Torvalds's avatar
Linus Torvalds committed
271

272
273
	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
		  skb->len + sizeof (struct ethhdr), skb->protocol);
Linus Torvalds's avatar
Linus Torvalds committed
274
	memset (skb->cb, 0, sizeof (struct skb_data));
275
276
277
278

	if (skb_defer_rx_timestamp(skb))
		return;

Linus Torvalds's avatar
Linus Torvalds committed
279
	status = netif_rx (skb);
280
281
282
	if (status != NET_RX_SUCCESS)
		netif_dbg(dev, rx_err, dev->net,
			  "netif_rx status %d\n", status);
Linus Torvalds's avatar
Linus Torvalds committed
283
}
284
EXPORT_SYMBOL_GPL(usbnet_skb_return);
Linus Torvalds's avatar
Linus Torvalds committed
285
286
287
288
289
290
291
292


/*-------------------------------------------------------------------------
 *
 * Network Device Driver (peer link to "Host Device", from USB host)
 *
 *-------------------------------------------------------------------------*/

293
int usbnet_change_mtu (struct net_device *net, int new_mtu)
Linus Torvalds's avatar
Linus Torvalds committed
294
295
{
	struct usbnet	*dev = netdev_priv(net);
296
	int		ll_mtu = new_mtu + net->hard_header_len;
297
298
	int		old_hard_mtu = dev->hard_mtu;
	int		old_rx_urb_size = dev->rx_urb_size;
Linus Torvalds's avatar
Linus Torvalds committed
299

300
	if (new_mtu <= 0)
Linus Torvalds's avatar
Linus Torvalds committed
301
302
		return -EINVAL;
	// no second zero-length packet read wanted after mtu-sized packets
303
	if ((ll_mtu % dev->maxpacket) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
304
305
		return -EDOM;
	net->mtu = new_mtu;
306
307
308
309
310
311
312
313

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

Linus Torvalds's avatar
Linus Torvalds committed
314
315
	return 0;
}
316
EXPORT_SYMBOL_GPL(usbnet_change_mtu);
Linus Torvalds's avatar
Linus Torvalds committed
317

318
319
320
321
322
323
324
325
326
327
/* 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;
}

Linus Torvalds's avatar
Linus Torvalds committed
328
329
330
331
332
333
/*-------------------------------------------------------------------------*/

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

334
335
static enum skb_state defer_bh(struct usbnet *dev, struct sk_buff *skb,
		struct sk_buff_head *list, enum skb_state state)
Linus Torvalds's avatar
Linus Torvalds committed
336
337
{
	unsigned long		flags;
338
339
	enum skb_state 		old_state;
	struct skb_data *entry = (struct skb_data *) skb->cb;
Linus Torvalds's avatar
Linus Torvalds committed
340

David S. Miller's avatar
David S. Miller committed
341
	spin_lock_irqsave(&list->lock, flags);
342
343
	old_state = entry->state;
	entry->state = state;
David S. Miller's avatar
David S. Miller committed
344
345
346
347
	__skb_unlink(skb, list);
	spin_unlock(&list->lock);
	spin_lock(&dev->done.lock);
	__skb_queue_tail(&dev->done, skb);
Linus Torvalds's avatar
Linus Torvalds committed
348
	if (dev->done.qlen == 1)
David S. Miller's avatar
David S. Miller committed
349
350
		tasklet_schedule(&dev->bh);
	spin_unlock_irqrestore(&dev->done.lock, flags);
351
	return old_state;
Linus Torvalds's avatar
Linus Torvalds committed
352
353
354
355
356
357
358
}

/* 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.
 */
359
void usbnet_defer_kevent (struct usbnet *dev, int work)
Linus Torvalds's avatar
Linus Torvalds committed
360
361
362
{
	set_bit (work, &dev->flags);
	if (!schedule_work (&dev->kevent))
363
		netdev_err(dev->net, "kevent %d may have been dropped\n", work);
Linus Torvalds's avatar
Linus Torvalds committed
364
	else
365
		netdev_dbg(dev->net, "kevent %d scheduled\n", work);
Linus Torvalds's avatar
Linus Torvalds committed
366
}
367
EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
Linus Torvalds's avatar
Linus Torvalds committed
368
369
370

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

371
static void rx_complete (struct urb *urb);
Linus Torvalds's avatar
Linus Torvalds committed
372

373
static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
Linus Torvalds's avatar
Linus Torvalds committed
374
375
376
377
378
{
	struct sk_buff		*skb;
	struct skb_data		*entry;
	int			retval = 0;
	unsigned long		lockflags;
379
	size_t			size = dev->rx_urb_size;
Linus Torvalds's avatar
Linus Torvalds committed
380

381
382
	skb = __netdev_alloc_skb_ip_align(dev->net, size, flags);
	if (!skb) {
383
		netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
384
		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
Linus Torvalds's avatar
Linus Torvalds committed
385
		usb_free_urb (urb);
386
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
387
388
389
390
391
392
393
394
395
396
397
398
	}

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

399
400
	if (netif_running (dev->net) &&
	    netif_device_present (dev->net) &&
401
402
	    !test_bit (EVENT_RX_HALT, &dev->flags) &&
	    !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {
David Brownell's avatar
David Brownell committed
403
		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {
Linus Torvalds's avatar
Linus Torvalds committed
404
		case -EPIPE:
405
			usbnet_defer_kevent (dev, EVENT_RX_HALT);
Linus Torvalds's avatar
Linus Torvalds committed
406
407
			break;
		case -ENOMEM:
408
			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
Linus Torvalds's avatar
Linus Torvalds committed
409
410
			break;
		case -ENODEV:
411
			netif_dbg(dev, ifdown, dev->net, "device gone\n");
Linus Torvalds's avatar
Linus Torvalds committed
412
413
			netif_device_detach (dev->net);
			break;
414
415
416
		case -EHOSTUNREACH:
			retval = -ENOLINK;
			break;
Linus Torvalds's avatar
Linus Torvalds committed
417
		default:
418
419
			netif_dbg(dev, rx_err, dev->net,
				  "rx submit, %d\n", retval);
Linus Torvalds's avatar
Linus Torvalds committed
420
421
422
			tasklet_schedule (&dev->bh);
			break;
		case 0:
423
			__usbnet_queue_skb(&dev->rxq, skb, rx_start);
Linus Torvalds's avatar
Linus Torvalds committed
424
425
		}
	} else {
426
		netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
Linus Torvalds's avatar
Linus Torvalds committed
427
428
429
430
431
432
433
		retval = -ENOLINK;
	}
	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
	if (retval) {
		dev_kfree_skb_any (skb);
		usb_free_urb (urb);
	}
434
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
435
436
437
438
439
440
441
}


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

static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
{
442
	if (dev->driver_info->rx_fixup &&
443
444
445
446
447
448
	    !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;
	}
Linus Torvalds's avatar
Linus Torvalds committed
449
450
	// else network stack removes extra byte if we forced a short packet

451
452
453
454
455
456
457
	if (skb->len) {
		/* all data was already cloned from skb inside the driver */
		if (dev->driver_info->flags & FLAG_MULTI_PACKET)
			dev_kfree_skb_any(skb);
		else
			usbnet_skb_return(dev, skb);
		return;
Linus Torvalds's avatar
Linus Torvalds committed
458
	}
459
460
461

	netif_dbg(dev, rx_err, dev->net, "drop\n");
	dev->net->stats.rx_errors++;
462
done:
463
	skb_queue_tail(&dev->done, skb);
Linus Torvalds's avatar
Linus Torvalds committed
464
465
466
467
}

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

468
static void rx_complete (struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
469
470
471
472
473
{
	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;
474
	enum skb_state		state;
Linus Torvalds's avatar
Linus Torvalds committed
475
476

	skb_put (skb, urb->actual_length);
477
	state = rx_done;
Linus Torvalds's avatar
Linus Torvalds committed
478
479
480
	entry->urb = NULL;

	switch (urb_status) {
David Brownell's avatar
David Brownell committed
481
482
	/* success */
	case 0:
483
		if (skb->len < dev->net->hard_header_len) {
484
			state = rx_cleanup;
485
486
			dev->net->stats.rx_errors++;
			dev->net->stats.rx_length_errors++;
487
488
			netif_dbg(dev, rx_err, dev->net,
				  "rx length %d\n", skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
489
490
491
		}
		break;

David Brownell's avatar
David Brownell committed
492
493
	/* stalls need manual reset. this is rare ... except that
	 * when going through USB 2.0 TTs, unplug appears this way.
494
	 * we avoid the highspeed version of the ETIMEDOUT/EILSEQ
David Brownell's avatar
David Brownell committed
495
496
497
	 * storm, recovering as needed.
	 */
	case -EPIPE:
498
		dev->net->stats.rx_errors++;
499
		usbnet_defer_kevent (dev, EVENT_RX_HALT);
Linus Torvalds's avatar
Linus Torvalds committed
500
501
		// FALLTHROUGH

David Brownell's avatar
David Brownell committed
502
503
504
	/* software-driven interface shutdown */
	case -ECONNRESET:		/* async unlink */
	case -ESHUTDOWN:		/* hardware gone */
505
506
		netif_dbg(dev, ifdown, dev->net,
			  "rx shutdown, code %d\n", urb_status);
Linus Torvalds's avatar
Linus Torvalds committed
507
508
		goto block;

David Brownell's avatar
David Brownell committed
509
510
511
512
513
514
515
	/* we get controller i/o faults during khubd disconnect() delays.
	 * throttle down resubmits, to avoid log floods; just temporarily,
	 * so we still recover when the fault isn't a khubd delay.
	 */
	case -EPROTO:
	case -ETIME:
	case -EILSEQ:
516
		dev->net->stats.rx_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
517
518
		if (!timer_pending (&dev->delay)) {
			mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
519
520
			netif_dbg(dev, link, dev->net,
				  "rx throttle %d\n", urb_status);
Linus Torvalds's avatar
Linus Torvalds committed
521
522
		}
block:
523
		state = rx_cleanup;
Linus Torvalds's avatar
Linus Torvalds committed
524
525
526
527
		entry->urb = urb;
		urb = NULL;
		break;

David Brownell's avatar
David Brownell committed
528
529
	/* data overrun ... flush fifo? */
	case -EOVERFLOW:
530
		dev->net->stats.rx_over_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
531
		// FALLTHROUGH
532

David Brownell's avatar
David Brownell committed
533
	default:
534
		state = rx_cleanup;
535
		dev->net->stats.rx_errors++;
536
		netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
Linus Torvalds's avatar
Linus Torvalds committed
537
538
539
		break;
	}

540
	state = defer_bh(dev, skb, &dev->rxq, state);
Linus Torvalds's avatar
Linus Torvalds committed
541
542

	if (urb) {
543
		if (netif_running (dev->net) &&
544
545
		    !test_bit (EVENT_RX_HALT, &dev->flags) &&
		    state != unlink_start) {
Linus Torvalds's avatar
Linus Torvalds committed
546
			rx_submit (dev, urb, GFP_ATOMIC);
547
			usb_mark_last_busy(dev->udev);
Linus Torvalds's avatar
Linus Torvalds committed
548
549
550
551
			return;
		}
		usb_free_urb (urb);
	}
552
	netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
Linus Torvalds's avatar
Linus Torvalds committed
553
554
}

Jussi Kivilinna's avatar
Jussi Kivilinna committed
555
556
557
558
559
/*-------------------------------------------------------------------------*/
void usbnet_pause_rx(struct usbnet *dev)
{
	set_bit(EVENT_RX_PAUSED, &dev->flags);

560
	netif_dbg(dev, rx_status, dev->net, "paused rx queue enabled\n");
Jussi Kivilinna's avatar
Jussi Kivilinna committed
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
}
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);

578
579
	netif_dbg(dev, rx_status, dev->net,
		  "paused rx queue disabled, %d skbs requeued\n", num);
Jussi Kivilinna's avatar
Jussi Kivilinna committed
580
581
582
583
584
585
586
587
588
}
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);

Linus Torvalds's avatar
Linus Torvalds committed
589
590
591
592
593
594
595
/*-------------------------------------------------------------------------*/

// 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;
596
	struct sk_buff		*skb;
Linus Torvalds's avatar
Linus Torvalds committed
597
598
599
	int			count = 0;

	spin_lock_irqsave (&q->lock, flags);
600
	while (!skb_queue_empty(q)) {
Linus Torvalds's avatar
Linus Torvalds committed
601
602
603
604
		struct skb_data		*entry;
		struct urb		*urb;
		int			retval;

605
606
607
608
609
610
611
612
		skb_queue_walk(q, skb) {
			entry = (struct skb_data *) skb->cb;
			if (entry->state != unlink_start)
				goto found;
		}
		break;
found:
		entry->state = unlink_start;
Linus Torvalds's avatar
Linus Torvalds committed
613
614
		urb = entry->urb;

615
616
617
618
619
620
621
622
		/*
		 * 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);
623
		spin_unlock_irqrestore(&q->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
624
625
626
627
		// during some PM-driven resume scenarios,
		// these (async) unlinks complete immediately
		retval = usb_unlink_urb (urb);
		if (retval != -EINPROGRESS && retval != 0)
628
			netdev_dbg(dev->net, "unlink urb err, %d\n", retval);
Linus Torvalds's avatar
Linus Torvalds committed
629
630
		else
			count++;
631
		usb_put_urb(urb);
632
		spin_lock_irqsave(&q->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
633
634
635
636
637
	}
	spin_unlock_irqrestore (&q->lock, flags);
	return count;
}

638
639
640
641
642
643
644
645
646
647
648
// 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);
Linus Torvalds's avatar
Linus Torvalds committed
649
650
651
652

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

// precondition: never called in_interrupt
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
static void usbnet_terminate_urbs(struct usbnet *dev)
{
	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
	DECLARE_WAITQUEUE(wait, current);
	int temp;

	/* ensure there are no more active urbs */
	add_wait_queue(&unlink_wakeup, &wait);
	set_current_state(TASK_UNINTERRUPTIBLE);
	dev->wait = &unlink_wakeup;
	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)) {
670
			schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
671
			set_current_state(TASK_UNINTERRUPTIBLE);
672
673
			netif_dbg(dev, ifdown, dev->net,
				  "waited for %d urb completions\n", temp);
674
675
676
677
678
	}
	set_current_state(TASK_RUNNING);
	dev->wait = NULL;
	remove_wait_queue(&unlink_wakeup, &wait);
}
Linus Torvalds's avatar
Linus Torvalds committed
679

680
int usbnet_stop (struct net_device *net)
Linus Torvalds's avatar
Linus Torvalds committed
681
682
{
	struct usbnet		*dev = netdev_priv(net);
683
684
	struct driver_info	*info = dev->driver_info;
	int			retval;
Linus Torvalds's avatar
Linus Torvalds committed
685

686
	clear_bit(EVENT_DEV_OPEN, &dev->flags);
Linus Torvalds's avatar
Linus Torvalds committed
687
688
	netif_stop_queue (net);

689
	netif_info(dev, ifdown, dev->net,
690
		   "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
691
692
		   net->stats.rx_packets, net->stats.tx_packets,
		   net->stats.rx_errors, net->stats.tx_errors);
Linus Torvalds's avatar
Linus Torvalds committed
693

694
695
696
697
	/* allow minidriver to stop correctly (wireless devices to turn off
	 * radio etc) */
	if (info->stop) {
		retval = info->stop(dev);
698
699
700
701
702
703
		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);
704
705
	}

706
707
	if (!(info->flags & FLAG_AVOID_UNLINK_URBS))
		usbnet_terminate_urbs(dev);
Linus Torvalds's avatar
Linus Torvalds committed
708
709
710

	usb_kill_urb(dev->interrupt);

Jussi Kivilinna's avatar
Jussi Kivilinna committed
711
712
	usbnet_purge_paused_rxq(dev);

Linus Torvalds's avatar
Linus Torvalds committed
713
714
715
716
717
718
719
	/* 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);
720
721
722
723
	if (info->manage_power)
		info->manage_power(dev, 0);
	else
		usb_autopm_put_interface(dev->intf);
Linus Torvalds's avatar
Linus Torvalds committed
724
725
726

	return 0;
}
727
EXPORT_SYMBOL_GPL(usbnet_stop);
Linus Torvalds's avatar
Linus Torvalds committed
728
729
730
731
732
733
734

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

// posts reads, and enables write queuing

// precondition: never called in_interrupt

735
int usbnet_open (struct net_device *net)
Linus Torvalds's avatar
Linus Torvalds committed
736
737
{
	struct usbnet		*dev = netdev_priv(net);
738
	int			retval;
Linus Torvalds's avatar
Linus Torvalds committed
739
740
	struct driver_info	*info = dev->driver_info;

741
	if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
742
743
744
745
746
747
		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);
748
749
750
		goto done_nopm;
	}

Linus Torvalds's avatar
Linus Torvalds committed
751
752
	// put into "known safe" state
	if (info->reset && (retval = info->reset (dev)) < 0) {
753
754
755
756
757
758
		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);
Linus Torvalds's avatar
Linus Torvalds committed
759
760
761
762
763
		goto done;
	}

	// insist peer be connected
	if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
764
		netif_dbg(dev, ifup, dev->net, "can't open; %d\n", retval);
Linus Torvalds's avatar
Linus Torvalds committed
765
766
767
768
769
770
771
		goto done;
	}

	/* start any status interrupt transfer */
	if (dev->interrupt) {
		retval = usb_submit_urb (dev->interrupt, GFP_KERNEL);
		if (retval < 0) {
772
773
			netif_err(dev, ifup, dev->net,
				  "intr submit %d\n", retval);
Linus Torvalds's avatar
Linus Torvalds committed
774
775
776
777
			goto done;
		}
	}

778
	set_bit(EVENT_DEV_OPEN, &dev->flags);
Linus Torvalds's avatar
Linus Torvalds committed
779
	netif_start_queue (net);
780
781
782
783
784
785
786
787
788
789
	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");
Linus Torvalds's avatar
Linus Torvalds committed
790
791
792

	// delay posting reads until we're fully open
	tasklet_schedule (&dev->bh);
793
794
795
	if (info->manage_power) {
		retval = info->manage_power(dev, 1);
		if (retval < 0)
796
			goto done_manage_power_error;
797
798
		usb_autopm_put_interface(dev->intf);
	}
799
	return retval;
800

801
802
done_manage_power_error:
	clear_bit(EVENT_DEV_OPEN, &dev->flags);
Linus Torvalds's avatar
Linus Torvalds committed
803
done:
804
805
	usb_autopm_put_interface(dev->intf);
done_nopm:
Linus Torvalds's avatar
Linus Torvalds committed
806
807
	return retval;
}
808
EXPORT_SYMBOL_GPL(usbnet_open);
Linus Torvalds's avatar
Linus Torvalds committed
809
810
811

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

812
813
814
815
/* ethtool methods; minidrivers may need to add some more, but
 * they'll probably want to use this base set.
 */

816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
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);

	return retval;

}
EXPORT_SYMBOL_GPL(usbnet_set_settings);

u32 usbnet_get_link (struct net_device *net)
Linus Torvalds's avatar
Linus Torvalds committed
847
848
849
{
	struct usbnet *dev = netdev_priv(net);

850
	/* If a check_connect is defined, return its result */
Linus Torvalds's avatar
Linus Torvalds committed
851
852
853
	if (dev->driver_info->check_connect)
		return dev->driver_info->check_connect (dev) == 0;

854
855
856
857
	/* if the device has mii operations, use those */
	if (dev->mii.mdio_read)
		return mii_link_ok(&dev->mii);

858
859
	/* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */
	return ethtool_op_get_link(net);
Linus Torvalds's avatar
Linus Torvalds committed
860
}
861
EXPORT_SYMBOL_GPL(usbnet_get_link);
Linus Torvalds's avatar
Linus Torvalds committed
862

863
int usbnet_nway_reset(struct net_device *net)
Linus Torvalds's avatar
Linus Torvalds committed
864
865
866
{
	struct usbnet *dev = netdev_priv(net);

867
868
869
870
	if (!dev->mii.mdio_write)
		return -EOPNOTSUPP;

	return mii_nway_restart(&dev->mii);
Linus Torvalds's avatar
Linus Torvalds committed
871
}
872
EXPORT_SYMBOL_GPL(usbnet_nway_reset);
Linus Torvalds's avatar
Linus Torvalds committed
873

874
void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
Linus Torvalds's avatar
Linus Torvalds committed
875
876
877
{
	struct usbnet *dev = netdev_priv(net);

878
879
880
	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,
881
882
		sizeof info->fw_version);
	usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
Linus Torvalds's avatar
Linus Torvalds committed
883
}
884
EXPORT_SYMBOL_GPL(usbnet_get_drvinfo);
Linus Torvalds's avatar
Linus Torvalds committed
885

886
u32 usbnet_get_msglevel (struct net_device *net)
887
888
889
{
	struct usbnet *dev = netdev_priv(net);

890
891
892
	return dev->msg_enable;
}
EXPORT_SYMBOL_GPL(usbnet_get_msglevel);
893

894
895
896
897
898
void usbnet_set_msglevel (struct net_device *net, u32 level)
{
	struct usbnet *dev = netdev_priv(net);

	dev->msg_enable = level;
899
}
900
EXPORT_SYMBOL_GPL(usbnet_set_msglevel);
901

902
/* drivers may override default ethtool_ops in their bind() routine */
903
static const struct ethtool_ops usbnet_ethtool_ops = {
904
905
	.get_settings		= usbnet_get_settings,
	.set_settings		= usbnet_set_settings,
906
	.get_link		= usbnet_get_link,
907
	.nway_reset		= usbnet_nway_reset,
908
	.get_drvinfo		= usbnet_get_drvinfo,
909
910
	.get_msglevel		= usbnet_get_msglevel,
	.set_msglevel		= usbnet_set_msglevel,
911
	.get_ts_info		= ethtool_op_get_ts_info,
912
};
Linus Torvalds's avatar
Linus Torvalds committed
913
914
915
916
917
918
919
920
921

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

/* 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
David Howells's avatar
David Howells committed
922
kevent (struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
923
{
David Howells's avatar
David Howells committed
924
925
	struct usbnet		*dev =
		container_of(work, struct usbnet, kevent);
Linus Torvalds's avatar
Linus Torvalds committed
926
927
928
929
930
	int			status;

	/* usb_clear_halt() needs a thread context */
	if (test_bit (EVENT_TX_HALT, &dev->flags)) {
		unlink_urbs (dev, &dev->txq);
931
932
933
		status = usb_autopm_get_interface(dev->intf);
		if (status < 0)
			goto fail_pipe;
Linus Torvalds's avatar
Linus Torvalds committed
934
		status = usb_clear_halt (dev->udev, dev->out);
935
		usb_autopm_put_interface(dev->intf);
936
937
938
		if (status < 0 &&
		    status != -EPIPE &&
		    status != -ESHUTDOWN) {
Linus Torvalds's avatar
Linus Torvalds committed
939
			if (netif_msg_tx_err (dev))
940
fail_pipe:
941
942
				netdev_err(dev->net, "can't clear tx halt, status %d\n",
					   status);
Linus Torvalds's avatar
Linus Torvalds committed
943
944
		} else {
			clear_bit (EVENT_TX_HALT, &dev->flags);
945
946
			if (status != -ESHUTDOWN)
				netif_wake_queue (dev->net);
Linus Torvalds's avatar
Linus Torvalds committed
947
948
949
950
		}
	}
	if (test_bit (EVENT_RX_HALT, &dev->flags)) {
		unlink_urbs (dev, &dev->rxq);
951
952
953
		status = usb_autopm_get_interface(dev->intf);
		if (status < 0)
			goto fail_halt;
Linus Torvalds's avatar
Linus Torvalds committed
954
		status = usb_clear_halt (dev->udev, dev->in);
955
		usb_autopm_put_interface(dev->intf);
956
957
958
		if (status < 0 &&
		    status != -EPIPE &&
		    status != -ESHUTDOWN) {
Linus Torvalds's avatar
Linus Torvalds committed
959
			if (netif_msg_rx_err (dev))
960
fail_halt:
961
962
				netdev_err(dev->net, "can't clear rx halt, status %d\n",
					   status);
Linus Torvalds's avatar
Linus Torvalds committed
963
964
965
966
967
968
969
970
971
		} 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;
972
		int resched = 1;
Linus Torvalds's avatar
Linus Torvalds committed
973
974
975
976
977
978
979

		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);
980
			status = usb_autopm_get_interface(dev->intf);
981
982
			if (status < 0) {
				usb_free_urb(urb);
983
				goto fail_lowmem;
984
			}
985
986
			if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
				resched = 0;
987
988
			usb_autopm_put_interface(dev->intf);
fail_lowmem:
989
990
			if (resched)
				tasklet_schedule (&dev->bh);
Linus Torvalds's avatar
Linus Torvalds committed
991
992
993
		}
	}

994
	if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
995
		struct driver_info	*info = dev->driver_info;
996
997
998
		int			retval = 0;

		clear_bit (EVENT_LINK_RESET, &dev->flags);
999
1000
1001
		status = usb_autopm_get_interface(dev->intf);
		if (status < 0)
			goto skip_reset;
1002
		if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
1003
1004
			usb_autopm_put_interface(dev->intf);
skip_reset:
1005
1006
1007
1008
1009
			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);
1010
1011
		} else {
			usb_autopm_put_interface(dev->intf);
1012
1013
1014
		}
	}

Linus Torvalds's avatar
Linus Torvalds committed
1015
	if (dev->flags)
1016
		netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags);
Linus Torvalds's avatar
Linus Torvalds committed
1017
1018
1019
1020
}

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

1021
static void tx_complete (struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
1022
1023
1024
1025
1026
1027
{
	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) {
1028
1029
		if (!(dev->driver_info->flags & FLAG_MULTI_PACKET))
			dev->net->stats.tx_packets++;
1030
		dev->net->stats.tx_bytes += entry->length;
Linus Torvalds's avatar
Linus Torvalds committed
1031
	} else {
1032
		dev->net->stats.tx_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
1033
1034
1035

		switch (urb->status) {
		case -EPIPE:
1036
			usbnet_defer_kevent (dev, EVENT_TX_HALT);
Linus Torvalds's avatar
Linus Torvalds committed
1037
1038
1039
1040
1041
1042
1043
1044
1045
			break;

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

		// like rx, tx gets controller i/o faults during khubd delays
		// and so it uses the same throttling mechanism.
1046
1047
1048
		case -EPROTO:
		case -ETIME:
		case -EILSEQ:
1049
			usb_mark_last_busy(dev->udev);
Linus Torvalds's avatar
Linus Torvalds committed
1050
1051
1052
			if (!timer_pending (&dev->delay)) {
				mod_timer (&dev->delay,
					jiffies + THROTTLE_JIFFIES);
1053
1054
				netif_dbg(dev, link, dev->net,
					  "tx throttle %d\n", urb->status);
Linus Torvalds's avatar
Linus Torvalds committed
1055
1056
1057
1058
			}
			netif_stop_queue (dev->net);
			break;
		default:
1059
1060
			netif_dbg(dev, tx_err, dev->net,
				  "tx err %d\n", entry->urb->status);
Linus Torvalds's avatar
Linus Torvalds committed
1061
1062
1063
1064
			break;
		}
	}

1065
	usb_autopm_put_interface_async(dev->intf);
1066
	(void) defer_bh(dev, skb, &dev->txq, tx_done);
Linus Torvalds's avatar
Linus Torvalds committed
1067
1068
1069
1070
}

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

1071
void usbnet_tx_timeout (struct net_device *net)
Linus Torvalds's avatar
Linus Torvalds committed
1072
1073
1074
1075
1076
1077
1078
1079
{
	struct usbnet		*dev = netdev_priv(net);

	unlink_urbs (dev, &dev->txq);
	tasklet_schedule (&dev->bh);

	// FIXME: device recovery -- reset?
}
1080
EXPORT_SYMBOL_GPL(usbnet_tx_timeout);
Linus Torvalds's avatar
Linus Torvalds committed
1081
1082
1083

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

1084
1085
netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
				     struct net_device *net)
Linus Torvalds's avatar
Linus Torvalds committed
1086
1087
1088
1089
1090
1091
1092
{
	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;
1093
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
1094

1095
1096
	if (skb)
		skb_tx_timestamp(skb);
1097

Linus Torvalds's avatar
Linus Torvalds committed
1098
1099
1100
1101
1102
	// 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) {
1103
1104
1105
1106
1107
1108
1109
			if (netif_msg_tx_err(dev)) {
				netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb\n");
				goto drop;
			} else {
				/* cdc_ncm collected packet; waits for more */
				goto not_drop;
			}
Linus Torvalds's avatar
Linus Torvalds committed
1110
1111
1112
1113
1114
		}
	}
	length = skb->len;

	if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {
1115
		netif_dbg(dev, tx_err, dev->net, "no urb\n");
Linus Torvalds's avatar
Linus Torvalds committed
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
		goto drop;
	}

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

	usb_fill_bulk_urb (urb, dev->udev, dev->out,
			skb->data, skb->len, tx_complete, skb);

	/* 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.
1130
1131
1132
	 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
1133
	 */
1134
1135
	if (length % dev->maxpacket == 0) {
		if (!(info->flags & FLAG_SEND_ZLP)) {
1136
1137
1138
1139
1140
1141
			if (!(info->flags & FLAG_MULTI_PACKET)) {
				urb->transfer_buffer_length++;
				if (skb_tailroom(skb)) {
					skb->data[skb->len] = 0;
					__skb_put(skb, 1);
				}
1142
1143
1144
			}
		} else
			urb->transfer_flags |= URB_ZERO_PACKET;
1145
	}
Linus Torvalds's avatar
Linus Torvalds committed
1146

1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
	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);
1161
		usb_put_urb(urb);
1162
		spin_unlock_irqrestore(&dev->txq.lock, flags);
1163
		netdev_dbg(dev->net, "Delaying transmission for resumption\n");
1164
1165
1166
		goto deferred;
	}
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1167
1168
1169
1170

	switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {
	case -EPIPE:
		netif_stop_queue (net);
1171
		usbnet_defer_kevent (dev, EVENT_TX_HALT);
1172
		usb_autopm_put_interface_async(dev->intf);
Linus Torvalds's avatar
Linus Torvalds committed
1173
1174
		break;
	default:
1175
		usb_autopm_put_interface_async(dev->intf);
1176
1177
		netif_dbg(dev, tx_err, dev->net,
			  "tx: submit urb err %d\n", retval);
Linus Torvalds's avatar
Linus Torvalds committed
1178
1179
1180
		break;
	case 0:
		net->trans_start = jiffies;
1181
		__usbnet_queue_skb(&dev->txq, skb, tx_start);
Linus Torvalds's avatar
Linus Torvalds committed
1182
1183
1184
1185
1186
1187
		if (dev->txq.qlen >= TX_QLEN (dev))
			netif_stop_queue (net);
	}
	spin_unlock_irqrestore (&dev->txq.lock, flags);

	if (retval) {
1188
		netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval);
Linus Torvalds's avatar
Linus Torvalds committed
1189
drop:
1190
		dev->net->stats.tx_dropped++;
1191
not_drop:
Linus Torvalds's avatar
Linus Torvalds committed
1192
1193
1194
		if (skb)
			dev_kfree_skb_any (skb);
		usb_free_urb (urb);
1195
1196
1197
	} else
		netif_dbg(dev, tx_queued, dev->net,
			  "> tx, len %d, type 0x%x\n", length, skb->protocol);
1198
1199
1200
#ifdef CONFIG_PM
deferred:
#endif
1201
	return NETDEV_TX_OK;
Linus Torvalds's avatar
Linus Torvalds committed
1202
}
Stephen Hemminger's avatar