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