/* 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.
*/
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,
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,
__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) ==
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);
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,
return (0);
-fail3:
- EFSYS_PROBE(fail3);
fail2:
EFSYS_PROBE(fail2);
fail1:
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;
#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
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);
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:
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);
return (0);
+fail2:
+ EFSYS_PROBE(fail2);
fail1:
EFSYS_PROBE1(fail1, efx_rc_t, rc);
__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)
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
git.droids-corp.org / dpdk.git / blobdiff