From: Rasesh Mody Date: Sun, 20 Oct 2019 05:20:49 +0000 (-0700) Subject: net/qede/base: update FW to 8.40.33.0 X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=58bb1ee4a50a3ce79241e5b033985a5697081fc2;p=dpdk.git net/qede/base: update FW to 8.40.33.0 In our testing we have identified a critical FW bug. Performance is degraded significantly for certain packet sizes with 8.40.25.0 FW. This patch updates the FW to version 8.40.33.0. The updated FW has a fix to performance issue. The patch also adds initialization for FW overlay RAM as part of hardware initialization which is required by the new FW. Fixes: 3b307c55f2ac ("net/qede/base: update FW to 8.40.25.0") Cc: stable@dpdk.org Signed-off-by: Rasesh Mody --- diff --git a/doc/guides/nics/qede.rst b/doc/guides/nics/qede.rst index 471d98014b..2f40457950 100644 --- a/doc/guides/nics/qede.rst +++ b/doc/guides/nics/qede.rst @@ -78,9 +78,9 @@ Supported QLogic Adapters Prerequisites ------------- -- Requires storm firmware version **8.37.7.0**. Firmware may be available +- Requires storm firmware version **8.40.33.0**. Firmware may be available inbox in certain newer Linux distros under the standard directory - ``E.g. /lib/firmware/qed/qed_init_values-8.37.7.0.bin``. + ``E.g. /lib/firmware/qed/qed_init_values-8.40.33.0.bin``. If the required firmware files are not available then download it from `linux-firmware git repository `_ or `QLogic Driver Download Center `_. diff --git a/drivers/net/qede/base/common_hsi.h b/drivers/net/qede/base/common_hsi.h index 74afed1ecc..e230fe5acc 100644 --- a/drivers/net/qede/base/common_hsi.h +++ b/drivers/net/qede/base/common_hsi.h @@ -92,10 +92,10 @@ /****************************************************************************/ -#define FW_MAJOR_VERSION 8 +#define FW_MAJOR_VERSION 8 #define FW_MINOR_VERSION 40 -#define FW_REVISION_VERSION 25 -#define FW_ENGINEERING_VERSION 0 +#define FW_REVISION_VERSION 33 +#define FW_ENGINEERING_VERSION 0 /***********************/ /* COMMON HW CONSTANTS */ diff --git a/drivers/net/qede/base/ecore.h b/drivers/net/qede/base/ecore.h index 925b75cb99..b2077bc46e 100644 --- a/drivers/net/qede/base/ecore.h +++ b/drivers/net/qede/base/ecore.h @@ -29,7 +29,7 @@ #define ECORE_MAJOR_VERSION 8 #define ECORE_MINOR_VERSION 40 -#define ECORE_REVISION_VERSION 18 +#define ECORE_REVISION_VERSION 26 #define ECORE_ENGINEERING_VERSION 0 #define ECORE_VERSION \ @@ -699,6 +699,8 @@ struct ecore_hwfn { */ bool b_en_pacing; + struct phys_mem_desc *fw_overlay_mem; + /* @DPDK */ struct ecore_ptt *p_arfs_ptt; }; diff --git a/drivers/net/qede/base/ecore_dev.c b/drivers/net/qede/base/ecore_dev.c index 2c47aba48a..9d1db14590 100644 --- a/drivers/net/qede/base/ecore_dev.c +++ b/drivers/net/qede/base/ecore_dev.c @@ -1653,6 +1653,7 @@ void ecore_resc_free(struct ecore_dev *p_dev) ecore_dmae_info_free(p_hwfn); ecore_dcbx_info_free(p_hwfn); ecore_dbg_user_data_free(p_hwfn); + ecore_fw_overlay_mem_free(p_hwfn, p_hwfn->fw_overlay_mem); /* @@@TBD Flush work-queue ? */ /* destroy doorbell recovery mechanism */ @@ -3467,6 +3468,8 @@ ecore_hw_init_pf(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, if (rc) return rc; + ecore_fw_overlay_init_ram(p_hwfn, p_ptt, p_hwfn->fw_overlay_mem); + /* Pure runtime initializations - directly to the HW */ ecore_int_igu_init_pure_rt(p_hwfn, p_ptt, true, true); @@ -3494,7 +3497,7 @@ ecore_hw_init_pf(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, if (IS_LEAD_HWFN(p_hwfn)) { rc = ecore_llh_hw_init_pf(p_hwfn, p_ptt, p_params->avoid_eng_affin); - if (rc) + if (rc != ECORE_SUCCESS) return rc; } @@ -3510,7 +3513,6 @@ ecore_hw_init_pf(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, if (rc) { DP_NOTICE(p_hwfn, true, "Function start ramrod failed\n"); - } else { return rc; } prs_reg = ecore_rd(p_hwfn, p_ptt, PRS_REG_SEARCH_TAG1); @@ -3677,6 +3679,8 @@ enum _ecore_status_t ecore_hw_init(struct ecore_dev *p_dev, u32 load_code, resp, param, drv_mb_param; bool b_default_mtu = true; struct ecore_hwfn *p_hwfn; + const u32 *fw_overlays; + u32 fw_overlays_len; enum _ecore_status_t rc = ECORE_SUCCESS; u16 ether_type; int i; @@ -3815,6 +3819,17 @@ enum _ecore_status_t ecore_hw_init(struct ecore_dev *p_dev, */ ecore_pglueb_clear_err(p_hwfn, p_hwfn->p_main_ptt); + fw_overlays = p_dev->fw_data->fw_overlays; + fw_overlays_len = p_dev->fw_data->fw_overlays_len; + p_hwfn->fw_overlay_mem = + ecore_fw_overlay_mem_alloc(p_hwfn, fw_overlays, + fw_overlays_len); + if (!p_hwfn->fw_overlay_mem) { + DP_NOTICE(p_hwfn, false, + "Failed to allocate fw overlay memory\n"); + goto load_err; + } + switch (load_code) { case FW_MSG_CODE_DRV_LOAD_ENGINE: rc = ecore_hw_init_common(p_hwfn, p_hwfn->p_main_ptt, diff --git a/drivers/net/qede/base/ecore_hsi_debug_tools.h b/drivers/net/qede/base/ecore_hsi_debug_tools.h index a959aeea7d..eb72e93cf7 100644 --- a/drivers/net/qede/base/ecore_hsi_debug_tools.h +++ b/drivers/net/qede/base/ecore_hsi_debug_tools.h @@ -917,6 +917,9 @@ enum dbg_grc_params { DBG_GRC_PARAM_NO_FW_VER /* dont read FW/MFW version (0/1) */, DBG_GRC_PARAM_RESERVED3 /* reserved */, DBG_GRC_PARAM_DUMP_MCP_HW_DUMP /* dump MCP HW Dump (0/1) */, + DBG_GRC_PARAM_DUMP_ILT_CDUC /* dump ILT CDUC client (0/1) */, + DBG_GRC_PARAM_DUMP_ILT_CDUT /* dump ILT CDUT client (0/1) */, + DBG_GRC_PARAM_DUMP_CAU_EXT /* dump CAU extended memories (0/1) */, MAX_DBG_GRC_PARAMS }; diff --git a/drivers/net/qede/base/ecore_hw.c b/drivers/net/qede/base/ecore_hw.c index 0aed043bb9..1db39d6a36 100644 --- a/drivers/net/qede/base/ecore_hw.c +++ b/drivers/net/qede/base/ecore_hw.c @@ -712,7 +712,7 @@ static enum _ecore_status_t ecore_dmae_operation_wait(struct ecore_hwfn *p_hwfn) while (*p_hwfn->dmae_info.p_completion_word != DMAE_COMPLETION_VAL) { OSAL_UDELAY(DMAE_MIN_WAIT_TIME); if (++wait_cnt > wait_cnt_limit) { - DP_NOTICE(p_hwfn->p_dev, ECORE_MSG_HW, + DP_NOTICE(p_hwfn->p_dev, false, "Timed-out waiting for operation to" " complete. Completion word is 0x%08x" " expected 0x%08x.\n", @@ -805,7 +805,7 @@ ecore_dmae_execute_sub_operation(struct ecore_hwfn *p_hwfn, length_dw * sizeof(u32), true); if (ecore_status != ECORE_SUCCESS) { - DP_NOTICE(p_hwfn, ECORE_MSG_HW, + DP_NOTICE(p_hwfn, false, "Wait Failed. source_addr 0x%lx, grc_addr 0x%lx, size_in_dwords 0x%x, intermediate buffer 0x%lx.\n", (unsigned long)src_addr, (unsigned long)dst_addr, length_dw, diff --git a/drivers/net/qede/base/ecore_init_fw_funcs.c b/drivers/net/qede/base/ecore_init_fw_funcs.c index fa1e89a86d..6a52f32cc9 100644 --- a/drivers/net/qede/base/ecore_init_fw_funcs.c +++ b/drivers/net/qede/base/ecore_init_fw_funcs.c @@ -2058,3 +2058,141 @@ void ecore_enable_context_validation(struct ecore_hwfn *p_hwfn, ctx_validation = CDU_CONTEXT_VALIDATION_DEFAULT_CFG << 8; ecore_wr(p_hwfn, p_ptt, CDU_REG_TCFC_CTX_VALID0, ctx_validation); } + +#define PHYS_ADDR_DWORDS DIV_ROUND_UP(sizeof(dma_addr_t), 4) +#define OVERLAY_HDR_SIZE_DWORDS (sizeof(struct fw_overlay_buf_hdr) / 4) + +static u32 ecore_get_overlay_addr_ram_addr(struct ecore_hwfn *p_hwfn, + u8 storm_id) +{ + switch (storm_id) { + case 0: return TSEM_REG_FAST_MEMORY + SEM_FAST_REG_INT_RAM + + TSTORM_OVERLAY_BUF_ADDR_OFFSET; + case 1: return MSEM_REG_FAST_MEMORY + SEM_FAST_REG_INT_RAM + + MSTORM_OVERLAY_BUF_ADDR_OFFSET; + case 2: return USEM_REG_FAST_MEMORY + SEM_FAST_REG_INT_RAM + + USTORM_OVERLAY_BUF_ADDR_OFFSET; + case 3: return XSEM_REG_FAST_MEMORY + SEM_FAST_REG_INT_RAM + + XSTORM_OVERLAY_BUF_ADDR_OFFSET; + case 4: return YSEM_REG_FAST_MEMORY + SEM_FAST_REG_INT_RAM + + YSTORM_OVERLAY_BUF_ADDR_OFFSET; + case 5: return PSEM_REG_FAST_MEMORY + SEM_FAST_REG_INT_RAM + + PSTORM_OVERLAY_BUF_ADDR_OFFSET; + + default: return 0; + } +} + +struct phys_mem_desc *ecore_fw_overlay_mem_alloc(struct ecore_hwfn *p_hwfn, + const u32 *const fw_overlay_in_buf, + u32 buf_size_in_bytes) +{ + u32 buf_size = buf_size_in_bytes / sizeof(u32), buf_offset = 0; + struct phys_mem_desc *allocated_mem; + + if (!buf_size) + return OSAL_NULL; + + allocated_mem = (struct phys_mem_desc *)OSAL_ZALLOC(p_hwfn->p_dev, + GFP_KERNEL, + NUM_STORMS * + sizeof(struct phys_mem_desc)); + if (!allocated_mem) + return OSAL_NULL; + + OSAL_MEMSET(allocated_mem, 0, NUM_STORMS * + sizeof(struct phys_mem_desc)); + + /* For each Storm, set physical address in RAM */ + while (buf_offset < buf_size) { + struct phys_mem_desc *storm_mem_desc; + struct fw_overlay_buf_hdr *hdr; + u32 storm_buf_size; + u8 storm_id; + + hdr = + (struct fw_overlay_buf_hdr *)&fw_overlay_in_buf[buf_offset]; + storm_buf_size = GET_FIELD(hdr->data, + FW_OVERLAY_BUF_HDR_BUF_SIZE); + storm_id = GET_FIELD(hdr->data, FW_OVERLAY_BUF_HDR_STORM_ID); + storm_mem_desc = allocated_mem + storm_id; + storm_mem_desc->size = storm_buf_size * sizeof(u32); + + /* Allocate physical memory for Storm's overlays buffer */ + storm_mem_desc->virt_addr = + OSAL_DMA_ALLOC_COHERENT(p_hwfn->p_dev, + &storm_mem_desc->phys_addr, + storm_mem_desc->size); + if (!storm_mem_desc->virt_addr) + break; + + /* Skip overlays buffer header */ + buf_offset += OVERLAY_HDR_SIZE_DWORDS; + + /* Copy Storm's overlays buffer to allocated memory */ + OSAL_MEMCPY(storm_mem_desc->virt_addr, + &fw_overlay_in_buf[buf_offset], + storm_mem_desc->size); + + /* Advance to next Storm */ + buf_offset += storm_buf_size; + } + + /* If memory allocation has failed, free all allocated memory */ + if (buf_offset < buf_size) { + ecore_fw_overlay_mem_free(p_hwfn, allocated_mem); + return OSAL_NULL; + } + + return allocated_mem; +} + +void ecore_fw_overlay_init_ram(struct ecore_hwfn *p_hwfn, + struct ecore_ptt *p_ptt, + struct phys_mem_desc *fw_overlay_mem) +{ + u8 storm_id; + + for (storm_id = 0; storm_id < NUM_STORMS; storm_id++) { + struct phys_mem_desc *storm_mem_desc = + (struct phys_mem_desc *)fw_overlay_mem + storm_id; + u32 ram_addr, i; + + /* Skip Storms with no FW overlays */ + if (!storm_mem_desc->virt_addr) + continue; + + /* Calculate overlay RAM GRC address of current PF */ + ram_addr = ecore_get_overlay_addr_ram_addr(p_hwfn, storm_id) + + sizeof(dma_addr_t) * p_hwfn->rel_pf_id; + + /* Write Storm's overlay physical address to RAM */ + for (i = 0; i < PHYS_ADDR_DWORDS; i++, ram_addr += sizeof(u32)) + ecore_wr(p_hwfn, p_ptt, ram_addr, + ((u32 *)&storm_mem_desc->phys_addr)[i]); + } +} + +void ecore_fw_overlay_mem_free(struct ecore_hwfn *p_hwfn, + struct phys_mem_desc *fw_overlay_mem) +{ + u8 storm_id; + + if (!fw_overlay_mem) + return; + + for (storm_id = 0; storm_id < NUM_STORMS; storm_id++) { + struct phys_mem_desc *storm_mem_desc = + (struct phys_mem_desc *)fw_overlay_mem + storm_id; + + /* Free Storm's physical memory */ + if (storm_mem_desc->virt_addr) + OSAL_DMA_FREE_COHERENT(p_hwfn->p_dev, + storm_mem_desc->virt_addr, + storm_mem_desc->phys_addr, + storm_mem_desc->size); + } + + /* Free allocated virtual memory */ + OSAL_FREE(p_hwfn->p_dev, fw_overlay_mem); +} diff --git a/drivers/net/qede/base/ecore_init_fw_funcs.h b/drivers/net/qede/base/ecore_init_fw_funcs.h index 1d1b107c4d..912451662f 100644 --- a/drivers/net/qede/base/ecore_init_fw_funcs.h +++ b/drivers/net/qede/base/ecore_init_fw_funcs.h @@ -553,5 +553,40 @@ void ecore_set_rdma_error_level(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, u8 assert_level[NUM_STORMS]); +/** + * @brief ecore_fw_overlay_mem_alloc - Allocates and fills the FW overlay memory + * + * @param p_hwfn - HW device data + * @param fw_overlay_in_buf - the input FW overlay buffer. + * @param buf_size - the size of the input FW overlay buffer in bytes. + * must be aligned to dwords. + * @param fw_overlay_out_mem - OUT: a pointer to the allocated overlays memory. + * + * @return a pointer to the allocated overlays memory, or OSAL_NULL in case of + * failures. + */ +struct phys_mem_desc *ecore_fw_overlay_mem_alloc(struct ecore_hwfn *p_hwfn, + const u32 *const fw_overlay_in_buf, + u32 buf_size_in_bytes); + +/** + * @brief ecore_fw_overlay_init_ram - Initializes the FW overlay RAM. + * + * @param p_hwfn - HW device data. + * @param p_ptt - ptt window used for writing the registers. + * @param fw_overlay_mem - the allocated FW overlay memory. + */ +void ecore_fw_overlay_init_ram(struct ecore_hwfn *p_hwfn, + struct ecore_ptt *p_ptt, + struct phys_mem_desc *fw_overlay_mem); + +/** + * @brief ecore_fw_overlay_mem_free - Frees the FW overlay memory. + * + * @param p_hwfn - HW device data. + * @param fw_overlay_mem - the allocated FW overlay memory to free. + */ +void ecore_fw_overlay_mem_free(struct ecore_hwfn *p_hwfn, + struct phys_mem_desc *fw_overlay_mem); #endif diff --git a/drivers/net/qede/base/ecore_int.c b/drivers/net/qede/base/ecore_int.c index b1e127849b..4207b1853e 100644 --- a/drivers/net/qede/base/ecore_int.c +++ b/drivers/net/qede/base/ecore_int.c @@ -192,7 +192,10 @@ static enum _ecore_status_t ecore_pswhst_attn_cb(struct ecore_hwfn *p_hwfn) return ECORE_SUCCESS; } -#define ECORE_GRC_ATTENTION_VALID_BIT (1 << 0) +/* Register GRC_REG_TIMEOUT_ATTN_ACCESS_VALID */ +#define ECORE_GRC_ATTENTION_VALID_BIT_MASK (0x1) +#define ECORE_GRC_ATTENTION_VALID_BIT_SHIFT (0) + #define ECORE_GRC_ATTENTION_ADDRESS_MASK (0x7fffff << 0) #define ECORE_GRC_ATTENTION_RDWR_BIT (1 << 23) #define ECORE_GRC_ATTENTION_MASTER_MASK (0xf << 24) @@ -237,15 +240,14 @@ static enum _ecore_status_t ecore_grc_attn_cb(struct ecore_hwfn *p_hwfn) u32 tmp, tmp2; /* We've already cleared the timeout interrupt register, so we learn - * of interrupts via the validity register. - * Any attention which is not for a timeout event is treated as fatal. + * of interrupts via the validity register. If it is not a timeout do + * nothing. It is too late at this stage to differentiate spurious + * interrupt from fatal grc attention. */ tmp = ecore_rd(p_hwfn, p_hwfn->p_dpc_ptt, GRC_REG_TIMEOUT_ATTN_ACCESS_VALID); - if (!(tmp & ECORE_GRC_ATTENTION_VALID_BIT)) { - rc = ECORE_INVAL; + if (!(GET_FIELD(tmp, ECORE_GRC_ATTENTION_VALID_BIT))) goto out; - } /* Read the GRC timeout information */ tmp = ecore_rd(p_hwfn, p_hwfn->p_dpc_ptt, diff --git a/drivers/net/qede/base/ecore_iro_values.h b/drivers/net/qede/base/ecore_iro_values.h index 6442057ac2..dd73497780 100644 --- a/drivers/net/qede/base/ecore_iro_values.h +++ b/drivers/net/qede/base/ecore_iro_values.h @@ -17,8 +17,8 @@ static const u32 iro_arr[] = { /* offset=0x0, size=0x8 */ 0x00000000, 0x00000000, 0x00080000, /* TSTORM_PORT_STAT_OFFSET(port_id), */ - /* offset=0x3908, mult1=0x88, size=0x88 */ - 0x00003908, 0x00000088, 0x00880000, + /* offset=0x3288, mult1=0x88, size=0x88 */ + 0x00003288, 0x00000088, 0x00880000, /* TSTORM_LL2_PORT_STAT_OFFSET(port_id), */ /* offset=0x58f0, mult1=0x20, size=0x20 */ 0x000058f0, 0x00000020, 0x00200000, @@ -38,38 +38,38 @@ static const u32 iro_arr[] = { /* offset=0x84, mult1=0x8, size=0x2 */ 0x00000084, 0x00000008, 0x00020000, /* XSTORM_PQ_INFO_OFFSET(pq_id), */ - /* offset=0x5618, mult1=0x4, size=0x4 */ - 0x00005618, 0x00000004, 0x00040000, - /* XSTORM_INTEG_TEST_DATA_OFFSET */ - /* offset=0x4cd0, size=0x78 */ - 0x00004cd0, 0x00000000, 0x00780000, + /* offset=0x5718, mult1=0x4, size=0x4 */ + 0x00005718, 0x00000004, 0x00040000, + /* XSTORM_INTEG_TEST_DATA_OFFSET, */ + /* offset=0x4dd0, size=0x78 */ + 0x00004dd0, 0x00000000, 0x00780000, /* YSTORM_INTEG_TEST_DATA_OFFSET */ /* offset=0x3e40, size=0x78 */ 0x00003e40, 0x00000000, 0x00780000, - /* PSTORM_INTEG_TEST_DATA_OFFSET */ - /* offset=0x3e00, size=0x78 */ - 0x00003e00, 0x00000000, 0x00780000, - /* TSTORM_INTEG_TEST_DATA_OFFSET */ - /* offset=0x3890, size=0x78 */ - 0x00003890, 0x00000000, 0x00780000, + /* PSTORM_INTEG_TEST_DATA_OFFSET, */ + /* offset=0x4480, size=0x78 */ + 0x00004480, 0x00000000, 0x00780000, + /* TSTORM_INTEG_TEST_DATA_OFFSET, */ + /* offset=0x3210, size=0x78 */ + 0x00003210, 0x00000000, 0x00780000, /* MSTORM_INTEG_TEST_DATA_OFFSET */ /* offset=0x3b50, size=0x78 */ 0x00003b50, 0x00000000, 0x00780000, /* USTORM_INTEG_TEST_DATA_OFFSET */ /* offset=0x7f58, size=0x78 */ 0x00007f58, 0x00000000, 0x00780000, - /* XSTORM_OVERLAY_BUF_ADDR_OFFSET */ - /* offset=0x5e58, size=0x8 */ - 0x00005e58, 0x00000000, 0x00080000, + /* XSTORM_OVERLAY_BUF_ADDR_OFFSET, */ + /* offset=0x5f58, size=0x8 */ + 0x00005f58, 0x00000000, 0x00080000, /* YSTORM_OVERLAY_BUF_ADDR_OFFSET */ /* offset=0x7100, size=0x8 */ 0x00007100, 0x00000000, 0x00080000, - /* PSTORM_OVERLAY_BUF_ADDR_OFFSET */ - /* offset=0xa820, size=0x8 */ - 0x0000a820, 0x00000000, 0x00080000, - /* TSTORM_OVERLAY_BUF_ADDR_OFFSET */ - /* offset=0x4a18, size=0x8 */ - 0x00004a18, 0x00000000, 0x00080000, + /* PSTORM_OVERLAY_BUF_ADDR_OFFSET, */ + /* offset=0xaea0, size=0x8 */ + 0x0000aea0, 0x00000000, 0x00080000, + /* TSTORM_OVERLAY_BUF_ADDR_OFFSET, */ + /* offset=0x4398, size=0x8 */ + 0x00004398, 0x00000000, 0x00080000, /* MSTORM_OVERLAY_BUF_ADDR_OFFSET */ /* offset=0xa5a0, size=0x8 */ 0x0000a5a0, 0x00000000, 0x00080000, @@ -86,8 +86,8 @@ static const u32 iro_arr[] = { /* offset=0xc210, mult1=0x30, size=0x30 */ 0x0000c210, 0x00000030, 0x00300000, /* CORE_LL2_PSTORM_PER_QUEUE_STAT_OFFSET(core_tx_stats_id), */ - /* offset=0xaa08, mult1=0x38, size=0x38 */ - 0x0000aa08, 0x00000038, 0x00380000, + /* offset=0xb088, mult1=0x38, size=0x38 */ + 0x0000b088, 0x00000038, 0x00380000, /* MSTORM_QUEUE_STAT_OFFSET(stat_counter_id), */ /* offset=0x3d20, mult1=0x80, size=0x40 */ 0x00003d20, 0x00000080, 0x00400000, @@ -110,20 +110,20 @@ static const u32 iro_arr[] = { /* offset=0xe840, mult1=0x60, size=0x60 */ 0x0000e840, 0x00000060, 0x00600000, /* PSTORM_QUEUE_STAT_OFFSET(stat_counter_id), */ - /* offset=0x3f98, mult1=0x80, size=0x38 */ - 0x00003f98, 0x00000080, 0x00380000, + /* offset=0x4618, mult1=0x80, size=0x38 */ + 0x00004618, 0x00000080, 0x00380000, /* PSTORM_ETH_PF_STAT_OFFSET(pf_id), */ - /* offset=0x100b8, mult1=0xc0, size=0xc0 */ - 0x000100b8, 0x000000c0, 0x00c00000, + /* offset=0x10738, mult1=0xc0, size=0xc0 */ + 0x00010738, 0x000000c0, 0x00c00000, /* PSTORM_CTL_FRAME_ETHTYPE_OFFSET(ethType_id), */ /* offset=0x1f8, mult1=0x2, size=0x2 */ 0x000001f8, 0x00000002, 0x00020000, - /* TSTORM_ETH_PRS_INPUT_OFFSET */ - /* offset=0xa2a0, size=0x108 */ - 0x0000a2a0, 0x00000000, 0x01080000, + /* TSTORM_ETH_PRS_INPUT_OFFSET, */ + /* offset=0xa2a8, size=0x108 */ + 0x0000a2a8, 0x00000000, 0x01080000, /* ETH_RX_RATE_LIMIT_OFFSET(pf_id), */ - /* offset=0xa3a8, mult1=0x8, size=0x8 */ - 0x0000a3a8, 0x00000008, 0x00080000, + /* offset=0xa3b0, mult1=0x8, size=0x8 */ + 0x0000a3b0, 0x00000008, 0x00080000, /* TSTORM_ETH_RSS_UPDATE_OFFSET(pf_id), */ /* offset=0x1c0, mult1=0x8, size=0x8 */ 0x000001c0, 0x00000008, 0x00080000, @@ -149,8 +149,8 @@ static const u32 iro_arr[] = { /* offset=0xb78, mult1=0x18, mult2=0x8, size=0x2 */ 0x00000b78, 0x00080018, 0x00020000, /* TSTORM_ISCSI_RX_STATS_OFFSET(storage_func_id), */ - /* offset=0xc640, mult1=0x50, size=0x3c */ - 0x0000c640, 0x00000050, 0x003c0000, + /* offset=0xc648, mult1=0x50, size=0x3c */ + 0x0000c648, 0x00000050, 0x003c0000, /* MSTORM_ISCSI_RX_STATS_OFFSET(storage_func_id), */ /* offset=0x12038, mult1=0x18, size=0x10 */ 0x00012038, 0x00000018, 0x00100000, @@ -158,38 +158,38 @@ static const u32 iro_arr[] = { /* offset=0x11b00, mult1=0x40, size=0x18 */ 0x00011b00, 0x00000040, 0x00180000, /* XSTORM_ISCSI_TX_STATS_OFFSET(storage_func_id), */ - /* offset=0x94d0, mult1=0x50, size=0x20 */ - 0x000094d0, 0x00000050, 0x00200000, + /* offset=0x95d0, mult1=0x50, size=0x20 */ + 0x000095d0, 0x00000050, 0x00200000, /* YSTORM_ISCSI_TX_STATS_OFFSET(storage_func_id), */ /* offset=0x8b10, mult1=0x40, size=0x28 */ 0x00008b10, 0x00000040, 0x00280000, /* PSTORM_ISCSI_TX_STATS_OFFSET(storage_func_id), */ - /* offset=0x10fc0, mult1=0x18, size=0x10 */ - 0x00010fc0, 0x00000018, 0x00100000, + /* offset=0x11640, mult1=0x18, size=0x10 */ + 0x00011640, 0x00000018, 0x00100000, /* TSTORM_FCOE_RX_STATS_OFFSET(pf_id), */ - /* offset=0xc828, mult1=0x48, size=0x38 */ - 0x0000c828, 0x00000048, 0x00380000, + /* offset=0xc830, mult1=0x48, size=0x38 */ + 0x0000c830, 0x00000048, 0x00380000, /* PSTORM_FCOE_TX_STATS_OFFSET(pf_id), */ - /* offset=0x11090, mult1=0x20, size=0x20 */ - 0x00011090, 0x00000020, 0x00200000, + /* offset=0x11710, mult1=0x20, size=0x20 */ + 0x00011710, 0x00000020, 0x00200000, /* PSTORM_RDMA_QUEUE_STAT_OFFSET(rdma_stat_counter_id), */ - /* offset=0x3fd0, mult1=0x80, size=0x10 */ - 0x00003fd0, 0x00000080, 0x00100000, + /* offset=0x4650, mult1=0x80, size=0x10 */ + 0x00004650, 0x00000080, 0x00100000, /* TSTORM_RDMA_QUEUE_STAT_OFFSET(rdma_stat_counter_id), */ - /* offset=0x3c98, mult1=0x10, size=0x10 */ - 0x00003c98, 0x00000010, 0x00100000, + /* offset=0x3618, mult1=0x10, size=0x10 */ + 0x00003618, 0x00000010, 0x00100000, /* XSTORM_RDMA_ASSERT_LEVEL_OFFSET(pf_id), */ - /* offset=0xa868, mult1=0x8, size=0x1 */ - 0x0000a868, 0x00000008, 0x00010000, + /* offset=0xa968, mult1=0x8, size=0x1 */ + 0x0000a968, 0x00000008, 0x00010000, /* YSTORM_RDMA_ASSERT_LEVEL_OFFSET(pf_id), */ /* offset=0x97a0, mult1=0x8, size=0x1 */ 0x000097a0, 0x00000008, 0x00010000, /* PSTORM_RDMA_ASSERT_LEVEL_OFFSET(pf_id), */ - /* offset=0x11310, mult1=0x8, size=0x1 */ - 0x00011310, 0x00000008, 0x00010000, + /* offset=0x11990, mult1=0x8, size=0x1 */ + 0x00011990, 0x00000008, 0x00010000, /* TSTORM_RDMA_ASSERT_LEVEL_OFFSET(pf_id), */ - /* offset=0xf018, mult1=0x8, size=0x1 */ - 0x0000f018, 0x00000008, 0x00010000, + /* offset=0xf020, mult1=0x8, size=0x1 */ + 0x0000f020, 0x00000008, 0x00010000, /* MSTORM_RDMA_ASSERT_LEVEL_OFFSET(pf_id), */ /* offset=0x12628, mult1=0x8, size=0x1 */ 0x00012628, 0x00000008, 0x00010000, @@ -197,11 +197,11 @@ static const u32 iro_arr[] = { /* offset=0x11da8, mult1=0x8, size=0x1 */ 0x00011da8, 0x00000008, 0x00010000, /* XSTORM_IWARP_RXMIT_STATS_OFFSET(pf_id), */ - /* offset=0xa978, mult1=0x30, size=0x10 */ - 0x0000a978, 0x00000030, 0x00100000, + /* offset=0xaa78, mult1=0x30, size=0x10 */ + 0x0000aa78, 0x00000030, 0x00100000, /* TSTORM_ROCE_EVENTS_STAT_OFFSET(roce_pf_id), */ - /* offset=0xd768, mult1=0x28, size=0x28 */ - 0x0000d768, 0x00000028, 0x00280000, + /* offset=0xd770, mult1=0x28, size=0x28 */ + 0x0000d770, 0x00000028, 0x00280000, /* YSTORM_ROCE_DCQCN_RECEIVED_STATS_OFFSET(roce_pf_id), */ /* offset=0x9a58, mult1=0x18, size=0x18 */ 0x00009a58, 0x00000018, 0x00180000, @@ -209,14 +209,14 @@ static const u32 iro_arr[] = { /* offset=0x9bd8, mult1=0x8, size=0x8 */ 0x00009bd8, 0x00000008, 0x00080000, /* PSTORM_ROCE_DCQCN_SENT_STATS_OFFSET(roce_pf_id), */ - /* offset=0x13398, mult1=0x8, size=0x8 */ - 0x00013398, 0x00000008, 0x00080000, + /* offset=0x13a18, mult1=0x8, size=0x8 */ + 0x00013a18, 0x00000008, 0x00080000, /* USTORM_ROCE_CQE_STATS_OFFSET(roce_pf_id), */ /* offset=0x126e8, mult1=0x18, size=0x18 */ 0x000126e8, 0x00000018, 0x00180000, /* TSTORM_NVMF_PORT_TASKPOOL_PRODUCER_CONSUMER_OFFSET(port_num_id,taskpool_index), */ - /* offset=0xe608, mult1=0x288, mult2=0x50, size=0x10 */ - 0x0000e608, 0x00500288, 0x00100000, + /* offset=0xe610, mult1=0x288, mult2=0x50, size=0x10 */ + 0x0000e610, 0x00500288, 0x00100000, /* USTORM_NVMF_PORT_COUNTERS_OFFSET(port_num_id), */ /* offset=0x12970, mult1=0x138, size=0x28 */ 0x00012970, 0x00000138, 0x00280000, diff --git a/drivers/net/qede/qede_ethdev.h b/drivers/net/qede/qede_ethdev.h index 1ac2d086a2..21115a077e 100644 --- a/drivers/net/qede/qede_ethdev.h +++ b/drivers/net/qede/qede_ethdev.h @@ -46,7 +46,7 @@ #define QEDE_PMD_VER_PREFIX "QEDE PMD" #define QEDE_PMD_VERSION_MAJOR 2 #define QEDE_PMD_VERSION_MINOR 11 -#define QEDE_PMD_VERSION_REVISION 0 +#define QEDE_PMD_VERSION_REVISION 3 #define QEDE_PMD_VERSION_PATCH 1 #define QEDE_PMD_DRV_VERSION qede_stringify(QEDE_PMD_VERSION_MAJOR) "." \ diff --git a/drivers/net/qede/qede_main.c b/drivers/net/qede/qede_main.c index c9caec6450..4eb79d0fbb 100644 --- a/drivers/net/qede/qede_main.c +++ b/drivers/net/qede/qede_main.c @@ -18,7 +18,7 @@ char qede_fw_file[PATH_MAX]; static const char * const QEDE_DEFAULT_FIRMWARE = - "/lib/firmware/qed/qed_init_values-8.40.25.0.bin"; + "/lib/firmware/qed/qed_init_values-8.40.33.0.bin"; static void qed_update_pf_params(struct ecore_dev *edev, struct ecore_pf_params *params)