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