Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next

Pull networking updates from David Miller:

 1) More iov_iter conversion work from Al Viro.

    [ The "crypto: switch af_alg_make_sg() to iov_iter" commit was
      wrong, and this pull actually adds an extra commit on top of the
      branch I'm pulling to fix that up, so that the pre-merge state is
      ok.   - Linus ]

 2) Various optimizations to the ipv4 forwarding information base trie
    lookup implementation.  From Alexander Duyck.

 3) Remove sock_iocb altogether, from CHristoph Hellwig.

 4) Allow congestion control algorithm selection via routing metrics.
    From Daniel Borkmann.

 5) Make ipv4 uncached route list per-cpu, from Eric Dumazet.

 6) Handle rfs hash collisions more gracefully, also from Eric Dumazet.

 7) Add xmit_more support to r8169, e1000, and e1000e drivers.  From
    Florian Westphal.

 8) Transparent Ethernet Bridging support for GRO, from Jesse Gross.

 9) Add BPF packet actions to packet scheduler, from Jiri Pirko.

10) Add support for uniqu flow IDs to openvswitch, from Joe Stringer.

11) New NetCP ethernet driver, from Muralidharan Karicheri and Wingman
    Kwok.

12) More sanely handle out-of-window dupacks, which can result in
    serious ACK storms.  From Neal Cardwell.

13) Various rhashtable bug fixes and enhancements, from Herbert Xu,
    Patrick McHardy, and Thomas Graf.

14) Support xmit_more in be2net, from Sathya Perla.

15) Group Policy extensions for vxlan, from Thomas Graf.

16) Remove Checksum Offload support for vxlan, from Tom Herbert.

17) Like ipv4, support lockless transmit over ipv6 UDP sockets.  From
    Vlad Yasevich.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1494+1 commits)
  crypto: fix af_alg_make_sg() conversion to iov_iter
  ipv4: Namespecify TCP PMTU mechanism
  i40e: Fix for stats init function call in Rx setup
  tcp: don't include Fast Open option in SYN-ACK on pure SYN-data
  openvswitch: Only set TUNNEL_VXLAN_OPT if VXLAN-GBP metadata is set
  ipv6: Make __ipv6_select_ident static
  ipv6: Fix fragment id assignment on LE arches.
  bridge: Fix inability to add non-vlan fdb entry
  net: Mellanox: Delete unnecessary checks before the function call "vunmap"
  cxgb4: Add support in cxgb4 to get expansion rom version via ethtool
  ethtool: rename reserved1 memeber in ethtool_drvinfo for expansion ROM version
  net: dsa: Remove redundant phy_attach()
  IB/mlx4: Reset flow support for IB kernel ULPs
  IB/mlx4: Always use the correct port for mirrored multicast attachments
  net/bonding: Fix potential bad memory access during bonding events
  tipc: remove tipc_snprintf
  tipc: nl compat add noop and remove legacy nl framework
  tipc: convert legacy nl stats show to nl compat
  tipc: convert legacy nl net id get to nl compat
  tipc: convert legacy nl net id set to nl compat
  ...

214 files changed, 20425 insertions, 5476 deletions

diff --git a/drivers/net/ethernet/3com/typhoon.c b/drivers/net/ethernet/3com/typhoon.c
index dede43f4ce09..8f8418d2ac4a 100644
--- a/drivers/net/ethernet/3com/typhoon.c
+++ b/drivers/net/ethernet/3com/typhoon.c
@@ -769,11 +769,11 @@ typhoon_start_tx(struct sk_buff *skb, struct net_device *dev)
                 first_txd->processFlags |= TYPHOON_TX_PF_IP_CHKSUM;
         }
 
-        if(vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 first_txd->processFlags |=
                     TYPHOON_TX_PF_INSERT_VLAN | TYPHOON_TX_PF_VLAN_PRIORITY;
                 first_txd->processFlags |=
-                    cpu_to_le32(htons(vlan_tx_tag_get(skb)) <<
+                    cpu_to_le32(htons(skb_vlan_tag_get(skb)) <<
                                 TYPHOON_TX_PF_VLAN_TAG_SHIFT);
         }
 
diff --git a/drivers/net/ethernet/alteon/acenic.c b/drivers/net/ethernet/alteon/acenic.c
index b68074803de3..b90a26b13fdf 100644
--- a/drivers/net/ethernet/alteon/acenic.c
+++ b/drivers/net/ethernet/alteon/acenic.c
@@ -2429,9 +2429,9 @@ restart:
                 flagsize = (skb->len << 16) | (BD_FLG_END);
                 if (skb->ip_summed == CHECKSUM_PARTIAL)
                         flagsize |= BD_FLG_TCP_UDP_SUM;
-                if (vlan_tx_tag_present(skb)) {
+                if (skb_vlan_tag_present(skb)) {
                         flagsize |= BD_FLG_VLAN_TAG;
-                        vlan_tag = vlan_tx_tag_get(skb);
+                        vlan_tag = skb_vlan_tag_get(skb);
                 }
                 desc = ap->tx_ring + idx;
                 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
@@ -2450,9 +2450,9 @@ restart:
                 flagsize = (skb_headlen(skb) << 16);
                 if (skb->ip_summed == CHECKSUM_PARTIAL)
                         flagsize |= BD_FLG_TCP_UDP_SUM;
-                if (vlan_tx_tag_present(skb)) {
+                if (skb_vlan_tag_present(skb)) {
                         flagsize |= BD_FLG_VLAN_TAG;
-                        vlan_tag = vlan_tx_tag_get(skb);
+                        vlan_tag = skb_vlan_tag_get(skb);
                 }
 
                 ace_load_tx_bd(ap, ap->tx_ring + idx, mapping, flagsize, vlan_tag);
diff --git a/drivers/net/ethernet/amd/Kconfig b/drivers/net/ethernet/amd/Kconfig
index 77f1f6048ddd..c638c85f3954 100644
--- a/drivers/net/ethernet/amd/Kconfig
+++ b/drivers/net/ethernet/amd/Kconfig
@@ -179,7 +179,7 @@ config SUNLANCE
 
 config AMD_XGBE
         tristate "AMD 10GbE Ethernet driver"
-        depends on OF_NET && HAS_IOMEM
+        depends on (OF_NET || ACPI) && HAS_IOMEM
         select PHYLIB
         select AMD_XGBE_PHY
         select BITREVERSE
diff --git a/drivers/net/ethernet/amd/amd8111e.c b/drivers/net/ethernet/amd/amd8111e.c
index 841e6558db68..4c2ae2221780 100644
--- a/drivers/net/ethernet/amd/amd8111e.c
+++ b/drivers/net/ethernet/amd/amd8111e.c
@@ -1299,11 +1299,11 @@ static netdev_tx_t amd8111e_start_xmit(struct sk_buff *skb,
         lp->tx_ring[tx_index].tx_flags = 0;
 
 #if AMD8111E_VLAN_TAG_USED
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 lp->tx_ring[tx_index].tag_ctrl_cmd |=
                                 cpu_to_le16(TCC_VLAN_INSERT);
                 lp->tx_ring[tx_index].tag_ctrl_info =
-                                cpu_to_le16(vlan_tx_tag_get(skb));
+                                cpu_to_le16(skb_vlan_tag_get(skb));
 
         }
 #endif
diff --git a/drivers/net/ethernet/amd/pcnet32.c b/drivers/net/ethernet/amd/pcnet32.c
index e2e3aaf501a2..11d6e6561df1 100644
--- a/drivers/net/ethernet/amd/pcnet32.c
+++ b/drivers/net/ethernet/amd/pcnet32.c
@@ -2806,7 +2806,7 @@ static void pcnet32_check_media(struct net_device *dev, int verbose)
 
 /*
  * Check for loss of link and link establishment.
- * Can not use mii_check_media because it does nothing if mode is forced.
+ * Could possibly be changed to use mii_check_media instead.
  */
 
 static void pcnet32_watchdog(struct net_device *dev)
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-debugfs.c b/drivers/net/ethernet/amd/xgbe/xgbe-debugfs.c
index 76479d04b903..2c063b60db4b 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-debugfs.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-debugfs.c
@@ -328,7 +328,7 @@ void xgbe_debugfs_init(struct xgbe_prv_data *pdata)
 
         buf = kasprintf(GFP_KERNEL, "amd-xgbe-%s", pdata->netdev->name);
         pdata->xgbe_debugfs = debugfs_create_dir(buf, NULL);
-        if (pdata->xgbe_debugfs == NULL) {
+        if (!pdata->xgbe_debugfs) {
                 netdev_err(pdata->netdev, "debugfs_create_dir failed\n");
                 return;
         }
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-desc.c b/drivers/net/ethernet/amd/xgbe/xgbe-desc.c
index a50891f52197..d81fc6bd4759 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-desc.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-desc.c
@@ -422,7 +422,6 @@ static void xgbe_wrapper_rx_descriptor_init(struct xgbe_prv_data *pdata)
 
                 ring->cur = 0;
                 ring->dirty = 0;
-                memset(&ring->rx, 0, sizeof(ring->rx));
 
                 hw_if->rx_desc_init(channel);
         }
@@ -621,35 +620,6 @@ err_out:
         return 0;
 }
 
-static void xgbe_realloc_rx_buffer(struct xgbe_channel *channel)
-{
-        struct xgbe_prv_data *pdata = channel->pdata;
-        struct xgbe_hw_if *hw_if = &pdata->hw_if;
-        struct xgbe_ring *ring = channel->rx_ring;
-        struct xgbe_ring_data *rdata;
-        int i;
-
-        DBGPR("-->xgbe_realloc_rx_buffer: rx_ring->rx.realloc_index = %u\n",
-              ring->rx.realloc_index);
-
-        for (i = 0; i < ring->dirty; i++) {
-                rdata = XGBE_GET_DESC_DATA(ring, ring->rx.realloc_index);
-
-                /* Reset rdata values */
-                xgbe_unmap_rdata(pdata, rdata);
-
-                if (xgbe_map_rx_buffer(pdata, ring, rdata))
-                        break;
-
-                hw_if->rx_desc_reset(rdata);
-
-                ring->rx.realloc_index++;
-        }
-        ring->dirty = 0;
-
-        DBGPR("<--xgbe_realloc_rx_buffer\n");
-}
-
 void xgbe_init_function_ptrs_desc(struct xgbe_desc_if *desc_if)
 {
         DBGPR("-->xgbe_init_function_ptrs_desc\n");
@@ -657,7 +627,7 @@ void xgbe_init_function_ptrs_desc(struct xgbe_desc_if *desc_if)
         desc_if->alloc_ring_resources = xgbe_alloc_ring_resources;
         desc_if->free_ring_resources = xgbe_free_ring_resources;
         desc_if->map_tx_skb = xgbe_map_tx_skb;
-        desc_if->realloc_rx_buffer = xgbe_realloc_rx_buffer;
+        desc_if->map_rx_buffer = xgbe_map_rx_buffer;
         desc_if->unmap_rdata = xgbe_unmap_rdata;
         desc_if->wrapper_tx_desc_init = xgbe_wrapper_tx_descriptor_init;
         desc_if->wrapper_rx_desc_init = xgbe_wrapper_rx_descriptor_init;
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-dev.c b/drivers/net/ethernet/amd/xgbe/xgbe-dev.c
index 4c66cd1d1e60..400757b49872 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-dev.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-dev.c
@@ -115,6 +115,7 @@
  */
 
 #include <linux/phy.h>
+#include <linux/mdio.h>
 #include <linux/clk.h>
 #include <linux/bitrev.h>
 #include <linux/crc32.h>
@@ -130,7 +131,7 @@ static unsigned int xgbe_usec_to_riwt(struct xgbe_prv_data *pdata,
 
         DBGPR("-->xgbe_usec_to_riwt\n");
 
-        rate = clk_get_rate(pdata->sysclk);
+        rate = pdata->sysclk_rate;
 
         /*
          * Convert the input usec value to the watchdog timer value. Each
@@ -153,7 +154,7 @@ static unsigned int xgbe_riwt_to_usec(struct xgbe_prv_data *pdata,
 
         DBGPR("-->xgbe_riwt_to_usec\n");
 
-        rate = clk_get_rate(pdata->sysclk);
+        rate = pdata->sysclk_rate;
 
         /*
          * Convert the input watchdog timer value to the usec value. Each
@@ -673,6 +674,9 @@ static void xgbe_enable_mac_interrupts(struct xgbe_prv_data *pdata)
 
 static int xgbe_set_gmii_speed(struct xgbe_prv_data *pdata)
 {
+        if (XGMAC_IOREAD_BITS(pdata, MAC_TCR, SS) == 0x3)
+                return 0;
+
         XGMAC_IOWRITE_BITS(pdata, MAC_TCR, SS, 0x3);
 
         return 0;
@@ -680,6 +684,9 @@ static int xgbe_set_gmii_speed(struct xgbe_prv_data *pdata)
 
 static int xgbe_set_gmii_2500_speed(struct xgbe_prv_data *pdata)
 {
+        if (XGMAC_IOREAD_BITS(pdata, MAC_TCR, SS) == 0x2)
+                return 0;
+
         XGMAC_IOWRITE_BITS(pdata, MAC_TCR, SS, 0x2);
 
         return 0;
@@ -687,6 +694,9 @@ static int xgbe_set_gmii_2500_speed(struct xgbe_prv_data *pdata)
 
 static int xgbe_set_xgmii_speed(struct xgbe_prv_data *pdata)
 {
+        if (XGMAC_IOREAD_BITS(pdata, MAC_TCR, SS) == 0)
+                return 0;
+
         XGMAC_IOWRITE_BITS(pdata, MAC_TCR, SS, 0);
 
         return 0;
@@ -881,6 +891,23 @@ static void xgbe_write_mmd_regs(struct xgbe_prv_data *pdata, int prtad,
         else
                 mmd_address = (pdata->mdio_mmd << 16) | (mmd_reg & 0xffff);
 
+        /* If the PCS is changing modes, match the MAC speed to it */
+        if (((mmd_address >> 16) == MDIO_MMD_PCS) &&
+            ((mmd_address & 0xffff) == MDIO_CTRL2)) {
+                struct phy_device *phydev = pdata->phydev;
+
+                if (mmd_data & MDIO_PCS_CTRL2_TYPE) {
+                        /* KX mode */
+                        if (phydev->supported & SUPPORTED_1000baseKX_Full)
+                                xgbe_set_gmii_speed(pdata);
+                        else
+                                xgbe_set_gmii_2500_speed(pdata);
+                } else {
+                        /* KR mode */
+                        xgbe_set_xgmii_speed(pdata);
+                }
+        }
+
         /* The PCS registers are accessed using mmio. The underlying APB3
          * management interface uses indirect addressing to access the MMD
          * register sets. This requires accessing of the PCS register in two
@@ -1359,6 +1386,7 @@ static void xgbe_dev_xmit(struct xgbe_channel *channel)
         unsigned int tso_context, vlan_context;
         unsigned int tx_set_ic;
         int start_index = ring->cur;
+        int cur_index = ring->cur;
         int i;
 
         DBGPR("-->xgbe_dev_xmit\n");
@@ -1401,7 +1429,7 @@ static void xgbe_dev_xmit(struct xgbe_channel *channel)
         else
                 tx_set_ic = 0;
 
-        rdata = XGBE_GET_DESC_DATA(ring, ring->cur);
+        rdata = XGBE_GET_DESC_DATA(ring, cur_index);
         rdesc = rdata->rdesc;
 
         /* Create a context descriptor if this is a TSO packet */
@@ -1444,8 +1472,8 @@ static void xgbe_dev_xmit(struct xgbe_channel *channel)
                         ring->tx.cur_vlan_ctag = packet->vlan_ctag;
                 }
 
-                ring->cur++;
-                rdata = XGBE_GET_DESC_DATA(ring, ring->cur);
+                cur_index++;
+                rdata = XGBE_GET_DESC_DATA(ring, cur_index);
                 rdesc = rdata->rdesc;
         }
 
@@ -1473,7 +1501,7 @@ static void xgbe_dev_xmit(struct xgbe_channel *channel)
         XGMAC_SET_BITS_LE(rdesc->desc3, TX_NORMAL_DESC3, CTXT, 0);
 
         /* Set OWN bit if not the first descriptor */
-        if (ring->cur != start_index)
+        if (cur_index != start_index)
                 XGMAC_SET_BITS_LE(rdesc->desc3, TX_NORMAL_DESC3, OWN, 1);
 
         if (tso) {
@@ -1497,9 +1525,9 @@ static void xgbe_dev_xmit(struct xgbe_channel *channel)
                                   packet->length);
         }
 
-        for (i = ring->cur - start_index + 1; i < packet->rdesc_count; i++) {
-                ring->cur++;
-                rdata = XGBE_GET_DESC_DATA(ring, ring->cur);
+        for (i = cur_index - start_index + 1; i < packet->rdesc_count; i++) {
+                cur_index++;
+                rdata = XGBE_GET_DESC_DATA(ring, cur_index);
                 rdesc = rdata->rdesc;
 
                 /* Update buffer address */
@@ -1551,7 +1579,7 @@ static void xgbe_dev_xmit(struct xgbe_channel *channel)
         /* Make sure ownership is written to the descriptor */
         wmb();
 
-        ring->cur++;
+        ring->cur = cur_index + 1;
         if (!packet->skb->xmit_more ||
             netif_xmit_stopped(netdev_get_tx_queue(pdata->netdev,
                                                    channel->queue_index)))
@@ -2107,6 +2135,23 @@ static void xgbe_config_jumbo_enable(struct xgbe_prv_data *pdata)
         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, JE, val);
 }
 
+static void xgbe_config_mac_speed(struct xgbe_prv_data *pdata)
+{
+        switch (pdata->phy_speed) {
+        case SPEED_10000:
+                xgbe_set_xgmii_speed(pdata);
+                break;
+
+        case SPEED_2500:
+                xgbe_set_gmii_2500_speed(pdata);
+                break;
+
+        case SPEED_1000:
+                xgbe_set_gmii_speed(pdata);
+                break;
+        }
+}
+
 static void xgbe_config_checksum_offload(struct xgbe_prv_data *pdata)
 {
         if (pdata->netdev->features & NETIF_F_RXCSUM)
@@ -2757,6 +2802,7 @@ static int xgbe_init(struct xgbe_prv_data *pdata)
         xgbe_config_mac_address(pdata);
         xgbe_config_jumbo_enable(pdata);
         xgbe_config_flow_control(pdata);
+        xgbe_config_mac_speed(pdata);
         xgbe_config_checksum_offload(pdata);
         xgbe_config_vlan_support(pdata);
         xgbe_config_mmc(pdata);
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
index e5ffb2ccb67d..b93d4404d975 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
@@ -225,6 +225,11 @@ static inline unsigned int xgbe_tx_avail_desc(struct xgbe_ring *ring)
         return (ring->rdesc_count - (ring->cur - ring->dirty));
 }
 
+static inline unsigned int xgbe_rx_dirty_desc(struct xgbe_ring *ring)
+{
+        return (ring->cur - ring->dirty);
+}
+
 static int xgbe_maybe_stop_tx_queue(struct xgbe_channel *channel,
                                     struct xgbe_ring *ring, unsigned int count)
 {
@@ -337,12 +342,13 @@ static irqreturn_t xgbe_isr(int irq, void *data)
                 dma_ch_isr = XGMAC_DMA_IOREAD(channel, DMA_CH_SR);
                 DBGPR("  DMA_CH%u_ISR = %08x\n", i, dma_ch_isr);
 
-                /* If we get a TI or RI interrupt that means per channel DMA
-                 * interrupts are not enabled, so we use the private data napi
-                 * structure, not the per channel napi structure
+                /* The TI or RI interrupt bits may still be set even if using
+                 * per channel DMA interrupts. Check to be sure those are not
+                 * enabled before using the private data napi structure.
                  */
-                if (XGMAC_GET_BITS(dma_ch_isr, DMA_CH_SR, TI) ||
-                    XGMAC_GET_BITS(dma_ch_isr, DMA_CH_SR, RI)) {
+                if (!pdata->per_channel_irq &&
+                    (XGMAC_GET_BITS(dma_ch_isr, DMA_CH_SR, TI) ||
+                     XGMAC_GET_BITS(dma_ch_isr, DMA_CH_SR, RI))) {
                         if (napi_schedule_prep(&pdata->napi)) {
                                 /* Disable Tx and Rx interrupts */
                                 xgbe_disable_rx_tx_ints(pdata);
@@ -410,17 +416,13 @@ static enum hrtimer_restart xgbe_tx_timer(struct hrtimer *timer)
         struct xgbe_channel *channel = container_of(timer,
                                                     struct xgbe_channel,
                                                     tx_timer);
-        struct xgbe_ring *ring = channel->tx_ring;
         struct xgbe_prv_data *pdata = channel->pdata;
         struct napi_struct *napi;
-        unsigned long flags;
 
         DBGPR("-->xgbe_tx_timer\n");
 
         napi = (pdata->per_channel_irq) ? &channel->napi : &pdata->napi;
 
-        spin_lock_irqsave(&ring->lock, flags);
-
         if (napi_schedule_prep(napi)) {
                 /* Disable Tx and Rx interrupts */
                 if (pdata->per_channel_irq)
@@ -434,8 +436,6 @@ static enum hrtimer_restart xgbe_tx_timer(struct hrtimer *timer)
 
         channel->tx_timer_active = 0;
 
-        spin_unlock_irqrestore(&ring->lock, flags);
-
         DBGPR("<--xgbe_tx_timer\n");
 
         return HRTIMER_NORESTART;
@@ -694,7 +694,7 @@ static void xgbe_adjust_link(struct net_device *netdev)
         struct phy_device *phydev = pdata->phydev;
         int new_state = 0;
 
-        if (phydev == NULL)
+        if (!phydev)
                 return;
 
         if (phydev->link) {
@@ -929,7 +929,7 @@ static void xgbe_stop(struct xgbe_prv_data *pdata)
         DBGPR("<--xgbe_stop\n");
 }
 
-static void xgbe_restart_dev(struct xgbe_prv_data *pdata, unsigned int reset)
+static void xgbe_restart_dev(struct xgbe_prv_data *pdata)
 {
         struct xgbe_channel *channel;
         struct xgbe_hw_if *hw_if = &pdata->hw_if;
@@ -952,9 +952,8 @@ static void xgbe_restart_dev(struct xgbe_prv_data *pdata, unsigned int reset)
         xgbe_free_tx_data(pdata);
         xgbe_free_rx_data(pdata);
 
-        /* Issue software reset to device if requested */
-        if (reset)
-                hw_if->exit(pdata);
+        /* Issue software reset to device */
+        hw_if->exit(pdata);
 
         xgbe_start(pdata);
 
@@ -969,7 +968,7 @@ static void xgbe_restart(struct work_struct *work)
 
         rtnl_lock();
 
-        xgbe_restart_dev(pdata, 1);
+        xgbe_restart_dev(pdata);
 
         rtnl_unlock();
 }
@@ -1167,8 +1166,8 @@ static void xgbe_prep_tx_tstamp(struct xgbe_prv_data *pdata,
 
 static void xgbe_prep_vlan(struct sk_buff *skb, struct xgbe_packet_data *packet)
 {
-        if (vlan_tx_tag_present(skb))
-                packet->vlan_ctag = vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb))
+                packet->vlan_ctag = skb_vlan_tag_get(skb);
 }
 
 static int xgbe_prep_tso(struct sk_buff *skb, struct xgbe_packet_data *packet)
@@ -1249,9 +1248,9 @@ static void xgbe_packet_info(struct xgbe_prv_data *pdata,
                 XGMAC_SET_BITS(packet->attributes, TX_PACKET_ATTRIBUTES,
                                CSUM_ENABLE, 1);
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 /* VLAN requires an extra descriptor if tag is different */
-                if (vlan_tx_tag_get(skb) != ring->tx.cur_vlan_ctag)
+                if (skb_vlan_tag_get(skb) != ring->tx.cur_vlan_ctag)
                         /* We can share with the TSO context descriptor */
                         if (!context_desc) {
                                 context_desc = 1;
@@ -1448,7 +1447,6 @@ static int xgbe_xmit(struct sk_buff *skb, struct net_device *netdev)
         struct xgbe_ring *ring;
         struct xgbe_packet_data *packet;
         struct netdev_queue *txq;
-        unsigned long flags;
         int ret;
 
         DBGPR("-->xgbe_xmit: skb->len = %d\n", skb->len);
@@ -1460,8 +1458,6 @@ static int xgbe_xmit(struct sk_buff *skb, struct net_device *netdev)
 
         ret = NETDEV_TX_OK;
 
-        spin_lock_irqsave(&ring->lock, flags);
-
         if (skb->len == 0) {
                 netdev_err(netdev, "empty skb received from stack\n");
                 dev_kfree_skb_any(skb);
@@ -1508,10 +1504,6 @@ static int xgbe_xmit(struct sk_buff *skb, struct net_device *netdev)
         ret = NETDEV_TX_OK;
 
 tx_netdev_return:
-        spin_unlock_irqrestore(&ring->lock, flags);
-
-        DBGPR("<--xgbe_xmit\n");
-
         return ret;
 }
 
@@ -1589,7 +1581,7 @@ static int xgbe_change_mtu(struct net_device *netdev, int mtu)
         pdata->rx_buf_size = ret;
         netdev->mtu = mtu;
 
-        xgbe_restart_dev(pdata, 0);
+        xgbe_restart_dev(pdata);
 
         DBGPR("<--xgbe_change_mtu\n");
 
@@ -1778,15 +1770,28 @@ struct net_device_ops *xgbe_get_netdev_ops(void)
 static void xgbe_rx_refresh(struct xgbe_channel *channel)
 {
         struct xgbe_prv_data *pdata = channel->pdata;
+        struct xgbe_hw_if *hw_if = &pdata->hw_if;
         struct xgbe_desc_if *desc_if = &pdata->desc_if;
         struct xgbe_ring *ring = channel->rx_ring;
         struct xgbe_ring_data *rdata;
 
-        desc_if->realloc_rx_buffer(channel);
+        while (ring->dirty != ring->cur) {
+                rdata = XGBE_GET_DESC_DATA(ring, ring->dirty);
+
+                /* Reset rdata values */
+                desc_if->unmap_rdata(pdata, rdata);
+
+                if (desc_if->map_rx_buffer(pdata, ring, rdata))
+                        break;
+
+                hw_if->rx_desc_reset(rdata);
+
+                ring->dirty++;
+        }
 
         /* Update the Rx Tail Pointer Register with address of
          * the last cleaned entry */
-        rdata = XGBE_GET_DESC_DATA(ring, ring->rx.realloc_index - 1);
+        rdata = XGBE_GET_DESC_DATA(ring, ring->dirty - 1);
         XGMAC_DMA_IOWRITE(channel, DMA_CH_RDTR_LO,
                           lower_32_bits(rdata->rdesc_dma));
 }
@@ -1826,7 +1831,6 @@ static int xgbe_tx_poll(struct xgbe_channel *channel)
         struct xgbe_ring_desc *rdesc;
         struct net_device *netdev = pdata->netdev;
         struct netdev_queue *txq;
-        unsigned long flags;
         int processed = 0;
         unsigned int tx_packets = 0, tx_bytes = 0;
 
@@ -1838,8 +1842,6 @@ static int xgbe_tx_poll(struct xgbe_channel *channel)
 
         txq = netdev_get_tx_queue(netdev, channel->queue_index);
 
-        spin_lock_irqsave(&ring->lock, flags);
-
         while ((processed < XGBE_TX_DESC_MAX_PROC) &&
                (ring->dirty != ring->cur)) {
                 rdata = XGBE_GET_DESC_DATA(ring, ring->dirty);
@@ -1870,7 +1872,7 @@ static int xgbe_tx_poll(struct xgbe_channel *channel)
         }
 
         if (!processed)
-                goto unlock;
+                return 0;
 
         netdev_tx_completed_queue(txq, tx_packets, tx_bytes);
 
@@ -1882,9 +1884,6 @@ static int xgbe_tx_poll(struct xgbe_channel *channel)
 
         DBGPR("<--xgbe_tx_poll: processed=%d\n", processed);
 
-unlock:
-        spin_unlock_irqrestore(&ring->lock, flags);
-
         return processed;
 }
 
@@ -1936,7 +1935,7 @@ static int xgbe_rx_poll(struct xgbe_channel *channel, int budget)
 read_again:
                 rdata = XGBE_GET_DESC_DATA(ring, ring->cur);
 
-                if (ring->dirty > (XGBE_RX_DESC_CNT >> 3))
+                if (xgbe_rx_dirty_desc(ring) > (XGBE_RX_DESC_CNT >> 3))
                         xgbe_rx_refresh(channel);
 
                 if (hw_if->dev_read(channel))
@@ -1944,7 +1943,6 @@ read_again:
 
                 received++;
                 ring->cur++;
-                ring->dirty++;
 
                 incomplete = XGMAC_GET_BITS(packet->attributes,
                                             RX_PACKET_ATTRIBUTES,
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-main.c b/drivers/net/ethernet/amd/xgbe/xgbe-main.c
index dbd3850b8b0a..32dd65137051 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-main.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-main.c
@@ -123,7 +123,10 @@
 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_net.h>
+#include <linux/of_address.h>
 #include <linux/clk.h>
+#include <linux/property.h>
+#include <linux/acpi.h>
 
 #include "xgbe.h"
 #include "xgbe-common.h"
@@ -148,6 +151,7 @@ static void xgbe_default_config(struct xgbe_prv_data *pdata)
         pdata->pause_autoneg = 1;
         pdata->tx_pause = 1;
         pdata->rx_pause = 1;
+        pdata->phy_speed = SPEED_UNKNOWN;
         pdata->power_down = 0;
         pdata->default_autoneg = AUTONEG_ENABLE;
         pdata->default_speed = SPEED_10000;
@@ -161,6 +165,96 @@ static void xgbe_init_all_fptrs(struct xgbe_prv_data *pdata)
         xgbe_init_function_ptrs_desc(&pdata->desc_if);
 }
 
+#ifdef CONFIG_ACPI
+static int xgbe_acpi_support(struct xgbe_prv_data *pdata)
+{
+        struct acpi_device *adev = pdata->adev;
+        struct device *dev = pdata->dev;
+        u32 property;
+        acpi_handle handle;
+        acpi_status status;
+        unsigned long long data;
+        int cca;
+        int ret;
+
+        /* Obtain the system clock setting */
+        ret = device_property_read_u32(dev, XGBE_ACPI_DMA_FREQ, &property);
+        if (ret) {
+                dev_err(dev, "unable to obtain %s property\n",
+                        XGBE_ACPI_DMA_FREQ);
+                return ret;
+        }
+        pdata->sysclk_rate = property;
+
+        /* Obtain the PTP clock setting */
+        ret = device_property_read_u32(dev, XGBE_ACPI_PTP_FREQ, &property);
+        if (ret) {
+                dev_err(dev, "unable to obtain %s property\n",
+                        XGBE_ACPI_PTP_FREQ);
+                return ret;
+        }
+        pdata->ptpclk_rate = property;
+
+        /* Retrieve the device cache coherency value */
+        handle = adev->handle;
+        do {
+                status = acpi_evaluate_integer(handle, "_CCA", NULL, &data);
+                if (!ACPI_FAILURE(status)) {
+                        cca = data;
+                        break;
+                }
+
+                status = acpi_get_parent(handle, &handle);
+        } while (!ACPI_FAILURE(status));
+
+        if (ACPI_FAILURE(status)) {
+                dev_err(dev, "error obtaining acpi coherency value\n");
+                return -EINVAL;
+        }
+        pdata->coherent = !!cca;
+
+        return 0;
+}
+#else   /* CONFIG_ACPI */
+static int xgbe_acpi_support(struct xgbe_prv_data *pdata)
+{
+        return -EINVAL;
+}
+#endif  /* CONFIG_ACPI */
+
+#ifdef CONFIG_OF
+static int xgbe_of_support(struct xgbe_prv_data *pdata)
+{
+        struct device *dev = pdata->dev;
+
+        /* Obtain the system clock setting */
+        pdata->sysclk = devm_clk_get(dev, XGBE_DMA_CLOCK);
+        if (IS_ERR(pdata->sysclk)) {
+                dev_err(dev, "dma devm_clk_get failed\n");
+                return PTR_ERR(pdata->sysclk);
+        }
+        pdata->sysclk_rate = clk_get_rate(pdata->sysclk);
+
+        /* Obtain the PTP clock setting */
+        pdata->ptpclk = devm_clk_get(dev, XGBE_PTP_CLOCK);
+        if (IS_ERR(pdata->ptpclk)) {
+                dev_err(dev, "ptp devm_clk_get failed\n");
+                return PTR_ERR(pdata->ptpclk);
+        }
+        pdata->ptpclk_rate = clk_get_rate(pdata->ptpclk);
+
+        /* Retrieve the device cache coherency value */
+        pdata->coherent = of_dma_is_coherent(dev->of_node);
+
+        return 0;
+}
+#else   /* CONFIG_OF */
+static int xgbe_of_support(struct xgbe_prv_data *pdata)
+{
+        return -EINVAL;
+}
+#endif  /*CONFIG_OF */
+
 static int xgbe_probe(struct platform_device *pdev)
 {
         struct xgbe_prv_data *pdata;
@@ -169,7 +263,7 @@ static int xgbe_probe(struct platform_device *pdev)
         struct net_device *netdev;
         struct device *dev = &pdev->dev;
         struct resource *res;
-        const u8 *mac_addr;
+        const char *phy_mode;
         unsigned int i;
         int ret;
 
@@ -186,6 +280,7 @@ static int xgbe_probe(struct platform_device *pdev)
         pdata = netdev_priv(netdev);
         pdata->netdev = netdev;
         pdata->pdev = pdev;
+        pdata->adev = ACPI_COMPANION(dev);
         pdata->dev = dev;
         platform_set_drvdata(pdev, netdev);
 
@@ -194,6 +289,9 @@ static int xgbe_probe(struct platform_device *pdev)
         mutex_init(&pdata->rss_mutex);
         spin_lock_init(&pdata->tstamp_lock);
 
+        /* Check if we should use ACPI or DT */
+        pdata->use_acpi = (!pdata->adev || acpi_disabled) ? 0 : 1;
+
         /* Set and validate the number of descriptors for a ring */
         BUILD_BUG_ON_NOT_POWER_OF_2(XGBE_TX_DESC_CNT);
         pdata->tx_desc_count = XGBE_TX_DESC_CNT;
@@ -212,22 +310,6 @@ static int xgbe_probe(struct platform_device *pdev)
                 goto err_io;
         }
 
-        /* Obtain the system clock setting */
-        pdata->sysclk = devm_clk_get(dev, XGBE_DMA_CLOCK);
-        if (IS_ERR(pdata->sysclk)) {
-                dev_err(dev, "dma devm_clk_get failed\n");
-                ret = PTR_ERR(pdata->sysclk);
-                goto err_io;
-        }
-
-        /* Obtain the PTP clock setting */
-        pdata->ptpclk = devm_clk_get(dev, XGBE_PTP_CLOCK);
-        if (IS_ERR(pdata->ptpclk)) {
-                dev_err(dev, "ptp devm_clk_get failed\n");
-                ret = PTR_ERR(pdata->ptpclk);
-                goto err_io;
-        }
-
         /* Obtain the mmio areas for the device */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         pdata->xgmac_regs = devm_ioremap_resource(dev, res);
@@ -247,16 +329,42 @@ static int xgbe_probe(struct platform_device *pdev)
         }
         DBGPR("  xpcs_regs  = %p\n", pdata->xpcs_regs);
 
-        /* Set the DMA mask */
-        if (!dev->dma_mask)
-                dev->dma_mask = &dev->coherent_dma_mask;
-        ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(40));
-        if (ret) {
-                dev_err(dev, "dma_set_mask_and_coherent failed\n");
+        /* Retrieve the MAC address */
+        ret = device_property_read_u8_array(dev, XGBE_MAC_ADDR_PROPERTY,
+                                            pdata->mac_addr,
+                                            sizeof(pdata->mac_addr));
+        if (ret || !is_valid_ether_addr(pdata->mac_addr)) {
+                dev_err(dev, "invalid %s property\n", XGBE_MAC_ADDR_PROPERTY);
+                if (!ret)
+                        ret = -EINVAL;
                 goto err_io;
         }
 
-        if (of_property_read_bool(dev->of_node, "dma-coherent")) {
+        /* Retrieve the PHY mode - it must be "xgmii" */
+        ret = device_property_read_string(dev, XGBE_PHY_MODE_PROPERTY,
+                                          &phy_mode);
+        if (ret || strcmp(phy_mode, phy_modes(PHY_INTERFACE_MODE_XGMII))) {
+                dev_err(dev, "invalid %s property\n", XGBE_PHY_MODE_PROPERTY);
+                if (!ret)
+                        ret = -EINVAL;
+                goto err_io;
+        }
+        pdata->phy_mode = PHY_INTERFACE_MODE_XGMII;
+
+        /* Check for per channel interrupt support */
+        if (device_property_present(dev, XGBE_DMA_IRQS_PROPERTY))
+                pdata->per_channel_irq = 1;
+
+        /* Obtain device settings unique to ACPI/OF */
+        if (pdata->use_acpi)
+                ret = xgbe_acpi_support(pdata);
+        else
+                ret = xgbe_of_support(pdata);
+        if (ret)
+                goto err_io;
+
+        /* Set the DMA coherency values */
+        if (pdata->coherent) {
                 pdata->axdomain = XGBE_DMA_OS_AXDOMAIN;
                 pdata->arcache = XGBE_DMA_OS_ARCACHE;
                 pdata->awcache = XGBE_DMA_OS_AWCACHE;
@@ -266,10 +374,16 @@ static int xgbe_probe(struct platform_device *pdev)
                 pdata->awcache = XGBE_DMA_SYS_AWCACHE;
         }
 
-        /* Check for per channel interrupt support */
-        if (of_property_read_bool(dev->of_node, XGBE_DMA_IRQS))
-                pdata->per_channel_irq = 1;
+        /* Set the DMA mask */
+        if (!dev->dma_mask)
+                dev->dma_mask = &dev->coherent_dma_mask;
+        ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(40));
+        if (ret) {
+                dev_err(dev, "dma_set_mask_and_coherent failed\n");
+                goto err_io;
+        }
 
+        /* Get the device interrupt */
         ret = platform_get_irq(pdev, 0);
         if (ret < 0) {
                 dev_err(dev, "platform_get_irq 0 failed\n");
@@ -279,6 +393,7 @@ static int xgbe_probe(struct platform_device *pdev)
 
         netdev->irq = pdata->dev_irq;
         netdev->base_addr = (unsigned long)pdata->xgmac_regs;
+        memcpy(netdev->dev_addr, pdata->mac_addr, netdev->addr_len);
 
         /* Set all the function pointers */
         xgbe_init_all_fptrs(pdata);
@@ -291,23 +406,6 @@ static int xgbe_probe(struct platform_device *pdev)
         /* Populate the hardware features */
         xgbe_get_all_hw_features(pdata);
 
-        /* Retrieve the MAC address */
-        mac_addr = of_get_mac_address(dev->of_node);
-        if (!mac_addr) {
-                dev_err(dev, "invalid mac address for this device\n");
-                ret = -EINVAL;
-                goto err_io;
-        }
-        memcpy(netdev->dev_addr, mac_addr, netdev->addr_len);
-
-        /* Retrieve the PHY mode - it must be "xgmii" */
-        pdata->phy_mode = of_get_phy_mode(dev->of_node);
-        if (pdata->phy_mode != PHY_INTERFACE_MODE_XGMII) {
-                dev_err(dev, "invalid phy-mode specified for this device\n");
-                ret = -EINVAL;
-                goto err_io;
-        }
-
         /* Set default configuration data */
         xgbe_default_config(pdata);
 
@@ -491,18 +589,35 @@ static int xgbe_resume(struct device *dev)
 }
 #endif /* CONFIG_PM */
 
+#ifdef CONFIG_ACPI
+static const struct acpi_device_id xgbe_acpi_match[] = {
+        { "AMDI8001", 0 },
+        {},
+};
+
+MODULE_DEVICE_TABLE(acpi, xgbe_acpi_match);
+#endif
+
+#ifdef CONFIG_OF
 static const struct of_device_id xgbe_of_match[] = {
         { .compatible = "amd,xgbe-seattle-v1a", },
         {},
 };
 
 MODULE_DEVICE_TABLE(of, xgbe_of_match);
+#endif
+
 static SIMPLE_DEV_PM_OPS(xgbe_pm_ops, xgbe_suspend, xgbe_resume);
 
 static struct platform_driver xgbe_driver = {
         .driver = {
                 .name = "amd-xgbe",
+#ifdef CONFIG_ACPI
+                .acpi_match_table = xgbe_acpi_match,
+#endif
+#ifdef CONFIG_OF
                 .of_match_table = xgbe_of_match,
+#endif
                 .pm = &xgbe_pm_ops,
         },
         .probe = xgbe_probe,
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c b/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
index 363b210560f3..59e267f3f1b7 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
@@ -205,25 +205,16 @@ void xgbe_dump_phy_registers(struct xgbe_prv_data *pdata)
 
 int xgbe_mdio_register(struct xgbe_prv_data *pdata)
 {
-        struct device_node *phy_node;
         struct mii_bus *mii;
         struct phy_device *phydev;
         int ret = 0;
 
         DBGPR("-->xgbe_mdio_register\n");
 
-        /* Retrieve the phy-handle */
-        phy_node = of_parse_phandle(pdata->dev->of_node, "phy-handle", 0);
-        if (!phy_node) {
-                dev_err(pdata->dev, "unable to parse phy-handle\n");
-                return -EINVAL;
-        }
-
         mii = mdiobus_alloc();
-        if (mii == NULL) {
+        if (!mii) {
                 dev_err(pdata->dev, "mdiobus_alloc failed\n");
-                ret = -ENOMEM;
-                goto err_node_get;
+                return -ENOMEM;
         }
 
         /* Register on the MDIO bus (don't probe any PHYs) */
@@ -252,18 +243,19 @@ int xgbe_mdio_register(struct xgbe_prv_data *pdata)
         request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,
                        MDIO_ID_ARGS(phydev->c45_ids.device_ids[MDIO_MMD_PCS]));
 
-        of_node_get(phy_node);
-        phydev->dev.of_node = phy_node;
         ret = phy_device_register(phydev);
         if (ret) {
                 dev_err(pdata->dev, "phy_device_register failed\n");
-                of_node_put(phy_node);
+                goto err_phy_device;
+        }
+        if (!phydev->dev.driver) {
+                dev_err(pdata->dev, "phy driver probe failed\n");
+                ret = -EIO;
                 goto err_phy_device;
         }
 
         /* Add a reference to the PHY driver so it can't be unloaded */
-        pdata->phy_module = phydev->dev.driver ?
-                            phydev->dev.driver->owner : NULL;
+        pdata->phy_module = phydev->dev.driver->owner;
         if (!try_module_get(pdata->phy_module)) {
                 dev_err(pdata->dev, "try_module_get failed\n");
                 ret = -EIO;
@@ -283,8 +275,6 @@ int xgbe_mdio_register(struct xgbe_prv_data *pdata)
 
         pdata->phydev = phydev;
 
-        of_node_put(phy_node);
-
         DBGPHY_REGS(pdata);
 
         DBGPR("<--xgbe_mdio_register\n");
@@ -300,9 +290,6 @@ err_mdiobus_register:
 err_mdiobus_alloc:
         mdiobus_free(mii);
 
-err_node_get:
-        of_node_put(phy_node);
-
         return ret;
 }
 
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-ptp.c b/drivers/net/ethernet/amd/xgbe/xgbe-ptp.c
index a1bf9d1cdae1..f326178ef376 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-ptp.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-ptp.c
@@ -171,15 +171,9 @@ static int xgbe_adjtime(struct ptp_clock_info *info, s64 delta)
                                                    struct xgbe_prv_data,
                                                    ptp_clock_info);
         unsigned long flags;
-        u64 nsec;
 
         spin_lock_irqsave(&pdata->tstamp_lock, flags);
-
-        nsec = timecounter_read(&pdata->tstamp_tc);
-
-        nsec += delta;
-        timecounter_init(&pdata->tstamp_tc, &pdata->tstamp_cc, nsec);
-
+        timecounter_adjtime(&pdata->tstamp_tc, delta);
         spin_unlock_irqrestore(&pdata->tstamp_lock, flags);
 
         return 0;
@@ -239,7 +233,7 @@ void xgbe_ptp_register(struct xgbe_prv_data *pdata)
         snprintf(info->name, sizeof(info->name), "%s",
                  netdev_name(pdata->netdev));
         info->owner = THIS_MODULE;
-        info->max_adj = clk_get_rate(pdata->ptpclk);
+        info->max_adj = pdata->ptpclk_rate;
         info->adjfreq = xgbe_adjfreq;
         info->adjtime = xgbe_adjtime;
         info->gettime = xgbe_gettime;
@@ -260,7 +254,7 @@ void xgbe_ptp_register(struct xgbe_prv_data *pdata)
          */
         dividend = 50000000;
         dividend <<= 32;
-        pdata->tstamp_addend = div_u64(dividend, clk_get_rate(pdata->ptpclk));
+        pdata->tstamp_addend = div_u64(dividend, pdata->ptpclk_rate);
 
         /* Setup the timecounter */
         cc->read = xgbe_cc_read;
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe.h b/drivers/net/ethernet/amd/xgbe/xgbe.h
index f9ec762ac3f0..13e8f95c077c 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe.h
+++ b/drivers/net/ethernet/amd/xgbe/xgbe.h
@@ -124,7 +124,7 @@
 #include <linux/if_vlan.h>
 #include <linux/bitops.h>
 #include <linux/ptp_clock_kernel.h>
-#include <linux/clocksource.h>
+#include <linux/timecounter.h>
 #include <linux/net_tstamp.h>
 #include <net/dcbnl.h>
 
@@ -182,10 +182,18 @@
 #define XGBE_PHY_NAME           "amd_xgbe_phy"
 #define XGBE_PRTAD              0
 
+/* Common property names */
+#define XGBE_MAC_ADDR_PROPERTY  "mac-address"
+#define XGBE_PHY_MODE_PROPERTY  "phy-mode"
+#define XGBE_DMA_IRQS_PROPERTY  "amd,per-channel-interrupt"
+
 /* Device-tree clock names */
 #define XGBE_DMA_CLOCK          "dma_clk"
 #define XGBE_PTP_CLOCK          "ptp_clk"
-#define XGBE_DMA_IRQS           "amd,per-channel-interrupt"
+
+/* ACPI property names */
+#define XGBE_ACPI_DMA_FREQ      "amd,dma-freq"
+#define XGBE_ACPI_PTP_FREQ      "amd,ptp-freq"
 
 /* Timestamp support - values based on 50MHz PTP clock
  *   50MHz => 20 nsec
@@ -361,8 +369,7 @@ struct xgbe_ring {
          *  cur   - Tx: index of descriptor to be used for current transfer
          *          Rx: index of descriptor to check for packet availability
          *  dirty - Tx: index of descriptor to check for transfer complete
-         *          Rx: count of descriptors in which a packet has been received
-         *              (used with skb_realloc_index to refresh the ring)
+         *          Rx: index of descriptor to check for buffer reallocation
          */
         unsigned int cur;
         unsigned int dirty;
@@ -377,11 +384,6 @@ struct xgbe_ring {
                         unsigned short cur_mss;
                         unsigned short cur_vlan_ctag;
                 } tx;
-
-                struct {
-                        unsigned int realloc_index;
-                        unsigned int realloc_threshold;
-                } rx;
         };
 } ____cacheline_aligned;
 
@@ -596,7 +598,8 @@ struct xgbe_desc_if {
         int (*alloc_ring_resources)(struct xgbe_prv_data *);
         void (*free_ring_resources)(struct xgbe_prv_data *);
         int (*map_tx_skb)(struct xgbe_channel *, struct sk_buff *);
-        void (*realloc_rx_buffer)(struct xgbe_channel *);
+        int (*map_rx_buffer)(struct xgbe_prv_data *, struct xgbe_ring *,
+                             struct xgbe_ring_data *);
         void (*unmap_rdata)(struct xgbe_prv_data *, struct xgbe_ring_data *);
         void (*wrapper_tx_desc_init)(struct xgbe_prv_data *);
         void (*wrapper_rx_desc_init)(struct xgbe_prv_data *);
@@ -650,8 +653,12 @@ struct xgbe_hw_features {
 struct xgbe_prv_data {
         struct net_device *netdev;
         struct platform_device *pdev;
+        struct acpi_device *adev;
         struct device *dev;
 
+        /* ACPI or DT flag */
+        unsigned int use_acpi;
+
         /* XGMAC/XPCS related mmio registers */
         void __iomem *xgmac_regs;       /* XGMAC CSRs */
         void __iomem *xpcs_regs;        /* XPCS MMD registers */
@@ -672,6 +679,7 @@ struct xgbe_prv_data {
         struct xgbe_desc_if desc_if;
 
         /* AXI DMA settings */
+        unsigned int coherent;
         unsigned int axdomain;
         unsigned int arcache;
         unsigned int awcache;
@@ -739,6 +747,7 @@ struct xgbe_prv_data {
         unsigned int phy_rx_pause;
 
         /* Netdev related settings */
+        unsigned char mac_addr[ETH_ALEN];
         netdev_features_t netdev_features;
         struct napi_struct napi;
         struct xgbe_mmc_stats mmc_stats;
@@ -748,7 +757,9 @@ struct xgbe_prv_data {
 
         /* Device clocks */
         struct clk *sysclk;
+        unsigned long sysclk_rate;
         struct clk *ptpclk;
+        unsigned long ptpclk_rate;
 
         /* Timestamp support */
         spinlock_t tstamp_lock;
diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_hw.c b/drivers/net/ethernet/apm/xgene/xgene_enet_hw.c
index 7ba83ffb08ac..869d97fcf781 100644
--- a/drivers/net/ethernet/apm/xgene/xgene_enet_hw.c
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_hw.c
@@ -593,10 +593,12 @@ static int xgene_enet_reset(struct xgene_enet_pdata *pdata)
         if (!xgene_ring_mgr_init(pdata))
                 return -ENODEV;
 
-        clk_prepare_enable(pdata->clk);
-        clk_disable_unprepare(pdata->clk);
-        clk_prepare_enable(pdata->clk);
-        xgene_enet_ecc_init(pdata);
+        if (!efi_enabled(EFI_BOOT)) {
+                clk_prepare_enable(pdata->clk);
+                clk_disable_unprepare(pdata->clk);
+                clk_prepare_enable(pdata->clk);
+                xgene_enet_ecc_init(pdata);
+        }
         xgene_enet_config_ring_if_assoc(pdata);
 
         /* Enable auto-incr for scanning */
@@ -663,15 +665,20 @@ static int xgene_enet_phy_connect(struct net_device *ndev)
         struct phy_device *phy_dev;
         struct device *dev = &pdata->pdev->dev;
 
-        phy_np = of_parse_phandle(dev->of_node, "phy-handle", 0);
-        if (!phy_np) {
-                netdev_dbg(ndev, "No phy-handle found\n");
-                return -ENODEV;
+        if (dev->of_node) {
+                phy_np = of_parse_phandle(dev->of_node, "phy-handle", 0);
+                if (!phy_np) {
+                        netdev_dbg(ndev, "No phy-handle found in DT\n");
+                        return -ENODEV;
+                }
+                pdata->phy_dev = of_phy_find_device(phy_np);
         }
 
-        phy_dev = of_phy_connect(ndev, phy_np, &xgene_enet_adjust_link,
-                                 0, pdata->phy_mode);
-        if (!phy_dev) {
+        phy_dev = pdata->phy_dev;
+
+        if (!phy_dev ||
+            phy_connect_direct(ndev, phy_dev, &xgene_enet_adjust_link,
+                               pdata->phy_mode)) {
                 netdev_err(ndev, "Could not connect to PHY\n");
                 return  -ENODEV;
         }
@@ -681,32 +688,71 @@ static int xgene_enet_phy_connect(struct net_device *ndev)
                               ~SUPPORTED_100baseT_Half &
                               ~SUPPORTED_1000baseT_Half;
         phy_dev->advertising = phy_dev->supported;
-        pdata->phy_dev = phy_dev;
 
         return 0;
 }
 
-int xgene_enet_mdio_config(struct xgene_enet_pdata *pdata)
+static int xgene_mdiobus_register(struct xgene_enet_pdata *pdata,
+                                  struct mii_bus *mdio)
 {
-        struct net_device *ndev = pdata->ndev;
         struct device *dev = &pdata->pdev->dev;
+        struct net_device *ndev = pdata->ndev;
+        struct phy_device *phy;
         struct device_node *child_np;
         struct device_node *mdio_np = NULL;
-        struct mii_bus *mdio_bus;
         int ret;
+        u32 phy_id;
+
+        if (dev->of_node) {
+                for_each_child_of_node(dev->of_node, child_np) {
+                        if (of_device_is_compatible(child_np,
+                                                    "apm,xgene-mdio")) {
+                                mdio_np = child_np;
+                                break;
+                        }
+                }
 
-        for_each_child_of_node(dev->of_node, child_np) {
-                if (of_device_is_compatible(child_np, "apm,xgene-mdio")) {
-                        mdio_np = child_np;
-                        break;
+                if (!mdio_np) {
+                        netdev_dbg(ndev, "No mdio node in the dts\n");
+                        return -ENXIO;
                 }
-        }
 
-        if (!mdio_np) {
-                netdev_dbg(ndev, "No mdio node in the dts\n");
-                return -ENXIO;
+                return of_mdiobus_register(mdio, mdio_np);
         }
 
+        /* Mask out all PHYs from auto probing. */
+        mdio->phy_mask = ~0;
+
+        /* Register the MDIO bus */
+        ret = mdiobus_register(mdio);
+        if (ret)
+                return ret;
+
+        ret = device_property_read_u32(dev, "phy-channel", &phy_id);
+        if (ret)
+                ret = device_property_read_u32(dev, "phy-addr", &phy_id);
+        if (ret)
+                return -EINVAL;
+
+        phy = get_phy_device(mdio, phy_id, true);
+        if (!phy || IS_ERR(phy))
+                return -EIO;
+
+        ret = phy_device_register(phy);
+        if (ret)
+                phy_device_free(phy);
+        else
+                pdata->phy_dev = phy;
+
+        return ret;
+}
+
+int xgene_enet_mdio_config(struct xgene_enet_pdata *pdata)
+{
+        struct net_device *ndev = pdata->ndev;
+        struct mii_bus *mdio_bus;
+        int ret;
+
         mdio_bus = mdiobus_alloc();
         if (!mdio_bus)
                 return -ENOMEM;
@@ -720,7 +766,7 @@ int xgene_enet_mdio_config(struct xgene_enet_pdata *pdata)
         mdio_bus->priv = pdata;
         mdio_bus->parent = &ndev->dev;
 
-        ret = of_mdiobus_register(mdio_bus, mdio_np);
+        ret = xgene_mdiobus_register(pdata, mdio_bus);
         if (ret) {
                 netdev_err(ndev, "Failed to register MDIO bus\n");
                 mdiobus_free(mdio_bus);
diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_main.c b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
index 793f3b73eeff..44b15373d6b3 100644
--- a/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
@@ -24,6 +24,10 @@
 #include "xgene_enet_sgmac.h"
 #include "xgene_enet_xgmac.h"
 
+#define RES_ENET_CSR    0
+#define RES_RING_CSR    1
+#define RES_RING_CMD    2
+
 static void xgene_enet_init_bufpool(struct xgene_enet_desc_ring *buf_pool)
 {
         struct xgene_enet_raw_desc16 *raw_desc;
@@ -748,6 +752,41 @@ static const struct net_device_ops xgene_ndev_ops = {
         .ndo_set_mac_address = xgene_enet_set_mac_address,
 };
 
+static int xgene_get_mac_address(struct device *dev,
+                                 unsigned char *addr)
+{
+        int ret;
+
+        ret = device_property_read_u8_array(dev, "local-mac-address", addr, 6);
+        if (ret)
+                ret = device_property_read_u8_array(dev, "mac-address",
+                                                    addr, 6);
+        if (ret)
+                return -ENODEV;
+
+        return ETH_ALEN;
+}
+
+static int xgene_get_phy_mode(struct device *dev)
+{
+        int i, ret;
+        char *modestr;
+
+        ret = device_property_read_string(dev, "phy-connection-type",
+                                          (const char **)&modestr);
+        if (ret)
+                ret = device_property_read_string(dev, "phy-mode",
+                                                  (const char **)&modestr);
+        if (ret)
+                return -ENODEV;
+
+        for (i = 0; i < PHY_INTERFACE_MODE_MAX; i++) {
+                if (!strcasecmp(modestr, phy_modes(i)))
+                        return i;
+        }
+        return -ENODEV;
+}
+
 static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata)
 {
         struct platform_device *pdev;
@@ -755,32 +794,45 @@ static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata)
         struct device *dev;
         struct resource *res;
         void __iomem *base_addr;
-        const char *mac;
         int ret;
 
         pdev = pdata->pdev;
         dev = &pdev->dev;
         ndev = pdata->ndev;
 
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "enet_csr");
-        pdata->base_addr = devm_ioremap_resource(dev, res);
-        if (IS_ERR(pdata->base_addr)) {
+        res = platform_get_resource(pdev, IORESOURCE_MEM, RES_ENET_CSR);
+        if (!res) {
+                dev_err(dev, "Resource enet_csr not defined\n");
+                return -ENODEV;
+        }
+        pdata->base_addr = devm_ioremap(dev, res->start, resource_size(res));
+        if (!pdata->base_addr) {
                 dev_err(dev, "Unable to retrieve ENET Port CSR region\n");
-                return PTR_ERR(pdata->base_addr);
+                return -ENOMEM;
         }
 
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ring_csr");
-        pdata->ring_csr_addr = devm_ioremap_resource(dev, res);
-        if (IS_ERR(pdata->ring_csr_addr)) {
+        res = platform_get_resource(pdev, IORESOURCE_MEM, RES_RING_CSR);
+        if (!res) {
+                dev_err(dev, "Resource ring_csr not defined\n");
+                return -ENODEV;
+        }
+        pdata->ring_csr_addr = devm_ioremap(dev, res->start,
+                                                        resource_size(res));
+        if (!pdata->ring_csr_addr) {
                 dev_err(dev, "Unable to retrieve ENET Ring CSR region\n");
-                return PTR_ERR(pdata->ring_csr_addr);
+                return -ENOMEM;
         }
 
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ring_cmd");
-        pdata->ring_cmd_addr = devm_ioremap_resource(dev, res);
-        if (IS_ERR(pdata->ring_cmd_addr)) {
+        res = platform_get_resource(pdev, IORESOURCE_MEM, RES_RING_CMD);
+        if (!res) {
+                dev_err(dev, "Resource ring_cmd not defined\n");
+                return -ENODEV;
+        }
+        pdata->ring_cmd_addr = devm_ioremap(dev, res->start,
+                                                        resource_size(res));
+        if (!pdata->ring_cmd_addr) {
                 dev_err(dev, "Unable to retrieve ENET Ring command region\n");
-                return PTR_ERR(pdata->ring_cmd_addr);
+                return -ENOMEM;
         }
 
         ret = platform_get_irq(pdev, 0);
@@ -791,14 +843,12 @@ static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata)
         }
         pdata->rx_irq = ret;
 
-        mac = of_get_mac_address(dev->of_node);
-        if (mac)
-                memcpy(ndev->dev_addr, mac, ndev->addr_len);
-        else
+        if (xgene_get_mac_address(dev, ndev->dev_addr) != ETH_ALEN)
                 eth_hw_addr_random(ndev);
+
         memcpy(ndev->perm_addr, ndev->dev_addr, ndev->addr_len);
 
-        pdata->phy_mode = of_get_phy_mode(pdev->dev.of_node);
+        pdata->phy_mode = xgene_get_phy_mode(dev);
         if (pdata->phy_mode < 0) {
                 dev_err(dev, "Unable to get phy-connection-type\n");
                 return pdata->phy_mode;
@@ -811,11 +861,9 @@ static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata)
         }
 
         pdata->clk = devm_clk_get(&pdev->dev, NULL);
-        ret = IS_ERR(pdata->clk);
         if (IS_ERR(pdata->clk)) {
-                dev_err(&pdev->dev, "can't get clock\n");
-                ret = PTR_ERR(pdata->clk);
-                return ret;
+                /* Firmware may have set up the clock already. */
+                pdata->clk = NULL;
         }
 
         base_addr = pdata->base_addr;
@@ -926,7 +974,7 @@ static int xgene_enet_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
+        ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(64));
         if (ret) {
                 netdev_err(ndev, "No usable DMA configuration\n");
                 goto err;
@@ -974,17 +1022,26 @@ static int xgene_enet_remove(struct platform_device *pdev)
         return 0;
 }
 
-static struct of_device_id xgene_enet_match[] = {
+#ifdef CONFIG_ACPI
+static const struct acpi_device_id xgene_enet_acpi_match[] = {
+        { "APMC0D05", },
+        { }
+};
+MODULE_DEVICE_TABLE(acpi, xgene_enet_acpi_match);
+#endif
+
+static struct of_device_id xgene_enet_of_match[] = {
         {.compatible = "apm,xgene-enet",},
         {},
 };
 
-MODULE_DEVICE_TABLE(of, xgene_enet_match);
+MODULE_DEVICE_TABLE(of, xgene_enet_of_match);
 
 static struct platform_driver xgene_enet_driver = {
         .driver = {
                    .name = "xgene-enet",
-                   .of_match_table = xgene_enet_match,
+                   .of_match_table = of_match_ptr(xgene_enet_of_match),
+                   .acpi_match_table = ACPI_PTR(xgene_enet_acpi_match),
         },
         .probe = xgene_enet_probe,
         .remove = xgene_enet_remove,
diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_main.h b/drivers/net/ethernet/apm/xgene/xgene_enet_main.h
index f9958fae6ffd..c2d465c3db66 100644
--- a/drivers/net/ethernet/apm/xgene/xgene_enet_main.h
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_main.h
@@ -22,7 +22,10 @@
 #ifndef __XGENE_ENET_MAIN_H__
 #define __XGENE_ENET_MAIN_H__
 
+#include <linux/acpi.h>
 #include <linux/clk.h>
+#include <linux/efi.h>
+#include <linux/io.h>
 #include <linux/of_platform.h>
 #include <linux/of_net.h>
 #include <linux/of_mdio.h>
diff --git a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
index c9946c6c119e..587f63e87588 100644
--- a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
+++ b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
@@ -2235,8 +2235,8 @@ static netdev_tx_t atl1c_xmit_frame(struct sk_buff *skb,
                 return NETDEV_TX_OK;
         }
 
-        if (unlikely(vlan_tx_tag_present(skb))) {
-                u16 vlan = vlan_tx_tag_get(skb);
+        if (unlikely(skb_vlan_tag_present(skb))) {
+                u16 vlan = skb_vlan_tag_get(skb);
                 __le16 tag;
 
                 vlan = cpu_to_le16(vlan);
diff --git a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c
index 2326579f9454..59a03a193e83 100644
--- a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c
+++ b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c
@@ -1892,8 +1892,8 @@ static netdev_tx_t atl1e_xmit_frame(struct sk_buff *skb,
 
         tpd = atl1e_get_tpd(adapter);
 
-        if (vlan_tx_tag_present(skb)) {
-                u16 vlan_tag = vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb)) {
+                u16 vlan_tag = skb_vlan_tag_get(skb);
                 u16 atl1e_vlan_tag;
 
                 tpd->word3 |= 1 << TPD_INS_VL_TAG_SHIFT;
@@ -2373,9 +2373,8 @@ static int atl1e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         netif_napi_add(netdev, &adapter->napi, atl1e_clean, 64);
 
-        init_timer(&adapter->phy_config_timer);
-        adapter->phy_config_timer.function = atl1e_phy_config;
-        adapter->phy_config_timer.data = (unsigned long) adapter;
+        setup_timer(&adapter->phy_config_timer, atl1e_phy_config,
+                    (unsigned long)adapter);
 
         /* get user settings */
         atl1e_check_options(adapter);
diff --git a/drivers/net/ethernet/atheros/atlx/atl1.c b/drivers/net/ethernet/atheros/atlx/atl1.c
index 2c8f398aeda9..eca1d113fee1 100644
--- a/drivers/net/ethernet/atheros/atlx/atl1.c
+++ b/drivers/net/ethernet/atheros/atlx/atl1.c
@@ -2415,8 +2415,8 @@ static netdev_tx_t atl1_xmit_frame(struct sk_buff *skb,
                 (u16) atomic_read(&tpd_ring->next_to_use));
         memset(ptpd, 0, sizeof(struct tx_packet_desc));
 
-        if (vlan_tx_tag_present(skb)) {
-                vlan_tag = vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb)) {
+                vlan_tag = skb_vlan_tag_get(skb);
                 vlan_tag = (vlan_tag << 4) | (vlan_tag >> 13) |
                         ((vlan_tag >> 9) & 0x8);
                 ptpd->word3 |= 1 << TPD_INS_VL_TAG_SHIFT;
diff --git a/drivers/net/ethernet/atheros/atlx/atl2.c b/drivers/net/ethernet/atheros/atlx/atl2.c
index 84a09e8ddd9c..46a535318c7a 100644
--- a/drivers/net/ethernet/atheros/atlx/atl2.c
+++ b/drivers/net/ethernet/atheros/atlx/atl2.c
@@ -887,8 +887,8 @@ static netdev_tx_t atl2_xmit_frame(struct sk_buff *skb,
                 offset = ((u32)(skb->len-copy_len + 3) & ~3);
         }
 #ifdef NETIF_F_HW_VLAN_CTAG_TX
-        if (vlan_tx_tag_present(skb)) {
-                u16 vlan_tag = vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb)) {
+                u16 vlan_tag = skb_vlan_tag_get(skb);
                 vlan_tag = (vlan_tag << 4) |
                         (vlan_tag >> 13) |
                         ((vlan_tag >> 9) & 0x8);
@@ -1436,13 +1436,11 @@ static int atl2_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         atl2_check_options(adapter);
 
-        init_timer(&adapter->watchdog_timer);
-        adapter->watchdog_timer.function = atl2_watchdog;
-        adapter->watchdog_timer.data = (unsigned long) adapter;
+        setup_timer(&adapter->watchdog_timer, atl2_watchdog,
+                    (unsigned long)adapter);
 
-        init_timer(&adapter->phy_config_timer);
-        adapter->phy_config_timer.function = atl2_phy_config;
-        adapter->phy_config_timer.data = (unsigned long) adapter;
+        setup_timer(&adapter->phy_config_timer, atl2_phy_config,
+                    (unsigned long)adapter);
 
         INIT_WORK(&adapter->reset_task, atl2_reset_task);
         INIT_WORK(&adapter->link_chg_task, atl2_link_chg_task);
diff --git a/drivers/net/ethernet/broadcom/bnx2.c b/drivers/net/ethernet/broadcom/bnx2.c
index 823d01c5684c..02bf0b86995b 100644
--- a/drivers/net/ethernet/broadcom/bnx2.c
+++ b/drivers/net/ethernet/broadcom/bnx2.c
@@ -6597,9 +6597,9 @@ bnx2_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 vlan_tag_flags |= TX_BD_FLAGS_TCP_UDP_CKSUM;
         }
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 vlan_tag_flags |=
-                        (TX_BD_FLAGS_VLAN_TAG | (vlan_tx_tag_get(skb) << 16));
+                        (TX_BD_FLAGS_VLAN_TAG | (skb_vlan_tag_get(skb) << 16));
         }
 
         if ((mss = skb_shinfo(skb)->gso_size)) {
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
index c3a6072134f5..756053c028be 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
@@ -22,7 +22,7 @@
 
 #include <linux/ptp_clock_kernel.h>
 #include <linux/net_tstamp.h>
-#include <linux/clocksource.h>
+#include <linux/timecounter.h>
 
 /* compilation time flags */
 
@@ -1138,12 +1138,8 @@ struct bnx2x_port {
         u32                     link_config[LINK_CONFIG_SIZE];
 
         u32                     supported[LINK_CONFIG_SIZE];
-/* link settings - missing defines */
-#define SUPPORTED_2500baseX_Full        (1 << 15)
 
         u32                     advertising[LINK_CONFIG_SIZE];
-/* link settings - missing defines */
-#define ADVERTISED_2500baseX_Full       (1 << 15)
 
         u32                     phy_addr;
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
index e468ed3f210f..0a9faa134a9a 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
@@ -3865,9 +3865,9 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
            "sending pkt %u @%p  next_idx %u  bd %u @%p\n",
            pkt_prod, tx_buf, txdata->tx_pkt_prod, bd_prod, tx_start_bd);
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 tx_start_bd->vlan_or_ethertype =
-                    cpu_to_le16(vlan_tx_tag_get(skb));
+                    cpu_to_le16(skb_vlan_tag_get(skb));
                 tx_start_bd->bd_flags.as_bitfield |=
                     (X_ETH_OUTBAND_VLAN << ETH_TX_BD_FLAGS_VLAN_MODE_SHIFT);
         } else {
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index 72eef9fc883e..7155e1d2c208 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -9169,7 +9169,7 @@ static void bnx2x_disable_ptp(struct bnx2x *bp)
 }
 
 /* Called during unload, to stop PTP-related stuff */
-void bnx2x_stop_ptp(struct bnx2x *bp)
+static void bnx2x_stop_ptp(struct bnx2x *bp)
 {
         /* Cancel PTP work queue. Should be done after the Tx queues are
          * drained to prevent additional scheduling.
@@ -13267,14 +13267,10 @@ static int bnx2x_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
 static int bnx2x_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
 {
         struct bnx2x *bp = container_of(ptp, struct bnx2x, ptp_clock_info);
-        u64 now;
 
         DP(BNX2X_MSG_PTP, "PTP adjtime called, delta = %llx\n", delta);
 
-        now = timecounter_read(&bp->timecounter);
-        now += delta;
-        /* Re-init the timecounter */
-        timecounter_init(&bp->timecounter, &bp->cyclecounter, now);
+        timecounter_adjtime(&bp->timecounter, delta);
 
         return 0;
 }
@@ -13322,7 +13318,7 @@ static int bnx2x_ptp_enable(struct ptp_clock_info *ptp,
         return -ENOTSUPP;
 }
 
-void bnx2x_register_phc(struct bnx2x *bp)
+static void bnx2x_register_phc(struct bnx2x *bp)
 {
         /* Fill the ptp_clock_info struct and register PTP clock*/
         bp->ptp_clock_info.owner = THIS_MODULE;
@@ -14614,7 +14610,7 @@ static void bnx2x_init_cyclecounter(struct bnx2x *bp)
 {
         memset(&bp->cyclecounter, 0, sizeof(bp->cyclecounter));
         bp->cyclecounter.read = bnx2x_cyclecounter_read;
-        bp->cyclecounter.mask = CLOCKSOURCE_MASK(64);
+        bp->cyclecounter.mask = CYCLECOUNTER_MASK(64);
         bp->cyclecounter.shift = 1;
         bp->cyclecounter.mult = 1;
 }
@@ -14639,7 +14635,7 @@ static int bnx2x_send_reset_timesync_ramrod(struct bnx2x *bp)
         return bnx2x_func_state_change(bp, &func_params);
 }
 
-int bnx2x_enable_ptp_packets(struct bnx2x *bp)
+static int bnx2x_enable_ptp_packets(struct bnx2x *bp)
 {
         struct bnx2x_queue_state_params q_params;
         int rc, i;
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index 96bf01ba32dd..615a6dbde047 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -8008,9 +8008,9 @@ static netdev_tx_t tg3_start_xmit(struct sk_buff *skb, struct net_device *dev)
             !mss && skb->len > VLAN_ETH_FRAME_LEN)
                 base_flags |= TXD_FLAG_JMB_PKT;
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 base_flags |= TXD_FLAG_VLAN;
-                vlan = vlan_tx_tag_get(skb);
+                vlan = skb_vlan_tag_get(skb);
         }
 
         if ((unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) &&
@@ -11573,11 +11573,7 @@ static int tg3_start(struct tg3 *tp, bool reset_phy, bool test_irq,
         tg3_flag_set(tp, INIT_COMPLETE);
         tg3_enable_ints(tp);
 
-        if (init)
-                tg3_ptp_init(tp);
-        else
-                tg3_ptp_resume(tp);
-
+        tg3_ptp_resume(tp);
 
         tg3_full_unlock(tp);
 
@@ -11698,13 +11694,6 @@ static int tg3_open(struct net_device *dev)
                 pci_set_power_state(tp->pdev, PCI_D3hot);
         }
 
-        if (tg3_flag(tp, PTP_CAPABLE)) {
-                tp->ptp_clock = ptp_clock_register(&tp->ptp_info,
-                                                   &tp->pdev->dev);
-                if (IS_ERR(tp->ptp_clock))
-                        tp->ptp_clock = NULL;
-        }
-
         return err;
 }
 
@@ -11718,8 +11707,6 @@ static int tg3_close(struct net_device *dev)
                 return -EAGAIN;
         }
 
-        tg3_ptp_fini(tp);
-
         tg3_stop(tp);
 
         /* Clear stats across close / open calls */
@@ -17897,6 +17884,14 @@ static int tg3_init_one(struct pci_dev *pdev,
                 goto err_out_apeunmap;
         }
 
+        if (tg3_flag(tp, PTP_CAPABLE)) {
+                tg3_ptp_init(tp);
+                tp->ptp_clock = ptp_clock_register(&tp->ptp_info,
+                                                   &tp->pdev->dev);
+                if (IS_ERR(tp->ptp_clock))
+                        tp->ptp_clock = NULL;
+        }
+
         netdev_info(dev, "Tigon3 [partno(%s) rev %04x] (%s) MAC address %pM\n",
                     tp->board_part_number,
                     tg3_chip_rev_id(tp),
@@ -17972,6 +17967,8 @@ static void tg3_remove_one(struct pci_dev *pdev)
         if (dev) {
                 struct tg3 *tp = netdev_priv(dev);
 
+                tg3_ptp_fini(tp);
+
                 release_firmware(tp->fw);
 
                 tg3_reset_task_cancel(tp);
diff --git a/drivers/net/ethernet/brocade/bna/bnad.c b/drivers/net/ethernet/brocade/bna/bnad.c
index 323721838cf9..7714d7790089 100644
--- a/drivers/net/ethernet/brocade/bna/bnad.c
+++ b/drivers/net/ethernet/brocade/bna/bnad.c
@@ -2824,8 +2824,8 @@ bnad_txq_wi_prepare(struct bnad *bnad, struct bna_tcb *tcb,
         u32 gso_size;
         u16 vlan_tag = 0;
 
-        if (vlan_tx_tag_present(skb)) {
-                vlan_tag = (u16)vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb)) {
+                vlan_tag = (u16)skb_vlan_tag_get(skb);
                 flags |= (BNA_TXQ_WI_CF_INS_PRIO | BNA_TXQ_WI_CF_INS_VLAN);
         }
         if (test_bit(BNAD_RF_CEE_RUNNING, &bnad->run_flags)) {
diff --git a/drivers/net/ethernet/cadence/macb.c b/drivers/net/ethernet/cadence/macb.c
index 3767271c7667..ad76b8e35a00 100644
--- a/drivers/net/ethernet/cadence/macb.c
+++ b/drivers/net/ethernet/cadence/macb.c
@@ -1691,7 +1691,7 @@ static int hash_get_index(__u8 *addr)
 
         for (j = 0; j < 6; j++) {
                 for (i = 0, bitval = 0; i < 8; i++)
-                        bitval ^= hash_bit_value(i*6 + j, addr);
+                        bitval ^= hash_bit_value(i * 6 + j, addr);
 
                 hash_index |= (bitval << j);
         }
@@ -1827,12 +1827,23 @@ static int macb_close(struct net_device *dev)
 
 static void gem_update_stats(struct macb *bp)
 {
-        u32 __iomem *reg = bp->regs + GEM_OTX;
+        int i;
         u32 *p = &bp->hw_stats.gem.tx_octets_31_0;
-        u32 *end = &bp->hw_stats.gem.rx_udp_checksum_errors + 1;
 
-        for (; p < end; p++, reg++)
-                *p += __raw_readl(reg);
+        for (i = 0; i < GEM_STATS_LEN; ++i, ++p) {
+                u32 offset = gem_statistics[i].offset;
+                u64 val = __raw_readl(bp->regs + offset);
+
+                bp->ethtool_stats[i] += val;
+                *p += val;
+
+                if (offset == GEM_OCTTXL || offset == GEM_OCTRXL) {
+                        /* Add GEM_OCTTXH, GEM_OCTRXH */
+                        val = __raw_readl(bp->regs + offset + 4);
+                        bp->ethtool_stats[i] += ((u64)val) << 32;
+                        *(++p) += val;
+                }
+        }
 }
 
 static struct net_device_stats *gem_get_stats(struct macb *bp)
@@ -1873,6 +1884,39 @@ static struct net_device_stats *gem_get_stats(struct macb *bp)
         return nstat;
 }
 
+static void gem_get_ethtool_stats(struct net_device *dev,
+                                  struct ethtool_stats *stats, u64 *data)
+{
+        struct macb *bp;
+
+        bp = netdev_priv(dev);
+        gem_update_stats(bp);
+        memcpy(data, &bp->ethtool_stats, sizeof(u64) * GEM_STATS_LEN);
+}
+
+static int gem_get_sset_count(struct net_device *dev, int sset)
+{
+        switch (sset) {
+        case ETH_SS_STATS:
+                return GEM_STATS_LEN;
+        default:
+                return -EOPNOTSUPP;
+        }
+}
+
+static void gem_get_ethtool_strings(struct net_device *dev, u32 sset, u8 *p)
+{
+        int i;
+
+        switch (sset) {
+        case ETH_SS_STATS:
+                for (i = 0; i < GEM_STATS_LEN; i++, p += ETH_GSTRING_LEN)
+                        memcpy(p, gem_statistics[i].stat_string,
+                               ETH_GSTRING_LEN);
+                break;
+        }
+}
+
 struct net_device_stats *macb_get_stats(struct net_device *dev)
 {
         struct macb *bp = netdev_priv(dev);
@@ -1991,6 +2035,18 @@ const struct ethtool_ops macb_ethtool_ops = {
 };
 EXPORT_SYMBOL_GPL(macb_ethtool_ops);
 
+static const struct ethtool_ops gem_ethtool_ops = {
+        .get_settings           = macb_get_settings,
+        .set_settings           = macb_set_settings,
+        .get_regs_len           = macb_get_regs_len,
+        .get_regs               = macb_get_regs,
+        .get_link               = ethtool_op_get_link,
+        .get_ts_info            = ethtool_op_get_ts_info,
+        .get_ethtool_stats      = gem_get_ethtool_stats,
+        .get_strings            = gem_get_ethtool_strings,
+        .get_sset_count         = gem_get_sset_count,
+};
+
 int macb_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
         struct macb *bp = netdev_priv(dev);
@@ -2148,7 +2204,7 @@ static void macb_probe_queues(void __iomem *mem,
                         (*num_queues)++;
 }
 
-static int __init macb_probe(struct platform_device *pdev)
+static int macb_probe(struct platform_device *pdev)
 {
         struct macb_platform_data *pdata;
         struct resource *regs;
@@ -2278,7 +2334,6 @@ static int __init macb_probe(struct platform_device *pdev)
 
         dev->netdev_ops = &macb_netdev_ops;
         netif_napi_add(dev, &bp->napi, macb_poll, 64);
-        dev->ethtool_ops = &macb_ethtool_ops;
 
         dev->base_addr = regs->start;
 
@@ -2292,12 +2347,14 @@ static int __init macb_probe(struct platform_device *pdev)
                 bp->macbgem_ops.mog_free_rx_buffers = gem_free_rx_buffers;
                 bp->macbgem_ops.mog_init_rings = gem_init_rings;
                 bp->macbgem_ops.mog_rx = gem_rx;
+                dev->ethtool_ops = &gem_ethtool_ops;
         } else {
                 bp->max_tx_length = MACB_MAX_TX_LEN;
                 bp->macbgem_ops.mog_alloc_rx_buffers = macb_alloc_rx_buffers;
                 bp->macbgem_ops.mog_free_rx_buffers = macb_free_rx_buffers;
                 bp->macbgem_ops.mog_init_rings = macb_init_rings;
                 bp->macbgem_ops.mog_rx = macb_rx;
+                dev->ethtool_ops = &macb_ethtool_ops;
         }
 
         /* Set features */
@@ -2386,7 +2443,7 @@ err_out:
         return err;
 }
 
-static int __exit macb_remove(struct platform_device *pdev)
+static int macb_remove(struct platform_device *pdev)
 {
         struct net_device *dev;
         struct macb *bp;
@@ -2411,8 +2468,7 @@ static int __exit macb_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int macb_suspend(struct device *dev)
+static int __maybe_unused macb_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct net_device *netdev = platform_get_drvdata(pdev);
@@ -2429,7 +2485,7 @@ static int macb_suspend(struct device *dev)
         return 0;
 }
 
-static int macb_resume(struct device *dev)
+static int __maybe_unused macb_resume(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct net_device *netdev = platform_get_drvdata(pdev);
@@ -2444,12 +2500,12 @@ static int macb_resume(struct device *dev)
 
         return 0;
 }
-#endif
 
 static SIMPLE_DEV_PM_OPS(macb_pm_ops, macb_suspend, macb_resume);
 
 static struct platform_driver macb_driver = {
-        .remove         = __exit_p(macb_remove),
+        .probe          = macb_probe,
+        .remove         = macb_remove,
         .driver         = {
                 .name           = "macb",
                 .of_match_table = of_match_ptr(macb_dt_ids),
@@ -2457,7 +2513,7 @@ static struct platform_driver macb_driver = {
         },
 };
 
-module_platform_driver_probe(macb_driver, macb_probe);
+module_platform_driver(macb_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Cadence MACB/GEM Ethernet driver");
diff --git a/drivers/net/ethernet/cadence/macb.h b/drivers/net/ethernet/cadence/macb.h
index 084191b6fad2..31dc080f2437 100644
--- a/drivers/net/ethernet/cadence/macb.h
+++ b/drivers/net/ethernet/cadence/macb.h
@@ -15,263 +15,309 @@
 #define MACB_MAX_QUEUES 8
 
 /* MACB register offsets */
-#define MACB_NCR                                0x0000
-#define MACB_NCFGR                              0x0004
-#define MACB_NSR                                0x0008
-#define MACB_TAR                                0x000c /* AT91RM9200 only */
-#define MACB_TCR                                0x0010 /* AT91RM9200 only */
-#define MACB_TSR                                0x0014
-#define MACB_RBQP                               0x0018
-#define MACB_TBQP                               0x001c
-#define MACB_RSR                                0x0020
-#define MACB_ISR                                0x0024
-#define MACB_IER                                0x0028
-#define MACB_IDR                                0x002c
-#define MACB_IMR                                0x0030
-#define MACB_MAN                                0x0034
-#define MACB_PTR                                0x0038
-#define MACB_PFR                                0x003c
-#define MACB_FTO                                0x0040
-#define MACB_SCF                                0x0044
-#define MACB_MCF                                0x0048
-#define MACB_FRO                                0x004c
-#define MACB_FCSE                               0x0050
-#define MACB_ALE                                0x0054
-#define MACB_DTF                                0x0058
-#define MACB_LCOL                               0x005c
-#define MACB_EXCOL                              0x0060
-#define MACB_TUND                               0x0064
-#define MACB_CSE                                0x0068
-#define MACB_RRE                                0x006c
-#define MACB_ROVR                               0x0070
-#define MACB_RSE                                0x0074
-#define MACB_ELE                                0x0078
-#define MACB_RJA                                0x007c
-#define MACB_USF                                0x0080
-#define MACB_STE                                0x0084
-#define MACB_RLE                                0x0088
-#define MACB_TPF                                0x008c
-#define MACB_HRB                                0x0090
-#define MACB_HRT                                0x0094
-#define MACB_SA1B                               0x0098
-#define MACB_SA1T                               0x009c
-#define MACB_SA2B                               0x00a0
-#define MACB_SA2T                               0x00a4
-#define MACB_SA3B                               0x00a8
-#define MACB_SA3T                               0x00ac
-#define MACB_SA4B                               0x00b0
-#define MACB_SA4T                               0x00b4
-#define MACB_TID                                0x00b8
-#define MACB_TPQ                                0x00bc
-#define MACB_USRIO                              0x00c0
-#define MACB_WOL                                0x00c4
-#define MACB_MID                                0x00fc
+#define MACB_NCR                0x0000 /* Network Control */
+#define MACB_NCFGR              0x0004 /* Network Config */
+#define MACB_NSR                0x0008 /* Network Status */
+#define MACB_TAR                0x000c /* AT91RM9200 only */
+#define MACB_TCR                0x0010 /* AT91RM9200 only */
+#define MACB_TSR                0x0014 /* Transmit Status */
+#define MACB_RBQP               0x0018 /* RX Q Base Address */
+#define MACB_TBQP               0x001c /* TX Q Base Address */
+#define MACB_RSR                0x0020 /* Receive Status */
+#define MACB_ISR                0x0024 /* Interrupt Status */
+#define MACB_IER                0x0028 /* Interrupt Enable */
+#define MACB_IDR                0x002c /* Interrupt Disable */
+#define MACB_IMR                0x0030 /* Interrupt Mask */
+#define MACB_MAN                0x0034 /* PHY Maintenance */
+#define MACB_PTR                0x0038
+#define MACB_PFR                0x003c
+#define MACB_FTO                0x0040
+#define MACB_SCF                0x0044
+#define MACB_MCF                0x0048
+#define MACB_FRO                0x004c
+#define MACB_FCSE               0x0050
+#define MACB_ALE                0x0054
+#define MACB_DTF                0x0058
+#define MACB_LCOL               0x005c
+#define MACB_EXCOL              0x0060
+#define MACB_TUND               0x0064
+#define MACB_CSE                0x0068
+#define MACB_RRE                0x006c
+#define MACB_ROVR               0x0070
+#define MACB_RSE                0x0074
+#define MACB_ELE                0x0078
+#define MACB_RJA                0x007c
+#define MACB_USF                0x0080
+#define MACB_STE                0x0084
+#define MACB_RLE                0x0088
+#define MACB_TPF                0x008c
+#define MACB_HRB                0x0090
+#define MACB_HRT                0x0094
+#define MACB_SA1B               0x0098
+#define MACB_SA1T               0x009c
+#define MACB_SA2B               0x00a0
+#define MACB_SA2T               0x00a4
+#define MACB_SA3B               0x00a8
+#define MACB_SA3T               0x00ac
+#define MACB_SA4B               0x00b0
+#define MACB_SA4T               0x00b4
+#define MACB_TID                0x00b8
+#define MACB_TPQ                0x00bc
+#define MACB_USRIO              0x00c0
+#define MACB_WOL                0x00c4
+#define MACB_MID                0x00fc
 
 /* GEM register offsets. */
-#define GEM_NCFGR                               0x0004
-#define GEM_USRIO                               0x000c
-#define GEM_DMACFG                              0x0010
-#define GEM_HRB                                 0x0080
-#define GEM_HRT                                 0x0084
-#define GEM_SA1B                                0x0088
-#define GEM_SA1T                                0x008C
-#define GEM_SA2B                                0x0090
-#define GEM_SA2T                                0x0094
-#define GEM_SA3B                                0x0098
-#define GEM_SA3T                                0x009C
-#define GEM_SA4B                                0x00A0
-#define GEM_SA4T                                0x00A4
-#define GEM_OTX                                 0x0100
-#define GEM_DCFG1                               0x0280
-#define GEM_DCFG2                               0x0284
-#define GEM_DCFG3                               0x0288
-#define GEM_DCFG4                               0x028c
-#define GEM_DCFG5                               0x0290
-#define GEM_DCFG6                               0x0294
-#define GEM_DCFG7                               0x0298
-
-#define GEM_ISR(hw_q)                           (0x0400 + ((hw_q) << 2))
-#define GEM_TBQP(hw_q)                          (0x0440 + ((hw_q) << 2))
-#define GEM_RBQP(hw_q)                          (0x0480 + ((hw_q) << 2))
-#define GEM_IER(hw_q)                           (0x0600 + ((hw_q) << 2))
-#define GEM_IDR(hw_q)                           (0x0620 + ((hw_q) << 2))
-#define GEM_IMR(hw_q)                           (0x0640 + ((hw_q) << 2))
+#define GEM_NCFGR               0x0004 /* Network Config */
+#define GEM_USRIO               0x000c /* User IO */
+#define GEM_DMACFG              0x0010 /* DMA Configuration */
+#define GEM_HRB                 0x0080 /* Hash Bottom */
+#define GEM_HRT                 0x0084 /* Hash Top */
+#define GEM_SA1B                0x0088 /* Specific1 Bottom */
+#define GEM_SA1T                0x008C /* Specific1 Top */
+#define GEM_SA2B                0x0090 /* Specific2 Bottom */
+#define GEM_SA2T                0x0094 /* Specific2 Top */
+#define GEM_SA3B                0x0098 /* Specific3 Bottom */
+#define GEM_SA3T                0x009C /* Specific3 Top */
+#define GEM_SA4B                0x00A0 /* Specific4 Bottom */
+#define GEM_SA4T                0x00A4 /* Specific4 Top */
+#define GEM_OTX                 0x0100 /* Octets transmitted */
+#define GEM_OCTTXL              0x0100 /* Octets transmitted [31:0] */
+#define GEM_OCTTXH              0x0104 /* Octets transmitted [47:32] */
+#define GEM_TXCNT               0x0108 /* Frames Transmitted counter */
+#define GEM_TXBCCNT             0x010c /* Broadcast Frames counter */
+#define GEM_TXMCCNT             0x0110 /* Multicast Frames counter */
+#define GEM_TXPAUSECNT          0x0114 /* Pause Frames Transmitted Counter */
+#define GEM_TX64CNT             0x0118 /* 64 byte Frames TX counter */
+#define GEM_TX65CNT             0x011c /* 65-127 byte Frames TX counter */
+#define GEM_TX128CNT            0x0120 /* 128-255 byte Frames TX counter */
+#define GEM_TX256CNT            0x0124 /* 256-511 byte Frames TX counter */
+#define GEM_TX512CNT            0x0128 /* 512-1023 byte Frames TX counter */
+#define GEM_TX1024CNT           0x012c /* 1024-1518 byte Frames TX counter */
+#define GEM_TX1519CNT           0x0130 /* 1519+ byte Frames TX counter */
+#define GEM_TXURUNCNT           0x0134 /* TX under run error counter */
+#define GEM_SNGLCOLLCNT         0x0138 /* Single Collision Frame Counter */
+#define GEM_MULTICOLLCNT        0x013c /* Multiple Collision Frame Counter */
+#define GEM_EXCESSCOLLCNT       0x0140 /* Excessive Collision Frame Counter */
+#define GEM_LATECOLLCNT         0x0144 /* Late Collision Frame Counter */
+#define GEM_TXDEFERCNT          0x0148 /* Deferred Transmission Frame Counter */
+#define GEM_TXCSENSECNT         0x014c /* Carrier Sense Error Counter */
+#define GEM_ORX                 0x0150 /* Octets received */
+#define GEM_OCTRXL              0x0150 /* Octets received [31:0] */
+#define GEM_OCTRXH              0x0154 /* Octets received [47:32] */
+#define GEM_RXCNT               0x0158 /* Frames Received Counter */
+#define GEM_RXBROADCNT          0x015c /* Broadcast Frames Received Counter */
+#define GEM_RXMULTICNT          0x0160 /* Multicast Frames Received Counter */
+#define GEM_RXPAUSECNT          0x0164 /* Pause Frames Received Counter */
+#define GEM_RX64CNT             0x0168 /* 64 byte Frames RX Counter */
+#define GEM_RX65CNT             0x016c /* 65-127 byte Frames RX Counter */
+#define GEM_RX128CNT            0x0170 /* 128-255 byte Frames RX Counter */
+#define GEM_RX256CNT            0x0174 /* 256-511 byte Frames RX Counter */
+#define GEM_RX512CNT            0x0178 /* 512-1023 byte Frames RX Counter */
+#define GEM_RX1024CNT           0x017c /* 1024-1518 byte Frames RX Counter */
+#define GEM_RX1519CNT           0x0180 /* 1519+ byte Frames RX Counter */
+#define GEM_RXUNDRCNT           0x0184 /* Undersize Frames Received Counter */
+#define GEM_RXOVRCNT            0x0188 /* Oversize Frames Received Counter */
+#define GEM_RXJABCNT            0x018c /* Jabbers Received Counter */
+#define GEM_RXFCSCNT            0x0190 /* Frame Check Sequence Error Counter */
+#define GEM_RXLENGTHCNT         0x0194 /* Length Field Error Counter */
+#define GEM_RXSYMBCNT           0x0198 /* Symbol Error Counter */
+#define GEM_RXALIGNCNT          0x019c /* Alignment Error Counter */
+#define GEM_RXRESERRCNT         0x01a0 /* Receive Resource Error Counter */
+#define GEM_RXORCNT             0x01a4 /* Receive Overrun Counter */
+#define GEM_RXIPCCNT            0x01a8 /* IP header Checksum Error Counter */
+#define GEM_RXTCPCCNT           0x01ac /* TCP Checksum Error Counter */
+#define GEM_RXUDPCCNT           0x01b0 /* UDP Checksum Error Counter */
+#define GEM_DCFG1               0x0280 /* Design Config 1 */
+#define GEM_DCFG2               0x0284 /* Design Config 2 */
+#define GEM_DCFG3               0x0288 /* Design Config 3 */
+#define GEM_DCFG4               0x028c /* Design Config 4 */
+#define GEM_DCFG5               0x0290 /* Design Config 5 */
+#define GEM_DCFG6               0x0294 /* Design Config 6 */
+#define GEM_DCFG7               0x0298 /* Design Config 7 */
+
+#define GEM_ISR(hw_q)           (0x0400 + ((hw_q) << 2))
+#define GEM_TBQP(hw_q)          (0x0440 + ((hw_q) << 2))
+#define GEM_RBQP(hw_q)          (0x0480 + ((hw_q) << 2))
+#define GEM_IER(hw_q)           (0x0600 + ((hw_q) << 2))
+#define GEM_IDR(hw_q)           (0x0620 + ((hw_q) << 2))
+#define GEM_IMR(hw_q)           (0x0640 + ((hw_q) << 2))
 
 /* Bitfields in NCR */
-#define MACB_LB_OFFSET                          0
-#define MACB_LB_SIZE                            1
-#define MACB_LLB_OFFSET                         1
-#define MACB_LLB_SIZE                           1
-#define MACB_RE_OFFSET                          2
-#define MACB_RE_SIZE                            1
-#define MACB_TE_OFFSET                          3
-#define MACB_TE_SIZE                            1
-#define MACB_MPE_OFFSET                         4
-#define MACB_MPE_SIZE                           1
-#define MACB_CLRSTAT_OFFSET                     5
-#define MACB_CLRSTAT_SIZE                       1
-#define MACB_INCSTAT_OFFSET                     6
-#define MACB_INCSTAT_SIZE                       1
-#define MACB_WESTAT_OFFSET                      7
-#define MACB_WESTAT_SIZE                        1
-#define MACB_BP_OFFSET                          8
-#define MACB_BP_SIZE                            1
-#define MACB_TSTART_OFFSET                      9
-#define MACB_TSTART_SIZE                        1
-#define MACB_THALT_OFFSET                       10
-#define MACB_THALT_SIZE                         1
-#define MACB_NCR_TPF_OFFSET                     11
-#define MACB_NCR_TPF_SIZE                       1
-#define MACB_TZQ_OFFSET                         12
-#define MACB_TZQ_SIZE                           1
+#define MACB_LB_OFFSET          0 /* reserved */
+#define MACB_LB_SIZE            1
+#define MACB_LLB_OFFSET         1 /* Loop back local */
+#define MACB_LLB_SIZE           1
+#define MACB_RE_OFFSET          2 /* Receive enable */
+#define MACB_RE_SIZE            1
+#define MACB_TE_OFFSET          3 /* Transmit enable */
+#define MACB_TE_SIZE            1
+#define MACB_MPE_OFFSET         4 /* Management port enable */
+#define MACB_MPE_SIZE           1
+#define MACB_CLRSTAT_OFFSET     5 /* Clear stats regs */
+#define MACB_CLRSTAT_SIZE       1
+#define MACB_INCSTAT_OFFSET     6 /* Incremental stats regs */
+#define MACB_INCSTAT_SIZE       1
+#define MACB_WESTAT_OFFSET      7 /* Write enable stats regs */
+#define MACB_WESTAT_SIZE        1
+#define MACB_BP_OFFSET          8 /* Back pressure */
+#define MACB_BP_SIZE            1
+#define MACB_TSTART_OFFSET      9 /* Start transmission */
+#define MACB_TSTART_SIZE        1
+#define MACB_THALT_OFFSET       10 /* Transmit halt */
+#define MACB_THALT_SIZE         1
+#define MACB_NCR_TPF_OFFSET     11 /* Transmit pause frame */
+#define MACB_NCR_TPF_SIZE       1
+#define MACB_TZQ_OFFSET         12 /* Transmit zero quantum pause frame */
+#define MACB_TZQ_SIZE           1
 
 /* Bitfields in NCFGR */
-#define MACB_SPD_OFFSET                         0
-#define MACB_SPD_SIZE                           1
-#define MACB_FD_OFFSET                          1
-#define MACB_FD_SIZE                            1
-#define MACB_BIT_RATE_OFFSET                    2
-#define MACB_BIT_RATE_SIZE                      1
-#define MACB_JFRAME_OFFSET                      3
-#define MACB_JFRAME_SIZE                        1
-#define MACB_CAF_OFFSET                         4
-#define MACB_CAF_SIZE                           1
-#define MACB_NBC_OFFSET                         5
-#define MACB_NBC_SIZE                           1
-#define MACB_NCFGR_MTI_OFFSET                   6
-#define MACB_NCFGR_MTI_SIZE                     1
-#define MACB_UNI_OFFSET                         7
-#define MACB_UNI_SIZE                           1
-#define MACB_BIG_OFFSET                         8
-#define MACB_BIG_SIZE                           1
-#define MACB_EAE_OFFSET                         9
-#define MACB_EAE_SIZE                           1
-#define MACB_CLK_OFFSET                         10
-#define MACB_CLK_SIZE                           2
-#define MACB_RTY_OFFSET                         12
-#define MACB_RTY_SIZE                           1
-#define MACB_PAE_OFFSET                         13
-#define MACB_PAE_SIZE                           1
-#define MACB_RM9200_RMII_OFFSET                 13 /* AT91RM9200 only */
-#define MACB_RM9200_RMII_SIZE                   1  /* AT91RM9200 only */
-#define MACB_RBOF_OFFSET                        14
-#define MACB_RBOF_SIZE                          2
-#define MACB_RLCE_OFFSET                        16
-#define MACB_RLCE_SIZE                          1
-#define MACB_DRFCS_OFFSET                       17
-#define MACB_DRFCS_SIZE                         1
-#define MACB_EFRHD_OFFSET                       18
-#define MACB_EFRHD_SIZE                         1
-#define MACB_IRXFCS_OFFSET                      19
-#define MACB_IRXFCS_SIZE                        1
+#define MACB_SPD_OFFSET         0 /* Speed */
+#define MACB_SPD_SIZE           1
+#define MACB_FD_OFFSET          1 /* Full duplex */
+#define MACB_FD_SIZE            1
+#define MACB_BIT_RATE_OFFSET    2 /* Discard non-VLAN frames */
+#define MACB_BIT_RATE_SIZE      1
+#define MACB_JFRAME_OFFSET      3 /* reserved */
+#define MACB_JFRAME_SIZE        1
+#define MACB_CAF_OFFSET         4 /* Copy all frames */
+#define MACB_CAF_SIZE           1
+#define MACB_NBC_OFFSET         5 /* No broadcast */
+#define MACB_NBC_SIZE           1
+#define MACB_NCFGR_MTI_OFFSET   6 /* Multicast hash enable */
+#define MACB_NCFGR_MTI_SIZE     1
+#define MACB_UNI_OFFSET         7 /* Unicast hash enable */
+#define MACB_UNI_SIZE           1
+#define MACB_BIG_OFFSET         8 /* Receive 1536 byte frames */
+#define MACB_BIG_SIZE           1
+#define MACB_EAE_OFFSET         9 /* External address match enable */
+#define MACB_EAE_SIZE           1
+#define MACB_CLK_OFFSET         10
+#define MACB_CLK_SIZE           2
+#define MACB_RTY_OFFSET         12 /* Retry test */
+#define MACB_RTY_SIZE           1
+#define MACB_PAE_OFFSET         13 /* Pause enable */
+#define MACB_PAE_SIZE           1
+#define MACB_RM9200_RMII_OFFSET 13 /* AT91RM9200 only */
+#define MACB_RM9200_RMII_SIZE   1  /* AT91RM9200 only */
+#define MACB_RBOF_OFFSET        14 /* Receive buffer offset */
+#define MACB_RBOF_SIZE          2
+#define MACB_RLCE_OFFSET        16 /* Length field error frame discard */
+#define MACB_RLCE_SIZE          1
+#define MACB_DRFCS_OFFSET       17 /* FCS remove */
+#define MACB_DRFCS_SIZE         1
+#define MACB_EFRHD_OFFSET       18
+#define MACB_EFRHD_SIZE         1
+#define MACB_IRXFCS_OFFSET      19
+#define MACB_IRXFCS_SIZE        1
 
 /* GEM specific NCFGR bitfields. */
-#define GEM_GBE_OFFSET                          10
-#define GEM_GBE_SIZE                            1
-#define GEM_CLK_OFFSET                          18
-#define GEM_CLK_SIZE                            3
-#define GEM_DBW_OFFSET                          21
-#define GEM_DBW_SIZE                            2
-#define GEM_RXCOEN_OFFSET                       24
-#define GEM_RXCOEN_SIZE                         1
+#define GEM_GBE_OFFSET          10 /* Gigabit mode enable */
+#define GEM_GBE_SIZE            1
+#define GEM_CLK_OFFSET          18 /* MDC clock division */
+#define GEM_CLK_SIZE            3
+#define GEM_DBW_OFFSET          21 /* Data bus width */
+#define GEM_DBW_SIZE            2
+#define GEM_RXCOEN_OFFSET       24
+#define GEM_RXCOEN_SIZE         1
 
 /* Constants for data bus width. */
-#define GEM_DBW32                               0
-#define GEM_DBW64                               1
-#define GEM_DBW128                              2
+#define GEM_DBW32               0 /* 32 bit AMBA AHB data bus width */
+#define GEM_DBW64               1 /* 64 bit AMBA AHB data bus width */
+#define GEM_DBW128              2 /* 128 bit AMBA AHB data bus width */
 
 /* Bitfields in DMACFG. */
-#define GEM_FBLDO_OFFSET                        0
-#define GEM_FBLDO_SIZE                          5
-#define GEM_ENDIA_OFFSET                        7
-#define GEM_ENDIA_SIZE                          1
-#define GEM_RXBMS_OFFSET                        8
-#define GEM_RXBMS_SIZE                          2
-#define GEM_TXPBMS_OFFSET                       10
-#define GEM_TXPBMS_SIZE                         1
-#define GEM_TXCOEN_OFFSET                       11
-#define GEM_TXCOEN_SIZE                         1
-#define GEM_RXBS_OFFSET                         16
-#define GEM_RXBS_SIZE                           8
-#define GEM_DDRP_OFFSET                         24
-#define GEM_DDRP_SIZE                           1
+#define GEM_FBLDO_OFFSET        0 /* fixed burst length for DMA */
+#define GEM_FBLDO_SIZE          5
+#define GEM_ENDIA_OFFSET        7 /* endian swap mode for packet data access */
+#define GEM_ENDIA_SIZE          1
+#define GEM_RXBMS_OFFSET        8 /* RX packet buffer memory size select */
+#define GEM_RXBMS_SIZE          2
+#define GEM_TXPBMS_OFFSET       10 /* TX packet buffer memory size select */
+#define GEM_TXPBMS_SIZE         1
+#define GEM_TXCOEN_OFFSET       11 /* TX IP/TCP/UDP checksum gen offload */
+#define GEM_TXCOEN_SIZE         1
+#define GEM_RXBS_OFFSET         16 /* DMA receive buffer size */
+#define GEM_RXBS_SIZE           8
+#define GEM_DDRP_OFFSET         24 /* disc_when_no_ahb */
+#define GEM_DDRP_SIZE           1
 
 
 /* Bitfields in NSR */
-#define MACB_NSR_LINK_OFFSET                    0
-#define MACB_NSR_LINK_SIZE                      1
-#define MACB_MDIO_OFFSET                        1
-#define MACB_MDIO_SIZE                          1
-#define MACB_IDLE_OFFSET                        2
-#define MACB_IDLE_SIZE                          1
+#define MACB_NSR_LINK_OFFSET    0 /* pcs_link_state */
+#define MACB_NSR_LINK_SIZE      1
+#define MACB_MDIO_OFFSET        1 /* status of the mdio_in pin */
+#define MACB_MDIO_SIZE          1
+#define MACB_IDLE_OFFSET        2 /* The PHY management logic is idle */
+#define MACB_IDLE_SIZE          1
 
 /* Bitfields in TSR */
-#define MACB_UBR_OFFSET                         0
-#define MACB_UBR_SIZE                           1
-#define MACB_COL_OFFSET                         1
-#define MACB_COL_SIZE                           1
-#define MACB_TSR_RLE_OFFSET                     2
-#define MACB_TSR_RLE_SIZE                       1
-#define MACB_TGO_OFFSET                         3
-#define MACB_TGO_SIZE                           1
-#define MACB_BEX_OFFSET                         4
-#define MACB_BEX_SIZE                           1
-#define MACB_RM9200_BNQ_OFFSET                  4 /* AT91RM9200 only */
-#define MACB_RM9200_BNQ_SIZE                    1 /* AT91RM9200 only */
-#define MACB_COMP_OFFSET                        5
-#define MACB_COMP_SIZE                          1
-#define MACB_UND_OFFSET                         6
-#define MACB_UND_SIZE                           1
+#define MACB_UBR_OFFSET         0 /* Used bit read */
+#define MACB_UBR_SIZE           1
+#define MACB_COL_OFFSET         1 /* Collision occurred */
+#define MACB_COL_SIZE           1
+#define MACB_TSR_RLE_OFFSET     2 /* Retry limit exceeded */
+#define MACB_TSR_RLE_SIZE       1
+#define MACB_TGO_OFFSET         3 /* Transmit go */
+#define MACB_TGO_SIZE           1
+#define MACB_BEX_OFFSET         4 /* TX frame corruption due to AHB error */
+#define MACB_BEX_SIZE           1
+#define MACB_RM9200_BNQ_OFFSET  4 /* AT91RM9200 only */
+#define MACB_RM9200_BNQ_SIZE    1 /* AT91RM9200 only */
+#define MACB_COMP_OFFSET        5 /* Trnasmit complete */
+#define MACB_COMP_SIZE          1
+#define MACB_UND_OFFSET         6 /* Trnasmit under run */
+#define MACB_UND_SIZE           1
 
 /* Bitfields in RSR */
-#define MACB_BNA_OFFSET                         0
-#define MACB_BNA_SIZE                           1
-#define MACB_REC_OFFSET                         1
-#define MACB_REC_SIZE                           1
-#define MACB_OVR_OFFSET                         2
-#define MACB_OVR_SIZE                           1
+#define MACB_BNA_OFFSET         0 /* Buffer not available */
+#define MACB_BNA_SIZE           1
+#define MACB_REC_OFFSET         1 /* Frame received */
+#define MACB_REC_SIZE           1
+#define MACB_OVR_OFFSET         2 /* Receive overrun */
+#define MACB_OVR_SIZE           1
 
 /* Bitfields in ISR/IER/IDR/IMR */
-#define MACB_MFD_OFFSET                         0
-#define MACB_MFD_SIZE                           1
-#define MACB_RCOMP_OFFSET                       1
-#define MACB_RCOMP_SIZE                         1
-#define MACB_RXUBR_OFFSET                       2
-#define MACB_RXUBR_SIZE                         1
-#define MACB_TXUBR_OFFSET                       3
-#define MACB_TXUBR_SIZE                         1
-#define MACB_ISR_TUND_OFFSET                    4
-#define MACB_ISR_TUND_SIZE                      1
-#define MACB_ISR_RLE_OFFSET                     5
-#define MACB_ISR_RLE_SIZE                       1
-#define MACB_TXERR_OFFSET                       6
-#define MACB_TXERR_SIZE                         1
-#define MACB_TCOMP_OFFSET                       7
-#define MACB_TCOMP_SIZE                         1
-#define MACB_ISR_LINK_OFFSET                    9
-#define MACB_ISR_LINK_SIZE                      1
-#define MACB_ISR_ROVR_OFFSET                    10
-#define MACB_ISR_ROVR_SIZE                      1
-#define MACB_HRESP_OFFSET                       11
-#define MACB_HRESP_SIZE                         1
-#define MACB_PFR_OFFSET                         12
-#define MACB_PFR_SIZE                           1
-#define MACB_PTZ_OFFSET                         13
-#define MACB_PTZ_SIZE                           1
+#define MACB_MFD_OFFSET         0 /* Management frame sent */
+#define MACB_MFD_SIZE           1
+#define MACB_RCOMP_OFFSET       1 /* Receive complete */
+#define MACB_RCOMP_SIZE         1
+#define MACB_RXUBR_OFFSET       2 /* RX used bit read */
+#define MACB_RXUBR_SIZE         1
+#define MACB_TXUBR_OFFSET       3 /* TX used bit read */
+#define MACB_TXUBR_SIZE         1
+#define MACB_ISR_TUND_OFFSET    4 /* Enable TX buffer under run interrupt */
+#define MACB_ISR_TUND_SIZE      1
+#define MACB_ISR_RLE_OFFSET     5 /* EN retry exceeded/late coll interrupt */
+#define MACB_ISR_RLE_SIZE       1
+#define MACB_TXERR_OFFSET       6 /* EN TX frame corrupt from error interrupt */
+#define MACB_TXERR_SIZE         1
+#define MACB_TCOMP_OFFSET       7 /* Enable transmit complete interrupt */
+#define MACB_TCOMP_SIZE         1
+#define MACB_ISR_LINK_OFFSET    9 /* Enable link change interrupt */
+#define MACB_ISR_LINK_SIZE      1
+#define MACB_ISR_ROVR_OFFSET    10 /* Enable receive overrun interrupt */
+#define MACB_ISR_ROVR_SIZE      1
+#define MACB_HRESP_OFFSET       11 /* Enable hrsep not OK interrupt */
+#define MACB_HRESP_SIZE         1
+#define MACB_PFR_OFFSET         12 /* Enable pause frame w/ quantum interrupt */
+#define MACB_PFR_SIZE           1
+#define MACB_PTZ_OFFSET         13 /* Enable pause time zero interrupt */
+#define MACB_PTZ_SIZE           1
 
 /* Bitfields in MAN */
-#define MACB_DATA_OFFSET                        0
-#define MACB_DATA_SIZE                          16
-#define MACB_CODE_OFFSET                        16
-#define MACB_CODE_SIZE                          2
-#define MACB_REGA_OFFSET                        18
-#define MACB_REGA_SIZE                          5
-#define MACB_PHYA_OFFSET                        23
-#define MACB_PHYA_SIZE                          5
-#define MACB_RW_OFFSET                          28
-#define MACB_RW_SIZE                            2
-#define MACB_SOF_OFFSET                         30
-#define MACB_SOF_SIZE                           2
+#define MACB_DATA_OFFSET        0 /* data */
+#define MACB_DATA_SIZE          16
+#define MACB_CODE_OFFSET        16 /* Must be written to 10 */
+#define MACB_CODE_SIZE          2
+#define MACB_REGA_OFFSET        18 /* Register address */
+#define MACB_REGA_SIZE          5
+#define MACB_PHYA_OFFSET        23 /* PHY address */
+#define MACB_PHYA_SIZE          5
+#define MACB_RW_OFFSET          28 /* Operation. 10 is read. 01 is write. */
+#define MACB_RW_SIZE            2
+#define MACB_SOF_OFFSET         30 /* Must be written to 1 for Clause 22 */
+#define MACB_SOF_SIZE           2
 
 /* Bitfields in USRIO (AVR32) */
 #define MACB_MII_OFFSET                         0
@@ -286,7 +332,7 @@
 /* Bitfields in USRIO (AT91) */
 #define MACB_RMII_OFFSET                        0
 #define MACB_RMII_SIZE                          1
-#define GEM_RGMII_OFFSET                        0       /* GEM gigabit mode */
+#define GEM_RGMII_OFFSET                        0 /* GEM gigabit mode */
 #define GEM_RGMII_SIZE                          1
 #define MACB_CLKEN_OFFSET                       1
 #define MACB_CLKEN_SIZE                         1
@@ -389,8 +435,7 @@
 #define queue_writel(queue, reg, value)                 \
         __raw_writel((value), (queue)->bp->regs + (queue)->reg)
 
-/*
- * Conditional GEM/MACB macros.  These perform the operation to the correct
+/* Conditional GEM/MACB macros.  These perform the operation to the correct
  * register dependent on whether the device is a GEM or a MACB.  For registers
  * and bitfields that are common across both devices, use macb_{read,write}l
  * to avoid the cost of the conditional.
@@ -413,8 +458,7 @@
                 __v; \
         })
 
-/**
- * struct macb_dma_desc - Hardware DMA descriptor
+/* struct macb_dma_desc - Hardware DMA descriptor
  * @addr: DMA address of data buffer
  * @ctrl: Control and status bits
  */
@@ -503,8 +547,7 @@ struct macb_dma_desc {
 /* limit RX checksum offload to TCP and UDP packets */
 #define GEM_RX_CSUM_CHECKED_MASK                2
 
-/**
- * struct macb_tx_skb - data about an skb which is being transmitted
+/* struct macb_tx_skb - data about an skb which is being transmitted
  * @skb: skb currently being transmitted, only set for the last buffer
  *       of the frame
  * @mapping: DMA address of the skb's fragment buffer
@@ -519,8 +562,7 @@ struct macb_tx_skb {
         bool                    mapped_as_page;
 };
 
-/*
- * Hardware-collected statistics. Used when updating the network
+/* Hardware-collected statistics. Used when updating the network
  * device stats by a periodic timer.
  */
 struct macb_stats {
@@ -595,6 +637,107 @@ struct gem_stats {
         u32     rx_udp_checksum_errors;
 };
 
+/* Describes the name and offset of an individual statistic register, as
+ * returned by `ethtool -S`. Also describes which net_device_stats statistics
+ * this register should contribute to.
+ */
+struct gem_statistic {
+        char stat_string[ETH_GSTRING_LEN];
+        int offset;
+        u32 stat_bits;
+};
+
+/* Bitfield defs for net_device_stat statistics */
+#define GEM_NDS_RXERR_OFFSET            0
+#define GEM_NDS_RXLENERR_OFFSET         1
+#define GEM_NDS_RXOVERERR_OFFSET        2
+#define GEM_NDS_RXCRCERR_OFFSET         3
+#define GEM_NDS_RXFRAMEERR_OFFSET       4
+#define GEM_NDS_RXFIFOERR_OFFSET        5
+#define GEM_NDS_TXERR_OFFSET            6
+#define GEM_NDS_TXABORTEDERR_OFFSET     7
+#define GEM_NDS_TXCARRIERERR_OFFSET     8
+#define GEM_NDS_TXFIFOERR_OFFSET        9
+#define GEM_NDS_COLLISIONS_OFFSET       10
+
+#define GEM_STAT_TITLE(name, title) GEM_STAT_TITLE_BITS(name, title, 0)
+#define GEM_STAT_TITLE_BITS(name, title, bits) {        \
+        .stat_string = title,                           \
+        .offset = GEM_##name,                           \
+        .stat_bits = bits                               \
+}
+
+/* list of gem statistic registers. The names MUST match the
+ * corresponding GEM_* definitions.
+ */
+static const struct gem_statistic gem_statistics[] = {
+        GEM_STAT_TITLE(OCTTXL, "tx_octets"), /* OCTTXH combined with OCTTXL */
+        GEM_STAT_TITLE(TXCNT, "tx_frames"),
+        GEM_STAT_TITLE(TXBCCNT, "tx_broadcast_frames"),
+        GEM_STAT_TITLE(TXMCCNT, "tx_multicast_frames"),
+        GEM_STAT_TITLE(TXPAUSECNT, "tx_pause_frames"),
+        GEM_STAT_TITLE(TX64CNT, "tx_64_byte_frames"),
+        GEM_STAT_TITLE(TX65CNT, "tx_65_127_byte_frames"),
+        GEM_STAT_TITLE(TX128CNT, "tx_128_255_byte_frames"),
+        GEM_STAT_TITLE(TX256CNT, "tx_256_511_byte_frames"),
+        GEM_STAT_TITLE(TX512CNT, "tx_512_1023_byte_frames"),
+        GEM_STAT_TITLE(TX1024CNT, "tx_1024_1518_byte_frames"),
+        GEM_STAT_TITLE(TX1519CNT, "tx_greater_than_1518_byte_frames"),
+        GEM_STAT_TITLE_BITS(TXURUNCNT, "tx_underrun",
+                            GEM_BIT(NDS_TXERR)|GEM_BIT(NDS_TXFIFOERR)),
+        GEM_STAT_TITLE_BITS(SNGLCOLLCNT, "tx_single_collision_frames",
+                            GEM_BIT(NDS_TXERR)|GEM_BIT(NDS_COLLISIONS)),
+        GEM_STAT_TITLE_BITS(MULTICOLLCNT, "tx_multiple_collision_frames",
+                            GEM_BIT(NDS_TXERR)|GEM_BIT(NDS_COLLISIONS)),
+        GEM_STAT_TITLE_BITS(EXCESSCOLLCNT, "tx_excessive_collisions",
+                            GEM_BIT(NDS_TXERR)|
+                            GEM_BIT(NDS_TXABORTEDERR)|
+                            GEM_BIT(NDS_COLLISIONS)),
+        GEM_STAT_TITLE_BITS(LATECOLLCNT, "tx_late_collisions",
+                            GEM_BIT(NDS_TXERR)|GEM_BIT(NDS_COLLISIONS)),
+        GEM_STAT_TITLE(TXDEFERCNT, "tx_deferred_frames"),
+        GEM_STAT_TITLE_BITS(TXCSENSECNT, "tx_carrier_sense_errors",
+                            GEM_BIT(NDS_TXERR)|GEM_BIT(NDS_COLLISIONS)),
+        GEM_STAT_TITLE(OCTRXL, "rx_octets"), /* OCTRXH combined with OCTRXL */
+        GEM_STAT_TITLE(RXCNT, "rx_frames"),
+        GEM_STAT_TITLE(RXBROADCNT, "rx_broadcast_frames"),
+        GEM_STAT_TITLE(RXMULTICNT, "rx_multicast_frames"),
+        GEM_STAT_TITLE(RXPAUSECNT, "rx_pause_frames"),
+        GEM_STAT_TITLE(RX64CNT, "rx_64_byte_frames"),
+        GEM_STAT_TITLE(RX65CNT, "rx_65_127_byte_frames"),
+        GEM_STAT_TITLE(RX128CNT, "rx_128_255_byte_frames"),
+        GEM_STAT_TITLE(RX256CNT, "rx_256_511_byte_frames"),
+        GEM_STAT_TITLE(RX512CNT, "rx_512_1023_byte_frames"),
+        GEM_STAT_TITLE(RX1024CNT, "rx_1024_1518_byte_frames"),
+        GEM_STAT_TITLE(RX1519CNT, "rx_greater_than_1518_byte_frames"),
+        GEM_STAT_TITLE_BITS(RXUNDRCNT, "rx_undersized_frames",
+                            GEM_BIT(NDS_RXERR)|GEM_BIT(NDS_RXLENERR)),
+        GEM_STAT_TITLE_BITS(RXOVRCNT, "rx_oversize_frames",
+                            GEM_BIT(NDS_RXERR)|GEM_BIT(NDS_RXLENERR)),
+        GEM_STAT_TITLE_BITS(RXJABCNT, "rx_jabbers",
+                            GEM_BIT(NDS_RXERR)|GEM_BIT(NDS_RXLENERR)),
+        GEM_STAT_TITLE_BITS(RXFCSCNT, "rx_frame_check_sequence_errors",
+                            GEM_BIT(NDS_RXERR)|GEM_BIT(NDS_RXCRCERR)),
+        GEM_STAT_TITLE_BITS(RXLENGTHCNT, "rx_length_field_frame_errors",
+                            GEM_BIT(NDS_RXERR)),
+        GEM_STAT_TITLE_BITS(RXSYMBCNT, "rx_symbol_errors",
+                            GEM_BIT(NDS_RXERR)|GEM_BIT(NDS_RXFRAMEERR)),
+        GEM_STAT_TITLE_BITS(RXALIGNCNT, "rx_alignment_errors",
+                            GEM_BIT(NDS_RXERR)|GEM_BIT(NDS_RXOVERERR)),
+        GEM_STAT_TITLE_BITS(RXRESERRCNT, "rx_resource_errors",
+                            GEM_BIT(NDS_RXERR)|GEM_BIT(NDS_RXOVERERR)),
+        GEM_STAT_TITLE_BITS(RXORCNT, "rx_overruns",
+                            GEM_BIT(NDS_RXERR)|GEM_BIT(NDS_RXFIFOERR)),
+        GEM_STAT_TITLE_BITS(RXIPCCNT, "rx_ip_header_checksum_errors",
+                            GEM_BIT(NDS_RXERR)),
+        GEM_STAT_TITLE_BITS(RXTCPCCNT, "rx_tcp_checksum_errors",
+                            GEM_BIT(NDS_RXERR)),
+        GEM_STAT_TITLE_BITS(RXUDPCCNT, "rx_udp_checksum_errors",
+                            GEM_BIT(NDS_RXERR)),
+};
+
+#define GEM_STATS_LEN ARRAY_SIZE(gem_statistics)
+
 struct macb;
 
 struct macb_or_gem_ops {
@@ -673,6 +816,8 @@ struct macb {
         dma_addr_t skb_physaddr;                /* phys addr from pci_map_single */
         int skb_length;                         /* saved skb length for pci_unmap_single */
         unsigned int            max_tx_length;
+
+        u64                     ethtool_stats[GEM_STATS_LEN];
 };
 
 extern const struct ethtool_ops macb_ethtool_ops;
diff --git a/drivers/net/ethernet/chelsio/cxgb/sge.c b/drivers/net/ethernet/chelsio/cxgb/sge.c
index babe2a915b00..526ea74e82d9 100644
--- a/drivers/net/ethernet/chelsio/cxgb/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb/sge.c
@@ -1860,9 +1860,9 @@ netdev_tx_t t1_start_xmit(struct sk_buff *skb, struct net_device *dev)
         }
         cpl->iff = dev->if_port;
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 cpl->vlan_valid = 1;
-                cpl->vlan = htons(vlan_tx_tag_get(skb));
+                cpl->vlan = htons(skb_vlan_tag_get(skb));
                 st->vlan_insert++;
         } else
                 cpl->vlan_valid = 0;
diff --git a/drivers/net/ethernet/chelsio/cxgb3/mc5.c b/drivers/net/ethernet/chelsio/cxgb3/mc5.c
index e13b7fe9d082..338301b11518 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/mc5.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/mc5.c
@@ -97,14 +97,6 @@ static int mc5_cmd_write(struct adapter *adapter, u32 cmd)
                                F_DBGIRSPVALID, 1, MAX_WRITE_ATTEMPTS, 1);
 }
 
-static inline void dbgi_wr_addr3(struct adapter *adapter, u32 v1, u32 v2,
-                                 u32 v3)
-{
-        t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_ADDR0, v1);
-        t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_ADDR1, v2);
-        t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_ADDR2, v3);
-}
-
 static inline void dbgi_wr_data3(struct adapter *adapter, u32 v1, u32 v2,
                                  u32 v3)
 {
@@ -113,14 +105,6 @@ static inline void dbgi_wr_data3(struct adapter *adapter, u32 v1, u32 v2,
         t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_DATA2, v3);
 }
 
-static inline void dbgi_rd_rsp3(struct adapter *adapter, u32 *v1, u32 *v2,
-                                u32 *v3)
-{
-        *v1 = t3_read_reg(adapter, A_MC5_DB_DBGI_RSP_DATA0);
-        *v2 = t3_read_reg(adapter, A_MC5_DB_DBGI_RSP_DATA1);
-        *v3 = t3_read_reg(adapter, A_MC5_DB_DBGI_RSP_DATA2);
-}
-
 /*
  * Write data to the TCAM register at address (0, 0, addr_lo) using the TCAM
  * command cmd.  The data to be written must have been set up by the caller.
diff --git a/drivers/net/ethernet/chelsio/cxgb3/sge.c b/drivers/net/ethernet/chelsio/cxgb3/sge.c
index 3dfcf600fcc6..d6aa602f168d 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/sge.c
@@ -1148,8 +1148,8 @@ static void write_tx_pkt_wr(struct adapter *adap, struct sk_buff *skb,
         cpl->len = htonl(skb->len);
         cntrl = V_TXPKT_INTF(pi->port_id);
 
-        if (vlan_tx_tag_present(skb))
-                cntrl |= F_TXPKT_VLAN_VLD | V_TXPKT_VLAN(vlan_tx_tag_get(skb));
+        if (skb_vlan_tag_present(skb))
+                cntrl |= F_TXPKT_VLAN_VLD | V_TXPKT_VLAN(skb_vlan_tag_get(skb));
 
         tso_info = V_LSO_MSS(skb_shinfo(skb)->gso_size);
         if (tso_info) {
@@ -1282,7 +1282,7 @@ netdev_tx_t t3_eth_xmit(struct sk_buff *skb, struct net_device *dev)
                 qs->port_stats[SGE_PSTAT_TX_CSUM]++;
         if (skb_shinfo(skb)->gso_size)
                 qs->port_stats[SGE_PSTAT_TSO]++;
-        if (vlan_tx_tag_present(skb))
+        if (skb_vlan_tag_present(skb))
                 qs->port_stats[SGE_PSTAT_VLANINS]++;
 
         /*
diff --git a/drivers/net/ethernet/chelsio/cxgb3/t3_hw.c b/drivers/net/ethernet/chelsio/cxgb3/t3_hw.c
index c74a898fcd4f..184a8d545ac4 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/t3_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/t3_hw.c
@@ -727,9 +727,9 @@ static int get_vpd_params(struct adapter *adapter, struct vpd_params *p)
                 p->xauicfg[1] = simple_strtoul(vpd.xaui1cfg_data, NULL, 16);
         }
 
-        for (i = 0; i < 6; i++)
-                p->eth_base[i] = hex_to_bin(vpd.na_data[2 * i]) * 16 +
-                                 hex_to_bin(vpd.na_data[2 * i + 1]);
+        ret = hex2bin(p->eth_base, vpd.na_data, 6);
+        if (ret < 0)
+                return -EINVAL;
         return 0;
 }
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/Makefile b/drivers/net/ethernet/chelsio/cxgb4/Makefile
index b85280775997..ae50cd72358c 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/Makefile
+++ b/drivers/net/ethernet/chelsio/cxgb4/Makefile
@@ -4,6 +4,6 @@
 
 obj-$(CONFIG_CHELSIO_T4) += cxgb4.o
 
-cxgb4-objs := cxgb4_main.o l2t.o t4_hw.o sge.o
+cxgb4-objs := cxgb4_main.o l2t.o t4_hw.o sge.o clip_tbl.o
 cxgb4-$(CONFIG_CHELSIO_T4_DCB) +=  cxgb4_dcb.o
 cxgb4-$(CONFIG_DEBUG_FS) += cxgb4_debugfs.o
diff --git a/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.c b/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.c
new file mode 100644
index 000000000000..9062a8434246
--- /dev/null
+++ b/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.c
@@ -0,0 +1,317 @@
+/*
+ *  This file is part of the Chelsio T4 Ethernet driver for Linux.
+ *  Copyright (C) 2003-2014 Chelsio Communications.  All rights reserved.
+ *
+ *  Written by Deepak (deepak.s@chelsio.com)
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE.  See the LICENSE file included in this
+ *  release for licensing terms and conditions.
+ */
+
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/jhash.h>
+#include <linux/if_vlan.h>
+#include <net/addrconf.h>
+#include "cxgb4.h"
+#include "clip_tbl.h"
+
+static inline unsigned int ipv4_clip_hash(struct clip_tbl *c, const u32 *key)
+{
+        unsigned int clipt_size_half = c->clipt_size / 2;
+
+        return jhash_1word(*key, 0) % clipt_size_half;
+}
+
+static inline unsigned int ipv6_clip_hash(struct clip_tbl *d, const u32 *key)
+{
+        unsigned int clipt_size_half = d->clipt_size / 2;
+        u32 xor = key[0] ^ key[1] ^ key[2] ^ key[3];
+
+        return clipt_size_half +
+                (jhash_1word(xor, 0) % clipt_size_half);
+}
+
+static unsigned int clip_addr_hash(struct clip_tbl *ctbl, const u32 *addr,
+                                   int addr_len)
+{
+        return addr_len == 4 ? ipv4_clip_hash(ctbl, addr) :
+                                ipv6_clip_hash(ctbl, addr);
+}
+
+static int clip6_get_mbox(const struct net_device *dev,
+                          const struct in6_addr *lip)
+{
+        struct adapter *adap = netdev2adap(dev);
+        struct fw_clip_cmd c;
+
+        memset(&c, 0, sizeof(c));
+        c.op_to_write = htonl(FW_CMD_OP_V(FW_CLIP_CMD) |
+                              FW_CMD_REQUEST_F | FW_CMD_WRITE_F);
+        c.alloc_to_len16 = htonl(FW_CLIP_CMD_ALLOC_F | FW_LEN16(c));
+        *(__be64 *)&c.ip_hi = *(__be64 *)(lip->s6_addr);
+        *(__be64 *)&c.ip_lo = *(__be64 *)(lip->s6_addr + 8);
+        return t4_wr_mbox_meat(adap, adap->mbox, &c, sizeof(c), &c, false);
+}
+
+static int clip6_release_mbox(const struct net_device *dev,
+                              const struct in6_addr *lip)
+{
+        struct adapter *adap = netdev2adap(dev);
+        struct fw_clip_cmd c;
+
+        memset(&c, 0, sizeof(c));
+        c.op_to_write = htonl(FW_CMD_OP_V(FW_CLIP_CMD) |
+                              FW_CMD_REQUEST_F | FW_CMD_READ_F);
+        c.alloc_to_len16 = htonl(FW_CLIP_CMD_FREE_F | FW_LEN16(c));
+        *(__be64 *)&c.ip_hi = *(__be64 *)(lip->s6_addr);
+        *(__be64 *)&c.ip_lo = *(__be64 *)(lip->s6_addr + 8);
+        return t4_wr_mbox_meat(adap, adap->mbox, &c, sizeof(c), &c, false);
+}
+
+int cxgb4_clip_get(const struct net_device *dev, const u32 *lip, u8 v6)
+{
+        struct adapter *adap = netdev2adap(dev);
+        struct clip_tbl *ctbl = adap->clipt;
+        struct clip_entry *ce, *cte;
+        u32 *addr = (u32 *)lip;
+        int hash;
+        int addr_len;
+        int ret = 0;
+
+        if (!ctbl)
+                return 0;
+
+        if (v6)
+                addr_len = 16;
+        else
+                addr_len = 4;
+
+        hash = clip_addr_hash(ctbl, addr, addr_len);
+
+        read_lock_bh(&ctbl->lock);
+        list_for_each_entry(cte, &ctbl->hash_list[hash], list) {
+                if (addr_len == cte->addr_len &&
+                    memcmp(lip, cte->addr, cte->addr_len) == 0) {
+                        ce = cte;
+                        read_unlock_bh(&ctbl->lock);
+                        goto found;
+                }
+        }
+        read_unlock_bh(&ctbl->lock);
+
+        write_lock_bh(&ctbl->lock);
+        if (!list_empty(&ctbl->ce_free_head)) {
+                ce = list_first_entry(&ctbl->ce_free_head,
+                                      struct clip_entry, list);
+                list_del(&ce->list);
+                INIT_LIST_HEAD(&ce->list);
+                spin_lock_init(&ce->lock);
+                atomic_set(&ce->refcnt, 0);
+                atomic_dec(&ctbl->nfree);
+                ce->addr_len = addr_len;
+                memcpy(ce->addr, lip, addr_len);
+                list_add_tail(&ce->list, &ctbl->hash_list[hash]);
+                if (v6) {
+                        ret = clip6_get_mbox(dev, (const struct in6_addr *)lip);
+                        if (ret) {
+                                write_unlock_bh(&ctbl->lock);
+                                return ret;
+                        }
+                }
+        } else {
+                write_unlock_bh(&ctbl->lock);
+                return -ENOMEM;
+        }
+        write_unlock_bh(&ctbl->lock);
+found:
+        atomic_inc(&ce->refcnt);
+
+        return 0;
+}
+EXPORT_SYMBOL(cxgb4_clip_get);
+
+void cxgb4_clip_release(const struct net_device *dev, const u32 *lip, u8 v6)
+{
+        struct adapter *adap = netdev2adap(dev);
+        struct clip_tbl *ctbl = adap->clipt;
+        struct clip_entry *ce, *cte;
+        u32 *addr = (u32 *)lip;
+        int hash;
+        int addr_len;
+
+        if (v6)
+                addr_len = 16;
+        else
+                addr_len = 4;
+
+        hash = clip_addr_hash(ctbl, addr, addr_len);
+
+        read_lock_bh(&ctbl->lock);
+        list_for_each_entry(cte, &ctbl->hash_list[hash], list) {
+                if (addr_len == cte->addr_len &&
+                    memcmp(lip, cte->addr, cte->addr_len) == 0) {
+                        ce = cte;
+                        read_unlock_bh(&ctbl->lock);
+                        goto found;
+                }
+        }
+        read_unlock_bh(&ctbl->lock);
+
+        return;
+found:
+        write_lock_bh(&ctbl->lock);
+        spin_lock_bh(&ce->lock);
+        if (atomic_dec_and_test(&ce->refcnt)) {
+                list_del(&ce->list);
+                INIT_LIST_HEAD(&ce->list);
+                list_add_tail(&ce->list, &ctbl->ce_free_head);
+                atomic_inc(&ctbl->nfree);
+                if (v6)
+                        clip6_release_mbox(dev, (const struct in6_addr *)lip);
+        }
+        spin_unlock_bh(&ce->lock);
+        write_unlock_bh(&ctbl->lock);
+}
+EXPORT_SYMBOL(cxgb4_clip_release);
+
+/* Retrieves IPv6 addresses from a root device (bond, vlan) associated with
+ * a physical device.
+ * The physical device reference is needed to send the actul CLIP command.
+ */
+static int cxgb4_update_dev_clip(struct net_device *root_dev,
+                                 struct net_device *dev)
+{
+        struct inet6_dev *idev = NULL;
+        struct inet6_ifaddr *ifa;
+        int ret = 0;
+
+        idev = __in6_dev_get(root_dev);
+        if (!idev)
+                return ret;
+
+        read_lock_bh(&idev->lock);
+        list_for_each_entry(ifa, &idev->addr_list, if_list) {
+                ret = cxgb4_clip_get(dev, (const u32 *)ifa->addr.s6_addr, 1);
+                if (ret < 0)
+                        break;
+        }
+        read_unlock_bh(&idev->lock);
+
+        return ret;
+}
+
+int cxgb4_update_root_dev_clip(struct net_device *dev)
+{
+        struct net_device *root_dev = NULL;
+        int i, ret = 0;
+
+        /* First populate the real net device's IPv6 addresses */
+        ret = cxgb4_update_dev_clip(dev, dev);
+        if (ret)
+                return ret;
+
+        /* Parse all bond and vlan devices layered on top of the physical dev */
+        root_dev = netdev_master_upper_dev_get_rcu(dev);
+        if (root_dev) {
+                ret = cxgb4_update_dev_clip(root_dev, dev);
+                if (ret)
+                        return ret;
+        }
+
+        for (i = 0; i < VLAN_N_VID; i++) {
+                root_dev = __vlan_find_dev_deep_rcu(dev, htons(ETH_P_8021Q), i);
+                if (!root_dev)
+                        continue;
+
+                ret = cxgb4_update_dev_clip(root_dev, dev);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL(cxgb4_update_root_dev_clip);
+
+int clip_tbl_show(struct seq_file *seq, void *v)
+{
+        struct adapter *adapter = seq->private;
+        struct clip_tbl *ctbl = adapter->clipt;
+        struct clip_entry *ce;
+        char ip[60];
+        int i;
+
+        read_lock_bh(&ctbl->lock);
+
+        seq_puts(seq, "IP Address                  Users\n");
+        for (i = 0 ; i < ctbl->clipt_size;  ++i) {
+                list_for_each_entry(ce, &ctbl->hash_list[i], list) {
+                        ip[0] = '\0';
+                        if (ce->addr_len == 16)
+                                sprintf(ip, "%pI6c", ce->addr);
+                        else
+                                sprintf(ip, "%pI4c", ce->addr);
+                        seq_printf(seq, "%-25s   %u\n", ip,
+                                   atomic_read(&ce->refcnt));
+                }
+        }
+        seq_printf(seq, "Free clip entries : %d\n", atomic_read(&ctbl->nfree));
+
+        read_unlock_bh(&ctbl->lock);
+
+        return 0;
+}
+
+struct clip_tbl *t4_init_clip_tbl(unsigned int clipt_start,
+                                  unsigned int clipt_end)
+{
+        struct clip_entry *cl_list;
+        struct clip_tbl *ctbl;
+        unsigned int clipt_size;
+        int i;
+
+        if (clipt_start >= clipt_end)
+                return NULL;
+        clipt_size = clipt_end - clipt_start + 1;
+        if (clipt_size < CLIPT_MIN_HASH_BUCKETS)
+                return NULL;
+
+        ctbl = t4_alloc_mem(sizeof(*ctbl) +
+                            clipt_size*sizeof(struct list_head));
+        if (!ctbl)
+                return NULL;
+
+        ctbl->clipt_start = clipt_start;
+        ctbl->clipt_size = clipt_size;
+        INIT_LIST_HEAD(&ctbl->ce_free_head);
+
+        atomic_set(&ctbl->nfree, clipt_size);
+        rwlock_init(&ctbl->lock);
+
+        for (i = 0; i < ctbl->clipt_size; ++i)
+                INIT_LIST_HEAD(&ctbl->hash_list[i]);
+
+        cl_list = t4_alloc_mem(clipt_size*sizeof(struct clip_entry));
+        ctbl->cl_list = (void *)cl_list;
+
+        for (i = 0; i < clipt_size; i++) {
+                INIT_LIST_HEAD(&cl_list[i].list);
+                list_add_tail(&cl_list[i].list, &ctbl->ce_free_head);
+        }
+
+        return ctbl;
+}
+
+void t4_cleanup_clip_tbl(struct adapter *adap)
+{
+        struct clip_tbl *ctbl = adap->clipt;
+
+        if (ctbl) {
+                if (ctbl->cl_list)
+                        t4_free_mem(ctbl->cl_list);
+                t4_free_mem(ctbl);
+        }
+}
+EXPORT_SYMBOL(t4_cleanup_clip_tbl);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.h b/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.h
new file mode 100644
index 000000000000..2eaba0161cf8
--- /dev/null
+++ b/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.h
@@ -0,0 +1,41 @@
+/*
+ *  This file is part of the Chelsio T4 Ethernet driver for Linux.
+ *  Copyright (C) 2003-2014 Chelsio Communications.  All rights reserved.
+ *
+ *  Written by Deepak (deepak.s@chelsio.com)
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE.  See the LICENSE file included in this
+ *  release for licensing terms and conditions.
+ */
+
+struct clip_entry {
+        spinlock_t lock;        /* Hold while modifying clip reference */
+        atomic_t refcnt;
+        struct list_head list;
+        u32 addr[4];
+        int addr_len;
+};
+
+struct clip_tbl {
+        unsigned int clipt_start;
+        unsigned int clipt_size;
+        rwlock_t lock;
+        atomic_t nfree;
+        struct list_head ce_free_head;
+        void *cl_list;
+        struct list_head hash_list[0];
+};
+
+enum {
+        CLIPT_MIN_HASH_BUCKETS = 2,
+};
+
+struct clip_tbl *t4_init_clip_tbl(unsigned int clipt_start,
+                                  unsigned int clipt_end);
+int cxgb4_clip_get(const struct net_device *dev, const u32 *lip, u8 v6);
+void cxgb4_clip_release(const struct net_device *dev, const u32 *lip, u8 v6);
+int clip_tbl_show(struct seq_file *seq, void *v);
+int cxgb4_update_root_dev_clip(struct net_device *dev);
+void t4_cleanup_clip_tbl(struct adapter *adap);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
index 5ab5c3133acd..d6cda17efe6e 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
@@ -49,16 +49,6 @@
 #include <asm/io.h>
 #include "cxgb4_uld.h"
 
-#define T4FW_VERSION_MAJOR 0x01
-#define T4FW_VERSION_MINOR 0x0C
-#define T4FW_VERSION_MICRO 0x19
-#define T4FW_VERSION_BUILD 0x00
-
-#define T5FW_VERSION_MAJOR 0x01
-#define T5FW_VERSION_MINOR 0x0C
-#define T5FW_VERSION_MICRO 0x19
-#define T5FW_VERSION_BUILD 0x00
-
 #define CH_WARN(adap, fmt, ...) dev_warn(adap->pdev_dev, fmt, ## __VA_ARGS__)
 
 enum {
@@ -231,6 +221,7 @@ struct sge_params {
 struct tp_params {
         unsigned int ntxchan;        /* # of Tx channels */
         unsigned int tre;            /* log2 of core clocks per TP tick */
+        unsigned int la_mask;        /* what events are recorded by TP LA */
         unsigned short tx_modq_map;  /* TX modulation scheduler queue to */
                                      /* channel map */
 
@@ -290,11 +281,21 @@ enum chip_type {
         T5_LAST_REV     = T5_A1,
 };
 
+struct devlog_params {
+        u32 memtype;                    /* which memory (EDC0, EDC1, MC) */
+        u32 start;                      /* start of log in firmware memory */
+        u32 size;                       /* size of log */
+};
+
 struct adapter_params {
         struct sge_params sge;
         struct tp_params  tp;
         struct vpd_params vpd;
         struct pci_params pci;
+        struct devlog_params devlog;
+        enum pcie_memwin drv_memwin;
+
+        unsigned int cim_la_size;
 
         unsigned int sf_size;             /* serial flash size in bytes */
         unsigned int sf_nsec;             /* # of flash sectors */
@@ -476,6 +477,22 @@ struct sge_rspq {                   /* state for an SGE response queue */
         struct adapter *adap;
         struct net_device *netdev;  /* associated net device */
         rspq_handler_t handler;
+#ifdef CONFIG_NET_RX_BUSY_POLL
+#define CXGB_POLL_STATE_IDLE            0
+#define CXGB_POLL_STATE_NAPI            BIT(0) /* NAPI owns this poll */
+#define CXGB_POLL_STATE_POLL            BIT(1) /* poll owns this poll */
+#define CXGB_POLL_STATE_NAPI_YIELD      BIT(2) /* NAPI yielded this poll */
+#define CXGB_POLL_STATE_POLL_YIELD      BIT(3) /* poll yielded this poll */
+#define CXGB_POLL_YIELD                 (CXGB_POLL_STATE_NAPI_YIELD |   \
+                                         CXGB_POLL_STATE_POLL_YIELD)
+#define CXGB_POLL_LOCKED                (CXGB_POLL_STATE_NAPI |         \
+                                         CXGB_POLL_STATE_POLL)
+#define CXGB_POLL_USER_PEND             (CXGB_POLL_STATE_POLL |         \
+                                         CXGB_POLL_STATE_POLL_YIELD)
+        unsigned int bpoll_state;
+        spinlock_t bpoll_lock;          /* lock for busy poll */
+#endif /* CONFIG_NET_RX_BUSY_POLL */
+
 };
 
 struct sge_eth_stats {              /* Ethernet queue statistics */
@@ -658,6 +675,9 @@ struct adapter {
         unsigned int l2t_start;
         unsigned int l2t_end;
         struct l2t_data *l2t;
+        unsigned int clipt_start;
+        unsigned int clipt_end;
+        struct clip_tbl *clipt;
         void *uld_handle[CXGB4_ULD_MAX];
         struct list_head list_node;
         struct list_head rcu_node;
@@ -877,6 +897,102 @@ static inline struct adapter *netdev2adap(const struct net_device *dev)
         return netdev2pinfo(dev)->adapter;
 }
 
+#ifdef CONFIG_NET_RX_BUSY_POLL
+static inline void cxgb_busy_poll_init_lock(struct sge_rspq *q)
+{
+        spin_lock_init(&q->bpoll_lock);
+        q->bpoll_state = CXGB_POLL_STATE_IDLE;
+}
+
+static inline bool cxgb_poll_lock_napi(struct sge_rspq *q)
+{
+        bool rc = true;
+
+        spin_lock(&q->bpoll_lock);
+        if (q->bpoll_state & CXGB_POLL_LOCKED) {
+                q->bpoll_state |= CXGB_POLL_STATE_NAPI_YIELD;
+                rc = false;
+        } else {
+                q->bpoll_state = CXGB_POLL_STATE_NAPI;
+        }
+        spin_unlock(&q->bpoll_lock);
+        return rc;
+}
+
+static inline bool cxgb_poll_unlock_napi(struct sge_rspq *q)
+{
+        bool rc = false;
+
+        spin_lock(&q->bpoll_lock);
+        if (q->bpoll_state & CXGB_POLL_STATE_POLL_YIELD)
+                rc = true;
+        q->bpoll_state = CXGB_POLL_STATE_IDLE;
+        spin_unlock(&q->bpoll_lock);
+        return rc;
+}
+
+static inline bool cxgb_poll_lock_poll(struct sge_rspq *q)
+{
+        bool rc = true;
+
+        spin_lock_bh(&q->bpoll_lock);
+        if (q->bpoll_state & CXGB_POLL_LOCKED) {
+                q->bpoll_state |= CXGB_POLL_STATE_POLL_YIELD;
+                rc = false;
+        } else {
+                q->bpoll_state |= CXGB_POLL_STATE_POLL;
+        }
+        spin_unlock_bh(&q->bpoll_lock);
+        return rc;
+}
+
+static inline bool cxgb_poll_unlock_poll(struct sge_rspq *q)
+{
+        bool rc = false;
+
+        spin_lock_bh(&q->bpoll_lock);
+        if (q->bpoll_state & CXGB_POLL_STATE_POLL_YIELD)
+                rc = true;
+        q->bpoll_state = CXGB_POLL_STATE_IDLE;
+        spin_unlock_bh(&q->bpoll_lock);
+        return rc;
+}
+
+static inline bool cxgb_poll_busy_polling(struct sge_rspq *q)
+{
+        return q->bpoll_state & CXGB_POLL_USER_PEND;
+}
+#else
+static inline void cxgb_busy_poll_init_lock(struct sge_rspq *q)
+{
+}
+
+static inline bool cxgb_poll_lock_napi(struct sge_rspq *q)
+{
+        return true;
+}
+
+static inline bool cxgb_poll_unlock_napi(struct sge_rspq *q)
+{
+        return false;
+}
+
+static inline bool cxgb_poll_lock_poll(struct sge_rspq *q)
+{
+        return false;
+}
+
+static inline bool cxgb_poll_unlock_poll(struct sge_rspq *q)
+{
+        return false;
+}
+
+static inline bool cxgb_poll_busy_polling(struct sge_rspq *q)
+{
+        return false;
+}
+#endif /* CONFIG_NET_RX_BUSY_POLL */
+
 void t4_os_portmod_changed(const struct adapter *adap, int port_id);
 void t4_os_link_changed(struct adapter *adap, int port_id, int link_stat);
 
@@ -905,6 +1021,7 @@ irqreturn_t t4_sge_intr_msix(int irq, void *cookie);
 int t4_sge_init(struct adapter *adap);
 void t4_sge_start(struct adapter *adap);
 void t4_sge_stop(struct adapter *adap);
+int cxgb_busy_poll(struct napi_struct *napi);
 extern int dbfifo_int_thresh;
 
 #define for_each_port(adapter, iter) \
@@ -995,12 +1112,16 @@ static inline int t4_memory_write(struct adapter *adap, int mtype, u32 addr,
 
 int t4_seeprom_wp(struct adapter *adapter, bool enable);
 int get_vpd_params(struct adapter *adapter, struct vpd_params *p);
+int t4_read_flash(struct adapter *adapter, unsigned int addr,
+                  unsigned int nwords, u32 *data, int byte_oriented);
 int t4_load_fw(struct adapter *adapter, const u8 *fw_data, unsigned int size);
+int t4_fwcache(struct adapter *adap, enum fw_params_param_dev_fwcache op);
 int t4_fw_upgrade(struct adapter *adap, unsigned int mbox,
                   const u8 *fw_data, unsigned int size, int force);
 unsigned int t4_flash_cfg_addr(struct adapter *adapter);
 int t4_get_fw_version(struct adapter *adapter, u32 *vers);
 int t4_get_tp_version(struct adapter *adapter, u32 *vers);
+int t4_get_exprom_version(struct adapter *adapter, u32 *vers);
 int t4_prep_fw(struct adapter *adap, struct fw_info *fw_info,
                const u8 *fw_data, unsigned int fw_size,
                struct fw_hdr *card_fw, enum dev_state state, int *reset);
@@ -1013,6 +1134,8 @@ int cxgb4_t4_bar2_sge_qregs(struct adapter *adapter,
                       u64 *pbar2_qoffset,
                       unsigned int *pbar2_qid);
 
+unsigned int qtimer_val(const struct adapter *adap,
+                        const struct sge_rspq *q);
 int t4_init_sge_params(struct adapter *adapter);
 int t4_init_tp_params(struct adapter *adap);
 int t4_filter_field_shift(const struct adapter *adap, int filter_sel);
@@ -1022,20 +1145,46 @@ int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid,
                         int start, int n, const u16 *rspq, unsigned int nrspq);
 int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode,
                        unsigned int flags);
+int t4_read_rss(struct adapter *adapter, u16 *entries);
+void t4_read_rss_key(struct adapter *adapter, u32 *key);
+void t4_write_rss_key(struct adapter *adap, const u32 *key, int idx);
+void t4_read_rss_pf_config(struct adapter *adapter, unsigned int index,
+                           u32 *valp);
+void t4_read_rss_vf_config(struct adapter *adapter, unsigned int index,
+                           u32 *vfl, u32 *vfh);
+u32 t4_read_rss_pf_map(struct adapter *adapter);
+u32 t4_read_rss_pf_mask(struct adapter *adapter);
+
 int t4_mc_read(struct adapter *adap, int idx, u32 addr, __be32 *data,
                u64 *parity);
 int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data,
                 u64 *parity);
+void t4_pmtx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[]);
+void t4_pmrx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[]);
+int t4_read_cim_ibq(struct adapter *adap, unsigned int qid, u32 *data,
+                    size_t n);
+int t4_read_cim_obq(struct adapter *adap, unsigned int qid, u32 *data,
+                    size_t n);
+int t4_cim_read(struct adapter *adap, unsigned int addr, unsigned int n,
+                unsigned int *valp);
+int t4_cim_write(struct adapter *adap, unsigned int addr, unsigned int n,
+                 const unsigned int *valp);
+int t4_cim_read_la(struct adapter *adap, u32 *la_buf, unsigned int *wrptr);
+void t4_read_cimq_cfg(struct adapter *adap, u16 *base, u16 *size, u16 *thres);
 const char *t4_get_port_type_description(enum fw_port_type port_type);
 void t4_get_port_stats(struct adapter *adap, int idx, struct port_stats *p);
 void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log);
+void t4_read_cong_tbl(struct adapter *adap, u16 incr[NMTUS][NCCTRL_WIN]);
 void t4_tp_wr_bits_indirect(struct adapter *adap, unsigned int addr,
                             unsigned int mask, unsigned int val);
+void t4_tp_read_la(struct adapter *adap, u64 *la_buf, unsigned int *wrptr);
 void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4,
                          struct tp_tcp_stats *v6);
 void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
                   const unsigned short *alpha, const unsigned short *beta);
 
+void t4_ulprx_read_la(struct adapter *adap, u32 *la_buf);
+
 void t4_mk_filtdelwr(unsigned int ftid, struct fw_filter_wr *wr, int qid);
 
 void t4_wol_magic_enable(struct adapter *adap, unsigned int port,
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.c
index a35d1ec6950e..6074680bc985 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.c
@@ -22,7 +22,7 @@
 
 /* DCBx version control
  */
-char *dcb_ver_array[] = {
+static const char * const dcb_ver_array[] = {
         "Unknown",
         "DCBx-CIN",
         "DCBx-CEE 1.01",
@@ -428,7 +428,10 @@ static void cxgb4_getpgtccfg(struct net_device *dev, int tc,
         }
         *pgid = (be32_to_cpu(pcmd.u.dcb.pgid.pgid) >> (tc * 4)) & 0xf;
 
-        INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
+        if (local)
+                INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
+        else
+                INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
         pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
         err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
         if (err != FW_PORT_DCB_CFG_SUCCESS) {
@@ -900,6 +903,88 @@ cxgb4_ieee_negotiation_complete(struct net_device *dev,
                 (dcb->supported & DCB_CAP_DCBX_VER_IEEE));
 }
 
+static int cxgb4_ieee_read_ets(struct net_device *dev, struct ieee_ets *ets,
+                               int local)
+{
+        struct port_info *pi = netdev2pinfo(dev);
+        struct port_dcb_info *dcb = &pi->dcb;
+        struct adapter *adap = pi->adapter;
+        uint32_t tc_info;
+        struct fw_port_cmd pcmd;
+        int i, bwg, err;
+
+        if (!(dcb->msgs & (CXGB4_DCB_FW_PGID | CXGB4_DCB_FW_PGRATE)))
+                return 0;
+
+        ets->ets_cap =  dcb->pg_num_tcs_supported;
+
+        if (local) {
+                ets->willing = 1;
+                INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
+        } else {
+                INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
+        }
+
+        pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID;
+        err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
+        if (err != FW_PORT_DCB_CFG_SUCCESS) {
+                dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err);
+                return err;
+        }
+
+        tc_info = be32_to_cpu(pcmd.u.dcb.pgid.pgid);
+
+        if (local)
+                INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
+        else
+                INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
+
+        pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
+        err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
+        if (err != FW_PORT_DCB_CFG_SUCCESS) {
+                dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
+                        -err);
+                return err;
+        }
+
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                bwg = (tc_info >> ((7 - i) * 4)) & 0xF;
+                ets->prio_tc[i] = bwg;
+                ets->tc_tx_bw[i] = pcmd.u.dcb.pgrate.pgrate[i];
+                ets->tc_rx_bw[i] = ets->tc_tx_bw[i];
+                ets->tc_tsa[i] = pcmd.u.dcb.pgrate.tsa[i];
+        }
+
+        return 0;
+}
+
+static int cxgb4_ieee_get_ets(struct net_device *dev, struct ieee_ets *ets)
+{
+        return cxgb4_ieee_read_ets(dev, ets, 1);
+}
+
+/* We reuse this for peer PFC as well, as we can't have it enabled one way */
+static int cxgb4_ieee_get_pfc(struct net_device *dev, struct ieee_pfc *pfc)
+{
+        struct port_info *pi = netdev2pinfo(dev);
+        struct port_dcb_info *dcb = &pi->dcb;
+
+        memset(pfc, 0, sizeof(struct ieee_pfc));
+
+        if (!(dcb->msgs & CXGB4_DCB_FW_PFC))
+                return 0;
+
+        pfc->pfc_cap = dcb->pfc_num_tcs_supported;
+        pfc->pfc_en = bitswap_1(dcb->pfcen);
+
+        return 0;
+}
+
+static int cxgb4_ieee_peer_ets(struct net_device *dev, struct ieee_ets *ets)
+{
+        return cxgb4_ieee_read_ets(dev, ets, 0);
+}
+
 /* Fill in the Application User Priority Map associated with the
  * specified Application.
  * Priority for IEEE dcb_app is an integer, with 0 being a valid value
@@ -1106,14 +1191,23 @@ static int cxgb4_cee_peer_getpfc(struct net_device *dev, struct cee_pfc *pfc)
         struct port_info *pi = netdev2pinfo(dev);
 
         cxgb4_getnumtcs(dev, DCB_NUMTCS_ATTR_PFC, &(pfc->tcs_supported));
-        pfc->pfc_en = pi->dcb.pfcen;
+
+        /* Firmware sends this to us in a formwat that is a bit flipped version
+         * of spec, correct it before we send it to host. This is taken care of
+         * by bit shifting in other uses of pfcen
+         */
+        pfc->pfc_en = bitswap_1(pi->dcb.pfcen);
 
         return 0;
 }
 
 const struct dcbnl_rtnl_ops cxgb4_dcb_ops = {
+        .ieee_getets            = cxgb4_ieee_get_ets,
+        .ieee_getpfc            = cxgb4_ieee_get_pfc,
         .ieee_getapp            = cxgb4_ieee_getapp,
         .ieee_setapp            = cxgb4_ieee_setapp,
+        .ieee_peer_getets       = cxgb4_ieee_peer_ets,
+        .ieee_peer_getpfc       = cxgb4_ieee_get_pfc,
 
         /* CEE std */
         .getstate               = cxgb4_getstate,
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.h
index 31ce425616c9..ccf24d3dc982 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.h
@@ -136,6 +136,17 @@ void cxgb4_dcb_handle_fw_update(struct adapter *, const struct fw_port_cmd *);
 void cxgb4_dcb_set_caps(struct adapter *, const struct fw_port_cmd *);
 extern const struct dcbnl_rtnl_ops cxgb4_dcb_ops;
 
+static inline __u8 bitswap_1(unsigned char val)
+{
+        return ((val & 0x80) >> 7) |
+               ((val & 0x40) >> 5) |
+               ((val & 0x20) >> 3) |
+               ((val & 0x10) >> 1) |
+               ((val & 0x08) << 1) |
+               ((val & 0x04) << 3) |
+               ((val & 0x02) << 5) |
+               ((val & 0x01) << 7);
+}
 #define CXGB4_DCB_ENABLED true
 
 #else /* !CONFIG_CHELSIO_T4_DCB */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
index c98a350d857e..d221f6b28fcd 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
@@ -36,13 +36,1867 @@
 #include <linux/debugfs.h>
 #include <linux/string_helpers.h>
 #include <linux/sort.h>
+#include <linux/ctype.h>
 
 #include "cxgb4.h"
 #include "t4_regs.h"
+#include "t4_values.h"
 #include "t4fw_api.h"
 #include "cxgb4_debugfs.h"
+#include "clip_tbl.h"
 #include "l2t.h"
 
+/* generic seq_file support for showing a table of size rows x width. */
+static void *seq_tab_get_idx(struct seq_tab *tb, loff_t pos)
+{
+        pos -= tb->skip_first;
+        return pos >= tb->rows ? NULL : &tb->data[pos * tb->width];
+}
+
+static void *seq_tab_start(struct seq_file *seq, loff_t *pos)
+{
+        struct seq_tab *tb = seq->private;
+
+        if (tb->skip_first && *pos == 0)
+                return SEQ_START_TOKEN;
+
+        return seq_tab_get_idx(tb, *pos);
+}
+
+static void *seq_tab_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+        v = seq_tab_get_idx(seq->private, *pos + 1);
+        if (v)
+                ++*pos;
+        return v;
+}
+
+static void seq_tab_stop(struct seq_file *seq, void *v)
+{
+}
+
+static int seq_tab_show(struct seq_file *seq, void *v)
+{
+        const struct seq_tab *tb = seq->private;
+
+        return tb->show(seq, v, ((char *)v - tb->data) / tb->width);
+}
+
+static const struct seq_operations seq_tab_ops = {
+        .start = seq_tab_start,
+        .next  = seq_tab_next,
+        .stop  = seq_tab_stop,
+        .show  = seq_tab_show
+};
+
+struct seq_tab *seq_open_tab(struct file *f, unsigned int rows,
+                             unsigned int width, unsigned int have_header,
+                             int (*show)(struct seq_file *seq, void *v, int i))
+{
+        struct seq_tab *p;
+
+        p = __seq_open_private(f, &seq_tab_ops, sizeof(*p) + rows * width);
+        if (p) {
+                p->show = show;
+                p->rows = rows;
+                p->width = width;
+                p->skip_first = have_header != 0;
+        }
+        return p;
+}
+
+/* Trim the size of a seq_tab to the supplied number of rows.  The operation is
+ * irreversible.
+ */
+static int seq_tab_trim(struct seq_tab *p, unsigned int new_rows)
+{
+        if (new_rows > p->rows)
+                return -EINVAL;
+        p->rows = new_rows;
+        return 0;
+}
+
+static int cim_la_show(struct seq_file *seq, void *v, int idx)
+{
+        if (v == SEQ_START_TOKEN)
+                seq_puts(seq, "Status   Data      PC     LS0Stat  LS0Addr "
+                         "            LS0Data\n");
+        else {
+                const u32 *p = v;
+
+                seq_printf(seq,
+                           "  %02x  %x%07x %x%07x %08x %08x %08x%08x%08x%08x\n",
+                           (p[0] >> 4) & 0xff, p[0] & 0xf, p[1] >> 4,
+                           p[1] & 0xf, p[2] >> 4, p[2] & 0xf, p[3], p[4], p[5],
+                           p[6], p[7]);
+        }
+        return 0;
+}
+
+static int cim_la_show_3in1(struct seq_file *seq, void *v, int idx)
+{
+        if (v == SEQ_START_TOKEN) {
+                seq_puts(seq, "Status   Data      PC\n");
+        } else {
+                const u32 *p = v;
+
+                seq_printf(seq, "  %02x   %08x %08x\n", p[5] & 0xff, p[6],
+                           p[7]);
+                seq_printf(seq, "  %02x   %02x%06x %02x%06x\n",
+                           (p[3] >> 8) & 0xff, p[3] & 0xff, p[4] >> 8,
+                           p[4] & 0xff, p[5] >> 8);
+                seq_printf(seq, "  %02x   %x%07x %x%07x\n", (p[0] >> 4) & 0xff,
+                           p[0] & 0xf, p[1] >> 4, p[1] & 0xf, p[2] >> 4);
+        }
+        return 0;
+}
+
+static int cim_la_open(struct inode *inode, struct file *file)
+{
+        int ret;
+        unsigned int cfg;
+        struct seq_tab *p;
+        struct adapter *adap = inode->i_private;
+
+        ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg);
+        if (ret)
+                return ret;
+
+        p = seq_open_tab(file, adap->params.cim_la_size / 8, 8 * sizeof(u32), 1,
+                         cfg & UPDBGLACAPTPCONLY_F ?
+                         cim_la_show_3in1 : cim_la_show);
+        if (!p)
+                return -ENOMEM;
+
+        ret = t4_cim_read_la(adap, (u32 *)p->data, NULL);
+        if (ret)
+                seq_release_private(inode, file);
+        return ret;
+}
+
+static const struct file_operations cim_la_fops = {
+        .owner   = THIS_MODULE,
+        .open    = cim_la_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_private
+};
+
+static int cim_qcfg_show(struct seq_file *seq, void *v)
+{
+        static const char * const qname[] = {
+                "TP0", "TP1", "ULP", "SGE0", "SGE1", "NC-SI",
+                "ULP0", "ULP1", "ULP2", "ULP3", "SGE", "NC-SI",
+                "SGE0-RX", "SGE1-RX"
+        };
+
+        int i;
+        struct adapter *adap = seq->private;
+        u16 base[CIM_NUM_IBQ + CIM_NUM_OBQ_T5];
+        u16 size[CIM_NUM_IBQ + CIM_NUM_OBQ_T5];
+        u32 stat[(4 * (CIM_NUM_IBQ + CIM_NUM_OBQ_T5))];
+        u16 thres[CIM_NUM_IBQ];
+        u32 obq_wr_t4[2 * CIM_NUM_OBQ], *wr;
+        u32 obq_wr_t5[2 * CIM_NUM_OBQ_T5];
+        u32 *p = stat;
+        int cim_num_obq = is_t4(adap->params.chip) ?
+                                CIM_NUM_OBQ : CIM_NUM_OBQ_T5;
+
+        i = t4_cim_read(adap, is_t4(adap->params.chip) ? UP_IBQ_0_RDADDR_A :
+                        UP_IBQ_0_SHADOW_RDADDR_A,
+                        ARRAY_SIZE(stat), stat);
+        if (!i) {
+                if (is_t4(adap->params.chip)) {
+                        i = t4_cim_read(adap, UP_OBQ_0_REALADDR_A,
+                                        ARRAY_SIZE(obq_wr_t4), obq_wr_t4);
+                                wr = obq_wr_t4;
+                } else {
+                        i = t4_cim_read(adap, UP_OBQ_0_SHADOW_REALADDR_A,
+                                        ARRAY_SIZE(obq_wr_t5), obq_wr_t5);
+                                wr = obq_wr_t5;
+                }
+        }
+        if (i)
+                return i;
+
+        t4_read_cimq_cfg(adap, base, size, thres);
+
+        seq_printf(seq,
+                   "  Queue  Base  Size Thres  RdPtr WrPtr  SOP  EOP Avail\n");
+        for (i = 0; i < CIM_NUM_IBQ; i++, p += 4)
+                seq_printf(seq, "%7s %5x %5u %5u %6x  %4x %4u %4u %5u\n",
+                           qname[i], base[i], size[i], thres[i],
+                           IBQRDADDR_G(p[0]), IBQWRADDR_G(p[1]),
+                           QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]),
+                           QUEREMFLITS_G(p[2]) * 16);
+        for ( ; i < CIM_NUM_IBQ + cim_num_obq; i++, p += 4, wr += 2)
+                seq_printf(seq, "%7s %5x %5u %12x  %4x %4u %4u %5u\n",
+                           qname[i], base[i], size[i],
+                           QUERDADDR_G(p[0]) & 0x3fff, wr[0] - base[i],
+                           QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]),
+                           QUEREMFLITS_G(p[2]) * 16);
+        return 0;
+}
+
+static int cim_qcfg_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, cim_qcfg_show, inode->i_private);
+}
+
+static const struct file_operations cim_qcfg_fops = {
+        .owner   = THIS_MODULE,
+        .open    = cim_qcfg_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+};
+
+static int cimq_show(struct seq_file *seq, void *v, int idx)
+{
+        const u32 *p = v;
+
+        seq_printf(seq, "%#06x: %08x %08x %08x %08x\n", idx * 16, p[0], p[1],
+                   p[2], p[3]);
+        return 0;
+}
+
+static int cim_ibq_open(struct inode *inode, struct file *file)
+{
+        int ret;
+        struct seq_tab *p;
+        unsigned int qid = (uintptr_t)inode->i_private & 7;
+        struct adapter *adap = inode->i_private - qid;
+
+        p = seq_open_tab(file, CIM_IBQ_SIZE, 4 * sizeof(u32), 0, cimq_show);
+        if (!p)
+                return -ENOMEM;
+
+        ret = t4_read_cim_ibq(adap, qid, (u32 *)p->data, CIM_IBQ_SIZE * 4);
+        if (ret < 0)
+                seq_release_private(inode, file);
+        else
+                ret = 0;
+        return ret;
+}
+
+static const struct file_operations cim_ibq_fops = {
+        .owner   = THIS_MODULE,
+        .open    = cim_ibq_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_private
+};
+
+static int cim_obq_open(struct inode *inode, struct file *file)
+{
+        int ret;
+        struct seq_tab *p;
+        unsigned int qid = (uintptr_t)inode->i_private & 7;
+        struct adapter *adap = inode->i_private - qid;
+
+        p = seq_open_tab(file, 6 * CIM_OBQ_SIZE, 4 * sizeof(u32), 0, cimq_show);
+        if (!p)
+                return -ENOMEM;
+
+        ret = t4_read_cim_obq(adap, qid, (u32 *)p->data, 6 * CIM_OBQ_SIZE * 4);
+        if (ret < 0) {
+                seq_release_private(inode, file);
+        } else {
+                seq_tab_trim(p, ret / 4);
+                ret = 0;
+        }
+        return ret;
+}
+
+static const struct file_operations cim_obq_fops = {
+        .owner   = THIS_MODULE,
+        .open    = cim_obq_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_private
+};
+
+struct field_desc {
+        const char *name;
+        unsigned int start;
+        unsigned int width;
+};
+
+static void field_desc_show(struct seq_file *seq, u64 v,
+                            const struct field_desc *p)
+{
+        char buf[32];
+        int line_size = 0;
+
+        while (p->name) {
+                u64 mask = (1ULL << p->width) - 1;
+                int len = scnprintf(buf, sizeof(buf), "%s: %llu", p->name,
+                                    ((unsigned long long)v >> p->start) & mask);
+
+                if (line_size + len >= 79) {
+                        line_size = 8;
+                        seq_puts(seq, "\n        ");
+                }
+                seq_printf(seq, "%s ", buf);
+                line_size += len + 1;
+                p++;
+        }
+        seq_putc(seq, '\n');
+}
+
+static struct field_desc tp_la0[] = {
+        { "RcfOpCodeOut", 60, 4 },
+        { "State", 56, 4 },
+        { "WcfState", 52, 4 },
+        { "RcfOpcSrcOut", 50, 2 },
+        { "CRxError", 49, 1 },
+        { "ERxError", 48, 1 },
+        { "SanityFailed", 47, 1 },
+        { "SpuriousMsg", 46, 1 },
+        { "FlushInputMsg", 45, 1 },
+        { "FlushInputCpl", 44, 1 },
+        { "RssUpBit", 43, 1 },
+        { "RssFilterHit", 42, 1 },
+        { "Tid", 32, 10 },
+        { "InitTcb", 31, 1 },
+        { "LineNumber", 24, 7 },
+        { "Emsg", 23, 1 },
+        { "EdataOut", 22, 1 },
+        { "Cmsg", 21, 1 },
+        { "CdataOut", 20, 1 },
+        { "EreadPdu", 19, 1 },
+        { "CreadPdu", 18, 1 },
+        { "TunnelPkt", 17, 1 },
+        { "RcfPeerFin", 16, 1 },
+        { "RcfReasonOut", 12, 4 },
+        { "TxCchannel", 10, 2 },
+        { "RcfTxChannel", 8, 2 },
+        { "RxEchannel", 6, 2 },
+        { "RcfRxChannel", 5, 1 },
+        { "RcfDataOutSrdy", 4, 1 },
+        { "RxDvld", 3, 1 },
+        { "RxOoDvld", 2, 1 },
+        { "RxCongestion", 1, 1 },
+        { "TxCongestion", 0, 1 },
+        { NULL }
+};
+
+static int tp_la_show(struct seq_file *seq, void *v, int idx)
+{
+        const u64 *p = v;
+
+        field_desc_show(seq, *p, tp_la0);
+        return 0;
+}
+
+static int tp_la_show2(struct seq_file *seq, void *v, int idx)
+{
+        const u64 *p = v;
+
+        if (idx)
+                seq_putc(seq, '\n');
+        field_desc_show(seq, p[0], tp_la0);
+        if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL)
+                field_desc_show(seq, p[1], tp_la0);
+        return 0;
+}
+
+static int tp_la_show3(struct seq_file *seq, void *v, int idx)
+{
+        static struct field_desc tp_la1[] = {
+                { "CplCmdIn", 56, 8 },
+                { "CplCmdOut", 48, 8 },
+                { "ESynOut", 47, 1 },
+                { "EAckOut", 46, 1 },
+                { "EFinOut", 45, 1 },
+                { "ERstOut", 44, 1 },
+                { "SynIn", 43, 1 },
+                { "AckIn", 42, 1 },
+                { "FinIn", 41, 1 },
+                { "RstIn", 40, 1 },
+                { "DataIn", 39, 1 },
+                { "DataInVld", 38, 1 },
+                { "PadIn", 37, 1 },
+                { "RxBufEmpty", 36, 1 },
+                { "RxDdp", 35, 1 },
+                { "RxFbCongestion", 34, 1 },
+                { "TxFbCongestion", 33, 1 },
+                { "TxPktSumSrdy", 32, 1 },
+                { "RcfUlpType", 28, 4 },
+                { "Eread", 27, 1 },
+                { "Ebypass", 26, 1 },
+                { "Esave", 25, 1 },
+                { "Static0", 24, 1 },
+                { "Cread", 23, 1 },
+                { "Cbypass", 22, 1 },
+                { "Csave", 21, 1 },
+                { "CPktOut", 20, 1 },
+                { "RxPagePoolFull", 18, 2 },
+                { "RxLpbkPkt", 17, 1 },
+                { "TxLpbkPkt", 16, 1 },
+                { "RxVfValid", 15, 1 },
+                { "SynLearned", 14, 1 },
+                { "SetDelEntry", 13, 1 },
+                { "SetInvEntry", 12, 1 },
+                { "CpcmdDvld", 11, 1 },
+                { "CpcmdSave", 10, 1 },
+                { "RxPstructsFull", 8, 2 },
+                { "EpcmdDvld", 7, 1 },
+                { "EpcmdFlush", 6, 1 },
+                { "EpcmdTrimPrefix", 5, 1 },
+                { "EpcmdTrimPostfix", 4, 1 },
+                { "ERssIp4Pkt", 3, 1 },
+                { "ERssIp6Pkt", 2, 1 },
+                { "ERssTcpUdpPkt", 1, 1 },
+                { "ERssFceFipPkt", 0, 1 },
+                { NULL }
+        };
+        static struct field_desc tp_la2[] = {
+                { "CplCmdIn", 56, 8 },
+                { "MpsVfVld", 55, 1 },
+                { "MpsPf", 52, 3 },
+                { "MpsVf", 44, 8 },
+                { "SynIn", 43, 1 },
+                { "AckIn", 42, 1 },
+                { "FinIn", 41, 1 },
+                { "RstIn", 40, 1 },
+                { "DataIn", 39, 1 },
+                { "DataInVld", 38, 1 },
+                { "PadIn", 37, 1 },
+                { "RxBufEmpty", 36, 1 },
+                { "RxDdp", 35, 1 },
+                { "RxFbCongestion", 34, 1 },
+                { "TxFbCongestion", 33, 1 },
+                { "TxPktSumSrdy", 32, 1 },
+                { "RcfUlpType", 28, 4 },
+                { "Eread", 27, 1 },
+                { "Ebypass", 26, 1 },
+                { "Esave", 25, 1 },
+                { "Static0", 24, 1 },
+                { "Cread", 23, 1 },
+                { "Cbypass", 22, 1 },
+                { "Csave", 21, 1 },
+                { "CPktOut", 20, 1 },
+                { "RxPagePoolFull", 18, 2 },
+                { "RxLpbkPkt", 17, 1 },
+                { "TxLpbkPkt", 16, 1 },
+                { "RxVfValid", 15, 1 },
+                { "SynLearned", 14, 1 },
+                { "SetDelEntry", 13, 1 },
+                { "SetInvEntry", 12, 1 },
+                { "CpcmdDvld", 11, 1 },
+                { "CpcmdSave", 10, 1 },
+                { "RxPstructsFull", 8, 2 },
+                { "EpcmdDvld", 7, 1 },
+                { "EpcmdFlush", 6, 1 },
+                { "EpcmdTrimPrefix", 5, 1 },
+                { "EpcmdTrimPostfix", 4, 1 },
+                { "ERssIp4Pkt", 3, 1 },
+                { "ERssIp6Pkt", 2, 1 },
+                { "ERssTcpUdpPkt", 1, 1 },
+                { "ERssFceFipPkt", 0, 1 },
+                { NULL }
+        };
+        const u64 *p = v;
+
+        if (idx)
+                seq_putc(seq, '\n');
+        field_desc_show(seq, p[0], tp_la0);
+        if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL)
+                field_desc_show(seq, p[1], (p[0] & BIT(17)) ? tp_la2 : tp_la1);
+        return 0;
+}
+
+static int tp_la_open(struct inode *inode, struct file *file)
+{
+        struct seq_tab *p;
+        struct adapter *adap = inode->i_private;
+
+        switch (DBGLAMODE_G(t4_read_reg(adap, TP_DBG_LA_CONFIG_A))) {
+        case 2:
+                p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0,
+                                 tp_la_show2);
+                break;
+        case 3:
+                p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0,
+                                 tp_la_show3);
+                break;
+        default:
+                p = seq_open_tab(file, TPLA_SIZE, sizeof(u64), 0, tp_la_show);
+        }
+        if (!p)
+                return -ENOMEM;
+
+        t4_tp_read_la(adap, (u64 *)p->data, NULL);
+        return 0;
+}
+
+static ssize_t tp_la_write(struct file *file, const char __user *buf,
+                           size_t count, loff_t *pos)
+{
+        int err;
+        char s[32];
+        unsigned long val;
+        size_t size = min(sizeof(s) - 1, count);
+        struct adapter *adap = FILE_DATA(file)->i_private;
+
+        if (copy_from_user(s, buf, size))
+                return -EFAULT;
+        s[size] = '\0';
+        err = kstrtoul(s, 0, &val);
+        if (err)
+                return err;
+        if (val > 0xffff)
+                return -EINVAL;
+        adap->params.tp.la_mask = val << 16;
+        t4_set_reg_field(adap, TP_DBG_LA_CONFIG_A, 0xffff0000U,
+                         adap->params.tp.la_mask);
+        return count;
+}
+
+static const struct file_operations tp_la_fops = {
+        .owner   = THIS_MODULE,
+        .open    = tp_la_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_private,
+        .write   = tp_la_write
+};
+
+static int ulprx_la_show(struct seq_file *seq, void *v, int idx)
+{
+        const u32 *p = v;
+
+        if (v == SEQ_START_TOKEN)
+                seq_puts(seq, "      Pcmd        Type   Message"
+                         "                Data\n");
+        else
+                seq_printf(seq, "%08x%08x  %4x  %08x  %08x%08x%08x%08x\n",
+                           p[1], p[0], p[2], p[3], p[7], p[6], p[5], p[4]);
+        return 0;
+}
+
+static int ulprx_la_open(struct inode *inode, struct file *file)
+{
+        struct seq_tab *p;
+        struct adapter *adap = inode->i_private;
+
+        p = seq_open_tab(file, ULPRX_LA_SIZE, 8 * sizeof(u32), 1,
+                         ulprx_la_show);
+        if (!p)
+                return -ENOMEM;
+
+        t4_ulprx_read_la(adap, (u32 *)p->data);
+        return 0;
+}
+
+static const struct file_operations ulprx_la_fops = {
+        .owner   = THIS_MODULE,
+        .open    = ulprx_la_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_private
+};
+
+/* Show the PM memory stats.  These stats include:
+ *
+ * TX:
+ *   Read: memory read operation
+ *   Write Bypass: cut-through
+ *   Bypass + mem: cut-through and save copy
+ *
+ * RX:
+ *   Read: memory read
+ *   Write Bypass: cut-through
+ *   Flush: payload trim or drop
+ */
+static int pm_stats_show(struct seq_file *seq, void *v)
+{
+        static const char * const tx_pm_stats[] = {
+                "Read:", "Write bypass:", "Write mem:", "Bypass + mem:"
+        };
+        static const char * const rx_pm_stats[] = {
+                "Read:", "Write bypass:", "Write mem:", "Flush:"
+        };
+
+        int i;
+        u32 tx_cnt[PM_NSTATS], rx_cnt[PM_NSTATS];
+        u64 tx_cyc[PM_NSTATS], rx_cyc[PM_NSTATS];
+        struct adapter *adap = seq->private;
+
+        t4_pmtx_get_stats(adap, tx_cnt, tx_cyc);
+        t4_pmrx_get_stats(adap, rx_cnt, rx_cyc);
+
+        seq_printf(seq, "%13s %10s  %20s\n", " ", "Tx pcmds", "Tx bytes");
+        for (i = 0; i < PM_NSTATS - 1; i++)
+                seq_printf(seq, "%-13s %10u  %20llu\n",
+                           tx_pm_stats[i], tx_cnt[i], tx_cyc[i]);
+
+        seq_printf(seq, "%13s %10s  %20s\n", " ", "Rx pcmds", "Rx bytes");
+        for (i = 0; i < PM_NSTATS - 1; i++)
+                seq_printf(seq, "%-13s %10u  %20llu\n",
+                           rx_pm_stats[i], rx_cnt[i], rx_cyc[i]);
+        return 0;
+}
+
+static int pm_stats_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, pm_stats_show, inode->i_private);
+}
+
+static ssize_t pm_stats_clear(struct file *file, const char __user *buf,
+                              size_t count, loff_t *pos)
+{
+        struct adapter *adap = FILE_DATA(file)->i_private;
+
+        t4_write_reg(adap, PM_RX_STAT_CONFIG_A, 0);
+        t4_write_reg(adap, PM_TX_STAT_CONFIG_A, 0);
+        return count;
+}
+
+static const struct file_operations pm_stats_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = pm_stats_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+        .write   = pm_stats_clear
+};
+
+static int cctrl_tbl_show(struct seq_file *seq, void *v)
+{
+        static const char * const dec_fac[] = {
+                "0.5", "0.5625", "0.625", "0.6875", "0.75", "0.8125", "0.875",
+                "0.9375" };
+
+        int i;
+        u16 incr[NMTUS][NCCTRL_WIN];
+        struct adapter *adap = seq->private;
+
+        t4_read_cong_tbl(adap, incr);
+
+        for (i = 0; i < NCCTRL_WIN; ++i) {
+                seq_printf(seq, "%2d: %4u %4u %4u %4u %4u %4u %4u %4u\n", i,
+                           incr[0][i], incr[1][i], incr[2][i], incr[3][i],
+                           incr[4][i], incr[5][i], incr[6][i], incr[7][i]);
+                seq_printf(seq, "%8u %4u %4u %4u %4u %4u %4u %4u %5u %s\n",
+                           incr[8][i], incr[9][i], incr[10][i], incr[11][i],
+                           incr[12][i], incr[13][i], incr[14][i], incr[15][i],
+                           adap->params.a_wnd[i],
+                           dec_fac[adap->params.b_wnd[i]]);
+        }
+        return 0;
+}
+
+DEFINE_SIMPLE_DEBUGFS_FILE(cctrl_tbl);
+
+/* Format a value in a unit that differs from the value's native unit by the
+ * given factor.
+ */
+static char *unit_conv(char *buf, size_t len, unsigned int val,
+                       unsigned int factor)
+{
+        unsigned int rem = val % factor;
+
+        if (rem == 0) {
+                snprintf(buf, len, "%u", val / factor);
+        } else {
+                while (rem % 10 == 0)
+                        rem /= 10;
+                snprintf(buf, len, "%u.%u", val / factor, rem);
+        }
+        return buf;
+}
+
+static int clk_show(struct seq_file *seq, void *v)
+{
+        char buf[32];
+        struct adapter *adap = seq->private;
+        unsigned int cclk_ps = 1000000000 / adap->params.vpd.cclk;  /* in ps */
+        u32 res = t4_read_reg(adap, TP_TIMER_RESOLUTION_A);
+        unsigned int tre = TIMERRESOLUTION_G(res);
+        unsigned int dack_re = DELAYEDACKRESOLUTION_G(res);
+        unsigned long long tp_tick_us = (cclk_ps << tre) / 1000000; /* in us */
+
+        seq_printf(seq, "Core clock period: %s ns\n",
+                   unit_conv(buf, sizeof(buf), cclk_ps, 1000));
+        seq_printf(seq, "TP timer tick: %s us\n",
+                   unit_conv(buf, sizeof(buf), (cclk_ps << tre), 1000000));
+        seq_printf(seq, "TCP timestamp tick: %s us\n",
+                   unit_conv(buf, sizeof(buf),
+                             (cclk_ps << TIMESTAMPRESOLUTION_G(res)), 1000000));
+        seq_printf(seq, "DACK tick: %s us\n",
+                   unit_conv(buf, sizeof(buf), (cclk_ps << dack_re), 1000000));
+        seq_printf(seq, "DACK timer: %u us\n",
+                   ((cclk_ps << dack_re) / 1000000) *
+                   t4_read_reg(adap, TP_DACK_TIMER_A));
+        seq_printf(seq, "Retransmit min: %llu us\n",
+                   tp_tick_us * t4_read_reg(adap, TP_RXT_MIN_A));
+        seq_printf(seq, "Retransmit max: %llu us\n",
+                   tp_tick_us * t4_read_reg(adap, TP_RXT_MAX_A));
+        seq_printf(seq, "Persist timer min: %llu us\n",
+                   tp_tick_us * t4_read_reg(adap, TP_PERS_MIN_A));
+        seq_printf(seq, "Persist timer max: %llu us\n",
+                   tp_tick_us * t4_read_reg(adap, TP_PERS_MAX_A));
+        seq_printf(seq, "Keepalive idle timer: %llu us\n",
+                   tp_tick_us * t4_read_reg(adap, TP_KEEP_IDLE_A));
+        seq_printf(seq, "Keepalive interval: %llu us\n",
+                   tp_tick_us * t4_read_reg(adap, TP_KEEP_INTVL_A));
+        seq_printf(seq, "Initial SRTT: %llu us\n",
+                   tp_tick_us * INITSRTT_G(t4_read_reg(adap, TP_INIT_SRTT_A)));
+        seq_printf(seq, "FINWAIT2 timer: %llu us\n",
+                   tp_tick_us * t4_read_reg(adap, TP_FINWAIT2_TIMER_A));
+
+        return 0;
+}
+
+DEFINE_SIMPLE_DEBUGFS_FILE(clk);
+
+/* Firmware Device Log dump. */
+static const char * const devlog_level_strings[] = {
+        [FW_DEVLOG_LEVEL_EMERG]         = "EMERG",
+        [FW_DEVLOG_LEVEL_CRIT]          = "CRIT",
+        [FW_DEVLOG_LEVEL_ERR]           = "ERR",
+        [FW_DEVLOG_LEVEL_NOTICE]        = "NOTICE",
+        [FW_DEVLOG_LEVEL_INFO]          = "INFO",
+        [FW_DEVLOG_LEVEL_DEBUG]         = "DEBUG"
+};
+
+static const char * const devlog_facility_strings[] = {
+        [FW_DEVLOG_FACILITY_CORE]       = "CORE",
+        [FW_DEVLOG_FACILITY_SCHED]      = "SCHED",
+        [FW_DEVLOG_FACILITY_TIMER]      = "TIMER",
+        [FW_DEVLOG_FACILITY_RES]        = "RES",
+        [FW_DEVLOG_FACILITY_HW]         = "HW",
+        [FW_DEVLOG_FACILITY_FLR]        = "FLR",
+        [FW_DEVLOG_FACILITY_DMAQ]       = "DMAQ",
+        [FW_DEVLOG_FACILITY_PHY]        = "PHY",
+        [FW_DEVLOG_FACILITY_MAC]        = "MAC",
+        [FW_DEVLOG_FACILITY_PORT]       = "PORT",
+        [FW_DEVLOG_FACILITY_VI]         = "VI",
+        [FW_DEVLOG_FACILITY_FILTER]     = "FILTER",
+        [FW_DEVLOG_FACILITY_ACL]        = "ACL",
+        [FW_DEVLOG_FACILITY_TM]         = "TM",
+        [FW_DEVLOG_FACILITY_QFC]        = "QFC",
+        [FW_DEVLOG_FACILITY_DCB]        = "DCB",
+        [FW_DEVLOG_FACILITY_ETH]        = "ETH",
+        [FW_DEVLOG_FACILITY_OFLD]       = "OFLD",
+        [FW_DEVLOG_FACILITY_RI]         = "RI",
+        [FW_DEVLOG_FACILITY_ISCSI]      = "ISCSI",
+        [FW_DEVLOG_FACILITY_FCOE]       = "FCOE",
+        [FW_DEVLOG_FACILITY_FOISCSI]    = "FOISCSI",
+        [FW_DEVLOG_FACILITY_FOFCOE]     = "FOFCOE"
+};
+
+/* Information gathered by Device Log Open routine for the display routine.
+ */
+struct devlog_info {
+        unsigned int nentries;          /* number of entries in log[] */
+        unsigned int first;             /* first [temporal] entry in log[] */
+        struct fw_devlog_e log[0];      /* Firmware Device Log */
+};
+
+/* Dump a Firmaware Device Log entry.
+ */
+static int devlog_show(struct seq_file *seq, void *v)
+{
+        if (v == SEQ_START_TOKEN)
+                seq_printf(seq, "%10s  %15s  %8s  %8s  %s\n",
+                           "Seq#", "Tstamp", "Level", "Facility", "Message");
+        else {
+                struct devlog_info *dinfo = seq->private;
+                int fidx = (uintptr_t)v - 2;
+                unsigned long index;
+                struct fw_devlog_e *e;
+
+                /* Get a pointer to the log entry to display.  Skip unused log
+                 * entries.
+                 */
+                index = dinfo->first + fidx;
+                if (index >= dinfo->nentries)
+                        index -= dinfo->nentries;
+                e = &dinfo->log[index];
+                if (e->timestamp == 0)
+                        return 0;
+
+                /* Print the message.  This depends on the firmware using
+                 * exactly the same formating strings as the kernel so we may
+                 * eventually have to put a format interpreter in here ...
+                 */
+                seq_printf(seq, "%10d  %15llu  %8s  %8s  ",
+                           e->seqno, e->timestamp,
+                           (e->level < ARRAY_SIZE(devlog_level_strings)
+                            ? devlog_level_strings[e->level]
+                            : "UNKNOWN"),
+                           (e->facility < ARRAY_SIZE(devlog_facility_strings)
+                            ? devlog_facility_strings[e->facility]
+                            : "UNKNOWN"));
+                seq_printf(seq, e->fmt, e->params[0], e->params[1],
+                           e->params[2], e->params[3], e->params[4],
+                           e->params[5], e->params[6], e->params[7]);
+        }
+        return 0;
+}
+
+/* Sequential File Operations for Device Log.
+ */
+static inline void *devlog_get_idx(struct devlog_info *dinfo, loff_t pos)
+{
+        if (pos > dinfo->nentries)
+                return NULL;
+
+        return (void *)(uintptr_t)(pos + 1);
+}
+
+static void *devlog_start(struct seq_file *seq, loff_t *pos)
+{
+        struct devlog_info *dinfo = seq->private;
+
+        return (*pos
+                ? devlog_get_idx(dinfo, *pos)
+                : SEQ_START_TOKEN);
+}
+
+static void *devlog_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+        struct devlog_info *dinfo = seq->private;
+
+        (*pos)++;
+        return devlog_get_idx(dinfo, *pos);
+}
+
+static void devlog_stop(struct seq_file *seq, void *v)
+{
+}
+
+static const struct seq_operations devlog_seq_ops = {
+        .start = devlog_start,
+        .next  = devlog_next,
+        .stop  = devlog_stop,
+        .show  = devlog_show
+};
+
+/* Set up for reading the firmware's device log.  We read the entire log here
+ * and then display it incrementally in devlog_show().
+ */
+static int devlog_open(struct inode *inode, struct file *file)
+{
+        struct adapter *adap = inode->i_private;
+        struct devlog_params *dparams = &adap->params.devlog;
+        struct devlog_info *dinfo;
+        unsigned int index;
+        u32 fseqno;
+        int ret;
+
+        /* If we don't know where the log is we can't do anything.
+         */
+        if (dparams->start == 0)
+                return -ENXIO;
+
+        /* Allocate the space to read in the firmware's device log and set up
+         * for the iterated call to our display function.
+         */
+        dinfo = __seq_open_private(file, &devlog_seq_ops,
+                                   sizeof(*dinfo) + dparams->size);
+        if (!dinfo)
+                return -ENOMEM;
+
+        /* Record the basic log buffer information and read in the raw log.
+         */
+        dinfo->nentries = (dparams->size / sizeof(struct fw_devlog_e));
+        dinfo->first = 0;
+        spin_lock(&adap->win0_lock);
+        ret = t4_memory_rw(adap, adap->params.drv_memwin, dparams->memtype,
+                           dparams->start, dparams->size, (__be32 *)dinfo->log,
+                           T4_MEMORY_READ);
+        spin_unlock(&adap->win0_lock);
+        if (ret) {
+                seq_release_private(inode, file);
+                return ret;
+        }
+
+        /* Translate log multi-byte integral elements into host native format
+         * and determine where the first entry in the log is.
+         */
+        for (fseqno = ~((u32)0), index = 0; index < dinfo->nentries; index++) {
+                struct fw_devlog_e *e = &dinfo->log[index];
+                int i;
+                __u32 seqno;
+
+                if (e->timestamp == 0)
+                        continue;
+
+                e->timestamp = (__force __be64)be64_to_cpu(e->timestamp);
+                seqno = be32_to_cpu(e->seqno);
+                for (i = 0; i < 8; i++)
+                        e->params[i] =
+                                (__force __be32)be32_to_cpu(e->params[i]);
+
+                if (seqno < fseqno) {
+                        fseqno = seqno;
+                        dinfo->first = index;
+                }
+        }
+        return 0;
+}
+
+static const struct file_operations devlog_fops = {
+        .owner   = THIS_MODULE,
+        .open    = devlog_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_private
+};
+
+static int mbox_show(struct seq_file *seq, void *v)
+{
+        static const char * const owner[] = { "none", "FW", "driver",
+                                              "unknown" };
+
+        int i;
+        unsigned int mbox = (uintptr_t)seq->private & 7;
+        struct adapter *adap = seq->private - mbox;
+        void __iomem *addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
+        unsigned int ctrl_reg = (is_t4(adap->params.chip)
+                                 ? CIM_PF_MAILBOX_CTRL_A
+                                 : CIM_PF_MAILBOX_CTRL_SHADOW_COPY_A);
+        void __iomem *ctrl = adap->regs + PF_REG(mbox, ctrl_reg);
+
+        i = MBOWNER_G(readl(ctrl));
+        seq_printf(seq, "mailbox owned by %s\n\n", owner[i]);
+
+        for (i = 0; i < MBOX_LEN; i += 8)
+                seq_printf(seq, "%016llx\n",
+                           (unsigned long long)readq(addr + i));
+        return 0;
+}
+
+static int mbox_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, mbox_show, inode->i_private);
+}
+
+static ssize_t mbox_write(struct file *file, const char __user *buf,
+                          size_t count, loff_t *pos)
+{
+        int i;
+        char c = '\n', s[256];
+        unsigned long long data[8];
+        const struct inode *ino;
+        unsigned int mbox;
+        struct adapter *adap;
+        void __iomem *addr;
+        void __iomem *ctrl;
+
+        if (count > sizeof(s) - 1 || !count)
+                return -EINVAL;
+        if (copy_from_user(s, buf, count))
+                return -EFAULT;
+        s[count] = '\0';
+
+        if (sscanf(s, "%llx %llx %llx %llx %llx %llx %llx %llx%c", &data[0],
+                   &data[1], &data[2], &data[3], &data[4], &data[5], &data[6],
+                   &data[7], &c) < 8 || c != '\n')
+                return -EINVAL;
+
+        ino = FILE_DATA(file);
+        mbox = (uintptr_t)ino->i_private & 7;
+        adap = ino->i_private - mbox;
+        addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
+        ctrl = addr + MBOX_LEN;
+
+        if (MBOWNER_G(readl(ctrl)) != X_MBOWNER_PL)
+                return -EBUSY;
+
+        for (i = 0; i < 8; i++)
+                writeq(data[i], addr + 8 * i);
+
+        writel(MBMSGVALID_F | MBOWNER_V(X_MBOWNER_FW), ctrl);
+        return count;
+}
+
+static const struct file_operations mbox_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = mbox_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+        .write   = mbox_write
+};
+
+static ssize_t flash_read(struct file *file, char __user *buf, size_t count,
+                          loff_t *ppos)
+{
+        loff_t pos = *ppos;
+        loff_t avail = FILE_DATA(file)->i_size;
+        struct adapter *adap = file->private_data;
+
+        if (pos < 0)
+                return -EINVAL;
+        if (pos >= avail)
+                return 0;
+        if (count > avail - pos)
+                count = avail - pos;
+
+        while (count) {
+                size_t len;
+                int ret, ofst;
+                u8 data[256];
+
+                ofst = pos & 3;
+                len = min(count + ofst, sizeof(data));
+                ret = t4_read_flash(adap, pos - ofst, (len + 3) / 4,
+                                    (u32 *)data, 1);
+                if (ret)
+                        return ret;
+
+                len -= ofst;
+                if (copy_to_user(buf, data + ofst, len))
+                        return -EFAULT;
+
+                buf += len;
+                pos += len;
+                count -= len;
+        }
+        count = pos - *ppos;
+        *ppos = pos;
+        return count;
+}
+
+static const struct file_operations flash_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = mem_open,
+        .read    = flash_read,
+};
+
+static inline void tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask)
+{
+        *mask = x | y;
+        y = (__force u64)cpu_to_be64(y);
+        memcpy(addr, (char *)&y + 2, ETH_ALEN);
+}
+
+static int mps_tcam_show(struct seq_file *seq, void *v)
+{
+        if (v == SEQ_START_TOKEN)
+                seq_puts(seq, "Idx  Ethernet address     Mask     Vld Ports PF"
+                         "  VF              Replication             "
+                         "P0 P1 P2 P3  ML\n");
+        else {
+                u64 mask;
+                u8 addr[ETH_ALEN];
+                struct adapter *adap = seq->private;
+                unsigned int idx = (uintptr_t)v - 2;
+                u64 tcamy = t4_read_reg64(adap, MPS_CLS_TCAM_Y_L(idx));
+                u64 tcamx = t4_read_reg64(adap, MPS_CLS_TCAM_X_L(idx));
+                u32 cls_lo = t4_read_reg(adap, MPS_CLS_SRAM_L(idx));
+                u32 cls_hi = t4_read_reg(adap, MPS_CLS_SRAM_H(idx));
+                u32 rplc[4] = {0, 0, 0, 0};
+
+                if (tcamx & tcamy) {
+                        seq_printf(seq, "%3u         -\n", idx);
+                        goto out;
+                }
+
+                if (cls_lo & REPLICATE_F) {
+                        struct fw_ldst_cmd ldst_cmd;
+                        int ret;
+
+                        memset(&ldst_cmd, 0, sizeof(ldst_cmd));
+                        ldst_cmd.op_to_addrspace =
+                                htonl(FW_CMD_OP_V(FW_LDST_CMD) |
+                                      FW_CMD_REQUEST_F |
+                                      FW_CMD_READ_F |
+                                      FW_LDST_CMD_ADDRSPACE_V(
+                                              FW_LDST_ADDRSPC_MPS));
+                        ldst_cmd.cycles_to_len16 = htonl(FW_LEN16(ldst_cmd));
+                        ldst_cmd.u.mps.fid_ctl =
+                                htons(FW_LDST_CMD_FID_V(FW_LDST_MPS_RPLC) |
+                                      FW_LDST_CMD_CTL_V(idx));
+                        ret = t4_wr_mbox(adap, adap->mbox, &ldst_cmd,
+                                         sizeof(ldst_cmd), &ldst_cmd);
+                        if (ret)
+                                dev_warn(adap->pdev_dev, "Can't read MPS "
+                                         "replication map for idx %d: %d\n",
+                                         idx, -ret);
+                        else {
+                                rplc[0] = ntohl(ldst_cmd.u.mps.rplc31_0);
+                                rplc[1] = ntohl(ldst_cmd.u.mps.rplc63_32);
+                                rplc[2] = ntohl(ldst_cmd.u.mps.rplc95_64);
+                                rplc[3] = ntohl(ldst_cmd.u.mps.rplc127_96);
+                        }
+                }
+
+                tcamxy2valmask(tcamx, tcamy, addr, &mask);
+                seq_printf(seq, "%3u %02x:%02x:%02x:%02x:%02x:%02x %012llx"
+                           "%3c   %#x%4u%4d",
+                           idx, addr[0], addr[1], addr[2], addr[3], addr[4],
+                           addr[5], (unsigned long long)mask,
+                           (cls_lo & SRAM_VLD_F) ? 'Y' : 'N', PORTMAP_G(cls_hi),
+                           PF_G(cls_lo),
+                           (cls_lo & VF_VALID_F) ? VF_G(cls_lo) : -1);
+                if (cls_lo & REPLICATE_F)
+                        seq_printf(seq, " %08x %08x %08x %08x",
+                                   rplc[3], rplc[2], rplc[1], rplc[0]);
+                else
+                        seq_printf(seq, "%36c", ' ');
+                seq_printf(seq, "%4u%3u%3u%3u %#x\n",
+                           SRAM_PRIO0_G(cls_lo), SRAM_PRIO1_G(cls_lo),
+                           SRAM_PRIO2_G(cls_lo), SRAM_PRIO3_G(cls_lo),
+                           (cls_lo >> MULTILISTEN0_S) & 0xf);
+        }
+out:    return 0;
+}
+
+static inline void *mps_tcam_get_idx(struct seq_file *seq, loff_t pos)
+{
+        struct adapter *adap = seq->private;
+        int max_mac_addr = is_t4(adap->params.chip) ?
+                                NUM_MPS_CLS_SRAM_L_INSTANCES :
+                                NUM_MPS_T5_CLS_SRAM_L_INSTANCES;
+        return ((pos <= max_mac_addr) ? (void *)(uintptr_t)(pos + 1) : NULL);
+}
+
+static void *mps_tcam_start(struct seq_file *seq, loff_t *pos)
+{
+        return *pos ? mps_tcam_get_idx(seq, *pos) : SEQ_START_TOKEN;
+}
+
+static void *mps_tcam_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+        ++*pos;
+        return mps_tcam_get_idx(seq, *pos);
+}
+
+static void mps_tcam_stop(struct seq_file *seq, void *v)
+{
+}
+
+static const struct seq_operations mps_tcam_seq_ops = {
+        .start = mps_tcam_start,
+        .next  = mps_tcam_next,
+        .stop  = mps_tcam_stop,
+        .show  = mps_tcam_show
+};
+
+static int mps_tcam_open(struct inode *inode, struct file *file)
+{
+        int res = seq_open(file, &mps_tcam_seq_ops);
+
+        if (!res) {
+                struct seq_file *seq = file->private_data;
+
+                seq->private = inode->i_private;
+        }
+        return res;
+}
+
+static const struct file_operations mps_tcam_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = mps_tcam_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release,
+};
+
+/* Display various sensor information.
+ */
+static int sensors_show(struct seq_file *seq, void *v)
+{
+        struct adapter *adap = seq->private;
+        u32 param[7], val[7];
+        int ret;
+
+        /* Note that if the sensors haven't been initialized and turned on
+         * we'll get values of 0, so treat those as "<unknown>" ...
+         */
+        param[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
+                    FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) |
+                    FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_TMP));
+        param[1] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
+                    FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) |
+                    FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_VDD));
+        ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 2,
+                              param, val);
+
+        if (ret < 0 || val[0] == 0)
+                seq_puts(seq, "Temperature: <unknown>\n");
+        else
+                seq_printf(seq, "Temperature: %dC\n", val[0]);
+
+        if (ret < 0 || val[1] == 0)
+                seq_puts(seq, "Core VDD:    <unknown>\n");
+        else
+                seq_printf(seq, "Core VDD:    %dmV\n", val[1]);
+
+        return 0;
+}
+
+DEFINE_SIMPLE_DEBUGFS_FILE(sensors);
+
+#if IS_ENABLED(CONFIG_IPV6)
+static int clip_tbl_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, clip_tbl_show, inode->i_private);
+}
+
+static const struct file_operations clip_tbl_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = clip_tbl_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release
+};
+#endif
+
+/*RSS Table.
+ */
+
+static int rss_show(struct seq_file *seq, void *v, int idx)
+{
+        u16 *entry = v;
+
+        seq_printf(seq, "%4d:  %4u  %4u  %4u  %4u  %4u  %4u  %4u  %4u\n",
+                   idx * 8, entry[0], entry[1], entry[2], entry[3], entry[4],
+                   entry[5], entry[6], entry[7]);
+        return 0;
+}
+
+static int rss_open(struct inode *inode, struct file *file)
+{
+        int ret;
+        struct seq_tab *p;
+        struct adapter *adap = inode->i_private;
+
+        p = seq_open_tab(file, RSS_NENTRIES / 8, 8 * sizeof(u16), 0, rss_show);
+        if (!p)
+                return -ENOMEM;
+
+        ret = t4_read_rss(adap, (u16 *)p->data);
+        if (ret)
+                seq_release_private(inode, file);
+
+        return ret;
+}
+
+static const struct file_operations rss_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = rss_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_private
+};
+
+/* RSS Configuration.
+ */
+
+/* Small utility function to return the strings "yes" or "no" if the supplied
+ * argument is non-zero.
+ */
+static const char *yesno(int x)
+{
+        static const char *yes = "yes";
+        static const char *no = "no";
+
+        return x ? yes : no;
+}
+
+static int rss_config_show(struct seq_file *seq, void *v)
+{
+        struct adapter *adapter = seq->private;
+        static const char * const keymode[] = {
+                "global",
+                "global and per-VF scramble",
+                "per-PF and per-VF scramble",
+                "per-VF and per-VF scramble",
+        };
+        u32 rssconf;
+
+        rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_A);
+        seq_printf(seq, "TP_RSS_CONFIG: %#x\n", rssconf);
+        seq_printf(seq, "  Tnl4TupEnIpv6: %3s\n", yesno(rssconf &
+                                                        TNL4TUPENIPV6_F));
+        seq_printf(seq, "  Tnl2TupEnIpv6: %3s\n", yesno(rssconf &
+                                                        TNL2TUPENIPV6_F));
+        seq_printf(seq, "  Tnl4TupEnIpv4: %3s\n", yesno(rssconf &
+                                                        TNL4TUPENIPV4_F));
+        seq_printf(seq, "  Tnl2TupEnIpv4: %3s\n", yesno(rssconf &
+                                                        TNL2TUPENIPV4_F));
+        seq_printf(seq, "  TnlTcpSel:     %3s\n", yesno(rssconf & TNLTCPSEL_F));
+        seq_printf(seq, "  TnlIp6Sel:     %3s\n", yesno(rssconf & TNLIP6SEL_F));
+        seq_printf(seq, "  TnlVrtSel:     %3s\n", yesno(rssconf & TNLVRTSEL_F));
+        seq_printf(seq, "  TnlMapEn:      %3s\n", yesno(rssconf & TNLMAPEN_F));
+        seq_printf(seq, "  OfdHashSave:   %3s\n", yesno(rssconf &
+                                                        OFDHASHSAVE_F));
+        seq_printf(seq, "  OfdVrtSel:     %3s\n", yesno(rssconf & OFDVRTSEL_F));
+        seq_printf(seq, "  OfdMapEn:      %3s\n", yesno(rssconf & OFDMAPEN_F));
+        seq_printf(seq, "  OfdLkpEn:      %3s\n", yesno(rssconf & OFDLKPEN_F));
+        seq_printf(seq, "  Syn4TupEnIpv6: %3s\n", yesno(rssconf &
+                                                        SYN4TUPENIPV6_F));
+        seq_printf(seq, "  Syn2TupEnIpv6: %3s\n", yesno(rssconf &
+                                                        SYN2TUPENIPV6_F));
+        seq_printf(seq, "  Syn4TupEnIpv4: %3s\n", yesno(rssconf &
+                                                        SYN4TUPENIPV4_F));
+        seq_printf(seq, "  Syn2TupEnIpv4: %3s\n", yesno(rssconf &
+                                                        SYN2TUPENIPV4_F));
+        seq_printf(seq, "  Syn4TupEnIpv6: %3s\n", yesno(rssconf &
+                                                        SYN4TUPENIPV6_F));
+        seq_printf(seq, "  SynIp6Sel:     %3s\n", yesno(rssconf & SYNIP6SEL_F));
+        seq_printf(seq, "  SynVrt6Sel:    %3s\n", yesno(rssconf & SYNVRTSEL_F));
+        seq_printf(seq, "  SynMapEn:      %3s\n", yesno(rssconf & SYNMAPEN_F));
+        seq_printf(seq, "  SynLkpEn:      %3s\n", yesno(rssconf & SYNLKPEN_F));
+        seq_printf(seq, "  ChnEn:         %3s\n", yesno(rssconf &
+                                                        CHANNELENABLE_F));
+        seq_printf(seq, "  PrtEn:         %3s\n", yesno(rssconf &
+                                                        PORTENABLE_F));
+        seq_printf(seq, "  TnlAllLkp:     %3s\n", yesno(rssconf &
+                                                        TNLALLLOOKUP_F));
+        seq_printf(seq, "  VrtEn:         %3s\n", yesno(rssconf &
+                                                        VIRTENABLE_F));
+        seq_printf(seq, "  CngEn:         %3s\n", yesno(rssconf &
+                                                        CONGESTIONENABLE_F));
+        seq_printf(seq, "  HashToeplitz:  %3s\n", yesno(rssconf &
+                                                        HASHTOEPLITZ_F));
+        seq_printf(seq, "  Udp4En:        %3s\n", yesno(rssconf & UDPENABLE_F));
+        seq_printf(seq, "  Disable:       %3s\n", yesno(rssconf & DISABLE_F));
+
+        seq_puts(seq, "\n");
+
+        rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_TNL_A);
+        seq_printf(seq, "TP_RSS_CONFIG_TNL: %#x\n", rssconf);
+        seq_printf(seq, "  MaskSize:      %3d\n", MASKSIZE_G(rssconf));
+        seq_printf(seq, "  MaskFilter:    %3d\n", MASKFILTER_G(rssconf));
+        if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) {
+                seq_printf(seq, "  HashAll:     %3s\n",
+                           yesno(rssconf & HASHALL_F));
+                seq_printf(seq, "  HashEth:     %3s\n",
+                           yesno(rssconf & HASHETH_F));
+        }
+        seq_printf(seq, "  UseWireCh:     %3s\n", yesno(rssconf & USEWIRECH_F));
+
+        seq_puts(seq, "\n");
+
+        rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_OFD_A);
+        seq_printf(seq, "TP_RSS_CONFIG_OFD: %#x\n", rssconf);
+        seq_printf(seq, "  MaskSize:      %3d\n", MASKSIZE_G(rssconf));
+        seq_printf(seq, "  RRCplMapEn:    %3s\n", yesno(rssconf &
+                                                        RRCPLMAPEN_F));
+        seq_printf(seq, "  RRCplQueWidth: %3d\n", RRCPLQUEWIDTH_G(rssconf));
+
+        seq_puts(seq, "\n");
+
+        rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_SYN_A);
+        seq_printf(seq, "TP_RSS_CONFIG_SYN: %#x\n", rssconf);
+        seq_printf(seq, "  MaskSize:      %3d\n", MASKSIZE_G(rssconf));
+        seq_printf(seq, "  UseWireCh:     %3s\n", yesno(rssconf & USEWIRECH_F));
+
+        seq_puts(seq, "\n");
+
+        rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A);
+        seq_printf(seq, "TP_RSS_CONFIG_VRT: %#x\n", rssconf);
+        if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) {
+                seq_printf(seq, "  KeyWrAddrX:     %3d\n",
+                           KEYWRADDRX_G(rssconf));
+                seq_printf(seq, "  KeyExtend:      %3s\n",
+                           yesno(rssconf & KEYEXTEND_F));
+        }
+        seq_printf(seq, "  VfRdRg:        %3s\n", yesno(rssconf & VFRDRG_F));
+        seq_printf(seq, "  VfRdEn:        %3s\n", yesno(rssconf & VFRDEN_F));
+        seq_printf(seq, "  VfPerrEn:      %3s\n", yesno(rssconf & VFPERREN_F));
+        seq_printf(seq, "  KeyPerrEn:     %3s\n", yesno(rssconf & KEYPERREN_F));
+        seq_printf(seq, "  DisVfVlan:     %3s\n", yesno(rssconf &
+                                                        DISABLEVLAN_F));
+        seq_printf(seq, "  EnUpSwt:       %3s\n", yesno(rssconf & ENABLEUP0_F));
+        seq_printf(seq, "  HashDelay:     %3d\n", HASHDELAY_G(rssconf));
+        if (CHELSIO_CHIP_VERSION(adapter->params.chip) <= CHELSIO_T5)
+                seq_printf(seq, "  VfWrAddr:      %3d\n", VFWRADDR_G(rssconf));
+        seq_printf(seq, "  KeyMode:       %s\n", keymode[KEYMODE_G(rssconf)]);
+        seq_printf(seq, "  VfWrEn:        %3s\n", yesno(rssconf & VFWREN_F));
+        seq_printf(seq, "  KeyWrEn:       %3s\n", yesno(rssconf & KEYWREN_F));
+        seq_printf(seq, "  KeyWrAddr:     %3d\n", KEYWRADDR_G(rssconf));
+
+        seq_puts(seq, "\n");
+
+        rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_CNG_A);
+        seq_printf(seq, "TP_RSS_CONFIG_CNG: %#x\n", rssconf);
+        seq_printf(seq, "  ChnCount3:     %3s\n", yesno(rssconf & CHNCOUNT3_F));
+        seq_printf(seq, "  ChnCount2:     %3s\n", yesno(rssconf & CHNCOUNT2_F));
+        seq_printf(seq, "  ChnCount1:     %3s\n", yesno(rssconf & CHNCOUNT1_F));
+        seq_printf(seq, "  ChnCount0:     %3s\n", yesno(rssconf & CHNCOUNT0_F));
+        seq_printf(seq, "  ChnUndFlow3:   %3s\n", yesno(rssconf &
+                                                        CHNUNDFLOW3_F));
+        seq_printf(seq, "  ChnUndFlow2:   %3s\n", yesno(rssconf &
+                                                        CHNUNDFLOW2_F));
+        seq_printf(seq, "  ChnUndFlow1:   %3s\n", yesno(rssconf &
+                                                        CHNUNDFLOW1_F));
+        seq_printf(seq, "  ChnUndFlow0:   %3s\n", yesno(rssconf &
+                                                        CHNUNDFLOW0_F));
+        seq_printf(seq, "  RstChn3:       %3s\n", yesno(rssconf & RSTCHN3_F));
+        seq_printf(seq, "  RstChn2:       %3s\n", yesno(rssconf & RSTCHN2_F));
+        seq_printf(seq, "  RstChn1:       %3s\n", yesno(rssconf & RSTCHN1_F));
+        seq_printf(seq, "  RstChn0:       %3s\n", yesno(rssconf & RSTCHN0_F));
+        seq_printf(seq, "  UpdVld:        %3s\n", yesno(rssconf & UPDVLD_F));
+        seq_printf(seq, "  Xoff:          %3s\n", yesno(rssconf & XOFF_F));
+        seq_printf(seq, "  UpdChn3:       %3s\n", yesno(rssconf & UPDCHN3_F));
+        seq_printf(seq, "  UpdChn2:       %3s\n", yesno(rssconf & UPDCHN2_F));
+        seq_printf(seq, "  UpdChn1:       %3s\n", yesno(rssconf & UPDCHN1_F));
+        seq_printf(seq, "  UpdChn0:       %3s\n", yesno(rssconf & UPDCHN0_F));
+        seq_printf(seq, "  Queue:         %3d\n", QUEUE_G(rssconf));
+
+        return 0;
+}
+
+DEFINE_SIMPLE_DEBUGFS_FILE(rss_config);
+
+/* RSS Secret Key.
+ */
+
+static int rss_key_show(struct seq_file *seq, void *v)
+{
+        u32 key[10];
+
+        t4_read_rss_key(seq->private, key);
+        seq_printf(seq, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n",
+                   key[9], key[8], key[7], key[6], key[5], key[4], key[3],
+                   key[2], key[1], key[0]);
+        return 0;
+}
+
+static int rss_key_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, rss_key_show, inode->i_private);
+}
+
+static ssize_t rss_key_write(struct file *file, const char __user *buf,
+                             size_t count, loff_t *pos)
+{
+        int i, j;
+        u32 key[10];
+        char s[100], *p;
+        struct adapter *adap = FILE_DATA(file)->i_private;
+
+        if (count > sizeof(s) - 1)
+                return -EINVAL;
+        if (copy_from_user(s, buf, count))
+                return -EFAULT;
+        for (i = count; i > 0 && isspace(s[i - 1]); i--)
+                ;
+        s[i] = '\0';
+
+        for (p = s, i = 9; i >= 0; i--) {
+                key[i] = 0;
+                for (j = 0; j < 8; j++, p++) {
+                        if (!isxdigit(*p))
+                                return -EINVAL;
+                        key[i] = (key[i] << 4) | hex2val(*p);
+                }
+        }
+
+        t4_write_rss_key(adap, key, -1);
+        return count;
+}
+
+static const struct file_operations rss_key_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = rss_key_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+        .write   = rss_key_write
+};
+
+/* PF RSS Configuration.
+ */
+
+struct rss_pf_conf {
+        u32 rss_pf_map;
+        u32 rss_pf_mask;
+        u32 rss_pf_config;
+};
+
+static int rss_pf_config_show(struct seq_file *seq, void *v, int idx)
+{
+        struct rss_pf_conf *pfconf;
+
+        if (v == SEQ_START_TOKEN) {
+                /* use the 0th entry to dump the PF Map Index Size */
+                pfconf = seq->private + offsetof(struct seq_tab, data);
+                seq_printf(seq, "PF Map Index Size = %d\n\n",
+                           LKPIDXSIZE_G(pfconf->rss_pf_map));
+
+                seq_puts(seq, "     RSS              PF   VF    Hash Tuple Enable         Default\n");
+                seq_puts(seq, "     Enable       IPF Mask Mask  IPv6      IPv4      UDP   Queue\n");
+                seq_puts(seq, " PF  Map Chn Prt  Map Size Size  Four Two  Four Two  Four  Ch1  Ch0\n");
+        } else {
+                #define G_PFnLKPIDX(map, n) \
+                        (((map) >> PF1LKPIDX_S*(n)) & PF0LKPIDX_M)
+                #define G_PFnMSKSIZE(mask, n) \
+                        (((mask) >> PF1MSKSIZE_S*(n)) & PF1MSKSIZE_M)
+
+                pfconf = v;
+                seq_printf(seq, "%3d  %3s %3s %3s  %3d  %3d  %3d   %3s %3s   %3s %3s   %3s  %3d  %3d\n",
+                           idx,
+                           yesno(pfconf->rss_pf_config & MAPENABLE_F),
+                           yesno(pfconf->rss_pf_config & CHNENABLE_F),
+                           yesno(pfconf->rss_pf_config & PRTENABLE_F),
+                           G_PFnLKPIDX(pfconf->rss_pf_map, idx),
+                           G_PFnMSKSIZE(pfconf->rss_pf_mask, idx),
+                           IVFWIDTH_G(pfconf->rss_pf_config),
+                           yesno(pfconf->rss_pf_config & IP6FOURTUPEN_F),
+                           yesno(pfconf->rss_pf_config & IP6TWOTUPEN_F),
+                           yesno(pfconf->rss_pf_config & IP4FOURTUPEN_F),
+                           yesno(pfconf->rss_pf_config & IP4TWOTUPEN_F),
+                           yesno(pfconf->rss_pf_config & UDPFOURTUPEN_F),
+                           CH1DEFAULTQUEUE_G(pfconf->rss_pf_config),
+                           CH0DEFAULTQUEUE_G(pfconf->rss_pf_config));
+
+                #undef G_PFnLKPIDX
+                #undef G_PFnMSKSIZE
+        }
+        return 0;
+}
+
+static int rss_pf_config_open(struct inode *inode, struct file *file)
+{
+        struct adapter *adapter = inode->i_private;
+        struct seq_tab *p;
+        u32 rss_pf_map, rss_pf_mask;
+        struct rss_pf_conf *pfconf;
+        int pf;
+
+        p = seq_open_tab(file, 8, sizeof(*pfconf), 1, rss_pf_config_show);
+        if (!p)
+                return -ENOMEM;
+
+        pfconf = (struct rss_pf_conf *)p->data;
+        rss_pf_map = t4_read_rss_pf_map(adapter);
+        rss_pf_mask = t4_read_rss_pf_mask(adapter);
+        for (pf = 0; pf < 8; pf++) {
+                pfconf[pf].rss_pf_map = rss_pf_map;
+                pfconf[pf].rss_pf_mask = rss_pf_mask;
+                t4_read_rss_pf_config(adapter, pf, &pfconf[pf].rss_pf_config);
+        }
+        return 0;
+}
+
+static const struct file_operations rss_pf_config_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = rss_pf_config_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_private
+};
+
+/* VF RSS Configuration.
+ */
+
+struct rss_vf_conf {
+        u32 rss_vf_vfl;
+        u32 rss_vf_vfh;
+};
+
+static int rss_vf_config_show(struct seq_file *seq, void *v, int idx)
+{
+        if (v == SEQ_START_TOKEN) {
+                seq_puts(seq, "     RSS                     Hash Tuple Enable\n");
+                seq_puts(seq, "     Enable   IVF  Dis  Enb  IPv6      IPv4      UDP    Def  Secret Key\n");
+                seq_puts(seq, " VF  Chn Prt  Map  VLAN  uP  Four Two  Four Two  Four   Que  Idx       Hash\n");
+        } else {
+                struct rss_vf_conf *vfconf = v;
+
+                seq_printf(seq, "%3d  %3s %3s  %3d   %3s %3s   %3s %3s   %3s  %3s   %3s  %4d  %3d %#10x\n",
+                           idx,
+                           yesno(vfconf->rss_vf_vfh & VFCHNEN_F),
+                           yesno(vfconf->rss_vf_vfh & VFPRTEN_F),
+                           VFLKPIDX_G(vfconf->rss_vf_vfh),
+                           yesno(vfconf->rss_vf_vfh & VFVLNEX_F),
+                           yesno(vfconf->rss_vf_vfh & VFUPEN_F),
+                           yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F),
+                           yesno(vfconf->rss_vf_vfh & VFIP6TWOTUPEN_F),
+                           yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F),
+                           yesno(vfconf->rss_vf_vfh & VFIP4TWOTUPEN_F),
+                           yesno(vfconf->rss_vf_vfh & ENABLEUDPHASH_F),
+                           DEFAULTQUEUE_G(vfconf->rss_vf_vfh),
+                           KEYINDEX_G(vfconf->rss_vf_vfh),
+                           vfconf->rss_vf_vfl);
+        }
+        return 0;
+}
+
+static int rss_vf_config_open(struct inode *inode, struct file *file)
+{
+        struct adapter *adapter = inode->i_private;
+        struct seq_tab *p;
+        struct rss_vf_conf *vfconf;
+        int vf;
+
+        p = seq_open_tab(file, 128, sizeof(*vfconf), 1, rss_vf_config_show);
+        if (!p)
+                return -ENOMEM;
+
+        vfconf = (struct rss_vf_conf *)p->data;
+        for (vf = 0; vf < 128; vf++) {
+                t4_read_rss_vf_config(adapter, vf, &vfconf[vf].rss_vf_vfl,
+                                      &vfconf[vf].rss_vf_vfh);
+        }
+        return 0;
+}
+
+static const struct file_operations rss_vf_config_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = rss_vf_config_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_private
+};
+
+/**
+ * ethqset2pinfo - return port_info of an Ethernet Queue Set
+ * @adap: the adapter
+ * @qset: Ethernet Queue Set
+ */
+static inline struct port_info *ethqset2pinfo(struct adapter *adap, int qset)
+{
+        int pidx;
+
+        for_each_port(adap, pidx) {
+                struct port_info *pi = adap2pinfo(adap, pidx);
+
+                if (qset >= pi->first_qset &&
+                    qset < pi->first_qset + pi->nqsets)
+                        return pi;
+        }
+
+        /* should never happen! */
+        BUG_ON(1);
+        return NULL;
+}
+
+static int sge_qinfo_show(struct seq_file *seq, void *v)
+{
+        struct adapter *adap = seq->private;
+        int eth_entries = DIV_ROUND_UP(adap->sge.ethqsets, 4);
+        int toe_entries = DIV_ROUND_UP(adap->sge.ofldqsets, 4);
+        int rdma_entries = DIV_ROUND_UP(adap->sge.rdmaqs, 4);
+        int ciq_entries = DIV_ROUND_UP(adap->sge.rdmaciqs, 4);
+        int ctrl_entries = DIV_ROUND_UP(MAX_CTRL_QUEUES, 4);
+        int i, r = (uintptr_t)v - 1;
+        int toe_idx = r - eth_entries;
+        int rdma_idx = toe_idx - toe_entries;
+        int ciq_idx = rdma_idx - rdma_entries;
+        int ctrl_idx =  ciq_idx - ciq_entries;
+        int fq_idx =  ctrl_idx - ctrl_entries;
+
+        if (r)
+                seq_putc(seq, '\n');
+
+#define S3(fmt_spec, s, v) \
+do { \
+        seq_printf(seq, "%-12s", s); \
+        for (i = 0; i < n; ++i) \
+                seq_printf(seq, " %16" fmt_spec, v); \
+                seq_putc(seq, '\n'); \
+} while (0)
+#define S(s, v) S3("s", s, v)
+#define T(s, v) S3("u", s, tx[i].v)
+#define R(s, v) S3("u", s, rx[i].v)
+
+        if (r < eth_entries) {
+                int base_qset = r * 4;
+                const struct sge_eth_rxq *rx = &adap->sge.ethrxq[base_qset];
+                const struct sge_eth_txq *tx = &adap->sge.ethtxq[base_qset];
+                int n = min(4, adap->sge.ethqsets - 4 * r);
+
+                S("QType:", "Ethernet");
+                S("Interface:",
+                  rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A");
+                T("TxQ ID:", q.cntxt_id);
+                T("TxQ size:", q.size);
+                T("TxQ inuse:", q.in_use);
+                T("TxQ CIDX:", q.cidx);
+                T("TxQ PIDX:", q.pidx);
+#ifdef CONFIG_CHELSIO_T4_DCB
+                T("DCB Prio:", dcb_prio);
+                S3("u", "DCB PGID:",
+                   (ethqset2pinfo(adap, base_qset + i)->dcb.pgid >>
+                    4*(7-tx[i].dcb_prio)) & 0xf);
+                S3("u", "DCB PFC:",
+                   (ethqset2pinfo(adap, base_qset + i)->dcb.pfcen >>
+                    1*(7-tx[i].dcb_prio)) & 0x1);
+#endif
+                R("RspQ ID:", rspq.abs_id);
+                R("RspQ size:", rspq.size);
+                R("RspQE size:", rspq.iqe_len);
+                R("RspQ CIDX:", rspq.cidx);
+                R("RspQ Gen:", rspq.gen);
+                S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
+                S3("u", "Intr pktcnt:",
+                   adap->sge.counter_val[rx[i].rspq.pktcnt_idx]);
+                R("FL ID:", fl.cntxt_id);
+                R("FL size:", fl.size - 8);
+                R("FL pend:", fl.pend_cred);
+                R("FL avail:", fl.avail);
+                R("FL PIDX:", fl.pidx);
+                R("FL CIDX:", fl.cidx);
+        } else if (toe_idx < toe_entries) {
+                const struct sge_ofld_rxq *rx = &adap->sge.ofldrxq[toe_idx * 4];
+                const struct sge_ofld_txq *tx = &adap->sge.ofldtxq[toe_idx * 4];
+                int n = min(4, adap->sge.ofldqsets - 4 * toe_idx);
+
+                S("QType:", "TOE");
+                T("TxQ ID:", q.cntxt_id);
+                T("TxQ size:", q.size);
+                T("TxQ inuse:", q.in_use);
+                T("TxQ CIDX:", q.cidx);
+                T("TxQ PIDX:", q.pidx);
+                R("RspQ ID:", rspq.abs_id);
+                R("RspQ size:", rspq.size);
+                R("RspQE size:", rspq.iqe_len);
+                R("RspQ CIDX:", rspq.cidx);
+                R("RspQ Gen:", rspq.gen);
+                S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
+                S3("u", "Intr pktcnt:",
+                   adap->sge.counter_val[rx[i].rspq.pktcnt_idx]);
+                R("FL ID:", fl.cntxt_id);
+                R("FL size:", fl.size - 8);
+                R("FL pend:", fl.pend_cred);
+                R("FL avail:", fl.avail);
+                R("FL PIDX:", fl.pidx);
+                R("FL CIDX:", fl.cidx);
+        } else if (rdma_idx < rdma_entries) {
+                const struct sge_ofld_rxq *rx =
+                                &adap->sge.rdmarxq[rdma_idx * 4];
+                int n = min(4, adap->sge.rdmaqs - 4 * rdma_idx);
+
+                S("QType:", "RDMA-CPL");
+                R("RspQ ID:", rspq.abs_id);
+                R("RspQ size:", rspq.size);
+                R("RspQE size:", rspq.iqe_len);
+                R("RspQ CIDX:", rspq.cidx);
+                R("RspQ Gen:", rspq.gen);
+                S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
+                S3("u", "Intr pktcnt:",
+                   adap->sge.counter_val[rx[i].rspq.pktcnt_idx]);
+                R("FL ID:", fl.cntxt_id);
+                R("FL size:", fl.size - 8);
+                R("FL pend:", fl.pend_cred);
+                R("FL avail:", fl.avail);
+                R("FL PIDX:", fl.pidx);
+                R("FL CIDX:", fl.cidx);
+        } else if (ciq_idx < ciq_entries) {
+                const struct sge_ofld_rxq *rx = &adap->sge.rdmaciq[ciq_idx * 4];
+                int n = min(4, adap->sge.rdmaciqs - 4 * ciq_idx);
+
+                S("QType:", "RDMA-CIQ");
+                R("RspQ ID:", rspq.abs_id);
+                R("RspQ size:", rspq.size);
+                R("RspQE size:", rspq.iqe_len);
+                R("RspQ CIDX:", rspq.cidx);
+                R("RspQ Gen:", rspq.gen);
+                S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
+                S3("u", "Intr pktcnt:",
+                   adap->sge.counter_val[rx[i].rspq.pktcnt_idx]);
+        } else if (ctrl_idx < ctrl_entries) {
+                const struct sge_ctrl_txq *tx = &adap->sge.ctrlq[ctrl_idx * 4];
+                int n = min(4, adap->params.nports - 4 * ctrl_idx);
+
+                S("QType:", "Control");
+                T("TxQ ID:", q.cntxt_id);
+                T("TxQ size:", q.size);
+                T("TxQ inuse:", q.in_use);
+                T("TxQ CIDX:", q.cidx);
+                T("TxQ PIDX:", q.pidx);
+        } else if (fq_idx == 0) {
+                const struct sge_rspq *evtq = &adap->sge.fw_evtq;
+
+                seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue");
+                seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id);
+                seq_printf(seq, "%-12s %16u\n", "RspQ size:", evtq->size);
+                seq_printf(seq, "%-12s %16u\n", "RspQE size:", evtq->iqe_len);
+                seq_printf(seq, "%-12s %16u\n", "RspQ CIDX:", evtq->cidx);
+                seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen);
+                seq_printf(seq, "%-12s %16u\n", "Intr delay:",
+                           qtimer_val(adap, evtq));
+                seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
+                           adap->sge.counter_val[evtq->pktcnt_idx]);
+        }
+#undef R
+#undef T
+#undef S
+#undef S3
+return 0;
+}
+
+static int sge_queue_entries(const struct adapter *adap)
+{
+        return DIV_ROUND_UP(adap->sge.ethqsets, 4) +
+               DIV_ROUND_UP(adap->sge.ofldqsets, 4) +
+               DIV_ROUND_UP(adap->sge.rdmaqs, 4) +
+               DIV_ROUND_UP(adap->sge.rdmaciqs, 4) +
+               DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1;
+}
+
+static void *sge_queue_start(struct seq_file *seq, loff_t *pos)
+{
+        int entries = sge_queue_entries(seq->private);
+
+        return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
+}
+
+static void sge_queue_stop(struct seq_file *seq, void *v)
+{
+}
+
+static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+        int entries = sge_queue_entries(seq->private);
+
+        ++*pos;
+        return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
+}
+
+static const struct seq_operations sge_qinfo_seq_ops = {
+        .start = sge_queue_start,
+        .next  = sge_queue_next,
+        .stop  = sge_queue_stop,
+        .show  = sge_qinfo_show
+};
+
+static int sge_qinfo_open(struct inode *inode, struct file *file)
+{
+        int res = seq_open(file, &sge_qinfo_seq_ops);
+
+        if (!res) {
+                struct seq_file *seq = file->private_data;
+
+                seq->private = inode->i_private;
+        }
+        return res;
+}
+
+static const struct file_operations sge_qinfo_debugfs_fops = {
+        .owner   = THIS_MODULE,
+        .open    = sge_qinfo_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release,
+};
+
+int mem_open(struct inode *inode, struct file *file)
+{
+        unsigned int mem;
+        struct adapter *adap;
+
+        file->private_data = inode->i_private;
+
+        mem = (uintptr_t)file->private_data & 0x3;
+        adap = file->private_data - mem;
+
+        (void)t4_fwcache(adap, FW_PARAM_DEV_FWCACHE_FLUSH);
+
+        return 0;
+}
+
 static ssize_t mem_read(struct file *file, char __user *buf, size_t count,
                         loff_t *ppos)
 {
@@ -80,7 +1934,6 @@ static ssize_t mem_read(struct file *file, char __user *buf, size_t count,
         *ppos = pos + count;
         return count;
 }
-
 static const struct file_operations mem_debugfs_fops = {
         .owner   = THIS_MODULE,
         .open    = simple_open,
@@ -88,6 +1941,12 @@ static const struct file_operations mem_debugfs_fops = {
         .llseek  = default_llseek,
 };
 
+static void set_debugfs_file_size(struct dentry *de, loff_t size)
+{
+        if (!IS_ERR(de) && de->d_inode)
+                de->d_inode->i_size = size;
+}
+
 static void add_debugfs_mem(struct adapter *adap, const char *name,
                             unsigned int idx, unsigned int size_mb)
 {
@@ -119,14 +1978,65 @@ int t4_setup_debugfs(struct adapter *adap)
 {
         int i;
         u32 size;
+        struct dentry *de;
 
         static struct t4_debugfs_entry t4_debugfs_files[] = {
+                { "cim_la", &cim_la_fops, S_IRUSR, 0 },
+                { "cim_qcfg", &cim_qcfg_fops, S_IRUSR, 0 },
+                { "clk", &clk_debugfs_fops, S_IRUSR, 0 },
+                { "devlog", &devlog_fops, S_IRUSR, 0 },
+                { "mbox0", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 0 },
+                { "mbox1", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 1 },
+                { "mbox2", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 2 },
+                { "mbox3", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 3 },
+                { "mbox4", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 4 },
+                { "mbox5", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 5 },
+                { "mbox6", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 6 },
+                { "mbox7", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 7 },
                 { "l2t", &t4_l2t_fops, S_IRUSR, 0},
+                { "mps_tcam", &mps_tcam_debugfs_fops, S_IRUSR, 0 },
+                { "rss", &rss_debugfs_fops, S_IRUSR, 0 },
+                { "rss_config", &rss_config_debugfs_fops, S_IRUSR, 0 },
+                { "rss_key", &rss_key_debugfs_fops, S_IRUSR, 0 },
+                { "rss_pf_config", &rss_pf_config_debugfs_fops, S_IRUSR, 0 },
+                { "rss_vf_config", &rss_vf_config_debugfs_fops, S_IRUSR, 0 },
+                { "sge_qinfo", &sge_qinfo_debugfs_fops, S_IRUSR, 0 },
+                { "ibq_tp0",  &cim_ibq_fops, S_IRUSR, 0 },
+                { "ibq_tp1",  &cim_ibq_fops, S_IRUSR, 1 },
+                { "ibq_ulp",  &cim_ibq_fops, S_IRUSR, 2 },
+                { "ibq_sge0", &cim_ibq_fops, S_IRUSR, 3 },
+                { "ibq_sge1", &cim_ibq_fops, S_IRUSR, 4 },
+                { "ibq_ncsi", &cim_ibq_fops, S_IRUSR, 5 },
+                { "obq_ulp0", &cim_obq_fops, S_IRUSR, 0 },
+                { "obq_ulp1", &cim_obq_fops, S_IRUSR, 1 },
+                { "obq_ulp2", &cim_obq_fops, S_IRUSR, 2 },
+                { "obq_ulp3", &cim_obq_fops, S_IRUSR, 3 },
+                { "obq_sge",  &cim_obq_fops, S_IRUSR, 4 },
+                { "obq_ncsi", &cim_obq_fops, S_IRUSR, 5 },
+                { "tp_la", &tp_la_fops, S_IRUSR, 0 },
+                { "ulprx_la", &ulprx_la_fops, S_IRUSR, 0 },
+                { "sensors", &sensors_debugfs_fops, S_IRUSR, 0 },
+                { "pm_stats", &pm_stats_debugfs_fops, S_IRUSR, 0 },
+                { "cctrl", &cctrl_tbl_debugfs_fops, S_IRUSR, 0 },
+#if IS_ENABLED(CONFIG_IPV6)
+                { "clip_tbl", &clip_tbl_debugfs_fops, S_IRUSR, 0 },
+#endif
+        };
+
+        /* Debug FS nodes common to all T5 and later adapters.
+         */
+        static struct t4_debugfs_entry t5_debugfs_files[] = {
+                { "obq_sge_rx_q0", &cim_obq_fops, S_IRUSR, 6 },
+                { "obq_sge_rx_q1", &cim_obq_fops, S_IRUSR, 7 },
         };
 
         add_debugfs_files(adap,
                           t4_debugfs_files,
                           ARRAY_SIZE(t4_debugfs_files));
+        if (!is_t4(adap->params.chip))
+                add_debugfs_files(adap,
+                                  t5_debugfs_files,
+                                  ARRAY_SIZE(t5_debugfs_files));
 
         i = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A);
         if (i & EDRAM0_ENABLE_F) {
@@ -154,5 +2064,10 @@ int t4_setup_debugfs(struct adapter *adap)
                                         EXT_MEM1_SIZE_G(size));
                 }
         }
+
+        de = debugfs_create_file("flash", S_IRUSR, adap->debugfs_root, adap,
+                                 &flash_debugfs_fops);
+        set_debugfs_file_size(de, adap->params.sf_size);
+
         return 0;
 }
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.h
index a3d8867efd3d..b63cfee2d963 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.h
@@ -37,6 +37,21 @@
 
 #include <linux/export.h>
 
+#define FILE_DATA(_file) ((_file)->f_path.dentry->d_inode)
+
+#define DEFINE_SIMPLE_DEBUGFS_FILE(name) \
+static int name##_open(struct inode *inode, struct file *file) \
+{ \
+        return single_open(file, name##_show, inode->i_private); \
+} \
+static const struct file_operations name##_debugfs_fops = { \
+        .owner   = THIS_MODULE, \
+        .open    = name##_open, \
+        .read    = seq_read, \
+        .llseek  = seq_lseek, \
+        .release = single_release \
+}
+
 struct t4_debugfs_entry {
         const char *name;
         const struct file_operations *ops;
@@ -44,9 +59,27 @@ struct t4_debugfs_entry {
         unsigned char data;
 };
 
+struct seq_tab {
+        int (*show)(struct seq_file *seq, void *v, int idx);
+        unsigned int rows;        /* # of entries */
+        unsigned char width;      /* size in bytes of each entry */
+        unsigned char skip_first; /* whether the first line is a header */
+        char data[0];             /* the table data */
+};
+
+static inline unsigned int hex2val(char c)
+{
+        return isdigit(c) ? c - '0' : tolower(c) - 'a' + 10;
+}
+
+struct seq_tab *seq_open_tab(struct file *f, unsigned int rows,
+                             unsigned int width, unsigned int have_header,
+                             int (*show)(struct seq_file *seq, void *v, int i));
+
 int t4_setup_debugfs(struct adapter *adap);
 void add_debugfs_files(struct adapter *adap,
                        struct t4_debugfs_entry *files,
                        unsigned int nfiles);
+int mem_open(struct inode *inode, struct file *file);
 
 #endif
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index ccf3436024bc..a22cf932ca35 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -62,14 +62,18 @@
 #include <net/netevent.h>
 #include <net/addrconf.h>
 #include <net/bonding.h>
+#include <net/addrconf.h>
 #include <asm/uaccess.h>
 
 #include "cxgb4.h"
 #include "t4_regs.h"
+#include "t4_values.h"
 #include "t4_msg.h"
 #include "t4fw_api.h"
+#include "t4fw_version.h"
 #include "cxgb4_dcb.h"
 #include "cxgb4_debugfs.h"
+#include "clip_tbl.h"
 #include "l2t.h"
 
 #ifdef DRV_VERSION
@@ -78,99 +82,6 @@
 #define DRV_VERSION "2.0.0-ko"
 #define DRV_DESC "Chelsio T4/T5 Network Driver"
 
-/*
- * Max interrupt hold-off timer value in us.  Queues fall back to this value
- * under extreme memory pressure so it's largish to give the system time to
- * recover.
- */
-#define MAX_SGE_TIMERVAL 200U
-
-enum {
-        /*
-         * Physical Function provisioning constants.
-         */
-        PFRES_NVI = 4,                  /* # of Virtual Interfaces */
-        PFRES_NETHCTRL = 128,           /* # of EQs used for ETH or CTRL Qs */
-        PFRES_NIQFLINT = 128,           /* # of ingress Qs/w Free List(s)/intr
-                                         */
-        PFRES_NEQ = 256,                /* # of egress queues */
-        PFRES_NIQ = 0,                  /* # of ingress queues */
-        PFRES_TC = 0,                   /* PCI-E traffic class */
-        PFRES_NEXACTF = 128,            /* # of exact MPS filters */
-
-        PFRES_R_CAPS = FW_CMD_CAP_PF,
-        PFRES_WX_CAPS = FW_CMD_CAP_PF,
-
-#ifdef CONFIG_PCI_IOV
-        /*
-         * Virtual Function provisioning constants.  We need two extra Ingress
-         * Queues with Interrupt capability to serve as the VF's Firmware
-         * Event Queue and Forwarded Interrupt Queue (when using MSI mode) --
-         * neither will have Free Lists associated with them).  For each
-         * Ethernet/Control Egress Queue and for each Free List, we need an
-         * Egress Context.
-         */
-        VFRES_NPORTS = 1,               /* # of "ports" per VF */
-        VFRES_NQSETS = 2,               /* # of "Queue Sets" per VF */
-
-        VFRES_NVI = VFRES_NPORTS,       /* # of Virtual Interfaces */
-        VFRES_NETHCTRL = VFRES_NQSETS,  /* # of EQs used for ETH or CTRL Qs */
-        VFRES_NIQFLINT = VFRES_NQSETS+2,/* # of ingress Qs/w Free List(s)/intr */
-        VFRES_NEQ = VFRES_NQSETS*2,     /* # of egress queues */
-        VFRES_NIQ = 0,                  /* # of non-fl/int ingress queues */
-        VFRES_TC = 0,                   /* PCI-E traffic class */
-        VFRES_NEXACTF = 16,             /* # of exact MPS filters */
-
-        VFRES_R_CAPS = FW_CMD_CAP_DMAQ|FW_CMD_CAP_VF|FW_CMD_CAP_PORT,
-        VFRES_WX_CAPS = FW_CMD_CAP_DMAQ|FW_CMD_CAP_VF,
-#endif
-};
-
-/*
- * Provide a Port Access Rights Mask for the specified PF/VF.  This is very
- * static and likely not to be useful in the long run.  We really need to
- * implement some form of persistent configuration which the firmware
- * controls.
- */
-static unsigned int pfvfres_pmask(struct adapter *adapter,
-                                  unsigned int pf, unsigned int vf)
-{
-        unsigned int portn, portvec;
-
-        /*
-         * Give PF's access to all of the ports.
-         */
-        if (vf == 0)
-                return FW_PFVF_CMD_PMASK_M;
-
-        /*
-         * For VFs, we'll assign them access to the ports based purely on the
-         * PF.  We assign active ports in order, wrapping around if there are
-         * fewer active ports than PFs: e.g. active port[pf % nports].
-         * Unfortunately the adapter's port_info structs haven't been
-         * initialized yet so we have to compute this.
-         */
-        if (adapter->params.nports == 0)
-                return 0;
-
-        portn = pf % adapter->params.nports;
-        portvec = adapter->params.portvec;
-        for (;;) {
-                /*
-                 * Isolate the lowest set bit in the port vector.  If we're at
-                 * the port number that we want, return that as the pmask.
-                 * otherwise mask that bit out of the port vector and
-                 * decrement our port number ...
-                 */
-                unsigned int pmask = portvec ^ (portvec & (portvec-1));
-                if (portn == 0)
-                        return pmask;
-                portn--;
-                portvec &= ~pmask;
-        }
-        /*NOTREACHED*/
-}
-
 enum {
         MAX_TXQ_ENTRIES      = 16384,
         MAX_CTRL_TXQ_ENTRIES = 1024,
@@ -263,7 +174,8 @@ MODULE_PARM_DESC(force_init, "Forcibly become Master PF and initialize adapter")
 static uint force_old_init;
 
 module_param(force_old_init, uint, 0644);
-MODULE_PARM_DESC(force_old_init, "Force old initialization sequence");
+MODULE_PARM_DESC(force_old_init, "Force old initialization sequence, deprecated"
+                 " parameter");
 
 static int dflt_msg_enable = DFLT_MSG_ENABLE;
 
@@ -292,13 +204,14 @@ static unsigned int intr_holdoff[SGE_NTIMERS - 1] = { 5, 10, 20, 50, 100 };
 
 module_param_array(intr_holdoff, uint, NULL, 0644);
 MODULE_PARM_DESC(intr_holdoff, "values for queue interrupt hold-off timers "
-                 "0..4 in microseconds");
+                 "0..4 in microseconds, deprecated parameter");
 
 static unsigned int intr_cnt[SGE_NCOUNTERS - 1] = { 4, 8, 16 };
 
 module_param_array(intr_cnt, uint, NULL, 0644);
 MODULE_PARM_DESC(intr_cnt,
-                 "thresholds 1..3 for queue interrupt packet counters");
+                 "thresholds 1..3 for queue interrupt packet counters, "
+                 "deprecated parameter");
 
 /*
  * Normally we tell the chip to deliver Ingress Packets into our DMA buffers
@@ -318,7 +231,8 @@ static bool vf_acls;
 
 #ifdef CONFIG_PCI_IOV
 module_param(vf_acls, bool, 0644);
-MODULE_PARM_DESC(vf_acls, "if set enable virtualization L2 ACL enforcement");
+MODULE_PARM_DESC(vf_acls, "if set enable virtualization L2 ACL enforcement, "
+                 "deprecated parameter");
 
 /* Configure the number of PCI-E Virtual Function which are to be instantiated
  * on SR-IOV Capable Physical Functions.
@@ -340,32 +254,11 @@ module_param(select_queue, int, 0644);
 MODULE_PARM_DESC(select_queue,
                  "Select between kernel provided method of selecting or driver method of selecting TX queue. Default is kernel method.");
 
-/*
- * The filter TCAM has a fixed portion and a variable portion.  The fixed
- * portion can match on source/destination IP IPv4/IPv6 addresses and TCP/UDP
- * ports.  The variable portion is 36 bits which can include things like Exact
- * Match MAC Index (9 bits), Ether Type (16 bits), IP Protocol (8 bits),
- * [Inner] VLAN Tag (17 bits), etc. which, if all were somehow selected, would
- * far exceed the 36-bit budget for this "compressed" header portion of the
- * filter.  Thus, we have a scarce resource which must be carefully managed.
- *
- * By default we set this up to mostly match the set of filter matching
- * capabilities of T3 but with accommodations for some of T4's more
- * interesting features:
- *
- *   { IP Fragment (1), MPS Match Type (3), IP Protocol (8),
- *     [Inner] VLAN (17), Port (3), FCoE (1) }
- */
-enum {
-        TP_VLAN_PRI_MAP_DEFAULT = HW_TPL_FR_MT_PR_IV_P_FC,
-        TP_VLAN_PRI_MAP_FIRST = FCOE_SHIFT,
-        TP_VLAN_PRI_MAP_LAST = FRAGMENTATION_SHIFT,
-};
-
-static unsigned int tp_vlan_pri_map = TP_VLAN_PRI_MAP_DEFAULT;
+static unsigned int tp_vlan_pri_map = HW_TPL_FR_MT_PR_IV_P_FC;
 
 module_param(tp_vlan_pri_map, uint, 0644);
-MODULE_PARM_DESC(tp_vlan_pri_map, "global compressed filter configuration");
+MODULE_PARM_DESC(tp_vlan_pri_map, "global compressed filter configuration, "
+                 "deprecated parameter");
 
 static struct dentry *cxgb4_debugfs_root;
 
@@ -671,7 +564,7 @@ static void filter_rpl(struct adapter *adap, const struct cpl_set_tcb_rpl *rpl)
         if (idx >= adap->tids.ftid_base && nidx <
            (adap->tids.nftids + adap->tids.nsftids)) {
                 idx = nidx;
-                ret = GET_TCB_COOKIE(rpl->cookie);
+                ret = TCB_COOKIE_G(rpl->cookie);
                 f = &adap->tids.ftid_tab[idx];
 
                 if (ret == FW_FILTER_WR_FLT_DELETED) {
@@ -723,7 +616,7 @@ static int fwevtq_handler(struct sge_rspq *q, const __be64 *rsp,
 
         if (likely(opcode == CPL_SGE_EGR_UPDATE)) {
                 const struct cpl_sge_egr_update *p = (void *)rsp;
-                unsigned int qid = EGR_QID(ntohl(p->opcode_qid));
+                unsigned int qid = EGR_QID_G(ntohl(p->opcode_qid));
                 struct sge_txq *txq;
 
                 txq = q->adap->sge.egr_map[qid - q->adap->sge.egr_start];
@@ -833,11 +726,11 @@ static void disable_msi(struct adapter *adapter)
 static irqreturn_t t4_nondata_intr(int irq, void *cookie)
 {
         struct adapter *adap = cookie;
+        u32 v = t4_read_reg(adap, MYPF_REG(PL_PF_INT_CAUSE_A));
 
-        u32 v = t4_read_reg(adap, MYPF_REG(PL_PF_INT_CAUSE));
-        if (v & PFSW) {
+        if (v & PFSW_F) {
                 adap->swintr = 1;
-                t4_write_reg(adap, MYPF_REG(PL_PF_INT_CAUSE), v);
+                t4_write_reg(adap, MYPF_REG(PL_PF_INT_CAUSE_A), v);
         }
         t4_slow_intr_handler(adap);
         return IRQ_HANDLED;
@@ -1030,8 +923,14 @@ static void quiesce_rx(struct adapter *adap)
         for (i = 0; i < ARRAY_SIZE(adap->sge.ingr_map); i++) {
                 struct sge_rspq *q = adap->sge.ingr_map[i];
 
-                if (q && q->handler)
+                if (q && q->handler) {
                         napi_disable(&q->napi);
+                        local_bh_disable();
+                        while (!cxgb_poll_lock_napi(q))
+                                mdelay(1);
+                        local_bh_enable();
+                }
+
         }
 }
 
@@ -1047,12 +946,14 @@ static void enable_rx(struct adapter *adap)
 
                 if (!q)
                         continue;
-                if (q->handler)
+                if (q->handler) {
+                        cxgb_busy_poll_init_lock(q);
                         napi_enable(&q->napi);
+                }
                 /* 0-increment GTS to start the timer and enable interrupts */
-                t4_write_reg(adap, MYPF_REG(SGE_PF_GTS),
-                             SEINTARM(q->intr_params) |
-                             INGRESSQID(q->cntxt_id));
+                t4_write_reg(adap, MYPF_REG(SGE_PF_GTS_A),
+                             SEINTARM_V(q->intr_params) |
+                             INGRESSQID_V(q->cntxt_id));
         }
 }
 
@@ -1176,10 +1077,10 @@ freeout:	t4_free_sge_resources(adap);
         }
 
         t4_write_reg(adap, is_t4(adap->params.chip) ?
-                                MPS_TRC_RSS_CONTROL :
-                                MPS_T5_TRC_RSS_CONTROL,
-                     RSSCONTROL(netdev2pinfo(adap->port[0])->tx_chan) |
-                     QUEUENUMBER(s->ethrxq[0].rspq.abs_id));
+                                MPS_TRC_RSS_CONTROL_A :
+                                MPS_T5_TRC_RSS_CONTROL_A,
+                     RSSCONTROL_V(netdev2pinfo(adap->port[0])->tx_chan) |
+                     QUEUENUMBER_V(s->ethrxq[0].rspq.abs_id));
         return 0;
 }
 
@@ -1518,6 +1419,7 @@ static int get_eeprom_len(struct net_device *dev)
 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
         struct adapter *adapter = netdev2adap(dev);
+        u32 exprom_vers;
 
         strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
@@ -1535,6 +1437,14 @@ static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
                         FW_HDR_FW_VER_MINOR_G(adapter->params.tp_vers),
                         FW_HDR_FW_VER_MICRO_G(adapter->params.tp_vers),
                         FW_HDR_FW_VER_BUILD_G(adapter->params.tp_vers));
+
+        if (!t4_get_exprom_version(adapter, &exprom_vers))
+                snprintf(info->erom_version, sizeof(info->erom_version),
+                         "%u.%u.%u.%u",
+                         FW_HDR_FW_VER_MAJOR_G(exprom_vers),
+                         FW_HDR_FW_VER_MINOR_G(exprom_vers),
+                         FW_HDR_FW_VER_MICRO_G(exprom_vers),
+                         FW_HDR_FW_VER_BUILD_G(exprom_vers));
 }
 
 static void get_strings(struct net_device *dev, u32 stringset, u8 *data)
@@ -1589,9 +1499,9 @@ static void get_stats(struct net_device *dev, struct ethtool_stats *stats,
         collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data);
         data += sizeof(struct queue_port_stats) / sizeof(u64);
         if (!is_t4(adapter->params.chip)) {
-                t4_write_reg(adapter, SGE_STAT_CFG, STATSOURCE_T5(7));
-                val1 = t4_read_reg(adapter, SGE_STAT_TOTAL);
-                val2 = t4_read_reg(adapter, SGE_STAT_MATCH);
+                t4_write_reg(adapter, SGE_STAT_CFG_A, STATSOURCE_T5_V(7));
+                val1 = t4_read_reg(adapter, SGE_STAT_TOTAL_A);
+                val2 = t4_read_reg(adapter, SGE_STAT_MATCH_A);
                 *data = val1 - val2;
                 data++;
                 *data = val2;
@@ -2608,8 +2518,8 @@ static int closest_thres(const struct sge *s, int thres)
 /*
  * Return a queue's interrupt hold-off time in us.  0 means no timer.
  */
-static unsigned int qtimer_val(const struct adapter *adap,
-                               const struct sge_rspq *q)
+unsigned int qtimer_val(const struct adapter *adap,
+                        const struct sge_rspq *q)
 {
         unsigned int idx = q->intr_params >> 1;
 
@@ -3346,40 +3256,6 @@ static int tid_init(struct tid_info *t)
         return 0;
 }
 
-int cxgb4_clip_get(const struct net_device *dev,
-                   const struct in6_addr *lip)
-{
-        struct adapter *adap;
-        struct fw_clip_cmd c;
-
-        adap = netdev2adap(dev);
-        memset(&c, 0, sizeof(c));
-        c.op_to_write = htonl(FW_CMD_OP_V(FW_CLIP_CMD) |
-                        FW_CMD_REQUEST_F | FW_CMD_WRITE_F);
-        c.alloc_to_len16 = htonl(FW_CLIP_CMD_ALLOC_F | FW_LEN16(c));
-        c.ip_hi = *(__be64 *)(lip->s6_addr);
-        c.ip_lo = *(__be64 *)(lip->s6_addr + 8);
-        return t4_wr_mbox_meat(adap, adap->mbox, &c, sizeof(c), &c, false);
-}
-EXPORT_SYMBOL(cxgb4_clip_get);
-
-int cxgb4_clip_release(const struct net_device *dev,
-                       const struct in6_addr *lip)
-{
-        struct adapter *adap;
-        struct fw_clip_cmd c;
-
-        adap = netdev2adap(dev);
-        memset(&c, 0, sizeof(c));
-        c.op_to_write = htonl(FW_CMD_OP_V(FW_CLIP_CMD) |
-                        FW_CMD_REQUEST_F | FW_CMD_READ_F);
-        c.alloc_to_len16 = htonl(FW_CLIP_CMD_FREE_F | FW_LEN16(c));
-        c.ip_hi = *(__be64 *)(lip->s6_addr);
-        c.ip_lo = *(__be64 *)(lip->s6_addr + 8);
-        return t4_wr_mbox_meat(adap, adap->mbox, &c, sizeof(c), &c, false);
-}
-EXPORT_SYMBOL(cxgb4_clip_release);
-
 /**
  *      cxgb4_create_server - create an IP server
  *      @dev: the device
@@ -3415,8 +3291,8 @@ int cxgb4_create_server(const struct net_device *dev, unsigned int stid,
         req->peer_ip = htonl(0);
         chan = rxq_to_chan(&adap->sge, queue);
         req->opt0 = cpu_to_be64(TX_CHAN_V(chan));
-        req->opt1 = cpu_to_be64(CONN_POLICY_ASK |
-                                SYN_RSS_ENABLE | SYN_RSS_QUEUE(queue));
+        req->opt1 = cpu_to_be64(CONN_POLICY_V(CPL_CONN_POLICY_ASK) |
+                                SYN_RSS_ENABLE_F | SYN_RSS_QUEUE_V(queue));
         ret = t4_mgmt_tx(adap, skb);
         return net_xmit_eval(ret);
 }
@@ -3458,8 +3334,8 @@ int cxgb4_create_server6(const struct net_device *dev, unsigned int stid,
         req->peer_ip_lo = cpu_to_be64(0);
         chan = rxq_to_chan(&adap->sge, queue);
         req->opt0 = cpu_to_be64(TX_CHAN_V(chan));
-        req->opt1 = cpu_to_be64(CONN_POLICY_ASK |
-                                SYN_RSS_ENABLE | SYN_RSS_QUEUE(queue));
+        req->opt1 = cpu_to_be64(CONN_POLICY_V(CPL_CONN_POLICY_ASK) |
+                                SYN_RSS_ENABLE_F | SYN_RSS_QUEUE_V(queue));
         ret = t4_mgmt_tx(adap, skb);
         return net_xmit_eval(ret);
 }
@@ -3482,8 +3358,8 @@ int cxgb4_remove_server(const struct net_device *dev, unsigned int stid,
         req = (struct cpl_close_listsvr_req *)__skb_put(skb, sizeof(*req));
         INIT_TP_WR(req, 0);
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_CLOSE_LISTSRV_REQ, stid));
-        req->reply_ctrl = htons(NO_REPLY(0) | (ipv6 ? LISTSVR_IPV6(1) :
-                                LISTSVR_IPV6(0)) | QUEUENO(queue));
+        req->reply_ctrl = htons(NO_REPLY_V(0) | (ipv6 ? LISTSVR_IPV6_V(1) :
+                                LISTSVR_IPV6_V(0)) | QUEUENO_V(queue));
         ret = t4_mgmt_tx(adap, skb);
         return net_xmit_eval(ret);
 }
@@ -3600,14 +3476,14 @@ unsigned int cxgb4_dbfifo_count(const struct net_device *dev, int lpfifo)
         struct adapter *adap = netdev2adap(dev);
         u32 v1, v2, lp_count, hp_count;
 
-        v1 = t4_read_reg(adap, A_SGE_DBFIFO_STATUS);
-        v2 = t4_read_reg(adap, SGE_DBFIFO_STATUS2);
+        v1 = t4_read_reg(adap, SGE_DBFIFO_STATUS_A);
+        v2 = t4_read_reg(adap, SGE_DBFIFO_STATUS2_A);
         if (is_t4(adap->params.chip)) {
-                lp_count = G_LP_COUNT(v1);
-                hp_count = G_HP_COUNT(v1);
+                lp_count = LP_COUNT_G(v1);
+                hp_count = HP_COUNT_G(v1);
         } else {
-                lp_count = G_LP_COUNT_T5(v1);
-                hp_count = G_HP_COUNT_T5(v2);
+                lp_count = LP_COUNT_T5_G(v1);
+                hp_count = HP_COUNT_T5_G(v2);
         }
         return lpfifo ? lp_count : hp_count;
 }
@@ -3653,10 +3529,10 @@ void cxgb4_iscsi_init(struct net_device *dev, unsigned int tag_mask,
 {
         struct adapter *adap = netdev2adap(dev);
 
-        t4_write_reg(adap, ULP_RX_ISCSI_TAGMASK, tag_mask);
-        t4_write_reg(adap, ULP_RX_ISCSI_PSZ, HPZ0(pgsz_order[0]) |
-                     HPZ1(pgsz_order[1]) | HPZ2(pgsz_order[2]) |
-                     HPZ3(pgsz_order[3]));
+        t4_write_reg(adap, ULP_RX_ISCSI_TAGMASK_A, tag_mask);
+        t4_write_reg(adap, ULP_RX_ISCSI_PSZ_A, HPZ0_V(pgsz_order[0]) |
+                     HPZ1_V(pgsz_order[1]) | HPZ2_V(pgsz_order[2]) |
+                     HPZ3_V(pgsz_order[3]));
 }
 EXPORT_SYMBOL(cxgb4_iscsi_init);
 
@@ -3666,14 +3542,14 @@ int cxgb4_flush_eq_cache(struct net_device *dev)
         int ret;
 
         ret = t4_fwaddrspace_write(adap, adap->mbox,
-                                   0xe1000000 + A_SGE_CTXT_CMD, 0x20000000);
+                                   0xe1000000 + SGE_CTXT_CMD_A, 0x20000000);
         return ret;
 }
 EXPORT_SYMBOL(cxgb4_flush_eq_cache);
 
 static int read_eq_indices(struct adapter *adap, u16 qid, u16 *pidx, u16 *cidx)
 {
-        u32 addr = t4_read_reg(adap, A_SGE_DBQ_CTXT_BADDR) + 24 * qid + 8;
+        u32 addr = t4_read_reg(adap, SGE_DBQ_CTXT_BADDR_A) + 24 * qid + 8;
         __be64 indices;
         int ret;
 
@@ -3702,14 +3578,20 @@ int cxgb4_sync_txq_pidx(struct net_device *dev, u16 qid, u16 pidx,
 
         if (pidx != hw_pidx) {
                 u16 delta;
+                u32 val;
 
                 if (pidx >= hw_pidx)
                         delta = pidx - hw_pidx;
                 else
                         delta = size - hw_pidx + pidx;
+
+                if (is_t4(adap->params.chip))
+                        val = PIDX_V(delta);
+                else
+                        val = PIDX_T5_V(delta);
                 wmb();
-                t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL),
-                             QID(qid) | PIDX(delta));
+                t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL_A),
+                             QID_V(qid) | val);
         }
 out:
         return ret;
@@ -3721,8 +3603,8 @@ void cxgb4_disable_db_coalescing(struct net_device *dev)
         struct adapter *adap;
 
         adap = netdev2adap(dev);
-        t4_set_reg_field(adap, A_SGE_DOORBELL_CONTROL, F_NOCOALESCE,
-                         F_NOCOALESCE);
+        t4_set_reg_field(adap, SGE_DOORBELL_CONTROL_A, NOCOALESCE_F,
+                         NOCOALESCE_F);
 }
 EXPORT_SYMBOL(cxgb4_disable_db_coalescing);
 
@@ -3731,7 +3613,7 @@ void cxgb4_enable_db_coalescing(struct net_device *dev)
         struct adapter *adap;
 
         adap = netdev2adap(dev);
-        t4_set_reg_field(adap, A_SGE_DOORBELL_CONTROL, F_NOCOALESCE, 0);
+        t4_set_reg_field(adap, SGE_DOORBELL_CONTROL_A, NOCOALESCE_F, 0);
 }
 EXPORT_SYMBOL(cxgb4_enable_db_coalescing);
 
@@ -3809,8 +3691,8 @@ u64 cxgb4_read_sge_timestamp(struct net_device *dev)
         struct adapter *adap;
 
         adap = netdev2adap(dev);
-        lo = t4_read_reg(adap, SGE_TIMESTAMP_LO);
-        hi = GET_TSVAL(t4_read_reg(adap, SGE_TIMESTAMP_HI));
+        lo = t4_read_reg(adap, SGE_TIMESTAMP_LO_A);
+        hi = TSVAL_G(t4_read_reg(adap, SGE_TIMESTAMP_HI_A));
 
         return ((u64)hi << 32) | (u64)lo;
 }
@@ -3870,14 +3752,14 @@ static void drain_db_fifo(struct adapter *adap, int usecs)
         u32 v1, v2, lp_count, hp_count;
 
         do {
-                v1 = t4_read_reg(adap, A_SGE_DBFIFO_STATUS);
-                v2 = t4_read_reg(adap, SGE_DBFIFO_STATUS2);
+                v1 = t4_read_reg(adap, SGE_DBFIFO_STATUS_A);
+                v2 = t4_read_reg(adap, SGE_DBFIFO_STATUS2_A);
                 if (is_t4(adap->params.chip)) {
-                        lp_count = G_LP_COUNT(v1);
-                        hp_count = G_HP_COUNT(v1);
+                        lp_count = LP_COUNT_G(v1);
+                        hp_count = HP_COUNT_G(v1);
                 } else {
-                        lp_count = G_LP_COUNT_T5(v1);
-                        hp_count = G_HP_COUNT_T5(v2);
+                        lp_count = LP_COUNT_T5_G(v1);
+                        hp_count = HP_COUNT_T5_G(v2);
                 }
 
                 if (lp_count == 0 && hp_count == 0)
@@ -3904,8 +3786,8 @@ static void enable_txq_db(struct adapter *adap, struct sge_txq *q)
                  * are committed before we tell HW about them.
                  */
                 wmb();
-                t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL),
-                             QID(q->cntxt_id) | PIDX(q->db_pidx_inc));
+                t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL_A),
+                             QID_V(q->cntxt_id) | PIDX_V(q->db_pidx_inc));
                 q->db_pidx_inc = 0;
         }
         q->db_disabled = 0;
@@ -3952,9 +3834,9 @@ static void process_db_full(struct work_struct *work)
         drain_db_fifo(adap, dbfifo_drain_delay);
         enable_dbs(adap);
         notify_rdma_uld(adap, CXGB4_CONTROL_DB_EMPTY);
-        t4_set_reg_field(adap, SGE_INT_ENABLE3,
-                         DBFIFO_HP_INT | DBFIFO_LP_INT,
-                         DBFIFO_HP_INT | DBFIFO_LP_INT);
+        t4_set_reg_field(adap, SGE_INT_ENABLE3_A,
+                         DBFIFO_HP_INT_F | DBFIFO_LP_INT_F,
+                         DBFIFO_HP_INT_F | DBFIFO_LP_INT_F);
 }
 
 static void sync_txq_pidx(struct adapter *adap, struct sge_txq *q)
@@ -3968,14 +3850,20 @@ static void sync_txq_pidx(struct adapter *adap, struct sge_txq *q)
                 goto out;
         if (q->db_pidx != hw_pidx) {
                 u16 delta;
+                u32 val;
 
                 if (q->db_pidx >= hw_pidx)
                         delta = q->db_pidx - hw_pidx;
                 else
                         delta = q->size - hw_pidx + q->db_pidx;
+
+                if (is_t4(adap->params.chip))
+                        val = PIDX_V(delta);
+                else
+                        val = PIDX_T5_V(delta);
                 wmb();
-                t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL),
-                             QID(q->cntxt_id) | PIDX(delta));
+                t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL_A),
+                             QID_V(q->cntxt_id) | val);
         }
 out:
         q->db_disabled = 0;
@@ -4024,14 +3912,14 @@ static void process_db_drop(struct work_struct *work)
                         dev_err(adap->pdev_dev, "doorbell drop recovery: "
                                 "qid=%d, pidx_inc=%d\n", qid, pidx_inc);
                 else
-                        writel(PIDX_T5(pidx_inc) | QID(bar2_qid),
+                        writel(PIDX_T5_V(pidx_inc) | QID_V(bar2_qid),
                                adap->bar2 + bar2_qoffset + SGE_UDB_KDOORBELL);
 
                 /* Re-enable BAR2 WC */
                 t4_set_reg_field(adap, 0x10b0, 1<<15, 1<<15);
         }
 
-        t4_set_reg_field(adap, A_SGE_DOORBELL_CONTROL, F_DROPPED_DB, 0);
+        t4_set_reg_field(adap, SGE_DOORBELL_CONTROL_A, DROPPED_DB_F, 0);
 }
 
 void t4_db_full(struct adapter *adap)
@@ -4039,8 +3927,8 @@ void t4_db_full(struct adapter *adap)
         if (is_t4(adap->params.chip)) {
                 disable_dbs(adap);
                 notify_rdma_uld(adap, CXGB4_CONTROL_DB_FULL);
-                t4_set_reg_field(adap, SGE_INT_ENABLE3,
-                                 DBFIFO_HP_INT | DBFIFO_LP_INT, 0);
+                t4_set_reg_field(adap, SGE_INT_ENABLE3_A,
+                                 DBFIFO_HP_INT_F | DBFIFO_LP_INT_F, 0);
                 queue_work(adap->workq, &adap->db_full_task);
         }
 }
@@ -4081,7 +3969,7 @@ static void uld_attach(struct adapter *adap, unsigned int uld)
         lli.nports = adap->params.nports;
         lli.wr_cred = adap->params.ofldq_wr_cred;
         lli.adapter_type = adap->params.chip;
-        lli.iscsi_iolen = MAXRXDATA_GET(t4_read_reg(adap, TP_PARA_REG2));
+        lli.iscsi_iolen = MAXRXDATA_G(t4_read_reg(adap, TP_PARA_REG2_A));
         lli.cclk_ps = 1000000000 / adap->params.vpd.cclk;
         lli.udb_density = 1 << adap->params.sge.eq_qpp;
         lli.ucq_density = 1 << adap->params.sge.iq_qpp;
@@ -4089,8 +3977,8 @@ static void uld_attach(struct adapter *adap, unsigned int uld)
         /* MODQ_REQ_MAP sets queues 0-3 to chan 0-3 */
         for (i = 0; i < NCHAN; i++)
                 lli.tx_modq[i] = i;
-        lli.gts_reg = adap->regs + MYPF_REG(SGE_PF_GTS);
-        lli.db_reg = adap->regs + MYPF_REG(SGE_PF_KDOORBELL);
+        lli.gts_reg = adap->regs + MYPF_REG(SGE_PF_GTS_A);
+        lli.db_reg = adap->regs + MYPF_REG(SGE_PF_KDOORBELL_A);
         lli.fw_vers = adap->params.fw_vers;
         lli.dbfifo_int_thresh = dbfifo_int_thresh;
         lli.sge_ingpadboundary = adap->sge.fl_align;
@@ -4220,148 +4108,61 @@ int cxgb4_unregister_uld(enum cxgb4_uld type)
 }
 EXPORT_SYMBOL(cxgb4_unregister_uld);
 
-/* Check if netdev on which event is occured belongs to us or not. Return
- * success (true) if it belongs otherwise failure (false).
- * Called with rcu_read_lock() held.
- */
 #if IS_ENABLED(CONFIG_IPV6)
-static bool cxgb4_netdev(const struct net_device *netdev)
+static int cxgb4_inet6addr_handler(struct notifier_block *this,
+                                   unsigned long event, void *data)
 {
+        struct inet6_ifaddr *ifa = data;
+        struct net_device *event_dev = ifa->idev->dev;
+        const struct device *parent = NULL;
+#if IS_ENABLED(CONFIG_BONDING)
         struct adapter *adap;
-        int i;
-
-        list_for_each_entry_rcu(adap, &adap_rcu_list, rcu_node)
-                for (i = 0; i < MAX_NPORTS; i++)
-                        if (adap->port[i] == netdev)
-                                return true;
-        return false;
-}
+#endif
+        if (event_dev->priv_flags & IFF_802_1Q_VLAN)
+                event_dev = vlan_dev_real_dev(event_dev);
+#if IS_ENABLED(CONFIG_BONDING)
+        if (event_dev->flags & IFF_MASTER) {
+                list_for_each_entry(adap, &adapter_list, list_node) {
+                        switch (event) {
+                        case NETDEV_UP:
+                                cxgb4_clip_get(adap->port[0],
+                                               (const u32 *)ifa, 1);
+                                break;
+                        case NETDEV_DOWN:
+                                cxgb4_clip_release(adap->port[0],
+                                                   (const u32 *)ifa, 1);
+                                break;
+                        default:
+                                break;
+                        }
+                }
+                return NOTIFY_OK;
+        }
+#endif
 
-static int clip_add(struct net_device *event_dev, struct inet6_ifaddr *ifa,
-                    unsigned long event)
-{
-        int ret = NOTIFY_DONE;
+        if (event_dev)
+                parent = event_dev->dev.parent;
 
-        rcu_read_lock();
-        if (cxgb4_netdev(event_dev)) {
+        if (parent && parent->driver == &cxgb4_driver.driver) {
                 switch (event) {
                 case NETDEV_UP:
-                        ret = cxgb4_clip_get(event_dev, &ifa->addr);
-                        if (ret < 0) {
-                                rcu_read_unlock();
-                                return ret;
-                        }
-                        ret = NOTIFY_OK;
+                        cxgb4_clip_get(event_dev, (const u32 *)ifa, 1);
                         break;
                 case NETDEV_DOWN:
-                        cxgb4_clip_release(event_dev, &ifa->addr);
-                        ret = NOTIFY_OK;
+                        cxgb4_clip_release(event_dev, (const u32 *)ifa, 1);
                         break;
                 default:
                         break;
                 }
         }
-        rcu_read_unlock();
-        return ret;
-}
-
-static int cxgb4_inet6addr_handler(struct notifier_block *this,
-                unsigned long event, void *data)
-{
-        struct inet6_ifaddr *ifa = data;
-        struct net_device *event_dev;
-        int ret = NOTIFY_DONE;
-        struct bonding *bond = netdev_priv(ifa->idev->dev);
-        struct list_head *iter;
-        struct slave *slave;
-        struct pci_dev *first_pdev = NULL;
-
-        if (ifa->idev->dev->priv_flags & IFF_802_1Q_VLAN) {
-                event_dev = vlan_dev_real_dev(ifa->idev->dev);
-                ret = clip_add(event_dev, ifa, event);
-        } else if (ifa->idev->dev->flags & IFF_MASTER) {
-                /* It is possible that two different adapters are bonded in one
-                 * bond. We need to find such different adapters and add clip
-                 * in all of them only once.
-                 */
-                bond_for_each_slave(bond, slave, iter) {
-                        if (!first_pdev) {
-                                ret = clip_add(slave->dev, ifa, event);
-                                /* If clip_add is success then only initialize
-                                 * first_pdev since it means it is our device
-                                 */
-                                if (ret == NOTIFY_OK)
-                                        first_pdev = to_pci_dev(
-                                                        slave->dev->dev.parent);
-                        } else if (first_pdev !=
-                                   to_pci_dev(slave->dev->dev.parent))
-                                        ret = clip_add(slave->dev, ifa, event);
-                }
-        } else
-                ret = clip_add(ifa->idev->dev, ifa, event);
-
-        return ret;
+        return NOTIFY_OK;
 }
 
+static bool inet6addr_registered;
 static struct notifier_block cxgb4_inet6addr_notifier = {
         .notifier_call = cxgb4_inet6addr_handler
 };
 
-/* Retrieves IPv6 addresses from a root device (bond, vlan) associated with
- * a physical device.
- * The physical device reference is needed to send the actul CLIP command.
- */
-static int update_dev_clip(struct net_device *root_dev, struct net_device *dev)
-{
-        struct inet6_dev *idev = NULL;
-        struct inet6_ifaddr *ifa;
-        int ret = 0;
-
-        idev = __in6_dev_get(root_dev);
-        if (!idev)
-                return ret;
-
-        read_lock_bh(&idev->lock);
-        list_for_each_entry(ifa, &idev->addr_list, if_list) {
-                ret = cxgb4_clip_get(dev, &ifa->addr);
-                if (ret < 0)
-                        break;
-        }
-        read_unlock_bh(&idev->lock);
-
-        return ret;
-}
-
-static int update_root_dev_clip(struct net_device *dev)
-{
-        struct net_device *root_dev = NULL;
-        int i, ret = 0;
-
-        /* First populate the real net device's IPv6 addresses */
-        ret = update_dev_clip(dev, dev);
-        if (ret)
-                return ret;
-
-        /* Parse all bond and vlan devices layered on top of the physical dev */
-        root_dev = netdev_master_upper_dev_get_rcu(dev);
-        if (root_dev) {
-                ret = update_dev_clip(root_dev, dev);
-                if (ret)
-                        return ret;
-        }
-
-        for (i = 0; i < VLAN_N_VID; i++) {
-                root_dev = __vlan_find_dev_deep_rcu(dev, htons(ETH_P_8021Q), i);
-                if (!root_dev)
-                        continue;
-
-                ret = update_dev_clip(root_dev, dev);
-                if (ret)
-                        break;
-        }
-        return ret;
-}
-
 static void update_clip(const struct adapter *adap)
 {
         int i;
@@ -4375,7 +4176,7 @@ static void update_clip(const struct adapter *adap)
                 ret = 0;
 
                 if (dev)
-                        ret = update_root_dev_clip(dev);
+                        ret = cxgb4_update_root_dev_clip(dev);
 
                 if (ret < 0)
                         break;
@@ -4567,13 +4368,13 @@ int cxgb4_create_server_filter(const struct net_device *dev, unsigned int stid,
                         f->fs.val.lip[i] = val[i];
                         f->fs.mask.lip[i] = ~0;
                 }
-                if (adap->params.tp.vlan_pri_map & F_PORT) {
+                if (adap->params.tp.vlan_pri_map & PORT_F) {
                         f->fs.val.iport = port;
                         f->fs.mask.iport = mask;
                 }
         }
 
-        if (adap->params.tp.vlan_pri_map & F_PROTOCOL) {
+        if (adap->params.tp.vlan_pri_map & PROTOCOL_F) {
                 f->fs.val.proto = IPPROTO_TCP;
                 f->fs.mask.proto = ~0;
         }
@@ -4779,11 +4580,15 @@ static const struct net_device_ops cxgb4_netdev_ops = {
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller  = cxgb_netpoll,
 #endif
+#ifdef CONFIG_NET_RX_BUSY_POLL
+        .ndo_busy_poll        = cxgb_busy_poll,
+#endif
+
 };
 
 void t4_fatal_err(struct adapter *adap)
 {
-        t4_set_reg_field(adap, SGE_CONTROL, GLOBALENABLE, 0);
+        t4_set_reg_field(adap, SGE_CONTROL_A, GLOBALENABLE_F, 0);
         t4_intr_disable(adap);
         dev_alert(adap->pdev_dev, "encountered fatal error, adapter stopped\n");
 }
@@ -4858,16 +4663,16 @@ static void setup_memwin(struct adapter *adap)
                 mem_win2_base = MEMWIN2_BASE_T5;
                 mem_win2_aperture = MEMWIN2_APERTURE_T5;
         }
-        t4_write_reg(adap, PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, 0),
-                     mem_win0_base | BIR(0) |
-                     WINDOW(ilog2(MEMWIN0_APERTURE) - 10));
-        t4_write_reg(adap, PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, 1),
-                     mem_win1_base | BIR(0) |
-                     WINDOW(ilog2(MEMWIN1_APERTURE) - 10));
-        t4_write_reg(adap, PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, 2),
-                     mem_win2_base | BIR(0) |
-                     WINDOW(ilog2(mem_win2_aperture) - 10));
-        t4_read_reg(adap, PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, 2));
+        t4_write_reg(adap, PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, 0),
+                     mem_win0_base | BIR_V(0) |
+                     WINDOW_V(ilog2(MEMWIN0_APERTURE) - 10));
+        t4_write_reg(adap, PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, 1),
+                     mem_win1_base | BIR_V(0) |
+                     WINDOW_V(ilog2(MEMWIN1_APERTURE) - 10));
+        t4_write_reg(adap, PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, 2),
+                     mem_win2_base | BIR_V(0) |
+                     WINDOW_V(ilog2(mem_win2_aperture) - 10));
+        t4_read_reg(adap, PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, 2));
 }
 
 static void setup_memwin_rdma(struct adapter *adap)
@@ -4881,13 +4686,13 @@ static void setup_memwin_rdma(struct adapter *adap)
                 start += OCQ_WIN_OFFSET(adap->pdev, &adap->vres);
                 sz_kb = roundup_pow_of_two(adap->vres.ocq.size) >> 10;
                 t4_write_reg(adap,
-                             PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, 3),
-                             start | BIR(1) | WINDOW(ilog2(sz_kb)));
+                             PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, 3),
+                             start | BIR_V(1) | WINDOW_V(ilog2(sz_kb)));
                 t4_write_reg(adap,
-                             PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET, 3),
+                             PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, 3),
                              adap->vres.ocq.start);
                 t4_read_reg(adap,
-                            PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET, 3));
+                            PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, 3));
         }
 }
 
@@ -4936,38 +4741,38 @@ static int adap_init1(struct adapter *adap, struct fw_caps_config_cmd *c)
         t4_sge_init(adap);
 
         /* tweak some settings */
-        t4_write_reg(adap, TP_SHIFT_CNT, 0x64f8849);
-        t4_write_reg(adap, ULP_RX_TDDP_PSZ, HPZ0(PAGE_SHIFT - 12));
-        t4_write_reg(adap, TP_PIO_ADDR, TP_INGRESS_CONFIG);
-        v = t4_read_reg(adap, TP_PIO_DATA);
-        t4_write_reg(adap, TP_PIO_DATA, v & ~CSUM_HAS_PSEUDO_HDR);
+        t4_write_reg(adap, TP_SHIFT_CNT_A, 0x64f8849);
+        t4_write_reg(adap, ULP_RX_TDDP_PSZ_A, HPZ0_V(PAGE_SHIFT - 12));
+        t4_write_reg(adap, TP_PIO_ADDR_A, TP_INGRESS_CONFIG_A);
+        v = t4_read_reg(adap, TP_PIO_DATA_A);
+        t4_write_reg(adap, TP_PIO_DATA_A, v & ~CSUM_HAS_PSEUDO_HDR_F);
 
         /* first 4 Tx modulation queues point to consecutive Tx channels */
         adap->params.tp.tx_modq_map = 0xE4;
-        t4_write_reg(adap, A_TP_TX_MOD_QUEUE_REQ_MAP,
-                     V_TX_MOD_QUEUE_REQ_MAP(adap->params.tp.tx_modq_map));
+        t4_write_reg(adap, TP_TX_MOD_QUEUE_REQ_MAP_A,
+                     TX_MOD_QUEUE_REQ_MAP_V(adap->params.tp.tx_modq_map));
 
         /* associate each Tx modulation queue with consecutive Tx channels */
         v = 0x84218421;
-        t4_write_indirect(adap, TP_PIO_ADDR, TP_PIO_DATA,
-                          &v, 1, A_TP_TX_SCHED_HDR);
-        t4_write_indirect(adap, TP_PIO_ADDR, TP_PIO_DATA,
-                          &v, 1, A_TP_TX_SCHED_FIFO);
-        t4_write_indirect(adap, TP_PIO_ADDR, TP_PIO_DATA,
-                          &v, 1, A_TP_TX_SCHED_PCMD);
+        t4_write_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A,
+                          &v, 1, TP_TX_SCHED_HDR_A);
+        t4_write_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A,
+                          &v, 1, TP_TX_SCHED_FIFO_A);
+        t4_write_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A,
+                          &v, 1, TP_TX_SCHED_PCMD_A);
 
 #define T4_TX_MODQ_10G_WEIGHT_DEFAULT 16 /* in KB units */
         if (is_offload(adap)) {
-                t4_write_reg(adap, A_TP_TX_MOD_QUEUE_WEIGHT0,
-                             V_TX_MODQ_WEIGHT0(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
-                             V_TX_MODQ_WEIGHT1(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
-                             V_TX_MODQ_WEIGHT2(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
-                             V_TX_MODQ_WEIGHT3(T4_TX_MODQ_10G_WEIGHT_DEFAULT));
-                t4_write_reg(adap, A_TP_TX_MOD_CHANNEL_WEIGHT,
-                             V_TX_MODQ_WEIGHT0(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
-                             V_TX_MODQ_WEIGHT1(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
-                             V_TX_MODQ_WEIGHT2(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
-                             V_TX_MODQ_WEIGHT3(T4_TX_MODQ_10G_WEIGHT_DEFAULT));
+                t4_write_reg(adap, TP_TX_MOD_QUEUE_WEIGHT0_A,
+                             TX_MODQ_WEIGHT0_V(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
+                             TX_MODQ_WEIGHT1_V(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
+                             TX_MODQ_WEIGHT2_V(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
+                             TX_MODQ_WEIGHT3_V(T4_TX_MODQ_10G_WEIGHT_DEFAULT));
+                t4_write_reg(adap, TP_TX_MOD_CHANNEL_WEIGHT_A,
+                             TX_MODQ_WEIGHT0_V(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
+                             TX_MODQ_WEIGHT1_V(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
+                             TX_MODQ_WEIGHT2_V(T4_TX_MODQ_10G_WEIGHT_DEFAULT) |
+                             TX_MODQ_WEIGHT3_V(T4_TX_MODQ_10G_WEIGHT_DEFAULT));
         }
 
         /* get basic stuff going */
@@ -5013,16 +4818,16 @@ static int adap_init0_tweaks(struct adapter *adapter)
                         rx_dma_offset);
                 rx_dma_offset = 2;
         }
-        t4_set_reg_field(adapter, SGE_CONTROL,
-                         PKTSHIFT_MASK,
-                         PKTSHIFT(rx_dma_offset));
+        t4_set_reg_field(adapter, SGE_CONTROL_A,
+                         PKTSHIFT_V(PKTSHIFT_M),
+                         PKTSHIFT_V(rx_dma_offset));
 
         /*
          * Don't include the "IP Pseudo Header" in CPL_RX_PKT checksums: Linux
          * adds the pseudo header itself.
          */
-        t4_tp_wr_bits_indirect(adapter, TP_INGRESS_CONFIG,
-                               CSUM_HAS_PSEUDO_HDR, 0);
+        t4_tp_wr_bits_indirect(adapter, TP_INGRESS_CONFIG_A,
+                               CSUM_HAS_PSEUDO_HDR_F, 0);
 
         return 0;
 }
@@ -5046,7 +4851,7 @@ static int adap_init0_config(struct adapter *adapter, int reset)
          */
         if (reset) {
                 ret = t4_fw_reset(adapter, adapter->mbox,
-                                  PIORSTMODE | PIORST);
+                                  PIORSTMODE_F | PIORST_F);
                 if (ret < 0)
                         goto bye;
         }
@@ -5212,12 +5017,9 @@ static int adap_init0_config(struct adapter *adapter, int reset)
         if (ret < 0)
                 goto bye;
 
-        /*
-         * Return successfully and note that we're operating with parameters
-         * not supplied by the driver, rather than from hard-wired
-         * initialization constants burried in the driver.
+        /* Emit Firmware Configuration File information and return
+         * successfully.
          */
-        adapter->flags |= USING_SOFT_PARAMS;
         dev_info(adapter->pdev_dev, "Successfully configured using Firmware "\
                  "Configuration File \"%s\", version %#x, computed checksum %#x\n",
                  config_name, finiver, cfcsum);
@@ -5235,249 +5037,6 @@ bye:
         return ret;
 }
 
-/*
- * Attempt to initialize the adapter via hard-coded, driver supplied
- * parameters ...
- */
-static int adap_init0_no_config(struct adapter *adapter, int reset)
-{
-        struct sge *s = &adapter->sge;
-        struct fw_caps_config_cmd caps_cmd;
-        u32 v;
-        int i, ret;
-
-        /*
-         * Reset device if necessary
-         */
-        if (reset) {
-                ret = t4_fw_reset(adapter, adapter->mbox,
-                                  PIORSTMODE | PIORST);
-                if (ret < 0)
-                        goto bye;
-        }
-
-        /*
-         * Get device capabilities and select which we'll be using.
-         */
-        memset(&caps_cmd, 0, sizeof(caps_cmd));
-        caps_cmd.op_to_write = htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
-                                     FW_CMD_REQUEST_F | FW_CMD_READ_F);
-        caps_cmd.cfvalid_to_len16 = htonl(FW_LEN16(caps_cmd));
-        ret = t4_wr_mbox(adapter, adapter->mbox, &caps_cmd, sizeof(caps_cmd),
-                         &caps_cmd);
-        if (ret < 0)
-                goto bye;
-
-        if (caps_cmd.niccaps & htons(FW_CAPS_CONFIG_NIC_VM)) {
-                if (!vf_acls)
-                        caps_cmd.niccaps ^= htons(FW_CAPS_CONFIG_NIC_VM);
-                else
-                        caps_cmd.niccaps = htons(FW_CAPS_CONFIG_NIC_VM);
-        } else if (vf_acls) {
-                dev_err(adapter->pdev_dev, "virtualization ACLs not supported");
-                goto bye;
-        }
-        caps_cmd.op_to_write = htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
-                              FW_CMD_REQUEST_F | FW_CMD_WRITE_F);
-        ret = t4_wr_mbox(adapter, adapter->mbox, &caps_cmd, sizeof(caps_cmd),
-                         NULL);
-        if (ret < 0)
-                goto bye;
-
-        /*
-         * Tweak configuration based on system architecture, module
-         * parameters, etc.
-         */
-        ret = adap_init0_tweaks(adapter);
-        if (ret < 0)
-                goto bye;
-
-        /*
-         * Select RSS Global Mode we want to use.  We use "Basic Virtual"
-         * mode which maps each Virtual Interface to its own section of
-         * the RSS Table and we turn on all map and hash enables ...
-         */
-        adapter->flags |= RSS_TNLALLLOOKUP;
-        ret = t4_config_glbl_rss(adapter, adapter->mbox,
-                                 FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL,
-                                 FW_RSS_GLB_CONFIG_CMD_TNLMAPEN_F |
-                                 FW_RSS_GLB_CONFIG_CMD_HASHTOEPLITZ_F |
-                                 ((adapter->flags & RSS_TNLALLLOOKUP) ?
-                                        FW_RSS_GLB_CONFIG_CMD_TNLALLLKP_F : 0));
-        if (ret < 0)
-                goto bye;
-
-        /*
-         * Set up our own fundamental resource provisioning ...
-         */
-        ret = t4_cfg_pfvf(adapter, adapter->mbox, adapter->fn, 0,
-                          PFRES_NEQ, PFRES_NETHCTRL,
-                          PFRES_NIQFLINT, PFRES_NIQ,
-                          PFRES_TC, PFRES_NVI,
-                          FW_PFVF_CMD_CMASK_M,
-                          pfvfres_pmask(adapter, adapter->fn, 0),
-                          PFRES_NEXACTF,
-                          PFRES_R_CAPS, PFRES_WX_CAPS);
-        if (ret < 0)
-                goto bye;
-
-        /*
-         * Perform low level SGE initialization.  We need to do this before we
-         * send the firmware the INITIALIZE command because that will cause
-         * any other PF Drivers which are waiting for the Master
-         * Initialization to proceed forward.
-         */
-        for (i = 0; i < SGE_NTIMERS - 1; i++)
-                s->timer_val[i] = min(intr_holdoff[i], MAX_SGE_TIMERVAL);
-        s->timer_val[SGE_NTIMERS - 1] = MAX_SGE_TIMERVAL;
-        s->counter_val[0] = 1;
-        for (i = 1; i < SGE_NCOUNTERS; i++)
-                s->counter_val[i] = min(intr_cnt[i - 1],
-                                        THRESHOLD_0_GET(THRESHOLD_0_MASK));
-        t4_sge_init(adapter);
-
-#ifdef CONFIG_PCI_IOV
-        /*
-         * Provision resource limits for Virtual Functions.  We currently
-         * grant them all the same static resource limits except for the Port
-         * Access Rights Mask which we're assigning based on the PF.  All of
-         * the static provisioning stuff for both the PF and VF really needs
-         * to be managed in a persistent manner for each device which the
-         * firmware controls.
-         */
-        {
-                int pf, vf;
-
-                for (pf = 0; pf < ARRAY_SIZE(num_vf); pf++) {
-                        if (num_vf[pf] <= 0)
-                                continue;
-
-                        /* VF numbering starts at 1! */
-                        for (vf = 1; vf <= num_vf[pf]; vf++) {
-                                ret = t4_cfg_pfvf(adapter, adapter->mbox,
-                                                  pf, vf,
-                                                  VFRES_NEQ, VFRES_NETHCTRL,
-                                                  VFRES_NIQFLINT, VFRES_NIQ,
-                                                  VFRES_TC, VFRES_NVI,
-                                                  FW_PFVF_CMD_CMASK_M,
-                                                  pfvfres_pmask(
-                                                  adapter, pf, vf),
-                                                  VFRES_NEXACTF,
-                                                  VFRES_R_CAPS, VFRES_WX_CAPS);
-                                if (ret < 0)
-                                        dev_warn(adapter->pdev_dev,
-                                                 "failed to "\
-                                                 "provision pf/vf=%d/%d; "
-                                                 "err=%d\n", pf, vf, ret);
-                        }
-                }
-        }
-#endif
-
-        /*
-         * Set up the default filter mode.  Later we'll want to implement this
-         * via a firmware command, etc. ...  This needs to be done before the
-         * firmare initialization command ...  If the selected set of fields
-         * isn't equal to the default value, we'll need to make sure that the
-         * field selections will fit in the 36-bit budget.
-         */
-        if (tp_vlan_pri_map != TP_VLAN_PRI_MAP_DEFAULT) {
-                int j, bits = 0;
-
-                for (j = TP_VLAN_PRI_MAP_FIRST; j <= TP_VLAN_PRI_MAP_LAST; j++)
-                        switch (tp_vlan_pri_map & (1 << j)) {
-                        case 0:
-                                /* compressed filter field not enabled */
-                                break;
-                        case FCOE_MASK:
-                                bits +=  1;
-                                break;
-                        case PORT_MASK:
-                                bits +=  3;
-                                break;
-                        case VNIC_ID_MASK:
-                                bits += 17;
-                                break;
-                        case VLAN_MASK:
-                                bits += 17;
-                                break;
-                        case TOS_MASK:
-                                bits +=  8;
-                                break;
-                        case PROTOCOL_MASK:
-                                bits +=  8;
-                                break;
-                        case ETHERTYPE_MASK:
-                                bits += 16;
-                                break;
-                        case MACMATCH_MASK:
-                                bits +=  9;
-                                break;
-                        case MPSHITTYPE_MASK:
-                                bits +=  3;
-                                break;
-                        case FRAGMENTATION_MASK:
-                                bits +=  1;
-                                break;
-                        }
-
-                if (bits > 36) {
-                        dev_err(adapter->pdev_dev,
-                                "tp_vlan_pri_map=%#x needs %d bits > 36;"\
-                                " using %#x\n", tp_vlan_pri_map, bits,
-                                TP_VLAN_PRI_MAP_DEFAULT);
-                        tp_vlan_pri_map = TP_VLAN_PRI_MAP_DEFAULT;
-                }
-        }
-        v = tp_vlan_pri_map;
-        t4_write_indirect(adapter, TP_PIO_ADDR, TP_PIO_DATA,
-                          &v, 1, TP_VLAN_PRI_MAP);
-
-        /*
-         * We need Five Tuple Lookup mode to be set in TP_GLOBAL_CONFIG order
-         * to support any of the compressed filter fields above.  Newer
-         * versions of the firmware do this automatically but it doesn't hurt
-         * to set it here.  Meanwhile, we do _not_ need to set Lookup Every
-         * Packet in TP_INGRESS_CONFIG to support matching non-TCP packets
-         * since the firmware automatically turns this on and off when we have
-         * a non-zero number of filters active (since it does have a
-         * performance impact).
-         */
-        if (tp_vlan_pri_map)
-                t4_set_reg_field(adapter, TP_GLOBAL_CONFIG,
-                                 FIVETUPLELOOKUP_MASK,
-                                 FIVETUPLELOOKUP_MASK);
-
-        /*
-         * Tweak some settings.
-         */
-        t4_write_reg(adapter, TP_SHIFT_CNT, SYNSHIFTMAX(6) |
-                     RXTSHIFTMAXR1(4) | RXTSHIFTMAXR2(15) |
-                     PERSHIFTBACKOFFMAX(8) | PERSHIFTMAX(8) |
-                     KEEPALIVEMAXR1(4) | KEEPALIVEMAXR2(9));
-
-        /*
-         * Get basic stuff going by issuing the Firmware Initialize command.
-         * Note that this _must_ be after all PFVF commands ...
-         */
-        ret = t4_fw_initialize(adapter, adapter->mbox);
-        if (ret < 0)
-                goto bye;
-
-        /*
-         * Return successfully!
-         */
-        dev_info(adapter->pdev_dev, "Successfully configured using built-in "\
-                 "driver parameters\n");
-        return 0;
-
-        /*
-         * Something bad happened.  Return the error ...
-         */
-bye:
-        return ret;
-}
-
 static struct fw_info fw_info_array[] = {
         {
                 .chip = CHELSIO_T4,
@@ -5529,6 +5088,8 @@ static int adap_init0(struct adapter *adap)
         enum dev_state state;
         u32 params[7], val[7];
         struct fw_caps_config_cmd caps_cmd;
+        struct fw_devlog_cmd devlog_cmd;
+        u32 devlog_meminfo;
         int reset = 1;
 
         /* Contact FW, advertising Master capability */
@@ -5590,8 +5151,7 @@ static int adap_init0(struct adapter *adap)
                                  state, &reset);
 
                 /* Cleaning up */
-                if (fw != NULL)
-                        release_firmware(fw);
+                release_firmware(fw);
                 t4_free_mem(card_fw);
 
                 if (ret < 0)
@@ -5609,6 +5169,30 @@ static int adap_init0(struct adapter *adap)
         if (ret < 0)
                 goto bye;
 
+        /* Read firmware device log parameters.  We really need to find a way
+         * to get these parameters initialized with some default values (which
+         * are likely to be correct) for the case where we either don't
+         * attache to the firmware or it's crashed when we probe the adapter.
+         * That way we'll still be able to perform early firmware startup
+         * debugging ...  If the request to get the Firmware's Device Log
+         * parameters fails, we'll live so we don't make that a fatal error.
+         */
+        memset(&devlog_cmd, 0, sizeof(devlog_cmd));
+        devlog_cmd.op_to_write = htonl(FW_CMD_OP_V(FW_DEVLOG_CMD) |
+                                       FW_CMD_REQUEST_F | FW_CMD_READ_F);
+        devlog_cmd.retval_len16 = htonl(FW_LEN16(devlog_cmd));
+        ret = t4_wr_mbox(adap, adap->mbox, &devlog_cmd, sizeof(devlog_cmd),
+                         &devlog_cmd);
+        if (ret == 0) {
+                devlog_meminfo =
+                        ntohl(devlog_cmd.memtype_devlog_memaddr16_devlog);
+                adap->params.devlog.memtype =
+                        FW_DEVLOG_CMD_MEMTYPE_DEVLOG_G(devlog_meminfo);
+                adap->params.devlog.start =
+                        FW_DEVLOG_CMD_MEMADDR16_DEVLOG_G(devlog_meminfo) << 4;
+                adap->params.devlog.size = ntohl(devlog_cmd.memsize_devlog);
+        }
+
         /*
          * Find out what ports are available to us.  Note that we need to do
          * this before calling adap_init0_no_config() since it needs nports
@@ -5624,88 +5208,58 @@ static int adap_init0(struct adapter *adap)
         adap->params.nports = hweight32(port_vec);
         adap->params.portvec = port_vec;
 
-        /*
-         * If the firmware is initialized already (and we're not forcing a
-         * master initialization), note that we're living with existing
-         * adapter parameters.  Otherwise, it's time to try initializing the
-         * adapter ...
+        /* If the firmware is initialized already, emit a simply note to that
+         * effect. Otherwise, it's time to try initializing the adapter.
          */
         if (state == DEV_STATE_INIT) {
                 dev_info(adap->pdev_dev, "Coming up as %s: "\
                          "Adapter already initialized\n",
                          adap->flags & MASTER_PF ? "MASTER" : "SLAVE");
-                adap->flags |= USING_SOFT_PARAMS;
         } else {
                 dev_info(adap->pdev_dev, "Coming up as MASTER: "\
                          "Initializing adapter\n");
-                /*
-                 * If the firmware doesn't support Configuration
-                 * Files warn user and exit,
+
+                /* Find out whether we're dealing with a version of the
+                 * firmware which has configuration file support.
                  */
-                if (ret < 0)
-                        dev_warn(adap->pdev_dev, "Firmware doesn't support "
-                                 "configuration file.\n");
-                if (force_old_init)
-                        ret = adap_init0_no_config(adap, reset);
-                else {
-                        /*
-                         * Find out whether we're dealing with a version of
-                         * the firmware which has configuration file support.
-                         */
-                        params[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
-                                     FW_PARAMS_PARAM_X_V(
-                                             FW_PARAMS_PARAM_DEV_CF));
-                        ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 1,
-                                              params, val);
-
-                        /*
-                         * If the firmware doesn't support Configuration
-                         * Files, use the old Driver-based, hard-wired
-                         * initialization.  Otherwise, try using the
-                         * Configuration File support and fall back to the
-                         * Driver-based initialization if there's no
-                         * Configuration File found.
-                         */
-                        if (ret < 0)
-                                ret = adap_init0_no_config(adap, reset);
-                        else {
-                                /*
-                                 * The firmware provides us with a memory
-                                 * buffer where we can load a Configuration
-                                 * File from the host if we want to override
-                                 * the Configuration File in flash.
-                                 */
+                params[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
+                             FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_CF));
+                ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 1,
+                                      params, val);
 
-                                ret = adap_init0_config(adap, reset);
-                                if (ret == -ENOENT) {
-                                        dev_info(adap->pdev_dev,
-                                            "No Configuration File present "
-                                            "on adapter. Using hard-wired "
-                                            "configuration parameters.\n");
-                                        ret = adap_init0_no_config(adap, reset);
-                                }
-                        }
+                /* If the firmware doesn't support Configuration Files,
+                 * return an error.
+                 */
+                if (ret < 0) {
+                        dev_err(adap->pdev_dev, "firmware doesn't support "
+                                "Firmware Configuration Files\n");
+                        goto bye;
+                }
+
+                /* The firmware provides us with a memory buffer where we can
+                 * load a Configuration File from the host if we want to
+                 * override the Configuration File in flash.
+                 */
+                ret = adap_init0_config(adap, reset);
+                if (ret == -ENOENT) {
+                        dev_err(adap->pdev_dev, "no Configuration File "
+                                "present on adapter.\n");
+                        goto bye;
                 }
                 if (ret < 0) {
-                        dev_err(adap->pdev_dev,
-                                "could not initialize adapter, error %d\n",
-                                -ret);
+                        dev_err(adap->pdev_dev, "could not initialize "
+                                "adapter, error %d\n", -ret);
                         goto bye;
                 }
         }
 
-        /*
-         * If we're living with non-hard-coded parameters (either from a
-         * Firmware Configuration File or values programmed by a different PF
-         * Driver), give the SGE code a chance to pull in anything that it
-         * needs ...  Note that this must be called after we retrieve our VPD
-         * parameters in order to know how to convert core ticks to seconds.
+        /* Give the SGE code a chance to pull in anything that it needs ...
+         * Note that this must be called after we retrieve our VPD parameters
+         * in order to know how to convert core ticks to seconds, etc.
          */
-        if (adap->flags & USING_SOFT_PARAMS) {
-                ret = t4_sge_init(adap);
-                if (ret < 0)
-                        goto bye;
-        }
+        ret = t4_sge_init(adap);
+        if (ret < 0)
+                goto bye;
 
         if (is_bypass_device(adap->pdev->device))
                 adap->params.bypass = 1;
@@ -5739,6 +5293,14 @@ static int adap_init0(struct adapter *adap)
         adap->tids.nftids = val[4] - val[3] + 1;
         adap->sge.ingr_start = val[5];
 
+        params[0] = FW_PARAM_PFVF(CLIP_START);
+        params[1] = FW_PARAM_PFVF(CLIP_END);
+        ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 2, params, val);
+        if (ret < 0)
+                goto bye;
+        adap->clipt_start = val[0];
+        adap->clipt_end = val[1];
+
         /* query params related to active filter region */
         params[0] = FW_PARAM_PFVF(ACTIVE_FILTER_START);
         params[1] = FW_PARAM_PFVF(ACTIVE_FILTER_END);
@@ -6401,7 +5963,7 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto out_unmap_bar0;
 
         /* We control everything through one PF */
-        func = SOURCEPF_GET(readl(regs + PL_WHOAMI));
+        func = SOURCEPF_G(readl(regs + PL_WHOAMI_A));
         if (func != ent->driver_data) {
                 iounmap(regs);
                 pci_disable_device(pdev);
@@ -6467,9 +6029,11 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
 
         if (!is_t4(adapter->params.chip)) {
-                s_qpp = QUEUESPERPAGEPF1 * adapter->fn;
-                qpp = 1 << QUEUESPERPAGEPF0_GET(t4_read_reg(adapter,
-                      SGE_EGRESS_QUEUES_PER_PAGE_PF) >> s_qpp);
+                s_qpp = (QUEUESPERPAGEPF0_S +
+                        (QUEUESPERPAGEPF1_S - QUEUESPERPAGEPF0_S) *
+                        adapter->fn);
+                qpp = 1 << QUEUESPERPAGEPF0_G(t4_read_reg(adapter,
+                      SGE_EGRESS_QUEUES_PER_PAGE_PF_A) >> s_qpp);
                 num_seg = PAGE_SIZE / SEGMENT_SIZE;
 
                 /* Each segment size is 128B. Write coalescing is enabled only
@@ -6557,6 +6121,18 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 adapter->params.offload = 0;
         }
 
+#if IS_ENABLED(CONFIG_IPV6)
+        adapter->clipt = t4_init_clip_tbl(adapter->clipt_start,
+                                          adapter->clipt_end);
+        if (!adapter->clipt) {
+                /* We tolerate a lack of clip_table, giving up
+                 * some functionality
+                 */
+                dev_warn(&pdev->dev,
+                         "could not allocate Clip table, continuing\n");
+                adapter->params.offload = 0;
+        }
+#endif
         if (is_offload(adapter) && tid_init(&adapter->tids) < 0) {
                 dev_warn(&pdev->dev, "could not allocate TID table, "
                          "continuing\n");
@@ -6682,6 +6258,9 @@ static void remove_one(struct pci_dev *pdev)
                         cxgb_down(adapter);
 
                 free_some_resources(adapter);
+#if IS_ENABLED(CONFIG_IPV6)
+                t4_cleanup_clip_tbl(adapter);
+#endif
                 iounmap(adapter->regs);
                 if (!is_t4(adapter->params.chip))
                         iounmap(adapter->bar2);
@@ -6720,7 +6299,10 @@ static int __init cxgb4_init_module(void)
                 debugfs_remove(cxgb4_debugfs_root);
 
 #if IS_ENABLED(CONFIG_IPV6)
-        register_inet6addr_notifier(&cxgb4_inet6addr_notifier);
+        if (!inet6addr_registered) {
+                register_inet6addr_notifier(&cxgb4_inet6addr_notifier);
+                inet6addr_registered = true;
+        }
 #endif
 
         return ret;
@@ -6729,7 +6311,10 @@ static int __init cxgb4_init_module(void)
 static void __exit cxgb4_cleanup_module(void)
 {
 #if IS_ENABLED(CONFIG_IPV6)
-        unregister_inet6addr_notifier(&cxgb4_inet6addr_notifier);
+        if (inet6addr_registered) {
+                unregister_inet6addr_notifier(&cxgb4_inet6addr_notifier);
+                inet6addr_registered = false;
+        }
 #endif
         pci_unregister_driver(&cxgb4_driver);
         debugfs_remove(cxgb4_debugfs_root);  /* NULL ok */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
index 152b4c4c7809..78ab4d406ce2 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
@@ -173,9 +173,6 @@ int cxgb4_create_server_filter(const struct net_device *dev, unsigned int stid,
                                unsigned char port, unsigned char mask);
 int cxgb4_remove_server_filter(const struct net_device *dev, unsigned int stid,
                                unsigned int queue, bool ipv6);
-int cxgb4_clip_get(const struct net_device *dev, const struct in6_addr *lip);
-int cxgb4_clip_release(const struct net_device *dev,
-                       const struct in6_addr *lip);
 
 static inline void set_wr_txq(struct sk_buff *skb, int prio, int queue)
 {
diff --git a/drivers/net/ethernet/chelsio/cxgb4/l2t.c b/drivers/net/ethernet/chelsio/cxgb4/l2t.c
index a047baa9fd04..252efc29321f 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/l2t.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/l2t.c
@@ -46,6 +46,7 @@
 #include "t4_msg.h"
 #include "t4fw_api.h"
 #include "t4_regs.h"
+#include "t4_values.h"
 
 #define VLAN_NONE 0xfff
 
@@ -150,8 +151,8 @@ static int write_l2e(struct adapter *adap, struct l2t_entry *e, int sync)
 
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_L2T_WRITE_REQ,
                                         e->idx | (sync ? F_SYNC_WR : 0) |
-                                        TID_QID(adap->sge.fw_evtq.abs_id)));
-        req->params = htons(L2T_W_PORT(e->lport) | L2T_W_NOREPLY(!sync));
+                                        TID_QID_V(adap->sge.fw_evtq.abs_id)));
+        req->params = htons(L2T_W_PORT_V(e->lport) | L2T_W_NOREPLY_V(!sync));
         req->l2t_idx = htons(e->idx);
         req->vlan = htons(e->vlan);
         if (e->neigh && !(e->neigh->dev->flags & IFF_LOOPBACK))
@@ -425,7 +426,7 @@ u64 cxgb4_select_ntuple(struct net_device *dev,
          * in the Compressed Filter Tuple.
          */
         if (tp->vlan_shift >= 0 && l2t->vlan != VLAN_NONE)
-                ntuple |= (u64)(F_FT_VLAN_VLD | l2t->vlan) << tp->vlan_shift;
+                ntuple |= (u64)(FT_VLAN_VLD_F | l2t->vlan) << tp->vlan_shift;
 
         if (tp->port_shift >= 0)
                 ntuple |= (u64)l2t->lport << tp->port_shift;
@@ -439,9 +440,9 @@ u64 cxgb4_select_ntuple(struct net_device *dev,
                 u32 pf = FW_VIID_PFN_G(viid);
                 u32 vld = FW_VIID_VIVLD_G(viid);
 
-                ntuple |= (u64)(V_FT_VNID_ID_VF(vf) |
-                                V_FT_VNID_ID_PF(pf) |
-                                V_FT_VNID_ID_VLD(vld)) << tp->vnic_shift;
+                ntuple |= (u64)(FT_VNID_ID_VF_V(vf) |
+                                FT_VNID_ID_PF_V(pf) |
+                                FT_VNID_ID_VLD_V(vld)) << tp->vnic_shift;
         }
 
         return ntuple;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/sge.c b/drivers/net/ethernet/chelsio/cxgb4/sge.c
index ebf935a1e352..b4b9f6048fe7 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/sge.c
@@ -43,8 +43,12 @@
 #include <linux/export.h>
 #include <net/ipv6.h>
 #include <net/tcp.h>
+#ifdef CONFIG_NET_RX_BUSY_POLL
+#include <net/busy_poll.h>
+#endif /* CONFIG_NET_RX_BUSY_POLL */
 #include "cxgb4.h"
 #include "t4_regs.h"
+#include "t4_values.h"
 #include "t4_msg.h"
 #include "t4fw_api.h"
 
@@ -521,10 +525,12 @@ static inline void ring_fl_db(struct adapter *adap, struct sge_fl *q)
 {
         u32 val;
         if (q->pend_cred >= 8) {
-                val = PIDX(q->pend_cred / 8);
-                if (!is_t4(adap->params.chip))
-                        val |= DBTYPE(1);
-                val |= DBPRIO(1);
+                if (is_t4(adap->params.chip))
+                        val = PIDX_V(q->pend_cred / 8);
+                else
+                        val = PIDX_T5_V(q->pend_cred / 8) |
+                                DBTYPE_F;
+                val |= DBPRIO_F;
                 wmb();
 
                 /* If we don't have access to the new User Doorbell (T5+), use
@@ -532,10 +538,10 @@ static inline void ring_fl_db(struct adapter *adap, struct sge_fl *q)
                  * mechanism.
                  */
                 if (unlikely(q->bar2_addr == NULL)) {
-                        t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL),
-                                     val | QID(q->cntxt_id));
+                        t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL_A),
+                                     val | QID_V(q->cntxt_id));
                 } else {
-                        writel(val | QID(q->bar2_qid),
+                        writel(val | QID_V(q->bar2_qid),
                                q->bar2_addr + SGE_UDB_KDOORBELL);
 
                         /* This Write memory Barrier will force the write to
@@ -818,7 +824,8 @@ static void write_sgl(const struct sk_buff *skb, struct sge_txq *q,
                 sgl->addr0 = cpu_to_be64(addr[1]);
         }
 
-        sgl->cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) | ULPTX_NSGE(nfrags));
+        sgl->cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) |
+                              ULPTX_NSGE_V(nfrags));
         if (likely(--nfrags == 0))
                 return;
         /*
@@ -884,7 +891,7 @@ static inline void ring_tx_db(struct adapter *adap, struct sge_txq *q, int n)
          * doorbell mechanism; otherwise use the new BAR2 mechanism.
          */
         if (unlikely(q->bar2_addr == NULL)) {
-                u32 val = PIDX(n);
+                u32 val = PIDX_V(n);
                 unsigned long flags;
 
                 /* For T4 we need to participate in the Doorbell Recovery
@@ -892,14 +899,14 @@ static inline void ring_tx_db(struct adapter *adap, struct sge_txq *q, int n)
                  */
                 spin_lock_irqsave(&q->db_lock, flags);
                 if (!q->db_disabled)
-                        t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL),
-                                     QID(q->cntxt_id) | val);
+                        t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL_A),
+                                     QID_V(q->cntxt_id) | val);
                 else
                         q->db_pidx_inc += n;
                 q->db_pidx = q->pidx;
                 spin_unlock_irqrestore(&q->db_lock, flags);
         } else {
-                u32 val = PIDX_T5(n);
+                u32 val = PIDX_T5_V(n);
 
                 /* T4 and later chips share the same PIDX field offset within
                  * the doorbell, but T5 and later shrank the field in order to
@@ -907,7 +914,7 @@ static inline void ring_tx_db(struct adapter *adap, struct sge_txq *q, int n)
                  * large in the first place (14 bits) so we just use the T5
                  * and later limits and warn if a Queue ID is too large.
                  */
-                WARN_ON(val & DBPRIO(1));
+                WARN_ON(val & DBPRIO_F);
 
                 /* If we're only writing a single TX Descriptor and we can use
                  * Inferred QID registers, we can use the Write Combining
@@ -923,7 +930,7 @@ static inline void ring_tx_db(struct adapter *adap, struct sge_txq *q, int n)
                                       (q->bar2_addr + SGE_UDB_WCDOORBELL),
                                       wr);
                 } else {
-                        writel(val | QID(q->bar2_qid),
+                        writel(val | QID_V(q->bar2_qid),
                                q->bar2_addr + SGE_UDB_KDOORBELL);
                 }
 
@@ -1150,9 +1157,9 @@ out_free:	dev_kfree_skb_any(skb);
                         cntrl = TXPKT_L4CSUM_DIS | TXPKT_IPCSUM_DIS;
         }
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 q->vlan_ins++;
-                cntrl |= TXPKT_VLAN_VLD | TXPKT_VLAN(vlan_tx_tag_get(skb));
+                cntrl |= TXPKT_VLAN_VLD | TXPKT_VLAN(skb_vlan_tag_get(skb));
         }
 
         cpl->ctrl0 = htonl(TXPKT_OPCODE(CPL_TX_PKT_XT) |
@@ -1716,6 +1723,7 @@ static void do_gro(struct sge_eth_rxq *rxq, const struct pkt_gl *gl,
         skb->truesize += skb->data_len;
         skb->ip_summed = CHECKSUM_UNNECESSARY;
         skb_record_rx_queue(skb, rxq->rspq.idx);
+        skb_mark_napi_id(skb, &rxq->rspq.napi);
         if (rxq->rspq.netdev->features & NETIF_F_RXHASH)
                 skb_set_hash(skb, (__force u32)pkt->rsshdr.hash_val,
                              PKT_HASH_TYPE_L3);
@@ -1758,7 +1766,8 @@ int t4_ethrx_handler(struct sge_rspq *q, const __be64 *rsp,
         pkt = (const struct cpl_rx_pkt *)rsp;
         csum_ok = pkt->csum_calc && !pkt->err_vec &&
                   (q->netdev->features & NETIF_F_RXCSUM);
-        if ((pkt->l2info & htonl(RXF_TCP)) &&
+        if ((pkt->l2info & htonl(RXF_TCP_F)) &&
+            !(cxgb_poll_busy_polling(q)) &&
             (q->netdev->features & NETIF_F_GRO) && csum_ok && !pkt->ip_frag) {
                 do_gro(rxq, si, pkt);
                 return 0;
@@ -1780,11 +1789,11 @@ int t4_ethrx_handler(struct sge_rspq *q, const __be64 *rsp,
 
         rxq->stats.pkts++;
 
-        if (csum_ok && (pkt->l2info & htonl(RXF_UDP | RXF_TCP))) {
+        if (csum_ok && (pkt->l2info & htonl(RXF_UDP_F | RXF_TCP_F))) {
                 if (!pkt->ip_frag) {
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
                         rxq->stats.rx_cso++;
-                } else if (pkt->l2info & htonl(RXF_IP)) {
+                } else if (pkt->l2info & htonl(RXF_IP_F)) {
                         __sum16 c = (__force __sum16)pkt->csum;
                         skb->csum = csum_unfold(c);
                         skb->ip_summed = CHECKSUM_COMPLETE;
@@ -1797,6 +1806,7 @@ int t4_ethrx_handler(struct sge_rspq *q, const __be64 *rsp,
                 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ntohs(pkt->vlan));
                 rxq->stats.vlan_ex++;
         }
+        skb_mark_napi_id(skb, &q->napi);
         netif_receive_skb(skb);
         return 0;
 }
@@ -1959,6 +1969,38 @@ static int process_responses(struct sge_rspq *q, int budget)
         return budget - budget_left;
 }
 
+#ifdef CONFIG_NET_RX_BUSY_POLL
+int cxgb_busy_poll(struct napi_struct *napi)
+{
+        struct sge_rspq *q = container_of(napi, struct sge_rspq, napi);
+        unsigned int params, work_done;
+        u32 val;
+
+        if (!cxgb_poll_lock_poll(q))
+                return LL_FLUSH_BUSY;
+
+        work_done = process_responses(q, 4);
+        params = QINTR_TIMER_IDX(TIMERREG_COUNTER0_X) | QINTR_CNT_EN;
+        q->next_intr_params = params;
+        val = CIDXINC_V(work_done) | SEINTARM_V(params);
+
+        /* If we don't have access to the new User GTS (T5+), use the old
+         * doorbell mechanism; otherwise use the new BAR2 mechanism.
+         */
+        if (unlikely(!q->bar2_addr))
+                t4_write_reg(q->adap, MYPF_REG(SGE_PF_GTS_A),
+                             val | INGRESSQID_V((u32)q->cntxt_id));
+        else {
+                writel(val | INGRESSQID_V(q->bar2_qid),
+                       q->bar2_addr + SGE_UDB_GTS);
+                wmb();
+        }
+
+        cxgb_poll_unlock_poll(q);
+        return work_done;
+}
+#endif /* CONFIG_NET_RX_BUSY_POLL */
+
 /**
  *      napi_rx_handler - the NAPI handler for Rx processing
  *      @napi: the napi instance
@@ -1974,9 +2016,13 @@ static int napi_rx_handler(struct napi_struct *napi, int budget)
 {
         unsigned int params;
         struct sge_rspq *q = container_of(napi, struct sge_rspq, napi);
-        int work_done = process_responses(q, budget);
+        int work_done;
         u32 val;
 
+        if (!cxgb_poll_lock_napi(q))
+                return budget;
+
+        work_done = process_responses(q, budget);
         if (likely(work_done < budget)) {
                 int timer_index;
 
@@ -2001,19 +2047,20 @@ static int napi_rx_handler(struct napi_struct *napi, int budget)
         } else
                 params = QINTR_TIMER_IDX(7);
 
-        val = CIDXINC(work_done) | SEINTARM(params);
+        val = CIDXINC_V(work_done) | SEINTARM_V(params);
 
         /* If we don't have access to the new User GTS (T5+), use the old
          * doorbell mechanism; otherwise use the new BAR2 mechanism.
          */
         if (unlikely(q->bar2_addr == NULL)) {
-                t4_write_reg(q->adap, MYPF_REG(SGE_PF_GTS),
-                             val | INGRESSQID((u32)q->cntxt_id));
+                t4_write_reg(q->adap, MYPF_REG(SGE_PF_GTS_A),
+                             val | INGRESSQID_V((u32)q->cntxt_id));
         } else {
-                writel(val | INGRESSQID(q->bar2_qid),
+                writel(val | INGRESSQID_V(q->bar2_qid),
                        q->bar2_addr + SGE_UDB_GTS);
                 wmb();
         }
+        cxgb_poll_unlock_napi(q);
         return work_done;
 }
 
@@ -2056,16 +2103,16 @@ static unsigned int process_intrq(struct adapter *adap)
                 rspq_next(q);
         }
 
-        val =  CIDXINC(credits) | SEINTARM(q->intr_params);
+        val =  CIDXINC_V(credits) | SEINTARM_V(q->intr_params);
 
         /* If we don't have access to the new User GTS (T5+), use the old
          * doorbell mechanism; otherwise use the new BAR2 mechanism.
          */
         if (unlikely(q->bar2_addr == NULL)) {
-                t4_write_reg(adap, MYPF_REG(SGE_PF_GTS),
-                             val | INGRESSQID(q->cntxt_id));
+                t4_write_reg(adap, MYPF_REG(SGE_PF_GTS_A),
+                             val | INGRESSQID_V(q->cntxt_id));
         } else {
-                writel(val | INGRESSQID(q->bar2_qid),
+                writel(val | INGRESSQID_V(q->bar2_qid),
                        q->bar2_addr + SGE_UDB_GTS);
                 wmb();
         }
@@ -2095,7 +2142,7 @@ static irqreturn_t t4_intr_intx(int irq, void *cookie)
 {
         struct adapter *adap = cookie;
 
-        t4_write_reg(adap, MYPF_REG(PCIE_PF_CLI), 0);
+        t4_write_reg(adap, MYPF_REG(PCIE_PF_CLI_A), 0);
         if (t4_slow_intr_handler(adap) | process_intrq(adap))
                 return IRQ_HANDLED;
         return IRQ_NONE;             /* probably shared interrupt */
@@ -2142,9 +2189,9 @@ static void sge_rx_timer_cb(unsigned long data)
                         }
                 }
 
-        t4_write_reg(adap, SGE_DEBUG_INDEX, 13);
-        idma_same_state_cnt[0] = t4_read_reg(adap, SGE_DEBUG_DATA_HIGH);
-        idma_same_state_cnt[1] = t4_read_reg(adap, SGE_DEBUG_DATA_LOW);
+        t4_write_reg(adap, SGE_DEBUG_INDEX_A, 13);
+        idma_same_state_cnt[0] = t4_read_reg(adap, SGE_DEBUG_DATA_HIGH_A);
+        idma_same_state_cnt[1] = t4_read_reg(adap, SGE_DEBUG_DATA_LOW_A);
 
         for (i = 0; i < 2; i++) {
                 u32 debug0, debug11;
@@ -2188,12 +2235,12 @@ static void sge_rx_timer_cb(unsigned long data)
                 /* Read and save the SGE IDMA State and Queue ID information.
                  * We do this every time in case it changes across time ...
                  */
-                t4_write_reg(adap, SGE_DEBUG_INDEX, 0);
-                debug0 = t4_read_reg(adap, SGE_DEBUG_DATA_LOW);
+                t4_write_reg(adap, SGE_DEBUG_INDEX_A, 0);
+                debug0 = t4_read_reg(adap, SGE_DEBUG_DATA_LOW_A);
                 s->idma_state[i] = (debug0 >> (i * 9)) & 0x3f;
 
-                t4_write_reg(adap, SGE_DEBUG_INDEX, 11);
-                debug11 = t4_read_reg(adap, SGE_DEBUG_DATA_LOW);
+                t4_write_reg(adap, SGE_DEBUG_INDEX_A, 11);
+                debug11 = t4_read_reg(adap, SGE_DEBUG_DATA_LOW_A);
                 s->idma_qid[i] = (debug11 >> (i * 16)) & 0xffff;
 
                 CH_WARN(adap, "SGE idma%u, queue%u, maybe stuck state%u %dsecs (debug0=%#x, debug11=%#x)\n",
@@ -2337,6 +2384,7 @@ int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq,
                 goto err;
 
         netif_napi_add(dev, &iq->napi, napi_rx_handler, 64);
+        napi_hash_add(&iq->napi);
         iq->cur_desc = iq->desc;
         iq->cidx = 0;
         iq->gen = 1;
@@ -2594,6 +2642,7 @@ static void free_rspq_fl(struct adapter *adap, struct sge_rspq *rq,
                    rq->cntxt_id, fl_id, 0xffff);
         dma_free_coherent(adap->pdev_dev, (rq->size + 1) * rq->iqe_len,
                           rq->desc, rq->phys_addr);
+        napi_hash_del(&rq->napi);
         netif_napi_del(&rq->napi);
         rq->netdev = NULL;
         rq->cntxt_id = rq->abs_id = 0;
@@ -2738,24 +2787,11 @@ void t4_sge_stop(struct adapter *adap)
 }
 
 /**
- *      t4_sge_init - initialize SGE
+ *      t4_sge_init_soft - grab core SGE values needed by SGE code
  *      @adap: the adapter
  *
- *      Performs SGE initialization needed every time after a chip reset.
- *      We do not initialize any of the queues here, instead the driver
- *      top-level must request them individually.
- *
- *      Called in two different modes:
- *
- *       1. Perform actual hardware initialization and record hard-coded
- *          parameters which were used.  This gets used when we're the
- *          Master PF and the Firmware Configuration File support didn't
- *          work for some reason.
- *
- *       2. We're not the Master PF or initialization was performed with
- *          a Firmware Configuration File.  In this case we need to grab
- *          any of the SGE operating parameters that we need to have in
- *          order to do our job and make sure we can live with them ...
+ *      We need to grab the SGE operating parameters that we need to have
+ *      in order to do our job and make sure we can live with them.
  */
 
 static int t4_sge_init_soft(struct adapter *adap)
@@ -2770,8 +2806,8 @@ static int t4_sge_init_soft(struct adapter *adap)
          * process_responses() and that only packet data is going to the
          * Free Lists.
          */
-        if ((t4_read_reg(adap, SGE_CONTROL) & RXPKTCPLMODE_MASK) !=
-            RXPKTCPLMODE(X_RXPKTCPLMODE_SPLIT)) {
+        if ((t4_read_reg(adap, SGE_CONTROL_A) & RXPKTCPLMODE_F) !=
+            RXPKTCPLMODE_V(RXPKTCPLMODE_SPLIT_X)) {
                 dev_err(adap->pdev_dev, "bad SGE CPL MODE\n");
                 return -EINVAL;
         }
@@ -2785,7 +2821,7 @@ static int t4_sge_init_soft(struct adapter *adap)
          * XXX meet our needs!
          */
         #define READ_FL_BUF(x) \
-                t4_read_reg(adap, SGE_FL_BUFFER_SIZE0+(x)*sizeof(u32))
+                t4_read_reg(adap, SGE_FL_BUFFER_SIZE0_A+(x)*sizeof(u32))
 
         fl_small_pg = READ_FL_BUF(RX_SMALL_PG_BUF);
         fl_large_pg = READ_FL_BUF(RX_LARGE_PG_BUF);
@@ -2823,99 +2859,38 @@ static int t4_sge_init_soft(struct adapter *adap)
          * Retrieve our RX interrupt holdoff timer values and counter
          * threshold values from the SGE parameters.
          */
-        timer_value_0_and_1 = t4_read_reg(adap, SGE_TIMER_VALUE_0_AND_1);
-        timer_value_2_and_3 = t4_read_reg(adap, SGE_TIMER_VALUE_2_AND_3);
-        timer_value_4_and_5 = t4_read_reg(adap, SGE_TIMER_VALUE_4_AND_5);
+        timer_value_0_and_1 = t4_read_reg(adap, SGE_TIMER_VALUE_0_AND_1_A);
+        timer_value_2_and_3 = t4_read_reg(adap, SGE_TIMER_VALUE_2_AND_3_A);
+        timer_value_4_and_5 = t4_read_reg(adap, SGE_TIMER_VALUE_4_AND_5_A);
         s->timer_val[0] = core_ticks_to_us(adap,
-                TIMERVALUE0_GET(timer_value_0_and_1));
+                TIMERVALUE0_G(timer_value_0_and_1));
         s->timer_val[1] = core_ticks_to_us(adap,
-                TIMERVALUE1_GET(timer_value_0_and_1));
+                TIMERVALUE1_G(timer_value_0_and_1));
         s->timer_val[2] = core_ticks_to_us(adap,
-                TIMERVALUE2_GET(timer_value_2_and_3));
+                TIMERVALUE2_G(timer_value_2_and_3));
         s->timer_val[3] = core_ticks_to_us(adap,
-                TIMERVALUE3_GET(timer_value_2_and_3));
+                TIMERVALUE3_G(timer_value_2_and_3));
         s->timer_val[4] = core_ticks_to_us(adap,
-                TIMERVALUE4_GET(timer_value_4_and_5));
+                TIMERVALUE4_G(timer_value_4_and_5));
         s->timer_val[5] = core_ticks_to_us(adap,
-                TIMERVALUE5_GET(timer_value_4_and_5));
+                TIMERVALUE5_G(timer_value_4_and_5));
 
-        ingress_rx_threshold = t4_read_reg(adap, SGE_INGRESS_RX_THRESHOLD);
-        s->counter_val[0] = THRESHOLD_0_GET(ingress_rx_threshold);
-        s->counter_val[1] = THRESHOLD_1_GET(ingress_rx_threshold);
-        s->counter_val[2] = THRESHOLD_2_GET(ingress_rx_threshold);
-        s->counter_val[3] = THRESHOLD_3_GET(ingress_rx_threshold);
-
-        return 0;
-}
-
-static int t4_sge_init_hard(struct adapter *adap)
-{
-        struct sge *s = &adap->sge;
-
-        /*
-         * Set up our basic SGE mode to deliver CPL messages to our Ingress
-         * Queue and Packet Date to the Free List.
-         */
-        t4_set_reg_field(adap, SGE_CONTROL, RXPKTCPLMODE_MASK,
-                         RXPKTCPLMODE_MASK);
-
-        /*
-         * Set up to drop DOORBELL writes when the DOORBELL FIFO overflows
-         * and generate an interrupt when this occurs so we can recover.
-         */
-        if (is_t4(adap->params.chip)) {
-                t4_set_reg_field(adap, A_SGE_DBFIFO_STATUS,
-                                 V_HP_INT_THRESH(M_HP_INT_THRESH) |
-                                 V_LP_INT_THRESH(M_LP_INT_THRESH),
-                                 V_HP_INT_THRESH(dbfifo_int_thresh) |
-                                 V_LP_INT_THRESH(dbfifo_int_thresh));
-        } else {
-                t4_set_reg_field(adap, A_SGE_DBFIFO_STATUS,
-                                 V_LP_INT_THRESH_T5(M_LP_INT_THRESH_T5),
-                                 V_LP_INT_THRESH_T5(dbfifo_int_thresh));
-                t4_set_reg_field(adap, SGE_DBFIFO_STATUS2,
-                                 V_HP_INT_THRESH_T5(M_HP_INT_THRESH_T5),
-                                 V_HP_INT_THRESH_T5(dbfifo_int_thresh));
-        }
-        t4_set_reg_field(adap, A_SGE_DOORBELL_CONTROL, F_ENABLE_DROP,
-                        F_ENABLE_DROP);
-
-        /*
-         * SGE_FL_BUFFER_SIZE0 (RX_SMALL_PG_BUF) is set up by
-         * t4_fixup_host_params().
-         */
-        s->fl_pg_order = FL_PG_ORDER;
-        if (s->fl_pg_order)
-                t4_write_reg(adap,
-                             SGE_FL_BUFFER_SIZE0+RX_LARGE_PG_BUF*sizeof(u32),
-                             PAGE_SIZE << FL_PG_ORDER);
-        t4_write_reg(adap, SGE_FL_BUFFER_SIZE0+RX_SMALL_MTU_BUF*sizeof(u32),
-                     FL_MTU_SMALL_BUFSIZE(adap));
-        t4_write_reg(adap, SGE_FL_BUFFER_SIZE0+RX_LARGE_MTU_BUF*sizeof(u32),
-                     FL_MTU_LARGE_BUFSIZE(adap));
-
-        /*
-         * Note that the SGE Ingress Packet Count Interrupt Threshold and
-         * Timer Holdoff values must be supplied by our caller.
-         */
-        t4_write_reg(adap, SGE_INGRESS_RX_THRESHOLD,
-                     THRESHOLD_0(s->counter_val[0]) |
-                     THRESHOLD_1(s->counter_val[1]) |
-                     THRESHOLD_2(s->counter_val[2]) |
-                     THRESHOLD_3(s->counter_val[3]));
-        t4_write_reg(adap, SGE_TIMER_VALUE_0_AND_1,
-                     TIMERVALUE0(us_to_core_ticks(adap, s->timer_val[0])) |
-                     TIMERVALUE1(us_to_core_ticks(adap, s->timer_val[1])));
-        t4_write_reg(adap, SGE_TIMER_VALUE_2_AND_3,
-                     TIMERVALUE2(us_to_core_ticks(adap, s->timer_val[2])) |
-                     TIMERVALUE3(us_to_core_ticks(adap, s->timer_val[3])));
-        t4_write_reg(adap, SGE_TIMER_VALUE_4_AND_5,
-                     TIMERVALUE4(us_to_core_ticks(adap, s->timer_val[4])) |
-                     TIMERVALUE5(us_to_core_ticks(adap, s->timer_val[5])));
+        ingress_rx_threshold = t4_read_reg(adap, SGE_INGRESS_RX_THRESHOLD_A);
+        s->counter_val[0] = THRESHOLD_0_G(ingress_rx_threshold);
+        s->counter_val[1] = THRESHOLD_1_G(ingress_rx_threshold);
+        s->counter_val[2] = THRESHOLD_2_G(ingress_rx_threshold);
+        s->counter_val[3] = THRESHOLD_3_G(ingress_rx_threshold);
 
         return 0;
 }
 
+/**
+ *     t4_sge_init - initialize SGE
+ *     @adap: the adapter
+ *
+ *     Perform low-level SGE code initialization needed every time after a
+ *     chip reset.
+ */
 int t4_sge_init(struct adapter *adap)
 {
         struct sge *s = &adap->sge;
@@ -2927,9 +2902,9 @@ int t4_sge_init(struct adapter *adap)
          * Ingress Padding Boundary and Egress Status Page Size are set up by
          * t4_fixup_host_params().
          */
-        sge_control = t4_read_reg(adap, SGE_CONTROL);
-        s->pktshift = PKTSHIFT_GET(sge_control);
-        s->stat_len = (sge_control & EGRSTATUSPAGESIZE_MASK) ? 128 : 64;
+        sge_control = t4_read_reg(adap, SGE_CONTROL_A);
+        s->pktshift = PKTSHIFT_G(sge_control);
+        s->stat_len = (sge_control & EGRSTATUSPAGESIZE_F) ? 128 : 64;
 
         /* T4 uses a single control field to specify both the PCIe Padding and
          * Packing Boundary.  T5 introduced the ability to specify these
@@ -2937,8 +2912,8 @@ int t4_sge_init(struct adapter *adap)
          * within Packed Buffer Mode is the maximum of these two
          * specifications.
          */
-        ingpadboundary = 1 << (INGPADBOUNDARY_GET(sge_control) +
-                               X_INGPADBOUNDARY_SHIFT);
+        ingpadboundary = 1 << (INGPADBOUNDARY_G(sge_control) +
+                               INGPADBOUNDARY_SHIFT_X);
         if (is_t4(adap->params.chip)) {
                 s->fl_align = ingpadboundary;
         } else {
@@ -2956,10 +2931,7 @@ int t4_sge_init(struct adapter *adap)
                 s->fl_align = max(ingpadboundary, ingpackboundary);
         }
 
-        if (adap->flags & USING_SOFT_PARAMS)
-                ret = t4_sge_init_soft(adap);
-        else
-                ret = t4_sge_init_hard(adap);
+        ret = t4_sge_init_soft(adap);
         if (ret < 0)
                 return ret;
 
@@ -2975,11 +2947,11 @@ int t4_sge_init(struct adapter *adap)
          * buffers and a new field which only applies to Packed Mode Free List
          * buffers.
          */
-        sge_conm_ctrl = t4_read_reg(adap, SGE_CONM_CTRL);
+        sge_conm_ctrl = t4_read_reg(adap, SGE_CONM_CTRL_A);
         if (is_t4(adap->params.chip))
-                egress_threshold = EGRTHRESHOLD_GET(sge_conm_ctrl);
+                egress_threshold = EGRTHRESHOLD_G(sge_conm_ctrl);
         else
-                egress_threshold = EGRTHRESHOLDPACKING_GET(sge_conm_ctrl);
+                egress_threshold = EGRTHRESHOLDPACKING_G(sge_conm_ctrl);
         s->fl_starve_thres = 2*egress_threshold + 1;
 
         setup_timer(&s->rx_timer, sge_rx_timer_cb, (unsigned long)adap);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
index c132d9030729..4d643b65265e 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
@@ -35,6 +35,7 @@
 #include <linux/delay.h>
 #include "cxgb4.h"
 #include "t4_regs.h"
+#include "t4_values.h"
 #include "t4fw_api.h"
 
 /**
@@ -149,20 +150,20 @@ void t4_write_indirect(struct adapter *adap, unsigned int addr_reg,
  */
 void t4_hw_pci_read_cfg4(struct adapter *adap, int reg, u32 *val)
 {
-        u32 req = ENABLE | FUNCTION(adap->fn) | reg;
+        u32 req = ENABLE_F | FUNCTION_V(adap->fn) | REGISTER_V(reg);
 
         if (is_t4(adap->params.chip))
-                req |= F_LOCALCFG;
+                req |= LOCALCFG_F;
 
-        t4_write_reg(adap, PCIE_CFG_SPACE_REQ, req);
-        *val = t4_read_reg(adap, PCIE_CFG_SPACE_DATA);
+        t4_write_reg(adap, PCIE_CFG_SPACE_REQ_A, req);
+        *val = t4_read_reg(adap, PCIE_CFG_SPACE_DATA_A);
 
         /* Reset ENABLE to 0 so reads of PCIE_CFG_SPACE_DATA won't cause a
          * Configuration Space read.  (None of the other fields matter when
          * ENABLE is 0 so a simple register write is easier than a
          * read-modify-write via t4_set_reg_field().)
          */
-        t4_write_reg(adap, PCIE_CFG_SPACE_REQ, 0);
+        t4_write_reg(adap, PCIE_CFG_SPACE_REQ_A, 0);
 }
 
 /*
@@ -187,8 +188,8 @@ static void t4_report_fw_error(struct adapter *adap)
         };
         u32 pcie_fw;
 
-        pcie_fw = t4_read_reg(adap, MA_PCIE_FW);
-        if (pcie_fw & PCIE_FW_ERR)
+        pcie_fw = t4_read_reg(adap, PCIE_FW_A);
+        if (pcie_fw & PCIE_FW_ERR_F)
                 dev_err(adap->pdev_dev, "Firmware reports adapter error: %s\n",
                         reason[PCIE_FW_EVAL_G(pcie_fw)]);
 }
@@ -264,8 +265,8 @@ int t4_wr_mbox_meat(struct adapter *adap, int mbox, const void *cmd, int size,
         u64 res;
         int i, ms, delay_idx;
         const __be64 *p = cmd;
-        u32 data_reg = PF_REG(mbox, CIM_PF_MAILBOX_DATA);
-        u32 ctl_reg = PF_REG(mbox, CIM_PF_MAILBOX_CTRL);
+        u32 data_reg = PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
+        u32 ctl_reg = PF_REG(mbox, CIM_PF_MAILBOX_CTRL_A);
 
         if ((size & 15) || size > MBOX_LEN)
                 return -EINVAL;
@@ -277,9 +278,9 @@ int t4_wr_mbox_meat(struct adapter *adap, int mbox, const void *cmd, int size,
         if (adap->pdev->error_state != pci_channel_io_normal)
                 return -EIO;
 
-        v = MBOWNER_GET(t4_read_reg(adap, ctl_reg));
+        v = MBOWNER_G(t4_read_reg(adap, ctl_reg));
         for (i = 0; v == MBOX_OWNER_NONE && i < 3; i++)
-                v = MBOWNER_GET(t4_read_reg(adap, ctl_reg));
+                v = MBOWNER_G(t4_read_reg(adap, ctl_reg));
 
         if (v != MBOX_OWNER_DRV)
                 return v ? -EBUSY : -ETIMEDOUT;
@@ -287,7 +288,7 @@ int t4_wr_mbox_meat(struct adapter *adap, int mbox, const void *cmd, int size,
         for (i = 0; i < size; i += 8)
                 t4_write_reg64(adap, data_reg + i, be64_to_cpu(*p++));
 
-        t4_write_reg(adap, ctl_reg, MBMSGVALID | MBOWNER(MBOX_OWNER_FW));
+        t4_write_reg(adap, ctl_reg, MBMSGVALID_F | MBOWNER_V(MBOX_OWNER_FW));
         t4_read_reg(adap, ctl_reg);          /* flush write */
 
         delay_idx = 0;
@@ -303,8 +304,8 @@ int t4_wr_mbox_meat(struct adapter *adap, int mbox, const void *cmd, int size,
                         mdelay(ms);
 
                 v = t4_read_reg(adap, ctl_reg);
-                if (MBOWNER_GET(v) == MBOX_OWNER_DRV) {
-                        if (!(v & MBMSGVALID)) {
+                if (MBOWNER_G(v) == MBOX_OWNER_DRV) {
+                        if (!(v & MBMSGVALID_F)) {
                                 t4_write_reg(adap, ctl_reg, 0);
                                 continue;
                         }
@@ -350,27 +351,27 @@ int t4_mc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
         u32 mc_bist_status_rdata, mc_bist_data_pattern;
 
         if (is_t4(adap->params.chip)) {
-                mc_bist_cmd = MC_BIST_CMD;
-                mc_bist_cmd_addr = MC_BIST_CMD_ADDR;
-                mc_bist_cmd_len = MC_BIST_CMD_LEN;
-                mc_bist_status_rdata = MC_BIST_STATUS_RDATA;
-                mc_bist_data_pattern = MC_BIST_DATA_PATTERN;
+                mc_bist_cmd = MC_BIST_CMD_A;
+                mc_bist_cmd_addr = MC_BIST_CMD_ADDR_A;
+                mc_bist_cmd_len = MC_BIST_CMD_LEN_A;
+                mc_bist_status_rdata = MC_BIST_STATUS_RDATA_A;
+                mc_bist_data_pattern = MC_BIST_DATA_PATTERN_A;
         } else {
-                mc_bist_cmd = MC_REG(MC_P_BIST_CMD, idx);
-                mc_bist_cmd_addr = MC_REG(MC_P_BIST_CMD_ADDR, idx);
-                mc_bist_cmd_len = MC_REG(MC_P_BIST_CMD_LEN, idx);
-                mc_bist_status_rdata = MC_REG(MC_P_BIST_STATUS_RDATA, idx);
-                mc_bist_data_pattern = MC_REG(MC_P_BIST_DATA_PATTERN, idx);
+                mc_bist_cmd = MC_REG(MC_P_BIST_CMD_A, idx);
+                mc_bist_cmd_addr = MC_REG(MC_P_BIST_CMD_ADDR_A, idx);
+                mc_bist_cmd_len = MC_REG(MC_P_BIST_CMD_LEN_A, idx);
+                mc_bist_status_rdata = MC_REG(MC_P_BIST_STATUS_RDATA_A, idx);
+                mc_bist_data_pattern = MC_REG(MC_P_BIST_DATA_PATTERN_A, idx);
         }
 
-        if (t4_read_reg(adap, mc_bist_cmd) & START_BIST)
+        if (t4_read_reg(adap, mc_bist_cmd) & START_BIST_F)
                 return -EBUSY;
         t4_write_reg(adap, mc_bist_cmd_addr, addr & ~0x3fU);
         t4_write_reg(adap, mc_bist_cmd_len, 64);
         t4_write_reg(adap, mc_bist_data_pattern, 0xc);
-        t4_write_reg(adap, mc_bist_cmd, BIST_OPCODE(1) | START_BIST |
-                     BIST_CMD_GAP(1));
-        i = t4_wait_op_done(adap, mc_bist_cmd, START_BIST, 0, 10, 1);
+        t4_write_reg(adap, mc_bist_cmd, BIST_OPCODE_V(1) | START_BIST_F |
+                     BIST_CMD_GAP_V(1));
+        i = t4_wait_op_done(adap, mc_bist_cmd, START_BIST_F, 0, 10, 1);
         if (i)
                 return i;
 
@@ -403,31 +404,31 @@ int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
         u32 edc_bist_cmd_data_pattern, edc_bist_status_rdata;
 
         if (is_t4(adap->params.chip)) {
-                edc_bist_cmd = EDC_REG(EDC_BIST_CMD, idx);
-                edc_bist_cmd_addr = EDC_REG(EDC_BIST_CMD_ADDR, idx);
-                edc_bist_cmd_len = EDC_REG(EDC_BIST_CMD_LEN, idx);
-                edc_bist_cmd_data_pattern = EDC_REG(EDC_BIST_DATA_PATTERN,
-                                                    idx);
-                edc_bist_status_rdata = EDC_REG(EDC_BIST_STATUS_RDATA,
+                edc_bist_cmd = EDC_REG(EDC_BIST_CMD_A, idx);
+                edc_bist_cmd_addr = EDC_REG(EDC_BIST_CMD_ADDR_A, idx);
+                edc_bist_cmd_len = EDC_REG(EDC_BIST_CMD_LEN_A, idx);
+                edc_bist_cmd_data_pattern = EDC_REG(EDC_BIST_DATA_PATTERN_A,
                                                     idx);
+                edc_bist_status_rdata = EDC_REG(EDC_BIST_STATUS_RDATA_A,
+                                                idx);
         } else {
-                edc_bist_cmd = EDC_REG_T5(EDC_H_BIST_CMD, idx);
-                edc_bist_cmd_addr = EDC_REG_T5(EDC_H_BIST_CMD_ADDR, idx);
-                edc_bist_cmd_len = EDC_REG_T5(EDC_H_BIST_CMD_LEN, idx);
+                edc_bist_cmd = EDC_REG_T5(EDC_H_BIST_CMD_A, idx);
+                edc_bist_cmd_addr = EDC_REG_T5(EDC_H_BIST_CMD_ADDR_A, idx);
+                edc_bist_cmd_len = EDC_REG_T5(EDC_H_BIST_CMD_LEN_A, idx);
                 edc_bist_cmd_data_pattern =
-                        EDC_REG_T5(EDC_H_BIST_DATA_PATTERN, idx);
+                        EDC_REG_T5(EDC_H_BIST_DATA_PATTERN_A, idx);
                 edc_bist_status_rdata =
-                         EDC_REG_T5(EDC_H_BIST_STATUS_RDATA, idx);
+                         EDC_REG_T5(EDC_H_BIST_STATUS_RDATA_A, idx);
         }
 
-        if (t4_read_reg(adap, edc_bist_cmd) & START_BIST)
+        if (t4_read_reg(adap, edc_bist_cmd) & START_BIST_F)
                 return -EBUSY;
         t4_write_reg(adap, edc_bist_cmd_addr, addr & ~0x3fU);
         t4_write_reg(adap, edc_bist_cmd_len, 64);
         t4_write_reg(adap, edc_bist_cmd_data_pattern, 0xc);
         t4_write_reg(adap, edc_bist_cmd,
-                     BIST_OPCODE(1) | BIST_CMD_GAP(1) | START_BIST);
-        i = t4_wait_op_done(adap, edc_bist_cmd, START_BIST, 0, 10, 1);
+                     BIST_OPCODE_V(1) | BIST_CMD_GAP_V(1) | START_BIST_F);
+        i = t4_wait_op_done(adap, edc_bist_cmd, START_BIST_F, 0, 10, 1);
         if (i)
                 return i;
 
@@ -505,13 +506,13 @@ int t4_memory_rw(struct adapter *adap, int win, int mtype, u32 addr,
          * the address is relative to BAR0.
          */
         mem_reg = t4_read_reg(adap,
-                              PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN,
+                              PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A,
                                                   win));
-        mem_aperture = 1 << (GET_WINDOW(mem_reg) + 10);
-        mem_base = GET_PCIEOFST(mem_reg) << 10;
+        mem_aperture = 1 << (WINDOW_G(mem_reg) + WINDOW_SHIFT_X);
+        mem_base = PCIEOFST_G(mem_reg) << PCIEOFST_SHIFT_X;
         if (is_t4(adap->params.chip))
                 mem_base -= adap->t4_bar0;
-        win_pf = is_t4(adap->params.chip) ? 0 : V_PFNUM(adap->fn);
+        win_pf = is_t4(adap->params.chip) ? 0 : PFNUM_V(adap->fn);
 
         /* Calculate our initial PCI-E Memory Window Position and Offset into
          * that Window.
@@ -524,10 +525,10 @@ int t4_memory_rw(struct adapter *adap, int win, int mtype, u32 addr,
          * attempt to use the new value.)
          */
         t4_write_reg(adap,
-                     PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET, win),
+                     PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, win),
                      pos | win_pf);
         t4_read_reg(adap,
-                    PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET, win));
+                    PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, win));
 
         /* Transfer data to/from the adapter as long as there's an integral
          * number of 32-bit transfers to complete.
@@ -552,11 +553,11 @@ int t4_memory_rw(struct adapter *adap, int win, int mtype, u32 addr,
                         pos += mem_aperture;
                         offset = 0;
                         t4_write_reg(adap,
-                                     PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET,
-                                                         win), pos | win_pf);
+                                PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A,
+                                                    win), pos | win_pf);
                         t4_read_reg(adap,
-                                    PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET,
-                                                        win));
+                                PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A,
+                                                    win));
                 }
         }
 
@@ -760,14 +761,13 @@ static int sf1_read(struct adapter *adapter, unsigned int byte_cnt, int cont,
 
         if (!byte_cnt || byte_cnt > 4)
                 return -EINVAL;
-        if (t4_read_reg(adapter, SF_OP) & SF_BUSY)
+        if (t4_read_reg(adapter, SF_OP_A) & SF_BUSY_F)
                 return -EBUSY;
-        cont = cont ? SF_CONT : 0;
-        lock = lock ? SF_LOCK : 0;
-        t4_write_reg(adapter, SF_OP, lock | cont | BYTECNT(byte_cnt - 1));
-        ret = t4_wait_op_done(adapter, SF_OP, SF_BUSY, 0, SF_ATTEMPTS, 5);
+        t4_write_reg(adapter, SF_OP_A, SF_LOCK_V(lock) |
+                     SF_CONT_V(cont) | BYTECNT_V(byte_cnt - 1));
+        ret = t4_wait_op_done(adapter, SF_OP_A, SF_BUSY_F, 0, SF_ATTEMPTS, 5);
         if (!ret)
-                *valp = t4_read_reg(adapter, SF_DATA);
+                *valp = t4_read_reg(adapter, SF_DATA_A);
         return ret;
 }
 
@@ -788,14 +788,12 @@ static int sf1_write(struct adapter *adapter, unsigned int byte_cnt, int cont,
 {
         if (!byte_cnt || byte_cnt > 4)
                 return -EINVAL;
-        if (t4_read_reg(adapter, SF_OP) & SF_BUSY)
+        if (t4_read_reg(adapter, SF_OP_A) & SF_BUSY_F)
                 return -EBUSY;
-        cont = cont ? SF_CONT : 0;
-        lock = lock ? SF_LOCK : 0;
-        t4_write_reg(adapter, SF_DATA, val);
-        t4_write_reg(adapter, SF_OP, lock |
-                     cont | BYTECNT(byte_cnt - 1) | OP_WR);
-        return t4_wait_op_done(adapter, SF_OP, SF_BUSY, 0, SF_ATTEMPTS, 5);
+        t4_write_reg(adapter, SF_DATA_A, val);
+        t4_write_reg(adapter, SF_OP_A, SF_LOCK_V(lock) |
+                     SF_CONT_V(cont) | BYTECNT_V(byte_cnt - 1) | OP_V(1));
+        return t4_wait_op_done(adapter, SF_OP_A, SF_BUSY_F, 0, SF_ATTEMPTS, 5);
 }
 
 /**
@@ -837,8 +835,8 @@ static int flash_wait_op(struct adapter *adapter, int attempts, int delay)
  *      (i.e., big-endian), otherwise as 32-bit words in the platform's
  *      natural endianess.
  */
-static int t4_read_flash(struct adapter *adapter, unsigned int addr,
-                         unsigned int nwords, u32 *data, int byte_oriented)
+int t4_read_flash(struct adapter *adapter, unsigned int addr,
+                  unsigned int nwords, u32 *data, int byte_oriented)
 {
         int ret;
 
@@ -854,7 +852,7 @@ static int t4_read_flash(struct adapter *adapter, unsigned int addr,
         for ( ; nwords; nwords--, data++) {
                 ret = sf1_read(adapter, 4, nwords > 1, nwords == 1, data);
                 if (nwords == 1)
-                        t4_write_reg(adapter, SF_OP, 0);    /* unlock SF */
+                        t4_write_reg(adapter, SF_OP_A, 0);    /* unlock SF */
                 if (ret)
                         return ret;
                 if (byte_oriented)
@@ -902,7 +900,7 @@ static int t4_write_flash(struct adapter *adapter, unsigned int addr,
         if (ret)
                 goto unlock;
 
-        t4_write_reg(adapter, SF_OP, 0);    /* unlock SF */
+        t4_write_reg(adapter, SF_OP_A, 0);    /* unlock SF */
 
         /* Read the page to verify the write succeeded */
         ret = t4_read_flash(adapter, addr & ~0xff, ARRAY_SIZE(buf), buf, 1);
@@ -918,7 +916,7 @@ static int t4_write_flash(struct adapter *adapter, unsigned int addr,
         return 0;
 
 unlock:
-        t4_write_reg(adapter, SF_OP, 0);    /* unlock SF */
+        t4_write_reg(adapter, SF_OP_A, 0);    /* unlock SF */
         return ret;
 }
 
@@ -950,6 +948,43 @@ int t4_get_tp_version(struct adapter *adapter, u32 *vers)
                              1, vers, 0);
 }
 
+/**
+ *      t4_get_exprom_version - return the Expansion ROM version (if any)
+ *      @adapter: the adapter
+ *      @vers: where to place the version
+ *
+ *      Reads the Expansion ROM header from FLASH and returns the version
+ *      number (if present) through the @vers return value pointer.  We return
+ *      this in the Firmware Version Format since it's convenient.  Return
+ *      0 on success, -ENOENT if no Expansion ROM is present.
+ */
+int t4_get_exprom_version(struct adapter *adap, u32 *vers)
+{
+        struct exprom_header {
+                unsigned char hdr_arr[16];      /* must start with 0x55aa */
+                unsigned char hdr_ver[4];       /* Expansion ROM version */
+        } *hdr;
+        u32 exprom_header_buf[DIV_ROUND_UP(sizeof(struct exprom_header),
+                                           sizeof(u32))];
+        int ret;
+
+        ret = t4_read_flash(adap, FLASH_EXP_ROM_START,
+                            ARRAY_SIZE(exprom_header_buf), exprom_header_buf,
+                            0);
+        if (ret)
+                return ret;
+
+        hdr = (struct exprom_header *)exprom_header_buf;
+        if (hdr->hdr_arr[0] != 0x55 || hdr->hdr_arr[1] != 0xaa)
+                return -ENOENT;
+
+        *vers = (FW_HDR_FW_VER_MAJOR_V(hdr->hdr_ver[0]) |
+                 FW_HDR_FW_VER_MINOR_V(hdr->hdr_ver[1]) |
+                 FW_HDR_FW_VER_MICRO_V(hdr->hdr_ver[2]) |
+                 FW_HDR_FW_VER_BUILD_V(hdr->hdr_ver[3]));
+        return 0;
+}
+
 /* Is the given firmware API compatible with the one the driver was compiled
  * with?
  */
@@ -1113,7 +1148,7 @@ static int t4_flash_erase_sectors(struct adapter *adapter, int start, int end)
                 }
                 start++;
         }
-        t4_write_reg(adapter, SF_OP, 0);    /* unlock SF */
+        t4_write_reg(adapter, SF_OP_A, 0);    /* unlock SF */
         return ret;
 }
 
@@ -1241,6 +1276,45 @@ out:
         return ret;
 }
 
+/**
+ *      t4_fwcache - firmware cache operation
+ *      @adap: the adapter
+ *      @op  : the operation (flush or flush and invalidate)
+ */
+int t4_fwcache(struct adapter *adap, enum fw_params_param_dev_fwcache op)
+{
+        struct fw_params_cmd c;
+
+        memset(&c, 0, sizeof(c));
+        c.op_to_vfn =
+                cpu_to_be32(FW_CMD_OP_V(FW_PARAMS_CMD) |
+                            FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
+                            FW_PARAMS_CMD_PFN_V(adap->fn) |
+                            FW_PARAMS_CMD_VFN_V(0));
+        c.retval_len16 = cpu_to_be32(FW_LEN16(c));
+        c.param[0].mnem =
+                cpu_to_be32(FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
+                            FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_FWCACHE));
+        c.param[0].val = (__force __be32)op;
+
+        return t4_wr_mbox(adap, adap->mbox, &c, sizeof(c), NULL);
+}
+
+void t4_ulprx_read_la(struct adapter *adap, u32 *la_buf)
+{
+        unsigned int i, j;
+
+        for (i = 0; i < 8; i++) {
+                u32 *p = la_buf + i;
+
+                t4_write_reg(adap, ULP_RX_LA_CTL_A, i);
+                j = t4_read_reg(adap, ULP_RX_LA_WRPTR_A);
+                t4_write_reg(adap, ULP_RX_LA_RDPTR_A, j);
+                for (j = 0; j < ULPRX_LA_SIZE; j++, p += 8)
+                        *p = t4_read_reg(adap, ULP_RX_LA_RDDATA_A);
+        }
+}
+
 #define ADVERT_MASK (FW_PORT_CAP_SPEED_100M | FW_PORT_CAP_SPEED_1G |\
                      FW_PORT_CAP_SPEED_10G | FW_PORT_CAP_SPEED_40G | \
                      FW_PORT_CAP_ANEG)
@@ -1365,95 +1439,97 @@ static int t4_handle_intr_status(struct adapter *adapter, unsigned int reg,
 static void pcie_intr_handler(struct adapter *adapter)
 {
         static const struct intr_info sysbus_intr_info[] = {
-                { RNPP, "RXNP array parity error", -1, 1 },
-                { RPCP, "RXPC array parity error", -1, 1 },
-                { RCIP, "RXCIF array parity error", -1, 1 },
-                { RCCP, "Rx completions control array parity error", -1, 1 },
-                { RFTP, "RXFT array parity error", -1, 1 },
+                { RNPP_F, "RXNP array parity error", -1, 1 },
+                { RPCP_F, "RXPC array parity error", -1, 1 },
+                { RCIP_F, "RXCIF array parity error", -1, 1 },
+                { RCCP_F, "Rx completions control array parity error", -1, 1 },
+                { RFTP_F, "RXFT array parity error", -1, 1 },
                 { 0 }
         };
         static const struct intr_info pcie_port_intr_info[] = {
-                { TPCP, "TXPC array parity error", -1, 1 },
-                { TNPP, "TXNP array parity error", -1, 1 },
-                { TFTP, "TXFT array parity error", -1, 1 },
-                { TCAP, "TXCA array parity error", -1, 1 },
-                { TCIP, "TXCIF array parity error", -1, 1 },
-                { RCAP, "RXCA array parity error", -1, 1 },
-                { OTDD, "outbound request TLP discarded", -1, 1 },
-                { RDPE, "Rx data parity error", -1, 1 },
-                { TDUE, "Tx uncorrectable data error", -1, 1 },
+                { TPCP_F, "TXPC array parity error", -1, 1 },
+                { TNPP_F, "TXNP array parity error", -1, 1 },
+                { TFTP_F, "TXFT array parity error", -1, 1 },
+                { TCAP_F, "TXCA array parity error", -1, 1 },
+                { TCIP_F, "TXCIF array parity error", -1, 1 },
+                { RCAP_F, "RXCA array parity error", -1, 1 },
+                { OTDD_F, "outbound request TLP discarded", -1, 1 },
+                { RDPE_F, "Rx data parity error", -1, 1 },
+                { TDUE_F, "Tx uncorrectable data error", -1, 1 },
                 { 0 }
         };
         static const struct intr_info pcie_intr_info[] = {
-                { MSIADDRLPERR, "MSI AddrL parity error", -1, 1 },
-                { MSIADDRHPERR, "MSI AddrH parity error", -1, 1 },
-                { MSIDATAPERR, "MSI data parity error", -1, 1 },
-                { MSIXADDRLPERR, "MSI-X AddrL parity error", -1, 1 },
-                { MSIXADDRHPERR, "MSI-X AddrH parity error", -1, 1 },
-                { MSIXDATAPERR, "MSI-X data parity error", -1, 1 },
-                { MSIXDIPERR, "MSI-X DI parity error", -1, 1 },
-                { PIOCPLPERR, "PCI PIO completion FIFO parity error", -1, 1 },
-                { PIOREQPERR, "PCI PIO request FIFO parity error", -1, 1 },
-                { TARTAGPERR, "PCI PCI target tag FIFO parity error", -1, 1 },
-                { CCNTPERR, "PCI CMD channel count parity error", -1, 1 },
-                { CREQPERR, "PCI CMD channel request parity error", -1, 1 },
-                { CRSPPERR, "PCI CMD channel response parity error", -1, 1 },
-                { DCNTPERR, "PCI DMA channel count parity error", -1, 1 },
-                { DREQPERR, "PCI DMA channel request parity error", -1, 1 },
-                { DRSPPERR, "PCI DMA channel response parity error", -1, 1 },
-                { HCNTPERR, "PCI HMA channel count parity error", -1, 1 },
-                { HREQPERR, "PCI HMA channel request parity error", -1, 1 },
-                { HRSPPERR, "PCI HMA channel response parity error", -1, 1 },
-                { CFGSNPPERR, "PCI config snoop FIFO parity error", -1, 1 },
-                { FIDPERR, "PCI FID parity error", -1, 1 },
-                { INTXCLRPERR, "PCI INTx clear parity error", -1, 1 },
-                { MATAGPERR, "PCI MA tag parity error", -1, 1 },
-                { PIOTAGPERR, "PCI PIO tag parity error", -1, 1 },
-                { RXCPLPERR, "PCI Rx completion parity error", -1, 1 },
-                { RXWRPERR, "PCI Rx write parity error", -1, 1 },
-                { RPLPERR, "PCI replay buffer parity error", -1, 1 },
-                { PCIESINT, "PCI core secondary fault", -1, 1 },
-                { PCIEPINT, "PCI core primary fault", -1, 1 },
-                { UNXSPLCPLERR, "PCI unexpected split completion error", -1, 0 },
+                { MSIADDRLPERR_F, "MSI AddrL parity error", -1, 1 },
+                { MSIADDRHPERR_F, "MSI AddrH parity error", -1, 1 },
+                { MSIDATAPERR_F, "MSI data parity error", -1, 1 },
+                { MSIXADDRLPERR_F, "MSI-X AddrL parity error", -1, 1 },
+                { MSIXADDRHPERR_F, "MSI-X AddrH parity error", -1, 1 },
+                { MSIXDATAPERR_F, "MSI-X data parity error", -1, 1 },
+                { MSIXDIPERR_F, "MSI-X DI parity error", -1, 1 },
+                { PIOCPLPERR_F, "PCI PIO completion FIFO parity error", -1, 1 },
+                { PIOREQPERR_F, "PCI PIO request FIFO parity error", -1, 1 },
+                { TARTAGPERR_F, "PCI PCI target tag FIFO parity error", -1, 1 },
+                { CCNTPERR_F, "PCI CMD channel count parity error", -1, 1 },
+                { CREQPERR_F, "PCI CMD channel request parity error", -1, 1 },
+                { CRSPPERR_F, "PCI CMD channel response parity error", -1, 1 },
+                { DCNTPERR_F, "PCI DMA channel count parity error", -1, 1 },
+                { DREQPERR_F, "PCI DMA channel request parity error", -1, 1 },
+                { DRSPPERR_F, "PCI DMA channel response parity error", -1, 1 },
+                { HCNTPERR_F, "PCI HMA channel count parity error", -1, 1 },
+                { HREQPERR_F, "PCI HMA channel request parity error", -1, 1 },
+                { HRSPPERR_F, "PCI HMA channel response parity error", -1, 1 },
+                { CFGSNPPERR_F, "PCI config snoop FIFO parity error", -1, 1 },
+                { FIDPERR_F, "PCI FID parity error", -1, 1 },
+                { INTXCLRPERR_F, "PCI INTx clear parity error", -1, 1 },
+                { MATAGPERR_F, "PCI MA tag parity error", -1, 1 },
+                { PIOTAGPERR_F, "PCI PIO tag parity error", -1, 1 },
+                { RXCPLPERR_F, "PCI Rx completion parity error", -1, 1 },
+                { RXWRPERR_F, "PCI Rx write parity error", -1, 1 },
+                { RPLPERR_F, "PCI replay buffer parity error", -1, 1 },
+                { PCIESINT_F, "PCI core secondary fault", -1, 1 },
+                { PCIEPINT_F, "PCI core primary fault", -1, 1 },
+                { UNXSPLCPLERR_F, "PCI unexpected split completion error",
+                  -1, 0 },
                 { 0 }
         };
 
         static struct intr_info t5_pcie_intr_info[] = {
-                { MSTGRPPERR, "Master Response Read Queue parity error",
+                { MSTGRPPERR_F, "Master Response Read Queue parity error",
                   -1, 1 },
-                { MSTTIMEOUTPERR, "Master Timeout FIFO parity error", -1, 1 },
-                { MSIXSTIPERR, "MSI-X STI SRAM parity error", -1, 1 },
-                { MSIXADDRLPERR, "MSI-X AddrL parity error", -1, 1 },
-                { MSIXADDRHPERR, "MSI-X AddrH parity error", -1, 1 },
-                { MSIXDATAPERR, "MSI-X data parity error", -1, 1 },
-                { MSIXDIPERR, "MSI-X DI parity error", -1, 1 },
-                { PIOCPLGRPPERR, "PCI PIO completion Group FIFO parity error",
+                { MSTTIMEOUTPERR_F, "Master Timeout FIFO parity error", -1, 1 },
+                { MSIXSTIPERR_F, "MSI-X STI SRAM parity error", -1, 1 },
+                { MSIXADDRLPERR_F, "MSI-X AddrL parity error", -1, 1 },
+                { MSIXADDRHPERR_F, "MSI-X AddrH parity error", -1, 1 },
+                { MSIXDATAPERR_F, "MSI-X data parity error", -1, 1 },
+                { MSIXDIPERR_F, "MSI-X DI parity error", -1, 1 },
+                { PIOCPLGRPPERR_F, "PCI PIO completion Group FIFO parity error",
                   -1, 1 },
-                { PIOREQGRPPERR, "PCI PIO request Group FIFO parity error",
+                { PIOREQGRPPERR_F, "PCI PIO request Group FIFO parity error",
                   -1, 1 },
-                { TARTAGPERR, "PCI PCI target tag FIFO parity error", -1, 1 },
-                { MSTTAGQPERR, "PCI master tag queue parity error", -1, 1 },
-                { CREQPERR, "PCI CMD channel request parity error", -1, 1 },
-                { CRSPPERR, "PCI CMD channel response parity error", -1, 1 },
-                { DREQWRPERR, "PCI DMA channel write request parity error",
+                { TARTAGPERR_F, "PCI PCI target tag FIFO parity error", -1, 1 },
+                { MSTTAGQPERR_F, "PCI master tag queue parity error", -1, 1 },
+                { CREQPERR_F, "PCI CMD channel request parity error", -1, 1 },
+                { CRSPPERR_F, "PCI CMD channel response parity error", -1, 1 },
+                { DREQWRPERR_F, "PCI DMA channel write request parity error",
                   -1, 1 },
-                { DREQPERR, "PCI DMA channel request parity error", -1, 1 },
-                { DRSPPERR, "PCI DMA channel response parity error", -1, 1 },
-                { HREQWRPERR, "PCI HMA channel count parity error", -1, 1 },
-                { HREQPERR, "PCI HMA channel request parity error", -1, 1 },
-                { HRSPPERR, "PCI HMA channel response parity error", -1, 1 },
-                { CFGSNPPERR, "PCI config snoop FIFO parity error", -1, 1 },
-                { FIDPERR, "PCI FID parity error", -1, 1 },
-                { VFIDPERR, "PCI INTx clear parity error", -1, 1 },
-                { MAGRPPERR, "PCI MA group FIFO parity error", -1, 1 },
-                { PIOTAGPERR, "PCI PIO tag parity error", -1, 1 },
-                { IPRXHDRGRPPERR, "PCI IP Rx header group parity error",
+                { DREQPERR_F, "PCI DMA channel request parity error", -1, 1 },
+                { DRSPPERR_F, "PCI DMA channel response parity error", -1, 1 },
+                { HREQWRPERR_F, "PCI HMA channel count parity error", -1, 1 },
+                { HREQPERR_F, "PCI HMA channel request parity error", -1, 1 },
+                { HRSPPERR_F, "PCI HMA channel response parity error", -1, 1 },
+                { CFGSNPPERR_F, "PCI config snoop FIFO parity error", -1, 1 },
+                { FIDPERR_F, "PCI FID parity error", -1, 1 },
+                { VFIDPERR_F, "PCI INTx clear parity error", -1, 1 },
+                { MAGRPPERR_F, "PCI MA group FIFO parity error", -1, 1 },
+                { PIOTAGPERR_F, "PCI PIO tag parity error", -1, 1 },
+                { IPRXHDRGRPPERR_F, "PCI IP Rx header group parity error",
                   -1, 1 },
-                { IPRXDATAGRPPERR, "PCI IP Rx data group parity error", -1, 1 },
-                { RPLPERR, "PCI IP replay buffer parity error", -1, 1 },
-                { IPSOTPERR, "PCI IP SOT buffer parity error", -1, 1 },
-                { TRGT1GRPPERR, "PCI TRGT1 group FIFOs parity error", -1, 1 },
-                { READRSPERR, "Outbound read error", -1, 0 },
+                { IPRXDATAGRPPERR_F, "PCI IP Rx data group parity error",
+                  -1, 1 },
+                { RPLPERR_F, "PCI IP replay buffer parity error", -1, 1 },
+                { IPSOTPERR_F, "PCI IP SOT buffer parity error", -1, 1 },
+                { TRGT1GRPPERR_F, "PCI TRGT1 group FIFOs parity error", -1, 1 },
+                { READRSPERR_F, "Outbound read error", -1, 0 },
                 { 0 }
         };
 
@@ -1461,15 +1537,15 @@ static void pcie_intr_handler(struct adapter *adapter)
 
         if (is_t4(adapter->params.chip))
                 fat = t4_handle_intr_status(adapter,
-                                            PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS,
-                                            sysbus_intr_info) +
+                                PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS_A,
+                                sysbus_intr_info) +
                         t4_handle_intr_status(adapter,
-                                              PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS,
-                                              pcie_port_intr_info) +
-                        t4_handle_intr_status(adapter, PCIE_INT_CAUSE,
+                                        PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS_A,
+                                        pcie_port_intr_info) +
+                        t4_handle_intr_status(adapter, PCIE_INT_CAUSE_A,
                                               pcie_intr_info);
         else
-                fat = t4_handle_intr_status(adapter, PCIE_INT_CAUSE,
+                fat = t4_handle_intr_status(adapter, PCIE_INT_CAUSE_A,
                                             t5_pcie_intr_info);
 
         if (fat)
@@ -1483,11 +1559,11 @@ static void tp_intr_handler(struct adapter *adapter)
 {
         static const struct intr_info tp_intr_info[] = {
                 { 0x3fffffff, "TP parity error", -1, 1 },
-                { FLMTXFLSTEMPTY, "TP out of Tx pages", -1, 1 },
+                { FLMTXFLSTEMPTY_F, "TP out of Tx pages", -1, 1 },
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adapter, TP_INT_CAUSE, tp_intr_info))
+        if (t4_handle_intr_status(adapter, TP_INT_CAUSE_A, tp_intr_info))
                 t4_fatal_err(adapter);
 }
 
@@ -1499,102 +1575,107 @@ static void sge_intr_handler(struct adapter *adapter)
         u64 v;
 
         static const struct intr_info sge_intr_info[] = {
-                { ERR_CPL_EXCEED_IQE_SIZE,
+                { ERR_CPL_EXCEED_IQE_SIZE_F,
                   "SGE received CPL exceeding IQE size", -1, 1 },
-                { ERR_INVALID_CIDX_INC,
+                { ERR_INVALID_CIDX_INC_F,
                   "SGE GTS CIDX increment too large", -1, 0 },
-                { ERR_CPL_OPCODE_0, "SGE received 0-length CPL", -1, 0 },
-                { DBFIFO_LP_INT, NULL, -1, 0, t4_db_full },
-                { DBFIFO_HP_INT, NULL, -1, 0, t4_db_full },
-                { ERR_DROPPED_DB, NULL, -1, 0, t4_db_dropped },
-                { ERR_DATA_CPL_ON_HIGH_QID1 | ERR_DATA_CPL_ON_HIGH_QID0,
+                { ERR_CPL_OPCODE_0_F, "SGE received 0-length CPL", -1, 0 },
+                { DBFIFO_LP_INT_F, NULL, -1, 0, t4_db_full },
+                { DBFIFO_HP_INT_F, NULL, -1, 0, t4_db_full },
+                { ERR_DROPPED_DB_F, NULL, -1, 0, t4_db_dropped },
+                { ERR_DATA_CPL_ON_HIGH_QID1_F | ERR_DATA_CPL_ON_HIGH_QID0_F,
                   "SGE IQID > 1023 received CPL for FL", -1, 0 },
-                { ERR_BAD_DB_PIDX3, "SGE DBP 3 pidx increment too large", -1,
+                { ERR_BAD_DB_PIDX3_F, "SGE DBP 3 pidx increment too large", -1,
                   0 },
-                { ERR_BAD_DB_PIDX2, "SGE DBP 2 pidx increment too large", -1,
+                { ERR_BAD_DB_PIDX2_F, "SGE DBP 2 pidx increment too large", -1,
                   0 },
-                { ERR_BAD_DB_PIDX1, "SGE DBP 1 pidx increment too large", -1,
+                { ERR_BAD_DB_PIDX1_F, "SGE DBP 1 pidx increment too large", -1,
                   0 },
-                { ERR_BAD_DB_PIDX0, "SGE DBP 0 pidx increment too large", -1,
+                { ERR_BAD_DB_PIDX0_F, "SGE DBP 0 pidx increment too large", -1,
                   0 },
-                { ERR_ING_CTXT_PRIO,
+                { ERR_ING_CTXT_PRIO_F,
                   "SGE too many priority ingress contexts", -1, 0 },
-                { ERR_EGR_CTXT_PRIO,
+                { ERR_EGR_CTXT_PRIO_F,
                   "SGE too many priority egress contexts", -1, 0 },
-                { INGRESS_SIZE_ERR, "SGE illegal ingress QID", -1, 0 },
-                { EGRESS_SIZE_ERR, "SGE illegal egress QID", -1, 0 },
+                { INGRESS_SIZE_ERR_F, "SGE illegal ingress QID", -1, 0 },
+                { EGRESS_SIZE_ERR_F, "SGE illegal egress QID", -1, 0 },
                 { 0 }
         };
 
-        v = (u64)t4_read_reg(adapter, SGE_INT_CAUSE1) |
-                ((u64)t4_read_reg(adapter, SGE_INT_CAUSE2) << 32);
+        v = (u64)t4_read_reg(adapter, SGE_INT_CAUSE1_A) |
+                ((u64)t4_read_reg(adapter, SGE_INT_CAUSE2_A) << 32);
         if (v) {
                 dev_alert(adapter->pdev_dev, "SGE parity error (%#llx)\n",
                                 (unsigned long long)v);
-                t4_write_reg(adapter, SGE_INT_CAUSE1, v);
-                t4_write_reg(adapter, SGE_INT_CAUSE2, v >> 32);
+                t4_write_reg(adapter, SGE_INT_CAUSE1_A, v);
+                t4_write_reg(adapter, SGE_INT_CAUSE2_A, v >> 32);
         }
 
-        if (t4_handle_intr_status(adapter, SGE_INT_CAUSE3, sge_intr_info) ||
+        if (t4_handle_intr_status(adapter, SGE_INT_CAUSE3_A, sge_intr_info) ||
             v != 0)
                 t4_fatal_err(adapter);
 }
 
+#define CIM_OBQ_INTR (OBQULP0PARERR_F | OBQULP1PARERR_F | OBQULP2PARERR_F |\
+                      OBQULP3PARERR_F | OBQSGEPARERR_F | OBQNCSIPARERR_F)
+#define CIM_IBQ_INTR (IBQTP0PARERR_F | IBQTP1PARERR_F | IBQULPPARERR_F |\
+                      IBQSGEHIPARERR_F | IBQSGELOPARERR_F | IBQNCSIPARERR_F)
+
 /*
  * CIM interrupt handler.
  */
 static void cim_intr_handler(struct adapter *adapter)
 {
         static const struct intr_info cim_intr_info[] = {
-                { PREFDROPINT, "CIM control register prefetch drop", -1, 1 },
-                { OBQPARERR, "CIM OBQ parity error", -1, 1 },
-                { IBQPARERR, "CIM IBQ parity error", -1, 1 },
-                { MBUPPARERR, "CIM mailbox uP parity error", -1, 1 },
-                { MBHOSTPARERR, "CIM mailbox host parity error", -1, 1 },
-                { TIEQINPARERRINT, "CIM TIEQ outgoing parity error", -1, 1 },
-                { TIEQOUTPARERRINT, "CIM TIEQ incoming parity error", -1, 1 },
+                { PREFDROPINT_F, "CIM control register prefetch drop", -1, 1 },
+                { CIM_OBQ_INTR, "CIM OBQ parity error", -1, 1 },
+                { CIM_IBQ_INTR, "CIM IBQ parity error", -1, 1 },
+                { MBUPPARERR_F, "CIM mailbox uP parity error", -1, 1 },
+                { MBHOSTPARERR_F, "CIM mailbox host parity error", -1, 1 },
+                { TIEQINPARERRINT_F, "CIM TIEQ outgoing parity error", -1, 1 },
+                { TIEQOUTPARERRINT_F, "CIM TIEQ incoming parity error", -1, 1 },
                 { 0 }
         };
         static const struct intr_info cim_upintr_info[] = {
-                { RSVDSPACEINT, "CIM reserved space access", -1, 1 },
-                { ILLTRANSINT, "CIM illegal transaction", -1, 1 },
-                { ILLWRINT, "CIM illegal write", -1, 1 },
-                { ILLRDINT, "CIM illegal read", -1, 1 },
-                { ILLRDBEINT, "CIM illegal read BE", -1, 1 },
-                { ILLWRBEINT, "CIM illegal write BE", -1, 1 },
-                { SGLRDBOOTINT, "CIM single read from boot space", -1, 1 },
-                { SGLWRBOOTINT, "CIM single write to boot space", -1, 1 },
-                { BLKWRBOOTINT, "CIM block write to boot space", -1, 1 },
-                { SGLRDFLASHINT, "CIM single read from flash space", -1, 1 },
-                { SGLWRFLASHINT, "CIM single write to flash space", -1, 1 },
-                { BLKWRFLASHINT, "CIM block write to flash space", -1, 1 },
-                { SGLRDEEPROMINT, "CIM single EEPROM read", -1, 1 },
-                { SGLWREEPROMINT, "CIM single EEPROM write", -1, 1 },
-                { BLKRDEEPROMINT, "CIM block EEPROM read", -1, 1 },
-                { BLKWREEPROMINT, "CIM block EEPROM write", -1, 1 },
-                { SGLRDCTLINT , "CIM single read from CTL space", -1, 1 },
-                { SGLWRCTLINT , "CIM single write to CTL space", -1, 1 },
-                { BLKRDCTLINT , "CIM block read from CTL space", -1, 1 },
-                { BLKWRCTLINT , "CIM block write to CTL space", -1, 1 },
-                { SGLRDPLINT , "CIM single read from PL space", -1, 1 },
-                { SGLWRPLINT , "CIM single write to PL space", -1, 1 },
-                { BLKRDPLINT , "CIM block read from PL space", -1, 1 },
-                { BLKWRPLINT , "CIM block write to PL space", -1, 1 },
-                { REQOVRLOOKUPINT , "CIM request FIFO overwrite", -1, 1 },
-                { RSPOVRLOOKUPINT , "CIM response FIFO overwrite", -1, 1 },
-                { TIMEOUTINT , "CIM PIF timeout", -1, 1 },
-                { TIMEOUTMAINT , "CIM PIF MA timeout", -1, 1 },
+                { RSVDSPACEINT_F, "CIM reserved space access", -1, 1 },
+                { ILLTRANSINT_F, "CIM illegal transaction", -1, 1 },
+                { ILLWRINT_F, "CIM illegal write", -1, 1 },
+                { ILLRDINT_F, "CIM illegal read", -1, 1 },
+                { ILLRDBEINT_F, "CIM illegal read BE", -1, 1 },
+                { ILLWRBEINT_F, "CIM illegal write BE", -1, 1 },
+                { SGLRDBOOTINT_F, "CIM single read from boot space", -1, 1 },
+                { SGLWRBOOTINT_F, "CIM single write to boot space", -1, 1 },
+                { BLKWRBOOTINT_F, "CIM block write to boot space", -1, 1 },
+                { SGLRDFLASHINT_F, "CIM single read from flash space", -1, 1 },
+                { SGLWRFLASHINT_F, "CIM single write to flash space", -1, 1 },
+                { BLKWRFLASHINT_F, "CIM block write to flash space", -1, 1 },
+                { SGLRDEEPROMINT_F, "CIM single EEPROM read", -1, 1 },
+                { SGLWREEPROMINT_F, "CIM single EEPROM write", -1, 1 },
+                { BLKRDEEPROMINT_F, "CIM block EEPROM read", -1, 1 },
+                { BLKWREEPROMINT_F, "CIM block EEPROM write", -1, 1 },
+                { SGLRDCTLINT_F, "CIM single read from CTL space", -1, 1 },
+                { SGLWRCTLINT_F, "CIM single write to CTL space", -1, 1 },
+                { BLKRDCTLINT_F, "CIM block read from CTL space", -1, 1 },
+                { BLKWRCTLINT_F, "CIM block write to CTL space", -1, 1 },
+                { SGLRDPLINT_F, "CIM single read from PL space", -1, 1 },
+                { SGLWRPLINT_F, "CIM single write to PL space", -1, 1 },
+                { BLKRDPLINT_F, "CIM block read from PL space", -1, 1 },
+                { BLKWRPLINT_F, "CIM block write to PL space", -1, 1 },
+                { REQOVRLOOKUPINT_F, "CIM request FIFO overwrite", -1, 1 },
+                { RSPOVRLOOKUPINT_F, "CIM response FIFO overwrite", -1, 1 },
+                { TIMEOUTINT_F, "CIM PIF timeout", -1, 1 },
+                { TIMEOUTMAINT_F, "CIM PIF MA timeout", -1, 1 },
                 { 0 }
         };
 
         int fat;
 
-        if (t4_read_reg(adapter, MA_PCIE_FW) & PCIE_FW_ERR)
+        if (t4_read_reg(adapter, PCIE_FW_A) & PCIE_FW_ERR_F)
                 t4_report_fw_error(adapter);
 
-        fat = t4_handle_intr_status(adapter, CIM_HOST_INT_CAUSE,
+        fat = t4_handle_intr_status(adapter, CIM_HOST_INT_CAUSE_A,
                                     cim_intr_info) +
-              t4_handle_intr_status(adapter, CIM_HOST_UPACC_INT_CAUSE,
+              t4_handle_intr_status(adapter, CIM_HOST_UPACC_INT_CAUSE_A,
                                     cim_upintr_info);
         if (fat)
                 t4_fatal_err(adapter);
@@ -1611,7 +1692,7 @@ static void ulprx_intr_handler(struct adapter *adapter)
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adapter, ULP_RX_INT_CAUSE, ulprx_intr_info))
+        if (t4_handle_intr_status(adapter, ULP_RX_INT_CAUSE_A, ulprx_intr_info))
                 t4_fatal_err(adapter);
 }
 
@@ -1621,19 +1702,19 @@ static void ulprx_intr_handler(struct adapter *adapter)
 static void ulptx_intr_handler(struct adapter *adapter)
 {
         static const struct intr_info ulptx_intr_info[] = {
-                { PBL_BOUND_ERR_CH3, "ULPTX channel 3 PBL out of bounds", -1,
+                { PBL_BOUND_ERR_CH3_F, "ULPTX channel 3 PBL out of bounds", -1,
                   0 },
-                { PBL_BOUND_ERR_CH2, "ULPTX channel 2 PBL out of bounds", -1,
+                { PBL_BOUND_ERR_CH2_F, "ULPTX channel 2 PBL out of bounds", -1,
                   0 },
-                { PBL_BOUND_ERR_CH1, "ULPTX channel 1 PBL out of bounds", -1,
+                { PBL_BOUND_ERR_CH1_F, "ULPTX channel 1 PBL out of bounds", -1,
                   0 },
-                { PBL_BOUND_ERR_CH0, "ULPTX channel 0 PBL out of bounds", -1,
+                { PBL_BOUND_ERR_CH0_F, "ULPTX channel 0 PBL out of bounds", -1,
                   0 },
                 { 0xfffffff, "ULPTX parity error", -1, 1 },
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adapter, ULP_TX_INT_CAUSE, ulptx_intr_info))
+        if (t4_handle_intr_status(adapter, ULP_TX_INT_CAUSE_A, ulptx_intr_info))
                 t4_fatal_err(adapter);
 }
 
@@ -1643,19 +1724,20 @@ static void ulptx_intr_handler(struct adapter *adapter)
 static void pmtx_intr_handler(struct adapter *adapter)
 {
         static const struct intr_info pmtx_intr_info[] = {
-                { PCMD_LEN_OVFL0, "PMTX channel 0 pcmd too large", -1, 1 },
-                { PCMD_LEN_OVFL1, "PMTX channel 1 pcmd too large", -1, 1 },
-                { PCMD_LEN_OVFL2, "PMTX channel 2 pcmd too large", -1, 1 },
-                { ZERO_C_CMD_ERROR, "PMTX 0-length pcmd", -1, 1 },
-                { PMTX_FRAMING_ERROR, "PMTX framing error", -1, 1 },
-                { OESPI_PAR_ERROR, "PMTX oespi parity error", -1, 1 },
-                { DB_OPTIONS_PAR_ERROR, "PMTX db_options parity error", -1, 1 },
-                { ICSPI_PAR_ERROR, "PMTX icspi parity error", -1, 1 },
-                { C_PCMD_PAR_ERROR, "PMTX c_pcmd parity error", -1, 1},
+                { PCMD_LEN_OVFL0_F, "PMTX channel 0 pcmd too large", -1, 1 },
+                { PCMD_LEN_OVFL1_F, "PMTX channel 1 pcmd too large", -1, 1 },
+                { PCMD_LEN_OVFL2_F, "PMTX channel 2 pcmd too large", -1, 1 },
+                { ZERO_C_CMD_ERROR_F, "PMTX 0-length pcmd", -1, 1 },
+                { PMTX_FRAMING_ERROR_F, "PMTX framing error", -1, 1 },
+                { OESPI_PAR_ERROR_F, "PMTX oespi parity error", -1, 1 },
+                { DB_OPTIONS_PAR_ERROR_F, "PMTX db_options parity error",
+                  -1, 1 },
+                { ICSPI_PAR_ERROR_F, "PMTX icspi parity error", -1, 1 },
+                { PMTX_C_PCMD_PAR_ERROR_F, "PMTX c_pcmd parity error", -1, 1},
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adapter, PM_TX_INT_CAUSE, pmtx_intr_info))
+        if (t4_handle_intr_status(adapter, PM_TX_INT_CAUSE_A, pmtx_intr_info))
                 t4_fatal_err(adapter);
 }
 
@@ -1665,16 +1747,17 @@ static void pmtx_intr_handler(struct adapter *adapter)
 static void pmrx_intr_handler(struct adapter *adapter)
 {
         static const struct intr_info pmrx_intr_info[] = {
-                { ZERO_E_CMD_ERROR, "PMRX 0-length pcmd", -1, 1 },
-                { PMRX_FRAMING_ERROR, "PMRX framing error", -1, 1 },
-                { OCSPI_PAR_ERROR, "PMRX ocspi parity error", -1, 1 },
-                { DB_OPTIONS_PAR_ERROR, "PMRX db_options parity error", -1, 1 },
-                { IESPI_PAR_ERROR, "PMRX iespi parity error", -1, 1 },
-                { E_PCMD_PAR_ERROR, "PMRX e_pcmd parity error", -1, 1},
+                { ZERO_E_CMD_ERROR_F, "PMRX 0-length pcmd", -1, 1 },
+                { PMRX_FRAMING_ERROR_F, "PMRX framing error", -1, 1 },
+                { OCSPI_PAR_ERROR_F, "PMRX ocspi parity error", -1, 1 },
+                { DB_OPTIONS_PAR_ERROR_F, "PMRX db_options parity error",
+                  -1, 1 },
+                { IESPI_PAR_ERROR_F, "PMRX iespi parity error", -1, 1 },
+                { PMRX_E_PCMD_PAR_ERROR_F, "PMRX e_pcmd parity error", -1, 1},
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adapter, PM_RX_INT_CAUSE, pmrx_intr_info))
+        if (t4_handle_intr_status(adapter, PM_RX_INT_CAUSE_A, pmrx_intr_info))
                 t4_fatal_err(adapter);
 }
 
@@ -1684,16 +1767,16 @@ static void pmrx_intr_handler(struct adapter *adapter)
 static void cplsw_intr_handler(struct adapter *adapter)
 {
         static const struct intr_info cplsw_intr_info[] = {
-                { CIM_OP_MAP_PERR, "CPLSW CIM op_map parity error", -1, 1 },
-                { CIM_OVFL_ERROR, "CPLSW CIM overflow", -1, 1 },
-                { TP_FRAMING_ERROR, "CPLSW TP framing error", -1, 1 },
-                { SGE_FRAMING_ERROR, "CPLSW SGE framing error", -1, 1 },
-                { CIM_FRAMING_ERROR, "CPLSW CIM framing error", -1, 1 },
-                { ZERO_SWITCH_ERROR, "CPLSW no-switch error", -1, 1 },
+                { CIM_OP_MAP_PERR_F, "CPLSW CIM op_map parity error", -1, 1 },
+                { CIM_OVFL_ERROR_F, "CPLSW CIM overflow", -1, 1 },
+                { TP_FRAMING_ERROR_F, "CPLSW TP framing error", -1, 1 },
+                { SGE_FRAMING_ERROR_F, "CPLSW SGE framing error", -1, 1 },
+                { CIM_FRAMING_ERROR_F, "CPLSW CIM framing error", -1, 1 },
+                { ZERO_SWITCH_ERROR_F, "CPLSW no-switch error", -1, 1 },
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adapter, CPL_INTR_CAUSE, cplsw_intr_info))
+        if (t4_handle_intr_status(adapter, CPL_INTR_CAUSE_A, cplsw_intr_info))
                 t4_fatal_err(adapter);
 }
 
@@ -1703,15 +1786,15 @@ static void cplsw_intr_handler(struct adapter *adapter)
 static void le_intr_handler(struct adapter *adap)
 {
         static const struct intr_info le_intr_info[] = {
-                { LIPMISS, "LE LIP miss", -1, 0 },
-                { LIP0, "LE 0 LIP error", -1, 0 },
-                { PARITYERR, "LE parity error", -1, 1 },
-                { UNKNOWNCMD, "LE unknown command", -1, 1 },
-                { REQQPARERR, "LE request queue parity error", -1, 1 },
+                { LIPMISS_F, "LE LIP miss", -1, 0 },
+                { LIP0_F, "LE 0 LIP error", -1, 0 },
+                { PARITYERR_F, "LE parity error", -1, 1 },
+                { UNKNOWNCMD_F, "LE unknown command", -1, 1 },
+                { REQQPARERR_F, "LE request queue parity error", -1, 1 },
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adap, LE_DB_INT_CAUSE, le_intr_info))
+        if (t4_handle_intr_status(adap, LE_DB_INT_CAUSE_A, le_intr_info))
                 t4_fatal_err(adap);
 }
 
@@ -1725,19 +1808,22 @@ static void mps_intr_handler(struct adapter *adapter)
                 { 0 }
         };
         static const struct intr_info mps_tx_intr_info[] = {
-                { TPFIFO, "MPS Tx TP FIFO parity error", -1, 1 },
-                { NCSIFIFO, "MPS Tx NC-SI FIFO parity error", -1, 1 },
-                { TXDATAFIFO, "MPS Tx data FIFO parity error", -1, 1 },
-                { TXDESCFIFO, "MPS Tx desc FIFO parity error", -1, 1 },
-                { BUBBLE, "MPS Tx underflow", -1, 1 },
-                { SECNTERR, "MPS Tx SOP/EOP error", -1, 1 },
-                { FRMERR, "MPS Tx framing error", -1, 1 },
+                { TPFIFO_V(TPFIFO_M), "MPS Tx TP FIFO parity error", -1, 1 },
+                { NCSIFIFO_F, "MPS Tx NC-SI FIFO parity error", -1, 1 },
+                { TXDATAFIFO_V(TXDATAFIFO_M), "MPS Tx data FIFO parity error",
+                  -1, 1 },
+                { TXDESCFIFO_V(TXDESCFIFO_M), "MPS Tx desc FIFO parity error",
+                  -1, 1 },
+                { BUBBLE_F, "MPS Tx underflow", -1, 1 },
+                { SECNTERR_F, "MPS Tx SOP/EOP error", -1, 1 },
+                { FRMERR_F, "MPS Tx framing error", -1, 1 },
                 { 0 }
         };
         static const struct intr_info mps_trc_intr_info[] = {
-                { FILTMEM, "MPS TRC filter parity error", -1, 1 },
-                { PKTFIFO, "MPS TRC packet FIFO parity error", -1, 1 },
-                { MISCPERR, "MPS TRC misc parity error", -1, 1 },
+                { FILTMEM_V(FILTMEM_M), "MPS TRC filter parity error", -1, 1 },
+                { PKTFIFO_V(PKTFIFO_M), "MPS TRC packet FIFO parity error",
+                  -1, 1 },
+                { MISCPERR_F, "MPS TRC misc parity error", -1, 1 },
                 { 0 }
         };
         static const struct intr_info mps_stat_sram_intr_info[] = {
@@ -1753,37 +1839,37 @@ static void mps_intr_handler(struct adapter *adapter)
                 { 0 }
         };
         static const struct intr_info mps_cls_intr_info[] = {
-                { MATCHSRAM, "MPS match SRAM parity error", -1, 1 },
-                { MATCHTCAM, "MPS match TCAM parity error", -1, 1 },
-                { HASHSRAM, "MPS hash SRAM parity error", -1, 1 },
+                { MATCHSRAM_F, "MPS match SRAM parity error", -1, 1 },
+                { MATCHTCAM_F, "MPS match TCAM parity error", -1, 1 },
+                { HASHSRAM_F, "MPS hash SRAM parity error", -1, 1 },
                 { 0 }
         };
 
         int fat;
 
-        fat = t4_handle_intr_status(adapter, MPS_RX_PERR_INT_CAUSE,
+        fat = t4_handle_intr_status(adapter, MPS_RX_PERR_INT_CAUSE_A,
                                     mps_rx_intr_info) +
-              t4_handle_intr_status(adapter, MPS_TX_INT_CAUSE,
+              t4_handle_intr_status(adapter, MPS_TX_INT_CAUSE_A,
                                     mps_tx_intr_info) +
-              t4_handle_intr_status(adapter, MPS_TRC_INT_CAUSE,
+              t4_handle_intr_status(adapter, MPS_TRC_INT_CAUSE_A,
                                     mps_trc_intr_info) +
-              t4_handle_intr_status(adapter, MPS_STAT_PERR_INT_CAUSE_SRAM,
+              t4_handle_intr_status(adapter, MPS_STAT_PERR_INT_CAUSE_SRAM_A,
                                     mps_stat_sram_intr_info) +
-              t4_handle_intr_status(adapter, MPS_STAT_PERR_INT_CAUSE_TX_FIFO,
+              t4_handle_intr_status(adapter, MPS_STAT_PERR_INT_CAUSE_TX_FIFO_A,
                                     mps_stat_tx_intr_info) +
-              t4_handle_intr_status(adapter, MPS_STAT_PERR_INT_CAUSE_RX_FIFO,
+              t4_handle_intr_status(adapter, MPS_STAT_PERR_INT_CAUSE_RX_FIFO_A,
                                     mps_stat_rx_intr_info) +
-              t4_handle_intr_status(adapter, MPS_CLS_INT_CAUSE,
+              t4_handle_intr_status(adapter, MPS_CLS_INT_CAUSE_A,
                                     mps_cls_intr_info);
 
-        t4_write_reg(adapter, MPS_INT_CAUSE, CLSINT | TRCINT |
-                     RXINT | TXINT | STATINT);
-        t4_read_reg(adapter, MPS_INT_CAUSE);                    /* flush */
+        t4_write_reg(adapter, MPS_INT_CAUSE_A, 0);
+        t4_read_reg(adapter, MPS_INT_CAUSE_A);                    /* flush */
         if (fat)
                 t4_fatal_err(adapter);
 }
 
-#define MEM_INT_MASK (PERR_INT_CAUSE | ECC_CE_INT_CAUSE | ECC_UE_INT_CAUSE)
+#define MEM_INT_MASK (PERR_INT_CAUSE_F | ECC_CE_INT_CAUSE_F | \
+                      ECC_UE_INT_CAUSE_F)
 
 /*
  * EDC/MC interrupt handler.
@@ -1795,40 +1881,40 @@ static void mem_intr_handler(struct adapter *adapter, int idx)
         unsigned int addr, cnt_addr, v;
 
         if (idx <= MEM_EDC1) {
-                addr = EDC_REG(EDC_INT_CAUSE, idx);
-                cnt_addr = EDC_REG(EDC_ECC_STATUS, idx);
+                addr = EDC_REG(EDC_INT_CAUSE_A, idx);
+                cnt_addr = EDC_REG(EDC_ECC_STATUS_A, idx);
         } else if (idx == MEM_MC) {
                 if (is_t4(adapter->params.chip)) {
-                        addr = MC_INT_CAUSE;
-                        cnt_addr = MC_ECC_STATUS;
+                        addr = MC_INT_CAUSE_A;
+                        cnt_addr = MC_ECC_STATUS_A;
                 } else {
-                        addr = MC_P_INT_CAUSE;
-                        cnt_addr = MC_P_ECC_STATUS;
+                        addr = MC_P_INT_CAUSE_A;
+                        cnt_addr = MC_P_ECC_STATUS_A;
                 }
         } else {
-                addr = MC_REG(MC_P_INT_CAUSE, 1);
-                cnt_addr = MC_REG(MC_P_ECC_STATUS, 1);
+                addr = MC_REG(MC_P_INT_CAUSE_A, 1);
+                cnt_addr = MC_REG(MC_P_ECC_STATUS_A, 1);
         }
 
         v = t4_read_reg(adapter, addr) & MEM_INT_MASK;
-        if (v & PERR_INT_CAUSE)
+        if (v & PERR_INT_CAUSE_F)
                 dev_alert(adapter->pdev_dev, "%s FIFO parity error\n",
                           name[idx]);
-        if (v & ECC_CE_INT_CAUSE) {
-                u32 cnt = ECC_CECNT_GET(t4_read_reg(adapter, cnt_addr));
+        if (v & ECC_CE_INT_CAUSE_F) {
+                u32 cnt = ECC_CECNT_G(t4_read_reg(adapter, cnt_addr));
 
-                t4_write_reg(adapter, cnt_addr, ECC_CECNT_MASK);
+                t4_write_reg(adapter, cnt_addr, ECC_CECNT_V(ECC_CECNT_M));
                 if (printk_ratelimit())
                         dev_warn(adapter->pdev_dev,
                                  "%u %s correctable ECC data error%s\n",
                                  cnt, name[idx], cnt > 1 ? "s" : "");
         }
-        if (v & ECC_UE_INT_CAUSE)
+        if (v & ECC_UE_INT_CAUSE_F)
                 dev_alert(adapter->pdev_dev,
                           "%s uncorrectable ECC data error\n", name[idx]);
 
         t4_write_reg(adapter, addr, v);
-        if (v & (PERR_INT_CAUSE | ECC_UE_INT_CAUSE))
+        if (v & (PERR_INT_CAUSE_F | ECC_UE_INT_CAUSE_F))
                 t4_fatal_err(adapter);
 }
 
@@ -1837,26 +1923,26 @@ static void mem_intr_handler(struct adapter *adapter, int idx)
  */
 static void ma_intr_handler(struct adapter *adap)
 {
-        u32 v, status = t4_read_reg(adap, MA_INT_CAUSE);
+        u32 v, status = t4_read_reg(adap, MA_INT_CAUSE_A);
 
-        if (status & MEM_PERR_INT_CAUSE) {
+        if (status & MEM_PERR_INT_CAUSE_F) {
                 dev_alert(adap->pdev_dev,
                           "MA parity error, parity status %#x\n",
-                          t4_read_reg(adap, MA_PARITY_ERROR_STATUS));
+                          t4_read_reg(adap, MA_PARITY_ERROR_STATUS1_A));
                 if (is_t5(adap->params.chip))
                         dev_alert(adap->pdev_dev,
                                   "MA parity error, parity status %#x\n",
                                   t4_read_reg(adap,
-                                              MA_PARITY_ERROR_STATUS2));
+                                              MA_PARITY_ERROR_STATUS2_A));
         }
-        if (status & MEM_WRAP_INT_CAUSE) {
-                v = t4_read_reg(adap, MA_INT_WRAP_STATUS);
+        if (status & MEM_WRAP_INT_CAUSE_F) {
+                v = t4_read_reg(adap, MA_INT_WRAP_STATUS_A);
                 dev_alert(adap->pdev_dev, "MA address wrap-around error by "
                           "client %u to address %#x\n",
-                          MEM_WRAP_CLIENT_NUM_GET(v),
-                          MEM_WRAP_ADDRESS_GET(v) << 4);
+                          MEM_WRAP_CLIENT_NUM_G(v),
+                          MEM_WRAP_ADDRESS_G(v) << 4);
         }
-        t4_write_reg(adap, MA_INT_CAUSE, status);
+        t4_write_reg(adap, MA_INT_CAUSE_A, status);
         t4_fatal_err(adap);
 }
 
@@ -1866,13 +1952,13 @@ static void ma_intr_handler(struct adapter *adap)
 static void smb_intr_handler(struct adapter *adap)
 {
         static const struct intr_info smb_intr_info[] = {
-                { MSTTXFIFOPARINT, "SMB master Tx FIFO parity error", -1, 1 },
-                { MSTRXFIFOPARINT, "SMB master Rx FIFO parity error", -1, 1 },
-                { SLVFIFOPARINT, "SMB slave FIFO parity error", -1, 1 },
+                { MSTTXFIFOPARINT_F, "SMB master Tx FIFO parity error", -1, 1 },
+                { MSTRXFIFOPARINT_F, "SMB master Rx FIFO parity error", -1, 1 },
+                { SLVFIFOPARINT_F, "SMB slave FIFO parity error", -1, 1 },
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adap, SMB_INT_CAUSE, smb_intr_info))
+        if (t4_handle_intr_status(adap, SMB_INT_CAUSE_A, smb_intr_info))
                 t4_fatal_err(adap);
 }
 
@@ -1882,14 +1968,14 @@ static void smb_intr_handler(struct adapter *adap)
 static void ncsi_intr_handler(struct adapter *adap)
 {
         static const struct intr_info ncsi_intr_info[] = {
-                { CIM_DM_PRTY_ERR, "NC-SI CIM parity error", -1, 1 },
-                { MPS_DM_PRTY_ERR, "NC-SI MPS parity error", -1, 1 },
-                { TXFIFO_PRTY_ERR, "NC-SI Tx FIFO parity error", -1, 1 },
-                { RXFIFO_PRTY_ERR, "NC-SI Rx FIFO parity error", -1, 1 },
+                { CIM_DM_PRTY_ERR_F, "NC-SI CIM parity error", -1, 1 },
+                { MPS_DM_PRTY_ERR_F, "NC-SI MPS parity error", -1, 1 },
+                { TXFIFO_PRTY_ERR_F, "NC-SI Tx FIFO parity error", -1, 1 },
+                { RXFIFO_PRTY_ERR_F, "NC-SI Rx FIFO parity error", -1, 1 },
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adap, NCSI_INT_CAUSE, ncsi_intr_info))
+        if (t4_handle_intr_status(adap, NCSI_INT_CAUSE_A, ncsi_intr_info))
                 t4_fatal_err(adap);
 }
 
@@ -1901,23 +1987,23 @@ static void xgmac_intr_handler(struct adapter *adap, int port)
         u32 v, int_cause_reg;
 
         if (is_t4(adap->params.chip))
-                int_cause_reg = PORT_REG(port, XGMAC_PORT_INT_CAUSE);
+                int_cause_reg = PORT_REG(port, XGMAC_PORT_INT_CAUSE_A);
         else
-                int_cause_reg = T5_PORT_REG(port, MAC_PORT_INT_CAUSE);
+                int_cause_reg = T5_PORT_REG(port, MAC_PORT_INT_CAUSE_A);
 
         v = t4_read_reg(adap, int_cause_reg);
 
-        v &= TXFIFO_PRTY_ERR | RXFIFO_PRTY_ERR;
+        v &= TXFIFO_PRTY_ERR_F | RXFIFO_PRTY_ERR_F;
         if (!v)
                 return;
 
-        if (v & TXFIFO_PRTY_ERR)
+        if (v & TXFIFO_PRTY_ERR_F)
                 dev_alert(adap->pdev_dev, "XGMAC %d Tx FIFO parity error\n",
                           port);
-        if (v & RXFIFO_PRTY_ERR)
+        if (v & RXFIFO_PRTY_ERR_F)
                 dev_alert(adap->pdev_dev, "XGMAC %d Rx FIFO parity error\n",
                           port);
-        t4_write_reg(adap, PORT_REG(port, XGMAC_PORT_INT_CAUSE), v);
+        t4_write_reg(adap, PORT_REG(port, XGMAC_PORT_INT_CAUSE_A), v);
         t4_fatal_err(adap);
 }
 
@@ -1927,19 +2013,19 @@ static void xgmac_intr_handler(struct adapter *adap, int port)
 static void pl_intr_handler(struct adapter *adap)
 {
         static const struct intr_info pl_intr_info[] = {
-                { FATALPERR, "T4 fatal parity error", -1, 1 },
-                { PERRVFID, "PL VFID_MAP parity error", -1, 1 },
+                { FATALPERR_F, "T4 fatal parity error", -1, 1 },
+                { PERRVFID_F, "PL VFID_MAP parity error", -1, 1 },
                 { 0 }
         };
 
-        if (t4_handle_intr_status(adap, PL_PL_INT_CAUSE, pl_intr_info))
+        if (t4_handle_intr_status(adap, PL_PL_INT_CAUSE_A, pl_intr_info))
                 t4_fatal_err(adap);
 }
 
-#define PF_INTR_MASK (PFSW)
-#define GLBL_INTR_MASK (CIM | MPS | PL | PCIE | MC | EDC0 | \
-                EDC1 | LE | TP | MA | PM_TX | PM_RX | ULP_RX | \
-                CPL_SWITCH | SGE | ULP_TX)
+#define PF_INTR_MASK (PFSW_F)
+#define GLBL_INTR_MASK (CIM_F | MPS_F | PL_F | PCIE_F | MC_F | EDC0_F | \
+                EDC1_F | LE_F | TP_F | MA_F | PM_TX_F | PM_RX_F | ULP_RX_F | \
+                CPL_SWITCH_F | SGE_F | ULP_TX_F)
 
 /**
  *      t4_slow_intr_handler - control path interrupt handler
@@ -1951,60 +2037,60 @@ static void pl_intr_handler(struct adapter *adap)
  */
 int t4_slow_intr_handler(struct adapter *adapter)
 {
-        u32 cause = t4_read_reg(adapter, PL_INT_CAUSE);
+        u32 cause = t4_read_reg(adapter, PL_INT_CAUSE_A);
 
         if (!(cause & GLBL_INTR_MASK))
                 return 0;
-        if (cause & CIM)
+        if (cause & CIM_F)
                 cim_intr_handler(adapter);
-        if (cause & MPS)
+        if (cause & MPS_F)
                 mps_intr_handler(adapter);
-        if (cause & NCSI)
+        if (cause & NCSI_F)
                 ncsi_intr_handler(adapter);
-        if (cause & PL)
+        if (cause & PL_F)
                 pl_intr_handler(adapter);
-        if (cause & SMB)
+        if (cause & SMB_F)
                 smb_intr_handler(adapter);
-        if (cause & XGMAC0)
+        if (cause & XGMAC0_F)
                 xgmac_intr_handler(adapter, 0);
-        if (cause & XGMAC1)
+        if (cause & XGMAC1_F)
                 xgmac_intr_handler(adapter, 1);
-        if (cause & XGMAC_KR0)
+        if (cause & XGMAC_KR0_F)
                 xgmac_intr_handler(adapter, 2);
-        if (cause & XGMAC_KR1)
+        if (cause & XGMAC_KR1_F)
                 xgmac_intr_handler(adapter, 3);
-        if (cause & PCIE)
+        if (cause & PCIE_F)
                 pcie_intr_handler(adapter);
-        if (cause & MC)
+        if (cause & MC_F)
                 mem_intr_handler(adapter, MEM_MC);
-        if (!is_t4(adapter->params.chip) && (cause & MC1))
+        if (!is_t4(adapter->params.chip) && (cause & MC1_S))
                 mem_intr_handler(adapter, MEM_MC1);
-        if (cause & EDC0)
+        if (cause & EDC0_F)
                 mem_intr_handler(adapter, MEM_EDC0);
-        if (cause & EDC1)
+        if (cause & EDC1_F)
                 mem_intr_handler(adapter, MEM_EDC1);
-        if (cause & LE)
+        if (cause & LE_F)
                 le_intr_handler(adapter);
-        if (cause & TP)
+        if (cause & TP_F)
                 tp_intr_handler(adapter);
-        if (cause & MA)
+        if (cause & MA_F)
                 ma_intr_handler(adapter);
-        if (cause & PM_TX)
+        if (cause & PM_TX_F)
                 pmtx_intr_handler(adapter);
-        if (cause & PM_RX)
+        if (cause & PM_RX_F)
                 pmrx_intr_handler(adapter);
-        if (cause & ULP_RX)
+        if (cause & ULP_RX_F)
                 ulprx_intr_handler(adapter);
-        if (cause & CPL_SWITCH)
+        if (cause & CPL_SWITCH_F)
                 cplsw_intr_handler(adapter);
-        if (cause & SGE)
+        if (cause & SGE_F)
                 sge_intr_handler(adapter);
-        if (cause & ULP_TX)
+        if (cause & ULP_TX_F)
                 ulptx_intr_handler(adapter);
 
         /* Clear the interrupts just processed for which we are the master. */
-        t4_write_reg(adapter, PL_INT_CAUSE, cause & GLBL_INTR_MASK);
-        (void) t4_read_reg(adapter, PL_INT_CAUSE); /* flush */
+        t4_write_reg(adapter, PL_INT_CAUSE_A, cause & GLBL_INTR_MASK);
+        (void)t4_read_reg(adapter, PL_INT_CAUSE_A); /* flush */
         return 1;
 }
 
@@ -2023,19 +2109,19 @@ int t4_slow_intr_handler(struct adapter *adapter)
  */
 void t4_intr_enable(struct adapter *adapter)
 {
-        u32 pf = SOURCEPF_GET(t4_read_reg(adapter, PL_WHOAMI));
-
-        t4_write_reg(adapter, SGE_INT_ENABLE3, ERR_CPL_EXCEED_IQE_SIZE |
-                     ERR_INVALID_CIDX_INC | ERR_CPL_OPCODE_0 |
-                     ERR_DROPPED_DB | ERR_DATA_CPL_ON_HIGH_QID1 |
-                     ERR_DATA_CPL_ON_HIGH_QID0 | ERR_BAD_DB_PIDX3 |
-                     ERR_BAD_DB_PIDX2 | ERR_BAD_DB_PIDX1 |
-                     ERR_BAD_DB_PIDX0 | ERR_ING_CTXT_PRIO |
-                     ERR_EGR_CTXT_PRIO | INGRESS_SIZE_ERR |
-                     DBFIFO_HP_INT | DBFIFO_LP_INT |
-                     EGRESS_SIZE_ERR);
-        t4_write_reg(adapter, MYPF_REG(PL_PF_INT_ENABLE), PF_INTR_MASK);
-        t4_set_reg_field(adapter, PL_INT_MAP0, 0, 1 << pf);
+        u32 pf = SOURCEPF_G(t4_read_reg(adapter, PL_WHOAMI_A));
+
+        t4_write_reg(adapter, SGE_INT_ENABLE3_A, ERR_CPL_EXCEED_IQE_SIZE_F |
+                     ERR_INVALID_CIDX_INC_F | ERR_CPL_OPCODE_0_F |
+                     ERR_DROPPED_DB_F | ERR_DATA_CPL_ON_HIGH_QID1_F |
+                     ERR_DATA_CPL_ON_HIGH_QID0_F | ERR_BAD_DB_PIDX3_F |
+                     ERR_BAD_DB_PIDX2_F | ERR_BAD_DB_PIDX1_F |
+                     ERR_BAD_DB_PIDX0_F | ERR_ING_CTXT_PRIO_F |
+                     ERR_EGR_CTXT_PRIO_F | INGRESS_SIZE_ERR_F |
+                     DBFIFO_HP_INT_F | DBFIFO_LP_INT_F |
+                     EGRESS_SIZE_ERR_F);
+        t4_write_reg(adapter, MYPF_REG(PL_PF_INT_ENABLE_A), PF_INTR_MASK);
+        t4_set_reg_field(adapter, PL_INT_MAP0_A, 0, 1 << pf);
 }
 
 /**
@@ -2048,10 +2134,10 @@ void t4_intr_enable(struct adapter *adapter)
  */
 void t4_intr_disable(struct adapter *adapter)
 {
-        u32 pf = SOURCEPF_GET(t4_read_reg(adapter, PL_WHOAMI));
+        u32 pf = SOURCEPF_G(t4_read_reg(adapter, PL_WHOAMI_A));
 
-        t4_write_reg(adapter, MYPF_REG(PL_PF_INT_ENABLE), 0);
-        t4_set_reg_field(adapter, PL_INT_MAP0, 1 << pf, 0);
+        t4_write_reg(adapter, MYPF_REG(PL_PF_INT_ENABLE_A), 0);
+        t4_set_reg_field(adapter, PL_INT_MAP0_A, 1 << pf, 0);
 }
 
 /**
@@ -2166,6 +2252,147 @@ int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode,
         return t4_wr_mbox(adapter, mbox, &c, sizeof(c), NULL);
 }
 
+/* Read an RSS table row */
+static int rd_rss_row(struct adapter *adap, int row, u32 *val)
+{
+        t4_write_reg(adap, TP_RSS_LKP_TABLE_A, 0xfff00000 | row);
+        return t4_wait_op_done_val(adap, TP_RSS_LKP_TABLE_A, LKPTBLROWVLD_F, 1,
+                                   5, 0, val);
+}
+
+/**
+ *      t4_read_rss - read the contents of the RSS mapping table
+ *      @adapter: the adapter
+ *      @map: holds the contents of the RSS mapping table
+ *
+ *      Reads the contents of the RSS hash->queue mapping table.
+ */
+int t4_read_rss(struct adapter *adapter, u16 *map)
+{
+        u32 val;
+        int i, ret;
+
+        for (i = 0; i < RSS_NENTRIES / 2; ++i) {
+                ret = rd_rss_row(adapter, i, &val);
+                if (ret)
+                        return ret;
+                *map++ = LKPTBLQUEUE0_G(val);
+                *map++ = LKPTBLQUEUE1_G(val);
+        }
+        return 0;
+}
+
+/**
+ *      t4_read_rss_key - read the global RSS key
+ *      @adap: the adapter
+ *      @key: 10-entry array holding the 320-bit RSS key
+ *
+ *      Reads the global 320-bit RSS key.
+ */
+void t4_read_rss_key(struct adapter *adap, u32 *key)
+{
+        t4_read_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A, key, 10,
+                         TP_RSS_SECRET_KEY0_A);
+}
+
+/**
+ *      t4_write_rss_key - program one of the RSS keys
+ *      @adap: the adapter
+ *      @key: 10-entry array holding the 320-bit RSS key
+ *      @idx: which RSS key to write
+ *
+ *      Writes one of the RSS keys with the given 320-bit value.  If @idx is
+ *      0..15 the corresponding entry in the RSS key table is written,
+ *      otherwise the global RSS key is written.
+ */
+void t4_write_rss_key(struct adapter *adap, const u32 *key, int idx)
+{
+        t4_write_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A, key, 10,
+                          TP_RSS_SECRET_KEY0_A);
+        if (idx >= 0 && idx < 16)
+                t4_write_reg(adap, TP_RSS_CONFIG_VRT_A,
+                             KEYWRADDR_V(idx) | KEYWREN_F);
+}
+
+/**
+ *      t4_read_rss_pf_config - read PF RSS Configuration Table
+ *      @adapter: the adapter
+ *      @index: the entry in the PF RSS table to read
+ *      @valp: where to store the returned value
+ *
+ *      Reads the PF RSS Configuration Table at the specified index and returns
+ *      the value found there.
+ */
+void t4_read_rss_pf_config(struct adapter *adapter, unsigned int index,
+                           u32 *valp)
+{
+        t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
+                         valp, 1, TP_RSS_PF0_CONFIG_A + index);
+}
+
+/**
+ *      t4_read_rss_vf_config - read VF RSS Configuration Table
+ *      @adapter: the adapter
+ *      @index: the entry in the VF RSS table to read
+ *      @vfl: where to store the returned VFL
+ *      @vfh: where to store the returned VFH
+ *
+ *      Reads the VF RSS Configuration Table at the specified index and returns
+ *      the (VFL, VFH) values found there.
+ */
+void t4_read_rss_vf_config(struct adapter *adapter, unsigned int index,
+                           u32 *vfl, u32 *vfh)
+{
+        u32 vrt, mask, data;
+
+        mask = VFWRADDR_V(VFWRADDR_M);
+        data = VFWRADDR_V(index);
+
+        /* Request that the index'th VF Table values be read into VFL/VFH.
+         */
+        vrt = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A);
+        vrt &= ~(VFRDRG_F | VFWREN_F | KEYWREN_F | mask);
+        vrt |= data | VFRDEN_F;
+        t4_write_reg(adapter, TP_RSS_CONFIG_VRT_A, vrt);
+
+        /* Grab the VFL/VFH values ...
+         */
+        t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
+                         vfl, 1, TP_RSS_VFL_CONFIG_A);
+        t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
+                         vfh, 1, TP_RSS_VFH_CONFIG_A);
+}
+
+/**
+ *      t4_read_rss_pf_map - read PF RSS Map
+ *      @adapter: the adapter
+ *
+ *      Reads the PF RSS Map register and returns its value.
+ */
+u32 t4_read_rss_pf_map(struct adapter *adapter)
+{
+        u32 pfmap;
+
+        t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
+                         &pfmap, 1, TP_RSS_PF_MAP_A);
+        return pfmap;
+}
+
+/**
+ *      t4_read_rss_pf_mask - read PF RSS Mask
+ *      @adapter: the adapter
+ *
+ *      Reads the PF RSS Mask register and returns its value.
+ */
+u32 t4_read_rss_pf_mask(struct adapter *adapter)
+{
+        u32 pfmask;
+
+        t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
+                         &pfmask, 1, TP_RSS_PF_MSK_A);
+        return pfmask;
+}
+
 /**
  *      t4_tp_get_tcp_stats - read TP's TCP MIB counters
  *      @adap: the adapter
@@ -2178,23 +2405,23 @@ int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode,
 void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4,
                          struct tp_tcp_stats *v6)
 {
-        u32 val[TP_MIB_TCP_RXT_SEG_LO - TP_MIB_TCP_OUT_RST + 1];
+        u32 val[TP_MIB_TCP_RXT_SEG_LO_A - TP_MIB_TCP_OUT_RST_A + 1];
 
-#define STAT_IDX(x) ((TP_MIB_TCP_##x) - TP_MIB_TCP_OUT_RST)
+#define STAT_IDX(x) ((TP_MIB_TCP_##x##_A) - TP_MIB_TCP_OUT_RST_A)
 #define STAT(x)     val[STAT_IDX(x)]
 #define STAT64(x)   (((u64)STAT(x##_HI) << 32) | STAT(x##_LO))
 
         if (v4) {
-                t4_read_indirect(adap, TP_MIB_INDEX, TP_MIB_DATA, val,
-                                 ARRAY_SIZE(val), TP_MIB_TCP_OUT_RST);
+                t4_read_indirect(adap, TP_MIB_INDEX_A, TP_MIB_DATA_A, val,
+                                 ARRAY_SIZE(val), TP_MIB_TCP_OUT_RST_A);
                 v4->tcpOutRsts = STAT(OUT_RST);
                 v4->tcpInSegs  = STAT64(IN_SEG);
                 v4->tcpOutSegs = STAT64(OUT_SEG);
                 v4->tcpRetransSegs = STAT64(RXT_SEG);
         }
         if (v6) {
-                t4_read_indirect(adap, TP_MIB_INDEX, TP_MIB_DATA, val,
-                                 ARRAY_SIZE(val), TP_MIB_TCP_V6OUT_RST);
+                t4_read_indirect(adap, TP_MIB_INDEX_A, TP_MIB_DATA_A, val,
+                                 ARRAY_SIZE(val), TP_MIB_TCP_V6OUT_RST_A);
                 v6->tcpOutRsts = STAT(OUT_RST);
                 v6->tcpInSegs  = STAT64(IN_SEG);
                 v6->tcpOutSegs = STAT64(OUT_SEG);
@@ -2219,16 +2446,37 @@ void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log)
         int i;
 
         for (i = 0; i < NMTUS; ++i) {
-                t4_write_reg(adap, TP_MTU_TABLE,
-                             MTUINDEX(0xff) | MTUVALUE(i));
-                v = t4_read_reg(adap, TP_MTU_TABLE);
-                mtus[i] = MTUVALUE_GET(v);
+                t4_write_reg(adap, TP_MTU_TABLE_A,
+                             MTUINDEX_V(0xff) | MTUVALUE_V(i));
+                v = t4_read_reg(adap, TP_MTU_TABLE_A);
+                mtus[i] = MTUVALUE_G(v);
                 if (mtu_log)
-                        mtu_log[i] = MTUWIDTH_GET(v);
+                        mtu_log[i] = MTUWIDTH_G(v);
         }
 }
 
 /**
+ *      t4_read_cong_tbl - reads the congestion control table
+ *      @adap: the adapter
+ *      @incr: where to store the alpha values
+ *
+ *      Reads the additive increments programmed into the HW congestion
+ *      control table.
+ */
+void t4_read_cong_tbl(struct adapter *adap, u16 incr[NMTUS][NCCTRL_WIN])
+{
+        unsigned int mtu, w;
+
+        for (mtu = 0; mtu < NMTUS; ++mtu)
+                for (w = 0; w < NCCTRL_WIN; ++w) {
+                        t4_write_reg(adap, TP_CCTRL_TABLE_A,
+                                     ROWINDEX_V(0xffff) | (mtu << 5) | w);
+                        incr[mtu][w] = (u16)t4_read_reg(adap,
+                                                TP_CCTRL_TABLE_A) & 0x1fff;
+                }
+}
+
+/**
  *      t4_tp_wr_bits_indirect - set/clear bits in an indirect TP register
  *      @adap: the adapter
  *      @addr: the indirect TP register address
@@ -2240,9 +2488,9 @@ void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log)
 void t4_tp_wr_bits_indirect(struct adapter *adap, unsigned int addr,
                             unsigned int mask, unsigned int val)
 {
-        t4_write_reg(adap, TP_PIO_ADDR, addr);
-        val |= t4_read_reg(adap, TP_PIO_DATA) & ~mask;
-        t4_write_reg(adap, TP_PIO_DATA, val);
+        t4_write_reg(adap, TP_PIO_ADDR_A, addr);
+        val |= t4_read_reg(adap, TP_PIO_DATA_A) & ~mask;
+        t4_write_reg(adap, TP_PIO_DATA_A, val);
 }
 
 /**
@@ -2321,8 +2569,8 @@ void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
 
                 if (!(mtu & ((1 << log2) >> 2)))     /* round */
                         log2--;
-                t4_write_reg(adap, TP_MTU_TABLE, MTUINDEX(i) |
-                             MTUWIDTH(log2) | MTUVALUE(mtu));
+                t4_write_reg(adap, TP_MTU_TABLE_A, MTUINDEX_V(i) |
+                             MTUWIDTH_V(log2) | MTUVALUE_V(mtu));
 
                 for (w = 0; w < NCCTRL_WIN; ++w) {
                         unsigned int inc;
@@ -2330,13 +2578,67 @@ void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
                         inc = max(((mtu - 40) * alpha[w]) / avg_pkts[w],
                                   CC_MIN_INCR);
 
-                        t4_write_reg(adap, TP_CCTRL_TABLE, (i << 21) |
+                        t4_write_reg(adap, TP_CCTRL_TABLE_A, (i << 21) |
                                      (w << 16) | (beta[w] << 13) | inc);
                 }
         }
 }
 
 /**
+ *      t4_pmtx_get_stats - returns the HW stats from PMTX
+ *      @adap: the adapter
+ *      @cnt: where to store the count statistics
+ *      @cycles: where to store the cycle statistics
+ *
+ *      Returns performance statistics from PMTX.
+ */
+void t4_pmtx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[])
+{
+        int i;
+        u32 data[2];
+
+        for (i = 0; i < PM_NSTATS; i++) {
+                t4_write_reg(adap, PM_TX_STAT_CONFIG_A, i + 1);
+                cnt[i] = t4_read_reg(adap, PM_TX_STAT_COUNT_A);
+                if (is_t4(adap->params.chip)) {
+                        cycles[i] = t4_read_reg64(adap, PM_TX_STAT_LSB_A);
+                } else {
+                        t4_read_indirect(adap, PM_TX_DBG_CTRL_A,
+                                         PM_TX_DBG_DATA_A, data, 2,
+                                         PM_TX_DBG_STAT_MSB_A);
+                        cycles[i] = (((u64)data[0] << 32) | data[1]);
+                }
+        }
+}
+
+/**
+ *      t4_pmrx_get_stats - returns the HW stats from PMRX
+ *      @adap: the adapter
+ *      @cnt: where to store the count statistics
+ *      @cycles: where to store the cycle statistics
+ *
+ *      Returns performance statistics from PMRX.
+ */
+void t4_pmrx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[])
+{
+        int i;
+        u32 data[2];
+
+        for (i = 0; i < PM_NSTATS; i++) {
+                t4_write_reg(adap, PM_RX_STAT_CONFIG_A, i + 1);
+                cnt[i] = t4_read_reg(adap, PM_RX_STAT_COUNT_A);
+                if (is_t4(adap->params.chip)) {
+                        cycles[i] = t4_read_reg64(adap, PM_RX_STAT_LSB_A);
+                } else {
+                        t4_read_indirect(adap, PM_RX_DBG_CTRL_A,
+                                         PM_RX_DBG_DATA_A, data, 2,
+                                         PM_RX_DBG_STAT_MSB_A);
+                        cycles[i] = (((u64)data[0] << 32) | data[1]);
+                }
+        }
+}
+
+/**
  *      get_mps_bg_map - return the buffer groups associated with a port
  *      @adap: the adapter
  *      @idx: the port index
@@ -2347,7 +2649,7 @@ void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
  */
 static unsigned int get_mps_bg_map(struct adapter *adap, int idx)
 {
-        u32 n = NUMPORTS_GET(t4_read_reg(adap, MPS_CMN_CTL));
+        u32 n = NUMPORTS_G(t4_read_reg(adap, MPS_CMN_CTL_A));
 
         if (n == 0)
                 return idx == 0 ? 0xf : 0;
@@ -2485,11 +2787,11 @@ void t4_wol_magic_enable(struct adapter *adap, unsigned int port,
         if (is_t4(adap->params.chip)) {
                 mag_id_reg_l = PORT_REG(port, XGMAC_PORT_MAGIC_MACID_LO);
                 mag_id_reg_h = PORT_REG(port, XGMAC_PORT_MAGIC_MACID_HI);
-                port_cfg_reg = PORT_REG(port, XGMAC_PORT_CFG2);
+                port_cfg_reg = PORT_REG(port, XGMAC_PORT_CFG2_A);
         } else {
                 mag_id_reg_l = T5_PORT_REG(port, MAC_PORT_MAGIC_MACID_LO);
                 mag_id_reg_h = T5_PORT_REG(port, MAC_PORT_MAGIC_MACID_HI);
-                port_cfg_reg = T5_PORT_REG(port, MAC_PORT_CFG2);
+                port_cfg_reg = T5_PORT_REG(port, MAC_PORT_CFG2_A);
         }
 
         if (addr) {
@@ -2499,8 +2801,8 @@ void t4_wol_magic_enable(struct adapter *adap, unsigned int port,
                 t4_write_reg(adap, mag_id_reg_h,
                              (addr[0] << 8) | addr[1]);
         }
-        t4_set_reg_field(adap, port_cfg_reg, MAGICEN,
-                         addr ? MAGICEN : 0);
+        t4_set_reg_field(adap, port_cfg_reg, MAGICEN_F,
+                         addr ? MAGICEN_F : 0);
 }
 
 /**
@@ -2525,20 +2827,21 @@ int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map,
         u32 port_cfg_reg;
 
         if (is_t4(adap->params.chip))
-                port_cfg_reg = PORT_REG(port, XGMAC_PORT_CFG2);
+                port_cfg_reg = PORT_REG(port, XGMAC_PORT_CFG2_A);
         else
-                port_cfg_reg = T5_PORT_REG(port, MAC_PORT_CFG2);
+                port_cfg_reg = T5_PORT_REG(port, MAC_PORT_CFG2_A);
 
         if (!enable) {
-                t4_set_reg_field(adap, port_cfg_reg, PATEN, 0);
+                t4_set_reg_field(adap, port_cfg_reg, PATEN_F, 0);
                 return 0;
         }
         if (map > 0xff)
                 return -EINVAL;
 
 #define EPIO_REG(name) \
-        (is_t4(adap->params.chip) ? PORT_REG(port, XGMAC_PORT_EPIO_##name) : \
-        T5_PORT_REG(port, MAC_PORT_EPIO_##name))
+        (is_t4(adap->params.chip) ? \
+         PORT_REG(port, XGMAC_PORT_EPIO_##name##_A) : \
+         T5_PORT_REG(port, MAC_PORT_EPIO_##name##_A))
 
         t4_write_reg(adap, EPIO_REG(DATA1), mask0 >> 32);
         t4_write_reg(adap, EPIO_REG(DATA2), mask1);
@@ -2550,21 +2853,21 @@ int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map,
 
                 /* write byte masks */
                 t4_write_reg(adap, EPIO_REG(DATA0), mask0);
-                t4_write_reg(adap, EPIO_REG(OP), ADDRESS(i) | EPIOWR);
+                t4_write_reg(adap, EPIO_REG(OP), ADDRESS_V(i) | EPIOWR_F);
                 t4_read_reg(adap, EPIO_REG(OP));                /* flush */
-                if (t4_read_reg(adap, EPIO_REG(OP)) & SF_BUSY)
+                if (t4_read_reg(adap, EPIO_REG(OP)) & SF_BUSY_F)
                         return -ETIMEDOUT;
 
                 /* write CRC */
                 t4_write_reg(adap, EPIO_REG(DATA0), crc);
-                t4_write_reg(adap, EPIO_REG(OP), ADDRESS(i + 32) | EPIOWR);
+                t4_write_reg(adap, EPIO_REG(OP), ADDRESS_V(i + 32) | EPIOWR_F);
                 t4_read_reg(adap, EPIO_REG(OP));                /* flush */
-                if (t4_read_reg(adap, EPIO_REG(OP)) & SF_BUSY)
+                if (t4_read_reg(adap, EPIO_REG(OP)) & SF_BUSY_F)
                         return -ETIMEDOUT;
         }
 #undef EPIO_REG
 
-        t4_set_reg_field(adap, PORT_REG(port, XGMAC_PORT_CFG2), 0, PATEN);
+        t4_set_reg_field(adap, PORT_REG(port, XGMAC_PORT_CFG2_A), 0, PATEN_F);
         return 0;
 }
 
@@ -2749,9 +3052,9 @@ void t4_sge_decode_idma_state(struct adapter *adapter, int state)
                 "IDMA_FL_SEND_COMPLETION_TO_IMSG",
         };
         static const u32 sge_regs[] = {
-                SGE_DEBUG_DATA_LOW_INDEX_2,
-                SGE_DEBUG_DATA_LOW_INDEX_3,
-                SGE_DEBUG_DATA_HIGH_INDEX_10,
+                SGE_DEBUG_DATA_LOW_INDEX_2_A,
+                SGE_DEBUG_DATA_LOW_INDEX_3_A,
+                SGE_DEBUG_DATA_HIGH_INDEX_10_A,
         };
         const char **sge_idma_decode;
         int sge_idma_decode_nstates;
@@ -2818,7 +3121,7 @@ retry:
         if (ret < 0) {
                 if ((ret == -EBUSY || ret == -ETIMEDOUT) && retries-- > 0)
                         goto retry;
-                if (t4_read_reg(adap, MA_PCIE_FW) & PCIE_FW_ERR)
+                if (t4_read_reg(adap, PCIE_FW_A) & PCIE_FW_ERR_F)
                         t4_report_fw_error(adap);
                 return ret;
         }
@@ -2868,8 +3171,8 @@ retry:
                          * timeout ... and then retry if we haven't exhausted
                          * our retries ...
                          */
-                        pcie_fw = t4_read_reg(adap, MA_PCIE_FW);
-                        if (!(pcie_fw & (PCIE_FW_ERR|PCIE_FW_INIT))) {
+                        pcie_fw = t4_read_reg(adap, PCIE_FW_A);
+                        if (!(pcie_fw & (PCIE_FW_ERR_F|PCIE_FW_INIT_F))) {
                                 if (waiting <= 0) {
                                         if (retries-- > 0)
                                                 goto retry;
@@ -2884,9 +3187,9 @@ retry:
                          * report errors preferentially.
                          */
                         if (state) {
-                                if (pcie_fw & PCIE_FW_ERR)
+                                if (pcie_fw & PCIE_FW_ERR_F)
                                         *state = DEV_STATE_ERR;
-                                else if (pcie_fw & PCIE_FW_INIT)
+                                else if (pcie_fw & PCIE_FW_INIT_F)
                                         *state = DEV_STATE_INIT;
                         }
 
@@ -2896,7 +3199,7 @@ retry:
                          * for our caller.
                          */
                         if (master_mbox == PCIE_FW_MASTER_M &&
-                            (pcie_fw & PCIE_FW_MASTER_VLD))
+                            (pcie_fw & PCIE_FW_MASTER_VLD_F))
                                 master_mbox = PCIE_FW_MASTER_G(pcie_fw);
                         break;
                 }
@@ -2985,7 +3288,7 @@ static int t4_fw_halt(struct adapter *adap, unsigned int mbox, int force)
 
                 memset(&c, 0, sizeof(c));
                 INIT_CMD(c, RESET, WRITE);
-                c.val = htonl(PIORST | PIORSTMODE);
+                c.val = htonl(PIORST_F | PIORSTMODE_F);
                 c.halt_pkd = htonl(FW_RESET_CMD_HALT_F);
                 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
         }
@@ -3004,8 +3307,8 @@ static int t4_fw_halt(struct adapter *adap, unsigned int mbox, int force)
          * rather than a RESET ... if it's new enough to understand that ...
          */
         if (ret == 0 || force) {
-                t4_set_reg_field(adap, CIM_BOOT_CFG, UPCRST, UPCRST);
-                t4_set_reg_field(adap, PCIE_FW, PCIE_FW_HALT_F,
+                t4_set_reg_field(adap, CIM_BOOT_CFG_A, UPCRST_F, UPCRST_F);
+                t4_set_reg_field(adap, PCIE_FW_A, PCIE_FW_HALT_F,
                                  PCIE_FW_HALT_F);
         }
 
@@ -3045,7 +3348,7 @@ static int t4_fw_restart(struct adapter *adap, unsigned int mbox, int reset)
                  * doing it automatically, we need to clear the PCIE_FW.HALT
                  * bit.
                  */
-                t4_set_reg_field(adap, PCIE_FW, PCIE_FW_HALT_F, 0);
+                t4_set_reg_field(adap, PCIE_FW_A, PCIE_FW_HALT_F, 0);
 
                 /*
                  * If we've been given a valid mailbox, first try to get the
@@ -3055,21 +3358,21 @@ static int t4_fw_restart(struct adapter *adap, unsigned int mbox, int reset)
                  * hitting the chip with a hammer.
                  */
                 if (mbox <= PCIE_FW_MASTER_M) {
-                        t4_set_reg_field(adap, CIM_BOOT_CFG, UPCRST, 0);
+                        t4_set_reg_field(adap, CIM_BOOT_CFG_A, UPCRST_F, 0);
                         msleep(100);
                         if (t4_fw_reset(adap, mbox,
-                                        PIORST | PIORSTMODE) == 0)
+                                        PIORST_F | PIORSTMODE_F) == 0)
                                 return 0;
                 }
 
-                t4_write_reg(adap, PL_RST, PIORST | PIORSTMODE);
+                t4_write_reg(adap, PL_RST_A, PIORST_F | PIORSTMODE_F);
                 msleep(2000);
         } else {
                 int ms;
 
-                t4_set_reg_field(adap, CIM_BOOT_CFG, UPCRST, 0);
+                t4_set_reg_field(adap, CIM_BOOT_CFG_A, UPCRST_F, 0);
                 for (ms = 0; ms < FW_CMD_MAX_TIMEOUT; ) {
-                        if (!(t4_read_reg(adap, PCIE_FW) & PCIE_FW_HALT_F))
+                        if (!(t4_read_reg(adap, PCIE_FW_A) & PCIE_FW_HALT_F))
                                 return 0;
                         msleep(100);
                         ms += 100;
@@ -3148,22 +3451,23 @@ int t4_fixup_host_params(struct adapter *adap, unsigned int page_size,
         unsigned int fl_align = cache_line_size < 32 ? 32 : cache_line_size;
         unsigned int fl_align_log = fls(fl_align) - 1;
 
-        t4_write_reg(adap, SGE_HOST_PAGE_SIZE,
-                     HOSTPAGESIZEPF0(sge_hps) |
-                     HOSTPAGESIZEPF1(sge_hps) |
-                     HOSTPAGESIZEPF2(sge_hps) |
-                     HOSTPAGESIZEPF3(sge_hps) |
-                     HOSTPAGESIZEPF4(sge_hps) |
-                     HOSTPAGESIZEPF5(sge_hps) |
-                     HOSTPAGESIZEPF6(sge_hps) |
-                     HOSTPAGESIZEPF7(sge_hps));
+        t4_write_reg(adap, SGE_HOST_PAGE_SIZE_A,
+                     HOSTPAGESIZEPF0_V(sge_hps) |
+                     HOSTPAGESIZEPF1_V(sge_hps) |
+                     HOSTPAGESIZEPF2_V(sge_hps) |
+                     HOSTPAGESIZEPF3_V(sge_hps) |
+                     HOSTPAGESIZEPF4_V(sge_hps) |
+                     HOSTPAGESIZEPF5_V(sge_hps) |
+                     HOSTPAGESIZEPF6_V(sge_hps) |
+                     HOSTPAGESIZEPF7_V(sge_hps));
 
         if (is_t4(adap->params.chip)) {
-                t4_set_reg_field(adap, SGE_CONTROL,
-                                 INGPADBOUNDARY_MASK |
-                                 EGRSTATUSPAGESIZE_MASK,
-                                 INGPADBOUNDARY(fl_align_log - 5) |
-                                 EGRSTATUSPAGESIZE(stat_len != 64));
+                t4_set_reg_field(adap, SGE_CONTROL_A,
+                                 INGPADBOUNDARY_V(INGPADBOUNDARY_M) |
+                                 EGRSTATUSPAGESIZE_F,
+                                 INGPADBOUNDARY_V(fl_align_log -
+                                                  INGPADBOUNDARY_SHIFT_X) |
+                                 EGRSTATUSPAGESIZE_V(stat_len != 64));
         } else {
                 /* T5 introduced the separation of the Free List Padding and
                  * Packing Boundaries.  Thus, we can select a smaller Padding
@@ -3193,15 +3497,15 @@ int t4_fixup_host_params(struct adapter *adap, unsigned int page_size,
                         fl_align = 64;
                         fl_align_log = 6;
                 }
-                t4_set_reg_field(adap, SGE_CONTROL,
-                                 INGPADBOUNDARY_MASK |
-                                 EGRSTATUSPAGESIZE_MASK,
-                                 INGPADBOUNDARY(INGPCIEBOUNDARY_32B_X) |
-                                 EGRSTATUSPAGESIZE(stat_len != 64));
+                t4_set_reg_field(adap, SGE_CONTROL_A,
+                                 INGPADBOUNDARY_V(INGPADBOUNDARY_M) |
+                                 EGRSTATUSPAGESIZE_F,
+                                 INGPADBOUNDARY_V(INGPCIEBOUNDARY_32B_X) |
+                                 EGRSTATUSPAGESIZE_V(stat_len != 64));
                 t4_set_reg_field(adap, SGE_CONTROL2_A,
                                  INGPACKBOUNDARY_V(INGPACKBOUNDARY_M),
                                  INGPACKBOUNDARY_V(fl_align_log -
-                                                 INGPACKBOUNDARY_SHIFT_X));
+                                                   INGPACKBOUNDARY_SHIFT_X));
         }
         /*
          * Adjust various SGE Free List Host Buffer Sizes.
@@ -3224,15 +3528,15 @@ int t4_fixup_host_params(struct adapter *adap, unsigned int page_size,
          * Default Firmware Configuration File but we need to adjust it for
          * this host's cache line size.
          */
-        t4_write_reg(adap, SGE_FL_BUFFER_SIZE0, page_size);
-        t4_write_reg(adap, SGE_FL_BUFFER_SIZE2,
-                     (t4_read_reg(adap, SGE_FL_BUFFER_SIZE2) + fl_align-1)
+        t4_write_reg(adap, SGE_FL_BUFFER_SIZE0_A, page_size);
+        t4_write_reg(adap, SGE_FL_BUFFER_SIZE2_A,
+                     (t4_read_reg(adap, SGE_FL_BUFFER_SIZE2_A) + fl_align-1)
                      & ~(fl_align-1));
-        t4_write_reg(adap, SGE_FL_BUFFER_SIZE3,
-                     (t4_read_reg(adap, SGE_FL_BUFFER_SIZE3) + fl_align-1)
+        t4_write_reg(adap, SGE_FL_BUFFER_SIZE3_A,
+                     (t4_read_reg(adap, SGE_FL_BUFFER_SIZE3_A) + fl_align-1)
                      & ~(fl_align-1));
 
-        t4_write_reg(adap, ULP_RX_TDDP_PSZ, HPZ0(page_shift - 12));
+        t4_write_reg(adap, ULP_RX_TDDP_PSZ_A, HPZ0_V(page_shift - 12));
 
         return 0;
 }
@@ -3917,12 +4221,12 @@ int t4_wait_dev_ready(void __iomem *regs)
 {
         u32 whoami;
 
-        whoami = readl(regs + PL_WHOAMI);
+        whoami = readl(regs + PL_WHOAMI_A);
         if (whoami != 0xffffffff && whoami != CIM_PF_NOACCESS)
                 return 0;
 
         msleep(500);
-        whoami = readl(regs + PL_WHOAMI);
+        whoami = readl(regs + PL_WHOAMI_A);
         return (whoami != 0xffffffff && whoami != CIM_PF_NOACCESS ? 0 : -EIO);
 }
 
@@ -3946,7 +4250,7 @@ static int get_flash_params(struct adapter *adap)
         ret = sf1_write(adap, 1, 1, 0, SF_RD_ID);
         if (!ret)
                 ret = sf1_read(adap, 3, 0, 1, &info);
-        t4_write_reg(adap, SF_OP, 0);                    /* unlock SF */
+        t4_write_reg(adap, SF_OP_A, 0);                    /* unlock SF */
         if (ret)
                 return ret;
 
@@ -3969,7 +4273,7 @@ static int get_flash_params(struct adapter *adap)
                 return -EINVAL;
         adap->params.sf_size = 1 << info;
         adap->params.sf_fw_start =
-                t4_read_reg(adap, CIM_BOOT_CFG) & BOOTADDR_MASK;
+                t4_read_reg(adap, CIM_BOOT_CFG_A) & BOOTADDR_M;
 
         if (adap->params.sf_size < FLASH_MIN_SIZE)
                 dev_warn(adap->pdev_dev, "WARNING!!! FLASH size %#x < %#x!!!\n",
@@ -3993,7 +4297,7 @@ int t4_prep_adapter(struct adapter *adapter)
         u32 pl_rev;
 
         get_pci_mode(adapter, &adapter->params.pci);
-        pl_rev = G_REV(t4_read_reg(adapter, PL_REV));
+        pl_rev = REV_G(t4_read_reg(adapter, PL_REV_A));
 
         ret = get_flash_params(adapter);
         if (ret < 0) {
@@ -4019,6 +4323,7 @@ int t4_prep_adapter(struct adapter *adapter)
                 return -EINVAL;
         }
 
+        adapter->params.cim_la_size = CIMLA_SIZE;
         init_cong_ctrl(adapter->params.a_wnd, adapter->params.b_wnd);
 
         /*
@@ -4133,7 +4438,7 @@ int t4_init_sge_params(struct adapter *adapter)
 
         /* Extract the SGE Page Size for our PF.
          */
-        hps = t4_read_reg(adapter, SGE_HOST_PAGE_SIZE);
+        hps = t4_read_reg(adapter, SGE_HOST_PAGE_SIZE_A);
         s_hps = (HOSTPAGESIZEPF0_S +
                  (HOSTPAGESIZEPF1_S - HOSTPAGESIZEPF0_S) * adapter->fn);
         sge_params->hps = ((hps >> s_hps) & HOSTPAGESIZEPF0_M);
@@ -4142,10 +4447,10 @@ int t4_init_sge_params(struct adapter *adapter)
          */
         s_qpp = (QUEUESPERPAGEPF0_S +
                 (QUEUESPERPAGEPF1_S - QUEUESPERPAGEPF0_S) * adapter->fn);
-        qpp = t4_read_reg(adapter, SGE_EGRESS_QUEUES_PER_PAGE_PF);
-        sge_params->eq_qpp = ((qpp >> s_qpp) & QUEUESPERPAGEPF0_MASK);
-        qpp = t4_read_reg(adapter, SGE_INGRESS_QUEUES_PER_PAGE_PF);
-        sge_params->iq_qpp = ((qpp >> s_qpp) & QUEUESPERPAGEPF0_MASK);
+        qpp = t4_read_reg(adapter, SGE_EGRESS_QUEUES_PER_PAGE_PF_A);
+        sge_params->eq_qpp = ((qpp >> s_qpp) & QUEUESPERPAGEPF0_M);
+        qpp = t4_read_reg(adapter, SGE_INGRESS_QUEUES_PER_PAGE_PF_A);
+        sge_params->iq_qpp = ((qpp >> s_qpp) & QUEUESPERPAGEPF0_M);
 
         return 0;
 }
@@ -4161,9 +4466,9 @@ int t4_init_tp_params(struct adapter *adap)
         int chan;
         u32 v;
 
-        v = t4_read_reg(adap, TP_TIMER_RESOLUTION);
-        adap->params.tp.tre = TIMERRESOLUTION_GET(v);
-        adap->params.tp.dack_re = DELAYEDACKRESOLUTION_GET(v);
+        v = t4_read_reg(adap, TP_TIMER_RESOLUTION_A);
+        adap->params.tp.tre = TIMERRESOLUTION_G(v);
+        adap->params.tp.dack_re = DELAYEDACKRESOLUTION_G(v);
 
         /* MODQ_REQ_MAP defaults to setting queues 0-3 to chan 0-3 */
         for (chan = 0; chan < NCHAN; chan++)
@@ -4172,27 +4477,27 @@ int t4_init_tp_params(struct adapter *adap)
         /* Cache the adapter's Compressed Filter Mode and global Incress
          * Configuration.
          */
-        t4_read_indirect(adap, TP_PIO_ADDR, TP_PIO_DATA,
+        t4_read_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A,
                          &adap->params.tp.vlan_pri_map, 1,
-                         TP_VLAN_PRI_MAP);
-        t4_read_indirect(adap, TP_PIO_ADDR, TP_PIO_DATA,
+                         TP_VLAN_PRI_MAP_A);
+        t4_read_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A,
                          &adap->params.tp.ingress_config, 1,
-                         TP_INGRESS_CONFIG);
+                         TP_INGRESS_CONFIG_A);
 
         /* Now that we have TP_VLAN_PRI_MAP cached, we can calculate the field
          * shift positions of several elements of the Compressed Filter Tuple
          * for this adapter which we need frequently ...
          */
-        adap->params.tp.vlan_shift = t4_filter_field_shift(adap, F_VLAN);
-        adap->params.tp.vnic_shift = t4_filter_field_shift(adap, F_VNIC_ID);
-        adap->params.tp.port_shift = t4_filter_field_shift(adap, F_PORT);
+        adap->params.tp.vlan_shift = t4_filter_field_shift(adap, VLAN_F);
+        adap->params.tp.vnic_shift = t4_filter_field_shift(adap, VNIC_ID_F);
+        adap->params.tp.port_shift = t4_filter_field_shift(adap, PORT_F);
         adap->params.tp.protocol_shift = t4_filter_field_shift(adap,
-                                                               F_PROTOCOL);
+                                                               PROTOCOL_F);
 
         /* If TP_INGRESS_CONFIG.VNID == 0, then TP_VLAN_PRI_MAP.VNIC_ID
          * represents the presense of an Outer VLAN instead of a VNIC ID.
          */
-        if ((adap->params.tp.ingress_config & F_VNIC) == 0)
+        if ((adap->params.tp.ingress_config & VNIC_F) == 0)
                 adap->params.tp.vnic_shift = -1;
 
         return 0;
@@ -4218,35 +4523,35 @@ int t4_filter_field_shift(const struct adapter *adap, int filter_sel)
 
         for (sel = 1, field_shift = 0; sel < filter_sel; sel <<= 1) {
                 switch (filter_mode & sel) {
-                case F_FCOE:
-                        field_shift += W_FT_FCOE;
+                case FCOE_F:
+                        field_shift += FT_FCOE_W;
                         break;
-                case F_PORT:
-                        field_shift += W_FT_PORT;
+                case PORT_F:
+                        field_shift += FT_PORT_W;
                         break;
-                case F_VNIC_ID:
-                        field_shift += W_FT_VNIC_ID;
+                case VNIC_ID_F:
+                        field_shift += FT_VNIC_ID_W;
                         break;
-                case F_VLAN:
-                        field_shift += W_FT_VLAN;
+                case VLAN_F:
+                        field_shift += FT_VLAN_W;
                         break;
-                case F_TOS:
-                        field_shift += W_FT_TOS;
+                case TOS_F:
+                        field_shift += FT_TOS_W;
                         break;
-                case F_PROTOCOL:
-                        field_shift += W_FT_PROTOCOL;
+                case PROTOCOL_F:
+                        field_shift += FT_PROTOCOL_W;
                         break;
-                case F_ETHERTYPE:
-                        field_shift += W_FT_ETHERTYPE;
+                case ETHERTYPE_F:
+                        field_shift += FT_ETHERTYPE_W;
                         break;
-                case F_MACMATCH:
-                        field_shift += W_FT_MACMATCH;
+                case MACMATCH_F:
+                        field_shift += FT_MACMATCH_W;
                         break;
-                case F_MPSHITTYPE:
-                        field_shift += W_FT_MPSHITTYPE;
+                case MPSHITTYPE_F:
+                        field_shift += FT_MPSHITTYPE_W;
                         break;
-                case F_FRAGMENTATION:
-                        field_shift += W_FT_FRAGMENTATION;
+                case FRAGMENTATION_F:
+                        field_shift += FT_FRAGMENTATION_W;
                         break;
                 }
         }
@@ -4311,3 +4616,289 @@ int t4_port_init(struct adapter *adap, int mbox, int pf, int vf)
         }
         return 0;
 }
+
+/**
+ *      t4_read_cimq_cfg - read CIM queue configuration
+ *      @adap: the adapter
+ *      @base: holds the queue base addresses in bytes
+ *      @size: holds the queue sizes in bytes
+ *      @thres: holds the queue full thresholds in bytes
+ *
+ *      Returns the current configuration of the CIM queues, starting with
+ *      the IBQs, then the OBQs.
+ */
+void t4_read_cimq_cfg(struct adapter *adap, u16 *base, u16 *size, u16 *thres)
+{
+        unsigned int i, v;
+        int cim_num_obq = is_t4(adap->params.chip) ?
+                                CIM_NUM_OBQ : CIM_NUM_OBQ_T5;
+
+        for (i = 0; i < CIM_NUM_IBQ; i++) {
+                t4_write_reg(adap, CIM_QUEUE_CONFIG_REF_A, IBQSELECT_F |
+                             QUENUMSELECT_V(i));
+                v = t4_read_reg(adap, CIM_QUEUE_CONFIG_CTRL_A);
+                /* value is in 256-byte units */
+                *base++ = CIMQBASE_G(v) * 256;
+                *size++ = CIMQSIZE_G(v) * 256;
+                *thres++ = QUEFULLTHRSH_G(v) * 8; /* 8-byte unit */
+        }
+        for (i = 0; i < cim_num_obq; i++) {
+                t4_write_reg(adap, CIM_QUEUE_CONFIG_REF_A, OBQSELECT_F |
+                             QUENUMSELECT_V(i));
+                v = t4_read_reg(adap, CIM_QUEUE_CONFIG_CTRL_A);
+                /* value is in 256-byte units */
+                *base++ = CIMQBASE_G(v) * 256;
+                *size++ = CIMQSIZE_G(v) * 256;
+        }
+}
+
+/**
+ *      t4_read_cim_ibq - read the contents of a CIM inbound queue
+ *      @adap: the adapter
+ *      @qid: the queue index
+ *      @data: where to store the queue contents
+ *      @n: capacity of @data in 32-bit words
+ *
+ *      Reads the contents of the selected CIM queue starting at address 0 up
+ *      to the capacity of @data.  @n must be a multiple of 4.  Returns < 0 on
+ *      error and the number of 32-bit words actually read on success.
+ */
+int t4_read_cim_ibq(struct adapter *adap, unsigned int qid, u32 *data, size_t n)
+{
+        int i, err, attempts;
+        unsigned int addr;
+        const unsigned int nwords = CIM_IBQ_SIZE * 4;
+
+        if (qid > 5 || (n & 3))
+                return -EINVAL;
+
+        addr = qid * nwords;
+        if (n > nwords)
+                n = nwords;
+
+        /* It might take 3-10ms before the IBQ debug read access is allowed.
+         * Wait for 1 Sec with a delay of 1 usec.
+         */
+        attempts = 1000000;
+
+        for (i = 0; i < n; i++, addr++) {
+                t4_write_reg(adap, CIM_IBQ_DBG_CFG_A, IBQDBGADDR_V(addr) |
+                             IBQDBGEN_F);
+                err = t4_wait_op_done(adap, CIM_IBQ_DBG_CFG_A, IBQDBGBUSY_F, 0,
+                                      attempts, 1);
+                if (err)
+                        return err;
+                *data++ = t4_read_reg(adap, CIM_IBQ_DBG_DATA_A);
+        }
+        t4_write_reg(adap, CIM_IBQ_DBG_CFG_A, 0);
+        return i;
+}
+
+/**
+ *      t4_read_cim_obq - read the contents of a CIM outbound queue
+ *      @adap: the adapter
+ *      @qid: the queue index
+ *      @data: where to store the queue contents
+ *      @n: capacity of @data in 32-bit words
+ *
+ *      Reads the contents of the selected CIM queue starting at address 0 up
+ *      to the capacity of @data.  @n must be a multiple of 4.  Returns < 0 on
+ *      error and the number of 32-bit words actually read on success.
+ */
+int t4_read_cim_obq(struct adapter *adap, unsigned int qid, u32 *data, size_t n)
+{
+        int i, err;
+        unsigned int addr, v, nwords;
+        int cim_num_obq = is_t4(adap->params.chip) ?
+                                CIM_NUM_OBQ : CIM_NUM_OBQ_T5;
+
+        if ((qid > (cim_num_obq - 1)) || (n & 3))
+                return -EINVAL;
+
+        t4_write_reg(adap, CIM_QUEUE_CONFIG_REF_A, OBQSELECT_F |
+                     QUENUMSELECT_V(qid));
+        v = t4_read_reg(adap, CIM_QUEUE_CONFIG_CTRL_A);
+
+        addr = CIMQBASE_G(v) * 64;    /* muliple of 256 -> muliple of 4 */
+        nwords = CIMQSIZE_G(v) * 64;  /* same */
+        if (n > nwords)
+                n = nwords;
+
+        for (i = 0; i < n; i++, addr++) {
+                t4_write_reg(adap, CIM_OBQ_DBG_CFG_A, OBQDBGADDR_V(addr) |
+                             OBQDBGEN_F);
+                err = t4_wait_op_done(adap, CIM_OBQ_DBG_CFG_A, OBQDBGBUSY_F, 0,
+                                      2, 1);
+                if (err)
+                        return err;
+                *data++ = t4_read_reg(adap, CIM_OBQ_DBG_DATA_A);
+        }
+        t4_write_reg(adap, CIM_OBQ_DBG_CFG_A, 0);
+        return i;
+}
+
+/**
+ *      t4_cim_read - read a block from CIM internal address space
+ *      @adap: the adapter
+ *      @addr: the start address within the CIM address space
+ *      @n: number of words to read
+ *      @valp: where to store the result
+ *
+ *      Reads a block of 4-byte words from the CIM intenal address space.
+ */
+int t4_cim_read(struct adapter *adap, unsigned int addr, unsigned int n,
+                unsigned int *valp)
+{
+        int ret = 0;
+
+        if (t4_read_reg(adap, CIM_HOST_ACC_CTRL_A) & HOSTBUSY_F)
+                return -EBUSY;
+
+        for ( ; !ret && n--; addr += 4) {
+                t4_write_reg(adap, CIM_HOST_ACC_CTRL_A, addr);
+                ret = t4_wait_op_done(adap, CIM_HOST_ACC_CTRL_A, HOSTBUSY_F,
+                                      0, 5, 2);
+                if (!ret)
+                        *valp++ = t4_read_reg(adap, CIM_HOST_ACC_DATA_A);
+        }
+        return ret;
+}
+
+/**
+ *      t4_cim_write - write a block into CIM internal address space
+ *      @adap: the adapter
+ *      @addr: the start address within the CIM address space
+ *      @n: number of words to write
+ *      @valp: set of values to write
+ *
+ *      Writes a block of 4-byte words into the CIM intenal address space.
+ */
+int t4_cim_write(struct adapter *adap, unsigned int addr, unsigned int n,
+                 const unsigned int *valp)
+{
+        int ret = 0;
+
+        if (t4_read_reg(adap, CIM_HOST_ACC_CTRL_A) & HOSTBUSY_F)
+                return -EBUSY;
+
+        for ( ; !ret && n--; addr += 4) {
+                t4_write_reg(adap, CIM_HOST_ACC_DATA_A, *valp++);
+                t4_write_reg(adap, CIM_HOST_ACC_CTRL_A, addr | HOSTWRITE_F);
+                ret = t4_wait_op_done(adap, CIM_HOST_ACC_CTRL_A, HOSTBUSY_F,
+                                      0, 5, 2);
+        }
+        return ret;
+}
+
+static int t4_cim_write1(struct adapter *adap, unsigned int addr,
+                         unsigned int val)
+{
+        return t4_cim_write(adap, addr, 1, &val);
+}
+
+/**
+ *      t4_cim_read_la - read CIM LA capture buffer
+ *      @adap: the adapter
+ *      @la_buf: where to store the LA data
+ *      @wrptr: the HW write pointer within the capture buffer
+ *
+ *      Reads the contents of the CIM LA buffer with the most recent entry at
+ *      the end of the returned data and with the entry at @wrptr first.
+ *      We try to leave the LA in the running state we find it in.
+ */
+int t4_cim_read_la(struct adapter *adap, u32 *la_buf, unsigned int *wrptr)
+{
+        int i, ret;
+        unsigned int cfg, val, idx;
+
+        ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg);
+        if (ret)
+                return ret;
+
+        if (cfg & UPDBGLAEN_F) {        /* LA is running, freeze it */
+                ret = t4_cim_write1(adap, UP_UP_DBG_LA_CFG_A, 0);
+                if (ret)
+                        return ret;
+        }
+
+        ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &val);
+        if (ret)
+                goto restart;
+
+        idx = UPDBGLAWRPTR_G(val);
+        if (wrptr)
+                *wrptr = idx;
+
+        for (i = 0; i < adap->params.cim_la_size; i++) {
+                ret = t4_cim_write1(adap, UP_UP_DBG_LA_CFG_A,
+                                    UPDBGLARDPTR_V(idx) | UPDBGLARDEN_F);
+                if (ret)
+                        break;
+                ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &val);
+                if (ret)
+                        break;
+                if (val & UPDBGLARDEN_F) {
+                        ret = -ETIMEDOUT;
+                        break;
+                }
+                ret = t4_cim_read(adap, UP_UP_DBG_LA_DATA_A, 1, &la_buf[i]);
+                if (ret)
+                        break;
+                idx = (idx + 1) & UPDBGLARDPTR_M;
+        }
+restart:
+        if (cfg & UPDBGLAEN_F) {
+                int r = t4_cim_write1(adap, UP_UP_DBG_LA_CFG_A,
+                                      cfg & ~UPDBGLARDEN_F);
+                if (!ret)
+                        ret = r;
+        }
+        return ret;
+}
+
+/**
+ *      t4_tp_read_la - read TP LA capture buffer
+ *      @adap: the adapter
+ *      @la_buf: where to store the LA data
+ *      @wrptr: the HW write pointer within the capture buffer
+ *
+ *      Reads the contents of the TP LA buffer with the most recent entry at
+ *      the end of the returned data and with the entry at @wrptr first.
+ *      We leave the LA in the running state we find it in.
+ */
+void t4_tp_read_la(struct adapter *adap, u64 *la_buf, unsigned int *wrptr)
+{
+        bool last_incomplete;
+        unsigned int i, cfg, val, idx;
+
+        cfg = t4_read_reg(adap, TP_DBG_LA_CONFIG_A) & 0xffff;
+        if (cfg & DBGLAENABLE_F)                        /* freeze LA */
+                t4_write_reg(adap, TP_DBG_LA_CONFIG_A,
+                             adap->params.tp.la_mask | (cfg ^ DBGLAENABLE_F));
+
+        val = t4_read_reg(adap, TP_DBG_LA_CONFIG_A);
+        idx = DBGLAWPTR_G(val);
+        last_incomplete = DBGLAMODE_G(val) >= 2 && (val & DBGLAWHLF_F) == 0;
+        if (last_incomplete)
+                idx = (idx + 1) & DBGLARPTR_M;
+        if (wrptr)
+                *wrptr = idx;
+
+        val &= 0xffff;
+        val &= ~DBGLARPTR_V(DBGLARPTR_M);
+        val |= adap->params.tp.la_mask;
+
+        for (i = 0; i < TPLA_SIZE; i++) {
+                t4_write_reg(adap, TP_DBG_LA_CONFIG_A, DBGLARPTR_V(idx) | val);
+                la_buf[i] = t4_read_reg64(adap, TP_DBG_LA_DATAL_A);
+                idx = (idx + 1) & DBGLARPTR_M;
+        }
+
+        /* Wipe out last entry if it isn't valid */
+        if (last_incomplete)
+                la_buf[TPLA_SIZE - 1] = ~0ULL;
+
+        if (cfg & DBGLAENABLE_F)                    /* restore running state */
+                t4_write_reg(adap, TP_DBG_LA_CONFIG_A,
+                             cfg | adap->params.tp.la_mask);
+}
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.h b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.h
index c19a90e7f7d1..380b15c0417a 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.h
@@ -48,6 +48,7 @@ enum {
         NMTUS          = 16,    /* size of MTU table */
         NCCTRL_WIN     = 32,    /* # of congestion control windows */
         L2T_SIZE       = 4096,  /* # of L2T entries */
+        PM_NSTATS      = 5,     /* # of PM stats */
         MBOX_LEN       = 64,    /* mailbox size in bytes */
         TRACE_LEN      = 112,   /* length of trace data and mask */
         FILTER_OPT_LEN = 36,    /* filter tuple width for optional components */
@@ -56,6 +57,17 @@ enum {
 };
 
 enum {
+        CIM_NUM_IBQ    = 6,     /* # of CIM IBQs */
+        CIM_NUM_OBQ    = 6,     /* # of CIM OBQs */
+        CIM_NUM_OBQ_T5 = 8,     /* # of CIM OBQs for T5 adapter */
+        CIMLA_SIZE     = 2048,  /* # of 32-bit words in CIM LA */
+        CIM_IBQ_SIZE   = 128,   /* # of 128-bit words in a CIM IBQ */
+        CIM_OBQ_SIZE   = 128,   /* # of 128-bit words in a CIM OBQ */
+        TPLA_SIZE      = 128,   /* # of 64-bit words in TP LA */
+        ULPRX_LA_SIZE  = 512,   /* # of 256-bit words in ULP_RX LA */
+};
+
+enum {
         SF_PAGE_SIZE = 256,           /* serial flash page size */
         SF_SEC_SIZE = 64 * 1024,      /* serial flash sector size */
 };
@@ -110,6 +122,18 @@ enum {
         SGE_INGPADBOUNDARY_SHIFT = 5,/* ingress queue pad boundary */
 };
 
+/* PCI-e memory window access */
+enum pcie_memwin {
+        MEMWIN_NIC      = 0,
+        MEMWIN_RSVD1    = 1,
+        MEMWIN_RSVD2    = 2,
+        MEMWIN_RDMA     = 3,
+        MEMWIN_RSVD4    = 4,
+        MEMWIN_FOISCSI  = 5,
+        MEMWIN_CSIOSTOR = 6,
+        MEMWIN_RSVD7    = 7,
+};
+
 struct sge_qstat {                /* data written to SGE queue status entries */
         __be32 qid;
         __be16 cidx;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h b/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
index 0f89f68948ab..0fb975e258b3 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
@@ -124,6 +124,13 @@ enum CPL_error {
 };
 
 enum {
+        CPL_CONN_POLICY_AUTO = 0,
+        CPL_CONN_POLICY_ASK  = 1,
+        CPL_CONN_POLICY_FILTER = 2,
+        CPL_CONN_POLICY_DENY = 3
+};
+
+enum {
         ULP_MODE_NONE          = 0,
         ULP_MODE_ISCSI         = 2,
         ULP_MODE_RDMA          = 4,
@@ -160,16 +167,28 @@ union opcode_tid {
         u8 opcode;
 };
 
-#define CPL_OPCODE(x) ((x) << 24)
-#define G_CPL_OPCODE(x) (((x) >> 24) & 0xFF)
-#define MK_OPCODE_TID(opcode, tid) (CPL_OPCODE(opcode) | (tid))
+#define CPL_OPCODE_S    24
+#define CPL_OPCODE_V(x) ((x) << CPL_OPCODE_S)
+#define CPL_OPCODE_G(x) (((x) >> CPL_OPCODE_S) & 0xFF)
+#define TID_G(x)    ((x) & 0xFFFFFF)
+
+/* tid is assumed to be 24-bits */
+#define MK_OPCODE_TID(opcode, tid) (CPL_OPCODE_V(opcode) | (tid))
+
 #define OPCODE_TID(cmd) ((cmd)->ot.opcode_tid)
-#define GET_TID(cmd) (ntohl(OPCODE_TID(cmd)) & 0xFFFFFF)
+
+/* extract the TID from a CPL command */
+#define GET_TID(cmd) (TID_G(be32_to_cpu(OPCODE_TID(cmd))))
 
 /* partitioning of TID fields that also carry a queue id */
-#define GET_TID_TID(x) ((x) & 0x3fff)
-#define GET_TID_QID(x) (((x) >> 14) & 0x3ff)
-#define TID_QID(x)     ((x) << 14)
+#define TID_TID_S    0
+#define TID_TID_M    0x3fff
+#define TID_TID_G(x) (((x) >> TID_TID_S) & TID_TID_M)
+
+#define TID_QID_S    14
+#define TID_QID_M    0x3ff
+#define TID_QID_V(x) ((x) << TID_QID_S)
+#define TID_QID_G(x) (((x) >> TID_QID_S) & TID_QID_M)
 
 struct rss_header {
         u8 opcode;
@@ -199,8 +218,8 @@ struct work_request_hdr {
 };
 
 /* wr_hi fields */
-#define S_WR_OP    24
-#define V_WR_OP(x) ((__u64)(x) << S_WR_OP)
+#define WR_OP_S    24
+#define WR_OP_V(x) ((__u64)(x) << WR_OP_S)
 
 #define WR_HDR struct work_request_hdr wr
 
@@ -270,17 +289,42 @@ struct cpl_pass_open_req {
         __be32 local_ip;
         __be32 peer_ip;
         __be64 opt0;
-#define NO_CONG(x)    ((x) << 4)
-#define DELACK(x)     ((x) << 5)
-#define DSCP(x)       ((x) << 22)
-#define TCAM_BYPASS(x) ((u64)(x) << 48)
-#define NAGLE(x)      ((u64)(x) << 49)
         __be64 opt1;
-#define SYN_RSS_ENABLE   (1 << 0)
-#define SYN_RSS_QUEUE(x) ((x) << 2)
-#define CONN_POLICY_ASK  (1 << 22)
 };
 
+/* option 0 fields */
+#define NO_CONG_S    4
+#define NO_CONG_V(x) ((x) << NO_CONG_S)
+#define NO_CONG_F    NO_CONG_V(1U)
+
+#define DELACK_S    5
+#define DELACK_V(x) ((x) << DELACK_S)
+#define DELACK_F    DELACK_V(1U)
+
+#define DSCP_S    22
+#define DSCP_M    0x3F
+#define DSCP_V(x) ((x) << DSCP_S)
+#define DSCP_G(x) (((x) >> DSCP_S) & DSCP_M)
+
+#define TCAM_BYPASS_S    48
+#define TCAM_BYPASS_V(x) ((__u64)(x) << TCAM_BYPASS_S)
+#define TCAM_BYPASS_F    TCAM_BYPASS_V(1ULL)
+
+#define NAGLE_S    49
+#define NAGLE_V(x) ((__u64)(x) << NAGLE_S)
+#define NAGLE_F    NAGLE_V(1ULL)
+
+/* option 1 fields */
+#define SYN_RSS_ENABLE_S    0
+#define SYN_RSS_ENABLE_V(x) ((x) << SYN_RSS_ENABLE_S)
+#define SYN_RSS_ENABLE_F    SYN_RSS_ENABLE_V(1U)
+
+#define SYN_RSS_QUEUE_S    2
+#define SYN_RSS_QUEUE_V(x) ((x) << SYN_RSS_QUEUE_S)
+
+#define CONN_POLICY_S    22
+#define CONN_POLICY_V(x) ((x) << CONN_POLICY_S)
+
 struct cpl_pass_open_req6 {
         WR_HDR;
         union opcode_tid ot;
@@ -304,16 +348,37 @@ struct cpl_pass_accept_rpl {
         WR_HDR;
         union opcode_tid ot;
         __be32 opt2;
-#define RX_COALESCE_VALID(x) ((x) << 11)
-#define RX_COALESCE(x)       ((x) << 12)
-#define PACE(x)       ((x) << 16)
-#define TX_QUEUE(x)          ((x) << 23)
-#define CCTRL_ECN(x)         ((x) << 27)
-#define TSTAMPS_EN(x)        ((x) << 29)
-#define SACK_EN(x)           ((x) << 30)
         __be64 opt0;
 };
 
+/* option 2 fields */
+#define RX_COALESCE_VALID_S    11
+#define RX_COALESCE_VALID_V(x) ((x) << RX_COALESCE_VALID_S)
+#define RX_COALESCE_VALID_F    RX_COALESCE_VALID_V(1U)
+
+#define RX_COALESCE_S    12
+#define RX_COALESCE_V(x) ((x) << RX_COALESCE_S)
+
+#define PACE_S    16
+#define PACE_V(x) ((x) << PACE_S)
+
+#define TX_QUEUE_S    23
+#define TX_QUEUE_M    0x7
+#define TX_QUEUE_V(x) ((x) << TX_QUEUE_S)
+#define TX_QUEUE_G(x) (((x) >> TX_QUEUE_S) & TX_QUEUE_M)
+
+#define CCTRL_ECN_S    27
+#define CCTRL_ECN_V(x) ((x) << CCTRL_ECN_S)
+#define CCTRL_ECN_F    CCTRL_ECN_V(1U)
+
+#define TSTAMPS_EN_S    29
+#define TSTAMPS_EN_V(x) ((x) << TSTAMPS_EN_S)
+#define TSTAMPS_EN_F    TSTAMPS_EN_V(1U)
+
+#define SACK_EN_S    30
+#define SACK_EN_V(x) ((x) << SACK_EN_S)
+#define SACK_EN_F    SACK_EN_V(1U)
+
 struct cpl_t5_pass_accept_rpl {
         WR_HDR;
         union opcode_tid ot;
@@ -384,30 +449,61 @@ struct cpl_t5_act_open_req6 {
 struct cpl_act_open_rpl {
         union opcode_tid ot;
         __be32 atid_status;
-#define GET_AOPEN_STATUS(x) ((x) & 0xff)
-#define GET_AOPEN_ATID(x)   (((x) >> 8) & 0xffffff)
 };
 
+/* cpl_act_open_rpl.atid_status fields */
+#define AOPEN_STATUS_S    0
+#define AOPEN_STATUS_M    0xFF
+#define AOPEN_STATUS_G(x) (((x) >> AOPEN_STATUS_S) & AOPEN_STATUS_M)
+
+#define AOPEN_ATID_S    8
+#define AOPEN_ATID_M    0xFFFFFF
+#define AOPEN_ATID_G(x) (((x) >> AOPEN_ATID_S) & AOPEN_ATID_M)
+
 struct cpl_pass_establish {
         union opcode_tid ot;
         __be32 rsvd;
         __be32 tos_stid;
-#define PASS_OPEN_TID(x) ((x) << 0)
-#define PASS_OPEN_TOS(x) ((x) << 24)
-#define GET_PASS_OPEN_TID(x)    (((x) >> 0) & 0xFFFFFF)
-#define GET_POPEN_TID(x) ((x) & 0xffffff)
-#define GET_POPEN_TOS(x) (((x) >> 24) & 0xff)
         __be16 mac_idx;
         __be16 tcp_opt;
-#define GET_TCPOPT_WSCALE_OK(x)  (((x) >> 5) & 1)
-#define GET_TCPOPT_SACK(x)       (((x) >> 6) & 1)
-#define GET_TCPOPT_TSTAMP(x)     (((x) >> 7) & 1)
-#define GET_TCPOPT_SND_WSCALE(x) (((x) >> 8) & 0xf)
-#define GET_TCPOPT_MSS(x)        (((x) >> 12) & 0xf)
         __be32 snd_isn;
         __be32 rcv_isn;
 };
 
+/* cpl_pass_establish.tos_stid fields */
+#define PASS_OPEN_TID_S    0
+#define PASS_OPEN_TID_M    0xFFFFFF
+#define PASS_OPEN_TID_V(x) ((x) << PASS_OPEN_TID_S)
+#define PASS_OPEN_TID_G(x) (((x) >> PASS_OPEN_TID_S) & PASS_OPEN_TID_M)
+
+#define PASS_OPEN_TOS_S    24
+#define PASS_OPEN_TOS_M    0xFF
+#define PASS_OPEN_TOS_V(x) ((x) << PASS_OPEN_TOS_S)
+#define PASS_OPEN_TOS_G(x) (((x) >> PASS_OPEN_TOS_S) & PASS_OPEN_TOS_M)
+
+/* cpl_pass_establish.tcp_opt fields (also applies to act_open_establish) */
+#define TCPOPT_WSCALE_OK_S      5
+#define TCPOPT_WSCALE_OK_M      0x1
+#define TCPOPT_WSCALE_OK_G(x)   \
+        (((x) >> TCPOPT_WSCALE_OK_S) & TCPOPT_WSCALE_OK_M)
+
+#define TCPOPT_SACK_S           6
+#define TCPOPT_SACK_M           0x1
+#define TCPOPT_SACK_G(x)        (((x) >> TCPOPT_SACK_S) & TCPOPT_SACK_M)
+
+#define TCPOPT_TSTAMP_S         7
+#define TCPOPT_TSTAMP_M         0x1
+#define TCPOPT_TSTAMP_G(x)      (((x) >> TCPOPT_TSTAMP_S) & TCPOPT_TSTAMP_M)
+
+#define TCPOPT_SND_WSCALE_S     8
+#define TCPOPT_SND_WSCALE_M     0xF
+#define TCPOPT_SND_WSCALE_G(x)  \
+        (((x) >> TCPOPT_SND_WSCALE_S) & TCPOPT_SND_WSCALE_M)
+
+#define TCPOPT_MSS_S    12
+#define TCPOPT_MSS_M    0xF
+#define TCPOPT_MSS_G(x) (((x) >> TCPOPT_MSS_S) & TCPOPT_MSS_M)
+
 struct cpl_act_establish {
         union opcode_tid ot;
         __be32 rsvd;
@@ -422,24 +518,39 @@ struct cpl_get_tcb {
         WR_HDR;
         union opcode_tid ot;
         __be16 reply_ctrl;
-#define QUEUENO(x)    ((x) << 0)
-#define REPLY_CHAN(x) ((x) << 14)
-#define NO_REPLY(x)   ((x) << 15)
         __be16 cookie;
 };
 
+/* cpl_get_tcb.reply_ctrl fields */
+#define QUEUENO_S    0
+#define QUEUENO_V(x) ((x) << QUEUENO_S)
+
+#define REPLY_CHAN_S    14
+#define REPLY_CHAN_V(x) ((x) << REPLY_CHAN_S)
+#define REPLY_CHAN_F    REPLY_CHAN_V(1U)
+
+#define NO_REPLY_S    15
+#define NO_REPLY_V(x) ((x) << NO_REPLY_S)
+#define NO_REPLY_F    NO_REPLY_V(1U)
+
 struct cpl_set_tcb_field {
         WR_HDR;
         union opcode_tid ot;
         __be16 reply_ctrl;
         __be16 word_cookie;
-#define TCB_WORD(x)   ((x) << 0)
-#define TCB_COOKIE(x) ((x) << 5)
-#define GET_TCB_COOKIE(x) (((x) >> 5) & 7)
         __be64 mask;
         __be64 val;
 };
 
+/* cpl_set_tcb_field.word_cookie fields */
+#define TCB_WORD_S    0
+#define TCB_WORD(x)   ((x) << TCB_WORD_S)
+
+#define TCB_COOKIE_S    5
+#define TCB_COOKIE_M    0x7
+#define TCB_COOKIE_V(x) ((x) << TCB_COOKIE_S)
+#define TCB_COOKIE_G(x) (((x) >> TCB_COOKIE_S) & TCB_COOKIE_M)
+
 struct cpl_set_tcb_rpl {
         union opcode_tid ot;
         __be16 rsvd;
@@ -466,10 +577,14 @@ struct cpl_close_listsvr_req {
         WR_HDR;
         union opcode_tid ot;
         __be16 reply_ctrl;
-#define LISTSVR_IPV6(x) ((x) << 14)
         __be16 rsvd;
 };
 
+/* additional cpl_close_listsvr_req.reply_ctrl field */
+#define LISTSVR_IPV6_S    14
+#define LISTSVR_IPV6_V(x) ((x) << LISTSVR_IPV6_S)
+#define LISTSVR_IPV6_F    LISTSVR_IPV6_V(1U)
+
 struct cpl_close_listsvr_rpl {
         union opcode_tid ot;
         u8 rsvd[3];
@@ -565,6 +680,34 @@ struct cpl_tx_pkt_lso_core {
         /* encapsulated CPL (TX_PKT, TX_PKT_XT or TX_DATA) follows here */
 };
 
+/* cpl_tx_pkt_lso_core.lso_ctrl fields */
+#define LSO_TCPHDR_LEN_S    0
+#define LSO_TCPHDR_LEN_V(x) ((x) << LSO_TCPHDR_LEN_S)
+
+#define LSO_IPHDR_LEN_S    4
+#define LSO_IPHDR_LEN_V(x) ((x) << LSO_IPHDR_LEN_S)
+
+#define LSO_ETHHDR_LEN_S    16
+#define LSO_ETHHDR_LEN_V(x) ((x) << LSO_ETHHDR_LEN_S)
+
+#define LSO_IPV6_S    20
+#define LSO_IPV6_V(x) ((x) << LSO_IPV6_S)
+#define LSO_IPV6_F    LSO_IPV6_V(1U)
+
+#define LSO_LAST_SLICE_S    22
+#define LSO_LAST_SLICE_V(x) ((x) << LSO_LAST_SLICE_S)
+#define LSO_LAST_SLICE_F    LSO_LAST_SLICE_V(1U)
+
+#define LSO_FIRST_SLICE_S    23
+#define LSO_FIRST_SLICE_V(x) ((x) << LSO_FIRST_SLICE_S)
+#define LSO_FIRST_SLICE_F    LSO_FIRST_SLICE_V(1U)
+
+#define LSO_OPCODE_S    24
+#define LSO_OPCODE_V(x) ((x) << LSO_OPCODE_S)
+
+#define LSO_T5_XFER_SIZE_S         0
+#define LSO_T5_XFER_SIZE_V(x) ((x) << LSO_T5_XFER_SIZE_S)
+
 struct cpl_tx_pkt_lso {
         WR_HDR;
         struct cpl_tx_pkt_lso_core c;
@@ -574,8 +717,6 @@ struct cpl_tx_pkt_lso {
 struct cpl_iscsi_hdr {
         union opcode_tid ot;
         __be16 pdu_len_ddp;
-#define ISCSI_PDU_LEN(x) ((x) & 0x7FFF)
-#define ISCSI_DDP        (1 << 15)
         __be16 len;
         __be32 seq;
         __be16 urg;
@@ -583,6 +724,16 @@ struct cpl_iscsi_hdr {
         u8 status;
 };
 
+/* cpl_iscsi_hdr.pdu_len_ddp fields */
+#define ISCSI_PDU_LEN_S    0
+#define ISCSI_PDU_LEN_M    0x7FFF
+#define ISCSI_PDU_LEN_V(x) ((x) << ISCSI_PDU_LEN_S)
+#define ISCSI_PDU_LEN_G(x) (((x) >> ISCSI_PDU_LEN_S) & ISCSI_PDU_LEN_M)
+
+#define ISCSI_DDP_S    15
+#define ISCSI_DDP_V(x) ((x) << ISCSI_DDP_S)
+#define ISCSI_DDP_F    ISCSI_DDP_V(1U)
+
 struct cpl_rx_data {
         union opcode_tid ot;
         __be16 rsvd;
@@ -639,49 +790,61 @@ struct cpl_rx_pkt {
         __be16 vlan;
         __be16 len;
         __be32 l2info;
-#define RXF_UDP (1 << 22)
-#define RXF_TCP (1 << 23)
-#define RXF_IP  (1 << 24)
-#define RXF_IP6 (1 << 25)
         __be16 hdr_len;
         __be16 err_vec;
 };
 
+#define RXF_UDP_S    22
+#define RXF_UDP_V(x) ((x) << RXF_UDP_S)
+#define RXF_UDP_F    RXF_UDP_V(1U)
+
+#define RXF_TCP_S    23
+#define RXF_TCP_V(x) ((x) << RXF_TCP_S)
+#define RXF_TCP_F    RXF_TCP_V(1U)
+
+#define RXF_IP_S    24
+#define RXF_IP_V(x) ((x) << RXF_IP_S)
+#define RXF_IP_F    RXF_IP_V(1U)
+
+#define RXF_IP6_S    25
+#define RXF_IP6_V(x) ((x) << RXF_IP6_S)
+#define RXF_IP6_F    RXF_IP6_V(1U)
+
 /* rx_pkt.l2info fields */
-#define S_RX_ETHHDR_LEN    0
-#define M_RX_ETHHDR_LEN    0x1F
-#define V_RX_ETHHDR_LEN(x) ((x) << S_RX_ETHHDR_LEN)
-#define G_RX_ETHHDR_LEN(x) (((x) >> S_RX_ETHHDR_LEN) & M_RX_ETHHDR_LEN)
-
-#define S_RX_T5_ETHHDR_LEN    0
-#define M_RX_T5_ETHHDR_LEN    0x3F
-#define V_RX_T5_ETHHDR_LEN(x) ((x) << S_RX_T5_ETHHDR_LEN)
-#define G_RX_T5_ETHHDR_LEN(x) (((x) >> S_RX_T5_ETHHDR_LEN) & M_RX_T5_ETHHDR_LEN)
-
-#define S_RX_MACIDX    8
-#define M_RX_MACIDX    0x1FF
-#define V_RX_MACIDX(x) ((x) << S_RX_MACIDX)
-#define G_RX_MACIDX(x) (((x) >> S_RX_MACIDX) & M_RX_MACIDX)
-
-#define S_RXF_SYN    21
-#define V_RXF_SYN(x) ((x) << S_RXF_SYN)
-#define F_RXF_SYN    V_RXF_SYN(1U)
-
-#define S_RX_CHAN    28
-#define M_RX_CHAN    0xF
-#define V_RX_CHAN(x) ((x) << S_RX_CHAN)
-#define G_RX_CHAN(x) (((x) >> S_RX_CHAN) & M_RX_CHAN)
+#define RX_ETHHDR_LEN_S    0
+#define RX_ETHHDR_LEN_M    0x1F
+#define RX_ETHHDR_LEN_V(x) ((x) << RX_ETHHDR_LEN_S)
+#define RX_ETHHDR_LEN_G(x) (((x) >> RX_ETHHDR_LEN_S) & RX_ETHHDR_LEN_M)
+
+#define RX_T5_ETHHDR_LEN_S    0
+#define RX_T5_ETHHDR_LEN_M    0x3F
+#define RX_T5_ETHHDR_LEN_V(x) ((x) << RX_T5_ETHHDR_LEN_S)
+#define RX_T5_ETHHDR_LEN_G(x) (((x) >> RX_T5_ETHHDR_LEN_S) & RX_T5_ETHHDR_LEN_M)
+
+#define RX_MACIDX_S    8
+#define RX_MACIDX_M    0x1FF
+#define RX_MACIDX_V(x) ((x) << RX_MACIDX_S)
+#define RX_MACIDX_G(x) (((x) >> RX_MACIDX_S) & RX_MACIDX_M)
+
+#define RXF_SYN_S    21
+#define RXF_SYN_V(x) ((x) << RXF_SYN_S)
+#define RXF_SYN_F    RXF_SYN_V(1U)
+
+#define RX_CHAN_S    28
+#define RX_CHAN_M    0xF
+#define RX_CHAN_V(x) ((x) << RX_CHAN_S)
+#define RX_CHAN_G(x) (((x) >> RX_CHAN_S) & RX_CHAN_M)
 
 /* rx_pkt.hdr_len fields */
-#define S_RX_TCPHDR_LEN    0
-#define M_RX_TCPHDR_LEN    0x3F
-#define V_RX_TCPHDR_LEN(x) ((x) << S_RX_TCPHDR_LEN)
-#define G_RX_TCPHDR_LEN(x) (((x) >> S_RX_TCPHDR_LEN) & M_RX_TCPHDR_LEN)
+#define RX_TCPHDR_LEN_S    0
+#define RX_TCPHDR_LEN_M    0x3F
+#define RX_TCPHDR_LEN_V(x) ((x) << RX_TCPHDR_LEN_S)
+#define RX_TCPHDR_LEN_G(x) (((x) >> RX_TCPHDR_LEN_S) & RX_TCPHDR_LEN_M)
 
-#define S_RX_IPHDR_LEN    6
-#define M_RX_IPHDR_LEN    0x3FF
-#define V_RX_IPHDR_LEN(x) ((x) << S_RX_IPHDR_LEN)
-#define G_RX_IPHDR_LEN(x) (((x) >> S_RX_IPHDR_LEN) & M_RX_IPHDR_LEN)
+#define RX_IPHDR_LEN_S    6
+#define RX_IPHDR_LEN_M    0x3FF
+#define RX_IPHDR_LEN_V(x) ((x) << RX_IPHDR_LEN_S)
+#define RX_IPHDR_LEN_G(x) (((x) >> RX_IPHDR_LEN_S) & RX_IPHDR_LEN_M)
 
 struct cpl_trace_pkt {
         u8 opcode;
@@ -730,14 +893,22 @@ struct cpl_l2t_write_req {
         WR_HDR;
         union opcode_tid ot;
         __be16 params;
-#define L2T_W_INFO(x)    ((x) << 2)
-#define L2T_W_PORT(x)    ((x) << 8)
-#define L2T_W_NOREPLY(x) ((x) << 15)
         __be16 l2t_idx;
         __be16 vlan;
         u8 dst_mac[6];
 };
 
+/* cpl_l2t_write_req.params fields */
+#define L2T_W_INFO_S    2
+#define L2T_W_INFO_V(x) ((x) << L2T_W_INFO_S)
+
+#define L2T_W_PORT_S    8
+#define L2T_W_PORT_V(x) ((x) << L2T_W_PORT_S)
+
+#define L2T_W_NOREPLY_S    15
+#define L2T_W_NOREPLY_V(x) ((x) << L2T_W_NOREPLY_S)
+#define L2T_W_NOREPLY_F    L2T_W_NOREPLY_V(1U)
+
 struct cpl_l2t_write_rpl {
         union opcode_tid ot;
         u8 status;
@@ -752,11 +923,15 @@ struct cpl_rdma_terminate {
 
 struct cpl_sge_egr_update {
         __be32 opcode_qid;
-#define EGR_QID(x) ((x) & 0x1FFFF)
         __be16 cidx;
         __be16 pidx;
 };
 
+/* cpl_sge_egr_update.ot fields */
+#define EGR_QID_S    0
+#define EGR_QID_M    0x1FFFF
+#define EGR_QID_G(x) (((x) >> EGR_QID_S) & EGR_QID_M)
+
 /* cpl_fw*.type values */
 enum {
         FW_TYPE_CMD_RPL = 0,
@@ -849,22 +1024,30 @@ struct ulptx_sge_pair {
 
 struct ulptx_sgl {
         __be32 cmd_nsge;
-#define ULPTX_NSGE(x) ((x) << 0)
-#define ULPTX_MORE (1U << 23)
         __be32 len0;
         __be64 addr0;
         struct ulptx_sge_pair sge[0];
 };
 
+#define ULPTX_NSGE_S    0
+#define ULPTX_NSGE_V(x) ((x) << ULPTX_NSGE_S)
+
+#define ULPTX_MORE_S    23
+#define ULPTX_MORE_V(x) ((x) << ULPTX_MORE_S)
+#define ULPTX_MORE_F    ULPTX_MORE_V(1U)
+
 struct ulp_mem_io {
         WR_HDR;
         __be32 cmd;
         __be32 len16;             /* command length */
         __be32 dlen;              /* data length in 32-byte units */
         __be32 lock_addr;
-#define ULP_MEMIO_LOCK(x) ((x) << 31)
 };
 
+#define ULP_MEMIO_LOCK_S    31
+#define ULP_MEMIO_LOCK_V(x) ((x) << ULP_MEMIO_LOCK_S)
+#define ULP_MEMIO_LOCK_F    ULP_MEMIO_LOCK_V(1U)
+
 /* additional ulp_mem_io.cmd fields */
 #define ULP_MEMIO_ORDER_S    23
 #define ULP_MEMIO_ORDER_V(x) ((x) << ULP_MEMIO_ORDER_S)
@@ -874,13 +1057,9 @@ struct ulp_mem_io {
 #define T5_ULP_MEMIO_IMM_V(x) ((x) << T5_ULP_MEMIO_IMM_S)
 #define T5_ULP_MEMIO_IMM_F    T5_ULP_MEMIO_IMM_V(1U)
 
-#define S_T5_ULP_MEMIO_IMM    23
-#define V_T5_ULP_MEMIO_IMM(x) ((x) << S_T5_ULP_MEMIO_IMM)
-#define F_T5_ULP_MEMIO_IMM    V_T5_ULP_MEMIO_IMM(1U)
-
-#define S_T5_ULP_MEMIO_ORDER    22
-#define V_T5_ULP_MEMIO_ORDER(x) ((x) << S_T5_ULP_MEMIO_ORDER)
-#define F_T5_ULP_MEMIO_ORDER    V_T5_ULP_MEMIO_ORDER(1U)
+#define T5_ULP_MEMIO_ORDER_S    22
+#define T5_ULP_MEMIO_ORDER_V(x) ((x) << T5_ULP_MEMIO_ORDER_S)
+#define T5_ULP_MEMIO_ORDER_F    T5_ULP_MEMIO_ORDER_V(1U)
 
 /* ulp_mem_io.lock_addr fields */
 #define ULP_MEMIO_ADDR_S    0
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h b/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
index 9e4f95a91fb4..ddfb5b846045 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
@@ -153,6 +153,7 @@ CH_PCI_DEVICE_ID_TABLE_DEFINE_BEGIN
         CH_PCI_ID_TABLE_FENTRY(0x5086), /* Custom 2x T580-CR */
         CH_PCI_ID_TABLE_FENTRY(0x5087), /* Custom T580-CR */
         CH_PCI_ID_TABLE_FENTRY(0x5088), /* Custom T570-CR */
+        CH_PCI_ID_TABLE_FENTRY(0x5089), /* Custom T520-CR */
 CH_PCI_DEVICE_ID_TABLE_DEFINE_END;
 
 #endif /* CH_PCI_DEVICE_ID_TABLE_DEFINE_BEGIN */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h b/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h
index d7bd34ee65bd..231a725f6d5d 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h
@@ -63,460 +63,779 @@
 #define MC_BIST_STATUS_REG(reg_addr, idx) ((reg_addr) + (idx) * 4)
 #define EDC_BIST_STATUS_REG(reg_addr, idx) ((reg_addr) + (idx) * 4)
 
-#define SGE_PF_KDOORBELL 0x0
-#define  QID_MASK    0xffff8000U
-#define  QID_SHIFT   15
-#define  QID(x)      ((x) << QID_SHIFT)
-#define  DBPRIO(x)   ((x) << 14)
-#define  DBTYPE(x)   ((x) << 13)
-#define  PIDX_MASK   0x00003fffU
-#define  PIDX_SHIFT  0
-#define  PIDX(x)     ((x) << PIDX_SHIFT)
-#define  PIDX_SHIFT_T5   0
-#define  PIDX_T5(x)  ((x) << PIDX_SHIFT_T5)
-
-
-#define SGE_TIMERREGS   6
-#define SGE_PF_GTS 0x4
-#define  INGRESSQID_MASK   0xffff0000U
-#define  INGRESSQID_SHIFT  16
-#define  INGRESSQID(x)     ((x) << INGRESSQID_SHIFT)
-#define  TIMERREG_MASK     0x0000e000U
-#define  TIMERREG_SHIFT    13
-#define  TIMERREG(x)       ((x) << TIMERREG_SHIFT)
-#define  SEINTARM_MASK     0x00001000U
-#define  SEINTARM_SHIFT    12
-#define  SEINTARM(x)       ((x) << SEINTARM_SHIFT)
-#define  CIDXINC_MASK      0x00000fffU
-#define  CIDXINC_SHIFT     0
-#define  CIDXINC(x)        ((x) << CIDXINC_SHIFT)
-
-#define X_RXPKTCPLMODE_SPLIT     1
-#define X_INGPADBOUNDARY_SHIFT 5
-
-#define SGE_CONTROL 0x1008
-#define SGE_CONTROL2_A          0x1124
-#define  DCASYSTYPE             0x00080000U
-#define  RXPKTCPLMODE_MASK      0x00040000U
-#define  RXPKTCPLMODE_SHIFT     18
-#define  RXPKTCPLMODE(x)        ((x) << RXPKTCPLMODE_SHIFT)
-#define  EGRSTATUSPAGESIZE_MASK  0x00020000U
-#define  EGRSTATUSPAGESIZE_SHIFT 17
-#define  EGRSTATUSPAGESIZE(x)    ((x) << EGRSTATUSPAGESIZE_SHIFT)
-#define  PKTSHIFT_MASK          0x00001c00U
-#define  PKTSHIFT_SHIFT         10
-#define  PKTSHIFT(x)            ((x) << PKTSHIFT_SHIFT)
-#define  PKTSHIFT_GET(x)        (((x) & PKTSHIFT_MASK) >> PKTSHIFT_SHIFT)
-#define  INGPCIEBOUNDARY_32B_X  0
-#define  INGPCIEBOUNDARY_MASK   0x00000380U
-#define  INGPCIEBOUNDARY_SHIFT  7
-#define  INGPCIEBOUNDARY(x)     ((x) << INGPCIEBOUNDARY_SHIFT)
-#define  INGPADBOUNDARY_MASK    0x00000070U
-#define  INGPADBOUNDARY_SHIFT   4
-#define  INGPADBOUNDARY(x)      ((x) << INGPADBOUNDARY_SHIFT)
-#define  INGPADBOUNDARY_GET(x)  (((x) & INGPADBOUNDARY_MASK) \
-                                 >> INGPADBOUNDARY_SHIFT)
-#define  INGPACKBOUNDARY_16B_X  0
-#define  INGPACKBOUNDARY_SHIFT_X 5
+#define SGE_PF_KDOORBELL_A 0x0
+
+#define QID_S    15
+#define QID_V(x) ((x) << QID_S)
+
+#define DBPRIO_S    14
+#define DBPRIO_V(x) ((x) << DBPRIO_S)
+#define DBPRIO_F    DBPRIO_V(1U)
+
+#define PIDX_S    0
+#define PIDX_V(x) ((x) << PIDX_S)
+
+#define SGE_VF_KDOORBELL_A 0x0
+
+#define DBTYPE_S    13
+#define DBTYPE_V(x) ((x) << DBTYPE_S)
+#define DBTYPE_F    DBTYPE_V(1U)
+
+#define PIDX_T5_S    0
+#define PIDX_T5_M    0x1fffU
+#define PIDX_T5_V(x) ((x) << PIDX_T5_S)
+#define PIDX_T5_G(x) (((x) >> PIDX_T5_S) & PIDX_T5_M)
+
+#define SGE_PF_GTS_A 0x4
+
+#define INGRESSQID_S    16
+#define INGRESSQID_V(x) ((x) << INGRESSQID_S)
+
+#define TIMERREG_S    13
+#define TIMERREG_V(x) ((x) << TIMERREG_S)
+
+#define SEINTARM_S    12
+#define SEINTARM_V(x) ((x) << SEINTARM_S)
+
+#define CIDXINC_S    0
+#define CIDXINC_M    0xfffU
+#define CIDXINC_V(x) ((x) << CIDXINC_S)
+
+#define SGE_CONTROL_A   0x1008
+#define SGE_CONTROL2_A  0x1124
+
+#define RXPKTCPLMODE_S    18
+#define RXPKTCPLMODE_V(x) ((x) << RXPKTCPLMODE_S)
+#define RXPKTCPLMODE_F    RXPKTCPLMODE_V(1U)
+
+#define EGRSTATUSPAGESIZE_S    17
+#define EGRSTATUSPAGESIZE_V(x) ((x) << EGRSTATUSPAGESIZE_S)
+#define EGRSTATUSPAGESIZE_F    EGRSTATUSPAGESIZE_V(1U)
+
+#define PKTSHIFT_S    10
+#define PKTSHIFT_M    0x7U
+#define PKTSHIFT_V(x) ((x) << PKTSHIFT_S)
+#define PKTSHIFT_G(x) (((x) >> PKTSHIFT_S) & PKTSHIFT_M)
+
+#define INGPCIEBOUNDARY_S    7
+#define INGPCIEBOUNDARY_V(x) ((x) << INGPCIEBOUNDARY_S)
+
+#define INGPADBOUNDARY_S    4
+#define INGPADBOUNDARY_M    0x7U
+#define INGPADBOUNDARY_V(x) ((x) << INGPADBOUNDARY_S)
+#define INGPADBOUNDARY_G(x) (((x) >> INGPADBOUNDARY_S) & INGPADBOUNDARY_M)
+
+#define EGRPCIEBOUNDARY_S    1
+#define EGRPCIEBOUNDARY_V(x) ((x) << EGRPCIEBOUNDARY_S)
 
 #define  INGPACKBOUNDARY_S      16
 #define  INGPACKBOUNDARY_M      0x7U
 #define  INGPACKBOUNDARY_V(x)   ((x) << INGPACKBOUNDARY_S)
 #define  INGPACKBOUNDARY_G(x)   (((x) >> INGPACKBOUNDARY_S) \
                                  & INGPACKBOUNDARY_M)
-#define  EGRPCIEBOUNDARY_MASK   0x0000000eU
-#define  EGRPCIEBOUNDARY_SHIFT  1
-#define  EGRPCIEBOUNDARY(x)     ((x) << EGRPCIEBOUNDARY_SHIFT)
-#define  GLOBALENABLE           0x00000001U
 
-#define SGE_HOST_PAGE_SIZE 0x100c
+#define GLOBALENABLE_S    0
+#define GLOBALENABLE_V(x) ((x) << GLOBALENABLE_S)
+#define GLOBALENABLE_F    GLOBALENABLE_V(1U)
+
+#define SGE_HOST_PAGE_SIZE_A 0x100c
+
+#define HOSTPAGESIZEPF7_S    28
+#define HOSTPAGESIZEPF7_M    0xfU
+#define HOSTPAGESIZEPF7_V(x) ((x) << HOSTPAGESIZEPF7_S)
+#define HOSTPAGESIZEPF7_G(x) (((x) >> HOSTPAGESIZEPF7_S) & HOSTPAGESIZEPF7_M)
+
+#define HOSTPAGESIZEPF6_S    24
+#define HOSTPAGESIZEPF6_M    0xfU
+#define HOSTPAGESIZEPF6_V(x) ((x) << HOSTPAGESIZEPF6_S)
+#define HOSTPAGESIZEPF6_G(x) (((x) >> HOSTPAGESIZEPF6_S) & HOSTPAGESIZEPF6_M)
+
+#define HOSTPAGESIZEPF5_S    20
+#define HOSTPAGESIZEPF5_M    0xfU
+#define HOSTPAGESIZEPF5_V(x) ((x) << HOSTPAGESIZEPF5_S)
+#define HOSTPAGESIZEPF5_G(x) (((x) >> HOSTPAGESIZEPF5_S) & HOSTPAGESIZEPF5_M)
+
+#define HOSTPAGESIZEPF4_S    16
+#define HOSTPAGESIZEPF4_M    0xfU
+#define HOSTPAGESIZEPF4_V(x) ((x) << HOSTPAGESIZEPF4_S)
+#define HOSTPAGESIZEPF4_G(x) (((x) >> HOSTPAGESIZEPF4_S) & HOSTPAGESIZEPF4_M)
+
+#define HOSTPAGESIZEPF3_S    12
+#define HOSTPAGESIZEPF3_M    0xfU
+#define HOSTPAGESIZEPF3_V(x) ((x) << HOSTPAGESIZEPF3_S)
+#define HOSTPAGESIZEPF3_G(x) (((x) >> HOSTPAGESIZEPF3_S) & HOSTPAGESIZEPF3_M)
+
+#define HOSTPAGESIZEPF2_S    8
+#define HOSTPAGESIZEPF2_M    0xfU
+#define HOSTPAGESIZEPF2_V(x) ((x) << HOSTPAGESIZEPF2_S)
+#define HOSTPAGESIZEPF2_G(x) (((x) >> HOSTPAGESIZEPF2_S) & HOSTPAGESIZEPF2_M)
+
+#define HOSTPAGESIZEPF1_S    4
+#define HOSTPAGESIZEPF1_M    0xfU
+#define HOSTPAGESIZEPF1_V(x) ((x) << HOSTPAGESIZEPF1_S)
+#define HOSTPAGESIZEPF1_G(x) (((x) >> HOSTPAGESIZEPF1_S) & HOSTPAGESIZEPF1_M)
+
+#define HOSTPAGESIZEPF0_S    0
+#define HOSTPAGESIZEPF0_M    0xfU
+#define HOSTPAGESIZEPF0_V(x) ((x) << HOSTPAGESIZEPF0_S)
+#define HOSTPAGESIZEPF0_G(x) (((x) >> HOSTPAGESIZEPF0_S) & HOSTPAGESIZEPF0_M)
+
+#define SGE_EGRESS_QUEUES_PER_PAGE_PF_A 0x1010
+#define SGE_EGRESS_QUEUES_PER_PAGE_VF_A 0x1014
 
-#define  HOSTPAGESIZEPF7_MASK   0x0000000fU
-#define  HOSTPAGESIZEPF7_SHIFT  28
-#define  HOSTPAGESIZEPF7(x)     ((x) << HOSTPAGESIZEPF7_SHIFT)
+#define QUEUESPERPAGEPF1_S    4
 
-#define  HOSTPAGESIZEPF6_MASK   0x0000000fU
-#define  HOSTPAGESIZEPF6_SHIFT  24
-#define  HOSTPAGESIZEPF6(x)     ((x) << HOSTPAGESIZEPF6_SHIFT)
+#define QUEUESPERPAGEPF0_S    0
+#define QUEUESPERPAGEPF0_M    0xfU
+#define QUEUESPERPAGEPF0_V(x) ((x) << QUEUESPERPAGEPF0_S)
+#define QUEUESPERPAGEPF0_G(x) (((x) >> QUEUESPERPAGEPF0_S) & QUEUESPERPAGEPF0_M)
 
-#define  HOSTPAGESIZEPF5_MASK   0x0000000fU
-#define  HOSTPAGESIZEPF5_SHIFT  20
-#define  HOSTPAGESIZEPF5(x)     ((x) << HOSTPAGESIZEPF5_SHIFT)
+#define SGE_INT_CAUSE1_A        0x1024
+#define SGE_INT_CAUSE2_A        0x1030
+#define SGE_INT_CAUSE3_A        0x103c
+
+#define ERR_FLM_DBP_S    31
+#define ERR_FLM_DBP_V(x) ((x) << ERR_FLM_DBP_S)
+#define ERR_FLM_DBP_F    ERR_FLM_DBP_V(1U)
+
+#define ERR_FLM_IDMA1_S    30
+#define ERR_FLM_IDMA1_V(x) ((x) << ERR_FLM_IDMA1_S)
+#define ERR_FLM_IDMA1_F    ERR_FLM_IDMA1_V(1U)
+
+#define ERR_FLM_IDMA0_S    29
+#define ERR_FLM_IDMA0_V(x) ((x) << ERR_FLM_IDMA0_S)
+#define ERR_FLM_IDMA0_F    ERR_FLM_IDMA0_V(1U)
+
+#define ERR_FLM_HINT_S    28
+#define ERR_FLM_HINT_V(x) ((x) << ERR_FLM_HINT_S)
+#define ERR_FLM_HINT_F    ERR_FLM_HINT_V(1U)
+
+#define ERR_PCIE_ERROR3_S    27
+#define ERR_PCIE_ERROR3_V(x) ((x) << ERR_PCIE_ERROR3_S)
+#define ERR_PCIE_ERROR3_F    ERR_PCIE_ERROR3_V(1U)
+
+#define ERR_PCIE_ERROR2_S    26
+#define ERR_PCIE_ERROR2_V(x) ((x) << ERR_PCIE_ERROR2_S)
+#define ERR_PCIE_ERROR2_F    ERR_PCIE_ERROR2_V(1U)
+
+#define ERR_PCIE_ERROR1_S    25
+#define ERR_PCIE_ERROR1_V(x) ((x) << ERR_PCIE_ERROR1_S)
+#define ERR_PCIE_ERROR1_F    ERR_PCIE_ERROR1_V(1U)
+
+#define ERR_PCIE_ERROR0_S    24
+#define ERR_PCIE_ERROR0_V(x) ((x) << ERR_PCIE_ERROR0_S)
+#define ERR_PCIE_ERROR0_F    ERR_PCIE_ERROR0_V(1U)
+
+#define ERR_CPL_EXCEED_IQE_SIZE_S    22
+#define ERR_CPL_EXCEED_IQE_SIZE_V(x) ((x) << ERR_CPL_EXCEED_IQE_SIZE_S)
+#define ERR_CPL_EXCEED_IQE_SIZE_F    ERR_CPL_EXCEED_IQE_SIZE_V(1U)
+
+#define ERR_INVALID_CIDX_INC_S    21
+#define ERR_INVALID_CIDX_INC_V(x) ((x) << ERR_INVALID_CIDX_INC_S)
+#define ERR_INVALID_CIDX_INC_F    ERR_INVALID_CIDX_INC_V(1U)
+
+#define ERR_CPL_OPCODE_0_S    19
+#define ERR_CPL_OPCODE_0_V(x) ((x) << ERR_CPL_OPCODE_0_S)
+#define ERR_CPL_OPCODE_0_F    ERR_CPL_OPCODE_0_V(1U)
+
+#define ERR_DROPPED_DB_S    18
+#define ERR_DROPPED_DB_V(x) ((x) << ERR_DROPPED_DB_S)
+#define ERR_DROPPED_DB_F    ERR_DROPPED_DB_V(1U)
+
+#define ERR_DATA_CPL_ON_HIGH_QID1_S    17
+#define ERR_DATA_CPL_ON_HIGH_QID1_V(x) ((x) << ERR_DATA_CPL_ON_HIGH_QID1_S)
+#define ERR_DATA_CPL_ON_HIGH_QID1_F    ERR_DATA_CPL_ON_HIGH_QID1_V(1U)
+
+#define ERR_DATA_CPL_ON_HIGH_QID0_S    16
+#define ERR_DATA_CPL_ON_HIGH_QID0_V(x) ((x) << ERR_DATA_CPL_ON_HIGH_QID0_S)
+#define ERR_DATA_CPL_ON_HIGH_QID0_F    ERR_DATA_CPL_ON_HIGH_QID0_V(1U)
+
+#define ERR_BAD_DB_PIDX3_S    15
+#define ERR_BAD_DB_PIDX3_V(x) ((x) << ERR_BAD_DB_PIDX3_S)
+#define ERR_BAD_DB_PIDX3_F    ERR_BAD_DB_PIDX3_V(1U)
+
+#define ERR_BAD_DB_PIDX2_S    14
+#define ERR_BAD_DB_PIDX2_V(x) ((x) << ERR_BAD_DB_PIDX2_S)
+#define ERR_BAD_DB_PIDX2_F    ERR_BAD_DB_PIDX2_V(1U)
+
+#define ERR_BAD_DB_PIDX1_S    13
+#define ERR_BAD_DB_PIDX1_V(x) ((x) << ERR_BAD_DB_PIDX1_S)
+#define ERR_BAD_DB_PIDX1_F    ERR_BAD_DB_PIDX1_V(1U)
+
+#define ERR_BAD_DB_PIDX0_S    12
+#define ERR_BAD_DB_PIDX0_V(x) ((x) << ERR_BAD_DB_PIDX0_S)
+#define ERR_BAD_DB_PIDX0_F    ERR_BAD_DB_PIDX0_V(1U)
+
+#define ERR_ING_CTXT_PRIO_S    10
+#define ERR_ING_CTXT_PRIO_V(x) ((x) << ERR_ING_CTXT_PRIO_S)
+#define ERR_ING_CTXT_PRIO_F    ERR_ING_CTXT_PRIO_V(1U)
+
+#define ERR_EGR_CTXT_PRIO_S    9
+#define ERR_EGR_CTXT_PRIO_V(x) ((x) << ERR_EGR_CTXT_PRIO_S)
+#define ERR_EGR_CTXT_PRIO_F    ERR_EGR_CTXT_PRIO_V(1U)
+
+#define DBFIFO_HP_INT_S    8
+#define DBFIFO_HP_INT_V(x) ((x) << DBFIFO_HP_INT_S)
+#define DBFIFO_HP_INT_F    DBFIFO_HP_INT_V(1U)
+
+#define DBFIFO_LP_INT_S    7
+#define DBFIFO_LP_INT_V(x) ((x) << DBFIFO_LP_INT_S)
+#define DBFIFO_LP_INT_F    DBFIFO_LP_INT_V(1U)
+
+#define INGRESS_SIZE_ERR_S    5
+#define INGRESS_SIZE_ERR_V(x) ((x) << INGRESS_SIZE_ERR_S)
+#define INGRESS_SIZE_ERR_F    INGRESS_SIZE_ERR_V(1U)
+
+#define EGRESS_SIZE_ERR_S    4
+#define EGRESS_SIZE_ERR_V(x) ((x) << EGRESS_SIZE_ERR_S)
+#define EGRESS_SIZE_ERR_F    EGRESS_SIZE_ERR_V(1U)
+
+#define SGE_INT_ENABLE3_A 0x1040
+#define SGE_FL_BUFFER_SIZE0_A 0x1044
+#define SGE_FL_BUFFER_SIZE1_A 0x1048
+#define SGE_FL_BUFFER_SIZE2_A 0x104c
+#define SGE_FL_BUFFER_SIZE3_A 0x1050
+#define SGE_FL_BUFFER_SIZE4_A 0x1054
+#define SGE_FL_BUFFER_SIZE5_A 0x1058
+#define SGE_FL_BUFFER_SIZE6_A 0x105c
+#define SGE_FL_BUFFER_SIZE7_A 0x1060
+#define SGE_FL_BUFFER_SIZE8_A 0x1064
+
+#define SGE_INGRESS_RX_THRESHOLD_A 0x10a0
+
+#define THRESHOLD_0_S    24
+#define THRESHOLD_0_M    0x3fU
+#define THRESHOLD_0_V(x) ((x) << THRESHOLD_0_S)
+#define THRESHOLD_0_G(x) (((x) >> THRESHOLD_0_S) & THRESHOLD_0_M)
+
+#define THRESHOLD_1_S    16
+#define THRESHOLD_1_M    0x3fU
+#define THRESHOLD_1_V(x) ((x) << THRESHOLD_1_S)
+#define THRESHOLD_1_G(x) (((x) >> THRESHOLD_1_S) & THRESHOLD_1_M)
+
+#define THRESHOLD_2_S    8
+#define THRESHOLD_2_M    0x3fU
+#define THRESHOLD_2_V(x) ((x) << THRESHOLD_2_S)
+#define THRESHOLD_2_G(x) (((x) >> THRESHOLD_2_S) & THRESHOLD_2_M)
+
+#define THRESHOLD_3_S    0
+#define THRESHOLD_3_M    0x3fU
+#define THRESHOLD_3_V(x) ((x) << THRESHOLD_3_S)
+#define THRESHOLD_3_G(x) (((x) >> THRESHOLD_3_S) & THRESHOLD_3_M)
+
+#define SGE_CONM_CTRL_A 0x1094
+
+#define EGRTHRESHOLD_S    8
+#define EGRTHRESHOLD_M    0x3fU
+#define EGRTHRESHOLD_V(x) ((x) << EGRTHRESHOLD_S)
+#define EGRTHRESHOLD_G(x) (((x) >> EGRTHRESHOLD_S) & EGRTHRESHOLD_M)
+
+#define EGRTHRESHOLDPACKING_S    14
+#define EGRTHRESHOLDPACKING_M    0x3fU
+#define EGRTHRESHOLDPACKING_V(x) ((x) << EGRTHRESHOLDPACKING_S)
+#define EGRTHRESHOLDPACKING_G(x) \
+        (((x) >> EGRTHRESHOLDPACKING_S) & EGRTHRESHOLDPACKING_M)
+
+#define SGE_TIMESTAMP_LO_A 0x1098
+#define SGE_TIMESTAMP_HI_A 0x109c
+
+#define TSOP_S    28
+#define TSOP_M    0x3U
+#define TSOP_V(x) ((x) << TSOP_S)
+#define TSOP_G(x) (((x) >> TSOP_S) & TSOP_M)
+
+#define TSVAL_S    0
+#define TSVAL_M    0xfffffffU
+#define TSVAL_V(x) ((x) << TSVAL_S)
+#define TSVAL_G(x) (((x) >> TSVAL_S) & TSVAL_M)
+
+#define SGE_DBFIFO_STATUS_A 0x10a4
+
+#define HP_INT_THRESH_S    28
+#define HP_INT_THRESH_M    0xfU
+#define HP_INT_THRESH_V(x) ((x) << HP_INT_THRESH_S)
+
+#define LP_INT_THRESH_S    12
+#define LP_INT_THRESH_M    0xfU
+#define LP_INT_THRESH_V(x) ((x) << LP_INT_THRESH_S)
+
+#define SGE_DOORBELL_CONTROL_A 0x10a8
+
+#define NOCOALESCE_S    26
+#define NOCOALESCE_V(x) ((x) << NOCOALESCE_S)
+#define NOCOALESCE_F    NOCOALESCE_V(1U)
+
+#define ENABLE_DROP_S    13
+#define ENABLE_DROP_V(x) ((x) << ENABLE_DROP_S)
+#define ENABLE_DROP_F    ENABLE_DROP_V(1U)
+
+#define SGE_TIMER_VALUE_0_AND_1_A 0x10b8
+
+#define TIMERVALUE0_S    16
+#define TIMERVALUE0_M    0xffffU
+#define TIMERVALUE0_V(x) ((x) << TIMERVALUE0_S)
+#define TIMERVALUE0_G(x) (((x) >> TIMERVALUE0_S) & TIMERVALUE0_M)
+
+#define TIMERVALUE1_S    0
+#define TIMERVALUE1_M    0xffffU
+#define TIMERVALUE1_V(x) ((x) << TIMERVALUE1_S)
+#define TIMERVALUE1_G(x) (((x) >> TIMERVALUE1_S) & TIMERVALUE1_M)
+
+#define SGE_TIMER_VALUE_2_AND_3_A 0x10bc
+
+#define TIMERVALUE2_S    16
+#define TIMERVALUE2_M    0xffffU
+#define TIMERVALUE2_V(x) ((x) << TIMERVALUE2_S)
+#define TIMERVALUE2_G(x) (((x) >> TIMERVALUE2_S) & TIMERVALUE2_M)
+
+#define TIMERVALUE3_S    0
+#define TIMERVALUE3_M    0xffffU
+#define TIMERVALUE3_V(x) ((x) << TIMERVALUE3_S)
+#define TIMERVALUE3_G(x) (((x) >> TIMERVALUE3_S) & TIMERVALUE3_M)
+
+#define SGE_TIMER_VALUE_4_AND_5_A 0x10c0
+
+#define TIMERVALUE4_S    16
+#define TIMERVALUE4_M    0xffffU
+#define TIMERVALUE4_V(x) ((x) << TIMERVALUE4_S)
+#define TIMERVALUE4_G(x) (((x) >> TIMERVALUE4_S) & TIMERVALUE4_M)
 
-#define  HOSTPAGESIZEPF4_MASK   0x0000000fU
-#define  HOSTPAGESIZEPF4_SHIFT  16
-#define  HOSTPAGESIZEPF4(x)     ((x) << HOSTPAGESIZEPF4_SHIFT)
+#define TIMERVALUE5_S    0
+#define TIMERVALUE5_M    0xffffU
+#define TIMERVALUE5_V(x) ((x) << TIMERVALUE5_S)
+#define TIMERVALUE5_G(x) (((x) >> TIMERVALUE5_S) & TIMERVALUE5_M)
 
-#define  HOSTPAGESIZEPF3_MASK   0x0000000fU
-#define  HOSTPAGESIZEPF3_SHIFT  12
-#define  HOSTPAGESIZEPF3(x)     ((x) << HOSTPAGESIZEPF3_SHIFT)
+#define SGE_DEBUG_INDEX_A 0x10cc
+#define SGE_DEBUG_DATA_HIGH_A 0x10d0
+#define SGE_DEBUG_DATA_LOW_A 0x10d4
 
-#define  HOSTPAGESIZEPF2_MASK   0x0000000fU
-#define  HOSTPAGESIZEPF2_SHIFT  8
-#define  HOSTPAGESIZEPF2(x)     ((x) << HOSTPAGESIZEPF2_SHIFT)
+#define SGE_DEBUG_DATA_LOW_INDEX_2_A    0x12c8
+#define SGE_DEBUG_DATA_LOW_INDEX_3_A    0x12cc
+#define SGE_DEBUG_DATA_HIGH_INDEX_10_A  0x12a8
 
-#define  HOSTPAGESIZEPF1_M      0x0000000fU
-#define  HOSTPAGESIZEPF1_S      4
-#define  HOSTPAGESIZEPF1(x)     ((x) << HOSTPAGESIZEPF1_S)
+#define SGE_INGRESS_QUEUES_PER_PAGE_PF_A 0x10f4
+#define SGE_INGRESS_QUEUES_PER_PAGE_VF_A 0x10f8
 
-#define  HOSTPAGESIZEPF0_M      0x0000000fU
-#define  HOSTPAGESIZEPF0_S      0
-#define  HOSTPAGESIZEPF0(x)     ((x) << HOSTPAGESIZEPF0_S)
+#define HP_INT_THRESH_S    28
+#define HP_INT_THRESH_M    0xfU
+#define HP_INT_THRESH_V(x) ((x) << HP_INT_THRESH_S)
 
-#define SGE_EGRESS_QUEUES_PER_PAGE_PF 0x1010
-#define SGE_EGRESS_QUEUES_PER_PAGE_VF_A 0x1014
+#define HP_COUNT_S    16
+#define HP_COUNT_M    0x7ffU
+#define HP_COUNT_G(x) (((x) >> HP_COUNT_S) & HP_COUNT_M)
 
-#define QUEUESPERPAGEPF1_S    4
+#define LP_INT_THRESH_S    12
+#define LP_INT_THRESH_M    0xfU
+#define LP_INT_THRESH_V(x) ((x) << LP_INT_THRESH_S)
 
-#define QUEUESPERPAGEPF0_S    0
-#define QUEUESPERPAGEPF0_MASK   0x0000000fU
-#define QUEUESPERPAGEPF0_GET(x) ((x) & QUEUESPERPAGEPF0_MASK)
+#define LP_COUNT_S    0
+#define LP_COUNT_M    0x7ffU
+#define LP_COUNT_G(x) (((x) >> LP_COUNT_S) & LP_COUNT_M)
 
-#define QUEUESPERPAGEPF0    0
-#define QUEUESPERPAGEPF1    4
+#define LP_INT_THRESH_T5_S    18
+#define LP_INT_THRESH_T5_M    0xfffU
+#define LP_INT_THRESH_T5_V(x) ((x) << LP_INT_THRESH_T5_S)
 
-/* T5 and later support a new BAR2-based doorbell mechanism for Egress Queues.
- * The User Doorbells are each 128 bytes in length with a Simple Doorbell at
- * offsets 8x and a Write Combining single 64-byte Egress Queue Unit
- * (X_IDXSIZE_UNIT) Gather Buffer interface at offset 64.  For Ingress Queues,
- * we have a Going To Sleep register at offsets 8x+4.
- *
- * As noted above, we have many instances of the Simple Doorbell and Going To
- * Sleep registers at offsets 8x and 8x+4, respectively.  We want to use a
- * non-64-byte aligned offset for the Simple Doorbell in order to attempt to
- * avoid buffering of the writes to the Simple Doorbell and we want to use a
- * non-contiguous offset for the Going To Sleep writes in order to avoid
- * possible combining between them.
- */
-#define SGE_UDB_SIZE            128
-#define SGE_UDB_KDOORBELL       8
-#define SGE_UDB_GTS             20
-#define SGE_UDB_WCDOORBELL      64
-
-#define SGE_INT_CAUSE1 0x1024
-#define SGE_INT_CAUSE2 0x1030
-#define SGE_INT_CAUSE3 0x103c
-#define  ERR_FLM_DBP               0x80000000U
-#define  ERR_FLM_IDMA1             0x40000000U
-#define  ERR_FLM_IDMA0             0x20000000U
-#define  ERR_FLM_HINT              0x10000000U
-#define  ERR_PCIE_ERROR3           0x08000000U
-#define  ERR_PCIE_ERROR2           0x04000000U
-#define  ERR_PCIE_ERROR1           0x02000000U
-#define  ERR_PCIE_ERROR0           0x01000000U
-#define  ERR_TIMER_ABOVE_MAX_QID   0x00800000U
-#define  ERR_CPL_EXCEED_IQE_SIZE   0x00400000U
-#define  ERR_INVALID_CIDX_INC      0x00200000U
-#define  ERR_ITP_TIME_PAUSED       0x00100000U
-#define  ERR_CPL_OPCODE_0          0x00080000U
-#define  ERR_DROPPED_DB            0x00040000U
-#define  ERR_DATA_CPL_ON_HIGH_QID1 0x00020000U
-#define  ERR_DATA_CPL_ON_HIGH_QID0 0x00010000U
-#define  ERR_BAD_DB_PIDX3          0x00008000U
-#define  ERR_BAD_DB_PIDX2          0x00004000U
-#define  ERR_BAD_DB_PIDX1          0x00002000U
-#define  ERR_BAD_DB_PIDX0          0x00001000U
-#define  ERR_ING_PCIE_CHAN         0x00000800U
-#define  ERR_ING_CTXT_PRIO         0x00000400U
-#define  ERR_EGR_CTXT_PRIO         0x00000200U
-#define  DBFIFO_HP_INT             0x00000100U
-#define  DBFIFO_LP_INT             0x00000080U
-#define  REG_ADDRESS_ERR           0x00000040U
-#define  INGRESS_SIZE_ERR          0x00000020U
-#define  EGRESS_SIZE_ERR           0x00000010U
-#define  ERR_INV_CTXT3             0x00000008U
-#define  ERR_INV_CTXT2             0x00000004U
-#define  ERR_INV_CTXT1             0x00000002U
-#define  ERR_INV_CTXT0             0x00000001U
-
-#define SGE_INT_ENABLE3 0x1040
-#define SGE_FL_BUFFER_SIZE0 0x1044
-#define SGE_FL_BUFFER_SIZE1 0x1048
-#define SGE_FL_BUFFER_SIZE2 0x104c
-#define SGE_FL_BUFFER_SIZE3 0x1050
-#define SGE_FL_BUFFER_SIZE4 0x1054
-#define SGE_FL_BUFFER_SIZE5 0x1058
-#define SGE_FL_BUFFER_SIZE6 0x105c
-#define SGE_FL_BUFFER_SIZE7 0x1060
-#define SGE_FL_BUFFER_SIZE8 0x1064
-
-#define SGE_INGRESS_RX_THRESHOLD 0x10a0
-#define  THRESHOLD_0_MASK   0x3f000000U
-#define  THRESHOLD_0_SHIFT  24
-#define  THRESHOLD_0(x)     ((x) << THRESHOLD_0_SHIFT)
-#define  THRESHOLD_0_GET(x) (((x) & THRESHOLD_0_MASK) >> THRESHOLD_0_SHIFT)
-#define  THRESHOLD_1_MASK   0x003f0000U
-#define  THRESHOLD_1_SHIFT  16
-#define  THRESHOLD_1(x)     ((x) << THRESHOLD_1_SHIFT)
-#define  THRESHOLD_1_GET(x) (((x) & THRESHOLD_1_MASK) >> THRESHOLD_1_SHIFT)
-#define  THRESHOLD_2_MASK   0x00003f00U
-#define  THRESHOLD_2_SHIFT  8
-#define  THRESHOLD_2(x)     ((x) << THRESHOLD_2_SHIFT)
-#define  THRESHOLD_2_GET(x) (((x) & THRESHOLD_2_MASK) >> THRESHOLD_2_SHIFT)
-#define  THRESHOLD_3_MASK   0x0000003fU
-#define  THRESHOLD_3_SHIFT  0
-#define  THRESHOLD_3(x)     ((x) << THRESHOLD_3_SHIFT)
-#define  THRESHOLD_3_GET(x) (((x) & THRESHOLD_3_MASK) >> THRESHOLD_3_SHIFT)
-
-#define SGE_CONM_CTRL 0x1094
-#define  EGRTHRESHOLD_MASK   0x00003f00U
-#define  EGRTHRESHOLDshift   8
-#define  EGRTHRESHOLD(x)     ((x) << EGRTHRESHOLDshift)
-#define  EGRTHRESHOLD_GET(x) (((x) & EGRTHRESHOLD_MASK) >> EGRTHRESHOLDshift)
-
-#define EGRTHRESHOLDPACKING_MASK        0x3fU
-#define EGRTHRESHOLDPACKING_SHIFT       14
-#define EGRTHRESHOLDPACKING(x)          ((x) << EGRTHRESHOLDPACKING_SHIFT)
-#define EGRTHRESHOLDPACKING_GET(x)      (((x) >> EGRTHRESHOLDPACKING_SHIFT) & \
-                                          EGRTHRESHOLDPACKING_MASK)
-
-#define SGE_DBFIFO_STATUS 0x10a4
-#define  HP_INT_THRESH_SHIFT 28
-#define  HP_INT_THRESH_MASK  0xfU
-#define  HP_INT_THRESH(x)    ((x) << HP_INT_THRESH_SHIFT)
-#define  LP_INT_THRESH_SHIFT 12
-#define  LP_INT_THRESH_MASK  0xfU
-#define  LP_INT_THRESH(x)    ((x) << LP_INT_THRESH_SHIFT)
-
-#define SGE_DOORBELL_CONTROL 0x10a8
-#define  ENABLE_DROP        (1 << 13)
-
-#define S_NOCOALESCE    26
-#define V_NOCOALESCE(x) ((x) << S_NOCOALESCE)
-#define F_NOCOALESCE    V_NOCOALESCE(1U)
-
-#define SGE_TIMESTAMP_LO 0x1098
-#define SGE_TIMESTAMP_HI 0x109c
-#define S_TSVAL    0
-#define M_TSVAL    0xfffffffU
-#define GET_TSVAL(x) (((x) >> S_TSVAL) & M_TSVAL)
-
-#define SGE_TIMER_VALUE_0_AND_1 0x10b8
-#define  TIMERVALUE0_MASK   0xffff0000U
-#define  TIMERVALUE0_SHIFT  16
-#define  TIMERVALUE0(x)     ((x) << TIMERVALUE0_SHIFT)
-#define  TIMERVALUE0_GET(x) (((x) & TIMERVALUE0_MASK) >> TIMERVALUE0_SHIFT)
-#define  TIMERVALUE1_MASK   0x0000ffffU
-#define  TIMERVALUE1_SHIFT  0
-#define  TIMERVALUE1(x)     ((x) << TIMERVALUE1_SHIFT)
-#define  TIMERVALUE1_GET(x) (((x) & TIMERVALUE1_MASK) >> TIMERVALUE1_SHIFT)
-
-#define SGE_TIMER_VALUE_2_AND_3 0x10bc
-#define  TIMERVALUE2_MASK   0xffff0000U
-#define  TIMERVALUE2_SHIFT  16
-#define  TIMERVALUE2(x)     ((x) << TIMERVALUE2_SHIFT)
-#define  TIMERVALUE2_GET(x) (((x) & TIMERVALUE2_MASK) >> TIMERVALUE2_SHIFT)
-#define  TIMERVALUE3_MASK   0x0000ffffU
-#define  TIMERVALUE3_SHIFT  0
-#define  TIMERVALUE3(x)     ((x) << TIMERVALUE3_SHIFT)
-#define  TIMERVALUE3_GET(x) (((x) & TIMERVALUE3_MASK) >> TIMERVALUE3_SHIFT)
-
-#define SGE_TIMER_VALUE_4_AND_5 0x10c0
-#define  TIMERVALUE4_MASK   0xffff0000U
-#define  TIMERVALUE4_SHIFT  16
-#define  TIMERVALUE4(x)     ((x) << TIMERVALUE4_SHIFT)
-#define  TIMERVALUE4_GET(x) (((x) & TIMERVALUE4_MASK) >> TIMERVALUE4_SHIFT)
-#define  TIMERVALUE5_MASK   0x0000ffffU
-#define  TIMERVALUE5_SHIFT  0
-#define  TIMERVALUE5(x)     ((x) << TIMERVALUE5_SHIFT)
-#define  TIMERVALUE5_GET(x) (((x) & TIMERVALUE5_MASK) >> TIMERVALUE5_SHIFT)
-
-#define SGE_DEBUG_INDEX 0x10cc
-#define SGE_DEBUG_DATA_HIGH 0x10d0
-#define SGE_DEBUG_DATA_LOW 0x10d4
-#define SGE_DEBUG_DATA_LOW_INDEX_2      0x12c8
-#define SGE_DEBUG_DATA_LOW_INDEX_3      0x12cc
-#define SGE_DEBUG_DATA_HIGH_INDEX_10    0x12a8
-#define SGE_INGRESS_QUEUES_PER_PAGE_PF 0x10f4
-#define SGE_INGRESS_QUEUES_PER_PAGE_VF_A 0x10f8
+#define LP_COUNT_T5_S    0
+#define LP_COUNT_T5_M    0x3ffffU
+#define LP_COUNT_T5_G(x) (((x) >> LP_COUNT_T5_S) & LP_COUNT_T5_M)
+
+#define SGE_DOORBELL_CONTROL_A 0x10a8
+
+#define SGE_STAT_TOTAL_A        0x10e4
+#define SGE_STAT_MATCH_A        0x10e8
+#define SGE_STAT_CFG_A          0x10ec
+
+#define STATSOURCE_T5_S    9
+#define STATSOURCE_T5_V(x) ((x) << STATSOURCE_T5_S)
+
+#define SGE_DBFIFO_STATUS2_A 0x1118
+
+#define HP_INT_THRESH_T5_S    10
+#define HP_INT_THRESH_T5_M    0xfU
+#define HP_INT_THRESH_T5_V(x) ((x) << HP_INT_THRESH_T5_S)
+
+#define HP_COUNT_T5_S    0
+#define HP_COUNT_T5_M    0x3ffU
+#define HP_COUNT_T5_G(x) (((x) >> HP_COUNT_T5_S) & HP_COUNT_T5_M)
+
+#define ENABLE_DROP_S    13
+#define ENABLE_DROP_V(x) ((x) << ENABLE_DROP_S)
+#define ENABLE_DROP_F    ENABLE_DROP_V(1U)
+
+#define DROPPED_DB_S    0
+#define DROPPED_DB_V(x) ((x) << DROPPED_DB_S)
+#define DROPPED_DB_F    DROPPED_DB_V(1U)
+
+#define SGE_CTXT_CMD_A 0x11fc
+#define SGE_DBQ_CTXT_BADDR_A 0x1084
+
+/* registers for module PCIE */
+#define PCIE_PF_CFG_A   0x40
+
+#define AIVEC_S    4
+#define AIVEC_M    0x3ffU
+#define AIVEC_V(x) ((x) << AIVEC_S)
+
+#define PCIE_PF_CLI_A   0x44
+#define PCIE_INT_CAUSE_A        0x3004
+
+#define UNXSPLCPLERR_S    29
+#define UNXSPLCPLERR_V(x) ((x) << UNXSPLCPLERR_S)
+#define UNXSPLCPLERR_F    UNXSPLCPLERR_V(1U)
+
+#define PCIEPINT_S    28
+#define PCIEPINT_V(x) ((x) << PCIEPINT_S)
+#define PCIEPINT_F    PCIEPINT_V(1U)
+
+#define PCIESINT_S    27
+#define PCIESINT_V(x) ((x) << PCIESINT_S)
+#define PCIESINT_F    PCIESINT_V(1U)
+
+#define RPLPERR_S    26
+#define RPLPERR_V(x) ((x) << RPLPERR_S)
+#define RPLPERR_F    RPLPERR_V(1U)
+
+#define RXWRPERR_S    25
+#define RXWRPERR_V(x) ((x) << RXWRPERR_S)
+#define RXWRPERR_F    RXWRPERR_V(1U)
+
+#define RXCPLPERR_S    24
+#define RXCPLPERR_V(x) ((x) << RXCPLPERR_S)
+#define RXCPLPERR_F    RXCPLPERR_V(1U)
+
+#define PIOTAGPERR_S    23
+#define PIOTAGPERR_V(x) ((x) << PIOTAGPERR_S)
+#define PIOTAGPERR_F    PIOTAGPERR_V(1U)
+
+#define MATAGPERR_S    22
+#define MATAGPERR_V(x) ((x) << MATAGPERR_S)
+#define MATAGPERR_F    MATAGPERR_V(1U)
+
+#define INTXCLRPERR_S    21
+#define INTXCLRPERR_V(x) ((x) << INTXCLRPERR_S)
+#define INTXCLRPERR_F    INTXCLRPERR_V(1U)
+
+#define FIDPERR_S    20
+#define FIDPERR_V(x) ((x) << FIDPERR_S)
+#define FIDPERR_F    FIDPERR_V(1U)
+
+#define CFGSNPPERR_S    19
+#define CFGSNPPERR_V(x) ((x) << CFGSNPPERR_S)
+#define CFGSNPPERR_F    CFGSNPPERR_V(1U)
+
+#define HRSPPERR_S    18
+#define HRSPPERR_V(x) ((x) << HRSPPERR_S)
+#define HRSPPERR_F    HRSPPERR_V(1U)
+
+#define HREQPERR_S    17
+#define HREQPERR_V(x) ((x) << HREQPERR_S)
+#define HREQPERR_F    HREQPERR_V(1U)
+
+#define HCNTPERR_S    16
+#define HCNTPERR_V(x) ((x) << HCNTPERR_S)
+#define HCNTPERR_F    HCNTPERR_V(1U)
+
+#define DRSPPERR_S    15
+#define DRSPPERR_V(x) ((x) << DRSPPERR_S)
+#define DRSPPERR_F    DRSPPERR_V(1U)
+
+#define DREQPERR_S    14
+#define DREQPERR_V(x) ((x) << DREQPERR_S)
+#define DREQPERR_F    DREQPERR_V(1U)
+
+#define DCNTPERR_S    13
+#define DCNTPERR_V(x) ((x) << DCNTPERR_S)
+#define DCNTPERR_F    DCNTPERR_V(1U)
+
+#define CRSPPERR_S    12
+#define CRSPPERR_V(x) ((x) << CRSPPERR_S)
+#define CRSPPERR_F    CRSPPERR_V(1U)
+
+#define CREQPERR_S    11
+#define CREQPERR_V(x) ((x) << CREQPERR_S)
+#define CREQPERR_F    CREQPERR_V(1U)
+
+#define CCNTPERR_S    10
+#define CCNTPERR_V(x) ((x) << CCNTPERR_S)
+#define CCNTPERR_F    CCNTPERR_V(1U)
+
+#define TARTAGPERR_S    9
+#define TARTAGPERR_V(x) ((x) << TARTAGPERR_S)
+#define TARTAGPERR_F    TARTAGPERR_V(1U)
+
+#define PIOREQPERR_S    8
+#define PIOREQPERR_V(x) ((x) << PIOREQPERR_S)
+#define PIOREQPERR_F    PIOREQPERR_V(1U)
+
+#define PIOCPLPERR_S    7
+#define PIOCPLPERR_V(x) ((x) << PIOCPLPERR_S)
+#define PIOCPLPERR_F    PIOCPLPERR_V(1U)
+
+#define MSIXDIPERR_S    6
+#define MSIXDIPERR_V(x) ((x) << MSIXDIPERR_S)
+#define MSIXDIPERR_F    MSIXDIPERR_V(1U)
+
+#define MSIXDATAPERR_S    5
+#define MSIXDATAPERR_V(x) ((x) << MSIXDATAPERR_S)
+#define MSIXDATAPERR_F    MSIXDATAPERR_V(1U)
+
+#define MSIXADDRHPERR_S    4
+#define MSIXADDRHPERR_V(x) ((x) << MSIXADDRHPERR_S)
+#define MSIXADDRHPERR_F    MSIXADDRHPERR_V(1U)
+
+#define MSIXADDRLPERR_S    3
+#define MSIXADDRLPERR_V(x) ((x) << MSIXADDRLPERR_S)
+#define MSIXADDRLPERR_F    MSIXADDRLPERR_V(1U)
+
+#define MSIDATAPERR_S    2
+#define MSIDATAPERR_V(x) ((x) << MSIDATAPERR_S)
+#define MSIDATAPERR_F    MSIDATAPERR_V(1U)
+
+#define MSIADDRHPERR_S    1
+#define MSIADDRHPERR_V(x) ((x) << MSIADDRHPERR_S)
+#define MSIADDRHPERR_F    MSIADDRHPERR_V(1U)
+
+#define MSIADDRLPERR_S    0
+#define MSIADDRLPERR_V(x) ((x) << MSIADDRLPERR_S)
+#define MSIADDRLPERR_F    MSIADDRLPERR_V(1U)
+
+#define READRSPERR_S    29
+#define READRSPERR_V(x) ((x) << READRSPERR_S)
+#define READRSPERR_F    READRSPERR_V(1U)
+
+#define TRGT1GRPPERR_S    28
+#define TRGT1GRPPERR_V(x) ((x) << TRGT1GRPPERR_S)
+#define TRGT1GRPPERR_F    TRGT1GRPPERR_V(1U)
+
+#define IPSOTPERR_S    27
+#define IPSOTPERR_V(x) ((x) << IPSOTPERR_S)
+#define IPSOTPERR_F    IPSOTPERR_V(1U)
+
+#define IPRETRYPERR_S    26
+#define IPRETRYPERR_V(x) ((x) << IPRETRYPERR_S)
+#define IPRETRYPERR_F    IPRETRYPERR_V(1U)
+
+#define IPRXDATAGRPPERR_S    25
+#define IPRXDATAGRPPERR_V(x) ((x) << IPRXDATAGRPPERR_S)
+#define IPRXDATAGRPPERR_F    IPRXDATAGRPPERR_V(1U)
+
+#define IPRXHDRGRPPERR_S    24
+#define IPRXHDRGRPPERR_V(x) ((x) << IPRXHDRGRPPERR_S)
+#define IPRXHDRGRPPERR_F    IPRXHDRGRPPERR_V(1U)
+
+#define MAGRPPERR_S    22
+#define MAGRPPERR_V(x) ((x) << MAGRPPERR_S)
+#define MAGRPPERR_F    MAGRPPERR_V(1U)
+
+#define VFIDPERR_S    21
+#define VFIDPERR_V(x) ((x) << VFIDPERR_S)
+#define VFIDPERR_F    VFIDPERR_V(1U)
+
+#define HREQWRPERR_S    16
+#define HREQWRPERR_V(x) ((x) << HREQWRPERR_S)
+#define HREQWRPERR_F    HREQWRPERR_V(1U)
+
+#define DREQWRPERR_S    13
+#define DREQWRPERR_V(x) ((x) << DREQWRPERR_S)
+#define DREQWRPERR_F    DREQWRPERR_V(1U)
+
+#define CREQRDPERR_S    11
+#define CREQRDPERR_V(x) ((x) << CREQRDPERR_S)
+#define CREQRDPERR_F    CREQRDPERR_V(1U)
+
+#define MSTTAGQPERR_S    10
+#define MSTTAGQPERR_V(x) ((x) << MSTTAGQPERR_S)
+#define MSTTAGQPERR_F    MSTTAGQPERR_V(1U)
+
+#define PIOREQGRPPERR_S    8
+#define PIOREQGRPPERR_V(x) ((x) << PIOREQGRPPERR_S)
+#define PIOREQGRPPERR_F    PIOREQGRPPERR_V(1U)
+
+#define PIOCPLGRPPERR_S    7
+#define PIOCPLGRPPERR_V(x) ((x) << PIOCPLGRPPERR_S)
+#define PIOCPLGRPPERR_F    PIOCPLGRPPERR_V(1U)
+
+#define MSIXSTIPERR_S    2
+#define MSIXSTIPERR_V(x) ((x) << MSIXSTIPERR_S)
+#define MSIXSTIPERR_F    MSIXSTIPERR_V(1U)
+
+#define MSTTIMEOUTPERR_S    1
+#define MSTTIMEOUTPERR_V(x) ((x) << MSTTIMEOUTPERR_S)
+#define MSTTIMEOUTPERR_F    MSTTIMEOUTPERR_V(1U)
+
+#define MSTGRPPERR_S    0
+#define MSTGRPPERR_V(x) ((x) << MSTGRPPERR_S)
+#define MSTGRPPERR_F    MSTGRPPERR_V(1U)
+
+#define PCIE_NONFAT_ERR_A       0x3010
+#define PCIE_CFG_SPACE_REQ_A    0x3060
+#define PCIE_CFG_SPACE_DATA_A   0x3064
+#define PCIE_MEM_ACCESS_BASE_WIN_A 0x3068
+
+#define PCIEOFST_S    10
+#define PCIEOFST_M    0x3fffffU
+#define PCIEOFST_G(x) (((x) >> PCIEOFST_S) & PCIEOFST_M)
+
+#define BIR_S    8
+#define BIR_M    0x3U
+#define BIR_V(x) ((x) << BIR_S)
+#define BIR_G(x) (((x) >> BIR_S) & BIR_M)
+
+#define WINDOW_S    0
+#define WINDOW_M    0xffU
+#define WINDOW_V(x) ((x) << WINDOW_S)
+#define WINDOW_G(x) (((x) >> WINDOW_S) & WINDOW_M)
+
+#define PCIE_MEM_ACCESS_OFFSET_A 0x306c
+
+#define ENABLE_S    30
+#define ENABLE_V(x) ((x) << ENABLE_S)
+#define ENABLE_F    ENABLE_V(1U)
+
+#define LOCALCFG_S    28
+#define LOCALCFG_V(x) ((x) << LOCALCFG_S)
+#define LOCALCFG_F    LOCALCFG_V(1U)
+
+#define FUNCTION_S    12
+#define FUNCTION_V(x) ((x) << FUNCTION_S)
+
+#define REGISTER_S    0
+#define REGISTER_V(x) ((x) << REGISTER_S)
+
+#define PFNUM_S    0
+#define PFNUM_V(x) ((x) << PFNUM_S)
+
+#define PCIE_FW_A 0x30b8
+
+#define PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS_A 0x5908
+
+#define RNPP_S    31
+#define RNPP_V(x) ((x) << RNPP_S)
+#define RNPP_F    RNPP_V(1U)
+
+#define RPCP_S    29
+#define RPCP_V(x) ((x) << RPCP_S)
+#define RPCP_F    RPCP_V(1U)
+
+#define RCIP_S    27
+#define RCIP_V(x) ((x) << RCIP_S)
+#define RCIP_F    RCIP_V(1U)
+
+#define RCCP_S    26
+#define RCCP_V(x) ((x) << RCCP_S)
+#define RCCP_F    RCCP_V(1U)
+
+#define RFTP_S    23
+#define RFTP_V(x) ((x) << RFTP_S)
+#define RFTP_F    RFTP_V(1U)
+
+#define PTRP_S    20
+#define PTRP_V(x) ((x) << PTRP_S)
+#define PTRP_F    PTRP_V(1U)
 
-#define S_HP_INT_THRESH    28
-#define M_HP_INT_THRESH 0xfU
-#define V_HP_INT_THRESH(x) ((x) << S_HP_INT_THRESH)
-#define S_LP_INT_THRESH_T5    18
-#define V_LP_INT_THRESH_T5(x) ((x) << S_LP_INT_THRESH_T5)
-#define M_LP_COUNT_T5    0x3ffffU
-#define G_LP_COUNT_T5(x) (((x) >> S_LP_COUNT) & M_LP_COUNT_T5)
-#define M_HP_COUNT 0x7ffU
-#define S_HP_COUNT 16
-#define G_HP_COUNT(x) (((x) >> S_HP_COUNT) & M_HP_COUNT)
-#define S_LP_INT_THRESH    12
-#define M_LP_INT_THRESH 0xfU
-#define M_LP_INT_THRESH_T5    0xfffU
-#define V_LP_INT_THRESH(x) ((x) << S_LP_INT_THRESH)
-#define M_LP_COUNT 0x7ffU
-#define S_LP_COUNT 0
-#define G_LP_COUNT(x) (((x) >> S_LP_COUNT) & M_LP_COUNT)
-#define A_SGE_DBFIFO_STATUS 0x10a4
-
-#define SGE_STAT_TOTAL 0x10e4
-#define SGE_STAT_MATCH 0x10e8
-
-#define SGE_STAT_CFG   0x10ec
-#define S_STATSOURCE_T5    9
-#define STATSOURCE_T5(x) ((x) << S_STATSOURCE_T5)
-
-#define SGE_DBFIFO_STATUS2 0x1118
-#define M_HP_COUNT_T5    0x3ffU
-#define G_HP_COUNT_T5(x) ((x)  & M_HP_COUNT_T5)
-#define S_HP_INT_THRESH_T5    10
-#define M_HP_INT_THRESH_T5    0xfU
-#define V_HP_INT_THRESH_T5(x) ((x) << S_HP_INT_THRESH_T5)
-
-#define S_ENABLE_DROP    13
-#define V_ENABLE_DROP(x) ((x) << S_ENABLE_DROP)
-#define F_ENABLE_DROP    V_ENABLE_DROP(1U)
-#define S_DROPPED_DB 0
-#define V_DROPPED_DB(x) ((x) << S_DROPPED_DB)
-#define F_DROPPED_DB V_DROPPED_DB(1U)
-#define A_SGE_DOORBELL_CONTROL 0x10a8
-
-#define A_SGE_CTXT_CMD 0x11fc
-#define A_SGE_DBQ_CTXT_BADDR 0x1084
-
-#define PCIE_PF_CFG 0x40
-#define  AIVEC(x)       ((x) << 4)
-#define  AIVEC_MASK     0x3ffU
-
-#define PCIE_PF_CLI 0x44
-#define PCIE_INT_CAUSE 0x3004
-#define  UNXSPLCPLERR  0x20000000U
-#define  PCIEPINT      0x10000000U
-#define  PCIESINT      0x08000000U
-#define  RPLPERR       0x04000000U
-#define  RXWRPERR      0x02000000U
-#define  RXCPLPERR     0x01000000U
-#define  PIOTAGPERR    0x00800000U
-#define  MATAGPERR     0x00400000U
-#define  INTXCLRPERR   0x00200000U
-#define  FIDPERR       0x00100000U
-#define  CFGSNPPERR    0x00080000U
-#define  HRSPPERR      0x00040000U
-#define  HREQPERR      0x00020000U
-#define  HCNTPERR      0x00010000U
-#define  DRSPPERR      0x00008000U
-#define  DREQPERR      0x00004000U
-#define  DCNTPERR      0x00002000U
-#define  CRSPPERR      0x00001000U
-#define  CREQPERR      0x00000800U
-#define  CCNTPERR      0x00000400U
-#define  TARTAGPERR    0x00000200U
-#define  PIOREQPERR    0x00000100U
-#define  PIOCPLPERR    0x00000080U
-#define  MSIXDIPERR    0x00000040U
-#define  MSIXDATAPERR  0x00000020U
-#define  MSIXADDRHPERR 0x00000010U
-#define  MSIXADDRLPERR 0x00000008U
-#define  MSIDATAPERR   0x00000004U
-#define  MSIADDRHPERR  0x00000002U
-#define  MSIADDRLPERR  0x00000001U
-
-#define  READRSPERR      0x20000000U
-#define  TRGT1GRPPERR    0x10000000U
-#define  IPSOTPERR       0x08000000U
-#define  IPRXDATAGRPPERR 0x02000000U
-#define  IPRXHDRGRPPERR  0x01000000U
-#define  MAGRPPERR       0x00400000U
-#define  VFIDPERR        0x00200000U
-#define  HREQWRPERR      0x00010000U
-#define  DREQWRPERR      0x00002000U
-#define  MSTTAGQPERR     0x00000400U
-#define  PIOREQGRPPERR   0x00000100U
-#define  PIOCPLGRPPERR   0x00000080U
-#define  MSIXSTIPERR     0x00000004U
-#define  MSTTIMEOUTPERR  0x00000002U
-#define  MSTGRPPERR      0x00000001U
-
-#define PCIE_NONFAT_ERR 0x3010
-#define PCIE_CFG_SPACE_REQ 0x3060
-#define PCIE_CFG_SPACE_DATA 0x3064
-#define PCIE_MEM_ACCESS_BASE_WIN 0x3068
-#define S_PCIEOFST       10
-#define M_PCIEOFST       0x3fffffU
-#define GET_PCIEOFST(x)  (((x) >> S_PCIEOFST) & M_PCIEOFST)
-#define  PCIEOFST_MASK   0xfffffc00U
-#define  BIR_MASK        0x00000300U
-#define  BIR_SHIFT       8
-#define  BIR(x)          ((x) << BIR_SHIFT)
-#define  WINDOW_MASK     0x000000ffU
-#define  WINDOW_SHIFT    0
-#define  WINDOW(x)       ((x) << WINDOW_SHIFT)
-#define  GET_WINDOW(x)   (((x) >> WINDOW_SHIFT) & WINDOW_MASK)
-#define PCIE_MEM_ACCESS_OFFSET 0x306c
-#define ENABLE  (1U << 30)
-#define FUNCTION(x) ((x) << 12)
-#define F_LOCALCFG    (1U << 28)
-
-#define S_PFNUM    0
-#define V_PFNUM(x) ((x) << S_PFNUM)
-
-#define PCIE_FW 0x30b8
-#define  PCIE_FW_ERR            0x80000000U
-#define  PCIE_FW_INIT           0x40000000U
-#define  PCIE_FW_HALT           0x20000000U
-#define  PCIE_FW_MASTER_VLD     0x00008000U
-#define  PCIE_FW_MASTER(x)      ((x) << 12)
-#define  PCIE_FW_MASTER_MASK    0x7
-#define  PCIE_FW_MASTER_GET(x)  (((x) >> 12) & PCIE_FW_MASTER_MASK)
-
-#define PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS 0x5908
-#define  RNPP 0x80000000U
-#define  RPCP 0x20000000U
-#define  RCIP 0x08000000U
-#define  RCCP 0x04000000U
-#define  RFTP 0x00800000U
-#define  PTRP 0x00100000U
-
-#define PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS 0x59a4
-#define  TPCP 0x40000000U
-#define  TNPP 0x20000000U
-#define  TFTP 0x10000000U
-#define  TCAP 0x08000000U
-#define  TCIP 0x04000000U
-#define  RCAP 0x02000000U
-#define  PLUP 0x00800000U
-#define  PLDN 0x00400000U
-#define  OTDD 0x00200000U
-#define  GTRP 0x00100000U
-#define  RDPE 0x00040000U
-#define  TDCE 0x00020000U
-#define  TDUE 0x00010000U
-
-#define MC_INT_CAUSE 0x7518
-#define MC_P_INT_CAUSE 0x41318
-#define  ECC_UE_INT_CAUSE 0x00000004U
-#define  ECC_CE_INT_CAUSE 0x00000002U
-#define  PERR_INT_CAUSE   0x00000001U
-
-#define MC_ECC_STATUS 0x751c
-#define MC_P_ECC_STATUS 0x4131c
-#define  ECC_CECNT_MASK   0xffff0000U
-#define  ECC_CECNT_SHIFT  16
-#define  ECC_CECNT(x)     ((x) << ECC_CECNT_SHIFT)
-#define  ECC_CECNT_GET(x) (((x) & ECC_CECNT_MASK) >> ECC_CECNT_SHIFT)
-#define  ECC_UECNT_MASK   0x0000ffffU
-#define  ECC_UECNT_SHIFT  0
-#define  ECC_UECNT(x)     ((x) << ECC_UECNT_SHIFT)
-#define  ECC_UECNT_GET(x) (((x) & ECC_UECNT_MASK) >> ECC_UECNT_SHIFT)
-
-#define MC_BIST_CMD 0x7600
-#define  START_BIST          0x80000000U
-#define  BIST_CMD_GAP_MASK   0x0000ff00U
-#define  BIST_CMD_GAP_SHIFT  8
-#define  BIST_CMD_GAP(x)     ((x) << BIST_CMD_GAP_SHIFT)
-#define  BIST_OPCODE_MASK    0x00000003U
-#define  BIST_OPCODE_SHIFT   0
-#define  BIST_OPCODE(x)      ((x) << BIST_OPCODE_SHIFT)
-
-#define MC_BIST_CMD_ADDR 0x7604
-#define MC_BIST_CMD_LEN 0x7608
-#define MC_BIST_DATA_PATTERN 0x760c
-#define  BIST_DATA_TYPE_MASK   0x0000000fU
-#define  BIST_DATA_TYPE_SHIFT  0
-#define  BIST_DATA_TYPE(x)     ((x) << BIST_DATA_TYPE_SHIFT)
-
-#define MC_BIST_STATUS_RDATA 0x7688
+#define PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS_A 0x59a4
 
+#define TPCP_S    30
+#define TPCP_V(x) ((x) << TPCP_S)
+#define TPCP_F    TPCP_V(1U)
+
+#define TNPP_S    29
+#define TNPP_V(x) ((x) << TNPP_S)
+#define TNPP_F    TNPP_V(1U)
+
+#define TFTP_S    28
+#define TFTP_V(x) ((x) << TFTP_S)
+#define TFTP_F    TFTP_V(1U)
+
+#define TCAP_S    27
+#define TCAP_V(x) ((x) << TCAP_S)
+#define TCAP_F    TCAP_V(1U)
+
+#define TCIP_S    26
+#define TCIP_V(x) ((x) << TCIP_S)
+#define TCIP_F    TCIP_V(1U)
+
+#define RCAP_S    25
+#define RCAP_V(x) ((x) << RCAP_S)
+#define RCAP_F    RCAP_V(1U)
+
+#define PLUP_S    23
+#define PLUP_V(x) ((x) << PLUP_S)
+#define PLUP_F    PLUP_V(1U)
+
+#define PLDN_S    22
+#define PLDN_V(x) ((x) << PLDN_S)
+#define PLDN_F    PLDN_V(1U)
+
+#define OTDD_S    21
+#define OTDD_V(x) ((x) << OTDD_S)
+#define OTDD_F    OTDD_V(1U)
+
+#define GTRP_S    20
+#define GTRP_V(x) ((x) << GTRP_S)
+#define GTRP_F    GTRP_V(1U)
+
+#define RDPE_S    18
+#define RDPE_V(x) ((x) << RDPE_S)
+#define RDPE_F    RDPE_V(1U)
+
+#define TDCE_S    17
+#define TDCE_V(x) ((x) << TDCE_S)
+#define TDCE_F    TDCE_V(1U)
+
+#define TDUE_S    16
+#define TDUE_V(x) ((x) << TDUE_S)
+#define TDUE_F    TDUE_V(1U)
+
+/* registers for module MC */
+#define MC_INT_CAUSE_A          0x7518
+#define MC_P_INT_CAUSE_A        0x41318
+
+#define ECC_UE_INT_CAUSE_S    2
+#define ECC_UE_INT_CAUSE_V(x) ((x) << ECC_UE_INT_CAUSE_S)
+#define ECC_UE_INT_CAUSE_F    ECC_UE_INT_CAUSE_V(1U)
+
+#define ECC_CE_INT_CAUSE_S    1
+#define ECC_CE_INT_CAUSE_V(x) ((x) << ECC_CE_INT_CAUSE_S)
+#define ECC_CE_INT_CAUSE_F    ECC_CE_INT_CAUSE_V(1U)
+
+#define PERR_INT_CAUSE_S    0
+#define PERR_INT_CAUSE_V(x) ((x) << PERR_INT_CAUSE_S)
+#define PERR_INT_CAUSE_F    PERR_INT_CAUSE_V(1U)
+
+#define MC_ECC_STATUS_A         0x751c
+#define MC_P_ECC_STATUS_A       0x4131c
+
+#define ECC_CECNT_S    16
+#define ECC_CECNT_M    0xffffU
+#define ECC_CECNT_V(x) ((x) << ECC_CECNT_S)
+#define ECC_CECNT_G(x) (((x) >> ECC_CECNT_S) & ECC_CECNT_M)
+
+#define ECC_UECNT_S    0
+#define ECC_UECNT_M    0xffffU
+#define ECC_UECNT_V(x) ((x) << ECC_UECNT_S)
+#define ECC_UECNT_G(x) (((x) >> ECC_UECNT_S) & ECC_UECNT_M)
+
+#define MC_BIST_CMD_A 0x7600
+
+#define START_BIST_S    31
+#define START_BIST_V(x) ((x) << START_BIST_S)
+#define START_BIST_F    START_BIST_V(1U)
+
+#define BIST_CMD_GAP_S    8
+#define BIST_CMD_GAP_V(x) ((x) << BIST_CMD_GAP_S)
+
+#define BIST_OPCODE_S    0
+#define BIST_OPCODE_V(x) ((x) << BIST_OPCODE_S)
+
+#define MC_BIST_CMD_ADDR_A 0x7604
+#define MC_BIST_CMD_LEN_A 0x7608
+#define MC_BIST_DATA_PATTERN_A 0x760c
+
+#define MC_BIST_STATUS_RDATA_A 0x7688
+
+/* registers for module MA */
 #define MA_EDRAM0_BAR_A 0x77c0
 
 #define EDRAM0_SIZE_S    0
@@ -574,263 +893,608 @@
 #define EXT_MEM0_ENABLE_V(x) ((x) << EXT_MEM0_ENABLE_S)
 #define EXT_MEM0_ENABLE_F    EXT_MEM0_ENABLE_V(1U)
 
-#define MA_INT_CAUSE 0x77e0
-#define  MEM_PERR_INT_CAUSE 0x00000002U
-#define  MEM_WRAP_INT_CAUSE 0x00000001U
-
-#define MA_INT_WRAP_STATUS 0x77e4
-#define  MEM_WRAP_ADDRESS_MASK   0xfffffff0U
-#define  MEM_WRAP_ADDRESS_SHIFT  4
-#define  MEM_WRAP_ADDRESS_GET(x) (((x) & MEM_WRAP_ADDRESS_MASK) >> MEM_WRAP_ADDRESS_SHIFT)
-#define  MEM_WRAP_CLIENT_NUM_MASK   0x0000000fU
-#define  MEM_WRAP_CLIENT_NUM_SHIFT  0
-#define  MEM_WRAP_CLIENT_NUM_GET(x) (((x) & MEM_WRAP_CLIENT_NUM_MASK) >> MEM_WRAP_CLIENT_NUM_SHIFT)
-#define MA_PCIE_FW 0x30b8
-#define MA_PARITY_ERROR_STATUS 0x77f4
-#define MA_PARITY_ERROR_STATUS2 0x7804
-
-#define EDC_0_BASE_ADDR 0x7900
-
-#define EDC_BIST_CMD 0x7904
-#define EDC_BIST_CMD_ADDR 0x7908
-#define EDC_BIST_CMD_LEN 0x790c
-#define EDC_BIST_DATA_PATTERN 0x7910
-#define EDC_BIST_STATUS_RDATA 0x7928
-#define EDC_INT_CAUSE 0x7978
-#define  ECC_UE_PAR     0x00000020U
-#define  ECC_CE_PAR     0x00000010U
-#define  PERR_PAR_CAUSE 0x00000008U
-
-#define EDC_ECC_STATUS 0x797c
-
-#define EDC_1_BASE_ADDR 0x7980
-
-#define CIM_BOOT_CFG 0x7b00
-#define  BOOTADDR_MASK 0xffffff00U
-#define  UPCRST        0x1U
-
-#define CIM_PF_MAILBOX_DATA 0x240
-#define CIM_PF_MAILBOX_CTRL 0x280
-#define  MBMSGVALID     0x00000008U
-#define  MBINTREQ       0x00000004U
-#define  MBOWNER_MASK   0x00000003U
-#define  MBOWNER_SHIFT  0
-#define  MBOWNER(x)     ((x) << MBOWNER_SHIFT)
-#define  MBOWNER_GET(x) (((x) & MBOWNER_MASK) >> MBOWNER_SHIFT)
-
-#define CIM_PF_HOST_INT_ENABLE 0x288
-#define  MBMSGRDYINTEN(x) ((x) << 19)
-
-#define CIM_PF_HOST_INT_CAUSE 0x28c
-#define  MBMSGRDYINT 0x00080000U
-
-#define CIM_HOST_INT_CAUSE 0x7b2c
-#define  TIEQOUTPARERRINT  0x00100000U
-#define  TIEQINPARERRINT   0x00080000U
-#define  MBHOSTPARERR      0x00040000U
-#define  MBUPPARERR        0x00020000U
-#define  IBQPARERR         0x0001f800U
-#define  IBQTP0PARERR      0x00010000U
-#define  IBQTP1PARERR      0x00008000U
-#define  IBQULPPARERR      0x00004000U
-#define  IBQSGELOPARERR    0x00002000U
-#define  IBQSGEHIPARERR    0x00001000U
-#define  IBQNCSIPARERR     0x00000800U
-#define  OBQPARERR         0x000007e0U
-#define  OBQULP0PARERR     0x00000400U
-#define  OBQULP1PARERR     0x00000200U
-#define  OBQULP2PARERR     0x00000100U
-#define  OBQULP3PARERR     0x00000080U
-#define  OBQSGEPARERR      0x00000040U
-#define  OBQNCSIPARERR     0x00000020U
-#define  PREFDROPINT       0x00000002U
-#define  UPACCNONZERO      0x00000001U
-
-#define CIM_HOST_UPACC_INT_CAUSE 0x7b34
-#define  EEPROMWRINT      0x40000000U
-#define  TIMEOUTMAINT     0x20000000U
-#define  TIMEOUTINT       0x10000000U
-#define  RSPOVRLOOKUPINT  0x08000000U
-#define  REQOVRLOOKUPINT  0x04000000U
-#define  BLKWRPLINT       0x02000000U
-#define  BLKRDPLINT       0x01000000U
-#define  SGLWRPLINT       0x00800000U
-#define  SGLRDPLINT       0x00400000U
-#define  BLKWRCTLINT      0x00200000U
-#define  BLKRDCTLINT      0x00100000U
-#define  SGLWRCTLINT      0x00080000U
-#define  SGLRDCTLINT      0x00040000U
-#define  BLKWREEPROMINT   0x00020000U
-#define  BLKRDEEPROMINT   0x00010000U
-#define  SGLWREEPROMINT   0x00008000U
-#define  SGLRDEEPROMINT   0x00004000U
-#define  BLKWRFLASHINT    0x00002000U
-#define  BLKRDFLASHINT    0x00001000U
-#define  SGLWRFLASHINT    0x00000800U
-#define  SGLRDFLASHINT    0x00000400U
-#define  BLKWRBOOTINT     0x00000200U
-#define  BLKRDBOOTINT     0x00000100U
-#define  SGLWRBOOTINT     0x00000080U
-#define  SGLRDBOOTINT     0x00000040U
-#define  ILLWRBEINT       0x00000020U
-#define  ILLRDBEINT       0x00000010U
-#define  ILLRDINT         0x00000008U
-#define  ILLWRINT         0x00000004U
-#define  ILLTRANSINT      0x00000002U
-#define  RSVDSPACEINT     0x00000001U
-
-#define TP_OUT_CONFIG 0x7d04
-#define  VLANEXTENABLE_MASK  0x0000f000U
-#define  VLANEXTENABLE_SHIFT 12
-
-#define TP_GLOBAL_CONFIG 0x7d08
-#define  FIVETUPLELOOKUP_SHIFT  17
-#define  FIVETUPLELOOKUP_MASK   0x00060000U
-#define  FIVETUPLELOOKUP(x)     ((x) << FIVETUPLELOOKUP_SHIFT)
-#define  FIVETUPLELOOKUP_GET(x) (((x) & FIVETUPLELOOKUP_MASK) >> \
-                                FIVETUPLELOOKUP_SHIFT)
-
-#define TP_PARA_REG2 0x7d68
-#define  MAXRXDATA_MASK    0xffff0000U
-#define  MAXRXDATA_SHIFT   16
-#define  MAXRXDATA_GET(x) (((x) & MAXRXDATA_MASK) >> MAXRXDATA_SHIFT)
-
-#define TP_TIMER_RESOLUTION 0x7d90
-#define  TIMERRESOLUTION_MASK   0x00ff0000U
-#define  TIMERRESOLUTION_SHIFT  16
-#define  TIMERRESOLUTION_GET(x) (((x) & TIMERRESOLUTION_MASK) >> TIMERRESOLUTION_SHIFT)
-#define  DELAYEDACKRESOLUTION_MASK 0x000000ffU
-#define  DELAYEDACKRESOLUTION_SHIFT     0
-#define  DELAYEDACKRESOLUTION_GET(x) \
-        (((x) & DELAYEDACKRESOLUTION_MASK) >> DELAYEDACKRESOLUTION_SHIFT)
-
-#define TP_SHIFT_CNT 0x7dc0
-#define  SYNSHIFTMAX_SHIFT         24
-#define  SYNSHIFTMAX_MASK          0xff000000U
-#define  SYNSHIFTMAX(x)            ((x) << SYNSHIFTMAX_SHIFT)
-#define  SYNSHIFTMAX_GET(x)        (((x) & SYNSHIFTMAX_MASK) >> \
-                                   SYNSHIFTMAX_SHIFT)
-#define  RXTSHIFTMAXR1_SHIFT       20
-#define  RXTSHIFTMAXR1_MASK        0x00f00000U
-#define  RXTSHIFTMAXR1(x)          ((x) << RXTSHIFTMAXR1_SHIFT)
-#define  RXTSHIFTMAXR1_GET(x)      (((x) & RXTSHIFTMAXR1_MASK) >> \
-                                   RXTSHIFTMAXR1_SHIFT)
-#define  RXTSHIFTMAXR2_SHIFT       16
-#define  RXTSHIFTMAXR2_MASK        0x000f0000U
-#define  RXTSHIFTMAXR2(x)          ((x) << RXTSHIFTMAXR2_SHIFT)
-#define  RXTSHIFTMAXR2_GET(x)      (((x) & RXTSHIFTMAXR2_MASK) >> \
-                                   RXTSHIFTMAXR2_SHIFT)
-#define  PERSHIFTBACKOFFMAX_SHIFT  12
-#define  PERSHIFTBACKOFFMAX_MASK   0x0000f000U
-#define  PERSHIFTBACKOFFMAX(x)     ((x) << PERSHIFTBACKOFFMAX_SHIFT)
-#define  PERSHIFTBACKOFFMAX_GET(x) (((x) & PERSHIFTBACKOFFMAX_MASK) >> \
-                                   PERSHIFTBACKOFFMAX_SHIFT)
-#define  PERSHIFTMAX_SHIFT         8
-#define  PERSHIFTMAX_MASK          0x00000f00U
-#define  PERSHIFTMAX(x)            ((x) << PERSHIFTMAX_SHIFT)
-#define  PERSHIFTMAX_GET(x)        (((x) & PERSHIFTMAX_MASK) >> \
-                                   PERSHIFTMAX_SHIFT)
-#define  KEEPALIVEMAXR1_SHIFT      4
-#define  KEEPALIVEMAXR1_MASK       0x000000f0U
-#define  KEEPALIVEMAXR1(x)         ((x) << KEEPALIVEMAXR1_SHIFT)
-#define  KEEPALIVEMAXR1_GET(x)     (((x) & KEEPALIVEMAXR1_MASK) >> \
-                                   KEEPALIVEMAXR1_SHIFT)
-#define KEEPALIVEMAXR2_SHIFT       0
-#define KEEPALIVEMAXR2_MASK        0x0000000fU
-#define KEEPALIVEMAXR2(x)          ((x) << KEEPALIVEMAXR2_SHIFT)
-#define KEEPALIVEMAXR2_GET(x)      (((x) & KEEPALIVEMAXR2_MASK) >> \
-                                   KEEPALIVEMAXR2_SHIFT)
-
-#define TP_CCTRL_TABLE 0x7ddc
-#define TP_MTU_TABLE 0x7de4
-#define  MTUINDEX_MASK   0xff000000U
-#define  MTUINDEX_SHIFT  24
-#define  MTUINDEX(x)     ((x) << MTUINDEX_SHIFT)
-#define  MTUWIDTH_MASK   0x000f0000U
-#define  MTUWIDTH_SHIFT  16
-#define  MTUWIDTH(x)     ((x) << MTUWIDTH_SHIFT)
-#define  MTUWIDTH_GET(x) (((x) & MTUWIDTH_MASK) >> MTUWIDTH_SHIFT)
-#define  MTUVALUE_MASK   0x00003fffU
-#define  MTUVALUE_SHIFT  0
-#define  MTUVALUE(x)     ((x) << MTUVALUE_SHIFT)
-#define  MTUVALUE_GET(x) (((x) & MTUVALUE_MASK) >> MTUVALUE_SHIFT)
-
-#define TP_RSS_LKP_TABLE 0x7dec
-#define  LKPTBLROWVLD        0x80000000U
-#define  LKPTBLQUEUE1_MASK   0x000ffc00U
-#define  LKPTBLQUEUE1_SHIFT  10
-#define  LKPTBLQUEUE1(x)     ((x) << LKPTBLQUEUE1_SHIFT)
-#define  LKPTBLQUEUE1_GET(x) (((x) & LKPTBLQUEUE1_MASK) >> LKPTBLQUEUE1_SHIFT)
-#define  LKPTBLQUEUE0_MASK   0x000003ffU
-#define  LKPTBLQUEUE0_SHIFT  0
-#define  LKPTBLQUEUE0(x)     ((x) << LKPTBLQUEUE0_SHIFT)
-#define  LKPTBLQUEUE0_GET(x) (((x) & LKPTBLQUEUE0_MASK) >> LKPTBLQUEUE0_SHIFT)
-
-#define TP_PIO_ADDR 0x7e40
-#define TP_PIO_DATA 0x7e44
-#define TP_MIB_INDEX 0x7e50
-#define TP_MIB_DATA 0x7e54
-#define TP_INT_CAUSE 0x7e74
-#define  FLMTXFLSTEMPTY 0x40000000U
-
-#define TP_VLAN_PRI_MAP 0x140
-#define  FRAGMENTATION_SHIFT 9
-#define  FRAGMENTATION_MASK  0x00000200U
-#define  MPSHITTYPE_MASK     0x00000100U
-#define  MACMATCH_MASK       0x00000080U
-#define  ETHERTYPE_MASK      0x00000040U
-#define  PROTOCOL_MASK       0x00000020U
-#define  TOS_MASK            0x00000010U
-#define  VLAN_MASK           0x00000008U
-#define  VNIC_ID_MASK        0x00000004U
-#define  PORT_MASK           0x00000002U
-#define  FCOE_SHIFT          0
-#define  FCOE_MASK           0x00000001U
-
-#define TP_INGRESS_CONFIG 0x141
-#define  VNIC                0x00000800U
-#define  CSUM_HAS_PSEUDO_HDR 0x00000400U
-#define  RM_OVLAN            0x00000200U
-#define  LOOKUPEVERYPKT      0x00000100U
-
-#define TP_MIB_MAC_IN_ERR_0 0x0
-#define TP_MIB_TCP_OUT_RST 0xc
-#define TP_MIB_TCP_IN_SEG_HI 0x10
-#define TP_MIB_TCP_IN_SEG_LO 0x11
-#define TP_MIB_TCP_OUT_SEG_HI 0x12
-#define TP_MIB_TCP_OUT_SEG_LO 0x13
-#define TP_MIB_TCP_RXT_SEG_HI 0x14
-#define TP_MIB_TCP_RXT_SEG_LO 0x15
-#define TP_MIB_TNL_CNG_DROP_0 0x18
-#define TP_MIB_TCP_V6IN_ERR_0 0x28
-#define TP_MIB_TCP_V6OUT_RST 0x2c
-#define TP_MIB_OFD_ARP_DROP 0x36
-#define TP_MIB_TNL_DROP_0 0x44
-#define TP_MIB_OFD_VLN_DROP_0 0x58
-
-#define ULP_TX_INT_CAUSE 0x8dcc
-#define  PBL_BOUND_ERR_CH3 0x80000000U
-#define  PBL_BOUND_ERR_CH2 0x40000000U
-#define  PBL_BOUND_ERR_CH1 0x20000000U
-#define  PBL_BOUND_ERR_CH0 0x10000000U
-
-#define PM_RX_INT_CAUSE 0x8fdc
-#define  ZERO_E_CMD_ERROR     0x00400000U
-#define  PMRX_FRAMING_ERROR   0x003ffff0U
-#define  OCSPI_PAR_ERROR      0x00000008U
-#define  DB_OPTIONS_PAR_ERROR 0x00000004U
-#define  IESPI_PAR_ERROR      0x00000002U
-#define  E_PCMD_PAR_ERROR     0x00000001U
-
-#define PM_TX_INT_CAUSE 0x8ffc
-#define  PCMD_LEN_OVFL0     0x80000000U
-#define  PCMD_LEN_OVFL1     0x40000000U
-#define  PCMD_LEN_OVFL2     0x20000000U
-#define  ZERO_C_CMD_ERROR   0x10000000U
-#define  PMTX_FRAMING_ERROR 0x0ffffff0U
-#define  OESPI_PAR_ERROR    0x00000008U
-#define  ICSPI_PAR_ERROR    0x00000002U
-#define  C_PCMD_PAR_ERROR   0x00000001U
+#define MA_INT_CAUSE_A  0x77e0
+
+#define MEM_PERR_INT_CAUSE_S    1
+#define MEM_PERR_INT_CAUSE_V(x) ((x) << MEM_PERR_INT_CAUSE_S)
+#define MEM_PERR_INT_CAUSE_F    MEM_PERR_INT_CAUSE_V(1U)
+
+#define MEM_WRAP_INT_CAUSE_S    0
+#define MEM_WRAP_INT_CAUSE_V(x) ((x) << MEM_WRAP_INT_CAUSE_S)
+#define MEM_WRAP_INT_CAUSE_F    MEM_WRAP_INT_CAUSE_V(1U)
+
+#define MA_INT_WRAP_STATUS_A    0x77e4
+
+#define MEM_WRAP_ADDRESS_S    4
+#define MEM_WRAP_ADDRESS_M    0xfffffffU
+#define MEM_WRAP_ADDRESS_G(x) (((x) >> MEM_WRAP_ADDRESS_S) & MEM_WRAP_ADDRESS_M)
+
+#define MEM_WRAP_CLIENT_NUM_S    0
+#define MEM_WRAP_CLIENT_NUM_M    0xfU
+#define MEM_WRAP_CLIENT_NUM_G(x) \
+        (((x) >> MEM_WRAP_CLIENT_NUM_S) & MEM_WRAP_CLIENT_NUM_M)
+
+#define MA_PARITY_ERROR_STATUS_A        0x77f4
+#define MA_PARITY_ERROR_STATUS1_A       0x77f4
+#define MA_PARITY_ERROR_STATUS2_A       0x7804
+
+/* registers for module EDC_0 */
+#define EDC_0_BASE_ADDR         0x7900
+
+#define EDC_BIST_CMD_A          0x7904
+#define EDC_BIST_CMD_ADDR_A     0x7908
+#define EDC_BIST_CMD_LEN_A      0x790c
+#define EDC_BIST_DATA_PATTERN_A 0x7910
+#define EDC_BIST_STATUS_RDATA_A 0x7928
+#define EDC_INT_CAUSE_A         0x7978
+
+#define ECC_UE_PAR_S    5
+#define ECC_UE_PAR_V(x) ((x) << ECC_UE_PAR_S)
+#define ECC_UE_PAR_F    ECC_UE_PAR_V(1U)
+
+#define ECC_CE_PAR_S    4
+#define ECC_CE_PAR_V(x) ((x) << ECC_CE_PAR_S)
+#define ECC_CE_PAR_F    ECC_CE_PAR_V(1U)
+
+#define PERR_PAR_CAUSE_S    3
+#define PERR_PAR_CAUSE_V(x) ((x) << PERR_PAR_CAUSE_S)
+#define PERR_PAR_CAUSE_F    PERR_PAR_CAUSE_V(1U)
+
+#define EDC_ECC_STATUS_A        0x797c
+
+/* registers for module EDC_1 */
+#define EDC_1_BASE_ADDR 0x7980
+
+/* registers for module CIM */
+#define CIM_BOOT_CFG_A 0x7b00
+#define CIM_PF_MAILBOX_CTRL_SHADOW_COPY_A 0x290
+
+#define  BOOTADDR_M     0xffffff00U
+
+#define UPCRST_S    0
+#define UPCRST_V(x) ((x) << UPCRST_S)
+#define UPCRST_F    UPCRST_V(1U)
+
+#define CIM_PF_MAILBOX_DATA_A 0x240
+#define CIM_PF_MAILBOX_CTRL_A 0x280
+
+#define MBMSGVALID_S    3
+#define MBMSGVALID_V(x) ((x) << MBMSGVALID_S)
+#define MBMSGVALID_F    MBMSGVALID_V(1U)
+
+#define MBINTREQ_S    2
+#define MBINTREQ_V(x) ((x) << MBINTREQ_S)
+#define MBINTREQ_F    MBINTREQ_V(1U)
+
+#define MBOWNER_S    0
+#define MBOWNER_M    0x3U
+#define MBOWNER_V(x) ((x) << MBOWNER_S)
+#define MBOWNER_G(x) (((x) >> MBOWNER_S) & MBOWNER_M)
+
+#define CIM_PF_HOST_INT_ENABLE_A 0x288
+
+#define MBMSGRDYINTEN_S    19
+#define MBMSGRDYINTEN_V(x) ((x) << MBMSGRDYINTEN_S)
+#define MBMSGRDYINTEN_F    MBMSGRDYINTEN_V(1U)
+
+#define CIM_PF_HOST_INT_CAUSE_A 0x28c
+
+#define MBMSGRDYINT_S    19
+#define MBMSGRDYINT_V(x) ((x) << MBMSGRDYINT_S)
+#define MBMSGRDYINT_F    MBMSGRDYINT_V(1U)
+
+#define CIM_HOST_INT_CAUSE_A 0x7b2c
+
+#define TIEQOUTPARERRINT_S    20
+#define TIEQOUTPARERRINT_V(x) ((x) << TIEQOUTPARERRINT_S)
+#define TIEQOUTPARERRINT_F    TIEQOUTPARERRINT_V(1U)
+
+#define TIEQINPARERRINT_S    19
+#define TIEQINPARERRINT_V(x) ((x) << TIEQINPARERRINT_S)
+#define TIEQINPARERRINT_F    TIEQINPARERRINT_V(1U)
+
+#define PREFDROPINT_S    1
+#define PREFDROPINT_V(x) ((x) << PREFDROPINT_S)
+#define PREFDROPINT_F    PREFDROPINT_V(1U)
+
+#define UPACCNONZERO_S    0
+#define UPACCNONZERO_V(x) ((x) << UPACCNONZERO_S)
+#define UPACCNONZERO_F    UPACCNONZERO_V(1U)
+
+#define MBHOSTPARERR_S    18
+#define MBHOSTPARERR_V(x) ((x) << MBHOSTPARERR_S)
+#define MBHOSTPARERR_F    MBHOSTPARERR_V(1U)
+
+#define MBUPPARERR_S    17
+#define MBUPPARERR_V(x) ((x) << MBUPPARERR_S)
+#define MBUPPARERR_F    MBUPPARERR_V(1U)
+
+#define IBQTP0PARERR_S    16
+#define IBQTP0PARERR_V(x) ((x) << IBQTP0PARERR_S)
+#define IBQTP0PARERR_F    IBQTP0PARERR_V(1U)
+
+#define IBQTP1PARERR_S    15
+#define IBQTP1PARERR_V(x) ((x) << IBQTP1PARERR_S)
+#define IBQTP1PARERR_F    IBQTP1PARERR_V(1U)
+
+#define IBQULPPARERR_S    14
+#define IBQULPPARERR_V(x) ((x) << IBQULPPARERR_S)
+#define IBQULPPARERR_F    IBQULPPARERR_V(1U)
+
+#define IBQSGELOPARERR_S    13
+#define IBQSGELOPARERR_V(x) ((x) << IBQSGELOPARERR_S)
+#define IBQSGELOPARERR_F    IBQSGELOPARERR_V(1U)
+
+#define IBQSGEHIPARERR_S    12
+#define IBQSGEHIPARERR_V(x) ((x) << IBQSGEHIPARERR_S)
+#define IBQSGEHIPARERR_F    IBQSGEHIPARERR_V(1U)
+
+#define IBQNCSIPARERR_S    11
+#define IBQNCSIPARERR_V(x) ((x) << IBQNCSIPARERR_S)
+#define IBQNCSIPARERR_F    IBQNCSIPARERR_V(1U)
+
+#define OBQULP0PARERR_S    10
+#define OBQULP0PARERR_V(x) ((x) << OBQULP0PARERR_S)
+#define OBQULP0PARERR_F    OBQULP0PARERR_V(1U)
+
+#define OBQULP1PARERR_S    9
+#define OBQULP1PARERR_V(x) ((x) << OBQULP1PARERR_S)
+#define OBQULP1PARERR_F    OBQULP1PARERR_V(1U)
+
+#define OBQULP2PARERR_S    8
+#define OBQULP2PARERR_V(x) ((x) << OBQULP2PARERR_S)
+#define OBQULP2PARERR_F    OBQULP2PARERR_V(1U)
+
+#define OBQULP3PARERR_S    7
+#define OBQULP3PARERR_V(x) ((x) << OBQULP3PARERR_S)
+#define OBQULP3PARERR_F    OBQULP3PARERR_V(1U)
+
+#define OBQSGEPARERR_S    6
+#define OBQSGEPARERR_V(x) ((x) << OBQSGEPARERR_S)
+#define OBQSGEPARERR_F    OBQSGEPARERR_V(1U)
+
+#define OBQNCSIPARERR_S    5
+#define OBQNCSIPARERR_V(x) ((x) << OBQNCSIPARERR_S)
+#define OBQNCSIPARERR_F    OBQNCSIPARERR_V(1U)
+
+#define CIM_HOST_UPACC_INT_CAUSE_A 0x7b34
+
+#define EEPROMWRINT_S    30
+#define EEPROMWRINT_V(x) ((x) << EEPROMWRINT_S)
+#define EEPROMWRINT_F    EEPROMWRINT_V(1U)
+
+#define TIMEOUTMAINT_S    29
+#define TIMEOUTMAINT_V(x) ((x) << TIMEOUTMAINT_S)
+#define TIMEOUTMAINT_F    TIMEOUTMAINT_V(1U)
+
+#define TIMEOUTINT_S    28
+#define TIMEOUTINT_V(x) ((x) << TIMEOUTINT_S)
+#define TIMEOUTINT_F    TIMEOUTINT_V(1U)
+
+#define RSPOVRLOOKUPINT_S    27
+#define RSPOVRLOOKUPINT_V(x) ((x) << RSPOVRLOOKUPINT_S)
+#define RSPOVRLOOKUPINT_F    RSPOVRLOOKUPINT_V(1U)
+
+#define REQOVRLOOKUPINT_S    26
+#define REQOVRLOOKUPINT_V(x) ((x) << REQOVRLOOKUPINT_S)
+#define REQOVRLOOKUPINT_F    REQOVRLOOKUPINT_V(1U)
+
+#define BLKWRPLINT_S    25
+#define BLKWRPLINT_V(x) ((x) << BLKWRPLINT_S)
+#define BLKWRPLINT_F    BLKWRPLINT_V(1U)
+
+#define BLKRDPLINT_S    24
+#define BLKRDPLINT_V(x) ((x) << BLKRDPLINT_S)
+#define BLKRDPLINT_F    BLKRDPLINT_V(1U)
+
+#define SGLWRPLINT_S    23
+#define SGLWRPLINT_V(x) ((x) << SGLWRPLINT_S)
+#define SGLWRPLINT_F    SGLWRPLINT_V(1U)
+
+#define SGLRDPLINT_S    22
+#define SGLRDPLINT_V(x) ((x) << SGLRDPLINT_S)
+#define SGLRDPLINT_F    SGLRDPLINT_V(1U)
+
+#define BLKWRCTLINT_S    21
+#define BLKWRCTLINT_V(x) ((x) << BLKWRCTLINT_S)
+#define BLKWRCTLINT_F    BLKWRCTLINT_V(1U)
+
+#define BLKRDCTLINT_S    20
+#define BLKRDCTLINT_V(x) ((x) << BLKRDCTLINT_S)
+#define BLKRDCTLINT_F    BLKRDCTLINT_V(1U)
+
+#define SGLWRCTLINT_S    19
+#define SGLWRCTLINT_V(x) ((x) << SGLWRCTLINT_S)
+#define SGLWRCTLINT_F    SGLWRCTLINT_V(1U)
+
+#define SGLRDCTLINT_S    18
+#define SGLRDCTLINT_V(x) ((x) << SGLRDCTLINT_S)
+#define SGLRDCTLINT_F    SGLRDCTLINT_V(1U)
+
+#define BLKWREEPROMINT_S    17
+#define BLKWREEPROMINT_V(x) ((x) << BLKWREEPROMINT_S)
+#define BLKWREEPROMINT_F    BLKWREEPROMINT_V(1U)
+
+#define BLKRDEEPROMINT_S    16
+#define BLKRDEEPROMINT_V(x) ((x) << BLKRDEEPROMINT_S)
+#define BLKRDEEPROMINT_F    BLKRDEEPROMINT_V(1U)
+
+#define SGLWREEPROMINT_S    15
+#define SGLWREEPROMINT_V(x) ((x) << SGLWREEPROMINT_S)
+#define SGLWREEPROMINT_F    SGLWREEPROMINT_V(1U)
+
+#define SGLRDEEPROMINT_S    14
+#define SGLRDEEPROMINT_V(x) ((x) << SGLRDEEPROMINT_S)
+#define SGLRDEEPROMINT_F    SGLRDEEPROMINT_V(1U)
+
+#define BLKWRFLASHINT_S    13
+#define BLKWRFLASHINT_V(x) ((x) << BLKWRFLASHINT_S)
+#define BLKWRFLASHINT_F    BLKWRFLASHINT_V(1U)
+
+#define BLKRDFLASHINT_S    12
+#define BLKRDFLASHINT_V(x) ((x) << BLKRDFLASHINT_S)
+#define BLKRDFLASHINT_F    BLKRDFLASHINT_V(1U)
+
+#define SGLWRFLASHINT_S    11
+#define SGLWRFLASHINT_V(x) ((x) << SGLWRFLASHINT_S)
+#define SGLWRFLASHINT_F    SGLWRFLASHINT_V(1U)
+
+#define SGLRDFLASHINT_S    10
+#define SGLRDFLASHINT_V(x) ((x) << SGLRDFLASHINT_S)
+#define SGLRDFLASHINT_F    SGLRDFLASHINT_V(1U)
+
+#define BLKWRBOOTINT_S    9
+#define BLKWRBOOTINT_V(x) ((x) << BLKWRBOOTINT_S)
+#define BLKWRBOOTINT_F    BLKWRBOOTINT_V(1U)
+
+#define BLKRDBOOTINT_S    8
+#define BLKRDBOOTINT_V(x) ((x) << BLKRDBOOTINT_S)
+#define BLKRDBOOTINT_F    BLKRDBOOTINT_V(1U)
+
+#define SGLWRBOOTINT_S    7
+#define SGLWRBOOTINT_V(x) ((x) << SGLWRBOOTINT_S)
+#define SGLWRBOOTINT_F    SGLWRBOOTINT_V(1U)
+
+#define SGLRDBOOTINT_S    6
+#define SGLRDBOOTINT_V(x) ((x) << SGLRDBOOTINT_S)
+#define SGLRDBOOTINT_F    SGLRDBOOTINT_V(1U)
+
+#define ILLWRBEINT_S    5
+#define ILLWRBEINT_V(x) ((x) << ILLWRBEINT_S)
+#define ILLWRBEINT_F    ILLWRBEINT_V(1U)
+
+#define ILLRDBEINT_S    4
+#define ILLRDBEINT_V(x) ((x) << ILLRDBEINT_S)
+#define ILLRDBEINT_F    ILLRDBEINT_V(1U)
+
+#define ILLRDINT_S    3
+#define ILLRDINT_V(x) ((x) << ILLRDINT_S)
+#define ILLRDINT_F    ILLRDINT_V(1U)
+
+#define ILLWRINT_S    2
+#define ILLWRINT_V(x) ((x) << ILLWRINT_S)
+#define ILLWRINT_F    ILLWRINT_V(1U)
+
+#define ILLTRANSINT_S    1
+#define ILLTRANSINT_V(x) ((x) << ILLTRANSINT_S)
+#define ILLTRANSINT_F    ILLTRANSINT_V(1U)
+
+#define RSVDSPACEINT_S    0
+#define RSVDSPACEINT_V(x) ((x) << RSVDSPACEINT_S)
+#define RSVDSPACEINT_F    RSVDSPACEINT_V(1U)
+
+/* registers for module TP */
+#define DBGLAWHLF_S    23
+#define DBGLAWHLF_V(x) ((x) << DBGLAWHLF_S)
+#define DBGLAWHLF_F    DBGLAWHLF_V(1U)
+
+#define DBGLAWPTR_S    16
+#define DBGLAWPTR_M    0x7fU
+#define DBGLAWPTR_G(x) (((x) >> DBGLAWPTR_S) & DBGLAWPTR_M)
+
+#define DBGLAENABLE_S    12
+#define DBGLAENABLE_V(x) ((x) << DBGLAENABLE_S)
+#define DBGLAENABLE_F    DBGLAENABLE_V(1U)
+
+#define DBGLARPTR_S    0
+#define DBGLARPTR_M    0x7fU
+#define DBGLARPTR_V(x) ((x) << DBGLARPTR_S)
+
+#define TP_DBG_LA_DATAL_A       0x7ed8
+#define TP_DBG_LA_CONFIG_A      0x7ed4
+#define TP_OUT_CONFIG_A         0x7d04
+#define TP_GLOBAL_CONFIG_A      0x7d08
+
+#define DBGLAMODE_S     14
+#define DBGLAMODE_M     0x3U
+#define DBGLAMODE_G(x)  (((x) >> DBGLAMODE_S) & DBGLAMODE_M)
+
+#define FIVETUPLELOOKUP_S    17
+#define FIVETUPLELOOKUP_M    0x3U
+#define FIVETUPLELOOKUP_V(x) ((x) << FIVETUPLELOOKUP_S)
+#define FIVETUPLELOOKUP_G(x) (((x) >> FIVETUPLELOOKUP_S) & FIVETUPLELOOKUP_M)
+
+#define TP_PARA_REG2_A 0x7d68
+
+#define MAXRXDATA_S    16
+#define MAXRXDATA_M    0xffffU
+#define MAXRXDATA_G(x) (((x) >> MAXRXDATA_S) & MAXRXDATA_M)
+
+#define TP_TIMER_RESOLUTION_A 0x7d90
+
+#define TIMERRESOLUTION_S    16
+#define TIMERRESOLUTION_M    0xffU
+#define TIMERRESOLUTION_G(x) (((x) >> TIMERRESOLUTION_S) & TIMERRESOLUTION_M)
+
+#define TIMESTAMPRESOLUTION_S    8
+#define TIMESTAMPRESOLUTION_M    0xffU
+#define TIMESTAMPRESOLUTION_G(x) \
+        (((x) >> TIMESTAMPRESOLUTION_S) & TIMESTAMPRESOLUTION_M)
+
+#define DELAYEDACKRESOLUTION_S    0
+#define DELAYEDACKRESOLUTION_M    0xffU
+#define DELAYEDACKRESOLUTION_G(x) \
+        (((x) >> DELAYEDACKRESOLUTION_S) & DELAYEDACKRESOLUTION_M)
+
+#define TP_SHIFT_CNT_A 0x7dc0
+#define TP_RXT_MIN_A 0x7d98
+#define TP_RXT_MAX_A 0x7d9c
+#define TP_PERS_MIN_A 0x7da0
+#define TP_PERS_MAX_A 0x7da4
+#define TP_KEEP_IDLE_A 0x7da8
+#define TP_KEEP_INTVL_A 0x7dac
+#define TP_INIT_SRTT_A 0x7db0
+#define TP_DACK_TIMER_A 0x7db4
+#define TP_FINWAIT2_TIMER_A 0x7db8
+
+#define INITSRTT_S    0
+#define INITSRTT_M    0xffffU
+#define INITSRTT_G(x) (((x) >> INITSRTT_S) & INITSRTT_M)
+
+#define PERSMAX_S    0
+#define PERSMAX_M    0x3fffffffU
+#define PERSMAX_V(x) ((x) << PERSMAX_S)
+#define PERSMAX_G(x) (((x) >> PERSMAX_S) & PERSMAX_M)
+
+#define SYNSHIFTMAX_S    24
+#define SYNSHIFTMAX_M    0xffU
+#define SYNSHIFTMAX_V(x) ((x) << SYNSHIFTMAX_S)
+#define SYNSHIFTMAX_G(x) (((x) >> SYNSHIFTMAX_S) & SYNSHIFTMAX_M)
+
+#define RXTSHIFTMAXR1_S    20
+#define RXTSHIFTMAXR1_M    0xfU
+#define RXTSHIFTMAXR1_V(x) ((x) << RXTSHIFTMAXR1_S)
+#define RXTSHIFTMAXR1_G(x) (((x) >> RXTSHIFTMAXR1_S) & RXTSHIFTMAXR1_M)
+
+#define RXTSHIFTMAXR2_S    16
+#define RXTSHIFTMAXR2_M    0xfU
+#define RXTSHIFTMAXR2_V(x) ((x) << RXTSHIFTMAXR2_S)
+#define RXTSHIFTMAXR2_G(x) (((x) >> RXTSHIFTMAXR2_S) & RXTSHIFTMAXR2_M)
+
+#define PERSHIFTBACKOFFMAX_S    12
+#define PERSHIFTBACKOFFMAX_M    0xfU
+#define PERSHIFTBACKOFFMAX_V(x) ((x) << PERSHIFTBACKOFFMAX_S)
+#define PERSHIFTBACKOFFMAX_G(x) \
+        (((x) >> PERSHIFTBACKOFFMAX_S) & PERSHIFTBACKOFFMAX_M)
+
+#define PERSHIFTMAX_S    8
+#define PERSHIFTMAX_M    0xfU
+#define PERSHIFTMAX_V(x) ((x) << PERSHIFTMAX_S)
+#define PERSHIFTMAX_G(x) (((x) >> PERSHIFTMAX_S) & PERSHIFTMAX_M)
+
+#define KEEPALIVEMAXR1_S    4
+#define KEEPALIVEMAXR1_M    0xfU
+#define KEEPALIVEMAXR1_V(x) ((x) << KEEPALIVEMAXR1_S)
+#define KEEPALIVEMAXR1_G(x) (((x) >> KEEPALIVEMAXR1_S) & KEEPALIVEMAXR1_M)
+
+#define KEEPALIVEMAXR2_S    0
+#define KEEPALIVEMAXR2_M    0xfU
+#define KEEPALIVEMAXR2_V(x) ((x) << KEEPALIVEMAXR2_S)
+#define KEEPALIVEMAXR2_G(x) (((x) >> KEEPALIVEMAXR2_S) & KEEPALIVEMAXR2_M)
+
+#define ROWINDEX_S    16
+#define ROWINDEX_V(x) ((x) << ROWINDEX_S)
+
+#define TP_CCTRL_TABLE_A        0x7ddc
+#define TP_MTU_TABLE_A          0x7de4
+
+#define MTUINDEX_S    24
+#define MTUINDEX_V(x) ((x) << MTUINDEX_S)
+
+#define MTUWIDTH_S    16
+#define MTUWIDTH_M    0xfU
+#define MTUWIDTH_V(x) ((x) << MTUWIDTH_S)
+#define MTUWIDTH_G(x) (((x) >> MTUWIDTH_S) & MTUWIDTH_M)
+
+#define MTUVALUE_S    0
+#define MTUVALUE_M    0x3fffU
+#define MTUVALUE_V(x) ((x) << MTUVALUE_S)
+#define MTUVALUE_G(x) (((x) >> MTUVALUE_S) & MTUVALUE_M)
+
+#define TP_RSS_LKP_TABLE_A      0x7dec
+
+#define LKPTBLROWVLD_S    31
+#define LKPTBLROWVLD_V(x) ((x) << LKPTBLROWVLD_S)
+#define LKPTBLROWVLD_F    LKPTBLROWVLD_V(1U)
+
+#define LKPTBLQUEUE1_S    10
+#define LKPTBLQUEUE1_M    0x3ffU
+#define LKPTBLQUEUE1_G(x) (((x) >> LKPTBLQUEUE1_S) & LKPTBLQUEUE1_M)
+
+#define LKPTBLQUEUE0_S    0
+#define LKPTBLQUEUE0_M    0x3ffU
+#define LKPTBLQUEUE0_G(x) (((x) >> LKPTBLQUEUE0_S) & LKPTBLQUEUE0_M)
+
+#define TP_PIO_ADDR_A   0x7e40
+#define TP_PIO_DATA_A   0x7e44
+#define TP_MIB_INDEX_A  0x7e50
+#define TP_MIB_DATA_A   0x7e54
+#define TP_INT_CAUSE_A  0x7e74
+
+#define FLMTXFLSTEMPTY_S    30
+#define FLMTXFLSTEMPTY_V(x) ((x) << FLMTXFLSTEMPTY_S)
+#define FLMTXFLSTEMPTY_F    FLMTXFLSTEMPTY_V(1U)
+
+#define TP_VLAN_PRI_MAP_A 0x140
+
+#define FRAGMENTATION_S    9
+#define FRAGMENTATION_V(x) ((x) << FRAGMENTATION_S)
+#define FRAGMENTATION_F    FRAGMENTATION_V(1U)
+
+#define MPSHITTYPE_S    8
+#define MPSHITTYPE_V(x) ((x) << MPSHITTYPE_S)
+#define MPSHITTYPE_F    MPSHITTYPE_V(1U)
+
+#define MACMATCH_S    7
+#define MACMATCH_V(x) ((x) << MACMATCH_S)
+#define MACMATCH_F    MACMATCH_V(1U)
+
+#define ETHERTYPE_S    6
+#define ETHERTYPE_V(x) ((x) << ETHERTYPE_S)
+#define ETHERTYPE_F    ETHERTYPE_V(1U)
+
+#define PROTOCOL_S    5
+#define PROTOCOL_V(x) ((x) << PROTOCOL_S)
+#define PROTOCOL_F    PROTOCOL_V(1U)
+
+#define TOS_S    4
+#define TOS_V(x) ((x) << TOS_S)
+#define TOS_F    TOS_V(1U)
+
+#define VLAN_S    3
+#define VLAN_V(x) ((x) << VLAN_S)
+#define VLAN_F    VLAN_V(1U)
+
+#define VNIC_ID_S    2
+#define VNIC_ID_V(x) ((x) << VNIC_ID_S)
+#define VNIC_ID_F    VNIC_ID_V(1U)
+
+#define PORT_S    1
+#define PORT_V(x) ((x) << PORT_S)
+#define PORT_F    PORT_V(1U)
+
+#define FCOE_S    0
+#define FCOE_V(x) ((x) << FCOE_S)
+#define FCOE_F    FCOE_V(1U)
+
+#define FILTERMODE_S    15
+#define FILTERMODE_V(x) ((x) << FILTERMODE_S)
+#define FILTERMODE_F    FILTERMODE_V(1U)
+
+#define FCOEMASK_S    14
+#define FCOEMASK_V(x) ((x) << FCOEMASK_S)
+#define FCOEMASK_F    FCOEMASK_V(1U)
+
+#define TP_INGRESS_CONFIG_A     0x141
+
+#define VNIC_S    11
+#define VNIC_V(x) ((x) << VNIC_S)
+#define VNIC_F    VNIC_V(1U)
+
+#define CSUM_HAS_PSEUDO_HDR_S    10
+#define CSUM_HAS_PSEUDO_HDR_V(x) ((x) << CSUM_HAS_PSEUDO_HDR_S)
+#define CSUM_HAS_PSEUDO_HDR_F    CSUM_HAS_PSEUDO_HDR_V(1U)
+
+#define TP_MIB_MAC_IN_ERR_0_A   0x0
+#define TP_MIB_TCP_OUT_RST_A    0xc
+#define TP_MIB_TCP_IN_SEG_HI_A  0x10
+#define TP_MIB_TCP_IN_SEG_LO_A  0x11
+#define TP_MIB_TCP_OUT_SEG_HI_A 0x12
+#define TP_MIB_TCP_OUT_SEG_LO_A 0x13
+#define TP_MIB_TCP_RXT_SEG_HI_A 0x14
+#define TP_MIB_TCP_RXT_SEG_LO_A 0x15
+#define TP_MIB_TNL_CNG_DROP_0_A 0x18
+#define TP_MIB_TCP_V6IN_ERR_0_A 0x28
+#define TP_MIB_TCP_V6OUT_RST_A  0x2c
+#define TP_MIB_OFD_ARP_DROP_A   0x36
+#define TP_MIB_TNL_DROP_0_A     0x44
+#define TP_MIB_OFD_VLN_DROP_0_A 0x58
+
+#define ULP_TX_INT_CAUSE_A      0x8dcc
+
+#define PBL_BOUND_ERR_CH3_S    31
+#define PBL_BOUND_ERR_CH3_V(x) ((x) << PBL_BOUND_ERR_CH3_S)
+#define PBL_BOUND_ERR_CH3_F    PBL_BOUND_ERR_CH3_V(1U)
+
+#define PBL_BOUND_ERR_CH2_S    30
+#define PBL_BOUND_ERR_CH2_V(x) ((x) << PBL_BOUND_ERR_CH2_S)
+#define PBL_BOUND_ERR_CH2_F    PBL_BOUND_ERR_CH2_V(1U)
+
+#define PBL_BOUND_ERR_CH1_S    29
+#define PBL_BOUND_ERR_CH1_V(x) ((x) << PBL_BOUND_ERR_CH1_S)
+#define PBL_BOUND_ERR_CH1_F    PBL_BOUND_ERR_CH1_V(1U)
+
+#define PBL_BOUND_ERR_CH0_S    28
+#define PBL_BOUND_ERR_CH0_V(x) ((x) << PBL_BOUND_ERR_CH0_S)
+#define PBL_BOUND_ERR_CH0_F    PBL_BOUND_ERR_CH0_V(1U)
+
+#define PM_RX_INT_CAUSE_A       0x8fdc
+#define PM_RX_STAT_CONFIG_A 0x8fc8
+#define PM_RX_STAT_COUNT_A 0x8fcc
+#define PM_RX_STAT_LSB_A 0x8fd0
+#define PM_RX_DBG_CTRL_A 0x8fd0
+#define PM_RX_DBG_DATA_A 0x8fd4
+#define PM_RX_DBG_STAT_MSB_A 0x10013
+
+#define PMRX_FRAMING_ERROR_F    0x003ffff0U
+
+#define ZERO_E_CMD_ERROR_S    22
+#define ZERO_E_CMD_ERROR_V(x) ((x) << ZERO_E_CMD_ERROR_S)
+#define ZERO_E_CMD_ERROR_F    ZERO_E_CMD_ERROR_V(1U)
+
+#define OCSPI_PAR_ERROR_S    3
+#define OCSPI_PAR_ERROR_V(x) ((x) << OCSPI_PAR_ERROR_S)
+#define OCSPI_PAR_ERROR_F    OCSPI_PAR_ERROR_V(1U)
+
+#define DB_OPTIONS_PAR_ERROR_S    2
+#define DB_OPTIONS_PAR_ERROR_V(x) ((x) << DB_OPTIONS_PAR_ERROR_S)
+#define DB_OPTIONS_PAR_ERROR_F    DB_OPTIONS_PAR_ERROR_V(1U)
+
+#define IESPI_PAR_ERROR_S    1
+#define IESPI_PAR_ERROR_V(x) ((x) << IESPI_PAR_ERROR_S)
+#define IESPI_PAR_ERROR_F    IESPI_PAR_ERROR_V(1U)
+
+#define PMRX_E_PCMD_PAR_ERROR_S    0
+#define PMRX_E_PCMD_PAR_ERROR_V(x) ((x) << PMRX_E_PCMD_PAR_ERROR_S)
+#define PMRX_E_PCMD_PAR_ERROR_F    PMRX_E_PCMD_PAR_ERROR_V(1U)
+
+#define PM_TX_INT_CAUSE_A       0x8ffc
+#define PM_TX_STAT_CONFIG_A 0x8fe8
+#define PM_TX_STAT_COUNT_A 0x8fec
+#define PM_TX_STAT_LSB_A 0x8ff0
+#define PM_TX_DBG_CTRL_A 0x8ff0
+#define PM_TX_DBG_DATA_A 0x8ff4
+#define PM_TX_DBG_STAT_MSB_A 0x1001a
+
+#define PCMD_LEN_OVFL0_S    31
+#define PCMD_LEN_OVFL0_V(x) ((x) << PCMD_LEN_OVFL0_S)
+#define PCMD_LEN_OVFL0_F    PCMD_LEN_OVFL0_V(1U)
+
+#define PCMD_LEN_OVFL1_S    30
+#define PCMD_LEN_OVFL1_V(x) ((x) << PCMD_LEN_OVFL1_S)
+#define PCMD_LEN_OVFL1_F    PCMD_LEN_OVFL1_V(1U)
+
+#define PCMD_LEN_OVFL2_S    29
+#define PCMD_LEN_OVFL2_V(x) ((x) << PCMD_LEN_OVFL2_S)
+#define PCMD_LEN_OVFL2_F    PCMD_LEN_OVFL2_V(1U)
+
+#define ZERO_C_CMD_ERROR_S    28
+#define ZERO_C_CMD_ERROR_V(x) ((x) << ZERO_C_CMD_ERROR_S)
+#define ZERO_C_CMD_ERROR_F    ZERO_C_CMD_ERROR_V(1U)
+
+#define  PMTX_FRAMING_ERROR_F 0x0ffffff0U
+
+#define OESPI_PAR_ERROR_S    3
+#define OESPI_PAR_ERROR_V(x) ((x) << OESPI_PAR_ERROR_S)
+#define OESPI_PAR_ERROR_F    OESPI_PAR_ERROR_V(1U)
+
+#define ICSPI_PAR_ERROR_S    1
+#define ICSPI_PAR_ERROR_V(x) ((x) << ICSPI_PAR_ERROR_S)
+#define ICSPI_PAR_ERROR_F    ICSPI_PAR_ERROR_V(1U)
+
+#define PMTX_C_PCMD_PAR_ERROR_S    0
+#define PMTX_C_PCMD_PAR_ERROR_V(x) ((x) << PMTX_C_PCMD_PAR_ERROR_S)
+#define PMTX_C_PCMD_PAR_ERROR_F    PMTX_C_PCMD_PAR_ERROR_V(1U)
 
 #define MPS_PORT_STAT_TX_PORT_BYTES_L 0x400
 #define MPS_PORT_STAT_TX_PORT_BYTES_H 0x404
@@ -959,41 +1623,57 @@
 #define MPS_PORT_STAT_RX_PORT_PPP7_H 0x60c
 #define MPS_PORT_STAT_RX_PORT_LESS_64B_L 0x610
 #define MPS_PORT_STAT_RX_PORT_LESS_64B_H 0x614
-#define MAC_PORT_CFG2 0x818
 #define MAC_PORT_MAGIC_MACID_LO 0x824
 #define MAC_PORT_MAGIC_MACID_HI 0x828
-#define MAC_PORT_EPIO_DATA0 0x8c0
-#define MAC_PORT_EPIO_DATA1 0x8c4
-#define MAC_PORT_EPIO_DATA2 0x8c8
-#define MAC_PORT_EPIO_DATA3 0x8cc
-#define MAC_PORT_EPIO_OP 0x8d0
-
-#define MPS_CMN_CTL 0x9000
-#define  NUMPORTS_MASK   0x00000003U
-#define  NUMPORTS_SHIFT  0
-#define  NUMPORTS_GET(x) (((x) & NUMPORTS_MASK) >> NUMPORTS_SHIFT)
-
-#define MPS_INT_CAUSE 0x9008
-#define  STATINT 0x00000020U
-#define  TXINT   0x00000010U
-#define  RXINT   0x00000008U
-#define  TRCINT  0x00000004U
-#define  CLSINT  0x00000002U
-#define  PLINT   0x00000001U
-
-#define MPS_TX_INT_CAUSE 0x9408
-#define  PORTERR    0x00010000U
-#define  FRMERR     0x00008000U
-#define  SECNTERR   0x00004000U
-#define  BUBBLE     0x00002000U
-#define  TXDESCFIFO 0x00001e00U
-#define  TXDATAFIFO 0x000001e0U
-#define  NCSIFIFO   0x00000010U
-#define  TPFIFO     0x0000000fU
-
-#define MPS_STAT_PERR_INT_CAUSE_SRAM 0x9614
-#define MPS_STAT_PERR_INT_CAUSE_TX_FIFO 0x9620
-#define MPS_STAT_PERR_INT_CAUSE_RX_FIFO 0x962c
+
+#define MAC_PORT_EPIO_DATA0_A 0x8c0
+#define MAC_PORT_EPIO_DATA1_A 0x8c4
+#define MAC_PORT_EPIO_DATA2_A 0x8c8
+#define MAC_PORT_EPIO_DATA3_A 0x8cc
+#define MAC_PORT_EPIO_OP_A 0x8d0
+
+#define MAC_PORT_CFG2_A 0x818
+
+#define MPS_CMN_CTL_A   0x9000
+
+#define NUMPORTS_S    0
+#define NUMPORTS_M    0x3U
+#define NUMPORTS_G(x) (((x) >> NUMPORTS_S) & NUMPORTS_M)
+
+#define MPS_INT_CAUSE_A 0x9008
+#define MPS_TX_INT_CAUSE_A 0x9408
+
+#define FRMERR_S    15
+#define FRMERR_V(x) ((x) << FRMERR_S)
+#define FRMERR_F    FRMERR_V(1U)
+
+#define SECNTERR_S    14
+#define SECNTERR_V(x) ((x) << SECNTERR_S)
+#define SECNTERR_F    SECNTERR_V(1U)
+
+#define BUBBLE_S    13
+#define BUBBLE_V(x) ((x) << BUBBLE_S)
+#define BUBBLE_F    BUBBLE_V(1U)
+
+#define TXDESCFIFO_S    9
+#define TXDESCFIFO_M    0xfU
+#define TXDESCFIFO_V(x) ((x) << TXDESCFIFO_S)
+
+#define TXDATAFIFO_S    5
+#define TXDATAFIFO_M    0xfU
+#define TXDATAFIFO_V(x) ((x) << TXDATAFIFO_S)
+
+#define NCSIFIFO_S    4
+#define NCSIFIFO_V(x) ((x) << NCSIFIFO_S)
+#define NCSIFIFO_F    NCSIFIFO_V(1U)
+
+#define TPFIFO_S    0
+#define TPFIFO_M    0xfU
+#define TPFIFO_V(x) ((x) << TPFIFO_S)
+
+#define MPS_STAT_PERR_INT_CAUSE_SRAM_A          0x9614
+#define MPS_STAT_PERR_INT_CAUSE_TX_FIFO_A       0x9620
+#define MPS_STAT_PERR_INT_CAUSE_RX_FIFO_A       0x962c
 
 #define MPS_STAT_RX_BG_0_MAC_DROP_FRAME_L 0x9640
 #define MPS_STAT_RX_BG_0_MAC_DROP_FRAME_H 0x9644
@@ -1027,294 +1707,851 @@
 #define MPS_STAT_RX_BG_2_LB_TRUNC_FRAME_H 0x96b4
 #define MPS_STAT_RX_BG_3_LB_TRUNC_FRAME_L 0x96b8
 #define MPS_STAT_RX_BG_3_LB_TRUNC_FRAME_H 0x96bc
-#define MPS_TRC_CFG 0x9800
-#define  TRCFIFOEMPTY       0x00000010U
-#define  TRCIGNOREDROPINPUT 0x00000008U
-#define  TRCKEEPDUPLICATES  0x00000004U
-#define  TRCEN              0x00000002U
-#define  TRCMULTIFILTER     0x00000001U
-
-#define MPS_TRC_RSS_CONTROL 0x9808
-#define MPS_T5_TRC_RSS_CONTROL 0xa00c
-#define  RSSCONTROL_MASK    0x00ff0000U
-#define  RSSCONTROL_SHIFT   16
-#define  RSSCONTROL(x)      ((x) << RSSCONTROL_SHIFT)
-#define  QUEUENUMBER_MASK   0x0000ffffU
-#define  QUEUENUMBER_SHIFT  0
-#define  QUEUENUMBER(x)     ((x) << QUEUENUMBER_SHIFT)
-
-#define MPS_TRC_FILTER_MATCH_CTL_A 0x9810
-#define  TFINVERTMATCH   0x01000000U
-#define  TFPKTTOOLARGE   0x00800000U
-#define  TFEN            0x00400000U
-#define  TFPORT_MASK     0x003c0000U
-#define  TFPORT_SHIFT    18
-#define  TFPORT(x)       ((x) << TFPORT_SHIFT)
-#define  TFPORT_GET(x)   (((x) & TFPORT_MASK) >> TFPORT_SHIFT)
-#define  TFDROP          0x00020000U
-#define  TFSOPEOPERR     0x00010000U
-#define  TFLENGTH_MASK   0x00001f00U
-#define  TFLENGTH_SHIFT  8
-#define  TFLENGTH(x)     ((x) << TFLENGTH_SHIFT)
-#define  TFLENGTH_GET(x) (((x) & TFLENGTH_MASK) >> TFLENGTH_SHIFT)
-#define  TFOFFSET_MASK   0x0000001fU
-#define  TFOFFSET_SHIFT  0
-#define  TFOFFSET(x)     ((x) << TFOFFSET_SHIFT)
-#define  TFOFFSET_GET(x) (((x) & TFOFFSET_MASK) >> TFOFFSET_SHIFT)
-
-#define MPS_TRC_FILTER_MATCH_CTL_B 0x9820
-#define  TFMINPKTSIZE_MASK   0x01ff0000U
-#define  TFMINPKTSIZE_SHIFT  16
-#define  TFMINPKTSIZE(x)     ((x) << TFMINPKTSIZE_SHIFT)
-#define  TFMINPKTSIZE_GET(x) (((x) & TFMINPKTSIZE_MASK) >> TFMINPKTSIZE_SHIFT)
-#define  TFCAPTUREMAX_MASK   0x00003fffU
-#define  TFCAPTUREMAX_SHIFT  0
-#define  TFCAPTUREMAX(x)     ((x) << TFCAPTUREMAX_SHIFT)
-#define  TFCAPTUREMAX_GET(x) (((x) & TFCAPTUREMAX_MASK) >> TFCAPTUREMAX_SHIFT)
-
-#define MPS_TRC_INT_CAUSE 0x985c
-#define  MISCPERR 0x00000100U
-#define  PKTFIFO  0x000000f0U
-#define  FILTMEM  0x0000000fU
-
-#define MPS_TRC_FILTER0_MATCH 0x9c00
-#define MPS_TRC_FILTER0_DONT_CARE 0x9c80
-#define MPS_TRC_FILTER1_MATCH 0x9d00
-#define MPS_CLS_INT_CAUSE 0xd028
-#define  PLERRENB  0x00000008U
-#define  HASHSRAM  0x00000004U
-#define  MATCHTCAM 0x00000002U
-#define  MATCHSRAM 0x00000001U
-
-#define MPS_RX_PERR_INT_CAUSE 0x11074
-
-#define CPL_INTR_CAUSE 0x19054
-#define  CIM_OP_MAP_PERR   0x00000020U
-#define  CIM_OVFL_ERROR    0x00000010U
-#define  TP_FRAMING_ERROR  0x00000008U
-#define  SGE_FRAMING_ERROR 0x00000004U
-#define  CIM_FRAMING_ERROR 0x00000002U
-#define  ZERO_SWITCH_ERROR 0x00000001U
-
-#define SMB_INT_CAUSE 0x19090
-#define  MSTTXFIFOPARINT 0x00200000U
-#define  MSTRXFIFOPARINT 0x00100000U
-#define  SLVFIFOPARINT   0x00080000U
-
-#define ULP_RX_INT_CAUSE 0x19158
-#define ULP_RX_ISCSI_TAGMASK 0x19164
-#define ULP_RX_ISCSI_PSZ 0x19168
-#define  HPZ3_MASK   0x0f000000U
-#define  HPZ3_SHIFT  24
-#define  HPZ3(x)     ((x) << HPZ3_SHIFT)
-#define  HPZ2_MASK   0x000f0000U
-#define  HPZ2_SHIFT  16
-#define  HPZ2(x)     ((x) << HPZ2_SHIFT)
-#define  HPZ1_MASK   0x00000f00U
-#define  HPZ1_SHIFT  8
-#define  HPZ1(x)     ((x) << HPZ1_SHIFT)
-#define  HPZ0_MASK   0x0000000fU
-#define  HPZ0_SHIFT  0
-#define  HPZ0(x)     ((x) << HPZ0_SHIFT)
-
-#define ULP_RX_TDDP_PSZ 0x19178
-
-#define SF_DATA 0x193f8
-#define SF_OP 0x193fc
-#define  SF_BUSY       0x80000000U
-#define  SF_LOCK       0x00000010U
-#define  SF_CONT       0x00000008U
-#define  BYTECNT_MASK  0x00000006U
-#define  BYTECNT_SHIFT 1
-#define  BYTECNT(x)    ((x) << BYTECNT_SHIFT)
-#define  OP_WR         0x00000001U
-
-#define PL_PF_INT_CAUSE 0x3c0
-#define  PFSW  0x00000008U
-#define  PFSGE 0x00000004U
-#define  PFCIM 0x00000002U
-#define  PFMPS 0x00000001U
-
-#define PL_PF_INT_ENABLE 0x3c4
-#define PL_PF_CTL 0x3c8
-#define  SWINT 0x00000001U
-
-#define PL_WHOAMI 0x19400
-#define  SOURCEPF_MASK   0x00000700U
-#define  SOURCEPF_SHIFT  8
-#define  SOURCEPF(x)     ((x) << SOURCEPF_SHIFT)
-#define  SOURCEPF_GET(x) (((x) & SOURCEPF_MASK) >> SOURCEPF_SHIFT)
-#define  ISVF            0x00000080U
-#define  VFID_MASK       0x0000007fU
-#define  VFID_SHIFT      0
-#define  VFID(x)         ((x) << VFID_SHIFT)
-#define  VFID_GET(x)     (((x) & VFID_MASK) >> VFID_SHIFT)
-
-#define PL_INT_CAUSE 0x1940c
-#define  ULP_TX     0x08000000U
-#define  SGE        0x04000000U
-#define  HMA        0x02000000U
-#define  CPL_SWITCH 0x01000000U
-#define  ULP_RX     0x00800000U
-#define  PM_RX      0x00400000U
-#define  PM_TX      0x00200000U
-#define  MA         0x00100000U
-#define  TP         0x00080000U
-#define  LE         0x00040000U
-#define  EDC1       0x00020000U
-#define  EDC0       0x00010000U
-#define  MC         0x00008000U
-#define  PCIE       0x00004000U
-#define  PMU        0x00002000U
-#define  XGMAC_KR1  0x00001000U
-#define  XGMAC_KR0  0x00000800U
-#define  XGMAC1     0x00000400U
-#define  XGMAC0     0x00000200U
-#define  SMB        0x00000100U
-#define  SF         0x00000080U
-#define  PL         0x00000040U
-#define  NCSI       0x00000020U
-#define  MPS        0x00000010U
-#define  MI         0x00000008U
-#define  DBG        0x00000004U
-#define  I2CM       0x00000002U
-#define  CIM        0x00000001U
-
-#define MC1 0x31
-#define PL_INT_ENABLE 0x19410
-#define PL_INT_MAP0 0x19414
-#define PL_RST 0x19428
-#define  PIORST     0x00000002U
-#define  PIORSTMODE 0x00000001U
-
-#define PL_PL_INT_CAUSE 0x19430
-#define  FATALPERR 0x00000010U
-#define  PERRVFID  0x00000001U
-
-#define PL_REV 0x1943c
-
-#define S_REV    0
-#define M_REV    0xfU
-#define V_REV(x) ((x) << S_REV)
-#define G_REV(x) (((x) >> S_REV) & M_REV)
-
-#define LE_DB_CONFIG 0x19c04
-#define  HASHEN 0x00100000U
-
-#define LE_DB_SERVER_INDEX 0x19c18
-#define LE_DB_ACT_CNT_IPV4 0x19c20
-#define LE_DB_ACT_CNT_IPV6 0x19c24
-
-#define LE_DB_INT_CAUSE 0x19c3c
-#define  REQQPARERR 0x00010000U
-#define  UNKNOWNCMD 0x00008000U
-#define  PARITYERR  0x00000040U
-#define  LIPMISS    0x00000020U
-#define  LIP0       0x00000010U
-
-#define LE_DB_TID_HASHBASE 0x19df8
-
-#define NCSI_INT_CAUSE 0x1a0d8
-#define  CIM_DM_PRTY_ERR 0x00000100U
-#define  MPS_DM_PRTY_ERR 0x00000080U
-#define  TXFIFO_PRTY_ERR 0x00000002U
-#define  RXFIFO_PRTY_ERR 0x00000001U
-
-#define XGMAC_PORT_CFG2 0x1018
-#define  PATEN   0x00040000U
-#define  MAGICEN 0x00020000U
 
-#define XGMAC_PORT_MAGIC_MACID_LO 0x1024
-#define XGMAC_PORT_MAGIC_MACID_HI 0x1028
+#define MPS_TRC_CFG_A 0x9800
+
+#define TRCFIFOEMPTY_S    4
+#define TRCFIFOEMPTY_V(x) ((x) << TRCFIFOEMPTY_S)
+#define TRCFIFOEMPTY_F    TRCFIFOEMPTY_V(1U)
+
+#define TRCIGNOREDROPINPUT_S    3
+#define TRCIGNOREDROPINPUT_V(x) ((x) << TRCIGNOREDROPINPUT_S)
+#define TRCIGNOREDROPINPUT_F    TRCIGNOREDROPINPUT_V(1U)
+
+#define TRCKEEPDUPLICATES_S    2
+#define TRCKEEPDUPLICATES_V(x) ((x) << TRCKEEPDUPLICATES_S)
+#define TRCKEEPDUPLICATES_F    TRCKEEPDUPLICATES_V(1U)
+
+#define TRCEN_S    1
+#define TRCEN_V(x) ((x) << TRCEN_S)
+#define TRCEN_F    TRCEN_V(1U)
+
+#define TRCMULTIFILTER_S    0
+#define TRCMULTIFILTER_V(x) ((x) << TRCMULTIFILTER_S)
+#define TRCMULTIFILTER_F    TRCMULTIFILTER_V(1U)
+
+#define MPS_TRC_RSS_CONTROL_A           0x9808
+#define MPS_T5_TRC_RSS_CONTROL_A        0xa00c
+
+#define RSSCONTROL_S    16
+#define RSSCONTROL_V(x) ((x) << RSSCONTROL_S)
+
+#define QUEUENUMBER_S    0
+#define QUEUENUMBER_V(x) ((x) << QUEUENUMBER_S)
+
+#define TP_RSS_CONFIG_A 0x7df0
+
+#define TNL4TUPENIPV6_S    31
+#define TNL4TUPENIPV6_V(x) ((x) << TNL4TUPENIPV6_S)
+#define TNL4TUPENIPV6_F    TNL4TUPENIPV6_V(1U)
+
+#define TNL2TUPENIPV6_S    30
+#define TNL2TUPENIPV6_V(x) ((x) << TNL2TUPENIPV6_S)
+#define TNL2TUPENIPV6_F    TNL2TUPENIPV6_V(1U)
+
+#define TNL4TUPENIPV4_S    29
+#define TNL4TUPENIPV4_V(x) ((x) << TNL4TUPENIPV4_S)
+#define TNL4TUPENIPV4_F    TNL4TUPENIPV4_V(1U)
+
+#define TNL2TUPENIPV4_S    28
+#define TNL2TUPENIPV4_V(x) ((x) << TNL2TUPENIPV4_S)
+#define TNL2TUPENIPV4_F    TNL2TUPENIPV4_V(1U)
+
+#define TNLTCPSEL_S    27
+#define TNLTCPSEL_V(x) ((x) << TNLTCPSEL_S)
+#define TNLTCPSEL_F    TNLTCPSEL_V(1U)
+
+#define TNLIP6SEL_S    26
+#define TNLIP6SEL_V(x) ((x) << TNLIP6SEL_S)
+#define TNLIP6SEL_F    TNLIP6SEL_V(1U)
+
+#define TNLVRTSEL_S    25
+#define TNLVRTSEL_V(x) ((x) << TNLVRTSEL_S)
+#define TNLVRTSEL_F    TNLVRTSEL_V(1U)
+
+#define TNLMAPEN_S    24
+#define TNLMAPEN_V(x) ((x) << TNLMAPEN_S)
+#define TNLMAPEN_F    TNLMAPEN_V(1U)
+
+#define OFDHASHSAVE_S    19
+#define OFDHASHSAVE_V(x) ((x) << OFDHASHSAVE_S)
+#define OFDHASHSAVE_F    OFDHASHSAVE_V(1U)
+
+#define OFDVRTSEL_S    18
+#define OFDVRTSEL_V(x) ((x) << OFDVRTSEL_S)
+#define OFDVRTSEL_F    OFDVRTSEL_V(1U)
+
+#define OFDMAPEN_S    17
+#define OFDMAPEN_V(x) ((x) << OFDMAPEN_S)
+#define OFDMAPEN_F    OFDMAPEN_V(1U)
+
+#define OFDLKPEN_S    16
+#define OFDLKPEN_V(x) ((x) << OFDLKPEN_S)
+#define OFDLKPEN_F    OFDLKPEN_V(1U)
+
+#define SYN4TUPENIPV6_S    15
+#define SYN4TUPENIPV6_V(x) ((x) << SYN4TUPENIPV6_S)
+#define SYN4TUPENIPV6_F    SYN4TUPENIPV6_V(1U)
+
+#define SYN2TUPENIPV6_S    14
+#define SYN2TUPENIPV6_V(x) ((x) << SYN2TUPENIPV6_S)
+#define SYN2TUPENIPV6_F    SYN2TUPENIPV6_V(1U)
+
+#define SYN4TUPENIPV4_S    13
+#define SYN4TUPENIPV4_V(x) ((x) << SYN4TUPENIPV4_S)
+#define SYN4TUPENIPV4_F    SYN4TUPENIPV4_V(1U)
+
+#define SYN2TUPENIPV4_S    12
+#define SYN2TUPENIPV4_V(x) ((x) << SYN2TUPENIPV4_S)
+#define SYN2TUPENIPV4_F    SYN2TUPENIPV4_V(1U)
+
+#define SYNIP6SEL_S    11
+#define SYNIP6SEL_V(x) ((x) << SYNIP6SEL_S)
+#define SYNIP6SEL_F    SYNIP6SEL_V(1U)
+
+#define SYNVRTSEL_S    10
+#define SYNVRTSEL_V(x) ((x) << SYNVRTSEL_S)
+#define SYNVRTSEL_F    SYNVRTSEL_V(1U)
+
+#define SYNMAPEN_S    9
+#define SYNMAPEN_V(x) ((x) << SYNMAPEN_S)
+#define SYNMAPEN_F    SYNMAPEN_V(1U)
+
+#define SYNLKPEN_S    8
+#define SYNLKPEN_V(x) ((x) << SYNLKPEN_S)
+#define SYNLKPEN_F    SYNLKPEN_V(1U)
+
+#define CHANNELENABLE_S    7
+#define CHANNELENABLE_V(x) ((x) << CHANNELENABLE_S)
+#define CHANNELENABLE_F    CHANNELENABLE_V(1U)
+
+#define PORTENABLE_S    6
+#define PORTENABLE_V(x) ((x) << PORTENABLE_S)
+#define PORTENABLE_F    PORTENABLE_V(1U)
+
+#define TNLALLLOOKUP_S    5
+#define TNLALLLOOKUP_V(x) ((x) << TNLALLLOOKUP_S)
+#define TNLALLLOOKUP_F    TNLALLLOOKUP_V(1U)
+
+#define VIRTENABLE_S    4
+#define VIRTENABLE_V(x) ((x) << VIRTENABLE_S)
+#define VIRTENABLE_F    VIRTENABLE_V(1U)
+
+#define CONGESTIONENABLE_S    3
+#define CONGESTIONENABLE_V(x) ((x) << CONGESTIONENABLE_S)
+#define CONGESTIONENABLE_F    CONGESTIONENABLE_V(1U)
+
+#define HASHTOEPLITZ_S    2
+#define HASHTOEPLITZ_V(x) ((x) << HASHTOEPLITZ_S)
+#define HASHTOEPLITZ_F    HASHTOEPLITZ_V(1U)
+
+#define UDPENABLE_S    1
+#define UDPENABLE_V(x) ((x) << UDPENABLE_S)
+#define UDPENABLE_F    UDPENABLE_V(1U)
+
+#define DISABLE_S    0
+#define DISABLE_V(x) ((x) << DISABLE_S)
+#define DISABLE_F    DISABLE_V(1U)
+
+#define TP_RSS_CONFIG_TNL_A 0x7df4
+
+#define MASKSIZE_S    28
+#define MASKSIZE_M    0xfU
+#define MASKSIZE_V(x) ((x) << MASKSIZE_S)
+#define MASKSIZE_G(x) (((x) >> MASKSIZE_S) & MASKSIZE_M)
+
+#define MASKFILTER_S    16
+#define MASKFILTER_M    0x7ffU
+#define MASKFILTER_V(x) ((x) << MASKFILTER_S)
+#define MASKFILTER_G(x) (((x) >> MASKFILTER_S) & MASKFILTER_M)
+
+#define USEWIRECH_S    0
+#define USEWIRECH_V(x) ((x) << USEWIRECH_S)
+#define USEWIRECH_F    USEWIRECH_V(1U)
+
+#define HASHALL_S    2
+#define HASHALL_V(x) ((x) << HASHALL_S)
+#define HASHALL_F    HASHALL_V(1U)
+
+#define HASHETH_S    1
+#define HASHETH_V(x) ((x) << HASHETH_S)
+#define HASHETH_F    HASHETH_V(1U)
+
+#define TP_RSS_CONFIG_OFD_A 0x7df8
+
+#define RRCPLMAPEN_S    20
+#define RRCPLMAPEN_V(x) ((x) << RRCPLMAPEN_S)
+#define RRCPLMAPEN_F    RRCPLMAPEN_V(1U)
+
+#define RRCPLQUEWIDTH_S    16
+#define RRCPLQUEWIDTH_M    0xfU
+#define RRCPLQUEWIDTH_V(x) ((x) << RRCPLQUEWIDTH_S)
+#define RRCPLQUEWIDTH_G(x) (((x) >> RRCPLQUEWIDTH_S) & RRCPLQUEWIDTH_M)
+
+#define TP_RSS_CONFIG_SYN_A 0x7dfc
+#define TP_RSS_CONFIG_VRT_A 0x7e00
+
+#define VFRDRG_S    25
+#define VFRDRG_V(x) ((x) << VFRDRG_S)
+#define VFRDRG_F    VFRDRG_V(1U)
+
+#define VFRDEN_S    24
+#define VFRDEN_V(x) ((x) << VFRDEN_S)
+#define VFRDEN_F    VFRDEN_V(1U)
+
+#define VFPERREN_S    23
+#define VFPERREN_V(x) ((x) << VFPERREN_S)
+#define VFPERREN_F    VFPERREN_V(1U)
+
+#define KEYPERREN_S    22
+#define KEYPERREN_V(x) ((x) << KEYPERREN_S)
+#define KEYPERREN_F    KEYPERREN_V(1U)
+
+#define DISABLEVLAN_S    21
+#define DISABLEVLAN_V(x) ((x) << DISABLEVLAN_S)
+#define DISABLEVLAN_F    DISABLEVLAN_V(1U)
+
+#define ENABLEUP0_S    20
+#define ENABLEUP0_V(x) ((x) << ENABLEUP0_S)
+#define ENABLEUP0_F    ENABLEUP0_V(1U)
+
+#define HASHDELAY_S    16
+#define HASHDELAY_M    0xfU
+#define HASHDELAY_V(x) ((x) << HASHDELAY_S)
+#define HASHDELAY_G(x) (((x) >> HASHDELAY_S) & HASHDELAY_M)
+
+#define VFWRADDR_S    8
+#define VFWRADDR_M    0x7fU
+#define VFWRADDR_V(x) ((x) << VFWRADDR_S)
+#define VFWRADDR_G(x) (((x) >> VFWRADDR_S) & VFWRADDR_M)
+
+#define KEYMODE_S    6
+#define KEYMODE_M    0x3U
+#define KEYMODE_V(x) ((x) << KEYMODE_S)
+#define KEYMODE_G(x) (((x) >> KEYMODE_S) & KEYMODE_M)
+
+#define VFWREN_S    5
+#define VFWREN_V(x) ((x) << VFWREN_S)
+#define VFWREN_F    VFWREN_V(1U)
+
+#define KEYWREN_S    4
+#define KEYWREN_V(x) ((x) << KEYWREN_S)
+#define KEYWREN_F    KEYWREN_V(1U)
+
+#define KEYWRADDR_S    0
+#define KEYWRADDR_M    0xfU
+#define KEYWRADDR_V(x) ((x) << KEYWRADDR_S)
+#define KEYWRADDR_G(x) (((x) >> KEYWRADDR_S) & KEYWRADDR_M)
+
+#define KEYWRADDRX_S    30
+#define KEYWRADDRX_M    0x3U
+#define KEYWRADDRX_V(x) ((x) << KEYWRADDRX_S)
+#define KEYWRADDRX_G(x) (((x) >> KEYWRADDRX_S) & KEYWRADDRX_M)
+
+#define KEYEXTEND_S    26
+#define KEYEXTEND_V(x) ((x) << KEYEXTEND_S)
+#define KEYEXTEND_F    KEYEXTEND_V(1U)
+
+#define LKPIDXSIZE_S    24
+#define LKPIDXSIZE_M    0x3U
+#define LKPIDXSIZE_V(x) ((x) << LKPIDXSIZE_S)
+#define LKPIDXSIZE_G(x) (((x) >> LKPIDXSIZE_S) & LKPIDXSIZE_M)
+
+#define TP_RSS_VFL_CONFIG_A 0x3a
+#define TP_RSS_VFH_CONFIG_A 0x3b
+
+#define ENABLEUDPHASH_S    31
+#define ENABLEUDPHASH_V(x) ((x) << ENABLEUDPHASH_S)
+#define ENABLEUDPHASH_F    ENABLEUDPHASH_V(1U)
+
+#define VFUPEN_S    30
+#define VFUPEN_V(x) ((x) << VFUPEN_S)
+#define VFUPEN_F    VFUPEN_V(1U)
+
+#define VFVLNEX_S    28
+#define VFVLNEX_V(x) ((x) << VFVLNEX_S)
+#define VFVLNEX_F    VFVLNEX_V(1U)
+
+#define VFPRTEN_S    27
+#define VFPRTEN_V(x) ((x) << VFPRTEN_S)
+#define VFPRTEN_F    VFPRTEN_V(1U)
+
+#define VFCHNEN_S    26
+#define VFCHNEN_V(x) ((x) << VFCHNEN_S)
+#define VFCHNEN_F    VFCHNEN_V(1U)
+
+#define DEFAULTQUEUE_S    16
+#define DEFAULTQUEUE_M    0x3ffU
+#define DEFAULTQUEUE_G(x) (((x) >> DEFAULTQUEUE_S) & DEFAULTQUEUE_M)
+
+#define VFIP6TWOTUPEN_S    6
+#define VFIP6TWOTUPEN_V(x) ((x) << VFIP6TWOTUPEN_S)
+#define VFIP6TWOTUPEN_F    VFIP6TWOTUPEN_V(1U)
+
+#define VFIP4FOURTUPEN_S    5
+#define VFIP4FOURTUPEN_V(x) ((x) << VFIP4FOURTUPEN_S)
+#define VFIP4FOURTUPEN_F    VFIP4FOURTUPEN_V(1U)
+
+#define VFIP4TWOTUPEN_S    4
+#define VFIP4TWOTUPEN_V(x) ((x) << VFIP4TWOTUPEN_S)
+#define VFIP4TWOTUPEN_F    VFIP4TWOTUPEN_V(1U)
+
+#define KEYINDEX_S    0
+#define KEYINDEX_M    0xfU
+#define KEYINDEX_G(x) (((x) >> KEYINDEX_S) & KEYINDEX_M)
+
+#define MAPENABLE_S    31
+#define MAPENABLE_V(x) ((x) << MAPENABLE_S)
+#define MAPENABLE_F    MAPENABLE_V(1U)
+
+#define CHNENABLE_S    30
+#define CHNENABLE_V(x) ((x) << CHNENABLE_S)
+#define CHNENABLE_F    CHNENABLE_V(1U)
+
+#define PRTENABLE_S    29
+#define PRTENABLE_V(x) ((x) << PRTENABLE_S)
+#define PRTENABLE_F    PRTENABLE_V(1U)
+
+#define UDPFOURTUPEN_S    28
+#define UDPFOURTUPEN_V(x) ((x) << UDPFOURTUPEN_S)
+#define UDPFOURTUPEN_F    UDPFOURTUPEN_V(1U)
+
+#define IP6FOURTUPEN_S    27
+#define IP6FOURTUPEN_V(x) ((x) << IP6FOURTUPEN_S)
+#define IP6FOURTUPEN_F    IP6FOURTUPEN_V(1U)
 
-#define XGMAC_PORT_EPIO_DATA0 0x10c0
-#define XGMAC_PORT_EPIO_DATA1 0x10c4
-#define XGMAC_PORT_EPIO_DATA2 0x10c8
-#define XGMAC_PORT_EPIO_DATA3 0x10cc
-#define XGMAC_PORT_EPIO_OP 0x10d0
-#define  EPIOWR         0x00000100U
-#define  ADDRESS_MASK   0x000000ffU
-#define  ADDRESS_SHIFT  0
-#define  ADDRESS(x)     ((x) << ADDRESS_SHIFT)
+#define IP6TWOTUPEN_S    26
+#define IP6TWOTUPEN_V(x) ((x) << IP6TWOTUPEN_S)
+#define IP6TWOTUPEN_F    IP6TWOTUPEN_V(1U)
 
-#define MAC_PORT_INT_CAUSE 0x8dc
-#define XGMAC_PORT_INT_CAUSE 0x10dc
+#define IP4FOURTUPEN_S    25
+#define IP4FOURTUPEN_V(x) ((x) << IP4FOURTUPEN_S)
+#define IP4FOURTUPEN_F    IP4FOURTUPEN_V(1U)
 
-#define A_TP_TX_MOD_QUEUE_REQ_MAP 0x7e28
+#define IP4TWOTUPEN_S    24
+#define IP4TWOTUPEN_V(x) ((x) << IP4TWOTUPEN_S)
+#define IP4TWOTUPEN_F    IP4TWOTUPEN_V(1U)
 
-#define A_TP_TX_MOD_CHANNEL_WEIGHT 0x7e34
+#define IVFWIDTH_S    20
+#define IVFWIDTH_M    0xfU
+#define IVFWIDTH_V(x) ((x) << IVFWIDTH_S)
+#define IVFWIDTH_G(x) (((x) >> IVFWIDTH_S) & IVFWIDTH_M)
 
-#define S_TX_MOD_QUEUE_REQ_MAP    0
-#define M_TX_MOD_QUEUE_REQ_MAP    0xffffU
-#define V_TX_MOD_QUEUE_REQ_MAP(x) ((x) << S_TX_MOD_QUEUE_REQ_MAP)
+#define CH1DEFAULTQUEUE_S    10
+#define CH1DEFAULTQUEUE_M    0x3ffU
+#define CH1DEFAULTQUEUE_V(x) ((x) << CH1DEFAULTQUEUE_S)
+#define CH1DEFAULTQUEUE_G(x) (((x) >> CH1DEFAULTQUEUE_S) & CH1DEFAULTQUEUE_M)
 
-#define A_TP_TX_MOD_QUEUE_WEIGHT0 0x7e30
+#define CH0DEFAULTQUEUE_S    0
+#define CH0DEFAULTQUEUE_M    0x3ffU
+#define CH0DEFAULTQUEUE_V(x) ((x) << CH0DEFAULTQUEUE_S)
+#define CH0DEFAULTQUEUE_G(x) (((x) >> CH0DEFAULTQUEUE_S) & CH0DEFAULTQUEUE_M)
 
-#define S_TX_MODQ_WEIGHT3    24
-#define M_TX_MODQ_WEIGHT3    0xffU
-#define V_TX_MODQ_WEIGHT3(x) ((x) << S_TX_MODQ_WEIGHT3)
+#define VFLKPIDX_S    8
+#define VFLKPIDX_M    0xffU
+#define VFLKPIDX_G(x) (((x) >> VFLKPIDX_S) & VFLKPIDX_M)
 
-#define S_TX_MODQ_WEIGHT2    16
-#define M_TX_MODQ_WEIGHT2    0xffU
-#define V_TX_MODQ_WEIGHT2(x) ((x) << S_TX_MODQ_WEIGHT2)
+#define TP_RSS_CONFIG_CNG_A 0x7e04
+#define TP_RSS_SECRET_KEY0_A 0x40
+#define TP_RSS_PF0_CONFIG_A 0x30
+#define TP_RSS_PF_MAP_A 0x38
+#define TP_RSS_PF_MSK_A 0x39
 
-#define S_TX_MODQ_WEIGHT1    8
-#define M_TX_MODQ_WEIGHT1    0xffU
-#define V_TX_MODQ_WEIGHT1(x) ((x) << S_TX_MODQ_WEIGHT1)
+#define PF1LKPIDX_S    3
 
-#define S_TX_MODQ_WEIGHT0    0
-#define M_TX_MODQ_WEIGHT0    0xffU
-#define V_TX_MODQ_WEIGHT0(x) ((x) << S_TX_MODQ_WEIGHT0)
+#define PF0LKPIDX_M    0x7U
 
-#define A_TP_TX_SCHED_HDR 0x23
+#define PF1MSKSIZE_S    4
+#define PF1MSKSIZE_M    0xfU
 
-#define A_TP_TX_SCHED_FIFO 0x24
+#define CHNCOUNT3_S    31
+#define CHNCOUNT3_V(x) ((x) << CHNCOUNT3_S)
+#define CHNCOUNT3_F    CHNCOUNT3_V(1U)
 
-#define A_TP_TX_SCHED_PCMD 0x25
+#define CHNCOUNT2_S    30
+#define CHNCOUNT2_V(x) ((x) << CHNCOUNT2_S)
+#define CHNCOUNT2_F    CHNCOUNT2_V(1U)
 
-#define S_VNIC    11
-#define V_VNIC(x) ((x) << S_VNIC)
-#define F_VNIC    V_VNIC(1U)
+#define CHNCOUNT1_S    29
+#define CHNCOUNT1_V(x) ((x) << CHNCOUNT1_S)
+#define CHNCOUNT1_F    CHNCOUNT1_V(1U)
 
-#define S_FRAGMENTATION    9
-#define V_FRAGMENTATION(x) ((x) << S_FRAGMENTATION)
-#define F_FRAGMENTATION    V_FRAGMENTATION(1U)
+#define CHNCOUNT0_S    28
+#define CHNCOUNT0_V(x) ((x) << CHNCOUNT0_S)
+#define CHNCOUNT0_F    CHNCOUNT0_V(1U)
 
-#define S_MPSHITTYPE    8
-#define V_MPSHITTYPE(x) ((x) << S_MPSHITTYPE)
-#define F_MPSHITTYPE    V_MPSHITTYPE(1U)
+#define CHNUNDFLOW3_S    27
+#define CHNUNDFLOW3_V(x) ((x) << CHNUNDFLOW3_S)
+#define CHNUNDFLOW3_F    CHNUNDFLOW3_V(1U)
 
-#define S_MACMATCH    7
-#define V_MACMATCH(x) ((x) << S_MACMATCH)
-#define F_MACMATCH    V_MACMATCH(1U)
+#define CHNUNDFLOW2_S    26
+#define CHNUNDFLOW2_V(x) ((x) << CHNUNDFLOW2_S)
+#define CHNUNDFLOW2_F    CHNUNDFLOW2_V(1U)
 
-#define S_ETHERTYPE    6
-#define V_ETHERTYPE(x) ((x) << S_ETHERTYPE)
-#define F_ETHERTYPE    V_ETHERTYPE(1U)
+#define CHNUNDFLOW1_S    25
+#define CHNUNDFLOW1_V(x) ((x) << CHNUNDFLOW1_S)
+#define CHNUNDFLOW1_F    CHNUNDFLOW1_V(1U)
 
-#define S_PROTOCOL    5
-#define V_PROTOCOL(x) ((x) << S_PROTOCOL)
-#define F_PROTOCOL    V_PROTOCOL(1U)
+#define CHNUNDFLOW0_S    24
+#define CHNUNDFLOW0_V(x) ((x) << CHNUNDFLOW0_S)
+#define CHNUNDFLOW0_F    CHNUNDFLOW0_V(1U)
 
-#define S_TOS    4
-#define V_TOS(x) ((x) << S_TOS)
-#define F_TOS    V_TOS(1U)
+#define RSTCHN3_S    19
+#define RSTCHN3_V(x) ((x) << RSTCHN3_S)
+#define RSTCHN3_F    RSTCHN3_V(1U)
 
-#define S_VLAN    3
-#define V_VLAN(x) ((x) << S_VLAN)
-#define F_VLAN    V_VLAN(1U)
+#define RSTCHN2_S    18
+#define RSTCHN2_V(x) ((x) << RSTCHN2_S)
+#define RSTCHN2_F    RSTCHN2_V(1U)
 
-#define S_VNIC_ID    2
-#define V_VNIC_ID(x) ((x) << S_VNIC_ID)
-#define F_VNIC_ID    V_VNIC_ID(1U)
+#define RSTCHN1_S    17
+#define RSTCHN1_V(x) ((x) << RSTCHN1_S)
+#define RSTCHN1_F    RSTCHN1_V(1U)
 
-#define S_PORT    1
-#define V_PORT(x) ((x) << S_PORT)
-#define F_PORT    V_PORT(1U)
+#define RSTCHN0_S    16
+#define RSTCHN0_V(x) ((x) << RSTCHN0_S)
+#define RSTCHN0_F    RSTCHN0_V(1U)
 
-#define S_FCOE    0
-#define V_FCOE(x) ((x) << S_FCOE)
-#define F_FCOE    V_FCOE(1U)
+#define UPDVLD_S    15
+#define UPDVLD_V(x) ((x) << UPDVLD_S)
+#define UPDVLD_F    UPDVLD_V(1U)
+
+#define XOFF_S    14
+#define XOFF_V(x) ((x) << XOFF_S)
+#define XOFF_F    XOFF_V(1U)
+
+#define UPDCHN3_S    13
+#define UPDCHN3_V(x) ((x) << UPDCHN3_S)
+#define UPDCHN3_F    UPDCHN3_V(1U)
+
+#define UPDCHN2_S    12
+#define UPDCHN2_V(x) ((x) << UPDCHN2_S)
+#define UPDCHN2_F    UPDCHN2_V(1U)
+
+#define UPDCHN1_S    11
+#define UPDCHN1_V(x) ((x) << UPDCHN1_S)
+#define UPDCHN1_F    UPDCHN1_V(1U)
+
+#define UPDCHN0_S    10
+#define UPDCHN0_V(x) ((x) << UPDCHN0_S)
+#define UPDCHN0_F    UPDCHN0_V(1U)
+
+#define QUEUE_S    0
+#define QUEUE_M    0x3ffU
+#define QUEUE_V(x) ((x) << QUEUE_S)
+#define QUEUE_G(x) (((x) >> QUEUE_S) & QUEUE_M)
+
+#define MPS_TRC_INT_CAUSE_A     0x985c
+
+#define MISCPERR_S    8
+#define MISCPERR_V(x) ((x) << MISCPERR_S)
+#define MISCPERR_F    MISCPERR_V(1U)
+
+#define PKTFIFO_S    4
+#define PKTFIFO_M    0xfU
+#define PKTFIFO_V(x) ((x) << PKTFIFO_S)
+
+#define FILTMEM_S    0
+#define FILTMEM_M    0xfU
+#define FILTMEM_V(x) ((x) << FILTMEM_S)
+
+#define MPS_CLS_INT_CAUSE_A 0xd028
+
+#define HASHSRAM_S    2
+#define HASHSRAM_V(x) ((x) << HASHSRAM_S)
+#define HASHSRAM_F    HASHSRAM_V(1U)
+
+#define MATCHTCAM_S    1
+#define MATCHTCAM_V(x) ((x) << MATCHTCAM_S)
+#define MATCHTCAM_F    MATCHTCAM_V(1U)
+
+#define MATCHSRAM_S    0
+#define MATCHSRAM_V(x) ((x) << MATCHSRAM_S)
+#define MATCHSRAM_F    MATCHSRAM_V(1U)
+
+#define MPS_RX_PERR_INT_CAUSE_A 0x11074
+
+#define MPS_CLS_TCAM_Y_L_A 0xf000
+#define MPS_CLS_TCAM_X_L_A 0xf008
+
+#define MPS_CLS_TCAM_Y_L(idx) (MPS_CLS_TCAM_Y_L_A + (idx) * 16)
+#define NUM_MPS_CLS_TCAM_Y_L_INSTANCES 512
+
+#define MPS_CLS_TCAM_X_L(idx) (MPS_CLS_TCAM_X_L_A + (idx) * 16)
+#define NUM_MPS_CLS_TCAM_X_L_INSTANCES 512
+
+#define MPS_CLS_SRAM_L_A 0xe000
+#define MPS_CLS_SRAM_H_A 0xe004
+
+#define MPS_CLS_SRAM_L(idx) (MPS_CLS_SRAM_L_A + (idx) * 8)
+#define NUM_MPS_CLS_SRAM_L_INSTANCES 336
+
+#define MPS_CLS_SRAM_H(idx) (MPS_CLS_SRAM_H_A + (idx) * 8)
+#define NUM_MPS_CLS_SRAM_H_INSTANCES 336
+
+#define MULTILISTEN0_S    25
+
+#define REPLICATE_S    11
+#define REPLICATE_V(x) ((x) << REPLICATE_S)
+#define REPLICATE_F    REPLICATE_V(1U)
+
+#define PF_S    8
+#define PF_M    0x7U
+#define PF_G(x) (((x) >> PF_S) & PF_M)
+
+#define VF_VALID_S    7
+#define VF_VALID_V(x) ((x) << VF_VALID_S)
+#define VF_VALID_F    VF_VALID_V(1U)
+
+#define VF_S    0
+#define VF_M    0x7fU
+#define VF_G(x) (((x) >> VF_S) & VF_M)
+
+#define SRAM_PRIO3_S    22
+#define SRAM_PRIO3_M    0x7U
+#define SRAM_PRIO3_G(x) (((x) >> SRAM_PRIO3_S) & SRAM_PRIO3_M)
+
+#define SRAM_PRIO2_S    19
+#define SRAM_PRIO2_M    0x7U
+#define SRAM_PRIO2_G(x) (((x) >> SRAM_PRIO2_S) & SRAM_PRIO2_M)
+
+#define SRAM_PRIO1_S    16
+#define SRAM_PRIO1_M    0x7U
+#define SRAM_PRIO1_G(x) (((x) >> SRAM_PRIO1_S) & SRAM_PRIO1_M)
+
+#define SRAM_PRIO0_S    13
+#define SRAM_PRIO0_M    0x7U
+#define SRAM_PRIO0_G(x) (((x) >> SRAM_PRIO0_S) & SRAM_PRIO0_M)
+
+#define SRAM_VLD_S    12
+#define SRAM_VLD_V(x) ((x) << SRAM_VLD_S)
+#define SRAM_VLD_F    SRAM_VLD_V(1U)
+
+#define PORTMAP_S    0
+#define PORTMAP_M    0xfU
+#define PORTMAP_G(x) (((x) >> PORTMAP_S) & PORTMAP_M)
+
+#define CPL_INTR_CAUSE_A 0x19054
+
+#define CIM_OP_MAP_PERR_S    5
+#define CIM_OP_MAP_PERR_V(x) ((x) << CIM_OP_MAP_PERR_S)
+#define CIM_OP_MAP_PERR_F    CIM_OP_MAP_PERR_V(1U)
+
+#define CIM_OVFL_ERROR_S    4
+#define CIM_OVFL_ERROR_V(x) ((x) << CIM_OVFL_ERROR_S)
+#define CIM_OVFL_ERROR_F    CIM_OVFL_ERROR_V(1U)
+
+#define TP_FRAMING_ERROR_S    3
+#define TP_FRAMING_ERROR_V(x) ((x) << TP_FRAMING_ERROR_S)
+#define TP_FRAMING_ERROR_F    TP_FRAMING_ERROR_V(1U)
+
+#define SGE_FRAMING_ERROR_S    2
+#define SGE_FRAMING_ERROR_V(x) ((x) << SGE_FRAMING_ERROR_S)
+#define SGE_FRAMING_ERROR_F    SGE_FRAMING_ERROR_V(1U)
+
+#define CIM_FRAMING_ERROR_S    1
+#define CIM_FRAMING_ERROR_V(x) ((x) << CIM_FRAMING_ERROR_S)
+#define CIM_FRAMING_ERROR_F    CIM_FRAMING_ERROR_V(1U)
+
+#define ZERO_SWITCH_ERROR_S    0
+#define ZERO_SWITCH_ERROR_V(x) ((x) << ZERO_SWITCH_ERROR_S)
+#define ZERO_SWITCH_ERROR_F    ZERO_SWITCH_ERROR_V(1U)
+
+#define SMB_INT_CAUSE_A 0x19090
+
+#define MSTTXFIFOPARINT_S    21
+#define MSTTXFIFOPARINT_V(x) ((x) << MSTTXFIFOPARINT_S)
+#define MSTTXFIFOPARINT_F    MSTTXFIFOPARINT_V(1U)
+
+#define MSTRXFIFOPARINT_S    20
+#define MSTRXFIFOPARINT_V(x) ((x) << MSTRXFIFOPARINT_S)
+#define MSTRXFIFOPARINT_F    MSTRXFIFOPARINT_V(1U)
+
+#define SLVFIFOPARINT_S    19
+#define SLVFIFOPARINT_V(x) ((x) << SLVFIFOPARINT_S)
+#define SLVFIFOPARINT_F    SLVFIFOPARINT_V(1U)
+
+#define ULP_RX_INT_CAUSE_A 0x19158
+#define ULP_RX_ISCSI_TAGMASK_A 0x19164
+#define ULP_RX_ISCSI_PSZ_A 0x19168
+#define ULP_RX_LA_CTL_A 0x1923c
+#define ULP_RX_LA_RDPTR_A 0x19240
+#define ULP_RX_LA_RDDATA_A 0x19244
+#define ULP_RX_LA_WRPTR_A 0x19248
+
+#define HPZ3_S    24
+#define HPZ3_V(x) ((x) << HPZ3_S)
+
+#define HPZ2_S    16
+#define HPZ2_V(x) ((x) << HPZ2_S)
+
+#define HPZ1_S    8
+#define HPZ1_V(x) ((x) << HPZ1_S)
+
+#define HPZ0_S    0
+#define HPZ0_V(x) ((x) << HPZ0_S)
+
+#define ULP_RX_TDDP_PSZ_A 0x19178
+
+/* registers for module SF */
+#define SF_DATA_A 0x193f8
+#define SF_OP_A 0x193fc
+
+#define SF_BUSY_S    31
+#define SF_BUSY_V(x) ((x) << SF_BUSY_S)
+#define SF_BUSY_F    SF_BUSY_V(1U)
+
+#define SF_LOCK_S    4
+#define SF_LOCK_V(x) ((x) << SF_LOCK_S)
+#define SF_LOCK_F    SF_LOCK_V(1U)
+
+#define SF_CONT_S    3
+#define SF_CONT_V(x) ((x) << SF_CONT_S)
+#define SF_CONT_F    SF_CONT_V(1U)
+
+#define BYTECNT_S    1
+#define BYTECNT_V(x) ((x) << BYTECNT_S)
+
+#define OP_S    0
+#define OP_V(x) ((x) << OP_S)
+#define OP_F    OP_V(1U)
+
+#define PL_PF_INT_CAUSE_A 0x3c0
+
+#define PFSW_S    3
+#define PFSW_V(x) ((x) << PFSW_S)
+#define PFSW_F    PFSW_V(1U)
+
+#define PFCIM_S    1
+#define PFCIM_V(x) ((x) << PFCIM_S)
+#define PFCIM_F    PFCIM_V(1U)
+
+#define PL_PF_INT_ENABLE_A 0x3c4
+#define PL_PF_CTL_A 0x3c8
+
+#define PL_WHOAMI_A 0x19400
+
+#define SOURCEPF_S    8
+#define SOURCEPF_M    0x7U
+#define SOURCEPF_G(x) (((x) >> SOURCEPF_S) & SOURCEPF_M)
+
+#define PL_INT_CAUSE_A 0x1940c
+
+#define ULP_TX_S    27
+#define ULP_TX_V(x) ((x) << ULP_TX_S)
+#define ULP_TX_F    ULP_TX_V(1U)
+
+#define SGE_S    26
+#define SGE_V(x) ((x) << SGE_S)
+#define SGE_F    SGE_V(1U)
+
+#define CPL_SWITCH_S    24
+#define CPL_SWITCH_V(x) ((x) << CPL_SWITCH_S)
+#define CPL_SWITCH_F    CPL_SWITCH_V(1U)
+
+#define ULP_RX_S    23
+#define ULP_RX_V(x) ((x) << ULP_RX_S)
+#define ULP_RX_F    ULP_RX_V(1U)
+
+#define PM_RX_S    22
+#define PM_RX_V(x) ((x) << PM_RX_S)
+#define PM_RX_F    PM_RX_V(1U)
+
+#define PM_TX_S    21
+#define PM_TX_V(x) ((x) << PM_TX_S)
+#define PM_TX_F    PM_TX_V(1U)
+
+#define MA_S    20
+#define MA_V(x) ((x) << MA_S)
+#define MA_F    MA_V(1U)
+
+#define TP_S    19
+#define TP_V(x) ((x) << TP_S)
+#define TP_F    TP_V(1U)
+
+#define LE_S    18
+#define LE_V(x) ((x) << LE_S)
+#define LE_F    LE_V(1U)
+
+#define EDC1_S    17
+#define EDC1_V(x) ((x) << EDC1_S)
+#define EDC1_F    EDC1_V(1U)
+
+#define EDC0_S    16
+#define EDC0_V(x) ((x) << EDC0_S)
+#define EDC0_F    EDC0_V(1U)
+
+#define MC_S    15
+#define MC_V(x) ((x) << MC_S)
+#define MC_F    MC_V(1U)
+
+#define PCIE_S    14
+#define PCIE_V(x) ((x) << PCIE_S)
+#define PCIE_F    PCIE_V(1U)
+
+#define XGMAC_KR1_S    12
+#define XGMAC_KR1_V(x) ((x) << XGMAC_KR1_S)
+#define XGMAC_KR1_F    XGMAC_KR1_V(1U)
+
+#define XGMAC_KR0_S    11
+#define XGMAC_KR0_V(x) ((x) << XGMAC_KR0_S)
+#define XGMAC_KR0_F    XGMAC_KR0_V(1U)
+
+#define XGMAC1_S    10
+#define XGMAC1_V(x) ((x) << XGMAC1_S)
+#define XGMAC1_F    XGMAC1_V(1U)
+
+#define XGMAC0_S    9
+#define XGMAC0_V(x) ((x) << XGMAC0_S)
+#define XGMAC0_F    XGMAC0_V(1U)
+
+#define SMB_S    8
+#define SMB_V(x) ((x) << SMB_S)
+#define SMB_F    SMB_V(1U)
+
+#define SF_S    7
+#define SF_V(x) ((x) << SF_S)
+#define SF_F    SF_V(1U)
+
+#define PL_S    6
+#define PL_V(x) ((x) << PL_S)
+#define PL_F    PL_V(1U)
+
+#define NCSI_S    5
+#define NCSI_V(x) ((x) << NCSI_S)
+#define NCSI_F    NCSI_V(1U)
+
+#define MPS_S    4
+#define MPS_V(x) ((x) << MPS_S)
+#define MPS_F    MPS_V(1U)
+
+#define CIM_S    0
+#define CIM_V(x) ((x) << CIM_S)
+#define CIM_F    CIM_V(1U)
+
+#define MC1_S    31
+
+#define PL_INT_ENABLE_A 0x19410
+#define PL_INT_MAP0_A 0x19414
+#define PL_RST_A 0x19428
+
+#define PIORST_S    1
+#define PIORST_V(x) ((x) << PIORST_S)
+#define PIORST_F    PIORST_V(1U)
+
+#define PIORSTMODE_S    0
+#define PIORSTMODE_V(x) ((x) << PIORSTMODE_S)
+#define PIORSTMODE_F    PIORSTMODE_V(1U)
+
+#define PL_PL_INT_CAUSE_A 0x19430
+
+#define FATALPERR_S    4
+#define FATALPERR_V(x) ((x) << FATALPERR_S)
+#define FATALPERR_F    FATALPERR_V(1U)
+
+#define PERRVFID_S    0
+#define PERRVFID_V(x) ((x) << PERRVFID_S)
+#define PERRVFID_F    PERRVFID_V(1U)
+
+#define PL_REV_A 0x1943c
+
+#define REV_S    0
+#define REV_M    0xfU
+#define REV_V(x) ((x) << REV_S)
+#define REV_G(x) (((x) >> REV_S) & REV_M)
+
+#define LE_DB_INT_CAUSE_A 0x19c3c
+
+#define REQQPARERR_S    16
+#define REQQPARERR_V(x) ((x) << REQQPARERR_S)
+#define REQQPARERR_F    REQQPARERR_V(1U)
+
+#define UNKNOWNCMD_S    15
+#define UNKNOWNCMD_V(x) ((x) << UNKNOWNCMD_S)
+#define UNKNOWNCMD_F    UNKNOWNCMD_V(1U)
+
+#define PARITYERR_S    6
+#define PARITYERR_V(x) ((x) << PARITYERR_S)
+#define PARITYERR_F    PARITYERR_V(1U)
+
+#define LIPMISS_S    5
+#define LIPMISS_V(x) ((x) << LIPMISS_S)
+#define LIPMISS_F    LIPMISS_V(1U)
+
+#define LIP0_S    4
+#define LIP0_V(x) ((x) << LIP0_S)
+#define LIP0_F    LIP0_V(1U)
+
+#define NCSI_INT_CAUSE_A 0x1a0d8
+
+#define CIM_DM_PRTY_ERR_S    8
+#define CIM_DM_PRTY_ERR_V(x) ((x) << CIM_DM_PRTY_ERR_S)
+#define CIM_DM_PRTY_ERR_F    CIM_DM_PRTY_ERR_V(1U)
+
+#define MPS_DM_PRTY_ERR_S    7
+#define MPS_DM_PRTY_ERR_V(x) ((x) << MPS_DM_PRTY_ERR_S)
+#define MPS_DM_PRTY_ERR_F    MPS_DM_PRTY_ERR_V(1U)
+
+#define TXFIFO_PRTY_ERR_S    1
+#define TXFIFO_PRTY_ERR_V(x) ((x) << TXFIFO_PRTY_ERR_S)
+#define TXFIFO_PRTY_ERR_F    TXFIFO_PRTY_ERR_V(1U)
+
+#define RXFIFO_PRTY_ERR_S    0
+#define RXFIFO_PRTY_ERR_V(x) ((x) << RXFIFO_PRTY_ERR_S)
+#define RXFIFO_PRTY_ERR_F    RXFIFO_PRTY_ERR_V(1U)
+
+#define XGMAC_PORT_CFG2_A 0x1018
+
+#define PATEN_S    18
+#define PATEN_V(x) ((x) << PATEN_S)
+#define PATEN_F    PATEN_V(1U)
+
+#define MAGICEN_S    17
+#define MAGICEN_V(x) ((x) << MAGICEN_S)
+#define MAGICEN_F    MAGICEN_V(1U)
+
+#define XGMAC_PORT_MAGIC_MACID_LO 0x1024
+#define XGMAC_PORT_MAGIC_MACID_HI 0x1028
+
+#define XGMAC_PORT_EPIO_DATA0_A 0x10c0
+#define XGMAC_PORT_EPIO_DATA1_A 0x10c4
+#define XGMAC_PORT_EPIO_DATA2_A 0x10c8
+#define XGMAC_PORT_EPIO_DATA3_A 0x10cc
+#define XGMAC_PORT_EPIO_OP_A 0x10d0
+
+#define EPIOWR_S    8
+#define EPIOWR_V(x) ((x) << EPIOWR_S)
+#define EPIOWR_F    EPIOWR_V(1U)
+
+#define ADDRESS_S    0
+#define ADDRESS_V(x) ((x) << ADDRESS_S)
+
+#define MAC_PORT_INT_CAUSE_A 0x8dc
+#define XGMAC_PORT_INT_CAUSE_A 0x10dc
+
+#define TP_TX_MOD_QUEUE_REQ_MAP_A 0x7e28
+
+#define TP_TX_MOD_QUEUE_WEIGHT0_A 0x7e30
+#define TP_TX_MOD_CHANNEL_WEIGHT_A 0x7e34
+
+#define TX_MOD_QUEUE_REQ_MAP_S    0
+#define TX_MOD_QUEUE_REQ_MAP_V(x) ((x) << TX_MOD_QUEUE_REQ_MAP_S)
+
+#define TX_MODQ_WEIGHT3_S    24
+#define TX_MODQ_WEIGHT3_V(x) ((x) << TX_MODQ_WEIGHT3_S)
+
+#define TX_MODQ_WEIGHT2_S    16
+#define TX_MODQ_WEIGHT2_V(x) ((x) << TX_MODQ_WEIGHT2_S)
+
+#define TX_MODQ_WEIGHT1_S    8
+#define TX_MODQ_WEIGHT1_V(x) ((x) << TX_MODQ_WEIGHT1_S)
+
+#define TX_MODQ_WEIGHT0_S    0
+#define TX_MODQ_WEIGHT0_V(x) ((x) << TX_MODQ_WEIGHT0_S)
+
+#define TP_TX_SCHED_HDR_A 0x23
+#define TP_TX_SCHED_FIFO_A 0x24
+#define TP_TX_SCHED_PCMD_A 0x25
 
 #define NUM_MPS_CLS_SRAM_L_INSTANCES 336
 #define NUM_MPS_T5_CLS_SRAM_L_INSTANCES 512
@@ -1329,62 +2566,149 @@
 #define MC_STRIDE (MC_1_BASE_ADDR - MC_0_BASE_ADDR)
 #define MC_REG(reg, idx) (reg + MC_STRIDE * idx)
 
-#define MC_P_BIST_CMD 0x41400
-#define MC_P_BIST_CMD_ADDR 0x41404
-#define MC_P_BIST_CMD_LEN 0x41408
-#define MC_P_BIST_DATA_PATTERN 0x4140c
-#define MC_P_BIST_STATUS_RDATA 0x41488
-#define EDC_T50_BASE_ADDR 0x50000
-#define EDC_H_BIST_CMD 0x50004
-#define EDC_H_BIST_CMD_ADDR 0x50008
-#define EDC_H_BIST_CMD_LEN 0x5000c
-#define EDC_H_BIST_DATA_PATTERN 0x50010
-#define EDC_H_BIST_STATUS_RDATA 0x50028
-
-#define EDC_T51_BASE_ADDR 0x50800
+#define MC_P_BIST_CMD_A                 0x41400
+#define MC_P_BIST_CMD_ADDR_A            0x41404
+#define MC_P_BIST_CMD_LEN_A             0x41408
+#define MC_P_BIST_DATA_PATTERN_A        0x4140c
+#define MC_P_BIST_STATUS_RDATA_A        0x41488
+
+#define EDC_T50_BASE_ADDR               0x50000
+
+#define EDC_H_BIST_CMD_A                0x50004
+#define EDC_H_BIST_CMD_ADDR_A           0x50008
+#define EDC_H_BIST_CMD_LEN_A            0x5000c
+#define EDC_H_BIST_DATA_PATTERN_A       0x50010
+#define EDC_H_BIST_STATUS_RDATA_A       0x50028
+
+#define EDC_T51_BASE_ADDR               0x50800
+
 #define EDC_STRIDE_T5 (EDC_T51_BASE_ADDR - EDC_T50_BASE_ADDR)
 #define EDC_REG_T5(reg, idx) (reg + EDC_STRIDE_T5 * idx)
 
-#define A_PL_VF_REV 0x4
-#define A_PL_VF_WHOAMI 0x0
-#define A_PL_VF_REVISION 0x8
+#define PL_VF_REV_A 0x4
+#define PL_VF_WHOAMI_A 0x0
+#define PL_VF_REVISION_A 0x8
 
-#define S_CHIPID    4
-#define M_CHIPID    0xfU
-#define V_CHIPID(x) ((x) << S_CHIPID)
-#define G_CHIPID(x) (((x) >> S_CHIPID) & M_CHIPID)
+/* registers for module CIM */
+#define CIM_HOST_ACC_CTRL_A     0x7b50
+#define CIM_HOST_ACC_DATA_A     0x7b54
+#define UP_UP_DBG_LA_CFG_A      0x140
+#define UP_UP_DBG_LA_DATA_A     0x144
 
-/* TP_VLAN_PRI_MAP controls which subset of fields will be present in the
- * Compressed Filter Tuple for LE filters.  Each bit set in TP_VLAN_PRI_MAP
- * selects for a particular field being present.  These fields, when present
- * in the Compressed Filter Tuple, have the following widths in bits.
- */
-#define W_FT_FCOE                       1
-#define W_FT_PORT                       3
-#define W_FT_VNIC_ID                    17
-#define W_FT_VLAN                       17
-#define W_FT_TOS                        8
-#define W_FT_PROTOCOL                   8
-#define W_FT_ETHERTYPE                  16
-#define W_FT_MACMATCH                   9
-#define W_FT_MPSHITTYPE                 3
-#define W_FT_FRAGMENTATION              1
-
-/* Some of the Compressed Filter Tuple fields have internal structure.  These
- * bit shifts/masks describe those structures.  All shifts are relative to the
- * base position of the fields within the Compressed Filter Tuple
- */
-#define S_FT_VLAN_VLD                   16
-#define V_FT_VLAN_VLD(x)                ((x) << S_FT_VLAN_VLD)
-#define F_FT_VLAN_VLD                   V_FT_VLAN_VLD(1U)
+#define HOSTBUSY_S      17
+#define HOSTBUSY_V(x)   ((x) << HOSTBUSY_S)
+#define HOSTBUSY_F      HOSTBUSY_V(1U)
+
+#define HOSTWRITE_S     16
+#define HOSTWRITE_V(x)  ((x) << HOSTWRITE_S)
+#define HOSTWRITE_F     HOSTWRITE_V(1U)
+
+#define CIM_IBQ_DBG_CFG_A 0x7b60
+
+#define IBQDBGADDR_S    16
+#define IBQDBGADDR_M    0xfffU
+#define IBQDBGADDR_V(x) ((x) << IBQDBGADDR_S)
+#define IBQDBGADDR_G(x) (((x) >> IBQDBGADDR_S) & IBQDBGADDR_M)
+
+#define IBQDBGBUSY_S    1
+#define IBQDBGBUSY_V(x) ((x) << IBQDBGBUSY_S)
+#define IBQDBGBUSY_F    IBQDBGBUSY_V(1U)
+
+#define IBQDBGEN_S    0
+#define IBQDBGEN_V(x) ((x) << IBQDBGEN_S)
+#define IBQDBGEN_F    IBQDBGEN_V(1U)
+
+#define CIM_OBQ_DBG_CFG_A 0x7b64
+
+#define OBQDBGADDR_S    16
+#define OBQDBGADDR_M    0xfffU
+#define OBQDBGADDR_V(x) ((x) << OBQDBGADDR_S)
+#define OBQDBGADDR_G(x) (((x) >> OBQDBGADDR_S) & OBQDBGADDR_M)
+
+#define OBQDBGBUSY_S    1
+#define OBQDBGBUSY_V(x) ((x) << OBQDBGBUSY_S)
+#define OBQDBGBUSY_F    OBQDBGBUSY_V(1U)
+
+#define OBQDBGEN_S    0
+#define OBQDBGEN_V(x) ((x) << OBQDBGEN_S)
+#define OBQDBGEN_F    OBQDBGEN_V(1U)
+
+#define CIM_IBQ_DBG_DATA_A 0x7b68
+#define CIM_OBQ_DBG_DATA_A 0x7b6c
+
+#define UPDBGLARDEN_S           1
+#define UPDBGLARDEN_V(x)        ((x) << UPDBGLARDEN_S)
+#define UPDBGLARDEN_F           UPDBGLARDEN_V(1U)
+
+#define UPDBGLAEN_S     0
+#define UPDBGLAEN_V(x)  ((x) << UPDBGLAEN_S)
+#define UPDBGLAEN_F     UPDBGLAEN_V(1U)
+
+#define UPDBGLARDPTR_S          2
+#define UPDBGLARDPTR_M          0xfffU
+#define UPDBGLARDPTR_V(x)       ((x) << UPDBGLARDPTR_S)
+
+#define UPDBGLAWRPTR_S    16
+#define UPDBGLAWRPTR_M    0xfffU
+#define UPDBGLAWRPTR_G(x) (((x) >> UPDBGLAWRPTR_S) & UPDBGLAWRPTR_M)
+
+#define UPDBGLACAPTPCONLY_S     30
+#define UPDBGLACAPTPCONLY_V(x)  ((x) << UPDBGLACAPTPCONLY_S)
+#define UPDBGLACAPTPCONLY_F     UPDBGLACAPTPCONLY_V(1U)
+
+#define CIM_QUEUE_CONFIG_REF_A 0x7b48
+#define CIM_QUEUE_CONFIG_CTRL_A 0x7b4c
+
+#define CIMQSIZE_S    24
+#define CIMQSIZE_M    0x3fU
+#define CIMQSIZE_G(x) (((x) >> CIMQSIZE_S) & CIMQSIZE_M)
+
+#define CIMQBASE_S    16
+#define CIMQBASE_M    0x3fU
+#define CIMQBASE_G(x) (((x) >> CIMQBASE_S) & CIMQBASE_M)
+
+#define QUEFULLTHRSH_S    0
+#define QUEFULLTHRSH_M    0x1ffU
+#define QUEFULLTHRSH_G(x) (((x) >> QUEFULLTHRSH_S) & QUEFULLTHRSH_M)
+
+#define UP_IBQ_0_RDADDR_A 0x10
+#define UP_IBQ_0_SHADOW_RDADDR_A 0x280
+#define UP_OBQ_0_REALADDR_A 0x104
+#define UP_OBQ_0_SHADOW_REALADDR_A 0x394
+
+#define IBQRDADDR_S    0
+#define IBQRDADDR_M    0x1fffU
+#define IBQRDADDR_G(x) (((x) >> IBQRDADDR_S) & IBQRDADDR_M)
+
+#define IBQWRADDR_S    0
+#define IBQWRADDR_M    0x1fffU
+#define IBQWRADDR_G(x) (((x) >> IBQWRADDR_S) & IBQWRADDR_M)
+
+#define QUERDADDR_S    0
+#define QUERDADDR_M    0x7fffU
+#define QUERDADDR_G(x) (((x) >> QUERDADDR_S) & QUERDADDR_M)
+
+#define QUEREMFLITS_S    0
+#define QUEREMFLITS_M    0x7ffU
+#define QUEREMFLITS_G(x) (((x) >> QUEREMFLITS_S) & QUEREMFLITS_M)
+
+#define QUEEOPCNT_S    16
+#define QUEEOPCNT_M    0xfffU
+#define QUEEOPCNT_G(x) (((x) >> QUEEOPCNT_S) & QUEEOPCNT_M)
+
+#define QUESOPCNT_S    0
+#define QUESOPCNT_M    0xfffU
+#define QUESOPCNT_G(x) (((x) >> QUESOPCNT_S) & QUESOPCNT_M)
 
-#define S_FT_VNID_ID_VF                 0
-#define V_FT_VNID_ID_VF(x)              ((x) << S_FT_VNID_ID_VF)
+#define OBQSELECT_S    4
+#define OBQSELECT_V(x) ((x) << OBQSELECT_S)
+#define OBQSELECT_F    OBQSELECT_V(1U)
 
-#define S_FT_VNID_ID_PF                 7
-#define V_FT_VNID_ID_PF(x)              ((x) << S_FT_VNID_ID_PF)
+#define IBQSELECT_S    3
+#define IBQSELECT_V(x) ((x) << IBQSELECT_S)
+#define IBQSELECT_F    IBQSELECT_V(1U)
 
-#define S_FT_VNID_ID_VLD                16
-#define V_FT_VNID_ID_VLD(x)             ((x) << S_FT_VNID_ID_VLD)
+#define QUENUMSELECT_S    0
+#define QUENUMSELECT_V(x) ((x) << QUENUMSELECT_S)
 
 #endif /* __T4_REGS_H */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_values.h b/drivers/net/ethernet/chelsio/cxgb4/t4_values.h
new file mode 100644
index 000000000000..19b2dcf6acde
--- /dev/null
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_values.h
@@ -0,0 +1,124 @@
+/*
+ * This file is part of the Chelsio T4 Ethernet driver for Linux.
+ *
+ * Copyright (c) 2003-2014 Chelsio Communications, Inc. All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef __T4_VALUES_H__
+#define __T4_VALUES_H__
+
+/* This file contains definitions for various T4 register value hardware
+ * constants.  The types of values encoded here are predominantly those for
+ * register fields which control "modal" behavior.  For the most part, we do
+ * not include definitions for register fields which are simple numeric
+ * metrics, etc.
+ */
+
+/* SGE register field values.
+ */
+
+/* CONTROL1 register */
+#define RXPKTCPLMODE_SPLIT_X            1
+
+#define INGPCIEBOUNDARY_SHIFT_X         5
+#define INGPCIEBOUNDARY_32B_X           0
+
+#define INGPADBOUNDARY_SHIFT_X          5
+
+/* CONTROL2 register */
+#define INGPACKBOUNDARY_SHIFT_X         5
+#define INGPACKBOUNDARY_16B_X           0
+
+/* GTS register */
+#define SGE_TIMERREGS                   6
+#define TIMERREG_COUNTER0_X             0
+
+/* T5 and later support a new BAR2-based doorbell mechanism for Egress Queues.
+ * The User Doorbells are each 128 bytes in length with a Simple Doorbell at
+ * offsets 8x and a Write Combining single 64-byte Egress Queue Unit
+ * (IDXSIZE_UNIT_X) Gather Buffer interface at offset 64.  For Ingress Queues,
+ * we have a Going To Sleep register at offsets 8x+4.
+ *
+ * As noted above, we have many instances of the Simple Doorbell and Going To
+ * Sleep registers at offsets 8x and 8x+4, respectively.  We want to use a
+ * non-64-byte aligned offset for the Simple Doorbell in order to attempt to
+ * avoid buffering of the writes to the Simple Doorbell and we want to use a
+ * non-contiguous offset for the Going To Sleep writes in order to avoid
+ * possible combining between them.
+ */
+#define SGE_UDB_SIZE            128
+#define SGE_UDB_KDOORBELL       8
+#define SGE_UDB_GTS             20
+#define SGE_UDB_WCDOORBELL      64
+
+/* CIM register field values.
+ */
+#define X_MBOWNER_FW                    1
+#define X_MBOWNER_PL                    2
+
+/* PCI-E definitions */
+#define WINDOW_SHIFT_X          10
+#define PCIEOFST_SHIFT_X        10
+
+/* TP_VLAN_PRI_MAP controls which subset of fields will be present in the
+ * Compressed Filter Tuple for LE filters.  Each bit set in TP_VLAN_PRI_MAP
+ * selects for a particular field being present.  These fields, when present
+ * in the Compressed Filter Tuple, have the following widths in bits.
+ */
+#define FT_FCOE_W                       1
+#define FT_PORT_W                       3
+#define FT_VNIC_ID_W                    17
+#define FT_VLAN_W                       17
+#define FT_TOS_W                        8
+#define FT_PROTOCOL_W                   8
+#define FT_ETHERTYPE_W                  16
+#define FT_MACMATCH_W                   9
+#define FT_MPSHITTYPE_W                 3
+#define FT_FRAGMENTATION_W              1
+
+/* Some of the Compressed Filter Tuple fields have internal structure.  These
+ * bit shifts/masks describe those structures.  All shifts are relative to the
+ * base position of the fields within the Compressed Filter Tuple
+ */
+#define FT_VLAN_VLD_S                   16
+#define FT_VLAN_VLD_V(x)                ((x) << FT_VLAN_VLD_S)
+#define FT_VLAN_VLD_F                   FT_VLAN_VLD_V(1U)
+
+#define FT_VNID_ID_VF_S                 0
+#define FT_VNID_ID_VF_V(x)              ((x) << FT_VNID_ID_VF_S)
+
+#define FT_VNID_ID_PF_S                 7
+#define FT_VNID_ID_PF_V(x)              ((x) << FT_VNID_ID_PF_S)
+
+#define FT_VNID_ID_VLD_S                16
+#define FT_VNID_ID_VLD_V(x)             ((x) << FT_VNID_ID_VLD_S)
+
+#endif /* __T4_VALUES_H__ */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
index 7c0aec85137a..9b353a88cbda 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
@@ -673,6 +673,7 @@ enum fw_cmd_opcodes {
         FW_RSS_IND_TBL_CMD             = 0x20,
         FW_RSS_GLB_CONFIG_CMD          = 0x22,
         FW_RSS_VI_CONFIG_CMD           = 0x23,
+        FW_DEVLOG_CMD                  = 0x25,
         FW_CLIP_CMD                    = 0x28,
         FW_LASTC2E_CMD                 = 0x40,
         FW_ERROR_CMD                   = 0x80,
@@ -1058,9 +1059,11 @@ enum fw_params_param_dev {
         FW_PARAMS_PARAM_DEV_FWREV = 0x0B,
         FW_PARAMS_PARAM_DEV_TPREV = 0x0C,
         FW_PARAMS_PARAM_DEV_CF = 0x0D,
+        FW_PARAMS_PARAM_DEV_DIAG = 0x11,
         FW_PARAMS_PARAM_DEV_MAXORDIRD_QP = 0x13, /* max supported QP IRD/ORD */
         FW_PARAMS_PARAM_DEV_MAXIRD_ADAPTER = 0x14, /* max supported adap IRD */
         FW_PARAMS_PARAM_DEV_ULPTX_MEMWRITE_DSGL = 0x17,
+        FW_PARAMS_PARAM_DEV_FWCACHE = 0x18,
 };
 
 /*
@@ -1120,6 +1123,16 @@ enum fw_params_param_dmaq {
         FW_PARAMS_PARAM_DMAQ_EQ_DCBPRIO_ETH = 0x13,
 };
 
+enum fw_params_param_dev_diag {
+        FW_PARAM_DEV_DIAG_TMP           = 0x00,
+        FW_PARAM_DEV_DIAG_VDD           = 0x01,
+};
+
+enum fw_params_param_dev_fwcache {
+        FW_PARAM_DEV_FWCACHE_FLUSH      = 0x00,
+        FW_PARAM_DEV_FWCACHE_FLUSHINV   = 0x01,
+};
+
 #define FW_PARAMS_MNEM_S        24
 #define FW_PARAMS_MNEM_V(x)     ((x) << FW_PARAMS_MNEM_S)
 
@@ -3005,21 +3018,29 @@ enum fw_hdr_chip {
 
 #define FW_HDR_FW_VER_MAJOR_S   24
 #define FW_HDR_FW_VER_MAJOR_M   0xff
+#define FW_HDR_FW_VER_MAJOR_V(x) \
+        ((x) << FW_HDR_FW_VER_MAJOR_S)
 #define FW_HDR_FW_VER_MAJOR_G(x) \
         (((x) >> FW_HDR_FW_VER_MAJOR_S) & FW_HDR_FW_VER_MAJOR_M)
 
 #define FW_HDR_FW_VER_MINOR_S   16
 #define FW_HDR_FW_VER_MINOR_M   0xff
+#define FW_HDR_FW_VER_MINOR_V(x) \
+        ((x) << FW_HDR_FW_VER_MINOR_S)
 #define FW_HDR_FW_VER_MINOR_G(x) \
         (((x) >> FW_HDR_FW_VER_MINOR_S) & FW_HDR_FW_VER_MINOR_M)
 
 #define FW_HDR_FW_VER_MICRO_S   8
 #define FW_HDR_FW_VER_MICRO_M   0xff
+#define FW_HDR_FW_VER_MICRO_V(x) \
+        ((x) << FW_HDR_FW_VER_MICRO_S)
 #define FW_HDR_FW_VER_MICRO_G(x) \
         (((x) >> FW_HDR_FW_VER_MICRO_S) & FW_HDR_FW_VER_MICRO_M)
 
 #define FW_HDR_FW_VER_BUILD_S   0
 #define FW_HDR_FW_VER_BUILD_M   0xff
+#define FW_HDR_FW_VER_BUILD_V(x) \
+        ((x) << FW_HDR_FW_VER_BUILD_S)
 #define FW_HDR_FW_VER_BUILD_G(x) \
         (((x) >> FW_HDR_FW_VER_BUILD_S) & FW_HDR_FW_VER_BUILD_M)
 
@@ -3038,4 +3059,84 @@ enum fw_hdr_flags {
         FW_HDR_FLAGS_RESET_HALT = 0x00000001,
 };
 
+/* length of the formatting string  */
+#define FW_DEVLOG_FMT_LEN       192
+
+/* maximum number of the formatting string parameters */
+#define FW_DEVLOG_FMT_PARAMS_NUM 8
+
+/* priority levels */
+enum fw_devlog_level {
+        FW_DEVLOG_LEVEL_EMERG   = 0x0,
+        FW_DEVLOG_LEVEL_CRIT    = 0x1,
+        FW_DEVLOG_LEVEL_ERR     = 0x2,
+        FW_DEVLOG_LEVEL_NOTICE  = 0x3,
+        FW_DEVLOG_LEVEL_INFO    = 0x4,
+        FW_DEVLOG_LEVEL_DEBUG   = 0x5,
+        FW_DEVLOG_LEVEL_MAX     = 0x5,
+};
+
+/* facilities that may send a log message */
+enum fw_devlog_facility {
+        FW_DEVLOG_FACILITY_CORE         = 0x00,
+        FW_DEVLOG_FACILITY_CF           = 0x01,
+        FW_DEVLOG_FACILITY_SCHED        = 0x02,
+        FW_DEVLOG_FACILITY_TIMER        = 0x04,
+        FW_DEVLOG_FACILITY_RES          = 0x06,
+        FW_DEVLOG_FACILITY_HW           = 0x08,
+        FW_DEVLOG_FACILITY_FLR          = 0x10,
+        FW_DEVLOG_FACILITY_DMAQ         = 0x12,
+        FW_DEVLOG_FACILITY_PHY          = 0x14,
+        FW_DEVLOG_FACILITY_MAC          = 0x16,
+        FW_DEVLOG_FACILITY_PORT         = 0x18,
+        FW_DEVLOG_FACILITY_VI           = 0x1A,
+        FW_DEVLOG_FACILITY_FILTER       = 0x1C,
+        FW_DEVLOG_FACILITY_ACL          = 0x1E,
+        FW_DEVLOG_FACILITY_TM           = 0x20,
+        FW_DEVLOG_FACILITY_QFC          = 0x22,
+        FW_DEVLOG_FACILITY_DCB          = 0x24,
+        FW_DEVLOG_FACILITY_ETH          = 0x26,
+        FW_DEVLOG_FACILITY_OFLD         = 0x28,
+        FW_DEVLOG_FACILITY_RI           = 0x2A,
+        FW_DEVLOG_FACILITY_ISCSI        = 0x2C,
+        FW_DEVLOG_FACILITY_FCOE         = 0x2E,
+        FW_DEVLOG_FACILITY_FOISCSI      = 0x30,
+        FW_DEVLOG_FACILITY_FOFCOE       = 0x32,
+        FW_DEVLOG_FACILITY_MAX          = 0x32,
+};
+
+/* log message format */
+struct fw_devlog_e {
+        __be64  timestamp;
+        __be32  seqno;
+        __be16  reserved1;
+        __u8    level;
+        __u8    facility;
+        __u8    fmt[FW_DEVLOG_FMT_LEN];
+        __be32  params[FW_DEVLOG_FMT_PARAMS_NUM];
+        __be32  reserved3[4];
+};
+
+struct fw_devlog_cmd {
+        __be32 op_to_write;
+        __be32 retval_len16;
+        __u8   level;
+        __u8   r2[7];
+        __be32 memtype_devlog_memaddr16_devlog;
+        __be32 memsize_devlog;
+        __be32 r3[2];
+};
+
+#define FW_DEVLOG_CMD_MEMTYPE_DEVLOG_S          28
+#define FW_DEVLOG_CMD_MEMTYPE_DEVLOG_M          0xf
+#define FW_DEVLOG_CMD_MEMTYPE_DEVLOG_G(x)       \
+        (((x) >> FW_DEVLOG_CMD_MEMTYPE_DEVLOG_S) & \
+         FW_DEVLOG_CMD_MEMTYPE_DEVLOG_M)
+
+#define FW_DEVLOG_CMD_MEMADDR16_DEVLOG_S        0
+#define FW_DEVLOG_CMD_MEMADDR16_DEVLOG_M        0xfffffff
+#define FW_DEVLOG_CMD_MEMADDR16_DEVLOG_G(x)     \
+        (((x) >> FW_DEVLOG_CMD_MEMADDR16_DEVLOG_S) & \
+         FW_DEVLOG_CMD_MEMADDR16_DEVLOG_M)
+
 #endif /* _T4FW_INTERFACE_H_ */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4fw_version.h b/drivers/net/ethernet/chelsio/cxgb4/t4fw_version.h
new file mode 100644
index 000000000000..e2bd3f747858
--- /dev/null
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4fw_version.h
@@ -0,0 +1,48 @@
+/*
+ * This file is part of the Chelsio T4 Ethernet driver for Linux.
+ *
+ * Copyright (c) 2003-2014 Chelsio Communications, Inc. All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef __T4FW_VERSION_H__
+#define __T4FW_VERSION_H__
+
+#define T4FW_VERSION_MAJOR 0x01
+#define T4FW_VERSION_MINOR 0x0C
+#define T4FW_VERSION_MICRO 0x19
+#define T4FW_VERSION_BUILD 0x00
+
+#define T5FW_VERSION_MAJOR 0x01
+#define T5FW_VERSION_MINOR 0x0C
+#define T5FW_VERSION_MICRO 0x19
+#define T5FW_VERSION_BUILD 0x00
+
+#endif
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
index a936ee8958c7..122e2964e63b 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
@@ -380,9 +380,9 @@ static void qenable(struct sge_rspq *rspq)
          * enable interrupts.
          */
         t4_write_reg(rspq->adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
-                     CIDXINC(0) |
-                     SEINTARM(rspq->intr_params) |
-                     INGRESSQID(rspq->cntxt_id));
+                     CIDXINC_V(0) |
+                     SEINTARM_V(rspq->intr_params) |
+                     INGRESSQID_V(rspq->cntxt_id));
 }
 
 /*
@@ -403,9 +403,9 @@ static void enable_rx(struct adapter *adapter)
          */
         if (adapter->flags & USING_MSI)
                 t4_write_reg(adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
-                             CIDXINC(0) |
-                             SEINTARM(s->intrq.intr_params) |
-                             INGRESSQID(s->intrq.cntxt_id));
+                             CIDXINC_V(0) |
+                             SEINTARM_V(s->intrq.intr_params) |
+                             INGRESSQID_V(s->intrq.cntxt_id));
 
 }
 
@@ -450,7 +450,7 @@ static int fwevtq_handler(struct sge_rspq *rspq, const __be64 *rsp,
                 /* FW can send EGR_UPDATEs encapsulated in a CPL_FW4_MSG.
                  */
                 const struct cpl_sge_egr_update *p = (void *)(rsp + 3);
-                opcode = G_CPL_OPCODE(ntohl(p->opcode_qid));
+                opcode = CPL_OPCODE_G(ntohl(p->opcode_qid));
                 if (opcode != CPL_SGE_EGR_UPDATE) {
                         dev_err(adapter->pdev_dev, "unexpected FW4/CPL %#x on FW event queue\n"
                                 , opcode);
@@ -471,7 +471,7 @@ static int fwevtq_handler(struct sge_rspq *rspq, const __be64 *rsp,
                  * free TX Queue Descriptors ...
                  */
                 const struct cpl_sge_egr_update *p = cpl;
-                unsigned int qid = EGR_QID(be32_to_cpu(p->opcode_qid));
+                unsigned int qid = EGR_QID_G(be32_to_cpu(p->opcode_qid));
                 struct sge *s = &adapter->sge;
                 struct sge_txq *tq;
                 struct sge_eth_txq *txq;
@@ -1673,7 +1673,7 @@ static void cxgb4vf_get_regs(struct net_device *dev,
         reg_block_dump(adapter, regbuf,
                        T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_FIRST,
                        T4VF_PL_BASE_ADDR + (is_t4(adapter->params.chip)
-                       ? A_PL_VF_WHOAMI : A_PL_VF_REVISION));
+                       ? PL_VF_WHOAMI_A : PL_VF_REVISION_A));
         reg_block_dump(adapter, regbuf,
                        T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_FIRST,
                        T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_LAST);
@@ -2294,26 +2294,22 @@ static int adap_init0(struct adapter *adapter)
          * threshold values from the SGE parameters.
          */
         s->timer_val[0] = core_ticks_to_us(adapter,
-                TIMERVALUE0_GET(sge_params->sge_timer_value_0_and_1));
+                TIMERVALUE0_G(sge_params->sge_timer_value_0_and_1));
         s->timer_val[1] = core_ticks_to_us(adapter,
-                TIMERVALUE1_GET(sge_params->sge_timer_value_0_and_1));
+                TIMERVALUE1_G(sge_params->sge_timer_value_0_and_1));
         s->timer_val[2] = core_ticks_to_us(adapter,
-                TIMERVALUE0_GET(sge_params->sge_timer_value_2_and_3));
+                TIMERVALUE0_G(sge_params->sge_timer_value_2_and_3));
         s->timer_val[3] = core_ticks_to_us(adapter,
-                TIMERVALUE1_GET(sge_params->sge_timer_value_2_and_3));
+                TIMERVALUE1_G(sge_params->sge_timer_value_2_and_3));
         s->timer_val[4] = core_ticks_to_us(adapter,
-                TIMERVALUE0_GET(sge_params->sge_timer_value_4_and_5));
+                TIMERVALUE0_G(sge_params->sge_timer_value_4_and_5));
         s->timer_val[5] = core_ticks_to_us(adapter,
-                TIMERVALUE1_GET(sge_params->sge_timer_value_4_and_5));
-
-        s->counter_val[0] =
-                THRESHOLD_0_GET(sge_params->sge_ingress_rx_threshold);
-        s->counter_val[1] =
-                THRESHOLD_1_GET(sge_params->sge_ingress_rx_threshold);
-        s->counter_val[2] =
-                THRESHOLD_2_GET(sge_params->sge_ingress_rx_threshold);
-        s->counter_val[3] =
-                THRESHOLD_3_GET(sge_params->sge_ingress_rx_threshold);
+                TIMERVALUE1_G(sge_params->sge_timer_value_4_and_5));
+
+        s->counter_val[0] = THRESHOLD_0_G(sge_params->sge_ingress_rx_threshold);
+        s->counter_val[1] = THRESHOLD_1_G(sge_params->sge_ingress_rx_threshold);
+        s->counter_val[2] = THRESHOLD_2_G(sge_params->sge_ingress_rx_threshold);
+        s->counter_val[3] = THRESHOLD_3_G(sge_params->sge_ingress_rx_threshold);
 
         /*
          * Grab our Virtual Interface resource allocation, extract the
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
index f7fd1317d996..0545f0de1c52 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
@@ -47,6 +47,7 @@
 #include "t4vf_defs.h"
 
 #include "../cxgb4/t4_regs.h"
+#include "../cxgb4/t4_values.h"
 #include "../cxgb4/t4fw_api.h"
 #include "../cxgb4/t4_msg.h"
 
@@ -531,11 +532,11 @@ static inline void ring_fl_db(struct adapter *adapter, struct sge_fl *fl)
          */
         if (fl->pend_cred >= FL_PER_EQ_UNIT) {
                 if (is_t4(adapter->params.chip))
-                        val = PIDX(fl->pend_cred / FL_PER_EQ_UNIT);
+                        val = PIDX_V(fl->pend_cred / FL_PER_EQ_UNIT);
                 else
-                        val = PIDX_T5(fl->pend_cred / FL_PER_EQ_UNIT) |
-                              DBTYPE(1);
-                val |= DBPRIO(1);
+                        val = PIDX_T5_V(fl->pend_cred / FL_PER_EQ_UNIT) |
+                              DBTYPE_F;
+                val |= DBPRIO_F;
 
                 /* Make sure all memory writes to the Free List queue are
                  * committed before we tell the hardware about them.
@@ -549,9 +550,9 @@ static inline void ring_fl_db(struct adapter *adapter, struct sge_fl *fl)
                 if (unlikely(fl->bar2_addr == NULL)) {
                         t4_write_reg(adapter,
                                      T4VF_SGE_BASE_ADDR + SGE_VF_KDOORBELL,
-                                     QID(fl->cntxt_id) | val);
+                                     QID_V(fl->cntxt_id) | val);
                 } else {
-                        writel(val | QID(fl->bar2_qid),
+                        writel(val | QID_V(fl->bar2_qid),
                                fl->bar2_addr + SGE_UDB_KDOORBELL);
 
                         /* This Write memory Barrier will force the write to
@@ -925,7 +926,7 @@ static void write_sgl(const struct sk_buff *skb, struct sge_txq *tq,
         }
 
         sgl->cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) |
-                              ULPTX_NSGE(nfrags));
+                              ULPTX_NSGE_V(nfrags));
         if (likely(--nfrags == 0))
                 return;
         /*
@@ -979,12 +980,12 @@ static inline void ring_tx_db(struct adapter *adapter, struct sge_txq *tq,
          * doorbell mechanism; otherwise use the new BAR2 mechanism.
          */
         if (unlikely(tq->bar2_addr == NULL)) {
-                u32 val = PIDX(n);
+                u32 val = PIDX_V(n);
 
                 t4_write_reg(adapter, T4VF_SGE_BASE_ADDR + SGE_VF_KDOORBELL,
-                             QID(tq->cntxt_id) | val);
+                             QID_V(tq->cntxt_id) | val);
         } else {
-                u32 val = PIDX_T5(n);
+                u32 val = PIDX_T5_V(n);
 
                 /* T4 and later chips share the same PIDX field offset within
                  * the doorbell, but T5 and later shrank the field in order to
@@ -992,7 +993,7 @@ static inline void ring_tx_db(struct adapter *adapter, struct sge_txq *tq,
                  * large in the first place (14 bits) so we just use the T5
                  * and later limits and warn if a Queue ID is too large.
                  */
-                WARN_ON(val & DBPRIO(1));
+                WARN_ON(val & DBPRIO_F);
 
                 /* If we're only writing a single Egress Unit and the BAR2
                  * Queue ID is 0, we can use the Write Combining Doorbell
@@ -1023,7 +1024,7 @@ static inline void ring_tx_db(struct adapter *adapter, struct sge_txq *tq,
                                 count--;
                         }
                 } else
-                        writel(val | QID(tq->bar2_qid),
+                        writel(val | QID_V(tq->bar2_qid),
                                tq->bar2_addr + SGE_UDB_KDOORBELL);
 
                 /* This Write Memory Barrier will force the write to the User
@@ -1325,9 +1326,9 @@ int t4vf_eth_xmit(struct sk_buff *skb, struct net_device *dev)
          * If there's a VLAN tag present, add that to the list of things to
          * do in this Work Request.
          */
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 txq->vlan_ins++;
-                cntrl |= TXPKT_VLAN_VLD | TXPKT_VLAN(vlan_tx_tag_get(skb));
+                cntrl |= TXPKT_VLAN_VLD | TXPKT_VLAN(skb_vlan_tag_get(skb));
         }
 
         /*
@@ -1603,7 +1604,7 @@ int t4vf_ethrx_handler(struct sge_rspq *rspq, const __be64 *rsp,
          * If this is a good TCP packet and we have Generic Receive Offload
          * enabled, handle the packet in the GRO path.
          */
-        if ((pkt->l2info & cpu_to_be32(RXF_TCP)) &&
+        if ((pkt->l2info & cpu_to_be32(RXF_TCP_F)) &&
             (rspq->netdev->features & NETIF_F_GRO) && csum_ok &&
             !pkt->ip_frag) {
                 do_gro(rxq, gl, pkt);
@@ -1625,7 +1626,7 @@ int t4vf_ethrx_handler(struct sge_rspq *rspq, const __be64 *rsp,
         rxq->stats.pkts++;
 
         if (csum_ok && !pkt->err_vec &&
-            (be32_to_cpu(pkt->l2info) & (RXF_UDP|RXF_TCP))) {
+            (be32_to_cpu(pkt->l2info) & (RXF_UDP_F | RXF_TCP_F))) {
                 if (!pkt->ip_frag)
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
                 else {
@@ -1875,13 +1876,13 @@ static int napi_rx_handler(struct napi_struct *napi, int budget)
         if (unlikely(work_done == 0))
                 rspq->unhandled_irqs++;
 
-        val = CIDXINC(work_done) | SEINTARM(intr_params);
+        val = CIDXINC_V(work_done) | SEINTARM_V(intr_params);
         if (is_t4(rspq->adapter->params.chip)) {
                 t4_write_reg(rspq->adapter,
                              T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
-                             val | INGRESSQID((u32)rspq->cntxt_id));
+                             val | INGRESSQID_V((u32)rspq->cntxt_id));
         } else {
-                writel(val | INGRESSQID(rspq->bar2_qid),
+                writel(val | INGRESSQID_V(rspq->bar2_qid),
                        rspq->bar2_addr + SGE_UDB_GTS);
                 wmb();
         }
@@ -1975,12 +1976,12 @@ static unsigned int process_intrq(struct adapter *adapter)
                 rspq_next(intrq);
         }
 
-        val = CIDXINC(work_done) | SEINTARM(intrq->intr_params);
+        val = CIDXINC_V(work_done) | SEINTARM_V(intrq->intr_params);
         if (is_t4(adapter->params.chip))
                 t4_write_reg(adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
-                             val | INGRESSQID(intrq->cntxt_id));
+                             val | INGRESSQID_V(intrq->cntxt_id));
         else {
-                writel(val | INGRESSQID(intrq->bar2_qid),
+                writel(val | INGRESSQID_V(intrq->bar2_qid),
                        intrq->bar2_addr + SGE_UDB_GTS);
                 wmb();
         }
@@ -2583,7 +2584,7 @@ int t4vf_sge_init(struct adapter *adapter)
                         fl0, fl1);
                 return -EINVAL;
         }
-        if ((sge_params->sge_control & RXPKTCPLMODE_MASK) == 0) {
+        if ((sge_params->sge_control & RXPKTCPLMODE_F) == 0) {
                 dev_err(adapter->pdev_dev, "bad SGE CPL MODE\n");
                 return -EINVAL;
         }
@@ -2593,9 +2594,9 @@ int t4vf_sge_init(struct adapter *adapter)
          */
         if (fl1)
                 s->fl_pg_order = ilog2(fl1) - PAGE_SHIFT;
-        s->stat_len = ((sge_params->sge_control & EGRSTATUSPAGESIZE_MASK)
+        s->stat_len = ((sge_params->sge_control & EGRSTATUSPAGESIZE_F)
                         ? 128 : 64);
-        s->pktshift = PKTSHIFT_GET(sge_params->sge_control);
+        s->pktshift = PKTSHIFT_G(sge_params->sge_control);
 
         /* T4 uses a single control field to specify both the PCIe Padding and
          * Packing Boundary.  T5 introduced the ability to specify these
@@ -2607,8 +2608,8 @@ int t4vf_sge_init(struct adapter *adapter)
          * end doing this because it would initialize the Padding Boundary and
          * leave the Packing Boundary initialized to 0 (16 bytes).)
          */
-        ingpadboundary = 1 << (INGPADBOUNDARY_GET(sge_params->sge_control) +
-                               X_INGPADBOUNDARY_SHIFT);
+        ingpadboundary = 1 << (INGPADBOUNDARY_G(sge_params->sge_control) +
+                               INGPADBOUNDARY_SHIFT_X);
         if (is_t4(adapter->params.chip)) {
                 s->fl_align = ingpadboundary;
         } else {
@@ -2633,7 +2634,7 @@ int t4vf_sge_init(struct adapter *adapter)
          * Congestion Threshold is in units of 2 Free List pointers.)
          */
         s->fl_starve_thres
-                = EGRTHRESHOLD_GET(sge_params->sge_congestion_control)*2 + 1;
+                = EGRTHRESHOLD_G(sge_params->sge_congestion_control)*2 + 1;
 
         /*
          * Set up tasklet timers.
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_defs.h b/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_defs.h
index c7b127d93767..b516b12b1884 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_defs.h
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_defs.h
@@ -64,8 +64,8 @@
  * Mailbox Data in the fixed CIM PF map and the programmable VF map must
  * match.  However, it's a useful convention ...
  */
-#if T4VF_MBDATA_BASE_ADDR != CIM_PF_MAILBOX_DATA
-#error T4VF_MBDATA_BASE_ADDR must match CIM_PF_MAILBOX_DATA!
+#if T4VF_MBDATA_BASE_ADDR != CIM_PF_MAILBOX_DATA_A
+#error T4VF_MBDATA_BASE_ADDR must match CIM_PF_MAILBOX_DATA_A!
 #endif
 
 /*
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c b/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c
index 60426cf890a7..1b5506df35b1 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c
@@ -39,6 +39,7 @@
 #include "t4vf_defs.h"
 
 #include "../cxgb4/t4_regs.h"
+#include "../cxgb4/t4_values.h"
 #include "../cxgb4/t4fw_api.h"
 
 /*
@@ -137,9 +138,9 @@ int t4vf_wr_mbox_core(struct adapter *adapter, const void *cmd, int size,
          * Loop trying to get ownership of the mailbox.  Return an error
          * if we can't gain ownership.
          */
-        v = MBOWNER_GET(t4_read_reg(adapter, mbox_ctl));
+        v = MBOWNER_G(t4_read_reg(adapter, mbox_ctl));
         for (i = 0; v == MBOX_OWNER_NONE && i < 3; i++)
-                v = MBOWNER_GET(t4_read_reg(adapter, mbox_ctl));
+                v = MBOWNER_G(t4_read_reg(adapter, mbox_ctl));
         if (v != MBOX_OWNER_DRV)
                 return v == MBOX_OWNER_FW ? -EBUSY : -ETIMEDOUT;
 
@@ -161,7 +162,7 @@ int t4vf_wr_mbox_core(struct adapter *adapter, const void *cmd, int size,
         t4_read_reg(adapter, mbox_data);         /* flush write */
 
         t4_write_reg(adapter, mbox_ctl,
-                     MBMSGVALID | MBOWNER(MBOX_OWNER_FW));
+                     MBMSGVALID_F | MBOWNER_V(MBOX_OWNER_FW));
         t4_read_reg(adapter, mbox_ctl);          /* flush write */
 
         /*
@@ -183,14 +184,14 @@ int t4vf_wr_mbox_core(struct adapter *adapter, const void *cmd, int size,
                  * If we're the owner, see if this is the reply we wanted.
                  */
                 v = t4_read_reg(adapter, mbox_ctl);
-                if (MBOWNER_GET(v) == MBOX_OWNER_DRV) {
+                if (MBOWNER_G(v) == MBOX_OWNER_DRV) {
                         /*
                          * If the Message Valid bit isn't on, revoke ownership
                          * of the mailbox and continue waiting for our reply.
                          */
-                        if ((v & MBMSGVALID) == 0) {
+                        if ((v & MBMSGVALID_F) == 0) {
                                 t4_write_reg(adapter, mbox_ctl,
-                                             MBOWNER(MBOX_OWNER_NONE));
+                                             MBOWNER_V(MBOX_OWNER_NONE));
                                 continue;
                         }
 
@@ -216,7 +217,7 @@ int t4vf_wr_mbox_core(struct adapter *adapter, const void *cmd, int size,
                                          & FW_CMD_REQUEST_F) != 0);
                         }
                         t4_write_reg(adapter, mbox_ctl,
-                                     MBOWNER(MBOX_OWNER_NONE));
+                                     MBOWNER_V(MBOX_OWNER_NONE));
                         return -FW_CMD_RETVAL_G(v);
                 }
         }
@@ -530,19 +531,19 @@ int t4vf_get_sge_params(struct adapter *adapter)
         int v;
 
         params[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
-                     FW_PARAMS_PARAM_XYZ_V(SGE_CONTROL));
+                     FW_PARAMS_PARAM_XYZ_V(SGE_CONTROL_A));
         params[1] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
-                     FW_PARAMS_PARAM_XYZ_V(SGE_HOST_PAGE_SIZE));
+                     FW_PARAMS_PARAM_XYZ_V(SGE_HOST_PAGE_SIZE_A));
         params[2] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
-                     FW_PARAMS_PARAM_XYZ_V(SGE_FL_BUFFER_SIZE0));
+                     FW_PARAMS_PARAM_XYZ_V(SGE_FL_BUFFER_SIZE0_A));
         params[3] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
-                     FW_PARAMS_PARAM_XYZ_V(SGE_FL_BUFFER_SIZE1));
+                     FW_PARAMS_PARAM_XYZ_V(SGE_FL_BUFFER_SIZE1_A));
         params[4] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
-                     FW_PARAMS_PARAM_XYZ_V(SGE_TIMER_VALUE_0_AND_1));
+                     FW_PARAMS_PARAM_XYZ_V(SGE_TIMER_VALUE_0_AND_1_A));
         params[5] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
-                     FW_PARAMS_PARAM_XYZ_V(SGE_TIMER_VALUE_2_AND_3));
+                     FW_PARAMS_PARAM_XYZ_V(SGE_TIMER_VALUE_2_AND_3_A));
         params[6] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
-                     FW_PARAMS_PARAM_XYZ_V(SGE_TIMER_VALUE_4_AND_5));
+                     FW_PARAMS_PARAM_XYZ_V(SGE_TIMER_VALUE_4_AND_5_A));
         v = t4vf_query_params(adapter, 7, params, vals);
         if (v)
                 return v;
@@ -578,9 +579,9 @@ int t4vf_get_sge_params(struct adapter *adapter)
         }
 
         params[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
-                     FW_PARAMS_PARAM_XYZ_V(SGE_INGRESS_RX_THRESHOLD));
+                     FW_PARAMS_PARAM_XYZ_V(SGE_INGRESS_RX_THRESHOLD_A));
         params[1] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
-                     FW_PARAMS_PARAM_XYZ_V(SGE_CONM_CTRL));
+                     FW_PARAMS_PARAM_XYZ_V(SGE_CONM_CTRL_A));
         v = t4vf_query_params(adapter, 2, params, vals);
         if (v)
                 return v;
@@ -617,8 +618,8 @@ int t4vf_get_sge_params(struct adapter *adapter)
                  * the driver can just use it.
                  */
                 whoami = t4_read_reg(adapter,
-                                     T4VF_PL_BASE_ADDR + A_PL_VF_WHOAMI);
-                pf = SOURCEPF_GET(whoami);
+                                     T4VF_PL_BASE_ADDR + PL_VF_WHOAMI_A);
+                pf = SOURCEPF_G(whoami);
 
                 s_hps = (HOSTPAGESIZEPF0_S +
                          (HOSTPAGESIZEPF1_S - HOSTPAGESIZEPF0_S) * pf);
@@ -630,10 +631,10 @@ int t4vf_get_sge_params(struct adapter *adapter)
                          (QUEUESPERPAGEPF1_S - QUEUESPERPAGEPF0_S) * pf);
                 sge_params->sge_vf_eq_qpp =
                         ((sge_params->sge_egress_queues_per_page >> s_qpp)
-                         & QUEUESPERPAGEPF0_MASK);
+                         & QUEUESPERPAGEPF0_M);
                 sge_params->sge_vf_iq_qpp =
                         ((sge_params->sge_ingress_queues_per_page >> s_qpp)
-                         & QUEUESPERPAGEPF0_MASK);
+                         & QUEUESPERPAGEPF0_M);
         }
 
         return 0;
@@ -1592,7 +1593,7 @@ int t4vf_prep_adapter(struct adapter *adapter)
                 break;
 
         case CHELSIO_T5:
-                chipid = G_REV(t4_read_reg(adapter, A_PL_VF_REV));
+                chipid = REV_G(t4_read_reg(adapter, PL_VF_REV_A));
                 adapter->params.chip |= CHELSIO_CHIP_CODE(CHELSIO_T5, chipid);
                 break;
         }
diff --git a/drivers/net/ethernet/cirrus/ep93xx_eth.c b/drivers/net/ethernet/cirrus/ep93xx_eth.c
index 3a12c096ea1c..de9f7c97d916 100644
--- a/drivers/net/ethernet/cirrus/ep93xx_eth.c
+++ b/drivers/net/ethernet/cirrus/ep93xx_eth.c
@@ -475,8 +475,7 @@ static void ep93xx_free_buffers(struct ep93xx_priv *ep)
                 if (d)
                         dma_unmap_single(dev, d, PKT_BUF_SIZE, DMA_FROM_DEVICE);
 
-                if (ep->rx_buf[i] != NULL)
-                        kfree(ep->rx_buf[i]);
+                kfree(ep->rx_buf[i]);
         }
 
         for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
@@ -486,8 +485,7 @@ static void ep93xx_free_buffers(struct ep93xx_priv *ep)
                 if (d)
                         dma_unmap_single(dev, d, PKT_BUF_SIZE, DMA_TO_DEVICE);
 
-                if (ep->tx_buf[i] != NULL)
-                        kfree(ep->tx_buf[i]);
+                kfree(ep->tx_buf[i]);
         }
 
         dma_free_coherent(dev, sizeof(struct ep93xx_descs), ep->descs,
diff --git a/drivers/net/ethernet/cisco/enic/enic.h b/drivers/net/ethernet/cisco/enic/enic.h
index 25c4d88853d8..84b6a2b46aec 100644
--- a/drivers/net/ethernet/cisco/enic/enic.h
+++ b/drivers/net/ethernet/cisco/enic/enic.h
@@ -33,7 +33,7 @@
 
 #define DRV_NAME                "enic"
 #define DRV_DESCRIPTION         "Cisco VIC Ethernet NIC Driver"
-#define DRV_VERSION             "2.1.1.67"
+#define DRV_VERSION             "2.1.1.83"
 #define DRV_COPYRIGHT           "Copyright 2008-2013 Cisco Systems, Inc"
 
 #define ENIC_BARS_MAX           6
@@ -188,6 +188,7 @@ struct enic {
         struct enic_rfs_flw_tbl rfs_h;
         u32 rx_copybreak;
         u8 rss_key[ENIC_RSS_LEN];
+        struct vnic_gen_stats gen_stats;
 };
 
 static inline struct device *enic_get_dev(struct enic *enic)
@@ -242,6 +243,19 @@ static inline unsigned int enic_msix_notify_intr(struct enic *enic)
         return enic->rq_count + enic->wq_count + 1;
 }
 
+static inline int enic_dma_map_check(struct enic *enic, dma_addr_t dma_addr)
+{
+        if (unlikely(pci_dma_mapping_error(enic->pdev, dma_addr))) {
+                net_warn_ratelimited("%s: PCI dma mapping failed!\n",
+                                     enic->netdev->name);
+                enic->gen_stats.dma_map_error++;
+
+                return -ENOMEM;
+        }
+
+        return 0;
+}
+
 void enic_reset_addr_lists(struct enic *enic);
 int enic_sriov_enabled(struct enic *enic);
 int enic_is_valid_vf(struct enic *enic, int vf);
diff --git a/drivers/net/ethernet/cisco/enic/enic_dev.c b/drivers/net/ethernet/cisco/enic/enic_dev.c
index 87ddc44b590e..f8d2a6a34282 100644
--- a/drivers/net/ethernet/cisco/enic/enic_dev.c
+++ b/drivers/net/ethernet/cisco/enic/enic_dev.c
@@ -177,40 +177,6 @@ int enic_dev_intr_coal_timer_info(struct enic *enic)
         return err;
 }
 
-int enic_vnic_dev_deinit(struct enic *enic)
-{
-        int err;
-
-        spin_lock_bh(&enic->devcmd_lock);
-        err = vnic_dev_deinit(enic->vdev);
-        spin_unlock_bh(&enic->devcmd_lock);
-
-        return err;
-}
-
-int enic_dev_init_prov2(struct enic *enic, struct vic_provinfo *vp)
-{
-        int err;
-
-        spin_lock_bh(&enic->devcmd_lock);
-        err = vnic_dev_init_prov2(enic->vdev,
-                (u8 *)vp, vic_provinfo_size(vp));
-        spin_unlock_bh(&enic->devcmd_lock);
-
-        return err;
-}
-
-int enic_dev_deinit_done(struct enic *enic, int *status)
-{
-        int err;
-
-        spin_lock_bh(&enic->devcmd_lock);
-        err = vnic_dev_deinit_done(enic->vdev, status);
-        spin_unlock_bh(&enic->devcmd_lock);
-
-        return err;
-}
-
 /* rtnl lock is held */
 int enic_vlan_rx_add_vid(struct net_device *netdev, __be16 proto, u16 vid)
 {
@@ -237,28 +203,6 @@ int enic_vlan_rx_kill_vid(struct net_device *netdev, __be16 proto, u16 vid)
         return err;
 }
 
-int enic_dev_enable2(struct enic *enic, int active)
-{
-        int err;
-
-        spin_lock_bh(&enic->devcmd_lock);
-        err = vnic_dev_enable2(enic->vdev, active);
-        spin_unlock_bh(&enic->devcmd_lock);
-
-        return err;
-}
-
-int enic_dev_enable2_done(struct enic *enic, int *status)
-{
-        int err;
-
-        spin_lock_bh(&enic->devcmd_lock);
-        err = vnic_dev_enable2_done(enic->vdev, status);
-        spin_unlock_bh(&enic->devcmd_lock);
-
-        return err;
-}
-
 int enic_dev_status_to_errno(int devcmd_status)
 {
         switch (devcmd_status) {
diff --git a/drivers/net/ethernet/cisco/enic/enic_dev.h b/drivers/net/ethernet/cisco/enic/enic_dev.h
index 10bb970b2f35..f5bb058b3f96 100644
--- a/drivers/net/ethernet/cisco/enic/enic_dev.h
+++ b/drivers/net/ethernet/cisco/enic/enic_dev.h
@@ -55,11 +55,6 @@ int enic_dev_set_ig_vlan_rewrite_mode(struct enic *enic);
 int enic_dev_enable(struct enic *enic);
 int enic_dev_disable(struct enic *enic);
 int enic_dev_intr_coal_timer_info(struct enic *enic);
-int enic_vnic_dev_deinit(struct enic *enic);
-int enic_dev_init_prov2(struct enic *enic, struct vic_provinfo *vp);
-int enic_dev_deinit_done(struct enic *enic, int *status);
-int enic_dev_enable2(struct enic *enic, int arg);
-int enic_dev_enable2_done(struct enic *enic, int *status);
 int enic_dev_status_to_errno(int devcmd_status);
 
 #endif /* _ENIC_DEV_H_ */
diff --git a/drivers/net/ethernet/cisco/enic/enic_ethtool.c b/drivers/net/ethernet/cisco/enic/enic_ethtool.c
index eba1eb846d34..28d9ca675a27 100644
--- a/drivers/net/ethernet/cisco/enic/enic_ethtool.c
+++ b/drivers/net/ethernet/cisco/enic/enic_ethtool.c
@@ -24,6 +24,7 @@
 #include "enic_dev.h"
 #include "enic_clsf.h"
 #include "vnic_rss.h"
+#include "vnic_stats.h"
 
 struct enic_stat {
         char name[ETH_GSTRING_LEN];
@@ -40,6 +41,11 @@ struct enic_stat {
         .index = offsetof(struct vnic_rx_stats, stat) / sizeof(u64) \
 }
 
+#define ENIC_GEN_STAT(stat) { \
+        .name = #stat, \
+        .index = offsetof(struct vnic_gen_stats, stat) / sizeof(u64)\
+}
+
 static const struct enic_stat enic_tx_stats[] = {
         ENIC_TX_STAT(tx_frames_ok),
         ENIC_TX_STAT(tx_unicast_frames_ok),
@@ -78,10 +84,15 @@ static const struct enic_stat enic_rx_stats[] = {
         ENIC_RX_STAT(rx_frames_to_max),
 };
 
+static const struct enic_stat enic_gen_stats[] = {
+        ENIC_GEN_STAT(dma_map_error),
+};
+
 static const unsigned int enic_n_tx_stats = ARRAY_SIZE(enic_tx_stats);
 static const unsigned int enic_n_rx_stats = ARRAY_SIZE(enic_rx_stats);
+static const unsigned int enic_n_gen_stats = ARRAY_SIZE(enic_gen_stats);
 
-void enic_intr_coal_set_rx(struct enic *enic, u32 timer)
+static void enic_intr_coal_set_rx(struct enic *enic, u32 timer)
 {
         int i;
         int intr;
@@ -146,6 +157,10 @@ static void enic_get_strings(struct net_device *netdev, u32 stringset,
                         memcpy(data, enic_rx_stats[i].name, ETH_GSTRING_LEN);
                         data += ETH_GSTRING_LEN;
                 }
+                for (i = 0; i < enic_n_gen_stats; i++) {
+                        memcpy(data, enic_gen_stats[i].name, ETH_GSTRING_LEN);
+                        data += ETH_GSTRING_LEN;
+                }
                 break;
         }
 }
@@ -154,7 +169,7 @@ static int enic_get_sset_count(struct net_device *netdev, int sset)
 {
         switch (sset) {
         case ETH_SS_STATS:
-                return enic_n_tx_stats + enic_n_rx_stats;
+                return enic_n_tx_stats + enic_n_rx_stats + enic_n_gen_stats;
         default:
                 return -EOPNOTSUPP;
         }
@@ -173,6 +188,8 @@ static void enic_get_ethtool_stats(struct net_device *netdev,
                 *(data++) = ((u64 *)&vstats->tx)[enic_tx_stats[i].index];
         for (i = 0; i < enic_n_rx_stats; i++)
                 *(data++) = ((u64 *)&vstats->rx)[enic_rx_stats[i].index];
+        for (i = 0; i < enic_n_gen_stats; i++)
+                *(data++) = ((u64 *)&enic->gen_stats)[enic_gen_stats[i].index];
 }
 
 static u32 enic_get_msglevel(struct net_device *netdev)
diff --git a/drivers/net/ethernet/cisco/enic/enic_main.c b/drivers/net/ethernet/cisco/enic/enic_main.c
index e356afa44e7d..9cbe038a388e 100644
--- a/drivers/net/ethernet/cisco/enic/enic_main.c
+++ b/drivers/net/ethernet/cisco/enic/enic_main.c
@@ -45,6 +45,7 @@
 #ifdef CONFIG_NET_RX_BUSY_POLL
 #include <net/busy_poll.h>
 #endif
+#include <linux/crash_dump.h>
 
 #include "cq_enet_desc.h"
 #include "vnic_dev.h"
@@ -88,7 +89,7 @@ MODULE_DEVICE_TABLE(pci, enic_id_table);
  *  coalescing timer values
  *  {rx_rate in Mbps, mapping percentage of the range}
  */
-struct enic_intr_mod_table mod_table[ENIC_MAX_COALESCE_TIMERS + 1] = {
+static struct enic_intr_mod_table mod_table[ENIC_MAX_COALESCE_TIMERS + 1] = {
         {4000,  0},
         {4400, 10},
         {5060, 20},
@@ -105,7 +106,7 @@ struct enic_intr_mod_table mod_table[ENIC_MAX_COALESCE_TIMERS + 1] = {
 /* This table helps the driver to pick different ranges for rx coalescing
  * timer depending on the link speed.
  */
-struct enic_intr_mod_range mod_range[ENIC_MAX_LINK_SPEEDS] = {
+static struct enic_intr_mod_range mod_range[ENIC_MAX_LINK_SPEEDS] = {
         {0,  0}, /* 0  - 4  Gbps */
         {0,  3}, /* 4  - 10 Gbps */
         {3,  6}, /* 10 - 40 Gbps */
@@ -351,80 +352,94 @@ static irqreturn_t enic_isr_msix_notify(int irq, void *data)
         return IRQ_HANDLED;
 }
 
-static inline void enic_queue_wq_skb_cont(struct enic *enic,
-        struct vnic_wq *wq, struct sk_buff *skb,
-        unsigned int len_left, int loopback)
+static int enic_queue_wq_skb_cont(struct enic *enic, struct vnic_wq *wq,
+                                  struct sk_buff *skb, unsigned int len_left,
+                                  int loopback)
 {
         const skb_frag_t *frag;
+        dma_addr_t dma_addr;
 
         /* Queue additional data fragments */
         for (frag = skb_shinfo(skb)->frags; len_left; frag++) {
                 len_left -= skb_frag_size(frag);
-                enic_queue_wq_desc_cont(wq, skb,
-                        skb_frag_dma_map(&enic->pdev->dev,
-                                         frag, 0, skb_frag_size(frag),
-                                         DMA_TO_DEVICE),
-                        skb_frag_size(frag),
-                        (len_left == 0),        /* EOP? */
-                        loopback);
+                dma_addr = skb_frag_dma_map(&enic->pdev->dev, frag, 0,
+                                            skb_frag_size(frag),
+                                            DMA_TO_DEVICE);
+                if (unlikely(enic_dma_map_check(enic, dma_addr)))
+                        return -ENOMEM;
+                enic_queue_wq_desc_cont(wq, skb, dma_addr, skb_frag_size(frag),
+                                        (len_left == 0),        /* EOP? */
+                                        loopback);
         }
+
+        return 0;
 }
 
-static inline void enic_queue_wq_skb_vlan(struct enic *enic,
-        struct vnic_wq *wq, struct sk_buff *skb,
-        int vlan_tag_insert, unsigned int vlan_tag, int loopback)
+static int enic_queue_wq_skb_vlan(struct enic *enic, struct vnic_wq *wq,
+                                  struct sk_buff *skb, int vlan_tag_insert,
+                                  unsigned int vlan_tag, int loopback)
 {
         unsigned int head_len = skb_headlen(skb);
         unsigned int len_left = skb->len - head_len;
         int eop = (len_left == 0);
+        dma_addr_t dma_addr;
+        int err = 0;
+
+        dma_addr = pci_map_single(enic->pdev, skb->data, head_len,
+                                  PCI_DMA_TODEVICE);
+        if (unlikely(enic_dma_map_check(enic, dma_addr)))
+                return -ENOMEM;
 
         /* Queue the main skb fragment. The fragments are no larger
          * than max MTU(9000)+ETH_HDR_LEN(14) bytes, which is less
          * than WQ_ENET_MAX_DESC_LEN length. So only one descriptor
          * per fragment is queued.
          */
-        enic_queue_wq_desc(wq, skb,
-                pci_map_single(enic->pdev, skb->data,
-                        head_len, PCI_DMA_TODEVICE),
-                head_len,
-                vlan_tag_insert, vlan_tag,
-                eop, loopback);
+        enic_queue_wq_desc(wq, skb, dma_addr, head_len, vlan_tag_insert,
+                           vlan_tag, eop, loopback);
 
         if (!eop)
-                enic_queue_wq_skb_cont(enic, wq, skb, len_left, loopback);
+                err = enic_queue_wq_skb_cont(enic, wq, skb, len_left, loopback);
+
+        return err;
 }
 
-static inline void enic_queue_wq_skb_csum_l4(struct enic *enic,
-        struct vnic_wq *wq, struct sk_buff *skb,
-        int vlan_tag_insert, unsigned int vlan_tag, int loopback)
+static int enic_queue_wq_skb_csum_l4(struct enic *enic, struct vnic_wq *wq,
+                                     struct sk_buff *skb, int vlan_tag_insert,
+                                     unsigned int vlan_tag, int loopback)
 {
         unsigned int head_len = skb_headlen(skb);
         unsigned int len_left = skb->len - head_len;
         unsigned int hdr_len = skb_checksum_start_offset(skb);
         unsigned int csum_offset = hdr_len + skb->csum_offset;
         int eop = (len_left == 0);
+        dma_addr_t dma_addr;
+        int err = 0;
+
+        dma_addr = pci_map_single(enic->pdev, skb->data, head_len,
+                                  PCI_DMA_TODEVICE);
+        if (unlikely(enic_dma_map_check(enic, dma_addr)))
+                return -ENOMEM;
 
         /* Queue the main skb fragment. The fragments are no larger
          * than max MTU(9000)+ETH_HDR_LEN(14) bytes, which is less
          * than WQ_ENET_MAX_DESC_LEN length. So only one descriptor
          * per fragment is queued.
          */
-        enic_queue_wq_desc_csum_l4(wq, skb,
-                pci_map_single(enic->pdev, skb->data,
-                        head_len, PCI_DMA_TODEVICE),
-                head_len,
-                csum_offset,
-                hdr_len,
-                vlan_tag_insert, vlan_tag,
-                eop, loopback);
+        enic_queue_wq_desc_csum_l4(wq, skb, dma_addr, head_len, csum_offset,
+                                   hdr_len, vlan_tag_insert, vlan_tag, eop,
+                                   loopback);
 
         if (!eop)
-                enic_queue_wq_skb_cont(enic, wq, skb, len_left, loopback);
+                err = enic_queue_wq_skb_cont(enic, wq, skb, len_left, loopback);
+
+        return err;
 }
 
-static inline void enic_queue_wq_skb_tso(struct enic *enic,
-        struct vnic_wq *wq, struct sk_buff *skb, unsigned int mss,
-        int vlan_tag_insert, unsigned int vlan_tag, int loopback)
+static int enic_queue_wq_skb_tso(struct enic *enic, struct vnic_wq *wq,
+                                 struct sk_buff *skb, unsigned int mss,
+                                 int vlan_tag_insert, unsigned int vlan_tag,
+                                 int loopback)
 {
         unsigned int frag_len_left = skb_headlen(skb);
         unsigned int len_left = skb->len - frag_len_left;
@@ -454,20 +469,19 @@ static inline void enic_queue_wq_skb_tso(struct enic *enic,
          */
         while (frag_len_left) {
                 len = min(frag_len_left, (unsigned int)WQ_ENET_MAX_DESC_LEN);
-                dma_addr = pci_map_single(enic->pdev, skb->data + offset,
-                                len, PCI_DMA_TODEVICE);
-                enic_queue_wq_desc_tso(wq, skb,
-                        dma_addr,
-                        len,
-                        mss, hdr_len,
-                        vlan_tag_insert, vlan_tag,
-                        eop && (len == frag_len_left), loopback);
+                dma_addr = pci_map_single(enic->pdev, skb->data + offset, len,
+                                          PCI_DMA_TODEVICE);
+                if (unlikely(enic_dma_map_check(enic, dma_addr)))
+                        return -ENOMEM;
+                enic_queue_wq_desc_tso(wq, skb, dma_addr, len, mss, hdr_len,
+                                       vlan_tag_insert, vlan_tag,
+                                       eop && (len == frag_len_left), loopback);
                 frag_len_left -= len;
                 offset += len;
         }
 
         if (eop)
-                return;
+                return 0;
 
         /* Queue WQ_ENET_MAX_DESC_LEN length descriptors
          * for additional data fragments
@@ -483,16 +497,18 @@ static inline void enic_queue_wq_skb_tso(struct enic *enic,
                         dma_addr = skb_frag_dma_map(&enic->pdev->dev, frag,
                                                     offset, len,
                                                     DMA_TO_DEVICE);
-                        enic_queue_wq_desc_cont(wq, skb,
-                                dma_addr,
-                                len,
-                                (len_left == 0) &&
-                                (len == frag_len_left),         /* EOP? */
-                                loopback);
+                        if (unlikely(enic_dma_map_check(enic, dma_addr)))
+                                return -ENOMEM;
+                        enic_queue_wq_desc_cont(wq, skb, dma_addr, len,
+                                                (len_left == 0) &&
+                                                 (len == frag_len_left),/*EOP*/
+                                                loopback);
                         frag_len_left -= len;
                         offset += len;
                 }
         }
+
+        return 0;
 }
 
 static inline void enic_queue_wq_skb(struct enic *enic,
@@ -502,25 +518,42 @@ static inline void enic_queue_wq_skb(struct enic *enic,
         unsigned int vlan_tag = 0;
         int vlan_tag_insert = 0;
         int loopback = 0;
+        int err;
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 /* VLAN tag from trunking driver */
                 vlan_tag_insert = 1;
-                vlan_tag = vlan_tx_tag_get(skb);
+                vlan_tag = skb_vlan_tag_get(skb);
         } else if (enic->loop_enable) {
                 vlan_tag = enic->loop_tag;
                 loopback = 1;
         }
 
         if (mss)
-                enic_queue_wq_skb_tso(enic, wq, skb, mss,
-                        vlan_tag_insert, vlan_tag, loopback);
+                err = enic_queue_wq_skb_tso(enic, wq, skb, mss,
+                                            vlan_tag_insert, vlan_tag,
+                                            loopback);
         else if (skb->ip_summed == CHECKSUM_PARTIAL)
-                enic_queue_wq_skb_csum_l4(enic, wq, skb,
-                        vlan_tag_insert, vlan_tag, loopback);
+                err = enic_queue_wq_skb_csum_l4(enic, wq, skb, vlan_tag_insert,
+                                                vlan_tag, loopback);
         else
-                enic_queue_wq_skb_vlan(enic, wq, skb,
-                        vlan_tag_insert, vlan_tag, loopback);
+                err = enic_queue_wq_skb_vlan(enic, wq, skb, vlan_tag_insert,
+                                             vlan_tag, loopback);
+        if (unlikely(err)) {
+                struct vnic_wq_buf *buf;
+
+                buf = wq->to_use->prev;
+                /* while not EOP of previous pkt && queue not empty.
+                 * For all non EOP bufs, os_buf is NULL.
+                 */
+                while (!buf->os_buf && (buf->next != wq->to_clean)) {
+                        enic_free_wq_buf(wq, buf);
+                        wq->ring.desc_avail++;
+                        buf = buf->prev;
+                }
+                wq->to_use = buf->next;
+                dev_kfree_skb(skb);
+        }
 }
 
 /* netif_tx_lock held, process context with BHs disabled, or BH */
@@ -950,8 +983,12 @@ static int enic_rq_alloc_buf(struct vnic_rq *rq)
         if (!skb)
                 return -ENOMEM;
 
-        dma_addr = pci_map_single(enic->pdev, skb->data,
-                len, PCI_DMA_FROMDEVICE);
+        dma_addr = pci_map_single(enic->pdev, skb->data, len,
+                                  PCI_DMA_FROMDEVICE);
+        if (unlikely(enic_dma_map_check(enic, dma_addr))) {
+                dev_kfree_skb(skb);
+                return -ENOMEM;
+        }
 
         enic_queue_rq_desc(rq, skb, os_buf_index,
                 dma_addr, len);
@@ -1266,7 +1303,7 @@ static void enic_set_rx_cpu_rmap(struct enic *enic)
 #endif /* CONFIG_RFS_ACCEL */
 
 #ifdef CONFIG_NET_RX_BUSY_POLL
-int enic_busy_poll(struct napi_struct *napi)
+static int enic_busy_poll(struct napi_struct *napi)
 {
         struct net_device *netdev = napi->dev;
         struct enic *enic = netdev_priv(netdev);
@@ -2231,6 +2268,18 @@ static void enic_dev_deinit(struct enic *enic)
         enic_clear_intr_mode(enic);
 }
 
+static void enic_kdump_kernel_config(struct enic *enic)
+{
+        if (is_kdump_kernel()) {
+                dev_info(enic_get_dev(enic), "Running from within kdump kernel. Using minimal resources\n");
+                enic->rq_count = 1;
+                enic->wq_count = 1;
+                enic->config.rq_desc_count = ENIC_MIN_RQ_DESCS;
+                enic->config.wq_desc_count = ENIC_MIN_WQ_DESCS;
+                enic->config.mtu = min_t(u16, 1500, enic->config.mtu);
+        }
+}
+
 static int enic_dev_init(struct enic *enic)
 {
         struct device *dev = enic_get_dev(enic);
@@ -2260,6 +2309,10 @@ static int enic_dev_init(struct enic *enic)
 
         enic_get_res_counts(enic);
 
+        /* modify resource count if we are in kdump_kernel
+         */
+        enic_kdump_kernel_config(enic);
+
         /* Set interrupt mode based on resource counts and system
          * capabilities
          */
diff --git a/drivers/net/ethernet/cisco/enic/vnic_stats.h b/drivers/net/ethernet/cisco/enic/vnic_stats.h
index 77750ec93954..74c81ed6fdab 100644
--- a/drivers/net/ethernet/cisco/enic/vnic_stats.h
+++ b/drivers/net/ethernet/cisco/enic/vnic_stats.h
@@ -62,6 +62,11 @@ struct vnic_rx_stats {
         u64 rsvd[16];
 };
 
+/* Generic statistics */
+struct vnic_gen_stats {
+        u64 dma_map_error;
+};
+
 struct vnic_stats {
         struct vnic_tx_stats tx;
         struct vnic_rx_stats rx;
diff --git a/drivers/net/ethernet/cisco/enic/vnic_wq.c b/drivers/net/ethernet/cisco/enic/vnic_wq.c
index 3e6b8d54dafc..b5a1c937fad2 100644
--- a/drivers/net/ethernet/cisco/enic/vnic_wq.c
+++ b/drivers/net/ethernet/cisco/enic/vnic_wq.c
@@ -47,11 +47,14 @@ static int vnic_wq_alloc_bufs(struct vnic_wq *wq)
                                 wq->ring.desc_size * buf->index;
                         if (buf->index + 1 == count) {
                                 buf->next = wq->bufs[0];
+                                buf->next->prev = buf;
                                 break;
                         } else if (j + 1 == VNIC_WQ_BUF_BLK_ENTRIES(count)) {
                                 buf->next = wq->bufs[i + 1];
+                                buf->next->prev = buf;
                         } else {
                                 buf->next = buf + 1;
+                                buf->next->prev = buf;
                                 buf++;
                         }
                 }
diff --git a/drivers/net/ethernet/cisco/enic/vnic_wq.h b/drivers/net/ethernet/cisco/enic/vnic_wq.h
index 816f1ad6072f..296154351823 100644
--- a/drivers/net/ethernet/cisco/enic/vnic_wq.h
+++ b/drivers/net/ethernet/cisco/enic/vnic_wq.h
@@ -62,6 +62,7 @@ struct vnic_wq_buf {
         uint8_t cq_entry; /* Gets completion event from hw */
         uint8_t desc_skip_cnt; /* Num descs to occupy */
         uint8_t compressed_send; /* Both hdr and payload in one desc */
+        struct vnic_wq_buf *prev;
 };
 
 /* Break the vnic_wq_buf allocations into blocks of 32/64 entries */
diff --git a/drivers/net/ethernet/davicom/dm9000.c b/drivers/net/ethernet/davicom/dm9000.c
index ef0bb58750e6..c0a7813603c3 100644
--- a/drivers/net/ethernet/davicom/dm9000.c
+++ b/drivers/net/ethernet/davicom/dm9000.c
@@ -36,6 +36,9 @@
 #include <linux/platform_device.h>
 #include <linux/irq.h>
 #include <linux/slab.h>
+#include <linux/regulator/consumer.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
 
 #include <asm/delay.h>
 #include <asm/irq.h>
@@ -1426,11 +1429,48 @@ dm9000_probe(struct platform_device *pdev)
         struct dm9000_plat_data *pdata = dev_get_platdata(&pdev->dev);
         struct board_info *db;  /* Point a board information structure */
         struct net_device *ndev;
+        struct device *dev = &pdev->dev;
         const unsigned char *mac_src;
         int ret = 0;
         int iosize;
         int i;
         u32 id_val;
+        int reset_gpios;
+        enum of_gpio_flags flags;
+        struct regulator *power;
+
+        power = devm_regulator_get(dev, "vcc");
+        if (IS_ERR(power)) {
+                if (PTR_ERR(power) == -EPROBE_DEFER)
+                        return -EPROBE_DEFER;
+                dev_dbg(dev, "no regulator provided\n");
+        } else {
+                ret = regulator_enable(power);
+                if (ret != 0) {
+                        dev_err(dev,
+                                "Failed to enable power regulator: %d\n", ret);
+                        return ret;
+                }
+                dev_dbg(dev, "regulator enabled\n");
+        }
+
+        reset_gpios = of_get_named_gpio_flags(dev->of_node, "reset-gpios", 0,
+                                              &flags);
+        if (gpio_is_valid(reset_gpios)) {
+                ret = devm_gpio_request_one(dev, reset_gpios, flags,
+                                            "dm9000_reset");
+                if (ret) {
+                        dev_err(dev, "failed to request reset gpio %d: %d\n",
+                                reset_gpios, ret);
+                        return -ENODEV;
+                }
+
+                /* According to manual PWRST# Low Period Min 1ms */
+                msleep(2);
+                gpio_set_value(reset_gpios, 1);
+                /* Needs 3ms to read eeprom when PWRST is deasserted */
+                msleep(4);
+        }
 
         if (!pdata) {
                 pdata = dm9000_parse_dt(&pdev->dev);
diff --git a/drivers/net/ethernet/dec/tulip/winbond-840.c b/drivers/net/ethernet/dec/tulip/winbond-840.c
index 6aa887e0e1cb..9beb3d34d4ba 100644
--- a/drivers/net/ethernet/dec/tulip/winbond-840.c
+++ b/drivers/net/ethernet/dec/tulip/winbond-840.c
@@ -904,7 +904,7 @@ static void init_registers(struct net_device *dev)
         }
 #elif defined(__powerpc__) || defined(__i386__) || defined(__alpha__) || defined(__ia64__) || defined(__x86_64__)
         i |= 0xE000;
-#elif defined(CONFIG_SPARC) || defined (CONFIG_PARISC)
+#elif defined(CONFIG_SPARC) || defined (CONFIG_PARISC) || defined(CONFIG_ARM)
         i |= 0x4800;
 #else
 #warning Processor architecture undefined
diff --git a/drivers/net/ethernet/emulex/benet/be.h b/drivers/net/ethernet/emulex/benet/be.h
index 712e7f8e1df7..27de37aa90af 100644
--- a/drivers/net/ethernet/emulex/benet/be.h
+++ b/drivers/net/ethernet/emulex/benet/be.h
@@ -59,26 +59,6 @@
 #define OC_SUBSYS_DEVICE_ID3    0xE612
 #define OC_SUBSYS_DEVICE_ID4    0xE652
 
-static inline char *nic_name(struct pci_dev *pdev)
-{
-        switch (pdev->device) {
-        case OC_DEVICE_ID1:
-                return OC_NAME;
-        case OC_DEVICE_ID2:
-                return OC_NAME_BE;
-        case OC_DEVICE_ID3:
-        case OC_DEVICE_ID4:
-                return OC_NAME_LANCER;
-        case BE_DEVICE_ID2:
-                return BE3_NAME;
-        case OC_DEVICE_ID5:
-        case OC_DEVICE_ID6:
-                return OC_NAME_SH;
-        default:
-                return BE_NAME;
-        }
-}
-
 /* Number of bytes of an RX frame that are copied to skb->data */
 #define BE_HDR_LEN              ((u16) 64)
 /* allocate extra space to allow tunneling decapsulation without head reallocation */
@@ -243,7 +223,6 @@ struct be_tx_stats {
         u64 tx_bytes;
         u64 tx_pkts;
         u64 tx_reqs;
-        u64 tx_wrbs;
         u64 tx_compl;
         ulong tx_jiffies;
         u32 tx_stops;
@@ -266,6 +245,9 @@ struct be_tx_obj {
         /* Remember the skbs that were transmitted */
         struct sk_buff *sent_skb_list[TX_Q_LEN];
         struct be_tx_stats stats;
+        u16 pend_wrb_cnt;       /* Number of WRBs yet to be given to HW */
+        u16 last_req_wrb_cnt;   /* wrb cnt of the last req in the Q */
+        u16 last_req_hdr;       /* index of the last req's hdr-wrb */
 } ____cacheline_aligned_in_smp;
 
 /* Struct to remember the pages posted for rx frags */
@@ -379,15 +361,14 @@ enum vf_state {
         ASSIGNED = 1
 };
 
-#define BE_FLAGS_LINK_STATUS_INIT               1
-#define BE_FLAGS_SRIOV_ENABLED                  (1 << 2)
-#define BE_FLAGS_WORKER_SCHEDULED               (1 << 3)
-#define BE_FLAGS_VLAN_PROMISC                   (1 << 4)
-#define BE_FLAGS_MCAST_PROMISC                  (1 << 5)
-#define BE_FLAGS_NAPI_ENABLED                   (1 << 9)
-#define BE_FLAGS_QNQ_ASYNC_EVT_RCVD             (1 << 11)
-#define BE_FLAGS_VXLAN_OFFLOADS                 (1 << 12)
-#define BE_FLAGS_SETUP_DONE                     (1 << 13)
+#define BE_FLAGS_LINK_STATUS_INIT               BIT(1)
+#define BE_FLAGS_SRIOV_ENABLED                  BIT(2)
+#define BE_FLAGS_WORKER_SCHEDULED               BIT(3)
+#define BE_FLAGS_NAPI_ENABLED                   BIT(6)
+#define BE_FLAGS_QNQ_ASYNC_EVT_RCVD             BIT(7)
+#define BE_FLAGS_VXLAN_OFFLOADS                 BIT(8)
+#define BE_FLAGS_SETUP_DONE                     BIT(9)
+#define BE_FLAGS_EVT_INCOMPATIBLE_SFP           BIT(10)
 
 #define BE_UC_PMAC_COUNT                        30
 #define BE_VF_UC_PMAC_COUNT                     2
@@ -397,6 +378,8 @@ enum vf_state {
 #define LANCER_DELETE_FW_DUMP                   0x2
 
 struct phy_info {
+/* From SFF-8472 spec */
+#define SFP_VENDOR_NAME_LEN                     17
         u8 transceiver;
         u8 autoneg;
         u8 fc_autoneg;
@@ -410,6 +393,8 @@ struct phy_info {
         u32 advertising;
         u32 supported;
         u8 cable_type;
+        u8 vendor_name[SFP_VENDOR_NAME_LEN];
+        u8 vendor_pn[SFP_VENDOR_NAME_LEN];
 };
 
 struct be_resources {
@@ -467,8 +452,6 @@ struct be_adapter {
 
         struct be_drv_stats drv_stats;
         struct be_aic_obj aic_obj[MAX_EVT_QS];
-        u16 vlans_added;
-        unsigned long vids[BITS_TO_LONGS(VLAN_N_VID)];
         u8 vlan_prio_bmap;      /* Available Priority BitMap */
         u16 recommended_prio;   /* Recommended Priority */
         struct be_dma_mem rx_filter; /* Cmd DMA mem for rx-filter */
@@ -484,8 +467,15 @@ struct be_adapter {
         /* Ethtool knobs and info */
         char fw_ver[FW_VER_LEN];
         char fw_on_flash[FW_VER_LEN];
+
+        /* IFACE filtering fields */
         int if_handle;          /* Used to configure filtering */
+        u32 if_flags;           /* Interface filtering flags */
         u32 *pmac_id;           /* MAC addr handle used by BE card */
+        u32 uc_macs;            /* Count of secondary UC MAC programmed */
+        unsigned long vids[BITS_TO_LONGS(VLAN_N_VID)];
+        u16 vlans_added;
+
         u32 beacon_state;       /* for set_phys_id */
 
         bool eeh_error;
@@ -493,7 +483,7 @@ struct be_adapter {
         bool hw_error;
 
         u32 port_num;
-        bool promiscuous;
+        char port_name;
         u8 mc_type;
         u32 function_mode;
         u32 function_caps;
@@ -526,7 +516,6 @@ struct be_adapter {
         struct phy_info phy;
         u8 wol_cap;
         bool wol_en;
-        u32 uc_macs;            /* Count of secondary UC MAC programmed */
         u16 asic_rev;
         u16 qnq_vid;
         u32 msg_enable;
@@ -732,19 +721,6 @@ static inline bool is_ipv4_pkt(struct sk_buff *skb)
         return skb->protocol == htons(ETH_P_IP) && ip_hdr(skb)->version == 4;
 }
 
-static inline void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac)
-{
-        u32 addr;
-
-        addr = jhash(adapter->netdev->dev_addr, ETH_ALEN, 0);
-
-        mac[5] = (u8)(addr & 0xFF);
-        mac[4] = (u8)((addr >> 8) & 0xFF);
-        mac[3] = (u8)((addr >> 16) & 0xFF);
-        /* Use the OUI from the current MAC address */
-        memcpy(mac, adapter->netdev->dev_addr, 3);
-}
-
 static inline bool be_multi_rxq(const struct be_adapter *adapter)
 {
         return adapter->num_rx_qs > 1;
@@ -767,129 +743,6 @@ static inline void  be_clear_all_error(struct be_adapter *adapter)
         adapter->fw_timeout = false;
 }
 
-static inline bool be_is_wol_excluded(struct be_adapter *adapter)
-{
-        struct pci_dev *pdev = adapter->pdev;
-
-        if (!be_physfn(adapter))
-                return true;
-
-        switch (pdev->subsystem_device) {
-        case OC_SUBSYS_DEVICE_ID1:
-        case OC_SUBSYS_DEVICE_ID2:
-        case OC_SUBSYS_DEVICE_ID3:
-        case OC_SUBSYS_DEVICE_ID4:
-                return true;
-        default:
-                return false;
-        }
-}
-
-static inline int qnq_async_evt_rcvd(struct be_adapter *adapter)
-{
-        return adapter->flags & BE_FLAGS_QNQ_ASYNC_EVT_RCVD;
-}
-
-#ifdef CONFIG_NET_RX_BUSY_POLL
-static inline bool be_lock_napi(struct be_eq_obj *eqo)
-{
-        bool status = true;
-
-        spin_lock(&eqo->lock); /* BH is already disabled */
-        if (eqo->state & BE_EQ_LOCKED) {
-                WARN_ON(eqo->state & BE_EQ_NAPI);
-                eqo->state |= BE_EQ_NAPI_YIELD;
-                status = false;
-        } else {
-                eqo->state = BE_EQ_NAPI;
-        }
-        spin_unlock(&eqo->lock);
-        return status;
-}
-
-static inline void be_unlock_napi(struct be_eq_obj *eqo)
-{
-        spin_lock(&eqo->lock); /* BH is already disabled */
-
-        WARN_ON(eqo->state & (BE_EQ_POLL | BE_EQ_NAPI_YIELD));
-        eqo->state = BE_EQ_IDLE;
-
-        spin_unlock(&eqo->lock);
-}
-
-static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
-{
-        bool status = true;
-
-        spin_lock_bh(&eqo->lock);
-        if (eqo->state & BE_EQ_LOCKED) {
-                eqo->state |= BE_EQ_POLL_YIELD;
-                status = false;
-        } else {
-                eqo->state |= BE_EQ_POLL;
-        }
-        spin_unlock_bh(&eqo->lock);
-        return status;
-}
-
-static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
-{
-        spin_lock_bh(&eqo->lock);
-
-        WARN_ON(eqo->state & (BE_EQ_NAPI));
-        eqo->state = BE_EQ_IDLE;
-
-        spin_unlock_bh(&eqo->lock);
-}
-
-static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
-{
-        spin_lock_init(&eqo->lock);
-        eqo->state = BE_EQ_IDLE;
-}
-
-static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
-{
-        local_bh_disable();
-
-        /* It's enough to just acquire napi lock on the eqo to stop
-         * be_busy_poll() from processing any queueus.
-         */
-        while (!be_lock_napi(eqo))
-                mdelay(1);
-
-        local_bh_enable();
-}
-
-#else /* CONFIG_NET_RX_BUSY_POLL */
-
-static inline bool be_lock_napi(struct be_eq_obj *eqo)
-{
-        return true;
-}
-
-static inline void be_unlock_napi(struct be_eq_obj *eqo)
-{
-}
-
-static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
-{
-        return false;
-}
-
-static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
-{
-}
-
-static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
-{
-}
-
-static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
-{
-}
-#endif /* CONFIG_NET_RX_BUSY_POLL */
-
 void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm,
                   u16 num_popped);
 void be_link_status_update(struct be_adapter *adapter, u8 link_status);
@@ -898,16 +751,6 @@ int be_load_fw(struct be_adapter *adapter, u8 *func);
 bool be_is_wol_supported(struct be_adapter *adapter);
 bool be_pause_supported(struct be_adapter *adapter);
 u32 be_get_fw_log_level(struct be_adapter *adapter);
-
-static inline int fw_major_num(const char *fw_ver)
-{
-        int fw_major = 0;
-
-        sscanf(fw_ver, "%d.", &fw_major);
-
-        return fw_major;
-}
-
 int be_update_queues(struct be_adapter *adapter);
 int be_poll(struct napi_struct *napi, int budget);
 
diff --git a/drivers/net/ethernet/emulex/benet/be_cmds.c b/drivers/net/ethernet/emulex/benet/be_cmds.c
index fead5c65a4f0..36916cfa70f9 100644
--- a/drivers/net/ethernet/emulex/benet/be_cmds.c
+++ b/drivers/net/ethernet/emulex/benet/be_cmds.c
@@ -19,6 +19,22 @@
 #include "be.h"
 #include "be_cmds.h"
 
+static char *be_port_misconfig_evt_desc[] = {
+        "A valid SFP module detected",
+        "Optics faulted/ incorrectly installed/ not installed.",
+        "Optics of two types installed.",
+        "Incompatible optics.",
+        "Unknown port SFP status"
+};
+
+static char *be_port_misconfig_remedy_desc[] = {
+        "",
+        "Reseat optics. If issue not resolved, replace",
+        "Remove one optic or install matching pair of optics",
+        "Replace with compatible optics for card to function",
+        ""
+};
+
 static struct be_cmd_priv_map cmd_priv_map[] = {
         {
                 OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG,
@@ -249,6 +265,29 @@ static void be_async_link_state_process(struct be_adapter *adapter,
                                       evt->port_link_status & LINK_STATUS_MASK);
 }
 
+static void be_async_port_misconfig_event_process(struct be_adapter *adapter,
+                                                  struct be_mcc_compl *compl)
+{
+        struct be_async_event_misconfig_port *evt =
+                        (struct be_async_event_misconfig_port *)compl;
+        u32 sfp_mismatch_evt = le32_to_cpu(evt->event_data_word1);
+        struct device *dev = &adapter->pdev->dev;
+        u8 port_misconfig_evt;
+
+        port_misconfig_evt =
+                ((sfp_mismatch_evt >> (adapter->hba_port_num * 8)) & 0xff);
+
+        /* Log an error message that would allow a user to determine
+         * whether the SFPs have an issue
+         */
+        dev_info(dev, "Port %c: %s %s", adapter->port_name,
+                 be_port_misconfig_evt_desc[port_misconfig_evt],
+                 be_port_misconfig_remedy_desc[port_misconfig_evt]);
+
+        if (port_misconfig_evt == INCOMPATIBLE_SFP)
+                adapter->flags |= BE_FLAGS_EVT_INCOMPATIBLE_SFP;
+}
+
 /* Grp5 CoS Priority evt */
 static void be_async_grp5_cos_priority_process(struct be_adapter *adapter,
                                                struct be_mcc_compl *compl)
@@ -334,6 +373,16 @@ static void be_async_dbg_evt_process(struct be_adapter *adapter,
         }
 }
 
+static void be_async_sliport_evt_process(struct be_adapter *adapter,
+                                         struct be_mcc_compl *cmp)
+{
+        u8 event_type = (cmp->flags >> ASYNC_EVENT_TYPE_SHIFT) &
+                        ASYNC_EVENT_TYPE_MASK;
+
+        if (event_type == ASYNC_EVENT_PORT_MISCONFIG)
+                be_async_port_misconfig_event_process(adapter, cmp);
+}
+
 static inline bool is_link_state_evt(u32 flags)
 {
         return ((flags >> ASYNC_EVENT_CODE_SHIFT) & ASYNC_EVENT_CODE_MASK) ==
@@ -352,6 +401,12 @@ static inline bool is_dbg_evt(u32 flags)
                         ASYNC_EVENT_CODE_QNQ;
 }
 
+static inline bool is_sliport_evt(u32 flags)
+{
+        return ((flags >> ASYNC_EVENT_CODE_SHIFT) & ASYNC_EVENT_CODE_MASK) ==
+                ASYNC_EVENT_CODE_SLIPORT;
+}
+
 static void be_mcc_event_process(struct be_adapter *adapter,
                                  struct be_mcc_compl *compl)
 {
@@ -361,6 +416,8 @@ static void be_mcc_event_process(struct be_adapter *adapter,
                 be_async_grp5_evt_process(adapter, compl);
         else if (is_dbg_evt(compl->flags))
                 be_async_dbg_evt_process(adapter, compl);
+        else if (is_sliport_evt(compl->flags))
+                be_async_sliport_evt_process(adapter, compl);
 }
 
 static struct be_mcc_compl *be_mcc_compl_get(struct be_adapter *adapter)
@@ -573,7 +630,7 @@ static int lancer_wait_ready(struct be_adapter *adapter)
 {
 #define SLIPORT_READY_TIMEOUT 30
         u32 sliport_status;
-        int status = 0, i;
+        int i;
 
         for (i = 0; i < SLIPORT_READY_TIMEOUT; i++) {
                 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
@@ -584,9 +641,9 @@ static int lancer_wait_ready(struct be_adapter *adapter)
         }
 
         if (i == SLIPORT_READY_TIMEOUT)
-                status = -1;
+                return sliport_status ? : -1;
 
-        return status;
+        return 0;
 }
 
 static bool lancer_provisioning_error(struct be_adapter *adapter)
@@ -624,7 +681,7 @@ int lancer_test_and_set_rdy_state(struct be_adapter *adapter)
                         iowrite32(SLI_PORT_CONTROL_IP_MASK,
                                   adapter->db + SLIPORT_CONTROL_OFFSET);
 
-                        /* check adapter has corrected the error */
+                        /* check if adapter has corrected the error */
                         status = lancer_wait_ready(adapter);
                         sliport_status = ioread32(adapter->db +
                                                   SLIPORT_STATUS_OFFSET);
@@ -655,7 +712,11 @@ int be_fw_wait_ready(struct be_adapter *adapter)
 
         if (lancer_chip(adapter)) {
                 status = lancer_wait_ready(adapter);
-                return status;
+                if (status) {
+                        stage = status;
+                        goto err;
+                }
+                return 0;
         }
 
         do {
@@ -671,7 +732,8 @@ int be_fw_wait_ready(struct be_adapter *adapter)
                 timeout += 2;
         } while (timeout < 60);
 
-        dev_err(dev, "POST timeout; stage=0x%x\n", stage);
+err:
+        dev_err(dev, "POST timeout; stage=%#x\n", stage);
         return -1;
 }
 
@@ -1166,9 +1228,15 @@ static int be_cmd_mccq_ext_create(struct be_adapter *adapter,
                               ctxt, 1);
         }
 
-        /* Subscribe to Link State and Group 5 Events(bits 1 and 5 set) */
-        req->async_event_bitmap[0] = cpu_to_le32(0x00000022);
-        req->async_event_bitmap[0] |= cpu_to_le32(1 << ASYNC_EVENT_CODE_QNQ);
+        /* Subscribe to Link State, Sliport Event and Group 5 Events
+         * (bits 1, 5 and 17 set)
+         */
+        req->async_event_bitmap[0] =
+                        cpu_to_le32(BIT(ASYNC_EVENT_CODE_LINK_STATE) |
+                                    BIT(ASYNC_EVENT_CODE_GRP_5) |
+                                    BIT(ASYNC_EVENT_CODE_QNQ) |
+                                    BIT(ASYNC_EVENT_CODE_SLIPORT));
+
         be_dws_cpu_to_le(ctxt, sizeof(req->context));
 
         be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
@@ -1881,7 +1949,7 @@ err:
         return status;
 }
 
-int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value)
+static int __be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value)
 {
         struct be_mcc_wrb *wrb;
         struct be_dma_mem *mem = &adapter->rx_filter;
@@ -1901,31 +1969,13 @@ int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value)
                                wrb, mem);
 
         req->if_id = cpu_to_le32(adapter->if_handle);
-        if (flags & IFF_PROMISC) {
-                req->if_flags_mask = cpu_to_le32(BE_IF_FLAGS_PROMISCUOUS |
-                                                 BE_IF_FLAGS_VLAN_PROMISCUOUS |
-                                                 BE_IF_FLAGS_MCAST_PROMISCUOUS);
-                if (value == ON)
-                        req->if_flags =
-                                cpu_to_le32(BE_IF_FLAGS_PROMISCUOUS |
-                                            BE_IF_FLAGS_VLAN_PROMISCUOUS |
-                                            BE_IF_FLAGS_MCAST_PROMISCUOUS);
-        } else if (flags & IFF_ALLMULTI) {
-                req->if_flags_mask = cpu_to_le32(BE_IF_FLAGS_MCAST_PROMISCUOUS);
-                req->if_flags = cpu_to_le32(BE_IF_FLAGS_MCAST_PROMISCUOUS);
-        } else if (flags & BE_FLAGS_VLAN_PROMISC) {
-                req->if_flags_mask = cpu_to_le32(BE_IF_FLAGS_VLAN_PROMISCUOUS);
-
-                if (value == ON)
-                        req->if_flags =
-                                cpu_to_le32(BE_IF_FLAGS_VLAN_PROMISCUOUS);
-        } else {
+        req->if_flags_mask = cpu_to_le32(flags);
+        req->if_flags = (value == ON) ? req->if_flags_mask : 0;
+
+        if (flags & BE_IF_FLAGS_MULTICAST) {
                 struct netdev_hw_addr *ha;
                 int i = 0;
 
-                req->if_flags_mask = cpu_to_le32(BE_IF_FLAGS_MULTICAST);
-                req->if_flags = cpu_to_le32(BE_IF_FLAGS_MULTICAST);
-
                 /* Reset mcast promisc mode if already set by setting mask
                  * and not setting flags field
                  */
@@ -1937,24 +1987,26 @@ int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value)
                         memcpy(req->mcast_mac[i++].byte, ha->addr, ETH_ALEN);
         }
 
-        if ((req->if_flags_mask & cpu_to_le32(be_if_cap_flags(adapter))) !=
-            req->if_flags_mask) {
-                dev_warn(&adapter->pdev->dev,
-                         "Cannot set rx filter flags 0x%x\n",
-                         req->if_flags_mask);
-                dev_warn(&adapter->pdev->dev,
-                         "Interface is capable of 0x%x flags only\n",
-                         be_if_cap_flags(adapter));
-        }
-        req->if_flags_mask &= cpu_to_le32(be_if_cap_flags(adapter));
-
         status = be_mcc_notify_wait(adapter);
-
 err:
         spin_unlock_bh(&adapter->mcc_lock);
         return status;
 }
 
+int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value)
+{
+        struct device *dev = &adapter->pdev->dev;
+
+        if ((flags & be_if_cap_flags(adapter)) != flags) {
+                dev_warn(dev, "Cannot set rx filter flags 0x%x\n", flags);
+                dev_warn(dev, "Interface is capable of 0x%x flags only\n",
+                         be_if_cap_flags(adapter));
+        }
+        flags &= be_if_cap_flags(adapter);
+
+        return __be_cmd_rx_filter(adapter, flags, value);
+}
+
 /* Uses synchrounous mcc */
 int be_cmd_set_flow_control(struct be_adapter *adapter, u32 tx_fc, u32 rx_fc)
 {
@@ -2355,6 +2407,24 @@ int be_cmd_query_cable_type(struct be_adapter *adapter)
         return status;
 }
 
+int be_cmd_query_sfp_info(struct be_adapter *adapter)
+{
+        u8 page_data[PAGE_DATA_LEN];
+        int status;
+
+        status = be_cmd_read_port_transceiver_data(adapter, TR_PAGE_A0,
+                                                   page_data);
+        if (!status) {
+                strlcpy(adapter->phy.vendor_name, page_data +
+                        SFP_VENDOR_NAME_OFFSET, SFP_VENDOR_NAME_LEN - 1);
+                strlcpy(adapter->phy.vendor_pn,
+                        page_data + SFP_VENDOR_PN_OFFSET,
+                        SFP_VENDOR_NAME_LEN - 1);
+        }
+
+        return status;
+}
+
 int lancer_cmd_delete_object(struct be_adapter *adapter, const char *obj_name)
 {
         struct lancer_cmd_req_delete_object *req;
@@ -2431,7 +2501,8 @@ err_unlock:
 }
 
 int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd,
-                          u32 flash_type, u32 flash_opcode, u32 buf_size)
+                          u32 flash_type, u32 flash_opcode, u32 img_offset,
+                          u32 buf_size)
 {
         struct be_mcc_wrb *wrb;
         struct be_cmd_write_flashrom *req;
@@ -2452,6 +2523,9 @@ int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd,
                                cmd);
 
         req->params.op_type = cpu_to_le32(flash_type);
+        if (flash_type == OPTYPE_OFFSET_SPECIFIED)
+                req->params.offset = cpu_to_le32(img_offset);
+
         req->params.op_code = cpu_to_le32(flash_opcode);
         req->params.data_buf_size = cpu_to_le32(buf_size);
 
@@ -2472,10 +2546,10 @@ err_unlock:
 }
 
 int be_cmd_get_flash_crc(struct be_adapter *adapter, u8 *flashed_crc,
-                         u16 optype, int offset)
+                         u16 img_optype, u32 img_offset, u32 crc_offset)
 {
-        struct be_mcc_wrb *wrb;
         struct be_cmd_read_flash_crc *req;
+        struct be_mcc_wrb *wrb;
         int status;
 
         spin_lock_bh(&adapter->mcc_lock);
@@ -2491,9 +2565,13 @@ int be_cmd_get_flash_crc(struct be_adapter *adapter, u8 *flashed_crc,
                                OPCODE_COMMON_READ_FLASHROM, sizeof(*req),
                                wrb, NULL);
 
-        req->params.op_type = cpu_to_le32(optype);
+        req->params.op_type = cpu_to_le32(img_optype);
+        if (img_optype == OPTYPE_OFFSET_SPECIFIED)
+                req->params.offset = cpu_to_le32(img_offset + crc_offset);
+        else
+                req->params.offset = cpu_to_le32(crc_offset);
+
         req->params.op_code = cpu_to_le32(FLASHROM_OPER_REPORT);
-        req->params.offset = cpu_to_le32(offset);
         req->params.data_buf_size = cpu_to_le32(0x4);
 
         status = be_mcc_notify_wait(adapter);
@@ -2742,7 +2820,7 @@ err:
         return status;
 }
 
-int be_cmd_set_qos(struct be_adapter *adapter, u32 bps, u32 domain)
+static int be_cmd_set_qos(struct be_adapter *adapter, u32 bps, u32 domain)
 {
         struct be_mcc_wrb *wrb;
         struct be_cmd_req_set_qos *req;
@@ -3236,6 +3314,24 @@ err:
         return status;
 }
 
+static bool be_is_wol_excluded(struct be_adapter *adapter)
+{
+        struct pci_dev *pdev = adapter->pdev;
+
+        if (!be_physfn(adapter))
+                return true;
+
+        switch (pdev->subsystem_device) {
+        case OC_SUBSYS_DEVICE_ID1:
+        case OC_SUBSYS_DEVICE_ID2:
+        case OC_SUBSYS_DEVICE_ID3:
+        case OC_SUBSYS_DEVICE_ID4:
+                return true;
+        default:
+                return false;
+        }
+}
+
 int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter)
 {
         struct be_mcc_wrb *wrb;
@@ -3422,42 +3518,34 @@ err:
         return status;
 }
 
-int be_cmd_query_port_name(struct be_adapter *adapter, u8 *port_name)
+int be_cmd_query_port_name(struct be_adapter *adapter)
 {
-        struct be_mcc_wrb *wrb;
         struct be_cmd_req_get_port_name *req;
+        struct be_mcc_wrb *wrb;
         int status;
 
-        if (!lancer_chip(adapter)) {
-                *port_name = adapter->hba_port_num + '0';
-                return 0;
-        }
-
-        spin_lock_bh(&adapter->mcc_lock);
-
-        wrb = wrb_from_mccq(adapter);
-        if (!wrb) {
-                status = -EBUSY;
-                goto err;
-        }
+        if (mutex_lock_interruptible(&adapter->mbox_lock))
+                return -1;
 
+        wrb = wrb_from_mbox(adapter);
         req = embedded_payload(wrb);
 
         be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
                                OPCODE_COMMON_GET_PORT_NAME, sizeof(*req), wrb,
                                NULL);
-        req->hdr.version = 1;
+        if (!BEx_chip(adapter))
+                req->hdr.version = 1;
 
-        status = be_mcc_notify_wait(adapter);
+        status = be_mbox_notify_wait(adapter);
         if (!status) {
                 struct be_cmd_resp_get_port_name *resp = embedded_payload(wrb);
 
-                *port_name = resp->port_name[adapter->hba_port_num];
+                adapter->port_name = resp->port_name[adapter->hba_port_num];
         } else {
-                *port_name = adapter->hba_port_num + '0';
+                adapter->port_name = adapter->hba_port_num + '0';
         }
-err:
-        spin_unlock_bh(&adapter->mcc_lock);
+
+        mutex_unlock(&adapter->mbox_lock);
         return status;
 }
 
@@ -3751,6 +3839,7 @@ int be_cmd_config_qos(struct be_adapter *adapter, u32 max_rate, u16 link_speed,
         be_reset_nic_desc(&nic_desc);
         nic_desc.pf_num = adapter->pf_number;
         nic_desc.vf_num = domain;
+        nic_desc.bw_min = 0;
         if (lancer_chip(adapter)) {
                 nic_desc.hdr.desc_type = NIC_RESOURCE_DESC_TYPE_V0;
                 nic_desc.hdr.desc_len = RESOURCE_DESC_SIZE_V0;
@@ -4092,7 +4181,7 @@ int be_cmd_set_logical_link_config(struct be_adapter *adapter,
         int status;
 
         if (BEx_chip(adapter) || lancer_chip(adapter))
-                return 0;
+                return -EOPNOTSUPP;
 
         spin_lock_bh(&adapter->mcc_lock);
 
diff --git a/drivers/net/ethernet/emulex/benet/be_cmds.h b/drivers/net/ethernet/emulex/benet/be_cmds.h
index eb5085d6794f..db761e8e42a3 100644
--- a/drivers/net/ethernet/emulex/benet/be_cmds.h
+++ b/drivers/net/ethernet/emulex/benet/be_cmds.h
@@ -44,10 +44,10 @@ struct be_mcc_wrb {
         } payload;
 };
 
-#define CQE_FLAGS_VALID_MASK            (1 << 31)
-#define CQE_FLAGS_ASYNC_MASK            (1 << 30)
-#define CQE_FLAGS_COMPLETED_MASK        (1 << 28)
-#define CQE_FLAGS_CONSUMED_MASK         (1 << 27)
+#define CQE_FLAGS_VALID_MASK            BIT(31)
+#define CQE_FLAGS_ASYNC_MASK            BIT(30)
+#define CQE_FLAGS_COMPLETED_MASK        BIT(28)
+#define CQE_FLAGS_CONSUMED_MASK         BIT(27)
 
 /* Completion Status */
 enum mcc_base_status {
@@ -102,6 +102,8 @@ struct be_mcc_compl {
 #define ASYNC_EVENT_PVID_STATE          0x3
 #define ASYNC_EVENT_CODE_QNQ            0x6
 #define ASYNC_DEBUG_EVENT_TYPE_QNQ      1
+#define ASYNC_EVENT_CODE_SLIPORT        0x11
+#define ASYNC_EVENT_PORT_MISCONFIG      0x9
 
 enum {
         LINK_DOWN       = 0x0,
@@ -169,6 +171,15 @@ struct be_async_event_qnq {
         u32 flags;
 } __packed;
 
+#define INCOMPATIBLE_SFP                0x3
+/* async event indicating misconfigured port */
+struct be_async_event_misconfig_port {
+        u32 event_data_word1;
+        u32 event_data_word2;
+        u32 rsvd0;
+        u32 flags;
+} __packed;
+
 struct be_mcc_mailbox {
         struct be_mcc_wrb wrb;
         struct be_mcc_compl compl;
@@ -586,6 +597,10 @@ enum be_if_flags {
                          BE_IF_FLAGS_PASS_L3L4_ERRORS | BE_IF_FLAGS_MULTICAST |\
                          BE_IF_FLAGS_UNTAGGED)
 
+#define BE_IF_FLAGS_ALL_PROMISCUOUS     (BE_IF_FLAGS_PROMISCUOUS | \
+                                         BE_IF_FLAGS_VLAN_PROMISCUOUS |\
+                                         BE_IF_FLAGS_MCAST_PROMISCUOUS)
+
 /* An RX interface is an object with one or more MAC addresses and
  * filtering capabilities. */
 struct be_cmd_req_if_create {
@@ -1024,6 +1039,8 @@ enum {
 #define SFP_PLUS_SFF_8472_COMP          0x5E
 #define SFP_PLUS_CABLE_TYPE_OFFSET      0x8
 #define SFP_PLUS_COPPER_CABLE           0x4
+#define SFP_VENDOR_NAME_OFFSET          0x14
+#define SFP_VENDOR_PN_OFFSET            0x28
 
 #define PAGE_DATA_LEN   256
 struct be_cmd_resp_port_type {
@@ -1091,6 +1108,10 @@ struct be_cmd_req_query_fw_cfg {
         u32 rsvd[31];
 };
 
+/* ASIC revisions */
+#define ASIC_REV_B0             0x10
+#define ASIC_REV_P2             0x11
+
 struct be_cmd_resp_query_fw_cfg {
         struct be_cmd_resp_hdr hdr;
         u32 be_config_number;
@@ -1161,7 +1182,173 @@ struct be_cmd_resp_get_beacon_state {
         u8 rsvd0[3];
 } __packed;
 
+/* Flashrom related descriptors */
+#define MAX_FLASH_COMP                  32
+
+#define OPTYPE_ISCSI_ACTIVE             0
+#define OPTYPE_REDBOOT                  1
+#define OPTYPE_BIOS                     2
+#define OPTYPE_PXE_BIOS                 3
+#define OPTYPE_OFFSET_SPECIFIED         7
+#define OPTYPE_FCOE_BIOS                8
+#define OPTYPE_ISCSI_BACKUP             9
+#define OPTYPE_FCOE_FW_ACTIVE           10
+#define OPTYPE_FCOE_FW_BACKUP           11
+#define OPTYPE_NCSI_FW                  13
+#define OPTYPE_REDBOOT_DIR              18
+#define OPTYPE_REDBOOT_CONFIG           19
+#define OPTYPE_SH_PHY_FW                21
+#define OPTYPE_FLASHISM_JUMPVECTOR      22
+#define OPTYPE_UFI_DIR                  23
+#define OPTYPE_PHY_FW                   99
+
+#define FLASH_BIOS_IMAGE_MAX_SIZE_g2    262144  /* Max OPTION ROM image sz */
+#define FLASH_REDBOOT_IMAGE_MAX_SIZE_g2 262144  /* Max Redboot image sz    */
+#define FLASH_IMAGE_MAX_SIZE_g2         1310720 /* Max firmware image size */
+
+#define FLASH_NCSI_IMAGE_MAX_SIZE_g3    262144
+#define FLASH_PHY_FW_IMAGE_MAX_SIZE_g3  262144
+#define FLASH_BIOS_IMAGE_MAX_SIZE_g3    524288  /* Max OPTION ROM image sz */
+#define FLASH_REDBOOT_IMAGE_MAX_SIZE_g3 1048576 /* Max Redboot image sz    */
+#define FLASH_IMAGE_MAX_SIZE_g3         2097152 /* Max firmware image size */
+
+/* Offsets for components on Flash. */
+#define FLASH_REDBOOT_START_g2                  0
+#define FLASH_FCoE_BIOS_START_g2                524288
+#define FLASH_iSCSI_PRIMARY_IMAGE_START_g2      1048576
+#define FLASH_iSCSI_BACKUP_IMAGE_START_g2       2359296
+#define FLASH_FCoE_PRIMARY_IMAGE_START_g2       3670016
+#define FLASH_FCoE_BACKUP_IMAGE_START_g2        4980736
+#define FLASH_iSCSI_BIOS_START_g2               7340032
+#define FLASH_PXE_BIOS_START_g2                 7864320
+
+#define FLASH_REDBOOT_START_g3                  262144
+#define FLASH_PHY_FW_START_g3                   1310720
+#define FLASH_iSCSI_PRIMARY_IMAGE_START_g3      2097152
+#define FLASH_iSCSI_BACKUP_IMAGE_START_g3       4194304
+#define FLASH_FCoE_PRIMARY_IMAGE_START_g3       6291456
+#define FLASH_FCoE_BACKUP_IMAGE_START_g3        8388608
+#define FLASH_iSCSI_BIOS_START_g3               12582912
+#define FLASH_PXE_BIOS_START_g3                 13107200
+#define FLASH_FCoE_BIOS_START_g3                13631488
+#define FLASH_NCSI_START_g3                     15990784
+
+#define IMAGE_NCSI                      16
+#define IMAGE_OPTION_ROM_PXE            32
+#define IMAGE_OPTION_ROM_FCoE           33
+#define IMAGE_OPTION_ROM_ISCSI          34
+#define IMAGE_FLASHISM_JUMPVECTOR       48
+#define IMAGE_FIRMWARE_iSCSI            160
+#define IMAGE_FIRMWARE_FCoE             162
+#define IMAGE_FIRMWARE_BACKUP_iSCSI     176
+#define IMAGE_FIRMWARE_BACKUP_FCoE      178
+#define IMAGE_FIRMWARE_PHY              192
+#define IMAGE_REDBOOT_DIR               208
+#define IMAGE_REDBOOT_CONFIG            209
+#define IMAGE_UFI_DIR                   210
+#define IMAGE_BOOT_CODE                 224
+
+struct controller_id {
+        u32 vendor;
+        u32 device;
+        u32 subvendor;
+        u32 subdevice;
+};
+
+struct flash_comp {
+        unsigned long offset;
+        int optype;
+        int size;
+        int img_type;
+};
+
+struct image_hdr {
+        u32 imageid;
+        u32 imageoffset;
+        u32 imagelength;
+        u32 image_checksum;
+        u8 image_version[32];
+};
+
+struct flash_file_hdr_g2 {
+        u8 sign[32];
+        u32 cksum;
+        u32 antidote;
+        struct controller_id cont_id;
+        u32 file_len;
+        u32 chunk_num;
+        u32 total_chunks;
+        u32 num_imgs;
+        u8 build[24];
+};
+
+/* First letter of the build version of the image */
+#define BLD_STR_UFI_TYPE_BE2    '2'
+#define BLD_STR_UFI_TYPE_BE3    '3'
+#define BLD_STR_UFI_TYPE_SH     '4'
+
+struct flash_file_hdr_g3 {
+        u8 sign[52];
+        u8 ufi_version[4];
+        u32 file_len;
+        u32 cksum;
+        u32 antidote;
+        u32 num_imgs;
+        u8 build[24];
+        u8 asic_type_rev;
+        u8 rsvd[31];
+};
+
+struct flash_section_hdr {
+        u32 format_rev;
+        u32 cksum;
+        u32 antidote;
+        u32 num_images;
+        u8 id_string[128];
+        u32 rsvd[4];
+} __packed;
+
+struct flash_section_hdr_g2 {
+        u32 format_rev;
+        u32 cksum;
+        u32 antidote;
+        u32 build_num;
+        u8 id_string[128];
+        u32 rsvd[8];
+} __packed;
+
+struct flash_section_entry {
+        u32 type;
+        u32 offset;
+        u32 pad_size;
+        u32 image_size;
+        u32 cksum;
+        u32 entry_point;
+        u16 optype;
+        u16 rsvd0;
+        u32 rsvd1;
+        u8 ver_data[32];
+} __packed;
+
+struct flash_section_info {
+        u8 cookie[32];
+        struct flash_section_hdr fsec_hdr;
+        struct flash_section_entry fsec_entry[32];
+} __packed;
+
+struct flash_section_info_g2 {
+        u8 cookie[32];
+        struct flash_section_hdr_g2 fsec_hdr;
+        struct flash_section_entry fsec_entry[32];
+} __packed;
+
 /****************** Firmware Flash ******************/
+#define FLASHROM_OPER_FLASH             1
+#define FLASHROM_OPER_SAVE              2
+#define FLASHROM_OPER_REPORT            4
+#define FLASHROM_OPER_PHY_FLASH         9
+#define FLASHROM_OPER_PHY_SAVE          10
+
 struct flashrom_params {
         u32 op_code;
         u32 op_type;
@@ -1366,6 +1553,7 @@ enum {
         PHY_TYPE_QSFP,
         PHY_TYPE_KR4_40GB,
         PHY_TYPE_KR2_20GB,
+        PHY_TYPE_TN_8022,
         PHY_TYPE_DISABLED = 255
 };
 
@@ -1429,6 +1617,20 @@ struct be_cmd_req_set_qos {
 };
 
 /*********************** Controller Attributes ***********************/
+struct mgmt_hba_attribs {
+        u32 rsvd0[24];
+        u8 controller_model_number[32];
+        u32 rsvd1[79];
+        u8 rsvd2[3];
+        u8 phy_port;
+        u32 rsvd3[13];
+} __packed;
+
+struct mgmt_controller_attrib {
+        struct mgmt_hba_attribs hba_attribs;
+        u32 rsvd0[10];
+} __packed;
+
 struct be_cmd_req_cntl_attribs {
         struct be_cmd_req_hdr hdr;
 };
@@ -2070,8 +2272,10 @@ int be_cmd_get_beacon_state(struct be_adapter *adapter, u8 port_num,
 int be_cmd_read_port_transceiver_data(struct be_adapter *adapter,
                                       u8 page_num, u8 *data);
 int be_cmd_query_cable_type(struct be_adapter *adapter);
+int be_cmd_query_sfp_info(struct be_adapter *adapter);
 int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd,
-                          u32 flash_oper, u32 flash_opcode, u32 buf_size);
+                          u32 flash_oper, u32 flash_opcode, u32 img_offset,
+                          u32 buf_size);
 int lancer_cmd_write_object(struct be_adapter *adapter, struct be_dma_mem *cmd,
                             u32 data_size, u32 data_offset,
                             const char *obj_name, u32 *data_written,
@@ -2081,7 +2285,7 @@ int lancer_cmd_read_object(struct be_adapter *adapter, struct be_dma_mem *cmd,
                            u32 *data_read, u32 *eof, u8 *addn_status);
 int lancer_cmd_delete_object(struct be_adapter *adapter, const char *obj_name);
 int be_cmd_get_flash_crc(struct be_adapter *adapter, u8 *flashed_crc,
-                          u16 optype, int offset);
+                         u16 img_optype, u32 img_offset, u32 crc_offset);
 int be_cmd_enable_magic_wol(struct be_adapter *adapter, u8 *mac,
                             struct be_dma_mem *nonemb_cmd);
 int be_cmd_fw_init(struct be_adapter *adapter);
@@ -2136,7 +2340,7 @@ int lancer_initiate_dump(struct be_adapter *adapter);
 int lancer_delete_dump(struct be_adapter *adapter);
 bool dump_present(struct be_adapter *adapter);
 int lancer_test_and_set_rdy_state(struct be_adapter *adapter);
-int be_cmd_query_port_name(struct be_adapter *adapter, u8 *port_name);
+int be_cmd_query_port_name(struct be_adapter *adapter);
 int be_cmd_get_func_config(struct be_adapter *adapter,
                            struct be_resources *res);
 int be_cmd_get_profile_config(struct be_adapter *adapter,
diff --git a/drivers/net/ethernet/emulex/benet/be_ethtool.c b/drivers/net/ethernet/emulex/benet/be_ethtool.c
index 73a500ccbf69..4d2de4700769 100644
--- a/drivers/net/ethernet/emulex/benet/be_ethtool.c
+++ b/drivers/net/ethernet/emulex/benet/be_ethtool.c
@@ -193,8 +193,6 @@ static const struct be_ethtool_stat et_tx_stats[] = {
         {DRVSTAT_TX_INFO(tx_pkts)},
         /* Number of skbs queued for trasmission by the driver */
         {DRVSTAT_TX_INFO(tx_reqs)},
-        /* Number of TX work request blocks DMAed to HW */
-        {DRVSTAT_TX_INFO(tx_wrbs)},
         /* Number of times the TX queue was stopped due to lack
          * of spaces in the TXQ.
          */
@@ -707,15 +705,17 @@ be_set_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *ecmd)
 
         if (ecmd->autoneg != adapter->phy.fc_autoneg)
                 return -EINVAL;
-        adapter->tx_fc = ecmd->tx_pause;
-        adapter->rx_fc = ecmd->rx_pause;
 
-        status = be_cmd_set_flow_control(adapter,
-                                         adapter->tx_fc, adapter->rx_fc);
-        if (status)
+        status = be_cmd_set_flow_control(adapter, ecmd->tx_pause,
+                                         ecmd->rx_pause);
+        if (status) {
                 dev_warn(&adapter->pdev->dev, "Pause param set failed\n");
+                return be_cmd_status(status);
+        }
 
-        return be_cmd_status(status);
+        adapter->tx_fc = ecmd->tx_pause;
+        adapter->rx_fc = ecmd->rx_pause;
+        return 0;
 }
 
 static int be_set_phys_id(struct net_device *netdev,
diff --git a/drivers/net/ethernet/emulex/benet/be_hw.h b/drivers/net/ethernet/emulex/benet/be_hw.h
index 295ee0835ba0..48840889db62 100644
--- a/drivers/net/ethernet/emulex/benet/be_hw.h
+++ b/drivers/net/ethernet/emulex/benet/be_hw.h
@@ -75,7 +75,7 @@
  * atomically without having to arbitrate for the PCI Interrupt Disable bit
  * with the OS.
  */
-#define MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK      (1 << 29) /* bit 29 */
+#define MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK      BIT(29) /* bit 29 */
 
 /********* PCI Function Capability *********/
 #define BE_FUNCTION_CAPS_RSS                    0x2
@@ -171,94 +171,6 @@
 #define RETRIEVE_FAT    0
 #define QUERY_FAT       1
 
-/* Flashrom related descriptors */
-#define MAX_FLASH_COMP                  32
-#define IMAGE_TYPE_FIRMWARE             160
-#define IMAGE_TYPE_BOOTCODE             224
-#define IMAGE_TYPE_OPTIONROM            32
-
-#define NUM_FLASHDIR_ENTRIES            32
-
-#define OPTYPE_ISCSI_ACTIVE             0
-#define OPTYPE_REDBOOT                  1
-#define OPTYPE_BIOS                     2
-#define OPTYPE_PXE_BIOS                 3
-#define OPTYPE_FCOE_BIOS                8
-#define OPTYPE_ISCSI_BACKUP             9
-#define OPTYPE_FCOE_FW_ACTIVE           10
-#define OPTYPE_FCOE_FW_BACKUP           11
-#define OPTYPE_NCSI_FW                  13
-#define OPTYPE_REDBOOT_DIR              18
-#define OPTYPE_REDBOOT_CONFIG           19
-#define OPTYPE_SH_PHY_FW                21
-#define OPTYPE_FLASHISM_JUMPVECTOR      22
-#define OPTYPE_UFI_DIR                  23
-#define OPTYPE_PHY_FW                   99
-#define TN_8022                         13
-
-#define FLASHROM_OPER_PHY_FLASH         9
-#define FLASHROM_OPER_PHY_SAVE          10
-#define FLASHROM_OPER_FLASH             1
-#define FLASHROM_OPER_SAVE              2
-#define FLASHROM_OPER_REPORT            4
-
-#define FLASH_IMAGE_MAX_SIZE_g2         (1310720) /* Max firmware image size */
-#define FLASH_BIOS_IMAGE_MAX_SIZE_g2    (262144)  /* Max OPTION ROM image sz */
-#define FLASH_REDBOOT_IMAGE_MAX_SIZE_g2 (262144)  /* Max Redboot image sz    */
-#define FLASH_IMAGE_MAX_SIZE_g3         (2097152) /* Max firmware image size */
-#define FLASH_BIOS_IMAGE_MAX_SIZE_g3    (524288)  /* Max OPTION ROM image sz */
-#define FLASH_REDBOOT_IMAGE_MAX_SIZE_g3 (1048576)  /* Max Redboot image sz    */
-#define FLASH_NCSI_IMAGE_MAX_SIZE_g3    (262144)
-#define FLASH_PHY_FW_IMAGE_MAX_SIZE_g3  262144
-
-#define FLASH_NCSI_MAGIC                (0x16032009)
-#define FLASH_NCSI_DISABLED             (0)
-#define FLASH_NCSI_ENABLED              (1)
-
-#define FLASH_NCSI_BITFILE_HDR_OFFSET   (0x600000)
-
-/* Offsets for components on Flash. */
-#define FLASH_iSCSI_PRIMARY_IMAGE_START_g2 (1048576)
-#define FLASH_iSCSI_BACKUP_IMAGE_START_g2  (2359296)
-#define FLASH_FCoE_PRIMARY_IMAGE_START_g2  (3670016)
-#define FLASH_FCoE_BACKUP_IMAGE_START_g2   (4980736)
-#define FLASH_iSCSI_BIOS_START_g2          (7340032)
-#define FLASH_PXE_BIOS_START_g2            (7864320)
-#define FLASH_FCoE_BIOS_START_g2           (524288)
-#define FLASH_REDBOOT_START_g2            (0)
-
-#define FLASH_NCSI_START_g3                (15990784)
-#define FLASH_iSCSI_PRIMARY_IMAGE_START_g3 (2097152)
-#define FLASH_iSCSI_BACKUP_IMAGE_START_g3  (4194304)
-#define FLASH_FCoE_PRIMARY_IMAGE_START_g3  (6291456)
-#define FLASH_FCoE_BACKUP_IMAGE_START_g3   (8388608)
-#define FLASH_iSCSI_BIOS_START_g3          (12582912)
-#define FLASH_PXE_BIOS_START_g3            (13107200)
-#define FLASH_FCoE_BIOS_START_g3           (13631488)
-#define FLASH_REDBOOT_START_g3             (262144)
-#define FLASH_PHY_FW_START_g3              1310720
-
-#define IMAGE_NCSI                      16
-#define IMAGE_OPTION_ROM_PXE            32
-#define IMAGE_OPTION_ROM_FCoE           33
-#define IMAGE_OPTION_ROM_ISCSI          34
-#define IMAGE_FLASHISM_JUMPVECTOR       48
-#define IMAGE_FLASH_ISM                 49
-#define IMAGE_JUMP_VECTOR               50
-#define IMAGE_FIRMWARE_iSCSI            160
-#define IMAGE_FIRMWARE_COMP_iSCSI       161
-#define IMAGE_FIRMWARE_FCoE             162
-#define IMAGE_FIRMWARE_COMP_FCoE        163
-#define IMAGE_FIRMWARE_BACKUP_iSCSI     176
-#define IMAGE_FIRMWARE_BACKUP_COMP_iSCSI 177
-#define IMAGE_FIRMWARE_BACKUP_FCoE      178
-#define IMAGE_FIRMWARE_BACKUP_COMP_FCoE 179
-#define IMAGE_FIRMWARE_PHY              192
-#define IMAGE_REDBOOT_DIR               208
-#define IMAGE_REDBOOT_CONFIG            209
-#define IMAGE_UFI_DIR                   210
-#define IMAGE_BOOT_CODE                 224
-
 /************* Rx Packet Type Encoding **************/
 #define BE_UNICAST_PACKET               0
 #define BE_MULTICAST_PACKET             1
@@ -281,10 +193,10 @@ struct be_eq_entry {
 /* TX Queue Descriptor */
 #define ETH_WRB_FRAG_LEN_MASK           0xFFFF
 struct be_eth_wrb {
-        u32 frag_pa_hi;         /* dword 0 */
-        u32 frag_pa_lo;         /* dword 1 */
-        u32 rsvd0;              /* dword 2 */
-        u32 frag_len;           /* dword 3: bits 0 - 15 */
+        __le32 frag_pa_hi;              /* dword 0 */
+        __le32 frag_pa_lo;              /* dword 1 */
+        u32 rsvd0;                      /* dword 2 */
+        __le32 frag_len;                /* dword 3: bits 0 - 15 */
 } __packed;
 
 /* Pseudo amap definition for eth_hdr_wrb in which each bit of the
@@ -311,8 +223,13 @@ struct amap_eth_hdr_wrb {
         u8 vlan_tag[16];
 } __packed;
 
+#define TX_HDR_WRB_COMPL                1               /* word 2 */
+#define TX_HDR_WRB_EVT                  BIT(1)          /* word 2 */
+#define TX_HDR_WRB_NUM_SHIFT            13              /* word 2: bits 13:17 */
+#define TX_HDR_WRB_NUM_MASK             0x1F            /* word 2: bits 13:17 */
+
 struct be_eth_hdr_wrb {
-        u32 dw[4];
+        __le32 dw[4];
 };
 
 /********* Tx Compl Status Encoding *********/
@@ -435,138 +352,3 @@ struct amap_eth_rx_compl_v1 {
 struct be_eth_rx_compl {
         u32 dw[4];
 };
-
-struct mgmt_hba_attribs {
-        u8 flashrom_version_string[32];
-        u8 manufacturer_name[32];
-        u32 supported_modes;
-        u32 rsvd0[3];
-        u8 ncsi_ver_string[12];
-        u32 default_extended_timeout;
-        u8 controller_model_number[32];
-        u8 controller_description[64];
-        u8 controller_serial_number[32];
-        u8 ip_version_string[32];
-        u8 firmware_version_string[32];
-        u8 bios_version_string[32];
-        u8 redboot_version_string[32];
-        u8 driver_version_string[32];
-        u8 fw_on_flash_version_string[32];
-        u32 functionalities_supported;
-        u16 max_cdblength;
-        u8 asic_revision;
-        u8 generational_guid[16];
-        u8 hba_port_count;
-        u16 default_link_down_timeout;
-        u8 iscsi_ver_min_max;
-        u8 multifunction_device;
-        u8 cache_valid;
-        u8 hba_status;
-        u8 max_domains_supported;
-        u8 phy_port;
-        u32 firmware_post_status;
-        u32 hba_mtu[8];
-        u32 rsvd1[4];
-};
-
-struct mgmt_controller_attrib {
-        struct mgmt_hba_attribs hba_attribs;
-        u16 pci_vendor_id;
-        u16 pci_device_id;
-        u16 pci_sub_vendor_id;
-        u16 pci_sub_system_id;
-        u8 pci_bus_number;
-        u8 pci_device_number;
-        u8 pci_function_number;
-        u8 interface_type;
-        u64 unique_identifier;
-        u32 rsvd0[5];
-};
-
-struct controller_id {
-        u32 vendor;
-        u32 device;
-        u32 subvendor;
-        u32 subdevice;
-};
-
-struct flash_comp {
-        unsigned long offset;
-        int optype;
-        int size;
-        int img_type;
-};
-
-struct image_hdr {
-        u32 imageid;
-        u32 imageoffset;
-        u32 imagelength;
-        u32 image_checksum;
-        u8 image_version[32];
-};
-struct flash_file_hdr_g2 {
-        u8 sign[32];
-        u32 cksum;
-        u32 antidote;
-        struct controller_id cont_id;
-        u32 file_len;
-        u32 chunk_num;
-        u32 total_chunks;
-        u32 num_imgs;
-        u8 build[24];
-};
-
-struct flash_file_hdr_g3 {
-        u8 sign[52];
-        u8 ufi_version[4];
-        u32 file_len;
-        u32 cksum;
-        u32 antidote;
-        u32 num_imgs;
-        u8 build[24];
-        u8 asic_type_rev;
-        u8 rsvd[31];
-};
-
-struct flash_section_hdr {
-        u32 format_rev;
-        u32 cksum;
-        u32 antidote;
-        u32 num_images;
-        u8 id_string[128];
-        u32 rsvd[4];
-} __packed;
-
-struct flash_section_hdr_g2 {
-        u32 format_rev;
-        u32 cksum;
-        u32 antidote;
-        u32 build_num;
-        u8 id_string[128];
-        u32 rsvd[8];
-} __packed;
-
-struct flash_section_entry {
-        u32 type;
-        u32 offset;
-        u32 pad_size;
-        u32 image_size;
-        u32 cksum;
-        u32 entry_point;
-        u16 optype;
-        u16 rsvd0;
-        u32 rsvd1;
-        u8 ver_data[32];
-} __packed;
-
-struct flash_section_info {
-        u8 cookie[32];
-        struct flash_section_hdr fsec_hdr;
-        struct flash_section_entry fsec_entry[32];
-} __packed;
-
-struct flash_section_info_g2 {
-        u8 cookie[32];
-        struct flash_section_hdr_g2 fsec_hdr;
-        struct flash_section_entry fsec_entry[32];
-} __packed;
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index d48806b5cd88..932b93a14965 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -662,48 +662,40 @@ void be_link_status_update(struct be_adapter *adapter, u8 link_status)
                 netif_carrier_off(netdev);
 }
 
-static void be_tx_stats_update(struct be_tx_obj *txo,
-                               u32 wrb_cnt, u32 copied, u32 gso_segs,
-                               bool stopped)
+static void be_tx_stats_update(struct be_tx_obj *txo, struct sk_buff *skb)
 {
         struct be_tx_stats *stats = tx_stats(txo);
 
         u64_stats_update_begin(&stats->sync);
         stats->tx_reqs++;
-        stats->tx_wrbs += wrb_cnt;
-        stats->tx_bytes += copied;
-        stats->tx_pkts += (gso_segs ? gso_segs : 1);
-        if (stopped)
-                stats->tx_stops++;
+        stats->tx_bytes += skb->len;
+        stats->tx_pkts += (skb_shinfo(skb)->gso_segs ? : 1);
         u64_stats_update_end(&stats->sync);
 }
 
-/* Determine number of WRB entries needed to xmit data in an skb */
-static u32 wrb_cnt_for_skb(struct be_adapter *adapter, struct sk_buff *skb,
-                           bool *dummy)
+/* Returns number of WRBs needed for the skb */
+static u32 skb_wrb_cnt(struct sk_buff *skb)
 {
-        int cnt = (skb->len > skb->data_len);
-
-        cnt += skb_shinfo(skb)->nr_frags;
-
-        /* to account for hdr wrb */
-        cnt++;
-        if (lancer_chip(adapter) || !(cnt & 1)) {
-                *dummy = false;
-        } else {
-                /* add a dummy to make it an even num */
-                cnt++;
-                *dummy = true;
-        }
-        BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
-        return cnt;
+        /* +1 for the header wrb */
+        return 1 + (skb_headlen(skb) ? 1 : 0) + skb_shinfo(skb)->nr_frags;
 }
 
 static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
 {
-        wrb->frag_pa_hi = upper_32_bits(addr);
-        wrb->frag_pa_lo = addr & 0xFFFFFFFF;
-        wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK;
+        wrb->frag_pa_hi = cpu_to_le32(upper_32_bits(addr));
+        wrb->frag_pa_lo = cpu_to_le32(lower_32_bits(addr));
+        wrb->frag_len = cpu_to_le32(len & ETH_WRB_FRAG_LEN_MASK);
+        wrb->rsvd0 = 0;
+}
+
+/* A dummy wrb is just all zeros. Using a separate routine for dummy-wrb
+ * to avoid the swap and shift/mask operations in wrb_fill().
+ */
+static inline void wrb_fill_dummy(struct be_eth_wrb *wrb)
+{
+        wrb->frag_pa_hi = 0;
+        wrb->frag_pa_lo = 0;
+        wrb->frag_len = 0;
         wrb->rsvd0 = 0;
 }
 
@@ -713,7 +705,7 @@ static inline u16 be_get_tx_vlan_tag(struct be_adapter *adapter,
         u8 vlan_prio;
         u16 vlan_tag;
 
-        vlan_tag = vlan_tx_tag_get(skb);
+        vlan_tag = skb_vlan_tag_get(skb);
         vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
         /* If vlan priority provided by OS is NOT in available bmap */
         if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
@@ -764,52 +756,57 @@ static void wrb_fill_hdr(struct be_adapter *adapter, struct be_eth_hdr_wrb *hdr,
                         SET_TX_WRB_HDR_BITS(udpcs, hdr, 1);
         }
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 SET_TX_WRB_HDR_BITS(vlan, hdr, 1);
                 vlan_tag = be_get_tx_vlan_tag(adapter, skb);
                 SET_TX_WRB_HDR_BITS(vlan_tag, hdr, vlan_tag);
         }
 
-        /* To skip HW VLAN tagging: evt = 1, compl = 0 */
-        SET_TX_WRB_HDR_BITS(complete, hdr, !skip_hw_vlan);
-        SET_TX_WRB_HDR_BITS(event, hdr, 1);
         SET_TX_WRB_HDR_BITS(num_wrb, hdr, wrb_cnt);
         SET_TX_WRB_HDR_BITS(len, hdr, len);
+
+        /* Hack to skip HW VLAN tagging needs evt = 1, compl = 0
+         * When this hack is not needed, the evt bit is set while ringing DB
+         */
+        if (skip_hw_vlan)
+                SET_TX_WRB_HDR_BITS(event, hdr, 1);
 }
 
 static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
                           bool unmap_single)
 {
         dma_addr_t dma;
+        u32 frag_len = le32_to_cpu(wrb->frag_len);
 
-        be_dws_le_to_cpu(wrb, sizeof(*wrb));
 
-        dma = (u64)wrb->frag_pa_hi << 32 | (u64)wrb->frag_pa_lo;
-        if (wrb->frag_len) {
+        dma = (u64)le32_to_cpu(wrb->frag_pa_hi) << 32 |
+                (u64)le32_to_cpu(wrb->frag_pa_lo);
+        if (frag_len) {
                 if (unmap_single)
-                        dma_unmap_single(dev, dma, wrb->frag_len,
-                                         DMA_TO_DEVICE);
+                        dma_unmap_single(dev, dma, frag_len, DMA_TO_DEVICE);
                 else
-                        dma_unmap_page(dev, dma, wrb->frag_len, DMA_TO_DEVICE);
+                        dma_unmap_page(dev, dma, frag_len, DMA_TO_DEVICE);
         }
 }
 
-static int make_tx_wrbs(struct be_adapter *adapter, struct be_queue_info *txq,
-                        struct sk_buff *skb, u32 wrb_cnt, bool dummy_wrb,
-                        bool skip_hw_vlan)
+/* Returns the number of WRBs used up by the skb */
+static u32 be_xmit_enqueue(struct be_adapter *adapter, struct be_tx_obj *txo,
+                           struct sk_buff *skb, bool skip_hw_vlan)
 {
-        dma_addr_t busaddr;
-        int i, copied = 0;
+        u32 i, copied = 0, wrb_cnt = skb_wrb_cnt(skb);
         struct device *dev = &adapter->pdev->dev;
-        struct sk_buff *first_skb = skb;
-        struct be_eth_wrb *wrb;
+        struct be_queue_info *txq = &txo->q;
         struct be_eth_hdr_wrb *hdr;
         bool map_single = false;
-        u16 map_head;
+        struct be_eth_wrb *wrb;
+        dma_addr_t busaddr;
+        u16 head = txq->head;
 
         hdr = queue_head_node(txq);
+        wrb_fill_hdr(adapter, hdr, skb, wrb_cnt, skb->len, skip_hw_vlan);
+        be_dws_cpu_to_le(hdr, sizeof(*hdr));
+
         queue_head_inc(txq);
-        map_head = txq->head;
 
         if (skb->len > skb->data_len) {
                 int len = skb_headlen(skb);
@@ -820,7 +817,6 @@ static int make_tx_wrbs(struct be_adapter *adapter, struct be_queue_info *txq,
                 map_single = true;
                 wrb = queue_head_node(txq);
                 wrb_fill(wrb, busaddr, len);
-                be_dws_cpu_to_le(wrb, sizeof(*wrb));
                 queue_head_inc(txq);
                 copied += len;
         }
@@ -834,35 +830,44 @@ static int make_tx_wrbs(struct be_adapter *adapter, struct be_queue_info *txq,
                         goto dma_err;
                 wrb = queue_head_node(txq);
                 wrb_fill(wrb, busaddr, skb_frag_size(frag));
-                be_dws_cpu_to_le(wrb, sizeof(*wrb));
                 queue_head_inc(txq);
                 copied += skb_frag_size(frag);
         }
 
-        if (dummy_wrb) {
-                wrb = queue_head_node(txq);
-                wrb_fill(wrb, 0, 0);
-                be_dws_cpu_to_le(wrb, sizeof(*wrb));
-                queue_head_inc(txq);
-        }
+        BUG_ON(txo->sent_skb_list[head]);
+        txo->sent_skb_list[head] = skb;
+        txo->last_req_hdr = head;
+        atomic_add(wrb_cnt, &txq->used);
+        txo->last_req_wrb_cnt = wrb_cnt;
+        txo->pend_wrb_cnt += wrb_cnt;
 
-        wrb_fill_hdr(adapter, hdr, first_skb, wrb_cnt, copied, skip_hw_vlan);
-        be_dws_cpu_to_le(hdr, sizeof(*hdr));
+        be_tx_stats_update(txo, skb);
+        return wrb_cnt;
 
-        return copied;
 dma_err:
-        txq->head = map_head;
+        /* Bring the queue back to the state it was in before this
+         * routine was invoked.
+         */
+        txq->head = head;
+        /* skip the first wrb (hdr); it's not mapped */
+        queue_head_inc(txq);
         while (copied) {
                 wrb = queue_head_node(txq);
                 unmap_tx_frag(dev, wrb, map_single);
                 map_single = false;
-                copied -= wrb->frag_len;
+                copied -= le32_to_cpu(wrb->frag_len);
                 adapter->drv_stats.dma_map_errors++;
                 queue_head_inc(txq);
         }
+        txq->head = head;
         return 0;
 }
 
+static inline int qnq_async_evt_rcvd(struct be_adapter *adapter)
+{
+        return adapter->flags & BE_FLAGS_QNQ_ASYNC_EVT_RCVD;
+}
+
 static struct sk_buff *be_insert_vlan_in_pkt(struct be_adapter *adapter,
                                              struct sk_buff *skb,
                                              bool *skip_hw_vlan)
@@ -873,7 +878,7 @@ static struct sk_buff *be_insert_vlan_in_pkt(struct be_adapter *adapter,
         if (unlikely(!skb))
                 return skb;
 
-        if (vlan_tx_tag_present(skb))
+        if (skb_vlan_tag_present(skb))
                 vlan_tag = be_get_tx_vlan_tag(adapter, skb);
 
         if (qnq_async_evt_rcvd(adapter) && adapter->pvid) {
@@ -932,7 +937,7 @@ static bool be_ipv6_exthdr_check(struct sk_buff *skb)
 
 static int be_vlan_tag_tx_chk(struct be_adapter *adapter, struct sk_buff *skb)
 {
-        return vlan_tx_tag_present(skb) || adapter->pvid || adapter->qnq_vid;
+        return skb_vlan_tag_present(skb) || adapter->pvid || adapter->qnq_vid;
 }
 
 static int be_ipv6_tx_stall_chk(struct be_adapter *adapter, struct sk_buff *skb)
@@ -955,7 +960,7 @@ static struct sk_buff *be_lancer_xmit_workarounds(struct be_adapter *adapter,
         eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ?
                                                 VLAN_ETH_HLEN : ETH_HLEN;
         if (skb->len <= 60 &&
-            (lancer_chip(adapter) || vlan_tx_tag_present(skb)) &&
+            (lancer_chip(adapter) || skb_vlan_tag_present(skb)) &&
             is_ipv4_pkt(skb)) {
                 ip = (struct iphdr *)ip_hdr(skb);
                 pskb_trim(skb, eth_hdr_len + ntohs(ip->tot_len));
@@ -973,7 +978,7 @@ static struct sk_buff *be_lancer_xmit_workarounds(struct be_adapter *adapter,
          * Manually insert VLAN in pkt.
          */
         if (skb->ip_summed != CHECKSUM_PARTIAL &&
-            vlan_tx_tag_present(skb)) {
+            skb_vlan_tag_present(skb)) {
                 skb = be_insert_vlan_in_pkt(adapter, skb, skip_hw_vlan);
                 if (unlikely(!skb))
                         goto err;
@@ -1030,52 +1035,64 @@ static struct sk_buff *be_xmit_workarounds(struct be_adapter *adapter,
         return skb;
 }
 
+static void be_xmit_flush(struct be_adapter *adapter, struct be_tx_obj *txo)
+{
+        struct be_queue_info *txq = &txo->q;
+        struct be_eth_hdr_wrb *hdr = queue_index_node(txq, txo->last_req_hdr);
+
+        /* Mark the last request eventable if it hasn't been marked already */
+        if (!(hdr->dw[2] & cpu_to_le32(TX_HDR_WRB_EVT)))
+                hdr->dw[2] |= cpu_to_le32(TX_HDR_WRB_EVT | TX_HDR_WRB_COMPL);
+
+        /* compose a dummy wrb if there are odd set of wrbs to notify */
+        if (!lancer_chip(adapter) && (txo->pend_wrb_cnt & 1)) {
+                wrb_fill_dummy(queue_head_node(txq));
+                queue_head_inc(txq);
+                atomic_inc(&txq->used);
+                txo->pend_wrb_cnt++;
+                hdr->dw[2] &= ~cpu_to_le32(TX_HDR_WRB_NUM_MASK <<
+                                           TX_HDR_WRB_NUM_SHIFT);
+                hdr->dw[2] |= cpu_to_le32((txo->last_req_wrb_cnt + 1) <<
+                                          TX_HDR_WRB_NUM_SHIFT);
+        }
+        be_txq_notify(adapter, txo, txo->pend_wrb_cnt);
+        txo->pend_wrb_cnt = 0;
+}
+
 static netdev_tx_t be_xmit(struct sk_buff *skb, struct net_device *netdev)
 {
+        bool skip_hw_vlan = false, flush = !skb->xmit_more;
         struct be_adapter *adapter = netdev_priv(netdev);
-        struct be_tx_obj *txo = &adapter->tx_obj[skb_get_queue_mapping(skb)];
+        u16 q_idx = skb_get_queue_mapping(skb);
+        struct be_tx_obj *txo = &adapter->tx_obj[q_idx];
         struct be_queue_info *txq = &txo->q;
-        bool dummy_wrb, stopped = false;
-        u32 wrb_cnt = 0, copied = 0;
-        bool skip_hw_vlan = false;
-        u32 start = txq->head;
+        u16 wrb_cnt;
 
         skb = be_xmit_workarounds(adapter, skb, &skip_hw_vlan);
-        if (!skb) {
-                tx_stats(txo)->tx_drv_drops++;
-                return NETDEV_TX_OK;
-        }
-
-        wrb_cnt = wrb_cnt_for_skb(adapter, skb, &dummy_wrb);
+        if (unlikely(!skb))
+                goto drop;
 
-        copied = make_tx_wrbs(adapter, txq, skb, wrb_cnt, dummy_wrb,
-                              skip_hw_vlan);
-        if (copied) {
-                int gso_segs = skb_shinfo(skb)->gso_segs;
+        wrb_cnt = be_xmit_enqueue(adapter, txo, skb, skip_hw_vlan);
+        if (unlikely(!wrb_cnt)) {
+                dev_kfree_skb_any(skb);
+                goto drop;
+        }
 
-                /* record the sent skb in the sent_skb table */
-                BUG_ON(txo->sent_skb_list[start]);
-                txo->sent_skb_list[start] = skb;
+        if ((atomic_read(&txq->used) + BE_MAX_TX_FRAG_COUNT) >= txq->len) {
+                netif_stop_subqueue(netdev, q_idx);
+                tx_stats(txo)->tx_stops++;
+        }
 
-                /* Ensure txq has space for the next skb; Else stop the queue
-                 * *BEFORE* ringing the tx doorbell, so that we serialze the
-                 * tx compls of the current transmit which'll wake up the queue
-                 */
-                atomic_add(wrb_cnt, &txq->used);
-                if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >=
-                                                                txq->len) {
-                        netif_stop_subqueue(netdev, skb_get_queue_mapping(skb));
-                        stopped = true;
-                }
+        if (flush || __netif_subqueue_stopped(netdev, q_idx))
+                be_xmit_flush(adapter, txo);
 
-                be_txq_notify(adapter, txo, wrb_cnt);
+        return NETDEV_TX_OK;
+drop:
+        tx_stats(txo)->tx_drv_drops++;
+        /* Flush the already enqueued tx requests */
+        if (flush && txo->pend_wrb_cnt)
+                be_xmit_flush(adapter, txo);
 
-                be_tx_stats_update(txo, wrb_cnt, copied, gso_segs, stopped);
-        } else {
-                txq->head = start;
-                tx_stats(txo)->tx_drv_drops++;
-                dev_kfree_skb_any(skb);
-        }
         return NETDEV_TX_OK;
 }
 
@@ -1096,6 +1113,43 @@ static int be_change_mtu(struct net_device *netdev, int new_mtu)
         return 0;
 }
 
+static inline bool be_in_all_promisc(struct be_adapter *adapter)
+{
+        return (adapter->if_flags & BE_IF_FLAGS_ALL_PROMISCUOUS) ==
+                        BE_IF_FLAGS_ALL_PROMISCUOUS;
+}
+
+static int be_set_vlan_promisc(struct be_adapter *adapter)
+{
+        struct device *dev = &adapter->pdev->dev;
+        int status;
+
+        if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS)
+                return 0;
+
+        status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, ON);
+        if (!status) {
+                dev_info(dev, "Enabled VLAN promiscuous mode\n");
+                adapter->if_flags |= BE_IF_FLAGS_VLAN_PROMISCUOUS;
+        } else {
+                dev_err(dev, "Failed to enable VLAN promiscuous mode\n");
+        }
+        return status;
+}
+
+static int be_clear_vlan_promisc(struct be_adapter *adapter)
+{
+        struct device *dev = &adapter->pdev->dev;
+        int status;
+
+        status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, OFF);
+        if (!status) {
+                dev_info(dev, "Disabling VLAN promiscuous mode\n");
+                adapter->if_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
+        }
+        return status;
+}
+
 /*
  * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
  * If the user configures more, place BE in vlan promiscuous mode.
@@ -1108,11 +1162,11 @@ static int be_vid_config(struct be_adapter *adapter)
         int status = 0;
 
         /* No need to further configure vids if in promiscuous mode */
-        if (adapter->promiscuous)
+        if (be_in_all_promisc(adapter))
                 return 0;
 
         if (adapter->vlans_added > be_max_vlans(adapter))
-                goto set_vlan_promisc;
+                return be_set_vlan_promisc(adapter);
 
         /* Construct VLAN Table to give to HW */
         for_each_set_bit(i, adapter->vids, VLAN_N_VID)
@@ -1120,36 +1174,14 @@ static int be_vid_config(struct be_adapter *adapter)
 
         status = be_cmd_vlan_config(adapter, adapter->if_handle, vids, num);
         if (status) {
+                dev_err(dev, "Setting HW VLAN filtering failed\n");
                 /* Set to VLAN promisc mode as setting VLAN filter failed */
                 if (addl_status(status) ==
                                 MCC_ADDL_STATUS_INSUFFICIENT_RESOURCES)
-                        goto set_vlan_promisc;
-                dev_err(dev, "Setting HW VLAN filtering failed\n");
-        } else {
-                if (adapter->flags & BE_FLAGS_VLAN_PROMISC) {
-                        /* hw VLAN filtering re-enabled. */
-                        status = be_cmd_rx_filter(adapter,
-                                                  BE_FLAGS_VLAN_PROMISC, OFF);
-                        if (!status) {
-                                dev_info(dev,
-                                         "Disabling VLAN Promiscuous mode\n");
-                                adapter->flags &= ~BE_FLAGS_VLAN_PROMISC;
-                        }
-                }
+                        return be_set_vlan_promisc(adapter);
+        } else if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) {
+                status = be_clear_vlan_promisc(adapter);
         }
-
-        return status;
-
-set_vlan_promisc:
-        if (adapter->flags & BE_FLAGS_VLAN_PROMISC)
-                return 0;
-
-        status = be_cmd_rx_filter(adapter, BE_FLAGS_VLAN_PROMISC, ON);
-        if (!status) {
-                dev_info(dev, "Enable VLAN Promiscuous mode\n");
-                adapter->flags |= BE_FLAGS_VLAN_PROMISC;
-        } else
-                dev_err(dev, "Failed to enable VLAN Promiscuous mode\n");
         return status;
 }
 
@@ -1191,79 +1223,99 @@ static int be_vlan_rem_vid(struct net_device *netdev, __be16 proto, u16 vid)
         return be_vid_config(adapter);
 }
 
-static void be_clear_promisc(struct be_adapter *adapter)
+static void be_clear_all_promisc(struct be_adapter *adapter)
 {
-        adapter->promiscuous = false;
-        adapter->flags &= ~(BE_FLAGS_VLAN_PROMISC | BE_FLAGS_MCAST_PROMISC);
+        be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, OFF);
+        adapter->if_flags &= ~BE_IF_FLAGS_ALL_PROMISCUOUS;
+}
 
-        be_cmd_rx_filter(adapter, IFF_PROMISC, OFF);
+static void be_set_all_promisc(struct be_adapter *adapter)
+{
+        be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, ON);
+        adapter->if_flags |= BE_IF_FLAGS_ALL_PROMISCUOUS;
 }
 
-static void be_set_rx_mode(struct net_device *netdev)
+static void be_set_mc_promisc(struct be_adapter *adapter)
 {
-        struct be_adapter *adapter = netdev_priv(netdev);
         int status;
 
-        if (netdev->flags & IFF_PROMISC) {
-                be_cmd_rx_filter(adapter, IFF_PROMISC, ON);
-                adapter->promiscuous = true;
-                goto done;
-        }
+        if (adapter->if_flags & BE_IF_FLAGS_MCAST_PROMISCUOUS)
+                return;
 
-        /* BE was previously in promiscuous mode; disable it */
-        if (adapter->promiscuous) {
-                be_clear_promisc(adapter);
-                if (adapter->vlans_added)
-                        be_vid_config(adapter);
+        status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MCAST_PROMISCUOUS, ON);
+        if (!status)
+                adapter->if_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS;
+}
+
+static void be_set_mc_list(struct be_adapter *adapter)
+{
+        int status;
+
+        status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MULTICAST, ON);
+        if (!status)
+                adapter->if_flags &= ~BE_IF_FLAGS_MCAST_PROMISCUOUS;
+        else
+                be_set_mc_promisc(adapter);
+}
+
+static void be_set_uc_list(struct be_adapter *adapter)
+{
+        struct netdev_hw_addr *ha;
+        int i = 1; /* First slot is claimed by the Primary MAC */
+
+        for (; adapter->uc_macs > 0; adapter->uc_macs--, i++)
+                be_cmd_pmac_del(adapter, adapter->if_handle,
+                                adapter->pmac_id[i], 0);
+
+        if (netdev_uc_count(adapter->netdev) > be_max_uc(adapter)) {
+                be_set_all_promisc(adapter);
+                return;
         }
 
-        /* Enable multicast promisc if num configured exceeds what we support */
-        if (netdev->flags & IFF_ALLMULTI ||
-            netdev_mc_count(netdev) > be_max_mc(adapter))
-                goto set_mcast_promisc;
+        netdev_for_each_uc_addr(ha, adapter->netdev) {
+                adapter->uc_macs++; /* First slot is for Primary MAC */
+                be_cmd_pmac_add(adapter, (u8 *)ha->addr, adapter->if_handle,
+                                &adapter->pmac_id[adapter->uc_macs], 0);
+        }
+}
 
-        if (netdev_uc_count(netdev) != adapter->uc_macs) {
-                struct netdev_hw_addr *ha;
-                int i = 1; /* First slot is claimed by the Primary MAC */
+static void be_clear_uc_list(struct be_adapter *adapter)
+{
+        int i;
 
-                for (; adapter->uc_macs > 0; adapter->uc_macs--, i++) {
-                        be_cmd_pmac_del(adapter, adapter->if_handle,
-                                        adapter->pmac_id[i], 0);
-                }
+        for (i = 1; i < (adapter->uc_macs + 1); i++)
+                be_cmd_pmac_del(adapter, adapter->if_handle,
+                                adapter->pmac_id[i], 0);
+        adapter->uc_macs = 0;
+}
 
-                if (netdev_uc_count(netdev) > be_max_uc(adapter)) {
-                        be_cmd_rx_filter(adapter, IFF_PROMISC, ON);
-                        adapter->promiscuous = true;
-                        goto done;
-                }
+static void be_set_rx_mode(struct net_device *netdev)
+{
+        struct be_adapter *adapter = netdev_priv(netdev);
 
-                netdev_for_each_uc_addr(ha, adapter->netdev) {
-                        adapter->uc_macs++; /* First slot is for Primary MAC */
-                        be_cmd_pmac_add(adapter, (u8 *)ha->addr,
-                                        adapter->if_handle,
-                                        &adapter->pmac_id[adapter->uc_macs], 0);
-                }
+        if (netdev->flags & IFF_PROMISC) {
+                be_set_all_promisc(adapter);
+                return;
         }
 
-        status = be_cmd_rx_filter(adapter, IFF_MULTICAST, ON);
-        if (!status) {
-                if (adapter->flags & BE_FLAGS_MCAST_PROMISC)
-                        adapter->flags &= ~BE_FLAGS_MCAST_PROMISC;
-                goto done;
+        /* Interface was previously in promiscuous mode; disable it */
+        if (be_in_all_promisc(adapter)) {
+                be_clear_all_promisc(adapter);
+                if (adapter->vlans_added)
+                        be_vid_config(adapter);
         }
 
-set_mcast_promisc:
-        if (adapter->flags & BE_FLAGS_MCAST_PROMISC)
+        /* Enable multicast promisc if num configured exceeds what we support */
+        if (netdev->flags & IFF_ALLMULTI ||
+            netdev_mc_count(netdev) > be_max_mc(adapter)) {
+                be_set_mc_promisc(adapter);
                 return;
+        }
 
-        /* Set to MCAST promisc mode if setting MULTICAST address fails
-         * or if num configured exceeds what we support
-         */
-        status = be_cmd_rx_filter(adapter, IFF_ALLMULTI, ON);
-        if (!status)
-                adapter->flags |= BE_FLAGS_MCAST_PROMISC;
-done:
-        return;
+        if (netdev_uc_count(netdev) != adapter->uc_macs)
+                be_set_uc_list(adapter);
+
+        be_set_mc_list(adapter);
 }
 
 static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
@@ -1959,32 +2011,34 @@ static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
 static u16 be_tx_compl_process(struct be_adapter *adapter,
                                struct be_tx_obj *txo, u16 last_index)
 {
+        struct sk_buff **sent_skbs = txo->sent_skb_list;
         struct be_queue_info *txq = &txo->q;
+        u16 frag_index, num_wrbs = 0;
+        struct sk_buff *skb = NULL;
+        bool unmap_skb_hdr = false;
         struct be_eth_wrb *wrb;
-        struct sk_buff **sent_skbs = txo->sent_skb_list;
-        struct sk_buff *sent_skb;
-        u16 cur_index, num_wrbs = 1; /* account for hdr wrb */
-        bool unmap_skb_hdr = true;
-
-        sent_skb = sent_skbs[txq->tail];
-        BUG_ON(!sent_skb);
-        sent_skbs[txq->tail] = NULL;
-
-        /* skip header wrb */
-        queue_tail_inc(txq);
 
         do {
-                cur_index = txq->tail;
+                if (sent_skbs[txq->tail]) {
+                        /* Free skb from prev req */
+                        if (skb)
+                                dev_consume_skb_any(skb);
+                        skb = sent_skbs[txq->tail];
+                        sent_skbs[txq->tail] = NULL;
+                        queue_tail_inc(txq);  /* skip hdr wrb */
+                        num_wrbs++;
+                        unmap_skb_hdr = true;
+                }
                 wrb = queue_tail_node(txq);
+                frag_index = txq->tail;
                 unmap_tx_frag(&adapter->pdev->dev, wrb,
-                              (unmap_skb_hdr && skb_headlen(sent_skb)));
+                              (unmap_skb_hdr && skb_headlen(skb)));
                 unmap_skb_hdr = false;
-
-                num_wrbs++;
                 queue_tail_inc(txq);
-        } while (cur_index != last_index);
+                num_wrbs++;
+        } while (frag_index != last_index);
+        dev_consume_skb_any(skb);
 
-        dev_consume_skb_any(sent_skb);
         return num_wrbs;
 }
 
@@ -2068,12 +2122,11 @@ static void be_rx_cq_clean(struct be_rx_obj *rxo)
 
 static void be_tx_compl_clean(struct be_adapter *adapter)
 {
+        u16 end_idx, notified_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
+        struct device *dev = &adapter->pdev->dev;
         struct be_tx_obj *txo;
         struct be_queue_info *txq;
         struct be_eth_tx_compl *txcp;
-        u16 end_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
-        struct sk_buff *sent_skb;
-        bool dummy_wrb;
         int i, pending_txqs;
 
         /* Stop polling for compls when HW has been silent for 10ms */
@@ -2095,7 +2148,7 @@ static void be_tx_compl_clean(struct be_adapter *adapter)
                                 atomic_sub(num_wrbs, &txq->used);
                                 timeo = 0;
                         }
-                        if (atomic_read(&txq->used) == 0)
+                        if (atomic_read(&txq->used) == txo->pend_wrb_cnt)
                                 pending_txqs--;
                 }
 
@@ -2105,21 +2158,29 @@ static void be_tx_compl_clean(struct be_adapter *adapter)
                 mdelay(1);
         } while (true);
 
+        /* Free enqueued TX that was never notified to HW */
         for_all_tx_queues(adapter, txo, i) {
                 txq = &txo->q;
-                if (atomic_read(&txq->used))
-                        dev_err(&adapter->pdev->dev, "%d pending tx-compls\n",
-                                atomic_read(&txq->used));
 
-                /* free posted tx for which compls will never arrive */
-                while (atomic_read(&txq->used)) {
-                        sent_skb = txo->sent_skb_list[txq->tail];
+                if (atomic_read(&txq->used)) {
+                        dev_info(dev, "txq%d: cleaning %d pending tx-wrbs\n",
+                                 i, atomic_read(&txq->used));
+                        notified_idx = txq->tail;
                         end_idx = txq->tail;
-                        num_wrbs = wrb_cnt_for_skb(adapter, sent_skb,
-                                                   &dummy_wrb);
-                        index_adv(&end_idx, num_wrbs - 1, txq->len);
+                        index_adv(&end_idx, atomic_read(&txq->used) - 1,
+                                  txq->len);
+                        /* Use the tx-compl process logic to handle requests
+                         * that were not sent to the HW.
+                         */
                         num_wrbs = be_tx_compl_process(adapter, txo, end_idx);
                         atomic_sub(num_wrbs, &txq->used);
+                        BUG_ON(atomic_read(&txq->used));
+                        txo->pend_wrb_cnt = 0;
+                        /* Since hw was never notified of these requests,
+                         * reset TXQ indices
+                         */
+                        txq->head = notified_idx;
+                        txq->tail = notified_idx;
                 }
         }
 }
@@ -2514,6 +2575,106 @@ static void be_process_tx(struct be_adapter *adapter, struct be_tx_obj *txo,
         }
 }
 
+#ifdef CONFIG_NET_RX_BUSY_POLL
+static inline bool be_lock_napi(struct be_eq_obj *eqo)
+{
+        bool status = true;
+
+        spin_lock(&eqo->lock); /* BH is already disabled */
+        if (eqo->state & BE_EQ_LOCKED) {
+                WARN_ON(eqo->state & BE_EQ_NAPI);
+                eqo->state |= BE_EQ_NAPI_YIELD;
+                status = false;
+        } else {
+                eqo->state = BE_EQ_NAPI;
+        }
+        spin_unlock(&eqo->lock);
+        return status;
+}
+
+static inline void be_unlock_napi(struct be_eq_obj *eqo)
+{
+        spin_lock(&eqo->lock); /* BH is already disabled */
+
+        WARN_ON(eqo->state & (BE_EQ_POLL | BE_EQ_NAPI_YIELD));
+        eqo->state = BE_EQ_IDLE;
+
+        spin_unlock(&eqo->lock);
+}
+
+static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
+{
+        bool status = true;
+
+        spin_lock_bh(&eqo->lock);
+        if (eqo->state & BE_EQ_LOCKED) {
+                eqo->state |= BE_EQ_POLL_YIELD;
+                status = false;
+        } else {
+                eqo->state |= BE_EQ_POLL;
+        }
+        spin_unlock_bh(&eqo->lock);
+        return status;
+}
+
+static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
+{
+        spin_lock_bh(&eqo->lock);
+
+        WARN_ON(eqo->state & (BE_EQ_NAPI));
+        eqo->state = BE_EQ_IDLE;
+
+        spin_unlock_bh(&eqo->lock);
+}
+
+static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
+{
+        spin_lock_init(&eqo->lock);
+        eqo->state = BE_EQ_IDLE;
+}
+
+static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
+{
+        local_bh_disable();
+
+        /* It's enough to just acquire napi lock on the eqo to stop
+         * be_busy_poll() from processing any queueus.
+         */
+        while (!be_lock_napi(eqo))
+                mdelay(1);
+
+        local_bh_enable();
+}
+
+#else /* CONFIG_NET_RX_BUSY_POLL */
+
+static inline bool be_lock_napi(struct be_eq_obj *eqo)
+{
+        return true;
+}
+
+static inline void be_unlock_napi(struct be_eq_obj *eqo)
+{
+}
+
+static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
+{
+        return false;
+}
+
+static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
+{
+}
+
+static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
+{
+}
+
+static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
+{
+}
+#endif /* CONFIG_NET_RX_BUSY_POLL */
+
 int be_poll(struct napi_struct *napi, int budget)
 {
         struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
@@ -2833,11 +2994,7 @@ static int be_close(struct net_device *netdev)
         be_tx_compl_clean(adapter);
 
         be_rx_qs_destroy(adapter);
-
-        for (i = 1; i < (adapter->uc_macs + 1); i++)
-                be_cmd_pmac_del(adapter, adapter->if_handle,
-                                adapter->pmac_id[i], 0);
-        adapter->uc_macs = 0;
+        be_clear_uc_list(adapter);
 
         for_all_evt_queues(adapter, eqo, i) {
                 if (msix_enabled(adapter))
@@ -3008,6 +3165,19 @@ static int be_setup_wol(struct be_adapter *adapter, bool enable)
         return status;
 }
 
+static void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac)
+{
+        u32 addr;
+
+        addr = jhash(adapter->netdev->dev_addr, ETH_ALEN, 0);
+
+        mac[5] = (u8)(addr & 0xFF);
+        mac[4] = (u8)((addr >> 8) & 0xFF);
+        mac[3] = (u8)((addr >> 16) & 0xFF);
+        /* Use the OUI from the current MAC address */
+        memcpy(mac, adapter->netdev->dev_addr, 3);
+}
+
 /*
  * Generate a seed MAC address from the PF MAC Address using jhash.
  * MAC Address for VFs are assigned incrementally starting from the seed.
@@ -3108,14 +3278,9 @@ static void be_cancel_worker(struct be_adapter *adapter)
 
 static void be_mac_clear(struct be_adapter *adapter)
 {
-        int i;
-
         if (adapter->pmac_id) {
-                for (i = 0; i < (adapter->uc_macs + 1); i++)
-                        be_cmd_pmac_del(adapter, adapter->if_handle,
-                                        adapter->pmac_id[i], 0);
-                adapter->uc_macs = 0;
-
+                be_cmd_pmac_del(adapter, adapter->if_handle,
+                                adapter->pmac_id[0], 0);
                 kfree(adapter->pmac_id);
                 adapter->pmac_id = NULL;
         }
@@ -3171,13 +3336,32 @@ static int be_clear(struct be_adapter *adapter)
         return 0;
 }
 
+static int be_if_create(struct be_adapter *adapter, u32 *if_handle,
+                        u32 cap_flags, u32 vf)
+{
+        u32 en_flags;
+        int status;
+
+        en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
+                   BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS |
+                   BE_IF_FLAGS_RSS;
+
+        en_flags &= cap_flags;
+
+        status = be_cmd_if_create(adapter, cap_flags, en_flags,
+                                  if_handle, vf);
+
+        return status;
+}
+
 static int be_vfs_if_create(struct be_adapter *adapter)
 {
         struct be_resources res = {0};
         struct be_vf_cfg *vf_cfg;
-        u32 cap_flags, en_flags, vf;
-        int status = 0;
+        u32 cap_flags, vf;
+        int status;
 
+        /* If a FW profile exists, then cap_flags are updated */
         cap_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
                     BE_IF_FLAGS_MULTICAST;
 
@@ -3189,18 +3373,13 @@ static int be_vfs_if_create(struct be_adapter *adapter)
                                 cap_flags = res.if_cap_flags;
                 }
 
-                /* If a FW profile exists, then cap_flags are updated */
-                en_flags = cap_flags & (BE_IF_FLAGS_UNTAGGED |
-                                        BE_IF_FLAGS_BROADCAST |
-                                        BE_IF_FLAGS_MULTICAST);
-                status =
-                    be_cmd_if_create(adapter, cap_flags, en_flags,
-                                     &vf_cfg->if_handle, vf + 1);
+                status = be_if_create(adapter, &vf_cfg->if_handle,
+                                      cap_flags, vf + 1);
                 if (status)
-                        goto err;
+                        return status;
         }
-err:
-        return status;
+
+        return 0;
 }
 
 static int be_vf_setup_init(struct be_adapter *adapter)
@@ -3385,7 +3564,7 @@ static void be_setup_init(struct be_adapter *adapter)
         adapter->phy.link_speed = -1;
         adapter->if_handle = -1;
         adapter->be3_native = false;
-        adapter->promiscuous = false;
+        adapter->if_flags = 0;
         if (be_physfn(adapter))
                 adapter->cmd_privileges = MAX_PRIVILEGES;
         else
@@ -3512,7 +3691,9 @@ static int be_get_config(struct be_adapter *adapter)
         if (status)
                 return status;
 
-         if (be_physfn(adapter)) {
+        be_cmd_query_port_name(adapter);
+
+        if (be_physfn(adapter)) {
                 status = be_cmd_get_active_profile(adapter, &profile_id);
                 if (!status)
                         dev_info(&adapter->pdev->dev,
@@ -3638,10 +3819,20 @@ int be_update_queues(struct be_adapter *adapter)
         return status;
 }
 
+static inline int fw_major_num(const char *fw_ver)
+{
+        int fw_major = 0, i;
+
+        i = sscanf(fw_ver, "%d.", &fw_major);
+        if (i != 1)
+                return 0;
+
+        return fw_major;
+}
+
 static int be_setup(struct be_adapter *adapter)
 {
         struct device *dev = &adapter->pdev->dev;
-        u32 tx_fc, rx_fc, en_flags;
         int status;
 
         be_setup_init(adapter);
@@ -3657,13 +3848,8 @@ static int be_setup(struct be_adapter *adapter)
         if (status)
                 goto err;
 
-        en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
-                   BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS;
-        if (adapter->function_caps & BE_FUNCTION_CAPS_RSS)
-                en_flags |= BE_IF_FLAGS_RSS;
-        en_flags = en_flags & be_if_cap_flags(adapter);
-        status = be_cmd_if_create(adapter, be_if_cap_flags(adapter), en_flags,
-                                  &adapter->if_handle, 0);
+        status = be_if_create(adapter, &adapter->if_handle,
+                              be_if_cap_flags(adapter), 0);
         if (status)
                 goto err;
 
@@ -3696,11 +3882,14 @@ static int be_setup(struct be_adapter *adapter)
 
         be_cmd_get_acpi_wol_cap(adapter);
 
-        be_cmd_get_flow_control(adapter, &tx_fc, &rx_fc);
+        status = be_cmd_set_flow_control(adapter, adapter->tx_fc,
+                                         adapter->rx_fc);
+        if (status)
+                be_cmd_get_flow_control(adapter, &adapter->tx_fc,
+                                        &adapter->rx_fc);
 
-        if (rx_fc != adapter->rx_fc || tx_fc != adapter->tx_fc)
-                be_cmd_set_flow_control(adapter, adapter->tx_fc,
-                                        adapter->rx_fc);
+        dev_info(&adapter->pdev->dev, "HW Flow control - TX:%d RX:%d\n",
+                 adapter->tx_fc, adapter->rx_fc);
 
         if (be_physfn(adapter))
                 be_cmd_set_logical_link_config(adapter,
@@ -3739,7 +3928,7 @@ static char flash_cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "};
 
 static bool phy_flashing_required(struct be_adapter *adapter)
 {
-        return (adapter->phy.phy_type == TN_8022 &&
+        return (adapter->phy.phy_type == PHY_TYPE_TN_8022 &&
                 adapter->phy.interface_type == PHY_TYPE_BASET_10GB);
 }
 
@@ -3790,7 +3979,8 @@ static int be_check_flash_crc(struct be_adapter *adapter, const u8 *p,
         int status;
         u8 crc[4];
 
-        status = be_cmd_get_flash_crc(adapter, crc, img_optype, img_size - 4);
+        status = be_cmd_get_flash_crc(adapter, crc, img_optype, img_offset,
+                                      img_size - 4);
         if (status)
                 return status;
 
@@ -3806,13 +3996,13 @@ static int be_check_flash_crc(struct be_adapter *adapter, const u8 *p,
 }
 
 static int be_flash(struct be_adapter *adapter, const u8 *img,
-                    struct be_dma_mem *flash_cmd, int optype, int img_size)
+                    struct be_dma_mem *flash_cmd, int optype, int img_size,
+                    u32 img_offset)
 {
+        u32 flash_op, num_bytes, total_bytes = img_size, bytes_sent = 0;
         struct be_cmd_write_flashrom *req = flash_cmd->va;
-        u32 total_bytes, flash_op, num_bytes;
         int status;
 
-        total_bytes = img_size;
         while (total_bytes) {
                 num_bytes = min_t(u32, 32*1024, total_bytes);
 
@@ -3833,12 +4023,15 @@ static int be_flash(struct be_adapter *adapter, const u8 *img,
                 memcpy(req->data_buf, img, num_bytes);
                 img += num_bytes;
                 status = be_cmd_write_flashrom(adapter, flash_cmd, optype,
-                                               flash_op, num_bytes);
+                                               flash_op, img_offset +
+                                               bytes_sent, num_bytes);
                 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST &&
                     optype == OPTYPE_PHY_FW)
                         break;
                 else if (status)
                         return status;
+
+                bytes_sent += num_bytes;
         }
         return 0;
 }
@@ -3906,6 +4099,7 @@ static int be_flash_BEx(struct be_adapter *adapter,
                 pflashcomp = gen2_flash_types;
                 filehdr_size = sizeof(struct flash_file_hdr_g2);
                 num_comp = ARRAY_SIZE(gen2_flash_types);
+                img_hdrs_size = 0;
         }
 
         /* Get flash section info*/
@@ -3950,7 +4144,7 @@ static int be_flash_BEx(struct be_adapter *adapter,
                         return -1;
 
                 status = be_flash(adapter, p, flash_cmd, pflashcomp[i].optype,
-                                  pflashcomp[i].size);
+                                  pflashcomp[i].size, 0);
                 if (status) {
                         dev_err(dev, "Flashing section type 0x%x failed\n",
                                 pflashcomp[i].img_type);
@@ -4017,12 +4211,12 @@ static int be_flash_skyhawk(struct be_adapter *adapter,
                             struct be_dma_mem *flash_cmd, int num_of_images)
 {
         int img_hdrs_size = num_of_images * sizeof(struct image_hdr);
+        bool crc_match, old_fw_img, flash_offset_support = true;
         struct device *dev = &adapter->pdev->dev;
         struct flash_section_info *fsec = NULL;
         u32 img_offset, img_size, img_type;
+        u16 img_optype, flash_optype;
         int status, i, filehdr_size;
-        bool crc_match, old_fw_img;
-        u16 img_optype;
         const u8 *p;
 
         filehdr_size = sizeof(struct flash_file_hdr_g3);
@@ -4032,6 +4226,7 @@ static int be_flash_skyhawk(struct be_adapter *adapter,
                 return -EINVAL;
         }
 
+retry_flash:
         for (i = 0; i < le32_to_cpu(fsec->fsec_hdr.num_images); i++) {
                 img_offset = le32_to_cpu(fsec->fsec_entry[i].offset);
                 img_size   = le32_to_cpu(fsec->fsec_entry[i].pad_size);
@@ -4041,6 +4236,12 @@ static int be_flash_skyhawk(struct be_adapter *adapter,
 
                 if (img_optype == 0xFFFF)
                         continue;
+
+                if (flash_offset_support)
+                        flash_optype = OPTYPE_OFFSET_SPECIFIED;
+                else
+                        flash_optype = img_optype;
+
                 /* Don't bother verifying CRC if an old FW image is being
                  * flashed
                  */
@@ -4049,16 +4250,26 @@ static int be_flash_skyhawk(struct be_adapter *adapter,
 
                 status = be_check_flash_crc(adapter, fw->data, img_offset,
                                             img_size, filehdr_size +
-                                            img_hdrs_size, img_optype,
+                                            img_hdrs_size, flash_optype,
                                             &crc_match);
-                /* The current FW image on the card does not recognize the new
-                 * FLASH op_type. The FW download is partially complete.
-                 * Reboot the server now to enable FW image to recognize the
-                 * new FLASH op_type. To complete the remaining process,
-                 * download the same FW again after the reboot.
-                 */
                 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST ||
                     base_status(status) == MCC_STATUS_ILLEGAL_FIELD) {
+                        /* The current FW image on the card does not support
+                         * OFFSET based flashing. Retry using older mechanism
+                         * of OPTYPE based flashing
+                         */
+                        if (flash_optype == OPTYPE_OFFSET_SPECIFIED) {
+                                flash_offset_support = false;
+                                goto retry_flash;
+                        }
+
+                        /* The current FW image on the card does not recognize
+                         * the new FLASH op_type. The FW download is partially
+                         * complete. Reboot the server now to enable FW image
+                         * to recognize the new FLASH op_type. To complete the
+                         * remaining process, download the same FW again after
+                         * the reboot.
+                         */
                         dev_err(dev, "Flash incomplete. Reset the server\n");
                         dev_err(dev, "Download FW image again after reset\n");
                         return -EAGAIN;
@@ -4076,7 +4287,19 @@ flash:
                 if (p + img_size > fw->data + fw->size)
                         return -1;
 
-                status = be_flash(adapter, p, flash_cmd, img_optype, img_size);
+                status = be_flash(adapter, p, flash_cmd, flash_optype, img_size,
+                                  img_offset);
+
+                /* The current FW image on the card does not support OFFSET
+                 * based flashing. Retry using older mechanism of OPTYPE based
+                 * flashing
+                 */
+                if (base_status(status) == MCC_STATUS_ILLEGAL_FIELD &&
+                    flash_optype == OPTYPE_OFFSET_SPECIFIED) {
+                        flash_offset_support = false;
+                        goto retry_flash;
+                }
+
                 /* For old FW images ignore ILLEGAL_FIELD error or errors on
                  * UFI_DIR region
                  */
@@ -4179,98 +4402,105 @@ static int lancer_fw_download(struct be_adapter *adapter,
         return 0;
 }
 
-#define UFI_TYPE2               2
-#define UFI_TYPE3               3
-#define UFI_TYPE3R              10
-#define UFI_TYPE4               4
+#define BE2_UFI         2
+#define BE3_UFI         3
+#define BE3R_UFI        10
+#define SH_UFI          4
+#define SH_P2_UFI       11
+
 static int be_get_ufi_type(struct be_adapter *adapter,
                            struct flash_file_hdr_g3 *fhdr)
 {
-        if (!fhdr)
-                goto be_get_ufi_exit;
+        if (!fhdr) {
+                dev_err(&adapter->pdev->dev, "Invalid FW UFI file");
+                return -1;
+        }
 
-        if (skyhawk_chip(adapter) && fhdr->build[0] == '4')
-                return UFI_TYPE4;
-        else if (BE3_chip(adapter) && fhdr->build[0] == '3') {
-                if (fhdr->asic_type_rev == 0x10)
-                        return UFI_TYPE3R;
-                else
-                        return UFI_TYPE3;
-        } else if (BE2_chip(adapter) && fhdr->build[0] == '2')
-                return UFI_TYPE2;
+        /* First letter of the build version is used to identify
+         * which chip this image file is meant for.
+         */
+        switch (fhdr->build[0]) {
+        case BLD_STR_UFI_TYPE_SH:
+                return (fhdr->asic_type_rev == ASIC_REV_P2) ? SH_P2_UFI :
+                                                                SH_UFI;
+        case BLD_STR_UFI_TYPE_BE3:
+                return (fhdr->asic_type_rev == ASIC_REV_B0) ? BE3R_UFI :
+                                                                BE3_UFI;
+        case BLD_STR_UFI_TYPE_BE2:
+                return BE2_UFI;
+        default:
+                return -1;
+        }
+}
 
-be_get_ufi_exit:
-        dev_err(&adapter->pdev->dev,
-                "UFI and Interface are not compatible for flashing\n");
-        return -1;
+/* Check if the flash image file is compatible with the adapter that
+ * is being flashed.
+ * BE3 chips with asic-rev B0 must be flashed only with BE3R_UFI type.
+ * Skyhawk chips with asic-rev P2 must be flashed only with SH_P2_UFI type.
+ */
+static bool be_check_ufi_compatibility(struct be_adapter *adapter,
+                                       struct flash_file_hdr_g3 *fhdr)
+{
+        int ufi_type = be_get_ufi_type(adapter, fhdr);
+
+        switch (ufi_type) {
+        case SH_P2_UFI:
+                return skyhawk_chip(adapter);
+        case SH_UFI:
+                return (skyhawk_chip(adapter) &&
+                        adapter->asic_rev < ASIC_REV_P2);
+        case BE3R_UFI:
+                return BE3_chip(adapter);
+        case BE3_UFI:
+                return (BE3_chip(adapter) && adapter->asic_rev < ASIC_REV_B0);
+        case BE2_UFI:
+                return BE2_chip(adapter);
+        default:
+                return false;
+        }
 }
 
 static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
 {
+        struct device *dev = &adapter->pdev->dev;
         struct flash_file_hdr_g3 *fhdr3;
-        struct image_hdr *img_hdr_ptr = NULL;
+        struct image_hdr *img_hdr_ptr;
+        int status = 0, i, num_imgs;
         struct be_dma_mem flash_cmd;
-        const u8 *p;
-        int status = 0, i = 0, num_imgs = 0, ufi_type = 0;
 
-        flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
-        flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
-                                          &flash_cmd.dma, GFP_KERNEL);
-        if (!flash_cmd.va) {
-                status = -ENOMEM;
-                goto be_fw_exit;
+        fhdr3 = (struct flash_file_hdr_g3 *)fw->data;
+        if (!be_check_ufi_compatibility(adapter, fhdr3)) {
+                dev_err(dev, "Flash image is not compatible with adapter\n");
+                return -EINVAL;
         }
 
-        p = fw->data;
-        fhdr3 = (struct flash_file_hdr_g3 *)p;
-
-        ufi_type = be_get_ufi_type(adapter, fhdr3);
+        flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
+        flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
+                                          GFP_KERNEL);
+        if (!flash_cmd.va)
+                return -ENOMEM;
 
         num_imgs = le32_to_cpu(fhdr3->num_imgs);
         for (i = 0; i < num_imgs; i++) {
                 img_hdr_ptr = (struct image_hdr *)(fw->data +
                                 (sizeof(struct flash_file_hdr_g3) +
                                  i * sizeof(struct image_hdr)));
-                if (le32_to_cpu(img_hdr_ptr->imageid) == 1) {
-                        switch (ufi_type) {
-                        case UFI_TYPE4:
-                                status = be_flash_skyhawk(adapter, fw,
-                                                          &flash_cmd, num_imgs);
-                                break;
-                        case UFI_TYPE3R:
-                                status = be_flash_BEx(adapter, fw, &flash_cmd,
-                                                      num_imgs);
-                                break;
-                        case UFI_TYPE3:
-                                /* Do not flash this ufi on BE3-R cards */
-                                if (adapter->asic_rev < 0x10)
-                                        status = be_flash_BEx(adapter, fw,
-                                                              &flash_cmd,
-                                                              num_imgs);
-                                else {
-                                        status = -EINVAL;
-                                        dev_err(&adapter->pdev->dev,
-                                                "Can't load BE3 UFI on BE3R\n");
-                                }
-                        }
-                }
-        }
-
-        if (ufi_type == UFI_TYPE2)
-                status = be_flash_BEx(adapter, fw, &flash_cmd, 0);
-        else if (ufi_type == -1)
-                status = -EINVAL;
+                if (!BE2_chip(adapter) &&
+                    le32_to_cpu(img_hdr_ptr->imageid) != 1)
+                        continue;
 
-        dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
-                          flash_cmd.dma);
-        if (status) {
-                dev_err(&adapter->pdev->dev, "Firmware load error\n");
-                goto be_fw_exit;
+                if (skyhawk_chip(adapter))
+                        status = be_flash_skyhawk(adapter, fw, &flash_cmd,
+                                                  num_imgs);
+                else
+                        status = be_flash_BEx(adapter, fw, &flash_cmd,
+                                              num_imgs);
         }
 
-        dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
+        dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma);
+        if (!status)
+                dev_info(dev, "Firmware flashed successfully\n");
 
-be_fw_exit:
         return status;
 }
 
@@ -4304,7 +4534,8 @@ fw_exit:
         return status;
 }
 
-static int be_ndo_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh)
+static int be_ndo_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh,
+                                 u16 flags)
 {
         struct be_adapter *adapter = netdev_priv(dev);
         struct nlattr *attr, *br_spec;
@@ -4832,6 +5063,20 @@ static void be_func_recovery_task(struct work_struct *work)
                                       msecs_to_jiffies(1000));
 }
 
+static void be_log_sfp_info(struct be_adapter *adapter)
+{
+        int status;
+
+        status = be_cmd_query_sfp_info(adapter);
+        if (!status) {
+                dev_err(&adapter->pdev->dev,
+                        "Unqualified SFP+ detected on %c from %s part no: %s",
+                        adapter->port_name, adapter->phy.vendor_name,
+                        adapter->phy.vendor_pn);
+        }
+        adapter->flags &= ~BE_FLAGS_EVT_INCOMPATIBLE_SFP;
+}
+
 static void be_worker(struct work_struct *work)
 {
         struct be_adapter *adapter =
@@ -4870,6 +5115,9 @@ static void be_worker(struct work_struct *work)
 
         be_eqd_update(adapter);
 
+        if (adapter->flags & BE_FLAGS_EVT_INCOMPATIBLE_SFP)
+                be_log_sfp_info(adapter);
+
 reschedule:
         adapter->work_counter++;
         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
@@ -4916,12 +5164,31 @@ static inline char *func_name(struct be_adapter *adapter)
         return be_physfn(adapter) ? "PF" : "VF";
 }
 
+static inline char *nic_name(struct pci_dev *pdev)
+{
+        switch (pdev->device) {
+        case OC_DEVICE_ID1:
+                return OC_NAME;
+        case OC_DEVICE_ID2:
+                return OC_NAME_BE;
+        case OC_DEVICE_ID3:
+        case OC_DEVICE_ID4:
+                return OC_NAME_LANCER;
+        case BE_DEVICE_ID2:
+                return BE3_NAME;
+        case OC_DEVICE_ID5:
+        case OC_DEVICE_ID6:
+                return OC_NAME_SH;
+        default:
+                return BE_NAME;
+        }
+}
+
 static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id)
 {
-        int status = 0;
         struct be_adapter *adapter;
         struct net_device *netdev;
-        char port_name;
+        int status = 0;
 
         dev_info(&pdev->dev, "%s version is %s\n", DRV_NAME, DRV_VER);
 
@@ -5015,10 +5282,8 @@ static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id)
         schedule_delayed_work(&adapter->func_recovery_work,
                               msecs_to_jiffies(1000));
 
-        be_cmd_query_port_name(adapter, &port_name);
-
         dev_info(&pdev->dev, "%s: %s %s port %c\n", nic_name(pdev),
-                 func_name(adapter), mc_name(adapter), port_name);
+                 func_name(adapter), mc_name(adapter), adapter->port_name);
 
         return 0;
 
@@ -5083,6 +5348,10 @@ static int be_resume(struct pci_dev *pdev)
         if (status)
                 return status;
 
+        status = be_cmd_reset_function(adapter);
+        if (status)
+                return status;
+
         be_intr_set(adapter, true);
         /* tell fw we're ready to fire cmds */
         status = be_cmd_fw_init(adapter);
diff --git a/drivers/net/ethernet/freescale/Kconfig b/drivers/net/ethernet/freescale/Kconfig
index 270308315d43..ba84c4a9ce32 100644
--- a/drivers/net/ethernet/freescale/Kconfig
+++ b/drivers/net/ethernet/freescale/Kconfig
@@ -69,7 +69,8 @@ config FSL_XGMAC_MDIO
         select PHYLIB
         select OF_MDIO
         ---help---
-          This driver supports the MDIO bus on the Fman 10G Ethernet MACs.
+          This driver supports the MDIO bus on the Fman 10G Ethernet MACs, and
+          on the FMan mEMAC (which supports both Clauses 22 and 45)
 
 config UCC_GETH
         tristate "Freescale QE Gigabit Ethernet"
diff --git a/drivers/net/ethernet/freescale/fec.h b/drivers/net/ethernet/freescale/fec.h
index 40132929daf7..a86af8a7485d 100644
--- a/drivers/net/ethernet/freescale/fec.h
+++ b/drivers/net/ethernet/freescale/fec.h
@@ -16,6 +16,7 @@
 #include <linux/clocksource.h>
 #include <linux/net_tstamp.h>
 #include <linux/ptp_clock_kernel.h>
+#include <linux/timecounter.h>
 
 #if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
     defined(CONFIG_M520x) || defined(CONFIG_M532x) || \
@@ -356,6 +357,7 @@ struct bufdesc_ex {
 #define FEC_ENET_RXB    ((uint)0x01000000)      /* A buffer was received */
 #define FEC_ENET_MII    ((uint)0x00800000)      /* MII interrupt */
 #define FEC_ENET_EBERR  ((uint)0x00400000)      /* SDMA bus error */
+#define FEC_ENET_WAKEUP ((uint)0x00020000)      /* Wakeup request */
 #define FEC_ENET_TXF    (FEC_ENET_TXF_0 | FEC_ENET_TXF_1 | FEC_ENET_TXF_2)
 #define FEC_ENET_RXF    (FEC_ENET_RXF_0 | FEC_ENET_RXF_1 | FEC_ENET_RXF_2)
 #define FEC_ENET_TS_AVAIL       ((uint)0x00010000)
@@ -513,6 +515,7 @@ struct fec_enet_private {
         int     irq[FEC_IRQ_NUM];
         bool    bufdesc_ex;
         int     pause_flag;
+        int     wol_flag;
         u32     quirks;
 
         struct  napi_struct napi;
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c
index bba87775419d..9bb6220663b2 100644
--- a/drivers/net/ethernet/freescale/fec_main.c
+++ b/drivers/net/ethernet/freescale/fec_main.c
@@ -188,6 +188,9 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
 #define FEC_MMFR_RA(v)          ((v & 0x1f) << 18)
 #define FEC_MMFR_TA             (2 << 16)
 #define FEC_MMFR_DATA(v)        (v & 0xffff)
+/* FEC ECR bits definition */
+#define FEC_ECR_MAGICEN         (1 << 2)
+#define FEC_ECR_SLEEP           (1 << 3)
 
 #define FEC_MII_TIMEOUT         30000 /* us */
 
@@ -196,6 +199,9 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
 
 #define FEC_PAUSE_FLAG_AUTONEG  0x1
 #define FEC_PAUSE_FLAG_ENABLE   0x2
+#define FEC_WOL_HAS_MAGIC_PACKET        (0x1 << 0)
+#define FEC_WOL_FLAG_ENABLE             (0x1 << 1)
+#define FEC_WOL_FLAG_SLEEP_ON           (0x1 << 2)
 
 #define COPYBREAK_DEFAULT       256
 
@@ -1090,7 +1096,9 @@ static void
 fec_stop(struct net_device *ndev)
 {
         struct fec_enet_private *fep = netdev_priv(ndev);
+        struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
         u32 rmii_mode = readl(fep->hwp + FEC_R_CNTRL) & (1 << 8);
+        u32 val;
 
         /* We cannot expect a graceful transmit stop without link !!! */
         if (fep->link) {
@@ -1104,17 +1112,28 @@ fec_stop(struct net_device *ndev)
          * For i.MX6SX SOC, enet use AXI bus, we use disable MAC
          * instead of reset MAC itself.
          */
-        if (fep->quirks & FEC_QUIRK_HAS_AVB) {
-                writel(0, fep->hwp + FEC_ECNTRL);
+        if (!(fep->wol_flag & FEC_WOL_FLAG_SLEEP_ON)) {
+                if (fep->quirks & FEC_QUIRK_HAS_AVB) {
+                        writel(0, fep->hwp + FEC_ECNTRL);
+                } else {
+                        writel(1, fep->hwp + FEC_ECNTRL);
+                        udelay(10);
+                }
+                writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
         } else {
-                writel(1, fep->hwp + FEC_ECNTRL);
-                udelay(10);
+                writel(FEC_DEFAULT_IMASK | FEC_ENET_WAKEUP, fep->hwp + FEC_IMASK);
+                val = readl(fep->hwp + FEC_ECNTRL);
+                val |= (FEC_ECR_MAGICEN | FEC_ECR_SLEEP);
+                writel(val, fep->hwp + FEC_ECNTRL);
+
+                if (pdata && pdata->sleep_mode_enable)
+                        pdata->sleep_mode_enable(true);
         }
         writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
-        writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
 
         /* We have to keep ENET enabled to have MII interrupt stay working */
-        if (fep->quirks & FEC_QUIRK_ENET_MAC) {
+        if (fep->quirks & FEC_QUIRK_ENET_MAC &&
+                !(fep->wol_flag & FEC_WOL_FLAG_SLEEP_ON)) {
                 writel(2, fep->hwp + FEC_ECNTRL);
                 writel(rmii_mode, fep->hwp + FEC_R_CNTRL);
         }
@@ -1170,12 +1189,13 @@ static void
 fec_enet_tx_queue(struct net_device *ndev, u16 queue_id)
 {
         struct  fec_enet_private *fep;
-        struct bufdesc *bdp;
+        struct bufdesc *bdp, *bdp_t;
         unsigned short status;
         struct  sk_buff *skb;
         struct fec_enet_priv_tx_q *txq;
         struct netdev_queue *nq;
         int     index = 0;
+        int     i, bdnum;
         int     entries_free;
 
         fep = netdev_priv(ndev);
@@ -1196,18 +1216,29 @@ fec_enet_tx_queue(struct net_device *ndev, u16 queue_id)
                 if (bdp == txq->cur_tx)
                         break;
 
-                index = fec_enet_get_bd_index(txq->tx_bd_base, bdp, fep);
-
+                bdp_t = bdp;
+                bdnum = 1;
+                index = fec_enet_get_bd_index(txq->tx_bd_base, bdp_t, fep);
                 skb = txq->tx_skbuff[index];
-                txq->tx_skbuff[index] = NULL;
-                if (!IS_TSO_HEADER(txq, bdp->cbd_bufaddr))
-                        dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
-                                        bdp->cbd_datlen, DMA_TO_DEVICE);
-                bdp->cbd_bufaddr = 0;
-                if (!skb) {
-                        bdp = fec_enet_get_nextdesc(bdp, fep, queue_id);
-                        continue;
+                while (!skb) {
+                        bdp_t = fec_enet_get_nextdesc(bdp_t, fep, queue_id);
+                        index = fec_enet_get_bd_index(txq->tx_bd_base, bdp_t, fep);
+                        skb = txq->tx_skbuff[index];
+                        bdnum++;
                 }
+                if (skb_shinfo(skb)->nr_frags &&
+                    (status = bdp_t->cbd_sc) & BD_ENET_TX_READY)
+                        break;
+
+                for (i = 0; i < bdnum; i++) {
+                        if (!IS_TSO_HEADER(txq, bdp->cbd_bufaddr))
+                                dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
+                                                 bdp->cbd_datlen, DMA_TO_DEVICE);
+                        bdp->cbd_bufaddr = 0;
+                        if (i < bdnum - 1)
+                                bdp = fec_enet_get_nextdesc(bdp, fep, queue_id);
+                }
+                txq->tx_skbuff[index] = NULL;
 
                 /* Check for errors. */
                 if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
@@ -2428,6 +2459,44 @@ static int fec_enet_set_tunable(struct net_device *netdev,
         return ret;
 }
 
+static void
+fec_enet_get_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
+{
+        struct fec_enet_private *fep = netdev_priv(ndev);
+
+        if (fep->wol_flag & FEC_WOL_HAS_MAGIC_PACKET) {
+                wol->supported = WAKE_MAGIC;
+                wol->wolopts = fep->wol_flag & FEC_WOL_FLAG_ENABLE ? WAKE_MAGIC : 0;
+        } else {
+                wol->supported = wol->wolopts = 0;
+        }
+}
+
+static int
+fec_enet_set_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
+{
+        struct fec_enet_private *fep = netdev_priv(ndev);
+
+        if (!(fep->wol_flag & FEC_WOL_HAS_MAGIC_PACKET))
+                return -EINVAL;
+
+        if (wol->wolopts & ~WAKE_MAGIC)
+                return -EINVAL;
+
+        device_set_wakeup_enable(&ndev->dev, wol->wolopts & WAKE_MAGIC);
+        if (device_may_wakeup(&ndev->dev)) {
+                fep->wol_flag |= FEC_WOL_FLAG_ENABLE;
+                if (fep->irq[0] > 0)
+                        enable_irq_wake(fep->irq[0]);
+        } else {
+                fep->wol_flag &= (~FEC_WOL_FLAG_ENABLE);
+                if (fep->irq[0] > 0)
+                        disable_irq_wake(fep->irq[0]);
+        }
+
+        return 0;
+}
+
 static const struct ethtool_ops fec_enet_ethtool_ops = {
         .get_settings           = fec_enet_get_settings,
         .set_settings           = fec_enet_set_settings,
@@ -2446,6 +2515,8 @@ static const struct ethtool_ops fec_enet_ethtool_ops = {
         .get_ts_info            = fec_enet_get_ts_info,
         .get_tunable            = fec_enet_get_tunable,
         .set_tunable            = fec_enet_set_tunable,
+        .get_wol                = fec_enet_get_wol,
+        .set_wol                = fec_enet_set_wol,
 };
 
 static int fec_enet_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
@@ -2525,12 +2596,9 @@ static void fec_enet_free_queue(struct net_device *ndev)
                 }
 
         for (i = 0; i < fep->num_rx_queues; i++)
-                if (fep->rx_queue[i])
-                        kfree(fep->rx_queue[i]);
-
+                kfree(fep->rx_queue[i]);
         for (i = 0; i < fep->num_tx_queues; i++)
-                if (fep->tx_queue[i])
-                        kfree(fep->tx_queue[i]);
+                kfree(fep->tx_queue[i]);
 }
 
 static int fec_enet_alloc_queue(struct net_device *ndev)
@@ -2706,6 +2774,9 @@ fec_enet_open(struct net_device *ndev)
         phy_start(fep->phy_dev);
         netif_tx_start_all_queues(ndev);
 
+        device_set_wakeup_enable(&ndev->dev, fep->wol_flag &
+                                 FEC_WOL_FLAG_ENABLE);
+
         return 0;
 
 err_enet_mii_probe:
@@ -3155,6 +3226,9 @@ fec_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, ndev);
 
+        if (of_get_property(np, "fsl,magic-packet", NULL))
+                fep->wol_flag |= FEC_WOL_HAS_MAGIC_PACKET;
+
         phy_node = of_parse_phandle(np, "phy-handle", 0);
         if (!phy_node && of_phy_is_fixed_link(np)) {
                 ret = of_phy_register_fixed_link(np);
@@ -3249,6 +3323,8 @@ fec_probe(struct platform_device *pdev)
                                        0, pdev->name, ndev);
                 if (ret)
                         goto failed_irq;
+
+                fep->irq[i] = irq;
         }
 
         init_completion(&fep->mdio_done);
@@ -3265,6 +3341,9 @@ fec_probe(struct platform_device *pdev)
         if (ret)
                 goto failed_register;
 
+        device_init_wakeup(&ndev->dev, fep->wol_flag &
+                           FEC_WOL_HAS_MAGIC_PACKET);
+
         if (fep->bufdesc_ex && fep->ptp_clock)
                 netdev_info(ndev, "registered PHC device %d\n", fep->dev_id);
 
@@ -3318,6 +3397,8 @@ static int __maybe_unused fec_suspend(struct device *dev)
 
         rtnl_lock();
         if (netif_running(ndev)) {
+                if (fep->wol_flag & FEC_WOL_FLAG_ENABLE)
+                        fep->wol_flag |= FEC_WOL_FLAG_SLEEP_ON;
                 phy_stop(fep->phy_dev);
                 napi_disable(&fep->napi);
                 netif_tx_lock_bh(ndev);
@@ -3325,11 +3406,12 @@ static int __maybe_unused fec_suspend(struct device *dev)
                 netif_tx_unlock_bh(ndev);
                 fec_stop(ndev);
                 fec_enet_clk_enable(ndev, false);
-                pinctrl_pm_select_sleep_state(&fep->pdev->dev);
+                if (!(fep->wol_flag & FEC_WOL_FLAG_ENABLE))
+                        pinctrl_pm_select_sleep_state(&fep->pdev->dev);
         }
         rtnl_unlock();
 
-        if (fep->reg_phy)
+        if (fep->reg_phy && !(fep->wol_flag & FEC_WOL_FLAG_ENABLE))
                 regulator_disable(fep->reg_phy);
 
         /* SOC supply clock to phy, when clock is disabled, phy link down
@@ -3345,9 +3427,11 @@ static int __maybe_unused fec_resume(struct device *dev)
 {
         struct net_device *ndev = dev_get_drvdata(dev);
         struct fec_enet_private *fep = netdev_priv(ndev);
+        struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
         int ret;
+        int val;
 
-        if (fep->reg_phy) {
+        if (fep->reg_phy && !(fep->wol_flag & FEC_WOL_FLAG_ENABLE)) {
                 ret = regulator_enable(fep->reg_phy);
                 if (ret)
                         return ret;
@@ -3355,12 +3439,21 @@ static int __maybe_unused fec_resume(struct device *dev)
 
         rtnl_lock();
         if (netif_running(ndev)) {
-                pinctrl_pm_select_default_state(&fep->pdev->dev);
                 ret = fec_enet_clk_enable(ndev, true);
                 if (ret) {
                         rtnl_unlock();
                         goto failed_clk;
                 }
+                if (fep->wol_flag & FEC_WOL_FLAG_ENABLE) {
+                        if (pdata && pdata->sleep_mode_enable)
+                                pdata->sleep_mode_enable(false);
+                        val = readl(fep->hwp + FEC_ECNTRL);
+                        val &= ~(FEC_ECR_MAGICEN | FEC_ECR_SLEEP);
+                        writel(val, fep->hwp + FEC_ECNTRL);
+                        fep->wol_flag &= ~FEC_WOL_FLAG_SLEEP_ON;
+                } else {
+                        pinctrl_pm_select_default_state(&fep->pdev->dev);
+                }
                 fec_restart(ndev);
                 netif_tx_lock_bh(ndev);
                 netif_device_attach(ndev);
diff --git a/drivers/net/ethernet/freescale/fec_ptp.c b/drivers/net/ethernet/freescale/fec_ptp.c
index 992c8c3db553..1f9cf2345266 100644
--- a/drivers/net/ethernet/freescale/fec_ptp.c
+++ b/drivers/net/ethernet/freescale/fec_ptp.c
@@ -374,23 +374,9 @@ static int fec_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
         struct fec_enet_private *fep =
             container_of(ptp, struct fec_enet_private, ptp_caps);
         unsigned long flags;
-        u64 now;
-        u32 counter;
 
         spin_lock_irqsave(&fep->tmreg_lock, flags);
-
-        now = timecounter_read(&fep->tc);
-        now += delta;
-
-        /* Get the timer value based on adjusted timestamp.
-         * Update the counter with the masked value.
-         */
-        counter = now & fep->cc.mask;
-        writel(counter, fep->hwp + FEC_ATIME);
-
-        /* reset the timecounter */
-        timecounter_init(&fep->tc, &fep->cc, now);
-
+        timecounter_adjtime(&fep->tc, delta);
         spin_unlock_irqrestore(&fep->tmreg_lock, flags);
 
         return 0;
diff --git a/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c b/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
index 9e2bcb807923..a17628769a1f 100644
--- a/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
+++ b/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
@@ -278,14 +278,20 @@ static int fs_enet_tx_napi(struct napi_struct *napi, int budget)
                         fep->stats.collisions++;
 
                 /* unmap */
-                dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
-                                skb->len, DMA_TO_DEVICE);
+                if (fep->mapped_as_page[dirtyidx])
+                        dma_unmap_page(fep->dev, CBDR_BUFADDR(bdp),
+                                       CBDR_DATLEN(bdp), DMA_TO_DEVICE);
+                else
+                        dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
+                                         CBDR_DATLEN(bdp), DMA_TO_DEVICE);
 
                 /*
                  * Free the sk buffer associated with this last transmit.
                  */
-                dev_kfree_skb(skb);
-                fep->tx_skbuff[dirtyidx] = NULL;
+                if (skb) {
+                        dev_kfree_skb(skb);
+                        fep->tx_skbuff[dirtyidx] = NULL;
+                }
 
                 /*
                  * Update pointer to next buffer descriptor to be transmitted.
@@ -299,7 +305,7 @@ static int fs_enet_tx_napi(struct napi_struct *napi, int budget)
                  * Since we have freed up a buffer, the ring is no longer
                  * full.
                  */
-                if (!fep->tx_free++)
+                if (++fep->tx_free >= MAX_SKB_FRAGS)
                         do_wake = 1;
                 has_tx_work = 1;
         }
@@ -509,6 +515,9 @@ static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
         cbd_t __iomem *bdp;
         int curidx;
         u16 sc;
+        int nr_frags = skb_shinfo(skb)->nr_frags;
+        skb_frag_t *frag;
+        int len;
 
 #ifdef CONFIG_FS_ENET_MPC5121_FEC
         if (((unsigned long)skb->data) & 0x3) {
@@ -530,7 +539,7 @@ static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
          */
         bdp = fep->cur_tx;
 
-        if (!fep->tx_free || (CBDR_SC(bdp) & BD_ENET_TX_READY)) {
+        if (fep->tx_free <= nr_frags || (CBDR_SC(bdp) & BD_ENET_TX_READY)) {
                 netif_stop_queue(dev);
                 spin_unlock(&fep->tx_lock);
 
@@ -543,35 +552,42 @@ static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
         }
 
         curidx = bdp - fep->tx_bd_base;
-        /*
-         * Clear all of the status flags.
-         */
-        CBDC_SC(bdp, BD_ENET_TX_STATS);
-
-        /*
-         * Save skb pointer.
-         */
-        fep->tx_skbuff[curidx] = skb;
-
-        fep->stats.tx_bytes += skb->len;
 
+        len = skb->len;
+        fep->stats.tx_bytes += len;
+        if (nr_frags)
+                len -= skb->data_len;
+        fep->tx_free -= nr_frags + 1;
         /*
          * Push the data cache so the CPM does not get stale memory data.
          */
         CBDW_BUFADDR(bdp, dma_map_single(fep->dev,
-                                skb->data, skb->len, DMA_TO_DEVICE));
-        CBDW_DATLEN(bdp, skb->len);
+                                skb->data, len, DMA_TO_DEVICE));
+        CBDW_DATLEN(bdp, len);
+
+        fep->mapped_as_page[curidx] = 0;
+        frag = skb_shinfo(skb)->frags;
+        while (nr_frags) {
+                CBDC_SC(bdp,
+                        BD_ENET_TX_STATS | BD_ENET_TX_LAST | BD_ENET_TX_TC);
+                CBDS_SC(bdp, BD_ENET_TX_READY);
+
+                if ((CBDR_SC(bdp) & BD_ENET_TX_WRAP) == 0)
+                        bdp++, curidx++;
+                else
+                        bdp = fep->tx_bd_base, curidx = 0;
 
-        /*
-         * If this was the last BD in the ring, start at the beginning again.
-         */
-        if ((CBDR_SC(bdp) & BD_ENET_TX_WRAP) == 0)
-                fep->cur_tx++;
-        else
-                fep->cur_tx = fep->tx_bd_base;
+                len = skb_frag_size(frag);
+                CBDW_BUFADDR(bdp, skb_frag_dma_map(fep->dev, frag, 0, len,
+                                                   DMA_TO_DEVICE));
+                CBDW_DATLEN(bdp, len);
 
-        if (!--fep->tx_free)
-                netif_stop_queue(dev);
+                fep->tx_skbuff[curidx] = NULL;
+                fep->mapped_as_page[curidx] = 1;
+
+                frag++;
+                nr_frags--;
+        }
 
         /* Trigger transmission start */
         sc = BD_ENET_TX_READY | BD_ENET_TX_INTR |
@@ -582,8 +598,22 @@ static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
          * yay for hw reuse :) */
         if (skb->len <= 60)
                 sc |= BD_ENET_TX_PAD;
+        CBDC_SC(bdp, BD_ENET_TX_STATS);
         CBDS_SC(bdp, sc);
 
+        /* Save skb pointer. */
+        fep->tx_skbuff[curidx] = skb;
+
+        /* If this was the last BD in the ring, start at the beginning again. */
+        if ((CBDR_SC(bdp) & BD_ENET_TX_WRAP) == 0)
+                bdp++;
+        else
+                bdp = fep->tx_bd_base;
+        fep->cur_tx = bdp;
+
+        if (fep->tx_free < MAX_SKB_FRAGS)
+                netif_stop_queue(dev);
+
         skb_tx_timestamp(skb);
 
         (*fep->ops->tx_kickstart)(dev);
@@ -917,7 +947,7 @@ static int fs_enet_probe(struct platform_device *ofdev)
         }
 
         fpi->rx_ring = 32;
-        fpi->tx_ring = 32;
+        fpi->tx_ring = 64;
         fpi->rx_copybreak = 240;
         fpi->napi_weight = 17;
         fpi->phy_node = of_parse_phandle(ofdev->dev.of_node, "phy-handle", 0);
@@ -955,7 +985,8 @@ static int fs_enet_probe(struct platform_device *ofdev)
 
         privsize = sizeof(*fep) +
                    sizeof(struct sk_buff **) *
-                   (fpi->rx_ring + fpi->tx_ring);
+                     (fpi->rx_ring + fpi->tx_ring) +
+                   sizeof(char) * fpi->tx_ring;
 
         ndev = alloc_etherdev(privsize);
         if (!ndev) {
@@ -978,6 +1009,8 @@ static int fs_enet_probe(struct platform_device *ofdev)
 
         fep->rx_skbuff = (struct sk_buff **)&fep[1];
         fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
+        fep->mapped_as_page = (char *)(fep->rx_skbuff + fpi->rx_ring +
+                                       fpi->tx_ring);
 
         spin_lock_init(&fep->lock);
         spin_lock_init(&fep->tx_lock);
@@ -1007,6 +1040,8 @@ static int fs_enet_probe(struct platform_device *ofdev)
 
         netif_carrier_off(ndev);
 
+        ndev->features |= NETIF_F_SG;
+
         ret = register_netdev(ndev);
         if (ret)
                 goto out_free_bd;
diff --git a/drivers/net/ethernet/freescale/fs_enet/fs_enet.h b/drivers/net/ethernet/freescale/fs_enet/fs_enet.h
index 3a4b49e0e717..f184d8f952e2 100644
--- a/drivers/net/ethernet/freescale/fs_enet/fs_enet.h
+++ b/drivers/net/ethernet/freescale/fs_enet/fs_enet.h
@@ -134,6 +134,7 @@ struct fs_enet_private {
         void __iomem *ring_base;
         struct sk_buff **rx_skbuff;
         struct sk_buff **tx_skbuff;
+        char *mapped_as_page;
         cbd_t __iomem *rx_bd_base;      /* Address of Rx and Tx buffers.    */
         cbd_t __iomem *tx_bd_base;
         cbd_t __iomem *dirty_tx;        /* ring entries to be free()ed.     */
diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
index 5645342f5b28..43df78882e48 100644
--- a/drivers/net/ethernet/freescale/gianfar.c
+++ b/drivers/net/ethernet/freescale/gianfar.c
@@ -116,7 +116,8 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev);
 static void gfar_reset_task(struct work_struct *work);
 static void gfar_timeout(struct net_device *dev);
 static int gfar_close(struct net_device *dev);
-struct sk_buff *gfar_new_skb(struct net_device *dev, dma_addr_t *bufaddr);
+static struct sk_buff *gfar_new_skb(struct net_device *dev,
+                                    dma_addr_t *bufaddr);
 static int gfar_set_mac_address(struct net_device *dev);
 static int gfar_change_mtu(struct net_device *dev, int new_mtu);
 static irqreturn_t gfar_error(int irq, void *dev_id);
@@ -176,7 +177,7 @@ static int gfar_init_bds(struct net_device *ndev)
         struct gfar_priv_rx_q *rx_queue = NULL;
         struct txbd8 *txbdp;
         struct rxbd8 *rxbdp;
-        u32 *rfbptr;
+        u32 __iomem *rfbptr;
         int i, j;
         dma_addr_t bufaddr;
 
@@ -554,7 +555,7 @@ static void gfar_ints_enable(struct gfar_private *priv)
         }
 }
 
-void lock_tx_qs(struct gfar_private *priv)
+static void lock_tx_qs(struct gfar_private *priv)
 {
         int i;
 
@@ -562,7 +563,7 @@ void lock_tx_qs(struct gfar_private *priv)
                 spin_lock(&priv->tx_queue[i]->txlock);
 }
 
-void unlock_tx_qs(struct gfar_private *priv)
+static void unlock_tx_qs(struct gfar_private *priv)
 {
         int i;
 
@@ -763,7 +764,7 @@ static int gfar_of_init(struct platform_device *ofdev, struct net_device **pdev)
         u32 *tx_queues, *rx_queues;
         unsigned short mode, poll_mode;
 
-        if (!np || !of_device_is_available(np))
+        if (!np)
                 return -ENODEV;
 
         if (of_device_is_compatible(np, "fsl,etsec2")) {
@@ -2169,7 +2170,7 @@ static inline void gfar_tx_checksum(struct sk_buff *skb, struct txfcb *fcb,
 void inline gfar_tx_vlan(struct sk_buff *skb, struct txfcb *fcb)
 {
         fcb->flags |= TXFCB_VLN;
-        fcb->vlctl = vlan_tx_tag_get(skb);
+        fcb->vlctl = skb_vlan_tag_get(skb);
 }
 
 static inline struct txbd8 *skip_txbd(struct txbd8 *bdp, int stride,
@@ -2229,7 +2230,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
         regs = tx_queue->grp->regs;
 
         do_csum = (CHECKSUM_PARTIAL == skb->ip_summed);
-        do_vlan = vlan_tx_tag_present(skb);
+        do_vlan = skb_vlan_tag_present(skb);
         do_tstamp = (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
                     priv->hwts_tx_en;
 
@@ -2671,7 +2672,7 @@ static struct sk_buff *gfar_alloc_skb(struct net_device *dev)
         return skb;
 }
 
-struct sk_buff *gfar_new_skb(struct net_device *dev, dma_addr_t *bufaddr)
+static struct sk_buff *gfar_new_skb(struct net_device *dev, dma_addr_t *bufaddr)
 {
         struct gfar_private *priv = netdev_priv(dev);
         struct sk_buff *skb;
diff --git a/drivers/net/ethernet/freescale/gianfar.h b/drivers/net/ethernet/freescale/gianfar.h
index b581b8823a2a..9e1802400c23 100644
--- a/drivers/net/ethernet/freescale/gianfar.h
+++ b/drivers/net/ethernet/freescale/gianfar.h
@@ -1039,7 +1039,7 @@ struct gfar_priv_rx_q {
         /* RX Coalescing values */
         unsigned char rxcoalescing;
         unsigned long rxic;
-        u32 *rfbptr;
+        u32 __iomem *rfbptr;
 };
 
 enum gfar_irqinfo_id {
diff --git a/drivers/net/ethernet/freescale/xgmac_mdio.c b/drivers/net/ethernet/freescale/xgmac_mdio.c
index 6e7db66069aa..3a83bc2c613c 100644
--- a/drivers/net/ethernet/freescale/xgmac_mdio.c
+++ b/drivers/net/ethernet/freescale/xgmac_mdio.c
@@ -32,18 +32,19 @@ struct tgec_mdio_controller {
         __be32  mdio_addr;      /* MDIO address */
 } __packed;
 
+#define MDIO_STAT_ENC           BIT(6)
 #define MDIO_STAT_CLKDIV(x)     (((x>>1) & 0xff) << 8)
-#define MDIO_STAT_BSY           (1 << 0)
-#define MDIO_STAT_RD_ER         (1 << 1)
+#define MDIO_STAT_BSY           BIT(0)
+#define MDIO_STAT_RD_ER         BIT(1)
 #define MDIO_CTL_DEV_ADDR(x)    (x & 0x1f)
 #define MDIO_CTL_PORT_ADDR(x)   ((x & 0x1f) << 5)
-#define MDIO_CTL_PRE_DIS        (1 << 10)
-#define MDIO_CTL_SCAN_EN        (1 << 11)
-#define MDIO_CTL_POST_INC       (1 << 14)
-#define MDIO_CTL_READ           (1 << 15)
+#define MDIO_CTL_PRE_DIS        BIT(10)
+#define MDIO_CTL_SCAN_EN        BIT(11)
+#define MDIO_CTL_POST_INC       BIT(14)
+#define MDIO_CTL_READ           BIT(15)
 
 #define MDIO_DATA(x)            (x & 0xffff)
-#define MDIO_DATA_BSY           (1 << 31)
+#define MDIO_DATA_BSY           BIT(31)
 
 /*
  * Wait until the MDIO bus is free
@@ -51,12 +52,16 @@ struct tgec_mdio_controller {
 static int xgmac_wait_until_free(struct device *dev,
                                  struct tgec_mdio_controller __iomem *regs)
 {
-        uint32_t status;
+        unsigned int timeout;
 
         /* Wait till the bus is free */
-        status = spin_event_timeout(
-                !((in_be32(&regs->mdio_stat)) & MDIO_STAT_BSY), TIMEOUT, 0);
-        if (!status) {
+        timeout = TIMEOUT;
+        while ((ioread32be(&regs->mdio_stat) & MDIO_STAT_BSY) && timeout) {
+                cpu_relax();
+                timeout--;
+        }
+
+        if (!timeout) {
                 dev_err(dev, "timeout waiting for bus to be free\n");
                 return -ETIMEDOUT;
         }
@@ -70,12 +75,16 @@ static int xgmac_wait_until_free(struct device *dev,
 static int xgmac_wait_until_done(struct device *dev,
                                  struct tgec_mdio_controller __iomem *regs)
 {
-        uint32_t status;
+        unsigned int timeout;
 
         /* Wait till the MDIO write is complete */
-        status = spin_event_timeout(
-                !((in_be32(&regs->mdio_data)) & MDIO_DATA_BSY), TIMEOUT, 0);
-        if (!status) {
+        timeout = TIMEOUT;
+        while ((ioread32be(&regs->mdio_data) & MDIO_DATA_BSY) && timeout) {
+                cpu_relax();
+                timeout--;
+        }
+
+        if (!timeout) {
                 dev_err(dev, "timeout waiting for operation to complete\n");
                 return -ETIMEDOUT;
         }
@@ -91,29 +100,42 @@ static int xgmac_wait_until_done(struct device *dev,
 static int xgmac_mdio_write(struct mii_bus *bus, int phy_id, int regnum, u16 value)
 {
         struct tgec_mdio_controller __iomem *regs = bus->priv;
-        uint16_t dev_addr = regnum >> 16;
+        uint16_t dev_addr;
+        u32 mdio_ctl, mdio_stat;
         int ret;
 
-        /* Setup the MII Mgmt clock speed */
-        out_be32(&regs->mdio_stat, MDIO_STAT_CLKDIV(100));
+        mdio_stat = ioread32be(&regs->mdio_stat);
+        if (regnum & MII_ADDR_C45) {
+                /* Clause 45 (ie 10G) */
+                dev_addr = (regnum >> 16) & 0x1f;
+                mdio_stat |= MDIO_STAT_ENC;
+        } else {
+                /* Clause 22 (ie 1G) */
+                dev_addr = regnum & 0x1f;
+                mdio_stat &= ~MDIO_STAT_ENC;
+        }
+
+        iowrite32be(mdio_stat, &regs->mdio_stat);
 
         ret = xgmac_wait_until_free(&bus->dev, regs);
         if (ret)
                 return ret;
 
         /* Set the port and dev addr */
-        out_be32(&regs->mdio_ctl,
-                 MDIO_CTL_PORT_ADDR(phy_id) | MDIO_CTL_DEV_ADDR(dev_addr));
+        mdio_ctl = MDIO_CTL_PORT_ADDR(phy_id) | MDIO_CTL_DEV_ADDR(dev_addr);
+        iowrite32be(mdio_ctl, &regs->mdio_ctl);
 
         /* Set the register address */
-        out_be32(&regs->mdio_addr, regnum & 0xffff);
+        if (regnum & MII_ADDR_C45) {
+                iowrite32be(regnum & 0xffff, &regs->mdio_addr);
 
-        ret = xgmac_wait_until_free(&bus->dev, regs);
-        if (ret)
-                return ret;
+                ret = xgmac_wait_until_free(&bus->dev, regs);
+                if (ret)
+                        return ret;
+        }
 
         /* Write the value to the register */
-        out_be32(&regs->mdio_data, MDIO_DATA(value));
+        iowrite32be(MDIO_DATA(value), &regs->mdio_data);
 
         ret = xgmac_wait_until_done(&bus->dev, regs);
         if (ret)
@@ -130,13 +152,22 @@ static int xgmac_mdio_write(struct mii_bus *bus, int phy_id, int regnum, u16 val
 static int xgmac_mdio_read(struct mii_bus *bus, int phy_id, int regnum)
 {
         struct tgec_mdio_controller __iomem *regs = bus->priv;
-        uint16_t dev_addr = regnum >> 16;
+        uint16_t dev_addr;
+        uint32_t mdio_stat;
         uint32_t mdio_ctl;
         uint16_t value;
         int ret;
 
-        /* Setup the MII Mgmt clock speed */
-        out_be32(&regs->mdio_stat, MDIO_STAT_CLKDIV(100));
+        mdio_stat = ioread32be(&regs->mdio_stat);
+        if (regnum & MII_ADDR_C45) {
+                dev_addr = (regnum >> 16) & 0x1f;
+                mdio_stat |= MDIO_STAT_ENC;
+        } else {
+                dev_addr = regnum & 0x1f;
+                mdio_stat &= ~MDIO_STAT_ENC;
+        }
+
+        iowrite32be(mdio_stat, &regs->mdio_stat);
 
         ret = xgmac_wait_until_free(&bus->dev, regs);
         if (ret)
@@ -144,54 +175,38 @@ static int xgmac_mdio_read(struct mii_bus *bus, int phy_id, int regnum)
 
         /* Set the Port and Device Addrs */
         mdio_ctl = MDIO_CTL_PORT_ADDR(phy_id) | MDIO_CTL_DEV_ADDR(dev_addr);
-        out_be32(&regs->mdio_ctl, mdio_ctl);
+        iowrite32be(mdio_ctl, &regs->mdio_ctl);
 
         /* Set the register address */
-        out_be32(&regs->mdio_addr, regnum & 0xffff);
+        if (regnum & MII_ADDR_C45) {
+                iowrite32be(regnum & 0xffff, &regs->mdio_addr);
 
-        ret = xgmac_wait_until_free(&bus->dev, regs);
-        if (ret)
-                return ret;
+                ret = xgmac_wait_until_free(&bus->dev, regs);
+                if (ret)
+                        return ret;
+        }
 
         /* Initiate the read */
-        out_be32(&regs->mdio_ctl, mdio_ctl | MDIO_CTL_READ);
+        iowrite32be(mdio_ctl | MDIO_CTL_READ, &regs->mdio_ctl);
 
         ret = xgmac_wait_until_done(&bus->dev, regs);
         if (ret)
                 return ret;
 
         /* Return all Fs if nothing was there */
-        if (in_be32(&regs->mdio_stat) & MDIO_STAT_RD_ER) {
+        if (ioread32be(&regs->mdio_stat) & MDIO_STAT_RD_ER) {
                 dev_err(&bus->dev,
                         "Error while reading PHY%d reg at %d.%hhu\n",
                         phy_id, dev_addr, regnum);
                 return 0xffff;
         }
 
-        value = in_be32(&regs->mdio_data) & 0xffff;
+        value = ioread32be(&regs->mdio_data) & 0xffff;
         dev_dbg(&bus->dev, "read %04x\n", value);
 
         return value;
 }
 
-/* Reset the MIIM registers, and wait for the bus to free */
-static int xgmac_mdio_reset(struct mii_bus *bus)
-{
-        struct tgec_mdio_controller __iomem *regs = bus->priv;
-        int ret;
-
-        mutex_lock(&bus->mdio_lock);
-
-        /* Setup the MII Mgmt clock speed */
-        out_be32(&regs->mdio_stat, MDIO_STAT_CLKDIV(100));
-
-        ret = xgmac_wait_until_free(&bus->dev, regs);
-
-        mutex_unlock(&bus->mdio_lock);
-
-        return ret;
-}
-
 static int xgmac_mdio_probe(struct platform_device *pdev)
 {
         struct device_node *np = pdev->dev.of_node;
@@ -205,15 +220,13 @@ static int xgmac_mdio_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        bus = mdiobus_alloc_size(PHY_MAX_ADDR * sizeof(int));
+        bus = mdiobus_alloc();
         if (!bus)
                 return -ENOMEM;
 
         bus->name = "Freescale XGMAC MDIO Bus";
         bus->read = xgmac_mdio_read;
         bus->write = xgmac_mdio_write;
-        bus->reset = xgmac_mdio_reset;
-        bus->irq = bus->priv;
         bus->parent = &pdev->dev;
         snprintf(bus->id, MII_BUS_ID_SIZE, "%llx", (unsigned long long)res.start);
 
@@ -258,6 +271,9 @@ static struct of_device_id xgmac_mdio_match[] = {
         {
                 .compatible = "fsl,fman-xmdio",
         },
+        {
+                .compatible = "fsl,fman-memac-mdio",
+        },
         {},
 };
 MODULE_DEVICE_TABLE(of, xgmac_mdio_match);
diff --git a/drivers/net/ethernet/hisilicon/Kconfig b/drivers/net/ethernet/hisilicon/Kconfig
index e9421731b05e..a54d89791311 100644
--- a/drivers/net/ethernet/hisilicon/Kconfig
+++ b/drivers/net/ethernet/hisilicon/Kconfig
@@ -24,4 +24,13 @@ config HIX5HD2_GMAC
         help
           This selects the hix5hd2 mac family network device.
 
+config HIP04_ETH
+        tristate "HISILICON P04 Ethernet support"
+        select PHYLIB
+        select MARVELL_PHY
+        select MFD_SYSCON
+        ---help---
+          If you wish to compile a kernel for a hardware with hisilicon p04 SoC and
+          want to use the internal ethernet then you should answer Y to this.
+
 endif # NET_VENDOR_HISILICON
diff --git a/drivers/net/ethernet/hisilicon/Makefile b/drivers/net/ethernet/hisilicon/Makefile
index 9175e84622d4..6c14540a4dc5 100644
--- a/drivers/net/ethernet/hisilicon/Makefile
+++ b/drivers/net/ethernet/hisilicon/Makefile
@@ -3,3 +3,4 @@
 #
 
 obj-$(CONFIG_HIX5HD2_GMAC) += hix5hd2_gmac.o
+obj-$(CONFIG_HIP04_ETH) += hip04_mdio.o hip04_eth.o
diff --git a/drivers/net/ethernet/hisilicon/hip04_eth.c b/drivers/net/ethernet/hisilicon/hip04_eth.c
new file mode 100644
index 000000000000..b72d238695d7
--- /dev/null
+++ b/drivers/net/ethernet/hisilicon/hip04_eth.c
@@ -0,0 +1,971 @@
+
+/* Copyright (c) 2014 Linaro Ltd.
+ * Copyright (c) 2014 Hisilicon Limited.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/etherdevice.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/ktime.h>
+#include <linux/of_address.h>
+#include <linux/phy.h>
+#include <linux/of_mdio.h>
+#include <linux/of_net.h>
+#include <linux/mfd/syscon.h>
+#include <linux/regmap.h>
+
+#define PPE_CFG_RX_ADDR                 0x100
+#define PPE_CFG_POOL_GRP                0x300
+#define PPE_CFG_RX_BUF_SIZE             0x400
+#define PPE_CFG_RX_FIFO_SIZE            0x500
+#define PPE_CURR_BUF_CNT                0xa200
+
+#define GE_DUPLEX_TYPE                  0x08
+#define GE_MAX_FRM_SIZE_REG             0x3c
+#define GE_PORT_MODE                    0x40
+#define GE_PORT_EN                      0x44
+#define GE_SHORT_RUNTS_THR_REG          0x50
+#define GE_TX_LOCAL_PAGE_REG            0x5c
+#define GE_TRANSMIT_CONTROL_REG         0x60
+#define GE_CF_CRC_STRIP_REG             0x1b0
+#define GE_MODE_CHANGE_REG              0x1b4
+#define GE_RECV_CONTROL_REG             0x1e0
+#define GE_STATION_MAC_ADDRESS          0x210
+#define PPE_CFG_CPU_ADD_ADDR            0x580
+#define PPE_CFG_MAX_FRAME_LEN_REG       0x408
+#define PPE_CFG_BUS_CTRL_REG            0x424
+#define PPE_CFG_RX_CTRL_REG             0x428
+#define PPE_CFG_RX_PKT_MODE_REG         0x438
+#define PPE_CFG_QOS_VMID_GEN            0x500
+#define PPE_CFG_RX_PKT_INT              0x538
+#define PPE_INTEN                       0x600
+#define PPE_INTSTS                      0x608
+#define PPE_RINT                        0x604
+#define PPE_CFG_STS_MODE                0x700
+#define PPE_HIS_RX_PKT_CNT              0x804
+
+/* REG_INTERRUPT */
+#define RCV_INT                         BIT(10)
+#define RCV_NOBUF                       BIT(8)
+#define RCV_DROP                        BIT(7)
+#define TX_DROP                         BIT(6)
+#define DEF_INT_ERR                     (RCV_NOBUF | RCV_DROP | TX_DROP)
+#define DEF_INT_MASK                    (RCV_INT | DEF_INT_ERR)
+
+/* TX descriptor config */
+#define TX_FREE_MEM                     BIT(0)
+#define TX_READ_ALLOC_L3                BIT(1)
+#define TX_FINISH_CACHE_INV             BIT(2)
+#define TX_CLEAR_WB                     BIT(4)
+#define TX_L3_CHECKSUM                  BIT(5)
+#define TX_LOOP_BACK                    BIT(11)
+
+/* RX error */
+#define RX_PKT_DROP                     BIT(0)
+#define RX_L2_ERR                       BIT(1)
+#define RX_PKT_ERR                      (RX_PKT_DROP | RX_L2_ERR)
+
+#define SGMII_SPEED_1000                0x08
+#define SGMII_SPEED_100                 0x07
+#define SGMII_SPEED_10                  0x06
+#define MII_SPEED_100                   0x01
+#define MII_SPEED_10                    0x00
+
+#define GE_DUPLEX_FULL                  BIT(0)
+#define GE_DUPLEX_HALF                  0x00
+#define GE_MODE_CHANGE_EN               BIT(0)
+
+#define GE_TX_AUTO_NEG                  BIT(5)
+#define GE_TX_ADD_CRC                   BIT(6)
+#define GE_TX_SHORT_PAD_THROUGH         BIT(7)
+
+#define GE_RX_STRIP_CRC                 BIT(0)
+#define GE_RX_STRIP_PAD                 BIT(3)
+#define GE_RX_PAD_EN                    BIT(4)
+
+#define GE_AUTO_NEG_CTL                 BIT(0)
+
+#define GE_RX_INT_THRESHOLD             BIT(6)
+#define GE_RX_TIMEOUT                   0x04
+
+#define GE_RX_PORT_EN                   BIT(1)
+#define GE_TX_PORT_EN                   BIT(2)
+
+#define PPE_CFG_STS_RX_PKT_CNT_RC       BIT(12)
+
+#define PPE_CFG_RX_PKT_ALIGN            BIT(18)
+#define PPE_CFG_QOS_VMID_MODE           BIT(14)
+#define PPE_CFG_QOS_VMID_GRP_SHIFT      8
+
+#define PPE_CFG_RX_FIFO_FSFU            BIT(11)
+#define PPE_CFG_RX_DEPTH_SHIFT          16
+#define PPE_CFG_RX_START_SHIFT          0
+#define PPE_CFG_RX_CTRL_ALIGN_SHIFT     11
+
+#define PPE_CFG_BUS_LOCAL_REL           BIT(14)
+#define PPE_CFG_BUS_BIG_ENDIEN          BIT(0)
+
+#define RX_DESC_NUM                     128
+#define TX_DESC_NUM                     256
+#define TX_NEXT(N)                      (((N) + 1) & (TX_DESC_NUM-1))
+#define RX_NEXT(N)                      (((N) + 1) & (RX_DESC_NUM-1))
+
+#define GMAC_PPE_RX_PKT_MAX_LEN         379
+#define GMAC_MAX_PKT_LEN                1516
+#define GMAC_MIN_PKT_LEN                31
+#define RX_BUF_SIZE                     1600
+#define RESET_TIMEOUT                   1000
+#define TX_TIMEOUT                      (6 * HZ)
+
+#define DRV_NAME                        "hip04-ether"
+#define DRV_VERSION                     "v1.0"
+
+#define HIP04_MAX_TX_COALESCE_USECS     200
+#define HIP04_MIN_TX_COALESCE_USECS     100
+#define HIP04_MAX_TX_COALESCE_FRAMES    200
+#define HIP04_MIN_TX_COALESCE_FRAMES    100
+
+struct tx_desc {
+        u32 send_addr;
+        u32 send_size;
+        u32 next_addr;
+        u32 cfg;
+        u32 wb_addr;
+} __aligned(64);
+
+struct rx_desc {
+        u16 reserved_16;
+        u16 pkt_len;
+        u32 reserve1[3];
+        u32 pkt_err;
+        u32 reserve2[4];
+};
+
+struct hip04_priv {
+        void __iomem *base;
+        int phy_mode;
+        int chan;
+        unsigned int port;
+        unsigned int speed;
+        unsigned int duplex;
+        unsigned int reg_inten;
+
+        struct napi_struct napi;
+        struct net_device *ndev;
+
+        struct tx_desc *tx_desc;
+        dma_addr_t tx_desc_dma;
+        struct sk_buff *tx_skb[TX_DESC_NUM];
+        dma_addr_t tx_phys[TX_DESC_NUM];
+        unsigned int tx_head;
+
+        int tx_coalesce_frames;
+        int tx_coalesce_usecs;
+        struct hrtimer tx_coalesce_timer;
+
+        unsigned char *rx_buf[RX_DESC_NUM];
+        dma_addr_t rx_phys[RX_DESC_NUM];
+        unsigned int rx_head;
+        unsigned int rx_buf_size;
+
+        struct device_node *phy_node;
+        struct phy_device *phy;
+        struct regmap *map;
+        struct work_struct tx_timeout_task;
+
+        /* written only by tx cleanup */
+        unsigned int tx_tail ____cacheline_aligned_in_smp;
+};
+
+static inline unsigned int tx_count(unsigned int head, unsigned int tail)
+{
+        return (head - tail) % (TX_DESC_NUM - 1);
+}
+
+static void hip04_config_port(struct net_device *ndev, u32 speed, u32 duplex)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        u32 val;
+
+        priv->speed = speed;
+        priv->duplex = duplex;
+
+        switch (priv->phy_mode) {
+        case PHY_INTERFACE_MODE_SGMII:
+                if (speed == SPEED_1000)
+                        val = SGMII_SPEED_1000;
+                else if (speed == SPEED_100)
+                        val = SGMII_SPEED_100;
+                else
+                        val = SGMII_SPEED_10;
+                break;
+        case PHY_INTERFACE_MODE_MII:
+                if (speed == SPEED_100)
+                        val = MII_SPEED_100;
+                else
+                        val = MII_SPEED_10;
+                break;
+        default:
+                netdev_warn(ndev, "not supported mode\n");
+                val = MII_SPEED_10;
+                break;
+        }
+        writel_relaxed(val, priv->base + GE_PORT_MODE);
+
+        val = duplex ? GE_DUPLEX_FULL : GE_DUPLEX_HALF;
+        writel_relaxed(val, priv->base + GE_DUPLEX_TYPE);
+
+        val = GE_MODE_CHANGE_EN;
+        writel_relaxed(val, priv->base + GE_MODE_CHANGE_REG);
+}
+
+static void hip04_reset_ppe(struct hip04_priv *priv)
+{
+        u32 val, tmp, timeout = 0;
+
+        do {
+                regmap_read(priv->map, priv->port * 4 + PPE_CURR_BUF_CNT, &val);
+                regmap_read(priv->map, priv->port * 4 + PPE_CFG_RX_ADDR, &tmp);
+                if (timeout++ > RESET_TIMEOUT)
+                        break;
+        } while (val & 0xfff);
+}
+
+static void hip04_config_fifo(struct hip04_priv *priv)
+{
+        u32 val;
+
+        val = readl_relaxed(priv->base + PPE_CFG_STS_MODE);
+        val |= PPE_CFG_STS_RX_PKT_CNT_RC;
+        writel_relaxed(val, priv->base + PPE_CFG_STS_MODE);
+
+        val = BIT(priv->port);
+        regmap_write(priv->map, priv->port * 4 + PPE_CFG_POOL_GRP, val);
+
+        val = priv->port << PPE_CFG_QOS_VMID_GRP_SHIFT;
+        val |= PPE_CFG_QOS_VMID_MODE;
+        writel_relaxed(val, priv->base + PPE_CFG_QOS_VMID_GEN);
+
+        val = RX_BUF_SIZE;
+        regmap_write(priv->map, priv->port * 4 + PPE_CFG_RX_BUF_SIZE, val);
+
+        val = RX_DESC_NUM << PPE_CFG_RX_DEPTH_SHIFT;
+        val |= PPE_CFG_RX_FIFO_FSFU;
+        val |= priv->chan << PPE_CFG_RX_START_SHIFT;
+        regmap_write(priv->map, priv->port * 4 + PPE_CFG_RX_FIFO_SIZE, val);
+
+        val = NET_IP_ALIGN << PPE_CFG_RX_CTRL_ALIGN_SHIFT;
+        writel_relaxed(val, priv->base + PPE_CFG_RX_CTRL_REG);
+
+        val = PPE_CFG_RX_PKT_ALIGN;
+        writel_relaxed(val, priv->base + PPE_CFG_RX_PKT_MODE_REG);
+
+        val = PPE_CFG_BUS_LOCAL_REL | PPE_CFG_BUS_BIG_ENDIEN;
+        writel_relaxed(val, priv->base + PPE_CFG_BUS_CTRL_REG);
+
+        val = GMAC_PPE_RX_PKT_MAX_LEN;
+        writel_relaxed(val, priv->base + PPE_CFG_MAX_FRAME_LEN_REG);
+
+        val = GMAC_MAX_PKT_LEN;
+        writel_relaxed(val, priv->base + GE_MAX_FRM_SIZE_REG);
+
+        val = GMAC_MIN_PKT_LEN;
+        writel_relaxed(val, priv->base + GE_SHORT_RUNTS_THR_REG);
+
+        val = readl_relaxed(priv->base + GE_TRANSMIT_CONTROL_REG);
+        val |= GE_TX_AUTO_NEG | GE_TX_ADD_CRC | GE_TX_SHORT_PAD_THROUGH;
+        writel_relaxed(val, priv->base + GE_TRANSMIT_CONTROL_REG);
+
+        val = GE_RX_STRIP_CRC;
+        writel_relaxed(val, priv->base + GE_CF_CRC_STRIP_REG);
+
+        val = readl_relaxed(priv->base + GE_RECV_CONTROL_REG);
+        val |= GE_RX_STRIP_PAD | GE_RX_PAD_EN;
+        writel_relaxed(val, priv->base + GE_RECV_CONTROL_REG);
+
+        val = GE_AUTO_NEG_CTL;
+        writel_relaxed(val, priv->base + GE_TX_LOCAL_PAGE_REG);
+}
+
+static void hip04_mac_enable(struct net_device *ndev)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        u32 val;
+
+        /* enable tx & rx */
+        val = readl_relaxed(priv->base + GE_PORT_EN);
+        val |= GE_RX_PORT_EN | GE_TX_PORT_EN;
+        writel_relaxed(val, priv->base + GE_PORT_EN);
+
+        /* clear rx int */
+        val = RCV_INT;
+        writel_relaxed(val, priv->base + PPE_RINT);
+
+        /* config recv int */
+        val = GE_RX_INT_THRESHOLD | GE_RX_TIMEOUT;
+        writel_relaxed(val, priv->base + PPE_CFG_RX_PKT_INT);
+
+        /* enable interrupt */
+        priv->reg_inten = DEF_INT_MASK;
+        writel_relaxed(priv->reg_inten, priv->base + PPE_INTEN);
+}
+
+static void hip04_mac_disable(struct net_device *ndev)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        u32 val;
+
+        /* disable int */
+        priv->reg_inten &= ~(DEF_INT_MASK);
+        writel_relaxed(priv->reg_inten, priv->base + PPE_INTEN);
+
+        /* disable tx & rx */
+        val = readl_relaxed(priv->base + GE_PORT_EN);
+        val &= ~(GE_RX_PORT_EN | GE_TX_PORT_EN);
+        writel_relaxed(val, priv->base + GE_PORT_EN);
+}
+
+static void hip04_set_xmit_desc(struct hip04_priv *priv, dma_addr_t phys)
+{
+        writel(phys, priv->base + PPE_CFG_CPU_ADD_ADDR);
+}
+
+static void hip04_set_recv_desc(struct hip04_priv *priv, dma_addr_t phys)
+{
+        regmap_write(priv->map, priv->port * 4 + PPE_CFG_RX_ADDR, phys);
+}
+
+static u32 hip04_recv_cnt(struct hip04_priv *priv)
+{
+        return readl(priv->base + PPE_HIS_RX_PKT_CNT);
+}
+
+static void hip04_update_mac_address(struct net_device *ndev)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+
+        writel_relaxed(((ndev->dev_addr[0] << 8) | (ndev->dev_addr[1])),
+                       priv->base + GE_STATION_MAC_ADDRESS);
+        writel_relaxed(((ndev->dev_addr[2] << 24) | (ndev->dev_addr[3] << 16) |
+                        (ndev->dev_addr[4] << 8) | (ndev->dev_addr[5])),
+                       priv->base + GE_STATION_MAC_ADDRESS + 4);
+}
+
+static int hip04_set_mac_address(struct net_device *ndev, void *addr)
+{
+        eth_mac_addr(ndev, addr);
+        hip04_update_mac_address(ndev);
+        return 0;
+}
+
+static int hip04_tx_reclaim(struct net_device *ndev, bool force)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        unsigned tx_tail = priv->tx_tail;
+        struct tx_desc *desc;
+        unsigned int bytes_compl = 0, pkts_compl = 0;
+        unsigned int count;
+
+        smp_rmb();
+        count = tx_count(ACCESS_ONCE(priv->tx_head), tx_tail);
+        if (count == 0)
+                goto out;
+
+        while (count) {
+                desc = &priv->tx_desc[tx_tail];
+                if (desc->send_addr != 0) {
+                        if (force)
+                                desc->send_addr = 0;
+                        else
+                                break;
+                }
+
+                if (priv->tx_phys[tx_tail]) {
+                        dma_unmap_single(&ndev->dev, priv->tx_phys[tx_tail],
+                                         priv->tx_skb[tx_tail]->len,
+                                         DMA_TO_DEVICE);
+                        priv->tx_phys[tx_tail] = 0;
+                }
+                pkts_compl++;
+                bytes_compl += priv->tx_skb[tx_tail]->len;
+                dev_kfree_skb(priv->tx_skb[tx_tail]);
+                priv->tx_skb[tx_tail] = NULL;
+                tx_tail = TX_NEXT(tx_tail);
+                count--;
+        }
+
+        priv->tx_tail = tx_tail;
+        smp_wmb(); /* Ensure tx_tail visible to xmit */
+
+out:
+        if (pkts_compl || bytes_compl)
+                netdev_completed_queue(ndev, pkts_compl, bytes_compl);
+
+        if (unlikely(netif_queue_stopped(ndev)) && (count < (TX_DESC_NUM - 1)))
+                netif_wake_queue(ndev);
+
+        return count;
+}
+
+static int hip04_mac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        struct net_device_stats *stats = &ndev->stats;
+        unsigned int tx_head = priv->tx_head, count;
+        struct tx_desc *desc = &priv->tx_desc[tx_head];
+        dma_addr_t phys;
+
+        smp_rmb();
+        count = tx_count(tx_head, ACCESS_ONCE(priv->tx_tail));
+        if (count == (TX_DESC_NUM - 1)) {
+                netif_stop_queue(ndev);
+                return NETDEV_TX_BUSY;
+        }
+
+        phys = dma_map_single(&ndev->dev, skb->data, skb->len, DMA_TO_DEVICE);
+        if (dma_mapping_error(&ndev->dev, phys)) {
+                dev_kfree_skb(skb);
+                return NETDEV_TX_OK;
+        }
+
+        priv->tx_skb[tx_head] = skb;
+        priv->tx_phys[tx_head] = phys;
+        desc->send_addr = cpu_to_be32(phys);
+        desc->send_size = cpu_to_be32(skb->len);
+        desc->cfg = cpu_to_be32(TX_CLEAR_WB | TX_FINISH_CACHE_INV);
+        phys = priv->tx_desc_dma + tx_head * sizeof(struct tx_desc);
+        desc->wb_addr = cpu_to_be32(phys);
+        skb_tx_timestamp(skb);
+
+        hip04_set_xmit_desc(priv, phys);
+        priv->tx_head = TX_NEXT(tx_head);
+        count++;
+        netdev_sent_queue(ndev, skb->len);
+
+        stats->tx_bytes += skb->len;
+        stats->tx_packets++;
+
+        /* Ensure tx_head update visible to tx reclaim */
+        smp_wmb();
+
+        /* queue is getting full, better start cleaning up now */
+        if (count >= priv->tx_coalesce_frames) {
+                if (napi_schedule_prep(&priv->napi)) {
+                        /* disable rx interrupt and timer */
+                        priv->reg_inten &= ~(RCV_INT);
+                        writel_relaxed(DEF_INT_MASK & ~RCV_INT,
+                                       priv->base + PPE_INTEN);
+                        hrtimer_cancel(&priv->tx_coalesce_timer);
+                        __napi_schedule(&priv->napi);
+                }
+        } else if (!hrtimer_is_queued(&priv->tx_coalesce_timer)) {
+                /* cleanup not pending yet, start a new timer */
+                hrtimer_start_expires(&priv->tx_coalesce_timer,
+                                      HRTIMER_MODE_REL);
+        }
+
+        return NETDEV_TX_OK;
+}
+
+static int hip04_rx_poll(struct napi_struct *napi, int budget)
+{
+        struct hip04_priv *priv = container_of(napi, struct hip04_priv, napi);
+        struct net_device *ndev = priv->ndev;
+        struct net_device_stats *stats = &ndev->stats;
+        unsigned int cnt = hip04_recv_cnt(priv);
+        struct rx_desc *desc;
+        struct sk_buff *skb;
+        unsigned char *buf;
+        bool last = false;
+        dma_addr_t phys;
+        int rx = 0;
+        int tx_remaining;
+        u16 len;
+        u32 err;
+
+        while (cnt && !last) {
+                buf = priv->rx_buf[priv->rx_head];
+                skb = build_skb(buf, priv->rx_buf_size);
+                if (unlikely(!skb))
+                        net_dbg_ratelimited("build_skb failed\n");
+
+                dma_unmap_single(&ndev->dev, priv->rx_phys[priv->rx_head],
+                                 RX_BUF_SIZE, DMA_FROM_DEVICE);
+                priv->rx_phys[priv->rx_head] = 0;
+
+                desc = (struct rx_desc *)skb->data;
+                len = be16_to_cpu(desc->pkt_len);
+                err = be32_to_cpu(desc->pkt_err);
+
+                if (0 == len) {
+                        dev_kfree_skb_any(skb);
+                        last = true;
+                } else if ((err & RX_PKT_ERR) || (len >= GMAC_MAX_PKT_LEN)) {
+                        dev_kfree_skb_any(skb);
+                        stats->rx_dropped++;
+                        stats->rx_errors++;
+                } else {
+                        skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN);
+                        skb_put(skb, len);
+                        skb->protocol = eth_type_trans(skb, ndev);
+                        napi_gro_receive(&priv->napi, skb);
+                        stats->rx_packets++;
+                        stats->rx_bytes += len;
+                        rx++;
+                }
+
+                buf = netdev_alloc_frag(priv->rx_buf_size);
+                if (!buf)
+                        goto done;
+                phys = dma_map_single(&ndev->dev, buf,
+                                      RX_BUF_SIZE, DMA_FROM_DEVICE);
+                if (dma_mapping_error(&ndev->dev, phys))
+                        goto done;
+                priv->rx_buf[priv->rx_head] = buf;
+                priv->rx_phys[priv->rx_head] = phys;
+                hip04_set_recv_desc(priv, phys);
+
+                priv->rx_head = RX_NEXT(priv->rx_head);
+                if (rx >= budget)
+                        goto done;
+
+                if (--cnt == 0)
+                        cnt = hip04_recv_cnt(priv);
+        }
+
+        if (!(priv->reg_inten & RCV_INT)) {
+                /* enable rx interrupt */
+                priv->reg_inten |= RCV_INT;
+                writel_relaxed(priv->reg_inten, priv->base + PPE_INTEN);
+        }
+        napi_complete(napi);
+done:
+        /* clean up tx descriptors and start a new timer if necessary */
+        tx_remaining = hip04_tx_reclaim(ndev, false);
+        if (rx < budget && tx_remaining)
+                hrtimer_start_expires(&priv->tx_coalesce_timer, HRTIMER_MODE_REL);
+
+        return rx;
+}
+
+static irqreturn_t hip04_mac_interrupt(int irq, void *dev_id)
+{
+        struct net_device *ndev = (struct net_device *)dev_id;
+        struct hip04_priv *priv = netdev_priv(ndev);
+        struct net_device_stats *stats = &ndev->stats;
+        u32 ists = readl_relaxed(priv->base + PPE_INTSTS);
+
+        if (!ists)
+                return IRQ_NONE;
+
+        writel_relaxed(DEF_INT_MASK, priv->base + PPE_RINT);
+
+        if (unlikely(ists & DEF_INT_ERR)) {
+                if (ists & (RCV_NOBUF | RCV_DROP)) {
+                        stats->rx_errors++;
+                        stats->rx_dropped++;
+                        netdev_err(ndev, "rx drop\n");
+                }
+                if (ists & TX_DROP) {
+                        stats->tx_dropped++;
+                        netdev_err(ndev, "tx drop\n");
+                }
+        }
+
+        if (ists & RCV_INT && napi_schedule_prep(&priv->napi)) {
+                /* disable rx interrupt */
+                priv->reg_inten &= ~(RCV_INT);
+                writel_relaxed(DEF_INT_MASK & ~RCV_INT, priv->base + PPE_INTEN);
+                hrtimer_cancel(&priv->tx_coalesce_timer);
+                __napi_schedule(&priv->napi);
+        }
+
+        return IRQ_HANDLED;
+}
+
+enum hrtimer_restart tx_done(struct hrtimer *hrtimer)
+{
+        struct hip04_priv *priv;
+
+        priv = container_of(hrtimer, struct hip04_priv, tx_coalesce_timer);
+
+        if (napi_schedule_prep(&priv->napi)) {
+                /* disable rx interrupt */
+                priv->reg_inten &= ~(RCV_INT);
+                writel_relaxed(DEF_INT_MASK & ~RCV_INT, priv->base + PPE_INTEN);
+                __napi_schedule(&priv->napi);
+        }
+
+        return HRTIMER_NORESTART;
+}
+
+static void hip04_adjust_link(struct net_device *ndev)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        struct phy_device *phy = priv->phy;
+
+        if ((priv->speed != phy->speed) || (priv->duplex != phy->duplex)) {
+                hip04_config_port(ndev, phy->speed, phy->duplex);
+                phy_print_status(phy);
+        }
+}
+
+static int hip04_mac_open(struct net_device *ndev)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        int i;
+
+        priv->rx_head = 0;
+        priv->tx_head = 0;
+        priv->tx_tail = 0;
+        hip04_reset_ppe(priv);
+
+        for (i = 0; i < RX_DESC_NUM; i++) {
+                dma_addr_t phys;
+
+                phys = dma_map_single(&ndev->dev, priv->rx_buf[i],
+                                      RX_BUF_SIZE, DMA_FROM_DEVICE);
+                if (dma_mapping_error(&ndev->dev, phys))
+                        return -EIO;
+
+                priv->rx_phys[i] = phys;
+                hip04_set_recv_desc(priv, phys);
+        }
+
+        if (priv->phy)
+                phy_start(priv->phy);
+
+        netdev_reset_queue(ndev);
+        netif_start_queue(ndev);
+        hip04_mac_enable(ndev);
+        napi_enable(&priv->napi);
+
+        return 0;
+}
+
+static int hip04_mac_stop(struct net_device *ndev)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        int i;
+
+        napi_disable(&priv->napi);
+        netif_stop_queue(ndev);
+        hip04_mac_disable(ndev);
+        hip04_tx_reclaim(ndev, true);
+        hip04_reset_ppe(priv);
+
+        if (priv->phy)
+                phy_stop(priv->phy);
+
+        for (i = 0; i < RX_DESC_NUM; i++) {
+                if (priv->rx_phys[i]) {
+                        dma_unmap_single(&ndev->dev, priv->rx_phys[i],
+                                         RX_BUF_SIZE, DMA_FROM_DEVICE);
+                        priv->rx_phys[i] = 0;
+                }
+        }
+
+        return 0;
+}
+
+static void hip04_timeout(struct net_device *ndev)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+
+        schedule_work(&priv->tx_timeout_task);
+}
+
+static void hip04_tx_timeout_task(struct work_struct *work)
+{
+        struct hip04_priv *priv;
+
+        priv = container_of(work, struct hip04_priv, tx_timeout_task);
+        hip04_mac_stop(priv->ndev);
+        hip04_mac_open(priv->ndev);
+}
+
+static struct net_device_stats *hip04_get_stats(struct net_device *ndev)
+{
+        return &ndev->stats;
+}
+
+static int hip04_get_coalesce(struct net_device *netdev,
+                              struct ethtool_coalesce *ec)
+{
+        struct hip04_priv *priv = netdev_priv(netdev);
+
+        ec->tx_coalesce_usecs = priv->tx_coalesce_usecs;
+        ec->tx_max_coalesced_frames = priv->tx_coalesce_frames;
+
+        return 0;
+}
+
+static int hip04_set_coalesce(struct net_device *netdev,
+                              struct ethtool_coalesce *ec)
+{
+        struct hip04_priv *priv = netdev_priv(netdev);
+
+        /* Check not supported parameters  */
+        if ((ec->rx_max_coalesced_frames) || (ec->rx_coalesce_usecs_irq) ||
+            (ec->rx_max_coalesced_frames_irq) || (ec->tx_coalesce_usecs_irq) ||
+            (ec->use_adaptive_rx_coalesce) || (ec->use_adaptive_tx_coalesce) ||
+            (ec->pkt_rate_low) || (ec->rx_coalesce_usecs_low) ||
+            (ec->rx_max_coalesced_frames_low) || (ec->tx_coalesce_usecs_high) ||
+            (ec->tx_max_coalesced_frames_low) || (ec->pkt_rate_high) ||
+            (ec->tx_coalesce_usecs_low) || (ec->rx_coalesce_usecs_high) ||
+            (ec->rx_max_coalesced_frames_high) || (ec->rx_coalesce_usecs) ||
+            (ec->tx_max_coalesced_frames_irq) ||
+            (ec->stats_block_coalesce_usecs) ||
+            (ec->tx_max_coalesced_frames_high) || (ec->rate_sample_interval))
+                return -EOPNOTSUPP;
+
+        if ((ec->tx_coalesce_usecs > HIP04_MAX_TX_COALESCE_USECS ||
+             ec->tx_coalesce_usecs < HIP04_MIN_TX_COALESCE_USECS) ||
+            (ec->tx_max_coalesced_frames > HIP04_MAX_TX_COALESCE_FRAMES ||
+             ec->tx_max_coalesced_frames < HIP04_MIN_TX_COALESCE_FRAMES))
+                return -EINVAL;
+
+        priv->tx_coalesce_usecs = ec->tx_coalesce_usecs;
+        priv->tx_coalesce_frames = ec->tx_max_coalesced_frames;
+
+        return 0;
+}
+
+static void hip04_get_drvinfo(struct net_device *netdev,
+                              struct ethtool_drvinfo *drvinfo)
+{
+        strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
+        strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
+}
+
+static struct ethtool_ops hip04_ethtool_ops = {
+        .get_coalesce           = hip04_get_coalesce,
+        .set_coalesce           = hip04_set_coalesce,
+        .get_drvinfo            = hip04_get_drvinfo,
+};
+
+static struct net_device_ops hip04_netdev_ops = {
+        .ndo_open               = hip04_mac_open,
+        .ndo_stop               = hip04_mac_stop,
+        .ndo_get_stats          = hip04_get_stats,
+        .ndo_start_xmit         = hip04_mac_start_xmit,
+        .ndo_set_mac_address    = hip04_set_mac_address,
+        .ndo_tx_timeout         = hip04_timeout,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_change_mtu         = eth_change_mtu,
+};
+
+static int hip04_alloc_ring(struct net_device *ndev, struct device *d)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        int i;
+
+        priv->tx_desc = dma_alloc_coherent(d,
+                                           TX_DESC_NUM * sizeof(struct tx_desc),
+                                           &priv->tx_desc_dma, GFP_KERNEL);
+        if (!priv->tx_desc)
+                return -ENOMEM;
+
+        priv->rx_buf_size = RX_BUF_SIZE +
+                            SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+        for (i = 0; i < RX_DESC_NUM; i++) {
+                priv->rx_buf[i] = netdev_alloc_frag(priv->rx_buf_size);
+                if (!priv->rx_buf[i])
+                        return -ENOMEM;
+        }
+
+        return 0;
+}
+
+static void hip04_free_ring(struct net_device *ndev, struct device *d)
+{
+        struct hip04_priv *priv = netdev_priv(ndev);
+        int i;
+
+        for (i = 0; i < RX_DESC_NUM; i++)
+                if (priv->rx_buf[i])
+                        put_page(virt_to_head_page(priv->rx_buf[i]));
+
+        for (i = 0; i < TX_DESC_NUM; i++)
+                if (priv->tx_skb[i])
+                        dev_kfree_skb_any(priv->tx_skb[i]);
+
+        dma_free_coherent(d, TX_DESC_NUM * sizeof(struct tx_desc),
+                          priv->tx_desc, priv->tx_desc_dma);
+}
+
+static int hip04_mac_probe(struct platform_device *pdev)
+{
+        struct device *d = &pdev->dev;
+        struct device_node *node = d->of_node;
+        struct of_phandle_args arg;
+        struct net_device *ndev;
+        struct hip04_priv *priv;
+        struct resource *res;
+        unsigned int irq;
+        ktime_t txtime;
+        int ret;
+
+        ndev = alloc_etherdev(sizeof(struct hip04_priv));
+        if (!ndev)
+                return -ENOMEM;
+
+        priv = netdev_priv(ndev);
+        priv->ndev = ndev;
+        platform_set_drvdata(pdev, ndev);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        priv->base = devm_ioremap_resource(d, res);
+        if (IS_ERR(priv->base)) {
+                ret = PTR_ERR(priv->base);
+                goto init_fail;
+        }
+
+        ret = of_parse_phandle_with_fixed_args(node, "port-handle", 2, 0, &arg);
+        if (ret < 0) {
+                dev_warn(d, "no port-handle\n");
+                goto init_fail;
+        }
+
+        priv->port = arg.args[0];
+        priv->chan = arg.args[1] * RX_DESC_NUM;
+
+        hrtimer_init(&priv->tx_coalesce_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+
+        /* BQL will try to keep the TX queue as short as possible, but it can't
+         * be faster than tx_coalesce_usecs, so we need a fast timeout here,
+         * but also long enough to gather up enough frames to ensure we don't
+         * get more interrupts than necessary.
+         * 200us is enough for 16 frames of 1500 bytes at gigabit ethernet rate
+         */
+        priv->tx_coalesce_frames = TX_DESC_NUM * 3 / 4;
+        priv->tx_coalesce_usecs = 200;
+        /* allow timer to fire after half the time at the earliest */
+        txtime = ktime_set(0, priv->tx_coalesce_usecs * NSEC_PER_USEC / 2);
+        hrtimer_set_expires_range(&priv->tx_coalesce_timer, txtime, txtime);
+        priv->tx_coalesce_timer.function = tx_done;
+
+        priv->map = syscon_node_to_regmap(arg.np);
+        if (IS_ERR(priv->map)) {
+                dev_warn(d, "no syscon hisilicon,hip04-ppe\n");
+                ret = PTR_ERR(priv->map);
+                goto init_fail;
+        }
+
+        priv->phy_mode = of_get_phy_mode(node);
+        if (priv->phy_mode < 0) {
+                dev_warn(d, "not find phy-mode\n");
+                ret = -EINVAL;
+                goto init_fail;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq <= 0) {
+                ret = -EINVAL;
+                goto init_fail;
+        }
+
+        ret = devm_request_irq(d, irq, hip04_mac_interrupt,
+                               0, pdev->name, ndev);
+        if (ret) {
+                netdev_err(ndev, "devm_request_irq failed\n");
+                goto init_fail;
+        }
+
+        priv->phy_node = of_parse_phandle(node, "phy-handle", 0);
+        if (priv->phy_node) {
+                priv->phy = of_phy_connect(ndev, priv->phy_node,
+                                           &hip04_adjust_link,
+                                           0, priv->phy_mode);
+                if (!priv->phy) {
+                        ret = -EPROBE_DEFER;
+                        goto init_fail;
+                }
+        }
+
+        INIT_WORK(&priv->tx_timeout_task, hip04_tx_timeout_task);
+
+        ether_setup(ndev);
+        ndev->netdev_ops = &hip04_netdev_ops;
+        ndev->ethtool_ops = &hip04_ethtool_ops;
+        ndev->watchdog_timeo = TX_TIMEOUT;
+        ndev->priv_flags |= IFF_UNICAST_FLT;
+        ndev->irq = irq;
+        netif_napi_add(ndev, &priv->napi, hip04_rx_poll, NAPI_POLL_WEIGHT);
+        SET_NETDEV_DEV(ndev, &pdev->dev);
+
+        hip04_reset_ppe(priv);
+        if (priv->phy_mode == PHY_INTERFACE_MODE_MII)
+                hip04_config_port(ndev, SPEED_100, DUPLEX_FULL);
+
+        hip04_config_fifo(priv);
+        random_ether_addr(ndev->dev_addr);
+        hip04_update_mac_address(ndev);
+
+        ret = hip04_alloc_ring(ndev, d);
+        if (ret) {
+                netdev_err(ndev, "alloc ring fail\n");
+                goto alloc_fail;
+        }
+
+        ret = register_netdev(ndev);
+        if (ret) {
+                free_netdev(ndev);
+                goto alloc_fail;
+        }
+
+        return 0;
+
+alloc_fail:
+        hip04_free_ring(ndev, d);
+init_fail:
+        of_node_put(priv->phy_node);
+        free_netdev(ndev);
+        return ret;
+}
+
+static int hip04_remove(struct platform_device *pdev)
+{
+        struct net_device *ndev = platform_get_drvdata(pdev);
+        struct hip04_priv *priv = netdev_priv(ndev);
+        struct device *d = &pdev->dev;
+
+        if (priv->phy)
+                phy_disconnect(priv->phy);
+
+        hip04_free_ring(ndev, d);
+        unregister_netdev(ndev);
+        free_irq(ndev->irq, ndev);
+        of_node_put(priv->phy_node);
+        cancel_work_sync(&priv->tx_timeout_task);
+        free_netdev(ndev);
+
+        return 0;
+}
+
+static const struct of_device_id hip04_mac_match[] = {
+        { .compatible = "hisilicon,hip04-mac" },
+        { }
+};
+
+MODULE_DEVICE_TABLE(of, hip04_mac_match);
+
+static struct platform_driver hip04_mac_driver = {
+        .probe  = hip04_mac_probe,
+        .remove = hip04_remove,
+        .driver = {
+                .name           = DRV_NAME,
+                .owner          = THIS_MODULE,
+                .of_match_table = hip04_mac_match,
+        },
+};
+module_platform_driver(hip04_mac_driver);
+
+MODULE_DESCRIPTION("HISILICON P04 Ethernet driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/ethernet/hisilicon/hip04_mdio.c b/drivers/net/ethernet/hisilicon/hip04_mdio.c
new file mode 100644
index 000000000000..b3bac25db99c
--- /dev/null
+++ b/drivers/net/ethernet/hisilicon/hip04_mdio.c
@@ -0,0 +1,186 @@
+/* Copyright (c) 2014 Linaro Ltd.
+ * Copyright (c) 2014 Hisilicon Limited.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/of_mdio.h>
+#include <linux/delay.h>
+
+#define MDIO_CMD_REG            0x0
+#define MDIO_ADDR_REG           0x4
+#define MDIO_WDATA_REG          0x8
+#define MDIO_RDATA_REG          0xc
+#define MDIO_STA_REG            0x10
+
+#define MDIO_START              BIT(14)
+#define MDIO_R_VALID            BIT(1)
+#define MDIO_READ               (BIT(12) | BIT(11) | MDIO_START)
+#define MDIO_WRITE              (BIT(12) | BIT(10) | MDIO_START)
+
+struct hip04_mdio_priv {
+        void __iomem *base;
+};
+
+#define WAIT_TIMEOUT 10
+static int hip04_mdio_wait_ready(struct mii_bus *bus)
+{
+        struct hip04_mdio_priv *priv = bus->priv;
+        int i;
+
+        for (i = 0; readl_relaxed(priv->base + MDIO_CMD_REG) & MDIO_START; i++) {
+                if (i == WAIT_TIMEOUT)
+                        return -ETIMEDOUT;
+                msleep(20);
+        }
+
+        return 0;
+}
+
+static int hip04_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+        struct hip04_mdio_priv *priv = bus->priv;
+        u32 val;
+        int ret;
+
+        ret = hip04_mdio_wait_ready(bus);
+        if (ret < 0)
+                goto out;
+
+        val = regnum | (mii_id << 5) | MDIO_READ;
+        writel_relaxed(val, priv->base + MDIO_CMD_REG);
+
+        ret = hip04_mdio_wait_ready(bus);
+        if (ret < 0)
+                goto out;
+
+        val = readl_relaxed(priv->base + MDIO_STA_REG);
+        if (val & MDIO_R_VALID) {
+                dev_err(bus->parent, "SMI bus read not valid\n");
+                ret = -ENODEV;
+                goto out;
+        }
+
+        val = readl_relaxed(priv->base + MDIO_RDATA_REG);
+        ret = val & 0xFFFF;
+out:
+        return ret;
+}
+
+static int hip04_mdio_write(struct mii_bus *bus, int mii_id,
+                            int regnum, u16 value)
+{
+        struct hip04_mdio_priv *priv = bus->priv;
+        u32 val;
+        int ret;
+
+        ret = hip04_mdio_wait_ready(bus);
+        if (ret < 0)
+                goto out;
+
+        writel_relaxed(value, priv->base + MDIO_WDATA_REG);
+        val = regnum | (mii_id << 5) | MDIO_WRITE;
+        writel_relaxed(val, priv->base + MDIO_CMD_REG);
+out:
+        return ret;
+}
+
+static int hip04_mdio_reset(struct mii_bus *bus)
+{
+        int temp, i;
+
+        for (i = 0; i < PHY_MAX_ADDR; i++) {
+                hip04_mdio_write(bus, i, 22, 0);
+                temp = hip04_mdio_read(bus, i, MII_BMCR);
+                if (temp < 0)
+                        continue;
+
+                temp |= BMCR_RESET;
+                if (hip04_mdio_write(bus, i, MII_BMCR, temp) < 0)
+                        continue;
+        }
+
+        mdelay(500);
+        return 0;
+}
+
+static int hip04_mdio_probe(struct platform_device *pdev)
+{
+        struct resource *r;
+        struct mii_bus *bus;
+        struct hip04_mdio_priv *priv;
+        int ret;
+
+        bus = mdiobus_alloc_size(sizeof(struct hip04_mdio_priv));
+        if (!bus) {
+                dev_err(&pdev->dev, "Cannot allocate MDIO bus\n");
+                return -ENOMEM;
+        }
+
+        bus->name = "hip04_mdio_bus";
+        bus->read = hip04_mdio_read;
+        bus->write = hip04_mdio_write;
+        bus->reset = hip04_mdio_reset;
+        snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", dev_name(&pdev->dev));
+        bus->parent = &pdev->dev;
+        priv = bus->priv;
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        priv->base = devm_ioremap_resource(&pdev->dev, r);
+        if (IS_ERR(priv->base)) {
+                ret = PTR_ERR(priv->base);
+                goto out_mdio;
+        }
+
+        ret = of_mdiobus_register(bus, pdev->dev.of_node);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Cannot register MDIO bus (%d)\n", ret);
+                goto out_mdio;
+        }
+
+        platform_set_drvdata(pdev, bus);
+
+        return 0;
+
+out_mdio:
+        mdiobus_free(bus);
+        return ret;
+}
+
+static int hip04_mdio_remove(struct platform_device *pdev)
+{
+        struct mii_bus *bus = platform_get_drvdata(pdev);
+
+        mdiobus_unregister(bus);
+        mdiobus_free(bus);
+
+        return 0;
+}
+
+static const struct of_device_id hip04_mdio_match[] = {
+        { .compatible = "hisilicon,hip04-mdio" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, hip04_mdio_match);
+
+static struct platform_driver hip04_mdio_driver = {
+        .probe = hip04_mdio_probe,
+        .remove = hip04_mdio_remove,
+        .driver = {
+                .name = "hip04-mdio",
+                .owner = THIS_MODULE,
+                .of_match_table = hip04_mdio_match,
+        },
+};
+
+module_platform_driver(hip04_mdio_driver);
+
+MODULE_DESCRIPTION("HISILICON P04 MDIO interface driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:hip04-mdio");
diff --git a/drivers/net/ethernet/ibm/ehea/ehea_main.c b/drivers/net/ethernet/ibm/ehea/ehea_main.c
index 566b17db135a..e8a1adb7a962 100644
--- a/drivers/net/ethernet/ibm/ehea/ehea_main.c
+++ b/drivers/net/ethernet/ibm/ehea/ehea_main.c
@@ -2064,9 +2064,9 @@ static int ehea_start_xmit(struct sk_buff *skb, struct net_device *dev)
         memset(swqe, 0, SWQE_HEADER_SIZE);
         atomic_dec(&pr->swqe_avail);
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 swqe->tx_control |= EHEA_SWQE_VLAN_INSERT;
-                swqe->vlan_tag = vlan_tx_tag_get(skb);
+                swqe->vlan_tag = skb_vlan_tag_get(skb);
         }
 
         pr->tx_packets++;
diff --git a/drivers/net/ethernet/ibm/emac/core.c b/drivers/net/ethernet/ibm/emac/core.c
index 9388a83818f2..162762d1a12c 100644
--- a/drivers/net/ethernet/ibm/emac/core.c
+++ b/drivers/net/ethernet/ibm/emac/core.c
@@ -2367,7 +2367,7 @@ static int emac_wait_deps(struct emac_instance *dev)
         err = emac_check_deps(dev, deps) ? 0 : -ENODEV;
         for (i = 0; i < EMAC_DEP_COUNT; i++) {
                 of_node_put(deps[i].node);
-                if (err && deps[i].ofdev)
+                if (err)
                         of_dev_put(deps[i].ofdev);
         }
         if (err == 0) {
diff --git a/drivers/net/ethernet/intel/Kconfig b/drivers/net/ethernet/intel/Kconfig
index 4d61ef50b465..f4ff465584a0 100644
--- a/drivers/net/ethernet/intel/Kconfig
+++ b/drivers/net/ethernet/intel/Kconfig
@@ -192,6 +192,17 @@ config IXGBE
           To compile this driver as a module, choose M here. The module
           will be called ixgbe.
 
+config IXGBE_VXLAN
+        bool "Virtual eXtensible Local Area Network Support"
+        default n
+        depends on IXGBE && VXLAN && !(IXGBE=y && VXLAN=m)
+        ---help---
+          This allows one to create VXLAN virtual interfaces that provide
+          Layer 2 Networks over Layer 3 Networks. VXLAN is often used
+          to tunnel virtual network infrastructure in virtualized environments.
+          Say Y here if you want to use Virtual eXtensible Local Area Network
+          (VXLAN) in the driver.
+
 config IXGBE_HWMON
         bool "Intel(R) 10GbE PCI Express adapters HWMON support"
         default y
diff --git a/drivers/net/ethernet/intel/e1000/e1000_ethtool.c b/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
index b691eb4f6376..4270ad2d4ddf 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
@@ -24,6 +24,7 @@
 /* ethtool support for e1000 */
 
 #include "e1000.h"
+#include <linux/jiffies.h>
 #include <linux/uaccess.h>
 
 enum {NETDEV_STATS, E1000_STATS};
@@ -1460,7 +1461,7 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
                         ret_val = 13; /* ret_val is the same as mis-compare */
                         break;
                 }
-                if (jiffies >= (time + 2)) {
+                if (time_after_eq(jiffies, time + 2)) {
                         ret_val = 14; /* error code for time out error */
                         break;
                 }
diff --git a/drivers/net/ethernet/intel/e1000/e1000_main.c b/drivers/net/ethernet/intel/e1000/e1000_main.c
index 83140cbb5f01..7f997d36948f 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_main.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_main.c
@@ -2977,7 +2977,6 @@ static void e1000_tx_queue(struct e1000_adapter *adapter,
                            struct e1000_tx_ring *tx_ring, int tx_flags,
                            int count)
 {
-        struct e1000_hw *hw = &adapter->hw;
         struct e1000_tx_desc *tx_desc = NULL;
         struct e1000_tx_buffer *buffer_info;
         u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
@@ -3031,11 +3030,6 @@ static void e1000_tx_queue(struct e1000_adapter *adapter,
         wmb();
 
         tx_ring->next_to_use = i;
-        writel(i, hw->hw_addr + tx_ring->tdt);
-        /* we need this if more than one processor can write to our tail
-         * at a time, it synchronizes IO on IA64/Altix systems
-         */
-        mmiowb();
 }
 
 /* 82547 workaround to avoid controller hang in half-duplex environment.
@@ -3226,9 +3220,10 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                 return NETDEV_TX_BUSY;
         }
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 tx_flags |= E1000_TX_FLAGS_VLAN;
-                tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
+                tx_flags |= (skb_vlan_tag_get(skb) <<
+                             E1000_TX_FLAGS_VLAN_SHIFT);
         }
 
         first = tx_ring->next_to_use;
@@ -3263,6 +3258,15 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                 /* Make sure there is space in the ring for the next send. */
                 e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
 
+                if (!skb->xmit_more ||
+                    netif_xmit_stopped(netdev_get_tx_queue(netdev, 0))) {
+                        writel(tx_ring->next_to_use, hw->hw_addr + tx_ring->tdt);
+                        /* we need this if more than one processor can write to
+                         * our tail at a time, it synchronizes IO on IA64/Altix
+                         * systems
+                         */
+                        mmiowb();
+                }
         } else {
                 dev_kfree_skb_any(skb);
                 tx_ring->buffer_info[first].time_stamp = 0;
diff --git a/drivers/net/ethernet/intel/e1000e/e1000.h b/drivers/net/ethernet/intel/e1000e/e1000.h
index 7785240a0da1..9416e5a7e0c8 100644
--- a/drivers/net/ethernet/intel/e1000e/e1000.h
+++ b/drivers/net/ethernet/intel/e1000e/e1000.h
@@ -34,7 +34,7 @@
 #include <linux/pci-aspm.h>
 #include <linux/crc32.h>
 #include <linux/if_vlan.h>
-#include <linux/clocksource.h>
+#include <linux/timecounter.h>
 #include <linux/net_tstamp.h>
 #include <linux/ptp_clock_kernel.h>
 #include <linux/ptp_classify.h>
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index e14fd85f64eb..1e8c40fd5c3d 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -4189,7 +4189,7 @@ static int e1000_sw_init(struct e1000_adapter *adapter)
         /* Setup hardware time stamping cyclecounter */
         if (adapter->flags & FLAG_HAS_HW_TIMESTAMP) {
                 adapter->cc.read = e1000e_cyclecounter_read;
-                adapter->cc.mask = CLOCKSOURCE_MASK(64);
+                adapter->cc.mask = CYCLECOUNTER_MASK(64);
                 adapter->cc.mult = 1;
                 /* cc.shift set in e1000e_get_base_tininca() */
 
@@ -5444,16 +5444,6 @@ static void e1000_tx_queue(struct e1000_ring *tx_ring, int tx_flags, int count)
         wmb();
 
         tx_ring->next_to_use = i;
-
-        if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
-                e1000e_update_tdt_wa(tx_ring, i);
-        else
-                writel(i, tx_ring->tail);
-
-        /* we need this if more than one processor can write to our tail
-         * at a time, it synchronizes IO on IA64/Altix systems
-         */
-        mmiowb();
 }
 
 #define MINIMUM_DHCP_PACKET_SIZE 282
@@ -5463,8 +5453,8 @@ static int e1000_transfer_dhcp_info(struct e1000_adapter *adapter,
         struct e1000_hw *hw = &adapter->hw;
         u16 length, offset;
 
-        if (vlan_tx_tag_present(skb) &&
-            !((vlan_tx_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
+        if (skb_vlan_tag_present(skb) &&
+            !((skb_vlan_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
               (adapter->hw.mng_cookie.status &
                E1000_MNG_DHCP_COOKIE_STATUS_VLAN)))
                 return 0;
@@ -5603,9 +5593,10 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
         if (e1000_maybe_stop_tx(tx_ring, count + 2))
                 return NETDEV_TX_BUSY;
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 tx_flags |= E1000_TX_FLAGS_VLAN;
-                tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
+                tx_flags |= (skb_vlan_tag_get(skb) <<
+                             E1000_TX_FLAGS_VLAN_SHIFT);
         }
 
         first = tx_ring->next_to_use;
@@ -5635,8 +5626,9 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
         count = e1000_tx_map(tx_ring, skb, first, adapter->tx_fifo_limit,
                              nr_frags);
         if (count) {
-                if (unlikely((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
-                             !adapter->tx_hwtstamp_skb)) {
+                if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
+                    (adapter->flags & FLAG_HAS_HW_TIMESTAMP) &&
+                    !adapter->tx_hwtstamp_skb) {
                         skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
                         tx_flags |= E1000_TX_FLAGS_HWTSTAMP;
                         adapter->tx_hwtstamp_skb = skb_get(skb);
@@ -5653,6 +5645,21 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                                     (MAX_SKB_FRAGS *
                                      DIV_ROUND_UP(PAGE_SIZE,
                                                   adapter->tx_fifo_limit) + 2));
+
+                if (!skb->xmit_more ||
+                    netif_xmit_stopped(netdev_get_tx_queue(netdev, 0))) {
+                        if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                                e1000e_update_tdt_wa(tx_ring,
+                                                     tx_ring->next_to_use);
+                        else
+                                writel(tx_ring->next_to_use, tx_ring->tail);
+
+                        /* we need this if more than one processor can write
+                         * to our tail at a time, it synchronizes IO on
+                         *IA64/Altix systems
+                         */
+                        mmiowb();
+                }
         } else {
                 dev_kfree_skb_any(skb);
                 tx_ring->buffer_info[first].time_stamp = 0;
diff --git a/drivers/net/ethernet/intel/e1000e/ptp.c b/drivers/net/ethernet/intel/e1000e/ptp.c
index fb1a914a3ad4..978ef9c4a043 100644
--- a/drivers/net/ethernet/intel/e1000e/ptp.c
+++ b/drivers/net/ethernet/intel/e1000e/ptp.c
@@ -90,12 +90,9 @@ static int e1000e_phc_adjtime(struct ptp_clock_info *ptp, s64 delta)
         struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
                                                      ptp_clock_info);
         unsigned long flags;
-        s64 now;
 
         spin_lock_irqsave(&adapter->systim_lock, flags);
-        now = timecounter_read(&adapter->tc);
-        now += delta;
-        timecounter_init(&adapter->tc, &adapter->cc, now);
+        timecounter_adjtime(&adapter->tc, delta);
         spin_unlock_irqrestore(&adapter->systim_lock, flags);
 
         return 0;
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_main.c b/drivers/net/ethernet/intel/fm10k/fm10k_main.c
index eb088b129bc7..84ab9eea2768 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_main.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_main.c
@@ -97,7 +97,6 @@ static bool fm10k_alloc_mapped_page(struct fm10k_ring *rx_ring,
          */
         if (dma_mapping_error(rx_ring->dev, dma)) {
                 __free_page(page);
-                bi->page = NULL;
 
                 rx_ring->rx_stats.alloc_failed++;
                 return false;
@@ -147,8 +146,8 @@ void fm10k_alloc_rx_buffers(struct fm10k_ring *rx_ring, u16 cleaned_count)
                         i -= rx_ring->count;
                 }
 
-                /* clear the hdr_addr for the next_to_use descriptor */
-                rx_desc->q.hdr_addr = 0;
+                /* clear the status bits for the next_to_use descriptor */
+                rx_desc->d.staterr = 0;
 
                 cleaned_count--;
         } while (cleaned_count);
@@ -194,7 +193,7 @@ static void fm10k_reuse_rx_page(struct fm10k_ring *rx_ring,
         rx_ring->next_to_alloc = (nta < rx_ring->count) ? nta : 0;
 
         /* transfer page from old buffer to new buffer */
-        memcpy(new_buff, old_buff, sizeof(struct fm10k_rx_buffer));
+        *new_buff = *old_buff;
 
         /* sync the buffer for use by the device */
         dma_sync_single_range_for_device(rx_ring->dev, old_buff->dma,
@@ -203,12 +202,17 @@ static void fm10k_reuse_rx_page(struct fm10k_ring *rx_ring,
                                          DMA_FROM_DEVICE);
 }
 
+static inline bool fm10k_page_is_reserved(struct page *page)
+{
+        return (page_to_nid(page) != numa_mem_id()) || page->pfmemalloc;
+}
+
 static bool fm10k_can_reuse_rx_page(struct fm10k_rx_buffer *rx_buffer,
                                     struct page *page,
                                     unsigned int truesize)
 {
         /* avoid re-using remote pages */
-        if (unlikely(page_to_nid(page) != numa_mem_id()))
+        if (unlikely(fm10k_page_is_reserved(page)))
                 return false;
 
 #if (PAGE_SIZE < 8192)
@@ -218,22 +222,19 @@ static bool fm10k_can_reuse_rx_page(struct fm10k_rx_buffer *rx_buffer,
 
         /* flip page offset to other buffer */
         rx_buffer->page_offset ^= FM10K_RX_BUFSZ;
-
-        /* Even if we own the page, we are not allowed to use atomic_set()
-         * This would break get_page_unless_zero() users.
-         */
-        atomic_inc(&page->_count);
 #else
         /* move offset up to the next cache line */
         rx_buffer->page_offset += truesize;
 
         if (rx_buffer->page_offset > (PAGE_SIZE - FM10K_RX_BUFSZ))
                 return false;
-
-        /* bump ref count on page before it is given to the stack */
-        get_page(page);
 #endif
 
+        /* Even if we own the page, we are not allowed to use atomic_set()
+         * This would break get_page_unless_zero() users.
+         */
+        atomic_inc(&page->_count);
+
         return true;
 }
 
@@ -270,12 +271,12 @@ static bool fm10k_add_rx_frag(struct fm10k_ring *rx_ring,
 
                 memcpy(__skb_put(skb, size), va, ALIGN(size, sizeof(long)));
 
-                /* we can reuse buffer as-is, just make sure it is local */
-                if (likely(page_to_nid(page) == numa_mem_id()))
+                /* page is not reserved, we can reuse buffer as-is */
+                if (likely(!fm10k_page_is_reserved(page)))
                         return true;
 
                 /* this page cannot be reused so discard it */
-                put_page(page);
+                __free_page(page);
                 return false;
         }
 
@@ -293,7 +294,6 @@ static struct sk_buff *fm10k_fetch_rx_buffer(struct fm10k_ring *rx_ring,
         struct page *page;
 
         rx_buffer = &rx_ring->rx_buffer[rx_ring->next_to_clean];
-
         page = rx_buffer->page;
         prefetchw(page);
 
@@ -727,6 +727,12 @@ static __be16 fm10k_tx_encap_offload(struct sk_buff *skb)
         struct ethhdr *eth_hdr;
         u8 l4_hdr = 0;
 
+/* fm10k supports 184 octets of outer+inner headers. Minus 20 for inner L4. */
+#define FM10K_MAX_ENCAP_TRANSPORT_OFFSET        164
+        if (skb_inner_transport_header(skb) - skb_mac_header(skb) >
+            FM10K_MAX_ENCAP_TRANSPORT_OFFSET)
+                return 0;
+
         switch (vlan_get_protocol(skb)) {
         case htons(ETH_P_IP):
                 l4_hdr = ip_hdr(skb)->protocol;
@@ -965,8 +971,8 @@ static void fm10k_tx_map(struct fm10k_ring *tx_ring,
         tx_desc = FM10K_TX_DESC(tx_ring, i);
 
         /* add HW VLAN tag */
-        if (vlan_tx_tag_present(skb))
-                tx_desc->vlan = cpu_to_le16(vlan_tx_tag_get(skb));
+        if (skb_vlan_tag_present(skb))
+                tx_desc->vlan = cpu_to_le16(skb_vlan_tag_get(skb));
         else
                 tx_desc->vlan = 0;
 
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_mbx.c b/drivers/net/ethernet/intel/fm10k/fm10k_mbx.c
index 14a4ea795c01..9f5457c9e627 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_mbx.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_mbx.c
@@ -1194,12 +1194,11 @@ static s32 fm10k_mbx_process_disconnect(struct fm10k_hw *hw,
 {
         const enum fm10k_mbx_state state = mbx->state;
         const u32 *hdr = &mbx->mbx_hdr;
-        u16 head, tail;
+        u16 head;
         s32 err;
 
-        /* we will need to pull all of the fields for verification */
+        /* we will need to pull the header field for verification */
         head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
-        tail = FM10K_MSG_HDR_FIELD_GET(*hdr, TAIL);
 
         /* We should not be receiving disconnect if Rx is incomplete */
         if (mbx->pushed)
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c b/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c
index 8811364b91cb..cfde8bac1aeb 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c
@@ -609,7 +609,7 @@ static netdev_tx_t fm10k_xmit_frame(struct sk_buff *skb, struct net_device *dev)
         int err;
 
         if ((skb->protocol ==  htons(ETH_P_8021Q)) &&
-            !vlan_tx_tag_present(skb)) {
+            !skb_vlan_tag_present(skb)) {
                 /* FM10K only supports hardware tagging, any tags in frame
                  * are considered 2nd level or "outer" tags
                  */
@@ -1414,13 +1414,12 @@ struct net_device *fm10k_alloc_netdev(void)
         dev->vlan_features |= dev->features;
 
         /* configure tunnel offloads */
-        dev->hw_enc_features = NETIF_F_IP_CSUM |
-                               NETIF_F_TSO |
-                               NETIF_F_TSO6 |
-                               NETIF_F_TSO_ECN |
-                               NETIF_F_GSO_UDP_TUNNEL |
-                               NETIF_F_IPV6_CSUM |
-                               NETIF_F_SG;
+        dev->hw_enc_features |= NETIF_F_IP_CSUM |
+                                NETIF_F_TSO |
+                                NETIF_F_TSO6 |
+                                NETIF_F_TSO_ECN |
+                                NETIF_F_GSO_UDP_TUNNEL |
+                                NETIF_F_IPV6_CSUM;
 
         /* we want to leave these both on as we cannot disable VLAN tag
          * insertion or stripping on the hardware since it is contained
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_pf.c b/drivers/net/ethernet/intel/fm10k/fm10k_pf.c
index 275423d4f777..7e4711958e46 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_pf.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_pf.c
@@ -330,13 +330,10 @@ static s32 fm10k_update_xc_addr_pf(struct fm10k_hw *hw, u16 glort,
         struct fm10k_mac_update mac_update;
         u32 msg[5];
 
-        /* if glort is not valid return error */
-        if (!fm10k_glort_valid_pf(hw, glort))
+        /* if glort or vlan are not valid return error */
+        if (!fm10k_glort_valid_pf(hw, glort) || vid >= FM10K_VLAN_TABLE_VID_MAX)
                 return FM10K_ERR_PARAM;
 
-        /* drop upper 4 bits of VLAN ID */
-        vid = (vid << 4) >> 4;
-
         /* record fields */
         mac_update.mac_lower = cpu_to_le32(((u32)mac[2] << 24) |
                                                  ((u32)mac[3] << 16) |
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_ptp.c b/drivers/net/ethernet/intel/fm10k/fm10k_ptp.c
index 7822809436a3..d966044e017a 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_ptp.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_ptp.c
@@ -57,7 +57,6 @@ void fm10k_ts_tx_enqueue(struct fm10k_intfc *interface, struct sk_buff *skb)
         struct sk_buff_head *list = &interface->ts_tx_skb_queue;
         struct sk_buff *clone;
         unsigned long flags;
-        __le16 dglort;
 
         /* create clone for us to return on the Tx path */
         clone = skb_clone_sk(skb);
@@ -65,8 +64,6 @@ void fm10k_ts_tx_enqueue(struct fm10k_intfc *interface, struct sk_buff *skb)
                 return;
 
         FM10K_CB(clone)->ts_tx_timeout = jiffies + FM10K_TS_TX_TIMEOUT;
-        dglort = FM10K_CB(clone)->fi.w.dglort;
-
         spin_lock_irqsave(&list->lock, flags);
 
         /* attempt to locate any buffers with the same dglort,
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_type.h b/drivers/net/ethernet/intel/fm10k/fm10k_type.h
index 280296f29154..7c6d9d5a8ae5 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_type.h
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_type.h
@@ -354,7 +354,7 @@ struct fm10k_hw;
 
 /* Define timeouts for resets and disables */
 #define FM10K_QUEUE_DISABLE_TIMEOUT             100
-#define FM10K_RESET_TIMEOUT                     100
+#define FM10K_RESET_TIMEOUT                     150
 
 /* VF registers */
 #define FM10K_VFCTRL            0x00000
diff --git a/drivers/net/ethernet/intel/i40e/i40e.h b/drivers/net/ethernet/intel/i40e/i40e.h
index fc50f6461b13..2b65cdcad6ba 100644
--- a/drivers/net/ethernet/intel/i40e/i40e.h
+++ b/drivers/net/ethernet/intel/i40e/i40e.h
@@ -87,11 +87,12 @@
 #define I40E_MINIMUM_FCOE             1 /* minimum number of QPs for FCoE */
 #endif /* I40E_FCOE */
 #define I40E_MAX_AQ_BUF_SIZE          4096
-#define I40E_AQ_LEN                   128
-#define I40E_AQ_WORK_LIMIT            16
+#define I40E_AQ_LEN                   256
+#define I40E_AQ_WORK_LIMIT            32
 #define I40E_MAX_USER_PRIORITY        8
 #define I40E_DEFAULT_MSG_ENABLE       4
 #define I40E_QUEUE_WAIT_RETRY_LIMIT   10
+#define I40E_INT_NAME_STR_LEN        (IFNAMSIZ + 9)
 
 #define I40E_NVM_VERSION_LO_SHIFT  0
 #define I40E_NVM_VERSION_LO_MASK   (0xff << I40E_NVM_VERSION_LO_SHIFT)
@@ -147,6 +148,7 @@ enum i40e_state_t {
         __I40E_FD_FLUSH_REQUESTED,
         __I40E_RESET_FAILED,
         __I40E_PORT_TX_SUSPENDED,
+        __I40E_VF_DISABLE,
 };
 
 enum i40e_interrupt_policy {
@@ -268,7 +270,7 @@ struct i40e_pf {
         u16 rx_itr_default;
         u16 tx_itr_default;
         u16 msg_enable;
-        char misc_int_name[IFNAMSIZ + 9];
+        char int_name[I40E_INT_NAME_STR_LEN];
         u16 adminq_work_limit; /* num of admin receive queue desc to process */
         unsigned long service_timer_period;
         unsigned long service_timer_previous;
@@ -524,7 +526,7 @@ struct i40e_q_vector {
 
         cpumask_t affinity_mask;
         struct rcu_head rcu;    /* to avoid race with update stats on free */
-        char name[IFNAMSIZ + 9];
+        char name[I40E_INT_NAME_STR_LEN];
 } ____cacheline_internodealigned_in_smp;
 
 /* lan device */
diff --git a/drivers/net/ethernet/intel/i40e/i40e_adminq.h b/drivers/net/ethernet/intel/i40e/i40e_adminq.h
index 564d0b0192f7..de17b6fbcc4e 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_adminq.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_adminq.h
@@ -148,7 +148,7 @@ static inline int i40e_aq_rc_to_posix(u32 aq_ret, u16 aq_rc)
 
 /* general information */
 #define I40E_AQ_LARGE_BUF       512
-#define I40E_ASQ_CMD_TIMEOUT    100  /* msecs */
+#define I40E_ASQ_CMD_TIMEOUT    250  /* msecs */
 
 void i40e_fill_default_direct_cmd_desc(struct i40e_aq_desc *desc,
                                        u16 opcode);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h b/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h
index 8835aeeff23e..929e3d72a01e 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h
@@ -256,6 +256,8 @@ enum i40e_admin_queue_opc {
         i40e_aqc_opc_lldp_stop          = 0x0A05,
         i40e_aqc_opc_lldp_start         = 0x0A06,
         i40e_aqc_opc_get_cee_dcb_cfg    = 0x0A07,
+        i40e_aqc_opc_lldp_set_local_mib = 0x0A08,
+        i40e_aqc_opc_lldp_stop_start_spec_agent = 0x0A09,
 
         /* Tunnel commands */
         i40e_aqc_opc_add_udp_tunnel     = 0x0B00,
@@ -268,6 +270,8 @@ enum i40e_admin_queue_opc {
         /* OEM commands */
         i40e_aqc_opc_oem_parameter_change       = 0xFE00,
         i40e_aqc_opc_oem_device_status_change   = 0xFE01,
+        i40e_aqc_opc_oem_ocsd_initialize        = 0xFE02,
+        i40e_aqc_opc_oem_ocbb_initialize        = 0xFE03,
 
         /* debug commands */
         i40e_aqc_opc_debug_get_deviceid         = 0xFF00,
@@ -276,7 +280,6 @@ enum i40e_admin_queue_opc {
         i40e_aqc_opc_debug_write_reg            = 0xFF04,
         i40e_aqc_opc_debug_modify_reg           = 0xFF07,
         i40e_aqc_opc_debug_dump_internals       = 0xFF08,
-        i40e_aqc_opc_debug_modify_internals     = 0xFF09,
 };
 
 /* command structures and indirect data structures */
@@ -410,6 +413,7 @@ struct i40e_aqc_list_capabilities_element_resp {
 #define I40E_AQ_CAP_ID_VSI              0x0017
 #define I40E_AQ_CAP_ID_DCB              0x0018
 #define I40E_AQ_CAP_ID_FCOE             0x0021
+#define I40E_AQ_CAP_ID_ISCSI            0x0022
 #define I40E_AQ_CAP_ID_RSS              0x0040
 #define I40E_AQ_CAP_ID_RXQ              0x0041
 #define I40E_AQ_CAP_ID_TXQ              0x0042
@@ -454,8 +458,11 @@ struct i40e_aqc_arp_proxy_data {
         __le32  pfpm_proxyfc;
         __le32  ip_addr;
         u8      mac_addr[6];
+        u8      reserved[2];
 };
 
+I40E_CHECK_STRUCT_LEN(0x14, i40e_aqc_arp_proxy_data);
+
 /* Set NS Proxy Table Entry Command (indirect 0x0105) */
 struct i40e_aqc_ns_proxy_data {
         __le16  table_idx_mac_addr_0;
@@ -481,6 +488,8 @@ struct i40e_aqc_ns_proxy_data {
         u8      ipv6_addr_1[16];
 };
 
+I40E_CHECK_STRUCT_LEN(0x3c, i40e_aqc_ns_proxy_data);
+
 /* Manage LAA Command (0x0106) - obsolete */
 struct i40e_aqc_mng_laa {
         __le16  command_flags;
@@ -491,6 +500,8 @@ struct i40e_aqc_mng_laa {
         u8      reserved2[6];
 };
 
+I40E_CHECK_CMD_LENGTH(i40e_aqc_mng_laa);
+
 /* Manage MAC Address Read Command (indirect 0x0107) */
 struct i40e_aqc_mac_address_read {
         __le16  command_flags;
@@ -562,6 +573,8 @@ struct i40e_aqc_get_switch_config_header_resp {
         u8      reserved[12];
 };
 
+I40E_CHECK_CMD_LENGTH(i40e_aqc_get_switch_config_header_resp);
+
 struct i40e_aqc_switch_config_element_resp {
         u8      element_type;
 #define I40E_AQ_SW_ELEM_TYPE_MAC        1
@@ -587,6 +600,8 @@ struct i40e_aqc_switch_config_element_resp {
         __le16  element_info;
 };
 
+I40E_CHECK_STRUCT_LEN(0x10, i40e_aqc_switch_config_element_resp);
+
 /* Get Switch Configuration (indirect 0x0200)
  *    an array of elements are returned in the response buffer
  *    the first in the array is the header, remainder are elements
@@ -596,6 +611,8 @@ struct i40e_aqc_get_switch_config_resp {
         struct i40e_aqc_switch_config_element_resp      element[1];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_get_switch_config_resp);
+
 /* Add Statistics (direct 0x0201)
  * Remove Statistics (direct 0x0202)
  */
@@ -661,6 +678,8 @@ struct i40e_aqc_switch_resource_alloc_element_resp {
         u8      reserved2[6];
 };
 
+I40E_CHECK_STRUCT_LEN(0x10, i40e_aqc_switch_resource_alloc_element_resp);
+
 /* Add VSI (indirect 0x0210)
  *    this indirect command uses struct i40e_aqc_vsi_properties_data
  *    as the indirect buffer (128 bytes)
@@ -1092,6 +1111,8 @@ struct i40e_aqc_remove_tag {
         u8      reserved[12];
 };
 
+I40E_CHECK_CMD_LENGTH(i40e_aqc_remove_tag);
+
 /* Add multicast E-Tag (direct 0x0257)
  * del multicast E-Tag (direct 0x0258) only uses pv_seid and etag fields
  * and no external data
@@ -1207,7 +1228,7 @@ struct i40e_aqc_add_remove_cloud_filters_element_data {
         } ipaddr;
         __le16  flags;
 #define I40E_AQC_ADD_CLOUD_FILTER_SHIFT                 0
-#define I40E_AQC_ADD_CLOUD_FILTER_MASK                  (0x3F << \
+#define I40E_AQC_ADD_CLOUD_FILTER_MASK  (0x3F << \
                                         I40E_AQC_ADD_CLOUD_FILTER_SHIFT)
 /* 0x0000 reserved */
 #define I40E_AQC_ADD_CLOUD_FILTER_OIP                   0x0001
@@ -1240,7 +1261,7 @@ struct i40e_aqc_add_remove_cloud_filters_element_data {
         u8      reserved[4];
         __le16  queue_number;
 #define I40E_AQC_ADD_CLOUD_QUEUE_SHIFT          0
-#define I40E_AQC_ADD_CLOUD_QUEUE_MASK           (0x3F << \
+#define I40E_AQC_ADD_CLOUD_QUEUE_MASK           (0x7FF << \
                                                  I40E_AQC_ADD_CLOUD_QUEUE_SHIFT)
         u8      reserved2[14];
         /* response section */
@@ -1359,6 +1380,8 @@ struct i40e_aqc_configure_vsi_ets_sla_bw_data {
         u8      reserved1[28];
 };
 
+I40E_CHECK_STRUCT_LEN(0x40, i40e_aqc_configure_vsi_ets_sla_bw_data);
+
 /* Configure VSI Bandwidth Allocation per Traffic Type (indirect 0x0407)
  *    responds with i40e_aqc_qs_handles_resp
  */
@@ -1370,6 +1393,8 @@ struct i40e_aqc_configure_vsi_tc_bw_data {
         __le16  qs_handles[8];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_configure_vsi_tc_bw_data);
+
 /* Query vsi bw configuration (indirect 0x0408) */
 struct i40e_aqc_query_vsi_bw_config_resp {
         u8      tc_valid_bits;
@@ -1383,6 +1408,8 @@ struct i40e_aqc_query_vsi_bw_config_resp {
         u8      reserved3[23];
 };
 
+I40E_CHECK_STRUCT_LEN(0x40, i40e_aqc_query_vsi_bw_config_resp);
+
 /* Query VSI Bandwidth Allocation per Traffic Type (indirect 0x040A) */
 struct i40e_aqc_query_vsi_ets_sla_config_resp {
         u8      tc_valid_bits;
@@ -1394,6 +1421,8 @@ struct i40e_aqc_query_vsi_ets_sla_config_resp {
         __le16  tc_bw_max[2];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_query_vsi_ets_sla_config_resp);
+
 /* Configure Switching Component Bandwidth Limit (direct 0x0410) */
 struct i40e_aqc_configure_switching_comp_bw_limit {
         __le16  seid;
@@ -1421,6 +1450,8 @@ struct i40e_aqc_configure_switching_comp_ets_data {
         u8      reserved2[96];
 };
 
+I40E_CHECK_STRUCT_LEN(0x80, i40e_aqc_configure_switching_comp_ets_data);
+
 /* Configure Switching Component Bandwidth Limits per Tc (indirect 0x0416) */
 struct i40e_aqc_configure_switching_comp_ets_bw_limit_data {
         u8      tc_valid_bits;
@@ -1432,6 +1463,9 @@ struct i40e_aqc_configure_switching_comp_ets_bw_limit_data {
         u8      reserved1[28];
 };
 
+I40E_CHECK_STRUCT_LEN(0x40,
+                      i40e_aqc_configure_switching_comp_ets_bw_limit_data);
+
 /* Configure Switching Component Bandwidth Allocation per Tc
  * (indirect 0x0417)
  */
@@ -1443,6 +1477,8 @@ struct i40e_aqc_configure_switching_comp_bw_config_data {
         u8      reserved1[20];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_configure_switching_comp_bw_config_data);
+
 /* Query Switching Component Configuration (indirect 0x0418) */
 struct i40e_aqc_query_switching_comp_ets_config_resp {
         u8      tc_valid_bits;
@@ -1453,6 +1489,8 @@ struct i40e_aqc_query_switching_comp_ets_config_resp {
         u8      reserved2[23];
 };
 
+I40E_CHECK_STRUCT_LEN(0x40, i40e_aqc_query_switching_comp_ets_config_resp);
+
 /* Query PhysicalPort ETS Configuration (indirect 0x0419) */
 struct i40e_aqc_query_port_ets_config_resp {
         u8      reserved[4];
@@ -1468,6 +1506,8 @@ struct i40e_aqc_query_port_ets_config_resp {
         u8      reserved3[32];
 };
 
+I40E_CHECK_STRUCT_LEN(0x44, i40e_aqc_query_port_ets_config_resp);
+
 /* Query Switching Component Bandwidth Allocation per Traffic Type
  * (indirect 0x041A)
  */
@@ -1482,6 +1522,8 @@ struct i40e_aqc_query_switching_comp_bw_config_resp {
         __le16  tc_bw_max[2];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_query_switching_comp_bw_config_resp);
+
 /* Suspend/resume port TX traffic
  * (direct 0x041B and 0x041C) uses the generic SEID struct
  */
@@ -1495,6 +1537,8 @@ struct i40e_aqc_configure_partition_bw_data {
         u8      max_bw[16];      /* bandwidth limit */
 };
 
+I40E_CHECK_STRUCT_LEN(0x22, i40e_aqc_configure_partition_bw_data);
+
 /* Get and set the active HMC resource profile and status.
  * (direct 0x0500) and (direct 0x0501)
  */
@@ -1577,6 +1621,8 @@ struct i40e_aqc_module_desc {
         u8 reserved2[8];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_module_desc);
+
 struct i40e_aq_get_phy_abilities_resp {
         __le32  phy_type;       /* bitmap using the above enum for offsets */
         u8      link_speed;     /* bitmap using the above enum bit patterns */
@@ -1605,6 +1651,8 @@ struct i40e_aq_get_phy_abilities_resp {
         struct i40e_aqc_module_desc     qualified_module[I40E_AQ_PHY_MAX_QMS];
 };
 
+I40E_CHECK_STRUCT_LEN(0x218, i40e_aq_get_phy_abilities_resp);
+
 /* Set PHY Config (direct 0x0601) */
 struct i40e_aq_set_phy_config { /* same bits as above in all */
         __le32  phy_type;
@@ -1788,12 +1836,12 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_update);
 /* NVM Config Read (indirect 0x0704) */
 struct i40e_aqc_nvm_config_read {
         __le16  cmd_flags;
-#define ANVM_SINGLE_OR_MULTIPLE_FEATURES_MASK   1
-#define ANVM_READ_SINGLE_FEATURE                0
-#define ANVM_READ_MULTIPLE_FEATURES             1
+#define I40E_AQ_ANVM_SINGLE_OR_MULTIPLE_FEATURES_MASK   1 
+#define I40E_AQ_ANVM_READ_SINGLE_FEATURE                0 
+#define I40E_AQ_ANVM_READ_MULTIPLE_FEATURES             1
         __le16  element_count;
-        __le16  element_id; /* Feature/field ID */
-        u8      reserved[2];
+        __le16  element_id;     /* Feature/field ID */
+        __le16  element_id_msw; /* MSWord of field ID */
         __le32  address_high;
         __le32  address_low;
 };
@@ -1811,21 +1859,32 @@ struct i40e_aqc_nvm_config_write {
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_config_write);
 
+/* Used for 0x0704 as well as for 0x0705 commands */
+#define I40E_AQ_ANVM_FEATURE_OR_IMMEDIATE_SHIFT         1
+#define I40E_AQ_ANVM_FEATURE_OR_IMMEDIATE_MASK \
+                                (1 << I40E_AQ_ANVM_FEATURE_OR_IMMEDIATE_SHIFT)
+#define I40E_AQ_ANVM_FEATURE            0
+#define I40E_AQ_ANVM_IMMEDIATE_FIELD    (1 << FEATURE_OR_IMMEDIATE_SHIFT)
 struct i40e_aqc_nvm_config_data_feature {
         __le16 feature_id;
-        __le16 instance_id;
+#define I40E_AQ_ANVM_FEATURE_OPTION_OEM_ONLY            0x01
+#define I40E_AQ_ANVM_FEATURE_OPTION_DWORD_MAP           0x08
+#define I40E_AQ_ANVM_FEATURE_OPTION_POR_CSR             0x10
         __le16 feature_options;
         __le16 feature_selection;
 };
 
+I40E_CHECK_STRUCT_LEN(0x6, i40e_aqc_nvm_config_data_feature);
+
 struct i40e_aqc_nvm_config_data_immediate_field {
-#define ANVM_FEATURE_OR_IMMEDIATE_MASK  0x2
-        __le16 field_id;
-        __le16 instance_id;
+        __le32 field_id;
+        __le32 field_value;
         __le16 field_options;
-        __le16 field_value;
+        __le16 reserved;
 };
 
+I40E_CHECK_STRUCT_LEN(0xc, i40e_aqc_nvm_config_data_immediate_field);
+
 /* Send to PF command (indirect 0x0801) id is only used by PF
  * Send to VF command (indirect 0x0802) id is only used by PF
  * Send to Peer PF command (indirect 0x0803)
@@ -2026,12 +2085,54 @@ struct i40e_aqc_get_cee_dcb_cfg_resp {
         u8      oper_tc_bw[8];
         u8      oper_pfc_en;
         __le16  oper_app_prio;
+#define I40E_AQC_CEE_APP_FCOE_SHIFT     0x0
+#define I40E_AQC_CEE_APP_FCOE_MASK      (0x7 << I40E_AQC_CEE_APP_FCOE_SHIFT)
+#define I40E_AQC_CEE_APP_ISCSI_SHIFT    0x3
+#define I40E_AQC_CEE_APP_ISCSI_MASK     (0x7 << I40E_AQC_CEE_APP_ISCSI_SHIFT)
+#define I40E_AQC_CEE_APP_FIP_SHIFT      0x8
+#define I40E_AQC_CEE_APP_FIP_MASK       (0x7 << I40E_AQC_CEE_APP_FIP_SHIFT)
+#define I40E_AQC_CEE_APP_FIP_MASK       (0x7 << I40E_AQC_CEE_APP_FIP_SHIFT)
         __le32  tlv_status;
+#define I40E_AQC_CEE_PG_STATUS_SHIFT    0x0
+#define I40E_AQC_CEE_PG_STATUS_MASK     (0x7 << I40E_AQC_CEE_PG_STATUS_SHIFT)
+#define I40E_AQC_CEE_PFC_STATUS_SHIFT   0x3
+#define I40E_AQC_CEE_PFC_STATUS_MASK    (0x7 << I40E_AQC_CEE_PFC_STATUS_SHIFT)
+#define I40E_AQC_CEE_APP_STATUS_SHIFT   0x8
+#define I40E_AQC_CEE_APP_STATUS_MASK    (0x7 << I40E_AQC_CEE_APP_STATUS_SHIFT)
         u8      reserved[12];
 };
 
 I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_get_cee_dcb_cfg_resp);
 
+/*      Set Local LLDP MIB (indirect 0x0A08)
+ *      Used to replace the local MIB of a given LLDP agent. e.g. DCBx
+ */
+struct i40e_aqc_lldp_set_local_mib {
+#define SET_LOCAL_MIB_AC_TYPE_DCBX_SHIFT        0
+#define SET_LOCAL_MIB_AC_TYPE_DCBX_MASK (1 << SET_LOCAL_MIB_AC_TYPE_DCBX_SHIFT)
+        u8      type;
+        u8      reserved0;
+        __le16  length;
+        u8      reserved1[4];
+        __le32  address_high;
+        __le32  address_low;
+};
+
+I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_set_local_mib);
+
+/*      Stop/Start LLDP Agent (direct 0x0A09)
+ *      Used for stopping/starting specific LLDP agent. e.g. DCBx
+ */
+struct i40e_aqc_lldp_stop_start_specific_agent {
+#define I40E_AQC_START_SPECIFIC_AGENT_SHIFT     0
+#define I40E_AQC_START_SPECIFIC_AGENT_MASK \
+                                (1 << I40E_AQC_START_SPECIFIC_AGENT_SHIFT)
+        u8      command;
+        u8      reserved[15];
+};
+
+I40E_CHECK_CMD_LENGTH(i40e_aqc_lldp_stop_start_specific_agent);
+
 /* Add Udp Tunnel command and completion (direct 0x0B00) */
 struct i40e_aqc_add_udp_tunnel {
         __le16  udp_port;
@@ -2106,7 +2207,8 @@ struct i40e_aqc_oem_param_change {
 #define I40E_AQ_OEM_PARAM_TYPE_BW_CTL   1
 #define I40E_AQ_OEM_PARAM_MAC           2
         __le32  param_value1;
-        u8      param_value2[8];
+        __le16  param_value2;
+        u8      reserved[6];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_param_change);
@@ -2120,6 +2222,28 @@ struct i40e_aqc_oem_state_change {
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_state_change);
 
+/* Initialize OCSD (0xFE02, direct) */
+struct i40e_aqc_opc_oem_ocsd_initialize {
+        u8 type_status;
+        u8 reserved1[3];
+        __le32 ocsd_memory_block_addr_high;
+        __le32 ocsd_memory_block_addr_low;
+        __le32 requested_update_interval;
+};
+
+I40E_CHECK_CMD_LENGTH(i40e_aqc_opc_oem_ocsd_initialize);
+
+/* Initialize OCBB  (0xFE03, direct) */
+struct i40e_aqc_opc_oem_ocbb_initialize {
+        u8 type_status;
+        u8 reserved1[3];
+        __le32 ocbb_memory_block_addr_high;
+        __le32 ocbb_memory_block_addr_low;
+        u8 reserved2[4];
+};
+
+I40E_CHECK_CMD_LENGTH(i40e_aqc_opc_oem_ocbb_initialize);
+
 /* debug commands */
 
 /* get device id (0xFF00) uses the generic structure */
diff --git a/drivers/net/ethernet/intel/i40e/i40e_common.c b/drivers/net/ethernet/intel/i40e/i40e_common.c
index 3d741ee99a2c..11a9ffebf8d8 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_common.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_common.c
@@ -742,6 +742,65 @@ i40e_status i40e_get_san_mac_addr(struct i40e_hw *hw, u8 *mac_addr)
 #endif
 
 /**
+ *  i40e_read_pba_string - Reads part number string from EEPROM
+ *  @hw: pointer to hardware structure
+ *  @pba_num: stores the part number string from the EEPROM
+ *  @pba_num_size: part number string buffer length
+ *
+ *  Reads the part number string from the EEPROM.
+ **/
+i40e_status i40e_read_pba_string(struct i40e_hw *hw, u8 *pba_num,
+                                 u32 pba_num_size)
+{
+        i40e_status status = 0;
+        u16 pba_word = 0;
+        u16 pba_size = 0;
+        u16 pba_ptr = 0;
+        u16 i = 0;
+
+        status = i40e_read_nvm_word(hw, I40E_SR_PBA_FLAGS, &pba_word);
+        if (status || (pba_word != 0xFAFA)) {
+                hw_dbg(hw, "Failed to read PBA flags or flag is invalid.\n");
+                return status;
+        }
+
+        status = i40e_read_nvm_word(hw, I40E_SR_PBA_BLOCK_PTR, &pba_ptr);
+        if (status) {
+                hw_dbg(hw, "Failed to read PBA Block pointer.\n");
+                return status;
+        }
+
+        status = i40e_read_nvm_word(hw, pba_ptr, &pba_size);
+        if (status) {
+                hw_dbg(hw, "Failed to read PBA Block size.\n");
+                return status;
+        }
+
+        /* Subtract one to get PBA word count (PBA Size word is included in
+         * total size)
+         */
+        pba_size--;
+        if (pba_num_size < (((u32)pba_size * 2) + 1)) {
+                hw_dbg(hw, "Buffer to small for PBA data.\n");
+                return I40E_ERR_PARAM;
+        }
+
+        for (i = 0; i < pba_size; i++) {
+                status = i40e_read_nvm_word(hw, (pba_ptr + 1) + i, &pba_word);
+                if (status) {
+                        hw_dbg(hw, "Failed to read PBA Block word %d.\n", i);
+                        return status;
+                }
+
+                pba_num[(i * 2)] = (pba_word >> 8) & 0xFF;
+                pba_num[(i * 2) + 1] = pba_word & 0xFF;
+        }
+        pba_num[(pba_size * 2)] = '\0';
+
+        return status;
+}
+
+/**
  * i40e_get_media_type - Gets media type
  * @hw: pointer to the hardware structure
  **/
@@ -1083,8 +1142,10 @@ void i40e_led_set(struct i40e_hw *hw, u32 mode, bool blink)
                 if (mode == I40E_LINK_ACTIVITY)
                         blink = false;
 
-                gpio_val |= (blink ? 1 : 0) <<
-                            I40E_GLGEN_GPIO_CTL_LED_BLINK_SHIFT;
+                if (blink)
+                        gpio_val |= (1 << I40E_GLGEN_GPIO_CTL_LED_BLINK_SHIFT);
+                else
+                        gpio_val &= ~(1 << I40E_GLGEN_GPIO_CTL_LED_BLINK_SHIFT);
 
                 wr32(hw, I40E_GLGEN_GPIO_CTL(i), gpio_val);
                 break;
@@ -2035,6 +2096,43 @@ i40e_status i40e_aq_send_msg_to_vf(struct i40e_hw *hw, u16 vfid,
 }
 
 /**
+ * i40e_aq_debug_read_register
+ * @hw: pointer to the hw struct
+ * @reg_addr: register address
+ * @reg_val: register value
+ * @cmd_details: pointer to command details structure or NULL
+ *
+ * Read the register using the admin queue commands
+ **/
+i40e_status i40e_aq_debug_read_register(struct i40e_hw *hw,
+                                u32  reg_addr, u64 *reg_val,
+                                struct i40e_asq_cmd_details *cmd_details)
+{
+        struct i40e_aq_desc desc;
+        struct i40e_aqc_debug_reg_read_write *cmd_resp =
+                (struct i40e_aqc_debug_reg_read_write *)&desc.params.raw;
+        i40e_status status;
+
+        if (reg_val == NULL)
+                return I40E_ERR_PARAM;
+
+        i40e_fill_default_direct_cmd_desc(&desc,
+                                          i40e_aqc_opc_debug_read_reg);
+
+        cmd_resp->address = cpu_to_le32(reg_addr);
+
+        status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
+
+        if (!status) {
+                *reg_val = ((u64)cmd_resp->value_high << 32) |
+                            (u64)cmd_resp->value_low;
+                *reg_val = le64_to_cpu(*reg_val);
+        }
+
+        return status;
+}
+
+/**
  * i40e_aq_debug_write_register
  * @hw: pointer to the hw struct
  * @reg_addr: register address
@@ -2264,6 +2362,7 @@ i40e_aq_erase_nvm_exit:
 #define I40E_DEV_FUNC_CAP_VSI           0x17
 #define I40E_DEV_FUNC_CAP_DCB           0x18
 #define I40E_DEV_FUNC_CAP_FCOE          0x21
+#define I40E_DEV_FUNC_CAP_ISCSI         0x22
 #define I40E_DEV_FUNC_CAP_RSS           0x40
 #define I40E_DEV_FUNC_CAP_RX_QUEUES     0x41
 #define I40E_DEV_FUNC_CAP_TX_QUEUES     0x42
@@ -2292,6 +2391,7 @@ static void i40e_parse_discover_capabilities(struct i40e_hw *hw, void *buff,
                                      enum i40e_admin_queue_opc list_type_opc)
 {
         struct i40e_aqc_list_capabilities_element_resp *cap;
+        u32 valid_functions, num_functions;
         u32 number, logical_id, phys_id;
         struct i40e_hw_capabilities *p;
         u32 i = 0;
@@ -2362,6 +2462,10 @@ static void i40e_parse_discover_capabilities(struct i40e_hw *hw, void *buff,
                         if (number == 1)
                                 p->fcoe = true;
                         break;
+                case I40E_DEV_FUNC_CAP_ISCSI:
+                        if (number == 1)
+                                p->iscsi = true;
+                        break;
                 case I40E_DEV_FUNC_CAP_RSS:
                         p->rss = true;
                         p->rss_table_size = number;
@@ -2427,6 +2531,34 @@ static void i40e_parse_discover_capabilities(struct i40e_hw *hw, void *buff,
         if (p->npar_enable || p->mfp_mode_1)
                 p->fcoe = false;
 
+        /* count the enabled ports (aka the "not disabled" ports) */
+        hw->num_ports = 0;
+        for (i = 0; i < 4; i++) {
+                u32 port_cfg_reg = I40E_PRTGEN_CNF + (4 * i);
+                u64 port_cfg = 0;
+
+                /* use AQ read to get the physical register offset instead
+                 * of the port relative offset
+                 */
+                i40e_aq_debug_read_register(hw, port_cfg_reg, &port_cfg, NULL);
+                if (!(port_cfg & I40E_PRTGEN_CNF_PORT_DIS_MASK))
+                        hw->num_ports++;
+        }
+
+        valid_functions = p->valid_functions;
+        num_functions = 0;
+        while (valid_functions) {
+                if (valid_functions & 1)
+                        num_functions++;
+                valid_functions >>= 1;
+        }
+
+        /* partition id is 1-based, and functions are evenly spread
+         * across the ports as partitions
+         */
+        hw->partition_id = (hw->pf_id / hw->num_ports) + 1;
+        hw->num_partitions = num_functions / hw->num_ports;
+
         /* additional HW specific goodies that might
          * someday be HW version specific
          */
diff --git a/drivers/net/ethernet/intel/i40e/i40e_debugfs.c b/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
index cb0de455683e..61236f983971 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
@@ -1890,7 +1890,6 @@ static ssize_t i40e_dbg_command_write(struct file *filp,
                 dev_info(&pf->pdev->dev, "  dump desc tx <vsi_seid> <ring_id> [<desc_n>]\n");
                 dev_info(&pf->pdev->dev, "  dump desc rx <vsi_seid> <ring_id> [<desc_n>]\n");
                 dev_info(&pf->pdev->dev, "  dump desc aq\n");
-                dev_info(&pf->pdev->dev, "  dump stats\n");
                 dev_info(&pf->pdev->dev, "  dump reset stats\n");
                 dev_info(&pf->pdev->dev, "  msg_enable [level]\n");
                 dev_info(&pf->pdev->dev, "  read <reg>\n");
diff --git a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
index 951e8767fc50..b8230dc205ec 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
@@ -219,6 +219,16 @@ static const char i40e_gstrings_test[][ETH_GSTRING_LEN] = {
 #define I40E_TEST_LEN (sizeof(i40e_gstrings_test) / ETH_GSTRING_LEN)
 
 /**
+ * i40e_partition_setting_complaint - generic complaint for MFP restriction
+ * @pf: the PF struct
+ **/
+static void i40e_partition_setting_complaint(struct i40e_pf *pf)
+{
+        dev_info(&pf->pdev->dev,
+                 "The link settings are allowed to be changed only from the first partition of a given port. Please switch to the first partition in order to change the setting.\n");
+}
+
+/**
  * i40e_get_settings - Get Link Speed and Duplex settings
  * @netdev: network interface device structure
  * @ecmd: ethtool command
@@ -485,6 +495,14 @@ static int i40e_set_settings(struct net_device *netdev,
         u8 autoneg;
         u32 advertise;
 
+        /* Changing port settings is not supported if this isn't the
+         * port's controlling PF
+         */
+        if (hw->partition_id != 1) {
+                i40e_partition_setting_complaint(pf);
+                return -EOPNOTSUPP;
+        }
+
         if (vsi != pf->vsi[pf->lan_vsi])
                 return -EOPNOTSUPP;
 
@@ -687,6 +705,14 @@ static int i40e_set_pauseparam(struct net_device *netdev,
         u8 aq_failures;
         int err = 0;
 
+        /* Changing the port's flow control is not supported if this isn't the
+         * port's controlling PF
+         */
+        if (hw->partition_id != 1) {
+                i40e_partition_setting_complaint(pf);
+                return -EOPNOTSUPP;
+        }
+
         if (vsi != pf->vsi[pf->lan_vsi])
                 return -EOPNOTSUPP;
 
@@ -1503,7 +1529,7 @@ static void i40e_get_wol(struct net_device *netdev,
 
         /* NVM bit on means WoL disabled for the port */
         i40e_read_nvm_word(hw, I40E_SR_NVM_WAKE_ON_LAN, &wol_nvm_bits);
-        if ((1 << hw->port) & wol_nvm_bits) {
+        if ((1 << hw->port) & wol_nvm_bits || hw->partition_id != 1) {
                 wol->supported = 0;
                 wol->wolopts = 0;
         } else {
@@ -1512,13 +1538,28 @@ static void i40e_get_wol(struct net_device *netdev,
         }
 }
 
+/**
+ * i40e_set_wol - set the WakeOnLAN configuration
+ * @netdev: the netdev in question
+ * @wol: the ethtool WoL setting data
+ **/
 static int i40e_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
 {
         struct i40e_netdev_priv *np = netdev_priv(netdev);
         struct i40e_pf *pf = np->vsi->back;
+        struct i40e_vsi *vsi = np->vsi;
         struct i40e_hw *hw = &pf->hw;
         u16 wol_nvm_bits;
 
+        /* WoL not supported if this isn't the controlling PF on the port */
+        if (hw->partition_id != 1) {
+                i40e_partition_setting_complaint(pf);
+                return -EOPNOTSUPP;
+        }
+
+        if (vsi != pf->vsi[pf->lan_vsi])
+                return -EOPNOTSUPP;
+
         /* NVM bit on means WoL disabled for the port */
         i40e_read_nvm_word(hw, I40E_SR_NVM_WAKE_ON_LAN, &wol_nvm_bits);
         if (((1 << hw->port) & wol_nvm_bits))
diff --git a/drivers/net/ethernet/intel/i40e/i40e_fcoe.c b/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
index a8b8bd95108d..27c206e62da7 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
@@ -39,15 +39,6 @@
 #include "i40e_fcoe.h"
 
 /**
- * i40e_rx_is_fip - returns true if the rx packet type is FIP
- * @ptype: the packet type field from rx descriptor write-back
- **/
-static inline bool i40e_rx_is_fip(u16 ptype)
-{
-        return ptype == I40E_RX_PTYPE_L2_FIP_PAY2;
-}
-
-/**
  * i40e_rx_is_fcoe - returns true if the rx packet type is FCoE
  * @ptype: the packet type field from rx descriptor write-back
  **/
@@ -404,6 +395,7 @@ int i40e_fcoe_vsi_init(struct i40e_vsi *vsi, struct i40e_vsi_context *ctxt)
                                             I40E_AQ_VSI_PROP_INGRESS_UP_VALID |
                                             I40E_AQ_VSI_PROP_EGRESS_UP_VALID));
 
+        info->switch_id = cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
         enabled_tc = i40e_get_fcoe_tc_map(pf);
         i40e_vsi_setup_queue_map(vsi, ctxt, enabled_tc, true);
 
@@ -1511,12 +1503,16 @@ void i40e_fcoe_config_netdev(struct net_device *netdev, struct i40e_vsi *vsi)
         strlcpy(netdev->name, "fcoe%d", IFNAMSIZ-1);
         netdev->mtu = FCOE_MTU;
         SET_NETDEV_DEV(netdev, &pf->pdev->dev);
+        /* set different dev_port value 1 for FCoE netdev than the default
+         * zero dev_port value for PF netdev, this helps biosdevname user
+         * tool to differentiate them correctly while both attached to the
+         * same PCI function.
+         */
+        netdev->dev_port = 1;
         i40e_add_filter(vsi, hw->mac.san_addr, 0, false, false);
         i40e_add_filter(vsi, (u8[6]) FC_FCOE_FLOGI_MAC, 0, false, false);
         i40e_add_filter(vsi, FIP_ALL_FCOE_MACS, 0, false, false);
         i40e_add_filter(vsi, FIP_ALL_ENODE_MACS, 0, false, false);
-        i40e_add_filter(vsi, FIP_ALL_VN2VN_MACS, 0, false, false);
-        i40e_add_filter(vsi, FIP_ALL_P2P_MACS, 0, false, false);
 
         /* use san mac */
         ether_addr_copy(netdev->dev_addr, hw->mac.san_addr);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index a5f2660d552d..cbe281be1c9f 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -39,7 +39,7 @@ static const char i40e_driver_string[] =
 
 #define DRV_VERSION_MAJOR 1
 #define DRV_VERSION_MINOR 2
-#define DRV_VERSION_BUILD 2
+#define DRV_VERSION_BUILD 6
 #define DRV_VERSION __stringify(DRV_VERSION_MAJOR) "." \
              __stringify(DRV_VERSION_MINOR) "." \
              __stringify(DRV_VERSION_BUILD)    DRV_KERN
@@ -2819,8 +2819,9 @@ static void i40e_vsi_configure_msix(struct i40e_vsi *vsi)
  * i40e_enable_misc_int_causes - enable the non-queue interrupts
  * @hw: ptr to the hardware info
  **/
-static void i40e_enable_misc_int_causes(struct i40e_hw *hw)
+static void i40e_enable_misc_int_causes(struct i40e_pf *pf)
 {
+        struct i40e_hw *hw = &pf->hw;
         u32 val;
 
         /* clear things first */
@@ -2832,11 +2833,13 @@ static void i40e_enable_misc_int_causes(struct i40e_hw *hw)
               I40E_PFINT_ICR0_ENA_GRST_MASK          |
               I40E_PFINT_ICR0_ENA_PCI_EXCEPTION_MASK |
               I40E_PFINT_ICR0_ENA_GPIO_MASK          |
-              I40E_PFINT_ICR0_ENA_TIMESYNC_MASK      |
               I40E_PFINT_ICR0_ENA_HMC_ERR_MASK       |
               I40E_PFINT_ICR0_ENA_VFLR_MASK          |
               I40E_PFINT_ICR0_ENA_ADMINQ_MASK;
 
+        if (pf->flags & I40E_FLAG_PTP)
+                val |= I40E_PFINT_ICR0_ENA_TIMESYNC_MASK;
+
         wr32(hw, I40E_PFINT_ICR0_ENA, val);
 
         /* SW_ITR_IDX = 0, but don't change INTENA */
@@ -2866,7 +2869,7 @@ static void i40e_configure_msi_and_legacy(struct i40e_vsi *vsi)
         q_vector->tx.latency_range = I40E_LOW_LATENCY;
         wr32(hw, I40E_PFINT_ITR0(I40E_TX_ITR), q_vector->tx.itr);
 
-        i40e_enable_misc_int_causes(hw);
+        i40e_enable_misc_int_causes(pf);
 
         /* FIRSTQ_INDX = 0, FIRSTQ_TYPE = 0 (rx) */
         wr32(hw, I40E_PFINT_LNKLST0, 0);
@@ -2937,7 +2940,7 @@ void i40e_irq_dynamic_enable(struct i40e_vsi *vsi, int vector)
 /**
  * i40e_irq_dynamic_disable - Disable default interrupt generation settings
  * @vsi: pointer to a vsi
- * @vector: enable a particular Hw Interrupt vector
+ * @vector: disable a particular Hw Interrupt vector
  **/
 void i40e_irq_dynamic_disable(struct i40e_vsi *vsi, int vector)
 {
@@ -3402,10 +3405,10 @@ static int i40e_vsi_request_irq(struct i40e_vsi *vsi, char *basename)
                 err = i40e_vsi_request_irq_msix(vsi, basename);
         else if (pf->flags & I40E_FLAG_MSI_ENABLED)
                 err = request_irq(pf->pdev->irq, i40e_intr, 0,
-                                  pf->misc_int_name, pf);
+                                  pf->int_name, pf);
         else
                 err = request_irq(pf->pdev->irq, i40e_intr, IRQF_SHARED,
-                                  pf->misc_int_name, pf);
+                                  pf->int_name, pf);
 
         if (err)
                 dev_info(&pf->pdev->dev, "request_irq failed, Error %d\n", err);
@@ -3999,6 +4002,35 @@ static int i40e_pf_wait_txq_disabled(struct i40e_pf *pf)
 
 #endif
 /**
+ * i40e_get_iscsi_tc_map - Return TC map for iSCSI APP
+ * @pf: pointer to pf
+ *
+ * Get TC map for ISCSI PF type that will include iSCSI TC
+ * and LAN TC.
+ **/
+static u8 i40e_get_iscsi_tc_map(struct i40e_pf *pf)
+{
+        struct i40e_dcb_app_priority_table app;
+        struct i40e_hw *hw = &pf->hw;
+        u8 enabled_tc = 1; /* TC0 is always enabled */
+        u8 tc, i;
+        /* Get the iSCSI APP TLV */
+        struct i40e_dcbx_config *dcbcfg = &hw->local_dcbx_config;
+
+        for (i = 0; i < dcbcfg->numapps; i++) {
+                app = dcbcfg->app[i];
+                if (app.selector == I40E_APP_SEL_TCPIP &&
+                    app.protocolid == I40E_APP_PROTOID_ISCSI) {
+                        tc = dcbcfg->etscfg.prioritytable[app.priority];
+                        enabled_tc |= (1 << tc);
+                        break;
+                }
+        }
+
+        return enabled_tc;
+}
+
+/**
  * i40e_dcb_get_num_tc -  Get the number of TCs from DCBx config
  * @dcbcfg: the corresponding DCBx configuration structure
  *
@@ -4061,18 +4093,23 @@ static u8 i40e_pf_get_num_tc(struct i40e_pf *pf)
         if (!(pf->flags & I40E_FLAG_DCB_ENABLED))
                 return 1;
 
+        /* SFP mode will be enabled for all TCs on port */
+        if (!(pf->flags & I40E_FLAG_MFP_ENABLED))
+                return i40e_dcb_get_num_tc(dcbcfg);
+
         /* MFP mode return count of enabled TCs for this PF */
-        if (pf->flags & I40E_FLAG_MFP_ENABLED) {
+        if (pf->hw.func_caps.iscsi)
+                enabled_tc =  i40e_get_iscsi_tc_map(pf);
+        else
                 enabled_tc = pf->hw.func_caps.enabled_tcmap;
-                for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++) {
-                        if (enabled_tc & (1 << i))
-                                num_tc++;
-                }
-                return num_tc;
-        }
 
-        /* SFP mode will be enabled for all TCs on port */
-        return i40e_dcb_get_num_tc(dcbcfg);
+        /* At least have TC0 */
+        enabled_tc = (enabled_tc ? enabled_tc : 0x1);
+        for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++) {
+                if (enabled_tc & (1 << i))
+                        num_tc++;
+        }
+        return num_tc;
 }
 
 /**
@@ -4110,12 +4147,15 @@ static u8 i40e_pf_get_tc_map(struct i40e_pf *pf)
         if (!(pf->flags & I40E_FLAG_DCB_ENABLED))
                 return i40e_pf_get_default_tc(pf);
 
-        /* MFP mode will have enabled TCs set by FW */
-        if (pf->flags & I40E_FLAG_MFP_ENABLED)
-                return pf->hw.func_caps.enabled_tcmap;
-
         /* SFP mode we want PF to be enabled for all TCs */
-        return i40e_dcb_get_enabled_tc(&pf->hw.local_dcbx_config);
+        if (!(pf->flags & I40E_FLAG_MFP_ENABLED))
+                return i40e_dcb_get_enabled_tc(&pf->hw.local_dcbx_config);
+
+        /* MPF enabled and iSCSI PF type */
+        if (pf->hw.func_caps.iscsi)
+                return i40e_get_iscsi_tc_map(pf);
+        else
+                return pf->hw.func_caps.enabled_tcmap;
 }
 
 /**
@@ -4505,9 +4545,6 @@ static int i40e_init_pf_dcb(struct i40e_pf *pf)
         struct i40e_hw *hw = &pf->hw;
         int err = 0;
 
-        if (pf->hw.func_caps.npar_enable)
-                goto out;
-
         /* Get the initial DCB configuration */
         err = i40e_init_dcb(hw);
         if (!err) {
@@ -4533,7 +4570,8 @@ static int i40e_init_pf_dcb(struct i40e_pf *pf)
                                 "DCBX offload is supported for this PF.\n");
                 }
         } else {
-                dev_info(&pf->pdev->dev, "AQ Querying DCB configuration failed: %d\n",
+                dev_info(&pf->pdev->dev,
+                         "AQ Querying DCB configuration failed: aq_err %d\n",
                          pf->hw.aq.asq_last_status);
         }
 
@@ -4557,6 +4595,15 @@ static void i40e_print_link_message(struct i40e_vsi *vsi, bool isup)
                 return;
         }
 
+        /* Warn user if link speed on NPAR enabled partition is not at
+         * least 10GB
+         */
+        if (vsi->back->hw.func_caps.npar_enable &&
+            (vsi->back->hw.phy.link_info.link_speed == I40E_LINK_SPEED_1GB ||
+             vsi->back->hw.phy.link_info.link_speed == I40E_LINK_SPEED_100MB))
+                netdev_warn(vsi->netdev,
+                            "The partition detected link speed that is less than 10Gbps\n");
+
         switch (vsi->back->hw.phy.link_info.link_speed) {
         case I40E_LINK_SPEED_40GB:
                 strlcpy(speed, "40 Gbps", SPEED_SIZE);
@@ -4836,7 +4883,7 @@ static int i40e_open(struct net_device *netdev)
 int i40e_vsi_open(struct i40e_vsi *vsi)
 {
         struct i40e_pf *pf = vsi->back;
-        char int_name[IFNAMSIZ];
+        char int_name[I40E_INT_NAME_STR_LEN];
         int err;
 
         /* allocate descriptors */
@@ -4870,7 +4917,7 @@ int i40e_vsi_open(struct i40e_vsi *vsi)
                         goto err_set_queues;
 
         } else if (vsi->type == I40E_VSI_FDIR) {
-                snprintf(int_name, sizeof(int_name) - 1, "%s-%s-fdir",
+                snprintf(int_name, sizeof(int_name) - 1, "%s-%s:fdir",
                          dev_driver_string(&pf->pdev->dev),
                          dev_name(&pf->pdev->dev));
                 err = i40e_vsi_request_irq(vsi, int_name);
@@ -5494,14 +5541,18 @@ static void i40e_link_event(struct i40e_pf *pf)
 {
         bool new_link, old_link;
         struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
+        u8 new_link_speed, old_link_speed;
 
         /* set this to force the get_link_status call to refresh state */
         pf->hw.phy.get_link_info = true;
 
         old_link = (pf->hw.phy.link_info_old.link_info & I40E_AQ_LINK_UP);
         new_link = i40e_get_link_status(&pf->hw);
+        old_link_speed = pf->hw.phy.link_info_old.link_speed;
+        new_link_speed = pf->hw.phy.link_info.link_speed;
 
         if (new_link == old_link &&
+            new_link_speed == old_link_speed &&
             (test_bit(__I40E_DOWN, &vsi->state) ||
              new_link == netif_carrier_ok(vsi->netdev)))
                 return;
@@ -6175,8 +6226,9 @@ static void i40e_reset_and_rebuild(struct i40e_pf *pf, bool reinit)
 #ifdef CONFIG_I40E_DCB
         ret = i40e_init_pf_dcb(pf);
         if (ret) {
-                dev_info(&pf->pdev->dev, "init_pf_dcb failed: %d\n", ret);
-                goto end_core_reset;
+                dev_info(&pf->pdev->dev, "DCB init failed %d, disabled\n", ret);
+                pf->flags &= ~I40E_FLAG_DCB_CAPABLE;
+                /* Continue without DCB enabled */
         }
 #endif /* CONFIG_I40E_DCB */
 #ifdef I40E_FCOE
@@ -6881,17 +6933,17 @@ static int i40e_init_msix(struct i40e_pf *pf)
         if (pf->flags & I40E_FLAG_FD_SB_ENABLED)
                 other_vecs++;
 
+        /* Scale down if necessary, and the rings will share vectors */
+        pf->num_lan_msix = min_t(int, pf->num_lan_msix,
+                        (hw->func_caps.num_msix_vectors - other_vecs));
+        v_budget = pf->num_lan_msix + other_vecs;
+
 #ifdef I40E_FCOE
         if (pf->flags & I40E_FLAG_FCOE_ENABLED) {
                 pf->num_fcoe_msix = pf->num_fcoe_qps;
                 v_budget += pf->num_fcoe_msix;
         }
-
 #endif
-        /* Scale down if necessary, and the rings will share vectors */
-        pf->num_lan_msix = min_t(int, pf->num_lan_msix,
-                        (hw->func_caps.num_msix_vectors - other_vecs));
-        v_budget = pf->num_lan_msix + other_vecs;
 
         pf->msix_entries = kcalloc(v_budget, sizeof(struct msix_entry),
                                    GFP_KERNEL);
@@ -7113,16 +7165,16 @@ static int i40e_setup_misc_vector(struct i40e_pf *pf)
          */
         if (!test_bit(__I40E_RESET_RECOVERY_PENDING, &pf->state)) {
                 err = request_irq(pf->msix_entries[0].vector,
-                                  i40e_intr, 0, pf->misc_int_name, pf);
+                                  i40e_intr, 0, pf->int_name, pf);
                 if (err) {
                         dev_info(&pf->pdev->dev,
                                  "request_irq for %s failed: %d\n",
-                                 pf->misc_int_name, err);
+                                 pf->int_name, err);
                         return -EFAULT;
                 }
         }
 
-        i40e_enable_misc_int_causes(hw);
+        i40e_enable_misc_int_causes(pf);
 
         /* associate no queues to the misc vector */
         wr32(hw, I40E_PFINT_LNKLST0, I40E_QUEUE_END_OF_LIST);
@@ -7306,7 +7358,7 @@ static int i40e_sw_init(struct i40e_pf *pf)
 
 #endif /* I40E_FCOE */
 #ifdef CONFIG_PCI_IOV
-        if (pf->hw.func_caps.num_vfs) {
+        if (pf->hw.func_caps.num_vfs && pf->hw.partition_id == 1) {
                 pf->num_vf_qps = I40E_DEFAULT_QUEUES_PER_VF;
                 pf->flags |= I40E_FLAG_SRIOV_ENABLED;
                 pf->num_req_vfs = min_t(int,
@@ -7766,7 +7818,8 @@ static int i40e_add_vsi(struct i40e_vsi *vsi)
                 enabled_tc = i40e_pf_get_tc_map(pf);
 
                 /* MFP mode setup queue map and update VSI */
-                if (pf->flags & I40E_FLAG_MFP_ENABLED) {
+                if ((pf->flags & I40E_FLAG_MFP_ENABLED) &&
+                    !(pf->hw.func_caps.iscsi)) { /* NIC type PF */
                         memset(&ctxt, 0, sizeof(ctxt));
                         ctxt.seid = pf->main_vsi_seid;
                         ctxt.pf_num = pf->hw.pf_id;
@@ -7787,6 +7840,8 @@ static int i40e_add_vsi(struct i40e_vsi *vsi)
                         /* Default/Main VSI is only enabled for TC0
                          * reconfigure it to enable all TCs that are
                          * available on the port in SFP mode.
+                         * For MFP case the iSCSI PF would use this
+                         * flow to enable LAN+iSCSI TC.
                          */
                         ret = i40e_vsi_config_tc(vsi, enabled_tc);
                         if (ret) {
@@ -9164,7 +9219,7 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         hw->aq.asq_buf_size = I40E_MAX_AQ_BUF_SIZE;
         pf->adminq_work_limit = I40E_AQ_WORK_LIMIT;
 
-        snprintf(pf->misc_int_name, sizeof(pf->misc_int_name) - 1,
+        snprintf(pf->int_name, sizeof(pf->int_name) - 1,
                  "%s-%s:misc",
                  dev_driver_string(&pf->pdev->dev), dev_name(&pdev->dev));
 
@@ -9227,6 +9282,16 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto err_configure_lan_hmc;
         }
 
+        /* Disable LLDP for NICs that have firmware versions lower than v4.3.
+         * Ignore error return codes because if it was already disabled via
+         * hardware settings this will fail
+         */
+        if (((pf->hw.aq.fw_maj_ver == 4) && (pf->hw.aq.fw_min_ver < 3)) ||
+            (pf->hw.aq.fw_maj_ver < 4)) {
+                dev_info(&pdev->dev, "Stopping firmware LLDP agent.\n");
+                i40e_aq_stop_lldp(hw, true, NULL);
+        }
+
         i40e_get_mac_addr(hw, hw->mac.addr);
         if (!is_valid_ether_addr(hw->mac.addr)) {
                 dev_info(&pdev->dev, "invalid MAC address %pM\n", hw->mac.addr);
@@ -9256,7 +9321,7 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 #ifdef CONFIG_I40E_DCB
         err = i40e_init_pf_dcb(pf);
         if (err) {
-                dev_info(&pdev->dev, "init_pf_dcb failed: %d\n", err);
+                dev_info(&pdev->dev, "DCB init failed %d, disabled\n", err);
                 pf->flags &= ~I40E_FLAG_DCB_CAPABLE;
                 /* Continue without DCB enabled */
         }
@@ -9671,6 +9736,8 @@ static int i40e_suspend(struct pci_dev *pdev, pm_message_t state)
 
         set_bit(__I40E_SUSPENDED, &pf->state);
         set_bit(__I40E_DOWN, &pf->state);
+        del_timer_sync(&pf->service_timer);
+        cancel_work_sync(&pf->service_task);
         rtnl_lock();
         i40e_prep_for_reset(pf);
         rtnl_unlock();
diff --git a/drivers/net/ethernet/intel/i40e/i40e_prototype.h b/drivers/net/ethernet/intel/i40e/i40e_prototype.h
index 2fb4306597e8..68e852a96680 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_prototype.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_prototype.h
@@ -71,6 +71,9 @@ i40e_status i40e_aq_get_firmware_version(struct i40e_hw *hw,
 i40e_status i40e_aq_debug_write_register(struct i40e_hw *hw,
                                         u32 reg_addr, u64 reg_val,
                                         struct i40e_asq_cmd_details *cmd_details);
+i40e_status i40e_aq_debug_read_register(struct i40e_hw *hw,
+                                u32  reg_addr, u64 *reg_val,
+                                struct i40e_asq_cmd_details *cmd_details);
 i40e_status i40e_aq_set_phy_debug(struct i40e_hw *hw, u8 cmd_flags,
                                 struct i40e_asq_cmd_details *cmd_details);
 i40e_status i40e_aq_set_default_vsi(struct i40e_hw *hw, u16 vsi_id,
@@ -245,6 +248,8 @@ void i40e_clear_pxe_mode(struct i40e_hw *hw);
 bool i40e_get_link_status(struct i40e_hw *hw);
 i40e_status i40e_get_mac_addr(struct i40e_hw *hw, u8 *mac_addr);
 i40e_status i40e_get_port_mac_addr(struct i40e_hw *hw, u8 *mac_addr);
+i40e_status i40e_read_pba_string(struct i40e_hw *hw, u8 *pba_num,
+                                 u32 pba_num_size);
 i40e_status i40e_validate_mac_addr(u8 *mac_addr);
 void i40e_pre_tx_queue_cfg(struct i40e_hw *hw, u32 queue, bool enable);
 #ifdef I40E_FCOE
diff --git a/drivers/net/ethernet/intel/i40e/i40e_ptp.c b/drivers/net/ethernet/intel/i40e/i40e_ptp.c
index 6d1ec926aa37..fabcfa1b45b2 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_ptp.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_ptp.c
@@ -247,7 +247,12 @@ void i40e_ptp_rx_hang(struct i40e_vsi *vsi)
         u32 prttsyn_stat;
         int n;
 
-        if (!(pf->flags & I40E_FLAG_PTP))
+        /* Since we cannot turn off the Rx timestamp logic if the device is
+         * configured for Tx timestamping, we check if Rx timestamping is
+         * configured. We don't want to spuriously warn about Rx timestamp
+         * hangs if we don't care about the timestamps.
+         */
+        if (!(pf->flags & I40E_FLAG_PTP) || !pf->ptp_rx)
                 return;
 
         prttsyn_stat = rd32(hw, I40E_PRTTSYN_STAT_1);
@@ -305,6 +310,13 @@ void i40e_ptp_tx_hwtstamp(struct i40e_pf *pf)
         u32 hi, lo;
         u64 ns;
 
+        if (!(pf->flags & I40E_FLAG_PTP) || !pf->ptp_tx)
+                return;
+
+        /* don't attempt to timestamp if we don't have an skb */
+        if (!pf->ptp_tx_skb)
+                return;
+
         lo = rd32(hw, I40E_PRTTSYN_TXTIME_L);
         hi = rd32(hw, I40E_PRTTSYN_TXTIME_H);
 
@@ -338,7 +350,7 @@ void i40e_ptp_rx_hwtstamp(struct i40e_pf *pf, struct sk_buff *skb, u8 index)
         /* Since we cannot turn off the Rx timestamp logic if the device is
          * doing Tx timestamping, check if Rx timestamping is configured.
          */
-        if (!pf->ptp_rx)
+        if (!(pf->flags & I40E_FLAG_PTP) || !pf->ptp_rx)
                 return;
 
         hw = &pf->hw;
@@ -467,7 +479,12 @@ static int i40e_ptp_set_timestamp_mode(struct i40e_pf *pf,
         switch (config->rx_filter) {
         case HWTSTAMP_FILTER_NONE:
                 pf->ptp_rx = false;
-                tsyntype = 0;
+                /* We set the type to V1, but do not enable UDP packet
+                 * recognition. In this way, we should be as close to
+                 * disabling PTP Rx timestamps as possible since V1 packets
+                 * are always UDP, since L2 packets are a V2 feature.
+                 */
+                tsyntype = I40E_PRTTSYN_CTL1_TSYNTYPE_V1;
                 break;
         case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
         case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
@@ -521,17 +538,18 @@ static int i40e_ptp_set_timestamp_mode(struct i40e_pf *pf,
                 regval &= ~I40E_PFINT_ICR0_ENA_TIMESYNC_MASK;
         wr32(hw, I40E_PFINT_ICR0_ENA, regval);
 
-        /* There is no simple on/off switch for Rx. To "disable" Rx support,
-         * ignore any received timestamps, rather than turn off the clock.
+        /* Although there is no simple on/off switch for Rx, we "disable" Rx
+         * timestamps by setting to V1 only mode and clear the UDP
+         * recognition. This ought to disable all PTP Rx timestamps as V1
+         * packets are always over UDP. Note that software is configured to
+         * ignore Rx timestamps via the pf->ptp_rx flag.
          */
-        if (pf->ptp_rx) {
-                regval = rd32(hw, I40E_PRTTSYN_CTL1);
-                /* clear everything but the enable bit */
-                regval &= I40E_PRTTSYN_CTL1_TSYNENA_MASK;
-                /* now enable bits for desired Rx timestamps */
-                regval |= tsyntype;
-                wr32(hw, I40E_PRTTSYN_CTL1, regval);
-        }
+        regval = rd32(hw, I40E_PRTTSYN_CTL1);
+        /* clear everything but the enable bit */
+        regval &= I40E_PRTTSYN_CTL1_TSYNENA_MASK;
+        /* now enable bits for desired Rx timestamps */
+        regval |= tsyntype;
+        wr32(hw, I40E_PRTTSYN_CTL1, regval);
 
         return 0;
 }
diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.c b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
index cecb340898fe..2206d2d36f0f 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
@@ -836,8 +836,8 @@ static void i40e_force_wb(struct i40e_vsi *vsi, struct i40e_q_vector *q_vector)
 {
         u32 val = I40E_PFINT_DYN_CTLN_INTENA_MASK |
                   I40E_PFINT_DYN_CTLN_SWINT_TRIG_MASK |
-                  I40E_PFINT_DYN_CTLN_SW_ITR_INDX_ENA_MASK
-                  /* allow 00 to be written to the index */;
+                  I40E_PFINT_DYN_CTLN_SW_ITR_INDX_ENA_MASK;
+                  /* allow 00 to be written to the index */
 
         wr32(&vsi->back->hw,
              I40E_PFINT_DYN_CTLN(q_vector->v_idx + vsi->base_vector - 1),
@@ -1098,6 +1098,8 @@ int i40e_setup_rx_descriptors(struct i40e_ring *rx_ring)
         if (!rx_ring->rx_bi)
                 goto err;
 
+        u64_stats_init(&rx_ring->syncp);
+
         /* Round up to nearest 4K */
         rx_ring->size = ring_is_16byte_desc_enabled(rx_ring)
                 ? rx_ring->count * sizeof(union i40e_16byte_rx_desc)
@@ -1815,8 +1817,8 @@ static int i40e_tx_prepare_vlan_flags(struct sk_buff *skb,
         u32  tx_flags = 0;
 
         /* if we have a HW VLAN tag being added, default to the HW one */
-        if (vlan_tx_tag_present(skb)) {
-                tx_flags |= vlan_tx_tag_get(skb) << I40E_TX_FLAGS_VLAN_SHIFT;
+        if (skb_vlan_tag_present(skb)) {
+                tx_flags |= skb_vlan_tag_get(skb) << I40E_TX_FLAGS_VLAN_SHIFT;
                 tx_flags |= I40E_TX_FLAGS_HW_VLAN;
         /* else if it is a SW VLAN, check the next protocol and store the tag */
         } else if (protocol == htons(ETH_P_8021Q)) {
@@ -1939,6 +1941,9 @@ static int i40e_tsyn(struct i40e_ring *tx_ring, struct sk_buff *skb,
          * we are not already transmitting a packet to be timestamped
          */
         pf = i40e_netdev_to_pf(tx_ring->netdev);
+        if (!(pf->flags & I40E_FLAG_PTP))
+                return 0;
+
         if (pf->ptp_tx &&
             !test_and_set_bit_lock(__I40E_PTP_TX_IN_PROGRESS, &pf->state)) {
                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
diff --git a/drivers/net/ethernet/intel/i40e/i40e_type.h b/drivers/net/ethernet/intel/i40e/i40e_type.h
index c1f2eb963357..e9901ef06a63 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_type.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_type.h
@@ -211,6 +211,7 @@ struct i40e_hw_capabilities {
         bool evb_802_1_qbh; /* Bridge Port Extension */
         bool dcb;
         bool fcoe;
+        bool iscsi; /* Indicates iSCSI enabled */
         bool mfp_mode_1;
         bool mgmt_cem;
         bool ieee_1588;
@@ -431,7 +432,7 @@ struct i40e_hw {
         u8 __iomem *hw_addr;
         void *back;
 
-        /* function pointer structs */
+        /* subsystem structs */
         struct i40e_phy_info phy;
         struct i40e_mac_info mac;
         struct i40e_bus_info bus;
@@ -458,6 +459,11 @@ struct i40e_hw {
         u8  pf_id;
         u16 main_vsi_seid;
 
+        /* for multi-function MACs */
+        u16 partition_id;
+        u16 num_partitions;
+        u16 num_ports;
+
         /* Closest numa node to the device */
         u16 numa_node;
 
@@ -1135,6 +1141,8 @@ struct i40e_hw_port_stats {
 /* Checksum and Shadow RAM pointers */
 #define I40E_SR_NVM_CONTROL_WORD                0x00
 #define I40E_SR_EMP_MODULE_PTR                  0x0F
+#define I40E_SR_PBA_FLAGS                       0x15
+#define I40E_SR_PBA_BLOCK_PTR                   0x16
 #define I40E_SR_NVM_IMAGE_VERSION               0x18
 #define I40E_SR_NVM_WAKE_ON_LAN                 0x19
 #define I40E_SR_ALTERNATE_SAN_MAC_ADDRESS_PTR   0x27
diff --git a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
index 5bae89550657..40f042af4131 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
@@ -647,6 +647,9 @@ void i40e_reset_vf(struct i40e_vf *vf, bool flr)
         int i;
         u32 reg;
 
+        if (test_and_set_bit(__I40E_VF_DISABLE, &pf->state))
+                return;
+
         /* warn the VF */
         clear_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states);
 
@@ -668,13 +671,13 @@ void i40e_reset_vf(struct i40e_vf *vf, bool flr)
         /* poll VPGEN_VFRSTAT reg to make sure
          * that reset is complete
          */
-        for (i = 0; i < 100; i++) {
-                /* vf reset requires driver to first reset the
-                 * vf and then poll the status register to make sure
-                 * that the requested op was completed
-                 * successfully
+        for (i = 0; i < 10; i++) {
+                /* VF reset requires driver to first reset the VF and then
+                 * poll the status register to make sure that the reset
+                 * completed successfully. Due to internal HW FIFO flushes,
+                 * we must wait 10ms before the register will be valid.
                  */
-                usleep_range(10, 20);
+                usleep_range(10000, 20000);
                 reg = rd32(hw, I40E_VPGEN_VFRSTAT(vf->vf_id));
                 if (reg & I40E_VPGEN_VFRSTAT_VFRD_MASK) {
                         rsd = true;
@@ -706,6 +709,7 @@ complete_reset:
         /* tell the VF the reset is done */
         wr32(hw, I40E_VFGEN_RSTAT1(vf->vf_id), I40E_VFR_VFACTIVE);
         i40e_flush(hw);
+        clear_bit(__I40E_VF_DISABLE, &pf->state);
 }
 
 /**
@@ -790,11 +794,18 @@ void i40e_free_vfs(struct i40e_pf *pf)
 
         if (!pf->vf)
                 return;
+        while (test_and_set_bit(__I40E_VF_DISABLE, &pf->state))
+                usleep_range(1000, 2000);
 
-        /* Disable interrupt 0 so we don't try to handle the VFLR. */
-        i40e_irq_dynamic_disable_icr0(pf);
+        /* Disable IOV before freeing resources. This lets any VF drivers
+         * running in the host get themselves cleaned up before we yank
+         * the carpet out from underneath their feet.
+         */
+        if (!pci_vfs_assigned(pf->pdev))
+                pci_disable_sriov(pf->pdev);
+
+        msleep(20); /* let any messages in transit get finished up */
 
-        mdelay(10); /* let any messages in transit get finished up */
         /* free up vf resources */
         tmp = pf->num_alloc_vfs;
         pf->num_alloc_vfs = 0;
@@ -813,7 +824,6 @@ void i40e_free_vfs(struct i40e_pf *pf)
          * before this function ever gets called.
          */
         if (!pci_vfs_assigned(pf->pdev)) {
-                pci_disable_sriov(pf->pdev);
                 /* Acknowledge VFLR for all VFS. Without this, VFs will fail to
                  * work correctly when SR-IOV gets re-enabled.
                  */
@@ -827,9 +837,7 @@ void i40e_free_vfs(struct i40e_pf *pf)
                 dev_warn(&pf->pdev->dev,
                          "unable to disable SR-IOV because VFs are assigned.\n");
         }
-
-        /* Re-enable interrupt 0. */
-        i40e_irq_dynamic_enable_icr0(pf);
+        clear_bit(__I40E_VF_DISABLE, &pf->state);
 }
 
 #ifdef CONFIG_PCI_IOV
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_adminq.h b/drivers/net/ethernet/intel/i40evf/i40e_adminq.h
index 6c31bf22c2c3..60f04e96a80e 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_adminq.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_adminq.h
@@ -148,7 +148,7 @@ static inline int i40e_aq_rc_to_posix(u32 aq_ret, u16 aq_rc)
 
 /* general information */
 #define I40E_AQ_LARGE_BUF       512
-#define I40E_ASQ_CMD_TIMEOUT    100  /* msecs */
+#define I40E_ASQ_CMD_TIMEOUT    250  /* msecs */
 
 void i40evf_fill_default_direct_cmd_desc(struct i40e_aq_desc *desc,
                                        u16 opcode);
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_adminq_cmd.h b/drivers/net/ethernet/intel/i40evf/i40e_adminq_cmd.h
index ff1b16370da9..e715bccfb5d2 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_adminq_cmd.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_adminq_cmd.h
@@ -268,6 +268,8 @@ enum i40e_admin_queue_opc {
         /* OEM commands */
         i40e_aqc_opc_oem_parameter_change       = 0xFE00,
         i40e_aqc_opc_oem_device_status_change   = 0xFE01,
+        i40e_aqc_opc_oem_ocsd_initialize        = 0xFE02,
+        i40e_aqc_opc_oem_ocbb_initialize        = 0xFE03,
 
         /* debug commands */
         i40e_aqc_opc_debug_get_deviceid         = 0xFF00,
@@ -276,7 +278,6 @@ enum i40e_admin_queue_opc {
         i40e_aqc_opc_debug_write_reg            = 0xFF04,
         i40e_aqc_opc_debug_modify_reg           = 0xFF07,
         i40e_aqc_opc_debug_dump_internals       = 0xFF08,
-        i40e_aqc_opc_debug_modify_internals     = 0xFF09,
 };
 
 /* command structures and indirect data structures */
@@ -410,6 +411,7 @@ struct i40e_aqc_list_capabilities_element_resp {
 #define I40E_AQ_CAP_ID_VSI              0x0017
 #define I40E_AQ_CAP_ID_DCB              0x0018
 #define I40E_AQ_CAP_ID_FCOE             0x0021
+#define I40E_AQ_CAP_ID_ISCSI            0x0022
 #define I40E_AQ_CAP_ID_RSS              0x0040
 #define I40E_AQ_CAP_ID_RXQ              0x0041
 #define I40E_AQ_CAP_ID_TXQ              0x0042
@@ -454,8 +456,11 @@ struct i40e_aqc_arp_proxy_data {
         __le32  pfpm_proxyfc;
         __le32  ip_addr;
         u8      mac_addr[6];
+        u8      reserved[2];
 };
 
+I40E_CHECK_STRUCT_LEN(0x14, i40e_aqc_arp_proxy_data);
+
 /* Set NS Proxy Table Entry Command (indirect 0x0105) */
 struct i40e_aqc_ns_proxy_data {
         __le16  table_idx_mac_addr_0;
@@ -481,6 +486,8 @@ struct i40e_aqc_ns_proxy_data {
         u8      ipv6_addr_1[16];
 };
 
+I40E_CHECK_STRUCT_LEN(0x3c, i40e_aqc_ns_proxy_data);
+
 /* Manage LAA Command (0x0106) - obsolete */
 struct i40e_aqc_mng_laa {
         __le16  command_flags;
@@ -491,6 +498,8 @@ struct i40e_aqc_mng_laa {
         u8      reserved2[6];
 };
 
+I40E_CHECK_CMD_LENGTH(i40e_aqc_mng_laa);
+
 /* Manage MAC Address Read Command (indirect 0x0107) */
 struct i40e_aqc_mac_address_read {
         __le16  command_flags;
@@ -562,6 +571,8 @@ struct i40e_aqc_get_switch_config_header_resp {
         u8      reserved[12];
 };
 
+I40E_CHECK_CMD_LENGTH(i40e_aqc_get_switch_config_header_resp);
+
 struct i40e_aqc_switch_config_element_resp {
         u8      element_type;
 #define I40E_AQ_SW_ELEM_TYPE_MAC        1
@@ -587,6 +598,8 @@ struct i40e_aqc_switch_config_element_resp {
         __le16  element_info;
 };
 
+I40E_CHECK_STRUCT_LEN(0x10, i40e_aqc_switch_config_element_resp);
+
 /* Get Switch Configuration (indirect 0x0200)
  *    an array of elements are returned in the response buffer
  *    the first in the array is the header, remainder are elements
@@ -596,6 +609,8 @@ struct i40e_aqc_get_switch_config_resp {
         struct i40e_aqc_switch_config_element_resp      element[1];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_get_switch_config_resp);
+
 /* Add Statistics (direct 0x0201)
  * Remove Statistics (direct 0x0202)
  */
@@ -661,6 +676,8 @@ struct i40e_aqc_switch_resource_alloc_element_resp {
         u8      reserved2[6];
 };
 
+I40E_CHECK_STRUCT_LEN(0x10, i40e_aqc_switch_resource_alloc_element_resp);
+
 /* Add VSI (indirect 0x0210)
  *    this indirect command uses struct i40e_aqc_vsi_properties_data
  *    as the indirect buffer (128 bytes)
@@ -1092,6 +1109,8 @@ struct i40e_aqc_remove_tag {
         u8      reserved[12];
 };
 
+I40E_CHECK_CMD_LENGTH(i40e_aqc_remove_tag);
+
 /* Add multicast E-Tag (direct 0x0257)
  * del multicast E-Tag (direct 0x0258) only uses pv_seid and etag fields
  * and no external data
@@ -1207,7 +1226,7 @@ struct i40e_aqc_add_remove_cloud_filters_element_data {
         } ipaddr;
         __le16  flags;
 #define I40E_AQC_ADD_CLOUD_FILTER_SHIFT                 0
-#define I40E_AQC_ADD_CLOUD_FILTER_MASK                  (0x3F << \
+#define I40E_AQC_ADD_CLOUD_FILTER_MASK  (0x3F << \
                                         I40E_AQC_ADD_CLOUD_FILTER_SHIFT)
 /* 0x0000 reserved */
 #define I40E_AQC_ADD_CLOUD_FILTER_OIP                   0x0001
@@ -1240,7 +1259,7 @@ struct i40e_aqc_add_remove_cloud_filters_element_data {
         u8      reserved[4];
         __le16  queue_number;
 #define I40E_AQC_ADD_CLOUD_QUEUE_SHIFT          0
-#define I40E_AQC_ADD_CLOUD_QUEUE_MASK           (0x3F << \
+#define I40E_AQC_ADD_CLOUD_QUEUE_MASK           (0x7FF << \
                                                  I40E_AQC_ADD_CLOUD_QUEUE_SHIFT)
         u8      reserved2[14];
         /* response section */
@@ -1359,6 +1378,8 @@ struct i40e_aqc_configure_vsi_ets_sla_bw_data {
         u8      reserved1[28];
 };
 
+I40E_CHECK_STRUCT_LEN(0x40, i40e_aqc_configure_vsi_ets_sla_bw_data);
+
 /* Configure VSI Bandwidth Allocation per Traffic Type (indirect 0x0407)
  *    responds with i40e_aqc_qs_handles_resp
  */
@@ -1370,6 +1391,8 @@ struct i40e_aqc_configure_vsi_tc_bw_data {
         __le16  qs_handles[8];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_configure_vsi_tc_bw_data);
+
 /* Query vsi bw configuration (indirect 0x0408) */
 struct i40e_aqc_query_vsi_bw_config_resp {
         u8      tc_valid_bits;
@@ -1383,6 +1406,8 @@ struct i40e_aqc_query_vsi_bw_config_resp {
         u8      reserved3[23];
 };
 
+I40E_CHECK_STRUCT_LEN(0x40, i40e_aqc_query_vsi_bw_config_resp);
+
 /* Query VSI Bandwidth Allocation per Traffic Type (indirect 0x040A) */
 struct i40e_aqc_query_vsi_ets_sla_config_resp {
         u8      tc_valid_bits;
@@ -1394,6 +1419,8 @@ struct i40e_aqc_query_vsi_ets_sla_config_resp {
         __le16  tc_bw_max[2];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_query_vsi_ets_sla_config_resp);
+
 /* Configure Switching Component Bandwidth Limit (direct 0x0410) */
 struct i40e_aqc_configure_switching_comp_bw_limit {
         __le16  seid;
@@ -1421,6 +1448,8 @@ struct i40e_aqc_configure_switching_comp_ets_data {
         u8      reserved2[96];
 };
 
+I40E_CHECK_STRUCT_LEN(0x80, i40e_aqc_configure_switching_comp_ets_data);
+
 /* Configure Switching Component Bandwidth Limits per Tc (indirect 0x0416) */
 struct i40e_aqc_configure_switching_comp_ets_bw_limit_data {
         u8      tc_valid_bits;
@@ -1432,6 +1461,9 @@ struct i40e_aqc_configure_switching_comp_ets_bw_limit_data {
         u8      reserved1[28];
 };
 
+I40E_CHECK_STRUCT_LEN(0x40,
+                      i40e_aqc_configure_switching_comp_ets_bw_limit_data);
+
 /* Configure Switching Component Bandwidth Allocation per Tc
  * (indirect 0x0417)
  */
@@ -1443,6 +1475,8 @@ struct i40e_aqc_configure_switching_comp_bw_config_data {
         u8      reserved1[20];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_configure_switching_comp_bw_config_data);
+
 /* Query Switching Component Configuration (indirect 0x0418) */
 struct i40e_aqc_query_switching_comp_ets_config_resp {
         u8      tc_valid_bits;
@@ -1453,6 +1487,8 @@ struct i40e_aqc_query_switching_comp_ets_config_resp {
         u8      reserved2[23];
 };
 
+I40E_CHECK_STRUCT_LEN(0x40, i40e_aqc_query_switching_comp_ets_config_resp);
+
 /* Query PhysicalPort ETS Configuration (indirect 0x0419) */
 struct i40e_aqc_query_port_ets_config_resp {
         u8      reserved[4];
@@ -1468,6 +1504,8 @@ struct i40e_aqc_query_port_ets_config_resp {
         u8      reserved3[32];
 };
 
+I40E_CHECK_STRUCT_LEN(0x44, i40e_aqc_query_port_ets_config_resp);
+
 /* Query Switching Component Bandwidth Allocation per Traffic Type
  * (indirect 0x041A)
  */
@@ -1482,6 +1520,8 @@ struct i40e_aqc_query_switching_comp_bw_config_resp {
         __le16  tc_bw_max[2];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_query_switching_comp_bw_config_resp);
+
 /* Suspend/resume port TX traffic
  * (direct 0x041B and 0x041C) uses the generic SEID struct
  */
@@ -1495,6 +1535,8 @@ struct i40e_aqc_configure_partition_bw_data {
         u8      max_bw[16];      /* bandwidth limit */
 };
 
+I40E_CHECK_STRUCT_LEN(0x22, i40e_aqc_configure_partition_bw_data);
+
 /* Get and set the active HMC resource profile and status.
  * (direct 0x0500) and (direct 0x0501)
  */
@@ -1577,6 +1619,8 @@ struct i40e_aqc_module_desc {
         u8 reserved2[8];
 };
 
+I40E_CHECK_STRUCT_LEN(0x20, i40e_aqc_module_desc);
+
 struct i40e_aq_get_phy_abilities_resp {
         __le32  phy_type;       /* bitmap using the above enum for offsets */
         u8      link_speed;     /* bitmap using the above enum bit patterns */
@@ -1605,6 +1649,8 @@ struct i40e_aq_get_phy_abilities_resp {
         struct i40e_aqc_module_desc     qualified_module[I40E_AQ_PHY_MAX_QMS];
 };
 
+I40E_CHECK_STRUCT_LEN(0x218, i40e_aq_get_phy_abilities_resp);
+
 /* Set PHY Config (direct 0x0601) */
 struct i40e_aq_set_phy_config { /* same bits as above in all */
         __le32  phy_type;
@@ -1788,12 +1834,12 @@ I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_update);
 /* NVM Config Read (indirect 0x0704) */
 struct i40e_aqc_nvm_config_read {
         __le16  cmd_flags;
-#define ANVM_SINGLE_OR_MULTIPLE_FEATURES_MASK   1
-#define ANVM_READ_SINGLE_FEATURE                0
-#define ANVM_READ_MULTIPLE_FEATURES             1
+#define I40E_AQ_ANVM_SINGLE_OR_MULTIPLE_FEATURES_MASK   1
+#define I40E_AQ_ANVM_READ_SINGLE_FEATURE                0
+#define I40E_AQ_ANVM_READ_MULTIPLE_FEATURES             1
         __le16  element_count;
-        __le16  element_id; /* Feature/field ID */
-        u8      reserved[2];
+        __le16  element_id;     /* Feature/field ID */
+        __le16  element_id_msw; /* MSWord of field ID */
         __le32  address_high;
         __le32  address_low;
 };
@@ -1811,21 +1857,32 @@ struct i40e_aqc_nvm_config_write {
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_nvm_config_write);
 
+/* Used for 0x0704 as well as for 0x0705 commands */
+#define I40E_AQ_ANVM_FEATURE_OR_IMMEDIATE_SHIFT         1
+#define I40E_AQ_ANVM_FEATURE_OR_IMMEDIATE_MASK \
+                                (1 << I40E_AQ_ANVM_FEATURE_OR_IMMEDIATE_SHIFT)
+#define I40E_AQ_ANVM_FEATURE            0
+#define I40E_AQ_ANVM_IMMEDIATE_FIELD    (1 << FEATURE_OR_IMMEDIATE_SHIFT)
 struct i40e_aqc_nvm_config_data_feature {
         __le16 feature_id;
-        __le16 instance_id;
+#define I40E_AQ_ANVM_FEATURE_OPTION_OEM_ONLY            0x01
+#define I40E_AQ_ANVM_FEATURE_OPTION_DWORD_MAP           0x08
+#define I40E_AQ_ANVM_FEATURE_OPTION_POR_CSR             0x10
         __le16 feature_options;
         __le16 feature_selection;
 };
 
+I40E_CHECK_STRUCT_LEN(0x6, i40e_aqc_nvm_config_data_feature);
+
 struct i40e_aqc_nvm_config_data_immediate_field {
-#define ANVM_FEATURE_OR_IMMEDIATE_MASK  0x2
-        __le16 field_id;
-        __le16 instance_id;
+        __le32 field_id;
+        __le32 field_value;
         __le16 field_options;
-        __le16 field_value;
+        __le16 reserved;
 };
 
+I40E_CHECK_STRUCT_LEN(0xc, i40e_aqc_nvm_config_data_immediate_field);
+
 /* Send to PF command (indirect 0x0801) id is only used by PF
  * Send to VF command (indirect 0x0802) id is only used by PF
  * Send to Peer PF command (indirect 0x0803)
@@ -2082,7 +2139,8 @@ struct i40e_aqc_oem_param_change {
 #define I40E_AQ_OEM_PARAM_TYPE_BW_CTL   1
 #define I40E_AQ_OEM_PARAM_MAC           2
         __le32  param_value1;
-        u8      param_value2[8];
+        __le16  param_value2;
+        u8      reserved[6];
 };
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_param_change);
@@ -2096,6 +2154,28 @@ struct i40e_aqc_oem_state_change {
 
 I40E_CHECK_CMD_LENGTH(i40e_aqc_oem_state_change);
 
+/* Initialize OCSD (0xFE02, direct) */
+struct i40e_aqc_opc_oem_ocsd_initialize {
+        u8 type_status;
+        u8 reserved1[3];
+        __le32 ocsd_memory_block_addr_high;
+        __le32 ocsd_memory_block_addr_low;
+        __le32 requested_update_interval;
+};
+
+I40E_CHECK_CMD_LENGTH(i40e_aqc_opc_oem_ocsd_initialize);
+
+/* Initialize OCBB  (0xFE03, direct) */
+struct i40e_aqc_opc_oem_ocbb_initialize {
+        u8 type_status;
+        u8 reserved1[3];
+        __le32 ocbb_memory_block_addr_high;
+        __le32 ocbb_memory_block_addr_low;
+        u8 reserved2[4];
+};
+
+I40E_CHECK_CMD_LENGTH(i40e_aqc_opc_oem_ocbb_initialize);
+
 /* debug commands */
 
 /* get device id (0xFF00) uses the generic structure */
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
index 04c7c1557a0c..29004382f462 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
@@ -192,6 +192,8 @@ static inline u32 i40e_get_head(struct i40e_ring *tx_ring)
         return le32_to_cpu(*(volatile __le32 *)head);
 }
 
+#define WB_STRIDE 0x3
+
 /**
  * i40e_clean_tx_irq - Reclaim resources after transmit completes
  * @tx_ring:  tx ring to clean
@@ -293,6 +295,14 @@ static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
         tx_ring->q_vector->tx.total_bytes += total_bytes;
         tx_ring->q_vector->tx.total_packets += total_packets;
 
+        if (budget &&
+            !((i & WB_STRIDE) == WB_STRIDE) &&
+            !test_bit(__I40E_DOWN, &tx_ring->vsi->state) &&
+            (I40E_DESC_UNUSED(tx_ring) != tx_ring->count))
+                tx_ring->arm_wb = true;
+        else
+                tx_ring->arm_wb = false;
+
         if (check_for_tx_hang(tx_ring) && i40e_check_tx_hang(tx_ring)) {
                 /* schedule immediate reset if we believe we hung */
                 dev_info(tx_ring->dev, "Detected Tx Unit Hang\n"
@@ -344,6 +354,24 @@ static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
 }
 
 /**
+ * i40e_force_wb -Arm hardware to do a wb on noncache aligned descriptors
+ * @vsi: the VSI we care about
+ * @q_vector: the vector  on which to force writeback
+ *
+ **/
+static void i40e_force_wb(struct i40e_vsi *vsi, struct i40e_q_vector *q_vector)
+{
+        u32 val = I40E_VFINT_DYN_CTLN_INTENA_MASK |
+                  I40E_VFINT_DYN_CTLN_SWINT_TRIG_MASK |
+                  I40E_VFINT_DYN_CTLN_SW_ITR_INDX_ENA_MASK;
+                  /* allow 00 to be written to the index */
+
+        wr32(&vsi->back->hw,
+             I40E_VFINT_DYN_CTLN1(q_vector->v_idx + vsi->base_vector - 1),
+             val);
+}
+
+/**
  * i40e_set_new_dynamic_itr - Find new ITR level
  * @rc: structure containing ring performance data
  *
@@ -568,6 +596,8 @@ int i40evf_setup_rx_descriptors(struct i40e_ring *rx_ring)
         if (!rx_ring->rx_bi)
                 goto err;
 
+        u64_stats_init(&rx_ring->syncp);
+
         /* Round up to nearest 4K */
         rx_ring->size = ring_is_16byte_desc_enabled(rx_ring)
                 ? rx_ring->count * sizeof(union i40e_16byte_rx_desc)
@@ -1065,6 +1095,7 @@ int i40evf_napi_poll(struct napi_struct *napi, int budget)
         struct i40e_vsi *vsi = q_vector->vsi;
         struct i40e_ring *ring;
         bool clean_complete = true;
+        bool arm_wb = false;
         int budget_per_ring;
 
         if (test_bit(__I40E_DOWN, &vsi->state)) {
@@ -1075,8 +1106,10 @@ int i40evf_napi_poll(struct napi_struct *napi, int budget)
         /* Since the actual Tx work is minimal, we can give the Tx a larger
          * budget and be more aggressive about cleaning up the Tx descriptors.
          */
-        i40e_for_each_ring(ring, q_vector->tx)
+        i40e_for_each_ring(ring, q_vector->tx) {
                 clean_complete &= i40e_clean_tx_irq(ring, vsi->work_limit);
+                arm_wb |= ring->arm_wb;
+        }
 
         /* We attempt to distribute budget to each Rx queue fairly, but don't
          * allow the budget to go below 1 because that would exit polling early.
@@ -1087,8 +1120,11 @@ int i40evf_napi_poll(struct napi_struct *napi, int budget)
                 clean_complete &= i40e_clean_rx_irq(ring, budget_per_ring);
 
         /* If work not completed, return budget and polling will return */
-        if (!clean_complete)
+        if (!clean_complete) {
+                if (arm_wb)
+                        i40e_force_wb(vsi, q_vector);
                 return budget;
+        }
 
         /* Work is done so exit the polling mode and re-enable the interrupt */
         napi_complete(napi);
@@ -1122,8 +1158,8 @@ static int i40e_tx_prepare_vlan_flags(struct sk_buff *skb,
         u32  tx_flags = 0;
 
         /* if we have a HW VLAN tag being added, default to the HW one */
-        if (vlan_tx_tag_present(skb)) {
-                tx_flags |= vlan_tx_tag_get(skb) << I40E_TX_FLAGS_VLAN_SHIFT;
+        if (skb_vlan_tag_present(skb)) {
+                tx_flags |= skb_vlan_tag_get(skb) << I40E_TX_FLAGS_VLAN_SHIFT;
                 tx_flags |= I40E_TX_FLAGS_HW_VLAN;
         /* else if it is a SW VLAN, check the next protocol and store the tag */
         } else if (protocol == htons(ETH_P_8021Q)) {
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.h b/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
index c7f29626eada..4e15903b2b6d 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
@@ -238,6 +238,7 @@ struct i40e_ring {
         u8 atr_count;
 
         bool ring_active;               /* is ring online or not */
+        bool arm_wb;            /* do something to arm write back */
 
         /* stats structs */
         struct i40e_queue_stats stats;
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_type.h b/drivers/net/ethernet/intel/i40evf/i40e_type.h
index 68aec11f6523..3d0fdaab5cc8 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_type.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_type.h
@@ -211,6 +211,7 @@ struct i40e_hw_capabilities {
         bool evb_802_1_qbh; /* Bridge Port Extension */
         bool dcb;
         bool fcoe;
+        bool iscsi; /* Indicates iSCSI enabled */
         bool mfp_mode_1;
         bool mgmt_cem;
         bool ieee_1588;
@@ -425,7 +426,7 @@ struct i40e_hw {
         u8 __iomem *hw_addr;
         void *back;
 
-        /* function pointer structs */
+        /* subsystem structs */
         struct i40e_phy_info phy;
         struct i40e_mac_info mac;
         struct i40e_bus_info bus;
@@ -452,6 +453,11 @@ struct i40e_hw {
         u8  pf_id;
         u16 main_vsi_seid;
 
+        /* for multi-function MACs */
+        u16 partition_id;
+        u16 num_partitions;
+        u16 num_ports;
+
         /* Closest numa node to the device */
         u16 numa_node;
 
diff --git a/drivers/net/ethernet/intel/i40evf/i40evf_main.c b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
index cabaf599f562..8d8c201c63c1 100644
--- a/drivers/net/ethernet/intel/i40evf/i40evf_main.c
+++ b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
@@ -36,7 +36,7 @@ char i40evf_driver_name[] = "i40evf";
 static const char i40evf_driver_string[] =
         "Intel(R) XL710/X710 Virtual Function Network Driver";
 
-#define DRV_VERSION "1.0.6"
+#define DRV_VERSION "1.2.0"
 const char i40evf_driver_version[] = DRV_VERSION;
 static const char i40evf_copyright[] =
         "Copyright (c) 2013 - 2014 Intel Corporation.";
@@ -313,10 +313,6 @@ static irqreturn_t i40evf_msix_aq(int irq, void *data)
         val = val | I40E_PFINT_DYN_CTL0_CLEARPBA_MASK;
         wr32(hw, I40E_VFINT_DYN_CTL01, val);
 
-        /* re-enable interrupt causes */
-        wr32(hw, I40E_VFINT_ICR0_ENA1, ena_mask);
-        wr32(hw, I40E_VFINT_DYN_CTL01, I40E_VFINT_DYN_CTL01_INTENA_MASK);
-
         /* schedule work on the private workqueue */
         schedule_work(&adapter->adminq_task);
 
@@ -947,30 +943,6 @@ static int i40evf_up_complete(struct i40evf_adapter *adapter)
 }
 
 /**
- * i40evf_clean_all_rx_rings - Free Rx Buffers for all queues
- * @adapter: board private structure
- **/
-static void i40evf_clean_all_rx_rings(struct i40evf_adapter *adapter)
-{
-        int i;
-
-        for (i = 0; i < adapter->num_active_queues; i++)
-                i40evf_clean_rx_ring(adapter->rx_rings[i]);
-}
-
-/**
- * i40evf_clean_all_tx_rings - Free Tx Buffers for all queues
- * @adapter: board private structure
- **/
-static void i40evf_clean_all_tx_rings(struct i40evf_adapter *adapter)
-{
-        int i;
-
-        for (i = 0; i < adapter->num_active_queues; i++)
-                i40evf_clean_tx_ring(adapter->tx_rings[i]);
-}
-
-/**
  * i40e_down - Shutdown the connection processing
  * @adapter: board private structure
  **/
@@ -982,6 +954,12 @@ void i40evf_down(struct i40evf_adapter *adapter)
         if (adapter->state == __I40EVF_DOWN)
                 return;
 
+        while (test_and_set_bit(__I40EVF_IN_CRITICAL_TASK,
+                                &adapter->crit_section))
+                usleep_range(500, 1000);
+
+        i40evf_irq_disable(adapter);
+
         /* remove all MAC filters */
         list_for_each_entry(f, &adapter->mac_filter_list, list) {
                 f->remove = true;
@@ -992,25 +970,27 @@ void i40evf_down(struct i40evf_adapter *adapter)
         }
         if (!(adapter->flags & I40EVF_FLAG_PF_COMMS_FAILED) &&
             adapter->state != __I40EVF_RESETTING) {
-                adapter->aq_required |= I40EVF_FLAG_AQ_DEL_MAC_FILTER;
+                /* cancel any current operation */
+                adapter->current_op = I40E_VIRTCHNL_OP_UNKNOWN;
+                adapter->aq_pending = 0;
+                /* Schedule operations to close down the HW. Don't wait
+                 * here for this to complete. The watchdog is still running
+                 * and it will take care of this.
+                 */
+                adapter->aq_required = I40EVF_FLAG_AQ_DEL_MAC_FILTER;
                 adapter->aq_required |= I40EVF_FLAG_AQ_DEL_VLAN_FILTER;
-                /* disable receives */
                 adapter->aq_required |= I40EVF_FLAG_AQ_DISABLE_QUEUES;
-                mod_timer_pending(&adapter->watchdog_timer, jiffies + 1);
-                msleep(20);
         }
         netif_tx_disable(netdev);
 
         netif_tx_stop_all_queues(netdev);
 
-        i40evf_irq_disable(adapter);
-
         i40evf_napi_disable_all(adapter);
 
-        netif_carrier_off(netdev);
+        msleep(20);
 
-        i40evf_clean_all_tx_rings(adapter);
-        i40evf_clean_all_rx_rings(adapter);
+        netif_carrier_off(netdev);
+        clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section);
 }
 
 /**
@@ -1356,8 +1336,13 @@ static void i40evf_watchdog_task(struct work_struct *work)
         /* Process admin queue tasks. After init, everything gets done
          * here so we don't race on the admin queue.
          */
-        if (adapter->aq_pending)
+        if (adapter->aq_pending) {
+                if (!i40evf_asq_done(hw)) {
+                        dev_dbg(&adapter->pdev->dev, "Admin queue timeout\n");
+                        i40evf_send_api_ver(adapter);
+                }
                 goto watchdog_done;
+        }
 
         if (adapter->aq_required & I40EVF_FLAG_AQ_MAP_VECTORS) {
                 i40evf_map_queues(adapter);
@@ -1401,11 +1386,14 @@ static void i40evf_watchdog_task(struct work_struct *work)
 
         if (adapter->state == __I40EVF_RUNNING)
                 i40evf_request_stats(adapter);
-
-        i40evf_irq_enable(adapter, true);
-        i40evf_fire_sw_int(adapter, 0xFF);
-
 watchdog_done:
+        if (adapter->state == __I40EVF_RUNNING) {
+                i40evf_irq_enable_queues(adapter, ~0);
+                i40evf_fire_sw_int(adapter, 0xFF);
+        } else {
+                i40evf_fire_sw_int(adapter, 0x1);
+        }
+
         clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section);
 restart_watchdog:
         if (adapter->state == __I40EVF_REMOVE)
@@ -1633,17 +1621,17 @@ static void i40evf_adminq_task(struct work_struct *work)
         u16 pending;
 
         if (adapter->flags & I40EVF_FLAG_PF_COMMS_FAILED)
-                return;
+                goto out;
 
         event.buf_len = I40EVF_MAX_AQ_BUF_SIZE;
         event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL);
         if (!event.msg_buf)
-                return;
+                goto out;
 
         v_msg = (struct i40e_virtchnl_msg *)&event.desc;
         do {
                 ret = i40evf_clean_arq_element(hw, &event, &pending);
-                if (ret)
+                if (ret || !v_msg->v_opcode)
                         break; /* No event to process or error cleaning ARQ */
 
                 i40evf_virtchnl_completion(adapter, v_msg->v_opcode,
@@ -1688,10 +1676,10 @@ static void i40evf_adminq_task(struct work_struct *work)
         if (oldval != val)
                 wr32(hw, hw->aq.asq.len, val);
 
+        kfree(event.msg_buf);
+out:
         /* re-enable Admin queue interrupt cause */
         i40evf_misc_irq_enable(adapter);
-
-        kfree(event.msg_buf);
 }
 
 /**
@@ -2053,12 +2041,8 @@ static void i40evf_init_task(struct work_struct *work)
                 /* aq msg sent, awaiting reply */
                 err = i40evf_verify_api_ver(adapter);
                 if (err) {
-                        dev_info(&pdev->dev, "Unable to verify API version (%d), retrying\n",
-                                 err);
-                        if (err == I40E_ERR_ADMIN_QUEUE_NO_WORK) {
-                                dev_info(&pdev->dev, "Resending request\n");
+                        if (err == I40E_ERR_ADMIN_QUEUE_NO_WORK)
                                 err = i40evf_send_api_ver(adapter);
-                        }
                         goto err;
                 }
                 err = i40evf_send_vf_config_msg(adapter);
@@ -2081,7 +2065,6 @@ static void i40evf_init_task(struct work_struct *work)
                 }
                 err = i40evf_get_vf_config(adapter);
                 if (err == I40E_ERR_ADMIN_QUEUE_NO_WORK) {
-                        dev_info(&pdev->dev, "Resending VF config request\n");
                         err = i40evf_send_vf_config_msg(adapter);
                         goto err;
                 }
@@ -2230,12 +2213,18 @@ err:
 static void i40evf_shutdown(struct pci_dev *pdev)
 {
         struct net_device *netdev = pci_get_drvdata(pdev);
+        struct i40evf_adapter *adapter = netdev_priv(netdev);
 
         netif_device_detach(netdev);
 
         if (netif_running(netdev))
                 i40evf_close(netdev);
 
+        /* Prevent the watchdog from running. */
+        adapter->state = __I40EVF_REMOVE;
+        adapter->aq_required = 0;
+        adapter->aq_pending = 0;
+
 #ifdef CONFIG_PM
         pci_save_state(pdev);
 
@@ -2448,7 +2437,18 @@ static void i40evf_remove(struct pci_dev *pdev)
                 unregister_netdev(netdev);
                 adapter->netdev_registered = false;
         }
+
+        /* Shut down all the garbage mashers on the detention level */
         adapter->state = __I40EVF_REMOVE;
+        adapter->aq_required = 0;
+        adapter->aq_pending = 0;
+        i40evf_request_reset(adapter);
+        msleep(20);
+        /* If the FW isn't responding, kick it once, but only once. */
+        if (!i40evf_asq_done(hw)) {
+                i40evf_request_reset(adapter);
+                msleep(20);
+        }
 
         if (adapter->msix_entries) {
                 i40evf_misc_irq_disable(adapter);
@@ -2477,6 +2477,10 @@ static void i40evf_remove(struct pci_dev *pdev)
                 list_del(&f->list);
                 kfree(f);
         }
+        list_for_each_entry_safe(f, ftmp, &adapter->vlan_filter_list, list) {
+                list_del(&f->list);
+                kfree(f);
+        }
 
         free_netdev(netdev);
 
diff --git a/drivers/net/ethernet/intel/i40evf/i40evf_virtchnl.c b/drivers/net/ethernet/intel/i40evf/i40evf_virtchnl.c
index 5fde5a7f4591..3f0c85ecbca6 100644
--- a/drivers/net/ethernet/intel/i40evf/i40evf_virtchnl.c
+++ b/drivers/net/ethernet/intel/i40evf/i40evf_virtchnl.c
@@ -715,14 +715,14 @@ void i40evf_virtchnl_completion(struct i40evf_adapter *adapter,
                 }
                 return;
         }
-        if (v_opcode != adapter->current_op)
-                dev_info(&adapter->pdev->dev, "Pending op is %d, received %d\n",
-                         adapter->current_op, v_opcode);
         if (v_retval) {
                 dev_err(&adapter->pdev->dev, "%s: PF returned error %d to our request %d\n",
                         __func__, v_retval, v_opcode);
         }
         switch (v_opcode) {
+        case I40E_VIRTCHNL_OP_VERSION:
+                /* no action, but also not an error */
+                break;
         case I40E_VIRTCHNL_OP_GET_STATS: {
                 struct i40e_eth_stats *stats =
                         (struct i40e_eth_stats *)msg;
diff --git a/drivers/net/ethernet/intel/igb/igb.h b/drivers/net/ethernet/intel/igb/igb.h
index 82d891e183b1..c2bd4f98a837 100644
--- a/drivers/net/ethernet/intel/igb/igb.h
+++ b/drivers/net/ethernet/intel/igb/igb.h
@@ -29,7 +29,7 @@
 #include "e1000_mac.h"
 #include "e1000_82575.h"
 
-#include <linux/clocksource.h>
+#include <linux/timecounter.h>
 #include <linux/net_tstamp.h>
 #include <linux/ptp_clock_kernel.h>
 #include <linux/bitops.h>
@@ -343,6 +343,9 @@ struct hwmon_buff {
         };
 #endif
 
+#define IGB_N_EXTTS     2
+#define IGB_N_PEROUT    2
+#define IGB_N_SDP       4
 #define IGB_RETA_SIZE   128
 
 /* board specific private data structure */
@@ -439,6 +442,12 @@ struct igb_adapter {
         u32 tx_hwtstamp_timeouts;
         u32 rx_hwtstamp_cleared;
 
+        struct ptp_pin_desc sdp_config[IGB_N_SDP];
+        struct {
+                struct timespec start;
+                struct timespec period;
+        } perout[IGB_N_PEROUT];
+
         char fw_version[32];
 #ifdef CONFIG_IGB_HWMON
         struct hwmon_buff *igb_hwmon_buff;
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index ff59897a9463..f366b3b96d03 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -5035,9 +5035,9 @@ netdev_tx_t igb_xmit_frame_ring(struct sk_buff *skb,
 
         skb_tx_timestamp(skb);
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 tx_flags |= IGB_TX_FLAGS_VLAN;
-                tx_flags |= (vlan_tx_tag_get(skb) << IGB_TX_FLAGS_VLAN_SHIFT);
+                tx_flags |= (skb_vlan_tag_get(skb) << IGB_TX_FLAGS_VLAN_SHIFT);
         }
 
         /* record initial flags and protocol */
@@ -5384,6 +5384,80 @@ void igb_update_stats(struct igb_adapter *adapter,
         }
 }
 
+static void igb_tsync_interrupt(struct igb_adapter *adapter)
+{
+        struct e1000_hw *hw = &adapter->hw;
+        struct ptp_clock_event event;
+        struct timespec ts;
+        u32 ack = 0, tsauxc, sec, nsec, tsicr = rd32(E1000_TSICR);
+
+        if (tsicr & TSINTR_SYS_WRAP) {
+                event.type = PTP_CLOCK_PPS;
+                if (adapter->ptp_caps.pps)
+                        ptp_clock_event(adapter->ptp_clock, &event);
+                else
+                        dev_err(&adapter->pdev->dev, "unexpected SYS WRAP");
+                ack |= TSINTR_SYS_WRAP;
+        }
+
+        if (tsicr & E1000_TSICR_TXTS) {
+                /* retrieve hardware timestamp */
+                schedule_work(&adapter->ptp_tx_work);
+                ack |= E1000_TSICR_TXTS;
+        }
+
+        if (tsicr & TSINTR_TT0) {
+                spin_lock(&adapter->tmreg_lock);
+                ts = timespec_add(adapter->perout[0].start,
+                                  adapter->perout[0].period);
+                wr32(E1000_TRGTTIML0, ts.tv_nsec);
+                wr32(E1000_TRGTTIMH0, ts.tv_sec);
+                tsauxc = rd32(E1000_TSAUXC);
+                tsauxc |= TSAUXC_EN_TT0;
+                wr32(E1000_TSAUXC, tsauxc);
+                adapter->perout[0].start = ts;
+                spin_unlock(&adapter->tmreg_lock);
+                ack |= TSINTR_TT0;
+        }
+
+        if (tsicr & TSINTR_TT1) {
+                spin_lock(&adapter->tmreg_lock);
+                ts = timespec_add(adapter->perout[1].start,
+                                  adapter->perout[1].period);
+                wr32(E1000_TRGTTIML1, ts.tv_nsec);
+                wr32(E1000_TRGTTIMH1, ts.tv_sec);
+                tsauxc = rd32(E1000_TSAUXC);
+                tsauxc |= TSAUXC_EN_TT1;
+                wr32(E1000_TSAUXC, tsauxc);
+                adapter->perout[1].start = ts;
+                spin_unlock(&adapter->tmreg_lock);
+                ack |= TSINTR_TT1;
+        }
+
+        if (tsicr & TSINTR_AUTT0) {
+                nsec = rd32(E1000_AUXSTMPL0);
+                sec  = rd32(E1000_AUXSTMPH0);
+                event.type = PTP_CLOCK_EXTTS;
+                event.index = 0;
+                event.timestamp = sec * 1000000000ULL + nsec;
+                ptp_clock_event(adapter->ptp_clock, &event);
+                ack |= TSINTR_AUTT0;
+        }
+
+        if (tsicr & TSINTR_AUTT1) {
+                nsec = rd32(E1000_AUXSTMPL1);
+                sec  = rd32(E1000_AUXSTMPH1);
+                event.type = PTP_CLOCK_EXTTS;
+                event.index = 1;
+                event.timestamp = sec * 1000000000ULL + nsec;
+                ptp_clock_event(adapter->ptp_clock, &event);
+                ack |= TSINTR_AUTT1;
+        }
+
+        /* acknowledge the interrupts */
+        wr32(E1000_TSICR, ack);
+}
+
 static irqreturn_t igb_msix_other(int irq, void *data)
 {
         struct igb_adapter *adapter = data;
@@ -5415,16 +5489,8 @@ static irqreturn_t igb_msix_other(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        if (icr & E1000_ICR_TS) {
-                u32 tsicr = rd32(E1000_TSICR);
-
-                if (tsicr & E1000_TSICR_TXTS) {
-                        /* acknowledge the interrupt */
-                        wr32(E1000_TSICR, E1000_TSICR_TXTS);
-                        /* retrieve hardware timestamp */
-                        schedule_work(&adapter->ptp_tx_work);
-                }
-        }
+        if (icr & E1000_ICR_TS)
+                igb_tsync_interrupt(adapter);
 
         wr32(E1000_EIMS, adapter->eims_other);
 
@@ -6011,8 +6077,12 @@ static void igb_vf_reset_msg(struct igb_adapter *adapter, u32 vf)
         adapter->vf_data[vf].flags |= IGB_VF_FLAG_CTS;
 
         /* reply to reset with ack and vf mac address */
-        msgbuf[0] = E1000_VF_RESET | E1000_VT_MSGTYPE_ACK;
-        memcpy(addr, vf_mac, ETH_ALEN);
+        if (!is_zero_ether_addr(vf_mac)) {
+                msgbuf[0] = E1000_VF_RESET | E1000_VT_MSGTYPE_ACK;
+                memcpy(addr, vf_mac, ETH_ALEN);
+        } else {
+                msgbuf[0] = E1000_VF_RESET | E1000_VT_MSGTYPE_NACK;
+        }
         igb_write_mbx(hw, msgbuf, 3, vf);
 }
 
@@ -6203,16 +6273,8 @@ static irqreturn_t igb_intr_msi(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        if (icr & E1000_ICR_TS) {
-                u32 tsicr = rd32(E1000_TSICR);
-
-                if (tsicr & E1000_TSICR_TXTS) {
-                        /* acknowledge the interrupt */
-                        wr32(E1000_TSICR, E1000_TSICR_TXTS);
-                        /* retrieve hardware timestamp */
-                        schedule_work(&adapter->ptp_tx_work);
-                }
-        }
+        if (icr & E1000_ICR_TS)
+                igb_tsync_interrupt(adapter);
 
         napi_schedule(&q_vector->napi);
 
@@ -6257,16 +6319,8 @@ static irqreturn_t igb_intr(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        if (icr & E1000_ICR_TS) {
-                u32 tsicr = rd32(E1000_TSICR);
-
-                if (tsicr & E1000_TSICR_TXTS) {
-                        /* acknowledge the interrupt */
-                        wr32(E1000_TSICR, E1000_TSICR_TXTS);
-                        /* retrieve hardware timestamp */
-                        schedule_work(&adapter->ptp_tx_work);
-                }
-        }
+        if (icr & E1000_ICR_TS)
+                igb_tsync_interrupt(adapter);
 
         napi_schedule(&q_vector->napi);
 
@@ -6527,15 +6581,17 @@ static void igb_reuse_rx_page(struct igb_ring *rx_ring,
                                          DMA_FROM_DEVICE);
 }
 
+static inline bool igb_page_is_reserved(struct page *page)
+{
+        return (page_to_nid(page) != numa_mem_id()) || page->pfmemalloc;
+}
+
 static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer,
                                   struct page *page,
                                   unsigned int truesize)
 {
         /* avoid re-using remote pages */
-        if (unlikely(page_to_nid(page) != numa_node_id()))
-                return false;
-
-        if (unlikely(page->pfmemalloc))
+        if (unlikely(igb_page_is_reserved(page)))
                 return false;
 
 #if (PAGE_SIZE < 8192)
@@ -6545,22 +6601,19 @@ static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer,
 
         /* flip page offset to other buffer */
         rx_buffer->page_offset ^= IGB_RX_BUFSZ;
-
-        /* Even if we own the page, we are not allowed to use atomic_set()
-         * This would break get_page_unless_zero() users.
-         */
-        atomic_inc(&page->_count);
 #else
         /* move offset up to the next cache line */
         rx_buffer->page_offset += truesize;
 
         if (rx_buffer->page_offset > (PAGE_SIZE - IGB_RX_BUFSZ))
                 return false;
-
-        /* bump ref count on page before it is given to the stack */
-        get_page(page);
 #endif
 
+        /* Even if we own the page, we are not allowed to use atomic_set()
+         * This would break get_page_unless_zero() users.
+         */
+        atomic_inc(&page->_count);
+
         return true;
 }
 
@@ -6603,13 +6656,12 @@ static bool igb_add_rx_frag(struct igb_ring *rx_ring,
 
                 memcpy(__skb_put(skb, size), va, ALIGN(size, sizeof(long)));
 
-                /* we can reuse buffer as-is, just make sure it is local */
-                if (likely((page_to_nid(page) == numa_node_id()) &&
-                           !page->pfmemalloc))
+                /* page is not reserved, we can reuse buffer as-is */
+                if (likely(!igb_page_is_reserved(page)))
                         return true;
 
                 /* this page cannot be reused so discard it */
-                put_page(page);
+                __free_page(page);
                 return false;
         }
 
@@ -6627,7 +6679,6 @@ static struct sk_buff *igb_fetch_rx_buffer(struct igb_ring *rx_ring,
         struct page *page;
 
         rx_buffer = &rx_ring->rx_buffer_info[rx_ring->next_to_clean];
-
         page = rx_buffer->page;
         prefetchw(page);
 
@@ -7042,8 +7093,8 @@ void igb_alloc_rx_buffers(struct igb_ring *rx_ring, u16 cleaned_count)
                         i -= rx_ring->count;
                 }
 
-                /* clear the hdr_addr for the next_to_use descriptor */
-                rx_desc->read.hdr_addr = 0;
+                /* clear the status bits for the next_to_use descriptor */
+                rx_desc->wb.upper.status_error = 0;
 
                 cleaned_count--;
         } while (cleaned_count);
diff --git a/drivers/net/ethernet/intel/igb/igb_ptp.c b/drivers/net/ethernet/intel/igb/igb_ptp.c
index 794c139f0cc0..d20fc8ed11f1 100644
--- a/drivers/net/ethernet/intel/igb/igb_ptp.c
+++ b/drivers/net/ethernet/intel/igb/igb_ptp.c
@@ -256,14 +256,9 @@ static int igb_ptp_adjtime_82576(struct ptp_clock_info *ptp, s64 delta)
         struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
                                                ptp_caps);
         unsigned long flags;
-        s64 now;
 
         spin_lock_irqsave(&igb->tmreg_lock, flags);
-
-        now = timecounter_read(&igb->tc);
-        now += delta;
-        timecounter_init(&igb->tc, &igb->cc, now);
-
+        timecounter_adjtime(&igb->tc, delta);
         spin_unlock_irqrestore(&igb->tmreg_lock, flags);
 
         return 0;
@@ -360,12 +355,239 @@ static int igb_ptp_settime_i210(struct ptp_clock_info *ptp,
         return 0;
 }
 
+static void igb_pin_direction(int pin, int input, u32 *ctrl, u32 *ctrl_ext)
+{
+        u32 *ptr = pin < 2 ? ctrl : ctrl_ext;
+        u32 mask[IGB_N_SDP] = {
+                E1000_CTRL_SDP0_DIR,
+                E1000_CTRL_SDP1_DIR,
+                E1000_CTRL_EXT_SDP2_DIR,
+                E1000_CTRL_EXT_SDP3_DIR,
+        };
+
+        if (input)
+                *ptr &= ~mask[pin];
+        else
+                *ptr |= mask[pin];
+}
+
+static void igb_pin_extts(struct igb_adapter *igb, int chan, int pin)
+{
+        struct e1000_hw *hw = &igb->hw;
+        u32 aux0_sel_sdp[IGB_N_SDP] = {
+                AUX0_SEL_SDP0, AUX0_SEL_SDP1, AUX0_SEL_SDP2, AUX0_SEL_SDP3,
+        };
+        u32 aux1_sel_sdp[IGB_N_SDP] = {
+                AUX1_SEL_SDP0, AUX1_SEL_SDP1, AUX1_SEL_SDP2, AUX1_SEL_SDP3,
+        };
+        u32 ts_sdp_en[IGB_N_SDP] = {
+                TS_SDP0_EN, TS_SDP1_EN, TS_SDP2_EN, TS_SDP3_EN,
+        };
+        u32 ctrl, ctrl_ext, tssdp = 0;
+
+        ctrl = rd32(E1000_CTRL);
+        ctrl_ext = rd32(E1000_CTRL_EXT);
+        tssdp = rd32(E1000_TSSDP);
+
+        igb_pin_direction(pin, 1, &ctrl, &ctrl_ext);
+
+        /* Make sure this pin is not enabled as an output. */
+        tssdp &= ~ts_sdp_en[pin];
+
+        if (chan == 1) {
+                tssdp &= ~AUX1_SEL_SDP3;
+                tssdp |= aux1_sel_sdp[pin] | AUX1_TS_SDP_EN;
+        } else {
+                tssdp &= ~AUX0_SEL_SDP3;
+                tssdp |= aux0_sel_sdp[pin] | AUX0_TS_SDP_EN;
+        }
+
+        wr32(E1000_TSSDP, tssdp);
+        wr32(E1000_CTRL, ctrl);
+        wr32(E1000_CTRL_EXT, ctrl_ext);
+}
+
+static void igb_pin_perout(struct igb_adapter *igb, int chan, int pin)
+{
+        struct e1000_hw *hw = &igb->hw;
+        u32 aux0_sel_sdp[IGB_N_SDP] = {
+                AUX0_SEL_SDP0, AUX0_SEL_SDP1, AUX0_SEL_SDP2, AUX0_SEL_SDP3,
+        };
+        u32 aux1_sel_sdp[IGB_N_SDP] = {
+                AUX1_SEL_SDP0, AUX1_SEL_SDP1, AUX1_SEL_SDP2, AUX1_SEL_SDP3,
+        };
+        u32 ts_sdp_en[IGB_N_SDP] = {
+                TS_SDP0_EN, TS_SDP1_EN, TS_SDP2_EN, TS_SDP3_EN,
+        };
+        u32 ts_sdp_sel_tt0[IGB_N_SDP] = {
+                TS_SDP0_SEL_TT0, TS_SDP1_SEL_TT0,
+                TS_SDP2_SEL_TT0, TS_SDP3_SEL_TT0,
+        };
+        u32 ts_sdp_sel_tt1[IGB_N_SDP] = {
+                TS_SDP0_SEL_TT1, TS_SDP1_SEL_TT1,
+                TS_SDP2_SEL_TT1, TS_SDP3_SEL_TT1,
+        };
+        u32 ts_sdp_sel_clr[IGB_N_SDP] = {
+                TS_SDP0_SEL_FC1, TS_SDP1_SEL_FC1,
+                TS_SDP2_SEL_FC1, TS_SDP3_SEL_FC1,
+        };
+        u32 ctrl, ctrl_ext, tssdp = 0;
+
+        ctrl = rd32(E1000_CTRL);
+        ctrl_ext = rd32(E1000_CTRL_EXT);
+        tssdp = rd32(E1000_TSSDP);
+
+        igb_pin_direction(pin, 0, &ctrl, &ctrl_ext);
+
+        /* Make sure this pin is not enabled as an input. */
+        if ((tssdp & AUX0_SEL_SDP3) == aux0_sel_sdp[pin])
+                tssdp &= ~AUX0_TS_SDP_EN;
+
+        if ((tssdp & AUX1_SEL_SDP3) == aux1_sel_sdp[pin])
+                tssdp &= ~AUX1_TS_SDP_EN;
+
+        tssdp &= ~ts_sdp_sel_clr[pin];
+        if (chan == 1)
+                tssdp |= ts_sdp_sel_tt1[pin];
+        else
+                tssdp |= ts_sdp_sel_tt0[pin];
+
+        tssdp |= ts_sdp_en[pin];
+
+        wr32(E1000_TSSDP, tssdp);
+        wr32(E1000_CTRL, ctrl);
+        wr32(E1000_CTRL_EXT, ctrl_ext);
+}
+
+static int igb_ptp_feature_enable_i210(struct ptp_clock_info *ptp,
+                                       struct ptp_clock_request *rq, int on)
+{
+        struct igb_adapter *igb =
+                container_of(ptp, struct igb_adapter, ptp_caps);
+        struct e1000_hw *hw = &igb->hw;
+        u32 tsauxc, tsim, tsauxc_mask, tsim_mask, trgttiml, trgttimh;
+        unsigned long flags;
+        struct timespec ts;
+        int pin;
+        s64 ns;
+
+        switch (rq->type) {
+        case PTP_CLK_REQ_EXTTS:
+                if (on) {
+                        pin = ptp_find_pin(igb->ptp_clock, PTP_PF_EXTTS,
+                                           rq->extts.index);
+                        if (pin < 0)
+                                return -EBUSY;
+                }
+                if (rq->extts.index == 1) {
+                        tsauxc_mask = TSAUXC_EN_TS1;
+                        tsim_mask = TSINTR_AUTT1;
+                } else {
+                        tsauxc_mask = TSAUXC_EN_TS0;
+                        tsim_mask = TSINTR_AUTT0;
+                }
+                spin_lock_irqsave(&igb->tmreg_lock, flags);
+                tsauxc = rd32(E1000_TSAUXC);
+                tsim = rd32(E1000_TSIM);
+                if (on) {
+                        igb_pin_extts(igb, rq->extts.index, pin);
+                        tsauxc |= tsauxc_mask;
+                        tsim |= tsim_mask;
+                } else {
+                        tsauxc &= ~tsauxc_mask;
+                        tsim &= ~tsim_mask;
+                }
+                wr32(E1000_TSAUXC, tsauxc);
+                wr32(E1000_TSIM, tsim);
+                spin_unlock_irqrestore(&igb->tmreg_lock, flags);
+                return 0;
+
+        case PTP_CLK_REQ_PEROUT:
+                if (on) {
+                        pin = ptp_find_pin(igb->ptp_clock, PTP_PF_PEROUT,
+                                           rq->perout.index);
+                        if (pin < 0)
+                                return -EBUSY;
+                }
+                ts.tv_sec = rq->perout.period.sec;
+                ts.tv_nsec = rq->perout.period.nsec;
+                ns = timespec_to_ns(&ts);
+                ns = ns >> 1;
+                if (on && ns < 500000LL) {
+                        /* 2k interrupts per second is an awful lot. */
+                        return -EINVAL;
+                }
+                ts = ns_to_timespec(ns);
+                if (rq->perout.index == 1) {
+                        tsauxc_mask = TSAUXC_EN_TT1;
+                        tsim_mask = TSINTR_TT1;
+                        trgttiml = E1000_TRGTTIML1;
+                        trgttimh = E1000_TRGTTIMH1;
+                } else {
+                        tsauxc_mask = TSAUXC_EN_TT0;
+                        tsim_mask = TSINTR_TT0;
+                        trgttiml = E1000_TRGTTIML0;
+                        trgttimh = E1000_TRGTTIMH0;
+                }
+                spin_lock_irqsave(&igb->tmreg_lock, flags);
+                tsauxc = rd32(E1000_TSAUXC);
+                tsim = rd32(E1000_TSIM);
+                if (on) {
+                        int i = rq->perout.index;
+
+                        igb_pin_perout(igb, i, pin);
+                        igb->perout[i].start.tv_sec = rq->perout.start.sec;
+                        igb->perout[i].start.tv_nsec = rq->perout.start.nsec;
+                        igb->perout[i].period.tv_sec = ts.tv_sec;
+                        igb->perout[i].period.tv_nsec = ts.tv_nsec;
+                        wr32(trgttiml, rq->perout.start.sec);
+                        wr32(trgttimh, rq->perout.start.nsec);
+                        tsauxc |= tsauxc_mask;
+                        tsim |= tsim_mask;
+                } else {
+                        tsauxc &= ~tsauxc_mask;
+                        tsim &= ~tsim_mask;
+                }
+                wr32(E1000_TSAUXC, tsauxc);
+                wr32(E1000_TSIM, tsim);
+                spin_unlock_irqrestore(&igb->tmreg_lock, flags);
+                return 0;
+
+        case PTP_CLK_REQ_PPS:
+                spin_lock_irqsave(&igb->tmreg_lock, flags);
+                tsim = rd32(E1000_TSIM);
+                if (on)
+                        tsim |= TSINTR_SYS_WRAP;
+                else
+                        tsim &= ~TSINTR_SYS_WRAP;
+                wr32(E1000_TSIM, tsim);
+                spin_unlock_irqrestore(&igb->tmreg_lock, flags);
+                return 0;
+        }
+
+        return -EOPNOTSUPP;
+}
+
 static int igb_ptp_feature_enable(struct ptp_clock_info *ptp,
                                   struct ptp_clock_request *rq, int on)
 {
         return -EOPNOTSUPP;
 }
 
+static int igb_ptp_verify_pin(struct ptp_clock_info *ptp, unsigned int pin,
+                              enum ptp_pin_function func, unsigned int chan)
+{
+        switch (func) {
+        case PTP_PF_NONE:
+        case PTP_PF_EXTTS:
+        case PTP_PF_PEROUT:
+                break;
+        case PTP_PF_PHYSYNC:
+                return -1;
+        }
+        return 0;
+}
+
 /**
  * igb_ptp_tx_work
  * @work: pointer to work struct
@@ -756,6 +978,7 @@ void igb_ptp_init(struct igb_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
         struct net_device *netdev = adapter->netdev;
+        int i;
 
         switch (hw->mac.type) {
         case e1000_82576:
@@ -770,7 +993,7 @@ void igb_ptp_init(struct igb_adapter *adapter)
                 adapter->ptp_caps.settime = igb_ptp_settime_82576;
                 adapter->ptp_caps.enable = igb_ptp_feature_enable;
                 adapter->cc.read = igb_ptp_read_82576;
-                adapter->cc.mask = CLOCKSOURCE_MASK(64);
+                adapter->cc.mask = CYCLECOUNTER_MASK(64);
                 adapter->cc.mult = 1;
                 adapter->cc.shift = IGB_82576_TSYNC_SHIFT;
                 /* Dial the nominal frequency. */
@@ -790,7 +1013,7 @@ void igb_ptp_init(struct igb_adapter *adapter)
                 adapter->ptp_caps.settime = igb_ptp_settime_82576;
                 adapter->ptp_caps.enable = igb_ptp_feature_enable;
                 adapter->cc.read = igb_ptp_read_82580;
-                adapter->cc.mask = CLOCKSOURCE_MASK(IGB_NBITS_82580);
+                adapter->cc.mask = CYCLECOUNTER_MASK(IGB_NBITS_82580);
                 adapter->cc.mult = 1;
                 adapter->cc.shift = 0;
                 /* Enable the timer functions by clearing bit 31. */
@@ -798,16 +1021,27 @@ void igb_ptp_init(struct igb_adapter *adapter)
                 break;
         case e1000_i210:
         case e1000_i211:
+                for (i = 0; i < IGB_N_SDP; i++) {
+                        struct ptp_pin_desc *ppd = &adapter->sdp_config[i];
+
+                        snprintf(ppd->name, sizeof(ppd->name), "SDP%d", i);
+                        ppd->index = i;
+                        ppd->func = PTP_PF_NONE;
+                }
                 snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr);
                 adapter->ptp_caps.owner = THIS_MODULE;
                 adapter->ptp_caps.max_adj = 62499999;
-                adapter->ptp_caps.n_ext_ts = 0;
-                adapter->ptp_caps.pps = 0;
+                adapter->ptp_caps.n_ext_ts = IGB_N_EXTTS;
+                adapter->ptp_caps.n_per_out = IGB_N_PEROUT;
+                adapter->ptp_caps.n_pins = IGB_N_SDP;
+                adapter->ptp_caps.pps = 1;
+                adapter->ptp_caps.pin_config = adapter->sdp_config;
                 adapter->ptp_caps.adjfreq = igb_ptp_adjfreq_82580;
                 adapter->ptp_caps.adjtime = igb_ptp_adjtime_i210;
                 adapter->ptp_caps.gettime = igb_ptp_gettime_i210;
                 adapter->ptp_caps.settime = igb_ptp_settime_i210;
-                adapter->ptp_caps.enable = igb_ptp_feature_enable;
+                adapter->ptp_caps.enable = igb_ptp_feature_enable_i210;
+                adapter->ptp_caps.verify = igb_ptp_verify_pin;
                 /* Enable the timer functions by clearing bit 31. */
                 wr32(E1000_TSAUXC, 0x0);
                 break;
@@ -905,6 +1139,7 @@ void igb_ptp_stop(struct igb_adapter *adapter)
 void igb_ptp_reset(struct igb_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
+        unsigned long flags;
 
         if (!(adapter->flags & IGB_FLAG_PTP))
                 return;
@@ -912,6 +1147,8 @@ void igb_ptp_reset(struct igb_adapter *adapter)
         /* reset the tstamp_config */
         igb_ptp_set_timestamp_mode(adapter, &adapter->tstamp_config);
 
+        spin_lock_irqsave(&adapter->tmreg_lock, flags);
+
         switch (adapter->hw.mac.type) {
         case e1000_82576:
                 /* Dial the nominal frequency. */
@@ -922,23 +1159,25 @@ void igb_ptp_reset(struct igb_adapter *adapter)
         case e1000_i350:
         case e1000_i210:
         case e1000_i211:
-                /* Enable the timer functions and interrupts. */
                 wr32(E1000_TSAUXC, 0x0);
+                wr32(E1000_TSSDP, 0x0);
                 wr32(E1000_TSIM, TSYNC_INTERRUPTS);
                 wr32(E1000_IMS, E1000_IMS_TS);
                 break;
         default:
                 /* No work to do. */
-                return;
+                goto out;
         }
 
         /* Re-initialize the timer. */
         if ((hw->mac.type == e1000_i210) || (hw->mac.type == e1000_i211)) {
                 struct timespec ts = ktime_to_timespec(ktime_get_real());
 
-                igb_ptp_settime_i210(&adapter->ptp_caps, &ts);
+                igb_ptp_write_i210(adapter, &ts);
         } else {
                 timecounter_init(&adapter->tc, &adapter->cc,
                                  ktime_to_ns(ktime_get_real()));
         }
+out:
+        spin_unlock_irqrestore(&adapter->tmreg_lock, flags);
 }
diff --git a/drivers/net/ethernet/intel/igbvf/netdev.c b/drivers/net/ethernet/intel/igbvf/netdev.c
index edea13b0ee85..ebf9d4a42fdd 100644
--- a/drivers/net/ethernet/intel/igbvf/netdev.c
+++ b/drivers/net/ethernet/intel/igbvf/netdev.c
@@ -2237,9 +2237,10 @@ static netdev_tx_t igbvf_xmit_frame_ring_adv(struct sk_buff *skb,
                 return NETDEV_TX_BUSY;
         }
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 tx_flags |= IGBVF_TX_FLAGS_VLAN;
-                tx_flags |= (vlan_tx_tag_get(skb) << IGBVF_TX_FLAGS_VLAN_SHIFT);
+                tx_flags |= (skb_vlan_tag_get(skb) <<
+                             IGBVF_TX_FLAGS_VLAN_SHIFT);
         }
 
         if (protocol == htons(ETH_P_IP))
diff --git a/drivers/net/ethernet/intel/ixgb/ixgb_main.c b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
index aa87605b144a..11a1bdbe3fd9 100644
--- a/drivers/net/ethernet/intel/ixgb/ixgb_main.c
+++ b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
@@ -1532,9 +1532,9 @@ ixgb_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                      DESC_NEEDED)))
                 return NETDEV_TX_BUSY;
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 tx_flags |= IXGB_TX_FLAGS_VLAN;
-                vlan_id = vlan_tx_tag_get(skb);
+                vlan_id = skb_vlan_tag_get(skb);
         }
 
         first = adapter->tx_ring.next_to_use;
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe.h b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
index b6137be43920..7dcbbec09a70 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
@@ -38,7 +38,7 @@
 #include <linux/if_vlan.h>
 #include <linux/jiffies.h>
 
-#include <linux/clocksource.h>
+#include <linux/timecounter.h>
 #include <linux/net_tstamp.h>
 #include <linux/ptp_clock_kernel.h>
 
@@ -76,6 +76,8 @@
 #define IXGBE_MAX_RXD                      4096
 #define IXGBE_MIN_RXD                        64
 
+#define IXGBE_ETH_P_LLDP                 0x88CC
+
 /* flow control */
 #define IXGBE_MIN_FCRTL                    0x40
 #define IXGBE_MAX_FCRTL                 0x7FF80
@@ -753,6 +755,7 @@ struct ixgbe_adapter {
         u32 timer_event_accumulator;
         u32 vferr_refcount;
         struct ixgbe_mac_addr *mac_table;
+        u16 vxlan_port;
         struct kobject *info_kobj;
 #ifdef CONFIG_IXGBE_HWMON
         struct hwmon_buff *ixgbe_hwmon_buff;
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index 67b02bde179e..70cc4c5c0a01 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -50,6 +50,7 @@
 #include <linux/if_bridge.h>
 #include <linux/prefetch.h>
 #include <scsi/fc/fc_fcoe.h>
+#include <net/vxlan.h>
 
 #ifdef CONFIG_OF
 #include <linux/of_net.h>
@@ -1396,12 +1397,23 @@ static inline void ixgbe_rx_checksum(struct ixgbe_ring *ring,
                                      union ixgbe_adv_rx_desc *rx_desc,
                                      struct sk_buff *skb)
 {
+        __le16 pkt_info = rx_desc->wb.lower.lo_dword.hs_rss.pkt_info;
+        __le16 hdr_info = rx_desc->wb.lower.lo_dword.hs_rss.hdr_info;
+        bool encap_pkt = false;
+
         skb_checksum_none_assert(skb);
 
         /* Rx csum disabled */
         if (!(ring->netdev->features & NETIF_F_RXCSUM))
                 return;
 
+        if ((pkt_info & cpu_to_le16(IXGBE_RXDADV_PKTTYPE_VXLAN)) &&
+            (hdr_info & cpu_to_le16(IXGBE_RXDADV_PKTTYPE_TUNNEL >> 16))) {
+                encap_pkt = true;
+                skb->encapsulation = 1;
+                skb->ip_summed = CHECKSUM_NONE;
+        }
+
         /* if IP and error */
         if (ixgbe_test_staterr(rx_desc, IXGBE_RXD_STAT_IPCS) &&
             ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_ERR_IPE)) {
@@ -1413,8 +1425,6 @@ static inline void ixgbe_rx_checksum(struct ixgbe_ring *ring,
                 return;
 
         if (ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_ERR_TCPE)) {
-                __le16 pkt_info = rx_desc->wb.lower.lo_dword.hs_rss.pkt_info;
-
                 /*
                  * 82599 errata, UDP frames with a 0 checksum can be marked as
                  * checksum errors.
@@ -1429,6 +1439,17 @@ static inline void ixgbe_rx_checksum(struct ixgbe_ring *ring,
 
         /* It must be a TCP or UDP packet with a valid checksum */
         skb->ip_summed = CHECKSUM_UNNECESSARY;
+        if (encap_pkt) {
+                if (!ixgbe_test_staterr(rx_desc, IXGBE_RXD_STAT_OUTERIPCS))
+                        return;
+
+                if (ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_ERR_OUTERIPER)) {
+                        ring->rx_stats.csum_err++;
+                        return;
+                }
+                /* If we checked the outer header let the stack know */
+                skb->csum_level = 1;
+        }
 }
 
 static bool ixgbe_alloc_mapped_page(struct ixgbe_ring *rx_ring,
@@ -3564,10 +3585,24 @@ static void ixgbe_configure_virtualization(struct ixgbe_adapter *adapter)
         /* Enable MAC Anti-Spoofing */
         hw->mac.ops.set_mac_anti_spoofing(hw, (adapter->num_vfs != 0),
                                           adapter->num_vfs);
+
+        /* Ensure LLDP is set for Ethertype Antispoofing if we will be
+         * calling set_ethertype_anti_spoofing for each VF in loop below
+         */
+        if (hw->mac.ops.set_ethertype_anti_spoofing)
+                IXGBE_WRITE_REG(hw, IXGBE_ETQF(IXGBE_ETQF_FILTER_LLDP),
+                                (IXGBE_ETQF_FILTER_EN    | /* enable filter */
+                                 IXGBE_ETQF_TX_ANTISPOOF | /* tx antispoof */
+                                 IXGBE_ETH_P_LLDP));       /* LLDP eth type */
+
         /* For VFs that have spoof checking turned off */
         for (i = 0; i < adapter->num_vfs; i++) {
                 if (!adapter->vfinfo[i].spoofchk_enabled)
                         ixgbe_ndo_set_vf_spoofchk(adapter->netdev, i, false);
+
+                /* enable ethertype anti spoofing if hw supports it */
+                if (hw->mac.ops.set_ethertype_anti_spoofing)
+                        hw->mac.ops.set_ethertype_anti_spoofing(hw, true, i);
         }
 }
 
@@ -5627,6 +5662,10 @@ static int ixgbe_open(struct net_device *netdev)
 
         ixgbe_up_complete(adapter);
 
+#if IS_ENABLED(CONFIG_IXGBE_VXLAN)
+        vxlan_get_rx_port(netdev);
+
+#endif
         return 0;
 
 err_set_queues:
@@ -7217,8 +7256,8 @@ netdev_tx_t ixgbe_xmit_frame_ring(struct sk_buff *skb,
         first->gso_segs = 1;
 
         /* if we have a HW VLAN tag being added default to the HW one */
-        if (vlan_tx_tag_present(skb)) {
-                tx_flags |= vlan_tx_tag_get(skb) << IXGBE_TX_FLAGS_VLAN_SHIFT;
+        if (skb_vlan_tag_present(skb)) {
+                tx_flags |= skb_vlan_tag_get(skb) << IXGBE_TX_FLAGS_VLAN_SHIFT;
                 tx_flags |= IXGBE_TX_FLAGS_HW_VLAN;
         /* else if it is a SW VLAN check the next protocol and store the tag */
         } else if (protocol == htons(ETH_P_8021Q)) {
@@ -7771,6 +7810,64 @@ static int ixgbe_set_features(struct net_device *netdev,
         return 0;
 }
 
+/**
+ * ixgbe_add_vxlan_port - Get notifications about VXLAN ports that come up
+ * @dev: The port's netdev
+ * @sa_family: Socket Family that VXLAN is notifiying us about
+ * @port: New UDP port number that VXLAN started listening to
+ **/
+static void ixgbe_add_vxlan_port(struct net_device *dev, sa_family_t sa_family,
+                                 __be16 port)
+{
+        struct ixgbe_adapter *adapter = netdev_priv(dev);
+        struct ixgbe_hw *hw = &adapter->hw;
+        u16 new_port = ntohs(port);
+
+        if (sa_family == AF_INET6)
+                return;
+
+        if (adapter->vxlan_port == new_port) {
+                netdev_info(dev, "Port %d already offloaded\n", new_port);
+                return;
+        }
+
+        if (adapter->vxlan_port) {
+                netdev_info(dev,
+                            "Hit Max num of UDP ports, not adding port %d\n",
+                            new_port);
+                return;
+        }
+
+        adapter->vxlan_port = new_port;
+        IXGBE_WRITE_REG(hw, IXGBE_VXLANCTRL, new_port);
+}
+
+/**
+ * ixgbe_del_vxlan_port - Get notifications about VXLAN ports that go away
+ * @dev: The port's netdev
+ * @sa_family: Socket Family that VXLAN is notifying us about
+ * @port: UDP port number that VXLAN stopped listening to
+ **/
+static void ixgbe_del_vxlan_port(struct net_device *dev, sa_family_t sa_family,
+                                 __be16 port)
+{
+        struct ixgbe_adapter *adapter = netdev_priv(dev);
+        struct ixgbe_hw *hw = &adapter->hw;
+        u16 new_port = ntohs(port);
+
+        if (sa_family == AF_INET6)
+                return;
+
+        if (adapter->vxlan_port != new_port) {
+                netdev_info(dev, "Port %d was not found, not deleting\n",
+                            new_port);
+                return;
+        }
+
+        adapter->vxlan_port = 0;
+        IXGBE_WRITE_REG(hw, IXGBE_VXLANCTRL, 0);
+}
+
 static int ixgbe_ndo_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
                              struct net_device *dev,
                              const unsigned char *addr, u16 vid,
@@ -7786,7 +7883,7 @@ static int ixgbe_ndo_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
 }
 
 static int ixgbe_ndo_bridge_setlink(struct net_device *dev,
-                                    struct nlmsghdr *nlh)
+                                    struct nlmsghdr *nlh, u16 flags)
 {
         struct ixgbe_adapter *adapter = netdev_priv(dev);
         struct nlattr *attr, *br_spec;
@@ -7982,6 +8079,8 @@ static const struct net_device_ops ixgbe_netdev_ops = {
         .ndo_bridge_getlink     = ixgbe_ndo_bridge_getlink,
         .ndo_dfwd_add_station   = ixgbe_fwd_add,
         .ndo_dfwd_del_station   = ixgbe_fwd_del,
+        .ndo_add_vxlan_port     = ixgbe_add_vxlan_port,
+        .ndo_del_vxlan_port     = ixgbe_del_vxlan_port,
 };
 
 /**
@@ -8339,6 +8438,15 @@ skip_sriov:
         netdev->priv_flags |= IFF_UNICAST_FLT;
         netdev->priv_flags |= IFF_SUPP_NOFCS;
 
+        switch (adapter->hw.mac.type) {
+        case ixgbe_mac_X550:
+        case ixgbe_mac_X550EM_x:
+                netdev->hw_enc_features |= NETIF_F_RXCSUM;
+                break;
+        default:
+                break;
+        }
+
 #ifdef CONFIG_IXGBE_DCB
         netdev->dcbnl_ops = &dcbnl_ops;
 #endif
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
index 5fd4b5271f9a..79c00f57d3e7 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
@@ -261,18 +261,9 @@ static int ixgbe_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
         struct ixgbe_adapter *adapter =
                 container_of(ptp, struct ixgbe_adapter, ptp_caps);
         unsigned long flags;
-        u64 now;
 
         spin_lock_irqsave(&adapter->tmreg_lock, flags);
-
-        now = timecounter_read(&adapter->tc);
-        now += delta;
-
-        /* reset the timecounter */
-        timecounter_init(&adapter->tc,
-                         &adapter->cc,
-                         now);
-
+        timecounter_adjtime(&adapter->tc, delta);
         spin_unlock_irqrestore(&adapter->tmreg_lock, flags);
 
         ixgbe_ptp_setup_sdp(adapter);
@@ -802,7 +793,7 @@ void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter)
 
         memset(&adapter->cc, 0, sizeof(adapter->cc));
         adapter->cc.read = ixgbe_ptp_read;
-        adapter->cc.mask = CLOCKSOURCE_MASK(64);
+        adapter->cc.mask = CYCLECOUNTER_MASK(64);
         adapter->cc.shift = shift;
         adapter->cc.mult = 1;
 
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
index c76ba90ecc6e..7f37fe7269a7 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
@@ -101,9 +101,6 @@ static int __ixgbe_enable_sriov(struct ixgbe_adapter *adapter)
                         adapter->dcb_cfg.num_tcs.pfc_tcs = 1;
                 }
 
-                /* We do not support RSS w/ SR-IOV */
-                adapter->ring_feature[RING_F_RSS].limit = 1;
-
                 /* Disable RSC when in SR-IOV mode */
                 adapter->flags2 &= ~(IXGBE_FLAG2_RSC_CAPABLE |
                                      IXGBE_FLAG2_RSC_ENABLED);
@@ -1097,14 +1094,12 @@ static int ixgbe_enable_port_vlan(struct ixgbe_adapter *adapter, int vf,
                                   u16 vlan, u8 qos)
 {
         struct ixgbe_hw *hw = &adapter->hw;
-        int err = 0;
+        int err;
 
-        if (adapter->vfinfo[vf].pf_vlan)
-                err = ixgbe_set_vf_vlan(adapter, false,
-                                        adapter->vfinfo[vf].pf_vlan,
-                                        vf);
+        err = ixgbe_set_vf_vlan(adapter, true, vlan, vf);
         if (err)
                 goto out;
+
         ixgbe_set_vmvir(adapter, vlan, qos, vf);
         ixgbe_set_vmolr(hw, vf, false);
         if (adapter->vfinfo[vf].spoofchk_enabled)
@@ -1143,6 +1138,11 @@ static int ixgbe_disable_port_vlan(struct ixgbe_adapter *adapter, int vf)
         hw->mac.ops.set_vlan_anti_spoofing(hw, false, vf);
         if (adapter->vfinfo[vf].vlan_count)
                 adapter->vfinfo[vf].vlan_count--;
+
+        /* disable hide VLAN on X550 */
+        if (hw->mac.type >= ixgbe_mac_X550)
+                ixgbe_write_qde(adapter, vf, IXGBE_QDE_ENABLE);
+
         adapter->vfinfo[vf].pf_vlan = 0;
         adapter->vfinfo[vf].pf_qos = 0;
 
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h
index d101b25dc4b6..fc5ecee56ca8 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h
@@ -378,6 +378,8 @@ struct ixgbe_thermal_sensor_data {
 #define IXGBE_SPOOF_MACAS_MASK          0xFF
 #define IXGBE_SPOOF_VLANAS_MASK         0xFF00
 #define IXGBE_SPOOF_VLANAS_SHIFT        8
+#define IXGBE_SPOOF_ETHERTYPEAS         0xFF000000
+#define IXGBE_SPOOF_ETHERTYPEAS_SHIFT   16
 #define IXGBE_PFVFSPOOF_REG_COUNT       8
 
 #define IXGBE_DCA_TXCTRL(_i)    (0x07200 + ((_i) * 4)) /* 16 of these (0-15) */
@@ -399,6 +401,7 @@ struct ixgbe_thermal_sensor_data {
 
 #define IXGBE_WUPL      0x05900
 #define IXGBE_WUPM      0x05A00 /* wake up pkt memory 0x5A00-0x5A7C */
+#define IXGBE_VXLANCTRL 0x0000507C /* Rx filter VXLAN UDPPORT Register */
 #define IXGBE_FHFT(_n)  (0x09000 + ((_n) * 0x100)) /* Flex host filter table */
 #define IXGBE_FHFT_EXT(_n)      (0x09800 + ((_n) * 0x100)) /* Ext Flexible Host
                                                             * Filter Table */
@@ -1540,6 +1543,7 @@ enum {
 #define IXGBE_MAX_ETQF_FILTERS  8
 #define IXGBE_ETQF_FCOE         0x08000000 /* bit 27 */
 #define IXGBE_ETQF_BCN          0x10000000 /* bit 28 */
+#define IXGBE_ETQF_TX_ANTISPOOF 0x20000000 /* bit 29 */
 #define IXGBE_ETQF_1588         0x40000000 /* bit 30 */
 #define IXGBE_ETQF_FILTER_EN    0x80000000 /* bit 31 */
 #define IXGBE_ETQF_POOL_ENABLE   (1 << 26) /* bit 26 */
@@ -1565,6 +1569,9 @@ enum {
 #define IXGBE_ETQF_FILTER_FCOE           2
 #define IXGBE_ETQF_FILTER_1588           3
 #define IXGBE_ETQF_FILTER_FIP            4
+#define IXGBE_ETQF_FILTER_LLDP           5
+#define IXGBE_ETQF_FILTER_LACP           6
+
 /* VLAN Control Bit Masks */
 #define IXGBE_VLNCTRL_VET       0x0000FFFF  /* bits 0-15 */
 #define IXGBE_VLNCTRL_CFI       0x10000000  /* bit 28 */
@@ -2122,6 +2129,7 @@ enum {
 #define IXGBE_RXD_STAT_IPCS     0x40    /* IP xsum calculated */
 #define IXGBE_RXD_STAT_PIF      0x80    /* passed in-exact filter */
 #define IXGBE_RXD_STAT_CRCV     0x100   /* Speculative CRC Valid */
+#define IXGBE_RXD_STAT_OUTERIPCS  0x100 /* Cloud IP xsum calculated */
 #define IXGBE_RXD_STAT_VEXT     0x200   /* 1st VLAN found */
 #define IXGBE_RXD_STAT_UDPV     0x400   /* Valid UDP checksum */
 #define IXGBE_RXD_STAT_DYNINT   0x800   /* Pkt caused INT via DYNINT */
@@ -2139,6 +2147,7 @@ enum {
 #define IXGBE_RXD_ERR_IPE       0x80    /* IP Checksum Error */
 #define IXGBE_RXDADV_ERR_MASK           0xfff00000 /* RDESC.ERRORS mask */
 #define IXGBE_RXDADV_ERR_SHIFT          20         /* RDESC.ERRORS shift */
+#define IXGBE_RXDADV_ERR_OUTERIPER      0x04000000 /* CRC IP Header error */
 #define IXGBE_RXDADV_ERR_FCEOFE         0x80000000 /* FCoEFe/IPE */
 #define IXGBE_RXDADV_ERR_FCERR          0x00700000 /* FCERR/FDIRERR */
 #define IXGBE_RXDADV_ERR_FDIR_LEN       0x00100000 /* FDIR Length error */
@@ -2227,6 +2236,8 @@ enum {
 #define IXGBE_RXDADV_PKTTYPE_UDP        0x00000200 /* UDP hdr present */
 #define IXGBE_RXDADV_PKTTYPE_SCTP       0x00000400 /* SCTP hdr present */
 #define IXGBE_RXDADV_PKTTYPE_NFS        0x00000800 /* NFS hdr present */
+#define IXGBE_RXDADV_PKTTYPE_VXLAN      0x00000800 /* VXLAN hdr present */
+#define IXGBE_RXDADV_PKTTYPE_TUNNEL     0x00010000 /* Tunnel type */
 #define IXGBE_RXDADV_PKTTYPE_IPSEC_ESP  0x00001000 /* IPSec ESP */
 #define IXGBE_RXDADV_PKTTYPE_IPSEC_AH   0x00002000 /* IPSec AH */
 #define IXGBE_RXDADV_PKTTYPE_LINKSEC    0x00004000 /* LinkSec Encap */
@@ -3056,6 +3067,7 @@ struct ixgbe_mac_operations {
         s32 (*set_fw_drv_ver)(struct ixgbe_hw *, u8, u8, u8, u8);
         s32 (*get_thermal_sensor_data)(struct ixgbe_hw *);
         s32 (*init_thermal_sensor_thresh)(struct ixgbe_hw *hw);
+        void (*set_ethertype_anti_spoofing)(struct ixgbe_hw *, bool, int);
 
         /* DMA Coalescing */
         s32 (*dmac_config)(struct ixgbe_hw *hw);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.c
index ba54ff07b438..49395420c9b3 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.c
@@ -55,9 +55,6 @@ s32 ixgbe_get_invariants_X540(struct ixgbe_hw *hw)
 {
         struct ixgbe_mac_info *mac = &hw->mac;
 
-        /* Call PHY identify routine to get the phy type */
-        ixgbe_identify_phy_generic(hw);
-
         mac->mcft_size = IXGBE_X540_MC_TBL_SIZE;
         mac->vft_size = IXGBE_X540_VFT_TBL_SIZE;
         mac->num_rar_entries = IXGBE_X540_RAR_ENTRIES;
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c
index ffdd1231f419..50bf81908dd6 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c
@@ -80,7 +80,7 @@ static s32 ixgbe_write_phy_reg_x550em(struct ixgbe_hw *hw, u32 reg_addr,
  *  Initializes the EEPROM parameters ixgbe_eeprom_info within the
  *  ixgbe_hw struct in order to set up EEPROM access.
  **/
-s32 ixgbe_init_eeprom_params_X550(struct ixgbe_hw *hw)
+static s32 ixgbe_init_eeprom_params_X550(struct ixgbe_hw *hw)
 {
         struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
         u32 eec;
@@ -110,8 +110,8 @@ s32 ixgbe_init_eeprom_params_X550(struct ixgbe_hw *hw)
  *  @device_type: 3 bit device type
  *  @phy_data: Pointer to read data from the register
  **/
-s32 ixgbe_read_iosf_sb_reg_x550(struct ixgbe_hw *hw, u32 reg_addr,
-                                u32 device_type, u32 *data)
+static s32 ixgbe_read_iosf_sb_reg_x550(struct ixgbe_hw *hw, u32 reg_addr,
+                                       u32 device_type, u32 *data)
 {
         u32 i, command, error;
 
@@ -158,7 +158,8 @@ s32 ixgbe_read_iosf_sb_reg_x550(struct ixgbe_hw *hw, u32 reg_addr,
  *
  *  Reads a 16 bit word from the EEPROM using the hostif.
  **/
-s32 ixgbe_read_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset, u16 *data)
+static s32 ixgbe_read_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset,
+                                          u16 *data)
 {
         s32 status;
         struct ixgbe_hic_read_shadow_ram buffer;
@@ -193,8 +194,8 @@ s32 ixgbe_read_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset, u16 *data)
  *
  *  Reads a 16 bit word(s) from the EEPROM using the hostif.
  **/
-s32 ixgbe_read_ee_hostif_buffer_X550(struct ixgbe_hw *hw,
-                                     u16 offset, u16 words, u16 *data)
+static s32 ixgbe_read_ee_hostif_buffer_X550(struct ixgbe_hw *hw,
+                                            u16 offset, u16 words, u16 *data)
 {
         struct ixgbe_hic_read_shadow_ram buffer;
         u32 current_word = 0;
@@ -331,7 +332,8 @@ static s32 ixgbe_checksum_ptr_x550(struct ixgbe_hw *hw, u16 ptr,
  *
  *  Returns a negative error code on error, or the 16-bit checksum
  **/
-s32 ixgbe_calc_checksum_X550(struct ixgbe_hw *hw, u16 *buffer, u32 buffer_size)
+static s32 ixgbe_calc_checksum_X550(struct ixgbe_hw *hw, u16 *buffer,
+                                    u32 buffer_size)
 {
         u16 eeprom_ptrs[IXGBE_EEPROM_LAST_WORD + 1];
         u16 *local_buffer;
@@ -407,7 +409,7 @@ s32 ixgbe_calc_checksum_X550(struct ixgbe_hw *hw, u16 *buffer, u32 buffer_size)
  *
  *  Returns a negative error code on error, or the 16-bit checksum
  **/
-s32 ixgbe_calc_eeprom_checksum_X550(struct ixgbe_hw *hw)
+static s32 ixgbe_calc_eeprom_checksum_X550(struct ixgbe_hw *hw)
 {
         return ixgbe_calc_checksum_X550(hw, NULL, 0);
 }
@@ -419,7 +421,7 @@ s32 ixgbe_calc_eeprom_checksum_X550(struct ixgbe_hw *hw)
  *
  *   Reads a 16 bit word from the EEPROM using the hostif.
  **/
-s32 ixgbe_read_ee_hostif_X550(struct ixgbe_hw *hw, u16 offset, u16 *data)
+static s32 ixgbe_read_ee_hostif_X550(struct ixgbe_hw *hw, u16 offset, u16 *data)
 {
         s32 status = 0;
 
@@ -440,7 +442,8 @@ s32 ixgbe_read_ee_hostif_X550(struct ixgbe_hw *hw, u16 offset, u16 *data)
  *  Performs checksum calculation and validates the EEPROM checksum.  If the
  *  caller does not need checksum_val, the value can be NULL.
  **/
-s32 ixgbe_validate_eeprom_checksum_X550(struct ixgbe_hw *hw, u16 *checksum_val)
+static s32 ixgbe_validate_eeprom_checksum_X550(struct ixgbe_hw *hw,
+                                               u16 *checksum_val)
 {
         s32 status;
         u16 checksum;
@@ -489,7 +492,8 @@ s32 ixgbe_validate_eeprom_checksum_X550(struct ixgbe_hw *hw, u16 *checksum_val)
  *
  *  Write a 16 bit word to the EEPROM using the hostif.
  **/
-s32 ixgbe_write_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset, u16 data)
+static s32 ixgbe_write_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset,
+                                           u16 data)
 {
         s32 status;
         struct ixgbe_hic_write_shadow_ram buffer;
@@ -517,7 +521,7 @@ s32 ixgbe_write_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset, u16 data)
  *
  *  Write a 16 bit word to the EEPROM using the hostif.
  **/
-s32 ixgbe_write_ee_hostif_X550(struct ixgbe_hw *hw, u16 offset, u16 data)
+static s32 ixgbe_write_ee_hostif_X550(struct ixgbe_hw *hw, u16 offset, u16 data)
 {
         s32 status = 0;
 
@@ -537,7 +541,7 @@ s32 ixgbe_write_ee_hostif_X550(struct ixgbe_hw *hw, u16 offset, u16 data)
  *
  *  Issue a shadow RAM dump to FW to copy EEPROM from shadow RAM to the flash.
  **/
-s32 ixgbe_update_flash_X550(struct ixgbe_hw *hw)
+static s32 ixgbe_update_flash_X550(struct ixgbe_hw *hw)
 {
         s32 status = 0;
         union ixgbe_hic_hdr2 buffer;
@@ -560,7 +564,7 @@ s32 ixgbe_update_flash_X550(struct ixgbe_hw *hw)
  *  checksum and updates the EEPROM and instructs the hardware to update
  *  the flash.
  **/
-s32 ixgbe_update_eeprom_checksum_X550(struct ixgbe_hw *hw)
+static s32 ixgbe_update_eeprom_checksum_X550(struct ixgbe_hw *hw)
 {
         s32 status;
         u16 checksum = 0;
@@ -600,8 +604,9 @@ s32 ixgbe_update_eeprom_checksum_X550(struct ixgbe_hw *hw)
  *
  *  Write a 16 bit word(s) to the EEPROM using the hostif.
  **/
-s32 ixgbe_write_ee_hostif_buffer_X550(struct ixgbe_hw *hw,
-                                      u16 offset, u16 words, u16 *data)
+static s32 ixgbe_write_ee_hostif_buffer_X550(struct ixgbe_hw *hw,
+                                             u16 offset, u16 words,
+                                             u16 *data)
 {
         s32 status = 0;
         u32 i = 0;
@@ -630,7 +635,7 @@ s32 ixgbe_write_ee_hostif_buffer_X550(struct ixgbe_hw *hw,
 /** ixgbe_init_mac_link_ops_X550em - init mac link function pointers
  *  @hw: pointer to hardware structure
  **/
-void ixgbe_init_mac_link_ops_X550em(struct ixgbe_hw *hw)
+static void ixgbe_init_mac_link_ops_X550em(struct ixgbe_hw *hw)
 {
         struct ixgbe_mac_info *mac = &hw->mac;
 
@@ -647,7 +652,7 @@ void ixgbe_init_mac_link_ops_X550em(struct ixgbe_hw *hw)
 /** ixgbe_setup_sfp_modules_X550em - Setup SFP module
  * @hw: pointer to hardware structure
  */
-s32 ixgbe_setup_sfp_modules_X550em(struct ixgbe_hw *hw)
+static s32 ixgbe_setup_sfp_modules_X550em(struct ixgbe_hw *hw)
 {
         bool setup_linear;
         u16 reg_slice, edc_mode;
@@ -703,9 +708,9 @@ s32 ixgbe_setup_sfp_modules_X550em(struct ixgbe_hw *hw)
  * @speed: pointer to link speed
  * @autoneg: true when autoneg or autotry is enabled
  **/
-s32 ixgbe_get_link_capabilities_X550em(struct ixgbe_hw *hw,
-                                       ixgbe_link_speed *speed,
-                                       bool *autoneg)
+static s32 ixgbe_get_link_capabilities_X550em(struct ixgbe_hw *hw,
+                                              ixgbe_link_speed *speed,
+                                              bool *autoneg)
 {
         /* SFP */
         if (hw->phy.media_type == ixgbe_media_type_fiber) {
@@ -740,8 +745,8 @@ s32 ixgbe_get_link_capabilities_X550em(struct ixgbe_hw *hw,
  *  @device_type: 3 bit device type
  *  @data: Data to write to the register
  **/
-s32 ixgbe_write_iosf_sb_reg_x550(struct ixgbe_hw *hw, u32 reg_addr,
-                                 u32 device_type, u32 data)
+static s32 ixgbe_write_iosf_sb_reg_x550(struct ixgbe_hw *hw, u32 reg_addr,
+                                        u32 device_type, u32 data)
 {
         u32 i, command, error;
 
@@ -904,7 +909,7 @@ static s32 ixgbe_setup_ixfi_x550em(struct ixgbe_hw *hw, ixgbe_link_speed *speed)
  *
  *   Configures the integrated KX4 PHY.
  **/
-s32 ixgbe_setup_kx4_x550em(struct ixgbe_hw *hw)
+static s32 ixgbe_setup_kx4_x550em(struct ixgbe_hw *hw)
 {
         s32 status;
         u32 reg_val;
@@ -942,7 +947,7 @@ s32 ixgbe_setup_kx4_x550em(struct ixgbe_hw *hw)
  *
  *   Configures the integrated KR PHY.
  **/
-s32 ixgbe_setup_kr_x550em(struct ixgbe_hw *hw)
+static s32 ixgbe_setup_kr_x550em(struct ixgbe_hw *hw)
 {
         s32 status;
         u32 reg_val;
@@ -987,7 +992,7 @@ s32 ixgbe_setup_kr_x550em(struct ixgbe_hw *hw)
  *  A return of a non-zero value indicates an error, and the base driver should
  *  not report link up.
  **/
-s32 ixgbe_setup_internal_phy_x550em(struct ixgbe_hw *hw)
+static s32 ixgbe_setup_internal_phy_x550em(struct ixgbe_hw *hw)
 {
         u32 status;
         u16 lasi, autoneg_status, speed;
@@ -1049,7 +1054,7 @@ s32 ixgbe_setup_internal_phy_x550em(struct ixgbe_hw *hw)
  *  set during init_shared_code because the PHY/SFP type was
  *  not known.  Perform the SFP init if necessary.
  **/
-s32 ixgbe_init_phy_ops_X550em(struct ixgbe_hw *hw)
+static s32 ixgbe_init_phy_ops_X550em(struct ixgbe_hw *hw)
 {
         struct ixgbe_phy_info *phy = &hw->phy;
         s32 ret_val;
@@ -1102,7 +1107,7 @@ s32 ixgbe_init_phy_ops_X550em(struct ixgbe_hw *hw)
  *  Returns the media type (fiber, copper, backplane)
  *
  */
-enum ixgbe_media_type ixgbe_get_media_type_X550em(struct ixgbe_hw *hw)
+static enum ixgbe_media_type ixgbe_get_media_type_X550em(struct ixgbe_hw *hw)
 {
         enum ixgbe_media_type media_type;
 
@@ -1129,7 +1134,7 @@ enum ixgbe_media_type ixgbe_get_media_type_X550em(struct ixgbe_hw *hw)
 /** ixgbe_init_ext_t_x550em - Start (unstall) the external Base T PHY.
  ** @hw: pointer to hardware structure
  **/
-s32 ixgbe_init_ext_t_x550em(struct ixgbe_hw *hw)
+static s32 ixgbe_init_ext_t_x550em(struct ixgbe_hw *hw)
 {
         u32 status;
         u16 reg;
@@ -1202,7 +1207,7 @@ s32 ixgbe_init_ext_t_x550em(struct ixgbe_hw *hw)
  **  and clears all interrupts, perform a PHY reset, and perform a link (MAC)
  **  reset.
  **/
-s32 ixgbe_reset_hw_X550em(struct ixgbe_hw *hw)
+static s32 ixgbe_reset_hw_X550em(struct ixgbe_hw *hw)
 {
         ixgbe_link_speed link_speed;
         s32 status;
@@ -1295,6 +1300,28 @@ mac_reset_top:
         return status;
 }
 
+/** ixgbe_set_ethertype_anti_spoofing_X550 - Enable/Disable Ethertype
+ *      anti-spoofing
+ *  @hw:  pointer to hardware structure
+ *  @enable: enable or disable switch for Ethertype anti-spoofing
+ *  @vf: Virtual Function pool - VF Pool to set for Ethertype anti-spoofing
+ **/
+void ixgbe_set_ethertype_anti_spoofing_X550(struct ixgbe_hw *hw, bool enable,
+                                            int vf)
+{
+        int vf_target_reg = vf >> 3;
+        int vf_target_shift = vf % 8 + IXGBE_SPOOF_ETHERTYPEAS_SHIFT;
+        u32 pfvfspoof;
+
+        pfvfspoof = IXGBE_READ_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg));
+        if (enable)
+                pfvfspoof |= (1 << vf_target_shift);
+        else
+                pfvfspoof &= ~(1 << vf_target_shift);
+
+        IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg), pfvfspoof);
+}
+
 #define X550_COMMON_MAC \
         .init_hw                        = &ixgbe_init_hw_generic, \
         .start_hw                       = &ixgbe_start_hw_X540, \
@@ -1329,6 +1356,8 @@ mac_reset_top:
         .init_uta_tables                = &ixgbe_init_uta_tables_generic, \
         .set_mac_anti_spoofing          = &ixgbe_set_mac_anti_spoofing, \
         .set_vlan_anti_spoofing         = &ixgbe_set_vlan_anti_spoofing, \
+        .set_ethertype_anti_spoofing    = \
+                                &ixgbe_set_ethertype_anti_spoofing_X550, \
         .acquire_swfw_sync              = &ixgbe_acquire_swfw_sync_X540, \
         .release_swfw_sync              = &ixgbe_release_swfw_sync_X540, \
         .disable_rx_buff                = &ixgbe_disable_rx_buff_generic, \
@@ -1345,7 +1374,6 @@ static struct ixgbe_mac_operations mac_ops_X550 = {
         .get_san_mac_addr       = &ixgbe_get_san_mac_addr_generic,
         .get_wwn_prefix         = &ixgbe_get_wwn_prefix_generic,
         .setup_link             = &ixgbe_setup_mac_link_X540,
-        .set_rxpba              = &ixgbe_set_rxpba_generic,
         .get_link_capabilities  = &ixgbe_get_copper_link_capabilities_generic,
         .setup_sfp              = NULL,
 };
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h b/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
index 8c44ab25f3fa..3a9b356dff01 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
@@ -43,6 +43,13 @@
 #define BP_EXTENDED_STATS
 #endif
 
+#define IXGBE_MAX_TXD_PWR       14
+#define IXGBE_MAX_DATA_PER_TXD  BIT(IXGBE_MAX_TXD_PWR)
+
+/* Tx Descriptors needed, worst case */
+#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), IXGBE_MAX_DATA_PER_TXD)
+#define DESC_NEEDED (MAX_SKB_FRAGS + 4)
+
 /* wrapper around a pointer to a socket buffer,
  * so a DMA handle can be stored along with the buffer */
 struct ixgbevf_tx_buffer {
@@ -85,6 +92,18 @@ struct ixgbevf_rx_queue_stats {
         u64 csum_err;
 };
 
+enum ixgbevf_ring_state_t {
+        __IXGBEVF_TX_DETECT_HANG,
+        __IXGBEVF_HANG_CHECK_ARMED,
+};
+
+#define check_for_tx_hang(ring) \
+        test_bit(__IXGBEVF_TX_DETECT_HANG, &(ring)->state)
+#define set_check_for_tx_hang(ring) \
+        set_bit(__IXGBEVF_TX_DETECT_HANG, &(ring)->state)
+#define clear_check_for_tx_hang(ring) \
+        clear_bit(__IXGBEVF_TX_DETECT_HANG, &(ring)->state)
+
 struct ixgbevf_ring {
         struct ixgbevf_ring *next;
         struct net_device *netdev;
@@ -101,7 +120,7 @@ struct ixgbevf_ring {
                 struct ixgbevf_tx_buffer *tx_buffer_info;
                 struct ixgbevf_rx_buffer *rx_buffer_info;
         };
-
+        unsigned long state;
         struct ixgbevf_stats stats;
         struct u64_stats_sync syncp;
         union {
@@ -124,6 +143,7 @@ struct ixgbevf_ring {
 
 #define MAX_RX_QUEUES IXGBE_VF_MAX_RX_QUEUES
 #define MAX_TX_QUEUES IXGBE_VF_MAX_TX_QUEUES
+#define IXGBEVF_MAX_RSS_QUEUES 2
 
 #define IXGBEVF_DEFAULT_TXD   1024
 #define IXGBEVF_DEFAULT_RXD   512
@@ -347,8 +367,6 @@ struct ixgbevf_adapter {
         /* this field must be first, see ixgbevf_process_skb_fields */
         unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
 
-        struct timer_list watchdog_timer;
-        struct work_struct reset_task;
         struct ixgbevf_q_vector *q_vector[MAX_MSIX_Q_VECTORS];
 
         /* Interrupt Throttle Rate */
@@ -378,8 +396,7 @@ struct ixgbevf_adapter {
          * thus the additional *_CAPABLE flags.
          */
         u32 flags;
-#define IXGBE_FLAG_IN_WATCHDOG_TASK             (u32)(1)
-
+#define IXGBEVF_FLAG_RESET_REQUESTED            (u32)(1)
 #define IXGBEVF_FLAG_QUEUE_RESET_REQUESTED      (u32)(1 << 2)
 
         struct msix_entry *msix_entries;
@@ -415,9 +432,11 @@ struct ixgbevf_adapter {
         u32 link_speed;
         bool link_up;
 
-        spinlock_t mbx_lock;
+        struct timer_list service_timer;
+        struct work_struct service_task;
 
-        struct work_struct watchdog_task;
+        spinlock_t mbx_lock;
+        unsigned long last_reset;
 };
 
 enum ixbgevf_state_t {
@@ -426,7 +445,8 @@ enum ixbgevf_state_t {
         __IXGBEVF_DOWN,
         __IXGBEVF_DISABLED,
         __IXGBEVF_REMOVING,
-        __IXGBEVF_WORK_INIT,
+        __IXGBEVF_SERVICE_SCHED,
+        __IXGBEVF_SERVICE_INITED,
 };
 
 enum ixgbevf_boards {
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
index 38c7a0be8197..4186981e562d 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
@@ -98,6 +98,23 @@ static int debug = -1;
 module_param(debug, int, 0);
 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 
+static void ixgbevf_service_event_schedule(struct ixgbevf_adapter *adapter)
+{
+        if (!test_bit(__IXGBEVF_DOWN, &adapter->state) &&
+            !test_bit(__IXGBEVF_REMOVING, &adapter->state) &&
+            !test_and_set_bit(__IXGBEVF_SERVICE_SCHED, &adapter->state))
+                schedule_work(&adapter->service_task);
+}
+
+static void ixgbevf_service_event_complete(struct ixgbevf_adapter *adapter)
+{
+        BUG_ON(!test_bit(__IXGBEVF_SERVICE_SCHED, &adapter->state));
+
+        /* flush memory to make sure state is correct before next watchdog */
+        smp_mb__before_atomic();
+        clear_bit(__IXGBEVF_SERVICE_SCHED, &adapter->state);
+}
+
 /* forward decls */
 static void ixgbevf_queue_reset_subtask(struct ixgbevf_adapter *adapter);
 static void ixgbevf_set_itr(struct ixgbevf_q_vector *q_vector);
@@ -111,8 +128,8 @@ static void ixgbevf_remove_adapter(struct ixgbe_hw *hw)
                 return;
         hw->hw_addr = NULL;
         dev_err(&adapter->pdev->dev, "Adapter removed\n");
-        if (test_bit(__IXGBEVF_WORK_INIT, &adapter->state))
-                schedule_work(&adapter->watchdog_task);
+        if (test_bit(__IXGBEVF_SERVICE_INITED, &adapter->state))
+                ixgbevf_service_event_schedule(adapter);
 }
 
 static void ixgbevf_check_remove(struct ixgbe_hw *hw, u32 reg)
@@ -199,14 +216,72 @@ static void ixgbevf_unmap_and_free_tx_resource(struct ixgbevf_ring *tx_ring,
         /* tx_buffer must be completely set up in the transmit path */
 }
 
-#define IXGBE_MAX_TXD_PWR       14
-#define IXGBE_MAX_DATA_PER_TXD  (1 << IXGBE_MAX_TXD_PWR)
+static u64 ixgbevf_get_tx_completed(struct ixgbevf_ring *ring)
+{
+        return ring->stats.packets;
+}
+
+static u32 ixgbevf_get_tx_pending(struct ixgbevf_ring *ring)
+{
+        struct ixgbevf_adapter *adapter = netdev_priv(ring->netdev);
+        struct ixgbe_hw *hw = &adapter->hw;
+
+        u32 head = IXGBE_READ_REG(hw, IXGBE_VFTDH(ring->reg_idx));
+        u32 tail = IXGBE_READ_REG(hw, IXGBE_VFTDT(ring->reg_idx));
+
+        if (head != tail)
+                return (head < tail) ?
+                        tail - head : (tail + ring->count - head);
+
+        return 0;
+}
+
+static inline bool ixgbevf_check_tx_hang(struct ixgbevf_ring *tx_ring)
+{
+        u32 tx_done = ixgbevf_get_tx_completed(tx_ring);
+        u32 tx_done_old = tx_ring->tx_stats.tx_done_old;
+        u32 tx_pending = ixgbevf_get_tx_pending(tx_ring);
+
+        clear_check_for_tx_hang(tx_ring);
+
+        /* Check for a hung queue, but be thorough. This verifies
+         * that a transmit has been completed since the previous
+         * check AND there is at least one packet pending. The
+         * ARMED bit is set to indicate a potential hang.
+         */
+        if ((tx_done_old == tx_done) && tx_pending) {
+                /* make sure it is true for two checks in a row */
+                return test_and_set_bit(__IXGBEVF_HANG_CHECK_ARMED,
+                                        &tx_ring->state);
+        }
+        /* reset the countdown */
+        clear_bit(__IXGBEVF_HANG_CHECK_ARMED, &tx_ring->state);
+
+        /* update completed stats and continue */
+        tx_ring->tx_stats.tx_done_old = tx_done;
+
+        return false;
+}
+
+static void ixgbevf_tx_timeout_reset(struct ixgbevf_adapter *adapter)
+{
+        /* Do the reset outside of interrupt context */
+        if (!test_bit(__IXGBEVF_DOWN, &adapter->state)) {
+                adapter->flags |= IXGBEVF_FLAG_RESET_REQUESTED;
+                ixgbevf_service_event_schedule(adapter);
+        }
+}
 
-/* Tx Descriptors needed, worst case */
-#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), IXGBE_MAX_DATA_PER_TXD)
-#define DESC_NEEDED (MAX_SKB_FRAGS + 4)
+/**
+ * ixgbevf_tx_timeout - Respond to a Tx Hang
+ * @netdev: network interface device structure
+ **/
+static void ixgbevf_tx_timeout(struct net_device *netdev)
+{
+        struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 
-static void ixgbevf_tx_timeout(struct net_device *netdev);
+        ixgbevf_tx_timeout_reset(adapter);
+}
 
 /**
  * ixgbevf_clean_tx_irq - Reclaim resources after transmit completes
@@ -311,6 +386,37 @@ static bool ixgbevf_clean_tx_irq(struct ixgbevf_q_vector *q_vector,
         q_vector->tx.total_bytes += total_bytes;
         q_vector->tx.total_packets += total_packets;
 
+        if (check_for_tx_hang(tx_ring) && ixgbevf_check_tx_hang(tx_ring)) {
+                struct ixgbe_hw *hw = &adapter->hw;
+                union ixgbe_adv_tx_desc *eop_desc;
+
+                eop_desc = tx_ring->tx_buffer_info[i].next_to_watch;
+
+                pr_err("Detected Tx Unit Hang\n"
+                       "  Tx Queue             <%d>\n"
+                       "  TDH, TDT             <%x>, <%x>\n"
+                       "  next_to_use          <%x>\n"
+                       "  next_to_clean        <%x>\n"
+                       "tx_buffer_info[next_to_clean]\n"
+                       "  next_to_watch        <%p>\n"
+                       "  eop_desc->wb.status  <%x>\n"
+                       "  time_stamp           <%lx>\n"
+                       "  jiffies              <%lx>\n",
+                       tx_ring->queue_index,
+                       IXGBE_READ_REG(hw, IXGBE_VFTDH(tx_ring->reg_idx)),
+                       IXGBE_READ_REG(hw, IXGBE_VFTDT(tx_ring->reg_idx)),
+                       tx_ring->next_to_use, i,
+                       eop_desc, (eop_desc ? eop_desc->wb.status : 0),
+                       tx_ring->tx_buffer_info[i].time_stamp, jiffies);
+
+                netif_stop_subqueue(tx_ring->netdev, tx_ring->queue_index);
+
+                /* schedule immediate reset if we believe we hung */
+                ixgbevf_tx_timeout_reset(adapter);
+
+                return true;
+        }
+
 #define TX_WAKE_THRESHOLD (DESC_NEEDED * 2)
         if (unlikely(total_packets && netif_carrier_ok(tx_ring->netdev) &&
                      (ixgbevf_desc_unused(tx_ring) >= TX_WAKE_THRESHOLD))) {
@@ -1158,9 +1264,7 @@ static irqreturn_t ixgbevf_msix_other(int irq, void *data)
 
         hw->mac.get_link_status = 1;
 
-        if (!test_bit(__IXGBEVF_DOWN, &adapter->state) &&
-            !test_bit(__IXGBEVF_REMOVING, &adapter->state))
-                mod_timer(&adapter->watchdog_timer, jiffies);
+        ixgbevf_service_event_schedule(adapter);
 
         IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, adapter->eims_other);
 
@@ -1479,6 +1583,8 @@ static void ixgbevf_configure_tx_ring(struct ixgbevf_adapter *adapter,
         txdctl |= (1 << 8) |    /* HTHRESH = 1 */
                   32;          /* PTHRESH = 32 */
 
+        clear_bit(__IXGBEVF_HANG_CHECK_ARMED, &ring->state);
+
         IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(reg_idx), txdctl);
 
         /* poll to verify queue is enabled */
@@ -1584,6 +1690,39 @@ static void ixgbevf_rx_desc_queue_enable(struct ixgbevf_adapter *adapter,
                        reg_idx);
 }
 
+static void ixgbevf_setup_vfmrqc(struct ixgbevf_adapter *adapter)
+{
+        struct ixgbe_hw *hw = &adapter->hw;
+        u32 vfmrqc = 0, vfreta = 0;
+        u32 rss_key[10];
+        u16 rss_i = adapter->num_rx_queues;
+        int i, j;
+
+        /* Fill out hash function seeds */
+        netdev_rss_key_fill(rss_key, sizeof(rss_key));
+        for (i = 0; i < 10; i++)
+                IXGBE_WRITE_REG(hw, IXGBE_VFRSSRK(i), rss_key[i]);
+
+        /* Fill out redirection table */
+        for (i = 0, j = 0; i < 64; i++, j++) {
+                if (j == rss_i)
+                        j = 0;
+                vfreta = (vfreta << 8) | (j * 0x1);
+                if ((i & 3) == 3)
+                        IXGBE_WRITE_REG(hw, IXGBE_VFRETA(i >> 2), vfreta);
+        }
+
+        /* Perform hash on these packet types */
+        vfmrqc |= IXGBE_VFMRQC_RSS_FIELD_IPV4 |
+                IXGBE_VFMRQC_RSS_FIELD_IPV4_TCP |
+                IXGBE_VFMRQC_RSS_FIELD_IPV6 |
+                IXGBE_VFMRQC_RSS_FIELD_IPV6_TCP;
+
+        vfmrqc |= IXGBE_VFMRQC_RSSEN;
+
+        IXGBE_WRITE_REG(hw, IXGBE_VFMRQC, vfmrqc);
+}
+
 static void ixgbevf_configure_rx_ring(struct ixgbevf_adapter *adapter,
                                       struct ixgbevf_ring *ring)
 {
@@ -1640,6 +1779,8 @@ static void ixgbevf_configure_rx(struct ixgbevf_adapter *adapter)
         struct net_device *netdev = adapter->netdev;
 
         ixgbevf_setup_psrtype(adapter);
+        if (hw->mac.type >= ixgbe_mac_X550_vf)
+                ixgbevf_setup_vfmrqc(adapter);
 
         /* notify the PF of our intent to use this size of frame */
         ixgbevf_rlpml_set_vf(hw, netdev->mtu + ETH_HLEN + ETH_FCS_LEN);
@@ -1794,7 +1935,8 @@ static int ixgbevf_configure_dcb(struct ixgbevf_adapter *adapter)
         struct ixgbe_hw *hw = &adapter->hw;
         unsigned int def_q = 0;
         unsigned int num_tcs = 0;
-        unsigned int num_rx_queues = 1;
+        unsigned int num_rx_queues = adapter->num_rx_queues;
+        unsigned int num_tx_queues = adapter->num_tx_queues;
         int err;
 
         spin_lock_bh(&adapter->mbx_lock);
@@ -1808,6 +1950,9 @@ static int ixgbevf_configure_dcb(struct ixgbevf_adapter *adapter)
                 return err;
 
         if (num_tcs > 1) {
+                /* we need only one Tx queue */
+                num_tx_queues = 1;
+
                 /* update default Tx ring register index */
                 adapter->tx_ring[0]->reg_idx = def_q;
 
@@ -1816,7 +1961,8 @@ static int ixgbevf_configure_dcb(struct ixgbevf_adapter *adapter)
         }
 
         /* if we have a bad config abort request queue reset */
-        if (adapter->num_rx_queues != num_rx_queues) {
+        if ((adapter->num_rx_queues != num_rx_queues) ||
+            (adapter->num_tx_queues != num_tx_queues)) {
                 /* force mailbox timeout to prevent further messages */
                 hw->mbx.timeout = 0;
 
@@ -1917,6 +2063,10 @@ static void ixgbevf_up_complete(struct ixgbevf_adapter *adapter)
         clear_bit(__IXGBEVF_DOWN, &adapter->state);
         ixgbevf_napi_enable_all(adapter);
 
+        /* clear any pending interrupts, may auto mask */
+        IXGBE_READ_REG(hw, IXGBE_VTEICR);
+        ixgbevf_irq_enable(adapter);
+
         /* enable transmits */
         netif_tx_start_all_queues(netdev);
 
@@ -1924,21 +2074,14 @@ static void ixgbevf_up_complete(struct ixgbevf_adapter *adapter)
         ixgbevf_init_last_counter_stats(adapter);
 
         hw->mac.get_link_status = 1;
-        mod_timer(&adapter->watchdog_timer, jiffies);
+        mod_timer(&adapter->service_timer, jiffies);
 }
 
 void ixgbevf_up(struct ixgbevf_adapter *adapter)
 {
-        struct ixgbe_hw *hw = &adapter->hw;
-
         ixgbevf_configure(adapter);
 
         ixgbevf_up_complete(adapter);
-
-        /* clear any pending interrupts, may auto mask */
-        IXGBE_READ_REG(hw, IXGBE_VTEICR);
-
-        ixgbevf_irq_enable(adapter);
 }
 
 /**
@@ -2045,22 +2188,19 @@ void ixgbevf_down(struct ixgbevf_adapter *adapter)
         for (i = 0; i < adapter->num_rx_queues; i++)
                 ixgbevf_disable_rx_queue(adapter, adapter->rx_ring[i]);
 
-        netif_tx_disable(netdev);
-
-        msleep(10);
+        usleep_range(10000, 20000);
 
         netif_tx_stop_all_queues(netdev);
 
+        /* call carrier off first to avoid false dev_watchdog timeouts */
+        netif_carrier_off(netdev);
+        netif_tx_disable(netdev);
+
         ixgbevf_irq_disable(adapter);
 
         ixgbevf_napi_disable_all(adapter);
 
-        del_timer_sync(&adapter->watchdog_timer);
-        /* can't call flush scheduled work here because it can deadlock
-         * if linkwatch_event tries to acquire the rtnl_lock which we are
-         * holding */
-        while (adapter->flags & IXGBE_FLAG_IN_WATCHDOG_TASK)
-                msleep(1);
+        del_timer_sync(&adapter->service_timer);
 
         /* disable transmits in the hardware now that interrupts are off */
         for (i = 0; i < adapter->num_tx_queues; i++) {
@@ -2070,8 +2210,6 @@ void ixgbevf_down(struct ixgbevf_adapter *adapter)
                                 IXGBE_TXDCTL_SWFLSH);
         }
 
-        netif_carrier_off(netdev);
-
         if (!pci_channel_offline(adapter->pdev))
                 ixgbevf_reset(adapter);
 
@@ -2110,6 +2248,8 @@ void ixgbevf_reset(struct ixgbevf_adapter *adapter)
                 memcpy(netdev->perm_addr, adapter->hw.mac.addr,
                        netdev->addr_len);
         }
+
+        adapter->last_reset = jiffies;
 }
 
 static int ixgbevf_acquire_msix_vectors(struct ixgbevf_adapter *adapter,
@@ -2181,8 +2321,19 @@ static void ixgbevf_set_num_queues(struct ixgbevf_adapter *adapter)
                 return;
 
         /* we need as many queues as traffic classes */
-        if (num_tcs > 1)
+        if (num_tcs > 1) {
                 adapter->num_rx_queues = num_tcs;
+        } else {
+                u16 rss = min_t(u16, num_online_cpus(), IXGBEVF_MAX_RSS_QUEUES);
+
+                switch (hw->api_version) {
+                case ixgbe_mbox_api_11:
+                        adapter->num_rx_queues = rss;
+                        adapter->num_tx_queues = rss;
+                default:
+                        break;
+                }
+        }
 }
 
 /**
@@ -2552,7 +2703,8 @@ void ixgbevf_update_stats(struct ixgbevf_adapter *adapter)
         struct ixgbe_hw *hw = &adapter->hw;
         int i;
 
-        if (!adapter->link_up)
+        if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
+            test_bit(__IXGBEVF_RESETTING, &adapter->state))
                 return;
 
         UPDATE_VF_COUNTER_32bit(IXGBE_VFGPRC, adapter->stats.last_vfgprc,
@@ -2576,79 +2728,176 @@ void ixgbevf_update_stats(struct ixgbevf_adapter *adapter)
 }
 
 /**
- * ixgbevf_watchdog - Timer Call-back
+ * ixgbevf_service_timer - Timer Call-back
  * @data: pointer to adapter cast into an unsigned long
  **/
-static void ixgbevf_watchdog(unsigned long data)
+static void ixgbevf_service_timer(unsigned long data)
 {
         struct ixgbevf_adapter *adapter = (struct ixgbevf_adapter *)data;
+
+        /* Reset the timer */
+        mod_timer(&adapter->service_timer, (HZ * 2) + jiffies);
+
+        ixgbevf_service_event_schedule(adapter);
+}
+
+static void ixgbevf_reset_subtask(struct ixgbevf_adapter *adapter)
+{
+        if (!(adapter->flags & IXGBEVF_FLAG_RESET_REQUESTED))
+                return;
+
+        adapter->flags &= ~IXGBEVF_FLAG_RESET_REQUESTED;
+
+        /* If we're already down or resetting, just bail */
+        if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
+            test_bit(__IXGBEVF_RESETTING, &adapter->state))
+                return;
+
+        adapter->tx_timeout_count++;
+
+        ixgbevf_reinit_locked(adapter);
+}
+
+/* ixgbevf_check_hang_subtask - check for hung queues and dropped interrupts
+ * @adapter - pointer to the device adapter structure
+ *
+ * This function serves two purposes.  First it strobes the interrupt lines
+ * in order to make certain interrupts are occurring.  Secondly it sets the
+ * bits needed to check for TX hangs.  As a result we should immediately
+ * determine if a hang has occurred.
+ */
+static void ixgbevf_check_hang_subtask(struct ixgbevf_adapter *adapter)
+{
         struct ixgbe_hw *hw = &adapter->hw;
         u32 eics = 0;
         int i;
 
-        /*
-         * Do the watchdog outside of interrupt context due to the lovely
-         * delays that some of the newer hardware requires
-         */
+        /* If we're down or resetting, just bail */
+        if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
+            test_bit(__IXGBEVF_RESETTING, &adapter->state))
+                return;
 
-        if (test_bit(__IXGBEVF_DOWN, &adapter->state))
-                goto watchdog_short_circuit;
+        /* Force detection of hung controller */
+        if (netif_carrier_ok(adapter->netdev)) {
+                for (i = 0; i < adapter->num_tx_queues; i++)
+                        set_check_for_tx_hang(adapter->tx_ring[i]);
+        }
 
         /* get one bit for every active tx/rx interrupt vector */
         for (i = 0; i < adapter->num_msix_vectors - NON_Q_VECTORS; i++) {
                 struct ixgbevf_q_vector *qv = adapter->q_vector[i];
+
                 if (qv->rx.ring || qv->tx.ring)
                         eics |= 1 << i;
         }
 
+        /* Cause software interrupt to ensure rings are cleaned */
         IXGBE_WRITE_REG(hw, IXGBE_VTEICS, eics);
+}
 
-watchdog_short_circuit:
-        schedule_work(&adapter->watchdog_task);
+/**
+ * ixgbevf_watchdog_update_link - update the link status
+ * @adapter - pointer to the device adapter structure
+ **/
+static void ixgbevf_watchdog_update_link(struct ixgbevf_adapter *adapter)
+{
+        struct ixgbe_hw *hw = &adapter->hw;
+        u32 link_speed = adapter->link_speed;
+        bool link_up = adapter->link_up;
+        s32 err;
+
+        spin_lock_bh(&adapter->mbx_lock);
+
+        err = hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
+
+        spin_unlock_bh(&adapter->mbx_lock);
+
+        /* if check for link returns error we will need to reset */
+        if (err && time_after(jiffies, adapter->last_reset + (10 * HZ))) {
+                adapter->flags |= IXGBEVF_FLAG_RESET_REQUESTED;
+                link_up = false;
+        }
+
+        adapter->link_up = link_up;
+        adapter->link_speed = link_speed;
 }
 
 /**
- * ixgbevf_tx_timeout - Respond to a Tx Hang
- * @netdev: network interface device structure
+ * ixgbevf_watchdog_link_is_up - update netif_carrier status and
+ *                               print link up message
+ * @adapter - pointer to the device adapter structure
  **/
-static void ixgbevf_tx_timeout(struct net_device *netdev)
+static void ixgbevf_watchdog_link_is_up(struct ixgbevf_adapter *adapter)
 {
-        struct ixgbevf_adapter *adapter = netdev_priv(netdev);
+        struct net_device *netdev = adapter->netdev;
 
-        /* Do the reset outside of interrupt context */
-        schedule_work(&adapter->reset_task);
+        /* only continue if link was previously down */
+        if (netif_carrier_ok(netdev))
+                return;
+
+        dev_info(&adapter->pdev->dev, "NIC Link is Up %s\n",
+                 (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL) ?
+                 "10 Gbps" :
+                 (adapter->link_speed == IXGBE_LINK_SPEED_1GB_FULL) ?
+                 "1 Gbps" :
+                 (adapter->link_speed == IXGBE_LINK_SPEED_100_FULL) ?
+                 "100 Mbps" :
+                 "unknown speed");
+
+        netif_carrier_on(netdev);
 }
 
-static void ixgbevf_reset_task(struct work_struct *work)
+/**
+ * ixgbevf_watchdog_link_is_down - update netif_carrier status and
+ *                                 print link down message
+ * @adapter - pointer to the adapter structure
+ **/
+static void ixgbevf_watchdog_link_is_down(struct ixgbevf_adapter *adapter)
 {
-        struct ixgbevf_adapter *adapter;
-        adapter = container_of(work, struct ixgbevf_adapter, reset_task);
+        struct net_device *netdev = adapter->netdev;
 
-        /* If we're already down or resetting, just bail */
+        adapter->link_speed = 0;
+
+        /* only continue if link was up previously */
+        if (!netif_carrier_ok(netdev))
+                return;
+
+        dev_info(&adapter->pdev->dev, "NIC Link is Down\n");
+
+        netif_carrier_off(netdev);
+}
+
+/**
+ * ixgbevf_watchdog_subtask - worker thread to bring link up
+ * @work: pointer to work_struct containing our data
+ **/
+static void ixgbevf_watchdog_subtask(struct ixgbevf_adapter *adapter)
+{
+        /* if interface is down do nothing */
         if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
-            test_bit(__IXGBEVF_REMOVING, &adapter->state) ||
             test_bit(__IXGBEVF_RESETTING, &adapter->state))
                 return;
 
-        adapter->tx_timeout_count++;
+        ixgbevf_watchdog_update_link(adapter);
 
-        ixgbevf_reinit_locked(adapter);
+        if (adapter->link_up)
+                ixgbevf_watchdog_link_is_up(adapter);
+        else
+                ixgbevf_watchdog_link_is_down(adapter);
+
+        ixgbevf_update_stats(adapter);
 }
 
 /**
- * ixgbevf_watchdog_task - worker thread to bring link up
+ * ixgbevf_service_task - manages and runs subtasks
  * @work: pointer to work_struct containing our data
  **/
-static void ixgbevf_watchdog_task(struct work_struct *work)
+static void ixgbevf_service_task(struct work_struct *work)
 {
         struct ixgbevf_adapter *adapter = container_of(work,
                                                        struct ixgbevf_adapter,
-                                                       watchdog_task);
-        struct net_device *netdev = adapter->netdev;
+                                                       service_task);
         struct ixgbe_hw *hw = &adapter->hw;
-        u32 link_speed = adapter->link_speed;
-        bool link_up = adapter->link_up;
-        s32 need_reset;
 
         if (IXGBE_REMOVED(hw->hw_addr)) {
                 if (!test_bit(__IXGBEVF_DOWN, &adapter->state)) {
@@ -2658,73 +2907,13 @@ static void ixgbevf_watchdog_task(struct work_struct *work)
                 }
                 return;
         }
-        ixgbevf_queue_reset_subtask(adapter);
-
-        adapter->flags |= IXGBE_FLAG_IN_WATCHDOG_TASK;
-
-        /*
-         * Always check the link on the watchdog because we have
-         * no LSC interrupt
-         */
-        spin_lock_bh(&adapter->mbx_lock);
-
-        need_reset = hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
-
-        spin_unlock_bh(&adapter->mbx_lock);
-
-        if (need_reset) {
-                adapter->link_up = link_up;
-                adapter->link_speed = link_speed;
-                netif_carrier_off(netdev);
-                netif_tx_stop_all_queues(netdev);
-                schedule_work(&adapter->reset_task);
-                goto pf_has_reset;
-        }
-        adapter->link_up = link_up;
-        adapter->link_speed = link_speed;
-
-        if (link_up) {
-                if (!netif_carrier_ok(netdev)) {
-                        char *link_speed_string;
-                        switch (link_speed) {
-                        case IXGBE_LINK_SPEED_10GB_FULL:
-                                link_speed_string = "10 Gbps";
-                                break;
-                        case IXGBE_LINK_SPEED_1GB_FULL:
-                                link_speed_string = "1 Gbps";
-                                break;
-                        case IXGBE_LINK_SPEED_100_FULL:
-                                link_speed_string = "100 Mbps";
-                                break;
-                        default:
-                                link_speed_string = "unknown speed";
-                                break;
-                        }
-                        dev_info(&adapter->pdev->dev,
-                                "NIC Link is Up, %s\n", link_speed_string);
-                        netif_carrier_on(netdev);
-                        netif_tx_wake_all_queues(netdev);
-                }
-        } else {
-                adapter->link_up = false;
-                adapter->link_speed = 0;
-                if (netif_carrier_ok(netdev)) {
-                        dev_info(&adapter->pdev->dev, "NIC Link is Down\n");
-                        netif_carrier_off(netdev);
-                        netif_tx_stop_all_queues(netdev);
-                }
-        }
 
-        ixgbevf_update_stats(adapter);
-
-pf_has_reset:
-        /* Reset the timer */
-        if (!test_bit(__IXGBEVF_DOWN, &adapter->state) &&
-            !test_bit(__IXGBEVF_REMOVING, &adapter->state))
-                mod_timer(&adapter->watchdog_timer,
-                          round_jiffies(jiffies + (2 * HZ)));
+        ixgbevf_queue_reset_subtask(adapter);
+        ixgbevf_reset_subtask(adapter);
+        ixgbevf_watchdog_subtask(adapter);
+        ixgbevf_check_hang_subtask(adapter);
 
-        adapter->flags &= ~IXGBE_FLAG_IN_WATCHDOG_TASK;
+        ixgbevf_service_event_complete(adapter);
 }
 
 /**
@@ -2944,10 +3133,6 @@ static int ixgbevf_open(struct net_device *netdev)
         if (!adapter->num_msix_vectors)
                 return -ENOMEM;
 
-        /* disallow open during test */
-        if (test_bit(__IXGBEVF_TESTING, &adapter->state))
-                return -EBUSY;
-
         if (hw->adapter_stopped) {
                 ixgbevf_reset(adapter);
                 /* if adapter is still stopped then PF isn't up and
@@ -2960,6 +3145,12 @@ static int ixgbevf_open(struct net_device *netdev)
                 }
         }
 
+        /* disallow open during test */
+        if (test_bit(__IXGBEVF_TESTING, &adapter->state))
+                return -EBUSY;
+
+        netif_carrier_off(netdev);
+
         /* allocate transmit descriptors */
         err = ixgbevf_setup_all_tx_resources(adapter);
         if (err)
@@ -2979,15 +3170,11 @@ static int ixgbevf_open(struct net_device *netdev)
          */
         ixgbevf_map_rings_to_vectors(adapter);
 
-        ixgbevf_up_complete(adapter);
-
-        /* clear any pending interrupts, may auto mask */
-        IXGBE_READ_REG(hw, IXGBE_VTEICR);
         err = ixgbevf_request_irq(adapter);
         if (err)
                 goto err_req_irq;
 
-        ixgbevf_irq_enable(adapter);
+        ixgbevf_up_complete(adapter);
 
         return 0;
 
@@ -3452,8 +3639,8 @@ static int ixgbevf_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         first->bytecount = skb->len;
         first->gso_segs = 1;
 
-        if (vlan_tx_tag_present(skb)) {
-                tx_flags |= vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb)) {
+                tx_flags |= skb_vlan_tag_get(skb);
                 tx_flags <<= IXGBE_TX_FLAGS_VLAN_SHIFT;
                 tx_flags |= IXGBE_TX_FLAGS_VLAN;
         }
@@ -3822,28 +4009,28 @@ static int ixgbevf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                            NETIF_F_HW_VLAN_CTAG_RX |
                            NETIF_F_HW_VLAN_CTAG_FILTER;
 
-        netdev->vlan_features |= NETIF_F_TSO;
-        netdev->vlan_features |= NETIF_F_TSO6;
-        netdev->vlan_features |= NETIF_F_IP_CSUM;
-        netdev->vlan_features |= NETIF_F_IPV6_CSUM;
-        netdev->vlan_features |= NETIF_F_SG;
+        netdev->vlan_features |= NETIF_F_TSO |
+                                 NETIF_F_TSO6 |
+                                 NETIF_F_IP_CSUM |
+                                 NETIF_F_IPV6_CSUM |
+                                 NETIF_F_SG;
 
         if (pci_using_dac)
                 netdev->features |= NETIF_F_HIGHDMA;
 
         netdev->priv_flags |= IFF_UNICAST_FLT;
 
-        init_timer(&adapter->watchdog_timer);
-        adapter->watchdog_timer.function = ixgbevf_watchdog;
-        adapter->watchdog_timer.data = (unsigned long)adapter;
-
         if (IXGBE_REMOVED(hw->hw_addr)) {
                 err = -EIO;
                 goto err_sw_init;
         }
-        INIT_WORK(&adapter->reset_task, ixgbevf_reset_task);
-        INIT_WORK(&adapter->watchdog_task, ixgbevf_watchdog_task);
-        set_bit(__IXGBEVF_WORK_INIT, &adapter->state);
+
+        setup_timer(&adapter->service_timer, &ixgbevf_service_timer,
+                    (unsigned long)adapter);
+
+        INIT_WORK(&adapter->service_task, ixgbevf_service_task);
+        set_bit(__IXGBEVF_SERVICE_INITED, &adapter->state);
+        clear_bit(__IXGBEVF_SERVICE_SCHED, &adapter->state);
 
         err = ixgbevf_init_interrupt_scheme(adapter);
         if (err)
@@ -3917,11 +4104,7 @@ static void ixgbevf_remove(struct pci_dev *pdev)
         adapter = netdev_priv(netdev);
 
         set_bit(__IXGBEVF_REMOVING, &adapter->state);
-
-        del_timer_sync(&adapter->watchdog_timer);
-
-        cancel_work_sync(&adapter->reset_task);
-        cancel_work_sync(&adapter->watchdog_task);
+        cancel_work_sync(&adapter->service_task);
 
         if (netdev->reg_state == NETREG_REGISTERED)
                 unregister_netdev(netdev);
@@ -3955,7 +4138,7 @@ static pci_ers_result_t ixgbevf_io_error_detected(struct pci_dev *pdev,
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 
-        if (!test_bit(__IXGBEVF_WORK_INIT, &adapter->state))
+        if (!test_bit(__IXGBEVF_SERVICE_INITED, &adapter->state))
                 return PCI_ERS_RESULT_DISCONNECT;
 
         rtnl_lock();
diff --git a/drivers/net/ethernet/intel/ixgbevf/regs.h b/drivers/net/ethernet/intel/ixgbevf/regs.h
index 09dd8f698bea..3e712fd6e695 100644
--- a/drivers/net/ethernet/intel/ixgbevf/regs.h
+++ b/drivers/net/ethernet/intel/ixgbevf/regs.h
@@ -69,6 +69,16 @@
 #define IXGBE_VFGOTC_LSB       0x02020
 #define IXGBE_VFGOTC_MSB       0x02024
 #define IXGBE_VFMPRC           0x01034
+#define IXGBE_VFMRQC           0x3000
+#define IXGBE_VFRSSRK(x)       (0x3100 + ((x) * 4))
+#define IXGBE_VFRETA(x)        (0x3200 + ((x) * 4))
+
+/* VFMRQC bits */
+#define IXGBE_VFMRQC_RSSEN              0x00000001  /* RSS Enable */
+#define IXGBE_VFMRQC_RSS_FIELD_IPV4_TCP 0x00010000
+#define IXGBE_VFMRQC_RSS_FIELD_IPV4     0x00020000
+#define IXGBE_VFMRQC_RSS_FIELD_IPV6     0x00100000
+#define IXGBE_VFMRQC_RSS_FIELD_IPV6_TCP 0x00200000
 
 #define IXGBE_WRITE_FLUSH(a) (IXGBE_READ_REG(a, IXGBE_VFSTATUS))
 
diff --git a/drivers/net/ethernet/jme.c b/drivers/net/ethernet/jme.c
index 44ce7d88f554..6e9a792097d3 100644
--- a/drivers/net/ethernet/jme.c
+++ b/drivers/net/ethernet/jme.c
@@ -2154,9 +2154,9 @@ jme_tx_csum(struct jme_adapter *jme, struct sk_buff *skb, u8 *flags)
 static inline void
 jme_tx_vlan(struct sk_buff *skb, __le16 *vlan, u8 *flags)
 {
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 *flags |= TXFLAG_TAGON;
-                *vlan = cpu_to_le16(vlan_tx_tag_get(skb));
+                *vlan = cpu_to_le16(skb_vlan_tag_get(skb));
         }
 }
 
diff --git a/drivers/net/ethernet/marvell/sky2.c b/drivers/net/ethernet/marvell/sky2.c
index 867a6a3ef81f..d9f4498832a1 100644
--- a/drivers/net/ethernet/marvell/sky2.c
+++ b/drivers/net/ethernet/marvell/sky2.c
@@ -1895,14 +1895,14 @@ static netdev_tx_t sky2_xmit_frame(struct sk_buff *skb,
         ctrl = 0;
 
         /* Add VLAN tag, can piggyback on LRGLEN or ADDR64 */
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 if (!le) {
                         le = get_tx_le(sky2, &slot);
                         le->addr = 0;
                         le->opcode = OP_VLAN|HW_OWNER;
                 } else
                         le->opcode |= OP_VLAN;
-                le->length = cpu_to_be16(vlan_tx_tag_get(skb));
+                le->length = cpu_to_be16(skb_vlan_tag_get(skb));
                 ctrl |= INS_VLAN;
         }
 
@@ -2594,7 +2594,7 @@ static struct sk_buff *sky2_receive(struct net_device *dev,
         sky2->rx_next = (sky2->rx_next + 1) % sky2->rx_pending;
         prefetch(sky2->rx_ring + sky2->rx_next);
 
-        if (vlan_tx_tag_present(re->skb))
+        if (skb_vlan_tag_present(re->skb))
                 count -= VLAN_HLEN;     /* Account for vlan tag */
 
         /* This chip has hardware problems that generates bogus status.
diff --git a/drivers/net/ethernet/mellanox/mlx4/alloc.c b/drivers/net/ethernet/mellanox/mlx4/alloc.c
index 963dd7e6d547..0c51c69f802f 100644
--- a/drivers/net/ethernet/mellanox/mlx4/alloc.c
+++ b/drivers/net/ethernet/mellanox/mlx4/alloc.c
@@ -592,7 +592,7 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
                 buf->nbufs        = 1;
                 buf->npages       = 1;
                 buf->page_shift   = get_order(size) + PAGE_SHIFT;
-                buf->direct.buf   = dma_alloc_coherent(&dev->pdev->dev,
+                buf->direct.buf   = dma_alloc_coherent(&dev->persist->pdev->dev,
                                                        size, &t, gfp);
                 if (!buf->direct.buf)
                         return -ENOMEM;
@@ -619,7 +619,8 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
 
                 for (i = 0; i < buf->nbufs; ++i) {
                         buf->page_list[i].buf =
-                                dma_alloc_coherent(&dev->pdev->dev, PAGE_SIZE,
+                                dma_alloc_coherent(&dev->persist->pdev->dev,
+                                                   PAGE_SIZE,
                                                    &t, gfp);
                         if (!buf->page_list[i].buf)
                                 goto err_free;
@@ -657,15 +658,17 @@ void mlx4_buf_free(struct mlx4_dev *dev, int size, struct mlx4_buf *buf)
         int i;
 
         if (buf->nbufs == 1)
-                dma_free_coherent(&dev->pdev->dev, size, buf->direct.buf,
+                dma_free_coherent(&dev->persist->pdev->dev, size,
+                                  buf->direct.buf,
                                   buf->direct.map);
         else {
-                if (BITS_PER_LONG == 64 && buf->direct.buf)
+                if (BITS_PER_LONG == 64)
                         vunmap(buf->direct.buf);
 
                 for (i = 0; i < buf->nbufs; ++i)
                         if (buf->page_list[i].buf)
-                                dma_free_coherent(&dev->pdev->dev, PAGE_SIZE,
+                                dma_free_coherent(&dev->persist->pdev->dev,
+                                                  PAGE_SIZE,
                                                   buf->page_list[i].buf,
                                                   buf->page_list[i].map);
                 kfree(buf->page_list);
@@ -738,7 +741,7 @@ int mlx4_db_alloc(struct mlx4_dev *dev, struct mlx4_db *db, int order, gfp_t gfp
                 if (!mlx4_alloc_db_from_pgdir(pgdir, db, order))
                         goto out;
 
-        pgdir = mlx4_alloc_db_pgdir(&(dev->pdev->dev), gfp);
+        pgdir = mlx4_alloc_db_pgdir(&dev->persist->pdev->dev, gfp);
         if (!pgdir) {
                 ret = -ENOMEM;
                 goto out;
@@ -775,7 +778,7 @@ void mlx4_db_free(struct mlx4_dev *dev, struct mlx4_db *db)
         set_bit(i, db->u.pgdir->bits[o]);
 
         if (bitmap_full(db->u.pgdir->order1, MLX4_DB_PER_PAGE / 2)) {
-                dma_free_coherent(&(dev->pdev->dev), PAGE_SIZE,
+                dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,
                                   db->u.pgdir->db_page, db->u.pgdir->db_dma);
                 list_del(&db->u.pgdir->list);
                 kfree(db->u.pgdir);
diff --git a/drivers/net/ethernet/mellanox/mlx4/catas.c b/drivers/net/ethernet/mellanox/mlx4/catas.c
index 9c656fe4983d..715de8affcc9 100644
--- a/drivers/net/ethernet/mellanox/mlx4/catas.c
+++ b/drivers/net/ethernet/mellanox/mlx4/catas.c
@@ -40,16 +40,177 @@ enum {
         MLX4_CATAS_POLL_INTERVAL        = 5 * HZ,
 };
 
-static DEFINE_SPINLOCK(catas_lock);
 
-static LIST_HEAD(catas_list);
-static struct work_struct catas_work;
 
-static int internal_err_reset = 1;
-module_param(internal_err_reset, int, 0644);
+int mlx4_internal_err_reset = 1;
+module_param_named(internal_err_reset, mlx4_internal_err_reset,  int, 0644);
 MODULE_PARM_DESC(internal_err_reset,
-                 "Reset device on internal errors if non-zero"
-                 " (default 1, in SRIOV mode default is 0)");
+                 "Reset device on internal errors if non-zero (default 1)");
+
+static int read_vendor_id(struct mlx4_dev *dev)
+{
+        u16 vendor_id = 0;
+        int ret;
+
+        ret = pci_read_config_word(dev->persist->pdev, 0, &vendor_id);
+        if (ret) {
+                mlx4_err(dev, "Failed to read vendor ID, ret=%d\n", ret);
+                return ret;
+        }
+
+        if (vendor_id == 0xffff) {
+                mlx4_err(dev, "PCI can't be accessed to read vendor id\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int mlx4_reset_master(struct mlx4_dev *dev)
+{
+        int err = 0;
+
+        if (mlx4_is_master(dev))
+                mlx4_report_internal_err_comm_event(dev);
+
+        if (!pci_channel_offline(dev->persist->pdev)) {
+                err = read_vendor_id(dev);
+                /* If PCI can't be accessed to read vendor ID we assume that its
+                 * link was disabled and chip was already reset.
+                 */
+                if (err)
+                        return 0;
+
+                err = mlx4_reset(dev);
+                if (err)
+                        mlx4_err(dev, "Fail to reset HCA\n");
+        }
+
+        return err;
+}
+
+static int mlx4_reset_slave(struct mlx4_dev *dev)
+{
+#define COM_CHAN_RST_REQ_OFFSET 0x10
+#define COM_CHAN_RST_ACK_OFFSET 0x08
+
+        u32 comm_flags;
+        u32 rst_req;
+        u32 rst_ack;
+        unsigned long end;
+        struct mlx4_priv *priv = mlx4_priv(dev);
+
+        if (pci_channel_offline(dev->persist->pdev))
+                return 0;
+
+        comm_flags = swab32(readl((__iomem char *)priv->mfunc.comm +
+                                  MLX4_COMM_CHAN_FLAGS));
+        if (comm_flags == 0xffffffff) {
+                mlx4_err(dev, "VF reset is not needed\n");
+                return 0;
+        }
+
+        if (!(dev->caps.vf_caps & MLX4_VF_CAP_FLAG_RESET)) {
+                mlx4_err(dev, "VF reset is not supported\n");
+                return -EOPNOTSUPP;
+        }
+
+        rst_req = (comm_flags & (u32)(1 << COM_CHAN_RST_REQ_OFFSET)) >>
+                COM_CHAN_RST_REQ_OFFSET;
+        rst_ack = (comm_flags & (u32)(1 << COM_CHAN_RST_ACK_OFFSET)) >>
+                COM_CHAN_RST_ACK_OFFSET;
+        if (rst_req != rst_ack) {
+                mlx4_err(dev, "Communication channel isn't sync, fail to send reset\n");
+                return -EIO;
+        }
+
+        rst_req ^= 1;
+        mlx4_warn(dev, "VF is sending reset request to Firmware\n");
+        comm_flags = rst_req << COM_CHAN_RST_REQ_OFFSET;
+        __raw_writel((__force u32)cpu_to_be32(comm_flags),
+                     (__iomem char *)priv->mfunc.comm + MLX4_COMM_CHAN_FLAGS);
+        /* Make sure that our comm channel write doesn't
+         * get mixed in with writes from another CPU.
+         */
+        mmiowb();
+
+        end = msecs_to_jiffies(MLX4_COMM_TIME) + jiffies;
+        while (time_before(jiffies, end)) {
+                comm_flags = swab32(readl((__iomem char *)priv->mfunc.comm +
+                                          MLX4_COMM_CHAN_FLAGS));
+                rst_ack = (comm_flags & (u32)(1 << COM_CHAN_RST_ACK_OFFSET)) >>
+                        COM_CHAN_RST_ACK_OFFSET;
+
+                /* Reading rst_req again since the communication channel can
+                 * be reset at any time by the PF and all its bits will be
+                 * set to zero.
+                 */
+                rst_req = (comm_flags & (u32)(1 << COM_CHAN_RST_REQ_OFFSET)) >>
+                        COM_CHAN_RST_REQ_OFFSET;
+
+                if (rst_ack == rst_req) {
+                        mlx4_warn(dev, "VF Reset succeed\n");
+                        return 0;
+                }
+                cond_resched();
+        }
+        mlx4_err(dev, "Fail to send reset over the communication channel\n");
+        return -ETIMEDOUT;
+}
+
+static int mlx4_comm_internal_err(u32 slave_read)
+{
+        return (u32)COMM_CHAN_EVENT_INTERNAL_ERR ==
+                (slave_read & (u32)COMM_CHAN_EVENT_INTERNAL_ERR) ? 1 : 0;
+}
+
+void mlx4_enter_error_state(struct mlx4_dev_persistent *persist)
+{
+        int err;
+        struct mlx4_dev *dev;
+
+        if (!mlx4_internal_err_reset)
+                return;
+
+        mutex_lock(&persist->device_state_mutex);
+        if (persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
+                goto out;
+
+        dev = persist->dev;
+        mlx4_err(dev, "device is going to be reset\n");
+        if (mlx4_is_slave(dev))
+                err = mlx4_reset_slave(dev);
+        else
+                err = mlx4_reset_master(dev);
+        BUG_ON(err != 0);
+
+        dev->persist->state |= MLX4_DEVICE_STATE_INTERNAL_ERROR;
+        mlx4_err(dev, "device was reset successfully\n");
+        mutex_unlock(&persist->device_state_mutex);
+
+        /* At that step HW was already reset, now notify clients */
+        mlx4_dispatch_event(dev, MLX4_DEV_EVENT_CATASTROPHIC_ERROR, 0);
+        mlx4_cmd_wake_completions(dev);
+        return;
+
+out:
+        mutex_unlock(&persist->device_state_mutex);
+}
+
+static void mlx4_handle_error_state(struct mlx4_dev_persistent *persist)
+{
+        int err = 0;
+
+        mlx4_enter_error_state(persist);
+        mutex_lock(&persist->interface_state_mutex);
+        if (persist->interface_state & MLX4_INTERFACE_STATE_UP &&
+            !(persist->interface_state & MLX4_INTERFACE_STATE_DELETION)) {
+                err = mlx4_restart_one(persist->pdev);
+                mlx4_info(persist->dev, "mlx4_restart_one was ended, ret=%d\n",
+                          err);
+        }
+        mutex_unlock(&persist->interface_state_mutex);
+}
 
 static void dump_err_buf(struct mlx4_dev *dev)
 {
@@ -67,58 +228,40 @@ static void poll_catas(unsigned long dev_ptr)
 {
         struct mlx4_dev *dev = (struct mlx4_dev *) dev_ptr;
         struct mlx4_priv *priv = mlx4_priv(dev);
+        u32 slave_read;
 
-        if (readl(priv->catas_err.map)) {
-                /* If the device is off-line, we cannot try to recover it */
-                if (pci_channel_offline(dev->pdev))
-                        mod_timer(&priv->catas_err.timer,
-                                  round_jiffies(jiffies + MLX4_CATAS_POLL_INTERVAL));
-                else {
-                        dump_err_buf(dev);
-                        mlx4_dispatch_event(dev, MLX4_DEV_EVENT_CATASTROPHIC_ERROR, 0);
-
-                        if (internal_err_reset) {
-                                spin_lock(&catas_lock);
-                                list_add(&priv->catas_err.list, &catas_list);
-                                spin_unlock(&catas_lock);
-
-                                queue_work(mlx4_wq, &catas_work);
-                        }
+        if (mlx4_is_slave(dev)) {
+                slave_read = swab32(readl(&priv->mfunc.comm->slave_read));
+                if (mlx4_comm_internal_err(slave_read)) {
+                        mlx4_warn(dev, "Internal error detected on the communication channel\n");
+                        goto internal_err;
                 }
-        } else
-                mod_timer(&priv->catas_err.timer,
-                          round_jiffies(jiffies + MLX4_CATAS_POLL_INTERVAL));
+        } else if (readl(priv->catas_err.map)) {
+                dump_err_buf(dev);
+                goto internal_err;
+        }
+
+        if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR) {
+                mlx4_warn(dev, "Internal error mark was detected on device\n");
+                goto internal_err;
+        }
+
+        mod_timer(&priv->catas_err.timer,
+                  round_jiffies(jiffies + MLX4_CATAS_POLL_INTERVAL));
+        return;
+
+internal_err:
+        if (mlx4_internal_err_reset)
+                queue_work(dev->persist->catas_wq, &dev->persist->catas_work);
 }
 
 static void catas_reset(struct work_struct *work)
 {
-        struct mlx4_priv *priv, *tmppriv;
-        struct mlx4_dev *dev;
+        struct mlx4_dev_persistent *persist =
+                container_of(work, struct mlx4_dev_persistent,
+                             catas_work);
 
-        LIST_HEAD(tlist);
-        int ret;
-
-        spin_lock_irq(&catas_lock);
-        list_splice_init(&catas_list, &tlist);
-        spin_unlock_irq(&catas_lock);
-
-        list_for_each_entry_safe(priv, tmppriv, &tlist, catas_err.list) {
-                struct pci_dev *pdev = priv->dev.pdev;
-
-                /* If the device is off-line, we cannot reset it */
-                if (pci_channel_offline(pdev))
-                        continue;
-
-                ret = mlx4_restart_one(priv->dev.pdev);
-                /* 'priv' now is not valid */
-                if (ret)
-                        pr_err("mlx4 %s: Reset failed (%d)\n",
-                               pci_name(pdev), ret);
-                else {
-                        dev  = pci_get_drvdata(pdev);
-                        mlx4_dbg(dev, "Reset succeeded\n");
-                }
-        }
+        mlx4_handle_error_state(persist);
 }
 
 void mlx4_start_catas_poll(struct mlx4_dev *dev)
@@ -126,22 +269,21 @@ void mlx4_start_catas_poll(struct mlx4_dev *dev)
         struct mlx4_priv *priv = mlx4_priv(dev);
         phys_addr_t addr;
 
-        /*If we are in SRIOV the default of the module param must be 0*/
-        if (mlx4_is_mfunc(dev))
-                internal_err_reset = 0;
-
         INIT_LIST_HEAD(&priv->catas_err.list);
         init_timer(&priv->catas_err.timer);
         priv->catas_err.map = NULL;
 
-        addr = pci_resource_start(dev->pdev, priv->fw.catas_bar) +
-                priv->fw.catas_offset;
+        if (!mlx4_is_slave(dev)) {
+                addr = pci_resource_start(dev->persist->pdev,
+                                          priv->fw.catas_bar) +
+                                          priv->fw.catas_offset;
 
-        priv->catas_err.map = ioremap(addr, priv->fw.catas_size * 4);
-        if (!priv->catas_err.map) {
-                mlx4_warn(dev, "Failed to map internal error buffer at 0x%llx\n",
-                          (unsigned long long) addr);
-                return;
+                priv->catas_err.map = ioremap(addr, priv->fw.catas_size * 4);
+                if (!priv->catas_err.map) {
+                        mlx4_warn(dev, "Failed to map internal error buffer at 0x%llx\n",
+                                  (unsigned long long)addr);
+                        return;
+                }
         }
 
         priv->catas_err.timer.data     = (unsigned long) dev;
@@ -157,15 +299,29 @@ void mlx4_stop_catas_poll(struct mlx4_dev *dev)
 
         del_timer_sync(&priv->catas_err.timer);
 
-        if (priv->catas_err.map)
+        if (priv->catas_err.map) {
                 iounmap(priv->catas_err.map);
+                priv->catas_err.map = NULL;
+        }
 
-        spin_lock_irq(&catas_lock);
-        list_del(&priv->catas_err.list);
-        spin_unlock_irq(&catas_lock);
+        if (dev->persist->interface_state & MLX4_INTERFACE_STATE_DELETION)
+                flush_workqueue(dev->persist->catas_wq);
 }
 
-void  __init mlx4_catas_init(void)
+int  mlx4_catas_init(struct mlx4_dev *dev)
 {
-        INIT_WORK(&catas_work, catas_reset);
+        INIT_WORK(&dev->persist->catas_work, catas_reset);
+        dev->persist->catas_wq = create_singlethread_workqueue("mlx4_health");
+        if (!dev->persist->catas_wq)
+                return -ENOMEM;
+
+        return 0;
+}
+
+void mlx4_catas_end(struct mlx4_dev *dev)
+{
+        if (dev->persist->catas_wq) {
+                destroy_workqueue(dev->persist->catas_wq);
+                dev->persist->catas_wq = NULL;
+        }
 }
diff --git a/drivers/net/ethernet/mellanox/mlx4/cmd.c b/drivers/net/ethernet/mellanox/mlx4/cmd.c
index 5c93d1451c44..a681d7c0bb9f 100644
--- a/drivers/net/ethernet/mellanox/mlx4/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx4/cmd.c
@@ -42,6 +42,7 @@
 #include <linux/mlx4/device.h>
 #include <linux/semaphore.h>
 #include <rdma/ib_smi.h>
+#include <linux/delay.h>
 
 #include <asm/io.h>
 
@@ -182,6 +183,72 @@ static u8 mlx4_errno_to_status(int errno)
         }
 }
 
+static int mlx4_internal_err_ret_value(struct mlx4_dev *dev, u16 op,
+                                       u8 op_modifier)
+{
+        switch (op) {
+        case MLX4_CMD_UNMAP_ICM:
+        case MLX4_CMD_UNMAP_ICM_AUX:
+        case MLX4_CMD_UNMAP_FA:
+        case MLX4_CMD_2RST_QP:
+        case MLX4_CMD_HW2SW_EQ:
+        case MLX4_CMD_HW2SW_CQ:
+        case MLX4_CMD_HW2SW_SRQ:
+        case MLX4_CMD_HW2SW_MPT:
+        case MLX4_CMD_CLOSE_HCA:
+        case MLX4_QP_FLOW_STEERING_DETACH:
+        case MLX4_CMD_FREE_RES:
+        case MLX4_CMD_CLOSE_PORT:
+                return CMD_STAT_OK;
+
+        case MLX4_CMD_QP_ATTACH:
+                /* On Detach case return success */
+                if (op_modifier == 0)
+                        return CMD_STAT_OK;
+                return mlx4_status_to_errno(CMD_STAT_INTERNAL_ERR);
+
+        default:
+                return mlx4_status_to_errno(CMD_STAT_INTERNAL_ERR);
+        }
+}
+
+static int mlx4_closing_cmd_fatal_error(u16 op, u8 fw_status)
+{
+        /* Any error during the closing commands below is considered fatal */
+        if (op == MLX4_CMD_CLOSE_HCA ||
+            op == MLX4_CMD_HW2SW_EQ ||
+            op == MLX4_CMD_HW2SW_CQ ||
+            op == MLX4_CMD_2RST_QP ||
+            op == MLX4_CMD_HW2SW_SRQ ||
+            op == MLX4_CMD_SYNC_TPT ||
+            op == MLX4_CMD_UNMAP_ICM ||
+            op == MLX4_CMD_UNMAP_ICM_AUX ||
+            op == MLX4_CMD_UNMAP_FA)
+                return 1;
+        /* Error on MLX4_CMD_HW2SW_MPT is fatal except when fw status equals
+          * CMD_STAT_REG_BOUND.
+          * This status indicates that memory region has memory windows bound to it
+          * which may result from invalid user space usage and is not fatal.
+          */
+        if (op == MLX4_CMD_HW2SW_MPT && fw_status != CMD_STAT_REG_BOUND)
+                return 1;
+        return 0;
+}
+
+static int mlx4_cmd_reset_flow(struct mlx4_dev *dev, u16 op, u8 op_modifier,
+                               int err)
+{
+        /* Only if reset flow is really active return code is based on
+          * command, otherwise current error code is returned.
+          */
+        if (mlx4_internal_err_reset) {
+                mlx4_enter_error_state(dev->persist);
+                err = mlx4_internal_err_ret_value(dev, op, op_modifier);
+        }
+
+        return err;
+}
+
 static int comm_pending(struct mlx4_dev *dev)
 {
         struct mlx4_priv *priv = mlx4_priv(dev);
@@ -190,16 +257,30 @@ static int comm_pending(struct mlx4_dev *dev)
         return (swab32(status) >> 31) != priv->cmd.comm_toggle;
 }
 
-static void mlx4_comm_cmd_post(struct mlx4_dev *dev, u8 cmd, u16 param)
+static int mlx4_comm_cmd_post(struct mlx4_dev *dev, u8 cmd, u16 param)
 {
         struct mlx4_priv *priv = mlx4_priv(dev);
         u32 val;
 
+        /* To avoid writing to unknown addresses after the device state was
+         * changed to internal error and the function was rest,
+         * check the INTERNAL_ERROR flag which is updated under
+         * device_state_mutex lock.
+         */
+        mutex_lock(&dev->persist->device_state_mutex);
+
+        if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR) {
+                mutex_unlock(&dev->persist->device_state_mutex);
+                return -EIO;
+        }
+
         priv->cmd.comm_toggle ^= 1;
         val = param | (cmd << 16) | (priv->cmd.comm_toggle << 31);
         __raw_writel((__force u32) cpu_to_be32(val),
                      &priv->mfunc.comm->slave_write);
         mmiowb();
+        mutex_unlock(&dev->persist->device_state_mutex);
+        return 0;
 }
 
 static int mlx4_comm_cmd_poll(struct mlx4_dev *dev, u8 cmd, u16 param,
@@ -219,7 +300,13 @@ static int mlx4_comm_cmd_poll(struct mlx4_dev *dev, u8 cmd, u16 param,
 
         /* Write command */
         down(&priv->cmd.poll_sem);
-        mlx4_comm_cmd_post(dev, cmd, param);
+        if (mlx4_comm_cmd_post(dev, cmd, param)) {
+                /* Only in case the device state is INTERNAL_ERROR,
+                 * mlx4_comm_cmd_post returns with an error
+                 */
+                err = mlx4_status_to_errno(CMD_STAT_INTERNAL_ERR);
+                goto out;
+        }
 
         end = msecs_to_jiffies(timeout) + jiffies;
         while (comm_pending(dev) && time_before(jiffies, end))
@@ -231,18 +318,23 @@ static int mlx4_comm_cmd_poll(struct mlx4_dev *dev, u8 cmd, u16 param,
                  * is MLX4_DELAY_RESET_SLAVE*/
                 if ((MLX4_COMM_CMD_RESET == cmd)) {
                         err = MLX4_DELAY_RESET_SLAVE;
+                        goto out;
                 } else {
-                        mlx4_warn(dev, "Communication channel timed out\n");
-                        err = -ETIMEDOUT;
+                        mlx4_warn(dev, "Communication channel command 0x%x timed out\n",
+                                  cmd);
+                        err = mlx4_status_to_errno(CMD_STAT_INTERNAL_ERR);
                 }
         }
 
+        if (err)
+                mlx4_enter_error_state(dev->persist);
+out:
         up(&priv->cmd.poll_sem);
         return err;
 }
 
-static int mlx4_comm_cmd_wait(struct mlx4_dev *dev, u8 op,
-                              u16 param, unsigned long timeout)
+static int mlx4_comm_cmd_wait(struct mlx4_dev *dev, u8 vhcr_cmd,
+                              u16 param, u16 op, unsigned long timeout)
 {
         struct mlx4_cmd *cmd = &mlx4_priv(dev)->cmd;
         struct mlx4_cmd_context *context;
@@ -258,34 +350,49 @@ static int mlx4_comm_cmd_wait(struct mlx4_dev *dev, u8 op,
         cmd->free_head = context->next;
         spin_unlock(&cmd->context_lock);
 
-        init_completion(&context->done);
+        reinit_completion(&context->done);
 
-        mlx4_comm_cmd_post(dev, op, param);
+        if (mlx4_comm_cmd_post(dev, vhcr_cmd, param)) {
+                /* Only in case the device state is INTERNAL_ERROR,
+                 * mlx4_comm_cmd_post returns with an error
+                 */
+                err = mlx4_status_to_errno(CMD_STAT_INTERNAL_ERR);
+                goto out;
+        }
 
         if (!wait_for_completion_timeout(&context->done,
                                          msecs_to_jiffies(timeout))) {
-                mlx4_warn(dev, "communication channel command 0x%x timed out\n",
-                          op);
-                err = -EBUSY;
-                goto out;
+                mlx4_warn(dev, "communication channel command 0x%x (op=0x%x) timed out\n",
+                          vhcr_cmd, op);
+                goto out_reset;
         }
 
         err = context->result;
         if (err && context->fw_status != CMD_STAT_MULTI_FUNC_REQ) {
                 mlx4_err(dev, "command 0x%x failed: fw status = 0x%x\n",
-                         op, context->fw_status);
-                goto out;
+                         vhcr_cmd, context->fw_status);
+                if (mlx4_closing_cmd_fatal_error(op, context->fw_status))
+                        goto out_reset;
         }
 
-out:
         /* wait for comm channel ready
          * this is necessary for prevention the race
          * when switching between event to polling mode
+         * Skipping this section in case the device is in FATAL_ERROR state,
+         * In this state, no commands are sent via the comm channel until
+         * the device has returned from reset.
          */
-        end = msecs_to_jiffies(timeout) + jiffies;
-        while (comm_pending(dev) && time_before(jiffies, end))
-                cond_resched();
+        if (!(dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)) {
+                end = msecs_to_jiffies(timeout) + jiffies;
+                while (comm_pending(dev) && time_before(jiffies, end))
+                        cond_resched();
+        }
+        goto out;
 
+out_reset:
+        err = mlx4_status_to_errno(CMD_STAT_INTERNAL_ERR);
+        mlx4_enter_error_state(dev->persist);
+out:
         spin_lock(&cmd->context_lock);
         context->next = cmd->free_head;
         cmd->free_head = context - cmd->context;
@@ -296,10 +403,13 @@ out:
 }
 
 int mlx4_comm_cmd(struct mlx4_dev *dev, u8 cmd, u16 param,
-                  unsigned long timeout)
+                  u16 op, unsigned long timeout)
 {
+        if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
+                return mlx4_status_to_errno(CMD_STAT_INTERNAL_ERR);
+
         if (mlx4_priv(dev)->cmd.use_events)
-                return mlx4_comm_cmd_wait(dev, cmd, param, timeout);
+                return mlx4_comm_cmd_wait(dev, cmd, param, op, timeout);
         return mlx4_comm_cmd_poll(dev, cmd, param, timeout);
 }
 
@@ -307,7 +417,7 @@ static int cmd_pending(struct mlx4_dev *dev)
 {
         u32 status;
 
-        if (pci_channel_offline(dev->pdev))
+        if (pci_channel_offline(dev->persist->pdev))
                 return -EIO;
 
         status = readl(mlx4_priv(dev)->cmd.hcr + HCR_STATUS_OFFSET);
@@ -323,17 +433,21 @@ static int mlx4_cmd_post(struct mlx4_dev *dev, u64 in_param, u64 out_param,
 {
         struct mlx4_cmd *cmd = &mlx4_priv(dev)->cmd;
         u32 __iomem *hcr = cmd->hcr;
-        int ret = -EAGAIN;
+        int ret = -EIO;
         unsigned long end;
 
-        mutex_lock(&cmd->hcr_mutex);
-
-        if (pci_channel_offline(dev->pdev)) {
+        mutex_lock(&dev->persist->device_state_mutex);
+        /* To avoid writing to unknown addresses after the device state was
+          * changed to internal error and the chip was reset,
+          * check the INTERNAL_ERROR flag which is updated under
+          * device_state_mutex lock.
+          */
+        if (pci_channel_offline(dev->persist->pdev) ||
+            (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)) {
                 /*
                  * Device is going through error recovery
                  * and cannot accept commands.
                  */
-                ret = -EIO;
                 goto out;
         }
 
@@ -342,12 +456,11 @@ static int mlx4_cmd_post(struct mlx4_dev *dev, u64 in_param, u64 out_param,
                 end += msecs_to_jiffies(GO_BIT_TIMEOUT_MSECS);
 
         while (cmd_pending(dev)) {
-                if (pci_channel_offline(dev->pdev)) {
+                if (pci_channel_offline(dev->persist->pdev)) {
                         /*
                          * Device is going through error recovery
                          * and cannot accept commands.
                          */
-                        ret = -EIO;
                         goto out;
                 }
 
@@ -391,7 +504,11 @@ static int mlx4_cmd_post(struct mlx4_dev *dev, u64 in_param, u64 out_param,
         ret = 0;
 
 out:
-        mutex_unlock(&cmd->hcr_mutex);
+        if (ret)
+                mlx4_warn(dev, "Could not post command 0x%x: ret=%d, in_param=0x%llx, in_mod=0x%x, op_mod=0x%x\n",
+                          op, ret, in_param, in_modifier, op_modifier);
+        mutex_unlock(&dev->persist->device_state_mutex);
+
         return ret;
 }
 
@@ -428,8 +545,11 @@ static int mlx4_slave_cmd(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
                         }
                         ret = mlx4_status_to_errno(vhcr->status);
                 }
+                if (ret &&
+                    dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
+                        ret = mlx4_internal_err_ret_value(dev, op, op_modifier);
         } else {
-                ret = mlx4_comm_cmd(dev, MLX4_COMM_CMD_VHCR_POST, 0,
+                ret = mlx4_comm_cmd(dev, MLX4_COMM_CMD_VHCR_POST, 0, op,
                                     MLX4_COMM_TIME + timeout);
                 if (!ret) {
                         if (out_is_imm) {
@@ -443,9 +563,14 @@ static int mlx4_slave_cmd(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
                                 }
                         }
                         ret = mlx4_status_to_errno(vhcr->status);
-                } else
-                        mlx4_err(dev, "failed execution of VHCR_POST command opcode 0x%x\n",
-                                 op);
+                } else {
+                        if (dev->persist->state &
+                            MLX4_DEVICE_STATE_INTERNAL_ERROR)
+                                ret = mlx4_internal_err_ret_value(dev, op,
+                                                                  op_modifier);
+                        else
+                                mlx4_err(dev, "failed execution of VHCR_POST command opcode 0x%x\n", op);
+                }
         }
 
         mutex_unlock(&priv->cmd.slave_cmd_mutex);
@@ -464,12 +589,12 @@ static int mlx4_cmd_poll(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
 
         down(&priv->cmd.poll_sem);
 
-        if (pci_channel_offline(dev->pdev)) {
+        if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR) {
                 /*
                  * Device is going through error recovery
                  * and cannot accept commands.
                  */
-                err = -EIO;
+                err = mlx4_internal_err_ret_value(dev, op, op_modifier);
                 goto out;
         }
 
@@ -483,16 +608,21 @@ static int mlx4_cmd_poll(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
         err = mlx4_cmd_post(dev, in_param, out_param ? *out_param : 0,
                             in_modifier, op_modifier, op, CMD_POLL_TOKEN, 0);
         if (err)
-                goto out;
+                goto out_reset;
 
         end = msecs_to_jiffies(timeout) + jiffies;
         while (cmd_pending(dev) && time_before(jiffies, end)) {
-                if (pci_channel_offline(dev->pdev)) {
+                if (pci_channel_offline(dev->persist->pdev)) {
                         /*
                          * Device is going through error recovery
                          * and cannot accept commands.
                          */
                         err = -EIO;
+                        goto out_reset;
+                }
+
+                if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR) {
+                        err = mlx4_internal_err_ret_value(dev, op, op_modifier);
                         goto out;
                 }
 
@@ -502,8 +632,8 @@ static int mlx4_cmd_poll(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
         if (cmd_pending(dev)) {
                 mlx4_warn(dev, "command 0x%x timed out (go bit not cleared)\n",
                           op);
-                err = -ETIMEDOUT;
-                goto out;
+                err = -EIO;
+                goto out_reset;
         }
 
         if (out_is_imm)
@@ -515,10 +645,17 @@ static int mlx4_cmd_poll(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
         stat = be32_to_cpu((__force __be32)
                            __raw_readl(hcr + HCR_STATUS_OFFSET)) >> 24;
         err = mlx4_status_to_errno(stat);
-        if (err)
+        if (err) {
                 mlx4_err(dev, "command 0x%x failed: fw status = 0x%x\n",
                          op, stat);
+                if (mlx4_closing_cmd_fatal_error(op, stat))
+                        goto out_reset;
+                goto out;
+        }
 
+out_reset:
+        if (err)
+                err = mlx4_cmd_reset_flow(dev, op, op_modifier, err);
 out:
         up(&priv->cmd.poll_sem);
         return err;
@@ -565,17 +702,19 @@ static int mlx4_cmd_wait(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
                 goto out;
         }
 
-        init_completion(&context->done);
+        reinit_completion(&context->done);
 
-        mlx4_cmd_post(dev, in_param, out_param ? *out_param : 0,
-                      in_modifier, op_modifier, op, context->token, 1);
+        err = mlx4_cmd_post(dev, in_param, out_param ? *out_param : 0,
+                            in_modifier, op_modifier, op, context->token, 1);
+        if (err)
+                goto out_reset;
 
         if (!wait_for_completion_timeout(&context->done,
                                          msecs_to_jiffies(timeout))) {
                 mlx4_warn(dev, "command 0x%x timed out (go bit not cleared)\n",
                           op);
-                err = -EBUSY;
-                goto out;
+                err = -EIO;
+                goto out_reset;
         }
 
         err = context->result;
@@ -592,12 +731,20 @@ static int mlx4_cmd_wait(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
                 else
                         mlx4_err(dev, "command 0x%x failed: fw status = 0x%x\n",
                                  op, context->fw_status);
+                if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
+                        err = mlx4_internal_err_ret_value(dev, op, op_modifier);
+                else if (mlx4_closing_cmd_fatal_error(op, context->fw_status))
+                        goto out_reset;
+
                 goto out;
         }
 
         if (out_is_imm)
                 *out_param = context->out_param;
 
+out_reset:
+        if (err)
+                err = mlx4_cmd_reset_flow(dev, op, op_modifier, err);
 out:
         spin_lock(&cmd->context_lock);
         context->next = cmd->free_head;
@@ -612,10 +759,13 @@ int __mlx4_cmd(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
                int out_is_imm, u32 in_modifier, u8 op_modifier,
                u16 op, unsigned long timeout, int native)
 {
-        if (pci_channel_offline(dev->pdev))
-                return -EIO;
+        if (pci_channel_offline(dev->persist->pdev))
+                return mlx4_cmd_reset_flow(dev, op, op_modifier, -EIO);
 
         if (!mlx4_is_mfunc(dev) || (native && mlx4_is_master(dev))) {
+                if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
+                        return mlx4_internal_err_ret_value(dev, op,
+                                                          op_modifier);
                 if (mlx4_priv(dev)->cmd.use_events)
                         return mlx4_cmd_wait(dev, in_param, out_param,
                                              out_is_imm, in_modifier,
@@ -631,7 +781,7 @@ int __mlx4_cmd(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
 EXPORT_SYMBOL_GPL(__mlx4_cmd);
 
 
-static int mlx4_ARM_COMM_CHANNEL(struct mlx4_dev *dev)
+int mlx4_ARM_COMM_CHANNEL(struct mlx4_dev *dev)
 {
         return mlx4_cmd(dev, 0, 0, 0, MLX4_CMD_ARM_COMM_CHANNEL,
                         MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
@@ -751,7 +901,9 @@ static int mlx4_MAD_IFC_wrapper(struct mlx4_dev *dev, int slave,
                                 index = be32_to_cpu(smp->attr_mod);
                                 if (port < 1 || port > dev->caps.num_ports)
                                         return -EINVAL;
-                                table = kcalloc(dev->caps.pkey_table_len[port], sizeof *table, GFP_KERNEL);
+                                table = kcalloc((dev->caps.pkey_table_len[port] / 32) + 1,
+                                                sizeof(*table) * 32, GFP_KERNEL);
+
                                 if (!table)
                                         return -ENOMEM;
                                 /* need to get the full pkey table because the paravirtualized
@@ -1071,7 +1223,7 @@ static struct mlx4_cmd_info cmd_info[] = {
         {
                 .opcode = MLX4_CMD_HW2SW_EQ,
                 .has_inbox = false,
-                .has_outbox = true,
+                .has_outbox = false,
                 .out_is_imm = false,
                 .encode_slave_id = true,
                 .verify = NULL,
@@ -1431,6 +1583,15 @@ static struct mlx4_cmd_info cmd_info[] = {
                 .verify = NULL,
                 .wrapper = mlx4_CMD_EPERM_wrapper
         },
+        {
+                .opcode = MLX4_CMD_VIRT_PORT_MAP,
+                .has_inbox = false,
+                .has_outbox = false,
+                .out_is_imm = false,
+                .encode_slave_id = false,
+                .verify = NULL,
+                .wrapper = mlx4_CMD_EPERM_wrapper
+        },
 };
 
 static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
@@ -1460,8 +1621,10 @@ static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
                                       ALIGN(sizeof(struct mlx4_vhcr_cmd),
                                             MLX4_ACCESS_MEM_ALIGN), 1);
                 if (ret) {
-                        mlx4_err(dev, "%s: Failed reading vhcr ret: 0x%x\n",
-                                 __func__, ret);
+                        if (!(dev->persist->state &
+                            MLX4_DEVICE_STATE_INTERNAL_ERROR))
+                                mlx4_err(dev, "%s: Failed reading vhcr ret: 0x%x\n",
+                                         __func__, ret);
                         kfree(vhcr);
                         return ret;
                 }
@@ -1500,11 +1663,14 @@ static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
                         goto out_status;
                 }
 
-                if (mlx4_ACCESS_MEM(dev, inbox->dma, slave,
-                                    vhcr->in_param,
-                                    MLX4_MAILBOX_SIZE, 1)) {
-                        mlx4_err(dev, "%s: Failed reading inbox (cmd:0x%x)\n",
-                                 __func__, cmd->opcode);
+                ret = mlx4_ACCESS_MEM(dev, inbox->dma, slave,
+                                      vhcr->in_param,
+                                      MLX4_MAILBOX_SIZE, 1);
+                if (ret) {
+                        if (!(dev->persist->state &
+                            MLX4_DEVICE_STATE_INTERNAL_ERROR))
+                                mlx4_err(dev, "%s: Failed reading inbox (cmd:0x%x)\n",
+                                         __func__, cmd->opcode);
                         vhcr_cmd->status = CMD_STAT_INTERNAL_ERR;
                         goto out_status;
                 }
@@ -1552,8 +1718,9 @@ static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
         }
 
         if (err) {
-                mlx4_warn(dev, "vhcr command:0x%x slave:%d failed with error:%d, status %d\n",
-                          vhcr->op, slave, vhcr->errno, err);
+                if (!(dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR))
+                        mlx4_warn(dev, "vhcr command:0x%x slave:%d failed with error:%d, status %d\n",
+                                  vhcr->op, slave, vhcr->errno, err);
                 vhcr_cmd->status = mlx4_errno_to_status(err);
                 goto out_status;
         }
@@ -1568,7 +1735,9 @@ static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
                         /* If we failed to write back the outbox after the
                          *command was successfully executed, we must fail this
                          * slave, as it is now in undefined state */
-                        mlx4_err(dev, "%s:Failed writing outbox\n", __func__);
+                        if (!(dev->persist->state &
+                            MLX4_DEVICE_STATE_INTERNAL_ERROR))
+                                mlx4_err(dev, "%s:Failed writing outbox\n", __func__);
                         goto out;
                 }
         }
@@ -1847,8 +2016,11 @@ static void mlx4_master_do_cmd(struct mlx4_dev *dev, int slave, u8 cmd,
                 break;
         case MLX4_COMM_CMD_VHCR_POST:
                 if ((slave_state[slave].last_cmd != MLX4_COMM_CMD_VHCR_EN) &&
-                    (slave_state[slave].last_cmd != MLX4_COMM_CMD_VHCR_POST))
+                    (slave_state[slave].last_cmd != MLX4_COMM_CMD_VHCR_POST)) {
+                        mlx4_warn(dev, "slave:%d is out of sync, cmd=0x%x, last command=0x%x, reset is needed\n",
+                                  slave, cmd, slave_state[slave].last_cmd);
                         goto reset_slave;
+                }
 
                 mutex_lock(&priv->cmd.slave_cmd_mutex);
                 if (mlx4_master_process_vhcr(dev, slave, NULL)) {
@@ -1882,7 +2054,18 @@ static void mlx4_master_do_cmd(struct mlx4_dev *dev, int slave, u8 cmd,
 
 reset_slave:
         /* cleanup any slave resources */
-        mlx4_delete_all_resources_for_slave(dev, slave);
+        if (dev->persist->interface_state & MLX4_INTERFACE_STATE_UP)
+                mlx4_delete_all_resources_for_slave(dev, slave);
+
+        if (cmd != MLX4_COMM_CMD_RESET) {
+                mlx4_warn(dev, "Turn on internal error to force reset, slave=%d, cmd=0x%x\n",
+                          slave, cmd);
+                /* Turn on internal error letting slave reset itself immeditaly,
+                 * otherwise it might take till timeout on command is passed
+                 */
+                reply |= ((u32)COMM_CHAN_EVENT_INTERNAL_ERR);
+        }
+
         spin_lock_irqsave(&priv->mfunc.master.slave_state_lock, flags);
         if (!slave_state[slave].is_slave_going_down)
                 slave_state[slave].last_cmd = MLX4_COMM_CMD_RESET;
@@ -1958,17 +2141,28 @@ void mlx4_master_comm_channel(struct work_struct *work)
 static int sync_toggles(struct mlx4_dev *dev)
 {
         struct mlx4_priv *priv = mlx4_priv(dev);
-        int wr_toggle;
-        int rd_toggle;
+        u32 wr_toggle;
+        u32 rd_toggle;
         unsigned long end;
 
-        wr_toggle = swab32(readl(&priv->mfunc.comm->slave_write)) >> 31;
-        end = jiffies + msecs_to_jiffies(5000);
+        wr_toggle = swab32(readl(&priv->mfunc.comm->slave_write));
+        if (wr_toggle == 0xffffffff)
+                end = jiffies + msecs_to_jiffies(30000);
+        else
+                end = jiffies + msecs_to_jiffies(5000);
 
         while (time_before(jiffies, end)) {
-                rd_toggle = swab32(readl(&priv->mfunc.comm->slave_read)) >> 31;
-                if (rd_toggle == wr_toggle) {
-                        priv->cmd.comm_toggle = rd_toggle;
+                rd_toggle = swab32(readl(&priv->mfunc.comm->slave_read));
+                if (wr_toggle == 0xffffffff || rd_toggle == 0xffffffff) {
+                        /* PCI might be offline */
+                        msleep(100);
+                        wr_toggle = swab32(readl(&priv->mfunc.comm->
+                                           slave_write));
+                        continue;
+                }
+
+                if (rd_toggle >> 31 == wr_toggle >> 31) {
+                        priv->cmd.comm_toggle = rd_toggle >> 31;
                         return 0;
                 }
 
@@ -1997,11 +2191,12 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
 
         if (mlx4_is_master(dev))
                 priv->mfunc.comm =
-                ioremap(pci_resource_start(dev->pdev, priv->fw.comm_bar) +
+                ioremap(pci_resource_start(dev->persist->pdev,
+                                           priv->fw.comm_bar) +
                         priv->fw.comm_base, MLX4_COMM_PAGESIZE);
         else
                 priv->mfunc.comm =
-                ioremap(pci_resource_start(dev->pdev, 2) +
+                ioremap(pci_resource_start(dev->persist->pdev, 2) +
                         MLX4_SLAVE_COMM_BASE, MLX4_COMM_PAGESIZE);
         if (!priv->mfunc.comm) {
                 mlx4_err(dev, "Couldn't map communication vector\n");
@@ -2073,13 +2268,6 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
                 if (mlx4_init_resource_tracker(dev))
                         goto err_thread;
 
-                err = mlx4_ARM_COMM_CHANNEL(dev);
-                if (err) {
-                        mlx4_err(dev, " Failed to arm comm channel eq: %x\n",
-                                 err);
-                        goto err_resource;
-                }
-
         } else {
                 err = sync_toggles(dev);
                 if (err) {
@@ -2089,8 +2277,6 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
         }
         return 0;
 
-err_resource:
-        mlx4_free_resource_tracker(dev, RES_TR_FREE_ALL);
 err_thread:
         flush_workqueue(priv->mfunc.master.comm_wq);
         destroy_workqueue(priv->mfunc.master.comm_wq);
@@ -2107,9 +2293,9 @@ err_comm_admin:
 err_comm:
         iounmap(priv->mfunc.comm);
 err_vhcr:
-        dma_free_coherent(&(dev->pdev->dev), PAGE_SIZE,
-                                             priv->mfunc.vhcr,
-                                             priv->mfunc.vhcr_dma);
+        dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,
+                          priv->mfunc.vhcr,
+                          priv->mfunc.vhcr_dma);
         priv->mfunc.vhcr = NULL;
         return -ENOMEM;
 }
@@ -2120,7 +2306,6 @@ int mlx4_cmd_init(struct mlx4_dev *dev)
         int flags = 0;
 
         if (!priv->cmd.initialized) {
-                mutex_init(&priv->cmd.hcr_mutex);
                 mutex_init(&priv->cmd.slave_cmd_mutex);
                 sema_init(&priv->cmd.poll_sem, 1);
                 priv->cmd.use_events = 0;
@@ -2130,8 +2315,8 @@ int mlx4_cmd_init(struct mlx4_dev *dev)
         }
 
         if (!mlx4_is_slave(dev) && !priv->cmd.hcr) {
-                priv->cmd.hcr = ioremap(pci_resource_start(dev->pdev, 0) +
-                                        MLX4_HCR_BASE, MLX4_HCR_SIZE);
+                priv->cmd.hcr = ioremap(pci_resource_start(dev->persist->pdev,
+                                        0) + MLX4_HCR_BASE, MLX4_HCR_SIZE);
                 if (!priv->cmd.hcr) {
                         mlx4_err(dev, "Couldn't map command register\n");
                         goto err;
@@ -2140,7 +2325,8 @@ int mlx4_cmd_init(struct mlx4_dev *dev)
         }
 
         if (mlx4_is_mfunc(dev) && !priv->mfunc.vhcr) {
-                priv->mfunc.vhcr = dma_alloc_coherent(&(dev->pdev->dev), PAGE_SIZE,
+                priv->mfunc.vhcr = dma_alloc_coherent(&dev->persist->pdev->dev,
+                                                      PAGE_SIZE,
                                                       &priv->mfunc.vhcr_dma,
                                                       GFP_KERNEL);
                 if (!priv->mfunc.vhcr)
@@ -2150,7 +2336,8 @@ int mlx4_cmd_init(struct mlx4_dev *dev)
         }
 
         if (!priv->cmd.pool) {
-                priv->cmd.pool = pci_pool_create("mlx4_cmd", dev->pdev,
+                priv->cmd.pool = pci_pool_create("mlx4_cmd",
+                                                 dev->persist->pdev,
                                                  MLX4_MAILBOX_SIZE,
                                                  MLX4_MAILBOX_SIZE, 0);
                 if (!priv->cmd.pool)
@@ -2166,6 +2353,27 @@ err:
         return -ENOMEM;
 }
 
+void mlx4_report_internal_err_comm_event(struct mlx4_dev *dev)
+{
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        int slave;
+        u32 slave_read;
+
+        /* Report an internal error event to all
+         * communication channels.
+         */
+        for (slave = 0; slave < dev->num_slaves; slave++) {
+                slave_read = swab32(readl(&priv->mfunc.comm[slave].slave_read));
+                slave_read |= (u32)COMM_CHAN_EVENT_INTERNAL_ERR;
+                __raw_writel((__force u32)cpu_to_be32(slave_read),
+                             &priv->mfunc.comm[slave].slave_read);
+                /* Make sure that our comm channel write doesn't
+                 * get mixed in with writes from another CPU.
+                 */
+                mmiowb();
+        }
+}
+
 void mlx4_multi_func_cleanup(struct mlx4_dev *dev)
 {
         struct mlx4_priv *priv = mlx4_priv(dev);
@@ -2181,6 +2389,7 @@ void mlx4_multi_func_cleanup(struct mlx4_dev *dev)
                 kfree(priv->mfunc.master.slave_state);
                 kfree(priv->mfunc.master.vf_admin);
                 kfree(priv->mfunc.master.vf_oper);
+                dev->num_slaves = 0;
         }
 
         iounmap(priv->mfunc.comm);
@@ -2202,7 +2411,7 @@ void mlx4_cmd_cleanup(struct mlx4_dev *dev, int cleanup_mask)
         }
         if (mlx4_is_mfunc(dev) && priv->mfunc.vhcr &&
             (cleanup_mask & MLX4_CMD_CLEANUP_VHCR)) {
-                dma_free_coherent(&(dev->pdev->dev), PAGE_SIZE,
+                dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,
                                   priv->mfunc.vhcr, priv->mfunc.vhcr_dma);
                 priv->mfunc.vhcr = NULL;
         }
@@ -2229,6 +2438,11 @@ int mlx4_cmd_use_events(struct mlx4_dev *dev)
         for (i = 0; i < priv->cmd.max_cmds; ++i) {
                 priv->cmd.context[i].token = i;
                 priv->cmd.context[i].next  = i + 1;
+                /* To support fatal error flow, initialize all
+                 * cmd contexts to allow simulating completions
+                 * with complete() at any time.
+                 */
+                init_completion(&priv->cmd.context[i].done);
         }
 
         priv->cmd.context[priv->cmd.max_cmds - 1].next = -1;
@@ -2306,8 +2520,9 @@ u32 mlx4_comm_get_version(void)
 
 static int mlx4_get_slave_indx(struct mlx4_dev *dev, int vf)
 {
-        if ((vf < 0) || (vf >= dev->num_vfs)) {
-                mlx4_err(dev, "Bad vf number:%d (number of activated vf: %d)\n", vf, dev->num_vfs);
+        if ((vf < 0) || (vf >= dev->persist->num_vfs)) {
+                mlx4_err(dev, "Bad vf number:%d (number of activated vf: %d)\n",
+                         vf, dev->persist->num_vfs);
                 return -EINVAL;
         }
 
@@ -2316,7 +2531,7 @@ static int mlx4_get_slave_indx(struct mlx4_dev *dev, int vf)
 
 int mlx4_get_vf_indx(struct mlx4_dev *dev, int slave)
 {
-        if (slave < 1 || slave > dev->num_vfs) {
+        if (slave < 1 || slave > dev->persist->num_vfs) {
                 mlx4_err(dev,
                          "Bad slave number:%d (number of activated slaves: %lu)\n",
                          slave, dev->num_slaves);
@@ -2325,6 +2540,25 @@ int mlx4_get_vf_indx(struct mlx4_dev *dev, int slave)
         return slave - 1;
 }
 
+void mlx4_cmd_wake_completions(struct mlx4_dev *dev)
+{
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        struct mlx4_cmd_context *context;
+        int i;
+
+        spin_lock(&priv->cmd.context_lock);
+        if (priv->cmd.context) {
+                for (i = 0; i < priv->cmd.max_cmds; ++i) {
+                        context = &priv->cmd.context[i];
+                        context->fw_status = CMD_STAT_INTERNAL_ERR;
+                        context->result    =
+                                mlx4_status_to_errno(CMD_STAT_INTERNAL_ERR);
+                        complete(&context->done);
+                }
+        }
+        spin_unlock(&priv->cmd.context_lock);
+}
+
 struct mlx4_active_ports mlx4_get_active_ports(struct mlx4_dev *dev, int slave)
 {
         struct mlx4_active_ports actv_ports;
@@ -2388,7 +2622,7 @@ struct mlx4_slaves_pport mlx4_phys_to_slaves_pport(struct mlx4_dev *dev,
         if (port <= 0 || port > dev->caps.num_ports)
                 return slaves_pport;
 
-        for (i = 0; i < dev->num_vfs + 1; i++) {
+        for (i = 0; i < dev->persist->num_vfs + 1; i++) {
                 struct mlx4_active_ports actv_ports =
                         mlx4_get_active_ports(dev, i);
                 if (test_bit(port - 1, actv_ports.ports))
@@ -2408,7 +2642,7 @@ struct mlx4_slaves_pport mlx4_phys_to_slaves_pport_actv(
 
         bitmap_zero(slaves_pport.slaves, MLX4_MFUNC_MAX);
 
-        for (i = 0; i < dev->num_vfs + 1; i++) {
+        for (i = 0; i < dev->persist->num_vfs + 1; i++) {
                 struct mlx4_active_ports actv_ports =
                         mlx4_get_active_ports(dev, i);
                 if (bitmap_equal(crit_ports->ports, actv_ports.ports,
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_clock.c b/drivers/net/ethernet/mellanox/mlx4/en_clock.c
index 999014413b1a..90b5309cdb5c 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_clock.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_clock.c
@@ -32,6 +32,7 @@
  */
 
 #include <linux/mlx4/device.h>
+#include <linux/clocksource.h>
 
 #include "mlx4_en.h"
 
@@ -147,12 +148,9 @@ static int mlx4_en_phc_adjtime(struct ptp_clock_info *ptp, s64 delta)
         struct mlx4_en_dev *mdev = container_of(ptp, struct mlx4_en_dev,
                                                 ptp_clock_info);
         unsigned long flags;
-        s64 now;
 
         write_lock_irqsave(&mdev->clock_lock, flags);
-        now = timecounter_read(&mdev->clock);
-        now += delta;
-        timecounter_init(&mdev->clock, &mdev->cycles, now);
+        timecounter_adjtime(&mdev->clock, delta);
         write_unlock_irqrestore(&mdev->clock_lock, flags);
 
         return 0;
@@ -243,7 +241,7 @@ void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev)
 {
         struct mlx4_dev *dev = mdev->dev;
         unsigned long flags;
-        u64 ns;
+        u64 ns, zero = 0;
 
         rwlock_init(&mdev->clock_lock);
 
@@ -268,7 +266,7 @@ void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev)
         /* Calculate period in seconds to call the overflow watchdog - to make
          * sure counter is checked at least once every wrap around.
          */
-        ns = cyclecounter_cyc2ns(&mdev->cycles, mdev->cycles.mask);
+        ns = cyclecounter_cyc2ns(&mdev->cycles, mdev->cycles.mask, zero, &zero);
         do_div(ns, NSEC_PER_SEC / 2 / HZ);
         mdev->overflow_period = ns;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_cq.c b/drivers/net/ethernet/mellanox/mlx4/en_cq.c
index 82322b1c8411..22da4d0d0f05 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_cq.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_cq.c
@@ -70,10 +70,10 @@ int mlx4_en_create_cq(struct mlx4_en_priv *priv,
         /* Allocate HW buffers on provided NUMA node.
          * dev->numa_node is used in mtt range allocation flow.
          */
-        set_dev_node(&mdev->dev->pdev->dev, node);
+        set_dev_node(&mdev->dev->persist->pdev->dev, node);
         err = mlx4_alloc_hwq_res(mdev->dev, &cq->wqres,
                                 cq->buf_size, 2 * PAGE_SIZE);
-        set_dev_node(&mdev->dev->pdev->dev, mdev->dev->numa_node);
+        set_dev_node(&mdev->dev->persist->pdev->dev, mdev->dev->numa_node);
         if (err)
                 goto err_cq;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c
index 90e0f045a6bc..a7b58ba8492b 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c
@@ -92,7 +92,7 @@ mlx4_en_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
                 (u16) (mdev->dev->caps.fw_ver >> 32),
                 (u16) ((mdev->dev->caps.fw_ver >> 16) & 0xffff),
                 (u16) (mdev->dev->caps.fw_ver & 0xffff));
-        strlcpy(drvinfo->bus_info, pci_name(mdev->dev->pdev),
+        strlcpy(drvinfo->bus_info, pci_name(mdev->dev->persist->pdev),
                 sizeof(drvinfo->bus_info));
         drvinfo->n_stats = 0;
         drvinfo->regdump_len = 0;
@@ -770,22 +770,20 @@ static int mlx4_en_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 return 0;
         }
 
-        proto_admin = cpu_to_be32(ptys_adv);
-        if (speed >= 0 && speed != priv->port_state.link_speed)
-                /* If speed was set then speed decides :-) */
-                proto_admin = speed_set_ptys_admin(priv, speed,
-                                                   ptys_reg.eth_proto_cap);
+        proto_admin = cmd->autoneg == AUTONEG_ENABLE ?
+                cpu_to_be32(ptys_adv) :
+                speed_set_ptys_admin(priv, speed,
+                                     ptys_reg.eth_proto_cap);
 
         proto_admin &= ptys_reg.eth_proto_cap;
-
-        if (proto_admin == ptys_reg.eth_proto_admin)
-                return 0; /* Nothing to change */
-
         if (!proto_admin) {
                 en_warn(priv, "Not supported link mode(s) requested, check supported link modes.\n");
                 return -EINVAL; /* nothing to change due to bad input */
         }
 
+        if (proto_admin == ptys_reg.eth_proto_admin)
+                return 0; /* Nothing to change */
+
         en_dbg(DRV, priv, "mlx4_ACCESS_PTYS_REG SET: ptys_reg.eth_proto_admin = 0x%x\n",
                be32_to_cpu(proto_admin));
 
@@ -798,9 +796,9 @@ static int mlx4_en_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 return ret;
         }
 
-        en_warn(priv, "Port link mode changed, restarting port...\n");
         mutex_lock(&priv->mdev->state_lock);
         if (priv->port_up) {
+                en_warn(priv, "Port link mode changed, restarting port...\n");
                 mlx4_en_stop_port(dev, 1);
                 if (mlx4_en_start_port(dev))
                         en_err(priv, "Failed restarting port %d\n", priv->port);
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_main.c b/drivers/net/ethernet/mellanox/mlx4/en_main.c
index 9f16f754137b..58d5a07d0ff4 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_main.c
@@ -214,6 +214,8 @@ static void mlx4_en_remove(struct mlx4_dev *dev, void *endev_ptr)
         iounmap(mdev->uar_map);
         mlx4_uar_free(dev, &mdev->priv_uar);
         mlx4_pd_free(dev, mdev->priv_pdn);
+        if (mdev->nb.notifier_call)
+                unregister_netdevice_notifier(&mdev->nb);
         kfree(mdev);
 }
 
@@ -241,8 +243,8 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
         spin_lock_init(&mdev->uar_lock);
 
         mdev->dev = dev;
-        mdev->dma_device = &(dev->pdev->dev);
-        mdev->pdev = dev->pdev;
+        mdev->dma_device = &dev->persist->pdev->dev;
+        mdev->pdev = dev->persist->pdev;
         mdev->device_up = false;
 
         mdev->LSO_support = !!(dev->caps.flags & (1 << 15));
@@ -298,6 +300,12 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
                 if (mlx4_en_init_netdev(mdev, i, &mdev->profile.prof[i]))
                         mdev->pndev[i] = NULL;
         }
+        /* register notifier */
+        mdev->nb.notifier_call = mlx4_en_netdev_event;
+        if (register_netdevice_notifier(&mdev->nb)) {
+                mdev->nb.notifier_call = NULL;
+                mlx4_err(mdev, "Failed to create notifier\n");
+        }
 
         return mdev;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
index ac6a8f1eea6c..2a210c4efb89 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
@@ -2062,6 +2062,7 @@ void mlx4_en_destroy_netdev(struct net_device *dev)
         /* Detach the netdev so tasks would not attempt to access it */
         mutex_lock(&mdev->state_lock);
         mdev->pndev[priv->port] = NULL;
+        mdev->upper[priv->port] = NULL;
         mutex_unlock(&mdev->state_lock);
 
         mlx4_en_free_resources(priv);
@@ -2201,6 +2202,10 @@ static int mlx4_en_set_features(struct net_device *netdev,
                         return ret;
         }
 
+        if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_HW_VLAN_CTAG_TX))
+                en_info(priv, "Turn %s TX vlan strip offload\n",
+                        (features & NETIF_F_HW_VLAN_CTAG_TX) ? "ON" : "OFF");
+
         if (features & NETIF_F_LOOPBACK)
                 priv->ctrl_flags |= cpu_to_be32(MLX4_WQE_CTRL_FORCE_LOOPBACK);
         else
@@ -2441,6 +2446,180 @@ static const struct net_device_ops mlx4_netdev_ops_master = {
 #endif
 };
 
+struct mlx4_en_bond {
+        struct work_struct work;
+        struct mlx4_en_priv *priv;
+        int is_bonded;
+        struct mlx4_port_map port_map;
+};
+
+static void mlx4_en_bond_work(struct work_struct *work)
+{
+        struct mlx4_en_bond *bond = container_of(work,
+                                                     struct mlx4_en_bond,
+                                                     work);
+        int err = 0;
+        struct mlx4_dev *dev = bond->priv->mdev->dev;
+
+        if (bond->is_bonded) {
+                if (!mlx4_is_bonded(dev)) {
+                        err = mlx4_bond(dev);
+                        if (err)
+                                en_err(bond->priv, "Fail to bond device\n");
+                }
+                if (!err) {
+                        err = mlx4_port_map_set(dev, &bond->port_map);
+                        if (err)
+                                en_err(bond->priv, "Fail to set port map [%d][%d]: %d\n",
+                                       bond->port_map.port1,
+                                       bond->port_map.port2,
+                                       err);
+                }
+        } else if (mlx4_is_bonded(dev)) {
+                err = mlx4_unbond(dev);
+                if (err)
+                        en_err(bond->priv, "Fail to unbond device\n");
+        }
+        dev_put(bond->priv->dev);
+        kfree(bond);
+}
+
+static int mlx4_en_queue_bond_work(struct mlx4_en_priv *priv, int is_bonded,
+                                   u8 v2p_p1, u8 v2p_p2)
+{
+        struct mlx4_en_bond *bond = NULL;
+
+        bond = kzalloc(sizeof(*bond), GFP_ATOMIC);
+        if (!bond)
+                return -ENOMEM;
+
+        INIT_WORK(&bond->work, mlx4_en_bond_work);
+        bond->priv = priv;
+        bond->is_bonded = is_bonded;
+        bond->port_map.port1 = v2p_p1;
+        bond->port_map.port2 = v2p_p2;
+        dev_hold(priv->dev);
+        queue_work(priv->mdev->workqueue, &bond->work);
+        return 0;
+}
+
+int mlx4_en_netdev_event(struct notifier_block *this,
+                         unsigned long event, void *ptr)
+{
+        struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
+        u8 port = 0;
+        struct mlx4_en_dev *mdev;
+        struct mlx4_dev *dev;
+        int i, num_eth_ports = 0;
+        bool do_bond = true;
+        struct mlx4_en_priv *priv;
+        u8 v2p_port1 = 0;
+        u8 v2p_port2 = 0;
+
+        if (!net_eq(dev_net(ndev), &init_net))
+                return NOTIFY_DONE;
+
+        mdev = container_of(this, struct mlx4_en_dev, nb);
+        dev = mdev->dev;
+
+        /* Go into this mode only when two network devices set on two ports
+         * of the same mlx4 device are slaves of the same bonding master
+         */
+        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH) {
+                ++num_eth_ports;
+                if (!port && (mdev->pndev[i] == ndev))
+                        port = i;
+                mdev->upper[i] = mdev->pndev[i] ?
+                        netdev_master_upper_dev_get(mdev->pndev[i]) : NULL;
+                /* condition not met: network device is a slave */
+                if (!mdev->upper[i])
+                        do_bond = false;
+                if (num_eth_ports < 2)
+                        continue;
+                /* condition not met: same master */
+                if (mdev->upper[i] != mdev->upper[i-1])
+                        do_bond = false;
+        }
+        /* condition not met: 2 salves */
+        do_bond = (num_eth_ports ==  2) ? do_bond : false;
+
+        /* handle only events that come with enough info */
+        if ((do_bond && (event != NETDEV_BONDING_INFO)) || !port)
+                return NOTIFY_DONE;
+
+        priv = netdev_priv(ndev);
+        if (do_bond) {
+                struct netdev_notifier_bonding_info *notifier_info = ptr;
+                struct netdev_bonding_info *bonding_info =
+                        &notifier_info->bonding_info;
+
+                /* required mode 1, 2 or 4 */
+                if ((bonding_info->master.bond_mode != BOND_MODE_ACTIVEBACKUP) &&
+                    (bonding_info->master.bond_mode != BOND_MODE_XOR) &&
+                    (bonding_info->master.bond_mode != BOND_MODE_8023AD))
+                        do_bond = false;
+
+                /* require exactly 2 slaves */
+                if (bonding_info->master.num_slaves != 2)
+                        do_bond = false;
+
+                /* calc v2p */
+                if (do_bond) {
+                        if (bonding_info->master.bond_mode ==
+                            BOND_MODE_ACTIVEBACKUP) {
+                                /* in active-backup mode virtual ports are
+                                 * mapped to the physical port of the active
+                                 * slave */
+                                if (bonding_info->slave.state ==
+                                    BOND_STATE_BACKUP) {
+                                        if (port == 1) {
+                                                v2p_port1 = 2;
+                                                v2p_port2 = 2;
+                                        } else {
+                                                v2p_port1 = 1;
+                                                v2p_port2 = 1;
+                                        }
+                                } else { /* BOND_STATE_ACTIVE */
+                                        if (port == 1) {
+                                                v2p_port1 = 1;
+                                                v2p_port2 = 1;
+                                        } else {
+                                                v2p_port1 = 2;
+                                                v2p_port2 = 2;
+                                        }
+                                }
+                        } else { /* Active-Active */
+                                /* in active-active mode a virtual port is
+                                 * mapped to the native physical port if and only
+                                 * if the physical port is up */
+                                __s8 link = bonding_info->slave.link;
+
+                                if (port == 1)
+                                        v2p_port2 = 2;
+                                else
+                                        v2p_port1 = 1;
+                                if ((link == BOND_LINK_UP) ||
+                                    (link == BOND_LINK_FAIL)) {
+                                        if (port == 1)
+                                                v2p_port1 = 1;
+                                        else
+                                                v2p_port2 = 2;
+                                } else { /* BOND_LINK_DOWN || BOND_LINK_BACK */
+                                        if (port == 1)
+                                                v2p_port1 = 2;
+                                        else
+                                                v2p_port2 = 1;
+                                }
+                        }
+                }
+        }
+
+        mlx4_en_queue_bond_work(priv, do_bond,
+                                v2p_port1, v2p_port2);
+
+        return NOTIFY_DONE;
+}
+
 int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
                         struct mlx4_en_port_profile *prof)
 {
@@ -2458,7 +2637,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
         netif_set_real_num_tx_queues(dev, prof->tx_ring_num);
         netif_set_real_num_rx_queues(dev, prof->rx_ring_num);
 
-        SET_NETDEV_DEV(dev, &mdev->dev->pdev->dev);
+        SET_NETDEV_DEV(dev, &mdev->dev->persist->pdev->dev);
         dev->dev_port = port - 1;
 
         /*
@@ -2623,6 +2802,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
         }
 
         mdev->pndev[port] = dev;
+        mdev->upper[port] = NULL;
 
         netif_carrier_off(dev);
         mlx4_en_set_default_moderation(priv);
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_resources.c b/drivers/net/ethernet/mellanox/mlx4/en_resources.c
index f1a5500ff72d..34f2fdf4fe5d 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_resources.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_resources.c
@@ -50,10 +50,14 @@ void mlx4_en_fill_qp_context(struct mlx4_en_priv *priv, int size, int stride,
         context->mtu_msgmax = 0xff;
         if (!is_tx && !rss)
                 context->rq_size_stride = ilog2(size) << 3 | (ilog2(stride) - 4);
-        if (is_tx)
+        if (is_tx) {
                 context->sq_size_stride = ilog2(size) << 3 | (ilog2(stride) - 4);
-        else
+                if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_PORT_REMAP)
+                        context->params2 |= MLX4_QP_BIT_FPP;
+
+        } else {
                 context->sq_size_stride = ilog2(TXBB_SIZE) - 4;
+        }
         context->usr_page = cpu_to_be32(mdev->priv_uar.index);
         context->local_qpn = cpu_to_be32(qpn);
         context->pri_path.ackto = 1 & 0x07;
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_rx.c b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
index a0474eb94aa3..698d60de1255 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
@@ -162,6 +162,10 @@ static int mlx4_en_init_allocator(struct mlx4_en_priv *priv,
                 if (mlx4_alloc_pages(priv, &ring->page_alloc[i],
                                      frag_info, GFP_KERNEL | __GFP_COLD))
                         goto out;
+
+                en_dbg(DRV, priv, "  frag %d allocator: - size:%d frags:%d\n",
+                       i, ring->page_alloc[i].page_size,
+                       atomic_read(&ring->page_alloc[i].page->_count));
         }
         return 0;
 
@@ -387,10 +391,10 @@ int mlx4_en_create_rx_ring(struct mlx4_en_priv *priv,
                  ring->rx_info, tmp);
 
         /* Allocate HW buffers on provided NUMA node */
-        set_dev_node(&mdev->dev->pdev->dev, node);
+        set_dev_node(&mdev->dev->persist->pdev->dev, node);
         err = mlx4_alloc_hwq_res(mdev->dev, &ring->wqres,
                                  ring->buf_size, 2 * PAGE_SIZE);
-        set_dev_node(&mdev->dev->pdev->dev, mdev->dev->numa_node);
+        set_dev_node(&mdev->dev->persist->pdev->dev, mdev->dev->numa_node);
         if (err)
                 goto err_info;
 
@@ -1059,8 +1063,9 @@ void mlx4_en_calc_rx_buf(struct net_device *dev)
                         (eff_mtu > buf_size + frag_sizes[i]) ?
                                 frag_sizes[i] : eff_mtu - buf_size;
                 priv->frag_info[i].frag_prefix_size = buf_size;
-                priv->frag_info[i].frag_stride = ALIGN(frag_sizes[i],
-                                                       SMP_CACHE_BYTES);
+                priv->frag_info[i].frag_stride =
+                                ALIGN(priv->frag_info[i].frag_size,
+                                      SMP_CACHE_BYTES);
                 buf_size += priv->frag_info[i].frag_size;
                 i++;
         }
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_tx.c b/drivers/net/ethernet/mellanox/mlx4/en_tx.c
index e3357bf523df..55f9f5c5344e 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_tx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_tx.c
@@ -91,10 +91,10 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
         ring->buf_size = ALIGN(size * ring->stride, MLX4_EN_PAGE_SIZE);
 
         /* Allocate HW buffers on provided NUMA node */
-        set_dev_node(&mdev->dev->pdev->dev, node);
+        set_dev_node(&mdev->dev->persist->pdev->dev, node);
         err = mlx4_alloc_hwq_res(mdev->dev, &ring->wqres, ring->buf_size,
                                  2 * PAGE_SIZE);
-        set_dev_node(&mdev->dev->pdev->dev, mdev->dev->numa_node);
+        set_dev_node(&mdev->dev->persist->pdev->dev, mdev->dev->numa_node);
         if (err) {
                 en_err(priv, "Failed allocating hwq resources\n");
                 goto err_bounce;
@@ -682,8 +682,8 @@ u16 mlx4_en_select_queue(struct net_device *dev, struct sk_buff *skb,
         if (dev->num_tc)
                 return skb_tx_hash(dev, skb);
 
-        if (vlan_tx_tag_present(skb))
-                up = vlan_tx_tag_get(skb) >> VLAN_PRIO_SHIFT;
+        if (skb_vlan_tag_present(skb))
+                up = skb_vlan_tag_get(skb) >> VLAN_PRIO_SHIFT;
 
         return fallback(dev, skb) % rings_p_up + up * rings_p_up;
 }
@@ -742,8 +742,8 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
                 goto tx_drop;
         }
 
-        if (vlan_tx_tag_present(skb))
-                vlan_tag = vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb))
+                vlan_tag = skb_vlan_tag_get(skb);
 
 
         netdev_txq_bql_enqueue_prefetchw(ring->tx_queue);
@@ -930,7 +930,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
         real_size = (real_size / 16) & 0x3f;
 
         if (ring->bf_enabled && desc_size <= MAX_BF && !bounce &&
-            !vlan_tx_tag_present(skb) && send_doorbell) {
+            !skb_vlan_tag_present(skb) && send_doorbell) {
                 tx_desc->ctrl.bf_qpn = ring->doorbell_qpn |
                                        cpu_to_be32(real_size);
 
@@ -952,7 +952,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
         } else {
                 tx_desc->ctrl.vlan_tag = cpu_to_be16(vlan_tag);
                 tx_desc->ctrl.ins_vlan = MLX4_WQE_CTRL_INS_VLAN *
-                        !!vlan_tx_tag_present(skb);
+                        !!skb_vlan_tag_present(skb);
                 tx_desc->ctrl.fence_size = real_size;
 
                 /* Ensure new descriptor hits memory
diff --git a/drivers/net/ethernet/mellanox/mlx4/eq.c b/drivers/net/ethernet/mellanox/mlx4/eq.c
index 3d275fbaf0eb..264bc15c1ff2 100644
--- a/drivers/net/ethernet/mellanox/mlx4/eq.c
+++ b/drivers/net/ethernet/mellanox/mlx4/eq.c
@@ -88,6 +88,8 @@ static u64 get_async_ev_mask(struct mlx4_dev *dev)
         u64 async_ev_mask = MLX4_ASYNC_EVENT_MASK;
         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_PORT_MNG_CHG_EV)
                 async_ev_mask |= (1ull << MLX4_EVENT_TYPE_PORT_MNG_CHG_EVENT);
+        if (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RECOVERABLE_ERROR_EVENT)
+                async_ev_mask |= (1ull << MLX4_EVENT_TYPE_RECOVERABLE_ERROR_EVENT);
 
         return async_ev_mask;
 }
@@ -237,7 +239,7 @@ int mlx4_gen_guid_change_eqe(struct mlx4_dev *dev, int slave, u8 port)
         struct mlx4_eqe eqe;
 
         /*don't send if we don't have the that slave */
-        if (dev->num_vfs < slave)
+        if (dev->persist->num_vfs < slave)
                 return 0;
         memset(&eqe, 0, sizeof eqe);
 
@@ -255,7 +257,7 @@ int mlx4_gen_port_state_change_eqe(struct mlx4_dev *dev, int slave, u8 port,
         struct mlx4_eqe eqe;
 
         /*don't send if we don't have the that slave */
-        if (dev->num_vfs < slave)
+        if (dev->persist->num_vfs < slave)
                 return 0;
         memset(&eqe, 0, sizeof eqe);
 
@@ -310,7 +312,7 @@ static void set_all_slave_state(struct mlx4_dev *dev, u8 port, int event)
         struct mlx4_slaves_pport slaves_pport = mlx4_phys_to_slaves_pport(dev,
                                                                           port);
 
-        for (i = 0; i < dev->num_vfs + 1; i++)
+        for (i = 0; i < dev->persist->num_vfs + 1; i++)
                 if (test_bit(i, slaves_pport.slaves))
                         set_and_calc_slave_port_state(dev, i, port,
                                                       event, &gen_event);
@@ -429,8 +431,14 @@ void mlx4_master_handle_slave_flr(struct work_struct *work)
                 if (MLX4_COMM_CMD_FLR == slave_state[i].last_cmd) {
                         mlx4_dbg(dev, "mlx4_handle_slave_flr: clean slave: %d\n",
                                  i);
-
-                        mlx4_delete_all_resources_for_slave(dev, i);
+                        /* In case of 'Reset flow' FLR can be generated for
+                         * a slave before mlx4_load_one is done.
+                         * make sure interface is up before trying to delete
+                         * slave resources which weren't allocated yet.
+                         */
+                        if (dev->persist->interface_state &
+                            MLX4_INTERFACE_STATE_UP)
+                                mlx4_delete_all_resources_for_slave(dev, i);
                         /*return the slave to running mode*/
                         spin_lock_irqsave(&priv->mfunc.master.slave_state_lock, flags);
                         slave_state[i].last_cmd = MLX4_COMM_CMD_RESET;
@@ -560,7 +568,8 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
                                 mlx4_priv(dev)->sense.do_sense_port[port] = 1;
                                 if (!mlx4_is_master(dev))
                                         break;
-                                for (i = 0; i < dev->num_vfs + 1; i++) {
+                                for (i = 0; i < dev->persist->num_vfs + 1;
+                                     i++) {
                                         if (!test_bit(i, slaves_port.slaves))
                                                 continue;
                                         if (dev->caps.port_type[port] == MLX4_PORT_TYPE_ETH) {
@@ -596,7 +605,9 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
                                 if (!mlx4_is_master(dev))
                                         break;
                                 if (dev->caps.port_type[port] == MLX4_PORT_TYPE_ETH)
-                                        for (i = 0; i < dev->num_vfs + 1; i++) {
+                                        for (i = 0;
+                                             i < dev->persist->num_vfs + 1;
+                                             i++) {
                                                 if (!test_bit(i, slaves_port.slaves))
                                                         continue;
                                                 if (i == mlx4_master_func_num(dev))
@@ -727,6 +738,26 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
                                             (unsigned long) eqe);
                         break;
 
+                case MLX4_EVENT_TYPE_RECOVERABLE_ERROR_EVENT:
+                        switch (eqe->subtype) {
+                        case MLX4_RECOVERABLE_ERROR_EVENT_SUBTYPE_BAD_CABLE:
+                                mlx4_warn(dev, "Bad cable detected on port %u\n",
+                                          eqe->event.bad_cable.port);
+                                break;
+                        case MLX4_RECOVERABLE_ERROR_EVENT_SUBTYPE_UNSUPPORTED_CABLE:
+                                mlx4_warn(dev, "Unsupported cable detected\n");
+                                break;
+                        default:
+                                mlx4_dbg(dev,
+                                         "Unhandled recoverable error event detected: %02x(%02x) on EQ %d at index %u. owner=%x, nent=0x%x, ownership=%s\n",
+                                         eqe->type, eqe->subtype, eq->eqn,
+                                         eq->cons_index, eqe->owner, eq->nent,
+                                         !!(eqe->owner & 0x80) ^
+                                         !!(eq->cons_index & eq->nent) ? "HW" : "SW");
+                                break;
+                        }
+                        break;
+
                 case MLX4_EVENT_TYPE_EEC_CATAS_ERROR:
                 case MLX4_EVENT_TYPE_ECC_DETECT:
                 default:
@@ -837,12 +868,10 @@ static int mlx4_SW2HW_EQ(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox,
                         MLX4_CMD_WRAPPED);
 }
 
-static int mlx4_HW2SW_EQ(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox,
-                         int eq_num)
+static int mlx4_HW2SW_EQ(struct mlx4_dev *dev,  int eq_num)
 {
-        return mlx4_cmd_box(dev, 0, mailbox->dma, eq_num,
-                            0, MLX4_CMD_HW2SW_EQ, MLX4_CMD_TIME_CLASS_A,
-                            MLX4_CMD_WRAPPED);
+        return mlx4_cmd(dev, 0, eq_num, 1, MLX4_CMD_HW2SW_EQ,
+                        MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
 }
 
 static int mlx4_num_eq_uar(struct mlx4_dev *dev)
@@ -865,7 +894,7 @@ static void __iomem *mlx4_get_eq_uar(struct mlx4_dev *dev, struct mlx4_eq *eq)
 
         if (!priv->eq_table.uar_map[index]) {
                 priv->eq_table.uar_map[index] =
-                        ioremap(pci_resource_start(dev->pdev, 2) +
+                        ioremap(pci_resource_start(dev->persist->pdev, 2) +
                                 ((eq->eqn / 4) << PAGE_SHIFT),
                                 PAGE_SIZE);
                 if (!priv->eq_table.uar_map[index]) {
@@ -928,8 +957,10 @@ static int mlx4_create_eq(struct mlx4_dev *dev, int nent,
         eq_context = mailbox->buf;
 
         for (i = 0; i < npages; ++i) {
-                eq->page_list[i].buf = dma_alloc_coherent(&dev->pdev->dev,
-                                                          PAGE_SIZE, &t, GFP_KERNEL);
+                eq->page_list[i].buf = dma_alloc_coherent(&dev->persist->
+                                                          pdev->dev,
+                                                          PAGE_SIZE, &t,
+                                                          GFP_KERNEL);
                 if (!eq->page_list[i].buf)
                         goto err_out_free_pages;
 
@@ -995,7 +1026,7 @@ err_out_free_eq:
 err_out_free_pages:
         for (i = 0; i < npages; ++i)
                 if (eq->page_list[i].buf)
-                        dma_free_coherent(&dev->pdev->dev, PAGE_SIZE,
+                        dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,
                                           eq->page_list[i].buf,
                                           eq->page_list[i].map);
 
@@ -1013,7 +1044,6 @@ static void mlx4_free_eq(struct mlx4_dev *dev,
                          struct mlx4_eq *eq)
 {
         struct mlx4_priv *priv = mlx4_priv(dev);
-        struct mlx4_cmd_mailbox *mailbox;
         int err;
         int i;
         /* CX3 is capable of extending the CQE/EQE from 32 to 64 bytes, with
@@ -1021,36 +1051,21 @@ static void mlx4_free_eq(struct mlx4_dev *dev,
          */
         int npages = PAGE_ALIGN(dev->caps.eqe_size  * eq->nent) / PAGE_SIZE;
 
-        mailbox = mlx4_alloc_cmd_mailbox(dev);
-        if (IS_ERR(mailbox))
-                return;
-
-        err = mlx4_HW2SW_EQ(dev, mailbox, eq->eqn);
+        err = mlx4_HW2SW_EQ(dev, eq->eqn);
         if (err)
                 mlx4_warn(dev, "HW2SW_EQ failed (%d)\n", err);
 
-        if (0) {
-                mlx4_dbg(dev, "Dumping EQ context %02x:\n", eq->eqn);
-                for (i = 0; i < sizeof (struct mlx4_eq_context) / 4; ++i) {
-                        if (i % 4 == 0)
-                                pr_cont("[%02x] ", i * 4);
-                        pr_cont(" %08x", be32_to_cpup(mailbox->buf + i * 4));
-                        if ((i + 1) % 4 == 0)
-                                pr_cont("\n");
-                }
-        }
         synchronize_irq(eq->irq);
         tasklet_disable(&eq->tasklet_ctx.task);
 
         mlx4_mtt_cleanup(dev, &eq->mtt);
         for (i = 0; i < npages; ++i)
-                dma_free_coherent(&dev->pdev->dev, PAGE_SIZE,
-                                    eq->page_list[i].buf,
-                                    eq->page_list[i].map);
+                dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,
+                                  eq->page_list[i].buf,
+                                  eq->page_list[i].map);
 
         kfree(eq->page_list);
         mlx4_bitmap_free(&priv->eq_table.bitmap, eq->eqn, MLX4_USE_RR);
-        mlx4_free_cmd_mailbox(dev, mailbox);
 }
 
 static void mlx4_free_irqs(struct mlx4_dev *dev)
@@ -1060,7 +1075,7 @@ static void mlx4_free_irqs(struct mlx4_dev *dev)
         int     i, vec;
 
         if (eq_table->have_irq)
-                free_irq(dev->pdev->irq, dev);
+                free_irq(dev->persist->pdev->irq, dev);
 
         for (i = 0; i < dev->caps.num_comp_vectors + 1; ++i)
                 if (eq_table->eq[i].have_irq) {
@@ -1089,7 +1104,8 @@ static int mlx4_map_clr_int(struct mlx4_dev *dev)
 {
         struct mlx4_priv *priv = mlx4_priv(dev);
 
-        priv->clr_base = ioremap(pci_resource_start(dev->pdev, priv->fw.clr_int_bar) +
+        priv->clr_base = ioremap(pci_resource_start(dev->persist->pdev,
+                                 priv->fw.clr_int_bar) +
                                  priv->fw.clr_int_base, MLX4_CLR_INT_SIZE);
         if (!priv->clr_base) {
                 mlx4_err(dev, "Couldn't map interrupt clear register, aborting\n");
@@ -1212,13 +1228,13 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
                                          i * MLX4_IRQNAME_SIZE,
                                          MLX4_IRQNAME_SIZE,
                                          "mlx4-comp-%d@pci:%s", i,
-                                         pci_name(dev->pdev));
+                                         pci_name(dev->persist->pdev));
                         } else {
                                 snprintf(priv->eq_table.irq_names +
                                          i * MLX4_IRQNAME_SIZE,
                                          MLX4_IRQNAME_SIZE,
                                          "mlx4-async@pci:%s",
-                                         pci_name(dev->pdev));
+                                         pci_name(dev->persist->pdev));
                         }
 
                         eq_name = priv->eq_table.irq_names +
@@ -1235,8 +1251,8 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
                 snprintf(priv->eq_table.irq_names,
                          MLX4_IRQNAME_SIZE,
                          DRV_NAME "@pci:%s",
-                         pci_name(dev->pdev));
-                err = request_irq(dev->pdev->irq, mlx4_interrupt,
+                         pci_name(dev->persist->pdev));
+                err = request_irq(dev->persist->pdev->irq, mlx4_interrupt,
                                   IRQF_SHARED, priv->eq_table.irq_names, dev);
                 if (err)
                         goto err_out_async;
diff --git a/drivers/net/ethernet/mellanox/mlx4/fw.c b/drivers/net/ethernet/mellanox/mlx4/fw.c
index 982861d1df44..5a21e5dc94cb 100644
--- a/drivers/net/ethernet/mellanox/mlx4/fw.c
+++ b/drivers/net/ethernet/mellanox/mlx4/fw.c
@@ -84,13 +84,10 @@ static void dump_dev_cap_flags(struct mlx4_dev *dev, u64 flags)
                 [ 1] = "UC transport",
                 [ 2] = "UD transport",
                 [ 3] = "XRC transport",
-                [ 4] = "reliable multicast",
-                [ 5] = "FCoIB support",
                 [ 6] = "SRQ support",
                 [ 7] = "IPoIB checksum offload",
                 [ 8] = "P_Key violation counter",
                 [ 9] = "Q_Key violation counter",
-                [10] = "VMM",
                 [12] = "Dual Port Different Protocol (DPDP) support",
                 [15] = "Big LSO headers",
                 [16] = "MW support",
@@ -99,12 +96,11 @@ static void dump_dev_cap_flags(struct mlx4_dev *dev, u64 flags)
                 [19] = "Raw multicast support",
                 [20] = "Address vector port checking support",
                 [21] = "UD multicast support",
-                [24] = "Demand paging support",
-                [25] = "Router support",
                 [30] = "IBoE support",
                 [32] = "Unicast loopback support",
                 [34] = "FCS header control",
-                [38] = "Wake On LAN support",
+                [37] = "Wake On LAN (port1) support",
+                [38] = "Wake On LAN (port2) support",
                 [40] = "UDP RSS support",
                 [41] = "Unicast VEP steering support",
                 [42] = "Multicast VEP steering support",
@@ -145,7 +141,9 @@ static void dump_dev_cap_flags2(struct mlx4_dev *dev, u64 flags)
                 [16] = "CONFIG DEV support",
                 [17] = "Asymmetric EQs support",
                 [18] = "More than 80 VFs support",
-                [19] = "Performance optimized for limited rule configuration flow steering support"
+                [19] = "Performance optimized for limited rule configuration flow steering support",
+                [20] = "Recoverable error events support",
+                [21] = "Port Remap support"
         };
         int i;
 
@@ -259,6 +257,7 @@ int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
 #define QUERY_FUNC_CAP_MCG_QUOTA_OFFSET_DEP     0x28
 #define QUERY_FUNC_CAP_MAX_EQ_OFFSET            0x2c
 #define QUERY_FUNC_CAP_RESERVED_EQ_OFFSET       0x30
+#define QUERY_FUNC_CAP_QP_RESD_LKEY_OFFSET      0x48
 
 #define QUERY_FUNC_CAP_QP_QUOTA_OFFSET          0x50
 #define QUERY_FUNC_CAP_CQ_QUOTA_OFFSET          0x54
@@ -273,6 +272,7 @@ int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
 #define QUERY_FUNC_CAP_FLAG_RDMA                0x40
 #define QUERY_FUNC_CAP_FLAG_ETH                 0x80
 #define QUERY_FUNC_CAP_FLAG_QUOTAS              0x10
+#define QUERY_FUNC_CAP_FLAG_RESD_LKEY           0x08
 #define QUERY_FUNC_CAP_FLAG_VALID_MAILBOX       0x04
 
 #define QUERY_FUNC_CAP_EXTRA_FLAGS_BF_QP_ALLOC_FLAG     (1UL << 31)
@@ -344,9 +344,12 @@ int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
         } else if (vhcr->op_modifier == 0) {
                 struct mlx4_active_ports actv_ports =
                         mlx4_get_active_ports(dev, slave);
-                /* enable rdma and ethernet interfaces, and new quota locations */
+                /* enable rdma and ethernet interfaces, new quota locations,
+                 * and reserved lkey
+                 */
                 field = (QUERY_FUNC_CAP_FLAG_ETH | QUERY_FUNC_CAP_FLAG_RDMA |
-                         QUERY_FUNC_CAP_FLAG_QUOTAS | QUERY_FUNC_CAP_FLAG_VALID_MAILBOX);
+                         QUERY_FUNC_CAP_FLAG_QUOTAS | QUERY_FUNC_CAP_FLAG_VALID_MAILBOX |
+                         QUERY_FUNC_CAP_FLAG_RESD_LKEY);
                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_FLAGS_OFFSET);
 
                 field = min(
@@ -411,6 +414,9 @@ int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
                 size = QUERY_FUNC_CAP_EXTRA_FLAGS_BF_QP_ALLOC_FLAG |
                         QUERY_FUNC_CAP_EXTRA_FLAGS_A0_QP_ALLOC_FLAG;
                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_EXTRA_FLAGS_OFFSET);
+
+                size = dev->caps.reserved_lkey + ((slave << 8) & 0xFF00);
+                MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP_RESD_LKEY_OFFSET);
         } else
                 err = -EINVAL;
 
@@ -503,6 +509,13 @@ int mlx4_QUERY_FUNC_CAP(struct mlx4_dev *dev, u8 gen_or_port,
                 MLX4_GET(size, outbox, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
                 func_cap->reserved_eq = size & 0xFFFFFF;
 
+                if (func_cap->flags & QUERY_FUNC_CAP_FLAG_RESD_LKEY) {
+                        MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP_RESD_LKEY_OFFSET);
+                        func_cap->reserved_lkey = size;
+                } else {
+                        func_cap->reserved_lkey = 0;
+                }
+
                 func_cap->extra_flags = 0;
 
                 /* Mailbox data from 0x6c and onward should only be treated if
@@ -851,6 +864,8 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_EQE_STRIDE;
         MLX4_GET(dev_cap->bmme_flags, outbox,
                  QUERY_DEV_CAP_BMME_FLAGS_OFFSET);
+        if (dev_cap->bmme_flags & MLX4_FLAG_PORT_REMAP)
+                dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_PORT_REMAP;
         MLX4_GET(field, outbox, QUERY_DEV_CAP_CONFIG_DEV_OFFSET);
         if (field & 0x20)
                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_CONFIG_DEV;
@@ -859,6 +874,8 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
         MLX4_GET(field32, outbox, QUERY_DEV_CAP_ETH_BACKPL_OFFSET);
         if (field32 & (1 << 0))
                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP;
+        if (field32 & (1 << 7))
+                dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_RECOVERABLE_ERROR_EVENT;
         MLX4_GET(field, outbox, QUERY_DEV_CAP_FW_REASSIGN_MAC);
         if (field & 1<<6)
                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_REASSIGN_MAC_EN;
@@ -1106,9 +1123,10 @@ int mlx4_QUERY_DEV_CAP_wrapper(struct mlx4_dev *dev, int slave,
         field &= 0x7f;
         MLX4_PUT(outbox->buf, field, QUERY_DEV_CAP_BF_OFFSET);
 
-        /* For guests, disable mw type 2 */
+        /* For guests, disable mw type 2 and port remap*/
         MLX4_GET(bmme_flags, outbox->buf, QUERY_DEV_CAP_BMME_FLAGS_OFFSET);
         bmme_flags &= ~MLX4_BMME_FLAG_TYPE_2_WIN;
+        bmme_flags &= ~MLX4_FLAG_PORT_REMAP;
         MLX4_PUT(outbox->buf, bmme_flags, QUERY_DEV_CAP_BMME_FLAGS_OFFSET);
 
         /* turn off device-managed steering capability if not enabled */
@@ -1562,6 +1580,7 @@ int mlx4_INIT_HCA(struct mlx4_dev *dev, struct mlx4_init_hca_param *param)
 #define INIT_HCA_VXLAN_OFFSET            0x0c
 #define INIT_HCA_CACHELINE_SZ_OFFSET     0x0e
 #define INIT_HCA_FLAGS_OFFSET            0x014
+#define INIT_HCA_RECOVERABLE_ERROR_EVENT_OFFSET 0x018
 #define INIT_HCA_QPC_OFFSET              0x020
 #define  INIT_HCA_QPC_BASE_OFFSET        (INIT_HCA_QPC_OFFSET + 0x10)
 #define  INIT_HCA_LOG_QP_OFFSET          (INIT_HCA_QPC_OFFSET + 0x17)
@@ -1668,6 +1687,9 @@ int mlx4_INIT_HCA(struct mlx4_dev *dev, struct mlx4_init_hca_param *param)
                 dev->caps.userspace_caps |= MLX4_USER_DEV_CAP_LARGE_CQE;
         }
 
+        if (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RECOVERABLE_ERROR_EVENT)
+                *(inbox + INIT_HCA_RECOVERABLE_ERROR_EVENT_OFFSET / 4) |= cpu_to_be32(1 << 31);
+
         /* QPC/EEC/CQC/EQC/RDMARC attributes */
 
         MLX4_PUT(inbox, param->qpc_base,      INIT_HCA_QPC_BASE_OFFSET);
@@ -1752,8 +1774,8 @@ int mlx4_INIT_HCA(struct mlx4_dev *dev, struct mlx4_init_hca_param *param)
                 MLX4_PUT(inbox, parser_params,  INIT_HCA_VXLAN_OFFSET);
         }
 
-        err = mlx4_cmd(dev, mailbox->dma, 0, 0, MLX4_CMD_INIT_HCA, 10000,
-                       MLX4_CMD_NATIVE);
+        err = mlx4_cmd(dev, mailbox->dma, 0, 0, MLX4_CMD_INIT_HCA,
+                       MLX4_CMD_TIME_CLASS_C, MLX4_CMD_NATIVE);
 
         if (err)
                 mlx4_err(dev, "INIT_HCA returns %d\n", err);
@@ -1879,6 +1901,36 @@ out:
         return err;
 }
 
+static int mlx4_hca_core_clock_update(struct mlx4_dev *dev)
+{
+        struct mlx4_cmd_mailbox *mailbox;
+        __be32 *outbox;
+        int err;
+
+        mailbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(mailbox)) {
+                mlx4_warn(dev, "hca_core_clock mailbox allocation failed\n");
+                return PTR_ERR(mailbox);
+        }
+        outbox = mailbox->buf;
+
+        err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0,
+                           MLX4_CMD_QUERY_HCA,
+                           MLX4_CMD_TIME_CLASS_B,
+                           !mlx4_is_slave(dev));
+        if (err) {
+                mlx4_warn(dev, "hca_core_clock update failed\n");
+                goto out;
+        }
+
+        MLX4_GET(dev->caps.hca_core_clock, outbox, QUERY_HCA_CORE_CLOCK_OFFSET);
+
+out:
+        mlx4_free_cmd_mailbox(dev, mailbox);
+
+        return err;
+}
+
 /* for IB-type ports only in SRIOV mode. Checks that both proxy QP0
  * and real QP0 are active, so that the paravirtualized QP0 is ready
  * to operate */
@@ -1983,6 +2035,9 @@ int mlx4_INIT_PORT(struct mlx4_dev *dev, int port)
                 err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_INIT_PORT,
                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
 
+        if (!err)
+                mlx4_hca_core_clock_update(dev);
+
         return err;
 }
 EXPORT_SYMBOL_GPL(mlx4_INIT_PORT);
@@ -2007,7 +2062,7 @@ int mlx4_CLOSE_PORT_wrapper(struct mlx4_dev *dev, int slave,
         if (dev->caps.port_mask[port] != MLX4_PORT_TYPE_IB) {
                 if (priv->mfunc.master.init_port_ref[port] == 1) {
                         err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT,
-                                       1000, MLX4_CMD_NATIVE);
+                                       MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
                         if (err)
                                 return err;
                 }
@@ -2018,7 +2073,7 @@ int mlx4_CLOSE_PORT_wrapper(struct mlx4_dev *dev, int slave,
                         if (!priv->mfunc.master.qp0_state[port].qp0_active &&
                             priv->mfunc.master.qp0_state[port].port_active) {
                                 err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT,
-                                               1000, MLX4_CMD_NATIVE);
+                                               MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
                                 if (err)
                                         return err;
                                 priv->mfunc.master.slave_state[slave].init_port_mask &= ~(1 << port);
@@ -2033,15 +2088,15 @@ int mlx4_CLOSE_PORT_wrapper(struct mlx4_dev *dev, int slave,
 
 int mlx4_CLOSE_PORT(struct mlx4_dev *dev, int port)
 {
-        return mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT, 1000,
-                        MLX4_CMD_WRAPPED);
+        return mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT,
+                        MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
 }
 EXPORT_SYMBOL_GPL(mlx4_CLOSE_PORT);
 
 int mlx4_CLOSE_HCA(struct mlx4_dev *dev, int panic)
 {
-        return mlx4_cmd(dev, 0, 0, panic, MLX4_CMD_CLOSE_HCA, 1000,
-                        MLX4_CMD_NATIVE);
+        return mlx4_cmd(dev, 0, 0, panic, MLX4_CMD_CLOSE_HCA,
+                        MLX4_CMD_TIME_CLASS_C, MLX4_CMD_NATIVE);
 }
 
 struct mlx4_config_dev {
@@ -2049,13 +2104,16 @@ struct mlx4_config_dev {
         __be32  rsvd1[3];
         __be16  vxlan_udp_dport;
         __be16  rsvd2;
-        __be32  rsvd3[27];
-        __be16  rsvd4;
-        u8      rsvd5;
+        __be32  rsvd3;
+        __be32  roce_flags;
+        __be32  rsvd4[25];
+        __be16  rsvd5;
+        u8      rsvd6;
         u8      rx_checksum_val;
 };
 
 #define MLX4_VXLAN_UDP_DPORT (1 << 0)
+#define MLX4_DISABLE_RX_PORT BIT(18)
 
 static int mlx4_CONFIG_DEV_set(struct mlx4_dev *dev, struct mlx4_config_dev *config_dev)
 {
@@ -2111,7 +2169,7 @@ static const u8 config_dev_csum_flags[] = {
 int mlx4_config_dev_retrieval(struct mlx4_dev *dev,
                               struct mlx4_config_dev_params *params)
 {
-        struct mlx4_config_dev config_dev;
+        struct mlx4_config_dev config_dev = {0};
         int err;
         u8 csum_mask;
 
@@ -2158,6 +2216,45 @@ int mlx4_config_vxlan_port(struct mlx4_dev *dev, __be16 udp_port)
 }
 EXPORT_SYMBOL_GPL(mlx4_config_vxlan_port);
 
+#define CONFIG_DISABLE_RX_PORT BIT(15)
+int mlx4_disable_rx_port_check(struct mlx4_dev *dev, bool dis)
+{
+        struct mlx4_config_dev config_dev;
+
+        memset(&config_dev, 0, sizeof(config_dev));
+        config_dev.update_flags = cpu_to_be32(MLX4_DISABLE_RX_PORT);
+        if (dis)
+                config_dev.roce_flags =
+                        cpu_to_be32(CONFIG_DISABLE_RX_PORT);
+
+        return mlx4_CONFIG_DEV_set(dev, &config_dev);
+}
+
+int mlx4_virt2phy_port_map(struct mlx4_dev *dev, u32 port1, u32 port2)
+{
+        struct mlx4_cmd_mailbox *mailbox;
+        struct {
+                __be32 v_port1;
+                __be32 v_port2;
+        } *v2p;
+        int err;
+
+        mailbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(mailbox))
+                return -ENOMEM;
+
+        v2p = mailbox->buf;
+        v2p->v_port1 = cpu_to_be32(port1);
+        v2p->v_port2 = cpu_to_be32(port2);
+
+        err = mlx4_cmd(dev, mailbox->dma, 0,
+                       MLX4_SET_PORT_VIRT2PHY, MLX4_CMD_VIRT_PORT_MAP,
+                       MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
+
+        mlx4_free_cmd_mailbox(dev, mailbox);
+        return err;
+}
+
 
 int mlx4_SET_ICM_SIZE(struct mlx4_dev *dev, u64 icm_size, u64 *aux_pages)
 {
@@ -2180,7 +2277,8 @@ int mlx4_SET_ICM_SIZE(struct mlx4_dev *dev, u64 icm_size, u64 *aux_pages)
 int mlx4_NOP(struct mlx4_dev *dev)
 {
         /* Input modifier of 0x1f means "finish as soon as possible." */
-        return mlx4_cmd(dev, 0, 0x1f, 0, MLX4_CMD_NOP, 100, MLX4_CMD_NATIVE);
+        return mlx4_cmd(dev, 0, 0x1f, 0, MLX4_CMD_NOP, MLX4_CMD_TIME_CLASS_A,
+                        MLX4_CMD_NATIVE);
 }
 
 int mlx4_get_phys_port_id(struct mlx4_dev *dev)
diff --git a/drivers/net/ethernet/mellanox/mlx4/fw.h b/drivers/net/ethernet/mellanox/mlx4/fw.h
index 62562b60fa87..f44f7f6017ed 100644
--- a/drivers/net/ethernet/mellanox/mlx4/fw.h
+++ b/drivers/net/ethernet/mellanox/mlx4/fw.h
@@ -147,6 +147,7 @@ struct mlx4_func_cap {
         u32     qp0_proxy_qpn;
         u32     qp1_tunnel_qpn;
         u32     qp1_proxy_qpn;
+        u32     reserved_lkey;
         u8      physical_port;
         u8      port_flags;
         u8      flags1;
diff --git a/drivers/net/ethernet/mellanox/mlx4/icm.c b/drivers/net/ethernet/mellanox/mlx4/icm.c
index 97c9b1db1d27..2a9dd460a95f 100644
--- a/drivers/net/ethernet/mellanox/mlx4/icm.c
+++ b/drivers/net/ethernet/mellanox/mlx4/icm.c
@@ -56,7 +56,7 @@ static void mlx4_free_icm_pages(struct mlx4_dev *dev, struct mlx4_icm_chunk *chu
         int i;
 
         if (chunk->nsg > 0)
-                pci_unmap_sg(dev->pdev, chunk->mem, chunk->npages,
+                pci_unmap_sg(dev->persist->pdev, chunk->mem, chunk->npages,
                              PCI_DMA_BIDIRECTIONAL);
 
         for (i = 0; i < chunk->npages; ++i)
@@ -69,7 +69,8 @@ static void mlx4_free_icm_coherent(struct mlx4_dev *dev, struct mlx4_icm_chunk *
         int i;
 
         for (i = 0; i < chunk->npages; ++i)
-                dma_free_coherent(&dev->pdev->dev, chunk->mem[i].length,
+                dma_free_coherent(&dev->persist->pdev->dev,
+                                  chunk->mem[i].length,
                                   lowmem_page_address(sg_page(&chunk->mem[i])),
                                   sg_dma_address(&chunk->mem[i]));
 }
@@ -173,7 +174,7 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
                         --cur_order;
 
                 if (coherent)
-                        ret = mlx4_alloc_icm_coherent(&dev->pdev->dev,
+                        ret = mlx4_alloc_icm_coherent(&dev->persist->pdev->dev,
                                                       &chunk->mem[chunk->npages],
                                                       cur_order, gfp_mask);
                 else
@@ -193,7 +194,7 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
                 if (coherent)
                         ++chunk->nsg;
                 else if (chunk->npages == MLX4_ICM_CHUNK_LEN) {
-                        chunk->nsg = pci_map_sg(dev->pdev, chunk->mem,
+                        chunk->nsg = pci_map_sg(dev->persist->pdev, chunk->mem,
                                                 chunk->npages,
                                                 PCI_DMA_BIDIRECTIONAL);
 
@@ -208,7 +209,7 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
         }
 
         if (!coherent && chunk) {
-                chunk->nsg = pci_map_sg(dev->pdev, chunk->mem,
+                chunk->nsg = pci_map_sg(dev->persist->pdev, chunk->mem,
                                         chunk->npages,
                                         PCI_DMA_BIDIRECTIONAL);
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/intf.c b/drivers/net/ethernet/mellanox/mlx4/intf.c
index 116895ac8b35..6fce58718837 100644
--- a/drivers/net/ethernet/mellanox/mlx4/intf.c
+++ b/drivers/net/ethernet/mellanox/mlx4/intf.c
@@ -33,11 +33,13 @@
 
 #include <linux/slab.h>
 #include <linux/export.h>
+#include <linux/errno.h>
 
 #include "mlx4.h"
 
 struct mlx4_device_context {
         struct list_head        list;
+        struct list_head        bond_list;
         struct mlx4_interface  *intf;
         void                   *context;
 };
@@ -115,6 +117,58 @@ void mlx4_unregister_interface(struct mlx4_interface *intf)
 }
 EXPORT_SYMBOL_GPL(mlx4_unregister_interface);
 
+int mlx4_do_bond(struct mlx4_dev *dev, bool enable)
+{
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        struct mlx4_device_context *dev_ctx = NULL, *temp_dev_ctx;
+        unsigned long flags;
+        int ret;
+        LIST_HEAD(bond_list);
+
+        if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_PORT_REMAP))
+                return -ENOTSUPP;
+
+        ret = mlx4_disable_rx_port_check(dev, enable);
+        if (ret) {
+                mlx4_err(dev, "Fail to %s rx port check\n",
+                         enable ? "enable" : "disable");
+                return ret;
+        }
+        if (enable) {
+                dev->flags |= MLX4_FLAG_BONDED;
+        } else {
+                 ret = mlx4_virt2phy_port_map(dev, 1, 2);
+                if (ret) {
+                        mlx4_err(dev, "Fail to reset port map\n");
+                        return ret;
+                }
+                dev->flags &= ~MLX4_FLAG_BONDED;
+        }
+
+        spin_lock_irqsave(&priv->ctx_lock, flags);
+        list_for_each_entry_safe(dev_ctx, temp_dev_ctx, &priv->ctx_list, list) {
+                if (dev_ctx->intf->flags & MLX4_INTFF_BONDING) {
+                        list_add_tail(&dev_ctx->bond_list, &bond_list);
+                        list_del(&dev_ctx->list);
+                }
+        }
+        spin_unlock_irqrestore(&priv->ctx_lock, flags);
+
+        list_for_each_entry(dev_ctx, &bond_list, bond_list) {
+                dev_ctx->intf->remove(dev, dev_ctx->context);
+                dev_ctx->context =  dev_ctx->intf->add(dev);
+
+                spin_lock_irqsave(&priv->ctx_lock, flags);
+                list_add_tail(&dev_ctx->list, &priv->ctx_list);
+                spin_unlock_irqrestore(&priv->ctx_lock, flags);
+
+                mlx4_dbg(dev, "Inrerface for protocol %d restarted with when bonded mode is %s\n",
+                         dev_ctx->intf->protocol, enable ?
+                         "enabled" : "disabled");
+        }
+        return 0;
+}
+
 void mlx4_dispatch_event(struct mlx4_dev *dev, enum mlx4_dev_event type,
                          unsigned long param)
 {
@@ -138,13 +192,13 @@ int mlx4_register_device(struct mlx4_dev *dev)
 
         mutex_lock(&intf_mutex);
 
+        dev->persist->interface_state |= MLX4_INTERFACE_STATE_UP;
         list_add_tail(&priv->dev_list, &dev_list);
         list_for_each_entry(intf, &intf_list, list)
                 mlx4_add_device(intf, priv);
 
         mutex_unlock(&intf_mutex);
-        if (!mlx4_is_slave(dev))
-                mlx4_start_catas_poll(dev);
+        mlx4_start_catas_poll(dev);
 
         return 0;
 }
@@ -154,14 +208,14 @@ void mlx4_unregister_device(struct mlx4_dev *dev)
         struct mlx4_priv *priv = mlx4_priv(dev);
         struct mlx4_interface *intf;
 
-        if (!mlx4_is_slave(dev))
-                mlx4_stop_catas_poll(dev);
+        mlx4_stop_catas_poll(dev);
         mutex_lock(&intf_mutex);
 
         list_for_each_entry(intf, &intf_list, list)
                 mlx4_remove_device(intf, priv);
 
         list_del(&priv->dev_list);
+        dev->persist->interface_state &= ~MLX4_INTERFACE_STATE_UP;
 
         mutex_unlock(&intf_mutex);
 }
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index 6e08352ec994..7e487223489a 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -108,6 +108,8 @@ MODULE_PARM_DESC(enable_64b_cqe_eqe,
                                          MLX4_FUNC_CAP_EQE_CQE_STRIDE | \
                                          MLX4_FUNC_CAP_DMFS_A0_STATIC)
 
+#define RESET_PERSIST_MASK_FLAGS        (MLX4_FLAG_SRIOV)
+
 static char mlx4_version[] =
         DRV_NAME ": Mellanox ConnectX core driver v"
         DRV_VERSION " (" DRV_RELDATE ")\n";
@@ -249,7 +251,8 @@ static void mlx4_enable_cqe_eqe_stride(struct mlx4_dev *dev)
                 if (mlx4_is_master(dev))
                         dev_cap->function_caps |= MLX4_FUNC_CAP_EQE_CQE_STRIDE;
         } else {
-                mlx4_dbg(dev, "Disabling CQE stride cacheLine unsupported\n");
+                if (cache_line_size() != 32  && cache_line_size() != 64)
+                        mlx4_dbg(dev, "Disabling CQE stride, cacheLine size unsupported\n");
                 dev_cap->flags2 &= ~MLX4_DEV_CAP_FLAG2_CQE_STRIDE;
                 dev_cap->flags2 &= ~MLX4_DEV_CAP_FLAG2_EQE_STRIDE;
         }
@@ -318,10 +321,11 @@ static int mlx4_dev_cap(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
                 return -ENODEV;
         }
 
-        if (dev_cap->uar_size > pci_resource_len(dev->pdev, 2)) {
+        if (dev_cap->uar_size > pci_resource_len(dev->persist->pdev, 2)) {
                 mlx4_err(dev, "HCA reported UAR size of 0x%x bigger than PCI resource 2 size of 0x%llx, aborting\n",
                          dev_cap->uar_size,
-                         (unsigned long long) pci_resource_len(dev->pdev, 2));
+                         (unsigned long long)
+                         pci_resource_len(dev->persist->pdev, 2));
                 return -ENODEV;
         }
 
@@ -541,8 +545,10 @@ static int mlx4_get_pcie_dev_link_caps(struct mlx4_dev *dev,
         *speed = PCI_SPEED_UNKNOWN;
         *width = PCIE_LNK_WIDTH_UNKNOWN;
 
-        err1 = pcie_capability_read_dword(dev->pdev, PCI_EXP_LNKCAP, &lnkcap1);
-        err2 = pcie_capability_read_dword(dev->pdev, PCI_EXP_LNKCAP2, &lnkcap2);
+        err1 = pcie_capability_read_dword(dev->persist->pdev, PCI_EXP_LNKCAP,
+                                          &lnkcap1);
+        err2 = pcie_capability_read_dword(dev->persist->pdev, PCI_EXP_LNKCAP2,
+                                          &lnkcap2);
         if (!err2 && lnkcap2) { /* PCIe r3.0-compliant */
                 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB)
                         *speed = PCIE_SPEED_8_0GT;
@@ -587,7 +593,7 @@ static void mlx4_check_pcie_caps(struct mlx4_dev *dev)
                 return;
         }
 
-        err = pcie_get_minimum_link(dev->pdev, &speed, &width);
+        err = pcie_get_minimum_link(dev->persist->pdev, &speed, &width);
         if (err || speed == PCI_SPEED_UNKNOWN ||
             width == PCIE_LNK_WIDTH_UNKNOWN) {
                 mlx4_warn(dev,
@@ -792,6 +798,7 @@ static int mlx4_slave_cap(struct mlx4_dev *dev)
         dev->caps.num_mpts              = 1 << hca_param.log_mpt_sz;
         dev->caps.num_eqs               = func_cap.max_eq;
         dev->caps.reserved_eqs          = func_cap.reserved_eq;
+        dev->caps.reserved_lkey         = func_cap.reserved_lkey;
         dev->caps.num_pds               = MLX4_NUM_PDS;
         dev->caps.num_mgms              = 0;
         dev->caps.num_amgms             = 0;
@@ -837,10 +844,12 @@ static int mlx4_slave_cap(struct mlx4_dev *dev)
 
         if (dev->caps.uar_page_size * (dev->caps.num_uars -
                                        dev->caps.reserved_uars) >
-                                       pci_resource_len(dev->pdev, 2)) {
+                                       pci_resource_len(dev->persist->pdev,
+                                                        2)) {
                 mlx4_err(dev, "HCA reported UAR region size of 0x%x bigger than PCI resource 2 size of 0x%llx, aborting\n",
                          dev->caps.uar_page_size * dev->caps.num_uars,
-                         (unsigned long long) pci_resource_len(dev->pdev, 2));
+                         (unsigned long long)
+                         pci_resource_len(dev->persist->pdev, 2));
                 goto err_mem;
         }
 
@@ -1152,6 +1161,91 @@ err_set_port:
         return err ? err : count;
 }
 
+int mlx4_bond(struct mlx4_dev *dev)
+{
+        int ret = 0;
+        struct mlx4_priv *priv = mlx4_priv(dev);
+
+        mutex_lock(&priv->bond_mutex);
+
+        if (!mlx4_is_bonded(dev))
+                ret = mlx4_do_bond(dev, true);
+        else
+                ret = 0;
+
+        mutex_unlock(&priv->bond_mutex);
+        if (ret)
+                mlx4_err(dev, "Failed to bond device: %d\n", ret);
+        else
+                mlx4_dbg(dev, "Device is bonded\n");
+        return ret;
+}
+EXPORT_SYMBOL_GPL(mlx4_bond);
+
+int mlx4_unbond(struct mlx4_dev *dev)
+{
+        int ret = 0;
+        struct mlx4_priv *priv = mlx4_priv(dev);
+
+        mutex_lock(&priv->bond_mutex);
+
+        if (mlx4_is_bonded(dev))
+                ret = mlx4_do_bond(dev, false);
+
+        mutex_unlock(&priv->bond_mutex);
+        if (ret)
+                mlx4_err(dev, "Failed to unbond device: %d\n", ret);
+        else
+                mlx4_dbg(dev, "Device is unbonded\n");
+        return ret;
+}
+EXPORT_SYMBOL_GPL(mlx4_unbond);
+
+
+int mlx4_port_map_set(struct mlx4_dev *dev, struct mlx4_port_map *v2p)
+{
+        u8 port1 = v2p->port1;
+        u8 port2 = v2p->port2;
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        int err;
+
+        if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_PORT_REMAP))
+                return -ENOTSUPP;
+
+        mutex_lock(&priv->bond_mutex);
+
+        /* zero means keep current mapping for this port */
+        if (port1 == 0)
+                port1 = priv->v2p.port1;
+        if (port2 == 0)
+                port2 = priv->v2p.port2;
+
+        if ((port1 < 1) || (port1 > MLX4_MAX_PORTS) ||
+            (port2 < 1) || (port2 > MLX4_MAX_PORTS) ||
+            (port1 == 2 && port2 == 1)) {
+                /* besides boundary checks cross mapping makes
+                 * no sense and therefore not allowed */
+                err = -EINVAL;
+        } else if ((port1 == priv->v2p.port1) &&
+                 (port2 == priv->v2p.port2)) {
+                err = 0;
+        } else {
+                err = mlx4_virt2phy_port_map(dev, port1, port2);
+                if (!err) {
+                        mlx4_dbg(dev, "port map changed: [%d][%d]\n",
+                                 port1, port2);
+                        priv->v2p.port1 = port1;
+                        priv->v2p.port2 = port2;
+                } else {
+                        mlx4_err(dev, "Failed to change port mape: %d\n", err);
+                }
+        }
+
+        mutex_unlock(&priv->bond_mutex);
+        return err;
+}
+EXPORT_SYMBOL_GPL(mlx4_port_map_set);
+
 static int mlx4_load_fw(struct mlx4_dev *dev)
 {
         struct mlx4_priv *priv = mlx4_priv(dev);
@@ -1477,7 +1571,8 @@ static void mlx4_slave_exit(struct mlx4_dev *dev)
         struct mlx4_priv *priv = mlx4_priv(dev);
 
         mutex_lock(&priv->cmd.slave_cmd_mutex);
-        if (mlx4_comm_cmd(dev, MLX4_COMM_CMD_RESET, 0, MLX4_COMM_TIME))
+        if (mlx4_comm_cmd(dev, MLX4_COMM_CMD_RESET, 0, MLX4_COMM_CMD_NA_OP,
+                          MLX4_COMM_TIME))
                 mlx4_warn(dev, "Failed to close slave function\n");
         mutex_unlock(&priv->cmd.slave_cmd_mutex);
 }
@@ -1492,9 +1587,9 @@ static int map_bf_area(struct mlx4_dev *dev)
         if (!dev->caps.bf_reg_size)
                 return -ENXIO;
 
-        bf_start = pci_resource_start(dev->pdev, 2) +
+        bf_start = pci_resource_start(dev->persist->pdev, 2) +
                         (dev->caps.num_uars << PAGE_SHIFT);
-        bf_len = pci_resource_len(dev->pdev, 2) -
+        bf_len = pci_resource_len(dev->persist->pdev, 2) -
                         (dev->caps.num_uars << PAGE_SHIFT);
         priv->bf_mapping = io_mapping_create_wc(bf_start, bf_len);
         if (!priv->bf_mapping)
@@ -1536,7 +1631,8 @@ static int map_internal_clock(struct mlx4_dev *dev)
         struct mlx4_priv *priv = mlx4_priv(dev);
 
         priv->clock_mapping =
-                ioremap(pci_resource_start(dev->pdev, priv->fw.clock_bar) +
+                ioremap(pci_resource_start(dev->persist->pdev,
+                                           priv->fw.clock_bar) +
                         priv->fw.clock_offset, MLX4_CLOCK_SIZE);
 
         if (!priv->clock_mapping)
@@ -1573,6 +1669,50 @@ static void mlx4_close_fw(struct mlx4_dev *dev)
         }
 }
 
+static int mlx4_comm_check_offline(struct mlx4_dev *dev)
+{
+#define COMM_CHAN_OFFLINE_OFFSET 0x09
+
+        u32 comm_flags;
+        u32 offline_bit;
+        unsigned long end;
+        struct mlx4_priv *priv = mlx4_priv(dev);
+
+        end = msecs_to_jiffies(MLX4_COMM_OFFLINE_TIME_OUT) + jiffies;
+        while (time_before(jiffies, end)) {
+                comm_flags = swab32(readl((__iomem char *)priv->mfunc.comm +
+                                          MLX4_COMM_CHAN_FLAGS));
+                offline_bit = (comm_flags &
+                               (u32)(1 << COMM_CHAN_OFFLINE_OFFSET));
+                if (!offline_bit)
+                        return 0;
+                /* There are cases as part of AER/Reset flow that PF needs
+                 * around 100 msec to load. We therefore sleep for 100 msec
+                 * to allow other tasks to make use of that CPU during this
+                 * time interval.
+                 */
+                msleep(100);
+        }
+        mlx4_err(dev, "Communication channel is offline.\n");
+        return -EIO;
+}
+
+static void mlx4_reset_vf_support(struct mlx4_dev *dev)
+{
+#define COMM_CHAN_RST_OFFSET 0x1e
+
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        u32 comm_rst;
+        u32 comm_caps;
+
+        comm_caps = swab32(readl((__iomem char *)priv->mfunc.comm +
+                                 MLX4_COMM_CHAN_CAPS));
+        comm_rst = (comm_caps & (u32)(1 << COMM_CHAN_RST_OFFSET));
+
+        if (comm_rst)
+                dev->caps.vf_caps |= MLX4_VF_CAP_FLAG_RESET;
+}
+
 static int mlx4_init_slave(struct mlx4_dev *dev)
 {
         struct mlx4_priv *priv = mlx4_priv(dev);
@@ -1588,9 +1728,15 @@ static int mlx4_init_slave(struct mlx4_dev *dev)
 
         mutex_lock(&priv->cmd.slave_cmd_mutex);
         priv->cmd.max_cmds = 1;
+        if (mlx4_comm_check_offline(dev)) {
+                mlx4_err(dev, "PF is not responsive, skipping initialization\n");
+                goto err_offline;
+        }
+
+        mlx4_reset_vf_support(dev);
         mlx4_warn(dev, "Sending reset\n");
         ret_from_reset = mlx4_comm_cmd(dev, MLX4_COMM_CMD_RESET, 0,
-                                       MLX4_COMM_TIME);
+                                       MLX4_COMM_CMD_NA_OP, MLX4_COMM_TIME);
         /* if we are in the middle of flr the slave will try
          * NUM_OF_RESET_RETRIES times before leaving.*/
         if (ret_from_reset) {
@@ -1615,22 +1761,24 @@ static int mlx4_init_slave(struct mlx4_dev *dev)
 
         mlx4_warn(dev, "Sending vhcr0\n");
         if (mlx4_comm_cmd(dev, MLX4_COMM_CMD_VHCR0, dma >> 48,
-                                                    MLX4_COMM_TIME))
+                             MLX4_COMM_CMD_NA_OP, MLX4_COMM_TIME))
                 goto err;
         if (mlx4_comm_cmd(dev, MLX4_COMM_CMD_VHCR1, dma >> 32,
-                                                    MLX4_COMM_TIME))
+                             MLX4_COMM_CMD_NA_OP, MLX4_COMM_TIME))
                 goto err;
         if (mlx4_comm_cmd(dev, MLX4_COMM_CMD_VHCR2, dma >> 16,
-                                                    MLX4_COMM_TIME))
+                             MLX4_COMM_CMD_NA_OP, MLX4_COMM_TIME))
                 goto err;
-        if (mlx4_comm_cmd(dev, MLX4_COMM_CMD_VHCR_EN, dma, MLX4_COMM_TIME))
+        if (mlx4_comm_cmd(dev, MLX4_COMM_CMD_VHCR_EN, dma,
+                          MLX4_COMM_CMD_NA_OP, MLX4_COMM_TIME))
                 goto err;
 
         mutex_unlock(&priv->cmd.slave_cmd_mutex);
         return 0;
 
 err:
-        mlx4_comm_cmd(dev, MLX4_COMM_CMD_RESET, 0, 0);
+        mlx4_comm_cmd(dev, MLX4_COMM_CMD_RESET, 0, MLX4_COMM_CMD_NA_OP, 0);
+err_offline:
         mutex_unlock(&priv->cmd.slave_cmd_mutex);
         return -EIO;
 }
@@ -1705,7 +1853,8 @@ static void choose_steering_mode(struct mlx4_dev *dev,
         if (mlx4_log_num_mgm_entry_size <= 0 &&
             dev_cap->flags2 & MLX4_DEV_CAP_FLAG2_FS_EN &&
             (!mlx4_is_mfunc(dev) ||
-             (dev_cap->fs_max_num_qp_per_entry >= (dev->num_vfs + 1))) &&
+             (dev_cap->fs_max_num_qp_per_entry >=
+             (dev->persist->num_vfs + 1))) &&
             choose_log_fs_mgm_entry_size(dev_cap->fs_max_num_qp_per_entry) >=
                 MLX4_MIN_MGM_LOG_ENTRY_SIZE) {
                 dev->oper_log_mgm_entry_size =
@@ -2287,7 +2436,8 @@ static void mlx4_enable_msi_x(struct mlx4_dev *dev)
                 for (i = 0; i < nreq; ++i)
                         entries[i].entry = i;
 
-                nreq = pci_enable_msix_range(dev->pdev, entries, 2, nreq);
+                nreq = pci_enable_msix_range(dev->persist->pdev, entries, 2,
+                                             nreq);
 
                 if (nreq < 0) {
                         kfree(entries);
@@ -2315,7 +2465,7 @@ no_msi:
         dev->caps.comp_pool        = 0;
 
         for (i = 0; i < 2; ++i)
-                priv->eq_table.eq[i].irq = dev->pdev->irq;
+                priv->eq_table.eq[i].irq = dev->persist->pdev->irq;
 }
 
 static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
@@ -2343,7 +2493,7 @@ static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
         info->port_attr.show      = show_port_type;
         sysfs_attr_init(&info->port_attr.attr);
 
-        err = device_create_file(&dev->pdev->dev, &info->port_attr);
+        err = device_create_file(&dev->persist->pdev->dev, &info->port_attr);
         if (err) {
                 mlx4_err(dev, "Failed to create file for port %d\n", port);
                 info->port = -1;
@@ -2360,10 +2510,12 @@ static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
         info->port_mtu_attr.show      = show_port_ib_mtu;
         sysfs_attr_init(&info->port_mtu_attr.attr);
 
-        err = device_create_file(&dev->pdev->dev, &info->port_mtu_attr);
+        err = device_create_file(&dev->persist->pdev->dev,
+                                 &info->port_mtu_attr);
         if (err) {
                 mlx4_err(dev, "Failed to create mtu file for port %d\n", port);
-                device_remove_file(&info->dev->pdev->dev, &info->port_attr);
+                device_remove_file(&info->dev->persist->pdev->dev,
+                                   &info->port_attr);
                 info->port = -1;
         }
 
@@ -2375,8 +2527,9 @@ static void mlx4_cleanup_port_info(struct mlx4_port_info *info)
         if (info->port < 0)
                 return;
 
-        device_remove_file(&info->dev->pdev->dev, &info->port_attr);
-        device_remove_file(&info->dev->pdev->dev, &info->port_mtu_attr);
+        device_remove_file(&info->dev->persist->pdev->dev, &info->port_attr);
+        device_remove_file(&info->dev->persist->pdev->dev,
+                           &info->port_mtu_attr);
 }
 
 static int mlx4_init_steering(struct mlx4_dev *dev)
@@ -2443,10 +2596,11 @@ static int mlx4_get_ownership(struct mlx4_dev *dev)
         void __iomem *owner;
         u32 ret;
 
-        if (pci_channel_offline(dev->pdev))
+        if (pci_channel_offline(dev->persist->pdev))
                 return -EIO;
 
-        owner = ioremap(pci_resource_start(dev->pdev, 0) + MLX4_OWNER_BASE,
+        owner = ioremap(pci_resource_start(dev->persist->pdev, 0) +
+                        MLX4_OWNER_BASE,
                         MLX4_OWNER_SIZE);
         if (!owner) {
                 mlx4_err(dev, "Failed to obtain ownership bit\n");
@@ -2462,10 +2616,11 @@ static void mlx4_free_ownership(struct mlx4_dev *dev)
 {
         void __iomem *owner;
 
-        if (pci_channel_offline(dev->pdev))
+        if (pci_channel_offline(dev->persist->pdev))
                 return;
 
-        owner = ioremap(pci_resource_start(dev->pdev, 0) + MLX4_OWNER_BASE,
+        owner = ioremap(pci_resource_start(dev->persist->pdev, 0) +
+                        MLX4_OWNER_BASE,
                         MLX4_OWNER_SIZE);
         if (!owner) {
                 mlx4_err(dev, "Failed to obtain ownership bit\n");
@@ -2480,11 +2635,19 @@ static void mlx4_free_ownership(struct mlx4_dev *dev)
                                   !!((flags) & MLX4_FLAG_MASTER))
 
 static u64 mlx4_enable_sriov(struct mlx4_dev *dev, struct pci_dev *pdev,
-                             u8 total_vfs, int existing_vfs)
+                             u8 total_vfs, int existing_vfs, int reset_flow)
 {
         u64 dev_flags = dev->flags;
         int err = 0;
 
+        if (reset_flow) {
+                dev->dev_vfs = kcalloc(total_vfs, sizeof(*dev->dev_vfs),
+                                       GFP_KERNEL);
+                if (!dev->dev_vfs)
+                        goto free_mem;
+                return dev_flags;
+        }
+
         atomic_inc(&pf_loading);
         if (dev->flags &  MLX4_FLAG_SRIOV) {
                 if (existing_vfs != total_vfs) {
@@ -2513,13 +2676,14 @@ static u64 mlx4_enable_sriov(struct mlx4_dev *dev, struct pci_dev *pdev,
                 dev_flags |= MLX4_FLAG_SRIOV |
                         MLX4_FLAG_MASTER;
                 dev_flags &= ~MLX4_FLAG_SLAVE;
-                dev->num_vfs = total_vfs;
+                dev->persist->num_vfs = total_vfs;
         }
         return dev_flags;
 
 disable_sriov:
         atomic_dec(&pf_loading);
-        dev->num_vfs = 0;
+free_mem:
+        dev->persist->num_vfs = 0;
         kfree(dev->dev_vfs);
         return dev_flags & ~MLX4_FLAG_MASTER;
 }
@@ -2543,7 +2707,8 @@ static int mlx4_check_dev_cap(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap
 }
 
 static int mlx4_load_one(struct pci_dev *pdev, int pci_dev_data,
-                         int total_vfs, int *nvfs, struct mlx4_priv *priv)
+                         int total_vfs, int *nvfs, struct mlx4_priv *priv,
+                         int reset_flow)
 {
         struct mlx4_dev *dev;
         unsigned sum = 0;
@@ -2559,6 +2724,7 @@ static int mlx4_load_one(struct pci_dev *pdev, int pci_dev_data,
         spin_lock_init(&priv->ctx_lock);
 
         mutex_init(&priv->port_mutex);
+        mutex_init(&priv->bond_mutex);
 
         INIT_LIST_HEAD(&priv->pgdir_list);
         mutex_init(&priv->pgdir_mutex);
@@ -2606,10 +2772,15 @@ static int mlx4_load_one(struct pci_dev *pdev, int pci_dev_data,
                         existing_vfs = pci_num_vf(pdev);
                         if (existing_vfs)
                                 dev->flags |= MLX4_FLAG_SRIOV;
-                        dev->num_vfs = total_vfs;
+                        dev->persist->num_vfs = total_vfs;
                 }
         }
 
+        /* on load remove any previous indication of internal error,
+         * device is up.
+         */
+        dev->persist->state = MLX4_DEVICE_STATE_UP;
+
 slave_start:
         err = mlx4_cmd_init(dev);
         if (err) {
@@ -2660,8 +2831,10 @@ slave_start:
                                 goto err_fw;
 
                         if (!(dev_cap->flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS)) {
-                                u64 dev_flags = mlx4_enable_sriov(dev, pdev, total_vfs,
-                                                                  existing_vfs);
+                                u64 dev_flags = mlx4_enable_sriov(dev, pdev,
+                                                                  total_vfs,
+                                                                  existing_vfs,
+                                                                  reset_flow);
 
                                 mlx4_cmd_cleanup(dev, MLX4_CMD_CLEANUP_ALL);
                                 dev->flags = dev_flags;
@@ -2703,7 +2876,7 @@ slave_start:
                         if (dev->flags & MLX4_FLAG_SRIOV) {
                                 if (!existing_vfs)
                                         pci_disable_sriov(pdev);
-                                if (mlx4_is_master(dev))
+                                if (mlx4_is_master(dev) && !reset_flow)
                                         atomic_dec(&pf_loading);
                                 dev->flags &= ~MLX4_FLAG_SRIOV;
                         }
@@ -2717,7 +2890,8 @@ slave_start:
         }
 
         if (mlx4_is_master(dev) && (dev_cap->flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS)) {
-                u64 dev_flags = mlx4_enable_sriov(dev, pdev, total_vfs, existing_vfs);
+                u64 dev_flags = mlx4_enable_sriov(dev, pdev, total_vfs,
+                                                  existing_vfs, reset_flow);
 
                 if ((dev->flags ^ dev_flags) & (MLX4_FLAG_MASTER | MLX4_FLAG_SLAVE)) {
                         mlx4_cmd_cleanup(dev, MLX4_CMD_CLEANUP_VHCR);
@@ -2770,12 +2944,14 @@ slave_start:
                                  dev->caps.num_ports);
                         goto err_close;
                 }
-                memcpy(dev->nvfs, nvfs, sizeof(dev->nvfs));
+                memcpy(dev->persist->nvfs, nvfs, sizeof(dev->persist->nvfs));
 
-                for (i = 0; i < sizeof(dev->nvfs)/sizeof(dev->nvfs[0]); i++) {
+                for (i = 0;
+                     i < sizeof(dev->persist->nvfs)/
+                     sizeof(dev->persist->nvfs[0]); i++) {
                         unsigned j;
 
-                        for (j = 0; j < dev->nvfs[i]; ++sum, ++j) {
+                        for (j = 0; j < dev->persist->nvfs[i]; ++sum, ++j) {
                                 dev->dev_vfs[sum].min_port = i < 2 ? i + 1 : 1;
                                 dev->dev_vfs[sum].n_ports = i < 2 ? 1 :
                                         dev->caps.num_ports;
@@ -2827,6 +3003,17 @@ slave_start:
                 goto err_steer;
 
         mlx4_init_quotas(dev);
+        /* When PF resources are ready arm its comm channel to enable
+         * getting commands
+         */
+        if (mlx4_is_master(dev)) {
+                err = mlx4_ARM_COMM_CHANNEL(dev);
+                if (err) {
+                        mlx4_err(dev, " Failed to arm comm channel eq: %x\n",
+                                 err);
+                        goto err_steer;
+                }
+        }
 
         for (port = 1; port <= dev->caps.num_ports; port++) {
                 err = mlx4_init_port_info(dev, port);
@@ -2834,6 +3021,9 @@ slave_start:
                         goto err_port;
         }
 
+        priv->v2p.port1 = 1;
+        priv->v2p.port2 = 2;
+
         err = mlx4_register_device(dev);
         if (err)
                 goto err_port;
@@ -2845,7 +3035,7 @@ slave_start:
 
         priv->removed = 0;
 
-        if (mlx4_is_master(dev) && dev->num_vfs)
+        if (mlx4_is_master(dev) && dev->persist->num_vfs && !reset_flow)
                 atomic_dec(&pf_loading);
 
         kfree(dev_cap);
@@ -2879,8 +3069,10 @@ err_free_eq:
         mlx4_free_eq_table(dev);
 
 err_master_mfunc:
-        if (mlx4_is_master(dev))
+        if (mlx4_is_master(dev)) {
+                mlx4_free_resource_tracker(dev, RES_TR_FREE_STRUCTS_ONLY);
                 mlx4_multi_func_cleanup(dev);
+        }
 
         if (mlx4_is_slave(dev)) {
                 kfree(dev->caps.qp0_qkey);
@@ -2904,10 +3096,12 @@ err_cmd:
         mlx4_cmd_cleanup(dev, MLX4_CMD_CLEANUP_ALL);
 
 err_sriov:
-        if (dev->flags & MLX4_FLAG_SRIOV && !existing_vfs)
+        if (dev->flags & MLX4_FLAG_SRIOV && !existing_vfs) {
                 pci_disable_sriov(pdev);
+                dev->flags &= ~MLX4_FLAG_SRIOV;
+        }
 
-        if (mlx4_is_master(dev) && dev->num_vfs)
+        if (mlx4_is_master(dev) && dev->persist->num_vfs && !reset_flow)
                 atomic_dec(&pf_loading);
 
         kfree(priv->dev.dev_vfs);
@@ -3048,11 +3242,19 @@ static int __mlx4_init_one(struct pci_dev *pdev, int pci_dev_data,
                 }
         }
 
-        err = mlx4_load_one(pdev, pci_dev_data, total_vfs, nvfs, priv);
+        err = mlx4_catas_init(&priv->dev);
         if (err)
                 goto err_release_regions;
+
+        err = mlx4_load_one(pdev, pci_dev_data, total_vfs, nvfs, priv, 0);
+        if (err)
+                goto err_catas;
+
         return 0;
 
+err_catas:
+        mlx4_catas_end(&priv->dev);
+
 err_release_regions:
         pci_release_regions(pdev);
 
@@ -3075,38 +3277,60 @@ static int mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 return -ENOMEM;
 
         dev       = &priv->dev;
-        dev->pdev = pdev;
-        pci_set_drvdata(pdev, dev);
+        dev->persist = kzalloc(sizeof(*dev->persist), GFP_KERNEL);
+        if (!dev->persist) {
+                kfree(priv);
+                return -ENOMEM;
+        }
+        dev->persist->pdev = pdev;
+        dev->persist->dev = dev;
+        pci_set_drvdata(pdev, dev->persist);
         priv->pci_dev_data = id->driver_data;
+        mutex_init(&dev->persist->device_state_mutex);
+        mutex_init(&dev->persist->interface_state_mutex);
 
         ret =  __mlx4_init_one(pdev, id->driver_data, priv);
-        if (ret)
+        if (ret) {
+                kfree(dev->persist);
                 kfree(priv);
+        } else {
+                pci_save_state(pdev);
+        }
 
         return ret;
 }
 
+static void mlx4_clean_dev(struct mlx4_dev *dev)
+{
+        struct mlx4_dev_persistent *persist = dev->persist;
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        unsigned long   flags = (dev->flags & RESET_PERSIST_MASK_FLAGS);
+
+        memset(priv, 0, sizeof(*priv));
+        priv->dev.persist = persist;
+        priv->dev.flags = flags;
+}
+
 static void mlx4_unload_one(struct pci_dev *pdev)
 {
-        struct mlx4_dev  *dev  = pci_get_drvdata(pdev);
+        struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
+        struct mlx4_dev  *dev  = persist->dev;
         struct mlx4_priv *priv = mlx4_priv(dev);
         int               pci_dev_data;
-        int p;
-        int active_vfs = 0;
+        int p, i;
 
         if (priv->removed)
                 return;
 
+        /* saving current ports type for further use */
+        for (i = 0; i < dev->caps.num_ports; i++) {
+                dev->persist->curr_port_type[i] = dev->caps.port_type[i + 1];
+                dev->persist->curr_port_poss_type[i] = dev->caps.
+                                                       possible_type[i + 1];
+        }
+
         pci_dev_data = priv->pci_dev_data;
 
-        /* Disabling SR-IOV is not allowed while there are active vf's */
-        if (mlx4_is_master(dev)) {
-                active_vfs = mlx4_how_many_lives_vf(dev);
-                if (active_vfs) {
-                        pr_warn("Removing PF when there are active VF's !!\n");
-                        pr_warn("Will not disable SR-IOV.\n");
-                }
-        }
         mlx4_stop_sense(dev);
         mlx4_unregister_device(dev);
 
@@ -3150,12 +3374,6 @@ static void mlx4_unload_one(struct pci_dev *pdev)
 
         if (dev->flags & MLX4_FLAG_MSI_X)
                 pci_disable_msix(pdev);
-        if (dev->flags & MLX4_FLAG_SRIOV && !active_vfs) {
-                mlx4_warn(dev, "Disabling SR-IOV\n");
-                pci_disable_sriov(pdev);
-                dev->flags &= ~MLX4_FLAG_SRIOV;
-                dev->num_vfs = 0;
-        }
 
         if (!mlx4_is_slave(dev))
                 mlx4_free_ownership(dev);
@@ -3167,42 +3385,96 @@ static void mlx4_unload_one(struct pci_dev *pdev)
         kfree(dev->caps.qp1_proxy);
         kfree(dev->dev_vfs);
 
-        memset(priv, 0, sizeof(*priv));
+        mlx4_clean_dev(dev);
         priv->pci_dev_data = pci_dev_data;
         priv->removed = 1;
 }
 
 static void mlx4_remove_one(struct pci_dev *pdev)
 {
-        struct mlx4_dev  *dev  = pci_get_drvdata(pdev);
+        struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
+        struct mlx4_dev  *dev  = persist->dev;
         struct mlx4_priv *priv = mlx4_priv(dev);
+        int active_vfs = 0;
+
+        mutex_lock(&persist->interface_state_mutex);
+        persist->interface_state |= MLX4_INTERFACE_STATE_DELETION;
+        mutex_unlock(&persist->interface_state_mutex);
+
+        /* Disabling SR-IOV is not allowed while there are active vf's */
+        if (mlx4_is_master(dev) && dev->flags & MLX4_FLAG_SRIOV) {
+                active_vfs = mlx4_how_many_lives_vf(dev);
+                if (active_vfs) {
+                        pr_warn("Removing PF when there are active VF's !!\n");
+                        pr_warn("Will not disable SR-IOV.\n");
+                }
+        }
+
+        /* device marked to be under deletion running now without the lock
+         * letting other tasks to be terminated
+         */
+        if (persist->interface_state & MLX4_INTERFACE_STATE_UP)
+                mlx4_unload_one(pdev);
+        else
+                mlx4_info(dev, "%s: interface is down\n", __func__);
+        mlx4_catas_end(dev);
+        if (dev->flags & MLX4_FLAG_SRIOV && !active_vfs) {
+                mlx4_warn(dev, "Disabling SR-IOV\n");
+                pci_disable_sriov(pdev);
+        }
 
-        mlx4_unload_one(pdev);
         pci_release_regions(pdev);
         pci_disable_device(pdev);
+        kfree(dev->persist);
         kfree(priv);
         pci_set_drvdata(pdev, NULL);
 }
 
+static int restore_current_port_types(struct mlx4_dev *dev,
+                                      enum mlx4_port_type *types,
+                                      enum mlx4_port_type *poss_types)
+{
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        int err, i;
+
+        mlx4_stop_sense(dev);
+
+        mutex_lock(&priv->port_mutex);
+        for (i = 0; i < dev->caps.num_ports; i++)
+                dev->caps.possible_type[i + 1] = poss_types[i];
+        err = mlx4_change_port_types(dev, types);
+        mlx4_start_sense(dev);
+        mutex_unlock(&priv->port_mutex);
+
+        return err;
+}
+
 int mlx4_restart_one(struct pci_dev *pdev)
 {
-        struct mlx4_dev  *dev  = pci_get_drvdata(pdev);
+        struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
+        struct mlx4_dev  *dev  = persist->dev;
         struct mlx4_priv *priv = mlx4_priv(dev);
         int nvfs[MLX4_MAX_PORTS + 1] = {0, 0, 0};
         int pci_dev_data, err, total_vfs;
 
         pci_dev_data = priv->pci_dev_data;
-        total_vfs = dev->num_vfs;
-        memcpy(nvfs, dev->nvfs, sizeof(dev->nvfs));
+        total_vfs = dev->persist->num_vfs;
+        memcpy(nvfs, dev->persist->nvfs, sizeof(dev->persist->nvfs));
 
         mlx4_unload_one(pdev);
-        err = mlx4_load_one(pdev, pci_dev_data, total_vfs, nvfs, priv);
+        err = mlx4_load_one(pdev, pci_dev_data, total_vfs, nvfs, priv, 1);
         if (err) {
                 mlx4_err(dev, "%s: ERROR: mlx4_load_one failed, pci_name=%s, err=%d\n",
                          __func__, pci_name(pdev), err);
                 return err;
         }
 
+        err = restore_current_port_types(dev, dev->persist->curr_port_type,
+                                         dev->persist->curr_port_poss_type);
+        if (err)
+                mlx4_err(dev, "could not restore original port types (%d)\n",
+                         err);
+
         return err;
 }
 
@@ -3257,23 +3529,79 @@ MODULE_DEVICE_TABLE(pci, mlx4_pci_table);
 static pci_ers_result_t mlx4_pci_err_detected(struct pci_dev *pdev,
                                               pci_channel_state_t state)
 {
-        mlx4_unload_one(pdev);
+        struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
+
+        mlx4_err(persist->dev, "mlx4_pci_err_detected was called\n");
+        mlx4_enter_error_state(persist);
 
-        return state == pci_channel_io_perm_failure ?
-                PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_NEED_RESET;
+        mutex_lock(&persist->interface_state_mutex);
+        if (persist->interface_state & MLX4_INTERFACE_STATE_UP)
+                mlx4_unload_one(pdev);
+
+        mutex_unlock(&persist->interface_state_mutex);
+        if (state == pci_channel_io_perm_failure)
+                return PCI_ERS_RESULT_DISCONNECT;
+
+        pci_disable_device(pdev);
+        return PCI_ERS_RESULT_NEED_RESET;
 }
 
 static pci_ers_result_t mlx4_pci_slot_reset(struct pci_dev *pdev)
 {
-        struct mlx4_dev  *dev  = pci_get_drvdata(pdev);
+        struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
+        struct mlx4_dev  *dev  = persist->dev;
         struct mlx4_priv *priv = mlx4_priv(dev);
         int               ret;
+        int nvfs[MLX4_MAX_PORTS + 1] = {0, 0, 0};
+        int total_vfs;
 
-        ret = __mlx4_init_one(pdev, priv->pci_dev_data, priv);
+        mlx4_err(dev, "mlx4_pci_slot_reset was called\n");
+        ret = pci_enable_device(pdev);
+        if (ret) {
+                mlx4_err(dev, "Can not re-enable device, ret=%d\n", ret);
+                return PCI_ERS_RESULT_DISCONNECT;
+        }
+
+        pci_set_master(pdev);
+        pci_restore_state(pdev);
+        pci_save_state(pdev);
+
+        total_vfs = dev->persist->num_vfs;
+        memcpy(nvfs, dev->persist->nvfs, sizeof(dev->persist->nvfs));
+
+        mutex_lock(&persist->interface_state_mutex);
+        if (!(persist->interface_state & MLX4_INTERFACE_STATE_UP)) {
+                ret = mlx4_load_one(pdev, priv->pci_dev_data, total_vfs, nvfs,
+                                    priv, 1);
+                if (ret) {
+                        mlx4_err(dev, "%s: mlx4_load_one failed, ret=%d\n",
+                                 __func__,  ret);
+                        goto end;
+                }
+
+                ret = restore_current_port_types(dev, dev->persist->
+                                                 curr_port_type, dev->persist->
+                                                 curr_port_poss_type);
+                if (ret)
+                        mlx4_err(dev, "could not restore original port types (%d)\n", ret);
+        }
+end:
+        mutex_unlock(&persist->interface_state_mutex);
 
         return ret ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
 }
 
+static void mlx4_shutdown(struct pci_dev *pdev)
+{
+        struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
+
+        mlx4_info(persist->dev, "mlx4_shutdown was called\n");
+        mutex_lock(&persist->interface_state_mutex);
+        if (persist->interface_state & MLX4_INTERFACE_STATE_UP)
+                mlx4_unload_one(pdev);
+        mutex_unlock(&persist->interface_state_mutex);
+}
+
 static const struct pci_error_handlers mlx4_err_handler = {
         .error_detected = mlx4_pci_err_detected,
         .slot_reset     = mlx4_pci_slot_reset,
@@ -3283,7 +3611,7 @@ static struct pci_driver mlx4_driver = {
         .name           = DRV_NAME,
         .id_table       = mlx4_pci_table,
         .probe          = mlx4_init_one,
-        .shutdown       = mlx4_unload_one,
+        .shutdown       = mlx4_shutdown,
         .remove         = mlx4_remove_one,
         .err_handler    = &mlx4_err_handler,
 };
@@ -3335,7 +3663,6 @@ static int __init mlx4_init(void)
         if (mlx4_verify_params())
                 return -EINVAL;
 
-        mlx4_catas_init();
 
         mlx4_wq = create_singlethread_workqueue("mlx4");
         if (!mlx4_wq)
diff --git a/drivers/net/ethernet/mellanox/mlx4/mcg.c b/drivers/net/ethernet/mellanox/mlx4/mcg.c
index a3867e7ef885..bd9ea0d01aae 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mcg.c
+++ b/drivers/net/ethernet/mellanox/mlx4/mcg.c
@@ -1318,6 +1318,9 @@ out:
         mutex_unlock(&priv->mcg_table.mutex);
 
         mlx4_free_cmd_mailbox(dev, mailbox);
+        if (err && dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
+                /* In case device is under an error, return success as a closing command */
+                err = 0;
         return err;
 }
 
@@ -1347,6 +1350,9 @@ static int mlx4_QP_ATTACH(struct mlx4_dev *dev, struct mlx4_qp *qp,
                        MLX4_CMD_WRAPPED);
 
         mlx4_free_cmd_mailbox(dev, mailbox);
+        if (err && !attach &&
+            dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
+                err = 0;
         return err;
 }
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4.h b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
index 210691c89b6c..1409d0cd6143 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
@@ -85,7 +85,9 @@ enum {
         MLX4_CLR_INT_SIZE       = 0x00008,
         MLX4_SLAVE_COMM_BASE    = 0x0,
         MLX4_COMM_PAGESIZE      = 0x1000,
-        MLX4_CLOCK_SIZE         = 0x00008
+        MLX4_CLOCK_SIZE         = 0x00008,
+        MLX4_COMM_CHAN_CAPS     = 0x8,
+        MLX4_COMM_CHAN_FLAGS    = 0xc
 };
 
 enum {
@@ -120,6 +122,10 @@ enum mlx4_mpt_state {
 };
 
 #define MLX4_COMM_TIME          10000
+#define MLX4_COMM_OFFLINE_TIME_OUT 30000
+#define MLX4_COMM_CMD_NA_OP    0x0
+
+
 enum {
         MLX4_COMM_CMD_RESET,
         MLX4_COMM_CMD_VHCR0,
@@ -190,6 +196,7 @@ struct mlx4_vhcr {
 struct mlx4_vhcr_cmd {
         __be64 in_param;
         __be32 in_modifier;
+        u32 reserved1;
         __be64 out_param;
         __be16 token;
         u16 reserved;
@@ -221,19 +228,21 @@ extern int mlx4_debug_level;
 #define mlx4_dbg(mdev, format, ...)                                     \
 do {                                                                    \
         if (mlx4_debug_level)                                           \
-                dev_printk(KERN_DEBUG, &(mdev)->pdev->dev, format,      \
+                dev_printk(KERN_DEBUG,                                  \
+                           &(mdev)->persist->pdev->dev, format,         \
                            ##__VA_ARGS__);                              \
 } while (0)
 
 #define mlx4_err(mdev, format, ...)                                     \
-        dev_err(&(mdev)->pdev->dev, format, ##__VA_ARGS__)
+        dev_err(&(mdev)->persist->pdev->dev, format, ##__VA_ARGS__)
 #define mlx4_info(mdev, format, ...)                                    \
-        dev_info(&(mdev)->pdev->dev, format, ##__VA_ARGS__)
+        dev_info(&(mdev)->persist->pdev->dev, format, ##__VA_ARGS__)
 #define mlx4_warn(mdev, format, ...)                                    \
-        dev_warn(&(mdev)->pdev->dev, format, ##__VA_ARGS__)
+        dev_warn(&(mdev)->persist->pdev->dev, format, ##__VA_ARGS__)
 
 extern int mlx4_log_num_mgm_entry_size;
 extern int log_mtts_per_seg;
+extern int mlx4_internal_err_reset;
 
 #define MLX4_MAX_NUM_SLAVES     (min(MLX4_MAX_NUM_PF + MLX4_MAX_NUM_VF, \
                                      MLX4_MFUNC_MAX))
@@ -607,7 +616,6 @@ struct mlx4_mgm {
 struct mlx4_cmd {
         struct pci_pool        *pool;
         void __iomem           *hcr;
-        struct mutex            hcr_mutex;
         struct mutex            slave_cmd_mutex;
         struct semaphore        poll_sem;
         struct semaphore        event_sem;
@@ -878,6 +886,8 @@ struct mlx4_priv {
         int                     reserved_mtts;
         int                     fs_hash_mode;
         u8 virt2phys_pkey[MLX4_MFUNC_MAX][MLX4_MAX_PORTS][MLX4_MAX_PORT_PKEYS];
+        struct mlx4_port_map    v2p; /* cached port mapping configuration */
+        struct mutex            bond_mutex; /* for bond mode */
         __be64                  slave_node_guids[MLX4_MFUNC_MAX];
 
         atomic_t                opreq_count;
@@ -995,7 +1005,8 @@ void __mlx4_xrcd_free(struct mlx4_dev *dev, u32 xrcdn);
 
 void mlx4_start_catas_poll(struct mlx4_dev *dev);
 void mlx4_stop_catas_poll(struct mlx4_dev *dev);
-void mlx4_catas_init(void);
+int mlx4_catas_init(struct mlx4_dev *dev);
+void mlx4_catas_end(struct mlx4_dev *dev);
 int mlx4_restart_one(struct pci_dev *pdev);
 int mlx4_register_device(struct mlx4_dev *dev);
 void mlx4_unregister_device(struct mlx4_dev *dev);
@@ -1161,13 +1172,14 @@ enum {
 int mlx4_cmd_init(struct mlx4_dev *dev);
 void mlx4_cmd_cleanup(struct mlx4_dev *dev, int cleanup_mask);
 int mlx4_multi_func_init(struct mlx4_dev *dev);
+int mlx4_ARM_COMM_CHANNEL(struct mlx4_dev *dev);
 void mlx4_multi_func_cleanup(struct mlx4_dev *dev);
 void mlx4_cmd_event(struct mlx4_dev *dev, u16 token, u8 status, u64 out_param);
 int mlx4_cmd_use_events(struct mlx4_dev *dev);
 void mlx4_cmd_use_polling(struct mlx4_dev *dev);
 
 int mlx4_comm_cmd(struct mlx4_dev *dev, u8 cmd, u16 param,
-                  unsigned long timeout);
+                  u16 op, unsigned long timeout);
 
 void mlx4_cq_tasklet_cb(unsigned long data);
 void mlx4_cq_completion(struct mlx4_dev *dev, u32 cqn);
@@ -1177,7 +1189,7 @@ void mlx4_qp_event(struct mlx4_dev *dev, u32 qpn, int event_type);
 
 void mlx4_srq_event(struct mlx4_dev *dev, u32 srqn, int event_type);
 
-void mlx4_handle_catas_err(struct mlx4_dev *dev);
+void mlx4_enter_error_state(struct mlx4_dev_persistent *persist);
 
 int mlx4_SENSE_PORT(struct mlx4_dev *dev, int port,
                     enum mlx4_port_type *type);
@@ -1355,6 +1367,7 @@ int mlx4_get_slave_num_gids(struct mlx4_dev *dev, int slave, int port);
 /* Returns the VF index of slave */
 int mlx4_get_vf_indx(struct mlx4_dev *dev, int slave);
 int mlx4_config_mad_demux(struct mlx4_dev *dev);
+int mlx4_do_bond(struct mlx4_dev *dev, bool enable);
 
 enum mlx4_zone_flags {
         MLX4_ZONE_ALLOW_ALLOC_FROM_LOWER_PRIO   = 1UL << 0,
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
index 944a112dff37..2a8268e6be15 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
@@ -390,6 +390,7 @@ struct mlx4_en_dev {
         struct pci_dev          *pdev;
         struct mutex            state_lock;
         struct net_device       *pndev[MLX4_MAX_PORTS + 1];
+        struct net_device       *upper[MLX4_MAX_PORTS + 1];
         u32                     port_cnt;
         bool                    device_up;
         struct mlx4_en_profile  profile;
@@ -410,6 +411,7 @@ struct mlx4_en_dev {
         unsigned long           overflow_period;
         struct ptp_clock        *ptp_clock;
         struct ptp_clock_info   ptp_clock_info;
+        struct notifier_block   nb;
 };
 
 
@@ -845,6 +847,9 @@ int mlx4_en_reset_config(struct net_device *dev,
                          struct hwtstamp_config ts_config,
                          netdev_features_t new_features);
 
+int mlx4_en_netdev_event(struct notifier_block *this,
+                         unsigned long event, void *ptr);
+
 /*
  * Functions for time stamping
  */
diff --git a/drivers/net/ethernet/mellanox/mlx4/mr.c b/drivers/net/ethernet/mellanox/mlx4/mr.c
index 7094a9c70fd5..78f51e103880 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mr.c
+++ b/drivers/net/ethernet/mellanox/mlx4/mr.c
@@ -598,14 +598,11 @@ int mlx4_mr_rereg_mem_write(struct mlx4_dev *dev, struct mlx4_mr *mr,
         if (err)
                 return err;
 
-        mpt_entry->start       = cpu_to_be64(mr->iova);
-        mpt_entry->length      = cpu_to_be64(mr->size);
-        mpt_entry->entity_size = cpu_to_be32(mr->mtt.page_shift);
-
-        mpt_entry->pd_flags &= cpu_to_be32(MLX4_MPT_PD_MASK |
-                                           MLX4_MPT_PD_FLAG_EN_INV);
-        mpt_entry->flags    &= cpu_to_be32(MLX4_MPT_FLAG_FREE |
-                                           MLX4_MPT_FLAG_SW_OWNS);
+        mpt_entry->start       = cpu_to_be64(iova);
+        mpt_entry->length      = cpu_to_be64(size);
+        mpt_entry->entity_size = cpu_to_be32(page_shift);
+        mpt_entry->flags    &= ~(cpu_to_be32(MLX4_MPT_FLAG_FREE |
+                                           MLX4_MPT_FLAG_SW_OWNS));
         if (mr->mtt.order < 0) {
                 mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_PHYSICAL);
                 mpt_entry->mtt_addr = 0;
@@ -708,13 +705,13 @@ static int mlx4_write_mtt_chunk(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
         if (!mtts)
                 return -ENOMEM;
 
-        dma_sync_single_for_cpu(&dev->pdev->dev, dma_handle,
+        dma_sync_single_for_cpu(&dev->persist->pdev->dev, dma_handle,
                                 npages * sizeof (u64), DMA_TO_DEVICE);
 
         for (i = 0; i < npages; ++i)
                 mtts[i] = cpu_to_be64(page_list[i] | MLX4_MTT_FLAG_PRESENT);
 
-        dma_sync_single_for_device(&dev->pdev->dev, dma_handle,
+        dma_sync_single_for_device(&dev->persist->pdev->dev, dma_handle,
                                    npages * sizeof (u64), DMA_TO_DEVICE);
 
         return 0;
@@ -1020,13 +1017,13 @@ int mlx4_map_phys_fmr(struct mlx4_dev *dev, struct mlx4_fmr *fmr, u64 *page_list
         /* Make sure MPT status is visible before writing MTT entries */
         wmb();
 
-        dma_sync_single_for_cpu(&dev->pdev->dev, fmr->dma_handle,
+        dma_sync_single_for_cpu(&dev->persist->pdev->dev, fmr->dma_handle,
                                 npages * sizeof(u64), DMA_TO_DEVICE);
 
         for (i = 0; i < npages; ++i)
                 fmr->mtts[i] = cpu_to_be64(page_list[i] | MLX4_MTT_FLAG_PRESENT);
 
-        dma_sync_single_for_device(&dev->pdev->dev, fmr->dma_handle,
+        dma_sync_single_for_device(&dev->persist->pdev->dev, fmr->dma_handle,
                                    npages * sizeof(u64), DMA_TO_DEVICE);
 
         fmr->mpt->key    = cpu_to_be32(key);
@@ -1155,7 +1152,7 @@ EXPORT_SYMBOL_GPL(mlx4_fmr_free);
 
 int mlx4_SYNC_TPT(struct mlx4_dev *dev)
 {
-        return mlx4_cmd(dev, 0, 0, 0, MLX4_CMD_SYNC_TPT, 1000,
-                        MLX4_CMD_NATIVE);
+        return mlx4_cmd(dev, 0, 0, 0, MLX4_CMD_SYNC_TPT,
+                        MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
 }
 EXPORT_SYMBOL_GPL(mlx4_SYNC_TPT);
diff --git a/drivers/net/ethernet/mellanox/mlx4/pd.c b/drivers/net/ethernet/mellanox/mlx4/pd.c
index 74216071201f..609c59dc854e 100644
--- a/drivers/net/ethernet/mellanox/mlx4/pd.c
+++ b/drivers/net/ethernet/mellanox/mlx4/pd.c
@@ -151,11 +151,13 @@ int mlx4_uar_alloc(struct mlx4_dev *dev, struct mlx4_uar *uar)
                 return -ENOMEM;
 
         if (mlx4_is_slave(dev))
-                offset = uar->index % ((int) pci_resource_len(dev->pdev, 2) /
+                offset = uar->index % ((int)pci_resource_len(dev->persist->pdev,
+                                                             2) /
                                        dev->caps.uar_page_size);
         else
                 offset = uar->index;
-        uar->pfn = (pci_resource_start(dev->pdev, 2) >> PAGE_SHIFT) + offset;
+        uar->pfn = (pci_resource_start(dev->persist->pdev, 2) >> PAGE_SHIFT)
+                    + offset;
         uar->map = NULL;
         return 0;
 }
@@ -212,7 +214,6 @@ int mlx4_bf_alloc(struct mlx4_dev *dev, struct mlx4_bf *bf, int node)
                 list_add(&uar->bf_list, &priv->bf_list);
         }
 
-        bf->uar = uar;
         idx = ffz(uar->free_bf_bmap);
         uar->free_bf_bmap |= 1 << idx;
         bf->uar = uar;
diff --git a/drivers/net/ethernet/mellanox/mlx4/port.c b/drivers/net/ethernet/mellanox/mlx4/port.c
index 30eb1ead0fe6..9f268f05290a 100644
--- a/drivers/net/ethernet/mellanox/mlx4/port.c
+++ b/drivers/net/ethernet/mellanox/mlx4/port.c
@@ -553,9 +553,9 @@ int mlx4_get_slave_num_gids(struct mlx4_dev *dev, int slave, int port)
                 slaves_pport_actv = mlx4_phys_to_slaves_pport_actv(
                                     dev, &exclusive_ports);
                 slave_gid -= bitmap_weight(slaves_pport_actv.slaves,
-                                           dev->num_vfs + 1);
+                                           dev->persist->num_vfs + 1);
         }
-        vfs = bitmap_weight(slaves_pport.slaves, dev->num_vfs + 1) - 1;
+        vfs = bitmap_weight(slaves_pport.slaves, dev->persist->num_vfs + 1) - 1;
         if (slave_gid <= ((MLX4_ROCE_MAX_GIDS - MLX4_ROCE_PF_GIDS) % vfs))
                 return ((MLX4_ROCE_MAX_GIDS - MLX4_ROCE_PF_GIDS) / vfs) + 1;
         return (MLX4_ROCE_MAX_GIDS - MLX4_ROCE_PF_GIDS) / vfs;
@@ -590,10 +590,10 @@ int mlx4_get_base_gid_ix(struct mlx4_dev *dev, int slave, int port)
                 slaves_pport_actv = mlx4_phys_to_slaves_pport_actv(
                                     dev, &exclusive_ports);
                 slave_gid -= bitmap_weight(slaves_pport_actv.slaves,
-                                           dev->num_vfs + 1);
+                                           dev->persist->num_vfs + 1);
         }
         gids = MLX4_ROCE_MAX_GIDS - MLX4_ROCE_PF_GIDS;
-        vfs = bitmap_weight(slaves_pport.slaves, dev->num_vfs + 1) - 1;
+        vfs = bitmap_weight(slaves_pport.slaves, dev->persist->num_vfs + 1) - 1;
         if (slave_gid <= gids % vfs)
                 return MLX4_ROCE_PF_GIDS + ((gids / vfs) + 1) * (slave_gid - 1);
 
@@ -644,7 +644,7 @@ void mlx4_reset_roce_gids(struct mlx4_dev *dev, int slave)
         int num_eth_ports, err;
         int i;
 
-        if (slave < 0 || slave > dev->num_vfs)
+        if (slave < 0 || slave > dev->persist->num_vfs)
                 return;
 
         actv_ports = mlx4_get_active_ports(dev, slave);
@@ -1214,7 +1214,8 @@ int mlx4_get_slave_from_roce_gid(struct mlx4_dev *dev, int port, u8 *gid,
                 return -EINVAL;
 
         slaves_pport = mlx4_phys_to_slaves_pport(dev, port);
-        num_vfs = bitmap_weight(slaves_pport.slaves, dev->num_vfs + 1) - 1;
+        num_vfs = bitmap_weight(slaves_pport.slaves,
+                                dev->persist->num_vfs + 1) - 1;
 
         for (i = 0; i < MLX4_ROCE_MAX_GIDS; i++) {
                 if (!memcmp(priv->port[port].gid_table.roce_gids[i].raw, gid,
@@ -1258,7 +1259,7 @@ int mlx4_get_slave_from_roce_gid(struct mlx4_dev *dev, int port, u8 *gid,
                                                         dev, &exclusive_ports);
                                 num_vfs_before += bitmap_weight(
                                                 slaves_pport_actv.slaves,
-                                                dev->num_vfs + 1);
+                                                dev->persist->num_vfs + 1);
                         }
 
                         /* candidate_slave_gid isn't necessarily the correct slave, but
@@ -1288,7 +1289,7 @@ int mlx4_get_slave_from_roce_gid(struct mlx4_dev *dev, int port, u8 *gid,
                                                 dev, &exclusive_ports);
                                 slave_gid += bitmap_weight(
                                                 slaves_pport_actv.slaves,
-                                                dev->num_vfs + 1);
+                                                dev->persist->num_vfs + 1);
                         }
                 }
                 *slave_id = slave_gid;
diff --git a/drivers/net/ethernet/mellanox/mlx4/qp.c b/drivers/net/ethernet/mellanox/mlx4/qp.c
index 1586ecce13c7..2bb8553bd905 100644
--- a/drivers/net/ethernet/mellanox/mlx4/qp.c
+++ b/drivers/net/ethernet/mellanox/mlx4/qp.c
@@ -882,6 +882,8 @@ int mlx4_qp_to_ready(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
         for (i = 0; i < ARRAY_SIZE(states) - 1; i++) {
                 context->flags &= cpu_to_be32(~(0xf << 28));
                 context->flags |= cpu_to_be32(states[i + 1] << 28);
+                if (states[i + 1] != MLX4_QP_STATE_RTR)
+                        context->params2 &= ~MLX4_QP_BIT_FPP;
                 err = mlx4_qp_modify(dev, mtt, states[i], states[i + 1],
                                      context, 0, 0, qp);
                 if (err) {
diff --git a/drivers/net/ethernet/mellanox/mlx4/reset.c b/drivers/net/ethernet/mellanox/mlx4/reset.c
index ea1c6d092145..0076d88587ca 100644
--- a/drivers/net/ethernet/mellanox/mlx4/reset.c
+++ b/drivers/net/ethernet/mellanox/mlx4/reset.c
@@ -76,19 +76,21 @@ int mlx4_reset(struct mlx4_dev *dev)
                 goto out;
         }
 
-        pcie_cap = pci_pcie_cap(dev->pdev);
+        pcie_cap = pci_pcie_cap(dev->persist->pdev);
 
         for (i = 0; i < 64; ++i) {
                 if (i == 22 || i == 23)
                         continue;
-                if (pci_read_config_dword(dev->pdev, i * 4, hca_header + i)) {
+                if (pci_read_config_dword(dev->persist->pdev, i * 4,
+                                          hca_header + i)) {
                         err = -ENODEV;
                         mlx4_err(dev, "Couldn't save HCA PCI header, aborting\n");
                         goto out;
                 }
         }
 
-        reset = ioremap(pci_resource_start(dev->pdev, 0) + MLX4_RESET_BASE,
+        reset = ioremap(pci_resource_start(dev->persist->pdev, 0) +
+                        MLX4_RESET_BASE,
                         MLX4_RESET_SIZE);
         if (!reset) {
                 err = -ENOMEM;
@@ -122,8 +124,8 @@ int mlx4_reset(struct mlx4_dev *dev)
 
         end = jiffies + MLX4_RESET_TIMEOUT_JIFFIES;
         do {
-                if (!pci_read_config_word(dev->pdev, PCI_VENDOR_ID, &vendor) &&
-                    vendor != 0xffff)
+                if (!pci_read_config_word(dev->persist->pdev, PCI_VENDOR_ID,
+                                          &vendor) && vendor != 0xffff)
                         break;
 
                 msleep(1);
@@ -138,14 +140,16 @@ int mlx4_reset(struct mlx4_dev *dev)
         /* Now restore the PCI headers */
         if (pcie_cap) {
                 devctl = hca_header[(pcie_cap + PCI_EXP_DEVCTL) / 4];
-                if (pcie_capability_write_word(dev->pdev, PCI_EXP_DEVCTL,
+                if (pcie_capability_write_word(dev->persist->pdev,
+                                               PCI_EXP_DEVCTL,
                                                devctl)) {
                         err = -ENODEV;
                         mlx4_err(dev, "Couldn't restore HCA PCI Express Device Control register, aborting\n");
                         goto out;
                 }
                 linkctl = hca_header[(pcie_cap + PCI_EXP_LNKCTL) / 4];
-                if (pcie_capability_write_word(dev->pdev, PCI_EXP_LNKCTL,
+                if (pcie_capability_write_word(dev->persist->pdev,
+                                               PCI_EXP_LNKCTL,
                                                linkctl)) {
                         err = -ENODEV;
                         mlx4_err(dev, "Couldn't restore HCA PCI Express Link control register, aborting\n");
@@ -157,7 +161,8 @@ int mlx4_reset(struct mlx4_dev *dev)
                 if (i * 4 == PCI_COMMAND)
                         continue;
 
-                if (pci_write_config_dword(dev->pdev, i * 4, hca_header[i])) {
+                if (pci_write_config_dword(dev->persist->pdev, i * 4,
+                                           hca_header[i])) {
                         err = -ENODEV;
                         mlx4_err(dev, "Couldn't restore HCA reg %x, aborting\n",
                                  i);
@@ -165,7 +170,7 @@ int mlx4_reset(struct mlx4_dev *dev)
                 }
         }
 
-        if (pci_write_config_dword(dev->pdev, PCI_COMMAND,
+        if (pci_write_config_dword(dev->persist->pdev, PCI_COMMAND,
                                    hca_header[PCI_COMMAND / 4])) {
                 err = -ENODEV;
                 mlx4_err(dev, "Couldn't restore HCA COMMAND, aborting\n");
diff --git a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
index 4efbd1eca611..486e3d26cd4a 100644
--- a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
+++ b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
@@ -309,12 +309,13 @@ static inline int mlx4_grant_resource(struct mlx4_dev *dev, int slave,
         int allocated, free, reserved, guaranteed, from_free;
         int from_rsvd;
 
-        if (slave > dev->num_vfs)
+        if (slave > dev->persist->num_vfs)
                 return -EINVAL;
 
         spin_lock(&res_alloc->alloc_lock);
         allocated = (port > 0) ?
-                res_alloc->allocated[(port - 1) * (dev->num_vfs + 1) + slave] :
+                res_alloc->allocated[(port - 1) *
+                (dev->persist->num_vfs + 1) + slave] :
                 res_alloc->allocated[slave];
         free = (port > 0) ? res_alloc->res_port_free[port - 1] :
                 res_alloc->res_free;
@@ -352,7 +353,8 @@ static inline int mlx4_grant_resource(struct mlx4_dev *dev, int slave,
         if (!err) {
                 /* grant the request */
                 if (port > 0) {
-                        res_alloc->allocated[(port - 1) * (dev->num_vfs + 1) + slave] += count;
+                        res_alloc->allocated[(port - 1) *
+                        (dev->persist->num_vfs + 1) + slave] += count;
                         res_alloc->res_port_free[port - 1] -= count;
                         res_alloc->res_port_rsvd[port - 1] -= from_rsvd;
                 } else {
@@ -376,13 +378,14 @@ static inline void mlx4_release_resource(struct mlx4_dev *dev, int slave,
                 &priv->mfunc.master.res_tracker.res_alloc[res_type];
         int allocated, guaranteed, from_rsvd;
 
-        if (slave > dev->num_vfs)
+        if (slave > dev->persist->num_vfs)
                 return;
 
         spin_lock(&res_alloc->alloc_lock);
 
         allocated = (port > 0) ?
-                res_alloc->allocated[(port - 1) * (dev->num_vfs + 1) + slave] :
+                res_alloc->allocated[(port - 1) *
+                (dev->persist->num_vfs + 1) + slave] :
                 res_alloc->allocated[slave];
         guaranteed = res_alloc->guaranteed[slave];
 
@@ -397,7 +400,8 @@ static inline void mlx4_release_resource(struct mlx4_dev *dev, int slave,
         }
 
         if (port > 0) {
-                res_alloc->allocated[(port - 1) * (dev->num_vfs + 1) + slave] -= count;
+                res_alloc->allocated[(port - 1) *
+                (dev->persist->num_vfs + 1) + slave] -= count;
                 res_alloc->res_port_free[port - 1] += count;
                 res_alloc->res_port_rsvd[port - 1] += from_rsvd;
         } else {
@@ -415,7 +419,8 @@ static inline void initialize_res_quotas(struct mlx4_dev *dev,
                                          enum mlx4_resource res_type,
                                          int vf, int num_instances)
 {
-        res_alloc->guaranteed[vf] = num_instances / (2 * (dev->num_vfs + 1));
+        res_alloc->guaranteed[vf] = num_instances /
+                                    (2 * (dev->persist->num_vfs + 1));
         res_alloc->quota[vf] = (num_instances / 2) + res_alloc->guaranteed[vf];
         if (vf == mlx4_master_func_num(dev)) {
                 res_alloc->res_free = num_instances;
@@ -486,21 +491,26 @@ int mlx4_init_resource_tracker(struct mlx4_dev *dev)
         for (i = 0; i < MLX4_NUM_OF_RESOURCE_TYPE; i++) {
                 struct resource_allocator *res_alloc =
                         &priv->mfunc.master.res_tracker.res_alloc[i];
-                res_alloc->quota = kmalloc((dev->num_vfs + 1) * sizeof(int), GFP_KERNEL);
-                res_alloc->guaranteed = kmalloc((dev->num_vfs + 1) * sizeof(int), GFP_KERNEL);
+                res_alloc->quota = kmalloc((dev->persist->num_vfs + 1) *
+                                           sizeof(int), GFP_KERNEL);
+                res_alloc->guaranteed = kmalloc((dev->persist->num_vfs + 1) *
+                                                sizeof(int), GFP_KERNEL);
                 if (i == RES_MAC || i == RES_VLAN)
                         res_alloc->allocated = kzalloc(MLX4_MAX_PORTS *
-                                                       (dev->num_vfs + 1) * sizeof(int),
-                                                        GFP_KERNEL);
+                                                       (dev->persist->num_vfs
+                                                       + 1) *
+                                                       sizeof(int), GFP_KERNEL);
                 else
-                        res_alloc->allocated = kzalloc((dev->num_vfs + 1) * sizeof(int), GFP_KERNEL);
+                        res_alloc->allocated = kzalloc((dev->persist->
+                                                        num_vfs + 1) *
+                                                       sizeof(int), GFP_KERNEL);
 
                 if (!res_alloc->quota || !res_alloc->guaranteed ||
                     !res_alloc->allocated)
                         goto no_mem_err;
 
                 spin_lock_init(&res_alloc->alloc_lock);
-                for (t = 0; t < dev->num_vfs + 1; t++) {
+                for (t = 0; t < dev->persist->num_vfs + 1; t++) {
                         struct mlx4_active_ports actv_ports =
                                 mlx4_get_active_ports(dev, t);
                         switch (i) {
@@ -2531,7 +2541,7 @@ int mlx4_SW2HW_MPT_wrapper(struct mlx4_dev *dev, int slave,
         /* Make sure that the PD bits related to the slave id are zeros. */
         pd = mr_get_pd(inbox->buf);
         pd_slave = (pd >> 17) & 0x7f;
-        if (pd_slave != 0 && pd_slave != slave) {
+        if (pd_slave != 0 && --pd_slave != slave) {
                 err = -EPERM;
                 goto ex_abort;
         }
@@ -2934,6 +2944,9 @@ static int verify_qp_parameters(struct mlx4_dev *dev,
         qp_type = (be32_to_cpu(qp_ctx->flags) >> 16) & 0xff;
         optpar  = be32_to_cpu(*(__be32 *) inbox->buf);
 
+        if (slave != mlx4_master_func_num(dev))
+                qp_ctx->params2 &= ~MLX4_QP_BIT_FPP;
+
         switch (qp_type) {
         case MLX4_QP_ST_RC:
         case MLX4_QP_ST_XRC:
@@ -4667,7 +4680,6 @@ static void rem_slave_eqs(struct mlx4_dev *dev, int slave)
         int state;
         LIST_HEAD(tlist);
         int eqn;
-        struct mlx4_cmd_mailbox *mailbox;
 
         err = move_all_busy(dev, slave, RES_EQ);
         if (err)
@@ -4693,20 +4705,13 @@ static void rem_slave_eqs(struct mlx4_dev *dev, int slave)
                                         break;
 
                                 case RES_EQ_HW:
-                                        mailbox = mlx4_alloc_cmd_mailbox(dev);
-                                        if (IS_ERR(mailbox)) {
-                                                cond_resched();
-                                                continue;
-                                        }
-                                        err = mlx4_cmd_box(dev, slave, 0,
-                                                           eqn & 0xff, 0,
-                                                           MLX4_CMD_HW2SW_EQ,
-                                                           MLX4_CMD_TIME_CLASS_A,
-                                                           MLX4_CMD_NATIVE);
+                                        err = mlx4_cmd(dev, slave, eqn & 0xff,
+                                                       1, MLX4_CMD_HW2SW_EQ,
+                                                       MLX4_CMD_TIME_CLASS_A,
+                                                       MLX4_CMD_NATIVE);
                                         if (err)
                                                 mlx4_dbg(dev, "rem_slave_eqs: failed to move slave %d eqs %d to SW ownership\n",
                                                          slave, eqn);
-                                        mlx4_free_cmd_mailbox(dev, mailbox);
                                         atomic_dec(&eq->mtt->ref_count);
                                         state = RES_EQ_RESERVED;
                                         break;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/alloc.c b/drivers/net/ethernet/mellanox/mlx5/core/alloc.c
index 56779c1c7811..201ca6d76ce5 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/alloc.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/alloc.c
@@ -121,7 +121,7 @@ void mlx5_buf_free(struct mlx5_core_dev *dev, struct mlx5_buf *buf)
                 dma_free_coherent(&dev->pdev->dev, buf->size, buf->direct.buf,
                                   buf->direct.map);
         else {
-                if (BITS_PER_LONG == 64 && buf->direct.buf)
+                if (BITS_PER_LONG == 64)
                         vunmap(buf->direct.buf);
 
                 for (i = 0; i < buf->nbufs; i++)
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/debugfs.c b/drivers/net/ethernet/mellanox/mlx5/core/debugfs.c
index 10e1f1a18255..4878025e231c 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/debugfs.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/debugfs.c
@@ -300,11 +300,11 @@ static u64 qp_read_field(struct mlx5_core_dev *dev, struct mlx5_core_qp *qp,
                 param = qp->pid;
                 break;
         case QP_STATE:
-                param = (u64)mlx5_qp_state_str(be32_to_cpu(ctx->flags) >> 28);
+                param = (unsigned long)mlx5_qp_state_str(be32_to_cpu(ctx->flags) >> 28);
                 *is_str = 1;
                 break;
         case QP_XPORT:
-                param = (u64)mlx5_qp_type_str((be32_to_cpu(ctx->flags) >> 16) & 0xff);
+                param = (unsigned long)mlx5_qp_type_str((be32_to_cpu(ctx->flags) >> 16) & 0xff);
                 *is_str = 1;
                 break;
         case QP_MTU:
@@ -464,7 +464,7 @@ static ssize_t dbg_read(struct file *filp, char __user *buf, size_t count,
 
 
         if (is_str)
-                ret = snprintf(tbuf, sizeof(tbuf), "%s\n", (const char *)field);
+                ret = snprintf(tbuf, sizeof(tbuf), "%s\n", (const char *)(unsigned long)field);
         else
                 ret = snprintf(tbuf, sizeof(tbuf), "0x%llx\n", field);
 
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c
index 3f4525619a07..d6651937d899 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/main.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c
@@ -903,12 +903,12 @@ static void remove_one(struct pci_dev *pdev)
 }
 
 static const struct pci_device_id mlx5_core_pci_table[] = {
-        { PCI_VDEVICE(MELLANOX, 4113) }, /* Connect-IB */
-        { PCI_VDEVICE(MELLANOX, 4114) }, /* Connect-IB VF */
-        { PCI_VDEVICE(MELLANOX, 4115) }, /* ConnectX-4 */
-        { PCI_VDEVICE(MELLANOX, 4116) }, /* ConnectX-4 VF */
-        { PCI_VDEVICE(MELLANOX, 4117) }, /* ConnectX-4LX */
-        { PCI_VDEVICE(MELLANOX, 4118) }, /* ConnectX-4LX VF */
+        { PCI_VDEVICE(MELLANOX, 0x1011) }, /* Connect-IB */
+        { PCI_VDEVICE(MELLANOX, 0x1012) }, /* Connect-IB VF */
+        { PCI_VDEVICE(MELLANOX, 0x1013) }, /* ConnectX-4 */
+        { PCI_VDEVICE(MELLANOX, 0x1014) }, /* ConnectX-4 VF */
+        { PCI_VDEVICE(MELLANOX, 0x1015) }, /* ConnectX-4LX */
+        { PCI_VDEVICE(MELLANOX, 0x1016) }, /* ConnectX-4LX VF */
         { 0, }
 };
 
diff --git a/drivers/net/ethernet/micrel/ksz884x.c b/drivers/net/ethernet/micrel/ksz884x.c
index 2fa6ae026e4f..10988fbf47eb 100644
--- a/drivers/net/ethernet/micrel/ksz884x.c
+++ b/drivers/net/ethernet/micrel/ksz884x.c
@@ -4342,9 +4342,7 @@ static void ksz_init_timer(struct ksz_timer_info *info, int period,
 {
         info->max = 0;
         info->period = period;
-        init_timer(&info->timer);
-        info->timer.function = function;
-        info->timer.data = (unsigned long) data;
+        setup_timer(&info->timer, function, (unsigned long)data);
 }
 
 static void ksz_update_timer(struct ksz_timer_info *info)
diff --git a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
index 71af98bb72cb..1412f5af05ec 100644
--- a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
+++ b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
@@ -4226,8 +4226,7 @@ static void myri10ge_remove(struct pci_dev *pdev)
                 mtrr_del(mgp->mtrr, mgp->iomem_base, mgp->board_span);
 #endif
         myri10ge_free_slices(mgp);
-        if (mgp->msix_vectors != NULL)
-                kfree(mgp->msix_vectors);
+        kfree(mgp->msix_vectors);
         dma_free_coherent(&pdev->dev, sizeof(*mgp->cmd),
                           mgp->cmd, mgp->cmd_bus);
 
diff --git a/drivers/net/ethernet/natsemi/ns83820.c b/drivers/net/ethernet/natsemi/ns83820.c
index 2552e550a78c..eb807b0dc72a 100644
--- a/drivers/net/ethernet/natsemi/ns83820.c
+++ b/drivers/net/ethernet/natsemi/ns83820.c
@@ -1122,12 +1122,12 @@ again:
         }
 
 #ifdef NS83820_VLAN_ACCEL_SUPPORT
-        if(vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 /* fetch the vlan tag info out of the
                  * ancillary data if the vlan code
                  * is using hw vlan acceleration
                  */
-                short tag = vlan_tx_tag_get(skb);
+                short tag = skb_vlan_tag_get(skb);
                 extsts |= (EXTSTS_VPKT | htons(tag));
         }
 #endif
diff --git a/drivers/net/ethernet/neterion/s2io.c b/drivers/net/ethernet/neterion/s2io.c
index db0c7a9aee60..a4cdf2f8041a 100644
--- a/drivers/net/ethernet/neterion/s2io.c
+++ b/drivers/net/ethernet/neterion/s2io.c
@@ -4045,8 +4045,8 @@ static netdev_tx_t s2io_xmit(struct sk_buff *skb, struct net_device *dev)
         }
 
         queue = 0;
-        if (vlan_tx_tag_present(skb))
-                vlan_tag = vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb))
+                vlan_tag = skb_vlan_tag_get(skb);
         if (sp->config.tx_steering_type == TX_DEFAULT_STEERING) {
                 if (skb->protocol == htons(ETH_P_IP)) {
                         struct iphdr *ip;
diff --git a/drivers/net/ethernet/neterion/vxge/vxge-config.c b/drivers/net/ethernet/neterion/vxge/vxge-config.c
index 2bbd01fcb9b0..6223930a8155 100644
--- a/drivers/net/ethernet/neterion/vxge/vxge-config.c
+++ b/drivers/net/ethernet/neterion/vxge/vxge-config.c
@@ -4637,7 +4637,7 @@ static void __vxge_hw_vp_terminate(struct __vxge_hw_device *hldev, u32 vp_id)
         vpath->ringh = NULL;
         vpath->fifoh = NULL;
         memset(&vpath->vpath_handles, 0, sizeof(struct list_head));
-        vpath->stats_block = 0;
+        vpath->stats_block = NULL;
         vpath->hw_stats = NULL;
         vpath->hw_stats_sav = NULL;
         vpath->sw_stats = NULL;
diff --git a/drivers/net/ethernet/neterion/vxge/vxge-main.c b/drivers/net/ethernet/neterion/vxge/vxge-main.c
index cc0485e3c621..50d5604833ed 100644
--- a/drivers/net/ethernet/neterion/vxge/vxge-main.c
+++ b/drivers/net/ethernet/neterion/vxge/vxge-main.c
@@ -890,8 +890,8 @@ vxge_xmit(struct sk_buff *skb, struct net_device *dev)
                 dev->name, __func__, __LINE__,
                 fifo_hw, dtr, dtr_priv);
 
-        if (vlan_tx_tag_present(skb)) {
-                u16 vlan_tag = vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb)) {
+                u16 vlan_tag = skb_vlan_tag_get(skb);
                 vxge_hw_fifo_txdl_vlan_set(dtr, vlan_tag);
         }
 
diff --git a/drivers/net/ethernet/nvidia/forcedeth.c b/drivers/net/ethernet/nvidia/forcedeth.c
index f39cae620f61..a41bb5e6b954 100644
--- a/drivers/net/ethernet/nvidia/forcedeth.c
+++ b/drivers/net/ethernet/nvidia/forcedeth.c
@@ -2462,9 +2462,9 @@ static netdev_tx_t nv_start_xmit_optimized(struct sk_buff *skb,
                          NV_TX2_CHECKSUM_L3 | NV_TX2_CHECKSUM_L4 : 0;
 
         /* vlan tag */
-        if (vlan_tx_tag_present(skb))
+        if (skb_vlan_tag_present(skb))
                 start_tx->txvlan = cpu_to_le32(NV_TX3_VLAN_TAG_PRESENT |
-                                        vlan_tx_tag_get(skb));
+                                        skb_vlan_tag_get(skb));
         else
                 start_tx->txvlan = 0;
 
diff --git a/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c b/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
index c531c8ae1be4..e0c31e3947d1 100644
--- a/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
+++ b/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
@@ -176,9 +176,7 @@ netxen_alloc_sds_rings(struct netxen_recv_context *recv_ctx, int count)
 static void
 netxen_free_sds_rings(struct netxen_recv_context *recv_ctx)
 {
-        if (recv_ctx->sds_rings != NULL)
-                kfree(recv_ctx->sds_rings);
-
+        kfree(recv_ctx->sds_rings);
         recv_ctx->sds_rings = NULL;
 }
 
@@ -1893,9 +1891,9 @@ netxen_tso_check(struct net_device *netdev,
                 protocol = vh->h_vlan_encapsulated_proto;
                 flags = FLAGS_VLAN_TAGGED;
 
-        } else if (vlan_tx_tag_present(skb)) {
+        } else if (skb_vlan_tag_present(skb)) {
                 flags = FLAGS_VLAN_OOB;
-                vid = vlan_tx_tag_get(skb);
+                vid = skb_vlan_tag_get(skb);
                 netxen_set_tx_vlan_tci(first_desc, vid);
                 vlan_oob = 1;
         }
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
index 4e1f58cf19ce..d4b5085a21fa 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
@@ -10,6 +10,7 @@
 #include <net/ip.h>
 #include <linux/ipv6.h>
 #include <net/checksum.h>
+#include <linux/printk.h>
 
 #include "qlcnic.h"
 
@@ -320,8 +321,8 @@ static void qlcnic_send_filter(struct qlcnic_adapter *adapter,
                 if (protocol == ETH_P_8021Q) {
                         vh = (struct vlan_ethhdr *)skb->data;
                         vlan_id = ntohs(vh->h_vlan_TCI);
-                } else if (vlan_tx_tag_present(skb)) {
-                        vlan_id = vlan_tx_tag_get(skb);
+                } else if (skb_vlan_tag_present(skb)) {
+                        vlan_id = skb_vlan_tag_get(skb);
                 }
         }
 
@@ -472,9 +473,9 @@ static int qlcnic_tx_pkt(struct qlcnic_adapter *adapter,
                 flags = QLCNIC_FLAGS_VLAN_TAGGED;
                 vlan_tci = ntohs(vh->h_vlan_TCI);
                 protocol = ntohs(vh->h_vlan_encapsulated_proto);
-        } else if (vlan_tx_tag_present(skb)) {
+        } else if (skb_vlan_tag_present(skb)) {
                 flags = QLCNIC_FLAGS_VLAN_OOB;
-                vlan_tci = vlan_tx_tag_get(skb);
+                vlan_tci = skb_vlan_tag_get(skb);
         }
         if (unlikely(adapter->tx_pvid)) {
                 if (vlan_tci && !(adapter->flags & QLCNIC_TAGGING_ENABLED))
@@ -1473,14 +1474,14 @@ void qlcnic_post_rx_buffers(struct qlcnic_adapter *adapter,
 
 static void dump_skb(struct sk_buff *skb, struct qlcnic_adapter *adapter)
 {
-        int i;
-        unsigned char *data = skb->data;
-
-        pr_info(KERN_INFO "\n");
-        for (i = 0; i < skb->len; i++) {
-                QLCDB(adapter, DRV, "%02x ", data[i]);
-                if ((i & 0x0f) == 8)
-                        pr_info(KERN_INFO "\n");
+        if (adapter->ahw->msg_enable & NETIF_MSG_DRV) {
+                char prefix[30];
+
+                scnprintf(prefix, sizeof(prefix), "%s: %s: ",
+                          dev_name(&adapter->pdev->dev), __func__);
+
+                print_hex_dump_debug(prefix, DUMP_PREFIX_NONE, 16, 1,
+                                     skb->data, skb->len, true);
         }
 }
 
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
index 2528c3fb6b90..a430a34a4434 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
@@ -294,9 +294,7 @@ int qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
 
 void qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
 {
-        if (recv_ctx->sds_rings != NULL)
-                kfree(recv_ctx->sds_rings);
-
+        kfree(recv_ctx->sds_rings);
         recv_ctx->sds_rings = NULL;
 }
 
@@ -1257,8 +1255,7 @@ qlcnic_check_options(struct qlcnic_adapter *adapter)
         if (ahw->op_mode != QLCNIC_NON_PRIV_FUNC) {
                 if (fw_dump->tmpl_hdr == NULL ||
                                 adapter->fw_version > prev_fw_version) {
-                        if (fw_dump->tmpl_hdr)
-                                vfree(fw_dump->tmpl_hdr);
+                        vfree(fw_dump->tmpl_hdr);
                         if (!qlcnic_fw_cmd_get_minidump_temp(adapter))
                                 dev_info(&pdev->dev,
                                         "Supports FW dump capability\n");
@@ -2374,13 +2371,12 @@ void qlcnic_free_tx_rings(struct qlcnic_adapter *adapter)
 
         for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
                 tx_ring = &adapter->tx_ring[ring];
-                if (tx_ring && tx_ring->cmd_buf_arr != NULL) {
+                if (tx_ring) {
                         vfree(tx_ring->cmd_buf_arr);
                         tx_ring->cmd_buf_arr = NULL;
                 }
         }
-        if (adapter->tx_ring != NULL)
-                kfree(adapter->tx_ring);
+        kfree(adapter->tx_ring);
 }
 
 int qlcnic_alloc_tx_rings(struct qlcnic_adapter *adapter,
@@ -2758,13 +2754,9 @@ static void qlcnic_remove(struct pci_dev *pdev)
         }
 
         qlcnic_dcb_free(adapter->dcb);
-
         qlcnic_detach(adapter);
-
-        if (adapter->npars != NULL)
-                kfree(adapter->npars);
-        if (adapter->eswitch != NULL)
-                kfree(adapter->eswitch);
+        kfree(adapter->npars);
+        kfree(adapter->eswitch);
 
         if (qlcnic_82xx_check(adapter))
                 qlcnic_clr_all_drv_state(adapter, 0);
@@ -2932,13 +2924,13 @@ void qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter)
 
 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter)
 {
-        if (adapter->fhash.fmax && adapter->fhash.fhead)
+        if (adapter->fhash.fmax)
                 kfree(adapter->fhash.fhead);
 
         adapter->fhash.fhead = NULL;
         adapter->fhash.fmax = 0;
 
-        if (adapter->rx_fhash.fmax && adapter->rx_fhash.fhead)
+        if (adapter->rx_fhash.fmax)
                 kfree(adapter->rx_fhash.fhead);
 
         adapter->rx_fhash.fmax = 0;
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_minidump.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_minidump.c
index c9f57fb84b9e..332bb8a3f430 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_minidump.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_minidump.c
@@ -1407,8 +1407,7 @@ void qlcnic_83xx_get_minidump_template(struct qlcnic_adapter *adapter)
         current_version = qlcnic_83xx_get_fw_version(adapter);
 
         if (fw_dump->tmpl_hdr == NULL || current_version > prev_version) {
-                if (fw_dump->tmpl_hdr)
-                        vfree(fw_dump->tmpl_hdr);
+                vfree(fw_dump->tmpl_hdr);
                 if (!qlcnic_fw_cmd_get_minidump_temp(adapter))
                         dev_info(&pdev->dev, "Supports FW dump capability\n");
         }
diff --git a/drivers/net/ethernet/qlogic/qlge/qlge_main.c b/drivers/net/ethernet/qlogic/qlge/qlge_main.c
index ef5aed3b1225..8011ef3e7707 100644
--- a/drivers/net/ethernet/qlogic/qlge/qlge_main.c
+++ b/drivers/net/ethernet/qlogic/qlge/qlge_main.c
@@ -2666,11 +2666,11 @@ static netdev_tx_t qlge_send(struct sk_buff *skb, struct net_device *ndev)
 
         mac_iocb_ptr->frame_len = cpu_to_le16((u16) skb->len);
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 netif_printk(qdev, tx_queued, KERN_DEBUG, qdev->ndev,
-                             "Adding a vlan tag %d.\n", vlan_tx_tag_get(skb));
+                             "Adding a vlan tag %d.\n", skb_vlan_tag_get(skb));
                 mac_iocb_ptr->flags3 |= OB_MAC_IOCB_V;
-                mac_iocb_ptr->vlan_tci = cpu_to_le16(vlan_tx_tag_get(skb));
+                mac_iocb_ptr->vlan_tci = cpu_to_le16(skb_vlan_tag_get(skb));
         }
         tso = ql_tso(skb, (struct ob_mac_tso_iocb_req *)mac_iocb_ptr);
         if (tso < 0) {
diff --git a/drivers/net/ethernet/realtek/8139cp.c b/drivers/net/ethernet/realtek/8139cp.c
index 9c31e46d1eee..d79e33b3c191 100644
--- a/drivers/net/ethernet/realtek/8139cp.c
+++ b/drivers/net/ethernet/realtek/8139cp.c
@@ -708,8 +708,8 @@ static void cp_tx (struct cp_private *cp)
 
 static inline u32 cp_tx_vlan_tag(struct sk_buff *skb)
 {
-        return vlan_tx_tag_present(skb) ?
-                TxVlanTag | swab16(vlan_tx_tag_get(skb)) : 0x00;
+        return skb_vlan_tag_present(skb) ?
+                TxVlanTag | swab16(skb_vlan_tag_get(skb)) : 0x00;
 }
 
 static void unwind_tx_frag_mapping(struct cp_private *cp, struct sk_buff *skb,
diff --git a/drivers/net/ethernet/realtek/r8169.c b/drivers/net/ethernet/realtek/r8169.c
index fa274e0f47d7..ad0020af2193 100644
--- a/drivers/net/ethernet/realtek/r8169.c
+++ b/drivers/net/ethernet/realtek/r8169.c
@@ -2073,8 +2073,8 @@ static int rtl8169_set_features(struct net_device *dev,
 
 static inline u32 rtl8169_tx_vlan_tag(struct sk_buff *skb)
 {
-        return (vlan_tx_tag_present(skb)) ?
-                TxVlanTag | swab16(vlan_tx_tag_get(skb)) : 0x00;
+        return (skb_vlan_tag_present(skb)) ?
+                TxVlanTag | swab16(skb_vlan_tag_get(skb)) : 0x00;
 }
 
 static void rtl8169_rx_vlan_tag(struct RxDesc *desc, struct sk_buff *skb)
@@ -7049,6 +7049,7 @@ static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
         u32 status, len;
         u32 opts[2];
         int frags;
+        bool stop_queue;
 
         if (unlikely(!TX_FRAGS_READY_FOR(tp, skb_shinfo(skb)->nr_frags))) {
                 netif_err(tp, drv, dev, "BUG! Tx Ring full when queue awake!\n");
@@ -7105,11 +7106,16 @@ static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
 
         tp->cur_tx += frags + 1;
 
-        RTL_W8(TxPoll, NPQ);
+        stop_queue = !TX_FRAGS_READY_FOR(tp, MAX_SKB_FRAGS);
 
-        mmiowb();
+        if (!skb->xmit_more || stop_queue ||
+            netif_xmit_stopped(netdev_get_tx_queue(dev, 0))) {
+                RTL_W8(TxPoll, NPQ);
+
+                mmiowb();
+        }
 
-        if (!TX_FRAGS_READY_FOR(tp, MAX_SKB_FRAGS)) {
+        if (stop_queue) {
                 /* Avoid wrongly optimistic queue wake-up: rtl_tx thread must
                  * not miss a ring update when it notices a stopped queue.
                  */
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
index 04283fe0e6a7..4da8bd263997 100644
--- a/drivers/net/ethernet/renesas/sh_eth.c
+++ b/drivers/net/ethernet/renesas/sh_eth.c
@@ -597,7 +597,7 @@ static struct sh_eth_cpu_data sh7757_data = {
 static void sh_eth_chip_reset_giga(struct net_device *ndev)
 {
         int i;
-        unsigned long mahr[2], malr[2];
+        u32 mahr[2], malr[2];
 
         /* save MAHR and MALR */
         for (i = 0; i < 2; i++) {
@@ -991,7 +991,7 @@ static void read_mac_address(struct net_device *ndev, unsigned char *mac)
         }
 }
 
-static unsigned long sh_eth_get_edtrr_trns(struct sh_eth_private *mdp)
+static u32 sh_eth_get_edtrr_trns(struct sh_eth_private *mdp)
 {
         if (sh_eth_is_gether(mdp) || sh_eth_is_rz_fast_ether(mdp))
                 return EDTRR_TRNS_GETHER;
@@ -1565,7 +1565,7 @@ static void sh_eth_rcv_snd_enable(struct net_device *ndev)
 }
 
 /* error control function */
-static void sh_eth_error(struct net_device *ndev, int intr_status)
+static void sh_eth_error(struct net_device *ndev, u32 intr_status)
 {
         struct sh_eth_private *mdp = netdev_priv(ndev);
         u32 felic_stat;
@@ -1678,7 +1678,7 @@ static irqreturn_t sh_eth_interrupt(int irq, void *netdev)
         struct sh_eth_private *mdp = netdev_priv(ndev);
         struct sh_eth_cpu_data *cd = mdp->cd;
         irqreturn_t ret = IRQ_NONE;
-        unsigned long intr_status, intr_enable;
+        u32 intr_status, intr_enable;
 
         spin_lock(&mdp->lock);
 
@@ -1709,7 +1709,7 @@ static irqreturn_t sh_eth_interrupt(int irq, void *netdev)
                         __napi_schedule(&mdp->napi);
                 } else {
                         netdev_warn(ndev,
-                                    "ignoring interrupt, status 0x%08lx, mask 0x%08lx.\n",
+                                    "ignoring interrupt, status 0x%08x, mask 0x%08x.\n",
                                     intr_status, intr_enable);
                 }
         }
@@ -1742,7 +1742,7 @@ static int sh_eth_poll(struct napi_struct *napi, int budget)
                                                   napi);
         struct net_device *ndev = napi->dev;
         int quota = budget;
-        unsigned long intr_status;
+        u32 intr_status;
 
         for (;;) {
                 intr_status = sh_eth_read(ndev, EESR);
@@ -2133,7 +2133,7 @@ static void sh_eth_tx_timeout(struct net_device *ndev)
 
         netif_err(mdp, timer, ndev,
                   "transmit timed out, status %8.8x, resetting...\n",
-                  (int)sh_eth_read(ndev, EESR));
+                  sh_eth_read(ndev, EESR));
 
         /* tx_errors count up */
         ndev->stats.tx_errors++;
@@ -3019,6 +3019,36 @@ static int sh_eth_drv_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
+static int sh_eth_suspend(struct device *dev)
+{
+        struct net_device *ndev = dev_get_drvdata(dev);
+        int ret = 0;
+
+        if (netif_running(ndev)) {
+                netif_device_detach(ndev);
+                ret = sh_eth_close(ndev);
+        }
+
+        return ret;
+}
+
+static int sh_eth_resume(struct device *dev)
+{
+        struct net_device *ndev = dev_get_drvdata(dev);
+        int ret = 0;
+
+        if (netif_running(ndev)) {
+                ret = sh_eth_open(ndev);
+                if (ret < 0)
+                        return ret;
+                netif_device_attach(ndev);
+        }
+
+        return ret;
+}
+#endif
+
 static int sh_eth_runtime_nop(struct device *dev)
 {
         /* Runtime PM callback shared between ->runtime_suspend()
@@ -3032,8 +3062,8 @@ static int sh_eth_runtime_nop(struct device *dev)
 }
 
 static const struct dev_pm_ops sh_eth_dev_pm_ops = {
-        .runtime_suspend = sh_eth_runtime_nop,
-        .runtime_resume = sh_eth_runtime_nop,
+        SET_SYSTEM_SLEEP_PM_OPS(sh_eth_suspend, sh_eth_resume)
+        SET_RUNTIME_PM_OPS(sh_eth_runtime_nop, sh_eth_runtime_nop, NULL)
 };
 #define SH_ETH_PM_OPS (&sh_eth_dev_pm_ops)
 #else
diff --git a/drivers/net/ethernet/renesas/sh_eth.h b/drivers/net/ethernet/renesas/sh_eth.h
index 332d3c16d483..259d03f353e1 100644
--- a/drivers/net/ethernet/renesas/sh_eth.h
+++ b/drivers/net/ethernet/renesas/sh_eth.h
@@ -459,21 +459,21 @@ struct sh_eth_cpu_data {
 
         /* mandatory initialize value */
         int register_type;
-        unsigned long eesipr_value;
+        u32 eesipr_value;
 
         /* optional initialize value */
-        unsigned long ecsr_value;
-        unsigned long ecsipr_value;
-        unsigned long fdr_value;
-        unsigned long fcftr_value;
-        unsigned long rpadir_value;
+        u32 ecsr_value;
+        u32 ecsipr_value;
+        u32 fdr_value;
+        u32 fcftr_value;
+        u32 rpadir_value;
 
         /* interrupt checking mask */
-        unsigned long tx_check;
-        unsigned long eesr_err_check;
+        u32 tx_check;
+        u32 eesr_err_check;
 
         /* Error mask */
-        unsigned long trscer_err_mask;
+        u32 trscer_err_mask;
 
         /* hardware features */
         unsigned long irq_flags; /* IRQ configuration flags */
@@ -543,7 +543,7 @@ static inline void sh_eth_soft_swap(char *src, int len)
 #endif
 }
 
-static inline void sh_eth_write(struct net_device *ndev, unsigned long data,
+static inline void sh_eth_write(struct net_device *ndev, u32 data,
                                 int enum_index)
 {
         struct sh_eth_private *mdp = netdev_priv(ndev);
@@ -551,8 +551,7 @@ static inline void sh_eth_write(struct net_device *ndev, unsigned long data,
         iowrite32(data, mdp->addr + mdp->reg_offset[enum_index]);
 }
 
-static inline unsigned long sh_eth_read(struct net_device *ndev,
-                                        int enum_index)
+static inline u32 sh_eth_read(struct net_device *ndev, int enum_index)
 {
         struct sh_eth_private *mdp = netdev_priv(ndev);
 
@@ -565,14 +564,13 @@ static inline void *sh_eth_tsu_get_offset(struct sh_eth_private *mdp,
         return mdp->tsu_addr + mdp->reg_offset[enum_index];
 }
 
-static inline void sh_eth_tsu_write(struct sh_eth_private *mdp,
-                                unsigned long data, int enum_index)
+static inline void sh_eth_tsu_write(struct sh_eth_private *mdp, u32 data,
+                                    int enum_index)
 {
         iowrite32(data, mdp->tsu_addr + mdp->reg_offset[enum_index]);
 }
 
-static inline unsigned long sh_eth_tsu_read(struct sh_eth_private *mdp,
-                                        int enum_index)
+static inline u32 sh_eth_tsu_read(struct sh_eth_private *mdp, int enum_index)
 {
         return ioread32(mdp->tsu_addr + mdp->reg_offset[enum_index]);
 }
diff --git a/drivers/net/ethernet/rocker/rocker.c b/drivers/net/ethernet/rocker/rocker.c
index 2f398fa4b9e6..34389b6aa67c 100644
--- a/drivers/net/ethernet/rocker/rocker.c
+++ b/drivers/net/ethernet/rocker/rocker.c
@@ -806,13 +806,13 @@ static bool rocker_desc_gen(struct rocker_desc_info *desc_info)
 
 static void *rocker_desc_cookie_ptr_get(struct rocker_desc_info *desc_info)
 {
-        return (void *) desc_info->desc->cookie;
+        return (void *)(uintptr_t)desc_info->desc->cookie;
 }
 
 static void rocker_desc_cookie_ptr_set(struct rocker_desc_info *desc_info,
                                        void *ptr)
 {
-        desc_info->desc->cookie = (long) ptr;
+        desc_info->desc->cookie = (uintptr_t) ptr;
 }
 
 static struct rocker_desc_info *
@@ -3026,11 +3026,17 @@ static void rocker_port_fdb_learn_work(struct work_struct *work)
                 container_of(work, struct rocker_fdb_learn_work, work);
         bool removing = (lw->flags & ROCKER_OP_FLAG_REMOVE);
         bool learned = (lw->flags & ROCKER_OP_FLAG_LEARNED);
+        struct netdev_switch_notifier_fdb_info info;
+
+        info.addr = lw->addr;
+        info.vid = lw->vid;
 
         if (learned && removing)
-                br_fdb_external_learn_del(lw->dev, lw->addr, lw->vid);
+                call_netdev_switch_notifiers(NETDEV_SWITCH_FDB_DEL,
+                                             lw->dev, &info.info);
         else if (learned && !removing)
-                br_fdb_external_learn_add(lw->dev, lw->addr, lw->vid);
+                call_netdev_switch_notifiers(NETDEV_SWITCH_FDB_ADD,
+                                             lw->dev, &info.info);
 
         kfree(work);
 }
@@ -3565,6 +3571,8 @@ nest_cancel:
         rocker_tlv_nest_cancel(desc_info, frags);
 out:
         dev_kfree_skb(skb);
+        dev->stats.tx_dropped++;
+
         return NETDEV_TX_OK;
 }
 
@@ -3668,7 +3676,8 @@ static int rocker_fdb_fill_info(struct sk_buff *skb,
         if (vid && nla_put_u16(skb, NDA_VLAN, vid))
                 goto nla_put_failure;
 
-        return nlmsg_end(skb, nlh);
+        nlmsg_end(skb, nlh);
+        return 0;
 
 nla_put_failure:
         nlmsg_cancel(skb, nlh);
@@ -3713,7 +3722,7 @@ skip:
 }
 
 static int rocker_port_bridge_setlink(struct net_device *dev,
-                                      struct nlmsghdr *nlh)
+                                      struct nlmsghdr *nlh, u16 flags)
 {
         struct rocker_port *rocker_port = netdev_priv(dev);
         struct nlattr *protinfo;
@@ -3824,11 +3833,145 @@ static void rocker_port_get_drvinfo(struct net_device *dev,
         strlcpy(drvinfo->version, UTS_RELEASE, sizeof(drvinfo->version));
 }
 
+static struct rocker_port_stats {
+        char str[ETH_GSTRING_LEN];
+        int type;
+} rocker_port_stats[] = {
+        { "rx_packets", ROCKER_TLV_CMD_PORT_STATS_RX_PKTS,    },
+        { "rx_bytes",   ROCKER_TLV_CMD_PORT_STATS_RX_BYTES,   },
+        { "rx_dropped", ROCKER_TLV_CMD_PORT_STATS_RX_DROPPED, },
+        { "rx_errors",  ROCKER_TLV_CMD_PORT_STATS_RX_ERRORS,  },
+
+        { "tx_packets", ROCKER_TLV_CMD_PORT_STATS_TX_PKTS,    },
+        { "tx_bytes",   ROCKER_TLV_CMD_PORT_STATS_TX_BYTES,   },
+        { "tx_dropped", ROCKER_TLV_CMD_PORT_STATS_TX_DROPPED, },
+        { "tx_errors",  ROCKER_TLV_CMD_PORT_STATS_TX_ERRORS,  },
+};
+
+#define ROCKER_PORT_STATS_LEN  ARRAY_SIZE(rocker_port_stats)
+
+static void rocker_port_get_strings(struct net_device *netdev, u32 stringset,
+                                    u8 *data)
+{
+        u8 *p = data;
+        int i;
+
+        switch (stringset) {
+        case ETH_SS_STATS:
+                for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) {
+                        memcpy(p, rocker_port_stats[i].str, ETH_GSTRING_LEN);
+                        p += ETH_GSTRING_LEN;
+                }
+                break;
+        }
+}
+
+static int
+rocker_cmd_get_port_stats_prep(struct rocker *rocker,
+                               struct rocker_port *rocker_port,
+                               struct rocker_desc_info *desc_info,
+                               void *priv)
+{
+        struct rocker_tlv *cmd_stats;
+
+        if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE,
+                               ROCKER_TLV_CMD_TYPE_GET_PORT_STATS))
+                return -EMSGSIZE;
+
+        cmd_stats = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
+        if (!cmd_stats)
+                return -EMSGSIZE;
+
+        if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_STATS_LPORT,
+                               rocker_port->lport))
+                return -EMSGSIZE;
+
+        rocker_tlv_nest_end(desc_info, cmd_stats);
+
+        return 0;
+}
+
+static int
+rocker_cmd_get_port_stats_ethtool_proc(struct rocker *rocker,
+                                       struct rocker_port *rocker_port,
+                                       struct rocker_desc_info *desc_info,
+                                       void *priv)
+{
+        struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1];
+        struct rocker_tlv *stats_attrs[ROCKER_TLV_CMD_PORT_STATS_MAX + 1];
+        struct rocker_tlv *pattr;
+        u32 lport;
+        u64 *data = priv;
+        int i;
+
+        rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info);
+
+        if (!attrs[ROCKER_TLV_CMD_INFO])
+                return -EIO;
+
+        rocker_tlv_parse_nested(stats_attrs, ROCKER_TLV_CMD_PORT_STATS_MAX,
+                                attrs[ROCKER_TLV_CMD_INFO]);
+
+        if (!stats_attrs[ROCKER_TLV_CMD_PORT_STATS_LPORT])
+                return -EIO;
+
+        lport = rocker_tlv_get_u32(stats_attrs[ROCKER_TLV_CMD_PORT_STATS_LPORT]);
+        if (lport != rocker_port->lport)
+                return -EIO;
+
+        for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) {
+                pattr = stats_attrs[rocker_port_stats[i].type];
+                if (!pattr)
+                        continue;
+
+                data[i] = rocker_tlv_get_u64(pattr);
+        }
+
+        return 0;
+}
+
+static int rocker_cmd_get_port_stats_ethtool(struct rocker_port *rocker_port,
+                                             void *priv)
+{
+        return rocker_cmd_exec(rocker_port->rocker, rocker_port,
+                               rocker_cmd_get_port_stats_prep, NULL,
+                               rocker_cmd_get_port_stats_ethtool_proc,
+                               priv, false);
+}
+
+static void rocker_port_get_stats(struct net_device *dev,
+                                  struct ethtool_stats *stats, u64 *data)
+{
+        struct rocker_port *rocker_port = netdev_priv(dev);
+
+        if (rocker_cmd_get_port_stats_ethtool(rocker_port, data) != 0) {
+                int i;
+
+                for (i = 0; i < ARRAY_SIZE(rocker_port_stats); ++i)
+                        data[i] = 0;
+        }
+
+        return;
+}
+
+static int rocker_port_get_sset_count(struct net_device *netdev, int sset)
+{
+        switch (sset) {
+        case ETH_SS_STATS:
+                return ROCKER_PORT_STATS_LEN;
+        default:
+                return -EOPNOTSUPP;
+        }
+}
+
 static const struct ethtool_ops rocker_port_ethtool_ops = {
         .get_settings           = rocker_port_get_settings,
         .set_settings           = rocker_port_set_settings,
         .get_drvinfo            = rocker_port_get_drvinfo,
         .get_link               = ethtool_op_get_link,
+        .get_strings            = rocker_port_get_strings,
+        .get_ethtool_stats      = rocker_port_get_stats,
+        .get_sset_count         = rocker_port_get_sset_count,
 };
 
 /*****************
@@ -3850,12 +3993,22 @@ static int rocker_port_poll_tx(struct napi_struct *napi, int budget)
 
         /* Cleanup tx descriptors */
         while ((desc_info = rocker_desc_tail_get(&rocker_port->tx_ring))) {
+                struct sk_buff *skb;
+
                 err = rocker_desc_err(desc_info);
                 if (err && net_ratelimit())
                         netdev_err(rocker_port->dev, "tx desc received with err %d\n",
                                    err);
                 rocker_tx_desc_frags_unmap(rocker_port, desc_info);
-                dev_kfree_skb_any(rocker_desc_cookie_ptr_get(desc_info));
+
+                skb = rocker_desc_cookie_ptr_get(desc_info);
+                if (err == 0) {
+                        rocker_port->dev->stats.tx_packets++;
+                        rocker_port->dev->stats.tx_bytes += skb->len;
+                } else
+                        rocker_port->dev->stats.tx_errors++;
+
+                dev_kfree_skb_any(skb);
                 credits++;
         }
 
@@ -3888,6 +4041,10 @@ static int rocker_port_rx_proc(struct rocker *rocker,
         rx_len = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FRAG_LEN]);
         skb_put(skb, rx_len);
         skb->protocol = eth_type_trans(skb, rocker_port->dev);
+
+        rocker_port->dev->stats.rx_packets++;
+        rocker_port->dev->stats.rx_bytes += skb->len;
+
         netif_receive_skb(skb);
 
         return rocker_dma_rx_ring_skb_alloc(rocker, rocker_port, desc_info);
@@ -3921,6 +4078,9 @@ static int rocker_port_poll_rx(struct napi_struct *napi, int budget)
                                 netdev_err(rocker_port->dev, "rx processing failed with err %d\n",
                                            err);
                 }
+                if (err)
+                        rocker_port->dev->stats.rx_errors++;
+
                 rocker_desc_gen_clear(desc_info);
                 rocker_desc_head_set(rocker, &rocker_port->rx_ring, desc_info);
                 credits++;
@@ -4004,7 +4164,8 @@ static int rocker_probe_port(struct rocker *rocker, unsigned int port_number)
                        NAPI_POLL_WEIGHT);
         rocker_carrier_init(rocker_port);
 
-        dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
+        dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER |
+                                NETIF_F_HW_SWITCH_OFFLOAD;
 
         err = register_netdev(dev);
         if (err) {
diff --git a/drivers/net/ethernet/rocker/rocker.h b/drivers/net/ethernet/rocker/rocker.h
index 8d2865ba634c..a5bc432feada 100644
--- a/drivers/net/ethernet/rocker/rocker.h
+++ b/drivers/net/ethernet/rocker/rocker.h
@@ -127,6 +127,9 @@ enum {
         ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL,
         ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_GET_STATS,
 
+        ROCKER_TLV_CMD_TYPE_CLEAR_PORT_STATS,
+        ROCKER_TLV_CMD_TYPE_GET_PORT_STATS,
+
         __ROCKER_TLV_CMD_TYPE_MAX,
         ROCKER_TLV_CMD_TYPE_MAX = __ROCKER_TLV_CMD_TYPE_MAX - 1,
 };
@@ -146,6 +149,24 @@ enum {
                         __ROCKER_TLV_CMD_PORT_SETTINGS_MAX - 1,
 };
 
+enum {
+        ROCKER_TLV_CMD_PORT_STATS_UNSPEC,
+        ROCKER_TLV_CMD_PORT_STATS_LPORT,            /* u32 */
+
+        ROCKER_TLV_CMD_PORT_STATS_RX_PKTS,          /* u64 */
+        ROCKER_TLV_CMD_PORT_STATS_RX_BYTES,         /* u64 */
+        ROCKER_TLV_CMD_PORT_STATS_RX_DROPPED,       /* u64 */
+        ROCKER_TLV_CMD_PORT_STATS_RX_ERRORS,        /* u64 */
+
+        ROCKER_TLV_CMD_PORT_STATS_TX_PKTS,          /* u64 */
+        ROCKER_TLV_CMD_PORT_STATS_TX_BYTES,         /* u64 */
+        ROCKER_TLV_CMD_PORT_STATS_TX_DROPPED,       /* u64 */
+        ROCKER_TLV_CMD_PORT_STATS_TX_ERRORS,        /* u64 */
+
+        __ROCKER_TLV_CMD_PORT_STATS_MAX,
+        ROCKER_TLV_CMD_PORT_STATS_MAX = __ROCKER_TLV_CMD_PORT_STATS_MAX - 1,
+};
+
 enum rocker_port_mode {
         ROCKER_PORT_MODE_OF_DPA,
 };
diff --git a/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c b/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c
index b1a271853d85..c8a01ee4d25e 100644
--- a/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c
+++ b/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c
@@ -133,9 +133,8 @@ bool sxgbe_eee_init(struct sxgbe_priv_data * const priv)
                         return false;
 
                 priv->eee_active = 1;
-                init_timer(&priv->eee_ctrl_timer);
-                priv->eee_ctrl_timer.function = sxgbe_eee_ctrl_timer;
-                priv->eee_ctrl_timer.data = (unsigned long)priv;
+                setup_timer(&priv->eee_ctrl_timer, sxgbe_eee_ctrl_timer,
+                            (unsigned long)priv);
                 priv->eee_ctrl_timer.expires = SXGBE_LPI_TIMER(eee_timer);
                 add_timer(&priv->eee_ctrl_timer);
 
@@ -365,6 +364,26 @@ static int sxgbe_init_rx_buffers(struct net_device *dev,
 
         return 0;
 }
+
+/**
+ * sxgbe_free_rx_buffers - free what sxgbe_init_rx_buffers() allocated
+ * @dev: net device structure
+ * @rx_ring: ring to be freed
+ * @rx_rsize: ring size
+ * Description:  this function initializes the DMA RX descriptor
+ */
+static void sxgbe_free_rx_buffers(struct net_device *dev,
+                                  struct sxgbe_rx_norm_desc *p, int i,
+                                  unsigned int dma_buf_sz,
+                                  struct sxgbe_rx_queue *rx_ring)
+{
+        struct sxgbe_priv_data *priv = netdev_priv(dev);
+
+        kfree_skb(rx_ring->rx_skbuff[i]);
+        dma_unmap_single(priv->device, rx_ring->rx_skbuff_dma[i],
+                         dma_buf_sz, DMA_FROM_DEVICE);
+}
+
 /**
  * init_tx_ring - init the TX descriptor ring
  * @dev: net device structure
@@ -457,7 +476,7 @@ static int init_rx_ring(struct net_device *dev, u8 queue_no,
         /* RX ring is not allcoated */
         if (rx_ring == NULL) {
                 netdev_err(dev, "No memory for RX queue\n");
-                goto error;
+                return -ENOMEM;
         }
 
         /* assign queue number */
@@ -469,23 +488,21 @@ static int init_rx_ring(struct net_device *dev, u8 queue_no,
                                               &rx_ring->dma_rx_phy, GFP_KERNEL);
 
         if (rx_ring->dma_rx == NULL)
-                goto error;
+                return -ENOMEM;
 
         /* allocate memory for RX skbuff array */
         rx_ring->rx_skbuff_dma = kmalloc_array(rx_rsize,
                                                sizeof(dma_addr_t), GFP_KERNEL);
         if (!rx_ring->rx_skbuff_dma) {
-                dma_free_coherent(priv->device,
-                                  rx_rsize * sizeof(struct sxgbe_rx_norm_desc),
-                                  rx_ring->dma_rx, rx_ring->dma_rx_phy);
-                goto error;
+                ret = -ENOMEM;
+                goto err_free_dma_rx;
         }
 
         rx_ring->rx_skbuff = kmalloc_array(rx_rsize,
                                            sizeof(struct sk_buff *), GFP_KERNEL);
         if (!rx_ring->rx_skbuff) {
-                kfree(rx_ring->rx_skbuff_dma);
-                goto error;
+                ret = -ENOMEM;
+                goto err_free_skbuff_dma;
         }
 
         /* initialise the buffers */
@@ -495,7 +512,7 @@ static int init_rx_ring(struct net_device *dev, u8 queue_no,
                 ret = sxgbe_init_rx_buffers(dev, p, desc_index,
                                             bfsize, rx_ring);
                 if (ret)
-                        goto err_init_rx_buffers;
+                        goto err_free_rx_buffers;
         }
 
         /* initalise counters */
@@ -505,11 +522,22 @@ static int init_rx_ring(struct net_device *dev, u8 queue_no,
 
         return 0;
 
-err_init_rx_buffers:
-        while (--desc_index >= 0)
-                free_rx_ring(priv->device, rx_ring, desc_index);
-error:
-        return -ENOMEM;
+err_free_rx_buffers:
+        while (--desc_index >= 0) {
+                struct sxgbe_rx_norm_desc *p;
+
+                p = rx_ring->dma_rx + desc_index;
+                sxgbe_free_rx_buffers(dev, p, desc_index, bfsize, rx_ring);
+        }
+        kfree(rx_ring->rx_skbuff);
+err_free_skbuff_dma:
+        kfree(rx_ring->rx_skbuff_dma);
+err_free_dma_rx:
+        dma_free_coherent(priv->device,
+                          rx_rsize * sizeof(struct sxgbe_rx_norm_desc),
+                          rx_ring->dma_rx, rx_ring->dma_rx_phy);
+
+        return ret;
 }
 /**
  * free_tx_ring - free the TX descriptor ring
@@ -1008,10 +1036,9 @@ static void sxgbe_tx_init_coalesce(struct sxgbe_priv_data *priv)
                 struct sxgbe_tx_queue *p = priv->txq[queue_num];
                 p->tx_coal_frames =  SXGBE_TX_FRAMES;
                 p->tx_coal_timer = SXGBE_COAL_TX_TIMER;
-                init_timer(&p->txtimer);
+                setup_timer(&p->txtimer, sxgbe_tx_timer,
+                            (unsigned long)&priv->txq[queue_num]);
                 p->txtimer.expires = SXGBE_COAL_TIMER(p->tx_coal_timer);
-                p->txtimer.data = (unsigned long)&priv->txq[queue_num];
-                p->txtimer.function = sxgbe_tx_timer;
                 add_timer(&p->txtimer);
         }
 }
@@ -1273,7 +1300,7 @@ static netdev_tx_t sxgbe_xmit(struct sk_buff *skb, struct net_device *dev)
         if (unlikely(skb_is_gso(skb) && tqueue->prev_mss != cur_mss))
                 ctxt_desc_req = 1;
 
-        if (unlikely(vlan_tx_tag_present(skb) ||
+        if (unlikely(skb_vlan_tag_present(skb) ||
                      ((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
                       tqueue->hwts_tx_en)))
                 ctxt_desc_req = 1;
diff --git a/drivers/net/ethernet/smsc/Kconfig b/drivers/net/ethernet/smsc/Kconfig
index 9468e64e6007..3e97a8b43147 100644
--- a/drivers/net/ethernet/smsc/Kconfig
+++ b/drivers/net/ethernet/smsc/Kconfig
@@ -5,8 +5,9 @@
 config NET_VENDOR_SMSC
         bool "SMC (SMSC)/Western Digital devices"
         default y
-        depends on ARM || ISA || MAC || ARM64 || MIPS || M32R || SUPERH || \
-                BLACKFIN || MN10300 || COLDFIRE || XTENSA || NIOS2 || PCI || PCMCIA
+        depends on ARM || ARM64 || ATARI_ETHERNAT || BLACKFIN || COLDFIRE || \
+                   ISA || M32R || MAC || MIPS || MN10300 || NIOS2 || PCI || \
+                   PCMCIA || SUPERH || XTENSA
         ---help---
           If you have a network (Ethernet) card belonging to this class, say Y
           and read the Ethernet-HOWTO, available from
@@ -38,8 +39,9 @@ config SMC91X
         tristate "SMC 91C9x/91C1xxx support"
         select CRC32
         select MII
-        depends on (ARM || M32R || SUPERH || MIPS || BLACKFIN || \
-                    MN10300 || COLDFIRE || ARM64 || XTENSA || NIOS2) && (!OF || GPIOLIB)
+        depends on !OF || GPIOLIB
+        depends on ARM || ARM64 || ATARI_ETHERNAT || BLACKFIN || COLDFIRE || \
+                   M32R || MIPS || MN10300 || NIOS2 || SUPERH || XTENSA
         ---help---
           This is a driver for SMC's 91x series of Ethernet chipsets,
           including the SMC91C94 and the SMC91C111. Say Y if you want it
diff --git a/drivers/net/ethernet/smsc/smc91x.h b/drivers/net/ethernet/smsc/smc91x.h
index 2a38dacbbd27..be67baf5f677 100644
--- a/drivers/net/ethernet/smsc/smc91x.h
+++ b/drivers/net/ethernet/smsc/smc91x.h
@@ -216,6 +216,27 @@ SMC_outw(u16 val, void __iomem *ioaddr, int reg)
 
 #include <unit/smc91111.h>
 
+#elif defined(CONFIG_ATARI)
+
+#define SMC_CAN_USE_8BIT        1
+#define SMC_CAN_USE_16BIT       1
+#define SMC_CAN_USE_32BIT       1
+#define SMC_NOWAIT              1
+
+#define SMC_inb(a, r)           readb((a) + (r))
+#define SMC_inw(a, r)           readw((a) + (r))
+#define SMC_inl(a, r)           readl((a) + (r))
+#define SMC_outb(v, a, r)       writeb(v, (a) + (r))
+#define SMC_outw(v, a, r)       writew(v, (a) + (r))
+#define SMC_outl(v, a, r)       writel(v, (a) + (r))
+#define SMC_insw(a, r, p, l)    readsw((a) + (r), p, l)
+#define SMC_outsw(a, r, p, l)   writesw((a) + (r), p, l)
+#define SMC_insl(a, r, p, l)    readsl((a) + (r), p, l)
+#define SMC_outsl(a, r, p, l)   writesl((a) + (r), p, l)
+
+#define RPC_LSA_DEFAULT         RPC_LED_100_10
+#define RPC_LSB_DEFAULT         RPC_LED_TX_RX
+
 #elif defined(CONFIG_ARCH_MSM)
 
 #define SMC_CAN_USE_8BIT        0
diff --git a/drivers/net/ethernet/stmicro/stmmac/Makefile b/drivers/net/ethernet/stmicro/stmmac/Makefile
index ac4d5629d905..73c2715a27f3 100644
--- a/drivers/net/ethernet/stmicro/stmmac/Makefile
+++ b/drivers/net/ethernet/stmicro/stmmac/Makefile
@@ -6,7 +6,7 @@ stmmac-objs:= stmmac_main.o stmmac_ethtool.o stmmac_mdio.o ring_mode.o	\
 
 obj-$(CONFIG_STMMAC_PLATFORM) += stmmac-platform.o
 stmmac-platform-objs:= stmmac_platform.o dwmac-meson.o dwmac-sunxi.o    \
-                       dwmac-sti.o dwmac-socfpga.o
+                       dwmac-sti.o dwmac-socfpga.o dwmac-rk.o
 
 obj-$(CONFIG_STMMAC_PCI) += stmmac-pci.o
 stmmac-pci-objs:= stmmac_pci.o
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c
new file mode 100644
index 000000000000..6249a4ec08f0
--- /dev/null
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c
@@ -0,0 +1,437 @@
+/**
+ * dwmac-rk.c - Rockchip RK3288 DWMAC specific glue layer
+ *
+ * Copyright (C) 2014 Chen-Zhi (Roger Chen)
+ *
+ * Chen-Zhi (Roger Chen)  <roger.chen@rock-chips.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/stmmac.h>
+#include <linux/bitops.h>
+#include <linux/clk.h>
+#include <linux/phy.h>
+#include <linux/of_net.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
+#include <linux/of_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/delay.h>
+#include <linux/mfd/syscon.h>
+#include <linux/regmap.h>
+
+struct rk_priv_data {
+        struct platform_device *pdev;
+        int phy_iface;
+        struct regulator *regulator;
+
+        bool clk_enabled;
+        bool clock_input;
+
+        struct clk *clk_mac;
+        struct clk *clk_mac_pll;
+        struct clk *gmac_clkin;
+        struct clk *mac_clk_rx;
+        struct clk *mac_clk_tx;
+        struct clk *clk_mac_ref;
+        struct clk *clk_mac_refout;
+        struct clk *aclk_mac;
+        struct clk *pclk_mac;
+
+        int tx_delay;
+        int rx_delay;
+
+        struct regmap *grf;
+};
+
+#define HIWORD_UPDATE(val, mask, shift) \
+                ((val) << (shift) | (mask) << ((shift) + 16))
+
+#define GRF_BIT(nr)     (BIT(nr) | BIT(nr+16))
+#define GRF_CLR_BIT(nr) (BIT(nr+16))
+
+#define RK3288_GRF_SOC_CON1     0x0248
+#define RK3288_GRF_SOC_CON3     0x0250
+#define RK3288_GRF_GPIO3D_E     0x01ec
+#define RK3288_GRF_GPIO4A_E     0x01f0
+#define RK3288_GRF_GPIO4B_E     0x01f4
+
+/*RK3288_GRF_SOC_CON1*/
+#define GMAC_PHY_INTF_SEL_RGMII (GRF_BIT(6) | GRF_CLR_BIT(7) | GRF_CLR_BIT(8))
+#define GMAC_PHY_INTF_SEL_RMII  (GRF_CLR_BIT(6) | GRF_CLR_BIT(7) | GRF_BIT(8))
+#define GMAC_FLOW_CTRL          GRF_BIT(9)
+#define GMAC_FLOW_CTRL_CLR      GRF_CLR_BIT(9)
+#define GMAC_SPEED_10M          GRF_CLR_BIT(10)
+#define GMAC_SPEED_100M         GRF_BIT(10)
+#define GMAC_RMII_CLK_25M       GRF_BIT(11)
+#define GMAC_RMII_CLK_2_5M      GRF_CLR_BIT(11)
+#define GMAC_CLK_125M           (GRF_CLR_BIT(12) | GRF_CLR_BIT(13))
+#define GMAC_CLK_25M            (GRF_BIT(12) | GRF_BIT(13))
+#define GMAC_CLK_2_5M           (GRF_CLR_BIT(12) | GRF_BIT(13))
+#define GMAC_RMII_MODE          GRF_BIT(14)
+#define GMAC_RMII_MODE_CLR      GRF_CLR_BIT(14)
+
+/*RK3288_GRF_SOC_CON3*/
+#define GMAC_TXCLK_DLY_ENABLE   GRF_BIT(14)
+#define GMAC_TXCLK_DLY_DISABLE  GRF_CLR_BIT(14)
+#define GMAC_RXCLK_DLY_ENABLE   GRF_BIT(15)
+#define GMAC_RXCLK_DLY_DISABLE  GRF_CLR_BIT(15)
+#define GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 7)
+#define GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
+
+static void set_to_rgmii(struct rk_priv_data *bsp_priv,
+                         int tx_delay, int rx_delay)
+{
+        struct device *dev = &bsp_priv->pdev->dev;
+
+        if (IS_ERR(bsp_priv->grf)) {
+                dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
+                return;
+        }
+
+        regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
+                     GMAC_PHY_INTF_SEL_RGMII | GMAC_RMII_MODE_CLR);
+        regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON3,
+                     GMAC_RXCLK_DLY_ENABLE | GMAC_TXCLK_DLY_ENABLE |
+                     GMAC_CLK_RX_DL_CFG(rx_delay) |
+                     GMAC_CLK_TX_DL_CFG(tx_delay));
+}
+
+static void set_to_rmii(struct rk_priv_data *bsp_priv)
+{
+        struct device *dev = &bsp_priv->pdev->dev;
+
+        if (IS_ERR(bsp_priv->grf)) {
+                dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
+                return;
+        }
+
+        regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
+                     GMAC_PHY_INTF_SEL_RMII | GMAC_RMII_MODE);
+}
+
+static void set_rgmii_speed(struct rk_priv_data *bsp_priv, int speed)
+{
+        struct device *dev = &bsp_priv->pdev->dev;
+
+        if (IS_ERR(bsp_priv->grf)) {
+                dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
+                return;
+        }
+
+        if (speed == 10)
+                regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1, GMAC_CLK_2_5M);
+        else if (speed == 100)
+                regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1, GMAC_CLK_25M);
+        else if (speed == 1000)
+                regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1, GMAC_CLK_125M);
+        else
+                dev_err(dev, "unknown speed value for RGMII! speed=%d", speed);
+}
+
+static void set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
+{
+        struct device *dev = &bsp_priv->pdev->dev;
+
+        if (IS_ERR(bsp_priv->grf)) {
+                dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
+                return;
+        }
+
+        if (speed == 10) {
+                regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
+                             GMAC_RMII_CLK_2_5M | GMAC_SPEED_10M);
+        } else if (speed == 100) {
+                regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
+                             GMAC_RMII_CLK_25M | GMAC_SPEED_100M);
+        } else {
+                dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
+        }
+}
+
+static int gmac_clk_init(struct rk_priv_data *bsp_priv)
+{
+        struct device *dev = &bsp_priv->pdev->dev;
+
+        bsp_priv->clk_enabled = false;
+
+        bsp_priv->mac_clk_rx = devm_clk_get(dev, "mac_clk_rx");
+        if (IS_ERR(bsp_priv->mac_clk_rx))
+                dev_err(dev, "%s: cannot get clock %s\n",
+                        __func__, "mac_clk_rx");
+
+        bsp_priv->mac_clk_tx = devm_clk_get(dev, "mac_clk_tx");
+        if (IS_ERR(bsp_priv->mac_clk_tx))
+                dev_err(dev, "%s: cannot get clock %s\n",
+                        __func__, "mac_clk_tx");
+
+        bsp_priv->aclk_mac = devm_clk_get(dev, "aclk_mac");
+        if (IS_ERR(bsp_priv->aclk_mac))
+                dev_err(dev, "%s: cannot get clock %s\n",
+                        __func__, "aclk_mac");
+
+        bsp_priv->pclk_mac = devm_clk_get(dev, "pclk_mac");
+        if (IS_ERR(bsp_priv->pclk_mac))
+                dev_err(dev, "%s: cannot get clock %s\n",
+                        __func__, "pclk_mac");
+
+        bsp_priv->clk_mac = devm_clk_get(dev, "stmmaceth");
+        if (IS_ERR(bsp_priv->clk_mac))
+                dev_err(dev, "%s: cannot get clock %s\n",
+                        __func__, "stmmaceth");
+
+        if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII) {
+                bsp_priv->clk_mac_ref = devm_clk_get(dev, "clk_mac_ref");
+                if (IS_ERR(bsp_priv->clk_mac_ref))
+                        dev_err(dev, "%s: cannot get clock %s\n",
+                                __func__, "clk_mac_ref");
+
+                if (!bsp_priv->clock_input) {
+                        bsp_priv->clk_mac_refout =
+                                devm_clk_get(dev, "clk_mac_refout");
+                        if (IS_ERR(bsp_priv->clk_mac_refout))
+                                dev_err(dev, "%s: cannot get clock %s\n",
+                                        __func__, "clk_mac_refout");
+                }
+        }
+
+        if (bsp_priv->clock_input) {
+                dev_info(dev, "%s: clock input from PHY\n", __func__);
+        } else {
+                if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII)
+                        clk_set_rate(bsp_priv->clk_mac_pll, 50000000);
+        }
+
+        return 0;
+}
+
+static int gmac_clk_enable(struct rk_priv_data *bsp_priv, bool enable)
+{
+        int phy_iface = phy_iface = bsp_priv->phy_iface;
+
+        if (enable) {
+                if (!bsp_priv->clk_enabled) {
+                        if (phy_iface == PHY_INTERFACE_MODE_RMII) {
+                                if (!IS_ERR(bsp_priv->mac_clk_rx))
+                                        clk_prepare_enable(
+                                                bsp_priv->mac_clk_rx);
+
+                                if (!IS_ERR(bsp_priv->clk_mac_ref))
+                                        clk_prepare_enable(
+                                                bsp_priv->clk_mac_ref);
+
+                                if (!IS_ERR(bsp_priv->clk_mac_refout))
+                                        clk_prepare_enable(
+                                                bsp_priv->clk_mac_refout);
+                        }
+
+                        if (!IS_ERR(bsp_priv->aclk_mac))
+                                clk_prepare_enable(bsp_priv->aclk_mac);
+
+                        if (!IS_ERR(bsp_priv->pclk_mac))
+                                clk_prepare_enable(bsp_priv->pclk_mac);
+
+                        if (!IS_ERR(bsp_priv->mac_clk_tx))
+                                clk_prepare_enable(bsp_priv->mac_clk_tx);
+
+                        /**
+                         * if (!IS_ERR(bsp_priv->clk_mac))
+                         *      clk_prepare_enable(bsp_priv->clk_mac);
+                         */
+                        mdelay(5);
+                        bsp_priv->clk_enabled = true;
+                }
+        } else {
+                if (bsp_priv->clk_enabled) {
+                        if (phy_iface == PHY_INTERFACE_MODE_RMII) {
+                                if (!IS_ERR(bsp_priv->mac_clk_rx))
+                                        clk_disable_unprepare(
+                                                bsp_priv->mac_clk_rx);
+
+                                if (!IS_ERR(bsp_priv->clk_mac_ref))
+                                        clk_disable_unprepare(
+                                                bsp_priv->clk_mac_ref);
+
+                                if (!IS_ERR(bsp_priv->clk_mac_refout))
+                                        clk_disable_unprepare(
+                                                bsp_priv->clk_mac_refout);
+                        }
+
+                        if (!IS_ERR(bsp_priv->aclk_mac))
+                                clk_disable_unprepare(bsp_priv->aclk_mac);
+
+                        if (!IS_ERR(bsp_priv->pclk_mac))
+                                clk_disable_unprepare(bsp_priv->pclk_mac);
+
+                        if (!IS_ERR(bsp_priv->mac_clk_tx))
+                                clk_disable_unprepare(bsp_priv->mac_clk_tx);
+                        /**
+                         * if (!IS_ERR(bsp_priv->clk_mac))
+                         *      clk_disable_unprepare(bsp_priv->clk_mac);
+                         */
+                        bsp_priv->clk_enabled = false;
+                }
+        }
+
+        return 0;
+}
+
+static int phy_power_on(struct rk_priv_data *bsp_priv, bool enable)
+{
+        struct regulator *ldo = bsp_priv->regulator;
+        int ret;
+        struct device *dev = &bsp_priv->pdev->dev;
+
+        if (!ldo) {
+                dev_err(dev, "%s: no regulator found\n", __func__);
+                return -1;
+        }
+
+        if (enable) {
+                ret = regulator_enable(ldo);
+                if (ret)
+                        dev_err(dev, "%s: fail to enable phy-supply\n",
+                                __func__);
+        } else {
+                ret = regulator_disable(ldo);
+                if (ret)
+                        dev_err(dev, "%s: fail to disable phy-supply\n",
+                                __func__);
+        }
+
+        return 0;
+}
+
+static void *rk_gmac_setup(struct platform_device *pdev)
+{
+        struct rk_priv_data *bsp_priv;
+        struct device *dev = &pdev->dev;
+        int ret;
+        const char *strings = NULL;
+        int value;
+
+        bsp_priv = devm_kzalloc(dev, sizeof(*bsp_priv), GFP_KERNEL);
+        if (!bsp_priv)
+                return ERR_PTR(-ENOMEM);
+
+        bsp_priv->phy_iface = of_get_phy_mode(dev->of_node);
+
+        bsp_priv->regulator = devm_regulator_get_optional(dev, "phy");
+        if (IS_ERR(bsp_priv->regulator)) {
+                if (PTR_ERR(bsp_priv->regulator) == -EPROBE_DEFER) {
+                        dev_err(dev, "phy regulator is not available yet, deferred probing\n");
+                        return ERR_PTR(-EPROBE_DEFER);
+                }
+                dev_err(dev, "no regulator found\n");
+                bsp_priv->regulator = NULL;
+        }
+
+        ret = of_property_read_string(dev->of_node, "clock_in_out", &strings);
+        if (ret) {
+                dev_err(dev, "%s: Can not read property: clock_in_out.\n",
+                        __func__);
+                bsp_priv->clock_input = true;
+        } else {
+                dev_info(dev, "%s: clock input or output? (%s).\n",
+                         __func__, strings);
+                if (!strcmp(strings, "input"))
+                        bsp_priv->clock_input = true;
+                else
+                        bsp_priv->clock_input = false;
+        }
+
+        ret = of_property_read_u32(dev->of_node, "tx_delay", &value);
+        if (ret) {
+                bsp_priv->tx_delay = 0x30;
+                dev_err(dev, "%s: Can not read property: tx_delay.", __func__);
+                dev_err(dev, "%s: set tx_delay to 0x%x\n",
+                        __func__, bsp_priv->tx_delay);
+        } else {
+                dev_info(dev, "%s: TX delay(0x%x).\n", __func__, value);
+                bsp_priv->tx_delay = value;
+        }
+
+        ret = of_property_read_u32(dev->of_node, "rx_delay", &value);
+        if (ret) {
+                bsp_priv->rx_delay = 0x10;
+                dev_err(dev, "%s: Can not read property: rx_delay.", __func__);
+                dev_err(dev, "%s: set rx_delay to 0x%x\n",
+                        __func__, bsp_priv->rx_delay);
+        } else {
+                dev_info(dev, "%s: RX delay(0x%x).\n", __func__, value);
+                bsp_priv->rx_delay = value;
+        }
+
+        bsp_priv->grf = syscon_regmap_lookup_by_phandle(dev->of_node,
+                                                        "rockchip,grf");
+        bsp_priv->pdev = pdev;
+
+        /*rmii or rgmii*/
+        if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RGMII) {
+                dev_info(dev, "%s: init for RGMII\n", __func__);
+                set_to_rgmii(bsp_priv, bsp_priv->tx_delay, bsp_priv->rx_delay);
+        } else if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII) {
+                dev_info(dev, "%s: init for RMII\n", __func__);
+                set_to_rmii(bsp_priv);
+        } else {
+                dev_err(dev, "%s: NO interface defined!\n", __func__);
+        }
+
+        gmac_clk_init(bsp_priv);
+
+        return bsp_priv;
+}
+
+static int rk_gmac_init(struct platform_device *pdev, void *priv)
+{
+        struct rk_priv_data *bsp_priv = priv;
+        int ret;
+
+        ret = phy_power_on(bsp_priv, true);
+        if (ret)
+                return ret;
+
+        ret = gmac_clk_enable(bsp_priv, true);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static void rk_gmac_exit(struct platform_device *pdev, void *priv)
+{
+        struct rk_priv_data *gmac = priv;
+
+        phy_power_on(gmac, false);
+        gmac_clk_enable(gmac, false);
+}
+
+static void rk_fix_speed(void *priv, unsigned int speed)
+{
+        struct rk_priv_data *bsp_priv = priv;
+        struct device *dev = &bsp_priv->pdev->dev;
+
+        if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RGMII)
+                set_rgmii_speed(bsp_priv, speed);
+        else if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII)
+                set_rmii_speed(bsp_priv, speed);
+        else
+                dev_err(dev, "unsupported interface %d", bsp_priv->phy_iface);
+}
+
+const struct stmmac_of_data rk3288_gmac_data = {
+        .has_gmac = 1,
+        .fix_mac_speed = rk_fix_speed,
+        .setup = rk_gmac_setup,
+        .init = rk_gmac_init,
+        .exit = rk_gmac_exit,
+};
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-sti.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-sti.c
index 056b358b4a72..bb6e2dc61bec 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-sti.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-sti.c
@@ -122,7 +122,7 @@ struct sti_dwmac {
         bool ext_phyclk;        /* Clock from external PHY */
         u32 tx_retime_src;      /* TXCLK Retiming*/
         struct clk *clk;        /* PHY clock */
-        int ctrl_reg;           /* GMAC glue-logic control register */
+        u32 ctrl_reg;           /* GMAC glue-logic control register */
         int clk_sel_reg;        /* GMAC ext clk selection register */
         struct device *dev;
         struct regmap *regmap;
@@ -285,11 +285,6 @@ static int sti_dwmac_parse_data(struct sti_dwmac *dwmac,
         if (!np)
                 return -EINVAL;
 
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sti-ethconf");
-        if (!res)
-                return -ENODATA;
-        dwmac->ctrl_reg = res->start;
-
         /* clk selection from extra syscfg register */
         dwmac->clk_sel_reg = -ENXIO;
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sti-clkconf");
@@ -300,6 +295,12 @@ static int sti_dwmac_parse_data(struct sti_dwmac *dwmac,
         if (IS_ERR(regmap))
                 return PTR_ERR(regmap);
 
+        err = of_property_read_u32_index(np, "st,syscon", 1, &dwmac->ctrl_reg);
+        if (err) {
+                dev_err(dev, "Can't get sysconfig ctrl offset (%d)\n", err);
+                return err;
+        }
+
         dwmac->dev = dev;
         dwmac->interface = of_get_phy_mode(np);
         dwmac->regmap = regmap;
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index cf62ff4c8c56..55e89b3838f1 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -1097,6 +1097,7 @@ static int init_dma_desc_rings(struct net_device *dev, gfp_t flags)
 
         priv->dirty_tx = 0;
         priv->cur_tx = 0;
+        netdev_reset_queue(priv->dev);
 
         stmmac_clear_descriptors(priv);
 
@@ -1287,7 +1288,7 @@ static void stmmac_dma_operation_mode(struct stmmac_priv *priv)
                  *    that needs to not insert csum in the TDES.
                  */
                 priv->hw->dma->dma_mode(priv->ioaddr, SF_DMA_MODE, SF_DMA_MODE);
-                tc = SF_DMA_MODE;
+                priv->xstats.threshold = SF_DMA_MODE;
         } else
                 priv->hw->dma->dma_mode(priv->ioaddr, tc, SF_DMA_MODE);
 }
@@ -1300,6 +1301,7 @@ static void stmmac_dma_operation_mode(struct stmmac_priv *priv)
 static void stmmac_tx_clean(struct stmmac_priv *priv)
 {
         unsigned int txsize = priv->dma_tx_size;
+        unsigned int bytes_compl = 0, pkts_compl = 0;
 
         spin_lock(&priv->tx_lock);
 
@@ -1356,6 +1358,8 @@ static void stmmac_tx_clean(struct stmmac_priv *priv)
                 priv->hw->mode->clean_desc3(priv, p);
 
                 if (likely(skb != NULL)) {
+                        pkts_compl++;
+                        bytes_compl += skb->len;
                         dev_consume_skb_any(skb);
                         priv->tx_skbuff[entry] = NULL;
                 }
@@ -1364,6 +1368,9 @@ static void stmmac_tx_clean(struct stmmac_priv *priv)
 
                 priv->dirty_tx++;
         }
+
+        netdev_completed_queue(priv->dev, pkts_compl, bytes_compl);
+
         if (unlikely(netif_queue_stopped(priv->dev) &&
                      stmmac_tx_avail(priv) > STMMAC_TX_THRESH(priv))) {
                 netif_tx_lock(priv->dev);
@@ -1418,6 +1425,7 @@ static void stmmac_tx_err(struct stmmac_priv *priv)
                                                      (i == txsize - 1));
         priv->dirty_tx = 0;
         priv->cur_tx = 0;
+        netdev_reset_queue(priv->dev);
         priv->hw->dma->start_tx(priv->ioaddr);
 
         priv->dev->stats.tx_errors++;
@@ -1444,9 +1452,14 @@ static void stmmac_dma_interrupt(struct stmmac_priv *priv)
         }
         if (unlikely(status & tx_hard_error_bump_tc)) {
                 /* Try to bump up the dma threshold on this failure */
-                if (unlikely(tc != SF_DMA_MODE) && (tc <= 256)) {
+                if (unlikely(priv->xstats.threshold != SF_DMA_MODE) &&
+                    (tc <= 256)) {
                         tc += 64;
-                        priv->hw->dma->dma_mode(priv->ioaddr, tc, SF_DMA_MODE);
+                        if (priv->plat->force_thresh_dma_mode)
+                                priv->hw->dma->dma_mode(priv->ioaddr, tc, tc);
+                        else
+                                priv->hw->dma->dma_mode(priv->ioaddr, tc,
+                                        SF_DMA_MODE);
                         priv->xstats.threshold = tc;
                 }
         } else if (unlikely(status == tx_hard_error))
@@ -2050,6 +2063,7 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
         if (!priv->hwts_tx_en)
                 skb_tx_timestamp(skb);
 
+        netdev_sent_queue(dev, skb->len);
         priv->hw->dma->enable_dma_transmission(priv->ioaddr);
 
         spin_unlock(&priv->tx_lock);
@@ -2742,7 +2756,11 @@ static int stmmac_hw_init(struct stmmac_priv *priv)
                 priv->plat->enh_desc = priv->dma_cap.enh_desc;
                 priv->plat->pmt = priv->dma_cap.pmt_remote_wake_up;
 
-                priv->plat->tx_coe = priv->dma_cap.tx_coe;
+                /* TXCOE doesn't work in thresh DMA mode */
+                if (priv->plat->force_thresh_dma_mode)
+                        priv->plat->tx_coe = 0;
+                else
+                        priv->plat->tx_coe = priv->dma_cap.tx_coe;
 
                 if (priv->dma_cap.rx_coe_type2)
                         priv->plat->rx_coe = STMMAC_RX_COE_TYPE2;
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
index 054520d67de4..3bca908716e2 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
@@ -24,8 +24,50 @@
 *******************************************************************************/
 
 #include <linux/pci.h>
+#include <linux/dmi.h>
+
 #include "stmmac.h"
 
+/*
+ * This struct is used to associate PCI Function of MAC controller on a board,
+ * discovered via DMI, with the address of PHY connected to the MAC. The
+ * negative value of the address means that MAC controller is not connected
+ * with PHY.
+ */
+struct stmmac_pci_dmi_data {
+        const char *name;
+        unsigned int func;
+        int phy_addr;
+};
+
+struct stmmac_pci_info {
+        struct pci_dev *pdev;
+        int (*setup)(struct plat_stmmacenet_data *plat,
+                     struct stmmac_pci_info *info);
+        struct stmmac_pci_dmi_data *dmi;
+};
+
+static int stmmac_pci_find_phy_addr(struct stmmac_pci_info *info)
+{
+        const char *name = dmi_get_system_info(DMI_BOARD_NAME);
+        unsigned int func = PCI_FUNC(info->pdev->devfn);
+        struct stmmac_pci_dmi_data *dmi;
+
+        /*
+         * Galileo boards with old firmware don't support DMI. We always return
+         * 1 here, so at least first found MAC controller would be probed.
+         */
+        if (!name)
+                return 1;
+
+        for (dmi = info->dmi; dmi->name && *dmi->name; dmi++) {
+                if (!strcmp(dmi->name, name) && dmi->func == func)
+                        return dmi->phy_addr;
+        }
+
+        return -ENODEV;
+}
+
 static void stmmac_default_data(struct plat_stmmacenet_data *plat)
 {
         plat->bus_id = 1;
@@ -48,6 +90,62 @@ static void stmmac_default_data(struct plat_stmmacenet_data *plat)
         plat->unicast_filter_entries = 1;
 }
 
+static int quark_default_data(struct plat_stmmacenet_data *plat,
+                              struct stmmac_pci_info *info)
+{
+        struct pci_dev *pdev = info->pdev;
+        int ret;
+
+        /*
+         * Refuse to load the driver and register net device if MAC controller
+         * does not connect to any PHY interface.
+         */
+        ret = stmmac_pci_find_phy_addr(info);
+        if (ret < 0)
+                return ret;
+
+        plat->bus_id = PCI_DEVID(pdev->bus->number, pdev->devfn);
+        plat->phy_addr = ret;
+        plat->interface = PHY_INTERFACE_MODE_RMII;
+        plat->clk_csr = 2;
+        plat->has_gmac = 1;
+        plat->force_sf_dma_mode = 1;
+
+        plat->mdio_bus_data->phy_reset = NULL;
+        plat->mdio_bus_data->phy_mask = 0;
+
+        plat->dma_cfg->pbl = 16;
+        plat->dma_cfg->burst_len = DMA_AXI_BLEN_256;
+        plat->dma_cfg->fixed_burst = 1;
+
+        /* Set default value for multicast hash bins */
+        plat->multicast_filter_bins = HASH_TABLE_SIZE;
+
+        /* Set default value for unicast filter entries */
+        plat->unicast_filter_entries = 1;
+
+        return 0;
+}
+
+static struct stmmac_pci_dmi_data quark_pci_dmi_data[] = {
+        {
+                .name = "Galileo",
+                .func = 6,
+                .phy_addr = 1,
+        },
+        {
+                .name = "GalileoGen2",
+                .func = 6,
+                .phy_addr = 1,
+        },
+        {}
+};
+
+static struct stmmac_pci_info quark_pci_info = {
+        .setup = quark_default_data,
+        .dmi = quark_pci_dmi_data,
+};
+
 /**
  * stmmac_pci_probe
  *
@@ -63,6 +161,7 @@ static void stmmac_default_data(struct plat_stmmacenet_data *plat)
 static int stmmac_pci_probe(struct pci_dev *pdev,
                             const struct pci_device_id *id)
 {
+        struct stmmac_pci_info *info = (struct stmmac_pci_info *)id->driver_data;
         struct plat_stmmacenet_data *plat;
         struct stmmac_priv *priv;
         int i;
@@ -103,7 +202,17 @@ static int stmmac_pci_probe(struct pci_dev *pdev,
 
         pci_set_master(pdev);
 
-        stmmac_default_data(plat);
+        if (info) {
+                info->pdev = pdev;
+                if (info->setup) {
+                        ret = info->setup(plat, info);
+                        if (ret)
+                                return ret;
+                }
+        } else
+                stmmac_default_data(plat);
+
+        pci_enable_msi(pdev);
 
         priv = stmmac_dvr_probe(&pdev->dev, plat, pcim_iomap_table(pdev)[i]);
         if (IS_ERR(priv)) {
@@ -155,11 +264,13 @@ static int stmmac_pci_resume(struct device *dev)
 static SIMPLE_DEV_PM_OPS(stmmac_pm_ops, stmmac_pci_suspend, stmmac_pci_resume);
 
 #define STMMAC_VENDOR_ID 0x700
+#define STMMAC_QUARK_ID  0x0937
 #define STMMAC_DEVICE_ID 0x1108
 
 static const struct pci_device_id stmmac_id_table[] = {
         {PCI_DEVICE(STMMAC_VENDOR_ID, STMMAC_DEVICE_ID)},
         {PCI_DEVICE(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_MAC)},
+        {PCI_VDEVICE(INTEL, STMMAC_QUARK_ID), (kernel_ulong_t)&quark_pci_info},
         {}
 };
 
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
index 3039de2465ba..fb846ebba1d9 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
@@ -33,6 +33,7 @@
 
 static const struct of_device_id stmmac_dt_ids[] = {
         /* SoC specific glue layers should come before generic bindings */
+        { .compatible = "rockchip,rk3288-gmac", .data = &rk3288_gmac_data},
         { .compatible = "amlogic,meson6-dwmac", .data = &meson6_dwmac_data},
         { .compatible = "allwinner,sun7i-a20-gmac", .data = &sun7i_gmac_data},
         { .compatible = "st,stih415-dwmac", .data = &stih4xx_dwmac_data},
@@ -234,6 +235,9 @@ static int stmmac_probe_config_dt(struct platform_device *pdev,
                         of_property_read_bool(np, "snps,fixed-burst");
                 dma_cfg->mixed_burst =
                         of_property_read_bool(np, "snps,mixed-burst");
+                of_property_read_u32(np, "snps,burst_len", &dma_cfg->burst_len);
+                if (dma_cfg->burst_len < 0 || dma_cfg->burst_len > 256)
+                        dma_cfg->burst_len = 0;
         }
         plat->force_thresh_dma_mode = of_property_read_bool(np, "snps,force_thresh_dma_mode");
         if (plat->force_thresh_dma_mode) {
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.h b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.h
index 25dd1f7ace02..093eb99e5ffd 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.h
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.h
@@ -24,5 +24,6 @@ extern const struct stmmac_of_data sun7i_gmac_data;
 extern const struct stmmac_of_data stih4xx_dwmac_data;
 extern const struct stmmac_of_data stid127_dwmac_data;
 extern const struct stmmac_of_data socfpga_gmac_data;
+extern const struct stmmac_of_data rk3288_gmac_data;
 
 #endif /* __STMMAC_PLATFORM_H__ */
diff --git a/drivers/net/ethernet/sun/niu.c b/drivers/net/ethernet/sun/niu.c
index 0c6416213837..4b51f903fb73 100644
--- a/drivers/net/ethernet/sun/niu.c
+++ b/drivers/net/ethernet/sun/niu.c
@@ -3341,8 +3341,7 @@ static int niu_rbr_add_page(struct niu *np, struct rx_ring_info *rp,
 
         niu_hash_page(rp, page, addr);
         if (rp->rbr_blocks_per_page > 1)
-                atomic_add(rp->rbr_blocks_per_page - 1,
-                           &compound_head(page)->_count);
+                atomic_add(rp->rbr_blocks_per_page - 1, &page->_count);
 
         for (i = 0; i < rp->rbr_blocks_per_page; i++) {
                 __le32 *rbr = &rp->rbr[start_index + i];
diff --git a/drivers/net/ethernet/sun/sunvnet.c b/drivers/net/ethernet/sun/sunvnet.c
index 3699b98d5b2c..2b10b85d8a08 100644
--- a/drivers/net/ethernet/sun/sunvnet.c
+++ b/drivers/net/ethernet/sun/sunvnet.c
@@ -50,6 +50,7 @@ MODULE_VERSION(DRV_MODULE_VERSION);
 #define VNET_MAX_RETRIES        10
 
 static int __vnet_tx_trigger(struct vnet_port *port, u32 start);
+static void vnet_port_reset(struct vnet_port *port);
 
 /* Ordered from largest major to lowest */
 static struct vio_version vnet_versions[] = {
@@ -351,10 +352,15 @@ static int vnet_rx_one(struct vnet_port *port, struct vio_net_desc *desc)
         unsigned int len = desc->size;
         unsigned int copy_len;
         struct sk_buff *skb;
+        int maxlen;
         int err;
 
         err = -EMSGSIZE;
-        if (unlikely(len < ETH_ZLEN || len > port->rmtu)) {
+        if (port->tso && port->tsolen > port->rmtu)
+                maxlen = port->tsolen;
+        else
+                maxlen = port->rmtu;
+        if (unlikely(len < ETH_ZLEN || len > maxlen)) {
                 dev->stats.rx_length_errors++;
                 goto out_dropped;
         }
@@ -731,9 +737,7 @@ ldc_ctrl:
                 vio_link_state_change(vio, event);
 
                 if (event == LDC_EVENT_RESET) {
-                        port->rmtu = 0;
-                        port->tso = true;
-                        port->tsolen = 0;
+                        vnet_port_reset(port);
                         vio_port_up(vio);
                 }
                 port->rx_event = 0;
@@ -929,36 +933,36 @@ static struct sk_buff *vnet_clean_tx_ring(struct vnet_port *port,
 
         *pending = 0;
 
-        txi = dr->prod-1;
-        if (txi < 0)
-                txi = VNET_TX_RING_SIZE-1;
-
+        txi = dr->prod;
         for (i = 0; i < VNET_TX_RING_SIZE; ++i) {
                 struct vio_net_desc *d;
 
-                d = vio_dring_entry(dr, txi);
-
-                if (d->hdr.state == VIO_DESC_DONE) {
-                        if (port->tx_bufs[txi].skb) {
-                                BUG_ON(port->tx_bufs[txi].skb->next);
+                --txi;
+                if (txi < 0)
+                        txi = VNET_TX_RING_SIZE-1;
 
-                                port->tx_bufs[txi].skb->next = skb;
-                                skb = port->tx_bufs[txi].skb;
-                                port->tx_bufs[txi].skb = NULL;
+                d = vio_dring_entry(dr, txi);
 
-                                ldc_unmap(port->vio.lp,
-                                          port->tx_bufs[txi].cookies,
-                                          port->tx_bufs[txi].ncookies);
-                        }
-                        d->hdr.state = VIO_DESC_FREE;
-                } else if (d->hdr.state == VIO_DESC_READY) {
+                if (d->hdr.state == VIO_DESC_READY) {
                         (*pending)++;
-                } else if (d->hdr.state == VIO_DESC_FREE) {
-                        break;
+                        continue;
                 }
-                --txi;
-                if (txi < 0)
-                        txi = VNET_TX_RING_SIZE-1;
+                if (port->tx_bufs[txi].skb) {
+                        if (d->hdr.state != VIO_DESC_DONE)
+                                pr_notice("invalid ring buffer state %d\n",
+                                          d->hdr.state);
+                        BUG_ON(port->tx_bufs[txi].skb->next);
+
+                        port->tx_bufs[txi].skb->next = skb;
+                        skb = port->tx_bufs[txi].skb;
+                        port->tx_bufs[txi].skb = NULL;
+
+                        ldc_unmap(port->vio.lp,
+                                  port->tx_bufs[txi].cookies,
+                                  port->tx_bufs[txi].ncookies);
+                } else if (d->hdr.state == VIO_DESC_FREE)
+                        break;
+                d->hdr.state = VIO_DESC_FREE;
         }
         return skb;
 }
@@ -1633,16 +1637,9 @@ static void vnet_port_free_tx_bufs(struct vnet_port *port)
         int i;
 
         dr = &port->vio.drings[VIO_DRIVER_TX_RING];
-        if (dr->base) {
-                ldc_free_exp_dring(port->vio.lp, dr->base,
-                                   (dr->entry_size * dr->num_entries),
-                                   dr->cookies, dr->ncookies);
-                dr->base = NULL;
-                dr->entry_size = 0;
-                dr->num_entries = 0;
-                dr->pending = 0;
-                dr->ncookies = 0;
-        }
+
+        if (dr->base == NULL)
+                return;
 
         for (i = 0; i < VNET_TX_RING_SIZE; i++) {
                 struct vio_net_desc *d;
@@ -1652,8 +1649,6 @@ static void vnet_port_free_tx_bufs(struct vnet_port *port)
                         continue;
 
                 d = vio_dring_entry(dr, i);
-                if (d->hdr.state == VIO_DESC_READY)
-                        pr_warn("active transmit buffers freed\n");
 
                 ldc_unmap(port->vio.lp,
                           port->tx_bufs[i].cookies,
@@ -1662,6 +1657,23 @@ static void vnet_port_free_tx_bufs(struct vnet_port *port)
                 port->tx_bufs[i].skb = NULL;
                 d->hdr.state = VIO_DESC_FREE;
         }
+        ldc_free_exp_dring(port->vio.lp, dr->base,
+                           (dr->entry_size * dr->num_entries),
+                           dr->cookies, dr->ncookies);
+        dr->base = NULL;
+        dr->entry_size = 0;
+        dr->num_entries = 0;
+        dr->pending = 0;
+        dr->ncookies = 0;
+}
+
+static void vnet_port_reset(struct vnet_port *port)
+{
+        del_timer(&port->clean_timer);
+        vnet_port_free_tx_bufs(port);
+        port->rmtu = 0;
+        port->tso = true;
+        port->tsolen = 0;
 }
 
 static int vnet_port_alloc_tx_ring(struct vnet_port *port)
diff --git a/drivers/net/ethernet/tehuti/tehuti.c b/drivers/net/ethernet/tehuti/tehuti.c
index 6ab36d9ff2ab..a9cac8413e49 100644
--- a/drivers/net/ethernet/tehuti/tehuti.c
+++ b/drivers/net/ethernet/tehuti/tehuti.c
@@ -1650,9 +1650,9 @@ static netdev_tx_t bdx_tx_transmit(struct sk_buff *skb,
                     txd_mss);
         }
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 /*Cut VLAN ID to 12 bits */
-                txd_vlan_id = vlan_tx_tag_get(skb) & BITS_MASK(12);
+                txd_vlan_id = skb_vlan_tag_get(skb) & BITS_MASK(12);
                 txd_vtag = 1;
         }
 
diff --git a/drivers/net/ethernet/ti/Kconfig b/drivers/net/ethernet/ti/Kconfig
index 605dd909bcc3..3bc992cd70b7 100644
--- a/drivers/net/ethernet/ti/Kconfig
+++ b/drivers/net/ethernet/ti/Kconfig
@@ -56,12 +56,18 @@ config TI_CPSW_PHY_SEL
           This driver supports configuring of the phy mode connected to
           the CPSW.
 
+config TI_CPSW_ALE
+        tristate "TI CPSW ALE Support"
+        ---help---
+          This driver supports TI's CPSW ALE module.
+
 config TI_CPSW
         tristate "TI CPSW Switch Support"
         depends on ARCH_DAVINCI || ARCH_OMAP2PLUS
         select TI_DAVINCI_CPDMA
         select TI_DAVINCI_MDIO
         select TI_CPSW_PHY_SEL
+        select TI_CPSW_ALE
         select MFD_SYSCON
         select REGMAP
         ---help---
@@ -79,6 +85,25 @@ config TI_CPTS
           the CPSW Ethernet Switch. The unit can time stamp PTP UDP/IPv4
           and Layer 2 packets, and the driver offers a PTP Hardware Clock.
 
+config TI_KEYSTONE_NETCP
+        tristate "TI Keystone NETCP Core Support"
+        select TI_CPSW_ALE
+        depends on OF
+        depends on KEYSTONE_NAVIGATOR_DMA && KEYSTONE_NAVIGATOR_QMSS
+        ---help---
+          This driver supports TI's Keystone NETCP Core.
+
+          To compile this driver as a module, choose M here: the module
+          will be called keystone_netcp.
+
+config TI_KEYSTONE_NETCP_ETHSS
+        depends on TI_KEYSTONE_NETCP
+        tristate "TI Keystone NETCP Ethernet subsystem Support"
+        ---help---
+
+          To compile this driver as a module, choose M here: the module
+          will be called keystone_netcp_ethss.
+
 config TLAN
         tristate "TI ThunderLAN support"
         depends on (PCI || EISA)
diff --git a/drivers/net/ethernet/ti/Makefile b/drivers/net/ethernet/ti/Makefile
index 9cfaab8152be..d420d9413e4a 100644
--- a/drivers/net/ethernet/ti/Makefile
+++ b/drivers/net/ethernet/ti/Makefile
@@ -2,11 +2,20 @@
 # Makefile for the TI network device drivers.
 #
 
+obj-$(CONFIG_TI_CPSW) += cpsw-common.o
+obj-$(CONFIG_TI_DAVINCI_EMAC) += cpsw-common.o
+
 obj-$(CONFIG_TLAN) += tlan.o
 obj-$(CONFIG_CPMAC) += cpmac.o
 obj-$(CONFIG_TI_DAVINCI_EMAC) += davinci_emac.o
 obj-$(CONFIG_TI_DAVINCI_MDIO) += davinci_mdio.o
 obj-$(CONFIG_TI_DAVINCI_CPDMA) += davinci_cpdma.o
 obj-$(CONFIG_TI_CPSW_PHY_SEL) += cpsw-phy-sel.o
+obj-$(CONFIG_TI_CPSW_ALE) += cpsw_ale.o
 obj-$(CONFIG_TI_CPSW) += ti_cpsw.o
-ti_cpsw-y := cpsw_ale.o cpsw.o cpts.o
+ti_cpsw-y := cpsw.o cpts.o
+
+obj-$(CONFIG_TI_KEYSTONE_NETCP) += keystone_netcp.o
+keystone_netcp-y := netcp_core.o
+obj-$(CONFIG_TI_KEYSTONE_NETCP_ETHSS) += keystone_netcp_ethss.o
+keystone_netcp_ethss-y := netcp_ethss.o netcp_sgmii.o netcp_xgbepcsr.o
diff --git a/drivers/net/ethernet/ti/cpsw-common.c b/drivers/net/ethernet/ti/cpsw-common.c
new file mode 100644
index 000000000000..f59509486113
--- /dev/null
+++ b/drivers/net/ethernet/ti/cpsw-common.c
@@ -0,0 +1,55 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/regmap.h>
+#include <linux/mfd/syscon.h>
+
+#include "cpsw.h"
+
+#define AM33XX_CTRL_MAC_LO_REG(offset, id) ((offset) + 0x8 * (id))
+#define AM33XX_CTRL_MAC_HI_REG(offset, id) ((offset) + 0x8 * (id) + 0x4)
+
+int cpsw_am33xx_cm_get_macid(struct device *dev, u16 offset, int slave,
+                             u8 *mac_addr)
+{
+        u32 macid_lo;
+        u32 macid_hi;
+        struct regmap *syscon;
+
+        syscon = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon");
+        if (IS_ERR(syscon)) {
+                if (PTR_ERR(syscon) == -ENODEV)
+                        return 0;
+                return PTR_ERR(syscon);
+        }
+
+        regmap_read(syscon, AM33XX_CTRL_MAC_LO_REG(offset, slave),
+                    &macid_lo);
+        regmap_read(syscon, AM33XX_CTRL_MAC_HI_REG(offset, slave),
+                    &macid_hi);
+
+        mac_addr[5] = (macid_lo >> 8) & 0xff;
+        mac_addr[4] = macid_lo & 0xff;
+        mac_addr[3] = (macid_hi >> 24) & 0xff;
+        mac_addr[2] = (macid_hi >> 16) & 0xff;
+        mac_addr[1] = (macid_hi >> 8) & 0xff;
+        mac_addr[0] = macid_hi & 0xff;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cpsw_am33xx_cm_get_macid);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/ethernet/ti/cpsw.c b/drivers/net/ethernet/ti/cpsw.c
index a39131f494ec..7d8dd0d2182e 100644
--- a/drivers/net/ethernet/ti/cpsw.c
+++ b/drivers/net/ethernet/ti/cpsw.c
@@ -33,8 +33,6 @@
 #include <linux/of_net.h>
 #include <linux/of_device.h>
 #include <linux/if_vlan.h>
-#include <linux/mfd/syscon.h>
-#include <linux/regmap.h>
 
 #include <linux/pinctrl/consumer.h>
 
@@ -761,17 +759,25 @@ requeue:
                 dev_kfree_skb_any(new_skb);
 }
 
-static irqreturn_t cpsw_interrupt(int irq, void *dev_id)
+static irqreturn_t cpsw_tx_interrupt(int irq, void *dev_id)
 {
         struct cpsw_priv *priv = dev_id;
-        int value = irq - priv->irqs_table[0];
 
-        /* NOTICE: Ending IRQ here. The trick with the 'value' variable above
-         * is to make sure we will always write the correct value to the EOI
-         * register. Namely 0 for RX_THRESH Interrupt, 1 for RX Interrupt, 2
-         * for TX Interrupt and 3 for MISC Interrupt.
-         */
-        cpdma_ctlr_eoi(priv->dma, value);
+        cpdma_ctlr_eoi(priv->dma, CPDMA_EOI_TX);
+        cpdma_chan_process(priv->txch, 128);
+
+        priv = cpsw_get_slave_priv(priv, 1);
+        if (priv)
+                cpdma_chan_process(priv->txch, 128);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t cpsw_rx_interrupt(int irq, void *dev_id)
+{
+        struct cpsw_priv *priv = dev_id;
+
+        cpdma_ctlr_eoi(priv->dma, CPDMA_EOI_RX);
 
         cpsw_intr_disable(priv);
         if (priv->irq_enabled == true) {
@@ -1624,7 +1630,8 @@ static void cpsw_ndo_poll_controller(struct net_device *ndev)
 
         cpsw_intr_disable(priv);
         cpdma_ctlr_int_ctrl(priv->dma, false);
-        cpsw_interrupt(ndev->irq, priv);
+        cpsw_rx_interrupt(priv->irqs_table[0], priv);
+        cpsw_tx_interrupt(priv->irqs_table[1], priv);
         cpdma_ctlr_int_ctrl(priv->dma, true);
         cpsw_intr_enable(priv);
 }
@@ -1927,36 +1934,6 @@ static void cpsw_slave_init(struct cpsw_slave *slave, struct cpsw_priv *priv,
         slave->port_vlan = data->dual_emac_res_vlan;
 }
 
-#define AM33XX_CTRL_MAC_LO_REG(id) (0x630 + 0x8 * id)
-#define AM33XX_CTRL_MAC_HI_REG(id) (0x630 + 0x8 * id + 0x4)
-
-static int cpsw_am33xx_cm_get_macid(struct device *dev, int slave,
-                u8 *mac_addr)
-{
-        u32 macid_lo;
-        u32 macid_hi;
-        struct regmap *syscon;
-
-        syscon = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon");
-        if (IS_ERR(syscon)) {
-                if (PTR_ERR(syscon) == -ENODEV)
-                        return 0;
-                return PTR_ERR(syscon);
-        }
-
-        regmap_read(syscon, AM33XX_CTRL_MAC_LO_REG(slave), &macid_lo);
-        regmap_read(syscon, AM33XX_CTRL_MAC_HI_REG(slave), &macid_hi);
-
-        mac_addr[5] = (macid_lo >> 8) & 0xff;
-        mac_addr[4] = macid_lo & 0xff;
-        mac_addr[3] = (macid_hi >> 24) & 0xff;
-        mac_addr[2] = (macid_hi >> 16) & 0xff;
-        mac_addr[1] = (macid_hi >> 8) & 0xff;
-        mac_addr[0] = macid_hi & 0xff;
-
-        return 0;
-}
-
 static int cpsw_probe_dt(struct cpsw_platform_data *data,
                          struct platform_device *pdev)
 {
@@ -2081,7 +2058,8 @@ no_phy_slave:
                         memcpy(slave_data->mac_addr, mac_addr, ETH_ALEN);
                 } else {
                         if (of_machine_is_compatible("ti,am33xx")) {
-                                ret = cpsw_am33xx_cm_get_macid(&pdev->dev, i,
+                                ret = cpsw_am33xx_cm_get_macid(&pdev->dev,
+                                                        0x630, i,
                                                         slave_data->mac_addr);
                                 if (ret)
                                         return ret;
@@ -2192,7 +2170,8 @@ static int cpsw_probe(struct platform_device *pdev)
         void __iomem                    *ss_regs;
         struct resource                 *res, *ss_res;
         u32 slave_offset, sliver_offset, slave_size;
-        int ret = 0, i, k = 0;
+        int ret = 0, i;
+        int irq;
 
         ndev = alloc_etherdev(sizeof(struct cpsw_priv));
         if (!ndev) {
@@ -2374,31 +2353,47 @@ static int cpsw_probe(struct platform_device *pdev)
                 goto clean_dma_ret;
         }
 
-        ndev->irq = platform_get_irq(pdev, 0);
+        ndev->irq = platform_get_irq(pdev, 1);
         if (ndev->irq < 0) {
                 dev_err(priv->dev, "error getting irq resource\n");
                 ret = -ENOENT;
                 goto clean_ale_ret;
         }
 
-        while ((res = platform_get_resource(priv->pdev, IORESOURCE_IRQ, k))) {
-                if (k >= ARRAY_SIZE(priv->irqs_table)) {
-                        ret = -EINVAL;
-                        goto clean_ale_ret;
-                }
+        /* Grab RX and TX IRQs. Note that we also have RX_THRESHOLD and
+         * MISC IRQs which are always kept disabled with this driver so
+         * we will not request them.
+         *
+         * If anyone wants to implement support for those, make sure to
+         * first request and append them to irqs_table array.
+         */
 
-                ret = devm_request_irq(&pdev->dev, res->start, cpsw_interrupt,
-                                       0, dev_name(&pdev->dev), priv);
-                if (ret < 0) {
-                        dev_err(priv->dev, "error attaching irq (%d)\n", ret);
-                        goto clean_ale_ret;
-                }
+        /* RX IRQ */
+        irq = platform_get_irq(pdev, 1);
+        if (irq < 0)
+                goto clean_ale_ret;
 
-                priv->irqs_table[k] = res->start;
-                k++;
+        priv->irqs_table[0] = irq;
+        ret = devm_request_irq(&pdev->dev, irq, cpsw_rx_interrupt,
+                               0, dev_name(&pdev->dev), priv);
+        if (ret < 0) {
+                dev_err(priv->dev, "error attaching irq (%d)\n", ret);
+                goto clean_ale_ret;
         }
 
-        priv->num_irqs = k;
+        /* TX IRQ */
+        irq = platform_get_irq(pdev, 2);
+        if (irq < 0)
+                goto clean_ale_ret;
+
+        priv->irqs_table[1] = irq;
+        ret = devm_request_irq(&pdev->dev, irq, cpsw_tx_interrupt,
+                               0, dev_name(&pdev->dev), priv);
+        if (ret < 0) {
+                dev_err(priv->dev, "error attaching irq (%d)\n", ret);
+                goto clean_ale_ret;
+        }
+        priv->num_irqs = 2;
 
         ndev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
 
diff --git a/drivers/net/ethernet/ti/cpsw.h b/drivers/net/ethernet/ti/cpsw.h
index 1b710674630c..ca90efafd156 100644
--- a/drivers/net/ethernet/ti/cpsw.h
+++ b/drivers/net/ethernet/ti/cpsw.h
@@ -41,5 +41,7 @@ struct cpsw_platform_data {
 };
 
 void cpsw_phy_sel(struct device *dev, phy_interface_t phy_mode, int slave);
+int cpsw_am33xx_cm_get_macid(struct device *dev, u16 offset, int slave,
+                             u8 *mac_addr);
 
 #endif /* __CPSW_H__ */
diff --git a/drivers/net/ethernet/ti/cpsw_ale.c b/drivers/net/ethernet/ti/cpsw_ale.c
index 5246b3a18ff8..6e927b4583aa 100644
--- a/drivers/net/ethernet/ti/cpsw_ale.c
+++ b/drivers/net/ethernet/ti/cpsw_ale.c
@@ -13,6 +13,7 @@
  * GNU General Public License for more details.
  */
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
@@ -146,7 +147,7 @@ static int cpsw_ale_write(struct cpsw_ale *ale, int idx, u32 *ale_entry)
         return idx;
 }
 
-int cpsw_ale_match_addr(struct cpsw_ale *ale, u8 *addr, u16 vid)
+static int cpsw_ale_match_addr(struct cpsw_ale *ale, u8 *addr, u16 vid)
 {
         u32 ale_entry[ALE_ENTRY_WORDS];
         int type, idx;
@@ -167,7 +168,7 @@ int cpsw_ale_match_addr(struct cpsw_ale *ale, u8 *addr, u16 vid)
         return -ENOENT;
 }
 
-int cpsw_ale_match_vlan(struct cpsw_ale *ale, u16 vid)
+static int cpsw_ale_match_vlan(struct cpsw_ale *ale, u16 vid)
 {
         u32 ale_entry[ALE_ENTRY_WORDS];
         int type, idx;
@@ -265,6 +266,7 @@ int cpsw_ale_flush_multicast(struct cpsw_ale *ale, int port_mask, int vid)
         }
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_flush_multicast);
 
 static void cpsw_ale_flush_ucast(struct cpsw_ale *ale, u32 *ale_entry,
                                  int port_mask)
@@ -297,6 +299,7 @@ int cpsw_ale_flush(struct cpsw_ale *ale, int port_mask)
         }
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_flush);
 
 static inline void cpsw_ale_set_vlan_entry_type(u32 *ale_entry,
                                                 int flags, u16 vid)
@@ -334,6 +337,7 @@ int cpsw_ale_add_ucast(struct cpsw_ale *ale, u8 *addr, int port,
         cpsw_ale_write(ale, idx, ale_entry);
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_add_ucast);
 
 int cpsw_ale_del_ucast(struct cpsw_ale *ale, u8 *addr, int port,
                        int flags, u16 vid)
@@ -349,6 +353,7 @@ int cpsw_ale_del_ucast(struct cpsw_ale *ale, u8 *addr, int port,
         cpsw_ale_write(ale, idx, ale_entry);
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_del_ucast);
 
 int cpsw_ale_add_mcast(struct cpsw_ale *ale, u8 *addr, int port_mask,
                        int flags, u16 vid, int mcast_state)
@@ -380,6 +385,7 @@ int cpsw_ale_add_mcast(struct cpsw_ale *ale, u8 *addr, int port_mask,
         cpsw_ale_write(ale, idx, ale_entry);
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_add_mcast);
 
 int cpsw_ale_del_mcast(struct cpsw_ale *ale, u8 *addr, int port_mask,
                        int flags, u16 vid)
@@ -401,6 +407,7 @@ int cpsw_ale_del_mcast(struct cpsw_ale *ale, u8 *addr, int port_mask,
         cpsw_ale_write(ale, idx, ale_entry);
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_del_mcast);
 
 int cpsw_ale_add_vlan(struct cpsw_ale *ale, u16 vid, int port, int untag,
                       int reg_mcast, int unreg_mcast)
@@ -430,6 +437,7 @@ int cpsw_ale_add_vlan(struct cpsw_ale *ale, u16 vid, int port, int untag,
         cpsw_ale_write(ale, idx, ale_entry);
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_add_vlan);
 
 int cpsw_ale_del_vlan(struct cpsw_ale *ale, u16 vid, int port_mask)
 {
@@ -450,6 +458,7 @@ int cpsw_ale_del_vlan(struct cpsw_ale *ale, u16 vid, int port_mask)
         cpsw_ale_write(ale, idx, ale_entry);
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_del_vlan);
 
 void cpsw_ale_set_allmulti(struct cpsw_ale *ale, int allmulti)
 {
@@ -479,6 +488,7 @@ void cpsw_ale_set_allmulti(struct cpsw_ale *ale, int allmulti)
                 cpsw_ale_write(ale, idx, ale_entry);
         }
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_set_allmulti);
 
 struct ale_control_info {
         const char      *name;
@@ -704,6 +714,7 @@ int cpsw_ale_control_set(struct cpsw_ale *ale, int port, int control,
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_control_set);
 
 int cpsw_ale_control_get(struct cpsw_ale *ale, int port, int control)
 {
@@ -727,6 +738,7 @@ int cpsw_ale_control_get(struct cpsw_ale *ale, int port, int control)
         tmp = __raw_readl(ale->params.ale_regs + offset) >> shift;
         return tmp & BITMASK(info->bits);
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_control_get);
 
 static void cpsw_ale_timer(unsigned long arg)
 {
@@ -750,6 +762,7 @@ int cpsw_ale_set_ageout(struct cpsw_ale *ale, int ageout)
         }
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_set_ageout);
 
 void cpsw_ale_start(struct cpsw_ale *ale)
 {
@@ -769,11 +782,13 @@ void cpsw_ale_start(struct cpsw_ale *ale)
                 add_timer(&ale->timer);
         }
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_start);
 
 void cpsw_ale_stop(struct cpsw_ale *ale)
 {
         del_timer_sync(&ale->timer);
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_stop);
 
 struct cpsw_ale *cpsw_ale_create(struct cpsw_ale_params *params)
 {
@@ -788,6 +803,7 @@ struct cpsw_ale *cpsw_ale_create(struct cpsw_ale_params *params)
 
         return ale;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_create);
 
 int cpsw_ale_destroy(struct cpsw_ale *ale)
 {
@@ -797,6 +813,7 @@ int cpsw_ale_destroy(struct cpsw_ale *ale)
         kfree(ale);
         return 0;
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_destroy);
 
 void cpsw_ale_dump(struct cpsw_ale *ale, u32 *data)
 {
@@ -807,3 +824,8 @@ void cpsw_ale_dump(struct cpsw_ale *ale, u32 *data)
                 data += ALE_ENTRY_WORDS;
         }
 }
+EXPORT_SYMBOL_GPL(cpsw_ale_dump);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("TI CPSW ALE driver");
+MODULE_AUTHOR("Texas Instruments");
diff --git a/drivers/net/ethernet/ti/cpts.c b/drivers/net/ethernet/ti/cpts.c
index 4a4388b813ac..fbe42cb107ec 100644
--- a/drivers/net/ethernet/ti/cpts.c
+++ b/drivers/net/ethernet/ti/cpts.c
@@ -157,14 +157,11 @@ static int cpts_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
 
 static int cpts_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
 {
-        s64 now;
         unsigned long flags;
         struct cpts *cpts = container_of(ptp, struct cpts, info);
 
         spin_lock_irqsave(&cpts->lock, flags);
-        now = timecounter_read(&cpts->tc);
-        now += delta;
-        timecounter_init(&cpts->tc, &cpts->cc, now);
+        timecounter_adjtime(&cpts->tc, delta);
         spin_unlock_irqrestore(&cpts->lock, flags);
 
         return 0;
diff --git a/drivers/net/ethernet/ti/cpts.h b/drivers/net/ethernet/ti/cpts.h
index 1a581ef7eee8..69a46b92c7d6 100644
--- a/drivers/net/ethernet/ti/cpts.h
+++ b/drivers/net/ethernet/ti/cpts.h
@@ -27,6 +27,7 @@
 #include <linux/list.h>
 #include <linux/ptp_clock_kernel.h>
 #include <linux/skbuff.h>
+#include <linux/timecounter.h>
 
 struct cpsw_cpts {
         u32 idver;                /* Identification and version */
diff --git a/drivers/net/ethernet/ti/davinci_emac.c b/drivers/net/ethernet/ti/davinci_emac.c
index 5fae4354722c..aeebc0a7bf47 100644
--- a/drivers/net/ethernet/ti/davinci_emac.c
+++ b/drivers/net/ethernet/ti/davinci_emac.c
@@ -52,6 +52,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/clk.h>
 #include <linux/platform_device.h>
+#include <linux/regmap.h>
 #include <linux/semaphore.h>
 #include <linux/phy.h>
 #include <linux/bitops.h>
@@ -65,10 +66,12 @@
 #include <linux/of_mdio.h>
 #include <linux/of_irq.h>
 #include <linux/of_net.h>
+#include <linux/mfd/syscon.h>
 
 #include <asm/irq.h>
 #include <asm/page.h>
 
+#include "cpsw.h"
 #include "davinci_cpdma.h"
 
 static int debug_level;
@@ -1838,7 +1841,7 @@ davinci_emac_of_get_pdata(struct platform_device *pdev, struct emac_priv *priv)
         if (!is_valid_ether_addr(pdata->mac_addr)) {
                 mac_addr = of_get_mac_address(np);
                 if (mac_addr)
-                        memcpy(pdata->mac_addr, mac_addr, ETH_ALEN);
+                        ether_addr_copy(pdata->mac_addr, mac_addr);
         }
 
         of_property_read_u32(np, "ti,davinci-ctrl-reg-offset",
@@ -1879,6 +1882,53 @@ davinci_emac_of_get_pdata(struct platform_device *pdev, struct emac_priv *priv)
         return  pdata;
 }
 
+static int davinci_emac_3517_get_macid(struct device *dev, u16 offset,
+                                       int slave, u8 *mac_addr)
+{
+        u32 macid_lsb;
+        u32 macid_msb;
+        struct regmap *syscon;
+
+        syscon = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon");
+        if (IS_ERR(syscon)) {
+                if (PTR_ERR(syscon) == -ENODEV)
+                        return 0;
+                return PTR_ERR(syscon);
+        }
+
+        regmap_read(syscon, offset, &macid_lsb);
+        regmap_read(syscon, offset + 4, &macid_msb);
+
+        mac_addr[0] = (macid_msb >> 16) & 0xff;
+        mac_addr[1] = (macid_msb >> 8)  & 0xff;
+        mac_addr[2] = macid_msb & 0xff;
+        mac_addr[3] = (macid_lsb >> 16) & 0xff;
+        mac_addr[4] = (macid_lsb >> 8)  & 0xff;
+        mac_addr[5] = macid_lsb & 0xff;
+
+        return 0;
+}
+
+static int davinci_emac_try_get_mac(struct platform_device *pdev,
+                                    int instance, u8 *mac_addr)
+{
+        int error = -EINVAL;
+
+        if (!pdev->dev.of_node)
+                return error;
+
+        if (of_device_is_compatible(pdev->dev.of_node, "ti,am3517-emac"))
+                error = davinci_emac_3517_get_macid(&pdev->dev, 0x110,
+                                                    0, mac_addr);
+        else if (of_device_is_compatible(pdev->dev.of_node,
+                                         "ti,dm816-emac"))
+                error = cpsw_am33xx_cm_get_macid(&pdev->dev, 0x30,
+                                                 instance,
+                                                 mac_addr);
+
+        return error;
+}
+
 /**
  * davinci_emac_probe - EMAC device probe
  * @pdev: The DaVinci EMAC device that we are removing
@@ -2009,6 +2059,10 @@ static int davinci_emac_probe(struct platform_device *pdev)
         }
         ndev->irq = res->start;
 
+        rc = davinci_emac_try_get_mac(pdev, res_ctrl ? 0 : 1, priv->mac_addr);
+        if (!rc)
+                ether_addr_copy(ndev->dev_addr, priv->mac_addr);
+
         if (!is_valid_ether_addr(priv->mac_addr)) {
                 /* Use random MAC if none passed */
                 eth_hw_addr_random(ndev);
diff --git a/drivers/net/ethernet/ti/netcp.h b/drivers/net/ethernet/ti/netcp.h
new file mode 100644
index 000000000000..906e9bc412f5
--- /dev/null
+++ b/drivers/net/ethernet/ti/netcp.h
@@ -0,0 +1,229 @@
+/*
+ * NetCP driver local header
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated
+ * Authors:     Sandeep Nair <sandeep_n@ti.com>
+ *              Sandeep Paulraj <s-paulraj@ti.com>
+ *              Cyril Chemparathy <cyril@ti.com>
+ *              Santosh Shilimkar <santosh.shilimkar@ti.com>
+ *              Wingman Kwok <w-kwok2@ti.com>
+ *              Murali Karicheri <m-karicheri2@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef __NETCP_H__
+#define __NETCP_H__
+
+#include <linux/netdevice.h>
+#include <linux/soc/ti/knav_dma.h>
+
+/* Maximum Ethernet frame size supported by Keystone switch */
+#define NETCP_MAX_FRAME_SIZE            9504
+
+#define SGMII_LINK_MAC_MAC_AUTONEG      0
+#define SGMII_LINK_MAC_PHY              1
+#define SGMII_LINK_MAC_MAC_FORCED       2
+#define SGMII_LINK_MAC_FIBER            3
+#define SGMII_LINK_MAC_PHY_NO_MDIO      4
+#define XGMII_LINK_MAC_PHY              10
+#define XGMII_LINK_MAC_MAC_FORCED       11
+
+struct netcp_device;
+
+struct netcp_tx_pipe {
+        struct netcp_device     *netcp_device;
+        void                    *dma_queue;
+        unsigned int            dma_queue_id;
+        u8                      dma_psflags;
+        void                    *dma_channel;
+        const char              *dma_chan_name;
+};
+
+#define ADDR_NEW                        BIT(0)
+#define ADDR_VALID                      BIT(1)
+
+enum netcp_addr_type {
+        ADDR_ANY,
+        ADDR_DEV,
+        ADDR_UCAST,
+        ADDR_MCAST,
+        ADDR_BCAST
+};
+
+struct netcp_addr {
+        struct netcp_intf       *netcp;
+        unsigned char           addr[ETH_ALEN];
+        enum netcp_addr_type    type;
+        unsigned int            flags;
+        struct list_head        node;
+};
+
+struct netcp_intf {
+        struct device           *dev;
+        struct device           *ndev_dev;
+        struct net_device       *ndev;
+        bool                    big_endian;
+        unsigned int            tx_compl_qid;
+        void                    *tx_pool;
+        struct list_head        txhook_list_head;
+        unsigned int            tx_pause_threshold;
+        void                    *tx_compl_q;
+
+        unsigned int            tx_resume_threshold;
+        void                    *rx_queue;
+        void                    *rx_pool;
+        struct list_head        rxhook_list_head;
+        unsigned int            rx_queue_id;
+        void                    *rx_fdq[KNAV_DMA_FDQ_PER_CHAN];
+        u32                     rx_buffer_sizes[KNAV_DMA_FDQ_PER_CHAN];
+        struct napi_struct      rx_napi;
+        struct napi_struct      tx_napi;
+
+        void                    *rx_channel;
+        const char              *dma_chan_name;
+        u32                     rx_pool_size;
+        u32                     rx_pool_region_id;
+        u32                     tx_pool_size;
+        u32                     tx_pool_region_id;
+        struct list_head        module_head;
+        struct list_head        interface_list;
+        struct list_head        addr_list;
+        bool                    netdev_registered;
+        bool                    primary_module_attached;
+
+        /* Lock used for protecting Rx/Tx hook list management */
+        spinlock_t              lock;
+        struct netcp_device     *netcp_device;
+        struct device_node      *node_interface;
+
+        /* DMA configuration data */
+        u32                     msg_enable;
+        u32                     rx_queue_depths[KNAV_DMA_FDQ_PER_CHAN];
+};
+
+#define NETCP_PSDATA_LEN                KNAV_DMA_NUM_PS_WORDS
+struct netcp_packet {
+        struct sk_buff          *skb;
+        u32                     *epib;
+        u32                     *psdata;
+        unsigned int            psdata_len;
+        struct netcp_intf       *netcp;
+        struct netcp_tx_pipe    *tx_pipe;
+        bool                    rxtstamp_complete;
+        void                    *ts_context;
+
+        int     (*txtstamp_complete)(void *ctx, struct netcp_packet *pkt);
+};
+
+static inline u32 *netcp_push_psdata(struct netcp_packet *p_info,
+                                     unsigned int bytes)
+{
+        u32 *buf;
+        unsigned int words;
+
+        if ((bytes & 0x03) != 0)
+                return NULL;
+        words = bytes >> 2;
+
+        if ((p_info->psdata_len + words) > NETCP_PSDATA_LEN)
+                return NULL;
+
+        p_info->psdata_len += words;
+        buf = &p_info->psdata[NETCP_PSDATA_LEN - p_info->psdata_len];
+        return buf;
+}
+
+static inline int netcp_align_psdata(struct netcp_packet *p_info,
+                                     unsigned int byte_align)
+{
+        int padding;
+
+        switch (byte_align) {
+        case 0:
+                padding = -EINVAL;
+                break;
+        case 1:
+        case 2:
+        case 4:
+                padding = 0;
+                break;
+        case 8:
+                padding = (p_info->psdata_len << 2) % 8;
+                break;
+        case 16:
+                padding = (p_info->psdata_len << 2) % 16;
+                break;
+        default:
+                padding = (p_info->psdata_len << 2) % byte_align;
+                break;
+        }
+        return padding;
+}
+
+struct netcp_module {
+        const char              *name;
+        struct module           *owner;
+        bool                    primary;
+
+        /* probe/remove: called once per NETCP instance */
+        int     (*probe)(struct netcp_device *netcp_device,
+                         struct device *device, struct device_node *node,
+                         void **inst_priv);
+        int     (*remove)(struct netcp_device *netcp_device, void *inst_priv);
+
+        /* attach/release: called once per network interface */
+        int     (*attach)(void *inst_priv, struct net_device *ndev,
+                          struct device_node *node, void **intf_priv);
+        int     (*release)(void *intf_priv);
+        int     (*open)(void *intf_priv, struct net_device *ndev);
+        int     (*close)(void *intf_priv, struct net_device *ndev);
+        int     (*add_addr)(void *intf_priv, struct netcp_addr *naddr);
+        int     (*del_addr)(void *intf_priv, struct netcp_addr *naddr);
+        int     (*add_vid)(void *intf_priv, int vid);
+        int     (*del_vid)(void *intf_priv, int vid);
+        int     (*ioctl)(void *intf_priv, struct ifreq *req, int cmd);
+
+        /* used internally */
+        struct list_head        module_list;
+        struct list_head        interface_list;
+};
+
+int netcp_register_module(struct netcp_module *module);
+void netcp_unregister_module(struct netcp_module *module);
+void *netcp_module_get_intf_data(struct netcp_module *module,
+                                 struct netcp_intf *intf);
+
+int netcp_txpipe_init(struct netcp_tx_pipe *tx_pipe,
+                      struct netcp_device *netcp_device,
+                      const char *dma_chan_name, unsigned int dma_queue_id);
+int netcp_txpipe_open(struct netcp_tx_pipe *tx_pipe);
+int netcp_txpipe_close(struct netcp_tx_pipe *tx_pipe);
+
+typedef int netcp_hook_rtn(int order, void *data, struct netcp_packet *packet);
+int netcp_register_txhook(struct netcp_intf *netcp_priv, int order,
+                          netcp_hook_rtn *hook_rtn, void *hook_data);
+int netcp_unregister_txhook(struct netcp_intf *netcp_priv, int order,
+                            netcp_hook_rtn *hook_rtn, void *hook_data);
+int netcp_register_rxhook(struct netcp_intf *netcp_priv, int order,
+                          netcp_hook_rtn *hook_rtn, void *hook_data);
+int netcp_unregister_rxhook(struct netcp_intf *netcp_priv, int order,
+                            netcp_hook_rtn *hook_rtn, void *hook_data);
+void *netcp_device_find_module(struct netcp_device *netcp_device,
+                               const char *name);
+
+/* SGMII functions */
+int netcp_sgmii_reset(void __iomem *sgmii_ofs, int port);
+int netcp_sgmii_get_port_link(void __iomem *sgmii_ofs, int port);
+int netcp_sgmii_config(void __iomem *sgmii_ofs, int port, u32 interface);
+
+/* XGBE SERDES init functions */
+int netcp_xgbe_serdes_init(void __iomem *serdes_regs, void __iomem *xgbe_regs);
+
+#endif  /* __NETCP_H__ */
diff --git a/drivers/net/ethernet/ti/netcp_core.c b/drivers/net/ethernet/ti/netcp_core.c
new file mode 100644
index 000000000000..a31a8c3c8e7c
--- /dev/null
+++ b/drivers/net/ethernet/ti/netcp_core.c
@@ -0,0 +1,2149 @@
+/*
+ * Keystone NetCP Core driver
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated
+ * Authors:     Sandeep Nair <sandeep_n@ti.com>
+ *              Sandeep Paulraj <s-paulraj@ti.com>
+ *              Cyril Chemparathy <cyril@ti.com>
+ *              Santosh Shilimkar <santosh.shilimkar@ti.com>
+ *              Murali Karicheri <m-karicheri2@ti.com>
+ *              Wingman Kwok <w-kwok2@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of_net.h>
+#include <linux/of_address.h>
+#include <linux/if_vlan.h>
+#include <linux/pm_runtime.h>
+#include <linux/platform_device.h>
+#include <linux/soc/ti/knav_qmss.h>
+#include <linux/soc/ti/knav_dma.h>
+
+#include "netcp.h"
+
+#define NETCP_SOP_OFFSET        (NET_IP_ALIGN + NET_SKB_PAD)
+#define NETCP_NAPI_WEIGHT       64
+#define NETCP_TX_TIMEOUT        (5 * HZ)
+#define NETCP_MIN_PACKET_SIZE   ETH_ZLEN
+#define NETCP_MAX_MCAST_ADDR    16
+
+#define NETCP_EFUSE_REG_INDEX   0
+
+#define NETCP_MOD_PROBE_SKIPPED 1
+#define NETCP_MOD_PROBE_FAILED  2
+
+#define NETCP_DEBUG (NETIF_MSG_HW       | NETIF_MSG_WOL         |       \
+                    NETIF_MSG_DRV       | NETIF_MSG_LINK        |       \
+                    NETIF_MSG_IFUP      | NETIF_MSG_INTR        |       \
+                    NETIF_MSG_PROBE     | NETIF_MSG_TIMER       |       \
+                    NETIF_MSG_IFDOWN    | NETIF_MSG_RX_ERR      |       \
+                    NETIF_MSG_TX_ERR    | NETIF_MSG_TX_DONE     |       \
+                    NETIF_MSG_PKTDATA   | NETIF_MSG_TX_QUEUED   |       \
+                    NETIF_MSG_RX_STATUS)
+
+#define knav_queue_get_id(q)    knav_queue_device_control(q, \
+                                KNAV_QUEUE_GET_ID, (unsigned long)NULL)
+
+#define knav_queue_enable_notify(q) knav_queue_device_control(q,        \
+                                        KNAV_QUEUE_ENABLE_NOTIFY,       \
+                                        (unsigned long)NULL)
+
+#define knav_queue_disable_notify(q) knav_queue_device_control(q,       \
+                                        KNAV_QUEUE_DISABLE_NOTIFY,      \
+                                        (unsigned long)NULL)
+
+#define knav_queue_get_count(q) knav_queue_device_control(q, \
+                                KNAV_QUEUE_GET_COUNT, (unsigned long)NULL)
+
+#define for_each_netcp_module(module)                   \
+        list_for_each_entry(module, &netcp_modules, module_list)
+
+#define for_each_netcp_device_module(netcp_device, inst_modpriv) \
+        list_for_each_entry(inst_modpriv, \
+                &((netcp_device)->modpriv_head), inst_list)
+
+#define for_each_module(netcp, intf_modpriv)                    \
+        list_for_each_entry(intf_modpriv, &netcp->module_head, intf_list)
+
+/* Module management structures */
+struct netcp_device {
+        struct list_head        device_list;
+        struct list_head        interface_head;
+        struct list_head        modpriv_head;
+        struct device           *device;
+};
+
+struct netcp_inst_modpriv {
+        struct netcp_device     *netcp_device;
+        struct netcp_module     *netcp_module;
+        struct list_head        inst_list;
+        void                    *module_priv;
+};
+
+struct netcp_intf_modpriv {
+        struct netcp_intf       *netcp_priv;
+        struct netcp_module     *netcp_module;
+        struct list_head        intf_list;
+        void                    *module_priv;
+};
+
+static LIST_HEAD(netcp_devices);
+static LIST_HEAD(netcp_modules);
+static DEFINE_MUTEX(netcp_modules_lock);
+
+static int netcp_debug_level = -1;
+module_param(netcp_debug_level, int, 0);
+MODULE_PARM_DESC(netcp_debug_level, "Netcp debug level (NETIF_MSG bits) (0=none,...,16=all)");
+
+/* Helper functions - Get/Set */
+static void get_pkt_info(u32 *buff, u32 *buff_len, u32 *ndesc,
+                         struct knav_dma_desc *desc)
+{
+        *buff_len = desc->buff_len;
+        *buff = desc->buff;
+        *ndesc = desc->next_desc;
+}
+
+static void get_pad_info(u32 *pad0, u32 *pad1, struct knav_dma_desc *desc)
+{
+        *pad0 = desc->pad[0];
+        *pad1 = desc->pad[1];
+}
+
+static void get_org_pkt_info(u32 *buff, u32 *buff_len,
+                             struct knav_dma_desc *desc)
+{
+        *buff = desc->orig_buff;
+        *buff_len = desc->orig_len;
+}
+
+static void get_words(u32 *words, int num_words, u32 *desc)
+{
+        int i;
+
+        for (i = 0; i < num_words; i++)
+                words[i] = desc[i];
+}
+
+static void set_pkt_info(u32 buff, u32 buff_len, u32 ndesc,
+                         struct knav_dma_desc *desc)
+{
+        desc->buff_len = buff_len;
+        desc->buff = buff;
+        desc->next_desc = ndesc;
+}
+
+static void set_desc_info(u32 desc_info, u32 pkt_info,
+                          struct knav_dma_desc *desc)
+{
+        desc->desc_info = desc_info;
+        desc->packet_info = pkt_info;
+}
+
+static void set_pad_info(u32 pad0, u32 pad1, struct knav_dma_desc *desc)
+{
+        desc->pad[0] = pad0;
+        desc->pad[1] = pad1;
+}
+
+static void set_org_pkt_info(u32 buff, u32 buff_len,
+                             struct knav_dma_desc *desc)
+{
+        desc->orig_buff = buff;
+        desc->orig_len = buff_len;
+}
+
+static void set_words(u32 *words, int num_words, u32 *desc)
+{
+        int i;
+
+        for (i = 0; i < num_words; i++)
+                desc[i] = words[i];
+}
+
+/* Read the e-fuse value as 32 bit values to be endian independent */
+static int emac_arch_get_mac_addr(char *x, void __iomem *efuse_mac)
+{
+        unsigned int addr0, addr1;
+
+        addr1 = readl(efuse_mac + 4);
+        addr0 = readl(efuse_mac);
+
+        x[0] = (addr1 & 0x0000ff00) >> 8;
+        x[1] = addr1 & 0x000000ff;
+        x[2] = (addr0 & 0xff000000) >> 24;
+        x[3] = (addr0 & 0x00ff0000) >> 16;
+        x[4] = (addr0 & 0x0000ff00) >> 8;
+        x[5] = addr0 & 0x000000ff;
+
+        return 0;
+}
+
+static const char *netcp_node_name(struct device_node *node)
+{
+        const char *name;
+
+        if (of_property_read_string(node, "label", &name) < 0)
+                name = node->name;
+        if (!name)
+                name = "unknown";
+        return name;
+}
+
+/* Module management routines */
+static int netcp_register_interface(struct netcp_intf *netcp)
+{
+        int ret;
+
+        ret = register_netdev(netcp->ndev);
+        if (!ret)
+                netcp->netdev_registered = true;
+        return ret;
+}
+
+static int netcp_module_probe(struct netcp_device *netcp_device,
+                              struct netcp_module *module)
+{
+        struct device *dev = netcp_device->device;
+        struct device_node *devices, *interface, *node = dev->of_node;
+        struct device_node *child;
+        struct netcp_inst_modpriv *inst_modpriv;
+        struct netcp_intf *netcp_intf;
+        struct netcp_module *tmp;
+        bool primary_module_registered = false;
+        int ret;
+
+        /* Find this module in the sub-tree for this device */
+        devices = of_get_child_by_name(node, "netcp-devices");
+        if (!devices) {
+                dev_err(dev, "could not find netcp-devices node\n");
+                return NETCP_MOD_PROBE_SKIPPED;
+        }
+
+        for_each_available_child_of_node(devices, child) {
+                const char *name = netcp_node_name(child);
+
+                if (!strcasecmp(module->name, name))
+                        break;
+        }
+
+        of_node_put(devices);
+        /* If module not used for this device, skip it */
+        if (!child) {
+                dev_warn(dev, "module(%s) not used for device\n", module->name);
+                return NETCP_MOD_PROBE_SKIPPED;
+        }
+
+        inst_modpriv = devm_kzalloc(dev, sizeof(*inst_modpriv), GFP_KERNEL);
+        if (!inst_modpriv) {
+                of_node_put(child);
+                return -ENOMEM;
+        }
+
+        inst_modpriv->netcp_device = netcp_device;
+        inst_modpriv->netcp_module = module;
+        list_add_tail(&inst_modpriv->inst_list, &netcp_device->modpriv_head);
+
+        ret = module->probe(netcp_device, dev, child,
+                            &inst_modpriv->module_priv);
+        of_node_put(child);
+        if (ret) {
+                dev_err(dev, "Probe of module(%s) failed with %d\n",
+                        module->name, ret);
+                list_del(&inst_modpriv->inst_list);
+                devm_kfree(dev, inst_modpriv);
+                return NETCP_MOD_PROBE_FAILED;
+        }
+
+        /* Attach modules only if the primary module is probed */
+        for_each_netcp_module(tmp) {
+                if (tmp->primary)
+                        primary_module_registered = true;
+        }
+
+        if (!primary_module_registered)
+                return 0;
+
+        /* Attach module to interfaces */
+        list_for_each_entry(netcp_intf, &netcp_device->interface_head,
+                            interface_list) {
+                struct netcp_intf_modpriv *intf_modpriv;
+
+                /* If interface not registered then register now */
+                if (!netcp_intf->netdev_registered)
+                        ret = netcp_register_interface(netcp_intf);
+
+                if (ret)
+                        return -ENODEV;
+
+                intf_modpriv = devm_kzalloc(dev, sizeof(*intf_modpriv),
+                                            GFP_KERNEL);
+                if (!intf_modpriv)
+                        return -ENOMEM;
+
+                interface = of_parse_phandle(netcp_intf->node_interface,
+                                             module->name, 0);
+
+                intf_modpriv->netcp_priv = netcp_intf;
+                intf_modpriv->netcp_module = module;
+                list_add_tail(&intf_modpriv->intf_list,
+                              &netcp_intf->module_head);
+
+                ret = module->attach(inst_modpriv->module_priv,
+                                     netcp_intf->ndev, interface,
+                                     &intf_modpriv->module_priv);
+                of_node_put(interface);
+                if (ret) {
+                        dev_dbg(dev, "Attach of module %s declined with %d\n",
+                                module->name, ret);
+                        list_del(&intf_modpriv->intf_list);
+                        devm_kfree(dev, intf_modpriv);
+                        continue;
+                }
+        }
+        return 0;
+}
+
+int netcp_register_module(struct netcp_module *module)
+{
+        struct netcp_device *netcp_device;
+        struct netcp_module *tmp;
+        int ret;
+
+        if (!module->name) {
+                WARN(1, "error registering netcp module: no name\n");
+                return -EINVAL;
+        }
+
+        if (!module->probe) {
+                WARN(1, "error registering netcp module: no probe\n");
+                return -EINVAL;
+        }
+
+        mutex_lock(&netcp_modules_lock);
+
+        for_each_netcp_module(tmp) {
+                if (!strcasecmp(tmp->name, module->name)) {
+                        mutex_unlock(&netcp_modules_lock);
+                        return -EEXIST;
+                }
+        }
+        list_add_tail(&module->module_list, &netcp_modules);
+
+        list_for_each_entry(netcp_device, &netcp_devices, device_list) {
+                ret = netcp_module_probe(netcp_device, module);
+                if (ret < 0)
+                        goto fail;
+        }
+
+        mutex_unlock(&netcp_modules_lock);
+        return 0;
+
+fail:
+        mutex_unlock(&netcp_modules_lock);
+        netcp_unregister_module(module);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(netcp_register_module);
+
+static void netcp_release_module(struct netcp_device *netcp_device,
+                                 struct netcp_module *module)
+{
+        struct netcp_inst_modpriv *inst_modpriv, *inst_tmp;
+        struct netcp_intf *netcp_intf, *netcp_tmp;
+        struct device *dev = netcp_device->device;
+
+        /* Release the module from each interface */
+        list_for_each_entry_safe(netcp_intf, netcp_tmp,
+                                 &netcp_device->interface_head,
+                                 interface_list) {
+                struct netcp_intf_modpriv *intf_modpriv, *intf_tmp;
+
+                list_for_each_entry_safe(intf_modpriv, intf_tmp,
+                                         &netcp_intf->module_head,
+                                         intf_list) {
+                        if (intf_modpriv->netcp_module == module) {
+                                module->release(intf_modpriv->module_priv);
+                                list_del(&intf_modpriv->intf_list);
+                                devm_kfree(dev, intf_modpriv);
+                                break;
+                        }
+                }
+        }
+
+        /* Remove the module from each instance */
+        list_for_each_entry_safe(inst_modpriv, inst_tmp,
+                                 &netcp_device->modpriv_head, inst_list) {
+                if (inst_modpriv->netcp_module == module) {
+                        module->remove(netcp_device,
+                                       inst_modpriv->module_priv);
+                        list_del(&inst_modpriv->inst_list);
+                        devm_kfree(dev, inst_modpriv);
+                        break;
+                }
+        }
+}
+
+void netcp_unregister_module(struct netcp_module *module)
+{
+        struct netcp_device *netcp_device;
+        struct netcp_module *module_tmp;
+
+        mutex_lock(&netcp_modules_lock);
+
+        list_for_each_entry(netcp_device, &netcp_devices, device_list) {
+                netcp_release_module(netcp_device, module);
+        }
+
+        /* Remove the module from the module list */
+        for_each_netcp_module(module_tmp) {
+                if (module == module_tmp) {
+                        list_del(&module->module_list);
+                        break;
+                }
+        }
+
+        mutex_unlock(&netcp_modules_lock);
+}
+EXPORT_SYMBOL_GPL(netcp_unregister_module);
+
+void *netcp_module_get_intf_data(struct netcp_module *module,
+                                 struct netcp_intf *intf)
+{
+        struct netcp_intf_modpriv *intf_modpriv;
+
+        list_for_each_entry(intf_modpriv, &intf->module_head, intf_list)
+                if (intf_modpriv->netcp_module == module)
+                        return intf_modpriv->module_priv;
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(netcp_module_get_intf_data);
+
+/* Module TX and RX Hook management */
+struct netcp_hook_list {
+        struct list_head         list;
+        netcp_hook_rtn          *hook_rtn;
+        void                    *hook_data;
+        int                      order;
+};
+
+int netcp_register_txhook(struct netcp_intf *netcp_priv, int order,
+                          netcp_hook_rtn *hook_rtn, void *hook_data)
+{
+        struct netcp_hook_list *entry;
+        struct netcp_hook_list *next;
+        unsigned long flags;
+
+        entry = devm_kzalloc(netcp_priv->dev, sizeof(*entry), GFP_KERNEL);
+        if (!entry)
+                return -ENOMEM;
+
+        entry->hook_rtn  = hook_rtn;
+        entry->hook_data = hook_data;
+        entry->order     = order;
+
+        spin_lock_irqsave(&netcp_priv->lock, flags);
+        list_for_each_entry(next, &netcp_priv->txhook_list_head, list) {
+                if (next->order > order)
+                        break;
+        }
+        __list_add(&entry->list, next->list.prev, &next->list);
+        spin_unlock_irqrestore(&netcp_priv->lock, flags);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(netcp_register_txhook);
+
+int netcp_unregister_txhook(struct netcp_intf *netcp_priv, int order,
+                            netcp_hook_rtn *hook_rtn, void *hook_data)
+{
+        struct netcp_hook_list *next, *n;
+        unsigned long flags;
+
+        spin_lock_irqsave(&netcp_priv->lock, flags);
+        list_for_each_entry_safe(next, n, &netcp_priv->txhook_list_head, list) {
+                if ((next->order     == order) &&
+                    (next->hook_rtn  == hook_rtn) &&
+                    (next->hook_data == hook_data)) {
+                        list_del(&next->list);
+                        spin_unlock_irqrestore(&netcp_priv->lock, flags);
+                        devm_kfree(netcp_priv->dev, next);
+                        return 0;
+                }
+        }
+        spin_unlock_irqrestore(&netcp_priv->lock, flags);
+        return -ENOENT;
+}
+EXPORT_SYMBOL_GPL(netcp_unregister_txhook);
+
+int netcp_register_rxhook(struct netcp_intf *netcp_priv, int order,
+                          netcp_hook_rtn *hook_rtn, void *hook_data)
+{
+        struct netcp_hook_list *entry;
+        struct netcp_hook_list *next;
+        unsigned long flags;
+
+        entry = devm_kzalloc(netcp_priv->dev, sizeof(*entry), GFP_KERNEL);
+        if (!entry)
+                return -ENOMEM;
+
+        entry->hook_rtn  = hook_rtn;
+        entry->hook_data = hook_data;
+        entry->order     = order;
+
+        spin_lock_irqsave(&netcp_priv->lock, flags);
+        list_for_each_entry(next, &netcp_priv->rxhook_list_head, list) {
+                if (next->order > order)
+                        break;
+        }
+        __list_add(&entry->list, next->list.prev, &next->list);
+        spin_unlock_irqrestore(&netcp_priv->lock, flags);
+
+        return 0;
+}
+
+int netcp_unregister_rxhook(struct netcp_intf *netcp_priv, int order,
+                            netcp_hook_rtn *hook_rtn, void *hook_data)
+{
+        struct netcp_hook_list *next, *n;
+        unsigned long flags;
+
+        spin_lock_irqsave(&netcp_priv->lock, flags);
+        list_for_each_entry_safe(next, n, &netcp_priv->rxhook_list_head, list) {
+                if ((next->order     == order) &&
+                    (next->hook_rtn  == hook_rtn) &&
+                    (next->hook_data == hook_data)) {
+                        list_del(&next->list);
+                        spin_unlock_irqrestore(&netcp_priv->lock, flags);
+                        devm_kfree(netcp_priv->dev, next);
+                        return 0;
+                }
+        }
+        spin_unlock_irqrestore(&netcp_priv->lock, flags);
+
+        return -ENOENT;
+}
+
+static void netcp_frag_free(bool is_frag, void *ptr)
+{
+        if (is_frag)
+                put_page(virt_to_head_page(ptr));
+        else
+                kfree(ptr);
+}
+
+static void netcp_free_rx_desc_chain(struct netcp_intf *netcp,
+                                     struct knav_dma_desc *desc)
+{
+        struct knav_dma_desc *ndesc;
+        dma_addr_t dma_desc, dma_buf;
+        unsigned int buf_len, dma_sz = sizeof(*ndesc);
+        void *buf_ptr;
+        u32 tmp;
+
+        get_words(&dma_desc, 1, &desc->next_desc);
+
+        while (dma_desc) {
+                ndesc = knav_pool_desc_unmap(netcp->rx_pool, dma_desc, dma_sz);
+                if (unlikely(!ndesc)) {
+                        dev_err(netcp->ndev_dev, "failed to unmap Rx desc\n");
+                        break;
+                }
+                get_pkt_info(&dma_buf, &tmp, &dma_desc, ndesc);
+                get_pad_info((u32 *)&buf_ptr, &tmp, ndesc);
+                dma_unmap_page(netcp->dev, dma_buf, PAGE_SIZE, DMA_FROM_DEVICE);
+                __free_page(buf_ptr);
+                knav_pool_desc_put(netcp->rx_pool, desc);
+        }
+
+        get_pad_info((u32 *)&buf_ptr, &buf_len, desc);
+        if (buf_ptr)
+                netcp_frag_free(buf_len <= PAGE_SIZE, buf_ptr);
+        knav_pool_desc_put(netcp->rx_pool, desc);
+}
+
+static void netcp_empty_rx_queue(struct netcp_intf *netcp)
+{
+        struct knav_dma_desc *desc;
+        unsigned int dma_sz;
+        dma_addr_t dma;
+
+        for (; ;) {
+                dma = knav_queue_pop(netcp->rx_queue, &dma_sz);
+                if (!dma)
+                        break;
+
+                desc = knav_pool_desc_unmap(netcp->rx_pool, dma, dma_sz);
+                if (unlikely(!desc)) {
+                        dev_err(netcp->ndev_dev, "%s: failed to unmap Rx desc\n",
+                                __func__);
+                        netcp->ndev->stats.rx_errors++;
+                        continue;
+                }
+                netcp_free_rx_desc_chain(netcp, desc);
+                netcp->ndev->stats.rx_dropped++;
+        }
+}
+
+static int netcp_process_one_rx_packet(struct netcp_intf *netcp)
+{
+        unsigned int dma_sz, buf_len, org_buf_len;
+        struct knav_dma_desc *desc, *ndesc;
+        unsigned int pkt_sz = 0, accum_sz;
+        struct netcp_hook_list *rx_hook;
+        dma_addr_t dma_desc, dma_buff;
+        struct netcp_packet p_info;
+        struct sk_buff *skb;
+        void *org_buf_ptr;
+        u32 tmp;
+
+        dma_desc = knav_queue_pop(netcp->rx_queue, &dma_sz);
+        if (!dma_desc)
+                return -1;
+
+        desc = knav_pool_desc_unmap(netcp->rx_pool, dma_desc, dma_sz);
+        if (unlikely(!desc)) {
+                dev_err(netcp->ndev_dev, "failed to unmap Rx desc\n");
+                return 0;
+        }
+
+        get_pkt_info(&dma_buff, &buf_len, &dma_desc, desc);
+        get_pad_info((u32 *)&org_buf_ptr, &org_buf_len, desc);
+
+        if (unlikely(!org_buf_ptr)) {
+                dev_err(netcp->ndev_dev, "NULL bufptr in desc\n");
+                goto free_desc;
+        }
+
+        pkt_sz &= KNAV_DMA_DESC_PKT_LEN_MASK;
+        accum_sz = buf_len;
+        dma_unmap_single(netcp->dev, dma_buff, buf_len, DMA_FROM_DEVICE);
+
+        /* Build a new sk_buff for the primary buffer */
+        skb = build_skb(org_buf_ptr, org_buf_len);
+        if (unlikely(!skb)) {
+                dev_err(netcp->ndev_dev, "build_skb() failed\n");
+                goto free_desc;
+        }
+
+        /* update data, tail and len */
+        skb_reserve(skb, NETCP_SOP_OFFSET);
+        __skb_put(skb, buf_len);
+
+        /* Fill in the page fragment list */
+        while (dma_desc) {
+                struct page *page;
+
+                ndesc = knav_pool_desc_unmap(netcp->rx_pool, dma_desc, dma_sz);
+                if (unlikely(!ndesc)) {
+                        dev_err(netcp->ndev_dev, "failed to unmap Rx desc\n");
+                        goto free_desc;
+                }
+
+                get_pkt_info(&dma_buff, &buf_len, &dma_desc, ndesc);
+                get_pad_info((u32 *)&page, &tmp, ndesc);
+
+                if (likely(dma_buff && buf_len && page)) {
+                        dma_unmap_page(netcp->dev, dma_buff, PAGE_SIZE,
+                                       DMA_FROM_DEVICE);
+                } else {
+                        dev_err(netcp->ndev_dev, "Bad Rx desc dma_buff(%p), len(%d), page(%p)\n",
+                                (void *)dma_buff, buf_len, page);
+                        goto free_desc;
+                }
+
+                skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page,
+                                offset_in_page(dma_buff), buf_len, PAGE_SIZE);
+                accum_sz += buf_len;
+
+                /* Free the descriptor */
+                knav_pool_desc_put(netcp->rx_pool, ndesc);
+        }
+
+        /* Free the primary descriptor */
+        knav_pool_desc_put(netcp->rx_pool, desc);
+
+        /* check for packet len and warn */
+        if (unlikely(pkt_sz != accum_sz))
+                dev_dbg(netcp->ndev_dev, "mismatch in packet size(%d) & sum of fragments(%d)\n",
+                        pkt_sz, accum_sz);
+
+        /* Remove ethernet FCS from the packet */
+        __pskb_trim(skb, skb->len - ETH_FCS_LEN);
+
+        /* Call each of the RX hooks */
+        p_info.skb = skb;
+        p_info.rxtstamp_complete = false;
+        list_for_each_entry(rx_hook, &netcp->rxhook_list_head, list) {
+                int ret;
+
+                ret = rx_hook->hook_rtn(rx_hook->order, rx_hook->hook_data,
+                                        &p_info);
+                if (unlikely(ret)) {
+                        dev_err(netcp->ndev_dev, "RX hook %d failed: %d\n",
+                                rx_hook->order, ret);
+                        netcp->ndev->stats.rx_errors++;
+                        dev_kfree_skb(skb);
+                        return 0;
+                }
+        }
+
+        netcp->ndev->last_rx = jiffies;
+        netcp->ndev->stats.rx_packets++;
+        netcp->ndev->stats.rx_bytes += skb->len;
+
+        /* push skb up the stack */
+        skb->protocol = eth_type_trans(skb, netcp->ndev);
+        netif_receive_skb(skb);
+        return 0;
+
+free_desc:
+        netcp_free_rx_desc_chain(netcp, desc);
+        netcp->ndev->stats.rx_errors++;
+        return 0;
+}
+
+static int netcp_process_rx_packets(struct netcp_intf *netcp,
+                                    unsigned int budget)
+{
+        int i;
+
+        for (i = 0; (i < budget) && !netcp_process_one_rx_packet(netcp); i++)
+                ;
+        return i;
+}
+
+/* Release descriptors and attached buffers from Rx FDQ */
+static void netcp_free_rx_buf(struct netcp_intf *netcp, int fdq)
+{
+        struct knav_dma_desc *desc;
+        unsigned int buf_len, dma_sz;
+        dma_addr_t dma;
+        void *buf_ptr;
+        u32 tmp;
+
+        /* Allocate descriptor */
+        while ((dma = knav_queue_pop(netcp->rx_fdq[fdq], &dma_sz))) {
+                desc = knav_pool_desc_unmap(netcp->rx_pool, dma, dma_sz);
+                if (unlikely(!desc)) {
+                        dev_err(netcp->ndev_dev, "failed to unmap Rx desc\n");
+                        continue;
+                }
+
+                get_org_pkt_info(&dma, &buf_len, desc);
+                get_pad_info((u32 *)&buf_ptr, &tmp, desc);
+
+                if (unlikely(!dma)) {
+                        dev_err(netcp->ndev_dev, "NULL orig_buff in desc\n");
+                        knav_pool_desc_put(netcp->rx_pool, desc);
+                        continue;
+                }
+
+                if (unlikely(!buf_ptr)) {
+                        dev_err(netcp->ndev_dev, "NULL bufptr in desc\n");
+                        knav_pool_desc_put(netcp->rx_pool, desc);
+                        continue;
+                }
+
+                if (fdq == 0) {
+                        dma_unmap_single(netcp->dev, dma, buf_len,
+                                         DMA_FROM_DEVICE);
+                        netcp_frag_free((buf_len <= PAGE_SIZE), buf_ptr);
+                } else {
+                        dma_unmap_page(netcp->dev, dma, buf_len,
+                                       DMA_FROM_DEVICE);
+                        __free_page(buf_ptr);
+                }
+
+                knav_pool_desc_put(netcp->rx_pool, desc);
+        }
+}
+
+static void netcp_rxpool_free(struct netcp_intf *netcp)
+{
+        int i;
+
+        for (i = 0; i < KNAV_DMA_FDQ_PER_CHAN &&
+             !IS_ERR_OR_NULL(netcp->rx_fdq[i]); i++)
+                netcp_free_rx_buf(netcp, i);
+
+        if (knav_pool_count(netcp->rx_pool) != netcp->rx_pool_size)
+                dev_err(netcp->ndev_dev, "Lost Rx (%d) descriptors\n",
+                        netcp->rx_pool_size - knav_pool_count(netcp->rx_pool));
+
+        knav_pool_destroy(netcp->rx_pool);
+        netcp->rx_pool = NULL;
+}
+
+static void netcp_allocate_rx_buf(struct netcp_intf *netcp, int fdq)
+{
+        struct knav_dma_desc *hwdesc;
+        unsigned int buf_len, dma_sz;
+        u32 desc_info, pkt_info;
+        struct page *page;
+        dma_addr_t dma;
+        void *bufptr;
+        u32 pad[2];
+
+        /* Allocate descriptor */
+        hwdesc = knav_pool_desc_get(netcp->rx_pool);
+        if (IS_ERR_OR_NULL(hwdesc)) {
+                dev_dbg(netcp->ndev_dev, "out of rx pool desc\n");
+                return;
+        }
+
+        if (likely(fdq == 0)) {
+                unsigned int primary_buf_len;
+                /* Allocate a primary receive queue entry */
+                buf_len = netcp->rx_buffer_sizes[0] + NETCP_SOP_OFFSET;
+                primary_buf_len = SKB_DATA_ALIGN(buf_len) +
+                                SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+
+                if (primary_buf_len <= PAGE_SIZE) {
+                        bufptr = netdev_alloc_frag(primary_buf_len);
+                        pad[1] = primary_buf_len;
+                } else {
+                        bufptr = kmalloc(primary_buf_len, GFP_ATOMIC |
+                                         GFP_DMA32 | __GFP_COLD);
+                        pad[1] = 0;
+                }
+
+                if (unlikely(!bufptr)) {
+                        dev_warn_ratelimited(netcp->ndev_dev, "Primary RX buffer alloc failed\n");
+                        goto fail;
+                }
+                dma = dma_map_single(netcp->dev, bufptr, buf_len,
+                                     DMA_TO_DEVICE);
+                pad[0] = (u32)bufptr;
+
+        } else {
+                /* Allocate a secondary receive queue entry */
+                page = alloc_page(GFP_ATOMIC | GFP_DMA32 | __GFP_COLD);
+                if (unlikely(!page)) {
+                        dev_warn_ratelimited(netcp->ndev_dev, "Secondary page alloc failed\n");
+                        goto fail;
+                }
+                buf_len = PAGE_SIZE;
+                dma = dma_map_page(netcp->dev, page, 0, buf_len, DMA_TO_DEVICE);
+                pad[0] = (u32)page;
+                pad[1] = 0;
+        }
+
+        desc_info =  KNAV_DMA_DESC_PS_INFO_IN_DESC;
+        desc_info |= buf_len & KNAV_DMA_DESC_PKT_LEN_MASK;
+        pkt_info =  KNAV_DMA_DESC_HAS_EPIB;
+        pkt_info |= KNAV_DMA_NUM_PS_WORDS << KNAV_DMA_DESC_PSLEN_SHIFT;
+        pkt_info |= (netcp->rx_queue_id & KNAV_DMA_DESC_RETQ_MASK) <<
+                    KNAV_DMA_DESC_RETQ_SHIFT;
+        set_org_pkt_info(dma, buf_len, hwdesc);
+        set_pad_info(pad[0], pad[1], hwdesc);
+        set_desc_info(desc_info, pkt_info, hwdesc);
+
+        /* Push to FDQs */
+        knav_pool_desc_map(netcp->rx_pool, hwdesc, sizeof(*hwdesc), &dma,
+                           &dma_sz);
+        knav_queue_push(netcp->rx_fdq[fdq], dma, sizeof(*hwdesc), 0);
+        return;
+
+fail:
+        knav_pool_desc_put(netcp->rx_pool, hwdesc);
+}
+
+/* Refill Rx FDQ with descriptors & attached buffers */
+static void netcp_rxpool_refill(struct netcp_intf *netcp)
+{
+        u32 fdq_deficit[KNAV_DMA_FDQ_PER_CHAN] = {0};
+        int i;
+
+        /* Calculate the FDQ deficit and refill */
+        for (i = 0; i < KNAV_DMA_FDQ_PER_CHAN && netcp->rx_fdq[i]; i++) {
+                fdq_deficit[i] = netcp->rx_queue_depths[i] -
+                                 knav_queue_get_count(netcp->rx_fdq[i]);
+
+                while (fdq_deficit[i]--)
+                        netcp_allocate_rx_buf(netcp, i);
+        } /* end for fdqs */
+}
+
+/* NAPI poll */
+static int netcp_rx_poll(struct napi_struct *napi, int budget)
+{
+        struct netcp_intf *netcp = container_of(napi, struct netcp_intf,
+                                                rx_napi);
+        unsigned int packets;
+
+        packets = netcp_process_rx_packets(netcp, budget);
+
+        if (packets < budget) {
+                napi_complete(&netcp->rx_napi);
+                knav_queue_enable_notify(netcp->rx_queue);
+        }
+
+        netcp_rxpool_refill(netcp);
+        return packets;
+}
+
+static void netcp_rx_notify(void *arg)
+{
+        struct netcp_intf *netcp = arg;
+
+        knav_queue_disable_notify(netcp->rx_queue);
+        napi_schedule(&netcp->rx_napi);
+}
+
+static void netcp_free_tx_desc_chain(struct netcp_intf *netcp,
+                                     struct knav_dma_desc *desc,
+                                     unsigned int desc_sz)
+{
+        struct knav_dma_desc *ndesc = desc;
+        dma_addr_t dma_desc, dma_buf;
+        unsigned int buf_len;
+
+        while (ndesc) {
+                get_pkt_info(&dma_buf, &buf_len, &dma_desc, ndesc);
+
+                if (dma_buf && buf_len)
+                        dma_unmap_single(netcp->dev, dma_buf, buf_len,
+                                         DMA_TO_DEVICE);
+                else
+                        dev_warn(netcp->ndev_dev, "bad Tx desc buf(%p), len(%d)\n",
+                                 (void *)dma_buf, buf_len);
+
+                knav_pool_desc_put(netcp->tx_pool, ndesc);
+                ndesc = NULL;
+                if (dma_desc) {
+                        ndesc = knav_pool_desc_unmap(netcp->tx_pool, dma_desc,
+                                                     desc_sz);
+                        if (!ndesc)
+                                dev_err(netcp->ndev_dev, "failed to unmap Tx desc\n");
+                }
+        }
+}
+
+static int netcp_process_tx_compl_packets(struct netcp_intf *netcp,
+                                          unsigned int budget)
+{
+        struct knav_dma_desc *desc;
+        struct sk_buff *skb;
+        unsigned int dma_sz;
+        dma_addr_t dma;
+        int pkts = 0;
+        u32 tmp;
+
+        while (budget--) {
+                dma = knav_queue_pop(netcp->tx_compl_q, &dma_sz);
+                if (!dma)
+                        break;
+                desc = knav_pool_desc_unmap(netcp->tx_pool, dma, dma_sz);
+                if (unlikely(!desc)) {
+                        dev_err(netcp->ndev_dev, "failed to unmap Tx desc\n");
+                        netcp->ndev->stats.tx_errors++;
+                        continue;
+                }
+
+                get_pad_info((u32 *)&skb, &tmp, desc);
+                netcp_free_tx_desc_chain(netcp, desc, dma_sz);
+                if (!skb) {
+                        dev_err(netcp->ndev_dev, "No skb in Tx desc\n");
+                        netcp->ndev->stats.tx_errors++;
+                        continue;
+                }
+
+                if (netif_subqueue_stopped(netcp->ndev, skb) &&
+                    netif_running(netcp->ndev) &&
+                    (knav_pool_count(netcp->tx_pool) >
+                    netcp->tx_resume_threshold)) {
+                        u16 subqueue = skb_get_queue_mapping(skb);
+
+                        netif_wake_subqueue(netcp->ndev, subqueue);
+                }
+
+                netcp->ndev->stats.tx_packets++;
+                netcp->ndev->stats.tx_bytes += skb->len;
+                dev_kfree_skb(skb);
+                pkts++;
+        }
+        return pkts;
+}
+
+static int netcp_tx_poll(struct napi_struct *napi, int budget)
+{
+        int packets;
+        struct netcp_intf *netcp = container_of(napi, struct netcp_intf,
+                                                tx_napi);
+
+        packets = netcp_process_tx_compl_packets(netcp, budget);
+        if (packets < budget) {
+                napi_complete(&netcp->tx_napi);
+                knav_queue_enable_notify(netcp->tx_compl_q);
+        }
+
+        return packets;
+}
+
+static void netcp_tx_notify(void *arg)
+{
+        struct netcp_intf *netcp = arg;
+
+        knav_queue_disable_notify(netcp->tx_compl_q);
+        napi_schedule(&netcp->tx_napi);
+}
+
+static struct knav_dma_desc*
+netcp_tx_map_skb(struct sk_buff *skb, struct netcp_intf *netcp)
+{
+        struct knav_dma_desc *desc, *ndesc, *pdesc;
+        unsigned int pkt_len = skb_headlen(skb);
+        struct device *dev = netcp->dev;
+        dma_addr_t dma_addr;
+        unsigned int dma_sz;
+        int i;
+
+        /* Map the linear buffer */
+        dma_addr = dma_map_single(dev, skb->data, pkt_len, DMA_TO_DEVICE);
+        if (unlikely(!dma_addr)) {
+                dev_err(netcp->ndev_dev, "Failed to map skb buffer\n");
+                return NULL;
+        }
+
+        desc = knav_pool_desc_get(netcp->tx_pool);
+        if (unlikely(IS_ERR_OR_NULL(desc))) {
+                dev_err(netcp->ndev_dev, "out of TX desc\n");
+                dma_unmap_single(dev, dma_addr, pkt_len, DMA_TO_DEVICE);
+                return NULL;
+        }
+
+        set_pkt_info(dma_addr, pkt_len, 0, desc);
+        if (skb_is_nonlinear(skb)) {
+                prefetchw(skb_shinfo(skb));
+        } else {
+                desc->next_desc = 0;
+                goto upd_pkt_len;
+        }
+
+        pdesc = desc;
+
+        /* Handle the case where skb is fragmented in pages */
+        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
+                skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+                struct page *page = skb_frag_page(frag);
+                u32 page_offset = frag->page_offset;
+                u32 buf_len = skb_frag_size(frag);
+                dma_addr_t desc_dma;
+                u32 pkt_info;
+
+                dma_addr = dma_map_page(dev, page, page_offset, buf_len,
+                                        DMA_TO_DEVICE);
+                if (unlikely(!dma_addr)) {
+                        dev_err(netcp->ndev_dev, "Failed to map skb page\n");
+                        goto free_descs;
+                }
+
+                ndesc = knav_pool_desc_get(netcp->tx_pool);
+                if (unlikely(IS_ERR_OR_NULL(ndesc))) {
+                        dev_err(netcp->ndev_dev, "out of TX desc for frags\n");
+                        dma_unmap_page(dev, dma_addr, buf_len, DMA_TO_DEVICE);
+                        goto free_descs;
+                }
+
+                desc_dma = knav_pool_desc_virt_to_dma(netcp->tx_pool,
+                                                      (void *)ndesc);
+                pkt_info =
+                        (netcp->tx_compl_qid & KNAV_DMA_DESC_RETQ_MASK) <<
+                                KNAV_DMA_DESC_RETQ_SHIFT;
+                set_pkt_info(dma_addr, buf_len, 0, ndesc);
+                set_words(&desc_dma, 1, &pdesc->next_desc);
+                pkt_len += buf_len;
+                if (pdesc != desc)
+                        knav_pool_desc_map(netcp->tx_pool, pdesc,
+                                           sizeof(*pdesc), &desc_dma, &dma_sz);
+                pdesc = ndesc;
+        }
+        if (pdesc != desc)
+                knav_pool_desc_map(netcp->tx_pool, pdesc, sizeof(*pdesc),
+                                   &dma_addr, &dma_sz);
+
+        /* frag list based linkage is not supported for now. */
+        if (skb_shinfo(skb)->frag_list) {
+                dev_err_ratelimited(netcp->ndev_dev, "NETIF_F_FRAGLIST not supported\n");
+                goto free_descs;
+        }
+
+upd_pkt_len:
+        WARN_ON(pkt_len != skb->len);
+
+        pkt_len &= KNAV_DMA_DESC_PKT_LEN_MASK;
+        set_words(&pkt_len, 1, &desc->desc_info);
+        return desc;
+
+free_descs:
+        netcp_free_tx_desc_chain(netcp, desc, sizeof(*desc));
+        return NULL;
+}
+
+static int netcp_tx_submit_skb(struct netcp_intf *netcp,
+                               struct sk_buff *skb,
+                               struct knav_dma_desc *desc)
+{
+        struct netcp_tx_pipe *tx_pipe = NULL;
+        struct netcp_hook_list *tx_hook;
+        struct netcp_packet p_info;
+        u32 packet_info = 0;
+        unsigned int dma_sz;
+        dma_addr_t dma;
+        int ret = 0;
+
+        p_info.netcp = netcp;
+        p_info.skb = skb;
+        p_info.tx_pipe = NULL;
+        p_info.psdata_len = 0;
+        p_info.ts_context = NULL;
+        p_info.txtstamp_complete = NULL;
+        p_info.epib = desc->epib;
+        p_info.psdata = desc->psdata;
+        memset(p_info.epib, 0, KNAV_DMA_NUM_EPIB_WORDS * sizeof(u32));
+
+        /* Find out where to inject the packet for transmission */
+        list_for_each_entry(tx_hook, &netcp->txhook_list_head, list) {
+                ret = tx_hook->hook_rtn(tx_hook->order, tx_hook->hook_data,
+                                        &p_info);
+                if (unlikely(ret != 0)) {
+                        dev_err(netcp->ndev_dev, "TX hook %d rejected the packet with reason(%d)\n",
+                                tx_hook->order, ret);
+                        ret = (ret < 0) ? ret : NETDEV_TX_OK;
+                        goto out;
+                }
+        }
+
+        /* Make sure some TX hook claimed the packet */
+        tx_pipe = p_info.tx_pipe;
+        if (!tx_pipe) {
+                dev_err(netcp->ndev_dev, "No TX hook claimed the packet!\n");
+                ret = -ENXIO;
+                goto out;
+        }
+
+        /* update descriptor */
+        if (p_info.psdata_len) {
+                u32 *psdata = p_info.psdata;
+
+                memmove(p_info.psdata, p_info.psdata + p_info.psdata_len,
+                        p_info.psdata_len);
+                set_words(psdata, p_info.psdata_len, psdata);
+                packet_info |=
+                        (p_info.psdata_len & KNAV_DMA_DESC_PSLEN_MASK) <<
+                        KNAV_DMA_DESC_PSLEN_SHIFT;
+        }
+
+        packet_info |= KNAV_DMA_DESC_HAS_EPIB |
+                ((netcp->tx_compl_qid & KNAV_DMA_DESC_RETQ_MASK) <<
+                KNAV_DMA_DESC_RETQ_SHIFT) |
+                ((tx_pipe->dma_psflags & KNAV_DMA_DESC_PSFLAG_MASK) <<
+                KNAV_DMA_DESC_PSFLAG_SHIFT);
+
+        set_words(&packet_info, 1, &desc->packet_info);
+        set_words((u32 *)&skb, 1, &desc->pad[0]);
+
+        /* submit packet descriptor */
+        ret = knav_pool_desc_map(netcp->tx_pool, desc, sizeof(*desc), &dma,
+                                 &dma_sz);
+        if (unlikely(ret)) {
+                dev_err(netcp->ndev_dev, "%s() failed to map desc\n", __func__);
+                ret = -ENOMEM;
+                goto out;
+        }
+        skb_tx_timestamp(skb);
+        knav_queue_push(tx_pipe->dma_queue, dma, dma_sz, 0);
+
+out:
+        return ret;
+}
+
+/* Submit the packet */
+static int netcp_ndo_start_xmit(struct sk_buff *skb, struct net_device *ndev)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        int subqueue = skb_get_queue_mapping(skb);
+        struct knav_dma_desc *desc;
+        int desc_count, ret = 0;
+
+        if (unlikely(skb->len <= 0)) {
+                dev_kfree_skb(skb);
+                return NETDEV_TX_OK;
+        }
+
+        if (unlikely(skb->len < NETCP_MIN_PACKET_SIZE)) {
+                ret = skb_padto(skb, NETCP_MIN_PACKET_SIZE);
+                if (ret < 0) {
+                        /* If we get here, the skb has already been dropped */
+                        dev_warn(netcp->ndev_dev, "padding failed (%d), packet dropped\n",
+                                 ret);
+                        ndev->stats.tx_dropped++;
+                        return ret;
+                }
+                skb->len = NETCP_MIN_PACKET_SIZE;
+        }
+
+        desc = netcp_tx_map_skb(skb, netcp);
+        if (unlikely(!desc)) {
+                netif_stop_subqueue(ndev, subqueue);
+                ret = -ENOBUFS;
+                goto drop;
+        }
+
+        ret = netcp_tx_submit_skb(netcp, skb, desc);
+        if (ret)
+                goto drop;
+
+        ndev->trans_start = jiffies;
+
+        /* Check Tx pool count & stop subqueue if needed */
+        desc_count = knav_pool_count(netcp->tx_pool);
+        if (desc_count < netcp->tx_pause_threshold) {
+                dev_dbg(netcp->ndev_dev, "pausing tx, count(%d)\n", desc_count);
+                netif_stop_subqueue(ndev, subqueue);
+        }
+        return NETDEV_TX_OK;
+
+drop:
+        ndev->stats.tx_dropped++;
+        if (desc)
+                netcp_free_tx_desc_chain(netcp, desc, sizeof(*desc));
+        dev_kfree_skb(skb);
+        return ret;
+}
+
+int netcp_txpipe_close(struct netcp_tx_pipe *tx_pipe)
+{
+        if (tx_pipe->dma_channel) {
+                knav_dma_close_channel(tx_pipe->dma_channel);
+                tx_pipe->dma_channel = NULL;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(netcp_txpipe_close);
+
+int netcp_txpipe_open(struct netcp_tx_pipe *tx_pipe)
+{
+        struct device *dev = tx_pipe->netcp_device->device;
+        struct knav_dma_cfg config;
+        int ret = 0;
+        u8 name[16];
+
+        memset(&config, 0, sizeof(config));
+        config.direction = DMA_MEM_TO_DEV;
+        config.u.tx.filt_einfo = false;
+        config.u.tx.filt_pswords = false;
+        config.u.tx.priority = DMA_PRIO_MED_L;
+
+        tx_pipe->dma_channel = knav_dma_open_channel(dev,
+                                tx_pipe->dma_chan_name, &config);
+        if (IS_ERR_OR_NULL(tx_pipe->dma_channel)) {
+                dev_err(dev, "failed opening tx chan(%s)\n",
+                        tx_pipe->dma_chan_name);
+                goto err;
+        }
+
+        snprintf(name, sizeof(name), "tx-pipe-%s", dev_name(dev));
+        tx_pipe->dma_queue = knav_queue_open(name, tx_pipe->dma_queue_id,
+                                             KNAV_QUEUE_SHARED);
+        if (IS_ERR(tx_pipe->dma_queue)) {
+                dev_err(dev, "Could not open DMA queue for channel \"%s\": %d\n",
+                        name, ret);
+                ret = PTR_ERR(tx_pipe->dma_queue);
+                goto err;
+        }
+
+        dev_dbg(dev, "opened tx pipe %s\n", name);
+        return 0;
+
+err:
+        if (!IS_ERR_OR_NULL(tx_pipe->dma_channel))
+                knav_dma_close_channel(tx_pipe->dma_channel);
+        tx_pipe->dma_channel = NULL;
+        return ret;
+}
+EXPORT_SYMBOL_GPL(netcp_txpipe_open);
+
+int netcp_txpipe_init(struct netcp_tx_pipe *tx_pipe,
+                      struct netcp_device *netcp_device,
+                      const char *dma_chan_name, unsigned int dma_queue_id)
+{
+        memset(tx_pipe, 0, sizeof(*tx_pipe));
+        tx_pipe->netcp_device = netcp_device;
+        tx_pipe->dma_chan_name = dma_chan_name;
+        tx_pipe->dma_queue_id = dma_queue_id;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(netcp_txpipe_init);
+
+static struct netcp_addr *netcp_addr_find(struct netcp_intf *netcp,
+                                          const u8 *addr,
+                                          enum netcp_addr_type type)
+{
+        struct netcp_addr *naddr;
+
+        list_for_each_entry(naddr, &netcp->addr_list, node) {
+                if (naddr->type != type)
+                        continue;
+                if (addr && memcmp(addr, naddr->addr, ETH_ALEN))
+                        continue;
+                return naddr;
+        }
+
+        return NULL;
+}
+
+static struct netcp_addr *netcp_addr_add(struct netcp_intf *netcp,
+                                         const u8 *addr,
+                                         enum netcp_addr_type type)
+{
+        struct netcp_addr *naddr;
+
+        naddr = devm_kmalloc(netcp->dev, sizeof(*naddr), GFP_ATOMIC);
+        if (!naddr)
+                return NULL;
+
+        naddr->type = type;
+        naddr->flags = 0;
+        naddr->netcp = netcp;
+        if (addr)
+                ether_addr_copy(naddr->addr, addr);
+        else
+                memset(naddr->addr, 0, ETH_ALEN);
+        list_add_tail(&naddr->node, &netcp->addr_list);
+
+        return naddr;
+}
+
+static void netcp_addr_del(struct netcp_intf *netcp, struct netcp_addr *naddr)
+{
+        list_del(&naddr->node);
+        devm_kfree(netcp->dev, naddr);
+}
+
+static void netcp_addr_clear_mark(struct netcp_intf *netcp)
+{
+        struct netcp_addr *naddr;
+
+        list_for_each_entry(naddr, &netcp->addr_list, node)
+                naddr->flags = 0;
+}
+
+static void netcp_addr_add_mark(struct netcp_intf *netcp, const u8 *addr,
+                                enum netcp_addr_type type)
+{
+        struct netcp_addr *naddr;
+
+        naddr = netcp_addr_find(netcp, addr, type);
+        if (naddr) {
+                naddr->flags |= ADDR_VALID;
+                return;
+        }
+
+        naddr = netcp_addr_add(netcp, addr, type);
+        if (!WARN_ON(!naddr))
+                naddr->flags |= ADDR_NEW;
+}
+
+static void netcp_addr_sweep_del(struct netcp_intf *netcp)
+{
+        struct netcp_addr *naddr, *tmp;
+        struct netcp_intf_modpriv *priv;
+        struct netcp_module *module;
+        int error;
+
+        list_for_each_entry_safe(naddr, tmp, &netcp->addr_list, node) {
+                if (naddr->flags & (ADDR_VALID | ADDR_NEW))
+                        continue;
+                dev_dbg(netcp->ndev_dev, "deleting address %pM, type %x\n",
+                        naddr->addr, naddr->type);
+                mutex_lock(&netcp_modules_lock);
+                for_each_module(netcp, priv) {
+                        module = priv->netcp_module;
+                        if (!module->del_addr)
+                                continue;
+                        error = module->del_addr(priv->module_priv,
+                                                 naddr);
+                        WARN_ON(error);
+                }
+                mutex_unlock(&netcp_modules_lock);
+                netcp_addr_del(netcp, naddr);
+        }
+}
+
+static void netcp_addr_sweep_add(struct netcp_intf *netcp)
+{
+        struct netcp_addr *naddr, *tmp;
+        struct netcp_intf_modpriv *priv;
+        struct netcp_module *module;
+        int error;
+
+        list_for_each_entry_safe(naddr, tmp, &netcp->addr_list, node) {
+                if (!(naddr->flags & ADDR_NEW))
+                        continue;
+                dev_dbg(netcp->ndev_dev, "adding address %pM, type %x\n",
+                        naddr->addr, naddr->type);
+                mutex_lock(&netcp_modules_lock);
+                for_each_module(netcp, priv) {
+                        module = priv->netcp_module;
+                        if (!module->add_addr)
+                                continue;
+                        error = module->add_addr(priv->module_priv, naddr);
+                        WARN_ON(error);
+                }
+                mutex_unlock(&netcp_modules_lock);
+        }
+}
+
+static void netcp_set_rx_mode(struct net_device *ndev)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct netdev_hw_addr *ndev_addr;
+        bool promisc;
+
+        promisc = (ndev->flags & IFF_PROMISC ||
+                   ndev->flags & IFF_ALLMULTI ||
+                   netdev_mc_count(ndev) > NETCP_MAX_MCAST_ADDR);
+
+        /* first clear all marks */
+        netcp_addr_clear_mark(netcp);
+
+        /* next add new entries, mark existing ones */
+        netcp_addr_add_mark(netcp, ndev->broadcast, ADDR_BCAST);
+        for_each_dev_addr(ndev, ndev_addr)
+                netcp_addr_add_mark(netcp, ndev_addr->addr, ADDR_DEV);
+        netdev_for_each_uc_addr(ndev_addr, ndev)
+                netcp_addr_add_mark(netcp, ndev_addr->addr, ADDR_UCAST);
+        netdev_for_each_mc_addr(ndev_addr, ndev)
+                netcp_addr_add_mark(netcp, ndev_addr->addr, ADDR_MCAST);
+
+        if (promisc)
+                netcp_addr_add_mark(netcp, NULL, ADDR_ANY);
+
+        /* finally sweep and callout into modules */
+        netcp_addr_sweep_del(netcp);
+        netcp_addr_sweep_add(netcp);
+}
+
+static void netcp_free_navigator_resources(struct netcp_intf *netcp)
+{
+        int i;
+
+        if (netcp->rx_channel) {
+                knav_dma_close_channel(netcp->rx_channel);
+                netcp->rx_channel = NULL;
+        }
+
+        if (!IS_ERR_OR_NULL(netcp->rx_pool))
+                netcp_rxpool_free(netcp);
+
+        if (!IS_ERR_OR_NULL(netcp->rx_queue)) {
+                knav_queue_close(netcp->rx_queue);
+                netcp->rx_queue = NULL;
+        }
+
+        for (i = 0; i < KNAV_DMA_FDQ_PER_CHAN &&
+             !IS_ERR_OR_NULL(netcp->rx_fdq[i]) ; ++i) {
+                knav_queue_close(netcp->rx_fdq[i]);
+                netcp->rx_fdq[i] = NULL;
+        }
+
+        if (!IS_ERR_OR_NULL(netcp->tx_compl_q)) {
+                knav_queue_close(netcp->tx_compl_q);
+                netcp->tx_compl_q = NULL;
+        }
+
+        if (!IS_ERR_OR_NULL(netcp->tx_pool)) {
+                knav_pool_destroy(netcp->tx_pool);
+                netcp->tx_pool = NULL;
+        }
+}
+
+static int netcp_setup_navigator_resources(struct net_device *ndev)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct knav_queue_notify_config notify_cfg;
+        struct knav_dma_cfg config;
+        u32 last_fdq = 0;
+        u8 name[16];
+        int ret;
+        int i;
+
+        /* Create Rx/Tx descriptor pools */
+        snprintf(name, sizeof(name), "rx-pool-%s", ndev->name);
+        netcp->rx_pool = knav_pool_create(name, netcp->rx_pool_size,
+                                                netcp->rx_pool_region_id);
+        if (IS_ERR_OR_NULL(netcp->rx_pool)) {
+                dev_err(netcp->ndev_dev, "Couldn't create rx pool\n");
+                ret = PTR_ERR(netcp->rx_pool);
+                goto fail;
+        }
+
+        snprintf(name, sizeof(name), "tx-pool-%s", ndev->name);
+        netcp->tx_pool = knav_pool_create(name, netcp->tx_pool_size,
+                                                netcp->tx_pool_region_id);
+        if (IS_ERR_OR_NULL(netcp->tx_pool)) {
+                dev_err(netcp->ndev_dev, "Couldn't create tx pool\n");
+                ret = PTR_ERR(netcp->tx_pool);
+                goto fail;
+        }
+
+        /* open Tx completion queue */
+        snprintf(name, sizeof(name), "tx-compl-%s", ndev->name);
+        netcp->tx_compl_q = knav_queue_open(name, netcp->tx_compl_qid, 0);
+        if (IS_ERR_OR_NULL(netcp->tx_compl_q)) {
+                ret = PTR_ERR(netcp->tx_compl_q);
+                goto fail;
+        }
+        netcp->tx_compl_qid = knav_queue_get_id(netcp->tx_compl_q);
+
+        /* Set notification for Tx completion */
+        notify_cfg.fn = netcp_tx_notify;
+        notify_cfg.fn_arg = netcp;
+        ret = knav_queue_device_control(netcp->tx_compl_q,
+                                        KNAV_QUEUE_SET_NOTIFIER,
+                                        (unsigned long)&notify_cfg);
+        if (ret)
+                goto fail;
+
+        knav_queue_disable_notify(netcp->tx_compl_q);
+
+        /* open Rx completion queue */
+        snprintf(name, sizeof(name), "rx-compl-%s", ndev->name);
+        netcp->rx_queue = knav_queue_open(name, netcp->rx_queue_id, 0);
+        if (IS_ERR_OR_NULL(netcp->rx_queue)) {
+                ret = PTR_ERR(netcp->rx_queue);
+                goto fail;
+        }
+        netcp->rx_queue_id = knav_queue_get_id(netcp->rx_queue);
+
+        /* Set notification for Rx completion */
+        notify_cfg.fn = netcp_rx_notify;
+        notify_cfg.fn_arg = netcp;
+        ret = knav_queue_device_control(netcp->rx_queue,
+                                        KNAV_QUEUE_SET_NOTIFIER,
+                                        (unsigned long)&notify_cfg);
+        if (ret)
+                goto fail;
+
+        knav_queue_disable_notify(netcp->rx_queue);
+
+        /* open Rx FDQs */
+        for (i = 0; i < KNAV_DMA_FDQ_PER_CHAN &&
+             netcp->rx_queue_depths[i] && netcp->rx_buffer_sizes[i]; ++i) {
+                snprintf(name, sizeof(name), "rx-fdq-%s-%d", ndev->name, i);
+                netcp->rx_fdq[i] = knav_queue_open(name, KNAV_QUEUE_GP, 0);
+                if (IS_ERR_OR_NULL(netcp->rx_fdq[i])) {
+                        ret = PTR_ERR(netcp->rx_fdq[i]);
+                        goto fail;
+                }
+        }
+
+        memset(&config, 0, sizeof(config));
+        config.direction                = DMA_DEV_TO_MEM;
+        config.u.rx.einfo_present       = true;
+        config.u.rx.psinfo_present      = true;
+        config.u.rx.err_mode            = DMA_DROP;
+        config.u.rx.desc_type           = DMA_DESC_HOST;
+        config.u.rx.psinfo_at_sop       = false;
+        config.u.rx.sop_offset          = NETCP_SOP_OFFSET;
+        config.u.rx.dst_q               = netcp->rx_queue_id;
+        config.u.rx.thresh              = DMA_THRESH_NONE;
+
+        for (i = 0; i < KNAV_DMA_FDQ_PER_CHAN; ++i) {
+                if (netcp->rx_fdq[i])
+                        last_fdq = knav_queue_get_id(netcp->rx_fdq[i]);
+                config.u.rx.fdq[i] = last_fdq;
+        }
+
+        netcp->rx_channel = knav_dma_open_channel(netcp->netcp_device->device,
+                                        netcp->dma_chan_name, &config);
+        if (IS_ERR_OR_NULL(netcp->rx_channel)) {
+                dev_err(netcp->ndev_dev, "failed opening rx chan(%s\n",
+                        netcp->dma_chan_name);
+                goto fail;
+        }
+
+        dev_dbg(netcp->ndev_dev, "opened RX channel: %p\n", netcp->rx_channel);
+        return 0;
+
+fail:
+        netcp_free_navigator_resources(netcp);
+        return ret;
+}
+
+/* Open the device */
+static int netcp_ndo_open(struct net_device *ndev)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct netcp_intf_modpriv *intf_modpriv;
+        struct netcp_module *module;
+        int ret;
+
+        netif_carrier_off(ndev);
+        ret = netcp_setup_navigator_resources(ndev);
+        if (ret) {
+                dev_err(netcp->ndev_dev, "Failed to setup navigator resources\n");
+                goto fail;
+        }
+
+        mutex_lock(&netcp_modules_lock);
+        for_each_module(netcp, intf_modpriv) {
+                module = intf_modpriv->netcp_module;
+                if (module->open) {
+                        ret = module->open(intf_modpriv->module_priv, ndev);
+                        if (ret != 0) {
+                                dev_err(netcp->ndev_dev, "module open failed\n");
+                                goto fail_open;
+                        }
+                }
+        }
+        mutex_unlock(&netcp_modules_lock);
+
+        netcp_rxpool_refill(netcp);
+        napi_enable(&netcp->rx_napi);
+        napi_enable(&netcp->tx_napi);
+        knav_queue_enable_notify(netcp->tx_compl_q);
+        knav_queue_enable_notify(netcp->rx_queue);
+        netif_tx_wake_all_queues(ndev);
+        dev_dbg(netcp->ndev_dev, "netcp device %s opened\n", ndev->name);
+        return 0;
+
+fail_open:
+        for_each_module(netcp, intf_modpriv) {
+                module = intf_modpriv->netcp_module;
+                if (module->close)
+                        module->close(intf_modpriv->module_priv, ndev);
+        }
+        mutex_unlock(&netcp_modules_lock);
+
+fail:
+        netcp_free_navigator_resources(netcp);
+        return ret;
+}
+
+/* Close the device */
+static int netcp_ndo_stop(struct net_device *ndev)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct netcp_intf_modpriv *intf_modpriv;
+        struct netcp_module *module;
+        int err = 0;
+
+        netif_tx_stop_all_queues(ndev);
+        netif_carrier_off(ndev);
+        netcp_addr_clear_mark(netcp);
+        netcp_addr_sweep_del(netcp);
+        knav_queue_disable_notify(netcp->rx_queue);
+        knav_queue_disable_notify(netcp->tx_compl_q);
+        napi_disable(&netcp->rx_napi);
+        napi_disable(&netcp->tx_napi);
+
+        mutex_lock(&netcp_modules_lock);
+        for_each_module(netcp, intf_modpriv) {
+                module = intf_modpriv->netcp_module;
+                if (module->close) {
+                        err = module->close(intf_modpriv->module_priv, ndev);
+                        if (err != 0)
+                                dev_err(netcp->ndev_dev, "Close failed\n");
+                }
+        }
+        mutex_unlock(&netcp_modules_lock);
+
+        /* Recycle Rx descriptors from completion queue */
+        netcp_empty_rx_queue(netcp);
+
+        /* Recycle Tx descriptors from completion queue */
+        netcp_process_tx_compl_packets(netcp, netcp->tx_pool_size);
+
+        if (knav_pool_count(netcp->tx_pool) != netcp->tx_pool_size)
+                dev_err(netcp->ndev_dev, "Lost (%d) Tx descs\n",
+                        netcp->tx_pool_size - knav_pool_count(netcp->tx_pool));
+
+        netcp_free_navigator_resources(netcp);
+        dev_dbg(netcp->ndev_dev, "netcp device %s stopped\n", ndev->name);
+        return 0;
+}
+
+static int netcp_ndo_ioctl(struct net_device *ndev,
+                           struct ifreq *req, int cmd)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct netcp_intf_modpriv *intf_modpriv;
+        struct netcp_module *module;
+        int ret = -1, err = -EOPNOTSUPP;
+
+        if (!netif_running(ndev))
+                return -EINVAL;
+
+        mutex_lock(&netcp_modules_lock);
+        for_each_module(netcp, intf_modpriv) {
+                module = intf_modpriv->netcp_module;
+                if (!module->ioctl)
+                        continue;
+
+                err = module->ioctl(intf_modpriv->module_priv, req, cmd);
+                if ((err < 0) && (err != -EOPNOTSUPP)) {
+                        ret = err;
+                        goto out;
+                }
+                if (err == 0)
+                        ret = err;
+        }
+
+out:
+        mutex_unlock(&netcp_modules_lock);
+        return (ret == 0) ? 0 : err;
+}
+
+static int netcp_ndo_change_mtu(struct net_device *ndev, int new_mtu)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+
+        /* MTU < 68 is an error for IPv4 traffic */
+        if ((new_mtu < 68) ||
+            (new_mtu > (NETCP_MAX_FRAME_SIZE - ETH_HLEN - ETH_FCS_LEN))) {
+                dev_err(netcp->ndev_dev, "Invalid mtu size = %d\n", new_mtu);
+                return -EINVAL;
+        }
+
+        ndev->mtu = new_mtu;
+        return 0;
+}
+
+static void netcp_ndo_tx_timeout(struct net_device *ndev)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        unsigned int descs = knav_pool_count(netcp->tx_pool);
+
+        dev_err(netcp->ndev_dev, "transmit timed out tx descs(%d)\n", descs);
+        netcp_process_tx_compl_packets(netcp, netcp->tx_pool_size);
+        ndev->trans_start = jiffies;
+        netif_tx_wake_all_queues(ndev);
+}
+
+static int netcp_rx_add_vid(struct net_device *ndev, __be16 proto, u16 vid)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct netcp_intf_modpriv *intf_modpriv;
+        struct netcp_module *module;
+        int err = 0;
+
+        dev_dbg(netcp->ndev_dev, "adding rx vlan id: %d\n", vid);
+
+        mutex_lock(&netcp_modules_lock);
+        for_each_module(netcp, intf_modpriv) {
+                module = intf_modpriv->netcp_module;
+                if ((module->add_vid) && (vid != 0)) {
+                        err = module->add_vid(intf_modpriv->module_priv, vid);
+                        if (err != 0) {
+                                dev_err(netcp->ndev_dev, "Could not add vlan id = %d\n",
+                                        vid);
+                                break;
+                        }
+                }
+        }
+        mutex_unlock(&netcp_modules_lock);
+        return err;
+}
+
+static int netcp_rx_kill_vid(struct net_device *ndev, __be16 proto, u16 vid)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct netcp_intf_modpriv *intf_modpriv;
+        struct netcp_module *module;
+        int err = 0;
+
+        dev_dbg(netcp->ndev_dev, "removing rx vlan id: %d\n", vid);
+
+        mutex_lock(&netcp_modules_lock);
+        for_each_module(netcp, intf_modpriv) {
+                module = intf_modpriv->netcp_module;
+                if (module->del_vid) {
+                        err = module->del_vid(intf_modpriv->module_priv, vid);
+                        if (err != 0) {
+                                dev_err(netcp->ndev_dev, "Could not delete vlan id = %d\n",
+                                        vid);
+                                break;
+                        }
+                }
+        }
+        mutex_unlock(&netcp_modules_lock);
+        return err;
+}
+
+static u16 netcp_select_queue(struct net_device *dev, struct sk_buff *skb,
+                              void *accel_priv,
+                              select_queue_fallback_t fallback)
+{
+        return 0;
+}
+
+static int netcp_setup_tc(struct net_device *dev, u8 num_tc)
+{
+        int i;
+
+        /* setup tc must be called under rtnl lock */
+        ASSERT_RTNL();
+
+        /* Sanity-check the number of traffic classes requested */
+        if ((dev->real_num_tx_queues <= 1) ||
+            (dev->real_num_tx_queues < num_tc))
+                return -EINVAL;
+
+        /* Configure traffic class to queue mappings */
+        if (num_tc) {
+                netdev_set_num_tc(dev, num_tc);
+                for (i = 0; i < num_tc; i++)
+                        netdev_set_tc_queue(dev, i, 1, i);
+        } else {
+                netdev_reset_tc(dev);
+        }
+
+        return 0;
+}
+
+static const struct net_device_ops netcp_netdev_ops = {
+        .ndo_open               = netcp_ndo_open,
+        .ndo_stop               = netcp_ndo_stop,
+        .ndo_start_xmit         = netcp_ndo_start_xmit,
+        .ndo_set_rx_mode        = netcp_set_rx_mode,
+        .ndo_do_ioctl           = netcp_ndo_ioctl,
+        .ndo_change_mtu         = netcp_ndo_change_mtu,
+        .ndo_set_mac_address    = eth_mac_addr,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_vlan_rx_add_vid    = netcp_rx_add_vid,
+        .ndo_vlan_rx_kill_vid   = netcp_rx_kill_vid,
+        .ndo_tx_timeout         = netcp_ndo_tx_timeout,
+        .ndo_select_queue       = netcp_select_queue,
+        .ndo_setup_tc           = netcp_setup_tc,
+};
+
+static int netcp_create_interface(struct netcp_device *netcp_device,
+                                  struct device_node *node_interface)
+{
+        struct device *dev = netcp_device->device;
+        struct device_node *node = dev->of_node;
+        struct netcp_intf *netcp;
+        struct net_device *ndev;
+        resource_size_t size;
+        struct resource res;
+        void __iomem *efuse = NULL;
+        u32 efuse_mac = 0;
+        const void *mac_addr;
+        u8 efuse_mac_addr[6];
+        u32 temp[2];
+        int ret = 0;
+
+        ndev = alloc_etherdev_mqs(sizeof(*netcp), 1, 1);
+        if (!ndev) {
+                dev_err(dev, "Error allocating netdev\n");
+                return -ENOMEM;
+        }
+
+        ndev->features |= NETIF_F_SG;
+        ndev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
+        ndev->hw_features = ndev->features;
+        ndev->vlan_features |=  NETIF_F_SG;
+
+        netcp = netdev_priv(ndev);
+        spin_lock_init(&netcp->lock);
+        INIT_LIST_HEAD(&netcp->module_head);
+        INIT_LIST_HEAD(&netcp->txhook_list_head);
+        INIT_LIST_HEAD(&netcp->rxhook_list_head);
+        INIT_LIST_HEAD(&netcp->addr_list);
+        netcp->netcp_device = netcp_device;
+        netcp->dev = netcp_device->device;
+        netcp->ndev = ndev;
+        netcp->ndev_dev  = &ndev->dev;
+        netcp->msg_enable = netif_msg_init(netcp_debug_level, NETCP_DEBUG);
+        netcp->tx_pause_threshold = MAX_SKB_FRAGS;
+        netcp->tx_resume_threshold = netcp->tx_pause_threshold;
+        netcp->node_interface = node_interface;
+
+        ret = of_property_read_u32(node_interface, "efuse-mac", &efuse_mac);
+        if (efuse_mac) {
+                if (of_address_to_resource(node, NETCP_EFUSE_REG_INDEX, &res)) {
+                        dev_err(dev, "could not find efuse-mac reg resource\n");
+                        ret = -ENODEV;
+                        goto quit;
+                }
+                size = resource_size(&res);
+
+                if (!devm_request_mem_region(dev, res.start, size,
+                                             dev_name(dev))) {
+                        dev_err(dev, "could not reserve resource\n");
+                        ret = -ENOMEM;
+                        goto quit;
+                }
+
+                efuse = devm_ioremap_nocache(dev, res.start, size);
+                if (!efuse) {
+                        dev_err(dev, "could not map resource\n");
+                        devm_release_mem_region(dev, res.start, size);
+                        ret = -ENOMEM;
+                        goto quit;
+                }
+
+                emac_arch_get_mac_addr(efuse_mac_addr, efuse);
+                if (is_valid_ether_addr(efuse_mac_addr))
+                        ether_addr_copy(ndev->dev_addr, efuse_mac_addr);
+                else
+                        random_ether_addr(ndev->dev_addr);
+
+                devm_iounmap(dev, efuse);
+                devm_release_mem_region(dev, res.start, size);
+        } else {
+                mac_addr = of_get_mac_address(node_interface);
+                if (mac_addr)
+                        ether_addr_copy(ndev->dev_addr, mac_addr);
+                else
+                        random_ether_addr(ndev->dev_addr);
+        }
+
+        ret = of_property_read_string(node_interface, "rx-channel",
+                                      &netcp->dma_chan_name);
+        if (ret < 0) {
+                dev_err(dev, "missing \"rx-channel\" parameter\n");
+                ret = -ENODEV;
+                goto quit;
+        }
+
+        ret = of_property_read_u32(node_interface, "rx-queue",
+                                   &netcp->rx_queue_id);
+        if (ret < 0) {
+                dev_warn(dev, "missing \"rx-queue\" parameter\n");
+                netcp->rx_queue_id = KNAV_QUEUE_QPEND;
+        }
+
+        ret = of_property_read_u32_array(node_interface, "rx-queue-depth",
+                                         netcp->rx_queue_depths,
+                                         KNAV_DMA_FDQ_PER_CHAN);
+        if (ret < 0) {
+                dev_err(dev, "missing \"rx-queue-depth\" parameter\n");
+                netcp->rx_queue_depths[0] = 128;
+        }
+
+        ret = of_property_read_u32_array(node_interface, "rx-buffer-size",
+                                         netcp->rx_buffer_sizes,
+                                         KNAV_DMA_FDQ_PER_CHAN);
+        if (ret) {
+                dev_err(dev, "missing \"rx-buffer-size\" parameter\n");
+                netcp->rx_buffer_sizes[0] = 1536;
+        }
+
+        ret = of_property_read_u32_array(node_interface, "rx-pool", temp, 2);
+        if (ret < 0) {
+                dev_err(dev, "missing \"rx-pool\" parameter\n");
+                ret = -ENODEV;
+                goto quit;
+        }
+        netcp->rx_pool_size = temp[0];
+        netcp->rx_pool_region_id = temp[1];
+
+        ret = of_property_read_u32_array(node_interface, "tx-pool", temp, 2);
+        if (ret < 0) {
+                dev_err(dev, "missing \"tx-pool\" parameter\n");
+                ret = -ENODEV;
+                goto quit;
+        }
+        netcp->tx_pool_size = temp[0];
+        netcp->tx_pool_region_id = temp[1];
+
+        if (netcp->tx_pool_size < MAX_SKB_FRAGS) {
+                dev_err(dev, "tx-pool size too small, must be atleast(%ld)\n",
+                        MAX_SKB_FRAGS);
+                ret = -ENODEV;
+                goto quit;
+        }
+
+        ret = of_property_read_u32(node_interface, "tx-completion-queue",
+                                   &netcp->tx_compl_qid);
+        if (ret < 0) {
+                dev_warn(dev, "missing \"tx-completion-queue\" parameter\n");
+                netcp->tx_compl_qid = KNAV_QUEUE_QPEND;
+        }
+
+        /* NAPI register */
+        netif_napi_add(ndev, &netcp->rx_napi, netcp_rx_poll, NETCP_NAPI_WEIGHT);
+        netif_napi_add(ndev, &netcp->tx_napi, netcp_tx_poll, NETCP_NAPI_WEIGHT);
+
+        /* Register the network device */
+        ndev->dev_id            = 0;
+        ndev->watchdog_timeo    = NETCP_TX_TIMEOUT;
+        ndev->netdev_ops        = &netcp_netdev_ops;
+        SET_NETDEV_DEV(ndev, dev);
+
+        list_add_tail(&netcp->interface_list, &netcp_device->interface_head);
+        return 0;
+
+quit:
+        free_netdev(ndev);
+        return ret;
+}
+
+static void netcp_delete_interface(struct netcp_device *netcp_device,
+                                   struct net_device *ndev)
+{
+        struct netcp_intf_modpriv *intf_modpriv, *tmp;
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct netcp_module *module;
+
+        dev_dbg(netcp_device->device, "Removing interface \"%s\"\n",
+                ndev->name);
+
+        /* Notify each of the modules that the interface is going away */
+        list_for_each_entry_safe(intf_modpriv, tmp, &netcp->module_head,
+                                 intf_list) {
+                module = intf_modpriv->netcp_module;
+                dev_dbg(netcp_device->device, "Releasing module \"%s\"\n",
+                        module->name);
+                if (module->release)
+                        module->release(intf_modpriv->module_priv);
+                list_del(&intf_modpriv->intf_list);
+                kfree(intf_modpriv);
+        }
+        WARN(!list_empty(&netcp->module_head), "%s interface module list is not empty!\n",
+             ndev->name);
+
+        list_del(&netcp->interface_list);
+
+        of_node_put(netcp->node_interface);
+        unregister_netdev(ndev);
+        netif_napi_del(&netcp->rx_napi);
+        free_netdev(ndev);
+}
+
+static int netcp_probe(struct platform_device *pdev)
+{
+        struct device_node *node = pdev->dev.of_node;
+        struct netcp_intf *netcp_intf, *netcp_tmp;
+        struct device_node *child, *interfaces;
+        struct netcp_device *netcp_device;
+        struct device *dev = &pdev->dev;
+        struct netcp_module *module;
+        int ret;
+
+        if (!node) {
+                dev_err(dev, "could not find device info\n");
+                return -ENODEV;
+        }
+
+        /* Allocate a new NETCP device instance */
+        netcp_device = devm_kzalloc(dev, sizeof(*netcp_device), GFP_KERNEL);
+        if (!netcp_device)
+                return -ENOMEM;
+
+        pm_runtime_enable(&pdev->dev);
+        ret = pm_runtime_get_sync(&pdev->dev);
+        if (ret < 0) {
+                dev_err(dev, "Failed to enable NETCP power-domain\n");
+                pm_runtime_disable(&pdev->dev);
+                return ret;
+        }
+
+        /* Initialize the NETCP device instance */
+        INIT_LIST_HEAD(&netcp_device->interface_head);
+        INIT_LIST_HEAD(&netcp_device->modpriv_head);
+        netcp_device->device = dev;
+        platform_set_drvdata(pdev, netcp_device);
+
+        /* create interfaces */
+        interfaces = of_get_child_by_name(node, "netcp-interfaces");
+        if (!interfaces) {
+                dev_err(dev, "could not find netcp-interfaces node\n");
+                ret = -ENODEV;
+                goto probe_quit;
+        }
+
+        for_each_available_child_of_node(interfaces, child) {
+                ret = netcp_create_interface(netcp_device, child);
+                if (ret) {
+                        dev_err(dev, "could not create interface(%s)\n",
+                                child->name);
+                        goto probe_quit_interface;
+                }
+        }
+
+        /* Add the device instance to the list */
+        list_add_tail(&netcp_device->device_list, &netcp_devices);
+
+        /* Probe & attach any modules already registered */
+        mutex_lock(&netcp_modules_lock);
+        for_each_netcp_module(module) {
+                ret = netcp_module_probe(netcp_device, module);
+                if (ret < 0)
+                        dev_err(dev, "module(%s) probe failed\n", module->name);
+        }
+        mutex_unlock(&netcp_modules_lock);
+        return 0;
+
+probe_quit_interface:
+        list_for_each_entry_safe(netcp_intf, netcp_tmp,
+                                 &netcp_device->interface_head,
+                                 interface_list) {
+                netcp_delete_interface(netcp_device, netcp_intf->ndev);
+        }
+
+probe_quit:
+        pm_runtime_put_sync(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
+        platform_set_drvdata(pdev, NULL);
+        return ret;
+}
+
+static int netcp_remove(struct platform_device *pdev)
+{
+        struct netcp_device *netcp_device = platform_get_drvdata(pdev);
+        struct netcp_inst_modpriv *inst_modpriv, *tmp;
+        struct netcp_module *module;
+
+        list_for_each_entry_safe(inst_modpriv, tmp, &netcp_device->modpriv_head,
+                                 inst_list) {
+                module = inst_modpriv->netcp_module;
+                dev_dbg(&pdev->dev, "Removing module \"%s\"\n", module->name);
+                module->remove(netcp_device, inst_modpriv->module_priv);
+                list_del(&inst_modpriv->inst_list);
+                kfree(inst_modpriv);
+        }
+        WARN(!list_empty(&netcp_device->interface_head), "%s interface list not empty!\n",
+             pdev->name);
+
+        devm_kfree(&pdev->dev, netcp_device);
+        pm_runtime_put_sync(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+static struct of_device_id of_match[] = {
+        { .compatible = "ti,netcp-1.0", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, of_match);
+
+static struct platform_driver netcp_driver = {
+        .driver = {
+                .name           = "netcp-1.0",
+                .owner          = THIS_MODULE,
+                .of_match_table = of_match,
+        },
+        .probe = netcp_probe,
+        .remove = netcp_remove,
+};
+module_platform_driver(netcp_driver);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("TI NETCP driver for Keystone SOCs");
+MODULE_AUTHOR("Sandeep Nair <sandeep_n@ti.com");
diff --git a/drivers/net/ethernet/ti/netcp_ethss.c b/drivers/net/ethernet/ti/netcp_ethss.c
new file mode 100644
index 000000000000..84f5ce525750
--- /dev/null
+++ b/drivers/net/ethernet/ti/netcp_ethss.c
@@ -0,0 +1,2159 @@
+/*
+ * Keystone GBE and XGBE subsystem code
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated
+ * Authors:     Sandeep Nair <sandeep_n@ti.com>
+ *              Sandeep Paulraj <s-paulraj@ti.com>
+ *              Cyril Chemparathy <cyril@ti.com>
+ *              Santosh Shilimkar <santosh.shilimkar@ti.com>
+ *              Wingman Kwok <w-kwok2@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of_mdio.h>
+#include <linux/of_address.h>
+#include <linux/if_vlan.h>
+#include <linux/ethtool.h>
+
+#include "cpsw_ale.h"
+#include "netcp.h"
+
+#define NETCP_DRIVER_NAME               "TI KeyStone Ethernet Driver"
+#define NETCP_DRIVER_VERSION            "v1.0"
+
+#define GBE_IDENT(reg)                  ((reg >> 16) & 0xffff)
+#define GBE_MAJOR_VERSION(reg)          (reg >> 8 & 0x7)
+#define GBE_MINOR_VERSION(reg)          (reg & 0xff)
+#define GBE_RTL_VERSION(reg)            ((reg >> 11) & 0x1f)
+
+/* 1G Ethernet SS defines */
+#define GBE_MODULE_NAME                 "netcp-gbe"
+#define GBE_SS_VERSION_14               0x4ed21104
+
+#define GBE13_SGMII_MODULE_OFFSET       0x100
+#define GBE13_SGMII34_MODULE_OFFSET     0x400
+#define GBE13_SWITCH_MODULE_OFFSET      0x800
+#define GBE13_HOST_PORT_OFFSET          0x834
+#define GBE13_SLAVE_PORT_OFFSET         0x860
+#define GBE13_EMAC_OFFSET               0x900
+#define GBE13_SLAVE_PORT2_OFFSET        0xa00
+#define GBE13_HW_STATS_OFFSET           0xb00
+#define GBE13_ALE_OFFSET                0xe00
+#define GBE13_HOST_PORT_NUM             0
+#define GBE13_NUM_SLAVES                4
+#define GBE13_NUM_ALE_PORTS             (GBE13_NUM_SLAVES + 1)
+#define GBE13_NUM_ALE_ENTRIES           1024
+
+/* 10G Ethernet SS defines */
+#define XGBE_MODULE_NAME                "netcp-xgbe"
+#define XGBE_SS_VERSION_10              0x4ee42100
+
+#define XGBE_SERDES_REG_INDEX           1
+#define XGBE10_SGMII_MODULE_OFFSET      0x100
+#define XGBE10_SWITCH_MODULE_OFFSET     0x1000
+#define XGBE10_HOST_PORT_OFFSET         0x1034
+#define XGBE10_SLAVE_PORT_OFFSET        0x1064
+#define XGBE10_EMAC_OFFSET              0x1400
+#define XGBE10_ALE_OFFSET               0x1700
+#define XGBE10_HW_STATS_OFFSET          0x1800
+#define XGBE10_HOST_PORT_NUM            0
+#define XGBE10_NUM_SLAVES               2
+#define XGBE10_NUM_ALE_PORTS            (XGBE10_NUM_SLAVES + 1)
+#define XGBE10_NUM_ALE_ENTRIES          1024
+
+#define GBE_TIMER_INTERVAL                      (HZ / 2)
+
+/* Soft reset register values */
+#define SOFT_RESET_MASK                         BIT(0)
+#define SOFT_RESET                              BIT(0)
+#define DEVICE_EMACSL_RESET_POLL_COUNT          100
+#define GMACSL_RET_WARN_RESET_INCOMPLETE        -2
+
+#define MACSL_RX_ENABLE_CSF                     BIT(23)
+#define MACSL_ENABLE_EXT_CTL                    BIT(18)
+#define MACSL_XGMII_ENABLE                      BIT(13)
+#define MACSL_XGIG_MODE                         BIT(8)
+#define MACSL_GIG_MODE                          BIT(7)
+#define MACSL_GMII_ENABLE                       BIT(5)
+#define MACSL_FULLDUPLEX                        BIT(0)
+
+#define GBE_CTL_P0_ENABLE                       BIT(2)
+#define GBE_REG_VAL_STAT_ENABLE_ALL             0xff
+#define XGBE_REG_VAL_STAT_ENABLE_ALL            0xf
+#define GBE_STATS_CD_SEL                        BIT(28)
+
+#define GBE_PORT_MASK(x)                        (BIT(x) - 1)
+#define GBE_MASK_NO_PORTS                       0
+
+#define GBE_DEF_1G_MAC_CONTROL                                  \
+                (MACSL_GIG_MODE | MACSL_GMII_ENABLE |           \
+                 MACSL_ENABLE_EXT_CTL | MACSL_RX_ENABLE_CSF)
+
+#define GBE_DEF_10G_MAC_CONTROL                         \
+                (MACSL_XGIG_MODE | MACSL_XGMII_ENABLE |         \
+                 MACSL_ENABLE_EXT_CTL | MACSL_RX_ENABLE_CSF)
+
+#define GBE_STATSA_MODULE                       0
+#define GBE_STATSB_MODULE                       1
+#define GBE_STATSC_MODULE                       2
+#define GBE_STATSD_MODULE                       3
+
+#define XGBE_STATS0_MODULE                      0
+#define XGBE_STATS1_MODULE                      1
+#define XGBE_STATS2_MODULE                      2
+
+#define MAX_SLAVES                              GBE13_NUM_SLAVES
+/* s: 0-based slave_port */
+#define SGMII_BASE(s) \
+        (((s) < 2) ? gbe_dev->sgmii_port_regs : gbe_dev->sgmii_port34_regs)
+
+#define GBE_TX_QUEUE                            648
+#define GBE_TXHOOK_ORDER                        0
+#define GBE_DEFAULT_ALE_AGEOUT                  30
+#define SLAVE_LINK_IS_XGMII(s) ((s)->link_interface >= XGMII_LINK_MAC_PHY)
+#define NETCP_LINK_STATE_INVALID                -1
+
+#define GBE_SET_REG_OFS(p, rb, rn) p->rb##_ofs.rn = \
+                offsetof(struct gbe##_##rb, rn)
+#define XGBE_SET_REG_OFS(p, rb, rn) p->rb##_ofs.rn = \
+                offsetof(struct xgbe##_##rb, rn)
+#define GBE_REG_ADDR(p, rb, rn) (p->rb + p->rb##_ofs.rn)
+
+struct xgbe_ss_regs {
+        u32     id_ver;
+        u32     synce_count;
+        u32     synce_mux;
+        u32     control;
+};
+
+struct xgbe_switch_regs {
+        u32     id_ver;
+        u32     control;
+        u32     emcontrol;
+        u32     stat_port_en;
+        u32     ptype;
+        u32     soft_idle;
+        u32     thru_rate;
+        u32     gap_thresh;
+        u32     tx_start_wds;
+        u32     flow_control;
+        u32     cppi_thresh;
+};
+
+struct xgbe_port_regs {
+        u32     blk_cnt;
+        u32     port_vlan;
+        u32     tx_pri_map;
+        u32     sa_lo;
+        u32     sa_hi;
+        u32     ts_ctl;
+        u32     ts_seq_ltype;
+        u32     ts_vlan;
+        u32     ts_ctl_ltype2;
+        u32     ts_ctl2;
+        u32     control;
+};
+
+struct xgbe_host_port_regs {
+        u32     blk_cnt;
+        u32     port_vlan;
+        u32     tx_pri_map;
+        u32     src_id;
+        u32     rx_pri_map;
+        u32     rx_maxlen;
+};
+
+struct xgbe_emac_regs {
+        u32     id_ver;
+        u32     mac_control;
+        u32     mac_status;
+        u32     soft_reset;
+        u32     rx_maxlen;
+        u32     __reserved_0;
+        u32     rx_pause;
+        u32     tx_pause;
+        u32     em_control;
+        u32     __reserved_1;
+        u32     tx_gap;
+        u32     rsvd[4];
+};
+
+struct xgbe_host_hw_stats {
+        u32     rx_good_frames;
+        u32     rx_broadcast_frames;
+        u32     rx_multicast_frames;
+        u32     __rsvd_0[3];
+        u32     rx_oversized_frames;
+        u32     __rsvd_1;
+        u32     rx_undersized_frames;
+        u32     __rsvd_2;
+        u32     overrun_type4;
+        u32     overrun_type5;
+        u32     rx_bytes;
+        u32     tx_good_frames;
+        u32     tx_broadcast_frames;
+        u32     tx_multicast_frames;
+        u32     __rsvd_3[9];
+        u32     tx_bytes;
+        u32     tx_64byte_frames;
+        u32     tx_65_to_127byte_frames;
+        u32     tx_128_to_255byte_frames;
+        u32     tx_256_to_511byte_frames;
+        u32     tx_512_to_1023byte_frames;
+        u32     tx_1024byte_frames;
+        u32     net_bytes;
+        u32     rx_sof_overruns;
+        u32     rx_mof_overruns;
+        u32     rx_dma_overruns;
+};
+
+struct xgbe_hw_stats {
+        u32     rx_good_frames;
+        u32     rx_broadcast_frames;
+        u32     rx_multicast_frames;
+        u32     rx_pause_frames;
+        u32     rx_crc_errors;
+        u32     rx_align_code_errors;
+        u32     rx_oversized_frames;
+        u32     rx_jabber_frames;
+        u32     rx_undersized_frames;
+        u32     rx_fragments;
+        u32     overrun_type4;
+        u32     overrun_type5;
+        u32     rx_bytes;
+        u32     tx_good_frames;
+        u32     tx_broadcast_frames;
+        u32     tx_multicast_frames;
+        u32     tx_pause_frames;
+        u32     tx_deferred_frames;
+        u32     tx_collision_frames;
+        u32     tx_single_coll_frames;
+        u32     tx_mult_coll_frames;
+        u32     tx_excessive_collisions;
+        u32     tx_late_collisions;
+        u32     tx_underrun;
+        u32     tx_carrier_sense_errors;
+        u32     tx_bytes;
+        u32     tx_64byte_frames;
+        u32     tx_65_to_127byte_frames;
+        u32     tx_128_to_255byte_frames;
+        u32     tx_256_to_511byte_frames;
+        u32     tx_512_to_1023byte_frames;
+        u32     tx_1024byte_frames;
+        u32     net_bytes;
+        u32     rx_sof_overruns;
+        u32     rx_mof_overruns;
+        u32     rx_dma_overruns;
+};
+
+#define XGBE10_NUM_STAT_ENTRIES (sizeof(struct xgbe_hw_stats)/sizeof(u32))
+
+struct gbe_ss_regs {
+        u32     id_ver;
+        u32     synce_count;
+        u32     synce_mux;
+};
+
+struct gbe_ss_regs_ofs {
+        u16     id_ver;
+        u16     control;
+};
+
+struct gbe_switch_regs {
+        u32     id_ver;
+        u32     control;
+        u32     soft_reset;
+        u32     stat_port_en;
+        u32     ptype;
+        u32     soft_idle;
+        u32     thru_rate;
+        u32     gap_thresh;
+        u32     tx_start_wds;
+        u32     flow_control;
+};
+
+struct gbe_switch_regs_ofs {
+        u16     id_ver;
+        u16     control;
+        u16     soft_reset;
+        u16     emcontrol;
+        u16     stat_port_en;
+        u16     ptype;
+        u16     flow_control;
+};
+
+struct gbe_port_regs {
+        u32     max_blks;
+        u32     blk_cnt;
+        u32     port_vlan;
+        u32     tx_pri_map;
+        u32     sa_lo;
+        u32     sa_hi;
+        u32     ts_ctl;
+        u32     ts_seq_ltype;
+        u32     ts_vlan;
+        u32     ts_ctl_ltype2;
+        u32     ts_ctl2;
+};
+
+struct gbe_port_regs_ofs {
+        u16     port_vlan;
+        u16     tx_pri_map;
+        u16     sa_lo;
+        u16     sa_hi;
+        u16     ts_ctl;
+        u16     ts_seq_ltype;
+        u16     ts_vlan;
+        u16     ts_ctl_ltype2;
+        u16     ts_ctl2;
+};
+
+struct gbe_host_port_regs {
+        u32     src_id;
+        u32     port_vlan;
+        u32     rx_pri_map;
+        u32     rx_maxlen;
+};
+
+struct gbe_host_port_regs_ofs {
+        u16     port_vlan;
+        u16     tx_pri_map;
+        u16     rx_maxlen;
+};
+
+struct gbe_emac_regs {
+        u32     id_ver;
+        u32     mac_control;
+        u32     mac_status;
+        u32     soft_reset;
+        u32     rx_maxlen;
+        u32     __reserved_0;
+        u32     rx_pause;
+        u32     tx_pause;
+        u32     __reserved_1;
+        u32     rx_pri_map;
+        u32     rsvd[6];
+};
+
+struct gbe_emac_regs_ofs {
+        u16     mac_control;
+        u16     soft_reset;
+        u16     rx_maxlen;
+};
+
+struct gbe_hw_stats {
+        u32     rx_good_frames;
+        u32     rx_broadcast_frames;
+        u32     rx_multicast_frames;
+        u32     rx_pause_frames;
+        u32     rx_crc_errors;
+        u32     rx_align_code_errors;
+        u32     rx_oversized_frames;
+        u32     rx_jabber_frames;
+        u32     rx_undersized_frames;
+        u32     rx_fragments;
+        u32     __pad_0[2];
+        u32     rx_bytes;
+        u32     tx_good_frames;
+        u32     tx_broadcast_frames;
+        u32     tx_multicast_frames;
+        u32     tx_pause_frames;
+        u32     tx_deferred_frames;
+        u32     tx_collision_frames;
+        u32     tx_single_coll_frames;
+        u32     tx_mult_coll_frames;
+        u32     tx_excessive_collisions;
+        u32     tx_late_collisions;
+        u32     tx_underrun;
+        u32     tx_carrier_sense_errors;
+        u32     tx_bytes;
+        u32     tx_64byte_frames;
+        u32     tx_65_to_127byte_frames;
+        u32     tx_128_to_255byte_frames;
+        u32     tx_256_to_511byte_frames;
+        u32     tx_512_to_1023byte_frames;
+        u32     tx_1024byte_frames;
+        u32     net_bytes;
+        u32     rx_sof_overruns;
+        u32     rx_mof_overruns;
+        u32     rx_dma_overruns;
+};
+
+#define GBE13_NUM_HW_STAT_ENTRIES (sizeof(struct gbe_hw_stats)/sizeof(u32))
+#define GBE13_NUM_HW_STATS_MOD                  2
+#define XGBE10_NUM_HW_STATS_MOD                 3
+#define GBE_MAX_HW_STAT_MODS                    3
+#define GBE_HW_STATS_REG_MAP_SZ                 0x100
+
+struct gbe_slave {
+        void __iomem                    *port_regs;
+        void __iomem                    *emac_regs;
+        struct gbe_port_regs_ofs        port_regs_ofs;
+        struct gbe_emac_regs_ofs        emac_regs_ofs;
+        int                             slave_num; /* 0 based logical number */
+        int                             port_num;  /* actual port number */
+        atomic_t                        link_state;
+        bool                            open;
+        struct phy_device               *phy;
+        u32                             link_interface;
+        u32                             mac_control;
+        u8                              phy_port_t;
+        struct device_node              *phy_node;
+        struct list_head                slave_list;
+};
+
+struct gbe_priv {
+        struct device                   *dev;
+        struct netcp_device             *netcp_device;
+        struct timer_list               timer;
+        u32                             num_slaves;
+        u32                             ale_entries;
+        u32                             ale_ports;
+        bool                            enable_ale;
+        struct netcp_tx_pipe            tx_pipe;
+
+        int                             host_port;
+        u32                             rx_packet_max;
+        u32                             ss_version;
+
+        void __iomem                    *ss_regs;
+        void __iomem                    *switch_regs;
+        void __iomem                    *host_port_regs;
+        void __iomem                    *ale_reg;
+        void __iomem                    *sgmii_port_regs;
+        void __iomem                    *sgmii_port34_regs;
+        void __iomem                    *xgbe_serdes_regs;
+        void __iomem                    *hw_stats_regs[GBE_MAX_HW_STAT_MODS];
+
+        struct gbe_ss_regs_ofs          ss_regs_ofs;
+        struct gbe_switch_regs_ofs      switch_regs_ofs;
+        struct gbe_host_port_regs_ofs   host_port_regs_ofs;
+
+        struct cpsw_ale                 *ale;
+        unsigned int                    tx_queue_id;
+        const char                      *dma_chan_name;
+
+        struct list_head                gbe_intf_head;
+        struct list_head                secondary_slaves;
+        struct net_device               *dummy_ndev;
+
+        u64                             *hw_stats;
+        const struct netcp_ethtool_stat *et_stats;
+        int                             num_et_stats;
+        /*  Lock for updating the hwstats */
+        spinlock_t                      hw_stats_lock;
+};
+
+struct gbe_intf {
+        struct net_device       *ndev;
+        struct device           *dev;
+        struct gbe_priv         *gbe_dev;
+        struct netcp_tx_pipe    tx_pipe;
+        struct gbe_slave        *slave;
+        struct list_head        gbe_intf_list;
+        unsigned long           active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
+};
+
+static struct netcp_module gbe_module;
+static struct netcp_module xgbe_module;
+
+/* Statistic management */
+struct netcp_ethtool_stat {
+        char desc[ETH_GSTRING_LEN];
+        int type;
+        u32 size;
+        int offset;
+};
+
+#define GBE_STATSA_INFO(field)          "GBE_A:"#field, GBE_STATSA_MODULE,\
+                                FIELD_SIZEOF(struct gbe_hw_stats, field), \
+                                offsetof(struct gbe_hw_stats, field)
+
+#define GBE_STATSB_INFO(field)          "GBE_B:"#field, GBE_STATSB_MODULE,\
+                                FIELD_SIZEOF(struct gbe_hw_stats, field), \
+                                offsetof(struct gbe_hw_stats, field)
+
+#define GBE_STATSC_INFO(field)          "GBE_C:"#field, GBE_STATSC_MODULE,\
+                                FIELD_SIZEOF(struct gbe_hw_stats, field), \
+                                offsetof(struct gbe_hw_stats, field)
+
+#define GBE_STATSD_INFO(field)          "GBE_D:"#field, GBE_STATSD_MODULE,\
+                                FIELD_SIZEOF(struct gbe_hw_stats, field), \
+                                offsetof(struct gbe_hw_stats, field)
+
+static const struct netcp_ethtool_stat gbe13_et_stats[] = {
+        /* GBE module A */
+        {GBE_STATSA_INFO(rx_good_frames)},
+        {GBE_STATSA_INFO(rx_broadcast_frames)},
+        {GBE_STATSA_INFO(rx_multicast_frames)},
+        {GBE_STATSA_INFO(rx_pause_frames)},
+        {GBE_STATSA_INFO(rx_crc_errors)},
+        {GBE_STATSA_INFO(rx_align_code_errors)},
+        {GBE_STATSA_INFO(rx_oversized_frames)},
+        {GBE_STATSA_INFO(rx_jabber_frames)},
+        {GBE_STATSA_INFO(rx_undersized_frames)},
+        {GBE_STATSA_INFO(rx_fragments)},
+        {GBE_STATSA_INFO(rx_bytes)},
+        {GBE_STATSA_INFO(tx_good_frames)},
+        {GBE_STATSA_INFO(tx_broadcast_frames)},
+        {GBE_STATSA_INFO(tx_multicast_frames)},
+        {GBE_STATSA_INFO(tx_pause_frames)},
+        {GBE_STATSA_INFO(tx_deferred_frames)},
+        {GBE_STATSA_INFO(tx_collision_frames)},
+        {GBE_STATSA_INFO(tx_single_coll_frames)},
+        {GBE_STATSA_INFO(tx_mult_coll_frames)},
+        {GBE_STATSA_INFO(tx_excessive_collisions)},
+        {GBE_STATSA_INFO(tx_late_collisions)},
+        {GBE_STATSA_INFO(tx_underrun)},
+        {GBE_STATSA_INFO(tx_carrier_sense_errors)},
+        {GBE_STATSA_INFO(tx_bytes)},
+        {GBE_STATSA_INFO(tx_64byte_frames)},
+        {GBE_STATSA_INFO(tx_65_to_127byte_frames)},
+        {GBE_STATSA_INFO(tx_128_to_255byte_frames)},
+        {GBE_STATSA_INFO(tx_256_to_511byte_frames)},
+        {GBE_STATSA_INFO(tx_512_to_1023byte_frames)},
+        {GBE_STATSA_INFO(tx_1024byte_frames)},
+        {GBE_STATSA_INFO(net_bytes)},
+        {GBE_STATSA_INFO(rx_sof_overruns)},
+        {GBE_STATSA_INFO(rx_mof_overruns)},
+        {GBE_STATSA_INFO(rx_dma_overruns)},
+        /* GBE module B */
+        {GBE_STATSB_INFO(rx_good_frames)},
+        {GBE_STATSB_INFO(rx_broadcast_frames)},
+        {GBE_STATSB_INFO(rx_multicast_frames)},
+        {GBE_STATSB_INFO(rx_pause_frames)},
+        {GBE_STATSB_INFO(rx_crc_errors)},
+        {GBE_STATSB_INFO(rx_align_code_errors)},
+        {GBE_STATSB_INFO(rx_oversized_frames)},
+        {GBE_STATSB_INFO(rx_jabber_frames)},
+        {GBE_STATSB_INFO(rx_undersized_frames)},
+        {GBE_STATSB_INFO(rx_fragments)},
+        {GBE_STATSB_INFO(rx_bytes)},
+        {GBE_STATSB_INFO(tx_good_frames)},
+        {GBE_STATSB_INFO(tx_broadcast_frames)},
+        {GBE_STATSB_INFO(tx_multicast_frames)},
+        {GBE_STATSB_INFO(tx_pause_frames)},
+        {GBE_STATSB_INFO(tx_deferred_frames)},
+        {GBE_STATSB_INFO(tx_collision_frames)},
+        {GBE_STATSB_INFO(tx_single_coll_frames)},
+        {GBE_STATSB_INFO(tx_mult_coll_frames)},
+        {GBE_STATSB_INFO(tx_excessive_collisions)},
+        {GBE_STATSB_INFO(tx_late_collisions)},
+        {GBE_STATSB_INFO(tx_underrun)},
+        {GBE_STATSB_INFO(tx_carrier_sense_errors)},
+        {GBE_STATSB_INFO(tx_bytes)},
+        {GBE_STATSB_INFO(tx_64byte_frames)},
+        {GBE_STATSB_INFO(tx_65_to_127byte_frames)},
+        {GBE_STATSB_INFO(tx_128_to_255byte_frames)},
+        {GBE_STATSB_INFO(tx_256_to_511byte_frames)},
+        {GBE_STATSB_INFO(tx_512_to_1023byte_frames)},
+        {GBE_STATSB_INFO(tx_1024byte_frames)},
+        {GBE_STATSB_INFO(net_bytes)},
+        {GBE_STATSB_INFO(rx_sof_overruns)},
+        {GBE_STATSB_INFO(rx_mof_overruns)},
+        {GBE_STATSB_INFO(rx_dma_overruns)},
+        /* GBE module C */
+        {GBE_STATSC_INFO(rx_good_frames)},
+        {GBE_STATSC_INFO(rx_broadcast_frames)},
+        {GBE_STATSC_INFO(rx_multicast_frames)},
+        {GBE_STATSC_INFO(rx_pause_frames)},
+        {GBE_STATSC_INFO(rx_crc_errors)},
+        {GBE_STATSC_INFO(rx_align_code_errors)},
+        {GBE_STATSC_INFO(rx_oversized_frames)},
+        {GBE_STATSC_INFO(rx_jabber_frames)},
+        {GBE_STATSC_INFO(rx_undersized_frames)},
+        {GBE_STATSC_INFO(rx_fragments)},
+        {GBE_STATSC_INFO(rx_bytes)},
+        {GBE_STATSC_INFO(tx_good_frames)},
+        {GBE_STATSC_INFO(tx_broadcast_frames)},
+        {GBE_STATSC_INFO(tx_multicast_frames)},
+        {GBE_STATSC_INFO(tx_pause_frames)},
+        {GBE_STATSC_INFO(tx_deferred_frames)},
+        {GBE_STATSC_INFO(tx_collision_frames)},
+        {GBE_STATSC_INFO(tx_single_coll_frames)},
+        {GBE_STATSC_INFO(tx_mult_coll_frames)},
+        {GBE_STATSC_INFO(tx_excessive_collisions)},
+        {GBE_STATSC_INFO(tx_late_collisions)},
+        {GBE_STATSC_INFO(tx_underrun)},
+        {GBE_STATSC_INFO(tx_carrier_sense_errors)},
+        {GBE_STATSC_INFO(tx_bytes)},
+        {GBE_STATSC_INFO(tx_64byte_frames)},
+        {GBE_STATSC_INFO(tx_65_to_127byte_frames)},
+        {GBE_STATSC_INFO(tx_128_to_255byte_frames)},
+        {GBE_STATSC_INFO(tx_256_to_511byte_frames)},
+        {GBE_STATSC_INFO(tx_512_to_1023byte_frames)},
+        {GBE_STATSC_INFO(tx_1024byte_frames)},
+        {GBE_STATSC_INFO(net_bytes)},
+        {GBE_STATSC_INFO(rx_sof_overruns)},
+        {GBE_STATSC_INFO(rx_mof_overruns)},
+        {GBE_STATSC_INFO(rx_dma_overruns)},
+        /* GBE module D */
+        {GBE_STATSD_INFO(rx_good_frames)},
+        {GBE_STATSD_INFO(rx_broadcast_frames)},
+        {GBE_STATSD_INFO(rx_multicast_frames)},
+        {GBE_STATSD_INFO(rx_pause_frames)},
+        {GBE_STATSD_INFO(rx_crc_errors)},
+        {GBE_STATSD_INFO(rx_align_code_errors)},
+        {GBE_STATSD_INFO(rx_oversized_frames)},
+        {GBE_STATSD_INFO(rx_jabber_frames)},
+        {GBE_STATSD_INFO(rx_undersized_frames)},
+        {GBE_STATSD_INFO(rx_fragments)},
+        {GBE_STATSD_INFO(rx_bytes)},
+        {GBE_STATSD_INFO(tx_good_frames)},
+        {GBE_STATSD_INFO(tx_broadcast_frames)},
+        {GBE_STATSD_INFO(tx_multicast_frames)},
+        {GBE_STATSD_INFO(tx_pause_frames)},
+        {GBE_STATSD_INFO(tx_deferred_frames)},
+        {GBE_STATSD_INFO(tx_collision_frames)},
+        {GBE_STATSD_INFO(tx_single_coll_frames)},
+        {GBE_STATSD_INFO(tx_mult_coll_frames)},
+        {GBE_STATSD_INFO(tx_excessive_collisions)},
+        {GBE_STATSD_INFO(tx_late_collisions)},
+        {GBE_STATSD_INFO(tx_underrun)},
+        {GBE_STATSD_INFO(tx_carrier_sense_errors)},
+        {GBE_STATSD_INFO(tx_bytes)},
+        {GBE_STATSD_INFO(tx_64byte_frames)},
+        {GBE_STATSD_INFO(tx_65_to_127byte_frames)},
+        {GBE_STATSD_INFO(tx_128_to_255byte_frames)},
+        {GBE_STATSD_INFO(tx_256_to_511byte_frames)},
+        {GBE_STATSD_INFO(tx_512_to_1023byte_frames)},
+        {GBE_STATSD_INFO(tx_1024byte_frames)},
+        {GBE_STATSD_INFO(net_bytes)},
+        {GBE_STATSD_INFO(rx_sof_overruns)},
+        {GBE_STATSD_INFO(rx_mof_overruns)},
+        {GBE_STATSD_INFO(rx_dma_overruns)},
+};
+
+#define XGBE_STATS0_INFO(field) "GBE_0:"#field, XGBE_STATS0_MODULE, \
+                                FIELD_SIZEOF(struct xgbe_hw_stats, field), \
+                                offsetof(struct xgbe_hw_stats, field)
+
+#define XGBE_STATS1_INFO(field) "GBE_1:"#field, XGBE_STATS1_MODULE, \
+                                FIELD_SIZEOF(struct xgbe_hw_stats, field), \
+                                offsetof(struct xgbe_hw_stats, field)
+
+#define XGBE_STATS2_INFO(field) "GBE_2:"#field, XGBE_STATS2_MODULE, \
+                                FIELD_SIZEOF(struct xgbe_hw_stats, field), \
+                                offsetof(struct xgbe_hw_stats, field)
+
+static const struct netcp_ethtool_stat xgbe10_et_stats[] = {
+        /* GBE module 0 */
+        {XGBE_STATS0_INFO(rx_good_frames)},
+        {XGBE_STATS0_INFO(rx_broadcast_frames)},
+        {XGBE_STATS0_INFO(rx_multicast_frames)},
+        {XGBE_STATS0_INFO(rx_oversized_frames)},
+        {XGBE_STATS0_INFO(rx_undersized_frames)},
+        {XGBE_STATS0_INFO(overrun_type4)},
+        {XGBE_STATS0_INFO(overrun_type5)},
+        {XGBE_STATS0_INFO(rx_bytes)},
+        {XGBE_STATS0_INFO(tx_good_frames)},
+        {XGBE_STATS0_INFO(tx_broadcast_frames)},
+        {XGBE_STATS0_INFO(tx_multicast_frames)},
+        {XGBE_STATS0_INFO(tx_bytes)},
+        {XGBE_STATS0_INFO(tx_64byte_frames)},
+        {XGBE_STATS0_INFO(tx_65_to_127byte_frames)},
+        {XGBE_STATS0_INFO(tx_128_to_255byte_frames)},
+        {XGBE_STATS0_INFO(tx_256_to_511byte_frames)},
+        {XGBE_STATS0_INFO(tx_512_to_1023byte_frames)},
+        {XGBE_STATS0_INFO(tx_1024byte_frames)},
+        {XGBE_STATS0_INFO(net_bytes)},
+        {XGBE_STATS0_INFO(rx_sof_overruns)},
+        {XGBE_STATS0_INFO(rx_mof_overruns)},
+        {XGBE_STATS0_INFO(rx_dma_overruns)},
+        /* XGBE module 1 */
+        {XGBE_STATS1_INFO(rx_good_frames)},
+        {XGBE_STATS1_INFO(rx_broadcast_frames)},
+        {XGBE_STATS1_INFO(rx_multicast_frames)},
+        {XGBE_STATS1_INFO(rx_pause_frames)},
+        {XGBE_STATS1_INFO(rx_crc_errors)},
+        {XGBE_STATS1_INFO(rx_align_code_errors)},
+        {XGBE_STATS1_INFO(rx_oversized_frames)},
+        {XGBE_STATS1_INFO(rx_jabber_frames)},
+        {XGBE_STATS1_INFO(rx_undersized_frames)},
+        {XGBE_STATS1_INFO(rx_fragments)},
+        {XGBE_STATS1_INFO(overrun_type4)},
+        {XGBE_STATS1_INFO(overrun_type5)},
+        {XGBE_STATS1_INFO(rx_bytes)},
+        {XGBE_STATS1_INFO(tx_good_frames)},
+        {XGBE_STATS1_INFO(tx_broadcast_frames)},
+        {XGBE_STATS1_INFO(tx_multicast_frames)},
+        {XGBE_STATS1_INFO(tx_pause_frames)},
+        {XGBE_STATS1_INFO(tx_deferred_frames)},
+        {XGBE_STATS1_INFO(tx_collision_frames)},
+        {XGBE_STATS1_INFO(tx_single_coll_frames)},
+        {XGBE_STATS1_INFO(tx_mult_coll_frames)},
+        {XGBE_STATS1_INFO(tx_excessive_collisions)},
+        {XGBE_STATS1_INFO(tx_late_collisions)},
+        {XGBE_STATS1_INFO(tx_underrun)},
+        {XGBE_STATS1_INFO(tx_carrier_sense_errors)},
+        {XGBE_STATS1_INFO(tx_bytes)},
+        {XGBE_STATS1_INFO(tx_64byte_frames)},
+        {XGBE_STATS1_INFO(tx_65_to_127byte_frames)},
+        {XGBE_STATS1_INFO(tx_128_to_255byte_frames)},
+        {XGBE_STATS1_INFO(tx_256_to_511byte_frames)},
+        {XGBE_STATS1_INFO(tx_512_to_1023byte_frames)},
+        {XGBE_STATS1_INFO(tx_1024byte_frames)},
+        {XGBE_STATS1_INFO(net_bytes)},
+        {XGBE_STATS1_INFO(rx_sof_overruns)},
+        {XGBE_STATS1_INFO(rx_mof_overruns)},
+        {XGBE_STATS1_INFO(rx_dma_overruns)},
+        /* XGBE module 2 */
+        {XGBE_STATS2_INFO(rx_good_frames)},
+        {XGBE_STATS2_INFO(rx_broadcast_frames)},
+        {XGBE_STATS2_INFO(rx_multicast_frames)},
+        {XGBE_STATS2_INFO(rx_pause_frames)},
+        {XGBE_STATS2_INFO(rx_crc_errors)},
+        {XGBE_STATS2_INFO(rx_align_code_errors)},
+        {XGBE_STATS2_INFO(rx_oversized_frames)},
+        {XGBE_STATS2_INFO(rx_jabber_frames)},
+        {XGBE_STATS2_INFO(rx_undersized_frames)},
+        {XGBE_STATS2_INFO(rx_fragments)},
+        {XGBE_STATS2_INFO(overrun_type4)},
+        {XGBE_STATS2_INFO(overrun_type5)},
+        {XGBE_STATS2_INFO(rx_bytes)},
+        {XGBE_STATS2_INFO(tx_good_frames)},
+        {XGBE_STATS2_INFO(tx_broadcast_frames)},
+        {XGBE_STATS2_INFO(tx_multicast_frames)},
+        {XGBE_STATS2_INFO(tx_pause_frames)},
+        {XGBE_STATS2_INFO(tx_deferred_frames)},
+        {XGBE_STATS2_INFO(tx_collision_frames)},
+        {XGBE_STATS2_INFO(tx_single_coll_frames)},
+        {XGBE_STATS2_INFO(tx_mult_coll_frames)},
+        {XGBE_STATS2_INFO(tx_excessive_collisions)},
+        {XGBE_STATS2_INFO(tx_late_collisions)},
+        {XGBE_STATS2_INFO(tx_underrun)},
+        {XGBE_STATS2_INFO(tx_carrier_sense_errors)},
+        {XGBE_STATS2_INFO(tx_bytes)},
+        {XGBE_STATS2_INFO(tx_64byte_frames)},
+        {XGBE_STATS2_INFO(tx_65_to_127byte_frames)},
+        {XGBE_STATS2_INFO(tx_128_to_255byte_frames)},
+        {XGBE_STATS2_INFO(tx_256_to_511byte_frames)},
+        {XGBE_STATS2_INFO(tx_512_to_1023byte_frames)},
+        {XGBE_STATS2_INFO(tx_1024byte_frames)},
+        {XGBE_STATS2_INFO(net_bytes)},
+        {XGBE_STATS2_INFO(rx_sof_overruns)},
+        {XGBE_STATS2_INFO(rx_mof_overruns)},
+        {XGBE_STATS2_INFO(rx_dma_overruns)},
+};
+
+#define for_each_intf(i, priv) \
+        list_for_each_entry((i), &(priv)->gbe_intf_head, gbe_intf_list)
+
+#define for_each_sec_slave(slave, priv) \
+        list_for_each_entry((slave), &(priv)->secondary_slaves, slave_list)
+
+#define first_sec_slave(priv)                                   \
+        list_first_entry(&priv->secondary_slaves, \
+                        struct gbe_slave, slave_list)
+
+static void keystone_get_drvinfo(struct net_device *ndev,
+                                 struct ethtool_drvinfo *info)
+{
+        strncpy(info->driver, NETCP_DRIVER_NAME, sizeof(info->driver));
+        strncpy(info->version, NETCP_DRIVER_VERSION, sizeof(info->version));
+}
+
+static u32 keystone_get_msglevel(struct net_device *ndev)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+
+        return netcp->msg_enable;
+}
+
+static void keystone_set_msglevel(struct net_device *ndev, u32 value)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+
+        netcp->msg_enable = value;
+}
+
+static void keystone_get_stat_strings(struct net_device *ndev,
+                                      uint32_t stringset, uint8_t *data)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct gbe_intf *gbe_intf;
+        struct gbe_priv *gbe_dev;
+        int i;
+
+        gbe_intf = netcp_module_get_intf_data(&gbe_module, netcp);
+        if (!gbe_intf)
+                return;
+        gbe_dev = gbe_intf->gbe_dev;
+
+        switch (stringset) {
+        case ETH_SS_STATS:
+                for (i = 0; i < gbe_dev->num_et_stats; i++) {
+                        memcpy(data, gbe_dev->et_stats[i].desc,
+                               ETH_GSTRING_LEN);
+                        data += ETH_GSTRING_LEN;
+                }
+                break;
+        case ETH_SS_TEST:
+                break;
+        }
+}
+
+static int keystone_get_sset_count(struct net_device *ndev, int stringset)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct gbe_intf *gbe_intf;
+        struct gbe_priv *gbe_dev;
+
+        gbe_intf = netcp_module_get_intf_data(&gbe_module, netcp);
+        if (!gbe_intf)
+                return -EINVAL;
+        gbe_dev = gbe_intf->gbe_dev;
+
+        switch (stringset) {
+        case ETH_SS_TEST:
+                return 0;
+        case ETH_SS_STATS:
+                return gbe_dev->num_et_stats;
+        default:
+                return -EINVAL;
+        }
+}
+
+static void gbe_update_stats(struct gbe_priv *gbe_dev, uint64_t *data)
+{
+        void __iomem *base = NULL;
+        u32  __iomem *p;
+        u32 tmp = 0;
+        int i;
+
+        for (i = 0; i < gbe_dev->num_et_stats; i++) {
+                base = gbe_dev->hw_stats_regs[gbe_dev->et_stats[i].type];
+                p = base + gbe_dev->et_stats[i].offset;
+                tmp = readl(p);
+                gbe_dev->hw_stats[i] = gbe_dev->hw_stats[i] + tmp;
+                if (data)
+                        data[i] = gbe_dev->hw_stats[i];
+                /* write-to-decrement:
+                 * new register value = old register value - write value
+                 */
+                writel(tmp, p);
+        }
+}
+
+static void gbe_update_stats_ver14(struct gbe_priv *gbe_dev, uint64_t *data)
+{
+        void __iomem *gbe_statsa = gbe_dev->hw_stats_regs[0];
+        void __iomem *gbe_statsb = gbe_dev->hw_stats_regs[1];
+        u64 *hw_stats = &gbe_dev->hw_stats[0];
+        void __iomem *base = NULL;
+        u32  __iomem *p;
+        u32 tmp = 0, val, pair_size = (gbe_dev->num_et_stats / 2);
+        int i, j, pair;
+
+        for (pair = 0; pair < 2; pair++) {
+                val = readl(GBE_REG_ADDR(gbe_dev, switch_regs, stat_port_en));
+
+                if (pair == 0)
+                        val &= ~GBE_STATS_CD_SEL;
+                else
+                        val |= GBE_STATS_CD_SEL;
+
+                /* make the stat modules visible */
+                writel(val, GBE_REG_ADDR(gbe_dev, switch_regs, stat_port_en));
+
+                for (i = 0; i < pair_size; i++) {
+                        j = pair * pair_size + i;
+                        switch (gbe_dev->et_stats[j].type) {
+                        case GBE_STATSA_MODULE:
+                        case GBE_STATSC_MODULE:
+                                base = gbe_statsa;
+                        break;
+                        case GBE_STATSB_MODULE:
+                        case GBE_STATSD_MODULE:
+                                base  = gbe_statsb;
+                        break;
+                        }
+
+                        p = base + gbe_dev->et_stats[j].offset;
+                        tmp = readl(p);
+                        hw_stats[j] += tmp;
+                        if (data)
+                                data[j] = hw_stats[j];
+                        /* write-to-decrement:
+                         * new register value = old register value - write value
+                         */
+                        writel(tmp, p);
+                }
+        }
+}
+
+static void keystone_get_ethtool_stats(struct net_device *ndev,
+                                       struct ethtool_stats *stats,
+                                       uint64_t *data)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct gbe_intf *gbe_intf;
+        struct gbe_priv *gbe_dev;
+
+        gbe_intf = netcp_module_get_intf_data(&gbe_module, netcp);
+        if (!gbe_intf)
+                return;
+
+        gbe_dev = gbe_intf->gbe_dev;
+        spin_lock_bh(&gbe_dev->hw_stats_lock);
+        if (gbe_dev->ss_version == GBE_SS_VERSION_14)
+                gbe_update_stats_ver14(gbe_dev, data);
+        else
+                gbe_update_stats(gbe_dev, data);
+        spin_unlock_bh(&gbe_dev->hw_stats_lock);
+}
+
+static int keystone_get_settings(struct net_device *ndev,
+                                 struct ethtool_cmd *cmd)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct phy_device *phy = ndev->phydev;
+        struct gbe_intf *gbe_intf;
+        int ret;
+
+        if (!phy)
+                return -EINVAL;
+
+        gbe_intf = netcp_module_get_intf_data(&gbe_module, netcp);
+        if (!gbe_intf)
+                return -EINVAL;
+
+        if (!gbe_intf->slave)
+                return -EINVAL;
+
+        ret = phy_ethtool_gset(phy, cmd);
+        if (!ret)
+                cmd->port = gbe_intf->slave->phy_port_t;
+
+        return ret;
+}
+
+static int keystone_set_settings(struct net_device *ndev,
+                                 struct ethtool_cmd *cmd)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct phy_device *phy = ndev->phydev;
+        struct gbe_intf *gbe_intf;
+        u32 features = cmd->advertising & cmd->supported;
+
+        if (!phy)
+                return -EINVAL;
+
+        gbe_intf = netcp_module_get_intf_data(&gbe_module, netcp);
+        if (!gbe_intf)
+                return -EINVAL;
+
+        if (!gbe_intf->slave)
+                return -EINVAL;
+
+        if (cmd->port != gbe_intf->slave->phy_port_t) {
+                if ((cmd->port == PORT_TP) && !(features & ADVERTISED_TP))
+                        return -EINVAL;
+
+                if ((cmd->port == PORT_AUI) && !(features & ADVERTISED_AUI))
+                        return -EINVAL;
+
+                if ((cmd->port == PORT_BNC) && !(features & ADVERTISED_BNC))
+                        return -EINVAL;
+
+                if ((cmd->port == PORT_MII) && !(features & ADVERTISED_MII))
+                        return -EINVAL;
+
+                if ((cmd->port == PORT_FIBRE) && !(features & ADVERTISED_FIBRE))
+                        return -EINVAL;
+        }
+
+        gbe_intf->slave->phy_port_t = cmd->port;
+        return phy_ethtool_sset(phy, cmd);
+}
+
+static const struct ethtool_ops keystone_ethtool_ops = {
+        .get_drvinfo            = keystone_get_drvinfo,
+        .get_link               = ethtool_op_get_link,
+        .get_msglevel           = keystone_get_msglevel,
+        .set_msglevel           = keystone_set_msglevel,
+        .get_strings            = keystone_get_stat_strings,
+        .get_sset_count         = keystone_get_sset_count,
+        .get_ethtool_stats      = keystone_get_ethtool_stats,
+        .get_settings           = keystone_get_settings,
+        .set_settings           = keystone_set_settings,
+};
+
+#define mac_hi(mac)     (((mac)[0] << 0) | ((mac)[1] << 8) |    \
+                         ((mac)[2] << 16) | ((mac)[3] << 24))
+#define mac_lo(mac)     (((mac)[4] << 0) | ((mac)[5] << 8))
+
+static void gbe_set_slave_mac(struct gbe_slave *slave,
+                              struct gbe_intf *gbe_intf)
+{
+        struct net_device *ndev = gbe_intf->ndev;
+
+        writel(mac_hi(ndev->dev_addr), GBE_REG_ADDR(slave, port_regs, sa_hi));
+        writel(mac_lo(ndev->dev_addr), GBE_REG_ADDR(slave, port_regs, sa_lo));
+}
+
+static int gbe_get_slave_port(struct gbe_priv *priv, u32 slave_num)
+{
+        if (priv->host_port == 0)
+                return slave_num + 1;
+
+        return slave_num;
+}
+
+static void netcp_ethss_link_state_action(struct gbe_priv *gbe_dev,
+                                          struct net_device *ndev,
+                                          struct gbe_slave *slave,
+                                          int up)
+{
+        struct phy_device *phy = slave->phy;
+        u32 mac_control = 0;
+
+        if (up) {
+                mac_control = slave->mac_control;
+                if (phy && (phy->speed == SPEED_1000)) {
+                        mac_control |= MACSL_GIG_MODE;
+                        mac_control &= ~MACSL_XGIG_MODE;
+                } else if (phy && (phy->speed == SPEED_10000)) {
+                        mac_control |= MACSL_XGIG_MODE;
+                        mac_control &= ~MACSL_GIG_MODE;
+                }
+
+                writel(mac_control, GBE_REG_ADDR(slave, emac_regs,
+                                                 mac_control));
+
+                cpsw_ale_control_set(gbe_dev->ale, slave->port_num,
+                                     ALE_PORT_STATE,
+                                     ALE_PORT_STATE_FORWARD);
+
+                if (ndev && slave->open)
+                        netif_carrier_on(ndev);
+        } else {
+                writel(mac_control, GBE_REG_ADDR(slave, emac_regs,
+                                                 mac_control));
+                cpsw_ale_control_set(gbe_dev->ale, slave->port_num,
+                                     ALE_PORT_STATE,
+                                     ALE_PORT_STATE_DISABLE);
+                if (ndev)
+                        netif_carrier_off(ndev);
+        }
+
+        if (phy)
+                phy_print_status(phy);
+}
+
+static bool gbe_phy_link_status(struct gbe_slave *slave)
+{
+         return !slave->phy || slave->phy->link;
+}
+
+static void netcp_ethss_update_link_state(struct gbe_priv *gbe_dev,
+                                          struct gbe_slave *slave,
+                                          struct net_device *ndev)
+{
+        int sp = slave->slave_num;
+        int phy_link_state, sgmii_link_state = 1, link_state;
+
+        if (!slave->open)
+                return;
+
+        if (!SLAVE_LINK_IS_XGMII(slave))
+                sgmii_link_state = netcp_sgmii_get_port_link(SGMII_BASE(sp),
+                                                             sp);
+        phy_link_state = gbe_phy_link_status(slave);
+        link_state = phy_link_state & sgmii_link_state;
+
+        if (atomic_xchg(&slave->link_state, link_state) != link_state)
+                netcp_ethss_link_state_action(gbe_dev, ndev, slave,
+                                              link_state);
+}
+
+static void xgbe_adjust_link(struct net_device *ndev)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct gbe_intf *gbe_intf;
+
+        gbe_intf = netcp_module_get_intf_data(&xgbe_module, netcp);
+        if (!gbe_intf)
+                return;
+
+        netcp_ethss_update_link_state(gbe_intf->gbe_dev, gbe_intf->slave,
+                                      ndev);
+}
+
+static void gbe_adjust_link(struct net_device *ndev)
+{
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct gbe_intf *gbe_intf;
+
+        gbe_intf = netcp_module_get_intf_data(&gbe_module, netcp);
+        if (!gbe_intf)
+                return;
+
+        netcp_ethss_update_link_state(gbe_intf->gbe_dev, gbe_intf->slave,
+                                      ndev);
+}
+
+static void gbe_adjust_link_sec_slaves(struct net_device *ndev)
+{
+        struct gbe_priv *gbe_dev = netdev_priv(ndev);
+        struct gbe_slave *slave;
+
+        for_each_sec_slave(slave, gbe_dev)
+                netcp_ethss_update_link_state(gbe_dev, slave, NULL);
+}
+
+/* Reset EMAC
+ * Soft reset is set and polled until clear, or until a timeout occurs
+ */
+static int gbe_port_reset(struct gbe_slave *slave)
+{
+        u32 i, v;
+
+        /* Set the soft reset bit */
+        writel(SOFT_RESET, GBE_REG_ADDR(slave, emac_regs, soft_reset));
+
+        /* Wait for the bit to clear */
+        for (i = 0; i < DEVICE_EMACSL_RESET_POLL_COUNT; i++) {
+                v = readl(GBE_REG_ADDR(slave, emac_regs, soft_reset));
+                if ((v & SOFT_RESET_MASK) != SOFT_RESET)
+                        return 0;
+        }
+
+        /* Timeout on the reset */
+        return GMACSL_RET_WARN_RESET_INCOMPLETE;
+}
+
+/* Configure EMAC */
+static void gbe_port_config(struct gbe_priv *gbe_dev, struct gbe_slave *slave,
+                            int max_rx_len)
+{
+        u32 xgmii_mode;
+
+        if (max_rx_len > NETCP_MAX_FRAME_SIZE)
+                max_rx_len = NETCP_MAX_FRAME_SIZE;
+
+        /* Enable correct MII mode at SS level */
+        if ((gbe_dev->ss_version == XGBE_SS_VERSION_10) &&
+            (slave->link_interface >= XGMII_LINK_MAC_PHY)) {
+                xgmii_mode = readl(GBE_REG_ADDR(gbe_dev, ss_regs, control));
+                xgmii_mode |= (1 << slave->slave_num);
+                writel(xgmii_mode, GBE_REG_ADDR(gbe_dev, ss_regs, control));
+        }
+
+        writel(max_rx_len, GBE_REG_ADDR(slave, emac_regs, rx_maxlen));
+        writel(slave->mac_control, GBE_REG_ADDR(slave, emac_regs, mac_control));
+}
+
+static void gbe_slave_stop(struct gbe_intf *intf)
+{
+        struct gbe_priv *gbe_dev = intf->gbe_dev;
+        struct gbe_slave *slave = intf->slave;
+
+        gbe_port_reset(slave);
+        /* Disable forwarding */
+        cpsw_ale_control_set(gbe_dev->ale, slave->port_num,
+                             ALE_PORT_STATE, ALE_PORT_STATE_DISABLE);
+        cpsw_ale_del_mcast(gbe_dev->ale, intf->ndev->broadcast,
+                           1 << slave->port_num, 0, 0);
+
+        if (!slave->phy)
+                return;
+
+        phy_stop(slave->phy);
+        phy_disconnect(slave->phy);
+        slave->phy = NULL;
+}
+
+static void gbe_sgmii_config(struct gbe_priv *priv, struct gbe_slave *slave)
+{
+        void __iomem *sgmii_port_regs;
+
+        sgmii_port_regs = priv->sgmii_port_regs;
+        if ((priv->ss_version == GBE_SS_VERSION_14) && (slave->slave_num >= 2))
+                sgmii_port_regs = priv->sgmii_port34_regs;
+
+        if (!SLAVE_LINK_IS_XGMII(slave)) {
+                netcp_sgmii_reset(sgmii_port_regs, slave->slave_num);
+                netcp_sgmii_config(sgmii_port_regs, slave->slave_num,
+                                   slave->link_interface);
+        }
+}
+
+static int gbe_slave_open(struct gbe_intf *gbe_intf)
+{
+        struct gbe_priv *priv = gbe_intf->gbe_dev;
+        struct gbe_slave *slave = gbe_intf->slave;
+        phy_interface_t phy_mode;
+        bool has_phy = false;
+
+        void (*hndlr)(struct net_device *) = gbe_adjust_link;
+
+        gbe_sgmii_config(priv, slave);
+        gbe_port_reset(slave);
+        gbe_port_config(priv, slave, priv->rx_packet_max);
+        gbe_set_slave_mac(slave, gbe_intf);
+        /* enable forwarding */
+        cpsw_ale_control_set(priv->ale, slave->port_num,
+                             ALE_PORT_STATE, ALE_PORT_STATE_FORWARD);
+        cpsw_ale_add_mcast(priv->ale, gbe_intf->ndev->broadcast,
+                           1 << slave->port_num, 0, 0, ALE_MCAST_FWD_2);
+
+        if (slave->link_interface == SGMII_LINK_MAC_PHY) {
+                has_phy = true;
+                phy_mode = PHY_INTERFACE_MODE_SGMII;
+                slave->phy_port_t = PORT_MII;
+        } else if (slave->link_interface == XGMII_LINK_MAC_PHY) {
+                has_phy = true;
+                phy_mode = PHY_INTERFACE_MODE_NA;
+                slave->phy_port_t = PORT_FIBRE;
+        }
+
+        if (has_phy) {
+                if (priv->ss_version == XGBE_SS_VERSION_10)
+                        hndlr = xgbe_adjust_link;
+
+                slave->phy = of_phy_connect(gbe_intf->ndev,
+                                            slave->phy_node,
+                                            hndlr, 0,
+                                            phy_mode);
+                if (!slave->phy) {
+                        dev_err(priv->dev, "phy not found on slave %d\n",
+                                slave->slave_num);
+                        return -ENODEV;
+                }
+                dev_dbg(priv->dev, "phy found: id is: 0x%s\n",
+                        dev_name(&slave->phy->dev));
+                phy_start(slave->phy);
+                phy_read_status(slave->phy);
+        }
+        return 0;
+}
+
+static void gbe_init_host_port(struct gbe_priv *priv)
+{
+        int bypass_en = 1;
+        /* Max length register */
+        writel(NETCP_MAX_FRAME_SIZE, GBE_REG_ADDR(priv, host_port_regs,
+                                                  rx_maxlen));
+
+        cpsw_ale_start(priv->ale);
+
+        if (priv->enable_ale)
+                bypass_en = 0;
+
+        cpsw_ale_control_set(priv->ale, 0, ALE_BYPASS, bypass_en);
+
+        cpsw_ale_control_set(priv->ale, 0, ALE_NO_PORT_VLAN, 1);
+
+        cpsw_ale_control_set(priv->ale, priv->host_port,
+                             ALE_PORT_STATE, ALE_PORT_STATE_FORWARD);
+
+        cpsw_ale_control_set(priv->ale, 0,
+                             ALE_PORT_UNKNOWN_VLAN_MEMBER,
+                             GBE_PORT_MASK(priv->ale_ports));
+
+        cpsw_ale_control_set(priv->ale, 0,
+                             ALE_PORT_UNKNOWN_MCAST_FLOOD,
+                             GBE_PORT_MASK(priv->ale_ports - 1));
+
+        cpsw_ale_control_set(priv->ale, 0,
+                             ALE_PORT_UNKNOWN_REG_MCAST_FLOOD,
+                             GBE_PORT_MASK(priv->ale_ports));
+
+        cpsw_ale_control_set(priv->ale, 0,
+                             ALE_PORT_UNTAGGED_EGRESS,
+                             GBE_PORT_MASK(priv->ale_ports));
+}
+
+static void gbe_add_mcast_addr(struct gbe_intf *gbe_intf, u8 *addr)
+{
+        struct gbe_priv *gbe_dev = gbe_intf->gbe_dev;
+        u16 vlan_id;
+
+        cpsw_ale_add_mcast(gbe_dev->ale, addr,
+                           GBE_PORT_MASK(gbe_dev->ale_ports), 0, 0,
+                           ALE_MCAST_FWD_2);
+        for_each_set_bit(vlan_id, gbe_intf->active_vlans, VLAN_N_VID) {
+                cpsw_ale_add_mcast(gbe_dev->ale, addr,
+                                   GBE_PORT_MASK(gbe_dev->ale_ports),
+                                   ALE_VLAN, vlan_id, ALE_MCAST_FWD_2);
+        }
+}
+
+static void gbe_add_ucast_addr(struct gbe_intf *gbe_intf, u8 *addr)
+{
+        struct gbe_priv *gbe_dev = gbe_intf->gbe_dev;
+        u16 vlan_id;
+
+        cpsw_ale_add_ucast(gbe_dev->ale, addr, gbe_dev->host_port, 0, 0);
+
+        for_each_set_bit(vlan_id, gbe_intf->active_vlans, VLAN_N_VID)
+                cpsw_ale_add_ucast(gbe_dev->ale, addr, gbe_dev->host_port,
+                                   ALE_VLAN, vlan_id);
+}
+
+static void gbe_del_mcast_addr(struct gbe_intf *gbe_intf, u8 *addr)
+{
+        struct gbe_priv *gbe_dev = gbe_intf->gbe_dev;
+        u16 vlan_id;
+
+        cpsw_ale_del_mcast(gbe_dev->ale, addr, 0, 0, 0);
+
+        for_each_set_bit(vlan_id, gbe_intf->active_vlans, VLAN_N_VID) {
+                cpsw_ale_del_mcast(gbe_dev->ale, addr, 0, ALE_VLAN, vlan_id);
+        }
+}
+
+static void gbe_del_ucast_addr(struct gbe_intf *gbe_intf, u8 *addr)
+{
+        struct gbe_priv *gbe_dev = gbe_intf->gbe_dev;
+        u16 vlan_id;
+
+        cpsw_ale_del_ucast(gbe_dev->ale, addr, gbe_dev->host_port, 0, 0);
+
+        for_each_set_bit(vlan_id, gbe_intf->active_vlans, VLAN_N_VID) {
+                cpsw_ale_del_ucast(gbe_dev->ale, addr, gbe_dev->host_port,
+                                   ALE_VLAN, vlan_id);
+        }
+}
+
+static int gbe_add_addr(void *intf_priv, struct netcp_addr *naddr)
+{
+        struct gbe_intf *gbe_intf = intf_priv;
+        struct gbe_priv *gbe_dev = gbe_intf->gbe_dev;
+
+        dev_dbg(gbe_dev->dev, "ethss adding address %pM, type %d\n",
+                naddr->addr, naddr->type);
+
+        switch (naddr->type) {
+        case ADDR_MCAST:
+        case ADDR_BCAST:
+                gbe_add_mcast_addr(gbe_intf, naddr->addr);
+                break;
+        case ADDR_UCAST:
+        case ADDR_DEV:
+                gbe_add_ucast_addr(gbe_intf, naddr->addr);
+                break;
+        case ADDR_ANY:
+                /* nothing to do for promiscuous */
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+static int gbe_del_addr(void *intf_priv, struct netcp_addr *naddr)
+{
+        struct gbe_intf *gbe_intf = intf_priv;
+        struct gbe_priv *gbe_dev = gbe_intf->gbe_dev;
+
+        dev_dbg(gbe_dev->dev, "ethss deleting address %pM, type %d\n",
+                naddr->addr, naddr->type);
+
+        switch (naddr->type) {
+        case ADDR_MCAST:
+        case ADDR_BCAST:
+                gbe_del_mcast_addr(gbe_intf, naddr->addr);
+                break;
+        case ADDR_UCAST:
+        case ADDR_DEV:
+                gbe_del_ucast_addr(gbe_intf, naddr->addr);
+                break;
+        case ADDR_ANY:
+                /* nothing to do for promiscuous */
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+static int gbe_add_vid(void *intf_priv, int vid)
+{
+        struct gbe_intf *gbe_intf = intf_priv;
+        struct gbe_priv *gbe_dev = gbe_intf->gbe_dev;
+
+        set_bit(vid, gbe_intf->active_vlans);
+
+        cpsw_ale_add_vlan(gbe_dev->ale, vid,
+                          GBE_PORT_MASK(gbe_dev->ale_ports),
+                          GBE_MASK_NO_PORTS,
+                          GBE_PORT_MASK(gbe_dev->ale_ports),
+                          GBE_PORT_MASK(gbe_dev->ale_ports - 1));
+
+        return 0;
+}
+
+static int gbe_del_vid(void *intf_priv, int vid)
+{
+        struct gbe_intf *gbe_intf = intf_priv;
+        struct gbe_priv *gbe_dev = gbe_intf->gbe_dev;
+
+        cpsw_ale_del_vlan(gbe_dev->ale, vid, 0);
+        clear_bit(vid, gbe_intf->active_vlans);
+        return 0;
+}
+
+static int gbe_ioctl(void *intf_priv, struct ifreq *req, int cmd)
+{
+        struct gbe_intf *gbe_intf = intf_priv;
+        struct phy_device *phy = gbe_intf->slave->phy;
+        int ret = -EOPNOTSUPP;
+
+        if (phy)
+                ret = phy_mii_ioctl(phy, req, cmd);
+
+        return ret;
+}
+
+static void netcp_ethss_timer(unsigned long arg)
+{
+        struct gbe_priv *gbe_dev = (struct gbe_priv *)arg;
+        struct gbe_intf *gbe_intf;
+        struct gbe_slave *slave;
+
+        /* Check & update SGMII link state of interfaces */
+        for_each_intf(gbe_intf, gbe_dev) {
+                if (!gbe_intf->slave->open)
+                        continue;
+                netcp_ethss_update_link_state(gbe_dev, gbe_intf->slave,
+                                              gbe_intf->ndev);
+        }
+
+        /* Check & update SGMII link state of secondary ports */
+        for_each_sec_slave(slave, gbe_dev) {
+                netcp_ethss_update_link_state(gbe_dev, slave, NULL);
+        }
+
+        spin_lock_bh(&gbe_dev->hw_stats_lock);
+
+        if (gbe_dev->ss_version == GBE_SS_VERSION_14)
+                gbe_update_stats_ver14(gbe_dev, NULL);
+        else
+                gbe_update_stats(gbe_dev, NULL);
+
+        spin_unlock_bh(&gbe_dev->hw_stats_lock);
+
+        gbe_dev->timer.expires  = jiffies + GBE_TIMER_INTERVAL;
+        add_timer(&gbe_dev->timer);
+}
+
+static int gbe_tx_hook(int order, void *data, struct netcp_packet *p_info)
+{
+        struct gbe_intf *gbe_intf = data;
+
+        p_info->tx_pipe = &gbe_intf->tx_pipe;
+        return 0;
+}
+
+static int gbe_open(void *intf_priv, struct net_device *ndev)
+{
+        struct gbe_intf *gbe_intf = intf_priv;
+        struct gbe_priv *gbe_dev = gbe_intf->gbe_dev;
+        struct netcp_intf *netcp = netdev_priv(ndev);
+        struct gbe_slave *slave = gbe_intf->slave;
+        int port_num = slave->port_num;
+        u32 reg;
+        int ret;
+
+        reg = readl(GBE_REG_ADDR(gbe_dev, switch_regs, id_ver));
+        dev_dbg(gbe_dev->dev, "initializing gbe version %d.%d (%d) GBE identification value 0x%x\n",
+                GBE_MAJOR_VERSION(reg), GBE_MINOR_VERSION(reg),
+                GBE_RTL_VERSION(reg), GBE_IDENT(reg));
+
+        if (gbe_dev->enable_ale)
+                gbe_intf->tx_pipe.dma_psflags = 0;
+        else
+                gbe_intf->tx_pipe.dma_psflags = port_num;
+
+        dev_dbg(gbe_dev->dev, "opened TX channel %s: %p with psflags %d\n",
+                gbe_intf->tx_pipe.dma_chan_name,
+                gbe_intf->tx_pipe.dma_channel,
+                gbe_intf->tx_pipe.dma_psflags);
+
+        gbe_slave_stop(gbe_intf);
+
+        /* disable priority elevation and enable statistics on all ports */
+        writel(0, GBE_REG_ADDR(gbe_dev, switch_regs, ptype));
+
+        /* Control register */
+        writel(GBE_CTL_P0_ENABLE, GBE_REG_ADDR(gbe_dev, switch_regs, control));
+
+        /* All statistics enabled and STAT AB visible by default */
+        writel(GBE_REG_VAL_STAT_ENABLE_ALL, GBE_REG_ADDR(gbe_dev, switch_regs,
+                                                         stat_port_en));
+
+        ret = gbe_slave_open(gbe_intf);
+        if (ret)
+                goto fail;
+
+        netcp_register_txhook(netcp, GBE_TXHOOK_ORDER, gbe_tx_hook,
+                              gbe_intf);
+
+        slave->open = true;
+        netcp_ethss_update_link_state(gbe_dev, slave, ndev);
+        return 0;
+
+fail:
+        gbe_slave_stop(gbe_intf);
+        return ret;
+}
+
+static int gbe_close(void *intf_priv, struct net_device *ndev)
+{
+        struct gbe_intf *gbe_intf = intf_priv;
+        struct netcp_intf *netcp = netdev_priv(ndev);
+
+        gbe_slave_stop(gbe_intf);
+        netcp_unregister_txhook(netcp, GBE_TXHOOK_ORDER, gbe_tx_hook,
+                                gbe_intf);
+
+        gbe_intf->slave->open = false;
+        atomic_set(&gbe_intf->slave->link_state, NETCP_LINK_STATE_INVALID);
+        return 0;
+}
+
+static int init_slave(struct gbe_priv *gbe_dev, struct gbe_slave *slave,
+                      struct device_node *node)
+{
+        int port_reg_num;
+        u32 port_reg_ofs, emac_reg_ofs;
+
+        if (of_property_read_u32(node, "slave-port", &slave->slave_num)) {
+                dev_err(gbe_dev->dev, "missing slave-port parameter\n");
+                return -EINVAL;
+        }
+
+        if (of_property_read_u32(node, "link-interface",
+                                 &slave->link_interface)) {
+                dev_warn(gbe_dev->dev,
+                         "missing link-interface value defaulting to 1G mac-phy link\n");
+                slave->link_interface = SGMII_LINK_MAC_PHY;
+        }
+
+        slave->open = false;
+        slave->phy_node = of_parse_phandle(node, "phy-handle", 0);
+        slave->port_num = gbe_get_slave_port(gbe_dev, slave->slave_num);
+
+        if (slave->link_interface >= XGMII_LINK_MAC_PHY)
+                slave->mac_control = GBE_DEF_10G_MAC_CONTROL;
+        else
+                slave->mac_control = GBE_DEF_1G_MAC_CONTROL;
+
+        /* Emac regs memmap are contiguous but port regs are not */
+        port_reg_num = slave->slave_num;
+        if (gbe_dev->ss_version == GBE_SS_VERSION_14) {
+                if (slave->slave_num > 1) {
+                        port_reg_ofs = GBE13_SLAVE_PORT2_OFFSET;
+                        port_reg_num -= 2;
+                } else {
+                        port_reg_ofs = GBE13_SLAVE_PORT_OFFSET;
+                }
+        } else if (gbe_dev->ss_version == XGBE_SS_VERSION_10) {
+                port_reg_ofs = XGBE10_SLAVE_PORT_OFFSET;
+        } else {
+                dev_err(gbe_dev->dev, "unknown ethss(0x%x)\n",
+                        gbe_dev->ss_version);
+                return -EINVAL;
+        }
+
+        if (gbe_dev->ss_version == GBE_SS_VERSION_14)
+                emac_reg_ofs = GBE13_EMAC_OFFSET;
+        else if (gbe_dev->ss_version == XGBE_SS_VERSION_10)
+                emac_reg_ofs = XGBE10_EMAC_OFFSET;
+
+        slave->port_regs = gbe_dev->ss_regs + port_reg_ofs +
+                                (0x30 * port_reg_num);
+        slave->emac_regs = gbe_dev->ss_regs + emac_reg_ofs +
+                                (0x40 * slave->slave_num);
+
+        if (gbe_dev->ss_version == GBE_SS_VERSION_14) {
+                /* Initialize  slave port register offsets */
+                GBE_SET_REG_OFS(slave, port_regs, port_vlan);
+                GBE_SET_REG_OFS(slave, port_regs, tx_pri_map);
+                GBE_SET_REG_OFS(slave, port_regs, sa_lo);
+                GBE_SET_REG_OFS(slave, port_regs, sa_hi);
+                GBE_SET_REG_OFS(slave, port_regs, ts_ctl);
+                GBE_SET_REG_OFS(slave, port_regs, ts_seq_ltype);
+                GBE_SET_REG_OFS(slave, port_regs, ts_vlan);
+                GBE_SET_REG_OFS(slave, port_regs, ts_ctl_ltype2);
+                GBE_SET_REG_OFS(slave, port_regs, ts_ctl2);
+
+                /* Initialize EMAC register offsets */
+                GBE_SET_REG_OFS(slave, emac_regs, mac_control);
+                GBE_SET_REG_OFS(slave, emac_regs, soft_reset);
+                GBE_SET_REG_OFS(slave, emac_regs, rx_maxlen);
+
+        } else if (gbe_dev->ss_version == XGBE_SS_VERSION_10) {
+                /* Initialize  slave port register offsets */
+                XGBE_SET_REG_OFS(slave, port_regs, port_vlan);
+                XGBE_SET_REG_OFS(slave, port_regs, tx_pri_map);
+                XGBE_SET_REG_OFS(slave, port_regs, sa_lo);
+                XGBE_SET_REG_OFS(slave, port_regs, sa_hi);
+                XGBE_SET_REG_OFS(slave, port_regs, ts_ctl);
+                XGBE_SET_REG_OFS(slave, port_regs, ts_seq_ltype);
+                XGBE_SET_REG_OFS(slave, port_regs, ts_vlan);
+                XGBE_SET_REG_OFS(slave, port_regs, ts_ctl_ltype2);
+                XGBE_SET_REG_OFS(slave, port_regs, ts_ctl2);
+
+                /* Initialize EMAC register offsets */
+                XGBE_SET_REG_OFS(slave, emac_regs, mac_control);
+                XGBE_SET_REG_OFS(slave, emac_regs, soft_reset);
+                XGBE_SET_REG_OFS(slave, emac_regs, rx_maxlen);
+        }
+
+        atomic_set(&slave->link_state, NETCP_LINK_STATE_INVALID);
+        return 0;
+}
+
+static void init_secondary_ports(struct gbe_priv *gbe_dev,
+                                 struct device_node *node)
+{
+        struct device *dev = gbe_dev->dev;
+        phy_interface_t phy_mode;
+        struct gbe_priv **priv;
+        struct device_node *port;
+        struct gbe_slave *slave;
+        bool mac_phy_link = false;
+
+        for_each_child_of_node(node, port) {
+                slave = devm_kzalloc(dev, sizeof(*slave), GFP_KERNEL);
+                if (!slave) {
+                        dev_err(dev,
+                                "memomry alloc failed for secondary port(%s), skipping...\n",
+                                port->name);
+                        continue;
+                }
+
+                if (init_slave(gbe_dev, slave, port)) {
+                        dev_err(dev,
+                                "Failed to initialize secondary port(%s), skipping...\n",
+                                port->name);
+                        devm_kfree(dev, slave);
+                        continue;
+                }
+
+                gbe_sgmii_config(gbe_dev, slave);
+                gbe_port_reset(slave);
+                gbe_port_config(gbe_dev, slave, gbe_dev->rx_packet_max);
+                list_add_tail(&slave->slave_list, &gbe_dev->secondary_slaves);
+                gbe_dev->num_slaves++;
+                if ((slave->link_interface == SGMII_LINK_MAC_PHY) ||
+                    (slave->link_interface == XGMII_LINK_MAC_PHY))
+                        mac_phy_link = true;
+
+                slave->open = true;
+        }
+
+        /* of_phy_connect() is needed only for MAC-PHY interface */
+        if (!mac_phy_link)
+                return;
+
+        /* Allocate dummy netdev device for attaching to phy device */
+        gbe_dev->dummy_ndev = alloc_netdev(sizeof(gbe_dev), "dummy",
+                                        NET_NAME_UNKNOWN, ether_setup);
+        if (!gbe_dev->dummy_ndev) {
+                dev_err(dev,
+                        "Failed to allocate dummy netdev for secondary ports, skipping phy_connect()...\n");
+                return;
+        }
+        priv = netdev_priv(gbe_dev->dummy_ndev);
+        *priv = gbe_dev;
+
+        if (slave->link_interface == SGMII_LINK_MAC_PHY) {
+                phy_mode = PHY_INTERFACE_MODE_SGMII;
+                slave->phy_port_t = PORT_MII;
+        } else {
+                phy_mode = PHY_INTERFACE_MODE_NA;
+                slave->phy_port_t = PORT_FIBRE;
+        }
+
+        for_each_sec_slave(slave, gbe_dev) {
+                if ((slave->link_interface != SGMII_LINK_MAC_PHY) &&
+                    (slave->link_interface != XGMII_LINK_MAC_PHY))
+                        continue;
+                slave->phy =
+                        of_phy_connect(gbe_dev->dummy_ndev,
+                                       slave->phy_node,
+                                       gbe_adjust_link_sec_slaves,
+                                       0, phy_mode);
+                if (!slave->phy) {
+                        dev_err(dev, "phy not found for slave %d\n",
+                                slave->slave_num);
+                        slave->phy = NULL;
+                } else {
+                        dev_dbg(dev, "phy found: id is: 0x%s\n",
+                                dev_name(&slave->phy->dev));
+                        phy_start(slave->phy);
+                        phy_read_status(slave->phy);
+                }
+        }
+}
+
+static void free_secondary_ports(struct gbe_priv *gbe_dev)
+{
+        struct gbe_slave *slave;
+
+        for (;;) {
+                slave = first_sec_slave(gbe_dev);
+                if (!slave)
+                        break;
+                if (slave->phy)
+                        phy_disconnect(slave->phy);
+                list_del(&slave->slave_list);
+        }
+        if (gbe_dev->dummy_ndev)
+                free_netdev(gbe_dev->dummy_ndev);
+}
+
+static int set_xgbe_ethss10_priv(struct gbe_priv *gbe_dev,
+                                 struct device_node *node)
+{
+        struct resource res;
+        void __iomem *regs;
+        int ret, i;
+
+        ret = of_address_to_resource(node, 0, &res);
+        if (ret) {
+                dev_err(gbe_dev->dev, "Can't translate of node(%s) address for xgbe subsystem regs\n",
+                        node->name);
+                return ret;
+        }
+
+        regs = devm_ioremap_resource(gbe_dev->dev, &res);
+        if (IS_ERR(regs)) {
+                dev_err(gbe_dev->dev, "Failed to map xgbe register base\n");
+                return PTR_ERR(regs);
+        }
+        gbe_dev->ss_regs = regs;
+
+        ret = of_address_to_resource(node, XGBE_SERDES_REG_INDEX, &res);
+        if (ret) {
+                dev_err(gbe_dev->dev, "Can't translate of node(%s) address for xgbe serdes regs\n",
+                        node->name);
+                return ret;
+        }
+
+        regs = devm_ioremap_resource(gbe_dev->dev, &res);
+        if (IS_ERR(regs)) {
+                dev_err(gbe_dev->dev, "Failed to map xgbe serdes register base\n");
+                return PTR_ERR(regs);
+        }
+        gbe_dev->xgbe_serdes_regs = regs;
+
+        gbe_dev->hw_stats = devm_kzalloc(gbe_dev->dev,
+                                          XGBE10_NUM_STAT_ENTRIES *
+                                          (XGBE10_NUM_SLAVES + 1) * sizeof(u64),
+                                          GFP_KERNEL);
+        if (!gbe_dev->hw_stats) {
+                dev_err(gbe_dev->dev, "hw_stats memory allocation failed\n");
+                return -ENOMEM;
+        }
+
+        gbe_dev->ss_version = XGBE_SS_VERSION_10;
+        gbe_dev->sgmii_port_regs = gbe_dev->ss_regs +
+                                        XGBE10_SGMII_MODULE_OFFSET;
+        gbe_dev->switch_regs = gbe_dev->ss_regs + XGBE10_SWITCH_MODULE_OFFSET;
+        gbe_dev->host_port_regs = gbe_dev->ss_regs + XGBE10_HOST_PORT_OFFSET;
+
+        for (i = 0; i < XGBE10_NUM_HW_STATS_MOD; i++)
+                gbe_dev->hw_stats_regs[i] = gbe_dev->ss_regs +
+                        XGBE10_HW_STATS_OFFSET + (GBE_HW_STATS_REG_MAP_SZ * i);
+
+        gbe_dev->ale_reg = gbe_dev->ss_regs + XGBE10_ALE_OFFSET;
+        gbe_dev->ale_ports = XGBE10_NUM_ALE_PORTS;
+        gbe_dev->host_port = XGBE10_HOST_PORT_NUM;
+        gbe_dev->ale_entries = XGBE10_NUM_ALE_ENTRIES;
+        gbe_dev->et_stats = xgbe10_et_stats;
+        gbe_dev->num_et_stats = ARRAY_SIZE(xgbe10_et_stats);
+
+        /* Subsystem registers */
+        XGBE_SET_REG_OFS(gbe_dev, ss_regs, id_ver);
+        XGBE_SET_REG_OFS(gbe_dev, ss_regs, control);
+
+        /* Switch module registers */
+        XGBE_SET_REG_OFS(gbe_dev, switch_regs, id_ver);
+        XGBE_SET_REG_OFS(gbe_dev, switch_regs, control);
+        XGBE_SET_REG_OFS(gbe_dev, switch_regs, ptype);
+        XGBE_SET_REG_OFS(gbe_dev, switch_regs, stat_port_en);
+        XGBE_SET_REG_OFS(gbe_dev, switch_regs, flow_control);
+
+        /* Host port registers */
+        XGBE_SET_REG_OFS(gbe_dev, host_port_regs, port_vlan);
+        XGBE_SET_REG_OFS(gbe_dev, host_port_regs, tx_pri_map);
+        XGBE_SET_REG_OFS(gbe_dev, host_port_regs, rx_maxlen);
+        return 0;
+}
+
+static int get_gbe_resource_version(struct gbe_priv *gbe_dev,
+                                    struct device_node *node)
+{
+        struct resource res;
+        void __iomem *regs;
+        int ret;
+
+        ret = of_address_to_resource(node, 0, &res);
+        if (ret) {
+                dev_err(gbe_dev->dev, "Can't translate of node(%s) address\n",
+                        node->name);
+                return ret;
+        }
+
+        regs = devm_ioremap_resource(gbe_dev->dev, &res);
+        if (IS_ERR(regs)) {
+                dev_err(gbe_dev->dev, "Failed to map gbe register base\n");
+                return PTR_ERR(regs);
+        }
+        gbe_dev->ss_regs = regs;
+        gbe_dev->ss_version = readl(gbe_dev->ss_regs);
+        return 0;
+}
+
+static int set_gbe_ethss14_priv(struct gbe_priv *gbe_dev,
+                                struct device_node *node)
+{
+        void __iomem *regs;
+        int i;
+
+        gbe_dev->hw_stats = devm_kzalloc(gbe_dev->dev,
+                                          GBE13_NUM_HW_STAT_ENTRIES *
+                                          GBE13_NUM_SLAVES * sizeof(u64),
+                                          GFP_KERNEL);
+        if (!gbe_dev->hw_stats) {
+                dev_err(gbe_dev->dev, "hw_stats memory allocation failed\n");
+                return -ENOMEM;
+        }
+
+        regs = gbe_dev->ss_regs;
+        gbe_dev->sgmii_port_regs = regs + GBE13_SGMII_MODULE_OFFSET;
+        gbe_dev->sgmii_port34_regs = regs + GBE13_SGMII34_MODULE_OFFSET;
+        gbe_dev->switch_regs = regs + GBE13_SWITCH_MODULE_OFFSET;
+        gbe_dev->host_port_regs = regs + GBE13_HOST_PORT_OFFSET;
+
+        for (i = 0; i < GBE13_NUM_HW_STATS_MOD; i++)
+                gbe_dev->hw_stats_regs[i] = regs + GBE13_HW_STATS_OFFSET +
+                                (GBE_HW_STATS_REG_MAP_SZ * i);
+
+        gbe_dev->ale_reg = regs + GBE13_ALE_OFFSET;
+        gbe_dev->ale_ports = GBE13_NUM_ALE_PORTS;
+        gbe_dev->host_port = GBE13_HOST_PORT_NUM;
+        gbe_dev->ale_entries = GBE13_NUM_ALE_ENTRIES;
+        gbe_dev->et_stats = gbe13_et_stats;
+        gbe_dev->num_et_stats = ARRAY_SIZE(gbe13_et_stats);
+
+        /* Subsystem registers */
+        GBE_SET_REG_OFS(gbe_dev, ss_regs, id_ver);
+
+        /* Switch module registers */
+        GBE_SET_REG_OFS(gbe_dev, switch_regs, id_ver);
+        GBE_SET_REG_OFS(gbe_dev, switch_regs, control);
+        GBE_SET_REG_OFS(gbe_dev, switch_regs, soft_reset);
+        GBE_SET_REG_OFS(gbe_dev, switch_regs, stat_port_en);
+        GBE_SET_REG_OFS(gbe_dev, switch_regs, ptype);
+        GBE_SET_REG_OFS(gbe_dev, switch_regs, flow_control);
+
+        /* Host port registers */
+        GBE_SET_REG_OFS(gbe_dev, host_port_regs, port_vlan);
+        GBE_SET_REG_OFS(gbe_dev, host_port_regs, rx_maxlen);
+        return 0;
+}
+
+static int gbe_probe(struct netcp_device *netcp_device, struct device *dev,
+                     struct device_node *node, void **inst_priv)
+{
+        struct device_node *interfaces, *interface;
+        struct device_node *secondary_ports;
+        struct cpsw_ale_params ale_params;
+        struct gbe_priv *gbe_dev;
+        u32 slave_num;
+        int ret = 0;
+
+        if (!node) {
+                dev_err(dev, "device tree info unavailable\n");
+                return -ENODEV;
+        }
+
+        gbe_dev = devm_kzalloc(dev, sizeof(struct gbe_priv), GFP_KERNEL);
+        if (!gbe_dev)
+                return -ENOMEM;
+
+        gbe_dev->dev = dev;
+        gbe_dev->netcp_device = netcp_device;
+        gbe_dev->rx_packet_max = NETCP_MAX_FRAME_SIZE;
+
+        /* init the hw stats lock */
+        spin_lock_init(&gbe_dev->hw_stats_lock);
+
+        if (of_find_property(node, "enable-ale", NULL)) {
+                gbe_dev->enable_ale = true;
+                dev_info(dev, "ALE enabled\n");
+        } else {
+                gbe_dev->enable_ale = false;
+                dev_dbg(dev, "ALE bypass enabled*\n");
+        }
+
+        ret = of_property_read_u32(node, "tx-queue",
+                                   &gbe_dev->tx_queue_id);
+        if (ret < 0) {
+                dev_err(dev, "missing tx_queue parameter\n");
+                gbe_dev->tx_queue_id = GBE_TX_QUEUE;
+        }
+
+        ret = of_property_read_string(node, "tx-channel",
+                                      &gbe_dev->dma_chan_name);
+        if (ret < 0) {
+                dev_err(dev, "missing \"tx-channel\" parameter\n");
+                ret = -ENODEV;
+                goto quit;
+        }
+
+        if (!strcmp(node->name, "gbe")) {
+                ret = get_gbe_resource_version(gbe_dev, node);
+                if (ret)
+                        goto quit;
+
+                ret = set_gbe_ethss14_priv(gbe_dev, node);
+                if (ret)
+                        goto quit;
+        } else if (!strcmp(node->name, "xgbe")) {
+                ret = set_xgbe_ethss10_priv(gbe_dev, node);
+                if (ret)
+                        goto quit;
+                ret = netcp_xgbe_serdes_init(gbe_dev->xgbe_serdes_regs,
+                                             gbe_dev->ss_regs);
+                if (ret)
+                        goto quit;
+        } else {
+                dev_err(dev, "unknown GBE node(%s)\n", node->name);
+                ret = -ENODEV;
+                goto quit;
+        }
+
+        interfaces = of_get_child_by_name(node, "interfaces");
+        if (!interfaces)
+                dev_err(dev, "could not find interfaces\n");
+
+        ret = netcp_txpipe_init(&gbe_dev->tx_pipe, netcp_device,
+                                gbe_dev->dma_chan_name, gbe_dev->tx_queue_id);
+        if (ret)
+                goto quit;
+
+        ret = netcp_txpipe_open(&gbe_dev->tx_pipe);
+        if (ret)
+                goto quit;
+
+        /* Create network interfaces */
+        INIT_LIST_HEAD(&gbe_dev->gbe_intf_head);
+        for_each_child_of_node(interfaces, interface) {
+                ret = of_property_read_u32(interface, "slave-port", &slave_num);
+                if (ret) {
+                        dev_err(dev, "missing slave-port parameter, skipping interface configuration for %s\n",
+                                interface->name);
+                        continue;
+                }
+                gbe_dev->num_slaves++;
+        }
+
+        if (!gbe_dev->num_slaves)
+                dev_warn(dev, "No network interface configured\n");
+
+        /* Initialize Secondary slave ports */
+        secondary_ports = of_get_child_by_name(node, "secondary-slave-ports");
+        INIT_LIST_HEAD(&gbe_dev->secondary_slaves);
+        if (secondary_ports)
+                init_secondary_ports(gbe_dev, secondary_ports);
+        of_node_put(secondary_ports);
+
+        if (!gbe_dev->num_slaves) {
+                dev_err(dev, "No network interface or secondary ports configured\n");
+                ret = -ENODEV;
+                goto quit;
+        }
+
+        memset(&ale_params, 0, sizeof(ale_params));
+        ale_params.dev          = gbe_dev->dev;
+        ale_params.ale_regs     = gbe_dev->ale_reg;
+        ale_params.ale_ageout   = GBE_DEFAULT_ALE_AGEOUT;
+        ale_params.ale_entries  = gbe_dev->ale_entries;
+        ale_params.ale_ports    = gbe_dev->ale_ports;
+
+        gbe_dev->ale = cpsw_ale_create(&ale_params);
+        if (!gbe_dev->ale) {
+                dev_err(gbe_dev->dev, "error initializing ale engine\n");
+                ret = -ENODEV;
+                goto quit;
+        } else {
+                dev_dbg(gbe_dev->dev, "Created a gbe ale engine\n");
+        }
+
+        /* initialize host port */
+        gbe_init_host_port(gbe_dev);
+
+        init_timer(&gbe_dev->timer);
+        gbe_dev->timer.data      = (unsigned long)gbe_dev;
+        gbe_dev->timer.function = netcp_ethss_timer;
+        gbe_dev->timer.expires   = jiffies + GBE_TIMER_INTERVAL;
+        add_timer(&gbe_dev->timer);
+        *inst_priv = gbe_dev;
+        return 0;
+
+quit:
+        if (gbe_dev->hw_stats)
+                devm_kfree(dev, gbe_dev->hw_stats);
+        cpsw_ale_destroy(gbe_dev->ale);
+        if (gbe_dev->ss_regs)
+                devm_iounmap(dev, gbe_dev->ss_regs);
+        of_node_put(interfaces);
+        devm_kfree(dev, gbe_dev);
+        return ret;
+}
+
+static int gbe_attach(void *inst_priv, struct net_device *ndev,
+                      struct device_node *node, void **intf_priv)
+{
+        struct gbe_priv *gbe_dev = inst_priv;
+        struct gbe_intf *gbe_intf;
+        int ret;
+
+        if (!node) {
+                dev_err(gbe_dev->dev, "interface node not available\n");
+                return -ENODEV;
+        }
+
+        gbe_intf = devm_kzalloc(gbe_dev->dev, sizeof(*gbe_intf), GFP_KERNEL);
+        if (!gbe_intf)
+                return -ENOMEM;
+
+        gbe_intf->ndev = ndev;
+        gbe_intf->dev = gbe_dev->dev;
+        gbe_intf->gbe_dev = gbe_dev;
+
+        gbe_intf->slave = devm_kzalloc(gbe_dev->dev,
+                                        sizeof(*gbe_intf->slave),
+                                        GFP_KERNEL);
+        if (!gbe_intf->slave) {
+                ret = -ENOMEM;
+                goto fail;
+        }
+
+        if (init_slave(gbe_dev, gbe_intf->slave, node)) {
+                ret = -ENODEV;
+                goto fail;
+        }
+
+        gbe_intf->tx_pipe = gbe_dev->tx_pipe;
+        ndev->ethtool_ops = &keystone_ethtool_ops;
+        list_add_tail(&gbe_intf->gbe_intf_list, &gbe_dev->gbe_intf_head);
+        *intf_priv = gbe_intf;
+        return 0;
+
+fail:
+        if (gbe_intf->slave)
+                devm_kfree(gbe_dev->dev, gbe_intf->slave);
+        if (gbe_intf)
+                devm_kfree(gbe_dev->dev, gbe_intf);
+        return ret;
+}
+
+static int gbe_release(void *intf_priv)
+{
+        struct gbe_intf *gbe_intf = intf_priv;
+
+        gbe_intf->ndev->ethtool_ops = NULL;
+        list_del(&gbe_intf->gbe_intf_list);
+        devm_kfree(gbe_intf->dev, gbe_intf->slave);
+        devm_kfree(gbe_intf->dev, gbe_intf);
+        return 0;
+}
+
+static int gbe_remove(struct netcp_device *netcp_device, void *inst_priv)
+{
+        struct gbe_priv *gbe_dev = inst_priv;
+
+        del_timer_sync(&gbe_dev->timer);
+        cpsw_ale_stop(gbe_dev->ale);
+        cpsw_ale_destroy(gbe_dev->ale);
+        netcp_txpipe_close(&gbe_dev->tx_pipe);
+        free_secondary_ports(gbe_dev);
+
+        if (!list_empty(&gbe_dev->gbe_intf_head))
+                dev_alert(gbe_dev->dev, "unreleased ethss interfaces present\n");
+
+        devm_kfree(gbe_dev->dev, gbe_dev->hw_stats);
+        devm_iounmap(gbe_dev->dev, gbe_dev->ss_regs);
+        memset(gbe_dev, 0x00, sizeof(*gbe_dev));
+        devm_kfree(gbe_dev->dev, gbe_dev);
+        return 0;
+}
+
+static struct netcp_module gbe_module = {
+        .name           = GBE_MODULE_NAME,
+        .owner          = THIS_MODULE,
+        .primary        = true,
+        .probe          = gbe_probe,
+        .open           = gbe_open,
+        .close          = gbe_close,
+        .remove         = gbe_remove,
+        .attach         = gbe_attach,
+        .release        = gbe_release,
+        .add_addr       = gbe_add_addr,
+        .del_addr       = gbe_del_addr,
+        .add_vid        = gbe_add_vid,
+        .del_vid        = gbe_del_vid,
+        .ioctl          = gbe_ioctl,
+};
+
+static struct netcp_module xgbe_module = {
+        .name           = XGBE_MODULE_NAME,
+        .owner          = THIS_MODULE,
+        .primary        = true,
+        .probe          = gbe_probe,
+        .open           = gbe_open,
+        .close          = gbe_close,
+        .remove         = gbe_remove,
+        .attach         = gbe_attach,
+        .release        = gbe_release,
+        .add_addr       = gbe_add_addr,
+        .del_addr       = gbe_del_addr,
+        .add_vid        = gbe_add_vid,
+        .del_vid        = gbe_del_vid,
+        .ioctl          = gbe_ioctl,
+};
+
+static int __init keystone_gbe_init(void)
+{
+        int ret;
+
+        ret = netcp_register_module(&gbe_module);
+        if (ret)
+                return ret;
+
+        ret = netcp_register_module(&xgbe_module);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+module_init(keystone_gbe_init);
+
+static void __exit keystone_gbe_exit(void)
+{
+        netcp_unregister_module(&gbe_module);
+        netcp_unregister_module(&xgbe_module);
+}
+module_exit(keystone_gbe_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("TI NETCP ETHSS driver for Keystone SOCs");
+MODULE_AUTHOR("Sandeep Nair <sandeep_n@ti.com");
diff --git a/drivers/net/ethernet/ti/netcp_sgmii.c b/drivers/net/ethernet/ti/netcp_sgmii.c
new file mode 100644
index 000000000000..dbeb14266e2f
--- /dev/null
+++ b/drivers/net/ethernet/ti/netcp_sgmii.c
@@ -0,0 +1,131 @@
+/*
+ * SGMI module initialisation
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated
+ * Authors:     Sandeep Nair <sandeep_n@ti.com>
+ *              Sandeep Paulraj <s-paulraj@ti.com>
+ *              Wingman Kwok <w-kwok2@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "netcp.h"
+
+#define SGMII_REG_STATUS_LOCK           BIT(4)
+#define SGMII_REG_STATUS_LINK           BIT(0)
+#define SGMII_REG_STATUS_AUTONEG        BIT(2)
+#define SGMII_REG_CONTROL_AUTONEG       BIT(0)
+
+#define SGMII23_OFFSET(x)       ((x - 2) * 0x100)
+#define SGMII_OFFSET(x)         ((x <= 1) ? (x * 0x100) : (SGMII23_OFFSET(x)))
+
+/* SGMII registers */
+#define SGMII_SRESET_REG(x)   (SGMII_OFFSET(x) + 0x004)
+#define SGMII_CTL_REG(x)      (SGMII_OFFSET(x) + 0x010)
+#define SGMII_STATUS_REG(x)   (SGMII_OFFSET(x) + 0x014)
+#define SGMII_MRADV_REG(x)    (SGMII_OFFSET(x) + 0x018)
+
+static void sgmii_write_reg(void __iomem *base, int reg, u32 val)
+{
+        writel(val, base + reg);
+}
+
+static u32 sgmii_read_reg(void __iomem *base, int reg)
+{
+        return readl(base + reg);
+}
+
+static void sgmii_write_reg_bit(void __iomem *base, int reg, u32 val)
+{
+        writel((readl(base + reg) | val), base + reg);
+}
+
+/* port is 0 based */
+int netcp_sgmii_reset(void __iomem *sgmii_ofs, int port)
+{
+        /* Soft reset */
+        sgmii_write_reg_bit(sgmii_ofs, SGMII_SRESET_REG(port), 0x1);
+        while (sgmii_read_reg(sgmii_ofs, SGMII_SRESET_REG(port)) != 0x0)
+                ;
+        return 0;
+}
+
+int netcp_sgmii_get_port_link(void __iomem *sgmii_ofs, int port)
+{
+        u32 status = 0, link = 0;
+
+        status = sgmii_read_reg(sgmii_ofs, SGMII_STATUS_REG(port));
+        if ((status & SGMII_REG_STATUS_LINK) != 0)
+                link = 1;
+        return link;
+}
+
+int netcp_sgmii_config(void __iomem *sgmii_ofs, int port, u32 interface)
+{
+        unsigned int i, status, mask;
+        u32 mr_adv_ability;
+        u32 control;
+
+        switch (interface) {
+        case SGMII_LINK_MAC_MAC_AUTONEG:
+                mr_adv_ability  = 0x9801;
+                control         = 0x21;
+                break;
+
+        case SGMII_LINK_MAC_PHY:
+        case SGMII_LINK_MAC_PHY_NO_MDIO:
+                mr_adv_ability  = 1;
+                control         = 1;
+                break;
+
+        case SGMII_LINK_MAC_MAC_FORCED:
+                mr_adv_ability  = 0x9801;
+                control         = 0x20;
+                break;
+
+        case SGMII_LINK_MAC_FIBER:
+                mr_adv_ability  = 0x20;
+                control         = 0x1;
+                break;
+
+        default:
+                WARN_ONCE(1, "Invalid sgmii interface: %d\n", interface);
+                return -EINVAL;
+        }
+
+        sgmii_write_reg(sgmii_ofs, SGMII_CTL_REG(port), 0);
+
+        /* Wait for the SerDes pll to lock */
+        for (i = 0; i < 1000; i++)  {
+                usleep_range(1000, 2000);
+                status = sgmii_read_reg(sgmii_ofs, SGMII_STATUS_REG(port));
+                if ((status & SGMII_REG_STATUS_LOCK) != 0)
+                        break;
+        }
+
+        if ((status & SGMII_REG_STATUS_LOCK) == 0)
+                pr_err("serdes PLL not locked\n");
+
+        sgmii_write_reg(sgmii_ofs, SGMII_MRADV_REG(port), mr_adv_ability);
+        sgmii_write_reg(sgmii_ofs, SGMII_CTL_REG(port), control);
+
+        mask = SGMII_REG_STATUS_LINK;
+        if (control & SGMII_REG_CONTROL_AUTONEG)
+                mask |= SGMII_REG_STATUS_AUTONEG;
+
+        for (i = 0; i < 1000; i++)  {
+                usleep_range(200, 500);
+                status = sgmii_read_reg(sgmii_ofs, SGMII_STATUS_REG(port));
+                if ((status & mask) == mask)
+                        break;
+        }
+
+        return 0;
+}
diff --git a/drivers/net/ethernet/ti/netcp_xgbepcsr.c b/drivers/net/ethernet/ti/netcp_xgbepcsr.c
new file mode 100644
index 000000000000..33571acc52b6
--- /dev/null
+++ b/drivers/net/ethernet/ti/netcp_xgbepcsr.c
@@ -0,0 +1,501 @@
+/*
+ * XGE PCSR module initialisation
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated
+ * Authors:     Sandeep Nair <sandeep_n@ti.com>
+ *              WingMan Kwok <w-kwok2@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include "netcp.h"
+
+/* XGBE registers */
+#define XGBE_CTRL_OFFSET                0x0c
+#define XGBE_SGMII_1_OFFSET             0x0114
+#define XGBE_SGMII_2_OFFSET             0x0214
+
+/* PCS-R registers */
+#define PCSR_CPU_CTRL_OFFSET            0x1fd0
+#define POR_EN                          BIT(29)
+
+#define reg_rmw(addr, value, mask) \
+        writel(((readl(addr) & (~(mask))) | \
+                        (value & (mask))), (addr))
+
+/* bit mask of width w at offset s */
+#define MASK_WID_SH(w, s)               (((1 << w) - 1) << s)
+
+/* shift value v to offset s */
+#define VAL_SH(v, s)                    (v << s)
+
+#define PHY_A(serdes)                   0
+
+struct serdes_cfg {
+        u32 ofs;
+        u32 val;
+        u32 mask;
+};
+
+static struct serdes_cfg cfg_phyb_1p25g_156p25mhz_cmu0[] = {
+        {0x0000, 0x00800002, 0x00ff00ff},
+        {0x0014, 0x00003838, 0x0000ffff},
+        {0x0060, 0x1c44e438, 0xffffffff},
+        {0x0064, 0x00c18400, 0x00ffffff},
+        {0x0068, 0x17078200, 0xffffff00},
+        {0x006c, 0x00000014, 0x000000ff},
+        {0x0078, 0x0000c000, 0x0000ff00},
+        {0x0000, 0x00000003, 0x000000ff},
+};
+
+static struct serdes_cfg cfg_phyb_10p3125g_156p25mhz_cmu1[] = {
+        {0x0c00, 0x00030002, 0x00ff00ff},
+        {0x0c14, 0x00005252, 0x0000ffff},
+        {0x0c28, 0x80000000, 0xff000000},
+        {0x0c2c, 0x000000f6, 0x000000ff},
+        {0x0c3c, 0x04000405, 0xff00ffff},
+        {0x0c40, 0xc0800000, 0xffff0000},
+        {0x0c44, 0x5a202062, 0xffffffff},
+        {0x0c48, 0x40040424, 0xffffffff},
+        {0x0c4c, 0x00004002, 0x0000ffff},
+        {0x0c50, 0x19001c00, 0xff00ff00},
+        {0x0c54, 0x00002100, 0x0000ff00},
+        {0x0c58, 0x00000060, 0x000000ff},
+        {0x0c60, 0x80131e7c, 0xffffffff},
+        {0x0c64, 0x8400cb02, 0xff00ffff},
+        {0x0c68, 0x17078200, 0xffffff00},
+        {0x0c6c, 0x00000016, 0x000000ff},
+        {0x0c74, 0x00000400, 0x0000ff00},
+        {0x0c78, 0x0000c000, 0x0000ff00},
+        {0x0c00, 0x00000003, 0x000000ff},
+};
+
+static struct serdes_cfg cfg_phyb_10p3125g_16bit_lane[] = {
+        {0x0204, 0x00000080, 0x000000ff},
+        {0x0208, 0x0000920d, 0x0000ffff},
+        {0x0204, 0xfc000000, 0xff000000},
+        {0x0208, 0x00009104, 0x0000ffff},
+        {0x0210, 0x1a000000, 0xff000000},
+        {0x0214, 0x00006b58, 0x00ffffff},
+        {0x0218, 0x75800084, 0xffff00ff},
+        {0x022c, 0x00300000, 0x00ff0000},
+        {0x0230, 0x00003800, 0x0000ff00},
+        {0x024c, 0x008f0000, 0x00ff0000},
+        {0x0250, 0x30000000, 0xff000000},
+        {0x0260, 0x00000002, 0x000000ff},
+        {0x0264, 0x00000057, 0x000000ff},
+        {0x0268, 0x00575700, 0x00ffff00},
+        {0x0278, 0xff000000, 0xff000000},
+        {0x0280, 0x00500050, 0x00ff00ff},
+        {0x0284, 0x00001f15, 0x0000ffff},
+        {0x028c, 0x00006f00, 0x0000ff00},
+        {0x0294, 0x00000000, 0xffffff00},
+        {0x0298, 0x00002640, 0xff00ffff},
+        {0x029c, 0x00000003, 0x000000ff},
+        {0x02a4, 0x00000f13, 0x0000ffff},
+        {0x02a8, 0x0001b600, 0x00ffff00},
+        {0x0380, 0x00000030, 0x000000ff},
+        {0x03c0, 0x00000200, 0x0000ff00},
+        {0x03cc, 0x00000018, 0x000000ff},
+        {0x03cc, 0x00000000, 0x000000ff},
+};
+
+static struct serdes_cfg cfg_phyb_10p3125g_comlane[] = {
+        {0x0a00, 0x00000800, 0x0000ff00},
+        {0x0a84, 0x00000000, 0x000000ff},
+        {0x0a8c, 0x00130000, 0x00ff0000},
+        {0x0a90, 0x77a00000, 0xffff0000},
+        {0x0a94, 0x00007777, 0x0000ffff},
+        {0x0b08, 0x000f0000, 0xffff0000},
+        {0x0b0c, 0x000f0000, 0x00ffffff},
+        {0x0b10, 0xbe000000, 0xff000000},
+        {0x0b14, 0x000000ff, 0x000000ff},
+        {0x0b18, 0x00000014, 0x000000ff},
+        {0x0b5c, 0x981b0000, 0xffff0000},
+        {0x0b64, 0x00001100, 0x0000ff00},
+        {0x0b78, 0x00000c00, 0x0000ff00},
+        {0x0abc, 0xff000000, 0xff000000},
+        {0x0ac0, 0x0000008b, 0x000000ff},
+};
+
+static struct serdes_cfg cfg_cm_c1_c2[] = {
+        {0x0208, 0x00000000, 0x00000f00},
+        {0x0208, 0x00000000, 0x0000001f},
+        {0x0204, 0x00000000, 0x00040000},
+        {0x0208, 0x000000a0, 0x000000e0},
+};
+
+static void netcp_xgbe_serdes_cmu_init(void __iomem *serdes_regs)
+{
+        int i;
+
+        /* cmu0 setup */
+        for (i = 0; i < ARRAY_SIZE(cfg_phyb_1p25g_156p25mhz_cmu0); i++) {
+                reg_rmw(serdes_regs + cfg_phyb_1p25g_156p25mhz_cmu0[i].ofs,
+                        cfg_phyb_1p25g_156p25mhz_cmu0[i].val,
+                        cfg_phyb_1p25g_156p25mhz_cmu0[i].mask);
+        }
+
+        /* cmu1 setup */
+        for (i = 0; i < ARRAY_SIZE(cfg_phyb_10p3125g_156p25mhz_cmu1); i++) {
+                reg_rmw(serdes_regs + cfg_phyb_10p3125g_156p25mhz_cmu1[i].ofs,
+                        cfg_phyb_10p3125g_156p25mhz_cmu1[i].val,
+                        cfg_phyb_10p3125g_156p25mhz_cmu1[i].mask);
+        }
+}
+
+/* lane is 0 based */
+static void netcp_xgbe_serdes_lane_config(
+                        void __iomem *serdes_regs, int lane)
+{
+        int i;
+
+        /* lane setup */
+        for (i = 0; i < ARRAY_SIZE(cfg_phyb_10p3125g_16bit_lane); i++) {
+                reg_rmw(serdes_regs +
+                                cfg_phyb_10p3125g_16bit_lane[i].ofs +
+                                (0x200 * lane),
+                        cfg_phyb_10p3125g_16bit_lane[i].val,
+                        cfg_phyb_10p3125g_16bit_lane[i].mask);
+        }
+
+        /* disable auto negotiation*/
+        reg_rmw(serdes_regs + (0x200 * lane) + 0x0380,
+                0x00000000, 0x00000010);
+
+        /* disable link training */
+        reg_rmw(serdes_regs + (0x200 * lane) + 0x03c0,
+                0x00000000, 0x00000200);
+}
+
+static void netcp_xgbe_serdes_com_enable(void __iomem *serdes_regs)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(cfg_phyb_10p3125g_comlane); i++) {
+                reg_rmw(serdes_regs + cfg_phyb_10p3125g_comlane[i].ofs,
+                        cfg_phyb_10p3125g_comlane[i].val,
+                        cfg_phyb_10p3125g_comlane[i].mask);
+        }
+}
+
+static void netcp_xgbe_serdes_lane_enable(
+                        void __iomem *serdes_regs, int lane)
+{
+        /* Set Lane Control Rate */
+        writel(0xe0e9e038, serdes_regs + 0x1fe0 + (4 * lane));
+}
+
+static void netcp_xgbe_serdes_phyb_rst_clr(void __iomem *serdes_regs)
+{
+        reg_rmw(serdes_regs + 0x0a00, 0x0000001f, 0x000000ff);
+}
+
+static void netcp_xgbe_serdes_pll_disable(void __iomem *serdes_regs)
+{
+        writel(0x88000000, serdes_regs + 0x1ff4);
+}
+
+static void netcp_xgbe_serdes_pll_enable(void __iomem *serdes_regs)
+{
+        netcp_xgbe_serdes_phyb_rst_clr(serdes_regs);
+        writel(0xee000000, serdes_regs + 0x1ff4);
+}
+
+static int netcp_xgbe_wait_pll_locked(void __iomem *sw_regs)
+{
+        unsigned long timeout;
+        int ret = 0;
+        u32 val_1, val_0;
+
+        timeout = jiffies + msecs_to_jiffies(500);
+        do {
+                val_0 = (readl(sw_regs + XGBE_SGMII_1_OFFSET) & BIT(4));
+                val_1 = (readl(sw_regs + XGBE_SGMII_2_OFFSET) & BIT(4));
+
+                if (val_1 && val_0)
+                        return 0;
+
+                if (time_after(jiffies, timeout)) {
+                        ret = -ETIMEDOUT;
+                        break;
+                }
+
+                cpu_relax();
+        } while (true);
+
+        pr_err("XGBE serdes not locked: time out.\n");
+        return ret;
+}
+
+static void netcp_xgbe_serdes_enable_xgmii_port(void __iomem *sw_regs)
+{
+        writel(0x03, sw_regs + XGBE_CTRL_OFFSET);
+}
+
+static u32 netcp_xgbe_serdes_read_tbus_val(void __iomem *serdes_regs)
+{
+        u32 tmp;
+
+        if (PHY_A(serdes_regs)) {
+                tmp  = (readl(serdes_regs + 0x0ec) >> 24) & 0x0ff;
+                tmp |= ((readl(serdes_regs + 0x0fc) >> 16) & 0x00f00);
+        } else {
+                tmp  = (readl(serdes_regs + 0x0f8) >> 16) & 0x0fff;
+        }
+
+        return tmp;
+}
+
+static void netcp_xgbe_serdes_write_tbus_addr(void __iomem *serdes_regs,
+                                              int select, int ofs)
+{
+        if (PHY_A(serdes_regs)) {
+                reg_rmw(serdes_regs + 0x0008, ((select << 5) + ofs) << 24,
+                        ~0x00ffffff);
+                return;
+        }
+
+        /* For 2 lane Phy-B, lane0 is actually lane1 */
+        switch (select) {
+        case 1:
+                select = 2;
+                break;
+        case 2:
+                select = 3;
+                break;
+        default:
+                return;
+        }
+
+        reg_rmw(serdes_regs + 0x00fc, ((select << 8) + ofs) << 16, ~0xf800ffff);
+}
+
+static u32 netcp_xgbe_serdes_read_select_tbus(void __iomem *serdes_regs,
+                                              int select, int ofs)
+{
+        /* Set tbus address */
+        netcp_xgbe_serdes_write_tbus_addr(serdes_regs, select, ofs);
+        /* Get TBUS Value */
+        return netcp_xgbe_serdes_read_tbus_val(serdes_regs);
+}
+
+static void netcp_xgbe_serdes_reset_cdr(void __iomem *serdes_regs,
+                                        void __iomem *sig_detect_reg, int lane)
+{
+        u32 tmp, dlpf, tbus;
+
+        /*Get the DLPF values */
+        tmp = netcp_xgbe_serdes_read_select_tbus(
+                        serdes_regs, lane + 1, 5);
+
+        dlpf = tmp >> 2;
+
+        if (dlpf < 400 || dlpf > 700) {
+                reg_rmw(sig_detect_reg, VAL_SH(2, 1), MASK_WID_SH(2, 1));
+                mdelay(1);
+                reg_rmw(sig_detect_reg, VAL_SH(0, 1), MASK_WID_SH(2, 1));
+        } else {
+                tbus = netcp_xgbe_serdes_read_select_tbus(serdes_regs, lane +
+                                                          1, 0xe);
+
+                pr_debug("XGBE: CDR centered, DLPF: %4d,%d,%d.\n",
+                         tmp >> 2, tmp & 3, (tbus >> 2) & 3);
+        }
+}
+
+/* Call every 100 ms */
+static int netcp_xgbe_check_link_status(void __iomem *serdes_regs,
+                                        void __iomem *sw_regs, u32 lanes,
+                                        u32 *current_state, u32 *lane_down)
+{
+        void __iomem *pcsr_base = sw_regs + 0x0600;
+        void __iomem *sig_detect_reg;
+        u32 pcsr_rx_stat, blk_lock, blk_errs;
+        int loss, i, status = 1;
+
+        for (i = 0; i < lanes; i++) {
+                /* Get the Loss bit */
+                loss = readl(serdes_regs + 0x1fc0 + 0x20 + (i * 0x04)) & 0x1;
+
+                /* Get Block Errors and Block Lock bits */
+                pcsr_rx_stat = readl(pcsr_base + 0x0c + (i * 0x80));
+                blk_lock = (pcsr_rx_stat >> 30) & 0x1;
+                blk_errs = (pcsr_rx_stat >> 16) & 0x0ff;
+
+                /* Get Signal Detect Overlay Address */
+                sig_detect_reg = serdes_regs + (i * 0x200) + 0x200 + 0x04;
+
+                /* If Block errors maxed out, attempt recovery! */
+                if (blk_errs == 0x0ff)
+                        blk_lock = 0;
+
+                switch (current_state[i]) {
+                case 0:
+                        /* if good link lock the signal detect ON! */
+                        if (!loss && blk_lock) {
+                                pr_debug("XGBE PCSR Linked Lane: %d\n", i);
+                                reg_rmw(sig_detect_reg, VAL_SH(3, 1),
+                                        MASK_WID_SH(2, 1));
+                                current_state[i] = 1;
+                        } else if (!blk_lock) {
+                                /* if no lock, then reset CDR */
+                                pr_debug("XGBE PCSR Recover Lane: %d\n", i);
+                                netcp_xgbe_serdes_reset_cdr(serdes_regs,
+                                                            sig_detect_reg, i);
+                        }
+                        break;
+
+                case 1:
+                        if (!blk_lock) {
+                                /* Link Lost? */
+                                lane_down[i] = 1;
+                                current_state[i] = 2;
+                        }
+                        break;
+
+                case 2:
+                        if (blk_lock)
+                                /* Nope just noise */
+                                current_state[i] = 1;
+                        else {
+                                /* Lost the block lock, reset CDR if it is
+                                 * not centered and go back to sync state
+                                 */
+                                netcp_xgbe_serdes_reset_cdr(serdes_regs,
+                                                            sig_detect_reg, i);
+                                current_state[i] = 0;
+                        }
+                        break;
+
+                default:
+                        pr_err("XGBE: unknown current_state[%d] %d\n",
+                               i, current_state[i]);
+                        break;
+                }
+
+                if (blk_errs > 0) {
+                        /* Reset the Error counts! */
+                        reg_rmw(pcsr_base + 0x08 + (i * 0x80), VAL_SH(0x19, 0),
+                                MASK_WID_SH(8, 0));
+
+                        reg_rmw(pcsr_base + 0x08 + (i * 0x80), VAL_SH(0x00, 0),
+                                MASK_WID_SH(8, 0));
+                }
+
+                status &= (current_state[i] == 1);
+        }
+
+        return status;
+}
+
+static int netcp_xgbe_serdes_check_lane(void __iomem *serdes_regs,
+                                        void __iomem *sw_regs)
+{
+        u32 current_state[2] = {0, 0};
+        int retries = 0, link_up;
+        u32 lane_down[2];
+
+        do {
+                lane_down[0] = 0;
+                lane_down[1] = 0;
+
+                link_up = netcp_xgbe_check_link_status(serdes_regs, sw_regs, 2,
+                                                       current_state,
+                                                       lane_down);
+
+                /* if we did not get link up then wait 100ms before calling
+                 * it again
+                 */
+                if (link_up)
+                        break;
+
+                if (lane_down[0])
+                        pr_debug("XGBE: detected link down on lane 0\n");
+
+                if (lane_down[1])
+                        pr_debug("XGBE: detected link down on lane 1\n");
+
+                if (++retries > 1) {
+                        pr_debug("XGBE: timeout waiting for serdes link up\n");
+                        return -ETIMEDOUT;
+                }
+                mdelay(100);
+        } while (!link_up);
+
+        pr_debug("XGBE: PCSR link is up\n");
+        return 0;
+}
+
+static void netcp_xgbe_serdes_setup_cm_c1_c2(void __iomem *serdes_regs,
+                                             int lane, int cm, int c1, int c2)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(cfg_cm_c1_c2); i++) {
+                reg_rmw(serdes_regs + cfg_cm_c1_c2[i].ofs + (0x200 * lane),
+                        cfg_cm_c1_c2[i].val,
+                        cfg_cm_c1_c2[i].mask);
+        }
+}
+
+static void netcp_xgbe_reset_serdes(void __iomem *serdes_regs)
+{
+        /* Toggle the POR_EN bit in CONFIG.CPU_CTRL */
+        /* enable POR_EN bit */
+        reg_rmw(serdes_regs + PCSR_CPU_CTRL_OFFSET, POR_EN, POR_EN);
+        usleep_range(10, 100);
+
+        /* disable POR_EN bit */
+        reg_rmw(serdes_regs + PCSR_CPU_CTRL_OFFSET, 0, POR_EN);
+        usleep_range(10, 100);
+}
+
+static int netcp_xgbe_serdes_config(void __iomem *serdes_regs,
+                                    void __iomem *sw_regs)
+{
+        u32 ret, i;
+
+        netcp_xgbe_serdes_pll_disable(serdes_regs);
+        netcp_xgbe_serdes_cmu_init(serdes_regs);
+
+        for (i = 0; i < 2; i++)
+                netcp_xgbe_serdes_lane_config(serdes_regs, i);
+
+        netcp_xgbe_serdes_com_enable(serdes_regs);
+        /* This is EVM + RTM-BOC specific */
+        for (i = 0; i < 2; i++)
+                netcp_xgbe_serdes_setup_cm_c1_c2(serdes_regs, i, 0, 0, 5);
+
+        netcp_xgbe_serdes_pll_enable(serdes_regs);
+        for (i = 0; i < 2; i++)
+                netcp_xgbe_serdes_lane_enable(serdes_regs, i);
+
+        /* SB PLL Status Poll */
+        ret = netcp_xgbe_wait_pll_locked(sw_regs);
+        if (ret)
+                return ret;
+
+        netcp_xgbe_serdes_enable_xgmii_port(sw_regs);
+        netcp_xgbe_serdes_check_lane(serdes_regs, sw_regs);
+        return ret;
+}
+
+int netcp_xgbe_serdes_init(void __iomem *serdes_regs, void __iomem *xgbe_regs)
+{
+        u32 val;
+
+        /* read COMLANE bits 4:0 */
+        val = readl(serdes_regs + 0xa00);
+        if (val & 0x1f) {
+                pr_debug("XGBE: serdes already in operation - reset\n");
+                netcp_xgbe_reset_serdes(serdes_regs);
+        }
+        return netcp_xgbe_serdes_config(serdes_regs, xgbe_regs);
+}
diff --git a/drivers/net/ethernet/ti/tlan.c b/drivers/net/ethernet/ti/tlan.c
index f2ff0074aac9..691ec936e88d 100644
--- a/drivers/net/ethernet/ti/tlan.c
+++ b/drivers/net/ethernet/ti/tlan.c
@@ -2540,7 +2540,7 @@ static void tlan_phy_power_down(struct net_device *dev)
          * This is abitrary.  It is intended to make sure the
          * transceiver settles.
          */
-        tlan_set_timer(dev, (HZ/20), TLAN_TIMER_PHY_PUP);
+        tlan_set_timer(dev, msecs_to_jiffies(50), TLAN_TIMER_PHY_PUP);
 
 }
 
@@ -2561,7 +2561,7 @@ static void tlan_phy_power_up(struct net_device *dev)
          * transceiver.  The TLAN docs say both 50 ms and
          * 500 ms, so do the longer, just in case.
          */
-        tlan_set_timer(dev, (HZ/20), TLAN_TIMER_PHY_RESET);
+        tlan_set_timer(dev, msecs_to_jiffies(500), TLAN_TIMER_PHY_RESET);
 
 }
 
@@ -2593,7 +2593,7 @@ static void tlan_phy_reset(struct net_device *dev)
          * I don't remember why I wait this long.
          * I've changed this to 50ms, as it seems long enough.
          */
-        tlan_set_timer(dev, (HZ/20), TLAN_TIMER_PHY_START_LINK);
+        tlan_set_timer(dev, msecs_to_jiffies(50), TLAN_TIMER_PHY_START_LINK);
 
 }
 
@@ -2658,7 +2658,7 @@ static void tlan_phy_start_link(struct net_device *dev)
                 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN
                         | TLAN_NET_CFG_PHY_EN;
                 tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, data);
-                tlan_set_timer(dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN);
+                tlan_set_timer(dev, msecs_to_jiffies(40), TLAN_TIMER_PHY_PDOWN);
                 return;
         } else if (priv->phy_num == 0) {
                 control = 0;
@@ -2725,7 +2725,7 @@ static void tlan_phy_finish_auto_neg(struct net_device *dev)
             (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10) &&
             (priv->phy_num != 0)) {
                 priv->phy_num = 0;
-                tlan_set_timer(dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN);
+                tlan_set_timer(dev, msecs_to_jiffies(400), TLAN_TIMER_PHY_PDOWN);
                 return;
         }
 
@@ -2744,7 +2744,7 @@ static void tlan_phy_finish_auto_neg(struct net_device *dev)
 
         /* Wait for 100 ms.  No reason in partiticular.
          */
-        tlan_set_timer(dev, (HZ/10), TLAN_TIMER_FINISH_RESET);
+        tlan_set_timer(dev, msecs_to_jiffies(100), TLAN_TIMER_FINISH_RESET);
 
 }
 
@@ -2796,7 +2796,7 @@ static void tlan_phy_monitor(unsigned long data)
                                 /* set to external PHY */
                                 priv->phy_num = 1;
                                 /* restart autonegotiation */
-                                tlan_set_timer(dev, 4 * HZ / 10,
+                                tlan_set_timer(dev, msecs_to_jiffies(400),
                                                TLAN_TIMER_PHY_PDOWN);
                                 return;
                         }
diff --git a/drivers/net/ethernet/via/via-rhine.c b/drivers/net/ethernet/via/via-rhine.c
index a191afc23b56..17e276651601 100644
--- a/drivers/net/ethernet/via/via-rhine.c
+++ b/drivers/net/ethernet/via/via-rhine.c
@@ -1326,7 +1326,8 @@ static void rhine_check_media(struct net_device *dev, unsigned int init_media)
         struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
 
-        mii_check_media(&rp->mii_if, netif_msg_link(rp), init_media);
+        if (!rp->mii_if.force_media)
+                mii_check_media(&rp->mii_if, netif_msg_link(rp), init_media);
 
         if (rp->mii_if.full_duplex)
             iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1FDuplex,
@@ -1781,8 +1782,8 @@ static netdev_tx_t rhine_start_tx(struct sk_buff *skb,
         rp->tx_ring[entry].desc_length =
                 cpu_to_le32(TXDESC | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
 
-        if (unlikely(vlan_tx_tag_present(skb))) {
-                u16 vid_pcp = vlan_tx_tag_get(skb);
+        if (unlikely(skb_vlan_tag_present(skb))) {
+                u16 vid_pcp = skb_vlan_tag_get(skb);
 
                 /* drop CFI/DEI bit, register needs VID and PCP */
                 vid_pcp = (vid_pcp & VLAN_VID_MASK) |
@@ -1803,7 +1804,7 @@ static netdev_tx_t rhine_start_tx(struct sk_buff *skb,
 
         /* Non-x86 Todo: explicitly flush cache lines here. */
 
-        if (vlan_tx_tag_present(skb))
+        if (skb_vlan_tag_present(skb))
                 /* Tx queues are bits 7-0 (first Tx queue: bit 7) */
                 BYTE_REG_BITS_ON(1 << 7, ioaddr + TQWake);
 
diff --git a/drivers/net/ethernet/via/via-velocity.c b/drivers/net/ethernet/via/via-velocity.c
index 282f83a63b67..c20206f83cc1 100644
--- a/drivers/net/ethernet/via/via-velocity.c
+++ b/drivers/net/ethernet/via/via-velocity.c
@@ -2611,8 +2611,8 @@ static netdev_tx_t velocity_xmit(struct sk_buff *skb,
 
         td_ptr->tdesc1.cmd = TCPLS_NORMAL + (tdinfo->nskb_dma + 1) * 16;
 
-        if (vlan_tx_tag_present(skb)) {
-                td_ptr->tdesc1.vlan = cpu_to_le16(vlan_tx_tag_get(skb));
+        if (skb_vlan_tag_present(skb)) {
+                td_ptr->tdesc1.vlan = cpu_to_le16(skb_vlan_tag_get(skb));
                 td_ptr->tdesc1.TCR |= TCR0_VETAG;
         }