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=8c984d8cad77431b236189f553a8c33da9a9c02b;hpb=833cfcd590e23a5941561dda90ba6e07bd860586;p=dpdk.git diff --git a/drivers/common/sfc_efx/base/efx_mcdi.c b/drivers/common/sfc_efx/base/efx_mcdi.c index 8c984d8cad..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, @@ -964,15 +1040,17 @@ efx_mcdi_ev_death( __checkReturn efx_rc_t efx_mcdi_get_version( __in efx_nic_t *enp, - __in uint32_t flags_req, + __in uint32_t flags, __out efx_mcdi_version_t *verp) { efx_nic_board_info_t *board_infop = &verp->emv_board_info; EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_VERSION_EXT_IN_LEN, MC_CMD_GET_VERSION_V2_OUT_LEN); - size_t min_resp_len_required; + efx_word_t *ver_words; + uint16_t version[4]; efx_mcdi_req_t req; + uint32_t firmware; efx_rc_t rc; EFX_STATIC_ASSERT(sizeof (verp->emv_version) == @@ -996,18 +1074,14 @@ efx_mcdi_get_version( req.emr_in_buf = payload; req.emr_out_buf = payload; - if (flags_req != 0) { + 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; - - min_resp_len_required = 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; - - min_resp_len_required = MC_CMD_GET_VERSION_V0_OUT_LEN; } efx_mcdi_execute(enp, &req); @@ -1017,33 +1091,36 @@ efx_mcdi_get_version( goto fail1; } - if (req.emr_out_length_used < min_resp_len_required) { + /* bootrom support */ + if (req.emr_out_length_used == MC_CMD_GET_VERSION_V0_OUT_LEN) { + version[0] = version[1] = version[2] = version[3] = 0; + firmware = MCDI_OUT_DWORD(req, GET_VERSION_OUT_FIRMWARE); + goto out; + } + + if (req.emr_out_length_used < req.emr_out_length) { rc = EMSGSIZE; goto fail2; } - memset(verp, 0, sizeof (*verp)); - - if (req.emr_out_length_used > min_resp_len_required) { - efx_word_t *ver_words; - - if (req.emr_out_length_used < MC_CMD_GET_VERSION_OUT_LEN) { - rc = EMSGSIZE; - goto fail3; - } - - ver_words = MCDI_OUT2(req, efx_word_t, GET_VERSION_OUT_VERSION); + ver_words = MCDI_OUT2(req, efx_word_t, GET_VERSION_OUT_VERSION); + version[0] = EFX_WORD_FIELD(ver_words[0], EFX_WORD_0); + 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); + firmware = MCDI_OUT_DWORD(req, GET_VERSION_OUT_FIRMWARE); - verp->emv_version[0] = EFX_WORD_FIELD(ver_words[0], EFX_WORD_0); - verp->emv_version[1] = EFX_WORD_FIELD(ver_words[1], EFX_WORD_0); - verp->emv_version[2] = EFX_WORD_FIELD(ver_words[2], EFX_WORD_0); - verp->emv_version[3] = EFX_WORD_FIELD(ver_words[3], EFX_WORD_0); - } +out: + memset(verp, 0, sizeof (*verp)); - verp->emv_firmware = MCDI_OUT_DWORD(req, GET_VERSION_OUT_FIRMWARE); + 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_req; + verp->emv_flags &= flags; if ((verp->emv_flags & EFX_MCDI_VERSION_BOARD_INFO) != 0) { memcpy(board_infop->enbi_serial, @@ -1058,8 +1135,6 @@ efx_mcdi_get_version( return (0); -fail3: - EFSYS_PROBE(fail3); fail2: EFSYS_PROBE(fail2); fail1: @@ -1089,6 +1164,12 @@ efx_mcdi_get_boot_status( efx_mcdi_execute_quiet(enp, &req); + /* + * 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 fail1; @@ -2122,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 @@ -2132,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); @@ -2161,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: @@ -2286,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); @@ -2297,6 +2432,8 @@ efx_mcdi_get_workarounds( return (0); +fail2: + EFSYS_PROBE(fail2); fail1: EFSYS_PROBE1(fail1, efx_rc_t, rc); @@ -2553,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) @@ -2587,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