1 files changed, 28 insertions, 33 deletions

diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 9034a05734ef..ef1e3d1173c4 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -574,7 +574,7 @@ static void tg3_restart_ints(struct tg3 *tp)
 static inline void tg3_netif_stop(struct tg3 *tp)
 {
         tp->dev->trans_start = jiffies; /* prevent tx timeout */
-        netif_poll_disable(tp->dev);
+        napi_disable(&tp->napi);
         netif_tx_disable(tp->dev);
 }
 
@@ -585,7 +585,7 @@ static inline void tg3_netif_start(struct tg3 *tp)
          * so long as all callers are assured to have free tx slots
          * (such as after tg3_init_hw)
          */
-        netif_poll_enable(tp->dev);
+        napi_enable(&tp->napi);
         tp->hw_status->status |= SD_STATUS_UPDATED;
         tg3_enable_ints(tp);
 }
@@ -3471,11 +3471,12 @@ next_pkt_nopost:
         return received;
 }
 
-static int tg3_poll(struct net_device *netdev, int *budget)
+static int tg3_poll(struct napi_struct *napi, int budget)
 {
-        struct tg3 *tp = netdev_priv(netdev);
+        struct tg3 *tp = container_of(napi, struct tg3, napi);
+        struct net_device *netdev = tp->dev;
         struct tg3_hw_status *sblk = tp->hw_status;
-        int done;
+        int work_done = 0;
 
         /* handle link change and other phy events */
         if (!(tp->tg3_flags &
@@ -3494,7 +3495,7 @@ static int tg3_poll(struct net_device *netdev, int *budget)
         if (sblk->idx[0].tx_consumer != tp->tx_cons) {
                 tg3_tx(tp);
                 if (unlikely(tp->tg3_flags & TG3_FLAG_TX_RECOVERY_PENDING)) {
-                        netif_rx_complete(netdev);
+                        netif_rx_complete(netdev, napi);
                         schedule_work(&tp->reset_task);
                         return 0;
                 }
@@ -3502,20 +3503,10 @@ static int tg3_poll(struct net_device *netdev, int *budget)
 
         /* run RX thread, within the bounds set by NAPI.
          * All RX "locking" is done by ensuring outside
-         * code synchronizes with dev->poll()
+         * code synchronizes with tg3->napi.poll()
          */
-        if (sblk->idx[0].rx_producer != tp->rx_rcb_ptr) {
-                int orig_budget = *budget;
-                int work_done;
-
-                if (orig_budget > netdev->quota)
-                        orig_budget = netdev->quota;
-
-                work_done = tg3_rx(tp, orig_budget);
-
-                *budget -= work_done;
-                netdev->quota -= work_done;
-        }
+        if (sblk->idx[0].rx_producer != tp->rx_rcb_ptr)
+                work_done = tg3_rx(tp, budget);
 
         if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) {
                 tp->last_tag = sblk->status_tag;
@@ -3524,13 +3515,12 @@ static int tg3_poll(struct net_device *netdev, int *budget)
                 sblk->status &= ~SD_STATUS_UPDATED;
 
         /* if no more work, tell net stack and NIC we're done */
-        done = !tg3_has_work(tp);
-        if (done) {
-                netif_rx_complete(netdev);
+        if (!tg3_has_work(tp)) {
+                netif_rx_complete(netdev, napi);
                 tg3_restart_ints(tp);
         }
 
-        return (done ? 0 : 1);
+        return work_done;
 }
 
 static void tg3_irq_quiesce(struct tg3 *tp)
@@ -3577,7 +3567,7 @@ static irqreturn_t tg3_msi_1shot(int irq, void *dev_id)
         prefetch(&tp->rx_rcb[tp->rx_rcb_ptr]);
 
         if (likely(!tg3_irq_sync(tp)))
-                netif_rx_schedule(dev);         /* schedule NAPI poll */
+                netif_rx_schedule(dev, &tp->napi);
 
         return IRQ_HANDLED;
 }
@@ -3602,7 +3592,7 @@ static irqreturn_t tg3_msi(int irq, void *dev_id)
          */
         tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
         if (likely(!tg3_irq_sync(tp)))
-                netif_rx_schedule(dev);         /* schedule NAPI poll */
+                netif_rx_schedule(dev, &tp->napi);
 
         return IRQ_RETVAL(1);
 }
@@ -3644,7 +3634,7 @@ static irqreturn_t tg3_interrupt(int irq, void *dev_id)
         sblk->status &= ~SD_STATUS_UPDATED;
         if (likely(tg3_has_work(tp))) {
                 prefetch(&tp->rx_rcb[tp->rx_rcb_ptr]);
-                netif_rx_schedule(dev);         /* schedule NAPI poll */
+                netif_rx_schedule(dev, &tp->napi);
         } else {
                 /* No work, shared interrupt perhaps?  re-enable
                  * interrupts, and flush that PCI write
@@ -3690,7 +3680,7 @@ static irqreturn_t tg3_interrupt_tagged(int irq, void *dev_id)
         tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
         if (tg3_irq_sync(tp))
                 goto out;
-        if (netif_rx_schedule_prep(dev)) {
+        if (netif_rx_schedule_prep(dev, &tp->napi)) {
                 prefetch(&tp->rx_rcb[tp->rx_rcb_ptr]);
                 /* Update last_tag to mark that this status has been
                  * seen. Because interrupt may be shared, we may be
@@ -3698,7 +3688,7 @@ static irqreturn_t tg3_interrupt_tagged(int irq, void *dev_id)
                  * if tg3_poll() is not scheduled.
                  */
                 tp->last_tag = sblk->status_tag;
-                __netif_rx_schedule(dev);
+                __netif_rx_schedule(dev, &tp->napi);
         }
 out:
         return IRQ_RETVAL(handled);
@@ -3737,7 +3727,7 @@ static int tg3_restart_hw(struct tg3 *tp, int reset_phy)
                 tg3_full_unlock(tp);
                 del_timer_sync(&tp->timer);
                 tp->irq_sync = 0;
-                netif_poll_enable(tp->dev);
+                napi_enable(&tp->napi);
                 dev_close(tp->dev);
                 tg3_full_lock(tp, 0);
         }
@@ -3932,7 +3922,7 @@ static int tg3_start_xmit(struct sk_buff *skb, struct net_device *dev)
         len = skb_headlen(skb);
 
         /* We are running in BH disabled context with netif_tx_lock
-         * and TX reclaim runs via tp->poll inside of a software
+         * and TX reclaim runs via tp->napi.poll inside of a software
          * interrupt.  Furthermore, IRQ processing runs lockless so we have
          * no IRQ context deadlocks to worry about either.  Rejoice!
          */
@@ -4087,7 +4077,7 @@ static int tg3_start_xmit_dma_bug(struct sk_buff *skb, struct net_device *dev)
         len = skb_headlen(skb);
 
         /* We are running in BH disabled context with netif_tx_lock
-         * and TX reclaim runs via tp->poll inside of a software
+         * and TX reclaim runs via tp->napi.poll inside of a software
          * interrupt.  Furthermore, IRQ processing runs lockless so we have
          * no IRQ context deadlocks to worry about either.  Rejoice!
          */
@@ -7147,6 +7137,8 @@ static int tg3_open(struct net_device *dev)
                 return err;
         }
 
+        napi_enable(&tp->napi);
+
         tg3_full_lock(tp, 0);
 
         err = tg3_init_hw(tp, 1);
@@ -7174,6 +7166,7 @@ static int tg3_open(struct net_device *dev)
         tg3_full_unlock(tp);
 
         if (err) {
+                napi_disable(&tp->napi);
                 free_irq(tp->pdev->irq, dev);
                 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
                         pci_disable_msi(tp->pdev);
@@ -7199,6 +7192,8 @@ static int tg3_open(struct net_device *dev)
 
                         tg3_full_unlock(tp);
 
+                        napi_disable(&tp->napi);
+
                         return err;
                 }
 
@@ -7460,6 +7455,7 @@ static int tg3_close(struct net_device *dev)
 {
         struct tg3 *tp = netdev_priv(dev);
 
+        napi_disable(&tp->napi);
         cancel_work_sync(&tp->reset_task);
 
         netif_stop_queue(dev);
@@ -11900,9 +11896,8 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
         dev->set_mac_address = tg3_set_mac_addr;
         dev->do_ioctl = tg3_ioctl;
         dev->tx_timeout = tg3_tx_timeout;
-        dev->poll = tg3_poll;
+        netif_napi_add(dev, &tp->napi, tg3_poll, 64);
         dev->ethtool_ops = &tg3_ethtool_ops;
-        dev->weight = 64;
         dev->watchdog_timeo = TG3_TX_TIMEOUT;
         dev->change_mtu = tg3_change_mtu;
         dev->irq = pdev->irq;