New 7.0 FW: bnx2x, cnic, bnx2i, bnx2fc

New FW/HSI (7.0):
 - Added support to 578xx chips
 - Improved HSI - much less driver's direct access to the FW internal
   memory needed.

New implementation of the HSI handling layer in the bnx2x (bnx2x_sp.c):
 - Introduced chip dependent objects that have chip independent interfaces
   for configuration of MACs, multicast addresses, Rx mode, indirection table,
   fast path queues and function initialization/cleanup.
 - Objects functionality is based on the private function pointers, which
   allows not only a per-chip but also PF/VF differentiation while still
   preserving the same interface towards the driver.
 - Objects interface is not influenced by the HSI changes which do not require
   providing new parameters keeping the code outside the bnx2x_sp.c invariant
   with regard to such HSI chnages.

Changes in a CNIC, bnx2fc and bnx2i modules due to the new HSI.

Signed-off-by: Vladislav Zolotarov <vladz@broadcom.com>
Signed-off-by: Michael Chan <mchan@broadcom.com>
Signed-off-by: Bhanu Prakash Gollapudi <bprakash@broadcom.com>
Signed-off-by: Eilon Greenstein <eilong@broadcom.com>
Signed-off-by: David S. Miller <davem@conan.davemloft.net>

32 files changed, 20047 insertions, 9481 deletions

diff --git a/drivers/net/bnx2x/bnx2x.h b/drivers/net/bnx2x/bnx2x.h
index 6d4d6d4e53c6..b4b3abe9e7c4 100644
--- a/drivers/net/bnx2x/bnx2x.h
+++ b/drivers/net/bnx2x/bnx2x.h
@@ -47,11 +47,12 @@
 #endif
 
 #include <linux/mdio.h>
-#include <linux/pci.h>
+
 #include "bnx2x_reg.h"
 #include "bnx2x_fw_defs.h"
 #include "bnx2x_hsi.h"
 #include "bnx2x_link.h"
+#include "bnx2x_sp.h"
 #include "bnx2x_dcb.h"
 #include "bnx2x_stats.h"
 
@@ -80,6 +81,12 @@ do {								\
                        ##__args);                               \
 } while (0)
 
+#define DP_CONT(__mask, __fmt, __args...)                       \
+do {                                                            \
+        if (bp->msg_enable & (__mask))                          \
+                pr_cont(__fmt, ##__args);                       \
+} while (0)
+
 /* errors debug print */
 #define BNX2X_DBG_ERR(__fmt, __args...)                         \
 do {                                                            \
@@ -111,7 +118,9 @@ do {								 \
                 dev_info(&bp->pdev->dev, __fmt, ##__args);       \
 } while (0)
 
-void bnx2x_panic_dump(struct bnx2x *bp);
+#define BNX2X_MAC_FMT           "%pM"
+#define BNX2X_MAC_PRN_LIST(mac) (mac)
+
 
 #ifdef BNX2X_STOP_ON_ERROR
 #define bnx2x_panic() do { \
@@ -233,11 +242,11 @@ void bnx2x_panic_dump(struct bnx2x *bp);
  *
  */
 /* iSCSI L2 */
-#define BNX2X_ISCSI_ETH_CL_ID           17
+#define BNX2X_ISCSI_ETH_CL_ID_IDX       1
 #define BNX2X_ISCSI_ETH_CID             17
 
 /* FCoE L2 */
-#define BNX2X_FCOE_ETH_CL_ID            18
+#define BNX2X_FCOE_ETH_CL_ID_IDX        2
 #define BNX2X_FCOE_ETH_CID              18
 
 /** Additional rings budgeting */
@@ -283,44 +292,73 @@ union db_prod {
 
 
 /* MC hsi */
-#define BCM_PAGE_SHIFT                  12
-#define BCM_PAGE_SIZE                   (1 << BCM_PAGE_SHIFT)
-#define BCM_PAGE_MASK                   (~(BCM_PAGE_SIZE - 1))
+#define BCM_PAGE_SHIFT          12
+#define BCM_PAGE_SIZE           (1 << BCM_PAGE_SHIFT)
+#define BCM_PAGE_MASK           (~(BCM_PAGE_SIZE - 1))
 #define BCM_PAGE_ALIGN(addr)    (((addr) + BCM_PAGE_SIZE - 1) & BCM_PAGE_MASK)
 
-#define PAGES_PER_SGE_SHIFT             0
-#define PAGES_PER_SGE                   (1 << PAGES_PER_SGE_SHIFT)
-#define SGE_PAGE_SIZE                   PAGE_SIZE
-#define SGE_PAGE_SHIFT                  PAGE_SHIFT
-#define SGE_PAGE_ALIGN(addr)            PAGE_ALIGN((typeof(PAGE_SIZE))(addr))
+#define PAGES_PER_SGE_SHIFT     0
+#define PAGES_PER_SGE           (1 << PAGES_PER_SGE_SHIFT)
+#define SGE_PAGE_SIZE           PAGE_SIZE
+#define SGE_PAGE_SHIFT          PAGE_SHIFT
+#define SGE_PAGE_ALIGN(addr)    PAGE_ALIGN((typeof(PAGE_SIZE))(addr))
 
 /* SGE ring related macros */
-#define NUM_RX_SGE_PAGES                2
+#define NUM_RX_SGE_PAGES        2
 #define RX_SGE_CNT              (BCM_PAGE_SIZE / sizeof(struct eth_rx_sge))
-#define MAX_RX_SGE_CNT                  (RX_SGE_CNT - 2)
+#define MAX_RX_SGE_CNT          (RX_SGE_CNT - 2)
 /* RX_SGE_CNT is promised to be a power of 2 */
-#define RX_SGE_MASK                     (RX_SGE_CNT - 1)
-#define NUM_RX_SGE                      (RX_SGE_CNT * NUM_RX_SGE_PAGES)
-#define MAX_RX_SGE                      (NUM_RX_SGE - 1)
+#define RX_SGE_MASK             (RX_SGE_CNT - 1)
+#define NUM_RX_SGE              (RX_SGE_CNT * NUM_RX_SGE_PAGES)
+#define MAX_RX_SGE              (NUM_RX_SGE - 1)
 #define NEXT_SGE_IDX(x)         ((((x) & RX_SGE_MASK) == \
                                   (MAX_RX_SGE_CNT - 1)) ? (x) + 3 : (x) + 1)
-#define RX_SGE(x)                       ((x) & MAX_RX_SGE)
+#define RX_SGE(x)               ((x) & MAX_RX_SGE)
+
+/* Manipulate a bit vector defined as an array of u64 */
 
-/* SGE producer mask related macros */
 /* Number of bits in one sge_mask array element */
-#define RX_SGE_MASK_ELEM_SZ             64
-#define RX_SGE_MASK_ELEM_SHIFT          6
-#define RX_SGE_MASK_ELEM_MASK           ((u64)RX_SGE_MASK_ELEM_SZ - 1)
+#define BIT_VEC64_ELEM_SZ               64
+#define BIT_VEC64_ELEM_SHIFT            6
+#define BIT_VEC64_ELEM_MASK             ((u64)BIT_VEC64_ELEM_SZ - 1)
+
+
+#define __BIT_VEC64_SET_BIT(el, bit) \
+        do { \
+                el = ((el) | ((u64)0x1 << (bit))); \
+        } while (0)
+
+#define __BIT_VEC64_CLEAR_BIT(el, bit) \
+        do { \
+                el = ((el) & (~((u64)0x1 << (bit)))); \
+        } while (0)
+
+
+#define BIT_VEC64_SET_BIT(vec64, idx) \
+        __BIT_VEC64_SET_BIT((vec64)[(idx) >> BIT_VEC64_ELEM_SHIFT], \
+                           (idx) & BIT_VEC64_ELEM_MASK)
+
+#define BIT_VEC64_CLEAR_BIT(vec64, idx) \
+        __BIT_VEC64_CLEAR_BIT((vec64)[(idx) >> BIT_VEC64_ELEM_SHIFT], \
+                             (idx) & BIT_VEC64_ELEM_MASK)
+
+#define BIT_VEC64_TEST_BIT(vec64, idx) \
+        (((vec64)[(idx) >> BIT_VEC64_ELEM_SHIFT] >> \
+        ((idx) & BIT_VEC64_ELEM_MASK)) & 0x1)
 
 /* Creates a bitmask of all ones in less significant bits.
    idx - index of the most significant bit in the created mask */
-#define RX_SGE_ONES_MASK(idx) \
-                (((u64)0x1 << (((idx) & RX_SGE_MASK_ELEM_MASK) + 1)) - 1)
-#define RX_SGE_MASK_ELEM_ONE_MASK       ((u64)(~0))
+#define BIT_VEC64_ONES_MASK(idx) \
+                (((u64)0x1 << (((idx) & BIT_VEC64_ELEM_MASK) + 1)) - 1)
+#define BIT_VEC64_ELEM_ONE_MASK ((u64)(~0))
+
+/*******************************************************/
+
+
 
 /* Number of u64 elements in SGE mask array */
 #define RX_SGE_MASK_LEN                 ((NUM_RX_SGE_PAGES * RX_SGE_CNT) / \
-                                         RX_SGE_MASK_ELEM_SZ)
+                                         BIT_VEC64_ELEM_SZ)
 #define RX_SGE_MASK_LEN_MASK            (RX_SGE_MASK_LEN - 1)
 #define NEXT_SGE_MASK_ELEM(el)          (((el) + 1) & RX_SGE_MASK_LEN_MASK)
 
@@ -331,7 +369,30 @@ union host_hc_status_block {
         struct host_hc_status_block_e2  *e2_sb;
 };
 
+struct bnx2x_agg_info {
+        /*
+         * First aggregation buffer is an skb, the following - are pages.
+         * We will preallocate the skbs for each aggregation when
+         * we open the interface and will replace the BD at the consumer
+         * with this one when we receive the TPA_START CQE in order to
+         * keep the Rx BD ring consistent.
+         */
+        struct sw_rx_bd         first_buf;
+        u8                      tpa_state;
+#define BNX2X_TPA_START                 1
+#define BNX2X_TPA_STOP                  2
+#define BNX2X_TPA_ERROR                 3
+        u8                      placement_offset;
+        u16                     parsing_flags;
+        u16                     vlan_tag;
+        u16                     len_on_bd;
+};
+
+#define Q_STATS_OFFSET32(stat_name) \
+                        (offsetof(struct bnx2x_eth_q_stats, stat_name) / 4)
+
 struct bnx2x_fastpath {
+        struct bnx2x            *bp; /* parent */
 
 #define BNX2X_NAPI_WEIGHT       128
         struct napi_struct      napi;
@@ -366,23 +427,13 @@ struct bnx2x_fastpath {
 
         u64                     sge_mask[RX_SGE_MASK_LEN];
 
-        int                     state;
-#define BNX2X_FP_STATE_CLOSED           0
-#define BNX2X_FP_STATE_IRQ              0x80000
-#define BNX2X_FP_STATE_OPENING          0x90000
-#define BNX2X_FP_STATE_OPEN             0xa0000
-#define BNX2X_FP_STATE_HALTING          0xb0000
-#define BNX2X_FP_STATE_HALTED           0xc0000
-#define BNX2X_FP_STATE_TERMINATING      0xd0000
-#define BNX2X_FP_STATE_TERMINATED       0xe0000
+        u32                     cid;
 
         u8                      index;          /* number in fp array */
         u8                      cl_id;          /* eth client id */
         u8                      cl_qzone_id;
         u8                      fw_sb_id;       /* status block number in FW */
         u8                      igu_sb_id;      /* status block number in HW */
-        u32                     cid;
-
         union db_prod           tx_db;
 
         u16                     tx_pkt_prod;
@@ -401,24 +452,20 @@ struct bnx2x_fastpath {
         /* The last maximal completed SGE */
         u16                     last_max_sge;
         __le16                  *rx_cons_sb;
-
         unsigned long           tx_pkt,
                                 rx_pkt,
                                 rx_calls;
 
         /* TPA related */
-        struct sw_rx_bd         tpa_pool[ETH_MAX_AGGREGATION_QUEUES_E1H];
-        u8                      tpa_state[ETH_MAX_AGGREGATION_QUEUES_E1H];
-#define BNX2X_TPA_START                 1
-#define BNX2X_TPA_STOP                  2
+        struct bnx2x_agg_info   tpa_info[ETH_MAX_AGGREGATION_QUEUES_E1H_E2];
         u8                      disable_tpa;
 #ifdef BNX2X_STOP_ON_ERROR
         u64                     tpa_queue_used;
 #endif
 
-        struct tstorm_per_client_stats old_tclient;
-        struct ustorm_per_client_stats old_uclient;
-        struct xstorm_per_client_stats old_xclient;
+        struct tstorm_per_queue_stats old_tclient;
+        struct ustorm_per_queue_stats old_uclient;
+        struct xstorm_per_queue_stats old_xclient;
         struct bnx2x_eth_q_stats eth_q_stats;
 
         /* The size is calculated using the following:
@@ -427,7 +474,13 @@ struct bnx2x_fastpath {
              4 (for the digits and to make it DWORD aligned) */
 #define FP_NAME_SIZE            (sizeof(((struct net_device *)0)->name) + 8)
         char                    name[FP_NAME_SIZE];
-        struct bnx2x            *bp; /* parent */
+
+        /* MACs object */
+        struct bnx2x_vlan_mac_obj mac_obj;
+
+        /* Queue State object */
+        struct bnx2x_queue_sp_obj q_obj;
+
 };
 
 #define bnx2x_fp(bp, nr, var)           (bp->fp[nr].var)
@@ -435,11 +488,13 @@ struct bnx2x_fastpath {
 /* Use 2500 as a mini-jumbo MTU for FCoE */
 #define BNX2X_FCOE_MINI_JUMBO_MTU       2500
 
-#ifdef BCM_CNIC
-/* FCoE L2 `fastpath' is right after the eth entries */
+/* FCoE L2 `fastpath' entry is right after the eth entries */
 #define FCOE_IDX                        BNX2X_NUM_ETH_QUEUES(bp)
 #define bnx2x_fcoe_fp(bp)               (&bp->fp[FCOE_IDX])
 #define bnx2x_fcoe(bp, var)             (bnx2x_fcoe_fp(bp)->var)
+
+
+#ifdef BCM_CNIC
 #define IS_FCOE_FP(fp)                  (fp->index == FCOE_IDX)
 #define IS_FCOE_IDX(idx)                ((idx) == FCOE_IDX)
 #else
@@ -449,77 +504,68 @@ struct bnx2x_fastpath {
 
 
 /* MC hsi */
-#define MAX_FETCH_BD                    13      /* HW max BDs per packet */
-#define RX_COPY_THRESH                  92
+#define MAX_FETCH_BD            13      /* HW max BDs per packet */
+#define RX_COPY_THRESH          92
 
-#define NUM_TX_RINGS                    16
+#define NUM_TX_RINGS            16
 #define TX_DESC_CNT             (BCM_PAGE_SIZE / sizeof(union eth_tx_bd_types))
-#define MAX_TX_DESC_CNT                 (TX_DESC_CNT - 1)
-#define NUM_TX_BD                       (TX_DESC_CNT * NUM_TX_RINGS)
-#define MAX_TX_BD                       (NUM_TX_BD - 1)
-#define MAX_TX_AVAIL                    (MAX_TX_DESC_CNT * NUM_TX_RINGS - 2)
-#define INIT_JUMBO_TX_RING_SIZE         MAX_TX_AVAIL
-#define INIT_TX_RING_SIZE               MAX_TX_AVAIL
+#define MAX_TX_DESC_CNT         (TX_DESC_CNT - 1)
+#define NUM_TX_BD               (TX_DESC_CNT * NUM_TX_RINGS)
+#define MAX_TX_BD               (NUM_TX_BD - 1)
+#define MAX_TX_AVAIL            (MAX_TX_DESC_CNT * NUM_TX_RINGS - 2)
 #define NEXT_TX_IDX(x)          ((((x) & MAX_TX_DESC_CNT) == \
                                   (MAX_TX_DESC_CNT - 1)) ? (x) + 2 : (x) + 1)
-#define TX_BD(x)                        ((x) & MAX_TX_BD)
-#define TX_BD_POFF(x)                   ((x) & MAX_TX_DESC_CNT)
+#define TX_BD(x)                ((x) & MAX_TX_BD)
+#define TX_BD_POFF(x)           ((x) & MAX_TX_DESC_CNT)
 
 /* The RX BD ring is special, each bd is 8 bytes but the last one is 16 */
-#define NUM_RX_RINGS                    8
+#define NUM_RX_RINGS            8
 #define RX_DESC_CNT             (BCM_PAGE_SIZE / sizeof(struct eth_rx_bd))
-#define MAX_RX_DESC_CNT                 (RX_DESC_CNT - 2)
-#define RX_DESC_MASK                    (RX_DESC_CNT - 1)
-#define NUM_RX_BD                       (RX_DESC_CNT * NUM_RX_RINGS)
-#define MAX_RX_BD                       (NUM_RX_BD - 1)
-#define MAX_RX_AVAIL                    (MAX_RX_DESC_CNT * NUM_RX_RINGS - 2)
-#define MIN_RX_SIZE_TPA                 72
-#define MIN_RX_SIZE_NONTPA              10
-#define INIT_JUMBO_RX_RING_SIZE         MAX_RX_AVAIL
-#define INIT_RX_RING_SIZE               MAX_RX_AVAIL
+#define MAX_RX_DESC_CNT         (RX_DESC_CNT - 2)
+#define RX_DESC_MASK            (RX_DESC_CNT - 1)
+#define NUM_RX_BD               (RX_DESC_CNT * NUM_RX_RINGS)
+#define MAX_RX_BD               (NUM_RX_BD - 1)
+#define MAX_RX_AVAIL            (MAX_RX_DESC_CNT * NUM_RX_RINGS - 2)
+#define MIN_RX_AVAIL            128
+
+#define MIN_RX_SIZE_TPA_HW      (CHIP_IS_E1(bp) ? \
+                                        ETH_MIN_RX_CQES_WITH_TPA_E1 : \
+                                        ETH_MIN_RX_CQES_WITH_TPA_E1H_E2)
+#define MIN_RX_SIZE_NONTPA_HW   ETH_MIN_RX_CQES_WITHOUT_TPA
+#define MIN_RX_SIZE_TPA         (max_t(u32, MIN_RX_SIZE_TPA_HW, MIN_RX_AVAIL))
+#define MIN_RX_SIZE_NONTPA      (max_t(u32, MIN_RX_SIZE_NONTPA_HW,\
+                                                                MIN_RX_AVAIL))
+
 #define NEXT_RX_IDX(x)          ((((x) & RX_DESC_MASK) == \
                                   (MAX_RX_DESC_CNT - 1)) ? (x) + 3 : (x) + 1)
-#define RX_BD(x)                        ((x) & MAX_RX_BD)
+#define RX_BD(x)                ((x) & MAX_RX_BD)
 
-/* As long as CQE is 4 times bigger than BD entry we have to allocate
-   4 times more pages for CQ ring in order to keep it balanced with
-   BD ring */
-#define NUM_RCQ_RINGS                   (NUM_RX_RINGS * 4)
+/*
+ * As long as CQE is X times bigger than BD entry we have to allocate X times
+ * more pages for CQ ring in order to keep it balanced with BD ring
+ */
+#define CQE_BD_REL      (sizeof(union eth_rx_cqe) / sizeof(struct eth_rx_bd))
+#define NUM_RCQ_RINGS           (NUM_RX_RINGS * CQE_BD_REL)
 #define RCQ_DESC_CNT            (BCM_PAGE_SIZE / sizeof(union eth_rx_cqe))
-#define MAX_RCQ_DESC_CNT                (RCQ_DESC_CNT - 1)
-#define NUM_RCQ_BD                      (RCQ_DESC_CNT * NUM_RCQ_RINGS)
-#define MAX_RCQ_BD                      (NUM_RCQ_BD - 1)
-#define MAX_RCQ_AVAIL                   (MAX_RCQ_DESC_CNT * NUM_RCQ_RINGS - 2)
+#define MAX_RCQ_DESC_CNT        (RCQ_DESC_CNT - 1)
+#define NUM_RCQ_BD              (RCQ_DESC_CNT * NUM_RCQ_RINGS)
+#define MAX_RCQ_BD              (NUM_RCQ_BD - 1)
+#define MAX_RCQ_AVAIL           (MAX_RCQ_DESC_CNT * NUM_RCQ_RINGS - 2)
 #define NEXT_RCQ_IDX(x)         ((((x) & MAX_RCQ_DESC_CNT) == \
                                   (MAX_RCQ_DESC_CNT - 1)) ? (x) + 2 : (x) + 1)
-#define RCQ_BD(x)                       ((x) & MAX_RCQ_BD)
+#define RCQ_BD(x)               ((x) & MAX_RCQ_BD)
 
 
 /* This is needed for determining of last_max */
-#define SUB_S16(a, b)                   (s16)((s16)(a) - (s16)(b))
-
-#define __SGE_MASK_SET_BIT(el, bit) \
-        do { \
-                el = ((el) | ((u64)0x1 << (bit))); \
-        } while (0)
-
-#define __SGE_MASK_CLEAR_BIT(el, bit) \
-        do { \
-                el = ((el) & (~((u64)0x1 << (bit)))); \
-        } while (0)
-
-#define SGE_MASK_SET_BIT(fp, idx) \
-        __SGE_MASK_SET_BIT(fp->sge_mask[(idx) >> RX_SGE_MASK_ELEM_SHIFT], \
-                           ((idx) & RX_SGE_MASK_ELEM_MASK))
+#define SUB_S16(a, b)           (s16)((s16)(a) - (s16)(b))
+#define SUB_S32(a, b)           (s32)((s32)(a) - (s32)(b))
 
-#define SGE_MASK_CLEAR_BIT(fp, idx) \
-        __SGE_MASK_CLEAR_BIT(fp->sge_mask[(idx) >> RX_SGE_MASK_ELEM_SHIFT], \
-                             ((idx) & RX_SGE_MASK_ELEM_MASK))
 
+#define BNX2X_SWCID_SHIFT       17
+#define BNX2X_SWCID_MASK        ((0x1 << BNX2X_SWCID_SHIFT) - 1)
 
 /* used on a CID received from the HW */
-#define SW_CID(x)                       (le32_to_cpu(x) & \
-                                         (COMMON_RAMROD_ETH_RX_CQE_CID >> 7))
+#define SW_CID(x)                       (le32_to_cpu(x) & BNX2X_SWCID_MASK)
 #define CQE_CMD(x)                      (le32_to_cpu(x) >> \
                                         COMMON_RAMROD_ETH_RX_CQE_CMD_ID_SHIFT)
 
@@ -529,6 +575,9 @@ struct bnx2x_fastpath {
 
 #define BNX2X_DB_MIN_SHIFT              3       /* 8 bytes */
 #define BNX2X_DB_SHIFT                  7       /* 128 bytes*/
+#if (BNX2X_DB_SHIFT < BNX2X_DB_MIN_SHIFT)
+#error "Min DB doorbell stride is 8"
+#endif
 #define DPM_TRIGER_TYPE                 0x40
 #define DOORBELL(bp, cid, val) \
         do { \
@@ -557,13 +606,11 @@ struct bnx2x_fastpath {
 
 
 /* stuff added to make the code fit 80Col */
-
-#define CQE_TYPE(cqe_fp_flags)  ((cqe_fp_flags) & ETH_FAST_PATH_RX_CQE_TYPE)
-
-#define TPA_TYPE_START                  ETH_FAST_PATH_RX_CQE_START_FLG
-#define TPA_TYPE_END                    ETH_FAST_PATH_RX_CQE_END_FLG
-#define TPA_TYPE(cqe_fp_flags)          ((cqe_fp_flags) & \
-                                         (TPA_TYPE_START | TPA_TYPE_END))
+#define CQE_TYPE(cqe_fp_flags)   ((cqe_fp_flags) & ETH_FAST_PATH_RX_CQE_TYPE)
+#define CQE_TYPE_START(cqe_type) ((cqe_type) == RX_ETH_CQE_TYPE_ETH_START_AGG)
+#define CQE_TYPE_STOP(cqe_type)  ((cqe_type) == RX_ETH_CQE_TYPE_ETH_STOP_AGG)
+#define CQE_TYPE_SLOW(cqe_type)  ((cqe_type) == RX_ETH_CQE_TYPE_ETH_RAMROD)
+#define CQE_TYPE_FAST(cqe_type)  ((cqe_type) == RX_ETH_CQE_TYPE_ETH_FASTPATH)
 
 #define ETH_RX_ERROR_FALGS              ETH_FAST_PATH_RX_CQE_PHY_DECODE_ERR_FLG
 
@@ -590,12 +637,30 @@ struct bnx2x_fastpath {
 #define BNX2X_RX_SUM_FIX(cqe) \
         BNX2X_PRS_FLAG_OVERETH_IPV4(cqe->fast_path_cqe.pars_flags.flags)
 
-#define U_SB_ETH_RX_CQ_INDEX            1
-#define U_SB_ETH_RX_BD_INDEX            2
-#define C_SB_ETH_TX_CQ_INDEX            5
+
+#define FP_USB_FUNC_OFF \
+                        offsetof(struct cstorm_status_block_u, func)
+#define FP_CSB_FUNC_OFF \
+                        offsetof(struct cstorm_status_block_c, func)
+
+#define HC_INDEX_TOE_RX_CQ_CONS         0 /* Formerly Ustorm TOE CQ index */
+                                          /* (HC_INDEX_U_TOE_RX_CQ_CONS)  */
+#define HC_INDEX_ETH_RX_CQ_CONS         1 /* Formerly Ustorm ETH CQ index */
+                                          /* (HC_INDEX_U_ETH_RX_CQ_CONS)  */
+#define HC_INDEX_ETH_RX_BD_CONS         2 /* Formerly Ustorm ETH BD index */
+                                          /* (HC_INDEX_U_ETH_RX_BD_CONS)  */
+
+#define HC_INDEX_TOE_TX_CQ_CONS         4 /* Formerly Cstorm TOE CQ index   */
+                                          /* (HC_INDEX_C_TOE_TX_CQ_CONS)    */
+#define HC_INDEX_ETH_TX_CQ_CONS         5 /* Formerly Cstorm ETH CQ index   */
+                                          /* (HC_INDEX_C_ETH_TX_CQ_CONS)    */
+
+#define U_SB_ETH_RX_CQ_INDEX            HC_INDEX_ETH_RX_CQ_CONS
+#define U_SB_ETH_RX_BD_INDEX            HC_INDEX_ETH_RX_BD_CONS
+#define C_SB_ETH_TX_CQ_INDEX            HC_INDEX_ETH_TX_CQ_CONS
 
 #define BNX2X_RX_SB_INDEX \
-        (&fp->sb_index_values[U_SB_ETH_RX_CQ_INDEX])
+        (&fp->sb_index_values[HC_INDEX_ETH_RX_CQ_CONS])
 
 #define BNX2X_TX_SB_INDEX \
         (&fp->sb_index_values[C_SB_ETH_TX_CQ_INDEX])
@@ -615,29 +680,53 @@ struct bnx2x_common {
 #define CHIP_NUM_57711                  0x164f
 #define CHIP_NUM_57711E                 0x1650
 #define CHIP_NUM_57712                  0x1662
-#define CHIP_NUM_57712E                 0x1663
+#define CHIP_NUM_57712_MF               0x1663
+#define CHIP_NUM_57713                  0x1651
+#define CHIP_NUM_57713E                 0x1652
+#define CHIP_NUM_57800                  0x168a
+#define CHIP_NUM_57800_MF               0x16a5
+#define CHIP_NUM_57810                  0x168e
+#define CHIP_NUM_57810_MF               0x16ae
+#define CHIP_NUM_57840                  0x168d
+#define CHIP_NUM_57840_MF               0x16ab
 #define CHIP_IS_E1(bp)                  (CHIP_NUM(bp) == CHIP_NUM_57710)
 #define CHIP_IS_57711(bp)               (CHIP_NUM(bp) == CHIP_NUM_57711)
 #define CHIP_IS_57711E(bp)              (CHIP_NUM(bp) == CHIP_NUM_57711E)
 #define CHIP_IS_57712(bp)               (CHIP_NUM(bp) == CHIP_NUM_57712)
-#define CHIP_IS_57712E(bp)              (CHIP_NUM(bp) == CHIP_NUM_57712E)
+#define CHIP_IS_57712_MF(bp)            (CHIP_NUM(bp) == CHIP_NUM_57712_MF)
+#define CHIP_IS_57800(bp)               (CHIP_NUM(bp) == CHIP_NUM_57800)
+#define CHIP_IS_57800_MF(bp)            (CHIP_NUM(bp) == CHIP_NUM_57800_MF)
+#define CHIP_IS_57810(bp)               (CHIP_NUM(bp) == CHIP_NUM_57810)
+#define CHIP_IS_57810_MF(bp)            (CHIP_NUM(bp) == CHIP_NUM_57810_MF)
+#define CHIP_IS_57840(bp)               (CHIP_NUM(bp) == CHIP_NUM_57840)
+#define CHIP_IS_57840_MF(bp)            (CHIP_NUM(bp) == CHIP_NUM_57840_MF)
 #define CHIP_IS_E1H(bp)                 (CHIP_IS_57711(bp) || \
                                          CHIP_IS_57711E(bp))
 #define CHIP_IS_E2(bp)                  (CHIP_IS_57712(bp) || \
-                                         CHIP_IS_57712E(bp))
+                                         CHIP_IS_57712_MF(bp))
+#define CHIP_IS_E3(bp)                  (CHIP_IS_57800(bp) || \
+                                         CHIP_IS_57800_MF(bp) || \
+                                         CHIP_IS_57810(bp) || \
+                                         CHIP_IS_57810_MF(bp) || \
+                                         CHIP_IS_57840(bp) || \
+                                         CHIP_IS_57840_MF(bp))
 #define CHIP_IS_E1x(bp)                 (CHIP_IS_E1((bp)) || CHIP_IS_E1H((bp)))
-#define IS_E1H_OFFSET                   (CHIP_IS_E1H(bp) || CHIP_IS_E2(bp))
-
-#define CHIP_REV(bp)                    (bp->common.chip_id & 0x0000f000)
-#define CHIP_REV_Ax                     0x00000000
+#define USES_WARPCORE(bp)               (CHIP_IS_E3(bp))
+#define IS_E1H_OFFSET                   (!CHIP_IS_E1(bp))
+
+#define CHIP_REV_SHIFT                  12
+#define CHIP_REV_MASK                   (0xF << CHIP_REV_SHIFT)
+#define CHIP_REV_VAL(bp)                (bp->common.chip_id & CHIP_REV_MASK)
+#define CHIP_REV_Ax                     (0x0 << CHIP_REV_SHIFT)
+#define CHIP_REV_Bx                     (0x1 << CHIP_REV_SHIFT)
 /* assume maximum 5 revisions */
-#define CHIP_REV_IS_SLOW(bp)            (CHIP_REV(bp) > 0x00005000)
+#define CHIP_REV_IS_SLOW(bp)            (CHIP_REV_VAL(bp) > 0x00005000)
 /* Emul versions are A=>0xe, B=>0xc, C=>0xa, D=>8, E=>6 */
 #define CHIP_REV_IS_EMUL(bp)            ((CHIP_REV_IS_SLOW(bp)) && \
-                                         !(CHIP_REV(bp) & 0x00001000))
+                                         !(CHIP_REV_VAL(bp) & 0x00001000))
 /* FPGA versions are A=>0xf, B=>0xd, C=>0xb, D=>9, E=>7 */
 #define CHIP_REV_IS_FPGA(bp)            ((CHIP_REV_IS_SLOW(bp)) && \
-                                         (CHIP_REV(bp) & 0x00001000))
+                                         (CHIP_REV_VAL(bp) & 0x00001000))
 
 #define CHIP_TIME(bp)                   ((CHIP_REV_IS_EMUL(bp)) ? 2000 : \
                                         ((CHIP_REV_IS_FPGA(bp)) ? 200 : 1))
@@ -645,6 +734,16 @@ struct bnx2x_common {
 #define CHIP_METAL(bp)                  (bp->common.chip_id & 0x00000ff0)
 #define CHIP_BOND_ID(bp)                (bp->common.chip_id & 0x0000000f)
 #define CHIP_PARITY_ENABLED(bp) (CHIP_IS_E1(bp) || CHIP_IS_E1H(bp))
+#define CHIP_REV_SIM(bp)                (((CHIP_REV_MASK - CHIP_REV_VAL(bp)) >>\
+                                           (CHIP_REV_SHIFT + 1)) \
+                                                << CHIP_REV_SHIFT)
+#define CHIP_REV(bp)                    (CHIP_REV_IS_SLOW(bp) ? \
+                                                CHIP_REV_SIM(bp) :\
+                                                CHIP_REV_VAL(bp))
+#define CHIP_IS_E3B0(bp)                (CHIP_IS_E3(bp) && \
+                                         (CHIP_REV(bp) == CHIP_REV_Bx))
+#define CHIP_IS_E3A0(bp)                (CHIP_IS_E3(bp) && \
+                                         (CHIP_REV(bp) == CHIP_REV_Ax))
 
         int                     flash_size;
 #define NVRAM_1MB_SIZE                  0x20000 /* 1M bit in bytes */
@@ -666,7 +765,7 @@ struct bnx2x_common {
 #define INT_BLOCK_MODE_NORMAL           0
 #define INT_BLOCK_MODE_BW_COMP          2
 #define CHIP_INT_MODE_IS_NBC(bp)                \
-                        (CHIP_IS_E2(bp) &&      \
+                        (!CHIP_IS_E1x(bp) &&    \
                         !((bp)->common.int_block & INT_BLOCK_MODE_BW_COMP))
 #define CHIP_INT_MODE_IS_BC(bp) (!CHIP_INT_MODE_IS_NBC(bp))
 
@@ -712,19 +811,15 @@ struct bnx2x_port {
 
 /* end of port */
 
-/* e1h Classification CAM line allocations */
-enum {
-        CAM_ETH_LINE = 0,
-        CAM_ISCSI_ETH_LINE,
-        CAM_FIP_ETH_LINE,
-        CAM_FIP_MCAST_LINE,
-        CAM_MAX_PF_LINE = CAM_FIP_MCAST_LINE
-};
-/* number of MACs per function in NIG memory - used for SI mode */
-#define NIG_LLH_FUNC_MEM_SIZE           16
-/* number of entries in NIG_REG_LLHX_FUNC_MEM */
-#define NIG_LLH_FUNC_MEM_MAX_OFFSET     8
+#define STATS_OFFSET32(stat_name) \
+                        (offsetof(struct bnx2x_eth_stats, stat_name) / 4)
 
+/* slow path */
+
+/* slow path work-queue */
+extern struct workqueue_struct *bnx2x_wq;
+
+#define BNX2X_MAX_NUM_OF_VFS    64
 #define BNX2X_VF_ID_INVALID     0xFF
 
 /*
@@ -749,8 +844,10 @@ enum {
  *    L2 queue is supported. the cid for the FCoE L2 queue is always X.
  */
 
-#define FP_SB_MAX_E1x           16      /* fast-path interrupt contexts E1x */
-#define FP_SB_MAX_E2            16      /* fast-path interrupt contexts E2 */
+/* fast-path interrupt contexts E1x */
+#define FP_SB_MAX_E1x           16
+/* fast-path interrupt contexts E2 */
+#define FP_SB_MAX_E2            HC_SB_MAX_SB_E2
 
 /*
  * cid_cnt paramter below refers to the value returned by
@@ -761,13 +858,13 @@ enum {
  * The number of FP context allocated by the driver == max number of regular
  * L2 queues + 1 for the FCoE L2 queue
  */
-#define L2_FP_COUNT(cid_cnt)    ((cid_cnt) - CNIC_CONTEXT_USE)
+#define L2_FP_COUNT(cid_cnt)    ((cid_cnt) - FCOE_CONTEXT_USE)
 
 /*
  * The number of FP-SB allocated by the driver == max number of regular L2
  * queues + 1 for the CNIC which also consumes an FP-SB
  */
-#define FP_SB_COUNT(cid_cnt)    ((cid_cnt) - FCOE_CONTEXT_USE)
+#define FP_SB_COUNT(cid_cnt)    ((cid_cnt) - CNIC_CONTEXT_USE)
 #define NUM_IGU_SB_REQUIRED(cid_cnt) \
                                 (FP_SB_COUNT(cid_cnt) - NONE_ETH_CONTEXT_USE)
 
@@ -788,38 +885,61 @@ union cdu_context {
 #define CNIC_ILT_LINES          DIV_ROUND_UP(CNIC_CID_MAX, ILT_PAGE_CIDS)
 #endif
 
-#define QM_ILT_PAGE_SZ_HW       3
-#define QM_ILT_PAGE_SZ          (4096 << QM_ILT_PAGE_SZ_HW) /* 32K */
+#define QM_ILT_PAGE_SZ_HW       0
+#define QM_ILT_PAGE_SZ          (4096 << QM_ILT_PAGE_SZ_HW) /* 4K */
 #define QM_CID_ROUND            1024
 
 #ifdef BCM_CNIC
 /* TM (timers) host DB constants */
-#define TM_ILT_PAGE_SZ_HW       2
-#define TM_ILT_PAGE_SZ          (4096 << TM_ILT_PAGE_SZ_HW) /* 16K */
+#define TM_ILT_PAGE_SZ_HW       0
+#define TM_ILT_PAGE_SZ          (4096 << TM_ILT_PAGE_SZ_HW) /* 4K */
 /* #define TM_CONN_NUM          (CNIC_STARTING_CID+CNIC_ISCSI_CXT_MAX) */
 #define TM_CONN_NUM             1024
 #define TM_ILT_SZ               (8 * TM_CONN_NUM)
 #define TM_ILT_LINES            DIV_ROUND_UP(TM_ILT_SZ, TM_ILT_PAGE_SZ)
 
 /* SRC (Searcher) host DB constants */
-#define SRC_ILT_PAGE_SZ_HW      3
-#define SRC_ILT_PAGE_SZ         (4096 << SRC_ILT_PAGE_SZ_HW) /* 32K */
+#define SRC_ILT_PAGE_SZ_HW      0
+#define SRC_ILT_PAGE_SZ         (4096 << SRC_ILT_PAGE_SZ_HW) /* 4K */
 #define SRC_HASH_BITS           10
 #define SRC_CONN_NUM            (1 << SRC_HASH_BITS) /* 1024 */
 #define SRC_ILT_SZ              (sizeof(struct src_ent) * SRC_CONN_NUM)
 #define SRC_T2_SZ               SRC_ILT_SZ
 #define SRC_ILT_LINES           DIV_ROUND_UP(SRC_ILT_SZ, SRC_ILT_PAGE_SZ)
+
 #endif
 
-#define MAX_DMAE_C                      8
+#define MAX_DMAE_C              8
 
 /* DMA memory not used in fastpath */
 struct bnx2x_slowpath {
-        struct eth_stats_query          fw_stats;
-        struct mac_configuration_cmd    mac_config;
-        struct mac_configuration_cmd    mcast_config;
-        struct mac_configuration_cmd    uc_mac_config;
-        struct client_init_ramrod_data  client_init_data;
+        union {
+                struct mac_configuration_cmd            e1x;
+                struct eth_classify_rules_ramrod_data   e2;
+        } mac_rdata;
+
+
+        union {
+                struct tstorm_eth_mac_filter_config     e1x;
+                struct eth_filter_rules_ramrod_data     e2;
+        } rx_mode_rdata;
+
+        union {
+                struct mac_configuration_cmd            e1;
+                struct eth_multicast_rules_ramrod_data  e2;
+        } mcast_rdata;
+
+        struct eth_rss_update_ramrod_data       rss_rdata;
+
+        /* Queue State related ramrods are always sent under rtnl_lock */
+        union {
+                struct client_init_ramrod_data  init_data;
+                struct client_update_ramrod_data update_data;
+        } q_rdata;
+
+        union {
+                struct function_start_data      func_start;
+        } func_rdata;
 
         /* used by dmae command executer */
         struct dmae_command             dmae[MAX_DMAE_C];
@@ -846,7 +966,7 @@ struct bnx2x_slowpath {
 #define MAX_DYNAMIC_ATTN_GRPS           8
 
 struct attn_route {
-        u32     sig[5];
+        u32 sig[5];
 };
 
 struct iro {
@@ -872,7 +992,7 @@ typedef enum {
         BNX2X_RECOVERY_WAIT,
 } bnx2x_recovery_state_t;
 
-/**
+/*
  * Event queue (EQ or event ring) MC hsi
  * NUM_EQ_PAGES and EQ_DESC_CNT_PAGE must be power of 2
  */
@@ -910,6 +1030,24 @@ enum {
         BNX2X_LINK_REPORT_TX_FC_ON,
 };
 
+enum {
+        BNX2X_PORT_QUERY_IDX,
+        BNX2X_PF_QUERY_IDX,
+        BNX2X_FIRST_QUEUE_QUERY_IDX,
+};
+
+struct bnx2x_fw_stats_req {
+        struct stats_query_header hdr;
+        struct stats_query_entry query[STATS_QUERY_CMD_COUNT];
+};
+
+struct bnx2x_fw_stats_data {
+        struct stats_counter    storm_counters;
+        struct per_port_stats   port;
+        struct per_pf_stats     pf;
+        struct per_queue_stats  queue_stats[1];
+};
+
 struct bnx2x {
         /* Fields used in the tx and intr/napi performance paths
          * are grouped together in the beginning of the structure
@@ -919,10 +1057,23 @@ struct bnx2x {
         void __iomem            *doorbells;
         u16                     db_size;
 
+        u8                      pf_num; /* absolute PF number */
+        u8                      pfid;   /* per-path PF number */
+        int                     base_fw_ndsb; /**/
+#define BP_PATH(bp)                     (CHIP_IS_E1x(bp) ? 0 : (bp->pf_num & 1))
+#define BP_PORT(bp)                     (bp->pfid & 1)
+#define BP_FUNC(bp)                     (bp->pfid)
+#define BP_ABS_FUNC(bp)                 (bp->pf_num)
+#define BP_E1HVN(bp)                    (bp->pfid >> 1)
+#define BP_VN(bp)                       (BP_E1HVN(bp)) /*remove when approved*/
+#define BP_L_ID(bp)                     (BP_E1HVN(bp) << 2)
+#define BP_FW_MB_IDX(bp)                (BP_PORT(bp) +\
+                                         BP_VN(bp) * (CHIP_IS_E1x(bp) ? 2  : 1))
+
         struct net_device       *dev;
         struct pci_dev          *pdev;
 
-        struct iro              *iro_arr;
+        const struct iro        *iro_arr;
 #define IRO (bp->iro_arr)
 
         bnx2x_recovery_state_t  recovery_state;
@@ -940,7 +1091,8 @@ struct bnx2x {
         /* Max supported alignment is 256 (8 shift) */
 #define BNX2X_RX_ALIGN_SHIFT            ((L1_CACHE_SHIFT < 8) ? \
                                          L1_CACHE_SHIFT : 8)
-#define BNX2X_RX_ALIGN                  (1 << BNX2X_RX_ALIGN_SHIFT)
+        /* FW use 2 Cache lines Alignment for start packet and size  */
+#define BNX2X_FW_RX_ALIGN               (2 << BNX2X_RX_ALIGN_SHIFT)
 #define BNX2X_PXP_DRAM_ALIGN            (BNX2X_RX_ALIGN_SHIFT - 5)
 
         struct host_sp_status_block *def_status_blk;
@@ -970,10 +1122,12 @@ struct bnx2x {
         __le16                  *eq_cons_sb;
         atomic_t                eq_spq_left; /* COMMON_XXX ramrods credit */
 
-        /* Flags for marking that there is a STAT_QUERY or
-           SET_MAC ramrod pending */
-        int                     stats_pending;
-        int                     set_mac_pending;
+
+
+        /* Counter for marking that there is a STAT_QUERY ramrod pending */
+        u16                     stats_pending;
+        /*  Counter for completed statistics ramrods */
+        u16                     stats_comp;
 
         /* End of fields used in the performance code paths */
 
@@ -981,47 +1135,27 @@ struct bnx2x {
         int                     msg_enable;
 
         u32                     flags;
-#define PCIX_FLAG                       1
-#define PCI_32BIT_FLAG                  2
-#define ONE_PORT_FLAG                   4
-#define NO_WOL_FLAG                     8
-#define USING_DAC_FLAG                  0x10
-#define USING_MSIX_FLAG                 0x20
-#define USING_MSI_FLAG                  0x40
-
-#define TPA_ENABLE_FLAG                 0x80
-#define NO_MCP_FLAG                     0x100
-#define DISABLE_MSI_FLAG                0x200
+#define PCIX_FLAG                       (1 << 0)
+#define PCI_32BIT_FLAG                  (1 << 1)
+#define ONE_PORT_FLAG                   (1 << 2)
+#define NO_WOL_FLAG                     (1 << 3)
+#define USING_DAC_FLAG                  (1 << 4)
+#define USING_MSIX_FLAG                 (1 << 5)
+#define USING_MSI_FLAG                  (1 << 6)
+#define DISABLE_MSI_FLAG                (1 << 7)
+#define TPA_ENABLE_FLAG                 (1 << 8)
+#define NO_MCP_FLAG                     (1 << 9)
+
 #define BP_NOMCP(bp)                    (bp->flags & NO_MCP_FLAG)
-#define MF_FUNC_DIS                     0x1000
-#define FCOE_MACS_SET                   0x2000
-#define NO_FCOE_FLAG                    0x4000
-#define NO_ISCSI_OOO_FLAG               0x8000
-#define NO_ISCSI_FLAG                   0x10000
+#define MF_FUNC_DIS                     (1 << 11)
+#define OWN_CNIC_IRQ                    (1 << 12)
+#define NO_ISCSI_OOO_FLAG               (1 << 13)
+#define NO_ISCSI_FLAG                   (1 << 14)
+#define NO_FCOE_FLAG                    (1 << 15)
 
-#define NO_FCOE(bp)             ((bp)->flags & NO_FCOE_FLAG)
 #define NO_ISCSI(bp)            ((bp)->flags & NO_ISCSI_FLAG)
 #define NO_ISCSI_OOO(bp)        ((bp)->flags & NO_ISCSI_OOO_FLAG)
-
-        int                     pf_num; /* absolute PF number */
-        int                     pfid;   /* per-path PF number */
-        int                     base_fw_ndsb;
-#define BP_PATH(bp)                     (!CHIP_IS_E2(bp) ? \
-                                                0 : (bp->pf_num & 1))
-#define BP_PORT(bp)                     (bp->pfid & 1)
-#define BP_FUNC(bp)                     (bp->pfid)
-#define BP_ABS_FUNC(bp)                 (bp->pf_num)
-#define BP_E1HVN(bp)                    (bp->pfid >> 1)
-#define BP_VN(bp)                       (CHIP_MODE_IS_4_PORT(bp) ? \
-                                                0 : BP_E1HVN(bp))
-#define BP_L_ID(bp)                     (BP_E1HVN(bp) << 2)
-#define BP_FW_MB_IDX(bp)                (BP_PORT(bp) +\
-                                         BP_VN(bp) * (CHIP_IS_E1x(bp) ? 2  : 1))
-
-#ifdef BCM_CNIC
-#define BCM_CNIC_CID_START              16
-#define BCM_ISCSI_ETH_CL_ID             17
-#endif
+#define NO_FCOE(bp)             ((bp)->flags & NO_FCOE_FLAG)
 
         int                     pm_cap;
         int                     pcie_cap;
@@ -1048,9 +1182,9 @@ struct bnx2x {
 
         struct cmng_struct_per_port cmng;
         u32                     vn_weight_sum;
-
         u32                     mf_config[E1HVN_MAX];
         u32                     mf2_config[E2_FUNC_MAX];
+        u32                     path_has_ovlan; /* E3 */
         u16                     mf_ov;
         u8                      mf_mode;
 #define IS_MF(bp)               (bp->mf_mode != 0)
@@ -1075,32 +1209,20 @@ struct bnx2x {
 
         u32                     lin_cnt;
 
-        int                     state;
+        u16                     state;
 #define BNX2X_STATE_CLOSED              0
 #define BNX2X_STATE_OPENING_WAIT4_LOAD  0x1000
 #define BNX2X_STATE_OPENING_WAIT4_PORT  0x2000
 #define BNX2X_STATE_OPEN                0x3000
 #define BNX2X_STATE_CLOSING_WAIT4_HALT  0x4000
 #define BNX2X_STATE_CLOSING_WAIT4_DELETE 0x5000
-#define BNX2X_STATE_CLOSING_WAIT4_UNLOAD 0x6000
-#define BNX2X_STATE_FUNC_STARTED        0x7000
+
 #define BNX2X_STATE_DIAG                0xe000
 #define BNX2X_STATE_ERROR               0xf000
 
         int                     multi_mode;
         int                     num_queues;
         int                     disable_tpa;
-        u32                     *rx_indir_table;
-
-        struct tstorm_eth_mac_filter_config     mac_filters;
-#define BNX2X_ACCEPT_NONE               0x0000
-#define BNX2X_ACCEPT_UNICAST            0x0001
-#define BNX2X_ACCEPT_MULTICAST          0x0002
-#define BNX2X_ACCEPT_ALL_UNICAST        0x0004
-#define BNX2X_ACCEPT_ALL_MULTICAST      0x0008
-#define BNX2X_ACCEPT_BROADCAST          0x0010
-#define BNX2X_ACCEPT_UNMATCHED_UCAST    0x0020
-#define BNX2X_PROMISCUOUS_MODE          0x10000
 
         u32                     rx_mode;
 #define BNX2X_RX_MODE_NONE              0
@@ -1108,7 +1230,6 @@ struct bnx2x {
 #define BNX2X_RX_MODE_ALLMULTI          2
 #define BNX2X_RX_MODE_PROMISC           3
 #define BNX2X_MAX_MULTICAST             64
-#define BNX2X_MAX_EMUL_MULTI            16
 
         u8                      igu_dsb_id;
         u8                      igu_base_sb;
@@ -1117,11 +1238,38 @@ struct bnx2x {
 
         struct bnx2x_slowpath   *slowpath;
         dma_addr_t              slowpath_mapping;
+
+        /* Total number of FW statistics requests */
+        u8                      fw_stats_num;
+
+        /*
+         * This is a memory buffer that will contain both statistics
+         * ramrod request and data.
+         */
+        void                    *fw_stats;
+        dma_addr_t              fw_stats_mapping;
+
+        /*
+         * FW statistics request shortcut (points at the
+         * beginning of fw_stats buffer).
+         */
+        struct bnx2x_fw_stats_req       *fw_stats_req;
+        dma_addr_t                      fw_stats_req_mapping;
+        int                             fw_stats_req_sz;
+
+        /*
+         * FW statistics data shortcut (points at the begining of
+         * fw_stats buffer + fw_stats_req_sz).
+         */
+        struct bnx2x_fw_stats_data      *fw_stats_data;
+        dma_addr_t                      fw_stats_data_mapping;
+        int                             fw_stats_data_sz;
+
         struct hw_context       context;
 
         struct bnx2x_ilt        *ilt;
 #define BP_ILT(bp)              ((bp)->ilt)
-#define ILT_MAX_LINES           128
+#define ILT_MAX_LINES           256
 
         int                     l2_cid_count;
 #define L2_ILT_LINES(bp)        (DIV_ROUND_UP((bp)->l2_cid_count, \
@@ -1143,16 +1291,18 @@ struct bnx2x {
         struct cnic_eth_dev     cnic_eth_dev;
         union host_hc_status_block cnic_sb;
         dma_addr_t              cnic_sb_mapping;
-#define CNIC_SB_ID(bp)          ((bp)->base_fw_ndsb + BP_L_ID(bp))
-#define CNIC_IGU_SB_ID(bp)      ((bp)->igu_base_sb)
         struct eth_spe          *cnic_kwq;
         struct eth_spe          *cnic_kwq_prod;
         struct eth_spe          *cnic_kwq_cons;
         struct eth_spe          *cnic_kwq_last;
         u16                     cnic_kwq_pending;
         u16                     cnic_spq_pending;
-        struct mutex            cnic_mutex;
         u8                      fip_mac[ETH_ALEN];
+        struct mutex            cnic_mutex;
+        struct bnx2x_vlan_mac_obj iscsi_l2_mac_obj;
+
+        /* Start index of the "special" (CNIC related) L2 cleints */
+        u8                              cnic_base_cl_id;
 #endif
 
         int                     dmae_ready;
@@ -1189,6 +1339,8 @@ struct bnx2x {
         u16                     *init_ops_offsets;
         /* Data blob - has 32 bit granularity */
         u32                     *init_data;
+        u32                     init_mode_flags;
+#define INIT_MODE_FLAGS(bp)     (bp->init_mode_flags)
         /* Zipped PRAM blobs - raw data */
         const u8                *tsem_int_table_data;
         const u8                *tsem_pram_data;
@@ -1210,8 +1362,10 @@ struct bnx2x {
 #define INIT_CSEM_INT_TABLE_DATA(bp)    (bp->csem_int_table_data)
 #define INIT_CSEM_PRAM_DATA(bp)         (bp->csem_pram_data)
 
+#define PHY_FW_VER_LEN                  20
         char                    fw_ver[32];
         const struct firmware   *firmware;
+
         /* LLDP params */
         struct bnx2x_config_lldp_params         lldp_config_params;
 
@@ -1230,13 +1384,30 @@ struct bnx2x {
         bool dcbx_mode_uset;
 
         struct bnx2x_config_dcbx_params         dcbx_config_params;
-
         struct bnx2x_dcbx_port_params           dcbx_port_params;
         int                                     dcb_version;
 
-        /* DCBX Negotiation results */
+        /* CAM credit pools */
+        struct bnx2x_credit_pool_obj            macs_pool;
+
+        /* RX_MODE object */
+        struct bnx2x_rx_mode_obj                rx_mode_obj;
+
+        /* MCAST object */
+        struct bnx2x_mcast_obj                  mcast_obj;
+
+        /* RSS configuration object */
+        struct bnx2x_rss_config_obj             rss_conf_obj;
+
+        /* Function State controlling object */
+        struct bnx2x_func_sp_obj                func_obj;
+
+        unsigned long                           sp_state;
+
+        /* DCBX Negotation results */
         struct dcbx_features                    dcbx_local_feat;
         u32                                     dcbx_error;
+
 #ifdef BCM_DCBNL
         struct dcbx_features                    dcbx_remote_feat;
         u32                                     dcbx_remote_flags;
@@ -1244,42 +1415,11 @@ struct bnx2x {
         u32                                     pending_max;
 };
 
-/**
- *      Init queue/func interface
- */
-/* queue init flags */
-#define QUEUE_FLG_TPA           0x0001
-#define QUEUE_FLG_CACHE_ALIGN   0x0002
-#define QUEUE_FLG_STATS         0x0004
-#define QUEUE_FLG_OV            0x0008
-#define QUEUE_FLG_VLAN          0x0010
-#define QUEUE_FLG_COS           0x0020
-#define QUEUE_FLG_HC            0x0040
-#define QUEUE_FLG_DHC           0x0080
-#define QUEUE_FLG_OOO           0x0100
-
-#define QUEUE_DROP_IP_CS_ERR    TSTORM_ETH_CLIENT_CONFIG_DROP_IP_CS_ERR
-#define QUEUE_DROP_TCP_CS_ERR   TSTORM_ETH_CLIENT_CONFIG_DROP_TCP_CS_ERR
-#define QUEUE_DROP_TTL0         TSTORM_ETH_CLIENT_CONFIG_DROP_TTL0
-#define QUEUE_DROP_UDP_CS_ERR   TSTORM_ETH_CLIENT_CONFIG_DROP_UDP_CS_ERR
-
-
-
-/* rss capabilities */
-#define RSS_IPV4_CAP            0x0001
-#define RSS_IPV4_TCP_CAP        0x0002
-#define RSS_IPV6_CAP            0x0004
-#define RSS_IPV6_TCP_CAP        0x0008
-
+/* Tx queues may be less or equal to Rx queues */
+extern int num_queues;
 #define BNX2X_NUM_QUEUES(bp)    (bp->num_queues)
 #define BNX2X_NUM_ETH_QUEUES(bp) (BNX2X_NUM_QUEUES(bp) - NONE_ETH_CONTEXT_USE)
 
-/* ethtool statistics are displayed for all regular ethernet queues and the
- * fcoe L2 queue if not disabled
- */
-#define BNX2X_NUM_STAT_QUEUES(bp) (NO_FCOE(bp) ? BNX2X_NUM_ETH_QUEUES(bp) : \
-                           (BNX2X_NUM_ETH_QUEUES(bp) + FCOE_CONTEXT_USE))
-
 #define is_multi(bp)            (BNX2X_NUM_QUEUES(bp) > 1)
 
 #define BNX2X_MAX_QUEUES(bp)    (bp->igu_sb_cnt - CNIC_CONTEXT_USE)
@@ -1297,107 +1437,15 @@ struct bnx2x {
         TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_TCP_CAPABILITY
 
 /* func init flags */
-#define FUNC_FLG_STATS          0x0001
-#define FUNC_FLG_TPA            0x0002
-#define FUNC_FLG_SPQ            0x0004
-#define FUNC_FLG_LEADING        0x0008  /* PF only */
-
-struct rxq_pause_params {
-        u16             bd_th_lo;
-        u16             bd_th_hi;
-        u16             rcq_th_lo;
-        u16             rcq_th_hi;
-        u16             sge_th_lo; /* valid iff QUEUE_FLG_TPA */
-        u16             sge_th_hi; /* valid iff QUEUE_FLG_TPA */
-        u16             pri_map;
-};
-
-struct bnx2x_rxq_init_params {
-        /* cxt*/
-        struct eth_context *cxt;
-
-        /* dma */
-        dma_addr_t      dscr_map;
-        dma_addr_t      sge_map;
-        dma_addr_t      rcq_map;
-        dma_addr_t      rcq_np_map;
-
-        u16             flags;
-        u16             drop_flags;
-        u16             mtu;
-        u16             buf_sz;
-        u16             fw_sb_id;
-        u16             cl_id;
-        u16             spcl_id;
-        u16             cl_qzone_id;
-
-        /* valid iff QUEUE_FLG_STATS */
-        u16             stat_id;
-
-        /* valid iff QUEUE_FLG_TPA */
-        u16             tpa_agg_sz;
-        u16             sge_buf_sz;
-        u16             max_sges_pkt;
-
-        /* valid iff QUEUE_FLG_CACHE_ALIGN */
-        u8              cache_line_log;
-
-        u8              sb_cq_index;
-        u32             cid;
-
-        /* desired interrupts per sec. valid iff QUEUE_FLG_HC */
-        u32             hc_rate;
-};
-
-struct bnx2x_txq_init_params {
-        /* cxt*/
-        struct eth_context *cxt;
+#define FUNC_FLG_RSS            0x0001
+#define FUNC_FLG_STATS          0x0002
+/* removed  FUNC_FLG_UNMATCHED  0x0004 */
+#define FUNC_FLG_TPA            0x0008
+#define FUNC_FLG_SPQ            0x0010
+#define FUNC_FLG_LEADING        0x0020  /* PF only */
 
-        /* dma */
-        dma_addr_t      dscr_map;
-
-        u16             flags;
-        u16             fw_sb_id;
-        u8              sb_cq_index;
-        u8              cos;            /* valid iff QUEUE_FLG_COS */
-        u16             stat_id;        /* valid iff QUEUE_FLG_STATS */
-        u16             traffic_type;
-        u32             cid;
-        u16             hc_rate;        /* desired interrupts per sec.*/
-                                        /* valid iff QUEUE_FLG_HC */
-
-};
-
-struct bnx2x_client_ramrod_params {
-        int *pstate;
-        int state;
-        u16 index;
-        u16 cl_id;
-        u32 cid;
-        u8 poll;
-#define CLIENT_IS_FCOE                  0x01
-#define CLIENT_IS_LEADING_RSS           0x02
-        u8 flags;
-};
-
-struct bnx2x_client_init_params {
-        struct rxq_pause_params pause;
-        struct bnx2x_rxq_init_params rxq_params;
-        struct bnx2x_txq_init_params txq_params;
-        struct bnx2x_client_ramrod_params ramrod_params;
-};
-
-struct bnx2x_rss_params {
-        int     mode;
-        u16     cap;
-        u16     result_mask;
-};
 
 struct bnx2x_func_init_params {
-
-        /* rss */
-        struct bnx2x_rss_params *rss;   /* valid iff FUNC_FLG_RSS */
-
         /* dma */
         dma_addr_t      fw_stat_map;    /* valid iff FUNC_FLG_STATS */
         dma_addr_t      spq_map;        /* valid iff FUNC_FLG_SPQ */
@@ -1409,17 +1457,10 @@ struct bnx2x_func_init_params {
 };
 
 #define for_each_eth_queue(bp, var) \
-                        for (var = 0; var < BNX2X_NUM_ETH_QUEUES(bp); var++)
+        for (var = 0; var < BNX2X_NUM_ETH_QUEUES(bp); var++)
 
 #define for_each_nondefault_eth_queue(bp, var) \
-                        for (var = 1; var < BNX2X_NUM_ETH_QUEUES(bp); var++)
-
-#define for_each_napi_queue(bp, var) \
-        for (var = 0; \
-                var < BNX2X_NUM_ETH_QUEUES(bp) + FCOE_CONTEXT_USE; var++) \
-                if (skip_queue(bp, var))        \
-                        continue;               \
-                else
+        for (var = 1; var < BNX2X_NUM_ETH_QUEUES(bp); var++)
 
 #define for_each_queue(bp, var) \
         for (var = 0; var < BNX2X_NUM_QUEUES(bp); var++) \
@@ -1457,11 +1498,66 @@ struct bnx2x_func_init_params {
 
 #define skip_queue(bp, idx)     (NO_FCOE(bp) && IS_FCOE_IDX(idx))
 
-#define WAIT_RAMROD_POLL        0x01
-#define WAIT_RAMROD_COMMON      0x02
 
+
+
+/**
+ * bnx2x_set_mac_one - configure a single MAC address
+ *
+ * @bp:                 driver handle
+ * @mac:                MAC to configure
+ * @obj:                MAC object handle
+ * @set:                if 'true' add a new MAC, otherwise - delete
+ * @mac_type:           the type of the MAC to configure (e.g. ETH, UC list)
+ * @ramrod_flags:       RAMROD_XXX flags (e.g. RAMROD_CONT, RAMROD_COMP_WAIT)
+ *
+ * Configures one MAC according to provided parameters or continues the
+ * execution of previously scheduled commands if RAMROD_CONT is set in
+ * ramrod_flags.
+ *
+ * Returns zero if operation has successfully completed, a positive value if the
+ * operation has been successfully scheduled and a negative - if a requested
+ * operations has failed.
+ */
+int bnx2x_set_mac_one(struct bnx2x *bp, u8 *mac,
+                      struct bnx2x_vlan_mac_obj *obj, bool set,
+                      int mac_type, unsigned long *ramrod_flags);
+/**
+ * Deletes all MACs configured for the specific MAC object.
+ *
+ * @param bp Function driver instance
+ * @param mac_obj MAC object to cleanup
+ *
+ * @return zero if all MACs were cleaned
+ */
+
+/**
+ * bnx2x_del_all_macs - delete all MACs configured for the specific MAC object
+ *
+ * @bp:                 driver handle
+ * @mac_obj:            MAC object handle
+ * @mac_type:           type of the MACs to clear (BNX2X_XXX_MAC)
+ * @wait_for_comp:      if 'true' block until completion
+ *
+ * Deletes all MACs of the specific type (e.g. ETH, UC list).
+ *
+ * Returns zero if operation has successfully completed, a positive value if the
+ * operation has been successfully scheduled and a negative - if a requested
+ * operations has failed.
+ */
+int bnx2x_del_all_macs(struct bnx2x *bp,
+                       struct bnx2x_vlan_mac_obj *mac_obj,
+                       int mac_type, bool wait_for_comp);
+
+/* Init Function API  */
+void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p);
+int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, u8 port);
+int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port);
+int bnx2x_set_mult_gpio(struct bnx2x *bp, u8 pins, u32 mode);
+int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, u32 mode, u8 port);
 void bnx2x_read_mf_cfg(struct bnx2x *bp);
 
+
 /* dmae */
 void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32);
 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr, u32 dst_addr,
@@ -1472,21 +1568,10 @@ u32 bnx2x_dmae_opcode_clr_src_reset(u32 opcode);
 u32 bnx2x_dmae_opcode(struct bnx2x *bp, u8 src_type, u8 dst_type,
                       bool with_comp, u8 comp_type);
 
-int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, u8 port);
-int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port);
-int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, u32 mode, u8 port);
-u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param);
 
 void bnx2x_calc_fc_adv(struct bnx2x *bp);
 int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
-                  u32 data_hi, u32 data_lo, int common);
-
-/* Clears multicast and unicast list configuration in the chip. */
-void bnx2x_invalidate_uc_list(struct bnx2x *bp);
-
-int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
-                             int *state_p, int flags);
-
+                  u32 data_hi, u32 data_lo, int cmd_type);
 void bnx2x_update_coalesce(struct bnx2x *bp);
 int bnx2x_get_cur_phy_idx(struct bnx2x *bp);
 
@@ -1644,7 +1729,8 @@ static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
 
 /* must be used on a CID before placing it on a HW ring */
 #define HW_CID(bp, x)                   ((BP_PORT(bp) << 23) | \
-                                         (BP_E1HVN(bp) << 17) | (x))
+                                         (BP_E1HVN(bp) << BNX2X_SWCID_SHIFT) | \
+                                         (x))
 
 #define SP_DESC_CNT             (BCM_PAGE_SIZE / sizeof(struct eth_spe))
 #define MAX_SP_DESC_CNT                 (SP_DESC_CNT - 1)
@@ -1771,6 +1857,30 @@ static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
                   TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT))
 #define MULTI_MASK                      0x7f
 
+
+#define DEF_USB_FUNC_OFF        offsetof(struct cstorm_def_status_block_u, func)
+#define DEF_CSB_FUNC_OFF        offsetof(struct cstorm_def_status_block_c, func)
+#define DEF_XSB_FUNC_OFF        offsetof(struct xstorm_def_status_block, func)
+#define DEF_TSB_FUNC_OFF        offsetof(struct tstorm_def_status_block, func)
+
+#define DEF_USB_IGU_INDEX_OFF \
+                        offsetof(struct cstorm_def_status_block_u, igu_index)
+#define DEF_CSB_IGU_INDEX_OFF \
+                        offsetof(struct cstorm_def_status_block_c, igu_index)
+#define DEF_XSB_IGU_INDEX_OFF \
+                        offsetof(struct xstorm_def_status_block, igu_index)
+#define DEF_TSB_IGU_INDEX_OFF \
+                        offsetof(struct tstorm_def_status_block, igu_index)
+
+#define DEF_USB_SEGMENT_OFF \
+                        offsetof(struct cstorm_def_status_block_u, segment)
+#define DEF_CSB_SEGMENT_OFF \
+                        offsetof(struct cstorm_def_status_block_c, segment)
+#define DEF_XSB_SEGMENT_OFF \
+                        offsetof(struct xstorm_def_status_block, segment)
+#define DEF_TSB_SEGMENT_OFF \
+                        offsetof(struct tstorm_def_status_block, segment)
+
 #define BNX2X_SP_DSB_INDEX \
                 (&bp->def_status_blk->sp_sb.\
                                         index_values[HC_SP_INDEX_ETH_DEF_CONS])
@@ -1782,7 +1892,7 @@ static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
         } while (0)
 
 #define GET_FLAG(value, mask) \
-        (((value) &= (mask)) >> (mask##_SHIFT))
+        (((value) & (mask)) >> (mask##_SHIFT))
 
 #define GET_FIELD(value, fname) \
         (((value) & (fname##_MASK)) >> (fname##_SHIFT))
@@ -1817,14 +1927,12 @@ static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
 #define HC_SEG_ACCESS_ATTN              4
 #define HC_SEG_ACCESS_NORM              0   /*Driver decision 0-1*/
 
-#ifdef BNX2X_MAIN
-#define BNX2X_EXTERN
-#else
-#define BNX2X_EXTERN extern
-#endif
-
-BNX2X_EXTERN int load_count[2][3]; /* per path: 0-common, 1-port0, 2-port1 */
-
-extern void bnx2x_set_ethtool_ops(struct net_device *netdev);
+static const u32 dmae_reg_go_c[] = {
+        DMAE_REG_GO_C0, DMAE_REG_GO_C1, DMAE_REG_GO_C2, DMAE_REG_GO_C3,
+        DMAE_REG_GO_C4, DMAE_REG_GO_C5, DMAE_REG_GO_C6, DMAE_REG_GO_C7,
+        DMAE_REG_GO_C8, DMAE_REG_GO_C9, DMAE_REG_GO_C10, DMAE_REG_GO_C11,
+        DMAE_REG_GO_C12, DMAE_REG_GO_C13, DMAE_REG_GO_C14, DMAE_REG_GO_C15
+};
 
+void bnx2x_set_ethtool_ops(struct net_device *netdev);
 #endif /* bnx2x.h */
diff --git a/drivers/net/bnx2x/bnx2x_cmn.c b/drivers/net/bnx2x/bnx2x_cmn.c
index c72e1df04728..ebd8b1cdd58c 100644
--- a/drivers/net/bnx2x/bnx2x_cmn.c
+++ b/drivers/net/bnx2x/bnx2x_cmn.c
@@ -27,7 +27,7 @@
 #include "bnx2x_init.h"
 #include "bnx2x_sp.h"
 
-static int bnx2x_setup_irqs(struct bnx2x *bp);
+
 
 /**
  * bnx2x_bz_fp - zero content of the fastpath structure.
@@ -72,6 +72,8 @@ static inline void bnx2x_move_fp(struct bnx2x *bp, int from, int to)
         to_fp->napi = orig_napi;
 }
 
+int load_count[2][3] = { {0} }; /* per-path: 0-common, 1-port0, 2-port1 */
+
 /* free skb in the packet ring at pos idx
  * return idx of last bd freed
  */
@@ -88,8 +90,8 @@ static u16 bnx2x_free_tx_pkt(struct bnx2x *bp, struct bnx2x_fastpath *fp,
         /* prefetch skb end pointer to speedup dev_kfree_skb() */
         prefetch(&skb->end);
 
-        DP(BNX2X_MSG_OFF, "pkt_idx %d  buff @(%p)->skb %p\n",
-           idx, tx_buf, skb);
+        DP(BNX2X_MSG_FP, "fp[%d]: pkt_idx %d  buff @(%p)->skb %p\n",
+           fp->index, idx, tx_buf, skb);
 
         /* unmap first bd */
         DP(BNX2X_MSG_OFF, "free bd_idx %d\n", bd_idx);
@@ -97,6 +99,7 @@ static u16 bnx2x_free_tx_pkt(struct bnx2x *bp, struct bnx2x_fastpath *fp,
         dma_unmap_single(&bp->pdev->dev, BD_UNMAP_ADDR(tx_start_bd),
                          BD_UNMAP_LEN(tx_start_bd), DMA_TO_DEVICE);
 
+
         nbd = le16_to_cpu(tx_start_bd->nbd) - 1;
 #ifdef BNX2X_STOP_ON_ERROR
         if ((nbd - 1) > (MAX_SKB_FRAGS + 2)) {
@@ -175,6 +178,9 @@ int bnx2x_tx_int(struct bnx2x_fastpath *fp)
          * memory barrier, there is a small possibility that
          * start_xmit() will miss it and cause the queue to be stopped
          * forever.
+         * On the other hand we need an rmb() here to ensure the proper
+         * ordering of bit testing in the following
+         * netif_tx_queue_stopped(txq) call.
          */
         smp_mb();
 
@@ -226,7 +232,7 @@ static void bnx2x_update_sge_prod(struct bnx2x_fastpath *fp,
 
         /* First mark all used pages */
         for (i = 0; i < sge_len; i++)
-                SGE_MASK_CLEAR_BIT(fp,
+                BIT_VEC64_CLEAR_BIT(fp->sge_mask,
                         RX_SGE(le16_to_cpu(fp_cqe->sgl_or_raw_data.sgl[i])));
 
         DP(NETIF_MSG_RX_STATUS, "fp_cqe->sgl[%d] = %d\n",
@@ -238,8 +244,8 @@ static void bnx2x_update_sge_prod(struct bnx2x_fastpath *fp,
                 le16_to_cpu(fp_cqe->sgl_or_raw_data.sgl[sge_len - 1]));
 
         last_max = RX_SGE(fp->last_max_sge);
-        last_elem = last_max >> RX_SGE_MASK_ELEM_SHIFT;
-        first_elem = RX_SGE(fp->rx_sge_prod) >> RX_SGE_MASK_ELEM_SHIFT;
+        last_elem = last_max >> BIT_VEC64_ELEM_SHIFT;
+        first_elem = RX_SGE(fp->rx_sge_prod) >> BIT_VEC64_ELEM_SHIFT;
 
         /* If ring is not full */
         if (last_elem + 1 != first_elem)
@@ -250,8 +256,8 @@ static void bnx2x_update_sge_prod(struct bnx2x_fastpath *fp,
                 if (likely(fp->sge_mask[i]))
                         break;
 
-                fp->sge_mask[i] = RX_SGE_MASK_ELEM_ONE_MASK;
-                delta += RX_SGE_MASK_ELEM_SZ;
+                fp->sge_mask[i] = BIT_VEC64_ELEM_ONE_MASK;
+                delta += BIT_VEC64_ELEM_SZ;
         }
 
         if (delta > 0) {
@@ -266,33 +272,56 @@ static void bnx2x_update_sge_prod(struct bnx2x_fastpath *fp,
 }
 
 static void bnx2x_tpa_start(struct bnx2x_fastpath *fp, u16 queue,
-                            struct sk_buff *skb, u16 cons, u16 prod)
+                            struct sk_buff *skb, u16 cons, u16 prod,
+                            struct eth_fast_path_rx_cqe *cqe)
 {
         struct bnx2x *bp = fp->bp;
         struct sw_rx_bd *cons_rx_buf = &fp->rx_buf_ring[cons];
         struct sw_rx_bd *prod_rx_buf = &fp->rx_buf_ring[prod];
         struct eth_rx_bd *prod_bd = &fp->rx_desc_ring[prod];
         dma_addr_t mapping;
+        struct bnx2x_agg_info *tpa_info = &fp->tpa_info[queue];
+        struct sw_rx_bd *first_buf = &tpa_info->first_buf;
 
-        /* move empty skb from pool to prod and map it */
-        prod_rx_buf->skb = fp->tpa_pool[queue].skb;
-        mapping = dma_map_single(&bp->pdev->dev, fp->tpa_pool[queue].skb->data,
-                                 fp->rx_buf_size, DMA_FROM_DEVICE);
-        dma_unmap_addr_set(prod_rx_buf, mapping, mapping);
-
-        /* move partial skb from cons to pool (don't unmap yet) */
-        fp->tpa_pool[queue] = *cons_rx_buf;
-
-        /* mark bin state as start - print error if current state != stop */
-        if (fp->tpa_state[queue] != BNX2X_TPA_STOP)
+        /* print error if current state != stop */
+        if (tpa_info->tpa_state != BNX2X_TPA_STOP)
                 BNX2X_ERR("start of bin not in stop [%d]\n", queue);
 
-        fp->tpa_state[queue] = BNX2X_TPA_START;
+        /* Try to map an empty skb from the aggregation info  */
+        mapping = dma_map_single(&bp->pdev->dev,
+                                 first_buf->skb->data,
+                                 fp->rx_buf_size, DMA_FROM_DEVICE);
+        /*
+         *  ...if it fails - move the skb from the consumer to the producer
+         *  and set the current aggregation state as ERROR to drop it
+         *  when TPA_STOP arrives.
+         */
+
+        if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
+                /* Move the BD from the consumer to the producer */
+                bnx2x_reuse_rx_skb(fp, cons, prod);
+                tpa_info->tpa_state = BNX2X_TPA_ERROR;
+                return;
+        }
 
+        /* move empty skb from pool to prod */
+        prod_rx_buf->skb = first_buf->skb;
+        dma_unmap_addr_set(prod_rx_buf, mapping, mapping);
         /* point prod_bd to new skb */
         prod_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
         prod_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
 
+        /* move partial skb from cons to pool (don't unmap yet) */
+        *first_buf = *cons_rx_buf;
+
+        /* mark bin state as START */
+        tpa_info->parsing_flags =
+                le16_to_cpu(cqe->pars_flags.flags);
+        tpa_info->vlan_tag = le16_to_cpu(cqe->vlan_tag);
+        tpa_info->tpa_state = BNX2X_TPA_START;
+        tpa_info->len_on_bd = le16_to_cpu(cqe->len_on_bd);
+        tpa_info->placement_offset = cqe->placement_offset;
+
 #ifdef BNX2X_STOP_ON_ERROR
         fp->tpa_queue_used |= (1 << queue);
 #ifdef _ASM_GENERIC_INT_L64_H
@@ -323,10 +352,17 @@ static void bnx2x_tpa_start(struct bnx2x_fastpath *fp, u16 queue,
 static inline u16 bnx2x_set_lro_mss(struct bnx2x *bp, u16 parsing_flags,
                                     u16 len_on_bd)
 {
-        /* TPA arrgregation won't have an IP options and TCP options
-         * other than timestamp.
+        /*
+         * TPA arrgregation won't have either IP options or TCP options
+         * other than timestamp or IPv6 extension headers.
          */
-        u16 hdrs_len = ETH_HLEN + sizeof(struct iphdr) + sizeof(struct tcphdr);
+        u16 hdrs_len = ETH_HLEN + sizeof(struct tcphdr);
+
+        if (GET_FLAG(parsing_flags, PARSING_FLAGS_OVER_ETHERNET_PROTOCOL) ==
+            PRS_FLAG_OVERETH_IPV6)
+                hdrs_len += sizeof(struct ipv6hdr);
+        else /* IPv4 */
+                hdrs_len += sizeof(struct iphdr);
 
 
         /* Check if there was a TCP timestamp, if there is it's will
@@ -341,30 +377,30 @@ static inline u16 bnx2x_set_lro_mss(struct bnx2x *bp, u16 parsing_flags,
 }
 
 static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
-                               struct sk_buff *skb,
-                               struct eth_fast_path_rx_cqe *fp_cqe,
-                               u16 cqe_idx, u16 parsing_flags)
+                               u16 queue, struct sk_buff *skb,
+                               struct eth_end_agg_rx_cqe *cqe,
+                               u16 cqe_idx)
 {
         struct sw_rx_page *rx_pg, old_rx_pg;
-        u16 len_on_bd = le16_to_cpu(fp_cqe->len_on_bd);
         u32 i, frag_len, frag_size, pages;
         int err;
         int j;
+        struct bnx2x_agg_info *tpa_info = &fp->tpa_info[queue];
+        u16 len_on_bd = tpa_info->len_on_bd;
 
-        frag_size = le16_to_cpu(fp_cqe->pkt_len) - len_on_bd;
+        frag_size = le16_to_cpu(cqe->pkt_len) - len_on_bd;
         pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
 
         /* This is needed in order to enable forwarding support */
         if (frag_size)
-                skb_shinfo(skb)->gso_size = bnx2x_set_lro_mss(bp, parsing_flags,
-                                                              len_on_bd);
+                skb_shinfo(skb)->gso_size = bnx2x_set_lro_mss(bp,
+                                        tpa_info->parsing_flags, len_on_bd);
 
 #ifdef BNX2X_STOP_ON_ERROR
         if (pages > min_t(u32, 8, MAX_SKB_FRAGS)*SGE_PAGE_SIZE*PAGES_PER_SGE) {
                 BNX2X_ERR("SGL length is too long: %d. CQE index is %d\n",
                           pages, cqe_idx);
-                BNX2X_ERR("fp_cqe->pkt_len = %d  fp_cqe->len_on_bd = %d\n",
-                          fp_cqe->pkt_len, len_on_bd);
+                BNX2X_ERR("cqe->pkt_len = %d\n", cqe->pkt_len);
                 bnx2x_panic();
                 return -EINVAL;
         }
@@ -372,8 +408,7 @@ static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
 
         /* Run through the SGL and compose the fragmented skb */
         for (i = 0, j = 0; i < pages; i += PAGES_PER_SGE, j++) {
-                u16 sge_idx =
-                        RX_SGE(le16_to_cpu(fp_cqe->sgl_or_raw_data.sgl[j]));
+                u16 sge_idx = RX_SGE(le16_to_cpu(cqe->sgl_or_raw_data.sgl[j]));
 
                 /* FW gives the indices of the SGE as if the ring is an array
                    (meaning that "next" element will consume 2 indices) */
@@ -408,13 +443,28 @@ static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
 }
 
 static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
-                           u16 queue, int pad, int len, union eth_rx_cqe *cqe,
+                           u16 queue, struct eth_end_agg_rx_cqe *cqe,
                            u16 cqe_idx)
 {
-        struct sw_rx_bd *rx_buf = &fp->tpa_pool[queue];
+        struct bnx2x_agg_info *tpa_info = &fp->tpa_info[queue];
+        struct sw_rx_bd *rx_buf = &tpa_info->first_buf;
+        u8 pad = tpa_info->placement_offset;
+        u16 len = tpa_info->len_on_bd;
         struct sk_buff *skb = rx_buf->skb;
         /* alloc new skb */
-        struct sk_buff *new_skb = netdev_alloc_skb(bp->dev, fp->rx_buf_size);
+        struct sk_buff *new_skb;
+        u8 old_tpa_state = tpa_info->tpa_state;
+
+        tpa_info->tpa_state = BNX2X_TPA_STOP;
+
+        /* If we there was an error during the handling of the TPA_START -
+         * drop this aggregation.
+         */
+        if (old_tpa_state == BNX2X_TPA_ERROR)
+                goto drop;
+
+        /* Try to allocate the new skb */
+        new_skb = netdev_alloc_skb(bp->dev, fp->rx_buf_size);
 
         /* Unmap skb in the pool anyway, as we are going to change
            pool entry status to BNX2X_TPA_STOP even if new skb allocation
@@ -423,11 +473,6 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                          fp->rx_buf_size, DMA_FROM_DEVICE);
 
         if (likely(new_skb)) {
-                /* fix ip xsum and give it to the stack */
-                /* (no need to map the new skb) */
-                u16 parsing_flags =
-                        le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags);
-
                 prefetch(skb);
                 prefetch(((char *)(skb)) + L1_CACHE_BYTES);
 
@@ -447,21 +492,9 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                 skb->protocol = eth_type_trans(skb, bp->dev);
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 
-                {
-                        struct iphdr *iph;
-
-                        iph = (struct iphdr *)skb->data;
-                        iph->check = 0;
-                        iph->check = ip_fast_csum((u8 *)iph, iph->ihl);
-                }
-
-                if (!bnx2x_fill_frag_skb(bp, fp, skb,
-                                         &cqe->fast_path_cqe, cqe_idx,
-                                         parsing_flags)) {
-                        if (parsing_flags & PARSING_FLAGS_VLAN)
-                                __vlan_hwaccel_put_tag(skb,
-                                                 le16_to_cpu(cqe->fast_path_cqe.
-                                                             vlan_tag));
+                if (!bnx2x_fill_frag_skb(bp, fp, queue, skb, cqe, cqe_idx)) {
+                        if (tpa_info->parsing_flags & PARSING_FLAGS_VLAN)
+                                __vlan_hwaccel_put_tag(skb, tpa_info->vlan_tag);
                         napi_gro_receive(&fp->napi, skb);
                 } else {
                         DP(NETIF_MSG_RX_STATUS, "Failed to allocate new pages"
@@ -471,16 +504,16 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
 
 
                 /* put new skb in bin */
-                fp->tpa_pool[queue].skb = new_skb;
+                rx_buf->skb = new_skb;
 
-        } else {
-                /* else drop the packet and keep the buffer in the bin */
-                DP(NETIF_MSG_RX_STATUS,
-                   "Failed to allocate new skb - dropping packet!\n");
-                fp->eth_q_stats.rx_skb_alloc_failed++;
+                return;
         }
 
-        fp->tpa_state[queue] = BNX2X_TPA_STOP;
+drop:
+        /* drop the packet and keep the buffer in the bin */
+        DP(NETIF_MSG_RX_STATUS,
+           "Failed to allocate or map a new skb - dropping packet!\n");
+        fp->eth_q_stats.rx_skb_alloc_failed++;
 }
 
 /* Set Toeplitz hash value in the skb using the value from the
@@ -534,9 +567,16 @@ int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
                 struct sw_rx_bd *rx_buf = NULL;
                 struct sk_buff *skb;
                 union eth_rx_cqe *cqe;
+                struct eth_fast_path_rx_cqe *cqe_fp;
                 u8 cqe_fp_flags;
+                enum eth_rx_cqe_type cqe_fp_type;
                 u16 len, pad;
 
+#ifdef BNX2X_STOP_ON_ERROR
+                if (unlikely(bp->panic))
+                        return 0;
+#endif
+
                 comp_ring_cons = RCQ_BD(sw_comp_cons);
                 bd_prod = RX_BD(bd_prod);
                 bd_cons = RX_BD(bd_cons);
@@ -549,17 +589,18 @@ int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
                                   PAGE_SIZE + 1));
 
                 cqe = &fp->rx_comp_ring[comp_ring_cons];
-                cqe_fp_flags = cqe->fast_path_cqe.type_error_flags;
+                cqe_fp = &cqe->fast_path_cqe;
+                cqe_fp_flags = cqe_fp->type_error_flags;
+                cqe_fp_type = cqe_fp_flags & ETH_FAST_PATH_RX_CQE_TYPE;
 
                 DP(NETIF_MSG_RX_STATUS, "CQE type %x  err %x  status %x"
                    "  queue %x  vlan %x  len %u\n", CQE_TYPE(cqe_fp_flags),
-                   cqe_fp_flags, cqe->fast_path_cqe.status_flags,
-                   le32_to_cpu(cqe->fast_path_cqe.rss_hash_result),
-                   le16_to_cpu(cqe->fast_path_cqe.vlan_tag),
-                   le16_to_cpu(cqe->fast_path_cqe.pkt_len));
+                   cqe_fp_flags, cqe_fp->status_flags,
+                   le32_to_cpu(cqe_fp->rss_hash_result),
+                   le16_to_cpu(cqe_fp->vlan_tag), le16_to_cpu(cqe_fp->pkt_len));
 
                 /* is this a slowpath msg? */
-                if (unlikely(CQE_TYPE(cqe_fp_flags))) {
+                if (unlikely(CQE_TYPE_SLOW(cqe_fp_type))) {
                         bnx2x_sp_event(fp, cqe);
                         goto next_cqe;
 
@@ -568,61 +609,59 @@ int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
                         rx_buf = &fp->rx_buf_ring[bd_cons];
                         skb = rx_buf->skb;
                         prefetch(skb);
-                        len = le16_to_cpu(cqe->fast_path_cqe.pkt_len);
-                        pad = cqe->fast_path_cqe.placement_offset;
 
-                        /* - If CQE is marked both TPA_START and TPA_END it is
-                         *   a non-TPA CQE.
-                         * - FP CQE will always have either TPA_START or/and
-                         *   TPA_STOP flags set.
-                         */
-                        if ((!fp->disable_tpa) &&
-                            (TPA_TYPE(cqe_fp_flags) !=
-                                        (TPA_TYPE_START | TPA_TYPE_END))) {
-                                u16 queue = cqe->fast_path_cqe.queue_index;
+                        if (!CQE_TYPE_FAST(cqe_fp_type)) {
+#ifdef BNX2X_STOP_ON_ERROR
+                                /* sanity check */
+                                if (fp->disable_tpa &&
+                                    (CQE_TYPE_START(cqe_fp_type) ||
+                                     CQE_TYPE_STOP(cqe_fp_type)))
+                                        BNX2X_ERR("START/STOP packet while "
+                                                  "disable_tpa type %x\n",
+                                                  CQE_TYPE(cqe_fp_type));
+#endif
 
-                                if (TPA_TYPE(cqe_fp_flags) == TPA_TYPE_START) {
+                                if (CQE_TYPE_START(cqe_fp_type)) {
+                                        u16 queue = cqe_fp->queue_index;
                                         DP(NETIF_MSG_RX_STATUS,
                                            "calling tpa_start on queue %d\n",
                                            queue);
 
                                         bnx2x_tpa_start(fp, queue, skb,
-                                                        bd_cons, bd_prod);
+                                                        bd_cons, bd_prod,
+                                                        cqe_fp);
 
-                                        /* Set Toeplitz hash for an LRO skb */
+                                        /* Set Toeplitz hash for LRO skb */
                                         bnx2x_set_skb_rxhash(bp, cqe, skb);
 
                                         goto next_rx;
-                                } else { /* TPA_STOP */
+
+                                } else {
+                                        u16 queue =
+                                                cqe->end_agg_cqe.queue_index;
                                         DP(NETIF_MSG_RX_STATUS,
                                            "calling tpa_stop on queue %d\n",
                                            queue);
 
-                                        if (!BNX2X_RX_SUM_FIX(cqe))
-                                                BNX2X_ERR("STOP on none TCP "
-                                                          "data\n");
-
-                                        /* This is a size of the linear data
-                                           on this skb */
-                                        len = le16_to_cpu(cqe->fast_path_cqe.
-                                                                len_on_bd);
-                                        bnx2x_tpa_stop(bp, fp, queue, pad,
-                                                    len, cqe, comp_ring_cons);
+                                        bnx2x_tpa_stop(bp, fp, queue,
+                                                       &cqe->end_agg_cqe,
+                                                       comp_ring_cons);
 #ifdef BNX2X_STOP_ON_ERROR
                                         if (bp->panic)
                                                 return 0;
 #endif
 
-                                        bnx2x_update_sge_prod(fp,
-                                                        &cqe->fast_path_cqe);
+                                        bnx2x_update_sge_prod(fp, cqe_fp);
                                         goto next_cqe;
                                 }
                         }
-
+                        /* non TPA */
+                        len = le16_to_cpu(cqe_fp->pkt_len);
+                        pad = cqe_fp->placement_offset;
                         dma_sync_single_for_device(&bp->pdev->dev,
                                         dma_unmap_addr(rx_buf, mapping),
-                                                   pad + RX_COPY_THRESH,
-                                                   DMA_FROM_DEVICE);
+                                                       pad + RX_COPY_THRESH,
+                                                       DMA_FROM_DEVICE);
                         prefetch(((char *)(skb)) + L1_CACHE_BYTES);
 
                         /* is this an error packet? */
@@ -641,8 +680,7 @@ int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
                             (len <= RX_COPY_THRESH)) {
                                 struct sk_buff *new_skb;
 
-                                new_skb = netdev_alloc_skb(bp->dev,
-                                                           len + pad);
+                                new_skb = netdev_alloc_skb(bp->dev, len + pad);
                                 if (new_skb == NULL) {
                                         DP(NETIF_MSG_RX_ERR,
                                            "ERROR  packet dropped "
@@ -688,6 +726,7 @@ reuse_rx:
                         skb_checksum_none_assert(skb);
 
                         if (bp->dev->features & NETIF_F_RXCSUM) {
+
                                 if (likely(BNX2X_RX_CSUM_OK(cqe)))
                                         skb->ip_summed = CHECKSUM_UNNECESSARY;
                                 else
@@ -697,10 +736,10 @@ reuse_rx:
 
                 skb_record_rx_queue(skb, fp->index);
 
-                if (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
-                     PARSING_FLAGS_VLAN)
+                if (le16_to_cpu(cqe_fp->pars_flags.flags) &
+                    PARSING_FLAGS_VLAN)
                         __vlan_hwaccel_put_tag(skb,
-                                le16_to_cpu(cqe->fast_path_cqe.vlan_tag));
+                                               le16_to_cpu(cqe_fp->vlan_tag));
                 napi_gro_receive(&fp->napi, skb);
 
 
@@ -926,7 +965,7 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
 {
         int func = BP_FUNC(bp);
         int max_agg_queues = CHIP_IS_E1(bp) ? ETH_MAX_AGGREGATION_QUEUES_E1 :
-                                              ETH_MAX_AGGREGATION_QUEUES_E1H;
+                                              ETH_MAX_AGGREGATION_QUEUES_E1H_E2;
         u16 ring_prod;
         int i, j;
 
@@ -938,11 +977,16 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
                    "mtu %d  rx_buf_size %d\n", bp->dev->mtu, fp->rx_buf_size);
 
                 if (!fp->disable_tpa) {
-                        /* Fill the per-aggregation pool */
+                        /* Fill the per-aggregtion pool */
                         for (i = 0; i < max_agg_queues; i++) {
-                                fp->tpa_pool[i].skb =
-                                   netdev_alloc_skb(bp->dev, fp->rx_buf_size);
-                                if (!fp->tpa_pool[i].skb) {
+                                struct bnx2x_agg_info *tpa_info =
+                                        &fp->tpa_info[i];
+                                struct sw_rx_bd *first_buf =
+                                        &tpa_info->first_buf;
+
+                                first_buf->skb = netdev_alloc_skb(bp->dev,
+                                                       fp->rx_buf_size);
+                                if (!first_buf->skb) {
                                         BNX2X_ERR("Failed to allocate TPA "
                                                   "skb pool for queue[%d] - "
                                                   "disabling TPA on this "
@@ -951,10 +995,8 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
                                         fp->disable_tpa = 1;
                                         break;
                                 }
-                                dma_unmap_addr_set((struct sw_rx_bd *)
-                                                        &bp->fp->tpa_pool[i],
-                                                   mapping, 0);
-                                fp->tpa_state[i] = BNX2X_TPA_STOP;
+                                dma_unmap_addr_set(first_buf, mapping, 0);
+                                tpa_info->tpa_state = BNX2X_TPA_STOP;
                         }
 
                         /* "next page" elements initialization */
@@ -970,13 +1012,13 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
                                 if (bnx2x_alloc_rx_sge(bp, fp, ring_prod) < 0) {
                                         BNX2X_ERR("was only able to allocate "
                                                   "%d rx sges\n", i);
-                                        BNX2X_ERR("disabling TPA for"
-                                                  " queue[%d]\n", j);
+                                        BNX2X_ERR("disabling TPA for "
+                                                  "queue[%d]\n", j);
                                         /* Cleanup already allocated elements */
-                                        bnx2x_free_rx_sge_range(bp,
-                                                                fp, ring_prod);
-                                        bnx2x_free_tpa_pool(bp,
-                                                            fp, max_agg_queues);
+                                        bnx2x_free_rx_sge_range(bp, fp,
+                                                                ring_prod);
+                                        bnx2x_free_tpa_pool(bp, fp,
+                                                            max_agg_queues);
                                         fp->disable_tpa = 1;
                                         ring_prod = 0;
                                         break;
@@ -1004,7 +1046,7 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
                 if (j != 0)
                         continue;
 
-                if (!CHIP_IS_E2(bp)) {
+                if (CHIP_IS_E1(bp)) {
                         REG_WR(bp, BAR_USTRORM_INTMEM +
                                USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(func),
                                U64_LO(fp->rx_comp_mapping));
@@ -1048,7 +1090,6 @@ static void bnx2x_free_rx_bds(struct bnx2x_fastpath *fp)
 
                 if (skb == NULL)
                         continue;
-
                 dma_unmap_single(&bp->pdev->dev,
                                  dma_unmap_addr(rx_buf, mapping),
                                  fp->rx_buf_size, DMA_FROM_DEVICE);
@@ -1070,7 +1111,7 @@ static void bnx2x_free_rx_skbs(struct bnx2x *bp)
                 if (!fp->disable_tpa)
                         bnx2x_free_tpa_pool(bp, fp, CHIP_IS_E1(bp) ?
                                             ETH_MAX_AGGREGATION_QUEUES_E1 :
-                                            ETH_MAX_AGGREGATION_QUEUES_E1H);
+                                            ETH_MAX_AGGREGATION_QUEUES_E1H_E2);
         }
 }
 
@@ -1234,7 +1275,6 @@ static int bnx2x_req_msix_irqs(struct bnx2x *bp)
                 }
 
                 offset++;
-                fp->state = BNX2X_FP_STATE_IRQ;
         }
 
         i = BNX2X_NUM_ETH_QUEUES(bp);
@@ -1274,25 +1314,46 @@ static int bnx2x_req_irq(struct bnx2x *bp)
 
         rc = request_irq(bp->pdev->irq, bnx2x_interrupt, flags,
                          bp->dev->name, bp->dev);
-        if (!rc)
-                bnx2x_fp(bp, 0, state) = BNX2X_FP_STATE_IRQ;
-
         return rc;
 }
 
-static void bnx2x_napi_enable(struct bnx2x *bp)
+static inline int bnx2x_setup_irqs(struct bnx2x *bp)
+{
+        int rc = 0;
+        if (bp->flags & USING_MSIX_FLAG) {
+                rc = bnx2x_req_msix_irqs(bp);
+                if (rc)
+                        return rc;
+        } else {
+                bnx2x_ack_int(bp);
+                rc = bnx2x_req_irq(bp);
+                if (rc) {
+                        BNX2X_ERR("IRQ request failed  rc %d, aborting\n", rc);
+                        return rc;
+                }
+                if (bp->flags & USING_MSI_FLAG) {
+                        bp->dev->irq = bp->pdev->irq;
+                        netdev_info(bp->dev, "using MSI  IRQ %d\n",
+                               bp->pdev->irq);
+                }
+        }
+
+        return 0;
+}
+
+static inline void bnx2x_napi_enable(struct bnx2x *bp)
 {
         int i;
 
-        for_each_napi_queue(bp, i)
+        for_each_rx_queue(bp, i)
                 napi_enable(&bnx2x_fp(bp, i, napi));
 }
 
-static void bnx2x_napi_disable(struct bnx2x *bp)
+static inline void bnx2x_napi_disable(struct bnx2x *bp)
 {
         int i;
 
-        for_each_napi_queue(bp, i)
+        for_each_rx_queue(bp, i)
                 napi_disable(&bnx2x_fp(bp, i, napi));
 }
 
@@ -1310,7 +1371,6 @@ void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw)
 {
         bnx2x_int_disable_sync(bp, disable_hw);
         bnx2x_napi_disable(bp);
-        netif_tx_disable(bp->dev);
 }
 
 u16 bnx2x_select_queue(struct net_device *dev, struct sk_buff *skb)
@@ -1361,26 +1421,6 @@ void bnx2x_set_num_queues(struct bnx2x *bp)
         bp->num_queues += NONE_ETH_CONTEXT_USE;
 }
 
-#ifdef BCM_CNIC
-static inline void bnx2x_set_fcoe_eth_macs(struct bnx2x *bp)
-{
-        if (!NO_FCOE(bp)) {
-                if (!IS_MF_SD(bp))
-                        bnx2x_set_fip_eth_mac_addr(bp, 1);
-                bnx2x_set_all_enode_macs(bp, 1);
-                bp->flags |= FCOE_MACS_SET;
-        }
-}
-#endif
-
-static void bnx2x_release_firmware(struct bnx2x *bp)
-{
-        kfree(bp->init_ops_offsets);
-        kfree(bp->init_ops);
-        kfree(bp->init_data);
-        release_firmware(bp->firmware);
-}
-
 static inline int bnx2x_set_real_num_queues(struct bnx2x *bp)
 {
         int rc, num = bp->num_queues;
@@ -1412,27 +1452,198 @@ static inline void bnx2x_set_rx_buf_size(struct bnx2x *bp)
                          */
                         fp->rx_buf_size =
                                 BNX2X_FCOE_MINI_JUMBO_MTU + ETH_OVREHEAD +
-                                BNX2X_RX_ALIGN + IP_HEADER_ALIGNMENT_PADDING;
+                                BNX2X_FW_RX_ALIGN + IP_HEADER_ALIGNMENT_PADDING;
                 else
                         fp->rx_buf_size =
-                                bp->dev->mtu + ETH_OVREHEAD + BNX2X_RX_ALIGN +
-                                IP_HEADER_ALIGNMENT_PADDING;
+                                bp->dev->mtu + ETH_OVREHEAD +
+                                BNX2X_FW_RX_ALIGN + IP_HEADER_ALIGNMENT_PADDING;
         }
 }
 
+static inline int bnx2x_init_rss_pf(struct bnx2x *bp)
+{
+        int i;
+        u8 ind_table[T_ETH_INDIRECTION_TABLE_SIZE] = {0};
+        u8 num_eth_queues = BNX2X_NUM_ETH_QUEUES(bp);
+
+        /*
+         * Prepare the inital contents fo the indirection table if RSS is
+         * enabled
+         */
+        if (bp->multi_mode != ETH_RSS_MODE_DISABLED) {
+                for (i = 0; i < sizeof(ind_table); i++)
+                        ind_table[i] =
+                                bp->fp->cl_id + (i % num_eth_queues);
+        }
+
+        /*
+         * For 57710 and 57711 SEARCHER configuration (rss_keys) is
+         * per-port, so if explicit configuration is needed , do it only
+         * for a PMF.
+         *
+         * For 57712 and newer on the other hand it's a per-function
+         * configuration.
+         */
+        return bnx2x_config_rss_pf(bp, ind_table,
+                                   bp->port.pmf || !CHIP_IS_E1x(bp));
+}
+
+int bnx2x_config_rss_pf(struct bnx2x *bp, u8 *ind_table, bool config_hash)
+{
+        struct bnx2x_config_rss_params params = {0};
+        int i;
+
+        /* Although RSS is meaningless when there is a single HW queue we
+         * still need it enabled in order to have HW Rx hash generated.
+         *
+         * if (!is_eth_multi(bp))
+         *      bp->multi_mode = ETH_RSS_MODE_DISABLED;
+         */
+
+        params.rss_obj = &bp->rss_conf_obj;
+
+        __set_bit(RAMROD_COMP_WAIT, &params.ramrod_flags);
+
+        /* RSS mode */
+        switch (bp->multi_mode) {
+        case ETH_RSS_MODE_DISABLED:
+                __set_bit(BNX2X_RSS_MODE_DISABLED, &params.rss_flags);
+                break;
+        case ETH_RSS_MODE_REGULAR:
+                __set_bit(BNX2X_RSS_MODE_REGULAR, &params.rss_flags);
+                break;
+        case ETH_RSS_MODE_VLAN_PRI:
+                __set_bit(BNX2X_RSS_MODE_VLAN_PRI, &params.rss_flags);
+                break;
+        case ETH_RSS_MODE_E1HOV_PRI:
+                __set_bit(BNX2X_RSS_MODE_E1HOV_PRI, &params.rss_flags);
+                break;
+        case ETH_RSS_MODE_IP_DSCP:
+                __set_bit(BNX2X_RSS_MODE_IP_DSCP, &params.rss_flags);
+                break;
+        default:
+                BNX2X_ERR("Unknown multi_mode: %d\n", bp->multi_mode);
+                return -EINVAL;
+        }
+
+        /* If RSS is enabled */
+        if (bp->multi_mode != ETH_RSS_MODE_DISABLED) {
+                /* RSS configuration */
+                __set_bit(BNX2X_RSS_IPV4, &params.rss_flags);
+                __set_bit(BNX2X_RSS_IPV4_TCP, &params.rss_flags);
+                __set_bit(BNX2X_RSS_IPV6, &params.rss_flags);
+                __set_bit(BNX2X_RSS_IPV6_TCP, &params.rss_flags);
+
+                /* Hash bits */
+                params.rss_result_mask = MULTI_MASK;
+
+                memcpy(params.ind_table, ind_table, sizeof(params.ind_table));
+
+                if (config_hash) {
+                        /* RSS keys */
+                        for (i = 0; i < sizeof(params.rss_key) / 4; i++)
+                                params.rss_key[i] = random32();
+
+                        __set_bit(BNX2X_RSS_SET_SRCH, &params.rss_flags);
+                }
+        }
+
+        return bnx2x_config_rss(bp, &params);
+}
+
+static inline int bnx2x_init_hw(struct bnx2x *bp, u32 load_code)
+{
+        struct bnx2x_func_state_params func_params = {0};
+
+        /* Prepare parameters for function state transitions */
+        __set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
+
+        func_params.f_obj = &bp->func_obj;
+        func_params.cmd = BNX2X_F_CMD_HW_INIT;
+
+        func_params.params.hw_init.load_phase = load_code;
+
+        return bnx2x_func_state_change(bp, &func_params);
+}
+
+/*
+ * Cleans the object that have internal lists without sending
+ * ramrods. Should be run when interrutps are disabled.
+ */
+static void bnx2x_squeeze_objects(struct bnx2x *bp)
+{
+        int rc;
+        unsigned long ramrod_flags = 0, vlan_mac_flags = 0;
+        struct bnx2x_mcast_ramrod_params rparam = {0};
+        struct bnx2x_vlan_mac_obj *mac_obj = &bp->fp->mac_obj;
+
+        /***************** Cleanup MACs' object first *************************/
+
+        /* Wait for completion of requested */
+        __set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
+        /* Perform a dry cleanup */
+        __set_bit(RAMROD_DRV_CLR_ONLY, &ramrod_flags);
+
+        /* Clean ETH primary MAC */
+        __set_bit(BNX2X_ETH_MAC, &vlan_mac_flags);
+        rc = mac_obj->delete_all(bp, &bp->fp->mac_obj, &vlan_mac_flags,
+                                 &ramrod_flags);
+        if (rc != 0)
+                BNX2X_ERR("Failed to clean ETH MACs: %d\n", rc);
+
+        /* Cleanup UC list */
+        vlan_mac_flags = 0;
+        __set_bit(BNX2X_UC_LIST_MAC, &vlan_mac_flags);
+        rc = mac_obj->delete_all(bp, mac_obj, &vlan_mac_flags,
+                                 &ramrod_flags);
+        if (rc != 0)
+                BNX2X_ERR("Failed to clean UC list MACs: %d\n", rc);
+
+        /***************** Now clean mcast object *****************************/
+        rparam.mcast_obj = &bp->mcast_obj;
+        __set_bit(RAMROD_DRV_CLR_ONLY, &rparam.ramrod_flags);
+
+        /* Add a DEL command... */
+        rc = bnx2x_config_mcast(bp, &rparam, BNX2X_MCAST_CMD_DEL);
+        if (rc < 0)
+                BNX2X_ERR("Failed to add a new DEL command to a multi-cast "
+                          "object: %d\n", rc);
+
+        /* ...and wait until all pending commands are cleared */
+        rc = bnx2x_config_mcast(bp, &rparam, BNX2X_MCAST_CMD_CONT);
+        while (rc != 0) {
+                if (rc < 0) {
+                        BNX2X_ERR("Failed to clean multi-cast object: %d\n",
+                                  rc);
+                        return;
+                }
+
+                rc = bnx2x_config_mcast(bp, &rparam, BNX2X_MCAST_CMD_CONT);
+        }
+}
+
+#ifndef BNX2X_STOP_ON_ERROR
+#define LOAD_ERROR_EXIT(bp, label) \
+        do { \
+                (bp)->state = BNX2X_STATE_ERROR; \
+                goto label; \
+        } while (0)
+#else
+#define LOAD_ERROR_EXIT(bp, label) \
+        do { \
+                (bp)->state = BNX2X_STATE_ERROR; \
+                (bp)->panic = 1; \
+                return -EBUSY; \
+        } while (0)
+#endif
+
 /* must be called with rtnl_lock */
 int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 {
+        int port = BP_PORT(bp);
         u32 load_code;
         int i, rc;
 
-        /* Set init arrays */
-        rc = bnx2x_init_firmware(bp);
-        if (rc) {
-                BNX2X_ERR("Error loading firmware\n");
-                return rc;
-        }
-
 #ifdef BNX2X_STOP_ON_ERROR
         if (unlikely(bp->panic))
                 return -EPERM;
@@ -1459,6 +1670,10 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         /* Set the receive queues buffer size */
         bnx2x_set_rx_buf_size(bp);
 
+        /*
+         * set the tpa flag for each queue. The tpa flag determines the queue
+         * minimal size so it must be set prior to queue memory allocation
+         */
         for_each_queue(bp, i)
                 bnx2x_fp(bp, i, disable_tpa) =
                                         ((bp->flags & TPA_ENABLE_FLAG) == 0);
@@ -1478,31 +1693,30 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         rc = bnx2x_set_real_num_queues(bp);
         if (rc) {
                 BNX2X_ERR("Unable to set real_num_queues\n");
-                goto load_error0;
+                LOAD_ERROR_EXIT(bp, load_error0);
         }
 
         bnx2x_napi_enable(bp);
 
         /* Send LOAD_REQUEST command to MCP
-           Returns the type of LOAD command:
-           if it is the first port to be initialized
-           common blocks should be initialized, otherwise - not
-        */
+         * Returns the type of LOAD command:
+         * if it is the first port to be initialized
+         * common blocks should be initialized, otherwise - not
+         */
         if (!BP_NOMCP(bp)) {
                 load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ, 0);
                 if (!load_code) {
                         BNX2X_ERR("MCP response failure, aborting\n");
                         rc = -EBUSY;
-                        goto load_error1;
+                        LOAD_ERROR_EXIT(bp, load_error1);
                 }
                 if (load_code == FW_MSG_CODE_DRV_LOAD_REFUSED) {
                         rc = -EBUSY; /* other port in diagnostic mode */
-                        goto load_error1;
+                        LOAD_ERROR_EXIT(bp, load_error1);
                 }
 
         } else {
                 int path = BP_PATH(bp);
-                int port = BP_PORT(bp);
 
                 DP(NETIF_MSG_IFUP, "NO MCP - load counts[%d]      %d, %d, %d\n",
                    path, load_count[path][0], load_count[path][1],
@@ -1528,30 +1742,45 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 bp->port.pmf = 0;
         DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
 
+        /* Init Function state controlling object */
+        bnx2x__init_func_obj(bp);
+
         /* Initialize HW */
         rc = bnx2x_init_hw(bp, load_code);
         if (rc) {
                 BNX2X_ERR("HW init failed, aborting\n");
                 bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_DONE, 0);
-                goto load_error2;
+                LOAD_ERROR_EXIT(bp, load_error2);
         }
 
         /* Connect to IRQs */
         rc = bnx2x_setup_irqs(bp);
         if (rc) {
                 bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_DONE, 0);
-                goto load_error2;
+                LOAD_ERROR_EXIT(bp, load_error2);
         }
 
         /* Setup NIC internals and enable interrupts */
         bnx2x_nic_init(bp, load_code);
 
+        /* Init per-function objects */
+        bnx2x_init_bp_objs(bp);
+
         if (((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
             (load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP)) &&
-            (bp->common.shmem2_base))
-                SHMEM2_WR(bp, dcc_support,
-                          (SHMEM_DCC_SUPPORT_DISABLE_ENABLE_PF_TLV |
-                           SHMEM_DCC_SUPPORT_BANDWIDTH_ALLOCATION_TLV));
+            (bp->common.shmem2_base)) {
+                if (SHMEM2_HAS(bp, dcc_support))
+                        SHMEM2_WR(bp, dcc_support,
+                                  (SHMEM_DCC_SUPPORT_DISABLE_ENABLE_PF_TLV |
+                                   SHMEM_DCC_SUPPORT_BANDWIDTH_ALLOCATION_TLV));
+        }
+
+        bp->state = BNX2X_STATE_OPENING_WAIT4_PORT;
+        rc = bnx2x_func_start(bp);
+        if (rc) {
+                BNX2X_ERR("Function start failed!\n");
+                LOAD_ERROR_EXIT(bp, load_error3);
+        }
 
         /* Send LOAD_DONE command to MCP */
         if (!BP_NOMCP(bp)) {
@@ -1559,74 +1788,38 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 if (!load_code) {
                         BNX2X_ERR("MCP response failure, aborting\n");
                         rc = -EBUSY;
-                        goto load_error3;
+                        LOAD_ERROR_EXIT(bp, load_error3);
                 }
         }
 
-        bnx2x_dcbx_init(bp);
-
-        bp->state = BNX2X_STATE_OPENING_WAIT4_PORT;
-
-        rc = bnx2x_func_start(bp);
-        if (rc) {
-                BNX2X_ERR("Function start failed!\n");
-#ifndef BNX2X_STOP_ON_ERROR
-                goto load_error3;
-#else
-                bp->panic = 1;
-                return -EBUSY;
-#endif
-        }
-
-        rc = bnx2x_setup_client(bp, &bp->fp[0], 1 /* Leading */);
+        rc = bnx2x_setup_leading(bp);
         if (rc) {
                 BNX2X_ERR("Setup leading failed!\n");
-#ifndef BNX2X_STOP_ON_ERROR
-                goto load_error3;
-#else
-                bp->panic = 1;
-                return -EBUSY;
-#endif
-        }
-
-        if (!CHIP_IS_E1(bp) &&
-            (bp->mf_config[BP_VN(bp)] & FUNC_MF_CFG_FUNC_DISABLED)) {
-                DP(NETIF_MSG_IFUP, "mf_cfg function disabled\n");
-                bp->flags |= MF_FUNC_DIS;
+                LOAD_ERROR_EXIT(bp, load_error3);
         }
 
 #ifdef BCM_CNIC
         /* Enable Timer scan */
-        REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + BP_PORT(bp)*4, 1);
+        REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 1);
 #endif
 
         for_each_nondefault_queue(bp, i) {
-                rc = bnx2x_setup_client(bp, &bp->fp[i], 0);
+                rc = bnx2x_setup_queue(bp, &bp->fp[i], 0);
                 if (rc)
-#ifdef BCM_CNIC
-                        goto load_error4;
-#else
-                        goto load_error3;
-#endif
+                        LOAD_ERROR_EXIT(bp, load_error4);
         }
 
+        rc = bnx2x_init_rss_pf(bp);
+        if (rc)
+                LOAD_ERROR_EXIT(bp, load_error4);
+
         /* Now when Clients are configured we are ready to work */
         bp->state = BNX2X_STATE_OPEN;
 
-#ifdef BCM_CNIC
-        bnx2x_set_fcoe_eth_macs(bp);
-#endif
-
-        bnx2x_set_eth_mac(bp, 1);
-
-        /* Clear MC configuration */
-        if (CHIP_IS_E1(bp))
-                bnx2x_invalidate_e1_mc_list(bp);
-        else
-                bnx2x_invalidate_e1h_mc_list(bp);
-
-        /* Clear UC lists configuration */
-        bnx2x_invalidate_uc_list(bp);
+        /* Configure a ucast MAC */
+        rc = bnx2x_set_eth_mac(bp, true);
+        if (rc)
+                LOAD_ERROR_EXIT(bp, load_error4);
 
         if (bp->pending_max) {
                 bnx2x_update_max_mf_config(bp, bp->pending_max);
@@ -1636,15 +1829,18 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         if (bp->port.pmf)
                 bnx2x_initial_phy_init(bp, load_mode);
 
-        /* Initialize Rx filtering */
+        /* Start fast path */
+
+        /* Initialize Rx filter. */
+        netif_addr_lock_bh(bp->dev);
         bnx2x_set_rx_mode(bp->dev);
+        netif_addr_unlock_bh(bp->dev);
 
-        /* Start fast path */
+        /* Start the Tx */
         switch (load_mode) {
         case LOAD_NORMAL:
                 /* Tx queue should be only reenabled */
                 netif_tx_wake_all_queues(bp->dev);
-                /* Initialize the receive filter. */
                 break;
 
         case LOAD_OPEN:
@@ -1673,18 +1869,28 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 #endif
         bnx2x_inc_load_cnt(bp);
 
-        bnx2x_release_firmware(bp);
+        /* Wait for all pending SP commands to complete */
+        if (!bnx2x_wait_sp_comp(bp, ~0x0UL)) {
+                BNX2X_ERR("Timeout waiting for SP elements to complete\n");
+                bnx2x_nic_unload(bp, UNLOAD_CLOSE);
+                return -EBUSY;
+        }
 
+        bnx2x_dcbx_init(bp);
         return 0;
 
-#ifdef BCM_CNIC
+#ifndef BNX2X_STOP_ON_ERROR
 load_error4:
+#ifdef BCM_CNIC
         /* Disable Timer scan */
-        REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + BP_PORT(bp)*4, 0);
+        REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 0);
 #endif
 load_error3:
         bnx2x_int_disable_sync(bp, 1);
 
+        /* Clean queueable objects */
+        bnx2x_squeeze_objects(bp);
+
         /* Free SKBs, SGEs, TPA pool and driver internals */
         bnx2x_free_skbs(bp);
         for_each_rx_queue(bp, i)
@@ -1704,9 +1910,8 @@ load_error1:
 load_error0:
         bnx2x_free_mem(bp);
 
-        bnx2x_release_firmware(bp);
-
         return rc;
+#endif /* ! BNX2X_STOP_ON_ERROR */
 }
 
 /* must be called with rtnl_lock */
@@ -1728,18 +1933,19 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
         bnx2x_cnic_notify(bp, CNIC_CTL_STOP_CMD);
 #endif
         bp->state = BNX2X_STATE_CLOSING_WAIT4_HALT;
+        smp_mb();
 
-        /* Set "drop all" */
         bp->rx_mode = BNX2X_RX_MODE_NONE;
-        bnx2x_set_storm_rx_mode(bp);
 
         /* Stop Tx */
         bnx2x_tx_disable(bp);
 
         del_timer_sync(&bp->timer);
 
-        SHMEM_WR(bp, func_mb[BP_FW_MB_IDX(bp)].drv_pulse_mb,
-                 (DRV_PULSE_ALWAYS_ALIVE | bp->fw_drv_pulse_wr_seq));
+        /* Set ALWAYS_ALIVE bit in shmem */
+        bp->fw_drv_pulse_wr_seq |= DRV_PULSE_ALWAYS_ALIVE;
+
+        bnx2x_drv_pulse(bp);
 
         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
 
@@ -1754,6 +1960,12 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
                 bnx2x_free_irq(bp);
         }
 
+        /*
+         * At this stage no more interrupts will arrive so we may safly clean
+         * the queueable objects here in case they failed to get cleaned so far.
+         */
+        bnx2x_squeeze_objects(bp);
+
         bp->port.pmf = 0;
 
         /* Free SKBs, SGEs, TPA pool and driver internals */
@@ -2154,7 +2366,6 @@ static inline  u8 bnx2x_set_pbd_csum_e2(struct bnx2x *bp, struct sk_buff *skb,
 static inline void bnx2x_set_sbd_csum(struct bnx2x *bp, struct sk_buff *skb,
         struct eth_tx_start_bd *tx_start_bd, u32 xmit_type)
 {
-
         tx_start_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_L4_CSUM;
 
         if (xmit_type & XMIT_CSUM_V4)
@@ -2166,7 +2377,6 @@ static inline void bnx2x_set_sbd_csum(struct bnx2x *bp, struct sk_buff *skb,
 
         if (!(xmit_type & XMIT_CSUM_TCP))
                 tx_start_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_IS_UDP;
-
 }
 
 /**
@@ -2234,7 +2444,7 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
         struct bnx2x_fastpath *fp;
         struct netdev_queue *txq;
         struct sw_tx_bd *tx_buf;
-        struct eth_tx_start_bd *tx_start_bd;
+        struct eth_tx_start_bd *tx_start_bd, *first_bd;
         struct eth_tx_bd *tx_data_bd, *total_pkt_bd = NULL;
         struct eth_tx_parse_bd_e1x *pbd_e1x = NULL;
         struct eth_tx_parse_bd_e2 *pbd_e2 = NULL;
@@ -2296,7 +2506,15 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 }
         }
 #endif
-
+        /* Map skb linear data for DMA */
+        mapping = dma_map_single(&bp->pdev->dev, skb->data,
+                                 skb_headlen(skb), DMA_TO_DEVICE);
+        if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
+                DP(NETIF_MSG_TX_QUEUED, "SKB mapping failed - "
+                   "silently dropping this SKB\n");
+                dev_kfree_skb_any(skb);
+                return NETDEV_TX_OK;
+        }
         /*
         Please read carefully. First we use one BD which we mark as start,
         then we have a parsing info BD (used for TSO or xsum),
@@ -2306,12 +2524,19 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
         And above all, all pdb sizes are in words - NOT DWORDS!
         */
 
-        pkt_prod = fp->tx_pkt_prod++;
+        /* get current pkt produced now - advance it just before sending packet
+         * since mapping of pages may fail and cause packet to be dropped
+         */
+        pkt_prod = fp->tx_pkt_prod;
         bd_prod = TX_BD(fp->tx_bd_prod);
 
-        /* get a tx_buf and first BD */
+        /* get a tx_buf and first BD
+         * tx_start_bd may be changed during SPLIT,
+         * but first_bd will always stay first
+         */
         tx_buf = &fp->tx_buf_ring[TX_BD(pkt_prod)];
         tx_start_bd = &fp->tx_desc_ring[bd_prod].start_bd;
+        first_bd = tx_start_bd;
 
         tx_start_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_START_BD;
         SET_FLAG(tx_start_bd->general_data, ETH_TX_START_BD_ETH_ADDR_TYPE,
@@ -2343,7 +2568,7 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
         if (xmit_type & XMIT_CSUM)
                 bnx2x_set_sbd_csum(bp, skb, tx_start_bd, xmit_type);
 
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 pbd_e2 = &fp->tx_desc_ring[bd_prod].parse_bd_e2;
                 memset(pbd_e2, 0, sizeof(struct eth_tx_parse_bd_e2));
                 /* Set PBD in checksum offload case */
@@ -2351,6 +2576,20 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                         hlen = bnx2x_set_pbd_csum_e2(bp, skb,
                                                      &pbd_e2_parsing_data,
                                                      xmit_type);
+                if (IS_MF_SI(bp)) {
+                        /*
+                         * fill in the MAC addresses in the PBD - for local
+                         * switching
+                         */
+                        bnx2x_set_fw_mac_addr(&pbd_e2->src_mac_addr_hi,
+                                              &pbd_e2->src_mac_addr_mid,
+                                              &pbd_e2->src_mac_addr_lo,
+                                              eth->h_source);
+                        bnx2x_set_fw_mac_addr(&pbd_e2->dst_mac_addr_hi,
+                                              &pbd_e2->dst_mac_addr_mid,
+                                              &pbd_e2->dst_mac_addr_lo,
+                                              eth->h_dest);
+                }
         } else {
                 pbd_e1x = &fp->tx_desc_ring[bd_prod].parse_bd_e1x;
                 memset(pbd_e1x, 0, sizeof(struct eth_tx_parse_bd_e1x));
@@ -2360,15 +2599,10 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         }
 
-        /* Map skb linear data for DMA */
-        mapping = dma_map_single(&bp->pdev->dev, skb->data,
-                                 skb_headlen(skb), DMA_TO_DEVICE);
-
         /* Setup the data pointer of the first BD of the packet */
         tx_start_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
         tx_start_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
-        nbd = skb_shinfo(skb)->nr_frags + 2; /* start_bd + pbd + frags */
-        tx_start_bd->nbd = cpu_to_le16(nbd);
+        nbd = 2; /* start_bd + pbd + frags (updated when pages are mapped) */
         tx_start_bd->nbytes = cpu_to_le16(skb_headlen(skb));
         pkt_size = tx_start_bd->nbytes;
 
@@ -2391,7 +2625,7 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 if (unlikely(skb_headlen(skb) > hlen))
                         bd_prod = bnx2x_tx_split(bp, fp, tx_buf, &tx_start_bd,
                                                  hlen, bd_prod, ++nbd);
-                if (CHIP_IS_E2(bp))
+                if (!CHIP_IS_E1x(bp))
                         bnx2x_set_pbd_gso_e2(skb, &pbd_e2_parsing_data,
                                              xmit_type);
                 else
@@ -2410,19 +2644,34 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 
+                mapping = dma_map_page(&bp->pdev->dev, frag->page,
+                                       frag->page_offset, frag->size,
+                                       DMA_TO_DEVICE);
+                if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
+
+                        DP(NETIF_MSG_TX_QUEUED, "Unable to map page - "
+                                                "dropping packet...\n");
+
+                        /* we need unmap all buffers already mapped
+                         * for this SKB;
+                         * first_bd->nbd need to be properly updated
+                         * before call to bnx2x_free_tx_pkt
+                         */
+                        first_bd->nbd = cpu_to_le16(nbd);
+                        bnx2x_free_tx_pkt(bp, fp, TX_BD(fp->tx_pkt_prod));
+                        return NETDEV_TX_OK;
+                }
+
                 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
                 tx_data_bd = &fp->tx_desc_ring[bd_prod].reg_bd;
                 if (total_pkt_bd == NULL)
                         total_pkt_bd = &fp->tx_desc_ring[bd_prod].reg_bd;
 
-                mapping = dma_map_page(&bp->pdev->dev, frag->page,
-                                       frag->page_offset,
-                                       frag->size, DMA_TO_DEVICE);
-
                 tx_data_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
                 tx_data_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
                 tx_data_bd->nbytes = cpu_to_le16(frag->size);
                 le16_add_cpu(&pkt_size, frag->size);
+                nbd++;
 
                 DP(NETIF_MSG_TX_QUEUED,
                    "frag %d  bd @%p  addr (%x:%x)  nbytes %d\n",
@@ -2432,6 +2681,9 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         DP(NETIF_MSG_TX_QUEUED, "last bd @%p\n", tx_data_bd);
 
+        /* update with actual num BDs */
+        first_bd->nbd = cpu_to_le16(nbd);
+
         bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
 
         /* now send a tx doorbell, counting the next BD
@@ -2440,6 +2692,13 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
         if (TX_BD_POFF(bd_prod) < nbd)
                 nbd++;
 
+        /* total_pkt_bytes should be set on the first data BD if
+         * it's not an LSO packet and there is more than one
+         * data BD. In this case pkt_size is limited by an MTU value.
+         * However we prefer to set it for an LSO packet (while we don't
+         * have to) in order to save some CPU cycles in a none-LSO
+         * case, when we much more care about them.
+         */
         if (total_pkt_bd != NULL)
                 total_pkt_bd->total_pkt_bytes = pkt_size;
 
@@ -2460,6 +2719,7 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                    pbd_e2->parsing_data);
         DP(NETIF_MSG_TX_QUEUED, "doorbell: nbd %d  bd %u\n", nbd, bd_prod);
 
+        fp->tx_pkt_prod++;
         /*
          * Make sure that the BD data is updated before updating the producer
          * since FW might read the BD right after the producer is updated.
@@ -2500,15 +2760,23 @@ int bnx2x_change_mac_addr(struct net_device *dev, void *p)
 {
         struct sockaddr *addr = p;
         struct bnx2x *bp = netdev_priv(dev);
+        int rc = 0;
 
         if (!is_valid_ether_addr((u8 *)(addr->sa_data)))
                 return -EINVAL;
 
+        if (netif_running(dev))  {
+                rc = bnx2x_set_eth_mac(bp, false);
+                if (rc)
+                        return rc;
+        }
+
         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+
         if (netif_running(dev))
-                bnx2x_set_eth_mac(bp, 1);
+                rc = bnx2x_set_eth_mac(bp, true);
 
-        return 0;
+        return rc;
 }
 
 static void bnx2x_free_fp_mem_at(struct bnx2x *bp, int fp_index)
@@ -2525,7 +2793,7 @@ static void bnx2x_free_fp_mem_at(struct bnx2x *bp, int fp_index)
         } else {
 #endif
                 /* status blocks */
-                if (CHIP_IS_E2(bp))
+                if (!CHIP_IS_E1x(bp))
                         BNX2X_PCI_FREE(sb->e2_sb,
                                        bnx2x_fp(bp, fp_index,
                                                 status_blk_mapping),
@@ -2581,7 +2849,7 @@ void bnx2x_free_fp_mem(struct bnx2x *bp)
 static inline void set_sb_shortcuts(struct bnx2x *bp, int index)
 {
         union host_hc_status_block status_blk = bnx2x_fp(bp, index, status_blk);
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 bnx2x_fp(bp, index, sb_index_values) =
                         (__le16 *)status_blk.e2_sb->sb.index_values;
                 bnx2x_fp(bp, index, sb_running_index) =
@@ -2618,7 +2886,7 @@ static int bnx2x_alloc_fp_mem_at(struct bnx2x *bp, int index)
         if (!IS_FCOE_IDX(index)) {
 #endif
                 /* status blocks */
-                if (CHIP_IS_E2(bp))
+                if (!CHIP_IS_E1x(bp))
                         BNX2X_PCI_ALLOC(sb->e2_sb,
                                 &bnx2x_fp(bp, index, status_blk_mapping),
                                 sizeof(struct host_hc_status_block_e2));
@@ -2747,30 +3015,6 @@ int bnx2x_alloc_fp_mem(struct bnx2x *bp)
         return 0;
 }
 
-static int bnx2x_setup_irqs(struct bnx2x *bp)
-{
-        int rc = 0;
-        if (bp->flags & USING_MSIX_FLAG) {
-                rc = bnx2x_req_msix_irqs(bp);
-                if (rc)
-                        return rc;
-        } else {
-                bnx2x_ack_int(bp);
-                rc = bnx2x_req_irq(bp);
-                if (rc) {
-                        BNX2X_ERR("IRQ request failed  rc %d, aborting\n", rc);
-                        return rc;
-                }
-                if (bp->flags & USING_MSI_FLAG) {
-                        bp->dev->irq = bp->pdev->irq;
-                        netdev_info(bp->dev, "using MSI  IRQ %d\n",
-                               bp->pdev->irq);
-                }
-        }
-
-        return 0;
-}
-
 void bnx2x_free_mem_bp(struct bnx2x *bp)
 {
         kfree(bp->fp);
@@ -3021,3 +3265,57 @@ int bnx2x_resume(struct pci_dev *pdev)
 
         return rc;
 }
+
+
+void bnx2x_set_ctx_validation(struct bnx2x *bp, struct eth_context *cxt,
+                              u32 cid)
+{
+        /* ustorm cxt validation */
+        cxt->ustorm_ag_context.cdu_usage =
+                CDU_RSRVD_VALUE_TYPE_A(HW_CID(bp, cid),
+                        CDU_REGION_NUMBER_UCM_AG, ETH_CONNECTION_TYPE);
+        /* xcontext validation */
+        cxt->xstorm_ag_context.cdu_reserved =
+                CDU_RSRVD_VALUE_TYPE_A(HW_CID(bp, cid),
+                        CDU_REGION_NUMBER_XCM_AG, ETH_CONNECTION_TYPE);
+}
+
+static inline void storm_memset_hc_timeout(struct bnx2x *bp, u8 port,
+                                             u8 fw_sb_id, u8 sb_index,
+                                             u8 ticks)
+{
+
+        u32 addr = BAR_CSTRORM_INTMEM +
+                   CSTORM_STATUS_BLOCK_DATA_TIMEOUT_OFFSET(fw_sb_id, sb_index);
+        REG_WR8(bp, addr, ticks);
+        DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d ticks %d\n",
+                          port, fw_sb_id, sb_index, ticks);
+}
+
+static inline void storm_memset_hc_disable(struct bnx2x *bp, u8 port,
+                                             u16 fw_sb_id, u8 sb_index,
+                                             u8 disable)
+{
+        u32 enable_flag = disable ? 0 : (1 << HC_INDEX_DATA_HC_ENABLED_SHIFT);
+        u32 addr = BAR_CSTRORM_INTMEM +
+                   CSTORM_STATUS_BLOCK_DATA_FLAGS_OFFSET(fw_sb_id, sb_index);
+        u16 flags = REG_RD16(bp, addr);
+        /* clear and set */
+        flags &= ~HC_INDEX_DATA_HC_ENABLED;
+        flags |= enable_flag;
+        REG_WR16(bp, addr, flags);
+        DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d disable %d\n",
+                          port, fw_sb_id, sb_index, disable);
+}
+
+void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, u8 fw_sb_id,
+                                    u8 sb_index, u8 disable, u16 usec)
+{
+        int port = BP_PORT(bp);
+        u8 ticks = usec / BNX2X_BTR;
+
+        storm_memset_hc_timeout(bp, port, fw_sb_id, sb_index, ticks);
+
+        disable = disable ? 1 : (usec ? 0 : 1);
+        storm_memset_hc_disable(bp, port, fw_sb_id, sb_index, disable);
+}
diff --git a/drivers/net/bnx2x/bnx2x_cmn.h b/drivers/net/bnx2x/bnx2x_cmn.h
index 5a97f92b340c..944bcaeeba45 100644
--- a/drivers/net/bnx2x/bnx2x_cmn.h
+++ b/drivers/net/bnx2x/bnx2x_cmn.h
@@ -18,11 +18,15 @@
 #define BNX2X_CMN_H
 
 #include <linux/types.h>
+#include <linux/pci.h>
 #include <linux/netdevice.h>
 
 
 #include "bnx2x.h"
 
+/* This is used as a replacement for an MCP if it's not present */
+extern int load_count[2][3]; /* per-path: 0-common, 1-port0, 2-port1 */
+
 extern int num_queues;
 
 /************************ Macros ********************************/
@@ -61,6 +65,73 @@ extern int num_queues;
 /*********************** Interfaces ****************************
  *  Functions that need to be implemented by each driver version
  */
+/* Init */
+
+/**
+ * bnx2x_send_unload_req - request unload mode from the MCP.
+ *
+ * @bp:                 driver handle
+ * @unload_mode:        requested function's unload mode
+ *
+ * Return unload mode returned by the MCP: COMMON, PORT or FUNC.
+ */
+u32 bnx2x_send_unload_req(struct bnx2x *bp, int unload_mode);
+
+/**
+ * bnx2x_send_unload_done - send UNLOAD_DONE command to the MCP.
+ *
+ * @bp:         driver handle
+ */
+void bnx2x_send_unload_done(struct bnx2x *bp);
+
+/**
+ * bnx2x_config_rss_pf - configure RSS parameters.
+ *
+ * @bp:                 driver handle
+ * @ind_table:          indirection table to configure
+ * @config_hash:        re-configure RSS hash keys configuration
+ */
+int bnx2x_config_rss_pf(struct bnx2x *bp, u8 *ind_table, bool config_hash);
+
+/**
+ * bnx2x__init_func_obj - init function object
+ *
+ * @bp:                 driver handle
+ *
+ * Initializes the Function Object with the appropriate
+ * parameters which include a function slow path driver
+ * interface.
+ */
+void bnx2x__init_func_obj(struct bnx2x *bp);
+
+/**
+ * bnx2x_setup_queue - setup eth queue.
+ *
+ * @bp:         driver handle
+ * @fp:         pointer to the fastpath structure
+ * @leading:    boolean
+ *
+ */
+int bnx2x_setup_queue(struct bnx2x *bp, struct bnx2x_fastpath *fp,
+                       bool leading);
+
+/**
+ * bnx2x_setup_leading - bring up a leading eth queue.
+ *
+ * @bp:         driver handle
+ */
+int bnx2x_setup_leading(struct bnx2x *bp);
+
+/**
+ * bnx2x_fw_command - send the MCP a request
+ *
+ * @bp:         driver handle
+ * @command:    request
+ * @param:      request's parameter
+ *
+ * block until there is a reply
+ */
+u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param);
 
 /**
  * bnx2x_initial_phy_init - initialize link parameters structure variables.
@@ -88,6 +159,29 @@ void bnx2x_link_set(struct bnx2x *bp);
 u8 bnx2x_link_test(struct bnx2x *bp, u8 is_serdes);
 
 /**
+ * bnx2x_drv_pulse - write driver pulse to shmem
+ *
+ * @bp:         driver handle
+ *
+ * writes the value in bp->fw_drv_pulse_wr_seq to drv_pulse mbox
+ * in the shmem.
+ */
+void bnx2x_drv_pulse(struct bnx2x *bp);
+
+/**
+ * bnx2x_igu_ack_sb - update IGU with current SB value
+ *
+ * @bp:         driver handle
+ * @igu_sb_id:  SB id
+ * @segment:    SB segment
+ * @index:      SB index
+ * @op:         SB operation
+ * @update:     is HW update required
+ */
+void bnx2x_igu_ack_sb(struct bnx2x *bp, u8 igu_sb_id, u8 segment,
+                      u16 index, u8 op, u8 update);
+
+/**
  * bnx2x__link_status_update - handles link status change.
  *
  * @bp:         driver handle
@@ -165,21 +259,6 @@ void bnx2x_int_enable(struct bnx2x *bp);
 void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw);
 
 /**
- * bnx2x_init_firmware - loads device firmware
- *
- * @bp:         driver handle
- */
-int bnx2x_init_firmware(struct bnx2x *bp);
-
-/**
- * bnx2x_init_hw - init HW blocks according to current initialization stage.
- *
- * @bp:         driver handle
- * @load_code:  COMMON, PORT or FUNCTION
- */
-int bnx2x_init_hw(struct bnx2x *bp, u32 load_code);
-
-/**
  * bnx2x_nic_init - init driver internals.
  *
  * @bp:         driver handle
@@ -207,16 +286,6 @@ int bnx2x_alloc_mem(struct bnx2x *bp);
 void bnx2x_free_mem(struct bnx2x *bp);
 
 /**
- * bnx2x_setup_client - setup eth client.
- *
- * @bp:         driver handle
- * @fp:         pointer to fastpath structure
- * @is_leading: boolean
- */
-int bnx2x_setup_client(struct bnx2x *bp, struct bnx2x_fastpath *fp,
-                       int is_leading);
-
-/**
  * bnx2x_set_num_queues - set number of queues according to mode.
  *
  * @bp:         driver handle
@@ -259,38 +328,44 @@ int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource);
  *
  * Configures according to the value in netdev->dev_addr.
  */
-void bnx2x_set_eth_mac(struct bnx2x *bp, int set);
+int bnx2x_set_eth_mac(struct bnx2x *bp, bool set);
 
-#ifdef BCM_CNIC
 /**
- * bnx2x_set_fip_eth_mac_addr - Set/Clear FIP MAC(s)
+ * bnx2x_set_rx_mode - set MAC filtering configurations.
  *
- * @bp:         driver handle
- * @set:        set or clear the CAM entry
+ * @dev:        netdevice
  *
- * Used next enties in the CAM after the ETH MAC(s).
- * This function will wait until the ramdord completion returns.
- * Return 0 if cussess, -ENODEV if ramrod doesn't return.
+ * called with netif_tx_lock from dev_mcast.c
+ * If bp->state is OPEN, should be called with
+ * netif_addr_lock_bh()
  */
-int bnx2x_set_fip_eth_mac_addr(struct bnx2x *bp, int set);
+void bnx2x_set_rx_mode(struct net_device *dev);
 
 /**
- * bnx2x_set_all_enode_macs - Set/Clear ALL_ENODE mcast MAC.
+ * bnx2x_set_storm_rx_mode - configure MAC filtering rules in a FW.
  *
  * @bp:         driver handle
- * @set:        set or clear
+ *
+ * If bp->state is OPEN, should be called with
+ * netif_addr_lock_bh().
  */
-int bnx2x_set_all_enode_macs(struct bnx2x *bp, int set);
-#endif
+void bnx2x_set_storm_rx_mode(struct bnx2x *bp);
 
 /**
- * bnx2x_set_rx_mode - set MAC filtering configurations.
- *
- * @dev:        netdevice
+ * bnx2x_set_q_rx_mode - configures rx_mode for a single queue.
  *
- * called with netif_tx_lock from dev_mcast.c
+ * @bp:                 driver handle
+ * @cl_id:              client id
+ * @rx_mode_flags:      rx mode configuration
+ * @rx_accept_flags:    rx accept configuration
+ * @tx_accept_flags:    tx accept configuration (tx switch)
+ * @ramrod_flags:       ramrod configuration
  */
-void bnx2x_set_rx_mode(struct net_device *dev);
+void bnx2x_set_q_rx_mode(struct bnx2x *bp, u8 cl_id,
+                         unsigned long rx_mode_flags,
+                         unsigned long rx_accept_flags,
+                         unsigned long tx_accept_flags,
+                         unsigned long ramrod_flags);
 
 /* Parity errors related */
 void bnx2x_inc_load_cnt(struct bnx2x *bp);
@@ -300,14 +375,6 @@ bool bnx2x_reset_is_done(struct bnx2x *bp);
 void bnx2x_disable_close_the_gate(struct bnx2x *bp);
 
 /**
- * bnx2x_stats_handle - perform statistics handling according to event.
- *
- * @bp:         driver handle
- * @event:      bnx2x_stats_event
- */
-void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event);
-
-/**
  * bnx2x_sp_event - handle ramrods completion.
  *
  * @fp:         fastpath handle for the event
@@ -316,15 +383,6 @@ void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event);
 void bnx2x_sp_event(struct bnx2x_fastpath *fp, union eth_rx_cqe *rr_cqe);
 
 /**
- * bnx2x_func_start - init function
- *
- * @bp:         driver handle
- *
- * Must be called before sending CLIENT_SETUP for the first client.
- */
-int bnx2x_func_start(struct bnx2x *bp);
-
-/**
  * bnx2x_ilt_set_info - prepare ILT configurations.
  *
  * @bp:         driver handle
@@ -355,6 +413,8 @@ int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state);
  * @value:      new value
  */
 void bnx2x_update_max_mf_config(struct bnx2x *bp, u32 value);
+/* Error handling */
+void bnx2x_panic_dump(struct bnx2x *bp);
 
 void bnx2x_fw_dump_lvl(struct bnx2x *bp, const char *lvl);
 
@@ -378,6 +438,9 @@ int bnx2x_change_mac_addr(struct net_device *dev, void *p);
 /* NAPI poll Rx part */
 int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget);
 
+void bnx2x_update_rx_prod(struct bnx2x *bp, struct bnx2x_fastpath *fp,
+                        u16 bd_prod, u16 rx_comp_prod, u16 rx_sge_prod);
+
 /* NAPI poll Tx part */
 int bnx2x_tx_int(struct bnx2x_fastpath *fp);
 
@@ -390,7 +453,6 @@ void bnx2x_free_irq(struct bnx2x *bp);
 
 void bnx2x_free_fp_mem(struct bnx2x *bp);
 int bnx2x_alloc_fp_mem(struct bnx2x *bp);
-
 void bnx2x_init_rx_rings(struct bnx2x *bp);
 void bnx2x_free_skbs(struct bnx2x *bp);
 void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw);
@@ -455,19 +517,20 @@ int bnx2x_set_features(struct net_device *dev, u32 features);
  */
 void bnx2x_tx_timeout(struct net_device *dev);
 
+/*********************** Inlines **********************************/
+/*********************** Fast path ********************************/
 static inline void bnx2x_update_fpsb_idx(struct bnx2x_fastpath *fp)
 {
         barrier(); /* status block is written to by the chip */
         fp->fp_hc_idx = fp->sb_running_index[SM_RX_ID];
 }
 
-static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
-                                        struct bnx2x_fastpath *fp,
-                                        u16 bd_prod, u16 rx_comp_prod,
-                                        u16 rx_sge_prod)
+static inline void bnx2x_update_rx_prod_gen(struct bnx2x *bp,
+                        struct bnx2x_fastpath *fp, u16 bd_prod,
+                        u16 rx_comp_prod, u16 rx_sge_prod, u32 start)
 {
         struct ustorm_eth_rx_producers rx_prods = {0};
-        int i;
+        u32 i;
 
         /* Update producers */
         rx_prods.bd_prod = bd_prod;
@@ -484,10 +547,8 @@ static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
          */
         wmb();
 
-        for (i = 0; i < sizeof(struct ustorm_eth_rx_producers)/4; i++)
-                REG_WR(bp,
-                       BAR_USTRORM_INTMEM + fp->ustorm_rx_prods_offset + i*4,
-                       ((u32 *)&rx_prods)[i]);
+        for (i = 0; i < sizeof(rx_prods)/4; i++)
+                REG_WR(bp, start + i*4, ((u32 *)&rx_prods)[i]);
 
         mmiowb(); /* keep prod updates ordered */
 
@@ -517,7 +578,7 @@ static inline void bnx2x_igu_ack_sb_gen(struct bnx2x *bp, u8 igu_sb_id,
         barrier();
 }
 
-static inline void bnx2x_igu_clear_sb_gen(struct bnx2x *bp,
+static inline void bnx2x_igu_clear_sb_gen(struct bnx2x *bp, u8 func,
                                           u8 idu_sb_id, bool is_Pf)
 {
         u32 data, ctl, cnt = 100;
@@ -525,7 +586,7 @@ static inline void bnx2x_igu_clear_sb_gen(struct bnx2x *bp,
         u32 igu_addr_ctl = IGU_REG_COMMAND_REG_CTRL;
         u32 igu_addr_ack = IGU_REG_CSTORM_TYPE_0_SB_CLEANUP + (idu_sb_id/32)*4;
         u32 sb_bit =  1 << (idu_sb_id%32);
-        u32 func_encode = BP_FUNC(bp) |
+        u32 func_encode = func |
                         ((is_Pf == true ? 1 : 0) << IGU_FID_ENCODE_IS_PF_SHIFT);
         u32 addr_encode = IGU_CMD_E2_PROD_UPD_BASE + idu_sb_id;
 
@@ -588,15 +649,6 @@ static inline void bnx2x_hc_ack_sb(struct bnx2x *bp, u8 sb_id,
         barrier();
 }
 
-static inline void bnx2x_igu_ack_sb(struct bnx2x *bp, u8 igu_sb_id, u8 segment,
-                      u16 index, u8 op, u8 update)
-{
-        u32 igu_addr = BAR_IGU_INTMEM + (IGU_CMD_INT_ACK_BASE + igu_sb_id)*8;
-
-        bnx2x_igu_ack_sb_gen(bp, igu_sb_id, segment, index, op, update,
-                             igu_addr);
-}
-
 static inline void bnx2x_ack_sb(struct bnx2x *bp, u8 igu_sb_id, u8 storm,
                                 u16 index, u8 op, u8 update)
 {
@@ -703,7 +755,7 @@ static inline int bnx2x_has_rx_work(struct bnx2x_fastpath *fp)
 }
 
 /**
- * disables tx from stack point of view
+ * bnx2x_tx_disable - disables tx from stack point of view
  *
  * @bp:         driver handle
  */
@@ -738,7 +790,7 @@ static inline void bnx2x_add_all_napi(struct bnx2x *bp)
         int i;
 
         /* Add NAPI objects */
-        for_each_napi_queue(bp, i)
+        for_each_rx_queue(bp, i)
                 netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
                                bnx2x_poll, BNX2X_NAPI_WEIGHT);
 }
@@ -747,7 +799,7 @@ static inline void bnx2x_del_all_napi(struct bnx2x *bp)
 {
         int i;
 
-        for_each_napi_queue(bp, i)
+        for_each_rx_queue(bp, i)
                 netif_napi_del(&bnx2x_fp(bp, i, napi));
 }
 
@@ -777,7 +829,7 @@ static inline void bnx2x_clear_sge_mask_next_elems(struct bnx2x_fastpath *fp)
                 int idx = RX_SGE_CNT * i - 1;
 
                 for (j = 0; j < 2; j++) {
-                        SGE_MASK_CLEAR_BIT(fp, idx);
+                        BIT_VEC64_CLEAR_BIT(fp->sge_mask, idx);
                         idx--;
                 }
         }
@@ -787,7 +839,7 @@ static inline void bnx2x_init_sge_ring_bit_mask(struct bnx2x_fastpath *fp)
 {
         /* Set the mask to all 1-s: it's faster to compare to 0 than to 0xf-s */
         memset(fp->sge_mask, 0xff,
-               (NUM_RX_SGE >> RX_SGE_MASK_ELEM_SHIFT)*sizeof(u64));
+               (NUM_RX_SGE >> BIT_VEC64_ELEM_SHIFT)*sizeof(u64));
 
         /* Clear the two last indices in the page to 1:
            these are the indices that correspond to the "next" element,
@@ -869,12 +921,61 @@ static inline void bnx2x_reuse_rx_skb(struct bnx2x_fastpath *fp,
                                    dma_unmap_addr(cons_rx_buf, mapping),
                                    RX_COPY_THRESH, DMA_FROM_DEVICE);
 
-        prod_rx_buf->skb = cons_rx_buf->skb;
         dma_unmap_addr_set(prod_rx_buf, mapping,
                            dma_unmap_addr(cons_rx_buf, mapping));
+        prod_rx_buf->skb = cons_rx_buf->skb;
         *prod_bd = *cons_bd;
 }
 
+/************************* Init ******************************************/
+
+/**
+ * bnx2x_func_start - init function
+ *
+ * @bp:         driver handle
+ *
+ * Must be called before sending CLIENT_SETUP for the first client.
+ */
+static inline int bnx2x_func_start(struct bnx2x *bp)
+{
+        struct bnx2x_func_state_params func_params = {0};
+        struct bnx2x_func_start_params *start_params =
+                &func_params.params.start;
+
+        /* Prepare parameters for function state transitions */
+        __set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
+
+        func_params.f_obj = &bp->func_obj;
+        func_params.cmd = BNX2X_F_CMD_START;
+
+        /* Function parameters */
+        start_params->mf_mode = bp->mf_mode;
+        start_params->sd_vlan_tag = bp->mf_ov;
+                start_params->network_cos_mode = OVERRIDE_COS;
+
+        return bnx2x_func_state_change(bp, &func_params);
+}
+
+
+/**
+ * bnx2x_set_fw_mac_addr - fill in a MAC address in FW format
+ *
+ * @fw_hi:      pointer to upper part
+ * @fw_mid:     pointer to middle part
+ * @fw_lo:      pointer to lower part
+ * @mac:        pointer to MAC address
+ */
+static inline void bnx2x_set_fw_mac_addr(u16 *fw_hi, u16 *fw_mid, u16 *fw_lo,
+                                         u8 *mac)
+{
+        ((u8 *)fw_hi)[0]  = mac[1];
+        ((u8 *)fw_hi)[1]  = mac[0];
+        ((u8 *)fw_mid)[0] = mac[3];
+        ((u8 *)fw_mid)[1] = mac[2];
+        ((u8 *)fw_lo)[0]  = mac[5];
+        ((u8 *)fw_lo)[1]  = mac[4];
+}
+
 static inline void bnx2x_free_rx_sge_range(struct bnx2x *bp,
                                            struct bnx2x_fastpath *fp, int last)
 {
@@ -893,21 +994,20 @@ static inline void bnx2x_free_tpa_pool(struct bnx2x *bp,
         int i;
 
         for (i = 0; i < last; i++) {
-                struct sw_rx_bd *rx_buf = &(fp->tpa_pool[i]);
-                struct sk_buff *skb = rx_buf->skb;
+                struct bnx2x_agg_info *tpa_info = &fp->tpa_info[i];
+                struct sw_rx_bd *first_buf = &tpa_info->first_buf;
+                struct sk_buff *skb = first_buf->skb;
 
                 if (skb == NULL) {
                         DP(NETIF_MSG_IFDOWN, "tpa bin %d empty on free\n", i);
                         continue;
                 }
-
-                if (fp->tpa_state[i] == BNX2X_TPA_START)
+                if (tpa_info->tpa_state == BNX2X_TPA_START)
                         dma_unmap_single(&bp->pdev->dev,
-                                         dma_unmap_addr(rx_buf, mapping),
+                                         dma_unmap_addr(first_buf, mapping),
                                          fp->rx_buf_size, DMA_FROM_DEVICE);
-
                 dev_kfree_skb(skb);
-                rx_buf->skb = NULL;
+                first_buf->skb = NULL;
         }
 }
 
@@ -1036,31 +1136,199 @@ static inline int bnx2x_alloc_rx_bds(struct bnx2x_fastpath *fp,
         return i - fp->eth_q_stats.rx_skb_alloc_failed;
 }
 
+/* Statistics ID are global per chip/path, while Client IDs for E1x are per
+ * port.
+ */
+static inline u8 bnx2x_stats_id(struct bnx2x_fastpath *fp)
+{
+        if (!CHIP_IS_E1x(fp->bp))
+                return fp->cl_id;
+        else
+                return fp->cl_id + BP_PORT(fp->bp) * FP_SB_MAX_E1x;
+}
+
+static inline void bnx2x_init_vlan_mac_fp_objs(struct bnx2x_fastpath *fp,
+                                               bnx2x_obj_type obj_type)
+{
+        struct bnx2x *bp = fp->bp;
+
+        /* Configure classification DBs */
+        bnx2x_init_mac_obj(bp, &fp->mac_obj, fp->cl_id, fp->cid,
+                           BP_FUNC(bp), bnx2x_sp(bp, mac_rdata),
+                           bnx2x_sp_mapping(bp, mac_rdata),
+                           BNX2X_FILTER_MAC_PENDING,
+                           &bp->sp_state, obj_type,
+                           &bp->macs_pool);
+}
+
+/**
+ * bnx2x_get_path_func_num - get number of active functions
+ *
+ * @bp:         driver handle
+ *
+ * Calculates the number of active (not hidden) functions on the
+ * current path.
+ */
+static inline u8 bnx2x_get_path_func_num(struct bnx2x *bp)
+{
+        u8 func_num = 0, i;
+
+        /* 57710 has only one function per-port */
+        if (CHIP_IS_E1(bp))
+                return 1;
+
+        /* Calculate a number of functions enabled on the current
+         * PATH/PORT.
+         */
+        if (CHIP_REV_IS_SLOW(bp)) {
+                if (IS_MF(bp))
+                        func_num = 4;
+                else
+                        func_num = 2;
+        } else {
+                for (i = 0; i < E1H_FUNC_MAX / 2; i++) {
+                        u32 func_config =
+                                MF_CFG_RD(bp,
+                                          func_mf_config[BP_PORT(bp) + 2 * i].
+                                          config);
+                        func_num +=
+                                ((func_config & FUNC_MF_CFG_FUNC_HIDE) ? 0 : 1);
+                }
+        }
+
+        WARN_ON(!func_num);
+
+        return func_num;
+}
+
+static inline void bnx2x_init_bp_objs(struct bnx2x *bp)
+{
+        /* RX_MODE controlling object */
+        bnx2x_init_rx_mode_obj(bp, &bp->rx_mode_obj);
+
+        /* multicast configuration controlling object */
+        bnx2x_init_mcast_obj(bp, &bp->mcast_obj, bp->fp->cl_id, bp->fp->cid,
+                             BP_FUNC(bp), BP_FUNC(bp),
+                             bnx2x_sp(bp, mcast_rdata),
+                             bnx2x_sp_mapping(bp, mcast_rdata),
+                             BNX2X_FILTER_MCAST_PENDING, &bp->sp_state,
+                             BNX2X_OBJ_TYPE_RX);
+
+        /* Setup CAM credit pools */
+        bnx2x_init_mac_credit_pool(bp, &bp->macs_pool, BP_FUNC(bp),
+                                   bnx2x_get_path_func_num(bp));
+
+        /* RSS configuration object */
+        bnx2x_init_rss_config_obj(bp, &bp->rss_conf_obj, bp->fp->cl_id,
+                                  bp->fp->cid, BP_FUNC(bp), BP_FUNC(bp),
+                                  bnx2x_sp(bp, rss_rdata),
+                                  bnx2x_sp_mapping(bp, rss_rdata),
+                                  BNX2X_FILTER_RSS_CONF_PENDING, &bp->sp_state,
+                                  BNX2X_OBJ_TYPE_RX);
+}
+
+static inline u8 bnx2x_fp_qzone_id(struct bnx2x_fastpath *fp)
+{
+        if (CHIP_IS_E1x(fp->bp))
+                return fp->cl_id + BP_PORT(fp->bp) * ETH_MAX_RX_CLIENTS_E1H;
+        else
+                return fp->cl_id;
+}
+
+static inline u32 bnx2x_rx_ustorm_prods_offset(struct bnx2x_fastpath *fp)
+{
+        struct bnx2x *bp = fp->bp;
+
+        if (!CHIP_IS_E1x(bp))
+                return USTORM_RX_PRODS_E2_OFFSET(fp->cl_qzone_id);
+        else
+                return USTORM_RX_PRODS_E1X_OFFSET(BP_PORT(bp), fp->cl_id);
+}
+
+
 #ifdef BCM_CNIC
+static inline u8 bnx2x_cnic_eth_cl_id(struct bnx2x *bp, u8 cl_idx)
+{
+        return bp->cnic_base_cl_id + cl_idx +
+                (bp->pf_num >> 1) * NONE_ETH_CONTEXT_USE;
+}
+
+static inline u8 bnx2x_cnic_fw_sb_id(struct bnx2x *bp)
+{
+
+        /* the 'first' id is allocated for the cnic */
+        return bp->base_fw_ndsb;
+}
+
+static inline u8 bnx2x_cnic_igu_sb_id(struct bnx2x *bp)
+{
+        return bp->igu_base_sb;
+}
+
+
 static inline void bnx2x_init_fcoe_fp(struct bnx2x *bp)
 {
-        bnx2x_fcoe(bp, cl_id) = BNX2X_FCOE_ETH_CL_ID +
-                BP_E1HVN(bp) * NONE_ETH_CONTEXT_USE;
+        struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);
+        unsigned long q_type = 0;
+
+        bnx2x_fcoe(bp, cl_id) = bnx2x_cnic_eth_cl_id(bp,
+                                                     BNX2X_FCOE_ETH_CL_ID_IDX);
+        /** Current BNX2X_FCOE_ETH_CID deffinition implies not more than
+         *  16 ETH clients per function when CNIC is enabled!
+         *
+         *  Fix it ASAP!!!
+         */
         bnx2x_fcoe(bp, cid) = BNX2X_FCOE_ETH_CID;
         bnx2x_fcoe(bp, fw_sb_id) = DEF_SB_ID;
         bnx2x_fcoe(bp, igu_sb_id) = bp->igu_dsb_id;
         bnx2x_fcoe(bp, bp) = bp;
-        bnx2x_fcoe(bp, state) = BNX2X_FP_STATE_CLOSED;
         bnx2x_fcoe(bp, index) = FCOE_IDX;
         bnx2x_fcoe(bp, rx_cons_sb) = BNX2X_FCOE_L2_RX_INDEX;
         bnx2x_fcoe(bp, tx_cons_sb) = BNX2X_FCOE_L2_TX_INDEX;
         /* qZone id equals to FW (per path) client id */
-        bnx2x_fcoe(bp, cl_qzone_id) = bnx2x_fcoe(bp, cl_id) +
-                BP_PORT(bp)*(CHIP_IS_E2(bp) ? ETH_MAX_RX_CLIENTS_E2 :
-                                ETH_MAX_RX_CLIENTS_E1H);
+        bnx2x_fcoe(bp, cl_qzone_id) = bnx2x_fp_qzone_id(fp);
         /* init shortcut */
-        bnx2x_fcoe(bp, ustorm_rx_prods_offset) = CHIP_IS_E2(bp) ?
-            USTORM_RX_PRODS_E2_OFFSET(bnx2x_fcoe(bp, cl_qzone_id)) :
-            USTORM_RX_PRODS_E1X_OFFSET(BP_PORT(bp), bnx2x_fcoe_fp(bp)->cl_id);
-
+        bnx2x_fcoe(bp, ustorm_rx_prods_offset) =
+                bnx2x_rx_ustorm_prods_offset(fp);
+
+        /* Configure Queue State object */
+        __set_bit(BNX2X_Q_TYPE_HAS_RX, &q_type);
+        __set_bit(BNX2X_Q_TYPE_HAS_TX, &q_type);
+        bnx2x_init_queue_obj(bp, &fp->q_obj, fp->cl_id, fp->cid, BP_FUNC(bp),
+                bnx2x_sp(bp, q_rdata), bnx2x_sp_mapping(bp, q_rdata),
+                              q_type);
+
+        DP(NETIF_MSG_IFUP, "queue[%d]: bnx2x_init_sb(%p,%p) cl_id %d fw_sb %d "
+                           "igu_sb %d\n",
+           fp->index, bp, fp->status_blk.e2_sb, fp->cl_id, fp->fw_sb_id,
+           fp->igu_sb_id);
 }
 #endif
 
+static inline int bnx2x_clean_tx_queue(struct bnx2x *bp,
+                                       struct bnx2x_fastpath *fp)
+{
+        int cnt = 1000;
+
+        while (bnx2x_has_tx_work_unload(fp)) {
+                if (!cnt) {
+                        BNX2X_ERR("timeout waiting for queue[%d]: "
+                                 "fp->tx_pkt_prod(%d) != fp->tx_pkt_cons(%d)\n",
+                                  fp->index, fp->tx_pkt_prod, fp->tx_pkt_cons);
+#ifdef BNX2X_STOP_ON_ERROR
+                        bnx2x_panic();
+                        return -EBUSY;
+#else
+                        break;
+#endif
+                }
+                cnt--;
+                usleep_range(1000, 1000);
+        }
+
+        return 0;
+}
+
 int bnx2x_get_link_cfg_idx(struct bnx2x *bp);
 
 static inline void __storm_memset_struct(struct bnx2x *bp,
@@ -1071,48 +1339,81 @@ static inline void __storm_memset_struct(struct bnx2x *bp,
                 REG_WR(bp, addr + (i * 4), data[i]);
 }
 
-static inline void storm_memset_mac_filters(struct bnx2x *bp,
-                        struct tstorm_eth_mac_filter_config *mac_filters,
-                        u16 abs_fid)
+static inline void storm_memset_func_cfg(struct bnx2x *bp,
+                                struct tstorm_eth_function_common_config *tcfg,
+                                u16 abs_fid)
 {
-        size_t size = sizeof(struct tstorm_eth_mac_filter_config);
+        size_t size = sizeof(struct tstorm_eth_function_common_config);
 
         u32 addr = BAR_TSTRORM_INTMEM +
-                        TSTORM_MAC_FILTER_CONFIG_OFFSET(abs_fid);
+                        TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid);
 
-        __storm_memset_struct(bp, addr, size, (u32 *)mac_filters);
+        __storm_memset_struct(bp, addr, size, (u32 *)tcfg);
 }
 
 static inline void storm_memset_cmng(struct bnx2x *bp,
                                 struct cmng_struct_per_port *cmng,
                                 u8 port)
 {
-        size_t size =
-                sizeof(struct rate_shaping_vars_per_port) +
-                sizeof(struct fairness_vars_per_port) +
-                sizeof(struct safc_struct_per_port) +
-                sizeof(struct pfc_struct_per_port);
+        size_t size = sizeof(struct cmng_struct_per_port);
 
         u32 addr = BAR_XSTRORM_INTMEM +
                         XSTORM_CMNG_PER_PORT_VARS_OFFSET(port);
 
         __storm_memset_struct(bp, addr, size, (u32 *)cmng);
+}
+
+/**
+ * bnx2x_wait_sp_comp - wait for the outstanding SP commands.
+ *
+ * @bp:         driver handle
+ * @mask:       bits that need to be cleared
+ */
+static inline bool bnx2x_wait_sp_comp(struct bnx2x *bp, unsigned long mask)
+{
+        int tout = 5000; /* Wait for 5 secs tops */
+
+        while (tout--) {
+                smp_mb();
+                netif_addr_lock_bh(bp->dev);
+                if (!(bp->sp_state & mask)) {
+                        netif_addr_unlock_bh(bp->dev);
+                        return true;
+                }
+                netif_addr_unlock_bh(bp->dev);
 
-        addr += size + 4 /* SKIP DCB+LLFC */;
-        size = sizeof(struct cmng_struct_per_port) -
-                size /* written */ - 4 /*skipped*/;
+                usleep_range(1000, 1000);
+        }
+
+        smp_mb();
+
+        netif_addr_lock_bh(bp->dev);
+        if (bp->sp_state & mask) {
+                BNX2X_ERR("Filtering completion timed out. sp_state 0x%lx, "
+                          "mask 0x%lx\n", bp->sp_state, mask);
+                netif_addr_unlock_bh(bp->dev);
+                return false;
+        }
+        netif_addr_unlock_bh(bp->dev);
 
-        __storm_memset_struct(bp, addr, size,
-                              (u32 *)(cmng->traffic_type_to_priority_cos));
+        return true;
 }
 
-/* HW Lock for shared dual port PHYs */
+/**
+ * bnx2x_set_ctx_validation - set CDU context validation values
+ *
+ * @bp:         driver handle
+ * @cxt:        context of the connection on the host memory
+ * @cid:        SW CID of the connection to be configured
+ */
+void bnx2x_set_ctx_validation(struct bnx2x *bp, struct eth_context *cxt,
+                              u32 cid);
+
+void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, u8 fw_sb_id,
+                                    u8 sb_index, u8 disable, u16 usec);
 void bnx2x_acquire_phy_lock(struct bnx2x *bp);
 void bnx2x_release_phy_lock(struct bnx2x *bp);
 
-void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, u16 fw_sb_id,
-                                        u8 sb_index, u8 disable, u16 usec);
-
 /**
  * bnx2x_extract_max_cfg - extract MAX BW part from MF configuration.
  *
diff --git a/drivers/net/bnx2x/bnx2x_dcb.c b/drivers/net/bnx2x/bnx2x_dcb.c
index 410a49e571ac..aaed9f09c329 100644
--- a/drivers/net/bnx2x/bnx2x_dcb.c
+++ b/drivers/net/bnx2x/bnx2x_dcb.c
@@ -55,15 +55,14 @@ static void bnx2x_pfc_set(struct bnx2x *bp)
         struct bnx2x_nig_brb_pfc_port_params pfc_params = {0};
         u32 pri_bit, val = 0;
         u8 pri;
+        int i;
 
         /* Tx COS configuration */
-        if (bp->dcbx_port_params.ets.cos_params[0].pauseable)
-                pfc_params.rx_cos0_priority_mask =
-                        bp->dcbx_port_params.ets.cos_params[0].pri_bitmask;
-        if (bp->dcbx_port_params.ets.cos_params[1].pauseable)
-                pfc_params.rx_cos1_priority_mask =
-                        bp->dcbx_port_params.ets.cos_params[1].pri_bitmask;
-
+        for (i = 0; i < bp->dcbx_port_params.ets.num_of_cos; i++)
+                if (bp->dcbx_port_params.ets.cos_params[i].pauseable)
+                        pfc_params.rx_cos_priority_mask[i] =
+                                bp->dcbx_port_params.ets.
+                                        cos_params[i].pri_bitmask;
 
         /**
          * Rx COS configuration
@@ -378,7 +377,7 @@ static int bnx2x_dcbx_read_mib(struct bnx2x *bp,
 
 static void bnx2x_pfc_set_pfc(struct bnx2x *bp)
 {
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 if (BP_PORT(bp)) {
                         BNX2X_ERR("4 port mode is not supported");
                         return;
@@ -406,7 +405,7 @@ static void bnx2x_dcbx_stop_hw_tx(struct bnx2x *bp)
                       0 /* connectionless */,
                       0 /* dataHi is zero */,
                       0 /* dataLo is zero */,
-                      1 /* common */);
+                      NONE_CONNECTION_TYPE);
 }
 
 static void bnx2x_dcbx_resume_hw_tx(struct bnx2x *bp)
@@ -417,7 +416,7 @@ static void bnx2x_dcbx_resume_hw_tx(struct bnx2x *bp)
                       0, /* connectionless */
                       U64_HI(bnx2x_sp_mapping(bp, pfc_config)),
                       U64_LO(bnx2x_sp_mapping(bp, pfc_config)),
-                      1  /* commmon */);
+                      NONE_CONNECTION_TYPE);
 }
 
 static void bnx2x_dcbx_update_ets_params(struct bnx2x *bp)
@@ -425,7 +424,7 @@ static void bnx2x_dcbx_update_ets_params(struct bnx2x *bp)
         struct bnx2x_dcbx_pg_params *ets = &(bp->dcbx_port_params.ets);
         u8      status = 0;
 
-        bnx2x_ets_disabled(&bp->link_params);
+        bnx2x_ets_disabled(&bp->link_params/*, &bp->link_vars*/);
 
         if (!ets->enabled)
                 return;
@@ -527,6 +526,7 @@ static int bnx2x_dcbx_read_shmem_neg_results(struct bnx2x *bp)
                 BNX2X_ERR("FW doesn't support dcbx_neg_res_offset\n");
                 return -EINVAL;
         }
+
         rc = bnx2x_dcbx_read_mib(bp, (u32 *)&local_mib, dcbx_neg_res_offset,
                                  DCBX_READ_LOCAL_MIB);
 
@@ -563,15 +563,6 @@ u8 bnx2x_dcbx_dcbnl_app_idtype(struct dcbx_app_priority_entry *ent)
                 DCB_APP_IDTYPE_ETHTYPE;
 }
 
-static inline
-void bnx2x_dcbx_invalidate_local_apps(struct bnx2x *bp)
-{
-        int i;
-        for (i = 0; i < DCBX_MAX_APP_PROTOCOL; i++)
-                bp->dcbx_local_feat.app.app_pri_tbl[i].appBitfield &=
-                                                        ~DCBX_APP_ENTRY_VALID;
-}
-
 int bnx2x_dcbnl_update_applist(struct bnx2x *bp, bool delall)
 {
         int i, err = 0;
@@ -597,32 +588,28 @@ int bnx2x_dcbnl_update_applist(struct bnx2x *bp, bool delall)
 }
 #endif
 
+static inline void bnx2x_update_drv_flags(struct bnx2x *bp, u32 flags, u32 set)
+{
+        if (SHMEM2_HAS(bp, drv_flags)) {
+                u32 drv_flags;
+                bnx2x_acquire_hw_lock(bp, HW_LOCK_DRV_FLAGS);
+                drv_flags = SHMEM2_RD(bp, drv_flags);
+
+                if (set)
+                        SET_FLAGS(drv_flags, flags);
+                else
+                        RESET_FLAGS(drv_flags, flags);
+
+                SHMEM2_WR(bp, drv_flags, drv_flags);
+                DP(NETIF_MSG_HW, "drv_flags 0x%08x\n", drv_flags);
+                bnx2x_release_hw_lock(bp, HW_LOCK_DRV_FLAGS);
+        }
+}
+
 void bnx2x_dcbx_set_params(struct bnx2x *bp, u32 state)
 {
         switch (state) {
         case BNX2X_DCBX_STATE_NEG_RECEIVED:
-#ifdef BCM_CNIC
-                if (bp->state != BNX2X_STATE_OPENING_WAIT4_LOAD) {
-                        struct cnic_ops *c_ops;
-                        struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
-                        bp->flags |= NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG;
-                        cp->drv_state |= CNIC_DRV_STATE_NO_ISCSI_OOO;
-                        cp->drv_state |= CNIC_DRV_STATE_NO_ISCSI;
-
-                        rcu_read_lock();
-                        c_ops = rcu_dereference(bp->cnic_ops);
-                        if (c_ops) {
-                                bnx2x_cnic_notify(bp, CNIC_CTL_STOP_ISCSI_CMD);
-                                rcu_read_unlock();
-                                return;
-                        }
-                        rcu_read_unlock();
-                }
-
-                /* fall through if no CNIC initialized  */
-        case BNX2X_DCBX_STATE_ISCSI_STOPPED:
-#endif
-
                 {
                         DP(NETIF_MSG_LINK, "BNX2X_DCBX_STATE_NEG_RECEIVED\n");
 #ifdef BCM_DCBNL
@@ -646,41 +633,28 @@ void bnx2x_dcbx_set_params(struct bnx2x *bp, u32 state)
                         bnx2x_get_dcbx_drv_param(bp, &bp->dcbx_local_feat,
                                                  bp->dcbx_error);
 
-                        if (bp->state != BNX2X_STATE_OPENING_WAIT4_LOAD) {
-#ifdef BCM_DCBNL
-                                /**
-                                 * Add new app tlvs to dcbnl
-                                 */
-                                bnx2x_dcbnl_update_applist(bp, false);
-#endif
-                                bnx2x_dcbx_stop_hw_tx(bp);
-                                return;
-                        }
-                        /* fall through */
+                        /* mark DCBX result for PMF migration */
+                        bnx2x_update_drv_flags(bp, DRV_FLAGS_DCB_CONFIGURED, 1);
 #ifdef BCM_DCBNL
                         /**
-                         * Invalidate the local app tlvs if they are not added
-                         * to the dcbnl app list to avoid deleting them from
-                         * the list later on
+                         * Add new app tlvs to dcbnl
                          */
-                        bnx2x_dcbx_invalidate_local_apps(bp);
+                        bnx2x_dcbnl_update_applist(bp, false);
 #endif
+                        bnx2x_dcbx_stop_hw_tx(bp);
+
+                        return;
                 }
         case BNX2X_DCBX_STATE_TX_PAUSED:
                 DP(NETIF_MSG_LINK, "BNX2X_DCBX_STATE_TX_PAUSED\n");
                 bnx2x_pfc_set_pfc(bp);
 
                 bnx2x_dcbx_update_ets_params(bp);
-                if (bp->state != BNX2X_STATE_OPENING_WAIT4_LOAD) {
-                        bnx2x_dcbx_resume_hw_tx(bp);
-                        return;
-                }
-                /* fall through */
+                bnx2x_dcbx_resume_hw_tx(bp);
+                return;
         case BNX2X_DCBX_STATE_TX_RELEASED:
                 DP(NETIF_MSG_LINK, "BNX2X_DCBX_STATE_TX_RELEASED\n");
-                if (bp->state != BNX2X_STATE_OPENING_WAIT4_LOAD)
-                        bnx2x_fw_command(bp, DRV_MSG_CODE_DCBX_PMF_DRV_OK, 0);
-
+                bnx2x_fw_command(bp, DRV_MSG_CODE_DCBX_PMF_DRV_OK, 0);
                 return;
         default:
                 BNX2X_ERR("Unknown DCBX_STATE\n");
@@ -868,7 +842,7 @@ static void bnx2x_dcbx_admin_mib_updated_params(struct bnx2x *bp,
 
 void bnx2x_dcbx_set_state(struct bnx2x *bp, bool dcb_on, u32 dcbx_enabled)
 {
-        if (CHIP_IS_E2(bp) && !CHIP_MODE_IS_4_PORT(bp)) {
+        if (!CHIP_IS_E1x(bp) && !CHIP_MODE_IS_4_PORT(bp)) {
                 bp->dcb_state = dcb_on;
                 bp->dcbx_enabled = dcbx_enabled;
         } else {
@@ -966,7 +940,7 @@ void bnx2x_dcbx_init(struct bnx2x *bp)
         DP(NETIF_MSG_LINK, "dcb_state %d bp->port.pmf %d\n",
            bp->dcb_state, bp->port.pmf);
 
-        if (bp->dcb_state ==  BNX2X_DCB_STATE_ON && bp->port.pmf &&
+        if (bp->dcb_state == BNX2X_DCB_STATE_ON && bp->port.pmf &&
             SHMEM2_HAS(bp, dcbx_lldp_params_offset)) {
                 dcbx_lldp_params_offset =
                         SHMEM2_RD(bp, dcbx_lldp_params_offset);
@@ -974,6 +948,8 @@ void bnx2x_dcbx_init(struct bnx2x *bp)
                 DP(NETIF_MSG_LINK, "dcbx_lldp_params_offset 0x%x\n",
                    dcbx_lldp_params_offset);
 
+                bnx2x_update_drv_flags(bp, DRV_FLAGS_DCB_CONFIGURED, 0);
+
                 if (SHMEM_LLDP_DCBX_PARAMS_NONE != dcbx_lldp_params_offset) {
                         bnx2x_dcbx_lldp_updated_params(bp,
                                                        dcbx_lldp_params_offset);
@@ -981,46 +957,12 @@ void bnx2x_dcbx_init(struct bnx2x *bp)
                         bnx2x_dcbx_admin_mib_updated_params(bp,
                                 dcbx_lldp_params_offset);
 
-                        /* set default configuration BC has */
-                        bnx2x_dcbx_set_params(bp,
-                                              BNX2X_DCBX_STATE_NEG_RECEIVED);
-
+                        /* Let HW start negotiation */
                         bnx2x_fw_command(bp,
                                          DRV_MSG_CODE_DCBX_ADMIN_PMF_MSG, 0);
                 }
         }
 }
-
-void bnx2x_dcb_init_intmem_pfc(struct bnx2x *bp)
-{
-        struct priority_cos pricos[MAX_PFC_TRAFFIC_TYPES];
-        u32 i = 0, addr;
-        memset(pricos, 0, sizeof(pricos));
-        /* Default initialization */
-        for (i = 0; i < MAX_PFC_TRAFFIC_TYPES; i++)
-                pricos[i].priority = LLFC_TRAFFIC_TYPE_TO_PRIORITY_UNMAPPED;
-
-        /* Store per port struct to internal memory */
-        addr = BAR_XSTRORM_INTMEM +
-                        XSTORM_CMNG_PER_PORT_VARS_OFFSET(BP_PORT(bp)) +
-                        offsetof(struct cmng_struct_per_port,
-                                 traffic_type_to_priority_cos);
-        __storm_memset_struct(bp, addr, sizeof(pricos), (u32 *)pricos);
-
-
-        /* LLFC disabled.*/
-        REG_WR8(bp , BAR_XSTRORM_INTMEM +
-                    XSTORM_CMNG_PER_PORT_VARS_OFFSET(BP_PORT(bp)) +
-                    offsetof(struct cmng_struct_per_port, llfc_mode),
-                        LLFC_MODE_NONE);
-
-        /* DCBX disabled.*/
-        REG_WR8(bp , BAR_XSTRORM_INTMEM +
-                    XSTORM_CMNG_PER_PORT_VARS_OFFSET(BP_PORT(bp)) +
-                    offsetof(struct cmng_struct_per_port, dcb_enabled),
-                        DCB_DISABLED);
-}
-
 static void
 bnx2x_dcbx_print_cos_params(struct bnx2x *bp,
                             struct flow_control_configuration *pfc_fw_cfg)
@@ -1591,13 +1533,7 @@ static void bnx2x_pfc_fw_struct_e2(struct bnx2x *bp)
 
         /* Fw version should be incremented each update */
         pfc_fw_cfg->dcb_version = ++bp->dcb_version;
-        pfc_fw_cfg->dcb_enabled = DCB_ENABLED;
-
-        /* Default initialization */
-        for (pri = 0; pri < MAX_PFC_TRAFFIC_TYPES ; pri++) {
-                tt2cos[pri].priority = LLFC_TRAFFIC_TYPE_TO_PRIORITY_UNMAPPED;
-                tt2cos[pri].cos = 0;
-        }
+        pfc_fw_cfg->dcb_enabled = 1;
 
         /* Fill priority parameters */
         for (pri = 0; pri < LLFC_DRIVER_TRAFFIC_TYPE_MAX; pri++) {
@@ -1605,14 +1541,37 @@ static void bnx2x_pfc_fw_struct_e2(struct bnx2x *bp)
                 pri_bit = 1 << tt2cos[pri].priority;
 
                 /* Fill COS parameters based on COS calculated to
-                 * make it more generally for future use */
+                 * make it more general for future use */
                 for (cos = 0; cos < bp->dcbx_port_params.ets.num_of_cos; cos++)
                         if (bp->dcbx_port_params.ets.cos_params[cos].
                                                 pri_bitmask & pri_bit)
                                         tt2cos[pri].cos = cos;
         }
+
+        /* we never want the FW to add a 0 vlan tag */
+        pfc_fw_cfg->dont_add_pri_0_en = 1;
+
         bnx2x_dcbx_print_cos_params(bp, pfc_fw_cfg);
 }
+
+void bnx2x_dcbx_pmf_update(struct bnx2x *bp)
+{
+        /* if we need to syncronize DCBX result from prev PMF
+         * read it from shmem and update bp accordingly
+         */
+        if (SHMEM2_HAS(bp, drv_flags) &&
+           GET_FLAGS(SHMEM2_RD(bp, drv_flags), DRV_FLAGS_DCB_CONFIGURED)) {
+                /* Read neg results if dcbx is in the FW */
+                if (bnx2x_dcbx_read_shmem_neg_results(bp))
+                        return;
+
+                bnx2x_dump_dcbx_drv_param(bp, &bp->dcbx_local_feat,
+                                          bp->dcbx_error);
+                bnx2x_get_dcbx_drv_param(bp, &bp->dcbx_local_feat,
+                                         bp->dcbx_error);
+        }
+}
+
 /* DCB netlink */
 #ifdef BCM_DCBNL
 
diff --git a/drivers/net/bnx2x/bnx2x_dcb.h b/drivers/net/bnx2x/bnx2x_dcb.h
index 5bedd85e94df..7887834cd65c 100644
--- a/drivers/net/bnx2x/bnx2x_dcb.h
+++ b/drivers/net/bnx2x/bnx2x_dcb.h
@@ -179,9 +179,6 @@ void bnx2x_dcbx_set_state(struct bnx2x *bp, bool dcb_on, u32 dcbx_enabled);
 
 enum {
         BNX2X_DCBX_STATE_NEG_RECEIVED = 0x1,
-#ifdef BCM_CNIC
-        BNX2X_DCBX_STATE_ISCSI_STOPPED,
-#endif
         BNX2X_DCBX_STATE_TX_PAUSED,
         BNX2X_DCBX_STATE_TX_RELEASED
 };
diff --git a/drivers/net/bnx2x/bnx2x_dump.h b/drivers/net/bnx2x/bnx2x_dump.h
index fb3ff7c4d7ca..407531a9ab13 100644
--- a/drivers/net/bnx2x/bnx2x_dump.h
+++ b/drivers/net/bnx2x/bnx2x_dump.h
@@ -25,34 +25,55 @@
 
 
 /*definitions */
-#define XSTORM_WAITP_ADDR    0x2b8a80
-#define TSTORM_WAITP_ADDR    0x1b8a80
-#define USTORM_WAITP_ADDR    0x338a80
-#define CSTORM_WAITP_ADDR    0x238a80
-#define TSTORM_CAM_MODE         0x1B1440
-
-#define MAX_TIMER_PENDING      200
-#define TIMER_SCAN_DONT_CARE   0xFF
-#define RI_E1                   0x1
-#define RI_E1H                  0x2
-#define RI_E2                   0x4
-#define RI_ONLINE               0x100
-#define RI_PATH0_DUMP           0x200
-#define RI_PATH1_DUMP           0x400
-#define RI_E1_OFFLINE           (RI_E1)
-#define RI_E1_ONLINE            (RI_E1 | RI_ONLINE)
-#define RI_E1H_OFFLINE          (RI_E1H)
-#define RI_E1H_ONLINE           (RI_E1H | RI_ONLINE)
-#define RI_E2_OFFLINE           (RI_E2)
-#define RI_E2_ONLINE            (RI_E2 | RI_ONLINE)
-#define RI_E1E1H_OFFLINE        (RI_E1 | RI_E1H)
-#define RI_E1E1H_ONLINE         (RI_E1 | RI_E1H | RI_ONLINE)
-#define RI_E1HE2_OFFLINE        (RI_E2 | RI_E1H)
-#define RI_E1HE2_ONLINE         (RI_E2 | RI_E1H | RI_ONLINE)
-#define RI_E1E2_OFFLINE         (RI_E2 | RI_E1)
-#define RI_E1E2_ONLINE          (RI_E2 | RI_E1 | RI_ONLINE)
-#define RI_ALL_OFFLINE         (RI_E1 | RI_E1H | RI_E2)
-#define RI_ALL_ONLINE          (RI_E1 | RI_E1H | RI_E2 | RI_ONLINE)
+#define XSTORM_WAITP_ADDR       0x2b8a80
+#define TSTORM_WAITP_ADDR       0x1b8a80
+#define USTORM_WAITP_ADDR       0x338a80
+#define CSTORM_WAITP_ADDR       0x238a80
+#define TSTORM_CAM_MODE 0x1B1440
+
+#define MAX_TIMER_PENDING       200
+#define TIMER_SCAN_DONT_CARE    0xFF
+#define RI_E1                           0x1
+#define RI_E1H                          0x2
+#define RI_E2                           0x4
+#define RI_E3                           0x8
+#define RI_ONLINE                       0x100
+#define RI_PATH0_DUMP                   0x200
+#define RI_PATH1_DUMP                   0x400
+#define RI_E1_OFFLINE                   (RI_E1)
+#define RI_E1_ONLINE                    (RI_E1 | RI_ONLINE)
+#define RI_E1H_OFFLINE                  (RI_E1H)
+#define RI_E1H_ONLINE                   (RI_E1H | RI_ONLINE)
+#define RI_E2_OFFLINE                   (RI_E2)
+#define RI_E2_ONLINE                    (RI_E2 | RI_ONLINE)
+#define RI_E3_OFFLINE                   (RI_E3)
+#define RI_E3_ONLINE                    (RI_E3 | RI_ONLINE)
+#define RI_E1E1H_OFFLINE                (RI_E1 | RI_E1H)
+#define RI_E1E1H_ONLINE                 (RI_E1 | RI_E1H | RI_ONLINE)
+#define RI_E1E1HE2_OFFLINE              (RI_E1 | RI_E1H | RI_E2)
+#define RI_E1E1HE2_ONLINE               (RI_E1 | RI_E1H | RI_E2 | RI_ONLINE)
+#define RI_E1HE2_OFFLINE                (RI_E2 | RI_E1H)
+#define RI_E1HE2_ONLINE                 (RI_E2 | RI_E1H | RI_ONLINE)
+#define RI_E1E2_OFFLINE                 (RI_E2 | RI_E1)
+#define RI_E1E2_ONLINE                  (RI_E2 | RI_E1 | RI_ONLINE)
+#define RI_E1E3_OFFLINE                 (RI_E1 | RI_E3)
+#define RI_E1E3_ONLINE                  (RI_E1 | RI_E3 | RI_ONLINE)
+#define RI_E1HE3_OFFLINE                (RI_E1H | RI_E3)
+#define RI_E1HE3_ONLINE                 (RI_E1H | RI_E3 | RI_ONLINE)
+#define RI_E2E3_OFFLINE                 (RI_E2 | RI_E3)
+#define RI_E2E3_ONLINE                  (RI_E2 | RI_E3 | RI_ONLINE)
+#define RI_E1E1HE3_OFFLINE              (RI_E1 | RI_E1H | RI_E3)
+#define RI_E1E1HE3_ONLINE               (RI_E1 | RI_E1H | RI_E3 | RI_ONLINE)
+#define RI_E1HE2E3_OFFLINE              (RI_E2 | RI_E1H | RI_E3)
+#define RI_E1HE2E3_ONLINE               (RI_E2 | RI_E1H | RI_E3 | RI_ONLINE)
+#define RI_E1E2E3_OFFLINE               (RI_E2 | RI_E1 | RI_E3)
+#define RI_E1E2E3_ONLINE                (RI_E2 | RI_E1 | RI_E3 | RI_ONLINE)
+#define RI_ALL_OFFLINE                  (RI_E1 | RI_E1H | RI_E2 | RI_E3)
+#define RI_ALL_ONLINE           (RI_E1 | RI_E1H | RI_E2 | RI_E3 | RI_ONLINE)
+
+#define DBG_DMP_TRACE_BUFFER_SIZE       0x800
+#define DBG_DMP_TRACE_BUFFER_OFFSET(shmem0_offset) \
+        ((shmem0_offset) - DBG_DMP_TRACE_BUFFER_SIZE)
 
 struct dump_sign {
         u32 time_stamp;
@@ -86,185 +107,255 @@ struct wreg_addr {
         u16 info;
 };
 
-#define REGS_COUNT                      834
-static const struct reg_addr reg_addrs[REGS_COUNT] = {
+static const struct reg_addr reg_addrs[] = {
         { 0x2000, 341, RI_ALL_ONLINE }, { 0x2800, 103, RI_ALL_ONLINE },
         { 0x3000, 287, RI_ALL_ONLINE }, { 0x3800, 331, RI_ALL_ONLINE },
-        { 0x8800, 6, RI_ALL_ONLINE }, { 0x8818, 1, RI_E1HE2_ONLINE },
-        { 0x9000, 164, RI_E2_ONLINE }, { 0x9400, 33, RI_E2_ONLINE },
-        { 0xa000, 27, RI_ALL_ONLINE }, { 0xa06c, 1, RI_E1E1H_ONLINE },
-        { 0xa070, 71, RI_ALL_ONLINE }, { 0xa18c, 4, RI_E1E1H_ONLINE },
-        { 0xa19c, 62, RI_ALL_ONLINE }, { 0xa294, 2, RI_E1E1H_ONLINE },
-        { 0xa29c, 56, RI_ALL_ONLINE }, { 0xa39c, 7, RI_E1HE2_ONLINE },
-        { 0xa3c0, 3, RI_E1HE2_ONLINE }, { 0xa3d0, 1, RI_E1HE2_ONLINE },
-        { 0xa3d8, 1, RI_E1HE2_ONLINE }, { 0xa3e0, 1, RI_E1HE2_ONLINE },
-        { 0xa3e8, 1, RI_E1HE2_ONLINE }, { 0xa3f0, 1, RI_E1HE2_ONLINE },
-        { 0xa3f8, 1, RI_E1HE2_ONLINE }, { 0xa400, 43, RI_ALL_ONLINE },
-        { 0xa4ac, 2, RI_E1E1H_ONLINE }, { 0xa4b4, 1, RI_ALL_ONLINE },
+        { 0x8800, 6, RI_ALL_ONLINE }, { 0x8818, 1, RI_E1HE2E3_ONLINE },
+        { 0x9000, 147, RI_E2E3_ONLINE }, { 0x924c, 1, RI_E2_ONLINE },
+        { 0x9250, 16, RI_E2E3_ONLINE }, { 0x9400, 33, RI_E2E3_ONLINE },
+        { 0x9484, 5, RI_E3_ONLINE }, { 0xa000, 27, RI_ALL_ONLINE },
+        { 0xa06c, 1, RI_E1E1H_ONLINE }, { 0xa070, 71, RI_ALL_ONLINE },
+        { 0xa18c, 4, RI_E1E1H_ONLINE }, { 0xa19c, 62, RI_ALL_ONLINE },
+        { 0xa294, 2, RI_E1E1H_ONLINE }, { 0xa29c, 2, RI_ALL_ONLINE },
+        { 0xa2a4, 2, RI_E1E1HE2_ONLINE }, { 0xa2ac, 52, RI_ALL_ONLINE },
+        { 0xa39c, 7, RI_E1HE2E3_ONLINE }, { 0xa3b8, 2, RI_E3_ONLINE },
+        { 0xa3c0, 3, RI_E1HE2E3_ONLINE }, { 0xa3d0, 1, RI_E1HE2E3_ONLINE },
+        { 0xa3d8, 1, RI_E1HE2E3_ONLINE }, { 0xa3e0, 1, RI_E1HE2E3_ONLINE },
+        { 0xa3e8, 1, RI_E1HE2E3_ONLINE }, { 0xa3f0, 1, RI_E1HE2E3_ONLINE },
+        { 0xa3f8, 1, RI_E1HE2E3_ONLINE }, { 0xa400, 40, RI_ALL_ONLINE },
+        { 0xa4a0, 1, RI_E1E1HE2_ONLINE }, { 0xa4a4, 2, RI_ALL_ONLINE },
+        { 0xa4ac, 2, RI_E1E1H_ONLINE }, { 0xa4b4, 1, RI_E1E1HE2_ONLINE },
         { 0xa4b8, 2, RI_E1E1H_ONLINE }, { 0xa4c0, 3, RI_ALL_ONLINE },
-        { 0xa4cc, 5, RI_E1E1H_ONLINE }, { 0xa4e0, 9, RI_ALL_ONLINE },
-        { 0xa504, 1, RI_E1E1H_ONLINE }, { 0xa508, 3, RI_ALL_ONLINE },
-        { 0xa518, 1, RI_ALL_ONLINE }, { 0xa520, 1, RI_ALL_ONLINE },
-        { 0xa528, 1, RI_ALL_ONLINE }, { 0xa530, 1, RI_ALL_ONLINE },
-        { 0xa538, 1, RI_ALL_ONLINE }, { 0xa540, 1, RI_ALL_ONLINE },
-        { 0xa548, 1, RI_E1E1H_ONLINE }, { 0xa550, 1, RI_E1E1H_ONLINE },
-        { 0xa558, 1, RI_E1E1H_ONLINE }, { 0xa560, 1, RI_E1E1H_ONLINE },
-        { 0xa568, 1, RI_E1E1H_ONLINE }, { 0xa570, 1, RI_ALL_ONLINE },
-        { 0xa580, 1, RI_ALL_ONLINE }, { 0xa590, 1, RI_ALL_ONLINE },
-        { 0xa5a0, 1, RI_ALL_ONLINE }, { 0xa5c0, 1, RI_ALL_ONLINE },
-        { 0xa5e0, 1, RI_E1HE2_ONLINE }, { 0xa5e8, 1, RI_E1HE2_ONLINE },
-        { 0xa5f0, 1, RI_E1HE2_ONLINE }, { 0xa5f8, 10, RI_E1HE2_ONLINE },
-        { 0xa620, 111, RI_E2_ONLINE }, { 0xa800, 51, RI_E2_ONLINE },
-        { 0xa8d4, 4, RI_E2_ONLINE }, { 0xa8e8, 1, RI_E2_ONLINE },
-        { 0xa8f0, 1, RI_E2_ONLINE }, { 0x10000, 236, RI_ALL_ONLINE },
-        { 0x10400, 57, RI_ALL_ONLINE }, { 0x104e8, 2, RI_ALL_ONLINE },
+        { 0xa4cc, 5, RI_E1E1H_ONLINE }, { 0xa4e0, 3, RI_ALL_ONLINE },
+        { 0xa4fc, 2, RI_ALL_ONLINE }, { 0xa504, 1, RI_E1E1H_ONLINE },
+        { 0xa508, 3, RI_ALL_ONLINE }, { 0xa518, 1, RI_ALL_ONLINE },
+        { 0xa520, 1, RI_ALL_ONLINE }, { 0xa528, 1, RI_ALL_ONLINE },
+        { 0xa530, 1, RI_ALL_ONLINE }, { 0xa538, 1, RI_ALL_ONLINE },
+        { 0xa540, 1, RI_ALL_ONLINE }, { 0xa548, 1, RI_E1E1H_ONLINE },
+        { 0xa550, 1, RI_E1E1H_ONLINE }, { 0xa558, 1, RI_E1E1H_ONLINE },
+        { 0xa560, 1, RI_E1E1H_ONLINE }, { 0xa568, 1, RI_E1E1H_ONLINE },
+        { 0xa570, 1, RI_ALL_ONLINE }, { 0xa580, 1, RI_ALL_ONLINE },
+        { 0xa590, 1, RI_ALL_ONLINE }, { 0xa5a0, 1, RI_E1E1HE2_ONLINE },
+        { 0xa5c0, 1, RI_ALL_ONLINE }, { 0xa5e0, 1, RI_E1HE2E3_ONLINE },
+        { 0xa5e8, 1, RI_E1HE2E3_ONLINE }, { 0xa5f0, 1, RI_E1HE2E3_ONLINE },
+        { 0xa5f8, 1, RI_E1HE2_ONLINE }, { 0xa5fc, 9, RI_E1HE2E3_ONLINE },
+        { 0xa620, 6, RI_E2E3_ONLINE }, { 0xa638, 20, RI_E2_ONLINE },
+        { 0xa688, 42, RI_E2E3_ONLINE }, { 0xa730, 1, RI_E2_ONLINE },
+        { 0xa734, 2, RI_E2E3_ONLINE }, { 0xa73c, 4, RI_E2_ONLINE },
+        { 0xa74c, 5, RI_E2E3_ONLINE }, { 0xa760, 5, RI_E2_ONLINE },
+        { 0xa774, 7, RI_E2E3_ONLINE }, { 0xa790, 15, RI_E2_ONLINE },
+        { 0xa7cc, 4, RI_E2E3_ONLINE }, { 0xa7e0, 6, RI_E3_ONLINE },
+        { 0xa800, 18, RI_E2_ONLINE }, { 0xa848, 33, RI_E2E3_ONLINE },
+        { 0xa8cc, 2, RI_E3_ONLINE }, { 0xa8d4, 4, RI_E2E3_ONLINE },
+        { 0xa8e4, 1, RI_E3_ONLINE }, { 0xa8e8, 1, RI_E2E3_ONLINE },
+        { 0xa8f0, 1, RI_E2E3_ONLINE }, { 0xa8f8, 30, RI_E3_ONLINE },
+        { 0xa974, 73, RI_E3_ONLINE }, { 0xac30, 1, RI_E3_ONLINE },
+        { 0xac40, 1, RI_E3_ONLINE }, { 0xac50, 1, RI_E3_ONLINE },
+        { 0x10000, 9, RI_ALL_ONLINE }, { 0x10024, 1, RI_E1E1HE2_ONLINE },
+        { 0x10028, 5, RI_ALL_ONLINE }, { 0x1003c, 6, RI_E1E1HE2_ONLINE },
+        { 0x10054, 20, RI_ALL_ONLINE }, { 0x100a4, 4, RI_E1E1HE2_ONLINE },
+        { 0x100b4, 11, RI_ALL_ONLINE }, { 0x100e0, 4, RI_E1E1HE2_ONLINE },
+        { 0x100f0, 8, RI_ALL_ONLINE }, { 0x10110, 6, RI_E1E1HE2_ONLINE },
+        { 0x10128, 110, RI_ALL_ONLINE }, { 0x102e0, 4, RI_E1E1HE2_ONLINE },
+        { 0x102f0, 18, RI_ALL_ONLINE }, { 0x10338, 20, RI_E1E1HE2_ONLINE },
+        { 0x10388, 10, RI_ALL_ONLINE }, { 0x10400, 6, RI_E1E1HE2_ONLINE },
+        { 0x10418, 6, RI_ALL_ONLINE }, { 0x10430, 10, RI_E1E1HE2_ONLINE },
+        { 0x10458, 22, RI_ALL_ONLINE }, { 0x104b0, 12, RI_E1E1HE2_ONLINE },
+        { 0x104e0, 1, RI_ALL_ONLINE }, { 0x104e8, 2, RI_ALL_ONLINE },
         { 0x104f4, 2, RI_ALL_ONLINE }, { 0x10500, 146, RI_ALL_ONLINE },
-        { 0x10750, 2, RI_ALL_ONLINE }, { 0x10760, 2, RI_ALL_ONLINE },
-        { 0x10770, 2, RI_ALL_ONLINE }, { 0x10780, 2, RI_ALL_ONLINE },
-        { 0x10790, 2, RI_ALL_ONLINE }, { 0x107a0, 2, RI_ALL_ONLINE },
-        { 0x107b0, 2, RI_ALL_ONLINE }, { 0x107c0, 2, RI_ALL_ONLINE },
-        { 0x107d0, 2, RI_ALL_ONLINE }, { 0x107e0, 2, RI_ALL_ONLINE },
+        { 0x10750, 2, RI_E1E1HE2_ONLINE }, { 0x10760, 2, RI_E1E1HE2_ONLINE },
+        { 0x10770, 2, RI_E1E1HE2_ONLINE }, { 0x10780, 2, RI_E1E1HE2_ONLINE },
+        { 0x10790, 2, RI_ALL_ONLINE }, { 0x107a0, 2, RI_E1E1HE2_ONLINE },
+        { 0x107b0, 2, RI_E1E1HE2_ONLINE }, { 0x107c0, 2, RI_E1E1HE2_ONLINE },
+        { 0x107d0, 2, RI_E1E1HE2_ONLINE }, { 0x107e0, 2, RI_ALL_ONLINE },
         { 0x10880, 2, RI_ALL_ONLINE }, { 0x10900, 2, RI_ALL_ONLINE },
-        { 0x16000, 26, RI_E1HE2_ONLINE }, { 0x16070, 18, RI_E1HE2_ONLINE },
-        { 0x160c0, 27, RI_E1HE2_ONLINE }, { 0x16140, 1, RI_E1HE2_ONLINE },
-        { 0x16160, 1, RI_E1HE2_ONLINE }, { 0x16180, 2, RI_E1HE2_ONLINE },
-        { 0x161c0, 2, RI_E1HE2_ONLINE }, { 0x16204, 5, RI_E1HE2_ONLINE },
-        { 0x18000, 1, RI_E1HE2_ONLINE }, { 0x18008, 1, RI_E1HE2_ONLINE },
-        { 0x18010, 35, RI_E2_ONLINE }, { 0x180a4, 2, RI_E2_ONLINE },
-        { 0x180c0, 191, RI_E2_ONLINE }, { 0x18440, 1, RI_E2_ONLINE },
-        { 0x18460, 1, RI_E2_ONLINE }, { 0x18480, 2, RI_E2_ONLINE },
-        { 0x184c0, 2, RI_E2_ONLINE }, { 0x18500, 15, RI_E2_ONLINE },
-        { 0x20000, 24, RI_ALL_ONLINE }, { 0x20060, 8, RI_ALL_ONLINE },
-        { 0x20080, 94, RI_ALL_ONLINE }, { 0x201f8, 1, RI_E1E1H_ONLINE },
-        { 0x201fc, 1, RI_ALL_ONLINE }, { 0x20200, 1, RI_E1E1H_ONLINE },
-        { 0x20204, 1, RI_ALL_ONLINE }, { 0x20208, 1, RI_E1E1H_ONLINE },
-        { 0x2020c, 39, RI_ALL_ONLINE }, { 0x202c8, 1, RI_E2_ONLINE },
-        { 0x202d8, 4, RI_E2_ONLINE }, { 0x20400, 2, RI_ALL_ONLINE },
-        { 0x2040c, 8, RI_ALL_ONLINE }, { 0x2042c, 18, RI_E1HE2_ONLINE },
-        { 0x20480, 1, RI_ALL_ONLINE }, { 0x20500, 1, RI_ALL_ONLINE },
-        { 0x20600, 1, RI_ALL_ONLINE }, { 0x28000, 1, RI_ALL_ONLINE },
-        { 0x28004, 8191, RI_ALL_OFFLINE }, { 0x30000, 1, RI_ALL_ONLINE },
-        { 0x30004, 16383, RI_ALL_OFFLINE }, { 0x40000, 98, RI_ALL_ONLINE },
-        { 0x401a8, 8, RI_E1HE2_ONLINE }, { 0x401c8, 1, RI_E1H_ONLINE },
-        { 0x401cc, 2, RI_E1HE2_ONLINE }, { 0x401d4, 2, RI_E2_ONLINE },
-        { 0x40200, 4, RI_ALL_ONLINE }, { 0x40220, 18, RI_E2_ONLINE },
-        { 0x40400, 43, RI_ALL_ONLINE }, { 0x404cc, 3, RI_E1HE2_ONLINE },
-        { 0x404e0, 1, RI_E2_ONLINE }, { 0x40500, 2, RI_ALL_ONLINE },
+        { 0x16000, 1, RI_E1HE2_ONLINE }, { 0x16004, 25, RI_E1HE2E3_ONLINE },
+        { 0x16070, 18, RI_E1HE2E3_ONLINE }, { 0x160c0, 7, RI_E1HE2E3_ONLINE },
+        { 0x160dc, 2, RI_E1HE2_ONLINE }, { 0x160e4, 10, RI_E1HE2E3_ONLINE },
+        { 0x1610c, 2, RI_E1HE2_ONLINE }, { 0x16114, 6, RI_E1HE2E3_ONLINE },
+        { 0x16140, 48, RI_E1HE2E3_ONLINE }, { 0x16204, 5, RI_E1HE2E3_ONLINE },
+        { 0x18000, 1, RI_E1HE2E3_ONLINE }, { 0x18008, 1, RI_E1HE2E3_ONLINE },
+        { 0x18010, 35, RI_E2E3_ONLINE }, { 0x180a4, 2, RI_E2E3_ONLINE },
+        { 0x180c0, 109, RI_E2E3_ONLINE }, { 0x18274, 1, RI_E2_ONLINE },
+        { 0x18278, 81, RI_E2E3_ONLINE }, { 0x18440, 63, RI_E2E3_ONLINE },
+        { 0x18570, 42, RI_E3_ONLINE }, { 0x20000, 24, RI_ALL_ONLINE },
+        { 0x20060, 8, RI_ALL_ONLINE }, { 0x20080, 94, RI_ALL_ONLINE },
+        { 0x201f8, 1, RI_E1E1H_ONLINE }, { 0x201fc, 1, RI_ALL_ONLINE },
+        { 0x20200, 1, RI_E1E1H_ONLINE }, { 0x20204, 1, RI_ALL_ONLINE },
+        { 0x20208, 1, RI_E1E1H_ONLINE }, { 0x2020c, 39, RI_ALL_ONLINE },
+        { 0x202c8, 1, RI_E2E3_ONLINE }, { 0x202d8, 4, RI_E2E3_ONLINE },
+        { 0x20400, 2, RI_ALL_ONLINE }, { 0x2040c, 8, RI_ALL_ONLINE },
+        { 0x2042c, 18, RI_E1HE2E3_ONLINE }, { 0x20480, 1, RI_ALL_ONLINE },
+        { 0x20500, 1, RI_ALL_ONLINE }, { 0x20600, 1, RI_ALL_ONLINE },
+        { 0x28000, 1, RI_ALL_ONLINE }, { 0x28004, 8191, RI_ALL_OFFLINE },
+        { 0x30000, 1, RI_ALL_ONLINE }, { 0x30004, 16383, RI_ALL_OFFLINE },
+        { 0x40000, 98, RI_ALL_ONLINE }, { 0x401a8, 8, RI_E1HE2E3_ONLINE },
+        { 0x401c8, 1, RI_E1H_ONLINE }, { 0x401cc, 2, RI_E1HE2E3_ONLINE },
+        { 0x401d4, 2, RI_E2E3_ONLINE }, { 0x40200, 4, RI_ALL_ONLINE },
+        { 0x40220, 18, RI_E2E3_ONLINE }, { 0x40268, 2, RI_E3_ONLINE },
+        { 0x40400, 43, RI_ALL_ONLINE }, { 0x404cc, 3, RI_E1HE2E3_ONLINE },
+        { 0x404e0, 1, RI_E2E3_ONLINE }, { 0x40500, 2, RI_ALL_ONLINE },
         { 0x40510, 2, RI_ALL_ONLINE }, { 0x40520, 2, RI_ALL_ONLINE },
         { 0x40530, 2, RI_ALL_ONLINE }, { 0x40540, 2, RI_ALL_ONLINE },
-        { 0x40550, 10, RI_E2_ONLINE }, { 0x40610, 2, RI_E2_ONLINE },
-        { 0x42000, 164, RI_ALL_ONLINE }, { 0x422c0, 4, RI_E2_ONLINE },
-        { 0x422d4, 5, RI_E1HE2_ONLINE }, { 0x422e8, 1, RI_E2_ONLINE },
+        { 0x40550, 10, RI_E2E3_ONLINE }, { 0x40610, 2, RI_E2E3_ONLINE },
+        { 0x42000, 164, RI_ALL_ONLINE }, { 0x422c0, 4, RI_E2E3_ONLINE },
+        { 0x422d4, 5, RI_E1HE2E3_ONLINE }, { 0x422e8, 1, RI_E2E3_ONLINE },
         { 0x42400, 49, RI_ALL_ONLINE }, { 0x424c8, 38, RI_ALL_ONLINE },
-        { 0x42568, 2, RI_ALL_ONLINE }, { 0x42640, 5, RI_E2_ONLINE },
+        { 0x42568, 2, RI_ALL_ONLINE }, { 0x42640, 5, RI_E2E3_ONLINE },
         { 0x42800, 1, RI_ALL_ONLINE }, { 0x50000, 1, RI_ALL_ONLINE },
         { 0x50004, 19, RI_ALL_ONLINE }, { 0x50050, 8, RI_ALL_ONLINE },
-        { 0x50070, 88, RI_ALL_ONLINE }, { 0x501f0, 4, RI_E1HE2_ONLINE },
+        { 0x50070, 88, RI_ALL_ONLINE }, { 0x501f0, 4, RI_E1HE2E3_ONLINE },
         { 0x50200, 2, RI_ALL_ONLINE }, { 0x5020c, 7, RI_ALL_ONLINE },
-        { 0x50228, 6, RI_E1HE2_ONLINE }, { 0x50240, 1, RI_ALL_ONLINE },
-        { 0x50280, 1, RI_ALL_ONLINE }, { 0x50300, 1, RI_E2_ONLINE },
-        { 0x5030c, 1, RI_E2_ONLINE }, { 0x50318, 1, RI_E2_ONLINE },
-        { 0x5031c, 1, RI_E2_ONLINE }, { 0x50320, 2, RI_E2_ONLINE },
+        { 0x50228, 6, RI_E1HE2E3_ONLINE }, { 0x50240, 1, RI_ALL_ONLINE },
+        { 0x50280, 1, RI_ALL_ONLINE }, { 0x50300, 1, RI_E2E3_ONLINE },
+        { 0x5030c, 1, RI_E2E3_ONLINE }, { 0x50318, 1, RI_E2E3_ONLINE },
+        { 0x5031c, 1, RI_E2E3_ONLINE }, { 0x50320, 2, RI_E2E3_ONLINE },
         { 0x52000, 1, RI_ALL_ONLINE }, { 0x54000, 1, RI_ALL_ONLINE },
         { 0x54004, 3327, RI_ALL_OFFLINE }, { 0x58000, 1, RI_ALL_ONLINE },
         { 0x58004, 8191, RI_E1E1H_OFFLINE }, { 0x60000, 26, RI_ALL_ONLINE },
         { 0x60068, 8, RI_E1E1H_ONLINE }, { 0x60088, 12, RI_ALL_ONLINE },
         { 0x600b8, 9, RI_E1E1H_ONLINE }, { 0x600dc, 1, RI_ALL_ONLINE },
-        { 0x600e0, 5, RI_E1E1H_ONLINE }, { 0x600f4, 1, RI_ALL_ONLINE },
+        { 0x600e0, 5, RI_E1E1H_ONLINE }, { 0x600f4, 1, RI_E1E1HE2_ONLINE },
         { 0x600f8, 1, RI_E1E1H_ONLINE }, { 0x600fc, 8, RI_ALL_ONLINE },
-        { 0x6013c, 24, RI_E1H_ONLINE }, { 0x6019c, 2, RI_E2_ONLINE },
-        { 0x601ac, 18, RI_E2_ONLINE }, { 0x60200, 1, RI_ALL_ONLINE },
-        { 0x60204, 2, RI_ALL_OFFLINE }, { 0x60210, 13, RI_E2_ONLINE },
+        { 0x6013c, 24, RI_E1H_ONLINE }, { 0x6019c, 2, RI_E2E3_ONLINE },
+        { 0x601ac, 18, RI_E2E3_ONLINE }, { 0x60200, 1, RI_ALL_ONLINE },
+        { 0x60204, 2, RI_ALL_OFFLINE }, { 0x60210, 13, RI_E2E3_ONLINE },
         { 0x61000, 1, RI_ALL_ONLINE }, { 0x61004, 511, RI_ALL_OFFLINE },
-        { 0x70000, 8, RI_ALL_ONLINE }, { 0x70020, 8184, RI_ALL_OFFLINE },
+        { 0x61800, 512, RI_E3_OFFLINE }, { 0x70000, 8, RI_ALL_ONLINE },
+        { 0x70020, 8184, RI_ALL_OFFLINE }, { 0x78000, 8192, RI_E3_OFFLINE },
         { 0x85000, 3, RI_ALL_ONLINE }, { 0x8501c, 7, RI_ALL_ONLINE },
         { 0x85048, 1, RI_ALL_ONLINE }, { 0x85200, 32, RI_ALL_ONLINE },
-        { 0xc1000, 7, RI_ALL_ONLINE }, { 0xc103c, 2, RI_E2_ONLINE },
+        { 0xb0000, 16384, RI_E1H_ONLINE },
+        { 0xc1000, 7, RI_ALL_ONLINE }, { 0xc103c, 2, RI_E2E3_ONLINE },
         { 0xc1800, 2, RI_ALL_ONLINE }, { 0xc2000, 164, RI_ALL_ONLINE },
-        { 0xc22c0, 5, RI_E2_ONLINE }, { 0xc22d8, 4, RI_E2_ONLINE },
+        { 0xc22c0, 5, RI_E2E3_ONLINE }, { 0xc22d8, 4, RI_E2E3_ONLINE },
         { 0xc2400, 49, RI_ALL_ONLINE }, { 0xc24c8, 38, RI_ALL_ONLINE },
         { 0xc2568, 2, RI_ALL_ONLINE }, { 0xc2600, 1, RI_ALL_ONLINE },
-        { 0xc4000, 165, RI_ALL_ONLINE }, { 0xc42d8, 2, RI_E2_ONLINE },
-        { 0xc42e0, 7, RI_E1HE2_ONLINE }, { 0xc42fc, 1, RI_E2_ONLINE },
+        { 0xc4000, 165, RI_ALL_ONLINE }, { 0xc42d8, 2, RI_E2E3_ONLINE },
+        { 0xc42e0, 7, RI_E1HE2E3_ONLINE }, { 0xc42fc, 1, RI_E2E3_ONLINE },
         { 0xc4400, 51, RI_ALL_ONLINE }, { 0xc44d0, 38, RI_ALL_ONLINE },
-        { 0xc4570, 2, RI_ALL_ONLINE }, { 0xc4578, 5, RI_E2_ONLINE },
+        { 0xc4570, 2, RI_ALL_ONLINE }, { 0xc4578, 5, RI_E2E3_ONLINE },
         { 0xc4600, 1, RI_ALL_ONLINE }, { 0xd0000, 19, RI_ALL_ONLINE },
         { 0xd004c, 8, RI_ALL_ONLINE }, { 0xd006c, 91, RI_ALL_ONLINE },
-        { 0xd01fc, 1, RI_E2_ONLINE }, { 0xd0200, 2, RI_ALL_ONLINE },
-        { 0xd020c, 7, RI_ALL_ONLINE }, { 0xd0228, 18, RI_E1HE2_ONLINE },
+        { 0xd01fc, 1, RI_E2E3_ONLINE }, { 0xd0200, 2, RI_ALL_ONLINE },
+        { 0xd020c, 7, RI_ALL_ONLINE }, { 0xd0228, 18, RI_E1HE2E3_ONLINE },
         { 0xd0280, 1, RI_ALL_ONLINE }, { 0xd0300, 1, RI_ALL_ONLINE },
         { 0xd0400, 1, RI_ALL_ONLINE }, { 0xd4000, 1, RI_ALL_ONLINE },
         { 0xd4004, 2559, RI_ALL_OFFLINE }, { 0xd8000, 1, RI_ALL_ONLINE },
         { 0xd8004, 8191, RI_ALL_OFFLINE }, { 0xe0000, 21, RI_ALL_ONLINE },
         { 0xe0054, 8, RI_ALL_ONLINE }, { 0xe0074, 49, RI_ALL_ONLINE },
         { 0xe0138, 1, RI_E1E1H_ONLINE }, { 0xe013c, 35, RI_ALL_ONLINE },
-        { 0xe01f4, 2, RI_E2_ONLINE }, { 0xe0200, 2, RI_ALL_ONLINE },
-        { 0xe020c, 8, RI_ALL_ONLINE }, { 0xe022c, 18, RI_E1HE2_ONLINE },
-        { 0xe0280, 1, RI_ALL_ONLINE }, { 0xe0300, 1, RI_ALL_ONLINE },
-        { 0xe1000, 1, RI_ALL_ONLINE }, { 0xe2000, 1, RI_ALL_ONLINE },
-        { 0xe2004, 2047, RI_ALL_OFFLINE }, { 0xf0000, 1, RI_ALL_ONLINE },
-        { 0xf0004, 16383, RI_ALL_OFFLINE }, { 0x101000, 12, RI_ALL_ONLINE },
-        { 0x101050, 1, RI_E1HE2_ONLINE }, { 0x101054, 3, RI_E2_ONLINE },
-        { 0x101100, 1, RI_ALL_ONLINE }, { 0x101800, 8, RI_ALL_ONLINE },
-        { 0x102000, 18, RI_ALL_ONLINE }, { 0x102068, 6, RI_E2_ONLINE },
-        { 0x102080, 17, RI_ALL_ONLINE }, { 0x1020c8, 8, RI_E1H_ONLINE },
-        { 0x1020e8, 9, RI_E2_ONLINE }, { 0x102400, 1, RI_ALL_ONLINE },
-        { 0x103000, 26, RI_ALL_ONLINE }, { 0x103098, 5, RI_E1HE2_ONLINE },
-        { 0x1030ac, 10, RI_E2_ONLINE }, { 0x1030d8, 8, RI_E2_ONLINE },
-        { 0x103400, 1, RI_E2_ONLINE }, { 0x103404, 135, RI_E2_OFFLINE },
-        { 0x103800, 8, RI_ALL_ONLINE }, { 0x104000, 63, RI_ALL_ONLINE },
-        { 0x10411c, 16, RI_E2_ONLINE }, { 0x104200, 17, RI_ALL_ONLINE },
-        { 0x104400, 64, RI_ALL_ONLINE }, { 0x104500, 192, RI_ALL_OFFLINE },
-        { 0x104800, 64, RI_ALL_ONLINE }, { 0x104900, 192, RI_ALL_OFFLINE },
-        { 0x105000, 256, RI_ALL_ONLINE }, { 0x105400, 768, RI_ALL_OFFLINE },
-        { 0x107000, 7, RI_E2_ONLINE }, { 0x108000, 33, RI_E1E1H_ONLINE },
+        { 0xe01f4, 1, RI_E2_ONLINE }, { 0xe01f8, 1, RI_E2E3_ONLINE },
+        { 0xe0200, 2, RI_ALL_ONLINE }, { 0xe020c, 8, RI_ALL_ONLINE },
+        { 0xe022c, 18, RI_E1HE2E3_ONLINE }, { 0xe0280, 1, RI_ALL_ONLINE },
+        { 0xe0300, 1, RI_ALL_ONLINE }, { 0xe1000, 1, RI_ALL_ONLINE },
+        { 0xe2000, 1, RI_ALL_ONLINE }, { 0xe2004, 2047, RI_ALL_OFFLINE },
+        { 0xf0000, 1, RI_ALL_ONLINE }, { 0xf0004, 16383, RI_ALL_OFFLINE },
+        { 0x101000, 12, RI_ALL_ONLINE }, { 0x101050, 1, RI_E1HE2E3_ONLINE },
+        { 0x101054, 3, RI_E2E3_ONLINE }, { 0x101100, 1, RI_ALL_ONLINE },
+        { 0x101800, 8, RI_ALL_ONLINE }, { 0x102000, 18, RI_ALL_ONLINE },
+        { 0x102068, 6, RI_E2E3_ONLINE }, { 0x102080, 17, RI_ALL_ONLINE },
+        { 0x1020c8, 8, RI_E1H_ONLINE }, { 0x1020e8, 9, RI_E2E3_ONLINE },
+        { 0x102400, 1, RI_ALL_ONLINE }, { 0x103000, 26, RI_ALL_ONLINE },
+        { 0x103098, 5, RI_E1HE2E3_ONLINE }, { 0x1030ac, 2, RI_E2E3_ONLINE },
+        { 0x1030b4, 1, RI_E2_ONLINE }, { 0x1030b8, 7, RI_E2E3_ONLINE },
+        { 0x1030d8, 8, RI_E2E3_ONLINE }, { 0x103400, 1, RI_E2E3_ONLINE },
+        { 0x103404, 135, RI_E2E3_OFFLINE }, { 0x103800, 8, RI_ALL_ONLINE },
+        { 0x104000, 63, RI_ALL_ONLINE }, { 0x10411c, 16, RI_E2E3_ONLINE },
+        { 0x104200, 17, RI_ALL_ONLINE }, { 0x104400, 64, RI_ALL_ONLINE },
+        { 0x104500, 192, RI_ALL_OFFLINE }, { 0x104800, 64, RI_ALL_ONLINE },
+        { 0x104900, 192, RI_ALL_OFFLINE }, { 0x105000, 256, RI_ALL_ONLINE },
+        { 0x105400, 768, RI_ALL_OFFLINE }, { 0x107000, 7, RI_E2E3_ONLINE },
+        { 0x10701c, 1, RI_E3_ONLINE }, { 0x108000, 33, RI_E1E1H_ONLINE },
         { 0x1080ac, 5, RI_E1H_ONLINE }, { 0x108100, 5, RI_E1E1H_ONLINE },
         { 0x108120, 5, RI_E1E1H_ONLINE }, { 0x108200, 74, RI_E1E1H_ONLINE },
         { 0x108400, 74, RI_E1E1H_ONLINE }, { 0x108800, 152, RI_E1E1H_ONLINE },
-        { 0x110000, 111, RI_E2_ONLINE }, { 0x110200, 4, RI_E2_ONLINE },
-        { 0x120000, 2, RI_ALL_ONLINE }, { 0x120008, 4, RI_ALL_ONLINE },
-        { 0x120018, 3, RI_ALL_ONLINE }, { 0x120024, 4, RI_ALL_ONLINE },
-        { 0x120034, 3, RI_ALL_ONLINE }, { 0x120040, 4, RI_ALL_ONLINE },
-        { 0x120050, 3, RI_ALL_ONLINE }, { 0x12005c, 4, RI_ALL_ONLINE },
-        { 0x12006c, 3, RI_ALL_ONLINE }, { 0x120078, 4, RI_ALL_ONLINE },
-        { 0x120088, 3, RI_ALL_ONLINE }, { 0x120094, 4, RI_ALL_ONLINE },
-        { 0x1200a4, 3, RI_ALL_ONLINE }, { 0x1200b0, 4, RI_ALL_ONLINE },
-        { 0x1200c0, 3, RI_ALL_ONLINE }, { 0x1200cc, 4, RI_ALL_ONLINE },
-        { 0x1200dc, 3, RI_ALL_ONLINE }, { 0x1200e8, 4, RI_ALL_ONLINE },
-        { 0x1200f8, 3, RI_ALL_ONLINE }, { 0x120104, 4, RI_ALL_ONLINE },
-        { 0x120114, 1, RI_ALL_ONLINE }, { 0x120118, 22, RI_ALL_ONLINE },
-        { 0x120170, 2, RI_E1E1H_ONLINE }, { 0x120178, 243, RI_ALL_ONLINE },
-        { 0x120544, 4, RI_E1E1H_ONLINE }, { 0x120554, 7, RI_ALL_ONLINE },
-        { 0x12059c, 6, RI_E1HE2_ONLINE }, { 0x1205b4, 1, RI_E1HE2_ONLINE },
-        { 0x1205b8, 16, RI_E1HE2_ONLINE }, { 0x1205f8, 4, RI_E2_ONLINE },
-        { 0x120618, 1, RI_E2_ONLINE }, { 0x12061c, 20, RI_E1HE2_ONLINE },
-        { 0x12066c, 11, RI_E1HE2_ONLINE }, { 0x120698, 5, RI_E2_ONLINE },
-        { 0x1206b0, 76, RI_E2_ONLINE }, { 0x1207fc, 1, RI_E2_ONLINE },
-        { 0x120808, 66, RI_ALL_ONLINE }, { 0x120910, 7, RI_E2_ONLINE },
-        { 0x120930, 9, RI_E2_ONLINE }, { 0x120a00, 2, RI_ALL_ONLINE },
-        { 0x122000, 2, RI_ALL_ONLINE }, { 0x122008, 2046, RI_E1_OFFLINE },
-        { 0x128000, 2, RI_E1HE2_ONLINE }, { 0x128008, 6142, RI_E1HE2_OFFLINE },
-        { 0x130000, 35, RI_E2_ONLINE }, { 0x130100, 29, RI_E2_ONLINE },
-        { 0x130180, 1, RI_E2_ONLINE }, { 0x130200, 1, RI_E2_ONLINE },
-        { 0x130280, 1, RI_E2_ONLINE }, { 0x130300, 5, RI_E2_ONLINE },
-        { 0x130380, 1, RI_E2_ONLINE }, { 0x130400, 1, RI_E2_ONLINE },
-        { 0x130480, 5, RI_E2_ONLINE }, { 0x130800, 72, RI_E2_ONLINE },
-        { 0x131000, 136, RI_E2_ONLINE }, { 0x132000, 148, RI_E2_ONLINE },
-        { 0x134000, 544, RI_E2_ONLINE }, { 0x140000, 64, RI_ALL_ONLINE },
-        { 0x140100, 5, RI_E1E1H_ONLINE }, { 0x140114, 45, RI_ALL_ONLINE },
-        { 0x140200, 6, RI_ALL_ONLINE }, { 0x140220, 4, RI_E2_ONLINE },
-        { 0x140240, 4, RI_E2_ONLINE }, { 0x140260, 4, RI_E2_ONLINE },
-        { 0x140280, 4, RI_E2_ONLINE }, { 0x1402a0, 4, RI_E2_ONLINE },
-        { 0x1402c0, 4, RI_E2_ONLINE }, { 0x1402e0, 13, RI_E2_ONLINE },
-        { 0x144000, 4, RI_E1E1H_ONLINE }, { 0x148000, 4, RI_E1E1H_ONLINE },
-        { 0x14c000, 4, RI_E1E1H_ONLINE }, { 0x150000, 4, RI_E1E1H_ONLINE },
-        { 0x154000, 4, RI_E1E1H_ONLINE }, { 0x158000, 4, RI_E1E1H_ONLINE },
-        { 0x15c000, 2, RI_E1HE2_ONLINE }, { 0x15c008, 5, RI_E1H_ONLINE },
-        { 0x15c020, 27, RI_E2_ONLINE }, { 0x15c090, 13, RI_E2_ONLINE },
-        { 0x15c0c8, 34, RI_E2_ONLINE }, { 0x161000, 7, RI_ALL_ONLINE },
-        { 0x16103c, 2, RI_E2_ONLINE }, { 0x161800, 2, RI_ALL_ONLINE },
-        { 0x164000, 60, RI_ALL_ONLINE }, { 0x164110, 2, RI_E1HE2_ONLINE },
-        { 0x164118, 15, RI_E2_ONLINE }, { 0x164200, 1, RI_ALL_ONLINE },
+        { 0x110000, 111, RI_E2E3_ONLINE }, { 0x1101dc, 1, RI_E3_ONLINE },
+        { 0x110200, 4, RI_E2E3_ONLINE }, { 0x120000, 2, RI_ALL_ONLINE },
+        { 0x120008, 4, RI_ALL_ONLINE }, { 0x120018, 3, RI_ALL_ONLINE },
+        { 0x120024, 4, RI_ALL_ONLINE }, { 0x120034, 3, RI_ALL_ONLINE },
+        { 0x120040, 4, RI_ALL_ONLINE }, { 0x120050, 3, RI_ALL_ONLINE },
+        { 0x12005c, 4, RI_ALL_ONLINE }, { 0x12006c, 3, RI_ALL_ONLINE },
+        { 0x120078, 4, RI_ALL_ONLINE }, { 0x120088, 3, RI_ALL_ONLINE },
+        { 0x120094, 4, RI_ALL_ONLINE }, { 0x1200a4, 3, RI_ALL_ONLINE },
+        { 0x1200b0, 4, RI_ALL_ONLINE }, { 0x1200c0, 3, RI_ALL_ONLINE },
+        { 0x1200cc, 4, RI_ALL_ONLINE }, { 0x1200dc, 3, RI_ALL_ONLINE },
+        { 0x1200e8, 4, RI_ALL_ONLINE }, { 0x1200f8, 3, RI_ALL_ONLINE },
+        { 0x120104, 4, RI_ALL_ONLINE }, { 0x120114, 1, RI_ALL_ONLINE },
+        { 0x120118, 22, RI_ALL_ONLINE }, { 0x120170, 2, RI_E1E1H_ONLINE },
+        { 0x120178, 243, RI_ALL_ONLINE }, { 0x120544, 4, RI_E1E1H_ONLINE },
+        { 0x120554, 6, RI_ALL_ONLINE }, { 0x12059c, 6, RI_E1HE2E3_ONLINE },
+        { 0x1205b4, 1, RI_E1HE2E3_ONLINE }, { 0x1205b8, 15, RI_E1HE2E3_ONLINE },
+        { 0x1205f4, 1, RI_E1HE2_ONLINE }, { 0x1205f8, 4, RI_E2E3_ONLINE },
+        { 0x120618, 1, RI_E2E3_ONLINE }, { 0x12061c, 20, RI_E1HE2E3_ONLINE },
+        { 0x12066c, 11, RI_E1HE2E3_ONLINE }, { 0x120698, 3, RI_E2E3_ONLINE },
+        { 0x1206a4, 1, RI_E2_ONLINE }, { 0x1206a8, 1, RI_E2E3_ONLINE },
+        { 0x1206b0, 75, RI_E2E3_ONLINE }, { 0x1207dc, 1, RI_E2_ONLINE },
+        { 0x1207fc, 1, RI_E2E3_ONLINE }, { 0x12080c, 65, RI_ALL_ONLINE },
+        { 0x120910, 7, RI_E2E3_ONLINE }, { 0x120930, 9, RI_E2E3_ONLINE },
+        { 0x12095c, 37, RI_E3_ONLINE }, { 0x120a00, 2, RI_E1E1HE2_ONLINE },
+        { 0x120b00, 1, RI_E3_ONLINE }, { 0x122000, 2, RI_ALL_ONLINE },
+        { 0x122008, 2046, RI_E1_OFFLINE }, { 0x128000, 2, RI_E1HE2E3_ONLINE },
+        { 0x128008, 6142, RI_E1HE2E3_OFFLINE },
+        { 0x130000, 35, RI_E2E3_ONLINE },
+        { 0x130100, 29, RI_E2E3_ONLINE }, { 0x130180, 1, RI_E2E3_ONLINE },
+        { 0x130200, 1, RI_E2E3_ONLINE }, { 0x130280, 1, RI_E2E3_ONLINE },
+        { 0x130300, 5, RI_E2E3_ONLINE }, { 0x130380, 1, RI_E2E3_ONLINE },
+        { 0x130400, 1, RI_E2E3_ONLINE }, { 0x130480, 5, RI_E2E3_ONLINE },
+        { 0x130800, 72, RI_E2E3_ONLINE }, { 0x131000, 136, RI_E2E3_ONLINE },
+        { 0x132000, 148, RI_E2E3_ONLINE }, { 0x134000, 544, RI_E2E3_ONLINE },
+        { 0x140000, 64, RI_ALL_ONLINE }, { 0x140100, 5, RI_E1E1H_ONLINE },
+        { 0x140114, 45, RI_ALL_ONLINE }, { 0x140200, 6, RI_ALL_ONLINE },
+        { 0x140220, 4, RI_E2E3_ONLINE }, { 0x140240, 4, RI_E2E3_ONLINE },
+        { 0x140260, 4, RI_E2E3_ONLINE }, { 0x140280, 4, RI_E2E3_ONLINE },
+        { 0x1402a0, 4, RI_E2E3_ONLINE }, { 0x1402c0, 4, RI_E2E3_ONLINE },
+        { 0x1402e0, 13, RI_E2E3_ONLINE }, { 0x144000, 4, RI_E1E1H_ONLINE },
+        { 0x148000, 4, RI_E1E1H_ONLINE }, { 0x14c000, 4, RI_E1E1H_ONLINE },
+        { 0x150000, 4, RI_E1E1H_ONLINE }, { 0x154000, 4, RI_E1E1H_ONLINE },
+        { 0x158000, 4, RI_E1E1H_ONLINE }, { 0x15c000, 2, RI_E1HE2E3_ONLINE },
+        { 0x15c008, 5, RI_E1H_ONLINE }, { 0x15c020, 27, RI_E2E3_ONLINE },
+        { 0x15c090, 13, RI_E2E3_ONLINE }, { 0x15c0c8, 34, RI_E2E3_ONLINE },
+        { 0x15c150, 4, RI_E3_ONLINE }, { 0x160004, 6, RI_E3_ONLINE },
+        { 0x160040, 6, RI_E3_ONLINE }, { 0x16005c, 6, RI_E3_ONLINE },
+        { 0x160078, 2, RI_E3_ONLINE }, { 0x160300, 8, RI_E3_ONLINE },
+        { 0x160330, 6, RI_E3_ONLINE }, { 0x160404, 6, RI_E3_ONLINE },
+        { 0x160440, 6, RI_E3_ONLINE }, { 0x16045c, 6, RI_E3_ONLINE },
+        { 0x160478, 2, RI_E3_ONLINE }, { 0x160700, 8, RI_E3_ONLINE },
+        { 0x160730, 6, RI_E3_ONLINE }, { 0x161000, 7, RI_ALL_ONLINE },
+        { 0x16103c, 2, RI_E2E3_ONLINE }, { 0x161800, 2, RI_ALL_ONLINE },
+        { 0x162000, 54, RI_E3_ONLINE }, { 0x162200, 60, RI_E3_ONLINE },
+        { 0x162400, 54, RI_E3_ONLINE }, { 0x162600, 60, RI_E3_ONLINE },
+        { 0x162800, 54, RI_E3_ONLINE }, { 0x162a00, 60, RI_E3_ONLINE },
+        { 0x162c00, 54, RI_E3_ONLINE }, { 0x162e00, 60, RI_E3_ONLINE },
+        { 0x163000, 1, RI_E3_ONLINE }, { 0x163008, 1, RI_E3_ONLINE },
+        { 0x163010, 1, RI_E3_ONLINE }, { 0x163018, 1, RI_E3_ONLINE },
+        { 0x163020, 5, RI_E3_ONLINE }, { 0x163038, 3, RI_E3_ONLINE },
+        { 0x163048, 3, RI_E3_ONLINE }, { 0x163058, 1, RI_E3_ONLINE },
+        { 0x163060, 1, RI_E3_ONLINE }, { 0x163068, 1, RI_E3_ONLINE },
+        { 0x163070, 3, RI_E3_ONLINE }, { 0x163080, 1, RI_E3_ONLINE },
+        { 0x163088, 3, RI_E3_ONLINE }, { 0x163098, 1, RI_E3_ONLINE },
+        { 0x1630a0, 1, RI_E3_ONLINE }, { 0x1630a8, 1, RI_E3_ONLINE },
+        { 0x1630c0, 1, RI_E3_ONLINE }, { 0x1630c8, 1, RI_E3_ONLINE },
+        { 0x1630d0, 1, RI_E3_ONLINE }, { 0x1630d8, 1, RI_E3_ONLINE },
+        { 0x1630e0, 2, RI_E3_ONLINE }, { 0x163110, 1, RI_E3_ONLINE },
+        { 0x163120, 2, RI_E3_ONLINE }, { 0x163420, 4, RI_E3_ONLINE },
+        { 0x163438, 2, RI_E3_ONLINE }, { 0x163488, 2, RI_E3_ONLINE },
+        { 0x163520, 2, RI_E3_ONLINE }, { 0x163800, 1, RI_E3_ONLINE },
+        { 0x163808, 1, RI_E3_ONLINE }, { 0x163810, 1, RI_E3_ONLINE },
+        { 0x163818, 1, RI_E3_ONLINE }, { 0x163820, 5, RI_E3_ONLINE },
+        { 0x163838, 3, RI_E3_ONLINE }, { 0x163848, 3, RI_E3_ONLINE },
+        { 0x163858, 1, RI_E3_ONLINE }, { 0x163860, 1, RI_E3_ONLINE },
+        { 0x163868, 1, RI_E3_ONLINE }, { 0x163870, 3, RI_E3_ONLINE },
+        { 0x163880, 1, RI_E3_ONLINE }, { 0x163888, 3, RI_E3_ONLINE },
+        { 0x163898, 1, RI_E3_ONLINE }, { 0x1638a0, 1, RI_E3_ONLINE },
+        { 0x1638a8, 1, RI_E3_ONLINE }, { 0x1638c0, 1, RI_E3_ONLINE },
+        { 0x1638c8, 1, RI_E3_ONLINE }, { 0x1638d0, 1, RI_E3_ONLINE },
+        { 0x1638d8, 1, RI_E3_ONLINE }, { 0x1638e0, 2, RI_E3_ONLINE },
+        { 0x163910, 1, RI_E3_ONLINE }, { 0x163920, 2, RI_E3_ONLINE },
+        { 0x163c20, 4, RI_E3_ONLINE }, { 0x163c38, 2, RI_E3_ONLINE },
+        { 0x163c88, 2, RI_E3_ONLINE }, { 0x163d20, 2, RI_E3_ONLINE },
+        { 0x164000, 60, RI_ALL_ONLINE }, { 0x164110, 2, RI_E1HE2E3_ONLINE },
+        { 0x164118, 15, RI_E2E3_ONLINE }, { 0x164200, 1, RI_ALL_ONLINE },
         { 0x164208, 1, RI_ALL_ONLINE }, { 0x164210, 1, RI_ALL_ONLINE },
         { 0x164218, 1, RI_ALL_ONLINE }, { 0x164220, 1, RI_ALL_ONLINE },
         { 0x164228, 1, RI_ALL_ONLINE }, { 0x164230, 1, RI_ALL_ONLINE },
@@ -273,9 +364,9 @@ static const struct reg_addr reg_addrs[REGS_COUNT] = {
         { 0x164258, 1, RI_ALL_ONLINE }, { 0x164260, 1, RI_ALL_ONLINE },
         { 0x164270, 2, RI_ALL_ONLINE }, { 0x164280, 2, RI_ALL_ONLINE },
         { 0x164800, 2, RI_ALL_ONLINE }, { 0x165000, 2, RI_ALL_ONLINE },
-        { 0x166000, 164, RI_ALL_ONLINE }, { 0x1662cc, 7, RI_E2_ONLINE },
+        { 0x166000, 164, RI_ALL_ONLINE }, { 0x1662cc, 7, RI_E2E3_ONLINE },
         { 0x166400, 49, RI_ALL_ONLINE }, { 0x1664c8, 38, RI_ALL_ONLINE },
-        { 0x166568, 2, RI_ALL_ONLINE }, { 0x166570, 5, RI_E2_ONLINE },
+        { 0x166568, 2, RI_ALL_ONLINE }, { 0x166570, 5, RI_E2E3_ONLINE },
         { 0x166800, 1, RI_ALL_ONLINE }, { 0x168000, 137, RI_ALL_ONLINE },
         { 0x168224, 2, RI_E1E1H_ONLINE }, { 0x16822c, 29, RI_ALL_ONLINE },
         { 0x1682a0, 12, RI_E1E1H_ONLINE }, { 0x1682d0, 12, RI_ALL_ONLINE },
@@ -285,89 +376,94 @@ static const struct reg_addr reg_addrs[REGS_COUNT] = {
         { 0x168a00, 128, RI_ALL_ONLINE }, { 0x16a000, 1, RI_ALL_ONLINE },
         { 0x16a004, 1535, RI_ALL_OFFLINE }, { 0x16c000, 1, RI_ALL_ONLINE },
         { 0x16c004, 1535, RI_ALL_OFFLINE }, { 0x16e000, 16, RI_E1H_ONLINE },
-        { 0x16e040, 8, RI_E2_ONLINE }, { 0x16e100, 1, RI_E1H_ONLINE },
+        { 0x16e040, 8, RI_E2E3_ONLINE }, { 0x16e100, 1, RI_E1H_ONLINE },
         { 0x16e200, 2, RI_E1H_ONLINE }, { 0x16e400, 161, RI_E1H_ONLINE },
-        { 0x16e684, 2, RI_E1HE2_ONLINE }, { 0x16e68c, 12, RI_E1H_ONLINE },
-        { 0x16e6bc, 4, RI_E1HE2_ONLINE }, { 0x16e6cc, 4, RI_E1H_ONLINE },
-        { 0x16e6e0, 12, RI_E2_ONLINE }, { 0x16e768, 17, RI_E2_ONLINE },
+        { 0x16e684, 2, RI_E1HE2E3_ONLINE }, { 0x16e68c, 12, RI_E1H_ONLINE },
+        { 0x16e6bc, 4, RI_E1HE2E3_ONLINE }, { 0x16e6cc, 4, RI_E1H_ONLINE },
+        { 0x16e6e0, 12, RI_E2E3_ONLINE }, { 0x16e768, 17, RI_E2E3_ONLINE },
         { 0x170000, 24, RI_ALL_ONLINE }, { 0x170060, 4, RI_E1E1H_ONLINE },
-        { 0x170070, 65, RI_ALL_ONLINE }, { 0x170194, 11, RI_E2_ONLINE },
-        { 0x1701c4, 1, RI_E2_ONLINE }, { 0x1701cc, 7, RI_E2_ONLINE },
-        { 0x1701ec, 1, RI_E2_ONLINE }, { 0x1701f4, 1, RI_E2_ONLINE },
-        { 0x170200, 4, RI_ALL_ONLINE }, { 0x170214, 1, RI_ALL_ONLINE },
-        { 0x170218, 77, RI_E2_ONLINE }, { 0x170400, 64, RI_E2_ONLINE },
-        { 0x178000, 1, RI_ALL_ONLINE }, { 0x180000, 61, RI_ALL_ONLINE },
-        { 0x18013c, 2, RI_E1HE2_ONLINE }, { 0x180200, 58, RI_ALL_ONLINE },
-        { 0x180340, 4, RI_ALL_ONLINE }, { 0x180380, 1, RI_E2_ONLINE },
-        { 0x180388, 1, RI_E2_ONLINE }, { 0x180390, 1, RI_E2_ONLINE },
-        { 0x180398, 1, RI_E2_ONLINE }, { 0x1803a0, 5, RI_E2_ONLINE },
+        { 0x170070, 65, RI_ALL_ONLINE }, { 0x170194, 11, RI_E2E3_ONLINE },
+        { 0x1701c4, 1, RI_E2E3_ONLINE }, { 0x1701cc, 7, RI_E2E3_ONLINE },
+        { 0x1701e8, 1, RI_E3_ONLINE }, { 0x1701ec, 1, RI_E2E3_ONLINE },
+        { 0x1701f4, 1, RI_E2E3_ONLINE }, { 0x170200, 4, RI_ALL_ONLINE },
+        { 0x170214, 1, RI_ALL_ONLINE }, { 0x170218, 77, RI_E2E3_ONLINE },
+        { 0x170400, 64, RI_E2E3_ONLINE }, { 0x178000, 1, RI_ALL_ONLINE },
+        { 0x180000, 61, RI_ALL_ONLINE }, { 0x18013c, 2, RI_E1HE2E3_ONLINE },
+        { 0x180200, 58, RI_ALL_ONLINE }, { 0x180340, 4, RI_ALL_ONLINE },
+        { 0x180380, 1, RI_E2E3_ONLINE }, { 0x180388, 1, RI_E2E3_ONLINE },
+        { 0x180390, 1, RI_E2E3_ONLINE }, { 0x180398, 1, RI_E2E3_ONLINE },
+        { 0x1803a0, 5, RI_E2E3_ONLINE }, { 0x1803b4, 2, RI_E3_ONLINE },
         { 0x180400, 1, RI_ALL_ONLINE }, { 0x180404, 255, RI_E1E1H_OFFLINE },
         { 0x181000, 4, RI_ALL_ONLINE }, { 0x181010, 1020, RI_ALL_OFFLINE },
-        { 0x1a0000, 1, RI_ALL_ONLINE }, { 0x1a0004, 5631, RI_ALL_OFFLINE },
-        { 0x1a5800, 2560, RI_E1HE2_OFFLINE }, { 0x1a8000, 1, RI_ALL_ONLINE },
-        { 0x1a8004, 8191, RI_E1HE2_OFFLINE }, { 0x1b0000, 1, RI_ALL_ONLINE },
-        { 0x1b0004, 15, RI_E1H_OFFLINE }, { 0x1b0040, 1, RI_E1HE2_ONLINE },
-        { 0x1b0044, 239, RI_E1H_OFFLINE }, { 0x1b0400, 1, RI_ALL_ONLINE },
-        { 0x1b0404, 255, RI_E1H_OFFLINE }, { 0x1b0800, 1, RI_ALL_ONLINE },
-        { 0x1b0840, 1, RI_E1HE2_ONLINE }, { 0x1b0c00, 1, RI_ALL_ONLINE },
-        { 0x1b1000, 1, RI_ALL_ONLINE }, { 0x1b1040, 1, RI_E1HE2_ONLINE },
-        { 0x1b1400, 1, RI_ALL_ONLINE }, { 0x1b1440, 1, RI_E1HE2_ONLINE },
-        { 0x1b1480, 1, RI_E1HE2_ONLINE }, { 0x1b14c0, 1, RI_E1HE2_ONLINE },
-        { 0x1b1800, 128, RI_ALL_OFFLINE }, { 0x1b1c00, 128, RI_ALL_OFFLINE },
-        { 0x1b2000, 1, RI_ALL_ONLINE }, { 0x1b2400, 1, RI_E1HE2_ONLINE },
-        { 0x1b2404, 5631, RI_E2_OFFLINE }, { 0x1b8000, 1, RI_ALL_ONLINE },
-        { 0x1b8040, 1, RI_ALL_ONLINE }, { 0x1b8080, 1, RI_ALL_ONLINE },
-        { 0x1b80c0, 1, RI_ALL_ONLINE }, { 0x1b8100, 1, RI_ALL_ONLINE },
-        { 0x1b8140, 1, RI_ALL_ONLINE }, { 0x1b8180, 1, RI_ALL_ONLINE },
-        { 0x1b81c0, 1, RI_ALL_ONLINE }, { 0x1b8200, 1, RI_ALL_ONLINE },
-        { 0x1b8240, 1, RI_ALL_ONLINE }, { 0x1b8280, 1, RI_ALL_ONLINE },
-        { 0x1b82c0, 1, RI_ALL_ONLINE }, { 0x1b8300, 1, RI_ALL_ONLINE },
-        { 0x1b8340, 1, RI_ALL_ONLINE }, { 0x1b8380, 1, RI_ALL_ONLINE },
-        { 0x1b83c0, 1, RI_ALL_ONLINE }, { 0x1b8400, 1, RI_ALL_ONLINE },
-        { 0x1b8440, 1, RI_ALL_ONLINE }, { 0x1b8480, 1, RI_ALL_ONLINE },
-        { 0x1b84c0, 1, RI_ALL_ONLINE }, { 0x1b8500, 1, RI_ALL_ONLINE },
-        { 0x1b8540, 1, RI_ALL_ONLINE }, { 0x1b8580, 1, RI_ALL_ONLINE },
-        { 0x1b85c0, 19, RI_E2_ONLINE }, { 0x1b8800, 1, RI_ALL_ONLINE },
-        { 0x1b8840, 1, RI_ALL_ONLINE }, { 0x1b8880, 1, RI_ALL_ONLINE },
-        { 0x1b88c0, 1, RI_ALL_ONLINE }, { 0x1b8900, 1, RI_ALL_ONLINE },
-        { 0x1b8940, 1, RI_ALL_ONLINE }, { 0x1b8980, 1, RI_ALL_ONLINE },
-        { 0x1b89c0, 1, RI_ALL_ONLINE }, { 0x1b8a00, 1, RI_ALL_ONLINE },
-        { 0x1b8a40, 1, RI_ALL_ONLINE }, { 0x1b8a80, 1, RI_ALL_ONLINE },
-        { 0x1b8ac0, 1, RI_ALL_ONLINE }, { 0x1b8b00, 1, RI_ALL_ONLINE },
-        { 0x1b8b40, 1, RI_ALL_ONLINE }, { 0x1b8b80, 1, RI_ALL_ONLINE },
-        { 0x1b8bc0, 1, RI_ALL_ONLINE }, { 0x1b8c00, 1, RI_ALL_ONLINE },
-        { 0x1b8c40, 1, RI_ALL_ONLINE }, { 0x1b8c80, 1, RI_ALL_ONLINE },
-        { 0x1b8cc0, 1, RI_ALL_ONLINE }, { 0x1b8cc4, 1, RI_E2_ONLINE },
-        { 0x1b8d00, 1, RI_ALL_ONLINE }, { 0x1b8d40, 1, RI_ALL_ONLINE },
-        { 0x1b8d80, 1, RI_ALL_ONLINE }, { 0x1b8dc0, 1, RI_ALL_ONLINE },
-        { 0x1b8e00, 1, RI_ALL_ONLINE }, { 0x1b8e40, 1, RI_ALL_ONLINE },
-        { 0x1b8e80, 1, RI_ALL_ONLINE }, { 0x1b8e84, 1, RI_E2_ONLINE },
-        { 0x1b8ec0, 1, RI_E1HE2_ONLINE }, { 0x1b8f00, 1, RI_E1HE2_ONLINE },
-        { 0x1b8f40, 1, RI_E1HE2_ONLINE }, { 0x1b8f80, 1, RI_E1HE2_ONLINE },
-        { 0x1b8fc0, 1, RI_E1HE2_ONLINE }, { 0x1b8fc4, 2, RI_E2_ONLINE },
-        { 0x1b8fd0, 6, RI_E2_ONLINE }, { 0x1b9000, 1, RI_E2_ONLINE },
-        { 0x1b9040, 3, RI_E2_ONLINE }, { 0x1b9400, 14, RI_E2_ONLINE },
-        { 0x1b943c, 19, RI_E2_ONLINE }, { 0x1b9490, 10, RI_E2_ONLINE },
-        { 0x1c0000, 2, RI_ALL_ONLINE }, { 0x200000, 65, RI_ALL_ONLINE },
-        { 0x20014c, 2, RI_E1HE2_ONLINE }, { 0x200200, 58, RI_ALL_ONLINE },
-        { 0x200340, 4, RI_ALL_ONLINE }, { 0x200380, 1, RI_E2_ONLINE },
-        { 0x200388, 1, RI_E2_ONLINE }, { 0x200390, 1, RI_E2_ONLINE },
-        { 0x200398, 1, RI_E2_ONLINE }, { 0x2003a0, 1, RI_E2_ONLINE },
-        { 0x2003a8, 2, RI_E2_ONLINE }, { 0x200400, 1, RI_ALL_ONLINE },
-        { 0x200404, 255, RI_E1E1H_OFFLINE }, { 0x202000, 4, RI_ALL_ONLINE },
-        { 0x202010, 2044, RI_ALL_OFFLINE }, { 0x220000, 1, RI_ALL_ONLINE },
-        { 0x220004, 5631, RI_ALL_OFFLINE }, { 0x225800, 2560, RI_E1HE2_OFFLINE},
-        { 0x228000, 1, RI_ALL_ONLINE }, { 0x228004, 8191, RI_E1HE2_OFFLINE },
+        { 0x182000, 4, RI_E3_ONLINE }, { 0x1a0000, 1, RI_ALL_ONLINE },
+        { 0x1a0004, 5631, RI_ALL_OFFLINE },
+        { 0x1a5800, 2560, RI_E1HE2E3_OFFLINE },
+        { 0x1a8000, 1, RI_ALL_ONLINE }, { 0x1a8004, 8191, RI_E1HE2E3_OFFLINE },
+        { 0x1b0000, 1, RI_ALL_ONLINE }, { 0x1b0004, 15, RI_E1H_OFFLINE },
+        { 0x1b0040, 1, RI_E1HE2E3_ONLINE }, { 0x1b0044, 239, RI_E1H_OFFLINE },
+        { 0x1b0400, 1, RI_ALL_ONLINE }, { 0x1b0404, 255, RI_E1H_OFFLINE },
+        { 0x1b0800, 1, RI_ALL_ONLINE }, { 0x1b0840, 1, RI_E1HE2E3_ONLINE },
+        { 0x1b0c00, 1, RI_ALL_ONLINE }, { 0x1b1000, 1, RI_ALL_ONLINE },
+        { 0x1b1040, 1, RI_E1HE2E3_ONLINE }, { 0x1b1400, 1, RI_ALL_ONLINE },
+        { 0x1b1440, 1, RI_E1HE2E3_ONLINE }, { 0x1b1480, 1, RI_E1HE2E3_ONLINE },
+        { 0x1b14c0, 1, RI_E1HE2E3_ONLINE }, { 0x1b1800, 128, RI_ALL_OFFLINE },
+        { 0x1b1c00, 128, RI_ALL_OFFLINE }, { 0x1b2000, 1, RI_ALL_ONLINE },
+        { 0x1b2400, 1, RI_E1HE2E3_ONLINE }, { 0x1b2404, 5631, RI_E2E3_OFFLINE },
+        { 0x1b8000, 1, RI_ALL_ONLINE }, { 0x1b8040, 1, RI_ALL_ONLINE },
+        { 0x1b8080, 1, RI_ALL_ONLINE }, { 0x1b80c0, 1, RI_ALL_ONLINE },
+        { 0x1b8100, 1, RI_ALL_ONLINE }, { 0x1b8140, 1, RI_ALL_ONLINE },
+        { 0x1b8180, 1, RI_ALL_ONLINE }, { 0x1b81c0, 1, RI_ALL_ONLINE },
+        { 0x1b8200, 1, RI_ALL_ONLINE }, { 0x1b8240, 1, RI_ALL_ONLINE },
+        { 0x1b8280, 1, RI_ALL_ONLINE }, { 0x1b82c0, 1, RI_ALL_ONLINE },
+        { 0x1b8300, 1, RI_ALL_ONLINE }, { 0x1b8340, 1, RI_ALL_ONLINE },
+        { 0x1b8380, 1, RI_ALL_ONLINE }, { 0x1b83c0, 1, RI_ALL_ONLINE },
+        { 0x1b8400, 1, RI_ALL_ONLINE }, { 0x1b8440, 1, RI_ALL_ONLINE },
+        { 0x1b8480, 1, RI_ALL_ONLINE }, { 0x1b84c0, 1, RI_ALL_ONLINE },
+        { 0x1b8500, 1, RI_ALL_ONLINE }, { 0x1b8540, 1, RI_ALL_ONLINE },
+        { 0x1b8580, 1, RI_ALL_ONLINE }, { 0x1b85c0, 19, RI_E2E3_ONLINE },
+        { 0x1b8800, 1, RI_ALL_ONLINE }, { 0x1b8840, 1, RI_ALL_ONLINE },
+        { 0x1b8880, 1, RI_ALL_ONLINE }, { 0x1b88c0, 1, RI_ALL_ONLINE },
+        { 0x1b8900, 1, RI_ALL_ONLINE }, { 0x1b8940, 1, RI_ALL_ONLINE },
+        { 0x1b8980, 1, RI_ALL_ONLINE }, { 0x1b89c0, 1, RI_ALL_ONLINE },
+        { 0x1b8a00, 1, RI_ALL_ONLINE }, { 0x1b8a40, 1, RI_ALL_ONLINE },
+        { 0x1b8a80, 1, RI_ALL_ONLINE }, { 0x1b8ac0, 1, RI_ALL_ONLINE },
+        { 0x1b8b00, 1, RI_ALL_ONLINE }, { 0x1b8b40, 1, RI_ALL_ONLINE },
+        { 0x1b8b80, 1, RI_ALL_ONLINE }, { 0x1b8bc0, 1, RI_ALL_ONLINE },
+        { 0x1b8c00, 1, RI_ALL_ONLINE }, { 0x1b8c40, 1, RI_ALL_ONLINE },
+        { 0x1b8c80, 1, RI_ALL_ONLINE }, { 0x1b8cc0, 1, RI_ALL_ONLINE },
+        { 0x1b8cc4, 1, RI_E2E3_ONLINE }, { 0x1b8d00, 1, RI_ALL_ONLINE },
+        { 0x1b8d40, 1, RI_ALL_ONLINE }, { 0x1b8d80, 1, RI_ALL_ONLINE },
+        { 0x1b8dc0, 1, RI_ALL_ONLINE }, { 0x1b8e00, 1, RI_ALL_ONLINE },
+        { 0x1b8e40, 1, RI_ALL_ONLINE }, { 0x1b8e80, 1, RI_ALL_ONLINE },
+        { 0x1b8e84, 1, RI_E2E3_ONLINE }, { 0x1b8ec0, 1, RI_E1HE2E3_ONLINE },
+        { 0x1b8f00, 1, RI_E1HE2E3_ONLINE }, { 0x1b8f40, 1, RI_E1HE2E3_ONLINE },
+        { 0x1b8f80, 1, RI_E1HE2E3_ONLINE }, { 0x1b8fc0, 1, RI_E1HE2E3_ONLINE },
+        { 0x1b8fc4, 2, RI_E2E3_ONLINE }, { 0x1b8fd0, 6, RI_E2E3_ONLINE },
+        { 0x1b8fe8, 2, RI_E3_ONLINE }, { 0x1b9000, 1, RI_E2E3_ONLINE },
+        { 0x1b9040, 3, RI_E2E3_ONLINE }, { 0x1b905c, 1, RI_E3_ONLINE },
+        { 0x1b9400, 14, RI_E2E3_ONLINE }, { 0x1b943c, 19, RI_E2E3_ONLINE },
+        { 0x1b9490, 10, RI_E2E3_ONLINE }, { 0x1c0000, 2, RI_ALL_ONLINE },
+        { 0x200000, 65, RI_ALL_ONLINE }, { 0x20014c, 2, RI_E1HE2E3_ONLINE },
+        { 0x200200, 58, RI_ALL_ONLINE }, { 0x200340, 4, RI_ALL_ONLINE },
+        { 0x200380, 1, RI_E2E3_ONLINE }, { 0x200388, 1, RI_E2E3_ONLINE },
+        { 0x200390, 1, RI_E2E3_ONLINE }, { 0x200398, 1, RI_E2E3_ONLINE },
+        { 0x2003a0, 1, RI_E2E3_ONLINE }, { 0x2003a8, 2, RI_E2E3_ONLINE },
+        { 0x200400, 1, RI_ALL_ONLINE }, { 0x200404, 255, RI_E1E1H_OFFLINE },
+        { 0x202000, 4, RI_ALL_ONLINE }, { 0x202010, 2044, RI_ALL_OFFLINE },
+        { 0x204000, 4, RI_E3_ONLINE }, { 0x220000, 1, RI_ALL_ONLINE },
+        { 0x220004, 5631, RI_ALL_OFFLINE },
+        { 0x225800, 2560, RI_E1HE2E3_OFFLINE },
+        { 0x228000, 1, RI_ALL_ONLINE }, { 0x228004, 8191, RI_E1HE2E3_OFFLINE },
         { 0x230000, 1, RI_ALL_ONLINE }, { 0x230004, 15, RI_E1H_OFFLINE },
-        { 0x230040, 1, RI_E1HE2_ONLINE }, { 0x230044, 239, RI_E1H_OFFLINE },
+        { 0x230040, 1, RI_E1HE2E3_ONLINE }, { 0x230044, 239, RI_E1H_OFFLINE },
         { 0x230400, 1, RI_ALL_ONLINE }, { 0x230404, 255, RI_E1H_OFFLINE },
-        { 0x230800, 1, RI_ALL_ONLINE }, { 0x230840, 1, RI_E1HE2_ONLINE },
+        { 0x230800, 1, RI_ALL_ONLINE }, { 0x230840, 1, RI_E1HE2E3_ONLINE },
         { 0x230c00, 1, RI_ALL_ONLINE }, { 0x231000, 1, RI_ALL_ONLINE },
-        { 0x231040, 1, RI_E1HE2_ONLINE }, { 0x231400, 1, RI_ALL_ONLINE },
-        { 0x231440, 1, RI_E1HE2_ONLINE }, { 0x231480, 1, RI_E1HE2_ONLINE },
-        { 0x2314c0, 1, RI_E1HE2_ONLINE }, { 0x231800, 128, RI_ALL_OFFLINE },
+        { 0x231040, 1, RI_E1HE2E3_ONLINE }, { 0x231400, 1, RI_ALL_ONLINE },
+        { 0x231440, 1, RI_E1HE2E3_ONLINE }, { 0x231480, 1, RI_E1HE2E3_ONLINE },
+        { 0x2314c0, 1, RI_E1HE2E3_ONLINE }, { 0x231800, 128, RI_ALL_OFFLINE },
         { 0x231c00, 128, RI_ALL_OFFLINE }, { 0x232000, 1, RI_ALL_ONLINE },
-        { 0x232400, 1, RI_E1HE2_ONLINE }, { 0x232404, 5631, RI_E2_OFFLINE },
+        { 0x232400, 1, RI_E1HE2E3_ONLINE }, { 0x232404, 5631, RI_E2E3_OFFLINE },
         { 0x238000, 1, RI_ALL_ONLINE }, { 0x238040, 1, RI_ALL_ONLINE },
         { 0x238080, 1, RI_ALL_ONLINE }, { 0x2380c0, 1, RI_ALL_ONLINE },
         { 0x238100, 1, RI_ALL_ONLINE }, { 0x238140, 1, RI_ALL_ONLINE },
@@ -379,7 +475,7 @@ static const struct reg_addr reg_addrs[REGS_COUNT] = {
         { 0x238400, 1, RI_ALL_ONLINE }, { 0x238440, 1, RI_ALL_ONLINE },
         { 0x238480, 1, RI_ALL_ONLINE }, { 0x2384c0, 1, RI_ALL_ONLINE },
         { 0x238500, 1, RI_ALL_ONLINE }, { 0x238540, 1, RI_ALL_ONLINE },
-        { 0x238580, 1, RI_ALL_ONLINE }, { 0x2385c0, 19, RI_E2_ONLINE },
+        { 0x238580, 1, RI_ALL_ONLINE }, { 0x2385c0, 19, RI_E2E3_ONLINE },
         { 0x238800, 1, RI_ALL_ONLINE }, { 0x238840, 1, RI_ALL_ONLINE },
         { 0x238880, 1, RI_ALL_ONLINE }, { 0x2388c0, 1, RI_ALL_ONLINE },
         { 0x238900, 1, RI_ALL_ONLINE }, { 0x238940, 1, RI_ALL_ONLINE },
@@ -390,88 +486,91 @@ static const struct reg_addr reg_addrs[REGS_COUNT] = {
         { 0x238b80, 1, RI_ALL_ONLINE }, { 0x238bc0, 1, RI_ALL_ONLINE },
         { 0x238c00, 1, RI_ALL_ONLINE }, { 0x238c40, 1, RI_ALL_ONLINE },
         { 0x238c80, 1, RI_ALL_ONLINE }, { 0x238cc0, 1, RI_ALL_ONLINE },
-        { 0x238cc4, 1, RI_E2_ONLINE }, { 0x238d00, 1, RI_ALL_ONLINE },
+        { 0x238cc4, 1, RI_E2E3_ONLINE }, { 0x238d00, 1, RI_ALL_ONLINE },
         { 0x238d40, 1, RI_ALL_ONLINE }, { 0x238d80, 1, RI_ALL_ONLINE },
         { 0x238dc0, 1, RI_ALL_ONLINE }, { 0x238e00, 1, RI_ALL_ONLINE },
         { 0x238e40, 1, RI_ALL_ONLINE }, { 0x238e80, 1, RI_ALL_ONLINE },
-        { 0x238e84, 1, RI_E2_ONLINE }, { 0x238ec0, 1, RI_E1HE2_ONLINE },
-        { 0x238f00, 1, RI_E1HE2_ONLINE }, { 0x238f40, 1, RI_E1HE2_ONLINE },
-        { 0x238f80, 1, RI_E1HE2_ONLINE }, { 0x238fc0, 1, RI_E1HE2_ONLINE },
-        { 0x238fc4, 2, RI_E2_ONLINE }, { 0x238fd0, 6, RI_E2_ONLINE },
-        { 0x239000, 1, RI_E2_ONLINE }, { 0x239040, 3, RI_E2_ONLINE },
+        { 0x238e84, 1, RI_E2E3_ONLINE }, { 0x238ec0, 1, RI_E1HE2E3_ONLINE },
+        { 0x238f00, 1, RI_E1HE2E3_ONLINE }, { 0x238f40, 1, RI_E1HE2E3_ONLINE },
+        { 0x238f80, 1, RI_E1HE2E3_ONLINE }, { 0x238fc0, 1, RI_E1HE2E3_ONLINE },
+        { 0x238fc4, 2, RI_E2E3_ONLINE }, { 0x238fd0, 6, RI_E2E3_ONLINE },
+        { 0x238fe8, 2, RI_E3_ONLINE }, { 0x239000, 1, RI_E2E3_ONLINE },
+        { 0x239040, 3, RI_E2E3_ONLINE }, { 0x23905c, 1, RI_E3_ONLINE },
         { 0x240000, 2, RI_ALL_ONLINE }, { 0x280000, 65, RI_ALL_ONLINE },
-        { 0x28014c, 2, RI_E1HE2_ONLINE }, { 0x280200, 58, RI_ALL_ONLINE },
-        { 0x280340, 4, RI_ALL_ONLINE }, { 0x280380, 1, RI_E2_ONLINE },
-        { 0x280388, 1, RI_E2_ONLINE }, { 0x280390, 1, RI_E2_ONLINE },
-        { 0x280398, 1, RI_E2_ONLINE }, { 0x2803a0, 1, RI_E2_ONLINE },
-        { 0x2803a8, 2, RI_E2_ONLINE }, { 0x280400, 1, RI_ALL_ONLINE },
+        { 0x28014c, 2, RI_E1HE2E3_ONLINE }, { 0x280200, 58, RI_ALL_ONLINE },
+        { 0x280340, 4, RI_ALL_ONLINE }, { 0x280380, 1, RI_E2E3_ONLINE },
+        { 0x280388, 1, RI_E2E3_ONLINE }, { 0x280390, 1, RI_E2E3_ONLINE },
+        { 0x280398, 1, RI_E2E3_ONLINE }, { 0x2803a0, 1, RI_E2E3_ONLINE },
+        { 0x2803a8, 2, RI_E2E3_ONLINE }, { 0x280400, 1, RI_ALL_ONLINE },
         { 0x280404, 255, RI_E1E1H_OFFLINE }, { 0x282000, 4, RI_ALL_ONLINE },
-        { 0x282010, 2044, RI_ALL_OFFLINE }, { 0x2a0000, 1, RI_ALL_ONLINE },
-        { 0x2a0004, 5631, RI_ALL_OFFLINE }, { 0x2a5800, 2560, RI_E1HE2_OFFLINE},
-        { 0x2a8000, 1, RI_ALL_ONLINE }, { 0x2a8004, 8191, RI_E1HE2_OFFLINE },
-        { 0x2b0000, 1, RI_ALL_ONLINE }, { 0x2b0004, 15, RI_E1H_OFFLINE },
-        { 0x2b0040, 1, RI_E1HE2_ONLINE }, { 0x2b0044, 239, RI_E1H_OFFLINE },
-        { 0x2b0400, 1, RI_ALL_ONLINE }, { 0x2b0404, 255, RI_E1H_OFFLINE },
-        { 0x2b0800, 1, RI_ALL_ONLINE }, { 0x2b0840, 1, RI_E1HE2_ONLINE },
-        { 0x2b0c00, 1, RI_ALL_ONLINE }, { 0x2b1000, 1, RI_ALL_ONLINE },
-        { 0x2b1040, 1, RI_E1HE2_ONLINE }, { 0x2b1400, 1, RI_ALL_ONLINE },
-        { 0x2b1440, 1, RI_E1HE2_ONLINE }, { 0x2b1480, 1, RI_E1HE2_ONLINE },
-        { 0x2b14c0, 1, RI_E1HE2_ONLINE }, { 0x2b1800, 128, RI_ALL_OFFLINE },
-        { 0x2b1c00, 128, RI_ALL_OFFLINE }, { 0x2b2000, 1, RI_ALL_ONLINE },
-        { 0x2b2400, 1, RI_E1HE2_ONLINE }, { 0x2b2404, 5631, RI_E2_OFFLINE },
-        { 0x2b8000, 1, RI_ALL_ONLINE }, { 0x2b8040, 1, RI_ALL_ONLINE },
-        { 0x2b8080, 1, RI_ALL_ONLINE }, { 0x2b80c0, 1, RI_ALL_ONLINE },
-        { 0x2b8100, 1, RI_ALL_ONLINE }, { 0x2b8140, 1, RI_ALL_ONLINE },
-        { 0x2b8180, 1, RI_ALL_ONLINE }, { 0x2b81c0, 1, RI_ALL_ONLINE },
-        { 0x2b8200, 1, RI_ALL_ONLINE }, { 0x2b8240, 1, RI_ALL_ONLINE },
-        { 0x2b8280, 1, RI_ALL_ONLINE }, { 0x2b82c0, 1, RI_ALL_ONLINE },
-        { 0x2b8300, 1, RI_ALL_ONLINE }, { 0x2b8340, 1, RI_ALL_ONLINE },
-        { 0x2b8380, 1, RI_ALL_ONLINE }, { 0x2b83c0, 1, RI_ALL_ONLINE },
-        { 0x2b8400, 1, RI_ALL_ONLINE }, { 0x2b8440, 1, RI_ALL_ONLINE },
-        { 0x2b8480, 1, RI_ALL_ONLINE }, { 0x2b84c0, 1, RI_ALL_ONLINE },
-        { 0x2b8500, 1, RI_ALL_ONLINE }, { 0x2b8540, 1, RI_ALL_ONLINE },
-        { 0x2b8580, 1, RI_ALL_ONLINE }, { 0x2b85c0, 19, RI_E2_ONLINE },
-        { 0x2b8800, 1, RI_ALL_ONLINE }, { 0x2b8840, 1, RI_ALL_ONLINE },
-        { 0x2b8880, 1, RI_ALL_ONLINE }, { 0x2b88c0, 1, RI_ALL_ONLINE },
-        { 0x2b8900, 1, RI_ALL_ONLINE }, { 0x2b8940, 1, RI_ALL_ONLINE },
-        { 0x2b8980, 1, RI_ALL_ONLINE }, { 0x2b89c0, 1, RI_ALL_ONLINE },
-        { 0x2b8a00, 1, RI_ALL_ONLINE }, { 0x2b8a40, 1, RI_ALL_ONLINE },
-        { 0x2b8a80, 1, RI_ALL_ONLINE }, { 0x2b8ac0, 1, RI_ALL_ONLINE },
-        { 0x2b8b00, 1, RI_ALL_ONLINE }, { 0x2b8b40, 1, RI_ALL_ONLINE },
-        { 0x2b8b80, 1, RI_ALL_ONLINE }, { 0x2b8bc0, 1, RI_ALL_ONLINE },
-        { 0x2b8c00, 1, RI_ALL_ONLINE }, { 0x2b8c40, 1, RI_ALL_ONLINE },
-        { 0x2b8c80, 1, RI_ALL_ONLINE }, { 0x2b8cc0, 1, RI_ALL_ONLINE },
-        { 0x2b8cc4, 1, RI_E2_ONLINE }, { 0x2b8d00, 1, RI_ALL_ONLINE },
-        { 0x2b8d40, 1, RI_ALL_ONLINE }, { 0x2b8d80, 1, RI_ALL_ONLINE },
-        { 0x2b8dc0, 1, RI_ALL_ONLINE }, { 0x2b8e00, 1, RI_ALL_ONLINE },
-        { 0x2b8e40, 1, RI_ALL_ONLINE }, { 0x2b8e80, 1, RI_ALL_ONLINE },
-        { 0x2b8e84, 1, RI_E2_ONLINE }, { 0x2b8ec0, 1, RI_E1HE2_ONLINE },
-        { 0x2b8f00, 1, RI_E1HE2_ONLINE }, { 0x2b8f40, 1, RI_E1HE2_ONLINE },
-        { 0x2b8f80, 1, RI_E1HE2_ONLINE }, { 0x2b8fc0, 1, RI_E1HE2_ONLINE },
-        { 0x2b8fc4, 2, RI_E2_ONLINE }, { 0x2b8fd0, 6, RI_E2_ONLINE },
-        { 0x2b9000, 1, RI_E2_ONLINE }, { 0x2b9040, 3, RI_E2_ONLINE },
-        { 0x2b9400, 14, RI_E2_ONLINE }, { 0x2b943c, 19, RI_E2_ONLINE },
-        { 0x2b9490, 10, RI_E2_ONLINE }, { 0x2c0000, 2, RI_ALL_ONLINE },
-        { 0x300000, 65, RI_ALL_ONLINE }, { 0x30014c, 2, RI_E1HE2_ONLINE },
-        { 0x300200, 58, RI_ALL_ONLINE }, { 0x300340, 4, RI_ALL_ONLINE },
-        { 0x300380, 1, RI_E2_ONLINE }, { 0x300388, 1, RI_E2_ONLINE },
-        { 0x300390, 1, RI_E2_ONLINE }, { 0x300398, 1, RI_E2_ONLINE },
-        { 0x3003a0, 1, RI_E2_ONLINE }, { 0x3003a8, 2, RI_E2_ONLINE },
-        { 0x300400, 1, RI_ALL_ONLINE }, { 0x300404, 255, RI_E1E1H_OFFLINE },
-        { 0x302000, 4, RI_ALL_ONLINE }, { 0x302010, 2044, RI_ALL_OFFLINE },
+        { 0x282010, 2044, RI_ALL_OFFLINE }, { 0x284000, 4, RI_E3_ONLINE },
+        { 0x2a0000, 1, RI_ALL_ONLINE }, { 0x2a0004, 5631, RI_ALL_OFFLINE },
+        { 0x2a5800, 2560, RI_E1HE2E3_OFFLINE }, { 0x2a8000, 1, RI_ALL_ONLINE },
+        { 0x2a8004, 8191, RI_E1HE2E3_OFFLINE }, { 0x2b0000, 1, RI_ALL_ONLINE },
+        { 0x2b0004, 15, RI_E1H_OFFLINE }, { 0x2b0040, 1, RI_E1HE2E3_ONLINE },
+        { 0x2b0044, 239, RI_E1H_OFFLINE }, { 0x2b0400, 1, RI_ALL_ONLINE },
+        { 0x2b0404, 255, RI_E1H_OFFLINE }, { 0x2b0800, 1, RI_ALL_ONLINE },
+        { 0x2b0840, 1, RI_E1HE2E3_ONLINE }, { 0x2b0c00, 1, RI_ALL_ONLINE },
+        { 0x2b1000, 1, RI_ALL_ONLINE }, { 0x2b1040, 1, RI_E1HE2E3_ONLINE },
+        { 0x2b1400, 1, RI_ALL_ONLINE }, { 0x2b1440, 1, RI_E1HE2E3_ONLINE },
+        { 0x2b1480, 1, RI_E1HE2E3_ONLINE }, { 0x2b14c0, 1, RI_E1HE2E3_ONLINE },
+        { 0x2b1800, 128, RI_ALL_OFFLINE }, { 0x2b1c00, 128, RI_ALL_OFFLINE },
+        { 0x2b2000, 1, RI_ALL_ONLINE }, { 0x2b2400, 1, RI_E1HE2E3_ONLINE },
+        { 0x2b2404, 5631, RI_E2E3_OFFLINE }, { 0x2b8000, 1, RI_ALL_ONLINE },
+        { 0x2b8040, 1, RI_ALL_ONLINE }, { 0x2b8080, 1, RI_ALL_ONLINE },
+        { 0x2b80c0, 1, RI_ALL_ONLINE }, { 0x2b8100, 1, RI_ALL_ONLINE },
+        { 0x2b8140, 1, RI_ALL_ONLINE }, { 0x2b8180, 1, RI_ALL_ONLINE },
+        { 0x2b81c0, 1, RI_ALL_ONLINE }, { 0x2b8200, 1, RI_ALL_ONLINE },
+        { 0x2b8240, 1, RI_ALL_ONLINE }, { 0x2b8280, 1, RI_ALL_ONLINE },
+        { 0x2b82c0, 1, RI_ALL_ONLINE }, { 0x2b8300, 1, RI_ALL_ONLINE },
+        { 0x2b8340, 1, RI_ALL_ONLINE }, { 0x2b8380, 1, RI_ALL_ONLINE },
+        { 0x2b83c0, 1, RI_ALL_ONLINE }, { 0x2b8400, 1, RI_ALL_ONLINE },
+        { 0x2b8440, 1, RI_ALL_ONLINE }, { 0x2b8480, 1, RI_ALL_ONLINE },
+        { 0x2b84c0, 1, RI_ALL_ONLINE }, { 0x2b8500, 1, RI_ALL_ONLINE },
+        { 0x2b8540, 1, RI_ALL_ONLINE }, { 0x2b8580, 1, RI_ALL_ONLINE },
+        { 0x2b85c0, 19, RI_E2E3_ONLINE }, { 0x2b8800, 1, RI_ALL_ONLINE },
+        { 0x2b8840, 1, RI_ALL_ONLINE }, { 0x2b8880, 1, RI_ALL_ONLINE },
+        { 0x2b88c0, 1, RI_ALL_ONLINE }, { 0x2b8900, 1, RI_ALL_ONLINE },
+        { 0x2b8940, 1, RI_ALL_ONLINE }, { 0x2b8980, 1, RI_ALL_ONLINE },
+        { 0x2b89c0, 1, RI_ALL_ONLINE }, { 0x2b8a00, 1, RI_ALL_ONLINE },
+        { 0x2b8a40, 1, RI_ALL_ONLINE }, { 0x2b8a80, 1, RI_ALL_ONLINE },
+        { 0x2b8ac0, 1, RI_ALL_ONLINE }, { 0x2b8b00, 1, RI_ALL_ONLINE },
+        { 0x2b8b40, 1, RI_ALL_ONLINE }, { 0x2b8b80, 1, RI_ALL_ONLINE },
+        { 0x2b8bc0, 1, RI_ALL_ONLINE }, { 0x2b8c00, 1, RI_ALL_ONLINE },
+        { 0x2b8c40, 1, RI_ALL_ONLINE }, { 0x2b8c80, 1, RI_ALL_ONLINE },
+        { 0x2b8cc0, 1, RI_ALL_ONLINE }, { 0x2b8cc4, 1, RI_E2E3_ONLINE },
+        { 0x2b8d00, 1, RI_ALL_ONLINE }, { 0x2b8d40, 1, RI_ALL_ONLINE },
+        { 0x2b8d80, 1, RI_ALL_ONLINE }, { 0x2b8dc0, 1, RI_ALL_ONLINE },
+        { 0x2b8e00, 1, RI_ALL_ONLINE }, { 0x2b8e40, 1, RI_ALL_ONLINE },
+        { 0x2b8e80, 1, RI_ALL_ONLINE }, { 0x2b8e84, 1, RI_E2E3_ONLINE },
+        { 0x2b8ec0, 1, RI_E1HE2E3_ONLINE }, { 0x2b8f00, 1, RI_E1HE2E3_ONLINE },
+        { 0x2b8f40, 1, RI_E1HE2E3_ONLINE }, { 0x2b8f80, 1, RI_E1HE2E3_ONLINE },
+        { 0x2b8fc0, 1, RI_E1HE2E3_ONLINE }, { 0x2b8fc4, 2, RI_E2E3_ONLINE },
+        { 0x2b8fd0, 6, RI_E2E3_ONLINE }, { 0x2b8fe8, 2, RI_E3_ONLINE },
+        { 0x2b9000, 1, RI_E2E3_ONLINE }, { 0x2b9040, 3, RI_E2E3_ONLINE },
+        { 0x2b905c, 1, RI_E3_ONLINE }, { 0x2b9400, 14, RI_E2E3_ONLINE },
+        { 0x2b943c, 19, RI_E2E3_ONLINE }, { 0x2b9490, 10, RI_E2E3_ONLINE },
+        { 0x2c0000, 2, RI_ALL_ONLINE }, { 0x300000, 65, RI_ALL_ONLINE },
+        { 0x30014c, 2, RI_E1HE2E3_ONLINE }, { 0x300200, 58, RI_ALL_ONLINE },
+        { 0x300340, 4, RI_ALL_ONLINE }, { 0x300380, 1, RI_E2E3_ONLINE },
+        { 0x300388, 1, RI_E2E3_ONLINE }, { 0x300390, 1, RI_E2E3_ONLINE },
+        { 0x300398, 1, RI_E2E3_ONLINE }, { 0x3003a0, 1, RI_E2E3_ONLINE },
+        { 0x3003a8, 2, RI_E2E3_ONLINE }, { 0x300400, 1, RI_ALL_ONLINE },
+        { 0x300404, 255, RI_E1E1H_OFFLINE }, { 0x302000, 4, RI_ALL_ONLINE },
+        { 0x302010, 2044, RI_ALL_OFFLINE }, { 0x304000, 4, RI_E3_ONLINE },
         { 0x320000, 1, RI_ALL_ONLINE }, { 0x320004, 5631, RI_ALL_OFFLINE },
-        { 0x325800, 2560, RI_E1HE2_OFFLINE }, { 0x328000, 1, RI_ALL_ONLINE },
-        { 0x328004, 8191, RI_E1HE2_OFFLINE }, { 0x330000, 1, RI_ALL_ONLINE },
-        { 0x330004, 15, RI_E1H_OFFLINE }, { 0x330040, 1, RI_E1HE2_ONLINE },
+        { 0x325800, 2560, RI_E1HE2E3_OFFLINE }, { 0x328000, 1, RI_ALL_ONLINE },
+        { 0x328004, 8191, RI_E1HE2E3_OFFLINE }, { 0x330000, 1, RI_ALL_ONLINE },
+        { 0x330004, 15, RI_E1H_OFFLINE }, { 0x330040, 1, RI_E1HE2E3_ONLINE },
         { 0x330044, 239, RI_E1H_OFFLINE }, { 0x330400, 1, RI_ALL_ONLINE },
         { 0x330404, 255, RI_E1H_OFFLINE }, { 0x330800, 1, RI_ALL_ONLINE },
-        { 0x330840, 1, RI_E1HE2_ONLINE }, { 0x330c00, 1, RI_ALL_ONLINE },
-        { 0x331000, 1, RI_ALL_ONLINE }, { 0x331040, 1, RI_E1HE2_ONLINE },
-        { 0x331400, 1, RI_ALL_ONLINE }, { 0x331440, 1, RI_E1HE2_ONLINE },
-        { 0x331480, 1, RI_E1HE2_ONLINE }, { 0x3314c0, 1, RI_E1HE2_ONLINE },
+        { 0x330840, 1, RI_E1HE2E3_ONLINE }, { 0x330c00, 1, RI_ALL_ONLINE },
+        { 0x331000, 1, RI_ALL_ONLINE }, { 0x331040, 1, RI_E1HE2E3_ONLINE },
+        { 0x331400, 1, RI_ALL_ONLINE }, { 0x331440, 1, RI_E1HE2E3_ONLINE },
+        { 0x331480, 1, RI_E1HE2E3_ONLINE }, { 0x3314c0, 1, RI_E1HE2E3_ONLINE },
         { 0x331800, 128, RI_ALL_OFFLINE }, { 0x331c00, 128, RI_ALL_OFFLINE },
-        { 0x332000, 1, RI_ALL_ONLINE }, { 0x332400, 1, RI_E1HE2_ONLINE },
-        { 0x332404, 5631, RI_E2_OFFLINE }, { 0x338000, 1, RI_ALL_ONLINE },
+        { 0x332000, 1, RI_ALL_ONLINE }, { 0x332400, 1, RI_E1HE2E3_ONLINE },
+        { 0x332404, 5631, RI_E2E3_OFFLINE }, { 0x338000, 1, RI_ALL_ONLINE },
         { 0x338040, 1, RI_ALL_ONLINE }, { 0x338080, 1, RI_ALL_ONLINE },
         { 0x3380c0, 1, RI_ALL_ONLINE }, { 0x338100, 1, RI_ALL_ONLINE },
         { 0x338140, 1, RI_ALL_ONLINE }, { 0x338180, 1, RI_ALL_ONLINE },
@@ -483,7 +582,7 @@ static const struct reg_addr reg_addrs[REGS_COUNT] = {
         { 0x338440, 1, RI_ALL_ONLINE }, { 0x338480, 1, RI_ALL_ONLINE },
         { 0x3384c0, 1, RI_ALL_ONLINE }, { 0x338500, 1, RI_ALL_ONLINE },
         { 0x338540, 1, RI_ALL_ONLINE }, { 0x338580, 1, RI_ALL_ONLINE },
-        { 0x3385c0, 19, RI_E2_ONLINE }, { 0x338800, 1, RI_ALL_ONLINE },
+        { 0x3385c0, 19, RI_E2E3_ONLINE }, { 0x338800, 1, RI_ALL_ONLINE },
         { 0x338840, 1, RI_ALL_ONLINE }, { 0x338880, 1, RI_ALL_ONLINE },
         { 0x3388c0, 1, RI_ALL_ONLINE }, { 0x338900, 1, RI_ALL_ONLINE },
         { 0x338940, 1, RI_ALL_ONLINE }, { 0x338980, 1, RI_ALL_ONLINE },
@@ -493,35 +592,48 @@ static const struct reg_addr reg_addrs[REGS_COUNT] = {
         { 0x338b40, 1, RI_ALL_ONLINE }, { 0x338b80, 1, RI_ALL_ONLINE },
         { 0x338bc0, 1, RI_ALL_ONLINE }, { 0x338c00, 1, RI_ALL_ONLINE },
         { 0x338c40, 1, RI_ALL_ONLINE }, { 0x338c80, 1, RI_ALL_ONLINE },
-        { 0x338cc0, 1, RI_ALL_ONLINE }, { 0x338cc4, 1, RI_E2_ONLINE },
+        { 0x338cc0, 1, RI_ALL_ONLINE }, { 0x338cc4, 1, RI_E2E3_ONLINE },
         { 0x338d00, 1, RI_ALL_ONLINE }, { 0x338d40, 1, RI_ALL_ONLINE },
         { 0x338d80, 1, RI_ALL_ONLINE }, { 0x338dc0, 1, RI_ALL_ONLINE },
         { 0x338e00, 1, RI_ALL_ONLINE }, { 0x338e40, 1, RI_ALL_ONLINE },
-        { 0x338e80, 1, RI_ALL_ONLINE }, { 0x338e84, 1, RI_E2_ONLINE },
-        { 0x338ec0, 1, RI_E1HE2_ONLINE }, { 0x338f00, 1, RI_E1HE2_ONLINE },
-        { 0x338f40, 1, RI_E1HE2_ONLINE }, { 0x338f80, 1, RI_E1HE2_ONLINE },
-        { 0x338fc0, 1, RI_E1HE2_ONLINE }, { 0x338fc4, 2, RI_E2_ONLINE },
-        { 0x338fd0, 6, RI_E2_ONLINE }, { 0x339000, 1, RI_E2_ONLINE },
-        { 0x339040, 3, RI_E2_ONLINE }, { 0x340000, 2, RI_ALL_ONLINE },
+        { 0x338e80, 1, RI_ALL_ONLINE }, { 0x338e84, 1, RI_E2E3_ONLINE },
+        { 0x338ec0, 1, RI_E1HE2E3_ONLINE }, { 0x338f00, 1, RI_E1HE2E3_ONLINE },
+        { 0x338f40, 1, RI_E1HE2E3_ONLINE }, { 0x338f80, 1, RI_E1HE2E3_ONLINE },
+        { 0x338fc0, 1, RI_E1HE2E3_ONLINE }, { 0x338fc4, 2, RI_E2E3_ONLINE },
+        { 0x338fd0, 6, RI_E2E3_ONLINE }, { 0x338fe8, 2, RI_E3_ONLINE },
+        { 0x339000, 1, RI_E2E3_ONLINE }, { 0x339040, 3, RI_E2E3_ONLINE },
+        { 0x33905c, 1, RI_E3_ONLINE }, { 0x340000, 2, RI_ALL_ONLINE },
 };
+#define REGS_COUNT                      ARRAY_SIZE(reg_addrs)
 
-#define IDLE_REGS_COUNT                 237
-static const struct reg_addr idle_addrs[IDLE_REGS_COUNT] = {
+static const struct reg_addr idle_addrs[] = {
         { 0x2104, 1, RI_ALL_ONLINE }, { 0x2110, 2, RI_ALL_ONLINE },
         { 0x211c, 8, RI_ALL_ONLINE }, { 0x2814, 1, RI_ALL_ONLINE },
         { 0x281c, 2, RI_ALL_ONLINE }, { 0x2854, 1, RI_ALL_ONLINE },
-        { 0x285c, 1, RI_ALL_ONLINE }, { 0x9010, 7, RI_E2_ONLINE },
-        { 0x9030, 1, RI_E2_ONLINE }, { 0x9068, 16, RI_E2_ONLINE },
-        { 0x9230, 2, RI_E2_ONLINE }, { 0x9244, 1, RI_E2_ONLINE },
-        { 0x9298, 1, RI_E2_ONLINE }, { 0x92a8, 1, RI_E2_ONLINE },
-        { 0xa38c, 1, RI_ALL_ONLINE }, { 0xa3c4, 1, RI_E1HE2_ONLINE },
-        { 0xa408, 1, RI_ALL_ONLINE }, { 0xa42c, 12, RI_ALL_ONLINE },
-        { 0xa600, 5, RI_E1HE2_ONLINE }, { 0xa618, 1, RI_E1HE2_ONLINE },
-        { 0xa714, 1, RI_E2_ONLINE }, { 0xa720, 1, RI_E2_ONLINE },
-        { 0xa750, 1, RI_E2_ONLINE }, { 0xc09c, 1, RI_E1E1H_ONLINE },
-        { 0x103b0, 1, RI_ALL_ONLINE }, { 0x103c0, 1, RI_ALL_ONLINE },
-        { 0x103d0, 1, RI_E1H_ONLINE }, { 0x183bc, 1, RI_E2_ONLINE },
-        { 0x183cc, 1, RI_E2_ONLINE }, { 0x2021c, 11, RI_ALL_ONLINE },
+        { 0x285c, 1, RI_ALL_ONLINE }, { 0x3040, 1, RI_ALL_ONLINE },
+        { 0x9010, 7, RI_E2E3_ONLINE }, { 0x9030, 1, RI_E2E3_ONLINE },
+        { 0x9068, 16, RI_E2E3_ONLINE }, { 0x9230, 2, RI_E2E3_ONLINE },
+        { 0x9244, 1, RI_E2E3_ONLINE }, { 0x9298, 1, RI_E2E3_ONLINE },
+        { 0x92a8, 1, RI_E2E3_ONLINE }, { 0xa38c, 1, RI_ALL_ONLINE },
+        { 0xa3c4, 1, RI_E1HE2E3_ONLINE }, { 0xa404, 3, RI_ALL_ONLINE },
+        { 0xa42c, 12, RI_ALL_ONLINE }, { 0xa600, 5, RI_E1HE2E3_ONLINE },
+        { 0xa618, 1, RI_E1HE2E3_ONLINE }, { 0xa714, 1, RI_E2E3_ONLINE },
+        { 0xa720, 1, RI_E2E3_ONLINE }, { 0xa750, 1, RI_E2E3_ONLINE },
+        { 0xc09c, 1, RI_E1E1H_ONLINE }, { 0x103b0, 1, RI_ALL_ONLINE },
+        { 0x103c0, 1, RI_ALL_ONLINE }, { 0x103d0, 1, RI_E1H_ONLINE },
+        { 0x10418, 1, RI_ALL_ONLINE }, { 0x10420, 1, RI_ALL_ONLINE },
+        { 0x10428, 1, RI_ALL_ONLINE }, { 0x10460, 1, RI_ALL_ONLINE },
+        { 0x10474, 1, RI_ALL_ONLINE }, { 0x104e0, 1, RI_ALL_ONLINE },
+        { 0x104ec, 1, RI_ALL_ONLINE }, { 0x104f8, 1, RI_ALL_ONLINE },
+        { 0x10508, 1, RI_ALL_ONLINE }, { 0x10530, 1, RI_ALL_ONLINE },
+        { 0x10538, 1, RI_ALL_ONLINE }, { 0x10548, 1, RI_ALL_ONLINE },
+        { 0x10558, 1, RI_ALL_ONLINE }, { 0x182a8, 1, RI_E2E3_ONLINE },
+        { 0x182b8, 1, RI_E2E3_ONLINE }, { 0x18308, 1, RI_E2E3_ONLINE },
+        { 0x18318, 1, RI_E2E3_ONLINE }, { 0x18338, 1, RI_E2E3_ONLINE },
+        { 0x18348, 1, RI_E2E3_ONLINE }, { 0x183bc, 1, RI_E2E3_ONLINE },
+        { 0x183cc, 1, RI_E2E3_ONLINE }, { 0x18570, 1, RI_E3_ONLINE },
+        { 0x18578, 1, RI_E3_ONLINE }, { 0x1858c, 1, RI_E3_ONLINE },
+        { 0x18594, 1, RI_E3_ONLINE }, { 0x2021c, 11, RI_ALL_ONLINE },
         { 0x202a8, 1, RI_ALL_ONLINE }, { 0x202b8, 1, RI_ALL_ONLINE },
         { 0x20404, 1, RI_ALL_ONLINE }, { 0x2040c, 2, RI_ALL_ONLINE },
         { 0x2041c, 2, RI_ALL_ONLINE }, { 0x40154, 14, RI_ALL_ONLINE },
@@ -551,8 +663,8 @@ static const struct reg_addr idle_addrs[IDLE_REGS_COUNT] = {
         { 0x102058, 1, RI_ALL_ONLINE }, { 0x102080, 16, RI_ALL_ONLINE },
         { 0x103004, 2, RI_ALL_ONLINE }, { 0x103068, 1, RI_ALL_ONLINE },
         { 0x103078, 1, RI_ALL_ONLINE }, { 0x103088, 1, RI_ALL_ONLINE },
-        { 0x10309c, 2, RI_E1HE2_ONLINE }, { 0x1030b8, 2, RI_E2_ONLINE },
-        { 0x1030cc, 1, RI_E2_ONLINE }, { 0x1030e0, 1, RI_E2_ONLINE },
+        { 0x10309c, 2, RI_E1HE2E3_ONLINE }, { 0x1030b8, 2, RI_E2E3_ONLINE },
+        { 0x1030cc, 1, RI_E2E3_ONLINE }, { 0x1030e0, 1, RI_E2E3_ONLINE },
         { 0x104004, 1, RI_ALL_ONLINE }, { 0x104018, 1, RI_ALL_ONLINE },
         { 0x104020, 1, RI_ALL_ONLINE }, { 0x10403c, 1, RI_ALL_ONLINE },
         { 0x1040fc, 1, RI_ALL_ONLINE }, { 0x10410c, 1, RI_ALL_ONLINE },
@@ -563,28 +675,27 @@ static const struct reg_addr idle_addrs[IDLE_REGS_COUNT] = {
         { 0x120414, 15, RI_ALL_ONLINE }, { 0x120478, 2, RI_ALL_ONLINE },
         { 0x12052c, 1, RI_ALL_ONLINE }, { 0x120564, 3, RI_ALL_ONLINE },
         { 0x12057c, 1, RI_ALL_ONLINE }, { 0x12058c, 1, RI_ALL_ONLINE },
-        { 0x120608, 1, RI_E1HE2_ONLINE }, { 0x120738, 1, RI_E2_ONLINE },
-        { 0x120778, 2, RI_E2_ONLINE }, { 0x120808, 3, RI_ALL_ONLINE },
-        { 0x120818, 1, RI_ALL_ONLINE }, { 0x120820, 1, RI_ALL_ONLINE },
-        { 0x120828, 1, RI_ALL_ONLINE }, { 0x120830, 1, RI_ALL_ONLINE },
-        { 0x120838, 1, RI_ALL_ONLINE }, { 0x120840, 1, RI_ALL_ONLINE },
-        { 0x120848, 1, RI_ALL_ONLINE }, { 0x120850, 1, RI_ALL_ONLINE },
-        { 0x120858, 1, RI_ALL_ONLINE }, { 0x120860, 1, RI_ALL_ONLINE },
-        { 0x120868, 1, RI_ALL_ONLINE }, { 0x120870, 1, RI_ALL_ONLINE },
-        { 0x120878, 1, RI_ALL_ONLINE }, { 0x120880, 1, RI_ALL_ONLINE },
-        { 0x120888, 1, RI_ALL_ONLINE }, { 0x120890, 1, RI_ALL_ONLINE },
-        { 0x120898, 1, RI_ALL_ONLINE }, { 0x1208a0, 1, RI_ALL_ONLINE },
-        { 0x1208a8, 1, RI_ALL_ONLINE }, { 0x1208b0, 1, RI_ALL_ONLINE },
-        { 0x1208b8, 1, RI_ALL_ONLINE }, { 0x1208c0, 1, RI_ALL_ONLINE },
-        { 0x1208c8, 1, RI_ALL_ONLINE }, { 0x1208d0, 1, RI_ALL_ONLINE },
-        { 0x1208d8, 1, RI_ALL_ONLINE }, { 0x1208e0, 1, RI_ALL_ONLINE },
-        { 0x1208e8, 1, RI_ALL_ONLINE }, { 0x1208f0, 1, RI_ALL_ONLINE },
-        { 0x1208f8, 1, RI_ALL_ONLINE }, { 0x120900, 1, RI_ALL_ONLINE },
-        { 0x120908, 1, RI_ALL_ONLINE }, { 0x120940, 5, RI_E2_ONLINE },
-        { 0x130030, 1, RI_E2_ONLINE }, { 0x13004c, 3, RI_E2_ONLINE },
-        { 0x130064, 2, RI_E2_ONLINE }, { 0x13009c, 1, RI_E2_ONLINE },
-        { 0x130130, 1, RI_E2_ONLINE }, { 0x13016c, 1, RI_E2_ONLINE },
-        { 0x130300, 1, RI_E2_ONLINE }, { 0x130480, 1, RI_E2_ONLINE },
+        { 0x120608, 1, RI_E1HE2E3_ONLINE }, { 0x120778, 2, RI_E2E3_ONLINE },
+        { 0x120808, 3, RI_ALL_ONLINE }, { 0x120818, 1, RI_ALL_ONLINE },
+        { 0x120820, 1, RI_ALL_ONLINE }, { 0x120828, 1, RI_ALL_ONLINE },
+        { 0x120830, 1, RI_ALL_ONLINE }, { 0x120838, 1, RI_ALL_ONLINE },
+        { 0x120840, 1, RI_ALL_ONLINE }, { 0x120848, 1, RI_ALL_ONLINE },
+        { 0x120850, 1, RI_ALL_ONLINE }, { 0x120858, 1, RI_ALL_ONLINE },
+        { 0x120860, 1, RI_ALL_ONLINE }, { 0x120868, 1, RI_ALL_ONLINE },
+        { 0x120870, 1, RI_ALL_ONLINE }, { 0x120878, 1, RI_ALL_ONLINE },
+        { 0x120880, 1, RI_ALL_ONLINE }, { 0x120888, 1, RI_ALL_ONLINE },
+        { 0x120890, 1, RI_ALL_ONLINE }, { 0x120898, 1, RI_ALL_ONLINE },
+        { 0x1208a0, 1, RI_ALL_ONLINE }, { 0x1208a8, 1, RI_ALL_ONLINE },
+        { 0x1208b0, 1, RI_ALL_ONLINE }, { 0x1208b8, 1, RI_ALL_ONLINE },
+        { 0x1208c0, 1, RI_ALL_ONLINE }, { 0x1208c8, 1, RI_ALL_ONLINE },
+        { 0x1208d0, 1, RI_ALL_ONLINE }, { 0x1208d8, 1, RI_ALL_ONLINE },
+        { 0x1208e0, 1, RI_ALL_ONLINE }, { 0x1208e8, 1, RI_ALL_ONLINE },
+        { 0x1208f0, 1, RI_ALL_ONLINE }, { 0x1208f8, 1, RI_ALL_ONLINE },
+        { 0x120900, 1, RI_ALL_ONLINE }, { 0x120908, 1, RI_ALL_ONLINE },
+        { 0x130030, 1, RI_E2E3_ONLINE }, { 0x13004c, 3, RI_E2E3_ONLINE },
+        { 0x130064, 2, RI_E2E3_ONLINE }, { 0x13009c, 1, RI_E2E3_ONLINE },
+        { 0x130130, 1, RI_E2E3_ONLINE }, { 0x13016c, 1, RI_E2E3_ONLINE },
+        { 0x130300, 1, RI_E2E3_ONLINE }, { 0x130480, 1, RI_E2E3_ONLINE },
         { 0x14005c, 2, RI_ALL_ONLINE }, { 0x1400d0, 2, RI_ALL_ONLINE },
         { 0x1400e0, 1, RI_ALL_ONLINE }, { 0x1401c8, 1, RI_ALL_ONLINE },
         { 0x140200, 6, RI_ALL_ONLINE }, { 0x16101c, 1, RI_ALL_ONLINE },
@@ -602,8 +713,8 @@ static const struct reg_addr idle_addrs[IDLE_REGS_COUNT] = {
         { 0x168438, 1, RI_ALL_ONLINE }, { 0x168448, 1, RI_ALL_ONLINE },
         { 0x168a00, 128, RI_ALL_ONLINE }, { 0x16e200, 128, RI_E1H_ONLINE },
         { 0x16e404, 2, RI_E1H_ONLINE }, { 0x16e584, 64, RI_E1H_ONLINE },
-        { 0x16e684, 2, RI_E1HE2_ONLINE }, { 0x16e68c, 4, RI_E1H_ONLINE },
-        { 0x16e6fc, 4, RI_E2_ONLINE }, { 0x1700a4, 1, RI_ALL_ONLINE },
+        { 0x16e684, 2, RI_E1HE2E3_ONLINE }, { 0x16e68c, 4, RI_E1H_ONLINE },
+        { 0x16e6fc, 4, RI_E2E3_ONLINE }, { 0x1700a4, 1, RI_ALL_ONLINE },
         { 0x1700ac, 2, RI_ALL_ONLINE }, { 0x1700c0, 1, RI_ALL_ONLINE },
         { 0x170174, 1, RI_ALL_ONLINE }, { 0x170184, 1, RI_ALL_ONLINE },
         { 0x1800f4, 1, RI_ALL_ONLINE }, { 0x180104, 1, RI_ALL_ONLINE },
@@ -627,51 +738,61 @@ static const struct reg_addr idle_addrs[IDLE_REGS_COUNT] = {
         { 0x338040, 1, RI_ALL_ONLINE }, { 0x338080, 1, RI_ALL_ONLINE },
         { 0x3380c0, 1, RI_ALL_ONLINE }
 };
+#define IDLE_REGS_COUNT                 ARRAY_SIZE(idle_addrs)
 
-#define WREGS_COUNT_E1                  1
 static const u32 read_reg_e1_0[] = { 0x1b1000 };
+#define WREGS_COUNT_E1                  ARRAY_SIZE(read_reg_e1_0)
 
 static const struct wreg_addr wreg_addrs_e1[WREGS_COUNT_E1] = {
         { 0x1b0c00, 192, 1, read_reg_e1_0, RI_E1_OFFLINE }
 };
 
-#define WREGS_COUNT_E1H                 1
 static const u32 read_reg_e1h_0[] = { 0x1b1040, 0x1b1000 };
+#define WREGS_COUNT_E1H                 ARRAY_SIZE(read_reg_e1h_0)
 
 static const struct wreg_addr wreg_addrs_e1h[WREGS_COUNT_E1H] = {
         { 0x1b0c00, 256, 2, read_reg_e1h_0, RI_E1H_OFFLINE }
 };
 
-#define WREGS_COUNT_E2                  1
 static const u32 read_reg_e2_0[] = { 0x1b1040, 0x1b1000 };
+#define WREGS_COUNT_E2                  ARRAY_SIZE(read_reg_e2_0)
 
 static const struct wreg_addr wreg_addrs_e2[WREGS_COUNT_E2] = {
         { 0x1b0c00, 128, 2, read_reg_e2_0, RI_E2_OFFLINE }
 };
 
-static const struct dump_sign dump_sign_all = { 0x4d18b0a4, 0x60010, 0x3a };
+static const u32 read_reg_e3_0[] = { 0x1b1040, 0x1b1000 };
+#define WREGS_COUNT_E3                  ARRAY_SIZE(read_reg_e3_0)
+
+static const struct wreg_addr wreg_addrs_e3[WREGS_COUNT_E3] = {
+        { 0x1b0c00, 128, 2, read_reg_e3_0, RI_E3_OFFLINE } };
+
+static const struct dump_sign dump_sign_all = { 0x4dbe9fca, 0x60011, 0x3a };
 
-#define TIMER_REGS_COUNT_E1             2
+static const u32 timer_status_regs_e1[] = { 0x164014, 0x164018 };
+#define TIMER_REGS_COUNT_E1             ARRAY_SIZE(timer_status_regs_e1)
 
-static const u32 timer_status_regs_e1[TIMER_REGS_COUNT_E1] = {
-        0x164014, 0x164018 };
 static const u32 timer_scan_regs_e1[TIMER_REGS_COUNT_E1] = {
         0x1640d0, 0x1640d4 };
 
-#define TIMER_REGS_COUNT_E1H            2
+static const u32 timer_status_regs_e1h[] = { 0x164014, 0x164018 };
+#define TIMER_REGS_COUNT_E1H            ARRAY_SIZE(timer_status_regs_e1h)
 
-static const u32 timer_status_regs_e1h[TIMER_REGS_COUNT_E1H] = {
-        0x164014, 0x164018 };
 static const u32 timer_scan_regs_e1h[TIMER_REGS_COUNT_E1H] = {
         0x1640d0, 0x1640d4 };
 
-#define TIMER_REGS_COUNT_E2             2
+static const u32 timer_status_regs_e2[] = { 0x164014, 0x164018 };
+#define TIMER_REGS_COUNT_E2             ARRAY_SIZE(timer_status_regs_e2)
 
-static const u32 timer_status_regs_e2[TIMER_REGS_COUNT_E2] = {
-        0x164014, 0x164018 };
 static const u32 timer_scan_regs_e2[TIMER_REGS_COUNT_E2] = {
         0x1640d0, 0x1640d4 };
 
+static const u32 timer_status_regs_e3[] = { 0x164014, 0x164018 };
+#define TIMER_REGS_COUNT_E3             ARRAY_SIZE(timer_status_regs_e3)
+
+static const u32 timer_scan_regs_e3[TIMER_REGS_COUNT_E3] = {
+        0x1640d0, 0x1640d4 };
+
 #define PAGE_MODE_VALUES_E1 0
 
 #define PAGE_READ_REGS_E1 0
@@ -682,7 +803,8 @@ static const u32 page_vals_e1[] = { 0 };
 
 static const u32 page_write_regs_e1[] = { 0 };
 
-static const struct reg_addr page_read_regs_e1[] = { { 0x0, 0, RI_E1_ONLINE } };
+static const struct reg_addr page_read_regs_e1[] = {
+        { 0x0, 0, RI_E1_ONLINE } };
 
 #define PAGE_MODE_VALUES_E1H 0
 
@@ -697,17 +819,24 @@ static const u32 page_write_regs_e1h[] = { 0 };
 static const struct reg_addr page_read_regs_e1h[] = {
         { 0x0, 0, RI_E1H_ONLINE } };
 
-#define PAGE_MODE_VALUES_E2 2
+static const u32 page_vals_e2[] = { 0, 128 };
+#define PAGE_MODE_VALUES_E2             ARRAY_SIZE(page_vals_e2)
 
-#define PAGE_READ_REGS_E2 1
+static const u32 page_write_regs_e2[] = { 328476 };
+#define PAGE_WRITE_REGS_E2              ARRAY_SIZE(page_write_regs_e2)
 
-#define PAGE_WRITE_REGS_E2 1
+static const struct reg_addr page_read_regs_e2[] = {
+        { 0x58000, 4608, RI_E2_ONLINE } };
+#define PAGE_READ_REGS_E2               ARRAY_SIZE(page_read_regs_e2)
 
-static const u32 page_vals_e2[PAGE_MODE_VALUES_E2] = { 0, 128 };
+static const u32 page_vals_e3[] = { 0, 128 };
+#define PAGE_MODE_VALUES_E3             ARRAY_SIZE(page_vals_e3)
 
-static const u32 page_write_regs_e2[PAGE_WRITE_REGS_E2] = { 328476 };
+static const u32 page_write_regs_e3[] = { 328476 };
+#define PAGE_WRITE_REGS_E3              ARRAY_SIZE(page_write_regs_e3)
 
-static const struct reg_addr page_read_regs_e2[PAGE_READ_REGS_E2] = {
-        { 0x58000, 4608, RI_E2_ONLINE } };
+static const struct reg_addr page_read_regs_e3[] = {
+        { 0x58000, 4608, RI_E3_ONLINE } };
+#define PAGE_READ_REGS_E3               ARRAY_SIZE(page_read_regs_e3)
 
 #endif /* BNX2X_DUMP_H */
diff --git a/drivers/net/bnx2x/bnx2x_ethtool.c b/drivers/net/bnx2x/bnx2x_ethtool.c
index 7a133052660a..1b4fa1d98005 100644
--- a/drivers/net/bnx2x/bnx2x_ethtool.c
+++ b/drivers/net/bnx2x/bnx2x_ethtool.c
@@ -38,8 +38,6 @@ static const struct {
         char string[ETH_GSTRING_LEN];
 } bnx2x_q_stats_arr[] = {
 /* 1 */ { Q_STATS_OFFSET32(total_bytes_received_hi), 8, "[%s]: rx_bytes" },
-        { Q_STATS_OFFSET32(error_bytes_received_hi),
-                                                8, "[%s]: rx_error_bytes" },
         { Q_STATS_OFFSET32(total_unicast_packets_received_hi),
                                                 8, "[%s]: rx_ucast_packets" },
         { Q_STATS_OFFSET32(total_multicast_packets_received_hi),
@@ -53,13 +51,18 @@ static const struct {
                                          4, "[%s]: rx_skb_alloc_discard" },
         { Q_STATS_OFFSET32(hw_csum_err), 4, "[%s]: rx_csum_offload_errors" },
 
-/* 10 */{ Q_STATS_OFFSET32(total_bytes_transmitted_hi), 8, "[%s]: tx_bytes" },
-        { Q_STATS_OFFSET32(total_unicast_packets_transmitted_hi),
+        { Q_STATS_OFFSET32(total_bytes_transmitted_hi), 8, "[%s]: tx_bytes" },
+/* 10 */{ Q_STATS_OFFSET32(total_unicast_packets_transmitted_hi),
                                                 8, "[%s]: tx_ucast_packets" },
         { Q_STATS_OFFSET32(total_multicast_packets_transmitted_hi),
                                                 8, "[%s]: tx_mcast_packets" },
         { Q_STATS_OFFSET32(total_broadcast_packets_transmitted_hi),
-                                                8, "[%s]: tx_bcast_packets" }
+                                                8, "[%s]: tx_bcast_packets" },
+        { Q_STATS_OFFSET32(total_tpa_aggregations_hi),
+                                                8, "[%s]: tpa_aggregations" },
+        { Q_STATS_OFFSET32(total_tpa_aggregated_frames_hi),
+                                        8, "[%s]: tpa_aggregated_frames"},
+        { Q_STATS_OFFSET32(total_tpa_bytes_hi), 8, "[%s]: tpa_bytes"}
 };
 
 #define BNX2X_NUM_Q_STATS ARRAY_SIZE(bnx2x_q_stats_arr)
@@ -99,8 +102,8 @@ static const struct {
                                 8, STATS_FLAGS_BOTH, "rx_discards" },
         { STATS_OFFSET32(mac_filter_discard),
                                 4, STATS_FLAGS_PORT, "rx_filtered_packets" },
-        { STATS_OFFSET32(xxoverflow_discard),
-                                4, STATS_FLAGS_PORT, "rx_fw_discards" },
+        { STATS_OFFSET32(mf_tag_discard),
+                                4, STATS_FLAGS_PORT, "rx_mf_tag_discard" },
         { STATS_OFFSET32(brb_drop_hi),
                                 8, STATS_FLAGS_PORT, "rx_brb_discard" },
         { STATS_OFFSET32(brb_truncate_hi),
@@ -159,7 +162,13 @@ static const struct {
         { STATS_OFFSET32(etherstatspktsover1522octets_hi),
                         8, STATS_FLAGS_PORT, "tx_1523_to_9022_byte_packets" },
         { STATS_OFFSET32(pause_frames_sent_hi),
-                                8, STATS_FLAGS_PORT, "tx_pause_frames" }
+                                8, STATS_FLAGS_PORT, "tx_pause_frames" },
+        { STATS_OFFSET32(total_tpa_aggregations_hi),
+                        8, STATS_FLAGS_FUNC, "tpa_aggregations" },
+        { STATS_OFFSET32(total_tpa_aggregated_frames_hi),
+                        8, STATS_FLAGS_FUNC, "tpa_aggregated_frames"},
+        { STATS_OFFSET32(total_tpa_bytes_hi),
+                        8, STATS_FLAGS_FUNC, "tpa_bytes"}
 };
 
 #define BNX2X_NUM_STATS         ARRAY_SIZE(bnx2x_stats_arr)
@@ -517,7 +526,7 @@ static int bnx2x_get_regs_len(struct net_device *dev)
                         if (IS_E1H_ONLINE(wreg_addrs_e1h[i].info))
                                 regdump_len += wreg_addrs_e1h[i].size *
                                         (1 + wreg_addrs_e1h[i].read_regs_count);
-        } else if (CHIP_IS_E2(bp)) {
+        } else if (!CHIP_IS_E1x(bp)) {
                 for (i = 0; i < REGS_COUNT; i++)
                         if (IS_E2_ONLINE(reg_addrs[i].info))
                                 regdump_len += reg_addrs[i].size;
@@ -589,7 +598,7 @@ static void bnx2x_get_regs(struct net_device *dev,
                 dump_hdr.info = RI_E1_ONLINE;
         else if (CHIP_IS_E1H(bp))
                 dump_hdr.info = RI_E1H_ONLINE;
-        else if (CHIP_IS_E2(bp))
+        else if (!CHIP_IS_E1x(bp))
                 dump_hdr.info = RI_E2_ONLINE |
                 (BP_PATH(bp) ? RI_PATH1_DUMP : RI_PATH0_DUMP);
 
@@ -610,14 +619,18 @@ static void bnx2x_get_regs(struct net_device *dev,
                                         *p++ = REG_RD(bp,
                                                       reg_addrs[i].addr + j*4);
 
-        } else if (CHIP_IS_E2(bp)) {
+        } else if (!CHIP_IS_E1x(bp)) {
                 for (i = 0; i < REGS_COUNT; i++)
                         if (IS_E2_ONLINE(reg_addrs[i].info))
                                 for (j = 0; j < reg_addrs[i].size; j++)
                                         *p++ = REG_RD(bp,
                                               reg_addrs[i].addr + j*4);
 
-                bnx2x_read_pages_regs_e2(bp, p);
+                if (CHIP_IS_E2(bp))
+                        bnx2x_read_pages_regs_e2(bp, p);
+                else
+                        /* E3 paged registers read is unimplemented yet */
+                        WARN_ON(1);
         }
         /* Re-enable parity attentions */
         bnx2x_clear_blocks_parity(bp);
@@ -625,8 +638,6 @@ static void bnx2x_get_regs(struct net_device *dev,
                 bnx2x_enable_blocks_parity(bp);
 }
 
-#define PHY_FW_VER_LEN                  20
-
 static void bnx2x_get_drvinfo(struct net_device *dev,
                               struct ethtool_drvinfo *info)
 {
@@ -1334,60 +1345,129 @@ static const struct {
         { "idle check (online)" }
 };
 
+enum {
+        BNX2X_CHIP_E1_OFST = 0,
+        BNX2X_CHIP_E1H_OFST,
+        BNX2X_CHIP_E2_OFST,
+        BNX2X_CHIP_E3_OFST,
+        BNX2X_CHIP_E3B0_OFST,
+        BNX2X_CHIP_MAX_OFST
+};
+
+#define BNX2X_CHIP_MASK_E1      (1 << BNX2X_CHIP_E1_OFST)
+#define BNX2X_CHIP_MASK_E1H     (1 << BNX2X_CHIP_E1H_OFST)
+#define BNX2X_CHIP_MASK_E2      (1 << BNX2X_CHIP_E2_OFST)
+#define BNX2X_CHIP_MASK_E3      (1 << BNX2X_CHIP_E3_OFST)
+#define BNX2X_CHIP_MASK_E3B0    (1 << BNX2X_CHIP_E3B0_OFST)
+
+#define BNX2X_CHIP_MASK_ALL     ((1 << BNX2X_CHIP_MAX_OFST) - 1)
+#define BNX2X_CHIP_MASK_E1X     (BNX2X_CHIP_MASK_E1 | BNX2X_CHIP_MASK_E1H)
+
 static int bnx2x_test_registers(struct bnx2x *bp)
 {
         int idx, i, rc = -ENODEV;
-        u32 wr_val = 0;
+        u32 wr_val = 0, hw;
         int port = BP_PORT(bp);
         static const struct {
+                u32 hw;
                 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_LLH0_T_BIT,                  4, 0x00000001 },
-                { NIG_REG_EMAC0_IN_EN,                 4, 0x00000001 },
-/* 20 */        { 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 },
-                { NIG_REG_LLH0_DEST_UDP_0,           160, 0x0000ffff },
-/* 30 */        { 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 }
+/* 0 */         { BNX2X_CHIP_MASK_ALL,
+                        BRB1_REG_PAUSE_LOW_THRESHOLD_0, 4, 0x000003ff },
+                { BNX2X_CHIP_MASK_ALL,
+                        DORQ_REG_DB_ADDR0,              4, 0xffffffff },
+                { BNX2X_CHIP_MASK_E1X,
+                        HC_REG_AGG_INT_0,               4, 0x000003ff },
+                { BNX2X_CHIP_MASK_ALL,
+                        PBF_REG_MAC_IF0_ENABLE,         4, 0x00000001 },
+                { BNX2X_CHIP_MASK_E1X | BNX2X_CHIP_MASK_E2 | BNX2X_CHIP_MASK_E3,
+                        PBF_REG_P0_INIT_CRD,            4, 0x000007ff },
+                { BNX2X_CHIP_MASK_E3B0,
+                        PBF_REG_INIT_CRD_Q0,            4, 0x000007ff },
+                { BNX2X_CHIP_MASK_ALL,
+                        PRS_REG_CID_PORT_0,             4, 0x00ffffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        PXP2_REG_PSWRQ_CDU0_L2P,        4, 0x000fffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        PXP2_REG_RQ_CDU0_EFIRST_MEM_ADDR, 8, 0x0003ffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        PXP2_REG_PSWRQ_TM0_L2P,         4, 0x000fffff },
+/* 10 */        { BNX2X_CHIP_MASK_ALL,
+                        PXP2_REG_RQ_USDM0_EFIRST_MEM_ADDR, 8, 0x0003ffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        PXP2_REG_PSWRQ_TSDM0_L2P,       4, 0x000fffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        QM_REG_CONNNUM_0,               4, 0x000fffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        TM_REG_LIN0_MAX_ACTIVE_CID,     4, 0x0003ffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        SRC_REG_KEYRSS0_0,              40, 0xffffffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        SRC_REG_KEYRSS0_7,              40, 0xffffffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        XCM_REG_WU_DA_SET_TMR_CNT_FLG_CMD00, 4, 0x00000001 },
+                { BNX2X_CHIP_MASK_ALL,
+                        XCM_REG_WU_DA_CNT_CMD00,        4, 0x00000003 },
+                { BNX2X_CHIP_MASK_ALL,
+                        XCM_REG_GLB_DEL_ACK_MAX_CNT_0,  4, 0x000000ff },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_T_BIT,             4, 0x00000001 },
+/* 20 */        { BNX2X_CHIP_MASK_E1X | BNX2X_CHIP_MASK_E2,
+                        NIG_REG_EMAC0_IN_EN,            4, 0x00000001 },
+                { BNX2X_CHIP_MASK_E1X | BNX2X_CHIP_MASK_E2,
+                        NIG_REG_BMAC0_IN_EN,            4, 0x00000001 },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_XCM0_OUT_EN,            4, 0x00000001 },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_BRB0_OUT_EN,            4, 0x00000001 },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_XCM_MASK,          4, 0x00000007 },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_ACPI_PAT_6_LEN,    68, 0x000000ff },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_ACPI_PAT_0_CRC,    68, 0xffffffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_DEST_MAC_0_0,      160, 0xffffffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_DEST_IP_0_1,       160, 0xffffffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_IPV4_IPV6_0,       160, 0x00000001 },
+/* 30 */        { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_DEST_UDP_0,        160, 0x0000ffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_DEST_TCP_0,        160, 0x0000ffff },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LLH0_VLAN_ID_0, 160, 0x00000fff },
+                { BNX2X_CHIP_MASK_E1X | BNX2X_CHIP_MASK_E2,
+                        NIG_REG_XGXS_SERDES0_MODE_SEL,  4, 0x00000001 },
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0, 4, 0x00000001},
+                { BNX2X_CHIP_MASK_ALL,
+                        NIG_REG_STATUS_INTERRUPT_PORT0, 4, 0x07ffffff },
+                { BNX2X_CHIP_MASK_E1X | BNX2X_CHIP_MASK_E2,
+                        NIG_REG_XGXS0_CTRL_EXTREMOTEMDIOST, 24, 0x00000001 },
+                { BNX2X_CHIP_MASK_E1X | BNX2X_CHIP_MASK_E2,
+                        NIG_REG_SERDES0_CTRL_PHY_ADDR,  16, 0x0000001f },
+
+                { BNX2X_CHIP_MASK_ALL, 0xffffffff, 0, 0x00000000 }
         };
 
         if (!netif_running(bp->dev))
                 return rc;
 
+        if (CHIP_IS_E1(bp))
+                hw = BNX2X_CHIP_MASK_E1;
+        else if (CHIP_IS_E1H(bp))
+                hw = BNX2X_CHIP_MASK_E1H;
+        else if (CHIP_IS_E2(bp))
+                hw = BNX2X_CHIP_MASK_E2;
+        else if (CHIP_IS_E3B0(bp))
+                hw = BNX2X_CHIP_MASK_E3B0;
+        else /* e3 A0 */
+                hw = BNX2X_CHIP_MASK_E3;
+
         /* Repeat the test twice:
            First by writing 0x00000000, second by writing 0xffffffff */
         for (idx = 0; idx < 2; idx++) {
@@ -1403,8 +1483,7 @@ static int bnx2x_test_registers(struct bnx2x *bp)
 
                 for (i = 0; reg_tbl[i].offset0 != 0xffffffff; i++) {
                         u32 offset, mask, save_val, val;
-                        if (CHIP_IS_E2(bp) &&
-                            reg_tbl[i].offset0 == HC_REG_AGG_INT_0)
+                        if (!(hw & reg_tbl[i].hw))
                                 continue;
 
                         offset = reg_tbl[i].offset0 + port*reg_tbl[i].offset1;
@@ -1421,7 +1500,7 @@ static int bnx2x_test_registers(struct bnx2x *bp)
 
                         /* verify value is as expected */
                         if ((val & mask) != (wr_val & mask)) {
-                                DP(NETIF_MSG_PROBE,
+                                DP(NETIF_MSG_HW,
                                    "offset 0x%x: val 0x%x != 0x%x mask 0x%x\n",
                                    offset, val, wr_val, mask);
                                 goto test_reg_exit;
@@ -1438,7 +1517,7 @@ test_reg_exit:
 static int bnx2x_test_memory(struct bnx2x *bp)
 {
         int i, j, rc = -ENODEV;
-        u32 val;
+        u32 val, index;
         static const struct {
                 u32 offset;
                 int size;
@@ -1453,32 +1532,44 @@ static int bnx2x_test_memory(struct bnx2x *bp)
 
                 { 0xffffffff, 0 }
         };
+
         static const struct {
                 char *name;
                 u32 offset;
-                u32 e1_mask;
-                u32 e1h_mask;
-                u32 e2_mask;
+                u32 hw_mask[BNX2X_CHIP_MAX_OFST];
         } prty_tbl[] = {
-                { "CCM_PRTY_STS",  CCM_REG_CCM_PRTY_STS,   0x3ffc0, 0,   0 },
-                { "CFC_PRTY_STS",  CFC_REG_CFC_PRTY_STS,   0x2,     0x2, 0 },
-                { "DMAE_PRTY_STS", DMAE_REG_DMAE_PRTY_STS, 0,       0,   0 },
-                { "TCM_PRTY_STS",  TCM_REG_TCM_PRTY_STS,   0x3ffc0, 0,   0 },
-                { "UCM_PRTY_STS",  UCM_REG_UCM_PRTY_STS,   0x3ffc0, 0,   0 },
-                { "XCM_PRTY_STS",  XCM_REG_XCM_PRTY_STS,   0x3ffc1, 0,   0 },
-
-                { NULL, 0xffffffff, 0, 0, 0 }
+                { "CCM_PRTY_STS",  CCM_REG_CCM_PRTY_STS,
+                        {0x3ffc0, 0,   0, 0} },
+                { "CFC_PRTY_STS",  CFC_REG_CFC_PRTY_STS,
+                        {0x2,     0x2, 0, 0} },
+                { "DMAE_PRTY_STS", DMAE_REG_DMAE_PRTY_STS,
+                        {0,       0,   0, 0} },
+                { "TCM_PRTY_STS",  TCM_REG_TCM_PRTY_STS,
+                        {0x3ffc0, 0,   0, 0} },
+                { "UCM_PRTY_STS",  UCM_REG_UCM_PRTY_STS,
+                        {0x3ffc0, 0,   0, 0} },
+                { "XCM_PRTY_STS",  XCM_REG_XCM_PRTY_STS,
+                        {0x3ffc1, 0,   0, 0} },
+
+                { NULL, 0xffffffff, {0, 0, 0, 0} }
         };
 
         if (!netif_running(bp->dev))
                 return rc;
 
+        if (CHIP_IS_E1(bp))
+                index = BNX2X_CHIP_E1_OFST;
+        else if (CHIP_IS_E1H(bp))
+                index = BNX2X_CHIP_E1H_OFST;
+        else if (CHIP_IS_E2(bp))
+                index = BNX2X_CHIP_E2_OFST;
+        else /* e3 */
+                index = BNX2X_CHIP_E3_OFST;
+
         /* pre-Check the parity status */
         for (i = 0; prty_tbl[i].offset != 0xffffffff; i++) {
                 val = REG_RD(bp, prty_tbl[i].offset);
-                if ((CHIP_IS_E1(bp) && (val & ~(prty_tbl[i].e1_mask))) ||
-                    (CHIP_IS_E1H(bp) && (val & ~(prty_tbl[i].e1h_mask))) ||
-                    (CHIP_IS_E2(bp) && (val & ~(prty_tbl[i].e2_mask)))) {
+                if (val & ~(prty_tbl[i].hw_mask[index])) {
                         DP(NETIF_MSG_HW,
                            "%s is 0x%x\n", prty_tbl[i].name, val);
                         goto test_mem_exit;
@@ -1493,9 +1584,7 @@ static int bnx2x_test_memory(struct bnx2x *bp)
         /* Check the parity status */
         for (i = 0; prty_tbl[i].offset != 0xffffffff; i++) {
                 val = REG_RD(bp, prty_tbl[i].offset);
-                if ((CHIP_IS_E1(bp) && (val & ~(prty_tbl[i].e1_mask))) ||
-                    (CHIP_IS_E1H(bp) && (val & ~(prty_tbl[i].e1h_mask))) ||
-                    (CHIP_IS_E2(bp) && (val & ~(prty_tbl[i].e2_mask)))) {
+                if (val & ~(prty_tbl[i].hw_mask[index])) {
                         DP(NETIF_MSG_HW,
                            "%s is 0x%x\n", prty_tbl[i].name, val);
                         goto test_mem_exit;
@@ -1512,12 +1601,16 @@ static void bnx2x_wait_for_link(struct bnx2x *bp, u8 link_up, u8 is_serdes)
 {
         int cnt = 1400;
 
-        if (link_up)
+        if (link_up) {
                 while (bnx2x_link_test(bp, is_serdes) && cnt--)
-                        msleep(10);
+                        msleep(20);
+
+                if (cnt <= 0 && bnx2x_link_test(bp, is_serdes))
+                        DP(NETIF_MSG_LINK, "Timeout waiting for link up\n");
+        }
 }
 
-static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
+static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode)
 {
         unsigned int pkt_size, num_pkts, i;
         struct sk_buff *skb;
@@ -1526,14 +1619,14 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
         struct bnx2x_fastpath *fp_tx = &bp->fp[0];
         u16 tx_start_idx, tx_idx;
         u16 rx_start_idx, rx_idx;
-        u16 pkt_prod, bd_prod;
+        u16 pkt_prod, bd_prod, rx_comp_cons;
         struct sw_tx_bd *tx_buf;
         struct eth_tx_start_bd *tx_start_bd;
         struct eth_tx_parse_bd_e1x  *pbd_e1x = NULL;
         struct eth_tx_parse_bd_e2  *pbd_e2 = NULL;
         dma_addr_t mapping;
         union eth_rx_cqe *cqe;
-        u8 cqe_fp_flags;
+        u8 cqe_fp_flags, cqe_fp_type;
         struct sw_rx_bd *rx_buf;
         u16 len;
         int rc = -ENODEV;
@@ -1545,7 +1638,8 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
                         return -EINVAL;
                 break;
         case BNX2X_MAC_LOOPBACK:
-                bp->link_params.loopback_mode = LOOPBACK_BMAC;
+                bp->link_params.loopback_mode = CHIP_IS_E3(bp) ?
+                                                LOOPBACK_XMAC : LOOPBACK_BMAC;
                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
                 break;
         default:
@@ -1566,6 +1660,14 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
         memset(packet + 2*ETH_ALEN, 0x77, (ETH_HLEN - 2*ETH_ALEN));
         for (i = ETH_HLEN; i < pkt_size; i++)
                 packet[i] = (unsigned char) (i & 0xff);
+        mapping = dma_map_single(&bp->pdev->dev, skb->data,
+                                 skb_headlen(skb), DMA_TO_DEVICE);
+        if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
+                rc = -ENOMEM;
+                dev_kfree_skb(skb);
+                BNX2X_ERR("Unable to map SKB\n");
+                goto test_loopback_exit;
+        }
 
         /* send the loopback packet */
         num_pkts = 0;
@@ -1580,8 +1682,6 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
 
         bd_prod = TX_BD(fp_tx->tx_bd_prod);
         tx_start_bd = &fp_tx->tx_desc_ring[bd_prod].start_bd;
-        mapping = dma_map_single(&bp->pdev->dev, skb->data,
-                                 skb_headlen(skb), DMA_TO_DEVICE);
         tx_start_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
         tx_start_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
         tx_start_bd->nbd = cpu_to_le16(2); /* start + pbd */
@@ -1611,6 +1711,7 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
         DOORBELL(bp, fp_tx->index, fp_tx->tx_db.raw);
 
         mmiowb();
+        barrier();
 
         num_pkts++;
         fp_tx->tx_bd_prod += 2; /* start + pbd */
@@ -1639,9 +1740,11 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
         if (rx_idx != rx_start_idx + num_pkts)
                 goto test_loopback_exit;
 
-        cqe = &fp_rx->rx_comp_ring[RCQ_BD(fp_rx->rx_comp_cons)];
+        rx_comp_cons = le16_to_cpu(fp_rx->rx_comp_cons);
+        cqe = &fp_rx->rx_comp_ring[RCQ_BD(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))
+        cqe_fp_type = cqe_fp_flags & ETH_FAST_PATH_RX_CQE_TYPE;
+        if (!CQE_TYPE_FAST(cqe_fp_type) || (cqe_fp_flags & ETH_RX_ERROR_FALGS))
                 goto test_loopback_rx_exit;
 
         len = le16_to_cpu(cqe->fast_path_cqe.pkt_len);
@@ -1649,6 +1752,9 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
                 goto test_loopback_rx_exit;
 
         rx_buf = &fp_rx->rx_buf_ring[RX_BD(fp_rx->rx_bd_cons)];
+        dma_sync_single_for_device(&bp->pdev->dev,
+                                   dma_unmap_addr(rx_buf, mapping),
+                                   fp_rx->rx_buf_size, DMA_FROM_DEVICE);
         skb = rx_buf->skb;
         skb_reserve(skb, cqe->fast_path_cqe.placement_offset);
         for (i = ETH_HLEN; i < pkt_size; i++)
@@ -1674,7 +1780,7 @@ test_loopback_exit:
         return rc;
 }
 
-static int bnx2x_test_loopback(struct bnx2x *bp, u8 link_up)
+static int bnx2x_test_loopback(struct bnx2x *bp)
 {
         int rc = 0, res;
 
@@ -1687,13 +1793,13 @@ static int bnx2x_test_loopback(struct bnx2x *bp, u8 link_up)
         bnx2x_netif_stop(bp, 1);
         bnx2x_acquire_phy_lock(bp);
 
-        res = bnx2x_run_loopback(bp, BNX2X_PHY_LOOPBACK, link_up);
+        res = bnx2x_run_loopback(bp, BNX2X_PHY_LOOPBACK);
         if (res) {
                 DP(NETIF_MSG_PROBE, "  PHY loopback failed  (res %d)\n", res);
                 rc |= BNX2X_PHY_LOOPBACK_FAILED;
         }
 
-        res = bnx2x_run_loopback(bp, BNX2X_MAC_LOOPBACK, link_up);
+        res = bnx2x_run_loopback(bp, BNX2X_MAC_LOOPBACK);
         if (res) {
                 DP(NETIF_MSG_PROBE, "  MAC loopback failed  (res %d)\n", res);
                 rc |= BNX2X_MAC_LOOPBACK_FAILED;
@@ -1765,39 +1871,20 @@ test_nvram_exit:
         return rc;
 }
 
+/* Send an EMPTY ramrod on the first queue */
 static int bnx2x_test_intr(struct bnx2x *bp)
 {
-        struct mac_configuration_cmd *config = bnx2x_sp(bp, mac_config);
-        int i, rc;
+        struct bnx2x_queue_state_params params = {0};
 
         if (!netif_running(bp->dev))
                 return -ENODEV;
 
-        config->hdr.length = 0;
-        if (CHIP_IS_E1(bp))
-                config->hdr.offset = (BP_PORT(bp) ? 32 : 0);
-        else
-                config->hdr.offset = BP_FUNC(bp);
-        config->hdr.client_id = bp->fp->cl_id;
-        config->hdr.reserved1 = 0;
-
-        bp->set_mac_pending = 1;
-        smp_wmb();
-        rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
-                           U64_HI(bnx2x_sp_mapping(bp, mac_config)),
-                           U64_LO(bnx2x_sp_mapping(bp, mac_config)), 1);
-        if (rc == 0) {
-                for (i = 0; i < 10; i++) {
-                        if (!bp->set_mac_pending)
-                                break;
-                        smp_rmb();
-                        msleep_interruptible(10);
-                }
-                if (i == 10)
-                        rc = -ENODEV;
-        }
+        params.q_obj = &bp->fp->q_obj;
+        params.cmd = BNX2X_Q_CMD_EMPTY;
 
-        return rc;
+        __set_bit(RAMROD_COMP_WAIT, &params.ramrod_flags);
+
+        return bnx2x_queue_state_change(bp, &params);
 }
 
 static void bnx2x_self_test(struct net_device *dev,
@@ -1836,7 +1923,7 @@ static void bnx2x_self_test(struct net_device *dev,
                 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, is_serdes);
+                bnx2x_wait_for_link(bp, 1, is_serdes);
 
                 if (bnx2x_test_registers(bp) != 0) {
                         buf[0] = 1;
@@ -1847,7 +1934,7 @@ static void bnx2x_self_test(struct net_device *dev,
                         etest->flags |= ETH_TEST_FL_FAILED;
                 }
 
-                buf[2] = bnx2x_test_loopback(bp, link_up);
+                buf[2] = bnx2x_test_loopback(bp);
                 if (buf[2] != 0)
                         etest->flags |= ETH_TEST_FL_FAILED;
 
@@ -1885,6 +1972,14 @@ static void bnx2x_self_test(struct net_device *dev,
 #define IS_MF_MODE_STAT(bp) \
                         (IS_MF(bp) && !(bp->msg_enable & BNX2X_MSG_STATS))
 
+/* ethtool statistics are displayed for all regular ethernet queues and the
+ * fcoe L2 queue if not disabled
+ */
+static inline int bnx2x_num_stat_queues(struct bnx2x *bp)
+{
+        return BNX2X_NUM_ETH_QUEUES(bp);
+}
+
 static int bnx2x_get_sset_count(struct net_device *dev, int stringset)
 {
         struct bnx2x *bp = netdev_priv(dev);
@@ -1893,7 +1988,7 @@ static int bnx2x_get_sset_count(struct net_device *dev, int stringset)
         switch (stringset) {
         case ETH_SS_STATS:
                 if (is_multi(bp)) {
-                        num_stats = BNX2X_NUM_STAT_QUEUES(bp) *
+                        num_stats = bnx2x_num_stat_queues(bp) *
                                 BNX2X_NUM_Q_STATS;
                         if (!IS_MF_MODE_STAT(bp))
                                 num_stats += BNX2X_NUM_STATS;
@@ -1926,14 +2021,9 @@ static void bnx2x_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
         case ETH_SS_STATS:
                 if (is_multi(bp)) {
                         k = 0;
-                        for_each_napi_queue(bp, i) {
+                        for_each_eth_queue(bp, i) {
                                 memset(queue_name, 0, sizeof(queue_name));
-
-                                if (IS_FCOE_IDX(i))
-                                        sprintf(queue_name, "fcoe");
-                                else
-                                        sprintf(queue_name, "%d", i);
-
+                                sprintf(queue_name, "%d", i);
                                 for (j = 0; j < BNX2X_NUM_Q_STATS; j++)
                                         snprintf(buf + (k + j)*ETH_GSTRING_LEN,
                                                 ETH_GSTRING_LEN,
@@ -1972,7 +2062,7 @@ static void bnx2x_get_ethtool_stats(struct net_device *dev,
 
         if (is_multi(bp)) {
                 k = 0;
-                for_each_napi_queue(bp, i) {
+                for_each_eth_queue(bp, i) {
                         hw_stats = (u32 *)&bp->fp[i].eth_q_stats;
                         for (j = 0; j < BNX2X_NUM_Q_STATS; j++) {
                                 if (bnx2x_q_stats_arr[j].size == 0) {
@@ -2090,14 +2180,30 @@ static int bnx2x_get_rxfh_indir(struct net_device *dev,
 {
         struct bnx2x *bp = netdev_priv(dev);
         size_t copy_size =
-                min_t(size_t, indir->size, TSTORM_INDIRECTION_TABLE_SIZE);
+                min_t(size_t, indir->size, T_ETH_INDIRECTION_TABLE_SIZE);
+        u8 ind_table[T_ETH_INDIRECTION_TABLE_SIZE] = {0};
+        size_t i;
 
         if (bp->multi_mode == ETH_RSS_MODE_DISABLED)
                 return -EOPNOTSUPP;
 
-        indir->size = TSTORM_INDIRECTION_TABLE_SIZE;
-        memcpy(indir->ring_index, bp->rx_indir_table,
-               copy_size * sizeof(bp->rx_indir_table[0]));
+        /* Get the current configuration of the RSS indirection table */
+        bnx2x_get_rss_ind_table(&bp->rss_conf_obj, ind_table);
+
+        /*
+         * We can't use a memcpy() as an internal storage of an
+         * indirection table is a u8 array while indir->ring_index
+         * points to an array of u32.
+         *
+         * Indirection table contains the FW Client IDs, so we need to
+         * align the returned table to the Client ID of the leading RSS
+         * queue.
+         */
+        for (i = 0; i < copy_size; i++)
+                indir->ring_index[i] = ind_table[i] - bp->fp->cl_id;
+
+        indir->size = T_ETH_INDIRECTION_TABLE_SIZE;
+
         return 0;
 }
 
@@ -2106,21 +2212,33 @@ static int bnx2x_set_rxfh_indir(struct net_device *dev,
 {
         struct bnx2x *bp = netdev_priv(dev);
         size_t i;
+        u8 ind_table[T_ETH_INDIRECTION_TABLE_SIZE] = {0};
+        u32 num_eth_queues = BNX2X_NUM_ETH_QUEUES(bp);
 
         if (bp->multi_mode == ETH_RSS_MODE_DISABLED)
                 return -EOPNOTSUPP;
 
-        /* Validate size and indices */
-        if (indir->size != TSTORM_INDIRECTION_TABLE_SIZE)
+        /* validate the size */
+        if (indir->size != T_ETH_INDIRECTION_TABLE_SIZE)
                 return -EINVAL;
-        for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
-                if (indir->ring_index[i] >= BNX2X_NUM_ETH_QUEUES(bp))
+
+        for (i = 0; i < T_ETH_INDIRECTION_TABLE_SIZE; i++) {
+                /* validate the indices */
+                if (indir->ring_index[i] >= num_eth_queues)
                         return -EINVAL;
+                /*
+                 * The same as in bnx2x_get_rxfh_indir: we can't use a memcpy()
+                 * as an internal storage of an indirection table is a u8 array
+                 * while indir->ring_index points to an array of u32.
+                 *
+                 * Indirection table contains the FW Client IDs, so we need to
+                 * align the received table to the Client ID of the leading RSS
+                 * queue
+                 */
+                ind_table[i] = indir->ring_index[i] + bp->fp->cl_id;
+        }
 
-        memcpy(bp->rx_indir_table, indir->ring_index,
-               indir->size * sizeof(bp->rx_indir_table[0]));
-        bnx2x_push_indir_table(bp);
-        return 0;
+        return bnx2x_config_rss_pf(bp, ind_table, false);
 }
 
 static const struct ethtool_ops bnx2x_ethtool_ops = {
diff --git a/drivers/net/bnx2x/bnx2x_fw_defs.h b/drivers/net/bnx2x/bnx2x_fw_defs.h
index 9fe367836a57..998652a1b858 100644
--- a/drivers/net/bnx2x/bnx2x_fw_defs.h
+++ b/drivers/net/bnx2x/bnx2x_fw_defs.h
@@ -10,249 +10,221 @@
 #ifndef BNX2X_FW_DEFS_H
 #define BNX2X_FW_DEFS_H
 
-#define CSTORM_ASSERT_LIST_INDEX_OFFSET (IRO[142].base)
+#define CSTORM_ASSERT_LIST_INDEX_OFFSET (IRO[148].base)
 #define CSTORM_ASSERT_LIST_OFFSET(assertListEntry) \
-        (IRO[141].base + ((assertListEntry) * IRO[141].m1))
-#define CSTORM_ETH_STATS_QUERY_ADDR_OFFSET(pfId) \
-        (IRO[144].base + ((pfId) * IRO[144].m1))
+        (IRO[147].base + ((assertListEntry) * IRO[147].m1))
 #define CSTORM_EVENT_RING_DATA_OFFSET(pfId) \
-        (IRO[149].base + (((pfId)>>1) * IRO[149].m1) + (((pfId)&1) * \
-        IRO[149].m2))
+        (IRO[153].base + (((pfId)>>1) * IRO[153].m1) + (((pfId)&1) * \
+        IRO[153].m2))
 #define CSTORM_EVENT_RING_PROD_OFFSET(pfId) \
-        (IRO[150].base + (((pfId)>>1) * IRO[150].m1) + (((pfId)&1) * \
-        IRO[150].m2))
+        (IRO[154].base + (((pfId)>>1) * IRO[154].m1) + (((pfId)&1) * \
+        IRO[154].m2))
 #define CSTORM_FINAL_CLEANUP_COMPLETE_OFFSET(funcId) \
-        (IRO[156].base + ((funcId) * IRO[156].m1))
+        (IRO[159].base + ((funcId) * IRO[159].m1))
 #define CSTORM_FUNC_EN_OFFSET(funcId) \
-        (IRO[146].base + ((funcId) * IRO[146].m1))
-#define CSTORM_FUNCTION_MODE_OFFSET (IRO[153].base)
-#define CSTORM_IGU_MODE_OFFSET (IRO[154].base)
+        (IRO[149].base + ((funcId) * IRO[149].m1))
+#define CSTORM_IGU_MODE_OFFSET (IRO[157].base)
 #define CSTORM_ISCSI_CQ_SIZE_OFFSET(pfId) \
-        (IRO[311].base + ((pfId) * IRO[311].m1))
+        (IRO[315].base + ((pfId) * IRO[315].m1))
 #define CSTORM_ISCSI_CQ_SQN_SIZE_OFFSET(pfId) \
-        (IRO[312].base + ((pfId) * IRO[312].m1))
-        #define CSTORM_ISCSI_EQ_CONS_OFFSET(pfId, iscsiEqId) \
-        (IRO[304].base + ((pfId) * IRO[304].m1) + ((iscsiEqId) * \
-        IRO[304].m2))
-        #define CSTORM_ISCSI_EQ_NEXT_EQE_ADDR_OFFSET(pfId, iscsiEqId) \
-        (IRO[306].base + ((pfId) * IRO[306].m1) + ((iscsiEqId) * \
-        IRO[306].m2))
-        #define CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_OFFSET(pfId, iscsiEqId) \
-        (IRO[305].base + ((pfId) * IRO[305].m1) + ((iscsiEqId) * \
-        IRO[305].m2))
-        #define \
-        CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_VALID_OFFSET(pfId, iscsiEqId) \
-        (IRO[307].base + ((pfId) * IRO[307].m1) + ((iscsiEqId) * \
-        IRO[307].m2))
-        #define CSTORM_ISCSI_EQ_PROD_OFFSET(pfId, iscsiEqId) \
-        (IRO[303].base + ((pfId) * IRO[303].m1) + ((iscsiEqId) * \
-        IRO[303].m2))
-        #define CSTORM_ISCSI_EQ_SB_INDEX_OFFSET(pfId, iscsiEqId) \
-        (IRO[309].base + ((pfId) * IRO[309].m1) + ((iscsiEqId) * \
-        IRO[309].m2))
-        #define CSTORM_ISCSI_EQ_SB_NUM_OFFSET(pfId, iscsiEqId) \
-        (IRO[308].base + ((pfId) * IRO[308].m1) + ((iscsiEqId) * \
-        IRO[308].m2))
+        (IRO[316].base + ((pfId) * IRO[316].m1))
+#define CSTORM_ISCSI_EQ_CONS_OFFSET(pfId, iscsiEqId) \
+        (IRO[308].base + ((pfId) * IRO[308].m1) + ((iscsiEqId) * IRO[308].m2))
+#define CSTORM_ISCSI_EQ_NEXT_EQE_ADDR_OFFSET(pfId, iscsiEqId) \
+        (IRO[310].base + ((pfId) * IRO[310].m1) + ((iscsiEqId) * IRO[310].m2))
+#define CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_OFFSET(pfId, iscsiEqId) \
+        (IRO[309].base + ((pfId) * IRO[309].m1) + ((iscsiEqId) * IRO[309].m2))
+#define CSTORM_ISCSI_EQ_NEXT_PAGE_ADDR_VALID_OFFSET(pfId, iscsiEqId) \
+        (IRO[311].base + ((pfId) * IRO[311].m1) + ((iscsiEqId) * IRO[311].m2))
+#define CSTORM_ISCSI_EQ_PROD_OFFSET(pfId, iscsiEqId) \
+        (IRO[307].base + ((pfId) * IRO[307].m1) + ((iscsiEqId) * IRO[307].m2))
+#define CSTORM_ISCSI_EQ_SB_INDEX_OFFSET(pfId, iscsiEqId) \
+        (IRO[313].base + ((pfId) * IRO[313].m1) + ((iscsiEqId) * IRO[313].m2))
+#define CSTORM_ISCSI_EQ_SB_NUM_OFFSET(pfId, iscsiEqId) \
+        (IRO[312].base + ((pfId) * IRO[312].m1) + ((iscsiEqId) * IRO[312].m2))
 #define CSTORM_ISCSI_HQ_SIZE_OFFSET(pfId) \
-        (IRO[310].base + ((pfId) * IRO[310].m1))
+        (IRO[314].base + ((pfId) * IRO[314].m1))
 #define CSTORM_ISCSI_NUM_OF_TASKS_OFFSET(pfId) \
-        (IRO[302].base + ((pfId) * IRO[302].m1))
+        (IRO[306].base + ((pfId) * IRO[306].m1))
 #define CSTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(pfId) \
-        (IRO[301].base + ((pfId) * IRO[301].m1))
+        (IRO[305].base + ((pfId) * IRO[305].m1))
 #define CSTORM_ISCSI_PAGE_SIZE_OFFSET(pfId) \
-        (IRO[300].base + ((pfId) * IRO[300].m1))
-#define CSTORM_PATH_ID_OFFSET (IRO[159].base)
+        (IRO[304].base + ((pfId) * IRO[304].m1))
+#define CSTORM_RECORD_SLOW_PATH_OFFSET(funcId) \
+        (IRO[151].base + ((funcId) * IRO[151].m1))
 #define CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(pfId) \
-        (IRO[137].base + ((pfId) * IRO[137].m1))
+        (IRO[142].base + ((pfId) * IRO[142].m1))
+#define CSTORM_SP_STATUS_BLOCK_DATA_STATE_OFFSET(pfId) \
+        (IRO[143].base + ((pfId) * IRO[143].m1))
 #define CSTORM_SP_STATUS_BLOCK_OFFSET(pfId) \
-        (IRO[136].base + ((pfId) * IRO[136].m1))
-#define CSTORM_SP_STATUS_BLOCK_SIZE (IRO[136].size)
+        (IRO[141].base + ((pfId) * IRO[141].m1))
+#define CSTORM_SP_STATUS_BLOCK_SIZE (IRO[141].size)
 #define CSTORM_SP_SYNC_BLOCK_OFFSET(pfId) \
-        (IRO[138].base + ((pfId) * IRO[138].m1))
-#define CSTORM_SP_SYNC_BLOCK_SIZE (IRO[138].size)
-#define CSTORM_STATS_FLAGS_OFFSET(pfId) \
-        (IRO[143].base + ((pfId) * IRO[143].m1))
+        (IRO[144].base + ((pfId) * IRO[144].m1))
+#define CSTORM_SP_SYNC_BLOCK_SIZE (IRO[144].size)
+#define CSTORM_STATUS_BLOCK_DATA_FLAGS_OFFSET(sbId, hcIndex) \
+        (IRO[136].base + ((sbId) * IRO[136].m1) + ((hcIndex) * IRO[136].m2))
 #define CSTORM_STATUS_BLOCK_DATA_OFFSET(sbId) \
-        (IRO[129].base + ((sbId) * IRO[129].m1))
+        (IRO[133].base + ((sbId) * IRO[133].m1))
+#define CSTORM_STATUS_BLOCK_DATA_STATE_OFFSET(sbId) \
+        (IRO[134].base + ((sbId) * IRO[134].m1))
+#define CSTORM_STATUS_BLOCK_DATA_TIMEOUT_OFFSET(sbId, hcIndex) \
+        (IRO[135].base + ((sbId) * IRO[135].m1) + ((hcIndex) * IRO[135].m2))
 #define CSTORM_STATUS_BLOCK_OFFSET(sbId) \
-        (IRO[128].base + ((sbId) * IRO[128].m1))
-#define CSTORM_STATUS_BLOCK_SIZE (IRO[128].size)
-#define CSTORM_SYNC_BLOCK_OFFSET(sbId) \
         (IRO[132].base + ((sbId) * IRO[132].m1))
-#define CSTORM_SYNC_BLOCK_SIZE (IRO[132].size)
+#define CSTORM_STATUS_BLOCK_SIZE (IRO[132].size)
+#define CSTORM_SYNC_BLOCK_OFFSET(sbId) \
+        (IRO[137].base + ((sbId) * IRO[137].m1))
+#define CSTORM_SYNC_BLOCK_SIZE (IRO[137].size)
 #define CSTORM_VF_PF_CHANNEL_STATE_OFFSET(vfId) \
-        (IRO[151].base + ((vfId) * IRO[151].m1))
+        (IRO[155].base + ((vfId) * IRO[155].m1))
 #define CSTORM_VF_PF_CHANNEL_VALID_OFFSET(vfId) \
-        (IRO[152].base + ((vfId) * IRO[152].m1))
+        (IRO[156].base + ((vfId) * IRO[156].m1))
 #define CSTORM_VF_TO_PF_OFFSET(funcId) \
-        (IRO[147].base + ((funcId) * IRO[147].m1))
-#define TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET (IRO[199].base)
+        (IRO[150].base + ((funcId) * IRO[150].m1))
+#define TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET (IRO[204].base)
 #define TSTORM_APPROXIMATE_MATCH_MULTICAST_FILTERING_OFFSET(pfId) \
-        (IRO[198].base + ((pfId) * IRO[198].m1))
-#define TSTORM_ASSERT_LIST_INDEX_OFFSET (IRO[99].base)
+        (IRO[203].base + ((pfId) * IRO[203].m1))
+#define TSTORM_ASSERT_LIST_INDEX_OFFSET (IRO[102].base)
 #define TSTORM_ASSERT_LIST_OFFSET(assertListEntry) \
-        (IRO[98].base + ((assertListEntry) * IRO[98].m1))
-        #define TSTORM_CLIENT_CONFIG_OFFSET(portId, clientId) \
-        (IRO[197].base + ((portId) * IRO[197].m1) + ((clientId) * \
-        IRO[197].m2))
-#define TSTORM_COMMON_SAFC_WORKAROUND_ENABLE_OFFSET (IRO[104].base)
+        (IRO[101].base + ((assertListEntry) * IRO[101].m1))
+#define TSTORM_COMMON_SAFC_WORKAROUND_ENABLE_OFFSET (IRO[107].base)
 #define TSTORM_COMMON_SAFC_WORKAROUND_TIMEOUT_10USEC_OFFSET \
-        (IRO[105].base)
-#define TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(pfId) \
-        (IRO[96].base + ((pfId) * IRO[96].m1))
-#define TSTORM_FUNC_EN_OFFSET(funcId) \
-        (IRO[101].base + ((funcId) * IRO[101].m1))
+        (IRO[108].base)
 #define TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(pfId) \
-        (IRO[195].base + ((pfId) * IRO[195].m1))
-#define TSTORM_FUNCTION_MODE_OFFSET (IRO[103].base)
-#define TSTORM_INDIRECTION_TABLE_OFFSET(pfId) \
-        (IRO[91].base + ((pfId) * IRO[91].m1))
-#define TSTORM_INDIRECTION_TABLE_SIZE (IRO[91].size)
-        #define \
-        TSTORM_ISCSI_CONN_BUF_PBL_OFFSET(pfId, iscsiConBufPblEntry) \
-        (IRO[260].base + ((pfId) * IRO[260].m1) + ((iscsiConBufPblEntry) \
-        * IRO[260].m2))
+        (IRO[201].base + ((pfId) * IRO[201].m1))
+#define TSTORM_FUNC_EN_OFFSET(funcId) \
+        (IRO[103].base + ((funcId) * IRO[103].m1))
 #define TSTORM_ISCSI_ERROR_BITMAP_OFFSET(pfId) \
-        (IRO[264].base + ((pfId) * IRO[264].m1))
+        (IRO[271].base + ((pfId) * IRO[271].m1))
 #define TSTORM_ISCSI_L2_ISCSI_OOO_CID_TABLE_OFFSET(pfId) \
-        (IRO[265].base + ((pfId) * IRO[265].m1))
+        (IRO[272].base + ((pfId) * IRO[272].m1))
 #define TSTORM_ISCSI_L2_ISCSI_OOO_CLIENT_ID_TABLE_OFFSET(pfId) \
-        (IRO[266].base + ((pfId) * IRO[266].m1))
+        (IRO[273].base + ((pfId) * IRO[273].m1))
 #define TSTORM_ISCSI_L2_ISCSI_OOO_PROD_OFFSET(pfId) \
-        (IRO[267].base + ((pfId) * IRO[267].m1))
+        (IRO[274].base + ((pfId) * IRO[274].m1))
 #define TSTORM_ISCSI_NUM_OF_TASKS_OFFSET(pfId) \
-        (IRO[263].base + ((pfId) * IRO[263].m1))
+        (IRO[270].base + ((pfId) * IRO[270].m1))
 #define TSTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(pfId) \
-        (IRO[262].base + ((pfId) * IRO[262].m1))
+        (IRO[269].base + ((pfId) * IRO[269].m1))
 #define TSTORM_ISCSI_PAGE_SIZE_OFFSET(pfId) \
-        (IRO[261].base + ((pfId) * IRO[261].m1))
+        (IRO[268].base + ((pfId) * IRO[268].m1))
 #define TSTORM_ISCSI_RQ_SIZE_OFFSET(pfId) \
-        (IRO[259].base + ((pfId) * IRO[259].m1))
+        (IRO[267].base + ((pfId) * IRO[267].m1))
 #define TSTORM_ISCSI_TCP_LOCAL_ADV_WND_OFFSET(pfId) \
-        (IRO[269].base + ((pfId) * IRO[269].m1))
+        (IRO[276].base + ((pfId) * IRO[276].m1))
 #define TSTORM_ISCSI_TCP_VARS_FLAGS_OFFSET(pfId) \
-        (IRO[256].base + ((pfId) * IRO[256].m1))
+        (IRO[263].base + ((pfId) * IRO[263].m1))
 #define TSTORM_ISCSI_TCP_VARS_LSB_LOCAL_MAC_ADDR_OFFSET(pfId) \
-        (IRO[257].base + ((pfId) * IRO[257].m1))
+        (IRO[264].base + ((pfId) * IRO[264].m1))
+#define TSTORM_ISCSI_TCP_VARS_MID_LOCAL_MAC_ADDR_OFFSET(pfId) \
+        (IRO[265].base + ((pfId) * IRO[265].m1))
 #define TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfId) \
-        (IRO[258].base + ((pfId) * IRO[258].m1))
+        (IRO[266].base + ((pfId) * IRO[266].m1))
 #define TSTORM_MAC_FILTER_CONFIG_OFFSET(pfId) \
-        (IRO[196].base + ((pfId) * IRO[196].m1))
-        #define TSTORM_PER_COUNTER_ID_STATS_OFFSET(portId, tStatCntId) \
-        (IRO[100].base + ((portId) * IRO[100].m1) + ((tStatCntId) * \
-        IRO[100].m2))
-#define TSTORM_STATS_FLAGS_OFFSET(pfId) \
-        (IRO[95].base + ((pfId) * IRO[95].m1))
+        (IRO[202].base + ((pfId) * IRO[202].m1))
+#define TSTORM_RECORD_SLOW_PATH_OFFSET(funcId) \
+        (IRO[105].base + ((funcId) * IRO[105].m1))
 #define TSTORM_TCP_MAX_CWND_OFFSET(pfId) \
-        (IRO[211].base + ((pfId) * IRO[211].m1))
+        (IRO[216].base + ((pfId) * IRO[216].m1))
 #define TSTORM_VF_TO_PF_OFFSET(funcId) \
-        (IRO[102].base + ((funcId) * IRO[102].m1))
-#define USTORM_AGG_DATA_OFFSET (IRO[201].base)
-#define USTORM_AGG_DATA_SIZE (IRO[201].size)
-#define USTORM_ASSERT_LIST_INDEX_OFFSET (IRO[170].base)
+        (IRO[104].base + ((funcId) * IRO[104].m1))
+#define USTORM_AGG_DATA_OFFSET (IRO[206].base)
+#define USTORM_AGG_DATA_SIZE (IRO[206].size)
+#define USTORM_ASSERT_LIST_INDEX_OFFSET (IRO[177].base)
 #define USTORM_ASSERT_LIST_OFFSET(assertListEntry) \
-        (IRO[169].base + ((assertListEntry) * IRO[169].m1))
+        (IRO[176].base + ((assertListEntry) * IRO[176].m1))
+#define USTORM_CQE_PAGE_NEXT_OFFSET(portId, clientId) \
+        (IRO[205].base + ((portId) * IRO[205].m1) + ((clientId) * \
+        IRO[205].m2))
 #define USTORM_ETH_PAUSE_ENABLED_OFFSET(portId) \
-        (IRO[178].base + ((portId) * IRO[178].m1))
-#define USTORM_ETH_STATS_QUERY_ADDR_OFFSET(pfId) \
-        (IRO[172].base + ((pfId) * IRO[172].m1))
+        (IRO[183].base + ((portId) * IRO[183].m1))
 #define USTORM_FCOE_EQ_PROD_OFFSET(pfId) \
-        (IRO[313].base + ((pfId) * IRO[313].m1))
+        (IRO[317].base + ((pfId) * IRO[317].m1))
 #define USTORM_FUNC_EN_OFFSET(funcId) \
-        (IRO[174].base + ((funcId) * IRO[174].m1))
-#define USTORM_FUNCTION_MODE_OFFSET (IRO[177].base)
+        (IRO[178].base + ((funcId) * IRO[178].m1))
 #define USTORM_ISCSI_CQ_SIZE_OFFSET(pfId) \
-        (IRO[277].base + ((pfId) * IRO[277].m1))
+        (IRO[281].base + ((pfId) * IRO[281].m1))
 #define USTORM_ISCSI_CQ_SQN_SIZE_OFFSET(pfId) \
-        (IRO[278].base + ((pfId) * IRO[278].m1))
-#define USTORM_ISCSI_ERROR_BITMAP_OFFSET(pfId) \
         (IRO[282].base + ((pfId) * IRO[282].m1))
+#define USTORM_ISCSI_ERROR_BITMAP_OFFSET(pfId) \
+        (IRO[286].base + ((pfId) * IRO[286].m1))
 #define USTORM_ISCSI_GLOBAL_BUF_PHYS_ADDR_OFFSET(pfId) \
-        (IRO[279].base + ((pfId) * IRO[279].m1))
+        (IRO[283].base + ((pfId) * IRO[283].m1))
 #define USTORM_ISCSI_NUM_OF_TASKS_OFFSET(pfId) \
-        (IRO[275].base + ((pfId) * IRO[275].m1))
+        (IRO[279].base + ((pfId) * IRO[279].m1))
 #define USTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(pfId) \
-        (IRO[274].base + ((pfId) * IRO[274].m1))
+        (IRO[278].base + ((pfId) * IRO[278].m1))
 #define USTORM_ISCSI_PAGE_SIZE_OFFSET(pfId) \
-        (IRO[273].base + ((pfId) * IRO[273].m1))
+        (IRO[277].base + ((pfId) * IRO[277].m1))
 #define USTORM_ISCSI_R2TQ_SIZE_OFFSET(pfId) \
-        (IRO[276].base + ((pfId) * IRO[276].m1))
-#define USTORM_ISCSI_RQ_BUFFER_SIZE_OFFSET(pfId) \
         (IRO[280].base + ((pfId) * IRO[280].m1))
+#define USTORM_ISCSI_RQ_BUFFER_SIZE_OFFSET(pfId) \
+        (IRO[284].base + ((pfId) * IRO[284].m1))
 #define USTORM_ISCSI_RQ_SIZE_OFFSET(pfId) \
-        (IRO[281].base + ((pfId) * IRO[281].m1))
+        (IRO[285].base + ((pfId) * IRO[285].m1))
 #define USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(pfId) \
-        (IRO[176].base + ((pfId) * IRO[176].m1))
-        #define USTORM_PER_COUNTER_ID_STATS_OFFSET(portId, uStatCntId) \
-        (IRO[173].base + ((portId) * IRO[173].m1) + ((uStatCntId) * \
-        IRO[173].m2))
-        #define USTORM_RX_PRODS_E1X_OFFSET(portId, clientId) \
-        (IRO[204].base + ((portId) * IRO[204].m1) + ((clientId) * \
-        IRO[204].m2))
+        (IRO[182].base + ((pfId) * IRO[182].m1))
+#define USTORM_RECORD_SLOW_PATH_OFFSET(funcId) \
+        (IRO[180].base + ((funcId) * IRO[180].m1))
+#define USTORM_RX_PRODS_E1X_OFFSET(portId, clientId) \
+        (IRO[209].base + ((portId) * IRO[209].m1) + ((clientId) * \
+        IRO[209].m2))
 #define USTORM_RX_PRODS_E2_OFFSET(qzoneId) \
-        (IRO[205].base + ((qzoneId) * IRO[205].m1))
-#define USTORM_STATS_FLAGS_OFFSET(pfId) \
-        (IRO[171].base + ((pfId) * IRO[171].m1))
-#define USTORM_TPA_BTR_OFFSET (IRO[202].base)
-#define USTORM_TPA_BTR_SIZE (IRO[202].size)
+        (IRO[210].base + ((qzoneId) * IRO[210].m1))
+#define USTORM_TPA_BTR_OFFSET (IRO[207].base)
+#define USTORM_TPA_BTR_SIZE (IRO[207].size)
 #define USTORM_VF_TO_PF_OFFSET(funcId) \
-        (IRO[175].base + ((funcId) * IRO[175].m1))
-#define XSTORM_AGG_INT_FINAL_CLEANUP_COMP_TYPE (IRO[59].base)
-#define XSTORM_AGG_INT_FINAL_CLEANUP_INDEX (IRO[58].base)
-#define XSTORM_ASSERT_LIST_INDEX_OFFSET (IRO[54].base)
+        (IRO[179].base + ((funcId) * IRO[179].m1))
+#define XSTORM_AGG_INT_FINAL_CLEANUP_COMP_TYPE (IRO[67].base)
+#define XSTORM_AGG_INT_FINAL_CLEANUP_INDEX (IRO[66].base)
+#define XSTORM_ASSERT_LIST_INDEX_OFFSET (IRO[51].base)
 #define XSTORM_ASSERT_LIST_OFFSET(assertListEntry) \
-        (IRO[53].base + ((assertListEntry) * IRO[53].m1))
+        (IRO[50].base + ((assertListEntry) * IRO[50].m1))
 #define XSTORM_CMNG_PER_PORT_VARS_OFFSET(portId) \
-        (IRO[47].base + ((portId) * IRO[47].m1))
-#define XSTORM_E1HOV_OFFSET(pfId) \
-        (IRO[55].base + ((pfId) * IRO[55].m1))
-#define XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(pfId) \
-        (IRO[45].base + ((pfId) * IRO[45].m1))
+        (IRO[43].base + ((portId) * IRO[43].m1))
 #define XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(pfId) \
-        (IRO[49].base + ((pfId) * IRO[49].m1))
+        (IRO[45].base + ((pfId) * IRO[45].m1))
 #define XSTORM_FUNC_EN_OFFSET(funcId) \
-        (IRO[51].base + ((funcId) * IRO[51].m1))
-#define XSTORM_FUNCTION_MODE_OFFSET (IRO[56].base)
+        (IRO[47].base + ((funcId) * IRO[47].m1))
 #define XSTORM_ISCSI_HQ_SIZE_OFFSET(pfId) \
-        (IRO[290].base + ((pfId) * IRO[290].m1))
+        (IRO[294].base + ((pfId) * IRO[294].m1))
 #define XSTORM_ISCSI_LOCAL_MAC_ADDR0_OFFSET(pfId) \
-        (IRO[293].base + ((pfId) * IRO[293].m1))
+        (IRO[297].base + ((pfId) * IRO[297].m1))
 #define XSTORM_ISCSI_LOCAL_MAC_ADDR1_OFFSET(pfId) \
-        (IRO[294].base + ((pfId) * IRO[294].m1))
+        (IRO[298].base + ((pfId) * IRO[298].m1))
 #define XSTORM_ISCSI_LOCAL_MAC_ADDR2_OFFSET(pfId) \
-        (IRO[295].base + ((pfId) * IRO[295].m1))
+        (IRO[299].base + ((pfId) * IRO[299].m1))
 #define XSTORM_ISCSI_LOCAL_MAC_ADDR3_OFFSET(pfId) \
-        (IRO[296].base + ((pfId) * IRO[296].m1))
+        (IRO[300].base + ((pfId) * IRO[300].m1))
 #define XSTORM_ISCSI_LOCAL_MAC_ADDR4_OFFSET(pfId) \
-        (IRO[297].base + ((pfId) * IRO[297].m1))
+        (IRO[301].base + ((pfId) * IRO[301].m1))
 #define XSTORM_ISCSI_LOCAL_MAC_ADDR5_OFFSET(pfId) \
-        (IRO[298].base + ((pfId) * IRO[298].m1))
+        (IRO[302].base + ((pfId) * IRO[302].m1))
 #define XSTORM_ISCSI_LOCAL_VLAN_OFFSET(pfId) \
-        (IRO[299].base + ((pfId) * IRO[299].m1))
+        (IRO[303].base + ((pfId) * IRO[303].m1))
 #define XSTORM_ISCSI_NUM_OF_TASKS_OFFSET(pfId) \
-        (IRO[289].base + ((pfId) * IRO[289].m1))
+        (IRO[293].base + ((pfId) * IRO[293].m1))
 #define XSTORM_ISCSI_PAGE_SIZE_LOG_OFFSET(pfId) \
-        (IRO[288].base + ((pfId) * IRO[288].m1))
+        (IRO[292].base + ((pfId) * IRO[292].m1))
 #define XSTORM_ISCSI_PAGE_SIZE_OFFSET(pfId) \
-        (IRO[287].base + ((pfId) * IRO[287].m1))
+        (IRO[291].base + ((pfId) * IRO[291].m1))
 #define XSTORM_ISCSI_R2TQ_SIZE_OFFSET(pfId) \
-        (IRO[292].base + ((pfId) * IRO[292].m1))
+        (IRO[296].base + ((pfId) * IRO[296].m1))
 #define XSTORM_ISCSI_SQ_SIZE_OFFSET(pfId) \
-        (IRO[291].base + ((pfId) * IRO[291].m1))
+        (IRO[295].base + ((pfId) * IRO[295].m1))
 #define XSTORM_ISCSI_TCP_VARS_ADV_WND_SCL_OFFSET(pfId) \
-        (IRO[286].base + ((pfId) * IRO[286].m1))
+        (IRO[290].base + ((pfId) * IRO[290].m1))
 #define XSTORM_ISCSI_TCP_VARS_FLAGS_OFFSET(pfId) \
-        (IRO[285].base + ((pfId) * IRO[285].m1))
+        (IRO[289].base + ((pfId) * IRO[289].m1))
 #define XSTORM_ISCSI_TCP_VARS_TOS_OFFSET(pfId) \
-        (IRO[284].base + ((pfId) * IRO[284].m1))
+        (IRO[288].base + ((pfId) * IRO[288].m1))
 #define XSTORM_ISCSI_TCP_VARS_TTL_OFFSET(pfId) \
-        (IRO[283].base + ((pfId) * IRO[283].m1))
-#define XSTORM_PATH_ID_OFFSET (IRO[65].base)
-        #define XSTORM_PER_COUNTER_ID_STATS_OFFSET(portId, xStatCntId) \
-        (IRO[50].base + ((portId) * IRO[50].m1) + ((xStatCntId) * \
-        IRO[50].m2))
+        (IRO[287].base + ((pfId) * IRO[287].m1))
 #define XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(pfId) \
-        (IRO[48].base + ((pfId) * IRO[48].m1))
+        (IRO[44].base + ((pfId) * IRO[44].m1))
+#define XSTORM_RECORD_SLOW_PATH_OFFSET(funcId) \
+        (IRO[49].base + ((funcId) * IRO[49].m1))
 #define XSTORM_SPQ_DATA_OFFSET(funcId) \
         (IRO[32].base + ((funcId) * IRO[32].m1))
 #define XSTORM_SPQ_DATA_SIZE (IRO[32].size)
@@ -260,42 +232,37 @@
         (IRO[30].base + ((funcId) * IRO[30].m1))
 #define XSTORM_SPQ_PROD_OFFSET(funcId) \
         (IRO[31].base + ((funcId) * IRO[31].m1))
-#define XSTORM_STATS_FLAGS_OFFSET(pfId) \
-        (IRO[43].base + ((pfId) * IRO[43].m1))
 #define XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_ENABLED_OFFSET(portId) \
-        (IRO[206].base + ((portId) * IRO[206].m1))
+        (IRO[211].base + ((portId) * IRO[211].m1))
 #define XSTORM_TCP_GLOBAL_DEL_ACK_COUNTER_MAX_COUNT_OFFSET(portId) \
-        (IRO[207].base + ((portId) * IRO[207].m1))
+        (IRO[212].base + ((portId) * IRO[212].m1))
 #define XSTORM_TCP_TX_SWS_TIMER_VAL_OFFSET(pfId) \
-        (IRO[209].base + (((pfId)>>1) * IRO[209].m1) + (((pfId)&1) * \
-        IRO[209].m2))
+        (IRO[214].base + (((pfId)>>1) * IRO[214].m1) + (((pfId)&1) * \
+        IRO[214].m2))
 #define XSTORM_VF_TO_PF_OFFSET(funcId) \
-        (IRO[52].base + ((funcId) * IRO[52].m1))
+        (IRO[48].base + ((funcId) * IRO[48].m1))
 #define COMMON_ASM_INVALID_ASSERT_OPCODE 0x0
 
-/* RSS hash types */
-#define DEFAULT_HASH_TYPE 0
-#define IPV4_HASH_TYPE 1
-#define TCP_IPV4_HASH_TYPE 2
-#define IPV6_HASH_TYPE 3
-#define TCP_IPV6_HASH_TYPE 4
-#define VLAN_PRI_HASH_TYPE 5
-#define E1HOV_PRI_HASH_TYPE 6
-#define DSCP_HASH_TYPE 7
+/**
+* This file defines HSI constants for the ETH flow
+*/
+#ifdef _EVEREST_MICROCODE
+#include "Microcode\Generated\DataTypes\eth_rx_bd.h"
+#include "Microcode\Generated\DataTypes\eth_tx_bd.h"
+#include "Microcode\Generated\DataTypes\eth_rx_cqe.h"
+#include "Microcode\Generated\DataTypes\eth_rx_sge.h"
+#include "Microcode\Generated\DataTypes\eth_rx_cqe_next_page.h"
+#endif
 
 
 /* Ethernet Ring parameters */
 #define X_ETH_LOCAL_RING_SIZE 13
-#define FIRST_BD_IN_PKT 0
+#define FIRST_BD_IN_PKT 0
 #define PARSE_BD_INDEX 1
 #define NUM_OF_ETH_BDS_IN_PAGE ((PAGE_SIZE)/(STRUCT_SIZE(eth_tx_bd)/8))
 #define U_ETH_NUM_OF_SGES_TO_FETCH 8
 #define U_ETH_MAX_SGES_FOR_PACKET 3
 
-/*Tx params*/
-#define X_ETH_NO_VLAN 0
-#define X_ETH_OUTBAND_VLAN 1
-#define X_ETH_INBAND_VLAN 2
 /* Rx ring params */
 #define U_ETH_LOCAL_BD_RING_SIZE 8
 #define U_ETH_LOCAL_SGE_RING_SIZE 10
@@ -311,79 +278,64 @@
 #define U_ETH_BDS_PER_PAGE (PAGE_SIZE/(STRUCT_SIZE(eth_rx_bd)/8))
 #define U_ETH_SGES_PER_PAGE (PAGE_SIZE/(STRUCT_SIZE(eth_rx_sge)/8))
 
-#define U_ETH_BDS_PER_PAGE_MASK (U_ETH_BDS_PER_PAGE-1)
-#define U_ETH_CQE_PER_PAGE_MASK (TU_ETH_CQES_PER_PAGE-1)
+#define U_ETH_BDS_PER_PAGE_MASK (U_ETH_BDS_PER_PAGE-1)
+#define U_ETH_CQE_PER_PAGE_MASK (TU_ETH_CQES_PER_PAGE-1)
 #define U_ETH_SGES_PER_PAGE_MASK (U_ETH_SGES_PER_PAGE-1)
 
 #define U_ETH_UNDEFINED_Q 0xFF
 
-/* values of command IDs in the ramrod message */
-#define RAMROD_CMD_ID_ETH_UNUSED 0
-#define RAMROD_CMD_ID_ETH_CLIENT_SETUP 1
-#define RAMROD_CMD_ID_ETH_UPDATE 2
-#define RAMROD_CMD_ID_ETH_HALT 3
-#define RAMROD_CMD_ID_ETH_FORWARD_SETUP 4
-#define RAMROD_CMD_ID_ETH_ACTIVATE 5
-#define RAMROD_CMD_ID_ETH_DEACTIVATE 6
-#define RAMROD_CMD_ID_ETH_EMPTY 7
-#define RAMROD_CMD_ID_ETH_TERMINATE 8
-
-/* command values for set mac command */
-#define T_ETH_MAC_COMMAND_SET 0
-#define T_ETH_MAC_COMMAND_INVALIDATE 1
-
 #define T_ETH_INDIRECTION_TABLE_SIZE 128
+#define T_ETH_RSS_KEY 10
+#define ETH_NUM_OF_RSS_ENGINES_E2 72
+
+#define FILTER_RULES_COUNT 16
+#define MULTICAST_RULES_COUNT 16
+#define CLASSIFY_RULES_COUNT 16
 
 /*The CRC32 seed, that is used for the hash(reduction) multicast address */
-#define T_ETH_CRC32_HASH_SEED 0x00000000
+#define ETH_CRC32_HASH_SEED 0x00000000
+
+#define ETH_CRC32_HASH_BIT_SIZE (8)
+#define ETH_CRC32_HASH_MASK EVAL((1<<ETH_CRC32_HASH_BIT_SIZE)-1)
 
 /* Maximal L2 clients supported */
 #define ETH_MAX_RX_CLIENTS_E1 18
 #define ETH_MAX_RX_CLIENTS_E1H 28
+#define ETH_MAX_RX_CLIENTS_E2 152
+
+/* Maximal statistics client Ids */
+#define MAX_STAT_COUNTER_ID_E1 36
+#define MAX_STAT_COUNTER_ID_E1H 56
+#define MAX_STAT_COUNTER_ID_E2 140
+
+#define MAX_MAC_CREDIT_E1 192 /* Per Chip */
+#define MAX_MAC_CREDIT_E1H 256 /* Per Chip */
+#define MAX_MAC_CREDIT_E2 272 /* Per Path */
+#define MAX_VLAN_CREDIT_E1 0 /* Per Chip */
+#define MAX_VLAN_CREDIT_E1H 0 /* Per Chip */
+#define MAX_VLAN_CREDIT_E2 272 /* Per Path */
 
-#define MAX_STAT_COUNTER_ID ETH_MAX_RX_CLIENTS_E1H
 
 /* Maximal aggregation queues supported */
 #define ETH_MAX_AGGREGATION_QUEUES_E1 32
-#define ETH_MAX_AGGREGATION_QUEUES_E1H 64
+#define ETH_MAX_AGGREGATION_QUEUES_E1H_E2 64
 
-/* ETH RSS modes */
-#define ETH_RSS_MODE_DISABLED 0
-#define ETH_RSS_MODE_REGULAR 1
-#define ETH_RSS_MODE_VLAN_PRI 2
-#define ETH_RSS_MODE_E1HOV_PRI 3
-#define ETH_RSS_MODE_IP_DSCP 4
-#define ETH_RSS_MODE_E2_INTEG 5
 
+#define ETH_NUM_OF_MCAST_BINS 256
+#define ETH_NUM_OF_MCAST_ENGINES_E2 72
 
-/* ETH vlan filtering modes */
-#define ETH_VLAN_FILTER_ANY_VLAN 0 /* Don't filter by vlan */
-#define ETH_VLAN_FILTER_SPECIFIC_VLAN \
-        1 /* Only the vlan_id is allowed */
-#define ETH_VLAN_FILTER_CLASSIFY \
-        2 /* vlan will be added to CAM for classification */
+#define ETH_MIN_RX_CQES_WITHOUT_TPA (MAX_RAMRODS_PER_PORT + 3)
+#define ETH_MIN_RX_CQES_WITH_TPA_E1 \
+        (ETH_MAX_AGGREGATION_QUEUES_E1 + ETH_MIN_RX_CQES_WITHOUT_TPA)
+#define ETH_MIN_RX_CQES_WITH_TPA_E1H_E2 \
+        (ETH_MAX_AGGREGATION_QUEUES_E1H_E2 + ETH_MIN_RX_CQES_WITHOUT_TPA)
 
-/* Fast path CQE selection */
-#define ETH_FP_CQE_REGULAR 0
-#define ETH_FP_CQE_SGL 1
-#define ETH_FP_CQE_RAW 2
+#define DISABLE_STATISTIC_COUNTER_ID_VALUE 0
 
 
 /**
-* This file defines HSI constants common to all microcode flows
-*/
-
-/* Connection types */
-#define ETH_CONNECTION_TYPE 0
-#define TOE_CONNECTION_TYPE 1
-#define RDMA_CONNECTION_TYPE 2
-#define ISCSI_CONNECTION_TYPE 3
-#define FCOE_CONNECTION_TYPE 4
-#define RESERVED_CONNECTION_TYPE_0 5
-#define RESERVED_CONNECTION_TYPE_1 6
-#define RESERVED_CONNECTION_TYPE_2 7
-#define NONE_CONNECTION_TYPE 8
-
+ * This file defines HSI constants common to all microcode flows
+ */
 
 #define PROTOCOL_STATE_BIT_OFFSET 6
 
@@ -391,25 +343,9 @@
 #define TOE_STATE (TOE_CONNECTION_TYPE << PROTOCOL_STATE_BIT_OFFSET)
 #define RDMA_STATE (RDMA_CONNECTION_TYPE << PROTOCOL_STATE_BIT_OFFSET)
 
-/* values of command IDs in the ramrod message */
-#define RAMROD_CMD_ID_COMMON_FUNCTION_START 1
-#define RAMROD_CMD_ID_COMMON_FUNCTION_STOP 2
-#define RAMROD_CMD_ID_COMMON_CFC_DEL 3
-#define RAMROD_CMD_ID_COMMON_CFC_DEL_WB 4
-#define RAMROD_CMD_ID_COMMON_SET_MAC 5
-#define RAMROD_CMD_ID_COMMON_STAT_QUERY 6
-#define RAMROD_CMD_ID_COMMON_STOP_TRAFFIC 7
-#define RAMROD_CMD_ID_COMMON_START_TRAFFIC 8
-
 /* microcode fixed page page size 4K (chains and ring segments) */
 #define MC_PAGE_SIZE 4096
 
-
-/* Host coalescing constants */
-#define HC_IGU_BC_MODE 0
-#define HC_IGU_NBC_MODE 1
-/* Host coalescing constants. E1 includes E1H as well */
-
 /* Number of indices per slow-path SB */
 #define HC_SP_SB_MAX_INDICES 16
 
@@ -418,30 +354,17 @@
 #define HC_SB_MAX_INDICES_E2 8
 
 #define HC_SB_MAX_SB_E1X 32
-#define HC_SB_MAX_SB_E2 136
+#define HC_SB_MAX_SB_E2 136
 
 #define HC_SP_SB_ID 0xde
 
-#define HC_REGULAR_SEGMENT 0
-#define HC_DEFAULT_SEGMENT 1
 #define HC_SB_MAX_SM 2
 
 #define HC_SB_MAX_DYNAMIC_INDICES 4
-#define HC_FUNCTION_DISABLED 0xff
-/* used by the driver to get the SB offset */
-#define USTORM_ID 0
-#define CSTORM_ID 1
-#define XSTORM_ID 2
-#define TSTORM_ID 3
-#define ATTENTION_ID 4
 
 /* max number of slow path commands per port */
 #define MAX_RAMRODS_PER_PORT 8
 
-/* values for RX ETH CQE type field */
-#define RX_ETH_CQE_TYPE_ETH_FASTPATH 0
-#define RX_ETH_CQE_TYPE_ETH_RAMROD 1
-
 
 /**** DEFINES FOR TIMERS/CLOCKS RESOLUTIONS ****/
 
@@ -451,7 +374,7 @@
 
 #define XSEMI_CLK1_RESUL_CHIP (1e-3)
 
-#define SDM_TIMER_TICK_RESUL_CHIP (4*(1e-6))
+#define SDM_TIMER_TICK_RESUL_CHIP (4 * (1e-6))
 
 /**** END DEFINES FOR TIMERS/CLOCKS RESOLUTIONS ****/
 
@@ -460,72 +383,28 @@
 
 #define FW_LOG_LIST_SIZE 50
 
-#define NUM_OF_PROTOCOLS 4
 #define NUM_OF_SAFC_BITS 16
 #define MAX_COS_NUMBER 4
-
-#define FAIRNESS_COS_WRR_MODE 0
-#define FAIRNESS_COS_ETS_MODE 1
-
-
-/* Priority Flow Control (PFC) */
+#define MAX_TRAFFIC_TYPES 8
 #define MAX_PFC_PRIORITIES 8
-#define MAX_PFC_TRAFFIC_TYPES 8
-
-/* Available Traffic Types for Link Layer Flow Control */
-#define LLFC_TRAFFIC_TYPE_NW 0
-#define LLFC_TRAFFIC_TYPE_FCOE 1
-#define LLFC_TRAFFIC_TYPE_ISCSI 2
-        /***************** START OF E2 INTEGRATION \
-        CODE***************************************/
-#define LLFC_TRAFFIC_TYPE_NW_COS1_E2INTEG 3
-        /***************** END OF E2 INTEGRATION \
-        CODE***************************************/
-#define LLFC_TRAFFIC_TYPE_MAX 4
 
         /* used by array traffic_type_to_priority[] to mark traffic type \
         that is not mapped to priority*/
 #define LLFC_TRAFFIC_TYPE_TO_PRIORITY_UNMAPPED 0xFF
 
-#define LLFC_MODE_NONE 0
-#define LLFC_MODE_PFC 1
-#define LLFC_MODE_SAFC 2
-
-#define DCB_DISABLED 0
-#define DCB_ENABLED 1
 
-#define UNKNOWN_ADDRESS 0
-#define UNICAST_ADDRESS 1
-#define MULTICAST_ADDRESS 2
-#define BROADCAST_ADDRESS 3
+#define C_ERES_PER_PAGE \
+        (PAGE_SIZE / BITS_TO_BYTES(STRUCT_SIZE(event_ring_elem)))
+#define C_ERE_PER_PAGE_MASK (C_ERES_PER_PAGE - 1)
 
-#define SINGLE_FUNCTION 0
-#define MULTI_FUNCTION_SD 1
-#define MULTI_FUNCTION_SI 2
+#define STATS_QUERY_CMD_COUNT 16
 
-#define IP_V4 0
-#define IP_V6 1
+#define NIV_LIST_TABLE_SIZE 4096
 
+#define INVALID_VNIC_ID 0xFF
 
-#define C_ERES_PER_PAGE \
-        (PAGE_SIZE / BITS_TO_BYTES(STRUCT_SIZE(event_ring_elem)))
-#define C_ERE_PER_PAGE_MASK (C_ERES_PER_PAGE - 1)
 
-#define EVENT_RING_OPCODE_VF_PF_CHANNEL 0
-#define EVENT_RING_OPCODE_FUNCTION_START 1
-#define EVENT_RING_OPCODE_FUNCTION_STOP 2
-#define EVENT_RING_OPCODE_CFC_DEL 3
-#define EVENT_RING_OPCODE_CFC_DEL_WB 4
-#define EVENT_RING_OPCODE_SET_MAC 5
-#define EVENT_RING_OPCODE_STAT_QUERY 6
-#define EVENT_RING_OPCODE_STOP_TRAFFIC 7
-#define EVENT_RING_OPCODE_START_TRAFFIC 8
-#define EVENT_RING_OPCODE_FORWARD_SETUP 9
-
-#define VF_PF_CHANNEL_STATE_READY 0
-#define VF_PF_CHANNEL_STATE_WAITING_FOR_ACK 1
-
-#define VF_PF_CHANNEL_STATE_MAX_NUMBER 2
+#define UNDEF_IRO 0x80000000
 
 
 #endif /* BNX2X_FW_DEFS_H */
diff --git a/drivers/net/bnx2x/bnx2x_hsi.h b/drivers/net/bnx2x/bnx2x_hsi.h
index b8b4b2f0b60a..df5355818c30 100644
--- a/drivers/net/bnx2x/bnx2x_hsi.h
+++ b/drivers/net/bnx2x/bnx2x_hsi.h
@@ -11,7 +11,7 @@
 
 #include "bnx2x_fw_defs.h"
 
-#define FW_ENCODE_32BIT_PATTERN         0x1e1e1e1e
+#define FW_ENCODE_32BIT_PATTERN         0x1e1e1e1e
 
 struct license_key {
         u32 reserved[6];
@@ -33,201 +33,366 @@ struct license_key {
         u32 reserved_b[4];
 };
 
-#define PORT_0                          0
-#define PORT_1                          1
-#define PORT_MAX                        2
+
+#define PORT_0              0
+#define PORT_1              1
+#define PORT_MAX            2
 
 /****************************************************************************
- * Shared HW configuration                                                  *
+ * Shared HW configuration                                                  *
  ****************************************************************************/
-struct shared_hw_cfg {                                   /* NVRAM Offset */
+#define PIN_CFG_NA                          0x00000000
+#define PIN_CFG_GPIO0_P0                    0x00000001
+#define PIN_CFG_GPIO1_P0                    0x00000002
+#define PIN_CFG_GPIO2_P0                    0x00000003
+#define PIN_CFG_GPIO3_P0                    0x00000004
+#define PIN_CFG_GPIO0_P1                    0x00000005
+#define PIN_CFG_GPIO1_P1                    0x00000006
+#define PIN_CFG_GPIO2_P1                    0x00000007
+#define PIN_CFG_GPIO3_P1                    0x00000008
+#define PIN_CFG_EPIO0                       0x00000009
+#define PIN_CFG_EPIO1                       0x0000000a
+#define PIN_CFG_EPIO2                       0x0000000b
+#define PIN_CFG_EPIO3                       0x0000000c
+#define PIN_CFG_EPIO4                       0x0000000d
+#define PIN_CFG_EPIO5                       0x0000000e
+#define PIN_CFG_EPIO6                       0x0000000f
+#define PIN_CFG_EPIO7                       0x00000010
+#define PIN_CFG_EPIO8                       0x00000011
+#define PIN_CFG_EPIO9                       0x00000012
+#define PIN_CFG_EPIO10                      0x00000013
+#define PIN_CFG_EPIO11                      0x00000014
+#define PIN_CFG_EPIO12                      0x00000015
+#define PIN_CFG_EPIO13                      0x00000016
+#define PIN_CFG_EPIO14                      0x00000017
+#define PIN_CFG_EPIO15                      0x00000018
+#define PIN_CFG_EPIO16                      0x00000019
+#define PIN_CFG_EPIO17                      0x0000001a
+#define PIN_CFG_EPIO18                      0x0000001b
+#define PIN_CFG_EPIO19                      0x0000001c
+#define PIN_CFG_EPIO20                      0x0000001d
+#define PIN_CFG_EPIO21                      0x0000001e
+#define PIN_CFG_EPIO22                      0x0000001f
+#define PIN_CFG_EPIO23                      0x00000020
+#define PIN_CFG_EPIO24                      0x00000021
+#define PIN_CFG_EPIO25                      0x00000022
+#define PIN_CFG_EPIO26                      0x00000023
+#define PIN_CFG_EPIO27                      0x00000024
+#define PIN_CFG_EPIO28                      0x00000025
+#define PIN_CFG_EPIO29                      0x00000026
+#define PIN_CFG_EPIO30                      0x00000027
+#define PIN_CFG_EPIO31                      0x00000028
+
+/* EPIO definition */
+#define EPIO_CFG_NA                         0x00000000
+#define EPIO_CFG_EPIO0                      0x00000001
+#define EPIO_CFG_EPIO1                      0x00000002
+#define EPIO_CFG_EPIO2                      0x00000003
+#define EPIO_CFG_EPIO3                      0x00000004
+#define EPIO_CFG_EPIO4                      0x00000005
+#define EPIO_CFG_EPIO5                      0x00000006
+#define EPIO_CFG_EPIO6                      0x00000007
+#define EPIO_CFG_EPIO7                      0x00000008
+#define EPIO_CFG_EPIO8                      0x00000009
+#define EPIO_CFG_EPIO9                      0x0000000a
+#define EPIO_CFG_EPIO10                     0x0000000b
+#define EPIO_CFG_EPIO11                     0x0000000c
+#define EPIO_CFG_EPIO12                     0x0000000d
+#define EPIO_CFG_EPIO13                     0x0000000e
+#define EPIO_CFG_EPIO14                     0x0000000f
+#define EPIO_CFG_EPIO15                     0x00000010
+#define EPIO_CFG_EPIO16                     0x00000011
+#define EPIO_CFG_EPIO17                     0x00000012
+#define EPIO_CFG_EPIO18                     0x00000013
+#define EPIO_CFG_EPIO19                     0x00000014
+#define EPIO_CFG_EPIO20                     0x00000015
+#define EPIO_CFG_EPIO21                     0x00000016
+#define EPIO_CFG_EPIO22                     0x00000017
+#define EPIO_CFG_EPIO23                     0x00000018
+#define EPIO_CFG_EPIO24                     0x00000019
+#define EPIO_CFG_EPIO25                     0x0000001a
+#define EPIO_CFG_EPIO26                     0x0000001b
+#define EPIO_CFG_EPIO27                     0x0000001c
+#define EPIO_CFG_EPIO28                     0x0000001d
+#define EPIO_CFG_EPIO29                     0x0000001e
+#define EPIO_CFG_EPIO30                     0x0000001f
+#define EPIO_CFG_EPIO31                     0x00000020
+
+
+struct shared_hw_cfg {                   /* NVRAM Offset */
         /* Up to 16 bytes of NULL-terminated string */
-        u8  part_num[16];                                       /* 0x104 */
+        u8  part_num[16];                   /* 0x104 */
+
+        u32 config;                     /* 0x114 */
+        #define SHARED_HW_CFG_MDIO_VOLTAGE_MASK             0x00000001
+                #define SHARED_HW_CFG_MDIO_VOLTAGE_SHIFT             0
+                #define SHARED_HW_CFG_MDIO_VOLTAGE_1_2V              0x00000000
+                #define SHARED_HW_CFG_MDIO_VOLTAGE_2_5V              0x00000001
+        #define SHARED_HW_CFG_MCP_RST_ON_CORE_RST_EN        0x00000002
 
-        u32 config;                                             /* 0x114 */
-#define SHARED_HW_CFG_MDIO_VOLTAGE_MASK             0x00000001
-#define SHARED_HW_CFG_MDIO_VOLTAGE_SHIFT            0
-#define SHARED_HW_CFG_MDIO_VOLTAGE_1_2V             0x00000000
-#define SHARED_HW_CFG_MDIO_VOLTAGE_2_5V             0x00000001
-#define SHARED_HW_CFG_MCP_RST_ON_CORE_RST_EN        0x00000002
+        #define SHARED_HW_CFG_PORT_SWAP                     0x00000004
 
-#define SHARED_HW_CFG_PORT_SWAP                     0x00000004
+        #define SHARED_HW_CFG_BEACON_WOL_EN                 0x00000008
 
-#define SHARED_HW_CFG_BEACON_WOL_EN                 0x00000008
+        #define SHARED_HW_CFG_PCIE_GEN3_DISABLED            0x00000000
+        #define SHARED_HW_CFG_PCIE_GEN3_ENABLED             0x00000010
 
-#define SHARED_HW_CFG_MFW_SELECT_MASK               0x00000700
-#define SHARED_HW_CFG_MFW_SELECT_SHIFT              8
+        #define SHARED_HW_CFG_MFW_SELECT_MASK               0x00000700
+                #define SHARED_HW_CFG_MFW_SELECT_SHIFT               8
         /* Whatever MFW found in NVM
            (if multiple found, priority order is: NC-SI, UMP, IPMI) */
-#define SHARED_HW_CFG_MFW_SELECT_DEFAULT            0x00000000
-#define SHARED_HW_CFG_MFW_SELECT_NC_SI              0x00000100
-#define SHARED_HW_CFG_MFW_SELECT_UMP                0x00000200
-#define SHARED_HW_CFG_MFW_SELECT_IPMI               0x00000300
+                #define SHARED_HW_CFG_MFW_SELECT_DEFAULT             0x00000000
+                #define SHARED_HW_CFG_MFW_SELECT_NC_SI               0x00000100
+                #define SHARED_HW_CFG_MFW_SELECT_UMP                 0x00000200
+                #define SHARED_HW_CFG_MFW_SELECT_IPMI                0x00000300
         /* Use SPIO4 as an arbiter between: 0-NC_SI, 1-IPMI
           (can only be used when an add-in board, not BMC, pulls-down SPIO4) */
-#define SHARED_HW_CFG_MFW_SELECT_SPIO4_NC_SI_IPMI   0x00000400
+                #define SHARED_HW_CFG_MFW_SELECT_SPIO4_NC_SI_IPMI    0x00000400
         /* Use SPIO4 as an arbiter between: 0-UMP, 1-IPMI
           (can only be used when an add-in board, not BMC, pulls-down SPIO4) */
-#define SHARED_HW_CFG_MFW_SELECT_SPIO4_UMP_IPMI     0x00000500
+                #define SHARED_HW_CFG_MFW_SELECT_SPIO4_UMP_IPMI      0x00000500
         /* Use SPIO4 as an arbiter between: 0-NC-SI, 1-UMP
           (can only be used when an add-in board, not BMC, pulls-down SPIO4) */
-#define SHARED_HW_CFG_MFW_SELECT_SPIO4_NC_SI_UMP    0x00000600
-
-#define SHARED_HW_CFG_LED_MODE_MASK                 0x000f0000
-#define SHARED_HW_CFG_LED_MODE_SHIFT                16
-#define SHARED_HW_CFG_LED_MAC1                      0x00000000
-#define SHARED_HW_CFG_LED_PHY1                      0x00010000
-#define SHARED_HW_CFG_LED_PHY2                      0x00020000
-#define SHARED_HW_CFG_LED_PHY3                      0x00030000
-#define SHARED_HW_CFG_LED_MAC2                      0x00040000
-#define SHARED_HW_CFG_LED_PHY4                      0x00050000
-#define SHARED_HW_CFG_LED_PHY5                      0x00060000
-#define SHARED_HW_CFG_LED_PHY6                      0x00070000
-#define SHARED_HW_CFG_LED_MAC3                      0x00080000
-#define SHARED_HW_CFG_LED_PHY7                      0x00090000
-#define SHARED_HW_CFG_LED_PHY9                      0x000a0000
-#define SHARED_HW_CFG_LED_PHY11                     0x000b0000
-#define SHARED_HW_CFG_LED_MAC4                      0x000c0000
-#define SHARED_HW_CFG_LED_PHY8                      0x000d0000
-#define SHARED_HW_CFG_LED_EXTPHY1                   0x000e0000
-
-
-#define SHARED_HW_CFG_AN_ENABLE_MASK                0x3f000000
-#define SHARED_HW_CFG_AN_ENABLE_SHIFT               24
-#define SHARED_HW_CFG_AN_ENABLE_CL37                0x01000000
-#define SHARED_HW_CFG_AN_ENABLE_CL73                0x02000000
-#define SHARED_HW_CFG_AN_ENABLE_BAM                 0x04000000
-#define SHARED_HW_CFG_AN_ENABLE_PARALLEL_DETECTION  0x08000000
-#define SHARED_HW_CFG_AN_EN_SGMII_FIBER_AUTO_DETECT 0x10000000
-#define SHARED_HW_CFG_AN_ENABLE_REMOTE_PHY          0x20000000
-
-        u32 config2;                                            /* 0x118 */
+                #define SHARED_HW_CFG_MFW_SELECT_SPIO4_NC_SI_UMP     0x00000600
+
+        #define SHARED_HW_CFG_LED_MODE_MASK                 0x000f0000
+                #define SHARED_HW_CFG_LED_MODE_SHIFT                 16
+                #define SHARED_HW_CFG_LED_MAC1                       0x00000000
+                #define SHARED_HW_CFG_LED_PHY1                       0x00010000
+                #define SHARED_HW_CFG_LED_PHY2                       0x00020000
+                #define SHARED_HW_CFG_LED_PHY3                       0x00030000
+                #define SHARED_HW_CFG_LED_MAC2                       0x00040000
+                #define SHARED_HW_CFG_LED_PHY4                       0x00050000
+                #define SHARED_HW_CFG_LED_PHY5                       0x00060000
+                #define SHARED_HW_CFG_LED_PHY6                       0x00070000
+                #define SHARED_HW_CFG_LED_MAC3                       0x00080000
+                #define SHARED_HW_CFG_LED_PHY7                       0x00090000
+                #define SHARED_HW_CFG_LED_PHY9                       0x000a0000
+                #define SHARED_HW_CFG_LED_PHY11                      0x000b0000
+                #define SHARED_HW_CFG_LED_MAC4                       0x000c0000
+                #define SHARED_HW_CFG_LED_PHY8                       0x000d0000
+                #define SHARED_HW_CFG_LED_EXTPHY1                    0x000e0000
+
+
+        #define SHARED_HW_CFG_AN_ENABLE_MASK                0x3f000000
+                #define SHARED_HW_CFG_AN_ENABLE_SHIFT                24
+                #define SHARED_HW_CFG_AN_ENABLE_CL37                 0x01000000
+                #define SHARED_HW_CFG_AN_ENABLE_CL73                 0x02000000
+                #define SHARED_HW_CFG_AN_ENABLE_BAM                  0x04000000
+                #define SHARED_HW_CFG_AN_ENABLE_PARALLEL_DETECTION   0x08000000
+                #define SHARED_HW_CFG_AN_EN_SGMII_FIBER_AUTO_DETECT  0x10000000
+                #define SHARED_HW_CFG_AN_ENABLE_REMOTE_PHY           0x20000000
+
+        #define SHARED_HW_CFG_SRIOV_MASK                    0x40000000
+                #define SHARED_HW_CFG_SRIOV_DISABLED                 0x00000000
+                #define SHARED_HW_CFG_SRIOV_ENABLED                  0x40000000
+
+        #define SHARED_HW_CFG_ATC_MASK                      0x80000000
+                #define SHARED_HW_CFG_ATC_DISABLED                   0x00000000
+                #define SHARED_HW_CFG_ATC_ENABLED                    0x80000000
+
+        u32 config2;                        /* 0x118 */
         /* one time auto detect grace period (in sec) */
-#define SHARED_HW_CFG_GRACE_PERIOD_MASK             0x000000ff
-#define SHARED_HW_CFG_GRACE_PERIOD_SHIFT            0
+        #define SHARED_HW_CFG_GRACE_PERIOD_MASK             0x000000ff
+        #define SHARED_HW_CFG_GRACE_PERIOD_SHIFT                     0
 
-#define SHARED_HW_CFG_PCIE_GEN2_ENABLED             0x00000100
+        #define SHARED_HW_CFG_PCIE_GEN2_ENABLED             0x00000100
+        #define SHARED_HW_CFG_PCIE_GEN2_DISABLED            0x00000000
 
         /* The default value for the core clock is 250MHz and it is
            achieved by setting the clock change to 4 */
-#define SHARED_HW_CFG_CLOCK_CHANGE_MASK             0x00000e00
-#define SHARED_HW_CFG_CLOCK_CHANGE_SHIFT            9
+        #define SHARED_HW_CFG_CLOCK_CHANGE_MASK             0x00000e00
+        #define SHARED_HW_CFG_CLOCK_CHANGE_SHIFT                     9
 
-#define SHARED_HW_CFG_SMBUS_TIMING_100KHZ           0x00000000
-#define SHARED_HW_CFG_SMBUS_TIMING_400KHZ           0x00001000
+        #define SHARED_HW_CFG_SMBUS_TIMING_MASK             0x00001000
+                #define SHARED_HW_CFG_SMBUS_TIMING_100KHZ            0x00000000
+                #define SHARED_HW_CFG_SMBUS_TIMING_400KHZ            0x00001000
 
-#define SHARED_HW_CFG_HIDE_PORT1                    0x00002000
+        #define SHARED_HW_CFG_HIDE_PORT1                    0x00002000
 
-        /*  The fan failure mechanism is usually related to the PHY type
-          since the power consumption of the board is determined by the PHY.
-          Currently, fan is required for most designs with SFX7101, BCM8727
-          and BCM8481. If a fan is not required for a board which uses one
-          of those PHYs, this field should be set to "Disabled". If a fan is
-          required for a different PHY type, this option should be set to
-          "Enabled".
-          The fan failure indication is expected on
-          SPIO5 */
-#define SHARED_HW_CFG_FAN_FAILURE_MASK                        0x00180000
-#define SHARED_HW_CFG_FAN_FAILURE_SHIFT                       19
-#define SHARED_HW_CFG_FAN_FAILURE_PHY_TYPE                    0x00000000
-#define SHARED_HW_CFG_FAN_FAILURE_DISABLED                    0x00080000
-#define SHARED_HW_CFG_FAN_FAILURE_ENABLED                     0x00100000
-
-        /* Set the MDC/MDIO access for the first external phy */
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS1_MASK         0x1C000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS1_SHIFT        26
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS1_PHY_TYPE     0x00000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS1_EMAC0        0x04000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS1_EMAC1        0x08000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS1_BOTH         0x0c000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS1_SWAPPED      0x10000000
-
-        /* Set the MDC/MDIO access for the second external phy */
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS2_MASK         0xE0000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS2_SHIFT        29
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS2_PHY_TYPE     0x00000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS2_EMAC0        0x20000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS2_EMAC1        0x40000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS2_BOTH         0x60000000
-#define SHARED_HW_CFG_MDC_MDIO_ACCESS2_SWAPPED      0x80000000
-        u32 power_dissipated;                                   /* 0x11c */
-#define SHARED_HW_CFG_POWER_DIS_CMN_MASK            0xff000000
-#define SHARED_HW_CFG_POWER_DIS_CMN_SHIFT           24
-
-#define SHARED_HW_CFG_POWER_MGNT_SCALE_MASK         0x00ff0000
-#define SHARED_HW_CFG_POWER_MGNT_SCALE_SHIFT        16
-#define SHARED_HW_CFG_POWER_MGNT_UNKNOWN_SCALE      0x00000000
-#define SHARED_HW_CFG_POWER_MGNT_DOT_1_WATT         0x00010000
-#define SHARED_HW_CFG_POWER_MGNT_DOT_01_WATT        0x00020000
-#define SHARED_HW_CFG_POWER_MGNT_DOT_001_WATT       0x00030000
-
-        u32 ump_nc_si_config;                                   /* 0x120 */
-#define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_MASK       0x00000003
-#define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_SHIFT      0
-#define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_MAC        0x00000000
-#define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_PHY        0x00000001
-#define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_MII        0x00000000
-#define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_RMII       0x00000002
-
-#define SHARED_HW_CFG_UMP_NC_SI_NUM_DEVS_MASK       0x00000f00
-#define SHARED_HW_CFG_UMP_NC_SI_NUM_DEVS_SHIFT      8
-
-#define SHARED_HW_CFG_UMP_NC_SI_EXT_PHY_TYPE_MASK   0x00ff0000
-#define SHARED_HW_CFG_UMP_NC_SI_EXT_PHY_TYPE_SHIFT  16
-#define SHARED_HW_CFG_UMP_NC_SI_EXT_PHY_TYPE_NONE   0x00000000
-#define SHARED_HW_CFG_UMP_NC_SI_EXT_PHY_TYPE_BCM5221 0x00010000
-
-        u32 board;                                              /* 0x124 */
-#define SHARED_HW_CFG_BOARD_REV_MASK                0x00FF0000
-#define SHARED_HW_CFG_BOARD_REV_SHIFT               16
-
-#define SHARED_HW_CFG_BOARD_MAJOR_VER_MASK          0x0F000000
-#define SHARED_HW_CFG_BOARD_MAJOR_VER_SHIFT         24
-
-#define SHARED_HW_CFG_BOARD_MINOR_VER_MASK          0xF0000000
-#define SHARED_HW_CFG_BOARD_MINOR_VER_SHIFT         28
-
-        u32 reserved;                                           /* 0x128 */
+        #define SHARED_HW_CFG_WOL_CAPABLE_MASK              0x00004000
+                #define SHARED_HW_CFG_WOL_CAPABLE_DISABLED           0x00000000
+                #define SHARED_HW_CFG_WOL_CAPABLE_ENABLED            0x00004000
 
+                /* Output low when PERST is asserted */
+        #define SHARED_HW_CFG_SPIO4_FOLLOW_PERST_MASK       0x00008000
+                #define SHARED_HW_CFG_SPIO4_FOLLOW_PERST_DISABLED    0x00000000
+                #define SHARED_HW_CFG_SPIO4_FOLLOW_PERST_ENABLED     0x00008000
+
+        #define SHARED_HW_CFG_PCIE_GEN2_PREEMPHASIS_MASK    0x00070000
+                #define SHARED_HW_CFG_PCIE_GEN2_PREEMPHASIS_SHIFT    16
+                #define SHARED_HW_CFG_PCIE_GEN2_PREEMPHASIS_HW       0x00000000
+                #define SHARED_HW_CFG_PCIE_GEN2_PREEMPHASIS_0DB      0x00010000
+                #define SHARED_HW_CFG_PCIE_GEN2_PREEMPHASIS_3_5DB    0x00020000
+                #define SHARED_HW_CFG_PCIE_GEN2_PREEMPHASIS_6_0DB    0x00030000
+
+        /*  The fan failure mechanism is usually related to the PHY type
+              since the power consumption of the board is determined by the PHY.
+              Currently, fan is required for most designs with SFX7101, BCM8727
+              and BCM8481. If a fan is not required for a board which uses one
+              of those PHYs, this field should be set to "Disabled". If a fan is
+              required for a different PHY type, this option should be set to
+              "Enabled". The fan failure indication is expected on SPIO5 */
+        #define SHARED_HW_CFG_FAN_FAILURE_MASK              0x00180000
+                #define SHARED_HW_CFG_FAN_FAILURE_SHIFT              19
+                #define SHARED_HW_CFG_FAN_FAILURE_PHY_TYPE           0x00000000
+                #define SHARED_HW_CFG_FAN_FAILURE_DISABLED           0x00080000
+                #define SHARED_HW_CFG_FAN_FAILURE_ENABLED            0x00100000
+
+                /* ASPM Power Management support */
+        #define SHARED_HW_CFG_ASPM_SUPPORT_MASK             0x00600000
+                #define SHARED_HW_CFG_ASPM_SUPPORT_SHIFT             21
+                #define SHARED_HW_CFG_ASPM_SUPPORT_L0S_L1_ENABLED    0x00000000
+                #define SHARED_HW_CFG_ASPM_SUPPORT_L0S_DISABLED      0x00200000
+                #define SHARED_HW_CFG_ASPM_SUPPORT_L1_DISABLED       0x00400000
+                #define SHARED_HW_CFG_ASPM_SUPPORT_L0S_L1_DISABLED   0x00600000
+
+        /* The value of PM_TL_IGNORE_REQS (bit0) in PCI register
+           tl_control_0 (register 0x2800) */
+        #define SHARED_HW_CFG_PREVENT_L1_ENTRY_MASK         0x00800000
+                #define SHARED_HW_CFG_PREVENT_L1_ENTRY_DISABLED      0x00000000
+                #define SHARED_HW_CFG_PREVENT_L1_ENTRY_ENABLED       0x00800000
+
+        #define SHARED_HW_CFG_PORT_MODE_MASK                0x01000000
+                #define SHARED_HW_CFG_PORT_MODE_2                    0x00000000
+                #define SHARED_HW_CFG_PORT_MODE_4                    0x01000000
+
+        #define SHARED_HW_CFG_PATH_SWAP_MASK                0x02000000
+                #define SHARED_HW_CFG_PATH_SWAP_DISABLED             0x00000000
+                #define SHARED_HW_CFG_PATH_SWAP_ENABLED              0x02000000
+
+        /*  Set the MDC/MDIO access for the first external phy */
+        #define SHARED_HW_CFG_MDC_MDIO_ACCESS1_MASK         0x1C000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS1_SHIFT         26
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS1_PHY_TYPE      0x00000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS1_EMAC0         0x04000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS1_EMAC1         0x08000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS1_BOTH          0x0c000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS1_SWAPPED       0x10000000
+
+        /*  Set the MDC/MDIO access for the second external phy */
+        #define SHARED_HW_CFG_MDC_MDIO_ACCESS2_MASK         0xE0000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS2_SHIFT         29
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS2_PHY_TYPE      0x00000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS2_EMAC0         0x20000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS2_EMAC1         0x40000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS2_BOTH          0x60000000
+                #define SHARED_HW_CFG_MDC_MDIO_ACCESS2_SWAPPED       0x80000000
+
+
+        u32 power_dissipated;                   /* 0x11c */
+        #define SHARED_HW_CFG_POWER_MGNT_SCALE_MASK         0x00ff0000
+                #define SHARED_HW_CFG_POWER_MGNT_SCALE_SHIFT         16
+                #define SHARED_HW_CFG_POWER_MGNT_UNKNOWN_SCALE       0x00000000
+                #define SHARED_HW_CFG_POWER_MGNT_DOT_1_WATT          0x00010000
+                #define SHARED_HW_CFG_POWER_MGNT_DOT_01_WATT         0x00020000
+                #define SHARED_HW_CFG_POWER_MGNT_DOT_001_WATT        0x00030000
+
+        #define SHARED_HW_CFG_POWER_DIS_CMN_MASK            0xff000000
+        #define SHARED_HW_CFG_POWER_DIS_CMN_SHIFT                    24
+
+        u32 ump_nc_si_config;                   /* 0x120 */
+        #define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_MASK       0x00000003
+                #define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_SHIFT       0
+                #define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_MAC         0x00000000
+                #define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_PHY         0x00000001
+                #define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_MII         0x00000000
+                #define SHARED_HW_CFG_UMP_NC_SI_MII_MODE_RMII        0x00000002
+
+        #define SHARED_HW_CFG_UMP_NC_SI_NUM_DEVS_MASK       0x00000f00
+                #define SHARED_HW_CFG_UMP_NC_SI_NUM_DEVS_SHIFT       8
+
+        #define SHARED_HW_CFG_UMP_NC_SI_EXT_PHY_TYPE_MASK   0x00ff0000
+                #define SHARED_HW_CFG_UMP_NC_SI_EXT_PHY_TYPE_SHIFT   16
+                #define SHARED_HW_CFG_UMP_NC_SI_EXT_PHY_TYPE_NONE    0x00000000
+                #define SHARED_HW_CFG_UMP_NC_SI_EXT_PHY_TYPE_BCM5221 0x00010000
+
+        u32 board;                      /* 0x124 */
+        #define SHARED_HW_CFG_E3_I2C_MUX0_MASK              0x0000003F
+        #define SHARED_HW_CFG_E3_I2C_MUX0_SHIFT                      0
+        #define SHARED_HW_CFG_E3_I2C_MUX1_MASK              0x00000FC0
+        #define SHARED_HW_CFG_E3_I2C_MUX1_SHIFT                      6
+        /* Use the PIN_CFG_XXX defines on top */
+        #define SHARED_HW_CFG_BOARD_REV_MASK                0x00ff0000
+        #define SHARED_HW_CFG_BOARD_REV_SHIFT                        16
+
+        #define SHARED_HW_CFG_BOARD_MAJOR_VER_MASK          0x0f000000
+        #define SHARED_HW_CFG_BOARD_MAJOR_VER_SHIFT                  24
+
+        #define SHARED_HW_CFG_BOARD_MINOR_VER_MASK          0xf0000000
+        #define SHARED_HW_CFG_BOARD_MINOR_VER_SHIFT                  28
+
+        u32 wc_lane_config;                                 /* 0x128 */
+        #define SHARED_HW_CFG_LANE_SWAP_CFG_MASK            0x0000FFFF
+                #define SHARED_HW_CFG_LANE_SWAP_CFG_SHIFT            0
+                #define SHARED_HW_CFG_LANE_SWAP_CFG_32103210         0x00001b1b
+                #define SHARED_HW_CFG_LANE_SWAP_CFG_32100123         0x00001be4
+                #define SHARED_HW_CFG_LANE_SWAP_CFG_01233210         0x0000e41b
+                #define SHARED_HW_CFG_LANE_SWAP_CFG_01230123         0x0000e4e4
+        #define SHARED_HW_CFG_LANE_SWAP_CFG_TX_MASK         0x000000FF
+        #define SHARED_HW_CFG_LANE_SWAP_CFG_TX_SHIFT                 0
+        #define SHARED_HW_CFG_LANE_SWAP_CFG_RX_MASK         0x0000FF00
+        #define SHARED_HW_CFG_LANE_SWAP_CFG_RX_SHIFT                 8
+
+        /* TX lane Polarity swap */
+        #define SHARED_HW_CFG_TX_LANE0_POL_FLIP_ENABLED     0x00010000
+        #define SHARED_HW_CFG_TX_LANE1_POL_FLIP_ENABLED     0x00020000
+        #define SHARED_HW_CFG_TX_LANE2_POL_FLIP_ENABLED     0x00040000
+        #define SHARED_HW_CFG_TX_LANE3_POL_FLIP_ENABLED     0x00080000
+        /* TX lane Polarity swap */
+        #define SHARED_HW_CFG_RX_LANE0_POL_FLIP_ENABLED     0x00100000
+        #define SHARED_HW_CFG_RX_LANE1_POL_FLIP_ENABLED     0x00200000
+        #define SHARED_HW_CFG_RX_LANE2_POL_FLIP_ENABLED     0x00400000
+        #define SHARED_HW_CFG_RX_LANE3_POL_FLIP_ENABLED     0x00800000
+
+        /*  Selects the port layout of the board */
+        #define SHARED_HW_CFG_E3_PORT_LAYOUT_MASK           0x0F000000
+                #define SHARED_HW_CFG_E3_PORT_LAYOUT_SHIFT           24
+                #define SHARED_HW_CFG_E3_PORT_LAYOUT_2P_01           0x00000000
+                #define SHARED_HW_CFG_E3_PORT_LAYOUT_2P_10           0x01000000
+                #define SHARED_HW_CFG_E3_PORT_LAYOUT_4P_0123         0x02000000
+                #define SHARED_HW_CFG_E3_PORT_LAYOUT_4P_1032         0x03000000
+                #define SHARED_HW_CFG_E3_PORT_LAYOUT_4P_2301         0x04000000
+                #define SHARED_HW_CFG_E3_PORT_LAYOUT_4P_3210         0x05000000
 };
 
 
 /****************************************************************************
- * Port HW configuration                                                    *
+ * Port HW configuration                                                    *
  ****************************************************************************/
-struct port_hw_cfg {                        /* port 0: 0x12c  port 1: 0x2bc */
+struct port_hw_cfg {                /* port 0: 0x12c  port 1: 0x2bc */
 
         u32 pci_id;
-#define PORT_HW_CFG_PCI_VENDOR_ID_MASK              0xffff0000
-#define PORT_HW_CFG_PCI_DEVICE_ID_MASK              0x0000ffff
+        #define PORT_HW_CFG_PCI_VENDOR_ID_MASK              0xffff0000
+        #define PORT_HW_CFG_PCI_DEVICE_ID_MASK              0x0000ffff
 
         u32 pci_sub_id;
-#define PORT_HW_CFG_PCI_SUBSYS_DEVICE_ID_MASK       0xffff0000
-#define PORT_HW_CFG_PCI_SUBSYS_VENDOR_ID_MASK       0x0000ffff
+        #define PORT_HW_CFG_PCI_SUBSYS_DEVICE_ID_MASK       0xffff0000
+        #define PORT_HW_CFG_PCI_SUBSYS_VENDOR_ID_MASK       0x0000ffff
 
         u32 power_dissipated;
-#define PORT_HW_CFG_POWER_DIS_D3_MASK               0xff000000
-#define PORT_HW_CFG_POWER_DIS_D3_SHIFT              24
-#define PORT_HW_CFG_POWER_DIS_D2_MASK               0x00ff0000
-#define PORT_HW_CFG_POWER_DIS_D2_SHIFT              16
-#define PORT_HW_CFG_POWER_DIS_D1_MASK               0x0000ff00
-#define PORT_HW_CFG_POWER_DIS_D1_SHIFT              8
-#define PORT_HW_CFG_POWER_DIS_D0_MASK               0x000000ff
-#define PORT_HW_CFG_POWER_DIS_D0_SHIFT              0
+        #define PORT_HW_CFG_POWER_DIS_D0_MASK               0x000000ff
+        #define PORT_HW_CFG_POWER_DIS_D0_SHIFT                       0
+        #define PORT_HW_CFG_POWER_DIS_D1_MASK               0x0000ff00
+        #define PORT_HW_CFG_POWER_DIS_D1_SHIFT                       8
+        #define PORT_HW_CFG_POWER_DIS_D2_MASK               0x00ff0000
+        #define PORT_HW_CFG_POWER_DIS_D2_SHIFT                       16
+        #define PORT_HW_CFG_POWER_DIS_D3_MASK               0xff000000
+        #define PORT_HW_CFG_POWER_DIS_D3_SHIFT                       24
 
         u32 power_consumed;
-#define PORT_HW_CFG_POWER_CONS_D3_MASK              0xff000000
-#define PORT_HW_CFG_POWER_CONS_D3_SHIFT             24
-#define PORT_HW_CFG_POWER_CONS_D2_MASK              0x00ff0000
-#define PORT_HW_CFG_POWER_CONS_D2_SHIFT             16
-#define PORT_HW_CFG_POWER_CONS_D1_MASK              0x0000ff00
-#define PORT_HW_CFG_POWER_CONS_D1_SHIFT             8
-#define PORT_HW_CFG_POWER_CONS_D0_MASK              0x000000ff
-#define PORT_HW_CFG_POWER_CONS_D0_SHIFT             0
+        #define PORT_HW_CFG_POWER_CONS_D0_MASK              0x000000ff
+        #define PORT_HW_CFG_POWER_CONS_D0_SHIFT                      0
+        #define PORT_HW_CFG_POWER_CONS_D1_MASK              0x0000ff00
+        #define PORT_HW_CFG_POWER_CONS_D1_SHIFT                      8
+        #define PORT_HW_CFG_POWER_CONS_D2_MASK              0x00ff0000
+        #define PORT_HW_CFG_POWER_CONS_D2_SHIFT                      16
+        #define PORT_HW_CFG_POWER_CONS_D3_MASK              0xff000000
+        #define PORT_HW_CFG_POWER_CONS_D3_SHIFT                      24
 
         u32 mac_upper;
-#define PORT_HW_CFG_UPPERMAC_MASK                   0x0000ffff
-#define PORT_HW_CFG_UPPERMAC_SHIFT                  0
+        #define PORT_HW_CFG_UPPERMAC_MASK                   0x0000ffff
+        #define PORT_HW_CFG_UPPERMAC_SHIFT                           0
         u32 mac_lower;
 
         u32 iscsi_mac_upper;  /* Upper 16 bits are always zeroes */
@@ -237,658 +402,799 @@ struct port_hw_cfg {			    /* port 0: 0x12c  port 1: 0x2bc */
         u32 rdma_mac_lower;
 
         u32 serdes_config;
-#define PORT_HW_CFG_SERDES_TX_DRV_PRE_EMPHASIS_MASK           0x0000FFFF
-#define PORT_HW_CFG_SERDES_TX_DRV_PRE_EMPHASIS_SHIFT          0
-
-#define PORT_HW_CFG_SERDES_RX_DRV_EQUALIZER_MASK              0xFFFF0000
-#define PORT_HW_CFG_SERDES_RX_DRV_EQUALIZER_SHIFT             16
-
-
-        u32 Reserved0[3];                                   /* 0x158 */
-        /*      Controls the TX laser of the SFP+ module */
-        u32 sfp_ctrl;                                   /* 0x164 */
-#define PORT_HW_CFG_TX_LASER_MASK                             0x000000FF
-#define PORT_HW_CFG_TX_LASER_SHIFT                            0
-#define PORT_HW_CFG_TX_LASER_MDIO                             0x00000000
-#define PORT_HW_CFG_TX_LASER_GPIO0                            0x00000001
-#define PORT_HW_CFG_TX_LASER_GPIO1                            0x00000002
-#define PORT_HW_CFG_TX_LASER_GPIO2                            0x00000003
-#define PORT_HW_CFG_TX_LASER_GPIO3                            0x00000004
-
-    /*  Controls the fault module LED of the SFP+ */
-#define PORT_HW_CFG_FAULT_MODULE_LED_MASK                     0x0000FF00
-#define PORT_HW_CFG_FAULT_MODULE_LED_SHIFT                    8
-#define PORT_HW_CFG_FAULT_MODULE_LED_GPIO0                    0x00000000
-#define PORT_HW_CFG_FAULT_MODULE_LED_GPIO1                    0x00000100
-#define PORT_HW_CFG_FAULT_MODULE_LED_GPIO2                    0x00000200
-#define PORT_HW_CFG_FAULT_MODULE_LED_GPIO3                    0x00000300
-#define PORT_HW_CFG_FAULT_MODULE_LED_DISABLED                 0x00000400
-
-        u32 Reserved01[10];                                 /* 0x158 */
-
-        u32 aeu_int_mask;                                       /* 0x190 */
-
-        u32 media_type;                                 /* 0x194 */
-#define PORT_HW_CFG_MEDIA_TYPE_PHY0_MASK                      0x000000FF
-#define PORT_HW_CFG_MEDIA_TYPE_PHY0_SHIFT                     0
-
-#define PORT_HW_CFG_MEDIA_TYPE_PHY1_MASK                      0x0000FF00
-#define PORT_HW_CFG_MEDIA_TYPE_PHY1_SHIFT                     8
-
-#define PORT_HW_CFG_MEDIA_TYPE_PHY2_MASK                      0x00FF0000
-#define PORT_HW_CFG_MEDIA_TYPE_PHY2_SHIFT                     16
-        /*  for external PHY, or forced mode or during AN */
-        u16 xgxs_config_rx[4];                              /* 0x198 */
-
-        u16 xgxs_config_tx[4];                              /* 0x1A0 */
-
-        u32 Reserved1[56];                                  /* 0x1A8 */
-        u32 default_cfg;                                    /* 0x288 */
-#define PORT_HW_CFG_GPIO0_CONFIG_MASK                         0x00000003
-#define PORT_HW_CFG_GPIO0_CONFIG_SHIFT                        0
-#define PORT_HW_CFG_GPIO0_CONFIG_NA                           0x00000000
-#define PORT_HW_CFG_GPIO0_CONFIG_LOW                          0x00000001
-#define PORT_HW_CFG_GPIO0_CONFIG_HIGH                         0x00000002
-#define PORT_HW_CFG_GPIO0_CONFIG_INPUT                        0x00000003
-
-#define PORT_HW_CFG_GPIO1_CONFIG_MASK                         0x0000000C
-#define PORT_HW_CFG_GPIO1_CONFIG_SHIFT                        2
-#define PORT_HW_CFG_GPIO1_CONFIG_NA                           0x00000000
-#define PORT_HW_CFG_GPIO1_CONFIG_LOW                          0x00000004
-#define PORT_HW_CFG_GPIO1_CONFIG_HIGH                         0x00000008
-#define PORT_HW_CFG_GPIO1_CONFIG_INPUT                        0x0000000c
-
-#define PORT_HW_CFG_GPIO2_CONFIG_MASK                         0x00000030
-#define PORT_HW_CFG_GPIO2_CONFIG_SHIFT                        4
-#define PORT_HW_CFG_GPIO2_CONFIG_NA                           0x00000000
-#define PORT_HW_CFG_GPIO2_CONFIG_LOW                          0x00000010
-#define PORT_HW_CFG_GPIO2_CONFIG_HIGH                         0x00000020
-#define PORT_HW_CFG_GPIO2_CONFIG_INPUT                        0x00000030
-
-#define PORT_HW_CFG_GPIO3_CONFIG_MASK                         0x000000C0
-#define PORT_HW_CFG_GPIO3_CONFIG_SHIFT                        6
-#define PORT_HW_CFG_GPIO3_CONFIG_NA                           0x00000000
-#define PORT_HW_CFG_GPIO3_CONFIG_LOW                          0x00000040
-#define PORT_HW_CFG_GPIO3_CONFIG_HIGH                         0x00000080
-#define PORT_HW_CFG_GPIO3_CONFIG_INPUT                        0x000000c0
+        #define PORT_HW_CFG_SERDES_TX_DRV_PRE_EMPHASIS_MASK 0x0000ffff
+        #define PORT_HW_CFG_SERDES_TX_DRV_PRE_EMPHASIS_SHIFT         0
+
+        #define PORT_HW_CFG_SERDES_RX_DRV_EQUALIZER_MASK    0xffff0000
+        #define PORT_HW_CFG_SERDES_RX_DRV_EQUALIZER_SHIFT            16
+
+
+        /*  Default values: 2P-64, 4P-32 */
+        u32 pf_config;                                      /* 0x158 */
+        #define PORT_HW_CFG_PF_NUM_VF_MASK                  0x0000007F
+        #define PORT_HW_CFG_PF_NUM_VF_SHIFT                          0
+
+        /*  Default values: 17 */
+        #define PORT_HW_CFG_PF_NUM_MSIX_VECTORS_MASK        0x00007F00
+        #define PORT_HW_CFG_PF_NUM_MSIX_VECTORS_SHIFT                8
+
+        #define PORT_HW_CFG_ENABLE_FLR_MASK                 0x00010000
+        #define PORT_HW_CFG_FLR_ENABLED                     0x00010000
+
+        u32 vf_config;                                      /* 0x15C */
+        #define PORT_HW_CFG_VF_NUM_MSIX_VECTORS_MASK        0x0000007F
+        #define PORT_HW_CFG_VF_NUM_MSIX_VECTORS_SHIFT                0
+
+        #define PORT_HW_CFG_VF_PCI_DEVICE_ID_MASK           0xFFFF0000
+        #define PORT_HW_CFG_VF_PCI_DEVICE_ID_SHIFT                   16
+
+        u32 mf_pci_id;                                      /* 0x160 */
+        #define PORT_HW_CFG_MF_PCI_DEVICE_ID_MASK           0x0000FFFF
+        #define PORT_HW_CFG_MF_PCI_DEVICE_ID_SHIFT                   0
+
+        /*  Controls the TX laser of the SFP+ module */
+        u32 sfp_ctrl;                                       /* 0x164 */
+        #define PORT_HW_CFG_TX_LASER_MASK                   0x000000FF
+                #define PORT_HW_CFG_TX_LASER_SHIFT                   0
+                #define PORT_HW_CFG_TX_LASER_MDIO                    0x00000000
+                #define PORT_HW_CFG_TX_LASER_GPIO0                   0x00000001
+                #define PORT_HW_CFG_TX_LASER_GPIO1                   0x00000002
+                #define PORT_HW_CFG_TX_LASER_GPIO2                   0x00000003
+                #define PORT_HW_CFG_TX_LASER_GPIO3                   0x00000004
+
+        /*  Controls the fault module LED of the SFP+ */
+        #define PORT_HW_CFG_FAULT_MODULE_LED_MASK           0x0000FF00
+                #define PORT_HW_CFG_FAULT_MODULE_LED_SHIFT           8
+                #define PORT_HW_CFG_FAULT_MODULE_LED_GPIO0           0x00000000
+                #define PORT_HW_CFG_FAULT_MODULE_LED_GPIO1           0x00000100
+                #define PORT_HW_CFG_FAULT_MODULE_LED_GPIO2           0x00000200
+                #define PORT_HW_CFG_FAULT_MODULE_LED_GPIO3           0x00000300
+                #define PORT_HW_CFG_FAULT_MODULE_LED_DISABLED        0x00000400
+
+        /*  The output pin TX_DIS that controls the TX laser of the SFP+
+          module. Use the PIN_CFG_XXX defines on top */
+        u32 e3_sfp_ctrl;                                    /* 0x168 */
+        #define PORT_HW_CFG_E3_TX_LASER_MASK                0x000000FF
+        #define PORT_HW_CFG_E3_TX_LASER_SHIFT                        0
+
+        /*  The output pin for SFPP_TYPE which turns on the Fault module LED */
+        #define PORT_HW_CFG_E3_FAULT_MDL_LED_MASK           0x0000FF00
+        #define PORT_HW_CFG_E3_FAULT_MDL_LED_SHIFT                   8
+
+        /*  The input pin MOD_ABS that indicates whether SFP+ module is
+          present or not. Use the PIN_CFG_XXX defines on top */
+        #define PORT_HW_CFG_E3_MOD_ABS_MASK                 0x00FF0000
+        #define PORT_HW_CFG_E3_MOD_ABS_SHIFT                         16
+
+        /*  The output pin PWRDIS_SFP_X which disable the power of the SFP+
+          module. Use the PIN_CFG_XXX defines on top */
+        #define PORT_HW_CFG_E3_PWR_DIS_MASK                 0xFF000000
+        #define PORT_HW_CFG_E3_PWR_DIS_SHIFT                         24
 
         /*
-         * When KR link is required to be set to force which is not
-         * KR-compliant, this parameter determine what is the trigger for it.
-         * When GPIO is selected, low input will force the speed. Currently
-         * default speed is 1G. In the future, it may be widen to select the
-         * forced speed in with another parameter. Note when force-1G is
-         * enabled, it override option 56: Link Speed option.
+         * The input pin which signals module transmit fault. Use the
+         * PIN_CFG_XXX defines on top
          */
-#define PORT_HW_CFG_FORCE_KR_ENABLER_MASK                     0x00000F00
-#define PORT_HW_CFG_FORCE_KR_ENABLER_SHIFT                    8
-#define PORT_HW_CFG_FORCE_KR_ENABLER_NOT_FORCED               0x00000000
-#define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO0_P0                 0x00000100
-#define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO1_P0                 0x00000200
-#define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO2_P0                 0x00000300
-#define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO3_P0                 0x00000400
-#define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO0_P1                 0x00000500
-#define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO1_P1                 0x00000600
-#define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO2_P1                 0x00000700
-#define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO3_P1                 0x00000800
-#define PORT_HW_CFG_FORCE_KR_ENABLER_FORCED                   0x00000900
-    /*  Enable to determine with which GPIO to reset the external phy */
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_MASK                     0x000F0000
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_SHIFT                    16
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_PHY_TYPE                 0x00000000
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO0_P0                 0x00010000
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO1_P0                 0x00020000
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO2_P0                 0x00030000
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO3_P0                 0x00040000
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO0_P1                 0x00050000
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO1_P1                 0x00060000
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO2_P1                 0x00070000
-#define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO3_P1                 0x00080000
+        u32 e3_cmn_pin_cfg;                                 /* 0x16C */
+        #define PORT_HW_CFG_E3_TX_FAULT_MASK                0x000000FF
+        #define PORT_HW_CFG_E3_TX_FAULT_SHIFT                        0
+
+        /*  The output pin which reset the PHY. Use the PIN_CFG_XXX defines on
+         top */
+        #define PORT_HW_CFG_E3_PHY_RESET_MASK               0x0000FF00
+        #define PORT_HW_CFG_E3_PHY_RESET_SHIFT                       8
+
+        /*
+         * The output pin which powers down the PHY. Use the PIN_CFG_XXX
+         * defines on top
+         */
+        #define PORT_HW_CFG_E3_PWR_DOWN_MASK                0x00FF0000
+        #define PORT_HW_CFG_E3_PWR_DOWN_SHIFT                        16
+
+        /*  The output pin values BSC_SEL which selects the I2C for this port
+          in the I2C Mux */
+        #define PORT_HW_CFG_E3_I2C_MUX0_MASK                0x01000000
+        #define PORT_HW_CFG_E3_I2C_MUX1_MASK                0x02000000
+
+
+        /*
+         * The input pin I_FAULT which indicate over-current has occurred.
+         * Use the PIN_CFG_XXX defines on top
+         */
+        u32 e3_cmn_pin_cfg1;                                /* 0x170 */
+        #define PORT_HW_CFG_E3_OVER_CURRENT_MASK            0x000000FF
+        #define PORT_HW_CFG_E3_OVER_CURRENT_SHIFT                    0
+        u32 reserved0[7];                                   /* 0x174 */
+
+        u32 aeu_int_mask;                                   /* 0x190 */
+
+        u32 media_type;                                     /* 0x194 */
+        #define PORT_HW_CFG_MEDIA_TYPE_PHY0_MASK            0x000000FF
+        #define PORT_HW_CFG_MEDIA_TYPE_PHY0_SHIFT                    0
+
+        #define PORT_HW_CFG_MEDIA_TYPE_PHY1_MASK            0x0000FF00
+        #define PORT_HW_CFG_MEDIA_TYPE_PHY1_SHIFT                    8
+
+        #define PORT_HW_CFG_MEDIA_TYPE_PHY2_MASK            0x00FF0000
+        #define PORT_HW_CFG_MEDIA_TYPE_PHY2_SHIFT                    16
+
+        /*  4 times 16 bits for all 4 lanes. In case external PHY is present
+              (not direct mode), those values will not take effect on the 4 XGXS
+              lanes. For some external PHYs (such as 8706 and 8726) the values
+              will be used to configure the external PHY  in those cases, not
+              all 4 values are needed. */
+        u16 xgxs_config_rx[4];                  /* 0x198 */
+        u16 xgxs_config_tx[4];                  /* 0x1A0 */
+
+        /* For storing FCOE mac on shared memory */
+        u32 fcoe_fip_mac_upper;
+        #define PORT_HW_CFG_FCOE_UPPERMAC_MASK              0x0000ffff
+        #define PORT_HW_CFG_FCOE_UPPERMAC_SHIFT                      0
+        u32 fcoe_fip_mac_lower;
+
+        u32 fcoe_wwn_port_name_upper;
+        u32 fcoe_wwn_port_name_lower;
+
+        u32 fcoe_wwn_node_name_upper;
+        u32 fcoe_wwn_node_name_lower;
+
+        u32 Reserved1[50];                                      /* 0x1C0 */
+
+                u32 default_cfg;                            /* 0x288 */
+        #define PORT_HW_CFG_GPIO0_CONFIG_MASK               0x00000003
+                #define PORT_HW_CFG_GPIO0_CONFIG_SHIFT               0
+                #define PORT_HW_CFG_GPIO0_CONFIG_NA                  0x00000000
+                #define PORT_HW_CFG_GPIO0_CONFIG_LOW                 0x00000001
+                #define PORT_HW_CFG_GPIO0_CONFIG_HIGH                0x00000002
+                #define PORT_HW_CFG_GPIO0_CONFIG_INPUT               0x00000003
+
+        #define PORT_HW_CFG_GPIO1_CONFIG_MASK               0x0000000C
+                #define PORT_HW_CFG_GPIO1_CONFIG_SHIFT               2
+                #define PORT_HW_CFG_GPIO1_CONFIG_NA                  0x00000000
+                #define PORT_HW_CFG_GPIO1_CONFIG_LOW                 0x00000004
+                #define PORT_HW_CFG_GPIO1_CONFIG_HIGH                0x00000008
+                #define PORT_HW_CFG_GPIO1_CONFIG_INPUT               0x0000000c
+
+        #define PORT_HW_CFG_GPIO2_CONFIG_MASK               0x00000030
+                #define PORT_HW_CFG_GPIO2_CONFIG_SHIFT               4
+                #define PORT_HW_CFG_GPIO2_CONFIG_NA                  0x00000000
+                #define PORT_HW_CFG_GPIO2_CONFIG_LOW                 0x00000010
+                #define PORT_HW_CFG_GPIO2_CONFIG_HIGH                0x00000020
+                #define PORT_HW_CFG_GPIO2_CONFIG_INPUT               0x00000030
+
+        #define PORT_HW_CFG_GPIO3_CONFIG_MASK               0x000000C0
+                #define PORT_HW_CFG_GPIO3_CONFIG_SHIFT               6
+                #define PORT_HW_CFG_GPIO3_CONFIG_NA                  0x00000000
+                #define PORT_HW_CFG_GPIO3_CONFIG_LOW                 0x00000040
+                #define PORT_HW_CFG_GPIO3_CONFIG_HIGH                0x00000080
+                #define PORT_HW_CFG_GPIO3_CONFIG_INPUT               0x000000c0
+
+        /*  When KR link is required to be set to force which is not
+              KR-compliant, this parameter determine what is the trigger for it.
+              When GPIO is selected, low input will force the speed. Currently
+              default speed is 1G. In the future, it may be widen to select the
+              forced speed in with another parameter. Note when force-1G is
+              enabled, it override option 56: Link Speed option. */
+        #define PORT_HW_CFG_FORCE_KR_ENABLER_MASK           0x00000F00
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_SHIFT           8
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_NOT_FORCED      0x00000000
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO0_P0        0x00000100
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO1_P0        0x00000200
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO2_P0        0x00000300
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO3_P0        0x00000400
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO0_P1        0x00000500
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO1_P1        0x00000600
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO2_P1        0x00000700
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_GPIO3_P1        0x00000800
+                #define PORT_HW_CFG_FORCE_KR_ENABLER_FORCED          0x00000900
+        /*  Enable to determine with which GPIO to reset the external phy */
+        #define PORT_HW_CFG_EXT_PHY_GPIO_RST_MASK           0x000F0000
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_SHIFT           16
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_PHY_TYPE        0x00000000
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO0_P0        0x00010000
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO1_P0        0x00020000
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO2_P0        0x00030000
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO3_P0        0x00040000
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO0_P1        0x00050000
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO1_P1        0x00060000
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO2_P1        0x00070000
+                #define PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO3_P1        0x00080000
+
         /*  Enable BAM on KR */
-#define PORT_HW_CFG_ENABLE_BAM_ON_KR_MASK                     0x00100000
-#define PORT_HW_CFG_ENABLE_BAM_ON_KR_SHIFT                    20
-#define PORT_HW_CFG_ENABLE_BAM_ON_KR_DISABLED                 0x00000000
-#define PORT_HW_CFG_ENABLE_BAM_ON_KR_ENABLED                  0x00100000
+        #define PORT_HW_CFG_ENABLE_BAM_ON_KR_MASK           0x00100000
+        #define PORT_HW_CFG_ENABLE_BAM_ON_KR_SHIFT                   20
+        #define PORT_HW_CFG_ENABLE_BAM_ON_KR_DISABLED                0x00000000
+        #define PORT_HW_CFG_ENABLE_BAM_ON_KR_ENABLED                 0x00100000
 
         /*  Enable Common Mode Sense */
-#define PORT_HW_CFG_ENABLE_CMS_MASK                           0x00200000
-#define PORT_HW_CFG_ENABLE_CMS_SHIFT                          21
-#define PORT_HW_CFG_ENABLE_CMS_DISABLED                       0x00000000
-#define PORT_HW_CFG_ENABLE_CMS_ENABLED                        0x00200000
+        #define PORT_HW_CFG_ENABLE_CMS_MASK                 0x00200000
+        #define PORT_HW_CFG_ENABLE_CMS_SHIFT                         21
+        #define PORT_HW_CFG_ENABLE_CMS_DISABLED                      0x00000000
+        #define PORT_HW_CFG_ENABLE_CMS_ENABLED                       0x00200000
+
+        /*  Enable RJ45 magjack pair swapping on 10GBase-T PHY, 84833 only */
+        #define PORT_HW_CFG_RJ45_PR_SWP_MASK                0x00400000
+        #define PORT_HW_CFG_RJ45_PR_SWP_SHIFT                        22
+        #define PORT_HW_CFG_RJ45_PR_SWP_DISABLED                     0x00000000
+        #define PORT_HW_CFG_RJ45_PR_SWP_ENABLED                      0x00400000
+
+        /*  Determine the Serdes electrical interface   */
+        #define PORT_HW_CFG_NET_SERDES_IF_MASK              0x0F000000
+        #define PORT_HW_CFG_NET_SERDES_IF_SHIFT                      24
+        #define PORT_HW_CFG_NET_SERDES_IF_SGMII                      0x00000000
+        #define PORT_HW_CFG_NET_SERDES_IF_XFI                        0x01000000
+        #define PORT_HW_CFG_NET_SERDES_IF_SFI                        0x02000000
+        #define PORT_HW_CFG_NET_SERDES_IF_KR                         0x03000000
+        #define PORT_HW_CFG_NET_SERDES_IF_DXGXS                      0x04000000
+        #define PORT_HW_CFG_NET_SERDES_IF_KR2                        0x05000000
+
 
         u32 speed_capability_mask2;                         /* 0x28C */
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_MASK                 0x0000FFFF
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_SHIFT                0
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_10M_FULL             0x00000001
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3__                    0x00000002
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3___                   0x00000004
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_100M_FULL            0x00000008
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_1G                   0x00000010
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_2_DOT_5G             0x00000020
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_10G                  0x00000040
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_12G                  0x00000080
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_12_DOT_5G            0x00000100
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_13G                  0x00000200
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_15G                  0x00000400
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D3_16G                  0x00000800
-
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_MASK                 0xFFFF0000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_SHIFT                16
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_10M_FULL             0x00010000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0__                    0x00020000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0___                   0x00040000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_100M_FULL            0x00080000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_1G                   0x00100000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_2_DOT_5G             0x00200000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_10G                  0x00400000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_12G                  0x00800000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_12_DOT_5G            0x01000000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_13G                  0x02000000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_15G                  0x04000000
-#define PORT_HW_CFG_SPEED_CAPABILITY2_D0_16G                  0x08000000
-
-        /* In the case where two media types (e.g. copper and fiber) are
-          present and electrically active at the same time, PHY Selection
-          will determine which of the two PHYs will be designated as the
-          Active PHY and used for a connection to the network.  */
-        u32 multi_phy_config;                           /* 0x290 */
-#define PORT_HW_CFG_PHY_SELECTION_MASK               0x00000007
-#define PORT_HW_CFG_PHY_SELECTION_SHIFT              0
-#define PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT   0x00000000
-#define PORT_HW_CFG_PHY_SELECTION_FIRST_PHY          0x00000001
-#define PORT_HW_CFG_PHY_SELECTION_SECOND_PHY         0x00000002
-#define PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY 0x00000003
-#define PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY 0x00000004
-
-        /* When enabled, all second phy nvram parameters will be swapped
-          with the first phy parameters */
-#define PORT_HW_CFG_PHY_SWAPPED_MASK                 0x00000008
-#define PORT_HW_CFG_PHY_SWAPPED_SHIFT                3
-#define PORT_HW_CFG_PHY_SWAPPED_DISABLED             0x00000000
-#define PORT_HW_CFG_PHY_SWAPPED_ENABLED              0x00000008
-
-
-        /* Address of the second external phy */
-        u32 external_phy_config2;                               /* 0x294 */
-#define PORT_HW_CFG_XGXS_EXT_PHY2_ADDR_MASK         0x000000FF
-#define PORT_HW_CFG_XGXS_EXT_PHY2_ADDR_SHIFT        0
-
-        /* The second XGXS external PHY type */
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_MASK         0x0000FF00
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_SHIFT        8
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_DIRECT       0x00000000
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8071      0x00000100
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8072      0x00000200
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8073      0x00000300
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8705      0x00000400
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8706      0x00000500
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8726      0x00000600
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8481      0x00000700
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_SFX7101      0x00000800
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8727      0x00000900
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8727_NOC  0x00000a00
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM84823     0x00000b00
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM54640     0x00000c00
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM84833     0x00000d00
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8722      0x00000f00
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_FAILURE      0x0000fd00
-#define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_NOT_CONN     0x0000ff00
-
-        /* 4 times 16 bits for all 4 lanes. For some external PHYs (such as
-          8706, 8726 and 8727) not all 4 values are needed. */
-        u16 xgxs_config2_rx[4];                         /* 0x296 */
-        u16 xgxs_config2_tx[4];                         /* 0x2A0 */
+        #define PORT_HW_CFG_SPEED_CAPABILITY2_D3_MASK       0x0000FFFF
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D3_SHIFT       0
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D3_10M_FULL    0x00000001
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D3__           0x00000002
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D3___          0x00000004
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D3_100M_FULL   0x00000008
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D3_1G          0x00000010
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D3_2_DOT_5G    0x00000020
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D3_10G         0x00000040
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D3_20G         0x00000080
+
+        #define PORT_HW_CFG_SPEED_CAPABILITY2_D0_MASK       0xFFFF0000
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D0_SHIFT       16
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D0_10M_FULL    0x00010000
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D0__           0x00020000
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D0___          0x00040000
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D0_100M_FULL   0x00080000
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D0_1G          0x00100000
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D0_2_DOT_5G    0x00200000
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D0_10G         0x00400000
+                #define PORT_HW_CFG_SPEED_CAPABILITY2_D0_20G         0x00800000
+
+
+        /*  In the case where two media types (e.g. copper and fiber) are
+              present and electrically active at the same time, PHY Selection
+              will determine which of the two PHYs will be designated as the
+              Active PHY and used for a connection to the network.  */
+        u32 multi_phy_config;                               /* 0x290 */
+        #define PORT_HW_CFG_PHY_SELECTION_MASK              0x00000007
+                #define PORT_HW_CFG_PHY_SELECTION_SHIFT              0
+                #define PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT   0x00000000
+                #define PORT_HW_CFG_PHY_SELECTION_FIRST_PHY          0x00000001
+                #define PORT_HW_CFG_PHY_SELECTION_SECOND_PHY         0x00000002
+                #define PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY 0x00000003
+                #define PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY 0x00000004
+
+        /*  When enabled, all second phy nvram parameters will be swapped
+              with the first phy parameters */
+        #define PORT_HW_CFG_PHY_SWAPPED_MASK                0x00000008
+                #define PORT_HW_CFG_PHY_SWAPPED_SHIFT                3
+                #define PORT_HW_CFG_PHY_SWAPPED_DISABLED             0x00000000
+                #define PORT_HW_CFG_PHY_SWAPPED_ENABLED              0x00000008
+
+
+        /*  Address of the second external phy */
+        u32 external_phy_config2;                           /* 0x294 */
+        #define PORT_HW_CFG_XGXS_EXT_PHY2_ADDR_MASK         0x000000FF
+        #define PORT_HW_CFG_XGXS_EXT_PHY2_ADDR_SHIFT                 0
+
+        /*  The second XGXS external PHY type */
+        #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_MASK         0x0000FF00
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_SHIFT         8
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_DIRECT        0x00000000
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8071       0x00000100
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8072       0x00000200
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8073       0x00000300
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8705       0x00000400
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8706       0x00000500
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8726       0x00000600
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8481       0x00000700
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_SFX7101       0x00000800
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8727       0x00000900
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8727_NOC   0x00000a00
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM84823      0x00000b00
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM54640      0x00000c00
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM84833      0x00000d00
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM54616      0x00000e00
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_BCM8722       0x00000f00
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_FAILURE       0x0000fd00
+                #define PORT_HW_CFG_XGXS_EXT_PHY2_TYPE_NOT_CONN      0x0000ff00
+
+
+        /*  4 times 16 bits for all 4 lanes. For some external PHYs (such as
+              8706, 8726 and 8727) not all 4 values are needed. */
+        u16 xgxs_config2_rx[4];                             /* 0x296 */
+        u16 xgxs_config2_tx[4];                             /* 0x2A0 */
 
         u32 lane_config;
-#define PORT_HW_CFG_LANE_SWAP_CFG_MASK              0x0000ffff
-#define PORT_HW_CFG_LANE_SWAP_CFG_SHIFT             0
-
-#define PORT_HW_CFG_LANE_SWAP_CFG_TX_MASK           0x000000ff
-#define PORT_HW_CFG_LANE_SWAP_CFG_TX_SHIFT          0
-#define PORT_HW_CFG_LANE_SWAP_CFG_RX_MASK           0x0000ff00
-#define PORT_HW_CFG_LANE_SWAP_CFG_RX_SHIFT          8
-#define PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK       0x0000c000
-#define PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT      14
-        /* AN and forced */
-#define PORT_HW_CFG_LANE_SWAP_CFG_01230123          0x00001b1b
-        /* forced only */
-#define PORT_HW_CFG_LANE_SWAP_CFG_01233210          0x00001be4
-        /* forced only */
-#define PORT_HW_CFG_LANE_SWAP_CFG_31203120          0x0000d8d8
-        /* forced only */
-#define PORT_HW_CFG_LANE_SWAP_CFG_32103210          0x0000e4e4
-    /*  Indicate whether to swap the external phy polarity */
-#define PORT_HW_CFG_SWAP_PHY_POLARITY_MASK             0x00010000
-#define PORT_HW_CFG_SWAP_PHY_POLARITY_DISABLED      0x00000000
-#define PORT_HW_CFG_SWAP_PHY_POLARITY_ENABLED       0x00010000
+        #define PORT_HW_CFG_LANE_SWAP_CFG_MASK              0x0000ffff
+                #define PORT_HW_CFG_LANE_SWAP_CFG_SHIFT              0
+                /* AN and forced */
+                #define PORT_HW_CFG_LANE_SWAP_CFG_01230123           0x00001b1b
+                /* forced only */
+                #define PORT_HW_CFG_LANE_SWAP_CFG_01233210           0x00001be4
+                /* forced only */
+                #define PORT_HW_CFG_LANE_SWAP_CFG_31203120           0x0000d8d8
+                /* forced only */
+                #define PORT_HW_CFG_LANE_SWAP_CFG_32103210           0x0000e4e4
+        #define PORT_HW_CFG_LANE_SWAP_CFG_TX_MASK           0x000000ff
+        #define PORT_HW_CFG_LANE_SWAP_CFG_TX_SHIFT                   0
+        #define PORT_HW_CFG_LANE_SWAP_CFG_RX_MASK           0x0000ff00
+        #define PORT_HW_CFG_LANE_SWAP_CFG_RX_SHIFT                   8
+        #define PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK       0x0000c000
+        #define PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT               14
+
+        /*  Indicate whether to swap the external phy polarity */
+        #define PORT_HW_CFG_SWAP_PHY_POLARITY_MASK          0x00010000
+                #define PORT_HW_CFG_SWAP_PHY_POLARITY_DISABLED       0x00000000
+                #define PORT_HW_CFG_SWAP_PHY_POLARITY_ENABLED        0x00010000
+
 
         u32 external_phy_config;
-#define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_MASK        0xff000000
-#define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_SHIFT       24
-#define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT      0x00000000
-#define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482     0x01000000
-#define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT_SD   0x02000000
-#define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_NOT_CONN    0xff000000
-
-#define PORT_HW_CFG_SERDES_EXT_PHY_ADDR_MASK        0x00ff0000
-#define PORT_HW_CFG_SERDES_EXT_PHY_ADDR_SHIFT       16
-
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK          0x0000ff00
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SHIFT         8
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT        0x00000000
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8071       0x00000100
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072       0x00000200
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073       0x00000300
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705       0x00000400
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706       0x00000500
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726       0x00000600
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481       0x00000700
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101       0x00000800
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727       0x00000900
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727_NOC   0x00000a00
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823      0x00000b00
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833      0x00000d00
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8722       0x00000f00
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE       0x0000fd00
-#define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN      0x0000ff00
-
-#define PORT_HW_CFG_XGXS_EXT_PHY_ADDR_MASK          0x000000ff
-#define PORT_HW_CFG_XGXS_EXT_PHY_ADDR_SHIFT         0
+        #define PORT_HW_CFG_XGXS_EXT_PHY_ADDR_MASK          0x000000ff
+        #define PORT_HW_CFG_XGXS_EXT_PHY_ADDR_SHIFT                  0
+
+        #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK          0x0000ff00
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SHIFT          8
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT         0x00000000
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8071        0x00000100
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072        0x00000200
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073        0x00000300
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705        0x00000400
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706        0x00000500
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726        0x00000600
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481        0x00000700
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101        0x00000800
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727        0x00000900
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727_NOC    0x00000a00
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823       0x00000b00
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM54640       0x00000c00
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833       0x00000d00
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM54616       0x00000e00
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8722        0x00000f00
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT_WC      0x0000fc00
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE        0x0000fd00
+                #define PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN       0x0000ff00
+
+        #define PORT_HW_CFG_SERDES_EXT_PHY_ADDR_MASK        0x00ff0000
+        #define PORT_HW_CFG_SERDES_EXT_PHY_ADDR_SHIFT                16
+
+        #define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_MASK        0xff000000
+                #define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_SHIFT        24
+                #define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT       0x00000000
+                #define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482      0x01000000
+                #define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT_SD    0x02000000
+                #define PORT_HW_CFG_SERDES_EXT_PHY_TYPE_NOT_CONN     0xff000000
 
         u32 speed_capability_mask;
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_MASK        0xffff0000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_SHIFT       16
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL    0x00010000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF    0x00020000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF   0x00040000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL   0x00080000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_1G          0x00100000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G        0x00200000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_10G         0x00400000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_12G         0x00800000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_12_5G       0x01000000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_13G         0x02000000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_15G         0x04000000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_16G         0x08000000
-#define PORT_HW_CFG_SPEED_CAPABILITY_D0_RESERVED    0xf0000000
-
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_MASK        0x0000ffff
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_SHIFT       0
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_10M_FULL    0x00000001
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_10M_HALF    0x00000002
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_100M_HALF   0x00000004
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_100M_FULL   0x00000008
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_1G          0x00000010
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_2_5G        0x00000020
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_10G         0x00000040
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_12G         0x00000080
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_12_5G       0x00000100
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_13G         0x00000200
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_15G         0x00000400
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_16G         0x00000800
-#define PORT_HW_CFG_SPEED_CAPABILITY_D3_RESERVED    0x0000f000
-
-        u32 reserved[2];
+        #define PORT_HW_CFG_SPEED_CAPABILITY_D3_MASK        0x0000ffff
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_SHIFT        0
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_10M_FULL     0x00000001
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_10M_HALF     0x00000002
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_100M_HALF    0x00000004
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_100M_FULL    0x00000008
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_1G           0x00000010
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_2_5G         0x00000020
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_10G          0x00000040
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_20G          0x00000080
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D3_RESERVED     0x0000f000
+
+        #define PORT_HW_CFG_SPEED_CAPABILITY_D0_MASK        0xffff0000
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_SHIFT        16
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL     0x00010000
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF     0x00020000
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF    0x00040000
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL    0x00080000
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_1G           0x00100000
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G         0x00200000
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_10G          0x00400000
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_20G          0x00800000
+                #define PORT_HW_CFG_SPEED_CAPABILITY_D0_RESERVED     0xf0000000
+
+        /*  A place to hold the original MAC address as a backup */
+        u32 backup_mac_upper;                   /* 0x2B4 */
+        u32 backup_mac_lower;                   /* 0x2B8 */
 
 };
 
 
 /****************************************************************************
- * Shared Feature configuration                                             *
+ * Shared Feature configuration                                             *
  ****************************************************************************/
-struct shared_feat_cfg {                                 /* NVRAM Offset */
+struct shared_feat_cfg {                 /* NVRAM Offset */
+
+        u32 config;                     /* 0x450 */
+        #define SHARED_FEATURE_BMC_ECHO_MODE_EN             0x00000001
+
+        /* Use NVRAM values instead of HW default values */
+        #define SHARED_FEAT_CFG_OVERRIDE_PREEMPHASIS_CFG_MASK \
+                                                            0x00000002
+                #define SHARED_FEAT_CFG_OVERRIDE_PREEMPHASIS_CFG_DISABLED \
+                                                                     0x00000000
+                #define SHARED_FEAT_CFG_OVERRIDE_PREEMPHASIS_CFG_ENABLED \
+                                                                     0x00000002
 
-        u32 config;                                             /* 0x450 */
-#define SHARED_FEATURE_BMC_ECHO_MODE_EN             0x00000001
+        #define SHARED_FEAT_CFG_NCSI_ID_METHOD_MASK         0x00000008
+                #define SHARED_FEAT_CFG_NCSI_ID_METHOD_SPIO          0x00000000
+                #define SHARED_FEAT_CFG_NCSI_ID_METHOD_NVRAM         0x00000008
 
-        /*  Use the values from options 47 and 48 instead of the HW default
-          values */
-#define SHARED_FEAT_CFG_OVERRIDE_PREEMPHASIS_CFG_DISABLED     0x00000000
-#define SHARED_FEAT_CFG_OVERRIDE_PREEMPHASIS_CFG_ENABLED      0x00000002
+        #define SHARED_FEAT_CFG_NCSI_ID_MASK                0x00000030
+        #define SHARED_FEAT_CFG_NCSI_ID_SHIFT                        4
 
-#define SHARED_FEAT_CFG_FORCE_SF_MODE_MASK                    0x00000700
-#define SHARED_FEAT_CFG_FORCE_SF_MODE_SHIFT                   8
-#define SHARED_FEAT_CFG_FORCE_SF_MODE_MF_ALLOWED              0x00000000
-#define SHARED_FEAT_CFG_FORCE_SF_MODE_FORCED_SF               0x00000100
-#define SHARED_FEAT_CFG_FORCE_SF_MODE_SPIO4                   0x00000200
-#define SHARED_FEAT_CFG_FORCE_SF_MODE_SWITCH_INDEPT           0x00000300
+        /*  Override the OTP back to single function mode. When using GPIO,
+              high means only SF, 0 is according to CLP configuration */
+        #define SHARED_FEAT_CFG_FORCE_SF_MODE_MASK          0x00000700
+                #define SHARED_FEAT_CFG_FORCE_SF_MODE_SHIFT          8
+                #define SHARED_FEAT_CFG_FORCE_SF_MODE_MF_ALLOWED     0x00000000
+                #define SHARED_FEAT_CFG_FORCE_SF_MODE_FORCED_SF      0x00000100
+                #define SHARED_FEAT_CFG_FORCE_SF_MODE_SPIO4          0x00000200
+                #define SHARED_FEAT_CFG_FORCE_SF_MODE_SWITCH_INDEPT  0x00000300
+
+        /* The interval in seconds between sending LLDP packets. Set to zero
+           to disable the feature */
+        #define SHARED_FEAT_CFG_LLDP_XMIT_INTERVAL_MASK     0x00ff0000
+        #define SHARED_FEAT_CFG_LLDP_XMIT_INTERVAL_SHIFT             16
+
+        /* The assigned device type ID for LLDP usage */
+        #define SHARED_FEAT_CFG_LLDP_DEVICE_TYPE_ID_MASK    0xff000000
+        #define SHARED_FEAT_CFG_LLDP_DEVICE_TYPE_ID_SHIFT            24
 
 };
 
 
 /****************************************************************************
- * Port Feature configuration                                               *
+ * Port Feature configuration                                               *
  ****************************************************************************/
-struct port_feat_cfg {                      /* port 0: 0x454  port 1: 0x4c8 */
+struct port_feat_cfg {              /* port 0: 0x454  port 1: 0x4c8 */
 
         u32 config;
-#define PORT_FEATURE_BAR1_SIZE_MASK                 0x0000000f
-#define PORT_FEATURE_BAR1_SIZE_SHIFT                0
-#define PORT_FEATURE_BAR1_SIZE_DISABLED             0x00000000
-#define PORT_FEATURE_BAR1_SIZE_64K                  0x00000001
-#define PORT_FEATURE_BAR1_SIZE_128K                 0x00000002
-#define PORT_FEATURE_BAR1_SIZE_256K                 0x00000003
-#define PORT_FEATURE_BAR1_SIZE_512K                 0x00000004
-#define PORT_FEATURE_BAR1_SIZE_1M                   0x00000005
-#define PORT_FEATURE_BAR1_SIZE_2M                   0x00000006
-#define PORT_FEATURE_BAR1_SIZE_4M                   0x00000007
-#define PORT_FEATURE_BAR1_SIZE_8M                   0x00000008
-#define PORT_FEATURE_BAR1_SIZE_16M                  0x00000009
-#define PORT_FEATURE_BAR1_SIZE_32M                  0x0000000a
-#define PORT_FEATURE_BAR1_SIZE_64M                  0x0000000b
-#define PORT_FEATURE_BAR1_SIZE_128M                 0x0000000c
-#define PORT_FEATURE_BAR1_SIZE_256M                 0x0000000d
-#define PORT_FEATURE_BAR1_SIZE_512M                 0x0000000e
-#define PORT_FEATURE_BAR1_SIZE_1G                   0x0000000f
-#define PORT_FEATURE_BAR2_SIZE_MASK                 0x000000f0
-#define PORT_FEATURE_BAR2_SIZE_SHIFT                4
-#define PORT_FEATURE_BAR2_SIZE_DISABLED             0x00000000
-#define PORT_FEATURE_BAR2_SIZE_64K                  0x00000010
-#define PORT_FEATURE_BAR2_SIZE_128K                 0x00000020
-#define PORT_FEATURE_BAR2_SIZE_256K                 0x00000030
-#define PORT_FEATURE_BAR2_SIZE_512K                 0x00000040
-#define PORT_FEATURE_BAR2_SIZE_1M                   0x00000050
-#define PORT_FEATURE_BAR2_SIZE_2M                   0x00000060
-#define PORT_FEATURE_BAR2_SIZE_4M                   0x00000070
-#define PORT_FEATURE_BAR2_SIZE_8M                   0x00000080
-#define PORT_FEATURE_BAR2_SIZE_16M                  0x00000090
-#define PORT_FEATURE_BAR2_SIZE_32M                  0x000000a0
-#define PORT_FEATURE_BAR2_SIZE_64M                  0x000000b0
-#define PORT_FEATURE_BAR2_SIZE_128M                 0x000000c0
-#define PORT_FEATURE_BAR2_SIZE_256M                 0x000000d0
-#define PORT_FEATURE_BAR2_SIZE_512M                 0x000000e0
-#define PORT_FEATURE_BAR2_SIZE_1G                   0x000000f0
-#define PORT_FEATURE_EN_SIZE_MASK                   0x07000000
-#define PORT_FEATURE_EN_SIZE_SHIFT                  24
-#define PORT_FEATURE_WOL_ENABLED                    0x01000000
-#define PORT_FEATURE_MBA_ENABLED                    0x02000000
-#define PORT_FEATURE_MFW_ENABLED                    0x04000000
-
-        /* Reserved bits: 28-29 */
-        /*  Check the optic vendor via i2c against a list of approved modules
-          in a separate nvram image */
-#define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK                   0xE0000000
-#define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_SHIFT                  29
-#define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_NO_ENFORCEMENT         0x00000000
-#define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER       0x20000000
-#define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_WARNING_MSG            0x40000000
-#define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_POWER_DOWN             0x60000000
-
+        #define PORT_FEATURE_BAR1_SIZE_MASK                 0x0000000f
+                #define PORT_FEATURE_BAR1_SIZE_SHIFT                 0
+                #define PORT_FEATURE_BAR1_SIZE_DISABLED              0x00000000
+                #define PORT_FEATURE_BAR1_SIZE_64K                   0x00000001
+                #define PORT_FEATURE_BAR1_SIZE_128K                  0x00000002
+                #define PORT_FEATURE_BAR1_SIZE_256K                  0x00000003
+                #define PORT_FEATURE_BAR1_SIZE_512K                  0x00000004
+                #define PORT_FEATURE_BAR1_SIZE_1M                    0x00000005
+                #define PORT_FEATURE_BAR1_SIZE_2M                    0x00000006
+                #define PORT_FEATURE_BAR1_SIZE_4M                    0x00000007
+                #define PORT_FEATURE_BAR1_SIZE_8M                    0x00000008
+                #define PORT_FEATURE_BAR1_SIZE_16M                   0x00000009
+                #define PORT_FEATURE_BAR1_SIZE_32M                   0x0000000a
+                #define PORT_FEATURE_BAR1_SIZE_64M                   0x0000000b
+                #define PORT_FEATURE_BAR1_SIZE_128M                  0x0000000c
+                #define PORT_FEATURE_BAR1_SIZE_256M                  0x0000000d
+                #define PORT_FEATURE_BAR1_SIZE_512M                  0x0000000e
+                #define PORT_FEATURE_BAR1_SIZE_1G                    0x0000000f
+        #define PORT_FEATURE_BAR2_SIZE_MASK                 0x000000f0
+                #define PORT_FEATURE_BAR2_SIZE_SHIFT                 4
+                #define PORT_FEATURE_BAR2_SIZE_DISABLED              0x00000000
+                #define PORT_FEATURE_BAR2_SIZE_64K                   0x00000010
+                #define PORT_FEATURE_BAR2_SIZE_128K                  0x00000020
+                #define PORT_FEATURE_BAR2_SIZE_256K                  0x00000030
+                #define PORT_FEATURE_BAR2_SIZE_512K                  0x00000040
+                #define PORT_FEATURE_BAR2_SIZE_1M                    0x00000050
+                #define PORT_FEATURE_BAR2_SIZE_2M                    0x00000060
+                #define PORT_FEATURE_BAR2_SIZE_4M                    0x00000070
+                #define PORT_FEATURE_BAR2_SIZE_8M                    0x00000080
+                #define PORT_FEATURE_BAR2_SIZE_16M                   0x00000090
+                #define PORT_FEATURE_BAR2_SIZE_32M                   0x000000a0
+                #define PORT_FEATURE_BAR2_SIZE_64M                   0x000000b0
+                #define PORT_FEATURE_BAR2_SIZE_128M                  0x000000c0
+                #define PORT_FEATURE_BAR2_SIZE_256M                  0x000000d0
+                #define PORT_FEATURE_BAR2_SIZE_512M                  0x000000e0
+                #define PORT_FEATURE_BAR2_SIZE_1G                    0x000000f0
+
+        #define PORT_FEAT_CFG_DCBX_MASK                     0x00000100
+                #define PORT_FEAT_CFG_DCBX_DISABLED                  0x00000000
+                #define PORT_FEAT_CFG_DCBX_ENABLED                   0x00000100
+
+        #define PORT_FEAT_CFG_AUTOGREEN_MASK                0x00000200
+        #define PORT_FEAT_CFG_AUTOGREEN_SHIFT                        9
+        #define PORT_FEAT_CFG_AUTOGREEN_DISABLED                     0x00000000
+        #define PORT_FEAT_CFG_AUTOGREEN_ENABLED                      0x00000200
+
+        #define PORT_FEATURE_EN_SIZE_MASK                   0x0f000000
+        #define PORT_FEATURE_EN_SIZE_SHIFT                           24
+        #define PORT_FEATURE_WOL_ENABLED                             0x01000000
+        #define PORT_FEATURE_MBA_ENABLED                             0x02000000
+        #define PORT_FEATURE_MFW_ENABLED                             0x04000000
+
+        /* Advertise expansion ROM even if MBA is disabled */
+        #define PORT_FEAT_CFG_FORCE_EXP_ROM_ADV_MASK        0x08000000
+                #define PORT_FEAT_CFG_FORCE_EXP_ROM_ADV_DISABLED     0x00000000
+                #define PORT_FEAT_CFG_FORCE_EXP_ROM_ADV_ENABLED      0x08000000
+
+        /* Check the optic vendor via i2c against a list of approved modules
+           in a separate nvram image */
+        #define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK         0xe0000000
+                #define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_SHIFT         29
+                #define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_NO_ENFORCEMENT \
+                                                                     0x00000000
+                #define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER \
+                                                                     0x20000000
+                #define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_WARNING_MSG   0x40000000
+                #define PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_POWER_DOWN    0x60000000
 
         u32 wol_config;
         /* Default is used when driver sets to "auto" mode */
-#define PORT_FEATURE_WOL_DEFAULT_MASK               0x00000003
-#define PORT_FEATURE_WOL_DEFAULT_SHIFT              0
-#define PORT_FEATURE_WOL_DEFAULT_DISABLE            0x00000000
-#define PORT_FEATURE_WOL_DEFAULT_MAGIC              0x00000001
-#define PORT_FEATURE_WOL_DEFAULT_ACPI               0x00000002
-#define PORT_FEATURE_WOL_DEFAULT_MAGIC_AND_ACPI     0x00000003
-#define PORT_FEATURE_WOL_RES_PAUSE_CAP              0x00000004
-#define PORT_FEATURE_WOL_RES_ASYM_PAUSE_CAP         0x00000008
-#define PORT_FEATURE_WOL_ACPI_UPON_MGMT             0x00000010
+        #define PORT_FEATURE_WOL_DEFAULT_MASK               0x00000003
+                #define PORT_FEATURE_WOL_DEFAULT_SHIFT               0
+                #define PORT_FEATURE_WOL_DEFAULT_DISABLE             0x00000000
+                #define PORT_FEATURE_WOL_DEFAULT_MAGIC               0x00000001
+                #define PORT_FEATURE_WOL_DEFAULT_ACPI                0x00000002
+                #define PORT_FEATURE_WOL_DEFAULT_MAGIC_AND_ACPI      0x00000003
+        #define PORT_FEATURE_WOL_RES_PAUSE_CAP              0x00000004
+        #define PORT_FEATURE_WOL_RES_ASYM_PAUSE_CAP         0x00000008
+        #define PORT_FEATURE_WOL_ACPI_UPON_MGMT             0x00000010
 
         u32 mba_config;
-#define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_MASK       0x00000003
-#define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_SHIFT      0
-#define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_PXE        0x00000000
-#define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_RPL        0x00000001
-#define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_BOOTP      0x00000002
-#define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_ISCSIB     0x00000003
-#define PORT_FEATURE_MBA_RES_PAUSE_CAP              0x00000100
-#define PORT_FEATURE_MBA_RES_ASYM_PAUSE_CAP         0x00000200
-#define PORT_FEATURE_MBA_SETUP_PROMPT_ENABLE        0x00000400
-#define PORT_FEATURE_MBA_HOTKEY_CTRL_S              0x00000000
-#define PORT_FEATURE_MBA_HOTKEY_CTRL_B              0x00000800
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_MASK          0x000ff000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_SHIFT         12
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_DISABLED      0x00000000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_2K            0x00001000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_4K            0x00002000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_8K            0x00003000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_16K           0x00004000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_32K           0x00005000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_64K           0x00006000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_128K          0x00007000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_256K          0x00008000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_512K          0x00009000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_1M            0x0000a000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_2M            0x0000b000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_4M            0x0000c000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_8M            0x0000d000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_16M           0x0000e000
-#define PORT_FEATURE_MBA_EXP_ROM_SIZE_32M           0x0000f000
-#define PORT_FEATURE_MBA_MSG_TIMEOUT_MASK           0x00f00000
-#define PORT_FEATURE_MBA_MSG_TIMEOUT_SHIFT          20
-#define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_MASK        0x03000000
-#define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_SHIFT       24
-#define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_AUTO        0x00000000
-#define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_BBS         0x01000000
-#define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_INT18H      0x02000000
-#define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_INT19H      0x03000000
-#define PORT_FEATURE_MBA_LINK_SPEED_MASK            0x3c000000
-#define PORT_FEATURE_MBA_LINK_SPEED_SHIFT           26
-#define PORT_FEATURE_MBA_LINK_SPEED_AUTO            0x00000000
-#define PORT_FEATURE_MBA_LINK_SPEED_10HD            0x04000000
-#define PORT_FEATURE_MBA_LINK_SPEED_10FD            0x08000000
-#define PORT_FEATURE_MBA_LINK_SPEED_100HD           0x0c000000
-#define PORT_FEATURE_MBA_LINK_SPEED_100FD           0x10000000
-#define PORT_FEATURE_MBA_LINK_SPEED_1GBPS           0x14000000
-#define PORT_FEATURE_MBA_LINK_SPEED_2_5GBPS         0x18000000
-#define PORT_FEATURE_MBA_LINK_SPEED_10GBPS_CX4      0x1c000000
-#define PORT_FEATURE_MBA_LINK_SPEED_10GBPS_KX4      0x20000000
-#define PORT_FEATURE_MBA_LINK_SPEED_10GBPS_KR       0x24000000
-#define PORT_FEATURE_MBA_LINK_SPEED_12GBPS          0x28000000
-#define PORT_FEATURE_MBA_LINK_SPEED_12_5GBPS        0x2c000000
-#define PORT_FEATURE_MBA_LINK_SPEED_13GBPS          0x30000000
-#define PORT_FEATURE_MBA_LINK_SPEED_15GBPS          0x34000000
-#define PORT_FEATURE_MBA_LINK_SPEED_16GBPS          0x38000000
-
+        #define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_MASK       0x00000007
+                #define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_SHIFT       0
+                #define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_PXE         0x00000000
+                #define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_RPL         0x00000001
+                #define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_BOOTP       0x00000002
+                #define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_ISCSIB      0x00000003
+                #define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_FCOE_BOOT   0x00000004
+                #define PORT_FEATURE_MBA_BOOT_AGENT_TYPE_NONE        0x00000007
+
+        #define PORT_FEATURE_MBA_BOOT_RETRY_MASK            0x00000038
+        #define PORT_FEATURE_MBA_BOOT_RETRY_SHIFT                    3
+
+        #define PORT_FEATURE_MBA_RES_PAUSE_CAP              0x00000100
+        #define PORT_FEATURE_MBA_RES_ASYM_PAUSE_CAP         0x00000200
+        #define PORT_FEATURE_MBA_SETUP_PROMPT_ENABLE        0x00000400
+        #define PORT_FEATURE_MBA_HOTKEY_MASK                0x00000800
+                #define PORT_FEATURE_MBA_HOTKEY_CTRL_S               0x00000000
+                #define PORT_FEATURE_MBA_HOTKEY_CTRL_B               0x00000800
+        #define PORT_FEATURE_MBA_EXP_ROM_SIZE_MASK          0x000ff000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_SHIFT          12
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_DISABLED       0x00000000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_2K             0x00001000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_4K             0x00002000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_8K             0x00003000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_16K            0x00004000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_32K            0x00005000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_64K            0x00006000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_128K           0x00007000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_256K           0x00008000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_512K           0x00009000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_1M             0x0000a000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_2M             0x0000b000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_4M             0x0000c000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_8M             0x0000d000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_16M            0x0000e000
+                #define PORT_FEATURE_MBA_EXP_ROM_SIZE_32M            0x0000f000
+        #define PORT_FEATURE_MBA_MSG_TIMEOUT_MASK           0x00f00000
+        #define PORT_FEATURE_MBA_MSG_TIMEOUT_SHIFT                   20
+        #define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_MASK        0x03000000
+                #define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_SHIFT        24
+                #define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_AUTO         0x00000000
+                #define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_BBS          0x01000000
+                #define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_INT18H       0x02000000
+                #define PORT_FEATURE_MBA_BIOS_BOOTSTRAP_INT19H       0x03000000
+        #define PORT_FEATURE_MBA_LINK_SPEED_MASK            0x3c000000
+                #define PORT_FEATURE_MBA_LINK_SPEED_SHIFT            26
+                #define PORT_FEATURE_MBA_LINK_SPEED_AUTO             0x00000000
+                #define PORT_FEATURE_MBA_LINK_SPEED_10HD             0x04000000
+                #define PORT_FEATURE_MBA_LINK_SPEED_10FD             0x08000000
+                #define PORT_FEATURE_MBA_LINK_SPEED_100HD            0x0c000000
+                #define PORT_FEATURE_MBA_LINK_SPEED_100FD            0x10000000
+                #define PORT_FEATURE_MBA_LINK_SPEED_1GBPS            0x14000000
+                #define PORT_FEATURE_MBA_LINK_SPEED_2_5GBPS          0x18000000
+                #define PORT_FEATURE_MBA_LINK_SPEED_10GBPS_CX4       0x1c000000
+                #define PORT_FEATURE_MBA_LINK_SPEED_20GBPS           0x20000000
         u32 bmc_config;
-#define PORT_FEATURE_BMC_LINK_OVERRIDE_DEFAULT      0x00000000
-#define PORT_FEATURE_BMC_LINK_OVERRIDE_EN           0x00000001
+        #define PORT_FEATURE_BMC_LINK_OVERRIDE_MASK         0x00000001
+                #define PORT_FEATURE_BMC_LINK_OVERRIDE_DEFAULT       0x00000000
+                #define PORT_FEATURE_BMC_LINK_OVERRIDE_EN            0x00000001
 
         u32 mba_vlan_cfg;
-#define PORT_FEATURE_MBA_VLAN_TAG_MASK              0x0000ffff
-#define PORT_FEATURE_MBA_VLAN_TAG_SHIFT             0
-#define PORT_FEATURE_MBA_VLAN_EN                    0x00010000
+        #define PORT_FEATURE_MBA_VLAN_TAG_MASK              0x0000ffff
+        #define PORT_FEATURE_MBA_VLAN_TAG_SHIFT                      0
+        #define PORT_FEATURE_MBA_VLAN_EN                    0x00010000
 
         u32 resource_cfg;
-#define PORT_FEATURE_RESOURCE_CFG_VALID             0x00000001
-#define PORT_FEATURE_RESOURCE_CFG_DIAG              0x00000002
-#define PORT_FEATURE_RESOURCE_CFG_L2                0x00000004
-#define PORT_FEATURE_RESOURCE_CFG_ISCSI             0x00000008
-#define PORT_FEATURE_RESOURCE_CFG_RDMA              0x00000010
+        #define PORT_FEATURE_RESOURCE_CFG_VALID             0x00000001
+        #define PORT_FEATURE_RESOURCE_CFG_DIAG              0x00000002
+        #define PORT_FEATURE_RESOURCE_CFG_L2                0x00000004
+        #define PORT_FEATURE_RESOURCE_CFG_ISCSI             0x00000008
+        #define PORT_FEATURE_RESOURCE_CFG_RDMA              0x00000010
 
         u32 smbus_config;
-        /* Obsolete */
-#define PORT_FEATURE_SMBUS_EN                       0x00000001
-#define PORT_FEATURE_SMBUS_ADDR_MASK                0x000000fe
-#define PORT_FEATURE_SMBUS_ADDR_SHIFT               1
-
-        u32 reserved1;
+        #define PORT_FEATURE_SMBUS_ADDR_MASK                0x000000fe
+        #define PORT_FEATURE_SMBUS_ADDR_SHIFT                        1
+
+        u32 vf_config;
+        #define PORT_FEAT_CFG_VF_BAR2_SIZE_MASK             0x0000000f
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_SHIFT             0
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_DISABLED          0x00000000
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_4K                0x00000001
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_8K                0x00000002
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_16K               0x00000003
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_32K               0x00000004
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_64K               0x00000005
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_128K              0x00000006
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_256K              0x00000007
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_512K              0x00000008
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_1M                0x00000009
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_2M                0x0000000a
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_4M                0x0000000b
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_8M                0x0000000c
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_16M               0x0000000d
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_32M               0x0000000e
+                #define PORT_FEAT_CFG_VF_BAR2_SIZE_64M               0x0000000f
 
         u32 link_config;    /* Used as HW defaults for the driver */
-#define PORT_FEATURE_CONNECTED_SWITCH_MASK          0x03000000
-#define PORT_FEATURE_CONNECTED_SWITCH_SHIFT         24
-        /* (forced) low speed switch (< 10G) */
-#define PORT_FEATURE_CON_SWITCH_1G_SWITCH           0x00000000
-        /* (forced) high speed switch (>= 10G) */
-#define PORT_FEATURE_CON_SWITCH_10G_SWITCH          0x01000000
-#define PORT_FEATURE_CON_SWITCH_AUTO_DETECT         0x02000000
-#define PORT_FEATURE_CON_SWITCH_ONE_TIME_DETECT     0x03000000
-
-#define PORT_FEATURE_LINK_SPEED_MASK                0x000f0000
-#define PORT_FEATURE_LINK_SPEED_SHIFT               16
-#define PORT_FEATURE_LINK_SPEED_AUTO                0x00000000
-#define PORT_FEATURE_LINK_SPEED_10M_FULL            0x00010000
-#define PORT_FEATURE_LINK_SPEED_10M_HALF            0x00020000
-#define PORT_FEATURE_LINK_SPEED_100M_HALF           0x00030000
-#define PORT_FEATURE_LINK_SPEED_100M_FULL           0x00040000
-#define PORT_FEATURE_LINK_SPEED_1G                  0x00050000
-#define PORT_FEATURE_LINK_SPEED_2_5G                0x00060000
-#define PORT_FEATURE_LINK_SPEED_10G_CX4             0x00070000
-#define PORT_FEATURE_LINK_SPEED_10G_KX4             0x00080000
-#define PORT_FEATURE_LINK_SPEED_10G_KR              0x00090000
-#define PORT_FEATURE_LINK_SPEED_12G                 0x000a0000
-#define PORT_FEATURE_LINK_SPEED_12_5G               0x000b0000
-#define PORT_FEATURE_LINK_SPEED_13G                 0x000c0000
-#define PORT_FEATURE_LINK_SPEED_15G                 0x000d0000
-#define PORT_FEATURE_LINK_SPEED_16G                 0x000e0000
-
-#define PORT_FEATURE_FLOW_CONTROL_MASK              0x00000700
-#define PORT_FEATURE_FLOW_CONTROL_SHIFT             8
-#define PORT_FEATURE_FLOW_CONTROL_AUTO              0x00000000
-#define PORT_FEATURE_FLOW_CONTROL_TX                0x00000100
-#define PORT_FEATURE_FLOW_CONTROL_RX                0x00000200
-#define PORT_FEATURE_FLOW_CONTROL_BOTH              0x00000300
-#define PORT_FEATURE_FLOW_CONTROL_NONE              0x00000400
+        #define PORT_FEATURE_CONNECTED_SWITCH_MASK          0x03000000
+                #define PORT_FEATURE_CONNECTED_SWITCH_SHIFT          24
+                /* (forced) low speed switch (< 10G) */
+                #define PORT_FEATURE_CON_SWITCH_1G_SWITCH            0x00000000
+                /* (forced) high speed switch (>= 10G) */
+                #define PORT_FEATURE_CON_SWITCH_10G_SWITCH           0x01000000
+                #define PORT_FEATURE_CON_SWITCH_AUTO_DETECT          0x02000000
+                #define PORT_FEATURE_CON_SWITCH_ONE_TIME_DETECT      0x03000000
+
+        #define PORT_FEATURE_LINK_SPEED_MASK                0x000f0000
+                #define PORT_FEATURE_LINK_SPEED_SHIFT                16
+                #define PORT_FEATURE_LINK_SPEED_AUTO                 0x00000000
+                #define PORT_FEATURE_LINK_SPEED_10M_FULL             0x00010000
+                #define PORT_FEATURE_LINK_SPEED_10M_HALF             0x00020000
+                #define PORT_FEATURE_LINK_SPEED_100M_HALF            0x00030000
+                #define PORT_FEATURE_LINK_SPEED_100M_FULL            0x00040000
+                #define PORT_FEATURE_LINK_SPEED_1G                   0x00050000
+                #define PORT_FEATURE_LINK_SPEED_2_5G                 0x00060000
+                #define PORT_FEATURE_LINK_SPEED_10G_CX4              0x00070000
+                #define PORT_FEATURE_LINK_SPEED_20G                  0x00080000
+
+        #define PORT_FEATURE_FLOW_CONTROL_MASK              0x00000700
+                #define PORT_FEATURE_FLOW_CONTROL_SHIFT              8
+                #define PORT_FEATURE_FLOW_CONTROL_AUTO               0x00000000
+                #define PORT_FEATURE_FLOW_CONTROL_TX                 0x00000100
+                #define PORT_FEATURE_FLOW_CONTROL_RX                 0x00000200
+                #define PORT_FEATURE_FLOW_CONTROL_BOTH               0x00000300
+                #define PORT_FEATURE_FLOW_CONTROL_NONE               0x00000400
 
         /* The default for MCP link configuration,
-        uses the same defines as link_config */
+           uses the same defines as link_config */
         u32 mfw_wol_link_cfg;
+
         /* The default for the driver of the second external phy,
-        uses the same defines as link_config */
-        u32 link_config2;                                       /* 0x47C */
+           uses the same defines as link_config */
+        u32 link_config2;                                   /* 0x47C */
 
         /* The default for MCP of the second external phy,
-        uses the same defines as link_config */
-        u32 mfw_wol_link_cfg2;                          /* 0x480 */
+           uses the same defines as link_config */
+        u32 mfw_wol_link_cfg2;                              /* 0x480 */
 
-        u32 Reserved2[17];                                      /* 0x484 */
+        u32 Reserved2[17];                                  /* 0x484 */
 
 };
 
 
 /****************************************************************************
- * Device Information                                                       *
+ * Device Information                                                       *
  ****************************************************************************/
-struct shm_dev_info {                                               /* size */
+struct shm_dev_info {                           /* size */
 
         u32    bc_rev; /* 8 bits each: major, minor, build */          /* 4 */
 
-        struct shared_hw_cfg     shared_hw_config;                    /* 40 */
+        struct shared_hw_cfg     shared_hw_config;            /* 40 */
 
-        struct port_hw_cfg       port_hw_config[PORT_MAX];     /* 400*2=800 */
+        struct port_hw_cfg       port_hw_config[PORT_MAX];     /* 400*2=800 */
 
-        struct shared_feat_cfg   shared_feature_config;                /* 4 */
+        struct shared_feat_cfg   shared_feature_config;            /* 4 */
 
-        struct port_feat_cfg     port_feature_config[PORT_MAX];/* 116*2=232 */
+        struct port_feat_cfg     port_feature_config[PORT_MAX];/* 116*2=232 */
 
 };
 
 
-#define FUNC_0                          0
-#define FUNC_1                          1
-#define FUNC_2                          2
-#define FUNC_3                          3
-#define FUNC_4                          4
-#define FUNC_5                          5
-#define FUNC_6                          6
-#define FUNC_7                          7
-#define E1_FUNC_MAX                     2
-#define E1H_FUNC_MAX                    8
-#define E2_FUNC_MAX         4   /* per path */
-
-#define VN_0                            0
-#define VN_1                            1
-#define VN_2                            2
-#define VN_3                            3
-#define E1VN_MAX                        1
-#define E1HVN_MAX                       4
+#if !defined(__LITTLE_ENDIAN) && !defined(__BIG_ENDIAN)
+        #error "Missing either LITTLE_ENDIAN or BIG_ENDIAN definition."
+#endif
 
-#define E2_VF_MAX                       64
+#define FUNC_0              0
+#define FUNC_1              1
+#define FUNC_2              2
+#define FUNC_3              3
+#define FUNC_4              4
+#define FUNC_5              5
+#define FUNC_6              6
+#define FUNC_7              7
+#define E1_FUNC_MAX         2
+#define E1H_FUNC_MAX            8
+#define E2_FUNC_MAX         4   /* per path */
+
+#define VN_0                0
+#define VN_1                1
+#define VN_2                2
+#define VN_3                3
+#define E1VN_MAX            1
+#define E1HVN_MAX           4
+
+#define E2_VF_MAX           64  /* HC_REG_VF_CONFIGURATION_SIZE */
 /* This value (in milliseconds) determines the frequency of the driver
  * issuing the PULSE message code.  The firmware monitors this periodic
  * pulse to determine when to switch to an OS-absent mode. */
-#define DRV_PULSE_PERIOD_MS             250
+#define DRV_PULSE_PERIOD_MS     250
 
 /* This value (in milliseconds) determines how long the driver should
  * wait for an acknowledgement from the firmware before timing out.  Once
  * the firmware has timed out, the driver will assume there is no firmware
  * running and there won't be any firmware-driver synchronization during a
  * driver reset. */
-#define FW_ACK_TIME_OUT_MS              5000
+#define FW_ACK_TIME_OUT_MS      5000
 
-#define FW_ACK_POLL_TIME_MS             1
+#define FW_ACK_POLL_TIME_MS     1
 
-#define FW_ACK_NUM_OF_POLL      (FW_ACK_TIME_OUT_MS/FW_ACK_POLL_TIME_MS)
+#define FW_ACK_NUM_OF_POLL  (FW_ACK_TIME_OUT_MS/FW_ACK_POLL_TIME_MS)
 
 /* LED Blink rate that will achieve ~15.9Hz */
-#define LED_BLINK_RATE_VAL              480
+#define LED_BLINK_RATE_VAL      480
 
 /****************************************************************************
- * Driver <-> FW Mailbox                                                    *
+ * Driver <-> FW Mailbox                                                    *
  ****************************************************************************/
 struct drv_port_mb {
 
         u32 link_status;
         /* Driver should update this field on any link change event */
 
-#define LINK_STATUS_LINK_FLAG_MASK                      0x00000001
-#define LINK_STATUS_LINK_UP                             0x00000001
-#define LINK_STATUS_SPEED_AND_DUPLEX_MASK               0x0000001E
-#define LINK_STATUS_SPEED_AND_DUPLEX_AN_NOT_COMPLETE    (0<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_10THD              (1<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_10TFD              (2<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_100TXHD            (3<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_100T4              (4<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_100TXFD            (5<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_1000THD            (6<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_1000TFD            (7<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_1000XFD            (7<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_2500THD            (8<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_2500TFD            (9<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_2500XFD            (9<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_10GTFD             (10<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_10GXFD             (10<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_12GTFD             (11<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_12GXFD             (11<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_12_5GTFD           (12<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_12_5GXFD           (12<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_13GTFD             (13<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_13GXFD             (13<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_15GTFD             (14<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_15GXFD             (14<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_16GTFD             (15<<1)
-#define LINK_STATUS_SPEED_AND_DUPLEX_16GXFD             (15<<1)
-
-#define LINK_STATUS_AUTO_NEGOTIATE_FLAG_MASK            0x00000020
-#define LINK_STATUS_AUTO_NEGOTIATE_ENABLED              0x00000020
-
-#define LINK_STATUS_AUTO_NEGOTIATE_COMPLETE             0x00000040
-#define LINK_STATUS_PARALLEL_DETECTION_FLAG_MASK        0x00000080
-#define LINK_STATUS_PARALLEL_DETECTION_USED             0x00000080
-
-#define LINK_STATUS_LINK_PARTNER_1000TFD_CAPABLE        0x00000200
-#define LINK_STATUS_LINK_PARTNER_1000THD_CAPABLE        0x00000400
-#define LINK_STATUS_LINK_PARTNER_100T4_CAPABLE          0x00000800
-#define LINK_STATUS_LINK_PARTNER_100TXFD_CAPABLE        0x00001000
-#define LINK_STATUS_LINK_PARTNER_100TXHD_CAPABLE        0x00002000
-#define LINK_STATUS_LINK_PARTNER_10TFD_CAPABLE          0x00004000
-#define LINK_STATUS_LINK_PARTNER_10THD_CAPABLE          0x00008000
-
-#define LINK_STATUS_TX_FLOW_CONTROL_FLAG_MASK           0x00010000
-#define LINK_STATUS_TX_FLOW_CONTROL_ENABLED             0x00010000
-
-#define LINK_STATUS_RX_FLOW_CONTROL_FLAG_MASK           0x00020000
-#define LINK_STATUS_RX_FLOW_CONTROL_ENABLED             0x00020000
-
-#define LINK_STATUS_LINK_PARTNER_FLOW_CONTROL_MASK      0x000C0000
-#define LINK_STATUS_LINK_PARTNER_NOT_PAUSE_CAPABLE      (0<<18)
-#define LINK_STATUS_LINK_PARTNER_SYMMETRIC_PAUSE        (1<<18)
-#define LINK_STATUS_LINK_PARTNER_ASYMMETRIC_PAUSE       (2<<18)
-#define LINK_STATUS_LINK_PARTNER_BOTH_PAUSE             (3<<18)
-
-#define LINK_STATUS_SERDES_LINK                         0x00100000
-
-#define LINK_STATUS_LINK_PARTNER_2500XFD_CAPABLE        0x00200000
-#define LINK_STATUS_LINK_PARTNER_2500XHD_CAPABLE        0x00400000
-#define LINK_STATUS_LINK_PARTNER_10GXFD_CAPABLE         0x00800000
-#define LINK_STATUS_LINK_PARTNER_12GXFD_CAPABLE         0x01000000
-#define LINK_STATUS_LINK_PARTNER_12_5GXFD_CAPABLE       0x02000000
-#define LINK_STATUS_LINK_PARTNER_13GXFD_CAPABLE         0x04000000
-#define LINK_STATUS_LINK_PARTNER_15GXFD_CAPABLE         0x08000000
-#define LINK_STATUS_LINK_PARTNER_16GXFD_CAPABLE         0x10000000
+        #define LINK_STATUS_LINK_FLAG_MASK                      0x00000001
+        #define LINK_STATUS_LINK_UP                             0x00000001
+        #define LINK_STATUS_SPEED_AND_DUPLEX_MASK               0x0000001E
+        #define LINK_STATUS_SPEED_AND_DUPLEX_AN_NOT_COMPLETE    (0<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_10THD              (1<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_10TFD              (2<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_100TXHD            (3<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_100T4              (4<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_100TXFD            (5<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_1000THD            (6<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_1000TFD            (7<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_1000XFD            (7<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_2500THD            (8<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_2500TFD            (9<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_2500XFD            (9<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_10GTFD             (10<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_10GXFD             (10<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_20GTFD             (11<<1)
+        #define LINK_STATUS_SPEED_AND_DUPLEX_20GXFD             (11<<1)
+
+        #define LINK_STATUS_AUTO_NEGOTIATE_FLAG_MASK            0x00000020
+        #define LINK_STATUS_AUTO_NEGOTIATE_ENABLED              0x00000020
+
+        #define LINK_STATUS_AUTO_NEGOTIATE_COMPLETE             0x00000040
+        #define LINK_STATUS_PARALLEL_DETECTION_FLAG_MASK        0x00000080
+        #define LINK_STATUS_PARALLEL_DETECTION_USED             0x00000080
+
+        #define LINK_STATUS_LINK_PARTNER_1000TFD_CAPABLE        0x00000200
+        #define LINK_STATUS_LINK_PARTNER_1000THD_CAPABLE        0x00000400
+        #define LINK_STATUS_LINK_PARTNER_100T4_CAPABLE          0x00000800
+        #define LINK_STATUS_LINK_PARTNER_100TXFD_CAPABLE        0x00001000
+        #define LINK_STATUS_LINK_PARTNER_100TXHD_CAPABLE        0x00002000
+        #define LINK_STATUS_LINK_PARTNER_10TFD_CAPABLE          0x00004000
+        #define LINK_STATUS_LINK_PARTNER_10THD_CAPABLE          0x00008000
+
+        #define LINK_STATUS_TX_FLOW_CONTROL_FLAG_MASK           0x00010000
+        #define LINK_STATUS_TX_FLOW_CONTROL_ENABLED             0x00010000
+
+        #define LINK_STATUS_RX_FLOW_CONTROL_FLAG_MASK           0x00020000
+        #define LINK_STATUS_RX_FLOW_CONTROL_ENABLED             0x00020000
+
+        #define LINK_STATUS_LINK_PARTNER_FLOW_CONTROL_MASK      0x000C0000
+        #define LINK_STATUS_LINK_PARTNER_NOT_PAUSE_CAPABLE      (0<<18)
+        #define LINK_STATUS_LINK_PARTNER_SYMMETRIC_PAUSE        (1<<18)
+        #define LINK_STATUS_LINK_PARTNER_ASYMMETRIC_PAUSE       (2<<18)
+        #define LINK_STATUS_LINK_PARTNER_BOTH_PAUSE             (3<<18)
+
+        #define LINK_STATUS_SERDES_LINK                         0x00100000
+
+        #define LINK_STATUS_LINK_PARTNER_2500XFD_CAPABLE        0x00200000
+        #define LINK_STATUS_LINK_PARTNER_2500XHD_CAPABLE        0x00400000
+        #define LINK_STATUS_LINK_PARTNER_10GXFD_CAPABLE         0x00800000
+        #define LINK_STATUS_LINK_PARTNER_20GXFD_CAPABLE         0x10000000
 
         u32 port_stx;
 
@@ -903,138 +1209,158 @@ struct drv_port_mb {
 struct drv_func_mb {
 
         u32 drv_mb_header;
-#define DRV_MSG_CODE_MASK                               0xffff0000
-#define DRV_MSG_CODE_LOAD_REQ                           0x10000000
-#define DRV_MSG_CODE_LOAD_DONE                          0x11000000
-#define DRV_MSG_CODE_UNLOAD_REQ_WOL_EN                  0x20000000
-#define DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS                 0x20010000
-#define DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP                 0x20020000
-#define DRV_MSG_CODE_UNLOAD_DONE                        0x21000000
-#define DRV_MSG_CODE_DCC_OK                             0x30000000
-#define DRV_MSG_CODE_DCC_FAILURE                        0x31000000
-#define DRV_MSG_CODE_DIAG_ENTER_REQ                     0x50000000
-#define DRV_MSG_CODE_DIAG_EXIT_REQ                      0x60000000
-#define DRV_MSG_CODE_VALIDATE_KEY                       0x70000000
-#define DRV_MSG_CODE_GET_CURR_KEY                       0x80000000
-#define DRV_MSG_CODE_GET_UPGRADE_KEY                    0x81000000
-#define DRV_MSG_CODE_GET_MANUF_KEY                      0x82000000
-#define DRV_MSG_CODE_LOAD_L2B_PRAM                      0x90000000
-        /*
-         * The optic module verification commands require bootcode
-         * v5.0.6 or later
-         */
-#define DRV_MSG_CODE_VRFY_FIRST_PHY_OPT_MDL     0xa0000000
-#define REQ_BC_VER_4_VRFY_FIRST_PHY_OPT_MDL     0x00050006
+        #define DRV_MSG_CODE_MASK                       0xffff0000
+        #define DRV_MSG_CODE_LOAD_REQ                   0x10000000
+        #define DRV_MSG_CODE_LOAD_DONE                  0x11000000
+        #define DRV_MSG_CODE_UNLOAD_REQ_WOL_EN          0x20000000
+        #define DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS         0x20010000
+        #define DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP         0x20020000
+        #define DRV_MSG_CODE_UNLOAD_DONE                0x21000000
+        #define DRV_MSG_CODE_DCC_OK                     0x30000000
+        #define DRV_MSG_CODE_DCC_FAILURE                0x31000000
+        #define DRV_MSG_CODE_DIAG_ENTER_REQ             0x50000000
+        #define DRV_MSG_CODE_DIAG_EXIT_REQ              0x60000000
+        #define DRV_MSG_CODE_VALIDATE_KEY               0x70000000
+        #define DRV_MSG_CODE_GET_CURR_KEY               0x80000000
+        #define DRV_MSG_CODE_GET_UPGRADE_KEY            0x81000000
+        #define DRV_MSG_CODE_GET_MANUF_KEY              0x82000000
+        #define DRV_MSG_CODE_LOAD_L2B_PRAM              0x90000000
         /*
-         * The specific optic module verification command requires bootcode
-         * v5.2.12 or later
+         * The optic module verification command requires bootcode
+         * v5.0.6 or later, te specific optic module verification command
+         * requires bootcode v5.2.12 or later
          */
-#define DRV_MSG_CODE_VRFY_SPECIFIC_PHY_OPT_MDL      0xa1000000
-#define REQ_BC_VER_4_VRFY_SPECIFIC_PHY_OPT_MDL      0x00050234
+        #define DRV_MSG_CODE_VRFY_FIRST_PHY_OPT_MDL     0xa0000000
+        #define REQ_BC_VER_4_VRFY_FIRST_PHY_OPT_MDL     0x00050006
+        #define DRV_MSG_CODE_VRFY_SPECIFIC_PHY_OPT_MDL  0xa1000000
+        #define REQ_BC_VER_4_VRFY_SPECIFIC_PHY_OPT_MDL  0x00050234
 
-#define DRV_MSG_CODE_DCBX_ADMIN_PMF_MSG                 0xb0000000
-#define DRV_MSG_CODE_DCBX_PMF_DRV_OK                    0xb2000000
-#define DRV_MSG_CODE_SET_MF_BW                          0xe0000000
-#define REQ_BC_VER_4_SET_MF_BW                          0x00060202
-#define DRV_MSG_CODE_SET_MF_BW_ACK                      0xe1000000
-#define BIOS_MSG_CODE_LIC_CHALLENGE                     0xff010000
-#define BIOS_MSG_CODE_LIC_RESPONSE                      0xff020000
-#define BIOS_MSG_CODE_VIRT_MAC_PRIM                     0xff030000
-#define BIOS_MSG_CODE_VIRT_MAC_ISCSI                    0xff040000
+        #define DRV_MSG_CODE_DCBX_ADMIN_PMF_MSG         0xb0000000
+        #define DRV_MSG_CODE_DCBX_PMF_DRV_OK            0xb2000000
 
-#define DRV_MSG_SEQ_NUMBER_MASK                         0x0000ffff
+        #define DRV_MSG_CODE_VF_DISABLED_DONE           0xc0000000
+
+        #define DRV_MSG_CODE_SET_MF_BW                  0xe0000000
+        #define REQ_BC_VER_4_SET_MF_BW                  0x00060202
+        #define DRV_MSG_CODE_SET_MF_BW_ACK              0xe1000000
+
+        #define DRV_MSG_CODE_LINK_STATUS_CHANGED        0x01000000
+
+        #define BIOS_MSG_CODE_LIC_CHALLENGE             0xff010000
+        #define BIOS_MSG_CODE_LIC_RESPONSE              0xff020000
+        #define BIOS_MSG_CODE_VIRT_MAC_PRIM             0xff030000
+        #define BIOS_MSG_CODE_VIRT_MAC_ISCSI            0xff040000
+
+        #define DRV_MSG_SEQ_NUMBER_MASK                 0x0000ffff
 
         u32 drv_mb_param;
+        #define DRV_MSG_CODE_SET_MF_BW_MIN_MASK         0x00ff0000
+        #define DRV_MSG_CODE_SET_MF_BW_MAX_MASK         0xff000000
 
         u32 fw_mb_header;
-#define FW_MSG_CODE_MASK                                0xffff0000
-#define FW_MSG_CODE_DRV_LOAD_COMMON                     0x10100000
-#define FW_MSG_CODE_DRV_LOAD_PORT                       0x10110000
-#define FW_MSG_CODE_DRV_LOAD_FUNCTION                   0x10120000
-        /* Load common chip is supported from bc 6.0.0  */
-#define REQ_BC_VER_4_DRV_LOAD_COMMON_CHIP       0x00060000
-#define FW_MSG_CODE_DRV_LOAD_COMMON_CHIP        0x10130000
-#define FW_MSG_CODE_DRV_LOAD_REFUSED                    0x10200000
-#define FW_MSG_CODE_DRV_LOAD_DONE                       0x11100000
-#define FW_MSG_CODE_DRV_UNLOAD_COMMON                   0x20100000
-#define FW_MSG_CODE_DRV_UNLOAD_PORT                     0x20110000
-#define FW_MSG_CODE_DRV_UNLOAD_FUNCTION                 0x20120000
-#define FW_MSG_CODE_DRV_UNLOAD_DONE                     0x21100000
-#define FW_MSG_CODE_DCC_DONE                            0x30100000
-#define FW_MSG_CODE_DIAG_ENTER_DONE                     0x50100000
-#define FW_MSG_CODE_DIAG_REFUSE                         0x50200000
-#define FW_MSG_CODE_DIAG_EXIT_DONE                      0x60100000
-#define FW_MSG_CODE_VALIDATE_KEY_SUCCESS                0x70100000
-#define FW_MSG_CODE_VALIDATE_KEY_FAILURE                0x70200000
-#define FW_MSG_CODE_GET_KEY_DONE                        0x80100000
-#define FW_MSG_CODE_NO_KEY                              0x80f00000
-#define FW_MSG_CODE_LIC_INFO_NOT_READY                  0x80f80000
-#define FW_MSG_CODE_L2B_PRAM_LOADED                     0x90100000
-#define FW_MSG_CODE_L2B_PRAM_T_LOAD_FAILURE             0x90210000
-#define FW_MSG_CODE_L2B_PRAM_C_LOAD_FAILURE             0x90220000
-#define FW_MSG_CODE_L2B_PRAM_X_LOAD_FAILURE             0x90230000
-#define FW_MSG_CODE_L2B_PRAM_U_LOAD_FAILURE             0x90240000
-#define FW_MSG_CODE_VRFY_OPT_MDL_SUCCESS                0xa0100000
-#define FW_MSG_CODE_VRFY_OPT_MDL_INVLD_IMG              0xa0200000
-#define FW_MSG_CODE_VRFY_OPT_MDL_UNAPPROVED             0xa0300000
-
-#define FW_MSG_CODE_LIC_CHALLENGE                       0xff010000
-#define FW_MSG_CODE_LIC_RESPONSE                        0xff020000
-#define FW_MSG_CODE_VIRT_MAC_PRIM                       0xff030000
-#define FW_MSG_CODE_VIRT_MAC_ISCSI                      0xff040000
-
-#define FW_MSG_SEQ_NUMBER_MASK                          0x0000ffff
+        #define FW_MSG_CODE_MASK                        0xffff0000
+        #define FW_MSG_CODE_DRV_LOAD_COMMON             0x10100000
+        #define FW_MSG_CODE_DRV_LOAD_PORT               0x10110000
+        #define FW_MSG_CODE_DRV_LOAD_FUNCTION           0x10120000
+        /* Load common chip is supported from bc 6.0.0  */
+        #define REQ_BC_VER_4_DRV_LOAD_COMMON_CHIP       0x00060000
+        #define FW_MSG_CODE_DRV_LOAD_COMMON_CHIP        0x10130000
+
+        #define FW_MSG_CODE_DRV_LOAD_REFUSED            0x10200000
+        #define FW_MSG_CODE_DRV_LOAD_DONE               0x11100000
+        #define FW_MSG_CODE_DRV_UNLOAD_COMMON           0x20100000
+        #define FW_MSG_CODE_DRV_UNLOAD_PORT             0x20110000
+        #define FW_MSG_CODE_DRV_UNLOAD_FUNCTION         0x20120000
+        #define FW_MSG_CODE_DRV_UNLOAD_DONE             0x21100000
+        #define FW_MSG_CODE_DCC_DONE                    0x30100000
+        #define FW_MSG_CODE_LLDP_DONE                   0x40100000
+        #define FW_MSG_CODE_DIAG_ENTER_DONE             0x50100000
+        #define FW_MSG_CODE_DIAG_REFUSE                 0x50200000
+        #define FW_MSG_CODE_DIAG_EXIT_DONE              0x60100000
+        #define FW_MSG_CODE_VALIDATE_KEY_SUCCESS        0x70100000
+        #define FW_MSG_CODE_VALIDATE_KEY_FAILURE        0x70200000
+        #define FW_MSG_CODE_GET_KEY_DONE                0x80100000
+        #define FW_MSG_CODE_NO_KEY                      0x80f00000
+        #define FW_MSG_CODE_LIC_INFO_NOT_READY          0x80f80000
+        #define FW_MSG_CODE_L2B_PRAM_LOADED             0x90100000
+        #define FW_MSG_CODE_L2B_PRAM_T_LOAD_FAILURE     0x90210000
+        #define FW_MSG_CODE_L2B_PRAM_C_LOAD_FAILURE     0x90220000
+        #define FW_MSG_CODE_L2B_PRAM_X_LOAD_FAILURE     0x90230000
+        #define FW_MSG_CODE_L2B_PRAM_U_LOAD_FAILURE     0x90240000
+        #define FW_MSG_CODE_VRFY_OPT_MDL_SUCCESS        0xa0100000
+        #define FW_MSG_CODE_VRFY_OPT_MDL_INVLD_IMG      0xa0200000
+        #define FW_MSG_CODE_VRFY_OPT_MDL_UNAPPROVED     0xa0300000
+        #define FW_MSG_CODE_VF_DISABLED_DONE            0xb0000000
+
+        #define FW_MSG_CODE_SET_MF_BW_SENT              0xe0000000
+        #define FW_MSG_CODE_SET_MF_BW_DONE              0xe1000000
+
+        #define FW_MSG_CODE_LINK_CHANGED_ACK            0x01100000
+
+        #define FW_MSG_CODE_LIC_CHALLENGE               0xff010000
+        #define FW_MSG_CODE_LIC_RESPONSE                0xff020000
+        #define FW_MSG_CODE_VIRT_MAC_PRIM               0xff030000
+        #define FW_MSG_CODE_VIRT_MAC_ISCSI              0xff040000
+
+        #define FW_MSG_SEQ_NUMBER_MASK                  0x0000ffff
 
         u32 fw_mb_param;
 
         u32 drv_pulse_mb;
-#define DRV_PULSE_SEQ_MASK                              0x00007fff
-#define DRV_PULSE_SYSTEM_TIME_MASK                      0xffff0000
-        /* The system time is in the format of
-         * (year-2001)*12*32 + month*32 + day. */
-#define DRV_PULSE_ALWAYS_ALIVE                          0x00008000
-        /* Indicate to the firmware not to go into the
+        #define DRV_PULSE_SEQ_MASK                      0x00007fff
+        #define DRV_PULSE_SYSTEM_TIME_MASK              0xffff0000
+        /*
+         * The system time is in the format of
+         * (year-2001)*12*32 + month*32 + day.
+         */
+        #define DRV_PULSE_ALWAYS_ALIVE                  0x00008000
+        /*
+         * Indicate to the firmware not to go into the
          * OS-absent when it is not getting driver pulse.
-         * This is used for debugging as well for PXE(MBA). */
+         * This is used for debugging as well for PXE(MBA).
+         */
 
         u32 mcp_pulse_mb;
-#define MCP_PULSE_SEQ_MASK                              0x00007fff
-#define MCP_PULSE_ALWAYS_ALIVE                          0x00008000
+        #define MCP_PULSE_SEQ_MASK                      0x00007fff
+        #define MCP_PULSE_ALWAYS_ALIVE                  0x00008000
         /* Indicates to the driver not to assert due to lack
          * of MCP response */
-#define MCP_EVENT_MASK                                  0xffff0000
-#define MCP_EVENT_OTHER_DRIVER_RESET_REQ                0x00010000
+        #define MCP_EVENT_MASK                          0xffff0000
+        #define MCP_EVENT_OTHER_DRIVER_RESET_REQ        0x00010000
 
         u32 iscsi_boot_signature;
         u32 iscsi_boot_block_offset;
 
         u32 drv_status;
-#define DRV_STATUS_PMF                                  0x00000001
-#define DRV_STATUS_SET_MF_BW                            0x00000004
-
-#define DRV_STATUS_DCC_EVENT_MASK                       0x0000ff00
-#define DRV_STATUS_DCC_DISABLE_ENABLE_PF                0x00000100
-#define DRV_STATUS_DCC_BANDWIDTH_ALLOCATION             0x00000200
-#define DRV_STATUS_DCC_CHANGE_MAC_ADDRESS               0x00000400
-#define DRV_STATUS_DCC_RESERVED1                        0x00000800
-#define DRV_STATUS_DCC_SET_PROTOCOL                     0x00001000
-#define DRV_STATUS_DCC_SET_PRIORITY                     0x00002000
-#define DRV_STATUS_DCBX_EVENT_MASK                      0x000f0000
-#define DRV_STATUS_DCBX_NEGOTIATION_RESULTS             0x00010000
+        #define DRV_STATUS_PMF                          0x00000001
+        #define DRV_STATUS_VF_DISABLED                  0x00000002
+        #define DRV_STATUS_SET_MF_BW                    0x00000004
+        #define DRV_STATUS_LINK_EVENT                   0x00000008
+
+        #define DRV_STATUS_DCC_EVENT_MASK               0x0000ff00
+        #define DRV_STATUS_DCC_DISABLE_ENABLE_PF        0x00000100
+        #define DRV_STATUS_DCC_BANDWIDTH_ALLOCATION     0x00000200
+        #define DRV_STATUS_DCC_CHANGE_MAC_ADDRESS       0x00000400
+        #define DRV_STATUS_DCC_RESERVED1                0x00000800
+        #define DRV_STATUS_DCC_SET_PROTOCOL             0x00001000
+        #define DRV_STATUS_DCC_SET_PRIORITY             0x00002000
+
+        #define DRV_STATUS_DCBX_EVENT_MASK              0x000f0000
+        #define DRV_STATUS_DCBX_NEGOTIATION_RESULTS     0x00010000
 
         u32 virt_mac_upper;
-#define VIRT_MAC_SIGN_MASK                              0xffff0000
-#define VIRT_MAC_SIGNATURE                              0x564d0000
+        #define VIRT_MAC_SIGN_MASK                      0xffff0000
+        #define VIRT_MAC_SIGNATURE                      0x564d0000
         u32 virt_mac_lower;
 
 };
 
 
 /****************************************************************************
- * Management firmware state                                                *
+ * Management firmware state                                                *
  ****************************************************************************/
 /* Allocate 440 bytes for management firmware */
-#define MGMTFW_STATE_WORD_SIZE                              110
+#define MGMTFW_STATE_WORD_SIZE                          110
 
 struct mgmtfw_state {
         u32 opaque[MGMTFW_STATE_WORD_SIZE];
@@ -1042,25 +1368,25 @@ struct mgmtfw_state {
 
 
 /****************************************************************************
- * Multi-Function configuration                                             *
+ * Multi-Function configuration                                             *
  ****************************************************************************/
 struct shared_mf_cfg {
 
         u32 clp_mb;
-#define SHARED_MF_CLP_SET_DEFAULT                   0x00000000
+        #define SHARED_MF_CLP_SET_DEFAULT               0x00000000
         /* set by CLP */
-#define SHARED_MF_CLP_EXIT                          0x00000001
+        #define SHARED_MF_CLP_EXIT                      0x00000001
         /* set by MCP */
-#define SHARED_MF_CLP_EXIT_DONE                     0x00010000
+        #define SHARED_MF_CLP_EXIT_DONE                 0x00010000
 
 };
 
 struct port_mf_cfg {
 
-        u32 dynamic_cfg;        /* device control channel */
-#define PORT_MF_CFG_E1HOV_TAG_MASK                  0x0000ffff
-#define PORT_MF_CFG_E1HOV_TAG_SHIFT                 0
-#define PORT_MF_CFG_E1HOV_TAG_DEFAULT               PORT_MF_CFG_E1HOV_TAG_MASK
+        u32 dynamic_cfg;    /* device control channel */
+        #define PORT_MF_CFG_E1HOV_TAG_MASK              0x0000ffff
+        #define PORT_MF_CFG_E1HOV_TAG_SHIFT             0
+        #define PORT_MF_CFG_E1HOV_TAG_DEFAULT         PORT_MF_CFG_E1HOV_TAG_MASK
 
         u32 reserved[3];
 
@@ -1071,57 +1397,58 @@ struct func_mf_cfg {
         u32 config;
         /* E/R/I/D */
         /* function 0 of each port cannot be hidden */
-#define FUNC_MF_CFG_FUNC_HIDE                       0x00000001
+        #define FUNC_MF_CFG_FUNC_HIDE                   0x00000001
 
-#define FUNC_MF_CFG_PROTOCOL_MASK                   0x00000007
-#define FUNC_MF_CFG_PROTOCOL_ETHERNET               0x00000002
-#define FUNC_MF_CFG_PROTOCOL_ETHERNET_WITH_RDMA     0x00000004
-#define FUNC_MF_CFG_PROTOCOL_ISCSI                  0x00000006
-#define FUNC_MF_CFG_PROTOCOL_DEFAULT\
-        FUNC_MF_CFG_PROTOCOL_ETHERNET_WITH_RDMA
+        #define FUNC_MF_CFG_PROTOCOL_MASK               0x00000006
+        #define FUNC_MF_CFG_PROTOCOL_FCOE               0x00000000
+        #define FUNC_MF_CFG_PROTOCOL_ETHERNET           0x00000002
+        #define FUNC_MF_CFG_PROTOCOL_ETHERNET_WITH_RDMA 0x00000004
+        #define FUNC_MF_CFG_PROTOCOL_ISCSI              0x00000006
+        #define FUNC_MF_CFG_PROTOCOL_DEFAULT \
+                                FUNC_MF_CFG_PROTOCOL_ETHERNET_WITH_RDMA
 
-#define FUNC_MF_CFG_FUNC_DISABLED                   0x00000008
+        #define FUNC_MF_CFG_FUNC_DISABLED               0x00000008
+        #define FUNC_MF_CFG_FUNC_DELETED                0x00000010
 
         /* PRI */
         /* 0 - low priority, 3 - high priority */
-#define FUNC_MF_CFG_TRANSMIT_PRIORITY_MASK          0x00000300
-#define FUNC_MF_CFG_TRANSMIT_PRIORITY_SHIFT         8
-#define FUNC_MF_CFG_TRANSMIT_PRIORITY_DEFAULT       0x00000000
+        #define FUNC_MF_CFG_TRANSMIT_PRIORITY_MASK      0x00000300
+        #define FUNC_MF_CFG_TRANSMIT_PRIORITY_SHIFT     8
+        #define FUNC_MF_CFG_TRANSMIT_PRIORITY_DEFAULT   0x00000000
 
         /* MINBW, MAXBW */
         /* value range - 0..100, increments in 100Mbps */
-#define FUNC_MF_CFG_MIN_BW_MASK                     0x00ff0000
-#define FUNC_MF_CFG_MIN_BW_SHIFT                    16
-#define FUNC_MF_CFG_MIN_BW_DEFAULT                  0x00000000
-#define FUNC_MF_CFG_MAX_BW_MASK                     0xff000000
-#define FUNC_MF_CFG_MAX_BW_SHIFT                    24
-#define FUNC_MF_CFG_MAX_BW_DEFAULT                  0x64000000
-
-        u32 mac_upper;          /* MAC */
-#define FUNC_MF_CFG_UPPERMAC_MASK                   0x0000ffff
-#define FUNC_MF_CFG_UPPERMAC_SHIFT                  0
-#define FUNC_MF_CFG_UPPERMAC_DEFAULT                FUNC_MF_CFG_UPPERMAC_MASK
+        #define FUNC_MF_CFG_MIN_BW_MASK                 0x00ff0000
+        #define FUNC_MF_CFG_MIN_BW_SHIFT                16
+        #define FUNC_MF_CFG_MIN_BW_DEFAULT              0x00000000
+        #define FUNC_MF_CFG_MAX_BW_MASK                 0xff000000
+        #define FUNC_MF_CFG_MAX_BW_SHIFT                24
+        #define FUNC_MF_CFG_MAX_BW_DEFAULT              0x64000000
+
+        u32 mac_upper;      /* MAC */
+        #define FUNC_MF_CFG_UPPERMAC_MASK               0x0000ffff
+        #define FUNC_MF_CFG_UPPERMAC_SHIFT              0
+        #define FUNC_MF_CFG_UPPERMAC_DEFAULT           FUNC_MF_CFG_UPPERMAC_MASK
         u32 mac_lower;
-#define FUNC_MF_CFG_LOWERMAC_DEFAULT                0xffffffff
+        #define FUNC_MF_CFG_LOWERMAC_DEFAULT            0xffffffff
 
         u32 e1hov_tag;  /* VNI */
-#define FUNC_MF_CFG_E1HOV_TAG_MASK                  0x0000ffff
-#define FUNC_MF_CFG_E1HOV_TAG_SHIFT                 0
-#define FUNC_MF_CFG_E1HOV_TAG_DEFAULT               FUNC_MF_CFG_E1HOV_TAG_MASK
+        #define FUNC_MF_CFG_E1HOV_TAG_MASK              0x0000ffff
+        #define FUNC_MF_CFG_E1HOV_TAG_SHIFT             0
+        #define FUNC_MF_CFG_E1HOV_TAG_DEFAULT         FUNC_MF_CFG_E1HOV_TAG_MASK
 
         u32 reserved[2];
-
 };
 
 /* This structure is not applicable and should not be accessed on 57711 */
 struct func_ext_cfg {
         u32 func_cfg;
-#define MACP_FUNC_CFG_FLAGS_MASK                              0x000000FF
-#define MACP_FUNC_CFG_FLAGS_SHIFT                             0
-#define MACP_FUNC_CFG_FLAGS_ENABLED                           0x00000001
-#define MACP_FUNC_CFG_FLAGS_ETHERNET                          0x00000002
-#define MACP_FUNC_CFG_FLAGS_ISCSI_OFFLOAD                     0x00000004
-#define MACP_FUNC_CFG_FLAGS_FCOE_OFFLOAD                      0x00000008
+        #define MACP_FUNC_CFG_FLAGS_MASK                0x000000FF
+        #define MACP_FUNC_CFG_FLAGS_SHIFT               0
+        #define MACP_FUNC_CFG_FLAGS_ENABLED             0x00000001
+        #define MACP_FUNC_CFG_FLAGS_ETHERNET            0x00000002
+        #define MACP_FUNC_CFG_FLAGS_ISCSI_OFFLOAD       0x00000004
+        #define MACP_FUNC_CFG_FLAGS_FCOE_OFFLOAD        0x00000008
 
         u32 iscsi_mac_addr_upper;
         u32 iscsi_mac_addr_lower;
@@ -1136,73 +1463,99 @@ struct func_ext_cfg {
         u32 fcoe_wwn_node_name_lower;
 
         u32 preserve_data;
-#define MF_FUNC_CFG_PRESERVE_L2_MAC                          (1<<0)
-#define MF_FUNC_CFG_PRESERVE_ISCSI_MAC                       (1<<1)
-#define MF_FUNC_CFG_PRESERVE_FCOE_MAC                        (1<<2)
-#define MF_FUNC_CFG_PRESERVE_FCOE_WWN_P                      (1<<3)
-#define MF_FUNC_CFG_PRESERVE_FCOE_WWN_N                      (1<<4)
+        #define MF_FUNC_CFG_PRESERVE_L2_MAC             (1<<0)
+        #define MF_FUNC_CFG_PRESERVE_ISCSI_MAC          (1<<1)
+        #define MF_FUNC_CFG_PRESERVE_FCOE_MAC           (1<<2)
+        #define MF_FUNC_CFG_PRESERVE_FCOE_WWN_P         (1<<3)
+        #define MF_FUNC_CFG_PRESERVE_FCOE_WWN_N         (1<<4)
+        #define MF_FUNC_CFG_PRESERVE_TX_BW              (1<<5)
 };
 
 struct mf_cfg {
 
-        struct shared_mf_cfg    shared_mf_config;
-        struct port_mf_cfg      port_mf_config[PORT_MAX];
-        struct func_mf_cfg      func_mf_config[E1H_FUNC_MAX];
-
-        struct func_ext_cfg func_ext_config[E1H_FUNC_MAX];
-};
-
+        struct shared_mf_cfg    shared_mf_config;       /* 0x4 */
+        struct port_mf_cfg  port_mf_config[PORT_MAX];   /* 0x10 * 2 = 0x20 */
+        /* for all chips, there are 8 mf functions */
+        struct func_mf_cfg  func_mf_config[E1H_FUNC_MAX]; /* 0x18 * 8 = 0xc0 */
+        /*
+         * Extended configuration per function  - this array does not exist and
+         * should not be accessed on 57711
+         */
+        struct func_ext_cfg func_ext_config[E1H_FUNC_MAX]; /* 0x28 * 8 = 0x140*/
+}; /* 0x224 */
 
 /****************************************************************************
- * Shared Memory Region                                                     *
+ * Shared Memory Region                                                     *
  ****************************************************************************/
-struct shmem_region {                          /*   SharedMem Offset (size) */
+struct shmem_region {                  /*   SharedMem Offset (size) */
 
-        u32                     validity_map[PORT_MAX];  /* 0x0 (4*2 = 0x8) */
-#define SHR_MEM_FORMAT_REV_ID                       ('A'<<24)
-#define SHR_MEM_FORMAT_REV_MASK                     0xff000000
+        u32         validity_map[PORT_MAX];  /* 0x0 (4*2 = 0x8) */
+        #define SHR_MEM_FORMAT_REV_MASK                     0xff000000
+        #define SHR_MEM_FORMAT_REV_ID                       ('A'<<24)
         /* validity bits */
-#define SHR_MEM_VALIDITY_PCI_CFG                    0x00100000
-#define SHR_MEM_VALIDITY_MB                         0x00200000
-#define SHR_MEM_VALIDITY_DEV_INFO                   0x00400000
-#define SHR_MEM_VALIDITY_RESERVED                   0x00000007
+        #define SHR_MEM_VALIDITY_PCI_CFG                    0x00100000
+        #define SHR_MEM_VALIDITY_MB                         0x00200000
+        #define SHR_MEM_VALIDITY_DEV_INFO                   0x00400000
+        #define SHR_MEM_VALIDITY_RESERVED                   0x00000007
         /* One licensing bit should be set */
-#define SHR_MEM_VALIDITY_LIC_KEY_IN_EFFECT_MASK     0x00000038
-#define SHR_MEM_VALIDITY_LIC_MANUF_KEY_IN_EFFECT    0x00000008
-#define SHR_MEM_VALIDITY_LIC_UPGRADE_KEY_IN_EFFECT  0x00000010
-#define SHR_MEM_VALIDITY_LIC_NO_KEY_IN_EFFECT       0x00000020
+        #define SHR_MEM_VALIDITY_LIC_KEY_IN_EFFECT_MASK     0x00000038
+        #define SHR_MEM_VALIDITY_LIC_MANUF_KEY_IN_EFFECT    0x00000008
+        #define SHR_MEM_VALIDITY_LIC_UPGRADE_KEY_IN_EFFECT  0x00000010
+        #define SHR_MEM_VALIDITY_LIC_NO_KEY_IN_EFFECT       0x00000020
         /* Active MFW */
-#define SHR_MEM_VALIDITY_ACTIVE_MFW_UNKNOWN         0x00000000
-#define SHR_MEM_VALIDITY_ACTIVE_MFW_IPMI            0x00000040
-#define SHR_MEM_VALIDITY_ACTIVE_MFW_UMP             0x00000080
-#define SHR_MEM_VALIDITY_ACTIVE_MFW_NCSI            0x000000c0
-#define SHR_MEM_VALIDITY_ACTIVE_MFW_NONE            0x000001c0
-#define SHR_MEM_VALIDITY_ACTIVE_MFW_MASK            0x000001c0
+        #define SHR_MEM_VALIDITY_ACTIVE_MFW_UNKNOWN         0x00000000
+        #define SHR_MEM_VALIDITY_ACTIVE_MFW_MASK            0x000001c0
+        #define SHR_MEM_VALIDITY_ACTIVE_MFW_IPMI            0x00000040
+        #define SHR_MEM_VALIDITY_ACTIVE_MFW_UMP             0x00000080
+        #define SHR_MEM_VALIDITY_ACTIVE_MFW_NCSI            0x000000c0
+        #define SHR_MEM_VALIDITY_ACTIVE_MFW_NONE            0x000001c0
 
-        struct shm_dev_info     dev_info;                /* 0x8     (0x438) */
+        struct shm_dev_info dev_info;        /* 0x8     (0x438) */
 
-        struct license_key      drv_lic_key[PORT_MAX];  /* 0x440 (52*2=0x68) */
+        struct license_key       drv_lic_key[PORT_MAX]; /* 0x440 (52*2=0x68) */
 
         /* FW information (for internal FW use) */
-        u32                     fw_info_fio_offset;    /* 0x4a8       (0x4) */
-        struct mgmtfw_state     mgmtfw_state;          /* 0x4ac     (0x1b8) */
+        u32         fw_info_fio_offset;         /* 0x4a8       (0x4) */
+        struct mgmtfw_state mgmtfw_state;       /* 0x4ac     (0x1b8) */
+
+        struct drv_port_mb  port_mb[PORT_MAX];  /* 0x664 (16*2=0x20) */
 
-        struct drv_port_mb      port_mb[PORT_MAX];     /* 0x664 (16*2=0x20) */
-        struct drv_func_mb      func_mb[];             /* 0x684
-                                             (44*2/4/8=0x58/0xb0/0x160) */
+#ifdef BMAPI
+        /* This is a variable length array */
+        /* the number of function depends on the chip type */
+        struct drv_func_mb func_mb[1];  /* 0x684 (44*2/4/8=0x58/0xb0/0x160) */
+#else
+        /* the number of function depends on the chip type */
+        struct drv_func_mb  func_mb[];  /* 0x684 (44*2/4/8=0x58/0xb0/0x160) */
+#endif /* BMAPI */
 
 }; /* 57710 = 0x6dc | 57711 = 0x7E4 | 57712 = 0x734 */
 
+/****************************************************************************
+ * Shared Memory 2 Region                                                   *
+ ****************************************************************************/
+/* The fw_flr_ack is actually built in the following way:                   */
+/* 8 bit:  PF ack                                                           */
+/* 64 bit: VF ack                                                           */
+/* 8 bit:  ios_dis_ack                                                      */
+/* In order to maintain endianity in the mailbox hsi, we want to keep using */
+/* u32. The fw must have the VF right after the PF since this is how it     */
+/* access arrays(it expects always the VF to reside after the PF, and that  */
+/* makes the calculation much easier for it. )                              */
+/* In order to answer both limitations, and keep the struct small, the code */
+/* will abuse the structure defined here to achieve the actual partition    */
+/* above                                                                    */
+/****************************************************************************/
 struct fw_flr_ack {
-        u32     pf_ack;
-        u32     vf_ack[1];
-        u32     iov_dis_ack;
+        u32         pf_ack;
+        u32         vf_ack[1];
+        u32         iov_dis_ack;
 };
 
 struct fw_flr_mb {
-        u32     aggint;
-        u32     opgen_addr;
-        struct  fw_flr_ack ack;
+        u32         aggint;
+        u32         opgen_addr;
+        struct fw_flr_ack ack;
 };
 
 /**** SUPPORT FOR SHMEM ARRRAYS ***
@@ -1226,36 +1579,36 @@ struct fw_flr_mb {
  *
  * SHMEM_ARRAY_BITPOS(i, 4, 4) defines the stadard ordering:
  *
- *              |               |               |               |
- *   0  |   1   |   2   |   3   |   4   |   5   |   6   |   7   |
- *              |               |               |               |
+ *                |                |                |               |
+ *   0    |   1   |   2    |   3   |   4    |   5   |   6   |   7   |
+ *                |                |                |               |
  *
  * SHMEM_ARRAY_BITPOS(i, 4, 8) defines a flip ordering per byte:
  *
- *              |               |               |               |
- *   1  |   0   |   3   |   2   |   5   |   4   |   7   |   6   |
- *              |               |               |               |
+ *                |                |                |               |
+ *   1   |   0    |   3    |   2   |   5    |   4   |   7   |   6   |
+ *                |                |                |               |
  *
  * SHMEM_ARRAY_BITPOS(i, 4, 16) defines a flip ordering per word:
  *
- *              |               |               |               |
- *   3  |   2   |   1   |   0   |   7   |   6   |   5   |   4   |
- *              |               |               |               |
+ *                |                |                |               |
+ *   3   |   2    |   1   |   0    |   7   |   6    |   5   |   4   |
+ *                |                |                |               |
  */
 #define SHMEM_ARRAY_BITPOS(i, eb, fb)   \
         ((((32/(fb)) - 1 - ((i)/((fb)/(eb))) % (32/(fb))) * (fb)) + \
         (((i)%((fb)/(eb))) * (eb)))
 
-#define SHMEM_ARRAY_GET(a, i, eb, fb)                                      \
+#define SHMEM_ARRAY_GET(a, i, eb, fb)                                   \
         ((a[SHMEM_ARRAY_ENTRY(i, eb)] >> SHMEM_ARRAY_BITPOS(i, eb, fb)) &  \
         SHMEM_ARRAY_MASK(eb))
 
-#define SHMEM_ARRAY_SET(a, i, eb, fb, val)                                 \
+#define SHMEM_ARRAY_SET(a, i, eb, fb, val)                              \
 do {                                                                       \
         a[SHMEM_ARRAY_ENTRY(i, eb)] &= ~(SHMEM_ARRAY_MASK(eb) <<           \
-        SHMEM_ARRAY_BITPOS(i, eb, fb));                            \
+        SHMEM_ARRAY_BITPOS(i, eb, fb));                                    \
         a[SHMEM_ARRAY_ENTRY(i, eb)] |= (((val) & SHMEM_ARRAY_MASK(eb)) <<  \
-        SHMEM_ARRAY_BITPOS(i, eb, fb));                            \
+        SHMEM_ARRAY_BITPOS(i, eb, fb));                                    \
 } while (0)
 
 
@@ -1279,23 +1632,30 @@ do {									   \
 #define ISCSI_APP_IDX                   1
 #define PREDEFINED_APP_IDX_MAX          2
 
+
+/* Big/Little endian have the same representation. */
 struct dcbx_ets_feature {
+        /*
+         * For Admin MIB - is this feature supported by the
+         * driver | For Local MIB - should this feature be enabled.
+         */
         u32 enabled;
         u32  pg_bw_tbl[2];
         u32  pri_pg_tbl[1];
 };
 
+/* Driver structure in LE */
 struct dcbx_pfc_feature {
 #ifdef __BIG_ENDIAN
         u8 pri_en_bitmap;
-#define DCBX_PFC_PRI_0 0x01
-#define DCBX_PFC_PRI_1 0x02
-#define DCBX_PFC_PRI_2 0x04
-#define DCBX_PFC_PRI_3 0x08
-#define DCBX_PFC_PRI_4 0x10
-#define DCBX_PFC_PRI_5 0x20
-#define DCBX_PFC_PRI_6 0x40
-#define DCBX_PFC_PRI_7 0x80
+        #define DCBX_PFC_PRI_0 0x01
+        #define DCBX_PFC_PRI_1 0x02
+        #define DCBX_PFC_PRI_2 0x04
+        #define DCBX_PFC_PRI_3 0x08
+        #define DCBX_PFC_PRI_4 0x10
+        #define DCBX_PFC_PRI_5 0x20
+        #define DCBX_PFC_PRI_6 0x40
+        #define DCBX_PFC_PRI_7 0x80
         u8 pfc_caps;
         u8 reserved;
         u8 enabled;
@@ -1304,39 +1664,41 @@ struct dcbx_pfc_feature {
         u8 reserved;
         u8 pfc_caps;
         u8 pri_en_bitmap;
-#define DCBX_PFC_PRI_0 0x01
-#define DCBX_PFC_PRI_1 0x02
-#define DCBX_PFC_PRI_2 0x04
-#define DCBX_PFC_PRI_3 0x08
-#define DCBX_PFC_PRI_4 0x10
-#define DCBX_PFC_PRI_5 0x20
-#define DCBX_PFC_PRI_6 0x40
-#define DCBX_PFC_PRI_7 0x80
+        #define DCBX_PFC_PRI_0 0x01
+        #define DCBX_PFC_PRI_1 0x02
+        #define DCBX_PFC_PRI_2 0x04
+        #define DCBX_PFC_PRI_3 0x08
+        #define DCBX_PFC_PRI_4 0x10
+        #define DCBX_PFC_PRI_5 0x20
+        #define DCBX_PFC_PRI_6 0x40
+        #define DCBX_PFC_PRI_7 0x80
 #endif
 };
 
 struct dcbx_app_priority_entry {
 #ifdef __BIG_ENDIAN
-        u16     app_id;
-        u8      pri_bitmap;
-        u8      appBitfield;
-#define DCBX_APP_ENTRY_VALID         0x01
-#define DCBX_APP_ENTRY_SF_MASK       0x30
-#define DCBX_APP_ENTRY_SF_SHIFT      4
-#define DCBX_APP_SF_ETH_TYPE         0x10
-#define DCBX_APP_SF_PORT             0x20
+        u16  app_id;
+        u8  pri_bitmap;
+        u8  appBitfield;
+        #define DCBX_APP_ENTRY_VALID         0x01
+        #define DCBX_APP_ENTRY_SF_MASK       0x30
+        #define DCBX_APP_ENTRY_SF_SHIFT      4
+        #define DCBX_APP_SF_ETH_TYPE         0x10
+        #define DCBX_APP_SF_PORT             0x20
 #elif defined(__LITTLE_ENDIAN)
         u8 appBitfield;
-#define DCBX_APP_ENTRY_VALID         0x01
-#define DCBX_APP_ENTRY_SF_MASK       0x30
-#define DCBX_APP_ENTRY_SF_SHIFT      4
-#define DCBX_APP_SF_ETH_TYPE         0x10
-#define DCBX_APP_SF_PORT             0x20
-        u8      pri_bitmap;
-        u16     app_id;
+        #define DCBX_APP_ENTRY_VALID         0x01
+        #define DCBX_APP_ENTRY_SF_MASK       0x30
+        #define DCBX_APP_ENTRY_SF_SHIFT      4
+        #define DCBX_APP_SF_ETH_TYPE         0x10
+        #define DCBX_APP_SF_PORT             0x20
+        u8  pri_bitmap;
+        u16  app_id;
 #endif
 };
 
+
+/* FW structure in BE */
 struct dcbx_app_priority_feature {
 #ifdef __BIG_ENDIAN
         u8 reserved;
@@ -1352,302 +1714,402 @@ struct dcbx_app_priority_feature {
         struct dcbx_app_priority_entry  app_pri_tbl[DCBX_MAX_APP_PROTOCOL];
 };
 
+/* FW structure in BE */
 struct dcbx_features {
+        /* PG feature */
         struct dcbx_ets_feature ets;
+        /* PFC feature */
         struct dcbx_pfc_feature pfc;
+        /* APP feature */
         struct dcbx_app_priority_feature app;
 };
 
+/* LLDP protocol parameters */
+/* FW structure in BE */
 struct lldp_params {
 #ifdef __BIG_ENDIAN
-        u8      msg_fast_tx_interval;
-        u8      msg_tx_hold;
-        u8      msg_tx_interval;
-        u8      admin_status;
-#define LLDP_TX_ONLY  0x01
-#define LLDP_RX_ONLY  0x02
-#define LLDP_TX_RX    0x03
-#define LLDP_DISABLED 0x04
-        u8      reserved1;
-        u8      tx_fast;
-        u8      tx_crd_max;
-        u8      tx_crd;
+        u8  msg_fast_tx_interval;
+        u8  msg_tx_hold;
+        u8  msg_tx_interval;
+        u8  admin_status;
+        #define LLDP_TX_ONLY  0x01
+        #define LLDP_RX_ONLY  0x02
+        #define LLDP_TX_RX    0x03
+        #define LLDP_DISABLED 0x04
+        u8  reserved1;
+        u8  tx_fast;
+        u8  tx_crd_max;
+        u8  tx_crd;
 #elif defined(__LITTLE_ENDIAN)
-        u8      admin_status;
-#define LLDP_TX_ONLY  0x01
-#define LLDP_RX_ONLY  0x02
-#define LLDP_TX_RX    0x03
-#define LLDP_DISABLED 0x04
-        u8      msg_tx_interval;
-        u8      msg_tx_hold;
-        u8      msg_fast_tx_interval;
-        u8      tx_crd;
-        u8      tx_crd_max;
-        u8      tx_fast;
-        u8      reserved1;
+        u8  admin_status;
+        #define LLDP_TX_ONLY  0x01
+        #define LLDP_RX_ONLY  0x02
+        #define LLDP_TX_RX    0x03
+        #define LLDP_DISABLED 0x04
+        u8  msg_tx_interval;
+        u8  msg_tx_hold;
+        u8  msg_fast_tx_interval;
+        u8  tx_crd;
+        u8  tx_crd_max;
+        u8  tx_fast;
+        u8  reserved1;
 #endif
-#define REM_CHASSIS_ID_STAT_LEN 4
-#define REM_PORT_ID_STAT_LEN 4
+        #define REM_CHASSIS_ID_STAT_LEN 4
+        #define REM_PORT_ID_STAT_LEN 4
+        /* Holds remote Chassis ID TLV header, subtype and 9B of payload. */
         u32 peer_chassis_id[REM_CHASSIS_ID_STAT_LEN];
+        /* Holds remote Port ID TLV header, subtype and 9B of payload. */
         u32 peer_port_id[REM_PORT_ID_STAT_LEN];
 };
 
 struct lldp_dcbx_stat {
-#define LOCAL_CHASSIS_ID_STAT_LEN 2
-#define LOCAL_PORT_ID_STAT_LEN 2
+        #define LOCAL_CHASSIS_ID_STAT_LEN 2
+        #define LOCAL_PORT_ID_STAT_LEN 2
+        /* Holds local Chassis ID 8B payload of constant subtype 4. */
         u32 local_chassis_id[LOCAL_CHASSIS_ID_STAT_LEN];
+        /* Holds local Port ID 8B payload of constant subtype 3. */
         u32 local_port_id[LOCAL_PORT_ID_STAT_LEN];
+        /* Number of DCBX frames transmitted. */
         u32 num_tx_dcbx_pkts;
+        /* Number of DCBX frames received. */
         u32 num_rx_dcbx_pkts;
 };
 
+/* ADMIN MIB - DCBX local machine default configuration. */
 struct lldp_admin_mib {
-        u32     ver_cfg_flags;
-#define DCBX_ETS_CONFIG_TX_ENABLED      0x00000001
-#define DCBX_PFC_CONFIG_TX_ENABLED      0x00000002
-#define DCBX_APP_CONFIG_TX_ENABLED      0x00000004
-#define DCBX_ETS_RECO_TX_ENABLED        0x00000008
-#define DCBX_ETS_RECO_VALID             0x00000010
-#define DCBX_ETS_WILLING                0x00000020
-#define DCBX_PFC_WILLING                0x00000040
-#define DCBX_APP_WILLING                0x00000080
-#define DCBX_VERSION_CEE                0x00000100
-#define DCBX_VERSION_IEEE               0x00000200
-#define DCBX_DCBX_ENABLED               0x00000400
-#define DCBX_CEE_VERSION_MASK           0x0000f000
-#define DCBX_CEE_VERSION_SHIFT          12
-#define DCBX_CEE_MAX_VERSION_MASK       0x000f0000
-#define DCBX_CEE_MAX_VERSION_SHIFT      16
-        struct dcbx_features    features;
-};
-
+        u32     ver_cfg_flags;
+        #define DCBX_ETS_CONFIG_TX_ENABLED       0x00000001
+        #define DCBX_PFC_CONFIG_TX_ENABLED       0x00000002
+        #define DCBX_APP_CONFIG_TX_ENABLED       0x00000004
+        #define DCBX_ETS_RECO_TX_ENABLED         0x00000008
+        #define DCBX_ETS_RECO_VALID              0x00000010
+        #define DCBX_ETS_WILLING                 0x00000020
+        #define DCBX_PFC_WILLING                 0x00000040
+        #define DCBX_APP_WILLING                 0x00000080
+        #define DCBX_VERSION_CEE                 0x00000100
+        #define DCBX_VERSION_IEEE                0x00000200
+        #define DCBX_DCBX_ENABLED                0x00000400
+        #define DCBX_CEE_VERSION_MASK            0x0000f000
+        #define DCBX_CEE_VERSION_SHIFT           12
+        #define DCBX_CEE_MAX_VERSION_MASK        0x000f0000
+        #define DCBX_CEE_MAX_VERSION_SHIFT       16
+        struct dcbx_features     features;
+};
+
+/* REMOTE MIB - remote machine DCBX configuration. */
 struct lldp_remote_mib {
         u32 prefix_seq_num;
         u32 flags;
-#define DCBX_ETS_TLV_RX     0x00000001
-#define DCBX_PFC_TLV_RX     0x00000002
-#define DCBX_APP_TLV_RX     0x00000004
-#define DCBX_ETS_RX_ERROR   0x00000010
-#define DCBX_PFC_RX_ERROR   0x00000020
-#define DCBX_APP_RX_ERROR   0x00000040
-#define DCBX_ETS_REM_WILLING    0x00000100
-#define DCBX_PFC_REM_WILLING    0x00000200
-#define DCBX_APP_REM_WILLING    0x00000400
-#define DCBX_REMOTE_ETS_RECO_VALID  0x00001000
+        #define DCBX_ETS_TLV_RX                  0x00000001
+        #define DCBX_PFC_TLV_RX                  0x00000002
+        #define DCBX_APP_TLV_RX                  0x00000004
+        #define DCBX_ETS_RX_ERROR                0x00000010
+        #define DCBX_PFC_RX_ERROR                0x00000020
+        #define DCBX_APP_RX_ERROR                0x00000040
+        #define DCBX_ETS_REM_WILLING             0x00000100
+        #define DCBX_PFC_REM_WILLING             0x00000200
+        #define DCBX_APP_REM_WILLING             0x00000400
+        #define DCBX_REMOTE_ETS_RECO_VALID       0x00001000
+        #define DCBX_REMOTE_MIB_VALID            0x00002000
         struct dcbx_features features;
         u32 suffix_seq_num;
 };
 
+/* LOCAL MIB - operational DCBX configuration - transmitted on Tx LLDPDU. */
 struct lldp_local_mib {
         u32 prefix_seq_num;
+        /* Indicates if there is mismatch with negotiation results. */
         u32 error;
-#define DCBX_LOCAL_ETS_ERROR     0x00000001
-#define DCBX_LOCAL_PFC_ERROR     0x00000002
-#define DCBX_LOCAL_APP_ERROR     0x00000004
-#define DCBX_LOCAL_PFC_MISMATCH  0x00000010
-#define DCBX_LOCAL_APP_MISMATCH  0x00000020
+        #define DCBX_LOCAL_ETS_ERROR             0x00000001
+        #define DCBX_LOCAL_PFC_ERROR             0x00000002
+        #define DCBX_LOCAL_APP_ERROR             0x00000004
+        #define DCBX_LOCAL_PFC_MISMATCH          0x00000010
+        #define DCBX_LOCAL_APP_MISMATCH          0x00000020
         struct dcbx_features   features;
         u32 suffix_seq_num;
 };
 /***END OF DCBX STRUCTURES DECLARATIONS***/
 
+struct ncsi_oem_fcoe_features {
+        u32 fcoe_features1;
+        #define FCOE_FEATURES1_IOS_PER_CONNECTION_MASK          0x0000FFFF
+        #define FCOE_FEATURES1_IOS_PER_CONNECTION_OFFSET        0
+
+        #define FCOE_FEATURES1_LOGINS_PER_PORT_MASK             0xFFFF0000
+        #define FCOE_FEATURES1_LOGINS_PER_PORT_OFFSET           16
+
+        u32 fcoe_features2;
+        #define FCOE_FEATURES2_EXCHANGES_MASK                   0x0000FFFF
+        #define FCOE_FEATURES2_EXCHANGES_OFFSET                 0
+
+        #define FCOE_FEATURES2_NPIV_WWN_PER_PORT_MASK           0xFFFF0000
+        #define FCOE_FEATURES2_NPIV_WWN_PER_PORT_OFFSET         16
+
+        u32 fcoe_features3;
+        #define FCOE_FEATURES3_TARGETS_SUPPORTED_MASK           0x0000FFFF
+        #define FCOE_FEATURES3_TARGETS_SUPPORTED_OFFSET         0
+
+        #define FCOE_FEATURES3_OUTSTANDING_COMMANDS_MASK        0xFFFF0000
+        #define FCOE_FEATURES3_OUTSTANDING_COMMANDS_OFFSET      16
+
+        u32 fcoe_features4;
+        #define FCOE_FEATURES4_FEATURE_SETTINGS_MASK            0x0000000F
+        #define FCOE_FEATURES4_FEATURE_SETTINGS_OFFSET          0
+};
+
+struct ncsi_oem_data {
+        u32 driver_version[4];
+        struct ncsi_oem_fcoe_features ncsi_oem_fcoe_features;
+};
+
 struct shmem2_region {
 
-        u32                     size;
-
-        u32                     dcc_support;
-#define SHMEM_DCC_SUPPORT_NONE                      0x00000000
-#define SHMEM_DCC_SUPPORT_DISABLE_ENABLE_PF_TLV     0x00000001
-#define SHMEM_DCC_SUPPORT_BANDWIDTH_ALLOCATION_TLV  0x00000004
-#define SHMEM_DCC_SUPPORT_CHANGE_MAC_ADDRESS_TLV    0x00000008
-#define SHMEM_DCC_SUPPORT_SET_PROTOCOL_TLV          0x00000040
-#define SHMEM_DCC_SUPPORT_SET_PRIORITY_TLV          0x00000080
-#define SHMEM_DCC_SUPPORT_DEFAULT                   SHMEM_DCC_SUPPORT_NONE
-        u32 ext_phy_fw_version2[PORT_MAX];
+        u32 size;                                       /* 0x0000 */
+
+        u32 dcc_support;                                /* 0x0004 */
+        #define SHMEM_DCC_SUPPORT_NONE                      0x00000000
+        #define SHMEM_DCC_SUPPORT_DISABLE_ENABLE_PF_TLV     0x00000001
+        #define SHMEM_DCC_SUPPORT_BANDWIDTH_ALLOCATION_TLV  0x00000004
+        #define SHMEM_DCC_SUPPORT_CHANGE_MAC_ADDRESS_TLV    0x00000008
+        #define SHMEM_DCC_SUPPORT_SET_PROTOCOL_TLV          0x00000040
+        #define SHMEM_DCC_SUPPORT_SET_PRIORITY_TLV          0x00000080
+
+        u32 ext_phy_fw_version2[PORT_MAX];              /* 0x0008 */
         /*
          * For backwards compatibility, if the mf_cfg_addr does not exist
          * (the size filed is smaller than 0xc) the mf_cfg resides at the
          * end of struct shmem_region
-     */
-        u32     mf_cfg_addr;
-#define SHMEM_MF_CFG_ADDR_NONE                      0x00000000
-
-        struct fw_flr_mb flr_mb;
-        u32     dcbx_lldp_params_offset;
-#define SHMEM_LLDP_DCBX_PARAMS_NONE                 0x00000000
-        u32     dcbx_neg_res_offset;
-#define SHMEM_DCBX_NEG_RES_NONE                     0x00000000
-        u32     dcbx_remote_mib_offset;
-#define SHMEM_DCBX_REMOTE_MIB_NONE                  0x00000000
+         */
+        u32 mf_cfg_addr;                                /* 0x0010 */
+        #define SHMEM_MF_CFG_ADDR_NONE                  0x00000000
+
+        struct fw_flr_mb flr_mb;                        /* 0x0014 */
+        u32 dcbx_lldp_params_offset;                    /* 0x0028 */
+        #define SHMEM_LLDP_DCBX_PARAMS_NONE             0x00000000
+        u32 dcbx_neg_res_offset;                        /* 0x002c */
+        #define SHMEM_DCBX_NEG_RES_NONE                 0x00000000
+        u32 dcbx_remote_mib_offset;                     /* 0x0030 */
+        #define SHMEM_DCBX_REMOTE_MIB_NONE              0x00000000
         /*
          * The other shmemX_base_addr holds the other path's shmem address
          * required for example in case of common phy init, or for path1 to know
          * the address of mcp debug trace which is located in offset from shmem
          * of path0
          */
-        u32 other_shmem_base_addr;
-        u32 other_shmem2_base_addr;
-        u32     reserved1[E2_VF_MAX / 32];
-        u32     reserved2[E2_FUNC_MAX][E2_VF_MAX / 32];
-        u32     dcbx_lldp_dcbx_stat_offset;
-#define SHMEM_LLDP_DCBX_STAT_NONE                  0x00000000
+        u32 other_shmem_base_addr;                      /* 0x0034 */
+        u32 other_shmem2_base_addr;                     /* 0x0038 */
+        /*
+         * mcp_vf_disabled is set by the MCP to indicate the driver about VFs
+         * which were disabled/flred
+         */
+        u32 mcp_vf_disabled[E2_VF_MAX / 32];            /* 0x003c */
+
+        /*
+         * drv_ack_vf_disabled is set by the PF driver to ack handled disabled
+         * VFs
+         */
+        u32 drv_ack_vf_disabled[E2_FUNC_MAX][E2_VF_MAX / 32]; /* 0x0044 */
+
+        u32 dcbx_lldp_dcbx_stat_offset;                 /* 0x0064 */
+        #define SHMEM_LLDP_DCBX_STAT_NONE               0x00000000
+
+        /*
+         * edebug_driver_if field is used to transfer messages between edebug
+         * app to the driver through shmem2.
+         *
+         * message format:
+         * bits 0-2 -  function number / instance of driver to perform request
+         * bits 3-5 -  op code / is_ack?
+         * bits 6-63 - data
+         */
+        u32 edebug_driver_if[2];                        /* 0x0068 */
+        #define EDEBUG_DRIVER_IF_OP_CODE_GET_PHYS_ADDR  1
+        #define EDEBUG_DRIVER_IF_OP_CODE_GET_BUS_ADDR   2
+        #define EDEBUG_DRIVER_IF_OP_CODE_DISABLE_STAT   3
+
+        u32 nvm_retain_bitmap_addr;                     /* 0x0070 */
+
+        u32     reserved1;      /* 0x0074 */
+
+        u32     reserved2[E2_FUNC_MAX];
+
+        u32     reserved3[E2_FUNC_MAX];/* 0x0088 */
+        u32     reserved4[E2_FUNC_MAX];/* 0x0098 */
+
+        u32 swim_base_addr;                             /* 0x0108 */
+        u32 swim_funcs;
+        u32 swim_main_cb;
+
+        u32     reserved5[2];
+
+        /* generic flags controlled by the driver */
+        u32 drv_flags;
+        #define DRV_FLAGS_DCB_CONFIGURED                0x1
+
+        /* pointer to extended dev_info shared data copied from nvm image */
+        u32 extended_dev_info_shared_addr;
+        u32 ncsi_oem_data_addr;
+
+        u32 ocsd_host_addr;
+        u32 ocbb_host_addr;
+        u32 ocsd_req_update_interval;
 };
 
 
 struct emac_stats {
-    u32     rx_stat_ifhcinoctets;
-    u32     rx_stat_ifhcinbadoctets;
-    u32     rx_stat_etherstatsfragments;
-    u32     rx_stat_ifhcinucastpkts;
-    u32     rx_stat_ifhcinmulticastpkts;
-    u32     rx_stat_ifhcinbroadcastpkts;
-    u32     rx_stat_dot3statsfcserrors;
-    u32     rx_stat_dot3statsalignmenterrors;
-    u32     rx_stat_dot3statscarriersenseerrors;
-    u32     rx_stat_xonpauseframesreceived;
-    u32     rx_stat_xoffpauseframesreceived;
-    u32     rx_stat_maccontrolframesreceived;
-    u32     rx_stat_xoffstateentered;
-    u32     rx_stat_dot3statsframestoolong;
-    u32     rx_stat_etherstatsjabbers;
-    u32     rx_stat_etherstatsundersizepkts;
-    u32     rx_stat_etherstatspkts64octets;
-    u32     rx_stat_etherstatspkts65octetsto127octets;
-    u32     rx_stat_etherstatspkts128octetsto255octets;
-    u32     rx_stat_etherstatspkts256octetsto511octets;
-    u32     rx_stat_etherstatspkts512octetsto1023octets;
-    u32     rx_stat_etherstatspkts1024octetsto1522octets;
-    u32     rx_stat_etherstatspktsover1522octets;
-
-    u32     rx_stat_falsecarriererrors;
-
-    u32     tx_stat_ifhcoutoctets;
-    u32     tx_stat_ifhcoutbadoctets;
-    u32     tx_stat_etherstatscollisions;
-    u32     tx_stat_outxonsent;
-    u32     tx_stat_outxoffsent;
-    u32     tx_stat_flowcontroldone;
-    u32     tx_stat_dot3statssinglecollisionframes;
-    u32     tx_stat_dot3statsmultiplecollisionframes;
-    u32     tx_stat_dot3statsdeferredtransmissions;
-    u32     tx_stat_dot3statsexcessivecollisions;
-    u32     tx_stat_dot3statslatecollisions;
-    u32     tx_stat_ifhcoutucastpkts;
-    u32     tx_stat_ifhcoutmulticastpkts;
-    u32     tx_stat_ifhcoutbroadcastpkts;
-    u32     tx_stat_etherstatspkts64octets;
-    u32     tx_stat_etherstatspkts65octetsto127octets;
-    u32     tx_stat_etherstatspkts128octetsto255octets;
-    u32     tx_stat_etherstatspkts256octetsto511octets;
-    u32     tx_stat_etherstatspkts512octetsto1023octets;
-    u32     tx_stat_etherstatspkts1024octetsto1522octets;
-    u32     tx_stat_etherstatspktsover1522octets;
-    u32     tx_stat_dot3statsinternalmactransmiterrors;
+        u32     rx_stat_ifhcinoctets;
+        u32     rx_stat_ifhcinbadoctets;
+        u32     rx_stat_etherstatsfragments;
+        u32     rx_stat_ifhcinucastpkts;
+        u32     rx_stat_ifhcinmulticastpkts;
+        u32     rx_stat_ifhcinbroadcastpkts;
+        u32     rx_stat_dot3statsfcserrors;
+        u32     rx_stat_dot3statsalignmenterrors;
+        u32     rx_stat_dot3statscarriersenseerrors;
+        u32     rx_stat_xonpauseframesreceived;
+        u32     rx_stat_xoffpauseframesreceived;
+        u32     rx_stat_maccontrolframesreceived;
+        u32     rx_stat_xoffstateentered;
+        u32     rx_stat_dot3statsframestoolong;
+        u32     rx_stat_etherstatsjabbers;
+        u32     rx_stat_etherstatsundersizepkts;
+        u32     rx_stat_etherstatspkts64octets;
+        u32     rx_stat_etherstatspkts65octetsto127octets;
+        u32     rx_stat_etherstatspkts128octetsto255octets;
+        u32     rx_stat_etherstatspkts256octetsto511octets;
+        u32     rx_stat_etherstatspkts512octetsto1023octets;
+        u32     rx_stat_etherstatspkts1024octetsto1522octets;
+        u32     rx_stat_etherstatspktsover1522octets;
+
+        u32     rx_stat_falsecarriererrors;
+
+        u32     tx_stat_ifhcoutoctets;
+        u32     tx_stat_ifhcoutbadoctets;
+        u32     tx_stat_etherstatscollisions;
+        u32     tx_stat_outxonsent;
+        u32     tx_stat_outxoffsent;
+        u32     tx_stat_flowcontroldone;
+        u32     tx_stat_dot3statssinglecollisionframes;
+        u32     tx_stat_dot3statsmultiplecollisionframes;
+        u32     tx_stat_dot3statsdeferredtransmissions;
+        u32     tx_stat_dot3statsexcessivecollisions;
+        u32     tx_stat_dot3statslatecollisions;
+        u32     tx_stat_ifhcoutucastpkts;
+        u32     tx_stat_ifhcoutmulticastpkts;
+        u32     tx_stat_ifhcoutbroadcastpkts;
+        u32     tx_stat_etherstatspkts64octets;
+        u32     tx_stat_etherstatspkts65octetsto127octets;
+        u32     tx_stat_etherstatspkts128octetsto255octets;
+        u32     tx_stat_etherstatspkts256octetsto511octets;
+        u32     tx_stat_etherstatspkts512octetsto1023octets;
+        u32     tx_stat_etherstatspkts1024octetsto1522octets;
+        u32     tx_stat_etherstatspktsover1522octets;
+        u32     tx_stat_dot3statsinternalmactransmiterrors;
 };
 
 
 struct bmac1_stats {
-    u32     tx_stat_gtpkt_lo;
-    u32     tx_stat_gtpkt_hi;
-    u32     tx_stat_gtxpf_lo;
-    u32     tx_stat_gtxpf_hi;
-    u32     tx_stat_gtfcs_lo;
-    u32     tx_stat_gtfcs_hi;
-    u32     tx_stat_gtmca_lo;
-    u32     tx_stat_gtmca_hi;
-    u32     tx_stat_gtbca_lo;
-    u32     tx_stat_gtbca_hi;
-    u32     tx_stat_gtfrg_lo;
-    u32     tx_stat_gtfrg_hi;
-    u32     tx_stat_gtovr_lo;
-    u32     tx_stat_gtovr_hi;
-    u32     tx_stat_gt64_lo;
-    u32     tx_stat_gt64_hi;
-    u32     tx_stat_gt127_lo;
-    u32     tx_stat_gt127_hi;
-    u32     tx_stat_gt255_lo;
-    u32     tx_stat_gt255_hi;
-    u32     tx_stat_gt511_lo;
-    u32     tx_stat_gt511_hi;
-    u32     tx_stat_gt1023_lo;
-    u32     tx_stat_gt1023_hi;
-    u32     tx_stat_gt1518_lo;
-    u32     tx_stat_gt1518_hi;
-    u32     tx_stat_gt2047_lo;
-    u32     tx_stat_gt2047_hi;
-    u32     tx_stat_gt4095_lo;
-    u32     tx_stat_gt4095_hi;
-    u32     tx_stat_gt9216_lo;
-    u32     tx_stat_gt9216_hi;
-    u32     tx_stat_gt16383_lo;
-    u32     tx_stat_gt16383_hi;
-    u32     tx_stat_gtmax_lo;
-    u32     tx_stat_gtmax_hi;
-    u32     tx_stat_gtufl_lo;
-    u32     tx_stat_gtufl_hi;
-    u32     tx_stat_gterr_lo;
-    u32     tx_stat_gterr_hi;
-    u32     tx_stat_gtbyt_lo;
-    u32     tx_stat_gtbyt_hi;
-
-    u32     rx_stat_gr64_lo;
-    u32     rx_stat_gr64_hi;
-    u32     rx_stat_gr127_lo;
-    u32     rx_stat_gr127_hi;
-    u32     rx_stat_gr255_lo;
-    u32     rx_stat_gr255_hi;
-    u32     rx_stat_gr511_lo;
-    u32     rx_stat_gr511_hi;
-    u32     rx_stat_gr1023_lo;
-    u32     rx_stat_gr1023_hi;
-    u32     rx_stat_gr1518_lo;
-    u32     rx_stat_gr1518_hi;
-    u32     rx_stat_gr2047_lo;
-    u32     rx_stat_gr2047_hi;
-    u32     rx_stat_gr4095_lo;
-    u32     rx_stat_gr4095_hi;
-    u32     rx_stat_gr9216_lo;
-    u32     rx_stat_gr9216_hi;
-    u32     rx_stat_gr16383_lo;
-    u32     rx_stat_gr16383_hi;
-    u32     rx_stat_grmax_lo;
-    u32     rx_stat_grmax_hi;
-    u32     rx_stat_grpkt_lo;
-    u32     rx_stat_grpkt_hi;
-    u32     rx_stat_grfcs_lo;
-    u32     rx_stat_grfcs_hi;
-    u32     rx_stat_grmca_lo;
-    u32     rx_stat_grmca_hi;
-    u32     rx_stat_grbca_lo;
-    u32     rx_stat_grbca_hi;
-    u32     rx_stat_grxcf_lo;
-    u32     rx_stat_grxcf_hi;
-    u32     rx_stat_grxpf_lo;
-    u32     rx_stat_grxpf_hi;
-    u32     rx_stat_grxuo_lo;
-    u32     rx_stat_grxuo_hi;
-    u32     rx_stat_grjbr_lo;
-    u32     rx_stat_grjbr_hi;
-    u32     rx_stat_grovr_lo;
-    u32     rx_stat_grovr_hi;
-    u32     rx_stat_grflr_lo;
-    u32     rx_stat_grflr_hi;
-    u32     rx_stat_grmeg_lo;
-    u32     rx_stat_grmeg_hi;
-    u32     rx_stat_grmeb_lo;
-    u32     rx_stat_grmeb_hi;
-    u32     rx_stat_grbyt_lo;
-    u32     rx_stat_grbyt_hi;
-    u32     rx_stat_grund_lo;
-    u32     rx_stat_grund_hi;
-    u32     rx_stat_grfrg_lo;
-    u32     rx_stat_grfrg_hi;
-    u32     rx_stat_grerb_lo;
-    u32     rx_stat_grerb_hi;
-    u32     rx_stat_grfre_lo;
-    u32     rx_stat_grfre_hi;
-    u32     rx_stat_gripj_lo;
-    u32     rx_stat_gripj_hi;
+        u32     tx_stat_gtpkt_lo;
+        u32     tx_stat_gtpkt_hi;
+        u32     tx_stat_gtxpf_lo;
+        u32     tx_stat_gtxpf_hi;
+        u32     tx_stat_gtfcs_lo;
+        u32     tx_stat_gtfcs_hi;
+        u32     tx_stat_gtmca_lo;
+        u32     tx_stat_gtmca_hi;
+        u32     tx_stat_gtbca_lo;
+        u32     tx_stat_gtbca_hi;
+        u32     tx_stat_gtfrg_lo;
+        u32     tx_stat_gtfrg_hi;
+        u32     tx_stat_gtovr_lo;
+        u32     tx_stat_gtovr_hi;
+        u32     tx_stat_gt64_lo;
+        u32     tx_stat_gt64_hi;
+        u32     tx_stat_gt127_lo;
+        u32     tx_stat_gt127_hi;
+        u32     tx_stat_gt255_lo;
+        u32     tx_stat_gt255_hi;
+        u32     tx_stat_gt511_lo;
+        u32     tx_stat_gt511_hi;
+        u32     tx_stat_gt1023_lo;
+        u32     tx_stat_gt1023_hi;
+        u32     tx_stat_gt1518_lo;
+        u32     tx_stat_gt1518_hi;
+        u32     tx_stat_gt2047_lo;
+        u32     tx_stat_gt2047_hi;
+        u32     tx_stat_gt4095_lo;
+        u32     tx_stat_gt4095_hi;
+        u32     tx_stat_gt9216_lo;
+        u32     tx_stat_gt9216_hi;
+        u32     tx_stat_gt16383_lo;
+        u32     tx_stat_gt16383_hi;
+        u32     tx_stat_gtmax_lo;
+        u32     tx_stat_gtmax_hi;
+        u32     tx_stat_gtufl_lo;
+        u32     tx_stat_gtufl_hi;
+        u32     tx_stat_gterr_lo;
+        u32     tx_stat_gterr_hi;
+        u32     tx_stat_gtbyt_lo;
+        u32     tx_stat_gtbyt_hi;
+
+        u32     rx_stat_gr64_lo;
+        u32     rx_stat_gr64_hi;
+        u32     rx_stat_gr127_lo;
+        u32     rx_stat_gr127_hi;
+        u32     rx_stat_gr255_lo;
+        u32     rx_stat_gr255_hi;
+        u32     rx_stat_gr511_lo;
+        u32     rx_stat_gr511_hi;
+        u32     rx_stat_gr1023_lo;
+        u32     rx_stat_gr1023_hi;
+        u32     rx_stat_gr1518_lo;
+        u32     rx_stat_gr1518_hi;
+        u32     rx_stat_gr2047_lo;
+        u32     rx_stat_gr2047_hi;
+        u32     rx_stat_gr4095_lo;
+        u32     rx_stat_gr4095_hi;
+        u32     rx_stat_gr9216_lo;
+        u32     rx_stat_gr9216_hi;
+        u32     rx_stat_gr16383_lo;
+        u32     rx_stat_gr16383_hi;
+        u32     rx_stat_grmax_lo;
+        u32     rx_stat_grmax_hi;
+        u32     rx_stat_grpkt_lo;
+        u32     rx_stat_grpkt_hi;
+        u32     rx_stat_grfcs_lo;
+        u32     rx_stat_grfcs_hi;
+        u32     rx_stat_grmca_lo;
+        u32     rx_stat_grmca_hi;
+        u32     rx_stat_grbca_lo;
+        u32     rx_stat_grbca_hi;
+        u32     rx_stat_grxcf_lo;
+        u32     rx_stat_grxcf_hi;
+        u32     rx_stat_grxpf_lo;
+        u32     rx_stat_grxpf_hi;
+        u32     rx_stat_grxuo_lo;
+        u32     rx_stat_grxuo_hi;
+        u32     rx_stat_grjbr_lo;
+        u32     rx_stat_grjbr_hi;
+        u32     rx_stat_grovr_lo;
+        u32     rx_stat_grovr_hi;
+        u32     rx_stat_grflr_lo;
+        u32     rx_stat_grflr_hi;
+        u32     rx_stat_grmeg_lo;
+        u32     rx_stat_grmeg_hi;
+        u32     rx_stat_grmeb_lo;
+        u32     rx_stat_grmeb_hi;
+        u32     rx_stat_grbyt_lo;
+        u32     rx_stat_grbyt_hi;
+        u32     rx_stat_grund_lo;
+        u32     rx_stat_grund_hi;
+        u32     rx_stat_grfrg_lo;
+        u32     rx_stat_grfrg_hi;
+        u32     rx_stat_grerb_lo;
+        u32     rx_stat_grerb_hi;
+        u32     rx_stat_grfre_lo;
+        u32     rx_stat_grfre_hi;
+        u32     rx_stat_gripj_lo;
+        u32     rx_stat_gripj_hi;
 };
 
 struct bmac2_stats {
@@ -1766,187 +2228,316 @@ struct bmac2_stats {
         u32     rx_stat_gripj_hi;
 };
 
+struct mstat_stats {
+        struct {
+                /* OTE MSTAT on E3 has a bug where this register's contents are
+                 * actually tx_gtxpok + tx_gtxpf + (possibly)tx_gtxpp
+                 */
+                u32 tx_gtxpok_lo;
+                u32 tx_gtxpok_hi;
+                u32 tx_gtxpf_lo;
+                u32 tx_gtxpf_hi;
+                u32 tx_gtxpp_lo;
+                u32 tx_gtxpp_hi;
+                u32 tx_gtfcs_lo;
+                u32 tx_gtfcs_hi;
+                u32 tx_gtuca_lo;
+                u32 tx_gtuca_hi;
+                u32 tx_gtmca_lo;
+                u32 tx_gtmca_hi;
+                u32 tx_gtgca_lo;
+                u32 tx_gtgca_hi;
+                u32 tx_gtpkt_lo;
+                u32 tx_gtpkt_hi;
+                u32 tx_gt64_lo;
+                u32 tx_gt64_hi;
+                u32 tx_gt127_lo;
+                u32 tx_gt127_hi;
+                u32 tx_gt255_lo;
+                u32 tx_gt255_hi;
+                u32 tx_gt511_lo;
+                u32 tx_gt511_hi;
+                u32 tx_gt1023_lo;
+                u32 tx_gt1023_hi;
+                u32 tx_gt1518_lo;
+                u32 tx_gt1518_hi;
+                u32 tx_gt2047_lo;
+                u32 tx_gt2047_hi;
+                u32 tx_gt4095_lo;
+                u32 tx_gt4095_hi;
+                u32 tx_gt9216_lo;
+                u32 tx_gt9216_hi;
+                u32 tx_gt16383_lo;
+                u32 tx_gt16383_hi;
+                u32 tx_gtufl_lo;
+                u32 tx_gtufl_hi;
+                u32 tx_gterr_lo;
+                u32 tx_gterr_hi;
+                u32 tx_gtbyt_lo;
+                u32 tx_gtbyt_hi;
+                u32 tx_collisions_lo;
+                u32 tx_collisions_hi;
+                u32 tx_singlecollision_lo;
+                u32 tx_singlecollision_hi;
+                u32 tx_multiplecollisions_lo;
+                u32 tx_multiplecollisions_hi;
+                u32 tx_deferred_lo;
+                u32 tx_deferred_hi;
+                u32 tx_excessivecollisions_lo;
+                u32 tx_excessivecollisions_hi;
+                u32 tx_latecollisions_lo;
+                u32 tx_latecollisions_hi;
+        } stats_tx;
+
+        struct {
+                u32 rx_gr64_lo;
+                u32 rx_gr64_hi;
+                u32 rx_gr127_lo;
+                u32 rx_gr127_hi;
+                u32 rx_gr255_lo;
+                u32 rx_gr255_hi;
+                u32 rx_gr511_lo;
+                u32 rx_gr511_hi;
+                u32 rx_gr1023_lo;
+                u32 rx_gr1023_hi;
+                u32 rx_gr1518_lo;
+                u32 rx_gr1518_hi;
+                u32 rx_gr2047_lo;
+                u32 rx_gr2047_hi;
+                u32 rx_gr4095_lo;
+                u32 rx_gr4095_hi;
+                u32 rx_gr9216_lo;
+                u32 rx_gr9216_hi;
+                u32 rx_gr16383_lo;
+                u32 rx_gr16383_hi;
+                u32 rx_grpkt_lo;
+                u32 rx_grpkt_hi;
+                u32 rx_grfcs_lo;
+                u32 rx_grfcs_hi;
+                u32 rx_gruca_lo;
+                u32 rx_gruca_hi;
+                u32 rx_grmca_lo;
+                u32 rx_grmca_hi;
+                u32 rx_grbca_lo;
+                u32 rx_grbca_hi;
+                u32 rx_grxpf_lo;
+                u32 rx_grxpf_hi;
+                u32 rx_grxpp_lo;
+                u32 rx_grxpp_hi;
+                u32 rx_grxuo_lo;
+                u32 rx_grxuo_hi;
+                u32 rx_grovr_lo;
+                u32 rx_grovr_hi;
+                u32 rx_grxcf_lo;
+                u32 rx_grxcf_hi;
+                u32 rx_grflr_lo;
+                u32 rx_grflr_hi;
+                u32 rx_grpok_lo;
+                u32 rx_grpok_hi;
+                u32 rx_grbyt_lo;
+                u32 rx_grbyt_hi;
+                u32 rx_grund_lo;
+                u32 rx_grund_hi;
+                u32 rx_grfrg_lo;
+                u32 rx_grfrg_hi;
+                u32 rx_grerb_lo;
+                u32 rx_grerb_hi;
+                u32 rx_grfre_lo;
+                u32 rx_grfre_hi;
+
+                u32 rx_alignmenterrors_lo;
+                u32 rx_alignmenterrors_hi;
+                u32 rx_falsecarrier_lo;
+                u32 rx_falsecarrier_hi;
+                u32 rx_llfcmsgcnt_lo;
+                u32 rx_llfcmsgcnt_hi;
+        } stats_rx;
+};
+
 union mac_stats {
-        struct emac_stats        emac_stats;
-        struct bmac1_stats       bmac1_stats;
-        struct bmac2_stats       bmac2_stats;
+        struct emac_stats       emac_stats;
+        struct bmac1_stats      bmac1_stats;
+        struct bmac2_stats      bmac2_stats;
+        struct mstat_stats      mstat_stats;
 };
 
 
 struct mac_stx {
-    /* in_bad_octets */
-    u32     rx_stat_ifhcinbadoctets_hi;
-    u32     rx_stat_ifhcinbadoctets_lo;
-
-    /* out_bad_octets */
-    u32     tx_stat_ifhcoutbadoctets_hi;
-    u32     tx_stat_ifhcoutbadoctets_lo;
-
-    /* crc_receive_errors */
-    u32     rx_stat_dot3statsfcserrors_hi;
-    u32     rx_stat_dot3statsfcserrors_lo;
-    /* alignment_errors */
-    u32     rx_stat_dot3statsalignmenterrors_hi;
-    u32     rx_stat_dot3statsalignmenterrors_lo;
-    /* carrier_sense_errors */
-    u32     rx_stat_dot3statscarriersenseerrors_hi;
-    u32     rx_stat_dot3statscarriersenseerrors_lo;
-    /* false_carrier_detections */
-    u32     rx_stat_falsecarriererrors_hi;
-    u32     rx_stat_falsecarriererrors_lo;
-
-    /* runt_packets_received */
-    u32     rx_stat_etherstatsundersizepkts_hi;
-    u32     rx_stat_etherstatsundersizepkts_lo;
-    /* jabber_packets_received */
-    u32     rx_stat_dot3statsframestoolong_hi;
-    u32     rx_stat_dot3statsframestoolong_lo;
-
-    /* error_runt_packets_received */
-    u32     rx_stat_etherstatsfragments_hi;
-    u32     rx_stat_etherstatsfragments_lo;
-    /* error_jabber_packets_received */
-    u32     rx_stat_etherstatsjabbers_hi;
-    u32     rx_stat_etherstatsjabbers_lo;
-
-    /* control_frames_received */
-    u32     rx_stat_maccontrolframesreceived_hi;
-    u32     rx_stat_maccontrolframesreceived_lo;
-    u32     rx_stat_bmac_xpf_hi;
-    u32     rx_stat_bmac_xpf_lo;
-    u32     rx_stat_bmac_xcf_hi;
-    u32     rx_stat_bmac_xcf_lo;
-
-    /* xoff_state_entered */
-    u32     rx_stat_xoffstateentered_hi;
-    u32     rx_stat_xoffstateentered_lo;
-    /* pause_xon_frames_received */
-    u32     rx_stat_xonpauseframesreceived_hi;
-    u32     rx_stat_xonpauseframesreceived_lo;
-    /* pause_xoff_frames_received */
-    u32     rx_stat_xoffpauseframesreceived_hi;
-    u32     rx_stat_xoffpauseframesreceived_lo;
-    /* pause_xon_frames_transmitted */
-    u32     tx_stat_outxonsent_hi;
-    u32     tx_stat_outxonsent_lo;
-    /* pause_xoff_frames_transmitted */
-    u32     tx_stat_outxoffsent_hi;
-    u32     tx_stat_outxoffsent_lo;
-    /* flow_control_done */
-    u32     tx_stat_flowcontroldone_hi;
-    u32     tx_stat_flowcontroldone_lo;
-
-    /* ether_stats_collisions */
-    u32     tx_stat_etherstatscollisions_hi;
-    u32     tx_stat_etherstatscollisions_lo;
-    /* single_collision_transmit_frames */
-    u32     tx_stat_dot3statssinglecollisionframes_hi;
-    u32     tx_stat_dot3statssinglecollisionframes_lo;
-    /* multiple_collision_transmit_frames */
-    u32     tx_stat_dot3statsmultiplecollisionframes_hi;
-    u32     tx_stat_dot3statsmultiplecollisionframes_lo;
-    /* deferred_transmissions */
-    u32     tx_stat_dot3statsdeferredtransmissions_hi;
-    u32     tx_stat_dot3statsdeferredtransmissions_lo;
-    /* excessive_collision_frames */
-    u32     tx_stat_dot3statsexcessivecollisions_hi;
-    u32     tx_stat_dot3statsexcessivecollisions_lo;
-    /* late_collision_frames */
-    u32     tx_stat_dot3statslatecollisions_hi;
-    u32     tx_stat_dot3statslatecollisions_lo;
-
-    /* frames_transmitted_64_bytes */
-    u32     tx_stat_etherstatspkts64octets_hi;
-    u32     tx_stat_etherstatspkts64octets_lo;
-    /* frames_transmitted_65_127_bytes */
-    u32     tx_stat_etherstatspkts65octetsto127octets_hi;
-    u32     tx_stat_etherstatspkts65octetsto127octets_lo;
-    /* frames_transmitted_128_255_bytes */
-    u32     tx_stat_etherstatspkts128octetsto255octets_hi;
-    u32     tx_stat_etherstatspkts128octetsto255octets_lo;
-    /* frames_transmitted_256_511_bytes */
-    u32     tx_stat_etherstatspkts256octetsto511octets_hi;
-    u32     tx_stat_etherstatspkts256octetsto511octets_lo;
-    /* frames_transmitted_512_1023_bytes */
-    u32     tx_stat_etherstatspkts512octetsto1023octets_hi;
-    u32     tx_stat_etherstatspkts512octetsto1023octets_lo;
-    /* frames_transmitted_1024_1522_bytes */
-    u32     tx_stat_etherstatspkts1024octetsto1522octets_hi;
-    u32     tx_stat_etherstatspkts1024octetsto1522octets_lo;
-    /* frames_transmitted_1523_9022_bytes */
-    u32     tx_stat_etherstatspktsover1522octets_hi;
-    u32     tx_stat_etherstatspktsover1522octets_lo;
-    u32     tx_stat_bmac_2047_hi;
-    u32     tx_stat_bmac_2047_lo;
-    u32     tx_stat_bmac_4095_hi;
-    u32     tx_stat_bmac_4095_lo;
-    u32     tx_stat_bmac_9216_hi;
-    u32     tx_stat_bmac_9216_lo;
-    u32     tx_stat_bmac_16383_hi;
-    u32     tx_stat_bmac_16383_lo;
-
-    /* internal_mac_transmit_errors */
-    u32     tx_stat_dot3statsinternalmactransmiterrors_hi;
-    u32     tx_stat_dot3statsinternalmactransmiterrors_lo;
-
-    /* if_out_discards */
-    u32     tx_stat_bmac_ufl_hi;
-    u32     tx_stat_bmac_ufl_lo;
-};
-
-
-#define MAC_STX_IDX_MAX                     2
+        /* in_bad_octets */
+        u32     rx_stat_ifhcinbadoctets_hi;
+        u32     rx_stat_ifhcinbadoctets_lo;
+
+        /* out_bad_octets */
+        u32     tx_stat_ifhcoutbadoctets_hi;
+        u32     tx_stat_ifhcoutbadoctets_lo;
+
+        /* crc_receive_errors */
+        u32     rx_stat_dot3statsfcserrors_hi;
+        u32     rx_stat_dot3statsfcserrors_lo;
+        /* alignment_errors */
+        u32     rx_stat_dot3statsalignmenterrors_hi;
+        u32     rx_stat_dot3statsalignmenterrors_lo;
+        /* carrier_sense_errors */
+        u32     rx_stat_dot3statscarriersenseerrors_hi;
+        u32     rx_stat_dot3statscarriersenseerrors_lo;
+        /* false_carrier_detections */
+        u32     rx_stat_falsecarriererrors_hi;
+        u32     rx_stat_falsecarriererrors_lo;
+
+        /* runt_packets_received */
+        u32     rx_stat_etherstatsundersizepkts_hi;
+        u32     rx_stat_etherstatsundersizepkts_lo;
+        /* jabber_packets_received */
+        u32     rx_stat_dot3statsframestoolong_hi;
+        u32     rx_stat_dot3statsframestoolong_lo;
+
+        /* error_runt_packets_received */
+        u32     rx_stat_etherstatsfragments_hi;
+        u32     rx_stat_etherstatsfragments_lo;
+        /* error_jabber_packets_received */
+        u32     rx_stat_etherstatsjabbers_hi;
+        u32     rx_stat_etherstatsjabbers_lo;
+
+        /* control_frames_received */
+        u32     rx_stat_maccontrolframesreceived_hi;
+        u32     rx_stat_maccontrolframesreceived_lo;
+        u32     rx_stat_mac_xpf_hi;
+        u32     rx_stat_mac_xpf_lo;
+        u32     rx_stat_mac_xcf_hi;
+        u32     rx_stat_mac_xcf_lo;
+
+        /* xoff_state_entered */
+        u32     rx_stat_xoffstateentered_hi;
+        u32     rx_stat_xoffstateentered_lo;
+        /* pause_xon_frames_received */
+        u32     rx_stat_xonpauseframesreceived_hi;
+        u32     rx_stat_xonpauseframesreceived_lo;
+        /* pause_xoff_frames_received */
+        u32     rx_stat_xoffpauseframesreceived_hi;
+        u32     rx_stat_xoffpauseframesreceived_lo;
+        /* pause_xon_frames_transmitted */
+        u32     tx_stat_outxonsent_hi;
+        u32     tx_stat_outxonsent_lo;
+        /* pause_xoff_frames_transmitted */
+        u32     tx_stat_outxoffsent_hi;
+        u32     tx_stat_outxoffsent_lo;
+        /* flow_control_done */
+        u32     tx_stat_flowcontroldone_hi;
+        u32     tx_stat_flowcontroldone_lo;
+
+        /* ether_stats_collisions */
+        u32     tx_stat_etherstatscollisions_hi;
+        u32     tx_stat_etherstatscollisions_lo;
+        /* single_collision_transmit_frames */
+        u32     tx_stat_dot3statssinglecollisionframes_hi;
+        u32     tx_stat_dot3statssinglecollisionframes_lo;
+        /* multiple_collision_transmit_frames */
+        u32     tx_stat_dot3statsmultiplecollisionframes_hi;
+        u32     tx_stat_dot3statsmultiplecollisionframes_lo;
+        /* deferred_transmissions */
+        u32     tx_stat_dot3statsdeferredtransmissions_hi;
+        u32     tx_stat_dot3statsdeferredtransmissions_lo;
+        /* excessive_collision_frames */
+        u32     tx_stat_dot3statsexcessivecollisions_hi;
+        u32     tx_stat_dot3statsexcessivecollisions_lo;
+        /* late_collision_frames */
+        u32     tx_stat_dot3statslatecollisions_hi;
+        u32     tx_stat_dot3statslatecollisions_lo;
+
+        /* frames_transmitted_64_bytes */
+        u32     tx_stat_etherstatspkts64octets_hi;
+        u32     tx_stat_etherstatspkts64octets_lo;
+        /* frames_transmitted_65_127_bytes */
+        u32     tx_stat_etherstatspkts65octetsto127octets_hi;
+        u32     tx_stat_etherstatspkts65octetsto127octets_lo;
+        /* frames_transmitted_128_255_bytes */
+        u32     tx_stat_etherstatspkts128octetsto255octets_hi;
+        u32     tx_stat_etherstatspkts128octetsto255octets_lo;
+        /* frames_transmitted_256_511_bytes */
+        u32     tx_stat_etherstatspkts256octetsto511octets_hi;
+        u32     tx_stat_etherstatspkts256octetsto511octets_lo;
+        /* frames_transmitted_512_1023_bytes */
+        u32     tx_stat_etherstatspkts512octetsto1023octets_hi;
+        u32     tx_stat_etherstatspkts512octetsto1023octets_lo;
+        /* frames_transmitted_1024_1522_bytes */
+        u32     tx_stat_etherstatspkts1024octetsto1522octets_hi;
+        u32     tx_stat_etherstatspkts1024octetsto1522octets_lo;
+        /* frames_transmitted_1523_9022_bytes */
+        u32     tx_stat_etherstatspktsover1522octets_hi;
+        u32     tx_stat_etherstatspktsover1522octets_lo;
+        u32     tx_stat_mac_2047_hi;
+        u32     tx_stat_mac_2047_lo;
+        u32     tx_stat_mac_4095_hi;
+        u32     tx_stat_mac_4095_lo;
+        u32     tx_stat_mac_9216_hi;
+        u32     tx_stat_mac_9216_lo;
+        u32     tx_stat_mac_16383_hi;
+        u32     tx_stat_mac_16383_lo;
+
+        /* internal_mac_transmit_errors */
+        u32     tx_stat_dot3statsinternalmactransmiterrors_hi;
+        u32     tx_stat_dot3statsinternalmactransmiterrors_lo;
+
+        /* if_out_discards */
+        u32     tx_stat_mac_ufl_hi;
+        u32     tx_stat_mac_ufl_lo;
+};
+
+
+#define MAC_STX_IDX_MAX                     2
 
 struct host_port_stats {
-    u32            host_port_stats_start;
+        u32            host_port_stats_start;
 
-    struct mac_stx mac_stx[MAC_STX_IDX_MAX];
+        struct mac_stx mac_stx[MAC_STX_IDX_MAX];
 
-    u32            brb_drop_hi;
-    u32            brb_drop_lo;
+        u32            brb_drop_hi;
+        u32            brb_drop_lo;
 
-    u32            host_port_stats_end;
+        u32            host_port_stats_end;
 };
 
 
 struct host_func_stats {
-    u32     host_func_stats_start;
+        u32     host_func_stats_start;
 
-    u32     total_bytes_received_hi;
-    u32     total_bytes_received_lo;
+        u32     total_bytes_received_hi;
+        u32     total_bytes_received_lo;
 
-    u32     total_bytes_transmitted_hi;
-    u32     total_bytes_transmitted_lo;
+        u32     total_bytes_transmitted_hi;
+        u32     total_bytes_transmitted_lo;
 
-    u32     total_unicast_packets_received_hi;
-    u32     total_unicast_packets_received_lo;
+        u32     total_unicast_packets_received_hi;
+        u32     total_unicast_packets_received_lo;
 
-    u32     total_multicast_packets_received_hi;
-    u32     total_multicast_packets_received_lo;
+        u32     total_multicast_packets_received_hi;
+        u32     total_multicast_packets_received_lo;
 
-    u32     total_broadcast_packets_received_hi;
-    u32     total_broadcast_packets_received_lo;
+        u32     total_broadcast_packets_received_hi;
+        u32     total_broadcast_packets_received_lo;
 
-    u32     total_unicast_packets_transmitted_hi;
-    u32     total_unicast_packets_transmitted_lo;
+        u32     total_unicast_packets_transmitted_hi;
+        u32     total_unicast_packets_transmitted_lo;
 
-    u32     total_multicast_packets_transmitted_hi;
-    u32     total_multicast_packets_transmitted_lo;
+        u32     total_multicast_packets_transmitted_hi;
+        u32     total_multicast_packets_transmitted_lo;
 
-    u32     total_broadcast_packets_transmitted_hi;
-    u32     total_broadcast_packets_transmitted_lo;
+        u32     total_broadcast_packets_transmitted_hi;
+        u32     total_broadcast_packets_transmitted_lo;
 
-    u32     valid_bytes_received_hi;
-    u32     valid_bytes_received_lo;
+        u32     valid_bytes_received_hi;
+        u32     valid_bytes_received_lo;
 
-    u32     host_func_stats_end;
+        u32     host_func_stats_end;
 };
 
+/* VIC definitions */
+#define VICSTATST_UIF_INDEX 2
 
-#define BCM_5710_FW_MAJOR_VERSION                       6
-#define BCM_5710_FW_MINOR_VERSION                       2
-#define BCM_5710_FW_REVISION_VERSION                    9
-#define BCM_5710_FW_ENGINEERING_VERSION                 0
+#define BCM_5710_FW_MAJOR_VERSION                       7
+#define BCM_5710_FW_MINOR_VERSION                       0
+#define BCM_5710_FW_REVISION_VERSION            20
+#define BCM_5710_FW_ENGINEERING_VERSION         0
 #define BCM_5710_FW_COMPILE_FLAGS                       1
 
 
@@ -1964,6 +2555,115 @@ struct atten_sp_status_block {
 
 
 /*
+ * The eth aggregative context of Cstorm
+ */
+struct cstorm_eth_ag_context {
+        u32 __reserved0[10];
+};
+
+
+/*
+ * dmae command structure
+ */
+struct dmae_command {
+        u32 opcode;
+#define DMAE_COMMAND_SRC (0x1<<0)
+#define DMAE_COMMAND_SRC_SHIFT 0
+#define DMAE_COMMAND_DST (0x3<<1)
+#define DMAE_COMMAND_DST_SHIFT 1
+#define DMAE_COMMAND_C_DST (0x1<<3)
+#define DMAE_COMMAND_C_DST_SHIFT 3
+#define DMAE_COMMAND_C_TYPE_ENABLE (0x1<<4)
+#define DMAE_COMMAND_C_TYPE_ENABLE_SHIFT 4
+#define DMAE_COMMAND_C_TYPE_CRC_ENABLE (0x1<<5)
+#define DMAE_COMMAND_C_TYPE_CRC_ENABLE_SHIFT 5
+#define DMAE_COMMAND_C_TYPE_CRC_OFFSET (0x7<<6)
+#define DMAE_COMMAND_C_TYPE_CRC_OFFSET_SHIFT 6
+#define DMAE_COMMAND_ENDIANITY (0x3<<9)
+#define DMAE_COMMAND_ENDIANITY_SHIFT 9
+#define DMAE_COMMAND_PORT (0x1<<11)
+#define DMAE_COMMAND_PORT_SHIFT 11
+#define DMAE_COMMAND_CRC_RESET (0x1<<12)
+#define DMAE_COMMAND_CRC_RESET_SHIFT 12
+#define DMAE_COMMAND_SRC_RESET (0x1<<13)
+#define DMAE_COMMAND_SRC_RESET_SHIFT 13
+#define DMAE_COMMAND_DST_RESET (0x1<<14)
+#define DMAE_COMMAND_DST_RESET_SHIFT 14
+#define DMAE_COMMAND_E1HVN (0x3<<15)
+#define DMAE_COMMAND_E1HVN_SHIFT 15
+#define DMAE_COMMAND_DST_VN (0x3<<17)
+#define DMAE_COMMAND_DST_VN_SHIFT 17
+#define DMAE_COMMAND_C_FUNC (0x1<<19)
+#define DMAE_COMMAND_C_FUNC_SHIFT 19
+#define DMAE_COMMAND_ERR_POLICY (0x3<<20)
+#define DMAE_COMMAND_ERR_POLICY_SHIFT 20
+#define DMAE_COMMAND_RESERVED0 (0x3FF<<22)
+#define DMAE_COMMAND_RESERVED0_SHIFT 22
+        u32 src_addr_lo;
+        u32 src_addr_hi;
+        u32 dst_addr_lo;
+        u32 dst_addr_hi;
+#if defined(__BIG_ENDIAN)
+        u16 opcode_iov;
+#define DMAE_COMMAND_SRC_VFID (0x3F<<0)
+#define DMAE_COMMAND_SRC_VFID_SHIFT 0
+#define DMAE_COMMAND_SRC_VFPF (0x1<<6)
+#define DMAE_COMMAND_SRC_VFPF_SHIFT 6
+#define DMAE_COMMAND_RESERVED1 (0x1<<7)
+#define DMAE_COMMAND_RESERVED1_SHIFT 7
+#define DMAE_COMMAND_DST_VFID (0x3F<<8)
+#define DMAE_COMMAND_DST_VFID_SHIFT 8
+#define DMAE_COMMAND_DST_VFPF (0x1<<14)
+#define DMAE_COMMAND_DST_VFPF_SHIFT 14
+#define DMAE_COMMAND_RESERVED2 (0x1<<15)
+#define DMAE_COMMAND_RESERVED2_SHIFT 15
+        u16 len;
+#elif defined(__LITTLE_ENDIAN)
+        u16 len;
+        u16 opcode_iov;
+#define DMAE_COMMAND_SRC_VFID (0x3F<<0)
+#define DMAE_COMMAND_SRC_VFID_SHIFT 0
+#define DMAE_COMMAND_SRC_VFPF (0x1<<6)
+#define DMAE_COMMAND_SRC_VFPF_SHIFT 6
+#define DMAE_COMMAND_RESERVED1 (0x1<<7)
+#define DMAE_COMMAND_RESERVED1_SHIFT 7
+#define DMAE_COMMAND_DST_VFID (0x3F<<8)
+#define DMAE_COMMAND_DST_VFID_SHIFT 8
+#define DMAE_COMMAND_DST_VFPF (0x1<<14)
+#define DMAE_COMMAND_DST_VFPF_SHIFT 14
+#define DMAE_COMMAND_RESERVED2 (0x1<<15)
+#define DMAE_COMMAND_RESERVED2_SHIFT 15
+#endif
+        u32 comp_addr_lo;
+        u32 comp_addr_hi;
+        u32 comp_val;
+        u32 crc32;
+        u32 crc32_c;
+#if defined(__BIG_ENDIAN)
+        u16 crc16_c;
+        u16 crc16;
+#elif defined(__LITTLE_ENDIAN)
+        u16 crc16;
+        u16 crc16_c;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 reserved3;
+        u16 crc_t10;
+#elif defined(__LITTLE_ENDIAN)
+        u16 crc_t10;
+        u16 reserved3;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 xsum8;
+        u16 xsum16;
+#elif defined(__LITTLE_ENDIAN)
+        u16 xsum16;
+        u16 xsum8;
+#endif
+};
+
+
+/*
  * common data for all protocols
  */
 struct doorbell_hdr {
@@ -1979,33 +2679,29 @@ struct doorbell_hdr {
 };
 
 /*
- * doorbell message sent to the chip
- */
-struct doorbell {
-#if defined(__BIG_ENDIAN)
-        u16 zero_fill2;
-        u8 zero_fill1;
-        struct doorbell_hdr header;
-#elif defined(__LITTLE_ENDIAN)
-        struct doorbell_hdr header;
-        u8 zero_fill1;
-        u16 zero_fill2;
-#endif
-};
-
-
-/*
- * doorbell message sent to the chip
+ * Ethernet doorbell
  */
-struct doorbell_set_prod {
+struct eth_tx_doorbell {
 #if defined(__BIG_ENDIAN)
-        u16 prod;
-        u8 zero_fill1;
-        struct doorbell_hdr header;
+        u16 npackets;
+        u8 params;
+#define ETH_TX_DOORBELL_NUM_BDS (0x3F<<0)
+#define ETH_TX_DOORBELL_NUM_BDS_SHIFT 0
+#define ETH_TX_DOORBELL_RESERVED_TX_FIN_FLAG (0x1<<6)
+#define ETH_TX_DOORBELL_RESERVED_TX_FIN_FLAG_SHIFT 6
+#define ETH_TX_DOORBELL_SPARE (0x1<<7)
+#define ETH_TX_DOORBELL_SPARE_SHIFT 7
+        struct doorbell_hdr hdr;
 #elif defined(__LITTLE_ENDIAN)
-        struct doorbell_hdr header;
-        u8 zero_fill1;
-        u16 prod;
+        struct doorbell_hdr hdr;
+        u8 params;
+#define ETH_TX_DOORBELL_NUM_BDS (0x3F<<0)
+#define ETH_TX_DOORBELL_NUM_BDS_SHIFT 0
+#define ETH_TX_DOORBELL_RESERVED_TX_FIN_FLAG (0x1<<6)
+#define ETH_TX_DOORBELL_RESERVED_TX_FIN_FLAG_SHIFT 6
+#define ETH_TX_DOORBELL_SPARE (0x1<<7)
+#define ETH_TX_DOORBELL_SPARE_SHIFT 7
+        u16 npackets;
 #endif
 };
 
@@ -2016,7 +2712,7 @@ struct doorbell_set_prod {
 struct hc_status_block_e1x {
         __le16 index_values[HC_SB_MAX_INDICES_E1X];
         __le16 running_index[HC_SB_MAX_SM];
-        u32 rsrv;
+        __le32 rsrv[11];
 };
 
 /*
@@ -2033,7 +2729,7 @@ struct host_hc_status_block_e1x {
 struct hc_status_block_e2 {
         __le16 index_values[HC_SB_MAX_INDICES_E2];
         __le16 running_index[HC_SB_MAX_SM];
-        u32 reserved;
+        __le32 reserved[11];
 };
 
 /*
@@ -2154,6 +2850,16 @@ union igu_consprod_reg {
 
 
 /*
+ * Igu control commands
+ */
+enum igu_ctrl_cmd {
+        IGU_CTRL_CMD_TYPE_RD,
+        IGU_CTRL_CMD_TYPE_WR,
+        MAX_IGU_CTRL_CMD
+};
+
+
+/*
  * Control register for the IGU command register
  */
 struct igu_ctrl_reg {
@@ -2172,6 +2878,29 @@ struct igu_ctrl_reg {
 
 
 /*
+ * Igu interrupt command
+ */
+enum igu_int_cmd {
+        IGU_INT_ENABLE,
+        IGU_INT_DISABLE,
+        IGU_INT_NOP,
+        IGU_INT_NOP2,
+        MAX_IGU_INT_CMD
+};
+
+
+/*
+ * Igu segments
+ */
+enum igu_seg_access {
+        IGU_SEG_ACCESS_NORM,
+        IGU_SEG_ACCESS_DEF,
+        IGU_SEG_ACCESS_ATTN,
+        MAX_IGU_SEG_ACCESS
+};
+
+
+/*
  * Parser parsing flags field
  */
 struct parsing_flags {
@@ -2205,94 +2934,46 @@ struct parsing_flags {
 };
 
 
-struct regpair {
-        __le32 lo;
-        __le32 hi;
+/*
+ * Parsing flags for TCP ACK type
+ */
+enum prs_flags_ack_type {
+        PRS_FLAG_PUREACK_PIGGY,
+        PRS_FLAG_PUREACK_PURE,
+        MAX_PRS_FLAGS_ACK_TYPE
 };
 
 
 /*
- * dmae command structure
+ * Parsing flags for Ethernet address type
  */
-struct dmae_command {
-        u32 opcode;
-#define DMAE_COMMAND_SRC (0x1<<0)
-#define DMAE_COMMAND_SRC_SHIFT 0
-#define DMAE_COMMAND_DST (0x3<<1)
-#define DMAE_COMMAND_DST_SHIFT 1
-#define DMAE_COMMAND_C_DST (0x1<<3)
-#define DMAE_COMMAND_C_DST_SHIFT 3
-#define DMAE_COMMAND_C_TYPE_ENABLE (0x1<<4)
-#define DMAE_COMMAND_C_TYPE_ENABLE_SHIFT 4
-#define DMAE_COMMAND_C_TYPE_CRC_ENABLE (0x1<<5)
-#define DMAE_COMMAND_C_TYPE_CRC_ENABLE_SHIFT 5
-#define DMAE_COMMAND_C_TYPE_CRC_OFFSET (0x7<<6)
-#define DMAE_COMMAND_C_TYPE_CRC_OFFSET_SHIFT 6
-#define DMAE_COMMAND_ENDIANITY (0x3<<9)
-#define DMAE_COMMAND_ENDIANITY_SHIFT 9
-#define DMAE_COMMAND_PORT (0x1<<11)
-#define DMAE_COMMAND_PORT_SHIFT 11
-#define DMAE_COMMAND_CRC_RESET (0x1<<12)
-#define DMAE_COMMAND_CRC_RESET_SHIFT 12
-#define DMAE_COMMAND_SRC_RESET (0x1<<13)
-#define DMAE_COMMAND_SRC_RESET_SHIFT 13
-#define DMAE_COMMAND_DST_RESET (0x1<<14)
-#define DMAE_COMMAND_DST_RESET_SHIFT 14
-#define DMAE_COMMAND_E1HVN (0x3<<15)
-#define DMAE_COMMAND_E1HVN_SHIFT 15
-#define DMAE_COMMAND_DST_VN (0x3<<17)
-#define DMAE_COMMAND_DST_VN_SHIFT 17
-#define DMAE_COMMAND_C_FUNC (0x1<<19)
-#define DMAE_COMMAND_C_FUNC_SHIFT 19
-#define DMAE_COMMAND_ERR_POLICY (0x3<<20)
-#define DMAE_COMMAND_ERR_POLICY_SHIFT 20
-#define DMAE_COMMAND_RESERVED0 (0x3FF<<22)
-#define DMAE_COMMAND_RESERVED0_SHIFT 22
-        u32 src_addr_lo;
-        u32 src_addr_hi;
-        u32 dst_addr_lo;
-        u32 dst_addr_hi;
-#if defined(__BIG_ENDIAN)
-        u16 reserved1;
-        u16 len;
-#elif defined(__LITTLE_ENDIAN)
-        u16 len;
-        u16 reserved1;
-#endif
-        u32 comp_addr_lo;
-        u32 comp_addr_hi;
-        u32 comp_val;
-        u32 crc32;
-        u32 crc32_c;
-#if defined(__BIG_ENDIAN)
-        u16 crc16_c;
-        u16 crc16;
-#elif defined(__LITTLE_ENDIAN)
-        u16 crc16;
-        u16 crc16_c;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 reserved3;
-        u16 crc_t10;
-#elif defined(__LITTLE_ENDIAN)
-        u16 crc_t10;
-        u16 reserved3;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 xsum8;
-        u16 xsum16;
-#elif defined(__LITTLE_ENDIAN)
-        u16 xsum16;
-        u16 xsum8;
-#endif
+enum prs_flags_eth_addr_type {
+        PRS_FLAG_ETHTYPE_NON_UNICAST,
+        PRS_FLAG_ETHTYPE_UNICAST,
+        MAX_PRS_FLAGS_ETH_ADDR_TYPE
 };
 
 
-struct double_regpair {
-        u32 regpair0_lo;
-        u32 regpair0_hi;
-        u32 regpair1_lo;
-        u32 regpair1_hi;
+/*
+ * Parsing flags for over-ethernet protocol
+ */
+enum prs_flags_over_eth {
+        PRS_FLAG_OVERETH_UNKNOWN,
+        PRS_FLAG_OVERETH_IPV4,
+        PRS_FLAG_OVERETH_IPV6,
+        PRS_FLAG_OVERETH_LLCSNAP_UNKNOWN,
+        MAX_PRS_FLAGS_OVER_ETH
+};
+
+
+/*
+ * Parsing flags for over-IP protocol
+ */
+enum prs_flags_over_ip {
+        PRS_FLAG_OVERIP_UNKNOWN,
+        PRS_FLAG_OVERIP_TCP,
+        PRS_FLAG_OVERIP_UDP,
+        MAX_PRS_FLAGS_OVER_IP
 };
 
 
@@ -2313,54 +2994,23 @@ struct sdm_op_gen {
 #define SDM_OP_GEN_RESERVED_SHIFT 17
 };
 
-/*
- * The eth Rx Buffer Descriptor
- */
-struct eth_rx_bd {
-        __le32 addr_lo;
-        __le32 addr_hi;
-};
 
 /*
- * The eth Rx SGE Descriptor
- */
-struct eth_rx_sge {
-        __le32 addr_lo;
-        __le32 addr_hi;
-};
-
-
-
-/*
- * The eth storm context of Ustorm
- */
-struct ustorm_eth_st_context {
-        u32 reserved0[48];
-};
-
-/*
- * The eth storm context of Tstorm
+ * Timers connection context
  */
-struct tstorm_eth_st_context {
-        u32 __reserved0[28];
+struct timers_block_context {
+        u32 __reserved_0;
+        u32 __reserved_1;
+        u32 __reserved_2;
+        u32 flags;
+#define __TIMERS_BLOCK_CONTEXT_NUM_OF_ACTIVE_TIMERS (0x3<<0)
+#define __TIMERS_BLOCK_CONTEXT_NUM_OF_ACTIVE_TIMERS_SHIFT 0
+#define TIMERS_BLOCK_CONTEXT_CONN_VALID_FLG (0x1<<2)
+#define TIMERS_BLOCK_CONTEXT_CONN_VALID_FLG_SHIFT 2
+#define __TIMERS_BLOCK_CONTEXT_RESERVED0 (0x1FFFFFFF<<3)
+#define __TIMERS_BLOCK_CONTEXT_RESERVED0_SHIFT 3
 };
 
-/*
- * The eth aggregative context of Xstorm
- */
-struct xstorm_eth_ag_context {
-        u32 reserved0;
-#if defined(__BIG_ENDIAN)
-        u8 cdu_reserved;
-        u8 reserved2;
-        u16 reserved1;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved1;
-        u8 reserved2;
-        u8 cdu_reserved;
-#endif
-        u32 reserved3[30];
-};
 
 /*
  * The eth aggregative context of Tstorm
@@ -2371,14 +3021,6 @@ struct tstorm_eth_ag_context {
 
 
 /*
- * The eth aggregative context of Cstorm
- */
-struct cstorm_eth_ag_context {
-        u32 __reserved0[10];
-};
-
-
-/*
  * The eth aggregative context of Ustorm
  */
 struct ustorm_eth_ag_context {
@@ -2395,229 +3037,81 @@ struct ustorm_eth_ag_context {
         u32 __reserved3[6];
 };
 
-/*
- * Timers connection context
- */
-struct timers_block_context {
-        u32 __reserved_0;
-        u32 __reserved_1;
-        u32 __reserved_2;
-        u32 flags;
-#define __TIMERS_BLOCK_CONTEXT_NUM_OF_ACTIVE_TIMERS (0x3<<0)
-#define __TIMERS_BLOCK_CONTEXT_NUM_OF_ACTIVE_TIMERS_SHIFT 0
-#define TIMERS_BLOCK_CONTEXT_CONN_VALID_FLG (0x1<<2)
-#define TIMERS_BLOCK_CONTEXT_CONN_VALID_FLG_SHIFT 2
-#define __TIMERS_BLOCK_CONTEXT_RESERVED0 (0x1FFFFFFF<<3)
-#define __TIMERS_BLOCK_CONTEXT_RESERVED0_SHIFT 3
-};
 
 /*
- * structure for easy accessibility to assembler
- */
-struct eth_tx_bd_flags {
-        u8 as_bitfield;
-#define ETH_TX_BD_FLAGS_IP_CSUM (0x1<<0)
-#define ETH_TX_BD_FLAGS_IP_CSUM_SHIFT 0
-#define ETH_TX_BD_FLAGS_L4_CSUM (0x1<<1)
-#define ETH_TX_BD_FLAGS_L4_CSUM_SHIFT 1
-#define ETH_TX_BD_FLAGS_VLAN_MODE (0x3<<2)
-#define ETH_TX_BD_FLAGS_VLAN_MODE_SHIFT 2
-#define ETH_TX_BD_FLAGS_START_BD (0x1<<4)
-#define ETH_TX_BD_FLAGS_START_BD_SHIFT 4
-#define ETH_TX_BD_FLAGS_IS_UDP (0x1<<5)
-#define ETH_TX_BD_FLAGS_IS_UDP_SHIFT 5
-#define ETH_TX_BD_FLAGS_SW_LSO (0x1<<6)
-#define ETH_TX_BD_FLAGS_SW_LSO_SHIFT 6
-#define ETH_TX_BD_FLAGS_IPV6 (0x1<<7)
-#define ETH_TX_BD_FLAGS_IPV6_SHIFT 7
-};
-
-/*
- * The eth Tx Buffer Descriptor
- */
-struct eth_tx_start_bd {
-        __le32 addr_lo;
-        __le32 addr_hi;
-        __le16 nbd;
-        __le16 nbytes;
-        __le16 vlan_or_ethertype;
-        struct eth_tx_bd_flags bd_flags;
-        u8 general_data;
-#define ETH_TX_START_BD_HDR_NBDS (0x3F<<0)
-#define ETH_TX_START_BD_HDR_NBDS_SHIFT 0
-#define ETH_TX_START_BD_ETH_ADDR_TYPE (0x3<<6)
-#define ETH_TX_START_BD_ETH_ADDR_TYPE_SHIFT 6
-};
-
-/*
- * Tx regular BD structure
- */
-struct eth_tx_bd {
-        __le32 addr_lo;
-        __le32 addr_hi;
-        __le16 total_pkt_bytes;
-        __le16 nbytes;
-        u8 reserved[4];
-};
-
-/*
- * Tx parsing BD structure for ETH E1/E1h
- */
-struct eth_tx_parse_bd_e1x {
-        u8 global_data;
-#define ETH_TX_PARSE_BD_E1X_IP_HDR_START_OFFSET_W (0xF<<0)
-#define ETH_TX_PARSE_BD_E1X_IP_HDR_START_OFFSET_W_SHIFT 0
-#define ETH_TX_PARSE_BD_E1X_RESERVED0 (0x1<<4)
-#define ETH_TX_PARSE_BD_E1X_RESERVED0_SHIFT 4
-#define ETH_TX_PARSE_BD_E1X_PSEUDO_CS_WITHOUT_LEN (0x1<<5)
-#define ETH_TX_PARSE_BD_E1X_PSEUDO_CS_WITHOUT_LEN_SHIFT 5
-#define ETH_TX_PARSE_BD_E1X_LLC_SNAP_EN (0x1<<6)
-#define ETH_TX_PARSE_BD_E1X_LLC_SNAP_EN_SHIFT 6
-#define ETH_TX_PARSE_BD_E1X_NS_FLG (0x1<<7)
-#define ETH_TX_PARSE_BD_E1X_NS_FLG_SHIFT 7
-        u8 tcp_flags;
-#define ETH_TX_PARSE_BD_E1X_FIN_FLG (0x1<<0)
-#define ETH_TX_PARSE_BD_E1X_FIN_FLG_SHIFT 0
-#define ETH_TX_PARSE_BD_E1X_SYN_FLG (0x1<<1)
-#define ETH_TX_PARSE_BD_E1X_SYN_FLG_SHIFT 1
-#define ETH_TX_PARSE_BD_E1X_RST_FLG (0x1<<2)
-#define ETH_TX_PARSE_BD_E1X_RST_FLG_SHIFT 2
-#define ETH_TX_PARSE_BD_E1X_PSH_FLG (0x1<<3)
-#define ETH_TX_PARSE_BD_E1X_PSH_FLG_SHIFT 3
-#define ETH_TX_PARSE_BD_E1X_ACK_FLG (0x1<<4)
-#define ETH_TX_PARSE_BD_E1X_ACK_FLG_SHIFT 4
-#define ETH_TX_PARSE_BD_E1X_URG_FLG (0x1<<5)
-#define ETH_TX_PARSE_BD_E1X_URG_FLG_SHIFT 5
-#define ETH_TX_PARSE_BD_E1X_ECE_FLG (0x1<<6)
-#define ETH_TX_PARSE_BD_E1X_ECE_FLG_SHIFT 6
-#define ETH_TX_PARSE_BD_E1X_CWR_FLG (0x1<<7)
-#define ETH_TX_PARSE_BD_E1X_CWR_FLG_SHIFT 7
-        u8 ip_hlen_w;
-        s8 reserved;
-        __le16 total_hlen_w;
-        __le16 tcp_pseudo_csum;
-        __le16 lso_mss;
-        __le16 ip_id;
-        __le32 tcp_send_seq;
-};
-
-/*
- * Tx parsing BD structure for ETH E2
+ * The eth aggregative context of Xstorm
  */
-struct eth_tx_parse_bd_e2 {
-        __le16 dst_mac_addr_lo;
-        __le16 dst_mac_addr_mid;
-        __le16 dst_mac_addr_hi;
-        __le16 src_mac_addr_lo;
-        __le16 src_mac_addr_mid;
-        __le16 src_mac_addr_hi;
-        __le32 parsing_data;
-#define ETH_TX_PARSE_BD_E2_TCP_HDR_START_OFFSET_W (0x1FFF<<0)
-#define ETH_TX_PARSE_BD_E2_TCP_HDR_START_OFFSET_W_SHIFT 0
-#define ETH_TX_PARSE_BD_E2_TCP_HDR_LENGTH_DW (0xF<<13)
-#define ETH_TX_PARSE_BD_E2_TCP_HDR_LENGTH_DW_SHIFT 13
-#define ETH_TX_PARSE_BD_E2_LSO_MSS (0x3FFF<<17)
-#define ETH_TX_PARSE_BD_E2_LSO_MSS_SHIFT 17
-#define ETH_TX_PARSE_BD_E2_IPV6_WITH_EXT_HDR (0x1<<31)
-#define ETH_TX_PARSE_BD_E2_IPV6_WITH_EXT_HDR_SHIFT 31
+struct xstorm_eth_ag_context {
+        u32 reserved0;
+#if defined(__BIG_ENDIAN)
+        u8 cdu_reserved;
+        u8 reserved2;
+        u16 reserved1;
+#elif defined(__LITTLE_ENDIAN)
+        u16 reserved1;
+        u8 reserved2;
+        u8 cdu_reserved;
+#endif
+        u32 reserved3[30];
 };
 
-/*
- * The last BD in the BD memory will hold a pointer to the next BD memory
- */
-struct eth_tx_next_bd {
-        __le32 addr_lo;
-        __le32 addr_hi;
-        u8 reserved[8];
-};
 
 /*
- * union for 4 Bd types
+ * doorbell message sent to the chip
  */
-union eth_tx_bd_types {
-        struct eth_tx_start_bd start_bd;
-        struct eth_tx_bd reg_bd;
-        struct eth_tx_parse_bd_e1x parse_bd_e1x;
-        struct eth_tx_parse_bd_e2 parse_bd_e2;
-        struct eth_tx_next_bd next_bd;
+struct doorbell {
+#if defined(__BIG_ENDIAN)
+        u16 zero_fill2;
+        u8 zero_fill1;
+        struct doorbell_hdr header;
+#elif defined(__LITTLE_ENDIAN)
+        struct doorbell_hdr header;
+        u8 zero_fill1;
+        u16 zero_fill2;
+#endif
 };
 
 
 /*
- * The eth storm context of Xstorm
+ * doorbell message sent to the chip
  */
-struct xstorm_eth_st_context {
-        u32 reserved0[60];
+struct doorbell_set_prod {
+#if defined(__BIG_ENDIAN)
+        u16 prod;
+        u8 zero_fill1;
+        struct doorbell_hdr header;
+#elif defined(__LITTLE_ENDIAN)
+        struct doorbell_hdr header;
+        u8 zero_fill1;
+        u16 prod;
+#endif
 };
 
-/*
- * The eth storm context of Cstorm
- */
-struct cstorm_eth_st_context {
-        u32 __reserved0[4];
-};
 
-/*
- * Ethernet connection context
- */
-struct eth_context {
-        struct ustorm_eth_st_context ustorm_st_context;
-        struct tstorm_eth_st_context tstorm_st_context;
-        struct xstorm_eth_ag_context xstorm_ag_context;
-        struct tstorm_eth_ag_context tstorm_ag_context;
-        struct cstorm_eth_ag_context cstorm_ag_context;
-        struct ustorm_eth_ag_context ustorm_ag_context;
-        struct timers_block_context timers_context;
-        struct xstorm_eth_st_context xstorm_st_context;
-        struct cstorm_eth_st_context cstorm_st_context;
+struct regpair {
+        __le32 lo;
+        __le32 hi;
 };
 
 
 /*
- * Ethernet doorbell
+ * Classify rule opcodes in E2/E3
  */
-struct eth_tx_doorbell {
-#if defined(__BIG_ENDIAN)
-        u16 npackets;
-        u8 params;
-#define ETH_TX_DOORBELL_NUM_BDS (0x3F<<0)
-#define ETH_TX_DOORBELL_NUM_BDS_SHIFT 0
-#define ETH_TX_DOORBELL_RESERVED_TX_FIN_FLAG (0x1<<6)
-#define ETH_TX_DOORBELL_RESERVED_TX_FIN_FLAG_SHIFT 6
-#define ETH_TX_DOORBELL_SPARE (0x1<<7)
-#define ETH_TX_DOORBELL_SPARE_SHIFT 7
-        struct doorbell_hdr hdr;
-#elif defined(__LITTLE_ENDIAN)
-        struct doorbell_hdr hdr;
-        u8 params;
-#define ETH_TX_DOORBELL_NUM_BDS (0x3F<<0)
-#define ETH_TX_DOORBELL_NUM_BDS_SHIFT 0
-#define ETH_TX_DOORBELL_RESERVED_TX_FIN_FLAG (0x1<<6)
-#define ETH_TX_DOORBELL_RESERVED_TX_FIN_FLAG_SHIFT 6
-#define ETH_TX_DOORBELL_SPARE (0x1<<7)
-#define ETH_TX_DOORBELL_SPARE_SHIFT 7
-        u16 npackets;
-#endif
+enum classify_rule {
+        CLASSIFY_RULE_OPCODE_MAC,
+        CLASSIFY_RULE_OPCODE_VLAN,
+        CLASSIFY_RULE_OPCODE_PAIR,
+        MAX_CLASSIFY_RULE
 };
 
 
 /*
- * client init fc data
+ * Classify rule types in E2/E3
  */
-struct client_init_fc_data {
-        __le16 cqe_pause_thr_low;
-        __le16 cqe_pause_thr_high;
-        __le16 bd_pause_thr_low;
-        __le16 bd_pause_thr_high;
-        __le16 sge_pause_thr_low;
-        __le16 sge_pause_thr_high;
-        __le16 rx_cos_mask;
-        u8 safc_group_num;
-        u8 safc_group_en_flg;
-        u8 traffic_type;
-        u8 reserved0;
-        __le16 reserved1;
-        __le32 reserved2;
+enum classify_rule_action_type {
+        CLASSIFY_RULE_REMOVE,
+        CLASSIFY_RULE_ADD,
+        MAX_CLASSIFY_RULE_ACTION_TYPE
 };
 
 
@@ -2631,8 +3125,12 @@ struct client_init_general_data {
         u8 is_fcoe_flg;
         u8 activate_flg;
         u8 sp_client_id;
-        __le16 reserved0;
-        __le32 reserved1[2];
+        __le16 mtu;
+        u8 statistics_zero_flg;
+        u8 func_id;
+        u8 cos;
+        u8 traffic_type;
+        u32 reserved0;
 };
 
 
@@ -2640,7 +3138,13 @@ struct client_init_general_data {
  * client init rx data
  */
 struct client_init_rx_data {
-        u8 tpa_en_flg;
+        u8 tpa_en;
+#define CLIENT_INIT_RX_DATA_TPA_EN_IPV4 (0x1<<0)
+#define CLIENT_INIT_RX_DATA_TPA_EN_IPV4_SHIFT 0
+#define CLIENT_INIT_RX_DATA_TPA_EN_IPV6 (0x1<<1)
+#define CLIENT_INIT_RX_DATA_TPA_EN_IPV6_SHIFT 1
+#define CLIENT_INIT_RX_DATA_RESERVED5 (0x3F<<2)
+#define CLIENT_INIT_RX_DATA_RESERVED5_SHIFT 2
         u8 vmqueue_mode_en_flg;
         u8 extra_data_over_sgl_en_flg;
         u8 cache_line_alignment_log_size;
@@ -2655,17 +3159,46 @@ struct client_init_rx_data {
         u8 outer_vlan_removal_enable_flg;
         u8 status_block_id;
         u8 rx_sb_index_number;
-        u8 reserved0[3];
-        __le16 bd_buff_size;
+        u8 reserved0;
+        u8 max_tpa_queues;
+        u8 silent_vlan_removal_flg;
+        __le16 max_bytes_on_bd;
         __le16 sge_buff_size;
-        __le16 mtu;
+        u8 approx_mcast_engine_id;
+        u8 rss_engine_id;
         struct regpair bd_page_base;
         struct regpair sge_page_base;
         struct regpair cqe_page_base;
         u8 is_leading_rss;
         u8 is_approx_mcast;
         __le16 max_agg_size;
-        __le32 reserved2[3];
+        __le16 state;
+#define CLIENT_INIT_RX_DATA_UCAST_DROP_ALL (0x1<<0)
+#define CLIENT_INIT_RX_DATA_UCAST_DROP_ALL_SHIFT 0
+#define CLIENT_INIT_RX_DATA_UCAST_ACCEPT_ALL (0x1<<1)
+#define CLIENT_INIT_RX_DATA_UCAST_ACCEPT_ALL_SHIFT 1
+#define CLIENT_INIT_RX_DATA_UCAST_ACCEPT_UNMATCHED (0x1<<2)
+#define CLIENT_INIT_RX_DATA_UCAST_ACCEPT_UNMATCHED_SHIFT 2
+#define CLIENT_INIT_RX_DATA_MCAST_DROP_ALL (0x1<<3)
+#define CLIENT_INIT_RX_DATA_MCAST_DROP_ALL_SHIFT 3
+#define CLIENT_INIT_RX_DATA_MCAST_ACCEPT_ALL (0x1<<4)
+#define CLIENT_INIT_RX_DATA_MCAST_ACCEPT_ALL_SHIFT 4
+#define CLIENT_INIT_RX_DATA_BCAST_ACCEPT_ALL (0x1<<5)
+#define CLIENT_INIT_RX_DATA_BCAST_ACCEPT_ALL_SHIFT 5
+#define CLIENT_INIT_RX_DATA_ACCEPT_ANY_VLAN (0x1<<6)
+#define CLIENT_INIT_RX_DATA_ACCEPT_ANY_VLAN_SHIFT 6
+#define CLIENT_INIT_RX_DATA_RESERVED2 (0x1FF<<7)
+#define CLIENT_INIT_RX_DATA_RESERVED2_SHIFT 7
+        __le16 cqe_pause_thr_low;
+        __le16 cqe_pause_thr_high;
+        __le16 bd_pause_thr_low;
+        __le16 bd_pause_thr_high;
+        __le16 sge_pause_thr_low;
+        __le16 sge_pause_thr_high;
+        __le16 rx_cos_mask;
+        __le16 silent_vlan_value;
+        __le16 silent_vlan_mask;
+        __le32 reserved6[2];
 };
 
 /*
@@ -2675,11 +3208,25 @@ struct client_init_tx_data {
         u8 enforce_security_flg;
         u8 tx_status_block_id;
         u8 tx_sb_index_number;
-        u8 reserved0;
-        __le16 mtu;
-        __le16 reserved1;
+        u8 tss_leading_client_id;
+        u8 tx_switching_flg;
+        u8 anti_spoofing_flg;
+        __le16 default_vlan;
         struct regpair tx_bd_page_base;
-        __le32 reserved2[2];
+        __le16 state;
+#define CLIENT_INIT_TX_DATA_UCAST_ACCEPT_ALL (0x1<<0)
+#define CLIENT_INIT_TX_DATA_UCAST_ACCEPT_ALL_SHIFT 0
+#define CLIENT_INIT_TX_DATA_MCAST_ACCEPT_ALL (0x1<<1)
+#define CLIENT_INIT_TX_DATA_MCAST_ACCEPT_ALL_SHIFT 1
+#define CLIENT_INIT_TX_DATA_BCAST_ACCEPT_ALL (0x1<<2)
+#define CLIENT_INIT_TX_DATA_BCAST_ACCEPT_ALL_SHIFT 2
+#define CLIENT_INIT_TX_DATA_ACCEPT_ANY_VLAN (0x1<<3)
+#define CLIENT_INIT_TX_DATA_ACCEPT_ANY_VLAN_SHIFT 3
+#define CLIENT_INIT_TX_DATA_RESERVED1 (0xFFF<<4)
+#define CLIENT_INIT_TX_DATA_RESERVED1_SHIFT 4
+        u8 default_vlan_flg;
+        u8 reserved2;
+        __le32 reserved3;
 };
 
 /*
@@ -2689,7 +3236,146 @@ struct client_init_ramrod_data {
         struct client_init_general_data general;
         struct client_init_rx_data rx;
         struct client_init_tx_data tx;
-        struct client_init_fc_data fc;
+};
+
+
+/*
+ * client update ramrod data
+ */
+struct client_update_ramrod_data {
+        u8 client_id;
+        u8 func_id;
+        u8 inner_vlan_removal_enable_flg;
+        u8 inner_vlan_removal_change_flg;
+        u8 outer_vlan_removal_enable_flg;
+        u8 outer_vlan_removal_change_flg;
+        u8 anti_spoofing_enable_flg;
+        u8 anti_spoofing_change_flg;
+        u8 activate_flg;
+        u8 activate_change_flg;
+        __le16 default_vlan;
+        u8 default_vlan_enable_flg;
+        u8 default_vlan_change_flg;
+        __le16 silent_vlan_value;
+        __le16 silent_vlan_mask;
+        u8 silent_vlan_removal_flg;
+        u8 silent_vlan_change_flg;
+        __le32 echo;
+};
+
+
+/*
+ * The eth storm context of Cstorm
+ */
+struct cstorm_eth_st_context {
+        u32 __reserved0[4];
+};
+
+
+struct double_regpair {
+        u32 regpair0_lo;
+        u32 regpair0_hi;
+        u32 regpair1_lo;
+        u32 regpair1_hi;
+};
+
+
+/*
+ * Ethernet address typesm used in ethernet tx BDs
+ */
+enum eth_addr_type {
+        UNKNOWN_ADDRESS,
+        UNICAST_ADDRESS,
+        MULTICAST_ADDRESS,
+        BROADCAST_ADDRESS,
+        MAX_ETH_ADDR_TYPE
+};
+
+
+/*
+ *
+ */
+struct eth_classify_cmd_header {
+        u8 cmd_general_data;
+#define ETH_CLASSIFY_CMD_HEADER_RX_CMD (0x1<<0)
+#define ETH_CLASSIFY_CMD_HEADER_RX_CMD_SHIFT 0
+#define ETH_CLASSIFY_CMD_HEADER_TX_CMD (0x1<<1)
+#define ETH_CLASSIFY_CMD_HEADER_TX_CMD_SHIFT 1
+#define ETH_CLASSIFY_CMD_HEADER_OPCODE (0x3<<2)
+#define ETH_CLASSIFY_CMD_HEADER_OPCODE_SHIFT 2
+#define ETH_CLASSIFY_CMD_HEADER_IS_ADD (0x1<<4)
+#define ETH_CLASSIFY_CMD_HEADER_IS_ADD_SHIFT 4
+#define ETH_CLASSIFY_CMD_HEADER_RESERVED0 (0x7<<5)
+#define ETH_CLASSIFY_CMD_HEADER_RESERVED0_SHIFT 5
+        u8 func_id;
+        u8 client_id;
+        u8 reserved1;
+};
+
+
+/*
+ * header for eth classification config ramrod
+ */
+struct eth_classify_header {
+        u8 rule_cnt;
+        u8 reserved0;
+        __le16 reserved1;
+        __le32 echo;
+};
+
+
+/*
+ * Command for adding/removing a MAC classification rule
+ */
+struct eth_classify_mac_cmd {
+        struct eth_classify_cmd_header header;
+        __le32 reserved0;
+        __le16 mac_lsb;
+        __le16 mac_mid;
+        __le16 mac_msb;
+        __le16 reserved1;
+};
+
+
+/*
+ * Command for adding/removing a MAC-VLAN pair classification rule
+ */
+struct eth_classify_pair_cmd {
+        struct eth_classify_cmd_header header;
+        __le32 reserved0;
+        __le16 mac_lsb;
+        __le16 mac_mid;
+        __le16 mac_msb;
+        __le16 vlan;
+};
+
+
+/*
+ * Command for adding/removing a VLAN classification rule
+ */
+struct eth_classify_vlan_cmd {
+        struct eth_classify_cmd_header header;
+        __le32 reserved0;
+        __le32 reserved1;
+        __le16 reserved2;
+        __le16 vlan;
+};
+
+/*
+ * union for eth classification rule
+ */
+union eth_classify_rule_cmd {
+        struct eth_classify_mac_cmd mac;
+        struct eth_classify_vlan_cmd vlan;
+        struct eth_classify_pair_cmd pair;
+};
+
+/*
+ * parameters for eth classification configuration ramrod
+ */
+struct eth_classify_rules_ramrod_data {
+        struct eth_classify_header header;
+        union eth_classify_rule_cmd rules[CLASSIFY_RULES_COUNT];
 };
 
 
@@ -2697,8 +3383,45 @@ struct client_init_ramrod_data {
  * The data contain client ID need to the ramrod
  */
 struct eth_common_ramrod_data {
-        u32 client_id;
-        u32 reserved1;
+        __le32 client_id;
+        __le32 reserved1;
+};
+
+
+/*
+ * The eth storm context of Ustorm
+ */
+struct ustorm_eth_st_context {
+        u32 reserved0[52];
+};
+
+/*
+ * The eth storm context of Tstorm
+ */
+struct tstorm_eth_st_context {
+        u32 __reserved0[28];
+};
+
+/*
+ * The eth storm context of Xstorm
+ */
+struct xstorm_eth_st_context {
+        u32 reserved0[60];
+};
+
+/*
+ * Ethernet connection context
+ */
+struct eth_context {
+        struct ustorm_eth_st_context ustorm_st_context;
+        struct tstorm_eth_st_context tstorm_st_context;
+        struct xstorm_eth_ag_context xstorm_ag_context;
+        struct tstorm_eth_ag_context tstorm_ag_context;
+        struct cstorm_eth_ag_context cstorm_ag_context;
+        struct ustorm_eth_ag_context ustorm_ag_context;
+        struct timers_block_context timers_context;
+        struct xstorm_eth_st_context xstorm_st_context;
+        struct cstorm_eth_st_context cstorm_st_context;
 };
 
 
@@ -2711,24 +3434,47 @@ union eth_sgl_or_raw_data {
 };
 
 /*
+ * eth FP end aggregation CQE parameters struct
+ */
+struct eth_end_agg_rx_cqe {
+        u8 type_error_flags;
+#define ETH_END_AGG_RX_CQE_TYPE (0x3<<0)
+#define ETH_END_AGG_RX_CQE_TYPE_SHIFT 0
+#define ETH_END_AGG_RX_CQE_SGL_RAW_SEL (0x1<<2)
+#define ETH_END_AGG_RX_CQE_SGL_RAW_SEL_SHIFT 2
+#define ETH_END_AGG_RX_CQE_RESERVED0 (0x1F<<3)
+#define ETH_END_AGG_RX_CQE_RESERVED0_SHIFT 3
+        u8 reserved1;
+        u8 queue_index;
+        u8 reserved2;
+        __le32 timestamp_delta;
+        __le16 num_of_coalesced_segs;
+        __le16 pkt_len;
+        u8 pure_ack_count;
+        u8 reserved3;
+        __le16 reserved4;
+        union eth_sgl_or_raw_data sgl_or_raw_data;
+        __le32 reserved5[8];
+};
+
+
+/*
  * regular eth FP CQE parameters struct
  */
 struct eth_fast_path_rx_cqe {
         u8 type_error_flags;
-#define ETH_FAST_PATH_RX_CQE_TYPE (0x1<<0)
+#define ETH_FAST_PATH_RX_CQE_TYPE (0x3<<0)
 #define ETH_FAST_PATH_RX_CQE_TYPE_SHIFT 0
-#define ETH_FAST_PATH_RX_CQE_PHY_DECODE_ERR_FLG (0x1<<1)
-#define ETH_FAST_PATH_RX_CQE_PHY_DECODE_ERR_FLG_SHIFT 1
-#define ETH_FAST_PATH_RX_CQE_IP_BAD_XSUM_FLG (0x1<<2)
-#define ETH_FAST_PATH_RX_CQE_IP_BAD_XSUM_FLG_SHIFT 2
-#define ETH_FAST_PATH_RX_CQE_L4_BAD_XSUM_FLG (0x1<<3)
-#define ETH_FAST_PATH_RX_CQE_L4_BAD_XSUM_FLG_SHIFT 3
-#define ETH_FAST_PATH_RX_CQE_START_FLG (0x1<<4)
-#define ETH_FAST_PATH_RX_CQE_START_FLG_SHIFT 4
-#define ETH_FAST_PATH_RX_CQE_END_FLG (0x1<<5)
-#define ETH_FAST_PATH_RX_CQE_END_FLG_SHIFT 5
-#define ETH_FAST_PATH_RX_CQE_SGL_RAW_SEL (0x3<<6)
-#define ETH_FAST_PATH_RX_CQE_SGL_RAW_SEL_SHIFT 6
+#define ETH_FAST_PATH_RX_CQE_SGL_RAW_SEL (0x1<<2)
+#define ETH_FAST_PATH_RX_CQE_SGL_RAW_SEL_SHIFT 2
+#define ETH_FAST_PATH_RX_CQE_PHY_DECODE_ERR_FLG (0x1<<3)
+#define ETH_FAST_PATH_RX_CQE_PHY_DECODE_ERR_FLG_SHIFT 3
+#define ETH_FAST_PATH_RX_CQE_IP_BAD_XSUM_FLG (0x1<<4)
+#define ETH_FAST_PATH_RX_CQE_IP_BAD_XSUM_FLG_SHIFT 4
+#define ETH_FAST_PATH_RX_CQE_L4_BAD_XSUM_FLG (0x1<<5)
+#define ETH_FAST_PATH_RX_CQE_L4_BAD_XSUM_FLG_SHIFT 5
+#define ETH_FAST_PATH_RX_CQE_RESERVED0 (0x3<<6)
+#define ETH_FAST_PATH_RX_CQE_RESERVED0_SHIFT 6
         u8 status_flags;
 #define ETH_FAST_PATH_RX_CQE_RSS_HASH_TYPE (0x7<<0)
 #define ETH_FAST_PATH_RX_CQE_RSS_HASH_TYPE_SHIFT 0
@@ -2742,39 +3488,108 @@ struct eth_fast_path_rx_cqe {
 #define ETH_FAST_PATH_RX_CQE_IP_XSUM_NO_VALIDATION_FLG_SHIFT 6
 #define ETH_FAST_PATH_RX_CQE_L4_XSUM_NO_VALIDATION_FLG (0x1<<7)
 #define ETH_FAST_PATH_RX_CQE_L4_XSUM_NO_VALIDATION_FLG_SHIFT 7
-        u8 placement_offset;
         u8 queue_index;
+        u8 placement_offset;
         __le32 rss_hash_result;
         __le16 vlan_tag;
         __le16 pkt_len;
         __le16 len_on_bd;
         struct parsing_flags pars_flags;
         union eth_sgl_or_raw_data sgl_or_raw_data;
+        __le32 reserved1[8];
 };
 
 
 /*
- * The data for RSS setup ramrod
+ * Command for setting classification flags for a client
+ */
+struct eth_filter_rules_cmd {
+        u8 cmd_general_data;
+#define ETH_FILTER_RULES_CMD_RX_CMD (0x1<<0)
+#define ETH_FILTER_RULES_CMD_RX_CMD_SHIFT 0
+#define ETH_FILTER_RULES_CMD_TX_CMD (0x1<<1)
+#define ETH_FILTER_RULES_CMD_TX_CMD_SHIFT 1
+#define ETH_FILTER_RULES_CMD_RESERVED0 (0x3F<<2)
+#define ETH_FILTER_RULES_CMD_RESERVED0_SHIFT 2
+        u8 func_id;
+        u8 client_id;
+        u8 reserved1;
+        __le16 state;
+#define ETH_FILTER_RULES_CMD_UCAST_DROP_ALL (0x1<<0)
+#define ETH_FILTER_RULES_CMD_UCAST_DROP_ALL_SHIFT 0
+#define ETH_FILTER_RULES_CMD_UCAST_ACCEPT_ALL (0x1<<1)
+#define ETH_FILTER_RULES_CMD_UCAST_ACCEPT_ALL_SHIFT 1
+#define ETH_FILTER_RULES_CMD_UCAST_ACCEPT_UNMATCHED (0x1<<2)
+#define ETH_FILTER_RULES_CMD_UCAST_ACCEPT_UNMATCHED_SHIFT 2
+#define ETH_FILTER_RULES_CMD_MCAST_DROP_ALL (0x1<<3)
+#define ETH_FILTER_RULES_CMD_MCAST_DROP_ALL_SHIFT 3
+#define ETH_FILTER_RULES_CMD_MCAST_ACCEPT_ALL (0x1<<4)
+#define ETH_FILTER_RULES_CMD_MCAST_ACCEPT_ALL_SHIFT 4
+#define ETH_FILTER_RULES_CMD_BCAST_ACCEPT_ALL (0x1<<5)
+#define ETH_FILTER_RULES_CMD_BCAST_ACCEPT_ALL_SHIFT 5
+#define ETH_FILTER_RULES_CMD_ACCEPT_ANY_VLAN (0x1<<6)
+#define ETH_FILTER_RULES_CMD_ACCEPT_ANY_VLAN_SHIFT 6
+#define ETH_FILTER_RULES_CMD_RESERVED2 (0x1FF<<7)
+#define ETH_FILTER_RULES_CMD_RESERVED2_SHIFT 7
+        __le16 reserved3;
+        struct regpair reserved4;
+};
+
+
+/*
+ * parameters for eth classification filters ramrod
+ */
+struct eth_filter_rules_ramrod_data {
+        struct eth_classify_header header;
+        struct eth_filter_rules_cmd rules[FILTER_RULES_COUNT];
+};
+
+
+/*
+ * parameters for eth classification configuration ramrod
+ */
+struct eth_general_rules_ramrod_data {
+        struct eth_classify_header header;
+        union eth_classify_rule_cmd rules[CLASSIFY_RULES_COUNT];
+};
+
+
+/*
+ * The data for Halt ramrod
  */
 struct eth_halt_ramrod_data {
-        u32 client_id;
-        u32 reserved0;
+        __le32 client_id;
+        __le32 reserved0;
 };
 
+
 /*
- * The data for statistics query ramrod
+ * Command for setting multicast classification for a client
  */
-struct common_query_ramrod_data {
-#if defined(__BIG_ENDIAN)
-        u8 reserved0;
-        u8 collect_port;
-        u16 drv_counter;
-#elif defined(__LITTLE_ENDIAN)
-        u16 drv_counter;
-        u8 collect_port;
-        u8 reserved0;
-#endif
-        u32 ctr_id_vector;
+struct eth_multicast_rules_cmd {
+        u8 cmd_general_data;
+#define ETH_MULTICAST_RULES_CMD_RX_CMD (0x1<<0)
+#define ETH_MULTICAST_RULES_CMD_RX_CMD_SHIFT 0
+#define ETH_MULTICAST_RULES_CMD_TX_CMD (0x1<<1)
+#define ETH_MULTICAST_RULES_CMD_TX_CMD_SHIFT 1
+#define ETH_MULTICAST_RULES_CMD_IS_ADD (0x1<<2)
+#define ETH_MULTICAST_RULES_CMD_IS_ADD_SHIFT 2
+#define ETH_MULTICAST_RULES_CMD_RESERVED0 (0x1F<<3)
+#define ETH_MULTICAST_RULES_CMD_RESERVED0_SHIFT 3
+        u8 func_id;
+        u8 bin_id;
+        u8 engine_id;
+        __le32 reserved2;
+        struct regpair reserved3;
+};
+
+
+/*
+ * parameters for multicast classification ramrod
+ */
+struct eth_multicast_rules_ramrod_data {
+        struct eth_classify_header header;
+        struct eth_multicast_rules_cmd rules[MULTICAST_RULES_COUNT];
 };
 
 
@@ -2795,16 +3610,86 @@ union eth_ramrod_data {
 
 
 /*
+ * RSS toeplitz hash type, as reported in CQE
+ */
+enum eth_rss_hash_type {
+        DEFAULT_HASH_TYPE,
+        IPV4_HASH_TYPE,
+        TCP_IPV4_HASH_TYPE,
+        IPV6_HASH_TYPE,
+        TCP_IPV6_HASH_TYPE,
+        VLAN_PRI_HASH_TYPE,
+        E1HOV_PRI_HASH_TYPE,
+        DSCP_HASH_TYPE,
+        MAX_ETH_RSS_HASH_TYPE
+};
+
+
+/*
+ * Ethernet RSS mode
+ */
+enum eth_rss_mode {
+        ETH_RSS_MODE_DISABLED,
+        ETH_RSS_MODE_REGULAR,
+        ETH_RSS_MODE_VLAN_PRI,
+        ETH_RSS_MODE_E1HOV_PRI,
+        ETH_RSS_MODE_IP_DSCP,
+        MAX_ETH_RSS_MODE
+};
+
+
+/*
+ * parameters for RSS update ramrod (E2)
+ */
+struct eth_rss_update_ramrod_data {
+        u8 rss_engine_id;
+        u8 capabilities;
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV4_CAPABILITY (0x1<<0)
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV4_CAPABILITY_SHIFT 0
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV4_TCP_CAPABILITY (0x1<<1)
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV4_TCP_CAPABILITY_SHIFT 1
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV4_UDP_CAPABILITY (0x1<<2)
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV4_UDP_CAPABILITY_SHIFT 2
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV6_CAPABILITY (0x1<<3)
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV6_CAPABILITY_SHIFT 3
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV6_TCP_CAPABILITY (0x1<<4)
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV6_TCP_CAPABILITY_SHIFT 4
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV6_UDP_CAPABILITY (0x1<<5)
+#define ETH_RSS_UPDATE_RAMROD_DATA_IPV6_UDP_CAPABILITY_SHIFT 5
+#define ETH_RSS_UPDATE_RAMROD_DATA_UPDATE_RSS_KEY (0x1<<6)
+#define ETH_RSS_UPDATE_RAMROD_DATA_UPDATE_RSS_KEY_SHIFT 6
+#define __ETH_RSS_UPDATE_RAMROD_DATA_RESERVED0 (0x1<<7)
+#define __ETH_RSS_UPDATE_RAMROD_DATA_RESERVED0_SHIFT 7
+        u8 rss_result_mask;
+        u8 rss_mode;
+        __le32 __reserved2;
+        u8 indirection_table[T_ETH_INDIRECTION_TABLE_SIZE];
+        __le32 rss_key[T_ETH_RSS_KEY];
+        __le32 echo;
+        __le32 reserved3;
+};
+
+
+/*
+ * The eth Rx Buffer Descriptor
+ */
+struct eth_rx_bd {
+        __le32 addr_lo;
+        __le32 addr_hi;
+};
+
+
+/*
  * Eth Rx Cqe structure- general structure for ramrods
  */
 struct common_ramrod_eth_rx_cqe {
         u8 ramrod_type;
-#define COMMON_RAMROD_ETH_RX_CQE_TYPE (0x1<<0)
+#define COMMON_RAMROD_ETH_RX_CQE_TYPE (0x3<<0)
 #define COMMON_RAMROD_ETH_RX_CQE_TYPE_SHIFT 0
-#define COMMON_RAMROD_ETH_RX_CQE_ERROR (0x1<<1)
-#define COMMON_RAMROD_ETH_RX_CQE_ERROR_SHIFT 1
-#define COMMON_RAMROD_ETH_RX_CQE_RESERVED0 (0x3F<<2)
-#define COMMON_RAMROD_ETH_RX_CQE_RESERVED0_SHIFT 2
+#define COMMON_RAMROD_ETH_RX_CQE_ERROR (0x1<<2)
+#define COMMON_RAMROD_ETH_RX_CQE_ERROR_SHIFT 2
+#define COMMON_RAMROD_ETH_RX_CQE_RESERVED0 (0x1F<<3)
+#define COMMON_RAMROD_ETH_RX_CQE_RESERVED0_SHIFT 3
         u8 conn_type;
         __le16 reserved1;
         __le32 conn_and_cmd_data;
@@ -2813,7 +3698,8 @@ struct common_ramrod_eth_rx_cqe {
 #define COMMON_RAMROD_ETH_RX_CQE_CMD_ID (0xFF<<24)
 #define COMMON_RAMROD_ETH_RX_CQE_CMD_ID_SHIFT 24
         struct ramrod_data protocol_data;
-        __le32 reserved2[4];
+        __le32 echo;
+        __le32 reserved2[11];
 };
 
 /*
@@ -2822,7 +3708,7 @@ struct common_ramrod_eth_rx_cqe {
 struct eth_rx_cqe_next_page {
         __le32 addr_lo;
         __le32 addr_hi;
-        __le32 reserved[6];
+        __le32 reserved[14];
 };
 
 /*
@@ -2832,6 +3718,38 @@ union eth_rx_cqe {
         struct eth_fast_path_rx_cqe fast_path_cqe;
         struct common_ramrod_eth_rx_cqe ramrod_cqe;
         struct eth_rx_cqe_next_page next_page_cqe;
+        struct eth_end_agg_rx_cqe end_agg_cqe;
+};
+
+
+/*
+ * Values for RX ETH CQE type field
+ */
+enum eth_rx_cqe_type {
+        RX_ETH_CQE_TYPE_ETH_FASTPATH,
+        RX_ETH_CQE_TYPE_ETH_RAMROD,
+        RX_ETH_CQE_TYPE_ETH_START_AGG,
+        RX_ETH_CQE_TYPE_ETH_STOP_AGG,
+        MAX_ETH_RX_CQE_TYPE
+};
+
+
+/*
+ * Type of SGL/Raw field in ETH RX fast path CQE
+ */
+enum eth_rx_fp_sel {
+        ETH_FP_CQE_REGULAR,
+        ETH_FP_CQE_RAW,
+        MAX_ETH_RX_FP_SEL
+};
+
+
+/*
+ * The eth Rx SGE Descriptor
+ */
+struct eth_rx_sge {
+        __le32 addr_lo;
+        __le32 addr_hi;
 };
 
 
@@ -2853,14 +3771,18 @@ struct spe_hdr {
 };
 
 /*
- * Ethernet slow path element
+ * specific data for ethernet slow path element
  */
 union eth_specific_data {
         u8 protocol_data[8];
+        struct regpair client_update_ramrod_data;
         struct regpair client_init_ramrod_init_data;
         struct eth_halt_ramrod_data halt_ramrod_data;
         struct regpair update_data_addr;
         struct eth_common_ramrod_data common_ramrod_data;
+        struct regpair classify_cfg_addr;
+        struct regpair filter_cfg_addr;
+        struct regpair mcast_cfg_addr;
 };
 
 /*
@@ -2873,94 +3795,202 @@ struct eth_spe {
 
 
 /*
- * array of 13 bds as appears in the eth xstorm context
+ * Ethernet command ID for slow path elements
  */
-struct eth_tx_bds_array {
-        union eth_tx_bd_types bds[13];
+enum eth_spqe_cmd_id {
+        RAMROD_CMD_ID_ETH_UNUSED,
+        RAMROD_CMD_ID_ETH_CLIENT_SETUP,
+        RAMROD_CMD_ID_ETH_HALT,
+        RAMROD_CMD_ID_ETH_FORWARD_SETUP,
+        RAMROD_CMD_ID_ETH_TX_QUEUE_SETUP,
+        RAMROD_CMD_ID_ETH_CLIENT_UPDATE,
+        RAMROD_CMD_ID_ETH_EMPTY,
+        RAMROD_CMD_ID_ETH_TERMINATE,
+        RAMROD_CMD_ID_ETH_TPA_UPDATE,
+        RAMROD_CMD_ID_ETH_CLASSIFICATION_RULES,
+        RAMROD_CMD_ID_ETH_FILTER_RULES,
+        RAMROD_CMD_ID_ETH_MULTICAST_RULES,
+        RAMROD_CMD_ID_ETH_RSS_UPDATE,
+        RAMROD_CMD_ID_ETH_SET_MAC,
+        MAX_ETH_SPQE_CMD_ID
 };
 
 
 /*
- * Common configuration parameters per function in Tstorm
+ * eth tpa update command
  */
-struct tstorm_eth_function_common_config {
-#if defined(__BIG_ENDIAN)
-        u8 reserved1;
-        u8 rss_result_mask;
-        u16 config_flags;
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_CAPABILITY (0x1<<0)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_CAPABILITY_SHIFT 0
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_TCP_CAPABILITY (0x1<<1)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_TCP_CAPABILITY_SHIFT 1
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_CAPABILITY (0x1<<2)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_CAPABILITY_SHIFT 2
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_TCP_CAPABILITY (0x1<<3)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_TCP_CAPABILITY_SHIFT 3
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE (0x7<<4)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT 4
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA (0x1<<7)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA_SHIFT 7
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_VLAN_FILTERING_ENABLE (0x1<<8)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_VLAN_FILTERING_ENABLE_SHIFT 8
-#define __TSTORM_ETH_FUNCTION_COMMON_CONFIG_RESERVED0 (0x7F<<9)
-#define __TSTORM_ETH_FUNCTION_COMMON_CONFIG_RESERVED0_SHIFT 9
-#elif defined(__LITTLE_ENDIAN)
-        u16 config_flags;
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_CAPABILITY (0x1<<0)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_CAPABILITY_SHIFT 0
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_TCP_CAPABILITY (0x1<<1)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_TCP_CAPABILITY_SHIFT 1
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_CAPABILITY (0x1<<2)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_CAPABILITY_SHIFT 2
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_TCP_CAPABILITY (0x1<<3)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_TCP_CAPABILITY_SHIFT 3
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE (0x7<<4)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT 4
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA (0x1<<7)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA_SHIFT 7
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_VLAN_FILTERING_ENABLE (0x1<<8)
-#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_VLAN_FILTERING_ENABLE_SHIFT 8
-#define __TSTORM_ETH_FUNCTION_COMMON_CONFIG_RESERVED0 (0x7F<<9)
-#define __TSTORM_ETH_FUNCTION_COMMON_CONFIG_RESERVED0_SHIFT 9
-        u8 rss_result_mask;
-        u8 reserved1;
-#endif
-        u16 vlan_id[2];
+enum eth_tpa_update_command {
+        TPA_UPDATE_NONE_COMMAND,
+        TPA_UPDATE_ENABLE_COMMAND,
+        TPA_UPDATE_DISABLE_COMMAND,
+        MAX_ETH_TPA_UPDATE_COMMAND
 };
 
+
 /*
- * RSS idirection table update configuration
+ * Tx regular BD structure
  */
-struct rss_update_config {
-#if defined(__BIG_ENDIAN)
-        u16 toe_rss_bitmap;
-        u16 flags;
-#define RSS_UPDATE_CONFIG_ETH_UPDATE_ENABLE (0x1<<0)
-#define RSS_UPDATE_CONFIG_ETH_UPDATE_ENABLE_SHIFT 0
-#define RSS_UPDATE_CONFIG_TOE_UPDATE_ENABLE (0x1<<1)
-#define RSS_UPDATE_CONFIG_TOE_UPDATE_ENABLE_SHIFT 1
-#define __RSS_UPDATE_CONFIG_RESERVED0 (0x3FFF<<2)
-#define __RSS_UPDATE_CONFIG_RESERVED0_SHIFT 2
-#elif defined(__LITTLE_ENDIAN)
-        u16 flags;
-#define RSS_UPDATE_CONFIG_ETH_UPDATE_ENABLE (0x1<<0)
-#define RSS_UPDATE_CONFIG_ETH_UPDATE_ENABLE_SHIFT 0
-#define RSS_UPDATE_CONFIG_TOE_UPDATE_ENABLE (0x1<<1)
-#define RSS_UPDATE_CONFIG_TOE_UPDATE_ENABLE_SHIFT 1
-#define __RSS_UPDATE_CONFIG_RESERVED0 (0x3FFF<<2)
-#define __RSS_UPDATE_CONFIG_RESERVED0_SHIFT 2
-        u16 toe_rss_bitmap;
-#endif
-        u32 reserved1;
+struct eth_tx_bd {
+        __le32 addr_lo;
+        __le32 addr_hi;
+        __le16 total_pkt_bytes;
+        __le16 nbytes;
+        u8 reserved[4];
+};
+
+
+/*
+ * structure for easy accessibility to assembler
+ */
+struct eth_tx_bd_flags {
+        u8 as_bitfield;
+#define ETH_TX_BD_FLAGS_IP_CSUM (0x1<<0)
+#define ETH_TX_BD_FLAGS_IP_CSUM_SHIFT 0
+#define ETH_TX_BD_FLAGS_L4_CSUM (0x1<<1)
+#define ETH_TX_BD_FLAGS_L4_CSUM_SHIFT 1
+#define ETH_TX_BD_FLAGS_VLAN_MODE (0x3<<2)
+#define ETH_TX_BD_FLAGS_VLAN_MODE_SHIFT 2
+#define ETH_TX_BD_FLAGS_START_BD (0x1<<4)
+#define ETH_TX_BD_FLAGS_START_BD_SHIFT 4
+#define ETH_TX_BD_FLAGS_IS_UDP (0x1<<5)
+#define ETH_TX_BD_FLAGS_IS_UDP_SHIFT 5
+#define ETH_TX_BD_FLAGS_SW_LSO (0x1<<6)
+#define ETH_TX_BD_FLAGS_SW_LSO_SHIFT 6
+#define ETH_TX_BD_FLAGS_IPV6 (0x1<<7)
+#define ETH_TX_BD_FLAGS_IPV6_SHIFT 7
+};
+
+/*
+ * The eth Tx Buffer Descriptor
+ */
+struct eth_tx_start_bd {
+        __le32 addr_lo;
+        __le32 addr_hi;
+        __le16 nbd;
+        __le16 nbytes;
+        __le16 vlan_or_ethertype;
+        struct eth_tx_bd_flags bd_flags;
+        u8 general_data;
+#define ETH_TX_START_BD_HDR_NBDS (0xF<<0)
+#define ETH_TX_START_BD_HDR_NBDS_SHIFT 0
+#define ETH_TX_START_BD_FORCE_VLAN_MODE (0x1<<4)
+#define ETH_TX_START_BD_FORCE_VLAN_MODE_SHIFT 4
+#define ETH_TX_START_BD_RESREVED (0x1<<5)
+#define ETH_TX_START_BD_RESREVED_SHIFT 5
+#define ETH_TX_START_BD_ETH_ADDR_TYPE (0x3<<6)
+#define ETH_TX_START_BD_ETH_ADDR_TYPE_SHIFT 6
+};
+
+/*
+ * Tx parsing BD structure for ETH E1/E1h
+ */
+struct eth_tx_parse_bd_e1x {
+        u8 global_data;
+#define ETH_TX_PARSE_BD_E1X_IP_HDR_START_OFFSET_W (0xF<<0)
+#define ETH_TX_PARSE_BD_E1X_IP_HDR_START_OFFSET_W_SHIFT 0
+#define ETH_TX_PARSE_BD_E1X_RESERVED0 (0x1<<4)
+#define ETH_TX_PARSE_BD_E1X_RESERVED0_SHIFT 4
+#define ETH_TX_PARSE_BD_E1X_PSEUDO_CS_WITHOUT_LEN (0x1<<5)
+#define ETH_TX_PARSE_BD_E1X_PSEUDO_CS_WITHOUT_LEN_SHIFT 5
+#define ETH_TX_PARSE_BD_E1X_LLC_SNAP_EN (0x1<<6)
+#define ETH_TX_PARSE_BD_E1X_LLC_SNAP_EN_SHIFT 6
+#define ETH_TX_PARSE_BD_E1X_NS_FLG (0x1<<7)
+#define ETH_TX_PARSE_BD_E1X_NS_FLG_SHIFT 7
+        u8 tcp_flags;
+#define ETH_TX_PARSE_BD_E1X_FIN_FLG (0x1<<0)
+#define ETH_TX_PARSE_BD_E1X_FIN_FLG_SHIFT 0
+#define ETH_TX_PARSE_BD_E1X_SYN_FLG (0x1<<1)
+#define ETH_TX_PARSE_BD_E1X_SYN_FLG_SHIFT 1
+#define ETH_TX_PARSE_BD_E1X_RST_FLG (0x1<<2)
+#define ETH_TX_PARSE_BD_E1X_RST_FLG_SHIFT 2
+#define ETH_TX_PARSE_BD_E1X_PSH_FLG (0x1<<3)
+#define ETH_TX_PARSE_BD_E1X_PSH_FLG_SHIFT 3
+#define ETH_TX_PARSE_BD_E1X_ACK_FLG (0x1<<4)
+#define ETH_TX_PARSE_BD_E1X_ACK_FLG_SHIFT 4
+#define ETH_TX_PARSE_BD_E1X_URG_FLG (0x1<<5)
+#define ETH_TX_PARSE_BD_E1X_URG_FLG_SHIFT 5
+#define ETH_TX_PARSE_BD_E1X_ECE_FLG (0x1<<6)
+#define ETH_TX_PARSE_BD_E1X_ECE_FLG_SHIFT 6
+#define ETH_TX_PARSE_BD_E1X_CWR_FLG (0x1<<7)
+#define ETH_TX_PARSE_BD_E1X_CWR_FLG_SHIFT 7
+        u8 ip_hlen_w;
+        s8 reserved;
+        __le16 total_hlen_w;
+        __le16 tcp_pseudo_csum;
+        __le16 lso_mss;
+        __le16 ip_id;
+        __le32 tcp_send_seq;
+};
+
+/*
+ * Tx parsing BD structure for ETH E2
+ */
+struct eth_tx_parse_bd_e2 {
+        __le16 dst_mac_addr_lo;
+        __le16 dst_mac_addr_mid;
+        __le16 dst_mac_addr_hi;
+        __le16 src_mac_addr_lo;
+        __le16 src_mac_addr_mid;
+        __le16 src_mac_addr_hi;
+        __le32 parsing_data;
+#define ETH_TX_PARSE_BD_E2_TCP_HDR_START_OFFSET_W (0x1FFF<<0)
+#define ETH_TX_PARSE_BD_E2_TCP_HDR_START_OFFSET_W_SHIFT 0
+#define ETH_TX_PARSE_BD_E2_TCP_HDR_LENGTH_DW (0xF<<13)
+#define ETH_TX_PARSE_BD_E2_TCP_HDR_LENGTH_DW_SHIFT 13
+#define ETH_TX_PARSE_BD_E2_LSO_MSS (0x3FFF<<17)
+#define ETH_TX_PARSE_BD_E2_LSO_MSS_SHIFT 17
+#define ETH_TX_PARSE_BD_E2_IPV6_WITH_EXT_HDR (0x1<<31)
+#define ETH_TX_PARSE_BD_E2_IPV6_WITH_EXT_HDR_SHIFT 31
+};
+
+/*
+ * The last BD in the BD memory will hold a pointer to the next BD memory
+ */
+struct eth_tx_next_bd {
+        __le32 addr_lo;
+        __le32 addr_hi;
+        u8 reserved[8];
+};
+
+/*
+ * union for 4 Bd types
+ */
+union eth_tx_bd_types {
+        struct eth_tx_start_bd start_bd;
+        struct eth_tx_bd reg_bd;
+        struct eth_tx_parse_bd_e1x parse_bd_e1x;
+        struct eth_tx_parse_bd_e2 parse_bd_e2;
+        struct eth_tx_next_bd next_bd;
+};
+
+/*
+ * array of 13 bds as appears in the eth xstorm context
+ */
+struct eth_tx_bds_array {
+        union eth_tx_bd_types bds[13];
 };
 
+
 /*
- * parameters for eth update ramrod
+ * VLAN mode on TX BDs
  */
-struct eth_update_ramrod_data {
-        struct tstorm_eth_function_common_config func_config;
-        u8 indirectionTable[128];
-        struct rss_update_config rss_config;
+enum eth_tx_vlan_type {
+        X_ETH_NO_VLAN,
+        X_ETH_OUTBAND_VLAN,
+        X_ETH_INBAND_VLAN,
+        X_ETH_FW_ADDED_VLAN,
+        MAX_ETH_TX_VLAN_TYPE
+};
+
+
+/*
+ * Ethernet VLAN filtering mode in E1x
+ */
+enum eth_vlan_filter_mode {
+        ETH_VLAN_FILTER_ANY_VLAN,
+        ETH_VLAN_FILTER_SPECIFIC_VLAN,
+        ETH_VLAN_FILTER_CLASSIFY,
+        MAX_ETH_VLAN_FILTER_MODE
 };
 
 
@@ -2970,9 +4000,8 @@ struct eth_update_ramrod_data {
 struct mac_configuration_hdr {
         u8 length;
         u8 offset;
-        u16 client_id;
-        u16 echo;
-        u16 reserved1;
+        __le16 client_id;
+        __le32 echo;
 };
 
 /*
@@ -2997,8 +4026,8 @@ struct mac_configuration_entry {
 #define MAC_CONFIGURATION_ENTRY_BROADCAST_SHIFT 5
 #define MAC_CONFIGURATION_ENTRY_RESERVED1 (0x3<<6)
 #define MAC_CONFIGURATION_ENTRY_RESERVED1_SHIFT 6
-        u16 reserved0;
-        u32 clients_bit_vector;
+        __le16 reserved0;
+        __le32 clients_bit_vector;
 };
 
 /*
@@ -3011,6 +4040,36 @@ struct mac_configuration_cmd {
 
 
 /*
+ * Set-MAC command type (in E1x)
+ */
+enum set_mac_action_type {
+        T_ETH_MAC_COMMAND_INVALIDATE,
+        T_ETH_MAC_COMMAND_SET,
+        MAX_SET_MAC_ACTION_TYPE
+};
+
+
+/*
+ * tpa update ramrod data
+ */
+struct tpa_update_ramrod_data {
+        u8 update_ipv4;
+        u8 update_ipv6;
+        u8 client_id;
+        u8 max_tpa_queues;
+        u8 max_sges_for_packet;
+        u8 complete_on_both_clients;
+        __le16 reserved1;
+        __le16 sge_buff_size;
+        __le16 max_agg_size;
+        __le32 sge_page_base_lo;
+        __le32 sge_page_base_hi;
+        __le16 sge_pause_thr_low;
+        __le16 sge_pause_thr_high;
+};
+
+
+/*
  * approximate-match multicast filtering for E1H per function in Tstorm
  */
 struct tstorm_eth_approximate_match_multicast_filtering {
@@ -3019,35 +4078,50 @@ struct tstorm_eth_approximate_match_multicast_filtering {
 
 
 /*
+ * Common configuration parameters per function in Tstorm
+ */
+struct tstorm_eth_function_common_config {
+        __le16 config_flags;
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_CAPABILITY (0x1<<0)
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_CAPABILITY_SHIFT 0
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_TCP_CAPABILITY (0x1<<1)
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV4_TCP_CAPABILITY_SHIFT 1
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_CAPABILITY (0x1<<2)
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_CAPABILITY_SHIFT 2
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_TCP_CAPABILITY (0x1<<3)
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_IPV6_TCP_CAPABILITY_SHIFT 3
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE (0x7<<4)
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT 4
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_VLAN_FILTERING_ENABLE (0x1<<7)
+#define TSTORM_ETH_FUNCTION_COMMON_CONFIG_VLAN_FILTERING_ENABLE_SHIFT 7
+#define __TSTORM_ETH_FUNCTION_COMMON_CONFIG_RESERVED0 (0xFF<<8)
+#define __TSTORM_ETH_FUNCTION_COMMON_CONFIG_RESERVED0_SHIFT 8
+        u8 rss_result_mask;
+        u8 reserved1;
+        __le16 vlan_id[2];
+};
+
+
+/*
  * MAC filtering configuration parameters per port in Tstorm
  */
 struct tstorm_eth_mac_filter_config {
-        u32 ucast_drop_all;
-        u32 ucast_accept_all;
-        u32 mcast_drop_all;
-        u32 mcast_accept_all;
-        u32 bcast_drop_all;
-        u32 bcast_accept_all;
-        u32 vlan_filter[2];
-        u32 unmatched_unicast;
-        u32 reserved;
+        __le32 ucast_drop_all;
+        __le32 ucast_accept_all;
+        __le32 mcast_drop_all;
+        __le32 mcast_accept_all;
+        __le32 bcast_accept_all;
+        __le32 vlan_filter[2];
+        __le32 unmatched_unicast;
 };
 
 
 /*
- * common flag to indicate existence of TPA.
+ * tx only queue init ramrod data
  */
-struct tstorm_eth_tpa_exist {
-#if defined(__BIG_ENDIAN)
-        u16 reserved1;
-        u8 reserved0;
-        u8 tpa_exist;
-#elif defined(__LITTLE_ENDIAN)
-        u8 tpa_exist;
-        u8 reserved0;
-        u16 reserved1;
-#endif
-        u32 reserved2;
+struct tx_queue_init_ramrod_data {
+        struct client_init_general_data general;
+        struct client_init_tx_data tx;
 };
 
 
@@ -3077,10 +4151,8 @@ struct ustorm_eth_rx_producers {
  */
 struct cfc_del_event_data {
         u32 cid;
-        u8 error;
-        u8 reserved0;
-        u16 reserved1;
-        u32 reserved2;
+        u32 reserved0;
+        u32 reserved1;
 };
 
 
@@ -3088,22 +4160,18 @@ struct cfc_del_event_data {
  * per-port SAFC demo variables
  */
 struct cmng_flags_per_port {
-        u8 con_number[NUM_OF_PROTOCOLS];
         u32 cmng_enables;
 #define CMNG_FLAGS_PER_PORT_FAIRNESS_VN (0x1<<0)
 #define CMNG_FLAGS_PER_PORT_FAIRNESS_VN_SHIFT 0
 #define CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN (0x1<<1)
 #define CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN_SHIFT 1
-#define CMNG_FLAGS_PER_PORT_FAIRNESS_PROTOCOL (0x1<<2)
-#define CMNG_FLAGS_PER_PORT_FAIRNESS_PROTOCOL_SHIFT 2
-#define CMNG_FLAGS_PER_PORT_RATE_SHAPING_PROTOCOL (0x1<<3)
-#define CMNG_FLAGS_PER_PORT_RATE_SHAPING_PROTOCOL_SHIFT 3
-#define CMNG_FLAGS_PER_PORT_FAIRNESS_COS (0x1<<4)
-#define CMNG_FLAGS_PER_PORT_FAIRNESS_COS_SHIFT 4
-#define CMNG_FLAGS_PER_PORT_FAIRNESS_COS_MODE (0x1<<5)
-#define CMNG_FLAGS_PER_PORT_FAIRNESS_COS_MODE_SHIFT 5
-#define __CMNG_FLAGS_PER_PORT_RESERVED0 (0x3FFFFFF<<6)
-#define __CMNG_FLAGS_PER_PORT_RESERVED0_SHIFT 6
+#define CMNG_FLAGS_PER_PORT_FAIRNESS_COS (0x1<<2)
+#define CMNG_FLAGS_PER_PORT_FAIRNESS_COS_SHIFT 2
+#define CMNG_FLAGS_PER_PORT_FAIRNESS_COS_MODE (0x1<<3)
+#define CMNG_FLAGS_PER_PORT_FAIRNESS_COS_MODE_SHIFT 3
+#define __CMNG_FLAGS_PER_PORT_RESERVED0 (0xFFFFFFF<<4)
+#define __CMNG_FLAGS_PER_PORT_RESERVED0_SHIFT 4
+        u32 __reserved1;
 };
 
 
@@ -3122,6 +4190,7 @@ struct fairness_vars_per_port {
         u32 upper_bound;
         u32 fair_threshold;
         u32 fairness_timeout;
+        u32 reserved0;
 };
 
 /*
@@ -3138,65 +4207,65 @@ struct safc_struct_per_port {
         u16 __reserved1;
 #endif
         u8 cos_to_traffic_types[MAX_COS_NUMBER];
-        u32 __reserved2;
         u16 cos_to_pause_mask[NUM_OF_SAFC_BITS];
 };
 
 /*
- * per-port PFC variables
+ * Per-port congestion management variables
  */
-struct pfc_struct_per_port {
-        u8 priority_to_traffic_types[MAX_PFC_PRIORITIES];
-#if defined(__BIG_ENDIAN)
-        u16 pfc_pause_quanta_in_nanosec;
-        u8 __reserved0;
-        u8 priority_non_pausable_mask;
-#elif defined(__LITTLE_ENDIAN)
-        u8 priority_non_pausable_mask;
-        u8 __reserved0;
-        u16 pfc_pause_quanta_in_nanosec;
-#endif
+struct cmng_struct_per_port {
+        struct rate_shaping_vars_per_port rs_vars;
+        struct fairness_vars_per_port fair_vars;
+        struct safc_struct_per_port safc_vars;
+        struct cmng_flags_per_port flags;
 };
 
+
 /*
- * Priority and cos
+ * Protocol-common command ID for slow path elements
  */
-struct priority_cos {
-#if defined(__BIG_ENDIAN)
-        u16 reserved1;
-        u8 cos;
-        u8 priority;
-#elif defined(__LITTLE_ENDIAN)
-        u8 priority;
-        u8 cos;
-        u16 reserved1;
-#endif
-        u32 reserved2;
+enum common_spqe_cmd_id {
+        RAMROD_CMD_ID_COMMON_UNUSED,
+        RAMROD_CMD_ID_COMMON_FUNCTION_START,
+        RAMROD_CMD_ID_COMMON_FUNCTION_STOP,
+        RAMROD_CMD_ID_COMMON_CFC_DEL,
+        RAMROD_CMD_ID_COMMON_CFC_DEL_WB,
+        RAMROD_CMD_ID_COMMON_STAT_QUERY,
+        RAMROD_CMD_ID_COMMON_STOP_TRAFFIC,
+        RAMROD_CMD_ID_COMMON_START_TRAFFIC,
+        RAMROD_CMD_ID_COMMON_RESERVED1,
+        RAMROD_CMD_ID_COMMON_RESERVED2,
+        MAX_COMMON_SPQE_CMD_ID
 };
 
+
 /*
- * Per-port congestion management variables
+ * Per-protocol connection types
  */
-struct cmng_struct_per_port {
-        struct rate_shaping_vars_per_port rs_vars;
-        struct fairness_vars_per_port fair_vars;
-        struct safc_struct_per_port safc_vars;
-        struct pfc_struct_per_port pfc_vars;
-#if defined(__BIG_ENDIAN)
-        u16 __reserved1;
-        u8 dcb_enabled;
-        u8 llfc_mode;
-#elif defined(__LITTLE_ENDIAN)
-        u8 llfc_mode;
-        u8 dcb_enabled;
-        u16 __reserved1;
-#endif
-        struct priority_cos
-                traffic_type_to_priority_cos[MAX_PFC_TRAFFIC_TYPES];
-        struct cmng_flags_per_port flags;
+enum connection_type {
+        ETH_CONNECTION_TYPE,
+        TOE_CONNECTION_TYPE,
+        RDMA_CONNECTION_TYPE,
+        ISCSI_CONNECTION_TYPE,
+        FCOE_CONNECTION_TYPE,
+        RESERVED_CONNECTION_TYPE_0,
+        RESERVED_CONNECTION_TYPE_1,
+        RESERVED_CONNECTION_TYPE_2,
+        NONE_CONNECTION_TYPE,
+        MAX_CONNECTION_TYPE
 };
 
 
+/*
+ * Cos modes
+ */
+enum cos_mode {
+        OVERRIDE_COS,
+        STATIC_COS,
+        FW_WRR,
+        MAX_COS_MODE
+};
+
 
 /*
  * Dynamic HC counters set by the driver
@@ -3213,126 +4282,174 @@ struct cstorm_queue_zone_data {
         struct regpair reserved[2];
 };
 
+
 /*
- * Dynamic host coalescing init parameters
+ * Vf-PF channel data in cstorm ram (non-triggered zone)
  */
-struct dynamic_hc_config {
-        u32 threshold[3];
-        u8 shift_per_protocol[HC_SB_MAX_DYNAMIC_INDICES];
-        u8 hc_timeout0[HC_SB_MAX_DYNAMIC_INDICES];
-        u8 hc_timeout1[HC_SB_MAX_DYNAMIC_INDICES];
-        u8 hc_timeout2[HC_SB_MAX_DYNAMIC_INDICES];
-        u8 hc_timeout3[HC_SB_MAX_DYNAMIC_INDICES];
+struct vf_pf_channel_zone_data {
+        u32 msg_addr_lo;
+        u32 msg_addr_hi;
 };
 
-
 /*
- * Protocol-common statistics collected by the Xstorm (per client)
+ * zone for VF non-triggered data
  */
-struct xstorm_per_client_stats {
-        __le32 reserved0;
-        __le32 unicast_pkts_sent;
-        struct regpair unicast_bytes_sent;
-        struct regpair multicast_bytes_sent;
-        __le32 multicast_pkts_sent;
-        __le32 broadcast_pkts_sent;
-        struct regpair broadcast_bytes_sent;
-        __le16 stats_counter;
-        __le16 reserved1;
-        __le32 reserved2;
+struct non_trigger_vf_zone {
+        struct vf_pf_channel_zone_data vf_pf_channel;
 };
 
 /*
- * Common statistics collected by the Xstorm (per port)
+ * Vf-PF channel trigger zone in cstorm ram
  */
-struct xstorm_common_stats {
-        struct xstorm_per_client_stats client_statistics[MAX_STAT_COUNTER_ID];
+struct vf_pf_channel_zone_trigger {
+        u8 addr_valid;
 };
 
 /*
- * Protocol-common statistics collected by the Tstorm (per port)
+ * zone that triggers the in-bound interrupt
  */
-struct tstorm_per_port_stats {
-        __le32 mac_filter_discard;
-        __le32 xxoverflow_discard;
-        __le32 brb_truncate_discard;
-        __le32 mac_discard;
+struct trigger_vf_zone {
+#if defined(__BIG_ENDIAN)
+        u16 reserved1;
+        u8 reserved0;
+        struct vf_pf_channel_zone_trigger vf_pf_channel;
+#elif defined(__LITTLE_ENDIAN)
+        struct vf_pf_channel_zone_trigger vf_pf_channel;
+        u8 reserved0;
+        u16 reserved1;
+#endif
+        u32 reserved2;
 };
 
 /*
- * Protocol-common statistics collected by the Tstorm (per client)
+ * zone B per-VF data
  */
-struct tstorm_per_client_stats {
-        struct regpair rcv_unicast_bytes;
-        struct regpair rcv_broadcast_bytes;
-        struct regpair rcv_multicast_bytes;
-        struct regpair rcv_error_bytes;
-        __le32 checksum_discard;
-        __le32 packets_too_big_discard;
-        __le32 rcv_unicast_pkts;
-        __le32 rcv_broadcast_pkts;
-        __le32 rcv_multicast_pkts;
-        __le32 no_buff_discard;
-        __le32 ttl0_discard;
-        __le16 stats_counter;
-        __le16 reserved0;
+struct cstorm_vf_zone_data {
+        struct non_trigger_vf_zone non_trigger;
+        struct trigger_vf_zone trigger;
 };
 
+
 /*
- * Protocol-common statistics collected by the Tstorm
+ * Dynamic host coalescing init parameters, per state machine
  */
-struct tstorm_common_stats {
-        struct tstorm_per_port_stats port_statistics;
-        struct tstorm_per_client_stats client_statistics[MAX_STAT_COUNTER_ID];
+struct dynamic_hc_sm_config {
+        u32 threshold[3];
+        u8 shift_per_protocol[HC_SB_MAX_DYNAMIC_INDICES];
+        u8 hc_timeout0[HC_SB_MAX_DYNAMIC_INDICES];
+        u8 hc_timeout1[HC_SB_MAX_DYNAMIC_INDICES];
+        u8 hc_timeout2[HC_SB_MAX_DYNAMIC_INDICES];
+        u8 hc_timeout3[HC_SB_MAX_DYNAMIC_INDICES];
 };
 
 /*
- * Protocol-common statistics collected by the Ustorm (per client)
+ * Dynamic host coalescing init parameters
  */
-struct ustorm_per_client_stats {
-        struct regpair ucast_no_buff_bytes;
-        struct regpair mcast_no_buff_bytes;
-        struct regpair bcast_no_buff_bytes;
-        __le32 ucast_no_buff_pkts;
-        __le32 mcast_no_buff_pkts;
-        __le32 bcast_no_buff_pkts;
-        __le16 stats_counter;
-        __le16 reserved0;
+struct dynamic_hc_config {
+        struct dynamic_hc_sm_config sm_config[HC_SB_MAX_SM];
+};
+
+
+struct e2_integ_data {
+#if defined(__BIG_ENDIAN)
+        u8 flags;
+#define E2_INTEG_DATA_TESTING_EN (0x1<<0)
+#define E2_INTEG_DATA_TESTING_EN_SHIFT 0
+#define E2_INTEG_DATA_LB_TX (0x1<<1)
+#define E2_INTEG_DATA_LB_TX_SHIFT 1
+#define E2_INTEG_DATA_COS_TX (0x1<<2)
+#define E2_INTEG_DATA_COS_TX_SHIFT 2
+#define E2_INTEG_DATA_OPPORTUNISTICQM (0x1<<3)
+#define E2_INTEG_DATA_OPPORTUNISTICQM_SHIFT 3
+#define E2_INTEG_DATA_DPMTESTRELEASEDQ (0x1<<4)
+#define E2_INTEG_DATA_DPMTESTRELEASEDQ_SHIFT 4
+#define E2_INTEG_DATA_RESERVED (0x7<<5)
+#define E2_INTEG_DATA_RESERVED_SHIFT 5
+        u8 cos;
+        u8 voq;
+        u8 pbf_queue;
+#elif defined(__LITTLE_ENDIAN)
+        u8 pbf_queue;
+        u8 voq;
+        u8 cos;
+        u8 flags;
+#define E2_INTEG_DATA_TESTING_EN (0x1<<0)
+#define E2_INTEG_DATA_TESTING_EN_SHIFT 0
+#define E2_INTEG_DATA_LB_TX (0x1<<1)
+#define E2_INTEG_DATA_LB_TX_SHIFT 1
+#define E2_INTEG_DATA_COS_TX (0x1<<2)
+#define E2_INTEG_DATA_COS_TX_SHIFT 2
+#define E2_INTEG_DATA_OPPORTUNISTICQM (0x1<<3)
+#define E2_INTEG_DATA_OPPORTUNISTICQM_SHIFT 3
+#define E2_INTEG_DATA_DPMTESTRELEASEDQ (0x1<<4)
+#define E2_INTEG_DATA_DPMTESTRELEASEDQ_SHIFT 4
+#define E2_INTEG_DATA_RESERVED (0x7<<5)
+#define E2_INTEG_DATA_RESERVED_SHIFT 5
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 reserved3;
+        u8 reserved2;
+        u8 ramEn;
+#elif defined(__LITTLE_ENDIAN)
+        u8 ramEn;
+        u8 reserved2;
+        u16 reserved3;
+#endif
 };
 
+
 /*
- * Protocol-common statistics collected by the Ustorm
+ * set mac event data
  */
-struct ustorm_common_stats {
-        struct ustorm_per_client_stats client_statistics[MAX_STAT_COUNTER_ID];
+struct eth_event_data {
+        u32 echo;
+        u32 reserved0;
+        u32 reserved1;
 };
 
+
 /*
- * Eth statistics query structure for the eth_stats_query ramrod
+ * pf-vf event data
  */
-struct eth_stats_query {
-        struct xstorm_common_stats xstorm_common;
-        struct tstorm_common_stats tstorm_common;
-        struct ustorm_common_stats ustorm_common;
+struct vf_pf_event_data {
+        u8 vf_id;
+        u8 reserved0;
+        u16 reserved1;
+        u32 msg_addr_lo;
+        u32 msg_addr_hi;
 };
 
+/*
+ * VF FLR event data
+ */
+struct vf_flr_event_data {
+        u8 vf_id;
+        u8 reserved0;
+        u16 reserved1;
+        u32 reserved2;
+        u32 reserved3;
+};
 
 /*
- * set mac event data
+ * malicious VF event data
  */
-struct set_mac_event_data {
-        u16 echo;
-        u16 reserved0;
-        u32 reserved1;
+struct malicious_vf_event_data {
+        u8 vf_id;
+        u8 reserved0;
+        u16 reserved1;
         u32 reserved2;
+        u32 reserved3;
 };
 
 /*
  * union for all event ring message types
  */
 union event_data {
-        struct set_mac_event_data set_mac_event;
+        struct vf_pf_event_data vf_pf_event;
+        struct eth_event_data eth_event;
         struct cfc_del_event_data cfc_del_event;
+        struct vf_flr_event_data vf_flr_event;
+        struct malicious_vf_event_data malicious_vf_event;
 };
 
 
@@ -3359,7 +4476,7 @@ struct event_ring_data {
  */
 struct event_ring_msg {
         u8 opcode;
-        u8 reserved0;
+        u8 error;
         u16 reserved1;
         union event_data data;
 };
@@ -3382,32 +4499,82 @@ union event_ring_elem {
 
 
 /*
+ * Common event ring opcodes
+ */
+enum event_ring_opcode {
+        EVENT_RING_OPCODE_VF_PF_CHANNEL,
+        EVENT_RING_OPCODE_FUNCTION_START,
+        EVENT_RING_OPCODE_FUNCTION_STOP,
+        EVENT_RING_OPCODE_CFC_DEL,
+        EVENT_RING_OPCODE_CFC_DEL_WB,
+        EVENT_RING_OPCODE_STAT_QUERY,
+        EVENT_RING_OPCODE_STOP_TRAFFIC,
+        EVENT_RING_OPCODE_START_TRAFFIC,
+        EVENT_RING_OPCODE_VF_FLR,
+        EVENT_RING_OPCODE_MALICIOUS_VF,
+        EVENT_RING_OPCODE_FORWARD_SETUP,
+        EVENT_RING_OPCODE_RSS_UPDATE_RULES,
+        EVENT_RING_OPCODE_RESERVED1,
+        EVENT_RING_OPCODE_RESERVED2,
+        EVENT_RING_OPCODE_SET_MAC,
+        EVENT_RING_OPCODE_CLASSIFICATION_RULES,
+        EVENT_RING_OPCODE_FILTERS_RULES,
+        EVENT_RING_OPCODE_MULTICAST_RULES,
+        MAX_EVENT_RING_OPCODE
+};
+
+
+/*
+ * Modes for fairness algorithm
+ */
+enum fairness_mode {
+        FAIRNESS_COS_WRR_MODE,
+        FAIRNESS_COS_ETS_MODE,
+        MAX_FAIRNESS_MODE
+};
+
+
+/*
  * per-vnic fairness variables
  */
 struct fairness_vars_per_vn {
         u32 cos_credit_delta[MAX_COS_NUMBER];
-        u32 protocol_credit_delta[NUM_OF_PROTOCOLS];
         u32 vn_credit_delta;
         u32 __reserved0;
 };
 
 
 /*
+ * Priority and cos
+ */
+struct priority_cos {
+        u8 priority;
+        u8 cos;
+        __le16 reserved1;
+};
+
+/*
  * The data for flow control configuration
  */
 struct flow_control_configuration {
-        struct priority_cos
-                traffic_type_to_priority_cos[MAX_PFC_TRAFFIC_TYPES];
-#if defined(__BIG_ENDIAN)
-        u16 reserved1;
-        u8 dcb_version;
-        u8 dcb_enabled;
-#elif defined(__LITTLE_ENDIAN)
+        struct priority_cos traffic_type_to_priority_cos[MAX_TRAFFIC_TYPES];
         u8 dcb_enabled;
         u8 dcb_version;
-        u16 reserved1;
-#endif
-        u32 reserved2;
+        u8 dont_add_pri_0_en;
+        u8 reserved1;
+        __le32 reserved2;
+};
+
+
+/*
+ *
+ */
+struct function_start_data {
+        __le16 function_mode;
+        __le16 sd_vlan_tag;
+        u16 reserved;
+        u8 path_id;
+        u8 network_cos_mode;
 };
 
 
@@ -3520,13 +4687,13 @@ struct hc_sb_data {
         struct pci_entity p_func;
 #if defined(__BIG_ENDIAN)
         u8 rsrv0;
+        u8 state;
         u8 dhc_qzone_id;
-        u8 __dynamic_hc_level;
         u8 same_igu_sb_1b;
 #elif defined(__LITTLE_ENDIAN)
         u8 same_igu_sb_1b;
-        u8 __dynamic_hc_level;
         u8 dhc_qzone_id;
+        u8 state;
         u8 rsrv0;
 #endif
         struct regpair rsrv1[2];
@@ -3534,18 +4701,30 @@ struct hc_sb_data {
 
 
 /*
+ * Segment types for host coaslescing
+ */
+enum hc_segment {
+        HC_REGULAR_SEGMENT,
+        HC_DEFAULT_SEGMENT,
+        MAX_HC_SEGMENT
+};
+
+
+/*
  * The fast-path status block meta-data
  */
 struct hc_sp_status_block_data {
         struct regpair host_sb_addr;
 #if defined(__BIG_ENDIAN)
-        u16 rsrv;
+        u8 rsrv1;
+        u8 state;
         u8 igu_seg_id;
         u8 igu_sb_id;
 #elif defined(__LITTLE_ENDIAN)
         u8 igu_sb_id;
         u8 igu_seg_id;
-        u16 rsrv;
+        u8 state;
+        u8 rsrv1;
 #endif
         struct pci_entity p_func;
 };
@@ -3570,6 +4749,129 @@ struct hc_status_block_data_e2 {
 
 
 /*
+ * IGU block operartion modes (in Everest2)
+ */
+enum igu_mode {
+        HC_IGU_BC_MODE,
+        HC_IGU_NBC_MODE,
+        MAX_IGU_MODE
+};
+
+
+/*
+ * IP versions
+ */
+enum ip_ver {
+        IP_V4,
+        IP_V6,
+        MAX_IP_VER
+};
+
+
+/*
+ * Multi-function modes
+ */
+enum mf_mode {
+        SINGLE_FUNCTION,
+        MULTI_FUNCTION_SD,
+        MULTI_FUNCTION_SI,
+        MULTI_FUNCTION_RESERVED,
+        MAX_MF_MODE
+};
+
+/*
+ * Protocol-common statistics collected by the Tstorm (per pf)
+ */
+struct tstorm_per_pf_stats {
+        struct regpair rcv_error_bytes;
+};
+
+/*
+ *
+ */
+struct per_pf_stats {
+        struct tstorm_per_pf_stats tstorm_pf_statistics;
+};
+
+
+/*
+ * Protocol-common statistics collected by the Tstorm (per port)
+ */
+struct tstorm_per_port_stats {
+        __le32 mac_discard;
+        __le32 mac_filter_discard;
+        __le32 brb_truncate_discard;
+        __le32 mf_tag_discard;
+        __le32 packet_drop;
+        __le32 reserved;
+};
+
+/*
+ *
+ */
+struct per_port_stats {
+        struct tstorm_per_port_stats tstorm_port_statistics;
+};
+
+
+/*
+ * Protocol-common statistics collected by the Tstorm (per client)
+ */
+struct tstorm_per_queue_stats {
+        struct regpair rcv_ucast_bytes;
+        __le32 rcv_ucast_pkts;
+        __le32 checksum_discard;
+        struct regpair rcv_bcast_bytes;
+        __le32 rcv_bcast_pkts;
+        __le32 pkts_too_big_discard;
+        struct regpair rcv_mcast_bytes;
+        __le32 rcv_mcast_pkts;
+        __le32 ttl0_discard;
+        __le16 no_buff_discard;
+        __le16 reserved0;
+        __le32 reserved1;
+};
+
+/*
+ * Protocol-common statistics collected by the Ustorm (per client)
+ */
+struct ustorm_per_queue_stats {
+        struct regpair ucast_no_buff_bytes;
+        struct regpair mcast_no_buff_bytes;
+        struct regpair bcast_no_buff_bytes;
+        __le32 ucast_no_buff_pkts;
+        __le32 mcast_no_buff_pkts;
+        __le32 bcast_no_buff_pkts;
+        __le32 coalesced_pkts;
+        struct regpair coalesced_bytes;
+        __le32 coalesced_events;
+        __le32 coalesced_aborts;
+};
+
+/*
+ * Protocol-common statistics collected by the Xstorm (per client)
+ */
+struct xstorm_per_queue_stats {
+        struct regpair ucast_bytes_sent;
+        struct regpair mcast_bytes_sent;
+        struct regpair bcast_bytes_sent;
+        __le32 ucast_pkts_sent;
+        __le32 mcast_pkts_sent;
+        __le32 bcast_pkts_sent;
+        __le32 error_drop_pkts;
+};
+
+/*
+ *
+ */
+struct per_queue_stats {
+        struct tstorm_per_queue_stats tstorm_queue_statistics;
+        struct ustorm_per_queue_stats ustorm_queue_statistics;
+        struct xstorm_per_queue_stats xstorm_queue_statistics;
+};
+
+
+/*
  * FW version stored in first line of pram
  */
 struct pram_fw_version {
@@ -3598,7 +4900,6 @@ union protocol_common_specific_data {
         u8 protocol_data[8];
         struct regpair phy_address;
         struct regpair mac_config_addr;
-        struct common_query_ramrod_data query_ramrod_data;
 };
 
 /*
@@ -3629,7 +4930,6 @@ struct rate_shaping_counter {
  * per-vnic rate shaping variables
  */
 struct rate_shaping_vars_per_vn {
-        struct rate_shaping_counter protocol_counters[NUM_OF_PROTOCOLS];
         struct rate_shaping_counter vn_counter;
 };
 
@@ -3644,39 +4944,100 @@ struct slow_path_element {
 
 
 /*
- * eth/toe flags that indicate if to query
+ * Protocol-common statistics counter
  */
-struct stats_indication_flags {
-        u32 collect_eth;
-        u32 collect_toe;
+struct stats_counter {
+        __le16 xstats_counter;
+        __le16 reserved0;
+        __le32 reserved1;
+        __le16 tstats_counter;
+        __le16 reserved2;
+        __le32 reserved3;
+        __le16 ustats_counter;
+        __le16 reserved4;
+        __le32 reserved5;
+        __le16 cstats_counter;
+        __le16 reserved6;
+        __le32 reserved7;
 };
 
 
 /*
- * per-port PFC variables
+ *
  */
-struct storm_pfc_struct_per_port {
-#if defined(__BIG_ENDIAN)
-        u16 mid_mac_addr;
-        u16 msb_mac_addr;
-#elif defined(__LITTLE_ENDIAN)
-        u16 msb_mac_addr;
-        u16 mid_mac_addr;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 pfc_pause_quanta_in_nanosec;
-        u16 lsb_mac_addr;
-#elif defined(__LITTLE_ENDIAN)
-        u16 lsb_mac_addr;
-        u16 pfc_pause_quanta_in_nanosec;
-#endif
+struct stats_query_entry {
+        u8 kind;
+        u8 index;
+        __le16 funcID;
+        __le32 reserved;
+        struct regpair address;
 };
 
 /*
- * Per-port congestion management variables
+ * statistic command
  */
-struct storm_cmng_struct_per_port {
-        struct storm_pfc_struct_per_port pfc_vars;
+struct stats_query_cmd_group {
+        struct stats_query_entry query[STATS_QUERY_CMD_COUNT];
+};
+
+
+/*
+ * statistic command header
+ */
+struct stats_query_header {
+        u8 cmd_num;
+        u8 reserved0;
+        __le16 drv_stats_counter;
+        __le32 reserved1;
+        struct regpair stats_counters_addrs;
+};
+
+
+/*
+ * Types of statistcis query entry
+ */
+enum stats_query_type {
+        STATS_TYPE_QUEUE,
+        STATS_TYPE_PORT,
+        STATS_TYPE_PF,
+        STATS_TYPE_TOE,
+        STATS_TYPE_FCOE,
+        MAX_STATS_QUERY_TYPE
+};
+
+
+/*
+ * Indicate of the function status block state
+ */
+enum status_block_state {
+        SB_DISABLED,
+        SB_ENABLED,
+        SB_CLEANED,
+        MAX_STATUS_BLOCK_STATE
+};
+
+
+/*
+ * Storm IDs (including attentions for IGU related enums)
+ */
+enum storm_id {
+        USTORM_ID,
+        CSTORM_ID,
+        XSTORM_ID,
+        TSTORM_ID,
+        ATTENTION_ID,
+        MAX_STORM_ID
+};
+
+
+/*
+ * Taffic types used in ETS and flow control algorithms
+ */
+enum traffic_type {
+        LLFC_TRAFFIC_TYPE_NW,
+        LLFC_TRAFFIC_TYPE_FCOE,
+        LLFC_TRAFFIC_TYPE_ISCSI,
+        MAX_TRAFFIC_TYPE
 };
 
 
@@ -3731,6 +5092,16 @@ struct vf_pf_channel_data {
 
 
 /*
+ * State of VF-PF channel
+ */
+enum vf_pf_channel_state {
+        VF_PF_CHANNEL_STATE_READY,
+        VF_PF_CHANNEL_STATE_WAITING_FOR_ACK,
+        MAX_VF_PF_CHANNEL_STATE
+};
+
+
+/*
  * zone A per-queue data
  */
 struct xstorm_queue_zone_data {
diff --git a/drivers/net/bnx2x/bnx2x_init.h b/drivers/net/bnx2x/bnx2x_init.h
index d5399206f66e..8b1d62584436 100644
--- a/drivers/net/bnx2x/bnx2x_init.h
+++ b/drivers/net/bnx2x/bnx2x_init.h
@@ -15,98 +15,34 @@
 #ifndef BNX2X_INIT_H
 #define BNX2X_INIT_H
 
-/* RAM0 size in bytes */
-#define STORM_INTMEM_SIZE_E1            0x5800
-#define STORM_INTMEM_SIZE_E1H           0x10000
-#define STORM_INTMEM_SIZE(bp) ((CHIP_IS_E1(bp) ? STORM_INTMEM_SIZE_E1 : \
-                                                    STORM_INTMEM_SIZE_E1H) / 4)
-
-
 /* Init operation types and structures */
-/* Common for both E1 and E1H */
-#define OP_RD                   0x1 /* read single register */
-#define OP_WR                   0x2 /* write single register */
-#define OP_IW                   0x3 /* write single register using mailbox */
-#define OP_SW                   0x4 /* copy a string to the device */
-#define OP_SI                   0x5 /* copy a string using mailbox */
-#define OP_ZR                   0x6 /* clear memory */
-#define OP_ZP                   0x7 /* unzip then copy with DMAE */
-#define OP_WR_64                0x8 /* write 64 bit pattern */
-#define OP_WB                   0x9 /* copy a string using DMAE */
-
-/* FPGA and EMUL specific operations */
-#define OP_WR_EMUL              0xa /* write single register on Emulation */
-#define OP_WR_FPGA              0xb /* write single register on FPGA */
-#define OP_WR_ASIC              0xc /* write single register on ASIC */
-
-/* Init stages */
-/* Never reorder stages !!! */
-#define COMMON_STAGE            0
-#define PORT0_STAGE             1
-#define PORT1_STAGE             2
-#define FUNC0_STAGE             3
-#define FUNC1_STAGE             4
-#define FUNC2_STAGE             5
-#define FUNC3_STAGE             6
-#define FUNC4_STAGE             7
-#define FUNC5_STAGE             8
-#define FUNC6_STAGE             9
-#define FUNC7_STAGE             10
-#define STAGE_IDX_MAX           11
-
-#define STAGE_START             0
-#define STAGE_END               1
-
-
-/* Indices of blocks */
-#define PRS_BLOCK               0
-#define SRCH_BLOCK              1
-#define TSDM_BLOCK              2
-#define TCM_BLOCK               3
-#define BRB1_BLOCK              4
-#define TSEM_BLOCK              5
-#define PXPCS_BLOCK             6
-#define EMAC0_BLOCK             7
-#define EMAC1_BLOCK             8
-#define DBU_BLOCK               9
-#define MISC_BLOCK              10
-#define DBG_BLOCK               11
-#define NIG_BLOCK               12
-#define MCP_BLOCK               13
-#define UPB_BLOCK               14
-#define CSDM_BLOCK              15
-#define USDM_BLOCK              16
-#define CCM_BLOCK               17
-#define UCM_BLOCK               18
-#define USEM_BLOCK              19
-#define CSEM_BLOCK              20
-#define XPB_BLOCK               21
-#define DQ_BLOCK                22
-#define TIMERS_BLOCK            23
-#define XSDM_BLOCK              24
-#define QM_BLOCK                25
-#define PBF_BLOCK               26
-#define XCM_BLOCK               27
-#define XSEM_BLOCK              28
-#define CDU_BLOCK               29
-#define DMAE_BLOCK              30
-#define PXP_BLOCK               31
-#define CFC_BLOCK               32
-#define HC_BLOCK                33
-#define PXP2_BLOCK              34
-#define MISC_AEU_BLOCK          35
-#define PGLUE_B_BLOCK           36
-#define IGU_BLOCK               37
-#define ATC_BLOCK               38
-#define QM_4PORT_BLOCK          39
-#define XSEM_4PORT_BLOCK                40
+enum {
+        OP_RD = 0x1,    /* read a single register */
+        OP_WR,          /* write a single register */
+        OP_SW,          /* copy a string to the device */
+        OP_ZR,          /* clear memory */
+        OP_ZP,          /* unzip then copy with DMAE */
+        OP_WR_64,       /* write 64 bit pattern */
+        OP_WB,          /* copy a string using DMAE */
+        OP_WB_ZR,       /* Clear a string using DMAE or indirect-wr */
+        /* Skip the following ops if all of the init modes don't match */
+        OP_IF_MODE_OR,
+        /* Skip the following ops if any of the init modes don't match */
+        OP_IF_MODE_AND,
+        OP_MAX
+};
 
+enum {
+        STAGE_START,
+        STAGE_END,
+};
 
 /* Returns the index of start or end of a specific block stage in ops array*/
 #define BLOCK_OPS_IDX(block, stage, end) \
-                        (2*(((block)*STAGE_IDX_MAX) + (stage)) + (end))
+        (2*(((block)*NUM_OF_INIT_PHASES) + (stage)) + (end))
 
 
+/* structs for the various opcodes */
 struct raw_op {
         u32 op:8;
         u32 offset:24;
@@ -116,7 +52,7 @@ struct raw_op {
 struct op_read {
         u32 op:8;
         u32 offset:24;
-        u32 pad;
+        u32 val;
 };
 
 struct op_write {
@@ -125,15 +61,15 @@ struct op_write {
         u32 val;
 };
 
-struct op_string_write {
+struct op_arr_write {
         u32 op:8;
         u32 offset:24;
-#ifdef __LITTLE_ENDIAN
-        u16 data_off;
-        u16 data_len;
-#else /* __BIG_ENDIAN */
+#ifdef __BIG_ENDIAN
         u16 data_len;
         u16 data_off;
+#else /* __LITTLE_ENDIAN */
+        u16 data_off;
+        u16 data_len;
 #endif
 };
 
@@ -143,14 +79,210 @@ struct op_zero {
         u32 len;
 };
 
+struct op_if_mode {
+        u32 op:8;
+        u32 cmd_offset:24;
+        u32 mode_bit_map;
+};
+
+
 union init_op {
         struct op_read          read;
         struct op_write         write;
-        struct op_string_write  str_wr;
+        struct op_arr_write     arr_wr;
         struct op_zero          zero;
         struct raw_op           raw;
+        struct op_if_mode       if_mode;
+};
+
+
+/* Init Phases */
+enum {
+        PHASE_COMMON,
+        PHASE_PORT0,
+        PHASE_PORT1,
+        PHASE_PF0,
+        PHASE_PF1,
+        PHASE_PF2,
+        PHASE_PF3,
+        PHASE_PF4,
+        PHASE_PF5,
+        PHASE_PF6,
+        PHASE_PF7,
+        NUM_OF_INIT_PHASES
 };
 
+/* Init Modes */
+enum {
+        MODE_ASIC                      = 0x00000001,
+        MODE_FPGA                      = 0x00000002,
+        MODE_EMUL                      = 0x00000004,
+        MODE_E2                        = 0x00000008,
+        MODE_E3                        = 0x00000010,
+        MODE_PORT2                     = 0x00000020,
+        MODE_PORT4                     = 0x00000040,
+        MODE_SF                        = 0x00000080,
+        MODE_MF                        = 0x00000100,
+        MODE_MF_SD                     = 0x00000200,
+        MODE_MF_SI                     = 0x00000400,
+        MODE_MF_NIV                    = 0x00000800,
+        MODE_E3_A0                     = 0x00001000,
+        MODE_E3_B0                     = 0x00002000,
+        MODE_COS_BC                    = 0x00004000,
+        MODE_COS3                      = 0x00008000,
+        MODE_COS6                      = 0x00010000,
+        MODE_LITTLE_ENDIAN             = 0x00020000,
+        MODE_BIG_ENDIAN                = 0x00040000,
+};
+
+/* Init Blocks */
+enum {
+        BLOCK_ATC,
+        BLOCK_BRB1,
+        BLOCK_CCM,
+        BLOCK_CDU,
+        BLOCK_CFC,
+        BLOCK_CSDM,
+        BLOCK_CSEM,
+        BLOCK_DBG,
+        BLOCK_DMAE,
+        BLOCK_DORQ,
+        BLOCK_HC,
+        BLOCK_IGU,
+        BLOCK_MISC,
+        BLOCK_NIG,
+        BLOCK_PBF,
+        BLOCK_PGLUE_B,
+        BLOCK_PRS,
+        BLOCK_PXP2,
+        BLOCK_PXP,
+        BLOCK_QM,
+        BLOCK_SRC,
+        BLOCK_TCM,
+        BLOCK_TM,
+        BLOCK_TSDM,
+        BLOCK_TSEM,
+        BLOCK_UCM,
+        BLOCK_UPB,
+        BLOCK_USDM,
+        BLOCK_USEM,
+        BLOCK_XCM,
+        BLOCK_XPB,
+        BLOCK_XSDM,
+        BLOCK_XSEM,
+        BLOCK_MISC_AEU,
+        NUM_OF_INIT_BLOCKS
+};
+
+/* QM queue numbers */
+#define BNX2X_ETH_Q             0
+#define BNX2X_TOE_Q             3
+#define BNX2X_TOE_ACK_Q         6
+#define BNX2X_ISCSI_Q           9
+#define BNX2X_ISCSI_ACK_Q       8
+#define BNX2X_FCOE_Q            10
+
+/* Vnics per mode */
+#define BNX2X_PORT2_MODE_NUM_VNICS 4
+#define BNX2X_PORT4_MODE_NUM_VNICS 2
+
+/* COS offset for port1 in E3 B0 4port mode */
+#define BNX2X_E3B0_PORT1_COS_OFFSET 3
+
+/* QM Register addresses */
+#define BNX2X_Q_VOQ_REG_ADDR(pf_q_num)\
+        (QM_REG_QVOQIDX_0 + 4 * (pf_q_num))
+#define BNX2X_VOQ_Q_REG_ADDR(cos, pf_q_num)\
+        (QM_REG_VOQQMASK_0_LSB + 4 * ((cos) * 2 + ((pf_q_num) >> 5)))
+#define BNX2X_Q_CMDQ_REG_ADDR(pf_q_num)\
+        (QM_REG_BYTECRDCMDQ_0 + 4 * ((pf_q_num) >> 4))
+
+/* extracts the QM queue number for the specified port and vnic */
+#define BNX2X_PF_Q_NUM(q_num, port, vnic)\
+        ((((port) << 1) | (vnic)) * 16 + (q_num))
+
+
+/* Maps the specified queue to the specified COS */
+static inline void bnx2x_map_q_cos(struct bnx2x *bp, u32 q_num, u32 new_cos)
+{
+        /* find current COS mapping */
+        u32 curr_cos = REG_RD(bp, QM_REG_QVOQIDX_0 + q_num * 4);
+
+        /* check if queue->COS mapping has changed */
+        if (curr_cos != new_cos) {
+                u32 num_vnics = BNX2X_PORT2_MODE_NUM_VNICS;
+                u32 reg_addr, reg_bit_map, vnic;
+
+                /* update parameters for 4port mode */
+                if (INIT_MODE_FLAGS(bp) & MODE_PORT4) {
+                        num_vnics = BNX2X_PORT4_MODE_NUM_VNICS;
+                        if (BP_PORT(bp)) {
+                                curr_cos += BNX2X_E3B0_PORT1_COS_OFFSET;
+                                new_cos += BNX2X_E3B0_PORT1_COS_OFFSET;
+                        }
+                }
+
+                /* change queue mapping for each VNIC */
+                for (vnic = 0; vnic < num_vnics; vnic++) {
+                        u32 pf_q_num =
+                                BNX2X_PF_Q_NUM(q_num, BP_PORT(bp), vnic);
+                        u32 q_bit_map = 1 << (pf_q_num & 0x1f);
+
+                        /* overwrite queue->VOQ mapping */
+                        REG_WR(bp, BNX2X_Q_VOQ_REG_ADDR(pf_q_num), new_cos);
+
+                        /* clear queue bit from current COS bit map */
+                        reg_addr = BNX2X_VOQ_Q_REG_ADDR(curr_cos, pf_q_num);
+                        reg_bit_map = REG_RD(bp, reg_addr);
+                        REG_WR(bp, reg_addr, reg_bit_map & (~q_bit_map));
+
+                        /* set queue bit in new COS bit map */
+                        reg_addr = BNX2X_VOQ_Q_REG_ADDR(new_cos, pf_q_num);
+                        reg_bit_map = REG_RD(bp, reg_addr);
+                        REG_WR(bp, reg_addr, reg_bit_map | q_bit_map);
+
+                        /* set/clear queue bit in command-queue bit map
+                        (E2/E3A0 only, valid COS values are 0/1) */
+                        if (!(INIT_MODE_FLAGS(bp) & MODE_E3_B0)) {
+                                reg_addr = BNX2X_Q_CMDQ_REG_ADDR(pf_q_num);
+                                reg_bit_map = REG_RD(bp, reg_addr);
+                                q_bit_map = 1 << (2 * (pf_q_num & 0xf));
+                                reg_bit_map = new_cos ?
+                                              (reg_bit_map | q_bit_map) :
+                                              (reg_bit_map & (~q_bit_map));
+                                REG_WR(bp, reg_addr, reg_bit_map);
+                        }
+                }
+        }
+}
+
+/* Configures the QM according to the specified per-traffic-type COSes */
+static inline void bnx2x_dcb_config_qm(struct bnx2x *bp,
+                                       struct priority_cos *traffic_cos)
+{
+        bnx2x_map_q_cos(bp, BNX2X_FCOE_Q,
+                        traffic_cos[LLFC_TRAFFIC_TYPE_FCOE].cos);
+        bnx2x_map_q_cos(bp, BNX2X_ISCSI_Q,
+                        traffic_cos[LLFC_TRAFFIC_TYPE_ISCSI].cos);
+        if (INIT_MODE_FLAGS(bp) & MODE_COS_BC) {
+                /* required only in backward compatible COS mode */
+                bnx2x_map_q_cos(bp, BNX2X_ETH_Q,
+                                traffic_cos[LLFC_TRAFFIC_TYPE_NW].cos);
+                bnx2x_map_q_cos(bp, BNX2X_TOE_Q,
+                                traffic_cos[LLFC_TRAFFIC_TYPE_NW].cos);
+                bnx2x_map_q_cos(bp, BNX2X_TOE_ACK_Q,
+                                traffic_cos[LLFC_TRAFFIC_TYPE_NW].cos);
+                bnx2x_map_q_cos(bp, BNX2X_ISCSI_ACK_Q,
+                                traffic_cos[LLFC_TRAFFIC_TYPE_ISCSI].cos);
+        }
+}
+
+
+/* Returns the index of start or end of a specific block stage in ops array*/
+#define BLOCK_OPS_IDX(block, stage, end) \
+                        (2*(((block)*NUM_OF_INIT_PHASES) + (stage)) + (end))
+
+
 #define INITOP_SET              0       /* set the HW directly */
 #define INITOP_CLEAR            1       /* clear the HW directly */
 #define INITOP_INIT             2       /* set the init-value array */
diff --git a/drivers/net/bnx2x/bnx2x_init_ops.h b/drivers/net/bnx2x/bnx2x_init_ops.h
index aafd0232393f..7ec1724753ad 100644
--- a/drivers/net/bnx2x/bnx2x_init_ops.h
+++ b/drivers/net/bnx2x/bnx2x_init_ops.h
@@ -15,13 +15,39 @@
 #ifndef BNX2X_INIT_OPS_H
 #define BNX2X_INIT_OPS_H
 
+
+#ifndef BP_ILT
+#define BP_ILT(bp)      NULL
+#endif
+
+#ifndef BP_FUNC
+#define BP_FUNC(bp)     0
+#endif
+
+#ifndef BP_PORT
+#define BP_PORT(bp)     0
+#endif
+
+#ifndef BNX2X_ILT_FREE
+#define BNX2X_ILT_FREE(x, y, sz)
+#endif
+
+#ifndef BNX2X_ILT_ZALLOC
+#define BNX2X_ILT_ZALLOC(x, y, sz)
+#endif
+
+#ifndef ILOG2
+#define ILOG2(x)        x
+#endif
+
 static int bnx2x_gunzip(struct bnx2x *bp, const u8 *zbuf, int len);
 static void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val);
-static void bnx2x_write_dmae_phys_len(struct bnx2x *bp, dma_addr_t phys_addr,
-                                      u32 addr, u32 len);
+static void bnx2x_write_dmae_phys_len(struct bnx2x *bp,
+                                      dma_addr_t phys_addr, u32 addr,
+                                      u32 len);
 
-static void bnx2x_init_str_wr(struct bnx2x *bp, u32 addr, const u32 *data,
-                              u32 len)
+static void bnx2x_init_str_wr(struct bnx2x *bp, u32 addr,
+                              const u32 *data, u32 len)
 {
         u32 i;
 
@@ -29,24 +55,32 @@ static void bnx2x_init_str_wr(struct bnx2x *bp, u32 addr, const u32 *data,
                 REG_WR(bp, addr + i*4, data[i]);
 }
 
-static void bnx2x_init_ind_wr(struct bnx2x *bp, u32 addr, const u32 *data,
-                              u32 len)
+static void bnx2x_init_ind_wr(struct bnx2x *bp, u32 addr,
+                              const u32 *data, u32 len)
 {
         u32 i;
 
         for (i = 0; i < len; i++)
-                REG_WR_IND(bp, addr + i*4, data[i]);
+                bnx2x_reg_wr_ind(bp, addr + i*4, data[i]);
 }
 
-static void bnx2x_write_big_buf(struct bnx2x *bp, u32 addr, u32 len)
+static void bnx2x_write_big_buf(struct bnx2x *bp, u32 addr, u32 len,
+                                u8 wb)
 {
         if (bp->dmae_ready)
                 bnx2x_write_dmae_phys_len(bp, GUNZIP_PHYS(bp), addr, len);
+        else if (wb)
+                /*
+                 * Wide bus registers with no dmae need to be written
+                 * using indirect write.
+                 */
+                bnx2x_init_ind_wr(bp, addr, GUNZIP_BUF(bp), len);
         else
                 bnx2x_init_str_wr(bp, addr, GUNZIP_BUF(bp), len);
 }
 
-static void bnx2x_init_fill(struct bnx2x *bp, u32 addr, int fill, u32 len)
+static void bnx2x_init_fill(struct bnx2x *bp, u32 addr, int fill,
+                            u32 len, u8 wb)
 {
         u32 buf_len = (((len*4) > FW_BUF_SIZE) ? FW_BUF_SIZE : (len*4));
         u32 buf_len32 = buf_len/4;
@@ -57,12 +91,20 @@ static void bnx2x_init_fill(struct bnx2x *bp, u32 addr, int fill, u32 len)
         for (i = 0; i < len; i += buf_len32) {
                 u32 cur_len = min(buf_len32, len - i);
 
-                bnx2x_write_big_buf(bp, addr + i*4, cur_len);
+                bnx2x_write_big_buf(bp, addr + i*4, cur_len, wb);
         }
 }
 
-static void bnx2x_init_wr_64(struct bnx2x *bp, u32 addr, const u32 *data,
-                             u32 len64)
+static void bnx2x_write_big_buf_wb(struct bnx2x *bp, u32 addr, u32 len)
+{
+        if (bp->dmae_ready)
+                bnx2x_write_dmae_phys_len(bp, GUNZIP_PHYS(bp), addr, len);
+        else
+                bnx2x_init_ind_wr(bp, addr, GUNZIP_BUF(bp), len);
+}
+
+static void bnx2x_init_wr_64(struct bnx2x *bp, u32 addr,
+                             const u32 *data, u32 len64)
 {
         u32 buf_len32 = FW_BUF_SIZE/4;
         u32 len = len64*2;
@@ -82,7 +124,7 @@ static void bnx2x_init_wr_64(struct bnx2x *bp, u32 addr, const u32 *data,
         for (i = 0; i < len; i += buf_len32) {
                 u32 cur_len = min(buf_len32, len - i);
 
-                bnx2x_write_big_buf(bp, addr + i*4, cur_len);
+                bnx2x_write_big_buf_wb(bp, addr + i*4, cur_len);
         }
 }
 
@@ -100,7 +142,8 @@ static void bnx2x_init_wr_64(struct bnx2x *bp, u32 addr, const u32 *data,
 #define IF_IS_PRAM_ADDR(base, addr) \
                         if (((base) <= (addr)) && ((base) + 0x40000 >= (addr)))
 
-static const u8 *bnx2x_sel_blob(struct bnx2x *bp, u32 addr, const u8 *data)
+static const u8 *bnx2x_sel_blob(struct bnx2x *bp, u32 addr,
+                                const u8 *data)
 {
         IF_IS_INT_TABLE_ADDR(TSEM_REG_INT_TABLE, addr)
                 data = INIT_TSEM_INT_TABLE_DATA(bp);
@@ -129,31 +172,17 @@ static const u8 *bnx2x_sel_blob(struct bnx2x *bp, u32 addr, const u8 *data)
         return data;
 }
 
-static void bnx2x_write_big_buf_wb(struct bnx2x *bp, u32 addr, u32 len)
+static void bnx2x_init_wr_wb(struct bnx2x *bp, u32 addr,
+                             const u32 *data, u32 len)
 {
         if (bp->dmae_ready)
-                bnx2x_write_dmae_phys_len(bp, GUNZIP_PHYS(bp), addr, len);
+                VIRT_WR_DMAE_LEN(bp, data, addr, len, 0);
         else
-                bnx2x_init_ind_wr(bp, addr, GUNZIP_BUF(bp), len);
-}
-
-static void bnx2x_init_wr_wb(struct bnx2x *bp, u32 addr, const u32 *data,
-                             u32 len)
-{
-        const u32 *old_data = data;
-
-        data = (const u32 *)bnx2x_sel_blob(bp, addr, (const u8 *)data);
-
-        if (bp->dmae_ready) {
-                if (old_data != data)
-                        VIRT_WR_DMAE_LEN(bp, data, addr, len, 1);
-                else
-                        VIRT_WR_DMAE_LEN(bp, data, addr, len, 0);
-        } else
                 bnx2x_init_ind_wr(bp, addr, data, len);
 }
 
-static void bnx2x_wr_64(struct bnx2x *bp, u32 reg, u32 val_lo, u32 val_hi)
+static void bnx2x_wr_64(struct bnx2x *bp, u32 reg, u32 val_lo,
+                        u32 val_hi)
 {
         u32 wb_write[2];
 
@@ -161,8 +190,8 @@ static void bnx2x_wr_64(struct bnx2x *bp, u32 reg, u32 val_lo, u32 val_hi)
         wb_write[1] = val_hi;
         REG_WR_DMAE_LEN(bp, reg, wb_write, 2);
 }
-
-static void bnx2x_init_wr_zp(struct bnx2x *bp, u32 addr, u32 len, u32 blob_off)
+static void bnx2x_init_wr_zp(struct bnx2x *bp, u32 addr, u32 len,
+                             u32 blob_off)
 {
         const u8 *data = NULL;
         int rc;
@@ -186,39 +215,33 @@ static void bnx2x_init_wr_zp(struct bnx2x *bp, u32 addr, u32 len, u32 blob_off)
 static void bnx2x_init_block(struct bnx2x *bp, u32 block, u32 stage)
 {
         u16 op_start =
-                INIT_OPS_OFFSETS(bp)[BLOCK_OPS_IDX(block, stage, STAGE_START)];
+                INIT_OPS_OFFSETS(bp)[BLOCK_OPS_IDX(block, stage,
+                                                     STAGE_START)];
         u16 op_end =
-                INIT_OPS_OFFSETS(bp)[BLOCK_OPS_IDX(block, stage, STAGE_END)];
+                INIT_OPS_OFFSETS(bp)[BLOCK_OPS_IDX(block, stage,
+                                                     STAGE_END)];
         union init_op *op;
-        int hw_wr;
-        u32 i, op_type, addr, len;
+        u32 op_idx, op_type, addr, len;
         const u32 *data, *data_base;
 
         /* If empty block */
         if (op_start == op_end)
                 return;
 
-        if (CHIP_REV_IS_FPGA(bp))
-                hw_wr = OP_WR_FPGA;
-        else if (CHIP_REV_IS_EMUL(bp))
-                hw_wr = OP_WR_EMUL;
-        else
-                hw_wr = OP_WR_ASIC;
-
         data_base = INIT_DATA(bp);
 
-        for (i = op_start; i < op_end; i++) {
-
-                op = (union init_op *)&(INIT_OPS(bp)[i]);
+        for (op_idx = op_start; op_idx < op_end; op_idx++) {
 
-                op_type = op->str_wr.op;
-                addr = op->str_wr.offset;
-                len = op->str_wr.data_len;
-                data = data_base + op->str_wr.data_off;
-
-                /* HW/EMUL specific */
-                if ((op_type > OP_WB) && (op_type == hw_wr))
-                        op_type = OP_WR;
+                op = (union init_op *)&(INIT_OPS(bp)[op_idx]);
+                /* Get generic data */
+                op_type = op->raw.op;
+                addr = op->raw.offset;
+                /* Get data that's used for OP_SW, OP_WB, OP_FW, OP_ZP and
+                 * OP_WR64 (we assume that op_arr_write and op_write have the
+                 * same structure).
+                 */
+                len = op->arr_wr.data_len;
+                data = data_base + op->arr_wr.data_off;
 
                 switch (op_type) {
                 case OP_RD:
@@ -233,21 +256,39 @@ static void bnx2x_init_block(struct bnx2x *bp, u32 block, u32 stage)
                 case OP_WB:
                         bnx2x_init_wr_wb(bp, addr, data, len);
                         break;
-                case OP_SI:
-                        bnx2x_init_ind_wr(bp, addr, data, len);
-                        break;
                 case OP_ZR:
-                        bnx2x_init_fill(bp, addr, 0, op->zero.len);
+                        bnx2x_init_fill(bp, addr, 0, op->zero.len, 0);
+                        break;
+                case OP_WB_ZR:
+                        bnx2x_init_fill(bp, addr, 0, op->zero.len, 1);
                         break;
                 case OP_ZP:
                         bnx2x_init_wr_zp(bp, addr, len,
-                                         op->str_wr.data_off);
+                                         op->arr_wr.data_off);
                         break;
                 case OP_WR_64:
                         bnx2x_init_wr_64(bp, addr, data, len);
                         break;
+                case OP_IF_MODE_AND:
+                        /* if any of the flags doesn't match, skip the
+                         * conditional block.
+                         */
+                        if ((INIT_MODE_FLAGS(bp) &
+                                op->if_mode.mode_bit_map) !=
+                                op->if_mode.mode_bit_map)
+                                op_idx += op->if_mode.cmd_offset;
+                        break;
+                case OP_IF_MODE_OR:
+                        /* if all the flags don't match, skip the conditional
+                         * block.
+                         */
+                        if ((INIT_MODE_FLAGS(bp) &
+                                op->if_mode.mode_bit_map) == 0)
+                                op_idx += op->if_mode.cmd_offset;
+                        break;
                 default:
-                        /* happens whenever an op is of a diff HW */
+                        /* Should never get here! */
+
                         break;
                 }
         }
@@ -417,7 +458,8 @@ static const struct arb_line write_arb_addr[NUM_WR_Q-1] = {
                 PXP2_REG_RQ_BW_WR_UBOUND30}
 };
 
-static void bnx2x_init_pxp_arb(struct bnx2x *bp, int r_order, int w_order)
+static void bnx2x_init_pxp_arb(struct bnx2x *bp, int r_order,
+                               int w_order)
 {
         u32 val, i;
 
@@ -491,19 +533,21 @@ static void bnx2x_init_pxp_arb(struct bnx2x *bp, int r_order, int w_order)
         if ((CHIP_IS_E1(bp) || CHIP_IS_E1H(bp)) && (r_order == MAX_RD_ORD))
                 REG_WR(bp, PXP2_REG_RQ_PDR_LIMIT, 0xe00);
 
-        if (CHIP_IS_E2(bp))
+        if (CHIP_IS_E3(bp))
+                REG_WR(bp, PXP2_REG_WR_USDMDP_TH, (0x4 << w_order));
+        else if (CHIP_IS_E2(bp))
                 REG_WR(bp, PXP2_REG_WR_USDMDP_TH, (0x8 << w_order));
         else
                 REG_WR(bp, PXP2_REG_WR_USDMDP_TH, (0x18 << w_order));
 
-        if (CHIP_IS_E1H(bp) || CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1(bp)) {
                 /*    MPS      w_order     optimal TH      presently TH
                  *    128         0             0               2
                  *    256         1             1               3
                  *    >=512       2             2               3
                  */
                 /* DMAE is special */
-                if (CHIP_IS_E2(bp)) {
+                if (!CHIP_IS_E1H(bp)) {
                         /* E2 can use optimal TH */
                         val = w_order;
                         REG_WR(bp, PXP2_REG_WR_DMAE_MPS, val);
@@ -557,8 +601,8 @@ static void bnx2x_init_pxp_arb(struct bnx2x *bp, int r_order, int w_order)
 #define ILT_ADDR2(x)            ((u32)((1 << 20) | ((u64)x >> 44)))
 #define ILT_RANGE(f, l)         (((l) << 10) | f)
 
-static int bnx2x_ilt_line_mem_op(struct bnx2x *bp, struct ilt_line *line,
-                                 u32 size, u8 memop)
+static int bnx2x_ilt_line_mem_op(struct bnx2x *bp,
+                                 struct ilt_line *line, u32 size, u8 memop)
 {
         if (memop == ILT_MEMOP_FREE) {
                 BNX2X_ILT_FREE(line->page, line->page_mapping, line->size);
@@ -572,7 +616,8 @@ static int bnx2x_ilt_line_mem_op(struct bnx2x *bp, struct ilt_line *line,
 }
 
 
-static int bnx2x_ilt_client_mem_op(struct bnx2x *bp, int cli_num, u8 memop)
+static int bnx2x_ilt_client_mem_op(struct bnx2x *bp, int cli_num,
+                                   u8 memop)
 {
         int i, rc;
         struct bnx2x_ilt *ilt = BP_ILT(bp);
@@ -617,8 +662,8 @@ static void bnx2x_ilt_line_wr(struct bnx2x *bp, int abs_idx,
         bnx2x_wr_64(bp, reg, ILT_ADDR1(page_mapping), ILT_ADDR2(page_mapping));
 }
 
-static void bnx2x_ilt_line_init_op(struct bnx2x *bp, struct bnx2x_ilt *ilt,
-                                   int idx, u8 initop)
+static void bnx2x_ilt_line_init_op(struct bnx2x *bp,
+                                   struct bnx2x_ilt *ilt, int idx, u8 initop)
 {
         dma_addr_t      null_mapping;
         int abs_idx = ilt->start_line + idx;
@@ -733,7 +778,7 @@ static void bnx2x_ilt_init_op(struct bnx2x *bp, u8 initop)
 }
 
 static void bnx2x_ilt_init_client_psz(struct bnx2x *bp, int cli_num,
-                                            u32 psz_reg, u8 initop)
+                                      u32 psz_reg, u8 initop)
 {
         struct bnx2x_ilt *ilt = BP_ILT(bp);
         struct ilt_client_info *ilt_cli = &ilt->clients[cli_num];
@@ -848,7 +893,8 @@ static void bnx2x_src_init_t2(struct bnx2x *bp, struct src_ent *t2,
 
         /* Initialize T2 */
         for (i = 0; i < src_cid_count-1; i++)
-                t2[i].next = (u64)(t2_mapping + (i+1)*sizeof(struct src_ent));
+                t2[i].next = (u64)(t2_mapping +
+                             (i+1)*sizeof(struct src_ent));
 
         /* tell the searcher where the T2 table is */
         REG_WR(bp, SRC_REG_COUNTFREE0 + port*4, src_cid_count);
diff --git a/drivers/net/bnx2x/bnx2x_link.c b/drivers/net/bnx2x/bnx2x_link.c
index 15b5bc174331..347f3239ad1f 100644
--- a/drivers/net/bnx2x/bnx2x_link.c
+++ b/drivers/net/bnx2x/bnx2x_link.c
@@ -25,6 +25,8 @@
 #include <linux/mutex.h>
 
 #include "bnx2x.h"
+#include "bnx2x_cmn.h"
+
 
 /********************************************************/
 #define ETH_HLEN                        14
@@ -874,6 +876,54 @@ static void bnx2x_update_pfc_brb(struct link_params *params,
         }
 }
 
+/******************************************************************************
+* Description:
+*  This function is needed because NIG ARB_CREDIT_WEIGHT_X are
+*  not continues and ARB_CREDIT_WEIGHT_0 + offset is suitable.
+******************************************************************************/
+int bnx2x_pfc_nig_rx_priority_mask(struct bnx2x *bp,
+                                              u8 cos_entry,
+                                              u32 priority_mask, u8 port)
+{
+        u32 nig_reg_rx_priority_mask_add = 0;
+
+        switch (cos_entry) {
+        case 0:
+             nig_reg_rx_priority_mask_add = (port) ?
+                 NIG_REG_P1_RX_COS0_PRIORITY_MASK :
+                 NIG_REG_P0_RX_COS0_PRIORITY_MASK;
+             break;
+        case 1:
+            nig_reg_rx_priority_mask_add = (port) ?
+                NIG_REG_P1_RX_COS1_PRIORITY_MASK :
+                NIG_REG_P0_RX_COS1_PRIORITY_MASK;
+            break;
+        case 2:
+            nig_reg_rx_priority_mask_add = (port) ?
+                NIG_REG_P1_RX_COS2_PRIORITY_MASK :
+                NIG_REG_P0_RX_COS2_PRIORITY_MASK;
+            break;
+        case 3:
+            if (port)
+                return -EINVAL;
+            nig_reg_rx_priority_mask_add = NIG_REG_P0_RX_COS3_PRIORITY_MASK;
+            break;
+        case 4:
+            if (port)
+                return -EINVAL;
+            nig_reg_rx_priority_mask_add = NIG_REG_P0_RX_COS4_PRIORITY_MASK;
+            break;
+        case 5:
+            if (port)
+                return -EINVAL;
+            nig_reg_rx_priority_mask_add = NIG_REG_P0_RX_COS5_PRIORITY_MASK;
+            break;
+        }
+
+        REG_WR(bp, nig_reg_rx_priority_mask_add, priority_mask);
+
+        return 0;
+}
 static void bnx2x_update_pfc_nig(struct link_params *params,
                 struct link_vars *vars,
                 struct bnx2x_nig_brb_pfc_port_params *nig_params)
@@ -958,15 +1008,12 @@ static void bnx2x_update_pfc_nig(struct link_params *params,
         REG_WR(bp, NIG_REG_EGRESS_EMAC0_PORT, val);
 
         if (nig_params) {
+                u8 i = 0;
                 pkt_priority_to_cos = nig_params->pkt_priority_to_cos;
 
-                REG_WR(bp, port ? NIG_REG_P1_RX_COS0_PRIORITY_MASK :
-                       NIG_REG_P0_RX_COS0_PRIORITY_MASK,
-                       nig_params->rx_cos0_priority_mask);
-
-                REG_WR(bp, port ? NIG_REG_P1_RX_COS1_PRIORITY_MASK :
-                       NIG_REG_P0_RX_COS1_PRIORITY_MASK,
-                       nig_params->rx_cos1_priority_mask);
+                for (i = 0; i < nig_params->num_of_rx_cos_priority_mask; i++)
+                        bnx2x_pfc_nig_rx_priority_mask(bp, i,
+                nig_params->rx_cos_priority_mask[i], port);
 
                 REG_WR(bp, port ? NIG_REG_LLFC_HIGH_PRIORITY_CLASSES_1 :
                        NIG_REG_LLFC_HIGH_PRIORITY_CLASSES_0,
@@ -1824,26 +1871,6 @@ void bnx2x_link_status_update(struct link_params *params,
                                 vars->line_speed = SPEED_10000;
                                 break;
 
-                        case LINK_12GTFD:
-                                vars->line_speed = SPEED_12000;
-                                break;
-
-                        case LINK_12_5GTFD:
-                                vars->line_speed = SPEED_12500;
-                                break;
-
-                        case LINK_13GTFD:
-                                vars->line_speed = SPEED_13000;
-                                break;
-
-                        case LINK_15GTFD:
-                                vars->line_speed = SPEED_15000;
-                                break;
-
-                        case LINK_16GTFD:
-                                vars->line_speed = SPEED_16000;
-                                break;
-
                         default:
                                 break;
                 }
@@ -2667,31 +2694,6 @@ static int bnx2x_link_settings_status(struct bnx2x_phy *phy,
                         vars->link_status |= LINK_10GTFD;
                         break;
 
-                case GP_STATUS_12G_HIG:
-                        new_line_speed = SPEED_12000;
-                        vars->link_status |= LINK_12GTFD;
-                        break;
-
-                case GP_STATUS_12_5G:
-                        new_line_speed = SPEED_12500;
-                        vars->link_status |= LINK_12_5GTFD;
-                        break;
-
-                case GP_STATUS_13G:
-                        new_line_speed = SPEED_13000;
-                        vars->link_status |= LINK_13GTFD;
-                        break;
-
-                case GP_STATUS_15G:
-                        new_line_speed = SPEED_15000;
-                        vars->link_status |= LINK_15GTFD;
-                        break;
-
-                case GP_STATUS_16G:
-                        new_line_speed = SPEED_16000;
-                        vars->link_status |= LINK_16GTFD;
-                        break;
-
                 default:
                         DP(NETIF_MSG_LINK,
                                   "link speed unsupported gp_status 0x%x\n",
diff --git a/drivers/net/bnx2x/bnx2x_link.h b/drivers/net/bnx2x/bnx2x_link.h
index a106d8cbd69f..3fef7782490a 100644
--- a/drivers/net/bnx2x/bnx2x_link.h
+++ b/drivers/net/bnx2x/bnx2x_link.h
@@ -81,6 +81,7 @@
 #define PFC_BRB_FULL_LB_XOFF_THRESHOLD                          170
 #define PFC_BRB_FULL_LB_XON_THRESHOLD                           250
 
+#define MAXVAL(a, b) (((a) > (b)) ? (a) : (b))
 /***********************************************************/
 /*                         Structs                         */
 /***********************************************************/
@@ -262,6 +263,8 @@ struct link_vars {
 #define MAC_TYPE_NONE           0
 #define MAC_TYPE_EMAC           1
 #define MAC_TYPE_BMAC           2
+#define MAC_TYPE_UMAC           3
+#define MAC_TYPE_XMAC           4
 
         u8 phy_link_up; /* internal phy link indication */
         u8 link_up;
@@ -363,6 +366,20 @@ int bnx2x_phy_probe(struct link_params *params);
 u8 bnx2x_fan_failure_det_req(struct bnx2x *bp, u32 shmem_base,
                              u32 shmem2_base, u8 port);
 
+/* DCBX structs */
+
+/* Number of maximum COS per chip */
+#define DCBX_E2E3_MAX_NUM_COS           (2)
+#define DCBX_E3B0_MAX_NUM_COS_PORT0     (6)
+#define DCBX_E3B0_MAX_NUM_COS_PORT1     (3)
+#define DCBX_E3B0_MAX_NUM_COS           ( \
+                        MAXVAL(DCBX_E3B0_MAX_NUM_COS_PORT0, \
+                            DCBX_E3B0_MAX_NUM_COS_PORT1))
+
+#define DCBX_MAX_NUM_COS                        ( \
+                        MAXVAL(DCBX_E3B0_MAX_NUM_COS, \
+                            DCBX_E2E3_MAX_NUM_COS))
+
 /* PFC port configuration params */
 struct bnx2x_nig_brb_pfc_port_params {
         /* NIG */
@@ -370,8 +387,8 @@ struct bnx2x_nig_brb_pfc_port_params {
         u32 llfc_out_en;
         u32 llfc_enable;
         u32 pkt_priority_to_cos;
-        u32 rx_cos0_priority_mask;
-        u32 rx_cos1_priority_mask;
+        u8 num_of_rx_cos_priority_mask;
+        u32 rx_cos_priority_mask[DCBX_MAX_NUM_COS];
         u32 llfc_high_priority_classes;
         u32 llfc_low_priority_classes;
         /* BRB */
diff --git a/drivers/net/bnx2x/bnx2x_main.c b/drivers/net/bnx2x/bnx2x_main.c
index 84f419fcde26..63c92091586f 100644
--- a/drivers/net/bnx2x/bnx2x_main.c
+++ b/drivers/net/bnx2x/bnx2x_main.c
@@ -39,6 +39,7 @@
 #include <linux/mii.h>
 #include <linux/if_vlan.h>
 #include <net/ip.h>
+#include <net/ipv6.h>
 #include <net/tcp.h>
 #include <net/checksum.h>
 #include <net/ip6_checksum.h>
@@ -50,7 +51,6 @@
 #include <linux/io.h>
 #include <linux/stringify.h>
 
-#define BNX2X_MAIN
 #include "bnx2x.h"
 #include "bnx2x_init.h"
 #include "bnx2x_init_ops.h"
@@ -74,12 +74,14 @@
 #define TX_TIMEOUT              (5*HZ)
 
 static char version[] __devinitdata =
-        "Broadcom NetXtreme II 5771x 10Gigabit Ethernet Driver "
+        "Broadcom NetXtreme II 5771x/578xx 10/20-Gigabit Ethernet Driver "
         DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
 
 MODULE_AUTHOR("Eliezer Tamir");
 MODULE_DESCRIPTION("Broadcom NetXtreme II "
-                   "BCM57710/57711/57711E/57712/57712E Driver");
+                   "BCM57710/57711/57711E/"
+                   "57712/57712_MF/57800/57800_MF/57810/57810_MF/"
+                   "57840/57840_MF Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_MODULE_VERSION);
 MODULE_FIRMWARE(FW_FILE_NAME_E1);
@@ -104,7 +106,7 @@ MODULE_PARM_DESC(disable_tpa, " Disable the TPA (LRO) feature");
 #define INT_MODE_MSI                    2
 static int int_mode;
 module_param(int_mode, int, 0);
-MODULE_PARM_DESC(int_mode, " Force interrupt mode other then MSI-X "
+MODULE_PARM_DESC(int_mode, " Force interrupt mode other than MSI-X "
                                 "(1 INT#x; 2 MSI)");
 
 static int dropless_fc;
@@ -123,37 +125,87 @@ static int debug;
 module_param(debug, int, 0);
 MODULE_PARM_DESC(debug, " Default debug msglevel");
 
-static struct workqueue_struct *bnx2x_wq;
 
-#ifdef BCM_CNIC
-static u8 ALL_ENODE_MACS[] = {0x01, 0x10, 0x18, 0x01, 0x00, 0x01};
-#endif
+
+struct workqueue_struct *bnx2x_wq;
 
 enum bnx2x_board_type {
         BCM57710 = 0,
-        BCM57711 = 1,
-        BCM57711E = 2,
-        BCM57712 = 3,
-        BCM57712E = 4
+        BCM57711,
+        BCM57711E,
+        BCM57712,
+        BCM57712_MF,
+        BCM57800,
+        BCM57800_MF,
+        BCM57810,
+        BCM57810_MF,
+        BCM57840,
+        BCM57840_MF
 };
 
 /* indexed by board_type, above */
 static struct {
         char *name;
 } board_info[] __devinitdata = {
-        { "Broadcom NetXtreme II BCM57710 XGb" },
-        { "Broadcom NetXtreme II BCM57711 XGb" },
-        { "Broadcom NetXtreme II BCM57711E XGb" },
-        { "Broadcom NetXtreme II BCM57712 XGb" },
-        { "Broadcom NetXtreme II BCM57712E XGb" }
+        { "Broadcom NetXtreme II BCM57710 10 Gigabit PCIe [Everest]" },
+        { "Broadcom NetXtreme II BCM57711 10 Gigabit PCIe" },
+        { "Broadcom NetXtreme II BCM57711E 10 Gigabit PCIe" },
+        { "Broadcom NetXtreme II BCM57712 10 Gigabit Ethernet" },
+        { "Broadcom NetXtreme II BCM57712 10 Gigabit Ethernet Multi Function" },
+        { "Broadcom NetXtreme II BCM57800 10 Gigabit Ethernet" },
+        { "Broadcom NetXtreme II BCM57800 10 Gigabit Ethernet Multi Function" },
+        { "Broadcom NetXtreme II BCM57810 10 Gigabit Ethernet" },
+        { "Broadcom NetXtreme II BCM57810 10 Gigabit Ethernet Multi Function" },
+        { "Broadcom NetXtreme II BCM57840 10/20 Gigabit Ethernet" },
+        { "Broadcom NetXtreme II BCM57840 10/20 Gigabit "
+                                                "Ethernet Multi Function"}
 };
 
+#ifndef PCI_DEVICE_ID_NX2_57710
+#define PCI_DEVICE_ID_NX2_57710         CHIP_NUM_57710
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57711
+#define PCI_DEVICE_ID_NX2_57711         CHIP_NUM_57711
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57711E
+#define PCI_DEVICE_ID_NX2_57711E        CHIP_NUM_57711E
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57712
+#define PCI_DEVICE_ID_NX2_57712         CHIP_NUM_57712
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57712_MF
+#define PCI_DEVICE_ID_NX2_57712_MF      CHIP_NUM_57712_MF
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57800
+#define PCI_DEVICE_ID_NX2_57800         CHIP_NUM_57800
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57800_MF
+#define PCI_DEVICE_ID_NX2_57800_MF      CHIP_NUM_57800_MF
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57810
+#define PCI_DEVICE_ID_NX2_57810         CHIP_NUM_57810
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57810_MF
+#define PCI_DEVICE_ID_NX2_57810_MF      CHIP_NUM_57810_MF
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57840
+#define PCI_DEVICE_ID_NX2_57840         CHIP_NUM_57840
+#endif
+#ifndef PCI_DEVICE_ID_NX2_57840_MF
+#define PCI_DEVICE_ID_NX2_57840_MF      CHIP_NUM_57840_MF
+#endif
 static DEFINE_PCI_DEVICE_TABLE(bnx2x_pci_tbl) = {
         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57710), BCM57710 },
         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711), BCM57711 },
         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711E), BCM57711E },
         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712), BCM57712 },
-        { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712E), BCM57712E },
+        { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712_MF), BCM57712_MF },
+        { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800), BCM57800 },
+        { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800_MF), BCM57800_MF },
+        { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810), BCM57810 },
+        { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810_MF), BCM57810_MF },
+        { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840), BCM57840 },
+        { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_MF), BCM57840_MF },
         { 0 }
 };
 
@@ -163,11 +215,47 @@ MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
 * General service functions
 ****************************************************************************/
 
-static inline void storm_memset_ov(struct bnx2x *bp, u16 ov, u16 abs_fid)
+static inline void __storm_memset_dma_mapping(struct bnx2x *bp,
+                                       u32 addr, dma_addr_t mapping)
+{
+        REG_WR(bp,  addr, U64_LO(mapping));
+        REG_WR(bp,  addr + 4, U64_HI(mapping));
+}
+
+static inline void storm_memset_spq_addr(struct bnx2x *bp,
+                                         dma_addr_t mapping, u16 abs_fid)
+{
+        u32 addr = XSEM_REG_FAST_MEMORY +
+                        XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid);
+
+        __storm_memset_dma_mapping(bp, addr, mapping);
+}
+
+static inline void storm_memset_vf_to_pf(struct bnx2x *bp, u16 abs_fid,
+                                         u16 pf_id)
 {
-        REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_E1HOV_OFFSET(abs_fid), ov);
+        REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid),
+                pf_id);
+        REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid),
+                pf_id);
+        REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid),
+                pf_id);
+        REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid),
+                pf_id);
 }
 
+static inline void storm_memset_func_en(struct bnx2x *bp, u16 abs_fid,
+                                        u8 enable)
+{
+        REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid),
+                enable);
+        REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid),
+                enable);
+        REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid),
+                enable);
+        REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid),
+                enable);
+}
 
 static inline void storm_memset_eq_data(struct bnx2x *bp,
                                 struct event_ring_data *eq_data,
@@ -187,45 +275,6 @@ static inline void storm_memset_eq_prod(struct bnx2x *bp, u16 eq_prod,
         REG_WR16(bp, addr, eq_prod);
 }
 
-static inline void storm_memset_hc_timeout(struct bnx2x *bp, u8 port,
-                                             u16 fw_sb_id, u8 sb_index,
-                                             u8 ticks)
-{
-
-        int index_offset = CHIP_IS_E2(bp) ?
-                offsetof(struct hc_status_block_data_e2, index_data) :
-                offsetof(struct hc_status_block_data_e1x, index_data);
-        u32 addr = BAR_CSTRORM_INTMEM +
-                        CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
-                        index_offset +
-                        sizeof(struct hc_index_data)*sb_index +
-                        offsetof(struct hc_index_data, timeout);
-        REG_WR8(bp, addr, ticks);
-        DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d ticks %d\n",
-                          port, fw_sb_id, sb_index, ticks);
-}
-static inline void storm_memset_hc_disable(struct bnx2x *bp, u8 port,
-                                             u16 fw_sb_id, u8 sb_index,
-                                             u8 disable)
-{
-        u32 enable_flag = disable ? 0 : (1 << HC_INDEX_DATA_HC_ENABLED_SHIFT);
-        int index_offset = CHIP_IS_E2(bp) ?
-                offsetof(struct hc_status_block_data_e2, index_data) :
-                offsetof(struct hc_status_block_data_e1x, index_data);
-        u32 addr = BAR_CSTRORM_INTMEM +
-                        CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
-                        index_offset +
-                        sizeof(struct hc_index_data)*sb_index +
-                        offsetof(struct hc_index_data, flags);
-        u16 flags = REG_RD16(bp, addr);
-        /* clear and set */
-        flags &= ~HC_INDEX_DATA_HC_ENABLED;
-        flags |= enable_flag;
-        REG_WR16(bp, addr, flags);
-        DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d disable %d\n",
-                          port, fw_sb_id, sb_index, disable);
-}
-
 /* used only at init
  * locking is done by mcp
  */
@@ -319,13 +368,6 @@ static void bnx2x_dp_dmae(struct bnx2x *bp, struct dmae_command *dmae,
 
 }
 
-const u32 dmae_reg_go_c[] = {
-        DMAE_REG_GO_C0, DMAE_REG_GO_C1, DMAE_REG_GO_C2, DMAE_REG_GO_C3,
-        DMAE_REG_GO_C4, DMAE_REG_GO_C5, DMAE_REG_GO_C6, DMAE_REG_GO_C7,
-        DMAE_REG_GO_C8, DMAE_REG_GO_C9, DMAE_REG_GO_C10, DMAE_REG_GO_C11,
-        DMAE_REG_GO_C12, DMAE_REG_GO_C13, DMAE_REG_GO_C14, DMAE_REG_GO_C15
-};
-
 /* copy command into DMAE command memory and set DMAE command go */
 void bnx2x_post_dmae(struct bnx2x *bp, struct dmae_command *dmae, int idx)
 {
@@ -406,7 +448,11 @@ static int bnx2x_issue_dmae_with_comp(struct bnx2x *bp,
            bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
            bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
 
-        /* lock the dmae channel */
+        /*
+         * Lock the dmae channel. Disable BHs to prevent a dead-lock
+         * as long as this code is called both from syscall context and
+         * from ndo_set_rx_mode() flow that may be called from BH.
+         */
         spin_lock_bh(&bp->dmae_lock);
 
         /* reset completion */
@@ -730,9 +776,9 @@ void bnx2x_panic_dump(struct bnx2x *bp)
         /* Indices */
         /* Common */
         BNX2X_ERR("def_idx(0x%x)  def_att_idx(0x%x)  attn_state(0x%x)"
-                  "  spq_prod_idx(0x%x)\n",
-                  bp->def_idx, bp->def_att_idx,
-                  bp->attn_state, bp->spq_prod_idx);
+                  "  spq_prod_idx(0x%x) next_stats_cnt(0x%x)\n",
+                  bp->def_idx, bp->def_att_idx, bp->attn_state,
+                  bp->spq_prod_idx, bp->stats_counter);
         BNX2X_ERR("DSB: attn bits(0x%x)  ack(0x%x)  id(0x%x)  idx(0x%x)\n",
                   bp->def_status_blk->atten_status_block.attn_bits,
                   bp->def_status_blk->atten_status_block.attn_bits_ack,
@@ -749,15 +795,17 @@ void bnx2x_panic_dump(struct bnx2x *bp)
                         CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
                         i*sizeof(u32));
 
-        pr_cont("igu_sb_id(0x%x)  igu_seg_id (0x%x) "
+        pr_cont("igu_sb_id(0x%x)  igu_seg_id(0x%x) "
                          "pf_id(0x%x)  vnic_id(0x%x)  "
-                         "vf_id(0x%x)  vf_valid (0x%x)\n",
+                         "vf_id(0x%x)  vf_valid (0x%x) "
+                         "state(0x%x)\n",
                sp_sb_data.igu_sb_id,
                sp_sb_data.igu_seg_id,
                sp_sb_data.p_func.pf_id,
                sp_sb_data.p_func.vnic_id,
                sp_sb_data.p_func.vf_id,
-               sp_sb_data.p_func.vf_valid);
+               sp_sb_data.p_func.vf_valid,
+               sp_sb_data.state);
 
 
         for_each_eth_queue(bp, i) {
@@ -766,13 +814,13 @@ void bnx2x_panic_dump(struct bnx2x *bp)
                 struct hc_status_block_data_e2 sb_data_e2;
                 struct hc_status_block_data_e1x sb_data_e1x;
                 struct hc_status_block_sm  *hc_sm_p =
-                        CHIP_IS_E2(bp) ?
-                        sb_data_e2.common.state_machine :
-                        sb_data_e1x.common.state_machine;
+                        CHIP_IS_E1x(bp) ?
+                        sb_data_e1x.common.state_machine :
+                        sb_data_e2.common.state_machine;
                 struct hc_index_data *hc_index_p =
-                        CHIP_IS_E2(bp) ?
-                        sb_data_e2.index_data :
-                        sb_data_e1x.index_data;
+                        CHIP_IS_E1x(bp) ?
+                        sb_data_e1x.index_data :
+                        sb_data_e2.index_data;
                 int data_size;
                 u32 *sb_data_p;
 
@@ -795,8 +843,8 @@ void bnx2x_panic_dump(struct bnx2x *bp)
                           i, fp->tx_pkt_prod, fp->tx_pkt_cons, fp->tx_bd_prod,
                           fp->tx_bd_cons, le16_to_cpu(*fp->tx_cons_sb));
 
-                loop = CHIP_IS_E2(bp) ?
-                        HC_SB_MAX_INDICES_E2 : HC_SB_MAX_INDICES_E1X;
+                loop = CHIP_IS_E1x(bp) ?
+                        HC_SB_MAX_INDICES_E1X : HC_SB_MAX_INDICES_E2;
 
                 /* host sb data */
 
@@ -816,35 +864,39 @@ void bnx2x_panic_dump(struct bnx2x *bp)
                                fp->sb_index_values[j],
                                (j == loop - 1) ? ")" : " ");
                 /* fw sb data */
-                data_size = CHIP_IS_E2(bp) ?
-                        sizeof(struct hc_status_block_data_e2) :
-                        sizeof(struct hc_status_block_data_e1x);
+                data_size = CHIP_IS_E1x(bp) ?
+                        sizeof(struct hc_status_block_data_e1x) :
+                        sizeof(struct hc_status_block_data_e2);
                 data_size /= sizeof(u32);
-                sb_data_p = CHIP_IS_E2(bp) ?
-                        (u32 *)&sb_data_e2 :
-                        (u32 *)&sb_data_e1x;
+                sb_data_p = CHIP_IS_E1x(bp) ?
+                        (u32 *)&sb_data_e1x :
+                        (u32 *)&sb_data_e2;
                 /* copy sb data in here */
                 for (j = 0; j < data_size; j++)
                         *(sb_data_p + j) = REG_RD(bp, BAR_CSTRORM_INTMEM +
                                 CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id) +
                                 j * sizeof(u32));
 
-                if (CHIP_IS_E2(bp)) {
-                        pr_cont("pf_id(0x%x)  vf_id (0x%x)  vf_valid(0x%x) "
-                                "vnic_id(0x%x)  same_igu_sb_1b(0x%x)\n",
+                if (!CHIP_IS_E1x(bp)) {
+                        pr_cont("pf_id(0x%x)  vf_id(0x%x)  vf_valid(0x%x) "
+                                "vnic_id(0x%x)  same_igu_sb_1b(0x%x) "
+                                "state(0x%x)\n",
                                 sb_data_e2.common.p_func.pf_id,
                                 sb_data_e2.common.p_func.vf_id,
                                 sb_data_e2.common.p_func.vf_valid,
                                 sb_data_e2.common.p_func.vnic_id,
-                                sb_data_e2.common.same_igu_sb_1b);
+                                sb_data_e2.common.same_igu_sb_1b,
+                                sb_data_e2.common.state);
                 } else {
-                        pr_cont("pf_id(0x%x)  vf_id (0x%x)  vf_valid(0x%x) "
-                                "vnic_id(0x%x)  same_igu_sb_1b(0x%x)\n",
+                        pr_cont("pf_id(0x%x)  vf_id(0x%x)  vf_valid(0x%x) "
+                                "vnic_id(0x%x)  same_igu_sb_1b(0x%x) "
+                                "state(0x%x)\n",
                                 sb_data_e1x.common.p_func.pf_id,
                                 sb_data_e1x.common.p_func.vf_id,
                                 sb_data_e1x.common.p_func.vf_valid,
                                 sb_data_e1x.common.p_func.vnic_id,
-                                sb_data_e1x.common.same_igu_sb_1b);
+                                sb_data_e1x.common.same_igu_sb_1b,
+                                sb_data_e1x.common.state);
                 }
 
                 /* SB_SMs data */
@@ -933,6 +985,373 @@ void bnx2x_panic_dump(struct bnx2x *bp)
         BNX2X_ERR("end crash dump -----------------\n");
 }
 
+/*
+ * FLR Support for E2
+ *
+ * bnx2x_pf_flr_clnup() is called during nic_load in the per function HW
+ * initialization.
+ */
+#define FLR_WAIT_USEC           10000   /* 10 miliseconds */
+#define FLR_WAIT_INTERAVAL      50      /* usec */
+#define FLR_POLL_CNT            (FLR_WAIT_USEC/FLR_WAIT_INTERAVAL) /* 200 */
+
+struct pbf_pN_buf_regs {
+        int pN;
+        u32 init_crd;
+        u32 crd;
+        u32 crd_freed;
+};
+
+struct pbf_pN_cmd_regs {
+        int pN;
+        u32 lines_occup;
+        u32 lines_freed;
+};
+
+static void bnx2x_pbf_pN_buf_flushed(struct bnx2x *bp,
+                                     struct pbf_pN_buf_regs *regs,
+                                     u32 poll_count)
+{
+        u32 init_crd, crd, crd_start, crd_freed, crd_freed_start;
+        u32 cur_cnt = poll_count;
+
+        crd_freed = crd_freed_start = REG_RD(bp, regs->crd_freed);
+        crd = crd_start = REG_RD(bp, regs->crd);
+        init_crd = REG_RD(bp, regs->init_crd);
+
+        DP(BNX2X_MSG_SP, "INIT CREDIT[%d] : %x\n", regs->pN, init_crd);
+        DP(BNX2X_MSG_SP, "CREDIT[%d]      : s:%x\n", regs->pN, crd);
+        DP(BNX2X_MSG_SP, "CREDIT_FREED[%d]: s:%x\n", regs->pN, crd_freed);
+
+        while ((crd != init_crd) && ((u32)SUB_S32(crd_freed, crd_freed_start) <
+               (init_crd - crd_start))) {
+                if (cur_cnt--) {
+                        udelay(FLR_WAIT_INTERAVAL);
+                        crd = REG_RD(bp, regs->crd);
+                        crd_freed = REG_RD(bp, regs->crd_freed);
+                } else {
+                        DP(BNX2X_MSG_SP, "PBF tx buffer[%d] timed out\n",
+                           regs->pN);
+                        DP(BNX2X_MSG_SP, "CREDIT[%d]      : c:%x\n",
+                           regs->pN, crd);
+                        DP(BNX2X_MSG_SP, "CREDIT_FREED[%d]: c:%x\n",
+                           regs->pN, crd_freed);
+                        break;
+                }
+        }
+        DP(BNX2X_MSG_SP, "Waited %d*%d usec for PBF tx buffer[%d]\n",
+           poll_count-cur_cnt, FLR_WAIT_INTERAVAL, regs->pN);
+}
+
+static void bnx2x_pbf_pN_cmd_flushed(struct bnx2x *bp,
+                                     struct pbf_pN_cmd_regs *regs,
+                                     u32 poll_count)
+{
+        u32 occup, to_free, freed, freed_start;
+        u32 cur_cnt = poll_count;
+
+        occup = to_free = REG_RD(bp, regs->lines_occup);
+        freed = freed_start = REG_RD(bp, regs->lines_freed);
+
+        DP(BNX2X_MSG_SP, "OCCUPANCY[%d]   : s:%x\n", regs->pN, occup);
+        DP(BNX2X_MSG_SP, "LINES_FREED[%d] : s:%x\n", regs->pN, freed);
+
+        while (occup && ((u32)SUB_S32(freed, freed_start) < to_free)) {
+                if (cur_cnt--) {
+                        udelay(FLR_WAIT_INTERAVAL);
+                        occup = REG_RD(bp, regs->lines_occup);
+                        freed = REG_RD(bp, regs->lines_freed);
+                } else {
+                        DP(BNX2X_MSG_SP, "PBF cmd queue[%d] timed out\n",
+                           regs->pN);
+                        DP(BNX2X_MSG_SP, "OCCUPANCY[%d]   : s:%x\n",
+                           regs->pN, occup);
+                        DP(BNX2X_MSG_SP, "LINES_FREED[%d] : s:%x\n",
+                           regs->pN, freed);
+                        break;
+                }
+        }
+        DP(BNX2X_MSG_SP, "Waited %d*%d usec for PBF cmd queue[%d]\n",
+           poll_count-cur_cnt, FLR_WAIT_INTERAVAL, regs->pN);
+}
+
+static inline u32 bnx2x_flr_clnup_reg_poll(struct bnx2x *bp, u32 reg,
+                                     u32 expected, u32 poll_count)
+{
+        u32 cur_cnt = poll_count;
+        u32 val;
+
+        while ((val = REG_RD(bp, reg)) != expected && cur_cnt--)
+                udelay(FLR_WAIT_INTERAVAL);
+
+        return val;
+}
+
+static inline int bnx2x_flr_clnup_poll_hw_counter(struct bnx2x *bp, u32 reg,
+                                                  char *msg, u32 poll_cnt)
+{
+        u32 val = bnx2x_flr_clnup_reg_poll(bp, reg, 0, poll_cnt);
+        if (val != 0) {
+                BNX2X_ERR("%s usage count=%d\n", msg, val);
+                return 1;
+        }
+        return 0;
+}
+
+static u32 bnx2x_flr_clnup_poll_count(struct bnx2x *bp)
+{
+        /* adjust polling timeout */
+        if (CHIP_REV_IS_EMUL(bp))
+                return FLR_POLL_CNT * 2000;
+
+        if (CHIP_REV_IS_FPGA(bp))
+                return FLR_POLL_CNT * 120;
+
+        return FLR_POLL_CNT;
+}
+
+static void bnx2x_tx_hw_flushed(struct bnx2x *bp, u32 poll_count)
+{
+        struct pbf_pN_cmd_regs cmd_regs[] = {
+                {0, (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_TQ_OCCUPANCY_Q0 :
+                        PBF_REG_P0_TQ_OCCUPANCY,
+                    (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_TQ_LINES_FREED_CNT_Q0 :
+                        PBF_REG_P0_TQ_LINES_FREED_CNT},
+                {1, (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_TQ_OCCUPANCY_Q1 :
+                        PBF_REG_P1_TQ_OCCUPANCY,
+                    (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_TQ_LINES_FREED_CNT_Q1 :
+                        PBF_REG_P1_TQ_LINES_FREED_CNT},
+                {4, (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_TQ_OCCUPANCY_LB_Q :
+                        PBF_REG_P4_TQ_OCCUPANCY,
+                    (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_TQ_LINES_FREED_CNT_LB_Q :
+                        PBF_REG_P4_TQ_LINES_FREED_CNT}
+        };
+
+        struct pbf_pN_buf_regs buf_regs[] = {
+                {0, (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_INIT_CRD_Q0 :
+                        PBF_REG_P0_INIT_CRD ,
+                    (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_CREDIT_Q0 :
+                        PBF_REG_P0_CREDIT,
+                    (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_INTERNAL_CRD_FREED_CNT_Q0 :
+                        PBF_REG_P0_INTERNAL_CRD_FREED_CNT},
+                {1, (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_INIT_CRD_Q1 :
+                        PBF_REG_P1_INIT_CRD,
+                    (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_CREDIT_Q1 :
+                        PBF_REG_P1_CREDIT,
+                    (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_INTERNAL_CRD_FREED_CNT_Q1 :
+                        PBF_REG_P1_INTERNAL_CRD_FREED_CNT},
+                {4, (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_INIT_CRD_LB_Q :
+                        PBF_REG_P4_INIT_CRD,
+                    (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_CREDIT_LB_Q :
+                        PBF_REG_P4_CREDIT,
+                    (CHIP_IS_E3B0(bp)) ?
+                        PBF_REG_INTERNAL_CRD_FREED_CNT_LB_Q :
+                        PBF_REG_P4_INTERNAL_CRD_FREED_CNT},
+        };
+
+        int i;
+
+        /* Verify the command queues are flushed P0, P1, P4 */
+        for (i = 0; i < ARRAY_SIZE(cmd_regs); i++)
+                bnx2x_pbf_pN_cmd_flushed(bp, &cmd_regs[i], poll_count);
+
+
+        /* Verify the transmission buffers are flushed P0, P1, P4 */
+        for (i = 0; i < ARRAY_SIZE(buf_regs); i++)
+                bnx2x_pbf_pN_buf_flushed(bp, &buf_regs[i], poll_count);
+}
+
+#define OP_GEN_PARAM(param) \
+        (((param) << SDM_OP_GEN_COMP_PARAM_SHIFT) & SDM_OP_GEN_COMP_PARAM)
+
+#define OP_GEN_TYPE(type) \
+        (((type) << SDM_OP_GEN_COMP_TYPE_SHIFT) & SDM_OP_GEN_COMP_TYPE)
+
+#define OP_GEN_AGG_VECT(index) \
+        (((index) << SDM_OP_GEN_AGG_VECT_IDX_SHIFT) & SDM_OP_GEN_AGG_VECT_IDX)
+
+
+static inline int bnx2x_send_final_clnup(struct bnx2x *bp, u8 clnup_func,
+                                         u32 poll_cnt)
+{
+        struct sdm_op_gen op_gen = {0};
+
+        u32 comp_addr = BAR_CSTRORM_INTMEM +
+                        CSTORM_FINAL_CLEANUP_COMPLETE_OFFSET(clnup_func);
+        int ret = 0;
+
+        if (REG_RD(bp, comp_addr)) {
+                BNX2X_ERR("Cleanup complete is not 0\n");
+                return 1;
+        }
+
+        op_gen.command |= OP_GEN_PARAM(XSTORM_AGG_INT_FINAL_CLEANUP_INDEX);
+        op_gen.command |= OP_GEN_TYPE(XSTORM_AGG_INT_FINAL_CLEANUP_COMP_TYPE);
+        op_gen.command |= OP_GEN_AGG_VECT(clnup_func);
+        op_gen.command |= 1 << SDM_OP_GEN_AGG_VECT_IDX_VALID_SHIFT;
+
+        DP(BNX2X_MSG_SP, "FW Final cleanup\n");
+        REG_WR(bp, XSDM_REG_OPERATION_GEN, op_gen.command);
+
+        if (bnx2x_flr_clnup_reg_poll(bp, comp_addr, 1, poll_cnt) != 1) {
+                BNX2X_ERR("FW final cleanup did not succeed\n");
+                ret = 1;
+        }
+        /* Zero completion for nxt FLR */
+        REG_WR(bp, comp_addr, 0);
+
+        return ret;
+}
+
+static inline u8 bnx2x_is_pcie_pending(struct pci_dev *dev)
+{
+        int pos;
+        u16 status;
+
+        pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
+        if (!pos)
+                return false;
+
+        pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &status);
+        return status & PCI_EXP_DEVSTA_TRPND;
+}
+
+/* PF FLR specific routines
+*/
+static int bnx2x_poll_hw_usage_counters(struct bnx2x *bp, u32 poll_cnt)
+{
+
+        /* wait for CFC PF usage-counter to zero (includes all the VFs) */
+        if (bnx2x_flr_clnup_poll_hw_counter(bp,
+                        CFC_REG_NUM_LCIDS_INSIDE_PF,
+                        "CFC PF usage counter timed out",
+                        poll_cnt))
+                return 1;
+
+
+        /* Wait for DQ PF usage-counter to zero (until DQ cleanup) */
+        if (bnx2x_flr_clnup_poll_hw_counter(bp,
+                        DORQ_REG_PF_USAGE_CNT,
+                        "DQ PF usage counter timed out",
+                        poll_cnt))
+                return 1;
+
+        /* Wait for QM PF usage-counter to zero (until DQ cleanup) */
+        if (bnx2x_flr_clnup_poll_hw_counter(bp,
+                        QM_REG_PF_USG_CNT_0 + 4*BP_FUNC(bp),
+                        "QM PF usage counter timed out",
+                        poll_cnt))
+                return 1;
+
+        /* Wait for Timer PF usage-counters to zero (until DQ cleanup) */
+        if (bnx2x_flr_clnup_poll_hw_counter(bp,
+                        TM_REG_LIN0_VNIC_UC + 4*BP_PORT(bp),
+                        "Timers VNIC usage counter timed out",
+                        poll_cnt))
+                return 1;
+        if (bnx2x_flr_clnup_poll_hw_counter(bp,
+                        TM_REG_LIN0_NUM_SCANS + 4*BP_PORT(bp),
+                        "Timers NUM_SCANS usage counter timed out",
+                        poll_cnt))
+                return 1;
+
+        /* Wait DMAE PF usage counter to zero */
+        if (bnx2x_flr_clnup_poll_hw_counter(bp,
+                        dmae_reg_go_c[INIT_DMAE_C(bp)],
+                        "DMAE dommand register timed out",
+                        poll_cnt))
+                return 1;
+
+        return 0;
+}
+
+static void bnx2x_hw_enable_status(struct bnx2x *bp)
+{
+        u32 val;
+
+        val = REG_RD(bp, CFC_REG_WEAK_ENABLE_PF);
+        DP(BNX2X_MSG_SP, "CFC_REG_WEAK_ENABLE_PF is 0x%x\n", val);
+
+        val = REG_RD(bp, PBF_REG_DISABLE_PF);
+        DP(BNX2X_MSG_SP, "PBF_REG_DISABLE_PF is 0x%x\n", val);
+
+        val = REG_RD(bp, IGU_REG_PCI_PF_MSI_EN);
+        DP(BNX2X_MSG_SP, "IGU_REG_PCI_PF_MSI_EN is 0x%x\n", val);
+
+        val = REG_RD(bp, IGU_REG_PCI_PF_MSIX_EN);
+        DP(BNX2X_MSG_SP, "IGU_REG_PCI_PF_MSIX_EN is 0x%x\n", val);
+
+        val = REG_RD(bp, IGU_REG_PCI_PF_MSIX_FUNC_MASK);
+        DP(BNX2X_MSG_SP, "IGU_REG_PCI_PF_MSIX_FUNC_MASK is 0x%x\n", val);
+
+        val = REG_RD(bp, PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR);
+        DP(BNX2X_MSG_SP, "PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR is 0x%x\n", val);
+
+        val = REG_RD(bp, PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR);
+        DP(BNX2X_MSG_SP, "PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR is 0x%x\n", val);
+
+        val = REG_RD(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER);
+        DP(BNX2X_MSG_SP, "PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER is 0x%x\n",
+           val);
+}
+
+static int bnx2x_pf_flr_clnup(struct bnx2x *bp)
+{
+        u32 poll_cnt = bnx2x_flr_clnup_poll_count(bp);
+
+        DP(BNX2X_MSG_SP, "Cleanup after FLR PF[%d]\n", BP_ABS_FUNC(bp));
+
+        /* Re-enable PF target read access */
+        REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_TARGET_READ, 1);
+
+        /* Poll HW usage counters */
+        if (bnx2x_poll_hw_usage_counters(bp, poll_cnt))
+                return -EBUSY;
+
+        /* Zero the igu 'trailing edge' and 'leading edge' */
+
+        /* Send the FW cleanup command */
+        if (bnx2x_send_final_clnup(bp, (u8)BP_FUNC(bp), poll_cnt))
+                return -EBUSY;
+
+        /* ATC cleanup */
+
+        /* Verify TX hw is flushed */
+        bnx2x_tx_hw_flushed(bp, poll_cnt);
+
+        /* Wait 100ms (not adjusted according to platform) */
+        msleep(100);
+
+        /* Verify no pending pci transactions */
+        if (bnx2x_is_pcie_pending(bp->pdev))
+                BNX2X_ERR("PCIE Transactions still pending\n");
+
+        /* Debug */
+        bnx2x_hw_enable_status(bp);
+
+        /*
+         * Master enable - Due to WB DMAE writes performed before this
+         * register is re-initialized as part of the regular function init
+         */
+        REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
+
+        return 0;
+}
+
 static void bnx2x_hc_int_enable(struct bnx2x *bp)
 {
         int port = BP_PORT(bp);
@@ -1188,52 +1607,85 @@ static bool bnx2x_trylock_hw_lock(struct bnx2x *bp, u32 resource)
 }
 
 #ifdef BCM_CNIC
-static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid);
+static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid, u8 err);
 #endif
 
-void bnx2x_sp_event(struct bnx2x_fastpath *fp,
-                           union eth_rx_cqe *rr_cqe)
+void bnx2x_sp_event(struct bnx2x_fastpath *fp, union eth_rx_cqe *rr_cqe)
 {
         struct bnx2x *bp = fp->bp;
         int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
         int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
+        enum bnx2x_queue_cmd drv_cmd = BNX2X_Q_CMD_MAX;
+        struct bnx2x_queue_sp_obj *q_obj = &fp->q_obj;
 
         DP(BNX2X_MSG_SP,
            "fp %d  cid %d  got ramrod #%d  state is %x  type is %d\n",
            fp->index, cid, command, bp->state,
            rr_cqe->ramrod_cqe.ramrod_type);
 
-        switch (command | fp->state) {
-        case (RAMROD_CMD_ID_ETH_CLIENT_SETUP | BNX2X_FP_STATE_OPENING):
+        switch (command) {
+        case (RAMROD_CMD_ID_ETH_CLIENT_UPDATE):
+                DP(NETIF_MSG_IFUP, "got UPDATE ramrod. CID %d\n", cid);
+                drv_cmd = BNX2X_Q_CMD_UPDATE;
+                break;
+        case (RAMROD_CMD_ID_ETH_CLIENT_SETUP):
                 DP(NETIF_MSG_IFUP, "got MULTI[%d] setup ramrod\n", cid);
-                fp->state = BNX2X_FP_STATE_OPEN;
+                drv_cmd = BNX2X_Q_CMD_SETUP;
                 break;
 
-        case (RAMROD_CMD_ID_ETH_HALT | BNX2X_FP_STATE_HALTING):
+        case (RAMROD_CMD_ID_ETH_HALT):
                 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] halt ramrod\n", cid);
-                fp->state = BNX2X_FP_STATE_HALTED;
+                drv_cmd = BNX2X_Q_CMD_HALT;
                 break;
 
-        case (RAMROD_CMD_ID_ETH_TERMINATE | BNX2X_FP_STATE_TERMINATING):
+        case (RAMROD_CMD_ID_ETH_TERMINATE):
                 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] teminate ramrod\n", cid);
-                fp->state = BNX2X_FP_STATE_TERMINATED;
+                drv_cmd = BNX2X_Q_CMD_TERMINATE;
                 break;
 
-        default:
-                BNX2X_ERR("unexpected MC reply (%d)  "
-                          "fp[%d] state is %x\n",
-                          command, fp->index, fp->state);
+        case (RAMROD_CMD_ID_ETH_EMPTY):
+                DP(NETIF_MSG_IFDOWN, "got MULTI[%d] empty ramrod\n", cid);
+                drv_cmd = BNX2X_Q_CMD_EMPTY;
                 break;
+
+        default:
+                BNX2X_ERR("unexpected MC reply (%d) on fp[%d]\n",
+                          command, fp->index);
+                return;
         }
 
+        if ((drv_cmd != BNX2X_Q_CMD_MAX) &&
+            q_obj->complete_cmd(bp, q_obj, drv_cmd))
+                /* q_obj->complete_cmd() failure means that this was
+                 * an unexpected completion.
+                 *
+                 * In this case we don't want to increase the bp->spq_left
+                 * because apparently we haven't sent this command the first
+                 * place.
+                 */
+#ifdef BNX2X_STOP_ON_ERROR
+                bnx2x_panic();
+#else
+                return;
+#endif
+
         smp_mb__before_atomic_inc();
         atomic_inc(&bp->cq_spq_left);
-        /* push the change in fp->state and towards the memory */
-        smp_wmb();
+        /* push the change in bp->spq_left and towards the memory */
+        smp_mb__after_atomic_inc();
 
         return;
 }
 
+void bnx2x_update_rx_prod(struct bnx2x *bp, struct bnx2x_fastpath *fp,
+                        u16 bd_prod, u16 rx_comp_prod, u16 rx_sge_prod)
+{
+        u32 start = BAR_USTRORM_INTMEM + fp->ustorm_rx_prods_offset;
+
+        bnx2x_update_rx_prod_gen(bp, fp, bd_prod, rx_comp_prod, rx_sge_prod,
+                                 start);
+}
+
 irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
 {
         struct bnx2x *bp = netdev_priv(dev_instance);
@@ -1258,7 +1710,7 @@ irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
 
                 mask = 0x2 << (fp->index + CNIC_CONTEXT_USE);
                 if (status & mask) {
-                        /* Handle Rx and Tx according to SB id */
+                        /* Handle Rx or Tx according to SB id */
                         prefetch(fp->rx_cons_sb);
                         prefetch(fp->tx_cons_sb);
                         prefetch(&fp->sb_running_index[SM_RX_ID]);
@@ -1272,11 +1724,13 @@ irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
         if (status & (mask | 0x1)) {
                 struct cnic_ops *c_ops = NULL;
 
-                rcu_read_lock();
-                c_ops = rcu_dereference(bp->cnic_ops);
-                if (c_ops)
-                        c_ops->cnic_handler(bp->cnic_data, NULL);
-                rcu_read_unlock();
+                if (likely(bp->state == BNX2X_STATE_OPEN)) {
+                        rcu_read_lock();
+                        c_ops = rcu_dereference(bp->cnic_ops);
+                        if (c_ops)
+                                c_ops->cnic_handler(bp->cnic_data, NULL);
+                        rcu_read_unlock();
+                }
 
                 status &= ~mask;
         }
@@ -1297,9 +1751,6 @@ irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
         return IRQ_HANDLED;
 }
 
-/* end of fast path */
-
-
 /* Link */
 
 /*
@@ -1939,11 +2390,11 @@ static void bnx2x_link_attn(struct bnx2x *bp)
                                pause_enabled);
                 }
 
-                if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
+                if (bp->link_vars.mac_type != MAC_TYPE_EMAC) {
                         struct host_port_stats *pstats;
 
                         pstats = bnx2x_sp(bp, port_stats);
-                        /* reset old bmac stats */
+                        /* reset old mac stats */
                         memset(&(pstats->mac_stx[0]), 0,
                                sizeof(struct mac_stx));
                 }
@@ -1998,7 +2449,7 @@ static void bnx2x_pmf_update(struct bnx2x *bp)
         if (bp->common.int_block == INT_BLOCK_HC) {
                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
-        } else if (CHIP_IS_E2(bp)) {
+        } else if (!CHIP_IS_E1x(bp)) {
                 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
                 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
         }
@@ -2059,45 +2510,89 @@ u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param)
 static u8 stat_counter_valid(struct bnx2x *bp, struct bnx2x_fastpath *fp)
 {
 #ifdef BCM_CNIC
-        if (IS_FCOE_FP(fp) && IS_MF(bp))
+        /* Statistics are not supported for CNIC Clients at the moment */
+        if (IS_FCOE_FP(fp))
                 return false;
 #endif
         return true;
 }
 
-static inline u16 bnx2x_get_cl_flags(struct bnx2x *bp,
-                                     struct bnx2x_fastpath *fp)
+void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p)
+{
+        if (CHIP_IS_E1x(bp)) {
+                struct tstorm_eth_function_common_config tcfg = {0};
+
+                storm_memset_func_cfg(bp, &tcfg, p->func_id);
+        }
+
+        /* Enable the function in the FW */
+        storm_memset_vf_to_pf(bp, p->func_id, p->pf_id);
+        storm_memset_func_en(bp, p->func_id, 1);
+
+        /* spq */
+        if (p->func_flgs & FUNC_FLG_SPQ) {
+                storm_memset_spq_addr(bp, p->spq_map, p->func_id);
+                REG_WR(bp, XSEM_REG_FAST_MEMORY +
+                       XSTORM_SPQ_PROD_OFFSET(p->func_id), p->spq_prod);
+        }
+}
+
+static inline unsigned long bnx2x_get_q_flags(struct bnx2x *bp,
+                                              struct bnx2x_fastpath *fp,
+                                              bool leading)
 {
-        u16 flags = 0;
+        unsigned long flags = 0;
 
-        /* calculate queue flags */
-        flags |= QUEUE_FLG_CACHE_ALIGN;
-        flags |= QUEUE_FLG_HC;
-        flags |= IS_MF_SD(bp) ? QUEUE_FLG_OV : 0;
+        /* PF driver will always initialize the Queue to an ACTIVE state */
+        __set_bit(BNX2X_Q_FLG_ACTIVE, &flags);
 
-        flags |= QUEUE_FLG_VLAN;
-        DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
+        /* calculate other queue flags */
+        if (IS_MF_SD(bp))
+                __set_bit(BNX2X_Q_FLG_OV, &flags);
+
+        if (IS_FCOE_FP(fp))
+                __set_bit(BNX2X_Q_FLG_FCOE, &flags);
 
         if (!fp->disable_tpa)
-                flags |= QUEUE_FLG_TPA;
+                __set_bit(BNX2X_Q_FLG_TPA, &flags);
+
+        if (stat_counter_valid(bp, fp)) {
+                __set_bit(BNX2X_Q_FLG_STATS, &flags);
+                __set_bit(BNX2X_Q_FLG_ZERO_STATS, &flags);
+        }
+
+        if (leading) {
+                __set_bit(BNX2X_Q_FLG_LEADING_RSS, &flags);
+                __set_bit(BNX2X_Q_FLG_MCAST, &flags);
+        }
 
-        flags = stat_counter_valid(bp, fp) ?
-                        (flags | QUEUE_FLG_STATS) : (flags & ~QUEUE_FLG_STATS);
+        /* Always set HW VLAN stripping */
+        __set_bit(BNX2X_Q_FLG_VLAN, &flags);
 
         return flags;
 }
 
-static void bnx2x_pf_rx_cl_prep(struct bnx2x *bp,
+static void bnx2x_pf_q_prep_general(struct bnx2x *bp,
+        struct bnx2x_fastpath *fp, struct bnx2x_general_setup_params *gen_init)
+{
+        gen_init->stat_id = bnx2x_stats_id(fp);
+        gen_init->spcl_id = fp->cl_id;
+
+        /* Always use mini-jumbo MTU for FCoE L2 ring */
+        if (IS_FCOE_FP(fp))
+                gen_init->mtu = BNX2X_FCOE_MINI_JUMBO_MTU;
+        else
+                gen_init->mtu = bp->dev->mtu;
+}
+
+static void bnx2x_pf_rx_q_prep(struct bnx2x *bp,
         struct bnx2x_fastpath *fp, struct rxq_pause_params *pause,
-        struct bnx2x_rxq_init_params *rxq_init)
+        struct bnx2x_rxq_setup_params *rxq_init)
 {
-        u16 max_sge = 0;
+        u8 max_sge = 0;
         u16 sge_sz = 0;
         u16 tpa_agg_size = 0;
 
-        /* calculate queue flags */
-        u16 flags = bnx2x_get_cl_flags(bp, fp);
-
         if (!fp->disable_tpa) {
                 pause->sge_th_hi = 250;
                 pause->sge_th_lo = 150;
@@ -2118,33 +2613,37 @@ static void bnx2x_pf_rx_cl_prep(struct bnx2x *bp,
                 pause->bd_th_lo = 250;
                 pause->rcq_th_hi = 350;
                 pause->rcq_th_lo = 250;
-                pause->sge_th_hi = 0;
-                pause->sge_th_lo = 0;
+
                 pause->pri_map = 1;
         }
 
         /* rxq setup */
-        rxq_init->flags = flags;
-        rxq_init->cxt = &bp->context.vcxt[fp->cid].eth;
         rxq_init->dscr_map = fp->rx_desc_mapping;
         rxq_init->sge_map = fp->rx_sge_mapping;
         rxq_init->rcq_map = fp->rx_comp_mapping;
         rxq_init->rcq_np_map = fp->rx_comp_mapping + BCM_PAGE_SIZE;
 
-        /* Always use mini-jumbo MTU for FCoE L2 ring */
-        if (IS_FCOE_FP(fp))
-                rxq_init->mtu = BNX2X_FCOE_MINI_JUMBO_MTU;
-        else
-                rxq_init->mtu = bp->dev->mtu;
+        /* This should be a maximum number of data bytes that may be
+         * placed on the BD (not including paddings).
+         */
+        rxq_init->buf_sz = fp->rx_buf_size - BNX2X_FW_RX_ALIGN -
+                IP_HEADER_ALIGNMENT_PADDING;
 
-        rxq_init->buf_sz = fp->rx_buf_size;
         rxq_init->cl_qzone_id = fp->cl_qzone_id;
-        rxq_init->cl_id = fp->cl_id;
-        rxq_init->spcl_id = fp->cl_id;
-        rxq_init->stat_id = fp->cl_id;
         rxq_init->tpa_agg_sz = tpa_agg_size;
         rxq_init->sge_buf_sz = sge_sz;
         rxq_init->max_sges_pkt = max_sge;
+        rxq_init->rss_engine_id = BP_FUNC(bp);
+
+        /* Maximum number or simultaneous TPA aggregation for this Queue.
+         *
+         * For PF Clients it should be the maximum avaliable number.
+         * VF driver(s) may want to define it to a smaller value.
+         */
+        rxq_init->max_tpa_queues =
+                (CHIP_IS_E1(bp) ? ETH_MAX_AGGREGATION_QUEUES_E1 :
+                ETH_MAX_AGGREGATION_QUEUES_E1H_E2);
+
         rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
         rxq_init->fw_sb_id = fp->fw_sb_id;
 
@@ -2152,46 +2651,35 @@ static void bnx2x_pf_rx_cl_prep(struct bnx2x *bp,
                 rxq_init->sb_cq_index = HC_SP_INDEX_ETH_FCOE_RX_CQ_CONS;
         else
                 rxq_init->sb_cq_index = U_SB_ETH_RX_CQ_INDEX;
-
-        rxq_init->cid = HW_CID(bp, fp->cid);
-
-        rxq_init->hc_rate = bp->rx_ticks ? (1000000 / bp->rx_ticks) : 0;
 }
 
-static void bnx2x_pf_tx_cl_prep(struct bnx2x *bp,
-        struct bnx2x_fastpath *fp, struct bnx2x_txq_init_params *txq_init)
+static void bnx2x_pf_tx_q_prep(struct bnx2x *bp,
+        struct bnx2x_fastpath *fp, struct bnx2x_txq_setup_params *txq_init)
 {
-        u16 flags = bnx2x_get_cl_flags(bp, fp);
-
-        txq_init->flags = flags;
-        txq_init->cxt = &bp->context.vcxt[fp->cid].eth;
         txq_init->dscr_map = fp->tx_desc_mapping;
-        txq_init->stat_id = fp->cl_id;
-        txq_init->cid = HW_CID(bp, fp->cid);
         txq_init->sb_cq_index = C_SB_ETH_TX_CQ_INDEX;
         txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
         txq_init->fw_sb_id = fp->fw_sb_id;
 
+        /*
+         * set the tss leading client id for TX classfication ==
+         * leading RSS client id
+         */
+        txq_init->tss_leading_cl_id = bnx2x_fp(bp, 0, cl_id);
+
         if (IS_FCOE_FP(fp)) {
                 txq_init->sb_cq_index = HC_SP_INDEX_ETH_FCOE_TX_CQ_CONS;
                 txq_init->traffic_type = LLFC_TRAFFIC_TYPE_FCOE;
         }
-
-        txq_init->hc_rate = bp->tx_ticks ? (1000000 / bp->tx_ticks) : 0;
 }
 
 static void bnx2x_pf_init(struct bnx2x *bp)
 {
         struct bnx2x_func_init_params func_init = {0};
-        struct bnx2x_rss_params rss = {0};
         struct event_ring_data eq_data = { {0} };
         u16 flags;
 
-        /* pf specific setups */
-        if (!CHIP_IS_E1(bp))
-                storm_memset_ov(bp, bp->mf_ov, BP_FUNC(bp));
-
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 /* reset IGU PF statistics: MSIX + ATTN */
                 /* PF */
                 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
@@ -2209,27 +2697,14 @@ static void bnx2x_pf_init(struct bnx2x *bp)
         /* function setup flags */
         flags = (FUNC_FLG_STATS | FUNC_FLG_LEADING | FUNC_FLG_SPQ);
 
-        if (CHIP_IS_E1x(bp))
-                flags |= (bp->flags & TPA_ENABLE_FLAG) ? FUNC_FLG_TPA : 0;
-        else
-                flags |= FUNC_FLG_TPA;
-
-        /* function setup */
-
-        /**
-         * Although RSS is meaningless when there is a single HW queue we
-         * still need it enabled in order to have HW Rx hash generated.
+        /* This flag is relevant for E1x only.
+         * E2 doesn't have a TPA configuration in a function level.
          */
-        rss.cap = (RSS_IPV4_CAP | RSS_IPV4_TCP_CAP |
-                   RSS_IPV6_CAP | RSS_IPV6_TCP_CAP);
-        rss.mode = bp->multi_mode;
-        rss.result_mask = MULTI_MASK;
-        func_init.rss = &rss;
+        flags |= (bp->flags & TPA_ENABLE_FLAG) ? FUNC_FLG_TPA : 0;
 
         func_init.func_flgs = flags;
         func_init.pf_id = BP_FUNC(bp);
         func_init.func_id = BP_FUNC(bp);
-        func_init.fw_stat_map = bnx2x_sp_mapping(bp, fw_stats);
         func_init.spq_map = bp->spq_mapping;
         func_init.spq_prod = bp->spq_prod_idx;
 
@@ -2238,11 +2713,11 @@ static void bnx2x_pf_init(struct bnx2x *bp)
         memset(&(bp->cmng), 0, sizeof(struct cmng_struct_per_port));
 
         /*
-        Congestion management values depend on the link rate
-        There is no active link so initial link rate is set to 10 Gbps.
-        When the link comes up The congestion management values are
-        re-calculated according to the actual link rate.
-        */
+         * Congestion management values depend on the link rate
+         * There is no active link so initial link rate is set to 10 Gbps.
+         * When the link comes up The congestion management values are
+         * re-calculated according to the actual link rate.
+         */
         bp->link_vars.line_speed = SPEED_10000;
         bnx2x_cmng_fns_init(bp, true, bnx2x_get_cmng_fns_mode(bp));
 
@@ -2250,10 +2725,6 @@ static void bnx2x_pf_init(struct bnx2x *bp)
         if (bp->port.pmf)
                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
 
-        /* no rx until link is up */
-        bp->rx_mode = BNX2X_RX_MODE_NONE;
-        bnx2x_set_storm_rx_mode(bp);
-
         /* init Event Queue */
         eq_data.base_addr.hi = U64_HI(bp->eq_mapping);
         eq_data.base_addr.lo = U64_LO(bp->eq_mapping);
@@ -2268,11 +2739,9 @@ static void bnx2x_e1h_disable(struct bnx2x *bp)
 {
         int port = BP_PORT(bp);
 
-        netif_tx_disable(bp->dev);
+        bnx2x_tx_disable(bp);
 
         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
-
-        netif_carrier_off(bp->dev);
 }
 
 static void bnx2x_e1h_enable(struct bnx2x *bp)
@@ -2375,12 +2844,47 @@ static inline void bnx2x_sp_prod_update(struct bnx2x *bp)
         mmiowb();
 }
 
-/* the slow path queue is odd since completions arrive on the fastpath ring */
+/**
+ * bnx2x_is_contextless_ramrod - check if the current command ends on EQ
+ *
+ * @cmd:        command to check
+ * @cmd_type:   command type
+ */
+static inline bool bnx2x_is_contextless_ramrod(int cmd, int cmd_type)
+{
+        if ((cmd_type == NONE_CONNECTION_TYPE) ||
+            (cmd == RAMROD_CMD_ID_ETH_CLASSIFICATION_RULES) ||
+            (cmd == RAMROD_CMD_ID_ETH_FILTER_RULES) ||
+            (cmd == RAMROD_CMD_ID_ETH_MULTICAST_RULES) ||
+            (cmd == RAMROD_CMD_ID_ETH_SET_MAC) ||
+            (cmd == RAMROD_CMD_ID_ETH_RSS_UPDATE))
+                return true;
+        else
+                return false;
+
+}
+
+
+/**
+ * bnx2x_sp_post - place a single command on an SP ring
+ *
+ * @bp:         driver handle
+ * @command:    command to place (e.g. SETUP, FILTER_RULES, etc.)
+ * @cid:        SW CID the command is related to
+ * @data_hi:    command private data address (high 32 bits)
+ * @data_lo:    command private data address (low 32 bits)
+ * @cmd_type:   command type (e.g. NONE, ETH)
+ *
+ * SP data is handled as if it's always an address pair, thus data fields are
+ * not swapped to little endian in upper functions. Instead this function swaps
+ * data as if it's two u32 fields.
+ */
 int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
-                  u32 data_hi, u32 data_lo, int common)
+                  u32 data_hi, u32 data_lo, int cmd_type)
 {
         struct eth_spe *spe;
         u16 type;
+        bool common = bnx2x_is_contextless_ramrod(command, cmd_type);
 
 #ifdef BNX2X_STOP_ON_ERROR
         if (unlikely(bp->panic))
@@ -2410,17 +2914,7 @@ int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
                         cpu_to_le32((command << SPE_HDR_CMD_ID_SHIFT) |
                                     HW_CID(bp, cid));
 
-        if (common)
-                /* Common ramrods:
-                 *      FUNC_START, FUNC_STOP, CFC_DEL, STATS, SET_MAC
-                 *      TRAFFIC_STOP, TRAFFIC_START
-                 */
-                type = (NONE_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
-                        & SPE_HDR_CONN_TYPE;
-        else
-                /* ETH ramrods: SETUP, HALT */
-                type = (ETH_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
-                        & SPE_HDR_CONN_TYPE;
+        type = (cmd_type << SPE_HDR_CONN_TYPE_SHIFT) & SPE_HDR_CONN_TYPE;
 
         type |= ((BP_FUNC(bp) << SPE_HDR_FUNCTION_ID_SHIFT) &
                  SPE_HDR_FUNCTION_ID);
@@ -2432,7 +2926,8 @@ int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
 
         /* stats ramrod has it's own slot on the spq */
         if (command != RAMROD_CMD_ID_COMMON_STAT_QUERY) {
-                /* It's ok if the actual decrement is issued towards the memory
+                /*
+                 * It's ok if the actual decrement is issued towards the memory
                  * somewhere between the spin_lock and spin_unlock. Thus no
                  * more explict memory barrier is needed.
                  */
@@ -2728,13 +3223,13 @@ static inline void bnx2x_attn_int_deasserted2(struct bnx2x *bp, u32 attn)
         }
 
         if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
-
                 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_0);
-                BNX2X_ERR("PXP hw attention 0x%x\n", val);
+                BNX2X_ERR("PXP hw attention-0 0x%x\n", val);
                 /* RQ_USDMDP_FIFO_OVERFLOW */
                 if (val & 0x18000)
                         BNX2X_ERR("FATAL error from PXP\n");
-                if (CHIP_IS_E2(bp)) {
+
+                if (!CHIP_IS_E1x(bp)) {
                         val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_1);
                         BNX2X_ERR("PXP hw attention-1 0x%x\n", val);
                 }
@@ -3224,7 +3719,7 @@ static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
         attn.sig[1] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
         attn.sig[2] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
         attn.sig[3] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp))
                 attn.sig[4] =
                       REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_5_FUNC_0 + port*4);
         else
@@ -3320,6 +3815,15 @@ static void bnx2x_attn_int(struct bnx2x *bp)
                 bnx2x_attn_int_deasserted(bp, deasserted);
 }
 
+void bnx2x_igu_ack_sb(struct bnx2x *bp, u8 igu_sb_id, u8 segment,
+                      u16 index, u8 op, u8 update)
+{
+        u32 igu_addr = BAR_IGU_INTMEM + (IGU_CMD_INT_ACK_BASE + igu_sb_id)*8;
+
+        bnx2x_igu_ack_sb_gen(bp, igu_sb_id, segment, index, op, update,
+                             igu_addr);
+}
+
 static inline void bnx2x_update_eq_prod(struct bnx2x *bp, u16 prod)
 {
         /* No memory barriers */
@@ -3331,6 +3835,8 @@ static inline void bnx2x_update_eq_prod(struct bnx2x *bp, u16 prod)
 static int  bnx2x_cnic_handle_cfc_del(struct bnx2x *bp, u32 cid,
                                       union event_ring_elem *elem)
 {
+        u8 err = elem->message.error;
+
         if (!bp->cnic_eth_dev.starting_cid  ||
             (cid < bp->cnic_eth_dev.starting_cid &&
             cid != bp->cnic_eth_dev.iscsi_l2_cid))
@@ -3338,16 +3844,122 @@ static int  bnx2x_cnic_handle_cfc_del(struct bnx2x *bp, u32 cid,
 
         DP(BNX2X_MSG_SP, "got delete ramrod for CNIC CID %d\n", cid);
 
-        if (unlikely(elem->message.data.cfc_del_event.error)) {
+        if (unlikely(err)) {
+
                 BNX2X_ERR("got delete ramrod for CNIC CID %d with error!\n",
                           cid);
                 bnx2x_panic_dump(bp);
         }
-        bnx2x_cnic_cfc_comp(bp, cid);
+        bnx2x_cnic_cfc_comp(bp, cid, err);
         return 0;
 }
 #endif
 
+static inline void bnx2x_handle_mcast_eqe(struct bnx2x *bp)
+{
+        struct bnx2x_mcast_ramrod_params rparam;
+        int rc;
+
+        memset(&rparam, 0, sizeof(rparam));
+
+        rparam.mcast_obj = &bp->mcast_obj;
+
+        netif_addr_lock_bh(bp->dev);
+
+        /* Clear pending state for the last command */
+        bp->mcast_obj.raw.clear_pending(&bp->mcast_obj.raw);
+
+        /* If there are pending mcast commands - send them */
+        if (bp->mcast_obj.check_pending(&bp->mcast_obj)) {
+                rc = bnx2x_config_mcast(bp, &rparam, BNX2X_MCAST_CMD_CONT);
+                if (rc < 0)
+                        BNX2X_ERR("Failed to send pending mcast commands: %d\n",
+                                  rc);
+        }
+
+        netif_addr_unlock_bh(bp->dev);
+}
+
+static inline void bnx2x_handle_classification_eqe(struct bnx2x *bp,
+                                                   union event_ring_elem *elem)
+{
+        unsigned long ramrod_flags = 0;
+        int rc = 0;
+        u32 cid = elem->message.data.eth_event.echo & BNX2X_SWCID_MASK;
+        struct bnx2x_vlan_mac_obj *vlan_mac_obj;
+
+        /* Always push next commands out, don't wait here */
+        __set_bit(RAMROD_CONT, &ramrod_flags);
+
+        switch (elem->message.data.eth_event.echo >> BNX2X_SWCID_SHIFT) {
+        case BNX2X_FILTER_MAC_PENDING:
+#ifdef BCM_CNIC
+                if (cid == BNX2X_ISCSI_ETH_CID)
+                        vlan_mac_obj = &bp->iscsi_l2_mac_obj;
+                else
+#endif
+                        vlan_mac_obj = &bp->fp[cid].mac_obj;
+
+                break;
+                vlan_mac_obj = &bp->fp[cid].mac_obj;
+
+        case BNX2X_FILTER_MCAST_PENDING:
+                /* This is only relevant for 57710 where multicast MACs are
+                 * configured as unicast MACs using the same ramrod.
+                 */
+                bnx2x_handle_mcast_eqe(bp);
+                return;
+        default:
+                BNX2X_ERR("Unsupported classification command: %d\n",
+                          elem->message.data.eth_event.echo);
+                return;
+        }
+
+        rc = vlan_mac_obj->complete(bp, vlan_mac_obj, elem, &ramrod_flags);
+
+        if (rc < 0)
+                BNX2X_ERR("Failed to schedule new commands: %d\n", rc);
+        else if (rc > 0)
+                DP(BNX2X_MSG_SP, "Scheduled next pending commands...\n");
+
+}
+
+#ifdef BCM_CNIC
+static void bnx2x_set_iscsi_eth_rx_mode(struct bnx2x *bp, bool start);
+#endif
+
+static inline void bnx2x_handle_rx_mode_eqe(struct bnx2x *bp)
+{
+        netif_addr_lock_bh(bp->dev);
+
+        clear_bit(BNX2X_FILTER_RX_MODE_PENDING, &bp->sp_state);
+
+        /* Send rx_mode command again if was requested */
+        if (test_and_clear_bit(BNX2X_FILTER_RX_MODE_SCHED, &bp->sp_state))
+                bnx2x_set_storm_rx_mode(bp);
+#ifdef BCM_CNIC
+        else if (test_and_clear_bit(BNX2X_FILTER_ISCSI_ETH_START_SCHED,
+                                    &bp->sp_state))
+                bnx2x_set_iscsi_eth_rx_mode(bp, true);
+        else if (test_and_clear_bit(BNX2X_FILTER_ISCSI_ETH_STOP_SCHED,
+                                    &bp->sp_state))
+                bnx2x_set_iscsi_eth_rx_mode(bp, false);
+#endif
+
+        netif_addr_unlock_bh(bp->dev);
+}
+
+static inline struct bnx2x_queue_sp_obj *bnx2x_cid_to_q_obj(
+        struct bnx2x *bp, u32 cid)
+{
+#ifdef BCM_CNIC
+        if (cid == BNX2X_FCOE_ETH_CID)
+                return &bnx2x_fcoe(bp, q_obj);
+        else
+#endif
+                return &bnx2x_fp(bp, cid, q_obj);
+}
+
 static void bnx2x_eq_int(struct bnx2x *bp)
 {
         u16 hw_cons, sw_cons, sw_prod;
@@ -3355,6 +3967,9 @@ static void bnx2x_eq_int(struct bnx2x *bp)
         u32 cid;
         u8 opcode;
         int spqe_cnt = 0;
+        struct bnx2x_queue_sp_obj *q_obj;
+        struct bnx2x_func_sp_obj *f_obj = &bp->func_obj;
+        struct bnx2x_raw_obj *rss_raw = &bp->rss_conf_obj.raw;
 
         hw_cons = le16_to_cpu(*bp->eq_cons_sb);
 
@@ -3389,7 +4004,8 @@ static void bnx2x_eq_int(struct bnx2x *bp)
                 /* handle eq element */
                 switch (opcode) {
                 case EVENT_RING_OPCODE_STAT_QUERY:
-                        DP(NETIF_MSG_TIMER, "got statistics comp event\n");
+                        DP(NETIF_MSG_TIMER, "got statistics comp event %d\n",
+                           bp->stats_comp++);
                         /* nothing to do with stats comp */
                         continue;
 
@@ -3404,12 +4020,13 @@ static void bnx2x_eq_int(struct bnx2x *bp)
 #ifdef BCM_CNIC
                         if (!bnx2x_cnic_handle_cfc_del(bp, cid, elem))
                                 goto next_spqe;
-                        if (cid == BNX2X_FCOE_ETH_CID)
-                                bnx2x_fcoe(bp, state) = BNX2X_FP_STATE_CLOSED;
-                        else
 #endif
-                                bnx2x_fp(bp, cid, state) =
-                                                BNX2X_FP_STATE_CLOSED;
+                        q_obj = bnx2x_cid_to_q_obj(bp, cid);
+
+                        if (q_obj->complete_cmd(bp, q_obj, BNX2X_Q_CMD_CFC_DEL))
+                                break;
+
+
 
                         goto next_spqe;
 
@@ -3417,42 +4034,75 @@ static void bnx2x_eq_int(struct bnx2x *bp)
                         DP(NETIF_MSG_IFUP, "got STOP TRAFFIC\n");
                         bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_TX_PAUSED);
                         goto next_spqe;
+
                 case EVENT_RING_OPCODE_START_TRAFFIC:
                         DP(NETIF_MSG_IFUP, "got START TRAFFIC\n");
                         bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_TX_RELEASED);
                         goto next_spqe;
+                case EVENT_RING_OPCODE_FUNCTION_START:
+                        DP(NETIF_MSG_IFUP, "got FUNC_START ramrod\n");
+                        if (f_obj->complete_cmd(bp, f_obj, BNX2X_F_CMD_START))
+                                break;
+
+                        goto next_spqe;
+
+                case EVENT_RING_OPCODE_FUNCTION_STOP:
+                        DP(NETIF_MSG_IFDOWN, "got FUNC_STOP ramrod\n");
+                        if (f_obj->complete_cmd(bp, f_obj, BNX2X_F_CMD_STOP))
+                                break;
+
+                        goto next_spqe;
                 }
 
                 switch (opcode | bp->state) {
-                case (EVENT_RING_OPCODE_FUNCTION_START |
+                case (EVENT_RING_OPCODE_RSS_UPDATE_RULES |
+                      BNX2X_STATE_OPEN):
+                case (EVENT_RING_OPCODE_RSS_UPDATE_RULES |
                       BNX2X_STATE_OPENING_WAIT4_PORT):
-                        DP(NETIF_MSG_IFUP, "got setup ramrod\n");
-                        bp->state = BNX2X_STATE_FUNC_STARTED;
+                        cid = elem->message.data.eth_event.echo &
+                                BNX2X_SWCID_MASK;
+                        DP(NETIF_MSG_IFUP, "got RSS_UPDATE ramrod. CID %d\n",
+                           cid);
+                        rss_raw->clear_pending(rss_raw);
                         break;
 
-                case (EVENT_RING_OPCODE_FUNCTION_STOP |
+                case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_OPEN):
+                case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_DIAG):
+                case (EVENT_RING_OPCODE_SET_MAC |
+                      BNX2X_STATE_CLOSING_WAIT4_HALT):
+                case (EVENT_RING_OPCODE_CLASSIFICATION_RULES |
+                      BNX2X_STATE_OPEN):
+                case (EVENT_RING_OPCODE_CLASSIFICATION_RULES |
+                      BNX2X_STATE_DIAG):
+                case (EVENT_RING_OPCODE_CLASSIFICATION_RULES |
                       BNX2X_STATE_CLOSING_WAIT4_HALT):
-                        DP(NETIF_MSG_IFDOWN, "got halt ramrod\n");
-                        bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
+                        DP(NETIF_MSG_IFUP, "got (un)set mac ramrod\n");
+                        bnx2x_handle_classification_eqe(bp, elem);
                         break;
 
-                case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_OPEN):
-                case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_DIAG):
-                        DP(NETIF_MSG_IFUP, "got set mac ramrod\n");
-                        if (elem->message.data.set_mac_event.echo)
-                                bp->set_mac_pending = 0;
+                case (EVENT_RING_OPCODE_MULTICAST_RULES |
+                      BNX2X_STATE_OPEN):
+                case (EVENT_RING_OPCODE_MULTICAST_RULES |
+                      BNX2X_STATE_DIAG):
+                case (EVENT_RING_OPCODE_MULTICAST_RULES |
+                      BNX2X_STATE_CLOSING_WAIT4_HALT):
+                        DP(NETIF_MSG_IFUP, "got mcast ramrod\n");
+                        bnx2x_handle_mcast_eqe(bp);
                         break;
 
-                case (EVENT_RING_OPCODE_SET_MAC |
+                case (EVENT_RING_OPCODE_FILTERS_RULES |
+                      BNX2X_STATE_OPEN):
+                case (EVENT_RING_OPCODE_FILTERS_RULES |
+                      BNX2X_STATE_DIAG):
+                case (EVENT_RING_OPCODE_FILTERS_RULES |
                       BNX2X_STATE_CLOSING_WAIT4_HALT):
-                        DP(NETIF_MSG_IFDOWN, "got (un)set mac ramrod\n");
-                        if (elem->message.data.set_mac_event.echo)
-                                bp->set_mac_pending = 0;
+                        DP(NETIF_MSG_IFUP, "got rx_mode ramrod\n");
+                        bnx2x_handle_rx_mode_eqe(bp);
                         break;
                 default:
                         /* unknown event log error and continue */
-                        BNX2X_ERR("Unknown EQ event %d\n",
-                                  elem->message.opcode);
+                        BNX2X_ERR("Unknown EQ event %d, bp->state 0x%x\n",
+                                  elem->message.opcode, bp->state);
                 }
 next_spqe:
                 spqe_cnt++;
@@ -3544,6 +4194,14 @@ irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
 
 /* end of slow path */
 
+
+void bnx2x_drv_pulse(struct bnx2x *bp)
+{
+        SHMEM_WR(bp, func_mb[BP_FW_MB_IDX(bp)].drv_pulse_mb,
+                 bp->fw_drv_pulse_wr_seq);
+}
+
+
 static void bnx2x_timer(unsigned long data)
 {
         struct bnx2x *bp = (struct bnx2x *) data;
@@ -3567,7 +4225,7 @@ static void bnx2x_timer(unsigned long data)
                 bp->fw_drv_pulse_wr_seq &= DRV_PULSE_SEQ_MASK;
                 /* TBD - add SYSTEM_TIME */
                 drv_pulse = bp->fw_drv_pulse_wr_seq;
-                SHMEM_WR(bp, func_mb[mb_idx].drv_pulse_mb, drv_pulse);
+                bnx2x_drv_pulse(bp);
 
                 mcp_pulse = (SHMEM_RD(bp, func_mb[mb_idx].mcp_pulse_mb) &
                              MCP_PULSE_SEQ_MASK);
@@ -3630,18 +4288,16 @@ static inline void bnx2x_zero_fp_sb(struct bnx2x *bp, int fw_sb_id)
         struct hc_status_block_data_e1x sb_data_e1x;
 
         /* disable the function first */
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
-                sb_data_e2.common.p_func.pf_id = HC_FUNCTION_DISABLED;
-                sb_data_e2.common.p_func.vf_id = HC_FUNCTION_DISABLED;
+                sb_data_e2.common.state = SB_DISABLED;
                 sb_data_e2.common.p_func.vf_valid = false;
                 sb_data_p = (u32 *)&sb_data_e2;
                 data_size = sizeof(struct hc_status_block_data_e2)/sizeof(u32);
         } else {
                 memset(&sb_data_e1x, 0,
                        sizeof(struct hc_status_block_data_e1x));
-                sb_data_e1x.common.p_func.pf_id = HC_FUNCTION_DISABLED;
-                sb_data_e1x.common.p_func.vf_id = HC_FUNCTION_DISABLED;
+                sb_data_e1x.common.state = SB_DISABLED;
                 sb_data_e1x.common.p_func.vf_valid = false;
                 sb_data_p = (u32 *)&sb_data_e1x;
                 data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
@@ -3675,8 +4331,7 @@ static inline void bnx2x_zero_sp_sb(struct bnx2x *bp)
         struct hc_sp_status_block_data sp_sb_data;
         memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
 
-        sp_sb_data.p_func.pf_id = HC_FUNCTION_DISABLED;
-        sp_sb_data.p_func.vf_id = HC_FUNCTION_DISABLED;
+        sp_sb_data.state = SB_DISABLED;
         sp_sb_data.p_func.vf_valid = false;
 
         bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
@@ -3719,8 +4374,9 @@ static void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
 
         bnx2x_zero_fp_sb(bp, fw_sb_id);
 
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
+                sb_data_e2.common.state = SB_ENABLED;
                 sb_data_e2.common.p_func.pf_id = BP_FUNC(bp);
                 sb_data_e2.common.p_func.vf_id = vfid;
                 sb_data_e2.common.p_func.vf_valid = vf_valid;
@@ -3734,6 +4390,7 @@ static void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
         } else {
                 memset(&sb_data_e1x, 0,
                        sizeof(struct hc_status_block_data_e1x));
+                sb_data_e1x.common.state = SB_ENABLED;
                 sb_data_e1x.common.p_func.pf_id = BP_FUNC(bp);
                 sb_data_e1x.common.p_func.vf_id = 0xff;
                 sb_data_e1x.common.p_func.vf_valid = false;
@@ -3757,19 +4414,7 @@ static void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
         bnx2x_wr_fp_sb_data(bp, fw_sb_id, sb_data_p, data_size);
 }
 
-void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, u16 fw_sb_id,
-                                        u8 sb_index, u8 disable, u16 usec)
-{
-        int port = BP_PORT(bp);
-        u8 ticks = usec / BNX2X_BTR;
-
-        storm_memset_hc_timeout(bp, port, fw_sb_id, sb_index, ticks);
-
-        disable = disable ? 1 : (usec ? 0 : 1);
-        storm_memset_hc_disable(bp, port, fw_sb_id, sb_index, disable);
-}
-
-static void bnx2x_update_coalesce_sb(struct bnx2x *bp, u16 fw_sb_id,
+static void bnx2x_update_coalesce_sb(struct bnx2x *bp, u8 fw_sb_id,
                                      u16 tx_usec, u16 rx_usec)
 {
         bnx2x_update_coalesce_sb_index(bp, fw_sb_id, U_SB_ETH_RX_CQ_INDEX,
@@ -3816,7 +4461,7 @@ static void bnx2x_init_def_sb(struct bnx2x *bp)
                         bp->attn_group[index].sig[sindex] =
                            REG_RD(bp, reg_offset + sindex*0x4 + 0x10*index);
 
-                if (CHIP_IS_E2(bp))
+                if (!CHIP_IS_E1x(bp))
                         /*
                          * enable5 is separate from the rest of the registers,
                          * and therefore the address skip is 4
@@ -3834,7 +4479,7 @@ static void bnx2x_init_def_sb(struct bnx2x *bp)
 
                 REG_WR(bp, reg_offset, U64_LO(section));
                 REG_WR(bp, reg_offset + 4, U64_HI(section));
-        } else if (CHIP_IS_E2(bp)) {
+        } else if (!CHIP_IS_E1x(bp)) {
                 REG_WR(bp, IGU_REG_ATTN_MSG_ADDR_L, U64_LO(section));
                 REG_WR(bp, IGU_REG_ATTN_MSG_ADDR_H, U64_HI(section));
         }
@@ -3844,6 +4489,7 @@ static void bnx2x_init_def_sb(struct bnx2x *bp)
 
         bnx2x_zero_sp_sb(bp);
 
+        sp_sb_data.state                = SB_ENABLED;
         sp_sb_data.host_sb_addr.lo      = U64_LO(section);
         sp_sb_data.host_sb_addr.hi      = U64_HI(section);
         sp_sb_data.igu_sb_id            = igu_sp_sb_index;
@@ -3854,9 +4500,6 @@ static void bnx2x_init_def_sb(struct bnx2x *bp)
 
         bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
 
-        bp->stats_pending = 0;
-        bp->set_mac_pending = 0;
-
         bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
 }
 
@@ -3902,34 +4545,129 @@ static void bnx2x_init_eq_ring(struct bnx2x *bp)
                 min_t(int, MAX_SP_DESC_CNT - MAX_SPQ_PENDING, NUM_EQ_DESC) - 1);
 }
 
-static void bnx2x_init_ind_table(struct bnx2x *bp)
+
+/* called with netif_addr_lock_bh() */
+void bnx2x_set_q_rx_mode(struct bnx2x *bp, u8 cl_id,
+                         unsigned long rx_mode_flags,
+                         unsigned long rx_accept_flags,
+                         unsigned long tx_accept_flags,
+                         unsigned long ramrod_flags)
 {
-        int i;
+        struct bnx2x_rx_mode_ramrod_params ramrod_param;
+        int rc;
+
+        memset(&ramrod_param, 0, sizeof(ramrod_param));
 
-        for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
-                bp->rx_indir_table[i] = i % BNX2X_NUM_ETH_QUEUES(bp);
+        /* Prepare ramrod parameters */
+        ramrod_param.cid = 0;
+        ramrod_param.cl_id = cl_id;
+        ramrod_param.rx_mode_obj = &bp->rx_mode_obj;
+        ramrod_param.func_id = BP_FUNC(bp);
 
-        bnx2x_push_indir_table(bp);
+        ramrod_param.pstate = &bp->sp_state;
+        ramrod_param.state = BNX2X_FILTER_RX_MODE_PENDING;
+
+        ramrod_param.rdata = bnx2x_sp(bp, rx_mode_rdata);
+        ramrod_param.rdata_mapping = bnx2x_sp_mapping(bp, rx_mode_rdata);
+
+        set_bit(BNX2X_FILTER_RX_MODE_PENDING, &bp->sp_state);
+
+        ramrod_param.ramrod_flags = ramrod_flags;
+        ramrod_param.rx_mode_flags = rx_mode_flags;
+
+        ramrod_param.rx_accept_flags = rx_accept_flags;
+        ramrod_param.tx_accept_flags = tx_accept_flags;
+
+        rc = bnx2x_config_rx_mode(bp, &ramrod_param);
+        if (rc < 0) {
+                BNX2X_ERR("Set rx_mode %d failed\n", bp->rx_mode);
+                return;
+        }
 }
 
-static void bnx2x_init_internal_common(struct bnx2x *bp)
+/* called with netif_addr_lock_bh() */
+void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
 {
-        int i;
+        unsigned long rx_mode_flags = 0, ramrod_flags = 0;
+        unsigned long rx_accept_flags = 0, tx_accept_flags = 0;
 
-        if (!CHIP_IS_E1(bp)) {
+#ifdef BCM_CNIC
+        if (!NO_FCOE(bp))
+
+                /* Configure rx_mode of FCoE Queue */
+                __set_bit(BNX2X_RX_MODE_FCOE_ETH, &rx_mode_flags);
+#endif
+
+        switch (bp->rx_mode) {
+        case BNX2X_RX_MODE_NONE:
+                /*
+                 * 'drop all' supersedes any accept flags that may have been
+                 * passed to the function.
+                 */
+                break;
+        case BNX2X_RX_MODE_NORMAL:
+                __set_bit(BNX2X_ACCEPT_UNICAST, &rx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_MULTICAST, &rx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_BROADCAST, &rx_accept_flags);
+
+                /* internal switching mode */
+                __set_bit(BNX2X_ACCEPT_UNICAST, &tx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_MULTICAST, &tx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_BROADCAST, &tx_accept_flags);
+
+                break;
+        case BNX2X_RX_MODE_ALLMULTI:
+                __set_bit(BNX2X_ACCEPT_UNICAST, &rx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_ALL_MULTICAST, &rx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_BROADCAST, &rx_accept_flags);
+
+                /* internal switching mode */
+                __set_bit(BNX2X_ACCEPT_UNICAST, &tx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_ALL_MULTICAST, &tx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_BROADCAST, &tx_accept_flags);
+
+                break;
+        case BNX2X_RX_MODE_PROMISC:
+                /* According to deffinition of SI mode, iface in promisc mode
+                 * should receive matched and unmatched (in resolution of port)
+                 * unicast packets.
+                 */
+                __set_bit(BNX2X_ACCEPT_UNMATCHED, &rx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_UNICAST, &rx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_ALL_MULTICAST, &rx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_BROADCAST, &rx_accept_flags);
+
+                /* internal switching mode */
+                __set_bit(BNX2X_ACCEPT_ALL_MULTICAST, &tx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_BROADCAST, &tx_accept_flags);
 
-                /* xstorm needs to know whether to add  ovlan to packets or not,
-                 * in switch-independent we'll write 0 to here... */
-                REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNCTION_MODE_OFFSET,
-                        bp->mf_mode);
-                REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNCTION_MODE_OFFSET,
-                        bp->mf_mode);
-                REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNCTION_MODE_OFFSET,
-                        bp->mf_mode);
-                REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNCTION_MODE_OFFSET,
-                        bp->mf_mode);
+                if (IS_MF_SI(bp))
+                        __set_bit(BNX2X_ACCEPT_ALL_UNICAST, &tx_accept_flags);
+                else
+                        __set_bit(BNX2X_ACCEPT_UNICAST, &tx_accept_flags);
+
+                break;
+        default:
+                BNX2X_ERR("Unknown rx_mode: %d\n", bp->rx_mode);
+                return;
+        }
+
+        if (bp->rx_mode != BNX2X_RX_MODE_NONE) {
+                __set_bit(BNX2X_ACCEPT_ANY_VLAN, &rx_accept_flags);
+                __set_bit(BNX2X_ACCEPT_ANY_VLAN, &tx_accept_flags);
         }
 
+        __set_bit(RAMROD_RX, &ramrod_flags);
+        __set_bit(RAMROD_TX, &ramrod_flags);
+
+        bnx2x_set_q_rx_mode(bp, bp->fp->cl_id, rx_mode_flags, rx_accept_flags,
+                            tx_accept_flags, ramrod_flags);
+}
+
+static void bnx2x_init_internal_common(struct bnx2x *bp)
+{
+        int i;
+
         if (IS_MF_SI(bp))
                 /*
                  * In switch independent mode, the TSTORM needs to accept
@@ -3938,25 +4676,22 @@ static void bnx2x_init_internal_common(struct bnx2x *bp)
                  */
                 REG_WR8(bp, BAR_TSTRORM_INTMEM +
                             TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET, 2);
+        else if (!CHIP_IS_E1(bp)) /* 57710 doesn't support MF */
+                REG_WR8(bp, BAR_TSTRORM_INTMEM +
+                            TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET, 0);
 
         /* Zero this manually as its initialization is
            currently missing in the initTool */
         for (i = 0; i < (USTORM_AGG_DATA_SIZE >> 2); i++)
                 REG_WR(bp, BAR_USTRORM_INTMEM +
                        USTORM_AGG_DATA_OFFSET + i * 4, 0);
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_IGU_MODE_OFFSET,
                         CHIP_INT_MODE_IS_BC(bp) ?
                         HC_IGU_BC_MODE : HC_IGU_NBC_MODE);
         }
 }
 
-static void bnx2x_init_internal_port(struct bnx2x *bp)
-{
-        /* port */
-        bnx2x_dcb_init_intmem_pfc(bp);
-}
-
 static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
 {
         switch (load_code) {
@@ -3966,7 +4701,7 @@ static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
                 /* no break */
 
         case FW_MSG_CODE_DRV_LOAD_PORT:
-                bnx2x_init_internal_port(bp);
+                /* nothing to do */
                 /* no break */
 
         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
@@ -3980,31 +4715,57 @@ static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
         }
 }
 
-static void bnx2x_init_fp_sb(struct bnx2x *bp, int fp_idx)
+static inline u8 bnx2x_fp_igu_sb_id(struct bnx2x_fastpath *fp)
 {
-        struct bnx2x_fastpath *fp = &bp->fp[fp_idx];
+        return fp->bp->igu_base_sb + fp->index + CNIC_CONTEXT_USE;
+}
+
+static inline u8 bnx2x_fp_fw_sb_id(struct bnx2x_fastpath *fp)
+{
+        return fp->bp->base_fw_ndsb + fp->index + CNIC_CONTEXT_USE;
+}
+
+static inline u8 bnx2x_fp_cl_id(struct bnx2x_fastpath *fp)
+{
+        if (CHIP_IS_E1x(fp->bp))
+                return BP_L_ID(fp->bp) + fp->index;
+        else    /* We want Client ID to be the same as IGU SB ID for 57712 */
+                return bnx2x_fp_igu_sb_id(fp);
+}
 
-        fp->state = BNX2X_FP_STATE_CLOSED;
+static void bnx2x_init_fp(struct bnx2x *bp, int fp_idx)
+{
+        struct bnx2x_fastpath *fp = &bp->fp[fp_idx];
+        unsigned long q_type = 0;
 
         fp->cid = fp_idx;
-        fp->cl_id = BP_L_ID(bp) + fp_idx;
-        fp->fw_sb_id = bp->base_fw_ndsb + fp->cl_id + CNIC_CONTEXT_USE;
-        fp->igu_sb_id = bp->igu_base_sb + fp_idx + CNIC_CONTEXT_USE;
+        fp->cl_id = bnx2x_fp_cl_id(fp);
+        fp->fw_sb_id = bnx2x_fp_fw_sb_id(fp);
+        fp->igu_sb_id = bnx2x_fp_igu_sb_id(fp);
         /* qZone id equals to FW (per path) client id */
-        fp->cl_qzone_id  = fp->cl_id +
-                           BP_PORT(bp)*(CHIP_IS_E2(bp) ? ETH_MAX_RX_CLIENTS_E2 :
-                                ETH_MAX_RX_CLIENTS_E1H);
+        fp->cl_qzone_id  = bnx2x_fp_qzone_id(fp);
+
         /* init shortcut */
-        fp->ustorm_rx_prods_offset = CHIP_IS_E2(bp) ?
-                            USTORM_RX_PRODS_E2_OFFSET(fp->cl_qzone_id) :
-                            USTORM_RX_PRODS_E1X_OFFSET(BP_PORT(bp), fp->cl_id);
+        fp->ustorm_rx_prods_offset = bnx2x_rx_ustorm_prods_offset(fp);
         /* Setup SB indicies */
         fp->rx_cons_sb = BNX2X_RX_SB_INDEX;
         fp->tx_cons_sb = BNX2X_TX_SB_INDEX;
 
+        /* Configure Queue State object */
+        __set_bit(BNX2X_Q_TYPE_HAS_RX, &q_type);
+        __set_bit(BNX2X_Q_TYPE_HAS_TX, &q_type);
+        bnx2x_init_queue_obj(bp, &fp->q_obj, fp->cl_id, fp->cid, BP_FUNC(bp),
+                bnx2x_sp(bp, q_rdata), bnx2x_sp_mapping(bp, q_rdata),
+                              q_type);
+
+        /**
+         * Configure classification DBs: Always enable Tx switching
+         */
+        bnx2x_init_vlan_mac_fp_objs(fp, BNX2X_OBJ_TYPE_RX_TX);
+
         DP(NETIF_MSG_IFUP, "queue[%d]:  bnx2x_init_sb(%p,%p)  "
                                    "cl_id %d  fw_sb %d  igu_sb %d\n",
-                   fp_idx, bp, fp->status_blk.e1x_sb, fp->cl_id, fp->fw_sb_id,
+                   fp_idx, bp, fp->status_blk.e2_sb, fp->cl_id, fp->fw_sb_id,
                    fp->igu_sb_id);
         bnx2x_init_sb(bp, fp->status_blk_mapping, BNX2X_VF_ID_INVALID, false,
                       fp->fw_sb_id, fp->igu_sb_id);
@@ -4017,14 +4778,14 @@ void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
         int i;
 
         for_each_eth_queue(bp, i)
-                bnx2x_init_fp_sb(bp, i);
+                bnx2x_init_fp(bp, i);
 #ifdef BCM_CNIC
         if (!NO_FCOE(bp))
                 bnx2x_init_fcoe_fp(bp);
 
         bnx2x_init_sb(bp, bp->cnic_sb_mapping,
                       BNX2X_VF_ID_INVALID, false,
-                      CNIC_SB_ID(bp), CNIC_IGU_SB_ID(bp));
+                      bnx2x_cnic_fw_sb_id(bp), bnx2x_cnic_igu_sb_id(bp));
 
 #endif
 
@@ -4043,7 +4804,6 @@ void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
         bnx2x_init_eq_ring(bp);
         bnx2x_init_internal(bp, load_code);
         bnx2x_pf_init(bp);
-        bnx2x_init_ind_table(bp);
         bnx2x_stats_init(bp);
 
         /* flush all before enabling interrupts */
@@ -4249,8 +5009,8 @@ static int bnx2x_int_mem_test(struct bnx2x *bp)
         msleep(50);
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
         msleep(50);
-        bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_BRB1, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_PRS, PHASE_COMMON);
 
         DP(NETIF_MSG_HW, "part2\n");
 
@@ -4314,8 +5074,8 @@ static int bnx2x_int_mem_test(struct bnx2x *bp)
         msleep(50);
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
         msleep(50);
-        bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_BRB1, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_PRS, PHASE_COMMON);
 #ifndef BCM_CNIC
         /* set NIC mode */
         REG_WR(bp, PRS_REG_NIC_MODE, 1);
@@ -4335,7 +5095,7 @@ static int bnx2x_int_mem_test(struct bnx2x *bp)
 static void bnx2x_enable_blocks_attention(struct bnx2x *bp)
 {
         REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp))
                 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0x40);
         else
                 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0);
@@ -4369,7 +5129,7 @@ static void bnx2x_enable_blocks_attention(struct bnx2x *bp)
 
         if (CHIP_REV_IS_FPGA(bp))
                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x580000);
-        else if (CHIP_IS_E2(bp))
+        else if (!CHIP_IS_E1x(bp))
                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0,
                            (PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_OF
                                 | PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_AFT
@@ -4382,7 +5142,11 @@ static void bnx2x_enable_blocks_attention(struct bnx2x *bp)
         REG_WR(bp, TSDM_REG_TSDM_INT_MASK_1, 0);
         REG_WR(bp, TCM_REG_TCM_INT_MASK, 0);
 /*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_0, 0); */
-/*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_1, 0); */
+
+        if (!CHIP_IS_E1x(bp))
+                /* enable VFC attentions: bits 11 and 12, bits 31:13 reserved */
+                REG_WR(bp, TSEM_REG_TSEM_INT_MASK_1, 0x07ff);
+
         REG_WR(bp, CDU_REG_CDU_INT_MASK, 0);
         REG_WR(bp, DMAE_REG_DMAE_INT_MASK, 0);
 /*      REG_WR(bp, MISC_REG_MISC_INT_MASK, 0); */
@@ -4391,10 +5155,24 @@ static void bnx2x_enable_blocks_attention(struct bnx2x *bp)
 
 static void bnx2x_reset_common(struct bnx2x *bp)
 {
+        u32 val = 0x1400;
+
         /* reset_common */
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
                0xd3ffff7f);
-        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
+
+        if (CHIP_IS_E3(bp)) {
+                val |= MISC_REGISTERS_RESET_REG_2_MSTAT0;
+                val |= MISC_REGISTERS_RESET_REG_2_MSTAT1;
+        }
+
+        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, val);
+}
+
+static void bnx2x_setup_dmae(struct bnx2x *bp)
+{
+        bp->dmae_ready = 0;
+        spin_lock_init(&bp->dmae_lock);
 }
 
 static void bnx2x_init_pxp(struct bnx2x *bp)
@@ -4521,22 +5299,48 @@ static void bnx2x_pf_disable(struct bnx2x *bp)
         REG_WR(bp, CFC_REG_WEAK_ENABLE_PF, 0);
 }
 
-static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
+static inline void bnx2x__common_init_phy(struct bnx2x *bp)
+{
+        u32 shmem_base[2], shmem2_base[2];
+        shmem_base[0] =  bp->common.shmem_base;
+        shmem2_base[0] = bp->common.shmem2_base;
+        if (!CHIP_IS_E1x(bp)) {
+                shmem_base[1] =
+                        SHMEM2_RD(bp, other_shmem_base_addr);
+                shmem2_base[1] =
+                        SHMEM2_RD(bp, other_shmem2_base_addr);
+        }
+        bnx2x_acquire_phy_lock(bp);
+        bnx2x_common_init_phy(bp, shmem_base, shmem2_base,
+                              bp->common.chip_id);
+        bnx2x_release_phy_lock(bp);
+}
+
+/**
+ * bnx2x_init_hw_common - initialize the HW at the COMMON phase.
+ *
+ * @bp:         driver handle
+ */
+static int bnx2x_init_hw_common(struct bnx2x *bp)
 {
-        u32 val, i;
+        u32 val;
 
         DP(BNX2X_MSG_MCP, "starting common init  func %d\n", BP_ABS_FUNC(bp));
 
         bnx2x_reset_common(bp);
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
-        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, 0xfffc);
 
-        bnx2x_init_block(bp, MISC_BLOCK, COMMON_STAGE);
-        if (!CHIP_IS_E1(bp))
-                REG_WR(bp, MISC_REG_E1HMF_MODE, IS_MF(bp));
+        val = 0xfffc;
+        if (CHIP_IS_E3(bp)) {
+                val |= MISC_REGISTERS_RESET_REG_2_MSTAT0;
+                val |= MISC_REGISTERS_RESET_REG_2_MSTAT1;
+        }
+        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, val);
 
-        if (CHIP_IS_E2(bp)) {
-                u8 fid;
+        bnx2x_init_block(bp, BLOCK_MISC, PHASE_COMMON);
+
+        if (!CHIP_IS_E1x(bp)) {
+                u8 abs_func_id;
 
                 /**
                  * 4-port mode or 2-port mode we need to turn of master-enable
@@ -4545,29 +5349,30 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
                  * for all functions on the given path, this means 0,2,4,6 for
                  * path 0 and 1,3,5,7 for path 1
                  */
-                for (fid = BP_PATH(bp); fid  < E2_FUNC_MAX*2; fid += 2) {
-                        if (fid == BP_ABS_FUNC(bp)) {
+                for (abs_func_id = BP_PATH(bp);
+                     abs_func_id < E2_FUNC_MAX*2; abs_func_id += 2) {
+                        if (abs_func_id == BP_ABS_FUNC(bp)) {
                                 REG_WR(bp,
                                     PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER,
                                     1);
                                 continue;
                         }
 
-                        bnx2x_pretend_func(bp, fid);
+                        bnx2x_pretend_func(bp, abs_func_id);
                         /* clear pf enable */
                         bnx2x_pf_disable(bp);
                         bnx2x_pretend_func(bp, BP_ABS_FUNC(bp));
                 }
         }
 
-        bnx2x_init_block(bp, PXP_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_PXP, PHASE_COMMON);
         if (CHIP_IS_E1(bp)) {
                 /* enable HW interrupt from PXP on USDM overflow
                    bit 16 on INT_MASK_0 */
                 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
         }
 
-        bnx2x_init_block(bp, PXP2_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_PXP2, PHASE_COMMON);
         bnx2x_init_pxp(bp);
 
 #ifdef __BIG_ENDIAN
@@ -4610,7 +5415,69 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
          * This needs to be done by the first PF that is loaded in a path
          * (i.e. common phase)
          */
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
+/* In E2 there is a bug in the timers block that can cause function 6 / 7
+ * (i.e. vnic3) to start even if it is marked as "scan-off".
+ * This occurs when a different function (func2,3) is being marked
+ * as "scan-off". Real-life scenario for example: if a driver is being
+ * load-unloaded while func6,7 are down. This will cause the timer to access
+ * the ilt, translate to a logical address and send a request to read/write.
+ * Since the ilt for the function that is down is not valid, this will cause
+ * a translation error which is unrecoverable.
+ * The Workaround is intended to make sure that when this happens nothing fatal
+ * will occur. The workaround:
+ *      1.  First PF driver which loads on a path will:
+ *              a.  After taking the chip out of reset, by using pretend,
+ *                  it will write "0" to the following registers of
+ *                  the other vnics.
+ *                  REG_WR(pdev, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 0);
+ *                  REG_WR(pdev, CFC_REG_WEAK_ENABLE_PF,0);
+ *                  REG_WR(pdev, CFC_REG_STRONG_ENABLE_PF,0);
+ *                  And for itself it will write '1' to
+ *                  PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER to enable
+ *                  dmae-operations (writing to pram for example.)
+ *                  note: can be done for only function 6,7 but cleaner this
+ *                        way.
+ *              b.  Write zero+valid to the entire ILT.
+ *              c.  Init the first_timers_ilt_entry, last_timers_ilt_entry of
+ *                  VNIC3 (of that port). The range allocated will be the
+ *                  entire ILT. This is needed to prevent  ILT range error.
+ *      2.  Any PF driver load flow:
+ *              a.  ILT update with the physical addresses of the allocated
+ *                  logical pages.
+ *              b.  Wait 20msec. - note that this timeout is needed to make
+ *                  sure there are no requests in one of the PXP internal
+ *                  queues with "old" ILT addresses.
+ *              c.  PF enable in the PGLC.
+ *              d.  Clear the was_error of the PF in the PGLC. (could have
+ *                  occured while driver was down)
+ *              e.  PF enable in the CFC (WEAK + STRONG)
+ *              f.  Timers scan enable
+ *      3.  PF driver unload flow:
+ *              a.  Clear the Timers scan_en.
+ *              b.  Polling for scan_on=0 for that PF.
+ *              c.  Clear the PF enable bit in the PXP.
+ *              d.  Clear the PF enable in the CFC (WEAK + STRONG)
+ *              e.  Write zero+valid to all ILT entries (The valid bit must
+ *                  stay set)
+ *              f.  If this is VNIC 3 of a port then also init
+ *                  first_timers_ilt_entry to zero and last_timers_ilt_entry
+ *                  to the last enrty in the ILT.
+ *
+ *      Notes:
+ *      Currently the PF error in the PGLC is non recoverable.
+ *      In the future the there will be a recovery routine for this error.
+ *      Currently attention is masked.
+ *      Having an MCP lock on the load/unload process does not guarantee that
+ *      there is no Timer disable during Func6/7 enable. This is because the
+ *      Timers scan is currently being cleared by the MCP on FLR.
+ *      Step 2.d can be done only for PF6/7 and the driver can also check if
+ *      there is error before clearing it. But the flow above is simpler and
+ *      more general.
+ *      All ILT entries are written by zero+valid and not just PF6/7
+ *      ILT entries since in the future the ILT entries allocation for
+ *      PF-s might be dynamic.
+ */
                 struct ilt_client_info ilt_cli;
                 struct bnx2x_ilt ilt;
                 memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
@@ -4624,7 +5491,7 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
                 /* Step 1: set zeroes to all ilt page entries with valid bit on
                  * Step 2: set the timers first/last ilt entry to point
                  * to the entire range to prevent ILT range error for 3rd/4th
-                 * vnic (this code assumes existence of the vnic)
+                 * vnic (this code assumes existance of the vnic)
                  *
                  * both steps performed by call to bnx2x_ilt_client_init_op()
                  * with dummy TM client
@@ -4645,12 +5512,12 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
         REG_WR(bp, PXP2_REG_RQ_DISABLE_INPUTS, 0);
         REG_WR(bp, PXP2_REG_RD_DISABLE_INPUTS, 0);
 
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 int factor = CHIP_REV_IS_EMUL(bp) ? 1000 :
                                 (CHIP_REV_IS_FPGA(bp) ? 400 : 0);
-                bnx2x_init_block(bp, PGLUE_B_BLOCK, COMMON_STAGE);
+                bnx2x_init_block(bp, BLOCK_PGLUE_B, PHASE_COMMON);
 
-                bnx2x_init_block(bp, ATC_BLOCK, COMMON_STAGE);
+                bnx2x_init_block(bp, BLOCK_ATC, PHASE_COMMON);
 
                 /* let the HW do it's magic ... */
                 do {
@@ -4664,26 +5531,27 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
                 }
         }
 
-        bnx2x_init_block(bp, DMAE_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_DMAE, PHASE_COMMON);
 
         /* clean the DMAE memory */
         bp->dmae_ready = 1;
-        bnx2x_init_fill(bp, TSEM_REG_PRAM, 0, 8);
+        bnx2x_init_fill(bp, TSEM_REG_PRAM, 0, 8, 1);
+
+        bnx2x_init_block(bp, BLOCK_TCM, PHASE_COMMON);
 
-        bnx2x_init_block(bp, TCM_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, UCM_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, CCM_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, XCM_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_UCM, PHASE_COMMON);
+
+        bnx2x_init_block(bp, BLOCK_CCM, PHASE_COMMON);
+
+        bnx2x_init_block(bp, BLOCK_XCM, PHASE_COMMON);
 
         bnx2x_read_dmae(bp, XSEM_REG_PASSIVE_BUFFER, 3);
         bnx2x_read_dmae(bp, CSEM_REG_PASSIVE_BUFFER, 3);
         bnx2x_read_dmae(bp, TSEM_REG_PASSIVE_BUFFER, 3);
         bnx2x_read_dmae(bp, USEM_REG_PASSIVE_BUFFER, 3);
 
-        bnx2x_init_block(bp, QM_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_QM, PHASE_COMMON);
 
-        if (CHIP_MODE_IS_4_PORT(bp))
-                bnx2x_init_block(bp, QM_4PORT_BLOCK, COMMON_STAGE);
 
         /* QM queues pointers table */
         bnx2x_qm_init_ptr_table(bp, bp->qm_cid_count, INITOP_SET);
@@ -4693,57 +5561,51 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
         REG_WR(bp, QM_REG_SOFT_RESET, 0);
 
 #ifdef BCM_CNIC
-        bnx2x_init_block(bp, TIMERS_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_TM, PHASE_COMMON);
 #endif
 
-        bnx2x_init_block(bp, DQ_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_DORQ, PHASE_COMMON);
         REG_WR(bp, DORQ_REG_DPM_CID_OFST, BNX2X_DB_SHIFT);
-
-        if (!CHIP_REV_IS_SLOW(bp)) {
+        if (!CHIP_REV_IS_SLOW(bp))
                 /* enable hw interrupt from doorbell Q */
                 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
-        }
 
-        bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
-        if (CHIP_MODE_IS_4_PORT(bp)) {
-                REG_WR(bp, BRB1_REG_FULL_LB_XOFF_THRESHOLD, 248);
-                REG_WR(bp, BRB1_REG_FULL_LB_XON_THRESHOLD, 328);
-        }
+        bnx2x_init_block(bp, BLOCK_BRB1, PHASE_COMMON);
 
-        bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_PRS, PHASE_COMMON);
         REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
-#ifndef BCM_CNIC
-        /* set NIC mode */
-        REG_WR(bp, PRS_REG_NIC_MODE, 1);
-#endif
+
         if (!CHIP_IS_E1(bp))
-                REG_WR(bp, PRS_REG_E1HOV_MODE, IS_MF_SD(bp));
+                REG_WR(bp, PRS_REG_E1HOV_MODE, bp->path_has_ovlan);
 
-        if (CHIP_IS_E2(bp)) {
-                /* Bit-map indicating which L2 hdrs may appear after the
-                   basic Ethernet header */
-                int has_ovlan = IS_MF_SD(bp);
-                REG_WR(bp, PRS_REG_HDRS_AFTER_BASIC, (has_ovlan ? 7 : 6));
-                REG_WR(bp, PRS_REG_MUST_HAVE_HDRS, (has_ovlan ? 1 : 0));
-        }
+        if (!CHIP_IS_E1x(bp) && !CHIP_IS_E3B0(bp))
+                /* Bit-map indicating which L2 hdrs may appear
+                 * after the basic Ethernet header
+                 */
+                REG_WR(bp, PRS_REG_HDRS_AFTER_BASIC,
+                       bp->path_has_ovlan ? 7 : 6);
 
-        bnx2x_init_block(bp, TSDM_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, CSDM_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, USDM_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, XSDM_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_TSDM, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_CSDM, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_USDM, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_XSDM, PHASE_COMMON);
 
-        bnx2x_init_fill(bp, TSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
-        bnx2x_init_fill(bp, USEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
-        bnx2x_init_fill(bp, CSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
-        bnx2x_init_fill(bp, XSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
+        if (!CHIP_IS_E1x(bp)) {
+                /* reset VFC memories */
+                REG_WR(bp, TSEM_REG_FAST_MEMORY + VFC_REG_MEMORIES_RST,
+                           VFC_MEMORIES_RST_REG_CAM_RST |
+                           VFC_MEMORIES_RST_REG_RAM_RST);
+                REG_WR(bp, XSEM_REG_FAST_MEMORY + VFC_REG_MEMORIES_RST,
+                           VFC_MEMORIES_RST_REG_CAM_RST |
+                           VFC_MEMORIES_RST_REG_RAM_RST);
 
-        bnx2x_init_block(bp, TSEM_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, USEM_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, CSEM_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, XSEM_BLOCK, COMMON_STAGE);
+                msleep(20);
+        }
 
-        if (CHIP_MODE_IS_4_PORT(bp))
-                bnx2x_init_block(bp, XSEM_4PORT_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_TSEM, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_USEM, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_CSEM, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_XSEM, PHASE_COMMON);
 
         /* sync semi rtc */
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
@@ -4751,21 +5613,18 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
                0x80000000);
 
-        bnx2x_init_block(bp, UPB_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, XPB_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, PBF_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_UPB, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_XPB, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_PBF, PHASE_COMMON);
 
-        if (CHIP_IS_E2(bp)) {
-                int has_ovlan = IS_MF_SD(bp);
-                REG_WR(bp, PBF_REG_HDRS_AFTER_BASIC, (has_ovlan ? 7 : 6));
-                REG_WR(bp, PBF_REG_MUST_HAVE_HDRS, (has_ovlan ? 1 : 0));
-        }
+        if (!CHIP_IS_E1x(bp))
+                REG_WR(bp, PBF_REG_HDRS_AFTER_BASIC,
+                       bp->path_has_ovlan ? 7 : 6);
 
         REG_WR(bp, SRC_REG_SOFT_RST, 1);
-        for (i = SRC_REG_KEYRSS0_0; i <= SRC_REG_KEYRSS1_9; i += 4)
-                REG_WR(bp, i, random32());
 
-        bnx2x_init_block(bp, SRCH_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_SRC, PHASE_COMMON);
+
 #ifdef BCM_CNIC
         REG_WR(bp, SRC_REG_KEYSEARCH_0, 0x63285672);
         REG_WR(bp, SRC_REG_KEYSEARCH_1, 0x24b8f2cc);
@@ -4786,11 +5645,11 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
                                           "of cdu_context(%ld)\n",
                          (long)sizeof(union cdu_context));
 
-        bnx2x_init_block(bp, CDU_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_CDU, PHASE_COMMON);
         val = (4 << 24) + (0 << 12) + 1024;
         REG_WR(bp, CDU_REG_CDU_GLOBAL_PARAMS, val);
 
-        bnx2x_init_block(bp, CFC_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_CFC, PHASE_COMMON);
         REG_WR(bp, CFC_REG_INIT_REG, 0x7FF);
         /* enable context validation interrupt from CFC */
         REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
@@ -4798,20 +5657,19 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
         /* set the thresholds to prevent CFC/CDU race */
         REG_WR(bp, CFC_REG_DEBUG0, 0x20020000);
 
-        bnx2x_init_block(bp, HC_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_HC, PHASE_COMMON);
 
-        if (CHIP_IS_E2(bp) && BP_NOMCP(bp))
+        if (!CHIP_IS_E1x(bp) && BP_NOMCP(bp))
                 REG_WR(bp, IGU_REG_RESET_MEMORIES, 0x36);
 
-        bnx2x_init_block(bp, IGU_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, MISC_AEU_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_IGU, PHASE_COMMON);
+        bnx2x_init_block(bp, BLOCK_MISC_AEU, PHASE_COMMON);
 
-        bnx2x_init_block(bp, PXPCS_BLOCK, COMMON_STAGE);
         /* Reset PCIE errors for debug */
         REG_WR(bp, 0x2814, 0xffffffff);
         REG_WR(bp, 0x3820, 0xffffffff);
 
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_CONTROL_5,
                            (PXPCS_TL_CONTROL_5_ERR_UNSPPORT1 |
                                 PXPCS_TL_CONTROL_5_ERR_UNSPPORT));
@@ -4825,21 +5683,15 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
                                 PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT5));
         }
 
-        bnx2x_init_block(bp, EMAC0_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, EMAC1_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, DBU_BLOCK, COMMON_STAGE);
-        bnx2x_init_block(bp, DBG_BLOCK, COMMON_STAGE);
-
-        bnx2x_init_block(bp, NIG_BLOCK, COMMON_STAGE);
+        bnx2x_init_block(bp, BLOCK_NIG, PHASE_COMMON);
         if (!CHIP_IS_E1(bp)) {
-                REG_WR(bp, NIG_REG_LLH_MF_MODE, IS_MF(bp));
-                REG_WR(bp, NIG_REG_LLH_E1HOV_MODE, IS_MF_SD(bp));
-        }
-        if (CHIP_IS_E2(bp)) {
-                /* Bit-map indicating which L2 hdrs may appear after the
-                   basic Ethernet header */
-                REG_WR(bp, NIG_REG_P0_HDRS_AFTER_BASIC, (IS_MF_SD(bp) ? 7 : 6));
+                /* in E3 this done in per-port section */
+                if (!CHIP_IS_E3(bp))
+                        REG_WR(bp, NIG_REG_LLH_MF_MODE, IS_MF(bp));
         }
+        if (CHIP_IS_E1H(bp))
+                /* not applicable for E2 (and above ...) */
+                REG_WR(bp, NIG_REG_LLH_E1HOV_MODE, IS_MF_SD(bp));
 
         if (CHIP_REV_IS_SLOW(bp))
                 msleep(200);
@@ -4885,123 +5737,133 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
                 bnx2x_enable_blocks_parity(bp);
 
         if (!BP_NOMCP(bp)) {
-                /* In E2 2-PORT mode, same ext phy is used for the two paths */
-                if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) ||
-                    CHIP_IS_E1x(bp)) {
-                        u32 shmem_base[2], shmem2_base[2];
-                        shmem_base[0] =  bp->common.shmem_base;
-                        shmem2_base[0] = bp->common.shmem2_base;
-                        if (CHIP_IS_E2(bp)) {
-                                shmem_base[1] =
-                                        SHMEM2_RD(bp, other_shmem_base_addr);
-                                shmem2_base[1] =
-                                        SHMEM2_RD(bp, other_shmem2_base_addr);
-                        }
-                        bnx2x_acquire_phy_lock(bp);
-                        bnx2x_common_init_phy(bp, shmem_base, shmem2_base,
-                                              bp->common.chip_id);
-                        bnx2x_release_phy_lock(bp);
-                }
+                if (CHIP_IS_E1x(bp))
+                        bnx2x__common_init_phy(bp);
         } else
                 BNX2X_ERR("Bootcode is missing - can not initialize link\n");
 
         return 0;
 }
 
+/**
+ * bnx2x_init_hw_common_chip - init HW at the COMMON_CHIP phase.
+ *
+ * @bp:         driver handle
+ */
+static int bnx2x_init_hw_common_chip(struct bnx2x *bp)
+{
+        int rc = bnx2x_init_hw_common(bp);
+
+        if (rc)
+                return rc;
+
+        /* In E2 2-PORT mode, same ext phy is used for the two paths */
+        if (!BP_NOMCP(bp))
+                bnx2x__common_init_phy(bp);
+
+        return 0;
+}
+
 static int bnx2x_init_hw_port(struct bnx2x *bp)
 {
         int port = BP_PORT(bp);
-        int init_stage = port ? PORT1_STAGE : PORT0_STAGE;
+        int init_phase = port ? PHASE_PORT1 : PHASE_PORT0;
         u32 low, high;
         u32 val;
 
+        bnx2x__link_reset(bp);
+
         DP(BNX2X_MSG_MCP, "starting port init  port %d\n", port);
 
         REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
 
-        bnx2x_init_block(bp, PXP_BLOCK, init_stage);
-        bnx2x_init_block(bp, PXP2_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_MISC, init_phase);
+        bnx2x_init_block(bp, BLOCK_PXP, init_phase);
+        bnx2x_init_block(bp, BLOCK_PXP2, init_phase);
 
         /* Timers bug workaround: disables the pf_master bit in pglue at
          * common phase, we need to enable it here before any dmae access are
          * attempted. Therefore we manually added the enable-master to the
          * port phase (it also happens in the function phase)
          */
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp))
                 REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
 
-        bnx2x_init_block(bp, TCM_BLOCK, init_stage);
-        bnx2x_init_block(bp, UCM_BLOCK, init_stage);
-        bnx2x_init_block(bp, CCM_BLOCK, init_stage);
-        bnx2x_init_block(bp, XCM_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_ATC, init_phase);
+        bnx2x_init_block(bp, BLOCK_DMAE, init_phase);
+        bnx2x_init_block(bp, BLOCK_PGLUE_B, init_phase);
+        bnx2x_init_block(bp, BLOCK_QM, init_phase);
+
+        bnx2x_init_block(bp, BLOCK_TCM, init_phase);
+        bnx2x_init_block(bp, BLOCK_UCM, init_phase);
+        bnx2x_init_block(bp, BLOCK_CCM, init_phase);
+        bnx2x_init_block(bp, BLOCK_XCM, init_phase);
 
         /* QM cid (connection) count */
         bnx2x_qm_init_cid_count(bp, bp->qm_cid_count, INITOP_SET);
 
 #ifdef BCM_CNIC
-        bnx2x_init_block(bp, TIMERS_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_TM, init_phase);
         REG_WR(bp, TM_REG_LIN0_SCAN_TIME + port*4, 20);
         REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + port*4, 31);
 #endif
 
-        bnx2x_init_block(bp, DQ_BLOCK, init_stage);
-
-        if (CHIP_MODE_IS_4_PORT(bp))
-                bnx2x_init_block(bp, QM_4PORT_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_DORQ, init_phase);
 
         if (CHIP_IS_E1(bp) || CHIP_IS_E1H(bp)) {
-                bnx2x_init_block(bp, BRB1_BLOCK, init_stage);
-                if (CHIP_REV_IS_SLOW(bp) && CHIP_IS_E1(bp)) {
-                        /* no pause for emulation and FPGA */
-                        low = 0;
-                        high = 513;
-                } else {
-                        if (IS_MF(bp))
-                                low = ((bp->flags & ONE_PORT_FLAG) ? 160 : 246);
-                        else if (bp->dev->mtu > 4096) {
-                                if (bp->flags & ONE_PORT_FLAG)
-                                        low = 160;
-                                else {
-                                        val = bp->dev->mtu;
-                                        /* (24*1024 + val*4)/256 */
-                                        low = 96 + (val/64) +
-                                                        ((val % 64) ? 1 : 0);
-                                }
-                        } else
-                                low = ((bp->flags & ONE_PORT_FLAG) ? 80 : 160);
-                        high = low + 56;        /* 14*1024/256 */
-                }
+                bnx2x_init_block(bp, BLOCK_BRB1, init_phase);
+
+                if (IS_MF(bp))
+                        low = ((bp->flags & ONE_PORT_FLAG) ? 160 : 246);
+                else if (bp->dev->mtu > 4096) {
+                        if (bp->flags & ONE_PORT_FLAG)
+                                low = 160;
+                        else {
+                                val = bp->dev->mtu;
+                                /* (24*1024 + val*4)/256 */
+                                low = 96 + (val/64) +
+                                                ((val % 64) ? 1 : 0);
+                        }
+                } else
+                        low = ((bp->flags & ONE_PORT_FLAG) ? 80 : 160);
+                high = low + 56;        /* 14*1024/256 */
                 REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_0 + port*4, low);
                 REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_0 + port*4, high);
         }
 
-        if (CHIP_MODE_IS_4_PORT(bp)) {
-                REG_WR(bp, BRB1_REG_PAUSE_0_XOFF_THRESHOLD_0 + port*8, 248);
-                REG_WR(bp, BRB1_REG_PAUSE_0_XON_THRESHOLD_0 + port*8, 328);
-                REG_WR(bp, (BP_PORT(bp) ? BRB1_REG_MAC_GUARANTIED_1 :
-                                          BRB1_REG_MAC_GUARANTIED_0), 40);
-        }
+        if (CHIP_MODE_IS_4_PORT(bp))
+                REG_WR(bp, (BP_PORT(bp) ?
+                            BRB1_REG_MAC_GUARANTIED_1 :
+                            BRB1_REG_MAC_GUARANTIED_0), 40);
 
-        bnx2x_init_block(bp, PRS_BLOCK, init_stage);
 
-        bnx2x_init_block(bp, TSDM_BLOCK, init_stage);
-        bnx2x_init_block(bp, CSDM_BLOCK, init_stage);
-        bnx2x_init_block(bp, USDM_BLOCK, init_stage);
-        bnx2x_init_block(bp, XSDM_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_PRS, init_phase);
+        if (CHIP_IS_E3B0(bp))
+                /* Ovlan exists only if we are in multi-function +
+                 * switch-dependent mode, in switch-independent there
+                 * is no ovlan headers
+                 */
+                REG_WR(bp, BP_PORT(bp) ?
+                       PRS_REG_HDRS_AFTER_BASIC_PORT_1 :
+                       PRS_REG_HDRS_AFTER_BASIC_PORT_0,
+                       (bp->path_has_ovlan ? 7 : 6));
 
-        bnx2x_init_block(bp, TSEM_BLOCK, init_stage);
-        bnx2x_init_block(bp, USEM_BLOCK, init_stage);
-        bnx2x_init_block(bp, CSEM_BLOCK, init_stage);
-        bnx2x_init_block(bp, XSEM_BLOCK, init_stage);
-        if (CHIP_MODE_IS_4_PORT(bp))
-                bnx2x_init_block(bp, XSEM_4PORT_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_TSDM, init_phase);
+        bnx2x_init_block(bp, BLOCK_CSDM, init_phase);
+        bnx2x_init_block(bp, BLOCK_USDM, init_phase);
+        bnx2x_init_block(bp, BLOCK_XSDM, init_phase);
+
+        bnx2x_init_block(bp, BLOCK_TSEM, init_phase);
+        bnx2x_init_block(bp, BLOCK_USEM, init_phase);
+        bnx2x_init_block(bp, BLOCK_CSEM, init_phase);
+        bnx2x_init_block(bp, BLOCK_XSEM, init_phase);
 
-        bnx2x_init_block(bp, UPB_BLOCK, init_stage);
-        bnx2x_init_block(bp, XPB_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_UPB, init_phase);
+        bnx2x_init_block(bp, BLOCK_XPB, init_phase);
 
-        bnx2x_init_block(bp, PBF_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_PBF, init_phase);
 
-        if (!CHIP_IS_E2(bp)) {
+        if (CHIP_IS_E1x(bp)) {
                 /* configure PBF to work without PAUSE mtu 9000 */
                 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
 
@@ -5017,20 +5879,20 @@ static int bnx2x_init_hw_port(struct bnx2x *bp)
         }
 
 #ifdef BCM_CNIC
-        bnx2x_init_block(bp, SRCH_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_SRC, init_phase);
 #endif
-        bnx2x_init_block(bp, CDU_BLOCK, init_stage);
-        bnx2x_init_block(bp, CFC_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_CDU, init_phase);
+        bnx2x_init_block(bp, BLOCK_CFC, init_phase);
 
         if (CHIP_IS_E1(bp)) {
                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
         }
-        bnx2x_init_block(bp, HC_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_HC, init_phase);
 
-        bnx2x_init_block(bp, IGU_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_IGU, init_phase);
 
-        bnx2x_init_block(bp, MISC_AEU_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_MISC_AEU, init_phase);
         /* init aeu_mask_attn_func_0/1:
          *  - SF mode: bits 3-7 are masked. only bits 0-2 are in use
          *  - MF mode: bit 3 is masked. bits 0-2 are in use as in SF
@@ -5040,22 +5902,31 @@ static int bnx2x_init_hw_port(struct bnx2x *bp)
         val |= CHIP_IS_E1(bp) ? 0 : 0x10;
         REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, val);
 
-        bnx2x_init_block(bp, PXPCS_BLOCK, init_stage);
-        bnx2x_init_block(bp, EMAC0_BLOCK, init_stage);
-        bnx2x_init_block(bp, EMAC1_BLOCK, init_stage);
-        bnx2x_init_block(bp, DBU_BLOCK, init_stage);
-        bnx2x_init_block(bp, DBG_BLOCK, init_stage);
+        bnx2x_init_block(bp, BLOCK_NIG, init_phase);
 
-        bnx2x_init_block(bp, NIG_BLOCK, init_stage);
+        if (!CHIP_IS_E1x(bp)) {
+                /* Bit-map indicating which L2 hdrs may appear after the
+                 * basic Ethernet header
+                 */
+                REG_WR(bp, BP_PORT(bp) ?
+                           NIG_REG_P1_HDRS_AFTER_BASIC :
+                           NIG_REG_P0_HDRS_AFTER_BASIC,
+                           IS_MF_SD(bp) ? 7 : 6);
 
-        REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
+                if (CHIP_IS_E3(bp))
+                        REG_WR(bp, BP_PORT(bp) ?
+                                   NIG_REG_LLH1_MF_MODE :
+                                   NIG_REG_LLH_MF_MODE, IS_MF(bp));
+        }
+        if (!CHIP_IS_E3(bp))
+                REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
 
         if (!CHIP_IS_E1(bp)) {
                 /* 0x2 disable mf_ov, 0x1 enable */
                 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK_MF + port*4,
                        (IS_MF_SD(bp) ? 0x1 : 0x2));
 
-                if (CHIP_IS_E2(bp)) {
+                if (!CHIP_IS_E1x(bp)) {
                         val = 0;
                         switch (bp->mf_mode) {
                         case MULTI_FUNCTION_SD:
@@ -5076,17 +5947,16 @@ static int bnx2x_init_hw_port(struct bnx2x *bp)
                 }
         }
 
-        bnx2x_init_block(bp, MCP_BLOCK, init_stage);
-        bnx2x_init_block(bp, DMAE_BLOCK, init_stage);
-        if (bnx2x_fan_failure_det_req(bp, bp->common.shmem_base,
-                                      bp->common.shmem2_base, port)) {
+
+        /* If SPIO5 is set to generate interrupts, enable it for this port */
+        val = REG_RD(bp, MISC_REG_SPIO_EVENT_EN);
+        if (val & (1 << MISC_REGISTERS_SPIO_5)) {
                 u32 reg_addr = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
                                        MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
                 val = REG_RD(bp, reg_addr);
                 val |= AEU_INPUTS_ATTN_BITS_SPIO5;
                 REG_WR(bp, reg_addr, val);
         }
-        bnx2x__link_reset(bp);
 
         return 0;
 }
@@ -5105,7 +5975,7 @@ static void bnx2x_ilt_wr(struct bnx2x *bp, u32 index, dma_addr_t addr)
 
 static inline void bnx2x_igu_clear_sb(struct bnx2x *bp, u8 idu_sb_id)
 {
-        bnx2x_igu_clear_sb_gen(bp, idu_sb_id, true /*PF*/);
+        bnx2x_igu_clear_sb_gen(bp, BP_FUNC(bp), idu_sb_id, true /*PF*/);
 }
 
 static inline void bnx2x_clear_func_ilt(struct bnx2x *bp, u32 func)
@@ -5119,6 +5989,7 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
 {
         int port = BP_PORT(bp);
         int func = BP_FUNC(bp);
+        int init_phase = PHASE_PF0 + func;
         struct bnx2x_ilt *ilt = BP_ILT(bp);
         u16 cdu_ilt_start;
         u32 addr, val;
@@ -5127,6 +5998,10 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
 
         DP(BNX2X_MSG_MCP, "starting func init  func %d\n", func);
 
+        /* FLR cleanup - hmmm */
+        if (!CHIP_IS_E1x(bp))
+                bnx2x_pf_flr_clnup(bp);
+
         /* set MSI reconfigure capability */
         if (bp->common.int_block == INT_BLOCK_HC) {
                 addr = (port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0);
@@ -5135,6 +6010,9 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
                 REG_WR(bp, addr, val);
         }
 
+        bnx2x_init_block(bp, BLOCK_PXP, init_phase);
+        bnx2x_init_block(bp, BLOCK_PXP2, init_phase);
+
         ilt = BP_ILT(bp);
         cdu_ilt_start = ilt->clients[ILT_CLIENT_CDU].start;
 
@@ -5160,7 +6038,7 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
         REG_WR(bp, PRS_REG_NIC_MODE, 1);
 #endif  /* BCM_CNIC */
 
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 u32 pf_conf = IGU_PF_CONF_FUNC_EN;
 
                 /* Turn on a single ISR mode in IGU if driver is going to use
@@ -5187,58 +6065,55 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
 
         bp->dmae_ready = 1;
 
-        bnx2x_init_block(bp, PGLUE_B_BLOCK, FUNC0_STAGE + func);
+        bnx2x_init_block(bp, BLOCK_PGLUE_B, init_phase);
 
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp))
                 REG_WR(bp, PGLUE_B_REG_WAS_ERROR_PF_7_0_CLR, func);
 
-        bnx2x_init_block(bp, MISC_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, TCM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, UCM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, CCM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, XCM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, TSEM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, USEM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, CSEM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, XSEM_BLOCK, FUNC0_STAGE + func);
-
-        if (CHIP_IS_E2(bp)) {
-                REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_PATH_ID_OFFSET,
-                                                                BP_PATH(bp));
-                REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_PATH_ID_OFFSET,
-                                                                BP_PATH(bp));
-        }
-
-        if (CHIP_MODE_IS_4_PORT(bp))
-                bnx2x_init_block(bp, XSEM_4PORT_BLOCK, FUNC0_STAGE + func);
-
-        if (CHIP_IS_E2(bp))
+        bnx2x_init_block(bp, BLOCK_ATC, init_phase);
+        bnx2x_init_block(bp, BLOCK_DMAE, init_phase);
+        bnx2x_init_block(bp, BLOCK_NIG, init_phase);
+        bnx2x_init_block(bp, BLOCK_SRC, init_phase);
+        bnx2x_init_block(bp, BLOCK_MISC, init_phase);
+        bnx2x_init_block(bp, BLOCK_TCM, init_phase);
+        bnx2x_init_block(bp, BLOCK_UCM, init_phase);
+        bnx2x_init_block(bp, BLOCK_CCM, init_phase);
+        bnx2x_init_block(bp, BLOCK_XCM, init_phase);
+        bnx2x_init_block(bp, BLOCK_TSEM, init_phase);
+        bnx2x_init_block(bp, BLOCK_USEM, init_phase);
+        bnx2x_init_block(bp, BLOCK_CSEM, init_phase);
+        bnx2x_init_block(bp, BLOCK_XSEM, init_phase);
+
+        if (!CHIP_IS_E1x(bp))
                 REG_WR(bp, QM_REG_PF_EN, 1);
 
-        bnx2x_init_block(bp, QM_BLOCK, FUNC0_STAGE + func);
-
-        if (CHIP_MODE_IS_4_PORT(bp))
-                bnx2x_init_block(bp, QM_4PORT_BLOCK, FUNC0_STAGE + func);
-
-        bnx2x_init_block(bp, TIMERS_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, DQ_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, BRB1_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, PRS_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, TSDM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, CSDM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, USDM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, XSDM_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, UPB_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, XPB_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, PBF_BLOCK, FUNC0_STAGE + func);
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp)) {
+                REG_WR(bp, TSEM_REG_VFPF_ERR_NUM, BNX2X_MAX_NUM_OF_VFS + func);
+                REG_WR(bp, USEM_REG_VFPF_ERR_NUM, BNX2X_MAX_NUM_OF_VFS + func);
+                REG_WR(bp, CSEM_REG_VFPF_ERR_NUM, BNX2X_MAX_NUM_OF_VFS + func);
+                REG_WR(bp, XSEM_REG_VFPF_ERR_NUM, BNX2X_MAX_NUM_OF_VFS + func);
+        }
+        bnx2x_init_block(bp, BLOCK_QM, init_phase);
+
+        bnx2x_init_block(bp, BLOCK_TM, init_phase);
+        bnx2x_init_block(bp, BLOCK_DORQ, init_phase);
+        bnx2x_init_block(bp, BLOCK_BRB1, init_phase);
+        bnx2x_init_block(bp, BLOCK_PRS, init_phase);
+        bnx2x_init_block(bp, BLOCK_TSDM, init_phase);
+        bnx2x_init_block(bp, BLOCK_CSDM, init_phase);
+        bnx2x_init_block(bp, BLOCK_USDM, init_phase);
+        bnx2x_init_block(bp, BLOCK_XSDM, init_phase);
+        bnx2x_init_block(bp, BLOCK_UPB, init_phase);
+        bnx2x_init_block(bp, BLOCK_XPB, init_phase);
+        bnx2x_init_block(bp, BLOCK_PBF, init_phase);
+        if (!CHIP_IS_E1x(bp))
                 REG_WR(bp, PBF_REG_DISABLE_PF, 0);
 
-        bnx2x_init_block(bp, CDU_BLOCK, FUNC0_STAGE + func);
+        bnx2x_init_block(bp, BLOCK_CDU, init_phase);
 
-        bnx2x_init_block(bp, CFC_BLOCK, FUNC0_STAGE + func);
+        bnx2x_init_block(bp, BLOCK_CFC, init_phase);
 
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp))
                 REG_WR(bp, CFC_REG_WEAK_ENABLE_PF, 1);
 
         if (IS_MF(bp)) {
@@ -5246,7 +6121,7 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
                 REG_WR(bp, NIG_REG_LLH0_FUNC_VLAN_ID + port*8, bp->mf_ov);
         }
 
-        bnx2x_init_block(bp, MISC_AEU_BLOCK, FUNC0_STAGE + func);
+        bnx2x_init_block(bp, BLOCK_MISC_AEU, init_phase);
 
         /* HC init per function */
         if (bp->common.int_block == INT_BLOCK_HC) {
@@ -5256,21 +6131,21 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
                         REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
                         REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
                 }
-                bnx2x_init_block(bp, HC_BLOCK, FUNC0_STAGE + func);
+                bnx2x_init_block(bp, BLOCK_HC, init_phase);
 
         } else {
                 int num_segs, sb_idx, prod_offset;
 
                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
 
-                if (CHIP_IS_E2(bp)) {
+                if (!CHIP_IS_E1x(bp)) {
                         REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, 0);
                         REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, 0);
                 }
 
-                bnx2x_init_block(bp, IGU_BLOCK, FUNC0_STAGE + func);
+                bnx2x_init_block(bp, BLOCK_IGU, init_phase);
 
-                if (CHIP_IS_E2(bp)) {
+                if (!CHIP_IS_E1x(bp)) {
                         int dsb_idx = 0;
                         /**
                          * Producer memory:
@@ -5365,13 +6240,6 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
         REG_WR(bp, 0x2114, 0xffffffff);
         REG_WR(bp, 0x2120, 0xffffffff);
 
-        bnx2x_init_block(bp, EMAC0_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, EMAC1_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, DBU_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, DBG_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, MCP_BLOCK, FUNC0_STAGE + func);
-        bnx2x_init_block(bp, DMAE_BLOCK, FUNC0_STAGE + func);
-
         if (CHIP_IS_E1x(bp)) {
                 main_mem_size = HC_REG_MAIN_MEMORY_SIZE / 2; /*dwords*/
                 main_mem_base = HC_REG_MAIN_MEMORY +
@@ -5397,65 +6265,26 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
                 REG_RD(bp, main_mem_prty_clr);
         }
 
+#ifdef BNX2X_STOP_ON_ERROR
+        /* Enable STORMs SP logging */
+        REG_WR8(bp, BAR_USTRORM_INTMEM +
+               USTORM_RECORD_SLOW_PATH_OFFSET(BP_FUNC(bp)), 1);
+        REG_WR8(bp, BAR_TSTRORM_INTMEM +
+               TSTORM_RECORD_SLOW_PATH_OFFSET(BP_FUNC(bp)), 1);
+        REG_WR8(bp, BAR_CSTRORM_INTMEM +
+               CSTORM_RECORD_SLOW_PATH_OFFSET(BP_FUNC(bp)), 1);
+        REG_WR8(bp, BAR_XSTRORM_INTMEM +
+               XSTORM_RECORD_SLOW_PATH_OFFSET(BP_FUNC(bp)), 1);
+#endif
+
         bnx2x_phy_probe(&bp->link_params);
 
         return 0;
 }
 
-int bnx2x_init_hw(struct bnx2x *bp, u32 load_code)
-{
-        int rc = 0;
-
-        DP(BNX2X_MSG_MCP, "function %d  load_code %x\n",
-           BP_ABS_FUNC(bp), load_code);
-
-        bp->dmae_ready = 0;
-        spin_lock_init(&bp->dmae_lock);
-
-        switch (load_code) {
-        case FW_MSG_CODE_DRV_LOAD_COMMON:
-        case FW_MSG_CODE_DRV_LOAD_COMMON_CHIP:
-                rc = bnx2x_init_hw_common(bp, load_code);
-                if (rc)
-                        goto init_hw_err;
-                /* no break */
-
-        case FW_MSG_CODE_DRV_LOAD_PORT:
-                rc = bnx2x_init_hw_port(bp);
-                if (rc)
-                        goto init_hw_err;
-                /* no break */
-
-        case FW_MSG_CODE_DRV_LOAD_FUNCTION:
-                rc = bnx2x_init_hw_func(bp);
-                if (rc)
-                        goto init_hw_err;
-                break;
-
-        default:
-                BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
-                break;
-        }
-
-        if (!BP_NOMCP(bp)) {
-                int mb_idx = BP_FW_MB_IDX(bp);
-
-                bp->fw_drv_pulse_wr_seq =
-                                (SHMEM_RD(bp, func_mb[mb_idx].drv_pulse_mb) &
-                                 DRV_PULSE_SEQ_MASK);
-                DP(BNX2X_MSG_MCP, "drv_pulse 0x%x\n", bp->fw_drv_pulse_wr_seq);
-        }
-
-init_hw_err:
-        bnx2x_gunzip_end(bp);
-
-        return rc;
-}
 
 void bnx2x_free_mem(struct bnx2x *bp)
 {
-        bnx2x_gunzip_end(bp);
-
         /* fastpath */
         bnx2x_free_fp_mem(bp);
         /* end of fastpath */
@@ -5463,6 +6292,9 @@ void bnx2x_free_mem(struct bnx2x *bp)
         BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
                        sizeof(struct host_sp_status_block));
 
+        BNX2X_PCI_FREE(bp->fw_stats, bp->fw_stats_mapping,
+                       bp->fw_stats_data_sz + bp->fw_stats_req_sz);
+
         BNX2X_PCI_FREE(bp->slowpath, bp->slowpath_mapping,
                        sizeof(struct bnx2x_slowpath));
 
@@ -5474,7 +6306,7 @@ void bnx2x_free_mem(struct bnx2x *bp)
         BNX2X_FREE(bp->ilt->lines);
 
 #ifdef BCM_CNIC
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp))
                 BNX2X_PCI_FREE(bp->cnic_sb.e2_sb, bp->cnic_sb_mapping,
                                sizeof(struct host_hc_status_block_e2));
         else
@@ -5488,18 +6320,67 @@ void bnx2x_free_mem(struct bnx2x *bp)
 
         BNX2X_PCI_FREE(bp->eq_ring, bp->eq_mapping,
                        BCM_PAGE_SIZE * NUM_EQ_PAGES);
+}
+
+static inline int bnx2x_alloc_fw_stats_mem(struct bnx2x *bp)
+{
+        int num_groups;
+
+        /* number of eth_queues */
+        u8 num_queue_stats = BNX2X_NUM_ETH_QUEUES(bp);
+
+        /* Total number of FW statistics requests =
+         * 1 for port stats + 1 for PF stats + num_eth_queues */
+        bp->fw_stats_num = 2 + num_queue_stats;
+
+
+        /* Request is built from stats_query_header and an array of
+         * stats_query_cmd_group each of which contains
+         * STATS_QUERY_CMD_COUNT rules. The real number or requests is
+         * configured in the stats_query_header.
+         */
+        num_groups = (2 + num_queue_stats) / STATS_QUERY_CMD_COUNT +
+                (((2 + num_queue_stats) % STATS_QUERY_CMD_COUNT) ? 1 : 0);
+
+        bp->fw_stats_req_sz = sizeof(struct stats_query_header) +
+                        num_groups * sizeof(struct stats_query_cmd_group);
 
-        BNX2X_FREE(bp->rx_indir_table);
+        /* Data for statistics requests + stats_conter
+         *
+         * stats_counter holds per-STORM counters that are incremented
+         * when STORM has finished with the current request.
+         */
+        bp->fw_stats_data_sz = sizeof(struct per_port_stats) +
+                sizeof(struct per_pf_stats) +
+                sizeof(struct per_queue_stats) * num_queue_stats +
+                sizeof(struct stats_counter);
+
+        BNX2X_PCI_ALLOC(bp->fw_stats, &bp->fw_stats_mapping,
+                        bp->fw_stats_data_sz + bp->fw_stats_req_sz);
+
+        /* Set shortcuts */
+        bp->fw_stats_req = (struct bnx2x_fw_stats_req *)bp->fw_stats;
+        bp->fw_stats_req_mapping = bp->fw_stats_mapping;
+
+        bp->fw_stats_data = (struct bnx2x_fw_stats_data *)
+                ((u8 *)bp->fw_stats + bp->fw_stats_req_sz);
+
+        bp->fw_stats_data_mapping = bp->fw_stats_mapping +
+                                   bp->fw_stats_req_sz;
+        return 0;
+
+alloc_mem_err:
+        BNX2X_PCI_FREE(bp->fw_stats, bp->fw_stats_mapping,
+                       bp->fw_stats_data_sz + bp->fw_stats_req_sz);
+        return -ENOMEM;
 }
 
 
 int bnx2x_alloc_mem(struct bnx2x *bp)
 {
-        if (bnx2x_gunzip_init(bp))
-                return -ENOMEM;
-
 #ifdef BCM_CNIC
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp))
+                /* size = the status block + ramrod buffers */
                 BNX2X_PCI_ALLOC(bp->cnic_sb.e2_sb, &bp->cnic_sb_mapping,
                                 sizeof(struct host_hc_status_block_e2));
         else
@@ -5517,6 +6398,10 @@ int bnx2x_alloc_mem(struct bnx2x *bp)
         BNX2X_PCI_ALLOC(bp->slowpath, &bp->slowpath_mapping,
                         sizeof(struct bnx2x_slowpath));
 
+        /* Allocated memory for FW statistics  */
+        if (bnx2x_alloc_fw_stats_mem(bp))
+                goto alloc_mem_err;
+
         bp->context.size = sizeof(union cdu_context) * bp->l2_cid_count;
 
         BNX2X_PCI_ALLOC(bp->context.vcxt, &bp->context.cxt_mapping,
@@ -5534,8 +6419,6 @@ int bnx2x_alloc_mem(struct bnx2x *bp)
         BNX2X_PCI_ALLOC(bp->eq_ring, &bp->eq_mapping,
                         BCM_PAGE_SIZE * NUM_EQ_PAGES);
 
-        BNX2X_ALLOC(bp->rx_indir_table, sizeof(bp->rx_indir_table[0]) *
-                    TSTORM_INDIRECTION_TABLE_SIZE);
 
         /* fastpath */
         /* need to be done at the end, since it's self adjusting to amount
@@ -5553,235 +6436,76 @@ alloc_mem_err:
 /*
  * Init service functions
  */
-int bnx2x_func_start(struct bnx2x *bp)
-{
-        bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_START, 0, 0, 0, 1);
-
-        /* Wait for completion */
-        return bnx2x_wait_ramrod(bp, BNX2X_STATE_FUNC_STARTED, 0, &(bp->state),
-                                 WAIT_RAMROD_COMMON);
-}
 
-static int bnx2x_func_stop(struct bnx2x *bp)
+int bnx2x_set_mac_one(struct bnx2x *bp, u8 *mac,
+                      struct bnx2x_vlan_mac_obj *obj, bool set,
+                      int mac_type, unsigned long *ramrod_flags)
 {
-        bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_STOP, 0, 0, 0, 1);
-
-        /* Wait for completion */
-        return bnx2x_wait_ramrod(bp, BNX2X_STATE_CLOSING_WAIT4_UNLOAD,
-                                      0, &(bp->state), WAIT_RAMROD_COMMON);
-}
-
-int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
-                             int *state_p, int flags)
-{
-        /* can take a while if any port is running */
-        int cnt = 5000;
-        u8 poll = flags & WAIT_RAMROD_POLL;
-        u8 common = flags & WAIT_RAMROD_COMMON;
+        int rc;
+        struct bnx2x_vlan_mac_ramrod_params ramrod_param;
 
-        DP(NETIF_MSG_IFUP, "%s for state to become %x on IDX [%d]\n",
-           poll ? "polling" : "waiting", state, idx);
+        memset(&ramrod_param, 0, sizeof(ramrod_param));
 
-        might_sleep();
-        while (cnt--) {
-                if (poll) {
-                        if (common)
-                                bnx2x_eq_int(bp);
-                        else {
-                                bnx2x_rx_int(bp->fp, 10);
-                                /* if index is different from 0
-                                 * the reply for some commands will
-                                 * be on the non default queue
-                                 */
-                                if (idx)
-                                        bnx2x_rx_int(&bp->fp[idx], 10);
-                        }
-                }
+        /* Fill general parameters */
+        ramrod_param.vlan_mac_obj = obj;
+        ramrod_param.ramrod_flags = *ramrod_flags;
 
-                mb(); /* state is changed by bnx2x_sp_event() */
-                if (*state_p == state) {
-#ifdef BNX2X_STOP_ON_ERROR
-                        DP(NETIF_MSG_IFUP, "exit  (cnt %d)\n", 5000 - cnt);
-#endif
-                        return 0;
-                }
+        /* Fill a user request section if needed */
+        if (!test_bit(RAMROD_CONT, ramrod_flags)) {
+                memcpy(ramrod_param.user_req.u.mac.mac, mac, ETH_ALEN);
 
-                msleep(1);
+                __set_bit(mac_type, &ramrod_param.user_req.vlan_mac_flags);
 
-                if (bp->panic)
-                        return -EIO;
+                /* Set the command: ADD or DEL */
+                if (set)
+                        ramrod_param.user_req.cmd = BNX2X_VLAN_MAC_ADD;
+                else
+                        ramrod_param.user_req.cmd = BNX2X_VLAN_MAC_DEL;
         }
 
-        /* timeout! */
-        BNX2X_ERR("timeout %s for state %x on IDX [%d]\n",
-                  poll ? "polling" : "waiting", state, idx);
-#ifdef BNX2X_STOP_ON_ERROR
-        bnx2x_panic();
-#endif
-
-        return -EBUSY;
-}
-
-static u8 bnx2x_e1h_cam_offset(struct bnx2x *bp, u8 rel_offset)
-{
-        if (CHIP_IS_E1H(bp))
-                return E1H_FUNC_MAX * rel_offset + BP_FUNC(bp);
-        else if (CHIP_MODE_IS_4_PORT(bp))
-                return E2_FUNC_MAX * rel_offset + BP_FUNC(bp);
-        else
-                return E2_FUNC_MAX * rel_offset + BP_VN(bp);
+        rc = bnx2x_config_vlan_mac(bp, &ramrod_param);
+        if (rc < 0)
+                BNX2X_ERR("%s MAC failed\n", (set ? "Set" : "Del"));
+        return rc;
 }
 
-/**
- *  LLH CAM line allocations: currently only iSCSI and ETH macs are
- *  relevant. In addition, current implementation is tuned for a
- *  single ETH MAC.
- */
-enum {
-        LLH_CAM_ISCSI_ETH_LINE = 0,
-        LLH_CAM_ETH_LINE,
-        LLH_CAM_MAX_PF_LINE = NIG_REG_LLH1_FUNC_MEM_SIZE
-};
-
-static void bnx2x_set_mac_in_nig(struct bnx2x *bp,
-                          int set,
-                          unsigned char *dev_addr,
-                          int index)
+int bnx2x_del_all_macs(struct bnx2x *bp,
+                       struct bnx2x_vlan_mac_obj *mac_obj,
+                       int mac_type, bool wait_for_comp)
 {
-        u32 wb_data[2];
-        u32 mem_offset, ena_offset, mem_index;
-        /**
-         * indexes mapping:
-         * 0..7 - goes to MEM
-         * 8..15 - goes to MEM2
-         */
-
-        if (!IS_MF_SI(bp) || index > LLH_CAM_MAX_PF_LINE)
-                return;
-
-        /* calculate memory start offset according to the mapping
-         * and index in the memory */
-        if (index < NIG_LLH_FUNC_MEM_MAX_OFFSET) {
-                mem_offset = BP_PORT(bp) ? NIG_REG_LLH1_FUNC_MEM :
-                                           NIG_REG_LLH0_FUNC_MEM;
-                ena_offset = BP_PORT(bp) ? NIG_REG_LLH1_FUNC_MEM_ENABLE :
-                                           NIG_REG_LLH0_FUNC_MEM_ENABLE;
-                mem_index = index;
-        } else {
-                mem_offset = BP_PORT(bp) ? NIG_REG_P1_LLH_FUNC_MEM2 :
-                                           NIG_REG_P0_LLH_FUNC_MEM2;
-                ena_offset = BP_PORT(bp) ? NIG_REG_P1_LLH_FUNC_MEM2_ENABLE :
-                                           NIG_REG_P0_LLH_FUNC_MEM2_ENABLE;
-                mem_index = index - NIG_LLH_FUNC_MEM_MAX_OFFSET;
-        }
-
-        if (set) {
-                /* LLH_FUNC_MEM is a u64 WB register */
-                mem_offset += 8*mem_index;
-
-                wb_data[0] = ((dev_addr[2] << 24) | (dev_addr[3] << 16) |
-                              (dev_addr[4] <<  8) |  dev_addr[5]);
-                wb_data[1] = ((dev_addr[0] <<  8) |  dev_addr[1]);
-
-                REG_WR_DMAE(bp, mem_offset, wb_data, 2);
-        }
-
-        /* enable/disable the entry */
-        REG_WR(bp, ena_offset + 4*mem_index, set);
-
-}
+        int rc;
+        unsigned long ramrod_flags = 0, vlan_mac_flags = 0;
 
-void bnx2x_set_eth_mac(struct bnx2x *bp, int set)
-{
-        u8 cam_offset = (CHIP_IS_E1(bp) ? (BP_PORT(bp) ? 32 : 0) :
-                         bnx2x_e1h_cam_offset(bp, CAM_ETH_LINE));
+        /* Wait for completion of requested */
+        if (wait_for_comp)
+                __set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
 
-        /* networking  MAC */
-        bnx2x_set_mac_addr_gen(bp, set, bp->dev->dev_addr,
-                               (1 << bp->fp->cl_id), cam_offset , 0);
+        /* Set the mac type of addresses we want to clear */
+        __set_bit(mac_type, &vlan_mac_flags);
 
-        bnx2x_set_mac_in_nig(bp, set, bp->dev->dev_addr, LLH_CAM_ETH_LINE);
+        rc = mac_obj->delete_all(bp, mac_obj, &vlan_mac_flags, &ramrod_flags);
+        if (rc < 0)
+                BNX2X_ERR("Failed to delete MACs: %d\n", rc);
 
-        if (CHIP_IS_E1(bp)) {
-                /* broadcast MAC */
-                static const u8 bcast[ETH_ALEN] = {
-                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff
-                };
-                bnx2x_set_mac_addr_gen(bp, set, bcast, 0, cam_offset + 1, 1);
-        }
+        return rc;
 }
 
-#ifdef BCM_CNIC
-/**
- * bnx2x_set_iscsi_eth_mac_addr - set iSCSI MAC(s).
- *
- * @bp:         driver handle
- * @set:        set or clear the CAM entry
- *
- * This function will wait until the ramdord completion returns.
- * Return 0 if success, -ENODEV if ramrod doesn't return.
- */
-static int bnx2x_set_iscsi_eth_mac_addr(struct bnx2x *bp, int set)
+int bnx2x_set_eth_mac(struct bnx2x *bp, bool set)
 {
-        u8 cam_offset = (CHIP_IS_E1(bp) ? ((BP_PORT(bp) ? 32 : 0) + 2) :
-                         bnx2x_e1h_cam_offset(bp, CAM_ISCSI_ETH_LINE));
-        u32 iscsi_l2_cl_id = BNX2X_ISCSI_ETH_CL_ID +
-                BP_E1HVN(bp) * NONE_ETH_CONTEXT_USE;
-        u32 cl_bit_vec = (1 << iscsi_l2_cl_id);
-        u8 *iscsi_mac = bp->cnic_eth_dev.iscsi_mac;
-
-        /* Send a SET_MAC ramrod */
-        bnx2x_set_mac_addr_gen(bp, set, iscsi_mac, cl_bit_vec,
-                               cam_offset, 0);
-
-        bnx2x_set_mac_in_nig(bp, set, iscsi_mac, LLH_CAM_ISCSI_ETH_LINE);
-
-        return 0;
-}
+        unsigned long ramrod_flags = 0;
 
-/**
- * bnx2x_set_fip_eth_mac_addr - set FCoE L2 MAC(s)
- *
- * @bp:         driver handle
- * @set:        set or clear the CAM entry
- *
- * This function will wait until the ramrod completion returns.
- * Returns 0 if success, -ENODEV if ramrod doesn't return.
- */
-int bnx2x_set_fip_eth_mac_addr(struct bnx2x *bp, int set)
-{
-        u32 cl_bit_vec = (1 << bnx2x_fcoe(bp, cl_id));
-        /**
-         * CAM allocation for E1H
-         * eth unicasts: by func number
-         * iscsi: by func number
-         * fip unicast: by func number
-         * fip multicast: by func number
-         */
-        bnx2x_set_mac_addr_gen(bp, set, bp->fip_mac,
-                cl_bit_vec, bnx2x_e1h_cam_offset(bp, CAM_FIP_ETH_LINE), 0);
+        DP(NETIF_MSG_IFUP, "Adding Eth MAC\n");
 
-        return 0;
+        __set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
+        /* Eth MAC is set on RSS leading client (fp[0]) */
+        return bnx2x_set_mac_one(bp, bp->dev->dev_addr, &bp->fp->mac_obj, set,
+                                 BNX2X_ETH_MAC, &ramrod_flags);
 }
 
-int bnx2x_set_all_enode_macs(struct bnx2x *bp, int set)
+int bnx2x_setup_leading(struct bnx2x *bp)
 {
-        u32 cl_bit_vec = (1 << bnx2x_fcoe(bp, cl_id));
-
-        /**
-         * CAM allocation for E1H
-         * eth unicasts: by func number
-         * iscsi: by func number
-         * fip unicast: by func number
-         * fip multicast: by func number
-         */
-        bnx2x_set_mac_addr_gen(bp, set, ALL_ENODE_MACS, cl_bit_vec,
-                bnx2x_e1h_cam_offset(bp, CAM_FIP_MCAST_LINE), 0);
-
-        return 0;
+        return bnx2x_setup_queue(bp, &bp->fp[0], 1);
 }
-#endif
-
 
 /**
  * bnx2x_set_int_mode - configure interrupt mode
@@ -5792,7 +6516,6 @@ int bnx2x_set_all_enode_macs(struct bnx2x *bp, int set)
  */
 static void __devinit bnx2x_set_int_mode(struct bnx2x *bp)
 {
-
         switch (int_mode) {
         case INT_MODE_MSI:
                 bnx2x_enable_msi(bp);
@@ -5852,7 +6575,7 @@ void bnx2x_ilt_set_info(struct bnx2x *bp)
         ilt_client->page_size = CDU_ILT_PAGE_SZ;
         ilt_client->flags = ILT_CLIENT_SKIP_MEM;
         ilt_client->start = line;
-        line += L2_ILT_LINES(bp);
+        line += bnx2x_cid_ilt_lines(bp);
 #ifdef BCM_CNIC
         line += CNIC_ILT_LINES;
 #endif
@@ -5932,12 +6655,72 @@ void bnx2x_ilt_set_info(struct bnx2x *bp)
 #else
         ilt_client->flags = (ILT_CLIENT_SKIP_INIT | ILT_CLIENT_SKIP_MEM);
 #endif
+        BUG_ON(line > ILT_MAX_LINES);
+}
+
+/**
+ * bnx2x_pf_q_prep_init - prepare INIT transition parameters
+ *
+ * @bp:                 driver handle
+ * @fp:                 pointer to fastpath
+ * @init_params:        pointer to parameters structure
+ *
+ * parameters configured:
+ *      - HC configuration
+ *      - Queue's CDU context
+ */
+static inline void bnx2x_pf_q_prep_init(struct bnx2x *bp,
+        struct bnx2x_fastpath *fp, struct bnx2x_queue_init_params *init_params)
+{
+        /* FCoE Queue uses Default SB, thus has no HC capabilities */
+        if (!IS_FCOE_FP(fp)) {
+                __set_bit(BNX2X_Q_FLG_HC, &init_params->rx.flags);
+                __set_bit(BNX2X_Q_FLG_HC, &init_params->tx.flags);
+
+                /* If HC is supporterd, enable host coalescing in the transition
+                 * to INIT state.
+                 */
+                __set_bit(BNX2X_Q_FLG_HC_EN, &init_params->rx.flags);
+                __set_bit(BNX2X_Q_FLG_HC_EN, &init_params->tx.flags);
+
+                /* HC rate */
+                init_params->rx.hc_rate = bp->rx_ticks ?
+                        (1000000 / bp->rx_ticks) : 0;
+                init_params->tx.hc_rate = bp->tx_ticks ?
+                        (1000000 / bp->tx_ticks) : 0;
+
+                /* FW SB ID */
+                init_params->rx.fw_sb_id = init_params->tx.fw_sb_id =
+                        fp->fw_sb_id;
+
+                /*
+                 * CQ index among the SB indices: FCoE clients uses the default
+                 * SB, therefore it's different.
+                 */
+                init_params->rx.sb_cq_index = U_SB_ETH_RX_CQ_INDEX;
+                init_params->tx.sb_cq_index = C_SB_ETH_TX_CQ_INDEX;
+        }
+
+        init_params->cxt = &bp->context.vcxt[fp->cid].eth;
 }
 
-int bnx2x_setup_client(struct bnx2x *bp, struct bnx2x_fastpath *fp,
-                       int is_leading)
+/**
+ * bnx2x_setup_queue - setup queue
+ *
+ * @bp:         driver handle
+ * @fp:         pointer to fastpath
+ * @leading:    is leading
+ *
+ * This function performs 2 steps in a Queue state machine
+ *      actually: 1) RESET->INIT 2) INIT->SETUP
+ */
+
+int bnx2x_setup_queue(struct bnx2x *bp, struct bnx2x_fastpath *fp,
+                       bool leading)
 {
-        struct bnx2x_client_init_params params = { {0} };
+        struct bnx2x_queue_state_params q_params = {0};
+        struct bnx2x_queue_setup_params *setup_params =
+                                                &q_params.params.setup;
         int rc;
 
         /* reset IGU state skip FCoE L2 queue */
@@ -5945,79 +6728,73 @@ int bnx2x_setup_client(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                 bnx2x_ack_sb(bp, fp->igu_sb_id, USTORM_ID, 0,
                              IGU_INT_ENABLE, 0);
 
-        params.ramrod_params.pstate = &fp->state;
-        params.ramrod_params.state = BNX2X_FP_STATE_OPEN;
-        params.ramrod_params.index = fp->index;
-        params.ramrod_params.cid = fp->cid;
+        q_params.q_obj = &fp->q_obj;
+        /* We want to wait for completion in this context */
+        __set_bit(RAMROD_COMP_WAIT, &q_params.ramrod_flags);
 
-#ifdef BCM_CNIC
-        if (IS_FCOE_FP(fp))
-                params.ramrod_params.flags |= CLIENT_IS_FCOE;
+        /* Prepare the INIT parameters */
+        bnx2x_pf_q_prep_init(bp, fp, &q_params.params.init);
 
-#endif
+        /* Set the command */
+        q_params.cmd = BNX2X_Q_CMD_INIT;
 
-        if (is_leading)
-                params.ramrod_params.flags |= CLIENT_IS_LEADING_RSS;
+        /* Change the state to INIT */
+        rc = bnx2x_queue_state_change(bp, &q_params);
+        if (rc) {
+                BNX2X_ERR("Queue INIT failed\n");
+                return rc;
+        }
+
+        /* Now move the Queue to the SETUP state... */
+        memset(setup_params, 0, sizeof(*setup_params));
+
+        /* Set QUEUE flags */
+        setup_params->flags = bnx2x_get_q_flags(bp, fp, leading);
 
-        bnx2x_pf_rx_cl_prep(bp, fp, &params.pause, &params.rxq_params);
+        /* Set general SETUP parameters */
+        bnx2x_pf_q_prep_general(bp, fp, &setup_params->gen_params);
 
-        bnx2x_pf_tx_cl_prep(bp, fp, &params.txq_params);
+        bnx2x_pf_rx_q_prep(bp, fp, &setup_params->pause,
+                            &setup_params->rxq_params);
+
+        bnx2x_pf_tx_q_prep(bp, fp, &setup_params->txq_params);
+
+        /* Set the command */
+        q_params.cmd = BNX2X_Q_CMD_SETUP;
+
+        /* Change the state to SETUP */
+        rc = bnx2x_queue_state_change(bp, &q_params);
+        if (rc)
+                BNX2X_ERR("Queue SETUP failed\n");
 
-        rc = bnx2x_setup_fw_client(bp, &params, 1,
-                                     bnx2x_sp(bp, client_init_data),
-                                     bnx2x_sp_mapping(bp, client_init_data));
         return rc;
 }
 
-static int bnx2x_stop_fw_client(struct bnx2x *bp,
-                                struct bnx2x_client_ramrod_params *p)
+static int bnx2x_stop_queue(struct bnx2x *bp, int index)
 {
+        struct bnx2x_fastpath *fp = &bp->fp[index];
+        struct bnx2x_queue_state_params q_params = {0};
         int rc;
 
-        int poll_flag = p->poll ? WAIT_RAMROD_POLL : 0;
+        q_params.q_obj = &fp->q_obj;
+        /* We want to wait for completion in this context */
+        __set_bit(RAMROD_COMP_WAIT, &q_params.ramrod_flags);
 
         /* halt the connection */
-        *p->pstate = BNX2X_FP_STATE_HALTING;
-        bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, p->cid, 0,
-                                                  p->cl_id, 0);
-
-        /* Wait for completion */
-        rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, p->index,
-                               p->pstate, poll_flag);
-        if (rc) /* timeout */
+        q_params.cmd = BNX2X_Q_CMD_HALT;
+        rc = bnx2x_queue_state_change(bp, &q_params);
+        if (rc)
                 return rc;
 
-        *p->pstate = BNX2X_FP_STATE_TERMINATING;
-        bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_TERMINATE, p->cid, 0,
-                                                       p->cl_id, 0);
-        /* Wait for completion */
-        rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_TERMINATED, p->index,
-                               p->pstate, poll_flag);
-        if (rc) /* timeout */
+        /* terminate the connection */
+        q_params.cmd = BNX2X_Q_CMD_TERMINATE;
+        rc = bnx2x_queue_state_change(bp, &q_params);
+        if (rc)
                 return rc;
 
-
         /* delete cfc entry */
-        bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_CFC_DEL, p->cid, 0, 0, 1);
-
-        /* Wait for completion */
-        rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_CLOSED, p->index,
-                               p->pstate, WAIT_RAMROD_COMMON);
-        return rc;
-}
-
-static int bnx2x_stop_client(struct bnx2x *bp, int index)
-{
-        struct bnx2x_client_ramrod_params client_stop = {0};
-        struct bnx2x_fastpath *fp = &bp->fp[index];
-
-        client_stop.index = index;
-        client_stop.cid = fp->cid;
-        client_stop.cl_id = fp->cl_id;
-        client_stop.pstate = &(fp->state);
-        client_stop.poll = 0;
-
-        return bnx2x_stop_fw_client(bp, &client_stop);
+        q_params.cmd = BNX2X_Q_CMD_CFC_DEL;
+        return bnx2x_queue_state_change(bp, &q_params);
 }
 
 
@@ -6026,12 +6803,6 @@ static void bnx2x_reset_func(struct bnx2x *bp)
         int port = BP_PORT(bp);
         int func = BP_FUNC(bp);
         int i;
-        int pfunc_offset_fp = offsetof(struct hc_sb_data, p_func) +
-                        (CHIP_IS_E2(bp) ?
-                         offsetof(struct hc_status_block_data_e2, common) :
-                         offsetof(struct hc_status_block_data_e1x, common));
-        int pfunc_offset_sp = offsetof(struct hc_sp_status_block_data, p_func);
-        int pfid_offset = offsetof(struct pci_entity, pf_id);
 
         /* Disable the function in the FW */
         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(func), 0);
@@ -6042,20 +6813,21 @@ static void bnx2x_reset_func(struct bnx2x *bp)
         /* FP SBs */
         for_each_eth_queue(bp, i) {
                 struct bnx2x_fastpath *fp = &bp->fp[i];
-                REG_WR8(bp,
-                        BAR_CSTRORM_INTMEM +
-                        CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id)
-                        + pfunc_offset_fp + pfid_offset,
-                        HC_FUNCTION_DISABLED);
+                REG_WR8(bp, BAR_CSTRORM_INTMEM +
+                        CSTORM_STATUS_BLOCK_DATA_STATE_OFFSET(fp->fw_sb_id),
+                        SB_DISABLED);
         }
 
+#ifdef BCM_CNIC
+        /* CNIC SB */
+        REG_WR8(bp, BAR_CSTRORM_INTMEM +
+                CSTORM_STATUS_BLOCK_DATA_STATE_OFFSET(bnx2x_cnic_fw_sb_id(bp)),
+                SB_DISABLED);
+#endif
         /* SP SB */
-        REG_WR8(bp,
-                BAR_CSTRORM_INTMEM +
-                CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
-                pfunc_offset_sp + pfid_offset,
-                HC_FUNCTION_DISABLED);
-
+        REG_WR8(bp, BAR_CSTRORM_INTMEM +
+                CSTORM_SP_STATUS_BLOCK_DATA_STATE_OFFSET(func),
+                SB_DISABLED);
 
         for (i = 0; i < XSTORM_SPQ_DATA_SIZE / 4; i++)
                 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_DATA_OFFSET(func),
@@ -6089,7 +6861,7 @@ static void bnx2x_reset_func(struct bnx2x *bp)
         /* Timers workaround bug for E2: if this is vnic-3,
          * we need to set the entire ilt range for this timers.
          */
-        if (CHIP_IS_E2(bp) && BP_VN(bp) == 3) {
+        if (!CHIP_IS_E1x(bp) && BP_VN(bp) == 3) {
                 struct ilt_client_info ilt_cli;
                 /* use dummy TM client */
                 memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
@@ -6101,7 +6873,7 @@ static void bnx2x_reset_func(struct bnx2x *bp)
         }
 
         /* this assumes that reset_port() called before reset_func()*/
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp))
                 bnx2x_pf_disable(bp);
 
         bp->dmae_ready = 0;
@@ -6112,6 +6884,9 @@ static void bnx2x_reset_port(struct bnx2x *bp)
         int port = BP_PORT(bp);
         u32 val;
 
+        /* Reset physical Link */
+        bnx2x__link_reset(bp);
+
         REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
 
         /* Do not rcv packets to BRB */
@@ -6133,92 +6908,66 @@ static void bnx2x_reset_port(struct bnx2x *bp)
         /* TODO: Close Doorbell port? */
 }
 
-static void bnx2x_reset_chip(struct bnx2x *bp, u32 reset_code)
+static inline int bnx2x_reset_hw(struct bnx2x *bp, u32 load_code)
 {
-        DP(BNX2X_MSG_MCP, "function %d  reset_code %x\n",
-           BP_ABS_FUNC(bp), reset_code);
+        struct bnx2x_func_state_params func_params = {0};
 
-        switch (reset_code) {
-        case FW_MSG_CODE_DRV_UNLOAD_COMMON:
-                bnx2x_reset_port(bp);
-                bnx2x_reset_func(bp);
-                bnx2x_reset_common(bp);
-                break;
-
-        case FW_MSG_CODE_DRV_UNLOAD_PORT:
-                bnx2x_reset_port(bp);
-                bnx2x_reset_func(bp);
-                break;
-
-        case FW_MSG_CODE_DRV_UNLOAD_FUNCTION:
-                bnx2x_reset_func(bp);
-                break;
-
-        default:
-                BNX2X_ERR("Unknown reset_code (0x%x) from MCP\n", reset_code);
-                break;
-        }
-}
+        /* Prepare parameters for function state transitions */
+        __set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
 
-#ifdef BCM_CNIC
-static inline void bnx2x_del_fcoe_eth_macs(struct bnx2x *bp)
-{
-        if (bp->flags & FCOE_MACS_SET) {
-                if (!IS_MF_SD(bp))
-                        bnx2x_set_fip_eth_mac_addr(bp, 0);
+        func_params.f_obj = &bp->func_obj;
+        func_params.cmd = BNX2X_F_CMD_HW_RESET;
 
-                bnx2x_set_all_enode_macs(bp, 0);
+        func_params.params.hw_init.load_phase = load_code;
 
-                bp->flags &= ~FCOE_MACS_SET;
-        }
+        return bnx2x_func_state_change(bp, &func_params);
 }
-#endif
 
-void bnx2x_chip_cleanup(struct bnx2x *bp, int unload_mode)
+static inline int bnx2x_func_stop(struct bnx2x *bp)
 {
-        int port = BP_PORT(bp);
-        u32 reset_code = 0;
-        int i, cnt, rc;
-
-        /* Wait until tx fastpath tasks complete */
-        for_each_tx_queue(bp, i) {
-                struct bnx2x_fastpath *fp = &bp->fp[i];
+        struct bnx2x_func_state_params func_params = {0};
+        int rc;
 
-                cnt = 1000;
-                while (bnx2x_has_tx_work_unload(fp)) {
+        /* Prepare parameters for function state transitions */
+        __set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
+        func_params.f_obj = &bp->func_obj;
+        func_params.cmd = BNX2X_F_CMD_STOP;
 
-                        if (!cnt) {
-                                BNX2X_ERR("timeout waiting for queue[%d]\n",
-                                          i);
+        /*
+         * Try to stop the function the 'good way'. If fails (in case
+         * of a parity error during bnx2x_chip_cleanup()) and we are
+         * not in a debug mode, perform a state transaction in order to
+         * enable further HW_RESET transaction.
+         */
+        rc = bnx2x_func_state_change(bp, &func_params);
+        if (rc) {
 #ifdef BNX2X_STOP_ON_ERROR
-                                bnx2x_panic();
-                                return -EBUSY;
+                return rc;
 #else
-                                break;
+                BNX2X_ERR("FUNC_STOP ramrod failed. Running a dry "
+                          "transaction\n");
+                __set_bit(RAMROD_DRV_CLR_ONLY, &func_params.ramrod_flags);
+                return bnx2x_func_state_change(bp, &func_params);
 #endif
-                        }
-                        cnt--;
-                        msleep(1);
-                }
         }
-        /* Give HW time to discard old tx messages */
-        msleep(1);
-
-        bnx2x_set_eth_mac(bp, 0);
 
-        bnx2x_invalidate_uc_list(bp);
-
-        if (CHIP_IS_E1(bp))
-                bnx2x_invalidate_e1_mc_list(bp);
-        else {
-                bnx2x_invalidate_e1h_mc_list(bp);
-                REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
-        }
+        return 0;
+}
 
-#ifdef BCM_CNIC
-        bnx2x_del_fcoe_eth_macs(bp);
-#endif
+/**
+ * bnx2x_send_unload_req - request unload mode from the MCP.
+ *
+ * @bp:                 driver handle
+ * @unload_mode:        requested function's unload mode
+ *
+ * Return unload mode returned by the MCP: COMMON, PORT or FUNC.
+ */
+u32 bnx2x_send_unload_req(struct bnx2x *bp, int unload_mode)
+{
+        u32 reset_code = 0;
+        int port = BP_PORT(bp);
 
+        /* Select the UNLOAD request mode */
         if (unload_mode == UNLOAD_NORMAL)
                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
 
@@ -6245,54 +6994,135 @@ void bnx2x_chip_cleanup(struct bnx2x *bp, int unload_mode)
         } else
                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
 
+        /* Send the request to the MCP */
+        if (!BP_NOMCP(bp))
+                reset_code = bnx2x_fw_command(bp, reset_code, 0);
+        else {
+                int path = BP_PATH(bp);
+
+                DP(NETIF_MSG_IFDOWN, "NO MCP - load counts[%d]      "
+                                     "%d, %d, %d\n",
+                   path, load_count[path][0], load_count[path][1],
+                   load_count[path][2]);
+                load_count[path][0]--;
+                load_count[path][1 + port]--;
+                DP(NETIF_MSG_IFDOWN, "NO MCP - new load counts[%d]  "
+                                     "%d, %d, %d\n",
+                   path, load_count[path][0], load_count[path][1],
+                   load_count[path][2]);
+                if (load_count[path][0] == 0)
+                        reset_code = FW_MSG_CODE_DRV_UNLOAD_COMMON;
+                else if (load_count[path][1 + port] == 0)
+                        reset_code = FW_MSG_CODE_DRV_UNLOAD_PORT;
+                else
+                        reset_code = FW_MSG_CODE_DRV_UNLOAD_FUNCTION;
+        }
+
+        return reset_code;
+}
+
+/**
+ * bnx2x_send_unload_done - send UNLOAD_DONE command to the MCP.
+ *
+ * @bp:         driver handle
+ */
+void bnx2x_send_unload_done(struct bnx2x *bp)
+{
+        /* Report UNLOAD_DONE to MCP */
+        if (!BP_NOMCP(bp))
+                bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
+}
+
+void bnx2x_chip_cleanup(struct bnx2x *bp, int unload_mode)
+{
+        int port = BP_PORT(bp);
+        int i, rc;
+        struct bnx2x_mcast_ramrod_params rparam = {0};
+        u32 reset_code;
+
+        /* Wait until tx fastpath tasks complete */
+        for_each_tx_queue(bp, i) {
+                struct bnx2x_fastpath *fp = &bp->fp[i];
+
+                rc = bnx2x_clean_tx_queue(bp, fp);
+#ifdef BNX2X_STOP_ON_ERROR
+                if (rc)
+                        return;
+#endif
+        }
+
+        /* Give HW time to discard old tx messages */
+        usleep_range(1000, 1000);
+
+        /* Clean all ETH MACs */
+        rc = bnx2x_del_all_macs(bp, &bp->fp[0].mac_obj, BNX2X_ETH_MAC, false);
+        if (rc < 0)
+                BNX2X_ERR("Failed to delete all ETH macs: %d\n", rc);
+
+        /* Clean up UC list  */
+        rc = bnx2x_del_all_macs(bp, &bp->fp[0].mac_obj, BNX2X_UC_LIST_MAC,
+                                true);
+        if (rc < 0)
+                BNX2X_ERR("Failed to schedule DEL commands for UC MACs list: "
+                          "%d\n", rc);
+
+        /* Disable LLH */
+        if (!CHIP_IS_E1(bp))
+                REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
+
+        /* Set "drop all" (stop Rx).
+         * We need to take a netif_addr_lock() here in order to prevent
+         * a race between the completion code and this code.
+         */
+        netif_addr_lock_bh(bp->dev);
+        /* Schedule the rx_mode command */
+        if (test_bit(BNX2X_FILTER_RX_MODE_PENDING, &bp->sp_state))
+                set_bit(BNX2X_FILTER_RX_MODE_SCHED, &bp->sp_state);
+        else
+                bnx2x_set_storm_rx_mode(bp);
+
+        /* Cleanup multicast configuration */
+        rparam.mcast_obj = &bp->mcast_obj;
+        rc = bnx2x_config_mcast(bp, &rparam, BNX2X_MCAST_CMD_DEL);
+        if (rc < 0)
+                BNX2X_ERR("Failed to send DEL multicast command: %d\n", rc);
+
+        netif_addr_unlock_bh(bp->dev);
+
+
         /* Close multi and leading connections
-           Completions for ramrods are collected in a synchronous way */
+         * Completions for ramrods are collected in a synchronous way
+         */
         for_each_queue(bp, i)
-
-                if (bnx2x_stop_client(bp, i))
+                if (bnx2x_stop_queue(bp, i))
 #ifdef BNX2X_STOP_ON_ERROR
                         return;
 #else
                         goto unload_error;
 #endif
+        /* If SP settings didn't get completed so far - something
+         * very wrong has happen.
+         */
+        if (!bnx2x_wait_sp_comp(bp, ~0x0UL))
+                BNX2X_ERR("Hmmm... Common slow path ramrods got stuck!\n");
 
+#ifndef BNX2X_STOP_ON_ERROR
+unload_error:
+#endif
         rc = bnx2x_func_stop(bp);
         if (rc) {
                 BNX2X_ERR("Function stop failed!\n");
 #ifdef BNX2X_STOP_ON_ERROR
                 return;
-#else
-                goto unload_error;
-#endif
-        }
-#ifndef BNX2X_STOP_ON_ERROR
-unload_error:
 #endif
-        if (!BP_NOMCP(bp))
-                reset_code = bnx2x_fw_command(bp, reset_code, 0);
-        else {
-                DP(NETIF_MSG_IFDOWN, "NO MCP - load counts[%d]      "
-                                     "%d, %d, %d\n", BP_PATH(bp),
-                   load_count[BP_PATH(bp)][0],
-                   load_count[BP_PATH(bp)][1],
-                   load_count[BP_PATH(bp)][2]);
-                load_count[BP_PATH(bp)][0]--;
-                load_count[BP_PATH(bp)][1 + port]--;
-                DP(NETIF_MSG_IFDOWN, "NO MCP - new load counts[%d]  "
-                                     "%d, %d, %d\n", BP_PATH(bp),
-                   load_count[BP_PATH(bp)][0], load_count[BP_PATH(bp)][1],
-                   load_count[BP_PATH(bp)][2]);
-                if (load_count[BP_PATH(bp)][0] == 0)
-                        reset_code = FW_MSG_CODE_DRV_UNLOAD_COMMON;
-                else if (load_count[BP_PATH(bp)][1 + port] == 0)
-                        reset_code = FW_MSG_CODE_DRV_UNLOAD_PORT;
-                else
-                        reset_code = FW_MSG_CODE_DRV_UNLOAD_FUNCTION;
         }
 
-        if ((reset_code == FW_MSG_CODE_DRV_UNLOAD_COMMON) ||
-            (reset_code == FW_MSG_CODE_DRV_UNLOAD_PORT))
-                bnx2x__link_reset(bp);
+        /*
+         * Send the UNLOAD_REQUEST to the MCP. This will return if
+         * this function should perform FUNC, PORT or COMMON HW
+         * reset.
+         */
+        reset_code = bnx2x_send_unload_req(bp, unload_mode);
 
         /* Disable HW interrupts, NAPI */
         bnx2x_netif_stop(bp, 1);
@@ -6301,12 +7131,13 @@ unload_error:
         bnx2x_free_irq(bp);
 
         /* Reset the chip */
-        bnx2x_reset_chip(bp, reset_code);
+        rc = bnx2x_reset_hw(bp, reset_code);
+        if (rc)
+                BNX2X_ERR("HW_RESET failed\n");
 
-        /* Report UNLOAD_DONE to MCP */
-        if (!BP_NOMCP(bp))
-                bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
 
+        /* Report UNLOAD_DONE to MCP */
+        bnx2x_send_unload_done(bp);
 }
 
 void bnx2x_disable_close_the_gate(struct bnx2x *bp)
@@ -6323,7 +7154,7 @@ void bnx2x_disable_close_the_gate(struct bnx2x *bp)
                 val = REG_RD(bp, addr);
                 val &= ~(0x300);
                 REG_WR(bp, addr, val);
-        } else if (CHIP_IS_E1H(bp)) {
+        } else {
                 val = REG_RD(bp, MISC_REG_AEU_GENERAL_MASK);
                 val &= ~(MISC_AEU_GENERAL_MASK_REG_AEU_PXP_CLOSE_MASK |
                          MISC_AEU_GENERAL_MASK_REG_AEU_NIG_CLOSE_MASK);
@@ -6820,8 +7651,8 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                         u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
                         /* save our pf_num */
                         int orig_pf_num = bp->pf_num;
-                        u32 swap_en;
-                        u32 swap_val;
+                        int port;
+                        u32 swap_en, swap_val, value;
 
                         /* clear the UNDI indication */
                         REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
@@ -6856,21 +7687,19 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
 
                         bnx2x_undi_int_disable(bp);
+                        port = BP_PORT(bp);
 
                         /* close input traffic and wait for it */
                         /* Do not rcv packets to BRB */
-                        REG_WR(bp,
-                              (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_DRV_MASK :
-                                             NIG_REG_LLH0_BRB1_DRV_MASK), 0x0);
+                        REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_DRV_MASK :
+                                           NIG_REG_LLH0_BRB1_DRV_MASK), 0x0);
                         /* Do not direct rcv packets that are not for MCP to
                          * the BRB */
-                        REG_WR(bp,
-                               (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_NOT_MCP :
-                                              NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
+                        REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_NOT_MCP :
+                                           NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
                         /* clear AEU */
-                        REG_WR(bp,
-                             (BP_PORT(bp) ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
-                                            MISC_REG_AEU_MASK_ATTN_FUNC_0), 0);
+                        REG_WR(bp, (port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
+                                           MISC_REG_AEU_MASK_ATTN_FUNC_0), 0);
                         msleep(10);
 
                         /* save NIG port swap info */
@@ -6880,9 +7709,17 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                         REG_WR(bp,
                                GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
                                0xd3ffffff);
+
+                        value = 0x1400;
+                        if (CHIP_IS_E3(bp)) {
+                                value |= MISC_REGISTERS_RESET_REG_2_MSTAT0;
+                                value |= MISC_REGISTERS_RESET_REG_2_MSTAT1;
+                        }
+
                         REG_WR(bp,
                                GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
-                               0x1403);
+                               value);
+
                         /* take the NIG out of reset and restore swap values */
                         REG_WR(bp,
                                GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
@@ -6923,7 +7760,7 @@ static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
         /* Set doorbell size */
         bp->db_size = (1 << BNX2X_DB_SHIFT);
 
-        if (CHIP_IS_E2(bp)) {
+        if (!CHIP_IS_E1x(bp)) {
                 val = REG_RD(bp, MISC_REG_PORT4MODE_EN_OVWR);
                 if ((val & 1) == 0)
                         val = REG_RD(bp, MISC_REG_PORT4MODE_EN);
@@ -6943,16 +7780,6 @@ static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
                 bp->pfid = bp->pf_num;                  /* 0..7 */
         }
 
-        /*
-         * set base FW non-default (fast path) status block id, this value is
-         * used to initialize the fw_sb_id saved on the fp/queue structure to
-         * determine the id used by the FW.
-         */
-        if (CHIP_IS_E1x(bp))
-                bp->base_fw_ndsb = BP_PORT(bp) * FP_SB_MAX_E1x;
-        else /* E2 */
-                bp->base_fw_ndsb = BP_PORT(bp) * FP_SB_MAX_E2;
-
         bp->link_params.chip_id = bp->common.chip_id;
         BNX2X_DEV_INFO("chip ID is 0x%x\n", id);
 
@@ -6971,6 +7798,8 @@ static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
 
         bnx2x_init_shmem(bp);
 
+
+
         bp->common.shmem2_base = REG_RD(bp, (BP_PATH(bp) ?
                                         MISC_REG_GENERIC_CR_1 :
                                         MISC_REG_GENERIC_CR_0));
@@ -7080,8 +7909,14 @@ static void __devinit bnx2x_get_igu_cam_info(struct bnx2x *bp)
                         }
                 }
         }
-        bp->igu_sb_cnt = min_t(u8, bp->igu_sb_cnt,
-                                   NUM_IGU_SB_REQUIRED(bp->l2_cid_count));
+
+        /* It's expected that number of CAM entries for this
+         * functions is equal to the MSI-X table size (which was a
+         * used during bp->l2_cid_count value calculation.
+         * We want a harsh warning if these values are different!
+         */
+        WARN_ON(bp->igu_sb_cnt != NUM_IGU_SB_REQUIRED(bp->l2_cid_count));
+
         if (bp->igu_sb_cnt == 0)
                 BNX2X_ERR("CAM configuration error\n");
 }
@@ -7130,24 +7965,25 @@ static void __devinit bnx2x_link_settings_supported(struct bnx2x *bp,
                         return;
         }
 
-        switch (switch_cfg) {
-        case SWITCH_CFG_1G:
-                bp->port.phy_addr = REG_RD(bp, NIG_REG_SERDES0_CTRL_PHY_ADDR +
-                                           port*0x10);
-                BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
-                break;
-
-        case SWITCH_CFG_10G:
-                bp->port.phy_addr = REG_RD(bp, NIG_REG_XGXS0_CTRL_PHY_ADDR +
-                                           port*0x18);
-                BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
-                break;
-
-        default:
-                BNX2X_ERR("BAD switch_cfg link_config 0x%x\n",
-                          bp->port.link_config[0]);
-                return;
+        if (CHIP_IS_E3(bp))
+                bp->port.phy_addr = REG_RD(bp, MISC_REG_WC0_CTRL_PHY_ADDR);
+        else {
+                switch (switch_cfg) {
+                case SWITCH_CFG_1G:
+                        bp->port.phy_addr = REG_RD(
+                                bp, NIG_REG_SERDES0_CTRL_PHY_ADDR + port*0x10);
+                        break;
+                case SWITCH_CFG_10G:
+                        bp->port.phy_addr = REG_RD(
+                                bp, NIG_REG_XGXS0_CTRL_PHY_ADDR + port*0x18);
+                        break;
+                default:
+                        BNX2X_ERR("BAD switch_cfg link_config 0x%x\n",
+                                  bp->port.link_config[0]);
+                        return;
+                }
         }
+        BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
         /* mask what we support according to speed_cap_mask per configuration */
         for (idx = 0; idx < cfg_size; idx++) {
                 if (!(bp->link_params.speed_cap_mask[idx] &
@@ -7331,8 +8167,6 @@ static void __devinit bnx2x_link_settings_requested(struct bnx2x *bp)
                         break;
 
                 case PORT_FEATURE_LINK_SPEED_10G_CX4:
-                case PORT_FEATURE_LINK_SPEED_10G_KX4:
-                case PORT_FEATURE_LINK_SPEED_10G_KR:
                         if (bp->port.supported[idx] &
                             SUPPORTED_10000baseT_Full) {
                                 bp->link_params.req_line_speed[idx] =
@@ -7503,6 +8337,9 @@ static void __devinit bnx2x_get_mac_hwinfo(struct bnx2x *bp)
         u8 *fip_mac = bp->fip_mac;
 #endif
 
+        /* Zero primary MAC configuration */
+        memset(bp->dev->dev_addr, 0, ETH_ALEN);
+
         if (BP_NOMCP(bp)) {
                 BNX2X_ERROR("warning: random MAC workaround active\n");
                 random_ether_addr(bp->dev->dev_addr);
@@ -7524,9 +8361,10 @@ static void __devinit bnx2x_get_mac_hwinfo(struct bnx2x *bp)
                                                      iscsi_mac_addr_upper);
                                 val = MF_CFG_RD(bp, func_ext_config[func].
                                                     iscsi_mac_addr_lower);
-                                BNX2X_DEV_INFO("Read iSCSI MAC: "
-                                               "0x%x:0x%04x\n", val2, val);
                                 bnx2x_set_mac_buf(iscsi_mac, val, val2);
+                                BNX2X_DEV_INFO("Read iSCSI MAC: "
+                                               BNX2X_MAC_FMT"\n",
+                                               BNX2X_MAC_PRN_LIST(iscsi_mac));
                         } else
                                 bp->flags |= NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG;
 
@@ -7535,9 +8373,10 @@ static void __devinit bnx2x_get_mac_hwinfo(struct bnx2x *bp)
                                                      fcoe_mac_addr_upper);
                                 val = MF_CFG_RD(bp, func_ext_config[func].
                                                     fcoe_mac_addr_lower);
-                                BNX2X_DEV_INFO("Read FCoE MAC to "
-                                               "0x%x:0x%04x\n", val2, val);
                                 bnx2x_set_mac_buf(fip_mac, val, val2);
+                                BNX2X_DEV_INFO("Read FCoE L2 MAC to "
+                                               BNX2X_MAC_FMT"\n",
+                                               BNX2X_MAC_PRN_LIST(fip_mac));
 
                         } else
                                 bp->flags |= NO_FCOE_FLAG;
@@ -7586,6 +8425,13 @@ static void __devinit bnx2x_get_mac_hwinfo(struct bnx2x *bp)
                 memset(bp->fip_mac, 0, ETH_ALEN);
         }
 #endif
+
+        if (!is_valid_ether_addr(bp->dev->dev_addr))
+                dev_err(&bp->pdev->dev,
+                        "bad Ethernet MAC address configuration: "
+                        BNX2X_MAC_FMT", change it manually before bringing up "
+                        "the appropriate network interface\n",
+                        BNX2X_MAC_PRN_LIST(bp->dev->dev_addr));
 }
 
 static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
@@ -7607,17 +8453,55 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
         } else {
                 bp->common.int_block = INT_BLOCK_IGU;
                 val = REG_RD(bp, IGU_REG_BLOCK_CONFIGURATION);
+
+                if (val & IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN) {
+                        int tout = 5000;
+
+                        BNX2X_DEV_INFO("FORCING Normal Mode\n");
+
+                        val &= ~(IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN);
+                        REG_WR(bp, IGU_REG_BLOCK_CONFIGURATION, val);
+                        REG_WR(bp, IGU_REG_RESET_MEMORIES, 0x7f);
+
+                        while (tout && REG_RD(bp, IGU_REG_RESET_MEMORIES)) {
+                                tout--;
+                                usleep_range(1000, 1000);
+                        }
+
+                        if (REG_RD(bp, IGU_REG_RESET_MEMORIES)) {
+                                dev_err(&bp->pdev->dev,
+                                        "FORCING Normal Mode failed!!!\n");
+                                return -EPERM;
+                        }
+                }
+
                 if (val & IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN) {
-                        DP(NETIF_MSG_PROBE, "IGU Backward Compatible Mode\n");
+                        BNX2X_DEV_INFO("IGU Backward Compatible Mode\n");
                         bp->common.int_block |= INT_BLOCK_MODE_BW_COMP;
                 } else
-                        DP(NETIF_MSG_PROBE, "IGU Normal Mode\n");
+                        BNX2X_DEV_INFO("IGU Normal Mode\n");
 
                 bnx2x_get_igu_cam_info(bp);
 
         }
-        DP(NETIF_MSG_PROBE, "igu_dsb_id %d  igu_base_sb %d  igu_sb_cnt %d\n",
-                             bp->igu_dsb_id, bp->igu_base_sb, bp->igu_sb_cnt);
+
+        /*
+         * set base FW non-default (fast path) status block id, this value is
+         * used to initialize the fw_sb_id saved on the fp/queue structure to
+         * determine the id used by the FW.
+         */
+        if (CHIP_IS_E1x(bp))
+                bp->base_fw_ndsb = BP_PORT(bp) * FP_SB_MAX_E1x + BP_L_ID(bp);
+        else /*
+              * 57712 - we currently use one FW SB per IGU SB (Rx and Tx of
+              * the same queue are indicated on the same IGU SB). So we prefer
+              * FW and IGU SBs to be the same value.
+              */
+                bp->base_fw_ndsb = bp->igu_base_sb;
+
+        BNX2X_DEV_INFO("igu_dsb_id %d  igu_base_sb %d  igu_sb_cnt %d\n"
+                       "base_fw_ndsb %d\n", bp->igu_dsb_id, bp->igu_base_sb,
+                       bp->igu_sb_cnt, bp->base_fw_ndsb);
 
         /*
          * Initialize MF configuration
@@ -7628,10 +8512,10 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
         vn = BP_E1HVN(bp);
 
         if (!CHIP_IS_E1(bp) && !BP_NOMCP(bp)) {
-                DP(NETIF_MSG_PROBE,
-                            "shmem2base 0x%x, size %d, mfcfg offset %d\n",
-                            bp->common.shmem2_base, SHMEM2_RD(bp, size),
-                            (u32)offsetof(struct shmem2_region, mf_cfg_addr));
+                BNX2X_DEV_INFO("shmem2base 0x%x, size %d, mfcfg offset %d\n",
+                               bp->common.shmem2_base, SHMEM2_RD(bp, size),
+                              (u32)offsetof(struct shmem2_region, mf_cfg_addr));
+
                 if (SHMEM2_HAS(bp, mf_cfg_addr))
                         bp->common.mf_cfg_base = SHMEM2_RD(bp, mf_cfg_addr);
                 else
@@ -7662,8 +8546,8 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
                                         bp->mf_config[vn] = MF_CFG_RD(bp,
                                                    func_mf_config[func].config);
                                 } else
-                                        DP(NETIF_MSG_PROBE, "illegal MAC "
-                                                            "address for SI\n");
+                                        BNX2X_DEV_INFO("illegal MAC address "
+                                                       "for SI\n");
                                 break;
                         case SHARED_FEAT_CFG_FORCE_SF_MODE_MF_ALLOWED:
                                 /* get OV configuration */
@@ -7696,13 +8580,16 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
                               FUNC_MF_CFG_E1HOV_TAG_MASK;
                         if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
                                 bp->mf_ov = val;
-                                BNX2X_DEV_INFO("MF OV for func %d is %d"
-                                               " (0x%04x)\n", func,
-                                               bp->mf_ov, bp->mf_ov);
+                                bp->path_has_ovlan = true;
+
+                                BNX2X_DEV_INFO("MF OV for func %d is %d "
+                                               "(0x%04x)\n", func, bp->mf_ov,
+                                               bp->mf_ov);
                         } else {
-                                BNX2X_ERR("No valid MF OV for func %d,"
-                                          "  aborting\n", func);
-                                rc = -EPERM;
+                                dev_err(&bp->pdev->dev,
+                                        "No valid MF OV for func %d, "
+                                        "aborting\n", func);
+                                return -EPERM;
                         }
                         break;
                 case MULTI_FUNCTION_SI:
@@ -7711,31 +8598,40 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
                         break;
                 default:
                         if (vn) {
-                                BNX2X_ERR("VN %d in single function mode,"
-                                          "  aborting\n", vn);
-                                rc = -EPERM;
+                                dev_err(&bp->pdev->dev,
+                                        "VN %d is in a single function mode, "
+                                        "aborting\n", vn);
+                                return -EPERM;
                         }
                         break;
                 }
 
+                /* check if other port on the path needs ovlan:
+                 * Since MF configuration is shared between ports
+                 * Possible mixed modes are only
+                 * {SF, SI} {SF, SD} {SD, SF} {SI, SF}
+                 */
+                if (CHIP_MODE_IS_4_PORT(bp) &&
+                    !bp->path_has_ovlan &&
+                    !IS_MF(bp) &&
+                    bp->common.mf_cfg_base != SHMEM_MF_CFG_ADDR_NONE) {
+                        u8 other_port = !BP_PORT(bp);
+                        u8 other_func = BP_PATH(bp) + 2*other_port;
+                        val = MF_CFG_RD(bp,
+                                        func_mf_config[other_func].e1hov_tag);
+                        if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT)
+                                bp->path_has_ovlan = true;
+                }
         }
 
         /* adjust igu_sb_cnt to MF for E1x */
         if (CHIP_IS_E1x(bp) && IS_MF(bp))
                 bp->igu_sb_cnt /= E1HVN_MAX;
 
-        /*
-         * adjust E2 sb count: to be removed when FW will support
-         * more then 16 L2 clients
-         */
-#define MAX_L2_CLIENTS                          16
-        if (CHIP_IS_E2(bp))
-                bp->igu_sb_cnt = min_t(u8, bp->igu_sb_cnt,
-                                       MAX_L2_CLIENTS / (IS_MF(bp) ? 4 : 1));
+        /* port info */
+        bnx2x_get_port_hwinfo(bp);
 
         if (!BP_NOMCP(bp)) {
-                bnx2x_get_port_hwinfo(bp);
-
                 bp->fw_seq =
                         (SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
                          DRV_MSG_SEQ_NUMBER_MASK);
@@ -7749,6 +8645,16 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
         bnx2x_get_cnic_info(bp);
 #endif
 
+        /* Get current FW pulse sequence */
+        if (!BP_NOMCP(bp)) {
+                int mb_idx = BP_FW_MB_IDX(bp);
+
+                bp->fw_drv_pulse_wr_seq =
+                                (SHMEM_RD(bp, func_mb[mb_idx].drv_pulse_mb) &
+                                 DRV_PULSE_SEQ_MASK);
+                BNX2X_DEV_INFO("drv_pulse 0x%x\n", bp->fw_drv_pulse_wr_seq);
+        }
+
         return rc;
 }
 
@@ -7816,6 +8722,55 @@ out_not_found:
         return;
 }
 
+static void __devinit bnx2x_set_modes_bitmap(struct bnx2x *bp)
+{
+        u32 flags = 0;
+
+        if (CHIP_REV_IS_FPGA(bp))
+                SET_FLAGS(flags, MODE_FPGA);
+        else if (CHIP_REV_IS_EMUL(bp))
+                SET_FLAGS(flags, MODE_EMUL);
+        else
+                SET_FLAGS(flags, MODE_ASIC);
+
+        if (CHIP_MODE_IS_4_PORT(bp))
+                SET_FLAGS(flags, MODE_PORT4);
+        else
+                SET_FLAGS(flags, MODE_PORT2);
+
+        if (CHIP_IS_E2(bp))
+                SET_FLAGS(flags, MODE_E2);
+        else if (CHIP_IS_E3(bp)) {
+                SET_FLAGS(flags, MODE_E3);
+                if (CHIP_REV(bp) == CHIP_REV_Ax)
+                        SET_FLAGS(flags, MODE_E3_A0);
+                else {/*if (CHIP_REV(bp) == CHIP_REV_Bx)*/
+                        SET_FLAGS(flags, MODE_E3_B0);
+                        SET_FLAGS(flags, MODE_COS_BC);
+                }
+        }
+
+        if (IS_MF(bp)) {
+                SET_FLAGS(flags, MODE_MF);
+                switch (bp->mf_mode) {
+                case MULTI_FUNCTION_SD:
+                        SET_FLAGS(flags, MODE_MF_SD);
+                        break;
+                case MULTI_FUNCTION_SI:
+                        SET_FLAGS(flags, MODE_MF_SI);
+                        break;
+                }
+        } else
+                SET_FLAGS(flags, MODE_SF);
+
+#if defined(__LITTLE_ENDIAN)
+        SET_FLAGS(flags, MODE_LITTLE_ENDIAN);
+#else /*(__BIG_ENDIAN)*/
+        SET_FLAGS(flags, MODE_BIG_ENDIAN);
+#endif
+        INIT_MODE_FLAGS(bp) = flags;
+}
+
 static int __devinit bnx2x_init_bp(struct bnx2x *bp)
 {
         int func;
@@ -7833,9 +8788,14 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
         INIT_DELAYED_WORK(&bp->reset_task, bnx2x_reset_task);
 
         rc = bnx2x_get_hwinfo(bp);
+        if (rc)
+                return rc;
 
-        if (!rc)
-                rc = bnx2x_alloc_mem_bp(bp);
+        bnx2x_set_modes_bitmap(bp);
+
+        rc = bnx2x_alloc_mem_bp(bp);
+        if (rc)
+                return rc;
 
         bnx2x_read_fwinfo(bp);
 
@@ -7888,6 +8848,13 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
         bnx2x_dcbx_set_state(bp, true, BNX2X_DCBX_ENABLED_ON_NEG_ON);
         bnx2x_dcbx_init_params(bp);
 
+#ifdef BCM_CNIC
+        if (CHIP_IS_E1x(bp))
+                bp->cnic_base_cl_id = FP_SB_MAX_E1x;
+        else
+                bp->cnic_base_cl_id = FP_SB_MAX_E2;
+#endif
+
         return rc;
 }
 
@@ -7896,6 +8863,10 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
 * General service functions
 ****************************************************************************/
 
+/*
+ * net_device service functions
+ */
+
 /* called with rtnl_lock */
 static int bnx2x_open(struct net_device *dev)
 {
@@ -7954,193 +8925,119 @@ static int bnx2x_close(struct net_device *dev)
         return 0;
 }
 
-#define E1_MAX_UC_LIST  29
-#define E1H_MAX_UC_LIST 30
-#define E2_MAX_UC_LIST  14
-static inline u8 bnx2x_max_uc_list(struct bnx2x *bp)
+static inline int bnx2x_init_mcast_macs_list(struct bnx2x *bp,
+                                         struct bnx2x_mcast_ramrod_params *p)
 {
-        if (CHIP_IS_E1(bp))
-                return E1_MAX_UC_LIST;
-        else if (CHIP_IS_E1H(bp))
-                return E1H_MAX_UC_LIST;
-        else
-                return E2_MAX_UC_LIST;
-}
+        int mc_count = netdev_mc_count(bp->dev);
+        struct bnx2x_mcast_list_elem *mc_mac =
+                kzalloc(sizeof(*mc_mac) * mc_count, GFP_ATOMIC);
+        struct netdev_hw_addr *ha;
 
+        if (!mc_mac)
+                return -ENOMEM;
 
-static inline u8 bnx2x_uc_list_cam_offset(struct bnx2x *bp)
-{
-        if (CHIP_IS_E1(bp))
-                /* CAM Entries for Port0:
-                 *      0 - prim ETH MAC
-                 *      1 - BCAST MAC
-                 *      2 - iSCSI L2 ring ETH MAC
-                 *      3-31 - UC MACs
-                 *
-                 * Port1 entries are allocated the same way starting from
-                 * entry 32.
-                 */
-                return 3 + 32 * BP_PORT(bp);
-        else if (CHIP_IS_E1H(bp)) {
-                /* CAM Entries:
-                 *      0-7  - prim ETH MAC for each function
-                 *      8-15 - iSCSI L2 ring ETH MAC for each function
-                 *      16 till 255 UC MAC lists for each function
-                 *
-                 * Remark: There is no FCoE support for E1H, thus FCoE related
-                 *         MACs are not considered.
-                 */
-                return E1H_FUNC_MAX * (CAM_ISCSI_ETH_LINE + 1) +
-                        bnx2x_max_uc_list(bp) * BP_FUNC(bp);
-        } else {
-                /* CAM Entries (there is a separate CAM per engine):
-                 *      0-4  - prim ETH MAC for each function
-                 *      4-7 - iSCSI L2 ring ETH MAC for each function
-                 *      8-11 - FIP ucast L2 MAC for each function
-                 *      12-15 - ALL_ENODE_MACS mcast MAC for each function
-                 *      16 till 71 UC MAC lists for each function
-                 */
-                u8 func_idx =
-                        (CHIP_MODE_IS_4_PORT(bp) ? BP_FUNC(bp) : BP_VN(bp));
+        INIT_LIST_HEAD(&p->mcast_list);
 
-                return E2_FUNC_MAX * (CAM_MAX_PF_LINE + 1) +
-                        bnx2x_max_uc_list(bp) * func_idx;
+        netdev_for_each_mc_addr(ha, bp->dev) {
+                mc_mac->mac = bnx2x_mc_addr(ha);
+                list_add_tail(&mc_mac->link, &p->mcast_list);
+                mc_mac++;
         }
+
+        p->mcast_list_len = mc_count;
+
+        return 0;
+}
+
+static inline void bnx2x_free_mcast_macs_list(
+        struct bnx2x_mcast_ramrod_params *p)
+{
+        struct bnx2x_mcast_list_elem *mc_mac =
+                list_first_entry(&p->mcast_list, struct bnx2x_mcast_list_elem,
+                                 link);
+
+        WARN_ON(!mc_mac);
+        kfree(mc_mac);
 }
 
-/* set uc list, do not wait as wait implies sleep and
- * set_rx_mode can be invoked from non-sleepable context.
+/**
+ * bnx2x_set_uc_list - configure a new unicast MACs list.
+ *
+ * @bp: driver handle
  *
- * Instead we use the same ramrod data buffer each time we need
- * to configure a list of addresses, and use the fact that the
- * list of MACs is changed in an incremental way and that the
- * function is called under the netif_addr_lock. A temporary
- * inconsistent CAM configuration (possible in case of very fast
- * sequence of add/del/add on the host side) will shortly be
- * restored by the handler of the last ramrod.
+ * We will use zero (0) as a MAC type for these MACs.
  */
-static int bnx2x_set_uc_list(struct bnx2x *bp)
+static inline int bnx2x_set_uc_list(struct bnx2x *bp)
 {
-        int i = 0, old;
+        int rc;
         struct net_device *dev = bp->dev;
-        u8 offset = bnx2x_uc_list_cam_offset(bp);
         struct netdev_hw_addr *ha;
-        struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, uc_mac_config);
-        dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, uc_mac_config);
+        struct bnx2x_vlan_mac_obj *mac_obj = &bp->fp->mac_obj;
+        unsigned long ramrod_flags = 0;
 
-        if (netdev_uc_count(dev) > bnx2x_max_uc_list(bp))
-                return -EINVAL;
+        /* First schedule a cleanup up of old configuration */
+        rc = bnx2x_del_all_macs(bp, mac_obj, BNX2X_UC_LIST_MAC, false);
+        if (rc < 0) {
+                BNX2X_ERR("Failed to schedule DELETE operations: %d\n", rc);
+                return rc;
+        }
 
         netdev_for_each_uc_addr(ha, dev) {
-                /* copy mac */
-                config_cmd->config_table[i].msb_mac_addr =
-                        swab16(*(u16 *)&bnx2x_uc_addr(ha)[0]);
-                config_cmd->config_table[i].middle_mac_addr =
-                        swab16(*(u16 *)&bnx2x_uc_addr(ha)[2]);
-                config_cmd->config_table[i].lsb_mac_addr =
-                        swab16(*(u16 *)&bnx2x_uc_addr(ha)[4]);
-
-                config_cmd->config_table[i].vlan_id = 0;
-                config_cmd->config_table[i].pf_id = BP_FUNC(bp);
-                config_cmd->config_table[i].clients_bit_vector =
-                        cpu_to_le32(1 << BP_L_ID(bp));
-
-                SET_FLAG(config_cmd->config_table[i].flags,
-                        MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
-                        T_ETH_MAC_COMMAND_SET);
-
-                DP(NETIF_MSG_IFUP,
-                   "setting UCAST[%d] (%04x:%04x:%04x)\n", i,
-                   config_cmd->config_table[i].msb_mac_addr,
-                   config_cmd->config_table[i].middle_mac_addr,
-                   config_cmd->config_table[i].lsb_mac_addr);
-
-                i++;
-
-                /* Set uc MAC in NIG */
-                bnx2x_set_mac_in_nig(bp, 1, bnx2x_uc_addr(ha),
-                                     LLH_CAM_ETH_LINE + i);
-        }
-        old = config_cmd->hdr.length;
-        if (old > i) {
-                for (; i < old; i++) {
-                        if (CAM_IS_INVALID(config_cmd->
-                                           config_table[i])) {
-                                /* already invalidated */
-                                break;
-                        }
-                        /* invalidate */
-                        SET_FLAG(config_cmd->config_table[i].flags,
-                                MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
-                                T_ETH_MAC_COMMAND_INVALIDATE);
+                rc = bnx2x_set_mac_one(bp, bnx2x_uc_addr(ha), mac_obj, true,
+                                       BNX2X_UC_LIST_MAC, &ramrod_flags);
+                if (rc < 0) {
+                        BNX2X_ERR("Failed to schedule ADD operations: %d\n",
+                                  rc);
+                        return rc;
                 }
         }
 
-        wmb();
-
-        config_cmd->hdr.length = i;
-        config_cmd->hdr.offset = offset;
-        config_cmd->hdr.client_id = 0xff;
-        /* Mark that this ramrod doesn't use bp->set_mac_pending for
-         * synchronization.
-         */
-        config_cmd->hdr.echo = 0;
-
-        mb();
-
-        return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
-                   U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
-
+        /* Execute the pending commands */
+        __set_bit(RAMROD_CONT, &ramrod_flags);
+        return bnx2x_set_mac_one(bp, NULL, mac_obj, false /* don't care */,
+                                 BNX2X_UC_LIST_MAC, &ramrod_flags);
 }
 
-void bnx2x_invalidate_uc_list(struct bnx2x *bp)
+static inline int bnx2x_set_mc_list(struct bnx2x *bp)
 {
-        int i;
-        struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, uc_mac_config);
-        dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, uc_mac_config);
-        int ramrod_flags = WAIT_RAMROD_COMMON;
-        u8 offset = bnx2x_uc_list_cam_offset(bp);
-        u8 max_list_size = bnx2x_max_uc_list(bp);
-
-        for (i = 0; i < max_list_size; i++) {
-                SET_FLAG(config_cmd->config_table[i].flags,
-                        MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
-                        T_ETH_MAC_COMMAND_INVALIDATE);
-                bnx2x_set_mac_in_nig(bp, 0, NULL, LLH_CAM_ETH_LINE + 1 + i);
-        }
-
-        wmb();
+        struct net_device *dev = bp->dev;
+        struct bnx2x_mcast_ramrod_params rparam = {0};
+        int rc = 0;
 
-        config_cmd->hdr.length = max_list_size;
-        config_cmd->hdr.offset = offset;
-        config_cmd->hdr.client_id = 0xff;
-        /* We'll wait for a completion this time... */
-        config_cmd->hdr.echo = 1;
+        rparam.mcast_obj = &bp->mcast_obj;
 
-        bp->set_mac_pending = 1;
+        /* first, clear all configured multicast MACs */
+        rc = bnx2x_config_mcast(bp, &rparam, BNX2X_MCAST_CMD_DEL);
+        if (rc < 0) {
+                BNX2X_ERR("Failed to clear multicast "
+                          "configuration: %d\n", rc);
+                return rc;
+        }
 
-        mb();
+        /* then, configure a new MACs list */
+        if (netdev_mc_count(dev)) {
+                rc = bnx2x_init_mcast_macs_list(bp, &rparam);
+                if (rc) {
+                        BNX2X_ERR("Failed to create multicast MACs "
+                                  "list: %d\n", rc);
+                        return rc;
+                }
 
-        bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
-                      U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
+                /* Now add the new MACs */
+                rc = bnx2x_config_mcast(bp, &rparam,
+                                        BNX2X_MCAST_CMD_ADD);
+                if (rc < 0)
+                        BNX2X_ERR("Failed to set a new multicast "
+                                  "configuration: %d\n", rc);
 
-        /* Wait for a completion */
-        bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending,
-                                ramrod_flags);
+                bnx2x_free_mcast_macs_list(&rparam);
+        }
 
+        return rc;
 }
 
-static inline int bnx2x_set_mc_list(struct bnx2x *bp)
-{
-        /* some multicasts */
-        if (CHIP_IS_E1(bp)) {
-                return bnx2x_set_e1_mc_list(bp);
-        } else { /* E1H and newer */
-                return bnx2x_set_e1h_mc_list(bp);
-        }
-}
 
-/* called with netif_tx_lock from dev_mcast.c */
+/* If bp->state is OPEN, should be called with netif_addr_lock_bh() */
 void bnx2x_set_rx_mode(struct net_device *dev)
 {
         struct bnx2x *bp = netdev_priv(dev);
@@ -8151,23 +9048,31 @@ void bnx2x_set_rx_mode(struct net_device *dev)
                 return;
         }
 
-        DP(NETIF_MSG_IFUP, "dev->flags = %x\n", dev->flags);
+        DP(NETIF_MSG_IFUP, "dev->flags = %x\n", bp->dev->flags);
 
         if (dev->flags & IFF_PROMISC)
                 rx_mode = BNX2X_RX_MODE_PROMISC;
-        else if (dev->flags & IFF_ALLMULTI)
+        else if ((dev->flags & IFF_ALLMULTI) ||
+                 ((netdev_mc_count(dev) > BNX2X_MAX_MULTICAST) &&
+                  CHIP_IS_E1(bp)))
                 rx_mode = BNX2X_RX_MODE_ALLMULTI;
         else {
                 /* some multicasts */
-                if (bnx2x_set_mc_list(bp))
+                if (bnx2x_set_mc_list(bp) < 0)
                         rx_mode = BNX2X_RX_MODE_ALLMULTI;
 
-                /* some unicasts */
-                if (bnx2x_set_uc_list(bp))
+                if (bnx2x_set_uc_list(bp) < 0)
                         rx_mode = BNX2X_RX_MODE_PROMISC;
         }
 
         bp->rx_mode = rx_mode;
+
+        /* Schedule the rx_mode command */
+        if (test_bit(BNX2X_FILTER_RX_MODE_PENDING, &bp->sp_state)) {
+                set_bit(BNX2X_FILTER_RX_MODE_SCHED, &bp->sp_state);
+                return;
+        }
+
         bnx2x_set_storm_rx_mode(bp);
 }
 
@@ -8258,8 +9163,28 @@ static const struct net_device_ops bnx2x_netdev_ops = {
 #endif
 };
 
+static inline int bnx2x_set_coherency_mask(struct bnx2x *bp)
+{
+        struct device *dev = &bp->pdev->dev;
+
+        if (dma_set_mask(dev, DMA_BIT_MASK(64)) == 0) {
+                bp->flags |= USING_DAC_FLAG;
+                if (dma_set_coherent_mask(dev, DMA_BIT_MASK(64)) != 0) {
+                        dev_err(dev, "dma_set_coherent_mask failed, "
+                                     "aborting\n");
+                        return -EIO;
+                }
+        } else if (dma_set_mask(dev, DMA_BIT_MASK(32)) != 0) {
+                dev_err(dev, "System does not support DMA, aborting\n");
+                return -EIO;
+        }
+
+        return 0;
+}
+
 static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
-                                    struct net_device *dev)
+                                    struct net_device *dev,
+                                    unsigned long board_type)
 {
         struct bnx2x *bp;
         int rc;
@@ -8321,21 +9246,9 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
                 goto err_out_release;
         }
 
-        if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)) == 0) {
-                bp->flags |= USING_DAC_FLAG;
-                if (dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64)) != 0) {
-                        dev_err(&bp->pdev->dev, "dma_set_coherent_mask"
-                               " failed, aborting\n");
-                        rc = -EIO;
-                        goto err_out_release;
-                }
-
-        } else if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)) != 0) {
-                dev_err(&bp->pdev->dev,
-                        "System does not support DMA, aborting\n");
-                rc = -EIO;
+        rc = bnx2x_set_coherency_mask(bp);
+        if (rc)
                 goto err_out_release;
-        }
 
         dev->mem_start = pci_resource_start(pdev, 0);
         dev->base_addr = dev->mem_start;
@@ -8371,6 +9284,12 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
         REG_WR(bp, PXP2_REG_PGL_ADDR_90_F0 + BP_PORT(bp)*16, 0);
         REG_WR(bp, PXP2_REG_PGL_ADDR_94_F0 + BP_PORT(bp)*16, 0);
 
+        /**
+         * Enable internal target-read (in case we are probed after PF FLR).
+         * Must be done prior to any BAR read access
+         */
+        REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_TARGET_READ, 1);
+
         /* Reset the load counter */
         bnx2x_clear_load_cnt(bp);
 
@@ -8585,7 +9504,7 @@ int bnx2x_init_firmware(struct bnx2x *bp)
                 fw_file_name = FW_FILE_NAME_E1;
         else if (CHIP_IS_E1H(bp))
                 fw_file_name = FW_FILE_NAME_E1H;
-        else if (CHIP_IS_E2(bp))
+        else if (!CHIP_IS_E1x(bp))
                 fw_file_name = FW_FILE_NAME_E2;
         else {
                 BNX2X_ERR("Unsupported chip revision\n");
@@ -8653,6 +9572,44 @@ request_firmware_exit:
         return rc;
 }
 
+static void bnx2x_release_firmware(struct bnx2x *bp)
+{
+        kfree(bp->init_ops_offsets);
+        kfree(bp->init_ops);
+        kfree(bp->init_data);
+        release_firmware(bp->firmware);
+}
+
+
+static struct bnx2x_func_sp_drv_ops bnx2x_func_sp_drv = {
+        .init_hw_cmn_chip = bnx2x_init_hw_common_chip,
+        .init_hw_cmn      = bnx2x_init_hw_common,
+        .init_hw_port     = bnx2x_init_hw_port,
+        .init_hw_func     = bnx2x_init_hw_func,
+
+        .reset_hw_cmn     = bnx2x_reset_common,
+        .reset_hw_port    = bnx2x_reset_port,
+        .reset_hw_func    = bnx2x_reset_func,
+
+        .gunzip_init      = bnx2x_gunzip_init,
+        .gunzip_end       = bnx2x_gunzip_end,
+
+        .init_fw          = bnx2x_init_firmware,
+        .release_fw       = bnx2x_release_firmware,
+};
+
+void bnx2x__init_func_obj(struct bnx2x *bp)
+{
+        /* Prepare DMAE related driver resources */
+        bnx2x_setup_dmae(bp);
+
+        bnx2x_init_func_obj(bp, &bp->func_obj,
+                            bnx2x_sp(bp, func_rdata),
+                            bnx2x_sp_mapping(bp, func_rdata),
+                            &bnx2x_func_sp_drv);
+}
+
+/* must be called after sriov-enable */
 static inline int bnx2x_set_qm_cid_count(struct bnx2x *bp, int l2_cid_count)
 {
         int cid_count = L2_FP_COUNT(l2_cid_count);
@@ -8663,6 +9620,25 @@ static inline int bnx2x_set_qm_cid_count(struct bnx2x *bp, int l2_cid_count)
         return roundup(cid_count, QM_CID_ROUND);
 }
 
+/**
+ * bnx2x_pci_msix_table_size - get the size of the MSI-X table.
+ *
+ * @dev:        pci device
+ *
+ */
+static inline int bnx2x_pci_msix_table_size(struct pci_dev *pdev)
+{
+        int pos;
+        u16 control;
+
+        pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
+        if (!pos)
+                return 0;
+
+        pci_read_config_word(pdev, pos  + PCI_MSI_FLAGS, &control);
+        return (control & PCI_MSIX_FLAGS_QSIZE) + 1;
+}
+
 static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                                     const struct pci_device_id *ent)
 {
@@ -8675,12 +9651,28 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
         case BCM57710:
         case BCM57711:
         case BCM57711E:
-                cid_count = FP_SB_MAX_E1x;
-                break;
-
         case BCM57712:
-        case BCM57712E:
-                cid_count = FP_SB_MAX_E2;
+        case BCM57712_MF:
+        case BCM57800:
+        case BCM57800_MF:
+        case BCM57810:
+        case BCM57810_MF:
+        case BCM57840:
+        case BCM57840_MF:
+                /* The size requested for the MSI-X table corresponds to the
+                 * actual amount of avaliable IGU/HC status blocks. It includes
+                 * the default SB vector but we want cid_count to contain the
+                 * amount of only non-default SBs, that's what '-1' stands for.
+                 */
+                cid_count = bnx2x_pci_msix_table_size(pdev) - 1;
+
+                /* do not allow initial cid_count grow above 16
+                 * since Special CIDs starts from this number
+                 * use old FP_SB_MAX_E1x define for this matter
+                 */
+                cid_count = min_t(int, FP_SB_MAX_E1x, cid_count);
+
+                WARN_ON(!cid_count);
                 break;
 
         default:
@@ -8689,7 +9681,7 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                 return -ENODEV;
         }
 
-        cid_count += NONE_ETH_CONTEXT_USE + CNIC_CONTEXT_USE;
+        cid_count += FCOE_CONTEXT_USE;
 
         /* dev zeroed in init_etherdev */
         dev = alloc_etherdev_mq(sizeof(*bp), cid_count);
@@ -8698,6 +9690,11 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                 return -ENOMEM;
         }
 
+        /* We don't need a Tx queue for a CNIC and an OOO Rx-only ring,
+         * so update a cid_count after a netdev allocation.
+         */
+        cid_count += CNIC_CONTEXT_USE;
+
         bp = netdev_priv(dev);
         bp->msg_enable = debug;
 
@@ -8705,12 +9702,14 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
 
         bp->l2_cid_count = cid_count;
 
-        rc = bnx2x_init_dev(pdev, dev);
+        rc = bnx2x_init_dev(pdev, dev, ent->driver_data);
         if (rc < 0) {
                 free_netdev(dev);
                 return rc;
         }
 
+        BNX2X_DEV_INFO("cid_count=%d\n", cid_count);
+
         rc = bnx2x_init_bp(bp);
         if (rc)
                 goto init_one_exit;
@@ -8847,12 +9846,17 @@ static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
 
         bp->rx_mode = BNX2X_RX_MODE_NONE;
 
+#ifdef BCM_CNIC
+        bnx2x_cnic_notify(bp, CNIC_CTL_STOP_CMD);
+#endif
+        /* Stop Tx */
+        bnx2x_tx_disable(bp);
+
         bnx2x_netif_stop(bp, 0);
-        netif_carrier_off(bp->dev);
 
         del_timer_sync(&bp->timer);
-        bp->stats_state = STATS_STATE_DISABLED;
-        DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
+
+        bnx2x_stats_handle(bp, STATS_EVENT_STOP);
 
         /* Release IRQs */
         bnx2x_free_irq(bp);
@@ -8867,6 +9871,8 @@ static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
 
         bp->state = BNX2X_STATE_CLOSED;
 
+        netif_carrier_off(bp->dev);
+
         return 0;
 }
 
@@ -9043,6 +10049,24 @@ module_init(bnx2x_init);
 module_exit(bnx2x_cleanup);
 
 #ifdef BCM_CNIC
+/**
+ * bnx2x_set_iscsi_eth_mac_addr - set iSCSI MAC(s).
+ *
+ * @bp:         driver handle
+ * @set:        set or clear the CAM entry
+ *
+ * This function will wait until the ramdord completion returns.
+ * Return 0 if success, -ENODEV if ramrod doesn't return.
+ */
+static inline int bnx2x_set_iscsi_eth_mac_addr(struct bnx2x *bp)
+{
+        unsigned long ramrod_flags = 0;
+
+        __set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
+        return bnx2x_set_mac_one(bp, bp->cnic_eth_dev.iscsi_mac,
+                                 &bp->iscsi_l2_mac_obj, true,
+                                 BNX2X_ISCSI_ETH_MAC, &ramrod_flags);
+}
 
 /* count denotes the number of new completions we have seen */
 static void bnx2x_cnic_sp_post(struct bnx2x *bp, int count)
@@ -9063,23 +10087,22 @@ static void bnx2x_cnic_sp_post(struct bnx2x *bp, int count)
                 u16 type =  (le16_to_cpu(bp->cnic_kwq_cons->hdr.type)
                                 & SPE_HDR_CONN_TYPE) >>
                                 SPE_HDR_CONN_TYPE_SHIFT;
+                u8 cmd = (le32_to_cpu(bp->cnic_kwq_cons->hdr.conn_and_cmd_data)
+                                >> SPE_HDR_CMD_ID_SHIFT) & 0xff;
 
                 /* Set validation for iSCSI L2 client before sending SETUP
                  *  ramrod
                  */
                 if (type == ETH_CONNECTION_TYPE) {
-                        u8 cmd = (le32_to_cpu(bp->cnic_kwq_cons->
-                                             hdr.conn_and_cmd_data) >>
-                                SPE_HDR_CMD_ID_SHIFT) & 0xff;
-
                         if (cmd == RAMROD_CMD_ID_ETH_CLIENT_SETUP)
-                                bnx2x_set_ctx_validation(&bp->context.
-                                                vcxt[BNX2X_ISCSI_ETH_CID].eth,
-                                        HW_CID(bp, BNX2X_ISCSI_ETH_CID));
+                                bnx2x_set_ctx_validation(bp, &bp->context.
+                                        vcxt[BNX2X_ISCSI_ETH_CID].eth,
+                                        BNX2X_ISCSI_ETH_CID);
                 }
 
-                /* There may be not more than 8 L2 and not more than 8 L5 SPEs
-                 * We also check that the number of outstanding
+                /*
+                 * There may be not more than 8 L2, not more than 8 L5 SPEs
+                 * and in the air. We also check that number of outstanding
                  * COMMON ramrods is not more than the EQ and SPQ can
                  * accommodate.
                  */
@@ -9205,18 +10228,61 @@ int bnx2x_cnic_notify(struct bnx2x *bp, int cmd)
         return bnx2x_cnic_ctl_send(bp, &ctl);
 }
 
-static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid)
+static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid, u8 err)
 {
-        struct cnic_ctl_info ctl;
+        struct cnic_ctl_info ctl = {0};
 
         /* first we tell CNIC and only then we count this as a completion */
         ctl.cmd = CNIC_CTL_COMPLETION_CMD;
         ctl.data.comp.cid = cid;
+        ctl.data.comp.error = err;
 
         bnx2x_cnic_ctl_send_bh(bp, &ctl);
         bnx2x_cnic_sp_post(bp, 0);
 }
 
+
+/* Called with netif_addr_lock_bh() taken.
+ * Sets an rx_mode config for an iSCSI ETH client.
+ * Doesn't block.
+ * Completion should be checked outside.
+ */
+static void bnx2x_set_iscsi_eth_rx_mode(struct bnx2x *bp, bool start)
+{
+        unsigned long accept_flags = 0, ramrod_flags = 0;
+        u8 cl_id = bnx2x_cnic_eth_cl_id(bp, BNX2X_ISCSI_ETH_CL_ID_IDX);
+        int sched_state = BNX2X_FILTER_ISCSI_ETH_STOP_SCHED;
+
+        if (start) {
+                /* Start accepting on iSCSI L2 ring. Accept all multicasts
+                 * because it's the only way for UIO Queue to accept
+                 * multicasts (in non-promiscuous mode only one Queue per
+                 * function will receive multicast packets (leading in our
+                 * case).
+                 */
+                __set_bit(BNX2X_ACCEPT_UNICAST, &accept_flags);
+                __set_bit(BNX2X_ACCEPT_ALL_MULTICAST, &accept_flags);
+                __set_bit(BNX2X_ACCEPT_BROADCAST, &accept_flags);
+                __set_bit(BNX2X_ACCEPT_ANY_VLAN, &accept_flags);
+
+                /* Clear STOP_PENDING bit if START is requested */
+                clear_bit(BNX2X_FILTER_ISCSI_ETH_STOP_SCHED, &bp->sp_state);
+
+                sched_state = BNX2X_FILTER_ISCSI_ETH_START_SCHED;
+        } else
+                /* Clear START_PENDING bit if STOP is requested */
+                clear_bit(BNX2X_FILTER_ISCSI_ETH_START_SCHED, &bp->sp_state);
+
+        if (test_bit(BNX2X_FILTER_RX_MODE_PENDING, &bp->sp_state))
+                set_bit(sched_state, &bp->sp_state);
+        else {
+                __set_bit(RAMROD_RX, &ramrod_flags);
+                bnx2x_set_q_rx_mode(bp, cl_id, 0, accept_flags, 0,
+                                    ramrod_flags);
+        }
+}
+
+
 static int bnx2x_drv_ctl(struct net_device *dev, struct drv_ctl_info *ctl)
 {
         struct bnx2x *bp = netdev_priv(dev);
@@ -9240,45 +10306,65 @@ static int bnx2x_drv_ctl(struct net_device *dev, struct drv_ctl_info *ctl)
 
         /* rtnl_lock is held.  */
         case DRV_CTL_START_L2_CMD: {
-                u32 cli = ctl->data.ring.client_id;
-
-                /* Clear FCoE FIP and ALL ENODE MACs addresses first */
-                bnx2x_del_fcoe_eth_macs(bp);
+                struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
+                unsigned long sp_bits = 0;
+
+                /* Configure the iSCSI classification object */
+                bnx2x_init_mac_obj(bp, &bp->iscsi_l2_mac_obj,
+                                   cp->iscsi_l2_client_id,
+                                   cp->iscsi_l2_cid, BP_FUNC(bp),
+                                   bnx2x_sp(bp, mac_rdata),
+                                   bnx2x_sp_mapping(bp, mac_rdata),
+                                   BNX2X_FILTER_MAC_PENDING,
+                                   &bp->sp_state, BNX2X_OBJ_TYPE_RX,
+                                   &bp->macs_pool);
 
                 /* Set iSCSI MAC address */
-                bnx2x_set_iscsi_eth_mac_addr(bp, 1);
+                rc = bnx2x_set_iscsi_eth_mac_addr(bp);
+                if (rc)
+                        break;
 
                 mmiowb();
                 barrier();
 
-                /* Start accepting on iSCSI L2 ring. Accept all multicasts
-                 * because it's the only way for UIO Client to accept
-                 * multicasts (in non-promiscuous mode only one Client per
-                 * function will receive multicast packets (leading in our
-                 * case).
-                 */
-                bnx2x_rxq_set_mac_filters(bp, cli,
-                        BNX2X_ACCEPT_UNICAST |
-                        BNX2X_ACCEPT_BROADCAST |
-                        BNX2X_ACCEPT_ALL_MULTICAST);
-                storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
+                /* Start accepting on iSCSI L2 ring */
+
+                netif_addr_lock_bh(dev);
+                bnx2x_set_iscsi_eth_rx_mode(bp, true);
+                netif_addr_unlock_bh(dev);
+
+                /* bits to wait on */
+                __set_bit(BNX2X_FILTER_RX_MODE_PENDING, &sp_bits);
+                __set_bit(BNX2X_FILTER_ISCSI_ETH_START_SCHED, &sp_bits);
+
+                if (!bnx2x_wait_sp_comp(bp, sp_bits))
+                        BNX2X_ERR("rx_mode completion timed out!\n");
 
                 break;
         }
 
         /* rtnl_lock is held.  */
         case DRV_CTL_STOP_L2_CMD: {
-                u32 cli = ctl->data.ring.client_id;
+                unsigned long sp_bits = 0;
 
                 /* Stop accepting on iSCSI L2 ring */
-                bnx2x_rxq_set_mac_filters(bp, cli, BNX2X_ACCEPT_NONE);
-                storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
+                netif_addr_lock_bh(dev);
+                bnx2x_set_iscsi_eth_rx_mode(bp, false);
+                netif_addr_unlock_bh(dev);
+
+                /* bits to wait on */
+                __set_bit(BNX2X_FILTER_RX_MODE_PENDING, &sp_bits);
+                __set_bit(BNX2X_FILTER_ISCSI_ETH_STOP_SCHED, &sp_bits);
+
+                if (!bnx2x_wait_sp_comp(bp, sp_bits))
+                        BNX2X_ERR("rx_mode completion timed out!\n");
 
                 mmiowb();
                 barrier();
 
                 /* Unset iSCSI L2 MAC */
-                bnx2x_set_iscsi_eth_mac_addr(bp, 0);
+                rc = bnx2x_del_all_macs(bp, &bp->iscsi_l2_mac_obj,
+                                        BNX2X_ISCSI_ETH_MAC, true);
                 break;
         }
         case DRV_CTL_RET_L2_SPQ_CREDIT_CMD: {
@@ -9290,11 +10376,6 @@ static int bnx2x_drv_ctl(struct net_device *dev, struct drv_ctl_info *ctl)
                 break;
         }
 
-        case DRV_CTL_ISCSI_STOPPED_CMD: {
-                bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_ISCSI_STOPPED);
-                break;
-        }
-
         default:
                 BNX2X_ERR("unknown command %x\n", ctl->cmd);
                 rc = -EINVAL;
@@ -9315,13 +10396,13 @@ void bnx2x_setup_cnic_irq_info(struct bnx2x *bp)
                 cp->drv_state &= ~CNIC_DRV_STATE_USING_MSIX;
                 cp->irq_arr[0].irq_flags &= ~CNIC_IRQ_FL_MSIX;
         }
-        if (CHIP_IS_E2(bp))
+        if (!CHIP_IS_E1x(bp))
                 cp->irq_arr[0].status_blk = (void *)bp->cnic_sb.e2_sb;
         else
                 cp->irq_arr[0].status_blk = (void *)bp->cnic_sb.e1x_sb;
 
-        cp->irq_arr[0].status_blk_num = CNIC_SB_ID(bp);
-        cp->irq_arr[0].status_blk_num2 = CNIC_IGU_SB_ID(bp);
+        cp->irq_arr[0].status_blk_num =  bnx2x_cnic_fw_sb_id(bp);
+        cp->irq_arr[0].status_blk_num2 = bnx2x_cnic_igu_sb_id(bp);
         cp->irq_arr[1].status_blk = bp->def_status_blk;
         cp->irq_arr[1].status_blk_num = DEF_SB_ID;
         cp->irq_arr[1].status_blk_num2 = DEF_SB_IGU_ID;
@@ -9352,7 +10433,7 @@ static int bnx2x_register_cnic(struct net_device *dev, struct cnic_ops *ops,
         bp->cnic_data = data;
 
         cp->num_irq = 0;
-        cp->drv_state = CNIC_DRV_STATE_REGD;
+        cp->drv_state |= CNIC_DRV_STATE_REGD;
         cp->iro_arr = bp->iro_arr;
 
         bnx2x_setup_cnic_irq_info(bp);
@@ -9406,8 +10487,8 @@ struct cnic_eth_dev *bnx2x_cnic_probe(struct net_device *dev)
         cp->drv_register_cnic = bnx2x_register_cnic;
         cp->drv_unregister_cnic = bnx2x_unregister_cnic;
         cp->fcoe_init_cid = BNX2X_FCOE_ETH_CID;
-        cp->iscsi_l2_client_id = BNX2X_ISCSI_ETH_CL_ID +
-                BP_E1HVN(bp) * NONE_ETH_CONTEXT_USE;
+        cp->iscsi_l2_client_id =
+                bnx2x_cnic_eth_cl_id(bp, BNX2X_ISCSI_ETH_CL_ID_IDX);
         cp->iscsi_l2_cid = BNX2X_ISCSI_ETH_CID;
 
         if (NO_ISCSI_OOO(bp))
diff --git a/drivers/net/bnx2x/bnx2x_reg.h b/drivers/net/bnx2x/bnx2x_reg.h
index 18ac2ab08f3d..9868cb0270a4 100644
--- a/drivers/net/bnx2x/bnx2x_reg.h
+++ b/drivers/net/bnx2x/bnx2x_reg.h
@@ -422,6 +422,7 @@
 #define CFC_REG_NUM_LCIDS_ALLOC                                  0x104020
 /* [R 9] Number of Arriving LCIDs in Link List Block */
 #define CFC_REG_NUM_LCIDS_ARRIVING                               0x104004
+#define CFC_REG_NUM_LCIDS_INSIDE_PF                              0x104120
 /* [R 9] Number of Leaving LCIDs in Link List Block */
 #define CFC_REG_NUM_LCIDS_LEAVING                                0x104018
 #define CFC_REG_WEAK_ENABLE_PF                                   0x104124
@@ -783,6 +784,7 @@
 /* [RW 3] The number of simultaneous outstanding requests to Context Fetch
    Interface. */
 #define DORQ_REG_OUTST_REQ                                       0x17003c
+#define DORQ_REG_PF_USAGE_CNT                                    0x1701d0
 #define DORQ_REG_REGN                                            0x170038
 /* [R 4] Current value of response A counter credit. Initial credit is
    configured through write to ~dorq_registers_rsp_init_crd.rsp_init_crd
@@ -1645,6 +1647,17 @@
 #define NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_NO_VLAN    (0x1<<4)
 #define NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_UNCST      (0x1<<2)
 #define NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_VLAN       (0x1<<3)
+/* [RW 5] MDIO PHY Address. The WC uses this address to determine whether or
+ * not it is the recipient of the message on the MDIO interface. The value
+ * is compared to the value on ctrl_md_devad. Drives output
+ * misc_xgxs0_phy_addr. Global register. */
+#define MISC_REG_WC0_CTRL_PHY_ADDR                               0xa9cc
+/* [RW 32] 1 [47] Packet Size = 64 Write to this register write bits 31:0.
+ * Reads from this register will clear bits 31:0. */
+#define MSTAT_REG_RX_STAT_GR64_LO                                0x200
+/* [RW 32] 1 [00] Tx Good Packet Count Write to this register write bits
+ * 31:0. Reads from this register will clear bits 31:0. */
+#define MSTAT_REG_TX_STAT_GTXPOK_LO                              0
 #define NIG_LLH0_XCM_MASK_REG_LLH0_XCM_MASK_BCN                  (0x1<<0)
 #define NIG_LLH1_XCM_MASK_REG_LLH1_XCM_MASK_BCN                  (0x1<<0)
 #define NIG_MASK_INTERRUPT_PORT0_REG_MASK_EMAC0_MISC_MI_INT      (0x1<<0)
@@ -1838,6 +1851,10 @@
 #define NIG_REG_LLH1_FUNC_MEM                                    0x161c0
 #define NIG_REG_LLH1_FUNC_MEM_ENABLE                             0x16160
 #define NIG_REG_LLH1_FUNC_MEM_SIZE                               16
+/* [RW 1] When this bit is set; the LLH will classify the packet before
+ * sending it to the BRB or calculating WoL on it. This bit controls port 1
+ * only. The legacy llh_multi_function_mode bit controls port 0. */
+#define NIG_REG_LLH1_MF_MODE                                     0x18614
 /* [RW 8] init credit counter for port1 in LLH */
 #define NIG_REG_LLH1_XCM_INIT_CREDIT                             0x10564
 #define NIG_REG_LLH1_XCM_MASK                                    0x10134
@@ -1889,6 +1906,26 @@
  * than one bit may be set; allowing multiple priorities to be mapped to one
  * COS. */
 #define NIG_REG_P0_RX_COS1_PRIORITY_MASK                         0x1805c
+/* [RW 16] Bit-map indicating which SAFC/PFC priorities to map to COS 2. A
+ * priority is mapped to COS 2 when the corresponding mask bit is 1. More
+ * than one bit may be set; allowing multiple priorities to be mapped to one
+ * COS. */
+#define NIG_REG_P0_RX_COS2_PRIORITY_MASK                         0x186b0
+/* [RW 16] Bit-map indicating which SAFC/PFC priorities to map to COS 3. A
+ * priority is mapped to COS 3 when the corresponding mask bit is 1. More
+ * than one bit may be set; allowing multiple priorities to be mapped to one
+ * COS. */
+#define NIG_REG_P0_RX_COS3_PRIORITY_MASK                         0x186b4
+/* [RW 16] Bit-map indicating which SAFC/PFC priorities to map to COS 4. A
+ * priority is mapped to COS 4 when the corresponding mask bit is 1. More
+ * than one bit may be set; allowing multiple priorities to be mapped to one
+ * COS. */
+#define NIG_REG_P0_RX_COS4_PRIORITY_MASK                         0x186b8
+/* [RW 16] Bit-map indicating which SAFC/PFC priorities to map to COS 5. A
+ * priority is mapped to COS 5 when the corresponding mask bit is 1. More
+ * than one bit may be set; allowing multiple priorities to be mapped to one
+ * COS. */
+#define NIG_REG_P0_RX_COS5_PRIORITY_MASK                         0x186bc
 /* [RW 15] Specify which of the credit registers the client is to be mapped
  * to. Bits[2:0] are for client 0; bits [14:12] are for client 4. For
  * clients that are not subject to WFQ credit blocking - their
@@ -1926,6 +1963,9 @@
  * for management at priority 0; debug traffic at priorities 1 and 2; COS0
  * traffic at priority 3; and COS1 traffic at priority 4. */
 #define NIG_REG_P0_TX_ARB_PRIORITY_CLIENT                        0x180e4
+/* [RW 6] Bit-map indicating which L2 hdrs may appear after the basic
+ * Ethernet header. */
+#define NIG_REG_P1_HDRS_AFTER_BASIC                              0x1818c
 #define NIG_REG_P1_LLH_FUNC_MEM2                                 0x184c0
 #define NIG_REG_P1_LLH_FUNC_MEM2_ENABLE                  0x18460
 /* [RW 32] Eight 4-bit configurations for specifying which COS (0-15 for
@@ -1944,6 +1984,11 @@
  * than one bit may be set; allowing multiple priorities to be mapped to one
  * COS. */
 #define NIG_REG_P1_RX_COS1_PRIORITY_MASK                         0x181b0
+/* [RW 16] Bit-map indicating which SAFC/PFC priorities to map to COS 2. A
+ * priority is mapped to COS 2 when the corresponding mask bit is 1. More
+ * than one bit may be set; allowing multiple priorities to be mapped to one
+ * COS. */
+#define NIG_REG_P1_RX_COS2_PRIORITY_MASK                         0x186f8
 /* [RW 1] Pause enable for port0. This register may get 1 only when
    ~safc_enable.safc_enable = 0 and ppp_enable.ppp_enable =0 for the same
    port */
@@ -2033,6 +2078,15 @@
 #define PBF_REG_COS1_UPPER_BOUND                                 0x15c060
 /* [RW 31] The weight of COS1 in the ETS command arbiter. */
 #define PBF_REG_COS1_WEIGHT                                      0x15c058
+/* [R 11] Current credit for the LB queue in the tx port buffers in 16 byte
+ * lines. */
+#define PBF_REG_CREDIT_LB_Q                                      0x140338
+/* [R 11] Current credit for queue 0 in the tx port buffers in 16 byte
+ * lines. */
+#define PBF_REG_CREDIT_Q0                                        0x14033c
+/* [R 11] Current credit for queue 1 in the tx port buffers in 16 byte
+ * lines. */
+#define PBF_REG_CREDIT_Q1                                        0x140340
 /* [RW 1] Disable processing further tasks from port 0 (after ending the
    current task in process). */
 #define PBF_REG_DISABLE_NEW_TASK_PROC_P0                         0x14005c
@@ -2050,14 +2104,25 @@
 /* [RW 6] Bit-map indicating which L2 hdrs may appear after the basic
  * Ethernet header. */
 #define PBF_REG_HDRS_AFTER_BASIC                                 0x15c0a8
-/* [RW 1] Indicates which COS is conncted to the highest priority in the
- * command arbiter. */
+/* [RW 6] Bit-map indicating which L2 hdrs may appear after L2 tag 0 */
+#define PBF_REG_HDRS_AFTER_TAG_0                                 0x15c0b8
+/* [R 1] Removed for E3 B0 - Indicates which COS is conncted to the highest
+ * priority in the command arbiter. */
 #define PBF_REG_HIGH_PRIORITY_COS_NUM                            0x15c04c
 #define PBF_REG_IF_ENABLE_REG                                    0x140044
 /* [RW 1] Init bit. When set the initial credits are copied to the credit
    registers (except the port credits). Should be set and then reset after
    the configuration of the block has ended. */
 #define PBF_REG_INIT                                             0x140000
+/* [RW 11] Initial credit for the LB queue in the tx port buffers in 16 byte
+ * lines. */
+#define PBF_REG_INIT_CRD_LB_Q                                    0x15c248
+/* [RW 11] Initial credit for queue 0 in the tx port buffers in 16 byte
+ * lines. */
+#define PBF_REG_INIT_CRD_Q0                                      0x15c230
+/* [RW 11] Initial credit for queue 1 in the tx port buffers in 16 byte
+ * lines. */
+#define PBF_REG_INIT_CRD_Q1                                      0x15c234
 /* [RW 1] Init bit for port 0. When set the initial credit of port 0 is
    copied to the credit register. Should be set and then reset after the
    configuration of the port has ended. */
@@ -2070,6 +2135,15 @@
    copied to the credit register. Should be set and then reset after the
    configuration of the port has ended. */
 #define PBF_REG_INIT_P4                                          0x14000c
+/* [R 32] Cyclic counter for the amount credits in 16 bytes lines added for
+ * the LB queue. Reset upon init. */
+#define PBF_REG_INTERNAL_CRD_FREED_CNT_LB_Q                      0x140354
+/* [R 32] Cyclic counter for the amount credits in 16 bytes lines added for
+ * queue 0. Reset upon init. */
+#define PBF_REG_INTERNAL_CRD_FREED_CNT_Q0                        0x140358
+/* [R 32] Cyclic counter for the amount credits in 16 bytes lines added for
+ * queue 1. Reset upon init. */
+#define PBF_REG_INTERNAL_CRD_FREED_CNT_Q1                        0x14035c
 /* [RW 1] Enable for mac interface 0. */
 #define PBF_REG_MAC_IF0_ENABLE                                   0x140030
 /* [RW 1] Enable for mac interface 1. */
@@ -2090,24 +2164,49 @@
 /* [RW 11] Initial credit for port 0 in the tx port buffers in 16 byte
    lines. */
 #define PBF_REG_P0_INIT_CRD                                      0x1400d0
-/* [RW 1] Indication that pause is enabled for port 0. */
-#define PBF_REG_P0_PAUSE_ENABLE                                  0x140014
-/* [R 8] Number of tasks in port 0 task queue. */
+/* [R 32] Cyclic counter for the amount credits in 16 bytes lines added for
+ * port 0. Reset upon init. */
+#define PBF_REG_P0_INTERNAL_CRD_FREED_CNT                        0x140308
+/* [R 1] Removed for E3 B0 - Indication that pause is enabled for port 0. */
+#define PBF_REG_P0_PAUSE_ENABLE                                  0x140014
+/* [R 8] Removed for E3 B0 - Number of tasks in port 0 task queue. */
 #define PBF_REG_P0_TASK_CNT                                      0x140204
-/* [R 11] Current credit for port 1 in the tx port buffers in 16 byte lines. */
+/* [R 32] Removed for E3 B0 - Cyclic counter for number of 8 byte lines
+ * freed from the task queue of port 0. Reset upon init. */
+#define PBF_REG_P0_TQ_LINES_FREED_CNT                            0x1402f0
+/* [R 12] Number of 8 bytes lines occupied in the task queue of port 0. */
+#define PBF_REG_P0_TQ_OCCUPANCY                                  0x1402fc
+/* [R 11] Removed for E3 B0 - Current credit for port 1 in the tx port
+ * buffers in 16 byte lines. */
 #define PBF_REG_P1_CREDIT                                        0x140208
-/* [RW 11] Initial credit for port 1 in the tx port buffers in 16 byte
-   lines. */
+/* [R 11] Removed for E3 B0 - Initial credit for port 0 in the tx port
+ * buffers in 16 byte lines. */
 #define PBF_REG_P1_INIT_CRD                                      0x1400d4
-/* [R 8] Number of tasks in port 1 task queue. */
+/* [R 32] Cyclic counter for the amount credits in 16 bytes lines added for
+ * port 1. Reset upon init. */
+#define PBF_REG_P1_INTERNAL_CRD_FREED_CNT                        0x14030c
+/* [R 8] Removed for E3 B0 - Number of tasks in port 1 task queue. */
 #define PBF_REG_P1_TASK_CNT                                      0x14020c
+/* [R 32] Removed for E3 B0 - Cyclic counter for number of 8 byte lines
+ * freed from the task queue of port 1. Reset upon init. */
+#define PBF_REG_P1_TQ_LINES_FREED_CNT                            0x1402f4
+/* [R 12] Number of 8 bytes lines occupied in the task queue of port 1. */
+#define PBF_REG_P1_TQ_OCCUPANCY                                  0x140300
 /* [R 11] Current credit for port 4 in the tx port buffers in 16 byte lines. */
 #define PBF_REG_P4_CREDIT                                        0x140210
 /* [RW 11] Initial credit for port 4 in the tx port buffers in 16 byte
    lines. */
 #define PBF_REG_P4_INIT_CRD                                      0x1400e0
-/* [R 8] Number of tasks in port 4 task queue. */
+/* [R 32] Cyclic counter for the amount credits in 16 bytes lines added for
+ * port 4. Reset upon init. */
+#define PBF_REG_P4_INTERNAL_CRD_FREED_CNT                        0x140310
+/* [R 8] Removed for E3 B0 - Number of tasks in port 4 task queue. */
 #define PBF_REG_P4_TASK_CNT                                      0x140214
+/* [R 32] Removed for E3 B0 - Cyclic counter for number of 8 byte lines
+ * freed from the task queue of port 4. Reset upon init. */
+#define PBF_REG_P4_TQ_LINES_FREED_CNT                            0x1402f8
+/* [R 12] Number of 8 bytes lines occupied in the task queue of port 4. */
+#define PBF_REG_P4_TQ_OCCUPANCY                                  0x140304
 /* [RW 5] Interrupt mask register #0 read/write */
 #define PBF_REG_PBF_INT_MASK                                     0x1401d4
 /* [R 5] Interrupt register #0 read */
@@ -2116,6 +2215,27 @@
 #define PBF_REG_PBF_PRTY_MASK                                    0x1401e4
 /* [RC 20] Parity register #0 read clear */
 #define PBF_REG_PBF_PRTY_STS_CLR                                 0x1401dc
+/* [RW 16] The Ethernet type value for L2 tag 0 */
+#define PBF_REG_TAG_ETHERTYPE_0                                  0x15c090
+/* [RW 4] The length of the info field for L2 tag 0. The length is between
+ * 2B and 14B; in 2B granularity */
+#define PBF_REG_TAG_LEN_0                                        0x15c09c
+/* [R 32] Cyclic counter for number of 8 byte lines freed from the LB task
+ * queue. Reset upon init. */
+#define PBF_REG_TQ_LINES_FREED_CNT_LB_Q                          0x14038c
+/* [R 32] Cyclic counter for number of 8 byte lines freed from the task
+ * queue 0. Reset upon init. */
+#define PBF_REG_TQ_LINES_FREED_CNT_Q0                            0x140390
+/* [R 32] Cyclic counter for number of 8 byte lines freed from task queue 1.
+ * Reset upon init. */
+#define PBF_REG_TQ_LINES_FREED_CNT_Q1                            0x140394
+/* [R 13] Number of 8 bytes lines occupied in the task queue of the LB
+ * queue. */
+#define PBF_REG_TQ_OCCUPANCY_LB_Q                                0x1403a8
+/* [R 13] Number of 8 bytes lines occupied in the task queue of queue 0. */
+#define PBF_REG_TQ_OCCUPANCY_Q0                                  0x1403ac
+/* [R 13] Number of 8 bytes lines occupied in the task queue of queue 1. */
+#define PBF_REG_TQ_OCCUPANCY_Q1                                  0x1403b0
 #define PB_REG_CONTROL                                           0
 /* [RW 2] Interrupt mask register #0 read/write */
 #define PB_REG_PB_INT_MASK                                       0x28
@@ -2445,10 +2565,24 @@
 /* [RW 6] Bit-map indicating which L2 hdrs may appear after the basic
  * Ethernet header. */
 #define PRS_REG_HDRS_AFTER_BASIC                                 0x40238
+/* [RW 6] Bit-map indicating which L2 hdrs may appear after the basic
+ * Ethernet header for port 0 packets. */
+#define PRS_REG_HDRS_AFTER_BASIC_PORT_0                          0x40270
+#define PRS_REG_HDRS_AFTER_BASIC_PORT_1                          0x40290
+/* [R 6] Bit-map indicating which L2 hdrs may appear after L2 tag 0 */
+#define PRS_REG_HDRS_AFTER_TAG_0                                 0x40248
+/* [RW 6] Bit-map indicating which L2 hdrs may appear after L2 tag 0 for
+ * port 0 packets */
+#define PRS_REG_HDRS_AFTER_TAG_0_PORT_0                          0x40280
+#define PRS_REG_HDRS_AFTER_TAG_0_PORT_1                          0x402a0
 /* [RW 4] The increment value to send in the CFC load request message */
 #define PRS_REG_INC_VALUE                                        0x40048
 /* [RW 6] Bit-map indicating which headers must appear in the packet */
 #define PRS_REG_MUST_HAVE_HDRS                                   0x40254
+/* [RW 6] Bit-map indicating which headers must appear in the packet for
+ * port 0 packets */
+#define PRS_REG_MUST_HAVE_HDRS_PORT_0                            0x4028c
+#define PRS_REG_MUST_HAVE_HDRS_PORT_1                            0x402ac
 #define PRS_REG_NIC_MODE                                         0x40138
 /* [RW 8] The 8-bit event ID for cases where there is no match on the
    connection. Used in packet start message to TCM. */
@@ -2497,6 +2631,11 @@
 #define PRS_REG_SERIAL_NUM_STATUS_MSB                            0x40158
 /* [R 4] debug only: SRC current credit. Transaction based. */
 #define PRS_REG_SRC_CURRENT_CREDIT                               0x4016c
+/* [RW 16] The Ethernet type value for L2 tag 0 */
+#define PRS_REG_TAG_ETHERTYPE_0                                  0x401d4
+/* [RW 4] The length of the info field for L2 tag 0. The length is between
+ * 2B and 14B; in 2B granularity */
+#define PRS_REG_TAG_LEN_0                                        0x4022c
 /* [R 8] debug only: TCM current credit. Cycle based. */
 #define PRS_REG_TCM_CURRENT_CREDIT                               0x40160
 /* [R 8] debug only: TSDM current credit. Transaction based. */
@@ -3081,6 +3220,7 @@
 #define QM_REG_BYTECREDITAFULLTHR                                0x168094
 /* [RW 4] The initial credit for interface */
 #define QM_REG_CMINITCRD_0                                       0x1680cc
+#define QM_REG_BYTECRDCMDQ_0                                     0x16e6e8
 #define QM_REG_CMINITCRD_1                                       0x1680d0
 #define QM_REG_CMINITCRD_2                                       0x1680d4
 #define QM_REG_CMINITCRD_3                                       0x1680d8
@@ -3171,7 +3311,10 @@
 /* [RW 2] The PCI attributes field used in the PCI request. */
 #define QM_REG_PCIREQAT                                          0x168054
 #define QM_REG_PF_EN                                             0x16e70c
-/* [R 16] The byte credit of port 0 */
+/* [R 24] The number of tasks stored in the QM for the PF. only even
+ * functions are valid in E2 (odd I registers will be hard wired to 0) */
+#define QM_REG_PF_USG_CNT_0                                      0x16e040
+/* [R 16] NOT USED */
 #define QM_REG_PORT0BYTECRD                                      0x168300
 /* [R 16] The byte credit of port 1 */
 #define QM_REG_PORT1BYTECRD                                      0x168304
@@ -3783,6 +3926,8 @@
 #define TM_REG_LIN0_LOGIC_ADDR                                   0x164240
 /* [RW 18] Linear0 Max active cid (in banks of 32 entries). */
 #define TM_REG_LIN0_MAX_ACTIVE_CID                               0x164048
+/* [ST 16] Linear0 Number of scans counter. */
+#define TM_REG_LIN0_NUM_SCANS                                    0x1640a0
 /* [WB 64] Linear0 phy address. */
 #define TM_REG_LIN0_PHY_ADDR                                     0x164270
 /* [RW 1] Linear0 physical address valid. */
@@ -3790,6 +3935,7 @@
 #define TM_REG_LIN0_SCAN_ON                                      0x1640d0
 /* [RW 24] Linear0 array scan timeout. */
 #define TM_REG_LIN0_SCAN_TIME                                    0x16403c
+#define TM_REG_LIN0_VNIC_UC                                      0x164128
 /* [RW 32] Linear1 logic address. */
 #define TM_REG_LIN1_LOGIC_ADDR                                   0x164250
 /* [WB 64] Linear1 phy address. */
@@ -4845,8 +4991,10 @@
 #define XSDM_REG_NUM_OF_Q8_CMD                                   0x166264
 /* [ST 32] The number of commands received in queue 9 */
 #define XSDM_REG_NUM_OF_Q9_CMD                                   0x166268
-/* [RW 13] The start address in the internal RAM for queue counters */
-#define XSDM_REG_Q_COUNTER_START_ADDR                            0x166010
+/* [W 17] Generate an operation after completion; bit-16 is
+ * AggVectIdx_valid; bits 15:8 are AggVectIdx; bits 7:5 are the TRIG and
+ * bits 4:0 are the T124Param[4:0] */
+#define XSDM_REG_OPERATION_GEN                                   0x1664c4
 /* [R 1] pxp_ctrl rd_data fifo empty in sdm_dma_rsp block */
 #define XSDM_REG_RSP_PXP_CTRL_RDATA_EMPTY                        0x166548
 /* [R 1] parser fifo empty in sdm_sync block */
@@ -5129,6 +5277,8 @@
 #define MISC_REGISTERS_RESET_REG_1_RST_PXPV                      (0x1<<27)
 #define MISC_REGISTERS_RESET_REG_1_SET                           0x584
 #define MISC_REGISTERS_RESET_REG_2_CLEAR                         0x598
+#define MISC_REGISTERS_RESET_REG_2_MSTAT0                        (0x1<<24)
+#define MISC_REGISTERS_RESET_REG_2_MSTAT1                        (0x1<<25)
 #define MISC_REGISTERS_RESET_REG_2_RST_BMAC0                     (0x1<<0)
 #define MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE           (0x1<<14)
 #define MISC_REGISTERS_RESET_REG_2_RST_EMAC1_HARD_CORE           (0x1<<15)
@@ -5161,6 +5311,7 @@
 #define MISC_REGISTERS_SPIO_OUTPUT_HIGH                          1
 #define MISC_REGISTERS_SPIO_OUTPUT_LOW                           0
 #define MISC_REGISTERS_SPIO_SET_POS                              8
+#define HW_LOCK_DRV_FLAGS                                        10
 #define HW_LOCK_MAX_RESOURCE_VALUE                               31
 #define HW_LOCK_RESOURCE_GPIO                                    1
 #define HW_LOCK_RESOURCE_MDIO                                    0
@@ -5168,7 +5319,6 @@
 #define HW_LOCK_RESOURCE_RESERVED_08                             8
 #define HW_LOCK_RESOURCE_SPIO                                    2
 #define HW_LOCK_RESOURCE_UNDI                                    5
-#define PRS_FLAG_OVERETH_IPV4                                    1
 #define AEU_INPUTS_ATTN_BITS_ATC_HW_INTERRUPT                 (0x1<<4)
 #define AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR                 (0x1<<5)
 #define AEU_INPUTS_ATTN_BITS_BRB_PARITY_ERROR                 (1<<18)
@@ -5320,6 +5470,8 @@
 #define GRCBASE_PXP2            0x120000
 #define GRCBASE_PBF             0x140000
 #define GRCBASE_XPB             0x161000
+#define GRCBASE_MSTAT0      0x162000
+#define GRCBASE_MSTAT1      0x162800
 #define GRCBASE_TIMERS          0x164000
 #define GRCBASE_XSDM            0x166000
 #define GRCBASE_QM              0x168000
@@ -6243,11 +6395,6 @@ Theotherbitsarereservedandshouldbezero*/
 #define IGU_ADDR_MSI_ADDR_HI    0x0212
 #define IGU_ADDR_MSI_DATA               0x0213
 
-#define IGU_INT_ENABLE                  0
-#define IGU_INT_DISABLE                 1
-#define IGU_INT_NOP                             2
-#define IGU_INT_NOP2                    3
-
 #define IGU_USE_REGISTER_ustorm_type_0_sb_cleanup  0
 #define IGU_USE_REGISTER_ustorm_type_1_sb_cleanup  1
 #define IGU_USE_REGISTER_cstorm_type_0_sb_cleanup  2
@@ -6318,15 +6465,6 @@ Theotherbitsarereservedandshouldbezero*/
 #define IGU_BC_BASE_DSB_PROD   128
 #define IGU_NORM_BASE_DSB_PROD 136
 
-#define IGU_CTRL_CMD_TYPE_WR\
-        1
-#define IGU_CTRL_CMD_TYPE_RD\
-        0
-
-#define IGU_SEG_ACCESS_NORM   0
-#define IGU_SEG_ACCESS_DEF    1
-#define IGU_SEG_ACCESS_ATTN   2
-
         /* FID (if VF - [6] = 0; [5:0] = VF number; if PF - [6] = 1; \
         [5:2] = 0; [1:0] = PF number) */
 #define IGU_FID_ENCODE_IS_PF        (0x1<<6)
diff --git a/drivers/net/bnx2x/bnx2x_sp.c b/drivers/net/bnx2x/bnx2x_sp.c
index 7c876a06b779..5bdf09459a08 100644
--- a/drivers/net/bnx2x/bnx2x_sp.c
+++ b/drivers/net/bnx2x/bnx2x_sp.c
@@ -1,3 +1,21 @@
+/* bnx2x_sp.c: Broadcom Everest network driver.
+ *
+ * Copyright 2011 Broadcom Corporation
+ *
+ * Unless you and Broadcom execute a separate written software license
+ * agreement governing use of this software, this software is licensed to you
+ * under the terms of the GNU General Public License version 2, available
+ * at http://www.gnu.org/licenses/old-licenses/gpl-2.0.html (the "GPL").
+ *
+ * Notwithstanding the above, under no circumstances may you combine this
+ * software in any way with any other Broadcom software provided under a
+ * license other than the GPL, without Broadcom's express prior written
+ * consent.
+ *
+ * Maintained by: Eilon Greenstein <eilong@broadcom.com>
+ * Written by: Vladislav Zolotarov
+ *
+ */
 #include <linux/version.h>
 #include <linux/module.h>
 #include <linux/crc32.h>
@@ -8,691 +26,4277 @@
 #include "bnx2x_cmn.h"
 #include "bnx2x_sp.h"
 
+#define BNX2X_MAX_EMUL_MULTI            16
+
+/**** Exe Queue interfaces ****/
 
 /**
- * bnx2x_set_mac_addr_gen - set a MAC in a CAM for a few L2 Clients for E1x chips
+ * bnx2x_exe_queue_init - init the Exe Queue object
+ *
+ * @o:          poiter to the object
+ * @exe_len:    length
+ * @owner:      poiter to the owner
+ * @validate:   validate function pointer
+ * @optimize:   optimize function pointer
+ * @exec:       execute function pointer
+ * @get:        get function pointer
+ */
+static inline void bnx2x_exe_queue_init(struct bnx2x *bp,
+                                        struct bnx2x_exe_queue_obj *o,
+                                        int exe_len,
+                                        union bnx2x_qable_obj *owner,
+                                        exe_q_validate validate,
+                                        exe_q_optimize optimize,
+                                        exe_q_execute exec,
+                                        exe_q_get get)
+{
+        memset(o, 0, sizeof(*o));
+
+        INIT_LIST_HEAD(&o->exe_queue);
+        INIT_LIST_HEAD(&o->pending_comp);
+
+        spin_lock_init(&o->lock);
+
+        o->exe_chunk_len = exe_len;
+        o->owner         = owner;
+
+        /* Owner specific callbacks */
+        o->validate      = validate;
+        o->optimize      = optimize;
+        o->execute       = exec;
+        o->get           = get;
+
+        DP(BNX2X_MSG_SP, "Setup the execution queue with the chunk "
+                         "length of %d\n", exe_len);
+}
+
+static inline void bnx2x_exe_queue_free_elem(struct bnx2x *bp,
+                                             struct bnx2x_exeq_elem *elem)
+{
+        DP(BNX2X_MSG_SP, "Deleting an exe_queue element\n");
+        kfree(elem);
+}
+
+static inline int bnx2x_exe_queue_length(struct bnx2x_exe_queue_obj *o)
+{
+        struct bnx2x_exeq_elem *elem;
+        int cnt = 0;
+
+        spin_lock_bh(&o->lock);
+
+        list_for_each_entry(elem, &o->exe_queue, link)
+                cnt++;
+
+        spin_unlock_bh(&o->lock);
+
+        return cnt;
+}
+
+/**
+ * bnx2x_exe_queue_add - add a new element to the execution queue
  *
  * @bp:         driver handle
- * @set:        set or clear an entry (1 or 0)
- * @mac:        pointer to a buffer containing a MAC
- * @cl_bit_vec: bit vector of clients to register a MAC for
- * @cam_offset: offset in a CAM to use
- * @is_bcast:   is the set MAC a broadcast address (for E1 only)
+ * @o:          queue
+ * @cmd:        new command to add
+ * @restore:    true - do not optimize the command
+ *
+ * If the element is optimized or is illegal, frees it.
  */
-void bnx2x_set_mac_addr_gen(struct bnx2x *bp, int set, const u8 *mac,
-                            u32 cl_bit_vec, u8 cam_offset,
-                            u8 is_bcast)
+static inline int bnx2x_exe_queue_add(struct bnx2x *bp,
+                                      struct bnx2x_exe_queue_obj *o,
+                                      struct bnx2x_exeq_elem *elem,
+                                      bool restore)
 {
-        struct mac_configuration_cmd *config =
-                (struct mac_configuration_cmd *)bnx2x_sp(bp, mac_config);
-        int ramrod_flags = WAIT_RAMROD_COMMON;
-
-        bp->set_mac_pending = 1;
-
-        config->hdr.length = 1;
-        config->hdr.offset = cam_offset;
-        config->hdr.client_id = 0xff;
-        /* Mark the single MAC configuration ramrod as opposed to a
-         * UC/MC list configuration).
-         */
-        config->hdr.echo = 1;
-
-        /* primary MAC */
-        config->config_table[0].msb_mac_addr =
-                                        swab16(*(u16 *)&mac[0]);
-        config->config_table[0].middle_mac_addr =
-                                        swab16(*(u16 *)&mac[2]);
-        config->config_table[0].lsb_mac_addr =
-                                        swab16(*(u16 *)&mac[4]);
-        config->config_table[0].clients_bit_vector =
-                                        cpu_to_le32(cl_bit_vec);
-        config->config_table[0].vlan_id = 0;
-        config->config_table[0].pf_id = BP_FUNC(bp);
-        if (set)
-                SET_FLAG(config->config_table[0].flags,
-                        MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
-                        T_ETH_MAC_COMMAND_SET);
-        else
-                SET_FLAG(config->config_table[0].flags,
-                        MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
-                        T_ETH_MAC_COMMAND_INVALIDATE);
+        int rc;
+
+        spin_lock_bh(&o->lock);
+
+        if (!restore) {
+                /* Try to cancel this element queue */
+                rc = o->optimize(bp, o->owner, elem);
+                if (rc)
+                        goto free_and_exit;
+
+                /* Check if this request is ok */
+                rc = o->validate(bp, o->owner, elem);
+                if (rc) {
+                        BNX2X_ERR("Preamble failed: %d\n", rc);
+                        goto free_and_exit;
+                }
+        }
+
+        /* If so, add it to the execution queue */
+        list_add_tail(&elem->link, &o->exe_queue);
 
-        if (is_bcast)
-                SET_FLAG(config->config_table[0].flags,
-                        MAC_CONFIGURATION_ENTRY_BROADCAST, 1);
+        spin_unlock_bh(&o->lock);
 
-        DP(NETIF_MSG_IFUP, "%s MAC (%04x:%04x:%04x)  PF_ID %d  CLID mask %d\n",
-           (set ? "setting" : "clearing"),
-           config->config_table[0].msb_mac_addr,
-           config->config_table[0].middle_mac_addr,
-           config->config_table[0].lsb_mac_addr, BP_FUNC(bp), cl_bit_vec);
+        return 0;
+
+free_and_exit:
+        bnx2x_exe_queue_free_elem(bp, elem);
+
+        spin_unlock_bh(&o->lock);
+
+        return rc;
+
+}
+
+static inline void __bnx2x_exe_queue_reset_pending(
+        struct bnx2x *bp,
+        struct bnx2x_exe_queue_obj *o)
+{
+        struct bnx2x_exeq_elem *elem;
 
+        while (!list_empty(&o->pending_comp)) {
+                elem = list_first_entry(&o->pending_comp,
+                                        struct bnx2x_exeq_elem, link);
+
+                list_del(&elem->link);
+                bnx2x_exe_queue_free_elem(bp, elem);
+        }
+}
+
+static inline void bnx2x_exe_queue_reset_pending(struct bnx2x *bp,
+                                                 struct bnx2x_exe_queue_obj *o)
+{
+
+        spin_lock_bh(&o->lock);
+
+        __bnx2x_exe_queue_reset_pending(bp, o);
+
+        spin_unlock_bh(&o->lock);
+
+}
+
+/**
+ * bnx2x_exe_queue_step - execute one execution chunk atomically
+ *
+ * @bp:                 driver handle
+ * @o:                  queue
+ * @ramrod_flags:       flags
+ *
+ * (Atomicy is ensured using the exe_queue->lock).
+ */
+static inline int bnx2x_exe_queue_step(struct bnx2x *bp,
+                                       struct bnx2x_exe_queue_obj *o,
+                                       unsigned long *ramrod_flags)
+{
+        struct bnx2x_exeq_elem *elem, spacer;
+        int cur_len = 0, rc;
+
+        memset(&spacer, 0, sizeof(spacer));
+
+        spin_lock_bh(&o->lock);
+
+        /*
+         * Next step should not be performed until the current is finished,
+         * unless a DRV_CLEAR_ONLY bit is set. In this case we just want to
+         * properly clear object internals without sending any command to the FW
+         * which also implies there won't be any completion to clear the
+         * 'pending' list.
+         */
+        if (!list_empty(&o->pending_comp)) {
+                if (test_bit(RAMROD_DRV_CLR_ONLY, ramrod_flags)) {
+                        DP(BNX2X_MSG_SP, "RAMROD_DRV_CLR_ONLY requested: "
+                                         "resetting pending_comp\n");
+                        __bnx2x_exe_queue_reset_pending(bp, o);
+                } else {
+                        spin_unlock_bh(&o->lock);
+                        return 1;
+                }
+        }
+
+        /*
+         * Run through the pending commands list and create a next
+         * execution chunk.
+         */
+        while (!list_empty(&o->exe_queue)) {
+                elem = list_first_entry(&o->exe_queue, struct bnx2x_exeq_elem,
+                                        link);
+                WARN_ON(!elem->cmd_len);
+
+                if (cur_len + elem->cmd_len <= o->exe_chunk_len) {
+                        cur_len += elem->cmd_len;
+                        /*
+                         * Prevent from both lists being empty when moving an
+                         * element. This will allow the call of
+                         * bnx2x_exe_queue_empty() without locking.
+                         */
+                        list_add_tail(&spacer.link, &o->pending_comp);
+                        mb();
+                        list_del(&elem->link);
+                        list_add_tail(&elem->link, &o->pending_comp);
+                        list_del(&spacer.link);
+                } else
+                        break;
+        }
+
+        /* Sanity check */
+        if (!cur_len) {
+                spin_unlock_bh(&o->lock);
+                return 0;
+        }
+
+        rc = o->execute(bp, o->owner, &o->pending_comp, ramrod_flags);
+        if (rc < 0)
+                /*
+                 *  In case of an error return the commands back to the queue
+                 *  and reset the pending_comp.
+                 */
+                list_splice_init(&o->pending_comp, &o->exe_queue);
+        else if (!rc)
+                /*
+                 * If zero is returned, means there are no outstanding pending
+                 * completions and we may dismiss the pending list.
+                 */
+                __bnx2x_exe_queue_reset_pending(bp, o);
+
+        spin_unlock_bh(&o->lock);
+        return rc;
+}
+
+static inline bool bnx2x_exe_queue_empty(struct bnx2x_exe_queue_obj *o)
+{
+        bool empty = list_empty(&o->exe_queue);
+
+        /* Don't reorder!!! */
         mb();
 
-        bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
-                      U64_HI(bnx2x_sp_mapping(bp, mac_config)),
-                      U64_LO(bnx2x_sp_mapping(bp, mac_config)), 1);
+        return empty && list_empty(&o->pending_comp);
+}
+
+static inline struct bnx2x_exeq_elem *bnx2x_exe_queue_alloc_elem(
+        struct bnx2x *bp)
+{
+        DP(BNX2X_MSG_SP, "Allocating a new exe_queue element\n");
+        return kzalloc(sizeof(struct bnx2x_exeq_elem), GFP_ATOMIC);
+}
 
-        /* Wait for a completion */
-        bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending, ramrod_flags);
+/************************ raw_obj functions ***********************************/
+static bool bnx2x_raw_check_pending(struct bnx2x_raw_obj *o)
+{
+        return !!test_bit(o->state, o->pstate);
 }
 
+static void bnx2x_raw_clear_pending(struct bnx2x_raw_obj *o)
+{
+        smp_mb__before_clear_bit();
+        clear_bit(o->state, o->pstate);
+        smp_mb__after_clear_bit();
+}
 
-static inline u8 bnx2x_e1_cam_mc_offset(struct bnx2x *bp)
+static void bnx2x_raw_set_pending(struct bnx2x_raw_obj *o)
 {
-        return CHIP_REV_IS_SLOW(bp) ?
-                (BNX2X_MAX_EMUL_MULTI * (1 + BP_PORT(bp))) :
-                (BNX2X_MAX_MULTICAST * (1 + BP_PORT(bp)));
+        smp_mb__before_clear_bit();
+        set_bit(o->state, o->pstate);
+        smp_mb__after_clear_bit();
 }
 
-/* set mc list, do not wait as wait implies sleep and
- * set_rx_mode can be invoked from non-sleepable context.
+/**
+ * bnx2x_state_wait - wait until the given bit(state) is cleared
+ *
+ * @bp:         device handle
+ * @state:      state which is to be cleared
+ * @state_p:    state buffer
  *
- * Instead we use the same ramrod data buffer each time we need
- * to configure a list of addresses, and use the fact that the
- * list of MACs is changed in an incremental way and that the
- * function is called under the netif_addr_lock. A temporary
- * inconsistent CAM configuration (possible in case of a very fast
- * sequence of add/del/add on the host side) will shortly be
- * restored by the handler of the last ramrod.
  */
-int bnx2x_set_e1_mc_list(struct bnx2x *bp)
+static inline int bnx2x_state_wait(struct bnx2x *bp, int state,
+                                   unsigned long *pstate)
 {
-        int i = 0, old;
-        struct net_device *dev = bp->dev;
-        u8 offset = bnx2x_e1_cam_mc_offset(bp);
-        struct netdev_hw_addr *ha;
-        struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, mcast_config);
-        dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, mcast_config);
+        /* can take a while if any port is running */
+        int cnt = 5000;
+
 
-        if (netdev_mc_count(dev) > BNX2X_MAX_MULTICAST)
+        if (CHIP_REV_IS_EMUL(bp))
+                cnt *= 20;
+
+        DP(BNX2X_MSG_SP, "waiting for state to become %d\n", state);
+
+        might_sleep();
+        while (cnt--) {
+                if (!test_bit(state, pstate)) {
+#ifdef BNX2X_STOP_ON_ERROR
+                        DP(BNX2X_MSG_SP, "exit  (cnt %d)\n", 5000 - cnt);
+#endif
+                        return 0;
+                }
+
+                usleep_range(1000, 1000);
+
+                if (bp->panic)
+                        return -EIO;
+        }
+
+        /* timeout! */
+        BNX2X_ERR("timeout waiting for state %d\n", state);
+#ifdef BNX2X_STOP_ON_ERROR
+        bnx2x_panic();
+#endif
+
+        return -EBUSY;
+}
+
+static int bnx2x_raw_wait(struct bnx2x *bp, struct bnx2x_raw_obj *raw)
+{
+        return bnx2x_state_wait(bp, raw->state, raw->pstate);
+}
+
+/***************** Classification verbs: Set/Del MAC/VLAN/VLAN-MAC ************/
+/* credit handling callbacks */
+static bool bnx2x_get_cam_offset_mac(struct bnx2x_vlan_mac_obj *o, int *offset)
+{
+        struct bnx2x_credit_pool_obj *mp = o->macs_pool;
+
+        WARN_ON(!mp);
+
+        return mp->get_entry(mp, offset);
+}
+
+static bool bnx2x_get_credit_mac(struct bnx2x_vlan_mac_obj *o)
+{
+        struct bnx2x_credit_pool_obj *mp = o->macs_pool;
+
+        WARN_ON(!mp);
+
+        return mp->get(mp, 1);
+}
+
+static bool bnx2x_get_cam_offset_vlan(struct bnx2x_vlan_mac_obj *o, int *offset)
+{
+        struct bnx2x_credit_pool_obj *vp = o->vlans_pool;
+
+        WARN_ON(!vp);
+
+        return vp->get_entry(vp, offset);
+}
+
+static bool bnx2x_get_credit_vlan(struct bnx2x_vlan_mac_obj *o)
+{
+        struct bnx2x_credit_pool_obj *vp = o->vlans_pool;
+
+        WARN_ON(!vp);
+
+        return vp->get(vp, 1);
+}
+
+static bool bnx2x_get_credit_vlan_mac(struct bnx2x_vlan_mac_obj *o)
+{
+        struct bnx2x_credit_pool_obj *mp = o->macs_pool;
+        struct bnx2x_credit_pool_obj *vp = o->vlans_pool;
+
+        if (!mp->get(mp, 1))
+                return false;
+
+        if (!vp->get(vp, 1)) {
+                mp->put(mp, 1);
+                return false;
+        }
+
+        return true;
+}
+
+static bool bnx2x_put_cam_offset_mac(struct bnx2x_vlan_mac_obj *o, int offset)
+{
+        struct bnx2x_credit_pool_obj *mp = o->macs_pool;
+
+        return mp->put_entry(mp, offset);
+}
+
+static bool bnx2x_put_credit_mac(struct bnx2x_vlan_mac_obj *o)
+{
+        struct bnx2x_credit_pool_obj *mp = o->macs_pool;
+
+        return mp->put(mp, 1);
+}
+
+static bool bnx2x_put_cam_offset_vlan(struct bnx2x_vlan_mac_obj *o, int offset)
+{
+        struct bnx2x_credit_pool_obj *vp = o->vlans_pool;
+
+        return vp->put_entry(vp, offset);
+}
+
+static bool bnx2x_put_credit_vlan(struct bnx2x_vlan_mac_obj *o)
+{
+        struct bnx2x_credit_pool_obj *vp = o->vlans_pool;
+
+        return vp->put(vp, 1);
+}
+
+static bool bnx2x_put_credit_vlan_mac(struct bnx2x_vlan_mac_obj *o)
+{
+        struct bnx2x_credit_pool_obj *mp = o->macs_pool;
+        struct bnx2x_credit_pool_obj *vp = o->vlans_pool;
+
+        if (!mp->put(mp, 1))
+                return false;
+
+        if (!vp->put(vp, 1)) {
+                mp->get(mp, 1);
+                return false;
+        }
+
+        return true;
+}
+
+/* check_add() callbacks */
+static int bnx2x_check_mac_add(struct bnx2x_vlan_mac_obj *o,
+                               union bnx2x_classification_ramrod_data *data)
+{
+        struct bnx2x_vlan_mac_registry_elem *pos;
+
+        if (!is_valid_ether_addr(data->mac.mac))
                 return -EINVAL;
 
-        netdev_for_each_mc_addr(ha, dev) {
-                /* copy mac */
-                config_cmd->config_table[i].msb_mac_addr =
-                        swab16(*(u16 *)&bnx2x_mc_addr(ha)[0]);
-                config_cmd->config_table[i].middle_mac_addr =
-                        swab16(*(u16 *)&bnx2x_mc_addr(ha)[2]);
-                config_cmd->config_table[i].lsb_mac_addr =
-                        swab16(*(u16 *)&bnx2x_mc_addr(ha)[4]);
-
-                config_cmd->config_table[i].vlan_id = 0;
-                config_cmd->config_table[i].pf_id = BP_FUNC(bp);
-                config_cmd->config_table[i].clients_bit_vector =
-                        cpu_to_le32(1 << BP_L_ID(bp));
-
-                SET_FLAG(config_cmd->config_table[i].flags,
-                        MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
-                        T_ETH_MAC_COMMAND_SET);
-
-                DP(NETIF_MSG_IFUP,
-                   "setting MCAST[%d] (%04x:%04x:%04x)\n", i,
-                   config_cmd->config_table[i].msb_mac_addr,
-                   config_cmd->config_table[i].middle_mac_addr,
-                   config_cmd->config_table[i].lsb_mac_addr);
-                i++;
+        /* Check if a requested MAC already exists */
+        list_for_each_entry(pos, &o->head, link)
+                if (!memcmp(data->mac.mac, pos->u.mac.mac, ETH_ALEN))
+                        return -EEXIST;
+
+        return 0;
+}
+
+static int bnx2x_check_vlan_add(struct bnx2x_vlan_mac_obj *o,
+                                union bnx2x_classification_ramrod_data *data)
+{
+        struct bnx2x_vlan_mac_registry_elem *pos;
+
+        list_for_each_entry(pos, &o->head, link)
+                if (data->vlan.vlan == pos->u.vlan.vlan)
+                        return -EEXIST;
+
+        return 0;
+}
+
+static int bnx2x_check_vlan_mac_add(struct bnx2x_vlan_mac_obj *o,
+                                   union bnx2x_classification_ramrod_data *data)
+{
+        struct bnx2x_vlan_mac_registry_elem *pos;
+
+        list_for_each_entry(pos, &o->head, link)
+                if ((data->vlan_mac.vlan == pos->u.vlan_mac.vlan) &&
+                    (!memcmp(data->vlan_mac.mac, pos->u.vlan_mac.mac,
+                             ETH_ALEN)))
+                        return -EEXIST;
+
+        return 0;
+}
+
+
+/* check_del() callbacks */
+static struct bnx2x_vlan_mac_registry_elem *
+        bnx2x_check_mac_del(struct bnx2x_vlan_mac_obj *o,
+                            union bnx2x_classification_ramrod_data *data)
+{
+        struct bnx2x_vlan_mac_registry_elem *pos;
+
+        list_for_each_entry(pos, &o->head, link)
+                if (!memcmp(data->mac.mac, pos->u.mac.mac, ETH_ALEN))
+                        return pos;
+
+        return NULL;
+}
+
+static struct bnx2x_vlan_mac_registry_elem *
+        bnx2x_check_vlan_del(struct bnx2x_vlan_mac_obj *o,
+                             union bnx2x_classification_ramrod_data *data)
+{
+        struct bnx2x_vlan_mac_registry_elem *pos;
+
+        list_for_each_entry(pos, &o->head, link)
+                if (data->vlan.vlan == pos->u.vlan.vlan)
+                        return pos;
+
+        return NULL;
+}
+
+static struct bnx2x_vlan_mac_registry_elem *
+        bnx2x_check_vlan_mac_del(struct bnx2x_vlan_mac_obj *o,
+                                 union bnx2x_classification_ramrod_data *data)
+{
+        struct bnx2x_vlan_mac_registry_elem *pos;
+
+        list_for_each_entry(pos, &o->head, link)
+                if ((data->vlan_mac.vlan == pos->u.vlan_mac.vlan) &&
+                    (!memcmp(data->vlan_mac.mac, pos->u.vlan_mac.mac,
+                             ETH_ALEN)))
+                        return pos;
+
+        return NULL;
+}
+
+/* check_move() callback */
+static bool bnx2x_check_move(struct bnx2x_vlan_mac_obj *src_o,
+                             struct bnx2x_vlan_mac_obj *dst_o,
+                             union bnx2x_classification_ramrod_data *data)
+{
+        struct bnx2x_vlan_mac_registry_elem *pos;
+        int rc;
+
+        /* Check if we can delete the requested configuration from the first
+         * object.
+         */
+        pos = src_o->check_del(src_o, data);
+
+        /*  check if configuration can be added */
+        rc = dst_o->check_add(dst_o, data);
+
+        /* If this classification can not be added (is already set)
+         * or can't be deleted - return an error.
+         */
+        if (rc || !pos)
+                return false;
+
+        return true;
+}
+
+static bool bnx2x_check_move_always_err(
+        struct bnx2x_vlan_mac_obj *src_o,
+        struct bnx2x_vlan_mac_obj *dst_o,
+        union bnx2x_classification_ramrod_data *data)
+{
+        return false;
+}
+
+
+static inline u8 bnx2x_vlan_mac_get_rx_tx_flag(struct bnx2x_vlan_mac_obj *o)
+{
+        struct bnx2x_raw_obj *raw = &o->raw;
+        u8 rx_tx_flag = 0;
+
+        if ((raw->obj_type == BNX2X_OBJ_TYPE_TX) ||
+            (raw->obj_type == BNX2X_OBJ_TYPE_RX_TX))
+                rx_tx_flag |= ETH_CLASSIFY_CMD_HEADER_TX_CMD;
+
+        if ((raw->obj_type == BNX2X_OBJ_TYPE_RX) ||
+            (raw->obj_type == BNX2X_OBJ_TYPE_RX_TX))
+                rx_tx_flag |= ETH_CLASSIFY_CMD_HEADER_RX_CMD;
+
+        return rx_tx_flag;
+}
+
+/* LLH CAM line allocations */
+enum {
+        LLH_CAM_ISCSI_ETH_LINE = 0,
+        LLH_CAM_ETH_LINE,
+        LLH_CAM_MAX_PF_LINE = NIG_REG_LLH1_FUNC_MEM_SIZE / 2
+};
+
+static inline void bnx2x_set_mac_in_nig(struct bnx2x *bp,
+                                 bool add, unsigned char *dev_addr, int index)
+{
+        u32 wb_data[2];
+        u32 reg_offset = BP_PORT(bp) ? NIG_REG_LLH1_FUNC_MEM :
+                         NIG_REG_LLH0_FUNC_MEM;
+
+        if (!IS_MF_SI(bp) || index > LLH_CAM_MAX_PF_LINE)
+                return;
+
+        DP(BNX2X_MSG_SP, "Going to %s LLH configuration at entry %d\n",
+                         (add ? "ADD" : "DELETE"), index);
+
+        if (add) {
+                /* LLH_FUNC_MEM is a u64 WB register */
+                reg_offset += 8*index;
+
+                wb_data[0] = ((dev_addr[2] << 24) | (dev_addr[3] << 16) |
+                              (dev_addr[4] <<  8) |  dev_addr[5]);
+                wb_data[1] = ((dev_addr[0] <<  8) |  dev_addr[1]);
+
+                REG_WR_DMAE(bp, reg_offset, wb_data, 2);
         }
-        old = config_cmd->hdr.length;
-        if (old > i) {
-                for (; i < old; i++) {
-                        if (CAM_IS_INVALID(config_cmd->
-                                           config_table[i])) {
-                                /* already invalidated */
-                                break;
-                        }
-                        /* invalidate */
-                        SET_FLAG(config_cmd->config_table[i].flags,
-                                MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
-                                T_ETH_MAC_COMMAND_INVALIDATE);
-                }
+
+        REG_WR(bp, (BP_PORT(bp) ? NIG_REG_LLH1_FUNC_MEM_ENABLE :
+                                  NIG_REG_LLH0_FUNC_MEM_ENABLE) + 4*index, add);
+}
+
+/**
+ * bnx2x_vlan_mac_set_cmd_hdr_e2 - set a header in a single classify ramrod
+ *
+ * @bp:         device handle
+ * @o:          queue for which we want to configure this rule
+ * @add:        if true the command is an ADD command, DEL otherwise
+ * @opcode:     CLASSIFY_RULE_OPCODE_XXX
+ * @hdr:        pointer to a header to setup
+ *
+ */
+static inline void bnx2x_vlan_mac_set_cmd_hdr_e2(struct bnx2x *bp,
+        struct bnx2x_vlan_mac_obj *o, bool add, int opcode,
+        struct eth_classify_cmd_header *hdr)
+{
+        struct bnx2x_raw_obj *raw = &o->raw;
+
+        hdr->client_id = raw->cl_id;
+        hdr->func_id = raw->func_id;
+
+        /* Rx or/and Tx (internal switching) configuration ? */
+        hdr->cmd_general_data |=
+                bnx2x_vlan_mac_get_rx_tx_flag(o);
+
+        if (add)
+                hdr->cmd_general_data |= ETH_CLASSIFY_CMD_HEADER_IS_ADD;
+
+        hdr->cmd_general_data |=
+                (opcode << ETH_CLASSIFY_CMD_HEADER_OPCODE_SHIFT);
+}
+
+/**
+ * bnx2x_vlan_mac_set_rdata_hdr_e2 - set the classify ramrod data header
+ *
+ * @cid:        connection id
+ * @type:       BNX2X_FILTER_XXX_PENDING
+ * @hdr:        poiter to header to setup
+ * @rule_cnt:
+ *
+ * currently we always configure one rule and echo field to contain a CID and an
+ * opcode type.
+ */
+static inline void bnx2x_vlan_mac_set_rdata_hdr_e2(u32 cid, int type,
+                                struct eth_classify_header *hdr, int rule_cnt)
+{
+        hdr->echo = (cid & BNX2X_SWCID_MASK) | (type << BNX2X_SWCID_SHIFT);
+        hdr->rule_cnt = (u8)rule_cnt;
+}
+
+
+/* hw_config() callbacks */
+static void bnx2x_set_one_mac_e2(struct bnx2x *bp,
+                                 struct bnx2x_vlan_mac_obj *o,
+                                 struct bnx2x_exeq_elem *elem, int rule_idx,
+                                 int cam_offset)
+{
+        struct bnx2x_raw_obj *raw = &o->raw;
+        struct eth_classify_rules_ramrod_data *data =
+                (struct eth_classify_rules_ramrod_data *)(raw->rdata);
+        int rule_cnt = rule_idx + 1, cmd = elem->cmd_data.vlan_mac.cmd;
+        union eth_classify_rule_cmd *rule_entry = &data->rules[rule_idx];
+        bool add = (cmd == BNX2X_VLAN_MAC_ADD) ? true : false;
+        unsigned long *vlan_mac_flags = &elem->cmd_data.vlan_mac.vlan_mac_flags;
+        u8 *mac = elem->cmd_data.vlan_mac.u.mac.mac;
+
+        /*
+         * Set LLH CAM entry: currently only iSCSI and ETH macs are
+         * relevant. In addition, current implementation is tuned for a
+         * single ETH MAC.
+         *
+         * When multiple unicast ETH MACs PF configuration in switch
+         * independent mode is required (NetQ, multiple netdev MACs,
+         * etc.), consider better utilisation of 8 per function MAC
+         * entries in the LLH register. There is also
+         * NIG_REG_P[01]_LLH_FUNC_MEM2 registers that complete the
+         * total number of CAM entries to 16.
+         *
+         * Currently we won't configure NIG for MACs other than a primary ETH
+         * MAC and iSCSI L2 MAC.
+         *
+         * If this MAC is moving from one Queue to another, no need to change
+         * NIG configuration.
+         */
+        if (cmd != BNX2X_VLAN_MAC_MOVE) {
+                if (test_bit(BNX2X_ISCSI_ETH_MAC, vlan_mac_flags))
+                        bnx2x_set_mac_in_nig(bp, add, mac,
+                                             LLH_CAM_ISCSI_ETH_LINE);
+                else if (test_bit(BNX2X_ETH_MAC, vlan_mac_flags))
+                        bnx2x_set_mac_in_nig(bp, add, mac, LLH_CAM_ETH_LINE);
         }
 
-        wmb();
+        /* Reset the ramrod data buffer for the first rule */
+        if (rule_idx == 0)
+                memset(data, 0, sizeof(*data));
+
+        /* Setup a command header */
+        bnx2x_vlan_mac_set_cmd_hdr_e2(bp, o, add, CLASSIFY_RULE_OPCODE_MAC,
+                                      &rule_entry->mac.header);
+
+        DP(BNX2X_MSG_SP, "About to %s MAC "BNX2X_MAC_FMT" for "
+                         "Queue %d\n", (add ? "add" : "delete"),
+                         BNX2X_MAC_PRN_LIST(mac), raw->cl_id);
+
+        /* Set a MAC itself */
+        bnx2x_set_fw_mac_addr(&rule_entry->mac.mac_msb,
+                              &rule_entry->mac.mac_mid,
+                              &rule_entry->mac.mac_lsb, mac);
+
+        /* MOVE: Add a rule that will add this MAC to the target Queue */
+        if (cmd == BNX2X_VLAN_MAC_MOVE) {
+                rule_entry++;
+                rule_cnt++;
+
+                /* Setup ramrod data */
+                bnx2x_vlan_mac_set_cmd_hdr_e2(bp,
+                                        elem->cmd_data.vlan_mac.target_obj,
+                                              true, CLASSIFY_RULE_OPCODE_MAC,
+                                              &rule_entry->mac.header);
+
+                /* Set a MAC itself */
+                bnx2x_set_fw_mac_addr(&rule_entry->mac.mac_msb,
+                                      &rule_entry->mac.mac_mid,
+                                      &rule_entry->mac.mac_lsb, mac);
+        }
+
+        /* Set the ramrod data header */
+        /* TODO: take this to the higher level in order to prevent multiple
+                 writing */
+        bnx2x_vlan_mac_set_rdata_hdr_e2(raw->cid, raw->state, &data->header,
+                                        rule_cnt);
+}
+
+/**
+ * bnx2x_vlan_mac_set_rdata_hdr_e1x - set a header in a single classify ramrod
+ *
+ * @bp:         device handle
+ * @o:          queue
+ * @type:
+ * @cam_offset: offset in cam memory
+ * @hdr:        pointer to a header to setup
+ *
+ * E1/E1H
+ */
+static inline void bnx2x_vlan_mac_set_rdata_hdr_e1x(struct bnx2x *bp,
+        struct bnx2x_vlan_mac_obj *o, int type, int cam_offset,
+        struct mac_configuration_hdr *hdr)
+{
+        struct bnx2x_raw_obj *r = &o->raw;
+
+        hdr->length = 1;
+        hdr->offset = (u8)cam_offset;
+        hdr->client_id = 0xff;
+        hdr->echo = ((r->cid & BNX2X_SWCID_MASK) | (type << BNX2X_SWCID_SHIFT));
+}
 
-        config_cmd->hdr.length = i;
-        config_cmd->hdr.offset = offset;
-        config_cmd->hdr.client_id = 0xff;
-        /* Mark that this ramrod doesn't use bp->set_mac_pending for
-         * synchronization.
+static inline void bnx2x_vlan_mac_set_cfg_entry_e1x(struct bnx2x *bp,
+        struct bnx2x_vlan_mac_obj *o, bool add, int opcode, u8 *mac,
+        u16 vlan_id, struct mac_configuration_entry *cfg_entry)
+{
+        struct bnx2x_raw_obj *r = &o->raw;
+        u32 cl_bit_vec = (1 << r->cl_id);
+
+        cfg_entry->clients_bit_vector = cpu_to_le32(cl_bit_vec);
+        cfg_entry->pf_id = r->func_id;
+        cfg_entry->vlan_id = cpu_to_le16(vlan_id);
+
+        if (add) {
+                SET_FLAG(cfg_entry->flags, MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
+                         T_ETH_MAC_COMMAND_SET);
+                SET_FLAG(cfg_entry->flags,
+                         MAC_CONFIGURATION_ENTRY_VLAN_FILTERING_MODE, opcode);
+
+                /* Set a MAC in a ramrod data */
+                bnx2x_set_fw_mac_addr(&cfg_entry->msb_mac_addr,
+                                      &cfg_entry->middle_mac_addr,
+                                      &cfg_entry->lsb_mac_addr, mac);
+        } else
+                SET_FLAG(cfg_entry->flags, MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
+                         T_ETH_MAC_COMMAND_INVALIDATE);
+}
+
+static inline void bnx2x_vlan_mac_set_rdata_e1x(struct bnx2x *bp,
+        struct bnx2x_vlan_mac_obj *o, int type, int cam_offset, bool add,
+        u8 *mac, u16 vlan_id, int opcode, struct mac_configuration_cmd *config)
+{
+        struct mac_configuration_entry *cfg_entry = &config->config_table[0];
+        struct bnx2x_raw_obj *raw = &o->raw;
+
+        bnx2x_vlan_mac_set_rdata_hdr_e1x(bp, o, type, cam_offset,
+                                         &config->hdr);
+        bnx2x_vlan_mac_set_cfg_entry_e1x(bp, o, add, opcode, mac, vlan_id,
+                                         cfg_entry);
+
+        DP(BNX2X_MSG_SP, "%s MAC "BNX2X_MAC_FMT" CLID %d CAM offset %d\n",
+                         (add ? "setting" : "clearing"),
+                         BNX2X_MAC_PRN_LIST(mac), raw->cl_id, cam_offset);
+}
+
+/**
+ * bnx2x_set_one_mac_e1x - fill a single MAC rule ramrod data
+ *
+ * @bp:         device handle
+ * @o:          bnx2x_vlan_mac_obj
+ * @elem:       bnx2x_exeq_elem
+ * @rule_idx:   rule_idx
+ * @cam_offset: cam_offset
+ */
+static void bnx2x_set_one_mac_e1x(struct bnx2x *bp,
+                                  struct bnx2x_vlan_mac_obj *o,
+                                  struct bnx2x_exeq_elem *elem, int rule_idx,
+                                  int cam_offset)
+{
+        struct bnx2x_raw_obj *raw = &o->raw;
+        struct mac_configuration_cmd *config =
+                (struct mac_configuration_cmd *)(raw->rdata);
+        /*
+         * 57710 and 57711 do not support MOVE command,
+         * so it's either ADD or DEL
          */
-        config_cmd->hdr.echo = 0;
+        bool add = (elem->cmd_data.vlan_mac.cmd == BNX2X_VLAN_MAC_ADD) ?
+                true : false;
 
-        mb();
+        /* Reset the ramrod data buffer */
+        memset(config, 0, sizeof(*config));
 
-        return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
-                   U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
+        bnx2x_vlan_mac_set_rdata_e1x(bp, o, BNX2X_FILTER_MAC_PENDING,
+                                     cam_offset, add,
+                                     elem->cmd_data.vlan_mac.u.mac.mac, 0,
+                                     ETH_VLAN_FILTER_ANY_VLAN, config);
 }
 
-void bnx2x_invalidate_e1_mc_list(struct bnx2x *bp)
+static void bnx2x_set_one_vlan_e2(struct bnx2x *bp,
+                                  struct bnx2x_vlan_mac_obj *o,
+                                  struct bnx2x_exeq_elem *elem, int rule_idx,
+                                  int cam_offset)
 {
-        int i;
-        struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, mcast_config);
-        dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, mcast_config);
-        int ramrod_flags = WAIT_RAMROD_COMMON;
-        u8 offset = bnx2x_e1_cam_mc_offset(bp);
+        struct bnx2x_raw_obj *raw = &o->raw;
+        struct eth_classify_rules_ramrod_data *data =
+                (struct eth_classify_rules_ramrod_data *)(raw->rdata);
+        int rule_cnt = rule_idx + 1;
+        union eth_classify_rule_cmd *rule_entry = &data->rules[rule_idx];
+        int cmd = elem->cmd_data.vlan_mac.cmd;
+        bool add = (cmd == BNX2X_VLAN_MAC_ADD) ? true : false;
+        u16 vlan = elem->cmd_data.vlan_mac.u.vlan.vlan;
+
+        /* Reset the ramrod data buffer for the first rule */
+        if (rule_idx == 0)
+                memset(data, 0, sizeof(*data));
+
+        /* Set a rule header */
+        bnx2x_vlan_mac_set_cmd_hdr_e2(bp, o, add, CLASSIFY_RULE_OPCODE_VLAN,
+                                      &rule_entry->vlan.header);
+
+        DP(BNX2X_MSG_SP, "About to %s VLAN %d\n", (add ? "add" : "delete"),
+                         vlan);
+
+        /* Set a VLAN itself */
+        rule_entry->vlan.vlan = cpu_to_le16(vlan);
+
+        /* MOVE: Add a rule that will add this MAC to the target Queue */
+        if (cmd == BNX2X_VLAN_MAC_MOVE) {
+                rule_entry++;
+                rule_cnt++;
+
+                /* Setup ramrod data */
+                bnx2x_vlan_mac_set_cmd_hdr_e2(bp,
+                                        elem->cmd_data.vlan_mac.target_obj,
+                                              true, CLASSIFY_RULE_OPCODE_VLAN,
+                                              &rule_entry->vlan.header);
+
+                /* Set a VLAN itself */
+                rule_entry->vlan.vlan = cpu_to_le16(vlan);
+        }
 
-        for (i = 0; i < BNX2X_MAX_MULTICAST; i++)
-                SET_FLAG(config_cmd->config_table[i].flags,
-                        MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
-                        T_ETH_MAC_COMMAND_INVALIDATE);
+        /* Set the ramrod data header */
+        /* TODO: take this to the higher level in order to prevent multiple
+                 writing */
+        bnx2x_vlan_mac_set_rdata_hdr_e2(raw->cid, raw->state, &data->header,
+                                        rule_cnt);
+}
 
-        wmb();
+static void bnx2x_set_one_vlan_mac_e2(struct bnx2x *bp,
+                                      struct bnx2x_vlan_mac_obj *o,
+                                      struct bnx2x_exeq_elem *elem,
+                                      int rule_idx, int cam_offset)
+{
+        struct bnx2x_raw_obj *raw = &o->raw;
+        struct eth_classify_rules_ramrod_data *data =
+                (struct eth_classify_rules_ramrod_data *)(raw->rdata);
+        int rule_cnt = rule_idx + 1;
+        union eth_classify_rule_cmd *rule_entry = &data->rules[rule_idx];
+        int cmd = elem->cmd_data.vlan_mac.cmd;
+        bool add = (cmd == BNX2X_VLAN_MAC_ADD) ? true : false;
+        u16 vlan = elem->cmd_data.vlan_mac.u.vlan_mac.vlan;
+        u8 *mac = elem->cmd_data.vlan_mac.u.vlan_mac.mac;
+
+
+        /* Reset the ramrod data buffer for the first rule */
+        if (rule_idx == 0)
+                memset(data, 0, sizeof(*data));
+
+        /* Set a rule header */
+        bnx2x_vlan_mac_set_cmd_hdr_e2(bp, o, add, CLASSIFY_RULE_OPCODE_PAIR,
+                                      &rule_entry->pair.header);
+
+        /* Set VLAN and MAC themselvs */
+        rule_entry->pair.vlan = cpu_to_le16(vlan);
+        bnx2x_set_fw_mac_addr(&rule_entry->pair.mac_msb,
+                              &rule_entry->pair.mac_mid,
+                              &rule_entry->pair.mac_lsb, mac);
+
+        /* MOVE: Add a rule that will add this MAC to the target Queue */
+        if (cmd == BNX2X_VLAN_MAC_MOVE) {
+                rule_entry++;
+                rule_cnt++;
+
+                /* Setup ramrod data */
+                bnx2x_vlan_mac_set_cmd_hdr_e2(bp,
+                                        elem->cmd_data.vlan_mac.target_obj,
+                                              true, CLASSIFY_RULE_OPCODE_PAIR,
+                                              &rule_entry->pair.header);
+
+                /* Set a VLAN itself */
+                rule_entry->pair.vlan = cpu_to_le16(vlan);
+                bnx2x_set_fw_mac_addr(&rule_entry->pair.mac_msb,
+                                      &rule_entry->pair.mac_mid,
+                                      &rule_entry->pair.mac_lsb, mac);
+        }
+
+        /* Set the ramrod data header */
+        /* TODO: take this to the higher level in order to prevent multiple
+                 writing */
+        bnx2x_vlan_mac_set_rdata_hdr_e2(raw->cid, raw->state, &data->header,
+                                        rule_cnt);
+}
+
+/**
+ * bnx2x_set_one_vlan_mac_e1h -
+ *
+ * @bp:         device handle
+ * @o:          bnx2x_vlan_mac_obj
+ * @elem:       bnx2x_exeq_elem
+ * @rule_idx:   rule_idx
+ * @cam_offset: cam_offset
+ */
+static void bnx2x_set_one_vlan_mac_e1h(struct bnx2x *bp,
+                                       struct bnx2x_vlan_mac_obj *o,
+                                       struct bnx2x_exeq_elem *elem,
+                                       int rule_idx, int cam_offset)
+{
+        struct bnx2x_raw_obj *raw = &o->raw;
+        struct mac_configuration_cmd *config =
+                (struct mac_configuration_cmd *)(raw->rdata);
+        /*
+         * 57710 and 57711 do not support MOVE command,
+         * so it's either ADD or DEL
+         */
+        bool add = (elem->cmd_data.vlan_mac.cmd == BNX2X_VLAN_MAC_ADD) ?
+                true : false;
+
+        /* Reset the ramrod data buffer */
+        memset(config, 0, sizeof(*config));
 
-        config_cmd->hdr.length = BNX2X_MAX_MULTICAST;
-        config_cmd->hdr.offset = offset;
-        config_cmd->hdr.client_id = 0xff;
-        /* We'll wait for a completion this time... */
-        config_cmd->hdr.echo = 1;
+        bnx2x_vlan_mac_set_rdata_e1x(bp, o, BNX2X_FILTER_VLAN_MAC_PENDING,
+                                     cam_offset, add,
+                                     elem->cmd_data.vlan_mac.u.vlan_mac.mac,
+                                     elem->cmd_data.vlan_mac.u.vlan_mac.vlan,
+                                     ETH_VLAN_FILTER_CLASSIFY, config);
+}
 
-        bp->set_mac_pending = 1;
+#define list_next_entry(pos, member) \
+        list_entry((pos)->member.next, typeof(*(pos)), member)
 
-        mb();
+/**
+ * bnx2x_vlan_mac_restore - reconfigure next MAC/VLAN/VLAN-MAC element
+ *
+ * @bp:         device handle
+ * @p:          command parameters
+ * @ppos:       pointer to the cooky
+ *
+ * reconfigure next MAC/VLAN/VLAN-MAC element from the
+ * previously configured elements list.
+ *
+ * from command parameters only RAMROD_COMP_WAIT bit in ramrod_flags is taken
+ * into an account
+ *
+ * pointer to the cooky  - that should be given back in the next call to make
+ * function handle the next element. If *ppos is set to NULL it will restart the
+ * iterator. If returned *ppos == NULL this means that the last element has been
+ * handled.
+ *
+ */
+static int bnx2x_vlan_mac_restore(struct bnx2x *bp,
+                           struct bnx2x_vlan_mac_ramrod_params *p,
+                           struct bnx2x_vlan_mac_registry_elem **ppos)
+{
+        struct bnx2x_vlan_mac_registry_elem *pos;
+        struct bnx2x_vlan_mac_obj *o = p->vlan_mac_obj;
+
+        /* If list is empty - there is nothing to do here */
+        if (list_empty(&o->head)) {
+                *ppos = NULL;
+                return 0;
+        }
+
+        /* make a step... */
+        if (*ppos == NULL)
+                *ppos = list_first_entry(&o->head,
+                                         struct bnx2x_vlan_mac_registry_elem,
+                                         link);
+        else
+                *ppos = list_next_entry(*ppos, link);
+
+        pos = *ppos;
+
+        /* If it's the last step - return NULL */
+        if (list_is_last(&pos->link, &o->head))
+                *ppos = NULL;
+
+        /* Prepare a 'user_req' */
+        memcpy(&p->user_req.u, &pos->u, sizeof(pos->u));
+
+        /* Set the command */
+        p->user_req.cmd = BNX2X_VLAN_MAC_ADD;
 
-        bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
-                      U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
+        /* Set vlan_mac_flags */
+        p->user_req.vlan_mac_flags = pos->vlan_mac_flags;
 
-        /* Wait for a completion */
-        bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending,
-                                ramrod_flags);
+        /* Set a restore bit */
+        __set_bit(RAMROD_RESTORE, &p->ramrod_flags);
 
+        return bnx2x_config_vlan_mac(bp, p);
 }
 
-/* Accept one or more multicasts */
-int bnx2x_set_e1h_mc_list(struct bnx2x *bp)
+/*
+ * bnx2x_exeq_get_mac/bnx2x_exeq_get_vlan/bnx2x_exeq_get_vlan_mac return a
+ * pointer to an element with a specific criteria and NULL if such an element
+ * hasn't been found.
+ */
+static struct bnx2x_exeq_elem *bnx2x_exeq_get_mac(
+        struct bnx2x_exe_queue_obj *o,
+        struct bnx2x_exeq_elem *elem)
 {
-        struct net_device *dev = bp->dev;
-        struct netdev_hw_addr *ha;
-        u32 mc_filter[MC_HASH_SIZE];
-        u32 crc, bit, regidx;
-        int i;
+        struct bnx2x_exeq_elem *pos;
+        struct bnx2x_mac_ramrod_data *data = &elem->cmd_data.vlan_mac.u.mac;
+
+        /* Check pending for execution commands */
+        list_for_each_entry(pos, &o->exe_queue, link)
+                if (!memcmp(&pos->cmd_data.vlan_mac.u.mac, data,
+                              sizeof(*data)) &&
+                    (pos->cmd_data.vlan_mac.cmd == elem->cmd_data.vlan_mac.cmd))
+                        return pos;
+
+        return NULL;
+}
+
+static struct bnx2x_exeq_elem *bnx2x_exeq_get_vlan(
+        struct bnx2x_exe_queue_obj *o,
+        struct bnx2x_exeq_elem *elem)
+{
+        struct bnx2x_exeq_elem *pos;
+        struct bnx2x_vlan_ramrod_data *data = &elem->cmd_data.vlan_mac.u.vlan;
+
+        /* Check pending for execution commands */
+        list_for_each_entry(pos, &o->exe_queue, link)
+                if (!memcmp(&pos->cmd_data.vlan_mac.u.vlan, data,
+                              sizeof(*data)) &&
+                    (pos->cmd_data.vlan_mac.cmd == elem->cmd_data.vlan_mac.cmd))
+                        return pos;
+
+        return NULL;
+}
 
-        memset(mc_filter, 0, 4 * MC_HASH_SIZE);
+static struct bnx2x_exeq_elem *bnx2x_exeq_get_vlan_mac(
+        struct bnx2x_exe_queue_obj *o,
+        struct bnx2x_exeq_elem *elem)
+{
+        struct bnx2x_exeq_elem *pos;
+        struct bnx2x_vlan_mac_ramrod_data *data =
+                &elem->cmd_data.vlan_mac.u.vlan_mac;
+
+        /* Check pending for execution commands */
+        list_for_each_entry(pos, &o->exe_queue, link)
+                if (!memcmp(&pos->cmd_data.vlan_mac.u.vlan_mac, data,
+                              sizeof(*data)) &&
+                    (pos->cmd_data.vlan_mac.cmd == elem->cmd_data.vlan_mac.cmd))
+                        return pos;
+
+        return NULL;
+}
 
-        netdev_for_each_mc_addr(ha, dev) {
-                DP(NETIF_MSG_IFUP, "Adding mcast MAC: %pM\n",
-                   bnx2x_mc_addr(ha));
+/**
+ * bnx2x_validate_vlan_mac_add - check if an ADD command can be executed
+ *
+ * @bp:         device handle
+ * @qo:         bnx2x_qable_obj
+ * @elem:       bnx2x_exeq_elem
+ *
+ * Checks that the requested configuration can be added. If yes and if
+ * requested, consume CAM credit.
+ *
+ * The 'validate' is run after the 'optimize'.
+ *
+ */
+static inline int bnx2x_validate_vlan_mac_add(struct bnx2x *bp,
+                                              union bnx2x_qable_obj *qo,
+                                              struct bnx2x_exeq_elem *elem)
+{
+        struct bnx2x_vlan_mac_obj *o = &qo->vlan_mac;
+        struct bnx2x_exe_queue_obj *exeq = &o->exe_queue;
+        int rc;
+
+        /* Check the registry */
+        rc = o->check_add(o, &elem->cmd_data.vlan_mac.u);
+        if (rc) {
+                DP(BNX2X_MSG_SP, "ADD command is not allowed considering "
+                                 "current registry state\n");
+                return rc;
+        }
 
-                crc = crc32c_le(0, bnx2x_mc_addr(ha),
-                                ETH_ALEN);
-                bit = (crc >> 24) & 0xff;
-                regidx = bit >> 5;
-                bit &= 0x1f;
-                mc_filter[regidx] |= (1 << bit);
+        /*
+         * Check if there is a pending ADD command for this
+         * MAC/VLAN/VLAN-MAC. Return an error if there is.
+         */
+        if (exeq->get(exeq, elem)) {
+                DP(BNX2X_MSG_SP, "There is a pending ADD command already\n");
+                return -EEXIST;
         }
 
-        for (i = 0; i < MC_HASH_SIZE; i++)
-                REG_WR(bp, MC_HASH_OFFSET(bp, i),
-                       mc_filter[i]);
+        /*
+         * TODO: Check the pending MOVE from other objects where this
+         * object is a destination object.
+         */
+
+        /* Consume the credit if not requested not to */
+        if (!(test_bit(BNX2X_DONT_CONSUME_CAM_CREDIT,
+                       &elem->cmd_data.vlan_mac.vlan_mac_flags) ||
+            o->get_credit(o)))
+                return -EINVAL;
 
         return 0;
 }
 
-void bnx2x_invalidate_e1h_mc_list(struct bnx2x *bp)
+/**
+ * bnx2x_validate_vlan_mac_del - check if the DEL command can be executed
+ *
+ * @bp:         device handle
+ * @qo:         quable object to check
+ * @elem:       element that needs to be deleted
+ *
+ * Checks that the requested configuration can be deleted. If yes and if
+ * requested, returns a CAM credit.
+ *
+ * The 'validate' is run after the 'optimize'.
+ */
+static inline int bnx2x_validate_vlan_mac_del(struct bnx2x *bp,
+                                              union bnx2x_qable_obj *qo,
+                                              struct bnx2x_exeq_elem *elem)
 {
-        int i;
+        struct bnx2x_vlan_mac_obj *o = &qo->vlan_mac;
+        struct bnx2x_vlan_mac_registry_elem *pos;
+        struct bnx2x_exe_queue_obj *exeq = &o->exe_queue;
+        struct bnx2x_exeq_elem query_elem;
+
+        /* If this classification can not be deleted (doesn't exist)
+         * - return a BNX2X_EXIST.
+         */
+        pos = o->check_del(o, &elem->cmd_data.vlan_mac.u);
+        if (!pos) {
+                DP(BNX2X_MSG_SP, "DEL command is not allowed considering "
+                                 "current registry state\n");
+                return -EEXIST;
+        }
+
+        /*
+         * Check if there are pending DEL or MOVE commands for this
+         * MAC/VLAN/VLAN-MAC. Return an error if so.
+         */
+        memcpy(&query_elem, elem, sizeof(query_elem));
+
+        /* Check for MOVE commands */
+        query_elem.cmd_data.vlan_mac.cmd = BNX2X_VLAN_MAC_MOVE;
+        if (exeq->get(exeq, &query_elem)) {
+                BNX2X_ERR("There is a pending MOVE command already\n");
+                return -EINVAL;
+        }
+
+        /* Check for DEL commands */
+        if (exeq->get(exeq, elem)) {
+                DP(BNX2X_MSG_SP, "There is a pending DEL command already\n");
+                return -EEXIST;
+        }
+
+        /* Return the credit to the credit pool if not requested not to */
+        if (!(test_bit(BNX2X_DONT_CONSUME_CAM_CREDIT,
+                       &elem->cmd_data.vlan_mac.vlan_mac_flags) ||
+            o->put_credit(o))) {
+                BNX2X_ERR("Failed to return a credit\n");
+                return -EINVAL;
+        }
 
-        for (i = 0; i < MC_HASH_SIZE; i++)
-                REG_WR(bp, MC_HASH_OFFSET(bp, i), 0);
+        return 0;
 }
 
-/* must be called under rtnl_lock */
-void bnx2x_rxq_set_mac_filters(struct bnx2x *bp, u16 cl_id, u32 filters)
+/**
+ * bnx2x_validate_vlan_mac_move - check if the MOVE command can be executed
+ *
+ * @bp:         device handle
+ * @qo:         quable object to check (source)
+ * @elem:       element that needs to be moved
+ *
+ * Checks that the requested configuration can be moved. If yes and if
+ * requested, returns a CAM credit.
+ *
+ * The 'validate' is run after the 'optimize'.
+ */
+static inline int bnx2x_validate_vlan_mac_move(struct bnx2x *bp,
+                                               union bnx2x_qable_obj *qo,
+                                               struct bnx2x_exeq_elem *elem)
 {
-        u32 mask = (1 << cl_id);
+        struct bnx2x_vlan_mac_obj *src_o = &qo->vlan_mac;
+        struct bnx2x_vlan_mac_obj *dest_o = elem->cmd_data.vlan_mac.target_obj;
+        struct bnx2x_exeq_elem query_elem;
+        struct bnx2x_exe_queue_obj *src_exeq = &src_o->exe_queue;
+        struct bnx2x_exe_queue_obj *dest_exeq = &dest_o->exe_queue;
+
+        /*
+         * Check if we can perform this operation based on the current registry
+         * state.
+         */
+        if (!src_o->check_move(src_o, dest_o, &elem->cmd_data.vlan_mac.u)) {
+                DP(BNX2X_MSG_SP, "MOVE command is not allowed considering "
+                                 "current registry state\n");
+                return -EINVAL;
+        }
 
-        /* initial seeting is BNX2X_ACCEPT_NONE */
-        u8 drop_all_ucast = 1, drop_all_bcast = 1, drop_all_mcast = 1;
-        u8 accp_all_ucast = 0, accp_all_bcast = 0, accp_all_mcast = 0;
-        u8 unmatched_unicast = 0;
+        /*
+         * Check if there is an already pending DEL or MOVE command for the
+         * source object or ADD command for a destination object. Return an
+         * error if so.
+         */
+        memcpy(&query_elem, elem, sizeof(query_elem));
 
-        if (filters & BNX2X_ACCEPT_UNMATCHED_UCAST)
-                unmatched_unicast = 1;
+        /* Check DEL on source */
+        query_elem.cmd_data.vlan_mac.cmd = BNX2X_VLAN_MAC_DEL;
+        if (src_exeq->get(src_exeq, &query_elem)) {
+                BNX2X_ERR("There is a pending DEL command on the source "
+                          "queue already\n");
+                return -EINVAL;
+        }
+
+        /* Check MOVE on source */
+        if (src_exeq->get(src_exeq, elem)) {
+                DP(BNX2X_MSG_SP, "There is a pending MOVE command already\n");
+                return -EEXIST;
+        }
+
+        /* Check ADD on destination */
+        query_elem.cmd_data.vlan_mac.cmd = BNX2X_VLAN_MAC_ADD;
+        if (dest_exeq->get(dest_exeq, &query_elem)) {
+                BNX2X_ERR("There is a pending ADD command on the "
+                          "destination queue already\n");
+                return -EINVAL;
+        }
+
+        /* Consume the credit if not requested not to */
+        if (!(test_bit(BNX2X_DONT_CONSUME_CAM_CREDIT_DEST,
+                       &elem->cmd_data.vlan_mac.vlan_mac_flags) ||
+            dest_o->get_credit(dest_o)))
+                return -EINVAL;
+
+        if (!(test_bit(BNX2X_DONT_CONSUME_CAM_CREDIT,
+                       &elem->cmd_data.vlan_mac.vlan_mac_flags) ||
+            src_o->put_credit(src_o))) {
+                /* return the credit taken from dest... */
+                dest_o->put_credit(dest_o);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int bnx2x_validate_vlan_mac(struct bnx2x *bp,
+                                   union bnx2x_qable_obj *qo,
+                                   struct bnx2x_exeq_elem *elem)
+{
+        switch (elem->cmd_data.vlan_mac.cmd) {
+        case BNX2X_VLAN_MAC_ADD:
+                return bnx2x_validate_vlan_mac_add(bp, qo, elem);
+        case BNX2X_VLAN_MAC_DEL:
+                return bnx2x_validate_vlan_mac_del(bp, qo, elem);
+        case BNX2X_VLAN_MAC_MOVE:
+                return bnx2x_validate_vlan_mac_move(bp, qo, elem);
+        default:
+                return -EINVAL;
+        }
+}
 
-        if (filters & BNX2X_PROMISCUOUS_MODE) {
-                /* promiscious - accept all, drop none */
-                drop_all_ucast = drop_all_bcast = drop_all_mcast = 0;
-                accp_all_ucast = accp_all_bcast = accp_all_mcast = 1;
-                if (IS_MF_SI(bp)) {
+/**
+ * bnx2x_wait_vlan_mac - passivly wait for 5 seconds until all work completes.
+ *
+ * @bp:         device handle
+ * @o:          bnx2x_vlan_mac_obj
+ *
+ */
+static int bnx2x_wait_vlan_mac(struct bnx2x *bp,
+                               struct bnx2x_vlan_mac_obj *o)
+{
+        int cnt = 5000, rc;
+        struct bnx2x_exe_queue_obj *exeq = &o->exe_queue;
+        struct bnx2x_raw_obj *raw = &o->raw;
+
+        while (cnt--) {
+                /* Wait for the current command to complete */
+                rc = raw->wait_comp(bp, raw);
+                if (rc)
+                        return rc;
+
+                /* Wait until there are no pending commands */
+                if (!bnx2x_exe_queue_empty(exeq))
+                        usleep_range(1000, 1000);
+                else
+                        return 0;
+        }
+
+        return -EBUSY;
+}
+
+/**
+ * bnx2x_complete_vlan_mac - complete one VLAN-MAC ramrod
+ *
+ * @bp:         device handle
+ * @o:          bnx2x_vlan_mac_obj
+ * @cqe:
+ * @cont:       if true schedule next execution chunk
+ *
+ */
+static int bnx2x_complete_vlan_mac(struct bnx2x *bp,
+                                   struct bnx2x_vlan_mac_obj *o,
+                                   union event_ring_elem *cqe,
+                                   unsigned long *ramrod_flags)
+{
+        struct bnx2x_raw_obj *r = &o->raw;
+        int rc;
+
+        /* Reset pending list */
+        bnx2x_exe_queue_reset_pending(bp, &o->exe_queue);
+
+        /* Clear pending */
+        r->clear_pending(r);
+
+        /* If ramrod failed this is most likely a SW bug */
+        if (cqe->message.error)
+                return -EINVAL;
+
+        /* Run the next bulk of pending commands if requeted */
+        if (test_bit(RAMROD_CONT, ramrod_flags)) {
+                rc = bnx2x_exe_queue_step(bp, &o->exe_queue, ramrod_flags);
+                if (rc < 0)
+                        return rc;
+        }
+
+        /* If there is more work to do return PENDING */
+        if (!bnx2x_exe_queue_empty(&o->exe_queue))
+                return 1;
+
+        return 0;
+}
+
+/**
+ * bnx2x_optimize_vlan_mac - optimize ADD and DEL commands.
+ *
+ * @bp:         device handle
+ * @o:          bnx2x_qable_obj
+ * @elem:       bnx2x_exeq_elem
+ */
+static int bnx2x_optimize_vlan_mac(struct bnx2x *bp,
+                                   union bnx2x_qable_obj *qo,
+                                   struct bnx2x_exeq_elem *elem)
+{
+        struct bnx2x_exeq_elem query, *pos;
+        struct bnx2x_vlan_mac_obj *o = &qo->vlan_mac;
+        struct bnx2x_exe_queue_obj *exeq = &o->exe_queue;
+
+        memcpy(&query, elem, sizeof(query));
+
+        switch (elem->cmd_data.vlan_mac.cmd) {
+        case BNX2X_VLAN_MAC_ADD:
+                query.cmd_data.vlan_mac.cmd = BNX2X_VLAN_MAC_DEL;
+                break;
+        case BNX2X_VLAN_MAC_DEL:
+                query.cmd_data.vlan_mac.cmd = BNX2X_VLAN_MAC_ADD;
+                break;
+        default:
+                /* Don't handle anything other than ADD or DEL */
+                return 0;
+        }
+
+        /* If we found the appropriate element - delete it */
+        pos = exeq->get(exeq, &query);
+        if (pos) {
+
+                /* Return the credit of the optimized command */
+                if (!test_bit(BNX2X_DONT_CONSUME_CAM_CREDIT,
+                              &pos->cmd_data.vlan_mac.vlan_mac_flags)) {
+                        if ((query.cmd_data.vlan_mac.cmd ==
+                             BNX2X_VLAN_MAC_ADD) && !o->put_credit(o)) {
+                                BNX2X_ERR("Failed to return the credit for the "
+                                          "optimized ADD command\n");
+                                return -EINVAL;
+                        } else if (!o->get_credit(o)) { /* VLAN_MAC_DEL */
+                                BNX2X_ERR("Failed to recover the credit from "
+                                          "the optimized DEL command\n");
+                                return -EINVAL;
+                        }
+                }
+
+                DP(BNX2X_MSG_SP, "Optimizing %s command\n",
+                           (elem->cmd_data.vlan_mac.cmd == BNX2X_VLAN_MAC_ADD) ?
+                           "ADD" : "DEL");
+
+                list_del(&pos->link);
+                bnx2x_exe_queue_free_elem(bp, pos);
+                return 1;
+        }
+
+        return 0;
+}
+
+/**
+ * bnx2x_vlan_mac_get_registry_elem - prepare a registry element
+ *
+ * @bp:   device handle
+ * @o:
+ * @elem:
+ * @restore:
+ * @re:
+ *
+ * prepare a registry element according to the current command request.
+ */
+static inline int bnx2x_vlan_mac_get_registry_elem(
+        struct bnx2x *bp,
+        struct bnx2x_vlan_mac_obj *o,
+        struct bnx2x_exeq_elem *elem,
+        bool restore,
+        struct bnx2x_vlan_mac_registry_elem **re)
+{
+        int cmd = elem->cmd_data.vlan_mac.cmd;
+        struct bnx2x_vlan_mac_registry_elem *reg_elem;
+
+        /* Allocate a new registry element if needed. */
+        if (!restore &&
+            ((cmd == BNX2X_VLAN_MAC_ADD) || (cmd == BNX2X_VLAN_MAC_MOVE))) {
+                reg_elem = kzalloc(sizeof(*reg_elem), GFP_ATOMIC);
+                if (!reg_elem)
+                        return -ENOMEM;
+
+                /* Get a new CAM offset */
+                if (!o->get_cam_offset(o, &reg_elem->cam_offset)) {
+                        /*
+                         * This shell never happen, because we have checked the
+                         * CAM availiability in the 'validate'.
+                         */
+                        WARN_ON(1);
+                        kfree(reg_elem);
+                        return -EINVAL;
+                }
+
+                DP(BNX2X_MSG_SP, "Got cam offset %d\n", reg_elem->cam_offset);
+
+                /* Set a VLAN-MAC data */
+                memcpy(&reg_elem->u, &elem->cmd_data.vlan_mac.u,
+                          sizeof(reg_elem->u));
+
+                /* Copy the flags (needed for DEL and RESTORE flows) */
+                reg_elem->vlan_mac_flags =
+                        elem->cmd_data.vlan_mac.vlan_mac_flags;
+        } else /* DEL, RESTORE */
+                reg_elem = o->check_del(o, &elem->cmd_data.vlan_mac.u);
+
+        *re = reg_elem;
+        return 0;
+}
+
+/**
+ * bnx2x_execute_vlan_mac - execute vlan mac command
+ *
+ * @bp:                 device handle
+ * @qo:
+ * @exe_chunk:
+ * @ramrod_flags:
+ *
+ * go and send a ramrod!
+ */
+static int bnx2x_execute_vlan_mac(struct bnx2x *bp,
+                                  union bnx2x_qable_obj *qo,
+                                  struct list_head *exe_chunk,
+                                  unsigned long *ramrod_flags)
+{
+        struct bnx2x_exeq_elem *elem;
+        struct bnx2x_vlan_mac_obj *o = &qo->vlan_mac, *cam_obj;
+        struct bnx2x_raw_obj *r = &o->raw;
+        int rc, idx = 0;
+        bool restore = test_bit(RAMROD_RESTORE, ramrod_flags);
+        bool drv_only = test_bit(RAMROD_DRV_CLR_ONLY, ramrod_flags);
+        struct bnx2x_vlan_mac_registry_elem *reg_elem;
+        int cmd;
+
+        /*
+         * If DRIVER_ONLY execution is requested, cleanup a registry
+         * and exit. Otherwise send a ramrod to FW.
+         */
+        if (!drv_only) {
+                WARN_ON(r->check_pending(r));
+
+                /* Set pending */
+                r->set_pending(r);
+
+                /* Fill tha ramrod data */
+                list_for_each_entry(elem, exe_chunk, link) {
+                        cmd = elem->cmd_data.vlan_mac.cmd;
                         /*
-                         * SI mode defines to accept in promiscuos mode
-                         * only unmatched packets
+                         * We will add to the target object in MOVE command, so
+                         * change the object for a CAM search.
                          */
-                        unmatched_unicast = 1;
-                        accp_all_ucast = 0;
+                        if (cmd == BNX2X_VLAN_MAC_MOVE)
+                                cam_obj = elem->cmd_data.vlan_mac.target_obj;
+                        else
+                                cam_obj = o;
+
+                        rc = bnx2x_vlan_mac_get_registry_elem(bp, cam_obj,
+                                                              elem, restore,
+                                                              &reg_elem);
+                        if (rc)
+                                goto error_exit;
+
+                        WARN_ON(!reg_elem);
+
+                        /* Push a new entry into the registry */
+                        if (!restore &&
+                            ((cmd == BNX2X_VLAN_MAC_ADD) ||
+                            (cmd == BNX2X_VLAN_MAC_MOVE)))
+                                list_add(&reg_elem->link, &cam_obj->head);
+
+                        /* Configure a single command in a ramrod data buffer */
+                        o->set_one_rule(bp, o, elem, idx,
+                                        reg_elem->cam_offset);
+
+                        /* MOVE command consumes 2 entries in the ramrod data */
+                        if (cmd == BNX2X_VLAN_MAC_MOVE)
+                                idx += 2;
+                        else
+                                idx++;
+                }
+
+                /* Commit the data writes towards the memory */
+                mb();
+
+                rc = bnx2x_sp_post(bp, o->ramrod_cmd, r->cid,
+                                   U64_HI(r->rdata_mapping),
+                                   U64_LO(r->rdata_mapping),
+                                   ETH_CONNECTION_TYPE);
+                if (rc)
+                        goto error_exit;
+        }
+
+        /* Now, when we are done with the ramrod - clean up the registry */
+        list_for_each_entry(elem, exe_chunk, link) {
+                cmd = elem->cmd_data.vlan_mac.cmd;
+                if ((cmd == BNX2X_VLAN_MAC_DEL) ||
+                    (cmd == BNX2X_VLAN_MAC_MOVE)) {
+                        reg_elem = o->check_del(o, &elem->cmd_data.vlan_mac.u);
+
+                        WARN_ON(!reg_elem);
+
+                        o->put_cam_offset(o, reg_elem->cam_offset);
+                        list_del(&reg_elem->link);
+                        kfree(reg_elem);
+                }
+        }
+
+        if (!drv_only)
+                return 1;
+        else
+                return 0;
+
+error_exit:
+        r->clear_pending(r);
+
+        /* Cleanup a registry in case of a failure */
+        list_for_each_entry(elem, exe_chunk, link) {
+                cmd = elem->cmd_data.vlan_mac.cmd;
+
+                if (cmd == BNX2X_VLAN_MAC_MOVE)
+                        cam_obj = elem->cmd_data.vlan_mac.target_obj;
+                else
+                        cam_obj = o;
+
+                /* Delete all newly added above entries */
+                if (!restore &&
+                    ((cmd == BNX2X_VLAN_MAC_ADD) ||
+                    (cmd == BNX2X_VLAN_MAC_MOVE))) {
+                        reg_elem = o->check_del(cam_obj,
+                                                &elem->cmd_data.vlan_mac.u);
+                        if (reg_elem) {
+                                list_del(&reg_elem->link);
+                                kfree(reg_elem);
+                        }
                 }
         }
-        if (filters & BNX2X_ACCEPT_UNICAST) {
+
+        return rc;
+}
+
+static inline int bnx2x_vlan_mac_push_new_cmd(
+        struct bnx2x *bp,
+        struct bnx2x_vlan_mac_ramrod_params *p)
+{
+        struct bnx2x_exeq_elem *elem;
+        struct bnx2x_vlan_mac_obj *o = p->vlan_mac_obj;
+        bool restore = test_bit(RAMROD_RESTORE, &p->ramrod_flags);
+
+        /* Allocate the execution queue element */
+        elem = bnx2x_exe_queue_alloc_elem(bp);
+        if (!elem)
+                return -ENOMEM;
+
+        /* Set the command 'length' */
+        switch (p->user_req.cmd) {
+        case BNX2X_VLAN_MAC_MOVE:
+                elem->cmd_len = 2;
+                break;
+        default:
+                elem->cmd_len = 1;
+        }
+
+        /* Fill the object specific info */
+        memcpy(&elem->cmd_data.vlan_mac, &p->user_req, sizeof(p->user_req));
+
+        /* Try to add a new command to the pending list */
+        return bnx2x_exe_queue_add(bp, &o->exe_queue, elem, restore);
+}
+
+/**
+ * bnx2x_config_vlan_mac - configure VLAN/MAC/VLAN_MAC filtering rules.
+ *
+ * @bp:   device handle
+ * @p:
+ *
+ */
+int bnx2x_config_vlan_mac(
+        struct bnx2x *bp,
+        struct bnx2x_vlan_mac_ramrod_params *p)
+{
+        int rc = 0;
+        struct bnx2x_vlan_mac_obj *o = p->vlan_mac_obj;
+        unsigned long *ramrod_flags = &p->ramrod_flags;
+        bool cont = test_bit(RAMROD_CONT, ramrod_flags);
+        struct bnx2x_raw_obj *raw = &o->raw;
+
+        /*
+         * Add new elements to the execution list for commands that require it.
+         */
+        if (!cont) {
+                rc = bnx2x_vlan_mac_push_new_cmd(bp, p);
+                if (rc)
+                        return rc;
+        }
+
+        /*
+         * If nothing will be executed further in this iteration we want to
+         * return PENDING if there are pending commands
+         */
+        if (!bnx2x_exe_queue_empty(&o->exe_queue))
+                rc = 1;
+
+        /* Execute commands if required */
+        if (cont || test_bit(RAMROD_EXEC, ramrod_flags) ||
+            test_bit(RAMROD_COMP_WAIT, ramrod_flags)) {
+                rc = bnx2x_exe_queue_step(bp, &o->exe_queue, ramrod_flags);
+                if (rc < 0)
+                        return rc;
+        }
+
+        /*
+         * RAMROD_COMP_WAIT is a superset of RAMROD_EXEC. If it was set
+         * then user want to wait until the last command is done.
+         */
+        if (test_bit(RAMROD_COMP_WAIT, &p->ramrod_flags)) {
+                /*
+                 * Wait maximum for the current exe_queue length iterations plus
+                 * one (for the current pending command).
+                 */
+                int max_iterations = bnx2x_exe_queue_length(&o->exe_queue) + 1;
+
+                while (!bnx2x_exe_queue_empty(&o->exe_queue) &&
+                       max_iterations--) {
+
+                        /* Wait for the current command to complete */
+                        rc = raw->wait_comp(bp, raw);
+                        if (rc)
+                                return rc;
+
+                        /* Make a next step */
+                        rc = bnx2x_exe_queue_step(bp, &o->exe_queue,
+                                                  ramrod_flags);
+                        if (rc < 0)
+                                return rc;
+                }
+
+                return 0;
+        }
+
+        return rc;
+}
+
+
+
+/**
+ * bnx2x_vlan_mac_del_all - delete elements with given vlan_mac_flags spec
+ *
+ * @bp:                 device handle
+ * @o:
+ * @vlan_mac_flags:
+ * @ramrod_flags:       execution flags to be used for this deletion
+ *
+ * if the last operation has completed successfully and there are no
+ * moreelements left, positive value if the last operation has completed
+ * successfully and there are more previously configured elements, negative
+ * value is current operation has failed.
+ */
+static int bnx2x_vlan_mac_del_all(struct bnx2x *bp,
+                                  struct bnx2x_vlan_mac_obj *o,
+                                  unsigned long *vlan_mac_flags,
+                                  unsigned long *ramrod_flags)
+{
+        struct bnx2x_vlan_mac_registry_elem *pos = NULL;
+        int rc = 0;
+        struct bnx2x_vlan_mac_ramrod_params p;
+        struct bnx2x_exe_queue_obj *exeq = &o->exe_queue;
+        struct bnx2x_exeq_elem *exeq_pos, *exeq_pos_n;
+
+        /* Clear pending commands first */
+
+        spin_lock_bh(&exeq->lock);
+
+        list_for_each_entry_safe(exeq_pos, exeq_pos_n, &exeq->exe_queue, link) {
+                if (exeq_pos->cmd_data.vlan_mac.vlan_mac_flags ==
+                    *vlan_mac_flags)
+                        list_del(&exeq_pos->link);
+        }
+
+        spin_unlock_bh(&exeq->lock);
+
+        /* Prepare a command request */
+        memset(&p, 0, sizeof(p));
+        p.vlan_mac_obj = o;
+        p.ramrod_flags = *ramrod_flags;
+        p.user_req.cmd = BNX2X_VLAN_MAC_DEL;
+
+        /*
+         * Add all but the last VLAN-MAC to the execution queue without actually
+         * execution anything.
+         */
+        __clear_bit(RAMROD_COMP_WAIT, &p.ramrod_flags);
+        __clear_bit(RAMROD_EXEC, &p.ramrod_flags);
+        __clear_bit(RAMROD_CONT, &p.ramrod_flags);
+
+        list_for_each_entry(pos, &o->head, link) {
+                if (pos->vlan_mac_flags == *vlan_mac_flags) {
+                        p.user_req.vlan_mac_flags = pos->vlan_mac_flags;
+                        memcpy(&p.user_req.u, &pos->u, sizeof(pos->u));
+                        rc = bnx2x_config_vlan_mac(bp, &p);
+                        if (rc < 0) {
+                                BNX2X_ERR("Failed to add a new DEL command\n");
+                                return rc;
+                        }
+                }
+        }
+
+        p.ramrod_flags = *ramrod_flags;
+        __set_bit(RAMROD_CONT, &p.ramrod_flags);
+
+        return bnx2x_config_vlan_mac(bp, &p);
+}
+
+static inline void bnx2x_init_raw_obj(struct bnx2x_raw_obj *raw, u8 cl_id,
+        u32 cid, u8 func_id, void *rdata, dma_addr_t rdata_mapping, int state,
+        unsigned long *pstate, bnx2x_obj_type type)
+{
+        raw->func_id = func_id;
+        raw->cid = cid;
+        raw->cl_id = cl_id;
+        raw->rdata = rdata;
+        raw->rdata_mapping = rdata_mapping;
+        raw->state = state;
+        raw->pstate = pstate;
+        raw->obj_type = type;
+        raw->check_pending = bnx2x_raw_check_pending;
+        raw->clear_pending = bnx2x_raw_clear_pending;
+        raw->set_pending = bnx2x_raw_set_pending;
+        raw->wait_comp = bnx2x_raw_wait;
+}
+
+static inline void bnx2x_init_vlan_mac_common(struct bnx2x_vlan_mac_obj *o,
+        u8 cl_id, u32 cid, u8 func_id, void *rdata, dma_addr_t rdata_mapping,
+        int state, unsigned long *pstate, bnx2x_obj_type type,
+        struct bnx2x_credit_pool_obj *macs_pool,
+        struct bnx2x_credit_pool_obj *vlans_pool)
+{
+        INIT_LIST_HEAD(&o->head);
+
+        o->macs_pool = macs_pool;
+        o->vlans_pool = vlans_pool;
+
+        o->delete_all = bnx2x_vlan_mac_del_all;
+        o->restore = bnx2x_vlan_mac_restore;
+        o->complete = bnx2x_complete_vlan_mac;
+        o->wait = bnx2x_wait_vlan_mac;
+
+        bnx2x_init_raw_obj(&o->raw, cl_id, cid, func_id, rdata, rdata_mapping,
+                           state, pstate, type);
+}
+
+
+void bnx2x_init_mac_obj(struct bnx2x *bp,
+                        struct bnx2x_vlan_mac_obj *mac_obj,
+                        u8 cl_id, u32 cid, u8 func_id, void *rdata,
+                        dma_addr_t rdata_mapping, int state,
+                        unsigned long *pstate, bnx2x_obj_type type,
+                        struct bnx2x_credit_pool_obj *macs_pool)
+{
+        union bnx2x_qable_obj *qable_obj = (union bnx2x_qable_obj *)mac_obj;
+
+        bnx2x_init_vlan_mac_common(mac_obj, cl_id, cid, func_id, rdata,
+                                   rdata_mapping, state, pstate, type,
+                                   macs_pool, NULL);
+
+        /* CAM credit pool handling */
+        mac_obj->get_credit = bnx2x_get_credit_mac;
+        mac_obj->put_credit = bnx2x_put_credit_mac;
+        mac_obj->get_cam_offset = bnx2x_get_cam_offset_mac;
+        mac_obj->put_cam_offset = bnx2x_put_cam_offset_mac;
+
+        if (CHIP_IS_E1x(bp)) {
+                mac_obj->set_one_rule      = bnx2x_set_one_mac_e1x;
+                mac_obj->check_del         = bnx2x_check_mac_del;
+                mac_obj->check_add         = bnx2x_check_mac_add;
+                mac_obj->check_move        = bnx2x_check_move_always_err;
+                mac_obj->ramrod_cmd        = RAMROD_CMD_ID_ETH_SET_MAC;
+
+                /* Exe Queue */
+                bnx2x_exe_queue_init(bp,
+                                     &mac_obj->exe_queue, 1, qable_obj,
+                                     bnx2x_validate_vlan_mac,
+                                     bnx2x_optimize_vlan_mac,
+                                     bnx2x_execute_vlan_mac,
+                                     bnx2x_exeq_get_mac);
+        } else {
+                mac_obj->set_one_rule      = bnx2x_set_one_mac_e2;
+                mac_obj->check_del         = bnx2x_check_mac_del;
+                mac_obj->check_add         = bnx2x_check_mac_add;
+                mac_obj->check_move        = bnx2x_check_move;
+                mac_obj->ramrod_cmd        =
+                        RAMROD_CMD_ID_ETH_CLASSIFICATION_RULES;
+
+                /* Exe Queue */
+                bnx2x_exe_queue_init(bp,
+                                     &mac_obj->exe_queue, CLASSIFY_RULES_COUNT,
+                                     qable_obj, bnx2x_validate_vlan_mac,
+                                     bnx2x_optimize_vlan_mac,
+                                     bnx2x_execute_vlan_mac,
+                                     bnx2x_exeq_get_mac);
+        }
+}
+
+void bnx2x_init_vlan_obj(struct bnx2x *bp,
+                         struct bnx2x_vlan_mac_obj *vlan_obj,
+                         u8 cl_id, u32 cid, u8 func_id, void *rdata,
+                         dma_addr_t rdata_mapping, int state,
+                         unsigned long *pstate, bnx2x_obj_type type,
+                         struct bnx2x_credit_pool_obj *vlans_pool)
+{
+        union bnx2x_qable_obj *qable_obj = (union bnx2x_qable_obj *)vlan_obj;
+
+        bnx2x_init_vlan_mac_common(vlan_obj, cl_id, cid, func_id, rdata,
+                                   rdata_mapping, state, pstate, type, NULL,
+                                   vlans_pool);
+
+        vlan_obj->get_credit = bnx2x_get_credit_vlan;
+        vlan_obj->put_credit = bnx2x_put_credit_vlan;
+        vlan_obj->get_cam_offset = bnx2x_get_cam_offset_vlan;
+        vlan_obj->put_cam_offset = bnx2x_put_cam_offset_vlan;
+
+        if (CHIP_IS_E1x(bp)) {
+                BNX2X_ERR("Do not support chips others than E2 and newer\n");
+                BUG();
+        } else {
+                vlan_obj->set_one_rule      = bnx2x_set_one_vlan_e2;
+                vlan_obj->check_del         = bnx2x_check_vlan_del;
+                vlan_obj->check_add         = bnx2x_check_vlan_add;
+                vlan_obj->check_move        = bnx2x_check_move;
+                vlan_obj->ramrod_cmd        =
+                        RAMROD_CMD_ID_ETH_CLASSIFICATION_RULES;
+
+                /* Exe Queue */
+                bnx2x_exe_queue_init(bp,
+                                     &vlan_obj->exe_queue, CLASSIFY_RULES_COUNT,
+                                     qable_obj, bnx2x_validate_vlan_mac,
+                                     bnx2x_optimize_vlan_mac,
+                                     bnx2x_execute_vlan_mac,
+                                     bnx2x_exeq_get_vlan);
+        }
+}
+
+void bnx2x_init_vlan_mac_obj(struct bnx2x *bp,
+                             struct bnx2x_vlan_mac_obj *vlan_mac_obj,
+                             u8 cl_id, u32 cid, u8 func_id, void *rdata,
+                             dma_addr_t rdata_mapping, int state,
+                             unsigned long *pstate, bnx2x_obj_type type,
+                             struct bnx2x_credit_pool_obj *macs_pool,
+                             struct bnx2x_credit_pool_obj *vlans_pool)
+{
+        union bnx2x_qable_obj *qable_obj =
+                (union bnx2x_qable_obj *)vlan_mac_obj;
+
+        bnx2x_init_vlan_mac_common(vlan_mac_obj, cl_id, cid, func_id, rdata,
+                                   rdata_mapping, state, pstate, type,
+                                   macs_pool, vlans_pool);
+
+        /* CAM pool handling */
+        vlan_mac_obj->get_credit = bnx2x_get_credit_vlan_mac;
+        vlan_mac_obj->put_credit = bnx2x_put_credit_vlan_mac;
+        /*
+         * CAM offset is relevant for 57710 and 57711 chips only which have a
+         * single CAM for both MACs and VLAN-MAC pairs. So the offset
+         * will be taken from MACs' pool object only.
+         */
+        vlan_mac_obj->get_cam_offset = bnx2x_get_cam_offset_mac;
+        vlan_mac_obj->put_cam_offset = bnx2x_put_cam_offset_mac;
+
+        if (CHIP_IS_E1(bp)) {
+                BNX2X_ERR("Do not support chips others than E2\n");
+                BUG();
+        } else if (CHIP_IS_E1H(bp)) {
+                vlan_mac_obj->set_one_rule      = bnx2x_set_one_vlan_mac_e1h;
+                vlan_mac_obj->check_del         = bnx2x_check_vlan_mac_del;
+                vlan_mac_obj->check_add         = bnx2x_check_vlan_mac_add;
+                vlan_mac_obj->check_move        = bnx2x_check_move_always_err;
+                vlan_mac_obj->ramrod_cmd        = RAMROD_CMD_ID_ETH_SET_MAC;
+
+                /* Exe Queue */
+                bnx2x_exe_queue_init(bp,
+                                     &vlan_mac_obj->exe_queue, 1, qable_obj,
+                                     bnx2x_validate_vlan_mac,
+                                     bnx2x_optimize_vlan_mac,
+                                     bnx2x_execute_vlan_mac,
+                                     bnx2x_exeq_get_vlan_mac);
+        } else {
+                vlan_mac_obj->set_one_rule      = bnx2x_set_one_vlan_mac_e2;
+                vlan_mac_obj->check_del         = bnx2x_check_vlan_mac_del;
+                vlan_mac_obj->check_add         = bnx2x_check_vlan_mac_add;
+                vlan_mac_obj->check_move        = bnx2x_check_move;
+                vlan_mac_obj->ramrod_cmd        =
+                        RAMROD_CMD_ID_ETH_CLASSIFICATION_RULES;
+
+                /* Exe Queue */
+                bnx2x_exe_queue_init(bp,
+                                     &vlan_mac_obj->exe_queue,
+                                     CLASSIFY_RULES_COUNT,
+                                     qable_obj, bnx2x_validate_vlan_mac,
+                                     bnx2x_optimize_vlan_mac,
+                                     bnx2x_execute_vlan_mac,
+                                     bnx2x_exeq_get_vlan_mac);
+        }
+
+}
+
+/* RX_MODE verbs: DROP_ALL/ACCEPT_ALL/ACCEPT_ALL_MULTI/ACCEPT_ALL_VLAN/NORMAL */
+static inline void __storm_memset_mac_filters(struct bnx2x *bp,
+                        struct tstorm_eth_mac_filter_config *mac_filters,
+                        u16 pf_id)
+{
+        size_t size = sizeof(struct tstorm_eth_mac_filter_config);
+
+        u32 addr = BAR_TSTRORM_INTMEM +
+                        TSTORM_MAC_FILTER_CONFIG_OFFSET(pf_id);
+
+        __storm_memset_struct(bp, addr, size, (u32 *)mac_filters);
+}
+
+static int bnx2x_set_rx_mode_e1x(struct bnx2x *bp,
+                                 struct bnx2x_rx_mode_ramrod_params *p)
+{
+        /* update the bp MAC filter structure  */
+        u32 mask = (1 << p->cl_id);
+
+        struct tstorm_eth_mac_filter_config *mac_filters =
+                (struct tstorm_eth_mac_filter_config *)p->rdata;
+
+        /* initial seeting is drop-all */
+        u8 drop_all_ucast = 1, drop_all_mcast = 1;
+        u8 accp_all_ucast = 0, accp_all_bcast = 0, accp_all_mcast = 0;
+        u8 unmatched_unicast = 0;
+
+    /* In e1x there we only take into account rx acceot flag since tx switching
+     * isn't enabled. */
+        if (test_bit(BNX2X_ACCEPT_UNICAST, &p->rx_accept_flags))
                 /* accept matched ucast */
                 drop_all_ucast = 0;
-        }
-        if (filters & BNX2X_ACCEPT_MULTICAST)
+
+        if (test_bit(BNX2X_ACCEPT_MULTICAST, &p->rx_accept_flags))
                 /* accept matched mcast */
                 drop_all_mcast = 0;
 
-        if (filters & BNX2X_ACCEPT_ALL_UNICAST) {
+        if (test_bit(BNX2X_ACCEPT_ALL_UNICAST, &p->rx_accept_flags)) {
                 /* accept all mcast */
                 drop_all_ucast = 0;
                 accp_all_ucast = 1;
         }
-        if (filters & BNX2X_ACCEPT_ALL_MULTICAST) {
+        if (test_bit(BNX2X_ACCEPT_ALL_MULTICAST, &p->rx_accept_flags)) {
                 /* accept all mcast */
                 drop_all_mcast = 0;
                 accp_all_mcast = 1;
         }
-        if (filters & BNX2X_ACCEPT_BROADCAST) {
+        if (test_bit(BNX2X_ACCEPT_BROADCAST, &p->rx_accept_flags))
                 /* accept (all) bcast */
-                drop_all_bcast = 0;
                 accp_all_bcast = 1;
+        if (test_bit(BNX2X_ACCEPT_UNMATCHED, &p->rx_accept_flags))
+                /* accept unmatched unicasts */
+                unmatched_unicast = 1;
+
+        mac_filters->ucast_drop_all = drop_all_ucast ?
+                mac_filters->ucast_drop_all | mask :
+                mac_filters->ucast_drop_all & ~mask;
+
+        mac_filters->mcast_drop_all = drop_all_mcast ?
+                mac_filters->mcast_drop_all | mask :
+                mac_filters->mcast_drop_all & ~mask;
+
+        mac_filters->ucast_accept_all = accp_all_ucast ?
+                mac_filters->ucast_accept_all | mask :
+                mac_filters->ucast_accept_all & ~mask;
+
+        mac_filters->mcast_accept_all = accp_all_mcast ?
+                mac_filters->mcast_accept_all | mask :
+                mac_filters->mcast_accept_all & ~mask;
+
+        mac_filters->bcast_accept_all = accp_all_bcast ?
+                mac_filters->bcast_accept_all | mask :
+                mac_filters->bcast_accept_all & ~mask;
+
+        mac_filters->unmatched_unicast = unmatched_unicast ?
+                mac_filters->unmatched_unicast | mask :
+                mac_filters->unmatched_unicast & ~mask;
+
+        DP(BNX2X_MSG_SP, "drop_ucast 0x%x\ndrop_mcast 0x%x\n accp_ucast 0x%x\n"
+                         "accp_mcast 0x%x\naccp_bcast 0x%x\n",
+                         mac_filters->ucast_drop_all,
+                         mac_filters->mcast_drop_all,
+                         mac_filters->ucast_accept_all,
+                         mac_filters->mcast_accept_all,
+                         mac_filters->bcast_accept_all);
+
+        /* write the MAC filter structure*/
+        __storm_memset_mac_filters(bp, mac_filters, p->func_id);
+
+        /* The operation is completed */
+        clear_bit(p->state, p->pstate);
+        smp_mb__after_clear_bit();
+
+        return 0;
+}
+
+/* Setup ramrod data */
+static inline void bnx2x_rx_mode_set_rdata_hdr_e2(u32 cid,
+                                struct eth_classify_header *hdr,
+                                u8 rule_cnt)
+{
+        hdr->echo = cid;
+        hdr->rule_cnt = rule_cnt;
+}
+
+static inline void bnx2x_rx_mode_set_cmd_state_e2(struct bnx2x *bp,
+                                unsigned long accept_flags,
+                                struct eth_filter_rules_cmd *cmd,
+                                bool clear_accept_all)
+{
+        u16 state;
+
+        /* start with 'drop-all' */
+        state = ETH_FILTER_RULES_CMD_UCAST_DROP_ALL |
+                ETH_FILTER_RULES_CMD_MCAST_DROP_ALL;
+
+        if (accept_flags) {
+                if (test_bit(BNX2X_ACCEPT_UNICAST, &accept_flags))
+                        state &= ~ETH_FILTER_RULES_CMD_UCAST_DROP_ALL;
+
+                if (test_bit(BNX2X_ACCEPT_MULTICAST, &accept_flags))
+                        state &= ~ETH_FILTER_RULES_CMD_MCAST_DROP_ALL;
+
+                if (test_bit(BNX2X_ACCEPT_ALL_UNICAST, &accept_flags)) {
+                        state &= ~ETH_FILTER_RULES_CMD_UCAST_DROP_ALL;
+                        state |= ETH_FILTER_RULES_CMD_UCAST_ACCEPT_ALL;
+                }
+
+                if (test_bit(BNX2X_ACCEPT_ALL_MULTICAST, &accept_flags)) {
+                        state |= ETH_FILTER_RULES_CMD_MCAST_ACCEPT_ALL;
+                        state &= ~ETH_FILTER_RULES_CMD_MCAST_DROP_ALL;
+                }
+                if (test_bit(BNX2X_ACCEPT_BROADCAST, &accept_flags))
+                        state |= ETH_FILTER_RULES_CMD_BCAST_ACCEPT_ALL;
+
+                if (test_bit(BNX2X_ACCEPT_UNMATCHED, &accept_flags)) {
+                        state &= ~ETH_FILTER_RULES_CMD_UCAST_DROP_ALL;
+                        state |= ETH_FILTER_RULES_CMD_UCAST_ACCEPT_UNMATCHED;
+                }
+                if (test_bit(BNX2X_ACCEPT_ANY_VLAN, &accept_flags))
+                        state |= ETH_FILTER_RULES_CMD_ACCEPT_ANY_VLAN;
+        }
+
+        /* Clear ACCEPT_ALL_XXX flags for FCoE L2 Queue */
+        if (clear_accept_all) {
+                state &= ~ETH_FILTER_RULES_CMD_MCAST_ACCEPT_ALL;
+                state &= ~ETH_FILTER_RULES_CMD_BCAST_ACCEPT_ALL;
+                state &= ~ETH_FILTER_RULES_CMD_UCAST_ACCEPT_ALL;
+                state &= ~ETH_FILTER_RULES_CMD_UCAST_ACCEPT_UNMATCHED;
+        }
+
+        cmd->state = cpu_to_le16(state);
+
+}
+
+static int bnx2x_set_rx_mode_e2(struct bnx2x *bp,
+                                struct bnx2x_rx_mode_ramrod_params *p)
+{
+        struct eth_filter_rules_ramrod_data *data = p->rdata;
+        int rc;
+        u8 rule_idx = 0;
+
+        /* Reset the ramrod data buffer */
+        memset(data, 0, sizeof(*data));
+
+        /* Setup ramrod data */
+
+        /* Tx (internal switching) */
+        if (test_bit(RAMROD_TX, &p->ramrod_flags)) {
+                data->rules[rule_idx].client_id = p->cl_id;
+                data->rules[rule_idx].func_id = p->func_id;
+
+                data->rules[rule_idx].cmd_general_data =
+                        ETH_FILTER_RULES_CMD_TX_CMD;
+
+                bnx2x_rx_mode_set_cmd_state_e2(bp, p->tx_accept_flags,
+                        &(data->rules[rule_idx++]), false);
+        }
+
+        /* Rx */
+        if (test_bit(RAMROD_RX, &p->ramrod_flags)) {
+                data->rules[rule_idx].client_id = p->cl_id;
+                data->rules[rule_idx].func_id = p->func_id;
+
+                data->rules[rule_idx].cmd_general_data =
+                        ETH_FILTER_RULES_CMD_RX_CMD;
+
+                bnx2x_rx_mode_set_cmd_state_e2(bp, p->rx_accept_flags,
+                        &(data->rules[rule_idx++]), false);
+        }
+
+
+        /*
+         * If FCoE Queue configuration has been requested configure the Rx and
+         * internal switching modes for this queue in separate rules.
+         *
+         * FCoE queue shell never be set to ACCEPT_ALL packets of any sort:
+         * MCAST_ALL, UCAST_ALL, BCAST_ALL and UNMATCHED.
+         */
+        if (test_bit(BNX2X_RX_MODE_FCOE_ETH, &p->rx_mode_flags)) {
+                /*  Tx (internal switching) */
+                if (test_bit(RAMROD_TX, &p->ramrod_flags)) {
+                        data->rules[rule_idx].client_id = bnx2x_fcoe(bp, cl_id);
+                        data->rules[rule_idx].func_id = p->func_id;
+
+                        data->rules[rule_idx].cmd_general_data =
+                                                ETH_FILTER_RULES_CMD_TX_CMD;
+
+                        bnx2x_rx_mode_set_cmd_state_e2(bp, p->tx_accept_flags,
+                                                     &(data->rules[rule_idx++]),
+                                                       true);
+                }
+
+                /* Rx */
+                if (test_bit(RAMROD_RX, &p->ramrod_flags)) {
+                        data->rules[rule_idx].client_id = bnx2x_fcoe(bp, cl_id);
+                        data->rules[rule_idx].func_id = p->func_id;
+
+                        data->rules[rule_idx].cmd_general_data =
+                                                ETH_FILTER_RULES_CMD_RX_CMD;
+
+                        bnx2x_rx_mode_set_cmd_state_e2(bp, p->rx_accept_flags,
+                                                     &(data->rules[rule_idx++]),
+                                                       true);
+                }
         }
 
-        bp->mac_filters.ucast_drop_all = drop_all_ucast ?
-                bp->mac_filters.ucast_drop_all | mask :
-                bp->mac_filters.ucast_drop_all & ~mask;
+        /*
+         * Set the ramrod header (most importantly - number of rules to
+         * configure).
+         */
+        bnx2x_rx_mode_set_rdata_hdr_e2(p->cid, &data->header, rule_idx);
+
+        DP(BNX2X_MSG_SP, "About to configure %d rules, rx_accept_flags 0x%lx, "
+                         "tx_accept_flags 0x%lx\n",
+                         data->header.rule_cnt, p->rx_accept_flags,
+                         p->tx_accept_flags);
+
+        /* Commit writes towards the memory before sending a ramrod */
+        mb();
+
+        /* Send a ramrod */
+        rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_FILTER_RULES, p->cid,
+                           U64_HI(p->rdata_mapping),
+                           U64_LO(p->rdata_mapping),
+                           ETH_CONNECTION_TYPE);
+        if (rc)
+                return rc;
 
-        bp->mac_filters.mcast_drop_all = drop_all_mcast ?
-                bp->mac_filters.mcast_drop_all | mask :
-                bp->mac_filters.mcast_drop_all & ~mask;
+        /* Ramrod completion is pending */
+        return 1;
+}
+
+static int bnx2x_wait_rx_mode_comp_e2(struct bnx2x *bp,
+                                      struct bnx2x_rx_mode_ramrod_params *p)
+{
+        return bnx2x_state_wait(bp, p->state, p->pstate);
+}
+
+static int bnx2x_empty_rx_mode_wait(struct bnx2x *bp,
+                                    struct bnx2x_rx_mode_ramrod_params *p)
+{
+        /* Do nothing */
+        return 0;
+}
+
+int bnx2x_config_rx_mode(struct bnx2x *bp,
+                         struct bnx2x_rx_mode_ramrod_params *p)
+{
+        int rc;
+
+        /* Configure the new classification in the chip */
+        rc = p->rx_mode_obj->config_rx_mode(bp, p);
+        if (rc < 0)
+                return rc;
+
+        /* Wait for a ramrod completion if was requested */
+        if (test_bit(RAMROD_COMP_WAIT, &p->ramrod_flags)) {
+                rc = p->rx_mode_obj->wait_comp(bp, p);
+                if (rc)
+                        return rc;
+        }
 
-        bp->mac_filters.bcast_drop_all = drop_all_bcast ?
-                bp->mac_filters.bcast_drop_all | mask :
-                bp->mac_filters.bcast_drop_all & ~mask;
+        return rc;
+}
 
-        bp->mac_filters.ucast_accept_all = accp_all_ucast ?
-                bp->mac_filters.ucast_accept_all | mask :
-                bp->mac_filters.ucast_accept_all & ~mask;
+void bnx2x_init_rx_mode_obj(struct bnx2x *bp,
+                            struct bnx2x_rx_mode_obj *o)
+{
+        if (CHIP_IS_E1x(bp)) {
+                o->wait_comp      = bnx2x_empty_rx_mode_wait;
+                o->config_rx_mode = bnx2x_set_rx_mode_e1x;
+        } else {
+                o->wait_comp      = bnx2x_wait_rx_mode_comp_e2;
+                o->config_rx_mode = bnx2x_set_rx_mode_e2;
+        }
+}
 
-        bp->mac_filters.mcast_accept_all = accp_all_mcast ?
-                bp->mac_filters.mcast_accept_all | mask :
-                bp->mac_filters.mcast_accept_all & ~mask;
+/********************* Multicast verbs: SET, CLEAR ****************************/
+static inline u8 bnx2x_mcast_bin_from_mac(u8 *mac)
+{
+        return (crc32c_le(0, mac, ETH_ALEN) >> 24) & 0xff;
+}
 
-        bp->mac_filters.bcast_accept_all = accp_all_bcast ?
-                bp->mac_filters.bcast_accept_all | mask :
-                bp->mac_filters.bcast_accept_all & ~mask;
+struct bnx2x_mcast_mac_elem {
+        struct list_head link;
+        u8 mac[ETH_ALEN];
+        u8 pad[2]; /* For a natural alignment of the following buffer */
+};
+
+struct bnx2x_pending_mcast_cmd {
+        struct list_head link;
+        int type; /* BNX2X_MCAST_CMD_X */
+        union {
+                struct list_head macs_head;
+                u32 macs_num; /* Needed for DEL command */
+                int next_bin; /* Needed for RESTORE flow with aprox match */
+        } data;
+
+        bool done; /* set to true, when the command has been handled,
+                    * practically used in 57712 handling only, where one pending
+                    * command may be handled in a few operations. As long as for
+                    * other chips every operation handling is completed in a
+                    * single ramrod, there is no need to utilize this field.
+                    */
+};
+
+static int bnx2x_mcast_wait(struct bnx2x *bp,
+                            struct bnx2x_mcast_obj *o)
+{
+        if (bnx2x_state_wait(bp, o->sched_state, o->raw.pstate) ||
+                        o->raw.wait_comp(bp, &o->raw))
+                return -EBUSY;
 
-        bp->mac_filters.unmatched_unicast = unmatched_unicast ?
-                bp->mac_filters.unmatched_unicast | mask :
-                bp->mac_filters.unmatched_unicast & ~mask;
+        return 0;
 }
 
-void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
+static int bnx2x_mcast_enqueue_cmd(struct bnx2x *bp,
+                                   struct bnx2x_mcast_obj *o,
+                                   struct bnx2x_mcast_ramrod_params *p,
+                                   int cmd)
 {
-        int mode = bp->rx_mode;
-        int port = BP_PORT(bp);
-        u16 cl_id;
-        u32 def_q_filters = 0;
+        int total_sz;
+        struct bnx2x_pending_mcast_cmd *new_cmd;
+        struct bnx2x_mcast_mac_elem *cur_mac = NULL;
+        struct bnx2x_mcast_list_elem *pos;
+        int macs_list_len = ((cmd == BNX2X_MCAST_CMD_ADD) ?
+                             p->mcast_list_len : 0);
+
+        /* If the command is empty ("handle pending commands only"), break */
+        if (!p->mcast_list_len)
+                return 0;
+
+        total_sz = sizeof(*new_cmd) +
+                macs_list_len * sizeof(struct bnx2x_mcast_mac_elem);
+
+        /* Add mcast is called under spin_lock, thus calling with GFP_ATOMIC */
+        new_cmd = kzalloc(total_sz, GFP_ATOMIC);
+
+        if (!new_cmd)
+                return -ENOMEM;
 
-        /* All but management unicast packets should pass to the host as well */
-        u32 llh_mask =
-                NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_BRCST |
-                NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_MLCST |
-                NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_VLAN |
-                NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_NO_VLAN;
+        DP(BNX2X_MSG_SP, "About to enqueue a new %d command. "
+                         "macs_list_len=%d\n", cmd, macs_list_len);
 
-        switch (mode) {
-        case BNX2X_RX_MODE_NONE: /* no Rx */
-                def_q_filters = BNX2X_ACCEPT_NONE;
-#ifdef BCM_CNIC
-                if (!NO_FCOE(bp)) {
-                        cl_id = bnx2x_fcoe(bp, cl_id);
-                        bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_NONE);
+        INIT_LIST_HEAD(&new_cmd->data.macs_head);
+
+        new_cmd->type = cmd;
+        new_cmd->done = false;
+
+        switch (cmd) {
+        case BNX2X_MCAST_CMD_ADD:
+                cur_mac = (struct bnx2x_mcast_mac_elem *)
+                          ((u8 *)new_cmd + sizeof(*new_cmd));
+
+                /* Push the MACs of the current command into the pendig command
+                 * MACs list: FIFO
+                 */
+                list_for_each_entry(pos, &p->mcast_list, link) {
+                        memcpy(cur_mac->mac, pos->mac, ETH_ALEN);
+                        list_add_tail(&cur_mac->link, &new_cmd->data.macs_head);
+                        cur_mac++;
                 }
-#endif
+
                 break;
 
-        case BNX2X_RX_MODE_NORMAL:
-                def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST |
-                                BNX2X_ACCEPT_MULTICAST;
-#ifdef BCM_CNIC
-                if (!NO_FCOE(bp)) {
-                        cl_id = bnx2x_fcoe(bp, cl_id);
-                        bnx2x_rxq_set_mac_filters(bp, cl_id,
-                                                  BNX2X_ACCEPT_UNICAST |
-                                                  BNX2X_ACCEPT_MULTICAST);
-                }
-#endif
+        case BNX2X_MCAST_CMD_DEL:
+                new_cmd->data.macs_num = p->mcast_list_len;
                 break;
 
-        case BNX2X_RX_MODE_ALLMULTI:
-                def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST |
-                                BNX2X_ACCEPT_ALL_MULTICAST;
-#ifdef BCM_CNIC
-                /*
-                 *  Prevent duplication of multicast packets by configuring FCoE
-                 *  L2 Client to receive only matched unicast frames.
+        case BNX2X_MCAST_CMD_RESTORE:
+                new_cmd->data.next_bin = 0;
+                break;
+
+        default:
+                BNX2X_ERR("Unknown command: %d\n", cmd);
+                return -EINVAL;
+        }
+
+        /* Push the new pending command to the tail of the pending list: FIFO */
+        list_add_tail(&new_cmd->link, &o->pending_cmds_head);
+
+        o->set_sched(o);
+
+        return 1;
+}
+
+/**
+ * bnx2x_mcast_get_next_bin - get the next set bin (index)
+ *
+ * @o:
+ * @last:       index to start looking from (including)
+ *
+ * returns the next found (set) bin or a negative value if none is found.
+ */
+static inline int bnx2x_mcast_get_next_bin(struct bnx2x_mcast_obj *o, int last)
+{
+        int i, j, inner_start = last % BIT_VEC64_ELEM_SZ;
+
+        for (i = last / BIT_VEC64_ELEM_SZ; i < BNX2X_MCAST_VEC_SZ; i++) {
+                if (o->registry.aprox_match.vec[i])
+                        for (j = inner_start; j < BIT_VEC64_ELEM_SZ; j++) {
+                                int cur_bit = j + BIT_VEC64_ELEM_SZ * i;
+                                if (BIT_VEC64_TEST_BIT(o->registry.aprox_match.
+                                                       vec, cur_bit)) {
+                                        return cur_bit;
+                                }
+                        }
+                inner_start = 0;
+        }
+
+        /* None found */
+        return -1;
+}
+
+/**
+ * bnx2x_mcast_clear_first_bin - find the first set bin and clear it
+ *
+ * @o:
+ *
+ * returns the index of the found bin or -1 if none is found
+ */
+static inline int bnx2x_mcast_clear_first_bin(struct bnx2x_mcast_obj *o)
+{
+        int cur_bit = bnx2x_mcast_get_next_bin(o, 0);
+
+        if (cur_bit >= 0)
+                BIT_VEC64_CLEAR_BIT(o->registry.aprox_match.vec, cur_bit);
+
+        return cur_bit;
+}
+
+static inline u8 bnx2x_mcast_get_rx_tx_flag(struct bnx2x_mcast_obj *o)
+{
+        struct bnx2x_raw_obj *raw = &o->raw;
+        u8 rx_tx_flag = 0;
+
+        if ((raw->obj_type == BNX2X_OBJ_TYPE_TX) ||
+            (raw->obj_type == BNX2X_OBJ_TYPE_RX_TX))
+                rx_tx_flag |= ETH_MULTICAST_RULES_CMD_TX_CMD;
+
+        if ((raw->obj_type == BNX2X_OBJ_TYPE_RX) ||
+            (raw->obj_type == BNX2X_OBJ_TYPE_RX_TX))
+                rx_tx_flag |= ETH_MULTICAST_RULES_CMD_RX_CMD;
+
+        return rx_tx_flag;
+}
+
+static void bnx2x_mcast_set_one_rule_e2(struct bnx2x *bp,
+                                        struct bnx2x_mcast_obj *o, int idx,
+                                        union bnx2x_mcast_config_data *cfg_data,
+                                        int cmd)
+{
+        struct bnx2x_raw_obj *r = &o->raw;
+        struct eth_multicast_rules_ramrod_data *data =
+                (struct eth_multicast_rules_ramrod_data *)(r->rdata);
+        u8 func_id = r->func_id;
+        u8 rx_tx_add_flag = bnx2x_mcast_get_rx_tx_flag(o);
+        int bin;
+
+        if ((cmd == BNX2X_MCAST_CMD_ADD) || (cmd == BNX2X_MCAST_CMD_RESTORE))
+                rx_tx_add_flag |= ETH_MULTICAST_RULES_CMD_IS_ADD;
+
+        data->rules[idx].cmd_general_data |= rx_tx_add_flag;
+
+        /* Get a bin and update a bins' vector */
+        switch (cmd) {
+        case BNX2X_MCAST_CMD_ADD:
+                bin = bnx2x_mcast_bin_from_mac(cfg_data->mac);
+                BIT_VEC64_SET_BIT(o->registry.aprox_match.vec, bin);
+                break;
+
+        case BNX2X_MCAST_CMD_DEL:
+                /* If there were no more bins to clear
+                 * (bnx2x_mcast_clear_first_bin() returns -1) then we would
+                 * clear any (0xff) bin.
+                 * See bnx2x_mcast_validate_e2() for explanation when it may
+                 * happen.
                  */
-                if (!NO_FCOE(bp)) {
-                        cl_id = bnx2x_fcoe(bp, cl_id);
-                        bnx2x_rxq_set_mac_filters(bp, cl_id,
-                                                  BNX2X_ACCEPT_UNICAST);
-                }
-#endif
+                bin = bnx2x_mcast_clear_first_bin(o);
                 break;
 
-        case BNX2X_RX_MODE_PROMISC:
-                def_q_filters |= BNX2X_PROMISCUOUS_MODE;
-#ifdef BCM_CNIC
-                /*
-                 *  Prevent packets duplication by configuring DROP_ALL for FCoE
-                 *  L2 Client.
+        case BNX2X_MCAST_CMD_RESTORE:
+                bin = cfg_data->bin;
+                break;
+
+        default:
+                BNX2X_ERR("Unknown command: %d\n", cmd);
+                return;
+        }
+
+        DP(BNX2X_MSG_SP, "%s bin %d\n",
+                         ((rx_tx_add_flag & ETH_MULTICAST_RULES_CMD_IS_ADD) ?
+                         "Setting"  : "Clearing"), bin);
+
+        data->rules[idx].bin_id    = (u8)bin;
+        data->rules[idx].func_id   = func_id;
+        data->rules[idx].engine_id = o->engine_id;
+}
+
+/**
+ * bnx2x_mcast_handle_restore_cmd_e2 - restore configuration from the registry
+ *
+ * @bp:         device handle
+ * @o:
+ * @start_bin:  index in the registry to start from (including)
+ * @rdata_idx:  index in the ramrod data to start from
+ *
+ * returns last handled bin index or -1 if all bins have been handled
+ */
+static inline int bnx2x_mcast_handle_restore_cmd_e2(
+        struct bnx2x *bp, struct bnx2x_mcast_obj *o , int start_bin,
+        int *rdata_idx)
+{
+        int cur_bin, cnt = *rdata_idx;
+        union bnx2x_mcast_config_data cfg_data = {0};
+
+        /* go through the registry and configure the bins from it */
+        for (cur_bin = bnx2x_mcast_get_next_bin(o, start_bin); cur_bin >= 0;
+            cur_bin = bnx2x_mcast_get_next_bin(o, cur_bin + 1)) {
+
+                cfg_data.bin = (u8)cur_bin;
+                o->set_one_rule(bp, o, cnt, &cfg_data,
+                                BNX2X_MCAST_CMD_RESTORE);
+
+                cnt++;
+
+                DP(BNX2X_MSG_SP, "About to configure a bin %d\n", cur_bin);
+
+                /* Break if we reached the maximum number
+                 * of rules.
+                 */
+                if (cnt >= o->max_cmd_len)
+                        break;
+        }
+
+        *rdata_idx = cnt;
+
+        return cur_bin;
+}
+
+static inline void bnx2x_mcast_hdl_pending_add_e2(struct bnx2x *bp,
+        struct bnx2x_mcast_obj *o, struct bnx2x_pending_mcast_cmd *cmd_pos,
+        int *line_idx)
+{
+        struct bnx2x_mcast_mac_elem *pmac_pos, *pmac_pos_n;
+        int cnt = *line_idx;
+        union bnx2x_mcast_config_data cfg_data = {0};
+
+        list_for_each_entry_safe(pmac_pos, pmac_pos_n, &cmd_pos->data.macs_head,
+                                 link) {
+
+                cfg_data.mac = &pmac_pos->mac[0];
+                o->set_one_rule(bp, o, cnt, &cfg_data, cmd_pos->type);
+
+                cnt++;
+
+                DP(BNX2X_MSG_SP, "About to configure "BNX2X_MAC_FMT
+                                 " mcast MAC\n",
+                                 BNX2X_MAC_PRN_LIST(pmac_pos->mac));
+
+                list_del(&pmac_pos->link);
+
+                /* Break if we reached the maximum number
+                 * of rules.
+                 */
+                if (cnt >= o->max_cmd_len)
+                        break;
+        }
+
+        *line_idx = cnt;
+
+        /* if no more MACs to configure - we are done */
+        if (list_empty(&cmd_pos->data.macs_head))
+                cmd_pos->done = true;
+}
+
+static inline void bnx2x_mcast_hdl_pending_del_e2(struct bnx2x *bp,
+        struct bnx2x_mcast_obj *o, struct bnx2x_pending_mcast_cmd *cmd_pos,
+        int *line_idx)
+{
+        int cnt = *line_idx;
+
+        while (cmd_pos->data.macs_num) {
+                o->set_one_rule(bp, o, cnt, NULL, cmd_pos->type);
+
+                cnt++;
+
+                cmd_pos->data.macs_num--;
+
+                  DP(BNX2X_MSG_SP, "Deleting MAC. %d left,cnt is %d\n",
+                                   cmd_pos->data.macs_num, cnt);
+
+                /* Break if we reached the maximum
+                 * number of rules.
+                 */
+                if (cnt >= o->max_cmd_len)
+                        break;
+        }
+
+        *line_idx = cnt;
+
+        /* If we cleared all bins - we are done */
+        if (!cmd_pos->data.macs_num)
+                cmd_pos->done = true;
+}
+
+static inline void bnx2x_mcast_hdl_pending_restore_e2(struct bnx2x *bp,
+        struct bnx2x_mcast_obj *o, struct bnx2x_pending_mcast_cmd *cmd_pos,
+        int *line_idx)
+{
+        cmd_pos->data.next_bin = o->hdl_restore(bp, o, cmd_pos->data.next_bin,
+                                                line_idx);
+
+        if (cmd_pos->data.next_bin < 0)
+                /* If o->set_restore returned -1 we are done */
+                cmd_pos->done = true;
+        else
+                /* Start from the next bin next time */
+                cmd_pos->data.next_bin++;
+}
+
+static inline int bnx2x_mcast_handle_pending_cmds_e2(struct bnx2x *bp,
+                                struct bnx2x_mcast_ramrod_params *p)
+{
+        struct bnx2x_pending_mcast_cmd *cmd_pos, *cmd_pos_n;
+        int cnt = 0;
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
+
+        list_for_each_entry_safe(cmd_pos, cmd_pos_n, &o->pending_cmds_head,
+                                 link) {
+                switch (cmd_pos->type) {
+                case BNX2X_MCAST_CMD_ADD:
+                        bnx2x_mcast_hdl_pending_add_e2(bp, o, cmd_pos, &cnt);
+                        break;
+
+                case BNX2X_MCAST_CMD_DEL:
+                        bnx2x_mcast_hdl_pending_del_e2(bp, o, cmd_pos, &cnt);
+                        break;
+
+                case BNX2X_MCAST_CMD_RESTORE:
+                        bnx2x_mcast_hdl_pending_restore_e2(bp, o, cmd_pos,
+                                                           &cnt);
+                        break;
+
+                default:
+                        BNX2X_ERR("Unknown command: %d\n", cmd_pos->type);
+                        return -EINVAL;
+                }
+
+                /* If the command has been completed - remove it from the list
+                 * and free the memory
                  */
-                if (!NO_FCOE(bp)) {
-                        cl_id = bnx2x_fcoe(bp, cl_id);
-                        bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_NONE);
+                if (cmd_pos->done) {
+                        list_del(&cmd_pos->link);
+                        kfree(cmd_pos);
                 }
-#endif
-                /* pass management unicast packets as well */
-                llh_mask |= NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_UNCST;
+
+                /* Break if we reached the maximum number of rules */
+                if (cnt >= o->max_cmd_len)
+                        break;
+        }
+
+        return cnt;
+}
+
+static inline void bnx2x_mcast_hdl_add(struct bnx2x *bp,
+        struct bnx2x_mcast_obj *o, struct bnx2x_mcast_ramrod_params *p,
+        int *line_idx)
+{
+        struct bnx2x_mcast_list_elem *mlist_pos;
+        union bnx2x_mcast_config_data cfg_data = {0};
+        int cnt = *line_idx;
+
+        list_for_each_entry(mlist_pos, &p->mcast_list, link) {
+                cfg_data.mac = mlist_pos->mac;
+                o->set_one_rule(bp, o, cnt, &cfg_data, BNX2X_MCAST_CMD_ADD);
+
+                cnt++;
+
+                DP(BNX2X_MSG_SP, "About to configure "BNX2X_MAC_FMT
+                                 " mcast MAC\n",
+                                 BNX2X_MAC_PRN_LIST(mlist_pos->mac));
+        }
+
+        *line_idx = cnt;
+}
+
+static inline void bnx2x_mcast_hdl_del(struct bnx2x *bp,
+        struct bnx2x_mcast_obj *o, struct bnx2x_mcast_ramrod_params *p,
+        int *line_idx)
+{
+        int cnt = *line_idx, i;
+
+        for (i = 0; i < p->mcast_list_len; i++) {
+                o->set_one_rule(bp, o, cnt, NULL, BNX2X_MCAST_CMD_DEL);
+
+                cnt++;
+
+                DP(BNX2X_MSG_SP, "Deleting MAC. %d left\n",
+                                 p->mcast_list_len - i - 1);
+        }
+
+        *line_idx = cnt;
+}
+
+/**
+ * bnx2x_mcast_handle_current_cmd -
+ *
+ * @bp:         device handle
+ * @p:
+ * @cmd:
+ * @start_cnt:  first line in the ramrod data that may be used
+ *
+ * This function is called iff there is enough place for the current command in
+ * the ramrod data.
+ * Returns number of lines filled in the ramrod data in total.
+ */
+static inline int bnx2x_mcast_handle_current_cmd(struct bnx2x *bp,
+                        struct bnx2x_mcast_ramrod_params *p, int cmd,
+                        int start_cnt)
+{
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
+        int cnt = start_cnt;
+
+        DP(BNX2X_MSG_SP, "p->mcast_list_len=%d\n", p->mcast_list_len);
+
+        switch (cmd) {
+        case BNX2X_MCAST_CMD_ADD:
+                bnx2x_mcast_hdl_add(bp, o, p, &cnt);
+                break;
+
+        case BNX2X_MCAST_CMD_DEL:
+                bnx2x_mcast_hdl_del(bp, o, p, &cnt);
+                break;
+
+        case BNX2X_MCAST_CMD_RESTORE:
+                o->hdl_restore(bp, o, 0, &cnt);
                 break;
 
         default:
-                BNX2X_ERR("BAD rx mode (%d)\n", mode);
+                BNX2X_ERR("Unknown command: %d\n", cmd);
+                return -EINVAL;
+        }
+
+        /* The current command has been handled */
+        p->mcast_list_len = 0;
+
+        return cnt;
+}
+
+static int bnx2x_mcast_validate_e2(struct bnx2x *bp,
+                                   struct bnx2x_mcast_ramrod_params *p,
+                                   int cmd)
+{
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
+        int reg_sz = o->get_registry_size(o);
+
+        switch (cmd) {
+        /* DEL command deletes all currently configured MACs */
+        case BNX2X_MCAST_CMD_DEL:
+                o->set_registry_size(o, 0);
+                /* Don't break */
+
+        /* RESTORE command will restore the entire multicast configuration */
+        case BNX2X_MCAST_CMD_RESTORE:
+                /* Here we set the approximate amount of work to do, which in
+                 * fact may be only less as some MACs in postponed ADD
+                 * command(s) scheduled before this command may fall into
+                 * the same bin and the actual number of bins set in the
+                 * registry would be less than we estimated here. See
+                 * bnx2x_mcast_set_one_rule_e2() for further details.
+                 */
+                p->mcast_list_len = reg_sz;
+                break;
+
+        case BNX2X_MCAST_CMD_ADD:
+        case BNX2X_MCAST_CMD_CONT:
+                /* Here we assume that all new MACs will fall into new bins.
+                 * However we will correct the real registry size after we
+                 * handle all pending commands.
+                 */
+                o->set_registry_size(o, reg_sz + p->mcast_list_len);
                 break;
+
+        default:
+                BNX2X_ERR("Unknown command: %d\n", cmd);
+                return -EINVAL;
+
         }
 
-        cl_id = BP_L_ID(bp);
-        bnx2x_rxq_set_mac_filters(bp, cl_id, def_q_filters);
+        /* Increase the total number of MACs pending to be configured */
+        o->total_pending_num += p->mcast_list_len;
 
-        REG_WR(bp,
-               (port ? NIG_REG_LLH1_BRB1_DRV_MASK :
-                       NIG_REG_LLH0_BRB1_DRV_MASK), llh_mask);
+        return 0;
+}
 
-        DP(NETIF_MSG_IFUP, "rx mode %d\n"
-                "drop_ucast 0x%x\ndrop_mcast 0x%x\ndrop_bcast 0x%x\n"
-                "accp_ucast 0x%x\naccp_mcast 0x%x\naccp_bcast 0x%x\n"
-                "unmatched_ucast 0x%x\n", mode,
-                bp->mac_filters.ucast_drop_all,
-                bp->mac_filters.mcast_drop_all,
-                bp->mac_filters.bcast_drop_all,
-                bp->mac_filters.ucast_accept_all,
-                bp->mac_filters.mcast_accept_all,
-                bp->mac_filters.bcast_accept_all,
-                bp->mac_filters.unmatched_unicast
-        );
+static void bnx2x_mcast_revert_e2(struct bnx2x *bp,
+                                      struct bnx2x_mcast_ramrod_params *p,
+                                      int old_num_bins)
+{
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
 
-        storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
+        o->set_registry_size(o, old_num_bins);
+        o->total_pending_num -= p->mcast_list_len;
 }
 
-/* RSS configuration */
-static inline void __storm_memset_dma_mapping(struct bnx2x *bp,
-                                       u32 addr, dma_addr_t mapping)
+/**
+ * bnx2x_mcast_set_rdata_hdr_e2 - sets a header values
+ *
+ * @bp:         device handle
+ * @p:
+ * @len:        number of rules to handle
+ */
+static inline void bnx2x_mcast_set_rdata_hdr_e2(struct bnx2x *bp,
+                                        struct bnx2x_mcast_ramrod_params *p,
+                                        u8 len)
 {
-        REG_WR(bp,  addr, U64_LO(mapping));
-        REG_WR(bp,  addr + 4, U64_HI(mapping));
+        struct bnx2x_raw_obj *r = &p->mcast_obj->raw;
+        struct eth_multicast_rules_ramrod_data *data =
+                (struct eth_multicast_rules_ramrod_data *)(r->rdata);
+
+        data->header.echo = ((r->cid & BNX2X_SWCID_MASK) |
+                          (BNX2X_FILTER_MCAST_PENDING << BNX2X_SWCID_SHIFT));
+        data->header.rule_cnt = len;
 }
 
-static inline void __storm_fill(struct bnx2x *bp,
-                                       u32 addr, size_t size, u32 val)
+/**
+ * bnx2x_mcast_refresh_registry_e2 - recalculate the actual number of set bins
+ *
+ * @bp:         device handle
+ * @o:
+ *
+ * Recalculate the actual number of set bins in the registry using Brian
+ * Kernighan's algorithm: it's execution complexity is as a number of set bins.
+ *
+ * returns 0 for the compliance with bnx2x_mcast_refresh_registry_e1().
+ */
+static inline int bnx2x_mcast_refresh_registry_e2(struct bnx2x *bp,
+                                                  struct bnx2x_mcast_obj *o)
+{
+        int i, cnt = 0;
+        u64 elem;
+
+        for (i = 0; i < BNX2X_MCAST_VEC_SZ; i++) {
+                elem = o->registry.aprox_match.vec[i];
+                for (; elem; cnt++)
+                        elem &= elem - 1;
+        }
+
+        o->set_registry_size(o, cnt);
+
+        return 0;
+}
+
+static int bnx2x_mcast_setup_e2(struct bnx2x *bp,
+                                struct bnx2x_mcast_ramrod_params *p,
+                                int cmd)
+{
+        struct bnx2x_raw_obj *raw = &p->mcast_obj->raw;
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
+        struct eth_multicast_rules_ramrod_data *data =
+                (struct eth_multicast_rules_ramrod_data *)(raw->rdata);
+        int cnt = 0, rc;
+
+        /* Reset the ramrod data buffer */
+        memset(data, 0, sizeof(*data));
+
+        cnt = bnx2x_mcast_handle_pending_cmds_e2(bp, p);
+
+        /* If there are no more pending commands - clear SCHEDULED state */
+        if (list_empty(&o->pending_cmds_head))
+                o->clear_sched(o);
+
+        /* The below may be true iff there was enough room in ramrod
+         * data for all pending commands and for the current
+         * command. Otherwise the current command would have been added
+         * to the pending commands and p->mcast_list_len would have been
+         * zeroed.
+         */
+        if (p->mcast_list_len > 0)
+                cnt = bnx2x_mcast_handle_current_cmd(bp, p, cmd, cnt);
+
+        /* We've pulled out some MACs - update the total number of
+         * outstanding.
+         */
+        o->total_pending_num -= cnt;
+
+        /* send a ramrod */
+        WARN_ON(o->total_pending_num < 0);
+        WARN_ON(cnt > o->max_cmd_len);
+
+        bnx2x_mcast_set_rdata_hdr_e2(bp, p, (u8)cnt);
+
+        /* Update a registry size if there are no more pending operations.
+         *
+         * We don't want to change the value of the registry size if there are
+         * pending operations because we want it to always be equal to the
+         * exact or the approximate number (see bnx2x_mcast_validate_e2()) of
+         * set bins after the last requested operation in order to properly
+         * evaluate the size of the next DEL/RESTORE operation.
+         *
+         * Note that we update the registry itself during command(s) handling
+         * - see bnx2x_mcast_set_one_rule_e2(). That's because for 57712 we
+         * aggregate multiple commands (ADD/DEL/RESTORE) into one ramrod but
+         * with a limited amount of update commands (per MAC/bin) and we don't
+         * know in this scope what the actual state of bins configuration is
+         * going to be after this ramrod.
+         */
+        if (!o->total_pending_num)
+                bnx2x_mcast_refresh_registry_e2(bp, o);
+
+        /* Commit writes towards the memory before sending a ramrod */
+        mb();
+
+        /* If CLEAR_ONLY was requested - don't send a ramrod and clear
+         * RAMROD_PENDING status immediately.
+         */
+        if (test_bit(RAMROD_DRV_CLR_ONLY, &p->ramrod_flags)) {
+                raw->clear_pending(raw);
+                return 0;
+        } else {
+                /* Send a ramrod */
+                rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_MULTICAST_RULES,
+                                   raw->cid, U64_HI(raw->rdata_mapping),
+                                   U64_LO(raw->rdata_mapping),
+                                   ETH_CONNECTION_TYPE);
+                if (rc)
+                        return rc;
+
+                /* Ramrod completion is pending */
+                return 1;
+        }
+}
+
+static int bnx2x_mcast_validate_e1h(struct bnx2x *bp,
+                                    struct bnx2x_mcast_ramrod_params *p,
+                                    int cmd)
+{
+        /* Mark, that there is a work to do */
+        if ((cmd == BNX2X_MCAST_CMD_DEL) || (cmd == BNX2X_MCAST_CMD_RESTORE))
+                p->mcast_list_len = 1;
+
+        return 0;
+}
+
+static void bnx2x_mcast_revert_e1h(struct bnx2x *bp,
+                                       struct bnx2x_mcast_ramrod_params *p,
+                                       int old_num_bins)
+{
+        /* Do nothing */
+}
+
+#define BNX2X_57711_SET_MC_FILTER(filter, bit) \
+do { \
+        (filter)[(bit) >> 5] |= (1 << ((bit) & 0x1f)); \
+} while (0)
+
+static inline void bnx2x_mcast_hdl_add_e1h(struct bnx2x *bp,
+                                           struct bnx2x_mcast_obj *o,
+                                           struct bnx2x_mcast_ramrod_params *p,
+                                           u32 *mc_filter)
+{
+        struct bnx2x_mcast_list_elem *mlist_pos;
+        int bit;
+
+        list_for_each_entry(mlist_pos, &p->mcast_list, link) {
+                bit = bnx2x_mcast_bin_from_mac(mlist_pos->mac);
+                BNX2X_57711_SET_MC_FILTER(mc_filter, bit);
+
+                DP(BNX2X_MSG_SP, "About to configure "
+                                 BNX2X_MAC_FMT" mcast MAC, bin %d\n",
+                                 BNX2X_MAC_PRN_LIST(mlist_pos->mac), bit);
+
+                /* bookkeeping... */
+                BIT_VEC64_SET_BIT(o->registry.aprox_match.vec,
+                                  bit);
+        }
+}
+
+static inline void bnx2x_mcast_hdl_restore_e1h(struct bnx2x *bp,
+        struct bnx2x_mcast_obj *o, struct bnx2x_mcast_ramrod_params *p,
+        u32 *mc_filter)
+{
+        int bit;
+
+        for (bit = bnx2x_mcast_get_next_bin(o, 0);
+             bit >= 0;
+             bit = bnx2x_mcast_get_next_bin(o, bit + 1)) {
+                BNX2X_57711_SET_MC_FILTER(mc_filter, bit);
+                DP(BNX2X_MSG_SP, "About to set bin %d\n", bit);
+        }
+}
+
+/* On 57711 we write the multicast MACs' aproximate match
+ * table by directly into the TSTORM's internal RAM. So we don't
+ * really need to handle any tricks to make it work.
+ */
+static int bnx2x_mcast_setup_e1h(struct bnx2x *bp,
+                                 struct bnx2x_mcast_ramrod_params *p,
+                                 int cmd)
 {
         int i;
-        for (i = 0; i < size/4; i++)
-                REG_WR(bp,  addr + (i * 4), val);
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
+        struct bnx2x_raw_obj *r = &o->raw;
+
+        /* If CLEAR_ONLY has been requested - clear the registry
+         * and clear a pending bit.
+         */
+        if (!test_bit(RAMROD_DRV_CLR_ONLY, &p->ramrod_flags)) {
+                u32 mc_filter[MC_HASH_SIZE] = {0};
+
+                /* Set the multicast filter bits before writing it into
+                 * the internal memory.
+                 */
+                switch (cmd) {
+                case BNX2X_MCAST_CMD_ADD:
+                        bnx2x_mcast_hdl_add_e1h(bp, o, p, mc_filter);
+                        break;
+
+                case BNX2X_MCAST_CMD_DEL:
+                        DP(BNX2X_MSG_SP, "Invalidating multicast "
+                                         "MACs configuration\n");
+
+                        /* clear the registry */
+                        memset(o->registry.aprox_match.vec, 0,
+                               sizeof(o->registry.aprox_match.vec));
+                        break;
+
+                case BNX2X_MCAST_CMD_RESTORE:
+                        bnx2x_mcast_hdl_restore_e1h(bp, o, p, mc_filter);
+                        break;
+
+                default:
+                        BNX2X_ERR("Unknown command: %d\n", cmd);
+                        return -EINVAL;
+                }
+
+                /* Set the mcast filter in the internal memory */
+                for (i = 0; i < MC_HASH_SIZE; i++)
+                        REG_WR(bp, MC_HASH_OFFSET(bp, i), mc_filter[i]);
+        } else
+                /* clear the registry */
+                memset(o->registry.aprox_match.vec, 0,
+                       sizeof(o->registry.aprox_match.vec));
+
+        /* We are done */
+        r->clear_pending(r);
+
+        return 0;
 }
 
-static inline void storm_memset_ustats_zero(struct bnx2x *bp,
-                                            u8 port, u16 stat_id)
+static int bnx2x_mcast_validate_e1(struct bnx2x *bp,
+                                   struct bnx2x_mcast_ramrod_params *p,
+                                   int cmd)
 {
-        size_t size = sizeof(struct ustorm_per_client_stats);
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
+        int reg_sz = o->get_registry_size(o);
+
+        switch (cmd) {
+        /* DEL command deletes all currently configured MACs */
+        case BNX2X_MCAST_CMD_DEL:
+                o->set_registry_size(o, 0);
+                /* Don't break */
+
+        /* RESTORE command will restore the entire multicast configuration */
+        case BNX2X_MCAST_CMD_RESTORE:
+                p->mcast_list_len = reg_sz;
+                  DP(BNX2X_MSG_SP, "Command %d, p->mcast_list_len=%d\n",
+                                   cmd, p->mcast_list_len);
+                break;
+
+        case BNX2X_MCAST_CMD_ADD:
+        case BNX2X_MCAST_CMD_CONT:
+                /* Multicast MACs on 57710 are configured as unicast MACs and
+                 * there is only a limited number of CAM entries for that
+                 * matter.
+                 */
+                if (p->mcast_list_len > o->max_cmd_len) {
+                        BNX2X_ERR("Can't configure more than %d multicast MACs"
+                                   "on 57710\n", o->max_cmd_len);
+                        return -EINVAL;
+                }
+                /* Every configured MAC should be cleared if DEL command is
+                 * called. Only the last ADD command is relevant as long as
+                 * every ADD commands overrides the previous configuration.
+                 */
+                DP(BNX2X_MSG_SP, "p->mcast_list_len=%d\n", p->mcast_list_len);
+                if (p->mcast_list_len > 0)
+                        o->set_registry_size(o, p->mcast_list_len);
+
+                break;
+
+        default:
+                BNX2X_ERR("Unknown command: %d\n", cmd);
+                return -EINVAL;
+
+        }
 
-        u32 addr = BAR_USTRORM_INTMEM +
-                        USTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
+        /* We want to ensure that commands are executed one by one for 57710.
+         * Therefore each none-empty command will consume o->max_cmd_len.
+         */
+        if (p->mcast_list_len)
+                o->total_pending_num += o->max_cmd_len;
 
-        __storm_fill(bp, addr, size, 0);
+        return 0;
 }
 
-static inline void storm_memset_tstats_zero(struct bnx2x *bp,
-                                            u8 port, u16 stat_id)
+static void bnx2x_mcast_revert_e1(struct bnx2x *bp,
+                                      struct bnx2x_mcast_ramrod_params *p,
+                                      int old_num_macs)
 {
-        size_t size = sizeof(struct tstorm_per_client_stats);
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
 
-        u32 addr = BAR_TSTRORM_INTMEM +
-                        TSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
+        o->set_registry_size(o, old_num_macs);
+
+        /* If current command hasn't been handled yet and we are
+         * here means that it's meant to be dropped and we have to
+         * update the number of outstandling MACs accordingly.
+         */
+        if (p->mcast_list_len)
+                o->total_pending_num -= o->max_cmd_len;
+}
 
-        __storm_fill(bp, addr, size, 0);
+static void bnx2x_mcast_set_one_rule_e1(struct bnx2x *bp,
+                                        struct bnx2x_mcast_obj *o, int idx,
+                                        union bnx2x_mcast_config_data *cfg_data,
+                                        int cmd)
+{
+        struct bnx2x_raw_obj *r = &o->raw;
+        struct mac_configuration_cmd *data =
+                (struct mac_configuration_cmd *)(r->rdata);
+
+        /* copy mac */
+        if ((cmd == BNX2X_MCAST_CMD_ADD) || (cmd == BNX2X_MCAST_CMD_RESTORE)) {
+                bnx2x_set_fw_mac_addr(&data->config_table[idx].msb_mac_addr,
+                                      &data->config_table[idx].middle_mac_addr,
+                                      &data->config_table[idx].lsb_mac_addr,
+                                      cfg_data->mac);
+
+                data->config_table[idx].vlan_id = 0;
+                data->config_table[idx].pf_id = r->func_id;
+                data->config_table[idx].clients_bit_vector =
+                        cpu_to_le32(1 << r->cl_id);
+
+                SET_FLAG(data->config_table[idx].flags,
+                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
+                         T_ETH_MAC_COMMAND_SET);
+        }
+}
+
+/**
+ * bnx2x_mcast_set_rdata_hdr_e1  - set header values in mac_configuration_cmd
+ *
+ * @bp:         device handle
+ * @p:
+ * @len:        number of rules to handle
+ */
+static inline void bnx2x_mcast_set_rdata_hdr_e1(struct bnx2x *bp,
+                                        struct bnx2x_mcast_ramrod_params *p,
+                                        u8 len)
+{
+        struct bnx2x_raw_obj *r = &p->mcast_obj->raw;
+        struct mac_configuration_cmd *data =
+                (struct mac_configuration_cmd *)(r->rdata);
+
+        u8 offset = (CHIP_REV_IS_SLOW(bp) ?
+                     BNX2X_MAX_EMUL_MULTI*(1 + r->func_id) :
+                     BNX2X_MAX_MULTICAST*(1 + r->func_id));
+
+        data->hdr.offset = offset;
+        data->hdr.client_id = 0xff;
+        data->hdr.echo = ((r->cid & BNX2X_SWCID_MASK) |
+                          (BNX2X_FILTER_MCAST_PENDING << BNX2X_SWCID_SHIFT));
+        data->hdr.length = len;
 }
 
-static inline void storm_memset_xstats_zero(struct bnx2x *bp,
-                                            u8 port, u16 stat_id)
+/**
+ * bnx2x_mcast_handle_restore_cmd_e1 - restore command for 57710
+ *
+ * @bp:         device handle
+ * @o:
+ * @start_idx:  index in the registry to start from
+ * @rdata_idx:  index in the ramrod data to start from
+ *
+ * restore command for 57710 is like all other commands - always a stand alone
+ * command - start_idx and rdata_idx will always be 0. This function will always
+ * succeed.
+ * returns -1 to comply with 57712 variant.
+ */
+static inline int bnx2x_mcast_handle_restore_cmd_e1(
+        struct bnx2x *bp, struct bnx2x_mcast_obj *o , int start_idx,
+        int *rdata_idx)
 {
-        size_t size = sizeof(struct xstorm_per_client_stats);
+        struct bnx2x_mcast_mac_elem *elem;
+        int i = 0;
+        union bnx2x_mcast_config_data cfg_data = {0};
 
-        u32 addr = BAR_XSTRORM_INTMEM +
-                        XSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
+        /* go through the registry and configure the MACs from it. */
+        list_for_each_entry(elem, &o->registry.exact_match.macs, link) {
+                cfg_data.mac = &elem->mac[0];
+                o->set_one_rule(bp, o, i, &cfg_data, BNX2X_MCAST_CMD_RESTORE);
 
-        __storm_fill(bp, addr, size, 0);
+                i++;
+
+                  DP(BNX2X_MSG_SP, "About to configure "BNX2X_MAC_FMT
+                                   " mcast MAC\n",
+                                   BNX2X_MAC_PRN_LIST(cfg_data.mac));
+        }
+
+        *rdata_idx = i;
+
+        return -1;
 }
 
 
-static inline void storm_memset_spq_addr(struct bnx2x *bp,
-                                         dma_addr_t mapping, u16 abs_fid)
+static inline int bnx2x_mcast_handle_pending_cmds_e1(
+        struct bnx2x *bp, struct bnx2x_mcast_ramrod_params *p)
 {
-        u32 addr = XSEM_REG_FAST_MEMORY +
-                        XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid);
+        struct bnx2x_pending_mcast_cmd *cmd_pos;
+        struct bnx2x_mcast_mac_elem *pmac_pos;
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
+        union bnx2x_mcast_config_data cfg_data = {0};
+        int cnt = 0;
+
 
-        __storm_memset_dma_mapping(bp, addr, mapping);
+        /* If nothing to be done - return */
+        if (list_empty(&o->pending_cmds_head))
+                return 0;
+
+        /* Handle the first command */
+        cmd_pos = list_first_entry(&o->pending_cmds_head,
+                                   struct bnx2x_pending_mcast_cmd, link);
+
+        switch (cmd_pos->type) {
+        case BNX2X_MCAST_CMD_ADD:
+                list_for_each_entry(pmac_pos, &cmd_pos->data.macs_head, link) {
+                        cfg_data.mac = &pmac_pos->mac[0];
+                        o->set_one_rule(bp, o, cnt, &cfg_data, cmd_pos->type);
+
+                        cnt++;
+
+                        DP(BNX2X_MSG_SP, "About to configure "BNX2X_MAC_FMT
+                                         " mcast MAC\n",
+                                         BNX2X_MAC_PRN_LIST(pmac_pos->mac));
+                }
+                break;
+
+        case BNX2X_MCAST_CMD_DEL:
+                cnt = cmd_pos->data.macs_num;
+                DP(BNX2X_MSG_SP, "About to delete %d multicast MACs\n", cnt);
+                break;
+
+        case BNX2X_MCAST_CMD_RESTORE:
+                o->hdl_restore(bp, o, 0, &cnt);
+                break;
+
+        default:
+                BNX2X_ERR("Unknown command: %d\n", cmd_pos->type);
+                return -EINVAL;
+        }
+
+        list_del(&cmd_pos->link);
+        kfree(cmd_pos);
+
+        return cnt;
+}
+
+/**
+ * bnx2x_get_fw_mac_addr - revert the bnx2x_set_fw_mac_addr().
+ *
+ * @fw_hi:
+ * @fw_mid:
+ * @fw_lo:
+ * @mac:
+ */
+static inline void bnx2x_get_fw_mac_addr(__le16 *fw_hi, __le16 *fw_mid,
+                                         __le16 *fw_lo, u8 *mac)
+{
+        mac[1] = ((u8 *)fw_hi)[0];
+        mac[0] = ((u8 *)fw_hi)[1];
+        mac[3] = ((u8 *)fw_mid)[0];
+        mac[2] = ((u8 *)fw_mid)[1];
+        mac[5] = ((u8 *)fw_lo)[0];
+        mac[4] = ((u8 *)fw_lo)[1];
 }
 
-static inline void storm_memset_xstats_flags(struct bnx2x *bp,
-                                struct stats_indication_flags *flags,
-                                u16 abs_fid)
+/**
+ * bnx2x_mcast_refresh_registry_e1 -
+ *
+ * @bp:         device handle
+ * @cnt:
+ *
+ * Check the ramrod data first entry flag to see if it's a DELETE or ADD command
+ * and update the registry correspondingly: if ADD - allocate a memory and add
+ * the entries to the registry (list), if DELETE - clear the registry and free
+ * the memory.
+ */
+static inline int bnx2x_mcast_refresh_registry_e1(struct bnx2x *bp,
+                                                  struct bnx2x_mcast_obj *o)
 {
-        size_t size = sizeof(struct stats_indication_flags);
+        struct bnx2x_raw_obj *raw = &o->raw;
+        struct bnx2x_mcast_mac_elem *elem;
+        struct mac_configuration_cmd *data =
+                        (struct mac_configuration_cmd *)(raw->rdata);
+
+        /* If first entry contains a SET bit - the command was ADD,
+         * otherwise - DEL_ALL
+         */
+        if (GET_FLAG(data->config_table[0].flags,
+                        MAC_CONFIGURATION_ENTRY_ACTION_TYPE)) {
+                int i, len = data->hdr.length;
+
+                /* Break if it was a RESTORE command */
+                if (!list_empty(&o->registry.exact_match.macs))
+                        return 0;
+
+                elem = kzalloc(sizeof(*elem)*len, GFP_ATOMIC);
+                if (!elem) {
+                        BNX2X_ERR("Failed to allocate registry memory\n");
+                        return -ENOMEM;
+                }
 
-        u32 addr = BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(abs_fid);
+                for (i = 0; i < len; i++, elem++) {
+                        bnx2x_get_fw_mac_addr(
+                                &data->config_table[i].msb_mac_addr,
+                                &data->config_table[i].middle_mac_addr,
+                                &data->config_table[i].lsb_mac_addr,
+                                elem->mac);
+                        DP(BNX2X_MSG_SP, "Adding registry entry for ["
+                                         BNX2X_MAC_FMT"]\n",
+                                   BNX2X_MAC_PRN_LIST(elem->mac));
+                        list_add_tail(&elem->link,
+                                      &o->registry.exact_match.macs);
+                }
+        } else {
+                elem = list_first_entry(&o->registry.exact_match.macs,
+                                        struct bnx2x_mcast_mac_elem, link);
+                DP(BNX2X_MSG_SP, "Deleting a registry\n");
+                kfree(elem);
+                INIT_LIST_HEAD(&o->registry.exact_match.macs);
+        }
 
-        __storm_memset_struct(bp, addr, size, (u32 *)flags);
+        return 0;
 }
 
-static inline void storm_memset_tstats_flags(struct bnx2x *bp,
-                                struct stats_indication_flags *flags,
-                                u16 abs_fid)
+static int bnx2x_mcast_setup_e1(struct bnx2x *bp,
+                                struct bnx2x_mcast_ramrod_params *p,
+                                int cmd)
 {
-        size_t size = sizeof(struct stats_indication_flags);
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
+        struct bnx2x_raw_obj *raw = &o->raw;
+        struct mac_configuration_cmd *data =
+                (struct mac_configuration_cmd *)(raw->rdata);
+        int cnt = 0, i, rc;
+
+        /* Reset the ramrod data buffer */
+        memset(data, 0, sizeof(*data));
+
+        /* First set all entries as invalid */
+        for (i = 0; i < o->max_cmd_len ; i++)
+                SET_FLAG(data->config_table[i].flags,
+                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
+                         T_ETH_MAC_COMMAND_INVALIDATE);
+
+        /* Handle pending commands first */
+        cnt = bnx2x_mcast_handle_pending_cmds_e1(bp, p);
 
-        u32 addr = BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(abs_fid);
+        /* If there are no more pending commands - clear SCHEDULED state */
+        if (list_empty(&o->pending_cmds_head))
+                o->clear_sched(o);
 
-        __storm_memset_struct(bp, addr, size, (u32 *)flags);
+        /* The below may be true iff there were no pending commands */
+        if (!cnt)
+                cnt = bnx2x_mcast_handle_current_cmd(bp, p, cmd, 0);
+
+        /* For 57710 every command has o->max_cmd_len length to ensure that
+         * commands are done one at a time.
+         */
+        o->total_pending_num -= o->max_cmd_len;
+
+        /* send a ramrod */
+
+        WARN_ON(cnt > o->max_cmd_len);
+
+        /* Set ramrod header (in particular, a number of entries to update) */
+        bnx2x_mcast_set_rdata_hdr_e1(bp, p, (u8)cnt);
+
+        /* update a registry: we need the registry contents to be always up
+         * to date in order to be able to execute a RESTORE opcode. Here
+         * we use the fact that for 57710 we sent one command at a time
+         * hence we may take the registry update out of the command handling
+         * and do it in a simpler way here.
+         */
+        rc = bnx2x_mcast_refresh_registry_e1(bp, o);
+        if (rc)
+                return rc;
+
+        /* Commit writes towards the memory before sending a ramrod */
+        mb();
+
+        /* If CLEAR_ONLY was requested - don't send a ramrod and clear
+         * RAMROD_PENDING status immediately.
+         */
+        if (test_bit(RAMROD_DRV_CLR_ONLY, &p->ramrod_flags)) {
+                raw->clear_pending(raw);
+                return 0;
+        } else {
+                /* Send a ramrod */
+                rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, raw->cid,
+                                   U64_HI(raw->rdata_mapping),
+                                   U64_LO(raw->rdata_mapping),
+                                   ETH_CONNECTION_TYPE);
+                if (rc)
+                        return rc;
+
+                /* Ramrod completion is pending */
+                return 1;
+        }
+
+}
+
+static int bnx2x_mcast_get_registry_size_exact(struct bnx2x_mcast_obj *o)
+{
+        return o->registry.exact_match.num_macs_set;
 }
 
-static inline void storm_memset_ustats_flags(struct bnx2x *bp,
-                                struct stats_indication_flags *flags,
-                                u16 abs_fid)
+static int bnx2x_mcast_get_registry_size_aprox(struct bnx2x_mcast_obj *o)
 {
-        size_t size = sizeof(struct stats_indication_flags);
+        return o->registry.aprox_match.num_bins_set;
+}
 
-        u32 addr = BAR_USTRORM_INTMEM + USTORM_STATS_FLAGS_OFFSET(abs_fid);
+static void bnx2x_mcast_set_registry_size_exact(struct bnx2x_mcast_obj *o,
+                                                int n)
+{
+        o->registry.exact_match.num_macs_set = n;
+}
 
-        __storm_memset_struct(bp, addr, size, (u32 *)flags);
+static void bnx2x_mcast_set_registry_size_aprox(struct bnx2x_mcast_obj *o,
+                                                int n)
+{
+        o->registry.aprox_match.num_bins_set = n;
 }
 
-static inline void storm_memset_cstats_flags(struct bnx2x *bp,
-                                struct stats_indication_flags *flags,
-                                u16 abs_fid)
+int bnx2x_config_mcast(struct bnx2x *bp,
+                       struct bnx2x_mcast_ramrod_params *p,
+                       int cmd)
 {
-        size_t size = sizeof(struct stats_indication_flags);
+        struct bnx2x_mcast_obj *o = p->mcast_obj;
+        struct bnx2x_raw_obj *r = &o->raw;
+        int rc = 0, old_reg_size;
+
+        /* This is needed to recover number of currently configured mcast macs
+         * in case of failure.
+         */
+        old_reg_size = o->get_registry_size(o);
+
+        /* Do some calculations and checks */
+        rc = o->validate(bp, p, cmd);
+        if (rc)
+                return rc;
+
+        /* Return if there is no work to do */
+        if ((!p->mcast_list_len) && (!o->check_sched(o)))
+                return 0;
+
+        DP(BNX2X_MSG_SP, "o->total_pending_num=%d p->mcast_list_len=%d "
+                         "o->max_cmd_len=%d\n", o->total_pending_num,
+                         p->mcast_list_len, o->max_cmd_len);
+
+        /* Enqueue the current command to the pending list if we can't complete
+         * it in the current iteration
+         */
+        if (r->check_pending(r) ||
+            ((o->max_cmd_len > 0) && (o->total_pending_num > o->max_cmd_len))) {
+                rc = o->enqueue_cmd(bp, p->mcast_obj, p, cmd);
+                if (rc < 0)
+                        goto error_exit1;
+
+                /* As long as the current command is in a command list we
+                 * don't need to handle it separately.
+                 */
+                p->mcast_list_len = 0;
+        }
+
+        if (!r->check_pending(r)) {
+
+                /* Set 'pending' state */
+                r->set_pending(r);
+
+                /* Configure the new classification in the chip */
+                rc = o->config_mcast(bp, p, cmd);
+                if (rc < 0)
+                        goto error_exit2;
+
+                /* Wait for a ramrod completion if was requested */
+                if (test_bit(RAMROD_COMP_WAIT, &p->ramrod_flags))
+                        rc = o->wait_comp(bp, o);
+        }
+
+        return rc;
 
-        u32 addr = BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(abs_fid);
+error_exit2:
+        r->clear_pending(r);
 
-        __storm_memset_struct(bp, addr, size, (u32 *)flags);
+error_exit1:
+        o->revert(bp, p, old_reg_size);
+
+        return rc;
 }
 
-static inline void storm_memset_xstats_addr(struct bnx2x *bp,
-                                           dma_addr_t mapping, u16 abs_fid)
+static void bnx2x_mcast_clear_sched(struct bnx2x_mcast_obj *o)
 {
-        u32 addr = BAR_XSTRORM_INTMEM +
-                XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
+        smp_mb__before_clear_bit();
+        clear_bit(o->sched_state, o->raw.pstate);
+        smp_mb__after_clear_bit();
+}
 
-        __storm_memset_dma_mapping(bp, addr, mapping);
+static void bnx2x_mcast_set_sched(struct bnx2x_mcast_obj *o)
+{
+        smp_mb__before_clear_bit();
+        set_bit(o->sched_state, o->raw.pstate);
+        smp_mb__after_clear_bit();
 }
 
-static inline void storm_memset_tstats_addr(struct bnx2x *bp,
-                                           dma_addr_t mapping, u16 abs_fid)
+static bool bnx2x_mcast_check_sched(struct bnx2x_mcast_obj *o)
 {
-        u32 addr = BAR_TSTRORM_INTMEM +
-                TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
+        return !!test_bit(o->sched_state, o->raw.pstate);
+}
+
+static bool bnx2x_mcast_check_pending(struct bnx2x_mcast_obj *o)
+{
+        return o->raw.check_pending(&o->raw) || o->check_sched(o);
+}
+
+void bnx2x_init_mcast_obj(struct bnx2x *bp,
+                          struct bnx2x_mcast_obj *mcast_obj,
+                          u8 mcast_cl_id, u32 mcast_cid, u8 func_id,
+                          u8 engine_id, void *rdata, dma_addr_t rdata_mapping,
+                          int state, unsigned long *pstate, bnx2x_obj_type type)
+{
+        memset(mcast_obj, 0, sizeof(*mcast_obj));
+
+        bnx2x_init_raw_obj(&mcast_obj->raw, mcast_cl_id, mcast_cid, func_id,
+                           rdata, rdata_mapping, state, pstate, type);
+
+        mcast_obj->engine_id = engine_id;
+
+        INIT_LIST_HEAD(&mcast_obj->pending_cmds_head);
+
+        mcast_obj->sched_state = BNX2X_FILTER_MCAST_SCHED;
+        mcast_obj->check_sched = bnx2x_mcast_check_sched;
+        mcast_obj->set_sched = bnx2x_mcast_set_sched;
+        mcast_obj->clear_sched = bnx2x_mcast_clear_sched;
+
+        if (CHIP_IS_E1(bp)) {
+                mcast_obj->config_mcast      = bnx2x_mcast_setup_e1;
+                mcast_obj->enqueue_cmd       = bnx2x_mcast_enqueue_cmd;
+                mcast_obj->hdl_restore       =
+                        bnx2x_mcast_handle_restore_cmd_e1;
+                mcast_obj->check_pending     = bnx2x_mcast_check_pending;
+
+                if (CHIP_REV_IS_SLOW(bp))
+                        mcast_obj->max_cmd_len = BNX2X_MAX_EMUL_MULTI;
+                else
+                        mcast_obj->max_cmd_len = BNX2X_MAX_MULTICAST;
+
+                mcast_obj->wait_comp         = bnx2x_mcast_wait;
+                mcast_obj->set_one_rule      = bnx2x_mcast_set_one_rule_e1;
+                mcast_obj->validate          = bnx2x_mcast_validate_e1;
+                mcast_obj->revert            = bnx2x_mcast_revert_e1;
+                mcast_obj->get_registry_size =
+                        bnx2x_mcast_get_registry_size_exact;
+                mcast_obj->set_registry_size =
+                        bnx2x_mcast_set_registry_size_exact;
+
+                /* 57710 is the only chip that uses the exact match for mcast
+                 * at the moment.
+                 */
+                INIT_LIST_HEAD(&mcast_obj->registry.exact_match.macs);
+
+        } else if (CHIP_IS_E1H(bp)) {
+                mcast_obj->config_mcast  = bnx2x_mcast_setup_e1h;
+                mcast_obj->enqueue_cmd   = NULL;
+                mcast_obj->hdl_restore   = NULL;
+                mcast_obj->check_pending = bnx2x_mcast_check_pending;
+
+                /* 57711 doesn't send a ramrod, so it has unlimited credit
+                 * for one command.
+                 */
+                mcast_obj->max_cmd_len       = -1;
+                mcast_obj->wait_comp         = bnx2x_mcast_wait;
+                mcast_obj->set_one_rule      = NULL;
+                mcast_obj->validate          = bnx2x_mcast_validate_e1h;
+                mcast_obj->revert            = bnx2x_mcast_revert_e1h;
+                mcast_obj->get_registry_size =
+                        bnx2x_mcast_get_registry_size_aprox;
+                mcast_obj->set_registry_size =
+                        bnx2x_mcast_set_registry_size_aprox;
+        } else {
+                mcast_obj->config_mcast      = bnx2x_mcast_setup_e2;
+                mcast_obj->enqueue_cmd       = bnx2x_mcast_enqueue_cmd;
+                mcast_obj->hdl_restore       =
+                        bnx2x_mcast_handle_restore_cmd_e2;
+                mcast_obj->check_pending     = bnx2x_mcast_check_pending;
+                /* TODO: There should be a proper HSI define for this number!!!
+                 */
+                mcast_obj->max_cmd_len       = 16;
+                mcast_obj->wait_comp         = bnx2x_mcast_wait;
+                mcast_obj->set_one_rule      = bnx2x_mcast_set_one_rule_e2;
+                mcast_obj->validate          = bnx2x_mcast_validate_e2;
+                mcast_obj->revert            = bnx2x_mcast_revert_e2;
+                mcast_obj->get_registry_size =
+                        bnx2x_mcast_get_registry_size_aprox;
+                mcast_obj->set_registry_size =
+                        bnx2x_mcast_set_registry_size_aprox;
+        }
+}
+
+/*************************** Credit handling **********************************/
+
+/**
+ * atomic_add_ifless - add if the result is less than a given value.
+ *
+ * @v:  pointer of type atomic_t
+ * @a:  the amount to add to v...
+ * @u:  ...if (v + a) is less than u.
+ *
+ * returns true if (v + a) was less than u, and false otherwise.
+ *
+ */
+static inline bool __atomic_add_ifless(atomic_t *v, int a, int u)
+{
+        int c, old;
+
+        c = atomic_read(v);
+        for (;;) {
+                if (unlikely(c + a >= u))
+                        return false;
 
-        __storm_memset_dma_mapping(bp, addr, mapping);
+                old = atomic_cmpxchg((v), c, c + a);
+                if (likely(old == c))
+                        break;
+                c = old;
+        }
+
+        return true;
 }
 
-static inline void storm_memset_ustats_addr(struct bnx2x *bp,
-                                           dma_addr_t mapping, u16 abs_fid)
+/**
+ * atomic_dec_ifmoe - dec if the result is more or equal than a given value.
+ *
+ * @v:  pointer of type atomic_t
+ * @a:  the amount to dec from v...
+ * @u:  ...if (v - a) is more or equal than u.
+ *
+ * returns true if (v - a) was more or equal than u, and false
+ * otherwise.
+ */
+static inline bool __atomic_dec_ifmoe(atomic_t *v, int a, int u)
 {
-        u32 addr = BAR_USTRORM_INTMEM +
-                USTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
+        int c, old;
+
+        c = atomic_read(v);
+        for (;;) {
+                if (unlikely(c - a < u))
+                        return false;
+
+                old = atomic_cmpxchg((v), c, c - a);
+                if (likely(old == c))
+                        break;
+                c = old;
+        }
 
-        __storm_memset_dma_mapping(bp, addr, mapping);
+        return true;
 }
 
-static inline void storm_memset_cstats_addr(struct bnx2x *bp,
-                                           dma_addr_t mapping, u16 abs_fid)
+static bool bnx2x_credit_pool_get(struct bnx2x_credit_pool_obj *o, int cnt)
 {
-        u32 addr = BAR_CSTRORM_INTMEM +
-                CSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
+        bool rc;
 
-        __storm_memset_dma_mapping(bp, addr, mapping);
+        smp_mb();
+        rc = __atomic_dec_ifmoe(&o->credit, cnt, 0);
+        smp_mb();
+
+        return rc;
 }
 
-static inline void storm_memset_vf_to_pf(struct bnx2x *bp, u16 abs_fid,
-                                         u16 pf_id)
+static bool bnx2x_credit_pool_put(struct bnx2x_credit_pool_obj *o, int cnt)
 {
-        REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid),
-                pf_id);
-        REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid),
-                pf_id);
-        REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid),
-                pf_id);
-        REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid),
-                pf_id);
+        bool rc;
+
+        smp_mb();
+
+        /* Don't let to refill if credit + cnt > pool_sz */
+        rc = __atomic_add_ifless(&o->credit, cnt, o->pool_sz + 1);
+
+        smp_mb();
+
+        return rc;
 }
 
-static inline void storm_memset_func_en(struct bnx2x *bp, u16 abs_fid,
-                                        u8 enable)
+static int bnx2x_credit_pool_check(struct bnx2x_credit_pool_obj *o)
 {
-        REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid),
-                enable);
-        REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid),
-                enable);
-        REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid),
-                enable);
-        REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid),
-                enable);
+        int cur_credit;
+
+        smp_mb();
+        cur_credit = atomic_read(&o->credit);
+
+        return cur_credit;
 }
 
-static inline void storm_memset_func_cfg(struct bnx2x *bp,
-                                struct tstorm_eth_function_common_config *tcfg,
-                                u16 abs_fid)
+static bool bnx2x_credit_pool_always_true(struct bnx2x_credit_pool_obj *o,
+                                          int cnt)
 {
-        size_t size = sizeof(struct tstorm_eth_function_common_config);
+        return true;
+}
 
-        u32 addr = BAR_TSTRORM_INTMEM +
-                        TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid);
 
-        __storm_memset_struct(bp, addr, size, (u32 *)tcfg);
+static bool bnx2x_credit_pool_get_entry(
+        struct bnx2x_credit_pool_obj *o,
+        int *offset)
+{
+        int idx, vec, i;
+
+        *offset = -1;
+
+        /* Find "internal cam-offset" then add to base for this object... */
+        for (vec = 0; vec < BNX2X_POOL_VEC_SIZE; vec++) {
+
+                /* Skip the current vector if there are no free entries in it */
+                if (!o->pool_mirror[vec])
+                        continue;
+
+                /* If we've got here we are going to find a free entry */
+                for (idx = vec * BNX2X_POOL_VEC_SIZE, i = 0;
+                      i < BIT_VEC64_ELEM_SZ; idx++, i++)
+
+                        if (BIT_VEC64_TEST_BIT(o->pool_mirror, idx)) {
+                                /* Got one!! */
+                                BIT_VEC64_CLEAR_BIT(o->pool_mirror, idx);
+                                *offset = o->base_pool_offset + idx;
+                                return true;
+                        }
+        }
+
+        return false;
+}
+
+static bool bnx2x_credit_pool_put_entry(
+        struct bnx2x_credit_pool_obj *o,
+        int offset)
+{
+        if (offset < o->base_pool_offset)
+                return false;
+
+        offset -= o->base_pool_offset;
+
+        if (offset >= o->pool_sz)
+                return false;
+
+        /* Return the entry to the pool */
+        BIT_VEC64_SET_BIT(o->pool_mirror, offset);
+
+        return true;
+}
+
+static bool bnx2x_credit_pool_put_entry_always_true(
+        struct bnx2x_credit_pool_obj *o,
+        int offset)
+{
+        return true;
 }
 
-void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p)
+static bool bnx2x_credit_pool_get_entry_always_true(
+        struct bnx2x_credit_pool_obj *o,
+        int *offset)
+{
+        *offset = -1;
+        return true;
+}
+/**
+ * bnx2x_init_credit_pool - initialize credit pool internals.
+ *
+ * @p:
+ * @base:       Base entry in the CAM to use.
+ * @credit:     pool size.
+ *
+ * If base is negative no CAM entries handling will be performed.
+ * If credit is negative pool operations will always succeed (unlimited pool).
+ *
+ */
+static inline void bnx2x_init_credit_pool(struct bnx2x_credit_pool_obj *p,
+                                          int base, int credit)
 {
-        struct tstorm_eth_function_common_config tcfg = {0};
-        u16 rss_flgs;
+        /* Zero the object first */
+        memset(p, 0, sizeof(*p));
+
+        /* Set the table to all 1s */
+        memset(&p->pool_mirror, 0xff, sizeof(p->pool_mirror));
+
+        /* Init a pool as full */
+        atomic_set(&p->credit, credit);
+
+        /* The total poll size */
+        p->pool_sz = credit;
+
+        p->base_pool_offset = base;
+
+        /* Commit the change */
+        smp_mb();
 
-        /* tpa */
-        if (p->func_flgs & FUNC_FLG_TPA)
-                tcfg.config_flags |=
-                TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA;
+        p->check = bnx2x_credit_pool_check;
 
-        /* set rss flags */
-        rss_flgs = (p->rss->mode <<
-                TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT);
+        /* if pool credit is negative - disable the checks */
+        if (credit >= 0) {
+                p->put      = bnx2x_credit_pool_put;
+                p->get      = bnx2x_credit_pool_get;
+                p->put_entry = bnx2x_credit_pool_put_entry;
+                p->get_entry = bnx2x_credit_pool_get_entry;
+        } else {
+                p->put      = bnx2x_credit_pool_always_true;
+                p->get      = bnx2x_credit_pool_always_true;
+                p->put_entry = bnx2x_credit_pool_put_entry_always_true;
+                p->get_entry = bnx2x_credit_pool_get_entry_always_true;
+        }
+
+        /* If base is negative - disable entries handling */
+        if (base < 0) {
+                p->put_entry = bnx2x_credit_pool_put_entry_always_true;
+                p->get_entry = bnx2x_credit_pool_get_entry_always_true;
+        }
+}
+
+void bnx2x_init_mac_credit_pool(struct bnx2x *bp,
+                                struct bnx2x_credit_pool_obj *p, u8 func_id,
+                                u8 func_num)
+{
+/* TODO: this will be defined in consts as well... */
+#define BNX2X_CAM_SIZE_EMUL 5
 
-        if (p->rss->cap & RSS_IPV4_CAP)
-                rss_flgs |= RSS_IPV4_CAP_MASK;
-        if (p->rss->cap & RSS_IPV4_TCP_CAP)
-                rss_flgs |= RSS_IPV4_TCP_CAP_MASK;
-        if (p->rss->cap & RSS_IPV6_CAP)
-                rss_flgs |= RSS_IPV6_CAP_MASK;
-        if (p->rss->cap & RSS_IPV6_TCP_CAP)
-                rss_flgs |= RSS_IPV6_TCP_CAP_MASK;
+        int cam_sz;
 
-        tcfg.config_flags |= rss_flgs;
-        tcfg.rss_result_mask = p->rss->result_mask;
+        if (CHIP_IS_E1(bp)) {
+                /* In E1, Multicast is saved in cam... */
+                if (!CHIP_REV_IS_SLOW(bp))
+                        cam_sz = (MAX_MAC_CREDIT_E1 / 2) - BNX2X_MAX_MULTICAST;
+                else
+                        cam_sz = BNX2X_CAM_SIZE_EMUL - BNX2X_MAX_EMUL_MULTI;
 
-        storm_memset_func_cfg(bp, &tcfg, p->func_id);
+                bnx2x_init_credit_pool(p, func_id * cam_sz, cam_sz);
 
-        /* Enable the function in the FW */
-        storm_memset_vf_to_pf(bp, p->func_id, p->pf_id);
-        storm_memset_func_en(bp, p->func_id, 1);
+        } else if (CHIP_IS_E1H(bp)) {
+                /* CAM credit is equaly divided between all active functions
+                 * on the PORT!.
+                 */
+                if ((func_num > 0)) {
+                        if (!CHIP_REV_IS_SLOW(bp))
+                                cam_sz = (MAX_MAC_CREDIT_E1H / (2*func_num));
+                        else
+                                cam_sz = BNX2X_CAM_SIZE_EMUL;
+                        bnx2x_init_credit_pool(p, func_id * cam_sz, cam_sz);
+                } else {
+                        /* this should never happen! Block MAC operations. */
+                        bnx2x_init_credit_pool(p, 0, 0);
+                }
 
-        /* statistics */
-        if (p->func_flgs & FUNC_FLG_STATS) {
-                struct stats_indication_flags stats_flags = {0};
-                stats_flags.collect_eth = 1;
+        } else {
 
-                storm_memset_xstats_flags(bp, &stats_flags, p->func_id);
-                storm_memset_xstats_addr(bp, p->fw_stat_map, p->func_id);
+                /*
+                 * CAM credit is equaly divided between all active functions
+                 * on the PATH.
+                 */
+                if ((func_num > 0)) {
+                        if (!CHIP_REV_IS_SLOW(bp))
+                                cam_sz = (MAX_MAC_CREDIT_E2 / func_num);
+                        else
+                                cam_sz = BNX2X_CAM_SIZE_EMUL;
 
-                storm_memset_tstats_flags(bp, &stats_flags, p->func_id);
-                storm_memset_tstats_addr(bp, p->fw_stat_map, p->func_id);
+                        /*
+                         * No need for CAM entries handling for 57712 and
+                         * newer.
+                         */
+                        bnx2x_init_credit_pool(p, -1, cam_sz);
+                } else {
+                        /* this should never happen! Block MAC operations. */
+                        bnx2x_init_credit_pool(p, 0, 0);
+                }
 
-                storm_memset_ustats_flags(bp, &stats_flags, p->func_id);
-                storm_memset_ustats_addr(bp, p->fw_stat_map, p->func_id);
+        }
+}
 
-                storm_memset_cstats_flags(bp, &stats_flags, p->func_id);
-                storm_memset_cstats_addr(bp, p->fw_stat_map, p->func_id);
+void bnx2x_init_vlan_credit_pool(struct bnx2x *bp,
+                                 struct bnx2x_credit_pool_obj *p,
+                                 u8 func_id,
+                                 u8 func_num)
+{
+        if (CHIP_IS_E1x(bp)) {
+                /*
+                 * There is no VLAN credit in HW on 57710 and 57711 only
+                 * MAC / MAC-VLAN can be set
+                 */
+                bnx2x_init_credit_pool(p, 0, -1);
+        } else {
+                /*
+                 * CAM credit is equaly divided between all active functions
+                 * on the PATH.
+                 */
+                if (func_num > 0) {
+                        int credit = MAX_VLAN_CREDIT_E2 / func_num;
+                        bnx2x_init_credit_pool(p, func_id * credit, credit);
+                } else
+                        /* this should never happen! Block VLAN operations. */
+                        bnx2x_init_credit_pool(p, 0, 0);
         }
+}
+
+/****************** RSS Configuration ******************/
+/**
+ * bnx2x_debug_print_ind_table - prints the indirection table configuration.
+ *
+ * @bp:         driver hanlde
+ * @p:          pointer to rss configuration
+ *
+ * Prints it when NETIF_MSG_IFUP debug level is configured.
+ */
+static inline void bnx2x_debug_print_ind_table(struct bnx2x *bp,
+                                        struct bnx2x_config_rss_params *p)
+{
+        int i;
+
+        DP(BNX2X_MSG_SP, "Setting indirection table to:\n");
+        DP(BNX2X_MSG_SP, "0x0000: ");
+        for (i = 0; i < T_ETH_INDIRECTION_TABLE_SIZE; i++) {
+                DP_CONT(BNX2X_MSG_SP, "0x%02x ", p->ind_table[i]);
 
-        /* spq */
-        if (p->func_flgs & FUNC_FLG_SPQ) {
-                storm_memset_spq_addr(bp, p->spq_map, p->func_id);
-                REG_WR(bp, XSEM_REG_FAST_MEMORY +
-                       XSTORM_SPQ_PROD_OFFSET(p->func_id), p->spq_prod);
+                /* Print 4 bytes in a line */
+                if ((i + 1 < T_ETH_INDIRECTION_TABLE_SIZE) &&
+                    (((i + 1) & 0x3) == 0)) {
+                        DP_CONT(BNX2X_MSG_SP, "\n");
+                        DP(BNX2X_MSG_SP, "0x%04x: ", i + 1);
+                }
         }
+
+        DP_CONT(BNX2X_MSG_SP, "\n");
 }
 
-static void bnx2x_fill_cl_init_data(struct bnx2x *bp,
-                                    struct bnx2x_client_init_params *params,
-                                    u8 activate,
-                                    struct client_init_ramrod_data *data)
+/**
+ * bnx2x_setup_rss - configure RSS
+ *
+ * @bp:         device handle
+ * @p:          rss configuration
+ *
+ * sends on UPDATE ramrod for that matter.
+ */
+static int bnx2x_setup_rss(struct bnx2x *bp,
+                           struct bnx2x_config_rss_params *p)
 {
-        /* Clear the buffer */
+        struct bnx2x_rss_config_obj *o = p->rss_obj;
+        struct bnx2x_raw_obj *r = &o->raw;
+        struct eth_rss_update_ramrod_data *data =
+                (struct eth_rss_update_ramrod_data *)(r->rdata);
+        u8 rss_mode = 0;
+        int rc;
+
         memset(data, 0, sizeof(*data));
 
+        DP(BNX2X_MSG_SP, "Configuring RSS\n");
+
+        /* Set an echo field */
+        data->echo = (r->cid & BNX2X_SWCID_MASK) |
+                     (r->state << BNX2X_SWCID_SHIFT);
+
+        /* RSS mode */
+        if (test_bit(BNX2X_RSS_MODE_DISABLED, &p->rss_flags))
+                rss_mode = ETH_RSS_MODE_DISABLED;
+        else if (test_bit(BNX2X_RSS_MODE_REGULAR, &p->rss_flags))
+                rss_mode = ETH_RSS_MODE_REGULAR;
+        else if (test_bit(BNX2X_RSS_MODE_VLAN_PRI, &p->rss_flags))
+                rss_mode = ETH_RSS_MODE_VLAN_PRI;
+        else if (test_bit(BNX2X_RSS_MODE_E1HOV_PRI, &p->rss_flags))
+                rss_mode = ETH_RSS_MODE_E1HOV_PRI;
+        else if (test_bit(BNX2X_RSS_MODE_IP_DSCP, &p->rss_flags))
+                rss_mode = ETH_RSS_MODE_IP_DSCP;
+
+        data->rss_mode = rss_mode;
+
+        DP(BNX2X_MSG_SP, "rss_mode=%d\n", rss_mode);
+
+        /* RSS capabilities */
+        if (test_bit(BNX2X_RSS_IPV4, &p->rss_flags))
+                data->capabilities |=
+                        ETH_RSS_UPDATE_RAMROD_DATA_IPV4_CAPABILITY;
+
+        if (test_bit(BNX2X_RSS_IPV4_TCP, &p->rss_flags))
+                data->capabilities |=
+                        ETH_RSS_UPDATE_RAMROD_DATA_IPV4_TCP_CAPABILITY;
+
+        if (test_bit(BNX2X_RSS_IPV6, &p->rss_flags))
+                data->capabilities |=
+                        ETH_RSS_UPDATE_RAMROD_DATA_IPV6_CAPABILITY;
+
+        if (test_bit(BNX2X_RSS_IPV6_TCP, &p->rss_flags))
+                data->capabilities |=
+                        ETH_RSS_UPDATE_RAMROD_DATA_IPV6_TCP_CAPABILITY;
+
+        /* Hashing mask */
+        data->rss_result_mask = p->rss_result_mask;
+
+        /* RSS engine ID */
+        data->rss_engine_id = o->engine_id;
+
+        DP(BNX2X_MSG_SP, "rss_engine_id=%d\n", data->rss_engine_id);
+
+        /* Indirection table */
+        memcpy(data->indirection_table, p->ind_table,
+                  T_ETH_INDIRECTION_TABLE_SIZE);
+
+        /* Remember the last configuration */
+        memcpy(o->ind_table, p->ind_table, T_ETH_INDIRECTION_TABLE_SIZE);
+
+        /* Print the indirection table */
+        if (netif_msg_ifup(bp))
+                bnx2x_debug_print_ind_table(bp, p);
+
+        /* RSS keys */
+        if (test_bit(BNX2X_RSS_SET_SRCH, &p->rss_flags)) {
+                memcpy(&data->rss_key[0], &p->rss_key[0],
+                       sizeof(data->rss_key));
+                data->capabilities |= ETH_RSS_UPDATE_RAMROD_DATA_UPDATE_RSS_KEY;
+        }
+
+        /* Commit writes towards the memory before sending a ramrod */
+        mb();
+
+        /* Send a ramrod */
+        rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_RSS_UPDATE, r->cid,
+                           U64_HI(r->rdata_mapping),
+                           U64_LO(r->rdata_mapping),
+                           ETH_CONNECTION_TYPE);
+
+        if (rc < 0)
+                return rc;
+
+        return 1;
+}
+
+void bnx2x_get_rss_ind_table(struct bnx2x_rss_config_obj *rss_obj,
+                             u8 *ind_table)
+{
+        memcpy(ind_table, rss_obj->ind_table, sizeof(rss_obj->ind_table));
+}
+
+int bnx2x_config_rss(struct bnx2x *bp,
+                     struct bnx2x_config_rss_params *p)
+{
+        int rc;
+        struct bnx2x_rss_config_obj *o = p->rss_obj;
+        struct bnx2x_raw_obj *r = &o->raw;
+
+        /* Do nothing if only driver cleanup was requested */
+        if (test_bit(RAMROD_DRV_CLR_ONLY, &p->ramrod_flags))
+                return 0;
+
+        r->set_pending(r);
+
+        rc = o->config_rss(bp, p);
+        if (rc < 0) {
+                r->clear_pending(r);
+                return rc;
+        }
+
+        if (test_bit(RAMROD_COMP_WAIT, &p->ramrod_flags))
+                rc = r->wait_comp(bp, r);
+
+        return rc;
+}
+
+
+void bnx2x_init_rss_config_obj(struct bnx2x *bp,
+                               struct bnx2x_rss_config_obj *rss_obj,
+                               u8 cl_id, u32 cid, u8 func_id, u8 engine_id,
+                               void *rdata, dma_addr_t rdata_mapping,
+                               int state, unsigned long *pstate,
+                               bnx2x_obj_type type)
+{
+        bnx2x_init_raw_obj(&rss_obj->raw, cl_id, cid, func_id, rdata,
+                           rdata_mapping, state, pstate, type);
+
+        rss_obj->engine_id  = engine_id;
+        rss_obj->config_rss = bnx2x_setup_rss;
+}
+
+/********************** Queue state object ***********************************/
+
+/**
+ * bnx2x_queue_state_change - perform Queue state change transition
+ *
+ * @bp:         device handle
+ * @params:     parameters to perform the transition
+ *
+ * returns 0 in case of successfully completed transition, negative error
+ * code in case of failure, positive (EBUSY) value if there is a completion
+ * to that is still pending (possible only if RAMROD_COMP_WAIT is
+ * not set in params->ramrod_flags for asynchronous commands).
+ *
+ */
+int bnx2x_queue_state_change(struct bnx2x *bp,
+                             struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_sp_obj *o = params->q_obj;
+        int rc, pending_bit;
+        unsigned long *pending = &o->pending;
+
+        /* Check that the requested transition is legal */
+        if (o->check_transition(bp, o, params))
+                return -EINVAL;
+
+        /* Set "pending" bit */
+        pending_bit = o->set_pending(o, params);
+
+        /* Don't send a command if only driver cleanup was requested */
+        if (test_bit(RAMROD_DRV_CLR_ONLY, &params->ramrod_flags))
+                o->complete_cmd(bp, o, pending_bit);
+        else {
+                /* Send a ramrod */
+                rc = o->send_cmd(bp, params);
+                if (rc) {
+                        o->next_state = BNX2X_Q_STATE_MAX;
+                        clear_bit(pending_bit, pending);
+                        smp_mb__after_clear_bit();
+                        return rc;
+                }
+
+                if (test_bit(RAMROD_COMP_WAIT, &params->ramrod_flags)) {
+                        rc = o->wait_comp(bp, o, pending_bit);
+                        if (rc)
+                                return rc;
+
+                        return 0;
+                }
+        }
+
+        return !!test_bit(pending_bit, pending);
+}
+
+
+static int bnx2x_queue_set_pending(struct bnx2x_queue_sp_obj *obj,
+                                   struct bnx2x_queue_state_params *params)
+{
+        enum bnx2x_queue_cmd cmd = params->cmd, bit;
+
+        /* ACTIVATE and DEACTIVATE commands are implemented on top of
+         * UPDATE command.
+         */
+        if ((cmd == BNX2X_Q_CMD_ACTIVATE) ||
+            (cmd == BNX2X_Q_CMD_DEACTIVATE))
+                bit = BNX2X_Q_CMD_UPDATE;
+        else
+                bit = cmd;
+
+        set_bit(bit, &obj->pending);
+        return bit;
+}
+
+static int bnx2x_queue_wait_comp(struct bnx2x *bp,
+                                 struct bnx2x_queue_sp_obj *o,
+                                 enum bnx2x_queue_cmd cmd)
+{
+        return bnx2x_state_wait(bp, cmd, &o->pending);
+}
+
+/**
+ * bnx2x_queue_comp_cmd - complete the state change command.
+ *
+ * @bp:         device handle
+ * @o:
+ * @cmd:
+ *
+ * Checks that the arrived completion is expected.
+ */
+static int bnx2x_queue_comp_cmd(struct bnx2x *bp,
+                                struct bnx2x_queue_sp_obj *o,
+                                enum bnx2x_queue_cmd cmd)
+{
+        unsigned long cur_pending = o->pending;
+
+        if (!test_and_clear_bit(cmd, &cur_pending)) {
+                BNX2X_ERR("Bad MC reply %d for queue %d in state %d "
+                          "pending 0x%lx, next_state %d\n", cmd, o->cid,
+                          o->state, cur_pending, o->next_state);
+                return -EINVAL;
+        }
+
+        DP(BNX2X_MSG_SP, "Completing command %d for queue %d, "
+                         "setting state to %d\n", cmd, o->cid, o->next_state);
+
+        o->state = o->next_state;
+        o->next_state = BNX2X_Q_STATE_MAX;
+
+        /* It's important that o->state and o->next_state are
+         * updated before o->pending.
+         */
+        wmb();
+
+        clear_bit(cmd, &o->pending);
+        smp_mb__after_clear_bit();
+
+        return 0;
+}
+
+static void bnx2x_q_fill_setup_data_e2(struct bnx2x *bp,
+                                struct bnx2x_queue_state_params *cmd_params,
+                                struct client_init_ramrod_data *data)
+{
+        struct bnx2x_queue_setup_params *params = &cmd_params->params.setup;
+
+        /* Rx data */
+
+        /* IPv6 TPA supported for E2 and above only */
+        data->rx.tpa_en |= test_bit(BNX2X_Q_FLG_TPA, &params->flags) *
+                                CLIENT_INIT_RX_DATA_TPA_EN_IPV6;
+}
+
+static void bnx2x_q_fill_setup_data_cmn(struct bnx2x *bp,
+                                struct bnx2x_queue_state_params *cmd_params,
+                                struct client_init_ramrod_data *data)
+{
+        struct bnx2x_queue_sp_obj *o = cmd_params->q_obj;
+        struct bnx2x_queue_setup_params *params = &cmd_params->params.setup;
+
+
         /* general */
-        data->general.client_id = params->rxq_params.cl_id;
-        data->general.statistics_counter_id = params->rxq_params.stat_id;
-        data->general.statistics_en_flg =
-                (params->rxq_params.flags & QUEUE_FLG_STATS) ? 1 : 0;
-        data->general.is_fcoe_flg =
-                (params->ramrod_params.flags & CLIENT_IS_FCOE) ? 1 : 0;
-        data->general.activate_flg = activate;
-        data->general.sp_client_id = params->rxq_params.spcl_id;
+        data->general.client_id = o->cl_id;
+
+        if (test_bit(BNX2X_Q_FLG_STATS, &params->flags)) {
+                data->general.statistics_counter_id =
+                                        params->gen_params.stat_id;
+                data->general.statistics_en_flg = 1;
+                data->general.statistics_zero_flg =
+                        test_bit(BNX2X_Q_FLG_ZERO_STATS, &params->flags);
+        } else
+                data->general.statistics_counter_id =
+                                        DISABLE_STATISTIC_COUNTER_ID_VALUE;
+
+        data->general.is_fcoe_flg = test_bit(BNX2X_Q_FLG_FCOE, &params->flags);
+        data->general.activate_flg = test_bit(BNX2X_Q_FLG_ACTIVE,
+                                              &params->flags);
+        data->general.sp_client_id = params->gen_params.spcl_id;
+        data->general.mtu = cpu_to_le16(params->gen_params.mtu);
+        data->general.func_id = o->func_id;
+
+
+        data->general.cos = params->txq_params.cos;
+
+        data->general.traffic_type =
+                test_bit(BNX2X_Q_FLG_FCOE, &params->flags) ?
+                LLFC_TRAFFIC_TYPE_FCOE : LLFC_TRAFFIC_TYPE_NW;
 
         /* Rx data */
-        data->rx.tpa_en_flg =
-                (params->rxq_params.flags & QUEUE_FLG_TPA) ? 1 : 0;
+        data->rx.tpa_en = test_bit(BNX2X_Q_FLG_TPA, &params->flags) *
+                                CLIENT_INIT_RX_DATA_TPA_EN_IPV4;
         data->rx.vmqueue_mode_en_flg = 0;
+
         data->rx.cache_line_alignment_log_size =
                 params->rxq_params.cache_line_log;
         data->rx.enable_dynamic_hc =
-                (params->rxq_params.flags & QUEUE_FLG_DHC) ? 1 : 0;
+                test_bit(BNX2X_Q_FLG_DHC, &params->flags);
         data->rx.max_sges_for_packet = params->rxq_params.max_sges_pkt;
         data->rx.client_qzone_id = params->rxq_params.cl_qzone_id;
-        data->rx.max_agg_size = params->rxq_params.tpa_agg_sz;
+        data->rx.max_agg_size = cpu_to_le16(params->rxq_params.tpa_agg_sz);
+
+        /* Always start in DROP_ALL mode */
+        data->rx.state = cpu_to_le16(CLIENT_INIT_RX_DATA_UCAST_DROP_ALL |
+                                     CLIENT_INIT_RX_DATA_MCAST_DROP_ALL);
 
         /* We don't set drop flags */
         data->rx.drop_ip_cs_err_flg = 0;
         data->rx.drop_tcp_cs_err_flg = 0;
         data->rx.drop_ttl0_flg = 0;
         data->rx.drop_udp_cs_err_flg = 0;
-
         data->rx.inner_vlan_removal_enable_flg =
-                (params->rxq_params.flags & QUEUE_FLG_VLAN) ? 1 : 0;
+                test_bit(BNX2X_Q_FLG_VLAN, &params->flags);
         data->rx.outer_vlan_removal_enable_flg =
-                (params->rxq_params.flags & QUEUE_FLG_OV) ? 1 : 0;
+                test_bit(BNX2X_Q_FLG_OV, &params->flags);
         data->rx.status_block_id = params->rxq_params.fw_sb_id;
         data->rx.rx_sb_index_number = params->rxq_params.sb_cq_index;
-        data->rx.bd_buff_size = cpu_to_le16(params->rxq_params.buf_sz);
+        data->rx.max_tpa_queues = params->rxq_params.max_tpa_queues;
+        data->rx.max_bytes_on_bd = cpu_to_le16(params->rxq_params.buf_sz);
         data->rx.sge_buff_size = cpu_to_le16(params->rxq_params.sge_buf_sz);
-        data->rx.mtu = cpu_to_le16(params->rxq_params.mtu);
         data->rx.bd_page_base.lo =
                 cpu_to_le32(U64_LO(params->rxq_params.dscr_map));
         data->rx.bd_page_base.hi =
@@ -705,115 +4309,1025 @@ static void bnx2x_fill_cl_init_data(struct bnx2x *bp,
                 cpu_to_le32(U64_LO(params->rxq_params.rcq_map));
         data->rx.cqe_page_base.hi =
                 cpu_to_le32(U64_HI(params->rxq_params.rcq_map));
-        data->rx.is_leading_rss =
-                (params->ramrod_params.flags & CLIENT_IS_LEADING_RSS) ? 1 : 0;
-        data->rx.is_approx_mcast = data->rx.is_leading_rss;
+        data->rx.is_leading_rss = test_bit(BNX2X_Q_FLG_LEADING_RSS,
+                                           &params->flags);
+
+        if (test_bit(BNX2X_Q_FLG_MCAST, &params->flags)) {
+                data->rx.approx_mcast_engine_id = o->func_id;
+                data->rx.is_approx_mcast = 1;
+        }
+
+        data->rx.rss_engine_id = params->rxq_params.rss_engine_id;
+
+        /* flow control data */
+        data->rx.cqe_pause_thr_low = cpu_to_le16(params->pause.rcq_th_lo);
+        data->rx.cqe_pause_thr_high = cpu_to_le16(params->pause.rcq_th_hi);
+        data->rx.bd_pause_thr_low = cpu_to_le16(params->pause.bd_th_lo);
+        data->rx.bd_pause_thr_high = cpu_to_le16(params->pause.bd_th_hi);
+        data->rx.sge_pause_thr_low = cpu_to_le16(params->pause.sge_th_lo);
+        data->rx.sge_pause_thr_high = cpu_to_le16(params->pause.sge_th_hi);
+        data->rx.rx_cos_mask = cpu_to_le16(params->pause.pri_map);
+
+        /* silent vlan removal */
+        data->rx.silent_vlan_removal_flg =
+                test_bit(BNX2X_Q_FLG_SILENT_VLAN_REM, &params->flags);
+        data->rx.silent_vlan_value =
+                cpu_to_le16(params->rxq_params.silent_removal_value);
+        data->rx.silent_vlan_mask =
+                cpu_to_le16(params->rxq_params.silent_removal_mask);
 
         /* Tx data */
-        data->tx.enforce_security_flg = 0; /* VF specific */
+        data->tx.enforce_security_flg =
+                test_bit(BNX2X_Q_FLG_TX_SEC, &params->flags);
+        data->tx.default_vlan =
+                cpu_to_le16(params->txq_params.default_vlan);
+        data->tx.default_vlan_flg =
+                test_bit(BNX2X_Q_FLG_DEF_VLAN, &params->flags);
+        data->tx.tx_switching_flg =
+                test_bit(BNX2X_Q_FLG_TX_SWITCH, &params->flags);
+        data->tx.anti_spoofing_flg =
+                test_bit(BNX2X_Q_FLG_ANTI_SPOOF, &params->flags);
         data->tx.tx_status_block_id = params->txq_params.fw_sb_id;
         data->tx.tx_sb_index_number = params->txq_params.sb_cq_index;
-        data->tx.mtu = 0; /* VF specific */
+        data->tx.tss_leading_client_id = params->txq_params.tss_leading_cl_id;
+
         data->tx.tx_bd_page_base.lo =
                 cpu_to_le32(U64_LO(params->txq_params.dscr_map));
         data->tx.tx_bd_page_base.hi =
                 cpu_to_le32(U64_HI(params->txq_params.dscr_map));
 
-        /* flow control data */
-        data->fc.cqe_pause_thr_low = cpu_to_le16(params->pause.rcq_th_lo);
-        data->fc.cqe_pause_thr_high = cpu_to_le16(params->pause.rcq_th_hi);
-        data->fc.bd_pause_thr_low = cpu_to_le16(params->pause.bd_th_lo);
-        data->fc.bd_pause_thr_high = cpu_to_le16(params->pause.bd_th_hi);
-        data->fc.sge_pause_thr_low = cpu_to_le16(params->pause.sge_th_lo);
-        data->fc.sge_pause_thr_high = cpu_to_le16(params->pause.sge_th_hi);
-        data->fc.rx_cos_mask = cpu_to_le16(params->pause.pri_map);
-
-        data->fc.safc_group_num = params->txq_params.cos;
-        data->fc.safc_group_en_flg =
-                (params->txq_params.flags & QUEUE_FLG_COS) ? 1 : 0;
-        data->fc.traffic_type =
-                (params->ramrod_params.flags & CLIENT_IS_FCOE) ?
-                LLFC_TRAFFIC_TYPE_FCOE : LLFC_TRAFFIC_TYPE_NW;
+        /* Don't configure any Tx switching mode during queue SETUP */
+        data->tx.state = 0;
 }
 
 
-int bnx2x_setup_fw_client(struct bnx2x *bp,
-                          struct bnx2x_client_init_params *params,
-                          u8 activate,
-                          struct client_init_ramrod_data *data,
-                          dma_addr_t data_mapping)
+/**
+ * bnx2x_q_init - init HW/FW queue
+ *
+ * @bp:         device handle
+ * @params:
+ *
+ * HW/FW initial Queue configuration:
+ *      - HC: Rx and Tx
+ *      - CDU context validation
+ *
+ */
+static inline int bnx2x_q_init(struct bnx2x *bp,
+                               struct bnx2x_queue_state_params *params)
 {
+        struct bnx2x_queue_sp_obj *o = params->q_obj;
+        struct bnx2x_queue_init_params *init = &params->params.init;
         u16 hc_usec;
-        int ramrod = RAMROD_CMD_ID_ETH_CLIENT_SETUP;
-        int ramrod_flags = 0, rc;
-
-        /* HC and context validation values */
-        hc_usec = params->txq_params.hc_rate ?
-                1000000 / params->txq_params.hc_rate : 0;
-        bnx2x_update_coalesce_sb_index(bp,
-                        params->txq_params.fw_sb_id,
-                        params->txq_params.sb_cq_index,
-                        !(params->txq_params.flags & QUEUE_FLG_HC),
+
+        /* Tx HC configuration */
+        if (test_bit(BNX2X_Q_TYPE_HAS_TX, &o->type) &&
+            test_bit(BNX2X_Q_FLG_HC, &init->tx.flags)) {
+                hc_usec = init->tx.hc_rate ? 1000000 / init->tx.hc_rate : 0;
+
+                bnx2x_update_coalesce_sb_index(bp, init->tx.fw_sb_id,
+                        init->tx.sb_cq_index,
+                        !test_bit(BNX2X_Q_FLG_HC_EN, &init->tx.flags),
                         hc_usec);
+        }
 
-        *(params->ramrod_params.pstate) = BNX2X_FP_STATE_OPENING;
+        /* Rx HC configuration */
+        if (test_bit(BNX2X_Q_TYPE_HAS_RX, &o->type) &&
+            test_bit(BNX2X_Q_FLG_HC, &init->rx.flags)) {
+                hc_usec = init->rx.hc_rate ? 1000000 / init->rx.hc_rate : 0;
 
-        hc_usec = params->rxq_params.hc_rate ?
-                1000000 / params->rxq_params.hc_rate : 0;
-        bnx2x_update_coalesce_sb_index(bp,
-                        params->rxq_params.fw_sb_id,
-                        params->rxq_params.sb_cq_index,
-                        !(params->rxq_params.flags & QUEUE_FLG_HC),
+                bnx2x_update_coalesce_sb_index(bp, init->rx.fw_sb_id,
+                        init->rx.sb_cq_index,
+                        !test_bit(BNX2X_Q_FLG_HC_EN, &init->rx.flags),
                         hc_usec);
+        }
 
-        bnx2x_set_ctx_validation(params->rxq_params.cxt,
-                                 params->rxq_params.cid);
+        /* Set CDU context validation values */
+        bnx2x_set_ctx_validation(bp, init->cxt, o->cid);
 
-        /* zero stats */
-        if (params->txq_params.flags & QUEUE_FLG_STATS)
-                storm_memset_xstats_zero(bp, BP_PORT(bp),
-                                         params->txq_params.stat_id);
+        /* As no ramrod is sent, complete the command immediately  */
+        o->complete_cmd(bp, o, BNX2X_Q_CMD_INIT);
 
-        if (params->rxq_params.flags & QUEUE_FLG_STATS) {
-                storm_memset_ustats_zero(bp, BP_PORT(bp),
-                                         params->rxq_params.stat_id);
-                storm_memset_tstats_zero(bp, BP_PORT(bp),
-                                         params->rxq_params.stat_id);
-        }
+        mmiowb();
+        smp_mb();
+
+        return 0;
+}
+
+static inline int bnx2x_q_send_setup_e1x(struct bnx2x *bp,
+                                        struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_sp_obj *o = params->q_obj;
+        struct client_init_ramrod_data *rdata =
+                (struct client_init_ramrod_data *)o->rdata;
+        dma_addr_t data_mapping = o->rdata_mapping;
+        int ramrod = RAMROD_CMD_ID_ETH_CLIENT_SETUP;
+
+        /* Clear the ramrod data */
+        memset(rdata, 0, sizeof(*rdata));
 
         /* Fill the ramrod data */
-        bnx2x_fill_cl_init_data(bp, params, activate, data);
+        bnx2x_q_fill_setup_data_cmn(bp, params, rdata);
 
-        /* SETUP ramrod.
-         *
-         * bnx2x_sp_post() takes a spin_lock thus no other explict memory
-         * barrier except from mmiowb() is needed to impose a
-         * proper ordering of memory operations.
+        mb();
+
+        return bnx2x_sp_post(bp, ramrod, o->cid, U64_HI(data_mapping),
+                             U64_LO(data_mapping), ETH_CONNECTION_TYPE);
+}
+
+static inline int bnx2x_q_send_setup_e2(struct bnx2x *bp,
+                                        struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_sp_obj *o = params->q_obj;
+        struct client_init_ramrod_data *rdata =
+                (struct client_init_ramrod_data *)o->rdata;
+        dma_addr_t data_mapping = o->rdata_mapping;
+        int ramrod = RAMROD_CMD_ID_ETH_CLIENT_SETUP;
+
+        /* Clear the ramrod data */
+        memset(rdata, 0, sizeof(*rdata));
+
+        /* Fill the ramrod data */
+        bnx2x_q_fill_setup_data_cmn(bp, params, rdata);
+        bnx2x_q_fill_setup_data_e2(bp, params, rdata);
+
+        mb();
+
+        return bnx2x_sp_post(bp, ramrod, o->cid, U64_HI(data_mapping),
+                             U64_LO(data_mapping), ETH_CONNECTION_TYPE);
+}
+
+static void bnx2x_q_fill_update_data(struct bnx2x *bp,
+                                     struct bnx2x_queue_sp_obj *obj,
+                                     struct bnx2x_queue_update_params *params,
+                                     struct client_update_ramrod_data *data)
+{
+        /* Client ID of the client to update */
+        data->client_id = obj->cl_id;
+
+        /* Function ID of the client to update */
+        data->func_id = obj->func_id;
+
+        /* Default VLAN value */
+        data->default_vlan = cpu_to_le16(params->def_vlan);
+
+        /* Inner VLAN stripping */
+        data->inner_vlan_removal_enable_flg =
+                test_bit(BNX2X_Q_UPDATE_IN_VLAN_REM, &params->update_flags);
+        data->inner_vlan_removal_change_flg =
+                test_bit(BNX2X_Q_UPDATE_IN_VLAN_REM_CHNG,
+                         &params->update_flags);
+
+        /* Outer VLAN sripping */
+        data->outer_vlan_removal_enable_flg =
+                test_bit(BNX2X_Q_UPDATE_OUT_VLAN_REM, &params->update_flags);
+        data->outer_vlan_removal_change_flg =
+                test_bit(BNX2X_Q_UPDATE_OUT_VLAN_REM_CHNG,
+                         &params->update_flags);
+
+        /* Drop packets that have source MAC that doesn't belong to this
+         * Queue.
          */
-        mmiowb();
+        data->anti_spoofing_enable_flg =
+                test_bit(BNX2X_Q_UPDATE_ANTI_SPOOF, &params->update_flags);
+        data->anti_spoofing_change_flg =
+                test_bit(BNX2X_Q_UPDATE_ANTI_SPOOF_CHNG, &params->update_flags);
+
+        /* Activate/Deactivate */
+        data->activate_flg =
+                test_bit(BNX2X_Q_UPDATE_ACTIVATE, &params->update_flags);
+        data->activate_change_flg =
+                test_bit(BNX2X_Q_UPDATE_ACTIVATE_CHNG, &params->update_flags);
+
+        /* Enable default VLAN */
+        data->default_vlan_enable_flg =
+                test_bit(BNX2X_Q_UPDATE_DEF_VLAN_EN, &params->update_flags);
+        data->default_vlan_change_flg =
+                test_bit(BNX2X_Q_UPDATE_DEF_VLAN_EN_CHNG,
+                         &params->update_flags);
+
+        /* silent vlan removal */
+        data->silent_vlan_change_flg =
+                test_bit(BNX2X_Q_UPDATE_SILENT_VLAN_REM_CHNG,
+                         &params->update_flags);
+        data->silent_vlan_removal_flg =
+                test_bit(BNX2X_Q_UPDATE_SILENT_VLAN_REM, &params->update_flags);
+        data->silent_vlan_value = cpu_to_le16(params->silent_removal_value);
+        data->silent_vlan_mask = cpu_to_le16(params->silent_removal_mask);
+}
+
+static inline int bnx2x_q_send_update(struct bnx2x *bp,
+                                      struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_sp_obj *o = params->q_obj;
+        struct client_update_ramrod_data *rdata =
+                (struct client_update_ramrod_data *)o->rdata;
+        dma_addr_t data_mapping = o->rdata_mapping;
 
+        /* Clear the ramrod data */
+        memset(rdata, 0, sizeof(*rdata));
 
-        bnx2x_sp_post(bp, ramrod, params->ramrod_params.cid,
-                      U64_HI(data_mapping), U64_LO(data_mapping), 0);
+        /* Fill the ramrod data */
+        bnx2x_q_fill_update_data(bp, o, &params->params.update, rdata);
+
+        mb();
+
+        return bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_CLIENT_UPDATE, o->cid,
+                             U64_HI(data_mapping),
+                             U64_LO(data_mapping), ETH_CONNECTION_TYPE);
+}
+
+/**
+ * bnx2x_q_send_deactivate - send DEACTIVATE command
+ *
+ * @bp:         device handle
+ * @params:
+ *
+ * implemented using the UPDATE command.
+ */
+static inline int bnx2x_q_send_deactivate(struct bnx2x *bp,
+                                        struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_update_params *update = &params->params.update;
+
+        memset(update, 0, sizeof(*update));
+
+        __set_bit(BNX2X_Q_UPDATE_ACTIVATE_CHNG, &update->update_flags);
+
+        return bnx2x_q_send_update(bp, params);
+}
+
+/**
+ * bnx2x_q_send_activate - send ACTIVATE command
+ *
+ * @bp:         device handle
+ * @params:
+ *
+ * implemented using the UPDATE command.
+ */
+static inline int bnx2x_q_send_activate(struct bnx2x *bp,
+                                        struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_update_params *update = &params->params.update;
+
+        memset(update, 0, sizeof(*update));
+
+        __set_bit(BNX2X_Q_UPDATE_ACTIVATE, &update->update_flags);
+        __set_bit(BNX2X_Q_UPDATE_ACTIVATE_CHNG, &update->update_flags);
+
+        return bnx2x_q_send_update(bp, params);
+}
+
+static inline int bnx2x_q_send_update_tpa(struct bnx2x *bp,
+                                        struct bnx2x_queue_state_params *params)
+{
+        /* TODO: Not implemented yet. */
+        return -1;
+}
+
+static inline int bnx2x_q_send_halt(struct bnx2x *bp,
+                                    struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_sp_obj *o = params->q_obj;
+
+        return bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, o->cid, 0, o->cl_id,
+                             ETH_CONNECTION_TYPE);
+}
+
+static inline int bnx2x_q_send_cfc_del(struct bnx2x *bp,
+                                       struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_sp_obj *o = params->q_obj;
+
+        return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_CFC_DEL, o->cid, 0, 0,
+                             NONE_CONNECTION_TYPE);
+}
+
+static inline int bnx2x_q_send_terminate(struct bnx2x *bp,
+                                        struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_sp_obj *o = params->q_obj;
+
+        return bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_TERMINATE, o->cid, 0, 0,
+                             ETH_CONNECTION_TYPE);
+}
+
+static inline int bnx2x_q_send_empty(struct bnx2x *bp,
+                                     struct bnx2x_queue_state_params *params)
+{
+        struct bnx2x_queue_sp_obj *o = params->q_obj;
+
+        return bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_EMPTY, o->cid, 0, 0,
+                             ETH_CONNECTION_TYPE);
+}
+
+static inline int bnx2x_queue_send_cmd_cmn(struct bnx2x *bp,
+                                        struct bnx2x_queue_state_params *params)
+{
+        switch (params->cmd) {
+        case BNX2X_Q_CMD_INIT:
+                return bnx2x_q_init(bp, params);
+        case BNX2X_Q_CMD_DEACTIVATE:
+                return bnx2x_q_send_deactivate(bp, params);
+        case BNX2X_Q_CMD_ACTIVATE:
+                return bnx2x_q_send_activate(bp, params);
+        case BNX2X_Q_CMD_UPDATE:
+                return bnx2x_q_send_update(bp, params);
+        case BNX2X_Q_CMD_UPDATE_TPA:
+                return bnx2x_q_send_update_tpa(bp, params);
+        case BNX2X_Q_CMD_HALT:
+                return bnx2x_q_send_halt(bp, params);
+        case BNX2X_Q_CMD_CFC_DEL:
+                return bnx2x_q_send_cfc_del(bp, params);
+        case BNX2X_Q_CMD_TERMINATE:
+                return bnx2x_q_send_terminate(bp, params);
+        case BNX2X_Q_CMD_EMPTY:
+                return bnx2x_q_send_empty(bp, params);
+        default:
+                BNX2X_ERR("Unknown command: %d\n", params->cmd);
+                return -EINVAL;
+        }
+}
+
+static int bnx2x_queue_send_cmd_e1x(struct bnx2x *bp,
+                                    struct bnx2x_queue_state_params *params)
+{
+        switch (params->cmd) {
+        case BNX2X_Q_CMD_SETUP:
+                return bnx2x_q_send_setup_e1x(bp, params);
+        case BNX2X_Q_CMD_INIT:
+        case BNX2X_Q_CMD_DEACTIVATE:
+        case BNX2X_Q_CMD_ACTIVATE:
+        case BNX2X_Q_CMD_UPDATE:
+        case BNX2X_Q_CMD_UPDATE_TPA:
+        case BNX2X_Q_CMD_HALT:
+        case BNX2X_Q_CMD_CFC_DEL:
+        case BNX2X_Q_CMD_TERMINATE:
+        case BNX2X_Q_CMD_EMPTY:
+                return bnx2x_queue_send_cmd_cmn(bp, params);
+        default:
+                BNX2X_ERR("Unknown command: %d\n", params->cmd);
+                return -EINVAL;
+        }
+}
+
+static int bnx2x_queue_send_cmd_e2(struct bnx2x *bp,
+                                   struct bnx2x_queue_state_params *params)
+{
+        switch (params->cmd) {
+        case BNX2X_Q_CMD_SETUP:
+                return bnx2x_q_send_setup_e2(bp, params);
+        case BNX2X_Q_CMD_INIT:
+        case BNX2X_Q_CMD_DEACTIVATE:
+        case BNX2X_Q_CMD_ACTIVATE:
+        case BNX2X_Q_CMD_UPDATE:
+        case BNX2X_Q_CMD_UPDATE_TPA:
+        case BNX2X_Q_CMD_HALT:
+        case BNX2X_Q_CMD_CFC_DEL:
+        case BNX2X_Q_CMD_TERMINATE:
+        case BNX2X_Q_CMD_EMPTY:
+                return bnx2x_queue_send_cmd_cmn(bp, params);
+        default:
+                BNX2X_ERR("Unknown command: %d\n", params->cmd);
+                return -EINVAL;
+        }
+}
+
+/**
+ * bnx2x_queue_chk_transition - check state machine of a regular Queue
+ *
+ * @bp:         device handle
+ * @o:
+ * @params:
+ *
+ * (not Forwarding)
+ * It both checks if the requested command is legal in a current
+ * state and, if it's legal, sets a `next_state' in the object
+ * that will be used in the completion flow to set the `state'
+ * of the object.
+ *
+ * returns 0 if a requested command is a legal transition,
+ *         -EINVAL otherwise.
+ */
+static int bnx2x_queue_chk_transition(struct bnx2x *bp,
+                                      struct bnx2x_queue_sp_obj *o,
+                                      struct bnx2x_queue_state_params *params)
+{
+        enum bnx2x_q_state state = o->state, next_state = BNX2X_Q_STATE_MAX;
+        enum bnx2x_queue_cmd cmd = params->cmd;
+
+        switch (state) {
+        case BNX2X_Q_STATE_RESET:
+                if (cmd == BNX2X_Q_CMD_INIT)
+                        next_state = BNX2X_Q_STATE_INITIALIZED;
+
+                break;
+        case BNX2X_Q_STATE_INITIALIZED:
+                if (cmd == BNX2X_Q_CMD_SETUP) {
+                        if (test_bit(BNX2X_Q_FLG_ACTIVE,
+                                     &params->params.setup.flags))
+                                next_state = BNX2X_Q_STATE_ACTIVE;
+                        else
+                                next_state = BNX2X_Q_STATE_INACTIVE;
+                }
+
+                break;
+        case BNX2X_Q_STATE_ACTIVE:
+                if (cmd == BNX2X_Q_CMD_DEACTIVATE)
+                        next_state = BNX2X_Q_STATE_INACTIVE;
+
+                else if ((cmd == BNX2X_Q_CMD_EMPTY) ||
+                         (cmd == BNX2X_Q_CMD_UPDATE_TPA))
+                        next_state = BNX2X_Q_STATE_ACTIVE;
+
+                else if (cmd == BNX2X_Q_CMD_HALT)
+                        next_state = BNX2X_Q_STATE_STOPPED;
+
+                else if (cmd == BNX2X_Q_CMD_UPDATE) {
+                        struct bnx2x_queue_update_params *update_params =
+                                &params->params.update;
+
+                        /* If "active" state change is requested, update the
+                         *  state accordingly.
+                         */
+                        if (test_bit(BNX2X_Q_UPDATE_ACTIVATE_CHNG,
+                                     &update_params->update_flags) &&
+                            !test_bit(BNX2X_Q_UPDATE_ACTIVATE,
+                                      &update_params->update_flags))
+                                next_state = BNX2X_Q_STATE_INACTIVE;
+                        else
+                                next_state = BNX2X_Q_STATE_ACTIVE;
+                }
+
+                break;
+        case BNX2X_Q_STATE_INACTIVE:
+                if (cmd == BNX2X_Q_CMD_ACTIVATE)
+                        next_state = BNX2X_Q_STATE_ACTIVE;
+
+                else if ((cmd == BNX2X_Q_CMD_EMPTY) ||
+                         (cmd == BNX2X_Q_CMD_UPDATE_TPA))
+                        next_state = BNX2X_Q_STATE_INACTIVE;
+
+                else if (cmd == BNX2X_Q_CMD_HALT)
+                        next_state = BNX2X_Q_STATE_STOPPED;
+
+                else if (cmd == BNX2X_Q_CMD_UPDATE) {
+                        struct bnx2x_queue_update_params *update_params =
+                                &params->params.update;
+
+                        /* If "active" state change is requested, update the
+                         * state accordingly.
+                         */
+                        if (test_bit(BNX2X_Q_UPDATE_ACTIVATE_CHNG,
+                                     &update_params->update_flags) &&
+                            test_bit(BNX2X_Q_UPDATE_ACTIVATE,
+                                     &update_params->update_flags))
+                                next_state = BNX2X_Q_STATE_ACTIVE;
+                        else
+                                next_state = BNX2X_Q_STATE_INACTIVE;
+                }
+
+                break;
+        case BNX2X_Q_STATE_STOPPED:
+                if (cmd == BNX2X_Q_CMD_TERMINATE)
+                        next_state = BNX2X_Q_STATE_TERMINATED;
+
+                break;
+        case BNX2X_Q_STATE_TERMINATED:
+                if (cmd == BNX2X_Q_CMD_CFC_DEL)
+                        next_state = BNX2X_Q_STATE_RESET;
+
+                break;
+        default:
+                BNX2X_ERR("Illegal state: %d\n", state);
+        }
+
+        /* Transition is assured */
+        if (next_state != BNX2X_Q_STATE_MAX) {
+                DP(BNX2X_MSG_SP, "Good state transition: %d(%d)->%d\n",
+                                 state, cmd, next_state);
+                o->next_state = next_state;
+                return 0;
+        }
 
-        /* Wait for completion */
-        rc = bnx2x_wait_ramrod(bp, params->ramrod_params.state,
-                                 params->ramrod_params.index,
-                                 params->ramrod_params.pstate,
-                                 ramrod_flags);
+        DP(BNX2X_MSG_SP, "Bad state transition request: %d %d\n", state, cmd);
+
+        return -EINVAL;
+}
+
+void bnx2x_init_queue_obj(struct bnx2x *bp,
+                          struct bnx2x_queue_sp_obj *obj,
+                          u8 cl_id, u32 cid, u8 func_id, void *rdata,
+                          dma_addr_t rdata_mapping, unsigned long type)
+{
+        memset(obj, 0, sizeof(*obj));
+
+        obj->cid = cid;
+        obj->cl_id = cl_id;
+        obj->func_id = func_id;
+        obj->rdata = rdata;
+        obj->rdata_mapping = rdata_mapping;
+        obj->type = type;
+        obj->next_state = BNX2X_Q_STATE_MAX;
+
+        if (CHIP_IS_E1x(bp))
+                obj->send_cmd = bnx2x_queue_send_cmd_e1x;
+        else
+                obj->send_cmd = bnx2x_queue_send_cmd_e2;
+
+        obj->check_transition = bnx2x_queue_chk_transition;
+
+        obj->complete_cmd = bnx2x_queue_comp_cmd;
+        obj->wait_comp = bnx2x_queue_wait_comp;
+        obj->set_pending = bnx2x_queue_set_pending;
+}
+
+/********************** Function state object *********************************/
+
+static int bnx2x_func_wait_comp(struct bnx2x *bp,
+                                struct bnx2x_func_sp_obj *o,
+                                enum bnx2x_func_cmd cmd)
+{
+        return bnx2x_state_wait(bp, cmd, &o->pending);
+}
+
+/**
+ * bnx2x_func_state_change_comp - complete the state machine transition
+ *
+ * @bp:         device handle
+ * @o:
+ * @cmd:
+ *
+ * Called on state change transition. Completes the state
+ * machine transition only - no HW interaction.
+ */
+static inline int bnx2x_func_state_change_comp(struct bnx2x *bp,
+                                               struct bnx2x_func_sp_obj *o,
+                                               enum bnx2x_func_cmd cmd)
+{
+        unsigned long cur_pending = o->pending;
+
+        if (!test_and_clear_bit(cmd, &cur_pending)) {
+                BNX2X_ERR("Bad MC reply %d for func %d in state %d "
+                          "pending 0x%lx, next_state %d\n", cmd, BP_FUNC(bp),
+                          o->state, cur_pending, o->next_state);
+                return -EINVAL;
+        }
+
+        DP(BNX2X_MSG_SP, "Completing command %d for func %d, setting state to "
+                         "%d\n", cmd, BP_FUNC(bp), o->next_state);
+
+        o->state = o->next_state;
+        o->next_state = BNX2X_F_STATE_MAX;
+
+        /* It's important that o->state and o->next_state are
+         * updated before o->pending.
+         */
+        wmb();
+
+        clear_bit(cmd, &o->pending);
+        smp_mb__after_clear_bit();
+
+        return 0;
+}
+
+/**
+ * bnx2x_func_comp_cmd - complete the state change command
+ *
+ * @bp:         device handle
+ * @o:
+ * @cmd:
+ *
+ * Checks that the arrived completion is expected.
+ */
+static int bnx2x_func_comp_cmd(struct bnx2x *bp,
+                               struct bnx2x_func_sp_obj *o,
+                               enum bnx2x_func_cmd cmd)
+{
+        /* Complete the state machine part first, check if it's a
+         * legal completion.
+         */
+        int rc = bnx2x_func_state_change_comp(bp, o, cmd);
         return rc;
 }
 
-void bnx2x_push_indir_table(struct bnx2x *bp)
+/**
+ * bnx2x_func_chk_transition - perform function state machine transition
+ *
+ * @bp:         device handle
+ * @o:
+ * @params:
+ *
+ * It both checks if the requested command is legal in a current
+ * state and, if it's legal, sets a `next_state' in the object
+ * that will be used in the completion flow to set the `state'
+ * of the object.
+ *
+ * returns 0 if a requested command is a legal transition,
+ *         -EINVAL otherwise.
+ */
+static int bnx2x_func_chk_transition(struct bnx2x *bp,
+                                     struct bnx2x_func_sp_obj *o,
+                                     struct bnx2x_func_state_params *params)
 {
-        int func = BP_FUNC(bp);
-        int i;
+        enum bnx2x_func_state state = o->state, next_state = BNX2X_F_STATE_MAX;
+        enum bnx2x_func_cmd cmd = params->cmd;
 
-        if (bp->multi_mode == ETH_RSS_MODE_DISABLED)
-                return;
+        switch (state) {
+        case BNX2X_F_STATE_RESET:
+                if (cmd == BNX2X_F_CMD_HW_INIT)
+                        next_state = BNX2X_F_STATE_INITIALIZED;
+
+                break;
+        case BNX2X_F_STATE_INITIALIZED:
+                if (cmd == BNX2X_F_CMD_START)
+                        next_state = BNX2X_F_STATE_STARTED;
+
+                else if (cmd == BNX2X_F_CMD_HW_RESET)
+                        next_state = BNX2X_F_STATE_RESET;
+
+                break;
+        case BNX2X_F_STATE_STARTED:
+                if (cmd == BNX2X_F_CMD_STOP)
+                        next_state = BNX2X_F_STATE_INITIALIZED;
+
+                break;
+        default:
+                BNX2X_ERR("Unknown state: %d\n", state);
+        }
+
+        /* Transition is assured */
+        if (next_state != BNX2X_F_STATE_MAX) {
+                DP(BNX2X_MSG_SP, "Good function state transition: %d(%d)->%d\n",
+                                 state, cmd, next_state);
+                o->next_state = next_state;
+                return 0;
+        }
+
+        DP(BNX2X_MSG_SP, "Bad function state transition request: %d %d\n",
+                         state, cmd);
+
+        return -EINVAL;
+}
+
+/**
+ * bnx2x_func_init_func - performs HW init at function stage
+ *
+ * @bp:         device handle
+ * @drv:
+ *
+ * Init HW when the current phase is
+ * FW_MSG_CODE_DRV_LOAD_FUNCTION: initialize only FUNCTION-only
+ * HW blocks.
+ */
+static inline int bnx2x_func_init_func(struct bnx2x *bp,
+                                       const struct bnx2x_func_sp_drv_ops *drv)
+{
+        return drv->init_hw_func(bp);
+}
+
+/**
+ * bnx2x_func_init_port - performs HW init at port stage
+ *
+ * @bp:         device handle
+ * @drv:
+ *
+ * Init HW when the current phase is
+ * FW_MSG_CODE_DRV_LOAD_PORT: initialize PORT-only and
+ * FUNCTION-only HW blocks.
+ *
+ */
+static inline int bnx2x_func_init_port(struct bnx2x *bp,
+                                       const struct bnx2x_func_sp_drv_ops *drv)
+{
+        int rc = drv->init_hw_port(bp);
+        if (rc)
+                return rc;
+
+        return bnx2x_func_init_func(bp, drv);
+}
+
+/**
+ * bnx2x_func_init_cmn_chip - performs HW init at chip-common stage
+ *
+ * @bp:         device handle
+ * @drv:
+ *
+ * Init HW when the current phase is
+ * FW_MSG_CODE_DRV_LOAD_COMMON_CHIP: initialize COMMON_CHIP,
+ * PORT-only and FUNCTION-only HW blocks.
+ */
+static inline int bnx2x_func_init_cmn_chip(struct bnx2x *bp,
+                                        const struct bnx2x_func_sp_drv_ops *drv)
+{
+        int rc = drv->init_hw_cmn_chip(bp);
+        if (rc)
+                return rc;
+
+        return bnx2x_func_init_port(bp, drv);
+}
+
+/**
+ * bnx2x_func_init_cmn - performs HW init at common stage
+ *
+ * @bp:         device handle
+ * @drv:
+ *
+ * Init HW when the current phase is
+ * FW_MSG_CODE_DRV_LOAD_COMMON_CHIP: initialize COMMON,
+ * PORT-only and FUNCTION-only HW blocks.
+ */
+static inline int bnx2x_func_init_cmn(struct bnx2x *bp,
+                                      const struct bnx2x_func_sp_drv_ops *drv)
+{
+        int rc = drv->init_hw_cmn(bp);
+        if (rc)
+                return rc;
+
+        return bnx2x_func_init_port(bp, drv);
+}
+
+static int bnx2x_func_hw_init(struct bnx2x *bp,
+                              struct bnx2x_func_state_params *params)
+{
+        u32 load_code = params->params.hw_init.load_phase;
+        struct bnx2x_func_sp_obj *o = params->f_obj;
+        const struct bnx2x_func_sp_drv_ops *drv = o->drv;
+        int rc = 0;
+
+        DP(BNX2X_MSG_SP, "function %d  load_code %x\n",
+                         BP_ABS_FUNC(bp), load_code);
+
+        /* Prepare buffers for unzipping the FW */
+        rc = drv->gunzip_init(bp);
+        if (rc)
+                return rc;
+
+        /* Prepare FW */
+        rc = drv->init_fw(bp);
+        if (rc) {
+                BNX2X_ERR("Error loading firmware\n");
+                goto fw_init_err;
+        }
+
+        /* Handle the beginning of COMMON_XXX pases separatelly... */
+        switch (load_code) {
+        case FW_MSG_CODE_DRV_LOAD_COMMON_CHIP:
+                rc = bnx2x_func_init_cmn_chip(bp, drv);
+                if (rc)
+                        goto init_hw_err;
+
+                break;
+        case FW_MSG_CODE_DRV_LOAD_COMMON:
+                rc = bnx2x_func_init_cmn(bp, drv);
+                if (rc)
+                        goto init_hw_err;
+
+                break;
+        case FW_MSG_CODE_DRV_LOAD_PORT:
+                rc = bnx2x_func_init_port(bp, drv);
+                if (rc)
+                        goto init_hw_err;
+
+                break;
+        case FW_MSG_CODE_DRV_LOAD_FUNCTION:
+                rc = bnx2x_func_init_func(bp, drv);
+                if (rc)
+                        goto init_hw_err;
+
+                break;
+        default:
+                BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
+                rc = -EINVAL;
+        }
+
+init_hw_err:
+        drv->release_fw(bp);
+
+fw_init_err:
+        drv->gunzip_end(bp);
+
+        /* In case of success, complete the comand immediatelly: no ramrods
+         * have been sent.
+         */
+        if (!rc)
+                o->complete_cmd(bp, o, BNX2X_F_CMD_HW_INIT);
+
+        return rc;
+}
+
+/**
+ * bnx2x_func_reset_func - reset HW at function stage
+ *
+ * @bp:         device handle
+ * @drv:
+ *
+ * Reset HW at FW_MSG_CODE_DRV_UNLOAD_FUNCTION stage: reset only
+ * FUNCTION-only HW blocks.
+ */
+static inline void bnx2x_func_reset_func(struct bnx2x *bp,
+                                        const struct bnx2x_func_sp_drv_ops *drv)
+{
+        drv->reset_hw_func(bp);
+}
+
+/**
+ * bnx2x_func_reset_port - reser HW at port stage
+ *
+ * @bp:         device handle
+ * @drv:
+ *
+ * Reset HW at FW_MSG_CODE_DRV_UNLOAD_PORT stage: reset
+ * FUNCTION-only and PORT-only HW blocks.
+ *
+ *                 !!!IMPORTANT!!!
+ *
+ * It's important to call reset_port before reset_func() as the last thing
+ * reset_func does is pf_disable() thus disabling PGLUE_B, which
+ * makes impossible any DMAE transactions.
+ */
+static inline void bnx2x_func_reset_port(struct bnx2x *bp,
+                                        const struct bnx2x_func_sp_drv_ops *drv)
+{
+        drv->reset_hw_port(bp);
+        bnx2x_func_reset_func(bp, drv);
+}
+
+/**
+ * bnx2x_func_reset_cmn - reser HW at common stage
+ *
+ * @bp:         device handle
+ * @drv:
+ *
+ * Reset HW at FW_MSG_CODE_DRV_UNLOAD_COMMON and
+ * FW_MSG_CODE_DRV_UNLOAD_COMMON_CHIP stages: reset COMMON,
+ * COMMON_CHIP, FUNCTION-only and PORT-only HW blocks.
+ */
+static inline void bnx2x_func_reset_cmn(struct bnx2x *bp,
+                                        const struct bnx2x_func_sp_drv_ops *drv)
+{
+        bnx2x_func_reset_port(bp, drv);
+        drv->reset_hw_cmn(bp);
+}
+
+
+static inline int bnx2x_func_hw_reset(struct bnx2x *bp,
+                                      struct bnx2x_func_state_params *params)
+{
+        u32 reset_phase = params->params.hw_reset.reset_phase;
+        struct bnx2x_func_sp_obj *o = params->f_obj;
+        const struct bnx2x_func_sp_drv_ops *drv = o->drv;
+
+        DP(BNX2X_MSG_SP, "function %d  reset_phase %x\n", BP_ABS_FUNC(bp),
+                         reset_phase);
+
+        switch (reset_phase) {
+        case FW_MSG_CODE_DRV_UNLOAD_COMMON:
+                bnx2x_func_reset_cmn(bp, drv);
+                break;
+        case FW_MSG_CODE_DRV_UNLOAD_PORT:
+                bnx2x_func_reset_port(bp, drv);
+                break;
+        case FW_MSG_CODE_DRV_UNLOAD_FUNCTION:
+                bnx2x_func_reset_func(bp, drv);
+                break;
+        default:
+                BNX2X_ERR("Unknown reset_phase (0x%x) from MCP\n",
+                           reset_phase);
+                break;
+        }
+
+        /* Complete the comand immediatelly: no ramrods have been sent. */
+        o->complete_cmd(bp, o, BNX2X_F_CMD_HW_RESET);
+
+        return 0;
+}
+
+static inline int bnx2x_func_send_start(struct bnx2x *bp,
+                                        struct bnx2x_func_state_params *params)
+{
+        struct bnx2x_func_sp_obj *o = params->f_obj;
+        struct function_start_data *rdata =
+                (struct function_start_data *)o->rdata;
+        dma_addr_t data_mapping = o->rdata_mapping;
+        struct bnx2x_func_start_params *start_params = &params->params.start;
+
+        memset(rdata, 0, sizeof(*rdata));
+
+        /* Fill the ramrod data with provided parameters */
+        rdata->function_mode = cpu_to_le16(start_params->mf_mode);
+        rdata->sd_vlan_tag   = start_params->sd_vlan_tag;
+        rdata->path_id       = BP_PATH(bp);
+        rdata->network_cos_mode = start_params->network_cos_mode;
+
+        mb();
+
+        return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_START, 0,
+                             U64_HI(data_mapping),
+                             U64_LO(data_mapping), NONE_CONNECTION_TYPE);
+}
+
+static inline int bnx2x_func_send_stop(struct bnx2x *bp,
+                                       struct bnx2x_func_state_params *params)
+{
+        return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_STOP, 0, 0, 0,
+                             NONE_CONNECTION_TYPE);
+}
+
+static int bnx2x_func_send_cmd(struct bnx2x *bp,
+                               struct bnx2x_func_state_params *params)
+{
+        switch (params->cmd) {
+        case BNX2X_F_CMD_HW_INIT:
+                return bnx2x_func_hw_init(bp, params);
+        case BNX2X_F_CMD_START:
+                return bnx2x_func_send_start(bp, params);
+        case BNX2X_F_CMD_STOP:
+                return bnx2x_func_send_stop(bp, params);
+        case BNX2X_F_CMD_HW_RESET:
+                return bnx2x_func_hw_reset(bp, params);
+        default:
+                BNX2X_ERR("Unknown command: %d\n", params->cmd);
+                return -EINVAL;
+        }
+}
+
+void bnx2x_init_func_obj(struct bnx2x *bp,
+                         struct bnx2x_func_sp_obj *obj,
+                         void *rdata, dma_addr_t rdata_mapping,
+                         struct bnx2x_func_sp_drv_ops *drv_iface)
+{
+        memset(obj, 0, sizeof(*obj));
+
+        mutex_init(&obj->one_pending_mutex);
+
+        obj->rdata = rdata;
+        obj->rdata_mapping = rdata_mapping;
+
+        obj->send_cmd = bnx2x_func_send_cmd;
+        obj->check_transition = bnx2x_func_chk_transition;
+        obj->complete_cmd = bnx2x_func_comp_cmd;
+        obj->wait_comp = bnx2x_func_wait_comp;
+
+        obj->drv = drv_iface;
+}
+
+/**
+ * bnx2x_func_state_change - perform Function state change transition
+ *
+ * @bp:         device handle
+ * @params:     parameters to perform the transaction
+ *
+ * returns 0 in case of successfully completed transition,
+ *         negative error code in case of failure, positive
+ *         (EBUSY) value if there is a completion to that is
+ *         still pending (possible only if RAMROD_COMP_WAIT is
+ *         not set in params->ramrod_flags for asynchronous
+ *         commands).
+ */
+int bnx2x_func_state_change(struct bnx2x *bp,
+                            struct bnx2x_func_state_params *params)
+{
+        struct bnx2x_func_sp_obj *o = params->f_obj;
+        int rc;
+        enum bnx2x_func_cmd cmd = params->cmd;
+        unsigned long *pending = &o->pending;
+
+        mutex_lock(&o->one_pending_mutex);
+
+        /* Check that the requested transition is legal */
+        if (o->check_transition(bp, o, params)) {
+                mutex_unlock(&o->one_pending_mutex);
+                return -EINVAL;
+        }
+
+        /* Set "pending" bit */
+        set_bit(cmd, pending);
+
+        /* Don't send a command if only driver cleanup was requested */
+        if (test_bit(RAMROD_DRV_CLR_ONLY, &params->ramrod_flags)) {
+                bnx2x_func_state_change_comp(bp, o, cmd);
+                mutex_unlock(&o->one_pending_mutex);
+        } else {
+                /* Send a ramrod */
+                rc = o->send_cmd(bp, params);
+
+                mutex_unlock(&o->one_pending_mutex);
+
+                if (rc) {
+                        o->next_state = BNX2X_F_STATE_MAX;
+                        clear_bit(cmd, pending);
+                        smp_mb__after_clear_bit();
+                        return rc;
+                }
+
+                if (test_bit(RAMROD_COMP_WAIT, &params->ramrod_flags)) {
+                        rc = o->wait_comp(bp, o, cmd);
+                        if (rc)
+                                return rc;
+
+                        return 0;
+                }
+        }
 
-        for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
-                REG_WR8(bp, BAR_TSTRORM_INTMEM +
-                        TSTORM_INDIRECTION_TABLE_OFFSET(func) + i,
-                        bp->fp->cl_id + bp->rx_indir_table[i]);
+        return !!test_bit(cmd, pending);
 }
diff --git a/drivers/net/bnx2x/bnx2x_sp.h b/drivers/net/bnx2x/bnx2x_sp.h
index f9b755e4a108..86eaa80721ea 100644
--- a/drivers/net/bnx2x/bnx2x_sp.h
+++ b/drivers/net/bnx2x/bnx2x_sp.h
@@ -1,43 +1,1235 @@
-#ifndef BNX2X_SP
-#define BNX2X_SP
-
-#include "bnx2x_reg.h"
-
-/* MAC configuration */
-void bnx2x_set_mac_addr_gen(struct bnx2x *bp, int set, const u8 *mac,
-                            u32 cl_bit_vec, u8 cam_offset,
-                            u8 is_bcast);
-
-/* Multicast */
-void bnx2x_invalidate_e1_mc_list(struct bnx2x *bp);
-void bnx2x_invalidate_e1h_mc_list(struct bnx2x *bp);
-int bnx2x_set_e1_mc_list(struct bnx2x *bp);
-int bnx2x_set_e1h_mc_list(struct bnx2x *bp);
-
-/* Rx mode */
-void bnx2x_set_storm_rx_mode(struct bnx2x *bp);
-void bnx2x_rxq_set_mac_filters(struct bnx2x *bp, u16 cl_id, u32 filters);
-
-/* RSS configuration */
-void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p);
-void bnx2x_push_indir_table(struct bnx2x *bp);
-
-/* Queue configuration */
-static inline void bnx2x_set_ctx_validation(struct eth_context *cxt, u32 cid)
-{
-        /* ustorm cxt validation */
-        cxt->ustorm_ag_context.cdu_usage =
-                CDU_RSRVD_VALUE_TYPE_A(cid, CDU_REGION_NUMBER_UCM_AG,
-                                       ETH_CONNECTION_TYPE);
-        /* xcontext validation */
-        cxt->xstorm_ag_context.cdu_reserved =
-                CDU_RSRVD_VALUE_TYPE_A(cid, CDU_REGION_NUMBER_XCM_AG,
-                                       ETH_CONNECTION_TYPE);
-}
-
-int bnx2x_setup_fw_client(struct bnx2x *bp,
-                          struct bnx2x_client_init_params *params,
-                          u8 activate,
-                          struct client_init_ramrod_data *data,
-                          dma_addr_t data_mapping);
-#endif /* BNX2X_SP */
+/* bnx2x_sp.h: Broadcom Everest network driver.
+ *
+ * Copyright 2011 Broadcom Corporation
+ *
+ * Unless you and Broadcom execute a separate written software license
+ * agreement governing use of this software, this software is licensed to you
+ * under the terms of the GNU General Public License version 2, available
+ * at http://www.gnu.org/licenses/old-licenses/gpl-2.0.html (the "GPL").
+ *
+ * Notwithstanding the above, under no circumstances may you combine this
+ * software in any way with any other Broadcom software provided under a
+ * license other than the GPL, without Broadcom's express prior written
+ * consent.
+ *
+ * Maintained by: Eilon Greenstein <eilong@broadcom.com>
+ * Written by: Vladislav Zolotarov
+ *
+ */
+#ifndef BNX2X_SP_VERBS
+#define BNX2X_SP_VERBS
+
+struct bnx2x;
+struct eth_context;
+
+/* Bits representing general command's configuration */
+enum {
+        RAMROD_TX,
+        RAMROD_RX,
+        /* Wait until all pending commands complete */
+        RAMROD_COMP_WAIT,
+        /* Don't send a ramrod, only update a registry */
+        RAMROD_DRV_CLR_ONLY,
+        /* Configure HW according to the current object state */
+        RAMROD_RESTORE,
+         /* Execute the next command now */
+        RAMROD_EXEC,
+        /*
+         * Don't add a new command and continue execution of posponed
+         * commands. If not set a new command will be added to the
+         * pending commands list.
+         */
+        RAMROD_CONT,
+};
+
+typedef enum {
+        BNX2X_OBJ_TYPE_RX,
+        BNX2X_OBJ_TYPE_TX,
+        BNX2X_OBJ_TYPE_RX_TX,
+} bnx2x_obj_type;
+
+/* Filtering states */
+enum {
+        BNX2X_FILTER_MAC_PENDING,
+        BNX2X_FILTER_VLAN_PENDING,
+        BNX2X_FILTER_VLAN_MAC_PENDING,
+        BNX2X_FILTER_RX_MODE_PENDING,
+        BNX2X_FILTER_RX_MODE_SCHED,
+        BNX2X_FILTER_ISCSI_ETH_START_SCHED,
+        BNX2X_FILTER_ISCSI_ETH_STOP_SCHED,
+        BNX2X_FILTER_FCOE_ETH_START_SCHED,
+        BNX2X_FILTER_FCOE_ETH_STOP_SCHED,
+        BNX2X_FILTER_MCAST_PENDING,
+        BNX2X_FILTER_MCAST_SCHED,
+        BNX2X_FILTER_RSS_CONF_PENDING,
+};
+
+struct bnx2x_raw_obj {
+        u8              func_id;
+
+        /* Queue params */
+        u8              cl_id;
+        u32             cid;
+
+        /* Ramrod data buffer params */
+        void            *rdata;
+        dma_addr_t      rdata_mapping;
+
+        /* Ramrod state params */
+        int             state;   /* "ramrod is pending" state bit */
+        unsigned long   *pstate; /* pointer to state buffer */
+
+        bnx2x_obj_type  obj_type;
+
+        int (*wait_comp)(struct bnx2x *bp,
+                         struct bnx2x_raw_obj *o);
+
+        bool (*check_pending)(struct bnx2x_raw_obj *o);
+        void (*clear_pending)(struct bnx2x_raw_obj *o);
+        void (*set_pending)(struct bnx2x_raw_obj *o);
+};
+
+/************************* VLAN-MAC commands related parameters ***************/
+struct bnx2x_mac_ramrod_data {
+        u8 mac[ETH_ALEN];
+};
+
+struct bnx2x_vlan_ramrod_data {
+        u16 vlan;
+};
+
+struct bnx2x_vlan_mac_ramrod_data {
+        u8 mac[ETH_ALEN];
+        u16 vlan;
+};
+
+union bnx2x_classification_ramrod_data {
+        struct bnx2x_mac_ramrod_data mac;
+        struct bnx2x_vlan_ramrod_data vlan;
+        struct bnx2x_vlan_mac_ramrod_data vlan_mac;
+};
+
+/* VLAN_MAC commands */
+enum bnx2x_vlan_mac_cmd {
+        BNX2X_VLAN_MAC_ADD,
+        BNX2X_VLAN_MAC_DEL,
+        BNX2X_VLAN_MAC_MOVE,
+};
+
+struct bnx2x_vlan_mac_data {
+        /* Requested command: BNX2X_VLAN_MAC_XX */
+        enum bnx2x_vlan_mac_cmd cmd;
+        /*
+         * used to contain the data related vlan_mac_flags bits from
+         * ramrod parameters.
+         */
+        unsigned long vlan_mac_flags;
+
+        /* Needed for MOVE command */
+        struct bnx2x_vlan_mac_obj *target_obj;
+
+        union bnx2x_classification_ramrod_data u;
+};
+
+/*************************** Exe Queue obj ************************************/
+union bnx2x_exe_queue_cmd_data {
+        struct bnx2x_vlan_mac_data vlan_mac;
+
+        struct {
+                /* TODO */
+        } mcast;
+};
+
+struct bnx2x_exeq_elem {
+        struct list_head                link;
+
+        /* Length of this element in the exe_chunk. */
+        int                             cmd_len;
+
+        union bnx2x_exe_queue_cmd_data  cmd_data;
+};
+
+union bnx2x_qable_obj;
+
+union bnx2x_exeq_comp_elem {
+        union event_ring_elem *elem;
+};
+
+struct bnx2x_exe_queue_obj;
+
+typedef int (*exe_q_validate)(struct bnx2x *bp,
+                              union bnx2x_qable_obj *o,
+                              struct bnx2x_exeq_elem *elem);
+
+/**
+ * @return positive is entry was optimized, 0 - if not, negative
+ *         in case of an error.
+ */
+typedef int (*exe_q_optimize)(struct bnx2x *bp,
+                              union bnx2x_qable_obj *o,
+                              struct bnx2x_exeq_elem *elem);
+typedef int (*exe_q_execute)(struct bnx2x *bp,
+                             union bnx2x_qable_obj *o,
+                             struct list_head *exe_chunk,
+                             unsigned long *ramrod_flags);
+typedef struct bnx2x_exeq_elem *
+                        (*exe_q_get)(struct bnx2x_exe_queue_obj *o,
+                                     struct bnx2x_exeq_elem *elem);
+
+struct bnx2x_exe_queue_obj {
+        /*
+         * Commands pending for an execution.
+         */
+        struct list_head        exe_queue;
+
+        /*
+         * Commands pending for an completion.
+         */
+        struct list_head        pending_comp;
+
+        spinlock_t              lock;
+
+        /* Maximum length of commands' list for one execution */
+        int                     exe_chunk_len;
+
+        union bnx2x_qable_obj   *owner;
+
+        /****** Virtual functions ******/
+        /**
+         * Called before commands execution for commands that are really
+         * going to be executed (after 'optimize').
+         *
+         * Must run under exe_queue->lock
+         */
+        exe_q_validate          validate;
+
+
+        /**
+         * This will try to cancel the current pending commands list
+         * considering the new command.
+         *
+         * Must run under exe_queue->lock
+         */
+        exe_q_optimize          optimize;
+
+        /**
+         * Run the next commands chunk (owner specific).
+         */
+        exe_q_execute           execute;
+
+        /**
+         * Return the exe_queue element containing the specific command
+         * if any. Otherwise return NULL.
+         */
+        exe_q_get               get;
+};
+/***************** Classification verbs: Set/Del MAC/VLAN/VLAN-MAC ************/
+/*
+ * Element in the VLAN_MAC registry list having all currenty configured
+ * rules.
+ */
+struct bnx2x_vlan_mac_registry_elem {
+        struct list_head        link;
+
+        /*
+         * Used to store the cam offset used for the mac/vlan/vlan-mac.
+         * Relevant for 57710 and 57711 only. VLANs and MACs share the
+         * same CAM for these chips.
+         */
+        int                     cam_offset;
+
+        /* Needed for DEL and RESTORE flows */
+        unsigned long           vlan_mac_flags;
+
+        union bnx2x_classification_ramrod_data u;
+};
+
+/* Bits representing VLAN_MAC commands specific flags */
+enum {
+        BNX2X_UC_LIST_MAC,
+        BNX2X_ETH_MAC,
+        BNX2X_ISCSI_ETH_MAC,
+        BNX2X_NETQ_ETH_MAC,
+        BNX2X_DONT_CONSUME_CAM_CREDIT,
+        BNX2X_DONT_CONSUME_CAM_CREDIT_DEST,
+};
+
+struct bnx2x_vlan_mac_ramrod_params {
+        /* Object to run the command from */
+        struct bnx2x_vlan_mac_obj *vlan_mac_obj;
+
+        /* General command flags: COMP_WAIT, etc. */
+        unsigned long ramrod_flags;
+
+        /* Command specific configuration request */
+        struct bnx2x_vlan_mac_data user_req;
+};
+
+struct bnx2x_vlan_mac_obj {
+        struct bnx2x_raw_obj raw;
+
+        /* Bookkeeping list: will prevent the addition of already existing
+         * entries.
+         */
+        struct list_head                head;
+
+        /* TODO: Add it's initialization in the init functions */
+        struct bnx2x_exe_queue_obj      exe_queue;
+
+        /* MACs credit pool */
+        struct bnx2x_credit_pool_obj    *macs_pool;
+
+        /* VLANs credit pool */
+        struct bnx2x_credit_pool_obj    *vlans_pool;
+
+        /* RAMROD command to be used */
+        int                             ramrod_cmd;
+
+        /**
+         * Checks if ADD-ramrod with the given params may be performed.
+         *
+         * @return zero if the element may be added
+         */
+
+        int (*check_add)(struct bnx2x_vlan_mac_obj *o,
+                         union bnx2x_classification_ramrod_data *data);
+
+        /**
+         * Checks if DEL-ramrod with the given params may be performed.
+         *
+         * @return true if the element may be deleted
+         */
+        struct bnx2x_vlan_mac_registry_elem *
+                (*check_del)(struct bnx2x_vlan_mac_obj *o,
+                             union bnx2x_classification_ramrod_data *data);
+
+        /**
+         * Checks if DEL-ramrod with the given params may be performed.
+         *
+         * @return true if the element may be deleted
+         */
+        bool (*check_move)(struct bnx2x_vlan_mac_obj *src_o,
+                           struct bnx2x_vlan_mac_obj *dst_o,
+                           union bnx2x_classification_ramrod_data *data);
+
+        /**
+         *  Update the relevant credit object(s) (consume/return
+         *  correspondingly).
+         */
+        bool (*get_credit)(struct bnx2x_vlan_mac_obj *o);
+        bool (*put_credit)(struct bnx2x_vlan_mac_obj *o);
+        bool (*get_cam_offset)(struct bnx2x_vlan_mac_obj *o, int *offset);
+        bool (*put_cam_offset)(struct bnx2x_vlan_mac_obj *o, int offset);
+
+        /**
+         * Configures one rule in the ramrod data buffer.
+         */
+        void (*set_one_rule)(struct bnx2x *bp,
+                             struct bnx2x_vlan_mac_obj *o,
+                             struct bnx2x_exeq_elem *elem, int rule_idx,
+                             int cam_offset);
+
+        /**
+        *  Delete all configured elements having the given
+        *  vlan_mac_flags specification. Assumes no pending for
+        *  execution commands. Will schedule all all currently
+        *  configured MACs/VLANs/VLAN-MACs matching the vlan_mac_flags
+        *  specification for deletion and will use the given
+        *  ramrod_flags for the last DEL operation.
+         *
+         * @param bp
+         * @param o
+         * @param ramrod_flags RAMROD_XX flags
+         *
+         * @return 0 if the last operation has completed successfully
+         *         and there are no more elements left, positive value
+         *         if there are pending for completion commands,
+         *         negative value in case of failure.
+         */
+        int (*delete_all)(struct bnx2x *bp,
+                          struct bnx2x_vlan_mac_obj *o,
+                          unsigned long *vlan_mac_flags,
+                          unsigned long *ramrod_flags);
+
+        /**
+         * Reconfigures the next MAC/VLAN/VLAN-MAC element from the previously
+         * configured elements list.
+         *
+         * @param bp
+         * @param p Command parameters (RAMROD_COMP_WAIT bit in
+         *          ramrod_flags is only taken into an account)
+         * @param ppos a pointer to the cooky that should be given back in the
+         *        next call to make function handle the next element. If
+         *        *ppos is set to NULL it will restart the iterator.
+         *        If returned *ppos == NULL this means that the last
+         *        element has been handled.
+         *
+         * @return int
+         */
+        int (*restore)(struct bnx2x *bp,
+                       struct bnx2x_vlan_mac_ramrod_params *p,
+                       struct bnx2x_vlan_mac_registry_elem **ppos);
+
+        /**
+         * Should be called on a completion arival.
+         *
+         * @param bp
+         * @param o
+         * @param cqe Completion element we are handling
+         * @param ramrod_flags if RAMROD_CONT is set the next bulk of
+         *                     pending commands will be executed.
+         *                     RAMROD_DRV_CLR_ONLY and RAMROD_RESTORE
+         *                     may also be set if needed.
+         *
+         * @return 0 if there are neither pending nor waiting for
+         *         completion commands. Positive value if there are
+         *         pending for execution or for completion commands.
+         *         Negative value in case of an error (including an
+         *         error in the cqe).
+         */
+        int (*complete)(struct bnx2x *bp, struct bnx2x_vlan_mac_obj *o,
+                        union event_ring_elem *cqe,
+                        unsigned long *ramrod_flags);
+
+        /**
+         * Wait for completion of all commands. Don't schedule new ones,
+         * just wait. It assumes that the completion code will schedule
+         * for new commands.
+         */
+        int (*wait)(struct bnx2x *bp, struct bnx2x_vlan_mac_obj *o);
+};
+
+/** RX_MODE verbs:DROP_ALL/ACCEPT_ALL/ACCEPT_ALL_MULTI/ACCEPT_ALL_VLAN/NORMAL */
+
+/* RX_MODE ramrod spesial flags: set in rx_mode_flags field in
+ * a bnx2x_rx_mode_ramrod_params.
+ */
+enum {
+        BNX2X_RX_MODE_FCOE_ETH,
+        BNX2X_RX_MODE_ISCSI_ETH,
+};
+
+enum {
+        BNX2X_ACCEPT_UNICAST,
+        BNX2X_ACCEPT_MULTICAST,
+        BNX2X_ACCEPT_ALL_UNICAST,
+        BNX2X_ACCEPT_ALL_MULTICAST,
+        BNX2X_ACCEPT_BROADCAST,
+        BNX2X_ACCEPT_UNMATCHED,
+        BNX2X_ACCEPT_ANY_VLAN
+};
+
+struct bnx2x_rx_mode_ramrod_params {
+        struct bnx2x_rx_mode_obj *rx_mode_obj;
+        unsigned long *pstate;
+        int state;
+        u8 cl_id;
+        u32 cid;
+        u8 func_id;
+        unsigned long ramrod_flags;
+        unsigned long rx_mode_flags;
+
+        /*
+         * rdata is either a pointer to eth_filter_rules_ramrod_data(e2) or to
+         * a tstorm_eth_mac_filter_config (e1x).
+         */
+        void *rdata;
+        dma_addr_t rdata_mapping;
+
+        /* Rx mode settings */
+        unsigned long rx_accept_flags;
+
+        /* internal switching settings */
+        unsigned long tx_accept_flags;
+};
+
+struct bnx2x_rx_mode_obj {
+        int (*config_rx_mode)(struct bnx2x *bp,
+                              struct bnx2x_rx_mode_ramrod_params *p);
+
+        int (*wait_comp)(struct bnx2x *bp,
+                         struct bnx2x_rx_mode_ramrod_params *p);
+};
+
+/********************** Set multicast group ***********************************/
+
+struct bnx2x_mcast_list_elem {
+        struct list_head link;
+        u8 *mac;
+};
+
+union bnx2x_mcast_config_data {
+        u8 *mac;
+        u8 bin; /* used in a RESTORE flow */
+};
+
+struct bnx2x_mcast_ramrod_params {
+        struct bnx2x_mcast_obj *mcast_obj;
+
+        /* Relevant options are RAMROD_COMP_WAIT and RAMROD_DRV_CLR_ONLY */
+        unsigned long ramrod_flags;
+
+        struct list_head mcast_list; /* list of struct bnx2x_mcast_list_elem */
+        /** TODO:
+         *      - rename it to macs_num.
+         *      - Add a new command type for handling pending commands
+         *        (remove "zero semantics").
+         *
+         *  Length of mcast_list. If zero and ADD_CONT command - post
+         *  pending commands.
+         */
+        int mcast_list_len;
+};
+
+enum {
+        BNX2X_MCAST_CMD_ADD,
+        BNX2X_MCAST_CMD_CONT,
+        BNX2X_MCAST_CMD_DEL,
+        BNX2X_MCAST_CMD_RESTORE,
+};
+
+struct bnx2x_mcast_obj {
+        struct bnx2x_raw_obj raw;
+
+        union {
+                struct {
+                #define BNX2X_MCAST_BINS_NUM    256
+                #define BNX2X_MCAST_VEC_SZ      (BNX2X_MCAST_BINS_NUM / 64)
+                        u64 vec[BNX2X_MCAST_VEC_SZ];
+
+                        /** Number of BINs to clear. Should be updated
+                         *  immediately when a command arrives in order to
+                         *  properly create DEL commands.
+                         */
+                        int num_bins_set;
+                } aprox_match;
+
+                struct {
+                        struct list_head macs;
+                        int num_macs_set;
+                } exact_match;
+        } registry;
+
+        /* Pending commands */
+        struct list_head pending_cmds_head;
+
+        /* A state that is set in raw.pstate, when there are pending commands */
+        int sched_state;
+
+        /* Maximal number of mcast MACs configured in one command */
+        int max_cmd_len;
+
+        /* Total number of currently pending MACs to configure: both
+         * in the pending commands list and in the current command.
+         */
+        int total_pending_num;
+
+        u8 engine_id;
+
+        /**
+         * @param cmd command to execute (BNX2X_MCAST_CMD_X, see above)
+         */
+        int (*config_mcast)(struct bnx2x *bp,
+                                struct bnx2x_mcast_ramrod_params *p, int cmd);
+
+        /**
+         * Fills the ramrod data during the RESTORE flow.
+         *
+         * @param bp
+         * @param o
+         * @param start_idx Registry index to start from
+         * @param rdata_idx Index in the ramrod data to start from
+         *
+         * @return -1 if we handled the whole registry or index of the last
+         *         handled registry element.
+         */
+        int (*hdl_restore)(struct bnx2x *bp, struct bnx2x_mcast_obj *o,
+                           int start_bin, int *rdata_idx);
+
+        int (*enqueue_cmd)(struct bnx2x *bp, struct bnx2x_mcast_obj *o,
+                           struct bnx2x_mcast_ramrod_params *p, int cmd);
+
+        void (*set_one_rule)(struct bnx2x *bp,
+                             struct bnx2x_mcast_obj *o, int idx,
+                             union bnx2x_mcast_config_data *cfg_data, int cmd);
+
+        /** Checks if there are more mcast MACs to be set or a previous
+         *  command is still pending.
+         */
+        bool (*check_pending)(struct bnx2x_mcast_obj *o);
+
+        /**
+         * Set/Clear/Check SCHEDULED state of the object
+         */
+        void (*set_sched)(struct bnx2x_mcast_obj *o);
+        void (*clear_sched)(struct bnx2x_mcast_obj *o);
+        bool (*check_sched)(struct bnx2x_mcast_obj *o);
+
+        /* Wait until all pending commands complete */
+        int (*wait_comp)(struct bnx2x *bp, struct bnx2x_mcast_obj *o);
+
+        /**
+         * Handle the internal object counters needed for proper
+         * commands handling. Checks that the provided parameters are
+         * feasible.
+         */
+        int (*validate)(struct bnx2x *bp,
+                        struct bnx2x_mcast_ramrod_params *p, int cmd);
+
+        /**
+         * Restore the values of internal counters in case of a failure.
+         */
+        void (*revert)(struct bnx2x *bp,
+                       struct bnx2x_mcast_ramrod_params *p,
+                       int old_num_bins);
+
+        int (*get_registry_size)(struct bnx2x_mcast_obj *o);
+        void (*set_registry_size)(struct bnx2x_mcast_obj *o, int n);
+};
+
+/*************************** Credit handling **********************************/
+struct bnx2x_credit_pool_obj {
+
+        /* Current amount of credit in the pool */
+        atomic_t        credit;
+
+        /* Maximum allowed credit. put() will check against it. */
+        int             pool_sz;
+
+        /*
+         *  Allocate a pool table statically.
+         *
+         *  Currently the mamimum allowed size is MAX_MAC_CREDIT_E2(272)
+         *
+         *  The set bit in the table will mean that the entry is available.
+         */
+#define BNX2X_POOL_VEC_SIZE     (MAX_MAC_CREDIT_E2 / 64)
+        u64             pool_mirror[BNX2X_POOL_VEC_SIZE];
+
+        /* Base pool offset (initialized differently */
+        int             base_pool_offset;
+
+        /**
+         * Get the next free pool entry.
+         *
+         * @return true if there was a free entry in the pool
+         */
+        bool (*get_entry)(struct bnx2x_credit_pool_obj *o, int *entry);
+
+        /**
+         * Return the entry back to the pool.
+         *
+         * @return true if entry is legal and has been successfully
+         *         returned to the pool.
+         */
+        bool (*put_entry)(struct bnx2x_credit_pool_obj *o, int entry);
+
+        /**
+         * Get the requested amount of credit from the pool.
+         *
+         * @param cnt Amount of requested credit
+         * @return true if the operation is successful
+         */
+        bool (*get)(struct bnx2x_credit_pool_obj *o, int cnt);
+
+        /**
+         * Returns the credit to the pool.
+         *
+         * @param cnt Amount of credit to return
+         * @return true if the operation is successful
+         */
+        bool (*put)(struct bnx2x_credit_pool_obj *o, int cnt);
+
+        /**
+         * Reads the current amount of credit.
+         */
+        int (*check)(struct bnx2x_credit_pool_obj *o);
+};
+
+/*************************** RSS configuration ********************************/
+enum {
+        /* RSS_MODE bits are mutually exclusive */
+        BNX2X_RSS_MODE_DISABLED,
+        BNX2X_RSS_MODE_REGULAR,
+        BNX2X_RSS_MODE_VLAN_PRI,
+        BNX2X_RSS_MODE_E1HOV_PRI,
+        BNX2X_RSS_MODE_IP_DSCP,
+
+        BNX2X_RSS_SET_SRCH, /* Setup searcher, E1x specific flag */
+
+        BNX2X_RSS_IPV4,
+        BNX2X_RSS_IPV4_TCP,
+        BNX2X_RSS_IPV6,
+        BNX2X_RSS_IPV6_TCP,
+};
+
+struct bnx2x_config_rss_params {
+        struct bnx2x_rss_config_obj *rss_obj;
+
+        /* may have RAMROD_COMP_WAIT set only */
+        unsigned long   ramrod_flags;
+
+        /* BNX2X_RSS_X bits */
+        unsigned long   rss_flags;
+
+        /* Number hash bits to take into an account */
+        u8              rss_result_mask;
+
+        /* Indirection table */
+        u8              ind_table[T_ETH_INDIRECTION_TABLE_SIZE];
+
+        /* RSS hash values */
+        u32             rss_key[10];
+
+        /* valid only iff BNX2X_RSS_UPDATE_TOE is set */
+        u16             toe_rss_bitmap;
+};
+
+struct bnx2x_rss_config_obj {
+        struct bnx2x_raw_obj    raw;
+
+        /* RSS engine to use */
+        u8                      engine_id;
+
+        /* Last configured indirection table */
+        u8                      ind_table[T_ETH_INDIRECTION_TABLE_SIZE];
+
+        int (*config_rss)(struct bnx2x *bp,
+                          struct bnx2x_config_rss_params *p);
+};
+
+/*********************** Queue state update ***********************************/
+
+/* UPDATE command options */
+enum {
+        BNX2X_Q_UPDATE_IN_VLAN_REM,
+        BNX2X_Q_UPDATE_IN_VLAN_REM_CHNG,
+        BNX2X_Q_UPDATE_OUT_VLAN_REM,
+        BNX2X_Q_UPDATE_OUT_VLAN_REM_CHNG,
+        BNX2X_Q_UPDATE_ANTI_SPOOF,
+        BNX2X_Q_UPDATE_ANTI_SPOOF_CHNG,
+        BNX2X_Q_UPDATE_ACTIVATE,
+        BNX2X_Q_UPDATE_ACTIVATE_CHNG,
+        BNX2X_Q_UPDATE_DEF_VLAN_EN,
+        BNX2X_Q_UPDATE_DEF_VLAN_EN_CHNG,
+        BNX2X_Q_UPDATE_SILENT_VLAN_REM_CHNG,
+        BNX2X_Q_UPDATE_SILENT_VLAN_REM
+};
+
+/* Allowed Queue states */
+enum bnx2x_q_state {
+        BNX2X_Q_STATE_RESET,
+        BNX2X_Q_STATE_INITIALIZED,
+        BNX2X_Q_STATE_ACTIVE,
+        BNX2X_Q_STATE_INACTIVE,
+        BNX2X_Q_STATE_STOPPED,
+        BNX2X_Q_STATE_TERMINATED,
+        BNX2X_Q_STATE_FLRED,
+        BNX2X_Q_STATE_MAX,
+};
+
+/* Allowed commands */
+enum bnx2x_queue_cmd {
+        BNX2X_Q_CMD_INIT,
+        BNX2X_Q_CMD_SETUP,
+        BNX2X_Q_CMD_DEACTIVATE,
+        BNX2X_Q_CMD_ACTIVATE,
+        BNX2X_Q_CMD_UPDATE,
+        BNX2X_Q_CMD_UPDATE_TPA,
+        BNX2X_Q_CMD_HALT,
+        BNX2X_Q_CMD_CFC_DEL,
+        BNX2X_Q_CMD_TERMINATE,
+        BNX2X_Q_CMD_EMPTY,
+        BNX2X_Q_CMD_MAX,
+};
+
+/* queue SETUP + INIT flags */
+enum {
+        BNX2X_Q_FLG_TPA,
+        BNX2X_Q_FLG_STATS,
+        BNX2X_Q_FLG_ZERO_STATS,
+        BNX2X_Q_FLG_ACTIVE,
+        BNX2X_Q_FLG_OV,
+        BNX2X_Q_FLG_VLAN,
+        BNX2X_Q_FLG_COS,
+        BNX2X_Q_FLG_HC,
+        BNX2X_Q_FLG_HC_EN,
+        BNX2X_Q_FLG_DHC,
+        BNX2X_Q_FLG_FCOE,
+        BNX2X_Q_FLG_LEADING_RSS,
+        BNX2X_Q_FLG_MCAST,
+        BNX2X_Q_FLG_DEF_VLAN,
+        BNX2X_Q_FLG_TX_SWITCH,
+        BNX2X_Q_FLG_TX_SEC,
+        BNX2X_Q_FLG_ANTI_SPOOF,
+        BNX2X_Q_FLG_SILENT_VLAN_REM
+};
+
+/* Queue type options: queue type may be a compination of below. */
+enum bnx2x_q_type {
+        /** TODO: Consider moving both these flags into the init()
+         *        ramrod params.
+         */
+        BNX2X_Q_TYPE_HAS_RX,
+        BNX2X_Q_TYPE_HAS_TX,
+};
+
+struct bnx2x_queue_init_params {
+        struct {
+                unsigned long   flags;
+                u16             hc_rate;
+                u8              fw_sb_id;
+                u8              sb_cq_index;
+        } tx;
+
+        struct {
+                unsigned long   flags;
+                u16             hc_rate;
+                u8              fw_sb_id;
+                u8              sb_cq_index;
+        } rx;
+
+        /* CID context in the host memory */
+        struct eth_context *cxt;
+};
+
+struct bnx2x_queue_update_params {
+        unsigned long   update_flags; /* BNX2X_Q_UPDATE_XX bits */
+        u16             def_vlan;
+        u16             silent_removal_value;
+        u16             silent_removal_mask;
+};
+
+struct rxq_pause_params {
+        u16             bd_th_lo;
+        u16             bd_th_hi;
+        u16             rcq_th_lo;
+        u16             rcq_th_hi;
+        u16             sge_th_lo; /* valid iff BNX2X_Q_FLG_TPA */
+        u16             sge_th_hi; /* valid iff BNX2X_Q_FLG_TPA */
+        u16             pri_map;
+};
+
+/* general */
+struct bnx2x_general_setup_params {
+        /* valid iff BNX2X_Q_FLG_STATS */
+        u8              stat_id;
+
+        u8              spcl_id;
+        u16             mtu;
+};
+
+struct bnx2x_rxq_setup_params {
+        /* dma */
+        dma_addr_t      dscr_map;
+        dma_addr_t      sge_map;
+        dma_addr_t      rcq_map;
+        dma_addr_t      rcq_np_map;
+
+        u16             drop_flags;
+        u16             buf_sz;
+        u8              fw_sb_id;
+        u8              cl_qzone_id;
+
+        /* valid iff BNX2X_Q_FLG_TPA */
+        u16             tpa_agg_sz;
+        u16             sge_buf_sz;
+        u8              max_sges_pkt;
+        u8              max_tpa_queues;
+        u8              rss_engine_id;
+
+        u8              cache_line_log;
+
+        u8              sb_cq_index;
+
+        /* valid iff BXN2X_Q_FLG_SILENT_VLAN_REM */
+        u16 silent_removal_value;
+        u16 silent_removal_mask;
+};
+
+struct bnx2x_txq_setup_params {
+        /* dma */
+        dma_addr_t      dscr_map;
+
+        u8              fw_sb_id;
+        u8              sb_cq_index;
+        u8              cos;            /* valid iff BNX2X_Q_FLG_COS */
+        u16             traffic_type;
+        /* equals to the leading rss client id, used for TX classification*/
+        u8              tss_leading_cl_id;
+
+        /* valid iff BNX2X_Q_FLG_DEF_VLAN */
+        u16             default_vlan;
+};
+
+struct bnx2x_queue_setup_params {
+        struct rxq_pause_params pause;
+        struct bnx2x_general_setup_params gen_params;
+        struct bnx2x_rxq_setup_params rxq_params;
+        struct bnx2x_txq_setup_params txq_params;
+        unsigned long flags;
+};
+
+
+struct bnx2x_queue_state_params {
+        struct bnx2x_queue_sp_obj *q_obj;
+
+        /* Current command */
+        enum bnx2x_queue_cmd cmd;
+
+        /* may have RAMROD_COMP_WAIT set only */
+        unsigned long   ramrod_flags;
+
+        /* Params according to the current command */
+        union {
+                struct bnx2x_queue_update_params update;
+                struct bnx2x_queue_setup_params   setup;
+                struct bnx2x_queue_init_params    init;
+        } params;
+};
+
+struct bnx2x_queue_sp_obj {
+        u32             cid;
+        u8              cl_id;
+        u8              func_id;
+
+        enum bnx2x_q_state state, next_state;
+
+        /* bits from enum bnx2x_q_type */
+        unsigned long   type;
+
+        /* BNX2X_Q_CMD_XX bits. This object implements "one
+         * pending" paradigm but for debug and tracing purposes it's
+         * more convinient to have different bits for different
+         * commands.
+         */
+        unsigned long   pending;
+
+        /* Buffer to use as a ramrod data and its mapping */
+        void            *rdata;
+        dma_addr_t      rdata_mapping;
+
+        /**
+         * Performs one state change according to the given parameters.
+         *
+         * @return 0 in case of success and negative value otherwise.
+         */
+        int (*send_cmd)(struct bnx2x *bp,
+                        struct bnx2x_queue_state_params *params);
+
+        /**
+         * Sets the pending bit according to the requested transition.
+         */
+        int (*set_pending)(struct bnx2x_queue_sp_obj *o,
+                           struct bnx2x_queue_state_params *params);
+
+        /**
+         * Checks that the requested state transition is legal.
+         */
+        int (*check_transition)(struct bnx2x *bp,
+                                struct bnx2x_queue_sp_obj *o,
+                                struct bnx2x_queue_state_params *params);
+
+        /**
+         * Completes the pending command.
+         */
+        int (*complete_cmd)(struct bnx2x *bp,
+                            struct bnx2x_queue_sp_obj *o,
+                            enum bnx2x_queue_cmd);
+
+        int (*wait_comp)(struct bnx2x *bp,
+                         struct bnx2x_queue_sp_obj *o,
+                         enum bnx2x_queue_cmd cmd);
+};
+
+/********************** Function state update *********************************/
+/* Allowed Function states */
+enum bnx2x_func_state {
+        BNX2X_F_STATE_RESET,
+        BNX2X_F_STATE_INITIALIZED,
+        BNX2X_F_STATE_STARTED,
+        BNX2X_F_STATE_MAX,
+};
+
+/* Allowed Function commands */
+enum bnx2x_func_cmd {
+        BNX2X_F_CMD_HW_INIT,
+        BNX2X_F_CMD_START,
+        BNX2X_F_CMD_STOP,
+        BNX2X_F_CMD_HW_RESET,
+        BNX2X_F_CMD_MAX,
+};
+
+struct bnx2x_func_hw_init_params {
+        /* A load phase returned by MCP.
+         *
+         * May be:
+         *              FW_MSG_CODE_DRV_LOAD_COMMON_CHIP
+         *              FW_MSG_CODE_DRV_LOAD_COMMON
+         *              FW_MSG_CODE_DRV_LOAD_PORT
+         *              FW_MSG_CODE_DRV_LOAD_FUNCTION
+         */
+        u32 load_phase;
+};
+
+struct bnx2x_func_hw_reset_params {
+        /* A load phase returned by MCP.
+         *
+         * May be:
+         *              FW_MSG_CODE_DRV_LOAD_COMMON_CHIP
+         *              FW_MSG_CODE_DRV_LOAD_COMMON
+         *              FW_MSG_CODE_DRV_LOAD_PORT
+         *              FW_MSG_CODE_DRV_LOAD_FUNCTION
+         */
+        u32 reset_phase;
+};
+
+struct bnx2x_func_start_params {
+        /* Multi Function mode:
+         *      - Single Function
+         *      - Switch Dependent
+         *      - Switch Independent
+         */
+        u16 mf_mode;
+
+        /* Switch Dependent mode outer VLAN tag */
+        u16 sd_vlan_tag;
+
+        /* Function cos mode */
+        u8 network_cos_mode;
+};
+
+struct bnx2x_func_state_params {
+        struct bnx2x_func_sp_obj *f_obj;
+
+        /* Current command */
+        enum bnx2x_func_cmd cmd;
+
+        /* may have RAMROD_COMP_WAIT set only */
+        unsigned long   ramrod_flags;
+
+        /* Params according to the current command */
+        union {
+                struct bnx2x_func_hw_init_params hw_init;
+                struct bnx2x_func_hw_reset_params hw_reset;
+                struct bnx2x_func_start_params start;
+        } params;
+};
+
+struct bnx2x_func_sp_drv_ops {
+        /* Init tool + runtime initialization:
+         *      - Common Chip
+         *      - Common (per Path)
+         *      - Port
+         *      - Function phases
+         */
+        int (*init_hw_cmn_chip)(struct bnx2x *bp);
+        int (*init_hw_cmn)(struct bnx2x *bp);
+        int (*init_hw_port)(struct bnx2x *bp);
+        int (*init_hw_func)(struct bnx2x *bp);
+
+        /* Reset Function HW: Common, Port, Function phases. */
+        void (*reset_hw_cmn)(struct bnx2x *bp);
+        void (*reset_hw_port)(struct bnx2x *bp);
+        void (*reset_hw_func)(struct bnx2x *bp);
+
+        /* Init/Free GUNZIP resources */
+        int (*gunzip_init)(struct bnx2x *bp);
+        void (*gunzip_end)(struct bnx2x *bp);
+
+        /* Prepare/Release FW resources */
+        int (*init_fw)(struct bnx2x *bp);
+        void (*release_fw)(struct bnx2x *bp);
+};
+
+struct bnx2x_func_sp_obj {
+        enum bnx2x_func_state   state, next_state;
+
+        /* BNX2X_FUNC_CMD_XX bits. This object implements "one
+         * pending" paradigm but for debug and tracing purposes it's
+         * more convinient to have different bits for different
+         * commands.
+         */
+        unsigned long           pending;
+
+        /* Buffer to use as a ramrod data and its mapping */
+        void                    *rdata;
+        dma_addr_t              rdata_mapping;
+
+        /* this mutex validates that when pending flag is taken, the next
+         * ramrod to be sent will be the one set the pending bit
+         */
+        struct mutex            one_pending_mutex;
+
+        /* Driver interface */
+        struct bnx2x_func_sp_drv_ops    *drv;
+
+        /**
+         * Performs one state change according to the given parameters.
+         *
+         * @return 0 in case of success and negative value otherwise.
+         */
+        int (*send_cmd)(struct bnx2x *bp,
+                        struct bnx2x_func_state_params *params);
+
+        /**
+         * Checks that the requested state transition is legal.
+         */
+        int (*check_transition)(struct bnx2x *bp,
+                                struct bnx2x_func_sp_obj *o,
+                                struct bnx2x_func_state_params *params);
+
+        /**
+         * Completes the pending command.
+         */
+        int (*complete_cmd)(struct bnx2x *bp,
+                            struct bnx2x_func_sp_obj *o,
+                            enum bnx2x_func_cmd cmd);
+
+        int (*wait_comp)(struct bnx2x *bp, struct bnx2x_func_sp_obj *o,
+                         enum bnx2x_func_cmd cmd);
+};
+
+/********************** Interfaces ********************************************/
+/* Queueable objects set */
+union bnx2x_qable_obj {
+        struct bnx2x_vlan_mac_obj vlan_mac;
+};
+/************** Function state update *********/
+void bnx2x_init_func_obj(struct bnx2x *bp,
+                         struct bnx2x_func_sp_obj *obj,
+                         void *rdata, dma_addr_t rdata_mapping,
+                         struct bnx2x_func_sp_drv_ops *drv_iface);
+
+int bnx2x_func_state_change(struct bnx2x *bp,
+                            struct bnx2x_func_state_params *params);
+
+/******************* Queue State **************/
+void bnx2x_init_queue_obj(struct bnx2x *bp,
+                          struct bnx2x_queue_sp_obj *obj, u8 cl_id, u32 cid,
+                          u8 func_id, void *rdata, dma_addr_t rdata_mapping,
+                          unsigned long type);
+
+int bnx2x_queue_state_change(struct bnx2x *bp,
+                             struct bnx2x_queue_state_params *params);
+
+/********************* VLAN-MAC ****************/
+void bnx2x_init_mac_obj(struct bnx2x *bp,
+                        struct bnx2x_vlan_mac_obj *mac_obj,
+                        u8 cl_id, u32 cid, u8 func_id, void *rdata,
+                        dma_addr_t rdata_mapping, int state,
+                        unsigned long *pstate, bnx2x_obj_type type,
+                        struct bnx2x_credit_pool_obj *macs_pool);
+
+void bnx2x_init_vlan_obj(struct bnx2x *bp,
+                         struct bnx2x_vlan_mac_obj *vlan_obj,
+                         u8 cl_id, u32 cid, u8 func_id, void *rdata,
+                         dma_addr_t rdata_mapping, int state,
+                         unsigned long *pstate, bnx2x_obj_type type,
+                         struct bnx2x_credit_pool_obj *vlans_pool);
+
+void bnx2x_init_vlan_mac_obj(struct bnx2x *bp,
+                             struct bnx2x_vlan_mac_obj *vlan_mac_obj,
+                             u8 cl_id, u32 cid, u8 func_id, void *rdata,
+                             dma_addr_t rdata_mapping, int state,
+                             unsigned long *pstate, bnx2x_obj_type type,
+                             struct bnx2x_credit_pool_obj *macs_pool,
+                             struct bnx2x_credit_pool_obj *vlans_pool);
+
+int bnx2x_config_vlan_mac(struct bnx2x *bp,
+                          struct bnx2x_vlan_mac_ramrod_params *p);
+
+int bnx2x_vlan_mac_move(struct bnx2x *bp,
+                        struct bnx2x_vlan_mac_ramrod_params *p,
+                        struct bnx2x_vlan_mac_obj *dest_o);
+
+/********************* RX MODE ****************/
+
+void bnx2x_init_rx_mode_obj(struct bnx2x *bp,
+                            struct bnx2x_rx_mode_obj *o);
+
+/**
+ * Send and RX_MODE ramrod according to the provided parameters.
+ *
+ * @param bp
+ * @param p Command parameters
+ *
+ * @return 0 - if operation was successfull and there is no pending completions,
+ *         positive number - if there are pending completions,
+ *         negative - if there were errors
+ */
+int bnx2x_config_rx_mode(struct bnx2x *bp,
+                         struct bnx2x_rx_mode_ramrod_params *p);
+
+/****************** MULTICASTS ****************/
+
+void bnx2x_init_mcast_obj(struct bnx2x *bp,
+                          struct bnx2x_mcast_obj *mcast_obj,
+                          u8 mcast_cl_id, u32 mcast_cid, u8 func_id,
+                          u8 engine_id, void *rdata, dma_addr_t rdata_mapping,
+                          int state, unsigned long *pstate,
+                          bnx2x_obj_type type);
+
+/**
+ * Configure multicast MACs list. May configure a new list
+ * provided in p->mcast_list (BNX2X_MCAST_CMD_ADD), clean up
+ * (BNX2X_MCAST_CMD_DEL) or restore (BNX2X_MCAST_CMD_RESTORE) a current
+ * configuration, continue to execute the pending commands
+ * (BNX2X_MCAST_CMD_CONT).
+ *
+ * If previous command is still pending or if number of MACs to
+ * configure is more that maximum number of MACs in one command,
+ * the current command will be enqueued to the tail of the
+ * pending commands list.
+ *
+ * @param bp
+ * @param p
+ * @param command to execute: BNX2X_MCAST_CMD_X
+ *
+ * @return 0 is operation was sucessfull and there are no pending completions,
+ *         negative if there were errors, positive if there are pending
+ *         completions.
+ */
+int bnx2x_config_mcast(struct bnx2x *bp,
+                       struct bnx2x_mcast_ramrod_params *p, int cmd);
+
+/****************** CREDIT POOL ****************/
+void bnx2x_init_mac_credit_pool(struct bnx2x *bp,
+                                struct bnx2x_credit_pool_obj *p, u8 func_id,
+                                u8 func_num);
+void bnx2x_init_vlan_credit_pool(struct bnx2x *bp,
+                                 struct bnx2x_credit_pool_obj *p, u8 func_id,
+                                 u8 func_num);
+
+
+/****************** RSS CONFIGURATION ****************/
+void bnx2x_init_rss_config_obj(struct bnx2x *bp,
+                               struct bnx2x_rss_config_obj *rss_obj,
+                               u8 cl_id, u32 cid, u8 func_id, u8 engine_id,
+                               void *rdata, dma_addr_t rdata_mapping,
+                               int state, unsigned long *pstate,
+                               bnx2x_obj_type type);
+
+/**
+ * Updates RSS configuration according to provided parameters.
+ *
+ * @param bp
+ * @param p
+ *
+ * @return 0 in case of success
+ */
+int bnx2x_config_rss(struct bnx2x *bp,
+                     struct bnx2x_config_rss_params *p);
+
+/**
+ * Return the current ind_table configuration.
+ *
+ * @param bp
+ * @param ind_table buffer to fill with the current indirection
+ *                  table content. Should be at least
+ *                  T_ETH_INDIRECTION_TABLE_SIZE bytes long.
+ */
+void bnx2x_get_rss_ind_table(struct bnx2x_rss_config_obj *rss_obj,
+                             u8 *ind_table);
+
+#endif /* BNX2X_SP_VERBS */
diff --git a/drivers/net/bnx2x/bnx2x_stats.c b/drivers/net/bnx2x/bnx2x_stats.c
index e535bfa08945..54c07f557ad4 100644
--- a/drivers/net/bnx2x/bnx2x_stats.c
+++ b/drivers/net/bnx2x/bnx2x_stats.c
@@ -14,120 +14,11 @@
  * Statistics and Link management by Yitchak Gertner
  *
  */
-#include "bnx2x_cmn.h"
 #include "bnx2x_stats.h"
+#include "bnx2x_cmn.h"
 
-/* Statistics */
 
-/****************************************************************************
-* Macros
-****************************************************************************/
-
-/* sum[hi:lo] += add[hi:lo] */
-#define ADD_64(s_hi, a_hi, s_lo, a_lo) \
-        do { \
-                s_lo += a_lo; \
-                s_hi += a_hi + ((s_lo < a_lo) ? 1 : 0); \
-        } while (0)
-
-/* difference = minuend - subtrahend */
-#define DIFF_64(d_hi, m_hi, s_hi, d_lo, m_lo, s_lo) \
-        do { \
-                if (m_lo < s_lo) { \
-                        /* underflow */ \
-                        d_hi = m_hi - s_hi; \
-                        if (d_hi > 0) { \
-                                /* we can 'loan' 1 */ \
-                                d_hi--; \
-                                d_lo = m_lo + (UINT_MAX - s_lo) + 1; \
-                        } else { \
-                                /* m_hi <= s_hi */ \
-                                d_hi = 0; \
-                                d_lo = 0; \
-                        } \
-                } else { \
-                        /* m_lo >= s_lo */ \
-                        if (m_hi < s_hi) { \
-                                d_hi = 0; \
-                                d_lo = 0; \
-                        } else { \
-                                /* m_hi >= s_hi */ \
-                                d_hi = m_hi - s_hi; \
-                                d_lo = m_lo - s_lo; \
-                        } \
-                } \
-        } while (0)
-
-#define UPDATE_STAT64(s, t) \
-        do { \
-                DIFF_64(diff.hi, new->s##_hi, pstats->mac_stx[0].t##_hi, \
-                        diff.lo, new->s##_lo, pstats->mac_stx[0].t##_lo); \
-                pstats->mac_stx[0].t##_hi = new->s##_hi; \
-                pstats->mac_stx[0].t##_lo = new->s##_lo; \
-                ADD_64(pstats->mac_stx[1].t##_hi, diff.hi, \
-                       pstats->mac_stx[1].t##_lo, diff.lo); \
-        } while (0)
-
-#define UPDATE_STAT64_NIG(s, t) \
-        do { \
-                DIFF_64(diff.hi, new->s##_hi, old->s##_hi, \
-                        diff.lo, new->s##_lo, old->s##_lo); \
-                ADD_64(estats->t##_hi, diff.hi, \
-                       estats->t##_lo, diff.lo); \
-        } while (0)
-
-/* sum[hi:lo] += add */
-#define ADD_EXTEND_64(s_hi, s_lo, a) \
-        do { \
-                s_lo += a; \
-                s_hi += (s_lo < a) ? 1 : 0; \
-        } while (0)
-
-#define UPDATE_EXTEND_STAT(s) \
-        do { \
-                ADD_EXTEND_64(pstats->mac_stx[1].s##_hi, \
-                              pstats->mac_stx[1].s##_lo, \
-                              new->s); \
-        } while (0)
-
-#define UPDATE_EXTEND_TSTAT(s, t) \
-        do { \
-                diff = le32_to_cpu(tclient->s) - le32_to_cpu(old_tclient->s); \
-                old_tclient->s = tclient->s; \
-                ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
-        } while (0)
-
-#define UPDATE_EXTEND_USTAT(s, t) \
-        do { \
-                diff = le32_to_cpu(uclient->s) - le32_to_cpu(old_uclient->s); \
-                old_uclient->s = uclient->s; \
-                ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
-        } while (0)
-
-#define UPDATE_EXTEND_XSTAT(s, t) \
-        do { \
-                diff = le32_to_cpu(xclient->s) - le32_to_cpu(old_xclient->s); \
-                old_xclient->s = xclient->s; \
-                ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
-        } while (0)
-
-/* minuend -= subtrahend */
-#define SUB_64(m_hi, s_hi, m_lo, s_lo) \
-        do { \
-                DIFF_64(m_hi, m_hi, s_hi, m_lo, m_lo, s_lo); \
-        } while (0)
-
-/* minuend[hi:lo] -= subtrahend */
-#define SUB_EXTEND_64(m_hi, m_lo, s) \
-        do { \
-                SUB_64(m_hi, 0, m_lo, s); \
-        } while (0)
-
-#define SUB_EXTEND_USTAT(s, t) \
-        do { \
-                diff = le32_to_cpu(uclient->s) - le32_to_cpu(old_uclient->s); \
-                SUB_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
-        } while (0)
+/* Statistics */
 
 /*
  * General service functions
@@ -149,12 +40,16 @@ static inline long bnx2x_hilo(u32 *hiref)
  * Init service functions
  */
 
-
+/* Post the next statistics ramrod. Protect it with the spin in
+ * order to ensure the strict order between statistics ramrods
+ * (each ramrod has a sequence number passed in a
+ * bp->fw_stats_req->hdr.drv_stats_counter and ramrods must be
+ * sent in order).
+ */
 static void bnx2x_storm_stats_post(struct bnx2x *bp)
 {
         if (!bp->stats_pending) {
-                struct common_query_ramrod_data ramrod_data = {0};
-                int i, rc;
+                int rc;
 
                 spin_lock_bh(&bp->stats_lock);
 
@@ -163,14 +58,19 @@ static void bnx2x_storm_stats_post(struct bnx2x *bp)
                         return;
                 }
 
-                ramrod_data.drv_counter = bp->stats_counter++;
-                ramrod_data.collect_port = bp->port.pmf ? 1 : 0;
-                for_each_eth_queue(bp, i)
-                        ramrod_data.ctr_id_vector |= (1 << bp->fp[i].cl_id);
+                bp->fw_stats_req->hdr.drv_stats_counter =
+                        cpu_to_le16(bp->stats_counter++);
 
+                DP(NETIF_MSG_TIMER, "Sending statistics ramrod %d\n",
+                        bp->fw_stats_req->hdr.drv_stats_counter);
+
+
+
+                /* send FW stats ramrod */
                 rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_STAT_QUERY, 0,
-                                   ((u32 *)&ramrod_data)[1],
-                                   ((u32 *)&ramrod_data)[0], 1);
+                                   U64_HI(bp->fw_stats_req_mapping),
+                                   U64_LO(bp->fw_stats_req_mapping),
+                                   NONE_CONNECTION_TYPE);
                 if (rc == 0)
                         bp->stats_pending = 1;
 
@@ -230,7 +130,7 @@ static int bnx2x_stats_comp(struct bnx2x *bp)
                         break;
                 }
                 cnt--;
-                msleep(1);
+                usleep_range(1000, 1000);
         }
         return 1;
 }
@@ -338,69 +238,8 @@ static void bnx2x_port_stats_init(struct bnx2x *bp)
         opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_GRC, DMAE_DST_PCI,
                                    true, DMAE_COMP_GRC);
 
-        if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
-
-                mac_addr = (port ? NIG_REG_INGRESS_BMAC1_MEM :
-                                   NIG_REG_INGRESS_BMAC0_MEM);
-
-                /* BIGMAC_REGISTER_TX_STAT_GTPKT ..
-                   BIGMAC_REGISTER_TX_STAT_GTBYT */
-                dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
-                dmae->opcode = opcode;
-                if (CHIP_IS_E1x(bp)) {
-                        dmae->src_addr_lo = (mac_addr +
-                                     BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
-                        dmae->len = (8 + BIGMAC_REGISTER_TX_STAT_GTBYT -
-                                     BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
-                } else {
-                        dmae->src_addr_lo = (mac_addr +
-                                     BIGMAC2_REGISTER_TX_STAT_GTPOK) >> 2;
-                        dmae->len = (8 + BIGMAC2_REGISTER_TX_STAT_GTBYT -
-                                     BIGMAC2_REGISTER_TX_STAT_GTPOK) >> 2;
-                }
-
-                dmae->src_addr_hi = 0;
-                dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
-                dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
-                dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
-                dmae->comp_addr_hi = 0;
-                dmae->comp_val = 1;
-
-                /* BIGMAC_REGISTER_RX_STAT_GR64 ..
-                   BIGMAC_REGISTER_RX_STAT_GRIPJ */
-                dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
-                dmae->opcode = opcode;
-                dmae->src_addr_hi = 0;
-                if (CHIP_IS_E1x(bp)) {
-                        dmae->src_addr_lo = (mac_addr +
-                                             BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
-                        dmae->dst_addr_lo =
-                                U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
-                                offsetof(struct bmac1_stats, rx_stat_gr64_lo));
-                        dmae->dst_addr_hi =
-                                U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
-                                offsetof(struct bmac1_stats, rx_stat_gr64_lo));
-                        dmae->len = (8 + BIGMAC_REGISTER_RX_STAT_GRIPJ -
-                                     BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
-                } else {
-                        dmae->src_addr_lo =
-                                (mac_addr + BIGMAC2_REGISTER_RX_STAT_GR64) >> 2;
-                        dmae->dst_addr_lo =
-                                U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
-                                offsetof(struct bmac2_stats, rx_stat_gr64_lo));
-                        dmae->dst_addr_hi =
-                                U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
-                                offsetof(struct bmac2_stats, rx_stat_gr64_lo));
-                        dmae->len = (8 + BIGMAC2_REGISTER_RX_STAT_GRIPJ -
-                                     BIGMAC2_REGISTER_RX_STAT_GR64) >> 2;
-                }
-
-                dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
-                dmae->comp_addr_hi = 0;
-                dmae->comp_val = 1;
-
-        } else if (bp->link_vars.mac_type == MAC_TYPE_EMAC) {
-
+        /* EMAC is special */
+        if (bp->link_vars.mac_type == MAC_TYPE_EMAC) {
                 mac_addr = (port ? GRCBASE_EMAC1 : GRCBASE_EMAC0);
 
                 /* EMAC_REG_EMAC_RX_STAT_AC (EMAC_REG_EMAC_RX_STAT_AC_COUNT)*/
@@ -445,46 +284,122 @@ static void bnx2x_port_stats_init(struct bnx2x *bp)
                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
                 dmae->comp_addr_hi = 0;
                 dmae->comp_val = 1;
+        } else {
+                u32 tx_src_addr_lo, rx_src_addr_lo;
+                u16 rx_len, tx_len;
+
+                /* configure the params according to MAC type */
+                switch (bp->link_vars.mac_type) {
+                case MAC_TYPE_BMAC:
+                        mac_addr = (port ? NIG_REG_INGRESS_BMAC1_MEM :
+                                           NIG_REG_INGRESS_BMAC0_MEM);
+
+                        /* BIGMAC_REGISTER_TX_STAT_GTPKT ..
+                           BIGMAC_REGISTER_TX_STAT_GTBYT */
+                        if (CHIP_IS_E1x(bp)) {
+                                tx_src_addr_lo = (mac_addr +
+                                        BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
+                                tx_len = (8 + BIGMAC_REGISTER_TX_STAT_GTBYT -
+                                          BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
+                                rx_src_addr_lo = (mac_addr +
+                                        BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
+                                rx_len = (8 + BIGMAC_REGISTER_RX_STAT_GRIPJ -
+                                          BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
+                        } else {
+                                tx_src_addr_lo = (mac_addr +
+                                        BIGMAC2_REGISTER_TX_STAT_GTPOK) >> 2;
+                                tx_len = (8 + BIGMAC2_REGISTER_TX_STAT_GTBYT -
+                                          BIGMAC2_REGISTER_TX_STAT_GTPOK) >> 2;
+                                rx_src_addr_lo = (mac_addr +
+                                        BIGMAC2_REGISTER_RX_STAT_GR64) >> 2;
+                                rx_len = (8 + BIGMAC2_REGISTER_RX_STAT_GRIPJ -
+                                          BIGMAC2_REGISTER_RX_STAT_GR64) >> 2;
+                        }
+                        break;
+
+                case MAC_TYPE_UMAC: /* handled by MSTAT */
+                case MAC_TYPE_XMAC: /* handled by MSTAT */
+                default:
+                        mac_addr = port ? GRCBASE_MSTAT1 : GRCBASE_MSTAT0;
+                        tx_src_addr_lo = (mac_addr +
+                                          MSTAT_REG_TX_STAT_GTXPOK_LO) >> 2;
+                        rx_src_addr_lo = (mac_addr +
+                                          MSTAT_REG_RX_STAT_GR64_LO) >> 2;
+                        tx_len = sizeof(bp->slowpath->
+                                        mac_stats.mstat_stats.stats_tx) >> 2;
+                        rx_len = sizeof(bp->slowpath->
+                                        mac_stats.mstat_stats.stats_rx) >> 2;
+                        break;
+                }
+
+                /* TX stats */
+                dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
+                dmae->opcode = opcode;
+                dmae->src_addr_lo = tx_src_addr_lo;
+                dmae->src_addr_hi = 0;
+                dmae->len = tx_len;
+                dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
+                dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
+                dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
+                dmae->comp_addr_hi = 0;
+                dmae->comp_val = 1;
+
+                /* RX stats */
+                dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
+                dmae->opcode = opcode;
+                dmae->src_addr_hi = 0;
+                dmae->src_addr_lo = rx_src_addr_lo;
+                dmae->dst_addr_lo =
+                        U64_LO(bnx2x_sp_mapping(bp, mac_stats) + (tx_len << 2));
+                dmae->dst_addr_hi =
+                        U64_HI(bnx2x_sp_mapping(bp, mac_stats) + (tx_len << 2));
+                dmae->len = rx_len;
+                dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
+                dmae->comp_addr_hi = 0;
+                dmae->comp_val = 1;
         }
 
         /* NIG */
+        if (!CHIP_IS_E3(bp)) {
+                dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
+                dmae->opcode = opcode;
+                dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT0 :
+                                            NIG_REG_STAT0_EGRESS_MAC_PKT0) >> 2;
+                dmae->src_addr_hi = 0;
+                dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
+                                offsetof(struct nig_stats, egress_mac_pkt0_lo));
+                dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
+                                offsetof(struct nig_stats, egress_mac_pkt0_lo));
+                dmae->len = (2*sizeof(u32)) >> 2;
+                dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
+                dmae->comp_addr_hi = 0;
+                dmae->comp_val = 1;
+
+                dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
+                dmae->opcode = opcode;
+                dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT1 :
+                                            NIG_REG_STAT0_EGRESS_MAC_PKT1) >> 2;
+                dmae->src_addr_hi = 0;
+                dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
+                                offsetof(struct nig_stats, egress_mac_pkt1_lo));
+                dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
+                                offsetof(struct nig_stats, egress_mac_pkt1_lo));
+                dmae->len = (2*sizeof(u32)) >> 2;
+                dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
+                dmae->comp_addr_hi = 0;
+                dmae->comp_val = 1;
+        }
+
         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
-        dmae->opcode = opcode;
+        dmae->opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_GRC, DMAE_DST_PCI,
+                                                 true, DMAE_COMP_PCI);
         dmae->src_addr_lo = (port ? NIG_REG_STAT1_BRB_DISCARD :
                                     NIG_REG_STAT0_BRB_DISCARD) >> 2;
         dmae->src_addr_hi = 0;
         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats));
         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats));
         dmae->len = (sizeof(struct nig_stats) - 4*sizeof(u32)) >> 2;
-        dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
-        dmae->comp_addr_hi = 0;
-        dmae->comp_val = 1;
 
-        dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
-        dmae->opcode = opcode;
-        dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT0 :
-                                    NIG_REG_STAT0_EGRESS_MAC_PKT0) >> 2;
-        dmae->src_addr_hi = 0;
-        dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
-                        offsetof(struct nig_stats, egress_mac_pkt0_lo));
-        dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
-                        offsetof(struct nig_stats, egress_mac_pkt0_lo));
-        dmae->len = (2*sizeof(u32)) >> 2;
-        dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
-        dmae->comp_addr_hi = 0;
-        dmae->comp_val = 1;
-
-        dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
-        dmae->opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_GRC, DMAE_DST_PCI,
-                                         true, DMAE_COMP_PCI);
-        dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT1 :
-                                    NIG_REG_STAT0_EGRESS_MAC_PKT1) >> 2;
-        dmae->src_addr_hi = 0;
-        dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
-                        offsetof(struct nig_stats, egress_mac_pkt1_lo));
-        dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
-                        offsetof(struct nig_stats, egress_mac_pkt1_lo));
-        dmae->len = (2*sizeof(u32)) >> 2;
         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
         dmae->comp_val = DMAE_COMP_VAL;
@@ -566,7 +481,8 @@ static void bnx2x_bmac_stats_update(struct bnx2x *bp)
                 UPDATE_STAT64(rx_stat_grjbr, rx_stat_etherstatsjabbers);
                 UPDATE_STAT64(rx_stat_grxcf, rx_stat_maccontrolframesreceived);
                 UPDATE_STAT64(rx_stat_grxpf, rx_stat_xoffstateentered);
-                UPDATE_STAT64(rx_stat_grxpf, rx_stat_bmac_xpf);
+                UPDATE_STAT64(rx_stat_grxpf, rx_stat_mac_xpf);
+
                 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_outxoffsent);
                 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_flowcontroldone);
                 UPDATE_STAT64(tx_stat_gt64, tx_stat_etherstatspkts64octets);
@@ -580,13 +496,13 @@ static void bnx2x_bmac_stats_update(struct bnx2x *bp)
                                 tx_stat_etherstatspkts512octetsto1023octets);
                 UPDATE_STAT64(tx_stat_gt1518,
                                 tx_stat_etherstatspkts1024octetsto1522octets);
-                UPDATE_STAT64(tx_stat_gt2047, tx_stat_bmac_2047);
-                UPDATE_STAT64(tx_stat_gt4095, tx_stat_bmac_4095);
-                UPDATE_STAT64(tx_stat_gt9216, tx_stat_bmac_9216);
-                UPDATE_STAT64(tx_stat_gt16383, tx_stat_bmac_16383);
+                UPDATE_STAT64(tx_stat_gt2047, tx_stat_mac_2047);
+                UPDATE_STAT64(tx_stat_gt4095, tx_stat_mac_4095);
+                UPDATE_STAT64(tx_stat_gt9216, tx_stat_mac_9216);
+                UPDATE_STAT64(tx_stat_gt16383, tx_stat_mac_16383);
                 UPDATE_STAT64(tx_stat_gterr,
                                 tx_stat_dot3statsinternalmactransmiterrors);
-                UPDATE_STAT64(tx_stat_gtufl, tx_stat_bmac_ufl);
+                UPDATE_STAT64(tx_stat_gtufl, tx_stat_mac_ufl);
 
         } else {
                 struct bmac2_stats *new = bnx2x_sp(bp, mac_stats.bmac2_stats);
@@ -600,7 +516,7 @@ static void bnx2x_bmac_stats_update(struct bnx2x *bp)
                 UPDATE_STAT64(rx_stat_grjbr, rx_stat_etherstatsjabbers);
                 UPDATE_STAT64(rx_stat_grxcf, rx_stat_maccontrolframesreceived);
                 UPDATE_STAT64(rx_stat_grxpf, rx_stat_xoffstateentered);
-                UPDATE_STAT64(rx_stat_grxpf, rx_stat_bmac_xpf);
+                UPDATE_STAT64(rx_stat_grxpf, rx_stat_mac_xpf);
                 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_outxoffsent);
                 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_flowcontroldone);
                 UPDATE_STAT64(tx_stat_gt64, tx_stat_etherstatspkts64octets);
@@ -614,19 +530,96 @@ static void bnx2x_bmac_stats_update(struct bnx2x *bp)
                                 tx_stat_etherstatspkts512octetsto1023octets);
                 UPDATE_STAT64(tx_stat_gt1518,
                                 tx_stat_etherstatspkts1024octetsto1522octets);
-                UPDATE_STAT64(tx_stat_gt2047, tx_stat_bmac_2047);
-                UPDATE_STAT64(tx_stat_gt4095, tx_stat_bmac_4095);
-                UPDATE_STAT64(tx_stat_gt9216, tx_stat_bmac_9216);
-                UPDATE_STAT64(tx_stat_gt16383, tx_stat_bmac_16383);
+                UPDATE_STAT64(tx_stat_gt2047, tx_stat_mac_2047);
+                UPDATE_STAT64(tx_stat_gt4095, tx_stat_mac_4095);
+                UPDATE_STAT64(tx_stat_gt9216, tx_stat_mac_9216);
+                UPDATE_STAT64(tx_stat_gt16383, tx_stat_mac_16383);
                 UPDATE_STAT64(tx_stat_gterr,
                                 tx_stat_dot3statsinternalmactransmiterrors);
-                UPDATE_STAT64(tx_stat_gtufl, tx_stat_bmac_ufl);
+                UPDATE_STAT64(tx_stat_gtufl, tx_stat_mac_ufl);
         }
 
         estats->pause_frames_received_hi =
-                                pstats->mac_stx[1].rx_stat_bmac_xpf_hi;
+                                pstats->mac_stx[1].rx_stat_mac_xpf_hi;
+        estats->pause_frames_received_lo =
+                                pstats->mac_stx[1].rx_stat_mac_xpf_lo;
+
+        estats->pause_frames_sent_hi =
+                                pstats->mac_stx[1].tx_stat_outxoffsent_hi;
+        estats->pause_frames_sent_lo =
+                                pstats->mac_stx[1].tx_stat_outxoffsent_lo;
+}
+
+static void bnx2x_mstat_stats_update(struct bnx2x *bp)
+{
+        struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
+        struct bnx2x_eth_stats *estats = &bp->eth_stats;
+
+        struct mstat_stats *new = bnx2x_sp(bp, mac_stats.mstat_stats);
+
+        ADD_STAT64(stats_rx.rx_grerb, rx_stat_ifhcinbadoctets);
+        ADD_STAT64(stats_rx.rx_grfcs, rx_stat_dot3statsfcserrors);
+        ADD_STAT64(stats_rx.rx_grund, rx_stat_etherstatsundersizepkts);
+        ADD_STAT64(stats_rx.rx_grovr, rx_stat_dot3statsframestoolong);
+        ADD_STAT64(stats_rx.rx_grfrg, rx_stat_etherstatsfragments);
+        ADD_STAT64(stats_rx.rx_grxcf, rx_stat_maccontrolframesreceived);
+        ADD_STAT64(stats_rx.rx_grxpf, rx_stat_xoffstateentered);
+        ADD_STAT64(stats_rx.rx_grxpf, rx_stat_mac_xpf);
+        ADD_STAT64(stats_tx.tx_gtxpf, tx_stat_outxoffsent);
+        ADD_STAT64(stats_tx.tx_gtxpf, tx_stat_flowcontroldone);
+
+
+        ADD_STAT64(stats_tx.tx_gt64, tx_stat_etherstatspkts64octets);
+        ADD_STAT64(stats_tx.tx_gt127,
+                        tx_stat_etherstatspkts65octetsto127octets);
+        ADD_STAT64(stats_tx.tx_gt255,
+                        tx_stat_etherstatspkts128octetsto255octets);
+        ADD_STAT64(stats_tx.tx_gt511,
+                        tx_stat_etherstatspkts256octetsto511octets);
+        ADD_STAT64(stats_tx.tx_gt1023,
+                        tx_stat_etherstatspkts512octetsto1023octets);
+        ADD_STAT64(stats_tx.tx_gt1518,
+                        tx_stat_etherstatspkts1024octetsto1522octets);
+        ADD_STAT64(stats_tx.tx_gt2047, tx_stat_mac_2047);
+
+        ADD_STAT64(stats_tx.tx_gt4095, tx_stat_mac_4095);
+        ADD_STAT64(stats_tx.tx_gt9216, tx_stat_mac_9216);
+        ADD_STAT64(stats_tx.tx_gt16383, tx_stat_mac_16383);
+
+        ADD_STAT64(stats_tx.tx_gterr,
+                        tx_stat_dot3statsinternalmactransmiterrors);
+        ADD_STAT64(stats_tx.tx_gtufl, tx_stat_mac_ufl);
+
+        ADD_64(estats->etherstatspkts1024octetsto1522octets_hi,
+               new->stats_tx.tx_gt1518_hi,
+               estats->etherstatspkts1024octetsto1522octets_lo,
+               new->stats_tx.tx_gt1518_lo);
+
+        ADD_64(estats->etherstatspktsover1522octets_hi,
+               new->stats_tx.tx_gt2047_hi,
+               estats->etherstatspktsover1522octets_lo,
+               new->stats_tx.tx_gt2047_lo);
+
+        ADD_64(estats->etherstatspktsover1522octets_hi,
+               new->stats_tx.tx_gt4095_hi,
+               estats->etherstatspktsover1522octets_lo,
+               new->stats_tx.tx_gt4095_lo);
+
+        ADD_64(estats->etherstatspktsover1522octets_hi,
+               new->stats_tx.tx_gt9216_hi,
+               estats->etherstatspktsover1522octets_lo,
+               new->stats_tx.tx_gt9216_lo);
+
+
+        ADD_64(estats->etherstatspktsover1522octets_hi,
+               new->stats_tx.tx_gt16383_hi,
+               estats->etherstatspktsover1522octets_lo,
+               new->stats_tx.tx_gt16383_lo);
+
+        estats->pause_frames_received_hi =
+                                pstats->mac_stx[1].rx_stat_mac_xpf_hi;
         estats->pause_frames_received_lo =
-                                pstats->mac_stx[1].rx_stat_bmac_xpf_lo;
+                                pstats->mac_stx[1].rx_stat_mac_xpf_lo;
 
         estats->pause_frames_sent_hi =
                                 pstats->mac_stx[1].tx_stat_outxoffsent_hi;
@@ -702,15 +695,26 @@ static int bnx2x_hw_stats_update(struct bnx2x *bp)
                 u32 hi;
         } diff;
 
-        if (bp->link_vars.mac_type == MAC_TYPE_BMAC)
+        switch (bp->link_vars.mac_type) {
+        case MAC_TYPE_BMAC:
                 bnx2x_bmac_stats_update(bp);
+                break;
 
-        else if (bp->link_vars.mac_type == MAC_TYPE_EMAC)
+        case MAC_TYPE_EMAC:
                 bnx2x_emac_stats_update(bp);
+                break;
+
+        case MAC_TYPE_UMAC:
+        case MAC_TYPE_XMAC:
+                bnx2x_mstat_stats_update(bp);
+                break;
 
-        else { /* unreached */
+        case MAC_TYPE_NONE: /* unreached */
                 BNX2X_ERR("stats updated by DMAE but no MAC active\n");
                 return -1;
+
+        default: /* unreached */
+                BNX2X_ERR("Unknown MAC type\n");
         }
 
         ADD_EXTEND_64(pstats->brb_drop_hi, pstats->brb_drop_lo,
@@ -718,9 +722,12 @@ static int bnx2x_hw_stats_update(struct bnx2x *bp)
         ADD_EXTEND_64(estats->brb_truncate_hi, estats->brb_truncate_lo,
                       new->brb_truncate - old->brb_truncate);
 
-        UPDATE_STAT64_NIG(egress_mac_pkt0,
+        if (!CHIP_IS_E3(bp)) {
+                UPDATE_STAT64_NIG(egress_mac_pkt0,
                                         etherstatspkts1024octetsto1522octets);
-        UPDATE_STAT64_NIG(egress_mac_pkt1, etherstatspktsover1522octets);
+                UPDATE_STAT64_NIG(egress_mac_pkt1,
+                                        etherstatspktsover1522octets);
+        }
 
         memcpy(old, new, sizeof(struct nig_stats));
 
@@ -746,11 +753,13 @@ static int bnx2x_hw_stats_update(struct bnx2x *bp)
 
 static int bnx2x_storm_stats_update(struct bnx2x *bp)
 {
-        struct eth_stats_query *stats = bnx2x_sp(bp, fw_stats);
         struct tstorm_per_port_stats *tport =
-                                        &stats->tstorm_common.port_statistics;
+                                &bp->fw_stats_data->port.tstorm_port_statistics;
+        struct tstorm_per_pf_stats *tfunc =
+                                &bp->fw_stats_data->pf.tstorm_pf_statistics;
         struct host_func_stats *fstats = bnx2x_sp(bp, func_stats);
         struct bnx2x_eth_stats *estats = &bp->eth_stats;
+        struct stats_counter *counters = &bp->fw_stats_data->storm_counters;
         int i;
         u16 cur_stats_counter;
 
@@ -761,6 +770,35 @@ static int bnx2x_storm_stats_update(struct bnx2x *bp)
         cur_stats_counter = bp->stats_counter - 1;
         spin_unlock_bh(&bp->stats_lock);
 
+        /* are storm stats valid? */
+        if (le16_to_cpu(counters->xstats_counter) != cur_stats_counter) {
+                DP(BNX2X_MSG_STATS, "stats not updated by xstorm"
+                   "  xstorm counter (0x%x) != stats_counter (0x%x)\n",
+                   le16_to_cpu(counters->xstats_counter), bp->stats_counter);
+                return -EAGAIN;
+        }
+
+        if (le16_to_cpu(counters->ustats_counter) != cur_stats_counter) {
+                DP(BNX2X_MSG_STATS, "stats not updated by ustorm"
+                   "  ustorm counter (0x%x) != stats_counter (0x%x)\n",
+                   le16_to_cpu(counters->ustats_counter), bp->stats_counter);
+                return -EAGAIN;
+        }
+
+        if (le16_to_cpu(counters->cstats_counter) != cur_stats_counter) {
+                DP(BNX2X_MSG_STATS, "stats not updated by cstorm"
+                   "  cstorm counter (0x%x) != stats_counter (0x%x)\n",
+                   le16_to_cpu(counters->cstats_counter), bp->stats_counter);
+                return -EAGAIN;
+        }
+
+        if (le16_to_cpu(counters->tstats_counter) != cur_stats_counter) {
+                DP(BNX2X_MSG_STATS, "stats not updated by tstorm"
+                   "  tstorm counter (0x%x) != stats_counter (0x%x)\n",
+                   le16_to_cpu(counters->tstats_counter), bp->stats_counter);
+                return -EAGAIN;
+        }
+
         memcpy(&(fstats->total_bytes_received_hi),
                &(bnx2x_sp(bp, func_stats_base)->total_bytes_received_hi),
                sizeof(struct host_func_stats) - 2*sizeof(u32));
@@ -770,94 +808,84 @@ static int bnx2x_storm_stats_update(struct bnx2x *bp)
         estats->etherstatsoverrsizepkts_lo = 0;
         estats->no_buff_discard_hi = 0;
         estats->no_buff_discard_lo = 0;
+        estats->total_tpa_aggregations_hi = 0;
+        estats->total_tpa_aggregations_lo = 0;
+        estats->total_tpa_aggregated_frames_hi = 0;
+        estats->total_tpa_aggregated_frames_lo = 0;
+        estats->total_tpa_bytes_hi = 0;
+        estats->total_tpa_bytes_lo = 0;
 
         for_each_eth_queue(bp, i) {
                 struct bnx2x_fastpath *fp = &bp->fp[i];
-                int cl_id = fp->cl_id;
-                struct tstorm_per_client_stats *tclient =
-                                &stats->tstorm_common.client_statistics[cl_id];
-                struct tstorm_per_client_stats *old_tclient = &fp->old_tclient;
-                struct ustorm_per_client_stats *uclient =
-                                &stats->ustorm_common.client_statistics[cl_id];
-                struct ustorm_per_client_stats *old_uclient = &fp->old_uclient;
-                struct xstorm_per_client_stats *xclient =
-                                &stats->xstorm_common.client_statistics[cl_id];
-                struct xstorm_per_client_stats *old_xclient = &fp->old_xclient;
+                struct tstorm_per_queue_stats *tclient =
+                        &bp->fw_stats_data->queue_stats[i].
+                        tstorm_queue_statistics;
+                struct tstorm_per_queue_stats *old_tclient = &fp->old_tclient;
+                struct ustorm_per_queue_stats *uclient =
+                        &bp->fw_stats_data->queue_stats[i].
+                        ustorm_queue_statistics;
+                struct ustorm_per_queue_stats *old_uclient = &fp->old_uclient;
+                struct xstorm_per_queue_stats *xclient =
+                        &bp->fw_stats_data->queue_stats[i].
+                        xstorm_queue_statistics;
+                struct xstorm_per_queue_stats *old_xclient = &fp->old_xclient;
                 struct bnx2x_eth_q_stats *qstats = &fp->eth_q_stats;
                 u32 diff;
 
-                /* are storm stats valid? */
-                if (le16_to_cpu(xclient->stats_counter) != cur_stats_counter) {
-                        DP(BNX2X_MSG_STATS, "[%d] stats not updated by xstorm"
-                           "  xstorm counter (0x%x) != stats_counter (0x%x)\n",
-                           i, xclient->stats_counter, cur_stats_counter + 1);
-                        return -1;
-                }
-                if (le16_to_cpu(tclient->stats_counter) != cur_stats_counter) {
-                        DP(BNX2X_MSG_STATS, "[%d] stats not updated by tstorm"
-                           "  tstorm counter (0x%x) != stats_counter (0x%x)\n",
-                           i, tclient->stats_counter, cur_stats_counter + 1);
-                        return -2;
-                }
-                if (le16_to_cpu(uclient->stats_counter) != cur_stats_counter) {
-                        DP(BNX2X_MSG_STATS, "[%d] stats not updated by ustorm"
-                           "  ustorm counter (0x%x) != stats_counter (0x%x)\n",
-                           i, uclient->stats_counter, cur_stats_counter + 1);
-                        return -4;
-                }
+                DP(BNX2X_MSG_STATS, "queue[%d]: ucast_sent 0x%x, "
+                                    "bcast_sent 0x%x mcast_sent 0x%x\n",
+                   i, xclient->ucast_pkts_sent,
+                   xclient->bcast_pkts_sent, xclient->mcast_pkts_sent);
+
+                DP(BNX2X_MSG_STATS, "---------------\n");
 
+                qstats->total_broadcast_bytes_received_hi =
+                        le32_to_cpu(tclient->rcv_bcast_bytes.hi);
+                qstats->total_broadcast_bytes_received_lo =
+                        le32_to_cpu(tclient->rcv_bcast_bytes.lo);
+
+                qstats->total_multicast_bytes_received_hi =
+                        le32_to_cpu(tclient->rcv_mcast_bytes.hi);
+                qstats->total_multicast_bytes_received_lo =
+                        le32_to_cpu(tclient->rcv_mcast_bytes.lo);
+
+                qstats->total_unicast_bytes_received_hi =
+                        le32_to_cpu(tclient->rcv_ucast_bytes.hi);
+                qstats->total_unicast_bytes_received_lo =
+                        le32_to_cpu(tclient->rcv_ucast_bytes.lo);
+
+                /*
+                 * sum to total_bytes_received all
+                 * unicast/multicast/broadcast
+                 */
                 qstats->total_bytes_received_hi =
-                        le32_to_cpu(tclient->rcv_broadcast_bytes.hi);
+                        qstats->total_broadcast_bytes_received_hi;
                 qstats->total_bytes_received_lo =
-                        le32_to_cpu(tclient->rcv_broadcast_bytes.lo);
+                        qstats->total_broadcast_bytes_received_lo;
 
                 ADD_64(qstats->total_bytes_received_hi,
-                       le32_to_cpu(tclient->rcv_multicast_bytes.hi),
+                       qstats->total_multicast_bytes_received_hi,
                        qstats->total_bytes_received_lo,
-                       le32_to_cpu(tclient->rcv_multicast_bytes.lo));
+                       qstats->total_multicast_bytes_received_lo);
 
                 ADD_64(qstats->total_bytes_received_hi,
-                       le32_to_cpu(tclient->rcv_unicast_bytes.hi),
-                       qstats->total_bytes_received_lo,
-                       le32_to_cpu(tclient->rcv_unicast_bytes.lo));
-
-                SUB_64(qstats->total_bytes_received_hi,
-                       le32_to_cpu(uclient->bcast_no_buff_bytes.hi),
+                       qstats->total_unicast_bytes_received_hi,
                        qstats->total_bytes_received_lo,
-                       le32_to_cpu(uclient->bcast_no_buff_bytes.lo));
-
-                SUB_64(qstats->total_bytes_received_hi,
-                       le32_to_cpu(uclient->mcast_no_buff_bytes.hi),
-                       qstats->total_bytes_received_lo,
-                       le32_to_cpu(uclient->mcast_no_buff_bytes.lo));
-
-                SUB_64(qstats->total_bytes_received_hi,
-                       le32_to_cpu(uclient->ucast_no_buff_bytes.hi),
-                       qstats->total_bytes_received_lo,
-                       le32_to_cpu(uclient->ucast_no_buff_bytes.lo));
+                       qstats->total_unicast_bytes_received_lo);
 
                 qstats->valid_bytes_received_hi =
                                         qstats->total_bytes_received_hi;
                 qstats->valid_bytes_received_lo =
                                         qstats->total_bytes_received_lo;
 
-                qstats->error_bytes_received_hi =
-                                le32_to_cpu(tclient->rcv_error_bytes.hi);
-                qstats->error_bytes_received_lo =
-                                le32_to_cpu(tclient->rcv_error_bytes.lo);
-
-                ADD_64(qstats->total_bytes_received_hi,
-                       qstats->error_bytes_received_hi,
-                       qstats->total_bytes_received_lo,
-                       qstats->error_bytes_received_lo);
 
-                UPDATE_EXTEND_TSTAT(rcv_unicast_pkts,
+                UPDATE_EXTEND_TSTAT(rcv_ucast_pkts,
                                         total_unicast_packets_received);
-                UPDATE_EXTEND_TSTAT(rcv_multicast_pkts,
+                UPDATE_EXTEND_TSTAT(rcv_mcast_pkts,
                                         total_multicast_packets_received);
-                UPDATE_EXTEND_TSTAT(rcv_broadcast_pkts,
+                UPDATE_EXTEND_TSTAT(rcv_bcast_pkts,
                                         total_broadcast_packets_received);
-                UPDATE_EXTEND_TSTAT(packets_too_big_discard,
+                UPDATE_EXTEND_TSTAT(pkts_too_big_discard,
                                         etherstatsoverrsizepkts);
                 UPDATE_EXTEND_TSTAT(no_buff_discard, no_buff_discard);
 
@@ -871,30 +899,78 @@ static int bnx2x_storm_stats_update(struct bnx2x *bp)
                 UPDATE_EXTEND_USTAT(mcast_no_buff_pkts, no_buff_discard);
                 UPDATE_EXTEND_USTAT(bcast_no_buff_pkts, no_buff_discard);
 
+                qstats->total_broadcast_bytes_transmitted_hi =
+                        le32_to_cpu(xclient->bcast_bytes_sent.hi);
+                qstats->total_broadcast_bytes_transmitted_lo =
+                        le32_to_cpu(xclient->bcast_bytes_sent.lo);
+
+                qstats->total_multicast_bytes_transmitted_hi =
+                        le32_to_cpu(xclient->mcast_bytes_sent.hi);
+                qstats->total_multicast_bytes_transmitted_lo =
+                        le32_to_cpu(xclient->mcast_bytes_sent.lo);
+
+                qstats->total_unicast_bytes_transmitted_hi =
+                        le32_to_cpu(xclient->ucast_bytes_sent.hi);
+                qstats->total_unicast_bytes_transmitted_lo =
+                        le32_to_cpu(xclient->ucast_bytes_sent.lo);
+                /*
+                 * sum to total_bytes_transmitted all
+                 * unicast/multicast/broadcast
+                 */
                 qstats->total_bytes_transmitted_hi =
-                                le32_to_cpu(xclient->unicast_bytes_sent.hi);
+                                qstats->total_unicast_bytes_transmitted_hi;
                 qstats->total_bytes_transmitted_lo =
-                                le32_to_cpu(xclient->unicast_bytes_sent.lo);
+                                qstats->total_unicast_bytes_transmitted_lo;
 
                 ADD_64(qstats->total_bytes_transmitted_hi,
-                       le32_to_cpu(xclient->multicast_bytes_sent.hi),
+                       qstats->total_broadcast_bytes_transmitted_hi,
                        qstats->total_bytes_transmitted_lo,
-                       le32_to_cpu(xclient->multicast_bytes_sent.lo));
+                       qstats->total_broadcast_bytes_transmitted_lo);
 
                 ADD_64(qstats->total_bytes_transmitted_hi,
-                       le32_to_cpu(xclient->broadcast_bytes_sent.hi),
+                       qstats->total_multicast_bytes_transmitted_hi,
                        qstats->total_bytes_transmitted_lo,
-                       le32_to_cpu(xclient->broadcast_bytes_sent.lo));
+                       qstats->total_multicast_bytes_transmitted_lo);
 
-                UPDATE_EXTEND_XSTAT(unicast_pkts_sent,
+                UPDATE_EXTEND_XSTAT(ucast_pkts_sent,
                                         total_unicast_packets_transmitted);
-                UPDATE_EXTEND_XSTAT(multicast_pkts_sent,
+                UPDATE_EXTEND_XSTAT(mcast_pkts_sent,
                                         total_multicast_packets_transmitted);
-                UPDATE_EXTEND_XSTAT(broadcast_pkts_sent,
+                UPDATE_EXTEND_XSTAT(bcast_pkts_sent,
                                         total_broadcast_packets_transmitted);
 
-                old_tclient->checksum_discard = tclient->checksum_discard;
-                old_tclient->ttl0_discard = tclient->ttl0_discard;
+                UPDATE_EXTEND_TSTAT(checksum_discard,
+                                    total_packets_received_checksum_discarded);
+                UPDATE_EXTEND_TSTAT(ttl0_discard,
+                                    total_packets_received_ttl0_discarded);
+
+                UPDATE_EXTEND_XSTAT(error_drop_pkts,
+                                    total_transmitted_dropped_packets_error);
+
+                /* TPA aggregations completed */
+                UPDATE_EXTEND_USTAT(coalesced_events, total_tpa_aggregations);
+                /* Number of network frames aggregated by TPA */
+                UPDATE_EXTEND_USTAT(coalesced_pkts,
+                                    total_tpa_aggregated_frames);
+                /* Total number of bytes in completed TPA aggregations */
+                qstats->total_tpa_bytes_lo =
+                        le32_to_cpu(uclient->coalesced_bytes.lo);
+                qstats->total_tpa_bytes_hi =
+                        le32_to_cpu(uclient->coalesced_bytes.hi);
+
+                /* TPA stats per-function */
+                ADD_64(estats->total_tpa_aggregations_hi,
+                       qstats->total_tpa_aggregations_hi,
+                       estats->total_tpa_aggregations_lo,
+                       qstats->total_tpa_aggregations_lo);
+                ADD_64(estats->total_tpa_aggregated_frames_hi,
+                       qstats->total_tpa_aggregated_frames_hi,
+                       estats->total_tpa_aggregated_frames_lo,
+                       qstats->total_tpa_aggregated_frames_lo);
+                ADD_64(estats->total_tpa_bytes_hi,
+                       qstats->total_tpa_bytes_hi,
+                       estats->total_tpa_bytes_lo,
+                       qstats->total_tpa_bytes_lo);
 
                 ADD_64(fstats->total_bytes_received_hi,
                        qstats->total_bytes_received_hi,
@@ -933,10 +1009,6 @@ static int bnx2x_storm_stats_update(struct bnx2x *bp)
                        fstats->valid_bytes_received_lo,
                        qstats->valid_bytes_received_lo);
 
-                ADD_64(estats->error_bytes_received_hi,
-                       qstats->error_bytes_received_hi,
-                       estats->error_bytes_received_lo,
-                       qstats->error_bytes_received_lo);
                 ADD_64(estats->etherstatsoverrsizepkts_hi,
                        qstats->etherstatsoverrsizepkts_hi,
                        estats->etherstatsoverrsizepkts_lo,
@@ -950,9 +1022,19 @@ static int bnx2x_storm_stats_update(struct bnx2x *bp)
                fstats->total_bytes_received_lo,
                estats->rx_stat_ifhcinbadoctets_lo);
 
+        ADD_64(fstats->total_bytes_received_hi,
+               tfunc->rcv_error_bytes.hi,
+               fstats->total_bytes_received_lo,
+               tfunc->rcv_error_bytes.lo);
+
         memcpy(estats, &(fstats->total_bytes_received_hi),
                sizeof(struct host_func_stats) - 2*sizeof(u32));
 
+        ADD_64(estats->error_bytes_received_hi,
+               tfunc->rcv_error_bytes.hi,
+               estats->error_bytes_received_lo,
+               tfunc->rcv_error_bytes.lo);
+
         ADD_64(estats->etherstatsoverrsizepkts_hi,
                estats->rx_stat_dot3statsframestoolong_hi,
                estats->etherstatsoverrsizepkts_lo,
@@ -965,8 +1047,8 @@ static int bnx2x_storm_stats_update(struct bnx2x *bp)
         if (bp->port.pmf) {
                 estats->mac_filter_discard =
                                 le32_to_cpu(tport->mac_filter_discard);
-                estats->xxoverflow_discard =
-                                le32_to_cpu(tport->xxoverflow_discard);
+                estats->mf_tag_discard =
+                                le32_to_cpu(tport->mf_tag_discard);
                 estats->brb_truncate_discard =
                                 le32_to_cpu(tport->brb_truncate_discard);
                 estats->mac_discard = le32_to_cpu(tport->mac_discard);
@@ -1023,7 +1105,7 @@ static void bnx2x_net_stats_update(struct bnx2x *bp)
         nstats->rx_frame_errors =
                 bnx2x_hilo(&estats->rx_stat_dot3statsalignmenterrors_hi);
         nstats->rx_fifo_errors = bnx2x_hilo(&estats->no_buff_discard_hi);
-        nstats->rx_missed_errors = estats->xxoverflow_discard;
+        nstats->rx_missed_errors = 0;
 
         nstats->rx_errors = nstats->rx_length_errors +
                             nstats->rx_over_errors +
@@ -1065,10 +1147,27 @@ static void bnx2x_drv_stats_update(struct bnx2x *bp)
         }
 }
 
+static bool bnx2x_edebug_stats_stopped(struct bnx2x *bp)
+{
+        u32 val;
+
+        if (SHMEM2_HAS(bp, edebug_driver_if[1])) {
+                val = SHMEM2_RD(bp, edebug_driver_if[1]);
+
+                if (val == EDEBUG_DRIVER_IF_OP_CODE_DISABLE_STAT)
+                        return true;
+        }
+
+        return false;
+}
+
 static void bnx2x_stats_update(struct bnx2x *bp)
 {
         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
 
+        if (bnx2x_edebug_stats_stopped(bp))
+                return;
+
         if (*stats_comp != DMAE_COMP_VAL)
                 return;
 
@@ -1088,8 +1187,7 @@ static void bnx2x_stats_update(struct bnx2x *bp)
                 struct bnx2x_eth_stats *estats = &bp->eth_stats;
                 int i;
 
-                printk(KERN_DEBUG "%s: brb drops %u  brb truncate %u\n",
-                       bp->dev->name,
+                netdev_dbg(bp->dev, "brb drops %u  brb truncate %u\n",
                        estats->brb_drop_lo, estats->brb_truncate_lo);
 
                 for_each_eth_queue(bp, i) {
@@ -1149,6 +1247,7 @@ static void bnx2x_port_stats_stop(struct bnx2x *bp)
                 else
                         dmae->opcode = bnx2x_dmae_opcode_add_comp(
                                                 opcode, DMAE_COMP_PCI);
+
                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
                 dmae->dst_addr_lo = bp->port.port_stx >> 2;
@@ -1235,13 +1334,9 @@ static const struct {
 void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event)
 {
         enum bnx2x_stats_state state;
-
         if (unlikely(bp->panic))
                 return;
-
         bnx2x_stats_stm[bp->stats_state][event].action(bp);
-
-        /* Protect a state change flow */
         spin_lock_bh(&bp->stats_lock);
         state = bp->stats_state;
         bp->stats_state = bnx2x_stats_stm[state][event].next_state;
@@ -1297,7 +1392,7 @@ static void bnx2x_func_stats_base_init(struct bnx2x *bp)
         func_stx = bp->func_stx;
 
         for (vn = VN_0; vn < vn_max; vn++) {
-                int mb_idx = !CHIP_IS_E2(bp) ? 2*vn + BP_PORT(bp) : vn;
+                int mb_idx = CHIP_IS_E1x(bp) ? 2*vn + BP_PORT(bp) : vn;
 
                 bp->func_stx = SHMEM_RD(bp, func_mb[mb_idx].fw_mb_param);
                 bnx2x_func_stats_init(bp);
@@ -1339,12 +1434,97 @@ static void bnx2x_func_stats_base_update(struct bnx2x *bp)
         bnx2x_stats_comp(bp);
 }
 
+/**
+ * This function will prepare the statistics ramrod data the way
+ * we will only have to increment the statistics counter and
+ * send the ramrod each time we have to.
+ *
+ * @param bp
+ */
+static inline void bnx2x_prep_fw_stats_req(struct bnx2x *bp)
+{
+        int i;
+        struct stats_query_header *stats_hdr = &bp->fw_stats_req->hdr;
+
+        dma_addr_t cur_data_offset;
+        struct stats_query_entry *cur_query_entry;
+
+        stats_hdr->cmd_num = bp->fw_stats_num;
+        stats_hdr->drv_stats_counter = 0;
+
+        /* storm_counters struct contains the counters of completed
+         * statistics requests per storm which are incremented by FW
+         * each time it completes hadning a statistics ramrod. We will
+         * check these counters in the timer handler and discard a
+         * (statistics) ramrod completion.
+         */
+        cur_data_offset = bp->fw_stats_data_mapping +
+                offsetof(struct bnx2x_fw_stats_data, storm_counters);
+
+        stats_hdr->stats_counters_addrs.hi =
+                cpu_to_le32(U64_HI(cur_data_offset));
+        stats_hdr->stats_counters_addrs.lo =
+                cpu_to_le32(U64_LO(cur_data_offset));
+
+        /* prepare to the first stats ramrod (will be completed with
+         * the counters equal to zero) - init counters to somethig different.
+         */
+        memset(&bp->fw_stats_data->storm_counters, 0xff,
+               sizeof(struct stats_counter));
+
+        /**** Port FW statistics data ****/
+        cur_data_offset = bp->fw_stats_data_mapping +
+                offsetof(struct bnx2x_fw_stats_data, port);
+
+        cur_query_entry = &bp->fw_stats_req->query[BNX2X_PORT_QUERY_IDX];
+
+        cur_query_entry->kind = STATS_TYPE_PORT;
+        /* For port query index is a DONT CARE */
+        cur_query_entry->index = BP_PORT(bp);
+        /* For port query funcID is a DONT CARE */
+        cur_query_entry->funcID = cpu_to_le16(BP_FUNC(bp));
+        cur_query_entry->address.hi = cpu_to_le32(U64_HI(cur_data_offset));
+        cur_query_entry->address.lo = cpu_to_le32(U64_LO(cur_data_offset));
+
+        /**** PF FW statistics data ****/
+        cur_data_offset = bp->fw_stats_data_mapping +
+                offsetof(struct bnx2x_fw_stats_data, pf);
+
+        cur_query_entry = &bp->fw_stats_req->query[BNX2X_PF_QUERY_IDX];
+
+        cur_query_entry->kind = STATS_TYPE_PF;
+        /* For PF query index is a DONT CARE */
+        cur_query_entry->index = BP_PORT(bp);
+        cur_query_entry->funcID = cpu_to_le16(BP_FUNC(bp));
+        cur_query_entry->address.hi = cpu_to_le32(U64_HI(cur_data_offset));
+        cur_query_entry->address.lo = cpu_to_le32(U64_LO(cur_data_offset));
+
+        /**** Clients' queries ****/
+        cur_data_offset = bp->fw_stats_data_mapping +
+                offsetof(struct bnx2x_fw_stats_data, queue_stats);
+
+        for_each_eth_queue(bp, i) {
+                cur_query_entry =
+                        &bp->fw_stats_req->
+                                        query[BNX2X_FIRST_QUEUE_QUERY_IDX + i];
+
+                cur_query_entry->kind = STATS_TYPE_QUEUE;
+                cur_query_entry->index = bnx2x_stats_id(&bp->fp[i]);
+                cur_query_entry->funcID = cpu_to_le16(BP_FUNC(bp));
+                cur_query_entry->address.hi =
+                        cpu_to_le32(U64_HI(cur_data_offset));
+                cur_query_entry->address.lo =
+                        cpu_to_le32(U64_LO(cur_data_offset));
+
+                cur_data_offset += sizeof(struct per_queue_stats);
+        }
+}
+
 void bnx2x_stats_init(struct bnx2x *bp)
 {
-        int port = BP_PORT(bp);
+        int /*abs*/port = BP_PORT(bp);
         int mb_idx = BP_FW_MB_IDX(bp);
         int i;
-        struct eth_stats_query *stats = bnx2x_sp(bp, fw_stats);
 
         bp->stats_pending = 0;
         bp->executer_idx = 0;
@@ -1362,45 +1542,35 @@ void bnx2x_stats_init(struct bnx2x *bp)
         DP(BNX2X_MSG_STATS, "port_stx 0x%x  func_stx 0x%x\n",
            bp->port.port_stx, bp->func_stx);
 
+        port = BP_PORT(bp);
         /* port stats */
         memset(&(bp->port.old_nig_stats), 0, sizeof(struct nig_stats));
         bp->port.old_nig_stats.brb_discard =
                         REG_RD(bp, NIG_REG_STAT0_BRB_DISCARD + port*0x38);
         bp->port.old_nig_stats.brb_truncate =
                         REG_RD(bp, NIG_REG_STAT0_BRB_TRUNCATE + port*0x38);
-        REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT0 + port*0x50,
-                    &(bp->port.old_nig_stats.egress_mac_pkt0_lo), 2);
-        REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT1 + port*0x50,
-                    &(bp->port.old_nig_stats.egress_mac_pkt1_lo), 2);
+        if (!CHIP_IS_E3(bp)) {
+                REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT0 + port*0x50,
+                            &(bp->port.old_nig_stats.egress_mac_pkt0_lo), 2);
+                REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT1 + port*0x50,
+                            &(bp->port.old_nig_stats.egress_mac_pkt1_lo), 2);
+        }
 
         /* function stats */
         for_each_queue(bp, i) {
                 struct bnx2x_fastpath *fp = &bp->fp[i];
 
-                memset(&fp->old_tclient, 0,
-                       sizeof(struct tstorm_per_client_stats));
-                memset(&fp->old_uclient, 0,
-                       sizeof(struct ustorm_per_client_stats));
-                memset(&fp->old_xclient, 0,
-                       sizeof(struct xstorm_per_client_stats));
-                memset(&fp->eth_q_stats, 0, sizeof(struct bnx2x_eth_q_stats));
+                memset(&fp->old_tclient, 0, sizeof(fp->old_tclient));
+                memset(&fp->old_uclient, 0, sizeof(fp->old_uclient));
+                memset(&fp->old_xclient, 0, sizeof(fp->old_xclient));
+                memset(&fp->eth_q_stats, 0, sizeof(fp->eth_q_stats));
         }
 
-        /* FW stats are currently collected for ETH clients only */
-        for_each_eth_queue(bp, i) {
-                /* Set initial stats counter in the stats ramrod data to -1 */
-                int cl_id = bp->fp[i].cl_id;
-
-                stats->xstorm_common.client_statistics[cl_id].
-                        stats_counter = 0xffff;
-                stats->ustorm_common.client_statistics[cl_id].
-                        stats_counter = 0xffff;
-                stats->tstorm_common.client_statistics[cl_id].
-                        stats_counter = 0xffff;
-        }
+        /* Prepare statistics ramrod data */
+        bnx2x_prep_fw_stats_req(bp);
 
-        memset(&bp->dev->stats, 0, sizeof(struct net_device_stats));
-        memset(&bp->eth_stats, 0, sizeof(struct bnx2x_eth_stats));
+        memset(&bp->dev->stats, 0, sizeof(bp->dev->stats));
+        memset(&bp->eth_stats, 0, sizeof(bp->eth_stats));
 
         bp->stats_state = STATS_STATE_DISABLED;
 
diff --git a/drivers/net/bnx2x/bnx2x_stats.h b/drivers/net/bnx2x/bnx2x_stats.h
index 45d14d8bc1aa..5d8ce2f6afef 100644
--- a/drivers/net/bnx2x/bnx2x_stats.h
+++ b/drivers/net/bnx2x/bnx2x_stats.h
@@ -14,48 +14,11 @@
  * Statistics and Link management by Yitchak Gertner
  *
  */
-
 #ifndef BNX2X_STATS_H
 #define BNX2X_STATS_H
 
 #include <linux/types.h>
 
-struct bnx2x_eth_q_stats {
-        u32 total_bytes_received_hi;
-        u32 total_bytes_received_lo;
-        u32 total_bytes_transmitted_hi;
-        u32 total_bytes_transmitted_lo;
-        u32 total_unicast_packets_received_hi;
-        u32 total_unicast_packets_received_lo;
-        u32 total_multicast_packets_received_hi;
-        u32 total_multicast_packets_received_lo;
-        u32 total_broadcast_packets_received_hi;
-        u32 total_broadcast_packets_received_lo;
-        u32 total_unicast_packets_transmitted_hi;
-        u32 total_unicast_packets_transmitted_lo;
-        u32 total_multicast_packets_transmitted_hi;
-        u32 total_multicast_packets_transmitted_lo;
-        u32 total_broadcast_packets_transmitted_hi;
-        u32 total_broadcast_packets_transmitted_lo;
-        u32 valid_bytes_received_hi;
-        u32 valid_bytes_received_lo;
-
-        u32 error_bytes_received_hi;
-        u32 error_bytes_received_lo;
-        u32 etherstatsoverrsizepkts_hi;
-        u32 etherstatsoverrsizepkts_lo;
-        u32 no_buff_discard_hi;
-        u32 no_buff_discard_lo;
-
-        u32 driver_xoff;
-        u32 rx_err_discard_pkt;
-        u32 rx_skb_alloc_failed;
-        u32 hw_csum_err;
-};
-
-#define Q_STATS_OFFSET32(stat_name) \
-                        (offsetof(struct bnx2x_eth_q_stats, stat_name) / 4)
-
 struct nig_stats {
         u32 brb_discard;
         u32 brb_packet;
@@ -212,7 +175,7 @@ struct bnx2x_eth_stats {
         u32 brb_truncate_lo;
 
         u32 mac_filter_discard;
-        u32 xxoverflow_discard;
+        u32 mf_tag_discard;
         u32 brb_truncate_discard;
         u32 mac_discard;
 
@@ -222,16 +185,197 @@ struct bnx2x_eth_stats {
         u32 hw_csum_err;
 
         u32 nig_timer_max;
+
+        /* TPA */
+        u32 total_tpa_aggregations_hi;
+        u32 total_tpa_aggregations_lo;
+        u32 total_tpa_aggregated_frames_hi;
+        u32 total_tpa_aggregated_frames_lo;
+        u32 total_tpa_bytes_hi;
+        u32 total_tpa_bytes_lo;
+};
+
+
+struct bnx2x_eth_q_stats {
+        u32 total_unicast_bytes_received_hi;
+        u32 total_unicast_bytes_received_lo;
+        u32 total_broadcast_bytes_received_hi;
+        u32 total_broadcast_bytes_received_lo;
+        u32 total_multicast_bytes_received_hi;
+        u32 total_multicast_bytes_received_lo;
+        u32 total_bytes_received_hi;
+        u32 total_bytes_received_lo;
+        u32 total_unicast_bytes_transmitted_hi;
+        u32 total_unicast_bytes_transmitted_lo;
+        u32 total_broadcast_bytes_transmitted_hi;
+        u32 total_broadcast_bytes_transmitted_lo;
+        u32 total_multicast_bytes_transmitted_hi;
+        u32 total_multicast_bytes_transmitted_lo;
+        u32 total_bytes_transmitted_hi;
+        u32 total_bytes_transmitted_lo;
+        u32 total_unicast_packets_received_hi;
+        u32 total_unicast_packets_received_lo;
+        u32 total_multicast_packets_received_hi;
+        u32 total_multicast_packets_received_lo;
+        u32 total_broadcast_packets_received_hi;
+        u32 total_broadcast_packets_received_lo;
+        u32 total_unicast_packets_transmitted_hi;
+        u32 total_unicast_packets_transmitted_lo;
+        u32 total_multicast_packets_transmitted_hi;
+        u32 total_multicast_packets_transmitted_lo;
+        u32 total_broadcast_packets_transmitted_hi;
+        u32 total_broadcast_packets_transmitted_lo;
+        u32 valid_bytes_received_hi;
+        u32 valid_bytes_received_lo;
+
+        u32 etherstatsoverrsizepkts_hi;
+        u32 etherstatsoverrsizepkts_lo;
+        u32 no_buff_discard_hi;
+        u32 no_buff_discard_lo;
+
+        u32 driver_xoff;
+        u32 rx_err_discard_pkt;
+        u32 rx_skb_alloc_failed;
+        u32 hw_csum_err;
+
+        u32 total_packets_received_checksum_discarded_hi;
+        u32 total_packets_received_checksum_discarded_lo;
+        u32 total_packets_received_ttl0_discarded_hi;
+        u32 total_packets_received_ttl0_discarded_lo;
+        u32 total_transmitted_dropped_packets_error_hi;
+        u32 total_transmitted_dropped_packets_error_lo;
+
+        /* TPA */
+        u32 total_tpa_aggregations_hi;
+        u32 total_tpa_aggregations_lo;
+        u32 total_tpa_aggregated_frames_hi;
+        u32 total_tpa_aggregated_frames_lo;
+        u32 total_tpa_bytes_hi;
+        u32 total_tpa_bytes_lo;
 };
 
-#define STATS_OFFSET32(stat_name) \
-                        (offsetof(struct bnx2x_eth_stats, stat_name) / 4)
+/****************************************************************************
+* Macros
+****************************************************************************/
+
+/* sum[hi:lo] += add[hi:lo] */
+#define ADD_64(s_hi, a_hi, s_lo, a_lo) \
+        do { \
+                s_lo += a_lo; \
+                s_hi += a_hi + ((s_lo < a_lo) ? 1 : 0); \
+        } while (0)
+
+/* difference = minuend - subtrahend */
+#define DIFF_64(d_hi, m_hi, s_hi, d_lo, m_lo, s_lo) \
+        do { \
+                if (m_lo < s_lo) { \
+                        /* underflow */ \
+                        d_hi = m_hi - s_hi; \
+                        if (d_hi > 0) { \
+                                /* we can 'loan' 1 */ \
+                                d_hi--; \
+                                d_lo = m_lo + (UINT_MAX - s_lo) + 1; \
+                        } else { \
+                                /* m_hi <= s_hi */ \
+                                d_hi = 0; \
+                                d_lo = 0; \
+                        } \
+                } else { \
+                        /* m_lo >= s_lo */ \
+                        if (m_hi < s_hi) { \
+                                d_hi = 0; \
+                                d_lo = 0; \
+                        } else { \
+                                /* m_hi >= s_hi */ \
+                                d_hi = m_hi - s_hi; \
+                                d_lo = m_lo - s_lo; \
+                        } \
+                } \
+        } while (0)
+
+#define UPDATE_STAT64(s, t) \
+        do { \
+                DIFF_64(diff.hi, new->s##_hi, pstats->mac_stx[0].t##_hi, \
+                        diff.lo, new->s##_lo, pstats->mac_stx[0].t##_lo); \
+                pstats->mac_stx[0].t##_hi = new->s##_hi; \
+                pstats->mac_stx[0].t##_lo = new->s##_lo; \
+                ADD_64(pstats->mac_stx[1].t##_hi, diff.hi, \
+                       pstats->mac_stx[1].t##_lo, diff.lo); \
+        } while (0)
+
+#define UPDATE_STAT64_NIG(s, t) \
+        do { \
+                DIFF_64(diff.hi, new->s##_hi, old->s##_hi, \
+                        diff.lo, new->s##_lo, old->s##_lo); \
+                ADD_64(estats->t##_hi, diff.hi, \
+                       estats->t##_lo, diff.lo); \
+        } while (0)
+
+/* sum[hi:lo] += add */
+#define ADD_EXTEND_64(s_hi, s_lo, a) \
+        do { \
+                s_lo += a; \
+                s_hi += (s_lo < a) ? 1 : 0; \
+        } while (0)
+
+#define ADD_STAT64(diff, t) \
+        do { \
+                ADD_64(pstats->mac_stx[1].t##_hi, new->diff##_hi, \
+                       pstats->mac_stx[1].t##_lo, new->diff##_lo); \
+        } while (0)
+
+#define UPDATE_EXTEND_STAT(s) \
+        do { \
+                ADD_EXTEND_64(pstats->mac_stx[1].s##_hi, \
+                              pstats->mac_stx[1].s##_lo, \
+                              new->s); \
+        } while (0)
+
+#define UPDATE_EXTEND_TSTAT(s, t) \
+        do { \
+                diff = le32_to_cpu(tclient->s) - le32_to_cpu(old_tclient->s); \
+                old_tclient->s = tclient->s; \
+                ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
+        } while (0)
+
+#define UPDATE_EXTEND_USTAT(s, t) \
+        do { \
+                diff = le32_to_cpu(uclient->s) - le32_to_cpu(old_uclient->s); \
+                old_uclient->s = uclient->s; \
+                ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
+        } while (0)
+
+#define UPDATE_EXTEND_XSTAT(s, t) \
+        do { \
+                diff = le32_to_cpu(xclient->s) - le32_to_cpu(old_xclient->s); \
+                old_xclient->s = xclient->s; \
+                ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
+        } while (0)
+
+/* minuend -= subtrahend */
+#define SUB_64(m_hi, s_hi, m_lo, s_lo) \
+        do { \
+                DIFF_64(m_hi, m_hi, s_hi, m_lo, m_lo, s_lo); \
+        } while (0)
+
+/* minuend[hi:lo] -= subtrahend */
+#define SUB_EXTEND_64(m_hi, m_lo, s) \
+        do { \
+                SUB_64(m_hi, 0, m_lo, s); \
+        } while (0)
+
+#define SUB_EXTEND_USTAT(s, t) \
+        do { \
+                diff = le32_to_cpu(uclient->s) - le32_to_cpu(old_uclient->s); \
+                SUB_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
+        } while (0)
+
 
-/* Forward declaration */
+/* forward */
 struct bnx2x;
 
 void bnx2x_stats_init(struct bnx2x *bp);
 
-extern const u32 dmae_reg_go_c[];
+void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event);
 
 #endif /* BNX2X_STATS_H */
diff --git a/drivers/net/cnic.c b/drivers/net/cnic.c
index 07f1b13c8dce..e66c3d9ab2c6 100644
--- a/drivers/net/cnic.c
+++ b/drivers/net/cnic.c
@@ -1,6 +1,6 @@
 /* cnic.c: Broadcom CNIC core network driver.
  *
- * Copyright (c) 2006-2010 Broadcom Corporation
+ * Copyright (c) 2006-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
@@ -836,7 +836,6 @@ static void cnic_free_resc(struct cnic_dev *dev)
         cp->ctx_blks = 0;
 
         cnic_free_dma(dev, &cp->gbl_buf_info);
-        cnic_free_dma(dev, &cp->conn_buf_info);
         cnic_free_dma(dev, &cp->kwq_info);
         cnic_free_dma(dev, &cp->kwq_16_data_info);
         cnic_free_dma(dev, &cp->kcq2.dma);
@@ -1176,7 +1175,7 @@ static int cnic_alloc_bnx2x_resc(struct cnic_dev *dev)
         cp->iscsi_start_cid = start_cid;
         cp->fcoe_start_cid = start_cid + MAX_ISCSI_TBL_SZ;
 
-        if (BNX2X_CHIP_IS_E2(cp->chip_id)) {
+        if (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id)) {
                 cp->max_cid_space += BNX2X_FCOE_NUM_CONNECTIONS;
                 cp->fcoe_init_cid = ethdev->fcoe_init_cid;
                 if (!cp->fcoe_init_cid)
@@ -1232,18 +1231,12 @@ static int cnic_alloc_bnx2x_resc(struct cnic_dev *dev)
         if (ret)
                 goto error;
 
-        if (BNX2X_CHIP_IS_E2(cp->chip_id)) {
-                ret = cnic_alloc_kcq(dev, &cp->kcq2, false);
+        if (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id)) {
+                ret = cnic_alloc_kcq(dev, &cp->kcq2, true);
                 if (ret)
                         goto error;
         }
 
-        pages = PAGE_ALIGN(BNX2X_ISCSI_NUM_CONNECTIONS *
-                           BNX2X_ISCSI_CONN_BUF_SIZE) / PAGE_SIZE;
-        ret = cnic_alloc_dma(dev, &cp->conn_buf_info, pages, 1);
-        if (ret)
-                goto error;
-
         pages = PAGE_ALIGN(BNX2X_ISCSI_GLB_BUF_SIZE) / PAGE_SIZE;
         ret = cnic_alloc_dma(dev, &cp->gbl_buf_info, pages, 0);
         if (ret)
@@ -1610,6 +1603,7 @@ static int cnic_setup_bnx2x_ctx(struct cnic_dev *dev, struct kwqe *wqes[],
         struct iscsi_context *ictx;
         struct regpair context_addr;
         int i, j, n = 2, n_max;
+        u8 port = CNIC_PORT(cp);
 
         ctx->ctx_flags = 0;
         if (!req2->num_additional_wqes)
@@ -1661,6 +1655,17 @@ static int cnic_setup_bnx2x_ctx(struct cnic_dev *dev, struct kwqe *wqes[],
                 XSTORM_ISCSI_CONTEXT_FLAGS_B_IMMEDIATE_DATA;
         ictx->xstorm_st_context.iscsi.flags.flags |=
                 XSTORM_ISCSI_CONTEXT_FLAGS_B_INITIAL_R2T;
+        ictx->xstorm_st_context.common.ethernet.reserved_vlan_type =
+                ETH_P_8021Q;
+        if (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id) &&
+                cp->port_mode == CHIP_2_PORT_MODE) {
+
+                port = 0;
+        }
+        ictx->xstorm_st_context.common.flags =
+                1 << XSTORM_COMMON_CONTEXT_SECTION_PHYSQ_INITIALIZED_SHIFT;
+        ictx->xstorm_st_context.common.flags =
+                port << XSTORM_COMMON_CONTEXT_SECTION_PBF_PORT_SHIFT;
 
         ictx->tstorm_st_context.iscsi.hdr_bytes_2_fetch = ISCSI_HEADER_SIZE;
         /* TSTORM requires the base address of RQ DB & not PTE */
@@ -1876,8 +1881,11 @@ static int cnic_bnx2x_destroy_ramrod(struct cnic_dev *dev, u32 l5_cid)
         ret = cnic_submit_kwqe_16(dev, RAMROD_CMD_ID_COMMON_CFC_DEL,
                                   hw_cid, NONE_CONNECTION_TYPE, &l5_data);
 
-        if (ret == 0)
+        if (ret == 0) {
                 wait_event(ctx->waitq, ctx->wait_cond);
+                if (unlikely(test_bit(CTX_FL_CID_ERROR, &ctx->ctx_flags)))
+                        return -EBUSY;
+        }
 
         return ret;
 }
@@ -1912,8 +1920,10 @@ static int cnic_bnx2x_iscsi_destroy(struct cnic_dev *dev, struct kwqe *kwqe)
 skip_cfc_delete:
         cnic_free_bnx2x_conn_resc(dev, l5_cid);
 
-        atomic_dec(&cp->iscsi_conn);
-        clear_bit(CTX_FL_OFFLD_START, &ctx->ctx_flags);
+        if (!ret) {
+                atomic_dec(&cp->iscsi_conn);
+                clear_bit(CTX_FL_OFFLD_START, &ctx->ctx_flags);
+        }
 
 destroy_reply:
         memset(&kcqe, 0, sizeof(kcqe));
@@ -1972,8 +1982,6 @@ static void cnic_init_storm_conn_bufs(struct cnic_dev *dev,
                 tstorm_buf->ka_interval = kwqe3->ka_interval;
                 tstorm_buf->ka_max_probe_count = kwqe3->ka_max_probe_count;
         }
-        tstorm_buf->rcv_buf = kwqe3->rcv_buf;
-        tstorm_buf->snd_buf = kwqe3->snd_buf;
         tstorm_buf->max_rt_time = 0xffffffff;
 }
 
@@ -2002,15 +2010,14 @@ static void cnic_init_bnx2x_mac(struct cnic_dev *dev)
                  TSTORM_ISCSI_TCP_VARS_LSB_LOCAL_MAC_ADDR_OFFSET(pfid) + 1,
                  mac[4]);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid), mac[3]);
+                 TSTORM_ISCSI_TCP_VARS_MID_LOCAL_MAC_ADDR_OFFSET(pfid), mac[3]);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid) + 1,
+                 TSTORM_ISCSI_TCP_VARS_MID_LOCAL_MAC_ADDR_OFFSET(pfid) + 1,
                  mac[2]);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid) + 2,
-                 mac[1]);
+                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid), mac[1]);
         CNIC_WR8(dev, BAR_TSTRORM_INTMEM +
-                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid) + 3,
+                 TSTORM_ISCSI_TCP_VARS_MSB_LOCAL_MAC_ADDR_OFFSET(pfid) + 1,
                  mac[0]);
 }
 
@@ -2189,7 +2196,7 @@ static int cnic_bnx2x_fcoe_stat(struct cnic_dev *dev, struct kwqe *kwqe)
         memset(fcoe_stat, 0, sizeof(*fcoe_stat));
         memcpy(&fcoe_stat->stat_kwqe, req, sizeof(*req));
 
-        ret = cnic_submit_kwqe_16(dev, FCOE_RAMROD_CMD_ID_STAT, cid,
+        ret = cnic_submit_kwqe_16(dev, FCOE_RAMROD_CMD_ID_STAT_FUNC, cid,
                                   FCOE_CONNECTION_TYPE, &l5_data);
         return ret;
 }
@@ -2234,12 +2241,9 @@ static int cnic_bnx2x_fcoe_init1(struct cnic_dev *dev, struct kwqe *wqes[],
         memcpy(&fcoe_init->init_kwqe1, req1, sizeof(*req1));
         memcpy(&fcoe_init->init_kwqe2, req2, sizeof(*req2));
         memcpy(&fcoe_init->init_kwqe3, req3, sizeof(*req3));
-        fcoe_init->eq_addr.lo = cp->kcq2.dma.pg_map_arr[0] & 0xffffffff;
-        fcoe_init->eq_addr.hi = (u64) cp->kcq2.dma.pg_map_arr[0] >> 32;
-        fcoe_init->eq_next_page_addr.lo =
-                cp->kcq2.dma.pg_map_arr[1] & 0xffffffff;
-        fcoe_init->eq_next_page_addr.hi =
-                (u64) cp->kcq2.dma.pg_map_arr[1] >> 32;
+        fcoe_init->eq_pbl_base.lo = cp->kcq2.dma.pgtbl_map & 0xffffffff;
+        fcoe_init->eq_pbl_base.hi = (u64) cp->kcq2.dma.pgtbl_map >> 32;
+        fcoe_init->eq_pbl_size = cp->kcq2.dma.num_pages;
 
         fcoe_init->sb_num = cp->status_blk_num;
         fcoe_init->eq_prod = MAX_KCQ_IDX;
@@ -2247,7 +2251,7 @@ static int cnic_bnx2x_fcoe_init1(struct cnic_dev *dev, struct kwqe *wqes[],
         cp->kcq2.sw_prod_idx = 0;
 
         cid = BNX2X_HW_CID(cp, cp->fcoe_init_cid);
-        ret = cnic_submit_kwqe_16(dev, FCOE_RAMROD_CMD_ID_INIT, cid,
+        ret = cnic_submit_kwqe_16(dev, FCOE_RAMROD_CMD_ID_INIT_FUNC, cid,
                                   FCOE_CONNECTION_TYPE, &l5_data);
         *work = 3;
         return ret;
@@ -2463,7 +2467,7 @@ static int cnic_bnx2x_fcoe_fw_destroy(struct cnic_dev *dev, struct kwqe *kwqe)
         cid = BNX2X_HW_CID(cp, cp->fcoe_init_cid);
 
         memset(&l5_data, 0, sizeof(l5_data));
-        ret = cnic_submit_kwqe_16(dev, FCOE_RAMROD_CMD_ID_DESTROY, cid,
+        ret = cnic_submit_kwqe_16(dev, FCOE_RAMROD_CMD_ID_DESTROY_FUNC, cid,
                                   FCOE_CONNECTION_TYPE, &l5_data);
         return ret;
 }
@@ -2544,7 +2548,7 @@ static int cnic_submit_bnx2x_fcoe_kwqes(struct cnic_dev *dev,
         if (!test_bit(CNIC_F_CNIC_UP, &dev->flags))
                 return -EAGAIN;         /* bnx2 is down */
 
-        if (BNX2X_CHIP_NUM(cp->chip_id) == BNX2X_CHIP_NUM_57710)
+        if (!BNX2X_CHIP_IS_E2_PLUS(cp->chip_id))
                 return -EINVAL;
 
         for (i = 0; i < num_wqes; ) {
@@ -2935,7 +2939,7 @@ static void cnic_service_bnx2x_bh(unsigned long data)
                 CNIC_WR16(dev, cp->kcq1.io_addr,
                           cp->kcq1.sw_prod_idx + MAX_KCQ_IDX);
 
-                if (!BNX2X_CHIP_IS_E2(cp->chip_id)) {
+                if (!BNX2X_CHIP_IS_E2_PLUS(cp->chip_id)) {
                         cnic_ack_bnx2x_int(dev, cp->bnx2x_igu_sb_id, USTORM_ID,
                                            status_idx, IGU_INT_ENABLE, 1);
                         break;
@@ -3054,13 +3058,21 @@ static int cnic_ctl(void *data, struct cnic_ctl_info *info)
                 break;
         }
         case CNIC_CTL_COMPLETION_CMD: {
-                u32 cid = BNX2X_SW_CID(info->data.comp.cid);
+                struct cnic_ctl_completion *comp = &info->data.comp;
+                u32 cid = BNX2X_SW_CID(comp->cid);
                 u32 l5_cid;
                 struct cnic_local *cp = dev->cnic_priv;
 
                 if (cnic_get_l5_cid(cp, cid, &l5_cid) == 0) {
                         struct cnic_context *ctx = &cp->ctx_tbl[l5_cid];
 
+                        if (unlikely(comp->error)) {
+                                set_bit(CTX_FL_CID_ERROR, &ctx->ctx_flags);
+                                netdev_err(dev->netdev,
+                                           "CID %x CFC delete comp error %x\n",
+                                           cid, comp->error);
+                        }
+
                         ctx->wait_cond = 1;
                         wake_up(&ctx->waitq);
                 }
@@ -3935,10 +3947,17 @@ static void cnic_cm_stop_bnx2x_hw(struct cnic_dev *dev)
 
         for (i = 0; i < cp->max_cid_space; i++) {
                 struct cnic_context *ctx = &cp->ctx_tbl[i];
+                int j;
 
                 while (test_bit(CTX_FL_DELETE_WAIT, &ctx->ctx_flags))
                         msleep(10);
 
+                for (j = 0; j < 5; j++) {
+                        if (!test_bit(CTX_FL_OFFLD_START, &ctx->ctx_flags))
+                                break;
+                        msleep(20);
+                }
+
                 if (test_bit(CTX_FL_OFFLD_START, &ctx->ctx_flags))
                         netdev_warn(dev->netdev, "CID %x not deleted\n",
                                    ctx->cid);
@@ -4005,6 +4024,7 @@ static void cnic_delete_task(struct work_struct *work)
 
         for (i = 0; i < cp->max_cid_space; i++) {
                 struct cnic_context *ctx = &cp->ctx_tbl[i];
+                int err;
 
                 if (!test_bit(CTX_FL_OFFLD_START, &ctx->ctx_flags) ||
                     !test_bit(CTX_FL_DELETE_WAIT, &ctx->ctx_flags))
@@ -4018,13 +4038,15 @@ static void cnic_delete_task(struct work_struct *work)
                 if (!test_and_clear_bit(CTX_FL_DELETE_WAIT, &ctx->ctx_flags))
                         continue;
 
-                cnic_bnx2x_destroy_ramrod(dev, i);
+                err = cnic_bnx2x_destroy_ramrod(dev, i);
 
                 cnic_free_bnx2x_conn_resc(dev, i);
-                if (ctx->ulp_proto_id == CNIC_ULP_ISCSI)
-                        atomic_dec(&cp->iscsi_conn);
+                if (!err) {
+                        if (ctx->ulp_proto_id == CNIC_ULP_ISCSI)
+                                atomic_dec(&cp->iscsi_conn);
 
-                clear_bit(CTX_FL_OFFLD_START, &ctx->ctx_flags);
+                        clear_bit(CTX_FL_OFFLD_START, &ctx->ctx_flags);
+                }
         }
 
         if (need_resched)
@@ -4620,7 +4642,7 @@ static void cnic_enable_bnx2x_int(struct cnic_dev *dev)
                         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);
+                        offsetof(struct hc_index_data, timeout), 64 / 4);
         cnic_storm_memset_hc_disable(dev, sb_id, HC_INDEX_ISCSI_EQ_CONS, 0);
 }
 
@@ -4636,7 +4658,6 @@ static void cnic_init_bnx2x_tx_ring(struct cnic_dev *dev,
         union eth_tx_bd_types *txbd = (union eth_tx_bd_types *) udev->l2_ring;
         dma_addr_t buf_map, ring_map = udev->l2_ring_map;
         struct host_sp_status_block *sb = cp->bnx2x_def_status_blk;
-        int port = CNIC_PORT(cp);
         int i;
         u32 cli = cp->ethdev->iscsi_l2_client_id;
         u32 val;
@@ -4677,10 +4698,9 @@ static void cnic_init_bnx2x_tx_ring(struct cnic_dev *dev,
 
         /* reset xstorm per client statistics */
         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++)
-                        CNIC_WR(dev, val + i * 4, 0);
+                data->general.statistics_zero_flg = 1;
+                data->general.statistics_en_flg = 1;
+                data->general.statistics_counter_id = cli;
         }
 
         cp->tx_cons_ptr =
@@ -4698,7 +4718,6 @@ static void cnic_init_bnx2x_rx_ring(struct cnic_dev *dev,
                                 (udev->l2_ring + (2 * BCM_PAGE_SIZE));
         struct host_sp_status_block *sb = cp->bnx2x_def_status_blk;
         int i;
-        int port = CNIC_PORT(cp);
         u32 cli = cp->ethdev->iscsi_l2_client_id;
         int cl_qzone_id = BNX2X_CL_QZONE_ID(cp, cli);
         u32 val;
@@ -4706,10 +4725,10 @@ static void cnic_init_bnx2x_rx_ring(struct cnic_dev *dev,
 
         /* 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;
+        data->general.mtu = cpu_to_le16(cp->l2_single_buf_size - 14);
+        data->general.func_id = cp->pfid;
 
         for (i = 0; i < BNX2X_MAX_RX_DESC_CNT; i++, rxbd++) {
                 dma_addr_t buf_map;
@@ -4743,23 +4762,12 @@ static void cnic_init_bnx2x_rx_ring(struct cnic_dev *dev,
         data->rx.status_block_id = BNX2X_DEF_SB_ID;
 
         data->rx.cache_line_alignment_log_size = L1_CACHE_SHIFT;
-        data->rx.bd_buff_size = cpu_to_le16(cp->l2_single_buf_size);
 
-        data->rx.mtu = cpu_to_le16(cp->l2_single_buf_size - 14);
+        data->rx.max_bytes_on_bd = cpu_to_le16(cp->l2_single_buf_size);
         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);
-
-                val = BAR_USTRORM_INTMEM +
-                      USTORM_PER_COUNTER_ID_STATS_OFFSET(port, cli);
-                for (i = 0; i < sizeof(struct ustorm_per_client_stats) / 4; i++)
-                        CNIC_WR(dev, val + i * 4, 0);
-        }
+        data->rx.silent_vlan_removal_flg = 1;
+        data->rx.silent_vlan_value = 0;
+        data->rx.silent_vlan_mask = 0xffff;
 
         cp->rx_cons_ptr =
                 &sb->sp_sb.index_values[HC_SP_INDEX_ETH_ISCSI_RX_CQ_CONS];
@@ -4775,7 +4783,7 @@ static void cnic_init_bnx2x_kcq(struct cnic_dev *dev)
                            CSTORM_ISCSI_EQ_PROD_OFFSET(pfid, 0);
         cp->kcq1.sw_prod_idx = 0;
 
-        if (BNX2X_CHIP_IS_E2(cp->chip_id)) {
+        if (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id)) {
                 struct host_hc_status_block_e2 *sb = cp->status_blk.gen;
 
                 cp->kcq1.hw_prod_idx_ptr =
@@ -4791,7 +4799,7 @@ static void cnic_init_bnx2x_kcq(struct cnic_dev *dev)
                         &sb->sb.running_index[SM_RX_ID];
         }
 
-        if (BNX2X_CHIP_IS_E2(cp->chip_id)) {
+        if (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id)) {
                 struct host_hc_status_block_e2 *sb = cp->status_blk.gen;
 
                 cp->kcq2.io_addr = BAR_USTRORM_INTMEM +
@@ -4808,10 +4816,12 @@ 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 func = CNIC_FUNC(cp), ret;
         u32 pfid;
 
-        if (BNX2X_CHIP_IS_E2(cp->chip_id)) {
+        cp->port_mode = CHIP_PORT_MODE_NONE;
+
+        if (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id)) {
                 u32 val = CNIC_RD(dev, MISC_REG_PORT4MODE_EN_OVWR);
 
                 if (!(val & 1))
@@ -4819,10 +4829,13 @@ static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
                 else
                         val = (val >> 1) & 1;
 
-                if (val)
+                if (val) {
+                        cp->port_mode = CHIP_4_PORT_MODE;
                         cp->pfid = func >> 1;
-                else
+                } else {
+                        cp->port_mode = CHIP_4_PORT_MODE;
                         cp->pfid = func & 0x6;
+                }
         } else {
                 cp->pfid = func;
         }
@@ -4834,7 +4847,7 @@ static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
         if (ret)
                 return -ENOMEM;
 
-        if (BNX2X_CHIP_IS_E2(cp->chip_id)) {
+        if (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id)) {
                 ret = cnic_init_id_tbl(&cp->fcoe_cid_tbl,
                                         BNX2X_FCOE_NUM_CONNECTIONS,
                                         cp->fcoe_start_cid, 0);
@@ -4871,15 +4884,6 @@ static int cnic_start_bnx2x_hw(struct cnic_dev *dev)
                 CSTORM_ISCSI_EQ_SB_INDEX_OFFSET(pfid, 0),
                 HC_INDEX_ISCSI_EQ_CONS);
 
-        for (i = 0; i < cp->conn_buf_info.num_pages; i++) {
-                CNIC_WR(dev, BAR_TSTRORM_INTMEM +
-                        TSTORM_ISCSI_CONN_BUF_PBL_OFFSET(pfid, i),
-                        cp->conn_buf_info.pgtbl[2 * i]);
-                CNIC_WR(dev, BAR_TSTRORM_INTMEM +
-                        TSTORM_ISCSI_CONN_BUF_PBL_OFFSET(pfid, i) + 4,
-                        cp->conn_buf_info.pgtbl[(2 * i) + 1]);
-        }
-
         CNIC_WR(dev, BAR_USTRORM_INTMEM +
                 USTORM_ISCSI_GLOBAL_BUF_PHYS_ADDR_OFFSET(pfid),
                 cp->gbl_buf_info.pg_map_arr[0] & 0xffffffff);
@@ -4927,7 +4931,7 @@ static void cnic_init_rings(struct cnic_dev *dev)
                 cl_qzone_id = BNX2X_CL_QZONE_ID(cp, cli);
 
                 off = BAR_USTRORM_INTMEM +
-                        (BNX2X_CHIP_IS_E2(cp->chip_id) ?
+                        (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id) ?
                          USTORM_RX_PRODS_E2_OFFSET(cl_qzone_id) :
                          USTORM_RX_PRODS_E1X_OFFSET(CNIC_PORT(cp), cli));
 
@@ -5277,7 +5281,7 @@ static struct cnic_dev *init_bnx2x_cnic(struct net_device *dev)
 
         if (!(ethdev->drv_state & CNIC_DRV_STATE_NO_ISCSI))
                 cdev->max_iscsi_conn = ethdev->max_iscsi_conn;
-        if (BNX2X_CHIP_IS_E2(cp->chip_id) &&
+        if (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id) &&
             !(ethdev->drv_state & CNIC_DRV_STATE_NO_FCOE))
                 cdev->max_fcoe_conn = ethdev->max_fcoe_conn;
 
@@ -5293,7 +5297,7 @@ static struct cnic_dev *init_bnx2x_cnic(struct net_device *dev)
         cp->stop_cm = cnic_cm_stop_bnx2x_hw;
         cp->enable_int = cnic_enable_bnx2x_int;
         cp->disable_int_sync = cnic_disable_bnx2x_int_sync;
-        if (BNX2X_CHIP_IS_E2(cp->chip_id))
+        if (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id))
                 cp->ack_int = cnic_ack_bnx2x_e2_msix;
         else
                 cp->ack_int = cnic_ack_bnx2x_msix;
diff --git a/drivers/net/cnic.h b/drivers/net/cnic.h
index eb11821108a0..330ef9350413 100644
--- a/drivers/net/cnic.h
+++ b/drivers/net/cnic.h
@@ -1,6 +1,6 @@
 /* cnic.h: Broadcom CNIC core network driver.
  *
- * Copyright (c) 2006-2010 Broadcom Corporation
+ * Copyright (c) 2006-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
@@ -68,11 +68,6 @@
 #define BNX2_PG_CTX_MAP                 0x1a0034
 #define BNX2_ISCSI_CTX_MAP              0x1a0074
 
-struct cnic_redirect_entry {
-        struct dst_entry *old_dst;
-        struct dst_entry *new_dst;
-};
-
 #define MAX_COMPLETED_KCQE      64
 
 #define MAX_CNIC_L5_CONTEXT     256
@@ -171,6 +166,7 @@ struct cnic_context {
         unsigned long           ctx_flags;
 #define CTX_FL_OFFLD_START      0
 #define CTX_FL_DELETE_WAIT      1
+#define CTX_FL_CID_ERROR        2
         u8                      ulp_proto_id;
         union {
                 struct cnic_iscsi       *iscsi;
@@ -245,7 +241,7 @@ struct cnic_local {
         u16             rx_cons;
         u16             tx_cons;
 
-        struct iro              *iro_arr;
+        const struct iro        *iro_arr;
 #define IRO (((struct cnic_local *) dev->cnic_priv)->iro_arr)
 
         struct cnic_dma         kwq_info;
@@ -286,7 +282,6 @@ struct cnic_local {
         struct cnic_sock        *csk_tbl;
         struct cnic_id_tbl      csk_port_tbl;
 
-        struct cnic_dma         conn_buf_info;
         struct cnic_dma         gbl_buf_info;
 
         struct cnic_iscsi       *iscsi_tbl;
@@ -320,6 +315,11 @@ struct cnic_local {
         u32                     chip_id;
         int                     func;
         u32                     pfid;
+        u8                      port_mode;
+#define CHIP_4_PORT_MODE        0
+#define CHIP_2_PORT_MODE        1
+#define CHIP_PORT_MODE_NONE     2
+
         u32                     shmem_base;
 
         struct cnic_ops         *cnic_ops;
@@ -369,7 +369,6 @@ struct bnx2x_bd_chain_next {
 #define BNX2X_ISCSI_MAX_PENDING_R2TS    4
 #define BNX2X_ISCSI_R2TQE_SIZE          8
 #define BNX2X_ISCSI_HQ_BD_SIZE          64
-#define BNX2X_ISCSI_CONN_BUF_SIZE       64
 #define BNX2X_ISCSI_GLB_BUF_SIZE        64
 #define BNX2X_ISCSI_PBL_NOT_CACHED      0xff
 #define BNX2X_ISCSI_PDU_HEADER_NOT_CACHED       0xff
@@ -406,6 +405,7 @@ struct bnx2x_bd_chain_next {
 #define BNX2X_CHIP_IS_E2(x)             \
         (BNX2X_CHIP_IS_57712(x) || BNX2X_CHIP_IS_57712E(x) || \
          BNX2X_CHIP_IS_57713(x) || BNX2X_CHIP_IS_57713E(x))
+#define BNX2X_CHIP_IS_E2_PLUS(x) BNX2X_CHIP_IS_E2(x)
 
 #define IS_E1H_OFFSET                   BNX2X_CHIP_IS_E1H(cp->chip_id)
 
@@ -442,8 +442,8 @@ struct bnx2x_bd_chain_next {
 
 #define CNIC_PORT(cp)                   ((cp)->pfid & 1)
 #define CNIC_FUNC(cp)                   ((cp)->func)
-#define CNIC_PATH(cp)                   (!BNX2X_CHIP_IS_E2(cp->chip_id) ? 0 :\
-                                         (CNIC_FUNC(cp) & 1))
+#define CNIC_PATH(cp)                   (!BNX2X_CHIP_IS_E2_PLUS(cp->chip_id) ? \
+                                         0 : (CNIC_FUNC(cp) & 1))
 #define CNIC_E1HVN(cp)                  ((cp)->pfid >> 1)
 
 #define BNX2X_HW_CID(cp, x)             ((CNIC_PORT(cp) << 23) | \
@@ -452,10 +452,15 @@ struct bnx2x_bd_chain_next {
 #define BNX2X_SW_CID(x)                 (x & 0x1ffff)
 
 #define BNX2X_CL_QZONE_ID(cp, cli)                                      \
-                (cli + (CNIC_PORT(cp) * (BNX2X_CHIP_IS_E2(cp->chip_id) ?\
-                                        ETH_MAX_RX_CLIENTS_E2 :         \
-                                        ETH_MAX_RX_CLIENTS_E1H)))
+                (BNX2X_CHIP_IS_E2_PLUS(cp->chip_id) ? cli :             \
+                 cli + (CNIC_PORT(cp) * ETH_MAX_RX_CLIENTS_E1H))
+
+#ifndef MAX_STAT_COUNTER_ID
+#define MAX_STAT_COUNTER_ID                                             \
+        (BNX2X_CHIP_IS_E1H((cp)->chip_id) ? MAX_STAT_COUNTER_ID_E1H :   \
+         ((BNX2X_CHIP_IS_E2_PLUS((cp)->chip_id)) ? MAX_STAT_COUNTER_ID_E2 :\
+          MAX_STAT_COUNTER_ID_E1))
+#endif
 
-#define TCP_TSTORM_OOO_DROP_AND_PROC_ACK        (0<<4)
 #endif
 
diff --git a/drivers/net/cnic_defs.h b/drivers/net/cnic_defs.h
index fdbc00415603..e47d21076767 100644
--- a/drivers/net/cnic_defs.h
+++ b/drivers/net/cnic_defs.h
@@ -1,7 +1,7 @@
 
 /* cnic.c: Broadcom CNIC core network driver.
  *
- * Copyright (c) 2006-2010 Broadcom Corporation
+ * Copyright (c) 2006-2009 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
@@ -45,13 +45,13 @@
 #define FCOE_KCQE_OPCODE_CQ_EVENT_NOTIFICATION  (0x20)
 #define FCOE_KCQE_OPCODE_FCOE_ERROR                             (0x21)
 
-#define FCOE_RAMROD_CMD_ID_INIT                 (FCOE_KCQE_OPCODE_INIT_FUNC)
-#define FCOE_RAMROD_CMD_ID_DESTROY              (FCOE_KCQE_OPCODE_DESTROY_FUNC)
+#define FCOE_RAMROD_CMD_ID_INIT_FUNC            (FCOE_KCQE_OPCODE_INIT_FUNC)
+#define FCOE_RAMROD_CMD_ID_DESTROY_FUNC         (FCOE_KCQE_OPCODE_DESTROY_FUNC)
+#define FCOE_RAMROD_CMD_ID_STAT_FUNC            (FCOE_KCQE_OPCODE_STAT_FUNC)
 #define FCOE_RAMROD_CMD_ID_OFFLOAD_CONN         (FCOE_KCQE_OPCODE_OFFLOAD_CONN)
 #define FCOE_RAMROD_CMD_ID_ENABLE_CONN          (FCOE_KCQE_OPCODE_ENABLE_CONN)
 #define FCOE_RAMROD_CMD_ID_DISABLE_CONN         (FCOE_KCQE_OPCODE_DISABLE_CONN)
 #define FCOE_RAMROD_CMD_ID_DESTROY_CONN         (FCOE_KCQE_OPCODE_DESTROY_CONN)
-#define FCOE_RAMROD_CMD_ID_STAT                 (FCOE_KCQE_OPCODE_STAT_FUNC)
 #define FCOE_RAMROD_CMD_ID_TERMINATE_CONN       (0x81)
 
 #define FCOE_KWQE_OPCODE_INIT1                  (0)
@@ -641,20 +641,20 @@ struct cstorm_iscsi_ag_context {
 #define __CSTORM_ISCSI_AG_CONTEXT_RESERVED_ULP_RX_SE_CF_EN_SHIFT 12
 #define __CSTORM_ISCSI_AG_CONTEXT_RESERVED_ULP_RX_INV_CF_EN (0x1<<13)
 #define __CSTORM_ISCSI_AG_CONTEXT_RESERVED_ULP_RX_INV_CF_EN_SHIFT 13
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION3_CF (0x3<<14)
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION3_CF_SHIFT 14
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX4_CF (0x3<<14)
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX4_CF_SHIFT 14
 #define __CSTORM_ISCSI_AG_CONTEXT_RESERVED66 (0x3<<16)
 #define __CSTORM_ISCSI_AG_CONTEXT_RESERVED66_SHIFT 16
 #define __CSTORM_ISCSI_AG_CONTEXT_FIN_RECEIVED_CF_EN (0x1<<18)
 #define __CSTORM_ISCSI_AG_CONTEXT_FIN_RECEIVED_CF_EN_SHIFT 18
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION0_CF_EN (0x1<<19)
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION0_CF_EN_SHIFT 19
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION1_CF_EN (0x1<<20)
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION1_CF_EN_SHIFT 20
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION2_CF_EN (0x1<<21)
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION2_CF_EN_SHIFT 21
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION3_CF_EN (0x1<<22)
-#define __CSTORM_ISCSI_AG_CONTEXT_PENDING_COMPLETION3_CF_EN_SHIFT 22
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN (0x1<<19)
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN_SHIFT 19
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX2_CF_EN (0x1<<20)
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX2_CF_EN_SHIFT 20
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN (0x1<<21)
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN_SHIFT 21
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX4_CF_EN (0x1<<22)
+#define __CSTORM_ISCSI_AG_CONTEXT_AUX4_CF_EN_SHIFT 22
 #define __CSTORM_ISCSI_AG_CONTEXT_REL_SEQ_RULE (0x7<<23)
 #define __CSTORM_ISCSI_AG_CONTEXT_REL_SEQ_RULE_SHIFT 23
 #define CSTORM_ISCSI_AG_CONTEXT_HQ_PROD_RULE (0x3<<26)
@@ -694,573 +694,667 @@ struct cstorm_iscsi_ag_context {
 #endif
 #if defined(__BIG_ENDIAN)
         u16 __reserved64;
-        u16 __cq_u_prod0;
+        u16 cq_u_prod;
 #elif defined(__LITTLE_ENDIAN)
-        u16 __cq_u_prod0;
+        u16 cq_u_prod;
         u16 __reserved64;
 #endif
         u32 __cq_u_prod1;
 #if defined(__BIG_ENDIAN)
         u16 __agg_vars3;
-        u16 __cq_u_prod2;
+        u16 cq_u_pend;
 #elif defined(__LITTLE_ENDIAN)
-        u16 __cq_u_prod2;
+        u16 cq_u_pend;
         u16 __agg_vars3;
 #endif
 #if defined(__BIG_ENDIAN)
         u16 __aux2_th;
-        u16 __cq_u_prod3;
+        u16 aux2_val;
 #elif defined(__LITTLE_ENDIAN)
-        u16 __cq_u_prod3;
+        u16 aux2_val;
         u16 __aux2_th;
 #endif
 };
 
 /*
- * Parameters initialized during offloaded according to FLOGI/PLOGI/PRLI and used in FCoE context section
+ * The fcoe extra aggregative context section of Tstorm
  */
-struct ustorm_fcoe_params {
-#if defined(__BIG_ENDIAN)
-        u16 fcoe_conn_id;
-        u16 flags;
-#define USTORM_FCOE_PARAMS_B_MUL_N_PORT_IDS (0x1<<0)
-#define USTORM_FCOE_PARAMS_B_MUL_N_PORT_IDS_SHIFT 0
-#define USTORM_FCOE_PARAMS_B_E_D_TOV_RES (0x1<<1)
-#define USTORM_FCOE_PARAMS_B_E_D_TOV_RES_SHIFT 1
-#define USTORM_FCOE_PARAMS_B_CONT_INCR_SEQ_CNT (0x1<<2)
-#define USTORM_FCOE_PARAMS_B_CONT_INCR_SEQ_CNT_SHIFT 2
-#define USTORM_FCOE_PARAMS_B_CONF_REQ (0x1<<3)
-#define USTORM_FCOE_PARAMS_B_CONF_REQ_SHIFT 3
-#define USTORM_FCOE_PARAMS_B_REC_VALID (0x1<<4)
-#define USTORM_FCOE_PARAMS_B_REC_VALID_SHIFT 4
-#define USTORM_FCOE_PARAMS_B_CQ_TOGGLE_BIT (0x1<<5)
-#define USTORM_FCOE_PARAMS_B_CQ_TOGGLE_BIT_SHIFT 5
-#define USTORM_FCOE_PARAMS_B_XFRQ_TOGGLE_BIT (0x1<<6)
-#define USTORM_FCOE_PARAMS_B_XFRQ_TOGGLE_BIT_SHIFT 6
-#define USTORM_FCOE_PARAMS_B_C2_VALID (0x1<<7)
-#define USTORM_FCOE_PARAMS_B_C2_VALID_SHIFT 7
-#define USTORM_FCOE_PARAMS_B_ACK_0 (0x1<<8)
-#define USTORM_FCOE_PARAMS_B_ACK_0_SHIFT 8
-#define USTORM_FCOE_PARAMS_RSRV0 (0x7F<<9)
-#define USTORM_FCOE_PARAMS_RSRV0_SHIFT 9
-#elif defined(__LITTLE_ENDIAN)
-        u16 flags;
-#define USTORM_FCOE_PARAMS_B_MUL_N_PORT_IDS (0x1<<0)
-#define USTORM_FCOE_PARAMS_B_MUL_N_PORT_IDS_SHIFT 0
-#define USTORM_FCOE_PARAMS_B_E_D_TOV_RES (0x1<<1)
-#define USTORM_FCOE_PARAMS_B_E_D_TOV_RES_SHIFT 1
-#define USTORM_FCOE_PARAMS_B_CONT_INCR_SEQ_CNT (0x1<<2)
-#define USTORM_FCOE_PARAMS_B_CONT_INCR_SEQ_CNT_SHIFT 2
-#define USTORM_FCOE_PARAMS_B_CONF_REQ (0x1<<3)
-#define USTORM_FCOE_PARAMS_B_CONF_REQ_SHIFT 3
-#define USTORM_FCOE_PARAMS_B_REC_VALID (0x1<<4)
-#define USTORM_FCOE_PARAMS_B_REC_VALID_SHIFT 4
-#define USTORM_FCOE_PARAMS_B_CQ_TOGGLE_BIT (0x1<<5)
-#define USTORM_FCOE_PARAMS_B_CQ_TOGGLE_BIT_SHIFT 5
-#define USTORM_FCOE_PARAMS_B_XFRQ_TOGGLE_BIT (0x1<<6)
-#define USTORM_FCOE_PARAMS_B_XFRQ_TOGGLE_BIT_SHIFT 6
-#define USTORM_FCOE_PARAMS_B_C2_VALID (0x1<<7)
-#define USTORM_FCOE_PARAMS_B_C2_VALID_SHIFT 7
-#define USTORM_FCOE_PARAMS_B_ACK_0 (0x1<<8)
-#define USTORM_FCOE_PARAMS_B_ACK_0_SHIFT 8
-#define USTORM_FCOE_PARAMS_RSRV0 (0x7F<<9)
-#define USTORM_FCOE_PARAMS_RSRV0_SHIFT 9
-        u16 fcoe_conn_id;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 hc_csdm_byte_en;
-        u8 func_id;
-        u8 port_id;
-        u8 vnic_id;
-#elif defined(__LITTLE_ENDIAN)
-        u8 vnic_id;
-        u8 port_id;
-        u8 func_id;
-        u8 hc_csdm_byte_en;
-#endif
+struct tstorm_fcoe_extra_ag_context_section {
+        u32 __agg_val1;
 #if defined(__BIG_ENDIAN)
-        u16 rx_total_conc_seqs;
-        u16 rx_max_fc_pay_len;
+        u8 __tcp_agg_vars2;
+        u8 __agg_val3;
+        u16 __agg_val2;
 #elif defined(__LITTLE_ENDIAN)
-        u16 rx_max_fc_pay_len;
-        u16 rx_total_conc_seqs;
+        u16 __agg_val2;
+        u8 __agg_val3;
+        u8 __tcp_agg_vars2;
 #endif
 #if defined(__BIG_ENDIAN)
-        u16 ox_id;
-        u16 rx_max_conc_seqs;
+        u16 __agg_val5;
+        u8 __agg_val6;
+        u8 __tcp_agg_vars3;
 #elif defined(__LITTLE_ENDIAN)
-        u16 rx_max_conc_seqs;
-        u16 ox_id;
+        u8 __tcp_agg_vars3;
+        u8 __agg_val6;
+        u16 __agg_val5;
 #endif
+        u32 __lcq_prod;
+        u32 rtt_seq;
+        u32 rtt_time;
+        u32 __reserved66;
+        u32 wnd_right_edge;
+        u32 tcp_agg_vars1;
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_FIN_SENT_FLAG (0x1<<0)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_FIN_SENT_FLAG_SHIFT 0
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_LAST_PACKET_FIN_FLAG (0x1<<1)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_LAST_PACKET_FIN_FLAG_SHIFT 1
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_WND_UPD_CF (0x3<<2)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_WND_UPD_CF_SHIFT 2
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TIMEOUT_CF (0x3<<4)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TIMEOUT_CF_SHIFT 4
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_WND_UPD_CF_EN (0x1<<6)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_WND_UPD_CF_EN_SHIFT 6
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TIMEOUT_CF_EN (0x1<<7)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TIMEOUT_CF_EN_SHIFT 7
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_SEQ_EN (0x1<<8)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_SEQ_EN_SHIFT 8
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_LCQ_SND_EN (0x1<<9)
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_LCQ_SND_EN_SHIFT 9
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<10)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_FLAG_SHIFT 10
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_FLAG (0x1<<11)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_FLAG_SHIFT 11
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_CF_EN (0x1<<12)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_CF_EN_SHIFT 12
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_CF_EN (0x1<<13)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_CF_EN_SHIFT 13
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_CF (0x3<<14)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_CF_SHIFT 14
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_CF (0x3<<16)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_CF_SHIFT 16
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TX_BLOCKED (0x1<<18)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TX_BLOCKED_SHIFT 18
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX10_CF_EN (0x1<<19)
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX10_CF_EN_SHIFT 19
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX11_CF_EN (0x1<<20)
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX11_CF_EN_SHIFT 20
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX12_CF_EN (0x1<<21)
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX12_CF_EN_SHIFT 21
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED1 (0x3<<22)
+#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED1_SHIFT 22
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_PEND_SEQ (0xF<<24)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_PEND_SEQ_SHIFT 24
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_DONE_SEQ (0xF<<28)
+#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_DONE_SEQ_SHIFT 28
+        u32 snd_max;
+        u32 __lcq_cons;
+        u32 __reserved2;
 };
 
 /*
- * FCoE 16-bits index structure
- */
-struct fcoe_idx16_fields {
-        u16 fields;
-#define FCOE_IDX16_FIELDS_IDX (0x7FFF<<0)
-#define FCOE_IDX16_FIELDS_IDX_SHIFT 0
-#define FCOE_IDX16_FIELDS_MSB (0x1<<15)
-#define FCOE_IDX16_FIELDS_MSB_SHIFT 15
-};
-
-/*
- * FCoE 16-bits index union
- */
-union fcoe_idx16_field_union {
-        struct fcoe_idx16_fields fields;
-        u16 val;
-};
-
-/*
- * 4 regs size
+ * The fcoe aggregative context of Tstorm
  */
-struct fcoe_bd_ctx {
-        u32 buf_addr_hi;
-        u32 buf_addr_lo;
+struct tstorm_fcoe_ag_context {
 #if defined(__BIG_ENDIAN)
-        u16 rsrv0;
-        u16 buf_len;
+        u16 ulp_credit;
+        u8 agg_vars1;
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF (0x3<<4)
+#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_SHIFT 4
+#define __TSTORM_FCOE_AG_CONTEXT_AUX3_FLAG (0x1<<6)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX3_FLAG_SHIFT 6
+#define __TSTORM_FCOE_AG_CONTEXT_AUX4_FLAG (0x1<<7)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX4_FLAG_SHIFT 7
+        u8 state;
 #elif defined(__LITTLE_ENDIAN)
-        u16 buf_len;
-        u16 rsrv0;
+        u8 state;
+        u8 agg_vars1;
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF (0x3<<4)
+#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_SHIFT 4
+#define __TSTORM_FCOE_AG_CONTEXT_AUX3_FLAG (0x1<<6)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX3_FLAG_SHIFT 6
+#define __TSTORM_FCOE_AG_CONTEXT_AUX4_FLAG (0x1<<7)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX4_FLAG_SHIFT 7
+        u16 ulp_credit;
 #endif
 #if defined(__BIG_ENDIAN)
-        u16 rsrv1;
-        u16 flags;
+        u16 __agg_val4;
+        u16 agg_vars2;
+#define __TSTORM_FCOE_AG_CONTEXT_AUX5_FLAG (0x1<<0)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX5_FLAG_SHIFT 0
+#define __TSTORM_FCOE_AG_CONTEXT_AUX6_FLAG (0x1<<1)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX6_FLAG_SHIFT 1
+#define __TSTORM_FCOE_AG_CONTEXT_AUX4_CF (0x3<<2)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX4_CF_SHIFT 2
+#define __TSTORM_FCOE_AG_CONTEXT_AUX5_CF (0x3<<4)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX5_CF_SHIFT 4
+#define __TSTORM_FCOE_AG_CONTEXT_AUX6_CF (0x3<<6)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX6_CF_SHIFT 6
+#define __TSTORM_FCOE_AG_CONTEXT_AUX7_CF (0x3<<8)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX7_CF_SHIFT 8
+#define __TSTORM_FCOE_AG_CONTEXT_AUX7_FLAG (0x1<<10)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX7_FLAG_SHIFT 10
+#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_EN (0x1<<11)
+#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_EN_SHIFT 11
+#define TSTORM_FCOE_AG_CONTEXT_AUX4_CF_EN (0x1<<12)
+#define TSTORM_FCOE_AG_CONTEXT_AUX4_CF_EN_SHIFT 12
+#define TSTORM_FCOE_AG_CONTEXT_AUX5_CF_EN (0x1<<13)
+#define TSTORM_FCOE_AG_CONTEXT_AUX5_CF_EN_SHIFT 13
+#define TSTORM_FCOE_AG_CONTEXT_AUX6_CF_EN (0x1<<14)
+#define TSTORM_FCOE_AG_CONTEXT_AUX6_CF_EN_SHIFT 14
+#define TSTORM_FCOE_AG_CONTEXT_AUX7_CF_EN (0x1<<15)
+#define TSTORM_FCOE_AG_CONTEXT_AUX7_CF_EN_SHIFT 15
 #elif defined(__LITTLE_ENDIAN)
-        u16 flags;
-        u16 rsrv1;
+        u16 agg_vars2;
+#define __TSTORM_FCOE_AG_CONTEXT_AUX5_FLAG (0x1<<0)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX5_FLAG_SHIFT 0
+#define __TSTORM_FCOE_AG_CONTEXT_AUX6_FLAG (0x1<<1)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX6_FLAG_SHIFT 1
+#define __TSTORM_FCOE_AG_CONTEXT_AUX4_CF (0x3<<2)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX4_CF_SHIFT 2
+#define __TSTORM_FCOE_AG_CONTEXT_AUX5_CF (0x3<<4)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX5_CF_SHIFT 4
+#define __TSTORM_FCOE_AG_CONTEXT_AUX6_CF (0x3<<6)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX6_CF_SHIFT 6
+#define __TSTORM_FCOE_AG_CONTEXT_AUX7_CF (0x3<<8)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX7_CF_SHIFT 8
+#define __TSTORM_FCOE_AG_CONTEXT_AUX7_FLAG (0x1<<10)
+#define __TSTORM_FCOE_AG_CONTEXT_AUX7_FLAG_SHIFT 10
+#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_EN (0x1<<11)
+#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_EN_SHIFT 11
+#define TSTORM_FCOE_AG_CONTEXT_AUX4_CF_EN (0x1<<12)
+#define TSTORM_FCOE_AG_CONTEXT_AUX4_CF_EN_SHIFT 12
+#define TSTORM_FCOE_AG_CONTEXT_AUX5_CF_EN (0x1<<13)
+#define TSTORM_FCOE_AG_CONTEXT_AUX5_CF_EN_SHIFT 13
+#define TSTORM_FCOE_AG_CONTEXT_AUX6_CF_EN (0x1<<14)
+#define TSTORM_FCOE_AG_CONTEXT_AUX6_CF_EN_SHIFT 14
+#define TSTORM_FCOE_AG_CONTEXT_AUX7_CF_EN (0x1<<15)
+#define TSTORM_FCOE_AG_CONTEXT_AUX7_CF_EN_SHIFT 15
+        u16 __agg_val4;
 #endif
+        struct tstorm_fcoe_extra_ag_context_section __extra_section;
 };
 
+
+
 /*
- * Parameters required for placement according to SGL
+ * The tcp aggregative context section of Tstorm
  */
-struct ustorm_fcoe_data_place {
+struct tstorm_tcp_tcp_ag_context_section {
+        u32 __agg_val1;
 #if defined(__BIG_ENDIAN)
-        u16 cached_sge_off;
-        u8 cached_num_sges;
-        u8 cached_sge_idx;
+        u8 __tcp_agg_vars2;
+        u8 __agg_val3;
+        u16 __agg_val2;
 #elif defined(__LITTLE_ENDIAN)
-        u8 cached_sge_idx;
-        u8 cached_num_sges;
-        u16 cached_sge_off;
+        u16 __agg_val2;
+        u8 __agg_val3;
+        u8 __tcp_agg_vars2;
 #endif
-        struct fcoe_bd_ctx cached_sge[3];
-};
-
-struct fcoe_task_ctx_entry_txwr_rxrd {
 #if defined(__BIG_ENDIAN)
-        u16 verify_tx_seq;
-        u8 init_flags;
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE (0x7<<0)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE (0x1<<3)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE_SHIFT 3
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE (0x1<<4)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE_SHIFT 4
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_SINGLE_SGE (0x1<<5)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_SINGLE_SGE_SHIFT 5
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV5 (0x3<<6)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV5_SHIFT 6
-        u8 tx_flags;
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE (0xF<<0)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV4 (0xF<<4)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV4_SHIFT 4
+        u16 __agg_val5;
+        u8 __agg_val6;
+        u8 __tcp_agg_vars3;
 #elif defined(__LITTLE_ENDIAN)
-        u8 tx_flags;
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE (0xF<<0)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV4 (0xF<<4)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV4_SHIFT 4
-        u8 init_flags;
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE (0x7<<0)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE (0x1<<3)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE_SHIFT 3
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE (0x1<<4)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE_SHIFT 4
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_SINGLE_SGE (0x1<<5)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_SINGLE_SGE_SHIFT 5
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV5 (0x3<<6)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV5_SHIFT 6
-        u16 verify_tx_seq;
+        u8 __tcp_agg_vars3;
+        u8 __agg_val6;
+        u16 __agg_val5;
 #endif
+        u32 snd_nxt;
+        u32 rtt_seq;
+        u32 rtt_time;
+        u32 __reserved66;
+        u32 wnd_right_edge;
+        u32 tcp_agg_vars1;
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_FIN_SENT_FLAG (0x1<<0)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_FIN_SENT_FLAG_SHIFT 0
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_LAST_PACKET_FIN_FLAG (0x1<<1)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_LAST_PACKET_FIN_FLAG_SHIFT 1
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_WND_UPD_CF (0x3<<2)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_WND_UPD_CF_SHIFT 2
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TIMEOUT_CF (0x3<<4)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TIMEOUT_CF_SHIFT 4
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_WND_UPD_CF_EN (0x1<<6)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_WND_UPD_CF_EN_SHIFT 6
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TIMEOUT_CF_EN (0x1<<7)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TIMEOUT_CF_EN_SHIFT 7
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_SEQ_EN (0x1<<8)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_SEQ_EN_SHIFT 8
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_SND_NXT_EN (0x1<<9)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_SND_NXT_EN_SHIFT 9
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<10)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG_SHIFT 10
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_FLAG (0x1<<11)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_FLAG_SHIFT 11
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_CF_EN (0x1<<12)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_CF_EN_SHIFT 12
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_CF_EN (0x1<<13)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_CF_EN_SHIFT 13
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_CF (0x3<<14)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_CF_SHIFT 14
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_CF (0x3<<16)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_CF_SHIFT 16
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_BLOCKED (0x1<<18)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_BLOCKED_SHIFT 18
+#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_EN (0x1<<19)
+#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_EN_SHIFT 19
+#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX11_CF_EN (0x1<<20)
+#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX11_CF_EN_SHIFT 20
+#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX12_CF_EN (0x1<<21)
+#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX12_CF_EN_SHIFT 21
+#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RESERVED1 (0x3<<22)
+#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RESERVED1_SHIFT 22
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_PEND_SEQ (0xF<<24)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_PEND_SEQ_SHIFT 24
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_DONE_SEQ (0xF<<28)
+#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_DONE_SEQ_SHIFT 28
+        u32 snd_max;
+        u32 snd_una;
+        u32 __reserved2;
 };
 
-struct fcoe_fcp_cmd_payload {
-        u32 opaque[8];
-};
-
-struct fcoe_fc_hdr {
-#if defined(__BIG_ENDIAN)
-        u8 cs_ctl;
-        u8 s_id[3];
-#elif defined(__LITTLE_ENDIAN)
-        u8 s_id[3];
-        u8 cs_ctl;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 r_ctl;
-        u8 d_id[3];
-#elif defined(__LITTLE_ENDIAN)
-        u8 d_id[3];
-        u8 r_ctl;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 seq_id;
-        u8 df_ctl;
-        u16 seq_cnt;
-#elif defined(__LITTLE_ENDIAN)
-        u16 seq_cnt;
-        u8 df_ctl;
-        u8 seq_id;
-#endif
+/*
+ * The iscsi aggregative context of Tstorm
+ */
+struct tstorm_iscsi_ag_context {
 #if defined(__BIG_ENDIAN)
-        u8 type;
-        u8 f_ctl[3];
+        u16 ulp_credit;
+        u8 agg_vars1;
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF (0x3<<4)
+#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_SHIFT 4
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX3_FLAG (0x1<<6)
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX3_FLAG_SHIFT 6
+#define __TSTORM_ISCSI_AG_CONTEXT_ACK_ON_FIN_SENT_FLAG (0x1<<7)
+#define __TSTORM_ISCSI_AG_CONTEXT_ACK_ON_FIN_SENT_FLAG_SHIFT 7
+        u8 state;
 #elif defined(__LITTLE_ENDIAN)
-        u8 f_ctl[3];
-        u8 type;
+        u8 state;
+        u8 agg_vars1;
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF (0x3<<4)
+#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_SHIFT 4
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX3_FLAG (0x1<<6)
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX3_FLAG_SHIFT 6
+#define __TSTORM_ISCSI_AG_CONTEXT_ACK_ON_FIN_SENT_FLAG (0x1<<7)
+#define __TSTORM_ISCSI_AG_CONTEXT_ACK_ON_FIN_SENT_FLAG_SHIFT 7
+        u16 ulp_credit;
 #endif
-        u32 parameters;
 #if defined(__BIG_ENDIAN)
-        u16 ox_id;
-        u16 rx_id;
+        u16 __agg_val4;
+        u16 agg_vars2;
+#define __TSTORM_ISCSI_AG_CONTEXT_MSL_TIMER_SET_FLAG (0x1<<0)
+#define __TSTORM_ISCSI_AG_CONTEXT_MSL_TIMER_SET_FLAG_SHIFT 0
+#define __TSTORM_ISCSI_AG_CONTEXT_FIN_SENT_FIRST_FLAG (0x1<<1)
+#define __TSTORM_ISCSI_AG_CONTEXT_FIN_SENT_FIRST_FLAG_SHIFT 1
+#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF (0x3<<2)
+#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_SHIFT 2
+#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF (0x3<<4)
+#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_SHIFT 4
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX6_CF (0x3<<6)
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_SHIFT 6
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_CF (0x3<<8)
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_SHIFT 8
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_FLAG (0x1<<10)
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_FLAG_SHIFT 10
+#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN (0x1<<11)
+#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN_SHIFT 11
+#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_EN (0x1<<12)
+#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_EN_SHIFT 12
+#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_EN (0x1<<13)
+#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_EN_SHIFT 13
+#define TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_EN (0x1<<14)
+#define TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_EN_SHIFT 14
+#define TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_EN (0x1<<15)
+#define TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_EN_SHIFT 15
 #elif defined(__LITTLE_ENDIAN)
-        u16 rx_id;
-        u16 ox_id;
+        u16 agg_vars2;
+#define __TSTORM_ISCSI_AG_CONTEXT_MSL_TIMER_SET_FLAG (0x1<<0)
+#define __TSTORM_ISCSI_AG_CONTEXT_MSL_TIMER_SET_FLAG_SHIFT 0
+#define __TSTORM_ISCSI_AG_CONTEXT_FIN_SENT_FIRST_FLAG (0x1<<1)
+#define __TSTORM_ISCSI_AG_CONTEXT_FIN_SENT_FIRST_FLAG_SHIFT 1
+#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF (0x3<<2)
+#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_SHIFT 2
+#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF (0x3<<4)
+#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_SHIFT 4
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX6_CF (0x3<<6)
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_SHIFT 6
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_CF (0x3<<8)
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_SHIFT 8
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_FLAG (0x1<<10)
+#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_FLAG_SHIFT 10
+#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN (0x1<<11)
+#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN_SHIFT 11
+#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_EN (0x1<<12)
+#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_EN_SHIFT 12
+#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_EN (0x1<<13)
+#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_EN_SHIFT 13
+#define TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_EN (0x1<<14)
+#define TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_EN_SHIFT 14
+#define TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_EN (0x1<<15)
+#define TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_EN_SHIFT 15
+        u16 __agg_val4;
 #endif
+        struct tstorm_tcp_tcp_ag_context_section tcp;
 };
 
-struct fcoe_fc_frame {
-        struct fcoe_fc_hdr fc_hdr;
-        u32 reserved0[2];
-};
-
-union fcoe_cmd_flow_info {
-        struct fcoe_fcp_cmd_payload fcp_cmd_payload;
-        struct fcoe_fc_frame mp_fc_frame;
-};
-
-struct fcoe_read_flow_info {
-        struct fcoe_fc_hdr fc_data_in_hdr;
-        u32 reserved[2];
-};
-
-struct fcoe_fcp_xfr_rdy_payload {
-        u32 burst_len;
-        u32 data_ro;
-};
-
-struct fcoe_write_flow_info {
-        struct fcoe_fc_hdr fc_data_out_hdr;
-        struct fcoe_fcp_xfr_rdy_payload fcp_xfr_payload;
-};
-
-struct fcoe_fcp_rsp_flags {
-        u8 flags;
-#define FCOE_FCP_RSP_FLAGS_FCP_RSP_LEN_VALID (0x1<<0)
-#define FCOE_FCP_RSP_FLAGS_FCP_RSP_LEN_VALID_SHIFT 0
-#define FCOE_FCP_RSP_FLAGS_FCP_SNS_LEN_VALID (0x1<<1)
-#define FCOE_FCP_RSP_FLAGS_FCP_SNS_LEN_VALID_SHIFT 1
-#define FCOE_FCP_RSP_FLAGS_FCP_RESID_OVER (0x1<<2)
-#define FCOE_FCP_RSP_FLAGS_FCP_RESID_OVER_SHIFT 2
-#define FCOE_FCP_RSP_FLAGS_FCP_RESID_UNDER (0x1<<3)
-#define FCOE_FCP_RSP_FLAGS_FCP_RESID_UNDER_SHIFT 3
-#define FCOE_FCP_RSP_FLAGS_FCP_CONF_REQ (0x1<<4)
-#define FCOE_FCP_RSP_FLAGS_FCP_CONF_REQ_SHIFT 4
-#define FCOE_FCP_RSP_FLAGS_FCP_BIDI_FLAGS (0x7<<5)
-#define FCOE_FCP_RSP_FLAGS_FCP_BIDI_FLAGS_SHIFT 5
-};
-
-struct fcoe_fcp_rsp_payload {
-        struct regpair reserved0;
-        u32 fcp_resid;
-#if defined(__BIG_ENDIAN)
-        u16 retry_delay_timer;
-        struct fcoe_fcp_rsp_flags fcp_flags;
-        u8 scsi_status_code;
-#elif defined(__LITTLE_ENDIAN)
-        u8 scsi_status_code;
-        struct fcoe_fcp_rsp_flags fcp_flags;
-        u16 retry_delay_timer;
-#endif
-        u32 fcp_rsp_len;
-        u32 fcp_sns_len;
-};
 
-/*
- * Fixed size structure in order to plant it in Union structure
- */
-struct fcoe_fcp_rsp_union {
-        struct fcoe_fcp_rsp_payload payload;
-        struct regpair reserved0;
-};
 
 /*
- * Fixed size structure in order to plant it in Union structure
+ * The fcoe aggregative context of Ustorm
  */
-struct fcoe_abts_rsp_union {
-        u32 r_ctl;
-        u32 abts_rsp_payload[7];
-};
-
-union fcoe_rsp_flow_info {
-        struct fcoe_fcp_rsp_union fcp_rsp;
-        struct fcoe_abts_rsp_union abts_rsp;
-};
-
-struct fcoe_cleanup_flow_info {
+struct ustorm_fcoe_ag_context {
 #if defined(__BIG_ENDIAN)
-        u16 reserved1;
-        u16 task_id;
+        u8 __aux_counter_flags;
+        u8 agg_vars2;
+#define USTORM_FCOE_AG_CONTEXT_TX_CF (0x3<<0)
+#define USTORM_FCOE_AG_CONTEXT_TX_CF_SHIFT 0
+#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF (0x3<<2)
+#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_SHIFT 2
+#define USTORM_FCOE_AG_CONTEXT_AGG_MISC4_RULE (0x7<<4)
+#define USTORM_FCOE_AG_CONTEXT_AGG_MISC4_RULE_SHIFT 4
+#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL2_MASK (0x1<<7)
+#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL2_MASK_SHIFT 7
+        u8 agg_vars1;
+#define __USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define __USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define USTORM_FCOE_AG_CONTEXT_INV_CF (0x3<<4)
+#define USTORM_FCOE_AG_CONTEXT_INV_CF_SHIFT 4
+#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF (0x3<<6)
+#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_SHIFT 6
+        u8 state;
 #elif defined(__LITTLE_ENDIAN)
-        u16 task_id;
-        u16 reserved1;
+        u8 state;
+        u8 agg_vars1;
+#define __USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define __USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define USTORM_FCOE_AG_CONTEXT_INV_CF (0x3<<4)
+#define USTORM_FCOE_AG_CONTEXT_INV_CF_SHIFT 4
+#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF (0x3<<6)
+#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_SHIFT 6
+        u8 agg_vars2;
+#define USTORM_FCOE_AG_CONTEXT_TX_CF (0x3<<0)
+#define USTORM_FCOE_AG_CONTEXT_TX_CF_SHIFT 0
+#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF (0x3<<2)
+#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_SHIFT 2
+#define USTORM_FCOE_AG_CONTEXT_AGG_MISC4_RULE (0x7<<4)
+#define USTORM_FCOE_AG_CONTEXT_AGG_MISC4_RULE_SHIFT 4
+#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL2_MASK (0x1<<7)
+#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL2_MASK_SHIFT 7
+        u8 __aux_counter_flags;
 #endif
-        u32 reserved2[7];
-};
-
-/*
- * 32 bytes used for general purposes
- */
-union fcoe_general_task_ctx {
-        union fcoe_cmd_flow_info cmd_info;
-        struct fcoe_read_flow_info read_info;
-        struct fcoe_write_flow_info write_info;
-        union fcoe_rsp_flow_info rsp_info;
-        struct fcoe_cleanup_flow_info cleanup_info;
-        u32 comp_info[8];
-};
-
-struct fcoe_s_stat_ctx {
-        u8 flags;
-#define FCOE_S_STAT_CTX_ACTIVE (0x1<<0)
-#define FCOE_S_STAT_CTX_ACTIVE_SHIFT 0
-#define FCOE_S_STAT_CTX_ACK_ABORT_SEQ_COND (0x1<<1)
-#define FCOE_S_STAT_CTX_ACK_ABORT_SEQ_COND_SHIFT 1
-#define FCOE_S_STAT_CTX_ABTS_PERFORMED (0x1<<2)
-#define FCOE_S_STAT_CTX_ABTS_PERFORMED_SHIFT 2
-#define FCOE_S_STAT_CTX_SEQ_TIMEOUT (0x1<<3)
-#define FCOE_S_STAT_CTX_SEQ_TIMEOUT_SHIFT 3
-#define FCOE_S_STAT_CTX_P_RJT (0x1<<4)
-#define FCOE_S_STAT_CTX_P_RJT_SHIFT 4
-#define FCOE_S_STAT_CTX_ACK_EOFT (0x1<<5)
-#define FCOE_S_STAT_CTX_ACK_EOFT_SHIFT 5
-#define FCOE_S_STAT_CTX_RSRV1 (0x3<<6)
-#define FCOE_S_STAT_CTX_RSRV1_SHIFT 6
-};
-
-/*
- * Common section. Both TX and RX processing might write and read from it in different flows
- */
-struct fcoe_task_ctx_entry_tx_rx_cmn {
-        u32 data_2_trns;
-        union fcoe_general_task_ctx general;
-#if defined(__BIG_ENDIAN)
-        u16 tx_low_seq_cnt;
-        struct fcoe_s_stat_ctx tx_s_stat;
-        u8 tx_seq_id;
-#elif defined(__LITTLE_ENDIAN)
-        u8 tx_seq_id;
-        struct fcoe_s_stat_ctx tx_s_stat;
-        u16 tx_low_seq_cnt;
-#endif
-        u32 common_flags;
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_CID (0xFFFFFF<<0)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_CID_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_VALID (0x1<<24)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_VALID_SHIFT 24
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_SEQ_INIT (0x1<<25)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_SEQ_INIT_SHIFT 25
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_PEND_XFER (0x1<<26)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_PEND_XFER_SHIFT 26
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_PEND_CONF (0x1<<27)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_PEND_CONF_SHIFT 27
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_EXP_FIRST_FRAME (0x1<<28)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_EXP_FIRST_FRAME_SHIFT 28
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_RSRV (0x7<<29)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_RSRV_SHIFT 29
-};
-
-struct fcoe_task_ctx_entry_rxwr_txrd {
-#if defined(__BIG_ENDIAN)
-        u16 rx_id;
-        u16 rx_flags;
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE (0xF<<0)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE (0x7<<4)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE_SHIFT 4
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_CONF_REQ (0x1<<7)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_CONF_REQ_SHIFT 7
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_MISS_FRAME (0x1<<8)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_MISS_FRAME_SHIFT 8
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RESERVED0 (0x7F<<9)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RESERVED0_SHIFT 9
-#elif defined(__LITTLE_ENDIAN)
-        u16 rx_flags;
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE (0xF<<0)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE (0x7<<4)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE_SHIFT 4
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_CONF_REQ (0x1<<7)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_CONF_REQ_SHIFT 7
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_MISS_FRAME (0x1<<8)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_MISS_FRAME_SHIFT 8
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RESERVED0 (0x7F<<9)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RESERVED0_SHIFT 9
-        u16 rx_id;
-#endif
-};
-
-struct fcoe_seq_ctx {
-#if defined(__BIG_ENDIAN)
-        u16 low_seq_cnt;
-        struct fcoe_s_stat_ctx s_stat;
-        u8 seq_id;
+#if defined(__BIG_ENDIAN)
+        u8 cdu_usage;
+        u8 agg_misc2;
+        u16 pbf_tx_seq_ack;
 #elif defined(__LITTLE_ENDIAN)
-        u8 seq_id;
-        struct fcoe_s_stat_ctx s_stat;
-        u16 low_seq_cnt;
+        u16 pbf_tx_seq_ack;
+        u8 agg_misc2;
+        u8 cdu_usage;
 #endif
+        u32 agg_misc4;
 #if defined(__BIG_ENDIAN)
-        u16 err_seq_cnt;
-        u16 high_seq_cnt;
+        u8 agg_val3_th;
+        u8 agg_val3;
+        u16 agg_misc3;
 #elif defined(__LITTLE_ENDIAN)
-        u16 high_seq_cnt;
-        u16 err_seq_cnt;
+        u16 agg_misc3;
+        u8 agg_val3;
+        u8 agg_val3_th;
 #endif
-        u32 low_exp_ro;
-        u32 high_exp_ro;
-};
-
-struct fcoe_single_sge_ctx {
-        struct regpair cur_buf_addr;
+        u32 expired_task_id;
+        u32 agg_misc4_th;
 #if defined(__BIG_ENDIAN)
-        u16 reserved0;
-        u16 cur_buf_rem;
+        u16 cq_prod;
+        u16 cq_cons;
 #elif defined(__LITTLE_ENDIAN)
-        u16 cur_buf_rem;
-        u16 reserved0;
+        u16 cq_cons;
+        u16 cq_prod;
 #endif
-};
-
-struct fcoe_mul_sges_ctx {
-        struct regpair cur_sge_addr;
 #if defined(__BIG_ENDIAN)
-        u8 sgl_size;
-        u8 cur_sge_idx;
-        u16 cur_sge_off;
+        u16 __reserved2;
+        u8 decision_rules;
+#define USTORM_FCOE_AG_CONTEXT_CQ_DEC_RULE (0x7<<0)
+#define USTORM_FCOE_AG_CONTEXT_CQ_DEC_RULE_SHIFT 0
+#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL3_RULE (0x7<<3)
+#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL3_RULE_SHIFT 3
+#define USTORM_FCOE_AG_CONTEXT_CQ_ARM_N_FLAG (0x1<<6)
+#define USTORM_FCOE_AG_CONTEXT_CQ_ARM_N_FLAG_SHIFT 6
+#define __USTORM_FCOE_AG_CONTEXT_RESERVED1 (0x1<<7)
+#define __USTORM_FCOE_AG_CONTEXT_RESERVED1_SHIFT 7
+        u8 decision_rule_enable_bits;
+#define __USTORM_FCOE_AG_CONTEXT_RESERVED_INV_CF_EN (0x1<<0)
+#define __USTORM_FCOE_AG_CONTEXT_RESERVED_INV_CF_EN_SHIFT 0
+#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_EN (0x1<<1)
+#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_EN_SHIFT 1
+#define USTORM_FCOE_AG_CONTEXT_TX_CF_EN (0x1<<2)
+#define USTORM_FCOE_AG_CONTEXT_TX_CF_EN_SHIFT 2
+#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_EN (0x1<<3)
+#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_EN_SHIFT 3
+#define __USTORM_FCOE_AG_CONTEXT_AUX1_CF_EN (0x1<<4)
+#define __USTORM_FCOE_AG_CONTEXT_AUX1_CF_EN_SHIFT 4
+#define __USTORM_FCOE_AG_CONTEXT_QUEUE0_CF_EN (0x1<<5)
+#define __USTORM_FCOE_AG_CONTEXT_QUEUE0_CF_EN_SHIFT 5
+#define __USTORM_FCOE_AG_CONTEXT_AUX3_CF_EN (0x1<<6)
+#define __USTORM_FCOE_AG_CONTEXT_AUX3_CF_EN_SHIFT 6
+#define __USTORM_FCOE_AG_CONTEXT_DQ_CF_EN (0x1<<7)
+#define __USTORM_FCOE_AG_CONTEXT_DQ_CF_EN_SHIFT 7
 #elif defined(__LITTLE_ENDIAN)
-        u16 cur_sge_off;
-        u8 cur_sge_idx;
-        u8 sgl_size;
+        u8 decision_rule_enable_bits;
+#define __USTORM_FCOE_AG_CONTEXT_RESERVED_INV_CF_EN (0x1<<0)
+#define __USTORM_FCOE_AG_CONTEXT_RESERVED_INV_CF_EN_SHIFT 0
+#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_EN (0x1<<1)
+#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_EN_SHIFT 1
+#define USTORM_FCOE_AG_CONTEXT_TX_CF_EN (0x1<<2)
+#define USTORM_FCOE_AG_CONTEXT_TX_CF_EN_SHIFT 2
+#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_EN (0x1<<3)
+#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_EN_SHIFT 3
+#define __USTORM_FCOE_AG_CONTEXT_AUX1_CF_EN (0x1<<4)
+#define __USTORM_FCOE_AG_CONTEXT_AUX1_CF_EN_SHIFT 4
+#define __USTORM_FCOE_AG_CONTEXT_QUEUE0_CF_EN (0x1<<5)
+#define __USTORM_FCOE_AG_CONTEXT_QUEUE0_CF_EN_SHIFT 5
+#define __USTORM_FCOE_AG_CONTEXT_AUX3_CF_EN (0x1<<6)
+#define __USTORM_FCOE_AG_CONTEXT_AUX3_CF_EN_SHIFT 6
+#define __USTORM_FCOE_AG_CONTEXT_DQ_CF_EN (0x1<<7)
+#define __USTORM_FCOE_AG_CONTEXT_DQ_CF_EN_SHIFT 7
+        u8 decision_rules;
+#define USTORM_FCOE_AG_CONTEXT_CQ_DEC_RULE (0x7<<0)
+#define USTORM_FCOE_AG_CONTEXT_CQ_DEC_RULE_SHIFT 0
+#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL3_RULE (0x7<<3)
+#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL3_RULE_SHIFT 3
+#define USTORM_FCOE_AG_CONTEXT_CQ_ARM_N_FLAG (0x1<<6)
+#define USTORM_FCOE_AG_CONTEXT_CQ_ARM_N_FLAG_SHIFT 6
+#define __USTORM_FCOE_AG_CONTEXT_RESERVED1 (0x1<<7)
+#define __USTORM_FCOE_AG_CONTEXT_RESERVED1_SHIFT 7
+        u16 __reserved2;
 #endif
 };
 
-union fcoe_sgl_ctx {
-        struct fcoe_single_sge_ctx single_sge;
-        struct fcoe_mul_sges_ctx mul_sges;
-};
-
-struct fcoe_task_ctx_entry_rx_only {
-        struct fcoe_seq_ctx seq_ctx;
-        struct fcoe_seq_ctx ooo_seq_ctx;
-        u32 rsrv3;
-        union fcoe_sgl_ctx sgl_ctx;
-};
-
-struct ustorm_fcoe_task_ctx_entry_rd {
-        struct fcoe_task_ctx_entry_txwr_rxrd tx_wr_rx_rd;
-        struct fcoe_task_ctx_entry_tx_rx_cmn cmn;
-        struct fcoe_task_ctx_entry_rxwr_txrd rx_wr_tx_rd;
-        struct fcoe_task_ctx_entry_rx_only rx_wr;
-        u32 reserved;
-};
 
 /*
- * Ustorm FCoE Storm Context
+ * The iscsi aggregative context of Ustorm
  */
-struct ustorm_fcoe_st_context {
-        struct ustorm_fcoe_params fcoe_params;
-        struct regpair task_addr;
-        struct regpair cq_base_addr;
-        struct regpair rq_pbl_base;
-        struct regpair rq_cur_page_addr;
-        struct regpair confq_pbl_base_addr;
-        struct regpair conn_db_base;
-        struct regpair xfrq_base_addr;
-        struct regpair lcq_base_addr;
+struct ustorm_iscsi_ag_context {
 #if defined(__BIG_ENDIAN)
-        union fcoe_idx16_field_union rq_cons;
-        union fcoe_idx16_field_union rq_prod;
+        u8 __aux_counter_flags;
+        u8 agg_vars2;
+#define USTORM_ISCSI_AG_CONTEXT_TX_CF (0x3<<0)
+#define USTORM_ISCSI_AG_CONTEXT_TX_CF_SHIFT 0
+#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF (0x3<<2)
+#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_SHIFT 2
+#define USTORM_ISCSI_AG_CONTEXT_AGG_MISC4_RULE (0x7<<4)
+#define USTORM_ISCSI_AG_CONTEXT_AGG_MISC4_RULE_SHIFT 4
+#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_MASK (0x1<<7)
+#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_MASK_SHIFT 7
+        u8 agg_vars1;
+#define __USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define __USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define USTORM_ISCSI_AG_CONTEXT_INV_CF (0x3<<4)
+#define USTORM_ISCSI_AG_CONTEXT_INV_CF_SHIFT 4
+#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF (0x3<<6)
+#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_SHIFT 6
+        u8 state;
 #elif defined(__LITTLE_ENDIAN)
-        union fcoe_idx16_field_union rq_prod;
-        union fcoe_idx16_field_union rq_cons;
+        u8 state;
+        u8 agg_vars1;
+#define __USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define __USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define USTORM_ISCSI_AG_CONTEXT_INV_CF (0x3<<4)
+#define USTORM_ISCSI_AG_CONTEXT_INV_CF_SHIFT 4
+#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF (0x3<<6)
+#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_SHIFT 6
+        u8 agg_vars2;
+#define USTORM_ISCSI_AG_CONTEXT_TX_CF (0x3<<0)
+#define USTORM_ISCSI_AG_CONTEXT_TX_CF_SHIFT 0
+#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF (0x3<<2)
+#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_SHIFT 2
+#define USTORM_ISCSI_AG_CONTEXT_AGG_MISC4_RULE (0x7<<4)
+#define USTORM_ISCSI_AG_CONTEXT_AGG_MISC4_RULE_SHIFT 4
+#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_MASK (0x1<<7)
+#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_MASK_SHIFT 7
+        u8 __aux_counter_flags;
 #endif
 #if defined(__BIG_ENDIAN)
-        u16 xfrq_prod;
-        u16 cq_cons;
+        u8 cdu_usage;
+        u8 agg_misc2;
+        u16 __cq_local_comp_itt_val;
 #elif defined(__LITTLE_ENDIAN)
-        u16 cq_cons;
-        u16 xfrq_prod;
+        u16 __cq_local_comp_itt_val;
+        u8 agg_misc2;
+        u8 cdu_usage;
 #endif
+        u32 agg_misc4;
 #if defined(__BIG_ENDIAN)
-        u16 lcq_cons;
-        u16 hc_cram_address;
+        u8 agg_val3_th;
+        u8 agg_val3;
+        u16 agg_misc3;
 #elif defined(__LITTLE_ENDIAN)
-        u16 hc_cram_address;
-        u16 lcq_cons;
+        u16 agg_misc3;
+        u8 agg_val3;
+        u8 agg_val3_th;
 #endif
+        u32 agg_val1;
+        u32 agg_misc4_th;
 #if defined(__BIG_ENDIAN)
-        u16 sq_xfrq_lcq_confq_size;
-        u16 confq_prod;
+        u16 agg_val2_th;
+        u16 agg_val2;
 #elif defined(__LITTLE_ENDIAN)
-        u16 confq_prod;
-        u16 sq_xfrq_lcq_confq_size;
+        u16 agg_val2;
+        u16 agg_val2_th;
 #endif
 #if defined(__BIG_ENDIAN)
-        u8 hc_csdm_agg_int;
-        u8 flags;
-#define USTORM_FCOE_ST_CONTEXT_MID_SEQ_PROC_FLAG (0x1<<0)
-#define USTORM_FCOE_ST_CONTEXT_MID_SEQ_PROC_FLAG_SHIFT 0
-#define USTORM_FCOE_ST_CONTEXT_CACHED_CONN_FLAG (0x1<<1)
-#define USTORM_FCOE_ST_CONTEXT_CACHED_CONN_FLAG_SHIFT 1
-#define USTORM_FCOE_ST_CONTEXT_CACHED_TCE_FLAG (0x1<<2)
-#define USTORM_FCOE_ST_CONTEXT_CACHED_TCE_FLAG_SHIFT 2
-#define USTORM_FCOE_ST_CONTEXT_RSRV1 (0x1F<<3)
-#define USTORM_FCOE_ST_CONTEXT_RSRV1_SHIFT 3
-        u8 available_rqes;
-        u8 sp_q_flush_cnt;
+        u16 __reserved2;
+        u8 decision_rules;
+#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_RULE (0x7<<0)
+#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_RULE_SHIFT 0
+#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL3_RULE (0x7<<3)
+#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL3_RULE_SHIFT 3
+#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_ARM_N_FLAG (0x1<<6)
+#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_ARM_N_FLAG_SHIFT 6
+#define __USTORM_ISCSI_AG_CONTEXT_RESERVED1 (0x1<<7)
+#define __USTORM_ISCSI_AG_CONTEXT_RESERVED1_SHIFT 7
+        u8 decision_rule_enable_bits;
+#define USTORM_ISCSI_AG_CONTEXT_INV_CF_EN (0x1<<0)
+#define USTORM_ISCSI_AG_CONTEXT_INV_CF_EN_SHIFT 0
+#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_EN (0x1<<1)
+#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_EN_SHIFT 1
+#define USTORM_ISCSI_AG_CONTEXT_TX_CF_EN (0x1<<2)
+#define USTORM_ISCSI_AG_CONTEXT_TX_CF_EN_SHIFT 2
+#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_EN (0x1<<3)
+#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_EN_SHIFT 3
+#define __USTORM_ISCSI_AG_CONTEXT_CQ_LOCAL_COMP_CF_EN (0x1<<4)
+#define __USTORM_ISCSI_AG_CONTEXT_CQ_LOCAL_COMP_CF_EN_SHIFT 4
+#define __USTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN (0x1<<5)
+#define __USTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN_SHIFT 5
+#define __USTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN (0x1<<6)
+#define __USTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN_SHIFT 6
+#define __USTORM_ISCSI_AG_CONTEXT_DQ_CF_EN (0x1<<7)
+#define __USTORM_ISCSI_AG_CONTEXT_DQ_CF_EN_SHIFT 7
 #elif defined(__LITTLE_ENDIAN)
-        u8 sp_q_flush_cnt;
-        u8 available_rqes;
-        u8 flags;
-#define USTORM_FCOE_ST_CONTEXT_MID_SEQ_PROC_FLAG (0x1<<0)
-#define USTORM_FCOE_ST_CONTEXT_MID_SEQ_PROC_FLAG_SHIFT 0
-#define USTORM_FCOE_ST_CONTEXT_CACHED_CONN_FLAG (0x1<<1)
-#define USTORM_FCOE_ST_CONTEXT_CACHED_CONN_FLAG_SHIFT 1
-#define USTORM_FCOE_ST_CONTEXT_CACHED_TCE_FLAG (0x1<<2)
-#define USTORM_FCOE_ST_CONTEXT_CACHED_TCE_FLAG_SHIFT 2
-#define USTORM_FCOE_ST_CONTEXT_RSRV1 (0x1F<<3)
-#define USTORM_FCOE_ST_CONTEXT_RSRV1_SHIFT 3
-        u8 hc_csdm_agg_int;
+        u8 decision_rule_enable_bits;
+#define USTORM_ISCSI_AG_CONTEXT_INV_CF_EN (0x1<<0)
+#define USTORM_ISCSI_AG_CONTEXT_INV_CF_EN_SHIFT 0
+#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_EN (0x1<<1)
+#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_EN_SHIFT 1
+#define USTORM_ISCSI_AG_CONTEXT_TX_CF_EN (0x1<<2)
+#define USTORM_ISCSI_AG_CONTEXT_TX_CF_EN_SHIFT 2
+#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_EN (0x1<<3)
+#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_EN_SHIFT 3
+#define __USTORM_ISCSI_AG_CONTEXT_CQ_LOCAL_COMP_CF_EN (0x1<<4)
+#define __USTORM_ISCSI_AG_CONTEXT_CQ_LOCAL_COMP_CF_EN_SHIFT 4
+#define __USTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN (0x1<<5)
+#define __USTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN_SHIFT 5
+#define __USTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN (0x1<<6)
+#define __USTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN_SHIFT 6
+#define __USTORM_ISCSI_AG_CONTEXT_DQ_CF_EN (0x1<<7)
+#define __USTORM_ISCSI_AG_CONTEXT_DQ_CF_EN_SHIFT 7
+        u8 decision_rules;
+#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_RULE (0x7<<0)
+#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_RULE_SHIFT 0
+#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL3_RULE (0x7<<3)
+#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL3_RULE_SHIFT 3
+#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_ARM_N_FLAG (0x1<<6)
+#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_ARM_N_FLAG_SHIFT 6
+#define __USTORM_ISCSI_AG_CONTEXT_RESERVED1 (0x1<<7)
+#define __USTORM_ISCSI_AG_CONTEXT_RESERVED1_SHIFT 7
+        u16 __reserved2;
 #endif
-        struct ustorm_fcoe_data_place data_place;
-        struct ustorm_fcoe_task_ctx_entry_rd tce;
 };
 
-/*
- * The FCoE non-aggregative context of Tstorm
- */
-struct tstorm_fcoe_st_context {
-        struct regpair reserved0;
-        struct regpair reserved1;
-};
 
 /*
  * The fcoe aggregative context section of Xstorm
@@ -1272,8 +1366,8 @@ struct xstorm_fcoe_extra_ag_context_section {
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED51_SHIFT 0
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED (0x3<<2)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_SHIFT 2
-#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_PBF_TX_SEQ_ACK_CF (0x3<<4)
-#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_PBF_TX_SEQ_ACK_CF_SHIFT 4
+#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF (0x3<<4)
+#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_SHIFT 4
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_CLEAR_DA_TIMER_EN (0x1<<6)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_CLEAR_DA_TIMER_EN_SHIFT 6
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_DA_EXPIRATION_FLAG (0x1<<7)
@@ -1288,20 +1382,20 @@ struct xstorm_fcoe_extra_ag_context_section {
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED51_SHIFT 0
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED (0x3<<2)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_SHIFT 2
-#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_PBF_TX_SEQ_ACK_CF (0x3<<4)
-#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_PBF_TX_SEQ_ACK_CF_SHIFT 4
+#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF (0x3<<4)
+#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_SHIFT 4
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_CLEAR_DA_TIMER_EN (0x1<<6)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_CLEAR_DA_TIMER_EN_SHIFT 6
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_DA_EXPIRATION_FLAG (0x1<<7)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_DA_EXPIRATION_FLAG_SHIFT 7
 #endif
-        u32 __task_addr_lo;
-        u32 __task_addr_hi;
+        u32 snd_nxt;
+        u32 tx_wnd;
         u32 __reserved55;
-        u32 __tx_prods;
+        u32 local_adv_wnd;
 #if defined(__BIG_ENDIAN)
         u8 __agg_val8_th;
-        u8 __agg_val8;
+        u8 __tx_dest;
         u16 tcp_agg_vars2;
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED57 (0x1<<0)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED57_SHIFT 0
@@ -1317,8 +1411,8 @@ struct xstorm_fcoe_extra_ag_context_section {
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED60_SHIFT 5
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_ACK_TO_FE_UPDATED_EN (0x1<<6)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_ACK_TO_FE_UPDATED_EN_SHIFT 6
-#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_PBF_TX_SEQ_ACK_CF_EN (0x1<<7)
-#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_PBF_TX_SEQ_ACK_CF_EN_SHIFT 7
+#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_EN (0x1<<7)
+#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_EN_SHIFT 7
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_TX_FIN_FLAG_EN (0x1<<8)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_TX_FIN_FLAG_EN_SHIFT 8
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<9)
@@ -1327,8 +1421,8 @@ struct xstorm_fcoe_extra_ag_context_section {
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SET_RTO_CF_SHIFT 10
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF (0x3<<12)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF_SHIFT 12
-#define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX8_CF (0x3<<14)
-#define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX8_CF_SHIFT 14
+#define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF (0x3<<14)
+#define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF_SHIFT 14
 #elif defined(__LITTLE_ENDIAN)
         u16 tcp_agg_vars2;
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED57 (0x1<<0)
@@ -1345,8 +1439,8 @@ struct xstorm_fcoe_extra_ag_context_section {
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED60_SHIFT 5
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_ACK_TO_FE_UPDATED_EN (0x1<<6)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_ACK_TO_FE_UPDATED_EN_SHIFT 6
-#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_PBF_TX_SEQ_ACK_CF_EN (0x1<<7)
-#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_PBF_TX_SEQ_ACK_CF_EN_SHIFT 7
+#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_EN (0x1<<7)
+#define XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_EN_SHIFT 7
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_TX_FIN_FLAG_EN (0x1<<8)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED_TX_FIN_FLAG_EN_SHIFT 8
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<9)
@@ -1355,9 +1449,9 @@ struct xstorm_fcoe_extra_ag_context_section {
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_SET_RTO_CF_SHIFT 10
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF (0x3<<12)
 #define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF_SHIFT 12
-#define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX8_CF (0x3<<14)
-#define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX8_CF_SHIFT 14
-        u8 __agg_val8;
+#define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF (0x3<<14)
+#define __XSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF_SHIFT 14
+        u8 __tx_dest;
         u8 __agg_val8_th;
 #endif
         u32 __sq_base_addr_lo;
@@ -1591,9 +1685,9 @@ struct xstorm_fcoe_ag_context {
 #if defined(__BIG_ENDIAN)
         u8 __reserved1;
         u8 __agg_val6_th;
-        u16 __confq_tx_prod;
+        u16 __agg_val9;
 #elif defined(__LITTLE_ENDIAN)
-        u16 __confq_tx_prod;
+        u16 __agg_val9;
         u8 __agg_val6_th;
         u8 __reserved1;
 #endif
@@ -1605,16 +1699,16 @@ struct xstorm_fcoe_ag_context {
         u16 confq_cons;
 #endif
         u32 agg_vars8;
-#define __XSTORM_FCOE_AG_CONTEXT_CACHE_WQE_IDX (0xFFFFFF<<0)
-#define __XSTORM_FCOE_AG_CONTEXT_CACHE_WQE_IDX_SHIFT 0
+#define XSTORM_FCOE_AG_CONTEXT_AGG_MISC2 (0xFFFFFF<<0)
+#define XSTORM_FCOE_AG_CONTEXT_AGG_MISC2_SHIFT 0
 #define XSTORM_FCOE_AG_CONTEXT_AGG_MISC3 (0xFF<<24)
 #define XSTORM_FCOE_AG_CONTEXT_AGG_MISC3_SHIFT 24
 #if defined(__BIG_ENDIAN)
-        u16 ox_id;
+        u16 agg_misc0;
         u16 sq_prod;
 #elif defined(__LITTLE_ENDIAN)
         u16 sq_prod;
-        u16 ox_id;
+        u16 agg_misc0;
 #endif
 #if defined(__BIG_ENDIAN)
         u8 agg_val3;
@@ -1628,332 +1722,1685 @@ struct xstorm_fcoe_ag_context {
         u8 agg_val3;
 #endif
 #if defined(__BIG_ENDIAN)
-        u16 __pbf_tx_seq_ack;
+        u16 __agg_misc1;
         u16 agg_limit1;
 #elif defined(__LITTLE_ENDIAN)
         u16 agg_limit1;
-        u16 __pbf_tx_seq_ack;
+        u16 __agg_misc1;
 #endif
         u32 completion_seq;
         u32 confq_pbl_base_lo;
         u32 confq_pbl_base_hi;
 };
 
+
+
 /*
- * The fcoe extra aggregative context section of Tstorm
+ * The tcp aggregative context section of Xstorm
  */
-struct tstorm_fcoe_extra_ag_context_section {
-        u32 __agg_val1;
+struct xstorm_tcp_tcp_ag_context_section {
 #if defined(__BIG_ENDIAN)
-        u8 __tcp_agg_vars2;
-        u8 __agg_val3;
-        u16 __agg_val2;
+        u8 tcp_agg_vars1;
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_DA_TIMER_CF (0x3<<0)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_DA_TIMER_CF_SHIFT 0
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED (0x3<<2)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_SHIFT 2
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF (0x3<<4)
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_SHIFT 4
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_CLEAR_DA_TIMER_EN (0x1<<6)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_CLEAR_DA_TIMER_EN_SHIFT 6
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_EXPIRATION_FLAG (0x1<<7)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_EXPIRATION_FLAG_SHIFT 7
+        u8 __da_cnt;
+        u16 mss;
 #elif defined(__LITTLE_ENDIAN)
-        u16 __agg_val2;
-        u8 __agg_val3;
-        u8 __tcp_agg_vars2;
+        u16 mss;
+        u8 __da_cnt;
+        u8 tcp_agg_vars1;
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_DA_TIMER_CF (0x3<<0)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_DA_TIMER_CF_SHIFT 0
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED (0x3<<2)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_SHIFT 2
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF (0x3<<4)
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_SHIFT 4
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_CLEAR_DA_TIMER_EN (0x1<<6)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_CLEAR_DA_TIMER_EN_SHIFT 6
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_EXPIRATION_FLAG (0x1<<7)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_EXPIRATION_FLAG_SHIFT 7
 #endif
+        u32 snd_nxt;
+        u32 tx_wnd;
+        u32 snd_una;
+        u32 local_adv_wnd;
 #if defined(__BIG_ENDIAN)
-        u16 __agg_val5;
-        u8 __agg_val6;
+        u8 __agg_val8_th;
+        u8 __tx_dest;
+        u16 tcp_agg_vars2;
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG (0x1<<0)
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_SHIFT 0
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_UNBLOCKED (0x1<<1)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_UNBLOCKED_SHIFT 1
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_TIMER_ACTIVE (0x1<<2)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_TIMER_ACTIVE_SHIFT 2
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_FLAG (0x1<<3)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_FLAG_SHIFT 3
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX4_FLAG (0x1<<4)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX4_FLAG_SHIFT 4
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_ENABLE (0x1<<5)
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_ENABLE_SHIFT 5
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_EN (0x1<<6)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_EN_SHIFT 6
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_EN (0x1<<7)
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_EN_SHIFT 7
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_EN (0x1<<8)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_EN_SHIFT 8
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<9)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG_SHIFT 9
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_RTO_CF (0x3<<10)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_RTO_CF_SHIFT 10
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF (0x3<<12)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF_SHIFT 12
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF (0x3<<14)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF_SHIFT 14
+#elif defined(__LITTLE_ENDIAN)
+        u16 tcp_agg_vars2;
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG (0x1<<0)
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_SHIFT 0
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_UNBLOCKED (0x1<<1)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_UNBLOCKED_SHIFT 1
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_TIMER_ACTIVE (0x1<<2)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_TIMER_ACTIVE_SHIFT 2
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_FLAG (0x1<<3)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_FLAG_SHIFT 3
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX4_FLAG (0x1<<4)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX4_FLAG_SHIFT 4
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_ENABLE (0x1<<5)
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_ENABLE_SHIFT 5
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_EN (0x1<<6)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_EN_SHIFT 6
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_EN (0x1<<7)
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SIDEBAND_SENT_CF_EN_SHIFT 7
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_EN (0x1<<8)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_EN_SHIFT 8
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<9)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG_SHIFT 9
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_RTO_CF (0x3<<10)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_RTO_CF_SHIFT 10
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF (0x3<<12)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF_SHIFT 12
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF (0x3<<14)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF_SHIFT 14
+        u8 __tx_dest;
+        u8 __agg_val8_th;
+#endif
+        u32 ack_to_far_end;
+        u32 rto_timer;
+        u32 ka_timer;
+        u32 ts_to_echo;
+#if defined(__BIG_ENDIAN)
+        u16 __agg_val7_th;
+        u16 __agg_val7;
+#elif defined(__LITTLE_ENDIAN)
+        u16 __agg_val7;
+        u16 __agg_val7_th;
+#endif
+#if defined(__BIG_ENDIAN)
+        u8 __tcp_agg_vars5;
+        u8 __tcp_agg_vars4;
         u8 __tcp_agg_vars3;
+        u8 __force_pure_ack_cnt;
 #elif defined(__LITTLE_ENDIAN)
+        u8 __force_pure_ack_cnt;
         u8 __tcp_agg_vars3;
-        u8 __agg_val6;
-        u16 __agg_val5;
+        u8 __tcp_agg_vars4;
+        u8 __tcp_agg_vars5;
+#endif
+        u32 tcp_agg_vars6;
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_CF_EN (0x1<<0)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_CF_EN_SHIFT 0
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF_EN (0x1<<1)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_DEST_UPDATED_CF_EN_SHIFT 1
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX9_CF_EN (0x1<<2)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX9_CF_EN_SHIFT 2
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_EN (0x1<<3)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_EN_SHIFT 3
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX6_FLAG (0x1<<4)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX6_FLAG_SHIFT 4
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX7_FLAG (0x1<<5)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX7_FLAG_SHIFT 5
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX5_CF (0x3<<6)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX5_CF_SHIFT 6
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX9_CF (0x3<<8)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX9_CF_SHIFT 8
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF (0x3<<10)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_SHIFT 10
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX11_CF (0x3<<12)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX11_CF_SHIFT 12
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX12_CF (0x3<<14)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX12_CF_SHIFT 14
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX13_CF (0x3<<16)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX13_CF_SHIFT 16
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX14_CF (0x3<<18)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX14_CF_SHIFT 18
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX15_CF (0x3<<20)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX15_CF_SHIFT 20
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX16_CF (0x3<<22)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX16_CF_SHIFT 22
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX17_CF (0x3<<24)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX17_CF_SHIFT 24
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ECE_FLAG (0x1<<26)
+#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ECE_FLAG_SHIFT 26
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_RESERVED71 (0x1<<27)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_RESERVED71_SHIFT 27
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_FORCE_PURE_ACK_CNT_DIRTY (0x1<<28)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_FORCE_PURE_ACK_CNT_DIRTY_SHIFT 28
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TCP_AUTO_STOP_FLAG (0x1<<29)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TCP_AUTO_STOP_FLAG_SHIFT 29
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DO_TS_UPDATE_FLAG (0x1<<30)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DO_TS_UPDATE_FLAG_SHIFT 30
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_CANCEL_RETRANSMIT_FLAG (0x1<<31)
+#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_CANCEL_RETRANSMIT_FLAG_SHIFT 31
+#if defined(__BIG_ENDIAN)
+        u16 __agg_misc6;
+        u16 __tcp_agg_vars7;
+#elif defined(__LITTLE_ENDIAN)
+        u16 __tcp_agg_vars7;
+        u16 __agg_misc6;
+#endif
+        u32 __agg_val10;
+        u32 __agg_val10_th;
+#if defined(__BIG_ENDIAN)
+        u16 __reserved3;
+        u8 __reserved2;
+        u8 __da_only_cnt;
+#elif defined(__LITTLE_ENDIAN)
+        u8 __da_only_cnt;
+        u8 __reserved2;
+        u16 __reserved3;
 #endif
-        u32 __lcq_prod;
-        u32 rtt_seq;
-        u32 rtt_time;
-        u32 __reserved66;
-        u32 wnd_right_edge;
-        u32 tcp_agg_vars1;
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_FIN_SENT_FLAG (0x1<<0)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_FIN_SENT_FLAG_SHIFT 0
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_LAST_PACKET_FIN_FLAG (0x1<<1)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_LAST_PACKET_FIN_FLAG_SHIFT 1
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_WND_UPD_CF (0x3<<2)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_WND_UPD_CF_SHIFT 2
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TIMEOUT_CF (0x3<<4)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TIMEOUT_CF_SHIFT 4
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_WND_UPD_CF_EN (0x1<<6)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_WND_UPD_CF_EN_SHIFT 6
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TIMEOUT_CF_EN (0x1<<7)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TIMEOUT_CF_EN_SHIFT 7
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_SEQ_EN (0x1<<8)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_SEQ_EN_SHIFT 8
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_LCQ_SND_EN (0x1<<9)
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_LCQ_SND_EN_SHIFT 9
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<10)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_FLAG_SHIFT 10
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_FLAG (0x1<<11)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_FLAG_SHIFT 11
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_CF_EN (0x1<<12)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_CF_EN_SHIFT 12
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_CF_EN (0x1<<13)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_CF_EN_SHIFT 13
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_CF (0x3<<14)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX1_CF_SHIFT 14
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_CF (0x3<<16)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX2_CF_SHIFT 16
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TX_BLOCKED (0x1<<18)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_TX_BLOCKED_SHIFT 18
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX10_CF_EN (0x1<<19)
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX10_CF_EN_SHIFT 19
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX11_CF_EN (0x1<<20)
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX11_CF_EN_SHIFT 20
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX12_CF_EN (0x1<<21)
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_AUX12_CF_EN_SHIFT 21
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED1 (0x3<<22)
-#define __TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RESERVED1_SHIFT 22
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_PEND_SEQ (0xF<<24)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_PEND_SEQ_SHIFT 24
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_DONE_SEQ (0xF<<28)
-#define TSTORM_FCOE_EXTRA_AG_CONTEXT_SECTION_RETRANSMIT_DONE_SEQ_SHIFT 28
-        u32 snd_max;
-        u32 __lcq_cons;
-        u32 __reserved2;
 };
 
 /*
- * The fcoe aggregative context of Tstorm
+ * The iscsi aggregative context of Xstorm
  */
-struct tstorm_fcoe_ag_context {
+struct xstorm_iscsi_ag_context {
 #if defined(__BIG_ENDIAN)
-        u16 ulp_credit;
+        u16 agg_val1;
         u8 agg_vars1;
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF (0x3<<4)
-#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_SHIFT 4
-#define __TSTORM_FCOE_AG_CONTEXT_AUX3_FLAG (0x1<<6)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX3_FLAG_SHIFT 6
-#define __TSTORM_FCOE_AG_CONTEXT_AUX4_FLAG (0x1<<7)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX4_FLAG_SHIFT 7
+#define __XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define __XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define __XSTORM_ISCSI_AG_CONTEXT_MORE_TO_SEND_EN (0x1<<4)
+#define __XSTORM_ISCSI_AG_CONTEXT_MORE_TO_SEND_EN_SHIFT 4
+#define XSTORM_ISCSI_AG_CONTEXT_NAGLE_EN (0x1<<5)
+#define XSTORM_ISCSI_AG_CONTEXT_NAGLE_EN_SHIFT 5
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG (0x1<<6)
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_SHIFT 6
+#define __XSTORM_ISCSI_AG_CONTEXT_UNA_GT_NXT_EN (0x1<<7)
+#define __XSTORM_ISCSI_AG_CONTEXT_UNA_GT_NXT_EN_SHIFT 7
         u8 state;
 #elif defined(__LITTLE_ENDIAN)
         u8 state;
         u8 agg_vars1;
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define TSTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF (0x3<<4)
-#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_SHIFT 4
-#define __TSTORM_FCOE_AG_CONTEXT_AUX3_FLAG (0x1<<6)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX3_FLAG_SHIFT 6
-#define __TSTORM_FCOE_AG_CONTEXT_AUX4_FLAG (0x1<<7)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX4_FLAG_SHIFT 7
-        u16 ulp_credit;
+#define __XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define __XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define __XSTORM_ISCSI_AG_CONTEXT_MORE_TO_SEND_EN (0x1<<4)
+#define __XSTORM_ISCSI_AG_CONTEXT_MORE_TO_SEND_EN_SHIFT 4
+#define XSTORM_ISCSI_AG_CONTEXT_NAGLE_EN (0x1<<5)
+#define XSTORM_ISCSI_AG_CONTEXT_NAGLE_EN_SHIFT 5
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG (0x1<<6)
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_SHIFT 6
+#define __XSTORM_ISCSI_AG_CONTEXT_UNA_GT_NXT_EN (0x1<<7)
+#define __XSTORM_ISCSI_AG_CONTEXT_UNA_GT_NXT_EN_SHIFT 7
+        u16 agg_val1;
 #endif
 #if defined(__BIG_ENDIAN)
-        u16 __agg_val4;
-        u16 agg_vars2;
-#define __TSTORM_FCOE_AG_CONTEXT_AUX5_FLAG (0x1<<0)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX5_FLAG_SHIFT 0
-#define __TSTORM_FCOE_AG_CONTEXT_AUX6_FLAG (0x1<<1)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX6_FLAG_SHIFT 1
-#define __TSTORM_FCOE_AG_CONTEXT_AUX4_CF (0x3<<2)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX4_CF_SHIFT 2
-#define __TSTORM_FCOE_AG_CONTEXT_AUX5_CF (0x3<<4)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX5_CF_SHIFT 4
-#define __TSTORM_FCOE_AG_CONTEXT_AUX6_CF (0x3<<6)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX6_CF_SHIFT 6
-#define __TSTORM_FCOE_AG_CONTEXT_AUX7_CF (0x3<<8)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX7_CF_SHIFT 8
-#define __TSTORM_FCOE_AG_CONTEXT_AUX7_FLAG (0x1<<10)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX7_FLAG_SHIFT 10
-#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_EN (0x1<<11)
-#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_EN_SHIFT 11
-#define TSTORM_FCOE_AG_CONTEXT_AUX4_CF_EN (0x1<<12)
-#define TSTORM_FCOE_AG_CONTEXT_AUX4_CF_EN_SHIFT 12
-#define TSTORM_FCOE_AG_CONTEXT_AUX5_CF_EN (0x1<<13)
-#define TSTORM_FCOE_AG_CONTEXT_AUX5_CF_EN_SHIFT 13
-#define TSTORM_FCOE_AG_CONTEXT_AUX6_CF_EN (0x1<<14)
-#define TSTORM_FCOE_AG_CONTEXT_AUX6_CF_EN_SHIFT 14
-#define TSTORM_FCOE_AG_CONTEXT_AUX7_CF_EN (0x1<<15)
-#define TSTORM_FCOE_AG_CONTEXT_AUX7_CF_EN_SHIFT 15
+        u8 cdu_reserved;
+        u8 __agg_vars4;
+        u8 agg_vars3;
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM2 (0x3F<<0)
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM2_SHIFT 0
+#define __XSTORM_ISCSI_AG_CONTEXT_RX_TS_EN_CF (0x3<<6)
+#define __XSTORM_ISCSI_AG_CONTEXT_RX_TS_EN_CF_SHIFT 6
+        u8 agg_vars2;
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF (0x3<<0)
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_SHIFT 0
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_EN (0x1<<2)
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_EN_SHIFT 2
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX8_FLAG (0x1<<3)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX8_FLAG_SHIFT 3
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX9_FLAG (0x1<<4)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX9_FLAG_SHIFT 4
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE1 (0x3<<5)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE1_SHIFT 5
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_EN (0x1<<7)
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_EN_SHIFT 7
 #elif defined(__LITTLE_ENDIAN)
-        u16 agg_vars2;
-#define __TSTORM_FCOE_AG_CONTEXT_AUX5_FLAG (0x1<<0)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX5_FLAG_SHIFT 0
-#define __TSTORM_FCOE_AG_CONTEXT_AUX6_FLAG (0x1<<1)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX6_FLAG_SHIFT 1
-#define __TSTORM_FCOE_AG_CONTEXT_AUX4_CF (0x3<<2)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX4_CF_SHIFT 2
-#define __TSTORM_FCOE_AG_CONTEXT_AUX5_CF (0x3<<4)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX5_CF_SHIFT 4
-#define __TSTORM_FCOE_AG_CONTEXT_AUX6_CF (0x3<<6)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX6_CF_SHIFT 6
-#define __TSTORM_FCOE_AG_CONTEXT_AUX7_CF (0x3<<8)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX7_CF_SHIFT 8
-#define __TSTORM_FCOE_AG_CONTEXT_AUX7_FLAG (0x1<<10)
-#define __TSTORM_FCOE_AG_CONTEXT_AUX7_FLAG_SHIFT 10
-#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_EN (0x1<<11)
-#define __TSTORM_FCOE_AG_CONTEXT_QUEUE0_FLUSH_CF_EN_SHIFT 11
-#define TSTORM_FCOE_AG_CONTEXT_AUX4_CF_EN (0x1<<12)
-#define TSTORM_FCOE_AG_CONTEXT_AUX4_CF_EN_SHIFT 12
-#define TSTORM_FCOE_AG_CONTEXT_AUX5_CF_EN (0x1<<13)
-#define TSTORM_FCOE_AG_CONTEXT_AUX5_CF_EN_SHIFT 13
-#define TSTORM_FCOE_AG_CONTEXT_AUX6_CF_EN (0x1<<14)
-#define TSTORM_FCOE_AG_CONTEXT_AUX6_CF_EN_SHIFT 14
-#define TSTORM_FCOE_AG_CONTEXT_AUX7_CF_EN (0x1<<15)
-#define TSTORM_FCOE_AG_CONTEXT_AUX7_CF_EN_SHIFT 15
-        u16 __agg_val4;
+        u8 agg_vars2;
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF (0x3<<0)
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_SHIFT 0
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_EN (0x1<<2)
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_EN_SHIFT 2
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX8_FLAG (0x1<<3)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX8_FLAG_SHIFT 3
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX9_FLAG (0x1<<4)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX9_FLAG_SHIFT 4
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE1 (0x3<<5)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE1_SHIFT 5
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_EN (0x1<<7)
+#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_EN_SHIFT 7
+        u8 agg_vars3;
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM2 (0x3F<<0)
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM2_SHIFT 0
+#define __XSTORM_ISCSI_AG_CONTEXT_RX_TS_EN_CF (0x3<<6)
+#define __XSTORM_ISCSI_AG_CONTEXT_RX_TS_EN_CF_SHIFT 6
+        u8 __agg_vars4;
+        u8 cdu_reserved;
 #endif
-        struct tstorm_fcoe_extra_ag_context_section __extra_section;
+        u32 more_to_send;
+#if defined(__BIG_ENDIAN)
+        u16 agg_vars5;
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE5 (0x3<<0)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE5_SHIFT 0
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM0 (0x3F<<2)
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM0_SHIFT 2
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM1 (0x3F<<8)
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM1_SHIFT 8
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE2 (0x3<<14)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE2_SHIFT 14
+        u16 sq_cons;
+#elif defined(__LITTLE_ENDIAN)
+        u16 sq_cons;
+        u16 agg_vars5;
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE5 (0x3<<0)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE5_SHIFT 0
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM0 (0x3F<<2)
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM0_SHIFT 2
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM1 (0x3F<<8)
+#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM1_SHIFT 8
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE2 (0x3<<14)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE2_SHIFT 14
+#endif
+        struct xstorm_tcp_tcp_ag_context_section tcp;
+#if defined(__BIG_ENDIAN)
+        u16 agg_vars7;
+#define __XSTORM_ISCSI_AG_CONTEXT_AGG_VAL11_DECISION_RULE (0x7<<0)
+#define __XSTORM_ISCSI_AG_CONTEXT_AGG_VAL11_DECISION_RULE_SHIFT 0
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX13_FLAG (0x1<<3)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX13_FLAG_SHIFT 3
+#define __XSTORM_ISCSI_AG_CONTEXT_STORMS_SYNC_CF (0x3<<4)
+#define __XSTORM_ISCSI_AG_CONTEXT_STORMS_SYNC_CF_SHIFT 4
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE3 (0x3<<6)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE3_SHIFT 6
+#define XSTORM_ISCSI_AG_CONTEXT_AUX1_CF (0x3<<8)
+#define XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_SHIFT 8
+#define __XSTORM_ISCSI_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK (0x1<<10)
+#define __XSTORM_ISCSI_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK_SHIFT 10
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN (0x1<<11)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN_SHIFT 11
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX10_FLAG (0x1<<12)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX10_FLAG_SHIFT 12
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX11_FLAG (0x1<<13)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX11_FLAG_SHIFT 13
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX12_FLAG (0x1<<14)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX12_FLAG_SHIFT 14
+#define __XSTORM_ISCSI_AG_CONTEXT_RX_WND_SCL_EN (0x1<<15)
+#define __XSTORM_ISCSI_AG_CONTEXT_RX_WND_SCL_EN_SHIFT 15
+        u8 agg_val3_th;
+        u8 agg_vars6;
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE6 (0x7<<0)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE6_SHIFT 0
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE7 (0x7<<3)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE7_SHIFT 3
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE4 (0x3<<6)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE4_SHIFT 6
+#elif defined(__LITTLE_ENDIAN)
+        u8 agg_vars6;
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE6 (0x7<<0)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE6_SHIFT 0
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE7 (0x7<<3)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE7_SHIFT 3
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE4 (0x3<<6)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE4_SHIFT 6
+        u8 agg_val3_th;
+        u16 agg_vars7;
+#define __XSTORM_ISCSI_AG_CONTEXT_AGG_VAL11_DECISION_RULE (0x7<<0)
+#define __XSTORM_ISCSI_AG_CONTEXT_AGG_VAL11_DECISION_RULE_SHIFT 0
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX13_FLAG (0x1<<3)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX13_FLAG_SHIFT 3
+#define __XSTORM_ISCSI_AG_CONTEXT_STORMS_SYNC_CF (0x3<<4)
+#define __XSTORM_ISCSI_AG_CONTEXT_STORMS_SYNC_CF_SHIFT 4
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE3 (0x3<<6)
+#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE3_SHIFT 6
+#define XSTORM_ISCSI_AG_CONTEXT_AUX1_CF (0x3<<8)
+#define XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_SHIFT 8
+#define __XSTORM_ISCSI_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK (0x1<<10)
+#define __XSTORM_ISCSI_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK_SHIFT 10
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN (0x1<<11)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN_SHIFT 11
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX10_FLAG (0x1<<12)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX10_FLAG_SHIFT 12
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX11_FLAG (0x1<<13)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX11_FLAG_SHIFT 13
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX12_FLAG (0x1<<14)
+#define __XSTORM_ISCSI_AG_CONTEXT_AUX12_FLAG_SHIFT 14
+#define __XSTORM_ISCSI_AG_CONTEXT_RX_WND_SCL_EN (0x1<<15)
+#define __XSTORM_ISCSI_AG_CONTEXT_RX_WND_SCL_EN_SHIFT 15
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 __agg_val11_th;
+        u16 __gen_data;
+#elif defined(__LITTLE_ENDIAN)
+        u16 __gen_data;
+        u16 __agg_val11_th;
+#endif
+#if defined(__BIG_ENDIAN)
+        u8 __reserved1;
+        u8 __agg_val6_th;
+        u16 __agg_val9;
+#elif defined(__LITTLE_ENDIAN)
+        u16 __agg_val9;
+        u8 __agg_val6_th;
+        u8 __reserved1;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 hq_prod;
+        u16 hq_cons;
+#elif defined(__LITTLE_ENDIAN)
+        u16 hq_cons;
+        u16 hq_prod;
+#endif
+        u32 agg_vars8;
+#define XSTORM_ISCSI_AG_CONTEXT_AGG_MISC2 (0xFFFFFF<<0)
+#define XSTORM_ISCSI_AG_CONTEXT_AGG_MISC2_SHIFT 0
+#define XSTORM_ISCSI_AG_CONTEXT_AGG_MISC3 (0xFF<<24)
+#define XSTORM_ISCSI_AG_CONTEXT_AGG_MISC3_SHIFT 24
+#if defined(__BIG_ENDIAN)
+        u16 r2tq_prod;
+        u16 sq_prod;
+#elif defined(__LITTLE_ENDIAN)
+        u16 sq_prod;
+        u16 r2tq_prod;
+#endif
+#if defined(__BIG_ENDIAN)
+        u8 agg_val3;
+        u8 agg_val6;
+        u8 agg_val5_th;
+        u8 agg_val5;
+#elif defined(__LITTLE_ENDIAN)
+        u8 agg_val5;
+        u8 agg_val5_th;
+        u8 agg_val6;
+        u8 agg_val3;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 __agg_misc1;
+        u16 agg_limit1;
+#elif defined(__LITTLE_ENDIAN)
+        u16 agg_limit1;
+        u16 __agg_misc1;
+#endif
+        u32 hq_cons_tcp_seq;
+        u32 exp_stat_sn;
+        u32 rst_seq_num;
 };
 
+
 /*
- * The fcoe aggregative context of Ustorm
+ * The L5cm aggregative context of XStorm
  */
-struct ustorm_fcoe_ag_context {
+struct xstorm_l5cm_ag_context {
 #if defined(__BIG_ENDIAN)
-        u8 __aux_counter_flags;
-        u8 agg_vars2;
-#define USTORM_FCOE_AG_CONTEXT_TX_CF (0x3<<0)
-#define USTORM_FCOE_AG_CONTEXT_TX_CF_SHIFT 0
-#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF (0x3<<2)
-#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_SHIFT 2
-#define USTORM_FCOE_AG_CONTEXT_AGG_MISC4_RULE (0x7<<4)
-#define USTORM_FCOE_AG_CONTEXT_AGG_MISC4_RULE_SHIFT 4
-#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL2_MASK (0x1<<7)
-#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL2_MASK_SHIFT 7
+        u16 agg_val1;
         u8 agg_vars1;
-#define __USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define __USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define USTORM_FCOE_AG_CONTEXT_INV_CF (0x3<<4)
-#define USTORM_FCOE_AG_CONTEXT_INV_CF_SHIFT 4
-#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF (0x3<<6)
-#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_SHIFT 6
+#define __XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define __XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define __XSTORM_L5CM_AG_CONTEXT_MORE_TO_SEND_EN (0x1<<4)
+#define __XSTORM_L5CM_AG_CONTEXT_MORE_TO_SEND_EN_SHIFT 4
+#define XSTORM_L5CM_AG_CONTEXT_NAGLE_EN (0x1<<5)
+#define XSTORM_L5CM_AG_CONTEXT_NAGLE_EN_SHIFT 5
+#define __XSTORM_L5CM_AG_CONTEXT_DQ_SPARE_FLAG (0x1<<6)
+#define __XSTORM_L5CM_AG_CONTEXT_DQ_SPARE_FLAG_SHIFT 6
+#define __XSTORM_L5CM_AG_CONTEXT_UNA_GT_NXT_EN (0x1<<7)
+#define __XSTORM_L5CM_AG_CONTEXT_UNA_GT_NXT_EN_SHIFT 7
         u8 state;
 #elif defined(__LITTLE_ENDIAN)
         u8 state;
         u8 agg_vars1;
-#define __USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define __USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define USTORM_FCOE_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define USTORM_FCOE_AG_CONTEXT_INV_CF (0x3<<4)
-#define USTORM_FCOE_AG_CONTEXT_INV_CF_SHIFT 4
-#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF (0x3<<6)
-#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_SHIFT 6
-        u8 agg_vars2;
-#define USTORM_FCOE_AG_CONTEXT_TX_CF (0x3<<0)
-#define USTORM_FCOE_AG_CONTEXT_TX_CF_SHIFT 0
-#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF (0x3<<2)
-#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_SHIFT 2
-#define USTORM_FCOE_AG_CONTEXT_AGG_MISC4_RULE (0x7<<4)
-#define USTORM_FCOE_AG_CONTEXT_AGG_MISC4_RULE_SHIFT 4
-#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL2_MASK (0x1<<7)
-#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL2_MASK_SHIFT 7
-        u8 __aux_counter_flags;
+#define __XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
+#define __XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
+#define XSTORM_L5CM_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
+#define __XSTORM_L5CM_AG_CONTEXT_MORE_TO_SEND_EN (0x1<<4)
+#define __XSTORM_L5CM_AG_CONTEXT_MORE_TO_SEND_EN_SHIFT 4
+#define XSTORM_L5CM_AG_CONTEXT_NAGLE_EN (0x1<<5)
+#define XSTORM_L5CM_AG_CONTEXT_NAGLE_EN_SHIFT 5
+#define __XSTORM_L5CM_AG_CONTEXT_DQ_SPARE_FLAG (0x1<<6)
+#define __XSTORM_L5CM_AG_CONTEXT_DQ_SPARE_FLAG_SHIFT 6
+#define __XSTORM_L5CM_AG_CONTEXT_UNA_GT_NXT_EN (0x1<<7)
+#define __XSTORM_L5CM_AG_CONTEXT_UNA_GT_NXT_EN_SHIFT 7
+        u16 agg_val1;
 #endif
 #if defined(__BIG_ENDIAN)
-        u8 cdu_usage;
-        u8 agg_misc2;
-        u16 pbf_tx_seq_ack;
+        u8 cdu_reserved;
+        u8 __agg_vars4;
+        u8 agg_vars3;
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM2 (0x3F<<0)
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM2_SHIFT 0
+#define __XSTORM_L5CM_AG_CONTEXT_RX_TS_EN_CF (0x3<<6)
+#define __XSTORM_L5CM_AG_CONTEXT_RX_TS_EN_CF_SHIFT 6
+        u8 agg_vars2;
+#define XSTORM_L5CM_AG_CONTEXT_AUX4_CF (0x3<<0)
+#define XSTORM_L5CM_AG_CONTEXT_AUX4_CF_SHIFT 0
+#define __XSTORM_L5CM_AG_CONTEXT_DQ_SPARE_FLAG_EN (0x1<<2)
+#define __XSTORM_L5CM_AG_CONTEXT_DQ_SPARE_FLAG_EN_SHIFT 2
+#define __XSTORM_L5CM_AG_CONTEXT_AUX8_FLAG (0x1<<3)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX8_FLAG_SHIFT 3
+#define __XSTORM_L5CM_AG_CONTEXT_AUX9_FLAG (0x1<<4)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX9_FLAG_SHIFT 4
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE1 (0x3<<5)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE1_SHIFT 5
+#define XSTORM_L5CM_AG_CONTEXT_AUX4_CF_EN (0x1<<7)
+#define XSTORM_L5CM_AG_CONTEXT_AUX4_CF_EN_SHIFT 7
 #elif defined(__LITTLE_ENDIAN)
-        u16 pbf_tx_seq_ack;
-        u8 agg_misc2;
-        u8 cdu_usage;
+        u8 agg_vars2;
+#define XSTORM_L5CM_AG_CONTEXT_AUX4_CF (0x3<<0)
+#define XSTORM_L5CM_AG_CONTEXT_AUX4_CF_SHIFT 0
+#define __XSTORM_L5CM_AG_CONTEXT_DQ_SPARE_FLAG_EN (0x1<<2)
+#define __XSTORM_L5CM_AG_CONTEXT_DQ_SPARE_FLAG_EN_SHIFT 2
+#define __XSTORM_L5CM_AG_CONTEXT_AUX8_FLAG (0x1<<3)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX8_FLAG_SHIFT 3
+#define __XSTORM_L5CM_AG_CONTEXT_AUX9_FLAG (0x1<<4)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX9_FLAG_SHIFT 4
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE1 (0x3<<5)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE1_SHIFT 5
+#define XSTORM_L5CM_AG_CONTEXT_AUX4_CF_EN (0x1<<7)
+#define XSTORM_L5CM_AG_CONTEXT_AUX4_CF_EN_SHIFT 7
+        u8 agg_vars3;
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM2 (0x3F<<0)
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM2_SHIFT 0
+#define __XSTORM_L5CM_AG_CONTEXT_RX_TS_EN_CF (0x3<<6)
+#define __XSTORM_L5CM_AG_CONTEXT_RX_TS_EN_CF_SHIFT 6
+        u8 __agg_vars4;
+        u8 cdu_reserved;
 #endif
-        u32 agg_misc4;
+        u32 more_to_send;
+#if defined(__BIG_ENDIAN)
+        u16 agg_vars5;
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE5 (0x3<<0)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE5_SHIFT 0
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM0 (0x3F<<2)
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM0_SHIFT 2
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM1 (0x3F<<8)
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM1_SHIFT 8
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE2 (0x3<<14)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE2_SHIFT 14
+        u16 agg_val4_th;
+#elif defined(__LITTLE_ENDIAN)
+        u16 agg_val4_th;
+        u16 agg_vars5;
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE5 (0x3<<0)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE5_SHIFT 0
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM0 (0x3F<<2)
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM0_SHIFT 2
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM1 (0x3F<<8)
+#define XSTORM_L5CM_AG_CONTEXT_PHYSICAL_QUEUE_NUM1_SHIFT 8
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE2 (0x3<<14)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE2_SHIFT 14
+#endif
+        struct xstorm_tcp_tcp_ag_context_section tcp;
 #if defined(__BIG_ENDIAN)
+        u16 agg_vars7;
+#define __XSTORM_L5CM_AG_CONTEXT_AGG_VAL11_DECISION_RULE (0x7<<0)
+#define __XSTORM_L5CM_AG_CONTEXT_AGG_VAL11_DECISION_RULE_SHIFT 0
+#define __XSTORM_L5CM_AG_CONTEXT_AUX13_FLAG (0x1<<3)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX13_FLAG_SHIFT 3
+#define __XSTORM_L5CM_AG_CONTEXT_STORMS_SYNC_CF (0x3<<4)
+#define __XSTORM_L5CM_AG_CONTEXT_STORMS_SYNC_CF_SHIFT 4
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE3 (0x3<<6)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE3_SHIFT 6
+#define XSTORM_L5CM_AG_CONTEXT_AUX1_CF (0x3<<8)
+#define XSTORM_L5CM_AG_CONTEXT_AUX1_CF_SHIFT 8
+#define __XSTORM_L5CM_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK (0x1<<10)
+#define __XSTORM_L5CM_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK_SHIFT 10
+#define __XSTORM_L5CM_AG_CONTEXT_AUX1_CF_EN (0x1<<11)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX1_CF_EN_SHIFT 11
+#define __XSTORM_L5CM_AG_CONTEXT_AUX10_FLAG (0x1<<12)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX10_FLAG_SHIFT 12
+#define __XSTORM_L5CM_AG_CONTEXT_AUX11_FLAG (0x1<<13)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX11_FLAG_SHIFT 13
+#define __XSTORM_L5CM_AG_CONTEXT_AUX12_FLAG (0x1<<14)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX12_FLAG_SHIFT 14
+#define __XSTORM_L5CM_AG_CONTEXT_RX_WND_SCL_EN (0x1<<15)
+#define __XSTORM_L5CM_AG_CONTEXT_RX_WND_SCL_EN_SHIFT 15
         u8 agg_val3_th;
+        u8 agg_vars6;
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE6 (0x7<<0)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE6_SHIFT 0
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE7 (0x7<<3)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE7_SHIFT 3
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE4 (0x3<<6)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE4_SHIFT 6
+#elif defined(__LITTLE_ENDIAN)
+        u8 agg_vars6;
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE6 (0x7<<0)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE6_SHIFT 0
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE7 (0x7<<3)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE7_SHIFT 3
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE4 (0x3<<6)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE4_SHIFT 6
+        u8 agg_val3_th;
+        u16 agg_vars7;
+#define __XSTORM_L5CM_AG_CONTEXT_AGG_VAL11_DECISION_RULE (0x7<<0)
+#define __XSTORM_L5CM_AG_CONTEXT_AGG_VAL11_DECISION_RULE_SHIFT 0
+#define __XSTORM_L5CM_AG_CONTEXT_AUX13_FLAG (0x1<<3)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX13_FLAG_SHIFT 3
+#define __XSTORM_L5CM_AG_CONTEXT_STORMS_SYNC_CF (0x3<<4)
+#define __XSTORM_L5CM_AG_CONTEXT_STORMS_SYNC_CF_SHIFT 4
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE3 (0x3<<6)
+#define XSTORM_L5CM_AG_CONTEXT_DECISION_RULE3_SHIFT 6
+#define XSTORM_L5CM_AG_CONTEXT_AUX1_CF (0x3<<8)
+#define XSTORM_L5CM_AG_CONTEXT_AUX1_CF_SHIFT 8
+#define __XSTORM_L5CM_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK (0x1<<10)
+#define __XSTORM_L5CM_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK_SHIFT 10
+#define __XSTORM_L5CM_AG_CONTEXT_AUX1_CF_EN (0x1<<11)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX1_CF_EN_SHIFT 11
+#define __XSTORM_L5CM_AG_CONTEXT_AUX10_FLAG (0x1<<12)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX10_FLAG_SHIFT 12
+#define __XSTORM_L5CM_AG_CONTEXT_AUX11_FLAG (0x1<<13)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX11_FLAG_SHIFT 13
+#define __XSTORM_L5CM_AG_CONTEXT_AUX12_FLAG (0x1<<14)
+#define __XSTORM_L5CM_AG_CONTEXT_AUX12_FLAG_SHIFT 14
+#define __XSTORM_L5CM_AG_CONTEXT_RX_WND_SCL_EN (0x1<<15)
+#define __XSTORM_L5CM_AG_CONTEXT_RX_WND_SCL_EN_SHIFT 15
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 __agg_val11_th;
+        u16 __gen_data;
+#elif defined(__LITTLE_ENDIAN)
+        u16 __gen_data;
+        u16 __agg_val11_th;
+#endif
+#if defined(__BIG_ENDIAN)
+        u8 __reserved1;
+        u8 __agg_val6_th;
+        u16 __agg_val9;
+#elif defined(__LITTLE_ENDIAN)
+        u16 __agg_val9;
+        u8 __agg_val6_th;
+        u8 __reserved1;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 agg_val2_th;
+        u16 agg_val2;
+#elif defined(__LITTLE_ENDIAN)
+        u16 agg_val2;
+        u16 agg_val2_th;
+#endif
+        u32 agg_vars8;
+#define XSTORM_L5CM_AG_CONTEXT_AGG_MISC2 (0xFFFFFF<<0)
+#define XSTORM_L5CM_AG_CONTEXT_AGG_MISC2_SHIFT 0
+#define XSTORM_L5CM_AG_CONTEXT_AGG_MISC3 (0xFF<<24)
+#define XSTORM_L5CM_AG_CONTEXT_AGG_MISC3_SHIFT 24
+#if defined(__BIG_ENDIAN)
+        u16 agg_misc0;
+        u16 agg_val4;
+#elif defined(__LITTLE_ENDIAN)
+        u16 agg_val4;
+        u16 agg_misc0;
+#endif
+#if defined(__BIG_ENDIAN)
         u8 agg_val3;
-        u16 agg_misc3;
+        u8 agg_val6;
+        u8 agg_val5_th;
+        u8 agg_val5;
 #elif defined(__LITTLE_ENDIAN)
-        u16 agg_misc3;
+        u8 agg_val5;
+        u8 agg_val5_th;
+        u8 agg_val6;
         u8 agg_val3;
-        u8 agg_val3_th;
 #endif
-        u32 expired_task_id;
-        u32 agg_misc4_th;
 #if defined(__BIG_ENDIAN)
-        u16 cq_prod;
+        u16 __agg_misc1;
+        u16 agg_limit1;
+#elif defined(__LITTLE_ENDIAN)
+        u16 agg_limit1;
+        u16 __agg_misc1;
+#endif
+        u32 completion_seq;
+        u32 agg_misc4;
+        u32 rst_seq_num;
+};
+
+/*
+ * ABTS info $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_abts_info {
+        __le16 aborted_task_id;
+        __le16 reserved0;
+        __le32 reserved1;
+};
+
+
+/*
+ * Fixed size structure in order to plant it in Union structure
+ * $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_abts_rsp_union {
+        u8 r_ctl;
+        u8 rsrv[3];
+        __le32 abts_rsp_payload[7];
+};
+
+
+/*
+ * 4 regs size $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_bd_ctx {
+        __le32 buf_addr_hi;
+        __le32 buf_addr_lo;
+        __le16 buf_len;
+        __le16 rsrv0;
+        __le16 flags;
+        __le16 rsrv1;
+};
+
+
+/*
+ * FCoE cached sges context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_cached_sge_ctx {
+        struct regpair cur_buf_addr;
+        __le16 cur_buf_rem;
+        __le16 second_buf_rem;
+        struct regpair second_buf_addr;
+};
+
+
+/*
+ * Cleanup info $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_cleanup_info {
+        __le16 cleaned_task_id;
+        __le16 rolled_tx_seq_cnt;
+        __le32 rolled_tx_data_offset;
+};
+
+
+/*
+ * Fcp RSP flags $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fcp_rsp_flags {
+        u8 flags;
+#define FCOE_FCP_RSP_FLAGS_FCP_RSP_LEN_VALID (0x1<<0)
+#define FCOE_FCP_RSP_FLAGS_FCP_RSP_LEN_VALID_SHIFT 0
+#define FCOE_FCP_RSP_FLAGS_FCP_SNS_LEN_VALID (0x1<<1)
+#define FCOE_FCP_RSP_FLAGS_FCP_SNS_LEN_VALID_SHIFT 1
+#define FCOE_FCP_RSP_FLAGS_FCP_RESID_OVER (0x1<<2)
+#define FCOE_FCP_RSP_FLAGS_FCP_RESID_OVER_SHIFT 2
+#define FCOE_FCP_RSP_FLAGS_FCP_RESID_UNDER (0x1<<3)
+#define FCOE_FCP_RSP_FLAGS_FCP_RESID_UNDER_SHIFT 3
+#define FCOE_FCP_RSP_FLAGS_FCP_CONF_REQ (0x1<<4)
+#define FCOE_FCP_RSP_FLAGS_FCP_CONF_REQ_SHIFT 4
+#define FCOE_FCP_RSP_FLAGS_FCP_BIDI_FLAGS (0x7<<5)
+#define FCOE_FCP_RSP_FLAGS_FCP_BIDI_FLAGS_SHIFT 5
+};
+
+/*
+ * Fcp RSP payload $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fcp_rsp_payload {
+        struct regpair reserved0;
+        __le32 fcp_resid;
+        u8 scsi_status_code;
+        struct fcoe_fcp_rsp_flags fcp_flags;
+        __le16 retry_delay_timer;
+        __le32 fcp_rsp_len;
+        __le32 fcp_sns_len;
+};
+
+/*
+ * Fixed size structure in order to plant it in Union structure
+ * $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fcp_rsp_union {
+        struct fcoe_fcp_rsp_payload payload;
+        struct regpair reserved0;
+};
+
+/*
+ * FC header $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fc_hdr {
+        u8 s_id[3];
+        u8 cs_ctl;
+        u8 d_id[3];
+        u8 r_ctl;
+        __le16 seq_cnt;
+        u8 df_ctl;
+        u8 seq_id;
+        u8 f_ctl[3];
+        u8 type;
+        __le32 parameters;
+        __le16 rx_id;
+        __le16 ox_id;
+};
+
+/*
+ * FC header union $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_mp_rsp_union {
+        struct fcoe_fc_hdr fc_hdr;
+        __le32 mp_payload_len;
+        __le32 rsrv;
+};
+
+/*
+ * Completion information $$KEEP_ENDIANNESS$$
+ */
+union fcoe_comp_flow_info {
+        struct fcoe_fcp_rsp_union fcp_rsp;
+        struct fcoe_abts_rsp_union abts_rsp;
+        struct fcoe_mp_rsp_union mp_rsp;
+        __le32 opaque[8];
+};
+
+
+/*
+ * External ABTS info $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_ext_abts_info {
+        __le32 rsrv0[6];
+        struct fcoe_abts_info ctx;
+};
+
+
+/*
+ * External cleanup info $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_ext_cleanup_info {
+        __le32 rsrv0[6];
+        struct fcoe_cleanup_info ctx;
+};
+
+
+/*
+ * Fcoe FW Tx sequence context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fw_tx_seq_ctx {
+        __le32 data_offset;
+        __le16 seq_cnt;
+        __le16 rsrv0;
+};
+
+/*
+ * Fcoe external FW Tx sequence context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_ext_fw_tx_seq_ctx {
+        __le32 rsrv0[6];
+        struct fcoe_fw_tx_seq_ctx ctx;
+};
+
+
+/*
+ * FCoE multiple sges context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_mul_sges_ctx {
+        struct regpair cur_sge_addr;
+        __le16 cur_sge_off;
+        u8 cur_sge_idx;
+        u8 sgl_size;
+};
+
+/*
+ * FCoE external multiple sges context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_ext_mul_sges_ctx {
+        struct fcoe_mul_sges_ctx mul_sgl;
+        struct regpair rsrv0;
+};
+
+
+/*
+ * FCP CMD payload $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fcp_cmd_payload {
+        __le32 opaque[8];
+};
+
+
+
+
+
+/*
+ * Fcp xfr rdy payload $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fcp_xfr_rdy_payload {
+        __le32 burst_len;
+        __le32 data_ro;
+};
+
+
+/*
+ * FC frame $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fc_frame {
+        struct fcoe_fc_hdr fc_hdr;
+        __le32 reserved0[2];
+};
+
+
+
+
+/*
+ * FCoE KCQ CQE parameters $$KEEP_ENDIANNESS$$
+ */
+union fcoe_kcqe_params {
+        __le32 reserved0[4];
+};
+
+/*
+ * FCoE KCQ CQE $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kcqe {
+        __le32 fcoe_conn_id;
+        __le32 completion_status;
+        __le32 fcoe_conn_context_id;
+        union fcoe_kcqe_params params;
+        __le16 qe_self_seq;
+        u8 op_code;
+        u8 flags;
+#define FCOE_KCQE_RESERVED0 (0x7<<0)
+#define FCOE_KCQE_RESERVED0_SHIFT 0
+#define FCOE_KCQE_RAMROD_COMPLETION (0x1<<3)
+#define FCOE_KCQE_RAMROD_COMPLETION_SHIFT 3
+#define FCOE_KCQE_LAYER_CODE (0x7<<4)
+#define FCOE_KCQE_LAYER_CODE_SHIFT 4
+#define FCOE_KCQE_LINKED_WITH_NEXT (0x1<<7)
+#define FCOE_KCQE_LINKED_WITH_NEXT_SHIFT 7
+};
+
+
+
+/*
+ * FCoE KWQE header $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_header {
+        u8 op_code;
+        u8 flags;
+#define FCOE_KWQE_HEADER_RESERVED0 (0xF<<0)
+#define FCOE_KWQE_HEADER_RESERVED0_SHIFT 0
+#define FCOE_KWQE_HEADER_LAYER_CODE (0x7<<4)
+#define FCOE_KWQE_HEADER_LAYER_CODE_SHIFT 4
+#define FCOE_KWQE_HEADER_RESERVED1 (0x1<<7)
+#define FCOE_KWQE_HEADER_RESERVED1_SHIFT 7
+};
+
+/*
+ * FCoE firmware init request 1 $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_init1 {
+        __le16 num_tasks;
+        struct fcoe_kwqe_header hdr;
+        __le32 task_list_pbl_addr_lo;
+        __le32 task_list_pbl_addr_hi;
+        __le32 dummy_buffer_addr_lo;
+        __le32 dummy_buffer_addr_hi;
+        __le16 sq_num_wqes;
+        __le16 rq_num_wqes;
+        __le16 rq_buffer_log_size;
+        __le16 cq_num_wqes;
+        __le16 mtu;
+        u8 num_sessions_log;
+        u8 flags;
+#define FCOE_KWQE_INIT1_LOG_PAGE_SIZE (0xF<<0)
+#define FCOE_KWQE_INIT1_LOG_PAGE_SIZE_SHIFT 0
+#define FCOE_KWQE_INIT1_LOG_CACHED_PBES_PER_FUNC (0x7<<4)
+#define FCOE_KWQE_INIT1_LOG_CACHED_PBES_PER_FUNC_SHIFT 4
+#define FCOE_KWQE_INIT1_RESERVED1 (0x1<<7)
+#define FCOE_KWQE_INIT1_RESERVED1_SHIFT 7
+};
+
+/*
+ * FCoE firmware init request 2 $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_init2 {
+        u8 hsi_major_version;
+        u8 hsi_minor_version;
+        struct fcoe_kwqe_header hdr;
+        __le32 hash_tbl_pbl_addr_lo;
+        __le32 hash_tbl_pbl_addr_hi;
+        __le32 t2_hash_tbl_addr_lo;
+        __le32 t2_hash_tbl_addr_hi;
+        __le32 t2_ptr_hash_tbl_addr_lo;
+        __le32 t2_ptr_hash_tbl_addr_hi;
+        __le32 free_list_count;
+};
+
+/*
+ * FCoE firmware init request 3 $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_init3 {
+        __le16 reserved0;
+        struct fcoe_kwqe_header hdr;
+        __le32 error_bit_map_lo;
+        __le32 error_bit_map_hi;
+        u8 perf_config;
+        u8 reserved21[3];
+        __le32 reserved2[4];
+};
+
+/*
+ * FCoE connection offload request 1 $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_conn_offload1 {
+        __le16 fcoe_conn_id;
+        struct fcoe_kwqe_header hdr;
+        __le32 sq_addr_lo;
+        __le32 sq_addr_hi;
+        __le32 rq_pbl_addr_lo;
+        __le32 rq_pbl_addr_hi;
+        __le32 rq_first_pbe_addr_lo;
+        __le32 rq_first_pbe_addr_hi;
+        __le16 rq_prod;
+        __le16 reserved0;
+};
+
+/*
+ * FCoE connection offload request 2 $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_conn_offload2 {
+        __le16 tx_max_fc_pay_len;
+        struct fcoe_kwqe_header hdr;
+        __le32 cq_addr_lo;
+        __le32 cq_addr_hi;
+        __le32 xferq_addr_lo;
+        __le32 xferq_addr_hi;
+        __le32 conn_db_addr_lo;
+        __le32 conn_db_addr_hi;
+        __le32 reserved1;
+};
+
+/*
+ * FCoE connection offload request 3 $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_conn_offload3 {
+        __le16 vlan_tag;
+#define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID (0xFFF<<0)
+#define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID_SHIFT 0
+#define FCOE_KWQE_CONN_OFFLOAD3_CFI (0x1<<12)
+#define FCOE_KWQE_CONN_OFFLOAD3_CFI_SHIFT 12
+#define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY (0x7<<13)
+#define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY_SHIFT 13
+        struct fcoe_kwqe_header hdr;
+        u8 s_id[3];
+        u8 tx_max_conc_seqs_c3;
+        u8 d_id[3];
+        u8 flags;
+#define FCOE_KWQE_CONN_OFFLOAD3_B_MUL_N_PORT_IDS (0x1<<0)
+#define FCOE_KWQE_CONN_OFFLOAD3_B_MUL_N_PORT_IDS_SHIFT 0
+#define FCOE_KWQE_CONN_OFFLOAD3_B_E_D_TOV_RES (0x1<<1)
+#define FCOE_KWQE_CONN_OFFLOAD3_B_E_D_TOV_RES_SHIFT 1
+#define FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT (0x1<<2)
+#define FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT_SHIFT 2
+#define FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ (0x1<<3)
+#define FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ_SHIFT 3
+#define FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID (0x1<<4)
+#define FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID_SHIFT 4
+#define FCOE_KWQE_CONN_OFFLOAD3_B_C2_VALID (0x1<<5)
+#define FCOE_KWQE_CONN_OFFLOAD3_B_C2_VALID_SHIFT 5
+#define FCOE_KWQE_CONN_OFFLOAD3_B_ACK_0 (0x1<<6)
+#define FCOE_KWQE_CONN_OFFLOAD3_B_ACK_0_SHIFT 6
+#define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG (0x1<<7)
+#define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG_SHIFT 7
+        __le32 reserved;
+        __le32 confq_first_pbe_addr_lo;
+        __le32 confq_first_pbe_addr_hi;
+        __le16 tx_total_conc_seqs;
+        __le16 rx_max_fc_pay_len;
+        __le16 rx_total_conc_seqs;
+        u8 rx_max_conc_seqs_c3;
+        u8 rx_open_seqs_exch_c3;
+};
+
+/*
+ * FCoE connection offload request 4 $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_conn_offload4 {
+        u8 e_d_tov_timer_val;
+        u8 reserved2;
+        struct fcoe_kwqe_header hdr;
+        u8 src_mac_addr_lo[2];
+        u8 src_mac_addr_mid[2];
+        u8 src_mac_addr_hi[2];
+        u8 dst_mac_addr_hi[2];
+        u8 dst_mac_addr_lo[2];
+        u8 dst_mac_addr_mid[2];
+        __le32 lcq_addr_lo;
+        __le32 lcq_addr_hi;
+        __le32 confq_pbl_base_addr_lo;
+        __le32 confq_pbl_base_addr_hi;
+};
+
+/*
+ * FCoE connection enable request $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_conn_enable_disable {
+        __le16 reserved0;
+        struct fcoe_kwqe_header hdr;
+        u8 src_mac_addr_lo[2];
+        u8 src_mac_addr_mid[2];
+        u8 src_mac_addr_hi[2];
+        u16 vlan_tag;
+#define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID (0xFFF<<0)
+#define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID_SHIFT 0
+#define FCOE_KWQE_CONN_ENABLE_DISABLE_CFI (0x1<<12)
+#define FCOE_KWQE_CONN_ENABLE_DISABLE_CFI_SHIFT 12
+#define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY (0x7<<13)
+#define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY_SHIFT 13
+        u8 dst_mac_addr_lo[2];
+        u8 dst_mac_addr_mid[2];
+        u8 dst_mac_addr_hi[2];
+        __le16 reserved1;
+        u8 s_id[3];
+        u8 vlan_flag;
+        u8 d_id[3];
+        u8 reserved3;
+        __le32 context_id;
+        __le32 conn_id;
+        __le32 reserved4;
+};
+
+/*
+ * FCoE connection destroy request $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_conn_destroy {
+        __le16 reserved0;
+        struct fcoe_kwqe_header hdr;
+        __le32 context_id;
+        __le32 conn_id;
+        __le32 reserved1[5];
+};
+
+/*
+ * FCoe destroy request $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_destroy {
+        __le16 reserved0;
+        struct fcoe_kwqe_header hdr;
+        __le32 reserved1[7];
+};
+
+/*
+ * FCoe statistics request $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_kwqe_stat {
+        __le16 reserved0;
+        struct fcoe_kwqe_header hdr;
+        __le32 stat_params_addr_lo;
+        __le32 stat_params_addr_hi;
+        __le32 reserved1[5];
+};
+
+/*
+ * FCoE KWQ WQE $$KEEP_ENDIANNESS$$
+ */
+union fcoe_kwqe {
+        struct fcoe_kwqe_init1 init1;
+        struct fcoe_kwqe_init2 init2;
+        struct fcoe_kwqe_init3 init3;
+        struct fcoe_kwqe_conn_offload1 conn_offload1;
+        struct fcoe_kwqe_conn_offload2 conn_offload2;
+        struct fcoe_kwqe_conn_offload3 conn_offload3;
+        struct fcoe_kwqe_conn_offload4 conn_offload4;
+        struct fcoe_kwqe_conn_enable_disable conn_enable_disable;
+        struct fcoe_kwqe_conn_destroy conn_destroy;
+        struct fcoe_kwqe_destroy destroy;
+        struct fcoe_kwqe_stat statistics;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ * TX SGL context $$KEEP_ENDIANNESS$$
+ */
+union fcoe_sgl_union_ctx {
+        struct fcoe_cached_sge_ctx cached_sge;
+        struct fcoe_ext_mul_sges_ctx sgl;
+        __le32 opaque[5];
+};
+
+/*
+ * Data-In/ELS/BLS information $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_read_flow_info {
+        union fcoe_sgl_union_ctx sgl_ctx;
+        __le32 rsrv0[3];
+};
+
+
+/*
+ * Fcoe stat context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_s_stat_ctx {
+        u8 flags;
+#define FCOE_S_STAT_CTX_ACTIVE (0x1<<0)
+#define FCOE_S_STAT_CTX_ACTIVE_SHIFT 0
+#define FCOE_S_STAT_CTX_ACK_ABORT_SEQ_COND (0x1<<1)
+#define FCOE_S_STAT_CTX_ACK_ABORT_SEQ_COND_SHIFT 1
+#define FCOE_S_STAT_CTX_ABTS_PERFORMED (0x1<<2)
+#define FCOE_S_STAT_CTX_ABTS_PERFORMED_SHIFT 2
+#define FCOE_S_STAT_CTX_SEQ_TIMEOUT (0x1<<3)
+#define FCOE_S_STAT_CTX_SEQ_TIMEOUT_SHIFT 3
+#define FCOE_S_STAT_CTX_P_RJT (0x1<<4)
+#define FCOE_S_STAT_CTX_P_RJT_SHIFT 4
+#define FCOE_S_STAT_CTX_ACK_EOFT (0x1<<5)
+#define FCOE_S_STAT_CTX_ACK_EOFT_SHIFT 5
+#define FCOE_S_STAT_CTX_RSRV1 (0x3<<6)
+#define FCOE_S_STAT_CTX_RSRV1_SHIFT 6
+};
+
+/*
+ * Fcoe rx seq context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_rx_seq_ctx {
+        u8 seq_id;
+        struct fcoe_s_stat_ctx s_stat;
+        __le16 seq_cnt;
+        __le32 low_exp_ro;
+        __le32 high_exp_ro;
+};
+
+
+/*
+ * Fcoe rx_wr union context $$KEEP_ENDIANNESS$$
+ */
+union fcoe_rx_wr_union_ctx {
+        struct fcoe_read_flow_info read_info;
+        union fcoe_comp_flow_info comp_info;
+        __le32 opaque[8];
+};
+
+
+
+/*
+ * FCoE SQ element $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_sqe {
+        __le16 wqe;
+#define FCOE_SQE_TASK_ID (0x7FFF<<0)
+#define FCOE_SQE_TASK_ID_SHIFT 0
+#define FCOE_SQE_TOGGLE_BIT (0x1<<15)
+#define FCOE_SQE_TOGGLE_BIT_SHIFT 15
+};
+
+
+
+/*
+ * 14 regs $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_tx_only {
+        union fcoe_sgl_union_ctx sgl_ctx;
+        __le32 rsrv0;
+};
+
+/*
+ * 32 bytes (8 regs) used for TX only purposes $$KEEP_ENDIANNESS$$
+ */
+union fcoe_tx_wr_rx_rd_union_ctx {
+        struct fcoe_fc_frame tx_frame;
+        struct fcoe_fcp_cmd_payload fcp_cmd;
+        struct fcoe_ext_cleanup_info cleanup;
+        struct fcoe_ext_abts_info abts;
+        struct fcoe_ext_fw_tx_seq_ctx tx_seq;
+        __le32 opaque[8];
+};
+
+/*
+ * tce_tx_wr_rx_rd_const $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_tx_wr_rx_rd_const {
+        u8 init_flags;
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE (0x7<<0)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT 0
+#define FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE (0x1<<3)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT 3
+#define FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE (0x1<<4)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE_SHIFT 4
+#define FCOE_TCE_TX_WR_RX_RD_CONST_CACHED_SGE (0x3<<5)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_CACHED_SGE_SHIFT 5
+#define FCOE_TCE_TX_WR_RX_RD_CONST_SUPPORT_REC_TOV (0x1<<7)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_SUPPORT_REC_TOV_SHIFT 7
+        u8 tx_flags;
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_VALID (0x1<<0)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_VALID_SHIFT 0
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_STATE (0xF<<1)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_STATE_SHIFT 1
+#define FCOE_TCE_TX_WR_RX_RD_CONST_RSRV1 (0x1<<5)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_RSRV1_SHIFT 5
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_SEQ_INIT (0x1<<6)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_SEQ_INIT_SHIFT 6
+#define FCOE_TCE_TX_WR_RX_RD_CONST_RSRV2 (0x1<<7)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_RSRV2_SHIFT 7
+        __le16 rsrv3;
+        __le32 verify_tx_seq;
+};
+
+/*
+ * tce_tx_wr_rx_rd $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_tx_wr_rx_rd {
+        union fcoe_tx_wr_rx_rd_union_ctx union_ctx;
+        struct fcoe_tce_tx_wr_rx_rd_const const_ctx;
+};
+
+/*
+ * tce_rx_wr_tx_rd_const $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_rx_wr_tx_rd_const {
+        __le32 data_2_trns;
+        __le32 init_flags;
+#define FCOE_TCE_RX_WR_TX_RD_CONST_CID (0xFFFFFF<<0)
+#define FCOE_TCE_RX_WR_TX_RD_CONST_CID_SHIFT 0
+#define FCOE_TCE_RX_WR_TX_RD_CONST_RSRV0 (0xFF<<24)
+#define FCOE_TCE_RX_WR_TX_RD_CONST_RSRV0_SHIFT 24
+};
+
+/*
+ * tce_rx_wr_tx_rd_var $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_rx_wr_tx_rd_var {
+        __le16 rx_flags;
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RSRV1 (0xF<<0)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RSRV1_SHIFT 0
+#define FCOE_TCE_RX_WR_TX_RD_VAR_NUM_RQ_WQE (0x7<<4)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_NUM_RQ_WQE_SHIFT 4
+#define FCOE_TCE_RX_WR_TX_RD_VAR_CONF_REQ (0x1<<7)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_CONF_REQ_SHIFT 7
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_STATE (0xF<<8)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_STATE_SHIFT 8
+#define FCOE_TCE_RX_WR_TX_RD_VAR_EXP_FIRST_FRAME (0x1<<12)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_EXP_FIRST_FRAME_SHIFT 12
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_SEQ_INIT (0x1<<13)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_SEQ_INIT_SHIFT 13
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RSRV2 (0x1<<14)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RSRV2_SHIFT 14
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_VALID (0x1<<15)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_VALID_SHIFT 15
+        __le16 rx_id;
+        struct fcoe_fcp_xfr_rdy_payload fcp_xfr_rdy;
+};
+
+/*
+ * tce_rx_wr_tx_rd $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_rx_wr_tx_rd {
+        struct fcoe_tce_rx_wr_tx_rd_const const_ctx;
+        struct fcoe_tce_rx_wr_tx_rd_var var_ctx;
+};
+
+/*
+ * tce_rx_only $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_rx_only {
+        struct fcoe_rx_seq_ctx rx_seq_ctx;
+        union fcoe_rx_wr_union_ctx union_ctx;
+};
+
+/*
+ * task_ctx_entry $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_task_ctx_entry {
+        struct fcoe_tce_tx_only txwr_only;
+        struct fcoe_tce_tx_wr_rx_rd txwr_rxrd;
+        struct fcoe_tce_rx_wr_tx_rd rxwr_txrd;
+        struct fcoe_tce_rx_only rxwr_only;
+};
+
+
+
+
+
+
+
+
+
+
+/*
+ * FCoE XFRQ element $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_xfrqe {
+        __le16 wqe;
+#define FCOE_XFRQE_TASK_ID (0x7FFF<<0)
+#define FCOE_XFRQE_TASK_ID_SHIFT 0
+#define FCOE_XFRQE_TOGGLE_BIT (0x1<<15)
+#define FCOE_XFRQE_TOGGLE_BIT_SHIFT 15
+};
+
+
+/*
+ * Cached SGEs $$KEEP_ENDIANNESS$$
+ */
+struct common_fcoe_sgl {
+        struct fcoe_bd_ctx sge[3];
+};
+
+
+/*
+ * FCoE SQ\XFRQ element
+ */
+struct fcoe_cached_wqe {
+        struct fcoe_sqe sqe;
+        struct fcoe_xfrqe xfrqe;
+};
+
+
+/*
+ * FCoE connection enable\disable params passed by driver to FW in FCoE enable
+ * ramrod $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_conn_enable_disable_ramrod_params {
+        struct fcoe_kwqe_conn_enable_disable enable_disable_kwqe;
+};
+
+
+/*
+ * FCoE connection offload params passed by driver to FW in FCoE offload ramrod
+ * $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_conn_offload_ramrod_params {
+        struct fcoe_kwqe_conn_offload1 offload_kwqe1;
+        struct fcoe_kwqe_conn_offload2 offload_kwqe2;
+        struct fcoe_kwqe_conn_offload3 offload_kwqe3;
+        struct fcoe_kwqe_conn_offload4 offload_kwqe4;
+};
+
+
+struct ustorm_fcoe_mng_ctx {
+#if defined(__BIG_ENDIAN)
+        u8 mid_seq_proc_flag;
+        u8 tce_in_cam_flag;
+        u8 tce_on_ior_flag;
+        u8 en_cached_tce_flag;
+#elif defined(__LITTLE_ENDIAN)
+        u8 en_cached_tce_flag;
+        u8 tce_on_ior_flag;
+        u8 tce_in_cam_flag;
+        u8 mid_seq_proc_flag;
+#endif
+#if defined(__BIG_ENDIAN)
+        u8 tce_cam_addr;
+        u8 cached_conn_flag;
+        u16 rsrv0;
+#elif defined(__LITTLE_ENDIAN)
+        u16 rsrv0;
+        u8 cached_conn_flag;
+        u8 tce_cam_addr;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 dma_tce_ram_addr;
+        u16 tce_ram_addr;
+#elif defined(__LITTLE_ENDIAN)
+        u16 tce_ram_addr;
+        u16 dma_tce_ram_addr;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 ox_id;
+        u16 wr_done_seq;
+#elif defined(__LITTLE_ENDIAN)
+        u16 wr_done_seq;
+        u16 ox_id;
+#endif
+        struct regpair task_addr;
+};
+
+/*
+ * Parameters initialized during offloaded according to FLOGI/PLOGI/PRLI and
+ * used in FCoE context section
+ */
+struct ustorm_fcoe_params {
+#if defined(__BIG_ENDIAN)
+        u16 fcoe_conn_id;
+        u16 flags;
+#define USTORM_FCOE_PARAMS_B_MUL_N_PORT_IDS (0x1<<0)
+#define USTORM_FCOE_PARAMS_B_MUL_N_PORT_IDS_SHIFT 0
+#define USTORM_FCOE_PARAMS_B_E_D_TOV_RES (0x1<<1)
+#define USTORM_FCOE_PARAMS_B_E_D_TOV_RES_SHIFT 1
+#define USTORM_FCOE_PARAMS_B_CONT_INCR_SEQ_CNT (0x1<<2)
+#define USTORM_FCOE_PARAMS_B_CONT_INCR_SEQ_CNT_SHIFT 2
+#define USTORM_FCOE_PARAMS_B_CONF_REQ (0x1<<3)
+#define USTORM_FCOE_PARAMS_B_CONF_REQ_SHIFT 3
+#define USTORM_FCOE_PARAMS_B_REC_VALID (0x1<<4)
+#define USTORM_FCOE_PARAMS_B_REC_VALID_SHIFT 4
+#define USTORM_FCOE_PARAMS_B_CQ_TOGGLE_BIT (0x1<<5)
+#define USTORM_FCOE_PARAMS_B_CQ_TOGGLE_BIT_SHIFT 5
+#define USTORM_FCOE_PARAMS_B_XFRQ_TOGGLE_BIT (0x1<<6)
+#define USTORM_FCOE_PARAMS_B_XFRQ_TOGGLE_BIT_SHIFT 6
+#define USTORM_FCOE_PARAMS_RSRV0 (0x1FF<<7)
+#define USTORM_FCOE_PARAMS_RSRV0_SHIFT 7
+#elif defined(__LITTLE_ENDIAN)
+        u16 flags;
+#define USTORM_FCOE_PARAMS_B_MUL_N_PORT_IDS (0x1<<0)
+#define USTORM_FCOE_PARAMS_B_MUL_N_PORT_IDS_SHIFT 0
+#define USTORM_FCOE_PARAMS_B_E_D_TOV_RES (0x1<<1)
+#define USTORM_FCOE_PARAMS_B_E_D_TOV_RES_SHIFT 1
+#define USTORM_FCOE_PARAMS_B_CONT_INCR_SEQ_CNT (0x1<<2)
+#define USTORM_FCOE_PARAMS_B_CONT_INCR_SEQ_CNT_SHIFT 2
+#define USTORM_FCOE_PARAMS_B_CONF_REQ (0x1<<3)
+#define USTORM_FCOE_PARAMS_B_CONF_REQ_SHIFT 3
+#define USTORM_FCOE_PARAMS_B_REC_VALID (0x1<<4)
+#define USTORM_FCOE_PARAMS_B_REC_VALID_SHIFT 4
+#define USTORM_FCOE_PARAMS_B_CQ_TOGGLE_BIT (0x1<<5)
+#define USTORM_FCOE_PARAMS_B_CQ_TOGGLE_BIT_SHIFT 5
+#define USTORM_FCOE_PARAMS_B_XFRQ_TOGGLE_BIT (0x1<<6)
+#define USTORM_FCOE_PARAMS_B_XFRQ_TOGGLE_BIT_SHIFT 6
+#define USTORM_FCOE_PARAMS_RSRV0 (0x1FF<<7)
+#define USTORM_FCOE_PARAMS_RSRV0_SHIFT 7
+        u16 fcoe_conn_id;
+#endif
+#if defined(__BIG_ENDIAN)
+        u8 hc_csdm_byte_en;
+        u8 func_id;
+        u8 port_id;
+        u8 vnic_id;
+#elif defined(__LITTLE_ENDIAN)
+        u8 vnic_id;
+        u8 port_id;
+        u8 func_id;
+        u8 hc_csdm_byte_en;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 rx_total_conc_seqs;
+        u16 rx_max_fc_pay_len;
+#elif defined(__LITTLE_ENDIAN)
+        u16 rx_max_fc_pay_len;
+        u16 rx_total_conc_seqs;
+#endif
+#if defined(__BIG_ENDIAN)
+        u8 task_pbe_idx_off;
+        u8 task_in_page_log_size;
+        u16 rx_max_conc_seqs;
+#elif defined(__LITTLE_ENDIAN)
+        u16 rx_max_conc_seqs;
+        u8 task_in_page_log_size;
+        u8 task_pbe_idx_off;
+#endif
+};
+
+/*
+ * FCoE 16-bits index structure
+ */
+struct fcoe_idx16_fields {
+        u16 fields;
+#define FCOE_IDX16_FIELDS_IDX (0x7FFF<<0)
+#define FCOE_IDX16_FIELDS_IDX_SHIFT 0
+#define FCOE_IDX16_FIELDS_MSB (0x1<<15)
+#define FCOE_IDX16_FIELDS_MSB_SHIFT 15
+};
+
+/*
+ * FCoE 16-bits index union
+ */
+union fcoe_idx16_field_union {
+        struct fcoe_idx16_fields fields;
+        u16 val;
+};
+
+/*
+ * Parameters required for placement according to SGL
+ */
+struct ustorm_fcoe_data_place_mng {
+#if defined(__BIG_ENDIAN)
+        u16 sge_off;
+        u8 num_sges;
+        u8 sge_idx;
+#elif defined(__LITTLE_ENDIAN)
+        u8 sge_idx;
+        u8 num_sges;
+        u16 sge_off;
+#endif
+};
+
+/*
+ * Parameters required for placement according to SGL
+ */
+struct ustorm_fcoe_data_place {
+        struct ustorm_fcoe_data_place_mng cached_mng;
+        struct fcoe_bd_ctx cached_sge[2];
+};
+
+/*
+ * TX processing shall write and RX processing shall read from this section
+ */
+union fcoe_u_tce_tx_wr_rx_rd_union {
+        struct fcoe_abts_info abts;
+        struct fcoe_cleanup_info cleanup;
+        struct fcoe_fw_tx_seq_ctx tx_seq_ctx;
+        u32 opaque[2];
+};
+
+/*
+ * TX processing shall write and RX processing shall read from this section
+ */
+struct fcoe_u_tce_tx_wr_rx_rd {
+        union fcoe_u_tce_tx_wr_rx_rd_union union_ctx;
+        struct fcoe_tce_tx_wr_rx_rd_const const_ctx;
+};
+
+struct ustorm_fcoe_tce {
+        struct fcoe_u_tce_tx_wr_rx_rd txwr_rxrd;
+        struct fcoe_tce_rx_wr_tx_rd rxwr_txrd;
+        struct fcoe_tce_rx_only rxwr;
+};
+
+struct ustorm_fcoe_cache_ctx {
+        u32 rsrv0;
+        struct ustorm_fcoe_data_place data_place;
+        struct ustorm_fcoe_tce tce;
+};
+
+/*
+ * Ustorm FCoE Storm Context
+ */
+struct ustorm_fcoe_st_context {
+        struct ustorm_fcoe_mng_ctx mng_ctx;
+        struct ustorm_fcoe_params fcoe_params;
+        struct regpair cq_base_addr;
+        struct regpair rq_pbl_base;
+        struct regpair rq_cur_page_addr;
+        struct regpair confq_pbl_base_addr;
+        struct regpair conn_db_base;
+        struct regpair xfrq_base_addr;
+        struct regpair lcq_base_addr;
+#if defined(__BIG_ENDIAN)
+        union fcoe_idx16_field_union rq_cons;
+        union fcoe_idx16_field_union rq_prod;
+#elif defined(__LITTLE_ENDIAN)
+        union fcoe_idx16_field_union rq_prod;
+        union fcoe_idx16_field_union rq_cons;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 xfrq_prod;
         u16 cq_cons;
 #elif defined(__LITTLE_ENDIAN)
         u16 cq_cons;
-        u16 cq_prod;
+        u16 xfrq_prod;
 #endif
 #if defined(__BIG_ENDIAN)
-        u16 __reserved2;
-        u8 decision_rules;
-#define USTORM_FCOE_AG_CONTEXT_CQ_DEC_RULE (0x7<<0)
-#define USTORM_FCOE_AG_CONTEXT_CQ_DEC_RULE_SHIFT 0
-#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL3_RULE (0x7<<3)
-#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL3_RULE_SHIFT 3
-#define USTORM_FCOE_AG_CONTEXT_CQ_ARM_N_FLAG (0x1<<6)
-#define USTORM_FCOE_AG_CONTEXT_CQ_ARM_N_FLAG_SHIFT 6
-#define __USTORM_FCOE_AG_CONTEXT_RESERVED1 (0x1<<7)
-#define __USTORM_FCOE_AG_CONTEXT_RESERVED1_SHIFT 7
-        u8 decision_rule_enable_bits;
-#define __USTORM_FCOE_AG_CONTEXT_RESERVED_INV_CF_EN (0x1<<0)
-#define __USTORM_FCOE_AG_CONTEXT_RESERVED_INV_CF_EN_SHIFT 0
-#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_EN (0x1<<1)
-#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_EN_SHIFT 1
-#define USTORM_FCOE_AG_CONTEXT_TX_CF_EN (0x1<<2)
-#define USTORM_FCOE_AG_CONTEXT_TX_CF_EN_SHIFT 2
-#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_EN (0x1<<3)
-#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_EN_SHIFT 3
-#define __USTORM_FCOE_AG_CONTEXT_AUX1_CF_EN (0x1<<4)
-#define __USTORM_FCOE_AG_CONTEXT_AUX1_CF_EN_SHIFT 4
-#define __USTORM_FCOE_AG_CONTEXT_QUEUE0_CF_EN (0x1<<5)
-#define __USTORM_FCOE_AG_CONTEXT_QUEUE0_CF_EN_SHIFT 5
-#define __USTORM_FCOE_AG_CONTEXT_AUX3_CF_EN (0x1<<6)
-#define __USTORM_FCOE_AG_CONTEXT_AUX3_CF_EN_SHIFT 6
-#define __USTORM_FCOE_AG_CONTEXT_DQ_CF_EN (0x1<<7)
-#define __USTORM_FCOE_AG_CONTEXT_DQ_CF_EN_SHIFT 7
+        u16 lcq_cons;
+        u16 hc_cram_address;
 #elif defined(__LITTLE_ENDIAN)
-        u8 decision_rule_enable_bits;
-#define __USTORM_FCOE_AG_CONTEXT_RESERVED_INV_CF_EN (0x1<<0)
-#define __USTORM_FCOE_AG_CONTEXT_RESERVED_INV_CF_EN_SHIFT 0
-#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_EN (0x1<<1)
-#define USTORM_FCOE_AG_CONTEXT_COMPLETION_CF_EN_SHIFT 1
-#define USTORM_FCOE_AG_CONTEXT_TX_CF_EN (0x1<<2)
-#define USTORM_FCOE_AG_CONTEXT_TX_CF_EN_SHIFT 2
-#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_EN (0x1<<3)
-#define __USTORM_FCOE_AG_CONTEXT_TIMER_CF_EN_SHIFT 3
-#define __USTORM_FCOE_AG_CONTEXT_AUX1_CF_EN (0x1<<4)
-#define __USTORM_FCOE_AG_CONTEXT_AUX1_CF_EN_SHIFT 4
-#define __USTORM_FCOE_AG_CONTEXT_QUEUE0_CF_EN (0x1<<5)
-#define __USTORM_FCOE_AG_CONTEXT_QUEUE0_CF_EN_SHIFT 5
-#define __USTORM_FCOE_AG_CONTEXT_AUX3_CF_EN (0x1<<6)
-#define __USTORM_FCOE_AG_CONTEXT_AUX3_CF_EN_SHIFT 6
-#define __USTORM_FCOE_AG_CONTEXT_DQ_CF_EN (0x1<<7)
-#define __USTORM_FCOE_AG_CONTEXT_DQ_CF_EN_SHIFT 7
-        u8 decision_rules;
-#define USTORM_FCOE_AG_CONTEXT_CQ_DEC_RULE (0x7<<0)
-#define USTORM_FCOE_AG_CONTEXT_CQ_DEC_RULE_SHIFT 0
-#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL3_RULE (0x7<<3)
-#define __USTORM_FCOE_AG_CONTEXT_AGG_VAL3_RULE_SHIFT 3
-#define USTORM_FCOE_AG_CONTEXT_CQ_ARM_N_FLAG (0x1<<6)
-#define USTORM_FCOE_AG_CONTEXT_CQ_ARM_N_FLAG_SHIFT 6
-#define __USTORM_FCOE_AG_CONTEXT_RESERVED1 (0x1<<7)
-#define __USTORM_FCOE_AG_CONTEXT_RESERVED1_SHIFT 7
-        u16 __reserved2;
+        u16 hc_cram_address;
+        u16 lcq_cons;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 sq_xfrq_lcq_confq_size;
+        u16 confq_prod;
+#elif defined(__LITTLE_ENDIAN)
+        u16 confq_prod;
+        u16 sq_xfrq_lcq_confq_size;
+#endif
+#if defined(__BIG_ENDIAN)
+        u8 hc_csdm_agg_int;
+        u8 rsrv2;
+        u8 available_rqes;
+        u8 sp_q_flush_cnt;
+#elif defined(__LITTLE_ENDIAN)
+        u8 sp_q_flush_cnt;
+        u8 available_rqes;
+        u8 rsrv2;
+        u8 hc_csdm_agg_int;
 #endif
+#if defined(__BIG_ENDIAN)
+        u16 num_pend_tasks;
+        u16 pbf_ack_ram_addr;
+#elif defined(__LITTLE_ENDIAN)
+        u16 pbf_ack_ram_addr;
+        u16 num_pend_tasks;
+#endif
+        struct ustorm_fcoe_cache_ctx cache_ctx;
+};
+
+/*
+ * The FCoE non-aggregative context of Tstorm
+ */
+struct tstorm_fcoe_st_context {
+        struct regpair reserved0;
+        struct regpair reserved1;
 };
 
 /*
@@ -2023,86 +3470,106 @@ struct xstorm_fcoe_context_flags {
 #define XSTORM_FCOE_CONTEXT_FLAGS_B_PROC_Q_SHIFT 0
 #define XSTORM_FCOE_CONTEXT_FLAGS_B_MID_SEQ (0x1<<2)
 #define XSTORM_FCOE_CONTEXT_FLAGS_B_MID_SEQ_SHIFT 2
-#define XSTORM_FCOE_CONTEXT_FLAGS_B_EXCHANGE_CLEANUP_DEFFERED (0x1<<3)
-#define XSTORM_FCOE_CONTEXT_FLAGS_B_EXCHANGE_CLEANUP_DEFFERED_SHIFT 3
+#define XSTORM_FCOE_CONTEXT_FLAGS_B_BLOCK_SQ (0x1<<3)
+#define XSTORM_FCOE_CONTEXT_FLAGS_B_BLOCK_SQ_SHIFT 3
 #define XSTORM_FCOE_CONTEXT_FLAGS_B_REC_SUPPORT (0x1<<4)
 #define XSTORM_FCOE_CONTEXT_FLAGS_B_REC_SUPPORT_SHIFT 4
 #define XSTORM_FCOE_CONTEXT_FLAGS_B_SQ_TOGGLE (0x1<<5)
 #define XSTORM_FCOE_CONTEXT_FLAGS_B_SQ_TOGGLE_SHIFT 5
 #define XSTORM_FCOE_CONTEXT_FLAGS_B_XFRQ_TOGGLE (0x1<<6)
 #define XSTORM_FCOE_CONTEXT_FLAGS_B_XFRQ_TOGGLE_SHIFT 6
-#define XSTORM_FCOE_CONTEXT_FLAGS_B_ABTS_DEFFERED (0x1<<7)
-#define XSTORM_FCOE_CONTEXT_FLAGS_B_ABTS_DEFFERED_SHIFT 7
+#define XSTORM_FCOE_CONTEXT_FLAGS_B_VNTAG_VLAN (0x1<<7)
+#define XSTORM_FCOE_CONTEXT_FLAGS_B_VNTAG_VLAN_SHIFT 7
 };
 
-/*
- * FCoE SQ element
- */
-struct fcoe_sqe {
-        u16 wqe;
-#define FCOE_SQE_TASK_ID (0x7FFF<<0)
-#define FCOE_SQE_TASK_ID_SHIFT 0
-#define FCOE_SQE_TOGGLE_BIT (0x1<<15)
-#define FCOE_SQE_TOGGLE_BIT_SHIFT 15
-};
-
-/*
- * FCoE XFRQ element
- */
-struct fcoe_xfrqe {
-        u16 wqe;
-#define FCOE_XFRQE_TASK_ID (0x7FFF<<0)
-#define FCOE_XFRQE_TASK_ID_SHIFT 0
-#define FCOE_XFRQE_TOGGLE_BIT (0x1<<15)
-#define FCOE_XFRQE_TOGGLE_BIT_SHIFT 15
+struct xstorm_fcoe_tce {
+        struct fcoe_tce_tx_only txwr;
+        struct fcoe_tce_tx_wr_rx_rd txwr_rxrd;
 };
 
 /*
- * FCoE SQ\XFRQ element
+ * FCP_DATA parameters required for transmission
  */
-struct fcoe_cached_wqe {
+struct xstorm_fcoe_fcp_data {
+        u32 io_rem;
 #if defined(__BIG_ENDIAN)
-        struct fcoe_xfrqe xfrqe;
-        struct fcoe_sqe sqe;
+        u16 cached_sge_off;
+        u8 cached_num_sges;
+        u8 cached_sge_idx;
 #elif defined(__LITTLE_ENDIAN)
-        struct fcoe_sqe sqe;
-        struct fcoe_xfrqe xfrqe;
+        u8 cached_sge_idx;
+        u8 cached_num_sges;
+        u16 cached_sge_off;
+#endif
+        u32 buf_addr_hi_0;
+        u32 buf_addr_lo_0;
+#if defined(__BIG_ENDIAN)
+        u16 num_of_pending_tasks;
+        u16 buf_len_0;
+#elif defined(__LITTLE_ENDIAN)
+        u16 buf_len_0;
+        u16 num_of_pending_tasks;
+#endif
+        u32 buf_addr_hi_1;
+        u32 buf_addr_lo_1;
+#if defined(__BIG_ENDIAN)
+        u16 task_pbe_idx_off;
+        u16 buf_len_1;
+#elif defined(__LITTLE_ENDIAN)
+        u16 buf_len_1;
+        u16 task_pbe_idx_off;
+#endif
+        u32 buf_addr_hi_2;
+        u32 buf_addr_lo_2;
+#if defined(__BIG_ENDIAN)
+        u16 ox_id;
+        u16 buf_len_2;
+#elif defined(__LITTLE_ENDIAN)
+        u16 buf_len_2;
+        u16 ox_id;
 #endif
 };
 
-struct fcoe_task_ctx_entry_tx_only {
-        union fcoe_sgl_ctx sgl_ctx;
+/*
+ * vlan configuration
+ */
+struct xstorm_fcoe_vlan_conf {
+        u8 vlan_conf;
+#define XSTORM_FCOE_VLAN_CONF_PRIORITY (0x7<<0)
+#define XSTORM_FCOE_VLAN_CONF_PRIORITY_SHIFT 0
+#define XSTORM_FCOE_VLAN_CONF_INNER_VLAN_FLAG (0x1<<3)
+#define XSTORM_FCOE_VLAN_CONF_INNER_VLAN_FLAG_SHIFT 3
+#define XSTORM_FCOE_VLAN_CONF_RESERVED (0xF<<4)
+#define XSTORM_FCOE_VLAN_CONF_RESERVED_SHIFT 4
 };
 
-struct xstorm_fcoe_task_ctx_entry_rd {
-        struct fcoe_task_ctx_entry_tx_only tx_wr;
-        struct fcoe_task_ctx_entry_txwr_rxrd tx_wr_rx_rd;
-        struct fcoe_task_ctx_entry_tx_rx_cmn cmn;
-        struct fcoe_task_ctx_entry_rxwr_txrd rx_wr_tx_rd;
+/*
+ * FCoE 16-bits vlan structure
+ */
+struct fcoe_vlan_fields {
+        u16 fields;
+#define FCOE_VLAN_FIELDS_VID (0xFFF<<0)
+#define FCOE_VLAN_FIELDS_VID_SHIFT 0
+#define FCOE_VLAN_FIELDS_CLI (0x1<<12)
+#define FCOE_VLAN_FIELDS_CLI_SHIFT 12
+#define FCOE_VLAN_FIELDS_PRI (0x7<<13)
+#define FCOE_VLAN_FIELDS_PRI_SHIFT 13
 };
 
 /*
- * Cached SGEs
+ * FCoE 16-bits vlan union
  */
-struct common_fcoe_sgl {
-        struct fcoe_bd_ctx sge[2];
+union fcoe_vlan_field_union {
+        struct fcoe_vlan_fields fields;
+        u16 val;
 };
 
 /*
- * FCP_DATA parameters required for transmission
+ * FCoE 16-bits vlan, vif union
  */
-struct xstorm_fcoe_fcp_data {
-        u32 io_rem;
-#if defined(__BIG_ENDIAN)
-        u16 cached_sge_off;
-        u8 cached_num_sges;
-        u8 cached_sge_idx;
-#elif defined(__LITTLE_ENDIAN)
-        u8 cached_sge_idx;
-        u8 cached_num_sges;
-        u16 cached_sge_off;
-#endif
-        struct common_fcoe_sgl cached_sgl;
+union fcoe_vlan_vif_field_union {
+        union fcoe_vlan_field_union vlan;
+        u16 vif;
 };
 
 /*
@@ -2110,18 +3577,18 @@ struct xstorm_fcoe_fcp_data {
  */
 struct xstorm_fcoe_context_section {
 #if defined(__BIG_ENDIAN)
-        u8 vlan_flag;
+        u8 cs_ctl;
         u8 s_id[3];
 #elif defined(__LITTLE_ENDIAN)
         u8 s_id[3];
-        u8 vlan_flag;
+        u8 cs_ctl;
 #endif
 #if defined(__BIG_ENDIAN)
-        u8 func_id;
+        u8 rctl;
         u8 d_id[3];
 #elif defined(__LITTLE_ENDIAN)
         u8 d_id[3];
-        u8 func_id;
+        u8 rctl;
 #endif
 #if defined(__BIG_ENDIAN)
         u16 sq_xfrq_lcq_confq_size;
@@ -2133,56 +3600,84 @@ struct xstorm_fcoe_context_section {
         u32 lcq_prod;
 #if defined(__BIG_ENDIAN)
         u8 port_id;
-        u8 tx_max_conc_seqs_c3;
+        u8 func_id;
         u8 seq_id;
         struct xstorm_fcoe_context_flags tx_flags;
 #elif defined(__LITTLE_ENDIAN)
         struct xstorm_fcoe_context_flags tx_flags;
         u8 seq_id;
-        u8 tx_max_conc_seqs_c3;
+        u8 func_id;
         u8 port_id;
 #endif
 #if defined(__BIG_ENDIAN)
-        u16 verify_tx_seq;
+        u16 mtu;
         u8 func_mode;
         u8 vnic_id;
 #elif defined(__LITTLE_ENDIAN)
         u8 vnic_id;
         u8 func_mode;
-        u16 verify_tx_seq;
+        u16 mtu;
 #endif
         struct regpair confq_curr_page_addr;
         struct fcoe_cached_wqe cached_wqe[8];
         struct regpair lcq_base_addr;
-        struct xstorm_fcoe_task_ctx_entry_rd tce;
+        struct xstorm_fcoe_tce tce;
         struct xstorm_fcoe_fcp_data fcp_data;
 #if defined(__BIG_ENDIAN)
+        u8 tx_max_conc_seqs_c3;
+        u8 vlan_flag;
+        u8 dcb_val;
+        u8 data_pb_cmd_size;
+#elif defined(__LITTLE_ENDIAN)
+        u8 data_pb_cmd_size;
+        u8 dcb_val;
+        u8 vlan_flag;
+        u8 tx_max_conc_seqs_c3;
+#endif
+#if defined(__BIG_ENDIAN)
         u16 fcoe_tx_stat_params_ram_addr;
-        u16 cmng_port_ram_addr;
+        u16 fcoe_tx_fc_seq_ram_addr;
 #elif defined(__LITTLE_ENDIAN)
-        u16 cmng_port_ram_addr;
+        u16 fcoe_tx_fc_seq_ram_addr;
         u16 fcoe_tx_stat_params_ram_addr;
 #endif
 #if defined(__BIG_ENDIAN)
-        u8 fcp_cmd_pb_cmd_size;
+        u8 fcp_cmd_line_credit;
         u8 eth_hdr_size;
         u16 pbf_addr;
 #elif defined(__LITTLE_ENDIAN)
         u16 pbf_addr;
         u8 eth_hdr_size;
-        u8 fcp_cmd_pb_cmd_size;
+        u8 fcp_cmd_line_credit;
 #endif
 #if defined(__BIG_ENDIAN)
-        u8 reserved2[2];
+        union fcoe_vlan_vif_field_union multi_func_val;
+        u8 page_log_size;
+        struct xstorm_fcoe_vlan_conf orig_vlan_conf;
+#elif defined(__LITTLE_ENDIAN)
+        struct xstorm_fcoe_vlan_conf orig_vlan_conf;
+        u8 page_log_size;
+        union fcoe_vlan_vif_field_union multi_func_val;
+#endif
+#if defined(__BIG_ENDIAN)
+        u16 fcp_cmd_frame_size;
+        u16 pbf_addr_ff;
+#elif defined(__LITTLE_ENDIAN)
+        u16 pbf_addr_ff;
+        u16 fcp_cmd_frame_size;
+#endif
+#if defined(__BIG_ENDIAN)
+        u8 vlan_num;
         u8 cos;
-        u8 dcb_version;
+        u8 cache_xfrq_cons;
+        u8 cache_sq_cons;
 #elif defined(__LITTLE_ENDIAN)
-        u8 dcb_version;
+        u8 cache_sq_cons;
+        u8 cache_xfrq_cons;
         u8 cos;
-        u8 reserved2[2];
+        u8 vlan_num;
 #endif
-        u32 reserved3;
-        struct regpair reserved4[2];
+        u32 verify_tx_seq;
 };
 
 /*
@@ -2207,6 +3702,181 @@ struct fcoe_context {
 };
 
 /*
+ * FCoE init params passed by driver to FW in FCoE init ramrod
+ * $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_init_ramrod_params {
+        struct fcoe_kwqe_init1 init_kwqe1;
+        struct fcoe_kwqe_init2 init_kwqe2;
+        struct fcoe_kwqe_init3 init_kwqe3;
+        struct regpair eq_pbl_base;
+        __le32 eq_pbl_size;
+        __le32 reserved2;
+        __le16 eq_prod;
+        __le16 sb_num;
+        u8 sb_id;
+        u8 reserved0;
+        __le16 reserved1;
+};
+
+/*
+ * FCoE statistics params buffer passed by driver to FW in FCoE statistics
+ * ramrod $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_stat_ramrod_params {
+        struct fcoe_kwqe_stat stat_kwqe;
+};
+
+/*
+ * CQ DB CQ producer and pending completion counter
+ */
+struct iscsi_cq_db_prod_pnd_cmpltn_cnt {
+#if defined(__BIG_ENDIAN)
+        u16 cntr;
+        u16 prod;
+#elif defined(__LITTLE_ENDIAN)
+        u16 prod;
+        u16 cntr;
+#endif
+};
+
+/*
+ * CQ DB pending completion ITT array
+ */
+struct iscsi_cq_db_prod_pnd_cmpltn_cnt_arr {
+        struct iscsi_cq_db_prod_pnd_cmpltn_cnt prod_pend_comp[8];
+};
+
+/*
+ * Cstorm CQ sequence to notify array, updated by driver
+ */
+struct iscsi_cq_db_sqn_2_notify_arr {
+        u16 sqn[8];
+};
+
+/*
+ * Cstorm iSCSI Storm Context
+ */
+struct cstorm_iscsi_st_context {
+        struct iscsi_cq_db_prod_pnd_cmpltn_cnt_arr cq_c_prod_pend_comp_ctr_arr;
+        struct iscsi_cq_db_sqn_2_notify_arr cq_c_prod_sqn_arr;
+        struct iscsi_cq_db_sqn_2_notify_arr cq_c_sqn_2_notify_arr;
+        struct regpair hq_pbl_base;
+        struct regpair hq_curr_pbe;
+        struct regpair task_pbl_base;
+        struct regpair cq_db_base;
+#if defined(__BIG_ENDIAN)
+        u16 hq_bd_itt;
+        u16 iscsi_conn_id;
+#elif defined(__LITTLE_ENDIAN)
+        u16 iscsi_conn_id;
+        u16 hq_bd_itt;
+#endif
+        u32 hq_bd_data_segment_len;
+        u32 hq_bd_buffer_offset;
+#if defined(__BIG_ENDIAN)
+        u8 rsrv;
+        u8 cq_proc_en_bit_map;
+        u8 cq_pend_comp_itt_valid_bit_map;
+        u8 hq_bd_opcode;
+#elif defined(__LITTLE_ENDIAN)
+        u8 hq_bd_opcode;
+        u8 cq_pend_comp_itt_valid_bit_map;
+        u8 cq_proc_en_bit_map;
+        u8 rsrv;
+#endif
+        u32 hq_tcp_seq;
+#if defined(__BIG_ENDIAN)
+        u16 flags;
+#define CSTORM_ISCSI_ST_CONTEXT_DATA_DIGEST_EN (0x1<<0)
+#define CSTORM_ISCSI_ST_CONTEXT_DATA_DIGEST_EN_SHIFT 0
+#define CSTORM_ISCSI_ST_CONTEXT_HDR_DIGEST_EN (0x1<<1)
+#define CSTORM_ISCSI_ST_CONTEXT_HDR_DIGEST_EN_SHIFT 1
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_CTXT_VALID (0x1<<2)
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_CTXT_VALID_SHIFT 2
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_LCL_CMPLN_FLG (0x1<<3)
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_LCL_CMPLN_FLG_SHIFT 3
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_WRITE_TASK (0x1<<4)
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_WRITE_TASK_SHIFT 4
+#define CSTORM_ISCSI_ST_CONTEXT_CTRL_FLAGS_RSRV (0x7FF<<5)
+#define CSTORM_ISCSI_ST_CONTEXT_CTRL_FLAGS_RSRV_SHIFT 5
+        u16 hq_cons;
+#elif defined(__LITTLE_ENDIAN)
+        u16 hq_cons;
+        u16 flags;
+#define CSTORM_ISCSI_ST_CONTEXT_DATA_DIGEST_EN (0x1<<0)
+#define CSTORM_ISCSI_ST_CONTEXT_DATA_DIGEST_EN_SHIFT 0
+#define CSTORM_ISCSI_ST_CONTEXT_HDR_DIGEST_EN (0x1<<1)
+#define CSTORM_ISCSI_ST_CONTEXT_HDR_DIGEST_EN_SHIFT 1
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_CTXT_VALID (0x1<<2)
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_CTXT_VALID_SHIFT 2
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_LCL_CMPLN_FLG (0x1<<3)
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_LCL_CMPLN_FLG_SHIFT 3
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_WRITE_TASK (0x1<<4)
+#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_WRITE_TASK_SHIFT 4
+#define CSTORM_ISCSI_ST_CONTEXT_CTRL_FLAGS_RSRV (0x7FF<<5)
+#define CSTORM_ISCSI_ST_CONTEXT_CTRL_FLAGS_RSRV_SHIFT 5
+#endif
+        struct regpair rsrv1;
+};
+
+
+/*
+ * SCSI read/write SQ WQE
+ */
+struct iscsi_cmd_pdu_hdr_little_endian {
+#if defined(__BIG_ENDIAN)
+        u8 opcode;
+        u8 op_attr;
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_ATTRIBUTES (0x7<<0)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_ATTRIBUTES_SHIFT 0
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_RSRV1 (0x3<<3)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_RSRV1_SHIFT 3
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_WRITE_FLAG (0x1<<5)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_WRITE_FLAG_SHIFT 5
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_READ_FLAG (0x1<<6)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_READ_FLAG_SHIFT 6
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_FINAL_FLAG (0x1<<7)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_FINAL_FLAG_SHIFT 7
+        u16 rsrv0;
+#elif defined(__LITTLE_ENDIAN)
+        u16 rsrv0;
+        u8 op_attr;
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_ATTRIBUTES (0x7<<0)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_ATTRIBUTES_SHIFT 0
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_RSRV1 (0x3<<3)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_RSRV1_SHIFT 3
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_WRITE_FLAG (0x1<<5)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_WRITE_FLAG_SHIFT 5
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_READ_FLAG (0x1<<6)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_READ_FLAG_SHIFT 6
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_FINAL_FLAG (0x1<<7)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_FINAL_FLAG_SHIFT 7
+        u8 opcode;
+#endif
+        u32 data_fields;
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH (0xFFFFFF<<0)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH_SHIFT 0
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH (0xFF<<24)
+#define ISCSI_CMD_PDU_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH_SHIFT 24
+        struct regpair lun;
+        u32 itt;
+        u32 expected_data_transfer_length;
+        u32 cmd_sn;
+        u32 exp_stat_sn;
+        u32 scsi_command_block[4];
+};
+
+
+/*
+ * Buffer per connection, used in Tstorm
+ */
+struct iscsi_conn_buf {
+        struct regpair reserved[8];
+};
+
+
+/*
  * iSCSI context region, used only in iSCSI
  */
 struct ustorm_iscsi_rq_db {
@@ -2271,11 +3941,13 @@ struct ustorm_iscsi_placement_db {
         u32 local_sge_1_address_hi;
         u32 local_sge_1_address_lo;
 #if defined(__BIG_ENDIAN)
-        u16 reserved6;
+        u8 exp_padding_2b;
+        u8 nal_len_3b;
         u16 local_sge_1_size;
 #elif defined(__LITTLE_ENDIAN)
         u16 local_sge_1_size;
-        u16 reserved6;
+        u8 nal_len_3b;
+        u8 exp_padding_2b;
 #endif
 #if defined(__BIG_ENDIAN)
         u8 sgl_size;
@@ -2300,12 +3972,8 @@ struct ustorm_iscsi_placement_db {
         u32 nal;
 #define USTORM_ISCSI_PLACEMENT_DB_REM_SGE_SIZE (0xFFFFFF<<0)
 #define USTORM_ISCSI_PLACEMENT_DB_REM_SGE_SIZE_SHIFT 0
-#define USTORM_ISCSI_PLACEMENT_DB_EXP_PADDING_2B (0x3<<24)
-#define USTORM_ISCSI_PLACEMENT_DB_EXP_PADDING_2B_SHIFT 24
-#define USTORM_ISCSI_PLACEMENT_DB_EXP_DIGEST_3B (0x7<<26)
-#define USTORM_ISCSI_PLACEMENT_DB_EXP_DIGEST_3B_SHIFT 26
-#define USTORM_ISCSI_PLACEMENT_DB_NAL_LEN_3B (0x7<<29)
-#define USTORM_ISCSI_PLACEMENT_DB_NAL_LEN_3B_SHIFT 29
+#define USTORM_ISCSI_PLACEMENT_DB_EXP_DIGEST_3B (0xFF<<24)
+#define USTORM_ISCSI_PLACEMENT_DB_EXP_DIGEST_3B_SHIFT 24
 };
 
 /*
@@ -2509,7 +4177,13 @@ struct tstorm_tcp_st_context_section {
         u16 vlan_id;
         u16 lsb_mac_address;
 #endif
-        u32 msb_mac_address;
+#if defined(__BIG_ENDIAN)
+        u16 msb_mac_address;
+        u16 mid_mac_address;
+#elif defined(__LITTLE_ENDIAN)
+        u16 mid_mac_address;
+        u16 msb_mac_address;
+#endif
         u32 rightmost_received_seq;
 };
 
@@ -2534,13 +4208,7 @@ struct iscsi_term_vars {
  * iSCSI context region, used only in iSCSI
  */
 struct tstorm_iscsi_st_context_section {
-#if defined(__BIG_ENDIAN)
-        u16 rem_tcp_data_len;
-        u16 brb_offset;
-#elif defined(__LITTLE_ENDIAN)
-        u16 brb_offset;
-        u16 rem_tcp_data_len;
-#endif
+        u32 nalPayload;
         u32 b2nh;
 #if defined(__BIG_ENDIAN)
         u16 rq_cons;
@@ -2555,8 +4223,10 @@ struct tstorm_iscsi_st_context_section {
 #define TSTORM_ISCSI_ST_CONTEXT_SECTION_B_FULL_FEATURE_SHIFT 3
 #define TSTORM_ISCSI_ST_CONTEXT_SECTION_B_DROP_ALL_PDUS (0x1<<4)
 #define TSTORM_ISCSI_ST_CONTEXT_SECTION_B_DROP_ALL_PDUS_SHIFT 4
-#define TSTORM_ISCSI_ST_CONTEXT_SECTION_FLAGS_RSRV (0x7<<5)
-#define TSTORM_ISCSI_ST_CONTEXT_SECTION_FLAGS_RSRV_SHIFT 5
+#define TSTORM_ISCSI_ST_CONTEXT_SECTION_NALLEN (0x3<<5)
+#define TSTORM_ISCSI_ST_CONTEXT_SECTION_NALLEN_SHIFT 5
+#define TSTORM_ISCSI_ST_CONTEXT_SECTION_RSRV0 (0x1<<7)
+#define TSTORM_ISCSI_ST_CONTEXT_SECTION_RSRV0_SHIFT 7
         u8 hdr_bytes_2_fetch;
 #elif defined(__LITTLE_ENDIAN)
         u8 hdr_bytes_2_fetch;
@@ -2571,18 +4241,20 @@ struct tstorm_iscsi_st_context_section {
 #define TSTORM_ISCSI_ST_CONTEXT_SECTION_B_FULL_FEATURE_SHIFT 3
 #define TSTORM_ISCSI_ST_CONTEXT_SECTION_B_DROP_ALL_PDUS (0x1<<4)
 #define TSTORM_ISCSI_ST_CONTEXT_SECTION_B_DROP_ALL_PDUS_SHIFT 4
-#define TSTORM_ISCSI_ST_CONTEXT_SECTION_FLAGS_RSRV (0x7<<5)
-#define TSTORM_ISCSI_ST_CONTEXT_SECTION_FLAGS_RSRV_SHIFT 5
+#define TSTORM_ISCSI_ST_CONTEXT_SECTION_NALLEN (0x3<<5)
+#define TSTORM_ISCSI_ST_CONTEXT_SECTION_NALLEN_SHIFT 5
+#define TSTORM_ISCSI_ST_CONTEXT_SECTION_RSRV0 (0x1<<7)
+#define TSTORM_ISCSI_ST_CONTEXT_SECTION_RSRV0_SHIFT 7
         u16 rq_cons;
 #endif
         struct regpair rq_db_phy_addr;
 #if defined(__BIG_ENDIAN)
         struct iscsi_term_vars term_vars;
-        u8 scratchpad_idx;
+        u8 rsrv1;
         u16 iscsi_conn_id;
 #elif defined(__LITTLE_ENDIAN)
         u16 iscsi_conn_id;
-        u8 scratchpad_idx;
+        u8 rsrv1;
         struct iscsi_term_vars term_vars;
 #endif
         u32 process_nxt;
@@ -2597,724 +4269,6 @@ struct tstorm_iscsi_st_context {
 };
 
 /*
- * The tcp aggregative context section of Xstorm
- */
-struct xstorm_tcp_tcp_ag_context_section {
-#if defined(__BIG_ENDIAN)
-        u8 __tcp_agg_vars1;
-        u8 __da_cnt;
-        u16 mss;
-#elif defined(__LITTLE_ENDIAN)
-        u16 mss;
-        u8 __da_cnt;
-        u8 __tcp_agg_vars1;
-#endif
-        u32 snd_nxt;
-        u32 tx_wnd;
-        u32 snd_una;
-        u32 local_adv_wnd;
-#if defined(__BIG_ENDIAN)
-        u8 __agg_val8_th;
-        u8 __agg_val8;
-        u16 tcp_agg_vars2;
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG (0x1<<0)
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_SHIFT 0
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_UNBLOCKED (0x1<<1)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_UNBLOCKED_SHIFT 1
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_TIMER_ACTIVE (0x1<<2)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_TIMER_ACTIVE_SHIFT 2
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_FLAG (0x1<<3)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_FLAG_SHIFT 3
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX4_FLAG (0x1<<4)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX4_FLAG_SHIFT 4
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_ENABLE (0x1<<5)
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_ENABLE_SHIFT 5
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_EN (0x1<<6)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_EN_SHIFT 6
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_CF_EN (0x1<<7)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_CF_EN_SHIFT 7
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_EN (0x1<<8)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_EN_SHIFT 8
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<9)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG_SHIFT 9
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_RTO_CF (0x3<<10)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_RTO_CF_SHIFT 10
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF (0x3<<12)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF_SHIFT 12
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX8_CF (0x3<<14)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX8_CF_SHIFT 14
-#elif defined(__LITTLE_ENDIAN)
-        u16 tcp_agg_vars2;
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG (0x1<<0)
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_SHIFT 0
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_UNBLOCKED (0x1<<1)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_UNBLOCKED_SHIFT 1
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_TIMER_ACTIVE (0x1<<2)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_TIMER_ACTIVE_SHIFT 2
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_FLAG (0x1<<3)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_FLAG_SHIFT 3
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX4_FLAG (0x1<<4)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX4_FLAG_SHIFT 4
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_ENABLE (0x1<<5)
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DA_ENABLE_SHIFT 5
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_EN (0x1<<6)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ACK_TO_FE_UPDATED_EN_SHIFT 6
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_CF_EN (0x1<<7)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX3_CF_EN_SHIFT 7
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_EN (0x1<<8)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_FIN_FLAG_EN_SHIFT 8
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<9)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG_SHIFT 9
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_RTO_CF (0x3<<10)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_SET_RTO_CF_SHIFT 10
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF (0x3<<12)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_UPDATED_CF_SHIFT 12
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX8_CF (0x3<<14)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX8_CF_SHIFT 14
-        u8 __agg_val8;
-        u8 __agg_val8_th;
-#endif
-        u32 ack_to_far_end;
-        u32 rto_timer;
-        u32 ka_timer;
-        u32 ts_to_echo;
-#if defined(__BIG_ENDIAN)
-        u16 __agg_val7_th;
-        u16 __agg_val7;
-#elif defined(__LITTLE_ENDIAN)
-        u16 __agg_val7;
-        u16 __agg_val7_th;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 __tcp_agg_vars5;
-        u8 __tcp_agg_vars4;
-        u8 __tcp_agg_vars3;
-        u8 __force_pure_ack_cnt;
-#elif defined(__LITTLE_ENDIAN)
-        u8 __force_pure_ack_cnt;
-        u8 __tcp_agg_vars3;
-        u8 __tcp_agg_vars4;
-        u8 __tcp_agg_vars5;
-#endif
-        u32 tcp_agg_vars6;
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_CF_EN (0x1<<0)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TS_TO_ECHO_CF_EN_SHIFT 0
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX8_CF_EN (0x1<<1)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX8_CF_EN_SHIFT 1
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX9_CF_EN (0x1<<2)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX9_CF_EN_SHIFT 2
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_EN (0x1<<3)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_EN_SHIFT 3
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX6_FLAG (0x1<<4)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX6_FLAG_SHIFT 4
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX7_FLAG (0x1<<5)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX7_FLAG_SHIFT 5
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX5_CF (0x3<<6)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX5_CF_SHIFT 6
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX9_CF (0x3<<8)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX9_CF_SHIFT 8
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF (0x3<<10)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_SHIFT 10
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX11_CF (0x3<<12)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX11_CF_SHIFT 12
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX12_CF (0x3<<14)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX12_CF_SHIFT 14
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX13_CF (0x3<<16)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX13_CF_SHIFT 16
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX14_CF (0x3<<18)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX14_CF_SHIFT 18
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX15_CF (0x3<<20)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX15_CF_SHIFT 20
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX16_CF (0x3<<22)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX16_CF_SHIFT 22
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX17_CF (0x3<<24)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX17_CF_SHIFT 24
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ECE_FLAG (0x1<<26)
-#define XSTORM_TCP_TCP_AG_CONTEXT_SECTION_ECE_FLAG_SHIFT 26
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_RESERVED71 (0x1<<27)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_RESERVED71_SHIFT 27
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_FORCE_PURE_ACK_CNT_DIRTY (0x1<<28)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_FORCE_PURE_ACK_CNT_DIRTY_SHIFT 28
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TCP_AUTO_STOP_FLAG (0x1<<29)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_TCP_AUTO_STOP_FLAG_SHIFT 29
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DO_TS_UPDATE_FLAG (0x1<<30)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_DO_TS_UPDATE_FLAG_SHIFT 30
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_CANCEL_RETRANSMIT_FLAG (0x1<<31)
-#define __XSTORM_TCP_TCP_AG_CONTEXT_SECTION_CANCEL_RETRANSMIT_FLAG_SHIFT 31
-#if defined(__BIG_ENDIAN)
-        u16 __agg_misc6;
-        u16 __tcp_agg_vars7;
-#elif defined(__LITTLE_ENDIAN)
-        u16 __tcp_agg_vars7;
-        u16 __agg_misc6;
-#endif
-        u32 __agg_val10;
-        u32 __agg_val10_th;
-#if defined(__BIG_ENDIAN)
-        u16 __reserved3;
-        u8 __reserved2;
-        u8 __da_only_cnt;
-#elif defined(__LITTLE_ENDIAN)
-        u8 __da_only_cnt;
-        u8 __reserved2;
-        u16 __reserved3;
-#endif
-};
-
-/*
- * The iscsi aggregative context of Xstorm
- */
-struct xstorm_iscsi_ag_context {
-#if defined(__BIG_ENDIAN)
-        u16 agg_val1;
-        u8 agg_vars1;
-#define __XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define __XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define __XSTORM_ISCSI_AG_CONTEXT_MORE_TO_SEND_EN (0x1<<4)
-#define __XSTORM_ISCSI_AG_CONTEXT_MORE_TO_SEND_EN_SHIFT 4
-#define XSTORM_ISCSI_AG_CONTEXT_NAGLE_EN (0x1<<5)
-#define XSTORM_ISCSI_AG_CONTEXT_NAGLE_EN_SHIFT 5
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG (0x1<<6)
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_SHIFT 6
-#define __XSTORM_ISCSI_AG_CONTEXT_UNA_GT_NXT_EN (0x1<<7)
-#define __XSTORM_ISCSI_AG_CONTEXT_UNA_GT_NXT_EN_SHIFT 7
-        u8 state;
-#elif defined(__LITTLE_ENDIAN)
-        u8 state;
-        u8 agg_vars1;
-#define __XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define __XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define XSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define __XSTORM_ISCSI_AG_CONTEXT_MORE_TO_SEND_EN (0x1<<4)
-#define __XSTORM_ISCSI_AG_CONTEXT_MORE_TO_SEND_EN_SHIFT 4
-#define XSTORM_ISCSI_AG_CONTEXT_NAGLE_EN (0x1<<5)
-#define XSTORM_ISCSI_AG_CONTEXT_NAGLE_EN_SHIFT 5
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG (0x1<<6)
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_SHIFT 6
-#define __XSTORM_ISCSI_AG_CONTEXT_UNA_GT_NXT_EN (0x1<<7)
-#define __XSTORM_ISCSI_AG_CONTEXT_UNA_GT_NXT_EN_SHIFT 7
-        u16 agg_val1;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 cdu_reserved;
-        u8 __agg_vars4;
-        u8 agg_vars3;
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM2 (0x3F<<0)
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM2_SHIFT 0
-#define __XSTORM_ISCSI_AG_CONTEXT_RX_TS_EN_CF (0x3<<6)
-#define __XSTORM_ISCSI_AG_CONTEXT_RX_TS_EN_CF_SHIFT 6
-        u8 agg_vars2;
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF (0x3<<0)
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_SHIFT 0
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_EN (0x1<<2)
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_EN_SHIFT 2
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX8_FLAG (0x1<<3)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX8_FLAG_SHIFT 3
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX9_FLAG (0x1<<4)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX9_FLAG_SHIFT 4
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE1 (0x3<<5)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE1_SHIFT 5
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_EN (0x1<<7)
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_EN_SHIFT 7
-#elif defined(__LITTLE_ENDIAN)
-        u8 agg_vars2;
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF (0x3<<0)
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_SHIFT 0
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_EN (0x1<<2)
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_SPARE_FLAG_EN_SHIFT 2
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX8_FLAG (0x1<<3)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX8_FLAG_SHIFT 3
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX9_FLAG (0x1<<4)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX9_FLAG_SHIFT 4
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE1 (0x3<<5)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE1_SHIFT 5
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_EN (0x1<<7)
-#define __XSTORM_ISCSI_AG_CONTEXT_DQ_CF_EN_SHIFT 7
-        u8 agg_vars3;
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM2 (0x3F<<0)
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM2_SHIFT 0
-#define __XSTORM_ISCSI_AG_CONTEXT_RX_TS_EN_CF (0x3<<6)
-#define __XSTORM_ISCSI_AG_CONTEXT_RX_TS_EN_CF_SHIFT 6
-        u8 __agg_vars4;
-        u8 cdu_reserved;
-#endif
-        u32 more_to_send;
-#if defined(__BIG_ENDIAN)
-        u16 agg_vars5;
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE5 (0x3<<0)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE5_SHIFT 0
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM0 (0x3F<<2)
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM0_SHIFT 2
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM1 (0x3F<<8)
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM1_SHIFT 8
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE2 (0x3<<14)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE2_SHIFT 14
-        u16 sq_cons;
-#elif defined(__LITTLE_ENDIAN)
-        u16 sq_cons;
-        u16 agg_vars5;
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE5 (0x3<<0)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE5_SHIFT 0
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM0 (0x3F<<2)
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM0_SHIFT 2
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM1 (0x3F<<8)
-#define XSTORM_ISCSI_AG_CONTEXT_PHYSICAL_QUEUE_NUM1_SHIFT 8
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE2 (0x3<<14)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE2_SHIFT 14
-#endif
-        struct xstorm_tcp_tcp_ag_context_section tcp;
-#if defined(__BIG_ENDIAN)
-        u16 agg_vars7;
-#define __XSTORM_ISCSI_AG_CONTEXT_AGG_VAL11_DECISION_RULE (0x7<<0)
-#define __XSTORM_ISCSI_AG_CONTEXT_AGG_VAL11_DECISION_RULE_SHIFT 0
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX13_FLAG (0x1<<3)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX13_FLAG_SHIFT 3
-#define __XSTORM_ISCSI_AG_CONTEXT_STORMS_SYNC_CF (0x3<<4)
-#define __XSTORM_ISCSI_AG_CONTEXT_STORMS_SYNC_CF_SHIFT 4
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE3 (0x3<<6)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE3_SHIFT 6
-#define XSTORM_ISCSI_AG_CONTEXT_AUX1_CF (0x3<<8)
-#define XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_SHIFT 8
-#define __XSTORM_ISCSI_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK (0x1<<10)
-#define __XSTORM_ISCSI_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK_SHIFT 10
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN (0x1<<11)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN_SHIFT 11
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX10_FLAG (0x1<<12)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX10_FLAG_SHIFT 12
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX11_FLAG (0x1<<13)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX11_FLAG_SHIFT 13
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX12_FLAG (0x1<<14)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX12_FLAG_SHIFT 14
-#define __XSTORM_ISCSI_AG_CONTEXT_RX_WND_SCL_EN (0x1<<15)
-#define __XSTORM_ISCSI_AG_CONTEXT_RX_WND_SCL_EN_SHIFT 15
-        u8 agg_val3_th;
-        u8 agg_vars6;
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE6 (0x7<<0)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE6_SHIFT 0
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE7 (0x7<<3)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE7_SHIFT 3
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE4 (0x3<<6)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE4_SHIFT 6
-#elif defined(__LITTLE_ENDIAN)
-        u8 agg_vars6;
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE6 (0x7<<0)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE6_SHIFT 0
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE7 (0x7<<3)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE7_SHIFT 3
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE4 (0x3<<6)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE4_SHIFT 6
-        u8 agg_val3_th;
-        u16 agg_vars7;
-#define __XSTORM_ISCSI_AG_CONTEXT_AGG_VAL11_DECISION_RULE (0x7<<0)
-#define __XSTORM_ISCSI_AG_CONTEXT_AGG_VAL11_DECISION_RULE_SHIFT 0
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX13_FLAG (0x1<<3)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX13_FLAG_SHIFT 3
-#define __XSTORM_ISCSI_AG_CONTEXT_STORMS_SYNC_CF (0x3<<4)
-#define __XSTORM_ISCSI_AG_CONTEXT_STORMS_SYNC_CF_SHIFT 4
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE3 (0x3<<6)
-#define XSTORM_ISCSI_AG_CONTEXT_DECISION_RULE3_SHIFT 6
-#define XSTORM_ISCSI_AG_CONTEXT_AUX1_CF (0x3<<8)
-#define XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_SHIFT 8
-#define __XSTORM_ISCSI_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK (0x1<<10)
-#define __XSTORM_ISCSI_AG_CONTEXT_COMPLETION_SEQ_DECISION_MASK_SHIFT 10
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN (0x1<<11)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX1_CF_EN_SHIFT 11
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX10_FLAG (0x1<<12)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX10_FLAG_SHIFT 12
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX11_FLAG (0x1<<13)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX11_FLAG_SHIFT 13
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX12_FLAG (0x1<<14)
-#define __XSTORM_ISCSI_AG_CONTEXT_AUX12_FLAG_SHIFT 14
-#define __XSTORM_ISCSI_AG_CONTEXT_RX_WND_SCL_EN (0x1<<15)
-#define __XSTORM_ISCSI_AG_CONTEXT_RX_WND_SCL_EN_SHIFT 15
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 __agg_val11_th;
-        u16 __gen_data;
-#elif defined(__LITTLE_ENDIAN)
-        u16 __gen_data;
-        u16 __agg_val11_th;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 __reserved1;
-        u8 __agg_val6_th;
-        u16 __agg_val9;
-#elif defined(__LITTLE_ENDIAN)
-        u16 __agg_val9;
-        u8 __agg_val6_th;
-        u8 __reserved1;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 hq_prod;
-        u16 hq_cons;
-#elif defined(__LITTLE_ENDIAN)
-        u16 hq_cons;
-        u16 hq_prod;
-#endif
-        u32 agg_vars8;
-#define XSTORM_ISCSI_AG_CONTEXT_AGG_MISC2 (0xFFFFFF<<0)
-#define XSTORM_ISCSI_AG_CONTEXT_AGG_MISC2_SHIFT 0
-#define XSTORM_ISCSI_AG_CONTEXT_AGG_MISC3 (0xFF<<24)
-#define XSTORM_ISCSI_AG_CONTEXT_AGG_MISC3_SHIFT 24
-#if defined(__BIG_ENDIAN)
-        u16 r2tq_prod;
-        u16 sq_prod;
-#elif defined(__LITTLE_ENDIAN)
-        u16 sq_prod;
-        u16 r2tq_prod;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 agg_val3;
-        u8 agg_val6;
-        u8 agg_val5_th;
-        u8 agg_val5;
-#elif defined(__LITTLE_ENDIAN)
-        u8 agg_val5;
-        u8 agg_val5_th;
-        u8 agg_val6;
-        u8 agg_val3;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 __agg_misc1;
-        u16 agg_limit1;
-#elif defined(__LITTLE_ENDIAN)
-        u16 agg_limit1;
-        u16 __agg_misc1;
-#endif
-        u32 hq_cons_tcp_seq;
-        u32 exp_stat_sn;
-        u32 rst_seq_num;
-};
-
-/*
- * The tcp aggregative context section of Tstorm
- */
-struct tstorm_tcp_tcp_ag_context_section {
-        u32 __agg_val1;
-#if defined(__BIG_ENDIAN)
-        u8 __tcp_agg_vars2;
-        u8 __agg_val3;
-        u16 __agg_val2;
-#elif defined(__LITTLE_ENDIAN)
-        u16 __agg_val2;
-        u8 __agg_val3;
-        u8 __tcp_agg_vars2;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 __agg_val5;
-        u8 __agg_val6;
-        u8 __tcp_agg_vars3;
-#elif defined(__LITTLE_ENDIAN)
-        u8 __tcp_agg_vars3;
-        u8 __agg_val6;
-        u16 __agg_val5;
-#endif
-        u32 snd_nxt;
-        u32 rtt_seq;
-        u32 rtt_time;
-        u32 __reserved66;
-        u32 wnd_right_edge;
-        u32 tcp_agg_vars1;
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_FIN_SENT_FLAG (0x1<<0)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_FIN_SENT_FLAG_SHIFT 0
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_LAST_PACKET_FIN_FLAG (0x1<<1)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_LAST_PACKET_FIN_FLAG_SHIFT 1
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_WND_UPD_CF (0x3<<2)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_WND_UPD_CF_SHIFT 2
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TIMEOUT_CF (0x3<<4)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TIMEOUT_CF_SHIFT 4
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_WND_UPD_CF_EN (0x1<<6)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_WND_UPD_CF_EN_SHIFT 6
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TIMEOUT_CF_EN (0x1<<7)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TIMEOUT_CF_EN_SHIFT 7
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_SEQ_EN (0x1<<8)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_SEQ_EN_SHIFT 8
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_SND_NXT_EN (0x1<<9)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_SND_NXT_EN_SHIFT 9
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG (0x1<<10)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_FLAG_SHIFT 10
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_FLAG (0x1<<11)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_FLAG_SHIFT 11
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_CF_EN (0x1<<12)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_CF_EN_SHIFT 12
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_CF_EN (0x1<<13)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_CF_EN_SHIFT 13
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_CF (0x3<<14)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX1_CF_SHIFT 14
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_CF (0x3<<16)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX2_CF_SHIFT 16
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_BLOCKED (0x1<<18)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_TX_BLOCKED_SHIFT 18
-#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_EN (0x1<<19)
-#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX10_CF_EN_SHIFT 19
-#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX11_CF_EN (0x1<<20)
-#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX11_CF_EN_SHIFT 20
-#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX12_CF_EN (0x1<<21)
-#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_AUX12_CF_EN_SHIFT 21
-#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RESERVED1 (0x3<<22)
-#define __TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RESERVED1_SHIFT 22
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_PEND_SEQ (0xF<<24)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_PEND_SEQ_SHIFT 24
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_DONE_SEQ (0xF<<28)
-#define TSTORM_TCP_TCP_AG_CONTEXT_SECTION_RETRANSMIT_DONE_SEQ_SHIFT 28
-        u32 snd_max;
-        u32 snd_una;
-        u32 __reserved2;
-};
-
-/*
- * The iscsi aggregative context of Tstorm
- */
-struct tstorm_iscsi_ag_context {
-#if defined(__BIG_ENDIAN)
-        u16 ulp_credit;
-        u8 agg_vars1;
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF (0x3<<4)
-#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_SHIFT 4
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX3_FLAG (0x1<<6)
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX3_FLAG_SHIFT 6
-#define __TSTORM_ISCSI_AG_CONTEXT_ACK_ON_FIN_SENT_FLAG (0x1<<7)
-#define __TSTORM_ISCSI_AG_CONTEXT_ACK_ON_FIN_SENT_FLAG_SHIFT 7
-        u8 state;
-#elif defined(__LITTLE_ENDIAN)
-        u8 state;
-        u8 agg_vars1;
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define TSTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF (0x3<<4)
-#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_SHIFT 4
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX3_FLAG (0x1<<6)
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX3_FLAG_SHIFT 6
-#define __TSTORM_ISCSI_AG_CONTEXT_ACK_ON_FIN_SENT_FLAG (0x1<<7)
-#define __TSTORM_ISCSI_AG_CONTEXT_ACK_ON_FIN_SENT_FLAG_SHIFT 7
-        u16 ulp_credit;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 __agg_val4;
-        u16 agg_vars2;
-#define __TSTORM_ISCSI_AG_CONTEXT_MSL_TIMER_SET_FLAG (0x1<<0)
-#define __TSTORM_ISCSI_AG_CONTEXT_MSL_TIMER_SET_FLAG_SHIFT 0
-#define __TSTORM_ISCSI_AG_CONTEXT_FIN_SENT_FIRST_FLAG (0x1<<1)
-#define __TSTORM_ISCSI_AG_CONTEXT_FIN_SENT_FIRST_FLAG_SHIFT 1
-#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF (0x3<<2)
-#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_SHIFT 2
-#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF (0x3<<4)
-#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_SHIFT 4
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX6_CF (0x3<<6)
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_SHIFT 6
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_CF (0x3<<8)
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_SHIFT 8
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_FLAG (0x1<<10)
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_FLAG_SHIFT 10
-#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN (0x1<<11)
-#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN_SHIFT 11
-#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_EN (0x1<<12)
-#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_EN_SHIFT 12
-#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_EN (0x1<<13)
-#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_EN_SHIFT 13
-#define TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_EN (0x1<<14)
-#define TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_EN_SHIFT 14
-#define TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_EN (0x1<<15)
-#define TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_EN_SHIFT 15
-#elif defined(__LITTLE_ENDIAN)
-        u16 agg_vars2;
-#define __TSTORM_ISCSI_AG_CONTEXT_MSL_TIMER_SET_FLAG (0x1<<0)
-#define __TSTORM_ISCSI_AG_CONTEXT_MSL_TIMER_SET_FLAG_SHIFT 0
-#define __TSTORM_ISCSI_AG_CONTEXT_FIN_SENT_FIRST_FLAG (0x1<<1)
-#define __TSTORM_ISCSI_AG_CONTEXT_FIN_SENT_FIRST_FLAG_SHIFT 1
-#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF (0x3<<2)
-#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_SHIFT 2
-#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF (0x3<<4)
-#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_SHIFT 4
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX6_CF (0x3<<6)
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_SHIFT 6
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_CF (0x3<<8)
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_SHIFT 8
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_FLAG (0x1<<10)
-#define __TSTORM_ISCSI_AG_CONTEXT_AUX7_FLAG_SHIFT 10
-#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN (0x1<<11)
-#define __TSTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN_SHIFT 11
-#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_EN (0x1<<12)
-#define __TSTORM_ISCSI_AG_CONTEXT_RST_SENT_CF_EN_SHIFT 12
-#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_EN (0x1<<13)
-#define __TSTORM_ISCSI_AG_CONTEXT_WAKEUP_CALL_CF_EN_SHIFT 13
-#define TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_EN (0x1<<14)
-#define TSTORM_ISCSI_AG_CONTEXT_AUX6_CF_EN_SHIFT 14
-#define TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_EN (0x1<<15)
-#define TSTORM_ISCSI_AG_CONTEXT_AUX7_CF_EN_SHIFT 15
-        u16 __agg_val4;
-#endif
-        struct tstorm_tcp_tcp_ag_context_section tcp;
-};
-
-/*
- * The iscsi aggregative context of Ustorm
- */
-struct ustorm_iscsi_ag_context {
-#if defined(__BIG_ENDIAN)
-        u8 __aux_counter_flags;
-        u8 agg_vars2;
-#define USTORM_ISCSI_AG_CONTEXT_TX_CF (0x3<<0)
-#define USTORM_ISCSI_AG_CONTEXT_TX_CF_SHIFT 0
-#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF (0x3<<2)
-#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_SHIFT 2
-#define USTORM_ISCSI_AG_CONTEXT_AGG_MISC4_RULE (0x7<<4)
-#define USTORM_ISCSI_AG_CONTEXT_AGG_MISC4_RULE_SHIFT 4
-#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_MASK (0x1<<7)
-#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_MASK_SHIFT 7
-        u8 agg_vars1;
-#define __USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define __USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define USTORM_ISCSI_AG_CONTEXT_INV_CF (0x3<<4)
-#define USTORM_ISCSI_AG_CONTEXT_INV_CF_SHIFT 4
-#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF (0x3<<6)
-#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_SHIFT 6
-        u8 state;
-#elif defined(__LITTLE_ENDIAN)
-        u8 state;
-        u8 agg_vars1;
-#define __USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0 (0x1<<0)
-#define __USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM0_SHIFT 0
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1 (0x1<<1)
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM1_SHIFT 1
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2 (0x1<<2)
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM2_SHIFT 2
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3 (0x1<<3)
-#define USTORM_ISCSI_AG_CONTEXT_EXISTS_IN_QM3_SHIFT 3
-#define USTORM_ISCSI_AG_CONTEXT_INV_CF (0x3<<4)
-#define USTORM_ISCSI_AG_CONTEXT_INV_CF_SHIFT 4
-#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF (0x3<<6)
-#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_SHIFT 6
-        u8 agg_vars2;
-#define USTORM_ISCSI_AG_CONTEXT_TX_CF (0x3<<0)
-#define USTORM_ISCSI_AG_CONTEXT_TX_CF_SHIFT 0
-#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF (0x3<<2)
-#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_SHIFT 2
-#define USTORM_ISCSI_AG_CONTEXT_AGG_MISC4_RULE (0x7<<4)
-#define USTORM_ISCSI_AG_CONTEXT_AGG_MISC4_RULE_SHIFT 4
-#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_MASK (0x1<<7)
-#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_MASK_SHIFT 7
-        u8 __aux_counter_flags;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 cdu_usage;
-        u8 agg_misc2;
-        u16 __cq_local_comp_itt_val;
-#elif defined(__LITTLE_ENDIAN)
-        u16 __cq_local_comp_itt_val;
-        u8 agg_misc2;
-        u8 cdu_usage;
-#endif
-        u32 agg_misc4;
-#if defined(__BIG_ENDIAN)
-        u8 agg_val3_th;
-        u8 agg_val3;
-        u16 agg_misc3;
-#elif defined(__LITTLE_ENDIAN)
-        u16 agg_misc3;
-        u8 agg_val3;
-        u8 agg_val3_th;
-#endif
-        u32 agg_val1;
-        u32 agg_misc4_th;
-#if defined(__BIG_ENDIAN)
-        u16 agg_val2_th;
-        u16 agg_val2;
-#elif defined(__LITTLE_ENDIAN)
-        u16 agg_val2;
-        u16 agg_val2_th;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 __reserved2;
-        u8 decision_rules;
-#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_RULE (0x7<<0)
-#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_RULE_SHIFT 0
-#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL3_RULE (0x7<<3)
-#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL3_RULE_SHIFT 3
-#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_ARM_N_FLAG (0x1<<6)
-#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_ARM_N_FLAG_SHIFT 6
-#define __USTORM_ISCSI_AG_CONTEXT_RESERVED1 (0x1<<7)
-#define __USTORM_ISCSI_AG_CONTEXT_RESERVED1_SHIFT 7
-        u8 decision_rule_enable_bits;
-#define USTORM_ISCSI_AG_CONTEXT_INV_CF_EN (0x1<<0)
-#define USTORM_ISCSI_AG_CONTEXT_INV_CF_EN_SHIFT 0
-#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_EN (0x1<<1)
-#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_EN_SHIFT 1
-#define USTORM_ISCSI_AG_CONTEXT_TX_CF_EN (0x1<<2)
-#define USTORM_ISCSI_AG_CONTEXT_TX_CF_EN_SHIFT 2
-#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_EN (0x1<<3)
-#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_EN_SHIFT 3
-#define __USTORM_ISCSI_AG_CONTEXT_CQ_LOCAL_COMP_CF_EN (0x1<<4)
-#define __USTORM_ISCSI_AG_CONTEXT_CQ_LOCAL_COMP_CF_EN_SHIFT 4
-#define __USTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN (0x1<<5)
-#define __USTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN_SHIFT 5
-#define __USTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN (0x1<<6)
-#define __USTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN_SHIFT 6
-#define __USTORM_ISCSI_AG_CONTEXT_DQ_CF_EN (0x1<<7)
-#define __USTORM_ISCSI_AG_CONTEXT_DQ_CF_EN_SHIFT 7
-#elif defined(__LITTLE_ENDIAN)
-        u8 decision_rule_enable_bits;
-#define USTORM_ISCSI_AG_CONTEXT_INV_CF_EN (0x1<<0)
-#define USTORM_ISCSI_AG_CONTEXT_INV_CF_EN_SHIFT 0
-#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_EN (0x1<<1)
-#define USTORM_ISCSI_AG_CONTEXT_COMPLETION_CF_EN_SHIFT 1
-#define USTORM_ISCSI_AG_CONTEXT_TX_CF_EN (0x1<<2)
-#define USTORM_ISCSI_AG_CONTEXT_TX_CF_EN_SHIFT 2
-#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_EN (0x1<<3)
-#define __USTORM_ISCSI_AG_CONTEXT_TIMER_CF_EN_SHIFT 3
-#define __USTORM_ISCSI_AG_CONTEXT_CQ_LOCAL_COMP_CF_EN (0x1<<4)
-#define __USTORM_ISCSI_AG_CONTEXT_CQ_LOCAL_COMP_CF_EN_SHIFT 4
-#define __USTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN (0x1<<5)
-#define __USTORM_ISCSI_AG_CONTEXT_QUEUES_FLUSH_Q0_CF_EN_SHIFT 5
-#define __USTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN (0x1<<6)
-#define __USTORM_ISCSI_AG_CONTEXT_AUX3_CF_EN_SHIFT 6
-#define __USTORM_ISCSI_AG_CONTEXT_DQ_CF_EN (0x1<<7)
-#define __USTORM_ISCSI_AG_CONTEXT_DQ_CF_EN_SHIFT 7
-        u8 decision_rules;
-#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_RULE (0x7<<0)
-#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_RULE_SHIFT 0
-#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL3_RULE (0x7<<3)
-#define __USTORM_ISCSI_AG_CONTEXT_AGG_VAL3_RULE_SHIFT 3
-#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_ARM_N_FLAG (0x1<<6)
-#define USTORM_ISCSI_AG_CONTEXT_AGG_VAL2_ARM_N_FLAG_SHIFT 6
-#define __USTORM_ISCSI_AG_CONTEXT_RESERVED1 (0x1<<7)
-#define __USTORM_ISCSI_AG_CONTEXT_RESERVED1_SHIFT 7
-        u16 __reserved2;
-#endif
-};
-
-/*
  * Ethernet context section, shared in TOE, RDMA and ISCSI
  */
 struct xstorm_eth_context_section {
@@ -3509,7 +4463,27 @@ struct xstorm_tcp_context_section {
         u16 window_scaling_factor;
         u16 pseudo_csum;
 #endif
-        u32 reserved2;
+#if defined(__BIG_ENDIAN)
+        u16 reserved2;
+        u8 statistics_counter_id;
+        u8 statistics_params;
+#define XSTORM_TCP_CONTEXT_SECTION_UPDATE_L2_STATSTICS (0x1<<0)
+#define XSTORM_TCP_CONTEXT_SECTION_UPDATE_L2_STATSTICS_SHIFT 0
+#define XSTORM_TCP_CONTEXT_SECTION_UPDATE_L4_STATSTICS (0x1<<1)
+#define XSTORM_TCP_CONTEXT_SECTION_UPDATE_L4_STATSTICS_SHIFT 1
+#define XSTORM_TCP_CONTEXT_SECTION_RESERVED (0x3F<<2)
+#define XSTORM_TCP_CONTEXT_SECTION_RESERVED_SHIFT 2
+#elif defined(__LITTLE_ENDIAN)
+        u8 statistics_params;
+#define XSTORM_TCP_CONTEXT_SECTION_UPDATE_L2_STATSTICS (0x1<<0)
+#define XSTORM_TCP_CONTEXT_SECTION_UPDATE_L2_STATSTICS_SHIFT 0
+#define XSTORM_TCP_CONTEXT_SECTION_UPDATE_L4_STATSTICS (0x1<<1)
+#define XSTORM_TCP_CONTEXT_SECTION_UPDATE_L4_STATSTICS_SHIFT 1
+#define XSTORM_TCP_CONTEXT_SECTION_RESERVED (0x3F<<2)
+#define XSTORM_TCP_CONTEXT_SECTION_RESERVED_SHIFT 2
+        u8 statistics_counter_id;
+        u16 reserved2;
+#endif
         u32 ts_time_diff;
         u32 __next_timer_expir;
 };
@@ -3522,29 +4496,31 @@ struct xstorm_common_context_section {
         union xstorm_ip_context_section_types ip_union;
         struct xstorm_tcp_context_section tcp;
 #if defined(__BIG_ENDIAN)
-        u16 reserved;
-        u8 statistics_params;
-#define XSTORM_COMMON_CONTEXT_SECTION_UPDATE_L2_STATSTICS (0x1<<0)
-#define XSTORM_COMMON_CONTEXT_SECTION_UPDATE_L2_STATSTICS_SHIFT 0
-#define XSTORM_COMMON_CONTEXT_SECTION_UPDATE_L4_STATSTICS (0x1<<1)
-#define XSTORM_COMMON_CONTEXT_SECTION_UPDATE_L4_STATSTICS_SHIFT 1
-#define XSTORM_COMMON_CONTEXT_SECTION_STATISTICS_COUNTER_ID (0x1F<<2)
-#define XSTORM_COMMON_CONTEXT_SECTION_STATISTICS_COUNTER_ID_SHIFT 2
-#define XSTORM_COMMON_CONTEXT_SECTION_DCB_EXISTS (0x1<<7)
-#define XSTORM_COMMON_CONTEXT_SECTION_DCB_EXISTS_SHIFT 7
+        u8 __dcb_val;
+        u8 flags;
+#define XSTORM_COMMON_CONTEXT_SECTION_PHYSQ_INITIALIZED (0x1<<0)
+#define XSTORM_COMMON_CONTEXT_SECTION_PHYSQ_INITIALIZED_SHIFT 0
+#define XSTORM_COMMON_CONTEXT_SECTION_PBF_PORT (0x7<<1)
+#define XSTORM_COMMON_CONTEXT_SECTION_PBF_PORT_SHIFT 1
+#define XSTORM_COMMON_CONTEXT_SECTION_VLAN_MODE (0x1<<4)
+#define XSTORM_COMMON_CONTEXT_SECTION_VLAN_MODE_SHIFT 4
+#define XSTORM_COMMON_CONTEXT_SECTION_ORIGINAL_PRIORITY (0x7<<5)
+#define XSTORM_COMMON_CONTEXT_SECTION_ORIGINAL_PRIORITY_SHIFT 5
+        u8 reserved;
         u8 ip_version_1b;
 #elif defined(__LITTLE_ENDIAN)
         u8 ip_version_1b;
-        u8 statistics_params;
-#define XSTORM_COMMON_CONTEXT_SECTION_UPDATE_L2_STATSTICS (0x1<<0)
-#define XSTORM_COMMON_CONTEXT_SECTION_UPDATE_L2_STATSTICS_SHIFT 0
-#define XSTORM_COMMON_CONTEXT_SECTION_UPDATE_L4_STATSTICS (0x1<<1)
-#define XSTORM_COMMON_CONTEXT_SECTION_UPDATE_L4_STATSTICS_SHIFT 1
-#define XSTORM_COMMON_CONTEXT_SECTION_STATISTICS_COUNTER_ID (0x1F<<2)
-#define XSTORM_COMMON_CONTEXT_SECTION_STATISTICS_COUNTER_ID_SHIFT 2
-#define XSTORM_COMMON_CONTEXT_SECTION_DCB_EXISTS (0x1<<7)
-#define XSTORM_COMMON_CONTEXT_SECTION_DCB_EXISTS_SHIFT 7
-        u16 reserved;
+        u8 reserved;
+        u8 flags;
+#define XSTORM_COMMON_CONTEXT_SECTION_PHYSQ_INITIALIZED (0x1<<0)
+#define XSTORM_COMMON_CONTEXT_SECTION_PHYSQ_INITIALIZED_SHIFT 0
+#define XSTORM_COMMON_CONTEXT_SECTION_PBF_PORT (0x7<<1)
+#define XSTORM_COMMON_CONTEXT_SECTION_PBF_PORT_SHIFT 1
+#define XSTORM_COMMON_CONTEXT_SECTION_VLAN_MODE (0x1<<4)
+#define XSTORM_COMMON_CONTEXT_SECTION_VLAN_MODE_SHIFT 4
+#define XSTORM_COMMON_CONTEXT_SECTION_ORIGINAL_PRIORITY (0x7<<5)
+#define XSTORM_COMMON_CONTEXT_SECTION_ORIGINAL_PRIORITY_SHIFT 5
+        u8 __dcb_val;
 #endif
 };
 
@@ -3682,99 +4658,6 @@ struct xstorm_iscsi_st_context {
 };
 
 /*
- * CQ DB CQ producer and pending completion counter
- */
-struct iscsi_cq_db_prod_pnd_cmpltn_cnt {
-#if defined(__BIG_ENDIAN)
-        u16 cntr;
-        u16 prod;
-#elif defined(__LITTLE_ENDIAN)
-        u16 prod;
-        u16 cntr;
-#endif
-};
-
-/*
- * CQ DB pending completion ITT array
- */
-struct iscsi_cq_db_prod_pnd_cmpltn_cnt_arr {
-        struct iscsi_cq_db_prod_pnd_cmpltn_cnt prod_pend_comp[8];
-};
-
-/*
- * Cstorm CQ sequence to notify array, updated by driver
- */
-struct iscsi_cq_db_sqn_2_notify_arr {
-        u16 sqn[8];
-};
-
-/*
- * Cstorm iSCSI Storm Context
- */
-struct cstorm_iscsi_st_context {
-        struct iscsi_cq_db_prod_pnd_cmpltn_cnt_arr cq_c_prod_pend_comp_ctr_arr;
-        struct iscsi_cq_db_sqn_2_notify_arr cq_c_prod_sqn_arr;
-        struct iscsi_cq_db_sqn_2_notify_arr cq_c_sqn_2_notify_arr;
-        struct regpair hq_pbl_base;
-        struct regpair hq_curr_pbe;
-        struct regpair task_pbl_base;
-        struct regpair cq_db_base;
-#if defined(__BIG_ENDIAN)
-        u16 hq_bd_itt;
-        u16 iscsi_conn_id;
-#elif defined(__LITTLE_ENDIAN)
-        u16 iscsi_conn_id;
-        u16 hq_bd_itt;
-#endif
-        u32 hq_bd_data_segment_len;
-        u32 hq_bd_buffer_offset;
-#if defined(__BIG_ENDIAN)
-        u8 timer_entry_idx;
-        u8 cq_proc_en_bit_map;
-        u8 cq_pend_comp_itt_valid_bit_map;
-        u8 hq_bd_opcode;
-#elif defined(__LITTLE_ENDIAN)
-        u8 hq_bd_opcode;
-        u8 cq_pend_comp_itt_valid_bit_map;
-        u8 cq_proc_en_bit_map;
-        u8 timer_entry_idx;
-#endif
-        u32 hq_tcp_seq;
-#if defined(__BIG_ENDIAN)
-        u16 flags;
-#define CSTORM_ISCSI_ST_CONTEXT_DATA_DIGEST_EN (0x1<<0)
-#define CSTORM_ISCSI_ST_CONTEXT_DATA_DIGEST_EN_SHIFT 0
-#define CSTORM_ISCSI_ST_CONTEXT_HDR_DIGEST_EN (0x1<<1)
-#define CSTORM_ISCSI_ST_CONTEXT_HDR_DIGEST_EN_SHIFT 1
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_CTXT_VALID (0x1<<2)
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_CTXT_VALID_SHIFT 2
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_LCL_CMPLN_FLG (0x1<<3)
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_LCL_CMPLN_FLG_SHIFT 3
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_WRITE_TASK (0x1<<4)
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_WRITE_TASK_SHIFT 4
-#define CSTORM_ISCSI_ST_CONTEXT_CTRL_FLAGS_RSRV (0x7FF<<5)
-#define CSTORM_ISCSI_ST_CONTEXT_CTRL_FLAGS_RSRV_SHIFT 5
-        u16 hq_cons;
-#elif defined(__LITTLE_ENDIAN)
-        u16 hq_cons;
-        u16 flags;
-#define CSTORM_ISCSI_ST_CONTEXT_DATA_DIGEST_EN (0x1<<0)
-#define CSTORM_ISCSI_ST_CONTEXT_DATA_DIGEST_EN_SHIFT 0
-#define CSTORM_ISCSI_ST_CONTEXT_HDR_DIGEST_EN (0x1<<1)
-#define CSTORM_ISCSI_ST_CONTEXT_HDR_DIGEST_EN_SHIFT 1
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_CTXT_VALID (0x1<<2)
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_CTXT_VALID_SHIFT 2
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_LCL_CMPLN_FLG (0x1<<3)
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_LCL_CMPLN_FLG_SHIFT 3
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_WRITE_TASK (0x1<<4)
-#define CSTORM_ISCSI_ST_CONTEXT_HQ_BD_WRITE_TASK_SHIFT 4
-#define CSTORM_ISCSI_ST_CONTEXT_CTRL_FLAGS_RSRV (0x7FF<<5)
-#define CSTORM_ISCSI_ST_CONTEXT_CTRL_FLAGS_RSRV_SHIFT 5
-#endif
-        struct regpair rsrv1;
-};
-
-/*
  * Iscsi connection context
  */
 struct iscsi_context {
@@ -3791,583 +4674,388 @@ struct iscsi_context {
         struct cstorm_iscsi_st_context cstorm_st_context;
 };
 
-/*
- * FCoE KCQ CQE parameters
- */
-union fcoe_kcqe_params {
-        u32 reserved0[4];
-};
 
 /*
- * FCoE KCQ CQE
+ * PDU header of an iSCSI DATA-OUT
  */
-struct fcoe_kcqe {
-        u32 fcoe_conn_id;
-        u32 completion_status;
-        u32 fcoe_conn_context_id;
-        union fcoe_kcqe_params params;
+struct iscsi_data_pdu_hdr_little_endian {
 #if defined(__BIG_ENDIAN)
-        u8 flags;
-#define FCOE_KCQE_RESERVED0 (0x7<<0)
-#define FCOE_KCQE_RESERVED0_SHIFT 0
-#define FCOE_KCQE_RAMROD_COMPLETION (0x1<<3)
-#define FCOE_KCQE_RAMROD_COMPLETION_SHIFT 3
-#define FCOE_KCQE_LAYER_CODE (0x7<<4)
-#define FCOE_KCQE_LAYER_CODE_SHIFT 4
-#define FCOE_KCQE_LINKED_WITH_NEXT (0x1<<7)
-#define FCOE_KCQE_LINKED_WITH_NEXT_SHIFT 7
-        u8 op_code;
-        u16 qe_self_seq;
+        u8 opcode;
+        u8 op_attr;
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_RSRV1 (0x7F<<0)
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_RSRV1_SHIFT 0
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_FINAL_FLAG (0x1<<7)
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_FINAL_FLAG_SHIFT 7
+        u16 rsrv0;
 #elif defined(__LITTLE_ENDIAN)
-        u16 qe_self_seq;
-        u8 op_code;
-        u8 flags;
-#define FCOE_KCQE_RESERVED0 (0x7<<0)
-#define FCOE_KCQE_RESERVED0_SHIFT 0
-#define FCOE_KCQE_RAMROD_COMPLETION (0x1<<3)
-#define FCOE_KCQE_RAMROD_COMPLETION_SHIFT 3
-#define FCOE_KCQE_LAYER_CODE (0x7<<4)
-#define FCOE_KCQE_LAYER_CODE_SHIFT 4
-#define FCOE_KCQE_LINKED_WITH_NEXT (0x1<<7)
-#define FCOE_KCQE_LINKED_WITH_NEXT_SHIFT 7
+        u16 rsrv0;
+        u8 op_attr;
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_RSRV1 (0x7F<<0)
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_RSRV1_SHIFT 0
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_FINAL_FLAG (0x1<<7)
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_FINAL_FLAG_SHIFT 7
+        u8 opcode;
 #endif
+        u32 data_fields;
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH (0xFFFFFF<<0)
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH_SHIFT 0
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH (0xFF<<24)
+#define ISCSI_DATA_PDU_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH_SHIFT 24
+        struct regpair lun;
+        u32 itt;
+        u32 ttt;
+        u32 rsrv2;
+        u32 exp_stat_sn;
+        u32 rsrv3;
+        u32 data_sn;
+        u32 buffer_offset;
+        u32 rsrv4;
 };
 
-/*
- * FCoE KWQE header
- */
-struct fcoe_kwqe_header {
-#if defined(__BIG_ENDIAN)
-        u8 flags;
-#define FCOE_KWQE_HEADER_RESERVED0 (0xF<<0)
-#define FCOE_KWQE_HEADER_RESERVED0_SHIFT 0
-#define FCOE_KWQE_HEADER_LAYER_CODE (0x7<<4)
-#define FCOE_KWQE_HEADER_LAYER_CODE_SHIFT 4
-#define FCOE_KWQE_HEADER_RESERVED1 (0x1<<7)
-#define FCOE_KWQE_HEADER_RESERVED1_SHIFT 7
-        u8 op_code;
-#elif defined(__LITTLE_ENDIAN)
-        u8 op_code;
-        u8 flags;
-#define FCOE_KWQE_HEADER_RESERVED0 (0xF<<0)
-#define FCOE_KWQE_HEADER_RESERVED0_SHIFT 0
-#define FCOE_KWQE_HEADER_LAYER_CODE (0x7<<4)
-#define FCOE_KWQE_HEADER_LAYER_CODE_SHIFT 4
-#define FCOE_KWQE_HEADER_RESERVED1 (0x1<<7)
-#define FCOE_KWQE_HEADER_RESERVED1_SHIFT 7
-#endif
-};
 
 /*
- * FCoE firmware init request 1
+ * PDU header of an iSCSI login request
  */
-struct fcoe_kwqe_init1 {
+struct iscsi_login_req_hdr_little_endian {
 #if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 num_tasks;
-#elif defined(__LITTLE_ENDIAN)
-        u16 num_tasks;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u32 task_list_pbl_addr_lo;
-        u32 task_list_pbl_addr_hi;
-        u32 dummy_buffer_addr_lo;
-        u32 dummy_buffer_addr_hi;
-#if defined(__BIG_ENDIAN)
-        u16 rq_num_wqes;
-        u16 sq_num_wqes;
-#elif defined(__LITTLE_ENDIAN)
-        u16 sq_num_wqes;
-        u16 rq_num_wqes;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 cq_num_wqes;
-        u16 rq_buffer_log_size;
-#elif defined(__LITTLE_ENDIAN)
-        u16 rq_buffer_log_size;
-        u16 cq_num_wqes;
+        u8 opcode;
+        u8 op_attr;
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_NSG (0x3<<0)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_NSG_SHIFT 0
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_CSG (0x3<<2)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_CSG_SHIFT 2
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_RSRV0 (0x3<<4)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_RSRV0_SHIFT 4
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_CONTINUE_FLG (0x1<<6)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_CONTINUE_FLG_SHIFT 6
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_TRANSIT (0x1<<7)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_TRANSIT_SHIFT 7
+        u8 version_max;
+        u8 version_min;
+#elif defined(__LITTLE_ENDIAN)
+        u8 version_min;
+        u8 version_max;
+        u8 op_attr;
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_NSG (0x3<<0)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_NSG_SHIFT 0
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_CSG (0x3<<2)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_CSG_SHIFT 2
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_RSRV0 (0x3<<4)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_RSRV0_SHIFT 4
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_CONTINUE_FLG (0x1<<6)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_CONTINUE_FLG_SHIFT 6
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_TRANSIT (0x1<<7)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_TRANSIT_SHIFT 7
+        u8 opcode;
 #endif
+        u32 data_fields;
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH (0xFFFFFF<<0)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH_SHIFT 0
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH (0xFF<<24)
+#define ISCSI_LOGIN_REQ_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH_SHIFT 24
+        u32 isid_lo;
 #if defined(__BIG_ENDIAN)
-        u8 flags;
-#define FCOE_KWQE_INIT1_LOG_PAGE_SIZE (0xF<<0)
-#define FCOE_KWQE_INIT1_LOG_PAGE_SIZE_SHIFT 0
-#define FCOE_KWQE_INIT1_LOG_CACHED_PBES_PER_FUNC (0x7<<4)
-#define FCOE_KWQE_INIT1_LOG_CACHED_PBES_PER_FUNC_SHIFT 4
-#define FCOE_KWQE_INIT1_RESERVED1 (0x1<<7)
-#define FCOE_KWQE_INIT1_RESERVED1_SHIFT 7
-        u8 num_sessions_log;
-        u16 mtu;
+        u16 isid_hi;
+        u16 tsih;
 #elif defined(__LITTLE_ENDIAN)
-        u16 mtu;
-        u8 num_sessions_log;
-        u8 flags;
-#define FCOE_KWQE_INIT1_LOG_PAGE_SIZE (0xF<<0)
-#define FCOE_KWQE_INIT1_LOG_PAGE_SIZE_SHIFT 0
-#define FCOE_KWQE_INIT1_LOG_CACHED_PBES_PER_FUNC (0x7<<4)
-#define FCOE_KWQE_INIT1_LOG_CACHED_PBES_PER_FUNC_SHIFT 4
-#define FCOE_KWQE_INIT1_RESERVED1 (0x1<<7)
-#define FCOE_KWQE_INIT1_RESERVED1_SHIFT 7
+        u16 tsih;
+        u16 isid_hi;
 #endif
-};
-
-/*
- * FCoE firmware init request 2
- */
-struct fcoe_kwqe_init2 {
+        u32 itt;
 #if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
+        u16 cid;
+        u16 rsrv1;
 #elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
-        struct fcoe_kwqe_header hdr;
+        u16 rsrv1;
+        u16 cid;
 #endif
-        u32 hash_tbl_pbl_addr_lo;
-        u32 hash_tbl_pbl_addr_hi;
-        u32 t2_hash_tbl_addr_lo;
-        u32 t2_hash_tbl_addr_hi;
-        u32 t2_ptr_hash_tbl_addr_lo;
-        u32 t2_ptr_hash_tbl_addr_hi;
-        u32 free_list_count;
+        u32 cmd_sn;
+        u32 exp_stat_sn;
+        u32 rsrv2[4];
 };
 
 /*
- * FCoE firmware init request 3
+ * PDU header of an iSCSI logout request
  */
-struct fcoe_kwqe_init3 {
+struct iscsi_logout_req_hdr_little_endian {
 #if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
+        u8 opcode;
+        u8 op_attr;
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_REASON_CODE (0x7F<<0)
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_REASON_CODE_SHIFT 0
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_RSRV1_1 (0x1<<7)
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_RSRV1_1_SHIFT 7
+        u16 rsrv0;
 #elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
-        struct fcoe_kwqe_header hdr;
+        u16 rsrv0;
+        u8 op_attr;
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_REASON_CODE (0x7F<<0)
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_REASON_CODE_SHIFT 0
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_RSRV1_1 (0x1<<7)
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_RSRV1_1_SHIFT 7
+        u8 opcode;
 #endif
-        u32 error_bit_map_lo;
-        u32 error_bit_map_hi;
+        u32 data_fields;
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH (0xFFFFFF<<0)
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH_SHIFT 0
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH (0xFF<<24)
+#define ISCSI_LOGOUT_REQ_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH_SHIFT 24
+        u32 rsrv2[2];
+        u32 itt;
 #if defined(__BIG_ENDIAN)
-        u8 reserved21[3];
-        u8 cached_session_enable;
+        u16 cid;
+        u16 rsrv1;
 #elif defined(__LITTLE_ENDIAN)
-        u8 cached_session_enable;
-        u8 reserved21[3];
+        u16 rsrv1;
+        u16 cid;
 #endif
-        u32 reserved2[4];
+        u32 cmd_sn;
+        u32 exp_stat_sn;
+        u32 rsrv3[4];
 };
 
 /*
- * FCoE connection offload request 1
+ * PDU header of an iSCSI TMF request
  */
-struct fcoe_kwqe_conn_offload1 {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 fcoe_conn_id;
-#elif defined(__LITTLE_ENDIAN)
-        u16 fcoe_conn_id;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u32 sq_addr_lo;
-        u32 sq_addr_hi;
-        u32 rq_pbl_addr_lo;
-        u32 rq_pbl_addr_hi;
-        u32 rq_first_pbe_addr_lo;
-        u32 rq_first_pbe_addr_hi;
+struct iscsi_tmf_req_hdr_little_endian {
 #if defined(__BIG_ENDIAN)
-        u16 reserved0;
-        u16 rq_prod;
+        u8 opcode;
+        u8 op_attr;
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_FUNCTION (0x7F<<0)
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_FUNCTION_SHIFT 0
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_RSRV1_1 (0x1<<7)
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_RSRV1_1_SHIFT 7
+        u16 rsrv0;
 #elif defined(__LITTLE_ENDIAN)
-        u16 rq_prod;
-        u16 reserved0;
+        u16 rsrv0;
+        u8 op_attr;
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_FUNCTION (0x7F<<0)
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_FUNCTION_SHIFT 0
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_RSRV1_1 (0x1<<7)
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_RSRV1_1_SHIFT 7
+        u8 opcode;
 #endif
+        u32 data_fields;
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH (0xFFFFFF<<0)
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH_SHIFT 0
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH (0xFF<<24)
+#define ISCSI_TMF_REQ_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH_SHIFT 24
+        struct regpair lun;
+        u32 itt;
+        u32 referenced_task_tag;
+        u32 cmd_sn;
+        u32 exp_stat_sn;
+        u32 ref_cmd_sn;
+        u32 exp_data_sn;
+        u32 rsrv2[2];
 };
 
 /*
- * FCoE connection offload request 2
+ * PDU header of an iSCSI Text request
  */
-struct fcoe_kwqe_conn_offload2 {
+struct iscsi_text_req_hdr_little_endian {
 #if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 tx_max_fc_pay_len;
+        u8 opcode;
+        u8 op_attr;
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_RSRV1 (0x3F<<0)
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_RSRV1_SHIFT 0
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_CONTINUE_FLG (0x1<<6)
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_CONTINUE_FLG_SHIFT 6
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_FINAL (0x1<<7)
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_FINAL_SHIFT 7
+        u16 rsrv0;
 #elif defined(__LITTLE_ENDIAN)
-        u16 tx_max_fc_pay_len;
-        struct fcoe_kwqe_header hdr;
+        u16 rsrv0;
+        u8 op_attr;
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_RSRV1 (0x3F<<0)
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_RSRV1_SHIFT 0
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_CONTINUE_FLG (0x1<<6)
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_CONTINUE_FLG_SHIFT 6
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_FINAL (0x1<<7)
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_FINAL_SHIFT 7
+        u8 opcode;
 #endif
-        u32 cq_addr_lo;
-        u32 cq_addr_hi;
-        u32 xferq_addr_lo;
-        u32 xferq_addr_hi;
-        u32 conn_db_addr_lo;
-        u32 conn_db_addr_hi;
-        u32 reserved1;
+        u32 data_fields;
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH (0xFFFFFF<<0)
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH_SHIFT 0
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH (0xFF<<24)
+#define ISCSI_TEXT_REQ_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH_SHIFT 24
+        struct regpair lun;
+        u32 itt;
+        u32 ttt;
+        u32 cmd_sn;
+        u32 exp_stat_sn;
+        u32 rsrv3[4];
 };
 
 /*
- * FCoE connection offload request 3
+ * PDU header of an iSCSI Nop-Out
  */
-struct fcoe_kwqe_conn_offload3 {
+struct iscsi_nop_out_hdr_little_endian {
 #if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 vlan_tag;
-#define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID (0xFFF<<0)
-#define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID_SHIFT 0
-#define FCOE_KWQE_CONN_OFFLOAD3_CFI (0x1<<12)
-#define FCOE_KWQE_CONN_OFFLOAD3_CFI_SHIFT 12
-#define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY (0x7<<13)
-#define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY_SHIFT 13
-#elif defined(__LITTLE_ENDIAN)
-        u16 vlan_tag;
-#define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID (0xFFF<<0)
-#define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID_SHIFT 0
-#define FCOE_KWQE_CONN_OFFLOAD3_CFI (0x1<<12)
-#define FCOE_KWQE_CONN_OFFLOAD3_CFI_SHIFT 12
-#define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY (0x7<<13)
-#define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY_SHIFT 13
-        struct fcoe_kwqe_header hdr;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 tx_max_conc_seqs_c3;
-        u8 s_id[3];
-#elif defined(__LITTLE_ENDIAN)
-        u8 s_id[3];
-        u8 tx_max_conc_seqs_c3;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 flags;
-#define FCOE_KWQE_CONN_OFFLOAD3_B_MUL_N_PORT_IDS (0x1<<0)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_MUL_N_PORT_IDS_SHIFT 0
-#define FCOE_KWQE_CONN_OFFLOAD3_B_E_D_TOV_RES (0x1<<1)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_E_D_TOV_RES_SHIFT 1
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT (0x1<<2)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT_SHIFT 2
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ (0x1<<3)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ_SHIFT 3
-#define FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID (0x1<<4)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID_SHIFT 4
-#define FCOE_KWQE_CONN_OFFLOAD3_B_C2_VALID (0x1<<5)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_C2_VALID_SHIFT 5
-#define FCOE_KWQE_CONN_OFFLOAD3_B_ACK_0 (0x1<<6)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_ACK_0_SHIFT 6
-#define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG (0x1<<7)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG_SHIFT 7
-        u8 d_id[3];
-#elif defined(__LITTLE_ENDIAN)
-        u8 d_id[3];
-        u8 flags;
-#define FCOE_KWQE_CONN_OFFLOAD3_B_MUL_N_PORT_IDS (0x1<<0)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_MUL_N_PORT_IDS_SHIFT 0
-#define FCOE_KWQE_CONN_OFFLOAD3_B_E_D_TOV_RES (0x1<<1)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_E_D_TOV_RES_SHIFT 1
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT (0x1<<2)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT_SHIFT 2
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ (0x1<<3)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ_SHIFT 3
-#define FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID (0x1<<4)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID_SHIFT 4
-#define FCOE_KWQE_CONN_OFFLOAD3_B_C2_VALID (0x1<<5)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_C2_VALID_SHIFT 5
-#define FCOE_KWQE_CONN_OFFLOAD3_B_ACK_0 (0x1<<6)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_ACK_0_SHIFT 6
-#define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG (0x1<<7)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG_SHIFT 7
-#endif
-        u32 reserved;
-        u32 confq_first_pbe_addr_lo;
-        u32 confq_first_pbe_addr_hi;
-#if defined(__BIG_ENDIAN)
-        u16 rx_max_fc_pay_len;
-        u16 tx_total_conc_seqs;
-#elif defined(__LITTLE_ENDIAN)
-        u16 tx_total_conc_seqs;
-        u16 rx_max_fc_pay_len;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 rx_open_seqs_exch_c3;
-        u8 rx_max_conc_seqs_c3;
-        u16 rx_total_conc_seqs;
+        u8 opcode;
+        u8 op_attr;
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_RSRV1 (0x7F<<0)
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_RSRV1_SHIFT 0
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_RSRV2_1 (0x1<<7)
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_RSRV2_1_SHIFT 7
+        u16 rsrv0;
 #elif defined(__LITTLE_ENDIAN)
-        u16 rx_total_conc_seqs;
-        u8 rx_max_conc_seqs_c3;
-        u8 rx_open_seqs_exch_c3;
+        u16 rsrv0;
+        u8 op_attr;
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_RSRV1 (0x7F<<0)
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_RSRV1_SHIFT 0
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_RSRV2_1 (0x1<<7)
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_RSRV2_1_SHIFT 7
+        u8 opcode;
 #endif
+        u32 data_fields;
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH (0xFFFFFF<<0)
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_DATA_SEGMENT_LENGTH_SHIFT 0
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH (0xFF<<24)
+#define ISCSI_NOP_OUT_HDR_LITTLE_ENDIAN_TOTAL_AHS_LENGTH_SHIFT 24
+        struct regpair lun;
+        u32 itt;
+        u32 ttt;
+        u32 cmd_sn;
+        u32 exp_stat_sn;
+        u32 rsrv3[4];
 };
 
 /*
- * FCoE connection offload request 4
+ * iscsi pdu headers in little endian form.
  */
-struct fcoe_kwqe_conn_offload4 {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u8 reserved2;
-        u8 e_d_tov_timer_val;
-#elif defined(__LITTLE_ENDIAN)
-        u8 e_d_tov_timer_val;
-        u8 reserved2;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u8 src_mac_addr_lo32[4];
-#if defined(__BIG_ENDIAN)
-        u8 dst_mac_addr_hi16[2];
-        u8 src_mac_addr_hi16[2];
-#elif defined(__LITTLE_ENDIAN)
-        u8 src_mac_addr_hi16[2];
-        u8 dst_mac_addr_hi16[2];
-#endif
-        u8 dst_mac_addr_lo32[4];
-        u32 lcq_addr_lo;
-        u32 lcq_addr_hi;
-        u32 confq_pbl_base_addr_lo;
-        u32 confq_pbl_base_addr_hi;
+union iscsi_pdu_headers_little_endian {
+        u32 fullHeaderSize[12];
+        struct iscsi_cmd_pdu_hdr_little_endian command_pdu_hdr;
+        struct iscsi_data_pdu_hdr_little_endian data_out_pdu_hdr;
+        struct iscsi_login_req_hdr_little_endian login_req_pdu_hdr;
+        struct iscsi_logout_req_hdr_little_endian logout_req_pdu_hdr;
+        struct iscsi_tmf_req_hdr_little_endian tmf_req_pdu_hdr;
+        struct iscsi_text_req_hdr_little_endian text_req_pdu_hdr;
+        struct iscsi_nop_out_hdr_little_endian nop_out_pdu_hdr;
 };
 
-/*
- * FCoE connection enable request
- */
-struct fcoe_kwqe_conn_enable_disable {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u8 src_mac_addr_lo32[4];
-#if defined(__BIG_ENDIAN)
-        u16 vlan_tag;
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID (0xFFF<<0)
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID_SHIFT 0
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_CFI (0x1<<12)
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_CFI_SHIFT 12
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY (0x7<<13)
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY_SHIFT 13
-        u8 src_mac_addr_hi16[2];
-#elif defined(__LITTLE_ENDIAN)
-        u8 src_mac_addr_hi16[2];
-        u16 vlan_tag;
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID (0xFFF<<0)
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID_SHIFT 0
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_CFI (0x1<<12)
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_CFI_SHIFT 12
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY (0x7<<13)
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY_SHIFT 13
-#endif
-        u8 dst_mac_addr_lo32[4];
+struct iscsi_hq_bd {
+        union iscsi_pdu_headers_little_endian pdu_header;
 #if defined(__BIG_ENDIAN)
         u16 reserved1;
-        u8 dst_mac_addr_hi16[2];
+        u16 lcl_cmp_flg;
 #elif defined(__LITTLE_ENDIAN)
-        u8 dst_mac_addr_hi16[2];
+        u16 lcl_cmp_flg;
         u16 reserved1;
 #endif
+        u32 sgl_base_lo;
+        u32 sgl_base_hi;
 #if defined(__BIG_ENDIAN)
-        u8 vlan_flag;
-        u8 s_id[3];
-#elif defined(__LITTLE_ENDIAN)
-        u8 s_id[3];
-        u8 vlan_flag;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 reserved3;
-        u8 d_id[3];
+        u8 sgl_size;
+        u8 sge_index;
+        u16 sge_offset;
 #elif defined(__LITTLE_ENDIAN)
-        u8 d_id[3];
-        u8 reserved3;
+        u16 sge_offset;
+        u8 sge_index;
+        u8 sgl_size;
 #endif
-        u32 context_id;
-        u32 conn_id;
-        u32 reserved4;
 };
 
-/*
- * FCoE connection destroy request
- */
-struct fcoe_kwqe_conn_destroy {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u32 context_id;
-        u32 conn_id;
-        u32 reserved1[5];
-};
 
 /*
- * FCoe destroy request
+ * CQE data for L2 OOO connection $$KEEP_ENDIANNESS$$
  */
-struct fcoe_kwqe_destroy {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u32 reserved1[7];
+struct iscsi_l2_ooo_data {
+        __le32 iscsi_cid;
+        u8 drop_isle;
+        u8 drop_size;
+        u8 ooo_opcode;
+        u8 ooo_isle;
+        u8 reserved[8];
 };
 
-/*
- * FCoe statistics request
- */
-struct fcoe_kwqe_stat {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u32 stat_params_addr_lo;
-        u32 stat_params_addr_hi;
-        u32 reserved1[5];
-};
 
-/*
- * FCoE KWQ WQE
- */
-union fcoe_kwqe {
-        struct fcoe_kwqe_init1 init1;
-        struct fcoe_kwqe_init2 init2;
-        struct fcoe_kwqe_init3 init3;
-        struct fcoe_kwqe_conn_offload1 conn_offload1;
-        struct fcoe_kwqe_conn_offload2 conn_offload2;
-        struct fcoe_kwqe_conn_offload3 conn_offload3;
-        struct fcoe_kwqe_conn_offload4 conn_offload4;
-        struct fcoe_kwqe_conn_enable_disable conn_enable_disable;
-        struct fcoe_kwqe_conn_destroy conn_destroy;
-        struct fcoe_kwqe_destroy destroy;
-        struct fcoe_kwqe_stat statistics;
-};
 
-struct fcoe_task_ctx_entry {
-        struct fcoe_task_ctx_entry_tx_only tx_wr_only;
-        struct fcoe_task_ctx_entry_txwr_rxrd tx_wr_rx_rd;
-        struct fcoe_task_ctx_entry_tx_rx_cmn cmn;
-        struct fcoe_task_ctx_entry_rxwr_txrd rx_wr_tx_rd;
-        struct fcoe_task_ctx_entry_rx_only rx_wr_only;
-        u32 reserved[4];
-};
 
-/*
- * FCoE connection enable\disable params passed by driver to FW in FCoE enable ramrod
- */
-struct fcoe_conn_enable_disable_ramrod_params {
-        struct fcoe_kwqe_conn_enable_disable enable_disable_kwqe;
-};
 
 
-/*
- * FCoE connection offload params passed by driver to FW in FCoE offload ramrod
- */
-struct fcoe_conn_offload_ramrod_params {
-        struct fcoe_kwqe_conn_offload1 offload_kwqe1;
-        struct fcoe_kwqe_conn_offload2 offload_kwqe2;
-        struct fcoe_kwqe_conn_offload3 offload_kwqe3;
-        struct fcoe_kwqe_conn_offload4 offload_kwqe4;
+struct iscsi_task_context_entry_xuc_c_write_only {
+        u32 total_data_acked;
 };
 
-/*
- * FCoE init params passed by driver to FW in FCoE init ramrod
- */
-struct fcoe_init_ramrod_params {
-        struct fcoe_kwqe_init1 init_kwqe1;
-        struct fcoe_kwqe_init2 init_kwqe2;
-        struct fcoe_kwqe_init3 init_kwqe3;
-        struct regpair eq_addr;
-        struct regpair eq_next_page_addr;
+struct iscsi_task_context_r2t_table_entry {
+        u32 ttt;
+        u32 desired_data_len;
+};
+
+struct iscsi_task_context_entry_xuc_u_write_only {
+        u32 exp_r2t_sn;
+        struct iscsi_task_context_r2t_table_entry r2t_table[4];
 #if defined(__BIG_ENDIAN)
-        u16 sb_num;
-        u16 eq_prod;
+        u16 data_in_count;
+        u8 cq_id;
+        u8 valid_1b;
 #elif defined(__LITTLE_ENDIAN)
-        u16 eq_prod;
-        u16 sb_num;
+        u8 valid_1b;
+        u8 cq_id;
+        u16 data_in_count;
 #endif
+};
+
+struct iscsi_task_context_entry_xuc {
+        struct iscsi_task_context_entry_xuc_c_write_only write_c;
+        u32 exp_data_transfer_len;
+        struct iscsi_task_context_entry_xuc_x_write_only write_x;
+        u32 lun_lo;
+        struct iscsi_task_context_entry_xuc_xu_write_both write_xu;
+        u32 lun_hi;
+        struct iscsi_task_context_entry_xuc_u_write_only write_u;
+};
+
+struct iscsi_task_context_entry_u {
+        u32 exp_r2t_buff_offset;
+        u32 rem_rcv_len;
+        u32 exp_data_sn;
+};
+
+struct iscsi_task_context_entry {
+        struct iscsi_task_context_entry_x tce_x;
 #if defined(__BIG_ENDIAN)
-        u16 reserved1;
-        u8 reserved0;
-        u8 sb_id;
+        u16 data_out_count;
+        u16 rsrv0;
 #elif defined(__LITTLE_ENDIAN)
-        u8 sb_id;
-        u8 reserved0;
-        u16 reserved1;
+        u16 rsrv0;
+        u16 data_out_count;
 #endif
+        struct iscsi_task_context_entry_xuc tce_xuc;
+        struct iscsi_task_context_entry_u tce_u;
+        u32 rsrv1[7];
 };
 
 
-/*
- * FCoE statistics params buffer passed by driver to FW in FCoE statistics ramrod
- */
-struct fcoe_stat_ramrod_params {
-        struct fcoe_kwqe_stat stat_kwqe;
-};
 
 
-/*
- * FCoE 16-bits vlan structure
- */
-struct fcoe_vlan_fields {
-        u16 fields;
-#define FCOE_VLAN_FIELDS_VID (0xFFF<<0)
-#define FCOE_VLAN_FIELDS_VID_SHIFT 0
-#define FCOE_VLAN_FIELDS_CLI (0x1<<12)
-#define FCOE_VLAN_FIELDS_CLI_SHIFT 12
-#define FCOE_VLAN_FIELDS_PRI (0x7<<13)
-#define FCOE_VLAN_FIELDS_PRI_SHIFT 13
-};
 
 
-/*
- * FCoE 16-bits vlan union
- */
-union fcoe_vlan_field_union {
-        struct fcoe_vlan_fields fields;
-        u16 val;
-};
 
-/*
- * Parameters used for Class 2 verifications
- */
-struct ustorm_fcoe_c2_params {
-#if defined(__BIG_ENDIAN)
-        u16 e2e_credit;
-        u16 con_seq;
-#elif defined(__LITTLE_ENDIAN)
-        u16 con_seq;
-        u16 e2e_credit;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 ackq_prod;
-        u16 open_seq_per_exch;
-#elif defined(__LITTLE_ENDIAN)
-        u16 open_seq_per_exch;
-        u16 ackq_prod;
-#endif
-        struct regpair ackq_pbl_base;
-        struct regpair ackq_cur_seg;
-};
 
-/*
- * Parameters used for Class 2 verifications
- */
-struct xstorm_fcoe_c2_params {
-#if defined(__BIG_ENDIAN)
-        u16 reserved0;
-        u8 ackq_x_prod;
-        u8 max_conc_seqs_c2;
-#elif defined(__LITTLE_ENDIAN)
-        u8 max_conc_seqs_c2;
-        u8 ackq_x_prod;
-        u16 reserved0;
-#endif
-        struct regpair ackq_pbl_base;
-        struct regpair ackq_cur_seg;
+struct iscsi_task_context_entry_xuc_x_init_only {
+        struct regpair lun;
+        u32 exp_data_transfer_len;
 };
 
-/*
- * Buffer per connection, used in Tstorm
- */
-struct iscsi_conn_buf {
-        struct regpair reserved[8];
-};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /*
  * ipv6 structure
@@ -4379,6 +5067,8 @@ struct ip_v6_addr {
         u32 ip_addr_hi_hi;
 };
 
+
+
 /*
  * l5cm- connection identification params
  */
@@ -4460,8 +5150,7 @@ struct l5cm_xstorm_conn_buffer {
  * l5cm-tstorm connection buffer
  */
 struct l5cm_tstorm_conn_buffer {
-        u32 snd_buf;
-        u32 rcv_buf;
+        u32 rsrv1[2];
 #if defined(__BIG_ENDIAN)
         u16 params;
 #define L5CM_TSTORM_CONN_BUFFER_DELAYED_ACK_ENABLE (0x1<<0)
@@ -4493,6 +5182,72 @@ struct l5cm_active_conn_buffer {
         struct l5cm_tstorm_conn_buffer tstorm_conn_buffer;
 };
 
+
+
+/*
+ * The l5cm opaque buffer passed in add new connection ramrod passive side
+ */
+struct l5cm_hash_input_string {
+        u32 __opaque1;
+#if defined(__BIG_ENDIAN)
+        u16 __opaque3;
+        u16 __opaque2;
+#elif defined(__LITTLE_ENDIAN)
+        u16 __opaque2;
+        u16 __opaque3;
+#endif
+        struct ip_v6_addr __opaque4;
+        struct ip_v6_addr __opaque5;
+        u32 __opaque6;
+        u32 __opaque7[5];
+};
+
+
+/*
+ * syn cookie component
+ */
+struct l5cm_syn_cookie_comp {
+        u32 __opaque;
+};
+
+/*
+ * data related to listeners of a TCP port
+ */
+struct l5cm_port_listener_data {
+        u8 params;
+#define L5CM_PORT_LISTENER_DATA_ENABLE (0x1<<0)
+#define L5CM_PORT_LISTENER_DATA_ENABLE_SHIFT 0
+#define L5CM_PORT_LISTENER_DATA_IP_INDEX (0xF<<1)
+#define L5CM_PORT_LISTENER_DATA_IP_INDEX_SHIFT 1
+#define L5CM_PORT_LISTENER_DATA_NET_FILTER (0x1<<5)
+#define L5CM_PORT_LISTENER_DATA_NET_FILTER_SHIFT 5
+#define L5CM_PORT_LISTENER_DATA_DEFFERED_MODE (0x1<<6)
+#define L5CM_PORT_LISTENER_DATA_DEFFERED_MODE_SHIFT 6
+#define L5CM_PORT_LISTENER_DATA_MPA_MODE (0x1<<7)
+#define L5CM_PORT_LISTENER_DATA_MPA_MODE_SHIFT 7
+};
+
+/*
+ * Opaque structure passed from U to X when final ack arrives
+ */
+struct l5cm_opaque_buf {
+        u32 __opaque1;
+        u32 __opaque2;
+        u32 __opaque3;
+        u32 __opaque4;
+        struct l5cm_syn_cookie_comp __opaque5;
+#if defined(__BIG_ENDIAN)
+        u16 rsrv2;
+        u8 rsrv;
+        struct l5cm_port_listener_data __opaque6;
+#elif defined(__LITTLE_ENDIAN)
+        struct l5cm_port_listener_data __opaque6;
+        u8 rsrv;
+        u16 rsrv2;
+#endif
+};
+
+
 /*
  * l5cm slow path element
  */
@@ -4501,6 +5256,109 @@ struct l5cm_packet_size {
         u32 rsrv;
 };
 
+
+/*
+ * The final-ack union structure in PCS entry after final ack arrived
+ */
+struct l5cm_pcse_ack {
+        struct l5cm_xstorm_conn_buffer tx_socket_params;
+        struct l5cm_opaque_buf opaque_buf;
+        struct l5cm_tstorm_conn_buffer rx_socket_params;
+};
+
+
+/*
+ * The syn union structure in PCS entry after syn arrived
+ */
+struct l5cm_pcse_syn {
+        struct l5cm_opaque_buf opaque_buf;
+        u32 rsrv[12];
+};
+
+
+/*
+ * pcs entry data for passive connections
+ */
+struct l5cm_pcs_attributes {
+#if defined(__BIG_ENDIAN)
+        u16 pcs_id;
+        u8 status;
+        u8 flags;
+#define L5CM_PCS_ATTRIBUTES_NET_FILTER (0x1<<0)
+#define L5CM_PCS_ATTRIBUTES_NET_FILTER_SHIFT 0
+#define L5CM_PCS_ATTRIBUTES_CALCULATE_HASH (0x1<<1)
+#define L5CM_PCS_ATTRIBUTES_CALCULATE_HASH_SHIFT 1
+#define L5CM_PCS_ATTRIBUTES_COMPARE_HASH_RESULT (0x1<<2)
+#define L5CM_PCS_ATTRIBUTES_COMPARE_HASH_RESULT_SHIFT 2
+#define L5CM_PCS_ATTRIBUTES_QUERY_ULP_ACCEPT (0x1<<3)
+#define L5CM_PCS_ATTRIBUTES_QUERY_ULP_ACCEPT_SHIFT 3
+#define L5CM_PCS_ATTRIBUTES_FIND_DEST_MAC (0x1<<4)
+#define L5CM_PCS_ATTRIBUTES_FIND_DEST_MAC_SHIFT 4
+#define L5CM_PCS_ATTRIBUTES_L4_OFFLOAD (0x1<<5)
+#define L5CM_PCS_ATTRIBUTES_L4_OFFLOAD_SHIFT 5
+#define L5CM_PCS_ATTRIBUTES_FORWARD_PACKET (0x1<<6)
+#define L5CM_PCS_ATTRIBUTES_FORWARD_PACKET_SHIFT 6
+#define L5CM_PCS_ATTRIBUTES_RSRV (0x1<<7)
+#define L5CM_PCS_ATTRIBUTES_RSRV_SHIFT 7
+#elif defined(__LITTLE_ENDIAN)
+        u8 flags;
+#define L5CM_PCS_ATTRIBUTES_NET_FILTER (0x1<<0)
+#define L5CM_PCS_ATTRIBUTES_NET_FILTER_SHIFT 0
+#define L5CM_PCS_ATTRIBUTES_CALCULATE_HASH (0x1<<1)
+#define L5CM_PCS_ATTRIBUTES_CALCULATE_HASH_SHIFT 1
+#define L5CM_PCS_ATTRIBUTES_COMPARE_HASH_RESULT (0x1<<2)
+#define L5CM_PCS_ATTRIBUTES_COMPARE_HASH_RESULT_SHIFT 2
+#define L5CM_PCS_ATTRIBUTES_QUERY_ULP_ACCEPT (0x1<<3)
+#define L5CM_PCS_ATTRIBUTES_QUERY_ULP_ACCEPT_SHIFT 3
+#define L5CM_PCS_ATTRIBUTES_FIND_DEST_MAC (0x1<<4)
+#define L5CM_PCS_ATTRIBUTES_FIND_DEST_MAC_SHIFT 4
+#define L5CM_PCS_ATTRIBUTES_L4_OFFLOAD (0x1<<5)
+#define L5CM_PCS_ATTRIBUTES_L4_OFFLOAD_SHIFT 5
+#define L5CM_PCS_ATTRIBUTES_FORWARD_PACKET (0x1<<6)
+#define L5CM_PCS_ATTRIBUTES_FORWARD_PACKET_SHIFT 6
+#define L5CM_PCS_ATTRIBUTES_RSRV (0x1<<7)
+#define L5CM_PCS_ATTRIBUTES_RSRV_SHIFT 7
+        u8 status;
+        u16 pcs_id;
+#endif
+};
+
+
+union l5cm_seg_params {
+        struct l5cm_pcse_syn syn_seg_params;
+        struct l5cm_pcse_ack ack_seg_params;
+};
+
+/*
+ * pcs entry data for passive connections
+ */
+struct l5cm_pcs_hdr {
+        struct l5cm_hash_input_string hash_input_string;
+        struct l5cm_conn_addr_params conn_addr_buf;
+        u32 cid;
+        u32 hash_result;
+        union l5cm_seg_params seg_params;
+        struct l5cm_pcs_attributes att;
+#if defined(__BIG_ENDIAN)
+        u16 rsrv;
+        u16 rx_seg_size;
+#elif defined(__LITTLE_ENDIAN)
+        u16 rx_seg_size;
+        u16 rsrv;
+#endif
+};
+
+/*
+ * pcs entry for passive connections
+ */
+struct l5cm_pcs_entry {
+        struct l5cm_pcs_hdr hdr;
+        u8 rx_segment[1516];
+};
+
+
+
+
 /*
  * l5cm connection parameters
  */
@@ -4535,6 +5393,29 @@ struct l5cm_spe {
         union l5cm_specific_data data;
 };
 
+
+
+
+/*
+ * Termination variables
+ */
+struct l5cm_term_vars {
+        u8 BitMap;
+#define L5CM_TERM_VARS_TCP_STATE (0xF<<0)
+#define L5CM_TERM_VARS_TCP_STATE_SHIFT 0
+#define L5CM_TERM_VARS_FIN_RECEIVED_SBIT (0x1<<4)
+#define L5CM_TERM_VARS_FIN_RECEIVED_SBIT_SHIFT 4
+#define L5CM_TERM_VARS_ACK_ON_FIN_RECEIVED_SBIT (0x1<<5)
+#define L5CM_TERM_VARS_ACK_ON_FIN_RECEIVED_SBIT_SHIFT 5
+#define L5CM_TERM_VARS_TERM_ON_CHIP (0x1<<6)
+#define L5CM_TERM_VARS_TERM_ON_CHIP_SHIFT 6
+#define L5CM_TERM_VARS_RSRV (0x1<<7)
+#define L5CM_TERM_VARS_RSRV_SHIFT 7
+};
+
+
+
+
 /*
  * Tstorm Tcp flags
  */
@@ -4550,6 +5431,7 @@ struct tstorm_l5cm_tcp_flags {
 #define TSTORM_L5CM_TCP_FLAGS_RSRV1_SHIFT 14
 };
 
+
 /*
  * Xstorm Tcp flags
  */
@@ -4565,4 +5447,38 @@ struct xstorm_l5cm_tcp_flags {
 #define XSTORM_L5CM_TCP_FLAGS_RSRV_SHIFT 3
 };
 
-#endif /* CNIC_DEFS_H */
+
+
+/*
+ * Out-of-order states
+ */
+enum tcp_ooo_event {
+        TCP_EVENT_ADD_PEN = 0,
+        TCP_EVENT_ADD_NEW_ISLE = 1,
+        TCP_EVENT_ADD_ISLE_RIGHT = 2,
+        TCP_EVENT_ADD_ISLE_LEFT = 3,
+        TCP_EVENT_JOIN = 4,
+        TCP_EVENT_NOP = 5,
+        MAX_TCP_OOO_EVENT
+};
+
+
+/*
+ * OOO support modes
+ */
+enum tcp_tstorm_ooo {
+        TCP_TSTORM_OOO_DROP_AND_PROC_ACK = 0,
+        TCP_TSTORM_OOO_SEND_PURE_ACK = 1,
+        TCP_TSTORM_OOO_SUPPORTED = 2,
+        MAX_TCP_TSTORM_OOO
+};
+
+
+
+
+
+
+
+
+
+#endif /* __5710_HSI_CNIC_LE__ */
diff --git a/drivers/net/cnic_if.h b/drivers/net/cnic_if.h
index fdd8e46a9050..bc7000a2d4e1 100644
--- a/drivers/net/cnic_if.h
+++ b/drivers/net/cnic_if.h
@@ -12,8 +12,8 @@
 #ifndef CNIC_IF_H
 #define CNIC_IF_H
 
-#define CNIC_MODULE_VERSION     "2.2.14"
-#define CNIC_MODULE_RELDATE     "Mar 30, 2011"
+#define CNIC_MODULE_VERSION     "2.5.3"
+#define CNIC_MODULE_RELDATE     "June 6, 2011"
 
 #define CNIC_ULP_RDMA           0
 #define CNIC_ULP_ISCSI          1
@@ -99,6 +99,8 @@ struct kcqe {
 
 struct cnic_ctl_completion {
         u32     cid;
+        u8      opcode;
+        u8      error;
 };
 
 struct cnic_ctl_info {
@@ -169,7 +171,7 @@ struct cnic_eth_dev {
         struct pci_dev  *pdev;
         void __iomem    *io_base;
         void __iomem    *io_base2;
-        void            *iro_arr;
+        const void      *iro_arr;
 
         u32             ctx_tbl_offset;
         u32             ctx_tbl_len;
diff --git a/drivers/scsi/bnx2fc/57xx_hsi_bnx2fc.h b/drivers/scsi/bnx2fc/57xx_hsi_bnx2fc.h
index 97a61b4d81b7..e1f1e3448f98 100644
--- a/drivers/scsi/bnx2fc/57xx_hsi_bnx2fc.h
+++ b/drivers/scsi/bnx2fc/57xx_hsi_bnx2fc.h
@@ -19,6 +19,23 @@ struct b577xx_doorbell_hdr {
 /*
  * doorbell message sent to the chip
  */
+struct b577xx_doorbell {
+#if defined(__BIG_ENDIAN)
+        u16 zero_fill2;
+        u8 zero_fill1;
+        struct b577xx_doorbell_hdr header;
+#elif defined(__LITTLE_ENDIAN)
+        struct b577xx_doorbell_hdr header;
+        u8 zero_fill1;
+        u16 zero_fill2;
+#endif
+};
+
+
+
+/*
+ * doorbell message sent to the chip
+ */
 struct b577xx_doorbell_set_prod {
 #if defined(__BIG_ENDIAN)
         u16 prod;
@@ -39,106 +56,63 @@ struct regpair {
 
 
 /*
- * Fixed size structure in order to plant it in Union structure
+ * ABTS info $$KEEP_ENDIANNESS$$
  */
-struct fcoe_abts_rsp_union {
-        u32 r_ctl;
-        u32 abts_rsp_payload[7];
+struct fcoe_abts_info {
+        __le16 aborted_task_id;
+        __le16 reserved0;
+        __le32 reserved1;
 };
 
 
 /*
- * 4 regs size
+ * Fixed size structure in order to plant it in Union structure
+ * $$KEEP_ENDIANNESS$$
  */
-struct fcoe_bd_ctx {
-        u32 buf_addr_hi;
-        u32 buf_addr_lo;
-#if defined(__BIG_ENDIAN)
-        u16 rsrv0;
-        u16 buf_len;
-#elif defined(__LITTLE_ENDIAN)
-        u16 buf_len;
-        u16 rsrv0;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 rsrv1;
-        u16 flags;
-#elif defined(__LITTLE_ENDIAN)
-        u16 flags;
-        u16 rsrv1;
-#endif
+struct fcoe_abts_rsp_union {
+        u8 r_ctl;
+        u8 rsrv[3];
+        __le32 abts_rsp_payload[7];
 };
 
 
-struct fcoe_cleanup_flow_info {
-#if defined(__BIG_ENDIAN)
-        u16 reserved1;
-        u16 task_id;
-#elif defined(__LITTLE_ENDIAN)
-        u16 task_id;
-        u16 reserved1;
-#endif
-        u32 reserved2[7];
+/*
+ * 4 regs size $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_bd_ctx {
+        __le32 buf_addr_hi;
+        __le32 buf_addr_lo;
+        __le16 buf_len;
+        __le16 rsrv0;
+        __le16 flags;
+        __le16 rsrv1;
 };
 
 
-struct fcoe_fcp_cmd_payload {
-        u32 opaque[8];
-};
-
-struct fcoe_fc_hdr {
-#if defined(__BIG_ENDIAN)
-        u8 cs_ctl;
-        u8 s_id[3];
-#elif defined(__LITTLE_ENDIAN)
-        u8 s_id[3];
-        u8 cs_ctl;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 r_ctl;
-        u8 d_id[3];
-#elif defined(__LITTLE_ENDIAN)
-        u8 d_id[3];
-        u8 r_ctl;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 seq_id;
-        u8 df_ctl;
-        u16 seq_cnt;
-#elif defined(__LITTLE_ENDIAN)
-        u16 seq_cnt;
-        u8 df_ctl;
-        u8 seq_id;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 type;
-        u8 f_ctl[3];
-#elif defined(__LITTLE_ENDIAN)
-        u8 f_ctl[3];
-        u8 type;
-#endif
-        u32 parameters;
-#if defined(__BIG_ENDIAN)
-        u16 ox_id;
-        u16 rx_id;
-#elif defined(__LITTLE_ENDIAN)
-        u16 rx_id;
-        u16 ox_id;
-#endif
+/*
+ * FCoE cached sges context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_cached_sge_ctx {
+        struct regpair cur_buf_addr;
+        __le16 cur_buf_rem;
+        __le16 second_buf_rem;
+        struct regpair second_buf_addr;
 };
 
-struct fcoe_fc_frame {
-        struct fcoe_fc_hdr fc_hdr;
-        u32 reserved0[2];
-};
 
-union fcoe_cmd_flow_info {
-        struct fcoe_fcp_cmd_payload fcp_cmd_payload;
-        struct fcoe_fc_frame mp_fc_frame;
+/*
+ * Cleanup info $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_cleanup_info {
+        __le16 cleaned_task_id;
+        __le16 rolled_tx_seq_cnt;
+        __le32 rolled_tx_data_offset;
 };
 
 
-
+/*
+ * Fcp RSP flags $$KEEP_ENDIANNESS$$
+ */
 struct fcoe_fcp_rsp_flags {
         u8 flags;
 #define FCOE_FCP_RSP_FLAGS_FCP_RSP_LEN_VALID (0x1<<0)
@@ -155,95 +129,168 @@ struct fcoe_fcp_rsp_flags {
 #define FCOE_FCP_RSP_FLAGS_FCP_BIDI_FLAGS_SHIFT 5
 };
 
-
+/*
+ * Fcp RSP payload $$KEEP_ENDIANNESS$$
+ */
 struct fcoe_fcp_rsp_payload {
         struct regpair reserved0;
-        u32 fcp_resid;
-#if defined(__BIG_ENDIAN)
-        u16 retry_delay_timer;
-        struct fcoe_fcp_rsp_flags fcp_flags;
-        u8 scsi_status_code;
-#elif defined(__LITTLE_ENDIAN)
+        __le32 fcp_resid;
         u8 scsi_status_code;
         struct fcoe_fcp_rsp_flags fcp_flags;
-        u16 retry_delay_timer;
-#endif
-        u32 fcp_rsp_len;
-        u32 fcp_sns_len;
+        __le16 retry_delay_timer;
+        __le32 fcp_rsp_len;
+        __le32 fcp_sns_len;
 };
 
-
 /*
  * Fixed size structure in order to plant it in Union structure
+ * $$KEEP_ENDIANNESS$$
  */
 struct fcoe_fcp_rsp_union {
         struct fcoe_fcp_rsp_payload payload;
         struct regpair reserved0;
 };
 
+/*
+ * FC header $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fc_hdr {
+        u8 s_id[3];
+        u8 cs_ctl;
+        u8 d_id[3];
+        u8 r_ctl;
+        __le16 seq_cnt;
+        u8 df_ctl;
+        u8 seq_id;
+        u8 f_ctl[3];
+        u8 type;
+        __le32 parameters;
+        __le16 rx_id;
+        __le16 ox_id;
+};
 
-struct fcoe_fcp_xfr_rdy_payload {
-        u32 burst_len;
-        u32 data_ro;
+/*
+ * FC header union $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_mp_rsp_union {
+        struct fcoe_fc_hdr fc_hdr;
+        __le32 mp_payload_len;
+        __le32 rsrv;
 };
 
-struct fcoe_read_flow_info {
-        struct fcoe_fc_hdr fc_data_in_hdr;
-        u32 reserved[2];
+/*
+ * Completion information $$KEEP_ENDIANNESS$$
+ */
+union fcoe_comp_flow_info {
+        struct fcoe_fcp_rsp_union fcp_rsp;
+        struct fcoe_abts_rsp_union abts_rsp;
+        struct fcoe_mp_rsp_union mp_rsp;
+        __le32 opaque[8];
 };
 
-struct fcoe_write_flow_info {
-        struct fcoe_fc_hdr fc_data_out_hdr;
-        struct fcoe_fcp_xfr_rdy_payload fcp_xfr_payload;
+
+/*
+ * External ABTS info $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_ext_abts_info {
+        __le32 rsrv0[6];
+        struct fcoe_abts_info ctx;
 };
 
-union fcoe_rsp_flow_info {
-        struct fcoe_fcp_rsp_union fcp_rsp;
-        struct fcoe_abts_rsp_union abts_rsp;
+
+/*
+ * External cleanup info $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_ext_cleanup_info {
+        __le32 rsrv0[6];
+        struct fcoe_cleanup_info ctx;
 };
 
+
 /*
- * 32 bytes used for general purposes
+ * Fcoe FW Tx sequence context $$KEEP_ENDIANNESS$$
  */
-union fcoe_general_task_ctx {
-        union fcoe_cmd_flow_info cmd_info;
-        struct fcoe_read_flow_info read_info;
-        struct fcoe_write_flow_info write_info;
-        union fcoe_rsp_flow_info rsp_info;
-        struct fcoe_cleanup_flow_info cleanup_info;
-        u32 comp_info[8];
+struct fcoe_fw_tx_seq_ctx {
+        __le32 data_offset;
+        __le16 seq_cnt;
+        __le16 rsrv0;
+};
+
+/*
+ * Fcoe external FW Tx sequence context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_ext_fw_tx_seq_ctx {
+        __le32 rsrv0[6];
+        struct fcoe_fw_tx_seq_ctx ctx;
+};
+
+
+/*
+ * FCoE multiple sges context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_mul_sges_ctx {
+        struct regpair cur_sge_addr;
+        __le16 cur_sge_off;
+        u8 cur_sge_idx;
+        u8 sgl_size;
+};
+
+/*
+ * FCoE external multiple sges context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_ext_mul_sges_ctx {
+        struct fcoe_mul_sges_ctx mul_sgl;
+        struct regpair rsrv0;
 };
 
 
 /*
- * FCoE KCQ CQE parameters
+ * FCP CMD payload $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fcp_cmd_payload {
+        __le32 opaque[8];
+};
+
+
+
+
+
+/*
+ * Fcp xfr rdy payload $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fcp_xfr_rdy_payload {
+        __le32 burst_len;
+        __le32 data_ro;
+};
+
+
+/*
+ * FC frame $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_fc_frame {
+        struct fcoe_fc_hdr fc_hdr;
+        __le32 reserved0[2];
+};
+
+
+
+
+/*
+ * FCoE KCQ CQE parameters $$KEEP_ENDIANNESS$$
  */
 union fcoe_kcqe_params {
-        u32 reserved0[4];
+        __le32 reserved0[4];
 };
 
 /*
- * FCoE KCQ CQE
+ * FCoE KCQ CQE $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kcqe {
-        u32 fcoe_conn_id;
-        u32 completion_status;
-        u32 fcoe_conn_context_id;
+        __le32 fcoe_conn_id;
+        __le32 completion_status;
+        __le32 fcoe_conn_context_id;
         union fcoe_kcqe_params params;
-#if defined(__BIG_ENDIAN)
-        u8 flags;
-#define FCOE_KCQE_RESERVED0 (0x7<<0)
-#define FCOE_KCQE_RESERVED0_SHIFT 0
-#define FCOE_KCQE_RAMROD_COMPLETION (0x1<<3)
-#define FCOE_KCQE_RAMROD_COMPLETION_SHIFT 3
-#define FCOE_KCQE_LAYER_CODE (0x7<<4)
-#define FCOE_KCQE_LAYER_CODE_SHIFT 4
-#define FCOE_KCQE_LINKED_WITH_NEXT (0x1<<7)
-#define FCOE_KCQE_LINKED_WITH_NEXT_SHIFT 7
-        u8 op_code;
-        u16 qe_self_seq;
-#elif defined(__LITTLE_ENDIAN)
-        u16 qe_self_seq;
+        __le16 qe_self_seq;
         u8 op_code;
         u8 flags;
 #define FCOE_KCQE_RESERVED0 (0x7<<0)
@@ -254,23 +301,14 @@ struct fcoe_kcqe {
 #define FCOE_KCQE_LAYER_CODE_SHIFT 4
 #define FCOE_KCQE_LINKED_WITH_NEXT (0x1<<7)
 #define FCOE_KCQE_LINKED_WITH_NEXT_SHIFT 7
-#endif
 };
 
+
+
 /*
- * FCoE KWQE header
+ * FCoE KWQE header $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_header {
-#if defined(__BIG_ENDIAN)
-        u8 flags;
-#define FCOE_KWQE_HEADER_RESERVED0 (0xF<<0)
-#define FCOE_KWQE_HEADER_RESERVED0_SHIFT 0
-#define FCOE_KWQE_HEADER_LAYER_CODE (0x7<<4)
-#define FCOE_KWQE_HEADER_LAYER_CODE_SHIFT 4
-#define FCOE_KWQE_HEADER_RESERVED1 (0x1<<7)
-#define FCOE_KWQE_HEADER_RESERVED1_SHIFT 7
-        u8 op_code;
-#elif defined(__LITTLE_ENDIAN)
         u8 op_code;
         u8 flags;
 #define FCOE_KWQE_HEADER_RESERVED0 (0xF<<0)
@@ -279,50 +317,23 @@ struct fcoe_kwqe_header {
 #define FCOE_KWQE_HEADER_LAYER_CODE_SHIFT 4
 #define FCOE_KWQE_HEADER_RESERVED1 (0x1<<7)
 #define FCOE_KWQE_HEADER_RESERVED1_SHIFT 7
-#endif
 };
 
 /*
- * FCoE firmware init request 1
+ * FCoE firmware init request 1 $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_init1 {
-#if defined(__BIG_ENDIAN)
+        __le16 num_tasks;
         struct fcoe_kwqe_header hdr;
-        u16 num_tasks;
-#elif defined(__LITTLE_ENDIAN)
-        u16 num_tasks;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u32 task_list_pbl_addr_lo;
-        u32 task_list_pbl_addr_hi;
-        u32 dummy_buffer_addr_lo;
-        u32 dummy_buffer_addr_hi;
-#if defined(__BIG_ENDIAN)
-        u16 rq_num_wqes;
-        u16 sq_num_wqes;
-#elif defined(__LITTLE_ENDIAN)
-        u16 sq_num_wqes;
-        u16 rq_num_wqes;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 cq_num_wqes;
-        u16 rq_buffer_log_size;
-#elif defined(__LITTLE_ENDIAN)
-        u16 rq_buffer_log_size;
-        u16 cq_num_wqes;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 flags;
-#define FCOE_KWQE_INIT1_LOG_PAGE_SIZE (0xF<<0)
-#define FCOE_KWQE_INIT1_LOG_PAGE_SIZE_SHIFT 0
-#define FCOE_KWQE_INIT1_LOG_CACHED_PBES_PER_FUNC (0x7<<4)
-#define FCOE_KWQE_INIT1_LOG_CACHED_PBES_PER_FUNC_SHIFT 4
-#define FCOE_KWQE_INIT1_RESERVED1 (0x1<<7)
-#define FCOE_KWQE_INIT1_RESERVED1_SHIFT 7
-        u8 num_sessions_log;
-        u16 mtu;
-#elif defined(__LITTLE_ENDIAN)
-        u16 mtu;
+        __le32 task_list_pbl_addr_lo;
+        __le32 task_list_pbl_addr_hi;
+        __le32 dummy_buffer_addr_lo;
+        __le32 dummy_buffer_addr_hi;
+        __le16 sq_num_wqes;
+        __le16 rq_num_wqes;
+        __le16 rq_buffer_log_size;
+        __le16 cq_num_wqes;
+        __le16 mtu;
         u8 num_sessions_log;
         u8 flags;
 #define FCOE_KWQE_INIT1_LOG_PAGE_SIZE (0xF<<0)
@@ -331,113 +342,73 @@ struct fcoe_kwqe_init1 {
 #define FCOE_KWQE_INIT1_LOG_CACHED_PBES_PER_FUNC_SHIFT 4
 #define FCOE_KWQE_INIT1_RESERVED1 (0x1<<7)
 #define FCOE_KWQE_INIT1_RESERVED1_SHIFT 7
-#endif
 };
 
 /*
- * FCoE firmware init request 2
+ * FCoE firmware init request 2 $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_init2 {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
+        u8 hsi_major_version;
+        u8 hsi_minor_version;
         struct fcoe_kwqe_header hdr;
-#endif
-        u32 hash_tbl_pbl_addr_lo;
-        u32 hash_tbl_pbl_addr_hi;
-        u32 t2_hash_tbl_addr_lo;
-        u32 t2_hash_tbl_addr_hi;
-        u32 t2_ptr_hash_tbl_addr_lo;
-        u32 t2_ptr_hash_tbl_addr_hi;
-        u32 free_list_count;
+        __le32 hash_tbl_pbl_addr_lo;
+        __le32 hash_tbl_pbl_addr_hi;
+        __le32 t2_hash_tbl_addr_lo;
+        __le32 t2_hash_tbl_addr_hi;
+        __le32 t2_ptr_hash_tbl_addr_lo;
+        __le32 t2_ptr_hash_tbl_addr_hi;
+        __le32 free_list_count;
 };
 
 /*
- * FCoE firmware init request 3
+ * FCoE firmware init request 3 $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_init3 {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
+        __le16 reserved0;
         struct fcoe_kwqe_header hdr;
-#endif
-        u32 error_bit_map_lo;
-        u32 error_bit_map_hi;
-#if defined(__BIG_ENDIAN)
-        u8 reserved21[3];
-        u8 cached_session_enable;
-#elif defined(__LITTLE_ENDIAN)
-        u8 cached_session_enable;
+        __le32 error_bit_map_lo;
+        __le32 error_bit_map_hi;
+        u8 perf_config;
         u8 reserved21[3];
-#endif
-        u32 reserved2[4];
+        __le32 reserved2[4];
 };
 
 /*
- * FCoE connection offload request 1
+ * FCoE connection offload request 1 $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_conn_offload1 {
-#if defined(__BIG_ENDIAN)
+        __le16 fcoe_conn_id;
         struct fcoe_kwqe_header hdr;
-        u16 fcoe_conn_id;
-#elif defined(__LITTLE_ENDIAN)
-        u16 fcoe_conn_id;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u32 sq_addr_lo;
-        u32 sq_addr_hi;
-        u32 rq_pbl_addr_lo;
-        u32 rq_pbl_addr_hi;
-        u32 rq_first_pbe_addr_lo;
-        u32 rq_first_pbe_addr_hi;
-#if defined(__BIG_ENDIAN)
-        u16 reserved0;
-        u16 rq_prod;
-#elif defined(__LITTLE_ENDIAN)
-        u16 rq_prod;
-        u16 reserved0;
-#endif
+        __le32 sq_addr_lo;
+        __le32 sq_addr_hi;
+        __le32 rq_pbl_addr_lo;
+        __le32 rq_pbl_addr_hi;
+        __le32 rq_first_pbe_addr_lo;
+        __le32 rq_first_pbe_addr_hi;
+        __le16 rq_prod;
+        __le16 reserved0;
 };
 
 /*
- * FCoE connection offload request 2
+ * FCoE connection offload request 2 $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_conn_offload2 {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 tx_max_fc_pay_len;
-#elif defined(__LITTLE_ENDIAN)
-        u16 tx_max_fc_pay_len;
+        __le16 tx_max_fc_pay_len;
         struct fcoe_kwqe_header hdr;
-#endif
-        u32 cq_addr_lo;
-        u32 cq_addr_hi;
-        u32 xferq_addr_lo;
-        u32 xferq_addr_hi;
-        u32 conn_db_addr_lo;
-        u32 conn_db_addr_hi;
-        u32 reserved1;
+        __le32 cq_addr_lo;
+        __le32 cq_addr_hi;
+        __le32 xferq_addr_lo;
+        __le32 xferq_addr_hi;
+        __le32 conn_db_addr_lo;
+        __le32 conn_db_addr_hi;
+        __le32 reserved1;
 };
 
 /*
- * FCoE connection offload request 3
+ * FCoE connection offload request 3 $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_conn_offload3 {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 vlan_tag;
-#define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID (0xFFF<<0)
-#define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID_SHIFT 0
-#define FCOE_KWQE_CONN_OFFLOAD3_CFI (0x1<<12)
-#define FCOE_KWQE_CONN_OFFLOAD3_CFI_SHIFT 12
-#define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY (0x7<<13)
-#define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY_SHIFT 13
-#elif defined(__LITTLE_ENDIAN)
-        u16 vlan_tag;
+        __le16 vlan_tag;
 #define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID (0xFFF<<0)
 #define FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID_SHIFT 0
 #define FCOE_KWQE_CONN_OFFLOAD3_CFI (0x1<<12)
@@ -445,34 +416,8 @@ struct fcoe_kwqe_conn_offload3 {
 #define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY (0x7<<13)
 #define FCOE_KWQE_CONN_OFFLOAD3_PRIORITY_SHIFT 13
         struct fcoe_kwqe_header hdr;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 tx_max_conc_seqs_c3;
-        u8 s_id[3];
-#elif defined(__LITTLE_ENDIAN)
         u8 s_id[3];
         u8 tx_max_conc_seqs_c3;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 flags;
-#define FCOE_KWQE_CONN_OFFLOAD3_B_MUL_N_PORT_IDS (0x1<<0)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_MUL_N_PORT_IDS_SHIFT 0
-#define FCOE_KWQE_CONN_OFFLOAD3_B_E_D_TOV_RES (0x1<<1)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_E_D_TOV_RES_SHIFT 1
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT (0x1<<2)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT_SHIFT 2
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ (0x1<<3)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ_SHIFT 3
-#define FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID (0x1<<4)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID_SHIFT 4
-#define FCOE_KWQE_CONN_OFFLOAD3_B_C2_VALID (0x1<<5)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_C2_VALID_SHIFT 5
-#define FCOE_KWQE_CONN_OFFLOAD3_B_ACK_0 (0x1<<6)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_ACK_0_SHIFT 6
-#define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG (0x1<<7)
-#define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG_SHIFT 7
-        u8 d_id[3];
-#elif defined(__LITTLE_ENDIAN)
         u8 d_id[3];
         u8 flags;
 #define FCOE_KWQE_CONN_OFFLOAD3_B_MUL_N_PORT_IDS (0x1<<0)
@@ -491,79 +436,44 @@ struct fcoe_kwqe_conn_offload3 {
 #define FCOE_KWQE_CONN_OFFLOAD3_B_ACK_0_SHIFT 6
 #define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG (0x1<<7)
 #define FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG_SHIFT 7
-#endif
-        u32 reserved;
-        u32 confq_first_pbe_addr_lo;
-        u32 confq_first_pbe_addr_hi;
-#if defined(__BIG_ENDIAN)
-        u16 rx_max_fc_pay_len;
-        u16 tx_total_conc_seqs;
-#elif defined(__LITTLE_ENDIAN)
-        u16 tx_total_conc_seqs;
-        u16 rx_max_fc_pay_len;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 rx_open_seqs_exch_c3;
-        u8 rx_max_conc_seqs_c3;
-        u16 rx_total_conc_seqs;
-#elif defined(__LITTLE_ENDIAN)
-        u16 rx_total_conc_seqs;
+        __le32 reserved;
+        __le32 confq_first_pbe_addr_lo;
+        __le32 confq_first_pbe_addr_hi;
+        __le16 tx_total_conc_seqs;
+        __le16 rx_max_fc_pay_len;
+        __le16 rx_total_conc_seqs;
         u8 rx_max_conc_seqs_c3;
         u8 rx_open_seqs_exch_c3;
-#endif
 };
 
 /*
- * FCoE connection offload request 4
+ * FCoE connection offload request 4 $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_conn_offload4 {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u8 reserved2;
-        u8 e_d_tov_timer_val;
-#elif defined(__LITTLE_ENDIAN)
         u8 e_d_tov_timer_val;
         u8 reserved2;
         struct fcoe_kwqe_header hdr;
-#endif
-        u8 src_mac_addr_lo32[4];
-#if defined(__BIG_ENDIAN)
-        u8 dst_mac_addr_hi16[2];
-        u8 src_mac_addr_hi16[2];
-#elif defined(__LITTLE_ENDIAN)
-        u8 src_mac_addr_hi16[2];
-        u8 dst_mac_addr_hi16[2];
-#endif
-        u8 dst_mac_addr_lo32[4];
-        u32 lcq_addr_lo;
-        u32 lcq_addr_hi;
-        u32 confq_pbl_base_addr_lo;
-        u32 confq_pbl_base_addr_hi;
+        u8 src_mac_addr_lo[2];
+        u8 src_mac_addr_mid[2];
+        u8 src_mac_addr_hi[2];
+        u8 dst_mac_addr_hi[2];
+        u8 dst_mac_addr_lo[2];
+        u8 dst_mac_addr_mid[2];
+        __le32 lcq_addr_lo;
+        __le32 lcq_addr_hi;
+        __le32 confq_pbl_base_addr_lo;
+        __le32 confq_pbl_base_addr_hi;
 };
 
 /*
- * FCoE connection enable request
+ * FCoE connection enable request $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_conn_enable_disable {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
+        __le16 reserved0;
         struct fcoe_kwqe_header hdr;
-#endif
-        u8 src_mac_addr_lo32[4];
-#if defined(__BIG_ENDIAN)
-        u16 vlan_tag;
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID (0xFFF<<0)
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID_SHIFT 0
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_CFI (0x1<<12)
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_CFI_SHIFT 12
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY (0x7<<13)
-#define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY_SHIFT 13
-        u8 src_mac_addr_hi16[2];
-#elif defined(__LITTLE_ENDIAN)
-        u8 src_mac_addr_hi16[2];
+        u8 src_mac_addr_lo[2];
+        u8 src_mac_addr_mid[2];
+        u8 src_mac_addr_hi[2];
         u16 vlan_tag;
 #define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID (0xFFF<<0)
 #define FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID_SHIFT 0
@@ -571,82 +481,52 @@ struct fcoe_kwqe_conn_enable_disable {
 #define FCOE_KWQE_CONN_ENABLE_DISABLE_CFI_SHIFT 12
 #define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY (0x7<<13)
 #define FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY_SHIFT 13
-#endif
-        u8 dst_mac_addr_lo32[4];
-#if defined(__BIG_ENDIAN)
-        u16 reserved1;
-        u8 dst_mac_addr_hi16[2];
-#elif defined(__LITTLE_ENDIAN)
-        u8 dst_mac_addr_hi16[2];
-        u16 reserved1;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 vlan_flag;
-        u8 s_id[3];
-#elif defined(__LITTLE_ENDIAN)
+        u8 dst_mac_addr_lo[2];
+        u8 dst_mac_addr_mid[2];
+        u8 dst_mac_addr_hi[2];
+        __le16 reserved1;
         u8 s_id[3];
         u8 vlan_flag;
-#endif
-#if defined(__BIG_ENDIAN)
-        u8 reserved3;
-        u8 d_id[3];
-#elif defined(__LITTLE_ENDIAN)
         u8 d_id[3];
         u8 reserved3;
-#endif
-        u32 context_id;
-        u32 conn_id;
-        u32 reserved4;
+        __le32 context_id;
+        __le32 conn_id;
+        __le32 reserved4;
 };
 
 /*
- * FCoE connection destroy request
+ * FCoE connection destroy request $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_conn_destroy {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
+        __le16 reserved0;
         struct fcoe_kwqe_header hdr;
-#endif
-        u32 context_id;
-        u32 conn_id;
-        u32 reserved1[5];
+        __le32 context_id;
+        __le32 conn_id;
+        __le32 reserved1[5];
 };
 
 /*
- * FCoe destroy request
+ * FCoe destroy request $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_destroy {
-#if defined(__BIG_ENDIAN)
-        struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
+        __le16 reserved0;
         struct fcoe_kwqe_header hdr;
-#endif
-        u32 reserved1[7];
+        __le32 reserved1[7];
 };
 
 /*
- * FCoe statistics request
+ * FCoe statistics request $$KEEP_ENDIANNESS$$
  */
 struct fcoe_kwqe_stat {
-#if defined(__BIG_ENDIAN)
+        __le16 reserved0;
         struct fcoe_kwqe_header hdr;
-        u16 reserved0;
-#elif defined(__LITTLE_ENDIAN)
-        u16 reserved0;
-        struct fcoe_kwqe_header hdr;
-#endif
-        u32 stat_params_addr_lo;
-        u32 stat_params_addr_hi;
-        u32 reserved1[5];
+        __le32 stat_params_addr_lo;
+        __le32 stat_params_addr_hi;
+        __le32 reserved1[5];
 };
 
 /*
- * FCoE KWQ WQE
+ * FCoE KWQ WQE $$KEEP_ENDIANNESS$$
  */
 union fcoe_kwqe {
         struct fcoe_kwqe_init1 init1;
@@ -662,19 +542,42 @@ union fcoe_kwqe {
         struct fcoe_kwqe_stat statistics;
 };
 
-struct fcoe_mul_sges_ctx {
-        struct regpair cur_sge_addr;
-#if defined(__BIG_ENDIAN)
-        u8 sgl_size;
-        u8 cur_sge_idx;
-        u16 cur_sge_off;
-#elif defined(__LITTLE_ENDIAN)
-        u16 cur_sge_off;
-        u8 cur_sge_idx;
-        u8 sgl_size;
-#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ * TX SGL context $$KEEP_ENDIANNESS$$
+ */
+union fcoe_sgl_union_ctx {
+        struct fcoe_cached_sge_ctx cached_sge;
+        struct fcoe_ext_mul_sges_ctx sgl;
+        __le32 opaque[5];
 };
 
+/*
+ * Data-In/ELS/BLS information $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_read_flow_info {
+        union fcoe_sgl_union_ctx sgl_ctx;
+        __le32 rsrv0[3];
+};
+
+
+/*
+ * Fcoe stat context $$KEEP_ENDIANNESS$$
+ */
 struct fcoe_s_stat_ctx {
         u8 flags;
 #define FCOE_S_STAT_CTX_ACTIVE (0x1<<0)
@@ -693,51 +596,34 @@ struct fcoe_s_stat_ctx {
 #define FCOE_S_STAT_CTX_RSRV1_SHIFT 6
 };
 
-struct fcoe_seq_ctx {
-#if defined(__BIG_ENDIAN)
-        u16 low_seq_cnt;
-        struct fcoe_s_stat_ctx s_stat;
-        u8 seq_id;
-#elif defined(__LITTLE_ENDIAN)
+/*
+ * Fcoe rx seq context $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_rx_seq_ctx {
         u8 seq_id;
         struct fcoe_s_stat_ctx s_stat;
-        u16 low_seq_cnt;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 err_seq_cnt;
-        u16 high_seq_cnt;
-#elif defined(__LITTLE_ENDIAN)
-        u16 high_seq_cnt;
-        u16 err_seq_cnt;
-#endif
-        u32 low_exp_ro;
-        u32 high_exp_ro;
+        __le16 seq_cnt;
+        __le32 low_exp_ro;
+        __le32 high_exp_ro;
 };
 
 
-struct fcoe_single_sge_ctx {
-        struct regpair cur_buf_addr;
-#if defined(__BIG_ENDIAN)
-        u16 reserved0;
-        u16 cur_buf_rem;
-#elif defined(__LITTLE_ENDIAN)
-        u16 cur_buf_rem;
-        u16 reserved0;
-#endif
-};
-
-union fcoe_sgl_ctx {
-        struct fcoe_single_sge_ctx single_sge;
-        struct fcoe_mul_sges_ctx mul_sges;
+/*
+ * Fcoe rx_wr union context $$KEEP_ENDIANNESS$$
+ */
+union fcoe_rx_wr_union_ctx {
+        struct fcoe_read_flow_info read_info;
+        union fcoe_comp_flow_info comp_info;
+        __le32 opaque[8];
 };
 
 
 
 /*
- * FCoE SQ element
+ * FCoE SQ element $$KEEP_ENDIANNESS$$
  */
 struct fcoe_sqe {
-        u16 wqe;
+        __le16 wqe;
 #define FCOE_SQE_TASK_ID (0x7FFF<<0)
 #define FCOE_SQE_TASK_ID_SHIFT 0
 #define FCOE_SQE_TOGGLE_BIT (0x1<<15)
@@ -746,135 +632,141 @@ struct fcoe_sqe {
 
 
 
-struct fcoe_task_ctx_entry_tx_only {
-        union fcoe_sgl_ctx sgl_ctx;
+/*
+ * 14 regs $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_tx_only {
+        union fcoe_sgl_union_ctx sgl_ctx;
+        __le32 rsrv0;
 };
 
-struct fcoe_task_ctx_entry_txwr_rxrd {
-#if defined(__BIG_ENDIAN)
-        u16 verify_tx_seq;
+/*
+ * 32 bytes (8 regs) used for TX only purposes $$KEEP_ENDIANNESS$$
+ */
+union fcoe_tx_wr_rx_rd_union_ctx {
+        struct fcoe_fc_frame tx_frame;
+        struct fcoe_fcp_cmd_payload fcp_cmd;
+        struct fcoe_ext_cleanup_info cleanup;
+        struct fcoe_ext_abts_info abts;
+        struct fcoe_ext_fw_tx_seq_ctx tx_seq;
+        __le32 opaque[8];
+};
+
+/*
+ * tce_tx_wr_rx_rd_const $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_tx_wr_rx_rd_const {
         u8 init_flags;
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE (0x7<<0)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE (0x1<<3)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE_SHIFT 3
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE (0x1<<4)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE_SHIFT 4
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_SINGLE_SGE (0x1<<5)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_SINGLE_SGE_SHIFT 5
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV5 (0x3<<6)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV5_SHIFT 6
-        u8 tx_flags;
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE (0xF<<0)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV4 (0xF<<4)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV4_SHIFT 4
-#elif defined(__LITTLE_ENDIAN)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE (0x7<<0)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT 0
+#define FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE (0x1<<3)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT 3
+#define FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE (0x1<<4)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE_SHIFT 4
+#define FCOE_TCE_TX_WR_RX_RD_CONST_CACHED_SGE (0x3<<5)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_CACHED_SGE_SHIFT 5
+#define FCOE_TCE_TX_WR_RX_RD_CONST_SUPPORT_REC_TOV (0x1<<7)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_SUPPORT_REC_TOV_SHIFT 7
         u8 tx_flags;
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE (0xF<<0)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV4 (0xF<<4)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV4_SHIFT 4
-        u8 init_flags;
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE (0x7<<0)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE (0x1<<3)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE_SHIFT 3
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE (0x1<<4)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE_SHIFT 4
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_SINGLE_SGE (0x1<<5)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_SINGLE_SGE_SHIFT 5
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV5 (0x3<<6)
-#define FCOE_TASK_CTX_ENTRY_TXWR_RXRD_RSRV5_SHIFT 6
-        u16 verify_tx_seq;
-#endif
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_VALID (0x1<<0)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_VALID_SHIFT 0
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_STATE (0xF<<1)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_STATE_SHIFT 1
+#define FCOE_TCE_TX_WR_RX_RD_CONST_RSRV1 (0x1<<5)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_RSRV1_SHIFT 5
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_SEQ_INIT (0x1<<6)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_TX_SEQ_INIT_SHIFT 6
+#define FCOE_TCE_TX_WR_RX_RD_CONST_RSRV2 (0x1<<7)
+#define FCOE_TCE_TX_WR_RX_RD_CONST_RSRV2_SHIFT 7
+        __le16 rsrv3;
+        __le32 verify_tx_seq;
 };
 
 /*
- * Common section. Both TX and RX processing might write and read from it in
- * different flows
+ * tce_tx_wr_rx_rd $$KEEP_ENDIANNESS$$
  */
-struct fcoe_task_ctx_entry_tx_rx_cmn {
-        u32 data_2_trns;
-        union fcoe_general_task_ctx general;
-#if defined(__BIG_ENDIAN)
-        u16 tx_low_seq_cnt;
-        struct fcoe_s_stat_ctx tx_s_stat;
-        u8 tx_seq_id;
-#elif defined(__LITTLE_ENDIAN)
-        u8 tx_seq_id;
-        struct fcoe_s_stat_ctx tx_s_stat;
-        u16 tx_low_seq_cnt;
-#endif
-        u32 common_flags;
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_CID (0xFFFFFF<<0)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_CID_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_VALID (0x1<<24)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_VALID_SHIFT 24
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_SEQ_INIT (0x1<<25)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_SEQ_INIT_SHIFT 25
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_PEND_XFER (0x1<<26)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_PEND_XFER_SHIFT 26
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_PEND_CONF (0x1<<27)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_PEND_CONF_SHIFT 27
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_EXP_FIRST_FRAME (0x1<<28)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_EXP_FIRST_FRAME_SHIFT 28
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_RSRV (0x7<<29)
-#define FCOE_TASK_CTX_ENTRY_TX_RX_CMN_RSRV_SHIFT 29
-};
-
-struct fcoe_task_ctx_entry_rxwr_txrd {
-#if defined(__BIG_ENDIAN)
-        u16 rx_id;
-        u16 rx_flags;
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE (0xF<<0)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE (0x7<<4)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE_SHIFT 4
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_CONF_REQ (0x1<<7)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_CONF_REQ_SHIFT 7
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_MISS_FRAME (0x1<<8)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_MISS_FRAME_SHIFT 8
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RESERVED0 (0x7F<<9)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RESERVED0_SHIFT 9
-#elif defined(__LITTLE_ENDIAN)
-        u16 rx_flags;
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE (0xF<<0)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE_SHIFT 0
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE (0x7<<4)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE_SHIFT 4
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_CONF_REQ (0x1<<7)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_CONF_REQ_SHIFT 7
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_MISS_FRAME (0x1<<8)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_MISS_FRAME_SHIFT 8
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RESERVED0 (0x7F<<9)
-#define FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RESERVED0_SHIFT 9
-        u16 rx_id;
-#endif
+struct fcoe_tce_tx_wr_rx_rd {
+        union fcoe_tx_wr_rx_rd_union_ctx union_ctx;
+        struct fcoe_tce_tx_wr_rx_rd_const const_ctx;
 };
 
-struct fcoe_task_ctx_entry_rx_only {
-        struct fcoe_seq_ctx seq_ctx;
-        struct fcoe_seq_ctx ooo_seq_ctx;
-        u32 rsrv3;
-        union fcoe_sgl_ctx sgl_ctx;
+/*
+ * tce_rx_wr_tx_rd_const $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_rx_wr_tx_rd_const {
+        __le32 data_2_trns;
+        __le32 init_flags;
+#define FCOE_TCE_RX_WR_TX_RD_CONST_CID (0xFFFFFF<<0)
+#define FCOE_TCE_RX_WR_TX_RD_CONST_CID_SHIFT 0
+#define FCOE_TCE_RX_WR_TX_RD_CONST_RSRV0 (0xFF<<24)
+#define FCOE_TCE_RX_WR_TX_RD_CONST_RSRV0_SHIFT 24
+};
+
+/*
+ * tce_rx_wr_tx_rd_var $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_rx_wr_tx_rd_var {
+        __le16 rx_flags;
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RSRV1 (0xF<<0)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RSRV1_SHIFT 0
+#define FCOE_TCE_RX_WR_TX_RD_VAR_NUM_RQ_WQE (0x7<<4)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_NUM_RQ_WQE_SHIFT 4
+#define FCOE_TCE_RX_WR_TX_RD_VAR_CONF_REQ (0x1<<7)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_CONF_REQ_SHIFT 7
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_STATE (0xF<<8)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_STATE_SHIFT 8
+#define FCOE_TCE_RX_WR_TX_RD_VAR_EXP_FIRST_FRAME (0x1<<12)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_EXP_FIRST_FRAME_SHIFT 12
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_SEQ_INIT (0x1<<13)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_SEQ_INIT_SHIFT 13
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RSRV2 (0x1<<14)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RSRV2_SHIFT 14
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_VALID (0x1<<15)
+#define FCOE_TCE_RX_WR_TX_RD_VAR_RX_VALID_SHIFT 15
+        __le16 rx_id;
+        struct fcoe_fcp_xfr_rdy_payload fcp_xfr_rdy;
+};
+
+/*
+ * tce_rx_wr_tx_rd $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_rx_wr_tx_rd {
+        struct fcoe_tce_rx_wr_tx_rd_const const_ctx;
+        struct fcoe_tce_rx_wr_tx_rd_var var_ctx;
+};
+
+/*
+ * tce_rx_only $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_tce_rx_only {
+        struct fcoe_rx_seq_ctx rx_seq_ctx;
+        union fcoe_rx_wr_union_ctx union_ctx;
 };
 
+/*
+ * task_ctx_entry $$KEEP_ENDIANNESS$$
+ */
 struct fcoe_task_ctx_entry {
-        struct fcoe_task_ctx_entry_tx_only tx_wr_only;
-        struct fcoe_task_ctx_entry_txwr_rxrd tx_wr_rx_rd;
-        struct fcoe_task_ctx_entry_tx_rx_cmn cmn;
-        struct fcoe_task_ctx_entry_rxwr_txrd rx_wr_tx_rd;
-        struct fcoe_task_ctx_entry_rx_only rx_wr_only;
-        u32 reserved[4];
+        struct fcoe_tce_tx_only txwr_only;
+        struct fcoe_tce_tx_wr_rx_rd txwr_rxrd;
+        struct fcoe_tce_rx_wr_tx_rd rxwr_txrd;
+        struct fcoe_tce_rx_only rxwr_only;
 };
 
 
+
+
+
+
+
+
+
+
 /*
- * FCoE XFRQ element
+ * FCoE XFRQ element $$KEEP_ENDIANNESS$$
  */
 struct fcoe_xfrqe {
-        u16 wqe;
+        __le16 wqe;
 #define FCOE_XFRQE_TASK_ID (0x7FFF<<0)
 #define FCOE_XFRQE_TASK_ID_SHIFT 0
 #define FCOE_XFRQE_TOGGLE_BIT (0x1<<15)
@@ -883,22 +775,31 @@ struct fcoe_xfrqe {
 
 
 /*
- * FCoE CONFQ element
+ * fcoe rx doorbell message sent to the chip $$KEEP_ENDIANNESS$$
+ */
+struct b577xx_fcoe_rx_doorbell {
+        struct b577xx_doorbell_hdr hdr;
+        u8 params;
+#define B577XX_FCOE_RX_DOORBELL_NEGATIVE_ARM (0x1F<<0)
+#define B577XX_FCOE_RX_DOORBELL_NEGATIVE_ARM_SHIFT 0
+#define B577XX_FCOE_RX_DOORBELL_OPCODE (0x7<<5)
+#define B577XX_FCOE_RX_DOORBELL_OPCODE_SHIFT 5
+        __le16 doorbell_cq_cons;
+};
+
+
+/*
+ * FCoE CONFQ element $$KEEP_ENDIANNESS$$
  */
 struct fcoe_confqe {
-#if defined(__BIG_ENDIAN)
-        u16 rx_id;
-        u16 ox_id;
-#elif defined(__LITTLE_ENDIAN)
-        u16 ox_id;
-        u16 rx_id;
-#endif
-        u32 param;
+        __le16 ox_id;
+        __le16 rx_id;
+        __le32 param;
 };
 
 
 /*
- * FCoE connection data base
+ * FCoE conection data base
  */
 struct fcoe_conn_db {
 #if defined(__BIG_ENDIAN)
@@ -914,10 +815,10 @@ struct fcoe_conn_db {
 
 
 /*
- * FCoE CQ element
+ * FCoE CQ element $$KEEP_ENDIANNESS$$
  */
 struct fcoe_cqe {
-        u16 wqe;
+        __le16 wqe;
 #define FCOE_CQE_CQE_INFO (0x3FFF<<0)
 #define FCOE_CQE_CQE_INFO_SHIFT 0
 #define FCOE_CQE_CQE_TYPE (0x1<<14)
@@ -928,61 +829,46 @@ struct fcoe_cqe {
 
 
 /*
- * FCoE error/warning resporting entry
+ * FCoE error/warning reporting entry $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_partial_err_report_entry {
+        __le32 err_warn_bitmap_lo;
+        __le32 err_warn_bitmap_hi;
+        __le32 tx_buf_off;
+        __le32 rx_buf_off;
+};
+
+/*
+ * FCoE error/warning reporting entry $$KEEP_ENDIANNESS$$
  */
 struct fcoe_err_report_entry {
-        u32 err_warn_bitmap_lo;
-        u32 err_warn_bitmap_hi;
-        u32 tx_buf_off;
-        u32 rx_buf_off;
+        struct fcoe_partial_err_report_entry data;
         struct fcoe_fc_hdr fc_hdr;
 };
 
 
 /*
- * FCoE hash table entry (32 bytes)
+ * FCoE hash table entry (32 bytes) $$KEEP_ENDIANNESS$$
  */
 struct fcoe_hash_table_entry {
-#if defined(__BIG_ENDIAN)
-        u8 d_id_0;
-        u8 s_id_2;
-        u8 s_id_1;
-        u8 s_id_0;
-#elif defined(__LITTLE_ENDIAN)
         u8 s_id_0;
         u8 s_id_1;
         u8 s_id_2;
         u8 d_id_0;
-#endif
-#if defined(__BIG_ENDIAN)
-        u16 dst_mac_addr_hi;
-        u8 d_id_2;
-        u8 d_id_1;
-#elif defined(__LITTLE_ENDIAN)
         u8 d_id_1;
         u8 d_id_2;
-        u16 dst_mac_addr_hi;
-#endif
-        u32 dst_mac_addr_lo;
-#if defined(__BIG_ENDIAN)
-        u16 vlan_id;
-        u16 src_mac_addr_hi;
-#elif defined(__LITTLE_ENDIAN)
-        u16 src_mac_addr_hi;
-        u16 vlan_id;
-#endif
-        u32 src_mac_addr_lo;
-#if defined(__BIG_ENDIAN)
-        u16 reserved1;
-        u8 reserved0;
-        u8 vlan_flag;
-#elif defined(__LITTLE_ENDIAN)
+        __le16 dst_mac_addr_hi;
+        __le16 dst_mac_addr_mid;
+        __le16 dst_mac_addr_lo;
+        __le16 src_mac_addr_hi;
+        __le16 vlan_id;
+        __le16 src_mac_addr_lo;
+        __le16 src_mac_addr_mid;
         u8 vlan_flag;
         u8 reserved0;
-        u16 reserved1;
-#endif
-        u32 reserved2;
-        u32 field_id;
+        __le16 reserved1;
+        __le32 reserved2;
+        __le32 field_id;
 #define FCOE_HASH_TABLE_ENTRY_CID (0xFFFFFF<<0)
 #define FCOE_HASH_TABLE_ENTRY_CID_SHIFT 0
 #define FCOE_HASH_TABLE_ENTRY_RESERVED3 (0x7F<<24)
@@ -991,11 +877,27 @@ struct fcoe_hash_table_entry {
 #define FCOE_HASH_TABLE_ENTRY_VALID_SHIFT 31
 };
 
+
 /*
- * FCoE pending work request CQE
+ * FCoE LCQ element $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_lcqe {
+        __le32 wqe;
+#define FCOE_LCQE_TASK_ID (0xFFFF<<0)
+#define FCOE_LCQE_TASK_ID_SHIFT 0
+#define FCOE_LCQE_LCQE_TYPE (0xFF<<16)
+#define FCOE_LCQE_LCQE_TYPE_SHIFT 16
+#define FCOE_LCQE_RESERVED (0xFF<<24)
+#define FCOE_LCQE_RESERVED_SHIFT 24
+};
+
+
+
+/*
+ * FCoE pending work request CQE $$KEEP_ENDIANNESS$$
  */
 struct fcoe_pend_wq_cqe {
-        u16 wqe;
+        __le16 wqe;
 #define FCOE_PEND_WQ_CQE_TASK_ID (0x3FFF<<0)
 #define FCOE_PEND_WQ_CQE_TASK_ID_SHIFT 0
 #define FCOE_PEND_WQ_CQE_CQE_TYPE (0x1<<14)
@@ -1006,53 +908,61 @@ struct fcoe_pend_wq_cqe {
 
 
 /*
- * FCoE RX statistics parameters section#0
+ * FCoE RX statistics parameters section#0 $$KEEP_ENDIANNESS$$
  */
 struct fcoe_rx_stat_params_section0 {
-        u32 fcoe_ver_cnt;
-        u32 fcoe_rx_pkt_cnt;
-        u32 fcoe_rx_byte_cnt;
-        u32 fcoe_rx_drop_pkt_cnt;
+        __le32 fcoe_rx_pkt_cnt;
+        __le32 fcoe_rx_byte_cnt;
 };
 
 
 /*
- * FCoE RX statistics parameters section#1
+ * FCoE RX statistics parameters section#1 $$KEEP_ENDIANNESS$$
  */
 struct fcoe_rx_stat_params_section1 {
-        u32 fc_crc_cnt;
-        u32 eofa_del_cnt;
-        u32 miss_frame_cnt;
-        u32 seq_timeout_cnt;
-        u32 drop_seq_cnt;
-        u32 fcoe_rx_drop_pkt_cnt;
-        u32 fcp_rx_pkt_cnt;
-        u32 reserved0;
+        __le32 fcoe_ver_cnt;
+        __le32 fcoe_rx_drop_pkt_cnt;
+};
+
+
+/*
+ * FCoE RX statistics parameters section#2 $$KEEP_ENDIANNESS$$
+ */
+struct fcoe_rx_stat_params_section2 {
+        __le32 fc_crc_cnt;
+        __le32 eofa_del_cnt;
+        __le32 miss_frame_cnt;
+        __le32 seq_timeout_cnt;
+        __le32 drop_seq_cnt;
+        __le32 fcoe_rx_drop_pkt_cnt;
+        __le32 fcp_rx_pkt_cnt;
+        __le32 reserved0;
 };
 
 
 /*
- * FCoE TX statistics parameters
+ * FCoE TX statistics parameters $$KEEP_ENDIANNESS$$
  */
 struct fcoe_tx_stat_params {
-        u32 fcoe_tx_pkt_cnt;
-        u32 fcoe_tx_byte_cnt;
-        u32 fcp_tx_pkt_cnt;
-        u32 reserved0;
+        __le32 fcoe_tx_pkt_cnt;
+        __le32 fcoe_tx_byte_cnt;
+        __le32 fcp_tx_pkt_cnt;
+        __le32 reserved0;
 };
 
 /*
- * FCoE statistics parameters
+ * FCoE statistics parameters $$KEEP_ENDIANNESS$$
  */
 struct fcoe_statistics_params {
         struct fcoe_tx_stat_params tx_stat;
         struct fcoe_rx_stat_params_section0 rx_stat0;
         struct fcoe_rx_stat_params_section1 rx_stat1;
+        struct fcoe_rx_stat_params_section2 rx_stat2;
 };
 
 
 /*
- * FCoE t2 hash table entry (64 bytes)
+ * FCoE t2 hash table entry (64 bytes) $$KEEP_ENDIANNESS$$
  */
 struct fcoe_t2_hash_table_entry {
         struct fcoe_hash_table_entry data;
@@ -1060,11 +970,13 @@ struct fcoe_t2_hash_table_entry {
         struct regpair reserved0[3];
 };
 
+
+
 /*
- * FCoE unsolicited CQE
+ * FCoE unsolicited CQE $$KEEP_ENDIANNESS$$
  */
 struct fcoe_unsolicited_cqe {
-        u16 wqe;
+        __le16 wqe;
 #define FCOE_UNSOLICITED_CQE_SUBTYPE (0x3<<0)
 #define FCOE_UNSOLICITED_CQE_SUBTYPE_SHIFT 0
 #define FCOE_UNSOLICITED_CQE_PKT_LEN (0xFFF<<2)
@@ -1075,6 +987,4 @@ struct fcoe_unsolicited_cqe {
 #define FCOE_UNSOLICITED_CQE_TOGGLE_BIT_SHIFT 15
 };
 
-
-
 #endif /* __57XX_FCOE_HSI_LINUX_LE__ */
diff --git a/drivers/scsi/bnx2fc/bnx2fc.h b/drivers/scsi/bnx2fc/bnx2fc.h
index 0a404bfb44fe..907672e86063 100644
--- a/drivers/scsi/bnx2fc/bnx2fc.h
+++ b/drivers/scsi/bnx2fc/bnx2fc.h
@@ -62,7 +62,7 @@
 #include "bnx2fc_constants.h"
 
 #define BNX2FC_NAME             "bnx2fc"
-#define BNX2FC_VERSION          "1.0.1"
+#define BNX2FC_VERSION          "1.0.3"
 
 #define PFX                     "bnx2fc: "
 
@@ -262,9 +262,14 @@ struct bnx2fc_rport {
 #define BNX2FC_FLAG_UPLD_REQ_COMPL      0x8
 #define BNX2FC_FLAG_EXPL_LOGO           0x9
 
+        u8 src_addr[ETH_ALEN];
         u32 max_sqes;
         u32 max_rqes;
         u32 max_cqes;
+        atomic_t free_sqes;
+
+        struct b577xx_doorbell_set_prod sq_db;
+        struct b577xx_fcoe_rx_doorbell rx_db;
 
         struct fcoe_sqe *sq;
         dma_addr_t sq_dma;
@@ -274,7 +279,7 @@ struct bnx2fc_rport {
 
         struct fcoe_cqe *cq;
         dma_addr_t cq_dma;
-        u32 cq_cons_idx;
+        u16 cq_cons_idx;
         u8 cq_curr_toggle_bit;
         u32 cq_mem_size;
 
@@ -505,6 +510,7 @@ struct fc_seq *bnx2fc_elsct_send(struct fc_lport *lport, u32 did,
                                                    struct fc_frame *,
                                                    void *),
                                       void *arg, u32 timeout);
+void bnx2fc_arm_cq(struct bnx2fc_rport *tgt);
 int bnx2fc_process_new_cqes(struct bnx2fc_rport *tgt);
 void bnx2fc_process_cq_compl(struct bnx2fc_rport *tgt, u16 wqe);
 struct bnx2fc_rport *bnx2fc_tgt_lookup(struct fcoe_port *port,
diff --git a/drivers/scsi/bnx2fc/bnx2fc_constants.h b/drivers/scsi/bnx2fc/bnx2fc_constants.h
index fe7769173c43..399cda047a77 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_constants.h
+++ b/drivers/scsi/bnx2fc/bnx2fc_constants.h
@@ -5,6 +5,12 @@
  * This file defines HSI constants for the FCoE flows
  */
 
+/* Current FCoE HSI version number composed of two fields (16 bit) */
+/* Implies on a change broken previous HSI */
+#define FCOE_HSI_MAJOR_VERSION (1)
+/* Implies on a change which does not broken previous HSI */
+#define FCOE_HSI_MINOR_VERSION (1)
+
 /* KWQ/KCQ FCoE layer code */
 #define FCOE_KWQE_LAYER_CODE   (7)
 
@@ -40,21 +46,62 @@
 #define FCOE_KCQE_COMPLETION_STATUS_CTX_ALLOC_FAILURE   (0x3)
 #define FCOE_KCQE_COMPLETION_STATUS_CTX_FREE_FAILURE    (0x4)
 #define FCOE_KCQE_COMPLETION_STATUS_NIC_ERROR                   (0x5)
+#define FCOE_KCQE_COMPLETION_STATUS_WRONG_HSI_VERSION   (0x6)
+
+/* CQE type */
+#define FCOE_PENDING_CQE_TYPE                   0
+#define FCOE_UNSOLIC_CQE_TYPE                   1
 
 /* Unsolicited CQE type */
 #define FCOE_UNSOLICITED_FRAME_CQE_TYPE                 0
 #define FCOE_ERROR_DETECTION_CQE_TYPE                   1
 #define FCOE_WARNING_DETECTION_CQE_TYPE                 2
 
+/* E_D_TOV timer resolution in ms */
+#define FCOE_E_D_TOV_TIMER_RESOLUTION_MS (20)
+
+/* E_D_TOV timer resolution for SDM (4 micro) */
+#define FCOE_E_D_TOV_SDM_TIMER_RESOLUTION                               \
+        (FCOE_E_D_TOV_TIMER_RESOLUTION_MS * 1000 / 4)
+
+/* REC timer resolution in ms */
+#define FCOE_REC_TIMER_RESOLUTION_MS (20)
+
+/* REC timer resolution for SDM (4 micro) */
+#define FCOE_REC_SDM_TIMER_RESOLUTION (FCOE_REC_TIMER_RESOLUTION_MS * 1000 / 4)
+
+/* E_D_TOV timer default wraparound value (2 sec) in 20 ms resolution */
+#define FCOE_E_D_TOV_DEFAULT_WRAPAROUND_VAL                     \
+                        (2000 / FCOE_E_D_TOV_TIMER_RESOLUTION_MS)
+
+/* REC_TOV timer default wraparound value (3 sec) in 20 ms resolution */
+#define FCOE_REC_TOV_DEFAULT_WRAPAROUND_VAL                     \
+                        (3000 / FCOE_REC_TIMER_RESOLUTION_MS)
+
+#define FCOE_NUM_OF_TIMER_TASKS  (8 * 1024)
+
+#define FCOE_NUM_OF_CACHED_TASKS_TIMER (8)
+
 /* Task context constants */
+/******** Remove FCP_CMD write tce sleep ***********************/
+/* In case timer services are required then shall be updated by Xstorm after
+ * start processing the task. In case no timer facilities are required then the
+ * driver would initialize the state to this value
+ *
+#define FCOE_TASK_TX_STATE_NORMAL                               0
+ * After driver has initialize the task in case timer services required *
+#define FCOE_TASK_TX_STATE_INIT                                 1
+******** Remove FCP_CMD write tce sleep ***********************/
 /* After driver has initialize the task in case timer services required */
 #define FCOE_TASK_TX_STATE_INIT                                 0
 /* In case timer services are required then shall be updated by Xstorm after
  * start processing the task. In case no timer facilities are required then the
- * driver would initialize the state to this value */
+ * driver would initialize the state to this value
+ */
 #define FCOE_TASK_TX_STATE_NORMAL                               1
 /* Task is under abort procedure. Updated in order to stop processing of
- * pending WQEs on this task */
+ * pending WQEs on this task
+ */
 #define FCOE_TASK_TX_STATE_ABORT                                2
 /* For E_D_T_TOV timer expiration in Xstorm (Class 2 only) */
 #define FCOE_TASK_TX_STATE_ERROR                                3
@@ -66,17 +113,8 @@
 #define FCOE_TASK_TX_STATE_EXCHANGE_CLEANUP                     6
 /* For sequence cleanup request task */
 #define FCOE_TASK_TX_STATE_SEQUENCE_CLEANUP                     7
-/* Mark task as aborted and indicate that ABTS was not transmitted */
-#define FCOE_TASK_TX_STATE_BEFORE_ABTS_TX                       8
-/* Mark task as aborted and indicate that ABTS was transmitted */
-#define FCOE_TASK_TX_STATE_AFTER_ABTS_TX                        9
 /* For completion the ABTS task. */
-#define FCOE_TASK_TX_STATE_ABTS_TX_COMPLETED                    10
-/* Mark task as aborted and indicate that Exchange cleanup was not transmitted
- */
-#define FCOE_TASK_TX_STATE_BEFORE_EXCHANGE_CLEANUP_TX           11
-/* Mark task as aborted and indicate that Exchange cleanup was transmitted */
-#define FCOE_TASK_TX_STATE_AFTER_EXCHANGE_CLEANUP_TX            12
+#define FCOE_TASK_TX_STATE_ABTS_TX                              8
 
 #define FCOE_TASK_RX_STATE_NORMAL                               0
 #define FCOE_TASK_RX_STATE_COMPLETED                            1
@@ -86,25 +124,25 @@
 #define FCOE_TASK_RX_STATE_WARNING                              3
 /* For E_D_T_TOV timer expiration in Ustorm */
 #define FCOE_TASK_RX_STATE_ERROR                                4
-/* ABTS ACC arrived wait for local completion to finally complete the task. */
-#define FCOE_TASK_RX_STATE_ABTS_ACC_ARRIVED                     5
-/* local completion arrived wait for ABTS ACC to finally complete the task. */
-#define FCOE_TASK_RX_STATE_ABTS_LOCAL_COMP_ARRIVED              6
+/* FW only: First visit at rx-path, part of the abts round trip */
+#define FCOE_TASK_RX_STATE_ABTS_IN_PROCESS                      5
+/* FW only: Second visit at rx-path, after ABTS frame transmitted */
+#define FCOE_TASK_RX_STATE_ABTS_TRANSMITTED                     6
 /* Special completion indication in case of task was aborted. */
 #define FCOE_TASK_RX_STATE_ABTS_COMPLETED                       7
-/* Special completion indication in case of task was cleaned. */
-#define FCOE_TASK_RX_STATE_EXCHANGE_CLEANUP_COMPLETED           8
-/* Special completion indication (in task requested the exchange cleanup) in
- * case cleaned task is in non-valid. */
-#define FCOE_TASK_RX_STATE_ABORT_CLEANUP_COMPLETED              9
+/* FW only: First visit at rx-path, part of the cleanup round trip */
+#define FCOE_TASK_RX_STATE_EXCHANGE_CLEANUP_IN_PROCESS          8
+/* FW only: Special completion indication in case of task was cleaned. */
+#define FCOE_TASK_RX_STATE_EXCHANGE_CLEANUP_COMPLETED           9
+/* Not in used: Special completion indication (in task requested the exchange
+ * cleanup) in case cleaned task is in non-valid.
+ */
+#define FCOE_TASK_RX_STATE_ABORT_CLEANUP_COMPLETED              10
 /* Special completion indication (in task requested the sequence cleanup) in
- * case cleaned task was already returned to normal. */
-#define FCOE_TASK_RX_STATE_IGNORED_SEQUENCE_CLEANUP             10
-/* Exchange cleanup arrived wait until xfer will be handled to finally
- * complete the task. */
-#define FCOE_TASK_RX_STATE_EXCHANGE_CLEANUP_ARRIVED             11
-/* Xfer handled, wait for exchange cleanup to finally complete the task. */
-#define FCOE_TASK_RX_STATE_EXCHANGE_CLEANUP_HANDLED_XFER        12
+ * case cleaned task was already returned to normal.
+ */
+#define FCOE_TASK_RX_STATE_IGNORED_SEQUENCE_CLEANUP             11
+
 
 #define FCOE_TASK_TYPE_WRITE                    0
 #define FCOE_TASK_TYPE_READ                             1
@@ -120,11 +158,40 @@
 #define FCOE_TASK_CLASS_TYPE_3                  0
 #define FCOE_TASK_CLASS_TYPE_2                  1
 
+/* FCoE/FC packet fields  */
+#define FCOE_ETH_TYPE                                   0x8906
+
+/* FCoE maximum elements in hash table */
+#define FCOE_MAX_ELEMENTS_IN_HASH_TABLE_ROW     8
+
+/* FCoE half of the elements in hash table */
+#define FCOE_HALF_ELEMENTS_IN_HASH_TABLE_ROW                    \
+                        (FCOE_MAX_ELEMENTS_IN_HASH_TABLE_ROW / 2)
+
+/* FcoE number of cached T2 entries */
+#define T_FCOE_NUMBER_OF_CACHED_T2_ENTRIES (4)
+
+/* FCoE maximum elements in hash table */
+#define FCOE_HASH_TBL_CHUNK_SIZE        16384
+
 /* Everest FCoE connection type */
 #define B577XX_FCOE_CONNECTION_TYPE             4
 
-/* Error codes for Error Reporting in fast path flows */
-/* XFER error codes */
+/* FCoE number of rows (in log). This number derives
+ * from the maximum connections supported which is 2048.
+ * TBA: Need a different constant for E2
+ */
+#define FCOE_MAX_NUM_SESSIONS_LOG               11
+
+#define FC_ABTS_REPLY_MAX_PAYLOAD_LEN   12
+
+/* Error codes for Error Reporting in slow path flows */
+#define FCOE_SLOW_PATH_ERROR_CODE_TOO_MANY_FUNCS                        0
+#define FCOE_SLOW_PATH_ERROR_CODE_NO_LICENSE                            1
+
+/* Error codes for Error Reporting in fast path flows
+ * XFER error codes
+ */
 #define FCOE_ERROR_CODE_XFER_OOO_RO                                     0
 #define FCOE_ERROR_CODE_XFER_RO_NOT_ALIGNED                             1
 #define FCOE_ERROR_CODE_XFER_NULL_BURST_LEN                             2
@@ -155,17 +222,17 @@
 #define FCOE_ERROR_CODE_DATA_SOFI3_SEQ_ACTIVE_SET                       23
 #define FCOE_ERROR_CODE_DATA_SOFN_SEQ_ACTIVE_RESET                      24
 #define FCOE_ERROR_CODE_DATA_EOFN_END_SEQ_SET                           25
-#define FCOE_ERROR_CODE_DATA_EOFT_END_SEQ_RESET                 26
-#define FCOE_ERROR_CODE_DATA_TASK_TYPE_NOT_READ                 27
+#define FCOE_ERROR_CODE_DATA_EOFT_END_SEQ_RESET                         26
+#define FCOE_ERROR_CODE_DATA_TASK_TYPE_NOT_READ                         27
 #define FCOE_ERROR_CODE_DATA_FCTL                                       28
 
 /* Middle path error codes */
-#define FCOE_ERROR_CODE_MIDPATH_TYPE_NOT_ELS                            29
+#define FCOE_ERROR_CODE_MIDPATH_INVALID_TYPE                            29
 #define FCOE_ERROR_CODE_MIDPATH_SOFI3_SEQ_ACTIVE_SET                    30
 #define FCOE_ERROR_CODE_MIDPATH_SOFN_SEQ_ACTIVE_RESET                   31
 #define FCOE_ERROR_CODE_MIDPATH_EOFN_END_SEQ_SET                        32
 #define FCOE_ERROR_CODE_MIDPATH_EOFT_END_SEQ_RESET                      33
-#define FCOE_ERROR_CODE_MIDPATH_ELS_REPLY_FCTL                          34
+#define FCOE_ERROR_CODE_MIDPATH_REPLY_FCTL                              34
 #define FCOE_ERROR_CODE_MIDPATH_INVALID_REPLY                           35
 #define FCOE_ERROR_CODE_MIDPATH_ELS_REPLY_RCTL                          36
 
@@ -173,7 +240,7 @@
 #define FCOE_ERROR_CODE_ABTS_REPLY_F_CTL                                37
 #define FCOE_ERROR_CODE_ABTS_REPLY_DDF_RCTL_FIELD                       38
 #define FCOE_ERROR_CODE_ABTS_REPLY_INVALID_BLS_RCTL                     39
-#define FCOE_ERROR_CODE_ABTS_REPLY_INVALID_RCTL                 40
+#define FCOE_ERROR_CODE_ABTS_REPLY_INVALID_RCTL                         40
 #define FCOE_ERROR_CODE_ABTS_REPLY_RCTL_GENERAL_MISMATCH                41
 
 /* Common error codes */
@@ -185,7 +252,7 @@
 #define FCOE_ERROR_CODE_COMMON_DATA_NO_MORE_SGES                        47
 #define FCOE_ERROR_CODE_COMMON_OPTIONAL_FC_HDR                          48
 #define FCOE_ERROR_CODE_COMMON_READ_TCE_OX_ID_TOO_BIG                   49
-#define FCOE_ERROR_CODE_COMMON_DATA_WAS_NOT_TRANSMITTED         50
+#define FCOE_ERROR_CODE_COMMON_DATA_WAS_NOT_TRANSMITTED                 50
 
 /* Unsolicited Rx error codes */
 #define FCOE_ERROR_CODE_UNSOLICITED_TYPE_NOT_ELS                        51
diff --git a/drivers/scsi/bnx2fc/bnx2fc_els.c b/drivers/scsi/bnx2fc/bnx2fc_els.c
index 52c358427ce2..7e89143f15cf 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_els.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_els.c
@@ -83,7 +83,7 @@ int bnx2fc_send_rrq(struct bnx2fc_cmd *aborted_io_req)
         rrq.rrq_cmd = ELS_RRQ;
         hton24(rrq.rrq_s_id, sid);
         rrq.rrq_ox_id = htons(aborted_io_req->xid);
-        rrq.rrq_rx_id = htons(aborted_io_req->task->rx_wr_tx_rd.rx_id);
+        rrq.rrq_rx_id = htons(aborted_io_req->task->rxwr_txrd.var_ctx.rx_id);
 
 retry_rrq:
         rc = bnx2fc_initiate_els(tgt, ELS_RRQ, &rrq, sizeof(rrq),
@@ -417,12 +417,13 @@ void bnx2fc_process_els_compl(struct bnx2fc_cmd *els_req,
 
         hdr = (u64 *)fc_hdr;
         temp_hdr = (u64 *)
-                &task->cmn.general.cmd_info.mp_fc_frame.fc_hdr;
+                &task->rxwr_only.union_ctx.comp_info.mp_rsp.fc_hdr;
         hdr[0] = cpu_to_be64(temp_hdr[0]);
         hdr[1] = cpu_to_be64(temp_hdr[1]);
         hdr[2] = cpu_to_be64(temp_hdr[2]);
 
-        mp_req->resp_len = task->rx_wr_only.sgl_ctx.mul_sges.cur_sge_off;
+        mp_req->resp_len =
+                task->rxwr_only.union_ctx.comp_info.mp_rsp.mp_payload_len;
 
         /* Parse ELS response */
         if ((els_req->cb_func) && (els_req->cb_arg)) {
diff --git a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
index ab255fbc7f36..7a16ca1c3ecf 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
@@ -21,7 +21,7 @@ DEFINE_PER_CPU(struct bnx2fc_percpu_s, bnx2fc_percpu);
 
 #define DRV_MODULE_NAME         "bnx2fc"
 #define DRV_MODULE_VERSION      BNX2FC_VERSION
-#define DRV_MODULE_RELDATE      "Mar 17, 2011"
+#define DRV_MODULE_RELDATE      "Jun 10, 2011"
 
 
 static char version[] __devinitdata =
@@ -612,7 +612,7 @@ static struct fc_host_statistics *bnx2fc_get_host_stats(struct Scsi_Host *shost)
                 BNX2FC_HBA_DBG(lport, "FW stat req timed out\n");
                 return bnx2fc_stats;
         }
-        bnx2fc_stats->invalid_crc_count += fw_stats->rx_stat1.fc_crc_cnt;
+        bnx2fc_stats->invalid_crc_count += fw_stats->rx_stat2.fc_crc_cnt;
         bnx2fc_stats->tx_frames += fw_stats->tx_stat.fcoe_tx_pkt_cnt;
         bnx2fc_stats->tx_words += (fw_stats->tx_stat.fcoe_tx_byte_cnt) / 4;
         bnx2fc_stats->rx_frames += fw_stats->rx_stat0.fcoe_rx_pkt_cnt;
diff --git a/drivers/scsi/bnx2fc/bnx2fc_hwi.c b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
index f756d5f85c7a..d8e8a825560d 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_hwi.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
@@ -100,6 +100,9 @@ int bnx2fc_send_fw_fcoe_init_msg(struct bnx2fc_hba *hba)
         fcoe_init2.hdr.flags = (FCOE_KWQE_LAYER_CODE <<
                                         FCOE_KWQE_HEADER_LAYER_CODE_SHIFT);
 
+        fcoe_init2.hsi_major_version = FCOE_HSI_MAJOR_VERSION;
+        fcoe_init2.hsi_minor_version = FCOE_HSI_MINOR_VERSION;
+
         fcoe_init2.hash_tbl_pbl_addr_lo = (u32) hba->hash_tbl_pbl_dma;
         fcoe_init2.hash_tbl_pbl_addr_hi = (u32)
                                            ((u64) hba->hash_tbl_pbl_dma >> 32);
@@ -122,6 +125,7 @@ int bnx2fc_send_fw_fcoe_init_msg(struct bnx2fc_hba *hba)
         fcoe_init3.error_bit_map_lo = 0xffffffff;
         fcoe_init3.error_bit_map_hi = 0xffffffff;
 
+        fcoe_init3.perf_config = 1;
 
         kwqe_arr[0] = (struct kwqe *) &fcoe_init1;
         kwqe_arr[1] = (struct kwqe *) &fcoe_init2;
@@ -289,19 +293,19 @@ int bnx2fc_send_session_ofld_req(struct fcoe_port *port,
         ofld_req4.e_d_tov_timer_val = lport->e_d_tov / 20;
 
 
-        ofld_req4.src_mac_addr_lo32[0] =  port->data_src_addr[5];
+        ofld_req4.src_mac_addr_lo[0] =  port->data_src_addr[5];
                                                         /* local mac */
-        ofld_req4.src_mac_addr_lo32[1] =  port->data_src_addr[4];
-        ofld_req4.src_mac_addr_lo32[2] =  port->data_src_addr[3];
-        ofld_req4.src_mac_addr_lo32[3] =  port->data_src_addr[2];
-        ofld_req4.src_mac_addr_hi16[0] =  port->data_src_addr[1];
-        ofld_req4.src_mac_addr_hi16[1] =  port->data_src_addr[0];
-        ofld_req4.dst_mac_addr_lo32[0] =  hba->ctlr.dest_addr[5];/* fcf mac */
-        ofld_req4.dst_mac_addr_lo32[1] =  hba->ctlr.dest_addr[4];
-        ofld_req4.dst_mac_addr_lo32[2] =  hba->ctlr.dest_addr[3];
-        ofld_req4.dst_mac_addr_lo32[3] =  hba->ctlr.dest_addr[2];
-        ofld_req4.dst_mac_addr_hi16[0] =  hba->ctlr.dest_addr[1];
-        ofld_req4.dst_mac_addr_hi16[1] =  hba->ctlr.dest_addr[0];
+        ofld_req4.src_mac_addr_lo[1] =  port->data_src_addr[4];
+        ofld_req4.src_mac_addr_mid[0] =  port->data_src_addr[3];
+        ofld_req4.src_mac_addr_mid[1] =  port->data_src_addr[2];
+        ofld_req4.src_mac_addr_hi[0] =  port->data_src_addr[1];
+        ofld_req4.src_mac_addr_hi[1] =  port->data_src_addr[0];
+        ofld_req4.dst_mac_addr_lo[0] =  hba->ctlr.dest_addr[5];/* fcf mac */
+        ofld_req4.dst_mac_addr_lo[1] =  hba->ctlr.dest_addr[4];
+        ofld_req4.dst_mac_addr_mid[0] =  hba->ctlr.dest_addr[3];
+        ofld_req4.dst_mac_addr_mid[1] =  hba->ctlr.dest_addr[2];
+        ofld_req4.dst_mac_addr_hi[0] =  hba->ctlr.dest_addr[1];
+        ofld_req4.dst_mac_addr_hi[1] =  hba->ctlr.dest_addr[0];
 
         ofld_req4.lcq_addr_lo = (u32) tgt->lcq_dma;
         ofld_req4.lcq_addr_hi = (u32)((u64) tgt->lcq_dma >> 32);
@@ -345,20 +349,21 @@ static int bnx2fc_send_session_enable_req(struct fcoe_port *port,
         enbl_req.hdr.flags =
                 (FCOE_KWQE_LAYER_CODE << FCOE_KWQE_HEADER_LAYER_CODE_SHIFT);
 
-        enbl_req.src_mac_addr_lo32[0] =  port->data_src_addr[5];
+        enbl_req.src_mac_addr_lo[0] =  port->data_src_addr[5];
                                                         /* local mac */
-        enbl_req.src_mac_addr_lo32[1] =  port->data_src_addr[4];
-        enbl_req.src_mac_addr_lo32[2] =  port->data_src_addr[3];
-        enbl_req.src_mac_addr_lo32[3] =  port->data_src_addr[2];
-        enbl_req.src_mac_addr_hi16[0] =  port->data_src_addr[1];
-        enbl_req.src_mac_addr_hi16[1] =  port->data_src_addr[0];
-
-        enbl_req.dst_mac_addr_lo32[0] =  hba->ctlr.dest_addr[5];/* fcf mac */
-        enbl_req.dst_mac_addr_lo32[1] =  hba->ctlr.dest_addr[4];
-        enbl_req.dst_mac_addr_lo32[2] =  hba->ctlr.dest_addr[3];
-        enbl_req.dst_mac_addr_lo32[3] =  hba->ctlr.dest_addr[2];
-        enbl_req.dst_mac_addr_hi16[0] =  hba->ctlr.dest_addr[1];
-        enbl_req.dst_mac_addr_hi16[1] =  hba->ctlr.dest_addr[0];
+        enbl_req.src_mac_addr_lo[1] =  port->data_src_addr[4];
+        enbl_req.src_mac_addr_mid[0] =  port->data_src_addr[3];
+        enbl_req.src_mac_addr_mid[1] =  port->data_src_addr[2];
+        enbl_req.src_mac_addr_hi[0] =  port->data_src_addr[1];
+        enbl_req.src_mac_addr_hi[1] =  port->data_src_addr[0];
+        memcpy(tgt->src_addr, port->data_src_addr, ETH_ALEN);
+
+        enbl_req.dst_mac_addr_lo[0] =  hba->ctlr.dest_addr[5];/* fcf mac */
+        enbl_req.dst_mac_addr_lo[1] =  hba->ctlr.dest_addr[4];
+        enbl_req.dst_mac_addr_mid[0] =  hba->ctlr.dest_addr[3];
+        enbl_req.dst_mac_addr_mid[1] =  hba->ctlr.dest_addr[2];
+        enbl_req.dst_mac_addr_hi[0] =  hba->ctlr.dest_addr[1];
+        enbl_req.dst_mac_addr_hi[1] =  hba->ctlr.dest_addr[0];
 
         port_id = fc_host_port_id(lport->host);
         if (port_id != tgt->sid) {
@@ -411,18 +416,19 @@ int bnx2fc_send_session_disable_req(struct fcoe_port *port,
         disable_req.hdr.flags =
                 (FCOE_KWQE_LAYER_CODE << FCOE_KWQE_HEADER_LAYER_CODE_SHIFT);
 
-        disable_req.src_mac_addr_lo32[0] =  port->data_src_addr[5];
-        disable_req.src_mac_addr_lo32[2] =  port->data_src_addr[3];
-        disable_req.src_mac_addr_lo32[3] =  port->data_src_addr[2];
-        disable_req.src_mac_addr_hi16[0] =  port->data_src_addr[1];
-        disable_req.src_mac_addr_hi16[1] =  port->data_src_addr[0];
+        disable_req.src_mac_addr_lo[0] =  tgt->src_addr[5];
+        disable_req.src_mac_addr_lo[1] =  tgt->src_addr[4];
+        disable_req.src_mac_addr_mid[0] =  tgt->src_addr[3];
+        disable_req.src_mac_addr_mid[1] =  tgt->src_addr[2];
+        disable_req.src_mac_addr_hi[0] =  tgt->src_addr[1];
+        disable_req.src_mac_addr_hi[1] =  tgt->src_addr[0];
 
-        disable_req.dst_mac_addr_lo32[0] =  hba->ctlr.dest_addr[5];/* fcf mac */
-        disable_req.dst_mac_addr_lo32[1] =  hba->ctlr.dest_addr[4];
-        disable_req.dst_mac_addr_lo32[2] =  hba->ctlr.dest_addr[3];
-        disable_req.dst_mac_addr_lo32[3] =  hba->ctlr.dest_addr[2];
-        disable_req.dst_mac_addr_hi16[0] =  hba->ctlr.dest_addr[1];
-        disable_req.dst_mac_addr_hi16[1] =  hba->ctlr.dest_addr[0];
+        disable_req.dst_mac_addr_lo[0] =  hba->ctlr.dest_addr[5];/* fcf mac */
+        disable_req.dst_mac_addr_lo[1] =  hba->ctlr.dest_addr[4];
+        disable_req.dst_mac_addr_mid[0] =  hba->ctlr.dest_addr[3];
+        disable_req.dst_mac_addr_mid[1] =  hba->ctlr.dest_addr[2];
+        disable_req.dst_mac_addr_hi[0] =  hba->ctlr.dest_addr[1];
+        disable_req.dst_mac_addr_hi[1] =  hba->ctlr.dest_addr[0];
 
         port_id = tgt->sid;
         disable_req.s_id[0] = (port_id & 0x000000FF);
@@ -640,10 +646,10 @@ static void bnx2fc_process_unsol_compl(struct bnx2fc_rport *tgt, u16 wqe)
                 xid = err_entry->fc_hdr.ox_id;
                 BNX2FC_TGT_DBG(tgt, "Unsol Error Frame OX_ID = 0x%x\n", xid);
                 BNX2FC_TGT_DBG(tgt, "err_warn_bitmap = %08x:%08x\n",
-                        err_entry->err_warn_bitmap_hi,
-                        err_entry->err_warn_bitmap_lo);
+                        err_entry->data.err_warn_bitmap_hi,
+                        err_entry->data.err_warn_bitmap_lo);
                 BNX2FC_TGT_DBG(tgt, "buf_offsets - tx = 0x%x, rx = 0x%x\n",
-                        err_entry->tx_buf_off, err_entry->rx_buf_off);
+                        err_entry->data.tx_buf_off, err_entry->data.rx_buf_off);
 
                 bnx2fc_return_rqe(tgt, 1);
 
@@ -722,10 +728,10 @@ static void bnx2fc_process_unsol_compl(struct bnx2fc_rport *tgt, u16 wqe)
                 xid = cpu_to_be16(err_entry->fc_hdr.ox_id);
                 BNX2FC_TGT_DBG(tgt, "Unsol Warning Frame OX_ID = 0x%x\n", xid);
                 BNX2FC_TGT_DBG(tgt, "err_warn_bitmap = %08x:%08x",
-                        err_entry->err_warn_bitmap_hi,
-                        err_entry->err_warn_bitmap_lo);
+                        err_entry->data.err_warn_bitmap_hi,
+                        err_entry->data.err_warn_bitmap_lo);
                 BNX2FC_TGT_DBG(tgt, "buf_offsets - tx = 0x%x, rx = 0x%x",
-                        err_entry->tx_buf_off, err_entry->rx_buf_off);
+                        err_entry->data.tx_buf_off, err_entry->data.rx_buf_off);
 
                 bnx2fc_return_rqe(tgt, 1);
                 spin_unlock_bh(&tgt->tgt_lock);
@@ -762,9 +768,9 @@ void bnx2fc_process_cq_compl(struct bnx2fc_rport *tgt, u16 wqe)
         task_page = (struct fcoe_task_ctx_entry *)hba->task_ctx[task_idx];
         task = &(task_page[index]);
 
-        num_rq = ((task->rx_wr_tx_rd.rx_flags &
-                   FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE) >>
-                   FCOE_TASK_CTX_ENTRY_RXWR_TXRD_NUM_RQ_WQE_SHIFT);
+        num_rq = ((task->rxwr_txrd.var_ctx.rx_flags &
+                   FCOE_TCE_RX_WR_TX_RD_VAR_NUM_RQ_WQE) >>
+                   FCOE_TCE_RX_WR_TX_RD_VAR_NUM_RQ_WQE_SHIFT);
 
         io_req = (struct bnx2fc_cmd *)hba->cmd_mgr->cmds[xid];
 
@@ -777,22 +783,19 @@ void bnx2fc_process_cq_compl(struct bnx2fc_rport *tgt, u16 wqe)
         /* Timestamp IO completion time */
         cmd_type = io_req->cmd_type;
 
-        /* optimized completion path */
-        if (cmd_type == BNX2FC_SCSI_CMD) {
-                rx_state = ((task->rx_wr_tx_rd.rx_flags &
-                            FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE) >>
-                            FCOE_TASK_CTX_ENTRY_RXWR_TXRD_RX_STATE_SHIFT);
+        rx_state = ((task->rxwr_txrd.var_ctx.rx_flags &
+                    FCOE_TCE_RX_WR_TX_RD_VAR_RX_STATE) >>
+                    FCOE_TCE_RX_WR_TX_RD_VAR_RX_STATE_SHIFT);
 
+        /* Process other IO completion types */
+        switch (cmd_type) {
+        case BNX2FC_SCSI_CMD:
                 if (rx_state == FCOE_TASK_RX_STATE_COMPLETED) {
                         bnx2fc_process_scsi_cmd_compl(io_req, task, num_rq);
                         spin_unlock_bh(&tgt->tgt_lock);
                         return;
                 }
-        }
 
-        /* Process other IO completion types */
-        switch (cmd_type) {
-        case BNX2FC_SCSI_CMD:
                 if (rx_state == FCOE_TASK_RX_STATE_ABTS_COMPLETED)
                         bnx2fc_process_abts_compl(io_req, task, num_rq);
                 else if (rx_state ==
@@ -819,8 +822,16 @@ void bnx2fc_process_cq_compl(struct bnx2fc_rport *tgt, u16 wqe)
                 break;
 
         case BNX2FC_ELS:
-                BNX2FC_IO_DBG(io_req, "cq_compl - call process_els_compl\n");
-                bnx2fc_process_els_compl(io_req, task, num_rq);
+                if (rx_state == FCOE_TASK_RX_STATE_COMPLETED)
+                        bnx2fc_process_els_compl(io_req, task, num_rq);
+                else if (rx_state == FCOE_TASK_RX_STATE_ABTS_COMPLETED)
+                        bnx2fc_process_abts_compl(io_req, task, num_rq);
+                else if (rx_state ==
+                         FCOE_TASK_RX_STATE_EXCHANGE_CLEANUP_COMPLETED)
+                        bnx2fc_process_cleanup_compl(io_req, task, num_rq);
+                else
+                        printk(KERN_ERR PFX "Invalid rx state =  %d\n",
+                                rx_state);
                 break;
 
         case BNX2FC_CLEANUP:
@@ -835,6 +846,20 @@ void bnx2fc_process_cq_compl(struct bnx2fc_rport *tgt, u16 wqe)
         spin_unlock_bh(&tgt->tgt_lock);
 }
 
+void bnx2fc_arm_cq(struct bnx2fc_rport *tgt)
+{
+        struct b577xx_fcoe_rx_doorbell *rx_db = &tgt->rx_db;
+        u32 msg;
+
+        wmb();
+        rx_db->doorbell_cq_cons = tgt->cq_cons_idx | (tgt->cq_curr_toggle_bit <<
+                        FCOE_CQE_TOGGLE_BIT_SHIFT);
+        msg = *((u32 *)rx_db);
+        writel(cpu_to_le32(msg), tgt->ctx_base);
+        mmiowb();
+
+}
+
 struct bnx2fc_work *bnx2fc_alloc_work(struct bnx2fc_rport *tgt, u16 wqe)
 {
         struct bnx2fc_work *work;
@@ -853,8 +878,8 @@ int bnx2fc_process_new_cqes(struct bnx2fc_rport *tgt)
         struct fcoe_cqe *cq;
         u32 cq_cons;
         struct fcoe_cqe *cqe;
+        u32 num_free_sqes = 0;
         u16 wqe;
-        bool more_cqes_found = false;
 
         /*
          * cq_lock is a low contention lock used to protect
@@ -872,62 +897,51 @@ int bnx2fc_process_new_cqes(struct bnx2fc_rport *tgt)
         cq_cons = tgt->cq_cons_idx;
         cqe = &cq[cq_cons];
 
-        do {
-                more_cqes_found ^= true;
-
-                while (((wqe = cqe->wqe) & FCOE_CQE_TOGGLE_BIT) ==
-                       (tgt->cq_curr_toggle_bit <<
-                       FCOE_CQE_TOGGLE_BIT_SHIFT)) {
+        while (((wqe = cqe->wqe) & FCOE_CQE_TOGGLE_BIT) ==
+               (tgt->cq_curr_toggle_bit <<
+               FCOE_CQE_TOGGLE_BIT_SHIFT)) {
 
-                        /* new entry on the cq */
-                        if (wqe & FCOE_CQE_CQE_TYPE) {
-                                /* Unsolicited event notification */
-                                bnx2fc_process_unsol_compl(tgt, wqe);
-                        } else {
-                                struct bnx2fc_work *work = NULL;
-                                struct bnx2fc_percpu_s *fps = NULL;
-                                unsigned int cpu = wqe % num_possible_cpus();
-
-                                fps = &per_cpu(bnx2fc_percpu, cpu);
-                                spin_lock_bh(&fps->fp_work_lock);
-                                if (unlikely(!fps->iothread))
-                                        goto unlock;
-
-                                work = bnx2fc_alloc_work(tgt, wqe);
-                                if (work)
-                                        list_add_tail(&work->list,
-                                                        &fps->work_list);
+                /* new entry on the cq */
+                if (wqe & FCOE_CQE_CQE_TYPE) {
+                        /* Unsolicited event notification */
+                        bnx2fc_process_unsol_compl(tgt, wqe);
+                } else {
+                        /* Pending work request completion */
+                        struct bnx2fc_work *work = NULL;
+                        struct bnx2fc_percpu_s *fps = NULL;
+                        unsigned int cpu = wqe % num_possible_cpus();
+
+                        fps = &per_cpu(bnx2fc_percpu, cpu);
+                        spin_lock_bh(&fps->fp_work_lock);
+                        if (unlikely(!fps->iothread))
+                                goto unlock;
+
+                        work = bnx2fc_alloc_work(tgt, wqe);
+                        if (work)
+                                list_add_tail(&work->list,
+                                              &fps->work_list);
 unlock:
-                                spin_unlock_bh(&fps->fp_work_lock);
+                        spin_unlock_bh(&fps->fp_work_lock);
 
-                                /* Pending work request completion */
-                                if (fps->iothread && work)
-                                        wake_up_process(fps->iothread);
-                                else
-                                        bnx2fc_process_cq_compl(tgt, wqe);
-                        }
-                        cqe++;
-                        tgt->cq_cons_idx++;
-
-                        if (tgt->cq_cons_idx == BNX2FC_CQ_WQES_MAX) {
-                                tgt->cq_cons_idx = 0;
-                                cqe = cq;
-                                tgt->cq_curr_toggle_bit =
-                                        1 - tgt->cq_curr_toggle_bit;
-                        }
+                        /* Pending work request completion */
+                        if (fps->iothread && work)
+                                wake_up_process(fps->iothread);
+                        else
+                                bnx2fc_process_cq_compl(tgt, wqe);
                 }
-                /* Re-arm CQ */
-                if (more_cqes_found) {
-                        tgt->conn_db->cq_arm.lo = -1;
-                        wmb();
+                cqe++;
+                tgt->cq_cons_idx++;
+                num_free_sqes++;
+
+                if (tgt->cq_cons_idx == BNX2FC_CQ_WQES_MAX) {
+                        tgt->cq_cons_idx = 0;
+                        cqe = cq;
+                        tgt->cq_curr_toggle_bit =
+                                1 - tgt->cq_curr_toggle_bit;
                 }
-        } while (more_cqes_found);
-
-        /*
-         * Commit tgt->cq_cons_idx change to the memory
-         * spin_lock implies full memory barrier, no need to smp_wmb
-         */
-
+        }
+        bnx2fc_arm_cq(tgt);
+        atomic_add(num_free_sqes, &tgt->free_sqes);
         spin_unlock_bh(&tgt->cq_lock);
         return 0;
 }
@@ -1141,7 +1155,11 @@ static void bnx2fc_init_failure(struct bnx2fc_hba *hba, u32 err_code)
         case FCOE_KCQE_COMPLETION_STATUS_NIC_ERROR:
                 printk(KERN_ERR PFX "init_failure due to NIC error\n");
                 break;
-
+        case FCOE_KCQE_COMPLETION_STATUS_ERROR:
+                printk(KERN_ERR PFX "init failure due to compl status err\n");
+                break;
+        case FCOE_KCQE_COMPLETION_STATUS_WRONG_HSI_VERSION:
+                printk(KERN_ERR PFX "init failure due to HSI mismatch\n");
         default:
                 printk(KERN_ERR PFX "Unknown Error code %d\n", err_code);
         }
@@ -1247,21 +1265,14 @@ void bnx2fc_add_2_sq(struct bnx2fc_rport *tgt, u16 xid)
 
 void bnx2fc_ring_doorbell(struct bnx2fc_rport *tgt)
 {
-        struct b577xx_doorbell_set_prod ev_doorbell;
+        struct b577xx_doorbell_set_prod *sq_db = &tgt->sq_db;
         u32 msg;
 
         wmb();
-
-        memset(&ev_doorbell, 0, sizeof(struct b577xx_doorbell_set_prod));
-        ev_doorbell.header.header = B577XX_DOORBELL_HDR_DB_TYPE;
-
-        ev_doorbell.prod = tgt->sq_prod_idx |
+        sq_db->prod = tgt->sq_prod_idx |
                                 (tgt->sq_curr_toggle_bit << 15);
-        ev_doorbell.header.header |= B577XX_FCOE_CONNECTION_TYPE <<
-                                        B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT;
-        msg = *((u32 *)&ev_doorbell);
+        msg = *((u32 *)sq_db);
         writel(cpu_to_le32(msg), tgt->ctx_base);
-
         mmiowb();
 
 }
@@ -1322,18 +1333,26 @@ void bnx2fc_init_cleanup_task(struct bnx2fc_cmd *io_req,
         memset(task, 0, sizeof(struct fcoe_task_ctx_entry));
 
         /* Tx Write Rx Read */
-        task->tx_wr_rx_rd.tx_flags = FCOE_TASK_TX_STATE_EXCHANGE_CLEANUP <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE_SHIFT;
-        task->tx_wr_rx_rd.init_flags = task_type <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE_SHIFT;
-        task->tx_wr_rx_rd.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE_SHIFT;
-        /* Common */
-        task->cmn.common_flags = context_id <<
-                                FCOE_TASK_CTX_ENTRY_TX_RX_CMN_CID_SHIFT;
-        task->cmn.general.cleanup_info.task_id = orig_xid;
-
-
+        /* init flags */
+        task->txwr_rxrd.const_ctx.init_flags = task_type <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT;
+        task->txwr_rxrd.const_ctx.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE_SHIFT;
+        task->txwr_rxrd.const_ctx.init_flags |=
+                                FCOE_TASK_DEV_TYPE_DISK <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT;
+        task->txwr_rxrd.union_ctx.cleanup.ctx.cleaned_task_id = orig_xid;
+
+        /* Tx flags */
+        task->txwr_rxrd.const_ctx.tx_flags =
+                                FCOE_TASK_TX_STATE_EXCHANGE_CLEANUP <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_TX_STATE_SHIFT;
+
+        /* Rx Read Tx Write */
+        task->rxwr_txrd.const_ctx.init_flags = context_id <<
+                                FCOE_TCE_RX_WR_TX_RD_CONST_CID_SHIFT;
+        task->rxwr_txrd.var_ctx.rx_flags |= 1 <<
+                                FCOE_TCE_RX_WR_TX_RD_VAR_EXP_FIRST_FRAME_SHIFT;
 }
 
 void bnx2fc_init_mp_task(struct bnx2fc_cmd *io_req,
@@ -1342,6 +1361,7 @@ void bnx2fc_init_mp_task(struct bnx2fc_cmd *io_req,
         struct bnx2fc_mp_req *mp_req = &(io_req->mp_req);
         struct bnx2fc_rport *tgt = io_req->tgt;
         struct fc_frame_header *fc_hdr;
+        struct fcoe_ext_mul_sges_ctx *sgl;
         u8 task_type = 0;
         u64 *hdr;
         u64 temp_hdr[3];
@@ -1367,47 +1387,49 @@ void bnx2fc_init_mp_task(struct bnx2fc_cmd *io_req,
         /* Tx only */
         if ((task_type == FCOE_TASK_TYPE_MIDPATH) ||
             (task_type == FCOE_TASK_TYPE_UNSOLICITED)) {
-                task->tx_wr_only.sgl_ctx.mul_sges.cur_sge_addr.lo =
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.lo =
                                 (u32)mp_req->mp_req_bd_dma;
-                task->tx_wr_only.sgl_ctx.mul_sges.cur_sge_addr.hi =
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.hi =
                                 (u32)((u64)mp_req->mp_req_bd_dma >> 32);
-                task->tx_wr_only.sgl_ctx.mul_sges.sgl_size = 1;
-                BNX2FC_IO_DBG(io_req, "init_mp_task - bd_dma = 0x%llx\n",
-                              (unsigned long long)mp_req->mp_req_bd_dma);
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.sgl_size = 1;
         }
 
         /* Tx Write Rx Read */
-        task->tx_wr_rx_rd.tx_flags = FCOE_TASK_TX_STATE_INIT <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE_SHIFT;
-        task->tx_wr_rx_rd.init_flags = task_type <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE_SHIFT;
-        task->tx_wr_rx_rd.init_flags |= FCOE_TASK_DEV_TYPE_DISK <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE_SHIFT;
-        task->tx_wr_rx_rd.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE_SHIFT;
-
-        /* Common */
-        task->cmn.data_2_trns = io_req->data_xfer_len;
-        context_id = tgt->context_id;
-        task->cmn.common_flags = context_id <<
-                                FCOE_TASK_CTX_ENTRY_TX_RX_CMN_CID_SHIFT;
-        task->cmn.common_flags |= 1 <<
-                                FCOE_TASK_CTX_ENTRY_TX_RX_CMN_VALID_SHIFT;
-        task->cmn.common_flags |= 1 <<
-                        FCOE_TASK_CTX_ENTRY_TX_RX_CMN_EXP_FIRST_FRAME_SHIFT;
+        /* init flags */
+        task->txwr_rxrd.const_ctx.init_flags = task_type <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT;
+        task->txwr_rxrd.const_ctx.init_flags |=
+                                FCOE_TASK_DEV_TYPE_DISK <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT;
+        task->txwr_rxrd.const_ctx.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE_SHIFT;
+
+        /* tx flags */
+        task->txwr_rxrd.const_ctx.tx_flags = FCOE_TASK_TX_STATE_INIT <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_TX_STATE_SHIFT;
 
         /* Rx Write Tx Read */
+        task->rxwr_txrd.const_ctx.data_2_trns = io_req->data_xfer_len;
+
+        /* rx flags */
+        task->rxwr_txrd.var_ctx.rx_flags |= 1 <<
+                                FCOE_TCE_RX_WR_TX_RD_VAR_EXP_FIRST_FRAME_SHIFT;
+
+        context_id = tgt->context_id;
+        task->rxwr_txrd.const_ctx.init_flags = context_id <<
+                                FCOE_TCE_RX_WR_TX_RD_CONST_CID_SHIFT;
+
         fc_hdr = &(mp_req->req_fc_hdr);
         if (task_type == FCOE_TASK_TYPE_MIDPATH) {
                 fc_hdr->fh_ox_id = cpu_to_be16(io_req->xid);
                 fc_hdr->fh_rx_id = htons(0xffff);
-                task->rx_wr_tx_rd.rx_id = 0xffff;
+                task->rxwr_txrd.var_ctx.rx_id = 0xffff;
         } else if (task_type == FCOE_TASK_TYPE_UNSOLICITED) {
                 fc_hdr->fh_rx_id = cpu_to_be16(io_req->xid);
         }
 
         /* Fill FC Header into middle path buffer */
-        hdr = (u64 *) &task->cmn.general.cmd_info.mp_fc_frame.fc_hdr;
+        hdr = (u64 *) &task->txwr_rxrd.union_ctx.tx_frame.fc_hdr;
         memcpy(temp_hdr, fc_hdr, sizeof(temp_hdr));
         hdr[0] = cpu_to_be64(temp_hdr[0]);
         hdr[1] = cpu_to_be64(temp_hdr[1]);
@@ -1415,12 +1437,12 @@ void bnx2fc_init_mp_task(struct bnx2fc_cmd *io_req,
 
         /* Rx Only */
         if (task_type == FCOE_TASK_TYPE_MIDPATH) {
+                sgl = &task->rxwr_only.union_ctx.read_info.sgl_ctx.sgl;
 
-                task->rx_wr_only.sgl_ctx.mul_sges.cur_sge_addr.lo =
-                                (u32)mp_req->mp_resp_bd_dma;
-                task->rx_wr_only.sgl_ctx.mul_sges.cur_sge_addr.hi =
+                sgl->mul_sgl.cur_sge_addr.lo = (u32)mp_req->mp_resp_bd_dma;
+                sgl->mul_sgl.cur_sge_addr.hi =
                                 (u32)((u64)mp_req->mp_resp_bd_dma >> 32);
-                task->rx_wr_only.sgl_ctx.mul_sges.sgl_size = 1;
+                sgl->mul_sgl.sgl_size = 1;
         }
 }
 
@@ -1431,6 +1453,8 @@ void bnx2fc_init_task(struct bnx2fc_cmd *io_req,
         struct scsi_cmnd *sc_cmd = io_req->sc_cmd;
         struct io_bdt *bd_tbl = io_req->bd_tbl;
         struct bnx2fc_rport *tgt = io_req->tgt;
+        struct fcoe_cached_sge_ctx *cached_sge;
+        struct fcoe_ext_mul_sges_ctx *sgl;
         u64 *fcp_cmnd;
         u64 tmp_fcp_cmnd[4];
         u32 context_id;
@@ -1449,47 +1473,33 @@ void bnx2fc_init_task(struct bnx2fc_cmd *io_req,
 
         /* Tx only */
         if (task_type == FCOE_TASK_TYPE_WRITE) {
-                task->tx_wr_only.sgl_ctx.mul_sges.cur_sge_addr.lo =
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.lo =
                                 (u32)bd_tbl->bd_tbl_dma;
-                task->tx_wr_only.sgl_ctx.mul_sges.cur_sge_addr.hi =
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.hi =
                                 (u32)((u64)bd_tbl->bd_tbl_dma >> 32);
-                task->tx_wr_only.sgl_ctx.mul_sges.sgl_size =
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.sgl_size =
                                 bd_tbl->bd_valid;
         }
 
         /*Tx Write Rx Read */
         /* Init state to NORMAL */
-        task->tx_wr_rx_rd.tx_flags = FCOE_TASK_TX_STATE_NORMAL <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TX_STATE_SHIFT;
-        task->tx_wr_rx_rd.init_flags = task_type <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_TASK_TYPE_SHIFT;
-        task->tx_wr_rx_rd.init_flags |= FCOE_TASK_DEV_TYPE_DISK <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_DEV_TYPE_SHIFT;
-        task->tx_wr_rx_rd.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_CLASS_TYPE_SHIFT;
-
-        /* Common */
-        task->cmn.data_2_trns = io_req->data_xfer_len;
-        context_id = tgt->context_id;
-        task->cmn.common_flags = context_id <<
-                                FCOE_TASK_CTX_ENTRY_TX_RX_CMN_CID_SHIFT;
-        task->cmn.common_flags |= 1 <<
-                                FCOE_TASK_CTX_ENTRY_TX_RX_CMN_VALID_SHIFT;
-        task->cmn.common_flags |= 1 <<
-                        FCOE_TASK_CTX_ENTRY_TX_RX_CMN_EXP_FIRST_FRAME_SHIFT;
-
-        /* Set initiative ownership */
-        task->cmn.common_flags |= FCOE_TASK_CTX_ENTRY_TX_RX_CMN_SEQ_INIT;
+        task->txwr_rxrd.const_ctx.init_flags = task_type <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT;
+        task->txwr_rxrd.const_ctx.init_flags |=
+                                FCOE_TASK_DEV_TYPE_DISK <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT;
+        task->txwr_rxrd.const_ctx.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE_SHIFT;
+        /* tx flags */
+        task->txwr_rxrd.const_ctx.tx_flags = FCOE_TASK_TX_STATE_NORMAL <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_TX_STATE_SHIFT;
 
         /* Set initial seq counter */
-        task->cmn.tx_low_seq_cnt = 1;
-
-        /* Set state to "waiting for the first packet" */
-        task->cmn.common_flags |= FCOE_TASK_CTX_ENTRY_TX_RX_CMN_EXP_FIRST_FRAME;
+        task->txwr_rxrd.union_ctx.tx_seq.ctx.seq_cnt = 1;
 
         /* Fill FCP_CMND IU */
         fcp_cmnd = (u64 *)
-                    task->cmn.general.cmd_info.fcp_cmd_payload.opaque;
+                    task->txwr_rxrd.union_ctx.fcp_cmd.opaque;
         bnx2fc_build_fcp_cmnd(io_req, (struct fcp_cmnd *)&tmp_fcp_cmnd);
 
         /* swap fcp_cmnd */
@@ -1501,32 +1511,54 @@ void bnx2fc_init_task(struct bnx2fc_cmd *io_req,
         }
 
         /* Rx Write Tx Read */
-        task->rx_wr_tx_rd.rx_id = 0xffff;
+        task->rxwr_txrd.const_ctx.data_2_trns = io_req->data_xfer_len;
+
+        context_id = tgt->context_id;
+        task->rxwr_txrd.const_ctx.init_flags = context_id <<
+                                FCOE_TCE_RX_WR_TX_RD_CONST_CID_SHIFT;
+
+        /* rx flags */
+        /* Set state to "waiting for the first packet" */
+        task->rxwr_txrd.var_ctx.rx_flags |= 1 <<
+                                FCOE_TCE_RX_WR_TX_RD_VAR_EXP_FIRST_FRAME_SHIFT;
+
+        task->rxwr_txrd.var_ctx.rx_id = 0xffff;
 
         /* Rx Only */
+        cached_sge = &task->rxwr_only.union_ctx.read_info.sgl_ctx.cached_sge;
+        sgl = &task->rxwr_only.union_ctx.read_info.sgl_ctx.sgl;
+        bd_count = bd_tbl->bd_valid;
         if (task_type == FCOE_TASK_TYPE_READ) {
-
-                bd_count = bd_tbl->bd_valid;
                 if (bd_count == 1) {
 
                         struct fcoe_bd_ctx *fcoe_bd_tbl = bd_tbl->bd_tbl;
 
-                        task->rx_wr_only.sgl_ctx.single_sge.cur_buf_addr.lo =
-                                        fcoe_bd_tbl->buf_addr_lo;
-                        task->rx_wr_only.sgl_ctx.single_sge.cur_buf_addr.hi =
-                                        fcoe_bd_tbl->buf_addr_hi;
-                        task->rx_wr_only.sgl_ctx.single_sge.cur_buf_rem =
-                                        fcoe_bd_tbl->buf_len;
-                        task->tx_wr_rx_rd.init_flags |= 1 <<
-                                FCOE_TASK_CTX_ENTRY_TXWR_RXRD_SINGLE_SGE_SHIFT;
+                        cached_sge->cur_buf_addr.lo = fcoe_bd_tbl->buf_addr_lo;
+                        cached_sge->cur_buf_addr.hi = fcoe_bd_tbl->buf_addr_hi;
+                        cached_sge->cur_buf_rem = fcoe_bd_tbl->buf_len;
+                        task->txwr_rxrd.const_ctx.init_flags |= 1 <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_CACHED_SGE_SHIFT;
+                } else if (bd_count == 2) {
+                        struct fcoe_bd_ctx *fcoe_bd_tbl = bd_tbl->bd_tbl;
+
+                        cached_sge->cur_buf_addr.lo = fcoe_bd_tbl->buf_addr_lo;
+                        cached_sge->cur_buf_addr.hi = fcoe_bd_tbl->buf_addr_hi;
+                        cached_sge->cur_buf_rem = fcoe_bd_tbl->buf_len;
+
+                        fcoe_bd_tbl++;
+                        cached_sge->second_buf_addr.lo =
+                                                 fcoe_bd_tbl->buf_addr_lo;
+                        cached_sge->second_buf_addr.hi =
+                                                fcoe_bd_tbl->buf_addr_hi;
+                        cached_sge->second_buf_rem = fcoe_bd_tbl->buf_len;
+                        task->txwr_rxrd.const_ctx.init_flags |= 1 <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_CACHED_SGE_SHIFT;
                 } else {
 
-                        task->rx_wr_only.sgl_ctx.mul_sges.cur_sge_addr.lo =
-                                        (u32)bd_tbl->bd_tbl_dma;
-                        task->rx_wr_only.sgl_ctx.mul_sges.cur_sge_addr.hi =
+                        sgl->mul_sgl.cur_sge_addr.lo = (u32)bd_tbl->bd_tbl_dma;
+                        sgl->mul_sgl.cur_sge_addr.hi =
                                         (u32)((u64)bd_tbl->bd_tbl_dma >> 32);
-                        task->rx_wr_only.sgl_ctx.mul_sges.sgl_size =
-                                        bd_tbl->bd_valid;
+                        sgl->mul_sgl.sgl_size = bd_count;
                 }
         }
 }
diff --git a/drivers/scsi/bnx2fc/bnx2fc_io.c b/drivers/scsi/bnx2fc/bnx2fc_io.c
index b5b5c346d779..5dc4205ed8af 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_io.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_io.c
@@ -425,6 +425,7 @@ struct bnx2fc_cmd *bnx2fc_elstm_alloc(struct bnx2fc_rport *tgt, int type)
         struct list_head *listp;
         struct io_bdt *bd_tbl;
         int index = RESERVE_FREE_LIST_INDEX;
+        u32 free_sqes;
         u32 max_sqes;
         u16 xid;
 
@@ -445,8 +446,10 @@ struct bnx2fc_cmd *bnx2fc_elstm_alloc(struct bnx2fc_rport *tgt, int type)
          * cmgr lock
          */
         spin_lock_bh(&cmd_mgr->free_list_lock[index]);
+        free_sqes = atomic_read(&tgt->free_sqes);
         if ((list_empty(&(cmd_mgr->free_list[index]))) ||
-            (tgt->num_active_ios.counter  >= max_sqes)) {
+            (tgt->num_active_ios.counter  >= max_sqes) ||
+            (free_sqes + max_sqes <= BNX2FC_SQ_WQES_MAX)) {
                 BNX2FC_TGT_DBG(tgt, "No free els_tm cmds available "
                         "ios(%d):sqes(%d)\n",
                         tgt->num_active_ios.counter, tgt->max_sqes);
@@ -463,6 +466,7 @@ struct bnx2fc_cmd *bnx2fc_elstm_alloc(struct bnx2fc_rport *tgt, int type)
         xid = io_req->xid;
         cmd_mgr->cmds[xid] = io_req;
         atomic_inc(&tgt->num_active_ios);
+        atomic_dec(&tgt->free_sqes);
         spin_unlock_bh(&cmd_mgr->free_list_lock[index]);
 
         INIT_LIST_HEAD(&io_req->link);
@@ -489,6 +493,7 @@ static struct bnx2fc_cmd *bnx2fc_cmd_alloc(struct bnx2fc_rport *tgt)
         struct bnx2fc_cmd *io_req;
         struct list_head *listp;
         struct io_bdt *bd_tbl;
+        u32 free_sqes;
         u32 max_sqes;
         u16 xid;
         int index = get_cpu();
@@ -499,8 +504,10 @@ static struct bnx2fc_cmd *bnx2fc_cmd_alloc(struct bnx2fc_rport *tgt)
          * cmgr lock
          */
         spin_lock_bh(&cmd_mgr->free_list_lock[index]);
+        free_sqes = atomic_read(&tgt->free_sqes);
         if ((list_empty(&cmd_mgr->free_list[index])) ||
-            (tgt->num_active_ios.counter  >= max_sqes)) {
+            (tgt->num_active_ios.counter  >= max_sqes) ||
+            (free_sqes + max_sqes <= BNX2FC_SQ_WQES_MAX)) {
                 spin_unlock_bh(&cmd_mgr->free_list_lock[index]);
                 put_cpu();
                 return NULL;
@@ -513,6 +520,7 @@ static struct bnx2fc_cmd *bnx2fc_cmd_alloc(struct bnx2fc_rport *tgt)
         xid = io_req->xid;
         cmd_mgr->cmds[xid] = io_req;
         atomic_inc(&tgt->num_active_ios);
+        atomic_dec(&tgt->free_sqes);
         spin_unlock_bh(&cmd_mgr->free_list_lock[index]);
         put_cpu();
 
@@ -873,7 +881,7 @@ int bnx2fc_initiate_abts(struct bnx2fc_cmd *io_req)
 
         /* Obtain oxid and rxid for the original exchange to be aborted */
         fc_hdr->fh_ox_id = htons(io_req->xid);
-        fc_hdr->fh_rx_id = htons(io_req->task->rx_wr_tx_rd.rx_id);
+        fc_hdr->fh_rx_id = htons(io_req->task->rxwr_txrd.var_ctx.rx_id);
 
         sid = tgt->sid;
         did = rport->port_id;
@@ -1189,7 +1197,7 @@ void bnx2fc_process_abts_compl(struct bnx2fc_cmd *io_req,
                         kref_put(&io_req->refcount,
                                  bnx2fc_cmd_release); /* drop timer hold */
 
-        r_ctl = task->cmn.general.rsp_info.abts_rsp.r_ctl;
+        r_ctl = (u8)task->rxwr_only.union_ctx.comp_info.abts_rsp.r_ctl;
 
         switch (r_ctl) {
         case FC_RCTL_BA_ACC:
@@ -1344,12 +1352,13 @@ void bnx2fc_process_tm_compl(struct bnx2fc_cmd *io_req,
         fc_hdr = &(tm_req->resp_fc_hdr);
         hdr = (u64 *)fc_hdr;
         temp_hdr = (u64 *)
-                &task->cmn.general.cmd_info.mp_fc_frame.fc_hdr;
+                &task->rxwr_only.union_ctx.comp_info.mp_rsp.fc_hdr;
         hdr[0] = cpu_to_be64(temp_hdr[0]);
         hdr[1] = cpu_to_be64(temp_hdr[1]);
         hdr[2] = cpu_to_be64(temp_hdr[2]);
 
-        tm_req->resp_len = task->rx_wr_only.sgl_ctx.mul_sges.cur_sge_off;
+        tm_req->resp_len =
+                task->rxwr_only.union_ctx.comp_info.mp_rsp.mp_payload_len;
 
         rsp_buf = tm_req->resp_buf;
 
@@ -1724,7 +1733,7 @@ void bnx2fc_process_scsi_cmd_compl(struct bnx2fc_cmd *io_req,
 
         /* Fetch fcp_rsp from task context and perform cmd completion */
         fcp_rsp = (struct fcoe_fcp_rsp_payload *)
-                   &(task->cmn.general.rsp_info.fcp_rsp.payload);
+                   &(task->rxwr_only.union_ctx.comp_info.fcp_rsp.payload);
 
         /* parse fcp_rsp and obtain sense data from RQ if available */
         bnx2fc_parse_fcp_rsp(io_req, fcp_rsp, num_rq);
diff --git a/drivers/scsi/bnx2fc/bnx2fc_tgt.c b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
index a2e3830bd268..3e892bd66fbe 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_tgt.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
@@ -133,6 +133,8 @@ retry_ofld:
                 /* upload will take care of cleaning up sess resc */
                 lport->tt.rport_logoff(rdata);
         }
+        /* Arm CQ */
+        bnx2fc_arm_cq(tgt);
         return;
 
 ofld_err:
@@ -315,6 +317,8 @@ static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
 
         struct fc_rport *rport = rdata->rport;
         struct bnx2fc_hba *hba = port->priv;
+        struct b577xx_doorbell_set_prod *sq_db = &tgt->sq_db;
+        struct b577xx_fcoe_rx_doorbell *rx_db = &tgt->rx_db;
 
         tgt->rport = rport;
         tgt->rdata = rdata;
@@ -335,6 +339,7 @@ static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
         tgt->max_sqes = BNX2FC_SQ_WQES_MAX;
         tgt->max_rqes = BNX2FC_RQ_WQES_MAX;
         tgt->max_cqes = BNX2FC_CQ_WQES_MAX;
+        atomic_set(&tgt->free_sqes, BNX2FC_SQ_WQES_MAX);
 
         /* Initialize the toggle bit */
         tgt->sq_curr_toggle_bit = 1;
@@ -345,7 +350,17 @@ static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
         tgt->rq_cons_idx = 0;
         atomic_set(&tgt->num_active_ios, 0);
 
-        tgt->work_time_slice = 2;
+        /* initialize sq doorbell */
+        sq_db->header.header = B577XX_DOORBELL_HDR_DB_TYPE;
+        sq_db->header.header |= B577XX_FCOE_CONNECTION_TYPE <<
+                                        B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT;
+        /* initialize rx doorbell */
+        rx_db->hdr.header = ((0x1 << B577XX_DOORBELL_HDR_RX_SHIFT) |
+                          (0x1 << B577XX_DOORBELL_HDR_DB_TYPE_SHIFT) |
+                          (B577XX_FCOE_CONNECTION_TYPE <<
+                                B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT));
+        rx_db->params = (0x2 << B577XX_FCOE_RX_DOORBELL_NEGATIVE_ARM_SHIFT) |
+                     (0x3 << B577XX_FCOE_RX_DOORBELL_OPCODE_SHIFT);
 
         spin_lock_init(&tgt->tgt_lock);
         spin_lock_init(&tgt->cq_lock);
@@ -758,8 +773,6 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         }
         memset(tgt->lcq, 0, tgt->lcq_mem_size);
 
-        /* Arm CQ */
-        tgt->conn_db->cq_arm.lo = -1;
         tgt->conn_db->rq_prod = 0x8000;
 
         return 0;
@@ -787,6 +800,8 @@ static void bnx2fc_free_session_resc(struct bnx2fc_hba *hba,
                 iounmap(tgt->ctx_base);
                 tgt->ctx_base = NULL;
         }
+
+        spin_lock_bh(&tgt->cq_lock);
         /* Free LCQ */
         if (tgt->lcq) {
                 dma_free_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
@@ -828,17 +843,16 @@ static void bnx2fc_free_session_resc(struct bnx2fc_hba *hba,
                 tgt->rq = NULL;
         }
         /* Free CQ */
-        spin_lock_bh(&tgt->cq_lock);
         if (tgt->cq) {
                 dma_free_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
                                     tgt->cq, tgt->cq_dma);
                 tgt->cq = NULL;
         }
-        spin_unlock_bh(&tgt->cq_lock);
         /* Free SQ */
         if (tgt->sq) {
                 dma_free_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
                                     tgt->sq, tgt->sq_dma);
                 tgt->sq = NULL;
         }
+        spin_unlock_bh(&tgt->cq_lock);
 }
diff --git a/drivers/scsi/bnx2i/57xx_iscsi_hsi.h b/drivers/scsi/bnx2i/57xx_iscsi_hsi.h
index dad6c8a34317..71890a063cd3 100644
--- a/drivers/scsi/bnx2i/57xx_iscsi_hsi.h
+++ b/drivers/scsi/bnx2i/57xx_iscsi_hsi.h
@@ -707,8 +707,10 @@ struct iscsi_kwqe_conn_update {
 #define ISCSI_KWQE_CONN_UPDATE_INITIAL_R2T_SHIFT 2
 #define ISCSI_KWQE_CONN_UPDATE_IMMEDIATE_DATA (0x1<<3)
 #define ISCSI_KWQE_CONN_UPDATE_IMMEDIATE_DATA_SHIFT 3
-#define ISCSI_KWQE_CONN_UPDATE_RESERVED1 (0xF<<4)
-#define ISCSI_KWQE_CONN_UPDATE_RESERVED1_SHIFT 4
+#define ISCSI_KWQE_CONN_UPDATE_OOO_SUPPORT_MODE (0x3<<4)
+#define ISCSI_KWQE_CONN_UPDATE_OOO_SUPPORT_MODE_SHIFT 4
+#define ISCSI_KWQE_CONN_UPDATE_RESERVED1 (0x3<<6)
+#define ISCSI_KWQE_CONN_UPDATE_RESERVED1_SHIFT 6
 #elif defined(__LITTLE_ENDIAN)
         u8 conn_flags;
 #define ISCSI_KWQE_CONN_UPDATE_HEADER_DIGEST (0x1<<0)
@@ -719,8 +721,10 @@ struct iscsi_kwqe_conn_update {
 #define ISCSI_KWQE_CONN_UPDATE_INITIAL_R2T_SHIFT 2
 #define ISCSI_KWQE_CONN_UPDATE_IMMEDIATE_DATA (0x1<<3)
 #define ISCSI_KWQE_CONN_UPDATE_IMMEDIATE_DATA_SHIFT 3
-#define ISCSI_KWQE_CONN_UPDATE_RESERVED1 (0xF<<4)
-#define ISCSI_KWQE_CONN_UPDATE_RESERVED1_SHIFT 4
+#define ISCSI_KWQE_CONN_UPDATE_OOO_SUPPORT_MODE (0x3<<4)
+#define ISCSI_KWQE_CONN_UPDATE_OOO_SUPPORT_MODE_SHIFT 4
+#define ISCSI_KWQE_CONN_UPDATE_RESERVED1 (0x3<<6)
+#define ISCSI_KWQE_CONN_UPDATE_RESERVED1_SHIFT 6
         u8 reserved2;
         u8 max_outstanding_r2ts;
         u8 session_error_recovery_level;