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 446A2A0563; Tue, 10 Mar 2020 07:58:37 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id D85B61C002; Tue, 10 Mar 2020 07:58:24 +0100 (CET) Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) by dpdk.org (Postfix) with ESMTP id 414B41C002 for ; Tue, 10 Mar 2020 07:58:22 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga106.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 09 Mar 2020 23:58:21 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,518,1574150400"; d="scan'208";a="321693944" Received: from npg-dpdk-haiyue-1.sh.intel.com ([10.67.119.213]) by orsmga001.jf.intel.com with ESMTP; 09 Mar 2020 23:58:17 -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: Tue, 10 Mar 2020 14:50:24 +0800 Message-Id: <20200310065029.40966-3-haiyue.wang@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20200310065029.40966-1-haiyue.wang@intel.com> References: <20200309141437.11800-1-haiyue.wang@intel.com> <20200310065029.40966-1-haiyue.wang@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [dpdk-dev] [PATCH v2 2/7] net/ice: add the DCF hardware initialization 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" Introduce the DCF (Device Config Function) feature in the ice PMD, it works as a standalone PMD which doesn't handle the packet Rx/Tx related things. Its hardware entity is the VF. Add the basic DCF hardware initialization, this is specified by devarg 'cap=dcf'. Signed-off-by: Haiyue Wang --- doc/guides/nics/ice.rst | 47 +++ doc/guides/nics/img/ice_dcf.png | Bin 0 -> 39168 bytes doc/guides/rel_notes/release_20_05.rst | 5 + drivers/common/Makefile | 1 + drivers/net/ice/Makefile | 5 + drivers/net/ice/ice_dcf.c | 474 +++++++++++++++++++++++++ drivers/net/ice/ice_dcf.h | 52 +++ drivers/net/ice/ice_dcf_ethdev.c | 317 +++++++++++++++++ drivers/net/ice/ice_dcf_ethdev.h | 24 ++ drivers/net/ice/meson.build | 7 +- mk/rte.app.mk | 1 + 11 files changed, 931 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 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/doc/guides/rel_notes/release_20_05.rst b/doc/guides/rel_notes/release_20_05.rst index 000bbf501..f404ee7fd 100644 --- a/doc/guides/rel_notes/release_20_05.rst +++ b/doc/guides/rel_notes/release_20_05.rst @@ -62,6 +62,11 @@ New Features * Added support for matching on IPv4 Time To Live and IPv6 Hop Limit. +* **Updated the Intel ice driver.** + + Updated the Intel ice driver with new features and improvements, including: + + * Added support for DCF (Device Config Function) feature. Removed Items ------------- 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..f493c9ed7 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,9 @@ 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_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..efb258a5a --- /dev/null +++ b/drivers/net/ice/ice_dcf.c @@ -0,0 +1,474 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 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)) + 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_INIT_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_INIT_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 | + 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_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_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; + } + + 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); + + iavf_shutdown_adminq(&hw->avf); + + rte_free(hw->arq_buf); + 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..f44c09db2 --- /dev/null +++ b/drivers/net/ice/ice_dcf.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Intel Corporation + */ + +#ifndef _ICE_DCF_H_ +#define _ICE_DCF_H_ + +#include + +#include +#include +#include + +#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; + uint8_t *arq_buf; + + 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_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..23f82a487 --- /dev/null +++ b/drivers/net/ice/ice_dcf_ethdev.c @@ -0,0 +1,317 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 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; + dev->data->mac_addrs = NULL; + + 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; + + if (ice_dcf_init_hw(eth_dev, &adapter->real_hw) != 0) { + PMD_INIT_LOG(ERR, "Failed to init DCF hardware"); + return -1; + } + + rte_eth_random_addr(adapter->mac_addr.addr_bytes); + eth_dev->data->mac_addrs = &adapter->mac_addr; + + return 0; +} + +static int +ice_dcf_dev_uninit(struct rte_eth_dev *eth_dev) +{ + ice_dcf_dev_close(eth_dev); + + return 0; +} + +static int +ice_dcf_cap_check_handler(__rte_unused const char *key, + const char *value, __rte_unused void *opaque) +{ + if (strcmp(value, "dcf")) + return -1; + + return 0; +} + +static int +ice_dcf_cap_selected(struct rte_devargs *devargs) +{ + struct rte_kvargs *kvlist; + const char *key = "cap"; + int ret = 0; + + if (devargs == NULL) + return 0; + + kvlist = rte_kvargs_parse(devargs->args, NULL); + if (kvlist == NULL) + return 0; + + if (!rte_kvargs_count(kvlist, key)) + goto exit; + + /* dcf capability selected when there's a key-value pair: cap=dcf */ + if (rte_kvargs_process(kvlist, key, + ice_dcf_cap_check_handler, NULL) < 0) + goto exit; + + ret = 1; + +exit: + rte_kvargs_free(kvlist); + return ret; +} + +static int eth_ice_dcf_pci_probe(__rte_unused struct rte_pci_driver *pci_drv, + struct rte_pci_device *pci_dev) +{ + if (!ice_dcf_cap_selected(pci_dev->device.devargs)) + return 1; + + 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..0c34a0095 --- /dev/null +++ b/drivers/net/ice/ice_dcf_ethdev.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Intel Corporation + */ + +#ifndef _ICE_DCF_ETHDEV_H_ +#define _ICE_DCF_ETHDEV_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_dcf_hw real_hw; + struct rte_ether_addr mac_addr; + struct ice_dcf_queue rxqs[ICE_DCF_MAX_RINGS]; + struct ice_dcf_queue txqs[ICE_DCF_MAX_RINGS]; +}; + +#endif /* _ICE_DCF_ETHDEV_H_ */ diff --git a/drivers/net/ice/meson.build b/drivers/net/ice/meson.build index f9e897bbc..0ba9668d1 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,7 @@ if arch_subdir == 'x86' endif endif +sources += files('ice_dcf.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