qed: Utilize FW 8.20.0.0
authorMintz, Yuval <Yuval.Mintz@cavium.com>
Thu, 18 May 2017 16:41:04 +0000 (19:41 +0300)
committerDavid S. Miller <davem@davemloft.net>
Thu, 18 May 2017 17:21:40 +0000 (13:21 -0400)
This pushes qed [and as result, all qed* drivers] into using 8.20.0.0
firmware. The changes are mostly contained in qed with minor changes
to qedi due to some HSI changes.

Content-wise, the firmware contains fixes to various issues exposed
since the release of the previous firmware, including:
 - Corrects iSCSI fast retransmit when data digest is enabled.
 - Stop draining packets when receiving several consecutive PFCs.
 - Prevent possible assertion when consecutively opening/closing
   many connections.
 - Prevent possible assertion due to too long BDQ fetch time.

In addition, the new firmware would allow us to later add iWARP support
in qed and qedr.

Changes from previous version
-----------------------------
 - V2: Fix warning in qed_debug.c

Signed-off-by: Chad Dupuis <Chad.Dupuis@cavium.com>
Signed-off-by: Ram Amrani <Ram.Amrani@cavium.com>
Signed-off-by: Tomer Tayar <Tomer.Tayar@cavium.com>
Signed-off-by: Manish Rangankar <Manish.Rangankar@cavium.com>
Signed-off-by: Yuval Mintz <Yuval.Mintz@cavium.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
20 files changed:
drivers/net/ethernet/qlogic/qed/qed.h
drivers/net/ethernet/qlogic/qed/qed_dcbx.c
drivers/net/ethernet/qlogic/qed/qed_debug.c
drivers/net/ethernet/qlogic/qed/qed_debug.h
drivers/net/ethernet/qlogic/qed/qed_hsi.h
drivers/net/ethernet/qlogic/qed/qed_init_fw_funcs.c
drivers/net/ethernet/qlogic/qed/qed_iscsi.c
drivers/net/ethernet/qlogic/qed/qed_reg_addr.h
drivers/net/ethernet/qlogic/qed/qed_roce.c
drivers/net/ethernet/qlogic/qed/qed_sp_commands.c
drivers/scsi/qedi/qedi_fw.c
drivers/scsi/qedi/qedi_fw_api.c
drivers/scsi/qedi/qedi_iscsi.c
include/linux/qed/common_hsi.h
include/linux/qed/eth_common.h
include/linux/qed/fcoe_common.h
include/linux/qed/iscsi_common.h
include/linux/qed/rdma_common.h
include/linux/qed/roce_common.h
include/linux/qed/tcp_common.h

index 2ab1aab7c3feb010505dc8a33e8bf96823251680..162cd7ff9a694ed9bada0c4fc0640e1834b13467 100644 (file)
@@ -54,7 +54,7 @@ extern const struct qed_common_ops qed_common_ops_pass;
 
 #define QED_MAJOR_VERSION               8
 #define QED_MINOR_VERSION               10
-#define QED_REVISION_VERSION            10
+#define QED_REVISION_VERSION            11
 #define QED_ENGINEERING_VERSION 21
 
 #define QED_VERSION                                             \
index d883ad5bec6dc61b73e49abc507c26dce10f8fb3..b7ca0e2181c44deb64f8f7ba0b935007314800da 100644 (file)
@@ -944,17 +944,18 @@ void qed_dcbx_set_pf_update_params(struct qed_dcbx_results *p_src,
        p_dest->pf_id = p_src->pf_id;
 
        update_flag = p_src->arr[DCBX_PROTOCOL_FCOE].update;
-       p_dest->update_fcoe_dcb_data_flag = update_flag;
+       p_dest->update_fcoe_dcb_data_mode = update_flag;
 
        update_flag = p_src->arr[DCBX_PROTOCOL_ROCE].update;
-       p_dest->update_roce_dcb_data_flag = update_flag;
+       p_dest->update_roce_dcb_data_mode = update_flag;
+
        update_flag = p_src->arr[DCBX_PROTOCOL_ROCE_V2].update;
-       p_dest->update_roce_dcb_data_flag = update_flag;
+       p_dest->update_rroce_dcb_data_mode = update_flag;
 
        update_flag = p_src->arr[DCBX_PROTOCOL_ISCSI].update;
-       p_dest->update_iscsi_dcb_data_flag = update_flag;
+       p_dest->update_iscsi_dcb_data_mode = update_flag;
        update_flag = p_src->arr[DCBX_PROTOCOL_ETH].update;
-       p_dest->update_eth_dcb_data_flag = update_flag;
+       p_dest->update_eth_dcb_data_mode = update_flag;
 
        p_dcb_data = &p_dest->fcoe_dcb_data;
        qed_dcbx_update_protocol_data(p_dcb_data, p_src, DCBX_PROTOCOL_FCOE);
index 483241b4b05db2add64ff928ccc9419fe733355a..87a1389fb4a8f9ecbf454b4f88988c189fb6f126 100644 (file)
 #include "qed_mcp.h"
 #include "qed_reg_addr.h"
 
-/* Chip IDs enum */
-enum chip_ids {
-       CHIP_BB_B0,
-       CHIP_K2,
-       MAX_CHIP_IDS
-};
-
 /* Memory groups enum */
 enum mem_groups {
        MEM_GROUP_PXP_MEM,
@@ -33,7 +26,6 @@ enum mem_groups {
        MEM_GROUP_BRB_MEM,
        MEM_GROUP_PRS_MEM,
        MEM_GROUP_SDM_MEM,
-       MEM_GROUP_PBUF,
        MEM_GROUP_IOR,
        MEM_GROUP_RAM,
        MEM_GROUP_BTB_RAM,
@@ -45,6 +37,7 @@ enum mem_groups {
        MEM_GROUP_CAU_PI,
        MEM_GROUP_CAU_MEM,
        MEM_GROUP_PXP_ILT,
+       MEM_GROUP_PBUF,
        MEM_GROUP_MULD_MEM,
        MEM_GROUP_BTB_MEM,
        MEM_GROUP_IGU_MEM,
@@ -66,7 +59,6 @@ static const char * const s_mem_group_names[] = {
        "BRB_MEM",
        "PRS_MEM",
        "SDM_MEM",
-       "PBUF",
        "IOR",
        "RAM",
        "BTB_RAM",
@@ -78,6 +70,7 @@ static const char * const s_mem_group_names[] = {
        "CAU_PI",
        "CAU_MEM",
        "PXP_ILT",
+       "PBUF",
        "MULD_MEM",
        "BTB_MEM",
        "IGU_MEM",
@@ -88,48 +81,59 @@ static const char * const s_mem_group_names[] = {
 };
 
 /* Idle check conditions */
-static u32 cond4(const u32 *r, const u32 *imm)
+
+static u32 cond5(const u32 *r, const u32 *imm)
 {
        return ((r[0] & imm[0]) != imm[1]) && ((r[1] & imm[2]) != imm[3]);
 }
 
-static u32 cond6(const u32 *r, const u32 *imm)
+static u32 cond7(const u32 *r, const u32 *imm)
 {
        return ((r[0] >> imm[0]) & imm[1]) != imm[2];
 }
 
-static u32 cond5(const u32 *r, const u32 *imm)
+static u32 cond14(const u32 *r, const u32 *imm)
+{
+       return (r[0] != imm[0]) && (((r[1] >> imm[1]) & imm[2]) == imm[3]);
+}
+
+static u32 cond6(const u32 *r, const u32 *imm)
 {
        return (r[0] & imm[0]) != imm[1];
 }
 
-static u32 cond8(const u32 *r, const u32 *imm)
+static u32 cond9(const u32 *r, const u32 *imm)
 {
        return ((r[0] & imm[0]) >> imm[1]) !=
            (((r[0] & imm[2]) >> imm[3]) | ((r[1] & imm[4]) << imm[5]));
 }
 
-static u32 cond9(const u32 *r, const u32 *imm)
+static u32 cond10(const u32 *r, const u32 *imm)
 {
        return ((r[0] & imm[0]) >> imm[1]) != (r[0] & imm[2]);
 }
 
-static u32 cond1(const u32 *r, const u32 *imm)
+static u32 cond4(const u32 *r, const u32 *imm)
 {
        return (r[0] & ~imm[0]) != imm[1];
 }
 
 static u32 cond0(const u32 *r, const u32 *imm)
+{
+       return (r[0] & ~r[1]) != imm[0];
+}
+
+static u32 cond1(const u32 *r, const u32 *imm)
 {
        return r[0] != imm[0];
 }
 
-static u32 cond10(const u32 *r, const u32 *imm)
+static u32 cond11(const u32 *r, const u32 *imm)
 {
        return r[0] != r[1] && r[2] == imm[0];
 }
 
-static u32 cond11(const u32 *r, const u32 *imm)
+static u32 cond12(const u32 *r, const u32 *imm)
 {
        return r[0] != r[1] && r[2] > imm[0];
 }
@@ -139,12 +143,12 @@ static u32 cond3(const u32 *r, const u32 *imm)
        return r[0] != r[1];
 }
 
-static u32 cond12(const u32 *r, const u32 *imm)
+static u32 cond13(const u32 *r, const u32 *imm)
 {
        return r[0] & imm[0];
 }
 
-static u32 cond7(const u32 *r, const u32 *imm)
+static u32 cond8(const u32 *r, const u32 *imm)
 {
        return r[0] < (r[1] - imm[0]);
 }
@@ -169,6 +173,8 @@ static u32(*cond_arr[]) (const u32 *r, const u32 *imm) = {
        cond10,
        cond11,
        cond12,
+       cond13,
+       cond14,
 };
 
 /******************************* Data Types **********************************/
@@ -181,11 +187,6 @@ enum platform_ids {
        MAX_PLATFORM_IDS
 };
 
-struct dbg_array {
-       const u32 *ptr;
-       u32 size_in_dwords;
-};
-
 struct chip_platform_defs {
        u8 num_ports;
        u8 num_pfs;
@@ -204,7 +205,9 @@ struct platform_defs {
        u32 delay_factor;
 };
 
-/* Storm constant definitions */
+/* Storm constant definitions.
+ * Addresses are in bytes, sizes are in quad-regs.
+ */
 struct storm_defs {
        char letter;
        enum block_id block_id;
@@ -218,13 +221,13 @@ struct storm_defs {
        u32 sem_sync_dbg_empty_addr;
        u32 sem_slow_dbg_empty_addr;
        u32 cm_ctx_wr_addr;
-       u32 cm_conn_ag_ctx_lid_size; /* In quad-regs */
+       u32 cm_conn_ag_ctx_lid_size;
        u32 cm_conn_ag_ctx_rd_addr;
-       u32 cm_conn_st_ctx_lid_size; /* In quad-regs */
+       u32 cm_conn_st_ctx_lid_size;
        u32 cm_conn_st_ctx_rd_addr;
-       u32 cm_task_ag_ctx_lid_size; /* In quad-regs */
+       u32 cm_task_ag_ctx_lid_size;
        u32 cm_task_ag_ctx_rd_addr;
-       u32 cm_task_st_ctx_lid_size; /* In quad-regs */
+       u32 cm_task_st_ctx_lid_size;
        u32 cm_task_st_ctx_rd_addr;
 };
 
@@ -233,17 +236,23 @@ struct block_defs {
        const char *name;
        bool has_dbg_bus[MAX_CHIP_IDS];
        bool associated_to_storm;
-       u32 storm_id; /* Valid only if associated_to_storm is true */
+
+       /* Valid only if associated_to_storm is true */
+       u32 storm_id;
        enum dbg_bus_clients dbg_client_id[MAX_CHIP_IDS];
        u32 dbg_select_addr;
-       u32 dbg_cycle_enable_addr;
+       u32 dbg_enable_addr;
        u32 dbg_shift_addr;
        u32 dbg_force_valid_addr;
        u32 dbg_force_frame_addr;
        bool has_reset_bit;
-       bool unreset; /* If true, the block is taken out of reset before dump */
+
+       /* If true, block is taken out of reset before dump */
+       bool unreset;
        enum dbg_reset_regs reset_reg;
-       u8 reset_bit_offset; /* Bit offset in reset register */
+
+       /* Bit offset in reset register */
+       u8 reset_bit_offset;
 };
 
 /* Reset register definitions */
@@ -262,12 +271,13 @@ struct grc_param_defs {
        u32 crash_preset_val;
 };
 
+/* Address is in 128b units. Width is in bits. */
 struct rss_mem_defs {
        const char *mem_name;
        const char *type_name;
-       u32 addr; /* In 128b units */
+       u32 addr;
        u32 num_entries[MAX_CHIP_IDS];
-       u32 entry_width[MAX_CHIP_IDS]; /* In bits */
+       u32 entry_width[MAX_CHIP_IDS];
 };
 
 struct vfc_ram_defs {
@@ -289,10 +299,20 @@ struct big_ram_defs {
 
 struct phy_defs {
        const char *phy_name;
+
+       /* PHY base GRC address */
        u32 base_addr;
+
+       /* Relative address of indirect TBUS address register (bits 0..7) */
        u32 tbus_addr_lo_addr;
+
+       /* Relative address of indirect TBUS address register (bits 8..10) */
        u32 tbus_addr_hi_addr;
+
+       /* Relative address of indirect TBUS data register (bits 0..7) */
        u32 tbus_data_lo_addr;
+
+       /* Relative address of indirect TBUS data register (bits 8..11) */
        u32 tbus_data_hi_addr;
 };
 
@@ -300,9 +320,11 @@ struct phy_defs {
 
 #define MAX_LCIDS                      320
 #define MAX_LTIDS                      320
+
 #define NUM_IOR_SETS                   2
 #define IORS_PER_SET                   176
 #define IOR_SET_OFFSET(set_id)         ((set_id) * 256)
+
 #define BYTES_IN_DWORD                 sizeof(u32)
 
 /* In the macros below, size and offset are specified in bits */
@@ -315,6 +337,7 @@ struct phy_defs {
 #define FIELD_BIT_MASK(type, field) \
        (((1 << FIELD_BIT_SIZE(type, field)) - 1) << \
         FIELD_DWORD_SHIFT(type, field))
+
 #define SET_VAR_FIELD(var, type, field, val) \
        do { \
                var[FIELD_DWORD_OFFSET(type, field)] &= \
@@ -322,31 +345,51 @@ struct phy_defs {
                var[FIELD_DWORD_OFFSET(type, field)] |= \
                (val) << FIELD_DWORD_SHIFT(type, field); \
        } while (0)
+
 #define ARR_REG_WR(dev, ptt, addr, arr, arr_size) \
        do { \
                for (i = 0; i < (arr_size); i++) \
                        qed_wr(dev, ptt, addr,  (arr)[i]); \
        } while (0)
+
 #define ARR_REG_RD(dev, ptt, addr, arr, arr_size) \
        do { \
                for (i = 0; i < (arr_size); i++) \
                        (arr)[i] = qed_rd(dev, ptt, addr); \
        } while (0)
 
+#ifndef DWORDS_TO_BYTES
 #define DWORDS_TO_BYTES(dwords)                ((dwords) * BYTES_IN_DWORD)
+#endif
+#ifndef BYTES_TO_DWORDS
 #define BYTES_TO_DWORDS(bytes)         ((bytes) / BYTES_IN_DWORD)
+#endif
+
+/* extra lines include a signature line + optional latency events line */
+#ifndef NUM_DBG_LINES
+#define NUM_EXTRA_DBG_LINES(block_desc) \
+       (1 + ((block_desc)->has_latency_events ? 1 : 0))
+#define NUM_DBG_LINES(block_desc) \
+       ((block_desc)->num_of_lines + NUM_EXTRA_DBG_LINES(block_desc))
+#endif
+
 #define RAM_LINES_TO_DWORDS(lines)     ((lines) * 2)
 #define RAM_LINES_TO_BYTES(lines) \
        DWORDS_TO_BYTES(RAM_LINES_TO_DWORDS(lines))
+
 #define REG_DUMP_LEN_SHIFT             24
 #define MEM_DUMP_ENTRY_SIZE_DWORDS \
        BYTES_TO_DWORDS(sizeof(struct dbg_dump_mem))
+
 #define IDLE_CHK_RULE_SIZE_DWORDS \
        BYTES_TO_DWORDS(sizeof(struct dbg_idle_chk_rule))
+
 #define IDLE_CHK_RESULT_HDR_DWORDS \
        BYTES_TO_DWORDS(sizeof(struct dbg_idle_chk_result_hdr))
+
 #define IDLE_CHK_RESULT_REG_HDR_DWORDS \
        BYTES_TO_DWORDS(sizeof(struct dbg_idle_chk_result_reg_hdr))
+
 #define IDLE_CHK_MAX_ENTRIES_SIZE      32
 
 /* The sizes and offsets below are specified in bits */
@@ -363,62 +406,92 @@ struct phy_defs {
 #define VFC_RAM_ADDR_ROW_OFFSET                2
 #define VFC_RAM_ADDR_ROW_SIZE          10
 #define VFC_RAM_RESP_STRUCT_SIZE       256
+
 #define VFC_CAM_CMD_DWORDS             CEIL_DWORDS(VFC_CAM_CMD_STRUCT_SIZE)
 #define VFC_CAM_ADDR_DWORDS            CEIL_DWORDS(VFC_CAM_ADDR_STRUCT_SIZE)
 #define VFC_CAM_RESP_DWORDS            CEIL_DWORDS(VFC_CAM_RESP_STRUCT_SIZE)
 #define VFC_RAM_CMD_DWORDS             VFC_CAM_CMD_DWORDS
 #define VFC_RAM_ADDR_DWORDS            CEIL_DWORDS(VFC_RAM_ADDR_STRUCT_SIZE)
 #define VFC_RAM_RESP_DWORDS            CEIL_DWORDS(VFC_RAM_RESP_STRUCT_SIZE)
+
 #define NUM_VFC_RAM_TYPES              4
+
 #define VFC_CAM_NUM_ROWS               512
+
 #define VFC_OPCODE_CAM_RD              14
 #define VFC_OPCODE_RAM_RD              0
+
 #define NUM_RSS_MEM_TYPES              5
+
 #define NUM_BIG_RAM_TYPES              3
 #define BIG_RAM_BLOCK_SIZE_BYTES       128
 #define BIG_RAM_BLOCK_SIZE_DWORDS \
        BYTES_TO_DWORDS(BIG_RAM_BLOCK_SIZE_BYTES)
+
 #define NUM_PHY_TBUS_ADDRESSES         2048
 #define PHY_DUMP_SIZE_DWORDS           (NUM_PHY_TBUS_ADDRESSES / 2)
+
 #define RESET_REG_UNRESET_OFFSET       4
+
 #define STALL_DELAY_MS                 500
+
 #define STATIC_DEBUG_LINE_DWORDS       9
-#define NUM_DBG_BUS_LINES              256
+
 #define NUM_COMMON_GLOBAL_PARAMS       8
+
 #define FW_IMG_MAIN                    1
-#define REG_FIFO_DEPTH_ELEMENTS                32
+
+#ifndef REG_FIFO_ELEMENT_DWORDS
 #define REG_FIFO_ELEMENT_DWORDS                2
+#endif
+#define REG_FIFO_DEPTH_ELEMENTS                32
 #define REG_FIFO_DEPTH_DWORDS \
        (REG_FIFO_ELEMENT_DWORDS * REG_FIFO_DEPTH_ELEMENTS)
-#define IGU_FIFO_DEPTH_ELEMENTS                64
+
+#ifndef IGU_FIFO_ELEMENT_DWORDS
 #define IGU_FIFO_ELEMENT_DWORDS                4
+#endif
+#define IGU_FIFO_DEPTH_ELEMENTS                64
 #define IGU_FIFO_DEPTH_DWORDS \
        (IGU_FIFO_ELEMENT_DWORDS * IGU_FIFO_DEPTH_ELEMENTS)
-#define PROTECTION_OVERRIDE_DEPTH_ELEMENTS     20
+
+#ifndef PROTECTION_OVERRIDE_ELEMENT_DWORDS
 #define PROTECTION_OVERRIDE_ELEMENT_DWORDS     2
+#endif
+#define PROTECTION_OVERRIDE_DEPTH_ELEMENTS     20
 #define PROTECTION_OVERRIDE_DEPTH_DWORDS \
        (PROTECTION_OVERRIDE_DEPTH_ELEMENTS * \
         PROTECTION_OVERRIDE_ELEMENT_DWORDS)
+
 #define MCP_SPAD_TRACE_OFFSIZE_ADDR \
        (MCP_REG_SCRATCH + \
         offsetof(struct static_init, sections[SPAD_SECTION_TRACE]))
-#define MCP_TRACE_META_IMAGE_SIGNATURE  0x669955aa
+
 #define EMPTY_FW_VERSION_STR           "???_???_???_???"
 #define EMPTY_FW_IMAGE_STR             "???????????????"
 
 /***************************** Constant Arrays *******************************/
 
+struct dbg_array {
+       const u32 *ptr;
+       u32 size_in_dwords;
+};
+
 /* Debug arrays */
-static struct dbg_array s_dbg_arrays[MAX_BIN_DBG_BUFFER_TYPE] = { {0} };
+static struct dbg_array s_dbg_arrays[MAX_BIN_DBG_BUFFER_TYPE] = { {NULL} };
 
 /* Chip constant definitions array */
 static struct chip_defs s_chip_defs[MAX_CHIP_IDS] = {
-       { "bb_b0",
-         { {MAX_NUM_PORTS_BB, MAX_NUM_PFS_BB, MAX_NUM_VFS_BB}, {0, 0, 0},
-           {0, 0, 0}, {0, 0, 0} } },
-       { "k2",
-         { {MAX_NUM_PORTS_K2, MAX_NUM_PFS_K2, MAX_NUM_VFS_K2}, {0, 0, 0},
-           {0, 0, 0}, {0, 0, 0} } }
+       { "bb",
+         {{MAX_NUM_PORTS_BB, MAX_NUM_PFS_BB, MAX_NUM_VFS_BB},
+          {0, 0, 0},
+          {0, 0, 0},
+          {0, 0, 0} } },
+       { "ah",
+         {{MAX_NUM_PORTS_K2, MAX_NUM_PFS_K2, MAX_NUM_VFS_K2},
+          {0, 0, 0},
+          {0, 0, 0},
+          {0, 0, 0} } }
 };
 
 /* Storm constant definitions array */
@@ -427,69 +500,74 @@ static struct storm_defs s_storm_defs[] = {
        {'T', BLOCK_TSEM,
         {DBG_BUS_CLIENT_RBCT, DBG_BUS_CLIENT_RBCT}, true,
         TSEM_REG_FAST_MEMORY,
-        TSEM_REG_DBG_FRAME_MODE, TSEM_REG_SLOW_DBG_ACTIVE,
-        TSEM_REG_SLOW_DBG_MODE, TSEM_REG_DBG_MODE1_CFG,
-        TSEM_REG_SYNC_DBG_EMPTY, TSEM_REG_SLOW_DBG_EMPTY,
+        TSEM_REG_DBG_FRAME_MODE_BB_K2, TSEM_REG_SLOW_DBG_ACTIVE_BB_K2,
+        TSEM_REG_SLOW_DBG_MODE_BB_K2, TSEM_REG_DBG_MODE1_CFG_BB_K2,
+        TSEM_REG_SYNC_DBG_EMPTY, TSEM_REG_SLOW_DBG_EMPTY_BB_K2,
         TCM_REG_CTX_RBC_ACCS,
         4, TCM_REG_AGG_CON_CTX,
         16, TCM_REG_SM_CON_CTX,
         2, TCM_REG_AGG_TASK_CTX,
         4, TCM_REG_SM_TASK_CTX},
+
        /* Mstorm */
        {'M', BLOCK_MSEM,
         {DBG_BUS_CLIENT_RBCT, DBG_BUS_CLIENT_RBCM}, false,
         MSEM_REG_FAST_MEMORY,
-        MSEM_REG_DBG_FRAME_MODE, MSEM_REG_SLOW_DBG_ACTIVE,
-        MSEM_REG_SLOW_DBG_MODE, MSEM_REG_DBG_MODE1_CFG,
-        MSEM_REG_SYNC_DBG_EMPTY, MSEM_REG_SLOW_DBG_EMPTY,
+        MSEM_REG_DBG_FRAME_MODE_BB_K2, MSEM_REG_SLOW_DBG_ACTIVE_BB_K2,
+        MSEM_REG_SLOW_DBG_MODE_BB_K2, MSEM_REG_DBG_MODE1_CFG_BB_K2,
+        MSEM_REG_SYNC_DBG_EMPTY, MSEM_REG_SLOW_DBG_EMPTY_BB_K2,
         MCM_REG_CTX_RBC_ACCS,
         1, MCM_REG_AGG_CON_CTX,
         10, MCM_REG_SM_CON_CTX,
         2, MCM_REG_AGG_TASK_CTX,
         7, MCM_REG_SM_TASK_CTX},
+
        /* Ustorm */
        {'U', BLOCK_USEM,
         {DBG_BUS_CLIENT_RBCU, DBG_BUS_CLIENT_RBCU}, false,
         USEM_REG_FAST_MEMORY,
-        USEM_REG_DBG_FRAME_MODE, USEM_REG_SLOW_DBG_ACTIVE,
-        USEM_REG_SLOW_DBG_MODE, USEM_REG_DBG_MODE1_CFG,
-        USEM_REG_SYNC_DBG_EMPTY, USEM_REG_SLOW_DBG_EMPTY,
+        USEM_REG_DBG_FRAME_MODE_BB_K2, USEM_REG_SLOW_DBG_ACTIVE_BB_K2,
+        USEM_REG_SLOW_DBG_MODE_BB_K2, USEM_REG_DBG_MODE1_CFG_BB_K2,
+        USEM_REG_SYNC_DBG_EMPTY, USEM_REG_SLOW_DBG_EMPTY_BB_K2,
         UCM_REG_CTX_RBC_ACCS,
         2, UCM_REG_AGG_CON_CTX,
         13, UCM_REG_SM_CON_CTX,
         3, UCM_REG_AGG_TASK_CTX,
         3, UCM_REG_SM_TASK_CTX},
+
        /* Xstorm */
        {'X', BLOCK_XSEM,
         {DBG_BUS_CLIENT_RBCX, DBG_BUS_CLIENT_RBCX}, false,
         XSEM_REG_FAST_MEMORY,
-        XSEM_REG_DBG_FRAME_MODE, XSEM_REG_SLOW_DBG_ACTIVE,
-        XSEM_REG_SLOW_DBG_MODE, XSEM_REG_DBG_MODE1_CFG,
-        XSEM_REG_SYNC_DBG_EMPTY, XSEM_REG_SLOW_DBG_EMPTY,
+        XSEM_REG_DBG_FRAME_MODE_BB_K2, XSEM_REG_SLOW_DBG_ACTIVE_BB_K2,
+        XSEM_REG_SLOW_DBG_MODE_BB_K2, XSEM_REG_DBG_MODE1_CFG_BB_K2,
+        XSEM_REG_SYNC_DBG_EMPTY, XSEM_REG_SLOW_DBG_EMPTY_BB_K2,
         XCM_REG_CTX_RBC_ACCS,
         9, XCM_REG_AGG_CON_CTX,
         15, XCM_REG_SM_CON_CTX,
         0, 0,
         0, 0},
+
        /* Ystorm */
        {'Y', BLOCK_YSEM,
         {DBG_BUS_CLIENT_RBCX, DBG_BUS_CLIENT_RBCY}, false,
         YSEM_REG_FAST_MEMORY,
-        YSEM_REG_DBG_FRAME_MODE, YSEM_REG_SLOW_DBG_ACTIVE,
-        YSEM_REG_SLOW_DBG_MODE, YSEM_REG_DBG_MODE1_CFG,
-        YSEM_REG_SYNC_DBG_EMPTY, TSEM_REG_SLOW_DBG_EMPTY,
+        YSEM_REG_DBG_FRAME_MODE_BB_K2, YSEM_REG_SLOW_DBG_ACTIVE_BB_K2,
+        YSEM_REG_SLOW_DBG_MODE_BB_K2, YSEM_REG_DBG_MODE1_CFG_BB_K2,
+        YSEM_REG_SYNC_DBG_EMPTY, TSEM_REG_SLOW_DBG_EMPTY_BB_K2,
         YCM_REG_CTX_RBC_ACCS,
         2, YCM_REG_AGG_CON_CTX,
         3, YCM_REG_SM_CON_CTX,
         2, YCM_REG_AGG_TASK_CTX,
         12, YCM_REG_SM_TASK_CTX},
+
        /* Pstorm */
        {'P', BLOCK_PSEM,
         {DBG_BUS_CLIENT_RBCS, DBG_BUS_CLIENT_RBCS}, true,
         PSEM_REG_FAST_MEMORY,
-        PSEM_REG_DBG_FRAME_MODE, PSEM_REG_SLOW_DBG_ACTIVE,
-        PSEM_REG_SLOW_DBG_MODE, PSEM_REG_DBG_MODE1_CFG,
-        PSEM_REG_SYNC_DBG_EMPTY, PSEM_REG_SLOW_DBG_EMPTY,
+        PSEM_REG_DBG_FRAME_MODE_BB_K2, PSEM_REG_SLOW_DBG_ACTIVE_BB_K2,
+        PSEM_REG_SLOW_DBG_MODE_BB_K2, PSEM_REG_DBG_MODE1_CFG_BB_K2,
+        PSEM_REG_SYNC_DBG_EMPTY, PSEM_REG_SLOW_DBG_EMPTY_BB_K2,
         PCM_REG_CTX_RBC_ACCS,
         0, 0,
         10, PCM_REG_SM_CON_CTX,
@@ -498,6 +576,7 @@ static struct storm_defs s_storm_defs[] = {
 };
 
 /* Block definitions array */
+
 static struct block_defs block_grc_defs = {
        "grc",
        {true, true}, false, 0,
@@ -587,9 +666,11 @@ static struct block_defs block_pcie_defs = {
        "pcie",
        {false, true}, false, 0,
        {MAX_DBG_BUS_CLIENTS, DBG_BUS_CLIENT_RBCH},
-       PCIE_REG_DBG_COMMON_SELECT, PCIE_REG_DBG_COMMON_DWORD_ENABLE,
-       PCIE_REG_DBG_COMMON_SHIFT, PCIE_REG_DBG_COMMON_FORCE_VALID,
-       PCIE_REG_DBG_COMMON_FORCE_FRAME,
+       PCIE_REG_DBG_COMMON_SELECT_K2,
+       PCIE_REG_DBG_COMMON_DWORD_ENABLE_K2,
+       PCIE_REG_DBG_COMMON_SHIFT_K2,
+       PCIE_REG_DBG_COMMON_FORCE_VALID_K2,
+       PCIE_REG_DBG_COMMON_FORCE_FRAME_K2,
        false, false, MAX_DBG_RESET_REGS, 0
 };
 
@@ -691,9 +772,9 @@ static struct block_defs block_pglcs_defs = {
        "pglcs",
        {false, true}, false, 0,
        {MAX_DBG_BUS_CLIENTS, DBG_BUS_CLIENT_RBCH},
-       PGLCS_REG_DBG_SELECT, PGLCS_REG_DBG_DWORD_ENABLE,
-       PGLCS_REG_DBG_SHIFT, PGLCS_REG_DBG_FORCE_VALID,
-       PGLCS_REG_DBG_FORCE_FRAME,
+       PGLCS_REG_DBG_SELECT_K2, PGLCS_REG_DBG_DWORD_ENABLE_K2,
+       PGLCS_REG_DBG_SHIFT_K2, PGLCS_REG_DBG_FORCE_VALID_K2,
+       PGLCS_REG_DBG_FORCE_FRAME_K2,
        true, false, DBG_RESET_REG_MISCS_PL_HV, 2
 };
 
@@ -991,10 +1072,11 @@ static struct block_defs block_yuld_defs = {
        "yuld",
        {true, true}, false, 0,
        {DBG_BUS_CLIENT_RBCU, DBG_BUS_CLIENT_RBCU},
-       YULD_REG_DBG_SELECT, YULD_REG_DBG_DWORD_ENABLE,
-       YULD_REG_DBG_SHIFT, YULD_REG_DBG_FORCE_VALID,
-       YULD_REG_DBG_FORCE_FRAME,
-       true, true, DBG_RESET_REG_MISC_PL_PDA_VMAIN_2, 15
+       YULD_REG_DBG_SELECT_BB_K2, YULD_REG_DBG_DWORD_ENABLE_BB_K2,
+       YULD_REG_DBG_SHIFT_BB_K2, YULD_REG_DBG_FORCE_VALID_BB_K2,
+       YULD_REG_DBG_FORCE_FRAME_BB_K2,
+       true, true, DBG_RESET_REG_MISC_PL_PDA_VMAIN_2,
+       15
 };
 
 static struct block_defs block_xyld_defs = {
@@ -1143,9 +1225,9 @@ static struct block_defs block_umac_defs = {
        "umac",
        {false, true}, false, 0,
        {MAX_DBG_BUS_CLIENTS, DBG_BUS_CLIENT_RBCZ},
-       UMAC_REG_DBG_SELECT, UMAC_REG_DBG_DWORD_ENABLE,
-       UMAC_REG_DBG_SHIFT, UMAC_REG_DBG_FORCE_VALID,
-       UMAC_REG_DBG_FORCE_FRAME,
+       UMAC_REG_DBG_SELECT_K2, UMAC_REG_DBG_DWORD_ENABLE_K2,
+       UMAC_REG_DBG_SHIFT_K2, UMAC_REG_DBG_FORCE_VALID_K2,
+       UMAC_REG_DBG_FORCE_FRAME_K2,
        true, false, DBG_RESET_REG_MISCS_PL_HV, 6
 };
 
@@ -1177,9 +1259,9 @@ static struct block_defs block_wol_defs = {
        "wol",
        {false, true}, false, 0,
        {MAX_DBG_BUS_CLIENTS, DBG_BUS_CLIENT_RBCZ},
-       WOL_REG_DBG_SELECT, WOL_REG_DBG_DWORD_ENABLE,
-       WOL_REG_DBG_SHIFT, WOL_REG_DBG_FORCE_VALID,
-       WOL_REG_DBG_FORCE_FRAME,
+       WOL_REG_DBG_SELECT_K2, WOL_REG_DBG_DWORD_ENABLE_K2,
+       WOL_REG_DBG_SHIFT_K2, WOL_REG_DBG_FORCE_VALID_K2,
+       WOL_REG_DBG_FORCE_FRAME_K2,
        true, true, DBG_RESET_REG_MISC_PL_PDA_VAUX, 7
 };
 
@@ -1187,9 +1269,9 @@ static struct block_defs block_bmbn_defs = {
        "bmbn",
        {false, true}, false, 0,
        {MAX_DBG_BUS_CLIENTS, DBG_BUS_CLIENT_RBCB},
-       BMBN_REG_DBG_SELECT, BMBN_REG_DBG_DWORD_ENABLE,
-       BMBN_REG_DBG_SHIFT, BMBN_REG_DBG_FORCE_VALID,
-       BMBN_REG_DBG_FORCE_FRAME,
+       BMBN_REG_DBG_SELECT_K2, BMBN_REG_DBG_DWORD_ENABLE_K2,
+       BMBN_REG_DBG_SHIFT_K2, BMBN_REG_DBG_FORCE_VALID_K2,
+       BMBN_REG_DBG_FORCE_FRAME_K2,
        false, false, MAX_DBG_RESET_REGS, 0
 };
 
@@ -1204,9 +1286,9 @@ static struct block_defs block_nwm_defs = {
        "nwm",
        {false, true}, false, 0,
        {MAX_DBG_BUS_CLIENTS, DBG_BUS_CLIENT_RBCW},
-       NWM_REG_DBG_SELECT, NWM_REG_DBG_DWORD_ENABLE,
-       NWM_REG_DBG_SHIFT, NWM_REG_DBG_FORCE_VALID,
-       NWM_REG_DBG_FORCE_FRAME,
+       NWM_REG_DBG_SELECT_K2, NWM_REG_DBG_DWORD_ENABLE_K2,
+       NWM_REG_DBG_SHIFT_K2, NWM_REG_DBG_FORCE_VALID_K2,
+       NWM_REG_DBG_FORCE_FRAME_K2,
        true, false, DBG_RESET_REG_MISCS_PL_HV_2, 0
 };
 
@@ -1214,9 +1296,9 @@ static struct block_defs block_nws_defs = {
        "nws",
        {false, true}, false, 0,
        {MAX_DBG_BUS_CLIENTS, DBG_BUS_CLIENT_RBCW},
-       NWS_REG_DBG_SELECT, NWS_REG_DBG_DWORD_ENABLE,
-       NWS_REG_DBG_SHIFT, NWS_REG_DBG_FORCE_VALID,
-       NWS_REG_DBG_FORCE_FRAME,
+       NWS_REG_DBG_SELECT_K2, NWS_REG_DBG_DWORD_ENABLE_K2,
+       NWS_REG_DBG_SHIFT_K2, NWS_REG_DBG_FORCE_VALID_K2,
+       NWS_REG_DBG_FORCE_FRAME_K2,
        true, false, DBG_RESET_REG_MISCS_PL_HV, 12
 };
 
@@ -1224,9 +1306,9 @@ static struct block_defs block_ms_defs = {
        "ms",
        {false, true}, false, 0,
        {MAX_DBG_BUS_CLIENTS, DBG_BUS_CLIENT_RBCZ},
-       MS_REG_DBG_SELECT, MS_REG_DBG_DWORD_ENABLE,
-       MS_REG_DBG_SHIFT, MS_REG_DBG_FORCE_VALID,
-       MS_REG_DBG_FORCE_FRAME,
+       MS_REG_DBG_SELECT_K2, MS_REG_DBG_DWORD_ENABLE_K2,
+       MS_REG_DBG_SHIFT_K2, MS_REG_DBG_FORCE_VALID_K2,
+       MS_REG_DBG_FORCE_FRAME_K2,
        true, false, DBG_RESET_REG_MISCS_PL_HV, 13
 };
 
@@ -1234,9 +1316,11 @@ static struct block_defs block_phy_pcie_defs = {
        "phy_pcie",
        {false, true}, false, 0,
        {MAX_DBG_BUS_CLIENTS, DBG_BUS_CLIENT_RBCH},
-       PCIE_REG_DBG_COMMON_SELECT, PCIE_REG_DBG_COMMON_DWORD_ENABLE,
-       PCIE_REG_DBG_COMMON_SHIFT, PCIE_REG_DBG_COMMON_FORCE_VALID,
-       PCIE_REG_DBG_COMMON_FORCE_FRAME,
+       PCIE_REG_DBG_COMMON_SELECT_K2,
+       PCIE_REG_DBG_COMMON_DWORD_ENABLE_K2,
+       PCIE_REG_DBG_COMMON_SHIFT_K2,
+       PCIE_REG_DBG_COMMON_FORCE_VALID_K2,
+       PCIE_REG_DBG_COMMON_FORCE_FRAME_K2,
        false, false, MAX_DBG_RESET_REGS, 0
 };
 
@@ -1261,6 +1345,13 @@ static struct block_defs block_rgfs_defs = {
        false, false, MAX_DBG_RESET_REGS, 0
 };
 
+static struct block_defs block_rgsrc_defs = {
+       "rgsrc", {false, false}, false, 0,
+       {MAX_DBG_BUS_CLIENTS, MAX_DBG_BUS_CLIENTS},
+       0, 0, 0, 0, 0,
+       false, false, MAX_DBG_RESET_REGS, 0
+};
+
 static struct block_defs block_tgfs_defs = {
        "tgfs", {false, false}, false, 0,
        {MAX_DBG_BUS_CLIENTS, MAX_DBG_BUS_CLIENTS},
@@ -1268,6 +1359,13 @@ static struct block_defs block_tgfs_defs = {
        false, false, MAX_DBG_RESET_REGS, 0
 };
 
+static struct block_defs block_tgsrc_defs = {
+       "tgsrc", {false, false}, false, 0,
+       {MAX_DBG_BUS_CLIENTS, MAX_DBG_BUS_CLIENTS},
+       0, 0, 0, 0, 0,
+       false, false, MAX_DBG_RESET_REGS, 0
+};
+
 static struct block_defs block_ptld_defs = {
        "ptld", {false, false}, false, 0,
        {MAX_DBG_BUS_CLIENTS, MAX_DBG_BUS_CLIENTS},
@@ -1350,6 +1448,8 @@ static struct block_defs *s_block_defs[MAX_BLOCK_ID] = {
        &block_muld_defs,
        &block_yuld_defs,
        &block_xyld_defs,
+       &block_ptld_defs,
+       &block_ypld_defs,
        &block_prm_defs,
        &block_pbf_pb1_defs,
        &block_pbf_pb2_defs,
@@ -1363,6 +1463,10 @@ static struct block_defs *s_block_defs[MAX_BLOCK_ID] = {
        &block_tcfc_defs,
        &block_igu_defs,
        &block_cau_defs,
+       &block_rgfs_defs,
+       &block_rgsrc_defs,
+       &block_tgfs_defs,
+       &block_tgsrc_defs,
        &block_umac_defs,
        &block_xmac_defs,
        &block_dbg_defs,
@@ -1376,10 +1480,6 @@ static struct block_defs *s_block_defs[MAX_BLOCK_ID] = {
        &block_phy_pcie_defs,
        &block_led_defs,
        &block_avs_wrap_defs,
-       &block_rgfs_defs,
-       &block_tgfs_defs,
-       &block_ptld_defs,
-       &block_ypld_defs,
        &block_misc_aeu_defs,
        &block_bar0_map_defs,
 };
@@ -1392,66 +1492,151 @@ static struct platform_defs s_platform_defs[] = {
 };
 
 static struct grc_param_defs s_grc_param_defs[] = {
-       {{1, 1}, 0, 1, false, 1, 1},    /* DBG_GRC_PARAM_DUMP_TSTORM */
-       {{1, 1}, 0, 1, false, 1, 1},    /* DBG_GRC_PARAM_DUMP_MSTORM */
-       {{1, 1}, 0, 1, false, 1, 1},    /* DBG_GRC_PARAM_DUMP_USTORM */
-       {{1, 1}, 0, 1, false, 1, 1},    /* DBG_GRC_PARAM_DUMP_XSTORM */
-       {{1, 1}, 0, 1, false, 1, 1},    /* DBG_GRC_PARAM_DUMP_YSTORM */
-       {{1, 1}, 0, 1, false, 1, 1},    /* DBG_GRC_PARAM_DUMP_PSTORM */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_REGS */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_RAM */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_PBUF */
-       {{0, 0}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_IOR */
-       {{0, 0}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_VFC */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_CM_CTX */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_ILT */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_RSS */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_CAU */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_QM */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_MCP */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_RESERVED */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_CFC */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_IGU */
-       {{0, 0}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_BRB */
-       {{0, 0}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_BTB */
-       {{0, 0}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_BMB */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_NIG */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_MULD */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_PRS */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_DMAE */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_TM */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_SDM */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_DIF */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_STATIC */
-       {{0, 0}, 0, 1, false, 0, 0},    /* DBG_GRC_PARAM_UNSTALL */
+       /* DBG_GRC_PARAM_DUMP_TSTORM */
+       {{1, 1}, 0, 1, false, 1, 1},
+
+       /* DBG_GRC_PARAM_DUMP_MSTORM */
+       {{1, 1}, 0, 1, false, 1, 1},
+
+       /* DBG_GRC_PARAM_DUMP_USTORM */
+       {{1, 1}, 0, 1, false, 1, 1},
+
+       /* DBG_GRC_PARAM_DUMP_XSTORM */
+       {{1, 1}, 0, 1, false, 1, 1},
+
+       /* DBG_GRC_PARAM_DUMP_YSTORM */
+       {{1, 1}, 0, 1, false, 1, 1},
+
+       /* DBG_GRC_PARAM_DUMP_PSTORM */
+       {{1, 1}, 0, 1, false, 1, 1},
+
+       /* DBG_GRC_PARAM_DUMP_REGS */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_RAM */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_PBUF */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_IOR */
+       {{0, 0}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_VFC */
+       {{0, 0}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_CM_CTX */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_ILT */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_RSS */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_CAU */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_QM */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_MCP */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_RESERVED */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_CFC */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_IGU */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_BRB */
+       {{0, 0}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_BTB */
+       {{0, 0}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_BMB */
+       {{0, 0}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_NIG */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_MULD */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_PRS */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_DMAE */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_TM */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_SDM */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_DIF */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_STATIC */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_UNSTALL */
+       {{0, 0}, 0, 1, false, 0, 0},
+
+       /* DBG_GRC_PARAM_NUM_LCIDS */
        {{MAX_LCIDS, MAX_LCIDS}, 1, MAX_LCIDS, false, MAX_LCIDS,
-        MAX_LCIDS},                    /* DBG_GRC_PARAM_NUM_LCIDS */
+        MAX_LCIDS},
+
+       /* DBG_GRC_PARAM_NUM_LTIDS */
        {{MAX_LTIDS, MAX_LTIDS}, 1, MAX_LTIDS, false, MAX_LTIDS,
-        MAX_LTIDS},                    /* DBG_GRC_PARAM_NUM_LTIDS */
-       {{0, 0}, 0, 1, true, 0, 0},     /* DBG_GRC_PARAM_EXCLUDE_ALL */
-       {{0, 0}, 0, 1, true, 0, 0},     /* DBG_GRC_PARAM_CRASH */
-       {{0, 0}, 0, 1, false, 1, 0},    /* DBG_GRC_PARAM_PARITY_SAFE */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_CM */
-       {{1, 1}, 0, 1, false, 0, 1},    /* DBG_GRC_PARAM_DUMP_PHY */
-       {{0, 0}, 0, 1, false, 0, 0},    /* DBG_GRC_PARAM_NO_MCP */
-       {{0, 0}, 0, 1, false, 0, 0}     /* DBG_GRC_PARAM_NO_FW_VER */
+        MAX_LTIDS},
+
+       /* DBG_GRC_PARAM_EXCLUDE_ALL */
+       {{0, 0}, 0, 1, true, 0, 0},
+
+       /* DBG_GRC_PARAM_CRASH */
+       {{0, 0}, 0, 1, true, 0, 0},
+
+       /* DBG_GRC_PARAM_PARITY_SAFE */
+       {{0, 0}, 0, 1, false, 1, 0},
+
+       /* DBG_GRC_PARAM_DUMP_CM */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_DUMP_PHY */
+       {{1, 1}, 0, 1, false, 0, 1},
+
+       /* DBG_GRC_PARAM_NO_MCP */
+       {{0, 0}, 0, 1, false, 0, 0},
+
+       /* DBG_GRC_PARAM_NO_FW_VER */
+       {{0, 0}, 0, 1, false, 0, 0}
 };
 
 static struct rss_mem_defs s_rss_mem_defs[] = {
        { "rss_mem_cid", "rss_cid", 0,
          {256, 320},
          {32, 32} },
+
        { "rss_mem_key_msb", "rss_key", 1024,
          {128, 208},
          {256, 256} },
+
        { "rss_mem_key_lsb", "rss_key", 2048,
          {128, 208},
          {64, 64} },
+
        { "rss_mem_info", "rss_info", 3072,
          {128, 208},
          {16, 16} },
+
        { "rss_mem_ind", "rss_ind", 4096,
-         {(128 * 128), (128 * 208)},
+         {16384, 26624},
          {16, 16} }
 };
 
@@ -1466,50 +1651,71 @@ static struct big_ram_defs s_big_ram_defs[] = {
        { "BRB", MEM_GROUP_BRB_MEM, MEM_GROUP_BRB_RAM, DBG_GRC_PARAM_DUMP_BRB,
          BRB_REG_BIG_RAM_ADDRESS, BRB_REG_BIG_RAM_DATA,
          {4800, 5632} },
+
        { "BTB", MEM_GROUP_BTB_MEM, MEM_GROUP_BTB_RAM, DBG_GRC_PARAM_DUMP_BTB,
          BTB_REG_BIG_RAM_ADDRESS, BTB_REG_BIG_RAM_DATA,
          {2880, 3680} },
+
        { "BMB", MEM_GROUP_BMB_MEM, MEM_GROUP_BMB_RAM, DBG_GRC_PARAM_DUMP_BMB,
          BMB_REG_BIG_RAM_ADDRESS, BMB_REG_BIG_RAM_DATA,
          {1152, 1152} }
 };
 
 static struct reset_reg_defs s_reset_regs_defs[] = {
+       /* DBG_RESET_REG_MISCS_PL_UA */
        { MISCS_REG_RESET_PL_UA, 0x0,
-         {true, true} },               /* DBG_RESET_REG_MISCS_PL_UA */
+         {true, true} },
+
+       /* DBG_RESET_REG_MISCS_PL_HV */
        { MISCS_REG_RESET_PL_HV, 0x0,
-         {true, true} },               /* DBG_RESET_REG_MISCS_PL_HV */
-       { MISCS_REG_RESET_PL_HV_2, 0x0,
-         {false, true} },      /* DBG_RESET_REG_MISCS_PL_HV_2 */
+         {true, true} },
+
+       /* DBG_RESET_REG_MISCS_PL_HV_2 */
+       { MISCS_REG_RESET_PL_HV_2_K2, 0x0,
+         {false, true} },
+
+       /* DBG_RESET_REG_MISC_PL_UA */
        { MISC_REG_RESET_PL_UA, 0x0,
-         {true, true} },               /* DBG_RESET_REG_MISC_PL_UA */
+         {true, true} },
+
+       /* DBG_RESET_REG_MISC_PL_HV */
        { MISC_REG_RESET_PL_HV, 0x0,
-         {true, true} },               /* DBG_RESET_REG_MISC_PL_HV */
+         {true, true} },
+
+       /* DBG_RESET_REG_MISC_PL_PDA_VMAIN_1 */
        { MISC_REG_RESET_PL_PDA_VMAIN_1, 0x4404040,
-         {true, true} },               /* DBG_RESET_REG_MISC_PL_PDA_VMAIN_1 */
+         {true, true} },
+
+       /* DBG_RESET_REG_MISC_PL_PDA_VMAIN_2 */
        { MISC_REG_RESET_PL_PDA_VMAIN_2, 0x7c00007,
-         {true, true} },               /* DBG_RESET_REG_MISC_PL_PDA_VMAIN_2 */
+         {true, true} },
+
+       /* DBG_RESET_REG_MISC_PL_PDA_VAUX */
        { MISC_REG_RESET_PL_PDA_VAUX, 0x2,
-         {true, true} },               /* DBG_RESET_REG_MISC_PL_PDA_VAUX */
+         {true, true} },
 };
 
 static struct phy_defs s_phy_defs[] = {
-       {"nw_phy", NWS_REG_NWS_CMU, PHY_NW_IP_REG_PHY0_TOP_TBUS_ADDR_7_0,
-        PHY_NW_IP_REG_PHY0_TOP_TBUS_ADDR_15_8,
-        PHY_NW_IP_REG_PHY0_TOP_TBUS_DATA_7_0,
-        PHY_NW_IP_REG_PHY0_TOP_TBUS_DATA_11_8},
-       {"sgmii_phy", MS_REG_MS_CMU, PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X132,
-        PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X133,
-        PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X130,
-        PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X131},
-       {"pcie_phy0", PHY_PCIE_REG_PHY0, PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X132,
-        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X133,
-        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X130,
-        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X131},
-       {"pcie_phy1", PHY_PCIE_REG_PHY1, PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X132,
-        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X133,
-        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X130,
-        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X131},
+       {"nw_phy", NWS_REG_NWS_CMU_K2,
+        PHY_NW_IP_REG_PHY0_TOP_TBUS_ADDR_7_0_K2,
+        PHY_NW_IP_REG_PHY0_TOP_TBUS_ADDR_15_8_K2,
+        PHY_NW_IP_REG_PHY0_TOP_TBUS_DATA_7_0_K2,
+        PHY_NW_IP_REG_PHY0_TOP_TBUS_DATA_11_8_K2},
+       {"sgmii_phy", MS_REG_MS_CMU_K2,
+        PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X132_K2,
+        PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X133_K2,
+        PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X130_K2,
+        PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X131_K2},
+       {"pcie_phy0", PHY_PCIE_REG_PHY0_K2,
+        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X132_K2,
+        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X133_K2,
+        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X130_K2,
+        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X131_K2},
+       {"pcie_phy1", PHY_PCIE_REG_PHY1_K2,
+        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X132_K2,
+        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X133_K2,
+        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X130_K2,
+        PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X131_K2},
 };
 
 /**************************** Private Functions ******************************/
@@ -1556,7 +1762,7 @@ static enum dbg_status qed_dbg_dev_init(struct qed_hwfn *p_hwfn,
                dev_data->chip_id = CHIP_K2;
                dev_data->mode_enable[MODE_K2] = 1;
        } else if (QED_IS_BB_B0(p_hwfn->cdev)) {
-               dev_data->chip_id = CHIP_BB_B0;
+               dev_data->chip_id = CHIP_BB;
                dev_data->mode_enable[MODE_BB] = 1;
        } else {
                return DBG_STATUS_UNKNOWN_CHIP;
@@ -1569,9 +1775,20 @@ static enum dbg_status qed_dbg_dev_init(struct qed_hwfn *p_hwfn,
        qed_dbg_grc_init_params(p_hwfn);
 
        dev_data->initialized = true;
+
        return DBG_STATUS_OK;
 }
 
+static struct dbg_bus_block *get_dbg_bus_block_desc(struct qed_hwfn *p_hwfn,
+                                                   enum block_id block_id)
+{
+       struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
+
+       return (struct dbg_bus_block *)&dbg_bus_blocks[block_id *
+                                                      MAX_CHIP_IDS +
+                                                      dev_data->chip_id];
+}
+
 /* Reads the FW info structure for the specified Storm from the chip,
  * and writes it to the specified fw_info pointer.
  */
@@ -1579,25 +1796,28 @@ static void qed_read_fw_info(struct qed_hwfn *p_hwfn,
                             struct qed_ptt *p_ptt,
                             u8 storm_id, struct fw_info *fw_info)
 {
-       /* Read first the address that points to fw_info location.
-        * The address is located in the last line of the Storm RAM.
-        */
-       u32 addr = s_storm_defs[storm_id].sem_fast_mem_addr +
-                  SEM_FAST_REG_INT_RAM +
-                  DWORDS_TO_BYTES(SEM_FAST_REG_INT_RAM_SIZE) -
-                  sizeof(struct fw_info_location);
+       struct storm_defs *storm = &s_storm_defs[storm_id];
        struct fw_info_location fw_info_location;
-       u32 *dest = (u32 *)&fw_info_location;
-       u32 i;
+       u32 addr, i, *dest;
 
        memset(&fw_info_location, 0, sizeof(fw_info_location));
        memset(fw_info, 0, sizeof(*fw_info));
+
+       /* Read first the address that points to fw_info location.
+        * The address is located in the last line of the Storm RAM.
+        */
+       addr = storm->sem_fast_mem_addr + SEM_FAST_REG_INT_RAM +
+              DWORDS_TO_BYTES(SEM_FAST_REG_INT_RAM_SIZE) -
+              sizeof(fw_info_location);
+       dest = (u32 *)&fw_info_location;
+
        for (i = 0; i < BYTES_TO_DWORDS(sizeof(fw_info_location));
             i++, addr += BYTES_IN_DWORD)
                dest[i] = qed_rd(p_hwfn, p_ptt, addr);
+
+       /* Read FW version info from Storm RAM */
        if (fw_info_location.size > 0 && fw_info_location.size <=
            sizeof(*fw_info)) {
-               /* Read FW version info from Storm RAM */
                addr = fw_info_location.grc_addr;
                dest = (u32 *)fw_info;
                for (i = 0; i < BYTES_TO_DWORDS(fw_info_location.size);
@@ -1606,27 +1826,30 @@ static void qed_read_fw_info(struct qed_hwfn *p_hwfn,
        }
 }
 
-/* Dumps the specified string to the specified buffer. Returns the dumped size
- * in bytes (actual length + 1 for the null character termination).
+/* Dumps the specified string to the specified buffer.
+ * Returns the dumped size in bytes.
  */
 static u32 qed_dump_str(char *dump_buf, bool dump, const char *str)
 {
        if (dump)
                strcpy(dump_buf, str);
+
        return (u32)strlen(str) + 1;
 }
 
-/* Dumps zeros to align the specified buffer to dwords. Returns the dumped size
- * in bytes.
+/* Dumps zeros to align the specified buffer to dwords.
+ * Returns the dumped size in bytes.
  */
 static u32 qed_dump_align(char *dump_buf, bool dump, u32 byte_offset)
 {
-       u8 offset_in_dword = (u8)(byte_offset & 0x3), align_size;
+       u8 offset_in_dword, align_size;
 
+       offset_in_dword = (u8)(byte_offset & 0x3);
        align_size = offset_in_dword ? BYTES_IN_DWORD - offset_in_dword : 0;
 
        if (dump && align_size)
                memset(dump_buf, 0, align_size);
+
        return align_size;
 }
 
@@ -1653,6 +1876,7 @@ static u32 qed_dump_str_param(u32 *dump_buf,
 
        /* Align buffer to next dword */
        offset += qed_dump_align(char_buf + offset, dump, offset);
+
        return BYTES_TO_DWORDS(offset);
 }
 
@@ -1681,6 +1905,7 @@ static u32 qed_dump_num_param(u32 *dump_buf,
        if (dump)
                *(dump_buf + offset) = param_val;
        offset++;
+
        return offset;
 }
 
@@ -1695,7 +1920,6 @@ static u32 qed_dump_fw_ver_param(struct qed_hwfn *p_hwfn,
        char fw_ver_str[16] = EMPTY_FW_VERSION_STR;
        char fw_img_str[16] = EMPTY_FW_IMAGE_STR;
        struct fw_info fw_info = { {0}, {0} };
-       int printed_chars;
        u32 offset = 0;
 
        if (dump && !qed_grc_get_param(p_hwfn, DBG_GRC_PARAM_NO_FW_VER)) {
@@ -1705,37 +1929,32 @@ static u32 qed_dump_fw_ver_param(struct qed_hwfn *p_hwfn,
 
                for (storm_id = 0; storm_id < MAX_DBG_STORMS && !found;
                     storm_id++) {
-                       /* Read FW version/image  */
-                       if (!dev_data->block_in_reset
-                           [s_storm_defs[storm_id].block_id]) {
-                               /* read FW info for the current Storm */
-                               qed_read_fw_info(p_hwfn,
-                                                p_ptt, storm_id, &fw_info);
-
-                               /* Create FW version/image strings */
-                               printed_chars =
-                                   snprintf(fw_ver_str,
-                                            sizeof(fw_ver_str),
-                                            "%d_%d_%d_%d",
-                                            fw_info.ver.num.major,
-                                            fw_info.ver.num.minor,
-                                            fw_info.ver.num.rev,
-                                            fw_info.ver.num.eng);
-                               if (printed_chars < 0 || printed_chars >=
-                                   sizeof(fw_ver_str))
-                                       DP_NOTICE(p_hwfn,
-                                                 "Unexpected debug error: invalid FW version string\n");
-                               switch (fw_info.ver.image_id) {
-                               case FW_IMG_MAIN:
-                                       strcpy(fw_img_str, "main");
-                                       break;
-                               default:
-                                       strcpy(fw_img_str, "unknown");
-                                       break;
-                               }
+                       struct storm_defs *storm = &s_storm_defs[storm_id];
+
+                       /* Read FW version/image */
+                       if (dev_data->block_in_reset[storm->block_id])
+                               continue;
 
-                               found = true;
+                       /* Read FW info for the current Storm */
+                       qed_read_fw_info(p_hwfn, p_ptt, storm_id, &fw_info);
+
+                       /* Create FW version/image strings */
+                       if (snprintf(fw_ver_str, sizeof(fw_ver_str),
+                                    "%d_%d_%d_%d", fw_info.ver.num.major,
+                                    fw_info.ver.num.minor, fw_info.ver.num.rev,
+                                    fw_info.ver.num.eng) < 0)
+                               DP_NOTICE(p_hwfn,
+                                         "Unexpected debug error: invalid FW version string\n");
+                       switch (fw_info.ver.image_id) {
+                       case FW_IMG_MAIN:
+                               strcpy(fw_img_str, "main");
+                               break;
+                       default:
+                               strcpy(fw_img_str, "unknown");
+                               break;
                        }
+
+                       found = true;
                }
        }
 
@@ -1747,6 +1966,7 @@ static u32 qed_dump_fw_ver_param(struct qed_hwfn *p_hwfn,
        offset += qed_dump_num_param(dump_buf + offset,
                                     dump,
                                     "fw-timestamp", fw_info.ver.timestamp);
+
        return offset;
 }
 
@@ -1759,17 +1979,18 @@ static u32 qed_dump_mfw_ver_param(struct qed_hwfn *p_hwfn,
 {
        char mfw_ver_str[16] = EMPTY_FW_VERSION_STR;
 
-       if (dump && !qed_grc_get_param(p_hwfn, DBG_GRC_PARAM_NO_FW_VER)) {
+       if (dump &&
+           !qed_grc_get_param(p_hwfn, DBG_GRC_PARAM_NO_FW_VER)) {
                u32 global_section_offsize, global_section_addr, mfw_ver;
                u32 public_data_addr, global_section_offsize_addr;
-               int printed_chars;
 
-               /* Find MCP public data GRC address.
-                * Needs to be ORed with MCP_REG_SCRATCH due to a HW bug.
+               /* Find MCP public data GRC address. Needs to be ORed with
+                * MCP_REG_SCRATCH due to a HW bug.
                 */
-               public_data_addr = qed_rd(p_hwfn, p_ptt,
+               public_data_addr = qed_rd(p_hwfn,
+                                         p_ptt,
                                          MISC_REG_SHARED_MEM_ADDR) |
-                                         MCP_REG_SCRATCH;
+                                  MCP_REG_SCRATCH;
 
                /* Find MCP public global section offset */
                global_section_offsize_addr = public_data_addr +
@@ -1778,9 +1999,9 @@ static u32 qed_dump_mfw_ver_param(struct qed_hwfn *p_hwfn,
                                              sizeof(offsize_t) * PUBLIC_GLOBAL;
                global_section_offsize = qed_rd(p_hwfn, p_ptt,
                                                global_section_offsize_addr);
-               global_section_addr = MCP_REG_SCRATCH +
-                                     (global_section_offsize &
-                                      OFFSIZE_OFFSET_MASK) * 4;
+               global_section_addr =
+                       MCP_REG_SCRATCH +
+                       (global_section_offsize & OFFSIZE_OFFSET_MASK) * 4;
 
                /* Read MFW version from MCP public global section */
                mfw_ver = qed_rd(p_hwfn, p_ptt,
@@ -1788,13 +2009,9 @@ static u32 qed_dump_mfw_ver_param(struct qed_hwfn *p_hwfn,
                                 offsetof(struct public_global, mfw_ver));
 
                /* Dump MFW version param */
-               printed_chars = snprintf(mfw_ver_str, sizeof(mfw_ver_str),
-                                        "%d_%d_%d_%d",
-                                        (u8) (mfw_ver >> 24),
-                                        (u8) (mfw_ver >> 16),
-                                        (u8) (mfw_ver >> 8),
-                                        (u8) mfw_ver);
-               if (printed_chars < 0 || printed_chars >= sizeof(mfw_ver_str))
+               if (snprintf(mfw_ver_str, sizeof(mfw_ver_str), "%d_%d_%d_%d",
+                            (u8)(mfw_ver >> 24), (u8)(mfw_ver >> 16),
+                            (u8)(mfw_ver >> 8), (u8)mfw_ver) < 0)
                        DP_NOTICE(p_hwfn,
                                  "Unexpected debug error: invalid MFW version string\n");
        }
@@ -1820,11 +2037,12 @@ static u32 qed_dump_common_global_params(struct qed_hwfn *p_hwfn,
                                         bool dump,
                                         u8 num_specific_global_params)
 {
-       u8 num_params = NUM_COMMON_GLOBAL_PARAMS + num_specific_global_params;
        struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
        u32 offset = 0;
+       u8 num_params;
 
-       /* Find platform string and dump global params section header */
+       /* Dump global params section header */
+       num_params = NUM_COMMON_GLOBAL_PARAMS + num_specific_global_params;
        offset += qed_dump_section_hdr(dump_buf + offset,
                                       dump, "global_params", num_params);
 
@@ -1846,25 +2064,29 @@ static u32 qed_dump_common_global_params(struct qed_hwfn *p_hwfn,
        offset +=
            qed_dump_num_param(dump_buf + offset, dump, "pci-func",
                               p_hwfn->abs_pf_id);
+
        return offset;
 }
 
-/* Writes the last section to the specified buffer at the given offset.
- * Returns the dumped size in dwords.
+/* Writes the "last" section (including CRC) to the specified buffer at the
+ * given offset. Returns the dumped size in dwords.
  */
-static u32 qed_dump_last_section(u32 *dump_buf, u32 offset, bool dump)
+static u32 qed_dump_last_section(struct qed_hwfn *p_hwfn,
+                                u32 *dump_buf, u32 offset, bool dump)
 {
-       u32 start_offset = offset, crc = ~0;
+       u32 start_offset = offset;
 
        /* Dump CRC section header */
        offset += qed_dump_section_hdr(dump_buf + offset, dump, "last", 0);
 
-       /* Calculate CRC32 and add it to the dword following the "last" section.
-        */
+       /* Calculate CRC32 and add it to the dword after the "last" section */
        if (dump)
-               *(dump_buf + offset) = ~crc32(crc, (u8 *)dump_buf,
+               *(dump_buf + offset) = ~crc32(0xffffffff,
+                                             (u8 *)dump_buf,
                                              DWORDS_TO_BYTES(offset));
+
        offset++;
+
        return offset - start_offset;
 }
 
@@ -1883,11 +2105,12 @@ static void qed_update_blocks_reset_state(struct qed_hwfn *p_hwfn,
                                            p_ptt, s_reset_regs_defs[i].addr);
 
        /* Check if blocks are in reset */
-       for (i = 0; i < MAX_BLOCK_ID; i++)
-               dev_data->block_in_reset[i] =
-                   s_block_defs[i]->has_reset_bit &&
-                   !(reg_val[s_block_defs[i]->reset_reg] &
-                     BIT(s_block_defs[i]->reset_bit_offset));
+       for (i = 0; i < MAX_BLOCK_ID; i++) {
+               struct block_defs *block = s_block_defs[i];
+
+               dev_data->block_in_reset[i] = block->has_reset_bit &&
+                   !(reg_val[block->reset_reg] & BIT(block->reset_bit_offset));
+       }
 }
 
 /* Enable / disable the Debug block */
@@ -1902,12 +2125,12 @@ static void qed_bus_reset_dbg_block(struct qed_hwfn *p_hwfn,
                                    struct qed_ptt *p_ptt)
 {
        u32 dbg_reset_reg_addr, old_reset_reg_val, new_reset_reg_val;
+       struct block_defs *dbg_block = s_block_defs[BLOCK_DBG];
 
-       dbg_reset_reg_addr =
-               s_reset_regs_defs[s_block_defs[BLOCK_DBG]->reset_reg].addr;
+       dbg_reset_reg_addr = s_reset_regs_defs[dbg_block->reset_reg].addr;
        old_reset_reg_val = qed_rd(p_hwfn, p_ptt, dbg_reset_reg_addr);
-       new_reset_reg_val = old_reset_reg_val &
-                           ~BIT(s_block_defs[BLOCK_DBG]->reset_bit_offset);
+       new_reset_reg_val =
+           old_reset_reg_val & ~BIT(dbg_block->reset_bit_offset);
 
        qed_wr(p_hwfn, p_ptt, dbg_reset_reg_addr, new_reset_reg_val);
        qed_wr(p_hwfn, p_ptt, dbg_reset_reg_addr, old_reset_reg_val);
@@ -1920,8 +2143,8 @@ static void qed_bus_set_framing_mode(struct qed_hwfn *p_hwfn,
        qed_wr(p_hwfn, p_ptt, DBG_REG_FRAMING_MODE, (u8)mode);
 }
 
-/* Enable / disable Debug Bus clients according to the specified mask.
- * (1 = enable, 0 = disable)
+/* Enable / disable Debug Bus clients according to the specified mask
+ * (1 = enable, 0 = disable).
  */
 static void qed_bus_enable_clients(struct qed_hwfn *p_hwfn,
                                   struct qed_ptt *p_ptt, u32 client_mask)
@@ -1931,10 +2154,14 @@ static void qed_bus_enable_clients(struct qed_hwfn *p_hwfn,
 
 static bool qed_is_mode_match(struct qed_hwfn *p_hwfn, u16 *modes_buf_offset)
 {
-       const u32 *ptr = s_dbg_arrays[BIN_BUF_DBG_MODE_TREE].ptr;
        struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
-       u8 tree_val = ((u8 *)ptr)[(*modes_buf_offset)++];
        bool arg1, arg2;
+       const u32 *ptr;
+       u8 tree_val;
+
+       /* Get next element from modes tree buffer */
+       ptr = s_dbg_arrays[BIN_BUF_DBG_MODE_TREE].ptr;
+       tree_val = ((u8 *)ptr)[(*modes_buf_offset)++];
 
        switch (tree_val) {
        case INIT_MODE_OP_NOT:
@@ -1974,75 +2201,81 @@ static bool qed_grc_is_storm_included(struct qed_hwfn *p_hwfn,
 static bool qed_grc_is_mem_included(struct qed_hwfn *p_hwfn,
                                    enum block_id block_id, u8 mem_group_id)
 {
+       struct block_defs *block = s_block_defs[block_id];
        u8 i;
 
        /* Check Storm match */
-       if (s_block_defs[block_id]->associated_to_storm &&
+       if (block->associated_to_storm &&
            !qed_grc_is_storm_included(p_hwfn,
-                       (enum dbg_storms)s_block_defs[block_id]->storm_id))
+                                      (enum dbg_storms)block->storm_id))
                return false;
 
-       for (i = 0; i < NUM_BIG_RAM_TYPES; i++)
-               if (mem_group_id == s_big_ram_defs[i].mem_group_id ||
-                   mem_group_id == s_big_ram_defs[i].ram_mem_group_id)
-                       return qed_grc_is_included(p_hwfn,
-                                                  s_big_ram_defs[i].grc_param);
-       if (mem_group_id == MEM_GROUP_PXP_ILT || mem_group_id ==
-           MEM_GROUP_PXP_MEM)
+       for (i = 0; i < NUM_BIG_RAM_TYPES; i++) {
+               struct big_ram_defs *big_ram = &s_big_ram_defs[i];
+
+               if (mem_group_id == big_ram->mem_group_id ||
+                   mem_group_id == big_ram->ram_mem_group_id)
+                       return qed_grc_is_included(p_hwfn, big_ram->grc_param);
+       }
+
+       switch (mem_group_id) {
+       case MEM_GROUP_PXP_ILT:
+       case MEM_GROUP_PXP_MEM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_PXP);
-       if (mem_group_id == MEM_GROUP_RAM)
+       case MEM_GROUP_RAM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_RAM);
-       if (mem_group_id == MEM_GROUP_PBUF)
+       case MEM_GROUP_PBUF:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_PBUF);
-       if (mem_group_id == MEM_GROUP_CAU_MEM ||
-           mem_group_id == MEM_GROUP_CAU_SB ||
-           mem_group_id == MEM_GROUP_CAU_PI)
+       case MEM_GROUP_CAU_MEM:
+       case MEM_GROUP_CAU_SB:
+       case MEM_GROUP_CAU_PI:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_CAU);
-       if (mem_group_id == MEM_GROUP_QM_MEM)
+       case MEM_GROUP_QM_MEM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_QM);
-       if (mem_group_id == MEM_GROUP_CONN_CFC_MEM ||
-           mem_group_id == MEM_GROUP_TASK_CFC_MEM)
+       case MEM_GROUP_CFC_MEM:
+       case MEM_GROUP_CONN_CFC_MEM:
+       case MEM_GROUP_TASK_CFC_MEM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_CFC);
-       if (mem_group_id == MEM_GROUP_IGU_MEM || mem_group_id ==
-           MEM_GROUP_IGU_MSIX)
+       case MEM_GROUP_IGU_MEM:
+       case MEM_GROUP_IGU_MSIX:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_IGU);
-       if (mem_group_id == MEM_GROUP_MULD_MEM)
+       case MEM_GROUP_MULD_MEM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_MULD);
-       if (mem_group_id == MEM_GROUP_PRS_MEM)
+       case MEM_GROUP_PRS_MEM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_PRS);
-       if (mem_group_id == MEM_GROUP_DMAE_MEM)
+       case MEM_GROUP_DMAE_MEM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_DMAE);
-       if (mem_group_id == MEM_GROUP_TM_MEM)
+       case MEM_GROUP_TM_MEM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_TM);
-       if (mem_group_id == MEM_GROUP_SDM_MEM)
+       case MEM_GROUP_SDM_MEM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_SDM);
-       if (mem_group_id == MEM_GROUP_TDIF_CTX || mem_group_id ==
-           MEM_GROUP_RDIF_CTX)
+       case MEM_GROUP_TDIF_CTX:
+       case MEM_GROUP_RDIF_CTX:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_DIF);
-       if (mem_group_id == MEM_GROUP_CM_MEM)
+       case MEM_GROUP_CM_MEM:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_CM);
-       if (mem_group_id == MEM_GROUP_IOR)
+       case MEM_GROUP_IOR:
                return qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_IOR);
-
-       return true;
+       default:
+               return true;
+       }
 }
 
 /* Stalls all Storms */
 static void qed_grc_stall_storms(struct qed_hwfn *p_hwfn,
                                 struct qed_ptt *p_ptt, bool stall)
 {
-       u8 reg_val = stall ? 1 : 0;
+       u32 reg_addr;
        u8 storm_id;
 
        for (storm_id = 0; storm_id < MAX_DBG_STORMS; storm_id++) {
-               if (qed_grc_is_storm_included(p_hwfn,
-                                             (enum dbg_storms)storm_id)) {
-                       u32 reg_addr =
-                           s_storm_defs[storm_id].sem_fast_mem_addr +
-                           SEM_FAST_REG_STALL_0;
+               if (!qed_grc_is_storm_included(p_hwfn,
+                                              (enum dbg_storms)storm_id))
+                       continue;
 
-                       qed_wr(p_hwfn, p_ptt, reg_addr, reg_val);
-               }
+               reg_addr = s_storm_defs[storm_id].sem_fast_mem_addr +
+                   SEM_FAST_REG_STALL_0_BB_K2;
+               qed_wr(p_hwfn, p_ptt, reg_addr, stall ? 1 : 0);
        }
 
        msleep(STALL_DELAY_MS);
@@ -2054,24 +2287,29 @@ static void qed_grc_unreset_blocks(struct qed_hwfn *p_hwfn,
 {
        struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
        u32 reg_val[MAX_DBG_RESET_REGS] = { 0 };
-       u32 i;
+       u32 block_id, i;
 
        /* Fill reset regs values */
-       for (i = 0; i < MAX_BLOCK_ID; i++)
-               if (s_block_defs[i]->has_reset_bit && s_block_defs[i]->unreset)
-                       reg_val[s_block_defs[i]->reset_reg] |=
-                           BIT(s_block_defs[i]->reset_bit_offset);
+       for (block_id = 0; block_id < MAX_BLOCK_ID; block_id++) {
+               struct block_defs *block = s_block_defs[block_id];
+
+               if (block->has_reset_bit && block->unreset)
+                       reg_val[block->reset_reg] |=
+                           BIT(block->reset_bit_offset);
+       }
 
        /* Write reset registers */
        for (i = 0; i < MAX_DBG_RESET_REGS; i++) {
-               if (s_reset_regs_defs[i].exists[dev_data->chip_id]) {
-                       reg_val[i] |= s_reset_regs_defs[i].unreset_val;
-                       if (reg_val[i])
-                               qed_wr(p_hwfn,
-                                      p_ptt,
-                                      s_reset_regs_defs[i].addr +
-                                      RESET_REG_UNRESET_OFFSET, reg_val[i]);
-               }
+               if (!s_reset_regs_defs[i].exists[dev_data->chip_id])
+                       continue;
+
+               reg_val[i] |= s_reset_regs_defs[i].unreset_val;
+
+               if (reg_val[i])
+                       qed_wr(p_hwfn,
+                              p_ptt,
+                              s_reset_regs_defs[i].addr +
+                              RESET_REG_UNRESET_OFFSET, reg_val[i]);
        }
 }
 
@@ -2095,6 +2333,7 @@ qed_get_block_attn_regs(enum block_id block_id, enum dbg_attn_type attn_type,
                qed_get_block_attn_data(block_id, attn_type);
 
        *num_attn_regs = block_type_data->num_regs;
+
        return &((const struct dbg_attn_reg *)
                 s_dbg_arrays[BIN_BUF_DBG_ATTN_REGS].ptr)[block_type_data->
                                                          regs_offset];
@@ -2105,34 +2344,34 @@ static void qed_grc_clear_all_prty(struct qed_hwfn *p_hwfn,
                                   struct qed_ptt *p_ptt)
 {
        struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
+       const struct dbg_attn_reg *attn_reg_arr;
        u8 reg_idx, num_attn_regs;
        u32 block_id;
 
        for (block_id = 0; block_id < MAX_BLOCK_ID; block_id++) {
-               const struct dbg_attn_reg *attn_reg_arr;
-
                if (dev_data->block_in_reset[block_id])
                        continue;
 
                attn_reg_arr = qed_get_block_attn_regs((enum block_id)block_id,
                                                       ATTN_TYPE_PARITY,
                                                       &num_attn_regs);
+
                for (reg_idx = 0; reg_idx < num_attn_regs; reg_idx++) {
                        const struct dbg_attn_reg *reg_data =
                                &attn_reg_arr[reg_idx];
+                       u16 modes_buf_offset;
+                       bool eval_mode;
 
                        /* Check mode */
-                       bool eval_mode = GET_FIELD(reg_data->mode.data,
-                                                  DBG_MODE_HDR_EVAL_MODE) > 0;
-                       u16 modes_buf_offset =
+                       eval_mode = GET_FIELD(reg_data->mode.data,
+                                             DBG_MODE_HDR_EVAL_MODE) > 0;
+                       modes_buf_offset =
                                GET_FIELD(reg_data->mode.data,
                                          DBG_MODE_HDR_MODES_BUF_OFFSET);
 
+                       /* If Mode match: clear parity status */
                        if (!eval_mode ||
                            qed_is_mode_match(p_hwfn, &modes_buf_offset))
-                               /* Mode match - read parity status read-clear
-                                * register.
-                                */
                                qed_rd(p_hwfn, p_ptt,
                                       DWORDS_TO_BYTES(reg_data->
                                                       sts_clr_address));
@@ -2142,11 +2381,11 @@ static void qed_grc_clear_all_prty(struct qed_hwfn *p_hwfn,
 
 /* Dumps GRC registers section header. Returns the dumped size in dwords.
  * The following parameters are dumped:
- * - 'count' = num_dumped_entries
- * - 'split' = split_type
- * - 'id' = split_id (dumped only if split_id >= 0)
- * - 'param_name' = param_val (user param, dumped only if param_name != NULL and
- *     param_val != NULL)
+ * - count:     no. of dumped entries
+ * - split:     split type
+ * - id:        split ID (dumped only if split_id >= 0)
+ * - param_name: user parameter value (dumped only if param_name != NULL
+ *              and param_val != NULL).
  */
 static u32 qed_grc_dump_regs_hdr(u32 *dump_buf,
                                 bool dump,
@@ -2170,84 +2409,100 @@ static u32 qed_grc_dump_regs_hdr(u32 *dump_buf,
        if (param_name && param_val)
                offset += qed_dump_str_param(dump_buf + offset,
                                             dump, param_name, param_val);
+
        return offset;
 }
 
 /* Dumps the GRC registers in the specified address range.
  * Returns the dumped size in dwords.
+ * The addr and len arguments are specified in dwords.
  */
 static u32 qed_grc_dump_addr_range(struct qed_hwfn *p_hwfn,
-                                  struct qed_ptt *p_ptt, u32 *dump_buf,
-                                  bool dump, u32 addr, u32 len)
+                                  struct qed_ptt *p_ptt,
+                                  u32 *dump_buf,
+                                  bool dump, u32 addr, u32 len, bool wide_bus)
 {
        u32 byte_addr = DWORDS_TO_BYTES(addr), offset = 0, i;
 
-       if (dump)
-               for (i = 0; i < len; i++, byte_addr += BYTES_IN_DWORD, offset++)
-                       *(dump_buf + offset) = qed_rd(p_hwfn, p_ptt, byte_addr);
-       else
-               offset += len;
+       if (!dump)
+               return len;
+
+       for (i = 0; i < len; i++, byte_addr += BYTES_IN_DWORD, offset++)
+               *(dump_buf + offset) = qed_rd(p_hwfn, p_ptt, byte_addr);
+
        return offset;
 }
 
-/* Dumps GRC registers sequence header. Returns the dumped size in dwords. */
-static u32 qed_grc_dump_reg_entry_hdr(u32 *dump_buf, bool dump, u32 addr,
-                                     u32 len)
+/* Dumps GRC registers sequence header. Returns the dumped size in dwords.
+ * The addr and len arguments are specified in dwords.
+ */
+static u32 qed_grc_dump_reg_entry_hdr(u32 *dump_buf,
+                                     bool dump, u32 addr, u32 len)
 {
        if (dump)
                *dump_buf = addr | (len << REG_DUMP_LEN_SHIFT);
+
        return 1;
 }
 
-/* Dumps GRC registers sequence. Returns the dumped size in dwords. */
+/* Dumps GRC registers sequence. Returns the dumped size in dwords.
+ * The addr and len arguments are specified in dwords.
+ */
 static u32 qed_grc_dump_reg_entry(struct qed_hwfn *p_hwfn,
-                                 struct qed_ptt *p_ptt, u32 *dump_buf,
-                                 bool dump, u32 addr, u32 len)
+                                 struct qed_ptt *p_ptt,
+                                 u32 *dump_buf,
+                                 bool dump, u32 addr, u32 len, bool wide_bus)
 {
        u32 offset = 0;
 
        offset += qed_grc_dump_reg_entry_hdr(dump_buf, dump, addr, len);
        offset += qed_grc_dump_addr_range(p_hwfn,
                                          p_ptt,
-                                         dump_buf + offset, dump, addr, len);
+                                         dump_buf + offset,
+                                         dump, addr, len, wide_bus);
+
        return offset;
 }
 
 /* Dumps GRC registers sequence with skip cycle.
  * Returns the dumped size in dwords.
+ * - addr:     start GRC address in dwords
+ * - total_len:        total no. of dwords to dump
+ * - read_len: no. consecutive dwords to read
+ * - skip_len: no. of dwords to skip (and fill with zeros)
  */
 static u32 qed_grc_dump_reg_entry_skip(struct qed_hwfn *p_hwfn,
-                                      struct qed_ptt *p_ptt, u32 *dump_buf,
-                                      bool dump, u32 addr, u32 total_len,
+                                      struct qed_ptt *p_ptt,
+                                      u32 *dump_buf,
+                                      bool dump,
+                                      u32 addr,
+                                      u32 total_len,
                                       u32 read_len, u32 skip_len)
 {
        u32 offset = 0, reg_offset = 0;
 
        offset += qed_grc_dump_reg_entry_hdr(dump_buf, dump, addr, total_len);
-       if (dump) {
-               while (reg_offset < total_len) {
-                       u32 curr_len = min_t(u32,
-                                            read_len,
-                                            total_len - reg_offset);
-                       offset += qed_grc_dump_addr_range(p_hwfn,
-                                                         p_ptt,
-                                                         dump_buf + offset,
-                                                         dump, addr, curr_len);
+
+       if (!dump)
+               return offset + total_len;
+
+       while (reg_offset < total_len) {
+               u32 curr_len = min_t(u32, read_len, total_len - reg_offset);
+
+               offset += qed_grc_dump_addr_range(p_hwfn,
+                                                 p_ptt,
+                                                 dump_buf + offset,
+                                                 dump, addr, curr_len, false);
+               reg_offset += curr_len;
+               addr += curr_len;
+
+               if (reg_offset < total_len) {
+                       curr_len = min_t(u32, skip_len, total_len - skip_len);
+                       memset(dump_buf + offset, 0, DWORDS_TO_BYTES(curr_len));
+                       offset += curr_len;
                        reg_offset += curr_len;
                        addr += curr_len;
-                       if (reg_offset < total_len) {
-                               curr_len = min_t(u32,
-                                                skip_len,
-                                                total_len - skip_len);
-                               memset(dump_buf + offset, 0,
-                                      DWORDS_TO_BYTES(curr_len));
-                               offset += curr_len;
-                               reg_offset += curr_len;
-                               addr += curr_len;
-                       }
                }
-       } else {
-               offset += total_len;
        }
 
        return offset;
@@ -2266,43 +2521,48 @@ static u32 qed_grc_dump_regs_entries(struct qed_hwfn *p_hwfn,
        bool mode_match = true;
 
        *num_dumped_reg_entries = 0;
+
        while (input_offset < input_regs_arr.size_in_dwords) {
                const struct dbg_dump_cond_hdr *cond_hdr =
                    (const struct dbg_dump_cond_hdr *)
                    &input_regs_arr.ptr[input_offset++];
-               bool eval_mode = GET_FIELD(cond_hdr->mode.data,
-                                          DBG_MODE_HDR_EVAL_MODE) > 0;
+               u16 modes_buf_offset;
+               bool eval_mode;
 
                /* Check mode/block */
+               eval_mode = GET_FIELD(cond_hdr->mode.data,
+                                     DBG_MODE_HDR_EVAL_MODE) > 0;
                if (eval_mode) {
-                       u16 modes_buf_offset =
+                       modes_buf_offset =
                                GET_FIELD(cond_hdr->mode.data,
                                          DBG_MODE_HDR_MODES_BUF_OFFSET);
                        mode_match = qed_is_mode_match(p_hwfn,
                                                       &modes_buf_offset);
                }
 
-               if (mode_match && block_enable[cond_hdr->block_id]) {
-                       for (i = 0; i < cond_hdr->data_size;
-                            i++, input_offset++) {
-                               const struct dbg_dump_reg *reg =
-                                   (const struct dbg_dump_reg *)
-                                   &input_regs_arr.ptr[input_offset];
-                               u32 addr, len;
-
-                               addr = GET_FIELD(reg->data,
-                                                DBG_DUMP_REG_ADDRESS);
-                               len = GET_FIELD(reg->data, DBG_DUMP_REG_LENGTH);
-                               offset +=
-                                   qed_grc_dump_reg_entry(p_hwfn, p_ptt,
-                                                          dump_buf + offset,
-                                                          dump,
-                                                          addr,
-                                                          len);
-                               (*num_dumped_reg_entries)++;
-                       }
-               } else {
+               if (!mode_match || !block_enable[cond_hdr->block_id]) {
                        input_offset += cond_hdr->data_size;
+                       continue;
+               }
+
+               for (i = 0; i < cond_hdr->data_size; i++, input_offset++) {
+                       const struct dbg_dump_reg *reg =
+                           (const struct dbg_dump_reg *)
+                           &input_regs_arr.ptr[input_offset];
+                       u32 addr, len;
+                       bool wide_bus;
+
+                       addr = GET_FIELD(reg->data, DBG_DUMP_REG_ADDRESS);
+                       len = GET_FIELD(reg->data, DBG_DUMP_REG_LENGTH);
+                       wide_bus = GET_FIELD(reg->data, DBG_DUMP_REG_WIDE_BUS);
+                       offset += qed_grc_dump_reg_entry(p_hwfn,
+                                                        p_ptt,
+                                                        dump_buf + offset,
+                                                        dump,
+                                                        addr,
+                                                        len,
+                                                        wide_bus);
+                       (*num_dumped_reg_entries)++;
                }
        }
 
@@ -2350,8 +2610,8 @@ static u32 qed_grc_dump_split_data(struct qed_hwfn *p_hwfn,
        return num_dumped_reg_entries > 0 ? offset : 0;
 }
 
-/* Dumps registers according to the input registers array.
- * Returns the dumped size in dwords.
+/* Dumps registers according to the input registers array. Returns the dumped
+ * size in dwords.
  */
 static u32 qed_grc_dump_registers(struct qed_hwfn *p_hwfn,
                                  struct qed_ptt *p_ptt,
@@ -2361,29 +2621,37 @@ static u32 qed_grc_dump_registers(struct qed_hwfn *p_hwfn,
                                  const char *param_name, const char *param_val)
 {
        struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
-       struct chip_platform_defs *p_platform_defs;
+       struct chip_platform_defs *chip_platform;
        u32 offset = 0, input_offset = 0;
-       struct chip_defs *p_chip_defs;
+       struct chip_defs *chip;
        u8 port_id, pf_id, vf_id;
        u16 fid;
 
-       p_chip_defs = &s_chip_defs[dev_data->chip_id];
-       p_platform_defs = &p_chip_defs->per_platform[dev_data->platform_id];
+       chip = &s_chip_defs[dev_data->chip_id];
+       chip_platform = &chip->per_platform[dev_data->platform_id];
 
        if (dump)
                DP_VERBOSE(p_hwfn, QED_MSG_DEBUG, "Dumping registers...\n");
+
        while (input_offset <
               s_dbg_arrays[BIN_BUF_DBG_DUMP_REG].size_in_dwords) {
-               const struct dbg_dump_split_hdr *split_hdr =
+               const struct dbg_dump_split_hdr *split_hdr;
+               struct dbg_array curr_input_regs_arr;
+               u32 split_data_size;
+               u8 split_type_id;
+
+               split_hdr =
                        (const struct dbg_dump_split_hdr *)
                        &s_dbg_arrays[BIN_BUF_DBG_DUMP_REG].ptr[input_offset++];
-               u8 split_type_id = GET_FIELD(split_hdr->hdr,
-                                            DBG_DUMP_SPLIT_HDR_SPLIT_TYPE_ID);
-               u32 split_data_size = GET_FIELD(split_hdr->hdr,
-                                               DBG_DUMP_SPLIT_HDR_DATA_SIZE);
-               struct dbg_array curr_input_regs_arr = {
-                       &s_dbg_arrays[BIN_BUF_DBG_DUMP_REG].ptr[input_offset],
-                       split_data_size};
+               split_type_id =
+                       GET_FIELD(split_hdr->hdr,
+                                 DBG_DUMP_SPLIT_HDR_SPLIT_TYPE_ID);
+               split_data_size =
+                       GET_FIELD(split_hdr->hdr,
+                                 DBG_DUMP_SPLIT_HDR_DATA_SIZE);
+               curr_input_regs_arr.ptr =
+                       &s_dbg_arrays[BIN_BUF_DBG_DUMP_REG].ptr[input_offset];
+               curr_input_regs_arr.size_in_dwords = split_data_size;
 
                switch (split_type_id) {
                case SPLIT_TYPE_NONE:
@@ -2398,8 +2666,9 @@ static u32 qed_grc_dump_registers(struct qed_hwfn *p_hwfn,
                                                          param_name,
                                                          param_val);
                        break;
+
                case SPLIT_TYPE_PORT:
-                       for (port_id = 0; port_id < p_platform_defs->num_ports;
+                       for (port_id = 0; port_id < chip_platform->num_ports;
                             port_id++) {
                                if (dump)
                                        qed_port_pretend(p_hwfn, p_ptt,
@@ -2414,9 +2683,10 @@ static u32 qed_grc_dump_registers(struct qed_hwfn *p_hwfn,
                                                            param_val);
                        }
                        break;
+
                case SPLIT_TYPE_PF:
                case SPLIT_TYPE_PORT_PF:
-                       for (pf_id = 0; pf_id < p_platform_defs->num_pfs;
+                       for (pf_id = 0; pf_id < chip_platform->num_pfs;
                             pf_id++) {
                                u8 pfid_shift =
                                        PXP_PRETEND_CONCRETE_FID_PFID_SHIFT;
@@ -2427,17 +2697,21 @@ static u32 qed_grc_dump_registers(struct qed_hwfn *p_hwfn,
                                }
 
                                offset +=
-                                   qed_grc_dump_split_data(p_hwfn, p_ptt,
+                                   qed_grc_dump_split_data(p_hwfn,
+                                                           p_ptt,
                                                            curr_input_regs_arr,
                                                            dump_buf + offset,
-                                                           dump, block_enable,
-                                                           "pf", pf_id,
+                                                           dump,
+                                                           block_enable,
+                                                           "pf",
+                                                           pf_id,
                                                            param_name,
                                                            param_val);
                        }
                        break;
+
                case SPLIT_TYPE_VF:
-                       for (vf_id = 0; vf_id < p_platform_defs->num_vfs;
+                       for (vf_id = 0; vf_id < chip_platform->num_vfs;
                             vf_id++) {
                                u8 vfvalid_shift =
                                        PXP_PRETEND_CONCRETE_FID_VFVALID_SHIFT;
@@ -2460,6 +2734,7 @@ static u32 qed_grc_dump_registers(struct qed_hwfn *p_hwfn,
                                                            param_val);
                        }
                        break;
+
                default:
                        break;
                }
@@ -2490,35 +2765,37 @@ static u32 qed_grc_dump_reset_regs(struct qed_hwfn *p_hwfn,
 
        /* Write reset registers */
        for (i = 0; i < MAX_DBG_RESET_REGS; i++) {
-               if (s_reset_regs_defs[i].exists[dev_data->chip_id]) {
-                       u32 addr = BYTES_TO_DWORDS(s_reset_regs_defs[i].addr);
+               if (!s_reset_regs_defs[i].exists[dev_data->chip_id])
+                       continue;
 
-                       offset += qed_grc_dump_reg_entry(p_hwfn,
-                                                        p_ptt,
-                                                        dump_buf + offset,
-                                                        dump,
-                                                        addr,
-                                                        1);
-                       num_regs++;
-               }
+               offset += qed_grc_dump_reg_entry(p_hwfn,
+                                                p_ptt,
+                                                dump_buf + offset,
+                                                dump,
+                                                BYTES_TO_DWORDS
+                                                (s_reset_regs_defs[i].addr), 1,
+                                                false);
+               num_regs++;
        }
 
        /* Write header */
        if (dump)
                qed_grc_dump_regs_hdr(dump_buf,
                                      true, num_regs, "eng", -1, NULL, NULL);
+
        return offset;
 }
 
-/* Dump registers that are modified during GRC Dump and therefore must be dumped
- * first. Returns the dumped size in dwords.
+/* Dump registers that are modified during GRC Dump and therefore must be
+ * dumped first. Returns the dumped size in dwords.
  */
 static u32 qed_grc_dump_modified_regs(struct qed_hwfn *p_hwfn,
                                      struct qed_ptt *p_ptt,
                                      u32 *dump_buf, bool dump)
 {
        struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
-       u32 offset = 0, num_reg_entries = 0, block_id;
+       u32 block_id, offset = 0, num_reg_entries = 0;
+       const struct dbg_attn_reg *attn_reg_arr;
        u8 storm_id, reg_idx, num_attn_regs;
 
        /* Calculate header size */
@@ -2527,14 +2804,13 @@ static u32 qed_grc_dump_modified_regs(struct qed_hwfn *p_hwfn,
 
        /* Write parity registers */
        for (block_id = 0; block_id < MAX_BLOCK_ID; block_id++) {
-               const struct dbg_attn_reg *attn_reg_arr;
-
                if (dev_data->block_in_reset[block_id] && dump)
                        continue;
 
                attn_reg_arr = qed_get_block_attn_regs((enum block_id)block_id,
                                                       ATTN_TYPE_PARITY,
                                                       &num_attn_regs);
+
                for (reg_idx = 0; reg_idx < num_attn_regs; reg_idx++) {
                        const struct dbg_attn_reg *reg_data =
                                &attn_reg_arr[reg_idx];
@@ -2548,37 +2824,36 @@ static u32 qed_grc_dump_modified_regs(struct qed_hwfn *p_hwfn,
                        modes_buf_offset =
                                GET_FIELD(reg_data->mode.data,
                                          DBG_MODE_HDR_MODES_BUF_OFFSET);
-                       if (!eval_mode ||
-                           qed_is_mode_match(p_hwfn, &modes_buf_offset)) {
-                               /* Mode match - read and dump registers */
-                               addr = reg_data->mask_address;
-                               offset +=
-                                   qed_grc_dump_reg_entry(p_hwfn,
-                                                          p_ptt,
-                                                          dump_buf + offset,
-                                                          dump,
-                                                          addr,
-                                                          1);
-                               addr = GET_FIELD(reg_data->data,
-                                                DBG_ATTN_REG_STS_ADDRESS);
-                               offset +=
-                                   qed_grc_dump_reg_entry(p_hwfn,
-                                                          p_ptt,
-                                                          dump_buf + offset,
-                                                          dump,
-                                                          addr,
-                                                          1);
-                               num_reg_entries += 2;
-                       }
+                       if (eval_mode &&
+                           !qed_is_mode_match(p_hwfn, &modes_buf_offset))
+                               continue;
+
+                       /* Mode match: read & dump registers */
+                       addr = reg_data->mask_address;
+                       offset += qed_grc_dump_reg_entry(p_hwfn,
+                                                        p_ptt,
+                                                        dump_buf + offset,
+                                                        dump,
+                                                        addr,
+                                                        1, false);
+                       addr = GET_FIELD(reg_data->data,
+                                        DBG_ATTN_REG_STS_ADDRESS);
+                       offset += qed_grc_dump_reg_entry(p_hwfn,
+                                                        p_ptt,
+                                                        dump_buf + offset,
+                                                        dump,
+                                                        addr,
+                                                        1, false);
+                       num_reg_entries += 2;
                }
        }
 
-       /* Write storm stall status registers */
+       /* Write Storm stall status registers */
        for (storm_id = 0; storm_id < MAX_DBG_STORMS; storm_id++) {
+               struct storm_defs *storm = &s_storm_defs[storm_id];
                u32 addr;
 
-               if (dev_data->block_in_reset[s_storm_defs[storm_id].block_id] &&
-                   dump)
+               if (dev_data->block_in_reset[storm->block_id] && dump)
                        continue;
 
                addr =
@@ -2589,7 +2864,8 @@ static u32 qed_grc_dump_modified_regs(struct qed_hwfn *p_hwfn,
                                                 dump_buf + offset,
                                                 dump,
                                                 addr,
-                                                1);
+                                                1,
+                                                false);
                num_reg_entries++;
        }
 
@@ -2598,6 +2874,7 @@ static u32 qed_grc_dump_modified_regs(struct qed_hwfn *p_hwfn,
                qed_grc_dump_regs_hdr(dump_buf,
                                      true,
                                      num_reg_entries, "eng", -1, NULL, NULL);
+
        return offset;
 }
 
@@ -2637,17 +2914,17 @@ static u32 qed_grc_dump_special_regs(struct qed_hwfn *p_hwfn,
        return offset;
 }
 
-/* Dumps a GRC memory header (section and params).
- * The following parameters are dumped:
- * name - name is dumped only if it's not NULL.
- * addr - addr is dumped only if name is NULL.
- * len - len is always dumped.
- * width - bit_width is dumped if it's not zero.
- * packed - packed=1 is dumped if it's not false.
- * mem_group - mem_group is always dumped.
- * is_storm - true only if the memory is related to a Storm.
- * storm_letter - storm letter (valid only if is_storm is true).
- * Returns the dumped size in dwords.
+/* Dumps a GRC memory header (section and params). Returns the dumped size in
+ * dwords. The following parameters are dumped:
+ * - name:        dumped only if it's not NULL.
+ * - addr:        in dwords, dumped only if name is NULL.
+ * - len:         in dwords, always dumped.
+ * - width:       dumped if it's not zero.
+ * - packed:      dumped only if it's not false.
+ * - mem_group:           always dumped.
+ * - is_storm:    true only if the memory is related to a Storm.
+ * - storm_letter: valid only if is_storm is true.
+ *
  */
 static u32 qed_grc_dump_mem_hdr(struct qed_hwfn *p_hwfn,
                                u32 *dump_buf,
@@ -2667,6 +2944,7 @@ static u32 qed_grc_dump_mem_hdr(struct qed_hwfn *p_hwfn,
        if (!len)
                DP_NOTICE(p_hwfn,
                          "Unexpected GRC Dump error: dumped memory size must be non-zero\n");
+
        if (bit_width)
                num_params++;
        if (packed)
@@ -2675,6 +2953,7 @@ static u32 qed_grc_dump_mem_hdr(struct qed_hwfn *p_hwfn,
        /* Dump section header */
        offset += qed_dump_section_hdr(dump_buf + offset,
                                       dump, "grc_mem", num_params);
+
        if (name) {
                /* Dump name */
                if (is_storm) {
@@ -2694,14 +2973,15 @@ static u32 qed_grc_dump_mem_hdr(struct qed_hwfn *p_hwfn,
                                   len, buf);
        } else {
                /* Dump address */
+               u32 addr_in_bytes = DWORDS_TO_BYTES(addr);
+
                offset += qed_dump_num_param(dump_buf + offset,
-                                            dump, "addr",
-                                            DWORDS_TO_BYTES(addr));
+                                            dump, "addr", addr_in_bytes);
                if (dump && len > 64)
                        DP_VERBOSE(p_hwfn,
                                   QED_MSG_DEBUG,
                                   "Dumping %d registers from address 0x%x...\n",
-                                  len, (u32)DWORDS_TO_BYTES(addr));
+                                  len, addr_in_bytes);
        }
 
        /* Dump len */
@@ -2727,11 +3007,13 @@ static u32 qed_grc_dump_mem_hdr(struct qed_hwfn *p_hwfn,
        }
 
        offset += qed_dump_str_param(dump_buf + offset, dump, "type", buf);
+
        return offset;
 }
 
 /* Dumps a single GRC memory. If name is NULL, the memory is stored by address.
  * Returns the dumped size in dwords.
+ * The addr and len arguments are specified in dwords.
  */
 static u32 qed_grc_dump_mem(struct qed_hwfn *p_hwfn,
                            struct qed_ptt *p_ptt,
@@ -2740,6 +3022,7 @@ static u32 qed_grc_dump_mem(struct qed_hwfn *p_hwfn,
                            const char *name,
                            u32 addr,
                            u32 len,
+                           bool wide_bus,
                            u32 bit_width,
                            bool packed,
                            const char *mem_group,
@@ -2758,7 +3041,9 @@ static u32 qed_grc_dump_mem(struct qed_hwfn *p_hwfn,
                                       mem_group, is_storm, storm_letter);
        offset += qed_grc_dump_addr_range(p_hwfn,
                                          p_ptt,
-                                         dump_buf + offset, dump, addr, len);
+                                         dump_buf + offset,
+                                         dump, addr, len, wide_bus);
+
        return offset;
 }
 
@@ -2773,20 +3058,21 @@ static u32 qed_grc_dump_mem_entries(struct qed_hwfn *p_hwfn,
 
        while (input_offset < input_mems_arr.size_in_dwords) {
                const struct dbg_dump_cond_hdr *cond_hdr;
+               u16 modes_buf_offset;
                u32 num_entries;
                bool eval_mode;
 
                cond_hdr = (const struct dbg_dump_cond_hdr *)
                           &input_mems_arr.ptr[input_offset++];
-               eval_mode = GET_FIELD(cond_hdr->mode.data,
-                                     DBG_MODE_HDR_EVAL_MODE) > 0;
+               num_entries = cond_hdr->data_size / MEM_DUMP_ENTRY_SIZE_DWORDS;
 
                /* Check required mode */
+               eval_mode = GET_FIELD(cond_hdr->mode.data,
+                                     DBG_MODE_HDR_EVAL_MODE) > 0;
                if (eval_mode) {
-                       u16 modes_buf_offset =
+                       modes_buf_offset =
                                GET_FIELD(cond_hdr->mode.data,
                                          DBG_MODE_HDR_MODES_BUF_OFFSET);
-
                        mode_match = qed_is_mode_match(p_hwfn,
                                                       &modes_buf_offset);
                }
@@ -2796,81 +3082,87 @@ static u32 qed_grc_dump_mem_entries(struct qed_hwfn *p_hwfn,
                        continue;
                }
 
-               num_entries = cond_hdr->data_size / MEM_DUMP_ENTRY_SIZE_DWORDS;
                for (i = 0; i < num_entries;
                     i++, input_offset += MEM_DUMP_ENTRY_SIZE_DWORDS) {
                        const struct dbg_dump_mem *mem =
                                (const struct dbg_dump_mem *)
                                &input_mems_arr.ptr[input_offset];
-                       u8 mem_group_id;
+                       u8 mem_group_id = GET_FIELD(mem->dword0,
+                                                   DBG_DUMP_MEM_MEM_GROUP_ID);
+                       bool is_storm = false, mem_wide_bus;
+                       enum dbg_grc_params grc_param;
+                       char storm_letter = 'a';
+                       enum block_id block_id;
+                       u32 mem_addr, mem_len;
 
-                       mem_group_id = GET_FIELD(mem->dword0,
-                                                DBG_DUMP_MEM_MEM_GROUP_ID);
                        if (mem_group_id >= MEM_GROUPS_NUM) {
                                DP_NOTICE(p_hwfn, "Invalid mem_group_id\n");
                                return 0;
                        }
 
-                       if (qed_grc_is_mem_included(p_hwfn,
-                                       (enum block_id)cond_hdr->block_id,
-                                       mem_group_id)) {
-                               u32 mem_addr = GET_FIELD(mem->dword0,
-                                                        DBG_DUMP_MEM_ADDRESS);
-                               u32 mem_len = GET_FIELD(mem->dword1,
-                                                       DBG_DUMP_MEM_LENGTH);
-                               enum dbg_grc_params grc_param;
-                               char storm_letter = 'a';
-                               bool is_storm = false;
-
-                               /* Update memory length for CCFC/TCFC memories
-                                * according to number of LCIDs/LTIDs.
-                                */
-                               if (mem_group_id == MEM_GROUP_CONN_CFC_MEM) {
-                                       if (mem_len % MAX_LCIDS != 0) {
-                                               DP_NOTICE(p_hwfn,
-                                                         "Invalid CCFC connection memory size\n");
-                                               return 0;
-                                       }
-
-                                       grc_param = DBG_GRC_PARAM_NUM_LCIDS;
-                                       mem_len = qed_grc_get_param(p_hwfn,
-                                                                   grc_param) *
-                                                 (mem_len / MAX_LCIDS);
-                               } else if (mem_group_id ==
-                                          MEM_GROUP_TASK_CFC_MEM) {
-                                       if (mem_len % MAX_LTIDS != 0) {
-                                               DP_NOTICE(p_hwfn,
-                                                         "Invalid TCFC task memory size\n");
-                                               return 0;
-                                       }
-
-                                       grc_param = DBG_GRC_PARAM_NUM_LTIDS;
-                                       mem_len = qed_grc_get_param(p_hwfn,
-                                                                   grc_param) *
-                                                 (mem_len / MAX_LTIDS);
+                       block_id = (enum block_id)cond_hdr->block_id;
+                       if (!qed_grc_is_mem_included(p_hwfn,
+                                                    block_id,
+                                                    mem_group_id))
+                               continue;
+
+                       mem_addr = GET_FIELD(mem->dword0, DBG_DUMP_MEM_ADDRESS);
+                       mem_len = GET_FIELD(mem->dword1, DBG_DUMP_MEM_LENGTH);
+                       mem_wide_bus = GET_FIELD(mem->dword1,
+                                                DBG_DUMP_MEM_WIDE_BUS);
+
+                       /* Update memory length for CCFC/TCFC memories
+                        * according to number of LCIDs/LTIDs.
+                        */
+                       if (mem_group_id == MEM_GROUP_CONN_CFC_MEM) {
+                               if (mem_len % MAX_LCIDS) {
+                                       DP_NOTICE(p_hwfn,
+                                                 "Invalid CCFC connection memory size\n");
+                                       return 0;
                                }
 
-                               /* If memory is associated with Storm, update
-                                * Storm details.
-                                */
-                               if (s_block_defs[cond_hdr->block_id]->
-                                                       associated_to_storm) {
-                                       is_storm = true;
-                                       storm_letter =
-                                               s_storm_defs[s_block_defs[
-                                               cond_hdr->block_id]->
-                                               storm_id].letter;
+                               grc_param = DBG_GRC_PARAM_NUM_LCIDS;
+                               mem_len = qed_grc_get_param(p_hwfn, grc_param) *
+                                         (mem_len / MAX_LCIDS);
+                       } else if (mem_group_id == MEM_GROUP_TASK_CFC_MEM) {
+                               if (mem_len % MAX_LTIDS) {
+                                       DP_NOTICE(p_hwfn,
+                                                 "Invalid TCFC task memory size\n");
+                                       return 0;
                                }
 
-                               /* Dump memory */
-                               offset += qed_grc_dump_mem(p_hwfn, p_ptt,
-                                               dump_buf + offset, dump, NULL,
-                                               mem_addr, mem_len, 0,
+                               grc_param = DBG_GRC_PARAM_NUM_LTIDS;
+                               mem_len = qed_grc_get_param(p_hwfn, grc_param) *
+                                         (mem_len / MAX_LTIDS);
+                       }
+
+                       /* If memory is associated with Storm, update Storm
+                        * details.
+                        */
+                       if (s_block_defs
+                           [cond_hdr->block_id]->associated_to_storm) {
+                               is_storm = true;
+                               storm_letter =
+                                   s_storm_defs[s_block_defs
+                                                [cond_hdr->block_id]->
+                                                storm_id].letter;
+                       }
+
+                       /* Dump memory */
+                       offset += qed_grc_dump_mem(p_hwfn,
+                                               p_ptt,
+                                               dump_buf + offset,
+                                               dump,
+                                               NULL,
+                                               mem_addr,
+                                               mem_len,
+                                               mem_wide_bus,
+                                               0,
                                                false,
                                                s_mem_group_names[mem_group_id],
-                                               is_storm, storm_letter);
-                               }
-                       }
+                                               is_storm,
+                                               storm_letter);
+               }
        }
 
        return offset;
@@ -2887,16 +3179,22 @@ static u32 qed_grc_dump_memories(struct qed_hwfn *p_hwfn,
 
        while (input_offset <
               s_dbg_arrays[BIN_BUF_DBG_DUMP_MEM].size_in_dwords) {
-               const struct dbg_dump_split_hdr *split_hdr =
-                       (const struct dbg_dump_split_hdr *)
+               const struct dbg_dump_split_hdr *split_hdr;
+               struct dbg_array curr_input_mems_arr;
+               u32 split_data_size;
+               u8 split_type_id;
+
+               split_hdr = (const struct dbg_dump_split_hdr *)
                        &s_dbg_arrays[BIN_BUF_DBG_DUMP_MEM].ptr[input_offset++];
-               u8 split_type_id = GET_FIELD(split_hdr->hdr,
-                                            DBG_DUMP_SPLIT_HDR_SPLIT_TYPE_ID);
-               u32 split_data_size = GET_FIELD(split_hdr->hdr,
-                                               DBG_DUMP_SPLIT_HDR_DATA_SIZE);
-               struct dbg_array curr_input_mems_arr = {
-                       &s_dbg_arrays[BIN_BUF_DBG_DUMP_MEM].ptr[input_offset],
-                       split_data_size};
+               split_type_id =
+                       GET_FIELD(split_hdr->hdr,
+                                 DBG_DUMP_SPLIT_HDR_SPLIT_TYPE_ID);
+               split_data_size =
+                       GET_FIELD(split_hdr->hdr,
+                                 DBG_DUMP_SPLIT_HDR_DATA_SIZE);
+               curr_input_mems_arr.ptr =
+                       &s_dbg_arrays[BIN_BUF_DBG_DUMP_MEM].ptr[input_offset];
+               curr_input_mems_arr.size_in_dwords = split_data_size;
 
                switch (split_type_id) {
                case SPLIT_TYPE_NONE:
@@ -2906,6 +3204,7 @@ static u32 qed_grc_dump_memories(struct qed_hwfn *p_hwfn,
                                                           dump_buf + offset,
                                                           dump);
                        break;
+
                default:
                        DP_NOTICE(p_hwfn,
                                  "Dumping split memories is currently not supported\n");
@@ -2920,6 +3219,7 @@ static u32 qed_grc_dump_memories(struct qed_hwfn *p_hwfn,
 
 /* Dumps GRC context data for the specified Storm.
  * Returns the dumped size in dwords.
+ * The lid_size argument is specified in quad-regs.
  */
 static u32 qed_grc_dump_ctx_data(struct qed_hwfn *p_hwfn,
                                 struct qed_ptt *p_ptt,
@@ -2931,13 +3231,15 @@ static u32 qed_grc_dump_ctx_data(struct qed_hwfn *p_hwfn,
                                 u32 rd_reg_addr,
                                 u8 storm_id)
 {
-       u32 i, lid, total_size;
-       u32 offset = 0;
+       struct storm_defs *storm = &s_storm_defs[storm_id];
+       u32 i, lid, total_size, offset = 0;
 
        if (!lid_size)
                return 0;
+
        lid_size *= BYTES_IN_DWORD;
        total_size = num_lids * lid_size;
+
        offset += qed_grc_dump_mem_hdr(p_hwfn,
                                       dump_buf + offset,
                                       dump,
@@ -2945,25 +3247,19 @@ static u32 qed_grc_dump_ctx_data(struct qed_hwfn *p_hwfn,
                                       0,
                                       total_size,
                                       lid_size * 32,
-                                      false,
-                                      name,
-                                      true, s_storm_defs[storm_id].letter);
+                                      false, name, true, storm->letter);
+
+       if (!dump)
+               return offset + total_size;
 
        /* Dump context data */
-       if (dump) {
-               for (lid = 0; lid < num_lids; lid++) {
-                       for (i = 0; i < lid_size; i++, offset++) {
-                               qed_wr(p_hwfn,
-                                      p_ptt,
-                                      s_storm_defs[storm_id].cm_ctx_wr_addr,
-                                      BIT(9) | lid);
-                               *(dump_buf + offset) = qed_rd(p_hwfn,
-                                                             p_ptt,
-                                                             rd_reg_addr);
-                       }
+       for (lid = 0; lid < num_lids; lid++) {
+               for (i = 0; i < lid_size; i++, offset++) {
+                       qed_wr(p_hwfn,
+                              p_ptt, storm->cm_ctx_wr_addr, (i << 9) | lid);
+                       *(dump_buf + offset) = qed_rd(p_hwfn,
+                                                     p_ptt, rd_reg_addr);
                }
-       } else {
-               offset += total_size;
        }
 
        return offset;
@@ -2973,15 +3269,19 @@ static u32 qed_grc_dump_ctx_data(struct qed_hwfn *p_hwfn,
 static u32 qed_grc_dump_ctx(struct qed_hwfn *p_hwfn,
                            struct qed_ptt *p_ptt, u32 *dump_buf, bool dump)
 {
+       enum dbg_grc_params grc_param;
        u32 offset = 0;
        u8 storm_id;
 
        for (storm_id = 0; storm_id < MAX_DBG_STORMS; storm_id++) {
+               struct storm_defs *storm = &s_storm_defs[storm_id];
+
                if (!qed_grc_is_storm_included(p_hwfn,
                                               (enum dbg_storms)storm_id))
                        continue;
 
                /* Dump Conn AG context size */
+               grc_param = DBG_GRC_PARAM_NUM_LCIDS;
                offset +=
                        qed_grc_dump_ctx_data(p_hwfn,
                                              p_ptt,
@@ -2989,14 +3289,13 @@ static u32 qed_grc_dump_ctx(struct qed_hwfn *p_hwfn,
                                              dump,
                                              "CONN_AG_CTX",
                                              qed_grc_get_param(p_hwfn,
-                                                   DBG_GRC_PARAM_NUM_LCIDS),
-                                             s_storm_defs[storm_id].
-                                                   cm_conn_ag_ctx_lid_size,
-                                             s_storm_defs[storm_id].
-                                                   cm_conn_ag_ctx_rd_addr,
+                                                               grc_param),
+                                             storm->cm_conn_ag_ctx_lid_size,
+                                             storm->cm_conn_ag_ctx_rd_addr,
                                              storm_id);
 
                /* Dump Conn ST context size */
+               grc_param = DBG_GRC_PARAM_NUM_LCIDS;
                offset +=
                        qed_grc_dump_ctx_data(p_hwfn,
                                              p_ptt,
@@ -3004,14 +3303,13 @@ static u32 qed_grc_dump_ctx(struct qed_hwfn *p_hwfn,
                                              dump,
                                              "CONN_ST_CTX",
                                              qed_grc_get_param(p_hwfn,
-                                                   DBG_GRC_PARAM_NUM_LCIDS),
-                                             s_storm_defs[storm_id].
-                                                   cm_conn_st_ctx_lid_size,
-                                             s_storm_defs[storm_id].
-                                                   cm_conn_st_ctx_rd_addr,
+                                                               grc_param),
+                                             storm->cm_conn_st_ctx_lid_size,
+                                             storm->cm_conn_st_ctx_rd_addr,
                                              storm_id);
 
                /* Dump Task AG context size */
+               grc_param = DBG_GRC_PARAM_NUM_LTIDS;
                offset +=
                        qed_grc_dump_ctx_data(p_hwfn,
                                              p_ptt,
@@ -3019,14 +3317,13 @@ static u32 qed_grc_dump_ctx(struct qed_hwfn *p_hwfn,
                                              dump,
                                              "TASK_AG_CTX",
                                              qed_grc_get_param(p_hwfn,
-                                                   DBG_GRC_PARAM_NUM_LTIDS),
-                                             s_storm_defs[storm_id].
-                                                   cm_task_ag_ctx_lid_size,
-                                             s_storm_defs[storm_id].
-                                                   cm_task_ag_ctx_rd_addr,
+                                                               grc_param),
+                                             storm->cm_task_ag_ctx_lid_size,
+                                             storm->cm_task_ag_ctx_rd_addr,
                                              storm_id);
 
                /* Dump Task ST context size */
+               grc_param = DBG_GRC_PARAM_NUM_LTIDS;
                offset +=
                        qed_grc_dump_ctx_data(p_hwfn,
                                              p_ptt,
@@ -3034,11 +3331,9 @@ static u32 qed_grc_dump_ctx(struct qed_hwfn *p_hwfn,
                                              dump,
                                              "TASK_ST_CTX",
                                              qed_grc_get_param(p_hwfn,
-                                                   DBG_GRC_PARAM_NUM_LTIDS),
-                                             s_storm_defs[storm_id].
-                                                   cm_task_st_ctx_lid_size,
-                                             s_storm_defs[storm_id].
-                                                   cm_task_st_ctx_rd_addr,
+                                                               grc_param),
+                                             storm->cm_task_st_ctx_lid_size,
+                                             storm->cm_task_st_ctx_rd_addr,
                                              storm_id);
        }
 
@@ -3050,8 +3345,8 @@ static u32 qed_grc_dump_iors(struct qed_hwfn *p_hwfn,
                             struct qed_ptt *p_ptt, u32 *dump_buf, bool dump)
 {
        char buf[10] = "IOR_SET_?";
+       u32 addr, offset = 0;
        u8 storm_id, set_id;
-       u32 offset = 0;
 
        for (storm_id = 0; storm_id < MAX_DBG_STORMS; storm_id++) {
                struct storm_defs *storm = &s_storm_defs[storm_id];
@@ -3061,11 +3356,9 @@ static u32 qed_grc_dump_iors(struct qed_hwfn *p_hwfn,
                        continue;
 
                for (set_id = 0; set_id < NUM_IOR_SETS; set_id++) {
-                       u32 dwords, addr;
-
-                       dwords = storm->sem_fast_mem_addr +
-                                SEM_FAST_REG_STORM_REG_FILE;
-                       addr = BYTES_TO_DWORDS(dwords) + IOR_SET_OFFSET(set_id);
+                       addr = BYTES_TO_DWORDS(storm->sem_fast_mem_addr +
+                                              SEM_FAST_REG_STORM_REG_FILE) +
+                              IOR_SET_OFFSET(set_id);
                        buf[strlen(buf) - 1] = '0' + set_id;
                        offset += qed_grc_dump_mem(p_hwfn,
                                                   p_ptt,
@@ -3074,6 +3367,7 @@ static u32 qed_grc_dump_iors(struct qed_hwfn *p_hwfn,
                                                   buf,
                                                   addr,
                                                   IORS_PER_SET,
+                                                  false,
                                                   32,
                                                   false,
                                                   "ior",
@@ -3091,10 +3385,10 @@ static u32 qed_grc_dump_vfc_cam(struct qed_hwfn *p_hwfn,
                                u32 *dump_buf, bool dump, u8 storm_id)
 {
        u32 total_size = VFC_CAM_NUM_ROWS * VFC_CAM_RESP_DWORDS;
+       struct storm_defs *storm = &s_storm_defs[storm_id];
        u32 cam_addr[VFC_CAM_ADDR_DWORDS] = { 0 };
        u32 cam_cmd[VFC_CAM_CMD_DWORDS] = { 0 };
-       u32 offset = 0;
-       u32 row, i;
+       u32 row, i, offset = 0;
 
        offset += qed_grc_dump_mem_hdr(p_hwfn,
                                       dump_buf + offset,
@@ -3103,38 +3397,34 @@ static u32 qed_grc_dump_vfc_cam(struct qed_hwfn *p_hwfn,
                                       0,
                                       total_size,
                                       256,
-                                      false,
-                                      "vfc_cam",
-                                      true, s_storm_defs[storm_id].letter);
-       if (dump) {
-               /* Prepare CAM address */
-               SET_VAR_FIELD(cam_addr, VFC_CAM_ADDR, OP, VFC_OPCODE_CAM_RD);
-               for (row = 0; row < VFC_CAM_NUM_ROWS;
-                    row++, offset += VFC_CAM_RESP_DWORDS) {
-                       /* Write VFC CAM command */
-                       SET_VAR_FIELD(cam_cmd, VFC_CAM_CMD, ROW, row);
-                       ARR_REG_WR(p_hwfn,
-                                  p_ptt,
-                                  s_storm_defs[storm_id].sem_fast_mem_addr +
-                                  SEM_FAST_REG_VFC_DATA_WR,
-                                  cam_cmd, VFC_CAM_CMD_DWORDS);
+                                      false, "vfc_cam", true, storm->letter);
 
-                       /* Write VFC CAM address */
-                       ARR_REG_WR(p_hwfn,
-                                  p_ptt,
-                                  s_storm_defs[storm_id].sem_fast_mem_addr +
-                                  SEM_FAST_REG_VFC_ADDR,
-                                  cam_addr, VFC_CAM_ADDR_DWORDS);
+       if (!dump)
+               return offset + total_size;
 
-                       /* Read VFC CAM read response */
-                       ARR_REG_RD(p_hwfn,
-                                  p_ptt,
-                                  s_storm_defs[storm_id].sem_fast_mem_addr +
-                                  SEM_FAST_REG_VFC_DATA_RD,
-                                  dump_buf + offset, VFC_CAM_RESP_DWORDS);
-               }
-       } else {
-               offset += total_size;
+       /* Prepare CAM address */
+       SET_VAR_FIELD(cam_addr, VFC_CAM_ADDR, OP, VFC_OPCODE_CAM_RD);
+
+       for (row = 0; row < VFC_CAM_NUM_ROWS;
+            row++, offset += VFC_CAM_RESP_DWORDS) {
+               /* Write VFC CAM command */
+               SET_VAR_FIELD(cam_cmd, VFC_CAM_CMD, ROW, row);
+               ARR_REG_WR(p_hwfn,
+                          p_ptt,
+                          storm->sem_fast_mem_addr + SEM_FAST_REG_VFC_DATA_WR,
+                          cam_cmd, VFC_CAM_CMD_DWORDS);
+
+               /* Write VFC CAM address */
+               ARR_REG_WR(p_hwfn,
+                          p_ptt,
+                          storm->sem_fast_mem_addr + SEM_FAST_REG_VFC_ADDR,
+                          cam_addr, VFC_CAM_ADDR_DWORDS);
+
+               /* Read VFC CAM read response */
+               ARR_REG_RD(p_hwfn,
+                          p_ptt,
+                          storm->sem_fast_mem_addr + SEM_FAST_REG_VFC_DATA_RD,
+                          dump_buf + offset, VFC_CAM_RESP_DWORDS);
        }
 
        return offset;
@@ -3148,10 +3438,10 @@ static u32 qed_grc_dump_vfc_ram(struct qed_hwfn *p_hwfn,
                                u8 storm_id, struct vfc_ram_defs *ram_defs)
 {
        u32 total_size = ram_defs->num_rows * VFC_RAM_RESP_DWORDS;
+       struct storm_defs *storm = &s_storm_defs[storm_id];
        u32 ram_addr[VFC_RAM_ADDR_DWORDS] = { 0 };
        u32 ram_cmd[VFC_RAM_CMD_DWORDS] = { 0 };
-       u32 offset = 0;
-       u32 row, i;
+       u32 row, i, offset = 0;
 
        offset += qed_grc_dump_mem_hdr(p_hwfn,
                                       dump_buf + offset,
@@ -3162,7 +3452,7 @@ static u32 qed_grc_dump_vfc_ram(struct qed_hwfn *p_hwfn,
                                       256,
                                       false,
                                       ram_defs->type_name,
-                                      true, s_storm_defs[storm_id].letter);
+                                      true, storm->letter);
 
        /* Prepare RAM address */
        SET_VAR_FIELD(ram_addr, VFC_RAM_ADDR, OP, VFC_OPCODE_RAM_RD);
@@ -3176,23 +3466,20 @@ static u32 qed_grc_dump_vfc_ram(struct qed_hwfn *p_hwfn,
                /* Write VFC RAM command */
                ARR_REG_WR(p_hwfn,
                           p_ptt,
-                          s_storm_defs[storm_id].sem_fast_mem_addr +
-                          SEM_FAST_REG_VFC_DATA_WR,
+                          storm->sem_fast_mem_addr + SEM_FAST_REG_VFC_DATA_WR,
                           ram_cmd, VFC_RAM_CMD_DWORDS);
 
                /* Write VFC RAM address */
                SET_VAR_FIELD(ram_addr, VFC_RAM_ADDR, ROW, row);
                ARR_REG_WR(p_hwfn,
                           p_ptt,
-                          s_storm_defs[storm_id].sem_fast_mem_addr +
-                          SEM_FAST_REG_VFC_ADDR,
+                          storm->sem_fast_mem_addr + SEM_FAST_REG_VFC_ADDR,
                           ram_addr, VFC_RAM_ADDR_DWORDS);
 
                /* Read VFC RAM read response */
                ARR_REG_RD(p_hwfn,
                           p_ptt,
-                          s_storm_defs[storm_id].sem_fast_mem_addr +
-                          SEM_FAST_REG_VFC_DATA_RD,
+                          storm->sem_fast_mem_addr + SEM_FAST_REG_VFC_DATA_RD,
                           dump_buf + offset, VFC_RAM_RESP_DWORDS);
        }
 
@@ -3208,28 +3495,27 @@ static u32 qed_grc_dump_vfc(struct qed_hwfn *p_hwfn,
        u32 offset = 0;
 
        for (storm_id = 0; storm_id < MAX_DBG_STORMS; storm_id++) {
-               if (qed_grc_is_storm_included(p_hwfn,
-                                             (enum dbg_storms)storm_id) &&
-                   s_storm_defs[storm_id].has_vfc &&
-                   (storm_id != DBG_PSTORM_ID ||
-                    dev_data->platform_id == PLATFORM_ASIC)) {
-                       /* Read CAM */
-                       offset += qed_grc_dump_vfc_cam(p_hwfn,
+               if (!qed_grc_is_storm_included(p_hwfn,
+                                              (enum dbg_storms)storm_id) ||
+                   !s_storm_defs[storm_id].has_vfc ||
+                   (storm_id == DBG_PSTORM_ID && dev_data->platform_id !=
+                    PLATFORM_ASIC))
+                       continue;
+
+               /* Read CAM */
+               offset += qed_grc_dump_vfc_cam(p_hwfn,
+                                              p_ptt,
+                                              dump_buf + offset,
+                                              dump, storm_id);
+
+               /* Read RAM */
+               for (i = 0; i < NUM_VFC_RAM_TYPES; i++)
+                       offset += qed_grc_dump_vfc_ram(p_hwfn,
                                                       p_ptt,
                                                       dump_buf + offset,
-                                                      dump, storm_id);
-
-                       /* Read RAM */
-                       for (i = 0; i < NUM_VFC_RAM_TYPES; i++)
-                               offset += qed_grc_dump_vfc_ram(p_hwfn,
-                                                              p_ptt,
-                                                              dump_buf +
-                                                              offset,
-                                                              dump,
-                                                              storm_id,
-                                                              &s_vfc_ram_defs
-                                                              [i]);
-               }
+                                                      dump,
+                                                      storm_id,
+                                                      &s_vfc_ram_defs[i]);
        }
 
        return offset;
@@ -3244,14 +3530,17 @@ static u32 qed_grc_dump_rss(struct qed_hwfn *p_hwfn,
        u8 rss_mem_id;
 
        for (rss_mem_id = 0; rss_mem_id < NUM_RSS_MEM_TYPES; rss_mem_id++) {
-               struct rss_mem_defs *rss_defs = &s_rss_mem_defs[rss_mem_id];
-               u32 num_entries = rss_defs->num_entries[dev_data->chip_id];
-               u32 entry_width = rss_defs->entry_width[dev_data->chip_id];
-               u32 total_dwords = (num_entries * entry_width) / 32;
-               u32 size = RSS_REG_RSS_RAM_DATA_SIZE;
-               bool packed = (entry_width == 16);
-               u32 rss_addr = rss_defs->addr;
-               u32 i, addr;
+               u32 rss_addr, num_entries, entry_width, total_dwords, i;
+               struct rss_mem_defs *rss_defs;
+               u32 addr, size;
+               bool packed;
+
+               rss_defs = &s_rss_mem_defs[rss_mem_id];
+               rss_addr = rss_defs->addr;
+               num_entries = rss_defs->num_entries[dev_data->chip_id];
+               entry_width = rss_defs->entry_width[dev_data->chip_id];
+               total_dwords = (num_entries * entry_width) / 32;
+               packed = (entry_width == 16);
 
                offset += qed_grc_dump_mem_hdr(p_hwfn,
                                               dump_buf + offset,
@@ -3263,23 +3552,23 @@ static u32 qed_grc_dump_rss(struct qed_hwfn *p_hwfn,
                                               packed,
                                               rss_defs->type_name, false, 0);
 
+               /* Dump RSS data */
                if (!dump) {
                        offset += total_dwords;
                        continue;
                }
 
-               /* Dump RSS data */
-               for (i = 0; i < total_dwords;
-                    i += RSS_REG_RSS_RAM_DATA_SIZE, rss_addr++) {
-                       addr = BYTES_TO_DWORDS(RSS_REG_RSS_RAM_DATA);
+               addr = BYTES_TO_DWORDS(RSS_REG_RSS_RAM_DATA);
+               size = RSS_REG_RSS_RAM_DATA_SIZE;
+               for (i = 0; i < total_dwords; i += size, rss_addr++) {
                        qed_wr(p_hwfn, p_ptt, RSS_REG_RSS_RAM_ADDR, rss_addr);
-                               offset += qed_grc_dump_addr_range(p_hwfn,
-                                                                 p_ptt,
-                                                                 dump_buf +
-                                                                 offset,
-                                                                 dump,
-                                                                 addr,
-                                                                 size);
+                       offset += qed_grc_dump_addr_range(p_hwfn,
+                                                         p_ptt,
+                                                         dump_buf + offset,
+                                                         dump,
+                                                         addr,
+                                                         size,
+                                                         false);
                }
        }
 
@@ -3316,10 +3605,11 @@ static u32 qed_grc_dump_big_ram(struct qed_hwfn *p_hwfn,
                                       BIG_RAM_BLOCK_SIZE_BYTES * 8,
                                       false, type_name, false, 0);
 
+       /* Read and dump Big RAM data */
        if (!dump)
                return offset + ram_size;
 
-       /* Read and dump Big RAM data */
+       /* Dump Big RAM */
        for (i = 0; i < total_blocks / 2; i++) {
                u32 addr, len;
 
@@ -3331,7 +3621,8 @@ static u32 qed_grc_dump_big_ram(struct qed_hwfn *p_hwfn,
                                                  dump_buf + offset,
                                                  dump,
                                                  addr,
-                                                 len);
+                                                 len,
+                                                 false);
        }
 
        return offset;
@@ -3359,7 +3650,7 @@ static u32 qed_grc_dump_mcp(struct qed_hwfn *p_hwfn,
                                   NULL,
                                   BYTES_TO_DWORDS(MCP_REG_SCRATCH),
                                   MCP_REG_SCRATCH_SIZE,
-                                  0, false, "MCP", false, 0);
+                                  false, 0, false, "MCP", false, 0);
 
        /* Dump MCP cpu_reg_file */
        offset += qed_grc_dump_mem(p_hwfn,
@@ -3369,7 +3660,7 @@ static u32 qed_grc_dump_mcp(struct qed_hwfn *p_hwfn,
                                   NULL,
                                   BYTES_TO_DWORDS(MCP_REG_CPU_REG_FILE),
                                   MCP_REG_CPU_REG_FILE_SIZE,
-                                  0, false, "MCP", false, 0);
+                                  false, 0, false, "MCP", false, 0);
 
        /* Dump MCP registers */
        block_enable[BLOCK_MCP] = true;
@@ -3387,11 +3678,13 @@ static u32 qed_grc_dump_mcp(struct qed_hwfn *p_hwfn,
                                         dump_buf + offset,
                                         dump,
                                         addr,
-                                        1);
+                                        1,
+                                        false);
 
        /* Release MCP */
        if (halted && qed_mcp_resume(p_hwfn, p_ptt))
                DP_NOTICE(p_hwfn, "Failed to resume MCP after halt!\n");
+
        return offset;
 }
 
@@ -3404,14 +3697,26 @@ static u32 qed_grc_dump_phy(struct qed_hwfn *p_hwfn,
        u8 phy_id;
 
        for (phy_id = 0; phy_id < ARRAY_SIZE(s_phy_defs); phy_id++) {
-               struct phy_defs *phy_defs = &s_phy_defs[phy_id];
-               int printed_chars;
-
-               printed_chars = snprintf(mem_name, sizeof(mem_name), "tbus_%s",
-                                        phy_defs->phy_name);
-               if (printed_chars < 0 || printed_chars >= sizeof(mem_name))
+               u32 addr_lo_addr, addr_hi_addr, data_lo_addr, data_hi_addr;
+               struct phy_defs *phy_defs;
+               u8 *bytes_buf;
+
+               phy_defs = &s_phy_defs[phy_id];
+               addr_lo_addr = phy_defs->base_addr +
+                              phy_defs->tbus_addr_lo_addr;
+               addr_hi_addr = phy_defs->base_addr +
+                              phy_defs->tbus_addr_hi_addr;
+               data_lo_addr = phy_defs->base_addr +
+                              phy_defs->tbus_data_lo_addr;
+               data_hi_addr = phy_defs->base_addr +
+                              phy_defs->tbus_data_hi_addr;
+               bytes_buf = (u8 *)(dump_buf + offset);
+
+               if (snprintf(mem_name, sizeof(mem_name), "tbus_%s",
+                            phy_defs->phy_name) < 0)
                        DP_NOTICE(p_hwfn,
                                  "Unexpected debug error: invalid PHY memory name\n");
+
                offset += qed_grc_dump_mem_hdr(p_hwfn,
                                               dump_buf + offset,
                                               dump,
@@ -3419,34 +3724,26 @@ static u32 qed_grc_dump_phy(struct qed_hwfn *p_hwfn,
                                               0,
                                               PHY_DUMP_SIZE_DWORDS,
                                               16, true, mem_name, false, 0);
-               if (dump) {
-                       u32 addr_lo_addr = phy_defs->base_addr +
-                                          phy_defs->tbus_addr_lo_addr;
-                       u32 addr_hi_addr = phy_defs->base_addr +
-                                          phy_defs->tbus_addr_hi_addr;
-                       u32 data_lo_addr = phy_defs->base_addr +
-                                          phy_defs->tbus_data_lo_addr;
-                       u32 data_hi_addr = phy_defs->base_addr +
-                                          phy_defs->tbus_data_hi_addr;
-                       u8 *bytes_buf = (u8 *)(dump_buf + offset);
-
-                       for (tbus_hi_offset = 0;
-                            tbus_hi_offset < (NUM_PHY_TBUS_ADDRESSES >> 8);
-                            tbus_hi_offset++) {
+
+               if (!dump) {
+                       offset += PHY_DUMP_SIZE_DWORDS;
+                       continue;
+               }
+
+               for (tbus_hi_offset = 0;
+                    tbus_hi_offset < (NUM_PHY_TBUS_ADDRESSES >> 8);
+                    tbus_hi_offset++) {
+                       qed_wr(p_hwfn, p_ptt, addr_hi_addr, tbus_hi_offset);
+                       for (tbus_lo_offset = 0; tbus_lo_offset < 256;
+                            tbus_lo_offset++) {
                                qed_wr(p_hwfn,
-                                      p_ptt, addr_hi_addr, tbus_hi_offset);
-                               for (tbus_lo_offset = 0; tbus_lo_offset < 256;
-                                    tbus_lo_offset++) {
-                                       qed_wr(p_hwfn,
-                                              p_ptt,
-                                              addr_lo_addr, tbus_lo_offset);
-                                       *(bytes_buf++) =
-                                               (u8)qed_rd(p_hwfn, p_ptt,
-                                                          data_lo_addr);
-                                       *(bytes_buf++) =
-                                               (u8)qed_rd(p_hwfn, p_ptt,
-                                                          data_hi_addr);
-                               }
+                                      p_ptt, addr_lo_addr, tbus_lo_offset);
+                               *(bytes_buf++) = (u8)qed_rd(p_hwfn,
+                                                           p_ptt,
+                                                           data_lo_addr);
+                               *(bytes_buf++) = (u8)qed_rd(p_hwfn,
+                                                           p_ptt,
+                                                           data_hi_addr);
                        }
                }
 
@@ -3460,16 +3757,17 @@ static void qed_config_dbg_line(struct qed_hwfn *p_hwfn,
                                struct qed_ptt *p_ptt,
                                enum block_id block_id,
                                u8 line_id,
-                               u8 cycle_en,
-                               u8 right_shift, u8 force_valid, u8 force_frame)
+                               u8 enable_mask,
+                               u8 right_shift,
+                               u8 force_valid_mask, u8 force_frame_mask)
 {
-       struct block_defs *p_block_defs = s_block_defs[block_id];
+       struct block_defs *block = s_block_defs[block_id];
 
-       qed_wr(p_hwfn, p_ptt, p_block_defs->dbg_select_addr, line_id);
-       qed_wr(p_hwfn, p_ptt, p_block_defs->dbg_cycle_enable_addr, cycle_en);
-       qed_wr(p_hwfn, p_ptt, p_block_defs->dbg_shift_addr, right_shift);
-       qed_wr(p_hwfn, p_ptt, p_block_defs->dbg_force_valid_addr, force_valid);
-       qed_wr(p_hwfn, p_ptt, p_block_defs->dbg_force_frame_addr, force_frame);
+       qed_wr(p_hwfn, p_ptt, block->dbg_select_addr, line_id);
+       qed_wr(p_hwfn, p_ptt, block->dbg_enable_addr, enable_mask);
+       qed_wr(p_hwfn, p_ptt, block->dbg_shift_addr, right_shift);
+       qed_wr(p_hwfn, p_ptt, block->dbg_force_valid_addr, force_valid_mask);
+       qed_wr(p_hwfn, p_ptt, block->dbg_force_frame_addr, force_frame_mask);
 }
 
 /* Dumps Static Debug data. Returns the dumped size in dwords. */
@@ -3477,10 +3775,12 @@ static u32 qed_grc_dump_static_debug(struct qed_hwfn *p_hwfn,
                                     struct qed_ptt *p_ptt,
                                     u32 *dump_buf, bool dump)
 {
-       u32 block_dwords = NUM_DBG_BUS_LINES * STATIC_DEBUG_LINE_DWORDS;
        struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
-       u32 offset = 0, block_id, line_id;
-       struct block_defs *p_block_defs;
+       u32 block_id, line_id, offset = 0;
+
+       /* Skip static debug if a debug bus recording is in progress */
+       if (qed_rd(p_hwfn, p_ptt, DBG_REG_DBG_BLOCK_ON))
+               return 0;
 
        if (dump) {
                DP_VERBOSE(p_hwfn,
@@ -3488,11 +3788,11 @@ static u32 qed_grc_dump_static_debug(struct qed_hwfn *p_hwfn,
 
                /* Disable all blocks debug output */
                for (block_id = 0; block_id < MAX_BLOCK_ID; block_id++) {
-                       p_block_defs = s_block_defs[block_id];
+                       struct block_defs *block = s_block_defs[block_id];
 
-                       if (p_block_defs->has_dbg_bus[dev_data->chip_id])
-                               qed_wr(p_hwfn, p_ptt,
-                                      p_block_defs->dbg_cycle_enable_addr, 0);
+                       if (block->has_dbg_bus[dev_data->chip_id])
+                               qed_wr(p_hwfn, p_ptt, block->dbg_enable_addr,
+                                      0);
                }
 
                qed_bus_reset_dbg_block(p_hwfn, p_ptt);
@@ -3506,59 +3806,71 @@ static u32 qed_grc_dump_static_debug(struct qed_hwfn *p_hwfn,
 
        /* Dump all static debug lines for each relevant block */
        for (block_id = 0; block_id < MAX_BLOCK_ID; block_id++) {
-               p_block_defs = s_block_defs[block_id];
+               struct block_defs *block = s_block_defs[block_id];
+               struct dbg_bus_block *block_desc;
+               u32 block_dwords, addr, len;
+               u8 dbg_client_id;
 
-               if (!p_block_defs->has_dbg_bus[dev_data->chip_id])
+               if (!block->has_dbg_bus[dev_data->chip_id])
                        continue;
 
+               block_desc =
+                       get_dbg_bus_block_desc(p_hwfn,
+                                              (enum block_id)block_id);
+               block_dwords = NUM_DBG_LINES(block_desc) *
+                              STATIC_DEBUG_LINE_DWORDS;
+
                /* Dump static section params */
                offset += qed_grc_dump_mem_hdr(p_hwfn,
                                               dump_buf + offset,
                                               dump,
-                                              p_block_defs->name, 0,
-                                              block_dwords, 32, false,
-                                              "STATIC", false, 0);
-
-               if (dump && !dev_data->block_in_reset[block_id]) {
-                       u8 dbg_client_id =
-                               p_block_defs->dbg_client_id[dev_data->chip_id];
-                       u32 addr = BYTES_TO_DWORDS(DBG_REG_CALENDAR_OUT_DATA);
-                       u32 len = STATIC_DEBUG_LINE_DWORDS;
-
-                       /* Enable block's client */
-                       qed_bus_enable_clients(p_hwfn, p_ptt,
-                                              BIT(dbg_client_id));
-
-                       for (line_id = 0; line_id < NUM_DBG_BUS_LINES;
-                            line_id++) {
-                               /* Configure debug line ID */
-                               qed_config_dbg_line(p_hwfn,
-                                                   p_ptt,
-                                                   (enum block_id)block_id,
-                                                   (u8)line_id,
-                                                   0xf, 0, 0, 0);
+                                              block->name,
+                                              0,
+                                              block_dwords,
+                                              32, false, "STATIC", false, 0);
 
-                               /* Read debug line info */
-                               offset +=
-                                   qed_grc_dump_addr_range(p_hwfn,
-                                                           p_ptt,
-                                                           dump_buf + offset,
-                                                           dump,
-                                                           addr,
-                                                           len);
-                       }
+               if (!dump) {
+                       offset += block_dwords;
+                       continue;
+               }
 
-                       /* Disable block's client and debug output */
-                       qed_bus_enable_clients(p_hwfn, p_ptt, 0);
-                       qed_wr(p_hwfn, p_ptt,
-                              p_block_defs->dbg_cycle_enable_addr, 0);
-               } else {
-                       /* All lines are invalid - dump zeros */
-                       if (dump)
-                               memset(dump_buf + offset, 0,
-                                      DWORDS_TO_BYTES(block_dwords));
+               /* If all lines are invalid - dump zeros */
+               if (dev_data->block_in_reset[block_id]) {
+                       memset(dump_buf + offset, 0,
+                              DWORDS_TO_BYTES(block_dwords));
                        offset += block_dwords;
+                       continue;
+               }
+
+               /* Enable block's client */
+               dbg_client_id = block->dbg_client_id[dev_data->chip_id];
+               qed_bus_enable_clients(p_hwfn,
+                                      p_ptt,
+                                      BIT(dbg_client_id));
+
+               addr = BYTES_TO_DWORDS(DBG_REG_CALENDAR_OUT_DATA);
+               len = STATIC_DEBUG_LINE_DWORDS;
+               for (line_id = 0; line_id < (u32)NUM_DBG_LINES(block_desc);
+                    line_id++) {
+                       /* Configure debug line ID */
+                       qed_config_dbg_line(p_hwfn,
+                                           p_ptt,
+                                           (enum block_id)block_id,
+                                           (u8)line_id, 0xf, 0, 0, 0);
+
+                       /* Read debug line info */
+                       offset += qed_grc_dump_addr_range(p_hwfn,
+                                                         p_ptt,
+                                                         dump_buf + offset,
+                                                         dump,
+                                                         addr,
+                                                         len,
+                                                         true);
                }
+
+               /* Disable block's client and debug output */
+               qed_bus_enable_clients(p_hwfn, p_ptt, 0);
+               qed_wr(p_hwfn, p_ptt, block->dbg_enable_addr, 0);
        }
 
        if (dump) {
@@ -3584,8 +3896,8 @@ static enum dbg_status qed_grc_dump(struct qed_hwfn *p_hwfn,
 
        *num_dumped_dwords = 0;
 
-       /* Find port mode */
        if (dump) {
+               /* Find port mode */
                switch (qed_rd(p_hwfn, p_ptt, MISC_REG_PORT_MODE)) {
                case 0:
                        port_mode = 1;
@@ -3597,11 +3909,10 @@ static enum dbg_status qed_grc_dump(struct qed_hwfn *p_hwfn,
                        port_mode = 4;
                        break;
                }
-       }
 
-       /* Update reset state */
-       if (dump)
+               /* Update reset state */
                qed_update_blocks_reset_state(p_hwfn, p_ptt);
+       }
 
        /* Dump global params */
        offset += qed_dump_common_global_params(p_hwfn,
@@ -3635,7 +3946,8 @@ static enum dbg_status qed_grc_dump(struct qed_hwfn *p_hwfn,
        }
 
        /* Disable all parities using MFW command */
-       if (dump && !qed_grc_get_param(p_hwfn, DBG_GRC_PARAM_NO_MCP)) {
+       if (dump &&
+           !qed_grc_get_param(p_hwfn, DBG_GRC_PARAM_NO_MCP)) {
                parities_masked = !qed_mcp_mask_parities(p_hwfn, p_ptt, 1);
                if (!parities_masked) {
                        DP_NOTICE(p_hwfn,
@@ -3661,9 +3973,9 @@ static enum dbg_status qed_grc_dump(struct qed_hwfn *p_hwfn,
 
        /* Dump all regs  */
        if (qed_grc_is_included(p_hwfn, DBG_GRC_PARAM_DUMP_REGS)) {
-               /* Dump all blocks except MCP */
                bool block_enable[MAX_BLOCK_ID];
 
+               /* Dump all blocks except MCP */
                for (i = 0; i < MAX_BLOCK_ID; i++)
                        block_enable[i] = true;
                block_enable[BLOCK_MCP] = false;
@@ -3732,7 +4044,8 @@ static enum dbg_status qed_grc_dump(struct qed_hwfn *p_hwfn,
                                                    dump_buf + offset, dump);
 
        /* Dump last section */
-       offset += qed_dump_last_section(dump_buf, offset, dump);
+       offset += qed_dump_last_section(p_hwfn, dump_buf, offset, dump);
+
        if (dump) {
                /* Unstall storms */
                if (qed_grc_get_param(p_hwfn, DBG_GRC_PARAM_UNSTALL))
@@ -3763,19 +4076,20 @@ static u32 qed_idle_chk_dump_failure(struct qed_hwfn *p_hwfn,
                                     const struct dbg_idle_chk_rule *rule,
                                     u16 fail_entry_id, u32 *cond_reg_values)
 {
-       const union dbg_idle_chk_reg *regs = &((const union dbg_idle_chk_reg *)
-                                              s_dbg_arrays
-                                              [BIN_BUF_DBG_IDLE_CHK_REGS].
-                                              ptr)[rule->reg_offset];
-       const struct dbg_idle_chk_cond_reg *cond_regs = &regs[0].cond_reg;
        struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
-       struct dbg_idle_chk_result_hdr *hdr =
-               (struct dbg_idle_chk_result_hdr *)dump_buf;
-       const struct dbg_idle_chk_info_reg *info_regs =
-               &regs[rule->num_cond_regs].info_reg;
-       u32 next_reg_offset = 0, i, offset = 0;
+       const struct dbg_idle_chk_cond_reg *cond_regs;
+       const struct dbg_idle_chk_info_reg *info_regs;
+       u32 i, next_reg_offset = 0, offset = 0;
+       struct dbg_idle_chk_result_hdr *hdr;
+       const union dbg_idle_chk_reg *regs;
        u8 reg_id;
 
+       hdr = (struct dbg_idle_chk_result_hdr *)dump_buf;
+       regs = &((const union dbg_idle_chk_reg *)
+                s_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_REGS].ptr)[rule->reg_offset];
+       cond_regs = &regs[0].cond_reg;
+       info_regs = &regs[rule->num_cond_regs].info_reg;
+
        /* Dump rule data */
        if (dump) {
                memset(hdr, 0, sizeof(*hdr));
@@ -3790,33 +4104,31 @@ static u32 qed_idle_chk_dump_failure(struct qed_hwfn *p_hwfn,
        /* Dump condition register values */
        for (reg_id = 0; reg_id < rule->num_cond_regs; reg_id++) {
                const struct dbg_idle_chk_cond_reg *reg = &cond_regs[reg_id];
+               struct dbg_idle_chk_result_reg_hdr *reg_hdr;
 
-               /* Write register header */
-               if (dump) {
-                       struct dbg_idle_chk_result_reg_hdr *reg_hdr =
-                           (struct dbg_idle_chk_result_reg_hdr *)(dump_buf
-                                                                  + offset);
-                       offset += IDLE_CHK_RESULT_REG_HDR_DWORDS;
-                       memset(reg_hdr, 0,
-                              sizeof(struct dbg_idle_chk_result_reg_hdr));
-                       reg_hdr->start_entry = reg->start_entry;
-                       reg_hdr->size = reg->entry_size;
-                       SET_FIELD(reg_hdr->data,
-                                 DBG_IDLE_CHK_RESULT_REG_HDR_IS_MEM,
-                                 reg->num_entries > 1 || reg->start_entry > 0
-                                 ? 1 : 0);
-                       SET_FIELD(reg_hdr->data,
-                                 DBG_IDLE_CHK_RESULT_REG_HDR_REG_ID, reg_id);
+               reg_hdr = (struct dbg_idle_chk_result_reg_hdr *)
+                         (dump_buf + offset);
 
-                       /* Write register values */
-                       for (i = 0; i < reg_hdr->size;
-                            i++, next_reg_offset++, offset++)
-                               dump_buf[offset] =
-                                   cond_reg_values[next_reg_offset];
-               } else {
+               /* Write register header */
+               if (!dump) {
                        offset += IDLE_CHK_RESULT_REG_HDR_DWORDS +
                            reg->entry_size;
+                       continue;
                }
+
+               offset += IDLE_CHK_RESULT_REG_HDR_DWORDS;
+               memset(reg_hdr, 0, sizeof(*reg_hdr));
+               reg_hdr->start_entry = reg->start_entry;
+               reg_hdr->size = reg->entry_size;
+               SET_FIELD(reg_hdr->data,
+                         DBG_IDLE_CHK_RESULT_REG_HDR_IS_MEM,
+                         reg->num_entries > 1 || reg->start_entry > 0 ? 1 : 0);
+               SET_FIELD(reg_hdr->data,
+                         DBG_IDLE_CHK_RESULT_REG_HDR_REG_ID, reg_id);
+
+               /* Write register values */
+               for (i = 0; i < reg_hdr->size; i++, next_reg_offset++, offset++)
+                       dump_buf[offset] = cond_reg_values[next_reg_offset];
        }
 
        /* Dump info register values */
@@ -3824,12 +4136,12 @@ static u32 qed_idle_chk_dump_failure(struct qed_hwfn *p_hwfn,
                const struct dbg_idle_chk_info_reg *reg = &info_regs[reg_id];
                u32 block_id;
 
+               /* Check if register's block is in reset */
                if (!dump) {
                        offset += IDLE_CHK_RESULT_REG_HDR_DWORDS + reg->size;
                        continue;
                }
 
-               /* Check if register's block is in reset */
                block_id = GET_FIELD(reg->data, DBG_IDLE_CHK_INFO_REG_BLOCK_ID);
                if (block_id >= MAX_BLOCK_ID) {
                        DP_NOTICE(p_hwfn, "Invalid block_id\n");
@@ -3837,47 +4149,50 @@ static u32 qed_idle_chk_dump_failure(struct qed_hwfn *p_hwfn,
                }
 
                if (!dev_data->block_in_reset[block_id]) {
-                       bool eval_mode = GET_FIELD(reg->mode.data,
-                                                  DBG_MODE_HDR_EVAL_MODE) > 0;
-                       bool mode_match = true;
+                       struct dbg_idle_chk_result_reg_hdr *reg_hdr;
+                       bool wide_bus, eval_mode, mode_match = true;
+                       u16 modes_buf_offset;
+                       u32 addr;
+
+                       reg_hdr = (struct dbg_idle_chk_result_reg_hdr *)
+                                 (dump_buf + offset);
 
                        /* Check mode */
+                       eval_mode = GET_FIELD(reg->mode.data,
+                                             DBG_MODE_HDR_EVAL_MODE) > 0;
                        if (eval_mode) {
-                               u16 modes_buf_offset =
-                                       GET_FIELD(reg->mode.data,
-                                               DBG_MODE_HDR_MODES_BUF_OFFSET);
+                               modes_buf_offset =
+                                   GET_FIELD(reg->mode.data,
+                                             DBG_MODE_HDR_MODES_BUF_OFFSET);
                                mode_match =
                                        qed_is_mode_match(p_hwfn,
                                                          &modes_buf_offset);
                        }
 
-                       if (mode_match) {
-                               u32 addr =
-                                   GET_FIELD(reg->data,
-                                             DBG_IDLE_CHK_INFO_REG_ADDRESS);
-
-                               /* Write register header */
-                               struct dbg_idle_chk_result_reg_hdr *reg_hdr =
-                                       (struct dbg_idle_chk_result_reg_hdr *)
-                                       (dump_buf + offset);
-
-                               offset += IDLE_CHK_RESULT_REG_HDR_DWORDS;
-                               hdr->num_dumped_info_regs++;
-                               memset(reg_hdr, 0, sizeof(*reg_hdr));
-                               reg_hdr->size = reg->size;
-                               SET_FIELD(reg_hdr->data,
-                                         DBG_IDLE_CHK_RESULT_REG_HDR_REG_ID,
-                                         rule->num_cond_regs + reg_id);
-
-                               /* Write register values */
-                               offset +=
-                                   qed_grc_dump_addr_range(p_hwfn,
-                                                           p_ptt,
-                                                           dump_buf + offset,
-                                                           dump,
-                                                           addr,
-                                                           reg->size);
-                       }
+                       if (!mode_match)
+                               continue;
+
+                       addr = GET_FIELD(reg->data,
+                                        DBG_IDLE_CHK_INFO_REG_ADDRESS);
+                       wide_bus = GET_FIELD(reg->data,
+                                            DBG_IDLE_CHK_INFO_REG_WIDE_BUS);
+
+                       /* Write register header */
+                       offset += IDLE_CHK_RESULT_REG_HDR_DWORDS;
+                       hdr->num_dumped_info_regs++;
+                       memset(reg_hdr, 0, sizeof(*reg_hdr));
+                       reg_hdr->size = reg->size;
+                       SET_FIELD(reg_hdr->data,
+                                 DBG_IDLE_CHK_RESULT_REG_HDR_REG_ID,
+                                 rule->num_cond_regs + reg_id);
+
+                       /* Write register values */
+                       offset += qed_grc_dump_addr_range(p_hwfn,
+                                                         p_ptt,
+                                                         dump_buf + offset,
+                                                         dump,
+                                                         addr,
+                                                         reg->size, wide_bus);
                }
        }
 
@@ -3898,6 +4213,7 @@ qed_idle_chk_dump_rule_entries(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
        u8 reg_id;
 
        *num_failing_rules = 0;
+
        for (i = 0; i < num_input_rules; i++) {
                const struct dbg_idle_chk_cond_reg *cond_regs;
                const struct dbg_idle_chk_rule *rule;
@@ -3920,8 +4236,9 @@ qed_idle_chk_dump_rule_entries(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
                 */
                for (reg_id = 0; reg_id < rule->num_cond_regs && check_rule;
                     reg_id++) {
-                       u32 block_id = GET_FIELD(cond_regs[reg_id].data,
-                                               DBG_IDLE_CHK_COND_REG_BLOCK_ID);
+                       u32 block_id =
+                               GET_FIELD(cond_regs[reg_id].data,
+                                         DBG_IDLE_CHK_COND_REG_BLOCK_ID);
 
                        if (block_id >= MAX_BLOCK_ID) {
                                DP_NOTICE(p_hwfn, "Invalid block_id\n");
@@ -3936,48 +4253,47 @@ qed_idle_chk_dump_rule_entries(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
                if (!check_rule && dump)
                        continue;
 
-               if (!dump) {
-                       u32 entry_dump_size =
-                               qed_idle_chk_dump_failure(p_hwfn,
-                                                         p_ptt,
-                                                         dump_buf + offset,
-                                                         false,
-                                                         rule->rule_id,
-                                                         rule,
-                                                         0,
-                                                         NULL);
-
-                       offset += num_reg_entries * entry_dump_size;
-                       (*num_failing_rules) += num_reg_entries;
-                       continue;
-               }
-
                /* Go over all register entries (number of entries is the same
                 * for all condition registers).
                 */
                for (entry_id = 0; entry_id < num_reg_entries; entry_id++) {
-                       /* Read current entry of all condition registers */
                        u32 next_reg_offset = 0;
 
+                       if (!dump) {
+                               offset += qed_idle_chk_dump_failure(p_hwfn,
+                                                       p_ptt,
+                                                       dump_buf + offset,
+                                                       false,
+                                                       rule->rule_id,
+                                                       rule,
+                                                       entry_id,
+                                                       NULL);
+                               (*num_failing_rules)++;
+                               break;
+                       }
+
+                       /* Read current entry of all condition registers */
                        for (reg_id = 0; reg_id < rule->num_cond_regs;
                             reg_id++) {
                                const struct dbg_idle_chk_cond_reg *reg =
-                                       &cond_regs[reg_id];
+                                   &cond_regs[reg_id];
+                               u32 padded_entry_size, addr;
+                               bool wide_bus;
 
-                               /* Find GRC address (if it's a memory,the
+                               /* Find GRC address (if it's a memory, the
                                 * address of the specific entry is calculated).
                                 */
-                               u32 addr =
+                               addr = GET_FIELD(reg->data,
+                                                DBG_IDLE_CHK_COND_REG_ADDRESS);
+                               wide_bus =
                                    GET_FIELD(reg->data,
-                                             DBG_IDLE_CHK_COND_REG_ADDRESS);
-
+                                             DBG_IDLE_CHK_COND_REG_WIDE_BUS);
                                if (reg->num_entries > 1 ||
                                    reg->start_entry > 0) {
-                                       u32 padded_entry_size =
-                                          reg->entry_size > 1 ?
-                                          roundup_pow_of_two(reg->entry_size) :
-                                          1;
-
+                                       padded_entry_size =
+                                           reg->entry_size > 1 ?
+                                           roundup_pow_of_two(reg->entry_size)
+                                           : 1;
                                        addr += (reg->start_entry + entry_id) *
                                                padded_entry_size;
                                }
@@ -3991,28 +4307,27 @@ qed_idle_chk_dump_rule_entries(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
                                }
 
                                next_reg_offset +=
-                                   qed_grc_dump_addr_range(p_hwfn,
-                                                           p_ptt,
+                                   qed_grc_dump_addr_range(p_hwfn, p_ptt,
                                                            cond_reg_values +
                                                            next_reg_offset,
                                                            dump, addr,
-                                                           reg->entry_size);
+                                                           reg->entry_size,
+                                                           wide_bus);
                        }
 
-                       /* Call rule's condition function - a return value of
-                        * true indicates failure.
+                       /* Call rule condition function.
+                        * If returns true, it's a failure.
                         */
-                       if ((*cond_arr[rule->cond_id])(cond_reg_values,
-                                                      imm_values)) {
-                               offset +=
-                                   qed_idle_chk_dump_failure(p_hwfn,
-                                                             p_ptt,
-                                                             dump_buf + offset,
-                                                             dump,
-                                                             rule->rule_id,
-                                                             rule,
-                                                             entry_id,
-                                                             cond_reg_values);
+                       if ((*cond_arr[rule->cond_id]) (cond_reg_values,
+                                                       imm_values)) {
+                               offset += qed_idle_chk_dump_failure(p_hwfn,
+                                                       p_ptt,
+                                                       dump_buf + offset,
+                                                       dump,
+                                                       rule->rule_id,
+                                                       rule,
+                                                       entry_id,
+                                                       cond_reg_values);
                                (*num_failing_rules)++;
                                break;
                        }
@@ -4028,8 +4343,8 @@ qed_idle_chk_dump_rule_entries(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
 static u32 qed_idle_chk_dump(struct qed_hwfn *p_hwfn,
                             struct qed_ptt *p_ptt, u32 *dump_buf, bool dump)
 {
-       u32 offset = 0, input_offset = 0, num_failing_rules = 0;
-       u32 num_failing_rules_offset;
+       u32 num_failing_rules_offset, offset = 0, input_offset = 0;
+       u32 num_failing_rules = 0;
 
        /* Dump global params */
        offset += qed_dump_common_global_params(p_hwfn,
@@ -4042,29 +4357,29 @@ static u32 qed_idle_chk_dump(struct qed_hwfn *p_hwfn,
        offset += qed_dump_section_hdr(dump_buf + offset, dump, "idle_chk", 1);
        num_failing_rules_offset = offset;
        offset += qed_dump_num_param(dump_buf + offset, dump, "num_rules", 0);
+
        while (input_offset <
               s_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_RULES].size_in_dwords) {
                const struct dbg_idle_chk_cond_hdr *cond_hdr =
                        (const struct dbg_idle_chk_cond_hdr *)
                        &s_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_RULES].ptr
                        [input_offset++];
-               bool eval_mode = GET_FIELD(cond_hdr->mode.data,
-                                          DBG_MODE_HDR_EVAL_MODE) > 0;
-               bool mode_match = true;
+               bool eval_mode, mode_match = true;
+               u32 curr_failing_rules;
+               u16 modes_buf_offset;
 
                /* Check mode */
+               eval_mode = GET_FIELD(cond_hdr->mode.data,
+                                     DBG_MODE_HDR_EVAL_MODE) > 0;
                if (eval_mode) {
-                       u16 modes_buf_offset =
+                       modes_buf_offset =
                                GET_FIELD(cond_hdr->mode.data,
                                          DBG_MODE_HDR_MODES_BUF_OFFSET);
-
                        mode_match = qed_is_mode_match(p_hwfn,
                                                       &modes_buf_offset);
                }
 
                if (mode_match) {
-                       u32 curr_failing_rules;
-
                        offset +=
                            qed_idle_chk_dump_rule_entries(p_hwfn,
                                p_ptt,
@@ -4086,10 +4401,13 @@ static u32 qed_idle_chk_dump(struct qed_hwfn *p_hwfn,
                qed_dump_num_param(dump_buf + num_failing_rules_offset,
                                   dump, "num_rules", num_failing_rules);
 
+       /* Dump last section */
+       offset += qed_dump_last_section(p_hwfn, dump_buf, offset, dump);
+
        return offset;
 }
 
-/* Finds the meta data image in NVRAM. */
+/* Finds the meta data image in NVRAM */
 static enum dbg_status qed_find_nvram_image(struct qed_hwfn *p_hwfn,
                                            struct qed_ptt *p_ptt,
                                            u32 image_type,
@@ -4098,16 +4416,16 @@ static enum dbg_status qed_find_nvram_image(struct qed_hwfn *p_hwfn,
 {
        u32 ret_mcp_resp, ret_mcp_param, ret_txn_size;
        struct mcp_file_att file_att;
+       int nvm_result;
 
        /* Call NVRAM get file command */
-       int nvm_result = qed_mcp_nvm_rd_cmd(p_hwfn,
-                                           p_ptt,
-                                           DRV_MSG_CODE_NVM_GET_FILE_ATT,
-                                           image_type,
-                                           &ret_mcp_resp,
-                                           &ret_mcp_param,
-                                           &ret_txn_size,
-                                           (u32 *)&file_att);
+       nvm_result = qed_mcp_nvm_rd_cmd(p_hwfn,
+                                       p_ptt,
+                                       DRV_MSG_CODE_NVM_GET_FILE_ATT,
+                                       image_type,
+                                       &ret_mcp_resp,
+                                       &ret_mcp_param,
+                                       &ret_txn_size, (u32 *)&file_att);
 
        /* Check response */
        if (nvm_result ||
@@ -4117,6 +4435,7 @@ static enum dbg_status qed_find_nvram_image(struct qed_hwfn *p_hwfn,
        /* Update return values */
        *nvram_offset_bytes = file_att.nvm_start_addr;
        *nvram_size_bytes = file_att.len;
+
        DP_VERBOSE(p_hwfn,
                   QED_MSG_DEBUG,
                   "find_nvram_image: found NVRAM image of type %d in NVRAM offset %d bytes with size %d bytes\n",
@@ -4125,22 +4444,25 @@ static enum dbg_status qed_find_nvram_image(struct qed_hwfn *p_hwfn,
        /* Check alignment */
        if (*nvram_size_bytes & 0x3)
                return DBG_STATUS_NON_ALIGNED_NVRAM_IMAGE;
+
        return DBG_STATUS_OK;
 }
 
+/* Reads data from NVRAM */
 static enum dbg_status qed_nvram_read(struct qed_hwfn *p_hwfn,
                                      struct qed_ptt *p_ptt,
                                      u32 nvram_offset_bytes,
                                      u32 nvram_size_bytes, u32 *ret_buf)
 {
-       u32 ret_mcp_resp, ret_mcp_param, ret_read_size;
-       u32 bytes_to_copy, read_offset = 0;
+       u32 ret_mcp_resp, ret_mcp_param, ret_read_size, bytes_to_copy;
        s32 bytes_left = nvram_size_bytes;
+       u32 read_offset = 0;
 
        DP_VERBOSE(p_hwfn,
                   QED_MSG_DEBUG,
                   "nvram_read: reading image of size %d bytes from NVRAM\n",
                   nvram_size_bytes);
+
        do {
                bytes_to_copy =
                    (bytes_left >
@@ -4155,8 +4477,7 @@ static enum dbg_status qed_nvram_read(struct qed_hwfn *p_hwfn,
                                        DRV_MB_PARAM_NVM_LEN_SHIFT),
                                       &ret_mcp_resp, &ret_mcp_param,
                                       &ret_read_size,
-                                      (u32 *)((u8 *)ret_buf +
-                                              read_offset)) != 0)
+                                      (u32 *)((u8 *)ret_buf + read_offset)))
                        return DBG_STATUS_NVRAM_READ_FAILED;
 
                /* Check response */
@@ -4172,24 +4493,20 @@ static enum dbg_status qed_nvram_read(struct qed_hwfn *p_hwfn,
 }
 
 /* Get info on the MCP Trace data in the scratchpad:
- * - trace_data_grc_addr - the GRC address of the trace data
- * - trace_data_size_bytes - the size in bytes of the MCP Trace data (without
- *     the header)
+ * - trace_data_grc_addr (OUT): trace data GRC address in bytes
+ * - trace_data_size (OUT): trace data size in bytes (without the header)
  */
 static enum dbg_status qed_mcp_trace_get_data_info(struct qed_hwfn *p_hwfn,
                                                   struct qed_ptt *p_ptt,
                                                   u32 *trace_data_grc_addr,
-                                                  u32 *trace_data_size_bytes)
+                                                  u32 *trace_data_size)
 {
-       /* Read MCP trace section offsize structure from MCP scratchpad */
-       u32 spad_trace_offsize = qed_rd(p_hwfn,
-                                       p_ptt,
-                                       MCP_SPAD_TRACE_OFFSIZE_ADDR);
-       u32 signature;
+       u32 spad_trace_offsize, signature;
 
-       /* Extract MCP trace section GRC address from offsize structure (within
-        * scratchpad).
-        */
+       /* Read trace section offsize structure from MCP scratchpad */
+       spad_trace_offsize = qed_rd(p_hwfn, p_ptt, MCP_SPAD_TRACE_OFFSIZE_ADDR);
+
+       /* Extract trace section address from offsize (in scratchpad) */
        *trace_data_grc_addr =
                MCP_REG_SCRATCH + SECTION_OFFSET(spad_trace_offsize);
 
@@ -4197,42 +4514,41 @@ static enum dbg_status qed_mcp_trace_get_data_info(struct qed_hwfn *p_hwfn,
        signature = qed_rd(p_hwfn, p_ptt,
                           *trace_data_grc_addr +
                           offsetof(struct mcp_trace, signature));
+
        if (signature != MFW_TRACE_SIGNATURE)
                return DBG_STATUS_INVALID_TRACE_SIGNATURE;
 
        /* Read trace size from MCP trace section */
-       *trace_data_size_bytes = qed_rd(p_hwfn,
-                                       p_ptt,
-                                       *trace_data_grc_addr +
-                                       offsetof(struct mcp_trace, size));
+       *trace_data_size = qed_rd(p_hwfn,
+                                 p_ptt,
+                                 *trace_data_grc_addr +
+                                 offsetof(struct mcp_trace, size));
+
        return DBG_STATUS_OK;
 }
 
-/* Reads MCP trace meta data image from NVRAM.
- * - running_bundle_id (OUT) - the running bundle ID (invalid when loaded from
- *     file)
- * - trace_meta_offset_bytes (OUT) - the NVRAM offset in bytes in which the MCP
- *     Trace meta data starts (invalid when loaded from file)
- * - trace_meta_size_bytes (OUT) - the size in bytes of the MCP Trace meta data
+/* Reads MCP trace meta data image from NVRAM
+ * - running_bundle_id (OUT): running bundle ID (invalid when loaded from file)
+ * - trace_meta_offset (OUT): trace meta offset in NVRAM in bytes (invalid when
+ *                           loaded from file).
+ * - trace_meta_size (OUT):   size in bytes of the trace meta data.
  */
 static enum dbg_status qed_mcp_trace_get_meta_info(struct qed_hwfn *p_hwfn,
                                                   struct qed_ptt *p_ptt,
                                                   u32 trace_data_size_bytes,
                                                   u32 *running_bundle_id,
-                                                  u32 *trace_meta_offset_bytes,
-                                                  u32 *trace_meta_size_bytes)
+                                                  u32 *trace_meta_offset,
+                                                  u32 *trace_meta_size)
 {
+       u32 spad_trace_offsize, nvram_image_type, running_mfw_addr;
+
        /* Read MCP trace section offsize structure from MCP scratchpad */
-       u32 spad_trace_offsize = qed_rd(p_hwfn,
-                                       p_ptt,
-                                       MCP_SPAD_TRACE_OFFSIZE_ADDR);
+       spad_trace_offsize = qed_rd(p_hwfn, p_ptt, MCP_SPAD_TRACE_OFFSIZE_ADDR);
 
        /* Find running bundle ID */
-       u32 running_mfw_addr =
+       running_mfw_addr =
                MCP_REG_SCRATCH + SECTION_OFFSET(spad_trace_offsize) +
                QED_SECTION_SIZE(spad_trace_offsize) + trace_data_size_bytes;
-       u32 nvram_image_type;
-
        *running_bundle_id = qed_rd(p_hwfn, p_ptt, running_mfw_addr);
        if (*running_bundle_id > 1)
                return DBG_STATUS_INVALID_NVRAM_BUNDLE;
@@ -4241,40 +4557,33 @@ static enum dbg_status qed_mcp_trace_get_meta_info(struct qed_hwfn *p_hwfn,
        nvram_image_type =
            (*running_bundle_id ==
             DIR_ID_1) ? NVM_TYPE_MFW_TRACE1 : NVM_TYPE_MFW_TRACE2;
-
        return qed_find_nvram_image(p_hwfn,
                                    p_ptt,
                                    nvram_image_type,
-                                   trace_meta_offset_bytes,
-                                   trace_meta_size_bytes);
+                                   trace_meta_offset, trace_meta_size);
 }
 
-/* Reads the MCP Trace meta data (from NVRAM or buffer) into the specified
- * buffer.
- */
+/* Reads the MCP Trace meta data from NVRAM into the specified buffer */
 static enum dbg_status qed_mcp_trace_read_meta(struct qed_hwfn *p_hwfn,
                                               struct qed_ptt *p_ptt,
                                               u32 nvram_offset_in_bytes,
                                               u32 size_in_bytes, u32 *buf)
 {
-       u8 *byte_buf = (u8 *)buf;
-       u8 modules_num, i;
+       u8 modules_num, module_len, i, *byte_buf = (u8 *)buf;
+       enum dbg_status status;
        u32 signature;
 
        /* Read meta data from NVRAM */
-       enum dbg_status status = qed_nvram_read(p_hwfn,
-                                               p_ptt,
-                                               nvram_offset_in_bytes,
-                                               size_in_bytes,
-                                               buf);
-
+       status = qed_nvram_read(p_hwfn,
+                               p_ptt,
+                               nvram_offset_in_bytes, size_in_bytes, buf);
        if (status != DBG_STATUS_OK)
                return status;
 
        /* Extract and check first signature */
        signature = qed_read_unaligned_dword(byte_buf);
-       byte_buf += sizeof(u32);
-       if (signature != MCP_TRACE_META_IMAGE_SIGNATURE)
+       byte_buf += sizeof(signature);
+       if (signature != NVM_MAGIC_VALUE)
                return DBG_STATUS_INVALID_TRACE_SIGNATURE;
 
        /* Extract number of modules */
@@ -4282,16 +4591,16 @@ static enum dbg_status qed_mcp_trace_read_meta(struct qed_hwfn *p_hwfn,
 
        /* Skip all modules */
        for (i = 0; i < modules_num; i++) {
-               u8 module_len = *(byte_buf++);
-
+               module_len = *(byte_buf++);
                byte_buf += module_len;
        }
 
        /* Extract and check second signature */
        signature = qed_read_unaligned_dword(byte_buf);
-       byte_buf += sizeof(u32);
-       if (signature != MCP_TRACE_META_IMAGE_SIGNATURE)
+       byte_buf += sizeof(signature);
+       if (signature != NVM_MAGIC_VALUE)
                return DBG_STATUS_INVALID_TRACE_SIGNATURE;
+
        return DBG_STATUS_OK;
 }
 
@@ -4308,10 +4617,10 @@ static enum dbg_status qed_mcp_trace_dump(struct qed_hwfn *p_hwfn,
        bool mcp_access;
        int halted = 0;
 
-       mcp_access = !qed_grc_get_param(p_hwfn, DBG_GRC_PARAM_NO_MCP);
-
        *num_dumped_dwords = 0;
 
+       mcp_access = !qed_grc_get_param(p_hwfn, DBG_GRC_PARAM_NO_MCP);
+
        /* Get trace data info */
        status = qed_mcp_trace_get_data_info(p_hwfn,
                                             p_ptt,
@@ -4328,7 +4637,7 @@ static enum dbg_status qed_mcp_trace_dump(struct qed_hwfn *p_hwfn,
                                     dump, "dump-type", "mcp-trace");
 
        /* Halt MCP while reading from scratchpad so the read data will be
-        * consistent if halt fails, MCP trace is taken anyway, with a small
+        * consistent. if halt fails, MCP trace is taken anyway, with a small
         * risk that it may be corrupt.
         */
        if (dump && mcp_access) {
@@ -4339,8 +4648,8 @@ static enum dbg_status qed_mcp_trace_dump(struct qed_hwfn *p_hwfn,
 
        /* Find trace data size */
        trace_data_size_dwords =
-               DIV_ROUND_UP(trace_data_size_bytes + sizeof(struct mcp_trace),
-                            BYTES_IN_DWORD);
+           DIV_ROUND_UP(trace_data_size_bytes + sizeof(struct mcp_trace),
+                        BYTES_IN_DWORD);
 
        /* Dump trace data section header and param */
        offset += qed_dump_section_hdr(dump_buf + offset,
@@ -4354,17 +4663,17 @@ static enum dbg_status qed_mcp_trace_dump(struct qed_hwfn *p_hwfn,
                                          dump_buf + offset,
                                          dump,
                                          BYTES_TO_DWORDS(trace_data_grc_addr),
-                                         trace_data_size_dwords);
+                                         trace_data_size_dwords, false);
 
        /* Resume MCP (only if halt succeeded) */
-       if (halted && qed_mcp_resume(p_hwfn, p_ptt) != 0)
+       if (halted && qed_mcp_resume(p_hwfn, p_ptt))
                DP_NOTICE(p_hwfn, "Failed to resume MCP after halt!\n");
 
        /* Dump trace meta section header */
        offset += qed_dump_section_hdr(dump_buf + offset,
                                       dump, "mcp_trace_meta", 1);
 
-       /* Read trace meta info */
+       /* Read trace meta info (trace_meta_size_bytes is dword-aligned) */
        if (mcp_access) {
                status = qed_mcp_trace_get_meta_info(p_hwfn,
                                                     p_ptt,
@@ -4391,6 +4700,9 @@ static enum dbg_status qed_mcp_trace_dump(struct qed_hwfn *p_hwfn,
        if (status == DBG_STATUS_OK)
                offset += trace_meta_size_dwords;
 
+       /* Dump last section */
+       offset += qed_dump_last_section(p_hwfn, dump_buf, offset, dump);
+
        *num_dumped_dwords = offset;
 
        /* If no mcp access, indicate that the dump doesn't contain the meta
@@ -4405,7 +4717,7 @@ static enum dbg_status qed_reg_fifo_dump(struct qed_hwfn *p_hwfn,
                                         u32 *dump_buf,
                                         bool dump, u32 *num_dumped_dwords)
 {
-       u32 offset = 0, dwords_read, size_param_offset;
+       u32 dwords_read, size_param_offset, offset = 0;
        bool fifo_has_data;
 
        *num_dumped_dwords = 0;
@@ -4417,8 +4729,8 @@ static enum dbg_status qed_reg_fifo_dump(struct qed_hwfn *p_hwfn,
        offset += qed_dump_str_param(dump_buf + offset,
                                     dump, "dump-type", "reg-fifo");
 
-       /* Dump fifo data section header and param. The size param is 0 for now,
-        * and is overwritten after reading the FIFO.
+       /* Dump fifo data section header and param. The size param is 0 for
+        * now, and is overwritten after reading the FIFO.
         */
        offset += qed_dump_section_hdr(dump_buf + offset,
                                       dump, "reg_fifo_data", 1);
@@ -4430,8 +4742,7 @@ static enum dbg_status qed_reg_fifo_dump(struct qed_hwfn *p_hwfn,
                 * test how much data is available, except for reading it.
                 */
                offset += REG_FIFO_DEPTH_DWORDS;
-               *num_dumped_dwords = offset;
-               return DBG_STATUS_OK;
+               goto out;
        }
 
        fifo_has_data = qed_rd(p_hwfn, p_ptt,
@@ -4456,8 +4767,12 @@ static enum dbg_status qed_reg_fifo_dump(struct qed_hwfn *p_hwfn,
 
        qed_dump_num_param(dump_buf + size_param_offset, dump, "size",
                           dwords_read);
+out:
+       /* Dump last section */
+       offset += qed_dump_last_section(p_hwfn, dump_buf, offset, dump);
 
        *num_dumped_dwords = offset;
+
        return DBG_STATUS_OK;
 }
 
@@ -4467,7 +4782,7 @@ static enum dbg_status qed_igu_fifo_dump(struct qed_hwfn *p_hwfn,
                                         u32 *dump_buf,
                                         bool dump, u32 *num_dumped_dwords)
 {
-       u32 offset = 0, dwords_read, size_param_offset;
+       u32 dwords_read, size_param_offset, offset = 0;
        bool fifo_has_data;
 
        *num_dumped_dwords = 0;
@@ -4479,8 +4794,8 @@ static enum dbg_status qed_igu_fifo_dump(struct qed_hwfn *p_hwfn,
        offset += qed_dump_str_param(dump_buf + offset,
                                     dump, "dump-type", "igu-fifo");
 
-       /* Dump fifo data section header and param. The size param is 0 for now,
-        * and is overwritten after reading the FIFO.
+       /* Dump fifo data section header and param. The size param is 0 for
+        * now, and is overwritten after reading the FIFO.
         */
        offset += qed_dump_section_hdr(dump_buf + offset,
                                       dump, "igu_fifo_data", 1);
@@ -4492,8 +4807,7 @@ static enum dbg_status qed_igu_fifo_dump(struct qed_hwfn *p_hwfn,
                 * test how much data is available, except for reading it.
                 */
                offset += IGU_FIFO_DEPTH_DWORDS;
-               *num_dumped_dwords = offset;
-               return DBG_STATUS_OK;
+               goto out;
        }
 
        fifo_has_data = qed_rd(p_hwfn, p_ptt,
@@ -4519,8 +4833,12 @@ static enum dbg_status qed_igu_fifo_dump(struct qed_hwfn *p_hwfn,
 
        qed_dump_num_param(dump_buf + size_param_offset, dump, "size",
                           dwords_read);
+out:
+       /* Dump last section */
+       offset += qed_dump_last_section(p_hwfn, dump_buf, offset, dump);
 
        *num_dumped_dwords = offset;
+
        return DBG_STATUS_OK;
 }
 
@@ -4531,7 +4849,7 @@ static enum dbg_status qed_protection_override_dump(struct qed_hwfn *p_hwfn,
                                                    bool dump,
                                                    u32 *num_dumped_dwords)
 {
-       u32 offset = 0, size_param_offset, override_window_dwords;
+       u32 size_param_offset, override_window_dwords, offset = 0;
 
        *num_dumped_dwords = 0;
 
@@ -4542,8 +4860,8 @@ static enum dbg_status qed_protection_override_dump(struct qed_hwfn *p_hwfn,
        offset += qed_dump_str_param(dump_buf + offset,
                                     dump, "dump-type", "protection-override");
 
-       /* Dump data section header and param. The size param is 0 for now, and
-        * is overwritten after reading the data.
+       /* Dump data section header and param. The size param is 0 for now,
+        * and is overwritten after reading the data.
         */
        offset += qed_dump_section_hdr(dump_buf + offset,
                                       dump, "protection_override_data", 1);
@@ -4552,8 +4870,7 @@ static enum dbg_status qed_protection_override_dump(struct qed_hwfn *p_hwfn,
 
        if (!dump) {
                offset += PROTECTION_OVERRIDE_DEPTH_DWORDS;
-               *num_dumped_dwords = offset;
-               return DBG_STATUS_OK;
+               goto out;
        }
 
        /* Add override window info to buffer */
@@ -4569,8 +4886,12 @@ static enum dbg_status qed_protection_override_dump(struct qed_hwfn *p_hwfn,
        offset += override_window_dwords;
        qed_dump_num_param(dump_buf + size_param_offset, dump, "size",
                           override_window_dwords);
+out:
+       /* Dump last section */
+       offset += qed_dump_last_section(p_hwfn, dump_buf, offset, dump);
 
        *num_dumped_dwords = offset;
+
        return DBG_STATUS_OK;
 }
 
@@ -4593,11 +4914,14 @@ static u32 qed_fw_asserts_dump(struct qed_hwfn *p_hwfn,
                                                dump_buf + offset, dump, 1);
        offset += qed_dump_str_param(dump_buf + offset,
                                     dump, "dump-type", "fw-asserts");
+
+       /* Find Storm dump size */
        for (storm_id = 0; storm_id < MAX_DBG_STORMS; storm_id++) {
                u32 fw_asserts_section_addr, next_list_idx_addr, next_list_idx;
+               struct storm_defs *storm = &s_storm_defs[storm_id];
                u32 last_list_idx, addr;
 
-               if (dev_data->block_in_reset[s_storm_defs[storm_id].block_id])
+               if (dev_data->block_in_reset[storm->block_id])
                        continue;
 
                /* Read FW info for the current Storm */
@@ -4606,26 +4930,26 @@ static u32 qed_fw_asserts_dump(struct qed_hwfn *p_hwfn,
                asserts = &fw_info.fw_asserts_section;
 
                /* Dump FW Asserts section header and params */
-               storm_letter_str[0] = s_storm_defs[storm_id].letter;
-               offset += qed_dump_section_hdr(dump_buf + offset, dump,
-                                              "fw_asserts", 2);
-               offset += qed_dump_str_param(dump_buf + offset, dump, "storm",
-                                            storm_letter_str);
-               offset += qed_dump_num_param(dump_buf + offset, dump, "size",
+               storm_letter_str[0] = storm->letter;
+               offset += qed_dump_section_hdr(dump_buf + offset,
+                                              dump, "fw_asserts", 2);
+               offset += qed_dump_str_param(dump_buf + offset,
+                                            dump, "storm", storm_letter_str);
+               offset += qed_dump_num_param(dump_buf + offset,
+                                            dump,
+                                            "size",
                                             asserts->list_element_dword_size);
 
+               /* Read and dump FW Asserts data */
                if (!dump) {
                        offset += asserts->list_element_dword_size;
                        continue;
                }
 
-               /* Read and dump FW Asserts data */
-               fw_asserts_section_addr =
-                       s_storm_defs[storm_id].sem_fast_mem_addr +
+               fw_asserts_section_addr = storm->sem_fast_mem_addr +
                        SEM_FAST_REG_INT_RAM +
                        RAM_LINES_TO_BYTES(asserts->section_ram_line_offset);
-               next_list_idx_addr =
-                       fw_asserts_section_addr +
+               next_list_idx_addr = fw_asserts_section_addr +
                        DWORDS_TO_BYTES(asserts->list_next_index_dword_offset);
                next_list_idx = qed_rd(p_hwfn, p_ptt, next_list_idx_addr);
                last_list_idx = (next_list_idx > 0
@@ -4638,11 +4962,13 @@ static u32 qed_fw_asserts_dump(struct qed_hwfn *p_hwfn,
                    qed_grc_dump_addr_range(p_hwfn, p_ptt,
                                            dump_buf + offset,
                                            dump, addr,
-                                           asserts->list_element_dword_size);
+                                           asserts->list_element_dword_size,
+                                           false);
        }
 
        /* Dump last section */
-       offset += qed_dump_section_hdr(dump_buf + offset, dump, "last", 0);
+       offset += qed_dump_last_section(p_hwfn, dump_buf, offset, dump);
+
        return offset;
 }
 
@@ -4650,10 +4976,10 @@ static u32 qed_fw_asserts_dump(struct qed_hwfn *p_hwfn,
 
 enum dbg_status qed_dbg_set_bin_ptr(const u8 * const bin_ptr)
 {
-       /* Convert binary data to debug arrays */
        struct bin_buffer_hdr *buf_array = (struct bin_buffer_hdr *)bin_ptr;
        u8 buf_id;
 
+       /* convert binary data to debug arrays */
        for (buf_id = 0; buf_id < MAX_BIN_DBG_BUFFER_TYPE; buf_id++) {
                s_dbg_arrays[buf_id].ptr =
                    (u32 *)(bin_ptr + buf_array[buf_id].offset);
@@ -4682,14 +5008,17 @@ enum dbg_status qed_dbg_grc_get_dump_buf_size(struct qed_hwfn *p_hwfn,
        enum dbg_status status = qed_dbg_dev_init(p_hwfn, p_ptt);
 
        *buf_size = 0;
+
        if (status != DBG_STATUS_OK)
                return status;
+
        if (!s_dbg_arrays[BIN_BUF_DBG_MODE_TREE].ptr ||
            !s_dbg_arrays[BIN_BUF_DBG_DUMP_REG].ptr ||
            !s_dbg_arrays[BIN_BUF_DBG_DUMP_MEM].ptr ||
            !s_dbg_arrays[BIN_BUF_DBG_ATTN_BLOCKS].ptr ||
            !s_dbg_arrays[BIN_BUF_DBG_ATTN_REGS].ptr)
                return DBG_STATUS_DBG_ARRAY_NOT_SET;
+
        return qed_grc_dump(p_hwfn, p_ptt, NULL, false, buf_size);
 }
 
@@ -4702,12 +5031,14 @@ enum dbg_status qed_dbg_grc_dump(struct qed_hwfn *p_hwfn,
        u32 needed_buf_size_in_dwords;
        enum dbg_status status;
 
-       status = qed_dbg_grc_get_dump_buf_size(p_hwfn, p_ptt,
-                                              &needed_buf_size_in_dwords);
-
        *num_dumped_dwords = 0;
+
+       status = qed_dbg_grc_get_dump_buf_size(p_hwfn,
+                                              p_ptt,
+                                              &needed_buf_size_in_dwords);
        if (status != DBG_STATUS_OK)
                return status;
+
        if (buf_size_in_dwords < needed_buf_size_in_dwords)
                return DBG_STATUS_DUMP_BUF_TOO_SMALL;
 
@@ -4724,25 +5055,31 @@ enum dbg_status qed_dbg_idle_chk_get_dump_buf_size(struct qed_hwfn *p_hwfn,
                                                   struct qed_ptt *p_ptt,
                                                   u32 *buf_size)
 {
-       enum dbg_status status = qed_dbg_dev_init(p_hwfn, p_ptt);
        struct dbg_tools_data *dev_data = &p_hwfn->dbg_info;
+       struct idle_chk_data *idle_chk;
+       enum dbg_status status;
 
+       idle_chk = &dev_data->idle_chk;
        *buf_size = 0;
+
+       status = qed_dbg_dev_init(p_hwfn, p_ptt);
        if (status != DBG_STATUS_OK)
                return status;
+
        if (!s_dbg_arrays[BIN_BUF_DBG_MODE_TREE].ptr ||
            !s_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_REGS].ptr ||
            !s_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_IMMS].ptr ||
            !s_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_RULES].ptr)
                return DBG_STATUS_DBG_ARRAY_NOT_SET;
-       if (!dev_data->idle_chk.buf_size_set) {
-               dev_data->idle_chk.buf_size = qed_idle_chk_dump(p_hwfn,
-                                                               p_ptt,
-                                                               NULL, false);
-               dev_data->idle_chk.buf_size_set = true;
+
+       if (!idle_chk->buf_size_set) {
+               idle_chk->buf_size = qed_idle_chk_dump(p_hwfn,
+                                                      p_ptt, NULL, false);
+               idle_chk->buf_size_set = true;
        }
 
-       *buf_size = dev_data->idle_chk.buf_size;
+       *buf_size = idle_chk->buf_size;
+
        return DBG_STATUS_OK;
 }
 
@@ -4755,12 +5092,14 @@ enum dbg_status qed_dbg_idle_chk_dump(struct qed_hwfn *p_hwfn,
        u32 needed_buf_size_in_dwords;
        enum dbg_status status;
 
-       status = qed_dbg_idle_chk_get_dump_buf_size(p_hwfn, p_ptt,
-                                                   &needed_buf_size_in_dwords);
-
        *num_dumped_dwords = 0;
+
+       status = qed_dbg_idle_chk_get_dump_buf_size(p_hwfn,
+                                                   p_ptt,
+                                                   &needed_buf_size_in_dwords);
        if (status != DBG_STATUS_OK)
                return status;
+
        if (buf_size_in_dwords < needed_buf_size_in_dwords)
                return DBG_STATUS_DUMP_BUF_TOO_SMALL;
 
@@ -4783,8 +5122,10 @@ enum dbg_status qed_dbg_mcp_trace_get_dump_buf_size(struct qed_hwfn *p_hwfn,
        enum dbg_status status = qed_dbg_dev_init(p_hwfn, p_ptt);
 
        *buf_size = 0;
+
        if (status != DBG_STATUS_OK)
                return status;
+
        return qed_mcp_trace_dump(p_hwfn, p_ptt, NULL, false, buf_size);
 }
 
@@ -4797,13 +5138,12 @@ enum dbg_status qed_dbg_mcp_trace_dump(struct qed_hwfn *p_hwfn,
        u32 needed_buf_size_in_dwords;
        enum dbg_status status;
 
-       /* validate buffer size */
        status =
-           qed_dbg_mcp_trace_get_dump_buf_size(p_hwfn, p_ptt,
-                                               &needed_buf_size_in_dwords);
-
-       if (status != DBG_STATUS_OK &&
-           status != DBG_STATUS_NVRAM_GET_IMAGE_FAILED)
+               qed_dbg_mcp_trace_get_dump_buf_size(p_hwfn,
+                                                   p_ptt,
+                                                   &needed_buf_size_in_dwords);
+       if (status != DBG_STATUS_OK && status !=
+           DBG_STATUS_NVRAM_GET_IMAGE_FAILED)
                return status;
 
        if (buf_size_in_dwords < needed_buf_size_in_dwords)
@@ -4829,8 +5169,10 @@ enum dbg_status qed_dbg_reg_fifo_get_dump_buf_size(struct qed_hwfn *p_hwfn,
        enum dbg_status status = qed_dbg_dev_init(p_hwfn, p_ptt);
 
        *buf_size = 0;
+
        if (status != DBG_STATUS_OK)
                return status;
+
        return qed_reg_fifo_dump(p_hwfn, p_ptt, NULL, false, buf_size);
 }
 
@@ -4843,12 +5185,14 @@ enum dbg_status qed_dbg_reg_fifo_dump(struct qed_hwfn *p_hwfn,
        u32 needed_buf_size_in_dwords;
        enum dbg_status status;
 
-       status = qed_dbg_reg_fifo_get_dump_buf_size(p_hwfn, p_ptt,
-                                                   &needed_buf_size_in_dwords);
-
        *num_dumped_dwords = 0;
+
+       status = qed_dbg_reg_fifo_get_dump_buf_size(p_hwfn,
+                                                   p_ptt,
+                                                   &needed_buf_size_in_dwords);
        if (status != DBG_STATUS_OK)
                return status;
+
        if (buf_size_in_dwords < needed_buf_size_in_dwords)
                return DBG_STATUS_DUMP_BUF_TOO_SMALL;
 
@@ -4871,8 +5215,10 @@ enum dbg_status qed_dbg_igu_fifo_get_dump_buf_size(struct qed_hwfn *p_hwfn,
        enum dbg_status status = qed_dbg_dev_init(p_hwfn, p_ptt);
 
        *buf_size = 0;
+
        if (status != DBG_STATUS_OK)
                return status;
+
        return qed_igu_fifo_dump(p_hwfn, p_ptt, NULL, false, buf_size);
 }
 
@@ -4885,12 +5231,14 @@ enum dbg_status qed_dbg_igu_fifo_dump(struct qed_hwfn *p_hwfn,
        u32 needed_buf_size_in_dwords;
        enum dbg_status status;
 
-       status = qed_dbg_igu_fifo_get_dump_buf_size(p_hwfn, p_ptt,
-                                                   &needed_buf_size_in_dwords);
-
        *num_dumped_dwords = 0;
+
+       status = qed_dbg_igu_fifo_get_dump_buf_size(p_hwfn,
+                                                   p_ptt,
+                                                   &needed_buf_size_in_dwords);
        if (status != DBG_STATUS_OK)
                return status;
+
        if (buf_size_in_dwords < needed_buf_size_in_dwords)
                return DBG_STATUS_DUMP_BUF_TOO_SMALL;
 
@@ -4913,8 +5261,10 @@ qed_dbg_protection_override_get_dump_buf_size(struct qed_hwfn *p_hwfn,
        enum dbg_status status = qed_dbg_dev_init(p_hwfn, p_ptt);
 
        *buf_size = 0;
+
        if (status != DBG_STATUS_OK)
                return status;
+
        return qed_protection_override_dump(p_hwfn,
                                            p_ptt, NULL, false, buf_size);
 }
@@ -4925,15 +5275,18 @@ enum dbg_status qed_dbg_protection_override_dump(struct qed_hwfn *p_hwfn,
                                                 u32 buf_size_in_dwords,
                                                 u32 *num_dumped_dwords)
 {
-       u32 needed_buf_size_in_dwords;
+       u32 needed_buf_size_in_dwords, *p_size = &needed_buf_size_in_dwords;
        enum dbg_status status;
 
-       status = qed_dbg_protection_override_get_dump_buf_size(p_hwfn, p_ptt,
-                                               &needed_buf_size_in_dwords);
-
        *num_dumped_dwords = 0;
+
+       status =
+               qed_dbg_protection_override_get_dump_buf_size(p_hwfn,
+                                                             p_ptt,
+                                                             p_size);
        if (status != DBG_STATUS_OK)
                return status;
+
        if (buf_size_in_dwords < needed_buf_size_in_dwords)
                return DBG_STATUS_DUMP_BUF_TOO_SMALL;
 
@@ -4958,12 +5311,15 @@ enum dbg_status qed_dbg_fw_asserts_get_dump_buf_size(struct qed_hwfn *p_hwfn,
        enum dbg_status status = qed_dbg_dev_init(p_hwfn, p_ptt);
 
        *buf_size = 0;
+
        if (status != DBG_STATUS_OK)
                return status;
 
        /* Update reset state */
        qed_update_blocks_reset_state(p_hwfn, p_ptt);
+
        *buf_size = qed_fw_asserts_dump(p_hwfn, p_ptt, NULL, false);
+
        return DBG_STATUS_OK;
 }
 
@@ -4973,19 +5329,26 @@ enum dbg_status qed_dbg_fw_asserts_dump(struct qed_hwfn *p_hwfn,
                                        u32 buf_size_in_dwords,
                                        u32 *num_dumped_dwords)
 {
-       u32 needed_buf_size_in_dwords;
+       u32 needed_buf_size_in_dwords, *p_size = &needed_buf_size_in_dwords;
        enum dbg_status status;
 
-       status = qed_dbg_fw_asserts_get_dump_buf_size(p_hwfn, p_ptt,
-                                               &needed_buf_size_in_dwords);
-
        *num_dumped_dwords = 0;
+
+       status =
+               qed_dbg_fw_asserts_get_dump_buf_size(p_hwfn,
+                                                    p_ptt,
+                                                    p_size);
        if (status != DBG_STATUS_OK)
                return status;
+
        if (buf_size_in_dwords < needed_buf_size_in_dwords)
                return DBG_STATUS_DUMP_BUF_TOO_SMALL;
 
        *num_dumped_dwords = qed_fw_asserts_dump(p_hwfn, p_ptt, dump_buf, true);
+
+       /* Revert GRC params to their default */
+       qed_dbg_grc_set_params_default(p_hwfn);
+
        return DBG_STATUS_OK;
 }
 
@@ -5005,9 +5368,14 @@ struct mcp_trace_format {
 #define MCP_TRACE_FORMAT_P3_SIZE_SHIFT 22
 #define MCP_TRACE_FORMAT_LEN_MASK      0xff000000
 #define MCP_TRACE_FORMAT_LEN_SHIFT     24
+
        char *format_str;
 };
 
+/* Meta data structure, generated by a perl script during MFW build. therefore,
+ * the structs mcp_trace_meta and mcp_trace_format are duplicated in the perl
+ * script.
+ */
 struct mcp_trace_meta {
        u32 modules_num;
        char **modules;
@@ -5015,7 +5383,7 @@ struct mcp_trace_meta {
        struct mcp_trace_format *formats;
 };
 
-/* Reg fifo element */
+/* REG fifo element */
 struct reg_fifo_element {
        u64 data;
 #define REG_FIFO_ELEMENT_ADDRESS_SHIFT         0
@@ -5140,12 +5508,15 @@ struct igu_fifo_addr_data {
 /******************************** Constants **********************************/
 
 #define MAX_MSG_LEN                            1024
+
 #define MCP_TRACE_MAX_MODULE_LEN               8
 #define MCP_TRACE_FORMAT_MAX_PARAMS            3
 #define MCP_TRACE_FORMAT_PARAM_WIDTH \
        (MCP_TRACE_FORMAT_P2_SIZE_SHIFT - MCP_TRACE_FORMAT_P1_SIZE_SHIFT)
+
 #define REG_FIFO_ELEMENT_ADDR_FACTOR           4
 #define REG_FIFO_ELEMENT_IS_PF_VF_VAL          127
+
 #define PROTECTION_OVERRIDE_ELEMENT_ADDR_FACTOR        4
 
 /********************************* Macros ************************************/
@@ -5154,59 +5525,178 @@ struct igu_fifo_addr_data {
 
 /***************************** Constant Arrays *******************************/
 
+struct user_dbg_array {
+       const u32 *ptr;
+       u32 size_in_dwords;
+};
+
+/* Debug arrays */
+static struct user_dbg_array
+s_user_dbg_arrays[MAX_BIN_DBG_BUFFER_TYPE] = { {NULL} };
+
 /* Status string array */
 static const char * const s_status_str[] = {
+       /* DBG_STATUS_OK */
        "Operation completed successfully",
+
+       /* DBG_STATUS_APP_VERSION_NOT_SET */
        "Debug application version wasn't set",
+
+       /* DBG_STATUS_UNSUPPORTED_APP_VERSION */
        "Unsupported debug application version",
+
+       /* DBG_STATUS_DBG_BLOCK_NOT_RESET */
        "The debug block wasn't reset since the last recording",
+
+       /* DBG_STATUS_INVALID_ARGS */
        "Invalid arguments",
+
+       /* DBG_STATUS_OUTPUT_ALREADY_SET */
        "The debug output was already set",
+
+       /* DBG_STATUS_INVALID_PCI_BUF_SIZE */
        "Invalid PCI buffer size",
+
+       /* DBG_STATUS_PCI_BUF_ALLOC_FAILED */
        "PCI buffer allocation failed",
+
+       /* DBG_STATUS_PCI_BUF_NOT_ALLOCATED */
        "A PCI buffer wasn't allocated",
+
+       /* DBG_STATUS_TOO_MANY_INPUTS */
        "Too many inputs were enabled. Enabled less inputs, or set 'unifyInputs' to true",
-       "GRC/Timestamp input overlap in cycle dword 0",
+
+       /* DBG_STATUS_INPUT_OVERLAP */
+       "Overlapping debug bus inputs",
+
+       /* DBG_STATUS_HW_ONLY_RECORDING */
        "Cannot record Storm data since the entire recording cycle is used by HW",
+
+       /* DBG_STATUS_STORM_ALREADY_ENABLED */
        "The Storm was already enabled",
+
+       /* DBG_STATUS_STORM_NOT_ENABLED */
        "The specified Storm wasn't enabled",
+
+       /* DBG_STATUS_BLOCK_ALREADY_ENABLED */
        "The block was already enabled",
+
+       /* DBG_STATUS_BLOCK_NOT_ENABLED */
        "The specified block wasn't enabled",
+
+       /* DBG_STATUS_NO_INPUT_ENABLED */
        "No input was enabled for recording",
+
+       /* DBG_STATUS_NO_FILTER_TRIGGER_64B */
        "Filters and triggers are not allowed when recording in 64b units",
+
+       /* DBG_STATUS_FILTER_ALREADY_ENABLED */
        "The filter was already enabled",
+
+       /* DBG_STATUS_TRIGGER_ALREADY_ENABLED */
        "The trigger was already enabled",
+
+       /* DBG_STATUS_TRIGGER_NOT_ENABLED */
        "The trigger wasn't enabled",
+
+       /* DBG_STATUS_CANT_ADD_CONSTRAINT */
        "A constraint can be added only after a filter was enabled or a trigger state was added",
+
+       /* DBG_STATUS_TOO_MANY_TRIGGER_STATES */
        "Cannot add more than 3 trigger states",
+
+       /* DBG_STATUS_TOO_MANY_CONSTRAINTS */
        "Cannot add more than 4 constraints per filter or trigger state",
+
+       /* DBG_STATUS_RECORDING_NOT_STARTED */
        "The recording wasn't started",
+
+       /* DBG_STATUS_DATA_DIDNT_TRIGGER */
        "A trigger was configured, but it didn't trigger",
+
+       /* DBG_STATUS_NO_DATA_RECORDED */
        "No data was recorded",
+
+       /* DBG_STATUS_DUMP_BUF_TOO_SMALL */
        "Dump buffer is too small",
+
+       /* DBG_STATUS_DUMP_NOT_CHUNK_ALIGNED */
        "Dumped data is not aligned to chunks",
+
+       /* DBG_STATUS_UNKNOWN_CHIP */
        "Unknown chip",
+
+       /* DBG_STATUS_VIRT_MEM_ALLOC_FAILED */
        "Failed allocating virtual memory",
+
+       /* DBG_STATUS_BLOCK_IN_RESET */
        "The input block is in reset",
+
+       /* DBG_STATUS_INVALID_TRACE_SIGNATURE */
        "Invalid MCP trace signature found in NVRAM",
+
+       /* DBG_STATUS_INVALID_NVRAM_BUNDLE */
        "Invalid bundle ID found in NVRAM",
+
+       /* DBG_STATUS_NVRAM_GET_IMAGE_FAILED */
        "Failed getting NVRAM image",
+
+       /* DBG_STATUS_NON_ALIGNED_NVRAM_IMAGE */
        "NVRAM image is not dword-aligned",
+
+       /* DBG_STATUS_NVRAM_READ_FAILED */
        "Failed reading from NVRAM",
+
+       /* DBG_STATUS_IDLE_CHK_PARSE_FAILED */
        "Idle check parsing failed",
+
+       /* DBG_STATUS_MCP_TRACE_BAD_DATA */
        "MCP Trace data is corrupt",
-       "Dump doesn't contain meta data - it must be provided in an image file",
+
+       /* DBG_STATUS_MCP_TRACE_NO_META */
+       "Dump doesn't contain meta data - it must be provided in image file",
+
+       /* DBG_STATUS_MCP_COULD_NOT_HALT */
        "Failed to halt MCP",
+
+       /* DBG_STATUS_MCP_COULD_NOT_RESUME */
        "Failed to resume MCP after halt",
+
+       /* DBG_STATUS_DMAE_FAILED */
        "DMAE transaction failed",
+
+       /* DBG_STATUS_SEMI_FIFO_NOT_EMPTY */
        "Failed to empty SEMI sync FIFO",
+
+       /* DBG_STATUS_IGU_FIFO_BAD_DATA */
        "IGU FIFO data is corrupt",
+
+       /* DBG_STATUS_MCP_COULD_NOT_MASK_PRTY */
        "MCP failed to mask parities",
+
+       /* DBG_STATUS_FW_ASSERTS_PARSE_FAILED */
        "FW Asserts parsing failed",
+
+       /* DBG_STATUS_REG_FIFO_BAD_DATA */
        "GRC FIFO data is corrupt",
+
+       /* DBG_STATUS_PROTECTION_OVERRIDE_BAD_DATA */
        "Protection Override data is corrupt",
+
+       /* DBG_STATUS_DBG_ARRAY_NOT_SET */
        "Debug arrays were not set (when using binary files, dbg_set_bin_ptr must be called)",
-       "When a block is filtered, no other blocks can be recorded unless inputs are unified (due to a HW bug)"
+
+       /* DBG_STATUS_FILTER_BUG */
+       "Debug Bus filtering requires the -unifyInputs option (due to a HW bug)",
+
+       /* DBG_STATUS_NON_MATCHING_LINES */
+       "Non-matching debug lines - all lines must be of the same type (either 128b or 256b)",
+
+       /* DBG_STATUS_INVALID_TRIGGER_DWORD_OFFSET */
+       "The selected trigger dword offset wasn't enabled in the recorded HW block",
+
+       /* DBG_STATUS_DBG_BUS_IN_USE */
+       "The debug bus is in use"
 };
 
 /* Idle check severity names array */
@@ -5223,12 +5713,13 @@ static const char * const s_mcp_trace_level_str[] = {
        "DEBUG"
 };
 
-/* Parsing strings */
+/* Access type names array */
 static const char * const s_access_strs[] = {
        "read",
        "write"
 };
 
+/* Privilege type names array */
 static const char * const s_privilege_strs[] = {
        "VF",
        "PDA",
@@ -5236,6 +5727,7 @@ static const char * const s_privilege_strs[] = {
        "UA"
 };
 
+/* Protection type names array */
 static const char * const s_protection_strs[] = {
        "(default)",
        "(default)",
@@ -5247,6 +5739,7 @@ static const char * const s_protection_strs[] = {
        "override UA"
 };
 
+/* Master type names array */
 static const char * const s_master_strs[] = {
        "???",
        "pxp",
@@ -5266,6 +5759,7 @@ static const char * const s_master_strs[] = {
        "???"
 };
 
+/* REG FIFO error messages array */
 static const char * const s_reg_fifo_error_strs[] = {
        "grc timeout",
        "address doesn't belong to any block",
@@ -5274,6 +5768,7 @@ static const char * const s_reg_fifo_error_strs[] = {
        "path isolation error"
 };
 
+/* IGU FIFO sources array */
 static const char * const s_igu_fifo_source_strs[] = {
        "TSTORM",
        "MSTORM",
@@ -5288,6 +5783,7 @@ static const char * const s_igu_fifo_source_strs[] = {
        "GRC",
 };
 
+/* IGU FIFO error messages */
 static const char * const s_igu_fifo_error_strs[] = {
        "no error",
        "length error",
@@ -5308,13 +5804,18 @@ static const char * const s_igu_fifo_error_strs[] = {
 
 /* IGU FIFO address data */
 static const struct igu_fifo_addr_data s_igu_fifo_addr_data[] = {
-       {0x0, 0x101, "MSI-X Memory", NULL, IGU_ADDR_TYPE_MSIX_MEM},
-       {0x102, 0x1ff, "reserved", NULL, IGU_ADDR_TYPE_RESERVED},
-       {0x200, 0x200, "Write PBA[0:63]", NULL, IGU_ADDR_TYPE_WRITE_PBA},
+       {0x0, 0x101, "MSI-X Memory", NULL,
+        IGU_ADDR_TYPE_MSIX_MEM},
+       {0x102, 0x1ff, "reserved", NULL,
+        IGU_ADDR_TYPE_RESERVED},
+       {0x200, 0x200, "Write PBA[0:63]", NULL,
+        IGU_ADDR_TYPE_WRITE_PBA},
        {0x201, 0x201, "Write PBA[64:127]", "reserved",
         IGU_ADDR_TYPE_WRITE_PBA},
-       {0x202, 0x202, "Write PBA[128]", "reserved", IGU_ADDR_TYPE_WRITE_PBA},
-       {0x203, 0x3ff, "reserved", NULL, IGU_ADDR_TYPE_RESERVED},
+       {0x202, 0x202, "Write PBA[128]", "reserved",
+        IGU_ADDR_TYPE_WRITE_PBA},
+       {0x203, 0x3ff, "reserved", NULL,
+        IGU_ADDR_TYPE_RESERVED},
        {0x400, 0x5ef, "Write interrupt acknowledgment", NULL,
         IGU_ADDR_TYPE_WRITE_INT_ACK},
        {0x5f0, 0x5f0, "Attention bits update", NULL,
@@ -5331,8 +5832,10 @@ static const struct igu_fifo_addr_data s_igu_fifo_addr_data[] = {
         IGU_ADDR_TYPE_READ_INT},
        {0x5f6, 0x5f6, "Read interrupt 0:63 without mask", NULL,
         IGU_ADDR_TYPE_READ_INT},
-       {0x5f7, 0x5ff, "reserved", NULL, IGU_ADDR_TYPE_RESERVED},
-       {0x600, 0x7ff, "Producer update", NULL, IGU_ADDR_TYPE_WRITE_PROD_UPDATE}
+       {0x5f7, 0x5ff, "reserved", NULL,
+        IGU_ADDR_TYPE_RESERVED},
+       {0x600, 0x7ff, "Producer update", NULL,
+        IGU_ADDR_TYPE_WRITE_PROD_UPDATE}
 };
 
 /******************************** Variables **********************************/
@@ -5340,28 +5843,12 @@ static const struct igu_fifo_addr_data s_igu_fifo_addr_data[] = {
 /* MCP Trace meta data - used in case the dump doesn't contain the meta data
  * (e.g. due to no NVRAM access).
  */
-static struct dbg_array s_mcp_trace_meta = { NULL, 0 };
+static struct user_dbg_array s_mcp_trace_meta = { NULL, 0 };
 
 /* Temporary buffer, used for print size calculations */
 static char s_temp_buf[MAX_MSG_LEN];
 
-/***************************** Public Functions *******************************/
-
-enum dbg_status qed_dbg_user_set_bin_ptr(const u8 * const bin_ptr)
-{
-       /* Convert binary data to debug arrays */
-       struct bin_buffer_hdr *buf_array = (struct bin_buffer_hdr *)bin_ptr;
-       u8 buf_id;
-
-       for (buf_id = 0; buf_id < MAX_BIN_DBG_BUFFER_TYPE; buf_id++) {
-               s_dbg_arrays[buf_id].ptr =
-                   (u32 *)(bin_ptr + buf_array[buf_id].offset);
-               s_dbg_arrays[buf_id].size_in_dwords =
-                   BYTES_TO_DWORDS(buf_array[buf_id].length);
-       }
-
-       return DBG_STATUS_OK;
-}
+/**************************** Private Functions ******************************/
 
 static u32 qed_cyclic_add(u32 a, u32 b, u32 size)
 {
@@ -5381,10 +5868,8 @@ static u32 qed_read_from_cyclic_buf(void *buf,
                                    u32 *offset,
                                    u32 buf_size, u8 num_bytes_to_read)
 {
-       u8 *bytes_buf = (u8 *)buf;
-       u8 *val_ptr;
+       u8 i, *val_ptr, *bytes_buf = (u8 *)buf;
        u32 val = 0;
-       u8 i;
 
        val_ptr = (u8 *)&val;
 
@@ -5412,6 +5897,7 @@ static u32 qed_read_dword_from_buf(void *buf, u32 *offset)
        u32 dword_val = *(u32 *)&((u8 *)buf)[*offset];
 
        *offset += 4;
+
        return dword_val;
 }
 
@@ -5445,7 +5931,7 @@ static u32 qed_read_param(u32 *dump_buf,
                          const char **param_str_val, u32 *param_num_val)
 {
        char *char_buf = (char *)dump_buf;
-       u32 offset = 0; /* In bytes */
+       size_t offset = 0;
 
        /* Extract param name */
        *param_name = char_buf;
@@ -5493,37 +5979,31 @@ static u32 qed_print_section_params(u32 *dump_buf,
        u32 i, dump_offset = 0, results_offset = 0;
 
        for (i = 0; i < num_section_params; i++) {
-               const char *param_name;
-               const char *param_str_val;
+               const char *param_name, *param_str_val;
                u32 param_num_val = 0;
 
                dump_offset += qed_read_param(dump_buf + dump_offset,
                                              &param_name,
                                              &param_str_val, &param_num_val);
+
                if (param_str_val)
-                       /* String param */
                        results_offset +=
                                sprintf(qed_get_buf_ptr(results_buf,
                                                        results_offset),
                                        "%s: %s\n", param_name, param_str_val);
                else if (strcmp(param_name, "fw-timestamp"))
-                       /* Numeric param */
                        results_offset +=
                                sprintf(qed_get_buf_ptr(results_buf,
                                                        results_offset),
                                        "%s: %d\n", param_name, param_num_val);
        }
 
-       results_offset +=
-           sprintf(qed_get_buf_ptr(results_buf, results_offset), "\n");
+       results_offset += sprintf(qed_get_buf_ptr(results_buf, results_offset),
+                                 "\n");
+
        *num_chars_printed = results_offset;
-       return dump_offset;
-}
 
-const char *qed_dbg_get_status_str(enum dbg_status status)
-{
-       return (status <
-               MAX_DBG_STATUS) ? s_status_str[status] : "Invalid debug status";
+       return dump_offset;
 }
 
 /* Parses the idle check rules and returns the number of characters printed.
@@ -5537,7 +6017,10 @@ static u32 qed_parse_idle_chk_dump_rules(struct qed_hwfn *p_hwfn,
                                         char *results_buf,
                                         u32 *num_errors, u32 *num_warnings)
 {
-       u32 rule_idx, results_offset = 0; /* Offset in results_buf in bytes */
+       /* Offset in results_buf in bytes */
+       u32 results_offset = 0;
+
+       u32 rule_idx;
        u16 i, j;
 
        *num_errors = 0;
@@ -5548,16 +6031,15 @@ static u32 qed_parse_idle_chk_dump_rules(struct qed_hwfn *p_hwfn,
             rule_idx++) {
                const struct dbg_idle_chk_rule_parsing_data *rule_parsing_data;
                struct dbg_idle_chk_result_hdr *hdr;
-               const char *parsing_str;
+               const char *parsing_str, *lsi_msg;
                u32 parsing_str_offset;
-               const char *lsi_msg;
-               u8 curr_reg_id = 0;
                bool has_fw_msg;
+               u8 curr_reg_id;
 
                hdr = (struct dbg_idle_chk_result_hdr *)dump_buf;
                rule_parsing_data =
                        (const struct dbg_idle_chk_rule_parsing_data *)
-                       &s_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_PARSING_DATA].
+                       &s_user_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_PARSING_DATA].
                        ptr[hdr->rule_id];
                parsing_str_offset =
                        GET_FIELD(rule_parsing_data->data,
@@ -5565,16 +6047,18 @@ static u32 qed_parse_idle_chk_dump_rules(struct qed_hwfn *p_hwfn,
                has_fw_msg =
                        GET_FIELD(rule_parsing_data->data,
                                DBG_IDLE_CHK_RULE_PARSING_DATA_HAS_FW_MSG) > 0;
-               parsing_str = &((const char *)
-                               s_dbg_arrays[BIN_BUF_DBG_PARSING_STRINGS].ptr)
-                               [parsing_str_offset];
+               parsing_str =
+                       &((const char *)
+                       s_user_dbg_arrays[BIN_BUF_DBG_PARSING_STRINGS].ptr)
+                       [parsing_str_offset];
                lsi_msg = parsing_str;
+               curr_reg_id = 0;
 
                if (hdr->severity >= MAX_DBG_IDLE_CHK_SEVERITY_TYPES)
                        return 0;
 
                /* Skip rule header */
-               dump_buf += (sizeof(struct dbg_idle_chk_result_hdr) / 4);
+               dump_buf += BYTES_TO_DWORDS(sizeof(*hdr));
 
                /* Update errors/warnings count */
                if (hdr->severity == IDLE_CHK_SEVERITY_ERROR ||
@@ -5606,19 +6090,19 @@ static u32 qed_parse_idle_chk_dump_rules(struct qed_hwfn *p_hwfn,
                for (i = 0;
                     i < hdr->num_dumped_cond_regs + hdr->num_dumped_info_regs;
                     i++) {
-                       struct dbg_idle_chk_result_reg_hdr *reg_hdr
-                           = (struct dbg_idle_chk_result_reg_hdr *)
-                           dump_buf;
-                       bool is_mem =
-                               GET_FIELD(reg_hdr->data,
-                                         DBG_IDLE_CHK_RESULT_REG_HDR_IS_MEM);
-                       u8 reg_id =
-                               GET_FIELD(reg_hdr->data,
-                                         DBG_IDLE_CHK_RESULT_REG_HDR_REG_ID);
+                       struct dbg_idle_chk_result_reg_hdr *reg_hdr;
+                       bool is_mem;
+                       u8 reg_id;
+
+                       reg_hdr =
+                               (struct dbg_idle_chk_result_reg_hdr *)dump_buf;
+                       is_mem = GET_FIELD(reg_hdr->data,
+                                          DBG_IDLE_CHK_RESULT_REG_HDR_IS_MEM);
+                       reg_id = GET_FIELD(reg_hdr->data,
+                                          DBG_IDLE_CHK_RESULT_REG_HDR_REG_ID);
 
                        /* Skip reg header */
-                       dump_buf +=
-                           (sizeof(struct dbg_idle_chk_result_reg_hdr) / 4);
+                       dump_buf += BYTES_TO_DWORDS(sizeof(*reg_hdr));
 
                        /* Skip register names until the required reg_id is
                         * reached.
@@ -5660,6 +6144,7 @@ static u32 qed_parse_idle_chk_dump_rules(struct qed_hwfn *p_hwfn,
        /* Check if end of dump buffer was exceeded */
        if (dump_buf > dump_buf_end)
                return 0;
+
        return results_offset;
 }
 
@@ -5680,13 +6165,16 @@ static enum dbg_status qed_parse_idle_chk_dump(struct qed_hwfn *p_hwfn,
        const char *section_name, *param_name, *param_str_val;
        u32 *dump_buf_end = dump_buf + num_dumped_dwords;
        u32 num_section_params = 0, num_rules;
-       u32 results_offset = 0; /* Offset in results_buf in bytes */
+
+       /* Offset in results_buf in bytes */
+       u32 results_offset = 0;
 
        *parsed_results_bytes = 0;
        *num_errors = 0;
        *num_warnings = 0;
-       if (!s_dbg_arrays[BIN_BUF_DBG_PARSING_STRINGS].ptr ||
-           !s_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_PARSING_DATA].ptr)
+
+       if (!s_user_dbg_arrays[BIN_BUF_DBG_PARSING_STRINGS].ptr ||
+           !s_user_dbg_arrays[BIN_BUF_DBG_IDLE_CHK_PARSING_DATA].ptr)
                return DBG_STATUS_DBG_ARRAY_NOT_SET;
 
        /* Read global_params section */
@@ -5705,10 +6193,9 @@ static enum dbg_status qed_parse_idle_chk_dump(struct qed_hwfn *p_hwfn,
                                         &section_name, &num_section_params);
        if (strcmp(section_name, "idle_chk") || num_section_params != 1)
                return DBG_STATUS_IDLE_CHK_PARSE_FAILED;
-
        dump_buf += qed_read_param(dump_buf,
                                   &param_name, &param_str_val, &num_rules);
-       if (strcmp(param_name, "num_rules") != 0)
+       if (strcmp(param_name, "num_rules"))
                return DBG_STATUS_IDLE_CHK_PARSE_FAILED;
 
        if (num_rules) {
@@ -5728,7 +6215,7 @@ static enum dbg_status qed_parse_idle_chk_dump(struct qed_hwfn *p_hwfn,
                                                      results_offset : NULL,
                                                      num_errors, num_warnings);
                results_offset += rules_print_size;
-               if (rules_print_size == 0)
+               if (!rules_print_size)
                        return DBG_STATUS_IDLE_CHK_PARSE_FAILED;
 
                /* Print LSI output */
@@ -5745,69 +6232,38 @@ static enum dbg_status qed_parse_idle_chk_dump(struct qed_hwfn *p_hwfn,
                                                      results_offset : NULL,
                                                      num_errors, num_warnings);
                results_offset += rules_print_size;
-               if (rules_print_size == 0)
+               if (!rules_print_size)
                        return DBG_STATUS_IDLE_CHK_PARSE_FAILED;
        }
 
        /* Print errors/warnings count */
-       if (*num_errors) {
+       if (*num_errors)
                results_offset +=
                    sprintf(qed_get_buf_ptr(results_buf,
                                            results_offset),
                            "\nIdle Check failed!!! (with %d errors and %d warnings)\n",
                            *num_errors, *num_warnings);
-       } else if (*num_warnings) {
+       else if (*num_warnings)
                results_offset +=
                    sprintf(qed_get_buf_ptr(results_buf,
                                            results_offset),
-                           "\nIdle Check completed successfuly (with %d warnings)\n",
+                           "\nIdle Check completed successfully (with %d warnings)\n",
                            *num_warnings);
-       } else {
+       else
                results_offset +=
                    sprintf(qed_get_buf_ptr(results_buf,
                                            results_offset),
-                           "\nIdle Check completed successfuly\n");
-       }
+                           "\nIdle Check completed successfully\n");
 
        /* Add 1 for string NULL termination */
        *parsed_results_bytes = results_offset + 1;
+
        return DBG_STATUS_OK;
 }
 
-enum dbg_status qed_get_idle_chk_results_buf_size(struct qed_hwfn *p_hwfn,
-                                                 u32 *dump_buf,
-                                                 u32 num_dumped_dwords,
-                                                 u32 *results_buf_size)
-{
-       u32 num_errors, num_warnings;
-
-       return qed_parse_idle_chk_dump(p_hwfn,
-                                      dump_buf,
-                                      num_dumped_dwords,
-                                      NULL,
-                                      results_buf_size,
-                                      &num_errors, &num_warnings);
-}
-
-enum dbg_status qed_print_idle_chk_results(struct qed_hwfn *p_hwfn,
-                                          u32 *dump_buf,
-                                          u32 num_dumped_dwords,
-                                          char *results_buf,
-                                          u32 *num_errors, u32 *num_warnings)
-{
-       u32 parsed_buf_size;
-
-       return qed_parse_idle_chk_dump(p_hwfn,
-                                      dump_buf,
-                                      num_dumped_dwords,
-                                      results_buf,
-                                      &parsed_buf_size,
-                                      num_errors, num_warnings);
-}
-
-/* Frees the specified MCP Trace meta data */
-static void qed_mcp_trace_free_meta(struct qed_hwfn *p_hwfn,
-                                   struct mcp_trace_meta *meta)
+/* Frees the specified MCP Trace meta data */
+static void qed_mcp_trace_free_meta(struct qed_hwfn *p_hwfn,
+                                   struct mcp_trace_meta *meta)
 {
        u32 i;
 
@@ -5841,12 +6297,10 @@ static enum dbg_status qed_mcp_trace_alloc_meta(struct qed_hwfn *p_hwfn,
 
        /* Read first signature */
        signature = qed_read_dword_from_buf(meta_buf_bytes, &offset);
-       if (signature != MCP_TRACE_META_IMAGE_SIGNATURE)
+       if (signature != NVM_MAGIC_VALUE)
                return DBG_STATUS_INVALID_TRACE_SIGNATURE;
 
-       /* Read number of modules and allocate memory for all the modules
-        * pointers.
-        */
+       /* Read no. of modules and allocate memory for their pointers */
        meta->modules_num = qed_read_byte_from_buf(meta_buf_bytes, &offset);
        meta->modules = kzalloc(meta->modules_num * sizeof(char *), GFP_KERNEL);
        if (!meta->modules)
@@ -5871,7 +6325,7 @@ static enum dbg_status qed_mcp_trace_alloc_meta(struct qed_hwfn *p_hwfn,
 
        /* Read second signature */
        signature = qed_read_dword_from_buf(meta_buf_bytes, &offset);
-       if (signature != MCP_TRACE_META_IMAGE_SIGNATURE)
+       if (signature != NVM_MAGIC_VALUE)
                return DBG_STATUS_INVALID_TRACE_SIGNATURE;
 
        /* Read number of formats and allocate memory for all formats */
@@ -5919,10 +6373,10 @@ static enum dbg_status qed_parse_mcp_trace_dump(struct qed_hwfn *p_hwfn,
                                                char *results_buf,
                                                u32 *parsed_results_bytes)
 {
-       u32 results_offset = 0, param_mask, param_shift, param_num_val;
-       u32 num_section_params, offset, end_offset, bytes_left;
+       u32 end_offset, bytes_left, trace_data_dwords, trace_meta_dwords;
+       u32 param_mask, param_shift, param_num_val, num_section_params;
        const char *section_name, *param_name, *param_str_val;
-       u32 trace_data_dwords, trace_meta_dwords;
+       u32 offset, results_offset = 0;
        struct mcp_trace_meta meta;
        struct mcp_trace *trace;
        enum dbg_status status;
@@ -5955,7 +6409,7 @@ static enum dbg_status qed_parse_mcp_trace_dump(struct qed_hwfn *p_hwfn,
 
        /* Prepare trace info */
        trace = (struct mcp_trace *)dump_buf;
-       trace_buf = (u8 *)dump_buf + sizeof(struct mcp_trace);
+       trace_buf = (u8 *)dump_buf + sizeof(*trace);
        offset = trace->trace_oldest;
        end_offset = trace->trace_prod;
        bytes_left = qed_cyclic_sub(end_offset, offset, trace->size);
@@ -5968,7 +6422,7 @@ static enum dbg_status qed_parse_mcp_trace_dump(struct qed_hwfn *p_hwfn,
                return DBG_STATUS_MCP_TRACE_BAD_DATA;
        dump_buf += qed_read_param(dump_buf,
                                   &param_name, &param_str_val, &param_num_val);
-       if (strcmp(param_name, "size") != 0)
+       if (strcmp(param_name, "size"))
                return DBG_STATUS_MCP_TRACE_BAD_DATA;
        trace_meta_dwords = param_num_val;
 
@@ -6028,6 +6482,7 @@ static enum dbg_status qed_parse_mcp_trace_dump(struct qed_hwfn *p_hwfn,
                }
 
                format_ptr = &meta.formats[format_idx];
+
                for (i = 0,
                     param_mask = MCP_TRACE_FORMAT_P1_SIZE_MASK, param_shift =
                     MCP_TRACE_FORMAT_P1_SIZE_SHIFT;
@@ -6050,6 +6505,7 @@ static enum dbg_status qed_parse_mcp_trace_dump(struct qed_hwfn *p_hwfn,
                         */
                        if (param_size == 3)
                                param_size = 4;
+
                        if (bytes_left < param_size) {
                                status = DBG_STATUS_MCP_TRACE_BAD_DATA;
                                goto free_mem;
@@ -6059,13 +6515,14 @@ static enum dbg_status qed_parse_mcp_trace_dump(struct qed_hwfn *p_hwfn,
                                                             &offset,
                                                             trace->size,
                                                             param_size);
+
                        bytes_left -= param_size;
                }
 
                format_level =
                    (u8)((format_ptr->data &
                          MCP_TRACE_FORMAT_LEVEL_MASK) >>
-                         MCP_TRACE_FORMAT_LEVEL_SHIFT);
+                        MCP_TRACE_FORMAT_LEVEL_SHIFT);
                format_module =
                    (u8)((format_ptr->data &
                          MCP_TRACE_FORMAT_MODULE_MASK) >>
@@ -6094,30 +6551,6 @@ free_mem:
        return status;
 }
 
-enum dbg_status qed_get_mcp_trace_results_buf_size(struct qed_hwfn *p_hwfn,
-                                                  u32 *dump_buf,
-                                                  u32 num_dumped_dwords,
-                                                  u32 *results_buf_size)
-{
-       return qed_parse_mcp_trace_dump(p_hwfn,
-                                       dump_buf,
-                                       num_dumped_dwords,
-                                       NULL, results_buf_size);
-}
-
-enum dbg_status qed_print_mcp_trace_results(struct qed_hwfn *p_hwfn,
-                                           u32 *dump_buf,
-                                           u32 num_dumped_dwords,
-                                           char *results_buf)
-{
-       u32 parsed_buf_size;
-
-       return qed_parse_mcp_trace_dump(p_hwfn,
-                                       dump_buf,
-                                       num_dumped_dwords,
-                                       results_buf, &parsed_buf_size);
-}
-
 /* Parses a Reg FIFO dump buffer.
  * If result_buf is not NULL, the Reg FIFO results are printed to it.
  * In any case, the required results buffer size is assigned to
@@ -6130,10 +6563,11 @@ static enum dbg_status qed_parse_reg_fifo_dump(struct qed_hwfn *p_hwfn,
                                               char *results_buf,
                                               u32 *parsed_results_bytes)
 {
-       u32 results_offset = 0, param_num_val, num_section_params, num_elements;
        const char *section_name, *param_name, *param_str_val;
+       u32 param_num_val, num_section_params, num_elements;
        struct reg_fifo_element *elements;
        u8 i, j, err_val, vf_val;
+       u32 results_offset = 0;
        char vf_str[4];
 
        /* Read global_params section */
@@ -6179,17 +6613,17 @@ static enum dbg_status qed_parse_reg_fifo_dump(struct qed_hwfn *p_hwfn,
                            "raw: 0x%016llx, address: 0x%07x, access: %-5s, pf: %2d, vf: %s, port: %d, privilege: %-3s, protection: %-12s, master: %-4s, errors: ",
                            elements[i].data,
                            (u32)GET_FIELD(elements[i].data,
-                                     REG_FIFO_ELEMENT_ADDRESS) *
-                                     REG_FIFO_ELEMENT_ADDR_FACTOR,
-                                     s_access_strs[GET_FIELD(elements[i].data,
+                                          REG_FIFO_ELEMENT_ADDRESS) *
+                           REG_FIFO_ELEMENT_ADDR_FACTOR,
+                           s_access_strs[GET_FIELD(elements[i].data,
                                                    REG_FIFO_ELEMENT_ACCESS)],
                            (u32)GET_FIELD(elements[i].data,
-                                          REG_FIFO_ELEMENT_PF), vf_str,
+                                          REG_FIFO_ELEMENT_PF),
+                           vf_str,
                            (u32)GET_FIELD(elements[i].data,
-                                     REG_FIFO_ELEMENT_PORT),
-                                     s_privilege_strs[GET_FIELD(elements[i].
-                                     data,
-                                     REG_FIFO_ELEMENT_PRIVILEGE)],
+                                          REG_FIFO_ELEMENT_PORT),
+                           s_privilege_strs[GET_FIELD(elements[i].data,
+                                               REG_FIFO_ELEMENT_PRIVILEGE)],
                            s_protection_strs[GET_FIELD(elements[i].data,
                                                REG_FIFO_ELEMENT_PROTECTION)],
                            s_master_strs[GET_FIELD(elements[i].data,
@@ -6201,18 +6635,18 @@ static enum dbg_status qed_parse_reg_fifo_dump(struct qed_hwfn *p_hwfn,
                                         REG_FIFO_ELEMENT_ERROR);
                     j < ARRAY_SIZE(s_reg_fifo_error_strs);
                     j++, err_val >>= 1) {
-                       if (!(err_val & 0x1))
-                               continue;
-                       if (err_printed)
+                       if (err_val & 0x1) {
+                               if (err_printed)
+                                       results_offset +=
+                                           sprintf(qed_get_buf_ptr
+                                                   (results_buf,
+                                                    results_offset), ", ");
                                results_offset +=
-                                       sprintf(qed_get_buf_ptr(results_buf,
-                                                               results_offset),
-                                               ", ");
-                       results_offset +=
-                               sprintf(qed_get_buf_ptr(results_buf,
-                                                       results_offset), "%s",
-                                       s_reg_fifo_error_strs[j]);
-                       err_printed = true;
+                                   sprintf(qed_get_buf_ptr
+                                           (results_buf, results_offset), "%s",
+                                           s_reg_fifo_error_strs[j]);
+                               err_printed = true;
+                       }
                }
 
                results_offset +=
@@ -6225,31 +6659,140 @@ static enum dbg_status qed_parse_reg_fifo_dump(struct qed_hwfn *p_hwfn,
 
        /* Add 1 for string NULL termination */
        *parsed_results_bytes = results_offset + 1;
+
        return DBG_STATUS_OK;
 }
 
-enum dbg_status qed_get_reg_fifo_results_buf_size(struct qed_hwfn *p_hwfn,
-                                                 u32 *dump_buf,
-                                                 u32 num_dumped_dwords,
-                                                 u32 *results_buf_size)
+static enum dbg_status qed_parse_igu_fifo_element(struct igu_fifo_element
+                                                 *element, char
+                                                 *results_buf,
+                                                 u32 *results_offset,
+                                                 u32 *parsed_results_bytes)
 {
-       return qed_parse_reg_fifo_dump(p_hwfn,
-                                      dump_buf,
-                                      num_dumped_dwords,
-                                      NULL, results_buf_size);
-}
+       const struct igu_fifo_addr_data *found_addr = NULL;
+       u8 source, err_type, i, is_cleanup;
+       char parsed_addr_data[32];
+       char parsed_wr_data[256];
+       u32 wr_data, prod_cons;
+       bool is_wr_cmd, is_pf;
+       u16 cmd_addr;
+       u64 dword12;
 
-enum dbg_status qed_print_reg_fifo_results(struct qed_hwfn *p_hwfn,
-                                          u32 *dump_buf,
-                                          u32 num_dumped_dwords,
-                                          char *results_buf)
-{
-       u32 parsed_buf_size;
+       /* Dword12 (dword index 1 and 2) contains bits 32..95 of the
+        * FIFO element.
+        */
+       dword12 = ((u64)element->dword2 << 32) | element->dword1;
+       is_wr_cmd = GET_FIELD(dword12, IGU_FIFO_ELEMENT_DWORD12_IS_WR_CMD);
+       is_pf = GET_FIELD(element->dword0, IGU_FIFO_ELEMENT_DWORD0_IS_PF);
+       cmd_addr = GET_FIELD(element->dword0, IGU_FIFO_ELEMENT_DWORD0_CMD_ADDR);
+       source = GET_FIELD(element->dword0, IGU_FIFO_ELEMENT_DWORD0_SOURCE);
+       err_type = GET_FIELD(element->dword0, IGU_FIFO_ELEMENT_DWORD0_ERR_TYPE);
+
+       if (source >= ARRAY_SIZE(s_igu_fifo_source_strs))
+               return DBG_STATUS_IGU_FIFO_BAD_DATA;
+       if (err_type >= ARRAY_SIZE(s_igu_fifo_error_strs))
+               return DBG_STATUS_IGU_FIFO_BAD_DATA;
 
-       return qed_parse_reg_fifo_dump(p_hwfn,
-                                      dump_buf,
-                                      num_dumped_dwords,
-                                      results_buf, &parsed_buf_size);
+       /* Find address data */
+       for (i = 0; i < ARRAY_SIZE(s_igu_fifo_addr_data) && !found_addr; i++) {
+               const struct igu_fifo_addr_data *curr_addr =
+                       &s_igu_fifo_addr_data[i];
+
+               if (cmd_addr >= curr_addr->start_addr && cmd_addr <=
+                   curr_addr->end_addr)
+                       found_addr = curr_addr;
+       }
+
+       if (!found_addr)
+               return DBG_STATUS_IGU_FIFO_BAD_DATA;
+
+       /* Prepare parsed address data */
+       switch (found_addr->type) {
+       case IGU_ADDR_TYPE_MSIX_MEM:
+               sprintf(parsed_addr_data, " vector_num = 0x%x", cmd_addr / 2);
+               break;
+       case IGU_ADDR_TYPE_WRITE_INT_ACK:
+       case IGU_ADDR_TYPE_WRITE_PROD_UPDATE:
+               sprintf(parsed_addr_data,
+                       " SB = 0x%x", cmd_addr - found_addr->start_addr);
+               break;
+       default:
+               parsed_addr_data[0] = '\0';
+       }
+
+       if (!is_wr_cmd) {
+               parsed_wr_data[0] = '\0';
+               goto out;
+       }
+
+       /* Prepare parsed write data */
+       wr_data = GET_FIELD(dword12, IGU_FIFO_ELEMENT_DWORD12_WR_DATA);
+       prod_cons = GET_FIELD(wr_data, IGU_FIFO_WR_DATA_PROD_CONS);
+       is_cleanup = GET_FIELD(wr_data, IGU_FIFO_WR_DATA_CMD_TYPE);
+
+       if (source == IGU_SRC_ATTN) {
+               sprintf(parsed_wr_data, "prod: 0x%x, ", prod_cons);
+       } else {
+               if (is_cleanup) {
+                       u8 cleanup_val, cleanup_type;
+
+                       cleanup_val =
+                               GET_FIELD(wr_data,
+                                         IGU_FIFO_CLEANUP_WR_DATA_CLEANUP_VAL);
+                       cleanup_type =
+                           GET_FIELD(wr_data,
+                                     IGU_FIFO_CLEANUP_WR_DATA_CLEANUP_TYPE);
+
+                       sprintf(parsed_wr_data,
+                               "cmd_type: cleanup, cleanup_val: %s, cleanup_type : %d, ",
+                               cleanup_val ? "set" : "clear",
+                               cleanup_type);
+               } else {
+                       u8 update_flag, en_dis_int_for_sb, segment;
+                       u8 timer_mask;
+
+                       update_flag = GET_FIELD(wr_data,
+                                               IGU_FIFO_WR_DATA_UPDATE_FLAG);
+                       en_dis_int_for_sb =
+                               GET_FIELD(wr_data,
+                                         IGU_FIFO_WR_DATA_EN_DIS_INT_FOR_SB);
+                       segment = GET_FIELD(wr_data,
+                                           IGU_FIFO_WR_DATA_SEGMENT);
+                       timer_mask = GET_FIELD(wr_data,
+                                              IGU_FIFO_WR_DATA_TIMER_MASK);
+
+                       sprintf(parsed_wr_data,
+                               "cmd_type: prod/cons update, prod/cons: 0x%x, update_flag: %s, en_dis_int_for_sb : %s, segment : %s, timer_mask = %d, ",
+                               prod_cons,
+                               update_flag ? "update" : "nop",
+                               en_dis_int_for_sb
+                               ? (en_dis_int_for_sb == 1 ? "disable" : "nop")
+                               : "enable",
+                               segment ? "attn" : "regular",
+                               timer_mask);
+               }
+       }
+out:
+       /* Add parsed element to parsed buffer */
+       *results_offset += sprintf(qed_get_buf_ptr(results_buf,
+                                                  *results_offset),
+                                  "raw: 0x%01x%08x%08x, %s: %d, source : %s, type : %s, cmd_addr : 0x%x(%s%s), %serror: %s\n",
+                                  element->dword2, element->dword1,
+                                  element->dword0,
+                                  is_pf ? "pf" : "vf",
+                                  GET_FIELD(element->dword0,
+                                            IGU_FIFO_ELEMENT_DWORD0_FID),
+                                  s_igu_fifo_source_strs[source],
+                                  is_wr_cmd ? "wr" : "rd",
+                                  cmd_addr,
+                                  (!is_pf && found_addr->vf_desc)
+                                  ? found_addr->vf_desc
+                                  : found_addr->desc,
+                                  parsed_addr_data,
+                                  parsed_wr_data,
+                                  s_igu_fifo_error_strs[err_type]);
+
+       return DBG_STATUS_OK;
 }
 
 /* Parses an IGU FIFO dump buffer.
@@ -6264,12 +6807,12 @@ static enum dbg_status qed_parse_igu_fifo_dump(struct qed_hwfn *p_hwfn,
                                               char *results_buf,
                                               u32 *parsed_results_bytes)
 {
-       u32 results_offset = 0, param_num_val, num_section_params, num_elements;
        const char *section_name, *param_name, *param_str_val;
+       u32 param_num_val, num_section_params, num_elements;
        struct igu_fifo_element *elements;
-       char parsed_addr_data[32];
-       char parsed_wr_data[256];
-       u8 i, j;
+       enum dbg_status status;
+       u32 results_offset = 0;
+       u8 i;
 
        /* Read global_params section */
        dump_buf += qed_read_section_hdr(dump_buf,
@@ -6298,118 +6841,12 @@ static enum dbg_status qed_parse_igu_fifo_dump(struct qed_hwfn *p_hwfn,
 
        /* Decode elements */
        for (i = 0; i < num_elements; i++) {
-               /* dword12 (dword index 1 and 2) contains bits 32..95 of the
-                * FIFO element.
-                */
-               u64 dword12 =
-                   ((u64)elements[i].dword2 << 32) | elements[i].dword1;
-               bool is_wr_cmd = GET_FIELD(dword12,
-                                          IGU_FIFO_ELEMENT_DWORD12_IS_WR_CMD);
-               bool is_pf = GET_FIELD(elements[i].dword0,
-                                      IGU_FIFO_ELEMENT_DWORD0_IS_PF);
-               u16 cmd_addr = GET_FIELD(elements[i].dword0,
-                                        IGU_FIFO_ELEMENT_DWORD0_CMD_ADDR);
-               u8 source = GET_FIELD(elements[i].dword0,
-                                     IGU_FIFO_ELEMENT_DWORD0_SOURCE);
-               u8 err_type = GET_FIELD(elements[i].dword0,
-                                       IGU_FIFO_ELEMENT_DWORD0_ERR_TYPE);
-               const struct igu_fifo_addr_data *addr_data = NULL;
-
-               if (source >= ARRAY_SIZE(s_igu_fifo_source_strs))
-                       return DBG_STATUS_IGU_FIFO_BAD_DATA;
-               if (err_type >= ARRAY_SIZE(s_igu_fifo_error_strs))
-                       return DBG_STATUS_IGU_FIFO_BAD_DATA;
-
-               /* Find address data */
-               for (j = 0; j < ARRAY_SIZE(s_igu_fifo_addr_data) && !addr_data;
-                    j++)
-                       if (cmd_addr >= s_igu_fifo_addr_data[j].start_addr &&
-                           cmd_addr <= s_igu_fifo_addr_data[j].end_addr)
-                               addr_data = &s_igu_fifo_addr_data[j];
-               if (!addr_data)
-                       return DBG_STATUS_IGU_FIFO_BAD_DATA;
-
-               /* Prepare parsed address data */
-               switch (addr_data->type) {
-               case IGU_ADDR_TYPE_MSIX_MEM:
-                       sprintf(parsed_addr_data,
-                               " vector_num=0x%x", cmd_addr / 2);
-                       break;
-               case IGU_ADDR_TYPE_WRITE_INT_ACK:
-               case IGU_ADDR_TYPE_WRITE_PROD_UPDATE:
-                       sprintf(parsed_addr_data,
-                               " SB=0x%x", cmd_addr - addr_data->start_addr);
-                       break;
-               default:
-                       parsed_addr_data[0] = '\0';
-               }
-
-               /* Prepare parsed write data */
-               if (is_wr_cmd) {
-                       u32 wr_data = GET_FIELD(dword12,
-                                       IGU_FIFO_ELEMENT_DWORD12_WR_DATA);
-                       u32 prod_cons = GET_FIELD(wr_data,
-                                                 IGU_FIFO_WR_DATA_PROD_CONS);
-                       u8 is_cleanup = GET_FIELD(wr_data,
-                                                 IGU_FIFO_WR_DATA_CMD_TYPE);
-
-                       if (source == IGU_SRC_ATTN) {
-                               sprintf(parsed_wr_data,
-                                       "prod: 0x%x, ", prod_cons);
-                       } else {
-                               if (is_cleanup) {
-                                       u8 cleanup_val = GET_FIELD(wr_data,
-                                                                  IGU_FIFO_CLEANUP_WR_DATA_CLEANUP_VAL);
-                                       u8 cleanup_type = GET_FIELD(wr_data,
-                                                                   IGU_FIFO_CLEANUP_WR_DATA_CLEANUP_TYPE);
-
-                                       sprintf(parsed_wr_data,
-                                               "cmd_type: cleanup, cleanup_val: %s, cleanup_type: %d, ",
-                                               cleanup_val ? "set" : "clear",
-                                               cleanup_type);
-                               } else {
-                                       u8 update_flag = GET_FIELD(wr_data,
-                                                                  IGU_FIFO_WR_DATA_UPDATE_FLAG);
-                                       u8 en_dis_int_for_sb =
-                                           GET_FIELD(wr_data,
-                                                     IGU_FIFO_WR_DATA_EN_DIS_INT_FOR_SB);
-                                       u8 segment = GET_FIELD(wr_data,
-                                                              IGU_FIFO_WR_DATA_SEGMENT);
-                                       u8 timer_mask = GET_FIELD(wr_data,
-                                                                 IGU_FIFO_WR_DATA_TIMER_MASK);
-
-                                       sprintf(parsed_wr_data,
-                                               "cmd_type: prod/cons update, prod/cons: 0x%x, update_flag: %s, en_dis_int_for_sb: %s, segment: %s, timer_mask=%d, ",
-                                               prod_cons,
-                                               update_flag ? "update" : "nop",
-                                               en_dis_int_for_sb
-                                               ? (en_dis_int_for_sb ==
-                                                  1 ? "disable" : "nop") :
-                                               "enable",
-                                               segment ? "attn" : "regular",
-                                               timer_mask);
-                               }
-                       }
-               } else {
-                       parsed_wr_data[0] = '\0';
-               }
-
-               /* Add parsed element to parsed buffer */
-               results_offset +=
-                   sprintf(qed_get_buf_ptr(results_buf,
-                                           results_offset),
-                           "raw: 0x%01x%08x%08x, %s: %d, source: %s, type: %s, cmd_addr: 0x%x (%s%s), %serror: %s\n",
-                           elements[i].dword2, elements[i].dword1,
-                           elements[i].dword0,
-                           is_pf ? "pf" : "vf",
-                           GET_FIELD(elements[i].dword0,
-                                     IGU_FIFO_ELEMENT_DWORD0_FID),
-                           s_igu_fifo_source_strs[source],
-                           is_wr_cmd ? "wr" : "rd", cmd_addr,
-                           (!is_pf && addr_data->vf_desc)
-                           ? addr_data->vf_desc : addr_data->desc,
-                           parsed_addr_data, parsed_wr_data,
-                           s_igu_fifo_error_strs[err_type]);
+               status = qed_parse_igu_fifo_element(&elements[i],
+                                                   results_buf,
+                                                   &results_offset,
+                                                   parsed_results_bytes);
+               if (status != DBG_STATUS_OK)
+                       return status;
        }
 
        results_offset += sprintf(qed_get_buf_ptr(results_buf,
@@ -6418,31 +6855,8 @@ static enum dbg_status qed_parse_igu_fifo_dump(struct qed_hwfn *p_hwfn,
 
        /* Add 1 for string NULL termination */
        *parsed_results_bytes = results_offset + 1;
-       return DBG_STATUS_OK;
-}
-
-enum dbg_status qed_get_igu_fifo_results_buf_size(struct qed_hwfn *p_hwfn,
-                                                 u32 *dump_buf,
-                                                 u32 num_dumped_dwords,
-                                                 u32 *results_buf_size)
-{
-       return qed_parse_igu_fifo_dump(p_hwfn,
-                                      dump_buf,
-                                      num_dumped_dwords,
-                                      NULL, results_buf_size);
-}
-
-enum dbg_status qed_print_igu_fifo_results(struct qed_hwfn *p_hwfn,
-                                          u32 *dump_buf,
-                                          u32 num_dumped_dwords,
-                                          char *results_buf)
-{
-       u32 parsed_buf_size;
 
-       return qed_parse_igu_fifo_dump(p_hwfn,
-                                      dump_buf,
-                                      num_dumped_dwords,
-                                      results_buf, &parsed_buf_size);
+       return DBG_STATUS_OK;
 }
 
 static enum dbg_status
@@ -6452,9 +6866,10 @@ qed_parse_protection_override_dump(struct qed_hwfn *p_hwfn,
                                   char *results_buf,
                                   u32 *parsed_results_bytes)
 {
-       u32 results_offset = 0, param_num_val, num_section_params, num_elements;
        const char *section_name, *param_name, *param_str_val;
+       u32 param_num_val, num_section_params, num_elements;
        struct protection_override_element *elements;
+       u32 results_offset = 0;
        u8 i;
 
        /* Read global_params section */
@@ -6477,7 +6892,7 @@ qed_parse_protection_override_dump(struct qed_hwfn *p_hwfn,
                                   &param_name, &param_str_val, &param_num_val);
        if (strcmp(param_name, "size"))
                return DBG_STATUS_PROTECTION_OVERRIDE_BAD_DATA;
-       if (param_num_val % PROTECTION_OVERRIDE_ELEMENT_DWORDS != 0)
+       if (param_num_val % PROTECTION_OVERRIDE_ELEMENT_DWORDS)
                return DBG_STATUS_PROTECTION_OVERRIDE_BAD_DATA;
        num_elements = param_num_val / PROTECTION_OVERRIDE_ELEMENT_DWORDS;
        elements = (struct protection_override_element *)dump_buf;
@@ -6486,7 +6901,7 @@ qed_parse_protection_override_dump(struct qed_hwfn *p_hwfn,
        for (i = 0; i < num_elements; i++) {
                u32 address = GET_FIELD(elements[i].data,
                                        PROTECTION_OVERRIDE_ELEMENT_ADDRESS) *
-                                       PROTECTION_OVERRIDE_ELEMENT_ADDR_FACTOR;
+                             PROTECTION_OVERRIDE_ELEMENT_ADDR_FACTOR;
 
                results_offset +=
                    sprintf(qed_get_buf_ptr(results_buf,
@@ -6512,33 +6927,8 @@ qed_parse_protection_override_dump(struct qed_hwfn *p_hwfn,
 
        /* Add 1 for string NULL termination */
        *parsed_results_bytes = results_offset + 1;
-       return DBG_STATUS_OK;
-}
-
-enum dbg_status
-qed_get_protection_override_results_buf_size(struct qed_hwfn *p_hwfn,
-                                            u32 *dump_buf,
-                                            u32 num_dumped_dwords,
-                                            u32 *results_buf_size)
-{
-       return qed_parse_protection_override_dump(p_hwfn,
-                                                 dump_buf,
-                                                 num_dumped_dwords,
-                                                 NULL, results_buf_size);
-}
 
-enum dbg_status qed_print_protection_override_results(struct qed_hwfn *p_hwfn,
-                                                     u32 *dump_buf,
-                                                     u32 num_dumped_dwords,
-                                                     char *results_buf)
-{
-       u32 parsed_buf_size;
-
-       return qed_parse_protection_override_dump(p_hwfn,
-                                                 dump_buf,
-                                                 num_dumped_dwords,
-                                                 results_buf,
-                                                 &parsed_buf_size);
+       return DBG_STATUS_OK;
 }
 
 /* Parses a FW Asserts dump buffer.
@@ -6553,7 +6943,7 @@ static enum dbg_status qed_parse_fw_asserts_dump(struct qed_hwfn *p_hwfn,
                                                 char *results_buf,
                                                 u32 *parsed_results_bytes)
 {
-       u32 results_offset = 0, num_section_params, param_num_val, i;
+       u32 num_section_params, param_num_val, i, results_offset = 0;
        const char *param_name, *param_str_val, *section_name;
        bool last_section_found = false;
 
@@ -6569,54 +6959,216 @@ static enum dbg_status qed_parse_fw_asserts_dump(struct qed_hwfn *p_hwfn,
        dump_buf += qed_print_section_params(dump_buf,
                                             num_section_params,
                                             results_buf, &results_offset);
-       while (!last_section_found) {
-               const char *storm_letter = NULL;
-               u32 storm_dump_size = 0;
 
+       while (!last_section_found) {
                dump_buf += qed_read_section_hdr(dump_buf,
                                                 &section_name,
                                                 &num_section_params);
-               if (!strcmp(section_name, "last")) {
-                       last_section_found = true;
-                       continue;
-               } else if (strcmp(section_name, "fw_asserts")) {
-                       return DBG_STATUS_FW_ASSERTS_PARSE_FAILED;
-               }
+               if (!strcmp(section_name, "fw_asserts")) {
+                       /* Extract params */
+                       const char *storm_letter = NULL;
+                       u32 storm_dump_size = 0;
+
+                       for (i = 0; i < num_section_params; i++) {
+                               dump_buf += qed_read_param(dump_buf,
+                                                          &param_name,
+                                                          &param_str_val,
+                                                          &param_num_val);
+                               if (!strcmp(param_name, "storm"))
+                                       storm_letter = param_str_val;
+                               else if (!strcmp(param_name, "size"))
+                                       storm_dump_size = param_num_val;
+                               else
+                                       return
+                                           DBG_STATUS_FW_ASSERTS_PARSE_FAILED;
+                       }
 
-               /* Extract params */
-               for (i = 0; i < num_section_params; i++) {
-                       dump_buf += qed_read_param(dump_buf,
-                                                  &param_name,
-                                                  &param_str_val,
-                                                  &param_num_val);
-                       if (!strcmp(param_name, "storm"))
-                               storm_letter = param_str_val;
-                       else if (!strcmp(param_name, "size"))
-                               storm_dump_size = param_num_val;
-                       else
+                       if (!storm_letter || !storm_dump_size)
                                return DBG_STATUS_FW_ASSERTS_PARSE_FAILED;
-               }
-
-               if (!storm_letter || !storm_dump_size)
-                       return DBG_STATUS_FW_ASSERTS_PARSE_FAILED;
 
-               /* Print data */
-               results_offset += sprintf(qed_get_buf_ptr(results_buf,
-                                                         results_offset),
-                                         "\n%sSTORM_ASSERT: size=%d\n",
-                                         storm_letter, storm_dump_size);
-               for (i = 0; i < storm_dump_size; i++, dump_buf++)
+                       /* Print data */
                        results_offset +=
                            sprintf(qed_get_buf_ptr(results_buf,
                                                    results_offset),
-                                   "%08x\n", *dump_buf);
+                                   "\n%sSTORM_ASSERT: size=%d\n",
+                                   storm_letter, storm_dump_size);
+                       for (i = 0; i < storm_dump_size; i++, dump_buf++)
+                               results_offset +=
+                                   sprintf(qed_get_buf_ptr(results_buf,
+                                                           results_offset),
+                                           "%08x\n", *dump_buf);
+               } else if (!strcmp(section_name, "last")) {
+                       last_section_found = true;
+               } else {
+                       return DBG_STATUS_FW_ASSERTS_PARSE_FAILED;
+               }
        }
 
        /* Add 1 for string NULL termination */
        *parsed_results_bytes = results_offset + 1;
+
+       return DBG_STATUS_OK;
+}
+
+/***************************** Public Functions *******************************/
+
+enum dbg_status qed_dbg_user_set_bin_ptr(const u8 * const bin_ptr)
+{
+       struct bin_buffer_hdr *buf_array = (struct bin_buffer_hdr *)bin_ptr;
+       u8 buf_id;
+
+       /* Convert binary data to debug arrays */
+       for (buf_id = 0; buf_id < MAX_BIN_DBG_BUFFER_TYPE; buf_id++) {
+               s_user_dbg_arrays[buf_id].ptr =
+                       (u32 *)(bin_ptr + buf_array[buf_id].offset);
+               s_user_dbg_arrays[buf_id].size_in_dwords =
+                       BYTES_TO_DWORDS(buf_array[buf_id].length);
+       }
+
        return DBG_STATUS_OK;
 }
 
+const char *qed_dbg_get_status_str(enum dbg_status status)
+{
+       return (status <
+               MAX_DBG_STATUS) ? s_status_str[status] : "Invalid debug status";
+}
+
+enum dbg_status qed_get_idle_chk_results_buf_size(struct qed_hwfn *p_hwfn,
+                                                 u32 *dump_buf,
+                                                 u32 num_dumped_dwords,
+                                                 u32 *results_buf_size)
+{
+       u32 num_errors, num_warnings;
+
+       return qed_parse_idle_chk_dump(p_hwfn,
+                                      dump_buf,
+                                      num_dumped_dwords,
+                                      NULL,
+                                      results_buf_size,
+                                      &num_errors, &num_warnings);
+}
+
+enum dbg_status qed_print_idle_chk_results(struct qed_hwfn *p_hwfn,
+                                          u32 *dump_buf,
+                                          u32 num_dumped_dwords,
+                                          char *results_buf,
+                                          u32 *num_errors, u32 *num_warnings)
+{
+       u32 parsed_buf_size;
+
+       return qed_parse_idle_chk_dump(p_hwfn,
+                                      dump_buf,
+                                      num_dumped_dwords,
+                                      results_buf,
+                                      &parsed_buf_size,
+                                      num_errors, num_warnings);
+}
+
+void qed_dbg_mcp_trace_set_meta_data(u32 *data, u32 size)
+{
+       s_mcp_trace_meta.ptr = data;
+       s_mcp_trace_meta.size_in_dwords = size;
+}
+
+enum dbg_status qed_get_mcp_trace_results_buf_size(struct qed_hwfn *p_hwfn,
+                                                  u32 *dump_buf,
+                                                  u32 num_dumped_dwords,
+                                                  u32 *results_buf_size)
+{
+       return qed_parse_mcp_trace_dump(p_hwfn,
+                                       dump_buf,
+                                       num_dumped_dwords,
+                                       NULL, results_buf_size);
+}
+
+enum dbg_status qed_print_mcp_trace_results(struct qed_hwfn *p_hwfn,
+                                           u32 *dump_buf,
+                                           u32 num_dumped_dwords,
+                                           char *results_buf)
+{
+       u32 parsed_buf_size;
+
+       return qed_parse_mcp_trace_dump(p_hwfn,
+                                       dump_buf,
+                                       num_dumped_dwords,
+                                       results_buf, &parsed_buf_size);
+}
+
+enum dbg_status qed_get_reg_fifo_results_buf_size(struct qed_hwfn *p_hwfn,
+                                                 u32 *dump_buf,
+                                                 u32 num_dumped_dwords,
+                                                 u32 *results_buf_size)
+{
+       return qed_parse_reg_fifo_dump(p_hwfn,
+                                      dump_buf,
+                                      num_dumped_dwords,
+                                      NULL, results_buf_size);
+}
+
+enum dbg_status qed_print_reg_fifo_results(struct qed_hwfn *p_hwfn,
+                                          u32 *dump_buf,
+                                          u32 num_dumped_dwords,
+                                          char *results_buf)
+{
+       u32 parsed_buf_size;
+
+       return qed_parse_reg_fifo_dump(p_hwfn,
+                                      dump_buf,
+                                      num_dumped_dwords,
+                                      results_buf, &parsed_buf_size);
+}
+
+enum dbg_status qed_get_igu_fifo_results_buf_size(struct qed_hwfn *p_hwfn,
+                                                 u32 *dump_buf,
+                                                 u32 num_dumped_dwords,
+                                                 u32 *results_buf_size)
+{
+       return qed_parse_igu_fifo_dump(p_hwfn,
+                                      dump_buf,
+                                      num_dumped_dwords,
+                                      NULL, results_buf_size);
+}
+
+enum dbg_status qed_print_igu_fifo_results(struct qed_hwfn *p_hwfn,
+                                          u32 *dump_buf,
+                                          u32 num_dumped_dwords,
+                                          char *results_buf)
+{
+       u32 parsed_buf_size;
+
+       return qed_parse_igu_fifo_dump(p_hwfn,
+                                      dump_buf,
+                                      num_dumped_dwords,
+                                      results_buf, &parsed_buf_size);
+}
+
+enum dbg_status
+qed_get_protection_override_results_buf_size(struct qed_hwfn *p_hwfn,
+                                            u32 *dump_buf,
+                                            u32 num_dumped_dwords,
+                                            u32 *results_buf_size)
+{
+       return qed_parse_protection_override_dump(p_hwfn,
+                                                 dump_buf,
+                                                 num_dumped_dwords,
+                                                 NULL, results_buf_size);
+}
+
+enum dbg_status qed_print_protection_override_results(struct qed_hwfn *p_hwfn,
+                                                     u32 *dump_buf,
+                                                     u32 num_dumped_dwords,
+                                                     char *results_buf)
+{
+       u32 parsed_buf_size;
+
+       return qed_parse_protection_override_dump(p_hwfn,
+                                                 dump_buf,
+                                                 num_dumped_dwords,
+                                                 results_buf,
+                                                 &parsed_buf_size);
+}
+
 enum dbg_status qed_get_fw_asserts_results_buf_size(struct qed_hwfn *p_hwfn,
                                                    u32 *dump_buf,
                                                    u32 num_dumped_dwords,
index f872d7324814d1010ece4917f51a8d70b55eeb83..ea1cc8eaa1255526e4c186b579e814b27eded412 100644 (file)
@@ -20,6 +20,9 @@ enum qed_dbg_features {
        DBG_FEATURE_NUM
 };
 
+/* Forward Declaration */
+struct qed_dev;
+
 int qed_dbg_grc(struct qed_dev *cdev, void *buffer, u32 *num_dumped_bytes);
 int qed_dbg_grc_size(struct qed_dev *cdev);
 int qed_dbg_idle_chk(struct qed_dev *cdev, void *buffer,
index 858a57a735894d9f7788f30cf8fab386ca965808..eedf79a026a2ffe38c33db3963ea2c94d4cac7ad 100644 (file)
@@ -346,7 +346,7 @@ struct xstorm_core_conn_ag_ctx {
        u8 byte13;
        u8 byte14;
        u8 byte15;
-       u8 byte16;
+       u8 e5_reserved;
        __le16 word11;
        __le32 reg10;
        __le32 reg11;
@@ -368,85 +368,85 @@ struct tstorm_core_conn_ag_ctx {
        u8 byte0;
        u8 byte1;
        u8 flags0;
-#define TSTORM_CORE_CONN_AG_CTX_BIT0_MASK      0x1
-#define TSTORM_CORE_CONN_AG_CTX_BIT0_SHIFT     0
-#define TSTORM_CORE_CONN_AG_CTX_BIT1_MASK      0x1
-#define TSTORM_CORE_CONN_AG_CTX_BIT1_SHIFT     1
-#define TSTORM_CORE_CONN_AG_CTX_BIT2_MASK      0x1
-#define TSTORM_CORE_CONN_AG_CTX_BIT2_SHIFT     2
-#define TSTORM_CORE_CONN_AG_CTX_BIT3_MASK      0x1
-#define TSTORM_CORE_CONN_AG_CTX_BIT3_SHIFT     3
-#define TSTORM_CORE_CONN_AG_CTX_BIT4_MASK      0x1
-#define TSTORM_CORE_CONN_AG_CTX_BIT4_SHIFT     4
-#define TSTORM_CORE_CONN_AG_CTX_BIT5_MASK      0x1
-#define TSTORM_CORE_CONN_AG_CTX_BIT5_SHIFT     5
-#define TSTORM_CORE_CONN_AG_CTX_CF0_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF0_SHIFT      6
+#define TSTORM_CORE_CONN_AG_CTX_BIT0_MASK     0x1      /* exist_in_qm0 */
+#define TSTORM_CORE_CONN_AG_CTX_BIT0_SHIFT    0
+#define TSTORM_CORE_CONN_AG_CTX_BIT1_MASK     0x1      /* exist_in_qm1 */
+#define TSTORM_CORE_CONN_AG_CTX_BIT1_SHIFT    1
+#define TSTORM_CORE_CONN_AG_CTX_BIT2_MASK     0x1      /* bit2 */
+#define TSTORM_CORE_CONN_AG_CTX_BIT2_SHIFT    2
+#define TSTORM_CORE_CONN_AG_CTX_BIT3_MASK     0x1      /* bit3 */
+#define TSTORM_CORE_CONN_AG_CTX_BIT3_SHIFT    3
+#define TSTORM_CORE_CONN_AG_CTX_BIT4_MASK     0x1      /* bit4 */
+#define TSTORM_CORE_CONN_AG_CTX_BIT4_SHIFT    4
+#define TSTORM_CORE_CONN_AG_CTX_BIT5_MASK     0x1      /* bit5 */
+#define TSTORM_CORE_CONN_AG_CTX_BIT5_SHIFT    5
+#define TSTORM_CORE_CONN_AG_CTX_CF0_MASK      0x3      /* timer0cf */
+#define TSTORM_CORE_CONN_AG_CTX_CF0_SHIFT     6
        u8 flags1;
-#define TSTORM_CORE_CONN_AG_CTX_CF1_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF1_SHIFT      0
-#define TSTORM_CORE_CONN_AG_CTX_CF2_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF2_SHIFT      2
-#define TSTORM_CORE_CONN_AG_CTX_CF3_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF3_SHIFT      4
-#define TSTORM_CORE_CONN_AG_CTX_CF4_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF4_SHIFT      6
+#define TSTORM_CORE_CONN_AG_CTX_CF1_MASK      0x3      /* timer1cf */
+#define TSTORM_CORE_CONN_AG_CTX_CF1_SHIFT     0
+#define TSTORM_CORE_CONN_AG_CTX_CF2_MASK      0x3      /* timer2cf */
+#define TSTORM_CORE_CONN_AG_CTX_CF2_SHIFT     2
+#define TSTORM_CORE_CONN_AG_CTX_CF3_MASK      0x3      /* timer_stop_all */
+#define TSTORM_CORE_CONN_AG_CTX_CF3_SHIFT     4
+#define TSTORM_CORE_CONN_AG_CTX_CF4_MASK      0x3      /* cf4 */
+#define TSTORM_CORE_CONN_AG_CTX_CF4_SHIFT     6
        u8 flags2;
-#define TSTORM_CORE_CONN_AG_CTX_CF5_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF5_SHIFT      0
-#define TSTORM_CORE_CONN_AG_CTX_CF6_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF6_SHIFT      2
-#define TSTORM_CORE_CONN_AG_CTX_CF7_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF7_SHIFT      4
-#define TSTORM_CORE_CONN_AG_CTX_CF8_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF8_SHIFT      6
+#define TSTORM_CORE_CONN_AG_CTX_CF5_MASK      0x3      /* cf5 */
+#define TSTORM_CORE_CONN_AG_CTX_CF5_SHIFT     0
+#define TSTORM_CORE_CONN_AG_CTX_CF6_MASK      0x3      /* cf6 */
+#define TSTORM_CORE_CONN_AG_CTX_CF6_SHIFT     2
+#define TSTORM_CORE_CONN_AG_CTX_CF7_MASK      0x3      /* cf7 */
+#define TSTORM_CORE_CONN_AG_CTX_CF7_SHIFT     4
+#define TSTORM_CORE_CONN_AG_CTX_CF8_MASK      0x3      /* cf8 */
+#define TSTORM_CORE_CONN_AG_CTX_CF8_SHIFT     6
        u8 flags3;
-#define TSTORM_CORE_CONN_AG_CTX_CF9_MASK       0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF9_SHIFT      0
-#define TSTORM_CORE_CONN_AG_CTX_CF10_MASK      0x3
-#define TSTORM_CORE_CONN_AG_CTX_CF10_SHIFT     2
-#define TSTORM_CORE_CONN_AG_CTX_CF0EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF0EN_SHIFT    4
-#define TSTORM_CORE_CONN_AG_CTX_CF1EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF1EN_SHIFT    5
-#define TSTORM_CORE_CONN_AG_CTX_CF2EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF2EN_SHIFT    6
-#define TSTORM_CORE_CONN_AG_CTX_CF3EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF3EN_SHIFT    7
+#define TSTORM_CORE_CONN_AG_CTX_CF9_MASK      0x3      /* cf9 */
+#define TSTORM_CORE_CONN_AG_CTX_CF9_SHIFT     0
+#define TSTORM_CORE_CONN_AG_CTX_CF10_MASK     0x3      /* cf10 */
+#define TSTORM_CORE_CONN_AG_CTX_CF10_SHIFT    2
+#define TSTORM_CORE_CONN_AG_CTX_CF0EN_MASK    0x1      /* cf0en */
+#define TSTORM_CORE_CONN_AG_CTX_CF0EN_SHIFT   4
+#define TSTORM_CORE_CONN_AG_CTX_CF1EN_MASK    0x1      /* cf1en */
+#define TSTORM_CORE_CONN_AG_CTX_CF1EN_SHIFT   5
+#define TSTORM_CORE_CONN_AG_CTX_CF2EN_MASK    0x1      /* cf2en */
+#define TSTORM_CORE_CONN_AG_CTX_CF2EN_SHIFT   6
+#define TSTORM_CORE_CONN_AG_CTX_CF3EN_MASK    0x1      /* cf3en */
+#define TSTORM_CORE_CONN_AG_CTX_CF3EN_SHIFT   7
        u8 flags4;
-#define TSTORM_CORE_CONN_AG_CTX_CF4EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF4EN_SHIFT    0
-#define TSTORM_CORE_CONN_AG_CTX_CF5EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF5EN_SHIFT    1
-#define TSTORM_CORE_CONN_AG_CTX_CF6EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF6EN_SHIFT    2
-#define TSTORM_CORE_CONN_AG_CTX_CF7EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF7EN_SHIFT    3
-#define TSTORM_CORE_CONN_AG_CTX_CF8EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF8EN_SHIFT    4
-#define TSTORM_CORE_CONN_AG_CTX_CF9EN_MASK     0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF9EN_SHIFT    5
-#define TSTORM_CORE_CONN_AG_CTX_CF10EN_MASK    0x1
-#define TSTORM_CORE_CONN_AG_CTX_CF10EN_SHIFT   6
-#define TSTORM_CORE_CONN_AG_CTX_RULE0EN_MASK   0x1
-#define TSTORM_CORE_CONN_AG_CTX_RULE0EN_SHIFT  7
+#define TSTORM_CORE_CONN_AG_CTX_CF4EN_MASK    0x1      /* cf4en */
+#define TSTORM_CORE_CONN_AG_CTX_CF4EN_SHIFT   0
+#define TSTORM_CORE_CONN_AG_CTX_CF5EN_MASK    0x1      /* cf5en */
+#define TSTORM_CORE_CONN_AG_CTX_CF5EN_SHIFT   1
+#define TSTORM_CORE_CONN_AG_CTX_CF6EN_MASK    0x1      /* cf6en */
+#define TSTORM_CORE_CONN_AG_CTX_CF6EN_SHIFT   2
+#define TSTORM_CORE_CONN_AG_CTX_CF7EN_MASK    0x1      /* cf7en */
+#define TSTORM_CORE_CONN_AG_CTX_CF7EN_SHIFT   3
+#define TSTORM_CORE_CONN_AG_CTX_CF8EN_MASK    0x1      /* cf8en */
+#define TSTORM_CORE_CONN_AG_CTX_CF8EN_SHIFT   4
+#define TSTORM_CORE_CONN_AG_CTX_CF9EN_MASK    0x1      /* cf9en */
+#define TSTORM_CORE_CONN_AG_CTX_CF9EN_SHIFT   5
+#define TSTORM_CORE_CONN_AG_CTX_CF10EN_MASK   0x1      /* cf10en */
+#define TSTORM_CORE_CONN_AG_CTX_CF10EN_SHIFT  6
+#define TSTORM_CORE_CONN_AG_CTX_RULE0EN_MASK  0x1      /* rule0en */
+#define TSTORM_CORE_CONN_AG_CTX_RULE0EN_SHIFT 7
        u8 flags5;
-#define TSTORM_CORE_CONN_AG_CTX_RULE1EN_MASK   0x1
-#define TSTORM_CORE_CONN_AG_CTX_RULE1EN_SHIFT  0
-#define TSTORM_CORE_CONN_AG_CTX_RULE2EN_MASK   0x1
-#define TSTORM_CORE_CONN_AG_CTX_RULE2EN_SHIFT  1
-#define TSTORM_CORE_CONN_AG_CTX_RULE3EN_MASK   0x1
-#define TSTORM_CORE_CONN_AG_CTX_RULE3EN_SHIFT  2
-#define TSTORM_CORE_CONN_AG_CTX_RULE4EN_MASK   0x1
-#define TSTORM_CORE_CONN_AG_CTX_RULE4EN_SHIFT  3
-#define TSTORM_CORE_CONN_AG_CTX_RULE5EN_MASK   0x1
-#define TSTORM_CORE_CONN_AG_CTX_RULE5EN_SHIFT  4
-#define TSTORM_CORE_CONN_AG_CTX_RULE6EN_MASK   0x1
-#define TSTORM_CORE_CONN_AG_CTX_RULE6EN_SHIFT  5
-#define TSTORM_CORE_CONN_AG_CTX_RULE7EN_MASK   0x1
-#define TSTORM_CORE_CONN_AG_CTX_RULE7EN_SHIFT  6
-#define TSTORM_CORE_CONN_AG_CTX_RULE8EN_MASK   0x1
-#define TSTORM_CORE_CONN_AG_CTX_RULE8EN_SHIFT  7
+#define TSTORM_CORE_CONN_AG_CTX_RULE1EN_MASK  0x1      /* rule1en */
+#define TSTORM_CORE_CONN_AG_CTX_RULE1EN_SHIFT 0
+#define TSTORM_CORE_CONN_AG_CTX_RULE2EN_MASK  0x1      /* rule2en */
+#define TSTORM_CORE_CONN_AG_CTX_RULE2EN_SHIFT 1
+#define TSTORM_CORE_CONN_AG_CTX_RULE3EN_MASK  0x1      /* rule3en */
+#define TSTORM_CORE_CONN_AG_CTX_RULE3EN_SHIFT 2
+#define TSTORM_CORE_CONN_AG_CTX_RULE4EN_MASK  0x1      /* rule4en */
+#define TSTORM_CORE_CONN_AG_CTX_RULE4EN_SHIFT 3
+#define TSTORM_CORE_CONN_AG_CTX_RULE5EN_MASK  0x1      /* rule5en */
+#define TSTORM_CORE_CONN_AG_CTX_RULE5EN_SHIFT 4
+#define TSTORM_CORE_CONN_AG_CTX_RULE6EN_MASK  0x1      /* rule6en */
+#define TSTORM_CORE_CONN_AG_CTX_RULE6EN_SHIFT 5
+#define TSTORM_CORE_CONN_AG_CTX_RULE7EN_MASK  0x1      /* rule7en */
+#define TSTORM_CORE_CONN_AG_CTX_RULE7EN_SHIFT 6
+#define TSTORM_CORE_CONN_AG_CTX_RULE8EN_MASK  0x1      /* rule8en */
+#define TSTORM_CORE_CONN_AG_CTX_RULE8EN_SHIFT 7
        __le32 reg0;
        __le32 reg1;
        __le32 reg2;
@@ -681,7 +681,9 @@ struct core_rx_fast_path_cqe {
        __le16 packet_length;
        __le16 vlan;
        struct core_rx_cqe_opaque_data opaque_data;
-       __le32 reserved[4];
+       struct parsing_err_flags err_flags;
+       __le16 reserved0;
+       __le32 reserved1[3];
 };
 
 struct core_rx_gsi_offload_cqe {
@@ -692,7 +694,7 @@ struct core_rx_gsi_offload_cqe {
        __le16 vlan;
        __le32 src_mac_addrhi;
        __le16 src_mac_addrlo;
-       u8 reserved1[2];
+       __le16 qp_id;
        __le32 gid_dst[4];
 };
 
@@ -774,15 +776,15 @@ struct core_tx_bd {
        __le16 bitfield1;
 #define CORE_TX_BD_L4_HDR_OFFSET_W_MASK        0x3FFF
 #define CORE_TX_BD_L4_HDR_OFFSET_W_SHIFT 0
-#define CORE_TX_BD_TX_DST_MASK 0x1
-#define CORE_TX_BD_TX_DST_SHIFT        14
-#define CORE_TX_BD_RESERVED_MASK         0x1
-#define CORE_TX_BD_RESERVED_SHIFT        15
+#define CORE_TX_BD_TX_DST_MASK         0x3
+#define CORE_TX_BD_TX_DST_SHIFT                14
 };
 
 enum core_tx_dest {
        CORE_TX_DEST_NW,
        CORE_TX_DEST_LB,
+       CORE_TX_DEST_RESERVED,
+       CORE_TX_DEST_DROP,
        MAX_CORE_TX_DEST
 };
 
@@ -804,12 +806,12 @@ struct core_tx_stop_ramrod_data {
        __le32 reserved0[2];
 };
 
-enum dcb_dhcp_update_flag {
-       DONT_UPDATE_DCB_DHCP,
+enum dcb_dscp_update_mode {
+       DONT_UPDATE_DCB_DSCP,
        UPDATE_DCB,
        UPDATE_DSCP,
        UPDATE_DCB_DSCP,
-       MAX_DCB_DHCP_UPDATE_FLAG
+       MAX_DCB_DSCP_UPDATE_MODE
 };
 
 struct eth_mstorm_per_pf_stat {
@@ -917,6 +919,14 @@ struct hsi_fp_ver_struct {
        u8 major_ver_arr[2];
 };
 
+enum iwarp_ll2_tx_queues {
+       IWARP_LL2_IN_ORDER_TX_QUEUE =                   1,
+       IWARP_LL2_ALIGNED_TX_QUEUE,
+       IWARP_LL2_ALIGNED_RIGHT_TRIMMED_TX_QUEUE,
+       IWARP_LL2_ERROR,
+       MAX_IWARP_LL2_TX_QUEUES
+};
+
 /* Mstorm non-triggering VF zone */
 enum malicious_vf_error_id {
        MALICIOUS_VF_NO_ERROR,
@@ -960,7 +970,7 @@ enum personality_type {
        PERSONALITY_ISCSI,
        PERSONALITY_FCOE,
        PERSONALITY_RDMA_AND_ETH,
-       PERSONALITY_RESERVED3,
+       PERSONALITY_RDMA,
        PERSONALITY_CORE,
        PERSONALITY_ETH,
        PERSONALITY_RESERVED4,
@@ -971,16 +981,12 @@ enum personality_type {
 struct pf_start_tunnel_config {
        u8 set_vxlan_udp_port_flg;
        u8 set_geneve_udp_port_flg;
-       u8 tx_enable_vxlan;
-       u8 tx_enable_l2geneve;
-       u8 tx_enable_ipgeneve;
-       u8 tx_enable_l2gre;
-       u8 tx_enable_ipgre;
        u8 tunnel_clss_vxlan;
        u8 tunnel_clss_l2geneve;
        u8 tunnel_clss_ipgeneve;
        u8 tunnel_clss_l2gre;
        u8 tunnel_clss_ipgre;
+       u8 reserved;
        __le16 vxlan_udp_port;
        __le16 geneve_udp_port;
 };
@@ -990,6 +996,7 @@ struct pf_start_ramrod_data {
        struct regpair event_ring_pbl_addr;
        struct regpair consolid_q_pbl_addr;
        struct pf_start_tunnel_config tunnel_config;
+       __le32 reserved;
        __le16 event_ring_sb_id;
        u8 base_vf_id;
        u8 num_vfs;
@@ -1007,7 +1014,6 @@ struct pf_start_ramrod_data {
        u8 pri_map_valid;
        __le32 outer_tag;
        struct hsi_fp_ver_struct hsi_fp_ver;
-
 };
 
 struct protocol_dcb_data {
@@ -1023,14 +1029,8 @@ struct pf_update_tunnel_config {
        u8 update_rx_pf_clss;
        u8 update_rx_def_ucast_clss;
        u8 update_rx_def_non_ucast_clss;
-       u8 update_tx_pf_clss;
        u8 set_vxlan_udp_port_flg;
        u8 set_geneve_udp_port_flg;
-       u8 tx_enable_vxlan;
-       u8 tx_enable_l2geneve;
-       u8 tx_enable_ipgeneve;
-       u8 tx_enable_l2gre;
-       u8 tx_enable_ipgre;
        u8 tunnel_clss_vxlan;
        u8 tunnel_clss_l2geneve;
        u8 tunnel_clss_ipgeneve;
@@ -1038,17 +1038,17 @@ struct pf_update_tunnel_config {
        u8 tunnel_clss_ipgre;
        __le16 vxlan_udp_port;
        __le16 geneve_udp_port;
-       __le16 reserved[2];
+       __le16 reserved;
 };
 
 struct pf_update_ramrod_data {
        u8 pf_id;
-       u8 update_eth_dcb_data_flag;
-       u8 update_fcoe_dcb_data_flag;
-       u8 update_iscsi_dcb_data_flag;
-       u8 update_roce_dcb_data_flag;
-       u8 update_rroce_dcb_data_flag;
-       u8 update_iwarp_dcb_data_flag;
+       u8 update_eth_dcb_data_mode;
+       u8 update_fcoe_dcb_data_mode;
+       u8 update_iscsi_dcb_data_mode;
+       u8 update_roce_dcb_data_mode;
+       u8 update_rroce_dcb_data_mode;
+       u8 update_iwarp_dcb_data_mode;
        u8 update_mf_vlan_flag;
        struct protocol_dcb_data eth_dcb_data;
        struct protocol_dcb_data fcoe_dcb_data;
@@ -1127,7 +1127,7 @@ struct tstorm_per_port_stat {
        struct regpair iscsi_irregular_pkt;
        struct regpair fcoe_irregular_pkt;
        struct regpair roce_irregular_pkt;
-       struct regpair reserved;
+       struct regpair iwarp_irregular_pkt;
        struct regpair eth_irregular_pkt;
        struct regpair reserved1;
        struct regpair preroce_irregular_pkt;
@@ -1326,6 +1326,87 @@ enum dmae_cmd_src_enum {
        MAX_DMAE_CMD_SRC_ENUM
 };
 
+struct mstorm_core_conn_ag_ctx {
+       u8 byte0;
+       u8 byte1;
+       u8 flags0;
+#define MSTORM_CORE_CONN_AG_CTX_BIT0_MASK      0x1
+#define MSTORM_CORE_CONN_AG_CTX_BIT0_SHIFT     0
+#define MSTORM_CORE_CONN_AG_CTX_BIT1_MASK      0x1
+#define MSTORM_CORE_CONN_AG_CTX_BIT1_SHIFT     1
+#define MSTORM_CORE_CONN_AG_CTX_CF0_MASK       0x3
+#define MSTORM_CORE_CONN_AG_CTX_CF0_SHIFT      2
+#define MSTORM_CORE_CONN_AG_CTX_CF1_MASK       0x3
+#define MSTORM_CORE_CONN_AG_CTX_CF1_SHIFT      4
+#define MSTORM_CORE_CONN_AG_CTX_CF2_MASK       0x3
+#define MSTORM_CORE_CONN_AG_CTX_CF2_SHIFT      6
+       u8 flags1;
+#define MSTORM_CORE_CONN_AG_CTX_CF0EN_MASK     0x1
+#define MSTORM_CORE_CONN_AG_CTX_CF0EN_SHIFT    0
+#define MSTORM_CORE_CONN_AG_CTX_CF1EN_MASK     0x1
+#define MSTORM_CORE_CONN_AG_CTX_CF1EN_SHIFT    1
+#define MSTORM_CORE_CONN_AG_CTX_CF2EN_MASK     0x1
+#define MSTORM_CORE_CONN_AG_CTX_CF2EN_SHIFT    2
+#define MSTORM_CORE_CONN_AG_CTX_RULE0EN_MASK   0x1
+#define MSTORM_CORE_CONN_AG_CTX_RULE0EN_SHIFT  3
+#define MSTORM_CORE_CONN_AG_CTX_RULE1EN_MASK   0x1
+#define MSTORM_CORE_CONN_AG_CTX_RULE1EN_SHIFT  4
+#define MSTORM_CORE_CONN_AG_CTX_RULE2EN_MASK   0x1
+#define MSTORM_CORE_CONN_AG_CTX_RULE2EN_SHIFT  5
+#define MSTORM_CORE_CONN_AG_CTX_RULE3EN_MASK   0x1
+#define MSTORM_CORE_CONN_AG_CTX_RULE3EN_SHIFT  6
+#define MSTORM_CORE_CONN_AG_CTX_RULE4EN_MASK   0x1
+#define MSTORM_CORE_CONN_AG_CTX_RULE4EN_SHIFT  7
+       __le16 word0;
+       __le16 word1;
+       __le32 reg0;
+       __le32 reg1;
+};
+
+struct ystorm_core_conn_ag_ctx {
+       u8 byte0;
+       u8 byte1;
+       u8 flags0;
+#define YSTORM_CORE_CONN_AG_CTX_BIT0_MASK      0x1
+#define YSTORM_CORE_CONN_AG_CTX_BIT0_SHIFT     0
+#define YSTORM_CORE_CONN_AG_CTX_BIT1_MASK      0x1
+#define YSTORM_CORE_CONN_AG_CTX_BIT1_SHIFT     1
+#define YSTORM_CORE_CONN_AG_CTX_CF0_MASK       0x3
+#define YSTORM_CORE_CONN_AG_CTX_CF0_SHIFT      2
+#define YSTORM_CORE_CONN_AG_CTX_CF1_MASK       0x3
+#define YSTORM_CORE_CONN_AG_CTX_CF1_SHIFT      4
+#define YSTORM_CORE_CONN_AG_CTX_CF2_MASK       0x3
+#define YSTORM_CORE_CONN_AG_CTX_CF2_SHIFT      6
+       u8 flags1;
+#define YSTORM_CORE_CONN_AG_CTX_CF0EN_MASK     0x1
+#define YSTORM_CORE_CONN_AG_CTX_CF0EN_SHIFT    0
+#define YSTORM_CORE_CONN_AG_CTX_CF1EN_MASK     0x1
+#define YSTORM_CORE_CONN_AG_CTX_CF1EN_SHIFT    1
+#define YSTORM_CORE_CONN_AG_CTX_CF2EN_MASK     0x1
+#define YSTORM_CORE_CONN_AG_CTX_CF2EN_SHIFT    2
+#define YSTORM_CORE_CONN_AG_CTX_RULE0EN_MASK   0x1
+#define YSTORM_CORE_CONN_AG_CTX_RULE0EN_SHIFT  3
+#define YSTORM_CORE_CONN_AG_CTX_RULE1EN_MASK   0x1
+#define YSTORM_CORE_CONN_AG_CTX_RULE1EN_SHIFT  4
+#define YSTORM_CORE_CONN_AG_CTX_RULE2EN_MASK   0x1
+#define YSTORM_CORE_CONN_AG_CTX_RULE2EN_SHIFT  5
+#define YSTORM_CORE_CONN_AG_CTX_RULE3EN_MASK   0x1
+#define YSTORM_CORE_CONN_AG_CTX_RULE3EN_SHIFT  6
+#define YSTORM_CORE_CONN_AG_CTX_RULE4EN_MASK   0x1
+#define YSTORM_CORE_CONN_AG_CTX_RULE4EN_SHIFT  7
+       u8 byte2;
+       u8 byte3;
+       __le16 word0;
+       __le32 reg0;
+       __le32 reg1;
+       __le16 word1;
+       __le16 word2;
+       __le16 word3;
+       __le16 word4;
+       __le32 reg2;
+       __le32 reg3;
+};
+
 /* IGU cleanup command */
 struct igu_cleanup {
        __le32 sb_id_and_flags;
@@ -1389,44 +1470,6 @@ struct igu_msix_vector {
 #define IGU_MSIX_VECTOR_RESERVED1_MASK         0xFF
 #define IGU_MSIX_VECTOR_RESERVED1_SHIFT                24
 };
-
-struct mstorm_core_conn_ag_ctx {
-       u8 byte0;
-       u8 byte1;
-       u8 flags0;
-#define MSTORM_CORE_CONN_AG_CTX_BIT0_MASK      0x1
-#define MSTORM_CORE_CONN_AG_CTX_BIT0_SHIFT     0
-#define MSTORM_CORE_CONN_AG_CTX_BIT1_MASK      0x1
-#define MSTORM_CORE_CONN_AG_CTX_BIT1_SHIFT     1
-#define MSTORM_CORE_CONN_AG_CTX_CF0_MASK       0x3
-#define MSTORM_CORE_CONN_AG_CTX_CF0_SHIFT      2
-#define MSTORM_CORE_CONN_AG_CTX_CF1_MASK       0x3
-#define MSTORM_CORE_CONN_AG_CTX_CF1_SHIFT      4
-#define MSTORM_CORE_CONN_AG_CTX_CF2_MASK       0x3
-#define MSTORM_CORE_CONN_AG_CTX_CF2_SHIFT      6
-       u8 flags1;
-#define MSTORM_CORE_CONN_AG_CTX_CF0EN_MASK     0x1
-#define MSTORM_CORE_CONN_AG_CTX_CF0EN_SHIFT    0
-#define MSTORM_CORE_CONN_AG_CTX_CF1EN_MASK     0x1
-#define MSTORM_CORE_CONN_AG_CTX_CF1EN_SHIFT    1
-#define MSTORM_CORE_CONN_AG_CTX_CF2EN_MASK     0x1
-#define MSTORM_CORE_CONN_AG_CTX_CF2EN_SHIFT    2
-#define MSTORM_CORE_CONN_AG_CTX_RULE0EN_MASK   0x1
-#define MSTORM_CORE_CONN_AG_CTX_RULE0EN_SHIFT  3
-#define MSTORM_CORE_CONN_AG_CTX_RULE1EN_MASK   0x1
-#define MSTORM_CORE_CONN_AG_CTX_RULE1EN_SHIFT  4
-#define MSTORM_CORE_CONN_AG_CTX_RULE2EN_MASK   0x1
-#define MSTORM_CORE_CONN_AG_CTX_RULE2EN_SHIFT  5
-#define MSTORM_CORE_CONN_AG_CTX_RULE3EN_MASK   0x1
-#define MSTORM_CORE_CONN_AG_CTX_RULE3EN_SHIFT  6
-#define MSTORM_CORE_CONN_AG_CTX_RULE4EN_MASK   0x1
-#define MSTORM_CORE_CONN_AG_CTX_RULE4EN_SHIFT  7
-       __le16 word0;
-       __le16 word1;
-       __le32 reg0;
-       __le32 reg1;
-};
-
 /* per encapsulation type enabling flags */
 struct prs_reg_encapsulation_type_en {
        u8 flags;
@@ -1541,50 +1584,6 @@ struct sdm_op_gen {
 #define SDM_OP_GEN_RESERVED_SHIFT      20
 };
 
-struct ystorm_core_conn_ag_ctx {
-       u8 byte0;
-       u8 byte1;
-       u8 flags0;
-#define YSTORM_CORE_CONN_AG_CTX_BIT0_MASK      0x1
-#define YSTORM_CORE_CONN_AG_CTX_BIT0_SHIFT     0
-#define YSTORM_CORE_CONN_AG_CTX_BIT1_MASK      0x1
-#define YSTORM_CORE_CONN_AG_CTX_BIT1_SHIFT     1
-#define YSTORM_CORE_CONN_AG_CTX_CF0_MASK       0x3
-#define YSTORM_CORE_CONN_AG_CTX_CF0_SHIFT      2
-#define YSTORM_CORE_CONN_AG_CTX_CF1_MASK       0x3
-#define YSTORM_CORE_CONN_AG_CTX_CF1_SHIFT      4
-#define YSTORM_CORE_CONN_AG_CTX_CF2_MASK       0x3
-#define YSTORM_CORE_CONN_AG_CTX_CF2_SHIFT      6
-       u8 flags1;
-#define YSTORM_CORE_CONN_AG_CTX_CF0EN_MASK     0x1
-#define YSTORM_CORE_CONN_AG_CTX_CF0EN_SHIFT    0
-#define YSTORM_CORE_CONN_AG_CTX_CF1EN_MASK     0x1
-#define YSTORM_CORE_CONN_AG_CTX_CF1EN_SHIFT    1
-#define YSTORM_CORE_CONN_AG_CTX_CF2EN_MASK     0x1
-#define YSTORM_CORE_CONN_AG_CTX_CF2EN_SHIFT    2
-#define YSTORM_CORE_CONN_AG_CTX_RULE0EN_MASK   0x1
-#define YSTORM_CORE_CONN_AG_CTX_RULE0EN_SHIFT  3
-#define YSTORM_CORE_CONN_AG_CTX_RULE1EN_MASK   0x1
-#define YSTORM_CORE_CONN_AG_CTX_RULE1EN_SHIFT  4
-#define YSTORM_CORE_CONN_AG_CTX_RULE2EN_MASK   0x1
-#define YSTORM_CORE_CONN_AG_CTX_RULE2EN_SHIFT  5
-#define YSTORM_CORE_CONN_AG_CTX_RULE3EN_MASK   0x1
-#define YSTORM_CORE_CONN_AG_CTX_RULE3EN_SHIFT  6
-#define YSTORM_CORE_CONN_AG_CTX_RULE4EN_MASK   0x1
-#define YSTORM_CORE_CONN_AG_CTX_RULE4EN_SHIFT  7
-       u8 byte2;
-       u8 byte3;
-       __le16 word0;
-       __le32 reg0;
-       __le32 reg1;
-       __le16 word1;
-       __le16 word2;
-       __le16 word3;
-       __le16 word4;
-       __le32 reg2;
-       __le32 reg3;
-};
-
 /****************************************/
 /* Debug Tools HSI constants and macros */
 /****************************************/
@@ -1643,6 +1642,8 @@ enum block_addr {
        GRCBASE_MULD = 0x4e0000,
        GRCBASE_YULD = 0x4c8000,
        GRCBASE_XYLD = 0x4c0000,
+       GRCBASE_PTLD = 0x590000,
+       GRCBASE_YPLD = 0x5b0000,
        GRCBASE_PRM = 0x230000,
        GRCBASE_PBF_PB1 = 0xda0000,
        GRCBASE_PBF_PB2 = 0xda4000,
@@ -1656,6 +1657,10 @@ enum block_addr {
        GRCBASE_TCFC = 0x2d0000,
        GRCBASE_IGU = 0x180000,
        GRCBASE_CAU = 0x1c0000,
+       GRCBASE_RGFS = 0xf00000,
+       GRCBASE_RGSRC = 0x320000,
+       GRCBASE_TGFS = 0xd00000,
+       GRCBASE_TGSRC = 0x322000,
        GRCBASE_UMAC = 0x51000,
        GRCBASE_XMAC = 0x210000,
        GRCBASE_DBG = 0x10000,
@@ -1669,10 +1674,6 @@ enum block_addr {
        GRCBASE_PHY_PCIE = 0x620000,
        GRCBASE_LED = 0x6b8000,
        GRCBASE_AVS_WRAP = 0x6b0000,
-       GRCBASE_RGFS = 0x19d0000,
-       GRCBASE_TGFS = 0x19e0000,
-       GRCBASE_PTLD = 0x19f0000,
-       GRCBASE_YPLD = 0x1a10000,
        GRCBASE_MISC_AEU = 0x8000,
        GRCBASE_BAR0_MAP = 0x1c00000,
        MAX_BLOCK_ADDR
@@ -1732,6 +1733,8 @@ enum block_id {
        BLOCK_MULD,
        BLOCK_YULD,
        BLOCK_XYLD,
+       BLOCK_PTLD,
+       BLOCK_YPLD,
        BLOCK_PRM,
        BLOCK_PBF_PB1,
        BLOCK_PBF_PB2,
@@ -1745,6 +1748,10 @@ enum block_id {
        BLOCK_TCFC,
        BLOCK_IGU,
        BLOCK_CAU,
+       BLOCK_RGFS,
+       BLOCK_RGSRC,
+       BLOCK_TGFS,
+       BLOCK_TGSRC,
        BLOCK_UMAC,
        BLOCK_XMAC,
        BLOCK_DBG,
@@ -1758,10 +1765,6 @@ enum block_id {
        BLOCK_PHY_PCIE,
        BLOCK_LED,
        BLOCK_AVS_WRAP,
-       BLOCK_RGFS,
-       BLOCK_TGFS,
-       BLOCK_PTLD,
-       BLOCK_YPLD,
        BLOCK_MISC_AEU,
        BLOCK_BAR0_MAP,
        MAX_BLOCK_ID
@@ -1780,6 +1783,10 @@ enum bin_dbg_buffer_type {
        BIN_BUF_DBG_ATTN_REGS,
        BIN_BUF_DBG_ATTN_INDEXES,
        BIN_BUF_DBG_ATTN_NAME_OFFSETS,
+       BIN_BUF_DBG_BUS_BLOCKS,
+       BIN_BUF_DBG_BUS_LINES,
+       BIN_BUF_DBG_BUS_BLOCKS_USER_DATA,
+       BIN_BUF_DBG_BUS_LINE_NAME_OFFSETS,
        BIN_BUF_DBG_PARSING_STRINGS,
        MAX_BIN_DBG_BUFFER_TYPE
 };
@@ -1862,6 +1869,29 @@ enum dbg_attn_type {
        MAX_DBG_ATTN_TYPE
 };
 
+struct dbg_bus_block {
+       u8 num_of_lines;
+       u8 has_latency_events;
+       __le16 lines_offset;
+};
+
+struct dbg_bus_block_user_data {
+       u8 num_of_lines;
+       u8 has_latency_events;
+       __le16 names_offset;
+};
+
+struct dbg_bus_line {
+       u8 data;
+#define DBG_BUS_LINE_NUM_OF_GROUPS_MASK  0xF
+#define DBG_BUS_LINE_NUM_OF_GROUPS_SHIFT 0
+#define DBG_BUS_LINE_IS_256B_MASK        0x1
+#define DBG_BUS_LINE_IS_256B_SHIFT       4
+#define DBG_BUS_LINE_RESERVED_MASK       0x7
+#define DBG_BUS_LINE_RESERVED_SHIFT      5
+       u8 group_sizes;
+};
+
 /* condition header for registers dump */
 struct dbg_dump_cond_hdr {
        struct dbg_mode_hdr mode; /* Mode header */
@@ -1879,17 +1909,21 @@ struct dbg_dump_mem {
        __le32 dword1;
 #define DBG_DUMP_MEM_LENGTH_MASK        0xFFFFFF
 #define DBG_DUMP_MEM_LENGTH_SHIFT       0
-#define DBG_DUMP_MEM_RESERVED_MASK      0xFF
-#define DBG_DUMP_MEM_RESERVED_SHIFT     24
+#define DBG_DUMP_MEM_WIDE_BUS_MASK      0x1
+#define DBG_DUMP_MEM_WIDE_BUS_SHIFT     24
+#define DBG_DUMP_MEM_RESERVED_MASK      0x7F
+#define DBG_DUMP_MEM_RESERVED_SHIFT     25
 };
 
 /* register data for registers dump */
 struct dbg_dump_reg {
        __le32 data;
-#define DBG_DUMP_REG_ADDRESS_MASK  0xFFFFFF /* register address (in dwords) */
+#define DBG_DUMP_REG_ADDRESS_MASK 0x7FFFFF /* register address (in dwords) */
 #define DBG_DUMP_REG_ADDRESS_SHIFT 0
-#define DBG_DUMP_REG_LENGTH_MASK   0xFF /* register size (in dwords) */
-#define DBG_DUMP_REG_LENGTH_SHIFT  24
+#define DBG_DUMP_REG_WIDE_BUS_MASK 0x1 /* indicates register is wide-bus */
+#define DBG_DUMP_REG_WIDE_BUS_SHIFT 23
+#define DBG_DUMP_REG_LENGTH_MASK  0xFF /* register size (in dwords) */
+#define DBG_DUMP_REG_LENGTH_SHIFT 24
 };
 
 /* split header for registers dump */
@@ -1910,20 +1944,24 @@ struct dbg_idle_chk_cond_hdr {
 /* Idle Check condition register */
 struct dbg_idle_chk_cond_reg {
        __le32 data;
-#define DBG_IDLE_CHK_COND_REG_ADDRESS_MASK   0xFFFFFF
+#define DBG_IDLE_CHK_COND_REG_ADDRESS_MASK   0x7FFFFF
 #define DBG_IDLE_CHK_COND_REG_ADDRESS_SHIFT  0
+#define DBG_IDLE_CHK_COND_REG_WIDE_BUS_MASK  0x1
+#define DBG_IDLE_CHK_COND_REG_WIDE_BUS_SHIFT 23
 #define DBG_IDLE_CHK_COND_REG_BLOCK_ID_MASK  0xFF
 #define DBG_IDLE_CHK_COND_REG_BLOCK_ID_SHIFT 24
-       __le16 num_entries; /* number of registers entries to check */
-       u8 entry_size; /* size of registers entry (in dwords) */
-       u8 start_entry; /* index of the first entry to check */
+       __le16 num_entries;
+       u8 entry_size;
+       u8 start_entry;
 };
 
 /* Idle Check info register */
 struct dbg_idle_chk_info_reg {
        __le32 data;
-#define DBG_IDLE_CHK_INFO_REG_ADDRESS_MASK   0xFFFFFF
+#define DBG_IDLE_CHK_INFO_REG_ADDRESS_MASK   0x7FFFFF
 #define DBG_IDLE_CHK_INFO_REG_ADDRESS_SHIFT  0
+#define DBG_IDLE_CHK_INFO_REG_WIDE_BUS_MASK  0x1
+#define DBG_IDLE_CHK_INFO_REG_WIDE_BUS_SHIFT 23
 #define DBG_IDLE_CHK_INFO_REG_BLOCK_ID_MASK  0xFF
 #define DBG_IDLE_CHK_INFO_REG_BLOCK_ID_SHIFT 24
        __le16 size; /* register size in dwords */
@@ -1996,15 +2034,17 @@ enum dbg_idle_chk_severity_types {
 
 /* Debug Bus block data */
 struct dbg_bus_block_data {
-       u8 enabled; /* Indicates if the block is enabled for recording (0/1) */
-       u8 hw_id; /* HW ID associated with the block */
-       u8 line_num; /* Debug line number to select */
-       u8 right_shift; /* Number of units to  right the debug data (0-3) */
-       u8 cycle_en; /* 4-bit value: bit i set -> unit i is enabled. */
-       u8 force_valid; /* 4-bit value: bit i set -> unit i is forced valid. */
-       u8 force_frame; /* 4-bit value: bit i set -> unit i frame bit is forced.
-                        */
-       u8 reserved;
+       __le16 data;
+#define DBG_BUS_BLOCK_DATA_ENABLE_MASK_MASK       0xF
+#define DBG_BUS_BLOCK_DATA_ENABLE_MASK_SHIFT      0
+#define DBG_BUS_BLOCK_DATA_RIGHT_SHIFT_MASK       0xF
+#define DBG_BUS_BLOCK_DATA_RIGHT_SHIFT_SHIFT      4
+#define DBG_BUS_BLOCK_DATA_FORCE_VALID_MASK_MASK  0xF
+#define DBG_BUS_BLOCK_DATA_FORCE_VALID_MASK_SHIFT 8
+#define DBG_BUS_BLOCK_DATA_FORCE_FRAME_MASK_MASK  0xF
+#define DBG_BUS_BLOCK_DATA_FORCE_FRAME_MASK_SHIFT 12
+       u8 line_num;
+       u8 hw_id;
 };
 
 /* Debug Bus Clients */
@@ -2045,6 +2085,14 @@ enum dbg_bus_constraint_ops {
        MAX_DBG_BUS_CONSTRAINT_OPS
 };
 
+struct dbg_bus_trigger_state_data {
+       u8 data;
+#define DBG_BUS_TRIGGER_STATE_DATA_BLOCK_SHIFTED_ENABLE_MASK_MASK  0xF
+#define DBG_BUS_TRIGGER_STATE_DATA_BLOCK_SHIFTED_ENABLE_MASK_SHIFT 0
+#define DBG_BUS_TRIGGER_STATE_DATA_CONSTRAINT_DWORD_MASK_MASK      0xF
+#define DBG_BUS_TRIGGER_STATE_DATA_CONSTRAINT_DWORD_MASK_SHIFT     4
+};
+
 /* Debug Bus memory address */
 struct dbg_bus_mem_addr {
        __le32 lo;
@@ -2078,66 +2126,42 @@ union dbg_bus_storm_eid_params {
 
 /* Debug Bus Storm data */
 struct dbg_bus_storm_data {
-       u8 fast_enabled;
-       u8 fast_mode;
-       u8 slow_enabled;
-       u8 slow_mode;
+       u8 enabled;
+       u8 mode;
        u8 hw_id;
        u8 eid_filter_en;
        u8 eid_range_not_mask;
        u8 cid_filter_en;
        union dbg_bus_storm_eid_params eid_filter_params;
-       __le16 reserved;
        __le32 cid;
 };
 
 /* Debug Bus data */
 struct dbg_bus_data {
-       __le32 app_version; /* The tools version number of the application */
-       u8 state; /* The current debug bus state */
-       u8 hw_dwords; /* HW dwords per cycle */
-       u8 next_hw_id; /* Next HW ID to be associated with an input */
-       u8 num_enabled_blocks; /* Number of blocks enabled for recording */
-       u8 num_enabled_storms; /* Number of Storms enabled for recording */
-       u8 target; /* Output target */
-       u8 next_trigger_state; /* ID of next trigger state to be added */
-       u8 next_constraint_id; /* ID of next filter/trigger constraint to be
-                               * added.
-                               */
-       u8 one_shot_en; /* Indicates if one-shot mode is enabled (0/1) */
-       u8 grc_input_en; /* Indicates if GRC recording is enabled (0/1) */
-       u8 timestamp_input_en; /* Indicates if timestamp recording is enabled
-                               * (0/1).
-                               */
-       u8 filter_en; /* Indicates if the recording filter is enabled (0/1) */
-       u8 trigger_en; /* Indicates if the recording trigger is enabled (0/1) */
-       u8 adding_filter; /* If true, the next added constraint belong to the
-                          * filter. Otherwise, it belongs to the last added
-                          * trigger state. Valid only if either filter or
-                          * triggers are enabled.
-                          */
-       u8 filter_pre_trigger; /* Indicates if the recording filter should be
-                               * applied before the trigger. Valid only if both
-                               * filter and trigger are enabled (0/1).
-                               */
-       u8 filter_post_trigger; /* Indicates if the recording filter should be
-                                * applied after the trigger. Valid only if both
-                                * filter and trigger are enabled (0/1).
-                                */
-       u8 unify_inputs; /* If true, all inputs are associated with HW ID 0.
-                         * Otherwise, each input is assigned a different HW ID
-                         * (0/1).
-                         */
-       u8 rcv_from_other_engine; /* Indicates if the other engine sends it NW
-                                  * recording to this engine (0/1).
-                                  */
-       struct dbg_bus_pci_buf_data pci_buf; /* Debug Bus PCI buffer data. Valid
-                                             * only when the target is
-                                             * DBG_BUS_TARGET_ID_PCI.
-                                             */
+       __le32 app_version;
+       u8 state;
+       u8 hw_dwords;
+       __le16 hw_id_mask;
+       u8 num_enabled_blocks;
+       u8 num_enabled_storms;
+       u8 target;
+       u8 one_shot_en;
+       u8 grc_input_en;
+       u8 timestamp_input_en;
+       u8 filter_en;
+       u8 adding_filter;
+       u8 filter_pre_trigger;
+       u8 filter_post_trigger;
        __le16 reserved;
-       struct dbg_bus_block_data blocks[88];/* Debug Bus data for each block */
-       struct dbg_bus_storm_data storms[6]; /* Debug Bus data for each block */
+       u8 trigger_en;
+       struct dbg_bus_trigger_state_data trigger_states[3];
+       u8 next_trigger_state;
+       u8 next_constraint_id;
+       u8 unify_inputs;
+       u8 rcv_from_other_engine;
+       struct dbg_bus_pci_buf_data pci_buf;
+       struct dbg_bus_block_data blocks[88];
+       struct dbg_bus_storm_data storms[6];
 };
 
 enum dbg_bus_filter_types {
@@ -2156,12 +2180,6 @@ enum dbg_bus_frame_modes {
        MAX_DBG_BUS_FRAME_MODES
 };
 
-enum dbg_bus_input_types {
-       DBG_BUS_INPUT_TYPE_STORM,
-       DBG_BUS_INPUT_TYPE_BLOCK,
-       MAX_DBG_BUS_INPUT_TYPES
-};
-
 enum dbg_bus_other_engine_modes {
        DBG_BUS_OTHER_ENGINE_MODE_NONE,
        DBG_BUS_OTHER_ENGINE_MODE_DOUBLE_BW_TX,
@@ -2185,19 +2203,19 @@ enum dbg_bus_pre_trigger_types {
 };
 
 enum dbg_bus_semi_frame_modes {
-       DBG_BUS_SEMI_FRAME_MODE_0SLOW_4FAST = 0,
-       DBG_BUS_SEMI_FRAME_MODE_4SLOW_0FAST = 3,
+       DBG_BUS_SEMI_FRAME_MODE_0SLOW_4FAST =
+           0,
+       DBG_BUS_SEMI_FRAME_MODE_4SLOW_0FAST =
+           3,
        MAX_DBG_BUS_SEMI_FRAME_MODES
 };
 
 /* Debug bus states */
 enum dbg_bus_states {
-       DBG_BUS_STATE_IDLE, /* debug bus idle state (not recording) */
-       DBG_BUS_STATE_READY, /* debug bus is ready for configuration and
-                             * recording.
-                             */
-       DBG_BUS_STATE_RECORDING, /* debug bus is currently recording */
-       DBG_BUS_STATE_STOPPED, /* debug bus recording has stopped */
+       DBG_BUS_STATE_IDLE,
+       DBG_BUS_STATE_READY,
+       DBG_BUS_STATE_RECORDING,
+       DBG_BUS_STATE_STOPPED,
        MAX_DBG_BUS_STATES
 };
 
@@ -2216,11 +2234,8 @@ enum dbg_bus_storm_modes {
 
 /* Debug bus target IDs */
 enum dbg_bus_targets {
-       /* records debug bus to DBG block internal buffer */
        DBG_BUS_TARGET_ID_INT_BUF,
-       /* records debug bus to the NW */
        DBG_BUS_TARGET_ID_NIG,
-       /* records debug bus to a PCI buffer */
        DBG_BUS_TARGET_ID_PCI,
        MAX_DBG_BUS_TARGETS
 };
@@ -2235,48 +2250,45 @@ struct dbg_grc_data {
 
 /* Debug GRC params */
 enum dbg_grc_params {
-       DBG_GRC_PARAM_DUMP_TSTORM, /* dump Tstorm memories (0/1) */
-       DBG_GRC_PARAM_DUMP_MSTORM, /* dump Mstorm memories (0/1) */
-       DBG_GRC_PARAM_DUMP_USTORM, /* dump Ustorm memories (0/1) */
-       DBG_GRC_PARAM_DUMP_XSTORM, /* dump Xstorm memories (0/1) */
-       DBG_GRC_PARAM_DUMP_YSTORM, /* dump Ystorm memories (0/1) */
-       DBG_GRC_PARAM_DUMP_PSTORM, /* dump Pstorm memories (0/1) */
-       DBG_GRC_PARAM_DUMP_REGS, /* dump non-memory registers (0/1) */
-       DBG_GRC_PARAM_DUMP_RAM, /* dump Storm internal RAMs (0/1) */
-       DBG_GRC_PARAM_DUMP_PBUF, /* dump Storm passive buffer (0/1) */
-       DBG_GRC_PARAM_DUMP_IOR, /* dump Storm IORs (0/1) */
-       DBG_GRC_PARAM_DUMP_VFC, /* dump VFC memories (0/1) */
-       DBG_GRC_PARAM_DUMP_CM_CTX, /* dump CM contexts (0/1) */
-       DBG_GRC_PARAM_DUMP_PXP, /* dump PXP memories (0/1) */
-       DBG_GRC_PARAM_DUMP_RSS, /* dump RSS memories (0/1) */
-       DBG_GRC_PARAM_DUMP_CAU, /* dump CAU memories (0/1) */
-       DBG_GRC_PARAM_DUMP_QM, /* dump QM memories (0/1) */
-       DBG_GRC_PARAM_DUMP_MCP, /* dump MCP memories (0/1) */
-       DBG_GRC_PARAM_RESERVED, /* reserved */
-       DBG_GRC_PARAM_DUMP_CFC, /* dump CFC memories (0/1) */
-       DBG_GRC_PARAM_DUMP_IGU, /* dump IGU memories (0/1) */
-       DBG_GRC_PARAM_DUMP_BRB, /* dump BRB memories (0/1) */
-       DBG_GRC_PARAM_DUMP_BTB, /* dump BTB memories (0/1) */
-       DBG_GRC_PARAM_DUMP_BMB, /* dump BMB memories (0/1) */
-       DBG_GRC_PARAM_DUMP_NIG, /* dump NIG memories (0/1) */
-       DBG_GRC_PARAM_DUMP_MULD, /* dump MULD memories (0/1) */
-       DBG_GRC_PARAM_DUMP_PRS, /* dump PRS memories (0/1) */
-       DBG_GRC_PARAM_DUMP_DMAE, /* dump PRS memories (0/1) */
-       DBG_GRC_PARAM_DUMP_TM, /* dump TM (timers) memories (0/1) */
-       DBG_GRC_PARAM_DUMP_SDM, /* dump SDM memories (0/1) */
-       DBG_GRC_PARAM_DUMP_DIF, /* dump DIF memories (0/1) */
-       DBG_GRC_PARAM_DUMP_STATIC, /* dump static debug data (0/1) */
-       DBG_GRC_PARAM_UNSTALL, /* un-stall Storms after dump (0/1) */
-       DBG_GRC_PARAM_NUM_LCIDS, /* number of LCIDs (0..320) */
-       DBG_GRC_PARAM_NUM_LTIDS, /* number of LTIDs (0..320) */
-       /* preset: exclude all memories from dump (1 only) */
+       DBG_GRC_PARAM_DUMP_TSTORM,
+       DBG_GRC_PARAM_DUMP_MSTORM,
+       DBG_GRC_PARAM_DUMP_USTORM,
+       DBG_GRC_PARAM_DUMP_XSTORM,
+       DBG_GRC_PARAM_DUMP_YSTORM,
+       DBG_GRC_PARAM_DUMP_PSTORM,
+       DBG_GRC_PARAM_DUMP_REGS,
+       DBG_GRC_PARAM_DUMP_RAM,
+       DBG_GRC_PARAM_DUMP_PBUF,
+       DBG_GRC_PARAM_DUMP_IOR,
+       DBG_GRC_PARAM_DUMP_VFC,
+       DBG_GRC_PARAM_DUMP_CM_CTX,
+       DBG_GRC_PARAM_DUMP_PXP,
+       DBG_GRC_PARAM_DUMP_RSS,
+       DBG_GRC_PARAM_DUMP_CAU,
+       DBG_GRC_PARAM_DUMP_QM,
+       DBG_GRC_PARAM_DUMP_MCP,
+       DBG_GRC_PARAM_RESERVED,
+       DBG_GRC_PARAM_DUMP_CFC,
+       DBG_GRC_PARAM_DUMP_IGU,
+       DBG_GRC_PARAM_DUMP_BRB,
+       DBG_GRC_PARAM_DUMP_BTB,
+       DBG_GRC_PARAM_DUMP_BMB,
+       DBG_GRC_PARAM_DUMP_NIG,
+       DBG_GRC_PARAM_DUMP_MULD,
+       DBG_GRC_PARAM_DUMP_PRS,
+       DBG_GRC_PARAM_DUMP_DMAE,
+       DBG_GRC_PARAM_DUMP_TM,
+       DBG_GRC_PARAM_DUMP_SDM,
+       DBG_GRC_PARAM_DUMP_DIF,
+       DBG_GRC_PARAM_DUMP_STATIC,
+       DBG_GRC_PARAM_UNSTALL,
+       DBG_GRC_PARAM_NUM_LCIDS,
+       DBG_GRC_PARAM_NUM_LTIDS,
        DBG_GRC_PARAM_EXCLUDE_ALL,
-       /* preset: include memories for crash dump (1 only) */
        DBG_GRC_PARAM_CRASH,
-       /* perform dump only if MFW is responding (0/1) */
        DBG_GRC_PARAM_PARITY_SAFE,
-       DBG_GRC_PARAM_DUMP_CM, /* dump CM memories (0/1) */
-       DBG_GRC_PARAM_DUMP_PHY, /* dump PHY memories (0/1) */
+       DBG_GRC_PARAM_DUMP_CM,
+       DBG_GRC_PARAM_DUMP_PHY,
        DBG_GRC_PARAM_NO_MCP,
        DBG_GRC_PARAM_NO_FW_VER,
        MAX_DBG_GRC_PARAMS
@@ -2347,7 +2359,10 @@ enum dbg_status {
        DBG_STATUS_REG_FIFO_BAD_DATA,
        DBG_STATUS_PROTECTION_OVERRIDE_BAD_DATA,
        DBG_STATUS_DBG_ARRAY_NOT_SET,
-       DBG_STATUS_MULTI_BLOCKS_WITH_FILTER,
+       DBG_STATUS_FILTER_BUG,
+       DBG_STATUS_NON_MATCHING_LINES,
+       DBG_STATUS_INVALID_TRIGGER_DWORD_OFFSET,
+       DBG_STATUS_DBG_BUS_IN_USE,
        MAX_DBG_STATUS
 };
 
@@ -2364,25 +2379,22 @@ enum dbg_storms {
 
 /* Idle Check data */
 struct idle_chk_data {
-       __le32 buf_size; /* Idle check buffer size in dwords */
-       u8 buf_size_set; /* Indicates if the idle check buffer size was set
-                         * (0/1).
-                         */
+       __le32 buf_size;
+       u8 buf_size_set;
        u8 reserved1;
        __le16 reserved2;
 };
 
 /* Debug Tools data (per HW function) */
 struct dbg_tools_data {
-       struct dbg_grc_data grc; /* GRC Dump data */
-       struct dbg_bus_data bus; /* Debug Bus data */
-       struct idle_chk_data idle_chk; /* Idle Check data */
-       u8 mode_enable[40]; /* Indicates if a mode is enabled (0/1) */
-       u8 block_in_reset[88]; /* Indicates if a block is in reset state (0/1).
-                               */
-       u8 chip_id; /* Chip ID (from enum chip_ids) */
-       u8 platform_id; /* Platform ID (from enum platform_ids) */
-       u8 initialized; /* Indicates if the data was initialized */
+       struct dbg_grc_data grc;
+       struct dbg_bus_data bus;
+       struct idle_chk_data idle_chk;
+       u8 mode_enable[40];
+       u8 block_in_reset[88];
+       u8 chip_id;
+       u8 platform_id;
+       u8 initialized;
        u8 reserved;
 };
 
@@ -2464,6 +2476,12 @@ struct init_qm_vport_params {
 
 /* Max size in dwords of a zipped array */
 #define MAX_ZIPPED_SIZE        8192
+enum chip_ids {
+       CHIP_BB,
+       CHIP_K2,
+       CHIP_RESERVED,
+       MAX_CHIP_IDS
+};
 
 struct fw_asserts_ram_section {
        __le16 section_ram_line_offset;
@@ -2475,18 +2493,18 @@ struct fw_asserts_ram_section {
 };
 
 struct fw_ver_num {
-       u8 major; /* Firmware major version number */
-       u8 minor; /* Firmware minor version number */
-       u8 rev; /* Firmware revision version number */
-       u8 eng; /* Firmware engineering version number (for bootleg versions) */
+       u8 major;
+       u8 minor;
+       u8 rev;
+       u8 eng;
 };
 
 struct fw_ver_info {
-       __le16 tools_ver; /* Tools version number */
-       u8 image_id; /* FW image ID (e.g. main) */
+       __le16 tools_ver;
+       u8 image_id;
        u8 reserved1;
-       struct fw_ver_num num; /* FW version number */
-       __le32 timestamp; /* FW Timestamp in unix time  (sec. since 1970) */
+       struct fw_ver_num num;
+       __le32 timestamp;
        __le32 reserved2;
 };
 
@@ -2722,7 +2740,6 @@ struct init_read_op {
 #define INIT_READ_OP_ADDRESS_MASK      0x7FFFFF
 #define INIT_READ_OP_ADDRESS_SHIFT     9
        __le32 expected_val;
-
 };
 
 /* Init operations union */
@@ -2782,6 +2799,7 @@ struct iro {
  * @param bin_ptr - a pointer to the binary data with debug arrays.
  */
 enum dbg_status qed_dbg_set_bin_ptr(const u8 * const bin_ptr);
+
 /**
  * @brief qed_dbg_grc_set_params_default - Reverts all GRC parameters to their
  *     default value.
@@ -2805,6 +2823,7 @@ void qed_dbg_grc_set_params_default(struct qed_hwfn *p_hwfn);
 enum dbg_status qed_dbg_grc_get_dump_buf_size(struct qed_hwfn *p_hwfn,
                                              struct qed_ptt *p_ptt,
                                              u32 *buf_size);
+
 /**
  * @brief qed_dbg_grc_dump - Dumps GRC data into the specified buffer.
  *
@@ -2824,6 +2843,7 @@ enum dbg_status qed_dbg_grc_dump(struct qed_hwfn *p_hwfn,
                                 u32 *dump_buf,
                                 u32 buf_size_in_dwords,
                                 u32 *num_dumped_dwords);
+
 /**
  * @brief qed_dbg_idle_chk_get_dump_buf_size - Returns the required buffer size
  *     for idle check results.
@@ -2840,6 +2860,7 @@ enum dbg_status qed_dbg_grc_dump(struct qed_hwfn *p_hwfn,
 enum dbg_status qed_dbg_idle_chk_get_dump_buf_size(struct qed_hwfn *p_hwfn,
                                                   struct qed_ptt *p_ptt,
                                                   u32 *buf_size);
+
 /**
  * @brief qed_dbg_idle_chk_dump - Performs idle check and writes the results
  *     into the specified buffer.
@@ -2860,6 +2881,7 @@ enum dbg_status qed_dbg_idle_chk_dump(struct qed_hwfn *p_hwfn,
                                      u32 *dump_buf,
                                      u32 buf_size_in_dwords,
                                      u32 *num_dumped_dwords);
+
 /**
  * @brief qed_dbg_mcp_trace_get_dump_buf_size - Returns the required buffer size
  *     for mcp trace results.
@@ -2878,6 +2900,7 @@ enum dbg_status qed_dbg_idle_chk_dump(struct qed_hwfn *p_hwfn,
 enum dbg_status qed_dbg_mcp_trace_get_dump_buf_size(struct qed_hwfn *p_hwfn,
                                                    struct qed_ptt *p_ptt,
                                                    u32 *buf_size);
+
 /**
  * @brief qed_dbg_mcp_trace_dump - Performs mcp trace and writes the results
  *     into the specified buffer.
@@ -2902,6 +2925,7 @@ enum dbg_status qed_dbg_mcp_trace_dump(struct qed_hwfn *p_hwfn,
                                       u32 *dump_buf,
                                       u32 buf_size_in_dwords,
                                       u32 *num_dumped_dwords);
+
 /**
  * @brief qed_dbg_reg_fifo_get_dump_buf_size - Returns the required buffer size
  *     for grc trace fifo results.
@@ -2917,6 +2941,7 @@ enum dbg_status qed_dbg_mcp_trace_dump(struct qed_hwfn *p_hwfn,
 enum dbg_status qed_dbg_reg_fifo_get_dump_buf_size(struct qed_hwfn *p_hwfn,
                                                   struct qed_ptt *p_ptt,
                                                   u32 *buf_size);
+
 /**
  * @brief qed_dbg_reg_fifo_dump - Reads the reg fifo and writes the results into
  *     the specified buffer.
@@ -2938,6 +2963,7 @@ enum dbg_status qed_dbg_reg_fifo_dump(struct qed_hwfn *p_hwfn,
                                      u32 *dump_buf,
                                      u32 buf_size_in_dwords,
                                      u32 *num_dumped_dwords);
+
 /**
  * @brief qed_dbg_igu_fifo_get_dump_buf_size - Returns the required buffer size
  *     for the IGU fifo results.
@@ -2954,6 +2980,7 @@ enum dbg_status qed_dbg_reg_fifo_dump(struct qed_hwfn *p_hwfn,
 enum dbg_status qed_dbg_igu_fifo_get_dump_buf_size(struct qed_hwfn *p_hwfn,
                                                   struct qed_ptt *p_ptt,
                                                   u32 *buf_size);
+
 /**
  * @brief qed_dbg_igu_fifo_dump - Reads the IGU fifo and writes the results into
  *     the specified buffer.
@@ -2975,6 +3002,7 @@ enum dbg_status qed_dbg_igu_fifo_dump(struct qed_hwfn *p_hwfn,
                                      u32 *dump_buf,
                                      u32 buf_size_in_dwords,
                                      u32 *num_dumped_dwords);
+
 /**
  * @brief qed_dbg_protection_override_get_dump_buf_size - Returns the required
  *     buffer size for protection override window results.
@@ -3074,6 +3102,7 @@ enum dbg_status qed_dbg_print_attn(struct qed_hwfn *p_hwfn,
  * @param bin_ptr - a pointer to the binary data with debug arrays.
  */
 enum dbg_status qed_dbg_user_set_bin_ptr(const u8 * const bin_ptr);
+
 /**
  * @brief qed_dbg_get_status_str - Returns a string for the specified status.
  *
@@ -3082,6 +3111,7 @@ enum dbg_status qed_dbg_user_set_bin_ptr(const u8 * const bin_ptr);
  * @return a string for the specified status
  */
 const char *qed_dbg_get_status_str(enum dbg_status status);
+
 /**
  * @brief qed_get_idle_chk_results_buf_size - Returns the required buffer size
  *     for idle check results (in bytes).
@@ -3116,6 +3146,7 @@ enum dbg_status qed_print_idle_chk_results(struct qed_hwfn *p_hwfn,
                                           char *results_buf,
                                           u32 *num_errors,
                                           u32 *num_warnings);
+
 /**
  * @brief qed_get_mcp_trace_results_buf_size - Returns the required buffer size
  *     for MCP Trace results (in bytes).
@@ -3132,6 +3163,7 @@ enum dbg_status qed_get_mcp_trace_results_buf_size(struct qed_hwfn *p_hwfn,
                                                   u32 *dump_buf,
                                                   u32 num_dumped_dwords,
                                                   u32 *results_buf_size);
+
 /**
  * @brief qed_print_mcp_trace_results - Prints MCP Trace results
  *
@@ -3146,6 +3178,7 @@ enum dbg_status qed_print_mcp_trace_results(struct qed_hwfn *p_hwfn,
                                            u32 *dump_buf,
                                            u32 num_dumped_dwords,
                                            char *results_buf);
+
 /**
  * @brief qed_get_reg_fifo_results_buf_size - Returns the required buffer size
  *     for reg_fifo results (in bytes).
@@ -3162,6 +3195,7 @@ enum dbg_status qed_get_reg_fifo_results_buf_size(struct qed_hwfn *p_hwfn,
                                                  u32 *dump_buf,
                                                  u32 num_dumped_dwords,
                                                  u32 *results_buf_size);
+
 /**
  * @brief qed_print_reg_fifo_results - Prints reg fifo results
  *
@@ -3176,6 +3210,7 @@ enum dbg_status qed_print_reg_fifo_results(struct qed_hwfn *p_hwfn,
                                           u32 *dump_buf,
                                           u32 num_dumped_dwords,
                                           char *results_buf);
+
 /**
  * @brief qed_get_igu_fifo_results_buf_size - Returns the required buffer size
  *     for igu_fifo results (in bytes).
@@ -3192,6 +3227,7 @@ enum dbg_status qed_get_igu_fifo_results_buf_size(struct qed_hwfn *p_hwfn,
                                                  u32 *dump_buf,
                                                  u32 num_dumped_dwords,
                                                  u32 *results_buf_size);
+
 /**
  * @brief qed_print_igu_fifo_results - Prints IGU fifo results
  *
@@ -3206,6 +3242,7 @@ enum dbg_status qed_print_igu_fifo_results(struct qed_hwfn *p_hwfn,
                                           u32 *dump_buf,
                                           u32 num_dumped_dwords,
                                           char *results_buf);
+
 /**
  * @brief qed_get_protection_override_results_buf_size - Returns the required
  *     buffer size for protection override results (in bytes).
@@ -3223,6 +3260,7 @@ qed_get_protection_override_results_buf_size(struct qed_hwfn *p_hwfn,
                                             u32 *dump_buf,
                                             u32 num_dumped_dwords,
                                             u32 *results_buf_size);
+
 /**
  * @brief qed_print_protection_override_results - Prints protection override
  *     results.
@@ -3238,6 +3276,7 @@ enum dbg_status qed_print_protection_override_results(struct qed_hwfn *p_hwfn,
                                                      u32 *dump_buf,
                                                      u32 num_dumped_dwords,
                                                      char *results_buf);
+
 /**
  * @brief qed_get_fw_asserts_results_buf_size - Returns the required buffer size
  *     for FW Asserts results (in bytes).
@@ -3254,6 +3293,7 @@ enum dbg_status qed_get_fw_asserts_results_buf_size(struct qed_hwfn *p_hwfn,
                                                    u32 *dump_buf,
                                                    u32 num_dumped_dwords,
                                                    u32 *results_buf_size);
+
 /**
  * @brief qed_print_fw_asserts_results - Prints FW Asserts results
  *
@@ -3268,6 +3308,269 @@ enum dbg_status qed_print_fw_asserts_results(struct qed_hwfn *p_hwfn,
                                             u32 *dump_buf,
                                             u32 num_dumped_dwords,
                                             char *results_buf);
+
+/* Debug Bus blocks */
+static const u32 dbg_bus_blocks[] = {
+       0x0000000f,             /* grc, bb, 15 lines */
+       0x0000000f,             /* grc, k2, 15 lines */
+       0x00000000,
+       0x00000000,             /* miscs, bb, 0 lines */
+       0x00000000,             /* miscs, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* misc, bb, 0 lines */
+       0x00000000,             /* misc, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* dbu, bb, 0 lines */
+       0x00000000,             /* dbu, k2, 0 lines */
+       0x00000000,
+       0x000f0127,             /* pglue_b, bb, 39 lines */
+       0x0036012a,             /* pglue_b, k2, 42 lines */
+       0x00000000,
+       0x00000000,             /* cnig, bb, 0 lines */
+       0x00120102,             /* cnig, k2, 2 lines */
+       0x00000000,
+       0x00000000,             /* cpmu, bb, 0 lines */
+       0x00000000,             /* cpmu, k2, 0 lines */
+       0x00000000,
+       0x00000001,             /* ncsi, bb, 1 lines */
+       0x00000001,             /* ncsi, k2, 1 lines */
+       0x00000000,
+       0x00000000,             /* opte, bb, 0 lines */
+       0x00000000,             /* opte, k2, 0 lines */
+       0x00000000,
+       0x00600085,             /* bmb, bb, 133 lines */
+       0x00600085,             /* bmb, k2, 133 lines */
+       0x00000000,
+       0x00000000,             /* pcie, bb, 0 lines */
+       0x00e50033,             /* pcie, k2, 51 lines */
+       0x00000000,
+       0x00000000,             /* mcp, bb, 0 lines */
+       0x00000000,             /* mcp, k2, 0 lines */
+       0x00000000,
+       0x01180009,             /* mcp2, bb, 9 lines */
+       0x01180009,             /* mcp2, k2, 9 lines */
+       0x00000000,
+       0x01210104,             /* pswhst, bb, 4 lines */
+       0x01210104,             /* pswhst, k2, 4 lines */
+       0x00000000,
+       0x01250103,             /* pswhst2, bb, 3 lines */
+       0x01250103,             /* pswhst2, k2, 3 lines */
+       0x00000000,
+       0x00340101,             /* pswrd, bb, 1 lines */
+       0x00340101,             /* pswrd, k2, 1 lines */
+       0x00000000,
+       0x01280119,             /* pswrd2, bb, 25 lines */
+       0x01280119,             /* pswrd2, k2, 25 lines */
+       0x00000000,
+       0x01410109,             /* pswwr, bb, 9 lines */
+       0x01410109,             /* pswwr, k2, 9 lines */
+       0x00000000,
+       0x00000000,             /* pswwr2, bb, 0 lines */
+       0x00000000,             /* pswwr2, k2, 0 lines */
+       0x00000000,
+       0x001c0001,             /* pswrq, bb, 1 lines */
+       0x001c0001,             /* pswrq, k2, 1 lines */
+       0x00000000,
+       0x014a0015,             /* pswrq2, bb, 21 lines */
+       0x014a0015,             /* pswrq2, k2, 21 lines */
+       0x00000000,
+       0x00000000,             /* pglcs, bb, 0 lines */
+       0x00120006,             /* pglcs, k2, 6 lines */
+       0x00000000,
+       0x00100001,             /* dmae, bb, 1 lines */
+       0x00100001,             /* dmae, k2, 1 lines */
+       0x00000000,
+       0x015f0105,             /* ptu, bb, 5 lines */
+       0x015f0105,             /* ptu, k2, 5 lines */
+       0x00000000,
+       0x01640120,             /* tcm, bb, 32 lines */
+       0x01640120,             /* tcm, k2, 32 lines */
+       0x00000000,
+       0x01640120,             /* mcm, bb, 32 lines */
+       0x01640120,             /* mcm, k2, 32 lines */
+       0x00000000,
+       0x01640120,             /* ucm, bb, 32 lines */
+       0x01640120,             /* ucm, k2, 32 lines */
+       0x00000000,
+       0x01640120,             /* xcm, bb, 32 lines */
+       0x01640120,             /* xcm, k2, 32 lines */
+       0x00000000,
+       0x01640120,             /* ycm, bb, 32 lines */
+       0x01640120,             /* ycm, k2, 32 lines */
+       0x00000000,
+       0x01640120,             /* pcm, bb, 32 lines */
+       0x01640120,             /* pcm, k2, 32 lines */
+       0x00000000,
+       0x01840062,             /* qm, bb, 98 lines */
+       0x01840062,             /* qm, k2, 98 lines */
+       0x00000000,
+       0x01e60021,             /* tm, bb, 33 lines */
+       0x01e60021,             /* tm, k2, 33 lines */
+       0x00000000,
+       0x02070107,             /* dorq, bb, 7 lines */
+       0x02070107,             /* dorq, k2, 7 lines */
+       0x00000000,
+       0x00600185,             /* brb, bb, 133 lines */
+       0x00600185,             /* brb, k2, 133 lines */
+       0x00000000,
+       0x020e0019,             /* src, bb, 25 lines */
+       0x020c001a,             /* src, k2, 26 lines */
+       0x00000000,
+       0x02270104,             /* prs, bb, 4 lines */
+       0x02270104,             /* prs, k2, 4 lines */
+       0x00000000,
+       0x022b0133,             /* tsdm, bb, 51 lines */
+       0x022b0133,             /* tsdm, k2, 51 lines */
+       0x00000000,
+       0x022b0133,             /* msdm, bb, 51 lines */
+       0x022b0133,             /* msdm, k2, 51 lines */
+       0x00000000,
+       0x022b0133,             /* usdm, bb, 51 lines */
+       0x022b0133,             /* usdm, k2, 51 lines */
+       0x00000000,
+       0x022b0133,             /* xsdm, bb, 51 lines */
+       0x022b0133,             /* xsdm, k2, 51 lines */
+       0x00000000,
+       0x022b0133,             /* ysdm, bb, 51 lines */
+       0x022b0133,             /* ysdm, k2, 51 lines */
+       0x00000000,
+       0x022b0133,             /* psdm, bb, 51 lines */
+       0x022b0133,             /* psdm, k2, 51 lines */
+       0x00000000,
+       0x025e010c,             /* tsem, bb, 12 lines */
+       0x025e010c,             /* tsem, k2, 12 lines */
+       0x00000000,
+       0x025e010c,             /* msem, bb, 12 lines */
+       0x025e010c,             /* msem, k2, 12 lines */
+       0x00000000,
+       0x025e010c,             /* usem, bb, 12 lines */
+       0x025e010c,             /* usem, k2, 12 lines */
+       0x00000000,
+       0x025e010c,             /* xsem, bb, 12 lines */
+       0x025e010c,             /* xsem, k2, 12 lines */
+       0x00000000,
+       0x025e010c,             /* ysem, bb, 12 lines */
+       0x025e010c,             /* ysem, k2, 12 lines */
+       0x00000000,
+       0x025e010c,             /* psem, bb, 12 lines */
+       0x025e010c,             /* psem, k2, 12 lines */
+       0x00000000,
+       0x026a000d,             /* rss, bb, 13 lines */
+       0x026a000d,             /* rss, k2, 13 lines */
+       0x00000000,
+       0x02770106,             /* tmld, bb, 6 lines */
+       0x02770106,             /* tmld, k2, 6 lines */
+       0x00000000,
+       0x027d0106,             /* muld, bb, 6 lines */
+       0x027d0106,             /* muld, k2, 6 lines */
+       0x00000000,
+       0x02770005,             /* yuld, bb, 5 lines */
+       0x02770005,             /* yuld, k2, 5 lines */
+       0x00000000,
+       0x02830107,             /* xyld, bb, 7 lines */
+       0x027d0107,             /* xyld, k2, 7 lines */
+       0x00000000,
+       0x00000000,             /* ptld, bb, 0 lines */
+       0x00000000,             /* ptld, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* ypld, bb, 0 lines */
+       0x00000000,             /* ypld, k2, 0 lines */
+       0x00000000,
+       0x028a010e,             /* prm, bb, 14 lines */
+       0x02980110,             /* prm, k2, 16 lines */
+       0x00000000,
+       0x02a8000d,             /* pbf_pb1, bb, 13 lines */
+       0x02a8000d,             /* pbf_pb1, k2, 13 lines */
+       0x00000000,
+       0x02a8000d,             /* pbf_pb2, bb, 13 lines */
+       0x02a8000d,             /* pbf_pb2, k2, 13 lines */
+       0x00000000,
+       0x02a8000d,             /* rpb, bb, 13 lines */
+       0x02a8000d,             /* rpb, k2, 13 lines */
+       0x00000000,
+       0x00600185,             /* btb, bb, 133 lines */
+       0x00600185,             /* btb, k2, 133 lines */
+       0x00000000,
+       0x02b50117,             /* pbf, bb, 23 lines */
+       0x02b50117,             /* pbf, k2, 23 lines */
+       0x00000000,
+       0x02cc0006,             /* rdif, bb, 6 lines */
+       0x02cc0006,             /* rdif, k2, 6 lines */
+       0x00000000,
+       0x02d20006,             /* tdif, bb, 6 lines */
+       0x02d20006,             /* tdif, k2, 6 lines */
+       0x00000000,
+       0x02d80003,             /* cdu, bb, 3 lines */
+       0x02db000e,             /* cdu, k2, 14 lines */
+       0x00000000,
+       0x02e9010d,             /* ccfc, bb, 13 lines */
+       0x02f60117,             /* ccfc, k2, 23 lines */
+       0x00000000,
+       0x02e9010d,             /* tcfc, bb, 13 lines */
+       0x02f60117,             /* tcfc, k2, 23 lines */
+       0x00000000,
+       0x030d0133,             /* igu, bb, 51 lines */
+       0x030d0133,             /* igu, k2, 51 lines */
+       0x00000000,
+       0x03400106,             /* cau, bb, 6 lines */
+       0x03400106,             /* cau, k2, 6 lines */
+       0x00000000,
+       0x00000000,             /* rgfs, bb, 0 lines */
+       0x00000000,             /* rgfs, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* rgsrc, bb, 0 lines */
+       0x00000000,             /* rgsrc, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* tgfs, bb, 0 lines */
+       0x00000000,             /* tgfs, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* tgsrc, bb, 0 lines */
+       0x00000000,             /* tgsrc, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* umac, bb, 0 lines */
+       0x00120006,             /* umac, k2, 6 lines */
+       0x00000000,
+       0x00000000,             /* xmac, bb, 0 lines */
+       0x00000000,             /* xmac, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* dbg, bb, 0 lines */
+       0x00000000,             /* dbg, k2, 0 lines */
+       0x00000000,
+       0x0346012b,             /* nig, bb, 43 lines */
+       0x0346011d,             /* nig, k2, 29 lines */
+       0x00000000,
+       0x00000000,             /* wol, bb, 0 lines */
+       0x001c0002,             /* wol, k2, 2 lines */
+       0x00000000,
+       0x00000000,             /* bmbn, bb, 0 lines */
+       0x00210008,             /* bmbn, k2, 8 lines */
+       0x00000000,
+       0x00000000,             /* ipc, bb, 0 lines */
+       0x00000000,             /* ipc, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* nwm, bb, 0 lines */
+       0x0371000b,             /* nwm, k2, 11 lines */
+       0x00000000,
+       0x00000000,             /* nws, bb, 0 lines */
+       0x037c0009,             /* nws, k2, 9 lines */
+       0x00000000,
+       0x00000000,             /* ms, bb, 0 lines */
+       0x00120004,             /* ms, k2, 4 lines */
+       0x00000000,
+       0x00000000,             /* phy_pcie, bb, 0 lines */
+       0x00e5001a,             /* phy_pcie, k2, 26 lines */
+       0x00000000,
+       0x00000000,             /* led, bb, 0 lines */
+       0x00000000,             /* led, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* avs_wrap, bb, 0 lines */
+       0x00000000,             /* avs_wrap, k2, 0 lines */
+       0x00000000,
+       0x00000000,             /* bar0_map, bb, 0 lines */
+       0x00000000,             /* bar0_map, k2, 0 lines */
+       0x00000000,
+};
+
 /* Win 2 */
 #define GTT_BAR0_MAP_REG_IGU_CMD       0x00f000UL
 
@@ -3589,37 +3892,37 @@ void qed_set_rfs_mode_enable(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
 #define PSTORM_FCOE_TX_STATS_OFFSET(pf_id) \
        (IRO[44].base + ((pf_id) * IRO[44].m1))
 
-static const struct iro iro_arr[47] = {
+static const struct iro iro_arr[49] = {
        {0x0, 0x0, 0x0, 0x0, 0x8},
        {0x4cb0, 0x80, 0x0, 0x0, 0x80},
-       {0x6318, 0x20, 0x0, 0x0, 0x20},
+       {0x6518, 0x20, 0x0, 0x0, 0x20},
        {0xb00, 0x8, 0x0, 0x0, 0x4},
        {0xa80, 0x8, 0x0, 0x0, 0x4},
        {0x0, 0x8, 0x0, 0x0, 0x2},
        {0x80, 0x8, 0x0, 0x0, 0x4},
        {0x84, 0x8, 0x0, 0x0, 0x2},
-       {0x4bc0, 0x0, 0x0, 0x0, 0x78},
+       {0x4c40, 0x0, 0x0, 0x0, 0x78},
        {0x3df0, 0x0, 0x0, 0x0, 0x78},
        {0x29b0, 0x0, 0x0, 0x0, 0x78},
        {0x4c38, 0x0, 0x0, 0x0, 0x78},
        {0x4990, 0x0, 0x0, 0x0, 0x78},
-       {0x7e48, 0x0, 0x0, 0x0, 0x78},
+       {0x7f48, 0x0, 0x0, 0x0, 0x78},
        {0xa28, 0x8, 0x0, 0x0, 0x8},
-       {0x60f8, 0x10, 0x0, 0x0, 0x10},
-       {0xb820, 0x30, 0x0, 0x0, 0x30},
+       {0x61f8, 0x10, 0x0, 0x0, 0x10},
+       {0xbd20, 0x30, 0x0, 0x0, 0x30},
        {0x95b8, 0x30, 0x0, 0x0, 0x30},
        {0x4b60, 0x80, 0x0, 0x0, 0x40},
        {0x1f8, 0x4, 0x0, 0x0, 0x4},
        {0x53a0, 0x80, 0x4, 0x0, 0x4},
-       {0xc8f0, 0x0, 0x0, 0x0, 0x4},
+       {0xc7c8, 0x0, 0x0, 0x0, 0x4},
        {0x4ba0, 0x80, 0x0, 0x0, 0x20},
-       {0x8050, 0x40, 0x0, 0x0, 0x30},
-       {0xe770, 0x60, 0x0, 0x0, 0x60},
+       {0x8150, 0x40, 0x0, 0x0, 0x30},
+       {0xec70, 0x60, 0x0, 0x0, 0x60},
        {0x2b48, 0x80, 0x0, 0x0, 0x38},
-       {0xf188, 0x78, 0x0, 0x0, 0x78},
+       {0xf1b0, 0x78, 0x0, 0x0, 0x78},
        {0x1f8, 0x4, 0x0, 0x0, 0x4},
-       {0xacf0, 0x0, 0x0, 0x0, 0xf0},
-       {0xade0, 0x8, 0x0, 0x0, 0x8},
+       {0xaef8, 0x0, 0x0, 0x0, 0xf0},
+       {0xafe8, 0x8, 0x0, 0x0, 0x8},
        {0x1f8, 0x8, 0x0, 0x0, 0x8},
        {0xac0, 0x8, 0x0, 0x0, 0x8},
        {0x2578, 0x8, 0x0, 0x0, 0x8},
@@ -3627,16 +3930,18 @@ static const struct iro iro_arr[47] = {
        {0x0, 0x8, 0x0, 0x0, 0x8},
        {0x200, 0x10, 0x8, 0x0, 0x8},
        {0xb78, 0x10, 0x8, 0x0, 0x2},
-       {0xd888, 0x38, 0x0, 0x0, 0x24},
-       {0x12c38, 0x10, 0x0, 0x0, 0x8},
-       {0x11aa0, 0x38, 0x0, 0x0, 0x18},
-       {0xa8c0, 0x38, 0x0, 0x0, 0x10},
+       {0xd9a8, 0x38, 0x0, 0x0, 0x24},
+       {0x12988, 0x10, 0x0, 0x0, 0x8},
+       {0x11fa0, 0x38, 0x0, 0x0, 0x18},
+       {0xa580, 0x38, 0x0, 0x0, 0x10},
        {0x86f8, 0x30, 0x0, 0x0, 0x18},
        {0x101f8, 0x10, 0x0, 0x0, 0x10},
-       {0xdd08, 0x48, 0x0, 0x0, 0x38},
+       {0xde28, 0x48, 0x0, 0x0, 0x38},
        {0x10660, 0x20, 0x0, 0x0, 0x20},
        {0x2b80, 0x80, 0x0, 0x0, 0x10},
        {0x5020, 0x10, 0x0, 0x0, 0x10},
+       {0xc9b0, 0x30, 0x0, 0x0, 0x10},
+       {0xeec0, 0x10, 0x0, 0x0, 0x10},
 };
 
 /* Runtime array offsets */
@@ -3724,361 +4029,359 @@ static const struct iro iro_arr[47] = {
 #define PSWRQ2_REG_CDUC_BLOCKS_FACTOR_RT_OFFSET        6697
 #define PSWRQ2_REG_VF_BASE_RT_OFFSET   6698
 #define PSWRQ2_REG_VF_LAST_ILT_RT_OFFSET       6699
-#define PSWRQ2_REG_WR_MBS0_RT_OFFSET   6700
-#define PSWRQ2_REG_RD_MBS0_RT_OFFSET   6701
-#define PSWRQ2_REG_DRAM_ALIGN_WR_RT_OFFSET     6702
-#define PSWRQ2_REG_DRAM_ALIGN_RD_RT_OFFSET     6703
-#define PSWRQ2_REG_ILT_MEMORY_RT_OFFSET        6704
+#define PSWRQ2_REG_DRAM_ALIGN_WR_RT_OFFSET     6700
+#define PSWRQ2_REG_DRAM_ALIGN_RD_RT_OFFSET     6701
+#define PSWRQ2_REG_ILT_MEMORY_RT_OFFSET        6702
 #define PSWRQ2_REG_ILT_MEMORY_RT_SIZE  22000
-#define PGLUE_REG_B_VF_BASE_RT_OFFSET  28704
-#define PGLUE_REG_B_MSDM_OFFSET_MASK_B_RT_OFFSET       28705
-#define PGLUE_REG_B_MSDM_VF_SHIFT_B_RT_OFFSET  28706
-#define PGLUE_REG_B_CACHE_LINE_SIZE_RT_OFFSET  28707
-#define PGLUE_REG_B_PF_BAR0_SIZE_RT_OFFSET     28708
-#define PGLUE_REG_B_PF_BAR1_SIZE_RT_OFFSET     28709
-#define PGLUE_REG_B_VF_BAR1_SIZE_RT_OFFSET     28710
-#define TM_REG_VF_ENABLE_CONN_RT_OFFSET        28711
-#define TM_REG_PF_ENABLE_CONN_RT_OFFSET        28712
-#define TM_REG_PF_ENABLE_TASK_RT_OFFSET        28713
-#define TM_REG_GROUP_SIZE_RESOLUTION_CONN_RT_OFFSET    28714
-#define TM_REG_GROUP_SIZE_RESOLUTION_TASK_RT_OFFSET    28715
-#define TM_REG_CONFIG_CONN_MEM_RT_OFFSET       28716
+#define PGLUE_REG_B_VF_BASE_RT_OFFSET  28702
+#define PGLUE_REG_B_MSDM_OFFSET_MASK_B_RT_OFFSET       28703
+#define PGLUE_REG_B_MSDM_VF_SHIFT_B_RT_OFFSET  28704
+#define PGLUE_REG_B_CACHE_LINE_SIZE_RT_OFFSET  28705
+#define PGLUE_REG_B_PF_BAR0_SIZE_RT_OFFSET     28706
+#define PGLUE_REG_B_PF_BAR1_SIZE_RT_OFFSET     28707
+#define PGLUE_REG_B_VF_BAR1_SIZE_RT_OFFSET     28708
+#define TM_REG_VF_ENABLE_CONN_RT_OFFSET        28709
+#define TM_REG_PF_ENABLE_CONN_RT_OFFSET        28710
+#define TM_REG_PF_ENABLE_TASK_RT_OFFSET        28711
+#define TM_REG_GROUP_SIZE_RESOLUTION_CONN_RT_OFFSET    28712
+#define TM_REG_GROUP_SIZE_RESOLUTION_TASK_RT_OFFSET    28713
+#define TM_REG_CONFIG_CONN_MEM_RT_OFFSET       28714
 #define TM_REG_CONFIG_CONN_MEM_RT_SIZE 416
-#define TM_REG_CONFIG_TASK_MEM_RT_OFFSET       29132
-#define TM_REG_CONFIG_TASK_MEM_RT_SIZE 512
-#define QM_REG_MAXPQSIZE_0_RT_OFFSET   29644
-#define QM_REG_MAXPQSIZE_1_RT_OFFSET   29645
-#define QM_REG_MAXPQSIZE_2_RT_OFFSET   29646
-#define QM_REG_MAXPQSIZETXSEL_0_RT_OFFSET      29647
-#define QM_REG_MAXPQSIZETXSEL_1_RT_OFFSET      29648
-#define QM_REG_MAXPQSIZETXSEL_2_RT_OFFSET      29649
-#define QM_REG_MAXPQSIZETXSEL_3_RT_OFFSET      29650
-#define QM_REG_MAXPQSIZETXSEL_4_RT_OFFSET      29651
-#define QM_REG_MAXPQSIZETXSEL_5_RT_OFFSET      29652
-#define QM_REG_MAXPQSIZETXSEL_6_RT_OFFSET      29653
-#define QM_REG_MAXPQSIZETXSEL_7_RT_OFFSET      29654
-#define QM_REG_MAXPQSIZETXSEL_8_RT_OFFSET      29655
-#define QM_REG_MAXPQSIZETXSEL_9_RT_OFFSET      29656
-#define QM_REG_MAXPQSIZETXSEL_10_RT_OFFSET     29657
-#define QM_REG_MAXPQSIZETXSEL_11_RT_OFFSET     29658
-#define QM_REG_MAXPQSIZETXSEL_12_RT_OFFSET     29659
-#define QM_REG_MAXPQSIZETXSEL_13_RT_OFFSET     29660
-#define QM_REG_MAXPQSIZETXSEL_14_RT_OFFSET     29661
-#define QM_REG_MAXPQSIZETXSEL_15_RT_OFFSET     29662
-#define QM_REG_MAXPQSIZETXSEL_16_RT_OFFSET     29663
-#define QM_REG_MAXPQSIZETXSEL_17_RT_OFFSET     29664
-#define QM_REG_MAXPQSIZETXSEL_18_RT_OFFSET     29665
-#define QM_REG_MAXPQSIZETXSEL_19_RT_OFFSET     29666
-#define QM_REG_MAXPQSIZETXSEL_20_RT_OFFSET     29667
-#define QM_REG_MAXPQSIZETXSEL_21_RT_OFFSET     29668
-#define QM_REG_MAXPQSIZETXSEL_22_RT_OFFSET     29669
-#define QM_REG_MAXPQSIZETXSEL_23_RT_OFFSET     29670
-#define QM_REG_MAXPQSIZETXSEL_24_RT_OFFSET     29671
-#define QM_REG_MAXPQSIZETXSEL_25_RT_OFFSET     29672
-#define QM_REG_MAXPQSIZETXSEL_26_RT_OFFSET     29673
-#define QM_REG_MAXPQSIZETXSEL_27_RT_OFFSET     29674
-#define QM_REG_MAXPQSIZETXSEL_28_RT_OFFSET     29675
-#define QM_REG_MAXPQSIZETXSEL_29_RT_OFFSET     29676
-#define QM_REG_MAXPQSIZETXSEL_30_RT_OFFSET     29677
-#define QM_REG_MAXPQSIZETXSEL_31_RT_OFFSET     29678
-#define QM_REG_MAXPQSIZETXSEL_32_RT_OFFSET     29679
-#define QM_REG_MAXPQSIZETXSEL_33_RT_OFFSET     29680
-#define QM_REG_MAXPQSIZETXSEL_34_RT_OFFSET     29681
-#define QM_REG_MAXPQSIZETXSEL_35_RT_OFFSET     29682
-#define QM_REG_MAXPQSIZETXSEL_36_RT_OFFSET     29683
-#define QM_REG_MAXPQSIZETXSEL_37_RT_OFFSET     29684
-#define QM_REG_MAXPQSIZETXSEL_38_RT_OFFSET     29685
-#define QM_REG_MAXPQSIZETXSEL_39_RT_OFFSET     29686
-#define QM_REG_MAXPQSIZETXSEL_40_RT_OFFSET     29687
-#define QM_REG_MAXPQSIZETXSEL_41_RT_OFFSET     29688
-#define QM_REG_MAXPQSIZETXSEL_42_RT_OFFSET     29689
-#define QM_REG_MAXPQSIZETXSEL_43_RT_OFFSET     29690
-#define QM_REG_MAXPQSIZETXSEL_44_RT_OFFSET     29691
-#define QM_REG_MAXPQSIZETXSEL_45_RT_OFFSET     29692
-#define QM_REG_MAXPQSIZETXSEL_46_RT_OFFSET     29693
-#define QM_REG_MAXPQSIZETXSEL_47_RT_OFFSET     29694
-#define QM_REG_MAXPQSIZETXSEL_48_RT_OFFSET     29695
-#define QM_REG_MAXPQSIZETXSEL_49_RT_OFFSET     29696
-#define QM_REG_MAXPQSIZETXSEL_50_RT_OFFSET     29697
-#define QM_REG_MAXPQSIZETXSEL_51_RT_OFFSET     29698
-#define QM_REG_MAXPQSIZETXSEL_52_RT_OFFSET     29699
-#define QM_REG_MAXPQSIZETXSEL_53_RT_OFFSET     29700
-#define QM_REG_MAXPQSIZETXSEL_54_RT_OFFSET     29701
-#define QM_REG_MAXPQSIZETXSEL_55_RT_OFFSET     29702
-#define QM_REG_MAXPQSIZETXSEL_56_RT_OFFSET     29703
-#define QM_REG_MAXPQSIZETXSEL_57_RT_OFFSET     29704
-#define QM_REG_MAXPQSIZETXSEL_58_RT_OFFSET     29705
-#define QM_REG_MAXPQSIZETXSEL_59_RT_OFFSET     29706
-#define QM_REG_MAXPQSIZETXSEL_60_RT_OFFSET     29707
-#define QM_REG_MAXPQSIZETXSEL_61_RT_OFFSET     29708
-#define QM_REG_MAXPQSIZETXSEL_62_RT_OFFSET     29709
-#define QM_REG_MAXPQSIZETXSEL_63_RT_OFFSET     29710
-#define QM_REG_BASEADDROTHERPQ_RT_OFFSET       29711
+#define TM_REG_CONFIG_TASK_MEM_RT_OFFSET       29130
+#define TM_REG_CONFIG_TASK_MEM_RT_SIZE 608
+#define QM_REG_MAXPQSIZE_0_RT_OFFSET   29738
+#define QM_REG_MAXPQSIZE_1_RT_OFFSET   29739
+#define QM_REG_MAXPQSIZE_2_RT_OFFSET   29740
+#define QM_REG_MAXPQSIZETXSEL_0_RT_OFFSET      29741
+#define QM_REG_MAXPQSIZETXSEL_1_RT_OFFSET      29742
+#define QM_REG_MAXPQSIZETXSEL_2_RT_OFFSET      29743
+#define QM_REG_MAXPQSIZETXSEL_3_RT_OFFSET      29744
+#define QM_REG_MAXPQSIZETXSEL_4_RT_OFFSET      29745
+#define QM_REG_MAXPQSIZETXSEL_5_RT_OFFSET      29746
+#define QM_REG_MAXPQSIZETXSEL_6_RT_OFFSET      29747
+#define QM_REG_MAXPQSIZETXSEL_7_RT_OFFSET      29748
+#define QM_REG_MAXPQSIZETXSEL_8_RT_OFFSET      29749
+#define QM_REG_MAXPQSIZETXSEL_9_RT_OFFSET      29750
+#define QM_REG_MAXPQSIZETXSEL_10_RT_OFFSET     29751
+#define QM_REG_MAXPQSIZETXSEL_11_RT_OFFSET     29752
+#define QM_REG_MAXPQSIZETXSEL_12_RT_OFFSET     29753
+#define QM_REG_MAXPQSIZETXSEL_13_RT_OFFSET     29754
+#define QM_REG_MAXPQSIZETXSEL_14_RT_OFFSET     29755
+#define QM_REG_MAXPQSIZETXSEL_15_RT_OFFSET     29756
+#define QM_REG_MAXPQSIZETXSEL_16_RT_OFFSET     29757
+#define QM_REG_MAXPQSIZETXSEL_17_RT_OFFSET     29758
+#define QM_REG_MAXPQSIZETXSEL_18_RT_OFFSET     29759
+#define QM_REG_MAXPQSIZETXSEL_19_RT_OFFSET     29760
+#define QM_REG_MAXPQSIZETXSEL_20_RT_OFFSET     29761
+#define QM_REG_MAXPQSIZETXSEL_21_RT_OFFSET     29762
+#define QM_REG_MAXPQSIZETXSEL_22_RT_OFFSET     29763
+#define QM_REG_MAXPQSIZETXSEL_23_RT_OFFSET     29764
+#define QM_REG_MAXPQSIZETXSEL_24_RT_OFFSET     29765
+#define QM_REG_MAXPQSIZETXSEL_25_RT_OFFSET     29766
+#define QM_REG_MAXPQSIZETXSEL_26_RT_OFFSET     29767
+#define QM_REG_MAXPQSIZETXSEL_27_RT_OFFSET     29768
+#define QM_REG_MAXPQSIZETXSEL_28_RT_OFFSET     29769
+#define QM_REG_MAXPQSIZETXSEL_29_RT_OFFSET     29770
+#define QM_REG_MAXPQSIZETXSEL_30_RT_OFFSET     29771
+#define QM_REG_MAXPQSIZETXSEL_31_RT_OFFSET     29772
+#define QM_REG_MAXPQSIZETXSEL_32_RT_OFFSET     29773
+#define QM_REG_MAXPQSIZETXSEL_33_RT_OFFSET     29774
+#define QM_REG_MAXPQSIZETXSEL_34_RT_OFFSET     29775
+#define QM_REG_MAXPQSIZETXSEL_35_RT_OFFSET     29776
+#define QM_REG_MAXPQSIZETXSEL_36_RT_OFFSET     29777
+#define QM_REG_MAXPQSIZETXSEL_37_RT_OFFSET     29778
+#define QM_REG_MAXPQSIZETXSEL_38_RT_OFFSET     29779
+#define QM_REG_MAXPQSIZETXSEL_39_RT_OFFSET     29780
+#define QM_REG_MAXPQSIZETXSEL_40_RT_OFFSET     29781
+#define QM_REG_MAXPQSIZETXSEL_41_RT_OFFSET     29782
+#define QM_REG_MAXPQSIZETXSEL_42_RT_OFFSET     29783
+#define QM_REG_MAXPQSIZETXSEL_43_RT_OFFSET     29784
+#define QM_REG_MAXPQSIZETXSEL_44_RT_OFFSET     29785
+#define QM_REG_MAXPQSIZETXSEL_45_RT_OFFSET     29786
+#define QM_REG_MAXPQSIZETXSEL_46_RT_OFFSET     29787
+#define QM_REG_MAXPQSIZETXSEL_47_RT_OFFSET     29788
+#define QM_REG_MAXPQSIZETXSEL_48_RT_OFFSET     29789
+#define QM_REG_MAXPQSIZETXSEL_49_RT_OFFSET     29790
+#define QM_REG_MAXPQSIZETXSEL_50_RT_OFFSET     29791
+#define QM_REG_MAXPQSIZETXSEL_51_RT_OFFSET     29792
+#define QM_REG_MAXPQSIZETXSEL_52_RT_OFFSET     29793
+#define QM_REG_MAXPQSIZETXSEL_53_RT_OFFSET     29794
+#define QM_REG_MAXPQSIZETXSEL_54_RT_OFFSET     29795
+#define QM_REG_MAXPQSIZETXSEL_55_RT_OFFSET     29796
+#define QM_REG_MAXPQSIZETXSEL_56_RT_OFFSET     29797
+#define QM_REG_MAXPQSIZETXSEL_57_RT_OFFSET     29798
+#define QM_REG_MAXPQSIZETXSEL_58_RT_OFFSET     29799
+#define QM_REG_MAXPQSIZETXSEL_59_RT_OFFSET     29800
+#define QM_REG_MAXPQSIZETXSEL_60_RT_OFFSET     29801
+#define QM_REG_MAXPQSIZETXSEL_61_RT_OFFSET     29802
+#define QM_REG_MAXPQSIZETXSEL_62_RT_OFFSET     29803
+#define QM_REG_MAXPQSIZETXSEL_63_RT_OFFSET     29804
+#define QM_REG_BASEADDROTHERPQ_RT_OFFSET       29805
 #define QM_REG_BASEADDROTHERPQ_RT_SIZE 128
-#define QM_REG_VOQCRDLINE_RT_OFFSET    29839
-#define QM_REG_VOQCRDLINE_RT_SIZE      20
-#define QM_REG_VOQINITCRDLINE_RT_OFFSET        29859
-#define QM_REG_VOQINITCRDLINE_RT_SIZE  20
-#define QM_REG_AFULLQMBYPTHRPFWFQ_RT_OFFSET    29879
-#define QM_REG_AFULLQMBYPTHRVPWFQ_RT_OFFSET    29880
-#define QM_REG_AFULLQMBYPTHRPFRL_RT_OFFSET     29881
-#define QM_REG_AFULLQMBYPTHRGLBLRL_RT_OFFSET   29882
-#define QM_REG_AFULLOPRTNSTCCRDMASK_RT_OFFSET  29883
-#define QM_REG_WRROTHERPQGRP_0_RT_OFFSET       29884
-#define QM_REG_WRROTHERPQGRP_1_RT_OFFSET       29885
-#define QM_REG_WRROTHERPQGRP_2_RT_OFFSET       29886
-#define QM_REG_WRROTHERPQGRP_3_RT_OFFSET       29887
-#define QM_REG_WRROTHERPQGRP_4_RT_OFFSET       29888
-#define QM_REG_WRROTHERPQGRP_5_RT_OFFSET       29889
-#define QM_REG_WRROTHERPQGRP_6_RT_OFFSET       29890
-#define QM_REG_WRROTHERPQGRP_7_RT_OFFSET       29891
-#define QM_REG_WRROTHERPQGRP_8_RT_OFFSET       29892
-#define QM_REG_WRROTHERPQGRP_9_RT_OFFSET       29893
-#define QM_REG_WRROTHERPQGRP_10_RT_OFFSET      29894
-#define QM_REG_WRROTHERPQGRP_11_RT_OFFSET      29895
-#define QM_REG_WRROTHERPQGRP_12_RT_OFFSET      29896
-#define QM_REG_WRROTHERPQGRP_13_RT_OFFSET      29897
-#define QM_REG_WRROTHERPQGRP_14_RT_OFFSET      29898
-#define QM_REG_WRROTHERPQGRP_15_RT_OFFSET      29899
-#define QM_REG_WRROTHERGRPWEIGHT_0_RT_OFFSET   29900
-#define QM_REG_WRROTHERGRPWEIGHT_1_RT_OFFSET   29901
-#define QM_REG_WRROTHERGRPWEIGHT_2_RT_OFFSET   29902
-#define QM_REG_WRROTHERGRPWEIGHT_3_RT_OFFSET   29903
-#define QM_REG_WRRTXGRPWEIGHT_0_RT_OFFSET      29904
-#define QM_REG_WRRTXGRPWEIGHT_1_RT_OFFSET      29905
-#define QM_REG_PQTX2PF_0_RT_OFFSET     29906
-#define QM_REG_PQTX2PF_1_RT_OFFSET     29907
-#define QM_REG_PQTX2PF_2_RT_OFFSET     29908
-#define QM_REG_PQTX2PF_3_RT_OFFSET     29909
-#define QM_REG_PQTX2PF_4_RT_OFFSET     29910
-#define QM_REG_PQTX2PF_5_RT_OFFSET     29911
-#define QM_REG_PQTX2PF_6_RT_OFFSET     29912
-#define QM_REG_PQTX2PF_7_RT_OFFSET     29913
-#define QM_REG_PQTX2PF_8_RT_OFFSET     29914
-#define QM_REG_PQTX2PF_9_RT_OFFSET     29915
-#define QM_REG_PQTX2PF_10_RT_OFFSET    29916
-#define QM_REG_PQTX2PF_11_RT_OFFSET    29917
-#define QM_REG_PQTX2PF_12_RT_OFFSET    29918
-#define QM_REG_PQTX2PF_13_RT_OFFSET    29919
-#define QM_REG_PQTX2PF_14_RT_OFFSET    29920
-#define QM_REG_PQTX2PF_15_RT_OFFSET    29921
-#define QM_REG_PQTX2PF_16_RT_OFFSET    29922
-#define QM_REG_PQTX2PF_17_RT_OFFSET    29923
-#define QM_REG_PQTX2PF_18_RT_OFFSET    29924
-#define QM_REG_PQTX2PF_19_RT_OFFSET    29925
-#define QM_REG_PQTX2PF_20_RT_OFFSET    29926
-#define QM_REG_PQTX2PF_21_RT_OFFSET    29927
-#define QM_REG_PQTX2PF_22_RT_OFFSET    29928
-#define QM_REG_PQTX2PF_23_RT_OFFSET    29929
-#define QM_REG_PQTX2PF_24_RT_OFFSET    29930
-#define QM_REG_PQTX2PF_25_RT_OFFSET    29931
-#define QM_REG_PQTX2PF_26_RT_OFFSET    29932
-#define QM_REG_PQTX2PF_27_RT_OFFSET    29933
-#define QM_REG_PQTX2PF_28_RT_OFFSET    29934
-#define QM_REG_PQTX2PF_29_RT_OFFSET    29935
-#define QM_REG_PQTX2PF_30_RT_OFFSET    29936
-#define QM_REG_PQTX2PF_31_RT_OFFSET    29937
-#define QM_REG_PQTX2PF_32_RT_OFFSET    29938
-#define QM_REG_PQTX2PF_33_RT_OFFSET    29939
-#define QM_REG_PQTX2PF_34_RT_OFFSET    29940
-#define QM_REG_PQTX2PF_35_RT_OFFSET    29941
-#define QM_REG_PQTX2PF_36_RT_OFFSET    29942
-#define QM_REG_PQTX2PF_37_RT_OFFSET    29943
-#define QM_REG_PQTX2PF_38_RT_OFFSET    29944
-#define QM_REG_PQTX2PF_39_RT_OFFSET    29945
-#define QM_REG_PQTX2PF_40_RT_OFFSET    29946
-#define QM_REG_PQTX2PF_41_RT_OFFSET    29947
-#define QM_REG_PQTX2PF_42_RT_OFFSET    29948
-#define QM_REG_PQTX2PF_43_RT_OFFSET    29949
-#define QM_REG_PQTX2PF_44_RT_OFFSET    29950
-#define QM_REG_PQTX2PF_45_RT_OFFSET    29951
-#define QM_REG_PQTX2PF_46_RT_OFFSET    29952
-#define QM_REG_PQTX2PF_47_RT_OFFSET    29953
-#define QM_REG_PQTX2PF_48_RT_OFFSET    29954
-#define QM_REG_PQTX2PF_49_RT_OFFSET    29955
-#define QM_REG_PQTX2PF_50_RT_OFFSET    29956
-#define QM_REG_PQTX2PF_51_RT_OFFSET    29957
-#define QM_REG_PQTX2PF_52_RT_OFFSET    29958
-#define QM_REG_PQTX2PF_53_RT_OFFSET    29959
-#define QM_REG_PQTX2PF_54_RT_OFFSET    29960
-#define QM_REG_PQTX2PF_55_RT_OFFSET    29961
-#define QM_REG_PQTX2PF_56_RT_OFFSET    29962
-#define QM_REG_PQTX2PF_57_RT_OFFSET    29963
-#define QM_REG_PQTX2PF_58_RT_OFFSET    29964
-#define QM_REG_PQTX2PF_59_RT_OFFSET    29965
-#define QM_REG_PQTX2PF_60_RT_OFFSET    29966
-#define QM_REG_PQTX2PF_61_RT_OFFSET    29967
-#define QM_REG_PQTX2PF_62_RT_OFFSET    29968
-#define QM_REG_PQTX2PF_63_RT_OFFSET    29969
-#define QM_REG_PQOTHER2PF_0_RT_OFFSET  29970
-#define QM_REG_PQOTHER2PF_1_RT_OFFSET  29971
-#define QM_REG_PQOTHER2PF_2_RT_OFFSET  29972
-#define QM_REG_PQOTHER2PF_3_RT_OFFSET  29973
-#define QM_REG_PQOTHER2PF_4_RT_OFFSET  29974
-#define QM_REG_PQOTHER2PF_5_RT_OFFSET  29975
-#define QM_REG_PQOTHER2PF_6_RT_OFFSET  29976
-#define QM_REG_PQOTHER2PF_7_RT_OFFSET  29977
-#define QM_REG_PQOTHER2PF_8_RT_OFFSET  29978
-#define QM_REG_PQOTHER2PF_9_RT_OFFSET  29979
-#define QM_REG_PQOTHER2PF_10_RT_OFFSET 29980
-#define QM_REG_PQOTHER2PF_11_RT_OFFSET 29981
-#define QM_REG_PQOTHER2PF_12_RT_OFFSET 29982
-#define QM_REG_PQOTHER2PF_13_RT_OFFSET 29983
-#define QM_REG_PQOTHER2PF_14_RT_OFFSET 29984
-#define QM_REG_PQOTHER2PF_15_RT_OFFSET 29985
-#define QM_REG_RLGLBLPERIOD_0_RT_OFFSET        29986
-#define QM_REG_RLGLBLPERIOD_1_RT_OFFSET        29987
-#define QM_REG_RLGLBLPERIODTIMER_0_RT_OFFSET   29988
-#define QM_REG_RLGLBLPERIODTIMER_1_RT_OFFSET   29989
-#define QM_REG_RLGLBLPERIODSEL_0_RT_OFFSET     29990
-#define QM_REG_RLGLBLPERIODSEL_1_RT_OFFSET     29991
-#define QM_REG_RLGLBLPERIODSEL_2_RT_OFFSET     29992
-#define QM_REG_RLGLBLPERIODSEL_3_RT_OFFSET     29993
-#define QM_REG_RLGLBLPERIODSEL_4_RT_OFFSET     29994
-#define QM_REG_RLGLBLPERIODSEL_5_RT_OFFSET     29995
-#define QM_REG_RLGLBLPERIODSEL_6_RT_OFFSET     29996
-#define QM_REG_RLGLBLPERIODSEL_7_RT_OFFSET     29997
-#define QM_REG_RLGLBLINCVAL_RT_OFFSET  29998
+#define QM_REG_AFULLQMBYPTHRPFWFQ_RT_OFFSET    29933
+#define QM_REG_AFULLQMBYPTHRVPWFQ_RT_OFFSET    29934
+#define QM_REG_AFULLQMBYPTHRPFRL_RT_OFFSET     29935
+#define QM_REG_AFULLQMBYPTHRGLBLRL_RT_OFFSET   29936
+#define QM_REG_AFULLOPRTNSTCCRDMASK_RT_OFFSET  29937
+#define QM_REG_WRROTHERPQGRP_0_RT_OFFSET       29938
+#define QM_REG_WRROTHERPQGRP_1_RT_OFFSET       29939
+#define QM_REG_WRROTHERPQGRP_2_RT_OFFSET       29940
+#define QM_REG_WRROTHERPQGRP_3_RT_OFFSET       29941
+#define QM_REG_WRROTHERPQGRP_4_RT_OFFSET       29942
+#define QM_REG_WRROTHERPQGRP_5_RT_OFFSET       29943
+#define QM_REG_WRROTHERPQGRP_6_RT_OFFSET       29944
+#define QM_REG_WRROTHERPQGRP_7_RT_OFFSET       29945
+#define QM_REG_WRROTHERPQGRP_8_RT_OFFSET       29946
+#define QM_REG_WRROTHERPQGRP_9_RT_OFFSET       29947
+#define QM_REG_WRROTHERPQGRP_10_RT_OFFSET      29948
+#define QM_REG_WRROTHERPQGRP_11_RT_OFFSET      29949
+#define QM_REG_WRROTHERPQGRP_12_RT_OFFSET      29950
+#define QM_REG_WRROTHERPQGRP_13_RT_OFFSET      29951
+#define QM_REG_WRROTHERPQGRP_14_RT_OFFSET      29952
+#define QM_REG_WRROTHERPQGRP_15_RT_OFFSET      29953
+#define QM_REG_WRROTHERGRPWEIGHT_0_RT_OFFSET   29954
+#define QM_REG_WRROTHERGRPWEIGHT_1_RT_OFFSET   29955
+#define QM_REG_WRROTHERGRPWEIGHT_2_RT_OFFSET   29956
+#define QM_REG_WRROTHERGRPWEIGHT_3_RT_OFFSET   29957
+#define QM_REG_WRRTXGRPWEIGHT_0_RT_OFFSET      29958
+#define QM_REG_WRRTXGRPWEIGHT_1_RT_OFFSET      29959
+#define QM_REG_PQTX2PF_0_RT_OFFSET     29960
+#define QM_REG_PQTX2PF_1_RT_OFFSET     29961
+#define QM_REG_PQTX2PF_2_RT_OFFSET     29962
+#define QM_REG_PQTX2PF_3_RT_OFFSET     29963
+#define QM_REG_PQTX2PF_4_RT_OFFSET     29964
+#define QM_REG_PQTX2PF_5_RT_OFFSET     29965
+#define QM_REG_PQTX2PF_6_RT_OFFSET     29966
+#define QM_REG_PQTX2PF_7_RT_OFFSET     29967
+#define QM_REG_PQTX2PF_8_RT_OFFSET     29968
+#define QM_REG_PQTX2PF_9_RT_OFFSET     29969
+#define QM_REG_PQTX2PF_10_RT_OFFSET    29970
+#define QM_REG_PQTX2PF_11_RT_OFFSET    29971
+#define QM_REG_PQTX2PF_12_RT_OFFSET    29972
+#define QM_REG_PQTX2PF_13_RT_OFFSET    29973
+#define QM_REG_PQTX2PF_14_RT_OFFSET    29974
+#define QM_REG_PQTX2PF_15_RT_OFFSET    29975
+#define QM_REG_PQTX2PF_16_RT_OFFSET    29976
+#define QM_REG_PQTX2PF_17_RT_OFFSET    29977
+#define QM_REG_PQTX2PF_18_RT_OFFSET    29978
+#define QM_REG_PQTX2PF_19_RT_OFFSET    29979
+#define QM_REG_PQTX2PF_20_RT_OFFSET    29980
+#define QM_REG_PQTX2PF_21_RT_OFFSET    29981
+#define QM_REG_PQTX2PF_22_RT_OFFSET    29982
+#define QM_REG_PQTX2PF_23_RT_OFFSET    29983
+#define QM_REG_PQTX2PF_24_RT_OFFSET    29984
+#define QM_REG_PQTX2PF_25_RT_OFFSET    29985
+#define QM_REG_PQTX2PF_26_RT_OFFSET    29986
+#define QM_REG_PQTX2PF_27_RT_OFFSET    29987
+#define QM_REG_PQTX2PF_28_RT_OFFSET    29988
+#define QM_REG_PQTX2PF_29_RT_OFFSET    29989
+#define QM_REG_PQTX2PF_30_RT_OFFSET    29990
+#define QM_REG_PQTX2PF_31_RT_OFFSET    29991
+#define QM_REG_PQTX2PF_32_RT_OFFSET    29992
+#define QM_REG_PQTX2PF_33_RT_OFFSET    29993
+#define QM_REG_PQTX2PF_34_RT_OFFSET    29994
+#define QM_REG_PQTX2PF_35_RT_OFFSET    29995
+#define QM_REG_PQTX2PF_36_RT_OFFSET    29996
+#define QM_REG_PQTX2PF_37_RT_OFFSET    29997
+#define QM_REG_PQTX2PF_38_RT_OFFSET    29998
+#define QM_REG_PQTX2PF_39_RT_OFFSET    29999
+#define QM_REG_PQTX2PF_40_RT_OFFSET    30000
+#define QM_REG_PQTX2PF_41_RT_OFFSET    30001
+#define QM_REG_PQTX2PF_42_RT_OFFSET    30002
+#define QM_REG_PQTX2PF_43_RT_OFFSET    30003
+#define QM_REG_PQTX2PF_44_RT_OFFSET    30004
+#define QM_REG_PQTX2PF_45_RT_OFFSET    30005
+#define QM_REG_PQTX2PF_46_RT_OFFSET    30006
+#define QM_REG_PQTX2PF_47_RT_OFFSET    30007
+#define QM_REG_PQTX2PF_48_RT_OFFSET    30008
+#define QM_REG_PQTX2PF_49_RT_OFFSET    30009
+#define QM_REG_PQTX2PF_50_RT_OFFSET    30010
+#define QM_REG_PQTX2PF_51_RT_OFFSET    30011
+#define QM_REG_PQTX2PF_52_RT_OFFSET    30012
+#define QM_REG_PQTX2PF_53_RT_OFFSET    30013
+#define QM_REG_PQTX2PF_54_RT_OFFSET    30014
+#define QM_REG_PQTX2PF_55_RT_OFFSET    30015
+#define QM_REG_PQTX2PF_56_RT_OFFSET    30016
+#define QM_REG_PQTX2PF_57_RT_OFFSET    30017
+#define QM_REG_PQTX2PF_58_RT_OFFSET    30018
+#define QM_REG_PQTX2PF_59_RT_OFFSET    30019
+#define QM_REG_PQTX2PF_60_RT_OFFSET    30020
+#define QM_REG_PQTX2PF_61_RT_OFFSET    30021
+#define QM_REG_PQTX2PF_62_RT_OFFSET    30022
+#define QM_REG_PQTX2PF_63_RT_OFFSET    30023
+#define QM_REG_PQOTHER2PF_0_RT_OFFSET  30024
+#define QM_REG_PQOTHER2PF_1_RT_OFFSET  30025
+#define QM_REG_PQOTHER2PF_2_RT_OFFSET  30026
+#define QM_REG_PQOTHER2PF_3_RT_OFFSET  30027
+#define QM_REG_PQOTHER2PF_4_RT_OFFSET  30028
+#define QM_REG_PQOTHER2PF_5_RT_OFFSET  30029
+#define QM_REG_PQOTHER2PF_6_RT_OFFSET  30030
+#define QM_REG_PQOTHER2PF_7_RT_OFFSET  30031
+#define QM_REG_PQOTHER2PF_8_RT_OFFSET  30032
+#define QM_REG_PQOTHER2PF_9_RT_OFFSET  30033
+#define QM_REG_PQOTHER2PF_10_RT_OFFSET 30034
+#define QM_REG_PQOTHER2PF_11_RT_OFFSET 30035
+#define QM_REG_PQOTHER2PF_12_RT_OFFSET 30036
+#define QM_REG_PQOTHER2PF_13_RT_OFFSET 30037
+#define QM_REG_PQOTHER2PF_14_RT_OFFSET 30038
+#define QM_REG_PQOTHER2PF_15_RT_OFFSET 30039
+#define QM_REG_RLGLBLPERIOD_0_RT_OFFSET        30040
+#define QM_REG_RLGLBLPERIOD_1_RT_OFFSET        30041
+#define QM_REG_RLGLBLPERIODTIMER_0_RT_OFFSET   30042
+#define QM_REG_RLGLBLPERIODTIMER_1_RT_OFFSET   30043
+#define QM_REG_RLGLBLPERIODSEL_0_RT_OFFSET     30044
+#define QM_REG_RLGLBLPERIODSEL_1_RT_OFFSET     30045
+#define QM_REG_RLGLBLPERIODSEL_2_RT_OFFSET     30046
+#define QM_REG_RLGLBLPERIODSEL_3_RT_OFFSET     30047
+#define QM_REG_RLGLBLPERIODSEL_4_RT_OFFSET     30048
+#define QM_REG_RLGLBLPERIODSEL_5_RT_OFFSET     30049
+#define QM_REG_RLGLBLPERIODSEL_6_RT_OFFSET     30050
+#define QM_REG_RLGLBLPERIODSEL_7_RT_OFFSET     30051
+#define QM_REG_RLGLBLINCVAL_RT_OFFSET  30052
 #define QM_REG_RLGLBLINCVAL_RT_SIZE    256
-#define QM_REG_RLGLBLUPPERBOUND_RT_OFFSET      30254
+#define QM_REG_RLGLBLUPPERBOUND_RT_OFFSET      30308
 #define QM_REG_RLGLBLUPPERBOUND_RT_SIZE        256
-#define QM_REG_RLGLBLCRD_RT_OFFSET     30510
+#define QM_REG_RLGLBLCRD_RT_OFFSET     30564
 #define QM_REG_RLGLBLCRD_RT_SIZE       256
-#define QM_REG_RLGLBLENABLE_RT_OFFSET  30766
-#define QM_REG_RLPFPERIOD_RT_OFFSET    30767
-#define QM_REG_RLPFPERIODTIMER_RT_OFFSET       30768
-#define QM_REG_RLPFINCVAL_RT_OFFSET    30769
+#define QM_REG_RLGLBLENABLE_RT_OFFSET  30820
+#define QM_REG_RLPFPERIOD_RT_OFFSET    30821
+#define QM_REG_RLPFPERIODTIMER_RT_OFFSET       30822
+#define QM_REG_RLPFINCVAL_RT_OFFSET    30823
 #define QM_REG_RLPFINCVAL_RT_SIZE      16
-#define QM_REG_RLPFUPPERBOUND_RT_OFFSET        30785
+#define QM_REG_RLPFUPPERBOUND_RT_OFFSET        30839
 #define QM_REG_RLPFUPPERBOUND_RT_SIZE  16
-#define QM_REG_RLPFCRD_RT_OFFSET       30801
+#define QM_REG_RLPFCRD_RT_OFFSET       30855
 #define QM_REG_RLPFCRD_RT_SIZE 16
-#define QM_REG_RLPFENABLE_RT_OFFSET    30817
-#define QM_REG_RLPFVOQENABLE_RT_OFFSET 30818
-#define QM_REG_WFQPFWEIGHT_RT_OFFSET   30819
+#define QM_REG_RLPFENABLE_RT_OFFSET    30871
+#define QM_REG_RLPFVOQENABLE_RT_OFFSET 30872
+#define QM_REG_WFQPFWEIGHT_RT_OFFSET   30873
 #define QM_REG_WFQPFWEIGHT_RT_SIZE     16
-#define QM_REG_WFQPFUPPERBOUND_RT_OFFSET       30835
+#define QM_REG_WFQPFUPPERBOUND_RT_OFFSET       30889
 #define QM_REG_WFQPFUPPERBOUND_RT_SIZE 16
-#define QM_REG_WFQPFCRD_RT_OFFSET      30851
-#define QM_REG_WFQPFCRD_RT_SIZE        160
-#define QM_REG_WFQPFENABLE_RT_OFFSET   31011
-#define QM_REG_WFQVPENABLE_RT_OFFSET   31012
-#define QM_REG_BASEADDRTXPQ_RT_OFFSET  31013
+#define QM_REG_WFQPFCRD_RT_OFFSET      30905
+#define QM_REG_WFQPFCRD_RT_SIZE        256
+#define QM_REG_WFQPFENABLE_RT_OFFSET   31161
+#define QM_REG_WFQVPENABLE_RT_OFFSET   31162
+#define QM_REG_BASEADDRTXPQ_RT_OFFSET  31163
 #define QM_REG_BASEADDRTXPQ_RT_SIZE    512
-#define QM_REG_TXPQMAP_RT_OFFSET       31525
+#define QM_REG_TXPQMAP_RT_OFFSET       31675
 #define QM_REG_TXPQMAP_RT_SIZE 512
-#define QM_REG_WFQVPWEIGHT_RT_OFFSET   32037
+#define QM_REG_WFQVPWEIGHT_RT_OFFSET   32187
 #define QM_REG_WFQVPWEIGHT_RT_SIZE     512
-#define QM_REG_WFQVPCRD_RT_OFFSET      32549
+#define QM_REG_WFQVPCRD_RT_OFFSET      32699
 #define QM_REG_WFQVPCRD_RT_SIZE        512
-#define QM_REG_WFQVPMAP_RT_OFFSET      33061
+#define QM_REG_WFQVPMAP_RT_OFFSET      33211
 #define QM_REG_WFQVPMAP_RT_SIZE        512
-#define QM_REG_WFQPFCRD_MSB_RT_OFFSET  33573
-#define QM_REG_WFQPFCRD_MSB_RT_SIZE    160
-#define NIG_REG_TAG_ETHERTYPE_0_RT_OFFSET      33733
-#define NIG_REG_OUTER_TAG_VALUE_LIST0_RT_OFFSET        33734
-#define NIG_REG_OUTER_TAG_VALUE_LIST1_RT_OFFSET        33735
-#define NIG_REG_OUTER_TAG_VALUE_LIST2_RT_OFFSET        33736
-#define NIG_REG_OUTER_TAG_VALUE_LIST3_RT_OFFSET        33737
-#define NIG_REG_OUTER_TAG_VALUE_MASK_RT_OFFSET 33738
-#define NIG_REG_LLH_FUNC_TAGMAC_CLS_TYPE_RT_OFFSET     33739
-#define NIG_REG_LLH_FUNC_TAG_EN_RT_OFFSET      33740
+#define QM_REG_WFQPFCRD_MSB_RT_OFFSET  33723
+#define QM_REG_WFQPFCRD_MSB_RT_SIZE    320
+#define QM_REG_VOQCRDLINE_RT_OFFSET    34043
+#define QM_REG_VOQCRDLINE_RT_SIZE      36
+#define QM_REG_VOQINITCRDLINE_RT_OFFSET        34079
+#define QM_REG_VOQINITCRDLINE_RT_SIZE  36
+#define NIG_REG_TAG_ETHERTYPE_0_RT_OFFSET      34115
+#define NIG_REG_OUTER_TAG_VALUE_LIST0_RT_OFFSET        34116
+#define NIG_REG_OUTER_TAG_VALUE_LIST1_RT_OFFSET        34117
+#define NIG_REG_OUTER_TAG_VALUE_LIST2_RT_OFFSET        34118
+#define NIG_REG_OUTER_TAG_VALUE_LIST3_RT_OFFSET        34119
+#define NIG_REG_OUTER_TAG_VALUE_MASK_RT_OFFSET 34120
+#define NIG_REG_LLH_FUNC_TAGMAC_CLS_TYPE_RT_OFFSET     34121
+#define NIG_REG_LLH_FUNC_TAG_EN_RT_OFFSET      34122
 #define NIG_REG_LLH_FUNC_TAG_EN_RT_SIZE        4
-#define NIG_REG_LLH_FUNC_TAG_HDR_SEL_RT_OFFSET 33744
+#define NIG_REG_LLH_FUNC_TAG_HDR_SEL_RT_OFFSET 34126
 #define NIG_REG_LLH_FUNC_TAG_HDR_SEL_RT_SIZE   4
-#define NIG_REG_LLH_FUNC_TAG_VALUE_RT_OFFSET   33748
+#define NIG_REG_LLH_FUNC_TAG_VALUE_RT_OFFSET   34130
 #define NIG_REG_LLH_FUNC_TAG_VALUE_RT_SIZE     4
-#define NIG_REG_LLH_FUNC_NO_TAG_RT_OFFSET      33752
-#define NIG_REG_LLH_FUNC_FILTER_VALUE_RT_OFFSET        33753
+#define NIG_REG_LLH_FUNC_NO_TAG_RT_OFFSET      34134
+#define NIG_REG_LLH_FUNC_FILTER_VALUE_RT_OFFSET        34135
 #define NIG_REG_LLH_FUNC_FILTER_VALUE_RT_SIZE  32
-#define NIG_REG_LLH_FUNC_FILTER_EN_RT_OFFSET   33785
+#define NIG_REG_LLH_FUNC_FILTER_EN_RT_OFFSET   34167
 #define NIG_REG_LLH_FUNC_FILTER_EN_RT_SIZE     16
-#define NIG_REG_LLH_FUNC_FILTER_MODE_RT_OFFSET 33801
+#define NIG_REG_LLH_FUNC_FILTER_MODE_RT_OFFSET 34183
 #define NIG_REG_LLH_FUNC_FILTER_MODE_RT_SIZE   16
-#define NIG_REG_LLH_FUNC_FILTER_PROTOCOL_TYPE_RT_OFFSET        33817
+#define NIG_REG_LLH_FUNC_FILTER_PROTOCOL_TYPE_RT_OFFSET        34199
 #define NIG_REG_LLH_FUNC_FILTER_PROTOCOL_TYPE_RT_SIZE  16
-#define NIG_REG_LLH_FUNC_FILTER_HDR_SEL_RT_OFFSET      33833
+#define NIG_REG_LLH_FUNC_FILTER_HDR_SEL_RT_OFFSET      34215
 #define NIG_REG_LLH_FUNC_FILTER_HDR_SEL_RT_SIZE        16
-#define NIG_REG_TX_EDPM_CTRL_RT_OFFSET 33849
-#define NIG_REG_ROCE_DUPLICATE_TO_HOST_RT_OFFSET       33850
-#define CDU_REG_CID_ADDR_PARAMS_RT_OFFSET      33851
-#define CDU_REG_SEGMENT0_PARAMS_RT_OFFSET      33852
-#define CDU_REG_SEGMENT1_PARAMS_RT_OFFSET      33853
-#define CDU_REG_PF_SEG0_TYPE_OFFSET_RT_OFFSET  33854
-#define CDU_REG_PF_SEG1_TYPE_OFFSET_RT_OFFSET  33855
-#define CDU_REG_PF_SEG2_TYPE_OFFSET_RT_OFFSET  33856
-#define CDU_REG_PF_SEG3_TYPE_OFFSET_RT_OFFSET  33857
-#define CDU_REG_PF_FL_SEG0_TYPE_OFFSET_RT_OFFSET       33858
-#define CDU_REG_PF_FL_SEG1_TYPE_OFFSET_RT_OFFSET       33859
-#define CDU_REG_PF_FL_SEG2_TYPE_OFFSET_RT_OFFSET       33860
-#define CDU_REG_PF_FL_SEG3_TYPE_OFFSET_RT_OFFSET       33861
-#define CDU_REG_VF_SEG_TYPE_OFFSET_RT_OFFSET   33862
-#define CDU_REG_VF_FL_SEG_TYPE_OFFSET_RT_OFFSET        33863
-#define PBF_REG_TAG_ETHERTYPE_0_RT_OFFSET      33864
-#define PBF_REG_BTB_SHARED_AREA_SIZE_RT_OFFSET 33865
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ0_RT_OFFSET       33866
-#define PBF_REG_BTB_GUARANTEED_VOQ0_RT_OFFSET  33867
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ0_RT_OFFSET   33868
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ1_RT_OFFSET       33869
-#define PBF_REG_BTB_GUARANTEED_VOQ1_RT_OFFSET  33870
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ1_RT_OFFSET   33871
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ2_RT_OFFSET       33872
-#define PBF_REG_BTB_GUARANTEED_VOQ2_RT_OFFSET  33873
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ2_RT_OFFSET   33874
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ3_RT_OFFSET       33875
-#define PBF_REG_BTB_GUARANTEED_VOQ3_RT_OFFSET  33876
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ3_RT_OFFSET   33877
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ4_RT_OFFSET       33878
-#define PBF_REG_BTB_GUARANTEED_VOQ4_RT_OFFSET  33879
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ4_RT_OFFSET   33880
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ5_RT_OFFSET       33881
-#define PBF_REG_BTB_GUARANTEED_VOQ5_RT_OFFSET  33882
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ5_RT_OFFSET   33883
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ6_RT_OFFSET       33884
-#define PBF_REG_BTB_GUARANTEED_VOQ6_RT_OFFSET  33885
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ6_RT_OFFSET   33886
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ7_RT_OFFSET       33887
-#define PBF_REG_BTB_GUARANTEED_VOQ7_RT_OFFSET  33888
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ7_RT_OFFSET   33889
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ8_RT_OFFSET       33890
-#define PBF_REG_BTB_GUARANTEED_VOQ8_RT_OFFSET  33891
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ8_RT_OFFSET   33892
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ9_RT_OFFSET       33893
-#define PBF_REG_BTB_GUARANTEED_VOQ9_RT_OFFSET  33894
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ9_RT_OFFSET   33895
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ10_RT_OFFSET      33896
-#define PBF_REG_BTB_GUARANTEED_VOQ10_RT_OFFSET 33897
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ10_RT_OFFSET  33898
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ11_RT_OFFSET      33899
-#define PBF_REG_BTB_GUARANTEED_VOQ11_RT_OFFSET 33900
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ11_RT_OFFSET  33901
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ12_RT_OFFSET      33902
-#define PBF_REG_BTB_GUARANTEED_VOQ12_RT_OFFSET 33903
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ12_RT_OFFSET  33904
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ13_RT_OFFSET      33905
-#define PBF_REG_BTB_GUARANTEED_VOQ13_RT_OFFSET 33906
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ13_RT_OFFSET  33907
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ14_RT_OFFSET      33908
-#define PBF_REG_BTB_GUARANTEED_VOQ14_RT_OFFSET 33909
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ14_RT_OFFSET  33910
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ15_RT_OFFSET      33911
-#define PBF_REG_BTB_GUARANTEED_VOQ15_RT_OFFSET 33912
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ15_RT_OFFSET  33913
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ16_RT_OFFSET      33914
-#define PBF_REG_BTB_GUARANTEED_VOQ16_RT_OFFSET 33915
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ16_RT_OFFSET  33916
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ17_RT_OFFSET      33917
-#define PBF_REG_BTB_GUARANTEED_VOQ17_RT_OFFSET 33918
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ17_RT_OFFSET  33919
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ18_RT_OFFSET      33920
-#define PBF_REG_BTB_GUARANTEED_VOQ18_RT_OFFSET 33921
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ18_RT_OFFSET  33922
-#define PBF_REG_YCMD_QS_NUM_LINES_VOQ19_RT_OFFSET      33923
-#define PBF_REG_BTB_GUARANTEED_VOQ19_RT_OFFSET 33924
-#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ19_RT_OFFSET  33925
-#define XCM_REG_CON_PHY_Q3_RT_OFFSET   33926
-
-#define RUNTIME_ARRAY_SIZE 33927
+#define NIG_REG_TX_EDPM_CTRL_RT_OFFSET 34231
+#define NIG_REG_ROCE_DUPLICATE_TO_HOST_RT_OFFSET       34232
+#define CDU_REG_CID_ADDR_PARAMS_RT_OFFSET      34233
+#define CDU_REG_SEGMENT0_PARAMS_RT_OFFSET      34234
+#define CDU_REG_SEGMENT1_PARAMS_RT_OFFSET      34235
+#define CDU_REG_PF_SEG0_TYPE_OFFSET_RT_OFFSET  34236
+#define CDU_REG_PF_SEG1_TYPE_OFFSET_RT_OFFSET  34237
+#define CDU_REG_PF_SEG2_TYPE_OFFSET_RT_OFFSET  34238
+#define CDU_REG_PF_SEG3_TYPE_OFFSET_RT_OFFSET  34239
+#define CDU_REG_PF_FL_SEG0_TYPE_OFFSET_RT_OFFSET       34240
+#define CDU_REG_PF_FL_SEG1_TYPE_OFFSET_RT_OFFSET       34241
+#define CDU_REG_PF_FL_SEG2_TYPE_OFFSET_RT_OFFSET       34242
+#define CDU_REG_PF_FL_SEG3_TYPE_OFFSET_RT_OFFSET       34243
+#define CDU_REG_VF_SEG_TYPE_OFFSET_RT_OFFSET   34244
+#define CDU_REG_VF_FL_SEG_TYPE_OFFSET_RT_OFFSET        34245
+#define PBF_REG_TAG_ETHERTYPE_0_RT_OFFSET      34246
+#define PBF_REG_BTB_SHARED_AREA_SIZE_RT_OFFSET 34247
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ0_RT_OFFSET       34248
+#define PBF_REG_BTB_GUARANTEED_VOQ0_RT_OFFSET  34249
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ0_RT_OFFSET   34250
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ1_RT_OFFSET       34251
+#define PBF_REG_BTB_GUARANTEED_VOQ1_RT_OFFSET  34252
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ1_RT_OFFSET   34253
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ2_RT_OFFSET       34254
+#define PBF_REG_BTB_GUARANTEED_VOQ2_RT_OFFSET  34255
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ2_RT_OFFSET   34256
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ3_RT_OFFSET       34257
+#define PBF_REG_BTB_GUARANTEED_VOQ3_RT_OFFSET  34258
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ3_RT_OFFSET   34259
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ4_RT_OFFSET       34260
+#define PBF_REG_BTB_GUARANTEED_VOQ4_RT_OFFSET  34261
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ4_RT_OFFSET   34262
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ5_RT_OFFSET       34263
+#define PBF_REG_BTB_GUARANTEED_VOQ5_RT_OFFSET  34264
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ5_RT_OFFSET   34265
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ6_RT_OFFSET       34266
+#define PBF_REG_BTB_GUARANTEED_VOQ6_RT_OFFSET  34267
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ6_RT_OFFSET   34268
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ7_RT_OFFSET       34269
+#define PBF_REG_BTB_GUARANTEED_VOQ7_RT_OFFSET  34270
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ7_RT_OFFSET   34271
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ8_RT_OFFSET       34272
+#define PBF_REG_BTB_GUARANTEED_VOQ8_RT_OFFSET  34273
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ8_RT_OFFSET   34274
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ9_RT_OFFSET       34275
+#define PBF_REG_BTB_GUARANTEED_VOQ9_RT_OFFSET  34276
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ9_RT_OFFSET   34277
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ10_RT_OFFSET      34278
+#define PBF_REG_BTB_GUARANTEED_VOQ10_RT_OFFSET 34279
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ10_RT_OFFSET  34280
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ11_RT_OFFSET      34281
+#define PBF_REG_BTB_GUARANTEED_VOQ11_RT_OFFSET 34282
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ11_RT_OFFSET  34283
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ12_RT_OFFSET      34284
+#define PBF_REG_BTB_GUARANTEED_VOQ12_RT_OFFSET 34285
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ12_RT_OFFSET  34286
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ13_RT_OFFSET      34287
+#define PBF_REG_BTB_GUARANTEED_VOQ13_RT_OFFSET 34288
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ13_RT_OFFSET  34289
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ14_RT_OFFSET      34290
+#define PBF_REG_BTB_GUARANTEED_VOQ14_RT_OFFSET 34291
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ14_RT_OFFSET  34292
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ15_RT_OFFSET      34293
+#define PBF_REG_BTB_GUARANTEED_VOQ15_RT_OFFSET 34294
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ15_RT_OFFSET  34295
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ16_RT_OFFSET      34296
+#define PBF_REG_BTB_GUARANTEED_VOQ16_RT_OFFSET 34297
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ16_RT_OFFSET  34298
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ17_RT_OFFSET      34299
+#define PBF_REG_BTB_GUARANTEED_VOQ17_RT_OFFSET 34300
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ17_RT_OFFSET  34301
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ18_RT_OFFSET      34302
+#define PBF_REG_BTB_GUARANTEED_VOQ18_RT_OFFSET 34303
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ18_RT_OFFSET  34304
+#define PBF_REG_YCMD_QS_NUM_LINES_VOQ19_RT_OFFSET      34305
+#define PBF_REG_BTB_GUARANTEED_VOQ19_RT_OFFSET 34306
+#define PBF_REG_BTB_SHARED_AREA_SETUP_VOQ19_RT_OFFSET  34307
+#define XCM_REG_CON_PHY_Q3_RT_OFFSET   34308
+
+#define RUNTIME_ARRAY_SIZE 34309
 
 /* The eth storm context for the Tstorm */
 struct tstorm_eth_conn_st_ctx {
@@ -4307,7 +4610,7 @@ struct xstorm_eth_conn_ag_ctx {
 #define XSTORM_ETH_CONN_AG_CTX_TPH_ENABLE_SHIFT                6
        u8 edpm_event_id;
        __le16 physical_q0;
-       __le16 quota;
+       __le16 ereserved1;
        __le16 edpm_num_bds;
        __le16 tx_bd_cons;
        __le16 tx_bd_prod;
@@ -4340,7 +4643,7 @@ struct xstorm_eth_conn_ag_ctx {
        u8 byte13;
        u8 byte14;
        u8 byte15;
-       u8 byte16;
+       u8 ereserved;
        __le16 word11;
        __le32 reg10;
        __le32 reg11;
@@ -4627,6 +4930,7 @@ enum eth_error_code {
        ETH_FILTERS_PAIR_ADD_FAIL_ZERO_MAC,
        ETH_FILTERS_VNI_ADD_FAIL_FULL,
        ETH_FILTERS_VNI_ADD_FAIL_DUP,
+       ETH_FILTERS_GFT_UPDATE_FAIL,
        MAX_ETH_ERROR_CODE
 };
 
@@ -4879,6 +5183,39 @@ enum gft_logic_filter_type {
        MAX_GFT_LOGIC_FILTER_TYPE
 };
 
+struct rx_add_openflow_filter_data {
+       __le16 action_icid;
+       u8 priority;
+       u8 reserved0;
+       __le32 tenant_id;
+       __le16 dst_mac_hi;
+       __le16 dst_mac_mid;
+       __le16 dst_mac_lo;
+       __le16 src_mac_hi;
+       __le16 src_mac_mid;
+       __le16 src_mac_lo;
+       __le16 vlan_id;
+       __le16 l2_eth_type;
+       u8 ipv4_dscp;
+       u8 ipv4_frag_type;
+       u8 ipv4_over_ip;
+       u8 tenant_id_exists;
+       __le32 ipv4_dst_addr;
+       __le32 ipv4_src_addr;
+       __le16 l4_dst_port;
+       __le16 l4_src_port;
+};
+
+struct rx_create_gft_action_data {
+       u8 vport_id;
+       u8 reserved[7];
+};
+
+struct rx_create_openflow_action_data {
+       u8 vport_id;
+       u8 reserved[7];
+};
+
 /* Ramrod data for rx queue start ramrod */
 struct rx_queue_start_ramrod_data {
        __le16 rx_queue_id;
@@ -4956,7 +5293,7 @@ struct rx_update_gft_filter_data {
        u8 vport_id;
        u8 filter_type;
        u8 filter_action;
-       u8 reserved;
+       u8 assert_on_error;
 };
 
 /* Ramrod data for rx queue start ramrod */
@@ -5102,203 +5439,6 @@ struct vport_update_ramrod_data {
        struct eth_vport_rss_config rss_config;
 };
 
-struct gft_cam_line {
-       __le32 camline;
-#define GFT_CAM_LINE_VALID_MASK                0x1
-#define GFT_CAM_LINE_VALID_SHIFT       0
-#define GFT_CAM_LINE_DATA_MASK         0x3FFF
-#define GFT_CAM_LINE_DATA_SHIFT                1
-#define GFT_CAM_LINE_MASK_BITS_MASK    0x3FFF
-#define GFT_CAM_LINE_MASK_BITS_SHIFT   15
-#define GFT_CAM_LINE_RESERVED1_MASK    0x7
-#define GFT_CAM_LINE_RESERVED1_SHIFT   29
-};
-
-struct gft_cam_line_mapped {
-       __le32 camline;
-#define GFT_CAM_LINE_MAPPED_VALID_MASK                         0x1
-#define GFT_CAM_LINE_MAPPED_VALID_SHIFT                                0
-#define GFT_CAM_LINE_MAPPED_IP_VERSION_MASK                    0x1
-#define GFT_CAM_LINE_MAPPED_IP_VERSION_SHIFT                   1
-#define GFT_CAM_LINE_MAPPED_TUNNEL_IP_VERSION_MASK             0x1
-#define GFT_CAM_LINE_MAPPED_TUNNEL_IP_VERSION_SHIFT            2
-#define GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_MASK           0xF
-#define GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_SHIFT          3
-#define GFT_CAM_LINE_MAPPED_TUNNEL_TYPE_MASK                   0xF
-#define GFT_CAM_LINE_MAPPED_TUNNEL_TYPE_SHIFT                  7
-#define GFT_CAM_LINE_MAPPED_PF_ID_MASK                         0xF
-#define GFT_CAM_LINE_MAPPED_PF_ID_SHIFT                                11
-#define GFT_CAM_LINE_MAPPED_IP_VERSION_MASK_MASK               0x1
-#define GFT_CAM_LINE_MAPPED_IP_VERSION_MASK_SHIFT              15
-#define GFT_CAM_LINE_MAPPED_TUNNEL_IP_VERSION_MASK_MASK                0x1
-#define GFT_CAM_LINE_MAPPED_TUNNEL_IP_VERSION_MASK_SHIFT       16
-#define GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_MASK_MASK      0xF
-#define GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_MASK_SHIFT     17
-#define GFT_CAM_LINE_MAPPED_TUNNEL_TYPE_MASK_MASK              0xF
-#define GFT_CAM_LINE_MAPPED_TUNNEL_TYPE_MASK_SHIFT             21
-#define GFT_CAM_LINE_MAPPED_PF_ID_MASK_MASK                    0xF
-#define GFT_CAM_LINE_MAPPED_PF_ID_MASK_SHIFT                   25
-#define GFT_CAM_LINE_MAPPED_RESERVED1_MASK                     0x7
-#define GFT_CAM_LINE_MAPPED_RESERVED1_SHIFT                    29
-};
-
-union gft_cam_line_union {
-       struct gft_cam_line cam_line;
-       struct gft_cam_line_mapped cam_line_mapped;
-};
-
-enum gft_profile_ip_version {
-       GFT_PROFILE_IPV4 = 0,
-       GFT_PROFILE_IPV6 = 1,
-       MAX_GFT_PROFILE_IP_VERSION
-};
-
-enum gft_profile_upper_protocol_type {
-       GFT_PROFILE_ROCE_PROTOCOL = 0,
-       GFT_PROFILE_RROCE_PROTOCOL = 1,
-       GFT_PROFILE_FCOE_PROTOCOL = 2,
-       GFT_PROFILE_ICMP_PROTOCOL = 3,
-       GFT_PROFILE_ARP_PROTOCOL = 4,
-       GFT_PROFILE_USER_TCP_SRC_PORT_1_INNER = 5,
-       GFT_PROFILE_USER_TCP_DST_PORT_1_INNER = 6,
-       GFT_PROFILE_TCP_PROTOCOL = 7,
-       GFT_PROFILE_USER_UDP_DST_PORT_1_INNER = 8,
-       GFT_PROFILE_USER_UDP_DST_PORT_2_OUTER = 9,
-       GFT_PROFILE_UDP_PROTOCOL = 10,
-       GFT_PROFILE_USER_IP_1_INNER = 11,
-       GFT_PROFILE_USER_IP_2_OUTER = 12,
-       GFT_PROFILE_USER_ETH_1_INNER = 13,
-       GFT_PROFILE_USER_ETH_2_OUTER = 14,
-       GFT_PROFILE_RAW = 15,
-       MAX_GFT_PROFILE_UPPER_PROTOCOL_TYPE
-};
-
-struct gft_ram_line {
-       __le32 low32bits;
-#define GFT_RAM_LINE_VLAN_SELECT_MASK                  0x3
-#define GFT_RAM_LINE_VLAN_SELECT_SHIFT                 0
-#define GFT_RAM_LINE_TUNNEL_ENTROPHY_MASK              0x1
-#define GFT_RAM_LINE_TUNNEL_ENTROPHY_SHIFT             2
-#define GFT_RAM_LINE_TUNNEL_TTL_EQUAL_ONE_MASK         0x1
-#define GFT_RAM_LINE_TUNNEL_TTL_EQUAL_ONE_SHIFT                3
-#define GFT_RAM_LINE_TUNNEL_TTL_MASK                   0x1
-#define GFT_RAM_LINE_TUNNEL_TTL_SHIFT                  4
-#define GFT_RAM_LINE_TUNNEL_ETHERTYPE_MASK             0x1
-#define GFT_RAM_LINE_TUNNEL_ETHERTYPE_SHIFT            5
-#define GFT_RAM_LINE_TUNNEL_DST_PORT_MASK              0x1
-#define GFT_RAM_LINE_TUNNEL_DST_PORT_SHIFT             6
-#define GFT_RAM_LINE_TUNNEL_SRC_PORT_MASK              0x1
-#define GFT_RAM_LINE_TUNNEL_SRC_PORT_SHIFT             7
-#define GFT_RAM_LINE_TUNNEL_DSCP_MASK                  0x1
-#define GFT_RAM_LINE_TUNNEL_DSCP_SHIFT                 8
-#define GFT_RAM_LINE_TUNNEL_OVER_IP_PROTOCOL_MASK      0x1
-#define GFT_RAM_LINE_TUNNEL_OVER_IP_PROTOCOL_SHIFT     9
-#define GFT_RAM_LINE_TUNNEL_DST_IP_MASK                        0x1
-#define GFT_RAM_LINE_TUNNEL_DST_IP_SHIFT               10
-#define GFT_RAM_LINE_TUNNEL_SRC_IP_MASK                        0x1
-#define GFT_RAM_LINE_TUNNEL_SRC_IP_SHIFT               11
-#define GFT_RAM_LINE_TUNNEL_PRIORITY_MASK              0x1
-#define GFT_RAM_LINE_TUNNEL_PRIORITY_SHIFT             12
-#define GFT_RAM_LINE_TUNNEL_PROVIDER_VLAN_MASK         0x1
-#define GFT_RAM_LINE_TUNNEL_PROVIDER_VLAN_SHIFT                13
-#define GFT_RAM_LINE_TUNNEL_VLAN_MASK                  0x1
-#define GFT_RAM_LINE_TUNNEL_VLAN_SHIFT                 14
-#define GFT_RAM_LINE_TUNNEL_DST_MAC_MASK               0x1
-#define GFT_RAM_LINE_TUNNEL_DST_MAC_SHIFT              15
-#define GFT_RAM_LINE_TUNNEL_SRC_MAC_MASK               0x1
-#define GFT_RAM_LINE_TUNNEL_SRC_MAC_SHIFT              16
-#define GFT_RAM_LINE_TTL_EQUAL_ONE_MASK                        0x1
-#define GFT_RAM_LINE_TTL_EQUAL_ONE_SHIFT               17
-#define GFT_RAM_LINE_TTL_MASK                          0x1
-#define GFT_RAM_LINE_TTL_SHIFT                         18
-#define GFT_RAM_LINE_ETHERTYPE_MASK                    0x1
-#define GFT_RAM_LINE_ETHERTYPE_SHIFT                   19
-#define GFT_RAM_LINE_RESERVED0_MASK                    0x1
-#define GFT_RAM_LINE_RESERVED0_SHIFT                   20
-#define GFT_RAM_LINE_TCP_FLAG_FIN_MASK                 0x1
-#define GFT_RAM_LINE_TCP_FLAG_FIN_SHIFT                        21
-#define GFT_RAM_LINE_TCP_FLAG_SYN_MASK                 0x1
-#define GFT_RAM_LINE_TCP_FLAG_SYN_SHIFT                        22
-#define GFT_RAM_LINE_TCP_FLAG_RST_MASK                 0x1
-#define GFT_RAM_LINE_TCP_FLAG_RST_SHIFT                        23
-#define GFT_RAM_LINE_TCP_FLAG_PSH_MASK                 0x1
-#define GFT_RAM_LINE_TCP_FLAG_PSH_SHIFT                        24
-#define GFT_RAM_LINE_TCP_FLAG_ACK_MASK                 0x1
-#define GFT_RAM_LINE_TCP_FLAG_ACK_SHIFT                        25
-#define GFT_RAM_LINE_TCP_FLAG_URG_MASK                 0x1
-#define GFT_RAM_LINE_TCP_FLAG_URG_SHIFT                        26
-#define GFT_RAM_LINE_TCP_FLAG_ECE_MASK                 0x1
-#define GFT_RAM_LINE_TCP_FLAG_ECE_SHIFT                        27
-#define GFT_RAM_LINE_TCP_FLAG_CWR_MASK                 0x1
-#define GFT_RAM_LINE_TCP_FLAG_CWR_SHIFT                        28
-#define GFT_RAM_LINE_TCP_FLAG_NS_MASK                  0x1
-#define GFT_RAM_LINE_TCP_FLAG_NS_SHIFT                 29
-#define GFT_RAM_LINE_DST_PORT_MASK                     0x1
-#define GFT_RAM_LINE_DST_PORT_SHIFT                    30
-#define GFT_RAM_LINE_SRC_PORT_MASK                     0x1
-#define GFT_RAM_LINE_SRC_PORT_SHIFT                    31
-       __le32 high32bits;
-#define GFT_RAM_LINE_DSCP_MASK                         0x1
-#define GFT_RAM_LINE_DSCP_SHIFT                                0
-#define GFT_RAM_LINE_OVER_IP_PROTOCOL_MASK             0x1
-#define GFT_RAM_LINE_OVER_IP_PROTOCOL_SHIFT            1
-#define GFT_RAM_LINE_DST_IP_MASK                       0x1
-#define GFT_RAM_LINE_DST_IP_SHIFT                      2
-#define GFT_RAM_LINE_SRC_IP_MASK                       0x1
-#define GFT_RAM_LINE_SRC_IP_SHIFT                      3
-#define GFT_RAM_LINE_PRIORITY_MASK                     0x1
-#define GFT_RAM_LINE_PRIORITY_SHIFT                    4
-#define GFT_RAM_LINE_PROVIDER_VLAN_MASK                        0x1
-#define GFT_RAM_LINE_PROVIDER_VLAN_SHIFT               5
-#define GFT_RAM_LINE_VLAN_MASK                         0x1
-#define GFT_RAM_LINE_VLAN_SHIFT                                6
-#define GFT_RAM_LINE_DST_MAC_MASK                      0x1
-#define GFT_RAM_LINE_DST_MAC_SHIFT                     7
-#define GFT_RAM_LINE_SRC_MAC_MASK                      0x1
-#define GFT_RAM_LINE_SRC_MAC_SHIFT                     8
-#define GFT_RAM_LINE_TENANT_ID_MASK                    0x1
-#define GFT_RAM_LINE_TENANT_ID_SHIFT                   9
-#define GFT_RAM_LINE_RESERVED1_MASK                    0x3FFFFF
-#define GFT_RAM_LINE_RESERVED1_SHIFT                   10
-};
-
-struct mstorm_eth_conn_ag_ctx {
-       u8 byte0;
-       u8 byte1;
-       u8 flags0;
-#define MSTORM_ETH_CONN_AG_CTX_EXIST_IN_QM0_MASK       0x1
-#define MSTORM_ETH_CONN_AG_CTX_EXIST_IN_QM0_SHIFT 0
-#define MSTORM_ETH_CONN_AG_CTX_BIT1_MASK       0x1
-#define MSTORM_ETH_CONN_AG_CTX_BIT1_SHIFT         1
-#define MSTORM_ETH_CONN_AG_CTX_CF0_MASK        0x3
-#define MSTORM_ETH_CONN_AG_CTX_CF0_SHIFT          2
-#define MSTORM_ETH_CONN_AG_CTX_CF1_MASK        0x3
-#define MSTORM_ETH_CONN_AG_CTX_CF1_SHIFT          4
-#define MSTORM_ETH_CONN_AG_CTX_CF2_MASK        0x3
-#define MSTORM_ETH_CONN_AG_CTX_CF2_SHIFT          6
-       u8 flags1;
-#define MSTORM_ETH_CONN_AG_CTX_CF0EN_MASK      0x1
-#define MSTORM_ETH_CONN_AG_CTX_CF0EN_SHIFT        0
-#define MSTORM_ETH_CONN_AG_CTX_CF1EN_MASK      0x1
-#define MSTORM_ETH_CONN_AG_CTX_CF1EN_SHIFT        1
-#define MSTORM_ETH_CONN_AG_CTX_CF2EN_MASK      0x1
-#define MSTORM_ETH_CONN_AG_CTX_CF2EN_SHIFT        2
-#define MSTORM_ETH_CONN_AG_CTX_RULE0EN_MASK    0x1
-#define MSTORM_ETH_CONN_AG_CTX_RULE0EN_SHIFT      3
-#define MSTORM_ETH_CONN_AG_CTX_RULE1EN_MASK    0x1
-#define MSTORM_ETH_CONN_AG_CTX_RULE1EN_SHIFT      4
-#define MSTORM_ETH_CONN_AG_CTX_RULE2EN_MASK    0x1
-#define MSTORM_ETH_CONN_AG_CTX_RULE2EN_SHIFT      5
-#define MSTORM_ETH_CONN_AG_CTX_RULE3EN_MASK    0x1
-#define MSTORM_ETH_CONN_AG_CTX_RULE3EN_SHIFT      6
-#define MSTORM_ETH_CONN_AG_CTX_RULE4EN_MASK    0x1
-#define MSTORM_ETH_CONN_AG_CTX_RULE4EN_SHIFT      7
-       __le16 word0;
-       __le16 word1;
-       __le32 reg0;
-       __le32 reg1;
-};
-
 struct xstorm_eth_conn_agctxdq_ext_ldpart {
        u8 reserved0;
        u8 eth_state;
@@ -5511,7 +5651,7 @@ struct xstorm_eth_conn_agctxdq_ext_ldpart {
 #define XSTORMETHCONNAGCTXDQEXTLDPART_TPH_ENABLE_SHIFT             6
        u8 edpm_event_id;
        __le16 physical_q0;
-       __le16 quota;
+       __le16 ereserved1;
        __le16 edpm_num_bds;
        __le16 tx_bd_cons;
        __le16 tx_bd_prod;
@@ -5528,6 +5668,43 @@ struct xstorm_eth_conn_agctxdq_ext_ldpart {
        __le32 reg4;
 };
 
+struct mstorm_eth_conn_ag_ctx {
+       u8 byte0;
+       u8 byte1;
+       u8 flags0;
+#define MSTORM_ETH_CONN_AG_CTX_EXIST_IN_QM0_MASK       0x1
+#define MSTORM_ETH_CONN_AG_CTX_EXIST_IN_QM0_SHIFT 0
+#define MSTORM_ETH_CONN_AG_CTX_BIT1_MASK       0x1
+#define MSTORM_ETH_CONN_AG_CTX_BIT1_SHIFT         1
+#define MSTORM_ETH_CONN_AG_CTX_CF0_MASK        0x3
+#define MSTORM_ETH_CONN_AG_CTX_CF0_SHIFT          2
+#define MSTORM_ETH_CONN_AG_CTX_CF1_MASK        0x3
+#define MSTORM_ETH_CONN_AG_CTX_CF1_SHIFT          4
+#define MSTORM_ETH_CONN_AG_CTX_CF2_MASK        0x3
+#define MSTORM_ETH_CONN_AG_CTX_CF2_SHIFT          6
+       u8 flags1;
+#define MSTORM_ETH_CONN_AG_CTX_CF0EN_MASK      0x1
+#define MSTORM_ETH_CONN_AG_CTX_CF0EN_SHIFT        0
+#define MSTORM_ETH_CONN_AG_CTX_CF1EN_MASK      0x1
+#define MSTORM_ETH_CONN_AG_CTX_CF1EN_SHIFT        1
+#define MSTORM_ETH_CONN_AG_CTX_CF2EN_MASK      0x1
+#define MSTORM_ETH_CONN_AG_CTX_CF2EN_SHIFT        2
+#define MSTORM_ETH_CONN_AG_CTX_RULE0EN_MASK    0x1
+#define MSTORM_ETH_CONN_AG_CTX_RULE0EN_SHIFT      3
+#define MSTORM_ETH_CONN_AG_CTX_RULE1EN_MASK    0x1
+#define MSTORM_ETH_CONN_AG_CTX_RULE1EN_SHIFT      4
+#define MSTORM_ETH_CONN_AG_CTX_RULE2EN_MASK    0x1
+#define MSTORM_ETH_CONN_AG_CTX_RULE2EN_SHIFT      5
+#define MSTORM_ETH_CONN_AG_CTX_RULE3EN_MASK    0x1
+#define MSTORM_ETH_CONN_AG_CTX_RULE3EN_SHIFT      6
+#define MSTORM_ETH_CONN_AG_CTX_RULE4EN_MASK    0x1
+#define MSTORM_ETH_CONN_AG_CTX_RULE4EN_SHIFT      7
+       __le16 word0;
+       __le16 word1;
+       __le32 reg0;
+       __le32 reg1;
+};
+
 struct xstorm_eth_hw_conn_ag_ctx {
        u8 reserved0;
        u8 eth_state;
@@ -5740,7 +5917,7 @@ struct xstorm_eth_hw_conn_ag_ctx {
 #define XSTORM_ETH_HW_CONN_AG_CTX_TPH_ENABLE_SHIFT             6
        u8 edpm_event_id;
        __le16 physical_q0;
-       __le16 quota;
+       __le16 ereserved1;
        __le16 edpm_num_bds;
        __le16 tx_bd_cons;
        __le16 tx_bd_prod;
@@ -5748,32 +5925,226 @@ struct xstorm_eth_hw_conn_ag_ctx {
        __le16 conn_dpi;
 };
 
-struct mstorm_rdma_task_st_ctx {
-       struct regpair temp[4];
-};
-
-struct rdma_close_func_ramrod_data {
-       u8 cnq_start_offset;
-       u8 num_cnqs;
-       u8 vf_id;
-       u8 vf_valid;
-       u8 reserved[4];
-};
-
-struct rdma_cnq_params {
-       __le16 sb_num;
-       u8 sb_index;
-       u8 num_pbl_pages;
-       __le32 reserved;
-       struct regpair pbl_base_addr;
-       __le16 queue_zone_num;
-       u8 reserved1[6];
+struct gft_cam_line {
+       __le32 camline;
+#define GFT_CAM_LINE_VALID_MASK                0x1
+#define GFT_CAM_LINE_VALID_SHIFT       0
+#define GFT_CAM_LINE_DATA_MASK         0x3FFF
+#define GFT_CAM_LINE_DATA_SHIFT                1
+#define GFT_CAM_LINE_MASK_BITS_MASK    0x3FFF
+#define GFT_CAM_LINE_MASK_BITS_SHIFT   15
+#define GFT_CAM_LINE_RESERVED1_MASK    0x7
+#define GFT_CAM_LINE_RESERVED1_SHIFT   29
 };
 
-struct rdma_create_cq_ramrod_data {
-       struct regpair cq_handle;
-       struct regpair pbl_addr;
-       __le32 max_cqes;
+struct gft_cam_line_mapped {
+       __le32 camline;
+#define GFT_CAM_LINE_MAPPED_VALID_MASK                         0x1
+#define GFT_CAM_LINE_MAPPED_VALID_SHIFT                                0
+#define GFT_CAM_LINE_MAPPED_IP_VERSION_MASK                    0x1
+#define GFT_CAM_LINE_MAPPED_IP_VERSION_SHIFT                   1
+#define GFT_CAM_LINE_MAPPED_TUNNEL_IP_VERSION_MASK             0x1
+#define GFT_CAM_LINE_MAPPED_TUNNEL_IP_VERSION_SHIFT            2
+#define GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_MASK           0xF
+#define GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_SHIFT          3
+#define GFT_CAM_LINE_MAPPED_TUNNEL_TYPE_MASK                   0xF
+#define GFT_CAM_LINE_MAPPED_TUNNEL_TYPE_SHIFT                  7
+#define GFT_CAM_LINE_MAPPED_PF_ID_MASK                         0xF
+#define GFT_CAM_LINE_MAPPED_PF_ID_SHIFT                                11
+#define GFT_CAM_LINE_MAPPED_IP_VERSION_MASK_MASK               0x1
+#define GFT_CAM_LINE_MAPPED_IP_VERSION_MASK_SHIFT              15
+#define GFT_CAM_LINE_MAPPED_TUNNEL_IP_VERSION_MASK_MASK                0x1
+#define GFT_CAM_LINE_MAPPED_TUNNEL_IP_VERSION_MASK_SHIFT       16
+#define GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_MASK_MASK      0xF
+#define GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_MASK_SHIFT     17
+#define GFT_CAM_LINE_MAPPED_TUNNEL_TYPE_MASK_MASK              0xF
+#define GFT_CAM_LINE_MAPPED_TUNNEL_TYPE_MASK_SHIFT             21
+#define GFT_CAM_LINE_MAPPED_PF_ID_MASK_MASK                    0xF
+#define GFT_CAM_LINE_MAPPED_PF_ID_MASK_SHIFT                   25
+#define GFT_CAM_LINE_MAPPED_RESERVED1_MASK                     0x7
+#define GFT_CAM_LINE_MAPPED_RESERVED1_SHIFT                    29
+};
+
+union gft_cam_line_union {
+       struct gft_cam_line cam_line;
+       struct gft_cam_line_mapped cam_line_mapped;
+};
+
+enum gft_profile_ip_version {
+       GFT_PROFILE_IPV4 = 0,
+       GFT_PROFILE_IPV6 = 1,
+       MAX_GFT_PROFILE_IP_VERSION
+};
+
+struct gft_profile_key {
+       __le16 profile_key;
+#define GFT_PROFILE_KEY_IP_VERSION_MASK           0x1
+#define GFT_PROFILE_KEY_IP_VERSION_SHIFT          0
+#define GFT_PROFILE_KEY_TUNNEL_IP_VERSION_MASK    0x1
+#define GFT_PROFILE_KEY_TUNNEL_IP_VERSION_SHIFT   1
+#define GFT_PROFILE_KEY_UPPER_PROTOCOL_TYPE_MASK  0xF
+#define GFT_PROFILE_KEY_UPPER_PROTOCOL_TYPE_SHIFT 2
+#define GFT_PROFILE_KEY_TUNNEL_TYPE_MASK          0xF
+#define GFT_PROFILE_KEY_TUNNEL_TYPE_SHIFT         6
+#define GFT_PROFILE_KEY_PF_ID_MASK                0xF
+#define GFT_PROFILE_KEY_PF_ID_SHIFT               10
+#define GFT_PROFILE_KEY_RESERVED0_MASK            0x3
+#define GFT_PROFILE_KEY_RESERVED0_SHIFT           14
+};
+
+enum gft_profile_tunnel_type {
+       GFT_PROFILE_NO_TUNNEL = 0,
+       GFT_PROFILE_VXLAN_TUNNEL = 1,
+       GFT_PROFILE_GRE_MAC_OR_NVGRE_TUNNEL = 2,
+       GFT_PROFILE_GRE_IP_TUNNEL = 3,
+       GFT_PROFILE_GENEVE_MAC_TUNNEL = 4,
+       GFT_PROFILE_GENEVE_IP_TUNNEL = 5,
+       MAX_GFT_PROFILE_TUNNEL_TYPE
+};
+
+enum gft_profile_upper_protocol_type {
+       GFT_PROFILE_ROCE_PROTOCOL = 0,
+       GFT_PROFILE_RROCE_PROTOCOL = 1,
+       GFT_PROFILE_FCOE_PROTOCOL = 2,
+       GFT_PROFILE_ICMP_PROTOCOL = 3,
+       GFT_PROFILE_ARP_PROTOCOL = 4,
+       GFT_PROFILE_USER_TCP_SRC_PORT_1_INNER = 5,
+       GFT_PROFILE_USER_TCP_DST_PORT_1_INNER = 6,
+       GFT_PROFILE_TCP_PROTOCOL = 7,
+       GFT_PROFILE_USER_UDP_DST_PORT_1_INNER = 8,
+       GFT_PROFILE_USER_UDP_DST_PORT_2_OUTER = 9,
+       GFT_PROFILE_UDP_PROTOCOL = 10,
+       GFT_PROFILE_USER_IP_1_INNER = 11,
+       GFT_PROFILE_USER_IP_2_OUTER = 12,
+       GFT_PROFILE_USER_ETH_1_INNER = 13,
+       GFT_PROFILE_USER_ETH_2_OUTER = 14,
+       GFT_PROFILE_RAW = 15,
+       MAX_GFT_PROFILE_UPPER_PROTOCOL_TYPE
+};
+
+struct gft_ram_line {
+       __le32 lo;
+#define GFT_RAM_LINE_VLAN_SELECT_MASK                  0x3
+#define GFT_RAM_LINE_VLAN_SELECT_SHIFT                 0
+#define GFT_RAM_LINE_TUNNEL_ENTROPHY_MASK              0x1
+#define GFT_RAM_LINE_TUNNEL_ENTROPHY_SHIFT             2
+#define GFT_RAM_LINE_TUNNEL_TTL_EQUAL_ONE_MASK         0x1
+#define GFT_RAM_LINE_TUNNEL_TTL_EQUAL_ONE_SHIFT                3
+#define GFT_RAM_LINE_TUNNEL_TTL_MASK                   0x1
+#define GFT_RAM_LINE_TUNNEL_TTL_SHIFT                  4
+#define GFT_RAM_LINE_TUNNEL_ETHERTYPE_MASK             0x1
+#define GFT_RAM_LINE_TUNNEL_ETHERTYPE_SHIFT            5
+#define GFT_RAM_LINE_TUNNEL_DST_PORT_MASK              0x1
+#define GFT_RAM_LINE_TUNNEL_DST_PORT_SHIFT             6
+#define GFT_RAM_LINE_TUNNEL_SRC_PORT_MASK              0x1
+#define GFT_RAM_LINE_TUNNEL_SRC_PORT_SHIFT             7
+#define GFT_RAM_LINE_TUNNEL_DSCP_MASK                  0x1
+#define GFT_RAM_LINE_TUNNEL_DSCP_SHIFT                 8
+#define GFT_RAM_LINE_TUNNEL_OVER_IP_PROTOCOL_MASK      0x1
+#define GFT_RAM_LINE_TUNNEL_OVER_IP_PROTOCOL_SHIFT     9
+#define GFT_RAM_LINE_TUNNEL_DST_IP_MASK                        0x1
+#define GFT_RAM_LINE_TUNNEL_DST_IP_SHIFT               10
+#define GFT_RAM_LINE_TUNNEL_SRC_IP_MASK                        0x1
+#define GFT_RAM_LINE_TUNNEL_SRC_IP_SHIFT               11
+#define GFT_RAM_LINE_TUNNEL_PRIORITY_MASK              0x1
+#define GFT_RAM_LINE_TUNNEL_PRIORITY_SHIFT             12
+#define GFT_RAM_LINE_TUNNEL_PROVIDER_VLAN_MASK         0x1
+#define GFT_RAM_LINE_TUNNEL_PROVIDER_VLAN_SHIFT                13
+#define GFT_RAM_LINE_TUNNEL_VLAN_MASK                  0x1
+#define GFT_RAM_LINE_TUNNEL_VLAN_SHIFT                 14
+#define GFT_RAM_LINE_TUNNEL_DST_MAC_MASK               0x1
+#define GFT_RAM_LINE_TUNNEL_DST_MAC_SHIFT              15
+#define GFT_RAM_LINE_TUNNEL_SRC_MAC_MASK               0x1
+#define GFT_RAM_LINE_TUNNEL_SRC_MAC_SHIFT              16
+#define GFT_RAM_LINE_TTL_EQUAL_ONE_MASK                        0x1
+#define GFT_RAM_LINE_TTL_EQUAL_ONE_SHIFT               17
+#define GFT_RAM_LINE_TTL_MASK                          0x1
+#define GFT_RAM_LINE_TTL_SHIFT                         18
+#define GFT_RAM_LINE_ETHERTYPE_MASK                    0x1
+#define GFT_RAM_LINE_ETHERTYPE_SHIFT                   19
+#define GFT_RAM_LINE_RESERVED0_MASK                    0x1
+#define GFT_RAM_LINE_RESERVED0_SHIFT                   20
+#define GFT_RAM_LINE_TCP_FLAG_FIN_MASK                 0x1
+#define GFT_RAM_LINE_TCP_FLAG_FIN_SHIFT                        21
+#define GFT_RAM_LINE_TCP_FLAG_SYN_MASK                 0x1
+#define GFT_RAM_LINE_TCP_FLAG_SYN_SHIFT                        22
+#define GFT_RAM_LINE_TCP_FLAG_RST_MASK                 0x1
+#define GFT_RAM_LINE_TCP_FLAG_RST_SHIFT                        23
+#define GFT_RAM_LINE_TCP_FLAG_PSH_MASK                 0x1
+#define GFT_RAM_LINE_TCP_FLAG_PSH_SHIFT                        24
+#define GFT_RAM_LINE_TCP_FLAG_ACK_MASK                 0x1
+#define GFT_RAM_LINE_TCP_FLAG_ACK_SHIFT                        25
+#define GFT_RAM_LINE_TCP_FLAG_URG_MASK                 0x1
+#define GFT_RAM_LINE_TCP_FLAG_URG_SHIFT                        26
+#define GFT_RAM_LINE_TCP_FLAG_ECE_MASK                 0x1
+#define GFT_RAM_LINE_TCP_FLAG_ECE_SHIFT                        27
+#define GFT_RAM_LINE_TCP_FLAG_CWR_MASK                 0x1
+#define GFT_RAM_LINE_TCP_FLAG_CWR_SHIFT                        28
+#define GFT_RAM_LINE_TCP_FLAG_NS_MASK                  0x1
+#define GFT_RAM_LINE_TCP_FLAG_NS_SHIFT                 29
+#define GFT_RAM_LINE_DST_PORT_MASK                     0x1
+#define GFT_RAM_LINE_DST_PORT_SHIFT                    30
+#define GFT_RAM_LINE_SRC_PORT_MASK                     0x1
+#define GFT_RAM_LINE_SRC_PORT_SHIFT                    31
+       __le32 hi;
+#define GFT_RAM_LINE_DSCP_MASK                         0x1
+#define GFT_RAM_LINE_DSCP_SHIFT                                0
+#define GFT_RAM_LINE_OVER_IP_PROTOCOL_MASK             0x1
+#define GFT_RAM_LINE_OVER_IP_PROTOCOL_SHIFT            1
+#define GFT_RAM_LINE_DST_IP_MASK                       0x1
+#define GFT_RAM_LINE_DST_IP_SHIFT                      2
+#define GFT_RAM_LINE_SRC_IP_MASK                       0x1
+#define GFT_RAM_LINE_SRC_IP_SHIFT                      3
+#define GFT_RAM_LINE_PRIORITY_MASK                     0x1
+#define GFT_RAM_LINE_PRIORITY_SHIFT                    4
+#define GFT_RAM_LINE_PROVIDER_VLAN_MASK                        0x1
+#define GFT_RAM_LINE_PROVIDER_VLAN_SHIFT               5
+#define GFT_RAM_LINE_VLAN_MASK                         0x1
+#define GFT_RAM_LINE_VLAN_SHIFT                                6
+#define GFT_RAM_LINE_DST_MAC_MASK                      0x1
+#define GFT_RAM_LINE_DST_MAC_SHIFT                     7
+#define GFT_RAM_LINE_SRC_MAC_MASK                      0x1
+#define GFT_RAM_LINE_SRC_MAC_SHIFT                     8
+#define GFT_RAM_LINE_TENANT_ID_MASK                    0x1
+#define GFT_RAM_LINE_TENANT_ID_SHIFT                   9
+#define GFT_RAM_LINE_RESERVED1_MASK                    0x3FFFFF
+#define GFT_RAM_LINE_RESERVED1_SHIFT                   10
+};
+
+enum gft_vlan_select {
+       INNER_PROVIDER_VLAN = 0,
+       INNER_VLAN = 1,
+       OUTER_PROVIDER_VLAN = 2,
+       OUTER_VLAN = 3,
+       MAX_GFT_VLAN_SELECT
+};
+
+struct mstorm_rdma_task_st_ctx {
+       struct regpair temp[4];
+};
+
+struct rdma_close_func_ramrod_data {
+       u8 cnq_start_offset;
+       u8 num_cnqs;
+       u8 vf_id;
+       u8 vf_valid;
+       u8 reserved[4];
+};
+
+struct rdma_cnq_params {
+       __le16 sb_num;
+       u8 sb_index;
+       u8 num_pbl_pages;
+       __le32 reserved;
+       struct regpair pbl_base_addr;
+       __le16 queue_zone_num;
+       u8 reserved1[6];
+};
+
+struct rdma_create_cq_ramrod_data {
+       struct regpair cq_handle;
+       struct regpair pbl_addr;
+       __le32 max_cqes;
        __le16 pbl_num_pages;
        __le16 dpi;
        u8 is_two_level_pbl;
@@ -5827,12 +6198,9 @@ struct rdma_init_func_hdr {
        u8 cnq_start_offset;
        u8 num_cnqs;
        u8 cq_ring_mode;
-       u8 cnp_vlan_priority;
-       __le32 cnp_send_timeout;
-       u8 cnp_dscp;
        u8 vf_id;
        u8 vf_valid;
-       u8 reserved[5];
+       u8 reserved[3];
 };
 
 struct rdma_init_func_ramrod_data {
@@ -5856,54 +6224,55 @@ enum rdma_ramrod_cmd_id {
 };
 
 struct rdma_register_tid_ramrod_data {
-       __le32 flags;
-#define RDMA_REGISTER_TID_RAMROD_DATA_MAX_ID_MASK             0x3FFFF
-#define RDMA_REGISTER_TID_RAMROD_DATA_MAX_ID_SHIFT            0
-#define RDMA_REGISTER_TID_RAMROD_DATA_PAGE_SIZE_LOG_MASK      0x1F
-#define RDMA_REGISTER_TID_RAMROD_DATA_PAGE_SIZE_LOG_SHIFT     18
-#define RDMA_REGISTER_TID_RAMROD_DATA_TWO_LEVEL_PBL_MASK      0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_TWO_LEVEL_PBL_SHIFT     23
-#define RDMA_REGISTER_TID_RAMROD_DATA_ZERO_BASED_MASK         0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_ZERO_BASED_SHIFT        24
-#define RDMA_REGISTER_TID_RAMROD_DATA_PHY_MR_MASK             0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_PHY_MR_SHIFT            25
-#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_READ_MASK        0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_READ_SHIFT       26
-#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_WRITE_MASK       0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_WRITE_SHIFT      27
-#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_ATOMIC_MASK      0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_ATOMIC_SHIFT     28
-#define RDMA_REGISTER_TID_RAMROD_DATA_LOCAL_WRITE_MASK        0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_LOCAL_WRITE_SHIFT       29
-#define RDMA_REGISTER_TID_RAMROD_DATA_LOCAL_READ_MASK         0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_LOCAL_READ_SHIFT        30
-#define RDMA_REGISTER_TID_RAMROD_DATA_ENABLE_MW_BIND_MASK     0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_ENABLE_MW_BIND_SHIFT    31
+       __le16 flags;
+#define RDMA_REGISTER_TID_RAMROD_DATA_PAGE_SIZE_LOG_MASK       0x1F
+#define RDMA_REGISTER_TID_RAMROD_DATA_PAGE_SIZE_LOG_SHIFT      0
+#define RDMA_REGISTER_TID_RAMROD_DATA_TWO_LEVEL_PBL_MASK       0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_TWO_LEVEL_PBL_SHIFT      5
+#define RDMA_REGISTER_TID_RAMROD_DATA_ZERO_BASED_MASK  0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_ZERO_BASED_SHIFT 6
+#define RDMA_REGISTER_TID_RAMROD_DATA_PHY_MR_MASK      0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_PHY_MR_SHIFT     7
+#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_READ_MASK 0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_READ_SHIFT        8
+#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_WRITE_MASK        0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_WRITE_SHIFT       9
+#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_ATOMIC_MASK       0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_ATOMIC_SHIFT      10
+#define RDMA_REGISTER_TID_RAMROD_DATA_LOCAL_WRITE_MASK 0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_LOCAL_WRITE_SHIFT        11
+#define RDMA_REGISTER_TID_RAMROD_DATA_LOCAL_READ_MASK  0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_LOCAL_READ_SHIFT 12
+#define RDMA_REGISTER_TID_RAMROD_DATA_ENABLE_MW_BIND_MASK      0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_ENABLE_MW_BIND_SHIFT     13
+#define RDMA_REGISTER_TID_RAMROD_DATA_RESERVED_MASK    0x3
+#define RDMA_REGISTER_TID_RAMROD_DATA_RESERVED_SHIFT   14
        u8 flags1;
-#define RDMA_REGISTER_TID_RAMROD_DATA_PBL_PAGE_SIZE_LOG_MASK  0x1F
+#define RDMA_REGISTER_TID_RAMROD_DATA_PBL_PAGE_SIZE_LOG_MASK   0x1F
 #define RDMA_REGISTER_TID_RAMROD_DATA_PBL_PAGE_SIZE_LOG_SHIFT 0
-#define RDMA_REGISTER_TID_RAMROD_DATA_TID_TYPE_MASK           0x7
-#define RDMA_REGISTER_TID_RAMROD_DATA_TID_TYPE_SHIFT          5
+#define RDMA_REGISTER_TID_RAMROD_DATA_TID_TYPE_MASK    0x7
+#define RDMA_REGISTER_TID_RAMROD_DATA_TID_TYPE_SHIFT   5
        u8 flags2;
-#define RDMA_REGISTER_TID_RAMROD_DATA_DMA_MR_MASK             0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_DMA_MR_SHIFT            0
-#define RDMA_REGISTER_TID_RAMROD_DATA_DIF_ON_HOST_FLG_MASK    0x1
-#define RDMA_REGISTER_TID_RAMROD_DATA_DIF_ON_HOST_FLG_SHIFT   1
-#define RDMA_REGISTER_TID_RAMROD_DATA_RESERVED1_MASK          0x3F
-#define RDMA_REGISTER_TID_RAMROD_DATA_RESERVED1_SHIFT         2
+#define RDMA_REGISTER_TID_RAMROD_DATA_DMA_MR_MASK      0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_DMA_MR_SHIFT     0
+#define RDMA_REGISTER_TID_RAMROD_DATA_DIF_ON_HOST_FLG_MASK     0x1
+#define RDMA_REGISTER_TID_RAMROD_DATA_DIF_ON_HOST_FLG_SHIFT    1
+#define RDMA_REGISTER_TID_RAMROD_DATA_RESERVED1_MASK   0x3F
+#define RDMA_REGISTER_TID_RAMROD_DATA_RESERVED1_SHIFT  2
        u8 key;
        u8 length_hi;
        u8 vf_id;
        u8 vf_valid;
        __le16 pd;
+       __le16 reserved2;
        __le32 length_lo;
        __le32 itid;
-       __le32 reserved2;
+       __le32 reserved3;
        struct regpair va;
        struct regpair pbl_base;
        struct regpair dif_error_addr;
        struct regpair dif_runt_addr;
-       __le32 reserved3[2];
+       __le32 reserved4[2];
 };
 
 struct rdma_resize_cq_output_params {
@@ -6149,298 +6518,9 @@ enum rdma_tid_type {
        MAX_RDMA_TID_TYPE
 };
 
-struct mstorm_rdma_conn_ag_ctx {
-       u8 byte0;
-       u8 byte1;
-       u8 flags0;
-#define MSTORM_RDMA_CONN_AG_CTX_BIT0_MASK     0x1
-#define MSTORM_RDMA_CONN_AG_CTX_BIT0_SHIFT    0
-#define MSTORM_RDMA_CONN_AG_CTX_BIT1_MASK     0x1
-#define MSTORM_RDMA_CONN_AG_CTX_BIT1_SHIFT    1
-#define MSTORM_RDMA_CONN_AG_CTX_CF0_MASK      0x3
-#define MSTORM_RDMA_CONN_AG_CTX_CF0_SHIFT     2
-#define MSTORM_RDMA_CONN_AG_CTX_CF1_MASK      0x3
-#define MSTORM_RDMA_CONN_AG_CTX_CF1_SHIFT     4
-#define MSTORM_RDMA_CONN_AG_CTX_CF2_MASK      0x3
-#define MSTORM_RDMA_CONN_AG_CTX_CF2_SHIFT     6
-       u8 flags1;
-#define MSTORM_RDMA_CONN_AG_CTX_CF0EN_MASK    0x1
-#define MSTORM_RDMA_CONN_AG_CTX_CF0EN_SHIFT   0
-#define MSTORM_RDMA_CONN_AG_CTX_CF1EN_MASK    0x1
-#define MSTORM_RDMA_CONN_AG_CTX_CF1EN_SHIFT   1
-#define MSTORM_RDMA_CONN_AG_CTX_CF2EN_MASK    0x1
-#define MSTORM_RDMA_CONN_AG_CTX_CF2EN_SHIFT   2
-#define MSTORM_RDMA_CONN_AG_CTX_RULE0EN_MASK  0x1
-#define MSTORM_RDMA_CONN_AG_CTX_RULE0EN_SHIFT 3
-#define MSTORM_RDMA_CONN_AG_CTX_RULE1EN_MASK  0x1
-#define MSTORM_RDMA_CONN_AG_CTX_RULE1EN_SHIFT 4
-#define MSTORM_RDMA_CONN_AG_CTX_RULE2EN_MASK  0x1
-#define MSTORM_RDMA_CONN_AG_CTX_RULE2EN_SHIFT 5
-#define MSTORM_RDMA_CONN_AG_CTX_RULE3EN_MASK  0x1
-#define MSTORM_RDMA_CONN_AG_CTX_RULE3EN_SHIFT 6
-#define MSTORM_RDMA_CONN_AG_CTX_RULE4EN_MASK  0x1
-#define MSTORM_RDMA_CONN_AG_CTX_RULE4EN_SHIFT 7
-       __le16 word0;
-       __le16 word1;
-       __le32 reg0;
-       __le32 reg1;
-};
-
-struct tstorm_rdma_conn_ag_ctx {
+struct xstorm_roce_conn_ag_ctx_dq_ext_ld_part {
        u8 reserved0;
-       u8 byte1;
-       u8 flags0;
-#define TSTORM_RDMA_CONN_AG_CTX_EXIST_IN_QM0_MASK          0x1
-#define TSTORM_RDMA_CONN_AG_CTX_EXIST_IN_QM0_SHIFT         0
-#define TSTORM_RDMA_CONN_AG_CTX_BIT1_MASK                  0x1
-#define TSTORM_RDMA_CONN_AG_CTX_BIT1_SHIFT                 1
-#define TSTORM_RDMA_CONN_AG_CTX_BIT2_MASK                  0x1
-#define TSTORM_RDMA_CONN_AG_CTX_BIT2_SHIFT                 2
-#define TSTORM_RDMA_CONN_AG_CTX_BIT3_MASK                  0x1
-#define TSTORM_RDMA_CONN_AG_CTX_BIT3_SHIFT                 3
-#define TSTORM_RDMA_CONN_AG_CTX_BIT4_MASK                  0x1
-#define TSTORM_RDMA_CONN_AG_CTX_BIT4_SHIFT                 4
-#define TSTORM_RDMA_CONN_AG_CTX_BIT5_MASK                  0x1
-#define TSTORM_RDMA_CONN_AG_CTX_BIT5_SHIFT                 5
-#define TSTORM_RDMA_CONN_AG_CTX_CF0_MASK                   0x3
-#define TSTORM_RDMA_CONN_AG_CTX_CF0_SHIFT                  6
-       u8 flags1;
-#define TSTORM_RDMA_CONN_AG_CTX_CF1_MASK                   0x3
-#define TSTORM_RDMA_CONN_AG_CTX_CF1_SHIFT                  0
-#define TSTORM_RDMA_CONN_AG_CTX_CF2_MASK                   0x3
-#define TSTORM_RDMA_CONN_AG_CTX_CF2_SHIFT                  2
-#define TSTORM_RDMA_CONN_AG_CTX_TIMER_STOP_ALL_CF_MASK     0x3
-#define TSTORM_RDMA_CONN_AG_CTX_TIMER_STOP_ALL_CF_SHIFT    4
-#define TSTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_MASK           0x3
-#define TSTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_SHIFT          6
-       u8 flags2;
-#define TSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_CF_MASK       0x3
-#define TSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_CF_SHIFT      0
-#define TSTORM_RDMA_CONN_AG_CTX_CF6_MASK                   0x3
-#define TSTORM_RDMA_CONN_AG_CTX_CF6_SHIFT                  2
-#define TSTORM_RDMA_CONN_AG_CTX_CF7_MASK                   0x3
-#define TSTORM_RDMA_CONN_AG_CTX_CF7_SHIFT                  4
-#define TSTORM_RDMA_CONN_AG_CTX_CF8_MASK                   0x3
-#define TSTORM_RDMA_CONN_AG_CTX_CF8_SHIFT                  6
-       u8 flags3;
-#define TSTORM_RDMA_CONN_AG_CTX_CF9_MASK                   0x3
-#define TSTORM_RDMA_CONN_AG_CTX_CF9_SHIFT                  0
-#define TSTORM_RDMA_CONN_AG_CTX_CF10_MASK                  0x3
-#define TSTORM_RDMA_CONN_AG_CTX_CF10_SHIFT                 2
-#define TSTORM_RDMA_CONN_AG_CTX_CF0EN_MASK                 0x1
-#define TSTORM_RDMA_CONN_AG_CTX_CF0EN_SHIFT                4
-#define TSTORM_RDMA_CONN_AG_CTX_CF1EN_MASK                 0x1
-#define TSTORM_RDMA_CONN_AG_CTX_CF1EN_SHIFT                5
-#define TSTORM_RDMA_CONN_AG_CTX_CF2EN_MASK                 0x1
-#define TSTORM_RDMA_CONN_AG_CTX_CF2EN_SHIFT                6
-#define TSTORM_RDMA_CONN_AG_CTX_TIMER_STOP_ALL_CF_EN_MASK  0x1
-#define TSTORM_RDMA_CONN_AG_CTX_TIMER_STOP_ALL_CF_EN_SHIFT 7
-       u8 flags4;
-#define TSTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_EN_MASK        0x1
-#define TSTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_EN_SHIFT       0
-#define TSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_CF_EN_MASK    0x1
-#define TSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_CF_EN_SHIFT   1
-#define TSTORM_RDMA_CONN_AG_CTX_CF6EN_MASK                 0x1
-#define TSTORM_RDMA_CONN_AG_CTX_CF6EN_SHIFT                2
-#define TSTORM_RDMA_CONN_AG_CTX_CF7EN_MASK                 0x1
-#define TSTORM_RDMA_CONN_AG_CTX_CF7EN_SHIFT                3
-#define TSTORM_RDMA_CONN_AG_CTX_CF8EN_MASK                 0x1
-#define TSTORM_RDMA_CONN_AG_CTX_CF8EN_SHIFT                4
-#define TSTORM_RDMA_CONN_AG_CTX_CF9EN_MASK                 0x1
-#define TSTORM_RDMA_CONN_AG_CTX_CF9EN_SHIFT                5
-#define TSTORM_RDMA_CONN_AG_CTX_CF10EN_MASK                0x1
-#define TSTORM_RDMA_CONN_AG_CTX_CF10EN_SHIFT               6
-#define TSTORM_RDMA_CONN_AG_CTX_RULE0EN_MASK               0x1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE0EN_SHIFT              7
-       u8 flags5;
-#define TSTORM_RDMA_CONN_AG_CTX_RULE1EN_MASK               0x1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE1EN_SHIFT              0
-#define TSTORM_RDMA_CONN_AG_CTX_RULE2EN_MASK               0x1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE2EN_SHIFT              1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE3EN_MASK               0x1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE3EN_SHIFT              2
-#define TSTORM_RDMA_CONN_AG_CTX_RULE4EN_MASK               0x1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE4EN_SHIFT              3
-#define TSTORM_RDMA_CONN_AG_CTX_RULE5EN_MASK               0x1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE5EN_SHIFT              4
-#define TSTORM_RDMA_CONN_AG_CTX_RULE6EN_MASK               0x1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE6EN_SHIFT              5
-#define TSTORM_RDMA_CONN_AG_CTX_RULE7EN_MASK               0x1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE7EN_SHIFT              6
-#define TSTORM_RDMA_CONN_AG_CTX_RULE8EN_MASK               0x1
-#define TSTORM_RDMA_CONN_AG_CTX_RULE8EN_SHIFT              7
-       __le32 reg0;
-       __le32 reg1;
-       __le32 reg2;
-       __le32 reg3;
-       __le32 reg4;
-       __le32 reg5;
-       __le32 reg6;
-       __le32 reg7;
-       __le32 reg8;
-       u8 byte2;
-       u8 byte3;
-       __le16 word0;
-       u8 byte4;
-       u8 byte5;
-       __le16 word1;
-       __le16 word2;
-       __le16 word3;
-       __le32 reg9;
-       __le32 reg10;
-};
-
-struct tstorm_rdma_task_ag_ctx {
-       u8 byte0;
-       u8 byte1;
-       __le16 word0;
-       u8 flags0;
-#define TSTORM_RDMA_TASK_AG_CTX_NIBBLE0_MASK  0xF
-#define TSTORM_RDMA_TASK_AG_CTX_NIBBLE0_SHIFT 0
-#define TSTORM_RDMA_TASK_AG_CTX_BIT0_MASK     0x1
-#define TSTORM_RDMA_TASK_AG_CTX_BIT0_SHIFT    4
-#define TSTORM_RDMA_TASK_AG_CTX_BIT1_MASK     0x1
-#define TSTORM_RDMA_TASK_AG_CTX_BIT1_SHIFT    5
-#define TSTORM_RDMA_TASK_AG_CTX_BIT2_MASK     0x1
-#define TSTORM_RDMA_TASK_AG_CTX_BIT2_SHIFT    6
-#define TSTORM_RDMA_TASK_AG_CTX_BIT3_MASK     0x1
-#define TSTORM_RDMA_TASK_AG_CTX_BIT3_SHIFT    7
-       u8 flags1;
-#define TSTORM_RDMA_TASK_AG_CTX_BIT4_MASK     0x1
-#define TSTORM_RDMA_TASK_AG_CTX_BIT4_SHIFT    0
-#define TSTORM_RDMA_TASK_AG_CTX_BIT5_MASK     0x1
-#define TSTORM_RDMA_TASK_AG_CTX_BIT5_SHIFT    1
-#define TSTORM_RDMA_TASK_AG_CTX_CF0_MASK      0x3
-#define TSTORM_RDMA_TASK_AG_CTX_CF0_SHIFT     2
-#define TSTORM_RDMA_TASK_AG_CTX_CF1_MASK      0x3
-#define TSTORM_RDMA_TASK_AG_CTX_CF1_SHIFT     4
-#define TSTORM_RDMA_TASK_AG_CTX_CF2_MASK      0x3
-#define TSTORM_RDMA_TASK_AG_CTX_CF2_SHIFT     6
-       u8 flags2;
-#define TSTORM_RDMA_TASK_AG_CTX_CF3_MASK      0x3
-#define TSTORM_RDMA_TASK_AG_CTX_CF3_SHIFT     0
-#define TSTORM_RDMA_TASK_AG_CTX_CF4_MASK      0x3
-#define TSTORM_RDMA_TASK_AG_CTX_CF4_SHIFT     2
-#define TSTORM_RDMA_TASK_AG_CTX_CF5_MASK      0x3
-#define TSTORM_RDMA_TASK_AG_CTX_CF5_SHIFT     4
-#define TSTORM_RDMA_TASK_AG_CTX_CF6_MASK      0x3
-#define TSTORM_RDMA_TASK_AG_CTX_CF6_SHIFT     6
-       u8 flags3;
-#define TSTORM_RDMA_TASK_AG_CTX_CF7_MASK      0x3
-#define TSTORM_RDMA_TASK_AG_CTX_CF7_SHIFT     0
-#define TSTORM_RDMA_TASK_AG_CTX_CF0EN_MASK    0x1
-#define TSTORM_RDMA_TASK_AG_CTX_CF0EN_SHIFT   2
-#define TSTORM_RDMA_TASK_AG_CTX_CF1EN_MASK    0x1
-#define TSTORM_RDMA_TASK_AG_CTX_CF1EN_SHIFT   3
-#define TSTORM_RDMA_TASK_AG_CTX_CF2EN_MASK    0x1
-#define TSTORM_RDMA_TASK_AG_CTX_CF2EN_SHIFT   4
-#define TSTORM_RDMA_TASK_AG_CTX_CF3EN_MASK    0x1
-#define TSTORM_RDMA_TASK_AG_CTX_CF3EN_SHIFT   5
-#define TSTORM_RDMA_TASK_AG_CTX_CF4EN_MASK    0x1
-#define TSTORM_RDMA_TASK_AG_CTX_CF4EN_SHIFT   6
-#define TSTORM_RDMA_TASK_AG_CTX_CF5EN_MASK    0x1
-#define TSTORM_RDMA_TASK_AG_CTX_CF5EN_SHIFT   7
-       u8 flags4;
-#define TSTORM_RDMA_TASK_AG_CTX_CF6EN_MASK    0x1
-#define TSTORM_RDMA_TASK_AG_CTX_CF6EN_SHIFT   0
-#define TSTORM_RDMA_TASK_AG_CTX_CF7EN_MASK    0x1
-#define TSTORM_RDMA_TASK_AG_CTX_CF7EN_SHIFT   1
-#define TSTORM_RDMA_TASK_AG_CTX_RULE0EN_MASK  0x1
-#define TSTORM_RDMA_TASK_AG_CTX_RULE0EN_SHIFT 2
-#define TSTORM_RDMA_TASK_AG_CTX_RULE1EN_MASK  0x1
-#define TSTORM_RDMA_TASK_AG_CTX_RULE1EN_SHIFT 3
-#define TSTORM_RDMA_TASK_AG_CTX_RULE2EN_MASK  0x1
-#define TSTORM_RDMA_TASK_AG_CTX_RULE2EN_SHIFT 4
-#define TSTORM_RDMA_TASK_AG_CTX_RULE3EN_MASK  0x1
-#define TSTORM_RDMA_TASK_AG_CTX_RULE3EN_SHIFT 5
-#define TSTORM_RDMA_TASK_AG_CTX_RULE4EN_MASK  0x1
-#define TSTORM_RDMA_TASK_AG_CTX_RULE4EN_SHIFT 6
-#define TSTORM_RDMA_TASK_AG_CTX_RULE5EN_MASK  0x1
-#define TSTORM_RDMA_TASK_AG_CTX_RULE5EN_SHIFT 7
-       u8 byte2;
-       __le16 word1;
-       __le32 reg0;
-       u8 byte3;
-       u8 byte4;
-       __le16 word2;
-       __le16 word3;
-       __le16 word4;
-       __le32 reg1;
-       __le32 reg2;
-};
-
-struct ustorm_rdma_conn_ag_ctx {
-       u8 reserved;
-       u8 byte1;
-       u8 flags0;
-#define USTORM_RDMA_CONN_AG_CTX_EXIST_IN_QM0_MASK     0x1
-#define USTORM_RDMA_CONN_AG_CTX_EXIST_IN_QM0_SHIFT    0
-#define USTORM_RDMA_CONN_AG_CTX_BIT1_MASK             0x1
-#define USTORM_RDMA_CONN_AG_CTX_BIT1_SHIFT            1
-#define USTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_MASK      0x3
-#define USTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_SHIFT     2
-#define USTORM_RDMA_CONN_AG_CTX_CF1_MASK              0x3
-#define USTORM_RDMA_CONN_AG_CTX_CF1_SHIFT             4
-#define USTORM_RDMA_CONN_AG_CTX_CF2_MASK              0x3
-#define USTORM_RDMA_CONN_AG_CTX_CF2_SHIFT             6
-       u8 flags1;
-#define USTORM_RDMA_CONN_AG_CTX_CF3_MASK              0x3
-#define USTORM_RDMA_CONN_AG_CTX_CF3_SHIFT             0
-#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_SE_CF_MASK     0x3
-#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_SE_CF_SHIFT    2
-#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_CF_MASK        0x3
-#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_CF_SHIFT       4
-#define USTORM_RDMA_CONN_AG_CTX_CF6_MASK              0x3
-#define USTORM_RDMA_CONN_AG_CTX_CF6_SHIFT             6
-       u8 flags2;
-#define USTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_EN_MASK   0x1
-#define USTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_EN_SHIFT  0
-#define USTORM_RDMA_CONN_AG_CTX_CF1EN_MASK            0x1
-#define USTORM_RDMA_CONN_AG_CTX_CF1EN_SHIFT           1
-#define USTORM_RDMA_CONN_AG_CTX_CF2EN_MASK            0x1
-#define USTORM_RDMA_CONN_AG_CTX_CF2EN_SHIFT           2
-#define USTORM_RDMA_CONN_AG_CTX_CF3EN_MASK            0x1
-#define USTORM_RDMA_CONN_AG_CTX_CF3EN_SHIFT           3
-#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_SE_CF_EN_MASK  0x1
-#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_SE_CF_EN_SHIFT 4
-#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_CF_EN_MASK     0x1
-#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_CF_EN_SHIFT    5
-#define USTORM_RDMA_CONN_AG_CTX_CF6EN_MASK            0x1
-#define USTORM_RDMA_CONN_AG_CTX_CF6EN_SHIFT           6
-#define USTORM_RDMA_CONN_AG_CTX_CQ_SE_EN_MASK         0x1
-#define USTORM_RDMA_CONN_AG_CTX_CQ_SE_EN_SHIFT        7
-       u8 flags3;
-#define USTORM_RDMA_CONN_AG_CTX_CQ_EN_MASK            0x1
-#define USTORM_RDMA_CONN_AG_CTX_CQ_EN_SHIFT           0
-#define USTORM_RDMA_CONN_AG_CTX_RULE2EN_MASK          0x1
-#define USTORM_RDMA_CONN_AG_CTX_RULE2EN_SHIFT         1
-#define USTORM_RDMA_CONN_AG_CTX_RULE3EN_MASK          0x1
-#define USTORM_RDMA_CONN_AG_CTX_RULE3EN_SHIFT         2
-#define USTORM_RDMA_CONN_AG_CTX_RULE4EN_MASK          0x1
-#define USTORM_RDMA_CONN_AG_CTX_RULE4EN_SHIFT         3
-#define USTORM_RDMA_CONN_AG_CTX_RULE5EN_MASK          0x1
-#define USTORM_RDMA_CONN_AG_CTX_RULE5EN_SHIFT         4
-#define USTORM_RDMA_CONN_AG_CTX_RULE6EN_MASK          0x1
-#define USTORM_RDMA_CONN_AG_CTX_RULE6EN_SHIFT         5
-#define USTORM_RDMA_CONN_AG_CTX_RULE7EN_MASK          0x1
-#define USTORM_RDMA_CONN_AG_CTX_RULE7EN_SHIFT         6
-#define USTORM_RDMA_CONN_AG_CTX_RULE8EN_MASK          0x1
-#define USTORM_RDMA_CONN_AG_CTX_RULE8EN_SHIFT         7
-       u8 byte2;
-       u8 byte3;
-       __le16 conn_dpi;
-       __le16 word1;
-       __le32 cq_cons;
-       __le32 cq_se_prod;
-       __le32 cq_prod;
-       __le32 reg3;
-       __le16 int_timeout;
-       __le16 word3;
-};
-
-struct xstorm_roce_conn_ag_ctx_dq_ext_ld_part {
-       u8 reserved0;
-       u8 state;
+       u8 state;
        u8 flags0;
 #define XSTORMROCECONNAGCTXDQEXTLDPART_EXIST_IN_QM0_MASK      0x1
 #define XSTORMROCECONNAGCTXDQEXTLDPART_EXIST_IN_QM0_SHIFT     0
@@ -6469,8 +6549,8 @@ struct xstorm_roce_conn_ag_ctx_dq_ext_ld_part {
 #define XSTORMROCECONNAGCTXDQEXTLDPART_BIT11_SHIFT            3
 #define XSTORMROCECONNAGCTXDQEXTLDPART_BIT12_MASK             0x1
 #define XSTORMROCECONNAGCTXDQEXTLDPART_BIT12_SHIFT            4
-#define XSTORMROCECONNAGCTXDQEXTLDPART_BIT13_MASK             0x1
-#define XSTORMROCECONNAGCTXDQEXTLDPART_BIT13_SHIFT            5
+#define XSTORMROCECONNAGCTXDQEXTLDPART_MSTORM_FLUSH_MASK      0x1
+#define XSTORMROCECONNAGCTXDQEXTLDPART_MSTORM_FLUSH_SHIFT     5
 #define XSTORMROCECONNAGCTXDQEXTLDPART_BIT14_MASK             0x1
 #define XSTORMROCECONNAGCTXDQEXTLDPART_BIT14_SHIFT            6
 #define XSTORMROCECONNAGCTXDQEXTLDPART_YSTORM_FLUSH_MASK      0x1
@@ -6647,22 +6727,311 @@ struct xstorm_roce_conn_ag_ctx_dq_ext_ld_part {
 #define XSTORMROCECONNAGCTXDQEXTLDPART_CF23_MASK              0x3
 #define XSTORMROCECONNAGCTXDQEXTLDPART_CF23_SHIFT             6
        u8 byte2;
-       __le16 physical_q0;
+       __le16 physical_q0;
+       __le16 word1;
+       __le16 word2;
+       __le16 word3;
+       __le16 word4;
+       __le16 word5;
+       __le16 conn_dpi;
+       u8 byte3;
+       u8 byte4;
+       u8 byte5;
+       u8 byte6;
+       __le32 reg0;
+       __le32 reg1;
+       __le32 reg2;
+       __le32 snd_nxt_psn;
+       __le32 reg4;
+};
+
+struct mstorm_rdma_conn_ag_ctx {
+       u8 byte0;
+       u8 byte1;
+       u8 flags0;
+#define MSTORM_RDMA_CONN_AG_CTX_BIT0_MASK     0x1
+#define MSTORM_RDMA_CONN_AG_CTX_BIT0_SHIFT    0
+#define MSTORM_RDMA_CONN_AG_CTX_BIT1_MASK     0x1
+#define MSTORM_RDMA_CONN_AG_CTX_BIT1_SHIFT    1
+#define MSTORM_RDMA_CONN_AG_CTX_CF0_MASK      0x3
+#define MSTORM_RDMA_CONN_AG_CTX_CF0_SHIFT     2
+#define MSTORM_RDMA_CONN_AG_CTX_CF1_MASK      0x3
+#define MSTORM_RDMA_CONN_AG_CTX_CF1_SHIFT     4
+#define MSTORM_RDMA_CONN_AG_CTX_CF2_MASK      0x3
+#define MSTORM_RDMA_CONN_AG_CTX_CF2_SHIFT     6
+       u8 flags1;
+#define MSTORM_RDMA_CONN_AG_CTX_CF0EN_MASK    0x1
+#define MSTORM_RDMA_CONN_AG_CTX_CF0EN_SHIFT   0
+#define MSTORM_RDMA_CONN_AG_CTX_CF1EN_MASK    0x1
+#define MSTORM_RDMA_CONN_AG_CTX_CF1EN_SHIFT   1
+#define MSTORM_RDMA_CONN_AG_CTX_CF2EN_MASK    0x1
+#define MSTORM_RDMA_CONN_AG_CTX_CF2EN_SHIFT   2
+#define MSTORM_RDMA_CONN_AG_CTX_RULE0EN_MASK  0x1
+#define MSTORM_RDMA_CONN_AG_CTX_RULE0EN_SHIFT 3
+#define MSTORM_RDMA_CONN_AG_CTX_RULE1EN_MASK  0x1
+#define MSTORM_RDMA_CONN_AG_CTX_RULE1EN_SHIFT 4
+#define MSTORM_RDMA_CONN_AG_CTX_RULE2EN_MASK  0x1
+#define MSTORM_RDMA_CONN_AG_CTX_RULE2EN_SHIFT 5
+#define MSTORM_RDMA_CONN_AG_CTX_RULE3EN_MASK  0x1
+#define MSTORM_RDMA_CONN_AG_CTX_RULE3EN_SHIFT 6
+#define MSTORM_RDMA_CONN_AG_CTX_RULE4EN_MASK  0x1
+#define MSTORM_RDMA_CONN_AG_CTX_RULE4EN_SHIFT 7
+       __le16 word0;
+       __le16 word1;
+       __le32 reg0;
+       __le32 reg1;
+};
+
+struct tstorm_rdma_conn_ag_ctx {
+       u8 reserved0;
+       u8 byte1;
+       u8 flags0;
+#define TSTORM_RDMA_CONN_AG_CTX_EXIST_IN_QM0_MASK          0x1
+#define TSTORM_RDMA_CONN_AG_CTX_EXIST_IN_QM0_SHIFT         0
+#define TSTORM_RDMA_CONN_AG_CTX_BIT1_MASK                  0x1
+#define TSTORM_RDMA_CONN_AG_CTX_BIT1_SHIFT                 1
+#define TSTORM_RDMA_CONN_AG_CTX_BIT2_MASK                  0x1
+#define TSTORM_RDMA_CONN_AG_CTX_BIT2_SHIFT                 2
+#define TSTORM_RDMA_CONN_AG_CTX_BIT3_MASK                  0x1
+#define TSTORM_RDMA_CONN_AG_CTX_BIT3_SHIFT                 3
+#define TSTORM_RDMA_CONN_AG_CTX_BIT4_MASK                  0x1
+#define TSTORM_RDMA_CONN_AG_CTX_BIT4_SHIFT                 4
+#define TSTORM_RDMA_CONN_AG_CTX_BIT5_MASK                  0x1
+#define TSTORM_RDMA_CONN_AG_CTX_BIT5_SHIFT                 5
+#define TSTORM_RDMA_CONN_AG_CTX_CF0_MASK                   0x3
+#define TSTORM_RDMA_CONN_AG_CTX_CF0_SHIFT                  6
+       u8 flags1;
+#define TSTORM_RDMA_CONN_AG_CTX_CF1_MASK                   0x3
+#define TSTORM_RDMA_CONN_AG_CTX_CF1_SHIFT                  0
+#define TSTORM_RDMA_CONN_AG_CTX_CF2_MASK                   0x3
+#define TSTORM_RDMA_CONN_AG_CTX_CF2_SHIFT                  2
+#define TSTORM_RDMA_CONN_AG_CTX_TIMER_STOP_ALL_CF_MASK     0x3
+#define TSTORM_RDMA_CONN_AG_CTX_TIMER_STOP_ALL_CF_SHIFT    4
+#define TSTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_MASK           0x3
+#define TSTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_SHIFT          6
+       u8 flags2;
+#define TSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_CF_MASK       0x3
+#define TSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_CF_SHIFT      0
+#define TSTORM_RDMA_CONN_AG_CTX_CF6_MASK                   0x3
+#define TSTORM_RDMA_CONN_AG_CTX_CF6_SHIFT                  2
+#define TSTORM_RDMA_CONN_AG_CTX_CF7_MASK                   0x3
+#define TSTORM_RDMA_CONN_AG_CTX_CF7_SHIFT                  4
+#define TSTORM_RDMA_CONN_AG_CTX_CF8_MASK                   0x3
+#define TSTORM_RDMA_CONN_AG_CTX_CF8_SHIFT                  6
+       u8 flags3;
+#define TSTORM_RDMA_CONN_AG_CTX_CF9_MASK                   0x3
+#define TSTORM_RDMA_CONN_AG_CTX_CF9_SHIFT                  0
+#define TSTORM_RDMA_CONN_AG_CTX_CF10_MASK                  0x3
+#define TSTORM_RDMA_CONN_AG_CTX_CF10_SHIFT                 2
+#define TSTORM_RDMA_CONN_AG_CTX_CF0EN_MASK                 0x1
+#define TSTORM_RDMA_CONN_AG_CTX_CF0EN_SHIFT                4
+#define TSTORM_RDMA_CONN_AG_CTX_CF1EN_MASK                 0x1
+#define TSTORM_RDMA_CONN_AG_CTX_CF1EN_SHIFT                5
+#define TSTORM_RDMA_CONN_AG_CTX_CF2EN_MASK                 0x1
+#define TSTORM_RDMA_CONN_AG_CTX_CF2EN_SHIFT                6
+#define TSTORM_RDMA_CONN_AG_CTX_TIMER_STOP_ALL_CF_EN_MASK  0x1
+#define TSTORM_RDMA_CONN_AG_CTX_TIMER_STOP_ALL_CF_EN_SHIFT 7
+       u8 flags4;
+#define TSTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_EN_MASK        0x1
+#define TSTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_EN_SHIFT       0
+#define TSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_CF_EN_MASK    0x1
+#define TSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_CF_EN_SHIFT   1
+#define TSTORM_RDMA_CONN_AG_CTX_CF6EN_MASK                 0x1
+#define TSTORM_RDMA_CONN_AG_CTX_CF6EN_SHIFT                2
+#define TSTORM_RDMA_CONN_AG_CTX_CF7EN_MASK                 0x1
+#define TSTORM_RDMA_CONN_AG_CTX_CF7EN_SHIFT                3
+#define TSTORM_RDMA_CONN_AG_CTX_CF8EN_MASK                 0x1
+#define TSTORM_RDMA_CONN_AG_CTX_CF8EN_SHIFT                4
+#define TSTORM_RDMA_CONN_AG_CTX_CF9EN_MASK                 0x1
+#define TSTORM_RDMA_CONN_AG_CTX_CF9EN_SHIFT                5
+#define TSTORM_RDMA_CONN_AG_CTX_CF10EN_MASK                0x1
+#define TSTORM_RDMA_CONN_AG_CTX_CF10EN_SHIFT               6
+#define TSTORM_RDMA_CONN_AG_CTX_RULE0EN_MASK               0x1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE0EN_SHIFT              7
+       u8 flags5;
+#define TSTORM_RDMA_CONN_AG_CTX_RULE1EN_MASK               0x1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE1EN_SHIFT              0
+#define TSTORM_RDMA_CONN_AG_CTX_RULE2EN_MASK               0x1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE2EN_SHIFT              1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE3EN_MASK               0x1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE3EN_SHIFT              2
+#define TSTORM_RDMA_CONN_AG_CTX_RULE4EN_MASK               0x1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE4EN_SHIFT              3
+#define TSTORM_RDMA_CONN_AG_CTX_RULE5EN_MASK               0x1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE5EN_SHIFT              4
+#define TSTORM_RDMA_CONN_AG_CTX_RULE6EN_MASK               0x1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE6EN_SHIFT              5
+#define TSTORM_RDMA_CONN_AG_CTX_RULE7EN_MASK               0x1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE7EN_SHIFT              6
+#define TSTORM_RDMA_CONN_AG_CTX_RULE8EN_MASK               0x1
+#define TSTORM_RDMA_CONN_AG_CTX_RULE8EN_SHIFT              7
+       __le32 reg0;
+       __le32 reg1;
+       __le32 reg2;
+       __le32 reg3;
+       __le32 reg4;
+       __le32 reg5;
+       __le32 reg6;
+       __le32 reg7;
+       __le32 reg8;
+       u8 byte2;
+       u8 byte3;
+       __le16 word0;
+       u8 byte4;
+       u8 byte5;
+       __le16 word1;
+       __le16 word2;
+       __le16 word3;
+       __le32 reg9;
+       __le32 reg10;
+};
+
+struct tstorm_rdma_task_ag_ctx {
+       u8 byte0;
+       u8 byte1;
+       __le16 word0;
+       u8 flags0;
+#define TSTORM_RDMA_TASK_AG_CTX_NIBBLE0_MASK  0xF
+#define TSTORM_RDMA_TASK_AG_CTX_NIBBLE0_SHIFT 0
+#define TSTORM_RDMA_TASK_AG_CTX_BIT0_MASK     0x1
+#define TSTORM_RDMA_TASK_AG_CTX_BIT0_SHIFT    4
+#define TSTORM_RDMA_TASK_AG_CTX_BIT1_MASK     0x1
+#define TSTORM_RDMA_TASK_AG_CTX_BIT1_SHIFT    5
+#define TSTORM_RDMA_TASK_AG_CTX_BIT2_MASK     0x1
+#define TSTORM_RDMA_TASK_AG_CTX_BIT2_SHIFT    6
+#define TSTORM_RDMA_TASK_AG_CTX_BIT3_MASK     0x1
+#define TSTORM_RDMA_TASK_AG_CTX_BIT3_SHIFT    7
+       u8 flags1;
+#define TSTORM_RDMA_TASK_AG_CTX_BIT4_MASK     0x1
+#define TSTORM_RDMA_TASK_AG_CTX_BIT4_SHIFT    0
+#define TSTORM_RDMA_TASK_AG_CTX_BIT5_MASK     0x1
+#define TSTORM_RDMA_TASK_AG_CTX_BIT5_SHIFT    1
+#define TSTORM_RDMA_TASK_AG_CTX_CF0_MASK      0x3
+#define TSTORM_RDMA_TASK_AG_CTX_CF0_SHIFT     2
+#define TSTORM_RDMA_TASK_AG_CTX_CF1_MASK      0x3
+#define TSTORM_RDMA_TASK_AG_CTX_CF1_SHIFT     4
+#define TSTORM_RDMA_TASK_AG_CTX_CF2_MASK      0x3
+#define TSTORM_RDMA_TASK_AG_CTX_CF2_SHIFT     6
+       u8 flags2;
+#define TSTORM_RDMA_TASK_AG_CTX_CF3_MASK      0x3
+#define TSTORM_RDMA_TASK_AG_CTX_CF3_SHIFT     0
+#define TSTORM_RDMA_TASK_AG_CTX_CF4_MASK      0x3
+#define TSTORM_RDMA_TASK_AG_CTX_CF4_SHIFT     2
+#define TSTORM_RDMA_TASK_AG_CTX_CF5_MASK      0x3
+#define TSTORM_RDMA_TASK_AG_CTX_CF5_SHIFT     4
+#define TSTORM_RDMA_TASK_AG_CTX_CF6_MASK      0x3
+#define TSTORM_RDMA_TASK_AG_CTX_CF6_SHIFT     6
+       u8 flags3;
+#define TSTORM_RDMA_TASK_AG_CTX_CF7_MASK      0x3
+#define TSTORM_RDMA_TASK_AG_CTX_CF7_SHIFT     0
+#define TSTORM_RDMA_TASK_AG_CTX_CF0EN_MASK    0x1
+#define TSTORM_RDMA_TASK_AG_CTX_CF0EN_SHIFT   2
+#define TSTORM_RDMA_TASK_AG_CTX_CF1EN_MASK    0x1
+#define TSTORM_RDMA_TASK_AG_CTX_CF1EN_SHIFT   3
+#define TSTORM_RDMA_TASK_AG_CTX_CF2EN_MASK    0x1
+#define TSTORM_RDMA_TASK_AG_CTX_CF2EN_SHIFT   4
+#define TSTORM_RDMA_TASK_AG_CTX_CF3EN_MASK    0x1
+#define TSTORM_RDMA_TASK_AG_CTX_CF3EN_SHIFT   5
+#define TSTORM_RDMA_TASK_AG_CTX_CF4EN_MASK    0x1
+#define TSTORM_RDMA_TASK_AG_CTX_CF4EN_SHIFT   6
+#define TSTORM_RDMA_TASK_AG_CTX_CF5EN_MASK    0x1
+#define TSTORM_RDMA_TASK_AG_CTX_CF5EN_SHIFT   7
+       u8 flags4;
+#define TSTORM_RDMA_TASK_AG_CTX_CF6EN_MASK    0x1
+#define TSTORM_RDMA_TASK_AG_CTX_CF6EN_SHIFT   0
+#define TSTORM_RDMA_TASK_AG_CTX_CF7EN_MASK    0x1
+#define TSTORM_RDMA_TASK_AG_CTX_CF7EN_SHIFT   1
+#define TSTORM_RDMA_TASK_AG_CTX_RULE0EN_MASK  0x1
+#define TSTORM_RDMA_TASK_AG_CTX_RULE0EN_SHIFT 2
+#define TSTORM_RDMA_TASK_AG_CTX_RULE1EN_MASK  0x1
+#define TSTORM_RDMA_TASK_AG_CTX_RULE1EN_SHIFT 3
+#define TSTORM_RDMA_TASK_AG_CTX_RULE2EN_MASK  0x1
+#define TSTORM_RDMA_TASK_AG_CTX_RULE2EN_SHIFT 4
+#define TSTORM_RDMA_TASK_AG_CTX_RULE3EN_MASK  0x1
+#define TSTORM_RDMA_TASK_AG_CTX_RULE3EN_SHIFT 5
+#define TSTORM_RDMA_TASK_AG_CTX_RULE4EN_MASK  0x1
+#define TSTORM_RDMA_TASK_AG_CTX_RULE4EN_SHIFT 6
+#define TSTORM_RDMA_TASK_AG_CTX_RULE5EN_MASK  0x1
+#define TSTORM_RDMA_TASK_AG_CTX_RULE5EN_SHIFT 7
+       u8 byte2;
+       __le16 word1;
+       __le32 reg0;
+       u8 byte3;
+       u8 byte4;
+       __le16 word2;
+       __le16 word3;
+       __le16 word4;
+       __le32 reg1;
+       __le32 reg2;
+};
+
+struct ustorm_rdma_conn_ag_ctx {
+       u8 reserved;
+       u8 byte1;
+       u8 flags0;
+#define USTORM_RDMA_CONN_AG_CTX_EXIST_IN_QM0_MASK     0x1
+#define USTORM_RDMA_CONN_AG_CTX_EXIST_IN_QM0_SHIFT    0
+#define USTORM_RDMA_CONN_AG_CTX_BIT1_MASK             0x1
+#define USTORM_RDMA_CONN_AG_CTX_BIT1_SHIFT            1
+#define USTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_MASK      0x3
+#define USTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_SHIFT     2
+#define USTORM_RDMA_CONN_AG_CTX_CF1_MASK              0x3
+#define USTORM_RDMA_CONN_AG_CTX_CF1_SHIFT             4
+#define USTORM_RDMA_CONN_AG_CTX_CF2_MASK              0x3
+#define USTORM_RDMA_CONN_AG_CTX_CF2_SHIFT             6
+       u8 flags1;
+#define USTORM_RDMA_CONN_AG_CTX_CF3_MASK              0x3
+#define USTORM_RDMA_CONN_AG_CTX_CF3_SHIFT             0
+#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_SE_CF_MASK     0x3
+#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_SE_CF_SHIFT    2
+#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_CF_MASK        0x3
+#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_CF_SHIFT       4
+#define USTORM_RDMA_CONN_AG_CTX_CF6_MASK              0x3
+#define USTORM_RDMA_CONN_AG_CTX_CF6_SHIFT             6
+       u8 flags2;
+#define USTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_EN_MASK   0x1
+#define USTORM_RDMA_CONN_AG_CTX_FLUSH_Q0_CF_EN_SHIFT  0
+#define USTORM_RDMA_CONN_AG_CTX_CF1EN_MASK            0x1
+#define USTORM_RDMA_CONN_AG_CTX_CF1EN_SHIFT           1
+#define USTORM_RDMA_CONN_AG_CTX_CF2EN_MASK            0x1
+#define USTORM_RDMA_CONN_AG_CTX_CF2EN_SHIFT           2
+#define USTORM_RDMA_CONN_AG_CTX_CF3EN_MASK            0x1
+#define USTORM_RDMA_CONN_AG_CTX_CF3EN_SHIFT           3
+#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_SE_CF_EN_MASK  0x1
+#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_SE_CF_EN_SHIFT 4
+#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_CF_EN_MASK     0x1
+#define USTORM_RDMA_CONN_AG_CTX_CQ_ARM_CF_EN_SHIFT    5
+#define USTORM_RDMA_CONN_AG_CTX_CF6EN_MASK            0x1
+#define USTORM_RDMA_CONN_AG_CTX_CF6EN_SHIFT           6
+#define USTORM_RDMA_CONN_AG_CTX_CQ_SE_EN_MASK         0x1
+#define USTORM_RDMA_CONN_AG_CTX_CQ_SE_EN_SHIFT        7
+       u8 flags3;
+#define USTORM_RDMA_CONN_AG_CTX_CQ_EN_MASK            0x1
+#define USTORM_RDMA_CONN_AG_CTX_CQ_EN_SHIFT           0
+#define USTORM_RDMA_CONN_AG_CTX_RULE2EN_MASK          0x1
+#define USTORM_RDMA_CONN_AG_CTX_RULE2EN_SHIFT         1
+#define USTORM_RDMA_CONN_AG_CTX_RULE3EN_MASK          0x1
+#define USTORM_RDMA_CONN_AG_CTX_RULE3EN_SHIFT         2
+#define USTORM_RDMA_CONN_AG_CTX_RULE4EN_MASK          0x1
+#define USTORM_RDMA_CONN_AG_CTX_RULE4EN_SHIFT         3
+#define USTORM_RDMA_CONN_AG_CTX_RULE5EN_MASK          0x1
+#define USTORM_RDMA_CONN_AG_CTX_RULE5EN_SHIFT         4
+#define USTORM_RDMA_CONN_AG_CTX_RULE6EN_MASK          0x1
+#define USTORM_RDMA_CONN_AG_CTX_RULE6EN_SHIFT         5
+#define USTORM_RDMA_CONN_AG_CTX_RULE7EN_MASK          0x1
+#define USTORM_RDMA_CONN_AG_CTX_RULE7EN_SHIFT         6
+#define USTORM_RDMA_CONN_AG_CTX_RULE8EN_MASK          0x1
+#define USTORM_RDMA_CONN_AG_CTX_RULE8EN_SHIFT         7
+       u8 byte2;
+       u8 byte3;
+       __le16 conn_dpi;
        __le16 word1;
-       __le16 word2;
+       __le32 cq_cons;
+       __le32 cq_se_prod;
+       __le32 cq_prod;
+       __le32 reg3;
+       __le16 int_timeout;
        __le16 word3;
-       __le16 word4;
-       __le16 word5;
-       __le16 conn_dpi;
-       u8 byte3;
-       u8 byte4;
-       u8 byte5;
-       u8 byte6;
-       __le32 reg0;
-       __le32 reg1;
-       __le32 reg2;
-       __le32 snd_nxt_psn;
-       __le32 reg4;
 };
 
 struct xstorm_rdma_conn_ag_ctx {
@@ -6696,8 +7065,8 @@ struct xstorm_rdma_conn_ag_ctx {
 #define XSTORM_RDMA_CONN_AG_CTX_BIT11_SHIFT            3
 #define XSTORM_RDMA_CONN_AG_CTX_BIT12_MASK             0x1
 #define XSTORM_RDMA_CONN_AG_CTX_BIT12_SHIFT            4
-#define XSTORM_RDMA_CONN_AG_CTX_BIT13_MASK             0x1
-#define XSTORM_RDMA_CONN_AG_CTX_BIT13_SHIFT            5
+#define XSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_MASK      0x1
+#define XSTORM_RDMA_CONN_AG_CTX_MSTORM_FLUSH_SHIFT     5
 #define XSTORM_RDMA_CONN_AG_CTX_BIT14_MASK             0x1
 #define XSTORM_RDMA_CONN_AG_CTX_BIT14_SHIFT            6
 #define XSTORM_RDMA_CONN_AG_CTX_YSTORM_FLUSH_MASK      0x1
@@ -7093,16 +7462,35 @@ struct roce_destroy_qp_resp_ramrod_data {
        struct regpair output_params_addr;
 };
 
+struct roce_events_stats {
+       __le16 silent_drops;
+       __le16 rnr_naks_sent;
+       __le32 retransmit_count;
+       __le32 icrc_error_count;
+       __le32 reserved;
+};
+
 enum roce_event_opcode {
        ROCE_EVENT_CREATE_QP = 11,
        ROCE_EVENT_MODIFY_QP,
        ROCE_EVENT_QUERY_QP,
        ROCE_EVENT_DESTROY_QP,
+       ROCE_EVENT_CREATE_UD_QP,
+       ROCE_EVENT_DESTROY_UD_QP,
        MAX_ROCE_EVENT_OPCODE
 };
 
+struct roce_init_func_params {
+       u8 ll2_queue_id;
+       u8 cnp_vlan_priority;
+       u8 cnp_dscp;
+       u8 reserved;
+       __le32 cnp_send_timeout;
+};
+
 struct roce_init_func_ramrod_data {
        struct rdma_init_func_ramrod_data rdma;
+       struct roce_init_func_params roce;
 };
 
 struct roce_modify_qp_req_ramrod_data {
@@ -7222,6 +7610,8 @@ enum roce_ramrod_cmd_id {
        ROCE_RAMROD_MODIFY_QP,
        ROCE_RAMROD_QUERY_QP,
        ROCE_RAMROD_DESTROY_QP,
+       ROCE_RAMROD_CREATE_UD_QP,
+       ROCE_RAMROD_DESTROY_UD_QP,
        MAX_ROCE_RAMROD_CMD_ID
 };
 
@@ -7299,13 +7689,6 @@ struct mstorm_roce_resp_conn_ag_ctx {
        __le32 reg1;
 };
 
-enum roce_flavor {
-       PLAIN_ROCE /* RoCE v1 */ ,
-       RROCE_IPV4 /* RoCE v2 (Routable RoCE) over ipv4 */ ,
-       RROCE_IPV6 /* RoCE v2 (Routable RoCE) over ipv6 */ ,
-       MAX_ROCE_FLAVOR
-};
-
 struct tstorm_roce_req_conn_ag_ctx {
        u8 reserved0;
        u8 state;
@@ -7416,8 +7799,8 @@ struct tstorm_roce_resp_conn_ag_ctx {
        u8 flags0;
 #define TSTORM_ROCE_RESP_CONN_AG_CTX_EXIST_IN_QM0_MASK        0x1
 #define TSTORM_ROCE_RESP_CONN_AG_CTX_EXIST_IN_QM0_SHIFT       0
-#define TSTORM_ROCE_RESP_CONN_AG_CTX_BIT1_MASK                0x1
-#define TSTORM_ROCE_RESP_CONN_AG_CTX_BIT1_SHIFT               1
+#define TSTORM_ROCE_RESP_CONN_AG_CTX_RX_ERROR_NOTIFY_REQUESTER_MASK  0x1
+#define TSTORM_ROCE_RESP_CONN_AG_CTX_RX_ERROR_NOTIFY_REQUESTER_SHIFT 1
 #define TSTORM_ROCE_RESP_CONN_AG_CTX_BIT2_MASK                0x1
 #define TSTORM_ROCE_RESP_CONN_AG_CTX_BIT2_SHIFT               2
 #define TSTORM_ROCE_RESP_CONN_AG_CTX_BIT3_MASK                0x1
@@ -8097,7 +8480,7 @@ struct xstorm_roce_resp_conn_ag_ctx {
        __le16 irq_prod;
        __le16 word3;
        __le16 word4;
-       __le16 word5;
+       __le16 ereserved1;
        __le16 irq_cons;
        u8 rxmit_opcode;
        u8 byte4;
@@ -8200,6 +8583,812 @@ struct ystorm_roce_resp_conn_ag_ctx {
        __le32 reg3;
 };
 
+enum roce_flavor {
+       PLAIN_ROCE,
+       RROCE_IPV4,
+       RROCE_IPV6,
+       MAX_ROCE_FLAVOR
+};
+
+struct ystorm_iwarp_conn_st_ctx {
+       __le32 reserved[4];
+};
+
+struct pstorm_iwarp_conn_st_ctx {
+       __le32 reserved[36];
+};
+
+struct xstorm_iwarp_conn_st_ctx {
+       __le32 reserved[44];
+};
+
+struct xstorm_iwarp_conn_ag_ctx {
+       u8 reserved0;
+       u8 state;
+       u8 flags0;
+#define XSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM0_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM0_SHIFT    0
+#define XSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM1_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM1_SHIFT    1
+#define XSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM2_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM2_SHIFT    2
+#define XSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM3_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM3_SHIFT    3
+#define XSTORM_IWARP_CONN_AG_CTX_BIT4_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT4_SHIFT    4
+#define XSTORM_IWARP_CONN_AG_CTX_RESERVED2_MASK        0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RESERVED2_SHIFT       5
+#define XSTORM_IWARP_CONN_AG_CTX_BIT6_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT6_SHIFT    6
+#define XSTORM_IWARP_CONN_AG_CTX_BIT7_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT7_SHIFT    7
+       u8 flags1;
+#define XSTORM_IWARP_CONN_AG_CTX_BIT8_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT8_SHIFT    0
+#define XSTORM_IWARP_CONN_AG_CTX_BIT9_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT9_SHIFT    1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT10_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT10_SHIFT   2
+#define XSTORM_IWARP_CONN_AG_CTX_BIT11_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT11_SHIFT   3
+#define XSTORM_IWARP_CONN_AG_CTX_BIT12_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT12_SHIFT   4
+#define XSTORM_IWARP_CONN_AG_CTX_BIT13_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT13_SHIFT   5
+#define XSTORM_IWARP_CONN_AG_CTX_BIT14_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT14_SHIFT   6
+#define XSTORM_IWARP_CONN_AG_CTX_YSTORM_FLUSH_OR_REWIND_SND_MAX_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_YSTORM_FLUSH_OR_REWIND_SND_MAX_SHIFT  7
+       u8 flags2;
+#define XSTORM_IWARP_CONN_AG_CTX_CF0_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF0_SHIFT     0
+#define XSTORM_IWARP_CONN_AG_CTX_CF1_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF1_SHIFT     2
+#define XSTORM_IWARP_CONN_AG_CTX_CF2_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF2_SHIFT     4
+#define XSTORM_IWARP_CONN_AG_CTX_TIMER_STOP_ALL_MASK   0x3
+#define XSTORM_IWARP_CONN_AG_CTX_TIMER_STOP_ALL_SHIFT  6
+       u8 flags3;
+#define XSTORM_IWARP_CONN_AG_CTX_CF4_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF4_SHIFT     0
+#define XSTORM_IWARP_CONN_AG_CTX_CF5_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF5_SHIFT     2
+#define XSTORM_IWARP_CONN_AG_CTX_CF6_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF6_SHIFT     4
+#define XSTORM_IWARP_CONN_AG_CTX_CF7_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF7_SHIFT     6
+       u8 flags4;
+#define XSTORM_IWARP_CONN_AG_CTX_CF8_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF8_SHIFT     0
+#define XSTORM_IWARP_CONN_AG_CTX_CF9_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF9_SHIFT     2
+#define XSTORM_IWARP_CONN_AG_CTX_CF10_MASK     0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF10_SHIFT    4
+#define XSTORM_IWARP_CONN_AG_CTX_CF11_MASK     0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF11_SHIFT    6
+       u8 flags5;
+#define XSTORM_IWARP_CONN_AG_CTX_CF12_MASK     0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF12_SHIFT    0
+#define XSTORM_IWARP_CONN_AG_CTX_CF13_MASK     0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF13_SHIFT    2
+#define XSTORM_IWARP_CONN_AG_CTX_SQ_FLUSH_CF_MASK      0x3
+#define XSTORM_IWARP_CONN_AG_CTX_SQ_FLUSH_CF_SHIFT     4
+#define XSTORM_IWARP_CONN_AG_CTX_CF15_MASK     0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF15_SHIFT    6
+       u8 flags6;
+#define XSTORM_IWARP_CONN_AG_CTX_MPA_OR_ERROR_WAKEUP_TRIGGER_CF_MASK   0x3
+#define XSTORM_IWARP_CONN_AG_CTX_MPA_OR_ERROR_WAKEUP_TRIGGER_CF_SHIFT  0
+#define XSTORM_IWARP_CONN_AG_CTX_CF17_MASK     0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF17_SHIFT    2
+#define XSTORM_IWARP_CONN_AG_CTX_CF18_MASK     0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF18_SHIFT    4
+#define XSTORM_IWARP_CONN_AG_CTX_DQ_FLUSH_MASK 0x3
+#define XSTORM_IWARP_CONN_AG_CTX_DQ_FLUSH_SHIFT        6
+       u8 flags7;
+#define XSTORM_IWARP_CONN_AG_CTX_FLUSH_Q0_MASK 0x3
+#define XSTORM_IWARP_CONN_AG_CTX_FLUSH_Q0_SHIFT        0
+#define XSTORM_IWARP_CONN_AG_CTX_FLUSH_Q1_MASK 0x3
+#define XSTORM_IWARP_CONN_AG_CTX_FLUSH_Q1_SHIFT        2
+#define XSTORM_IWARP_CONN_AG_CTX_SLOW_PATH_MASK        0x3
+#define XSTORM_IWARP_CONN_AG_CTX_SLOW_PATH_SHIFT       4
+#define XSTORM_IWARP_CONN_AG_CTX_CF0EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF0EN_SHIFT   6
+#define XSTORM_IWARP_CONN_AG_CTX_CF1EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF1EN_SHIFT   7
+       u8 flags8;
+#define XSTORM_IWARP_CONN_AG_CTX_CF2EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF2EN_SHIFT   0
+#define XSTORM_IWARP_CONN_AG_CTX_TIMER_STOP_ALL_EN_MASK        0x1
+#define XSTORM_IWARP_CONN_AG_CTX_TIMER_STOP_ALL_EN_SHIFT       1
+#define XSTORM_IWARP_CONN_AG_CTX_CF4EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF4EN_SHIFT   2
+#define XSTORM_IWARP_CONN_AG_CTX_CF5EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF5EN_SHIFT   3
+#define XSTORM_IWARP_CONN_AG_CTX_CF6EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF6EN_SHIFT   4
+#define XSTORM_IWARP_CONN_AG_CTX_CF7EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF7EN_SHIFT   5
+#define XSTORM_IWARP_CONN_AG_CTX_CF8EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF8EN_SHIFT   6
+#define XSTORM_IWARP_CONN_AG_CTX_CF9EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF9EN_SHIFT   7
+       u8 flags9;
+#define XSTORM_IWARP_CONN_AG_CTX_CF10EN_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF10EN_SHIFT  0
+#define XSTORM_IWARP_CONN_AG_CTX_CF11EN_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF11EN_SHIFT  1
+#define XSTORM_IWARP_CONN_AG_CTX_CF12EN_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF12EN_SHIFT  2
+#define XSTORM_IWARP_CONN_AG_CTX_CF13EN_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF13EN_SHIFT  3
+#define XSTORM_IWARP_CONN_AG_CTX_SQ_FLUSH_CF_EN_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_SQ_FLUSH_CF_EN_SHIFT  4
+#define XSTORM_IWARP_CONN_AG_CTX_CF15EN_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF15EN_SHIFT  5
+#define XSTORM_IWARP_CONN_AG_CTX_MPA_OR_ERROR_WAKEUP_TRIGGER_CF_EN_MASK        0x1
+#define XSTORM_IWARP_CONN_AG_CTX_MPA_OR_ERROR_WAKEUP_TRIGGER_CF_EN_SHIFT 6
+#define XSTORM_IWARP_CONN_AG_CTX_CF17EN_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF17EN_SHIFT  7
+       u8 flags10;
+#define XSTORM_IWARP_CONN_AG_CTX_CF18EN_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF18EN_SHIFT  0
+#define XSTORM_IWARP_CONN_AG_CTX_DQ_FLUSH_EN_MASK      0x1
+#define XSTORM_IWARP_CONN_AG_CTX_DQ_FLUSH_EN_SHIFT     1
+#define XSTORM_IWARP_CONN_AG_CTX_FLUSH_Q0_EN_MASK      0x1
+#define XSTORM_IWARP_CONN_AG_CTX_FLUSH_Q0_EN_SHIFT     2
+#define XSTORM_IWARP_CONN_AG_CTX_FLUSH_Q1_EN_MASK      0x1
+#define XSTORM_IWARP_CONN_AG_CTX_FLUSH_Q1_EN_SHIFT     3
+#define XSTORM_IWARP_CONN_AG_CTX_SLOW_PATH_EN_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_SLOW_PATH_EN_SHIFT    4
+#define XSTORM_IWARP_CONN_AG_CTX_CF23EN_MASK   0x1
+#define XSTORM_IWARP_CONN_AG_CTX_CF23EN_SHIFT  5
+#define XSTORM_IWARP_CONN_AG_CTX_RULE0EN_MASK  0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE0EN_SHIFT 6
+#define XSTORM_IWARP_CONN_AG_CTX_MORE_TO_SEND_RULE_EN_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_MORE_TO_SEND_RULE_EN_SHIFT    7
+       u8 flags11;
+#define XSTORM_IWARP_CONN_AG_CTX_TX_BLOCKED_EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_TX_BLOCKED_EN_SHIFT   0
+#define XSTORM_IWARP_CONN_AG_CTX_RULE3EN_MASK  0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE3EN_SHIFT 1
+#define XSTORM_IWARP_CONN_AG_CTX_RESERVED3_MASK        0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RESERVED3_SHIFT       2
+#define XSTORM_IWARP_CONN_AG_CTX_RULE5EN_MASK  0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE5EN_SHIFT 3
+#define XSTORM_IWARP_CONN_AG_CTX_RULE6EN_MASK  0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE6EN_SHIFT 4
+#define XSTORM_IWARP_CONN_AG_CTX_RULE7EN_MASK  0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE7EN_SHIFT 5
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED1_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED1_SHIFT    6
+#define XSTORM_IWARP_CONN_AG_CTX_RULE9EN_MASK  0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE9EN_SHIFT 7
+       u8 flags12;
+#define XSTORM_IWARP_CONN_AG_CTX_SQ_NOT_EMPTY_RULE_EN_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_SQ_NOT_EMPTY_RULE_EN_SHIFT    0
+#define XSTORM_IWARP_CONN_AG_CTX_RULE11EN_MASK 0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE11EN_SHIFT        1
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED2_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED2_SHIFT    2
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED3_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED3_SHIFT    3
+#define XSTORM_IWARP_CONN_AG_CTX_SQ_FENCE_RULE_EN_MASK 0x1
+#define XSTORM_IWARP_CONN_AG_CTX_SQ_FENCE_RULE_EN_SHIFT        4
+#define XSTORM_IWARP_CONN_AG_CTX_RULE15EN_MASK 0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE15EN_SHIFT        5
+#define XSTORM_IWARP_CONN_AG_CTX_RULE16EN_MASK 0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE16EN_SHIFT        6
+#define XSTORM_IWARP_CONN_AG_CTX_RULE17EN_MASK 0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE17EN_SHIFT        7
+       u8 flags13;
+#define XSTORM_IWARP_CONN_AG_CTX_IRQ_NOT_EMPTY_RULE_EN_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_IRQ_NOT_EMPTY_RULE_EN_SHIFT   0
+#define XSTORM_IWARP_CONN_AG_CTX_HQ_NOT_FULL_RULE_EN_MASK      0x1
+#define XSTORM_IWARP_CONN_AG_CTX_HQ_NOT_FULL_RULE_EN_SHIFT     1
+#define XSTORM_IWARP_CONN_AG_CTX_ORQ_RD_FENCE_RULE_EN_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_ORQ_RD_FENCE_RULE_EN_SHIFT    2
+#define XSTORM_IWARP_CONN_AG_CTX_RULE21EN_MASK 0x1
+#define XSTORM_IWARP_CONN_AG_CTX_RULE21EN_SHIFT        3
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED6_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED6_SHIFT    4
+#define XSTORM_IWARP_CONN_AG_CTX_ORQ_NOT_FULL_RULE_EN_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_ORQ_NOT_FULL_RULE_EN_SHIFT    5
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED8_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED8_SHIFT    6
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED9_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_A0_RESERVED9_SHIFT    7
+       u8 flags14;
+#define XSTORM_IWARP_CONN_AG_CTX_BIT16_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT16_SHIFT   0
+#define XSTORM_IWARP_CONN_AG_CTX_BIT17_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT17_SHIFT   1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT18_MASK    0x1
+#define XSTORM_IWARP_CONN_AG_CTX_BIT18_SHIFT   2
+#define XSTORM_IWARP_CONN_AG_CTX_E5_RESERVED1_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_E5_RESERVED1_SHIFT    3
+#define XSTORM_IWARP_CONN_AG_CTX_E5_RESERVED2_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_E5_RESERVED2_SHIFT    4
+#define XSTORM_IWARP_CONN_AG_CTX_E5_RESERVED3_MASK     0x1
+#define XSTORM_IWARP_CONN_AG_CTX_E5_RESERVED3_SHIFT    5
+#define XSTORM_IWARP_CONN_AG_CTX_CF23_MASK     0x3
+#define XSTORM_IWARP_CONN_AG_CTX_CF23_SHIFT    6
+       u8 byte2;
+       __le16 physical_q0;
+       __le16 physical_q1;
+       __le16 sq_comp_cons;
+       __le16 sq_tx_cons;
+       __le16 sq_prod;
+       __le16 word5;
+       __le16 conn_dpi;
+       u8 byte3;
+       u8 byte4;
+       u8 byte5;
+       u8 byte6;
+       __le32 reg0;
+       __le32 reg1;
+       __le32 reg2;
+       __le32 more_to_send_seq;
+       __le32 reg4;
+       __le32 rewinded_snd_max;
+       __le32 rd_msn;
+       __le16 irq_prod_via_msdm;
+       __le16 irq_cons;
+       __le16 hq_cons_th_or_mpa_data;
+       __le16 hq_cons;
+       __le32 atom_msn;
+       __le32 orq_cons;
+       __le32 orq_cons_th;
+       u8 byte7;
+       u8 max_ord;
+       u8 wqe_data_pad_bytes;
+       u8 former_hq_prod;
+       u8 irq_prod_via_msem;
+       u8 byte12;
+       u8 max_pkt_pdu_size_lo;
+       u8 max_pkt_pdu_size_hi;
+       u8 byte15;
+       u8 e5_reserved;
+       __le16 e5_reserved4;
+       __le32 reg10;
+       __le32 reg11;
+       __le32 shared_queue_page_addr_lo;
+       __le32 shared_queue_page_addr_hi;
+       __le32 reg14;
+       __le32 reg15;
+       __le32 reg16;
+       __le32 reg17;
+};
+
+struct tstorm_iwarp_conn_ag_ctx {
+       u8 reserved0;
+       u8 state;
+       u8 flags0;
+#define TSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM0_MASK     0x1
+#define TSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM0_SHIFT    0
+#define TSTORM_IWARP_CONN_AG_CTX_BIT1_MASK     0x1
+#define TSTORM_IWARP_CONN_AG_CTX_BIT1_SHIFT    1
+#define TSTORM_IWARP_CONN_AG_CTX_BIT2_MASK     0x1
+#define TSTORM_IWARP_CONN_AG_CTX_BIT2_SHIFT    2
+#define TSTORM_IWARP_CONN_AG_CTX_MSTORM_FLUSH_MASK     0x1
+#define TSTORM_IWARP_CONN_AG_CTX_MSTORM_FLUSH_SHIFT    3
+#define TSTORM_IWARP_CONN_AG_CTX_BIT4_MASK     0x1
+#define TSTORM_IWARP_CONN_AG_CTX_BIT4_SHIFT    4
+#define TSTORM_IWARP_CONN_AG_CTX_CACHED_ORQ_MASK       0x1
+#define TSTORM_IWARP_CONN_AG_CTX_CACHED_ORQ_SHIFT      5
+#define TSTORM_IWARP_CONN_AG_CTX_CF0_MASK      0x3
+#define TSTORM_IWARP_CONN_AG_CTX_CF0_SHIFT     6
+       u8 flags1;
+#define TSTORM_IWARP_CONN_AG_CTX_RQ_POST_CF_MASK       0x3
+#define TSTORM_IWARP_CONN_AG_CTX_RQ_POST_CF_SHIFT      0
+#define TSTORM_IWARP_CONN_AG_CTX_MPA_TIMEOUT_CF_MASK   0x3
+#define TSTORM_IWARP_CONN_AG_CTX_MPA_TIMEOUT_CF_SHIFT  2
+#define TSTORM_IWARP_CONN_AG_CTX_TIMER_STOP_ALL_MASK   0x3
+#define TSTORM_IWARP_CONN_AG_CTX_TIMER_STOP_ALL_SHIFT  4
+#define TSTORM_IWARP_CONN_AG_CTX_CF4_MASK      0x3
+#define TSTORM_IWARP_CONN_AG_CTX_CF4_SHIFT     6
+       u8 flags2;
+#define TSTORM_IWARP_CONN_AG_CTX_CF5_MASK      0x3
+#define TSTORM_IWARP_CONN_AG_CTX_CF5_SHIFT     0
+#define TSTORM_IWARP_CONN_AG_CTX_CF6_MASK      0x3
+#define TSTORM_IWARP_CONN_AG_CTX_CF6_SHIFT     2
+#define TSTORM_IWARP_CONN_AG_CTX_CF7_MASK      0x3
+#define TSTORM_IWARP_CONN_AG_CTX_CF7_SHIFT     4
+#define TSTORM_IWARP_CONN_AG_CTX_CF8_MASK      0x3
+#define TSTORM_IWARP_CONN_AG_CTX_CF8_SHIFT     6
+       u8 flags3;
+#define TSTORM_IWARP_CONN_AG_CTX_FLUSH_Q0_MASK 0x3
+#define TSTORM_IWARP_CONN_AG_CTX_FLUSH_Q0_SHIFT        0
+#define TSTORM_IWARP_CONN_AG_CTX_FLUSH_OR_ERROR_DETECTED_MASK  0x3
+#define TSTORM_IWARP_CONN_AG_CTX_FLUSH_OR_ERROR_DETECTED_SHIFT 2
+#define TSTORM_IWARP_CONN_AG_CTX_CF0EN_MASK    0x1
+#define TSTORM_IWARP_CONN_AG_CTX_CF0EN_SHIFT   4
+#define TSTORM_IWARP_CONN_AG_CTX_RQ_POST_CF_EN_MASK    0x1
+#define TSTORM_IWARP_CONN_AG_CTX_RQ_POST_CF_EN_SHIFT   5
+#define TSTORM_IWARP_CONN_AG_CTX_MPA_TIMEOUT_CF_EN_MASK        0x1
+#define TSTORM_IWARP_CONN_AG_CTX_MPA_TIMEOUT_CF_EN_SHIFT       6
+#define TSTORM_IWARP_CONN_AG_CTX_TIMER_STOP_ALL_EN_MASK        0x1
+#define TSTORM_IWARP_CONN_AG_CTX_TIMER_STOP_ALL_EN_SHIFT       7
+       u8 flags4;
+#define TSTORM_IWARP_CONN_AG_CTX_CF4EN_MASK    0x1
+#define TSTORM_IWARP_CONN_AG_CTX_CF4EN_SHIFT   0
+#define TSTORM_IWARP_CONN_AG_CTX_CF5EN_MASK    0x1
+#define TSTORM_IWARP_CONN_AG_CTX_CF5EN_SHIFT   1
+#define TSTORM_IWARP_CONN_AG_CTX_CF6EN_MASK    0x1
+#define TSTORM_IWARP_CONN_AG_CTX_CF6EN_SHIFT   2
+#define TSTORM_IWARP_CONN_AG_CTX_CF7EN_MASK    0x1
+#define TSTORM_IWARP_CONN_AG_CTX_CF7EN_SHIFT   3
+#define TSTORM_IWARP_CONN_AG_CTX_CF8EN_MASK    0x1
+#define TSTORM_IWARP_CONN_AG_CTX_CF8EN_SHIFT   4
+#define TSTORM_IWARP_CONN_AG_CTX_FLUSH_Q0_EN_MASK      0x1
+#define TSTORM_IWARP_CONN_AG_CTX_FLUSH_Q0_EN_SHIFT     5
+#define TSTORM_IWARP_CONN_AG_CTX_FLUSH_OR_ERROR_DETECTED_EN_MASK       0x1
+#define TSTORM_IWARP_CONN_AG_CTX_FLUSH_OR_ERROR_DETECTED_EN_SHIFT 6
+#define TSTORM_IWARP_CONN_AG_CTX_RULE0EN_MASK  0x1
+#define TSTORM_IWARP_CONN_AG_CTX_RULE0EN_SHIFT 7
+       u8 flags5;
+#define TSTORM_IWARP_CONN_AG_CTX_RULE1EN_MASK  0x1
+#define TSTORM_IWARP_CONN_AG_CTX_RULE1EN_SHIFT 0
+#define TSTORM_IWARP_CONN_AG_CTX_RULE2EN_MASK  0x1
+#define TSTORM_IWARP_CONN_AG_CTX_RULE2EN_SHIFT 1
+#define TSTORM_IWARP_CONN_AG_CTX_RULE3EN_MASK  0x1
+#define TSTORM_IWARP_CONN_AG_CTX_RULE3EN_SHIFT 2
+#define TSTORM_IWARP_CONN_AG_CTX_RULE4EN_MASK  0x1
+#define TSTORM_IWARP_CONN_AG_CTX_RULE4EN_SHIFT 3
+#define TSTORM_IWARP_CONN_AG_CTX_RULE5EN_MASK  0x1
+#define TSTORM_IWARP_CONN_AG_CTX_RULE5EN_SHIFT 4
+#define TSTORM_IWARP_CONN_AG_CTX_SND_SQ_CONS_RULE_MASK 0x1
+#define TSTORM_IWARP_CONN_AG_CTX_SND_SQ_CONS_RULE_SHIFT        5
+#define TSTORM_IWARP_CONN_AG_CTX_RULE7EN_MASK  0x1
+#define TSTORM_IWARP_CONN_AG_CTX_RULE7EN_SHIFT 6
+#define TSTORM_IWARP_CONN_AG_CTX_RULE8EN_MASK  0x1
+#define TSTORM_IWARP_CONN_AG_CTX_RULE8EN_SHIFT 7
+       __le32 reg0;
+       __le32 reg1;
+       __le32 unaligned_nxt_seq;
+       __le32 reg3;
+       __le32 reg4;
+       __le32 reg5;
+       __le32 reg6;
+       __le32 reg7;
+       __le32 reg8;
+       u8 orq_cache_idx;
+       u8 hq_prod;
+       __le16 sq_tx_cons_th;
+       u8 orq_prod;
+       u8 irq_cons;
+       __le16 sq_tx_cons;
+       __le16 conn_dpi;
+       __le16 rq_prod;
+       __le32 snd_seq;
+       __le32 last_hq_sequence;
+};
+
+struct tstorm_iwarp_conn_st_ctx {
+       __le32 reserved[60];
+};
+
+struct mstorm_iwarp_conn_st_ctx {
+       __le32 reserved[32];
+};
+
+struct ustorm_iwarp_conn_st_ctx {
+       __le32 reserved[24];
+};
+
+struct iwarp_conn_context {
+       struct ystorm_iwarp_conn_st_ctx ystorm_st_context;
+       struct regpair ystorm_st_padding[2];
+       struct pstorm_iwarp_conn_st_ctx pstorm_st_context;
+       struct regpair pstorm_st_padding[2];
+       struct xstorm_iwarp_conn_st_ctx xstorm_st_context;
+       struct regpair xstorm_st_padding[2];
+       struct xstorm_iwarp_conn_ag_ctx xstorm_ag_context;
+       struct tstorm_iwarp_conn_ag_ctx tstorm_ag_context;
+       struct timers_context timer_context;
+       struct ustorm_rdma_conn_ag_ctx ustorm_ag_context;
+       struct tstorm_iwarp_conn_st_ctx tstorm_st_context;
+       struct regpair tstorm_st_padding[2];
+       struct mstorm_iwarp_conn_st_ctx mstorm_st_context;
+       struct ustorm_iwarp_conn_st_ctx ustorm_st_context;
+};
+
+struct iwarp_create_qp_ramrod_data {
+       u8 flags;
+#define IWARP_CREATE_QP_RAMROD_DATA_FMR_AND_RESERVED_EN_MASK   0x1
+#define IWARP_CREATE_QP_RAMROD_DATA_FMR_AND_RESERVED_EN_SHIFT 0
+#define IWARP_CREATE_QP_RAMROD_DATA_SIGNALED_COMP_MASK 0x1
+#define IWARP_CREATE_QP_RAMROD_DATA_SIGNALED_COMP_SHIFT        1
+#define IWARP_CREATE_QP_RAMROD_DATA_RDMA_RD_EN_MASK    0x1
+#define IWARP_CREATE_QP_RAMROD_DATA_RDMA_RD_EN_SHIFT   2
+#define IWARP_CREATE_QP_RAMROD_DATA_RDMA_WR_EN_MASK    0x1
+#define IWARP_CREATE_QP_RAMROD_DATA_RDMA_WR_EN_SHIFT   3
+#define IWARP_CREATE_QP_RAMROD_DATA_ATOMIC_EN_MASK     0x1
+#define IWARP_CREATE_QP_RAMROD_DATA_ATOMIC_EN_SHIFT    4
+#define IWARP_CREATE_QP_RAMROD_DATA_SRQ_FLG_MASK       0x1
+#define IWARP_CREATE_QP_RAMROD_DATA_SRQ_FLG_SHIFT      5
+#define IWARP_CREATE_QP_RAMROD_DATA_RESERVED0_MASK     0x3
+#define IWARP_CREATE_QP_RAMROD_DATA_RESERVED0_SHIFT    6
+       u8 reserved1;
+       __le16 pd;
+       __le16 sq_num_pages;
+       __le16 rq_num_pages;
+       __le32 reserved3[2];
+       struct regpair qp_handle_for_cqe;
+       struct rdma_srq_id srq_id;
+       __le32 cq_cid_for_sq;
+       __le32 cq_cid_for_rq;
+       __le16 dpi;
+       __le16 physical_q0;
+       __le16 physical_q1;
+       u8 reserved2[6];
+};
+
+enum iwarp_eqe_async_opcode {
+       IWARP_EVENT_TYPE_ASYNC_CONNECT_COMPLETE,
+       IWARP_EVENT_TYPE_ASYNC_ENHANCED_MPA_REPLY_ARRIVED,
+       IWARP_EVENT_TYPE_ASYNC_MPA_HANDSHAKE_COMPLETE,
+       IWARP_EVENT_TYPE_ASYNC_CID_CLEANED,
+       IWARP_EVENT_TYPE_ASYNC_EXCEPTION_DETECTED,
+       IWARP_EVENT_TYPE_ASYNC_QP_IN_ERROR_STATE,
+       IWARP_EVENT_TYPE_ASYNC_CQ_OVERFLOW,
+       MAX_IWARP_EQE_ASYNC_OPCODE
+};
+
+struct iwarp_eqe_data_mpa_async_completion {
+       __le16 ulp_data_len;
+       u8 reserved[6];
+};
+
+struct iwarp_eqe_data_tcp_async_completion {
+       __le16 ulp_data_len;
+       u8 mpa_handshake_mode;
+       u8 reserved[5];
+};
+
+enum iwarp_eqe_sync_opcode {
+       IWARP_EVENT_TYPE_TCP_OFFLOAD =
+       11,
+       IWARP_EVENT_TYPE_MPA_OFFLOAD,
+       IWARP_EVENT_TYPE_MPA_OFFLOAD_SEND_RTR,
+       IWARP_EVENT_TYPE_CREATE_QP,
+       IWARP_EVENT_TYPE_QUERY_QP,
+       IWARP_EVENT_TYPE_MODIFY_QP,
+       IWARP_EVENT_TYPE_DESTROY_QP,
+       MAX_IWARP_EQE_SYNC_OPCODE
+};
+
+enum iwarp_fw_return_code {
+       IWARP_CONN_ERROR_TCP_CONNECT_INVALID_PACKET = 5,
+       IWARP_CONN_ERROR_TCP_CONNECTION_RST,
+       IWARP_CONN_ERROR_TCP_CONNECT_TIMEOUT,
+       IWARP_CONN_ERROR_MPA_ERROR_REJECT,
+       IWARP_CONN_ERROR_MPA_NOT_SUPPORTED_VER,
+       IWARP_CONN_ERROR_MPA_RST,
+       IWARP_CONN_ERROR_MPA_FIN,
+       IWARP_CONN_ERROR_MPA_RTR_MISMATCH,
+       IWARP_CONN_ERROR_MPA_INSUF_IRD,
+       IWARP_CONN_ERROR_MPA_INVALID_PACKET,
+       IWARP_CONN_ERROR_MPA_LOCAL_ERROR,
+       IWARP_CONN_ERROR_MPA_TIMEOUT,
+       IWARP_CONN_ERROR_MPA_TERMINATE,
+       IWARP_QP_IN_ERROR_GOOD_CLOSE,
+       IWARP_QP_IN_ERROR_BAD_CLOSE,
+       IWARP_EXCEPTION_DETECTED_LLP_CLOSED,
+       IWARP_EXCEPTION_DETECTED_LLP_RESET,
+       IWARP_EXCEPTION_DETECTED_IRQ_FULL,
+       IWARP_EXCEPTION_DETECTED_RQ_EMPTY,
+       IWARP_EXCEPTION_DETECTED_LLP_TIMEOUT,
+       IWARP_EXCEPTION_DETECTED_REMOTE_PROTECTION_ERROR,
+       IWARP_EXCEPTION_DETECTED_CQ_OVERFLOW,
+       IWARP_EXCEPTION_DETECTED_LOCAL_CATASTROPHIC,
+       IWARP_EXCEPTION_DETECTED_LOCAL_ACCESS_ERROR,
+       IWARP_EXCEPTION_DETECTED_REMOTE_OPERATION_ERROR,
+       IWARP_EXCEPTION_DETECTED_TERMINATE_RECEIVED,
+       MAX_IWARP_FW_RETURN_CODE
+};
+
+struct iwarp_init_func_params {
+       u8 ll2_ooo_q_index;
+       u8 reserved1[7];
+};
+
+struct iwarp_init_func_ramrod_data {
+       struct rdma_init_func_ramrod_data rdma;
+       struct tcp_init_params tcp;
+       struct iwarp_init_func_params iwarp;
+};
+
+enum iwarp_modify_qp_new_state_type {
+       IWARP_MODIFY_QP_STATE_CLOSING = 1,
+       IWARP_MODIFY_QP_STATE_ERROR =
+       2,
+       MAX_IWARP_MODIFY_QP_NEW_STATE_TYPE
+};
+
+struct iwarp_modify_qp_ramrod_data {
+       __le16 transition_to_state;
+       __le16 flags;
+#define IWARP_MODIFY_QP_RAMROD_DATA_RDMA_RD_EN_MASK    0x1
+#define IWARP_MODIFY_QP_RAMROD_DATA_RDMA_RD_EN_SHIFT   0
+#define IWARP_MODIFY_QP_RAMROD_DATA_RDMA_WR_EN_MASK    0x1
+#define IWARP_MODIFY_QP_RAMROD_DATA_RDMA_WR_EN_SHIFT   1
+#define IWARP_MODIFY_QP_RAMROD_DATA_ATOMIC_EN_MASK     0x1
+#define IWARP_MODIFY_QP_RAMROD_DATA_ATOMIC_EN_SHIFT    2
+#define IWARP_MODIFY_QP_RAMROD_DATA_STATE_TRANS_EN_MASK        0x1
+#define IWARP_MODIFY_QP_RAMROD_DATA_STATE_TRANS_EN_SHIFT       3
+#define IWARP_MODIFY_QP_RAMROD_DATA_RDMA_OPS_EN_FLG_MASK       0x1
+#define IWARP_MODIFY_QP_RAMROD_DATA_RDMA_OPS_EN_FLG_SHIFT 4
+#define IWARP_MODIFY_QP_RAMROD_DATA_RESERVED_MASK      0x7FF
+#define IWARP_MODIFY_QP_RAMROD_DATA_RESERVED_SHIFT     5
+       __le32 reserved3[3];
+       __le32 reserved4[8];
+};
+
+struct mpa_rq_params {
+       __le32 ird;
+       __le32 ord;
+};
+
+struct mpa_ulp_buffer {
+       struct regpair addr;
+       __le16 len;
+       __le16 reserved[3];
+};
+
+struct mpa_outgoing_params {
+       u8 crc_needed;
+       u8 reject;
+       u8 reserved[6];
+       struct mpa_rq_params out_rq;
+       struct mpa_ulp_buffer outgoing_ulp_buffer;
+};
+
+struct iwarp_mpa_offload_ramrod_data {
+       struct mpa_outgoing_params common;
+       __le32 tcp_cid;
+       u8 mode;
+       u8 tcp_connect_side;
+       u8 rtr_pref;
+#define IWARP_MPA_OFFLOAD_RAMROD_DATA_RTR_SUPPORTED_MASK       0x7
+#define IWARP_MPA_OFFLOAD_RAMROD_DATA_RTR_SUPPORTED_SHIFT 0
+#define IWARP_MPA_OFFLOAD_RAMROD_DATA_RESERVED1_MASK   0x1F
+#define IWARP_MPA_OFFLOAD_RAMROD_DATA_RESERVED1_SHIFT  3
+       u8 reserved2;
+       struct mpa_ulp_buffer incoming_ulp_buffer;
+       struct regpair async_eqe_output_buf;
+       struct regpair handle_for_async;
+       struct regpair shared_queue_addr;
+       u8 stats_counter_id;
+       u8 reserved3[15];
+};
+
+struct iwarp_offload_params {
+       struct mpa_ulp_buffer incoming_ulp_buffer;
+       struct regpair async_eqe_output_buf;
+       struct regpair handle_for_async;
+       __le16 physical_q0;
+       __le16 physical_q1;
+       u8 stats_counter_id;
+       u8 mpa_mode;
+       u8 reserved[10];
+};
+
+struct iwarp_query_qp_output_params {
+       __le32 flags;
+#define IWARP_QUERY_QP_OUTPUT_PARAMS_ERROR_FLG_MASK    0x1
+#define IWARP_QUERY_QP_OUTPUT_PARAMS_ERROR_FLG_SHIFT 0
+#define IWARP_QUERY_QP_OUTPUT_PARAMS_RESERVED0_MASK    0x7FFFFFFF
+#define IWARP_QUERY_QP_OUTPUT_PARAMS_RESERVED0_SHIFT 1
+       u8 reserved1[4];
+};
+
+struct iwarp_query_qp_ramrod_data {
+       struct regpair output_params_addr;
+};
+
+enum iwarp_ramrod_cmd_id {
+       IWARP_RAMROD_CMD_ID_TCP_OFFLOAD =
+       11,
+       IWARP_RAMROD_CMD_ID_MPA_OFFLOAD,
+       IWARP_RAMROD_CMD_ID_MPA_OFFLOAD_SEND_RTR,
+       IWARP_RAMROD_CMD_ID_CREATE_QP,
+       IWARP_RAMROD_CMD_ID_QUERY_QP,
+       IWARP_RAMROD_CMD_ID_MODIFY_QP,
+       IWARP_RAMROD_CMD_ID_DESTROY_QP,
+       MAX_IWARP_RAMROD_CMD_ID
+};
+
+struct iwarp_rxmit_stats_drv {
+       struct regpair tx_go_to_slow_start_event_cnt;
+       struct regpair tx_fast_retransmit_event_cnt;
+};
+
+struct iwarp_tcp_offload_ramrod_data {
+       struct iwarp_offload_params iwarp;
+       struct tcp_offload_params_opt2 tcp;
+};
+
+enum mpa_negotiation_mode {
+       MPA_NEGOTIATION_TYPE_BASIC = 1,
+       MPA_NEGOTIATION_TYPE_ENHANCED = 2,
+       MAX_MPA_NEGOTIATION_MODE
+};
+
+enum mpa_rtr_type {
+       MPA_RTR_TYPE_NONE = 0,
+       MPA_RTR_TYPE_ZERO_SEND = 1,
+       MPA_RTR_TYPE_ZERO_WRITE = 2,
+       MPA_RTR_TYPE_ZERO_SEND_AND_WRITE = 3,
+       MPA_RTR_TYPE_ZERO_READ = 4,
+       MPA_RTR_TYPE_ZERO_SEND_AND_READ = 5,
+       MPA_RTR_TYPE_ZERO_WRITE_AND_READ = 6,
+       MPA_RTR_TYPE_ZERO_SEND_AND_WRITE_AND_READ = 7,
+       MAX_MPA_RTR_TYPE
+};
+
+struct unaligned_opaque_data {
+       __le16 first_mpa_offset;
+       u8 tcp_payload_offset;
+       u8 flags;
+#define UNALIGNED_OPAQUE_DATA_PKT_REACHED_WIN_RIGHT_EDGE_MASK  0x1
+#define UNALIGNED_OPAQUE_DATA_PKT_REACHED_WIN_RIGHT_EDGE_SHIFT 0
+#define UNALIGNED_OPAQUE_DATA_CONNECTION_CLOSED_MASK   0x1
+#define UNALIGNED_OPAQUE_DATA_CONNECTION_CLOSED_SHIFT  1
+#define UNALIGNED_OPAQUE_DATA_RESERVED_MASK    0x3F
+#define UNALIGNED_OPAQUE_DATA_RESERVED_SHIFT   2
+       __le32 cid;
+};
+
+struct mstorm_iwarp_conn_ag_ctx {
+       u8 reserved;
+       u8 state;
+       u8 flags0;
+#define MSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM0_MASK     0x1
+#define MSTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM0_SHIFT    0
+#define MSTORM_IWARP_CONN_AG_CTX_BIT1_MASK     0x1
+#define MSTORM_IWARP_CONN_AG_CTX_BIT1_SHIFT    1
+#define MSTORM_IWARP_CONN_AG_CTX_INV_STAG_DONE_CF_MASK 0x3
+#define MSTORM_IWARP_CONN_AG_CTX_INV_STAG_DONE_CF_SHIFT        2
+#define MSTORM_IWARP_CONN_AG_CTX_CF1_MASK      0x3
+#define MSTORM_IWARP_CONN_AG_CTX_CF1_SHIFT     4
+#define MSTORM_IWARP_CONN_AG_CTX_CF2_MASK      0x3
+#define MSTORM_IWARP_CONN_AG_CTX_CF2_SHIFT     6
+       u8 flags1;
+#define MSTORM_IWARP_CONN_AG_CTX_INV_STAG_DONE_CF_EN_MASK      0x1
+#define MSTORM_IWARP_CONN_AG_CTX_INV_STAG_DONE_CF_EN_SHIFT 0
+#define MSTORM_IWARP_CONN_AG_CTX_CF1EN_MASK    0x1
+#define MSTORM_IWARP_CONN_AG_CTX_CF1EN_SHIFT   1
+#define MSTORM_IWARP_CONN_AG_CTX_CF2EN_MASK    0x1
+#define MSTORM_IWARP_CONN_AG_CTX_CF2EN_SHIFT   2
+#define MSTORM_IWARP_CONN_AG_CTX_RULE0EN_MASK  0x1
+#define MSTORM_IWARP_CONN_AG_CTX_RULE0EN_SHIFT 3
+#define MSTORM_IWARP_CONN_AG_CTX_RULE1EN_MASK  0x1
+#define MSTORM_IWARP_CONN_AG_CTX_RULE1EN_SHIFT 4
+#define MSTORM_IWARP_CONN_AG_CTX_RULE2EN_MASK  0x1
+#define MSTORM_IWARP_CONN_AG_CTX_RULE2EN_SHIFT 5
+#define MSTORM_IWARP_CONN_AG_CTX_RCQ_CONS_EN_MASK      0x1
+#define MSTORM_IWARP_CONN_AG_CTX_RCQ_CONS_EN_SHIFT     6
+#define MSTORM_IWARP_CONN_AG_CTX_RULE4EN_MASK  0x1
+#define MSTORM_IWARP_CONN_AG_CTX_RULE4EN_SHIFT 7
+       __le16 rcq_cons;
+       __le16 rcq_cons_th;
+       __le32 reg0;
+       __le32 reg1;
+};
+
+struct ustorm_iwarp_conn_ag_ctx {
+       u8 reserved;
+       u8 byte1;
+       u8 flags0;
+#define USTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM0_MASK     0x1
+#define USTORM_IWARP_CONN_AG_CTX_EXIST_IN_QM0_SHIFT    0
+#define USTORM_IWARP_CONN_AG_CTX_BIT1_MASK     0x1
+#define USTORM_IWARP_CONN_AG_CTX_BIT1_SHIFT    1
+#define USTORM_IWARP_CONN_AG_CTX_CF0_MASK      0x3
+#define USTORM_IWARP_CONN_AG_CTX_CF0_SHIFT     2
+#define USTORM_IWARP_CONN_AG_CTX_CF1_MASK      0x3
+#define USTORM_IWARP_CONN_AG_CTX_CF1_SHIFT     4
+#define USTORM_IWARP_CONN_AG_CTX_CF2_MASK      0x3
+#define USTORM_IWARP_CONN_AG_CTX_CF2_SHIFT     6
+       u8 flags1;
+#define USTORM_IWARP_CONN_AG_CTX_CF3_MASK      0x3
+#define USTORM_IWARP_CONN_AG_CTX_CF3_SHIFT     0
+#define USTORM_IWARP_CONN_AG_CTX_CQ_ARM_SE_CF_MASK     0x3
+#define USTORM_IWARP_CONN_AG_CTX_CQ_ARM_SE_CF_SHIFT    2
+#define USTORM_IWARP_CONN_AG_CTX_CQ_ARM_CF_MASK        0x3
+#define USTORM_IWARP_CONN_AG_CTX_CQ_ARM_CF_SHIFT       4
+#define USTORM_IWARP_CONN_AG_CTX_CF6_MASK      0x3
+#define USTORM_IWARP_CONN_AG_CTX_CF6_SHIFT     6
+       u8 flags2;
+#define USTORM_IWARP_CONN_AG_CTX_CF0EN_MASK    0x1
+#define USTORM_IWARP_CONN_AG_CTX_CF0EN_SHIFT   0
+#define USTORM_IWARP_CONN_AG_CTX_CF1EN_MASK    0x1
+#define USTORM_IWARP_CONN_AG_CTX_CF1EN_SHIFT   1
+#define USTORM_IWARP_CONN_AG_CTX_CF2EN_MASK    0x1
+#define USTORM_IWARP_CONN_AG_CTX_CF2EN_SHIFT   2
+#define USTORM_IWARP_CONN_AG_CTX_CF3EN_MASK    0x1
+#define USTORM_IWARP_CONN_AG_CTX_CF3EN_SHIFT   3
+#define USTORM_IWARP_CONN_AG_CTX_CQ_ARM_SE_CF_EN_MASK  0x1
+#define USTORM_IWARP_CONN_AG_CTX_CQ_ARM_SE_CF_EN_SHIFT 4
+#define USTORM_IWARP_CONN_AG_CTX_CQ_ARM_CF_EN_MASK     0x1
+#define USTORM_IWARP_CONN_AG_CTX_CQ_ARM_CF_EN_SHIFT    5
+#define USTORM_IWARP_CONN_AG_CTX_CF6EN_MASK    0x1
+#define USTORM_IWARP_CONN_AG_CTX_CF6EN_SHIFT   6
+#define USTORM_IWARP_CONN_AG_CTX_CQ_SE_EN_MASK 0x1
+#define USTORM_IWARP_CONN_AG_CTX_CQ_SE_EN_SHIFT        7
+       u8 flags3;
+#define USTORM_IWARP_CONN_AG_CTX_CQ_EN_MASK    0x1
+#define USTORM_IWARP_CONN_AG_CTX_CQ_EN_SHIFT   0
+#define USTORM_IWARP_CONN_AG_CTX_RULE2EN_MASK  0x1
+#define USTORM_IWARP_CONN_AG_CTX_RULE2EN_SHIFT 1
+#define USTORM_IWARP_CONN_AG_CTX_RULE3EN_MASK  0x1
+#define USTORM_IWARP_CONN_AG_CTX_RULE3EN_SHIFT 2
+#define USTORM_IWARP_CONN_AG_CTX_RULE4EN_MASK  0x1
+#define USTORM_IWARP_CONN_AG_CTX_RULE4EN_SHIFT 3
+#define USTORM_IWARP_CONN_AG_CTX_RULE5EN_MASK  0x1
+#define USTORM_IWARP_CONN_AG_CTX_RULE5EN_SHIFT 4
+#define USTORM_IWARP_CONN_AG_CTX_RULE6EN_MASK  0x1
+#define USTORM_IWARP_CONN_AG_CTX_RULE6EN_SHIFT 5
+#define USTORM_IWARP_CONN_AG_CTX_RULE7EN_MASK  0x1
+#define USTORM_IWARP_CONN_AG_CTX_RULE7EN_SHIFT 6
+#define USTORM_IWARP_CONN_AG_CTX_RULE8EN_MASK  0x1
+#define USTORM_IWARP_CONN_AG_CTX_RULE8EN_SHIFT 7
+       u8 byte2;
+       u8 byte3;
+       __le16 word0;
+       __le16 word1;
+       __le32 cq_cons;
+       __le32 cq_se_prod;
+       __le32 cq_prod;
+       __le32 reg3;
+       __le16 word2;
+       __le16 word3;
+};
+
+struct ystorm_iwarp_conn_ag_ctx {
+       u8 byte0;
+       u8 byte1;
+       u8 flags0;
+#define YSTORM_IWARP_CONN_AG_CTX_BIT0_MASK     0x1
+#define YSTORM_IWARP_CONN_AG_CTX_BIT0_SHIFT    0
+#define YSTORM_IWARP_CONN_AG_CTX_BIT1_MASK     0x1
+#define YSTORM_IWARP_CONN_AG_CTX_BIT1_SHIFT    1
+#define YSTORM_IWARP_CONN_AG_CTX_CF0_MASK      0x3
+#define YSTORM_IWARP_CONN_AG_CTX_CF0_SHIFT     2
+#define YSTORM_IWARP_CONN_AG_CTX_CF1_MASK      0x3
+#define YSTORM_IWARP_CONN_AG_CTX_CF1_SHIFT     4
+#define YSTORM_IWARP_CONN_AG_CTX_CF2_MASK      0x3
+#define YSTORM_IWARP_CONN_AG_CTX_CF2_SHIFT     6
+       u8 flags1;
+#define YSTORM_IWARP_CONN_AG_CTX_CF0EN_MASK    0x1
+#define YSTORM_IWARP_CONN_AG_CTX_CF0EN_SHIFT   0
+#define YSTORM_IWARP_CONN_AG_CTX_CF1EN_MASK    0x1
+#define YSTORM_IWARP_CONN_AG_CTX_CF1EN_SHIFT   1
+#define YSTORM_IWARP_CONN_AG_CTX_CF2EN_MASK    0x1
+#define YSTORM_IWARP_CONN_AG_CTX_CF2EN_SHIFT   2
+#define YSTORM_IWARP_CONN_AG_CTX_RULE0EN_MASK  0x1
+#define YSTORM_IWARP_CONN_AG_CTX_RULE0EN_SHIFT 3
+#define YSTORM_IWARP_CONN_AG_CTX_RULE1EN_MASK  0x1
+#define YSTORM_IWARP_CONN_AG_CTX_RULE1EN_SHIFT 4
+#define YSTORM_IWARP_CONN_AG_CTX_RULE2EN_MASK  0x1
+#define YSTORM_IWARP_CONN_AG_CTX_RULE2EN_SHIFT 5
+#define YSTORM_IWARP_CONN_AG_CTX_RULE3EN_MASK  0x1
+#define YSTORM_IWARP_CONN_AG_CTX_RULE3EN_SHIFT 6
+#define YSTORM_IWARP_CONN_AG_CTX_RULE4EN_MASK  0x1
+#define YSTORM_IWARP_CONN_AG_CTX_RULE4EN_SHIFT 7
+       u8 byte2;
+       u8 byte3;
+       __le16 word0;
+       __le32 reg0;
+       __le32 reg1;
+       __le16 word1;
+       __le16 word2;
+       __le16 word3;
+       __le16 word4;
+       __le32 reg2;
+       __le32 reg3;
+};
+
 struct ystorm_fcoe_conn_st_ctx {
        u8 func_mode;
        u8 cos;
@@ -9222,7 +10411,7 @@ struct xstorm_iscsi_conn_ag_ctx {
        u8 byte13;
        u8 byte14;
        u8 byte15;
-       u8 byte16;
+       u8 ereserved;
        __le16 word11;
        __le32 reg10;
        __le32 reg11;
@@ -10758,6 +11947,8 @@ struct static_init {
        u32 rsrv_persist[5];    /* Persist reserved for MFW upgrades */
 };
 
+#define NVM_MAGIC_VALUE                0x669955aa
+
 enum nvm_image_type {
        NVM_TYPE_TIM1 = 0x01,
        NVM_TYPE_TIM2 = 0x02,
index 0a8fde6299919b3c1e0d7382ac90be30631644e3..b069ad08826924f1fb18efacdcdd03a312f82bf3 100644 (file)
 #include "qed_init_ops.h"
 #include "qed_reg_addr.h"
 
-enum cminterface {
-       MCM_SEC,
-       MCM_PRI,
-       UCM_SEC,
-       UCM_PRI,
-       TCM_SEC,
-       TCM_PRI,
-       YCM_SEC,
-       YCM_PRI,
-       XCM_SEC,
-       XCM_PRI,
-       NUM_OF_CM_INTERFACES
-};
-
-/* general constants */
+/* General constants */
 #define QM_PQ_MEM_4KB(pq_size) (pq_size ? DIV_ROUND_UP((pq_size + 1) * \
                                                        QM_PQ_ELEMENT_SIZE, \
                                                        0x1000) : 0)
 #define QM_PQ_SIZE_256B(pq_size)       (pq_size ? DIV_ROUND_UP(pq_size, \
                                                                0x100) - 1 : 0)
 #define QM_INVALID_PQ_ID                        0xffff
-/* feature enable */
+/* Feature enable */
 #define QM_BYPASS_EN                            1
 #define QM_BYTE_CRD_EN                          1
-/* other PQ constants */
+/* Other PQ constants */
 #define QM_OTHER_PQS_PER_PF                     4
 /* WFQ constants */
 #define QM_WFQ_UPPER_BOUND             62500000
@@ -106,20 +92,21 @@ enum cminterface {
 #define BTB_PURE_LB_FACTOR                      10
 #define BTB_PURE_LB_RATIO                       7
 /* QM stop command constants */
-#define QM_STOP_PQ_MASK_WIDTH                   32
-#define QM_STOP_CMD_ADDR                                0x2
-#define QM_STOP_CMD_STRUCT_SIZE                 2
+#define QM_STOP_PQ_MASK_WIDTH           32
+#define QM_STOP_CMD_ADDR                2
+#define QM_STOP_CMD_STRUCT_SIZE         2
 #define QM_STOP_CMD_PAUSE_MASK_OFFSET   0
 #define QM_STOP_CMD_PAUSE_MASK_SHIFT    0
-#define QM_STOP_CMD_PAUSE_MASK_MASK             -1
-#define QM_STOP_CMD_GROUP_ID_OFFSET             1
-#define QM_STOP_CMD_GROUP_ID_SHIFT              16
-#define QM_STOP_CMD_GROUP_ID_MASK               15
-#define QM_STOP_CMD_PQ_TYPE_OFFSET              1
-#define QM_STOP_CMD_PQ_TYPE_SHIFT               24
-#define QM_STOP_CMD_PQ_TYPE_MASK                1
-#define QM_STOP_CMD_MAX_POLL_COUNT              100
-#define QM_STOP_CMD_POLL_PERIOD_US              500
+#define QM_STOP_CMD_PAUSE_MASK_MASK     -1
+#define QM_STOP_CMD_GROUP_ID_OFFSET     1
+#define QM_STOP_CMD_GROUP_ID_SHIFT      16
+#define QM_STOP_CMD_GROUP_ID_MASK       15
+#define QM_STOP_CMD_PQ_TYPE_OFFSET      1
+#define QM_STOP_CMD_PQ_TYPE_SHIFT       24
+#define QM_STOP_CMD_PQ_TYPE_MASK        1
+#define QM_STOP_CMD_MAX_POLL_COUNT      100
+#define QM_STOP_CMD_POLL_PERIOD_US      500
+
 /* QM command macros */
 #define QM_CMD_STRUCT_SIZE(cmd)                        cmd ## \
        _STRUCT_SIZE
@@ -146,16 +133,17 @@ static void qed_enable_pf_rl(struct qed_hwfn *p_hwfn, bool pf_rl_en)
 {
        STORE_RT_REG(p_hwfn, QM_REG_RLPFENABLE_RT_OFFSET, pf_rl_en ? 1 : 0);
        if (pf_rl_en) {
-               /* enable RLs for all VOQs */
+               /* Enable RLs for all VOQs */
                STORE_RT_REG(p_hwfn, QM_REG_RLPFVOQENABLE_RT_OFFSET,
                             (1 << MAX_NUM_VOQS) - 1);
-               /* write RL period */
+               /* Write RL period */
                STORE_RT_REG(p_hwfn,
                             QM_REG_RLPFPERIOD_RT_OFFSET, QM_RL_PERIOD_CLK_25M);
                STORE_RT_REG(p_hwfn,
                             QM_REG_RLPFPERIODTIMER_RT_OFFSET,
                             QM_RL_PERIOD_CLK_25M);
-               /* set credit threshold for QM bypass flow */
+
+               /* Set credit threshold for QM bypass flow */
                if (QM_BYPASS_EN)
                        STORE_RT_REG(p_hwfn,
                                     QM_REG_AFULLQMBYPTHRPFRL_RT_OFFSET,
@@ -167,7 +155,8 @@ static void qed_enable_pf_rl(struct qed_hwfn *p_hwfn, bool pf_rl_en)
 static void qed_enable_pf_wfq(struct qed_hwfn *p_hwfn, bool pf_wfq_en)
 {
        STORE_RT_REG(p_hwfn, QM_REG_WFQPFENABLE_RT_OFFSET, pf_wfq_en ? 1 : 0);
-       /* set credit threshold for QM bypass flow */
+
+       /* Set credit threshold for QM bypass flow */
        if (pf_wfq_en && QM_BYPASS_EN)
                STORE_RT_REG(p_hwfn,
                             QM_REG_AFULLQMBYPTHRPFWFQ_RT_OFFSET,
@@ -180,14 +169,15 @@ static void qed_enable_vport_rl(struct qed_hwfn *p_hwfn, bool vport_rl_en)
        STORE_RT_REG(p_hwfn, QM_REG_RLGLBLENABLE_RT_OFFSET,
                     vport_rl_en ? 1 : 0);
        if (vport_rl_en) {
-               /* write RL period (use timer 0 only) */
+               /* Write RL period (use timer 0 only) */
                STORE_RT_REG(p_hwfn,
                             QM_REG_RLGLBLPERIOD_0_RT_OFFSET,
                             QM_RL_PERIOD_CLK_25M);
                STORE_RT_REG(p_hwfn,
                             QM_REG_RLGLBLPERIODTIMER_0_RT_OFFSET,
                             QM_RL_PERIOD_CLK_25M);
-               /* set credit threshold for QM bypass flow */
+
+               /* Set credit threshold for QM bypass flow */
                if (QM_BYPASS_EN)
                        STORE_RT_REG(p_hwfn,
                                     QM_REG_AFULLQMBYPTHRGLBLRL_RT_OFFSET,
@@ -200,7 +190,8 @@ static void qed_enable_vport_wfq(struct qed_hwfn *p_hwfn, bool vport_wfq_en)
 {
        STORE_RT_REG(p_hwfn, QM_REG_WFQVPENABLE_RT_OFFSET,
                     vport_wfq_en ? 1 : 0);
-       /* set credit threshold for QM bypass flow */
+
+       /* Set credit threshold for QM bypass flow */
        if (vport_wfq_en && QM_BYPASS_EN)
                STORE_RT_REG(p_hwfn,
                             QM_REG_AFULLQMBYPTHRVPWFQ_RT_OFFSET,
@@ -208,7 +199,7 @@ static void qed_enable_vport_wfq(struct qed_hwfn *p_hwfn, bool vport_wfq_en)
 }
 
 /* Prepare runtime init values to allocate PBF command queue lines for
- * the specified VOQ
+ * the specified VOQ.
  */
 static void qed_cmdq_lines_voq_rt_init(struct qed_hwfn *p_hwfn,
                                       u8 voq, u16 cmdq_lines)
@@ -232,7 +223,7 @@ static void qed_cmdq_lines_rt_init(
 {
        u8 tc, voq, port_id, num_tcs_in_port;
 
-       /* clear PBF lines for all VOQs */
+       /* Clear PBF lines for all VOQs */
        for (voq = 0; voq < MAX_NUM_VOQS; voq++)
                STORE_RT_REG(p_hwfn, PBF_CMDQ_LINES_RT_OFFSET(voq), 0);
        for (port_id = 0; port_id < max_ports_per_engine; port_id++) {
@@ -285,7 +276,7 @@ static void qed_btb_blocks_rt_init(
                if (!port_params[port_id].active)
                        continue;
 
-               /* subtract headroom blocks */
+               /* Subtract headroom blocks */
                usable_blocks = port_params[port_id].num_btb_blocks -
                                BTB_HEADROOM_BLOCKS;
 
@@ -305,7 +296,7 @@ static void qed_btb_blocks_rt_init(
                phys_blocks = (usable_blocks - pure_lb_blocks) /
                              num_tcs_in_port;
 
-               /* init physical TCs */
+               /* Init physical TCs */
                for (tc = 0; tc < NUM_OF_PHYS_TCS; tc++) {
                        if (((port_params[port_id].active_phys_tcs >>
                              tc) & 0x1) != 1)
@@ -317,7 +308,7 @@ static void qed_btb_blocks_rt_init(
                                     phys_blocks);
                }
 
-               /* init pure LB TC */
+               /* Init pure LB TC */
                temp = LB_VOQ(port_id);
                STORE_RT_REG(p_hwfn, PBF_BTB_GUARANTEED_RT_OFFSET(temp),
                             pure_lb_blocks);
@@ -338,24 +329,24 @@ static void qed_tx_pq_map_rt_init(
                            QM_PF_QUEUE_GROUP_SIZE;
        u16 i, pq_id, pq_group;
 
-       /* a bit per Tx PQ indicating if the PQ is associated with a VF */
+       /* A bit per Tx PQ indicating if the PQ is associated with a VF */
        u32 tx_pq_vf_mask[MAX_QM_TX_QUEUES / QM_PF_QUEUE_GROUP_SIZE] = { 0 };
        u32 num_tx_pq_vf_masks = MAX_QM_TX_QUEUES / QM_PF_QUEUE_GROUP_SIZE;
        u32 pq_mem_4kb = QM_PQ_MEM_4KB(p_params->num_pf_cids);
        u32 vport_pq_mem_4kb = QM_PQ_MEM_4KB(p_params->num_vf_cids);
        u32 mem_addr_4kb = base_mem_addr_4kb;
 
-       /* set mapping from PQ group to PF */
+       /* Set mapping from PQ group to PF */
        for (pq_group = first_pq_group; pq_group <= last_pq_group; pq_group++)
                STORE_RT_REG(p_hwfn, QM_REG_PQTX2PF_0_RT_OFFSET + pq_group,
                             (u32)(p_params->pf_id));
-       /* set PQ sizes */
+       /* Set PQ sizes */
        STORE_RT_REG(p_hwfn, QM_REG_MAXPQSIZE_0_RT_OFFSET,
                     QM_PQ_SIZE_256B(p_params->num_pf_cids));
        STORE_RT_REG(p_hwfn, QM_REG_MAXPQSIZE_1_RT_OFFSET,
                     QM_PQ_SIZE_256B(p_params->num_vf_cids));
 
-       /* go over all Tx PQs */
+       /* Go over all Tx PQs */
        for (i = 0, pq_id = p_params->start_pq; i < num_pqs; i++, pq_id++) {
                u8 voq = VOQ(p_params->port_id, p_params->pq_params[i].tc_id,
                             p_params->max_phys_tcs_per_port);
@@ -366,17 +357,18 @@ static void qed_tx_pq_map_rt_init(
                                (p_params->pq_params[i].vport_id <
                                 MAX_QM_GLOBAL_RLS);
 
-               /* update first Tx PQ of VPORT/TC */
+               /* Update first Tx PQ of VPORT/TC */
                u8 vport_id_in_pf = p_params->pq_params[i].vport_id -
                                    p_params->start_vport;
                u16 *pq_ids = &vport_params[vport_id_in_pf].first_tx_pq_id[0];
                u16 first_tx_pq_id = pq_ids[p_params->pq_params[i].tc_id];
 
                if (first_tx_pq_id == QM_INVALID_PQ_ID) {
-                       /* create new VP PQ */
+                       /* Create new VP PQ */
                        pq_ids[p_params->pq_params[i].tc_id] = pq_id;
                        first_tx_pq_id = pq_id;
-                       /* map VP PQ to VOQ and PF */
+
+                       /* Map VP PQ to VOQ and PF */
                        STORE_RT_REG(p_hwfn,
                                     QM_REG_WFQVPMAP_RT_OFFSET +
                                     first_tx_pq_id,
@@ -388,7 +380,7 @@ static void qed_tx_pq_map_rt_init(
                if (p_params->pq_params[i].rl_valid && !rl_valid)
                        DP_NOTICE(p_hwfn,
                                  "Invalid VPORT ID for rate limiter configuration");
-               /* fill PQ map entry */
+               /* Fill PQ map entry */
                memset(&tx_pq_map, 0, sizeof(tx_pq_map));
                SET_FIELD(tx_pq_map.reg, QM_RF_PQ_MAP_PQ_VALID, 1);
                SET_FIELD(tx_pq_map.reg,
@@ -400,18 +392,16 @@ static void qed_tx_pq_map_rt_init(
                SET_FIELD(tx_pq_map.reg, QM_RF_PQ_MAP_VOQ, voq);
                SET_FIELD(tx_pq_map.reg, QM_RF_PQ_MAP_WRR_WEIGHT_GROUP,
                          p_params->pq_params[i].wrr_group);
-               /* write PQ map entry to CAM */
+               /* Write PQ map entry to CAM */
                STORE_RT_REG(p_hwfn, QM_REG_TXPQMAP_RT_OFFSET + pq_id,
                             *((u32 *)&tx_pq_map));
-               /* set base address */
+               /* Set base address */
                STORE_RT_REG(p_hwfn,
                             QM_REG_BASEADDRTXPQ_RT_OFFSET + pq_id,
                             mem_addr_4kb);
-               /* check if VF PQ */
+
+               /* If VF PQ, add indication to PQ VF mask */
                if (is_vf_pq) {
-                       /* if PQ is associated with a VF, add indication
-                        * to PQ VF mask
-                        */
                        tx_pq_vf_mask[pq_id /
                                      QM_PF_QUEUE_GROUP_SIZE] |=
                            BIT((pq_id % QM_PF_QUEUE_GROUP_SIZE));
@@ -421,16 +411,12 @@ static void qed_tx_pq_map_rt_init(
                }
        }
 
-       /* store Tx PQ VF mask to size select register */
-       for (i = 0; i < num_tx_pq_vf_masks; i++) {
-               if (tx_pq_vf_mask[i]) {
-                       u32 addr;
-
-                       addr = QM_REG_MAXPQSIZETXSEL_0_RT_OFFSET + i;
-                       STORE_RT_REG(p_hwfn, addr,
+       /* Store Tx PQ VF mask to size select register */
+       for (i = 0; i < num_tx_pq_vf_masks; i++)
+               if (tx_pq_vf_mask[i])
+                       STORE_RT_REG(p_hwfn,
+                                    QM_REG_MAXPQSIZETXSEL_0_RT_OFFSET + i,
                                     tx_pq_vf_mask[i]);
-               }
-       }
 }
 
 /* Prepare Other PQ mapping runtime init values for the specified PF */
@@ -440,23 +426,25 @@ static void qed_other_pq_map_rt_init(struct qed_hwfn *p_hwfn,
                                     u32 num_pf_cids,
                                     u32 num_tids, u32 base_mem_addr_4kb)
 {
-       u16 i, pq_id;
+       u32 pq_size, pq_mem_4kb, mem_addr_4kb;
+       u16 i, pq_id, pq_group;
 
        /* a single other PQ group is used in each PF,
         * where PQ group i is used in PF i.
         */
-       u16 pq_group = pf_id;
-       u32 pq_size = num_pf_cids + num_tids;
-       u32 pq_mem_4kb = QM_PQ_MEM_4KB(pq_size);
-       u32 mem_addr_4kb = base_mem_addr_4kb;
+       pq_group = pf_id;
+       pq_size = num_pf_cids + num_tids;
+       pq_mem_4kb = QM_PQ_MEM_4KB(pq_size);
+       mem_addr_4kb = base_mem_addr_4kb;
 
-       /* map PQ group to PF */
+       /* Map PQ group to PF */
        STORE_RT_REG(p_hwfn, QM_REG_PQOTHER2PF_0_RT_OFFSET + pq_group,
                     (u32)(pf_id));
-       /* set PQ sizes */
+       /* Set PQ sizes */
        STORE_RT_REG(p_hwfn, QM_REG_MAXPQSIZE_2_RT_OFFSET,
                     QM_PQ_SIZE_256B(pq_size));
-       /* set base address */
+
+       /* Set base address */
        for (i = 0, pq_id = pf_id * QM_PF_QUEUE_GROUP_SIZE;
             i < QM_OTHER_PQS_PER_PF; i++, pq_id++) {
                STORE_RT_REG(p_hwfn,
@@ -485,7 +473,7 @@ static int qed_pf_wfq_rt_init(struct qed_hwfn *p_hwfn,
 
        inc_val = QM_WFQ_INC_VAL(p_params->pf_wfq);
        if (!inc_val || inc_val > QM_WFQ_MAX_INC_VAL) {
-               DP_NOTICE(p_hwfn, "Invalid PF WFQ weight configuration");
+               DP_NOTICE(p_hwfn, "Invalid PF WFQ weight configuration\n");
                return -1;
        }
 
@@ -514,7 +502,7 @@ static int qed_pf_rl_rt_init(struct qed_hwfn *p_hwfn, u8 pf_id, u32 pf_rl)
        u32 inc_val = QM_RL_INC_VAL(pf_rl);
 
        if (inc_val > QM_RL_MAX_INC_VAL) {
-               DP_NOTICE(p_hwfn, "Invalid PF rate limit configuration");
+               DP_NOTICE(p_hwfn, "Invalid PF rate limit configuration\n");
                return -1;
        }
        STORE_RT_REG(p_hwfn, QM_REG_RLPFCRD_RT_OFFSET + pf_id,
@@ -535,7 +523,7 @@ static int qed_vp_wfq_rt_init(struct qed_hwfn *p_hwfn,
        u32 inc_val;
        u8 tc, i;
 
-       /* go over all PF VPORTs */
+       /* Go over all PF VPORTs */
        for (i = 0; i < num_vports; i++) {
 
                if (!vport_params[i].vport_wfq)
@@ -544,7 +532,7 @@ static int qed_vp_wfq_rt_init(struct qed_hwfn *p_hwfn,
                inc_val = QM_WFQ_INC_VAL(vport_params[i].vport_wfq);
                if (inc_val > QM_WFQ_MAX_INC_VAL) {
                        DP_NOTICE(p_hwfn,
-                                 "Invalid VPORT WFQ weight configuration");
+                                 "Invalid VPORT WFQ weight configuration\n");
                        return -1;
                }
 
@@ -578,17 +566,17 @@ static int qed_vport_rl_rt_init(struct qed_hwfn *p_hwfn,
 
        if (start_vport + num_vports >= MAX_QM_GLOBAL_RLS) {
                DP_NOTICE(p_hwfn,
-                         "Invalid VPORT ID for rate limiter configuration");
+                         "Invalid VPORT ID for rate limiter configuration\n");
                return -1;
        }
 
-       /* go over all PF VPORTs */
+       /* Go over all PF VPORTs */
        for (i = 0, vport_id = start_vport; i < num_vports; i++, vport_id++) {
                u32 inc_val = QM_RL_INC_VAL(vport_params[i].vport_rl);
 
                if (inc_val > QM_RL_MAX_INC_VAL) {
                        DP_NOTICE(p_hwfn,
-                                 "Invalid VPORT rate-limit configuration");
+                                 "Invalid VPORT rate-limit configuration\n");
                        return -1;
                }
 
@@ -617,7 +605,7 @@ static bool qed_poll_on_qm_cmd_ready(struct qed_hwfn *p_hwfn,
                reg_val = qed_rd(p_hwfn, p_ptt, QM_REG_SDMCMDREADY);
        }
 
-       /* check if timeout while waiting for SDM command ready */
+       /* Check if timeout while waiting for SDM command ready */
        if (i == QM_STOP_CMD_MAX_POLL_COUNT) {
                DP_VERBOSE(p_hwfn, NETIF_MSG_HW,
                           "Timeout when waiting for QM SDM command ready signal\n");
@@ -701,16 +689,16 @@ int qed_qm_pf_rt_init(struct qed_hwfn *p_hwfn,
                                 QM_OTHER_PQS_PER_PF;
        u8 tc, i;
 
-       /* clear first Tx PQ ID array for each VPORT */
+       /* Clear first Tx PQ ID array for each VPORT */
        for (i = 0; i < p_params->num_vports; i++)
                for (tc = 0; tc < NUM_OF_TCS; tc++)
                        vport_params[i].first_tx_pq_id[tc] = QM_INVALID_PQ_ID;
 
-       /* map Other PQs (if any) */
+       /* Map Other PQs (if any) */
        qed_other_pq_map_rt_init(p_hwfn, p_params->port_id, p_params->pf_id,
                                 p_params->num_pf_cids, p_params->num_tids, 0);
 
-       /* map Tx PQs */
+       /* Map Tx PQs */
        qed_tx_pq_map_rt_init(p_hwfn, p_ptt, p_params, other_mem_size_4kb);
 
        if (p_params->pf_wfq)
@@ -736,7 +724,7 @@ int qed_init_pf_wfq(struct qed_hwfn *p_hwfn,
        u32 inc_val = QM_WFQ_INC_VAL(pf_wfq);
 
        if (!inc_val || inc_val > QM_WFQ_MAX_INC_VAL) {
-               DP_NOTICE(p_hwfn, "Invalid PF WFQ weight configuration");
+               DP_NOTICE(p_hwfn, "Invalid PF WFQ weight configuration\n");
                return -1;
        }
 
@@ -750,7 +738,7 @@ int qed_init_pf_rl(struct qed_hwfn *p_hwfn,
        u32 inc_val = QM_RL_INC_VAL(pf_rl);
 
        if (inc_val > QM_RL_MAX_INC_VAL) {
-               DP_NOTICE(p_hwfn, "Invalid PF rate limit configuration");
+               DP_NOTICE(p_hwfn, "Invalid PF rate limit configuration\n");
                return -1;
        }
 
@@ -766,17 +754,18 @@ int qed_init_vport_wfq(struct qed_hwfn *p_hwfn,
                       struct qed_ptt *p_ptt,
                       u16 first_tx_pq_id[NUM_OF_TCS], u16 vport_wfq)
 {
-       u32 inc_val = QM_WFQ_INC_VAL(vport_wfq);
+       u16 vport_pq_id;
+       u32 inc_val;
        u8 tc;
 
+       inc_val = QM_WFQ_INC_VAL(vport_wfq);
        if (!inc_val || inc_val > QM_WFQ_MAX_INC_VAL) {
-               DP_NOTICE(p_hwfn, "Invalid VPORT WFQ weight configuration");
+               DP_NOTICE(p_hwfn, "Invalid VPORT WFQ weight configuration\n");
                return -1;
        }
 
        for (tc = 0; tc < NUM_OF_TCS; tc++) {
-               u16 vport_pq_id = first_tx_pq_id[tc];
-
+               vport_pq_id = first_tx_pq_id[tc];
                if (vport_pq_id != QM_INVALID_PQ_ID)
                        qed_wr(p_hwfn, p_ptt,
                               QM_REG_WFQVPWEIGHT + vport_pq_id * 4,
@@ -793,12 +782,12 @@ int qed_init_vport_rl(struct qed_hwfn *p_hwfn,
 
        if (vport_id >= MAX_QM_GLOBAL_RLS) {
                DP_NOTICE(p_hwfn,
-                         "Invalid VPORT ID for rate limiter configuration");
+                         "Invalid VPORT ID for rate limiter configuration\n");
                return -1;
        }
 
        if (inc_val > QM_RL_MAX_INC_VAL) {
-               DP_NOTICE(p_hwfn, "Invalid VPORT rate-limit configuration");
+               DP_NOTICE(p_hwfn, "Invalid VPORT rate-limit configuration\n");
                return -1;
        }
 
@@ -818,15 +807,15 @@ bool qed_send_qm_stop_cmd(struct qed_hwfn *p_hwfn,
        u32 cmd_arr[QM_CMD_STRUCT_SIZE(QM_STOP_CMD)] = { 0 };
        u32 pq_mask = 0, last_pq = start_pq + num_pqs - 1, pq_id;
 
-       /* set command's PQ type */
+       /* Set command's PQ type */
        QM_CMD_SET_FIELD(cmd_arr, QM_STOP_CMD, PQ_TYPE, is_tx_pq ? 0 : 1);
 
        for (pq_id = start_pq; pq_id <= last_pq; pq_id++) {
-               /* set PQ bit in mask (stop command only) */
+               /* Set PQ bit in mask (stop command only) */
                if (!is_release_cmd)
                        pq_mask |= (1 << (pq_id % QM_STOP_PQ_MASK_WIDTH));
 
-               /* if last PQ or end of PQ mask, write command */
+               /* If last PQ or end of PQ mask, write command */
                if ((pq_id == last_pq) ||
                    (pq_id % QM_STOP_PQ_MASK_WIDTH ==
                     (QM_STOP_PQ_MASK_WIDTH - 1))) {
@@ -962,8 +951,10 @@ void qed_set_geneve_enable(struct qed_hwfn *p_hwfn,
               ip_geneve_enable ? 1 : 0);
 }
 
+#define T_ETH_PACKET_ACTION_GFT_EVENTID  23
+#define PARSER_ETH_CONN_GFT_ACTION_CM_HDR  272
 #define T_ETH_PACKET_MATCH_RFS_EVENTID 25
-#define PARSER_ETH_CONN_CM_HDR (0x0)
+#define PARSER_ETH_CONN_CM_HDR 0
 #define CAM_LINE_SIZE sizeof(u32)
 #define RAM_LINE_SIZE sizeof(u64)
 #define REG_SIZE sizeof(u32)
@@ -971,40 +962,26 @@ void qed_set_geneve_enable(struct qed_hwfn *p_hwfn,
 void qed_set_rfs_mode_disable(struct qed_hwfn *p_hwfn,
                              struct qed_ptt *p_ptt, u16 pf_id)
 {
-       union gft_cam_line_union camline;
-       struct gft_ram_line ramline;
-       u32 *p_ramline, i;
-
-       p_ramline = (u32 *)&ramline;
+       u32 hw_addr = PRS_REG_GFT_PROFILE_MASK_RAM +
+                     pf_id * RAM_LINE_SIZE;
 
        /*stop using gft logic */
        qed_wr(p_hwfn, p_ptt, PRS_REG_SEARCH_GFT, 0);
        qed_wr(p_hwfn, p_ptt, PRS_REG_CM_HDR_GFT, 0x0);
-       memset(&camline, 0, sizeof(union gft_cam_line_union));
-       qed_wr(p_hwfn, p_ptt, PRS_REG_GFT_CAM + CAM_LINE_SIZE * pf_id,
-              camline.cam_line_mapped.camline);
-       memset(&ramline, 0, sizeof(ramline));
-
-       for (i = 0; i < RAM_LINE_SIZE / REG_SIZE; i++) {
-               u32 hw_addr = PRS_REG_GFT_PROFILE_MASK_RAM;
-
-               hw_addr += (RAM_LINE_SIZE * pf_id + i * REG_SIZE);
-
-               qed_wr(p_hwfn, p_ptt, hw_addr, *(p_ramline + i));
-       }
+       qed_wr(p_hwfn, p_ptt, PRS_REG_GFT_CAM + CAM_LINE_SIZE * pf_id, 0);
+       qed_wr(p_hwfn, p_ptt, hw_addr, 0);
+       qed_wr(p_hwfn, p_ptt, hw_addr + 4, 0);
 }
 
 void qed_set_rfs_mode_enable(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
                             u16 pf_id, bool tcp, bool udp,
                             bool ipv4, bool ipv6)
 {
-       u32 rfs_cm_hdr_event_id, *p_ramline;
        union gft_cam_line_union camline;
        struct gft_ram_line ramline;
-       int i;
+       u32 rfs_cm_hdr_event_id;
 
        rfs_cm_hdr_event_id = qed_rd(p_hwfn, p_ptt, PRS_REG_CM_HDR_GFT);
-       p_ramline = (u32 *)&ramline;
 
        if (!ipv6 && !ipv4)
                DP_NOTICE(p_hwfn,
@@ -1024,18 +1001,20 @@ void qed_set_rfs_mode_enable(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
        qed_wr(p_hwfn, p_ptt, PRS_REG_LOAD_L2_FILTER, 0);
        camline.cam_line_mapped.camline = 0;
 
-       /* cam line is now valid!! */
+       /* Cam line is now valid!! */
        SET_FIELD(camline.cam_line_mapped.camline,
                  GFT_CAM_LINE_MAPPED_VALID, 1);
 
        /* filters are per PF!! */
        SET_FIELD(camline.cam_line_mapped.camline,
-                 GFT_CAM_LINE_MAPPED_PF_ID_MASK, 1);
+                 GFT_CAM_LINE_MAPPED_PF_ID_MASK,
+                 GFT_CAM_LINE_MAPPED_PF_ID_MASK_MASK);
        SET_FIELD(camline.cam_line_mapped.camline,
                  GFT_CAM_LINE_MAPPED_PF_ID, pf_id);
        if (!(tcp && udp)) {
                SET_FIELD(camline.cam_line_mapped.camline,
-                         GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_MASK, 1);
+                         GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_MASK,
+                         GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE_MASK_MASK);
                if (tcp)
                        SET_FIELD(camline.cam_line_mapped.camline,
                                  GFT_CAM_LINE_MAPPED_UPPER_PROTOCOL_TYPE,
@@ -1059,34 +1038,38 @@ void qed_set_rfs_mode_enable(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
                                  GFT_PROFILE_IPV6);
        }
 
-       /* write characteristics to cam */
+       /* Write characteristics to cam */
        qed_wr(p_hwfn, p_ptt, PRS_REG_GFT_CAM + CAM_LINE_SIZE * pf_id,
               camline.cam_line_mapped.camline);
        camline.cam_line_mapped.camline = qed_rd(p_hwfn, p_ptt,
                                                 PRS_REG_GFT_CAM +
                                                 CAM_LINE_SIZE * pf_id);
 
-       /* write line to RAM - compare to filter 4 tuple */
-       ramline.low32bits = 0;
-       ramline.high32bits = 0;
-       SET_FIELD(ramline.high32bits, GFT_RAM_LINE_DST_IP, 1);
-       SET_FIELD(ramline.high32bits, GFT_RAM_LINE_SRC_IP, 1);
-       SET_FIELD(ramline.low32bits, GFT_RAM_LINE_SRC_PORT, 1);
-       SET_FIELD(ramline.low32bits, GFT_RAM_LINE_DST_PORT, 1);
-
-       /* each iteration write to reg */
-       for (i = 0; i < RAM_LINE_SIZE / REG_SIZE; i++)
-               qed_wr(p_hwfn, p_ptt,
-                      PRS_REG_GFT_PROFILE_MASK_RAM + RAM_LINE_SIZE * pf_id +
-                      i * REG_SIZE, *(p_ramline + i));
-
-       /* set default profile so that no filter match will happen */
-       ramline.low32bits = 0xffff;
-       ramline.high32bits = 0xffff;
-
-       for (i = 0; i < RAM_LINE_SIZE / REG_SIZE; i++)
-               qed_wr(p_hwfn, p_ptt,
-                      PRS_REG_GFT_PROFILE_MASK_RAM + RAM_LINE_SIZE *
-                      PRS_GFT_CAM_LINES_NO_MATCH + i * REG_SIZE,
-                      *(p_ramline + i));
+       /* Write line to RAM - compare to filter 4 tuple */
+       ramline.lo = 0;
+       ramline.hi = 0;
+       SET_FIELD(ramline.hi, GFT_RAM_LINE_DST_IP, 1);
+       SET_FIELD(ramline.hi, GFT_RAM_LINE_SRC_IP, 1);
+       SET_FIELD(ramline.hi, GFT_RAM_LINE_OVER_IP_PROTOCOL, 1);
+       SET_FIELD(ramline.lo, GFT_RAM_LINE_ETHERTYPE, 1);
+       SET_FIELD(ramline.lo, GFT_RAM_LINE_SRC_PORT, 1);
+       SET_FIELD(ramline.lo, GFT_RAM_LINE_DST_PORT, 1);
+
+       /* Each iteration write to reg */
+       qed_wr(p_hwfn, p_ptt,
+              PRS_REG_GFT_PROFILE_MASK_RAM + RAM_LINE_SIZE * pf_id,
+              ramline.lo);
+       qed_wr(p_hwfn, p_ptt,
+              PRS_REG_GFT_PROFILE_MASK_RAM + RAM_LINE_SIZE * pf_id + 4,
+              ramline.hi);
+
+       /* Set default profile so that no filter match will happen */
+       qed_wr(p_hwfn, p_ptt,
+              PRS_REG_GFT_PROFILE_MASK_RAM +
+              RAM_LINE_SIZE * PRS_GFT_CAM_LINES_NO_MATCH,
+              ramline.lo);
+       qed_wr(p_hwfn, p_ptt,
+              PRS_REG_GFT_PROFILE_MASK_RAM +
+              RAM_LINE_SIZE * PRS_GFT_CAM_LINES_NO_MATCH + 4,
+              ramline.hi);
 }
index 339c91dfa658e700a570ba55408c9c1a4a445fb6..3897ac0ae835e5c4fde3494d7ca5406176b394ae 100644 (file)
@@ -375,7 +375,6 @@ static int qed_sp_iscsi_conn_offload(struct qed_hwfn *p_hwfn,
                p_tcp->ss_thresh = cpu_to_le32(p_conn->ss_thresh);
                p_tcp->srtt = cpu_to_le16(p_conn->srtt);
                p_tcp->rtt_var = cpu_to_le16(p_conn->rtt_var);
-               p_tcp->ts_time = cpu_to_le32(p_conn->ts_time);
                p_tcp->ts_recent = cpu_to_le32(p_conn->ts_recent);
                p_tcp->ts_recent_age = cpu_to_le32(p_conn->ts_recent_age);
                p_tcp->total_rt = cpu_to_le32(p_conn->total_rt);
@@ -400,8 +399,6 @@ static int qed_sp_iscsi_conn_offload(struct qed_hwfn *p_hwfn,
                p_tcp->mss = cpu_to_le16(p_conn->mss);
                p_tcp->snd_wnd_scale = p_conn->snd_wnd_scale;
                p_tcp->rcv_wnd_scale = p_conn->rcv_wnd_scale;
-               dval = p_conn->ts_ticks_per_second;
-               p_tcp->ts_ticks_per_second = cpu_to_le32(dval);
                wval = p_conn->da_timeout_value;
                p_tcp->da_timeout_value = cpu_to_le16(wval);
                p_tcp->ack_frequency = p_conn->ack_frequency;
index 1ae73b2d6d1e1e7d96abcedc6fbdfa683ed8a566..f14772b9cda37762bda10b06003f7708770cdfab 100644 (file)
 #define QM_REG_WFQPFWEIGHT     0x2f4e80UL
 #define QM_REG_WFQVPWEIGHT     0x2fa000UL
 
-#define PGLCS_REG_DBG_SELECT \
+#define PGLCS_REG_DBG_SELECT_K2 \
        0x001d14UL
-#define PGLCS_REG_DBG_DWORD_ENABLE \
+#define PGLCS_REG_DBG_DWORD_ENABLE_K2 \
        0x001d18UL
-#define PGLCS_REG_DBG_SHIFT \
+#define PGLCS_REG_DBG_SHIFT_K2 \
        0x001d1cUL
-#define PGLCS_REG_DBG_FORCE_VALID \
+#define PGLCS_REG_DBG_FORCE_VALID_K2 \
        0x001d20UL
-#define PGLCS_REG_DBG_FORCE_FRAME \
+#define PGLCS_REG_DBG_FORCE_FRAME_K2 \
        0x001d24UL
 #define MISC_REG_RESET_PL_PDA_VMAIN_1 \
        0x008070UL
        0x009050UL
 #define MISCS_REG_RESET_PL_HV \
        0x009060UL
-#define MISCS_REG_RESET_PL_HV_2        \
+#define MISCS_REG_RESET_PL_HV_2_K2     \
        0x009150UL
 #define DMAE_REG_DBG_SELECT \
        0x00c510UL
        0x0500b0UL
 #define GRC_REG_DBG_FORCE_FRAME        \
        0x0500b4UL
-#define UMAC_REG_DBG_SELECT \
+#define UMAC_REG_DBG_SELECT_K2 \
        0x051094UL
-#define UMAC_REG_DBG_DWORD_ENABLE \
+#define UMAC_REG_DBG_DWORD_ENABLE_K2 \
        0x051098UL
-#define UMAC_REG_DBG_SHIFT \
+#define UMAC_REG_DBG_SHIFT_K2 \
        0x05109cUL
-#define UMAC_REG_DBG_FORCE_VALID \
+#define UMAC_REG_DBG_FORCE_VALID_K2 \
        0x0510a0UL
-#define UMAC_REG_DBG_FORCE_FRAME \
+#define UMAC_REG_DBG_FORCE_FRAME_K2 \
        0x0510a4UL
 #define MCP2_REG_DBG_SELECT \
        0x052400UL
        0x4c160cUL
 #define XYLD_REG_DBG_FORCE_FRAME \
        0x4c1610UL
-#define YULD_REG_DBG_SELECT \
+#define YULD_REG_DBG_SELECT_BB_K2 \
        0x4c9600UL
-#define YULD_REG_DBG_DWORD_ENABLE \
+#define YULD_REG_DBG_DWORD_ENABLE_BB_K2 \
        0x4c9604UL
-#define YULD_REG_DBG_SHIFT \
+#define YULD_REG_DBG_SHIFT_BB_K2 \
        0x4c9608UL
-#define YULD_REG_DBG_FORCE_VALID \
+#define YULD_REG_DBG_FORCE_VALID_BB_K2 \
        0x4c960cUL
-#define YULD_REG_DBG_FORCE_FRAME \
+#define YULD_REG_DBG_FORCE_FRAME_BB_K2 \
        0x4c9610UL
 #define TMLD_REG_DBG_SELECT \
        0x4d1600UL
        0x580710UL
 #define CDU_REG_DBG_FORCE_FRAME        \
        0x580714UL
-#define WOL_REG_DBG_SELECT \
+#define WOL_REG_DBG_SELECT_K2 \
        0x600140UL
-#define WOL_REG_DBG_DWORD_ENABLE \
+#define WOL_REG_DBG_DWORD_ENABLE_K2 \
        0x600144UL
-#define WOL_REG_DBG_SHIFT \
+#define WOL_REG_DBG_SHIFT_K2 \
        0x600148UL
-#define WOL_REG_DBG_FORCE_VALID        \
+#define WOL_REG_DBG_FORCE_VALID_K2 \
        0x60014cUL
-#define WOL_REG_DBG_FORCE_FRAME        \
+#define WOL_REG_DBG_FORCE_FRAME_K2 \
        0x600150UL
-#define BMBN_REG_DBG_SELECT \
+#define BMBN_REG_DBG_SELECT_K2 \
        0x610140UL
-#define BMBN_REG_DBG_DWORD_ENABLE \
+#define BMBN_REG_DBG_DWORD_ENABLE_K2 \
        0x610144UL
-#define BMBN_REG_DBG_SHIFT \
+#define BMBN_REG_DBG_SHIFT_K2 \
        0x610148UL
-#define BMBN_REG_DBG_FORCE_VALID \
+#define BMBN_REG_DBG_FORCE_VALID_K2 \
        0x61014cUL
-#define BMBN_REG_DBG_FORCE_FRAME \
+#define BMBN_REG_DBG_FORCE_FRAME_K2 \
        0x610150UL
-#define NWM_REG_DBG_SELECT \
+#define NWM_REG_DBG_SELECT_K2 \
        0x8000ecUL
-#define NWM_REG_DBG_DWORD_ENABLE \
+#define NWM_REG_DBG_DWORD_ENABLE_K2 \
        0x8000f0UL
-#define NWM_REG_DBG_SHIFT \
+#define NWM_REG_DBG_SHIFT_K2 \
        0x8000f4UL
-#define NWM_REG_DBG_FORCE_VALID        \
+#define NWM_REG_DBG_FORCE_VALID_K2 \
        0x8000f8UL
-#define NWM_REG_DBG_FORCE_FRAME        \
+#define NWM_REG_DBG_FORCE_FRAME_K2\
        0x8000fcUL
 #define PBF_REG_DBG_SELECT \
        0xd80060UL
        0x1901534UL
 #define USEM_REG_DBG_FORCE_FRAME \
        0x1901538UL
-#define NWS_REG_DBG_SELECT \
+#define NWS_REG_DBG_SELECT_K2 \
        0x700128UL
-#define NWS_REG_DBG_DWORD_ENABLE \
+#define NWS_REG_DBG_DWORD_ENABLE_K2 \
        0x70012cUL
-#define NWS_REG_DBG_SHIFT \
+#define NWS_REG_DBG_SHIFT_K2 \
        0x700130UL
-#define NWS_REG_DBG_FORCE_VALID        \
+#define NWS_REG_DBG_FORCE_VALID_K2 \
        0x700134UL
-#define NWS_REG_DBG_FORCE_FRAME        \
+#define NWS_REG_DBG_FORCE_FRAME_K2 \
        0x700138UL
-#define MS_REG_DBG_SELECT \
+#define MS_REG_DBG_SELECT_K2 \
        0x6a0228UL
-#define MS_REG_DBG_DWORD_ENABLE \
+#define MS_REG_DBG_DWORD_ENABLE_K2 \
        0x6a022cUL
-#define MS_REG_DBG_SHIFT \
+#define MS_REG_DBG_SHIFT_K2 \
        0x6a0230UL
-#define MS_REG_DBG_FORCE_VALID \
+#define MS_REG_DBG_FORCE_VALID_K2 \
        0x6a0234UL
-#define MS_REG_DBG_FORCE_FRAME \
+#define MS_REG_DBG_FORCE_FRAME_K2 \
        0x6a0238UL
-#define PCIE_REG_DBG_COMMON_SELECT \
+#define PCIE_REG_DBG_COMMON_SELECT_K2 \
        0x054398UL
-#define PCIE_REG_DBG_COMMON_DWORD_ENABLE \
+#define PCIE_REG_DBG_COMMON_DWORD_ENABLE_K2 \
        0x05439cUL
-#define PCIE_REG_DBG_COMMON_SHIFT \
+#define PCIE_REG_DBG_COMMON_SHIFT_K2 \
        0x0543a0UL
-#define PCIE_REG_DBG_COMMON_FORCE_VALID        \
+#define PCIE_REG_DBG_COMMON_FORCE_VALID_K2 \
        0x0543a4UL
-#define PCIE_REG_DBG_COMMON_FORCE_FRAME        \
+#define PCIE_REG_DBG_COMMON_FORCE_FRAME_K2 \
        0x0543a8UL
 #define MISC_REG_RESET_PL_UA \
        0x008050UL
        0x128170cUL
 #define UCM_REG_SM_TASK_CTX \
        0x1281710UL
-#define XSEM_REG_SLOW_DBG_EMPTY        \
+#define XSEM_REG_SLOW_DBG_EMPTY_BB_K2  \
        0x1401140UL
 #define XSEM_REG_SYNC_DBG_EMPTY        \
        0x1401160UL
-#define XSEM_REG_SLOW_DBG_ACTIVE \
+#define XSEM_REG_SLOW_DBG_ACTIVE_BB_K2 \
        0x1401400UL
-#define XSEM_REG_SLOW_DBG_MODE \
+#define XSEM_REG_SLOW_DBG_MODE_BB_K2 \
        0x1401404UL
-#define XSEM_REG_DBG_FRAME_MODE        \
+#define XSEM_REG_DBG_FRAME_MODE_BB_K2  \
        0x1401408UL
-#define XSEM_REG_DBG_MODE1_CFG \
+#define XSEM_REG_DBG_MODE1_CFG_BB_K2 \
        0x1401420UL
 #define XSEM_REG_FAST_MEMORY \
        0x1440000UL
 #define YSEM_REG_SYNC_DBG_EMPTY        \
        0x1501160UL
-#define YSEM_REG_SLOW_DBG_ACTIVE \
+#define YSEM_REG_SLOW_DBG_ACTIVE_BB_K2 \
        0x1501400UL
-#define YSEM_REG_SLOW_DBG_MODE \
+#define YSEM_REG_SLOW_DBG_MODE_BB_K2 \
        0x1501404UL
-#define YSEM_REG_DBG_FRAME_MODE        \
+#define YSEM_REG_DBG_FRAME_MODE_BB_K2  \
        0x1501408UL
-#define YSEM_REG_DBG_MODE1_CFG \
+#define YSEM_REG_DBG_MODE1_CFG_BB_K2 \
        0x1501420UL
 #define YSEM_REG_FAST_MEMORY \
        0x1540000UL
-#define PSEM_REG_SLOW_DBG_EMPTY        \
+#define PSEM_REG_SLOW_DBG_EMPTY_BB_K2  \
        0x1601140UL
 #define PSEM_REG_SYNC_DBG_EMPTY        \
        0x1601160UL
-#define PSEM_REG_SLOW_DBG_ACTIVE \
+#define PSEM_REG_SLOW_DBG_ACTIVE_BB_K2 \
        0x1601400UL
-#define PSEM_REG_SLOW_DBG_MODE \
+#define PSEM_REG_SLOW_DBG_MODE_BB_K2 \
        0x1601404UL
-#define PSEM_REG_DBG_FRAME_MODE        \
+#define PSEM_REG_DBG_FRAME_MODE_BB_K2  \
        0x1601408UL
-#define PSEM_REG_DBG_MODE1_CFG \
+#define PSEM_REG_DBG_MODE1_CFG_BB_K2 \
        0x1601420UL
 #define PSEM_REG_FAST_MEMORY \
        0x1640000UL
-#define TSEM_REG_SLOW_DBG_EMPTY        \
+#define TSEM_REG_SLOW_DBG_EMPTY_BB_K2  \
        0x1701140UL
 #define TSEM_REG_SYNC_DBG_EMPTY        \
        0x1701160UL
-#define TSEM_REG_SLOW_DBG_ACTIVE \
+#define TSEM_REG_SLOW_DBG_ACTIVE_BB_K2 \
        0x1701400UL
-#define TSEM_REG_SLOW_DBG_MODE \
+#define TSEM_REG_SLOW_DBG_MODE_BB_K2 \
        0x1701404UL
-#define TSEM_REG_DBG_FRAME_MODE        \
+#define TSEM_REG_DBG_FRAME_MODE_BB_K2  \
        0x1701408UL
-#define TSEM_REG_DBG_MODE1_CFG \
+#define TSEM_REG_DBG_MODE1_CFG_BB_K2 \
        0x1701420UL
 #define TSEM_REG_FAST_MEMORY \
        0x1740000UL
-#define MSEM_REG_SLOW_DBG_EMPTY        \
+#define MSEM_REG_SLOW_DBG_EMPTY_BB_K2  \
        0x1801140UL
 #define MSEM_REG_SYNC_DBG_EMPTY        \
        0x1801160UL
-#define MSEM_REG_SLOW_DBG_ACTIVE \
+#define MSEM_REG_SLOW_DBG_ACTIVE_BB_K2 \
        0x1801400UL
-#define MSEM_REG_SLOW_DBG_MODE \
+#define MSEM_REG_SLOW_DBG_MODE_BB_K2 \
        0x1801404UL
-#define MSEM_REG_DBG_FRAME_MODE        \
+#define MSEM_REG_DBG_FRAME_MODE_BB_K2  \
        0x1801408UL
-#define MSEM_REG_DBG_MODE1_CFG \
+#define MSEM_REG_DBG_MODE1_CFG_BB_K2 \
        0x1801420UL
 #define MSEM_REG_FAST_MEMORY \
        0x1840000UL
-#define USEM_REG_SLOW_DBG_EMPTY        \
+#define USEM_REG_SLOW_DBG_EMPTY_BB_K2  \
        0x1901140UL
 #define USEM_REG_SYNC_DBG_EMPTY        \
        0x1901160UL
-#define USEM_REG_SLOW_DBG_ACTIVE \
+#define USEM_REG_SLOW_DBG_ACTIVE_BB_K2 \
        0x1901400UL
-#define USEM_REG_SLOW_DBG_MODE \
+#define USEM_REG_SLOW_DBG_MODE_BB_K2 \
        0x1901404UL
-#define USEM_REG_DBG_FRAME_MODE        \
+#define USEM_REG_DBG_FRAME_MODE_BB_K2  \
        0x1901408UL
-#define USEM_REG_DBG_MODE1_CFG \
+#define USEM_REG_DBG_MODE1_CFG_BB_K2 \
        0x1901420UL
 #define USEM_REG_FAST_MEMORY \
        0x1940000UL
        0x340800UL
 #define BRB_REG_BIG_RAM_DATA \
        0x341500UL
-#define SEM_FAST_REG_STALL_0 \
+#define SEM_FAST_REG_STALL_0_BB_K2 \
        0x000488UL
 #define SEM_FAST_REG_STALLED \
        0x000494UL
        4
 #define MISC_REG_BLOCK_256B_EN \
        0x008c14UL
-#define NWS_REG_NWS_CMU        \
+#define NWS_REG_NWS_CMU_K2     \
        0x720000UL
-#define PHY_NW_IP_REG_PHY0_TOP_TBUS_ADDR_7_0 \
+#define PHY_NW_IP_REG_PHY0_TOP_TBUS_ADDR_7_0_K2 \
        0x000680UL
-#define PHY_NW_IP_REG_PHY0_TOP_TBUS_ADDR_15_8 \
+#define PHY_NW_IP_REG_PHY0_TOP_TBUS_ADDR_15_8_K2 \
        0x000684UL
-#define PHY_NW_IP_REG_PHY0_TOP_TBUS_DATA_7_0 \
+#define PHY_NW_IP_REG_PHY0_TOP_TBUS_DATA_7_0_K2 \
        0x0006c0UL
-#define PHY_NW_IP_REG_PHY0_TOP_TBUS_DATA_11_8 \
+#define PHY_NW_IP_REG_PHY0_TOP_TBUS_DATA_11_8_K2 \
        0x0006c4UL
-#define MS_REG_MS_CMU \
+#define MS_REG_MS_CMU_K2 \
        0x6a4000UL
-#define PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X130 \
+#define PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X130_K2 \
        0x000208UL
-#define PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X132 \
-       0x000210UL
-#define PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X131 \
+#define PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X131_K2 \
        0x00020cUL
-#define PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X133 \
+#define PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X132_K2 \
+       0x000210UL
+#define PHY_SGMII_IP_REG_AHB_CMU_CSR_0_X133_K2 \
        0x000214UL
-#define PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X130 \
+#define PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X130_K2 \
        0x000208UL
-#define PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X131 \
+#define PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X131_K2 \
        0x00020cUL
-#define PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X132 \
+#define PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X132_K2 \
        0x000210UL
-#define PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X133 \
+#define PHY_PCIE_IP_REG_AHB_CMU_CSR_0_X133_K2 \
        0x000214UL
-#define PHY_PCIE_REG_PHY0 \
+#define PHY_PCIE_REG_PHY0_K2 \
        0x620000UL
-#define PHY_PCIE_REG_PHY1 \
+#define PHY_PCIE_REG_PHY1_K2 \
        0x624000UL
 #define NIG_REG_ROCE_DUPLICATE_TO_HOST 0x5088f0UL
 #define PRS_REG_LIGHT_L2_ETHERTYPE_EN 0x1f0968UL
index 56289d7cd306a0255a5d8854f1abb4298d7cd4dd..eb1a5cfc49c0b7a222932cbd88bdb4ec5ed6b078 100644 (file)
@@ -2431,10 +2431,6 @@ qed_rdma_register_tid(void *rdma_cxt,
                          RDMA_REGISTER_TID_RAMROD_DATA_PAGE_SIZE_LOG,
                          params->page_size_log - 12);
 
-       SET_FIELD(p_ramrod->flags,
-                 RDMA_REGISTER_TID_RAMROD_DATA_MAX_ID,
-                 p_hwfn->p_rdma_info->last_tid);
-
        SET_FIELD(p_ramrod->flags,
                  RDMA_REGISTER_TID_RAMROD_DATA_REMOTE_READ,
                  params->remote_read);
index bc3694e91b858af2478d0145bdbb2294840ef5f0..5abcac64d9694930713d4d18c83b334bbc52c2a0 100644 (file)
@@ -185,22 +185,20 @@ static void qed_set_tunn_ports(struct qed_tunnel_info *p_tun,
 }
 
 static void
-__qed_set_ramrod_tunnel_param(u8 *p_tunn_cls, u8 *p_enable_tx_clas,
+__qed_set_ramrod_tunnel_param(u8 *p_tunn_cls,
                              struct qed_tunn_update_type *tun_type)
 {
        *p_tunn_cls = tun_type->tun_cls;
-
-       if (tun_type->b_mode_enabled)
-               *p_enable_tx_clas = 1;
 }
 
 static void
-qed_set_ramrod_tunnel_param(u8 *p_tunn_cls, u8 *p_enable_tx_clas,
+qed_set_ramrod_tunnel_param(u8 *p_tunn_cls,
                            struct qed_tunn_update_type *tun_type,
-                           u8 *p_update_port, __le16 *p_port,
+                           u8 *p_update_port,
+                           __le16 *p_port,
                            struct qed_tunn_update_udp_port *p_udp_port)
 {
-       __qed_set_ramrod_tunnel_param(p_tunn_cls, p_enable_tx_clas, tun_type);
+       __qed_set_ramrod_tunnel_param(p_tunn_cls, tun_type);
        if (p_udp_port->b_update_port) {
                *p_update_port = 1;
                *p_port = cpu_to_le16(p_udp_port->port);
@@ -219,33 +217,27 @@ qed_tunn_set_pf_update_params(struct qed_hwfn *p_hwfn,
        qed_set_tunn_ports(p_tun, p_src);
 
        qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_vxlan,
-                                   &p_tunn_cfg->tx_enable_vxlan,
                                    &p_tun->vxlan,
                                    &p_tunn_cfg->set_vxlan_udp_port_flg,
                                    &p_tunn_cfg->vxlan_udp_port,
                                    &p_tun->vxlan_port);
 
        qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_l2geneve,
-                                   &p_tunn_cfg->tx_enable_l2geneve,
                                    &p_tun->l2_geneve,
                                    &p_tunn_cfg->set_geneve_udp_port_flg,
                                    &p_tunn_cfg->geneve_udp_port,
                                    &p_tun->geneve_port);
 
        __qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_ipgeneve,
-                                     &p_tunn_cfg->tx_enable_ipgeneve,
                                      &p_tun->ip_geneve);
 
        __qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_l2gre,
-                                     &p_tunn_cfg->tx_enable_l2gre,
                                      &p_tun->l2_gre);
 
        __qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_ipgre,
-                                     &p_tunn_cfg->tx_enable_ipgre,
                                      &p_tun->ip_gre);
 
        p_tunn_cfg->update_rx_pf_clss = p_tun->b_update_rx_cls;
-       p_tunn_cfg->update_tx_pf_clss = p_tun->b_update_tx_cls;
 }
 
 static void qed_set_hw_tunn_mode(struct qed_hwfn *p_hwfn,
@@ -289,29 +281,24 @@ qed_tunn_set_pf_start_params(struct qed_hwfn *p_hwfn,
        qed_set_tunn_ports(p_tun, p_src);
 
        qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_vxlan,
-                                   &p_tunn_cfg->tx_enable_vxlan,
                                    &p_tun->vxlan,
                                    &p_tunn_cfg->set_vxlan_udp_port_flg,
                                    &p_tunn_cfg->vxlan_udp_port,
                                    &p_tun->vxlan_port);
 
        qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_l2geneve,
-                                   &p_tunn_cfg->tx_enable_l2geneve,
                                    &p_tun->l2_geneve,
                                    &p_tunn_cfg->set_geneve_udp_port_flg,
                                    &p_tunn_cfg->geneve_udp_port,
                                    &p_tun->geneve_port);
 
        __qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_ipgeneve,
-                                     &p_tunn_cfg->tx_enable_ipgeneve,
                                      &p_tun->ip_geneve);
 
        __qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_l2gre,
-                                     &p_tunn_cfg->tx_enable_l2gre,
                                      &p_tun->l2_gre);
 
        __qed_set_ramrod_tunnel_param(&p_tunn_cfg->tunnel_clss_ipgre,
-                                     &p_tunn_cfg->tx_enable_ipgre,
                                      &p_tun->ip_gre);
 }
 
index d6978cbc56f0586aa8a075191433184c50c93b01..7658138f228341e309de78afb5076aea6b1e4309 100644 (file)
@@ -2099,14 +2099,16 @@ int qedi_iscsi_send_ioreq(struct iscsi_task *task)
        /* Update header info */
        SET_FIELD(cmd_pdu_header.flags_attr, ISCSI_CMD_HDR_ATTR,
                  ISCSI_ATTR_SIMPLE);
-       if (sc->sc_data_direction == DMA_TO_DEVICE) {
-               SET_FIELD(cmd_pdu_header.flags_attr,
-                         ISCSI_CMD_HDR_WRITE, 1);
-               task_type = ISCSI_TASK_TYPE_INITIATOR_WRITE;
-       } else {
-               SET_FIELD(cmd_pdu_header.flags_attr,
-                         ISCSI_CMD_HDR_READ, 1);
-               task_type = ISCSI_TASK_TYPE_INITIATOR_READ;
+       if (hdr->cdb[0] != TEST_UNIT_READY) {
+               if (sc->sc_data_direction == DMA_TO_DEVICE) {
+                       SET_FIELD(cmd_pdu_header.flags_attr,
+                                 ISCSI_CMD_HDR_WRITE, 1);
+                       task_type = ISCSI_TASK_TYPE_INITIATOR_WRITE;
+               } else {
+                       SET_FIELD(cmd_pdu_header.flags_attr,
+                                 ISCSI_CMD_HDR_READ, 1);
+                       task_type = ISCSI_TASK_TYPE_INITIATOR_READ;
+               }
        }
 
        cmd_pdu_header.lun.lo = be32_to_cpu(scsi_lun[0]);
@@ -2117,7 +2119,7 @@ int qedi_iscsi_send_ioreq(struct iscsi_task *task)
        cmd_pdu_header.expected_transfer_length = cpu_to_be32(hdr->data_length);
        cmd_pdu_header.hdr_second_dword = ntoh24(hdr->dlength);
        cmd_pdu_header.cmd_sn = be32_to_cpu(hdr->cmdsn);
-       cmd_pdu_header.opcode = hdr->opcode;
+       cmd_pdu_header.hdr_first_byte = hdr->opcode;
        qedi_cpy_scsi_cdb(sc, (u32 *)cmd_pdu_header.cdb);
 
        /* Fill tx AHS and rx buffer */
index fd354d4e03ebdf7f3ff87b6fc5d2f0c8864d851b..7df32a68bd5437a3be108ef187480e609eb98a40 100644 (file)
@@ -578,7 +578,8 @@ int init_initiator_rw_iscsi_task(struct iscsi_task_params *task_params,
                                          (struct iscsi_common_hdr *)cmd_header,
                                          tx_sgl_params, cmd_params,
                                          dif_task_params);
-       else if (GET_FIELD(cmd_header->flags_attr, ISCSI_CMD_HDR_READ))
+       else if (GET_FIELD(cmd_header->flags_attr, ISCSI_CMD_HDR_READ) ||
+                (task_params->rx_io_size == 0 && task_params->tx_io_size == 0))
                return init_rw_iscsi_task(task_params,
                                          ISCSI_TASK_TYPE_INITIATOR_READ,
                                          conn_params,
index 3548d46f9b275825a9f76765966cf8c943762e88..0c8ccffa4c387921064ffef35c55e236c3b639f2 100644 (file)
@@ -1461,9 +1461,6 @@ static const struct {
        { ISCSI_CONN_ERROR_OUT_OF_SGES_ERROR,
          "out of sge error"
        },
-       { ISCSI_CONN_ERROR_TCP_SEG_PROC_IP_OPTIONS_ERROR,
-         "tcp seg ip options error"
-       },
        { ISCSI_CONN_ERROR_TCP_IP_FRAGMENT_ERROR,
          "tcp ip fragment error"
        },
index fbab6e0514f07bf0f4a9ac481cb712c58d113b7f..a567cbf8c5b465edf3aff52d0454886e3d0239c7 100644 (file)
 
 #define CORE_SPQE_PAGE_SIZE_BYTES      4096
 
-#define MAX_NUM_LL2_RX_QUEUES          32
-#define MAX_NUM_LL2_TX_STATS_COUNTERS  32
+#define MAX_NUM_LL2_RX_QUEUES          48
+#define MAX_NUM_LL2_TX_STATS_COUNTERS  48
 
 #define FW_MAJOR_VERSION       8
-#define FW_MINOR_VERSION       15
-#define FW_REVISION_VERSION    3
+#define FW_MINOR_VERSION       20
+#define FW_REVISION_VERSION    0
 #define FW_ENGINEERING_VERSION 0
 
 /***********************/
 
 #define CDU_VF_FL_SEG_TYPE_OFFSET_REG_TYPE_SHIFT       (12)
 #define CDU_VF_FL_SEG_TYPE_OFFSET_REG_OFFSET_MASK      (0xfff)
+
+#define CDU_CONTEXT_VALIDATION_CFG_ENABLE_SHIFT                        (0)
+#define CDU_CONTEXT_VALIDATION_CFG_VALIDATION_TYPE_SHIFT       (1)
+#define CDU_CONTEXT_VALIDATION_CFG_USE_TYPE                    (2)
+#define CDU_CONTEXT_VALIDATION_CFG_USE_REGION                  (3)
+#define CDU_CONTEXT_VALIDATION_CFG_USE_CID                     (4)
+#define CDU_CONTEXT_VALIDATION_CFG_USE_ACTIVE                  (5)
+
 /*****************/
 /* DQ CONSTANTS  */
 /*****************/
 #define PXP_BAR_DQ     1
 
 /* PTT and GTT */
-#define PXP_NUM_PF_WINDOWS             12
 #define PXP_PER_PF_ENTRY_SIZE          8
 #define PXP_NUM_GLOBAL_WINDOWS         243
 #define PXP_GLOBAL_ENTRY_SIZE          4
 #define PXP_PF_ME_OPAQUE_ADDR          0x1f8
 #define PXP_PF_ME_CONCRETE_ADDR                0x1fc
 
+#define PXP_NUM_PF_WINDOWS     12
 #define PXP_EXTERNAL_BAR_PF_WINDOW_START       0x1000
 #define PXP_EXTERNAL_BAR_PF_WINDOW_NUM         PXP_NUM_PF_WINDOWS
 #define PXP_EXTERNAL_BAR_PF_WINDOW_SINGLE_SIZE 0x1000
 /*****************/
 /* PRM CONSTANTS */
 /*****************/
-#define PRM_DMA_PAD_BYTES_NUM  2
-/******************/
-/* SDMs CONSTANTS */
-/******************/
-#define SDM_OP_GEN_TRIG_NONE   0
-#define SDM_OP_GEN_TRIG_WAKE_THREAD    1
-#define SDM_OP_GEN_TRIG_AGG_INT        2
-#define SDM_OP_GEN_TRIG_LOADER 4
-#define SDM_OP_GEN_TRIG_INDICATE_ERROR 6
-#define SDM_OP_GEN_TRIG_RELEASE_THREAD 7
+#define PRM_DMA_PAD_BYTES_NUM  2
+/*****************/
+/* SDMs CONSTANTS  */
+/*****************/
+
+#define SDM_OP_GEN_TRIG_NONE                    0
+#define SDM_OP_GEN_TRIG_WAKE_THREAD             1
+#define SDM_OP_GEN_TRIG_AGG_INT                 2
+#define SDM_OP_GEN_TRIG_LOADER                  4
+#define SDM_OP_GEN_TRIG_INDICATE_ERROR  6
+#define SDM_OP_GEN_TRIG_INC_ORDER_CNT   9
+
+/********************/
+/* Completion types */
+/********************/
 
 #define SDM_COMP_TYPE_NONE              0
 #define SDM_COMP_TYPE_WAKE_THREAD       1
 #define SDM_COMP_TYPE_INDICATE_ERROR    6
 #define SDM_COMP_TYPE_RELEASE_THREAD    7
 #define SDM_COMP_TYPE_RAM               8
+#define SDM_COMP_TYPE_INC_ORDER_CNT     9
 
-/******************/
-/* PBF CONSTANTS  */
-/******************/
+/*****************/
+/* PBF Constants */
+/*****************/
 
 /* Number of PBF command queue lines. Each line is 32B. */
 #define PBF_MAX_CMD_LINES 3328
@@ -861,7 +875,7 @@ enum db_dest {
 /* Enum of doorbell DPM types */
 enum db_dpm_type {
        DPM_LEGACY,
-       DPM_ROCE,
+       DPM_RDMA,
        DPM_L2_INLINE,
        DPM_L2_BD,
        MAX_DB_DPM_TYPE
@@ -884,8 +898,8 @@ struct db_l2_dpm_data {
 #define DB_L2_DPM_DATA_RESERVED0_SHIFT 27
 #define DB_L2_DPM_DATA_SGE_NUM_MASK    0x7
 #define DB_L2_DPM_DATA_SGE_NUM_SHIFT   28
-#define DB_L2_DPM_DATA_RESERVED1_MASK  0x1
-#define DB_L2_DPM_DATA_RESERVED1_SHIFT 31
+#define DB_L2_DPM_DATA_GFS_SRC_EN_MASK 0x1
+#define DB_L2_DPM_DATA_GFS_SRC_EN_SHIFT        31
 };
 
 /* Structure for SGE in a DPM doorbell of type DPM_L2_BD */
@@ -931,31 +945,33 @@ struct db_pwm_addr {
 };
 
 /* Parameters to RoCE firmware, passed in EDPM doorbell */
-struct db_roce_dpm_params {
+struct db_rdma_dpm_params {
        __le32 params;
-#define DB_ROCE_DPM_PARAMS_SIZE_MASK           0x3F
-#define DB_ROCE_DPM_PARAMS_SIZE_SHIFT          0
-#define DB_ROCE_DPM_PARAMS_DPM_TYPE_MASK       0x3
-#define DB_ROCE_DPM_PARAMS_DPM_TYPE_SHIFT      6
-#define DB_ROCE_DPM_PARAMS_OPCODE_MASK         0xFF
-#define DB_ROCE_DPM_PARAMS_OPCODE_SHIFT                8
-#define DB_ROCE_DPM_PARAMS_WQE_SIZE_MASK       0x7FF
-#define DB_ROCE_DPM_PARAMS_WQE_SIZE_SHIFT      16
-#define DB_ROCE_DPM_PARAMS_RESERVED0_MASK      0x1
-#define DB_ROCE_DPM_PARAMS_RESERVED0_SHIFT     27
-#define DB_ROCE_DPM_PARAMS_COMPLETION_FLG_MASK 0x1
-#define DB_ROCE_DPM_PARAMS_COMPLETION_FLG_SHIFT 28
-#define DB_ROCE_DPM_PARAMS_S_FLG_MASK          0x1
-#define DB_ROCE_DPM_PARAMS_S_FLG_SHIFT         29
-#define DB_ROCE_DPM_PARAMS_RESERVED1_MASK      0x3
-#define DB_ROCE_DPM_PARAMS_RESERVED1_SHIFT     30
+#define DB_RDMA_DPM_PARAMS_SIZE_MASK           0x3F
+#define DB_RDMA_DPM_PARAMS_SIZE_SHIFT          0
+#define DB_RDMA_DPM_PARAMS_DPM_TYPE_MASK       0x3
+#define DB_RDMA_DPM_PARAMS_DPM_TYPE_SHIFT      6
+#define DB_RDMA_DPM_PARAMS_OPCODE_MASK         0xFF
+#define DB_RDMA_DPM_PARAMS_OPCODE_SHIFT                8
+#define DB_RDMA_DPM_PARAMS_WQE_SIZE_MASK       0x7FF
+#define DB_RDMA_DPM_PARAMS_WQE_SIZE_SHIFT      16
+#define DB_RDMA_DPM_PARAMS_RESERVED0_MASK      0x1
+#define DB_RDMA_DPM_PARAMS_RESERVED0_SHIFT     27
+#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_MASK 0x1
+#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_SHIFT 28
+#define DB_RDMA_DPM_PARAMS_S_FLG_MASK          0x1
+#define DB_RDMA_DPM_PARAMS_S_FLG_SHIFT         29
+#define DB_RDMA_DPM_PARAMS_RESERVED1_MASK      0x1
+#define DB_RDMA_DPM_PARAMS_RESERVED1_SHIFT     30
+#define DB_RDMA_DPM_PARAMS_CONN_TYPE_IS_IWARP_MASK     0x1
+#define DB_RDMA_DPM_PARAMS_CONN_TYPE_IS_IWARP_SHIFT    31
 };
 
 /* Structure for doorbell data, in ROCE DPM mode, for 1st db in a DPM burst */
-struct db_roce_dpm_data {
+struct db_rdma_dpm_data {
        __le16 icid;
        __le16 prod_val;
-       struct db_roce_dpm_params params;
+       struct db_rdma_dpm_params params;
 };
 
 /* Igu interrupt command */
@@ -1026,6 +1042,42 @@ struct parsing_and_err_flags {
 #define PARSING_AND_ERR_FLAGS_TUNNELL4CHKSMERROR_SHIFT         15
 };
 
+struct parsing_err_flags {
+       __le16 flags;
+#define PARSING_ERR_FLAGS_MAC_ERROR_MASK                               0x1
+#define PARSING_ERR_FLAGS_MAC_ERROR_SHIFT                              0
+#define PARSING_ERR_FLAGS_TRUNC_ERROR_MASK                             0x1
+#define PARSING_ERR_FLAGS_TRUNC_ERROR_SHIFT                            1
+#define PARSING_ERR_FLAGS_PKT_TOO_SMALL_MASK                           0x1
+#define PARSING_ERR_FLAGS_PKT_TOO_SMALL_SHIFT                          2
+#define PARSING_ERR_FLAGS_ANY_HDR_MISSING_TAG_MASK                     0x1
+#define PARSING_ERR_FLAGS_ANY_HDR_MISSING_TAG_SHIFT                    3
+#define PARSING_ERR_FLAGS_ANY_HDR_IP_VER_MISMTCH_MASK                  0x1
+#define PARSING_ERR_FLAGS_ANY_HDR_IP_VER_MISMTCH_SHIFT                 4
+#define PARSING_ERR_FLAGS_ANY_HDR_IP_V4_HDR_LEN_TOO_SMALL_MASK         0x1
+#define PARSING_ERR_FLAGS_ANY_HDR_IP_V4_HDR_LEN_TOO_SMALL_SHIFT                5
+#define PARSING_ERR_FLAGS_ANY_HDR_IP_BAD_TOTAL_LEN_MASK                        0x1
+#define PARSING_ERR_FLAGS_ANY_HDR_IP_BAD_TOTAL_LEN_SHIFT               6
+#define PARSING_ERR_FLAGS_IP_V4_CHKSM_ERROR_MASK                       0x1
+#define PARSING_ERR_FLAGS_IP_V4_CHKSM_ERROR_SHIFT                      7
+#define PARSING_ERR_FLAGS_ANY_HDR_L4_IP_LEN_MISMTCH_MASK               0x1
+#define PARSING_ERR_FLAGS_ANY_HDR_L4_IP_LEN_MISMTCH_SHIFT              8
+#define PARSING_ERR_FLAGS_ZERO_UDP_IP_V6_CHKSM_MASK                    0x1
+#define PARSING_ERR_FLAGS_ZERO_UDP_IP_V6_CHKSM_SHIFT                   9
+#define PARSING_ERR_FLAGS_INNER_L4_CHKSM_ERROR_MASK                    0x1
+#define PARSING_ERR_FLAGS_INNER_L4_CHKSM_ERROR_SHIFT                   10
+#define PARSING_ERR_FLAGS_ANY_HDR_ZERO_TTL_OR_HOP_LIM_MASK             0x1
+#define PARSING_ERR_FLAGS_ANY_HDR_ZERO_TTL_OR_HOP_LIM_SHIFT            11
+#define PARSING_ERR_FLAGS_NON_8021Q_TAG_EXISTS_IN_BOTH_HDRS_MASK       0x1
+#define PARSING_ERR_FLAGS_NON_8021Q_TAG_EXISTS_IN_BOTH_HDRS_SHIFT      12
+#define PARSING_ERR_FLAGS_GENEVE_OPTION_OVERSIZED_MASK                 0x1
+#define PARSING_ERR_FLAGS_GENEVE_OPTION_OVERSIZED_SHIFT                        13
+#define PARSING_ERR_FLAGS_TUNNEL_IP_V4_CHKSM_ERROR_MASK                        0x1
+#define PARSING_ERR_FLAGS_TUNNEL_IP_V4_CHKSM_ERROR_SHIFT               14
+#define PARSING_ERR_FLAGS_TUNNEL_L4_CHKSM_ERROR_MASK                   0x1
+#define PARSING_ERR_FLAGS_TUNNEL_L4_CHKSM_ERROR_SHIFT                  15
+};
+
 struct pb_context {
        __le32 crc[4];
 };
@@ -1288,39 +1340,56 @@ struct tdif_task_context {
 
 struct timers_context {
        __le32 logical_client_0;
-#define TIMERS_CONTEXT_EXPIRATIONTIMELC0_MASK     0xFFFFFFF
-#define TIMERS_CONTEXT_EXPIRATIONTIMELC0_SHIFT    0
-#define TIMERS_CONTEXT_VALIDLC0_MASK              0x1
-#define TIMERS_CONTEXT_VALIDLC0_SHIFT             28
-#define TIMERS_CONTEXT_ACTIVELC0_MASK             0x1
-#define TIMERS_CONTEXT_ACTIVELC0_SHIFT            29
-#define TIMERS_CONTEXT_RESERVED0_MASK             0x3
-#define TIMERS_CONTEXT_RESERVED0_SHIFT            30
+#define TIMERS_CONTEXT_EXPIRATIONTIMELC0_MASK  0x7FFFFFF
+#define TIMERS_CONTEXT_EXPIRATIONTIMELC0_SHIFT 0
+#define TIMERS_CONTEXT_RESERVED0_MASK          0x1
+#define TIMERS_CONTEXT_RESERVED0_SHIFT         27
+#define TIMERS_CONTEXT_VALIDLC0_MASK           0x1
+#define TIMERS_CONTEXT_VALIDLC0_SHIFT          28
+#define TIMERS_CONTEXT_ACTIVELC0_MASK          0x1
+#define TIMERS_CONTEXT_ACTIVELC0_SHIFT         29
+#define TIMERS_CONTEXT_RESERVED1_MASK          0x3
+#define TIMERS_CONTEXT_RESERVED1_SHIFT         30
        __le32 logical_client_1;
-#define TIMERS_CONTEXT_EXPIRATIONTIMELC1_MASK     0xFFFFFFF
-#define TIMERS_CONTEXT_EXPIRATIONTIMELC1_SHIFT    0
-#define TIMERS_CONTEXT_VALIDLC1_MASK              0x1
-#define TIMERS_CONTEXT_VALIDLC1_SHIFT             28
-#define TIMERS_CONTEXT_ACTIVELC1_MASK             0x1
-#define TIMERS_CONTEXT_ACTIVELC1_SHIFT            29
-#define TIMERS_CONTEXT_RESERVED1_MASK             0x3
-#define TIMERS_CONTEXT_RESERVED1_SHIFT            30
+#define TIMERS_CONTEXT_EXPIRATIONTIMELC1_MASK  0x7FFFFFF
+#define TIMERS_CONTEXT_EXPIRATIONTIMELC1_SHIFT 0
+#define TIMERS_CONTEXT_RESERVED2_MASK          0x1
+#define TIMERS_CONTEXT_RESERVED2_SHIFT         27
+#define TIMERS_CONTEXT_VALIDLC1_MASK           0x1
+#define TIMERS_CONTEXT_VALIDLC1_SHIFT          28
+#define TIMERS_CONTEXT_ACTIVELC1_MASK          0x1
+#define TIMERS_CONTEXT_ACTIVELC1_SHIFT         29
+#define TIMERS_CONTEXT_RESERVED3_MASK          0x3
+#define TIMERS_CONTEXT_RESERVED3_SHIFT         30
        __le32 logical_client_2;
-#define TIMERS_CONTEXT_EXPIRATIONTIMELC2_MASK     0xFFFFFFF
-#define TIMERS_CONTEXT_EXPIRATIONTIMELC2_SHIFT    0
-#define TIMERS_CONTEXT_VALIDLC2_MASK              0x1
-#define TIMERS_CONTEXT_VALIDLC2_SHIFT             28
-#define TIMERS_CONTEXT_ACTIVELC2_MASK             0x1
-#define TIMERS_CONTEXT_ACTIVELC2_SHIFT            29
-#define TIMERS_CONTEXT_RESERVED2_MASK             0x3
-#define TIMERS_CONTEXT_RESERVED2_SHIFT            30
+#define TIMERS_CONTEXT_EXPIRATIONTIMELC2_MASK  0x7FFFFFF
+#define TIMERS_CONTEXT_EXPIRATIONTIMELC2_SHIFT 0
+#define TIMERS_CONTEXT_RESERVED4_MASK          0x1
+#define TIMERS_CONTEXT_RESERVED4_SHIFT         27
+#define TIMERS_CONTEXT_VALIDLC2_MASK           0x1
+#define TIMERS_CONTEXT_VALIDLC2_SHIFT          28
+#define TIMERS_CONTEXT_ACTIVELC2_MASK          0x1
+#define TIMERS_CONTEXT_ACTIVELC2_SHIFT         29
+#define TIMERS_CONTEXT_RESERVED5_MASK          0x3
+#define TIMERS_CONTEXT_RESERVED5_SHIFT         30
        __le32 host_expiration_fields;
-#define TIMERS_CONTEXT_HOSTEXPRIRATIONVALUE_MASK  0xFFFFFFF
-#define TIMERS_CONTEXT_HOSTEXPRIRATIONVALUE_SHIFT 0
-#define TIMERS_CONTEXT_HOSTEXPRIRATIONVALID_MASK  0x1
-#define TIMERS_CONTEXT_HOSTEXPRIRATIONVALID_SHIFT 28
-#define TIMERS_CONTEXT_RESERVED3_MASK             0x7
-#define TIMERS_CONTEXT_RESERVED3_SHIFT            29
+#define TIMERS_CONTEXT_HOSTEXPRIRATIONVALUE_MASK       0x7FFFFFF
+#define TIMERS_CONTEXT_HOSTEXPRIRATIONVALUE_SHIFT      0
+#define TIMERS_CONTEXT_RESERVED6_MASK                  0x1
+#define TIMERS_CONTEXT_RESERVED6_SHIFT                 27
+#define TIMERS_CONTEXT_HOSTEXPRIRATIONVALID_MASK       0x1
+#define TIMERS_CONTEXT_HOSTEXPRIRATIONVALID_SHIFT       28
+#define TIMERS_CONTEXT_RESERVED7_MASK                  0x7
+#define TIMERS_CONTEXT_RESERVED7_SHIFT                 29
 };
+
+enum tunnel_next_protocol {
+       e_unknown = 0,
+       e_l2 = 1,
+       e_ipv4 = 2,
+       e_ipv6 = 3,
+       MAX_TUNNEL_NEXT_PROTOCOL
+};
+
 #endif /* __COMMON_HSI__ */
 #endif
index 34d93eb5bfba346019ba1d2c9014ab8a2fa5fd8f..cb06e6e368e1502e9528bd725909e567e518d0eb 100644 (file)
@@ -75,7 +75,8 @@
        (ETH_NUM_STATISTIC_COUNTERS - 3 * MAX_NUM_VFS / 4)
 
 /* Maximum number of buffers, used for RX packet placement */
-#define ETH_RX_MAX_BUFF_PER_PKT             5
+#define ETH_RX_MAX_BUFF_PER_PKT        5
+#define ETH_RX_BD_THRESHOLD    12
 
 /* num of MAC/VLAN filters */
 #define ETH_NUM_MAC_FILTERS                                     512
index 947a635d04bb57ff15a61f1ee82c41ae27c1d4e5..12fc9e788eea9ab4b3aadc26f56d7f8693c669f6 100644 (file)
@@ -13,7 +13,6 @@
 /*********************/
 
 #define FC_ABTS_REPLY_MAX_PAYLOAD_LEN  12
-#define FCOE_MAX_SIZE_FCP_DATA_SUPER   (8600)
 
 struct fcoe_abts_pkt {
        __le32 abts_rsp_fc_payload_lo;
index 69949f8e354b0447c7950884bd205622a4653ab2..85e086cba639bfd5779237a8db5054cad9956931 100644 (file)
 #define ISCSI_TARGET_MODE 1
 
 /* iSCSI request op codes */
-#define ISCSI_OPCODE_NOP_OUT_NO_IMM                     (0)
-#define ISCSI_OPCODE_NOP_OUT                            ( \
-               ISCSI_OPCODE_NOP_OUT_NO_IMM | 0x40)
-#define ISCSI_OPCODE_SCSI_CMD_NO_IMM            (1)
-#define ISCSI_OPCODE_SCSI_CMD                           ( \
-               ISCSI_OPCODE_SCSI_CMD_NO_IMM | 0x40)
-#define ISCSI_OPCODE_TMF_REQUEST_NO_IMM         (2)
-#define ISCSI_OPCODE_TMF_REQUEST                        ( \
-               ISCSI_OPCODE_TMF_REQUEST_NO_IMM | 0x40)
-#define ISCSI_OPCODE_LOGIN_REQUEST_NO_IMM       (3)
-#define ISCSI_OPCODE_LOGIN_REQUEST                      ( \
-               ISCSI_OPCODE_LOGIN_REQUEST_NO_IMM | 0x40)
-#define ISCSI_OPCODE_TEXT_REQUEST_NO_IMM        (4)
-#define ISCSI_OPCODE_TEXT_REQUEST                       ( \
-               ISCSI_OPCODE_TEXT_REQUEST_NO_IMM | 0x40)
-#define ISCSI_OPCODE_DATA_OUT                           (5)
-#define ISCSI_OPCODE_LOGOUT_REQUEST_NO_IMM      (6)
-#define ISCSI_OPCODE_LOGOUT_REQUEST                     ( \
-               ISCSI_OPCODE_LOGOUT_REQUEST_NO_IMM | 0x40)
+#define ISCSI_OPCODE_NOP_OUT           (0)
+#define ISCSI_OPCODE_SCSI_CMD          (1)
+#define ISCSI_OPCODE_TMF_REQUEST       (2)
+#define ISCSI_OPCODE_LOGIN_REQUEST     (3)
+#define ISCSI_OPCODE_TEXT_REQUEST      (4)
+#define ISCSI_OPCODE_DATA_OUT          (5)
+#define ISCSI_OPCODE_LOGOUT_REQUEST    (6)
 
 /* iSCSI response/messages op codes */
 #define ISCSI_OPCODE_NOP_IN             (0x20)
@@ -172,17 +160,23 @@ struct iscsi_async_msg_hdr {
 struct iscsi_cmd_hdr {
        __le16 reserved1;
        u8 flags_attr;
-#define ISCSI_CMD_HDR_ATTR_MASK           0x7
-#define ISCSI_CMD_HDR_ATTR_SHIFT          0
-#define ISCSI_CMD_HDR_RSRV_MASK           0x3
-#define ISCSI_CMD_HDR_RSRV_SHIFT          3
-#define ISCSI_CMD_HDR_WRITE_MASK          0x1
-#define ISCSI_CMD_HDR_WRITE_SHIFT         5
-#define ISCSI_CMD_HDR_READ_MASK           0x1
-#define ISCSI_CMD_HDR_READ_SHIFT          6
-#define ISCSI_CMD_HDR_FINAL_MASK          0x1
-#define ISCSI_CMD_HDR_FINAL_SHIFT         7
-       u8 opcode;
+#define ISCSI_CMD_HDR_ATTR_MASK                0x7
+#define ISCSI_CMD_HDR_ATTR_SHIFT       0
+#define ISCSI_CMD_HDR_RSRV_MASK                0x3
+#define ISCSI_CMD_HDR_RSRV_SHIFT       3
+#define ISCSI_CMD_HDR_WRITE_MASK       0x1
+#define ISCSI_CMD_HDR_WRITE_SHIFT      5
+#define ISCSI_CMD_HDR_READ_MASK                0x1
+#define ISCSI_CMD_HDR_READ_SHIFT       6
+#define ISCSI_CMD_HDR_FINAL_MASK       0x1
+#define ISCSI_CMD_HDR_FINAL_SHIFT      7
+       u8 hdr_first_byte;
+#define ISCSI_CMD_HDR_OPCODE_MASK      0x3F
+#define ISCSI_CMD_HDR_OPCODE_SHIFT     0
+#define ISCSI_CMD_HDR_IMM_MASK         0x1
+#define ISCSI_CMD_HDR_IMM_SHIFT                6
+#define ISCSI_CMD_HDR_RSRV1_MASK       0x1
+#define ISCSI_CMD_HDR_RSRV1_SHIFT      7
        __le32 hdr_second_dword;
 #define ISCSI_CMD_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
 #define ISCSI_CMD_HDR_DATA_SEG_LEN_SHIFT  0
@@ -790,9 +784,9 @@ enum iscsi_error_types {
        ISCSI_CONN_ERROR_LOCAL_COMPLETION_ERROR,
        ISCSI_CONN_ERROR_DATA_OVERRUN,
        ISCSI_CONN_ERROR_OUT_OF_SGES_ERROR,
-       ISCSI_CONN_ERROR_TCP_SEG_PROC_URG_ERROR,
-       ISCSI_CONN_ERROR_TCP_SEG_PROC_IP_OPTIONS_ERROR,
-       ISCSI_CONN_ERROR_TCP_SEG_PROC_CONNECT_INVALID_WS_OPTION,
+       ISCSI_CONN_ERROR_IP_OPTIONS_ERROR,
+       ISCSI_CONN_ERROR_PRS_ERRORS,
+       ISCSI_CONN_ERROR_CONNECT_INVALID_TCP_OPTION,
        ISCSI_CONN_ERROR_TCP_IP_FRAGMENT_ERROR,
        ISCSI_CONN_ERROR_PROTOCOL_ERR_AHS_LEN,
        ISCSI_CONN_ERROR_PROTOCOL_ERR_AHS_TYPE,
@@ -1304,22 +1298,6 @@ struct ystorm_iscsi_stats_drv {
        struct regpair iscsi_tx_total_pdu_cnt;
 };
 
-struct iscsi_db_data {
-       u8 params;
-#define ISCSI_DB_DATA_DEST_MASK         0x3
-#define ISCSI_DB_DATA_DEST_SHIFT        0
-#define ISCSI_DB_DATA_AGG_CMD_MASK      0x3
-#define ISCSI_DB_DATA_AGG_CMD_SHIFT     2
-#define ISCSI_DB_DATA_BYPASS_EN_MASK    0x1
-#define ISCSI_DB_DATA_BYPASS_EN_SHIFT   4
-#define ISCSI_DB_DATA_RESERVED_MASK     0x1
-#define ISCSI_DB_DATA_RESERVED_SHIFT    5
-#define ISCSI_DB_DATA_AGG_VAL_SEL_MASK  0x3
-#define ISCSI_DB_DATA_AGG_VAL_SEL_SHIFT 6
-       u8 agg_flags;
-       __le16 sq_prod;
-};
-
 struct tstorm_iscsi_task_ag_ctx {
        u8 byte0;
        u8 byte1;
@@ -1398,5 +1376,20 @@ struct tstorm_iscsi_task_ag_ctx {
        __le32 reg1;
        __le32 reg2;
 };
+struct iscsi_db_data {
+       u8 params;
+#define ISCSI_DB_DATA_DEST_MASK         0x3
+#define ISCSI_DB_DATA_DEST_SHIFT        0
+#define ISCSI_DB_DATA_AGG_CMD_MASK      0x3
+#define ISCSI_DB_DATA_AGG_CMD_SHIFT     2
+#define ISCSI_DB_DATA_BYPASS_EN_MASK    0x1
+#define ISCSI_DB_DATA_BYPASS_EN_SHIFT   4
+#define ISCSI_DB_DATA_RESERVED_MASK     0x1
+#define ISCSI_DB_DATA_RESERVED_SHIFT    5
+#define ISCSI_DB_DATA_AGG_VAL_SEL_MASK  0x3
+#define ISCSI_DB_DATA_AGG_VAL_SEL_SHIFT 6
+       u8 agg_flags;
+       __le16 sq_prod;
+};
 
 #endif /* __ISCSI_COMMON__ */
index 72c770f9f6669a5169f1780f8cae524bc6c3e0b4..a9b3050f469c7e9fb466ff4c1ae6d205b2382810 100644 (file)
@@ -42,7 +42,7 @@
 #define RDMA_MAX_SGE_PER_SQ_WQE         (4)
 #define RDMA_MAX_SGE_PER_RQ_WQE         (4)
 
-#define RDMA_MAX_DATA_SIZE_IN_WQE       (0x7FFFFFFF)
+#define RDMA_MAX_DATA_SIZE_IN_WQE      (0x80000000)
 
 #define RDMA_REQ_RD_ATOMIC_ELM_SIZE             (0x50)
 #define RDMA_RESP_RD_ATOMIC_ELM_SIZE    (0x20)
index 866f063026dedc6540d87d595bcacf9071f14681..fe6a33e45977e24eebd348fe2e702c2d837ff0cd 100644 (file)
@@ -37,6 +37,8 @@
 #define ROCE_REQ_MAX_SINGLE_SQ_WQE_SIZE (288)
 
 #define ROCE_MAX_QPS   (32 * 1024)
+#define ROCE_DCQCN_NP_MAX_QPS  (64)
+#define ROCE_DCQCN_RP_MAX_QPS  (64)
 
 enum roce_async_events_type {
        ROCE_ASYNC_EVENT_NONE = 0,
index a5e843268f0e9431eacd07ad5cc74e10be690b0d..dbf7a43c3e1fedc51f823ff53119ea647842588d 100644 (file)
@@ -111,7 +111,6 @@ struct tcp_offload_params {
        __le32 snd_wnd;
        __le32 rcv_wnd;
        __le32 snd_wl1;
-       __le32 ts_time;
        __le32 ts_recent;
        __le32 ts_recent_age;
        __le32 total_rt;
@@ -122,7 +121,7 @@ struct tcp_offload_params {
        u8 ka_probe_cnt;
        u8 rt_cnt;
        __le16 rtt_var;
-       __le16 reserved2;
+       __le16 fw_internal;
        __le32 ka_timeout;
        __le32 ka_interval;
        __le32 max_rt_time;
@@ -130,7 +129,7 @@ struct tcp_offload_params {
        u8 snd_wnd_scale;
        u8 ack_frequency;
        __le16 da_timeout_value;
-       __le32 ts_ticks_per_second;
+       __le32 reserved3[2];
 };
 
 struct tcp_offload_params_opt2 {