Lines Matching refs:dev
51 #define RX_QLEN(dev) ((dev)->rx_qlen)
52 #define TX_QLEN(dev) ((dev)->tx_qlen)
78 int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
133 !(dev->driver_info->flags & FLAG_NO_SETINT)) {
134 tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber,
140 dev->in = usb_rcvbulkpipe (dev->udev,
142 dev->out = usb_sndbulkpipe (dev->udev,
144 dev->status = status;
149 int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
154 ret = usb_string(dev->udev, iMACAddress, buf, sizeof buf);
156 tmp = hex2bin(dev->net->dev_addr, buf, 6);
158 dev_dbg(&dev->udev->dev,
170 struct usbnet *dev = urb->context;
176 dev->driver_info->status(dev, urb);
182 netif_dbg(dev, ifdown, dev->net,
190 netdev_dbg(dev->net, "intr status %d\n", status);
196 netif_err(dev, timer, dev->net,
200 static int init_status (struct usbnet *dev, struct usb_interface *intf)
207 if (!dev->driver_info->status)
210 pipe = usb_rcvintpipe (dev->udev,
211 dev->status->desc.bEndpointAddress
213 maxp = usb_maxpacket (dev->udev, pipe, 0);
216 period = max ((int) dev->status->desc.bInterval,
217 (dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3);
221 dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);
222 if (!dev->interrupt) {
226 usb_fill_int_urb(dev->interrupt, dev->udev, pipe,
227 buf, maxp, intr_complete, dev, period);
228 dev->interrupt->transfer_flags |= URB_FREE_BUFFER;
229 dev_dbg(&intf->dev,
238 int usbnet_status_start(struct usbnet *dev, gfp_t mem_flags)
242 WARN_ON_ONCE(dev->interrupt == NULL);
243 if (dev->interrupt) {
244 mutex_lock(&dev->interrupt_mutex);
246 if (++dev->interrupt_count == 1)
247 ret = usb_submit_urb(dev->interrupt, mem_flags);
249 dev_dbg(&dev->udev->dev, "incremented interrupt URB count to %d\n",
250 dev->interrupt_count);
251 mutex_unlock(&dev->interrupt_mutex);
258 static int __usbnet_status_start_force(struct usbnet *dev, gfp_t mem_flags)
262 mutex_lock(&dev->interrupt_mutex);
263 if (dev->interrupt_count) {
264 ret = usb_submit_urb(dev->interrupt, mem_flags);
265 dev_dbg(&dev->udev->dev,
268 mutex_unlock(&dev->interrupt_mutex);
273 void usbnet_status_stop(struct usbnet *dev)
275 if (dev->interrupt) {
276 mutex_lock(&dev->interrupt_mutex);
277 WARN_ON(dev->interrupt_count == 0);
279 if (dev->interrupt_count && --dev->interrupt_count == 0)
280 usb_kill_urb(dev->interrupt);
282 dev_dbg(&dev->udev->dev,
284 dev->interrupt_count);
285 mutex_unlock(&dev->interrupt_mutex);
291 static void __usbnet_status_stop_force(struct usbnet *dev)
293 if (dev->interrupt) {
294 mutex_lock(&dev->interrupt_mutex);
295 usb_kill_urb(dev->interrupt);
296 dev_dbg(&dev->udev->dev, "killed interrupt URB for suspend\n");
297 mutex_unlock(&dev->interrupt_mutex);
305 void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
307 struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->stats64);
311 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
312 skb_queue_tail(&dev->rxq_pause, skb);
318 skb->protocol = eth_type_trans (skb, dev->net);
325 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
334 netif_dbg(dev, rx_err, dev->net,
340 void usbnet_update_max_qlen(struct usbnet *dev)
342 enum usb_device_speed speed = dev->udev->speed;
344 if (!dev->rx_urb_size || !dev->hard_mtu)
348 dev->rx_qlen = MAX_QUEUE_MEMORY / dev->rx_urb_size;
349 dev->tx_qlen = MAX_QUEUE_MEMORY / dev->hard_mtu;
358 dev->rx_qlen = 5 * MAX_QUEUE_MEMORY / dev->rx_urb_size;
359 dev->tx_qlen = 5 * MAX_QUEUE_MEMORY / dev->hard_mtu;
363 dev->rx_qlen = dev->tx_qlen = 4;
378 struct usbnet *dev = netdev_priv(net);
380 int old_hard_mtu = dev->hard_mtu;
381 int old_rx_urb_size = dev->rx_urb_size;
384 if ((ll_mtu % dev->maxpacket) == 0)
388 dev->hard_mtu = net->mtu + net->hard_header_len;
389 if (dev->rx_urb_size == old_hard_mtu) {
390 dev->rx_urb_size = dev->hard_mtu;
391 if (dev->rx_urb_size > old_rx_urb_size) {
392 usbnet_pause_rx(dev);
393 usbnet_unlink_rx_urbs(dev);
394 usbnet_resume_rx(dev);
399 usbnet_update_max_qlen(dev);
421 static enum skb_state defer_bh(struct usbnet *dev, struct sk_buff *skb,
433 /* defer_bh() is never called with list == &dev->done.
435 * dev->done.lock here with list->lock held.
437 spin_lock_nested(&dev->done.lock, SINGLE_DEPTH_NESTING);
439 __skb_queue_tail(&dev->done, skb);
440 if (dev->done.qlen == 1)
441 tasklet_schedule(&dev->bh);
442 spin_unlock(&dev->done.lock);
452 void usbnet_defer_kevent (struct usbnet *dev, int work)
454 set_bit (work, &dev->flags);
455 if (!schedule_work (&dev->kevent))
456 netdev_dbg(dev->net, "kevent %d may have been dropped\n", work);
458 netdev_dbg(dev->net, "kevent %d scheduled\n", work);
466 static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
472 size_t size = dev->rx_urb_size;
475 if (test_bit(EVENT_RX_KILL, &dev->flags)) {
480 if (test_bit(EVENT_NO_IP_ALIGN, &dev->flags))
481 skb = __netdev_alloc_skb(dev->net, size, flags);
483 skb = __netdev_alloc_skb_ip_align(dev->net, size, flags);
485 netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
486 usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
493 entry->dev = dev;
496 usb_fill_bulk_urb (urb, dev->udev, dev->in,
499 spin_lock_irqsave (&dev->rxq.lock, lockflags);
501 if (netif_running (dev->net) &&
502 netif_device_present (dev->net) &&
503 test_bit(EVENT_DEV_OPEN, &dev->flags) &&
504 !test_bit (EVENT_RX_HALT, &dev->flags) &&
505 !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {
508 usbnet_defer_kevent (dev, EVENT_RX_HALT);
511 usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
514 netif_dbg(dev, ifdown, dev->net, "device gone\n");
515 netif_device_detach (dev->net);
521 netif_dbg(dev, rx_err, dev->net,
523 tasklet_schedule (&dev->bh);
526 __usbnet_queue_skb(&dev->rxq, skb, rx_start);
529 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
532 spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
543 static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
545 if (dev->driver_info->rx_fixup &&
546 !dev->driver_info->rx_fixup (dev, skb)) {
548 if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE))
549 dev->net->stats.rx_errors++;
555 if (dev->driver_info->flags & FLAG_MULTI_PACKET)
559 dev->net->stats.rx_errors++;
560 dev->net->stats.rx_length_errors++;
561 netif_dbg(dev, rx_err, dev->net, "rx length %d\n", skb->len);
563 usbnet_skb_return(dev, skb);
568 skb_queue_tail(&dev->done, skb);
577 struct usbnet *dev = entry->dev;
596 dev->net->stats.rx_errors++;
597 usbnet_defer_kevent (dev, EVENT_RX_HALT);
603 netif_dbg(dev, ifdown, dev->net,
614 dev->net->stats.rx_errors++;
615 if (!timer_pending (&dev->delay)) {
616 mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
617 netif_dbg(dev, link, dev->net,
628 dev->net->stats.rx_over_errors++;
633 dev->net->stats.rx_errors++;
634 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
639 if (++dev->pkt_cnt > 30) {
640 dev->pkt_cnt = 0;
641 dev->pkt_err = 0;
644 dev->pkt_err++;
645 if (dev->pkt_err > 20)
646 set_bit(EVENT_RX_KILL, &dev->flags);
649 state = defer_bh(dev, skb, &dev->rxq, state);
652 if (netif_running (dev->net) &&
653 !test_bit (EVENT_RX_HALT, &dev->flags) &&
655 rx_submit (dev, urb, GFP_ATOMIC);
656 usb_mark_last_busy(dev->udev);
661 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
665 void usbnet_pause_rx(struct usbnet *dev)
667 set_bit(EVENT_RX_PAUSED, &dev->flags);
669 netif_dbg(dev, rx_status, dev->net, "paused rx queue enabled\n");
673 void usbnet_resume_rx(struct usbnet *dev)
678 clear_bit(EVENT_RX_PAUSED, &dev->flags);
680 while ((skb = skb_dequeue(&dev->rxq_pause)) != NULL) {
681 usbnet_skb_return(dev, skb);
685 tasklet_schedule(&dev->bh);
687 netif_dbg(dev, rx_status, dev->net,
692 void usbnet_purge_paused_rxq(struct usbnet *dev)
694 skb_queue_purge(&dev->rxq_pause);
702 static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q)
737 netdev_dbg(dev->net, "unlink urb err, %d\n", retval);
750 void usbnet_unlink_rx_urbs(struct usbnet *dev)
752 if (netif_running(dev->net)) {
753 (void) unlink_urbs (dev, &dev->rxq);
754 tasklet_schedule(&dev->bh);
776 static void usbnet_terminate_urbs(struct usbnet *dev)
782 add_wait_queue(&dev->wait, &wait);
784 temp = unlink_urbs(dev, &dev->txq) +
785 unlink_urbs(dev, &dev->rxq);
788 wait_skb_queue_empty(&dev->rxq);
789 wait_skb_queue_empty(&dev->txq);
790 wait_skb_queue_empty(&dev->done);
791 netif_dbg(dev, ifdown, dev->net,
794 remove_wait_queue(&dev->wait, &wait);
799 struct usbnet *dev = netdev_priv(net);
800 const struct driver_info *info = dev->driver_info;
803 clear_bit(EVENT_DEV_OPEN, &dev->flags);
806 netif_info(dev, ifdown, dev->net,
812 pm = usb_autopm_get_interface(dev->intf);
816 retval = info->stop(dev);
818 netif_info(dev, ifdown, dev->net,
821 dev->udev->bus->bus_name, dev->udev->devpath,
826 usbnet_terminate_urbs(dev);
828 usbnet_status_stop(dev);
830 usbnet_purge_paused_rxq(dev);
832 mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags);
835 dev->flags = 0;
836 del_timer_sync (&dev->delay);
837 tasklet_kill (&dev->bh);
838 cancel_work_sync(&dev->kevent);
840 usb_autopm_put_interface(dev->intf);
843 info->manage_power(dev, 0);
845 usb_autopm_put_interface(dev->intf);
859 struct usbnet *dev = netdev_priv(net);
861 const struct driver_info *info = dev->driver_info;
863 if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
864 netif_info(dev, ifup, dev->net,
867 dev->udev->bus->bus_name,
868 dev->udev->devpath,
874 if (info->reset && (retval = info->reset (dev)) < 0) {
875 netif_info(dev, ifup, dev->net,
878 dev->udev->bus->bus_name,
879 dev->udev->devpath,
885 usbnet_update_max_qlen(dev);
888 if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
889 netif_dbg(dev, ifup, dev->net, "can't open; %d\n", retval);
894 if (dev->interrupt) {
895 retval = usbnet_status_start(dev, GFP_KERNEL);
897 netif_err(dev, ifup, dev->net,
903 set_bit(EVENT_DEV_OPEN, &dev->flags);
905 netif_info(dev, ifup, dev->net,
907 (int)RX_QLEN(dev), (int)TX_QLEN(dev),
908 dev->net->mtu,
909 (dev->driver_info->flags & FLAG_FRAMING_NC) ? "NetChip" :
910 (dev->driver_info->flags & FLAG_FRAMING_GL) ? "GeneSys" :
911 (dev->driver_info->flags & FLAG_FRAMING_Z) ? "Zaurus" :
912 (dev->driver_info->flags & FLAG_FRAMING_RN) ? "RNDIS" :
913 (dev->driver_info->flags & FLAG_FRAMING_AX) ? "ASIX" :
917 dev->pkt_cnt = 0;
918 dev->pkt_err = 0;
919 clear_bit(EVENT_RX_KILL, &dev->flags);
922 tasklet_schedule (&dev->bh);
924 retval = info->manage_power(dev, 1);
927 set_bit(EVENT_NO_RUNTIME_PM, &dev->flags);
929 usb_autopm_put_interface(dev->intf);
934 usb_autopm_put_interface(dev->intf);
949 struct usbnet *dev = netdev_priv(net);
951 if (!dev->mii.mdio_read)
954 mii_ethtool_get_link_ksettings(&dev->mii, cmd);
963 struct usbnet *dev = netdev_priv(net);
966 if (!dev->mii.mdio_write)
969 retval = mii_ethtool_set_link_ksettings(&dev->mii, cmd);
972 if (dev->driver_info->link_reset)
973 dev->driver_info->link_reset(dev);
976 usbnet_update_max_qlen(dev);
984 struct usbnet *dev = netdev_priv(net);
987 dev_fetch_sw_netstats(stats, dev->stats64);
993 struct usbnet *dev = netdev_priv(net);
996 if (dev->driver_info->check_connect)
997 return dev->driver_info->check_connect (dev) == 0;
1000 if (dev->mii.mdio_read)
1001 return mii_link_ok(&dev->mii);
1010 struct usbnet *dev = netdev_priv(net);
1012 if (!dev->mii.mdio_write)
1015 return mii_nway_restart(&dev->mii);
1021 struct usbnet *dev = netdev_priv(net);
1023 strlcpy (info->driver, dev->driver_name, sizeof info->driver);
1024 strlcpy (info->fw_version, dev->driver_info->description,
1026 usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
1032 struct usbnet *dev = netdev_priv(net);
1034 return dev->msg_enable;
1040 struct usbnet *dev = netdev_priv(net);
1042 dev->msg_enable = level;
1060 static void __handle_link_change(struct usbnet *dev)
1062 if (!test_bit(EVENT_DEV_OPEN, &dev->flags))
1065 if (!netif_carrier_ok(dev->net)) {
1067 unlink_urbs(dev, &dev->rxq);
1075 tasklet_schedule(&dev->bh);
1079 usbnet_update_max_qlen(dev);
1081 clear_bit(EVENT_LINK_CHANGE, &dev->flags);
1086 struct usbnet *dev = netdev_priv(net);
1088 usbnet_defer_kevent(dev, EVENT_SET_RX_MODE);
1092 static void __handle_set_rx_mode(struct usbnet *dev)
1094 if (dev->driver_info->set_rx_mode)
1095 (dev->driver_info->set_rx_mode)(dev);
1097 clear_bit(EVENT_SET_RX_MODE, &dev->flags);
1108 struct usbnet *dev =
1113 if (test_bit (EVENT_TX_HALT, &dev->flags)) {
1114 unlink_urbs (dev, &dev->txq);
1115 status = usb_autopm_get_interface(dev->intf);
1118 status = usb_clear_halt (dev->udev, dev->out);
1119 usb_autopm_put_interface(dev->intf);
1123 if (netif_msg_tx_err (dev))
1125 netdev_err(dev->net, "can't clear tx halt, status %d\n",
1128 clear_bit (EVENT_TX_HALT, &dev->flags);
1130 netif_wake_queue (dev->net);
1133 if (test_bit (EVENT_RX_HALT, &dev->flags)) {
1134 unlink_urbs (dev, &dev->rxq);
1135 status = usb_autopm_get_interface(dev->intf);
1138 status = usb_clear_halt (dev->udev, dev->in);
1139 usb_autopm_put_interface(dev->intf);
1143 if (netif_msg_rx_err (dev))
1145 netdev_err(dev->net, "can't clear rx halt, status %d\n",
1148 clear_bit (EVENT_RX_HALT, &dev->flags);
1149 tasklet_schedule (&dev->bh);
1154 if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
1158 if (netif_running (dev->net))
1161 clear_bit (EVENT_RX_MEMORY, &dev->flags);
1163 clear_bit (EVENT_RX_MEMORY, &dev->flags);
1164 status = usb_autopm_get_interface(dev->intf);
1169 if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
1171 usb_autopm_put_interface(dev->intf);
1174 tasklet_schedule (&dev->bh);
1178 if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
1179 const struct driver_info *info = dev->driver_info;
1182 clear_bit (EVENT_LINK_RESET, &dev->flags);
1183 status = usb_autopm_get_interface(dev->intf);
1186 if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
1187 usb_autopm_put_interface(dev->intf);
1189 netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s\n",
1191 dev->udev->bus->bus_name,
1192 dev->udev->devpath,
1195 usb_autopm_put_interface(dev->intf);
1199 __handle_link_change(dev);
1202 if (test_bit (EVENT_LINK_CHANGE, &dev->flags))
1203 __handle_link_change(dev);
1205 if (test_bit (EVENT_SET_RX_MODE, &dev->flags))
1206 __handle_set_rx_mode(dev);
1209 if (dev->flags)
1210 netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags);
1219 struct usbnet *dev = entry->dev;
1222 struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->stats64);
1230 dev->net->stats.tx_errors++;
1234 usbnet_defer_kevent (dev, EVENT_TX_HALT);
1248 usb_mark_last_busy(dev->udev);
1249 if (!timer_pending (&dev->delay)) {
1250 mod_timer (&dev->delay,
1252 netif_dbg(dev, link, dev->net,
1255 netif_stop_queue (dev->net);
1258 netif_dbg(dev, tx_err, dev->net,
1264 usb_autopm_put_interface_async(dev->intf);
1265 (void) defer_bh(dev, skb, &dev->txq, tx_done);
1272 struct usbnet *dev = netdev_priv(net);
1274 unlink_urbs (dev, &dev->txq);
1275 tasklet_schedule (&dev->bh);
1280 if (dev->driver_info->recover)
1281 (dev->driver_info->recover)(dev);
1323 struct usbnet *dev = netdev_priv(net);
1327 const struct driver_info *info = dev->driver_info;
1337 skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
1342 netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb\n");
1348 netif_dbg(dev, tx_err, dev->net, "no urb\n");
1354 entry->dev = dev;
1356 usb_fill_bulk_urb (urb, dev->udev, dev->out,
1358 if (dev->can_dma_sg) {
1371 if (length % dev->maxpacket == 0) {
1380 dev->padding_pkt, 1);
1399 spin_lock_irqsave(&dev->txq.lock, flags);
1400 retval = usb_autopm_get_interface_async(dev->intf);
1402 spin_unlock_irqrestore(&dev->txq.lock, flags);
1406 usb_autopm_put_interface_async(dev->intf);
1407 spin_unlock_irqrestore(&dev->txq.lock, flags);
1413 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
1415 usb_anchor_urb(urb, &dev->deferred);
1419 spin_unlock_irqrestore(&dev->txq.lock, flags);
1420 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
1428 usbnet_defer_kevent (dev, EVENT_TX_HALT);
1429 usb_autopm_put_interface_async(dev->intf);
1432 usb_autopm_put_interface_async(dev->intf);
1433 netif_dbg(dev, tx_err, dev->net,
1438 __usbnet_queue_skb(&dev->txq, skb, tx_start);
1439 if (dev->txq.qlen >= TX_QLEN (dev))
1442 spin_unlock_irqrestore (&dev->txq.lock, flags);
1445 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval);
1447 dev->net->stats.tx_dropped++;
1456 netif_dbg(dev, tx_queued, dev->net,
1465 static int rx_alloc_submit(struct usbnet *dev, gfp_t flags)
1472 for (i = 0; i < 10 && dev->rxq.qlen < RX_QLEN(dev); i++) {
1475 ret = rx_submit(dev, urb, flags);
1493 struct usbnet *dev = from_timer(dev, t, delay);
1497 while ((skb = skb_dequeue (&dev->done))) {
1502 rx_process (dev, skb);
1512 netdev_dbg(dev->net, "bogus skb state %d\n", entry->state);
1517 clear_bit(EVENT_RX_KILL, &dev->flags);
1522 if (waitqueue_active(&dev->wait)) {
1523 if (dev->txq.qlen + dev->rxq.qlen + dev->done.qlen == 0)
1524 wake_up_all(&dev->wait);
1527 } else if (netif_running (dev->net) &&
1528 netif_device_present (dev->net) &&
1529 netif_carrier_ok(dev->net) &&
1530 !timer_pending(&dev->delay) &&
1531 !test_bit(EVENT_RX_PAUSED, &dev->flags) &&
1532 !test_bit(EVENT_RX_HALT, &dev->flags)) {
1533 int temp = dev->rxq.qlen;
1535 if (temp < RX_QLEN(dev)) {
1536 if (rx_alloc_submit(dev, GFP_ATOMIC) == -ENOLINK)
1538 if (temp != dev->rxq.qlen)
1539 netif_dbg(dev, link, dev->net,
1541 temp, dev->rxq.qlen);
1542 if (dev->rxq.qlen < RX_QLEN(dev))
1543 tasklet_schedule (&dev->bh);
1545 if (dev->txq.qlen < TX_QLEN (dev))
1546 netif_wake_queue (dev->net);
1568 struct usbnet *dev;
1573 dev = usb_get_intfdata(intf);
1575 if (!dev)
1580 netif_info(dev, probe, dev->net, "unregister '%s' usb-%s-%s, %s\n",
1581 intf->dev.driver->name,
1583 dev->driver_info->description);
1585 net = dev->net;
1588 while ((urb = usb_get_from_anchor(&dev->deferred))) {
1594 if (dev->driver_info->unbind)
1595 dev->driver_info->unbind (dev, intf);
1597 usb_kill_urb(dev->interrupt);
1598 usb_free_urb(dev->interrupt);
1599 kfree(dev->padding_pkt);
1601 free_percpu(dev->stats64);
1633 struct usbnet *dev;
1640 struct usb_driver *driver = to_usb_driver(udev->dev.driver);
1648 pm_runtime_enable(&udev->dev);
1651 name = udev->dev.driver->name;
1654 dev_dbg (&udev->dev, "blacklisted by %s\n", name);
1663 net = alloc_etherdev(sizeof(*dev));
1668 SET_NETDEV_DEV(net, &udev->dev);
1670 dev = netdev_priv(net);
1671 dev->udev = xdev;
1672 dev->intf = udev;
1673 dev->driver_info = info;
1674 dev->driver_name = name;
1676 dev->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1677 if (!dev->stats64)
1680 dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV
1682 init_waitqueue_head(&dev->wait);
1683 skb_queue_head_init (&dev->rxq);
1684 skb_queue_head_init (&dev->txq);
1685 skb_queue_head_init (&dev->done);
1686 skb_queue_head_init(&dev->rxq_pause);
1687 dev->bh.func = usbnet_bh_tasklet;
1688 dev->bh.data = (unsigned long)&dev->delay;
1689 INIT_WORK (&dev->kevent, usbnet_deferred_kevent);
1690 init_usb_anchor(&dev->deferred);
1691 timer_setup(&dev->delay, usbnet_bh, 0);
1692 mutex_init (&dev->phy_mutex);
1693 mutex_init(&dev->interrupt_mutex);
1694 dev->interrupt_count = 0;
1696 dev->net = net;
1703 dev->hard_mtu = net->mtu + net->hard_header_len;
1714 status = info->bind (dev, udev);
1721 if ((dev->driver_info->flags & FLAG_ETHER) != 0 &&
1722 ((dev->driver_info->flags & FLAG_POINTTOPOINT) == 0 ||
1726 if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1729 if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1733 if ((dev->driver_info->flags & FLAG_NOARP) != 0)
1737 if (net->mtu > (dev->hard_mtu - net->hard_header_len))
1738 net->mtu = dev->hard_mtu - net->hard_header_len;
1740 status = usbnet_get_endpoints (dev, udev);
1746 dev->in = usb_rcvbulkpipe (xdev, info->in);
1747 dev->out = usb_sndbulkpipe (xdev, info->out);
1758 if (status >= 0 && dev->status)
1759 status = init_status (dev, udev);
1763 if (!dev->rx_urb_size)
1764 dev->rx_urb_size = dev->hard_mtu;
1765 dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);
1766 if (dev->maxpacket == 0) {
1776 if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1778 if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1782 usbnet_update_max_qlen(dev);
1784 if (dev->can_dma_sg && !(info->flags & FLAG_SEND_ZLP) &&
1786 dev->padding_pkt = kzalloc(1, GFP_KERNEL);
1787 if (!dev->padding_pkt) {
1796 netif_info(dev, probe, dev->net,
1798 udev->dev.driver->name,
1800 dev->driver_info->description,
1804 usb_set_intfdata (udev, dev);
1808 if (dev->driver_info->flags & FLAG_LINK_INTR)
1809 usbnet_link_change(dev, 0, 0);
1814 kfree(dev->padding_pkt);
1816 usb_free_urb(dev->interrupt);
1819 info->unbind (dev, udev);
1826 cancel_work_sync(&dev->kevent);
1827 del_timer_sync(&dev->delay);
1828 free_percpu(dev->stats64);
1845 struct usbnet *dev = usb_get_intfdata(intf);
1847 if (!dev->suspend_count++) {
1848 spin_lock_irq(&dev->txq.lock);
1850 if (dev->txq.qlen && PMSG_IS_AUTO(message)) {
1851 dev->suspend_count--;
1852 spin_unlock_irq(&dev->txq.lock);
1855 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
1856 spin_unlock_irq(&dev->txq.lock);
1862 netif_device_detach (dev->net);
1863 usbnet_terminate_urbs(dev);
1864 __usbnet_status_stop_force(dev);
1870 netif_device_attach (dev->net);
1878 struct usbnet *dev = usb_get_intfdata(intf);
1883 if (!--dev->suspend_count) {
1885 __usbnet_status_start_force(dev, GFP_NOIO);
1887 spin_lock_irq(&dev->txq.lock);
1888 while ((res = usb_get_from_anchor(&dev->deferred))) {
1896 usb_autopm_put_interface_async(dev->intf);
1898 netif_trans_update(dev->net);
1899 __skb_queue_tail(&dev->txq, skb);
1904 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
1905 spin_unlock_irq(&dev->txq.lock);
1907 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
1911 if (netif_device_present(dev->net) &&
1912 !timer_pending(&dev->delay) &&
1913 !test_bit(EVENT_RX_HALT, &dev->flags))
1914 rx_alloc_submit(dev, GFP_NOIO);
1916 if (!(dev->txq.qlen >= TX_QLEN(dev)))
1917 netif_tx_wake_all_queues(dev->net);
1918 tasklet_schedule (&dev->bh);
1922 if (test_and_clear_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags))
1934 void usbnet_device_suggests_idle(struct usbnet *dev)
1936 if (!test_and_set_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags)) {
1937 dev->intf->needs_remote_wakeup = 1;
1938 usb_autopm_put_interface_async(dev->intf);
1946 int usbnet_manage_power(struct usbnet *dev, int on)
1948 dev->intf->needs_remote_wakeup = on;
1953 void usbnet_link_change(struct usbnet *dev, bool link, bool need_reset)
1957 netif_carrier_on(dev->net);
1959 netif_carrier_off(dev->net);
1962 usbnet_defer_kevent(dev, EVENT_LINK_RESET);
1964 usbnet_defer_kevent(dev, EVENT_LINK_CHANGE);
1969 static int __usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
1975 netdev_dbg(dev->net, "usbnet_read_cmd cmd=0x%02x reqtype=%02x"
1985 err = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
1992 netdev_dbg(dev->net,
2000 static int __usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2007 netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
2023 err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
2036 int usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2041 if (usb_autopm_get_interface(dev->intf) < 0)
2043 ret = __usbnet_read_cmd(dev, cmd, reqtype, value, index,
2045 usb_autopm_put_interface(dev->intf);
2054 int usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2059 if (usb_autopm_get_interface(dev->intf) < 0)
2061 ret = __usbnet_write_cmd(dev, cmd, reqtype, value, index,
2063 usb_autopm_put_interface(dev->intf);
2072 int usbnet_read_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
2075 return __usbnet_read_cmd(dev, cmd, reqtype, value, index,
2084 int usbnet_write_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
2088 return __usbnet_write_cmd(dev, cmd, reqtype, value, index,
2099 dev_dbg(&urb->dev->dev, "%s failed with %d",
2110 int usbnet_write_cmd_async(struct usbnet *dev, u8 cmd, u8 reqtype,
2118 netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
2129 netdev_err(dev->net, "Error allocating buffer"
2145 usb_fill_control_urb(urb, dev->udev,
2146 usb_sndctrlpipe(dev->udev, 0),
2153 netdev_err(dev->net, "Error submitting the control"