Lines Matching refs:dev
48 #define RX_QLEN(dev) ((dev)->rx_qlen)
49 #define TX_QLEN(dev) ((dev)->tx_qlen)
92 int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
147 !(dev->driver_info->flags & FLAG_NO_SETINT)) {
148 tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber,
154 dev->in = usb_rcvbulkpipe (dev->udev,
156 dev->out = usb_sndbulkpipe (dev->udev,
158 dev->status = status;
163 int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
169 ret = usb_string(dev->udev, iMACAddress, buf, sizeof buf);
173 dev_dbg(&dev->udev->dev,
179 eth_hw_addr_set(dev->net, addr);
186 struct usbnet *dev = urb->context;
192 dev->driver_info->status(dev, urb);
198 netif_dbg(dev, ifdown, dev->net,
206 netdev_dbg(dev->net, "intr status %d\n", status);
212 netif_err(dev, timer, dev->net,
216 static int init_status (struct usbnet *dev, struct usb_interface *intf)
223 if (!dev->driver_info->status)
226 pipe = usb_rcvintpipe (dev->udev,
227 dev->status->desc.bEndpointAddress
229 maxp = usb_maxpacket(dev->udev, pipe);
232 period = max ((int) dev->status->desc.bInterval,
233 (dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3);
237 dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);
238 if (!dev->interrupt) {
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,
254 int usbnet_status_start(struct usbnet *dev, gfp_t mem_flags)
258 WARN_ON_ONCE(dev->interrupt == NULL);
259 if (dev->interrupt) {
260 mutex_lock(&dev->interrupt_mutex);
262 if (++dev->interrupt_count == 1)
263 ret = usb_submit_urb(dev->interrupt, mem_flags);
265 dev_dbg(&dev->udev->dev, "incremented interrupt URB count to %d\n",
266 dev->interrupt_count);
267 mutex_unlock(&dev->interrupt_mutex);
274 static int __usbnet_status_start_force(struct usbnet *dev, gfp_t mem_flags)
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,
284 mutex_unlock(&dev->interrupt_mutex);
289 void usbnet_status_stop(struct usbnet *dev)
291 if (dev->interrupt) {
292 mutex_lock(&dev->interrupt_mutex);
293 WARN_ON(dev->interrupt_count == 0);
295 if (dev->interrupt_count && --dev->interrupt_count == 0)
296 usb_kill_urb(dev->interrupt);
298 dev_dbg(&dev->udev->dev,
300 dev->interrupt_count);
301 mutex_unlock(&dev->interrupt_mutex);
307 static void __usbnet_status_stop_force(struct usbnet *dev)
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);
321 void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
323 struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->net->tstats);
327 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
328 skb_queue_tail(&dev->rxq_pause, skb);
334 skb->protocol = eth_type_trans (skb, dev->net);
341 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
350 netif_dbg(dev, rx_err, dev->net,
356 void usbnet_update_max_qlen(struct usbnet *dev)
358 enum usb_device_speed speed = dev->udev->speed;
360 if (!dev->rx_urb_size || !dev->hard_mtu)
364 dev->rx_qlen = MAX_QUEUE_MEMORY / dev->rx_urb_size;
365 dev->tx_qlen = MAX_QUEUE_MEMORY / dev->hard_mtu;
374 dev->rx_qlen = 5 * MAX_QUEUE_MEMORY / dev->rx_urb_size;
375 dev->tx_qlen = 5 * MAX_QUEUE_MEMORY / dev->hard_mtu;
379 dev->rx_qlen = dev->tx_qlen = 4;
393 struct usbnet *dev = netdev_priv(net);
395 int old_hard_mtu = dev->hard_mtu;
396 int old_rx_urb_size = dev->rx_urb_size;
399 if ((ll_mtu % dev->maxpacket) == 0)
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);
414 usbnet_update_max_qlen(dev);
436 static enum skb_state defer_bh(struct usbnet *dev, struct sk_buff *skb,
448 /* defer_bh() is never called with list == &dev->done.
450 * dev->done.lock here with list->lock held.
452 spin_lock_nested(&dev->done.lock, SINGLE_DEPTH_NESTING);
454 __skb_queue_tail(&dev->done, skb);
455 if (dev->done.qlen == 1)
456 tasklet_schedule(&dev->bh);
457 spin_unlock(&dev->done.lock);
467 void usbnet_defer_kevent (struct usbnet *dev, int work)
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]);
473 netdev_dbg(dev->net, "kevent %s scheduled\n", usbnet_event_names[work]);
481 static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
487 size_t size = dev->rx_urb_size;
490 if (test_bit(EVENT_RX_KILL, &dev->flags)) {
495 if (test_bit(EVENT_NO_IP_ALIGN, &dev->flags))
496 skb = __netdev_alloc_skb(dev->net, size, flags);
498 skb = __netdev_alloc_skb_ip_align(dev->net, size, flags);
500 netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
501 usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
508 entry->dev = dev;
511 usb_fill_bulk_urb (urb, dev->udev, dev->in,
514 spin_lock_irqsave (&dev->rxq.lock, lockflags);
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)) {
523 usbnet_defer_kevent (dev, EVENT_RX_HALT);
526 usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
529 netif_dbg(dev, ifdown, dev->net, "device gone\n");
530 netif_device_detach (dev->net);
536 netif_dbg(dev, rx_err, dev->net,
538 tasklet_schedule (&dev->bh);
541 __usbnet_queue_skb(&dev->rxq, skb, rx_start);
544 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
547 spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
558 static inline int rx_process(struct usbnet *dev, struct sk_buff *skb)
560 if (dev->driver_info->rx_fixup &&
561 !dev->driver_info->rx_fixup (dev, skb)) {
563 if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE))
564 dev->net->stats.rx_errors++;
570 if (dev->driver_info->flags & FLAG_MULTI_PACKET)
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);
580 usbnet_skb_return(dev, skb);
590 struct usbnet *dev = entry->dev;
609 dev->net->stats.rx_errors++;
610 usbnet_defer_kevent (dev, EVENT_RX_HALT);
616 netif_dbg(dev, ifdown, dev->net,
627 dev->net->stats.rx_errors++;
628 if (!timer_pending (&dev->delay)) {
629 mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
630 netif_dbg(dev, link, dev->net,
641 dev->net->stats.rx_over_errors++;
646 dev->net->stats.rx_errors++;
647 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
652 if (++dev->pkt_cnt > 30) {
653 dev->pkt_cnt = 0;
654 dev->pkt_err = 0;
657 dev->pkt_err++;
658 if (dev->pkt_err > 20)
659 set_bit(EVENT_RX_KILL, &dev->flags);
662 state = defer_bh(dev, skb, &dev->rxq, state);
665 if (netif_running (dev->net) &&
666 !test_bit (EVENT_RX_HALT, &dev->flags) &&
668 rx_submit (dev, urb, GFP_ATOMIC);
669 usb_mark_last_busy(dev->udev);
674 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
678 void usbnet_pause_rx(struct usbnet *dev)
680 set_bit(EVENT_RX_PAUSED, &dev->flags);
682 netif_dbg(dev, rx_status, dev->net, "paused rx queue enabled\n");
686 void usbnet_resume_rx(struct usbnet *dev)
691 clear_bit(EVENT_RX_PAUSED, &dev->flags);
693 while ((skb = skb_dequeue(&dev->rxq_pause)) != NULL) {
694 usbnet_skb_return(dev, skb);
698 tasklet_schedule(&dev->bh);
700 netif_dbg(dev, rx_status, dev->net,
705 void usbnet_purge_paused_rxq(struct usbnet *dev)
707 skb_queue_purge(&dev->rxq_pause);
715 static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q)
750 netdev_dbg(dev->net, "unlink urb err, %d\n", retval);
763 void usbnet_unlink_rx_urbs(struct usbnet *dev)
765 if (netif_running(dev->net)) {
766 (void) unlink_urbs (dev, &dev->rxq);
767 tasklet_schedule(&dev->bh);
789 static void usbnet_terminate_urbs(struct usbnet *dev)
795 add_wait_queue(&dev->wait, &wait);
797 temp = unlink_urbs(dev, &dev->txq) +
798 unlink_urbs(dev, &dev->rxq);
801 wait_skb_queue_empty(&dev->rxq);
802 wait_skb_queue_empty(&dev->txq);
803 wait_skb_queue_empty(&dev->done);
804 netif_dbg(dev, ifdown, dev->net,
807 remove_wait_queue(&dev->wait, &wait);
812 struct usbnet *dev = netdev_priv(net);
813 const struct driver_info *info = dev->driver_info;
816 clear_bit(EVENT_DEV_OPEN, &dev->flags);
819 netif_info(dev, ifdown, dev->net,
825 pm = usb_autopm_get_interface(dev->intf);
829 retval = info->stop(dev);
831 netif_info(dev, ifdown, dev->net,
834 dev->udev->bus->bus_name, dev->udev->devpath,
839 usbnet_terminate_urbs(dev);
841 usbnet_status_stop(dev);
843 usbnet_purge_paused_rxq(dev);
845 mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags);
848 dev->flags = 0;
849 del_timer_sync (&dev->delay);
850 tasklet_kill (&dev->bh);
851 cancel_work_sync(&dev->kevent);
853 usb_autopm_put_interface(dev->intf);
856 info->manage_power(dev, 0);
858 usb_autopm_put_interface(dev->intf);
872 struct usbnet *dev = netdev_priv(net);
874 const struct driver_info *info = dev->driver_info;
876 if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
877 netif_info(dev, ifup, dev->net,
880 dev->udev->bus->bus_name,
881 dev->udev->devpath,
887 if (info->reset && (retval = info->reset (dev)) < 0) {
888 netif_info(dev, ifup, dev->net,
891 dev->udev->bus->bus_name,
892 dev->udev->devpath,
898 usbnet_update_max_qlen(dev);
901 if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
902 netif_err(dev, ifup, dev->net, "can't open; %d\n", retval);
907 if (dev->interrupt) {
908 retval = usbnet_status_start(dev, GFP_KERNEL);
910 netif_err(dev, ifup, dev->net,
916 set_bit(EVENT_DEV_OPEN, &dev->flags);
918 netif_info(dev, ifup, dev->net,
920 (int)RX_QLEN(dev), (int)TX_QLEN(dev),
921 dev->net->mtu,
922 (dev->driver_info->flags & FLAG_FRAMING_NC) ? "NetChip" :
923 (dev->driver_info->flags & FLAG_FRAMING_GL) ? "GeneSys" :
924 (dev->driver_info->flags & FLAG_FRAMING_Z) ? "Zaurus" :
925 (dev->driver_info->flags & FLAG_FRAMING_RN) ? "RNDIS" :
926 (dev->driver_info->flags & FLAG_FRAMING_AX) ? "ASIX" :
930 dev->pkt_cnt = 0;
931 dev->pkt_err = 0;
932 clear_bit(EVENT_RX_KILL, &dev->flags);
935 tasklet_schedule (&dev->bh);
937 retval = info->manage_power(dev, 1);
940 set_bit(EVENT_NO_RUNTIME_PM, &dev->flags);
942 usb_autopm_put_interface(dev->intf);
947 usb_autopm_put_interface(dev->intf);
965 struct usbnet *dev = netdev_priv(net);
967 if (!dev->mii.mdio_read)
970 mii_ethtool_get_link_ksettings(&dev->mii, cmd);
979 struct usbnet *dev = netdev_priv(net);
986 if (dev->rx_speed != SPEED_UNSET)
987 cmd->base.speed = dev->rx_speed / 1000000;
988 else if (dev->tx_speed != SPEED_UNSET)
989 cmd->base.speed = dev->tx_speed / 1000000;
1000 struct usbnet *dev = netdev_priv(net);
1003 if (!dev->mii.mdio_write)
1006 retval = mii_ethtool_set_link_ksettings(&dev->mii, cmd);
1009 if (dev->driver_info->link_reset)
1010 dev->driver_info->link_reset(dev);
1013 usbnet_update_max_qlen(dev);
1021 struct usbnet *dev = netdev_priv(net);
1024 if (dev->driver_info->check_connect)
1025 return dev->driver_info->check_connect (dev) == 0;
1028 if (dev->mii.mdio_read)
1029 return mii_link_ok(&dev->mii);
1038 struct usbnet *dev = netdev_priv(net);
1040 if (!dev->mii.mdio_write)
1043 return mii_nway_restart(&dev->mii);
1049 struct usbnet *dev = netdev_priv(net);
1051 strscpy(info->driver, dev->driver_name, sizeof(info->driver));
1052 strscpy(info->fw_version, dev->driver_info->description,
1054 usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
1060 struct usbnet *dev = netdev_priv(net);
1062 return dev->msg_enable;
1068 struct usbnet *dev = netdev_priv(net);
1070 dev->msg_enable = level;
1088 static void __handle_link_change(struct usbnet *dev)
1090 if (!test_bit(EVENT_DEV_OPEN, &dev->flags))
1093 if (!netif_carrier_ok(dev->net)) {
1095 unlink_urbs(dev, &dev->rxq);
1103 tasklet_schedule(&dev->bh);
1107 usbnet_update_max_qlen(dev);
1109 clear_bit(EVENT_LINK_CHANGE, &dev->flags);
1114 struct usbnet *dev = netdev_priv(net);
1116 usbnet_defer_kevent(dev, EVENT_SET_RX_MODE);
1120 static void __handle_set_rx_mode(struct usbnet *dev)
1122 if (dev->driver_info->set_rx_mode)
1123 (dev->driver_info->set_rx_mode)(dev);
1125 clear_bit(EVENT_SET_RX_MODE, &dev->flags);
1136 struct usbnet *dev =
1141 if (test_bit (EVENT_TX_HALT, &dev->flags)) {
1142 unlink_urbs (dev, &dev->txq);
1143 status = usb_autopm_get_interface(dev->intf);
1146 status = usb_clear_halt (dev->udev, dev->out);
1147 usb_autopm_put_interface(dev->intf);
1151 if (netif_msg_tx_err (dev))
1153 netdev_err(dev->net, "can't clear tx halt, status %d\n",
1156 clear_bit (EVENT_TX_HALT, &dev->flags);
1158 netif_wake_queue (dev->net);
1161 if (test_bit (EVENT_RX_HALT, &dev->flags)) {
1162 unlink_urbs (dev, &dev->rxq);
1163 status = usb_autopm_get_interface(dev->intf);
1166 status = usb_clear_halt (dev->udev, dev->in);
1167 usb_autopm_put_interface(dev->intf);
1171 if (netif_msg_rx_err (dev))
1173 netdev_err(dev->net, "can't clear rx halt, status %d\n",
1176 clear_bit (EVENT_RX_HALT, &dev->flags);
1177 tasklet_schedule (&dev->bh);
1182 if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
1186 if (netif_running (dev->net))
1189 clear_bit (EVENT_RX_MEMORY, &dev->flags);
1191 clear_bit (EVENT_RX_MEMORY, &dev->flags);
1192 status = usb_autopm_get_interface(dev->intf);
1197 if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
1199 usb_autopm_put_interface(dev->intf);
1202 tasklet_schedule (&dev->bh);
1206 if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
1207 const struct driver_info *info = dev->driver_info;
1210 clear_bit (EVENT_LINK_RESET, &dev->flags);
1211 status = usb_autopm_get_interface(dev->intf);
1214 if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
1215 usb_autopm_put_interface(dev->intf);
1217 netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s\n",
1219 dev->udev->bus->bus_name,
1220 dev->udev->devpath,
1223 usb_autopm_put_interface(dev->intf);
1227 __handle_link_change(dev);
1230 if (test_bit (EVENT_LINK_CHANGE, &dev->flags))
1231 __handle_link_change(dev);
1233 if (test_bit (EVENT_SET_RX_MODE, &dev->flags))
1234 __handle_set_rx_mode(dev);
1237 if (dev->flags)
1238 netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags);
1247 struct usbnet *dev = entry->dev;
1250 struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->net->tstats);
1258 dev->net->stats.tx_errors++;
1262 usbnet_defer_kevent (dev, EVENT_TX_HALT);
1276 usb_mark_last_busy(dev->udev);
1277 if (!timer_pending (&dev->delay)) {
1278 mod_timer (&dev->delay,
1280 netif_dbg(dev, link, dev->net,
1283 netif_stop_queue (dev->net);
1286 netif_dbg(dev, tx_err, dev->net,
1292 usb_autopm_put_interface_async(dev->intf);
1293 (void) defer_bh(dev, skb, &dev->txq, tx_done);
1300 struct usbnet *dev = netdev_priv(net);
1302 unlink_urbs (dev, &dev->txq);
1303 tasklet_schedule (&dev->bh);
1308 if (dev->driver_info->recover)
1309 (dev->driver_info->recover)(dev);
1351 struct usbnet *dev = netdev_priv(net);
1355 const struct driver_info *info = dev->driver_info;
1365 skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
1370 netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb\n");
1376 netif_dbg(dev, tx_err, dev->net, "no urb\n");
1382 entry->dev = dev;
1384 usb_fill_bulk_urb (urb, dev->udev, dev->out,
1386 if (dev->can_dma_sg) {
1399 if (length % dev->maxpacket == 0) {
1408 dev->padding_pkt, 1);
1427 spin_lock_irqsave(&dev->txq.lock, flags);
1428 retval = usb_autopm_get_interface_async(dev->intf);
1430 spin_unlock_irqrestore(&dev->txq.lock, flags);
1434 usb_autopm_put_interface_async(dev->intf);
1435 spin_unlock_irqrestore(&dev->txq.lock, flags);
1441 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
1443 usb_anchor_urb(urb, &dev->deferred);
1447 spin_unlock_irqrestore(&dev->txq.lock, flags);
1448 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
1456 usbnet_defer_kevent (dev, EVENT_TX_HALT);
1457 usb_autopm_put_interface_async(dev->intf);
1460 usb_autopm_put_interface_async(dev->intf);
1461 netif_dbg(dev, tx_err, dev->net,
1466 __usbnet_queue_skb(&dev->txq, skb, tx_start);
1467 if (dev->txq.qlen >= TX_QLEN (dev))
1470 spin_unlock_irqrestore (&dev->txq.lock, flags);
1473 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval);
1475 dev->net->stats.tx_dropped++;
1484 netif_dbg(dev, tx_queued, dev->net,
1493 static int rx_alloc_submit(struct usbnet *dev, gfp_t flags)
1500 for (i = 0; i < 10 && dev->rxq.qlen < RX_QLEN(dev); i++) {
1503 ret = rx_submit(dev, urb, flags);
1529 struct usbnet *dev = from_timer(dev, t, delay);
1533 while ((skb = skb_dequeue (&dev->done))) {
1537 if (rx_process(dev, skb))
1547 netdev_dbg(dev->net, "bogus skb state %d\n", entry->state);
1552 clear_bit(EVENT_RX_KILL, &dev->flags);
1557 if (waitqueue_active(&dev->wait)) {
1558 if (dev->txq.qlen + dev->rxq.qlen + dev->done.qlen == 0)
1559 wake_up_all(&dev->wait);
1562 } else if (netif_running (dev->net) &&
1563 netif_device_present (dev->net) &&
1564 netif_carrier_ok(dev->net) &&
1565 !timer_pending(&dev->delay) &&
1566 !test_bit(EVENT_RX_PAUSED, &dev->flags) &&
1567 !test_bit(EVENT_RX_HALT, &dev->flags)) {
1568 int temp = dev->rxq.qlen;
1570 if (temp < RX_QLEN(dev)) {
1571 if (rx_alloc_submit(dev, GFP_ATOMIC) == -ENOLINK)
1573 if (temp != dev->rxq.qlen)
1574 netif_dbg(dev, link, dev->net,
1576 temp, dev->rxq.qlen);
1577 if (dev->rxq.qlen < RX_QLEN(dev))
1578 tasklet_schedule (&dev->bh);
1580 if (dev->txq.qlen < TX_QLEN (dev))
1581 netif_wake_queue (dev->net);
1587 struct usbnet *dev = from_tasklet(dev, t, bh);
1589 usbnet_bh(&dev->delay);
1603 struct usbnet *dev;
1608 dev = usb_get_intfdata(intf);
1610 if (!dev)
1615 netif_info(dev, probe, dev->net, "unregister '%s' usb-%s-%s, %s\n",
1616 intf->dev.driver->name,
1618 dev->driver_info->description);
1620 net = dev->net;
1623 while ((urb = usb_get_from_anchor(&dev->deferred))) {
1629 if (dev->driver_info->unbind)
1630 dev->driver_info->unbind(dev, intf);
1632 usb_kill_urb(dev->interrupt);
1633 usb_free_urb(dev->interrupt);
1634 kfree(dev->padding_pkt);
1668 struct usbnet *dev;
1675 struct usb_driver *driver = to_usb_driver(udev->dev.driver);
1683 pm_runtime_enable(&udev->dev);
1686 name = udev->dev.driver->name;
1689 dev_dbg (&udev->dev, "blacklisted by %s\n", name);
1698 net = alloc_etherdev(sizeof(*dev));
1703 SET_NETDEV_DEV(net, &udev->dev);
1705 dev = netdev_priv(net);
1706 dev->udev = xdev;
1707 dev->intf = udev;
1708 dev->driver_info = info;
1709 dev->driver_name = name;
1710 dev->rx_speed = SPEED_UNSET;
1711 dev->tx_speed = SPEED_UNSET;
1717 dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV
1719 init_waitqueue_head(&dev->wait);
1720 skb_queue_head_init (&dev->rxq);
1721 skb_queue_head_init (&dev->txq);
1722 skb_queue_head_init (&dev->done);
1723 skb_queue_head_init(&dev->rxq_pause);
1724 tasklet_setup(&dev->bh, usbnet_bh_tasklet);
1725 INIT_WORK (&dev->kevent, usbnet_deferred_kevent);
1726 init_usb_anchor(&dev->deferred);
1727 timer_setup(&dev->delay, usbnet_bh, 0);
1728 mutex_init (&dev->phy_mutex);
1729 mutex_init(&dev->interrupt_mutex);
1730 dev->interrupt_count = 0;
1732 dev->net = net;
1739 dev->hard_mtu = net->mtu + net->hard_header_len;
1750 status = info->bind (dev, udev);
1757 if ((dev->driver_info->flags & FLAG_ETHER) != 0 &&
1758 ((dev->driver_info->flags & FLAG_POINTTOPOINT) == 0 ||
1762 if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1765 if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1769 if ((dev->driver_info->flags & FLAG_NOARP) != 0)
1773 if (net->mtu > (dev->hard_mtu - net->hard_header_len))
1774 net->mtu = dev->hard_mtu - net->hard_header_len;
1776 status = usbnet_get_endpoints (dev, udev);
1782 dev->in = usb_rcvbulkpipe (xdev, info->in);
1783 dev->out = usb_sndbulkpipe (xdev, info->out);
1794 if (status >= 0 && dev->status)
1795 status = init_status (dev, udev);
1799 if (!dev->rx_urb_size)
1800 dev->rx_urb_size = dev->hard_mtu;
1801 dev->maxpacket = usb_maxpacket(dev->udev, dev->out);
1802 if (dev->maxpacket == 0) {
1812 if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1814 if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1818 usbnet_update_max_qlen(dev);
1820 if (dev->can_dma_sg && !(info->flags & FLAG_SEND_ZLP) &&
1822 dev->padding_pkt = kzalloc(1, GFP_KERNEL);
1823 if (!dev->padding_pkt) {
1832 netif_info(dev, probe, dev->net,
1834 udev->dev.driver->name,
1836 dev->driver_info->description,
1840 usb_set_intfdata (udev, dev);
1844 if (dev->driver_info->flags & FLAG_LINK_INTR)
1845 usbnet_link_change(dev, 0, 0);
1850 kfree(dev->padding_pkt);
1852 usb_free_urb(dev->interrupt);
1855 info->unbind (dev, udev);
1862 cancel_work_sync(&dev->kevent);
1863 del_timer_sync(&dev->delay);
1881 struct usbnet *dev = usb_get_intfdata(intf);
1883 if (!dev->suspend_count++) {
1884 spin_lock_irq(&dev->txq.lock);
1886 if (dev->txq.qlen && PMSG_IS_AUTO(message)) {
1887 dev->suspend_count--;
1888 spin_unlock_irq(&dev->txq.lock);
1891 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
1892 spin_unlock_irq(&dev->txq.lock);
1898 netif_device_detach (dev->net);
1899 usbnet_terminate_urbs(dev);
1900 __usbnet_status_stop_force(dev);
1906 netif_device_attach (dev->net);
1914 struct usbnet *dev = usb_get_intfdata(intf);
1919 if (!--dev->suspend_count) {
1921 __usbnet_status_start_force(dev, GFP_NOIO);
1923 spin_lock_irq(&dev->txq.lock);
1924 while ((res = usb_get_from_anchor(&dev->deferred))) {
1932 usb_autopm_put_interface_async(dev->intf);
1934 netif_trans_update(dev->net);
1935 __skb_queue_tail(&dev->txq, skb);
1940 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
1941 spin_unlock_irq(&dev->txq.lock);
1943 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
1947 if (netif_device_present(dev->net) &&
1948 !timer_pending(&dev->delay) &&
1949 !test_bit(EVENT_RX_HALT, &dev->flags))
1950 rx_alloc_submit(dev, GFP_NOIO);
1952 if (!(dev->txq.qlen >= TX_QLEN(dev)))
1953 netif_tx_wake_all_queues(dev->net);
1954 tasklet_schedule (&dev->bh);
1958 if (test_and_clear_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags))
1970 void usbnet_device_suggests_idle(struct usbnet *dev)
1972 if (!test_and_set_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags)) {
1973 dev->intf->needs_remote_wakeup = 1;
1974 usb_autopm_put_interface_async(dev->intf);
1982 int usbnet_manage_power(struct usbnet *dev, int on)
1984 dev->intf->needs_remote_wakeup = on;
1989 void usbnet_link_change(struct usbnet *dev, bool link, bool need_reset)
1993 netif_carrier_on(dev->net);
1995 netif_carrier_off(dev->net);
1998 usbnet_defer_kevent(dev, EVENT_LINK_RESET);
2000 usbnet_defer_kevent(dev, EVENT_LINK_CHANGE);
2005 static int __usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2011 netdev_dbg(dev->net, "usbnet_read_cmd cmd=0x%02x reqtype=%02x"
2021 err = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
2028 netdev_dbg(dev->net,
2036 static int __usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2043 netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
2059 err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
2072 int usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2077 if (usb_autopm_get_interface(dev->intf) < 0)
2079 ret = __usbnet_read_cmd(dev, cmd, reqtype, value, index,
2081 usb_autopm_put_interface(dev->intf);
2090 int usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2095 if (usb_autopm_get_interface(dev->intf) < 0)
2097 ret = __usbnet_write_cmd(dev, cmd, reqtype, value, index,
2099 usb_autopm_put_interface(dev->intf);
2108 int usbnet_read_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
2111 return __usbnet_read_cmd(dev, cmd, reqtype, value, index,
2120 int usbnet_write_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
2124 return __usbnet_write_cmd(dev, cmd, reqtype, value, index,
2135 dev_dbg(&urb->dev->dev, "%s failed with %d",
2146 int usbnet_write_cmd_async(struct usbnet *dev, u8 cmd, u8 reqtype,
2154 netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
2165 netdev_err(dev->net, "Error allocating buffer"
2181 usb_fill_control_urb(urb, dev->udev,
2182 usb_sndctrlpipe(dev->udev, 0),
2189 netdev_err(dev->net, "Error submitting the control"