1 files changed, 244 insertions, 291 deletions

diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index e6a803f1c507..57d3293c65bd 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -1,6 +1,6 @@
 /* bnx2.c: Broadcom NX2 network driver.
  *
- * Copyright (c) 2004-2010 Broadcom Corporation
+ * Copyright (c) 2004-2011 Broadcom Corporation
  *
  * 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
@@ -37,9 +37,6 @@
 #include <linux/ethtool.h>
 #include <linux/mii.h>
 #include <linux/if_vlan.h>
-#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
-#define BCM_VLAN 1
-#endif
 #include <net/ip.h>
 #include <net/tcp.h>
 #include <net/checksum.h>
@@ -49,6 +46,7 @@
 #include <linux/cache.h>
 #include <linux/firmware.h>
 #include <linux/log2.h>
+#include <linux/aer.h>
 
 #if defined(CONFIG_CNIC) || defined(CONFIG_CNIC_MODULE)
 #define BCM_CNIC 1
@@ -58,13 +56,13 @@
 #include "bnx2_fw.h"
 
 #define DRV_MODULE_NAME         "bnx2"
-#define DRV_MODULE_VERSION      "2.0.17"
-#define DRV_MODULE_RELDATE      "July 18, 2010"
-#define FW_MIPS_FILE_06         "bnx2/bnx2-mips-06-5.0.0.j6.fw"
-#define FW_RV2P_FILE_06         "bnx2/bnx2-rv2p-06-5.0.0.j3.fw"
-#define FW_MIPS_FILE_09         "bnx2/bnx2-mips-09-5.0.0.j15.fw"
-#define FW_RV2P_FILE_09_Ax      "bnx2/bnx2-rv2p-09ax-5.0.0.j10.fw"
-#define FW_RV2P_FILE_09         "bnx2/bnx2-rv2p-09-5.0.0.j10.fw"
+#define DRV_MODULE_VERSION      "2.1.6"
+#define DRV_MODULE_RELDATE      "Mar 7, 2011"
+#define FW_MIPS_FILE_06         "bnx2/bnx2-mips-06-6.2.1.fw"
+#define FW_RV2P_FILE_06         "bnx2/bnx2-rv2p-06-6.0.15.fw"
+#define FW_MIPS_FILE_09         "bnx2/bnx2-mips-09-6.2.1a.fw"
+#define FW_RV2P_FILE_09_Ax      "bnx2/bnx2-rv2p-09ax-6.0.17.fw"
+#define FW_RV2P_FILE_09         "bnx2/bnx2-rv2p-09-6.0.17.fw"
 
 #define RUN_AT(x) (jiffies + (x))
 
@@ -265,7 +263,7 @@ static inline u32 bnx2_tx_avail(struct bnx2 *bp, struct bnx2_tx_ring_info *txr)
                 if (diff == TX_DESC_CNT)
                         diff = MAX_TX_DESC_CNT;
         }
-        return (bp->tx_ring_size - diff);
+        return bp->tx_ring_size - diff;
 }
 
 static u32
@@ -298,7 +296,7 @@ bnx2_shmem_wr(struct bnx2 *bp, u32 offset, u32 val)
 static u32
 bnx2_shmem_rd(struct bnx2 *bp, u32 offset)
 {
-        return (bnx2_reg_rd_ind(bp, bp->shmem_base + offset));
+        return bnx2_reg_rd_ind(bp, bp->shmem_base + offset);
 }
 
 static void
@@ -437,7 +435,8 @@ bnx2_cnic_stop(struct bnx2 *bp)
         struct cnic_ctl_info info;
 
         mutex_lock(&bp->cnic_lock);
-        c_ops = bp->cnic_ops;
+        c_ops = rcu_dereference_protected(bp->cnic_ops,
+                                          lockdep_is_held(&bp->cnic_lock));
         if (c_ops) {
                 info.cmd = CNIC_CTL_STOP_CMD;
                 c_ops->cnic_ctl(bp->cnic_data, &info);
@@ -452,7 +451,8 @@ bnx2_cnic_start(struct bnx2 *bp)
         struct cnic_ctl_info info;
 
         mutex_lock(&bp->cnic_lock);
-        c_ops = bp->cnic_ops;
+        c_ops = rcu_dereference_protected(bp->cnic_ops,
+                                          lockdep_is_held(&bp->cnic_lock));
         if (c_ops) {
                 if (!(bp->flags & BNX2_FLAG_USING_MSIX)) {
                         struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
@@ -768,13 +768,10 @@ bnx2_alloc_rx_mem(struct bnx2 *bp)
                 int j;
 
                 rxr->rx_buf_ring =
-                        vmalloc(SW_RXBD_RING_SIZE * bp->rx_max_ring);
+                        vzalloc(SW_RXBD_RING_SIZE * bp->rx_max_ring);
                 if (rxr->rx_buf_ring == NULL)
                         return -ENOMEM;
 
-                memset(rxr->rx_buf_ring, 0,
-                       SW_RXBD_RING_SIZE * bp->rx_max_ring);
-
                 for (j = 0; j < bp->rx_max_ring; j++) {
                         rxr->rx_desc_ring[j] =
                                 dma_alloc_coherent(&bp->pdev->dev,
@@ -787,13 +784,11 @@ bnx2_alloc_rx_mem(struct bnx2 *bp)
                 }
 
                 if (bp->rx_pg_ring_size) {
-                        rxr->rx_pg_ring = vmalloc(SW_RXPG_RING_SIZE *
+                        rxr->rx_pg_ring = vzalloc(SW_RXPG_RING_SIZE *
                                                   bp->rx_max_pg_ring);
                         if (rxr->rx_pg_ring == NULL)
                                 return -ENOMEM;
 
-                        memset(rxr->rx_pg_ring, 0, SW_RXPG_RING_SIZE *
-                               bp->rx_max_pg_ring);
                 }
 
                 for (j = 0; j < bp->rx_max_pg_ring; j++) {
@@ -976,9 +971,9 @@ bnx2_report_fw_link(struct bnx2 *bp)
 static char *
 bnx2_xceiver_str(struct bnx2 *bp)
 {
-        return ((bp->phy_port == PORT_FIBRE) ? "SerDes" :
+        return (bp->phy_port == PORT_FIBRE) ? "SerDes" :
                 ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) ? "Remote Copper" :
-                 "Copper"));
+                 "Copper");
 }
 
 static void
@@ -1268,30 +1263,9 @@ bnx2_init_rx_context(struct bnx2 *bp, u32 cid)
         val |= BNX2_L2CTX_CTX_TYPE_SIZE_L2;
         val |= 0x02 << 8;
 
-        if (CHIP_NUM(bp) == CHIP_NUM_5709) {
-                u32 lo_water, hi_water;
-
-                if (bp->flow_ctrl & FLOW_CTRL_TX)
-                        lo_water = BNX2_L2CTX_LO_WATER_MARK_DEFAULT;
-                else
-                        lo_water = BNX2_L2CTX_LO_WATER_MARK_DIS;
-                if (lo_water >= bp->rx_ring_size)
-                        lo_water = 0;
-
-                hi_water = min_t(int, bp->rx_ring_size / 4, lo_water + 16);
-
-                if (hi_water <= lo_water)
-                        lo_water = 0;
-
-                hi_water /= BNX2_L2CTX_HI_WATER_MARK_SCALE;
-                lo_water /= BNX2_L2CTX_LO_WATER_MARK_SCALE;
+        if (bp->flow_ctrl & FLOW_CTRL_TX)
+                val |= BNX2_L2CTX_FLOW_CTRL_ENABLE;
 
-                if (hi_water > 0xf)
-                        hi_water = 0xf;
-                else if (hi_water == 0)
-                        lo_water = 0;
-                val |= lo_water | (hi_water << BNX2_L2CTX_HI_WATER_MARK_SHIFT);
-        }
         bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_CTX_TYPE, val);
 }
 
@@ -1372,8 +1346,7 @@ bnx2_set_mac_link(struct bnx2 *bp)
         /* Acknowledge the interrupt. */
         REG_WR(bp, BNX2_EMAC_STATUS, BNX2_EMAC_STATUS_LINK_CHANGE);
 
-        if (CHIP_NUM(bp) == CHIP_NUM_5709)
-                bnx2_init_all_rx_contexts(bp);
+        bnx2_init_all_rx_contexts(bp);
 }
 
 static void
@@ -1757,7 +1730,7 @@ __acquires(&bp->phy_lock)
         u32 new_adv = 0;
 
         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
-                return (bnx2_setup_remote_phy(bp, port));
+                return bnx2_setup_remote_phy(bp, port);
 
         if (!(bp->autoneg & AUTONEG_SPEED)) {
                 u32 new_bmcr;
@@ -2170,10 +2143,10 @@ __acquires(&bp->phy_lock)
                 return 0;
 
         if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
-                return (bnx2_setup_serdes_phy(bp, port));
+                return bnx2_setup_serdes_phy(bp, port);
         }
         else {
-                return (bnx2_setup_copper_phy(bp));
+                return bnx2_setup_copper_phy(bp);
         }
 }
 
@@ -3108,8 +3081,6 @@ bnx2_rx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
                 struct sw_bd *rx_buf, *next_rx_buf;
                 struct sk_buff *skb;
                 dma_addr_t dma_addr;
-                u16 vtag = 0;
-                int hw_vlan __maybe_unused = 0;
 
                 sw_ring_cons = RX_RING_IDX(sw_cons);
                 sw_ring_prod = RX_RING_IDX(sw_prod);
@@ -3189,23 +3160,8 @@ bnx2_rx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
                         goto next_rx;
 
                 if ((status & L2_FHDR_STATUS_L2_VLAN_TAG) &&
-                    !(bp->rx_mode & BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG)) {
-                        vtag = rx_hdr->l2_fhdr_vlan_tag;
-#ifdef BCM_VLAN
-                        if (bp->vlgrp)
-                                hw_vlan = 1;
-                        else
-#endif
-                        {
-                                struct vlan_ethhdr *ve = (struct vlan_ethhdr *)
-                                        __skb_push(skb, 4);
-
-                                memmove(ve, skb->data + 4, ETH_ALEN * 2);
-                                ve->h_vlan_proto = htons(ETH_P_8021Q);
-                                ve->h_vlan_TCI = htons(vtag);
-                                len += 4;
-                        }
-                }
+                    !(bp->rx_mode & BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG))
+                        __vlan_hwaccel_put_tag(skb, rx_hdr->l2_fhdr_vlan_tag);
 
                 skb->protocol = eth_type_trans(skb, bp->dev);
 
@@ -3217,8 +3173,8 @@ bnx2_rx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
 
                 }
 
-                skb->ip_summed = CHECKSUM_NONE;
-                if (bp->rx_csum &&
+                skb_checksum_none_assert(skb);
+                if ((bp->dev->features & NETIF_F_RXCSUM) &&
                         (status & (L2_FHDR_STATUS_TCP_SEGMENT |
                         L2_FHDR_STATUS_UDP_DATAGRAM))) {
 
@@ -3232,14 +3188,7 @@ bnx2_rx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
                         skb->rxhash = rx_hdr->l2_fhdr_hash;
 
                 skb_record_rx_queue(skb, bnapi - &bp->bnx2_napi[0]);
-
-#ifdef BCM_VLAN
-                if (hw_vlan)
-                        vlan_gro_receive(&bnapi->napi, bp->vlgrp, vtag, skb);
-                else
-#endif
-                        napi_gro_receive(&bnapi->napi, skb);
-
+                napi_gro_receive(&bnapi->napi, skb);
                 rx_pkt++;
 
 next_rx:
@@ -3554,13 +3503,9 @@ bnx2_set_rx_mode(struct net_device *dev)
         rx_mode = bp->rx_mode & ~(BNX2_EMAC_RX_MODE_PROMISCUOUS |
                                   BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG);
         sort_mode = 1 | BNX2_RPM_SORT_USER0_BC_EN;
-#ifdef BCM_VLAN
-        if (!bp->vlgrp && (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN))
-                rx_mode |= BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG;
-#else
-        if (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN)
+        if (!(dev->features & NETIF_F_HW_VLAN_RX) &&
+             (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN))
                 rx_mode |= BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG;
-#endif
         if (dev->flags & IFF_PROMISC) {
                 /* Promiscuous mode. */
                 rx_mode |= BNX2_EMAC_RX_MODE_PROMISCUOUS;
@@ -4697,13 +4642,28 @@ bnx2_reset_chip(struct bnx2 *bp, u32 reset_code)
 
         /* Wait for the current PCI transaction to complete before
          * issuing a reset. */
-        REG_WR(bp, BNX2_MISC_ENABLE_CLR_BITS,
-               BNX2_MISC_ENABLE_CLR_BITS_TX_DMA_ENABLE |
-               BNX2_MISC_ENABLE_CLR_BITS_DMA_ENGINE_ENABLE |
-               BNX2_MISC_ENABLE_CLR_BITS_RX_DMA_ENABLE |
-               BNX2_MISC_ENABLE_CLR_BITS_HOST_COALESCE_ENABLE);
-        val = REG_RD(bp, BNX2_MISC_ENABLE_CLR_BITS);
-        udelay(5);
+        if ((CHIP_NUM(bp) == CHIP_NUM_5706) ||
+            (CHIP_NUM(bp) == CHIP_NUM_5708)) {
+                REG_WR(bp, BNX2_MISC_ENABLE_CLR_BITS,
+                       BNX2_MISC_ENABLE_CLR_BITS_TX_DMA_ENABLE |
+                       BNX2_MISC_ENABLE_CLR_BITS_DMA_ENGINE_ENABLE |
+                       BNX2_MISC_ENABLE_CLR_BITS_RX_DMA_ENABLE |
+                       BNX2_MISC_ENABLE_CLR_BITS_HOST_COALESCE_ENABLE);
+                val = REG_RD(bp, BNX2_MISC_ENABLE_CLR_BITS);
+                udelay(5);
+        } else {  /* 5709 */
+                val = REG_RD(bp, BNX2_MISC_NEW_CORE_CTL);
+                val &= ~BNX2_MISC_NEW_CORE_CTL_DMA_ENABLE;
+                REG_WR(bp, BNX2_MISC_NEW_CORE_CTL, val);
+                val = REG_RD(bp, BNX2_MISC_NEW_CORE_CTL);
+
+                for (i = 0; i < 100; i++) {
+                        msleep(1);
+                        val = REG_RD(bp, BNX2_PCICFG_DEVICE_CONTROL);
+                        if (!(val & BNX2_PCICFG_DEVICE_STATUS_NO_PEND))
+                                break;
+                }
+        }
 
         /* Wait for the firmware to tell us it is ok to issue a reset. */
         bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT0 | reset_code, 1, 1);
@@ -4725,7 +4685,7 @@ bnx2_reset_chip(struct bnx2 *bp, u32 reset_code)
                 val = BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
                       BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP;
 
-                pci_write_config_dword(bp->pdev, BNX2_PCICFG_MISC_CONFIG, val);
+                REG_WR(bp, BNX2_PCICFG_MISC_CONFIG, val);
 
         } else {
                 val = BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
@@ -4973,6 +4933,11 @@ bnx2_init_chip(struct bnx2 *bp)
 
         REG_WR(bp, BNX2_HC_CONFIG, val);
 
+        if (bp->rx_ticks < 25)
+                bnx2_reg_wr_ind(bp, BNX2_FW_RX_LOW_LATENCY, 1);
+        else
+                bnx2_reg_wr_ind(bp, BNX2_FW_RX_LOW_LATENCY, 0);
+
         for (i = 1; i < bp->irq_nvecs; i++) {
                 u32 base = ((i - 1) * BNX2_HC_SB_CONFIG_SIZE) +
                            BNX2_HC_SB_CONFIG_1;
@@ -5241,18 +5206,20 @@ bnx2_init_all_rings(struct bnx2 *bp)
                 bnx2_init_rx_ring(bp, i);
 
         if (bp->num_rx_rings > 1) {
-                u32 tbl_32;
-                u8 *tbl = (u8 *) &tbl_32;
-
-                bnx2_reg_wr_ind(bp, BNX2_RXP_SCRATCH_RSS_TBL_SZ,
-                                BNX2_RXP_SCRATCH_RSS_TBL_MAX_ENTRIES);
+                u32 tbl_32 = 0;
 
                 for (i = 0; i < BNX2_RXP_SCRATCH_RSS_TBL_MAX_ENTRIES; i++) {
-                        tbl[i % 4] = i % (bp->num_rx_rings - 1);
-                        if ((i % 4) == 3)
-                                bnx2_reg_wr_ind(bp,
-                                                BNX2_RXP_SCRATCH_RSS_TBL + i,
-                                                cpu_to_be32(tbl_32));
+                        int shift = (i % 8) << 2;
+
+                        tbl_32 |= (i % (bp->num_rx_rings - 1)) << shift;
+                        if ((i % 8) == 7) {
+                                REG_WR(bp, BNX2_RLUP_RSS_DATA, tbl_32);
+                                REG_WR(bp, BNX2_RLUP_RSS_COMMAND, (i >> 3) |
+                                        BNX2_RLUP_RSS_COMMAND_RSS_WRITE_MASK |
+                                        BNX2_RLUP_RSS_COMMAND_WRITE |
+                                        BNX2_RLUP_RSS_COMMAND_HASH_MASK);
+                                tbl_32 = 0;
+                        }
                 }
 
                 val = BNX2_RLUP_RSS_CONFIG_IPV4_RSS_TYPE_ALL_XI |
@@ -6131,7 +6098,7 @@ bnx2_request_irq(struct bnx2 *bp)
 }
 
 static void
-bnx2_free_irq(struct bnx2 *bp)
+__bnx2_free_irq(struct bnx2 *bp)
 {
         struct bnx2_irq *irq;
         int i;
@@ -6142,6 +6109,13 @@ bnx2_free_irq(struct bnx2 *bp)
                         free_irq(irq->vector, &bp->bnx2_napi[i]);
                 irq->requested = 0;
         }
+}
+
+static void
+bnx2_free_irq(struct bnx2 *bp)
+{
+
+        __bnx2_free_irq(bp);
         if (bp->flags & BNX2_FLAG_USING_MSI)
                 pci_disable_msi(bp->pdev);
         else if (bp->flags & BNX2_FLAG_USING_MSIX)
@@ -6201,7 +6175,7 @@ bnx2_enable_msix(struct bnx2 *bp, int msix_vecs)
         }
 }
 
-static void
+static int
 bnx2_setup_int_mode(struct bnx2 *bp, int dis_msi)
 {
         int cpus = num_online_cpus();
@@ -6230,9 +6204,10 @@ bnx2_setup_int_mode(struct bnx2 *bp, int dis_msi)
         }
 
         bp->num_tx_rings = rounddown_pow_of_two(bp->irq_nvecs);
-        bp->dev->real_num_tx_queues = bp->num_tx_rings;
+        netif_set_real_num_tx_queues(bp->dev, bp->num_tx_rings);
 
         bp->num_rx_rings = bp->irq_nvecs;
+        return netif_set_real_num_rx_queues(bp->dev, bp->num_rx_rings);
 }
 
 /* Called with rtnl_lock */
@@ -6247,7 +6222,9 @@ bnx2_open(struct net_device *dev)
         bnx2_set_power_state(bp, PCI_D0);
         bnx2_disable_int(bp);
 
-        bnx2_setup_int_mode(bp, disable_msi);
+        rc = bnx2_setup_int_mode(bp, disable_msi);
+        if (rc)
+                goto open_err;
         bnx2_init_napi(bp);
         bnx2_napi_enable(bp);
         rc = bnx2_alloc_mem(bp);
@@ -6376,29 +6353,6 @@ bnx2_tx_timeout(struct net_device *dev)
         schedule_work(&bp->reset_task);
 }
 
-#ifdef BCM_VLAN
-/* Called with rtnl_lock */
-static void
-bnx2_vlan_rx_register(struct net_device *dev, struct vlan_group *vlgrp)
-{
-        struct bnx2 *bp = netdev_priv(dev);
-
-        if (netif_running(dev))
-                bnx2_netif_stop(bp, false);
-
-        bp->vlgrp = vlgrp;
-
-        if (!netif_running(dev))
-                return;
-
-        bnx2_set_rx_mode(dev);
-        if (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN)
-                bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_KEEP_VLAN_UPDATE, 0, 1);
-
-        bnx2_netif_start(bp, false);
-}
-#endif
-
 /* Called with netif_tx_lock.
  * bnx2_tx_int() runs without netif_tx_lock unless it needs to call
  * netif_wake_queue().
@@ -6439,12 +6393,11 @@ bnx2_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 vlan_tag_flags |= TX_BD_FLAGS_TCP_UDP_CKSUM;
         }
 
-#ifdef BCM_VLAN
-        if (bp->vlgrp && vlan_tx_tag_present(skb)) {
+        if (vlan_tx_tag_present(skb)) {
                 vlan_tag_flags |=
                         (TX_BD_FLAGS_VLAN_TAG | (vlan_tx_tag_get(skb) << 16));
         }
-#endif
+
         if ((mss = skb_shinfo(skb)->gso_size)) {
                 u32 tcp_opt_len;
                 struct iphdr *iph;
@@ -6743,17 +6696,16 @@ bnx2_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 
         if (bp->autoneg & AUTONEG_SPEED) {
                 cmd->autoneg = AUTONEG_ENABLE;
-        }
-        else {
+        } else {
                 cmd->autoneg = AUTONEG_DISABLE;
         }
 
         if (netif_carrier_ok(dev)) {
-                cmd->speed = bp->line_speed;
+                ethtool_cmd_speed_set(cmd, bp->line_speed);
                 cmd->duplex = bp->duplex;
         }
         else {
-                cmd->speed = -1;
+                ethtool_cmd_speed_set(cmd, -1);
                 cmd->duplex = -1;
         }
         spin_unlock_bh(&bp->phy_lock);
@@ -6805,21 +6757,21 @@ bnx2_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 advertising |= ADVERTISED_Autoneg;
         }
         else {
+                u32 speed = ethtool_cmd_speed(cmd);
                 if (cmd->port == PORT_FIBRE) {
-                        if ((cmd->speed != SPEED_1000 &&
-                             cmd->speed != SPEED_2500) ||
+                        if ((speed != SPEED_1000 &&
+                             speed != SPEED_2500) ||
                             (cmd->duplex != DUPLEX_FULL))
                                 goto err_out_unlock;
 
-                        if (cmd->speed == SPEED_2500 &&
+                        if (speed == SPEED_2500 &&
                             !(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
                                 goto err_out_unlock;
-                }
-                else if (cmd->speed == SPEED_1000 || cmd->speed == SPEED_2500)
+                } else if (speed == SPEED_1000 || speed == SPEED_2500)
                         goto err_out_unlock;
 
                 autoneg &= ~AUTONEG_SPEED;
-                req_line_speed = cmd->speed;
+                req_line_speed = speed;
                 req_duplex = cmd->duplex;
                 advertising = 0;
         }
@@ -6867,28 +6819,30 @@ bnx2_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
         u32 *p = _p, i, offset;
         u8 *orig_p = _p;
         struct bnx2 *bp = netdev_priv(dev);
-        u32 reg_boundaries[] = { 0x0000, 0x0098, 0x0400, 0x045c,
-                                 0x0800, 0x0880, 0x0c00, 0x0c10,
-                                 0x0c30, 0x0d08, 0x1000, 0x101c,
-                                 0x1040, 0x1048, 0x1080, 0x10a4,
-                                 0x1400, 0x1490, 0x1498, 0x14f0,
-                                 0x1500, 0x155c, 0x1580, 0x15dc,
-                                 0x1600, 0x1658, 0x1680, 0x16d8,
-                                 0x1800, 0x1820, 0x1840, 0x1854,
-                                 0x1880, 0x1894, 0x1900, 0x1984,
-                                 0x1c00, 0x1c0c, 0x1c40, 0x1c54,
-                                 0x1c80, 0x1c94, 0x1d00, 0x1d84,
-                                 0x2000, 0x2030, 0x23c0, 0x2400,
-                                 0x2800, 0x2820, 0x2830, 0x2850,
-                                 0x2b40, 0x2c10, 0x2fc0, 0x3058,
-                                 0x3c00, 0x3c94, 0x4000, 0x4010,
-                                 0x4080, 0x4090, 0x43c0, 0x4458,
-                                 0x4c00, 0x4c18, 0x4c40, 0x4c54,
-                                 0x4fc0, 0x5010, 0x53c0, 0x5444,
-                                 0x5c00, 0x5c18, 0x5c80, 0x5c90,
-                                 0x5fc0, 0x6000, 0x6400, 0x6428,
-                                 0x6800, 0x6848, 0x684c, 0x6860,
-                                 0x6888, 0x6910, 0x8000 };
+        static const u32 reg_boundaries[] = {
+                0x0000, 0x0098, 0x0400, 0x045c,
+                0x0800, 0x0880, 0x0c00, 0x0c10,
+                0x0c30, 0x0d08, 0x1000, 0x101c,
+                0x1040, 0x1048, 0x1080, 0x10a4,
+                0x1400, 0x1490, 0x1498, 0x14f0,
+                0x1500, 0x155c, 0x1580, 0x15dc,
+                0x1600, 0x1658, 0x1680, 0x16d8,
+                0x1800, 0x1820, 0x1840, 0x1854,
+                0x1880, 0x1894, 0x1900, 0x1984,
+                0x1c00, 0x1c0c, 0x1c40, 0x1c54,
+                0x1c80, 0x1c94, 0x1d00, 0x1d84,
+                0x2000, 0x2030, 0x23c0, 0x2400,
+                0x2800, 0x2820, 0x2830, 0x2850,
+                0x2b40, 0x2c10, 0x2fc0, 0x3058,
+                0x3c00, 0x3c94, 0x4000, 0x4010,
+                0x4080, 0x4090, 0x43c0, 0x4458,
+                0x4c00, 0x4c18, 0x4c40, 0x4c54,
+                0x4fc0, 0x5010, 0x53c0, 0x5444,
+                0x5c00, 0x5c18, 0x5c80, 0x5c90,
+                0x5fc0, 0x6000, 0x6400, 0x6428,
+                0x6800, 0x6848, 0x684c, 0x6860,
+                0x6888, 0x6910, 0x8000
+        };
 
         regs->version = 0;
 
@@ -7146,6 +7100,7 @@ bnx2_change_ring_size(struct bnx2 *bp, u32 rx, u32 tx)
 
                 bnx2_netif_stop(bp, true);
                 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_RESET);
+                __bnx2_free_irq(bp);
                 bnx2_free_skbs(bp);
                 bnx2_free_mem(bp);
         }
@@ -7158,6 +7113,9 @@ bnx2_change_ring_size(struct bnx2 *bp, u32 rx, u32 tx)
 
                 rc = bnx2_alloc_mem(bp);
                 if (!rc)
+                        rc = bnx2_request_irq(bp);
+
+                if (!rc)
                         rc = bnx2_init_nic(bp, 0);
 
                 if (rc) {
@@ -7230,38 +7188,6 @@ bnx2_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
         return 0;
 }
 
-static u32
-bnx2_get_rx_csum(struct net_device *dev)
-{
-        struct bnx2 *bp = netdev_priv(dev);
-
-        return bp->rx_csum;
-}
-
-static int
-bnx2_set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct bnx2 *bp = netdev_priv(dev);
-
-        bp->rx_csum = data;
-        return 0;
-}
-
-static int
-bnx2_set_tso(struct net_device *dev, u32 data)
-{
-        struct bnx2 *bp = netdev_priv(dev);
-
-        if (data) {
-                dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
-                if (CHIP_NUM(bp) == CHIP_NUM_5709)
-                        dev->features |= NETIF_F_TSO6;
-        } else
-                dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6 |
-                                   NETIF_F_TSO_ECN);
-        return 0;
-}
-
 static struct {
         char string[ETH_GSTRING_LEN];
 } bnx2_stats_str_arr[] = {
@@ -7536,60 +7462,77 @@ bnx2_get_ethtool_stats(struct net_device *dev,
 }
 
 static int
-bnx2_phys_id(struct net_device *dev, u32 data)
+bnx2_set_phys_id(struct net_device *dev, enum ethtool_phys_id_state state)
 {
         struct bnx2 *bp = netdev_priv(dev);
-        int i;
-        u32 save;
 
-        bnx2_set_power_state(bp, PCI_D0);
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                bnx2_set_power_state(bp, PCI_D0);
 
-        if (data == 0)
-                data = 2;
+                bp->leds_save = REG_RD(bp, BNX2_MISC_CFG);
+                REG_WR(bp, BNX2_MISC_CFG, BNX2_MISC_CFG_LEDMODE_MAC);
+                return 1;       /* cycle on/off once per second */
+
+        case ETHTOOL_ID_ON:
+                REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE |
+                       BNX2_EMAC_LED_1000MB_OVERRIDE |
+                       BNX2_EMAC_LED_100MB_OVERRIDE |
+                       BNX2_EMAC_LED_10MB_OVERRIDE |
+                       BNX2_EMAC_LED_TRAFFIC_OVERRIDE |
+                       BNX2_EMAC_LED_TRAFFIC);
+                break;
 
-        save = REG_RD(bp, BNX2_MISC_CFG);
-        REG_WR(bp, BNX2_MISC_CFG, BNX2_MISC_CFG_LEDMODE_MAC);
+        case ETHTOOL_ID_OFF:
+                REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE);
+                break;
 
-        for (i = 0; i < (data * 2); i++) {
-                if ((i % 2) == 0) {
-                        REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE);
-                }
-                else {
-                        REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE |
-                                BNX2_EMAC_LED_1000MB_OVERRIDE |
-                                BNX2_EMAC_LED_100MB_OVERRIDE |
-                                BNX2_EMAC_LED_10MB_OVERRIDE |
-                                BNX2_EMAC_LED_TRAFFIC_OVERRIDE |
-                                BNX2_EMAC_LED_TRAFFIC);
-                }
-                msleep_interruptible(500);
-                if (signal_pending(current))
-                        break;
-        }
-        REG_WR(bp, BNX2_EMAC_LED, 0);
-        REG_WR(bp, BNX2_MISC_CFG, save);
+        case ETHTOOL_ID_INACTIVE:
+                REG_WR(bp, BNX2_EMAC_LED, 0);
+                REG_WR(bp, BNX2_MISC_CFG, bp->leds_save);
 
-        if (!netif_running(dev))
-                bnx2_set_power_state(bp, PCI_D3hot);
+                if (!netif_running(dev))
+                        bnx2_set_power_state(bp, PCI_D3hot);
+                break;
+        }
 
         return 0;
 }
 
-static int
-bnx2_set_tx_csum(struct net_device *dev, u32 data)
+static u32
+bnx2_fix_features(struct net_device *dev, u32 features)
 {
         struct bnx2 *bp = netdev_priv(dev);
 
-        if (CHIP_NUM(bp) == CHIP_NUM_5709)
-                return (ethtool_op_set_tx_ipv6_csum(dev, data));
-        else
-                return (ethtool_op_set_tx_csum(dev, data));
+        if (!(bp->flags & BNX2_FLAG_CAN_KEEP_VLAN))
+                features |= NETIF_F_HW_VLAN_RX;
+
+        return features;
 }
 
 static int
-bnx2_set_flags(struct net_device *dev, u32 data)
+bnx2_set_features(struct net_device *dev, u32 features)
 {
-        return ethtool_op_set_flags(dev, data, ETH_FLAG_RXHASH);
+        struct bnx2 *bp = netdev_priv(dev);
+
+        /* TSO with VLAN tag won't work with current firmware */
+        if (features & NETIF_F_HW_VLAN_TX)
+                dev->vlan_features |= (dev->hw_features & NETIF_F_ALL_TSO);
+        else
+                dev->vlan_features &= ~NETIF_F_ALL_TSO;
+
+        if ((!!(features & NETIF_F_HW_VLAN_RX) !=
+            !!(bp->rx_mode & BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG)) &&
+            netif_running(dev)) {
+                bnx2_netif_stop(bp, false);
+                dev->features = features;
+                bnx2_set_rx_mode(dev);
+                bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_KEEP_VLAN_UPDATE, 0, 1);
+                bnx2_netif_start(bp, false);
+                return 1;
+        }
+
+        return 0;
 }
 
 static const struct ethtool_ops bnx2_ethtool_ops = {
@@ -7611,18 +7554,11 @@ static const struct ethtool_ops bnx2_ethtool_ops = {
         .set_ringparam          = bnx2_set_ringparam,
         .get_pauseparam         = bnx2_get_pauseparam,
         .set_pauseparam         = bnx2_set_pauseparam,
-        .get_rx_csum            = bnx2_get_rx_csum,
-        .set_rx_csum            = bnx2_set_rx_csum,
-        .set_tx_csum            = bnx2_set_tx_csum,
-        .set_sg                 = ethtool_op_set_sg,
-        .set_tso                = bnx2_set_tso,
         .self_test              = bnx2_self_test,
         .get_strings            = bnx2_get_strings,
-        .phys_id                = bnx2_phys_id,
+        .set_phys_id            = bnx2_set_phys_id,
         .get_ethtool_stats      = bnx2_get_ethtool_stats,
         .get_sset_count         = bnx2_get_sset_count,
-        .set_flags              = bnx2_set_flags,
-        .get_flags              = ethtool_op_get_flags,
 };
 
 /* Called with rtnl_lock */
@@ -7704,7 +7640,7 @@ bnx2_change_mtu(struct net_device *dev, int new_mtu)
                 return -EINVAL;
 
         dev->mtu = new_mtu;
-        return (bnx2_change_ring_size(bp, bp->rx_ring_size, bp->tx_ring_size));
+        return bnx2_change_ring_size(bp, bp->rx_ring_size, bp->tx_ring_size);
 }
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
@@ -7890,6 +7826,7 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
         int rc, i, j;
         u32 reg;
         u64 dma_mask, persist_dma_mask;
+        int err;
 
         SET_NETDEV_DEV(dev, &pdev->dev);
         bp = netdev_priv(dev);
@@ -7926,7 +7863,6 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
         }
 
         pci_set_master(pdev);
-        pci_save_state(pdev);
 
         bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
         if (bp->pm_cap == 0) {
@@ -7959,15 +7895,15 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
                 goto err_out_release;
         }
 
+        bnx2_set_power_state(bp, PCI_D0);
+
         /* Configure byte swap and enable write to the reg_window registers.
          * Rely on CPU to do target byte swapping on big endian systems
          * The chip's target access swapping will not swap all accesses
          */
-        pci_write_config_dword(bp->pdev, BNX2_PCICFG_MISC_CONFIG,
-                               BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
-                               BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP);
-
-        bnx2_set_power_state(bp, PCI_D0);
+        REG_WR(bp, BNX2_PCICFG_MISC_CONFIG,
+                   BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
+                   BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP);
 
         bp->chip_id = REG_RD(bp, BNX2_MISC_ID);
 
@@ -7981,6 +7917,12 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
                 bp->flags |= BNX2_FLAG_PCIE;
                 if (CHIP_REV(bp) == CHIP_REV_Ax)
                         bp->flags |= BNX2_FLAG_JUMBO_BROKEN;
+
+                /* AER (Advanced Error Reporting) hooks */
+                err = pci_enable_pcie_error_reporting(pdev);
+                if (!err)
+                        bp->flags |= BNX2_FLAG_AER_ENABLED;
+
         } else {
                 bp->pcix_cap = pci_find_capability(pdev, PCI_CAP_ID_PCIX);
                 if (bp->pcix_cap == 0) {
@@ -8128,8 +8070,6 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
         bp->tx_ring_size = MAX_TX_DESC_CNT;
         bnx2_set_rx_ring_size(bp, 255);
 
-        bp->rx_csum = 1;
-
         bp->tx_quick_cons_trip_int = 2;
         bp->tx_quick_cons_trip = 20;
         bp->tx_ticks_int = 18;
@@ -8237,9 +8177,16 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
         bp->timer.data = (unsigned long) bp;
         bp->timer.function = bnx2_timer;
 
+        pci_save_state(pdev);
+
         return 0;
 
 err_out_unmap:
+        if (bp->flags & BNX2_FLAG_AER_ENABLED) {
+                pci_disable_pcie_error_reporting(pdev);
+                bp->flags &= ~BNX2_FLAG_AER_ENABLED;
+        }
+
         if (bp->regview) {
                 iounmap(bp->regview);
                 bp->regview = NULL;
@@ -8314,22 +8261,14 @@ static const struct net_device_ops bnx2_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_set_mac_address    = bnx2_change_mac_addr,
         .ndo_change_mtu         = bnx2_change_mtu,
+        .ndo_fix_features       = bnx2_fix_features,
+        .ndo_set_features       = bnx2_set_features,
         .ndo_tx_timeout         = bnx2_tx_timeout,
-#ifdef BCM_VLAN
-        .ndo_vlan_rx_register   = bnx2_vlan_rx_register,
-#endif
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = poll_bnx2,
 #endif
 };
 
-static void inline vlan_features_add(struct net_device *dev, unsigned long flags)
-{
-#ifdef BCM_VLAN
-        dev->vlan_features |= flags;
-#endif
-}
-
 static int __devinit
 bnx2_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
@@ -8369,22 +8308,17 @@ bnx2_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         memcpy(dev->dev_addr, bp->mac_addr, 6);
         memcpy(dev->perm_addr, bp->mac_addr, 6);
 
-        dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_GRO |
-                         NETIF_F_RXHASH;
-        vlan_features_add(dev, NETIF_F_IP_CSUM | NETIF_F_SG);
-        if (CHIP_NUM(bp) == CHIP_NUM_5709) {
-                dev->features |= NETIF_F_IPV6_CSUM;
-                vlan_features_add(dev, NETIF_F_IPV6_CSUM);
-        }
-#ifdef BCM_VLAN
-        dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
-#endif
-        dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
-        vlan_features_add(dev, NETIF_F_TSO | NETIF_F_TSO_ECN);
-        if (CHIP_NUM(bp) == CHIP_NUM_5709) {
-                dev->features |= NETIF_F_TSO6;
-                vlan_features_add(dev, NETIF_F_TSO6);
-        }
+        dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
+                NETIF_F_TSO | NETIF_F_TSO_ECN |
+                NETIF_F_RXHASH | NETIF_F_RXCSUM;
+
+        if (CHIP_NUM(bp) == CHIP_NUM_5709)
+                dev->hw_features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6;
+
+        dev->vlan_features = dev->hw_features;
+        dev->hw_features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
+        dev->features |= dev->hw_features;
+
         if ((rc = register_netdev(dev))) {
                 dev_err(&pdev->dev, "Cannot register net device\n");
                 goto error;
@@ -8421,10 +8355,10 @@ bnx2_remove_one(struct pci_dev *pdev)
         struct net_device *dev = pci_get_drvdata(pdev);
         struct bnx2 *bp = netdev_priv(dev);
 
-        flush_scheduled_work();
-
         unregister_netdev(dev);
 
+        del_timer_sync(&bp->timer);
+
         if (bp->mips_firmware)
                 release_firmware(bp->mips_firmware);
         if (bp->rv2p_firmware)
@@ -8435,7 +8369,13 @@ bnx2_remove_one(struct pci_dev *pdev)
 
         kfree(bp->temp_stats_blk);
 
+        if (bp->flags & BNX2_FLAG_AER_ENABLED) {
+                pci_disable_pcie_error_reporting(pdev);
+                bp->flags &= ~BNX2_FLAG_AER_ENABLED;
+        }
+
         free_netdev(dev);
+
         pci_release_regions(pdev);
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
@@ -8455,7 +8395,7 @@ bnx2_suspend(struct pci_dev *pdev, pm_message_t state)
         if (!netif_running(dev))
                 return 0;
 
-        flush_scheduled_work();
+        cancel_work_sync(&bp->reset_task);
         bnx2_netif_stop(bp, true);
         netif_device_detach(dev);
         del_timer_sync(&bp->timer);
@@ -8527,25 +8467,38 @@ static pci_ers_result_t bnx2_io_slot_reset(struct pci_dev *pdev)
 {
         struct net_device *dev = pci_get_drvdata(pdev);
         struct bnx2 *bp = netdev_priv(dev);
+        pci_ers_result_t result;
+        int err;
 
         rtnl_lock();
         if (pci_enable_device(pdev)) {
                 dev_err(&pdev->dev,
                         "Cannot re-enable PCI device after reset\n");
-                rtnl_unlock();
-                return PCI_ERS_RESULT_DISCONNECT;
+                result = PCI_ERS_RESULT_DISCONNECT;
+        } else {
+                pci_set_master(pdev);
+                pci_restore_state(pdev);
+                pci_save_state(pdev);
+
+                if (netif_running(dev)) {
+                        bnx2_set_power_state(bp, PCI_D0);
+                        bnx2_init_nic(bp, 1);
+                }
+                result = PCI_ERS_RESULT_RECOVERED;
         }
-        pci_set_master(pdev);
-        pci_restore_state(pdev);
-        pci_save_state(pdev);
+        rtnl_unlock();
 
-        if (netif_running(dev)) {
-                bnx2_set_power_state(bp, PCI_D0);
-                bnx2_init_nic(bp, 1);
+        if (!(bp->flags & BNX2_FLAG_AER_ENABLED))
+                return result;
+
+        err = pci_cleanup_aer_uncorrect_error_status(pdev);
+        if (err) {
+                dev_err(&pdev->dev,
+                        "pci_cleanup_aer_uncorrect_error_status failed 0x%0x\n",
+                         err); /* non-fatal, continue */
         }
 
-        rtnl_unlock();
-        return PCI_ERS_RESULT_RECOVERED;
+        return result;
 }
 
 /**