1 files changed, 82 insertions, 80 deletions

diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c
index 035fab04c0a0..8e732930d249 100644
--- a/drivers/net/usb/usbnet.c
+++ b/drivers/net/usb/usbnet.c
@@ -243,12 +243,12 @@ void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
         dev->net->stats.rx_bytes += skb->len;
 
         if (netif_msg_rx_status (dev))
-                devdbg (dev, "< rx, len %zu, type 0x%x",
-                        skb->len + sizeof (struct ethhdr), skb->protocol);
+                netdev_dbg(dev->net, "< rx, len %zu, type 0x%x\n",
+                           skb->len + sizeof (struct ethhdr), skb->protocol);
         memset (skb->cb, 0, sizeof (struct skb_data));
         status = netif_rx (skb);
         if (status != NET_RX_SUCCESS && netif_msg_rx_err (dev))
-                devdbg (dev, "netif_rx status %d", status);
+                netdev_dbg(dev->net, "netif_rx status %d\n", status);
 }
 EXPORT_SYMBOL_GPL(usbnet_skb_return);
 
@@ -313,9 +313,9 @@ void usbnet_defer_kevent (struct usbnet *dev, int work)
 {
         set_bit (work, &dev->flags);
         if (!schedule_work (&dev->kevent))
-                deverr (dev, "kevent %d may have been dropped", work);
+                netdev_err(dev->net, "kevent %d may have been dropped\n", work);
         else
-                devdbg (dev, "kevent %d scheduled", work);
+                netdev_dbg(dev->net, "kevent %d scheduled\n", work);
 }
 EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
 
@@ -333,7 +333,7 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
 
         if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {
                 if (netif_msg_rx_err (dev))
-                        devdbg (dev, "no rx skb");
+                        netdev_dbg(dev->net, "no rx skb\n");
                 usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
                 usb_free_urb (urb);
                 return;
@@ -364,12 +364,12 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
                         break;
                 case -ENODEV:
                         if (netif_msg_ifdown (dev))
-                                devdbg (dev, "device gone");
+                                netdev_dbg(dev->net, "device gone\n");
                         netif_device_detach (dev->net);
                         break;
                 default:
                         if (netif_msg_rx_err (dev))
-                                devdbg (dev, "rx submit, %d", retval);
+                                netdev_dbg(dev->net, "rx submit, %d\n", retval);
                         tasklet_schedule (&dev->bh);
                         break;
                 case 0:
@@ -377,7 +377,7 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
                 }
         } else {
                 if (netif_msg_ifdown (dev))
-                        devdbg (dev, "rx: stopped");
+                        netdev_dbg(dev->net, "rx: stopped\n");
                 retval = -ENOLINK;
         }
         spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
@@ -401,7 +401,7 @@ static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
                 usbnet_skb_return (dev, skb);
         else {
                 if (netif_msg_rx_err (dev))
-                        devdbg (dev, "drop");
+                        netdev_dbg(dev->net, "drop\n");
 error:
                 dev->net->stats.rx_errors++;
                 skb_queue_tail (&dev->done, skb);
@@ -429,7 +429,7 @@ static void rx_complete (struct urb *urb)
                         dev->net->stats.rx_errors++;
                         dev->net->stats.rx_length_errors++;
                         if (netif_msg_rx_err (dev))
-                                devdbg (dev, "rx length %d", skb->len);
+                                netdev_dbg(dev->net, "rx length %d\n", skb->len);
                 }
                 break;
 
@@ -447,7 +447,7 @@ static void rx_complete (struct urb *urb)
         case -ECONNRESET:               /* async unlink */
         case -ESHUTDOWN:                /* hardware gone */
                 if (netif_msg_ifdown (dev))
-                        devdbg (dev, "rx shutdown, code %d", urb_status);
+                        netdev_dbg(dev->net, "rx shutdown, code %d\n", urb_status);
                 goto block;
 
         /* we get controller i/o faults during khubd disconnect() delays.
@@ -461,7 +461,7 @@ static void rx_complete (struct urb *urb)
                 if (!timer_pending (&dev->delay)) {
                         mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
                         if (netif_msg_link (dev))
-                                devdbg (dev, "rx throttle %d", urb_status);
+                                netdev_dbg(dev->net, "rx throttle %d\n", urb_status);
                 }
 block:
                 entry->state = rx_cleanup;
@@ -478,7 +478,7 @@ block:
                 entry->state = rx_cleanup;
                 dev->net->stats.rx_errors++;
                 if (netif_msg_rx_err (dev))
-                        devdbg (dev, "rx status %d", urb_status);
+                        netdev_dbg(dev->net, "rx status %d\n", urb_status);
                 break;
         }
 
@@ -493,7 +493,7 @@ block:
                 usb_free_urb (urb);
         }
         if (netif_msg_rx_err (dev))
-                devdbg (dev, "no read resubmitted");
+                netdev_dbg(dev->net, "no read resubmitted\n");
 }
 
 static void intr_complete (struct urb *urb)
@@ -511,14 +511,14 @@ static void intr_complete (struct urb *urb)
         case -ENOENT:           /* urb killed */
         case -ESHUTDOWN:        /* hardware gone */
                 if (netif_msg_ifdown (dev))
-                        devdbg (dev, "intr shutdown, code %d", status);
+                        netdev_dbg(dev->net, "intr shutdown, code %d\n", status);
                 return;
 
         /* NOTE:  not throttling like RX/TX, since this endpoint
          * already polls infrequently
          */
         default:
-                devdbg (dev, "intr status %d", status);
+                netdev_dbg(dev->net, "intr status %d\n", status);
                 break;
         }
 
@@ -528,7 +528,7 @@ static void intr_complete (struct urb *urb)
         memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
         status = usb_submit_urb (urb, GFP_ATOMIC);
         if (status != 0 && netif_msg_timer (dev))
-                deverr(dev, "intr resubmit --> %d", status);
+                netdev_err(dev->net, "intr resubmit --> %d\n", status);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -537,7 +537,7 @@ void usbnet_pause_rx(struct usbnet *dev)
         set_bit(EVENT_RX_PAUSED, &dev->flags);
 
         if (netif_msg_rx_status(dev))
-                devdbg(dev, "paused rx queue enabled");
+                netdev_dbg(dev->net, "paused rx queue enabled\n");
 }
 EXPORT_SYMBOL_GPL(usbnet_pause_rx);
 
@@ -556,7 +556,8 @@ void usbnet_resume_rx(struct usbnet *dev)
         tasklet_schedule(&dev->bh);
 
         if (netif_msg_rx_status(dev))
-                devdbg(dev, "paused rx queue disabled, %d skbs requeued", num);
+                netdev_dbg(dev->net, "paused rx queue disabled, %d skbs requeued\n",
+                           num);
 }
 EXPORT_SYMBOL_GPL(usbnet_resume_rx);
 
@@ -589,7 +590,7 @@ static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q)
                 // these (async) unlinks complete immediately
                 retval = usb_unlink_urb (urb);
                 if (retval != -EINPROGRESS && retval != 0)
-                        devdbg (dev, "unlink urb err, %d", retval);
+                        netdev_dbg(dev->net, "unlink urb err, %d\n", retval);
                 else
                         count++;
         }
@@ -632,8 +633,8 @@ static void usbnet_terminate_urbs(struct usbnet *dev)
                         schedule_timeout(UNLINK_TIMEOUT_MS);
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         if (netif_msg_ifdown(dev))
-                                devdbg(dev, "waited for %d urb completions",
-                                        temp);
+                                netdev_dbg(dev->net, "waited for %d urb completions\n",
+                                           temp);
         }
         set_current_state(TASK_RUNNING);
         dev->wait = NULL;
@@ -649,21 +650,20 @@ int usbnet_stop (struct net_device *net)
         netif_stop_queue (net);
 
         if (netif_msg_ifdown (dev))
-                devinfo (dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld",
-                        net->stats.rx_packets, net->stats.tx_packets,
-                        net->stats.rx_errors, net->stats.tx_errors
-                        );
+                netdev_info(dev->net, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
+                            net->stats.rx_packets, net->stats.tx_packets,
+                            net->stats.rx_errors, net->stats.tx_errors);
 
         /* allow minidriver to stop correctly (wireless devices to turn off
          * radio etc) */
         if (info->stop) {
                 retval = info->stop(dev);
                 if (retval < 0 && netif_msg_ifdown(dev))
-                        devinfo(dev,
-                                "stop fail (%d) usbnet usb-%s-%s, %s",
-                                retval,
-                                dev->udev->bus->bus_name, dev->udev->devpath,
-                                info->description);
+                        netdev_info(dev->net,
+                                    "stop fail (%d) usbnet usb-%s-%s, %s\n",
+                                    retval,
+                                    dev->udev->bus->bus_name, dev->udev->devpath,
+                                    info->description);
         }
 
         if (!(info->flags & FLAG_AVOID_UNLINK_URBS))
@@ -703,29 +703,31 @@ int usbnet_open (struct net_device *net)
 
         if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
                 if (netif_msg_ifup (dev))
-                        devinfo (dev,
-                                "resumption fail (%d) usbnet usb-%s-%s, %s",
-                                retval,
-                                dev->udev->bus->bus_name, dev->udev->devpath,
-                        info->description);
+                        netdev_info(dev->net,
+                                    "resumption fail (%d) usbnet usb-%s-%s, %s\n",
+                                    retval,
+                                    dev->udev->bus->bus_name,
+                                    dev->udev->devpath,
+                                    info->description);
                 goto done_nopm;
         }
 
         // put into "known safe" state
         if (info->reset && (retval = info->reset (dev)) < 0) {
                 if (netif_msg_ifup (dev))
-                        devinfo (dev,
-                                "open reset fail (%d) usbnet usb-%s-%s, %s",
-                                retval,
-                                dev->udev->bus->bus_name, dev->udev->devpath,
-                        info->description);
+                        netdev_info(dev->net,
+                                    "open reset fail (%d) usbnet usb-%s-%s, %s\n",
+                                    retval,
+                                    dev->udev->bus->bus_name,
+                                    dev->udev->devpath,
+                                    info->description);
                 goto done;
         }
 
         // insist peer be connected
         if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
                 if (netif_msg_ifup (dev))
-                        devdbg (dev, "can't open; %d", retval);
+                        netdev_dbg(dev->net, "can't open; %d\n", retval);
                 goto done;
         }
 
@@ -734,7 +736,7 @@ int usbnet_open (struct net_device *net)
                 retval = usb_submit_urb (dev->interrupt, GFP_KERNEL);
                 if (retval < 0) {
                         if (netif_msg_ifup (dev))
-                                deverr (dev, "intr submit %d", retval);
+                                netdev_err(dev->net, "intr submit %d\n", retval);
                         goto done;
                 }
         }
@@ -756,10 +758,9 @@ int usbnet_open (struct net_device *net)
                 else
                         framing = "simple";
 
-                devinfo (dev, "open: enable queueing "
-                                "(rx %d, tx %d) mtu %d %s framing",
-                        (int)RX_QLEN (dev), (int)TX_QLEN (dev), dev->net->mtu,
-                        framing);
+                netdev_info(dev->net, "open: enable queueing (rx %d, tx %d) mtu %d %s framing\n",
+                            (int)RX_QLEN(dev), (int)TX_QLEN(dev),
+                            dev->net->mtu, framing);
         }
 
         // delay posting reads until we're fully open
@@ -908,8 +909,8 @@ kevent (struct work_struct *work)
                     status != -ESHUTDOWN) {
                         if (netif_msg_tx_err (dev))
 fail_pipe:
-                                deverr (dev, "can't clear tx halt, status %d",
-                                        status);
+                                netdev_err(dev->net, "can't clear tx halt, status %d\n",
+                                           status);
                 } else {
                         clear_bit (EVENT_TX_HALT, &dev->flags);
                         if (status != -ESHUTDOWN)
@@ -928,8 +929,8 @@ fail_pipe:
                     status != -ESHUTDOWN) {
                         if (netif_msg_rx_err (dev))
 fail_halt:
-                                deverr (dev, "can't clear rx halt, status %d",
-                                        status);
+                                netdev_err(dev->net, "can't clear rx halt, status %d\n",
+                                           status);
                 } else {
                         clear_bit (EVENT_RX_HALT, &dev->flags);
                         tasklet_schedule (&dev->bh);
@@ -967,18 +968,18 @@ fail_lowmem:
                 if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
                         usb_autopm_put_interface(dev->intf);
 skip_reset:
-                        devinfo(dev, "link reset failed (%d) usbnet usb-%s-%s, %s",
-                                retval,
-                                dev->udev->bus->bus_name, dev->udev->devpath,
-                                info->description);
+                        netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s\n",
+                                    retval,
+                                    dev->udev->bus->bus_name,
+                                    dev->udev->devpath,
+                                    info->description);
                 } else {
                         usb_autopm_put_interface(dev->intf);
                 }
         }
 
         if (dev->flags)
-                devdbg (dev, "kevent done, flags = 0x%lx",
-                        dev->flags);
+                netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -1015,14 +1016,15 @@ static void tx_complete (struct urb *urb)
                                 mod_timer (&dev->delay,
                                         jiffies + THROTTLE_JIFFIES);
                                 if (netif_msg_link (dev))
-                                        devdbg (dev, "tx throttle %d",
-                                                        urb->status);
+                                        netdev_dbg(dev->net, "tx throttle %d\n",
+                                                   urb->status);
                         }
                         netif_stop_queue (dev->net);
                         break;
                 default:
                         if (netif_msg_tx_err (dev))
-                                devdbg (dev, "tx err %d", entry->urb->status);
+                                netdev_dbg(dev->net, "tx err %d\n",
+                                           entry->urb->status);
                         break;
                 }
         }
@@ -1065,7 +1067,7 @@ netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
                 skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
                 if (!skb) {
                         if (netif_msg_tx_err (dev))
-                                devdbg (dev, "can't tx_fixup skb");
+                                netdev_dbg(dev->net, "can't tx_fixup skb\n");
                         goto drop;
                 }
         }
@@ -1073,7 +1075,7 @@ netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
 
         if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {
                 if (netif_msg_tx_err (dev))
-                        devdbg (dev, "no urb");
+                        netdev_dbg(dev->net, "no urb\n");
                 goto drop;
         }
 
@@ -1113,7 +1115,7 @@ netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
                 /* no use to process more packets */
                 netif_stop_queue(net);
                 spin_unlock_irqrestore(&dev->txq.lock, flags);
-                devdbg(dev, "Delaying transmission for resumption");
+                netdev_dbg(dev->net, "Delaying transmission for resumption\n");
                 goto deferred;
         }
 #endif
@@ -1127,7 +1129,7 @@ netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
         default:
                 usb_autopm_put_interface_async(dev->intf);
                 if (netif_msg_tx_err (dev))
-                        devdbg (dev, "tx: submit urb err %d", retval);
+                        netdev_dbg(dev->net, "tx: submit urb err %d\n", retval);
                 break;
         case 0:
                 net->trans_start = jiffies;
@@ -1139,15 +1141,15 @@ netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
 
         if (retval) {
                 if (netif_msg_tx_err (dev))
-                        devdbg (dev, "drop, code %d", retval);
+                        netdev_dbg(dev->net, "drop, code %d\n", retval);
 drop:
                 dev->net->stats.tx_dropped++;
                 if (skb)
                         dev_kfree_skb_any (skb);
                 usb_free_urb (urb);
         } else if (netif_msg_tx_queued (dev)) {
-                devdbg (dev, "> tx, len %d, type 0x%x",
-                        length, skb->protocol);
+                netdev_dbg(dev->net, "> tx, len %d, type 0x%x\n",
+                           length, skb->protocol);
         }
 #ifdef CONFIG_PM
 deferred:
@@ -1179,7 +1181,7 @@ static void usbnet_bh (unsigned long param)
                         dev_kfree_skb (skb);
                         continue;
                 default:
-                        devdbg (dev, "bogus skb state %d", entry->state);
+                        netdev_dbg(dev->net, "bogus skb state %d\n", entry->state);
                 }
         }
 
@@ -1208,8 +1210,8 @@ static void usbnet_bh (unsigned long param)
                                         rx_submit (dev, urb, GFP_ATOMIC);
                         }
                         if (temp != dev->rxq.qlen && netif_msg_link (dev))
-                                devdbg (dev, "rxqlen %d --> %d",
-                                                temp, dev->rxq.qlen);
+                                netdev_dbg(dev->net, "rxqlen %d --> %d\n",
+                                           temp, dev->rxq.qlen);
                         if (dev->rxq.qlen < qlen)
                                 tasklet_schedule (&dev->bh);
                 }
@@ -1241,10 +1243,10 @@ void usbnet_disconnect (struct usb_interface *intf)
         xdev = interface_to_usbdev (intf);
 
         if (netif_msg_probe (dev))
-                devinfo (dev, "unregister '%s' usb-%s-%s, %s",
-                        intf->dev.driver->name,
-                        xdev->bus->bus_name, xdev->devpath,
-                        dev->driver_info->description);
+                netdev_info(dev->net, "unregister '%s' usb-%s-%s, %s\n",
+                            intf->dev.driver->name,
+                            xdev->bus->bus_name, xdev->devpath,
+                            dev->driver_info->description);
 
         net = dev->net;
         unregister_netdev (net);
@@ -1408,11 +1410,11 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
         if (status)
                 goto out3;
         if (netif_msg_probe (dev))
-                devinfo (dev, "register '%s' at usb-%s-%s, %s, %pM",
-                        udev->dev.driver->name,
-                        xdev->bus->bus_name, xdev->devpath,
-                        dev->driver_info->description,
-                        net->dev_addr);
+                netdev_info(dev->net, "register '%s' at usb-%s-%s, %s, %pM\n",
+                            udev->dev.driver->name,
+                            xdev->bus->bus_name, xdev->devpath,
+                            dev->driver_info->description,
+                            net->dev_addr);
 
         // ok, it's ready to go.
         usb_set_intfdata (udev, dev);