usbnet.c 36.6 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 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.
L
Linus Torvalds 已提交
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.
 */
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
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 47

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


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

/*
 * 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).
58 59 60 61
 *
 * 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.
L
Linus Torvalds 已提交
62
 */
63 64 65 66 67
#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)
L
Linus Torvalds 已提交
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// 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 */
94
int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
L
Linus Torvalds 已提交
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
{
	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;
		 * ignore other endpoints and altsetttings.
		 */
		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:
118
				if (!usb_endpoint_dir_in(&e->desc))
L
Linus Torvalds 已提交
119 120 121 122 123 124 125 126
					continue;
				intr = 1;
				/* FALLTHROUGH */
			case USB_ENDPOINT_XFER_BULK:
				break;
			default:
				continue;
			}
127
			if (usb_endpoint_dir_in(&e->desc)) {
L
Linus Torvalds 已提交
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
				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;

	if (alt->desc.bAlternateSetting != 0
			|| !(dev->driver_info->flags & FLAG_NO_SETINT)) {
		tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber,
				alt->desc.bAlternateSetting);
		if (tmp < 0)
			return tmp;
	}
150

L
Linus Torvalds 已提交
151 152 153 154 155 156 157
	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;
}
158
EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
L
Linus Torvalds 已提交
159

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
static u8 nibble(unsigned char c)
{
	if (likely(isdigit(c)))
		return c - '0';
	c = toupper(c);
	if (likely(isxdigit(c)))
		return 10 + c - 'A';
	return 0;
}

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] =
			(nibble(buf [tmp]) << 4) + nibble(buf [tmp + 1]);
	return 0;
}
EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);

190
static void intr_complete (struct urb *urb);
L
Linus Torvalds 已提交
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210

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

211
	buf = kmalloc (maxp, GFP_KERNEL);
L
Linus Torvalds 已提交
212
	if (buf) {
213
		dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);
L
Linus Torvalds 已提交
214 215 216 217 218 219 220 221 222 223 224
		if (!dev->interrupt) {
			kfree (buf);
			return -ENOMEM;
		} else {
			usb_fill_int_urb(dev->interrupt, dev->udev, pipe,
				buf, maxp, intr_complete, dev, period);
			dev_dbg(&intf->dev,
				"status ep%din, %d bytes period %d\n",
				usb_pipeendpoint(pipe), maxp, period);
		}
	}
D
David Brownell 已提交
225
	return 0;
L
Linus Torvalds 已提交
226 227
}

228 229 230 231 232
/* 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 已提交
233 234 235
{
	int	status;

J
Jussi Kivilinna 已提交
236 237 238 239 240
	if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
		skb_queue_tail(&dev->rxq_pause, skb);
		return;
	}

L
Linus Torvalds 已提交
241
	skb->protocol = eth_type_trans (skb, dev->net);
H
Herbert Xu 已提交
242 243
	dev->net->stats.rx_packets++;
	dev->net->stats.rx_bytes += skb->len;
L
Linus Torvalds 已提交
244 245

	if (netif_msg_rx_status (dev))
246
		devdbg (dev, "< rx, len %zu, type 0x%x",
L
Linus Torvalds 已提交
247 248 249 250 251 252
			skb->len + sizeof (struct ethhdr), skb->protocol);
	memset (skb->cb, 0, sizeof (struct skb_data));
	status = netif_rx (skb);
	if (status != NET_RX_SUCCESS && netif_msg_rx_err (dev))
		devdbg (dev, "netif_rx status %d", status);
}
253
EXPORT_SYMBOL_GPL(usbnet_skb_return);
L
Linus Torvalds 已提交
254 255 256 257 258 259 260 261

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

262
int usbnet_change_mtu (struct net_device *net, int new_mtu)
L
Linus Torvalds 已提交
263 264
{
	struct usbnet	*dev = netdev_priv(net);
265
	int		ll_mtu = new_mtu + net->hard_header_len;
266 267
	int		old_hard_mtu = dev->hard_mtu;
	int		old_rx_urb_size = dev->rx_urb_size;
L
Linus Torvalds 已提交
268

269
	if (new_mtu <= 0)
L
Linus Torvalds 已提交
270 271
		return -EINVAL;
	// no second zero-length packet read wanted after mtu-sized packets
272
	if ((ll_mtu % dev->maxpacket) == 0)
L
Linus Torvalds 已提交
273 274
		return -EDOM;
	net->mtu = new_mtu;
275 276 277 278 279 280 281 282

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

L
Linus Torvalds 已提交
283 284
	return 0;
}
285
EXPORT_SYMBOL_GPL(usbnet_change_mtu);
L
Linus Torvalds 已提交
286 287 288 289 290 291 292

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

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

D
David S. Miller 已提交
293
static void defer_bh(struct usbnet *dev, struct sk_buff *skb, struct sk_buff_head *list)
L
Linus Torvalds 已提交
294 295 296
{
	unsigned long		flags;

D
David S. Miller 已提交
297 298 299 300 301
	spin_lock_irqsave(&list->lock, flags);
	__skb_unlink(skb, list);
	spin_unlock(&list->lock);
	spin_lock(&dev->done.lock);
	__skb_queue_tail(&dev->done, skb);
L
Linus Torvalds 已提交
302
	if (dev->done.qlen == 1)
D
David S. Miller 已提交
303 304
		tasklet_schedule(&dev->bh);
	spin_unlock_irqrestore(&dev->done.lock, flags);
L
Linus Torvalds 已提交
305 306 307 308 309 310 311
}

/* 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.
 */
312
void usbnet_defer_kevent (struct usbnet *dev, int work)
L
Linus Torvalds 已提交
313 314 315 316 317 318 319
{
	set_bit (work, &dev->flags);
	if (!schedule_work (&dev->kevent))
		deverr (dev, "kevent %d may have been dropped", work);
	else
		devdbg (dev, "kevent %d scheduled", work);
}
320
EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
L
Linus Torvalds 已提交
321 322 323

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

324
static void rx_complete (struct urb *urb);
L
Linus Torvalds 已提交
325

A
Al Viro 已提交
326
static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
L
Linus Torvalds 已提交
327 328 329 330 331
{
	struct sk_buff		*skb;
	struct skb_data		*entry;
	int			retval = 0;
	unsigned long		lockflags;
332
	size_t			size = dev->rx_urb_size;
L
Linus Torvalds 已提交
333 334 335 336

	if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {
		if (netif_msg_rx_err (dev))
			devdbg (dev, "no rx skb");
337
		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
L
Linus Torvalds 已提交
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
		usb_free_urb (urb);
		return;
	}
	skb_reserve (skb, NET_IP_ALIGN);

	entry = (struct skb_data *) skb->cb;
	entry->urb = urb;
	entry->dev = dev;
	entry->state = rx_start;
	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);

	if (netif_running (dev->net)
			&& netif_device_present (dev->net)
			&& !test_bit (EVENT_RX_HALT, &dev->flags)) {
D
David Brownell 已提交
357
		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {
L
Linus Torvalds 已提交
358
		case -EPIPE:
359
			usbnet_defer_kevent (dev, EVENT_RX_HALT);
L
Linus Torvalds 已提交
360 361
			break;
		case -ENOMEM:
362
			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
L
Linus Torvalds 已提交
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
			break;
		case -ENODEV:
			if (netif_msg_ifdown (dev))
				devdbg (dev, "device gone");
			netif_device_detach (dev->net);
			break;
		default:
			if (netif_msg_rx_err (dev))
				devdbg (dev, "rx submit, %d", retval);
			tasklet_schedule (&dev->bh);
			break;
		case 0:
			__skb_queue_tail (&dev->rxq, skb);
		}
	} else {
		if (netif_msg_ifdown (dev))
			devdbg (dev, "rx: stopped");
		retval = -ENOLINK;
	}
	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
	if (retval) {
		dev_kfree_skb_any (skb);
		usb_free_urb (urb);
	}
}


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

static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
{
	if (dev->driver_info->rx_fixup
			&& !dev->driver_info->rx_fixup (dev, skb))
		goto error;
	// else network stack removes extra byte if we forced a short packet

	if (skb->len)
400
		usbnet_skb_return (dev, skb);
L
Linus Torvalds 已提交
401 402 403 404
	else {
		if (netif_msg_rx_err (dev))
			devdbg (dev, "drop");
error:
H
Herbert Xu 已提交
405
		dev->net->stats.rx_errors++;
L
Linus Torvalds 已提交
406 407 408 409 410 411
		skb_queue_tail (&dev->done, skb);
	}
}

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

412
static void rx_complete (struct urb *urb)
L
Linus Torvalds 已提交
413 414 415 416 417 418 419 420 421 422 423
{
	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;

	skb_put (skb, urb->actual_length);
	entry->state = rx_done;
	entry->urb = NULL;

	switch (urb_status) {
D
David Brownell 已提交
424 425
	/* success */
	case 0:
426
		if (skb->len < dev->net->hard_header_len) {
L
Linus Torvalds 已提交
427
			entry->state = rx_cleanup;
H
Herbert Xu 已提交
428 429
			dev->net->stats.rx_errors++;
			dev->net->stats.rx_length_errors++;
L
Linus Torvalds 已提交
430 431 432 433 434
			if (netif_msg_rx_err (dev))
				devdbg (dev, "rx length %d", skb->len);
		}
		break;

D
David Brownell 已提交
435 436
	/* stalls need manual reset. this is rare ... except that
	 * when going through USB 2.0 TTs, unplug appears this way.
437
	 * we avoid the highspeed version of the ETIMEDOUT/EILSEQ
D
David Brownell 已提交
438 439 440
	 * storm, recovering as needed.
	 */
	case -EPIPE:
H
Herbert Xu 已提交
441
		dev->net->stats.rx_errors++;
442
		usbnet_defer_kevent (dev, EVENT_RX_HALT);
L
Linus Torvalds 已提交
443 444
		// FALLTHROUGH

D
David Brownell 已提交
445 446 447
	/* software-driven interface shutdown */
	case -ECONNRESET:		/* async unlink */
	case -ESHUTDOWN:		/* hardware gone */
L
Linus Torvalds 已提交
448 449 450 451
		if (netif_msg_ifdown (dev))
			devdbg (dev, "rx shutdown, code %d", urb_status);
		goto block;

D
David Brownell 已提交
452 453 454 455 456 457 458
	/* 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:
H
Herbert Xu 已提交
459
		dev->net->stats.rx_errors++;
L
Linus Torvalds 已提交
460 461 462 463 464 465 466 467 468 469 470
		if (!timer_pending (&dev->delay)) {
			mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
			if (netif_msg_link (dev))
				devdbg (dev, "rx throttle %d", urb_status);
		}
block:
		entry->state = rx_cleanup;
		entry->urb = urb;
		urb = NULL;
		break;

D
David Brownell 已提交
471 472
	/* data overrun ... flush fifo? */
	case -EOVERFLOW:
H
Herbert Xu 已提交
473
		dev->net->stats.rx_over_errors++;
L
Linus Torvalds 已提交
474
		// FALLTHROUGH
475

D
David Brownell 已提交
476
	default:
L
Linus Torvalds 已提交
477
		entry->state = rx_cleanup;
H
Herbert Xu 已提交
478
		dev->net->stats.rx_errors++;
L
Linus Torvalds 已提交
479 480 481 482 483
		if (netif_msg_rx_err (dev))
			devdbg (dev, "rx status %d", urb_status);
		break;
	}

D
David S. Miller 已提交
484
	defer_bh(dev, skb, &dev->rxq);
L
Linus Torvalds 已提交
485 486 487 488 489 490 491 492 493 494 495 496 497

	if (urb) {
		if (netif_running (dev->net)
				&& !test_bit (EVENT_RX_HALT, &dev->flags)) {
			rx_submit (dev, urb, GFP_ATOMIC);
			return;
		}
		usb_free_urb (urb);
	}
	if (netif_msg_rx_err (dev))
		devdbg (dev, "no read resubmitted");
}

498
static void intr_complete (struct urb *urb)
L
Linus Torvalds 已提交
499 500 501 502 503
{
	struct usbnet	*dev = urb->context;
	int		status = urb->status;

	switch (status) {
D
David Brownell 已提交
504 505
	/* success */
	case 0:
L
Linus Torvalds 已提交
506 507 508
		dev->driver_info->status(dev, urb);
		break;

D
David Brownell 已提交
509 510 511
	/* software-driven interface shutdown */
	case -ENOENT:		/* urb killed */
	case -ESHUTDOWN:	/* hardware gone */
L
Linus Torvalds 已提交
512 513 514 515
		if (netif_msg_ifdown (dev))
			devdbg (dev, "intr shutdown, code %d", status);
		return;

D
David Brownell 已提交
516 517 518 519
	/* NOTE:  not throttling like RX/TX, since this endpoint
	 * already polls infrequently
	 */
	default:
L
Linus Torvalds 已提交
520 521 522 523 524 525 526 527 528 529 530 531 532
		devdbg (dev, "intr status %d", status);
		break;
	}

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

	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
	status = usb_submit_urb (urb, GFP_ATOMIC);
	if (status != 0 && netif_msg_timer (dev))
		deverr(dev, "intr resubmit --> %d", status);
}

J
Jussi Kivilinna 已提交
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
/*-------------------------------------------------------------------------*/
void usbnet_pause_rx(struct usbnet *dev)
{
	set_bit(EVENT_RX_PAUSED, &dev->flags);

	if (netif_msg_rx_status(dev))
		devdbg(dev, "paused rx queue enabled");
}
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);

	if (netif_msg_rx_status(dev))
		devdbg(dev, "paused rx queue disabled, %d skbs requeued", num);
}
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 已提交
568 569 570 571 572 573 574 575 576 577 578
/*-------------------------------------------------------------------------*/

// 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;
	struct sk_buff		*skb, *skbnext;
	int			count = 0;

	spin_lock_irqsave (&q->lock, flags);
579
	skb_queue_walk_safe(q, skb, skbnext) {
L
Linus Torvalds 已提交
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
		struct skb_data		*entry;
		struct urb		*urb;
		int			retval;

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

		// during some PM-driven resume scenarios,
		// these (async) unlinks complete immediately
		retval = usb_unlink_urb (urb);
		if (retval != -EINPROGRESS && retval != 0)
			devdbg (dev, "unlink urb err, %d", retval);
		else
			count++;
	}
	spin_unlock_irqrestore (&q->lock, flags);
	return count;
}

599 600 601 602 603 604 605 606 607 608 609
// 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 已提交
610 611 612 613 614

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

// precondition: never called in_interrupt

615
int usbnet_stop (struct net_device *net)
L
Linus Torvalds 已提交
616 617
{
	struct usbnet		*dev = netdev_priv(net);
618
	struct driver_info	*info = dev->driver_info;
L
Linus Torvalds 已提交
619
	int			temp;
620
	int			retval;
621
	DECLARE_WAIT_QUEUE_HEAD_ONSTACK (unlink_wakeup);
L
Linus Torvalds 已提交
622 623 624 625 626 627
	DECLARE_WAITQUEUE (wait, current);

	netif_stop_queue (net);

	if (netif_msg_ifdown (dev))
		devinfo (dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld",
H
Herbert Xu 已提交
628 629
			net->stats.rx_packets, net->stats.tx_packets,
			net->stats.rx_errors, net->stats.tx_errors
L
Linus Torvalds 已提交
630 631
			);

632 633 634 635 636 637 638 639 640 641 642 643
	/* allow minidriver to stop correctly (wireless devices to turn off
	 * radio etc) */
	if (info->stop) {
		retval = info->stop(dev);
		if (retval < 0 && netif_msg_ifdown(dev))
			devinfo(dev,
				"stop fail (%d) usbnet usb-%s-%s, %s",
				retval,
				dev->udev->bus->bus_name, dev->udev->devpath,
				info->description);
	}

644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
	if (!(info->flags & FLAG_AVOID_UNLINK_URBS)) {
		/* ensure there are no more active urbs */
		add_wait_queue(&unlink_wakeup, &wait);
		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)) {
			msleep(UNLINK_TIMEOUT_MS);
			if (netif_msg_ifdown(dev))
				devdbg(dev, "waited for %d urb completions",
					temp);
		}
		dev->wait = NULL;
		remove_wait_queue(&unlink_wakeup, &wait);
L
Linus Torvalds 已提交
662 663 664 665
	}

	usb_kill_urb(dev->interrupt);

J
Jussi Kivilinna 已提交
666 667
	usbnet_purge_paused_rxq(dev);

L
Linus Torvalds 已提交
668 669 670 671 672 673 674
	/* 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);
675
	usb_autopm_put_interface(dev->intf);
L
Linus Torvalds 已提交
676 677 678

	return 0;
}
679
EXPORT_SYMBOL_GPL(usbnet_stop);
L
Linus Torvalds 已提交
680 681 682 683 684 685 686

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

// posts reads, and enables write queuing

// precondition: never called in_interrupt

687
int usbnet_open (struct net_device *net)
L
Linus Torvalds 已提交
688 689
{
	struct usbnet		*dev = netdev_priv(net);
690
	int			retval;
L
Linus Torvalds 已提交
691 692
	struct driver_info	*info = dev->driver_info;

693 694 695 696 697 698 699 700 701 702
	if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
		if (netif_msg_ifup (dev))
			devinfo (dev,
				"resumption fail (%d) usbnet usb-%s-%s, %s",
				retval,
				dev->udev->bus->bus_name, dev->udev->devpath,
			info->description);
		goto done_nopm;
	}

L
Linus Torvalds 已提交
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749
	// put into "known safe" state
	if (info->reset && (retval = info->reset (dev)) < 0) {
		if (netif_msg_ifup (dev))
			devinfo (dev,
				"open reset fail (%d) usbnet usb-%s-%s, %s",
				retval,
				dev->udev->bus->bus_name, dev->udev->devpath,
			info->description);
		goto done;
	}

	// insist peer be connected
	if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
		if (netif_msg_ifup (dev))
			devdbg (dev, "can't open; %d", retval);
		goto done;
	}

	/* start any status interrupt transfer */
	if (dev->interrupt) {
		retval = usb_submit_urb (dev->interrupt, GFP_KERNEL);
		if (retval < 0) {
			if (netif_msg_ifup (dev))
				deverr (dev, "intr submit %d", retval);
			goto done;
		}
	}

	netif_start_queue (net);
	if (netif_msg_ifup (dev)) {
		char	*framing;

		if (dev->driver_info->flags & FLAG_FRAMING_NC)
			framing = "NetChip";
		else if (dev->driver_info->flags & FLAG_FRAMING_GL)
			framing = "GeneSys";
		else if (dev->driver_info->flags & FLAG_FRAMING_Z)
			framing = "Zaurus";
		else if (dev->driver_info->flags & FLAG_FRAMING_RN)
			framing = "RNDIS";
		else if (dev->driver_info->flags & FLAG_FRAMING_AX)
			framing = "ASIX";
		else
			framing = "simple";

		devinfo (dev, "open: enable queueing "
				"(rx %d, tx %d) mtu %d %s framing",
R
Randy Dunlap 已提交
750
			(int)RX_QLEN (dev), (int)TX_QLEN (dev), dev->net->mtu,
L
Linus Torvalds 已提交
751 752 753 754 755
			framing);
	}

	// delay posting reads until we're fully open
	tasklet_schedule (&dev->bh);
756
	return retval;
L
Linus Torvalds 已提交
757
done:
758 759
	usb_autopm_put_interface(dev->intf);
done_nopm:
L
Linus Torvalds 已提交
760 761
	return retval;
}
762
EXPORT_SYMBOL_GPL(usbnet_open);
L
Linus Torvalds 已提交
763 764 765

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

766 767 768 769
/* ethtool methods; minidrivers may need to add some more, but
 * they'll probably want to use this base set.
 */

770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
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)
L
Linus Torvalds 已提交
801 802 803
{
	struct usbnet *dev = netdev_priv(net);

804
	/* If a check_connect is defined, return its result */
L
Linus Torvalds 已提交
805 806 807
	if (dev->driver_info->check_connect)
		return dev->driver_info->check_connect (dev) == 0;

808 809 810 811
	/* if the device has mii operations, use those */
	if (dev->mii.mdio_read)
		return mii_link_ok(&dev->mii);

812 813
	/* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */
	return ethtool_op_get_link(net);
L
Linus Torvalds 已提交
814
}
815
EXPORT_SYMBOL_GPL(usbnet_get_link);
L
Linus Torvalds 已提交
816

817
int usbnet_nway_reset(struct net_device *net)
L
Linus Torvalds 已提交
818 819 820
{
	struct usbnet *dev = netdev_priv(net);

821 822 823 824
	if (!dev->mii.mdio_write)
		return -EOPNOTSUPP;

	return mii_nway_restart(&dev->mii);
L
Linus Torvalds 已提交
825
}
826
EXPORT_SYMBOL_GPL(usbnet_nway_reset);
L
Linus Torvalds 已提交
827

828
void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
L
Linus Torvalds 已提交
829 830 831
{
	struct usbnet *dev = netdev_priv(net);

832
	strncpy (info->driver, dev->driver_name, sizeof info->driver);
833 834 835 836
	strncpy (info->version, DRIVER_VERSION, sizeof info->version);
	strncpy (info->fw_version, dev->driver_info->description,
		sizeof info->fw_version);
	usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
L
Linus Torvalds 已提交
837
}
838
EXPORT_SYMBOL_GPL(usbnet_get_drvinfo);
L
Linus Torvalds 已提交
839

840
u32 usbnet_get_msglevel (struct net_device *net)
841 842 843
{
	struct usbnet *dev = netdev_priv(net);

844 845 846
	return dev->msg_enable;
}
EXPORT_SYMBOL_GPL(usbnet_get_msglevel);
847

848 849 850 851 852
void usbnet_set_msglevel (struct net_device *net, u32 level)
{
	struct usbnet *dev = netdev_priv(net);

	dev->msg_enable = level;
853
}
854
EXPORT_SYMBOL_GPL(usbnet_set_msglevel);
855

856
/* drivers may override default ethtool_ops in their bind() routine */
857
static const struct ethtool_ops usbnet_ethtool_ops = {
858 859
	.get_settings		= usbnet_get_settings,
	.set_settings		= usbnet_set_settings,
860
	.get_link		= usbnet_get_link,
861
	.nway_reset		= usbnet_nway_reset,
862
	.get_drvinfo		= usbnet_get_drvinfo,
863 864 865
	.get_msglevel		= usbnet_get_msglevel,
	.set_msglevel		= usbnet_set_msglevel,
};
L
Linus Torvalds 已提交
866 867 868 869 870 871 872 873 874

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

/* 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 已提交
875
kevent (struct work_struct *work)
L
Linus Torvalds 已提交
876
{
D
David Howells 已提交
877 878
	struct usbnet		*dev =
		container_of(work, struct usbnet, kevent);
L
Linus Torvalds 已提交
879 880 881 882 883 884
	int			status;

	/* usb_clear_halt() needs a thread context */
	if (test_bit (EVENT_TX_HALT, &dev->flags)) {
		unlink_urbs (dev, &dev->txq);
		status = usb_clear_halt (dev->udev, dev->out);
885 886 887
		if (status < 0
				&& status != -EPIPE
				&& status != -ESHUTDOWN) {
L
Linus Torvalds 已提交
888 889 890 891 892
			if (netif_msg_tx_err (dev))
				deverr (dev, "can't clear tx halt, status %d",
					status);
		} else {
			clear_bit (EVENT_TX_HALT, &dev->flags);
893 894
			if (status != -ESHUTDOWN)
				netif_wake_queue (dev->net);
L
Linus Torvalds 已提交
895 896 897 898 899
		}
	}
	if (test_bit (EVENT_RX_HALT, &dev->flags)) {
		unlink_urbs (dev, &dev->rxq);
		status = usb_clear_halt (dev->udev, dev->in);
900 901 902
		if (status < 0
				&& status != -EPIPE
				&& status != -ESHUTDOWN) {
L
Linus Torvalds 已提交
903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
			if (netif_msg_rx_err (dev))
				deverr (dev, "can't clear rx halt, status %d",
					status);
		} 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;

		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);
			rx_submit (dev, urb, GFP_KERNEL);
			tasklet_schedule (&dev->bh);
		}
	}

927
	if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
928
		struct driver_info	*info = dev->driver_info;
929 930 931 932 933 934 935 936 937 938 939
		int			retval = 0;

		clear_bit (EVENT_LINK_RESET, &dev->flags);
		if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
			devinfo(dev, "link reset failed (%d) usbnet usb-%s-%s, %s",
				retval,
				dev->udev->bus->bus_name, dev->udev->devpath,
				info->description);
		}
	}

L
Linus Torvalds 已提交
940 941 942 943 944 945 946
	if (dev->flags)
		devdbg (dev, "kevent done, flags = 0x%lx",
			dev->flags);
}

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

947
static void tx_complete (struct urb *urb)
L
Linus Torvalds 已提交
948 949 950 951 952 953
{
	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) {
H
Herbert Xu 已提交
954 955
		dev->net->stats.tx_packets++;
		dev->net->stats.tx_bytes += entry->length;
L
Linus Torvalds 已提交
956
	} else {
H
Herbert Xu 已提交
957
		dev->net->stats.tx_errors++;
L
Linus Torvalds 已提交
958 959 960

		switch (urb->status) {
		case -EPIPE:
961
			usbnet_defer_kevent (dev, EVENT_TX_HALT);
L
Linus Torvalds 已提交
962 963 964 965 966 967 968 969 970
			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.
971 972 973
		case -EPROTO:
		case -ETIME:
		case -EILSEQ:
L
Linus Torvalds 已提交
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
			if (!timer_pending (&dev->delay)) {
				mod_timer (&dev->delay,
					jiffies + THROTTLE_JIFFIES);
				if (netif_msg_link (dev))
					devdbg (dev, "tx throttle %d",
							urb->status);
			}
			netif_stop_queue (dev->net);
			break;
		default:
			if (netif_msg_tx_err (dev))
				devdbg (dev, "tx err %d", entry->urb->status);
			break;
		}
	}

	urb->dev = NULL;
	entry->state = tx_done;
D
David S. Miller 已提交
992
	defer_bh(dev, skb, &dev->txq);
L
Linus Torvalds 已提交
993 994 995 996
}

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

997
void usbnet_tx_timeout (struct net_device *net)
L
Linus Torvalds 已提交
998 999 1000 1001 1002 1003 1004 1005
{
	struct usbnet		*dev = netdev_priv(net);

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

	// FIXME: device recovery -- reset?
}
1006
EXPORT_SYMBOL_GPL(usbnet_tx_timeout);
L
Linus Torvalds 已提交
1007 1008 1009

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

1010 1011
netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
				     struct net_device *net)
L
Linus Torvalds 已提交
1012 1013 1014 1015 1016 1017 1018
{
	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;
1019
	int retval;
L
Linus Torvalds 已提交
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051

	// 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) {
			if (netif_msg_tx_err (dev))
				devdbg (dev, "can't tx_fixup skb");
			goto drop;
		}
	}
	length = skb->len;

	if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {
		if (netif_msg_tx_err (dev))
			devdbg (dev, "no urb");
		goto drop;
	}

	entry = (struct skb_data *) skb->cb;
	entry->urb = urb;
	entry->dev = dev;
	entry->state = tx_start;
	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.
	 */
1052
	if ((length % dev->maxpacket) == 0) {
L
Linus Torvalds 已提交
1053
		urb->transfer_buffer_length++;
1054 1055 1056 1057 1058
		if (skb_tailroom(skb)) {
			skb->data[skb->len] = 0;
			__skb_put(skb, 1);
		}
	}
L
Linus Torvalds 已提交
1059 1060 1061 1062 1063 1064

	spin_lock_irqsave (&dev->txq.lock, flags);

	switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {
	case -EPIPE:
		netif_stop_queue (net);
1065
		usbnet_defer_kevent (dev, EVENT_TX_HALT);
L
Linus Torvalds 已提交
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
		break;
	default:
		if (netif_msg_tx_err (dev))
			devdbg (dev, "tx: submit urb err %d", retval);
		break;
	case 0:
		net->trans_start = jiffies;
		__skb_queue_tail (&dev->txq, skb);
		if (dev->txq.qlen >= TX_QLEN (dev))
			netif_stop_queue (net);
	}
	spin_unlock_irqrestore (&dev->txq.lock, flags);

	if (retval) {
		if (netif_msg_tx_err (dev))
			devdbg (dev, "drop, code %d", retval);
drop:
H
Herbert Xu 已提交
1083
		dev->net->stats.tx_dropped++;
L
Linus Torvalds 已提交
1084 1085 1086 1087 1088 1089 1090
		if (skb)
			dev_kfree_skb_any (skb);
		usb_free_urb (urb);
	} else if (netif_msg_tx_queued (dev)) {
		devdbg (dev, "> tx, len %d, type 0x%x",
			length, skb->protocol);
	}
1091
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
1092
}
1093
EXPORT_SYMBOL_GPL(usbnet_start_xmit);
L
Linus Torvalds 已提交
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107

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

// 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 已提交
1108
		case rx_done:
L
Linus Torvalds 已提交
1109 1110 1111
			entry->state = rx_cleanup;
			rx_process (dev, skb);
			continue;
D
David Brownell 已提交
1112 1113
		case tx_done:
		case rx_cleanup:
L
Linus Torvalds 已提交
1114 1115 1116
			usb_free_urb (entry->urb);
			dev_kfree_skb (skb);
			continue;
D
David Brownell 已提交
1117
		default:
L
Linus Torvalds 已提交
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
			devdbg (dev, "bogus skb state %d", entry->state);
		}
	}

	// waiting for all pending urbs to complete?
	if (dev->wait) {
		if ((dev->txq.qlen + dev->rxq.qlen + dev->done.qlen) == 0) {
			wake_up (dev->wait);
		}

	// or are we maybe short a few urbs?
	} else if (netif_running (dev->net)
			&& netif_device_present (dev->net)
			&& !timer_pending (&dev->delay)
			&& !test_bit (EVENT_RX_HALT, &dev->flags)) {
		int	temp = dev->rxq.qlen;
		int	qlen = RX_QLEN (dev);

		if (temp < qlen) {
			struct urb	*urb;
			int		i;

			// don't refill the queue all at once
			for (i = 0; i < 10 && dev->rxq.qlen < qlen; i++) {
				urb = usb_alloc_urb (0, GFP_ATOMIC);
				if (urb != NULL)
					rx_submit (dev, urb, GFP_ATOMIC);
			}
			if (temp != dev->rxq.qlen && netif_msg_link (dev))
				devdbg (dev, "rxqlen %d --> %d",
						temp, dev->rxq.qlen);
			if (dev->rxq.qlen < qlen)
				tasklet_schedule (&dev->bh);
		}
		if (dev->txq.qlen < TX_QLEN (dev))
			netif_wake_queue (dev->net);
	}
}


/*-------------------------------------------------------------------------
 *
 * USB Device Driver support
 *
 *-------------------------------------------------------------------------*/
1163

L
Linus Torvalds 已提交
1164 1165
// precondition: never called in_interrupt

1166
void usbnet_disconnect (struct usb_interface *intf)
L
Linus Torvalds 已提交
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
{
	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);

	if (netif_msg_probe (dev))
1180 1181
		devinfo (dev, "unregister '%s' usb-%s-%s, %s",
			intf->dev.driver->name,
L
Linus Torvalds 已提交
1182 1183
			xdev->bus->bus_name, xdev->devpath,
			dev->driver_info->description);
1184

L
Linus Torvalds 已提交
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
	net = dev->net;
	unregister_netdev (net);

	/* we don't hold rtnl here ... */
	flush_scheduled_work ();

	if (dev->driver_info->unbind)
		dev->driver_info->unbind (dev, intf);

	free_netdev(net);
	usb_put_dev (xdev);
}
1197
EXPORT_SYMBOL_GPL(usbnet_disconnect);
L
Linus Torvalds 已提交
1198

1199 1200 1201 1202 1203 1204 1205 1206 1207
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 已提交
1208 1209 1210 1211 1212

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

// precondition: never called in_interrupt

1213
int
L
Linus Torvalds 已提交
1214 1215 1216
usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
{
	struct usbnet			*dev;
1217
	struct net_device		*net;
L
Linus Torvalds 已提交
1218 1219 1220 1221
	struct usb_host_interface	*interface;
	struct driver_info		*info;
	struct usb_device		*xdev;
	int				status;
1222
	const char			*name;
L
Linus Torvalds 已提交
1223

1224
	name = udev->dev.driver->name;
L
Linus Torvalds 已提交
1225 1226
	info = (struct driver_info *) prod->driver_info;
	if (!info) {
1227
		dev_dbg (&udev->dev, "blacklisted by %s\n", name);
L
Linus Torvalds 已提交
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
		return -ENODEV;
	}
	xdev = interface_to_usbdev (udev);
	interface = udev->cur_altsetting;

	usb_get_dev (xdev);

	status = -ENOMEM;

	// set up our own records
	net = alloc_etherdev(sizeof(*dev));
	if (!net) {
		dbg ("can't kmalloc dev");
		goto out;
	}

	dev = netdev_priv(net);
	dev->udev = xdev;
1246
	dev->intf = udev;
L
Linus Torvalds 已提交
1247
	dev->driver_info = info;
1248
	dev->driver_name = name;
L
Linus Torvalds 已提交
1249 1250 1251 1252 1253
	dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV
				| NETIF_MSG_PROBE | NETIF_MSG_LINK);
	skb_queue_head_init (&dev->rxq);
	skb_queue_head_init (&dev->txq);
	skb_queue_head_init (&dev->done);
J
Jussi Kivilinna 已提交
1254
	skb_queue_head_init(&dev->rxq_pause);
L
Linus Torvalds 已提交
1255 1256
	dev->bh.func = usbnet_bh;
	dev->bh.data = (unsigned long) dev;
D
David Howells 已提交
1257
	INIT_WORK (&dev->kevent, kevent);
L
Linus Torvalds 已提交
1258 1259 1260
	dev->delay.function = usbnet_bh;
	dev->delay.data = (unsigned long) dev;
	init_timer (&dev->delay);
1261
	mutex_init (&dev->phy_mutex);
L
Linus Torvalds 已提交
1262 1263 1264 1265 1266

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

1267 1268 1269 1270
	/* 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 已提交
1271 1272 1273
#if 0
// dma_supported() is deeply broken on almost all architectures
	// possible with some EHCI controllers
1274
	if (dma_supported (&udev->dev, DMA_BIT_MASK(64)))
L
Linus Torvalds 已提交
1275 1276 1277
		net->features |= NETIF_F_HIGHDMA;
#endif

1278 1279
	net->netdev_ops = &usbnet_netdev_ops;
	net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
L
Linus Torvalds 已提交
1280 1281 1282 1283 1284 1285
	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);
1286 1287 1288
		if (status < 0)
			goto out1;

L
Linus Torvalds 已提交
1289 1290 1291 1292 1293 1294
		// 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.
		if ((dev->driver_info->flags & FLAG_ETHER) != 0
				&& (net->dev_addr [0] & 0x02) == 0)
			strcpy (net->name, "eth%d");
1295 1296 1297
		/* WLAN devices should always be named "wlan%d" */
		if ((dev->driver_info->flags & FLAG_WLAN) != 0)
			strcpy(net->name, "wlan%d");
1298 1299 1300 1301

		/* 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;
1302 1303
	} else if (!info->in || !info->out)
		status = usbnet_get_endpoints (dev, udev);
L
Linus Torvalds 已提交
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
	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;

	}
1315
	if (status >= 0 && dev->status)
L
Linus Torvalds 已提交
1316 1317
		status = init_status (dev, udev);
	if (status < 0)
1318
		goto out3;
L
Linus Torvalds 已提交
1319

1320 1321
	if (!dev->rx_urb_size)
		dev->rx_urb_size = dev->hard_mtu;
L
Linus Torvalds 已提交
1322
	dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);
1323

L
Linus Torvalds 已提交
1324 1325 1326 1327 1328
	SET_NETDEV_DEV(net, &udev->dev);
	status = register_netdev (net);
	if (status)
		goto out3;
	if (netif_msg_probe (dev))
J
Johannes Berg 已提交
1329
		devinfo (dev, "register '%s' at usb-%s-%s, %s, %pM",
1330
			udev->dev.driver->name,
L
Linus Torvalds 已提交
1331 1332
			xdev->bus->bus_name, xdev->devpath,
			dev->driver_info->description,
J
Johannes Berg 已提交
1333
			net->dev_addr);
L
Linus Torvalds 已提交
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351

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

	// start as if the link is up
	netif_device_attach (net);

	return 0;

out3:
	if (info->unbind)
		info->unbind (dev, udev);
out1:
	free_netdev(net);
out:
	usb_put_dev(xdev);
	return status;
}
1352
EXPORT_SYMBOL_GPL(usbnet_probe);
L
Linus Torvalds 已提交
1353 1354 1355

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

1356 1357 1358
/*
 * suspend the whole driver as soon as the first interface is suspended
 * resume only when the last interface is resumed
1359
 */
L
Linus Torvalds 已提交
1360

1361
int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
L
Linus Torvalds 已提交
1362 1363
{
	struct usbnet		*dev = usb_get_intfdata(intf);
1364

1365
	if (!dev->suspend_count++) {
1366 1367
		/*
		 * accelerate emptying of the rx and queues, to avoid
1368 1369 1370 1371 1372
		 * having everything error out.
		 */
		netif_device_detach (dev->net);
		(void) unlink_urbs (dev, &dev->rxq);
		(void) unlink_urbs (dev, &dev->txq);
1373 1374 1375 1376 1377
		/*
		 * reattach so runtime management can use and
		 * wake the device
		 */
		netif_device_attach (dev->net);
1378
	}
L
Linus Torvalds 已提交
1379 1380
	return 0;
}
1381
EXPORT_SYMBOL_GPL(usbnet_suspend);
L
Linus Torvalds 已提交
1382

1383
int usbnet_resume (struct usb_interface *intf)
L
Linus Torvalds 已提交
1384 1385 1386
{
	struct usbnet		*dev = usb_get_intfdata(intf);

1387
	if (!--dev->suspend_count)
1388
		tasklet_schedule (&dev->bh);
1389

L
Linus Torvalds 已提交
1390 1391
	return 0;
}
1392
EXPORT_SYMBOL_GPL(usbnet_resume);
L
Linus Torvalds 已提交
1393 1394 1395 1396


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

1397
static int __init usbnet_init(void)
L
Linus Torvalds 已提交
1398
{
1399
	/* compiler should optimize this out */
1400
	BUILD_BUG_ON (sizeof (((struct sk_buff *)0)->cb)
L
Linus Torvalds 已提交
1401 1402 1403
			< sizeof (struct skb_data));

	random_ether_addr(node_id);
1404
	return 0;
L
Linus Torvalds 已提交
1405
}
1406
module_init(usbnet_init);
L
Linus Torvalds 已提交
1407

1408
static void __exit usbnet_exit(void)
L
Linus Torvalds 已提交
1409 1410
{
}
1411
module_exit(usbnet_exit);
L
Linus Torvalds 已提交
1412

1413
MODULE_AUTHOR("David Brownell");
1414
MODULE_DESCRIPTION("USB network driver framework");
1415
MODULE_LICENSE("GPL");