From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 14D78A052E; Mon, 9 Mar 2020 15:22:54 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id CC1761C0BC; Mon, 9 Mar 2020 15:22:32 +0100 (CET) Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by dpdk.org (Postfix) with ESMTP id DC17B1C0BC for ; Mon, 9 Mar 2020 15:22:29 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga008.jf.intel.com ([10.7.209.65]) by orsmga103.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 09 Mar 2020 07:22:29 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,533,1574150400"; d="scan'208";a="235704334" Received: from npg-dpdk-haiyue-1.sh.intel.com ([10.67.119.213]) by orsmga008.jf.intel.com with ESMTP; 09 Mar 2020 07:22:25 -0700 From: Haiyue Wang To: dev@dpdk.org, xiaolong.ye@intel.com, qi.z.zhang@intel.com, qiming.yang@intel.com, beilei.xing@intel.com Cc: wei.zhao1@intel.com, Haiyue Wang Date: Mon, 9 Mar 2020 22:14:36 +0800 Message-Id: <20200309141437.11800-4-haiyue.wang@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20200309141437.11800-1-haiyue.wang@intel.com> References: <20200309141437.11800-1-haiyue.wang@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [dpdk-dev] [PATCH v1 3/4] net/ice: add the DCF framework X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" The DCF (Device Config Function) feature works as a standalone PMD, its hardware entity is the trusted VF with ID 0, and the software function is to control the flow setting of other VFs by the mailbox with PF. It doesn't handle packet Rx/Tx related things. This PMD needs the iAVF virtchnl to send the ICE PF's AdminQ command. Also for security, it needs to acquire the DCF capability from PF. The flow related things will be added later, it shares most of the ICE flow function. This mainly handles hardware initialization etc. .-------------. .-| | .-| | | | | | iAVF PMD | | | | | | | | | | | '-------------' | '-------------' '-------------' ^ Other VFs / / Flow Distribution .------------------. / | |/ DCF cap req .-------------. | CVL . <---------- | | | Kernel | ----------> | | . . DCF cap rsp | DCF PMD | | | | | '------------------' <----------- | | rte_flow '-------------' VF0 Signed-off-by: Haiyue Wang --- doc/guides/nics/ice.rst | 47 +++ doc/guides/nics/img/ice_dcf.png | Bin 0 -> 39168 bytes drivers/common/Makefile | 1 + drivers/net/ice/Makefile | 6 + drivers/net/ice/ice_dcf.c | 651 +++++++++++++++++++++++++++++++ drivers/net/ice/ice_dcf.h | 61 +++ drivers/net/ice/ice_dcf_ethdev.c | 319 +++++++++++++++ drivers/net/ice/ice_dcf_ethdev.h | 33 ++ drivers/net/ice/ice_dcf_parent.c | 348 +++++++++++++++++ drivers/net/ice/meson.build | 8 +- mk/rte.app.mk | 1 + 11 files changed, 1473 insertions(+), 2 deletions(-) create mode 100644 doc/guides/nics/img/ice_dcf.png create mode 100644 drivers/net/ice/ice_dcf.c create mode 100644 drivers/net/ice/ice_dcf.h create mode 100644 drivers/net/ice/ice_dcf_ethdev.c create mode 100644 drivers/net/ice/ice_dcf_ethdev.h create mode 100644 drivers/net/ice/ice_dcf_parent.c diff --git a/doc/guides/nics/ice.rst b/doc/guides/nics/ice.rst index 8af32dabf..2639ae239 100644 --- a/doc/guides/nics/ice.rst +++ b/doc/guides/nics/ice.rst @@ -240,6 +240,53 @@ report a MDD event and drop the packets. The APPs based on DPDK should avoid providing such packets. +Device Config Function (DCF) +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +This section demonstrates ICE DCF PMD, which shares the core module with ICE +PMD and iAVF PMD. + +A DCF (Device Config Function) PMD bounds to the device's trusted VF with ID 0, +it can act as a sole controlling entity to exercise advance functionality (such +as switch, ACL) for the rest VFs. + +The DCF PMD needs to advertise and acquire DCF capability which allows DCF to +send AdminQ commands that it would like to execute over to the PF and receive +responses for the same from PF. + +.. _figure_ice_dcf: + +.. figure:: img/ice_dcf.* + + DCF Communication flow. + +#. Create the VFs:: + + echo 4 > /sys/bus/pci/devices/0000\:18\:00.0/sriov_numvfs + +#. Enable the VF0 trust on:: + + ip link set dev enp24s0f0 vf 0 trust on + +#. Bind the VF0, and run testpmd with 'cap=dcf' devarg:: + + testpmd -l 22-25 -n 4 -w 18:01.0,cap=dcf -- -i + +#. Monitor the VF2 interface network traffic:: + + tcpdump -e -nn -i enp24s1f2 + +#. Create one flow to redirect the traffic to VF2 by DCF:: + + flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 \ + dst is 192.168.0.3 / end actions vf id 2 / end + +#. Send the packet, and it should be displayed on tcpdump:: + + sendp(Ether(src='3c:fd:fe:aa:bb:78', dst='00:00:00:01:02:03')/IP(src=' \ + 192.168.0.2', dst="192.168.0.3")/TCP(flags='S')/Raw(load='XXXXXXXXXX'), \ + iface="enp24s0f0", count=10) + Sample Application Notes ------------------------ diff --git a/doc/guides/nics/img/ice_dcf.png b/doc/guides/nics/img/ice_dcf.png new file mode 100644 index 0000000000000000000000000000000000000000..540823c4a05e9ea9d558d233fea77016d1ae5df3 GIT binary patch literal 39168 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 literal 0 HcmV?d00001 diff --git a/drivers/common/Makefile b/drivers/common/Makefile index 96bd7ac6e..df2e840cf 100644 --- a/drivers/common/Makefile +++ b/drivers/common/Makefile @@ -31,6 +31,7 @@ DIRS-y += dpaax endif IAVF-y := $(CONFIG_RTE_LIBRTE_IAVF_PMD) +IAVF-y += $(CONFIG_RTE_LIBRTE_ICE_PMD) ifneq (,$(findstring y,$(IAVF-y))) DIRS-y += iavf endif diff --git a/drivers/net/ice/Makefile b/drivers/net/ice/Makefile index e22c34287..643639a50 100644 --- a/drivers/net/ice/Makefile +++ b/drivers/net/ice/Makefile @@ -11,9 +11,11 @@ LIB = librte_pmd_ice.a CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) CFLAGS += -DALLOW_EXPERIMENTAL_API +CFLAGS += -I$(RTE_SDK)/drivers/common/iavf LDLIBS += -lrte_eal -lrte_mbuf -lrte_ethdev -lrte_kvargs LDLIBS += -lrte_bus_pci -lrte_mempool -lrte_hash +LDLIBS += -lrte_net -lrte_common_iavf EXPORT_MAP := rte_pmd_ice_version.map @@ -84,6 +86,10 @@ ifeq ($(CC_AVX2_SUPPORT), 1) endif SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_generic_flow.c +SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_dcf.c +SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_dcf_parent.c +SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_dcf_ethdev.c + # install this header file SYMLINK-$(CONFIG_RTE_LIBRTE_ICE_PMD)-include := rte_pmd_ice.h diff --git a/drivers/net/ice/ice_dcf.c b/drivers/net/ice/ice_dcf.c new file mode 100644 index 000000000..669122331 --- /dev/null +++ b/drivers/net/ice/ice_dcf.c @@ -0,0 +1,651 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ice_dcf.h" + +#define ICE_DCF_AQ_LEN 32 +#define ICE_DCF_AQ_BUF_SZ 4096 + +#define ICE_DCF_ARQ_MAX_RETRIES 200 +#define ICE_DCF_ARQ_CHECK_TIME 2 /* msecs */ + +#define ICE_DCF_VF_RES_BUF_SZ \ + (sizeof(struct virtchnl_vf_resource) + \ + IAVF_MAX_VF_VSI * sizeof(struct virtchnl_vsi_resource)) + +static __rte_always_inline int +ice_dcf_send_cmd_req_no_irq(struct ice_dcf_hw *hw, enum virtchnl_ops op, + uint8_t *req_msg, uint16_t req_msglen) +{ + return iavf_aq_send_msg_to_pf(&hw->avf, op, IAVF_SUCCESS, + req_msg, req_msglen, NULL); +} + +static int +ice_dcf_recv_cmd_rsp_no_irq(struct ice_dcf_hw *hw, enum virtchnl_ops op, + uint8_t *rsp_msgbuf, uint16_t rsp_buflen, + uint16_t *rsp_msglen) +{ + struct iavf_arq_event_info event; + enum virtchnl_ops v_op; + int i = 0; + int err; + + event.buf_len = rsp_buflen; + event.msg_buf = rsp_msgbuf; + + do { + err = iavf_clean_arq_element(&hw->avf, &event, NULL); + if (err != IAVF_SUCCESS) + goto again; + + v_op = rte_le_to_cpu_32(event.desc.cookie_high); + if (v_op != op) + goto again; + + if (rsp_msglen != NULL) + *rsp_msglen = event.msg_len; + return rte_le_to_cpu_32(event.desc.cookie_low); + +again: + rte_delay_ms(ICE_DCF_ARQ_CHECK_TIME); + } while (i++ < ICE_DCF_ARQ_MAX_RETRIES); + + return -EIO; +} + +static __rte_always_inline void +ice_dcf_aq_cmd_clear(struct ice_dcf_hw *hw, struct dcf_virtchnl_cmd *cmd) +{ + rte_spinlock_lock(&hw->vc_cmd_queue_lock); + + TAILQ_REMOVE(&hw->vc_cmd_queue, cmd, next); + + rte_spinlock_unlock(&hw->vc_cmd_queue_lock); +} + +static __rte_always_inline void +ice_dcf_vc_cmd_set(struct ice_dcf_hw *hw, struct dcf_virtchnl_cmd *cmd) +{ + cmd->v_ret = IAVF_ERR_NOT_READY; + cmd->rsp_msglen = 0; + cmd->pending = 1; + + rte_spinlock_lock(&hw->vc_cmd_queue_lock); + + TAILQ_INSERT_TAIL(&hw->vc_cmd_queue, cmd, next); + + rte_spinlock_unlock(&hw->vc_cmd_queue_lock); +} + +static __rte_always_inline int +ice_dcf_vc_cmd_send(struct ice_dcf_hw *hw, struct dcf_virtchnl_cmd *cmd) +{ + return iavf_aq_send_msg_to_pf(&hw->avf, + cmd->v_op, IAVF_SUCCESS, + cmd->req_msg, cmd->req_msglen, NULL); +} + +static __rte_always_inline void +ice_dcf_aq_cmd_handle(struct ice_dcf_hw *hw, struct iavf_arq_event_info *info) +{ + struct dcf_virtchnl_cmd *cmd; + enum virtchnl_ops v_op; + enum iavf_status v_ret; + uint16_t aq_op; + + aq_op = rte_le_to_cpu_16(info->desc.opcode); + if (unlikely(aq_op != iavf_aqc_opc_send_msg_to_vf)) { + PMD_DRV_LOG(ERR, + "Request %u is not supported yet", aq_op); + return; + } + + v_op = rte_le_to_cpu_32(info->desc.cookie_high); + if (unlikely(v_op == VIRTCHNL_OP_EVENT)) { + if (hw->vc_event_msg_cb != NULL) + hw->vc_event_msg_cb(hw, + info->msg_buf, + info->msg_len); + return; + } + + v_ret = rte_le_to_cpu_32(info->desc.cookie_low); + + rte_spinlock_lock(&hw->vc_cmd_queue_lock); + + TAILQ_FOREACH(cmd, &hw->vc_cmd_queue, next) { + if (cmd->v_op == v_op && cmd->pending) { + cmd->v_ret = v_ret; + cmd->rsp_msglen = RTE_MIN(info->msg_len, + cmd->rsp_buflen); + if (likely(cmd->rsp_msglen != 0)) + rte_memcpy(cmd->rsp_msgbuf, info->msg_buf, + cmd->rsp_msglen); + + /* prevent compiler reordering */ + rte_compiler_barrier(); + cmd->pending = 0; + break; + } + } + + rte_spinlock_unlock(&hw->vc_cmd_queue_lock); +} + +static void +ice_dcf_handle_virtchnl_msg(struct ice_dcf_hw *hw) +{ + struct iavf_arq_event_info info; + uint16_t pending = 1; + int ret; + + info.buf_len = ICE_DCF_AQ_BUF_SZ; + info.msg_buf = hw->arq_buf; + + while (pending) { + ret = iavf_clean_arq_element(&hw->avf, &info, &pending); + if (ret != IAVF_SUCCESS) + break; + + ice_dcf_aq_cmd_handle(hw, &info); + } +} + +static int +ice_dcf_init_check_api_version(struct ice_dcf_hw *hw) +{ +#define ICE_CPF_VIRTCHNL_VERSION_MAJOR_START 1 +#define ICE_CPF_VIRTCHNL_VERSION_MINOR_START 1 + struct virtchnl_version_info version, *pver; + int err; + + version.major = VIRTCHNL_VERSION_MAJOR; + version.minor = VIRTCHNL_VERSION_MINOR; + err = ice_dcf_send_cmd_req_no_irq(hw, VIRTCHNL_OP_VERSION, + (uint8_t *)&version, sizeof(version)); + if (err) { + PMD_INIT_LOG(ERR, "Fail to send OP_VERSION"); + return err; + } + + pver = &hw->virtchnl_version; + err = ice_dcf_recv_cmd_rsp_no_irq(hw, VIRTCHNL_OP_VERSION, + (uint8_t *)pver, sizeof(*pver), NULL); + if (err) { + PMD_INIT_LOG(ERR, "Fail to get response of OP_VERSION"); + return -1; + } + + PMD_DRV_LOG(DEBUG, + "Peer PF API version: %u.%u", pver->major, pver->minor); + + if (pver->major < ICE_CPF_VIRTCHNL_VERSION_MAJOR_START || + (pver->major == ICE_CPF_VIRTCHNL_VERSION_MAJOR_START && + pver->minor < ICE_CPF_VIRTCHNL_VERSION_MINOR_START)) { + PMD_INIT_LOG(ERR, + "VIRTCHNL API version should not be lower than (%u.%u)", + ICE_CPF_VIRTCHNL_VERSION_MAJOR_START, + ICE_CPF_VIRTCHNL_VERSION_MAJOR_START); + return -1; + } else if (pver->major > VIRTCHNL_VERSION_MAJOR || + (pver->major == VIRTCHNL_VERSION_MAJOR && + pver->minor > VIRTCHNL_VERSION_MINOR)) { + PMD_INIT_LOG(ERR, + "PF/VF API version mismatch:(%u.%u)-(%u.%u)", + pver->major, pver->minor, + VIRTCHNL_VERSION_MAJOR, VIRTCHNL_VERSION_MINOR); + return -1; + } + + PMD_DRV_LOG(DEBUG, "Peer is supported PF host"); + + return 0; +} + +static int +ice_dcf_get_vf_resource(struct ice_dcf_hw *hw) +{ + uint32_t caps; + int err, i; + + caps = VIRTCHNL_VF_OFFLOAD_WB_ON_ITR | VIRTCHNL_VF_OFFLOAD_RX_POLLING | + VIRTCHNL_VF_CAP_ADV_LINK_SPEED | VIRTCHNL_VF_CAP_DCF | + VF_BASE_MODE_OFFLOADS; + + err = ice_dcf_send_cmd_req_no_irq(hw, VIRTCHNL_OP_GET_VF_RESOURCES, + (uint8_t *)&caps, sizeof(caps)); + if (err) { + PMD_DRV_LOG(ERR, "Fail to send msg OP_GET_VF_RESOURCE"); + return err; + } + + err = ice_dcf_recv_cmd_rsp_no_irq(hw, VIRTCHNL_OP_GET_VF_RESOURCES, + (uint8_t *)hw->vf_res, + ICE_DCF_VF_RES_BUF_SZ, NULL); + if (err) { + PMD_DRV_LOG(ERR, "Fail to get response of OP_GET_VF_RESOURCE"); + return -1; + } + + iavf_vf_parse_hw_config(&hw->avf, hw->vf_res); + + hw->vsi_res = NULL; + for (i = 0; i < hw->vf_res->num_vsis; i++) { + if (hw->vf_res->vsi_res[i].vsi_type == VIRTCHNL_VSI_SRIOV) + hw->vsi_res = &hw->vf_res->vsi_res[i]; + } + + if (!hw->vsi_res) { + PMD_DRV_LOG(ERR, "no LAN VSI found"); + return -1; + } + + hw->vsi_id = hw->vsi_res->vsi_id; + PMD_DRV_LOG(DEBUG, "VSI ID is %u", hw->vsi_id); + + return 0; +} + +static int +ice_dcf_get_vf_vsi_map(struct ice_dcf_hw *hw) +{ + struct virtchnl_dcf_vsi_map *vsi_map; + uint16_t len; + int err; + + err = ice_dcf_send_cmd_req_no_irq(hw, VIRTCHNL_OP_DCF_GET_VSI_MAP, + NULL, 0); + if (err) { + PMD_DRV_LOG(ERR, "Fail to send msg OP_DCF_GET_VSI_MAP"); + return err; + } + + err = ice_dcf_recv_cmd_rsp_no_irq(hw, VIRTCHNL_OP_DCF_GET_VSI_MAP, + hw->arq_buf, ICE_DCF_AQ_BUF_SZ, + &len); + if (err) { + PMD_DRV_LOG(ERR, "Fail to get response of OP_DCF_GET_VSI_MAP"); + return err; + } + + vsi_map = (struct virtchnl_dcf_vsi_map *)hw->arq_buf; + if (len < sizeof(*vsi_map) || !vsi_map->num_vfs || + len < sizeof(*vsi_map) + + (vsi_map->num_vfs - 1) * sizeof(vsi_map->vf_vsi[0])) { + PMD_DRV_LOG(ERR, "invalid vf vsi map response with length %u", + len); + return -EINVAL; + } + + if (hw->num_vfs != 0 && hw->num_vfs != vsi_map->num_vfs) { + PMD_DRV_LOG(ERR, "The number VSI map (%u) doesn't match the number of VFs (%u)", + vsi_map->num_vfs, hw->num_vfs); + return -EINVAL; + } + + len = vsi_map->num_vfs * sizeof(vsi_map->vf_vsi[0]); + if (!hw->vf_vsi_map) { + hw->num_vfs = vsi_map->num_vfs; + hw->vf_vsi_map = rte_zmalloc("vf_vsi_ctx", len, 0); + } + + if (!hw->vf_vsi_map) { + PMD_DRV_LOG(ERR, "Fail to alloc memory for VSI context"); + return -ENOMEM; + } + + if (!memcmp(hw->vf_vsi_map, vsi_map->vf_vsi, len)) { + PMD_DRV_LOG(DEBUG, "VF VSI map doesn't change"); + return 1; + } + + rte_memcpy(hw->vf_vsi_map, vsi_map->vf_vsi, len); + return 0; +} + +static int +ice_dcf_mode_disable(struct ice_dcf_hw *hw) +{ + int err; + + err = ice_dcf_send_cmd_req_no_irq(hw, VIRTCHNL_OP_DCF_DISABLE, + NULL, 0); + if (err) { + PMD_DRV_LOG(ERR, "Fail to send msg OP_DCF_DISABLE"); + return err; + } + + err = ice_dcf_recv_cmd_rsp_no_irq(hw, VIRTCHNL_OP_DCF_DISABLE, + (uint8_t *)hw->arq_buf, + ICE_DCF_AQ_BUF_SZ, NULL); + if (err) { + PMD_DRV_LOG(ERR, + "Fail to get response of OP_DCF_DISABLE %d", + err); + return -1; + } + + return 0; +} + +static int +ice_dcf_check_reset_done(struct ice_dcf_hw *hw) +{ +#define ICE_DCF_RESET_WAIT_CNT 50 + struct iavf_hw *avf = &hw->avf; + int i, reset; + + for (i = 0; i < ICE_DCF_RESET_WAIT_CNT; i++) { + reset = IAVF_READ_REG(avf, IAVF_VFGEN_RSTAT) & + IAVF_VFGEN_RSTAT_VFR_STATE_MASK; + reset = reset >> IAVF_VFGEN_RSTAT_VFR_STATE_SHIFT; + + if (reset == VIRTCHNL_VFR_VFACTIVE || + reset == VIRTCHNL_VFR_COMPLETED) + break; + + rte_delay_ms(20); + } + + if (i >= ICE_DCF_RESET_WAIT_CNT) + return -1; + + return 0; +} + +static inline void +ice_dcf_enable_irq0(struct ice_dcf_hw *hw) +{ + struct iavf_hw *avf = &hw->avf; + + /* Enable admin queue interrupt trigger */ + IAVF_WRITE_REG(avf, IAVF_VFINT_ICR0_ENA1, + IAVF_VFINT_ICR0_ENA1_ADMINQ_MASK); + IAVF_WRITE_REG(avf, IAVF_VFINT_DYN_CTL01, + IAVF_VFINT_DYN_CTL01_INTENA_MASK | + IAVF_VFINT_DYN_CTL01_CLEARPBA_MASK | + IAVF_VFINT_DYN_CTL01_ITR_INDX_MASK); + + IAVF_WRITE_FLUSH(avf); +} + +static inline void +ice_dcf_disable_irq0(struct ice_dcf_hw *hw) +{ + struct iavf_hw *avf = &hw->avf; + + /* Disable all interrupt types */ + IAVF_WRITE_REG(avf, IAVF_VFINT_ICR0_ENA1, 0); + IAVF_WRITE_REG(avf, IAVF_VFINT_DYN_CTL01, + IAVF_VFINT_DYN_CTL01_ITR_INDX_MASK); + + IAVF_WRITE_FLUSH(avf); +} + +static void +ice_dcf_dev_interrupt_handler(void *param) +{ + struct ice_dcf_hw *hw = param; + + ice_dcf_disable_irq0(hw); + + ice_dcf_handle_virtchnl_msg(hw); + + ice_dcf_enable_irq0(hw); +} + +int +ice_dcf_execute_virtchnl_cmd(struct ice_dcf_hw *hw, + struct dcf_virtchnl_cmd *cmd) +{ + int i = 0; + int err; + + if ((cmd->req_msg && !cmd->req_msglen) || + (!cmd->req_msg && cmd->req_msglen) || + (cmd->rsp_msgbuf && !cmd->rsp_buflen) || + (!cmd->rsp_msgbuf && cmd->rsp_buflen)) + return -EINVAL; + + rte_spinlock_lock(&hw->vc_cmd_send_lock); + ice_dcf_vc_cmd_set(hw, cmd); + + err = ice_dcf_vc_cmd_send(hw, cmd); + if (err) { + PMD_DRV_LOG(ERR, "fail to send cmd %d", cmd->v_op); + goto ret; + } + + do { + if (!cmd->pending) + break; + + rte_delay_ms(ICE_DCF_ARQ_CHECK_TIME); + } while (i++ < ICE_DCF_ARQ_MAX_RETRIES); + + if (cmd->v_ret != IAVF_SUCCESS) { + err = -1; + PMD_DRV_LOG(ERR, + "No response (%d times) or return failure (%d) for cmd %d", + i, cmd->v_ret, cmd->v_op); + } + +ret: + ice_dcf_aq_cmd_clear(hw, cmd); + rte_spinlock_unlock(&hw->vc_cmd_send_lock); + return err; +} + +int +ice_dcf_send_aq_cmd(void *dcf_hw, struct ice_aq_desc *desc, + void *buf, uint16_t buf_size) +{ + struct dcf_virtchnl_cmd desc_cmd, buff_cmd; + struct ice_dcf_hw *hw = dcf_hw; + int err = 0; + int i = 0; + + if ((buf && !buf_size) || (!buf && buf_size) || + buf_size > ICE_DCF_AQ_BUF_SZ) + return -EINVAL; + + desc_cmd.v_op = VIRTCHNL_OP_DCF_CMD_DESC; + desc_cmd.req_msglen = sizeof(*desc); + desc_cmd.req_msg = (uint8_t *)desc; + desc_cmd.rsp_buflen = sizeof(*desc); + desc_cmd.rsp_msgbuf = (uint8_t *)desc; + + if (buf == NULL) + return ice_dcf_execute_virtchnl_cmd(hw, &desc_cmd); + + desc->flags |= rte_cpu_to_le_16(ICE_AQ_FLAG_BUF); + + buff_cmd.v_op = VIRTCHNL_OP_DCF_CMD_BUFF; + buff_cmd.req_msglen = buf_size; + buff_cmd.req_msg = buf; + buff_cmd.rsp_buflen = buf_size; + buff_cmd.rsp_msgbuf = buf; + + rte_spinlock_lock(&hw->vc_cmd_send_lock); + ice_dcf_vc_cmd_set(hw, &desc_cmd); + ice_dcf_vc_cmd_set(hw, &buff_cmd); + + if (ice_dcf_vc_cmd_send(hw, &desc_cmd) || + ice_dcf_vc_cmd_send(hw, &buff_cmd)) { + err = -1; + PMD_DRV_LOG(ERR, "fail to send OP_DCF_CMD_DESC/BUFF"); + goto ret; + } + + do { + if ((!desc_cmd.pending && !buff_cmd.pending) || + (!desc_cmd.pending && desc_cmd.v_ret != IAVF_SUCCESS) || + (!buff_cmd.pending && buff_cmd.v_ret != IAVF_SUCCESS)) + break; + + rte_delay_ms(ICE_DCF_ARQ_CHECK_TIME); + } while (i++ < ICE_DCF_ARQ_MAX_RETRIES); + + if (desc_cmd.v_ret != IAVF_SUCCESS || buff_cmd.v_ret != IAVF_SUCCESS) { + err = -1; + PMD_DRV_LOG(ERR, + "No response (%d times) or return failure (desc: %d / buff: %d)", + i, desc_cmd.v_ret, buff_cmd.v_ret); + } + +ret: + ice_dcf_aq_cmd_clear(hw, &desc_cmd); + ice_dcf_aq_cmd_clear(hw, &buff_cmd); + rte_spinlock_unlock(&hw->vc_cmd_send_lock); + + return err; +} + +int +ice_dcf_handle_vsi_update_event(struct ice_dcf_hw *hw) +{ + int err = 0; + + rte_spinlock_lock(&hw->vc_cmd_send_lock); + ice_dcf_disable_irq0(hw); + + if (ice_dcf_get_vf_resource(hw) || ice_dcf_get_vf_vsi_map(hw)) + err = -1; + + ice_dcf_enable_irq0(hw); + rte_spinlock_unlock(&hw->vc_cmd_send_lock); + + return err; +} + +int +ice_dcf_init_hw(struct rte_eth_dev *eth_dev, struct ice_dcf_hw *hw) +{ + struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev); + int ret; + + hw->avf.hw_addr = pci_dev->mem_resource[0].addr; + hw->avf.back = hw; + + hw->avf.bus.bus_id = pci_dev->addr.bus; + hw->avf.bus.device = pci_dev->addr.devid; + hw->avf.bus.func = pci_dev->addr.function; + + hw->avf.device_id = pci_dev->id.device_id; + hw->avf.vendor_id = pci_dev->id.vendor_id; + hw->avf.subsystem_device_id = pci_dev->id.subsystem_device_id; + hw->avf.subsystem_vendor_id = pci_dev->id.subsystem_vendor_id; + + hw->avf.aq.num_arq_entries = ICE_DCF_AQ_LEN; + hw->avf.aq.num_asq_entries = ICE_DCF_AQ_LEN; + hw->avf.aq.arq_buf_size = ICE_DCF_AQ_BUF_SZ; + hw->avf.aq.asq_buf_size = ICE_DCF_AQ_BUF_SZ; + + rte_spinlock_init(&hw->vc_cmd_send_lock); + rte_spinlock_init(&hw->vc_cmd_queue_lock); + TAILQ_INIT(&hw->vc_cmd_queue); + + hw->arq_buf = rte_zmalloc("arq_buf", ICE_DCF_AQ_BUF_SZ, 0); + if (hw->arq_buf == NULL) { + PMD_INIT_LOG(ERR, "unable to allocate AdminQ buffer memory"); + goto err; + } + + ret = iavf_set_mac_type(&hw->avf); + if (ret) { + PMD_INIT_LOG(ERR, "set_mac_type failed: %d", ret); + goto err; + } + + ret = ice_dcf_check_reset_done(hw); + if (ret) { + PMD_INIT_LOG(ERR, "VF is still resetting"); + goto err; + } + + ret = iavf_init_adminq(&hw->avf); + if (ret) { + PMD_INIT_LOG(ERR, "init_adminq failed: %d", ret); + goto err; + } + + if (ice_dcf_init_check_api_version(hw)) { + PMD_INIT_LOG(ERR, "check_api version failed"); + goto err_api; + } + + hw->vf_res = rte_zmalloc("vf_res", ICE_DCF_VF_RES_BUF_SZ, 0); + if (hw->vf_res == NULL) { + PMD_INIT_LOG(ERR, "unable to allocate vf_res memory"); + goto err_api; + } + + if (ice_dcf_get_vf_resource(hw)) { + PMD_INIT_LOG(ERR, "Failed to get VF resource"); + goto err_alloc; + } + + if (ice_dcf_get_vf_vsi_map(hw) < 0) { + PMD_INIT_LOG(ERR, "Failed to get VF VSI map"); + ice_dcf_mode_disable(hw); + goto err_alloc; + } + + rte_intr_callback_register(&pci_dev->intr_handle, + ice_dcf_dev_interrupt_handler, hw); + rte_intr_enable(&pci_dev->intr_handle); + ice_dcf_enable_irq0(hw); + + return 0; + +err_alloc: + rte_free(hw->vf_res); +err_api: + iavf_shutdown_adminq(&hw->avf); +err: + rte_free(hw->arq_buf); + + return -1; +} + +void +ice_dcf_uninit_hw(struct rte_eth_dev *eth_dev, struct ice_dcf_hw *hw) +{ + struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev); + struct rte_intr_handle *intr_handle = &pci_dev->intr_handle; + + ice_dcf_disable_irq0(hw); + rte_intr_disable(intr_handle); + rte_intr_callback_unregister(intr_handle, + ice_dcf_dev_interrupt_handler, hw); + + ice_dcf_mode_disable(hw); + iavf_shutdown_adminq(&hw->avf); + + rte_free(hw->arq_buf); + rte_free(hw->vf_vsi_map); + rte_free(hw->vf_res); +} diff --git a/drivers/net/ice/ice_dcf.h b/drivers/net/ice/ice_dcf.h new file mode 100644 index 000000000..58647d87f --- /dev/null +++ b/drivers/net/ice/ice_dcf.h @@ -0,0 +1,61 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#ifndef _ICE_DCF_H_ +#define _ICE_DCF_H_ + +#include + +#include +#include +#include + +#include "base/ice_type.h" +#include "ice_logs.h" + +struct dcf_virtchnl_cmd { + TAILQ_ENTRY(dcf_virtchnl_cmd) next; + + enum virtchnl_ops v_op; + enum iavf_status v_ret; + + uint16_t req_msglen; + uint8_t *req_msg; + + uint16_t rsp_msglen; + uint16_t rsp_buflen; + uint8_t *rsp_msgbuf; + + volatile int pending; +}; + +struct ice_dcf_hw { + struct iavf_hw avf; + + rte_spinlock_t vc_cmd_send_lock; + rte_spinlock_t vc_cmd_queue_lock; + TAILQ_HEAD(, dcf_virtchnl_cmd) vc_cmd_queue; + void (*vc_event_msg_cb)(struct ice_dcf_hw *dcf_hw, + uint8_t *msg, uint16_t msglen); + + uint8_t *arq_buf; + + uint16_t num_vfs; + uint16_t *vf_vsi_map; + + struct virtchnl_version_info virtchnl_version; + struct virtchnl_vf_resource *vf_res; /* VF resource */ + struct virtchnl_vsi_resource *vsi_res; /* LAN VSI */ + uint16_t vsi_id; +}; + +int ice_dcf_execute_virtchnl_cmd(struct ice_dcf_hw *hw, + struct dcf_virtchnl_cmd *cmd); +int ice_dcf_send_aq_cmd(void *dcf_hw, struct ice_aq_desc *desc, + void *buf, uint16_t buf_size); +int ice_dcf_handle_vsi_update_event(struct ice_dcf_hw *hw); +int ice_dcf_init_hw(struct rte_eth_dev *eth_dev, struct ice_dcf_hw *hw); +void ice_dcf_uninit_hw(struct rte_eth_dev *eth_dev, struct ice_dcf_hw *hw); + +#endif /* _ICE_DCF_H_ */ diff --git a/drivers/net/ice/ice_dcf_ethdev.c b/drivers/net/ice/ice_dcf_ethdev.c new file mode 100644 index 000000000..f65b962d4 --- /dev/null +++ b/drivers/net/ice/ice_dcf_ethdev.c @@ -0,0 +1,319 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "ice_generic_flow.h" +#include "ice_dcf_ethdev.h" + +static uint16_t +ice_dcf_recv_pkts(__rte_unused void *rx_queue, + __rte_unused struct rte_mbuf **bufs, + __rte_unused uint16_t nb_pkts) +{ + return 0; +} + +static uint16_t +ice_dcf_xmit_pkts(__rte_unused void *tx_queue, + __rte_unused struct rte_mbuf **bufs, + __rte_unused uint16_t nb_pkts) +{ + return 0; +} + +static int +ice_dcf_dev_start(struct rte_eth_dev *dev) +{ + dev->data->dev_link.link_status = ETH_LINK_UP; + + return 0; +} + +static void +ice_dcf_dev_stop(struct rte_eth_dev *dev) +{ + dev->data->dev_link.link_status = ETH_LINK_DOWN; +} + +static int +ice_dcf_dev_configure(__rte_unused struct rte_eth_dev *dev) +{ + return 0; +} + +static int +ice_dcf_dev_info_get(struct rte_eth_dev *dev, + struct rte_eth_dev_info *dev_info) +{ + struct ice_dcf_adapter *adapter = dev->data->dev_private; + + dev_info->max_mac_addrs = 1; + dev_info->max_rx_pktlen = (uint32_t)-1; + dev_info->max_rx_queues = RTE_DIM(adapter->rxqs); + dev_info->max_tx_queues = RTE_DIM(adapter->txqs); + + return 0; +} + +static int +ice_dcf_stats_get(__rte_unused struct rte_eth_dev *dev, + __rte_unused struct rte_eth_stats *igb_stats) +{ + return 0; +} + +static int +ice_dcf_stats_reset(__rte_unused struct rte_eth_dev *dev) +{ + return 0; +} + +static int +ice_dcf_dev_promiscuous_enable(__rte_unused struct rte_eth_dev *dev) +{ + return 0; +} + +static int +ice_dcf_dev_promiscuous_disable(__rte_unused struct rte_eth_dev *dev) +{ + return 0; +} + +static int +ice_dcf_dev_allmulticast_enable(__rte_unused struct rte_eth_dev *dev) +{ + return 0; +} + +static int +ice_dcf_dev_allmulticast_disable(__rte_unused struct rte_eth_dev *dev) +{ + return 0; +} + +static int +ice_dcf_dev_filter_ctrl(struct rte_eth_dev *dev, + enum rte_filter_type filter_type, + __rte_unused enum rte_filter_op filter_op, + __rte_unused void *arg) +{ + int ret = 0; + + if (!dev) + return -EINVAL; + + switch (filter_type) { + default: + PMD_DRV_LOG(WARNING, "Filter type (%d) not supported", + filter_type); + ret = -EINVAL; + break; + } + + return ret; +} + +static void +ice_dcf_dev_close(struct rte_eth_dev *dev) +{ + struct ice_dcf_adapter *adapter = dev->data->dev_private; + + if (rte_eal_process_type() != RTE_PROC_PRIMARY) + return; + + dev->dev_ops = NULL; + dev->rx_pkt_burst = NULL; + dev->tx_pkt_burst = NULL; + + ice_dcf_uninit_parent_adapter(dev); + ice_dcf_uninit_hw(dev, &adapter->real_hw); +} + +static void +ice_dcf_queue_release(__rte_unused void *q) +{ +} + +static int +ice_dcf_link_update(__rte_unused struct rte_eth_dev *dev, + __rte_unused int wait_to_complete) +{ + return 0; +} + +static int +ice_dcf_rx_queue_setup(struct rte_eth_dev *dev, + uint16_t rx_queue_id, + __rte_unused uint16_t nb_rx_desc, + __rte_unused unsigned int socket_id, + __rte_unused const struct rte_eth_rxconf *rx_conf, + __rte_unused struct rte_mempool *mb_pool) +{ + struct ice_dcf_adapter *adapter = dev->data->dev_private; + + dev->data->rx_queues[rx_queue_id] = &adapter->rxqs[rx_queue_id]; + + return 0; +} + +static int +ice_dcf_tx_queue_setup(struct rte_eth_dev *dev, + uint16_t tx_queue_id, + __rte_unused uint16_t nb_tx_desc, + __rte_unused unsigned int socket_id, + __rte_unused const struct rte_eth_txconf *tx_conf) +{ + struct ice_dcf_adapter *adapter = dev->data->dev_private; + + dev->data->tx_queues[tx_queue_id] = &adapter->txqs[tx_queue_id]; + + return 0; +} + +static const struct eth_dev_ops ice_dcf_eth_dev_ops = { + .dev_start = ice_dcf_dev_start, + .dev_stop = ice_dcf_dev_stop, + .dev_close = ice_dcf_dev_close, + .dev_configure = ice_dcf_dev_configure, + .dev_infos_get = ice_dcf_dev_info_get, + .rx_queue_setup = ice_dcf_rx_queue_setup, + .tx_queue_setup = ice_dcf_tx_queue_setup, + .rx_queue_release = ice_dcf_queue_release, + .tx_queue_release = ice_dcf_queue_release, + .link_update = ice_dcf_link_update, + .stats_get = ice_dcf_stats_get, + .stats_reset = ice_dcf_stats_reset, + .promiscuous_enable = ice_dcf_dev_promiscuous_enable, + .promiscuous_disable = ice_dcf_dev_promiscuous_disable, + .allmulticast_enable = ice_dcf_dev_allmulticast_enable, + .allmulticast_disable = ice_dcf_dev_allmulticast_disable, + .filter_ctrl = ice_dcf_dev_filter_ctrl, +}; + +static int +ice_dcf_dev_init(struct rte_eth_dev *eth_dev) +{ + struct ice_dcf_adapter *adapter = eth_dev->data->dev_private; + + eth_dev->dev_ops = &ice_dcf_eth_dev_ops; + eth_dev->rx_pkt_burst = ice_dcf_recv_pkts; + eth_dev->tx_pkt_burst = ice_dcf_xmit_pkts; + + if (rte_eal_process_type() != RTE_PROC_PRIMARY) + return 0; + + eth_dev->data->dev_flags |= RTE_ETH_DEV_CLOSE_REMOVE; + + adapter->real_hw.vc_event_msg_cb = ice_dcf_handle_pf_event_msg; + if (ice_dcf_init_hw(eth_dev, &adapter->real_hw) != 0) { + PMD_DRV_LOG(ERR, "Failed to init DCF hardware"); + return -1; + } + + if (ice_dcf_init_parent_adapter(eth_dev) != 0) { + PMD_DRV_LOG(ERR, "Failed to init DCF parent adapter"); + ice_dcf_uninit_hw(eth_dev, &adapter->real_hw); + return -1; + } + + return 0; +} + +static int +ice_dcf_dev_uninit(struct rte_eth_dev *eth_dev) +{ + ice_dcf_dev_close(eth_dev); + + return 0; +} + +static int +handle_dcf_arg(__rte_unused const char *key, const char *value, + __rte_unused void *arg) +{ + bool *dcf = arg; + + if (arg == NULL || value == NULL) + return -EINVAL; + + if (strcmp(value, "dcf") == 0) + *dcf = true; + else + *dcf = false; + + return 0; +} + +static bool +check_cap_dcf_enable(struct rte_devargs *devargs) +{ + struct rte_kvargs *kvlist; + bool enable = false; + + if (devargs == NULL) + return false; + + kvlist = rte_kvargs_parse(devargs->args, NULL); + if (kvlist == NULL) + return false; + + rte_kvargs_process(kvlist, "cap", handle_dcf_arg, &enable); + + rte_kvargs_free(kvlist); + + return enable; +} + +static int eth_ice_dcf_pci_probe(__rte_unused struct rte_pci_driver *pci_drv, + struct rte_pci_device *pci_dev) +{ + if (!check_cap_dcf_enable(pci_dev->device.devargs)) + return 1; /* continue to probe */ + + return rte_eth_dev_pci_generic_probe(pci_dev, + sizeof(struct ice_dcf_adapter), + ice_dcf_dev_init); +} + +static int eth_ice_dcf_pci_remove(struct rte_pci_device *pci_dev) +{ + return rte_eth_dev_pci_generic_remove(pci_dev, ice_dcf_dev_uninit); +} + +static const struct rte_pci_id pci_id_ice_dcf_map[] = { + { RTE_PCI_DEVICE(IAVF_INTEL_VENDOR_ID, IAVF_DEV_ID_ADAPTIVE_VF) }, + { .vendor_id = 0, /* sentinel */ }, +}; + +static struct rte_pci_driver rte_ice_dcf_pmd = { + .id_table = pci_id_ice_dcf_map, + .drv_flags = RTE_PCI_DRV_NEED_MAPPING, + .probe = eth_ice_dcf_pci_probe, + .remove = eth_ice_dcf_pci_remove, +}; + +RTE_PMD_REGISTER_PCI(net_ice_dcf, rte_ice_dcf_pmd); +RTE_PMD_REGISTER_PCI_TABLE(net_ice_dcf, pci_id_ice_dcf_map); +RTE_PMD_REGISTER_KMOD_DEP(net_ice_dcf, "* igb_uio | vfio-pci"); +RTE_PMD_REGISTER_PARAM_STRING(net_ice_dcf, "cap=dcf"); diff --git a/drivers/net/ice/ice_dcf_ethdev.h b/drivers/net/ice/ice_dcf_ethdev.h new file mode 100644 index 000000000..e95266599 --- /dev/null +++ b/drivers/net/ice/ice_dcf_ethdev.h @@ -0,0 +1,33 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#ifndef _ICE_DCF_ETHDEV_H_ +#define _ICE_DCF_ETHDEV_H_ + +#include "base/ice_common.h" +#include "base/ice_adminq_cmd.h" + +#include "ice_ethdev.h" +#include "ice_dcf.h" + +#define ICE_DCF_MAX_RINGS 1 + +struct ice_dcf_queue { + uint64_t dummy; +}; + +struct ice_dcf_adapter { + struct ice_adapter parent; /* Must be first */ + + struct ice_dcf_hw real_hw; + struct ice_dcf_queue rxqs[ICE_DCF_MAX_RINGS]; + struct ice_dcf_queue txqs[ICE_DCF_MAX_RINGS]; +}; + +void ice_dcf_handle_pf_event_msg(struct ice_dcf_hw *dcf_hw, + uint8_t *msg, uint16_t msglen); +int ice_dcf_init_parent_adapter(struct rte_eth_dev *eth_dev); +void ice_dcf_uninit_parent_adapter(struct rte_eth_dev *eth_dev); + +#endif /* _ICE_DCF_ETHDEV_H_ */ diff --git a/drivers/net/ice/ice_dcf_parent.c b/drivers/net/ice/ice_dcf_parent.c new file mode 100644 index 000000000..bca9cd34a --- /dev/null +++ b/drivers/net/ice/ice_dcf_parent.c @@ -0,0 +1,348 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ +#include +#include +#include + +#include + +#include "ice_dcf_ethdev.h" +#include "ice_generic_flow.h" + +#define ICE_DCF_VSI_UPDATE_SERVICE_INTERVAL 100000 /* us */ + +static __rte_always_inline void +ice_dcf_update_vsi_ctx(struct ice_hw *hw, uint16_t vsi_handle, + uint16_t vsi_map) +{ + struct ice_vsi_ctx *vsi_ctx; + + if (unlikely(vsi_handle >= ICE_MAX_VSI)) { + PMD_DRV_LOG(ERR, "Invalid vsi handle %u", vsi_handle); + return; + } + + vsi_ctx = hw->vsi_ctx[vsi_handle]; + + if (vsi_map & VIRTCHNL_DCF_VF_VSI_VALID) { + if (!vsi_ctx) + vsi_ctx = ice_malloc(hw, sizeof(*vsi_ctx)); + + if (!vsi_ctx) { + PMD_DRV_LOG(ERR, "No memory for vsi context %u", + vsi_handle); + return; + } + + vsi_ctx->vsi_num = (vsi_map & VIRTCHNL_DCF_VF_VSI_ID_M) >> + VIRTCHNL_DCF_VF_VSI_ID_S; + hw->vsi_ctx[vsi_handle] = vsi_ctx; + + PMD_DRV_LOG(DEBUG, "VF%u is assigned with vsi number %u", + vsi_handle, vsi_ctx->vsi_num); + } else { + hw->vsi_ctx[vsi_handle] = NULL; + + if (vsi_ctx) + ice_free(hw, vsi_ctx); + + PMD_DRV_LOG(NOTICE, "VF%u is disabled", vsi_handle); + } +} + +static void +ice_dcf_update_vf_vsi_map(struct ice_hw *hw, uint16_t num_vfs, + uint16_t *vf_vsi_map) +{ + uint16_t vf_id; + + for (vf_id = 0; vf_id < num_vfs; vf_id++) + ice_dcf_update_vsi_ctx(hw, vf_id, vf_vsi_map[vf_id]); +} + +static void +ice_dcf_vsi_update_service_handler(void *param) +{ + struct ice_dcf_hw *hw = param; + + if (!ice_dcf_handle_vsi_update_event(hw)) { + struct ice_dcf_adapter *dcf_ad = + container_of(hw, struct ice_dcf_adapter, real_hw); + + ice_dcf_update_vf_vsi_map(&dcf_ad->parent.hw, + hw->num_vfs, hw->vf_vsi_map); + } +} + +void +ice_dcf_handle_pf_event_msg(struct ice_dcf_hw *dcf_hw, + uint8_t *msg, uint16_t msglen) +{ + struct virtchnl_pf_event *pf_msg = (struct virtchnl_pf_event *)msg; + + if (msglen < sizeof(struct virtchnl_pf_event)) { + PMD_DRV_LOG(DEBUG, "Invalid event message length : %u", msglen); + return; + } + + switch (pf_msg->event) { + case VIRTCHNL_EVENT_RESET_IMPENDING: + PMD_DRV_LOG(DEBUG, "VIRTCHNL_EVENT_RESET_IMPENDING event"); + rte_eal_alarm_set(ICE_DCF_VSI_UPDATE_SERVICE_INTERVAL * 2, + ice_dcf_vsi_update_service_handler, dcf_hw); + break; + case VIRTCHNL_EVENT_LINK_CHANGE: + PMD_DRV_LOG(DEBUG, "VIRTCHNL_EVENT_LINK_CHANGE event"); + break; + case VIRTCHNL_EVENT_PF_DRIVER_CLOSE: + PMD_DRV_LOG(DEBUG, "VIRTCHNL_EVENT_PF_DRIVER_CLOSE event"); + break; + case VIRTCHNL_EVENT_DCF_VSI_MAP_UPDATE: + PMD_DRV_LOG(DEBUG, "VIRTCHNL_EVENT_DCF_VSI_MAP_UPDATE event : VF%u with VSI num %u", + pf_msg->event_data.vf_vsi_map.vf_id, + pf_msg->event_data.vf_vsi_map.vsi_id); + rte_eal_alarm_set(ICE_DCF_VSI_UPDATE_SERVICE_INTERVAL, + ice_dcf_vsi_update_service_handler, dcf_hw); + break; + default: + PMD_DRV_LOG(ERR, "Unknown event received %u", pf_msg->event); + break; + } +} + +static int +ice_dcf_init_parent_hw(struct ice_hw *hw) +{ + struct ice_aqc_get_phy_caps_data *pcaps; + enum ice_status status; + + status = ice_aq_get_fw_ver(hw, NULL); + if (status) + return status; + + status = ice_get_caps(hw); + if (status) + return status; + + hw->port_info = (struct ice_port_info *) + ice_malloc(hw, sizeof(*hw->port_info)); + if (!hw->port_info) + return ICE_ERR_NO_MEMORY; + + /* set the back pointer to HW */ + hw->port_info->hw = hw; + + /* Initialize port_info struct with switch configuration data */ + status = ice_get_initial_sw_cfg(hw); + if (status) + goto err_unroll_alloc; + + pcaps = (struct ice_aqc_get_phy_caps_data *) + ice_malloc(hw, sizeof(*pcaps)); + if (!pcaps) { + status = ICE_ERR_NO_MEMORY; + goto err_unroll_alloc; + } + + /* Initialize port_info struct with PHY capabilities */ + status = ice_aq_get_phy_caps(hw->port_info, false, + ICE_AQC_REPORT_TOPO_CAP, pcaps, NULL); + ice_free(hw, pcaps); + if (status) + goto err_unroll_alloc; + + /* Initialize port_info struct with link information */ + status = ice_aq_get_link_info(hw->port_info, false, NULL, NULL); + if (status) + goto err_unroll_alloc; + + status = ice_init_fltr_mgmt_struct(hw); + if (status) + goto err_unroll_alloc; + + status = ice_init_hw_tbls(hw); + if (status) + goto err_unroll_fltr_mgmt_struct; + + PMD_DRV_LOG(INFO, + "firmware %d.%d.%d api %d.%d.%d build 0x%08x", + hw->fw_maj_ver, hw->fw_min_ver, hw->fw_patch, + hw->api_maj_ver, hw->api_min_ver, hw->api_patch, + hw->fw_build); + + return ICE_SUCCESS; + +err_unroll_fltr_mgmt_struct: + ice_cleanup_fltr_mgmt_struct(hw); +err_unroll_alloc: + ice_free(hw, hw->port_info); + hw->port_info = NULL; + + return status; +} + +static void ice_dcf_uninit_parent_hw(struct ice_hw *hw) +{ + ice_cleanup_fltr_mgmt_struct(hw); + + ice_free_seg(hw); + ice_free_hw_tbls(hw); + + if (hw->port_info) { + ice_free(hw, hw->port_info); + hw->port_info = NULL; + } + + ice_clear_all_vsi_ctx(hw); +} + +static int +ice_dcf_request_pkg_name(struct ice_hw *hw, char *pkg_name) +{ + struct ice_dcf_adapter *dcf_adapter = + container_of(hw, struct ice_dcf_adapter, parent.hw); + + /* TODO: check with DSN firstly by iAVF */ + PMD_DRV_LOG(DEBUG, + "DCF VSI_ID = %u", + dcf_adapter->real_hw.vsi_id); + + snprintf(pkg_name, + ICE_MAX_PKG_FILENAME_SIZE, "%s", ICE_PKG_FILE_UPDATES); + if (!access(pkg_name, 0)) + return 0; + + snprintf(pkg_name, + ICE_MAX_PKG_FILENAME_SIZE, "%s", ICE_PKG_FILE_DEFAULT); + if (!access(pkg_name, 0)) + return 0; + + return -1; +} + +static int +ice_dcf_load_pkg(struct ice_hw *hw) +{ + char pkg_name[ICE_MAX_PKG_FILENAME_SIZE]; + uint8_t *pkg_buf; + uint32_t buf_len; + struct stat st; + FILE *fp; + int err; + + if (ice_dcf_request_pkg_name(hw, pkg_name)) { + PMD_INIT_LOG(ERR, "failed to locate the package file"); + return -ENOENT; + } + + PMD_INIT_LOG(DEBUG, "DDP package name: %s", pkg_name); + + err = stat(pkg_name, &st); + if (err) { + PMD_INIT_LOG(ERR, "failed to get file status"); + return err; + } + + buf_len = st.st_size; + pkg_buf = rte_malloc(NULL, buf_len, 0); + if (!pkg_buf) { + PMD_INIT_LOG(ERR, "failed to allocate buffer of size %u for package", + buf_len); + return -1; + } + + fp = fopen(pkg_name, "rb"); + if (!fp) { + PMD_INIT_LOG(ERR, "failed to open file: %s", pkg_name); + err = -1; + goto ret; + } + + err = fread(pkg_buf, buf_len, 1, fp); + fclose(fp); + if (err != 1) { + PMD_INIT_LOG(ERR, "failed to read package data"); + err = -1; + goto ret; + } + + err = ice_copy_and_init_pkg(hw, pkg_buf, buf_len); + if (err) + PMD_INIT_LOG(ERR, "ice_copy_and_init_hw failed: %d", err); + +ret: + rte_free(pkg_buf); + return err; +} + +int +ice_dcf_init_parent_adapter(struct rte_eth_dev *eth_dev) +{ + struct ice_dcf_adapter *adapter = eth_dev->data->dev_private; + struct ice_adapter *parent_adapter = &adapter->parent; + struct ice_hw *parent_hw = &parent_adapter->hw; + struct ice_dcf_hw *hw = &adapter->real_hw; + const struct rte_ether_addr *mac; + int err; + + parent_adapter->eth_dev = eth_dev; + parent_adapter->pf.adapter = parent_adapter; + parent_adapter->pf.dev_data = eth_dev->data; + parent_hw->back = parent_adapter; + parent_hw->mac_type = ICE_MAC_GENERIC; + parent_hw->vendor_id = ICE_INTEL_VENDOR_ID; + + ice_init_lock(&parent_hw->adminq.sq_lock); + ice_init_lock(&parent_hw->adminq.rq_lock); + parent_hw->aq_send_cmd_fn = ice_dcf_send_aq_cmd; + parent_hw->aq_send_cmd_param = &adapter->real_hw; + parent_hw->dcf_enabled = true; + + err = ice_dcf_init_parent_hw(parent_hw); + if (err) { + PMD_DRV_LOG(ERR, "failed to init the DCF parent hardware with error %d", + err); + return err; + } + + err = ice_dcf_load_pkg(parent_hw); + if (err) { + PMD_DRV_LOG(ERR, "failed to load package with error %d", + err); + goto uninit_hw; + } + parent_adapter->active_pkg_type = ice_load_pkg_type(parent_hw); + + ice_dcf_update_vf_vsi_map(parent_hw, + hw->num_vfs, hw->vf_vsi_map); + + mac = (const struct rte_ether_addr *)hw->avf.mac.addr; + if (rte_is_valid_assigned_ether_addr(mac)) + rte_ether_addr_copy(mac, &parent_adapter->pf.dev_addr); + else + rte_eth_random_addr(parent_adapter->pf.dev_addr.addr_bytes); + + eth_dev->data->mac_addrs = &parent_adapter->pf.dev_addr; + + return 0; + +uninit_hw: + ice_dcf_uninit_parent_hw(parent_hw); + return err; +} + +void +ice_dcf_uninit_parent_adapter(struct rte_eth_dev *eth_dev) +{ + struct ice_dcf_adapter *adapter = eth_dev->data->dev_private; + struct ice_adapter *parent_adapter = &adapter->parent; + struct ice_hw *parent_hw = &parent_adapter->hw; + + eth_dev->data->mac_addrs = NULL; + + rte_eal_alarm_cancel(ice_dcf_vsi_update_service_handler, + &adapter->real_hw); + + ice_dcf_uninit_parent_hw(parent_hw); +} diff --git a/drivers/net/ice/meson.build b/drivers/net/ice/meson.build index f9e897bbc..0df8ddc0f 100644 --- a/drivers/net/ice/meson.build +++ b/drivers/net/ice/meson.build @@ -15,8 +15,8 @@ sources = files( 'ice_hash.c' ) -deps += ['hash'] -includes += include_directories('base') +deps += ['hash', 'net', 'common_iavf'] +includes += include_directories('base', '../../common/iavf') if arch_subdir == 'x86' sources += files('ice_rxtx_vec_sse.c') @@ -37,4 +37,8 @@ if arch_subdir == 'x86' endif endif +sources += files('ice_dcf.c', + 'ice_dcf_parent.c', + 'ice_dcf_ethdev.c') + install_headers('rte_pmd_ice.h') diff --git a/mk/rte.app.mk b/mk/rte.app.mk index d295ca0a5..f3798a09f 100644 --- a/mk/rte.app.mk +++ b/mk/rte.app.mk @@ -185,6 +185,7 @@ _LDLIBS-$(CONFIG_RTE_LIBRTE_I40E_PMD) += -lrte_pmd_i40e _LDLIBS-$(CONFIG_RTE_LIBRTE_IAVF_PMD) += -lrte_pmd_iavf _LDLIBS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += -lrte_pmd_ice IAVF-y := $(CONFIG_RTE_LIBRTE_IAVF_PMD) +IAVF-y += $(CONFIG_RTE_LIBRTE_ICE_PMD) ifeq ($(findstring y,$(IAVF-y)),y) _LDLIBS-y += -lrte_common_iavf endif -- 2.25.1