X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fcommon%2Fsfc_efx%2Fbase%2Fefx_mcdi.c;h=cdf7181e0d9f7494863cf60bdd6c4c6e151b105b;hb=e8745b54126e263a07f98849cc9a390ac31fe111;hp=aa19c7c759aeadc2b18ebf31632dee509397610a;hpb=7640543f4c4f684dee99df343fc51403d60bd181;p=dpdk.git diff --git a/drivers/common/sfc_efx/base/efx_mcdi.c b/drivers/common/sfc_efx/base/efx_mcdi.c index aa19c7c759..cdf7181e0d 100644 --- a/drivers/common/sfc_efx/base/efx_mcdi.c +++ b/drivers/common/sfc_efx/base/efx_mcdi.c @@ -1,6 +1,6 @@ /* SPDX-License-Identifier: BSD-3-Clause * - * Copyright(c) 2019-2020 Xilinx, Inc. + * Copyright(c) 2019-2021 Xilinx, Inc. * Copyright(c) 2008-2019 Solarflare Communications Inc. */ @@ -516,6 +516,9 @@ efx_mcdi_finish_response( bytes = MIN(emrp->emr_out_length_used, emrp->emr_out_length); efx_mcdi_read_response(enp, emrp->emr_out_buf, resp_off, bytes); + /* Report bytes copied to caller (response message may be larger) */ + emrp->emr_out_length_used = bytes; + #if EFSYS_OPT_MCDI_LOGGING if (emtp->emt_logger != NULL) { emtp->emt_logger(emtp->emt_context, @@ -644,6 +647,79 @@ efx_mcdi_request_abort( return (aborted); } + __checkReturn efx_rc_t +efx_mcdi_get_client_handle( + __in efx_nic_t *enp, + __in efx_pcie_interface_t intf, + __in uint16_t pf, + __in uint16_t vf, + __out uint32_t *handle) +{ + efx_mcdi_req_t req; + EFX_MCDI_DECLARE_BUF(payload, + MC_CMD_GET_CLIENT_HANDLE_IN_LEN, + MC_CMD_GET_CLIENT_HANDLE_OUT_LEN); + efx_rc_t rc; + + if (handle == NULL) { + rc = EINVAL; + goto fail1; + } + + req.emr_cmd = MC_CMD_GET_CLIENT_HANDLE; + req.emr_in_buf = payload; + req.emr_in_length = MC_CMD_GET_CLIENT_HANDLE_IN_LEN; + req.emr_out_buf = payload; + req.emr_out_length = MC_CMD_GET_CLIENT_HANDLE_OUT_LEN; + + MCDI_IN_SET_DWORD(req, GET_CLIENT_HANDLE_IN_TYPE, + MC_CMD_GET_CLIENT_HANDLE_IN_TYPE_FUNC); + MCDI_IN_SET_WORD(req, GET_CLIENT_HANDLE_IN_FUNC_PF, pf); + MCDI_IN_SET_WORD(req, GET_CLIENT_HANDLE_IN_FUNC_VF, vf); + MCDI_IN_SET_DWORD(req, GET_CLIENT_HANDLE_IN_FUNC_INTF, intf); + + efx_mcdi_execute(enp, &req); + + if (req.emr_rc != 0) { + rc = req.emr_rc; + goto fail2; + } + + if (req.emr_out_length_used < MC_CMD_GET_CLIENT_HANDLE_OUT_LEN) { + rc = EMSGSIZE; + goto fail3; + } + + *handle = MCDI_OUT_DWORD(req, GET_CLIENT_HANDLE_OUT_HANDLE); + + return 0; +fail3: + EFSYS_PROBE(fail3); +fail2: + EFSYS_PROBE(fail2); +fail1: + EFSYS_PROBE1(fail1, efx_rc_t, rc); + return (rc); +} + + __checkReturn efx_rc_t +efx_mcdi_get_own_client_handle( + __in efx_nic_t *enp, + __out uint32_t *handle) +{ + efx_rc_t rc; + + rc = efx_mcdi_get_client_handle(enp, PCIE_INTERFACE_CALLER, + PCIE_FUNCTION_PF_NULL, PCIE_FUNCTION_VF_NULL, handle); + if (rc != 0) + goto fail1; + + return (0); +fail1: + EFSYS_PROBE1(fail1, efx_rc_t, rc); + return (rc); +} + void efx_mcdi_get_timeout( __in efx_nic_t *enp, @@ -962,30 +1038,51 @@ efx_mcdi_ev_death( } __checkReturn efx_rc_t -efx_mcdi_version( +efx_mcdi_get_version( __in efx_nic_t *enp, - __out_ecount_opt(4) uint16_t versionp[4], - __out_opt uint32_t *buildp, - __out_opt efx_mcdi_boot_t *statusp) + __in uint32_t flags, + __out efx_mcdi_version_t *verp) { - efx_mcdi_req_t req; + efx_nic_board_info_t *board_infop = &verp->emv_board_info; EFX_MCDI_DECLARE_BUF(payload, - MAX(MC_CMD_GET_VERSION_IN_LEN, MC_CMD_GET_BOOT_STATUS_IN_LEN), - MAX(MC_CMD_GET_VERSION_OUT_LEN, - MC_CMD_GET_BOOT_STATUS_OUT_LEN)); + MC_CMD_GET_VERSION_EXT_IN_LEN, + MC_CMD_GET_VERSION_V2_OUT_LEN); efx_word_t *ver_words; uint16_t version[4]; - uint32_t build; - efx_mcdi_boot_t status; + efx_mcdi_req_t req; + uint32_t firmware; efx_rc_t rc; + EFX_STATIC_ASSERT(sizeof (verp->emv_version) == + MC_CMD_GET_VERSION_OUT_VERSION_LEN); + EFX_STATIC_ASSERT(sizeof (verp->emv_firmware) == + MC_CMD_GET_VERSION_OUT_FIRMWARE_LEN); + + EFX_STATIC_ASSERT(EFX_MCDI_VERSION_BOARD_INFO == + (1U << MC_CMD_GET_VERSION_V2_OUT_BOARD_EXT_INFO_PRESENT_LBN)); + + EFX_STATIC_ASSERT(sizeof (board_infop->enbi_serial) == + MC_CMD_GET_VERSION_V2_OUT_BOARD_SERIAL_LEN); + EFX_STATIC_ASSERT(sizeof (board_infop->enbi_name) == + MC_CMD_GET_VERSION_V2_OUT_BOARD_NAME_LEN); + EFX_STATIC_ASSERT(sizeof (board_infop->enbi_revision) == + MC_CMD_GET_VERSION_V2_OUT_BOARD_REVISION_LEN); + EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI); req.emr_cmd = MC_CMD_GET_VERSION; req.emr_in_buf = payload; - req.emr_in_length = MC_CMD_GET_VERSION_IN_LEN; req.emr_out_buf = payload; - req.emr_out_length = MC_CMD_GET_VERSION_OUT_LEN; + + if ((flags & EFX_MCDI_VERSION_BOARD_INFO) != 0) { + /* Request basic + extended version information. */ + req.emr_in_length = MC_CMD_GET_VERSION_EXT_IN_LEN; + req.emr_out_length = MC_CMD_GET_VERSION_V2_OUT_LEN; + } else { + /* Request only basic version information. */ + req.emr_in_length = MC_CMD_GET_VERSION_IN_LEN; + req.emr_out_length = MC_CMD_GET_VERSION_OUT_LEN; + } efx_mcdi_execute(enp, &req); @@ -997,12 +1094,11 @@ efx_mcdi_version( /* bootrom support */ if (req.emr_out_length_used == MC_CMD_GET_VERSION_V0_OUT_LEN) { version[0] = version[1] = version[2] = version[3] = 0; - build = MCDI_OUT_DWORD(req, GET_VERSION_OUT_FIRMWARE); - - goto version; + firmware = MCDI_OUT_DWORD(req, GET_VERSION_OUT_FIRMWARE); + goto out; } - if (req.emr_out_length_used < MC_CMD_GET_VERSION_OUT_LEN) { + if (req.emr_out_length_used < req.emr_out_length) { rc = EMSGSIZE; goto fail2; } @@ -1012,16 +1108,54 @@ efx_mcdi_version( version[1] = EFX_WORD_FIELD(ver_words[1], EFX_WORD_0); version[2] = EFX_WORD_FIELD(ver_words[2], EFX_WORD_0); version[3] = EFX_WORD_FIELD(ver_words[3], EFX_WORD_0); - build = MCDI_OUT_DWORD(req, GET_VERSION_OUT_FIRMWARE); + firmware = MCDI_OUT_DWORD(req, GET_VERSION_OUT_FIRMWARE); -version: - /* The bootrom doesn't understand BOOT_STATUS */ - if (MC_FW_VERSION_IS_BOOTLOADER(build)) { - status = EFX_MCDI_BOOT_ROM; - goto out; +out: + memset(verp, 0, sizeof (*verp)); + + verp->emv_version[0] = version[0]; + verp->emv_version[1] = version[1]; + verp->emv_version[2] = version[2]; + verp->emv_version[3] = version[3]; + verp->emv_firmware = firmware; + + verp->emv_flags = MCDI_OUT_DWORD(req, GET_VERSION_V2_OUT_FLAGS); + verp->emv_flags &= flags; + + if ((verp->emv_flags & EFX_MCDI_VERSION_BOARD_INFO) != 0) { + memcpy(board_infop->enbi_serial, + MCDI_OUT2(req, char, GET_VERSION_V2_OUT_BOARD_SERIAL), + sizeof (board_infop->enbi_serial)); + memcpy(board_infop->enbi_name, + MCDI_OUT2(req, char, GET_VERSION_V2_OUT_BOARD_NAME), + sizeof (board_infop->enbi_name)); + board_infop->enbi_revision = + MCDI_OUT_DWORD(req, GET_VERSION_V2_OUT_BOARD_REVISION); } - (void) memset(payload, 0, sizeof (payload)); + return (0); + +fail2: + EFSYS_PROBE(fail2); +fail1: + EFSYS_PROBE1(fail1, efx_rc_t, rc); + + return (rc); +} + +static __checkReturn efx_rc_t +efx_mcdi_get_boot_status( + __in efx_nic_t *enp, + __out efx_mcdi_boot_t *statusp) +{ + EFX_MCDI_DECLARE_BUF(payload, + MC_CMD_GET_BOOT_STATUS_IN_LEN, + MC_CMD_GET_BOOT_STATUS_OUT_LEN); + efx_mcdi_req_t req; + efx_rc_t rc; + + EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI); + req.emr_cmd = MC_CMD_GET_BOOT_STATUS; req.emr_in_buf = payload; req.emr_in_length = MC_CMD_GET_BOOT_STATUS_IN_LEN; @@ -1030,44 +1164,79 @@ version: efx_mcdi_execute_quiet(enp, &req); - if (req.emr_rc == EACCES) { - /* Unprivileged functions cannot access BOOT_STATUS */ - status = EFX_MCDI_BOOT_PRIMARY; - version[0] = version[1] = version[2] = version[3] = 0; - build = 0; - goto out; - } + /* + * NOTE: Unprivileged functions cannot access boot status, + * so the MCDI request will return EACCES. This is + * also checked in efx_mcdi_version. + */ if (req.emr_rc != 0) { rc = req.emr_rc; - goto fail3; + goto fail1; } if (req.emr_out_length_used < MC_CMD_GET_BOOT_STATUS_OUT_LEN) { rc = EMSGSIZE; - goto fail4; + goto fail2; } if (MCDI_OUT_DWORD_FIELD(req, GET_BOOT_STATUS_OUT_FLAGS, GET_BOOT_STATUS_OUT_FLAGS_PRIMARY)) - status = EFX_MCDI_BOOT_PRIMARY; + *statusp = EFX_MCDI_BOOT_PRIMARY; else - status = EFX_MCDI_BOOT_SECONDARY; + *statusp = EFX_MCDI_BOOT_SECONDARY; + + return (0); + +fail2: + EFSYS_PROBE(fail2); +fail1: + EFSYS_PROBE1(fail1, efx_rc_t, rc); + + return (rc); +} + + __checkReturn efx_rc_t +efx_mcdi_version( + __in efx_nic_t *enp, + __out_ecount_opt(4) uint16_t versionp[4], + __out_opt uint32_t *buildp, + __out_opt efx_mcdi_boot_t *statusp) +{ + efx_mcdi_version_t ver; + efx_mcdi_boot_t status; + efx_rc_t rc; + + rc = efx_mcdi_get_version(enp, 0, &ver); + if (rc != 0) + goto fail1; + + /* The bootrom doesn't understand BOOT_STATUS */ + if (MC_FW_VERSION_IS_BOOTLOADER(ver.emv_firmware)) { + status = EFX_MCDI_BOOT_ROM; + goto out; + } + + rc = efx_mcdi_get_boot_status(enp, &status); + if (rc == EACCES) { + /* Unprivileged functions cannot access BOOT_STATUS */ + status = EFX_MCDI_BOOT_PRIMARY; + memset(ver.emv_version, 0, sizeof (ver.emv_version)); + ver.emv_firmware = 0; + } else if (rc != 0) { + goto fail2; + } out: if (versionp != NULL) - memcpy(versionp, version, sizeof (version)); + memcpy(versionp, ver.emv_version, sizeof (ver.emv_version)); if (buildp != NULL) - *buildp = build; + *buildp = ver.emv_firmware; if (statusp != NULL) *statusp = status; return (0); -fail4: - EFSYS_PROBE(fail4); -fail3: - EFSYS_PROBE(fail3); fail2: EFSYS_PROBE(fail2); fail1: @@ -2034,6 +2203,36 @@ fail1: #if EFSYS_OPT_RIVERHEAD || EFX_OPTS_EF10() + __checkReturn efx_rc_t +efx_mcdi_intf_from_pcie( + __in uint32_t pcie_intf, + __out efx_pcie_interface_t *efx_intf) +{ + efx_rc_t rc; + + switch (pcie_intf) { + case PCIE_INTERFACE_CALLER: + *efx_intf = EFX_PCIE_INTERFACE_CALLER; + break; + case PCIE_INTERFACE_HOST_PRIMARY: + *efx_intf = EFX_PCIE_INTERFACE_HOST_PRIMARY; + break; + case PCIE_INTERFACE_NIC_EMBEDDED: + *efx_intf = EFX_PCIE_INTERFACE_NIC_EMBEDDED; + break; + default: + rc = EINVAL; + goto fail1; + } + + return (0); + +fail1: + EFSYS_PROBE1(fail1, efx_rc_t, rc); + + return (rc); +} + /* * This function returns the pf and vf number of a function. If it is a pf the * vf number is 0xffff. The vf number is the index of the vf on that @@ -2044,18 +2243,21 @@ fail1: efx_mcdi_get_function_info( __in efx_nic_t *enp, __out uint32_t *pfp, - __out_opt uint32_t *vfp) + __out_opt uint32_t *vfp, + __out_opt efx_pcie_interface_t *intfp) { + efx_pcie_interface_t intf; efx_mcdi_req_t req; EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_FUNCTION_INFO_IN_LEN, - MC_CMD_GET_FUNCTION_INFO_OUT_LEN); + MC_CMD_GET_FUNCTION_INFO_OUT_V2_LEN); + uint32_t pcie_intf; efx_rc_t rc; req.emr_cmd = MC_CMD_GET_FUNCTION_INFO; req.emr_in_buf = payload; req.emr_in_length = MC_CMD_GET_FUNCTION_INFO_IN_LEN; req.emr_out_buf = payload; - req.emr_out_length = MC_CMD_GET_FUNCTION_INFO_OUT_LEN; + req.emr_out_length = MC_CMD_GET_FUNCTION_INFO_OUT_V2_LEN; efx_mcdi_execute(enp, &req); @@ -2073,8 +2275,24 @@ efx_mcdi_get_function_info( if (vfp != NULL) *vfp = MCDI_OUT_DWORD(req, GET_FUNCTION_INFO_OUT_VF); + if (req.emr_out_length < MC_CMD_GET_FUNCTION_INFO_OUT_V2_LEN) { + intf = EFX_PCIE_INTERFACE_HOST_PRIMARY; + } else { + pcie_intf = MCDI_OUT_DWORD(req, + GET_FUNCTION_INFO_OUT_V2_INTF); + + rc = efx_mcdi_intf_from_pcie(pcie_intf, &intf); + if (rc != 0) + goto fail3; + } + + if (intfp != NULL) + *intfp = intf; + return (0); +fail3: + EFSYS_PROBE(fail3); fail2: EFSYS_PROBE(fail2); fail1: @@ -2198,6 +2416,11 @@ efx_mcdi_get_workarounds( goto fail1; } + if (req.emr_out_length_used < MC_CMD_GET_WORKAROUNDS_OUT_LEN) { + rc = EMSGSIZE; + goto fail2; + } + if (implementedp != NULL) { *implementedp = MCDI_OUT_DWORD(req, GET_WORKAROUNDS_OUT_IMPLEMENTED); @@ -2209,6 +2432,8 @@ efx_mcdi_get_workarounds( return (0); +fail2: + EFSYS_PROBE(fail2); fail1: EFSYS_PROBE1(fail1, efx_rc_t, rc); @@ -2465,6 +2690,7 @@ efx_mcdi_init_evq( __in efsys_mem_t *esmp, __in size_t nevs, __in uint32_t irq, + __in uint32_t target_evq, __in uint32_t us, __in uint32_t flags, __in boolean_t low_latency) @@ -2475,6 +2701,7 @@ efx_mcdi_init_evq( MC_CMD_INIT_EVQ_V2_IN_LEN(INIT_EVQ_MAXNBUFS), MC_CMD_INIT_EVQ_V2_OUT_LEN); boolean_t interrupting; + int ev_extended_width; int ev_cut_through; int ev_merge; unsigned int evq_type; @@ -2484,7 +2711,7 @@ efx_mcdi_init_evq( int i; efx_rc_t rc; - npages = efx_evq_nbufs(enp, nevs); + npages = efx_evq_nbufs(enp, nevs, flags); if (npages > INIT_EVQ_MAXNBUFS) { rc = EINVAL; goto fail1; @@ -2498,11 +2725,15 @@ efx_mcdi_init_evq( MCDI_IN_SET_DWORD(req, INIT_EVQ_V2_IN_SIZE, nevs); MCDI_IN_SET_DWORD(req, INIT_EVQ_V2_IN_INSTANCE, instance); - MCDI_IN_SET_DWORD(req, INIT_EVQ_V2_IN_IRQ_NUM, irq); interrupting = ((flags & EFX_EVQ_FLAGS_NOTIFY_MASK) == EFX_EVQ_FLAGS_NOTIFY_INTERRUPT); + if (interrupting) + MCDI_IN_SET_DWORD(req, INIT_EVQ_V2_IN_IRQ_NUM, irq); + else + MCDI_IN_SET_DWORD(req, INIT_EVQ_V2_IN_TARGET_EVQ, target_evq); + if (encp->enc_init_evq_v2_supported) { /* * On Medford the low latency license is required to enable RX @@ -2558,14 +2789,27 @@ efx_mcdi_init_evq( } } - MCDI_IN_POPULATE_DWORD_7(req, INIT_EVQ_V2_IN_FLAGS, + /* + * On EF100, extended width event queues have a different event + * descriptor layout and are used to support descriptor proxy queues. + */ + ev_extended_width = 0; +#if EFSYS_OPT_EV_EXTENDED_WIDTH + if (encp->enc_init_evq_extended_width_supported) { + if (flags & EFX_EVQ_FLAGS_EXTENDED_WIDTH) + ev_extended_width = 1; + } +#endif + + MCDI_IN_POPULATE_DWORD_8(req, INIT_EVQ_V2_IN_FLAGS, INIT_EVQ_V2_IN_FLAG_INTERRUPTING, interrupting, INIT_EVQ_V2_IN_FLAG_RPTR_DOS, 0, INIT_EVQ_V2_IN_FLAG_INT_ARMD, 0, INIT_EVQ_V2_IN_FLAG_CUT_THRU, ev_cut_through, INIT_EVQ_V2_IN_FLAG_RX_MERGE, ev_merge, INIT_EVQ_V2_IN_FLAG_TX_MERGE, ev_merge, - INIT_EVQ_V2_IN_FLAG_TYPE, evq_type); + INIT_EVQ_V2_IN_FLAG_TYPE, evq_type, + INIT_EVQ_V2_IN_FLAG_EXT_WIDTH, ev_extended_width); /* If the value is zero then disable the timer */ if (us == 0) { @@ -2692,8 +2936,8 @@ efx_mcdi_init_rxq( { efx_nic_cfg_t *encp = &(enp->en_nic_cfg); efx_mcdi_req_t req; - EFX_MCDI_DECLARE_BUF(payload, MC_CMD_INIT_RXQ_V4_IN_LEN, - MC_CMD_INIT_RXQ_V4_OUT_LEN); + EFX_MCDI_DECLARE_BUF(payload, MC_CMD_INIT_RXQ_V5_IN_LEN, + MC_CMD_INIT_RXQ_V5_OUT_LEN); int npages = efx_rxq_nbufs(enp, ndescs); int i; efx_qword_t *dma_addr; @@ -2747,9 +2991,9 @@ efx_mcdi_init_rxq( req.emr_cmd = MC_CMD_INIT_RXQ; req.emr_in_buf = payload; - req.emr_in_length = MC_CMD_INIT_RXQ_V4_IN_LEN; + req.emr_in_length = MC_CMD_INIT_RXQ_V5_IN_LEN; req.emr_out_buf = payload; - req.emr_out_length = MC_CMD_INIT_RXQ_V4_OUT_LEN; + req.emr_out_length = MC_CMD_INIT_RXQ_V5_OUT_LEN; MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_SIZE, ndescs); MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_TARGET_EVQ, eep->ee_index); @@ -2787,6 +3031,8 @@ efx_mcdi_init_rxq( MCDI_IN_SET_DWORD(req, INIT_RXQ_V4_IN_BUFFER_SIZE_BYTES, params->buf_size); + MCDI_IN_SET_DWORD(req, INIT_RXQ_V5_IN_RX_PREFIX_ID, params->prefix_id); + dma_addr = MCDI_IN2(req, efx_qword_t, INIT_RXQ_IN_DMA_ADDR); addr = EFSYS_MEM_ADDR(esmp);