22 files changed, 336 insertions, 205 deletions

diff --git a/drivers/net/ethernet/8390/Kconfig b/drivers/net/ethernet/8390/Kconfig
index a5f91e1e8fe3..becef25fa194 100644
--- a/drivers/net/ethernet/8390/Kconfig
+++ b/drivers/net/ethernet/8390/Kconfig
@@ -148,7 +148,7 @@ config PCMCIA_PCNET
 
 config NE_H8300
         tristate "NE2000 compatible support for H8/300"
-        depends on H8300
+        depends on H8300H_AKI3068NET || H8300H_H8MAX
         ---help---
           Say Y here if you want to use the NE2000 compatible
           controller on the Renesas H8/300 processor.
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
index 8d726f6e1c52..2361bf236ce3 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
@@ -53,6 +53,7 @@ static inline void bnx2x_move_fp(struct bnx2x *bp, int from, int to)
         struct bnx2x_fp_stats *to_fp_stats = &bp->fp_stats[to];
         int old_max_eth_txqs, new_max_eth_txqs;
         int old_txdata_index = 0, new_txdata_index = 0;
+        struct bnx2x_agg_info *old_tpa_info = to_fp->tpa_info;
 
         /* Copy the NAPI object as it has been already initialized */
         from_fp->napi = to_fp->napi;
@@ -61,6 +62,11 @@ static inline void bnx2x_move_fp(struct bnx2x *bp, int from, int to)
         memcpy(to_fp, from_fp, sizeof(*to_fp));
         to_fp->index = to;
 
+        /* Retain the tpa_info of the original `to' version as we don't want
+         * 2 FPs to contain the same tpa_info pointer.
+         */
+        to_fp->tpa_info = old_tpa_info;
+
         /* move sp_objs contents as well, as their indices match fp ones */
         memcpy(to_sp_objs, from_sp_objs, sizeof(*to_sp_objs));
 
@@ -2959,8 +2965,9 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode, bool keep_link)
         if (IS_PF(bp)) {
                 if (CNIC_LOADED(bp))
                         bnx2x_free_mem_cnic(bp);
-                bnx2x_free_mem(bp);
         }
+        bnx2x_free_mem(bp);
+
         bp->state = BNX2X_STATE_CLOSED;
         bp->cnic_loaded = false;
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
index 9d64b988ab34..664568420c9b 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
@@ -6501,12 +6501,13 @@ static int bnx2x_link_initialize(struct link_params *params,
                 struct bnx2x_phy *phy = &params->phy[INT_PHY];
                 if (vars->line_speed == SPEED_AUTO_NEG &&
                     (CHIP_IS_E1x(bp) ||
-                     CHIP_IS_E2(bp)))
+                     CHIP_IS_E2(bp))) {
                         bnx2x_set_parallel_detection(phy, params);
                         if (params->phy[INT_PHY].config_init)
                                 params->phy[INT_PHY].config_init(phy,
                                                                  params,
                                                                  vars);
+                }
         }
 
         /* Init external phy*/
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index c69990d2170e..285f2a59a3a5 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -7855,12 +7855,15 @@ void bnx2x_free_mem(struct bnx2x *bp)
 {
         int i;
 
-        BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
-                       sizeof(struct host_sp_status_block));
-
         BNX2X_PCI_FREE(bp->fw_stats, bp->fw_stats_mapping,
                        bp->fw_stats_data_sz + bp->fw_stats_req_sz);
 
+        if (IS_VF(bp))
+                return;
+
+        BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
+                       sizeof(struct host_sp_status_block));
+
         BNX2X_PCI_FREE(bp->slowpath, bp->slowpath_mapping,
                        sizeof(struct bnx2x_slowpath));
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
index 73731eb68f2a..b26eb83069b6 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
@@ -545,23 +545,6 @@ static int bnx2x_vfop_set_user_req(struct bnx2x *bp,
         return 0;
 }
 
-static int
-bnx2x_vfop_config_vlan0(struct bnx2x *bp,
-                        struct bnx2x_vlan_mac_ramrod_params *vlan_mac,
-                        bool add)
-{
-        int rc;
-
-        vlan_mac->user_req.cmd = add ? BNX2X_VLAN_MAC_ADD :
-                BNX2X_VLAN_MAC_DEL;
-        vlan_mac->user_req.u.vlan.vlan = 0;
-
-        rc = bnx2x_config_vlan_mac(bp, vlan_mac);
-        if (rc == -EEXIST)
-                rc = 0;
-        return rc;
-}
-
 static int bnx2x_vfop_config_list(struct bnx2x *bp,
                                   struct bnx2x_vfop_filters *filters,
                                   struct bnx2x_vlan_mac_ramrod_params *vlan_mac)
@@ -666,30 +649,14 @@ static void bnx2x_vfop_vlan_mac(struct bnx2x *bp, struct bnx2x_virtf *vf)
 
         case BNX2X_VFOP_VLAN_CONFIG_LIST:
                 /* next state */
-                vfop->state = BNX2X_VFOP_VLAN_CONFIG_LIST_0;
-
-                /* remove vlan0 - could be no-op */
-                vfop->rc = bnx2x_vfop_config_vlan0(bp, vlan_mac, false);
-                if (vfop->rc)
-                        goto op_err;
+                vfop->state = BNX2X_VFOP_VLAN_MAC_CHK_DONE;
 
-                /* Do vlan list config. if this operation fails we try to
-                 * restore vlan0 to keep the queue is working order
-                 */
+                /* do list config */
                 vfop->rc = bnx2x_vfop_config_list(bp, filters, vlan_mac);
                 if (!vfop->rc) {
                         set_bit(RAMROD_CONT, &vlan_mac->ramrod_flags);
                         vfop->rc = bnx2x_config_vlan_mac(bp, vlan_mac);
                 }
-                bnx2x_vfop_finalize(vf, vfop->rc, VFOP_CONT); /* fall-through */
-
-        case BNX2X_VFOP_VLAN_CONFIG_LIST_0:
-                /* next state */
-                vfop->state = BNX2X_VFOP_VLAN_MAC_CHK_DONE;
-
-                if (list_empty(&obj->head))
-                        /* add vlan0 */
-                        vfop->rc = bnx2x_vfop_config_vlan0(bp, vlan_mac, true);
                 bnx2x_vfop_finalize(vf, vfop->rc, VFOP_DONE);
 
         default:
@@ -2833,6 +2800,18 @@ int bnx2x_vf_init(struct bnx2x *bp, struct bnx2x_virtf *vf, dma_addr_t *sb_map)
         return 0;
 }
 
+struct set_vf_state_cookie {
+        struct bnx2x_virtf *vf;
+        u8 state;
+};
+
+void bnx2x_set_vf_state(void *cookie)
+{
+        struct set_vf_state_cookie *p = (struct set_vf_state_cookie *)cookie;
+
+        p->vf->state = p->state;
+}
+
 /* VFOP close (teardown the queues, delete mcasts and close HW) */
 static void bnx2x_vfop_close(struct bnx2x *bp, struct bnx2x_virtf *vf)
 {
@@ -2883,7 +2862,19 @@ static void bnx2x_vfop_close(struct bnx2x *bp, struct bnx2x_virtf *vf)
 op_err:
         BNX2X_ERR("VF[%d] CLOSE error: rc %d\n", vf->abs_vfid, vfop->rc);
 op_done:
-        vf->state = VF_ACQUIRED;
+
+        /* need to make sure there are no outstanding stats ramrods which may
+         * cause the device to access the VF's stats buffer which it will free
+         * as soon as we return from the close flow.
+         */
+        {
+                struct set_vf_state_cookie cookie;
+
+                cookie.vf = vf;
+                cookie.state = VF_ACQUIRED;
+                bnx2x_stats_safe_exec(bp, bnx2x_set_vf_state, &cookie);
+        }
+
         DP(BNX2X_MSG_IOV, "set state to acquired\n");
         bnx2x_vfop_end(bp, vf, vfop);
 }
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c
index d63d1327b051..86436c77af03 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c
@@ -522,20 +522,16 @@ static void bnx2x_func_stats_init(struct bnx2x *bp)
 /* should be called under stats_sema */
 static void __bnx2x_stats_start(struct bnx2x *bp)
 {
-        /* vfs travel through here as part of the statistics FSM, but no action
-         * is required
-         */
-        if (IS_VF(bp))
-                return;
-
-        if (bp->port.pmf)
-                bnx2x_port_stats_init(bp);
+        if (IS_PF(bp)) {
+                if (bp->port.pmf)
+                        bnx2x_port_stats_init(bp);
 
-        else if (bp->func_stx)
-                bnx2x_func_stats_init(bp);
+                else if (bp->func_stx)
+                        bnx2x_func_stats_init(bp);
 
-        bnx2x_hw_stats_post(bp);
-        bnx2x_storm_stats_post(bp);
+                bnx2x_hw_stats_post(bp);
+                bnx2x_storm_stats_post(bp);
+        }
 
         bp->stats_started = true;
 }
@@ -1997,3 +1993,14 @@ void bnx2x_afex_collect_stats(struct bnx2x *bp, void *void_afex_stats,
                        estats->mac_discard);
         }
 }
+
+void bnx2x_stats_safe_exec(struct bnx2x *bp,
+                           void (func_to_exec)(void *cookie),
+                           void *cookie){
+        if (down_timeout(&bp->stats_sema, HZ/10))
+                BNX2X_ERR("Unable to acquire stats lock\n");
+        bnx2x_stats_comp(bp);
+        func_to_exec(cookie);
+        __bnx2x_stats_start(bp);
+        up(&bp->stats_sema);
+}
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h
index 853824d258e8..f35845006cdd 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h
@@ -539,6 +539,9 @@ struct bnx2x;
 void bnx2x_memset_stats(struct bnx2x *bp);
 void bnx2x_stats_init(struct bnx2x *bp);
 void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event);
+void bnx2x_stats_safe_exec(struct bnx2x *bp,
+                           void (func_to_exec)(void *cookie),
+                           void *cookie);
 
 /**
  * bnx2x_save_statistics - save statistics when unloading.
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index 2e55ee29cf13..5701f3d1a169 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -3030,6 +3030,19 @@ static bool tg3_phy_power_bug(struct tg3 *tp)
         return false;
 }
 
+static bool tg3_phy_led_bug(struct tg3 *tp)
+{
+        switch (tg3_asic_rev(tp)) {
+        case ASIC_REV_5719:
+                if ((tp->phy_flags & TG3_PHYFLG_MII_SERDES) &&
+                    !tp->pci_fn)
+                        return true;
+                return false;
+        }
+
+        return false;
+}
+
 static void tg3_power_down_phy(struct tg3 *tp, bool do_low_power)
 {
         u32 val;
@@ -3077,8 +3090,9 @@ static void tg3_power_down_phy(struct tg3 *tp, bool do_low_power)
                 }
                 return;
         } else if (do_low_power) {
-                tg3_writephy(tp, MII_TG3_EXT_CTRL,
-                             MII_TG3_EXT_CTRL_FORCE_LED_OFF);
+                if (!tg3_phy_led_bug(tp))
+                        tg3_writephy(tp, MII_TG3_EXT_CTRL,
+                                     MII_TG3_EXT_CTRL_FORCE_LED_OFF);
 
                 val = MII_TG3_AUXCTL_PCTL_100TX_LPWR |
                       MII_TG3_AUXCTL_PCTL_SPR_ISOLATE |
diff --git a/drivers/net/ethernet/calxeda/xgmac.c b/drivers/net/ethernet/calxeda/xgmac.c
index 7cb148c495c9..78d6d6b970e1 100644
--- a/drivers/net/ethernet/calxeda/xgmac.c
+++ b/drivers/net/ethernet/calxeda/xgmac.c
@@ -353,11 +353,9 @@ struct xgmac_extra_stats {
         /* Receive errors */
         unsigned long rx_watchdog;
         unsigned long rx_da_filter_fail;
-        unsigned long rx_sa_filter_fail;
         unsigned long rx_payload_error;
         unsigned long rx_ip_header_error;
         /* Tx/Rx IRQ errors */
-        unsigned long tx_undeflow;
         unsigned long tx_process_stopped;
         unsigned long rx_buf_unav;
         unsigned long rx_process_stopped;
@@ -393,6 +391,7 @@ struct xgmac_priv {
         char rx_pause;
         char tx_pause;
         int wolopts;
+        struct work_struct tx_timeout_work;
 };
 
 /* XGMAC Configuration Settings */
@@ -409,6 +408,9 @@ struct xgmac_priv {
 #define dma_ring_space(h, t, s) CIRC_SPACE(h, t, s)
 #define dma_ring_cnt(h, t, s)   CIRC_CNT(h, t, s)
 
+#define tx_dma_ring_space(p) \
+        dma_ring_space((p)->tx_head, (p)->tx_tail, DMA_TX_RING_SZ)
+
 /* XGMAC Descriptor Access Helpers */
 static inline void desc_set_buf_len(struct xgmac_dma_desc *p, u32 buf_sz)
 {
@@ -421,7 +423,7 @@ static inline void desc_set_buf_len(struct xgmac_dma_desc *p, u32 buf_sz)
 
 static inline int desc_get_buf_len(struct xgmac_dma_desc *p)
 {
-        u32 len = cpu_to_le32(p->flags);
+        u32 len = le32_to_cpu(p->buf_size);
         return (len & DESC_BUFFER1_SZ_MASK) +
                 ((len & DESC_BUFFER2_SZ_MASK) >> DESC_BUFFER2_SZ_OFFSET);
 }
@@ -464,11 +466,23 @@ static inline void desc_set_tx_owner(struct xgmac_dma_desc *p, u32 flags)
         p->flags = cpu_to_le32(tmpflags);
 }
 
+static inline void desc_clear_tx_owner(struct xgmac_dma_desc *p)
+{
+        u32 tmpflags = le32_to_cpu(p->flags);
+        tmpflags &= TXDESC_END_RING;
+        p->flags = cpu_to_le32(tmpflags);
+}
+
 static inline int desc_get_tx_ls(struct xgmac_dma_desc *p)
 {
         return le32_to_cpu(p->flags) & TXDESC_LAST_SEG;
 }
 
+static inline int desc_get_tx_fs(struct xgmac_dma_desc *p)
+{
+        return le32_to_cpu(p->flags) & TXDESC_FIRST_SEG;
+}
+
 static inline u32 desc_get_buf_addr(struct xgmac_dma_desc *p)
 {
         return le32_to_cpu(p->buf1_addr);
@@ -609,10 +623,15 @@ static void xgmac_set_mac_addr(void __iomem *ioaddr, unsigned char *addr,
 {
         u32 data;
 
-        data = (addr[5] << 8) | addr[4] | (num ? XGMAC_ADDR_AE : 0);
-        writel(data, ioaddr + XGMAC_ADDR_HIGH(num));
-        data = (addr[3] << 24) | (addr[2] << 16) | (addr[1] << 8) | addr[0];
-        writel(data, ioaddr + XGMAC_ADDR_LOW(num));
+        if (addr) {
+                data = (addr[5] << 8) | addr[4] | (num ? XGMAC_ADDR_AE : 0);
+                writel(data, ioaddr + XGMAC_ADDR_HIGH(num));
+                data = (addr[3] << 24) | (addr[2] << 16) | (addr[1] << 8) | addr[0];
+                writel(data, ioaddr + XGMAC_ADDR_LOW(num));
+        } else {
+                writel(0, ioaddr + XGMAC_ADDR_HIGH(num));
+                writel(0, ioaddr + XGMAC_ADDR_LOW(num));
+        }
 }
 
 static void xgmac_get_mac_addr(void __iomem *ioaddr, unsigned char *addr,
@@ -683,9 +702,14 @@ static void xgmac_rx_refill(struct xgmac_priv *priv)
                         if (unlikely(skb == NULL))
                                 break;
 
-                        priv->rx_skbuff[entry] = skb;
                         paddr = dma_map_single(priv->device, skb->data,
-                                               bufsz, DMA_FROM_DEVICE);
+                                               priv->dma_buf_sz - NET_IP_ALIGN,
+                                               DMA_FROM_DEVICE);
+                        if (dma_mapping_error(priv->device, paddr)) {
+                                dev_kfree_skb_any(skb);
+                                break;
+                        }
+                        priv->rx_skbuff[entry] = skb;
                         desc_set_buf_addr(p, paddr, priv->dma_buf_sz);
                 }
 
@@ -782,20 +806,21 @@ static void xgmac_free_rx_skbufs(struct xgmac_priv *priv)
                 return;
 
         for (i = 0; i < DMA_RX_RING_SZ; i++) {
-                if (priv->rx_skbuff[i] == NULL)
+                struct sk_buff *skb = priv->rx_skbuff[i];
+                if (skb == NULL)
                         continue;
 
                 p = priv->dma_rx + i;
                 dma_unmap_single(priv->device, desc_get_buf_addr(p),
-                                 priv->dma_buf_sz, DMA_FROM_DEVICE);
-                dev_kfree_skb_any(priv->rx_skbuff[i]);
+                                 priv->dma_buf_sz - NET_IP_ALIGN, DMA_FROM_DEVICE);
+                dev_kfree_skb_any(skb);
                 priv->rx_skbuff[i] = NULL;
         }
 }
 
 static void xgmac_free_tx_skbufs(struct xgmac_priv *priv)
 {
-        int i, f;
+        int i;
         struct xgmac_dma_desc *p;
 
         if (!priv->tx_skbuff)
@@ -806,16 +831,15 @@ static void xgmac_free_tx_skbufs(struct xgmac_priv *priv)
                         continue;
 
                 p = priv->dma_tx + i;
-                dma_unmap_single(priv->device, desc_get_buf_addr(p),
-                                 desc_get_buf_len(p), DMA_TO_DEVICE);
-
-                for (f = 0; f < skb_shinfo(priv->tx_skbuff[i])->nr_frags; f++) {
-                        p = priv->dma_tx + i++;
+                if (desc_get_tx_fs(p))
+                        dma_unmap_single(priv->device, desc_get_buf_addr(p),
+                                         desc_get_buf_len(p), DMA_TO_DEVICE);
+                else
                         dma_unmap_page(priv->device, desc_get_buf_addr(p),
                                        desc_get_buf_len(p), DMA_TO_DEVICE);
-                }
 
-                dev_kfree_skb_any(priv->tx_skbuff[i]);
+                if (desc_get_tx_ls(p))
+                        dev_kfree_skb_any(priv->tx_skbuff[i]);
                 priv->tx_skbuff[i] = NULL;
         }
 }
@@ -852,8 +876,6 @@ static void xgmac_free_dma_desc_rings(struct xgmac_priv *priv)
  */
 static void xgmac_tx_complete(struct xgmac_priv *priv)
 {
-        int i;
-
         while (dma_ring_cnt(priv->tx_head, priv->tx_tail, DMA_TX_RING_SZ)) {
                 unsigned int entry = priv->tx_tail;
                 struct sk_buff *skb = priv->tx_skbuff[entry];
@@ -863,55 +885,45 @@ static void xgmac_tx_complete(struct xgmac_priv *priv)
                 if (desc_get_owner(p))
                         break;
 
-                /* Verify tx error by looking at the last segment */
-                if (desc_get_tx_ls(p))
-                        desc_get_tx_status(priv, p);
-
                 netdev_dbg(priv->dev, "tx ring: curr %d, dirty %d\n",
                         priv->tx_head, priv->tx_tail);
 
-                dma_unmap_single(priv->device, desc_get_buf_addr(p),
-                                 desc_get_buf_len(p), DMA_TO_DEVICE);
-
-                priv->tx_skbuff[entry] = NULL;
-                priv->tx_tail = dma_ring_incr(entry, DMA_TX_RING_SZ);
-
-                if (!skb) {
-                        continue;
-                }
-
-                for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
-                        entry = priv->tx_tail = dma_ring_incr(priv->tx_tail,
-                                                              DMA_TX_RING_SZ);
-                        p = priv->dma_tx + priv->tx_tail;
-
+                if (desc_get_tx_fs(p))
+                        dma_unmap_single(priv->device, desc_get_buf_addr(p),
+                                         desc_get_buf_len(p), DMA_TO_DEVICE);
+                else
                         dma_unmap_page(priv->device, desc_get_buf_addr(p),
                                        desc_get_buf_len(p), DMA_TO_DEVICE);
+
+                /* Check tx error on the last segment */
+                if (desc_get_tx_ls(p)) {
+                        desc_get_tx_status(priv, p);
+                        dev_kfree_skb(skb);
                 }
 
-                dev_kfree_skb(skb);
+                priv->tx_skbuff[entry] = NULL;
+                priv->tx_tail = dma_ring_incr(entry, DMA_TX_RING_SZ);
         }
 
-        if (dma_ring_space(priv->tx_head, priv->tx_tail, DMA_TX_RING_SZ) >
-            MAX_SKB_FRAGS)
+        /* Ensure tx_tail is visible to xgmac_xmit */
+        smp_mb();
+        if (unlikely(netif_queue_stopped(priv->dev) &&
+            (tx_dma_ring_space(priv) > MAX_SKB_FRAGS)))
                 netif_wake_queue(priv->dev);
 }
 
-/**
- * xgmac_tx_err:
- * @priv: pointer to the private device structure
- * Description: it cleans the descriptors and restarts the transmission
- * in case of errors.
- */
-static void xgmac_tx_err(struct xgmac_priv *priv)
+static void xgmac_tx_timeout_work(struct work_struct *work)
 {
-        u32 reg, value, inten;
+        u32 reg, value;
+        struct xgmac_priv *priv =
+                container_of(work, struct xgmac_priv, tx_timeout_work);
 
-        netif_stop_queue(priv->dev);
+        napi_disable(&priv->napi);
 
-        inten = readl(priv->base + XGMAC_DMA_INTR_ENA);
         writel(0, priv->base + XGMAC_DMA_INTR_ENA);
 
+        netif_tx_lock(priv->dev);
+
         reg = readl(priv->base + XGMAC_DMA_CONTROL);
         writel(reg & ~DMA_CONTROL_ST, priv->base + XGMAC_DMA_CONTROL);
         do {
@@ -927,9 +939,15 @@ static void xgmac_tx_err(struct xgmac_priv *priv)
 
         writel(DMA_STATUS_TU | DMA_STATUS_TPS | DMA_STATUS_NIS | DMA_STATUS_AIS,
                 priv->base + XGMAC_DMA_STATUS);
-        writel(inten, priv->base + XGMAC_DMA_INTR_ENA);
 
+        netif_tx_unlock(priv->dev);
         netif_wake_queue(priv->dev);
+
+        napi_enable(&priv->napi);
+
+        /* Enable interrupts */
+        writel(DMA_INTR_DEFAULT_MASK, priv->base + XGMAC_DMA_STATUS);
+        writel(DMA_INTR_DEFAULT_MASK, priv->base + XGMAC_DMA_INTR_ENA);
 }
 
 static int xgmac_hw_init(struct net_device *dev)
@@ -957,9 +975,7 @@ static int xgmac_hw_init(struct net_device *dev)
                 DMA_BUS_MODE_FB | DMA_BUS_MODE_ATDS | DMA_BUS_MODE_AAL;
         writel(value, ioaddr + XGMAC_DMA_BUS_MODE);
 
-        /* Enable interrupts */
-        writel(DMA_INTR_DEFAULT_MASK, ioaddr + XGMAC_DMA_STATUS);
-        writel(DMA_INTR_DEFAULT_MASK, ioaddr + XGMAC_DMA_INTR_ENA);
+        writel(0, ioaddr + XGMAC_DMA_INTR_ENA);
 
         /* Mask power mgt interrupt */
         writel(XGMAC_INT_STAT_PMTIM, ioaddr + XGMAC_INT_STAT);
@@ -1027,6 +1043,10 @@ static int xgmac_open(struct net_device *dev)
         napi_enable(&priv->napi);
         netif_start_queue(dev);
 
+        /* Enable interrupts */
+        writel(DMA_INTR_DEFAULT_MASK, ioaddr + XGMAC_DMA_STATUS);
+        writel(DMA_INTR_DEFAULT_MASK, ioaddr + XGMAC_DMA_INTR_ENA);
+
         return 0;
 }
 
@@ -1087,7 +1107,7 @@ static netdev_tx_t xgmac_xmit(struct sk_buff *skb, struct net_device *dev)
         paddr = dma_map_single(priv->device, skb->data, len, DMA_TO_DEVICE);
         if (dma_mapping_error(priv->device, paddr)) {
                 dev_kfree_skb(skb);
-                return -EIO;
+                return NETDEV_TX_OK;
         }
         priv->tx_skbuff[entry] = skb;
         desc_set_buf_addr_and_size(desc, paddr, len);
@@ -1099,14 +1119,12 @@ static netdev_tx_t xgmac_xmit(struct sk_buff *skb, struct net_device *dev)
 
                 paddr = skb_frag_dma_map(priv->device, frag, 0, len,
                                          DMA_TO_DEVICE);
-                if (dma_mapping_error(priv->device, paddr)) {
-                        dev_kfree_skb(skb);
-                        return -EIO;
-                }
+                if (dma_mapping_error(priv->device, paddr))
+                        goto dma_err;
 
                 entry = dma_ring_incr(entry, DMA_TX_RING_SZ);
                 desc = priv->dma_tx + entry;
-                priv->tx_skbuff[entry] = NULL;
+                priv->tx_skbuff[entry] = skb;
 
                 desc_set_buf_addr_and_size(desc, paddr, len);
                 if (i < (nfrags - 1))
@@ -1124,13 +1142,35 @@ static netdev_tx_t xgmac_xmit(struct sk_buff *skb, struct net_device *dev)
         wmb();
         desc_set_tx_owner(first, desc_flags | TXDESC_FIRST_SEG);
 
+        writel(1, priv->base + XGMAC_DMA_TX_POLL);
+
         priv->tx_head = dma_ring_incr(entry, DMA_TX_RING_SZ);
 
-        writel(1, priv->base + XGMAC_DMA_TX_POLL);
-        if (dma_ring_space(priv->tx_head, priv->tx_tail, DMA_TX_RING_SZ) <
-            MAX_SKB_FRAGS)
+        /* Ensure tx_head update is visible to tx completion */
+        smp_mb();
+        if (unlikely(tx_dma_ring_space(priv) <= MAX_SKB_FRAGS)) {
                 netif_stop_queue(dev);
+                /* Ensure netif_stop_queue is visible to tx completion */
+                smp_mb();
+                if (tx_dma_ring_space(priv) > MAX_SKB_FRAGS)
+                        netif_start_queue(dev);
+        }
+        return NETDEV_TX_OK;
 
+dma_err:
+        entry = priv->tx_head;
+        for ( ; i > 0; i--) {
+                entry = dma_ring_incr(entry, DMA_TX_RING_SZ);
+                desc = priv->dma_tx + entry;
+                priv->tx_skbuff[entry] = NULL;
+                dma_unmap_page(priv->device, desc_get_buf_addr(desc),
+                               desc_get_buf_len(desc), DMA_TO_DEVICE);
+                desc_clear_tx_owner(desc);
+        }
+        desc = first;
+        dma_unmap_single(priv->device, desc_get_buf_addr(desc),
+                         desc_get_buf_len(desc), DMA_TO_DEVICE);
+        dev_kfree_skb(skb);
         return NETDEV_TX_OK;
 }
 
@@ -1174,7 +1214,7 @@ static int xgmac_rx(struct xgmac_priv *priv, int limit)
 
                 skb_put(skb, frame_len);
                 dma_unmap_single(priv->device, desc_get_buf_addr(p),
-                                 frame_len, DMA_FROM_DEVICE);
+                                 priv->dma_buf_sz - NET_IP_ALIGN, DMA_FROM_DEVICE);
 
                 skb->protocol = eth_type_trans(skb, priv->dev);
                 skb->ip_summed = ip_checksum;
@@ -1225,9 +1265,7 @@ static int xgmac_poll(struct napi_struct *napi, int budget)
 static void xgmac_tx_timeout(struct net_device *dev)
 {
         struct xgmac_priv *priv = netdev_priv(dev);
-
-        /* Clear Tx resources and restart transmitting again */
-        xgmac_tx_err(priv);
+        schedule_work(&priv->tx_timeout_work);
 }
 
 /**
@@ -1286,6 +1324,8 @@ static void xgmac_set_rx_mode(struct net_device *dev)
         if ((netdev_mc_count(dev) + reg - 1) > XGMAC_MAX_FILTER_ADDR) {
                 use_hash = true;
                 value |= XGMAC_FRAME_FILTER_HMC | XGMAC_FRAME_FILTER_HPF;
+        } else {
+                use_hash = false;
         }
         netdev_for_each_mc_addr(ha, dev) {
                 if (use_hash) {
@@ -1302,6 +1342,8 @@ static void xgmac_set_rx_mode(struct net_device *dev)
         }
 
 out:
+        for (i = reg; i < XGMAC_MAX_FILTER_ADDR; i++)
+                xgmac_set_mac_addr(ioaddr, NULL, reg);
         for (i = 0; i < XGMAC_NUM_HASH; i++)
                 writel(hash_filter[i], ioaddr + XGMAC_HASH(i));
 
@@ -1366,7 +1408,6 @@ static irqreturn_t xgmac_pmt_interrupt(int irq, void *dev_id)
 static irqreturn_t xgmac_interrupt(int irq, void *dev_id)
 {
         u32 intr_status;
-        bool tx_err = false;
         struct net_device *dev = (struct net_device *)dev_id;
         struct xgmac_priv *priv = netdev_priv(dev);
         struct xgmac_extra_stats *x = &priv->xstats;
@@ -1396,16 +1437,12 @@ static irqreturn_t xgmac_interrupt(int irq, void *dev_id)
                 if (intr_status & DMA_STATUS_TPS) {
                         netdev_err(priv->dev, "transmit process stopped\n");
                         x->tx_process_stopped++;
-                        tx_err = true;
+                        schedule_work(&priv->tx_timeout_work);
                 }
                 if (intr_status & DMA_STATUS_FBI) {
                         netdev_err(priv->dev, "fatal bus error\n");
                         x->fatal_bus_error++;
-                        tx_err = true;
                 }
-
-                if (tx_err)
-                        xgmac_tx_err(priv);
         }
 
         /* TX/RX NORMAL interrupts */
@@ -1569,7 +1606,6 @@ static const struct xgmac_stats xgmac_gstrings_stats[] = {
         XGMAC_STAT(rx_payload_error),
         XGMAC_STAT(rx_ip_header_error),
         XGMAC_STAT(rx_da_filter_fail),
-        XGMAC_STAT(rx_sa_filter_fail),
         XGMAC_STAT(fatal_bus_error),
         XGMAC_HW_STAT(rx_watchdog, XGMAC_MMC_RXWATCHDOG),
         XGMAC_HW_STAT(tx_vlan, XGMAC_MMC_TXVLANFRAME),
@@ -1708,6 +1744,7 @@ static int xgmac_probe(struct platform_device *pdev)
         ndev->netdev_ops = &xgmac_netdev_ops;
         SET_ETHTOOL_OPS(ndev, &xgmac_ethtool_ops);
         spin_lock_init(&priv->stats_lock);
+        INIT_WORK(&priv->tx_timeout_work, xgmac_tx_timeout_work);
 
         priv->device = &pdev->dev;
         priv->dev = ndev;
@@ -1759,7 +1796,7 @@ static int xgmac_probe(struct platform_device *pdev)
         if (device_can_wakeup(priv->device))
                 priv->wolopts = WAKE_MAGIC;     /* Magic Frame as default */
 
-        ndev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA;
+        ndev->hw_features = NETIF_F_SG | NETIF_F_HIGHDMA;
         if (readl(priv->base + XGMAC_DMA_HW_FEATURE) & DMA_HW_FEAT_TXCOESEL)
                 ndev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
                                      NETIF_F_RXCSUM;
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index e104db7fcf27..3224d28cdad4 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -4476,6 +4476,10 @@ static int be_resume(struct pci_dev *pdev)
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
 
+        status = be_fw_wait_ready(adapter);
+        if (status)
+                return status;
+
         /* tell fw we're ready to fire cmds */
         status = be_cmd_fw_init(adapter);
         if (status)
diff --git a/drivers/net/ethernet/freescale/fec.h b/drivers/net/ethernet/freescale/fec.h
index ae236009f1a8..0120217a16dd 100644
--- a/drivers/net/ethernet/freescale/fec.h
+++ b/drivers/net/ethernet/freescale/fec.h
@@ -296,6 +296,9 @@ struct fec_enet_private {
         /* The ring entries to be free()ed */
         struct bufdesc  *dirty_tx;
 
+        unsigned short tx_ring_size;
+        unsigned short rx_ring_size;
+
         struct  platform_device *pdev;
 
         int     opened;
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c
index 0cd5e4b8b545..f9aacf5d8523 100644
--- a/drivers/net/ethernet/freescale/fec_main.c
+++ b/drivers/net/ethernet/freescale/fec_main.c
@@ -238,22 +238,57 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
 
 static int mii_cnt;
 
-static struct bufdesc *fec_enet_get_nextdesc(struct bufdesc *bdp, int is_ex)
+static inline
+struct bufdesc *fec_enet_get_nextdesc(struct bufdesc *bdp, struct fec_enet_private *fep)
 {
-        struct bufdesc_ex *ex = (struct bufdesc_ex *)bdp;
-        if (is_ex)
-                return (struct bufdesc *)(ex + 1);
+        struct bufdesc *new_bd = bdp + 1;
+        struct bufdesc_ex *ex_new_bd = (struct bufdesc_ex *)bdp + 1;
+        struct bufdesc_ex *ex_base;
+        struct bufdesc *base;
+        int ring_size;
+
+        if (bdp >= fep->tx_bd_base) {
+                base = fep->tx_bd_base;
+                ring_size = fep->tx_ring_size;
+                ex_base = (struct bufdesc_ex *)fep->tx_bd_base;
+        } else {
+                base = fep->rx_bd_base;
+                ring_size = fep->rx_ring_size;
+                ex_base = (struct bufdesc_ex *)fep->rx_bd_base;
+        }
+
+        if (fep->bufdesc_ex)
+                return (struct bufdesc *)((ex_new_bd >= (ex_base + ring_size)) ?
+                        ex_base : ex_new_bd);
         else
-                return bdp + 1;
+                return (new_bd >= (base + ring_size)) ?
+                        base : new_bd;
 }
 
-static struct bufdesc *fec_enet_get_prevdesc(struct bufdesc *bdp, int is_ex)
+static inline
+struct bufdesc *fec_enet_get_prevdesc(struct bufdesc *bdp, struct fec_enet_private *fep)
 {
-        struct bufdesc_ex *ex = (struct bufdesc_ex *)bdp;
-        if (is_ex)
-                return (struct bufdesc *)(ex - 1);
+        struct bufdesc *new_bd = bdp - 1;
+        struct bufdesc_ex *ex_new_bd = (struct bufdesc_ex *)bdp - 1;
+        struct bufdesc_ex *ex_base;
+        struct bufdesc *base;
+        int ring_size;
+
+        if (bdp >= fep->tx_bd_base) {
+                base = fep->tx_bd_base;
+                ring_size = fep->tx_ring_size;
+                ex_base = (struct bufdesc_ex *)fep->tx_bd_base;
+        } else {
+                base = fep->rx_bd_base;
+                ring_size = fep->rx_ring_size;
+                ex_base = (struct bufdesc_ex *)fep->rx_bd_base;
+        }
+
+        if (fep->bufdesc_ex)
+                return (struct bufdesc *)((ex_new_bd < ex_base) ?
+                        (ex_new_bd + ring_size) : ex_new_bd);
         else
-                return bdp - 1;
+                return (new_bd < base) ? (new_bd + ring_size) : new_bd;
 }
 
 static void *swap_buffer(void *bufaddr, int len)
@@ -379,7 +414,7 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
                 }
         }
 
-        bdp_pre = fec_enet_get_prevdesc(bdp, fep->bufdesc_ex);
+        bdp_pre = fec_enet_get_prevdesc(bdp, fep);
         if ((id_entry->driver_data & FEC_QUIRK_ERR006358) &&
             !(bdp_pre->cbd_sc & BD_ENET_TX_READY)) {
                 fep->delay_work.trig_tx = true;
@@ -388,10 +423,7 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         }
 
         /* If this was the last BD in the ring, start at the beginning again. */
-        if (status & BD_ENET_TX_WRAP)
-                bdp = fep->tx_bd_base;
-        else
-                bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
+        bdp = fec_enet_get_nextdesc(bdp, fep);
 
         fep->cur_tx = bdp;
 
@@ -416,18 +448,18 @@ static void fec_enet_bd_init(struct net_device *dev)
 
         /* Initialize the receive buffer descriptors. */
         bdp = fep->rx_bd_base;
-        for (i = 0; i < RX_RING_SIZE; i++) {
+        for (i = 0; i < fep->rx_ring_size; i++) {
 
                 /* Initialize the BD for every fragment in the page. */
                 if (bdp->cbd_bufaddr)
                         bdp->cbd_sc = BD_ENET_RX_EMPTY;
                 else
                         bdp->cbd_sc = 0;
-                bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
+                bdp = fec_enet_get_nextdesc(bdp, fep);
         }
 
         /* Set the last buffer to wrap */
-        bdp = fec_enet_get_prevdesc(bdp, fep->bufdesc_ex);
+        bdp = fec_enet_get_prevdesc(bdp, fep);
         bdp->cbd_sc |= BD_SC_WRAP;
 
         fep->cur_rx = fep->rx_bd_base;
@@ -435,7 +467,7 @@ static void fec_enet_bd_init(struct net_device *dev)
         /* ...and the same for transmit */
         bdp = fep->tx_bd_base;
         fep->cur_tx = bdp;
-        for (i = 0; i < TX_RING_SIZE; i++) {
+        for (i = 0; i < fep->tx_ring_size; i++) {
 
                 /* Initialize the BD for every fragment in the page. */
                 bdp->cbd_sc = 0;
@@ -444,11 +476,11 @@ static void fec_enet_bd_init(struct net_device *dev)
                         fep->tx_skbuff[i] = NULL;
                 }
                 bdp->cbd_bufaddr = 0;
-                bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
+                bdp = fec_enet_get_nextdesc(bdp, fep);
         }
 
         /* Set the last buffer to wrap */
-        bdp = fec_enet_get_prevdesc(bdp, fep->bufdesc_ex);
+        bdp = fec_enet_get_prevdesc(bdp, fep);
         bdp->cbd_sc |= BD_SC_WRAP;
         fep->dirty_tx = bdp;
 }
@@ -509,10 +541,10 @@ fec_restart(struct net_device *ndev, int duplex)
         writel(fep->bd_dma, fep->hwp + FEC_R_DES_START);
         if (fep->bufdesc_ex)
                 writel((unsigned long)fep->bd_dma + sizeof(struct bufdesc_ex)
-                        * RX_RING_SIZE, fep->hwp + FEC_X_DES_START);
+                        * fep->rx_ring_size, fep->hwp + FEC_X_DES_START);
         else
                 writel((unsigned long)fep->bd_dma + sizeof(struct bufdesc)
-                        * RX_RING_SIZE, fep->hwp + FEC_X_DES_START);
+                        * fep->rx_ring_size,    fep->hwp + FEC_X_DES_START);
 
 
         for (i = 0; i <= TX_RING_MOD_MASK; i++) {
@@ -726,10 +758,7 @@ fec_enet_tx(struct net_device *ndev)
         bdp = fep->dirty_tx;
 
         /* get next bdp of dirty_tx */
-        if (bdp->cbd_sc & BD_ENET_TX_WRAP)
-                bdp = fep->tx_bd_base;
-        else
-                bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
+        bdp = fec_enet_get_nextdesc(bdp, fep);
 
         while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
 
@@ -799,10 +828,7 @@ fec_enet_tx(struct net_device *ndev)
                 fep->dirty_tx = bdp;
 
                 /* Update pointer to next buffer descriptor to be transmitted */
-                if (status & BD_ENET_TX_WRAP)
-                        bdp = fep->tx_bd_base;
-                else
-                        bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
+                bdp = fec_enet_get_nextdesc(bdp, fep);
 
                 /* Since we have freed up a buffer, the ring is no longer full
                  */
@@ -970,8 +996,7 @@ fec_enet_rx(struct net_device *ndev, int budget)
                                                        htons(ETH_P_8021Q),
                                                        vlan_tag);
 
-                        if (!skb_defer_rx_timestamp(skb))
-                                napi_gro_receive(&fep->napi, skb);
+                        napi_gro_receive(&fep->napi, skb);
                 }
 
                 bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, data,
@@ -993,10 +1018,8 @@ rx_processing_done:
                 }
 
                 /* Update BD pointer to next entry */
-                if (status & BD_ENET_RX_WRAP)
-                        bdp = fep->rx_bd_base;
-                else
-                        bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
+                bdp = fec_enet_get_nextdesc(bdp, fep);
+
                 /* Doing this here will keep the FEC running while we process
                  * incoming frames.  On a heavily loaded network, we should be
                  * able to keep up at the expense of system resources.
@@ -1662,7 +1685,7 @@ static void fec_enet_free_buffers(struct net_device *ndev)
         struct bufdesc  *bdp;
 
         bdp = fep->rx_bd_base;
-        for (i = 0; i < RX_RING_SIZE; i++) {
+        for (i = 0; i < fep->rx_ring_size; i++) {
                 skb = fep->rx_skbuff[i];
 
                 if (bdp->cbd_bufaddr)
@@ -1670,11 +1693,11 @@ static void fec_enet_free_buffers(struct net_device *ndev)
                                         FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
                 if (skb)
                         dev_kfree_skb(skb);
-                bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
+                bdp = fec_enet_get_nextdesc(bdp, fep);
         }
 
         bdp = fep->tx_bd_base;
-        for (i = 0; i < TX_RING_SIZE; i++)
+        for (i = 0; i < fep->tx_ring_size; i++)
                 kfree(fep->tx_bounce[i]);
 }
 
@@ -1686,7 +1709,7 @@ static int fec_enet_alloc_buffers(struct net_device *ndev)
         struct bufdesc  *bdp;
 
         bdp = fep->rx_bd_base;
-        for (i = 0; i < RX_RING_SIZE; i++) {
+        for (i = 0; i < fep->rx_ring_size; i++) {
                 skb = netdev_alloc_skb(ndev, FEC_ENET_RX_FRSIZE);
                 if (!skb) {
                         fec_enet_free_buffers(ndev);
@@ -1703,15 +1726,15 @@ static int fec_enet_alloc_buffers(struct net_device *ndev)
                         ebdp->cbd_esc = BD_ENET_RX_INT;
                 }
 
-                bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
+                bdp = fec_enet_get_nextdesc(bdp, fep);
         }
 
         /* Set the last buffer to wrap. */
-        bdp = fec_enet_get_prevdesc(bdp, fep->bufdesc_ex);
+        bdp = fec_enet_get_prevdesc(bdp, fep);
         bdp->cbd_sc |= BD_SC_WRAP;
 
         bdp = fep->tx_bd_base;
-        for (i = 0; i < TX_RING_SIZE; i++) {
+        for (i = 0; i < fep->tx_ring_size; i++) {
                 fep->tx_bounce[i] = kmalloc(FEC_ENET_TX_FRSIZE, GFP_KERNEL);
 
                 bdp->cbd_sc = 0;
@@ -1722,11 +1745,11 @@ static int fec_enet_alloc_buffers(struct net_device *ndev)
                         ebdp->cbd_esc = BD_ENET_TX_INT;
                 }
 
-                bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
+                bdp = fec_enet_get_nextdesc(bdp, fep);
         }
 
         /* Set the last buffer to wrap. */
-        bdp = fec_enet_get_prevdesc(bdp, fep->bufdesc_ex);
+        bdp = fec_enet_get_prevdesc(bdp, fep);
         bdp->cbd_sc |= BD_SC_WRAP;
 
         return 0;
@@ -1966,13 +1989,17 @@ static int fec_enet_init(struct net_device *ndev)
         /* Get the Ethernet address */
         fec_get_mac(ndev);
 
+        /* init the tx & rx ring size */
+        fep->tx_ring_size = TX_RING_SIZE;
+        fep->rx_ring_size = RX_RING_SIZE;
+
         /* Set receive and transmit descriptor base. */
         fep->rx_bd_base = cbd_base;
         if (fep->bufdesc_ex)
                 fep->tx_bd_base = (struct bufdesc *)
-                        (((struct bufdesc_ex *)cbd_base) + RX_RING_SIZE);
+                        (((struct bufdesc_ex *)cbd_base) + fep->rx_ring_size);
         else
-                fep->tx_bd_base = cbd_base + RX_RING_SIZE;
+                fep->tx_bd_base = cbd_base + fep->rx_ring_size;
 
         /* The FEC Ethernet specific entries in the device structure */
         ndev->watchdog_timeo = TX_TIMEOUT;
diff --git a/drivers/net/ethernet/jme.c b/drivers/net/ethernet/jme.c
index 7fbe6abf6054..23de82a9da82 100644
--- a/drivers/net/ethernet/jme.c
+++ b/drivers/net/ethernet/jme.c
@@ -3069,7 +3069,7 @@ jme_init_one(struct pci_dev *pdev,
                 jwrite32(jme, JME_APMC, apmc);
         }
 
-        NETIF_NAPI_SET(netdev, &jme->napi, jme_poll, jme->rx_ring_size >> 2)
+        NETIF_NAPI_SET(netdev, &jme->napi, jme_poll, NAPI_POLL_WEIGHT)
 
         spin_lock_init(&jme->phy_lock);
         spin_lock_init(&jme->macaddr_lock);
diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
index 2777c70c603b..e35bac7cfdf1 100644
--- a/drivers/net/ethernet/marvell/mvneta.c
+++ b/drivers/net/ethernet/marvell/mvneta.c
@@ -138,7 +138,9 @@
 #define      MVNETA_GMAC_FORCE_LINK_PASS         BIT(1)
 #define      MVNETA_GMAC_CONFIG_MII_SPEED        BIT(5)
 #define      MVNETA_GMAC_CONFIG_GMII_SPEED       BIT(6)
+#define      MVNETA_GMAC_AN_SPEED_EN             BIT(7)
 #define      MVNETA_GMAC_CONFIG_FULL_DUPLEX      BIT(12)
+#define      MVNETA_GMAC_AN_DUPLEX_EN            BIT(13)
 #define MVNETA_MIB_COUNTERS_BASE                 0x3080
 #define      MVNETA_MIB_LATE_COLLISION           0x7c
 #define MVNETA_DA_FILT_SPEC_MCAST                0x3400
@@ -948,6 +950,13 @@ static void mvneta_defaults_set(struct mvneta_port *pp)
         /* Assign port SDMA configuration */
         mvreg_write(pp, MVNETA_SDMA_CONFIG, val);
 
+        /* Disable PHY polling in hardware, since we're using the
+         * kernel phylib to do this.
+         */
+        val = mvreg_read(pp, MVNETA_UNIT_CONTROL);
+        val &= ~MVNETA_PHY_POLLING_ENABLE;
+        mvreg_write(pp, MVNETA_UNIT_CONTROL, val);
+
         mvneta_set_ucast_table(pp, -1);
         mvneta_set_special_mcast_table(pp, -1);
         mvneta_set_other_mcast_table(pp, -1);
@@ -2340,7 +2349,9 @@ static void mvneta_adjust_link(struct net_device *ndev)
                         val = mvreg_read(pp, MVNETA_GMAC_AUTONEG_CONFIG);
                         val &= ~(MVNETA_GMAC_CONFIG_MII_SPEED |
                                  MVNETA_GMAC_CONFIG_GMII_SPEED |
-                                 MVNETA_GMAC_CONFIG_FULL_DUPLEX);
+                                 MVNETA_GMAC_CONFIG_FULL_DUPLEX |
+                                 MVNETA_GMAC_AN_SPEED_EN |
+                                 MVNETA_GMAC_AN_DUPLEX_EN);
 
                         if (phydev->duplex)
                                 val |= MVNETA_GMAC_CONFIG_FULL_DUPLEX;
@@ -2473,6 +2484,21 @@ static int mvneta_stop(struct net_device *dev)
         return 0;
 }
 
+static int mvneta_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+{
+        struct mvneta_port *pp = netdev_priv(dev);
+        int ret;
+
+        if (!pp->phy_dev)
+                return -ENOTSUPP;
+
+        ret = phy_mii_ioctl(pp->phy_dev, ifr, cmd);
+        if (!ret)
+                mvneta_adjust_link(dev);
+
+        return ret;
+}
+
 /* Ethtool methods */
 
 /* Get settings (phy address, speed) for ethtools */
@@ -2591,6 +2617,7 @@ static const struct net_device_ops mvneta_netdev_ops = {
         .ndo_change_mtu      = mvneta_change_mtu,
         .ndo_tx_timeout      = mvneta_tx_timeout,
         .ndo_get_stats64     = mvneta_get_stats64,
+        .ndo_do_ioctl        = mvneta_ioctl,
 };
 
 const struct ethtool_ops mvneta_eth_tool_ops = {
diff --git a/drivers/net/ethernet/qlogic/netxen/netxen_nic.h b/drivers/net/ethernet/qlogic/netxen/netxen_nic.h
index 3fe09ab2d7c9..32675e16021e 100644
--- a/drivers/net/ethernet/qlogic/netxen/netxen_nic.h
+++ b/drivers/net/ethernet/qlogic/netxen/netxen_nic.h
@@ -1171,7 +1171,6 @@ typedef struct {
 
 #define NETXEN_DB_MAPSIZE_BYTES         0x1000
 
-#define NETXEN_NETDEV_WEIGHT 128
 #define NETXEN_ADAPTER_UP_MAGIC 777
 #define NETXEN_NIC_PEG_TUNE 0
 
diff --git a/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c b/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
index 1046e9461509..cbd75f97ffb3 100644
--- a/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
+++ b/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
@@ -197,7 +197,7 @@ netxen_napi_add(struct netxen_adapter *adapter, struct net_device *netdev)
         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
                 sds_ring = &recv_ctx->sds_rings[ring];
                 netif_napi_add(netdev, &sds_ring->napi,
-                                netxen_nic_poll, NETXEN_NETDEV_WEIGHT);
+                                netxen_nic_poll, NAPI_POLL_WEIGHT);
         }
 
         return 0;
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
index 474c8a86a2af..5cd831ebfa83 100644
--- a/drivers/net/ethernet/renesas/sh_eth.c
+++ b/drivers/net/ethernet/renesas/sh_eth.c
@@ -1348,7 +1348,7 @@ static int sh_eth_rx(struct net_device *ndev, u32 intr_status, int *quota)
                                                 DMA_FROM_DEVICE);
                         skb_put(skb, pkt_len);
                         skb->protocol = eth_type_trans(skb, ndev);
-                        netif_rx(skb);
+                        netif_receive_skb(skb);
                         ndev->stats.rx_packets++;
                         ndev->stats.rx_bytes += pkt_len;
                 }
@@ -1906,11 +1906,13 @@ static int sh_eth_open(struct net_device *ndev)
 
         pm_runtime_get_sync(&mdp->pdev->dev);
 
+        napi_enable(&mdp->napi);
+
         ret = request_irq(ndev->irq, sh_eth_interrupt,
                           mdp->cd->irq_flags, ndev->name, ndev);
         if (ret) {
                 dev_err(&ndev->dev, "Can not assign IRQ number\n");
-                return ret;
+                goto out_napi_off;
         }
 
         /* Descriptor set */
@@ -1928,12 +1930,12 @@ static int sh_eth_open(struct net_device *ndev)
         if (ret)
                 goto out_free_irq;
 
-        napi_enable(&mdp->napi);
-
         return ret;
 
 out_free_irq:
         free_irq(ndev->irq, ndev);
+out_napi_off:
+        napi_disable(&mdp->napi);
         pm_runtime_put_sync(&mdp->pdev->dev);
         return ret;
 }
@@ -2025,8 +2027,6 @@ static int sh_eth_close(struct net_device *ndev)
 {
         struct sh_eth_private *mdp = netdev_priv(ndev);
 
-        napi_disable(&mdp->napi);
-
         netif_stop_queue(ndev);
 
         /* Disable interrupts by clearing the interrupt mask. */
@@ -2044,6 +2044,8 @@ static int sh_eth_close(struct net_device *ndev)
 
         free_irq(ndev->irq, ndev);
 
+        napi_disable(&mdp->napi);
+
         /* Free all the skbuffs in the Rx queue. */
         sh_eth_ring_free(ndev);
 
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
index 623ebc50fe6b..7a0072003f34 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
@@ -71,19 +71,22 @@ static int stmmac_probe_config_dt(struct platform_device *pdev,
                 plat->force_sf_dma_mode = 1;
         }
 
-        dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*dma_cfg), GFP_KERNEL);
-        if (!dma_cfg)
-                return -ENOMEM;
-
-        plat->dma_cfg = dma_cfg;
-        of_property_read_u32(np, "snps,pbl", &dma_cfg->pbl);
-        dma_cfg->fixed_burst = of_property_read_bool(np, "snps,fixed-burst");
-        dma_cfg->mixed_burst = of_property_read_bool(np, "snps,mixed-burst");
+        if (of_find_property(np, "snps,pbl", NULL)) {
+                dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*dma_cfg),
+                                       GFP_KERNEL);
+                if (!dma_cfg)
+                        return -ENOMEM;
+                plat->dma_cfg = dma_cfg;
+                of_property_read_u32(np, "snps,pbl", &dma_cfg->pbl);
+                dma_cfg->fixed_burst =
+                        of_property_read_bool(np, "snps,fixed-burst");
+                dma_cfg->mixed_burst =
+                        of_property_read_bool(np, "snps,mixed-burst");
+        }
         plat->force_thresh_dma_mode = of_property_read_bool(np, "snps,force_thresh_dma_mode");
         if (plat->force_thresh_dma_mode) {
                 plat->force_sf_dma_mode = 0;
                 pr_warn("force_sf_dma_mode is ignored if force_thresh_dma_mode is set.");
-        }
 
         return 0;
 }
diff --git a/drivers/net/ethernet/toshiba/ps3_gelic_net.c b/drivers/net/ethernet/toshiba/ps3_gelic_net.c
index ad32af67e618..9c805e0c0cae 100644
--- a/drivers/net/ethernet/toshiba/ps3_gelic_net.c
+++ b/drivers/net/ethernet/toshiba/ps3_gelic_net.c
@@ -1466,8 +1466,7 @@ static void gelic_ether_setup_netdev_ops(struct net_device *netdev,
 {
         netdev->watchdog_timeo = GELIC_NET_WATCHDOG_TIMEOUT;
         /* NAPI */
-        netif_napi_add(netdev, napi,
-                       gelic_net_poll, GELIC_NET_NAPI_WEIGHT);
+        netif_napi_add(netdev, napi, gelic_net_poll, NAPI_POLL_WEIGHT);
         netdev->ethtool_ops = &gelic_ether_ethtool_ops;
         netdev->netdev_ops = &gelic_netdevice_ops;
 }
diff --git a/drivers/net/ethernet/toshiba/ps3_gelic_net.h b/drivers/net/ethernet/toshiba/ps3_gelic_net.h
index a93df6ac1909..309abb472aa2 100644
--- a/drivers/net/ethernet/toshiba/ps3_gelic_net.h
+++ b/drivers/net/ethernet/toshiba/ps3_gelic_net.h
@@ -37,7 +37,6 @@
 #define GELIC_NET_RXBUF_ALIGN           128
 #define GELIC_CARD_RX_CSUM_DEFAULT      1 /* hw chksum */
 #define GELIC_NET_WATCHDOG_TIMEOUT      5*HZ
-#define GELIC_NET_NAPI_WEIGHT           (GELIC_NET_RX_DESCRIPTORS)
 #define GELIC_NET_BROADCAST_ADDR        0xffffffffffffL
 
 #define GELIC_NET_MC_COUNT_MAX          32 /* multicast address list */
diff --git a/drivers/net/ethernet/xilinx/xilinx_axienet_mdio.c b/drivers/net/ethernet/xilinx/xilinx_axienet_mdio.c
index e90e1f46121e..64b4639f43b6 100644
--- a/drivers/net/ethernet/xilinx/xilinx_axienet_mdio.c
+++ b/drivers/net/ethernet/xilinx/xilinx_axienet_mdio.c
@@ -175,6 +175,7 @@ int axienet_mdio_setup(struct axienet_local *lp, struct device_node *np)
                 printk(KERN_WARNING "Setting MDIO clock divisor to "
                        "default %d\n", DEFAULT_CLOCK_DIVISOR);
                 clk_div = DEFAULT_CLOCK_DIVISOR;
+                of_node_put(np1);
                 goto issue;
         }
 
diff --git a/drivers/net/usb/cdc_mbim.c b/drivers/net/usb/cdc_mbim.c
index 872819851aef..25ba7eca9a13 100644
--- a/drivers/net/usb/cdc_mbim.c
+++ b/drivers/net/usb/cdc_mbim.c
@@ -400,6 +400,10 @@ static const struct usb_device_id mbim_devs[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x68a2, USB_CLASS_COMM, USB_CDC_SUBCLASS_MBIM, USB_CDC_PROTO_NONE),
           .driver_info = (unsigned long)&cdc_mbim_info_zlp,
         },
+        /* HP hs2434 Mobile Broadband Module needs ZLPs */
+        { USB_DEVICE_AND_INTERFACE_INFO(0x3f0, 0x4b1d, USB_CLASS_COMM, USB_CDC_SUBCLASS_MBIM, USB_CDC_PROTO_NONE),
+          .driver_info = (unsigned long)&cdc_mbim_info_zlp,
+        },
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MBIM, USB_CDC_PROTO_NONE),
           .driver_info = (unsigned long)&cdc_mbim_info,
         },