1 files changed, 138 insertions, 147 deletions

diff --git a/drivers/net/cnic.c b/drivers/net/cnic.c
index 4e9d4ae1f303..80259815af06 100644
--- a/drivers/net/cnic.c
+++ b/drivers/net/cnic.c
@@ -942,7 +942,7 @@ static int cnic_alloc_uio(struct cnic_dev *dev) {
         } else if (test_bit(CNIC_F_BNX2X_CLASS, &dev->flags)) {
                 uinfo->mem[1].addr = (unsigned long) cp->bnx2x_def_status_blk &
                         PAGE_MASK;
-                uinfo->mem[1].size = sizeof(struct host_def_status_block);
+                uinfo->mem[1].size = sizeof(*cp->bnx2x_def_status_blk);
 
                 uinfo->name = "bnx2x_cnic";
         }
@@ -1063,6 +1063,8 @@ static int cnic_alloc_bnx2x_resc(struct cnic_dev *dev)
         int i, j, n, ret, pages;
         struct cnic_dma *kwq_16_dma = &cp->kwq_16_data_info;
 
+        cp->iro_arr = ethdev->iro_arr;
+
         cp->max_cid_space = MAX_ISCSI_TBL_SZ;
         cp->iscsi_start_cid = start_cid;
         if (start_cid < BNX2X_ISCSI_START_CID) {
@@ -1127,8 +1129,6 @@ static int cnic_alloc_bnx2x_resc(struct cnic_dev *dev)
 
         cp->bnx2x_def_status_blk = cp->ethdev->irq_arr[1].status_blk;
 
-        memset(cp->status_blk.bnx2x, 0, sizeof(*cp->status_blk.bnx2x));
-
         cp->l2_rx_ring_size = 15;
 
         ret = cnic_alloc_l2_rings(dev, 4);
@@ -1211,7 +1211,7 @@ static int cnic_submit_kwqe_16(struct cnic_dev *dev, u32 cmd, u32 cid,
                 cpu_to_le32(((cmd << SPE_HDR_CMD_ID_SHIFT) |
                              BNX2X_HW_CID(cp, cid)));
         kwqe.hdr.type = cpu_to_le16(type);
-        kwqe.hdr.reserved = 0;
+        kwqe.hdr.reserved1 = 0;
         kwqe.data.phy_address.lo = cpu_to_le32(l5_data->phy_address.lo);
         kwqe.data.phy_address.hi = cpu_to_le32(l5_data->phy_address.hi);
 
@@ -1527,8 +1527,10 @@ static int cnic_setup_bnx2x_ctx(struct cnic_dev *dev, struct kwqe *wqes[],
         ictx->tstorm_st_context.tcp.cwnd = 0x5A8;
         ictx->tstorm_st_context.tcp.flags2 |=
                 TSTORM_TCP_ST_CONTEXT_SECTION_DA_EN;
+        ictx->tstorm_st_context.tcp.ooo_support_mode =
+                TCP_TSTORM_OOO_DROP_AND_PROC_ACK;
 
-        ictx->timers_context.flags |= ISCSI_TIMERS_BLOCK_CONTEXT_CONN_VALID_FLG;
+        ictx->timers_context.flags |= TIMERS_BLOCK_CONTEXT_CONN_VALID_FLG;
 
         ictx->ustorm_st_context.ring.rq.pbl_base.lo =
                 req2->rq_page_table_addr_lo;
@@ -1717,6 +1719,7 @@ static int cnic_bnx2x_iscsi_destroy(struct cnic_dev *dev, struct kwqe *kwqe)
         int ret = 0;
         struct iscsi_kcqe kcqe;
         struct kcqe *cqes[1];
+        u32 hw_cid, type;
 
         if (!(ctx->ctx_flags & CTX_FL_OFFLD_START))
                 goto skip_cfc_delete;
@@ -1727,11 +1730,15 @@ static int cnic_bnx2x_iscsi_destroy(struct cnic_dev *dev, struct kwqe *kwqe)
         init_waitqueue_head(&ctx->waitq);
         ctx->wait_cond = 0;
         memset(&l5_data, 0, sizeof(l5_data));
-        ret = cnic_submit_kwqe_16(dev, RAMROD_CMD_ID_ETH_CFC_DEL,
-                                  req->context_id,
-                                  ETH_CONNECTION_TYPE |
-                                  (1 << SPE_HDR_COMMON_RAMROD_SHIFT),
-                                  &l5_data);
+        hw_cid = BNX2X_HW_CID(cp, ctx->cid);
+        type = (NONE_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
+                & SPE_HDR_CONN_TYPE;
+        type |= ((cp->pfid << SPE_HDR_FUNCTION_ID_SHIFT) &
+                 SPE_HDR_FUNCTION_ID);
+
+        ret = cnic_submit_kwqe_16(dev, RAMROD_CMD_ID_COMMON_CFC_DEL,
+                                  hw_cid, type, &l5_data);
+
         if (ret == 0)
                 wait_event(ctx->waitq, ctx->wait_cond);
 
@@ -2322,7 +2329,7 @@ static void cnic_ack_bnx2x_msix(struct cnic_dev *dev)
 {
         struct cnic_local *cp = dev->cnic_priv;
 
-        cnic_ack_bnx2x_int(dev, cp->status_blk_num, CSTORM_ID, 0,
+        cnic_ack_bnx2x_int(dev, cp->bnx2x_igu_sb_id, CSTORM_ID, 0,
                            IGU_INT_DISABLE, 0);
 }
 
@@ -2357,7 +2364,7 @@ static void cnic_service_bnx2x_bh(unsigned long data)
         status_idx = cnic_service_bnx2x_kcq(dev, &cp->kcq1);
 
         CNIC_WR16(dev, cp->kcq1.io_addr, cp->kcq1.sw_prod_idx + MAX_KCQ_IDX);
-        cnic_ack_bnx2x_int(dev, cp->status_blk_num, CSTORM_ID,
+        cnic_ack_bnx2x_int(dev, cp->bnx2x_igu_sb_id, USTORM_ID,
                            status_idx, IGU_INT_ENABLE, 1);
 }
 
@@ -3285,6 +3292,7 @@ static int cnic_cm_init_bnx2x_hw(struct cnic_dev *dev)
 {
         struct cnic_local *cp = dev->cnic_priv;
         u32 pfid = cp->pfid;
+        u32 port = CNIC_PORT(cp);
 
         cnic_init_bnx2x_mac(dev);
         cnic_bnx2x_set_tcp_timestamp(dev, 1);
@@ -3293,9 +3301,9 @@ static int cnic_cm_init_bnx2x_hw(struct cnic_dev *dev)
                   XSTORM_ISCSI_LOCAL_VLAN_OFFSET(pfid), 0);
 
         CNIC_WR(dev, BAR_XSTRORM_INTMEM +
-                XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_ENABLED_OFFSET(pfid), 1);
+                XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_ENABLED_OFFSET(port), 1);
         CNIC_WR(dev, BAR_XSTRORM_INTMEM +
-                XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_MAX_COUNT_OFFSET(pfid),
+                XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_MAX_COUNT_OFFSET(port),
                 DEF_MAX_DA_COUNT);
 
         CNIC_WR8(dev, BAR_XSTRORM_INTMEM +
@@ -3859,32 +3867,48 @@ static int cnic_init_bnx2x_irq(struct cnic_dev *dev)
         return err;
 }
 
+static inline void cnic_storm_memset_hc_disable(struct cnic_dev *dev,
+                                                u16 sb_id, u8 sb_index,
+                                                u8 disable)
+{
+
+        u32 addr = BAR_CSTRORM_INTMEM +
+                        CSTORM_STATUS_BLOCK_DATA_OFFSET(sb_id) +
+                        offsetof(struct hc_status_block_data_e1x, index_data) +
+                        sizeof(struct hc_index_data)*sb_index +
+                        offsetof(struct hc_index_data, flags);
+        u16 flags = CNIC_RD16(dev, addr);
+        /* clear and set */
+        flags &= ~HC_INDEX_DATA_HC_ENABLED;
+        flags |= (((~disable) << HC_INDEX_DATA_HC_ENABLED_SHIFT) &
+                  HC_INDEX_DATA_HC_ENABLED);
+        CNIC_WR16(dev, addr, flags);
+}
+
 static void cnic_enable_bnx2x_int(struct cnic_dev *dev)
 {
         struct cnic_local *cp = dev->cnic_priv;
         u8 sb_id = cp->status_blk_num;
-        int port = CNIC_PORT(cp);
 
         CNIC_WR8(dev, BAR_CSTRORM_INTMEM +
-                 CSTORM_SB_HC_TIMEOUT_C_OFFSET(port, sb_id,
-                                               HC_INDEX_C_ISCSI_EQ_CONS),
-                 64 / 12);
-        CNIC_WR16(dev, BAR_CSTRORM_INTMEM +
-                  CSTORM_SB_HC_DISABLE_C_OFFSET(port, sb_id,
-                                                HC_INDEX_C_ISCSI_EQ_CONS), 0);
+                        CSTORM_STATUS_BLOCK_DATA_OFFSET(sb_id) +
+                        offsetof(struct hc_status_block_data_e1x, index_data) +
+                        sizeof(struct hc_index_data)*HC_INDEX_ISCSI_EQ_CONS +
+                        offsetof(struct hc_index_data, timeout), 64 / 12);
+        cnic_storm_memset_hc_disable(dev, sb_id, HC_INDEX_ISCSI_EQ_CONS, 0);
 }
 
 static void cnic_disable_bnx2x_int_sync(struct cnic_dev *dev)
 {
 }
 
-static void cnic_init_bnx2x_tx_ring(struct cnic_dev *dev)
+static void cnic_init_bnx2x_tx_ring(struct cnic_dev *dev,
+                                    struct client_init_ramrod_data *data)
 {
         struct cnic_local *cp = dev->cnic_priv;
         union eth_tx_bd_types *txbd = (union eth_tx_bd_types *) cp->l2_ring;
-        struct eth_context *context;
-        struct regpair context_addr;
-        dma_addr_t buf_map;
+        dma_addr_t buf_map, ring_map = cp->l2_ring_map;
+        struct host_sp_status_block *sb = cp->bnx2x_def_status_blk;
         int port = CNIC_PORT(cp);
         int i;
         int cli = BNX2X_ISCSI_CL_ID(CNIC_E1HVN(cp));
@@ -3909,33 +3933,23 @@ static void cnic_init_bnx2x_tx_ring(struct cnic_dev *dev)
                 start_bd->general_data |= (1 << ETH_TX_START_BD_HDR_NBDS_SHIFT);
 
         }
-        context = cnic_get_bnx2x_ctx(dev, BNX2X_ISCSI_L2_CID, 1, &context_addr);
 
-        val = (u64) cp->l2_ring_map >> 32;
+        val = (u64) ring_map >> 32;
         txbd->next_bd.addr_hi = cpu_to_le32(val);
 
-        context->xstorm_st_context.tx_bd_page_base_hi = val;
+        data->tx.tx_bd_page_base.hi = cpu_to_le32(val);
 
-        val = (u64) cp->l2_ring_map & 0xffffffff;
+        val = (u64) ring_map & 0xffffffff;
         txbd->next_bd.addr_lo = cpu_to_le32(val);
 
-        context->xstorm_st_context.tx_bd_page_base_lo = val;
-
-        context->cstorm_st_context.sb_index_number =
-                HC_INDEX_DEF_C_ETH_ISCSI_CQ_CONS;
-        context->cstorm_st_context.status_block_id = BNX2X_DEF_SB_ID;
-
-        if (cli < MAX_X_STAT_COUNTER_ID)
-                context->xstorm_st_context.statistics_data = cli |
-                                XSTORM_ETH_ST_CONTEXT_STATISTICS_ENABLE;
+        data->tx.tx_bd_page_base.lo = cpu_to_le32(val);
 
-        context->xstorm_ag_context.cdu_reserved =
-                CDU_RSRVD_VALUE_TYPE_A(BNX2X_HW_CID(cp, BNX2X_ISCSI_L2_CID),
-                                        CDU_REGION_NUMBER_XCM_AG,
-                                        ETH_CONNECTION_TYPE);
+        /* Other ramrod params */
+        data->tx.tx_sb_index_number = HC_SP_INDEX_ETH_ISCSI_CQ_CONS;
+        data->tx.tx_status_block_id = BNX2X_DEF_SB_ID;
 
         /* reset xstorm per client statistics */
-        if (cli < MAX_X_STAT_COUNTER_ID) {
+        if (cli < MAX_STAT_COUNTER_ID) {
                 val = BAR_XSTRORM_INTMEM +
                       XSTORM_PER_COUNTER_ID_STATS_OFFSET(port, cli);
                 for (i = 0; i < sizeof(struct xstorm_per_client_stats) / 4; i++)
@@ -3943,24 +3957,31 @@ static void cnic_init_bnx2x_tx_ring(struct cnic_dev *dev)
         }
 
         cp->tx_cons_ptr =
-                &cp->bnx2x_def_status_blk->c_def_status_block.index_values[
-                        HC_INDEX_DEF_C_ETH_ISCSI_CQ_CONS];
+                &sb->sp_sb.index_values[HC_SP_INDEX_ETH_ISCSI_CQ_CONS];
 }
 
-static void cnic_init_bnx2x_rx_ring(struct cnic_dev *dev)
+static void cnic_init_bnx2x_rx_ring(struct cnic_dev *dev,
+                                    struct client_init_ramrod_data *data)
 {
         struct cnic_local *cp = dev->cnic_priv;
         struct eth_rx_bd *rxbd = (struct eth_rx_bd *) (cp->l2_ring +
                                 BCM_PAGE_SIZE);
         struct eth_rx_cqe_next_page *rxcqe = (struct eth_rx_cqe_next_page *)
                                 (cp->l2_ring + (2 * BCM_PAGE_SIZE));
-        struct eth_context *context;
-        struct regpair context_addr;
+        struct host_sp_status_block *sb = cp->bnx2x_def_status_blk;
         int i;
         int port = CNIC_PORT(cp);
         int cli = BNX2X_ISCSI_CL_ID(CNIC_E1HVN(cp));
+        int cl_qzone_id = BNX2X_CL_QZONE_ID(cp, cli);
         u32 val;
-        struct tstorm_eth_client_config tstorm_client = {0};
+        dma_addr_t ring_map = cp->l2_ring_map;
+
+        /* General data */
+        data->general.client_id = cli;
+        data->general.statistics_en_flg = 1;
+        data->general.statistics_counter_id = cli;
+        data->general.activate_flg = 1;
+        data->general.sp_client_id = cli;
 
         for (i = 0; i < BNX2X_MAX_RX_DESC_CNT; i++, rxbd++) {
                 dma_addr_t buf_map;
@@ -3970,83 +3991,42 @@ static void cnic_init_bnx2x_rx_ring(struct cnic_dev *dev)
                 rxbd->addr_hi = cpu_to_le32((u64) buf_map >> 32);
                 rxbd->addr_lo = cpu_to_le32(buf_map & 0xffffffff);
         }
-        context = cnic_get_bnx2x_ctx(dev, BNX2X_ISCSI_L2_CID, 0, &context_addr);
 
-        val = (u64) (cp->l2_ring_map + BCM_PAGE_SIZE) >> 32;
+        val = (u64) (ring_map + BCM_PAGE_SIZE) >> 32;
         rxbd->addr_hi = cpu_to_le32(val);
+        data->rx.bd_page_base.hi = cpu_to_le32(val);
 
-        context->ustorm_st_context.common.bd_page_base_hi = val;
-
-        val = (u64) (cp->l2_ring_map + BCM_PAGE_SIZE) & 0xffffffff;
+        val = (u64) (ring_map + BCM_PAGE_SIZE) & 0xffffffff;
         rxbd->addr_lo = cpu_to_le32(val);
-
-        context->ustorm_st_context.common.bd_page_base_lo = val;
-
-        context->ustorm_st_context.common.sb_index_numbers =
-                                                BNX2X_ISCSI_RX_SB_INDEX_NUM;
-        context->ustorm_st_context.common.clientId = cli;
-        context->ustorm_st_context.common.status_block_id = BNX2X_DEF_SB_ID;
-        if (cli < MAX_U_STAT_COUNTER_ID) {
-                context->ustorm_st_context.common.flags =
-                        USTORM_ETH_ST_CONTEXT_CONFIG_ENABLE_STATISTICS;
-                context->ustorm_st_context.common.statistics_counter_id = cli;
-        }
-        context->ustorm_st_context.common.mc_alignment_log_size = 0;
-        context->ustorm_st_context.common.bd_buff_size =
-                                                cp->l2_single_buf_size;
-
-        context->ustorm_ag_context.cdu_usage =
-                CDU_RSRVD_VALUE_TYPE_A(BNX2X_HW_CID(cp, BNX2X_ISCSI_L2_CID),
-                                        CDU_REGION_NUMBER_UCM_AG,
-                                        ETH_CONNECTION_TYPE);
+        data->rx.bd_page_base.lo = cpu_to_le32(val);
 
         rxcqe += BNX2X_MAX_RCQ_DESC_CNT;
-        val = (u64) (cp->l2_ring_map + (2 * BCM_PAGE_SIZE)) >> 32;
+        val = (u64) (ring_map + (2 * BCM_PAGE_SIZE)) >> 32;
         rxcqe->addr_hi = cpu_to_le32(val);
+        data->rx.cqe_page_base.hi = cpu_to_le32(val);
 
-        CNIC_WR(dev, BAR_USTRORM_INTMEM +
-                USTORM_CQE_PAGE_BASE_OFFSET(port, cli) + 4, val);
-
-        CNIC_WR(dev, BAR_USTRORM_INTMEM +
-                USTORM_CQE_PAGE_NEXT_OFFSET(port, cli) + 4, val);
-
-        val = (u64) (cp->l2_ring_map + (2 * BCM_PAGE_SIZE)) & 0xffffffff;
+        val = (u64) (ring_map + (2 * BCM_PAGE_SIZE)) & 0xffffffff;
         rxcqe->addr_lo = cpu_to_le32(val);
+        data->rx.cqe_page_base.lo = cpu_to_le32(val);
 
-        CNIC_WR(dev, BAR_USTRORM_INTMEM +
-                USTORM_CQE_PAGE_BASE_OFFSET(port, cli), val);
-
-        CNIC_WR(dev, BAR_USTRORM_INTMEM +
-                USTORM_CQE_PAGE_NEXT_OFFSET(port, cli), val);
-
-        /* client tstorm info */
-        tstorm_client.mtu = cp->l2_single_buf_size - 14;
-        tstorm_client.config_flags = TSTORM_ETH_CLIENT_CONFIG_E1HOV_REM_ENABLE;
-
-        if (cli < MAX_T_STAT_COUNTER_ID) {
-                tstorm_client.config_flags |=
-                                TSTORM_ETH_CLIENT_CONFIG_STATSITICS_ENABLE;
-                tstorm_client.statistics_counter_id = cli;
-        }
+        /* Other ramrod params */
+        data->rx.client_qzone_id = cl_qzone_id;
+        data->rx.rx_sb_index_number = HC_SP_INDEX_ETH_ISCSI_RX_CQ_CONS;
+        data->rx.status_block_id = BNX2X_DEF_SB_ID;
 
-        CNIC_WR(dev, BAR_TSTRORM_INTMEM +
-                   TSTORM_CLIENT_CONFIG_OFFSET(port, cli),
-                   ((u32 *)&tstorm_client)[0]);
-        CNIC_WR(dev, BAR_TSTRORM_INTMEM +
-                   TSTORM_CLIENT_CONFIG_OFFSET(port, cli) + 4,
-                   ((u32 *)&tstorm_client)[1]);
+        data->rx.cache_line_alignment_log_size = L1_CACHE_SHIFT;
+        data->rx.bd_buff_size = cpu_to_le16(cp->l2_single_buf_size);
 
-        /* reset tstorm per client statistics */
-        if (cli < MAX_T_STAT_COUNTER_ID) {
+        data->rx.mtu = cpu_to_le16(cp->l2_single_buf_size - 14);
+        data->rx.outer_vlan_removal_enable_flg = 1;
 
+        /* reset tstorm and ustorm per client statistics */
+        if (cli < MAX_STAT_COUNTER_ID) {
                 val = BAR_TSTRORM_INTMEM +
                       TSTORM_PER_COUNTER_ID_STATS_OFFSET(port, cli);
                 for (i = 0; i < sizeof(struct tstorm_per_client_stats) / 4; i++)
                         CNIC_WR(dev, val + i * 4, 0);
-        }
 
-        /* reset ustorm per client statistics */
-        if (cli < MAX_U_STAT_COUNTER_ID) {
                 val = BAR_USTRORM_INTMEM +
                       USTORM_PER_COUNTER_ID_STATS_OFFSET(port, cli);
                 for (i = 0; i < sizeof(struct ustorm_per_client_stats) / 4; i++)
@@ -4054,8 +4034,7 @@ static void cnic_init_bnx2x_rx_ring(struct cnic_dev *dev)
         }
 
         cp->rx_cons_ptr =
-                &cp->bnx2x_def_status_blk->u_def_status_block.index_values[
-                        HC_INDEX_DEF_U_ETH_ISCSI_RX_CQ_CONS];
+                &sb->sp_sb.index_values[HC_SP_INDEX_ETH_ISCSI_RX_CQ_CONS];
 }
 
 static void cnic_get_bnx2x_iscsi_info(struct cnic_dev *dev)
@@ -4066,7 +4045,7 @@ static void cnic_get_bnx2x_iscsi_info(struct cnic_dev *dev)
 
         dev->max_iscsi_conn = 0;
         base = CNIC_RD(dev, MISC_REG_SHARED_MEM_ADDR);
-        if (base < 0xa0000 || base >= 0xc0000)
+        if (base == 0)
                 return;
 
         addr = BNX2X_SHMEM_ADDR(base,
@@ -4103,14 +4082,19 @@ static void cnic_get_bnx2x_iscsi_info(struct cnic_dev *dev)
         }
         if (BNX2X_CHIP_IS_E1H(cp->chip_id)) {
                 int func = CNIC_FUNC(cp);
+                u32 mf_cfg_addr;
+
+                mf_cfg_addr = base + BNX2X_SHMEM_MF_BLK_OFFSET;
+
+                addr = mf_cfg_addr +
+                        offsetof(struct mf_cfg, func_mf_config[func].e1hov_tag);
 
-                addr = BNX2X_SHMEM_ADDR(base,
-                                mf_cfg.func_mf_config[func].e1hov_tag);
                 val = CNIC_RD(dev, addr);
                 val &= FUNC_MF_CFG_E1HOV_TAG_MASK;
                 if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
-                        addr = BNX2X_SHMEM_ADDR(base,
-                                mf_cfg.func_mf_config[func].config);
+                        addr = mf_cfg_addr +
+                                offsetof(struct mf_cfg,
+                                         func_mf_config[func].config);
                         val = CNIC_RD(dev, addr);
                         val &= FUNC_MF_CFG_PROTOCOL_MASK;
                         if (val != FUNC_MF_CFG_PROTOCOL_ISCSI)
@@ -4122,11 +4106,10 @@ static void cnic_get_bnx2x_iscsi_info(struct cnic_dev *dev)
 static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
 {
         struct cnic_local *cp = dev->cnic_priv;
+        struct cnic_eth_dev *ethdev = cp->ethdev;
         int func = CNIC_FUNC(cp), ret, i;
-        int port = CNIC_PORT(cp);
         u32 pfid;
-        u16 eq_idx;
-        u8 sb_id = cp->status_blk_num;
+        struct host_hc_status_block_e1x *sb = cp->status_blk.gen;
 
         cp->pfid = func;
         pfid = cp->pfid;
@@ -4137,15 +4120,16 @@ static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
         if (ret)
                 return -ENOMEM;
 
+        cp->bnx2x_igu_sb_id = ethdev->irq_arr[0].status_blk_num2;
+
         cp->kcq1.io_addr = BAR_CSTRORM_INTMEM +
                           CSTORM_ISCSI_EQ_PROD_OFFSET(pfid, 0);
         cp->kcq1.sw_prod_idx = 0;
 
         cp->kcq1.hw_prod_idx_ptr =
-                &cp->status_blk.bnx2x->c_status_block.index_values[
-                        HC_INDEX_C_ISCSI_EQ_CONS];
+                &sb->sb.index_values[HC_INDEX_ISCSI_EQ_CONS];
         cp->kcq1.status_idx_ptr =
-                &cp->status_blk.bnx2x->c_status_block.status_block_index;
+                &sb->sb.running_index[SM_RX_ID];
 
         cnic_get_bnx2x_iscsi_info(dev);
 
@@ -4171,7 +4155,7 @@ static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
                 CSTORM_ISCSI_EQ_SB_NUM_OFFSET(pfid, 0), cp->status_blk_num);
         CNIC_WR8(dev, BAR_CSTRORM_INTMEM +
                 CSTORM_ISCSI_EQ_SB_INDEX_OFFSET(pfid, 0),
-                HC_INDEX_C_ISCSI_EQ_CONS);
+                HC_INDEX_ISCSI_EQ_CONS);
 
         for (i = 0; i < cp->conn_buf_info.num_pages; i++) {
                 CNIC_WR(dev, BAR_TSTRORM_INTMEM +
@@ -4189,16 +4173,11 @@ static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
                 USTORM_ISCSI_GLOBAL_BUF_PHYS_ADDR_OFFSET(pfid) + 4,
                 (u64) cp->gbl_buf_info.pg_map_arr[0] >> 32);
 
+        CNIC_WR(dev, BAR_TSTRORM_INTMEM +
+                TSTORM_ISCSI_TCP_LOCAL_ADV_WND_OFFSET(pfid), DEF_RCV_BUF);
+
         cnic_setup_bnx2x_context(dev);
 
-        eq_idx = CNIC_RD16(dev, BAR_CSTRORM_INTMEM +
-                           CSTORM_SB_HOST_STATUS_BLOCK_C_OFFSET(port, sb_id) +
-                           offsetof(struct cstorm_status_block_c,
-                                    index_values[HC_INDEX_C_ISCSI_EQ_CONS]));
-        if (eq_idx != 0) {
-                netdev_err(dev->netdev, "EQ cons index %x != 0\n", eq_idx);
-                return -EBUSY;
-        }
         ret = cnic_init_bnx2x_irq(dev);
         if (ret)
                 return ret;
@@ -4218,8 +4197,9 @@ static void cnic_init_rings(struct cnic_dev *dev)
                 cnic_init_bnx2_rx_ring(dev);
                 set_bit(CNIC_LCL_FL_RINGS_INITED, &cp->cnic_local_flags);
         } else if (test_bit(CNIC_F_BNX2X_CLASS, &dev->flags)) {
-                struct cnic_local *cp = dev->cnic_priv;
                 u32 cli = BNX2X_ISCSI_CL_ID(CNIC_E1HVN(cp));
+                u32 cl_qzone_id, type;
+                struct client_init_ramrod_data *data;
                 union l5cm_specific_data l5_data;
                 struct ustorm_eth_rx_producers rx_prods = {0};
                 u32 off, i;
@@ -4228,23 +4208,36 @@ static void cnic_init_rings(struct cnic_dev *dev)
                 rx_prods.cqe_prod = BNX2X_MAX_RCQ_DESC_CNT;
                 barrier();
 
+                cl_qzone_id = BNX2X_CL_QZONE_ID(cp, cli);
+
                 off = BAR_USTRORM_INTMEM +
-                        USTORM_RX_PRODS_OFFSET(CNIC_PORT(cp), cli);
+                         USTORM_RX_PRODS_E1X_OFFSET(CNIC_PORT(cp), cli);
 
                 for (i = 0; i < sizeof(struct ustorm_eth_rx_producers) / 4; i++)
                         CNIC_WR(dev, off + i * 4, ((u32 *) &rx_prods)[i]);
 
                 set_bit(CNIC_LCL_FL_L2_WAIT, &cp->cnic_local_flags);
 
-                cnic_init_bnx2x_tx_ring(dev);
-                cnic_init_bnx2x_rx_ring(dev);
+                data = cp->l2_buf;
+
+                memset(data, 0, sizeof(*data));
+
+                cnic_init_bnx2x_tx_ring(dev, data);
+                cnic_init_bnx2x_rx_ring(dev, data);
+
+                l5_data.phy_address.lo = cp->l2_buf_map & 0xffffffff;
+                l5_data.phy_address.hi = (u64) cp->l2_buf_map >> 32;
+
+                type = (ETH_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
+                        & SPE_HDR_CONN_TYPE;
+                type |= ((cp->pfid << SPE_HDR_FUNCTION_ID_SHIFT) &
+                        SPE_HDR_FUNCTION_ID);
 
                 set_bit(CNIC_LCL_FL_RINGS_INITED, &cp->cnic_local_flags);
 
-                l5_data.phy_address.lo = cli;
-                l5_data.phy_address.hi = 0;
                 cnic_submit_kwqe_16(dev, RAMROD_CMD_ID_ETH_CLIENT_SETUP,
-                        BNX2X_ISCSI_L2_CID, ETH_CONNECTION_TYPE, &l5_data);
+                        BNX2X_ISCSI_L2_CID, type, &l5_data);
+
                 i = 0;
                 while (test_bit(CNIC_LCL_FL_L2_WAIT, &cp->cnic_local_flags) &&
                        ++i < 10)
@@ -4272,6 +4265,7 @@ static void cnic_shutdown_rings(struct cnic_dev *dev)
                 u32 cli = BNX2X_ISCSI_CL_ID(CNIC_E1HVN(cp));
                 union l5cm_specific_data l5_data;
                 int i;
+                u32 type;
 
                 cnic_ring_ctl(dev, BNX2X_ISCSI_L2_CID, cli, 0);
 
@@ -4292,9 +4286,12 @@ static void cnic_shutdown_rings(struct cnic_dev *dev)
                 cnic_kwq_completion(dev, 1);
 
                 memset(&l5_data, 0, sizeof(l5_data));
-                cnic_submit_kwqe_16(dev, RAMROD_CMD_ID_ETH_CFC_DEL,
-                        BNX2X_ISCSI_L2_CID, ETH_CONNECTION_TYPE |
-                        (1 << SPE_HDR_COMMON_RAMROD_SHIFT), &l5_data);
+                type = (NONE_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
+                        & SPE_HDR_CONN_TYPE;
+                type |= ((cp->pfid << SPE_HDR_FUNCTION_ID_SHIFT) &
+                         SPE_HDR_FUNCTION_ID);
+                cnic_submit_kwqe_16(dev, RAMROD_CMD_ID_COMMON_CFC_DEL,
+                        BNX2X_ISCSI_L2_CID, type, &l5_data);
                 msleep(10);
         }
         clear_bit(CNIC_LCL_FL_RINGS_INITED, &cp->cnic_local_flags);
@@ -4392,15 +4389,9 @@ static void cnic_stop_bnx2_hw(struct cnic_dev *dev)
 static void cnic_stop_bnx2x_hw(struct cnic_dev *dev)
 {
         struct cnic_local *cp = dev->cnic_priv;
-        u8 sb_id = cp->status_blk_num;
-        int port = CNIC_PORT(cp);
 
         cnic_free_irq(dev);
-        CNIC_WR16(dev, BAR_CSTRORM_INTMEM +
-                  CSTORM_SB_HOST_STATUS_BLOCK_C_OFFSET(port, sb_id) +
-                  offsetof(struct cstorm_status_block_c,
-                           index_values[HC_INDEX_C_ISCSI_EQ_CONS]),
-                  0);
+        *cp->kcq1.hw_prod_idx_ptr = 0;
         CNIC_WR(dev, BAR_CSTRORM_INTMEM +
                 CSTORM_ISCSI_EQ_CONS_OFFSET(cp->pfid, 0), 0);
         CNIC_WR16(dev, cp->kcq1.io_addr, 0);