]> err.no Git - linux-2.6/blobdiff - drivers/net/bnx2x_main.c
Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / drivers / net / bnx2x_main.c
index fabde5555e326810c7059f3bd6256948967fc8d9..0263bef9cc6ddfb2cfa428ebe1ad6a104d27b49c 100644 (file)
@@ -60,8 +60,8 @@
 #include "bnx2x.h"
 #include "bnx2x_init.h"
 
-#define DRV_MODULE_VERSION      "1.42.4"
-#define DRV_MODULE_RELDATE      "2008/4/9"
+#define DRV_MODULE_VERSION      "1.45.6"
+#define DRV_MODULE_RELDATE      "2008/06/23"
 #define BNX2X_BC_VER           0x040200
 
 /* Time in jiffies before concluding the transmitter is hung */
@@ -8302,17 +8302,28 @@ static int bnx2x_set_rx_csum(struct net_device *dev, u32 data)
 
 static int bnx2x_set_tso(struct net_device *dev, u32 data)
 {
-       if (data)
+       if (data) {
                dev->features |= (NETIF_F_TSO | NETIF_F_TSO_ECN);
-       else
+               dev->features |= NETIF_F_TSO6;
+       } else {
                dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO_ECN);
+               dev->features &= ~NETIF_F_TSO6;
+       }
+
        return 0;
 }
 
-static struct {
+static const struct {
        char string[ETH_GSTRING_LEN];
 } bnx2x_tests_str_arr[BNX2X_NUM_TESTS] = {
-       { "MC Errors  (online)" }
+       { "register_test (offline)" },
+       { "memory_test (offline)" },
+       { "loopback_test (offline)" },
+       { "nvram_test (online)" },
+       { "interrupt_test (online)" },
+       { "link_test (online)" },
+       { "idle check (online)" },
+       { "MC errors (online)" }
 };
 
 static int bnx2x_self_test_count(struct net_device *dev)
@@ -8320,25 +8331,492 @@ static int bnx2x_self_test_count(struct net_device *dev)
        return BNX2X_NUM_TESTS;
 }
 
+static int bnx2x_test_registers(struct bnx2x *bp)
+{
+       int idx, i, rc = -ENODEV;
+       u32 wr_val = 0;
+       static const struct {
+               u32  offset0;
+               u32  offset1;
+               u32  mask;
+       } reg_tbl[] = {
+/* 0 */                { BRB1_REG_PAUSE_LOW_THRESHOLD_0,      4, 0x000003ff },
+               { DORQ_REG_DB_ADDR0,                   4, 0xffffffff },
+               { HC_REG_AGG_INT_0,                    4, 0x000003ff },
+               { PBF_REG_MAC_IF0_ENABLE,              4, 0x00000001 },
+               { PBF_REG_P0_INIT_CRD,                 4, 0x000007ff },
+               { PRS_REG_CID_PORT_0,                  4, 0x00ffffff },
+               { PXP2_REG_PSWRQ_CDU0_L2P,             4, 0x000fffff },
+               { PXP2_REG_RQ_CDU0_EFIRST_MEM_ADDR,    8, 0x0003ffff },
+               { PXP2_REG_PSWRQ_TM0_L2P,              4, 0x000fffff },
+               { PXP2_REG_RQ_USDM0_EFIRST_MEM_ADDR,   8, 0x0003ffff },
+/* 10 */       { PXP2_REG_PSWRQ_TSDM0_L2P,            4, 0x000fffff },
+               { QM_REG_CONNNUM_0,                    4, 0x000fffff },
+               { TM_REG_LIN0_MAX_ACTIVE_CID,          4, 0x0003ffff },
+               { SRC_REG_KEYRSS0_0,                  40, 0xffffffff },
+               { SRC_REG_KEYRSS0_7,                  40, 0xffffffff },
+               { XCM_REG_WU_DA_SET_TMR_CNT_FLG_CMD00, 4, 0x00000001 },
+               { XCM_REG_WU_DA_CNT_CMD00,             4, 0x00000003 },
+               { XCM_REG_GLB_DEL_ACK_MAX_CNT_0,       4, 0x000000ff },
+               { NIG_REG_EGRESS_MNG0_FIFO,           20, 0xffffffff },
+               { NIG_REG_LLH0_T_BIT,                  4, 0x00000001 },
+/* 20 */       { NIG_REG_EMAC0_IN_EN,                 4, 0x00000001 },
+               { NIG_REG_BMAC0_IN_EN,                 4, 0x00000001 },
+               { NIG_REG_XCM0_OUT_EN,                 4, 0x00000001 },
+               { NIG_REG_BRB0_OUT_EN,                 4, 0x00000001 },
+               { NIG_REG_LLH0_XCM_MASK,               4, 0x00000007 },
+               { NIG_REG_LLH0_ACPI_PAT_6_LEN,        68, 0x000000ff },
+               { NIG_REG_LLH0_ACPI_PAT_0_CRC,        68, 0xffffffff },
+               { NIG_REG_LLH0_DEST_MAC_0_0,         160, 0xffffffff },
+               { NIG_REG_LLH0_DEST_IP_0_1,          160, 0xffffffff },
+               { NIG_REG_LLH0_IPV4_IPV6_0,          160, 0x00000001 },
+/* 30 */       { NIG_REG_LLH0_DEST_UDP_0,           160, 0x0000ffff },
+               { NIG_REG_LLH0_DEST_TCP_0,           160, 0x0000ffff },
+               { NIG_REG_LLH0_VLAN_ID_0,            160, 0x00000fff },
+               { NIG_REG_XGXS_SERDES0_MODE_SEL,       4, 0x00000001 },
+               { NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0, 4, 0x00000001 },
+               { NIG_REG_STATUS_INTERRUPT_PORT0,      4, 0x07ffffff },
+               { NIG_REG_XGXS0_CTRL_EXTREMOTEMDIOST, 24, 0x00000001 },
+               { NIG_REG_SERDES0_CTRL_PHY_ADDR,      16, 0x0000001f },
+
+               { 0xffffffff, 0, 0x00000000 }
+       };
+
+       if (!netif_running(bp->dev))
+               return rc;
+
+       /* Repeat the test twice:
+          First by writing 0x00000000, second by writing 0xffffffff */
+       for (idx = 0; idx < 2; idx++) {
+
+               switch (idx) {
+               case 0:
+                       wr_val = 0;
+                       break;
+               case 1:
+                       wr_val = 0xffffffff;
+                       break;
+               }
+
+               for (i = 0; reg_tbl[i].offset0 != 0xffffffff; i++) {
+                       u32 offset, mask, save_val, val;
+                       int port = BP_PORT(bp);
+
+                       offset = reg_tbl[i].offset0 + port*reg_tbl[i].offset1;
+                       mask = reg_tbl[i].mask;
+
+                       save_val = REG_RD(bp, offset);
+
+                       REG_WR(bp, offset, wr_val);
+                       val = REG_RD(bp, offset);
+
+                       /* Restore the original register's value */
+                       REG_WR(bp, offset, save_val);
+
+                       /* verify that value is as expected value */
+                       if ((val & mask) != (wr_val & mask))
+                               goto test_reg_exit;
+               }
+       }
+
+       rc = 0;
+
+test_reg_exit:
+       return rc;
+}
+
+static int bnx2x_test_memory(struct bnx2x *bp)
+{
+       int i, j, rc = -ENODEV;
+       u32 val;
+       static const struct {
+               u32 offset;
+               int size;
+       } mem_tbl[] = {
+               { CCM_REG_XX_DESCR_TABLE,   CCM_REG_XX_DESCR_TABLE_SIZE },
+               { CFC_REG_ACTIVITY_COUNTER, CFC_REG_ACTIVITY_COUNTER_SIZE },
+               { CFC_REG_LINK_LIST,        CFC_REG_LINK_LIST_SIZE },
+               { DMAE_REG_CMD_MEM,         DMAE_REG_CMD_MEM_SIZE },
+               { TCM_REG_XX_DESCR_TABLE,   TCM_REG_XX_DESCR_TABLE_SIZE },
+               { UCM_REG_XX_DESCR_TABLE,   UCM_REG_XX_DESCR_TABLE_SIZE },
+               { XCM_REG_XX_DESCR_TABLE,   XCM_REG_XX_DESCR_TABLE_SIZE },
+
+               { 0xffffffff, 0 }
+       };
+       static const struct {
+               char *name;
+               u32 offset;
+               u32 mask;
+       } prty_tbl[] = {
+               { "CCM_REG_CCM_PRTY_STS",     CCM_REG_CCM_PRTY_STS,     0 },
+               { "CFC_REG_CFC_PRTY_STS",     CFC_REG_CFC_PRTY_STS,     0 },
+               { "DMAE_REG_DMAE_PRTY_STS",   DMAE_REG_DMAE_PRTY_STS,   0 },
+               { "TCM_REG_TCM_PRTY_STS",     TCM_REG_TCM_PRTY_STS,     0 },
+               { "UCM_REG_UCM_PRTY_STS",     UCM_REG_UCM_PRTY_STS,     0 },
+               { "XCM_REG_XCM_PRTY_STS",     XCM_REG_XCM_PRTY_STS,     0x1 },
+
+               { NULL, 0xffffffff, 0 }
+       };
+
+       if (!netif_running(bp->dev))
+               return rc;
+
+       /* Go through all the memories */
+       for (i = 0; mem_tbl[i].offset != 0xffffffff; i++)
+               for (j = 0; j < mem_tbl[i].size; j++)
+                       REG_RD(bp, mem_tbl[i].offset + j*4);
+
+       /* Check the parity status */
+       for (i = 0; prty_tbl[i].offset != 0xffffffff; i++) {
+               val = REG_RD(bp, prty_tbl[i].offset);
+               if (val & ~(prty_tbl[i].mask)) {
+                       DP(NETIF_MSG_HW,
+                          "%s is 0x%x\n", prty_tbl[i].name, val);
+                       goto test_mem_exit;
+               }
+       }
+
+       rc = 0;
+
+test_mem_exit:
+       return rc;
+}
+
+static void bnx2x_netif_start(struct bnx2x *bp)
+{
+       int i;
+
+       if (atomic_dec_and_test(&bp->intr_sem)) {
+               if (netif_running(bp->dev)) {
+                       bnx2x_int_enable(bp);
+                       for_each_queue(bp, i)
+                               napi_enable(&bnx2x_fp(bp, i, napi));
+                       if (bp->state == BNX2X_STATE_OPEN)
+                               netif_wake_queue(bp->dev);
+               }
+       }
+}
+
+static void bnx2x_netif_stop(struct bnx2x *bp)
+{
+       int i;
+
+       if (netif_running(bp->dev)) {
+               netif_tx_disable(bp->dev);
+               bp->dev->trans_start = jiffies; /* prevent tx timeout */
+               for_each_queue(bp, i)
+                       napi_disable(&bnx2x_fp(bp, i, napi));
+       }
+       bnx2x_int_disable_sync(bp);
+}
+
+static void bnx2x_wait_for_link(struct bnx2x *bp, u8 link_up)
+{
+       int cnt = 1000;
+
+       if (link_up)
+               while (bnx2x_link_test(bp) && cnt--)
+                       msleep(10);
+}
+
+static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
+{
+       unsigned int pkt_size, num_pkts, i;
+       struct sk_buff *skb;
+       unsigned char *packet;
+       struct bnx2x_fastpath *fp = &bp->fp[0];
+       u16 tx_start_idx, tx_idx;
+       u16 rx_start_idx, rx_idx;
+       u16 pkt_prod;
+       struct sw_tx_bd *tx_buf;
+       struct eth_tx_bd *tx_bd;
+       dma_addr_t mapping;
+       union eth_rx_cqe *cqe;
+       u8 cqe_fp_flags;
+       struct sw_rx_bd *rx_buf;
+       u16 len;
+       int rc = -ENODEV;
+
+       if (loopback_mode == BNX2X_MAC_LOOPBACK) {
+               bp->link_params.loopback_mode = LOOPBACK_BMAC;
+               bnx2x_phy_hw_lock(bp);
+               bnx2x_phy_init(&bp->link_params, &bp->link_vars);
+               bnx2x_phy_hw_unlock(bp);
+
+       } else if (loopback_mode == BNX2X_PHY_LOOPBACK) {
+               bp->link_params.loopback_mode = LOOPBACK_XGXS_10;
+               bnx2x_phy_hw_lock(bp);
+               bnx2x_phy_init(&bp->link_params, &bp->link_vars);
+               bnx2x_phy_hw_unlock(bp);
+               /* wait until link state is restored */
+               bnx2x_wait_for_link(bp, link_up);
+
+       } else
+               return -EINVAL;
+
+       pkt_size = 1514;
+       skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
+       if (!skb) {
+               rc = -ENOMEM;
+               goto test_loopback_exit;
+       }
+       packet = skb_put(skb, pkt_size);
+       memcpy(packet, bp->dev->dev_addr, ETH_ALEN);
+       memset(packet + ETH_ALEN, 0, (ETH_HLEN - ETH_ALEN));
+       for (i = ETH_HLEN; i < pkt_size; i++)
+               packet[i] = (unsigned char) (i & 0xff);
+
+       num_pkts = 0;
+       tx_start_idx = le16_to_cpu(*fp->tx_cons_sb);
+       rx_start_idx = le16_to_cpu(*fp->rx_cons_sb);
+
+       pkt_prod = fp->tx_pkt_prod++;
+       tx_buf = &fp->tx_buf_ring[TX_BD(pkt_prod)];
+       tx_buf->first_bd = fp->tx_bd_prod;
+       tx_buf->skb = skb;
+
+       tx_bd = &fp->tx_desc_ring[TX_BD(fp->tx_bd_prod)];
+       mapping = pci_map_single(bp->pdev, skb->data,
+                                skb_headlen(skb), PCI_DMA_TODEVICE);
+       tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
+       tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
+       tx_bd->nbd = cpu_to_le16(1);
+       tx_bd->nbytes = cpu_to_le16(skb_headlen(skb));
+       tx_bd->vlan = cpu_to_le16(pkt_prod);
+       tx_bd->bd_flags.as_bitfield = (ETH_TX_BD_FLAGS_START_BD |
+                                      ETH_TX_BD_FLAGS_END_BD);
+       tx_bd->general_data = ((UNICAST_ADDRESS <<
+                               ETH_TX_BD_ETH_ADDR_TYPE_SHIFT) | 1);
+
+       fp->hw_tx_prods->bds_prod =
+               cpu_to_le16(le16_to_cpu(fp->hw_tx_prods->bds_prod) + 1);
+       mb(); /* FW restriction: must not reorder writing nbd and packets */
+       fp->hw_tx_prods->packets_prod =
+               cpu_to_le32(le32_to_cpu(fp->hw_tx_prods->packets_prod) + 1);
+       DOORBELL(bp, FP_IDX(fp), 0);
+
+       mmiowb();
+
+       num_pkts++;
+       fp->tx_bd_prod++;
+       bp->dev->trans_start = jiffies;
+
+       udelay(100);
+
+       tx_idx = le16_to_cpu(*fp->tx_cons_sb);
+       if (tx_idx != tx_start_idx + num_pkts)
+               goto test_loopback_exit;
+
+       rx_idx = le16_to_cpu(*fp->rx_cons_sb);
+       if (rx_idx != rx_start_idx + num_pkts)
+               goto test_loopback_exit;
+
+       cqe = &fp->rx_comp_ring[RCQ_BD(fp->rx_comp_cons)];
+       cqe_fp_flags = cqe->fast_path_cqe.type_error_flags;
+       if (CQE_TYPE(cqe_fp_flags) || (cqe_fp_flags & ETH_RX_ERROR_FALGS))
+               goto test_loopback_rx_exit;
+
+       len = le16_to_cpu(cqe->fast_path_cqe.pkt_len);
+       if (len != pkt_size)
+               goto test_loopback_rx_exit;
+
+       rx_buf = &fp->rx_buf_ring[RX_BD(fp->rx_bd_cons)];
+       skb = rx_buf->skb;
+       skb_reserve(skb, cqe->fast_path_cqe.placement_offset);
+       for (i = ETH_HLEN; i < pkt_size; i++)
+               if (*(skb->data + i) != (unsigned char) (i & 0xff))
+                       goto test_loopback_rx_exit;
+
+       rc = 0;
+
+test_loopback_rx_exit:
+       bp->dev->last_rx = jiffies;
+
+       fp->rx_bd_cons = NEXT_RX_IDX(fp->rx_bd_cons);
+       fp->rx_bd_prod = NEXT_RX_IDX(fp->rx_bd_prod);
+       fp->rx_comp_cons = NEXT_RCQ_IDX(fp->rx_comp_cons);
+       fp->rx_comp_prod = NEXT_RCQ_IDX(fp->rx_comp_prod);
+
+       /* Update producers */
+       bnx2x_update_rx_prod(bp, fp, fp->rx_bd_prod, fp->rx_comp_prod,
+                            fp->rx_sge_prod);
+       mmiowb(); /* keep prod updates ordered */
+
+test_loopback_exit:
+       bp->link_params.loopback_mode = LOOPBACK_NONE;
+
+       return rc;
+}
+
+static int bnx2x_test_loopback(struct bnx2x *bp, u8 link_up)
+{
+       int rc = 0;
+
+       if (!netif_running(bp->dev))
+               return BNX2X_LOOPBACK_FAILED;
+
+       bnx2x_netif_stop(bp);
+
+       if (bnx2x_run_loopback(bp, BNX2X_MAC_LOOPBACK, link_up)) {
+               DP(NETIF_MSG_PROBE, "MAC loopback failed\n");
+               rc |= BNX2X_MAC_LOOPBACK_FAILED;
+       }
+
+       if (bnx2x_run_loopback(bp, BNX2X_PHY_LOOPBACK, link_up)) {
+               DP(NETIF_MSG_PROBE, "PHY loopback failed\n");
+               rc |= BNX2X_PHY_LOOPBACK_FAILED;
+       }
+
+       bnx2x_netif_start(bp);
+
+       return rc;
+}
+
+#define CRC32_RESIDUAL                 0xdebb20e3
+
+static int bnx2x_test_nvram(struct bnx2x *bp)
+{
+       static const struct {
+               int offset;
+               int size;
+       } nvram_tbl[] = {
+               {     0,  0x14 }, /* bootstrap */
+               {  0x14,  0xec }, /* dir */
+               { 0x100, 0x350 }, /* manuf_info */
+               { 0x450,  0xf0 }, /* feature_info */
+               { 0x640,  0x64 }, /* upgrade_key_info */
+               { 0x6a4,  0x64 },
+               { 0x708,  0x70 }, /* manuf_key_info */
+               { 0x778,  0x70 },
+               {     0,     0 }
+       };
+       u32 buf[0x350 / 4];
+       u8 *data = (u8 *)buf;
+       int i, rc;
+       u32 magic, csum;
+
+       rc = bnx2x_nvram_read(bp, 0, data, 4);
+       if (rc) {
+               DP(NETIF_MSG_PROBE, "magic value read (rc -%d)\n", -rc);
+               goto test_nvram_exit;
+       }
+
+       magic = be32_to_cpu(buf[0]);
+       if (magic != 0x669955aa) {
+               DP(NETIF_MSG_PROBE, "magic value (0x%08x)\n", magic);
+               rc = -ENODEV;
+               goto test_nvram_exit;
+       }
+
+       for (i = 0; nvram_tbl[i].size; i++) {
+
+               rc = bnx2x_nvram_read(bp, nvram_tbl[i].offset, data,
+                                     nvram_tbl[i].size);
+               if (rc) {
+                       DP(NETIF_MSG_PROBE,
+                          "nvram_tbl[%d] read data (rc -%d)\n", i, -rc);
+                       goto test_nvram_exit;
+               }
+
+               csum = ether_crc_le(nvram_tbl[i].size, data);
+               if (csum != CRC32_RESIDUAL) {
+                       DP(NETIF_MSG_PROBE,
+                          "nvram_tbl[%d] csum value (0x%08x)\n", i, csum);
+                       rc = -ENODEV;
+                       goto test_nvram_exit;
+               }
+       }
+
+test_nvram_exit:
+       return rc;
+}
+
+static int bnx2x_test_intr(struct bnx2x *bp)
+{
+       struct mac_configuration_cmd *config = bnx2x_sp(bp, mac_config);
+       int i, rc;
+
+       if (!netif_running(bp->dev))
+               return -ENODEV;
+
+       config->hdr.length_6b = 0;
+       config->hdr.offset = 0;
+       config->hdr.client_id = BP_CL_ID(bp);
+       config->hdr.reserved1 = 0;
+
+       rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
+                          U64_HI(bnx2x_sp_mapping(bp, mac_config)),
+                          U64_LO(bnx2x_sp_mapping(bp, mac_config)), 0);
+       if (rc == 0) {
+               bp->set_mac_pending++;
+               for (i = 0; i < 10; i++) {
+                       if (!bp->set_mac_pending)
+                               break;
+                       msleep_interruptible(10);
+               }
+               if (i == 10)
+                       rc = -ENODEV;
+       }
+
+       return rc;
+}
+
 static void bnx2x_self_test(struct net_device *dev,
                            struct ethtool_test *etest, u64 *buf)
 {
        struct bnx2x *bp = netdev_priv(dev);
-       int stats_state;
 
        memset(buf, 0, sizeof(u64) * BNX2X_NUM_TESTS);
 
-       if (bp->state != BNX2X_STATE_OPEN) {
-               DP(NETIF_MSG_PROBE, "state is %x, returning\n", bp->state);
+       if (!netif_running(dev))
                return;
-       }
 
-       stats_state = bp->stats_state;
+       /* offline tests are not suppoerted in MF mode */
+       if (IS_E1HMF(bp))
+               etest->flags &= ~ETH_TEST_FL_OFFLINE;
+
+       if (etest->flags & ETH_TEST_FL_OFFLINE) {
+               u8 link_up;
+
+               link_up = bp->link_vars.link_up;
+               bnx2x_nic_unload(bp, UNLOAD_NORMAL);
+               bnx2x_nic_load(bp, LOAD_DIAG);
+               /* wait until link state is restored */
+               bnx2x_wait_for_link(bp, link_up);
 
-       if (bnx2x_mc_assert(bp) != 0) {
-               buf[0] = 1;
+               if (bnx2x_test_registers(bp) != 0) {
+                       buf[0] = 1;
+                       etest->flags |= ETH_TEST_FL_FAILED;
+               }
+               if (bnx2x_test_memory(bp) != 0) {
+                       buf[1] = 1;
+                       etest->flags |= ETH_TEST_FL_FAILED;
+               }
+               buf[2] = bnx2x_test_loopback(bp, link_up);
+               if (buf[2] != 0)
+                       etest->flags |= ETH_TEST_FL_FAILED;
+
+               bnx2x_nic_unload(bp, UNLOAD_NORMAL);
+               bnx2x_nic_load(bp, LOAD_NORMAL);
+               /* wait until link state is restored */
+               bnx2x_wait_for_link(bp, link_up);
+       }
+       if (bnx2x_test_nvram(bp) != 0) {
+               buf[3] = 1;
                etest->flags |= ETH_TEST_FL_FAILED;
        }
+       if (bnx2x_test_intr(bp) != 0) {
+               buf[4] = 1;
+               etest->flags |= ETH_TEST_FL_FAILED;
+       }
+       if (bp->port.pmf)
+               if (bnx2x_link_test(bp) != 0) {
+                       buf[5] = 1;
+                       etest->flags |= ETH_TEST_FL_FAILED;
+               }
+       buf[7] = bnx2x_mc_assert(bp);
+       if (buf[7] != 0)
+               etest->flags |= ETH_TEST_FL_FAILED;
 
 #ifdef BNX2X_EXTRA_DEBUG
        bnx2x_panic_dump(bp);
@@ -8545,7 +9023,7 @@ static struct ethtool_ops bnx2x_ethtool_ops = {
        .get_rx_csum            = bnx2x_get_rx_csum,
        .set_rx_csum            = bnx2x_set_rx_csum,
        .get_tx_csum            = ethtool_op_get_tx_csum,
-       .set_tx_csum            = ethtool_op_set_tx_csum,
+       .set_tx_csum            = ethtool_op_set_tx_hw_csum,
        .set_flags              = bnx2x_set_flags,
        .get_flags              = ethtool_op_get_flags,
        .get_sg                 = ethtool_op_get_sg,
@@ -8651,9 +9129,180 @@ poll_panic:
        return work_done;
 }
 
-/* Called with netif_tx_lock.
+
+/* we split the first BD into headers and data BDs
+ * to ease the pain of our fellow micocode engineers
+ * we use one mapping for both BDs
+ * So far this has only been observed to happen
+ * in Other Operating Systems(TM)
+ */
+static noinline u16 bnx2x_tx_split(struct bnx2x *bp,
+                                  struct bnx2x_fastpath *fp,
+                                  struct eth_tx_bd **tx_bd, u16 hlen,
+                                  u16 bd_prod, int nbd)
+{
+       struct eth_tx_bd *h_tx_bd = *tx_bd;
+       struct eth_tx_bd *d_tx_bd;
+       dma_addr_t mapping;
+       int old_len = le16_to_cpu(h_tx_bd->nbytes);
+
+       /* first fix first BD */
+       h_tx_bd->nbd = cpu_to_le16(nbd);
+       h_tx_bd->nbytes = cpu_to_le16(hlen);
+
+       DP(NETIF_MSG_TX_QUEUED, "TSO split header size is %d "
+          "(%x:%x) nbd %d\n", h_tx_bd->nbytes, h_tx_bd->addr_hi,
+          h_tx_bd->addr_lo, h_tx_bd->nbd);
+
+       /* now get a new data BD
+        * (after the pbd) and fill it */
+       bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
+       d_tx_bd = &fp->tx_desc_ring[bd_prod];
+
+       mapping = HILO_U64(le32_to_cpu(h_tx_bd->addr_hi),
+                          le32_to_cpu(h_tx_bd->addr_lo)) + hlen;
+
+       d_tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
+       d_tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
+       d_tx_bd->nbytes = cpu_to_le16(old_len - hlen);
+       d_tx_bd->vlan = 0;
+       /* this marks the BD as one that has no individual mapping
+        * the FW ignores this flag in a BD not marked start
+        */
+       d_tx_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_SW_LSO;
+       DP(NETIF_MSG_TX_QUEUED,
+          "TSO split data size is %d (%x:%x)\n",
+          d_tx_bd->nbytes, d_tx_bd->addr_hi, d_tx_bd->addr_lo);
+
+       /* update tx_bd for marking the last BD flag */
+       *tx_bd = d_tx_bd;
+
+       return bd_prod;
+}
+
+static inline u16 bnx2x_csum_fix(unsigned char *t_header, u16 csum, s8 fix)
+{
+       if (fix > 0)
+               csum = (u16) ~csum_fold(csum_sub(csum,
+                               csum_partial(t_header - fix, fix, 0)));
+
+       else if (fix < 0)
+               csum = (u16) ~csum_fold(csum_add(csum,
+                               csum_partial(t_header, -fix, 0)));
+
+       return swab16(csum);
+}
+
+static inline u32 bnx2x_xmit_type(struct bnx2x *bp, struct sk_buff *skb)
+{
+       u32 rc;
+
+       if (skb->ip_summed != CHECKSUM_PARTIAL)
+               rc = XMIT_PLAIN;
+
+       else {
+               if (skb->protocol == ntohs(ETH_P_IPV6)) {
+                       rc = XMIT_CSUM_V6;
+                       if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
+                               rc |= XMIT_CSUM_TCP;
+
+               } else {
+                       rc = XMIT_CSUM_V4;
+                       if (ip_hdr(skb)->protocol == IPPROTO_TCP)
+                               rc |= XMIT_CSUM_TCP;
+               }
+       }
+
+       if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
+               rc |= XMIT_GSO_V4;
+
+       else if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
+               rc |= XMIT_GSO_V6;
+
+       return rc;
+}
+
+/* check if packet requires linearization (packet is too fragmented) */
+static int bnx2x_pkt_req_lin(struct bnx2x *bp, struct sk_buff *skb,
+                            u32 xmit_type)
+{
+       int to_copy = 0;
+       int hlen = 0;
+       int first_bd_sz = 0;
+
+       /* 3 = 1 (for linear data BD) + 2 (for PBD and last BD) */
+       if (skb_shinfo(skb)->nr_frags >= (MAX_FETCH_BD - 3)) {
+
+               if (xmit_type & XMIT_GSO) {
+                       unsigned short lso_mss = skb_shinfo(skb)->gso_size;
+                       /* Check if LSO packet needs to be copied:
+                          3 = 1 (for headers BD) + 2 (for PBD and last BD) */
+                       int wnd_size = MAX_FETCH_BD - 3;
+                       /* Number of widnows to check */
+                       int num_wnds = skb_shinfo(skb)->nr_frags - wnd_size;
+                       int wnd_idx = 0;
+                       int frag_idx = 0;
+                       u32 wnd_sum = 0;
+
+                       /* Headers length */
+                       hlen = (int)(skb_transport_header(skb) - skb->data) +
+                               tcp_hdrlen(skb);
+
+                       /* Amount of data (w/o headers) on linear part of SKB*/
+                       first_bd_sz = skb_headlen(skb) - hlen;
+
+                       wnd_sum  = first_bd_sz;
+
+                       /* Calculate the first sum - it's special */
+                       for (frag_idx = 0; frag_idx < wnd_size - 1; frag_idx++)
+                               wnd_sum +=
+                                       skb_shinfo(skb)->frags[frag_idx].size;
+
+                       /* If there was data on linear skb data - check it */
+                       if (first_bd_sz > 0) {
+                               if (unlikely(wnd_sum < lso_mss)) {
+                                       to_copy = 1;
+                                       goto exit_lbl;
+                               }
+
+                               wnd_sum -= first_bd_sz;
+                       }
+
+                       /* Others are easier: run through the frag list and
+                          check all windows */
+                       for (wnd_idx = 0; wnd_idx <= num_wnds; wnd_idx++) {
+                               wnd_sum +=
+                         skb_shinfo(skb)->frags[wnd_idx + wnd_size - 1].size;
+
+                               if (unlikely(wnd_sum < lso_mss)) {
+                                       to_copy = 1;
+                                       break;
+                               }
+                               wnd_sum -=
+                                       skb_shinfo(skb)->frags[wnd_idx].size;
+                       }
+
+               } else {
+                       /* in non-LSO too fragmented packet should always
+                          be linearized */
+                       to_copy = 1;
+               }
+       }
+
+exit_lbl:
+       if (unlikely(to_copy))
+               DP(NETIF_MSG_TX_QUEUED,
+                  "Linearization IS REQUIRED for %s packet. "
+                  "num_frags %d  hlen %d  first_bd_sz %d\n",
+                  (xmit_type & XMIT_GSO) ? "LSO" : "non-LSO",
+                  skb_shinfo(skb)->nr_frags, hlen, first_bd_sz);
+
+       return to_copy;
+}
+
+/* called with netif_tx_lock
  * bnx2x_tx_int() runs without netif_tx_lock unless it needs to call
- * netif_wake_queue().
+ * netif_wake_queue()
  */
 static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
@@ -8663,17 +9312,21 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
        struct eth_tx_bd *tx_bd;
        struct eth_tx_parse_bd *pbd = NULL;
        u16 pkt_prod, bd_prod;
-       int nbd, fp_index = 0;
+       int nbd, fp_index;
        dma_addr_t mapping;
+       u32 xmit_type = bnx2x_xmit_type(bp, skb);
+       int vlan_off = (bp->e1hov ? 4 : 0);
+       int i;
+       u8 hlen = 0;
 
 #ifdef BNX2X_STOP_ON_ERROR
        if (unlikely(bp->panic))
                return NETDEV_TX_BUSY;
 #endif
 
-       fp_index = smp_processor_id() % (bp->num_queues);
-
+       fp_index = (smp_processor_id() % bp->num_queues);
        fp = &bp->fp[fp_index];
+
        if (unlikely(bnx2x_tx_avail(bp->fp) <
                                        (skb_shinfo(skb)->nr_frags + 3))) {
                bp->eth_stats.driver_xoff++,
@@ -8682,20 +9335,37 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                return NETDEV_TX_BUSY;
        }
 
+       DP(NETIF_MSG_TX_QUEUED, "SKB: summed %x  protocol %x  protocol(%x,%x)"
+          "  gso type %x  xmit_type %x\n",
+          skb->ip_summed, skb->protocol, ipv6_hdr(skb)->nexthdr,
+          ip_hdr(skb)->protocol, skb_shinfo(skb)->gso_type, xmit_type);
+
+       /* First, check if we need to linearaize the skb
+          (due to FW restrictions) */
+       if (bnx2x_pkt_req_lin(bp, skb, xmit_type)) {
+               /* Statistics of linearization */
+               bp->lin_cnt++;
+               if (skb_linearize(skb) != 0) {
+                       DP(NETIF_MSG_TX_QUEUED, "SKB linearization failed - "
+                          "silently dropping this SKB\n");
+                       dev_kfree_skb_any(skb);
+                       return 0;
+               }
+       }
+
        /*
-       This is a bit ugly. First we use one BD which we mark as start,
+       Please read carefully. First we use one BD which we mark as start,
        then for TSO or xsum we have a parsing info BD,
-       and only then we have the rest of the TSO bds.
+       and only then we have the rest of the TSO BDs.
        (don't forget to mark the last one as last,
        and to unmap only AFTER you write to the BD ...)
-       I would like to thank DovH for this mess.
+       And above all, all pdb sizes are in words - NOT DWORDS!
        */
 
        pkt_prod = fp->tx_pkt_prod++;
-       bd_prod = fp->tx_bd_prod;
-       bd_prod = TX_BD(bd_prod);
+       bd_prod = TX_BD(fp->tx_bd_prod);
 
-       /* get a tx_buff and first bd */
+       /* get a tx_buf and first BD */
        tx_buf = &fp->tx_buf_ring[TX_BD(pkt_prod)];
        tx_bd = &fp->tx_desc_ring[bd_prod];
 
@@ -8704,65 +9374,80 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                               ETH_TX_BD_ETH_ADDR_TYPE_SHIFT);
        tx_bd->general_data |= 1; /* header nbd */
 
-       /* remember the first bd of the packet */
-       tx_buf->first_bd = bd_prod;
+       /* remember the first BD of the packet */
+       tx_buf->first_bd = fp->tx_bd_prod;
+       tx_buf->skb = skb;
 
        DP(NETIF_MSG_TX_QUEUED,
           "sending pkt %u @%p  next_idx %u  bd %u @%p\n",
           pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_bd);
 
-       if (skb->ip_summed == CHECKSUM_PARTIAL) {
-               struct iphdr *iph = ip_hdr(skb);
-               u8 len;
+       if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb)) {
+               tx_bd->vlan = cpu_to_le16(vlan_tx_tag_get(skb));
+               tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_VLAN_TAG;
+               vlan_off += 4;
+       } else
+               tx_bd->vlan = cpu_to_le16(pkt_prod);
 
-               tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_IP_CSUM;
+       if (xmit_type) {
 
-               /* turn on parsing and get a bd */
+               /* turn on parsing and get a BD */
                bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
                pbd = (void *)&fp->tx_desc_ring[bd_prod];
-               len = ((u8 *)iph - (u8 *)skb->data) / 2;
+
+               memset(pbd, 0, sizeof(struct eth_tx_parse_bd));
+       }
+
+       if (xmit_type & XMIT_CSUM) {
+               hlen = (skb_network_header(skb) - skb->data + vlan_off) / 2;
 
                /* for now NS flag is not used in Linux */
-               pbd->global_data = (len |
+               pbd->global_data = (hlen |
                                    ((skb->protocol == ntohs(ETH_P_8021Q)) <<
                                     ETH_TX_PARSE_BD_LLC_SNAP_EN_SHIFT));
-               pbd->ip_hlen = ip_hdrlen(skb) / 2;
-               pbd->total_hlen = cpu_to_le16(len + pbd->ip_hlen);
-               if (iph->protocol == IPPROTO_TCP) {
-                       struct tcphdr *th = tcp_hdr(skb);
 
-                       tx_bd->bd_flags.as_bitfield |=
-                                               ETH_TX_BD_FLAGS_TCP_CSUM;
-                       pbd->tcp_flags = pbd_tcp_flags(skb);
-                       pbd->total_hlen += cpu_to_le16(tcp_hdrlen(skb) / 2);
-                       pbd->tcp_pseudo_csum = swab16(th->check);
+               pbd->ip_hlen = (skb_transport_header(skb) -
+                               skb_network_header(skb)) / 2;
+
+               hlen += pbd->ip_hlen + tcp_hdrlen(skb) / 2;
+
+               pbd->total_hlen = cpu_to_le16(hlen);
+               hlen = hlen*2 - vlan_off;
 
-               } else if (iph->protocol == IPPROTO_UDP) {
-                       struct udphdr *uh = udp_hdr(skb);
+               tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_TCP_CSUM;
 
+               if (xmit_type & XMIT_CSUM_V4)
                        tx_bd->bd_flags.as_bitfield |=
-                                               ETH_TX_BD_FLAGS_TCP_CSUM;
-                       pbd->total_hlen += cpu_to_le16(4);
+                                               ETH_TX_BD_FLAGS_IP_CSUM;
+               else
+                       tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_IPV6;
+
+               if (xmit_type & XMIT_CSUM_TCP) {
+                       pbd->tcp_pseudo_csum = swab16(tcp_hdr(skb)->check);
+
+               } else {
+                       s8 fix = SKB_CS_OFF(skb); /* signed! */
+
                        pbd->global_data |= ETH_TX_PARSE_BD_CS_ANY_FLG;
-                       pbd->cs_offset = 5; /* 10 >> 1 */
-                       pbd->tcp_pseudo_csum = 0;
-                       /* HW bug: we need to subtract 10 bytes before the
-                        * UDP header from the csum
-                        */
-                       uh->check = (u16) ~csum_fold(csum_sub(uh->check,
-                               csum_partial(((u8 *)(uh)-10), 10, 0)));
-               }
-       }
+                       pbd->cs_offset = fix / 2;
 
-       if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb)) {
-               tx_bd->vlan = cpu_to_le16(vlan_tx_tag_get(skb));
-               tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_VLAN_TAG;
-       } else {
-               tx_bd->vlan = cpu_to_le16(pkt_prod);
+                       DP(NETIF_MSG_TX_QUEUED,
+                          "hlen %d  offset %d  fix %d  csum before fix %x\n",
+                          le16_to_cpu(pbd->total_hlen), pbd->cs_offset, fix,
+                          SKB_CS(skb));
+
+                       /* HW bug: fixup the CSUM */
+                       pbd->tcp_pseudo_csum =
+                               bnx2x_csum_fix(skb_transport_header(skb),
+                                              SKB_CS(skb), fix);
+
+                       DP(NETIF_MSG_TX_QUEUED, "csum after fix %x\n",
+                          pbd->tcp_pseudo_csum);
+               }
        }
 
        mapping = pci_map_single(bp->pdev, skb->data,
-                                skb->len, PCI_DMA_TODEVICE);
+                                skb_headlen(skb), PCI_DMA_TODEVICE);
 
        tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
        tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
@@ -8771,13 +9456,12 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
        tx_bd->nbytes = cpu_to_le16(skb_headlen(skb));
 
        DP(NETIF_MSG_TX_QUEUED, "first bd @%p  addr (%x:%x)  nbd %d"
-          "  nbytes %d  flags %x  vlan %u\n",
-          tx_bd, tx_bd->addr_hi, tx_bd->addr_lo, tx_bd->nbd,
-          tx_bd->nbytes, tx_bd->bd_flags.as_bitfield, tx_bd->vlan);
+          "  nbytes %d  flags %x  vlan %x\n",
+          tx_bd, tx_bd->addr_hi, tx_bd->addr_lo, le16_to_cpu(tx_bd->nbd),
+          le16_to_cpu(tx_bd->nbytes), tx_bd->bd_flags.as_bitfield,
+          le16_to_cpu(tx_bd->vlan));
 
-       if (skb_shinfo(skb)->gso_size &&
-           (skb->len > (bp->dev->mtu + ETH_HLEN))) {
-               int hlen = 2 * le16_to_cpu(pbd->total_hlen);
+       if (xmit_type & XMIT_GSO) {
 
                DP(NETIF_MSG_TX_QUEUED,
                   "TSO packet len %d  hlen %d  total len %d  tso size %d\n",
@@ -8786,99 +9470,60 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
                tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_SW_LSO;
 
-               if (tx_bd->nbytes > cpu_to_le16(hlen)) {
-                       /* we split the first bd into headers and data bds
-                        * to ease the pain of our fellow micocode engineers
-                        * we use one mapping for both bds
-                        * So far this has only been observed to happen
-                        * in Other Operating Systems(TM)
-                        */
-
-                       /* first fix first bd */
-                       nbd++;
-                       tx_bd->nbd = cpu_to_le16(nbd);
-                       tx_bd->nbytes = cpu_to_le16(hlen);
-
-                       /* we only print this as an error
-                        * because we don't think this will ever happen.
-                        */
-                       BNX2X_ERR("TSO split header size is %d (%x:%x)"
-                                 "  nbd %d\n", tx_bd->nbytes, tx_bd->addr_hi,
-                                 tx_bd->addr_lo, tx_bd->nbd);
-
-                       /* now get a new data bd
-                        * (after the pbd) and fill it */
-                       bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
-                       tx_bd = &fp->tx_desc_ring[bd_prod];
-
-                       tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
-                       tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping) + hlen);
-                       tx_bd->nbytes = cpu_to_le16(skb_headlen(skb) - hlen);
-                       tx_bd->vlan = cpu_to_le16(pkt_prod);
-                       /* this marks the bd
-                        * as one that has no individual mapping
-                        * the FW ignores this flag in a bd not marked start
-                        */
-                       tx_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_SW_LSO;
-                       DP(NETIF_MSG_TX_QUEUED,
-                          "TSO split data size is %d (%x:%x)\n",
-                          tx_bd->nbytes, tx_bd->addr_hi, tx_bd->addr_lo);
-               }
-
-               if (!pbd) {
-                       /* supposed to be unreached
-                        * (and therefore not handled properly...)
-                        */
-                       BNX2X_ERR("LSO with no PBD\n");
-                       BUG();
-               }
+               if (unlikely(skb_headlen(skb) > hlen))
+                       bd_prod = bnx2x_tx_split(bp, fp, &tx_bd, hlen,
+                                                bd_prod, ++nbd);
 
                pbd->lso_mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
                pbd->tcp_send_seq = swab32(tcp_hdr(skb)->seq);
-               pbd->ip_id = swab16(ip_hdr(skb)->id);
-               pbd->tcp_pseudo_csum =
+               pbd->tcp_flags = pbd_tcp_flags(skb);
+
+               if (xmit_type & XMIT_GSO_V4) {
+                       pbd->ip_id = swab16(ip_hdr(skb)->id);
+                       pbd->tcp_pseudo_csum =
                                swab16(~csum_tcpudp_magic(ip_hdr(skb)->saddr,
                                                          ip_hdr(skb)->daddr,
                                                          0, IPPROTO_TCP, 0));
+
+               } else
+                       pbd->tcp_pseudo_csum =
+                               swab16(~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
+                                                       &ipv6_hdr(skb)->daddr,
+                                                       0, IPPROTO_TCP, 0));
+
                pbd->global_data |= ETH_TX_PARSE_BD_PSEUDO_CS_WITHOUT_LEN;
        }
 
-       {
-               int i;
+       for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
+               skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 
-               for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
-                       skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+               bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
+               tx_bd = &fp->tx_desc_ring[bd_prod];
 
-                       bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
-                       tx_bd = &fp->tx_desc_ring[bd_prod];
+               mapping = pci_map_page(bp->pdev, frag->page, frag->page_offset,
+                                      frag->size, PCI_DMA_TODEVICE);
 
-                       mapping = pci_map_page(bp->pdev, frag->page,
-                                              frag->page_offset,
-                                              frag->size, PCI_DMA_TODEVICE);
+               tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
+               tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
+               tx_bd->nbytes = cpu_to_le16(frag->size);
+               tx_bd->vlan = cpu_to_le16(pkt_prod);
+               tx_bd->bd_flags.as_bitfield = 0;
 
-                       tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
-                       tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
-                       tx_bd->nbytes = cpu_to_le16(frag->size);
-                       tx_bd->vlan = cpu_to_le16(pkt_prod);
-                       tx_bd->bd_flags.as_bitfield = 0;
-                       DP(NETIF_MSG_TX_QUEUED, "frag %d  bd @%p"
-                          "  addr (%x:%x)  nbytes %d  flags %x\n",
-                          i, tx_bd, tx_bd->addr_hi, tx_bd->addr_lo,
-                          tx_bd->nbytes, tx_bd->bd_flags.as_bitfield);
-               } /* for */
+               DP(NETIF_MSG_TX_QUEUED,
+                  "frag %d  bd @%p  addr (%x:%x)  nbytes %d  flags %x\n",
+                  i, tx_bd, tx_bd->addr_hi, tx_bd->addr_lo,
+                  le16_to_cpu(tx_bd->nbytes), tx_bd->bd_flags.as_bitfield);
        }
 
-       /* now at last mark the bd as the last bd */
+       /* now at last mark the BD as the last BD */
        tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_END_BD;
 
        DP(NETIF_MSG_TX_QUEUED, "last bd @%p  flags %x\n",
           tx_bd, tx_bd->bd_flags.as_bitfield);
 
-       tx_buf->skb = skb;
-
        bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
 
-       /* now send a tx doorbell, counting the next bd
+       /* now send a tx doorbell, counting the next BD
         * if the packet contains or ends with it
         */
        if (TX_BD_POFF(bd_prod) < nbd)
@@ -8890,20 +9535,20 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                   "  tcp_flags %x  xsum %x  seq %u  hlen %u\n",
                   pbd, pbd->global_data, pbd->ip_hlen, pbd->ip_id,
                   pbd->lso_mss, pbd->tcp_flags, pbd->tcp_pseudo_csum,
-                  pbd->tcp_send_seq, pbd->total_hlen);
+                  pbd->tcp_send_seq, le16_to_cpu(pbd->total_hlen));
 
-       DP(NETIF_MSG_TX_QUEUED, "doorbell: nbd %u  bd %d\n", nbd, bd_prod);
+       DP(NETIF_MSG_TX_QUEUED, "doorbell: nbd %d  bd %u\n", nbd, bd_prod);
 
        fp->hw_tx_prods->bds_prod =
                cpu_to_le16(le16_to_cpu(fp->hw_tx_prods->bds_prod) + nbd);
        mb(); /* FW restriction: must not reorder writing nbd and packets */
        fp->hw_tx_prods->packets_prod =
                cpu_to_le32(le32_to_cpu(fp->hw_tx_prods->packets_prod) + 1);
-       DOORBELL(bp, fp_index, 0);
+       DOORBELL(bp, FP_IDX(fp), 0);
 
        mmiowb();
 
-       fp->tx_bd_prod = bd_prod;
+       fp->tx_bd_prod += nbd;
        dev->trans_start = jiffies;
 
        if (unlikely(bnx2x_tx_avail(fp) < MAX_SKB_FRAGS + 3)) {
@@ -9331,10 +9976,7 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
        dev->features |= (NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX);
 #endif
        dev->features |= (NETIF_F_TSO | NETIF_F_TSO_ECN);
-
-       bp->timer_interval = HZ;
-       bp->current_interval = (poll ? poll : HZ);
-
+       dev->features |= NETIF_F_TSO6;
 
        return 0;
 
@@ -9539,13 +10181,102 @@ static int bnx2x_resume(struct pci_dev *pdev)
        return rc;
 }
 
+/**
+ * bnx2x_io_error_detected - called when PCI error is detected
+ * @pdev: Pointer to PCI device
+ * @state: The current pci connection state
+ *
+ * This function is called after a PCI bus error affecting
+ * this device has been detected.
+ */
+static pci_ers_result_t bnx2x_io_error_detected(struct pci_dev *pdev,
+                                               pci_channel_state_t state)
+{
+       struct net_device *dev = pci_get_drvdata(pdev);
+       struct bnx2x *bp = netdev_priv(dev);
+
+       rtnl_lock();
+
+       netif_device_detach(dev);
+
+       if (netif_running(dev))
+               bnx2x_nic_unload(bp, UNLOAD_CLOSE);
+
+       pci_disable_device(pdev);
+
+       rtnl_unlock();
+
+       /* Request a slot reset */
+       return PCI_ERS_RESULT_NEED_RESET;
+}
+
+/**
+ * bnx2x_io_slot_reset - called after the PCI bus has been reset
+ * @pdev: Pointer to PCI device
+ *
+ * Restart the card from scratch, as if from a cold-boot.
+ */
+static pci_ers_result_t bnx2x_io_slot_reset(struct pci_dev *pdev)
+{
+       struct net_device *dev = pci_get_drvdata(pdev);
+       struct bnx2x *bp = netdev_priv(dev);
+
+       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;
+       }
+
+       pci_set_master(pdev);
+       pci_restore_state(pdev);
+
+       if (netif_running(dev))
+               bnx2x_set_power_state(bp, PCI_D0);
+
+       rtnl_unlock();
+
+       return PCI_ERS_RESULT_RECOVERED;
+}
+
+/**
+ * bnx2x_io_resume - called when traffic can start flowing again
+ * @pdev: Pointer to PCI device
+ *
+ * This callback is called when the error recovery driver tells us that
+ * its OK to resume normal operation.
+ */
+static void bnx2x_io_resume(struct pci_dev *pdev)
+{
+       struct net_device *dev = pci_get_drvdata(pdev);
+       struct bnx2x *bp = netdev_priv(dev);
+
+       rtnl_lock();
+
+       if (netif_running(dev))
+               bnx2x_nic_load(bp, LOAD_OPEN);
+
+       netif_device_attach(dev);
+
+       rtnl_unlock();
+}
+
+static struct pci_error_handlers bnx2x_err_handler = {
+       .error_detected = bnx2x_io_error_detected,
+       .slot_reset = bnx2x_io_slot_reset,
+       .resume = bnx2x_io_resume,
+};
+
 static struct pci_driver bnx2x_pci_driver = {
-       .name       = DRV_MODULE_NAME,
-       .id_table   = bnx2x_pci_tbl,
-       .probe      = bnx2x_init_one,
-       .remove     = __devexit_p(bnx2x_remove_one),
-       .suspend    = bnx2x_suspend,
-       .resume     = bnx2x_resume,
+       .name        = DRV_MODULE_NAME,
+       .id_table    = bnx2x_pci_tbl,
+       .probe       = bnx2x_init_one,
+       .remove      = __devexit_p(bnx2x_remove_one),
+       .suspend     = bnx2x_suspend,
+       .resume      = bnx2x_resume,
+       .err_handler = &bnx2x_err_handler,
 };
 
 static int __init bnx2x_init(void)