6 files changed, 77 insertions, 31 deletions

diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index b124eee4eb10..ebb726e655ac 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -1706,14 +1706,15 @@ static void __b44_set_rx_mode(struct net_device *dev)
 
                 __b44_set_mac_addr(bp);
 
-                if (dev->flags & IFF_ALLMULTI)
+                if ((dev->flags & IFF_ALLMULTI) ||
+                    (dev->mc_count > B44_MCAST_TABLE_SIZE))
                         val |= RXCONFIG_ALLMULTI;
                 else
                         i = __b44_load_mcast(bp, dev);
 
-                for (; i < 64; i++) {
+                for (; i < 64; i++)
                         __b44_cam_write(bp, zero, i);
-                }
+
                 bw32(bp, B44_RXCONFIG, val);
                 val = br32(bp, B44_CAM_CTRL);
                 bw32(bp, B44_CAM_CTRL, val | CAM_CTRL_ENABLE);
diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.c
index e83bc825f6af..32923162179e 100644
--- a/drivers/net/bonding/bond_alb.c
+++ b/drivers/net/bonding/bond_alb.c
@@ -1433,7 +1433,7 @@ void bond_alb_monitor(struct bonding *bond)
                  * write lock to protect from other code that also
                  * sets the promiscuity.
                  */
-                write_lock(&bond->curr_slave_lock);
+                write_lock_bh(&bond->curr_slave_lock);
 
                 if (bond_info->primary_is_promisc &&
                     (++bond_info->rlb_promisc_timeout_counter >= RLB_PROMISC_TIMEOUT)) {
@@ -1448,7 +1448,7 @@ void bond_alb_monitor(struct bonding *bond)
                         bond_info->primary_is_promisc = 0;
                 }
 
-                write_unlock(&bond->curr_slave_lock);
+                write_unlock_bh(&bond->curr_slave_lock);
 
                 if (bond_info->rlb_rebalance) {
                         bond_info->rlb_rebalance = 0;
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 99b7a411db28..c5ed635bce36 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -2497,6 +2497,7 @@ static irqreturn_t nv_nic_irq_tx(int foo, void *data)
         u8 __iomem *base = get_hwbase(dev);
         u32 events;
         int i;
+        unsigned long flags;
 
         dprintk(KERN_DEBUG "%s: nv_nic_irq_tx\n", dev->name);
 
@@ -2508,16 +2509,16 @@ static irqreturn_t nv_nic_irq_tx(int foo, void *data)
                 if (!(events & np->irqmask))
                         break;
 
-                spin_lock_irq(&np->lock);
+                spin_lock_irqsave(&np->lock, flags);
                 nv_tx_done(dev);
-                spin_unlock_irq(&np->lock);
+                spin_unlock_irqrestore(&np->lock, flags);
 
                 if (events & (NVREG_IRQ_TX_ERR)) {
                         dprintk(KERN_DEBUG "%s: received irq with events 0x%x. Probably TX fail.\n",
                                                 dev->name, events);
                 }
                 if (i > max_interrupt_work) {
-                        spin_lock_irq(&np->lock);
+                        spin_lock_irqsave(&np->lock, flags);
                         /* disable interrupts on the nic */
                         writel(NVREG_IRQ_TX_ALL, base + NvRegIrqMask);
                         pci_push(base);
@@ -2527,7 +2528,7 @@ static irqreturn_t nv_nic_irq_tx(int foo, void *data)
                                 mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
                         }
                         printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq_tx.\n", dev->name, i);
-                        spin_unlock_irq(&np->lock);
+                        spin_unlock_irqrestore(&np->lock, flags);
                         break;
                 }
 
@@ -2601,6 +2602,7 @@ static irqreturn_t nv_nic_irq_rx(int foo, void *data)
         u8 __iomem *base = get_hwbase(dev);
         u32 events;
         int i;
+        unsigned long flags;
 
         dprintk(KERN_DEBUG "%s: nv_nic_irq_rx\n", dev->name);
 
@@ -2614,14 +2616,14 @@ static irqreturn_t nv_nic_irq_rx(int foo, void *data)
 
                 nv_rx_process(dev, dev->weight);
                 if (nv_alloc_rx(dev)) {
-                        spin_lock_irq(&np->lock);
+                        spin_lock_irqsave(&np->lock, flags);
                         if (!np->in_shutdown)
                                 mod_timer(&np->oom_kick, jiffies + OOM_REFILL);
-                        spin_unlock_irq(&np->lock);
+                        spin_unlock_irqrestore(&np->lock, flags);
                 }
 
                 if (i > max_interrupt_work) {
-                        spin_lock_irq(&np->lock);
+                        spin_lock_irqsave(&np->lock, flags);
                         /* disable interrupts on the nic */
                         writel(NVREG_IRQ_RX_ALL, base + NvRegIrqMask);
                         pci_push(base);
@@ -2631,7 +2633,7 @@ static irqreturn_t nv_nic_irq_rx(int foo, void *data)
                                 mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
                         }
                         printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq_rx.\n", dev->name, i);
-                        spin_unlock_irq(&np->lock);
+                        spin_unlock_irqrestore(&np->lock, flags);
                         break;
                 }
         }
@@ -2648,6 +2650,7 @@ static irqreturn_t nv_nic_irq_other(int foo, void *data)
         u8 __iomem *base = get_hwbase(dev);
         u32 events;
         int i;
+        unsigned long flags;
 
         dprintk(KERN_DEBUG "%s: nv_nic_irq_other\n", dev->name);
 
@@ -2660,14 +2663,14 @@ static irqreturn_t nv_nic_irq_other(int foo, void *data)
                         break;
 
                 if (events & NVREG_IRQ_LINK) {
-                        spin_lock_irq(&np->lock);
+                        spin_lock_irqsave(&np->lock, flags);
                         nv_link_irq(dev);
-                        spin_unlock_irq(&np->lock);
+                        spin_unlock_irqrestore(&np->lock, flags);
                 }
                 if (np->need_linktimer && time_after(jiffies, np->link_timeout)) {
-                        spin_lock_irq(&np->lock);
+                        spin_lock_irqsave(&np->lock, flags);
                         nv_linkchange(dev);
-                        spin_unlock_irq(&np->lock);
+                        spin_unlock_irqrestore(&np->lock, flags);
                         np->link_timeout = jiffies + LINK_TIMEOUT;
                 }
                 if (events & (NVREG_IRQ_UNKNOWN)) {
@@ -2675,7 +2678,7 @@ static irqreturn_t nv_nic_irq_other(int foo, void *data)
                                                 dev->name, events);
                 }
                 if (i > max_interrupt_work) {
-                        spin_lock_irq(&np->lock);
+                        spin_lock_irqsave(&np->lock, flags);
                         /* disable interrupts on the nic */
                         writel(NVREG_IRQ_OTHER, base + NvRegIrqMask);
                         pci_push(base);
@@ -2685,7 +2688,7 @@ static irqreturn_t nv_nic_irq_other(int foo, void *data)
                                 mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
                         }
                         printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq_other.\n", dev->name, i);
-                        spin_unlock_irq(&np->lock);
+                        spin_unlock_irqrestore(&np->lock, flags);
                         break;
                 }
 
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index 4bac3cd8f235..bf414a93facb 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -213,6 +213,7 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
                 }
 
                 free_index = pool->consumer_index++ % pool->size;
+                pool->consumer_index = free_index;
                 index = pool->free_map[free_index];
 
                 ibmveth_assert(index != IBM_VETH_INVALID_MAP);
@@ -238,7 +239,10 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
                 if(lpar_rc != H_SUCCESS) {
                         pool->free_map[free_index] = index;
                         pool->skbuff[index] = NULL;
-                        pool->consumer_index--;
+                        if (pool->consumer_index == 0)
+                                pool->consumer_index = pool->size - 1;
+                        else
+                                pool->consumer_index--;
                         dma_unmap_single(&adapter->vdev->dev,
                                         pool->dma_addr[index], pool->buff_size,
                                         DMA_FROM_DEVICE);
@@ -326,6 +330,7 @@ static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter *adapter, u64
                          DMA_FROM_DEVICE);
 
         free_index = adapter->rx_buff_pool[pool].producer_index++ % adapter->rx_buff_pool[pool].size;
+        adapter->rx_buff_pool[pool].producer_index = free_index;
         adapter->rx_buff_pool[pool].free_map[free_index] = index;
 
         mb();
@@ -437,6 +442,31 @@ static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
                                                  &adapter->rx_buff_pool[i]);
 }
 
+static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter,
+        union ibmveth_buf_desc rxq_desc, u64 mac_address)
+{
+        int rc, try_again = 1;
+
+        /* After a kexec the adapter will still be open, so our attempt to
+        * open it will fail. So if we get a failure we free the adapter and
+        * try again, but only once. */
+retry:
+        rc = h_register_logical_lan(adapter->vdev->unit_address,
+                                    adapter->buffer_list_dma, rxq_desc.desc,
+                                    adapter->filter_list_dma, mac_address);
+
+        if (rc != H_SUCCESS && try_again) {
+                do {
+                        rc = h_free_logical_lan(adapter->vdev->unit_address);
+                } while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
+
+                try_again = 0;
+                goto retry;
+        }
+
+        return rc;
+}
+
 static int ibmveth_open(struct net_device *netdev)
 {
         struct ibmveth_adapter *adapter = netdev->priv;
@@ -502,12 +532,9 @@ static int ibmveth_open(struct net_device *netdev)
         ibmveth_debug_printk("filter list @ 0x%p\n", adapter->filter_list_addr);
         ibmveth_debug_printk("receive q   @ 0x%p\n", adapter->rx_queue.queue_addr);
 
+        h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
 
-        lpar_rc = h_register_logical_lan(adapter->vdev->unit_address,
-                                         adapter->buffer_list_dma,
-                                         rxq_desc.desc,
-                                         adapter->filter_list_dma,
-                                         mac_address);
+        lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address);
 
         if(lpar_rc != H_SUCCESS) {
                 ibmveth_error_printk("h_register_logical_lan failed with %ld\n", lpar_rc);
@@ -905,6 +932,14 @@ static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
         return -EINVAL;
 }
 
+#ifdef CONFIG_NET_POLL_CONTROLLER
+static void ibmveth_poll_controller(struct net_device *dev)
+{
+        ibmveth_replenish_task(dev->priv);
+        ibmveth_interrupt(dev->irq, dev, NULL);
+}
+#endif
+
 static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
 {
         int rc, i;
@@ -977,6 +1012,9 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
         netdev->ethtool_ops           = &netdev_ethtool_ops;
         netdev->change_mtu         = ibmveth_change_mtu;
         SET_NETDEV_DEV(netdev, &dev->dev);
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        netdev->poll_controller = ibmveth_poll_controller;
+#endif
         netdev->features |= NETIF_F_LLTX;
         spin_lock_init(&adapter->stats_lock);
 
@@ -1132,7 +1170,9 @@ static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
 {
         struct proc_dir_entry *entry;
         if (ibmveth_proc_dir) {
-                entry = create_proc_entry(adapter->netdev->name, S_IFREG, ibmveth_proc_dir);
+                char u_addr[10];
+                sprintf(u_addr, "%x", adapter->vdev->unit_address);
+                entry = create_proc_entry(u_addr, S_IFREG, ibmveth_proc_dir);
                 if (!entry) {
                         ibmveth_error_printk("Cannot create adapter proc entry");
                 } else {
@@ -1147,7 +1187,9 @@ static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
 static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter)
 {
         if (ibmveth_proc_dir) {
-                remove_proc_entry(adapter->netdev->name, ibmveth_proc_dir);
+                char u_addr[10];
+                sprintf(u_addr, "%x", adapter->vdev->unit_address);
+                remove_proc_entry(u_addr, ibmveth_proc_dir);
         }
 }
 
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index 2ffa3a59e704..9997081c6dae 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -2155,7 +2155,7 @@ static void eth_update_mib_counters(struct mv643xx_private *mp)
         for (offset = ETH_MIB_BAD_OCTETS_RECEIVED;
                         offset <= ETH_MIB_FRAMES_1024_TO_MAX_OCTETS;
                         offset += 4)
-                *(u32 *)((char *)p + offset) = read_mib(mp, offset);
+                *(u32 *)((char *)p + offset) += read_mib(mp, offset);
 
         p->good_octets_sent += read_mib(mp, ETH_MIB_GOOD_OCTETS_SENT_LOW);
         p->good_octets_sent +=
@@ -2164,7 +2164,7 @@ static void eth_update_mib_counters(struct mv643xx_private *mp)
         for (offset = ETH_MIB_GOOD_FRAMES_SENT;
                         offset <= ETH_MIB_LATE_COLLISION;
                         offset += 4)
-                *(u32 *)((char *)p + offset) = read_mib(mp, offset);
+                *(u32 *)((char *)p + offset) += read_mib(mp, offset);
 }
 
 /*
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 459c845d6648..5a5289b7a885 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -1907,7 +1907,7 @@ static struct sk_buff *receive_copy(struct sky2_port *sky2,
                 pci_dma_sync_single_for_device(sky2->hw->pdev, re->data_addr,
                                                length, PCI_DMA_FROMDEVICE);
                 re->skb->ip_summed = CHECKSUM_NONE;
-                __skb_put(skb, length);
+                skb_put(skb, length);
         }
         return skb;
 }
@@ -1970,7 +1970,7 @@ static struct sk_buff *receive_new(struct sky2_port *sky2,
         if (skb_shinfo(skb)->nr_frags)
                 skb_put_frags(skb, hdr_space, length);
         else
-                skb_put(skb, hdr_space);
+                skb_put(skb, length);
         return skb;
 }