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