/* 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,
}
__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);
/* 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;
}
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;
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:
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)
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;
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;
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
}
}
- 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) {
__in uint32_t label,
__in uint32_t instance,
__in efsys_mem_t *esmp,
- __in boolean_t disable_scatter,
- __in boolean_t want_inner_classes,
- __in uint32_t buf_size,
- __in uint32_t ps_bufsize,
- __in uint32_t es_bufs_per_desc,
- __in uint32_t es_max_dma_len,
- __in uint32_t es_buf_stride,
- __in uint32_t hol_block_timeout)
+ __in const efx_mcdi_init_rxq_params_t *params)
{
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;
}
no_cont_ev = (eep->ee_flags & EFX_EVQ_FLAGS_NO_CONT_EV);
- if ((no_cont_ev == B_TRUE) && (disable_scatter == B_FALSE)) {
+ if ((no_cont_ev == B_TRUE) && (params->disable_scatter == B_FALSE)) {
/* TODO: Support scatter in NO_CONT_EV mode */
rc = EINVAL;
goto fail2;
}
- if (ps_bufsize > 0)
+ if (params->ps_buf_size > 0)
dma_mode = MC_CMD_INIT_RXQ_EXT_IN_PACKED_STREAM;
- else if (es_bufs_per_desc > 0)
+ else if (params->es_bufs_per_desc > 0)
dma_mode = MC_CMD_INIT_RXQ_V3_IN_EQUAL_STRIDE_SUPER_BUFFER;
else
dma_mode = MC_CMD_INIT_RXQ_EXT_IN_SINGLE_PACKET;
if (encp->enc_tunnel_encapsulations_supported != 0 &&
- !want_inner_classes) {
+ !params->want_inner_classes) {
/*
* WANT_OUTER_CLASSES can only be specified on hardware which
* supports tunnel encapsulation offloads, even though it is
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);
INIT_RXQ_EXT_IN_FLAG_TIMESTAMP, 0,
INIT_RXQ_EXT_IN_CRC_MODE, 0,
INIT_RXQ_EXT_IN_FLAG_PREFIX, 1,
- INIT_RXQ_EXT_IN_FLAG_DISABLE_SCATTER, disable_scatter,
+ INIT_RXQ_EXT_IN_FLAG_DISABLE_SCATTER, params->disable_scatter,
INIT_RXQ_EXT_IN_DMA_MODE,
dma_mode,
- INIT_RXQ_EXT_IN_PACKED_STREAM_BUFF_SIZE, ps_bufsize,
+ INIT_RXQ_EXT_IN_PACKED_STREAM_BUFF_SIZE, params->ps_buf_size,
INIT_RXQ_EXT_IN_FLAG_WANT_OUTER_CLASSES, want_outer_classes,
INIT_RXQ_EXT_IN_FLAG_NO_CONT_EV, no_cont_ev);
MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_OWNER_ID, 0);
MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_PORT_ID, enp->en_vport_id);
- if (es_bufs_per_desc > 0) {
+ if (params->es_bufs_per_desc > 0) {
MCDI_IN_SET_DWORD(req,
INIT_RXQ_V3_IN_ES_PACKET_BUFFERS_PER_BUCKET,
- es_bufs_per_desc);
+ params->es_bufs_per_desc);
MCDI_IN_SET_DWORD(req,
- INIT_RXQ_V3_IN_ES_MAX_DMA_LEN, es_max_dma_len);
+ INIT_RXQ_V3_IN_ES_MAX_DMA_LEN, params->es_max_dma_len);
MCDI_IN_SET_DWORD(req,
- INIT_RXQ_V3_IN_ES_PACKET_STRIDE, es_buf_stride);
+ INIT_RXQ_V3_IN_ES_PACKET_STRIDE, params->es_buf_stride);
MCDI_IN_SET_DWORD(req,
INIT_RXQ_V3_IN_ES_HEAD_OF_LINE_BLOCK_TIMEOUT,
- hol_block_timeout);
+ params->hol_block_timeout);
}
if (encp->enc_init_rxq_with_buffer_size)
MCDI_IN_SET_DWORD(req, INIT_RXQ_V4_IN_BUFFER_SIZE_BYTES,
- buf_size);
+ 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);
return (rc);
}
-#endif /* EFSYS_OPT_RIVERHEAD || EFX_OPTS_EF10() */
-
-#if EFX_OPTS_EF10()
-
__checkReturn efx_rc_t
efx_mcdi_init_txq(
__in efx_nic_t *enp,
return (rc);
}
-#endif /* EFX_OPTS_EF10() */
+#endif /* EFSYS_OPT_RIVERHEAD || EFX_OPTS_EF10() */
#endif /* EFSYS_OPT_MCDI */