From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by dpdk.org (Postfix) with ESMTP id 284C91B8B5 for ; Mon, 17 Dec 2018 08:33:22 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga102.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 16 Dec 2018 23:33:21 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,364,1539673200"; d="scan'208";a="118899303" Received: from dpdk26.sh.intel.com ([10.67.110.164]) by orsmga002.jf.intel.com with ESMTP; 16 Dec 2018 23:33:20 -0800 From: Wenzhuo Lu To: dev@dpdk.org Cc: Wenzhuo Lu , Qiming Yang , Xiaoyun Li , Jingjing Wu Date: Mon, 17 Dec 2018 15:37:30 +0800 Message-Id: <1545032259-77179-23-git-send-email-wenzhuo.lu@intel.com> X-Mailer: git-send-email 1.9.3 In-Reply-To: <1545032259-77179-1-git-send-email-wenzhuo.lu@intel.com> References: <1542956179-80951-1-git-send-email-wenzhuo.lu@intel.com> <1545032259-77179-1-git-send-email-wenzhuo.lu@intel.com> Subject: [dpdk-dev] [PATCH v5 22/31] net/ice: support VLAN ops 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: , X-List-Received-Date: Mon, 17 Dec 2018 07:33:22 -0000 Add below ops, ice_vlan_filter_set ice_vlan_offload_set ice_vlan_tpid_set ice_vlan_pvid_set Signed-off-by: Wenzhuo Lu Signed-off-by: Qiming Yang Signed-off-by: Xiaoyun Li Signed-off-by: Jingjing Wu --- doc/guides/nics/features/ice.ini | 3 + doc/guides/nics/ice.rst | 16 ++ drivers/net/ice/ice_ethdev.c | 590 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 609 insertions(+) diff --git a/doc/guides/nics/features/ice.ini b/doc/guides/nics/features/ice.ini index 759a036..5ac8e56 100644 --- a/doc/guides/nics/features/ice.ini +++ b/doc/guides/nics/features/ice.ini @@ -12,6 +12,9 @@ MTU update = Y Jumbo frame = Y Unicast MAC filter = Y Multicast MAC filter = Y +VLAN filter = Y +VLAN offload = Y +QinQ offload = Y BSD nic_uio = Y Linux UIO = Y Linux VFIO = Y diff --git a/doc/guides/nics/ice.rst b/doc/guides/nics/ice.rst index 96a594f..466af55 100644 --- a/doc/guides/nics/ice.rst +++ b/doc/guides/nics/ice.rst @@ -64,6 +64,22 @@ Driver compilation and testing Refer to the document :ref:`compiling and testing a PMD for a NIC ` for details. +Sample Application Notes +------------------------ + +Vlan filter +~~~~~~~~~~~ + +Vlan filter only works when Promiscuous mode is off. + +To start ``testpmd``, and add vlan 10 to port 0: + +.. code-block:: console + + ./app/testpmd -l 0-15 -n 4 -- -i + ... + + testpmd> rx_vlan add 10 0 Limitations or Known issues --------------------------- diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index 29840fd..1d3cc7a 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -24,6 +24,13 @@ static void ice_dev_info_get(struct rte_eth_dev *dev, static int ice_link_update(struct rte_eth_dev *dev, int wait_to_complete); static int ice_mtu_set(struct rte_eth_dev *dev, uint16_t mtu); +static int ice_vlan_offload_set(struct rte_eth_dev *dev, int mask); +static int ice_vlan_tpid_set(struct rte_eth_dev *dev, + enum rte_vlan_type vlan_type, + uint16_t tpid); +static int ice_vlan_filter_set(struct rte_eth_dev *dev, + uint16_t vlan_id, + int on); static int ice_macaddr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr); static int ice_macaddr_add(struct rte_eth_dev *dev, @@ -31,6 +38,8 @@ static int ice_macaddr_add(struct rte_eth_dev *dev, __rte_unused uint32_t index, uint32_t pool); static void ice_macaddr_remove(struct rte_eth_dev *dev, uint32_t index); +static int ice_vlan_pvid_set(struct rte_eth_dev *dev, + uint16_t pvid, int on); static const struct rte_pci_id pci_id_ice_map[] = { { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E810C_BACKPLANE) }, @@ -60,6 +69,10 @@ static int ice_macaddr_add(struct rte_eth_dev *dev, .mac_addr_set = ice_macaddr_set, .mac_addr_add = ice_macaddr_add, .mac_addr_remove = ice_macaddr_remove, + .vlan_filter_set = ice_vlan_filter_set, + .vlan_offload_set = ice_vlan_offload_set, + .vlan_tpid_set = ice_vlan_tpid_set, + .vlan_pvid_set = ice_vlan_pvid_set, }; static void @@ -470,6 +483,297 @@ static int ice_macaddr_add(struct rte_eth_dev *dev, return ret; } +/* Find out specific VLAN filter */ +static struct ice_vlan_filter * +ice_find_vlan_filter(struct ice_vsi *vsi, uint16_t vlan_id) +{ + struct ice_vlan_filter *f; + + TAILQ_FOREACH(f, &vsi->vlan_list, next) { + if (vlan_id == f->vlan_info.vlan_id) + return f; + } + + return NULL; +} + +static int +ice_add_vlan_filter(struct ice_vsi *vsi, uint16_t vlan_id) +{ + struct ice_fltr_list_entry *v_list_itr = NULL; + struct ice_vlan_filter *f; + struct LIST_HEAD_TYPE list_head; + struct ice_hw *hw = ICE_VSI_TO_HW(vsi); + int ret = 0; + + if (!vsi || vlan_id > ETHER_MAX_VLAN_ID) + return -EINVAL; + + /* If it's added and configured, return. */ + f = ice_find_vlan_filter(vsi, vlan_id); + if (f) { + PMD_DRV_LOG(INFO, "This VLAN filter already exists."); + return 0; + } + + if (!vsi->vlan_anti_spoof_on && !vsi->vlan_filter_on) + return 0; + + INIT_LIST_HEAD(&list_head); + + v_list_itr = (struct ice_fltr_list_entry *) + ice_malloc(hw, sizeof(*v_list_itr)); + if (!v_list_itr) { + ret = -ENOMEM; + goto DONE; + } + v_list_itr->fltr_info.l_data.vlan.vlan_id = vlan_id; + v_list_itr->fltr_info.src_id = ICE_SRC_ID_VSI; + v_list_itr->fltr_info.fltr_act = ICE_FWD_TO_VSI; + v_list_itr->fltr_info.lkup_type = ICE_SW_LKUP_VLAN; + v_list_itr->fltr_info.flag = ICE_FLTR_TX; + v_list_itr->fltr_info.vsi_handle = vsi->idx; + + LIST_ADD(&v_list_itr->list_entry, &list_head); + + /* Add the vlan */ + ret = ice_add_vlan(hw, &list_head); + if (ret != ICE_SUCCESS) { + PMD_DRV_LOG(ERR, "Failed to add VLAN filter"); + ret = -EINVAL; + goto DONE; + } + + /* Add vlan into vlan list */ + f = rte_zmalloc(NULL, sizeof(*f), 0); + if (!f) { + PMD_DRV_LOG(ERR, "failed to allocate memory"); + ret = -ENOMEM; + goto DONE; + } + f->vlan_info.vlan_id = vlan_id; + TAILQ_INSERT_TAIL(&vsi->vlan_list, f, next); + vsi->vlan_num++; + + ret = 0; + +DONE: + rte_free(v_list_itr); + return ret; +} + +static int +ice_remove_vlan_filter(struct ice_vsi *vsi, uint16_t vlan_id) +{ + struct ice_fltr_list_entry *v_list_itr = NULL; + struct ice_vlan_filter *f; + struct LIST_HEAD_TYPE list_head; + struct ice_hw *hw = ICE_VSI_TO_HW(vsi); + int ret = 0; + + /** + * Vlan 0 is the generic filter for untagged packets + * and can't be removed. + */ + if (!vsi || vlan_id == 0 || vlan_id > ETHER_MAX_VLAN_ID) + return -EINVAL; + + /* Can't find it, return an error */ + f = ice_find_vlan_filter(vsi, vlan_id); + if (!f) + return -EINVAL; + + INIT_LIST_HEAD(&list_head); + + v_list_itr = (struct ice_fltr_list_entry *) + ice_malloc(hw, sizeof(*v_list_itr)); + if (!v_list_itr) { + ret = -ENOMEM; + goto DONE; + } + + v_list_itr->fltr_info.l_data.vlan.vlan_id = vlan_id; + v_list_itr->fltr_info.src_id = ICE_SRC_ID_VSI; + v_list_itr->fltr_info.fltr_act = ICE_FWD_TO_VSI; + v_list_itr->fltr_info.lkup_type = ICE_SW_LKUP_VLAN; + v_list_itr->fltr_info.flag = ICE_FLTR_TX; + v_list_itr->fltr_info.vsi_handle = vsi->idx; + + LIST_ADD(&v_list_itr->list_entry, &list_head); + + /* remove the vlan filter */ + ret = ice_remove_vlan(hw, &list_head); + if (ret != ICE_SUCCESS) { + PMD_DRV_LOG(ERR, "Failed to remove VLAN filter"); + ret = -EINVAL; + goto DONE; + } + + /* Remove the vlan id from vlan list */ + TAILQ_REMOVE(&vsi->vlan_list, f, next); + rte_free(f); + vsi->vlan_num--; + + ret = 0; +DONE: + rte_free(v_list_itr); + return ret; +} + +static int +ice_remove_all_mac_vlan_filters(struct ice_vsi *vsi) +{ + struct ice_mac_filter *m_f; + struct ice_vlan_filter *v_f; + int ret = 0; + + if (!vsi || !vsi->mac_num) + return -EINVAL; + + TAILQ_FOREACH(m_f, &vsi->mac_list, next) { + ret = ice_remove_mac_filter(vsi, &m_f->mac_info.mac_addr); + if (ret != ICE_SUCCESS) { + ret = -EINVAL; + goto DONE; + } + } + + if (vsi->vlan_num == 0) + return 0; + + TAILQ_FOREACH(v_f, &vsi->vlan_list, next) { + ret = ice_remove_vlan_filter(vsi, v_f->vlan_info.vlan_id); + if (ret != ICE_SUCCESS) { + ret = -EINVAL; + goto DONE; + } + } + +DONE: + return ret; +} + +static int +ice_vsi_config_qinq_insertion(struct ice_vsi *vsi, bool on) +{ + struct ice_hw *hw = ICE_VSI_TO_HW(vsi); + struct ice_vsi_ctx ctxt; + uint8_t qinq_flags; + int ret = 0; + + /* Check if it has been already on or off */ + if (vsi->info.valid_sections & + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID)) { + if (on) { + if ((vsi->info.outer_tag_flags & + ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST) == + ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST) + return 0; /* already on */ + } else { + if (!(vsi->info.outer_tag_flags & + ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST)) + return 0; /* already off */ + } + } + + if (on) + qinq_flags = ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST; + else + qinq_flags = 0; + /* clear global insertion and use per packet insertion */ + vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_INSERT); + vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST); + vsi->info.outer_tag_flags |= qinq_flags; + /* use default vlan type 0x8100 */ + vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_TYPE_M); + vsi->info.outer_tag_flags |= ICE_DFLT_OUTER_TAG_TYPE << + ICE_AQ_VSI_OUTER_TAG_TYPE_S; + (void)rte_memcpy(&ctxt.info, &vsi->info, sizeof(vsi->info)); + ctxt.info.valid_sections = + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID); + ctxt.vsi_num = vsi->vsi_id; + ret = ice_update_vsi(hw, vsi->idx, &ctxt, NULL); + if (ret) { + PMD_DRV_LOG(INFO, + "Update VSI failed to %s qinq stripping", + on ? "enable" : "disable"); + return -EINVAL; + } + + vsi->info.valid_sections |= + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID); + + return ret; +} + +static int +ice_vsi_config_qinq_stripping(struct ice_vsi *vsi, bool on) +{ + struct ice_hw *hw = ICE_VSI_TO_HW(vsi); + struct ice_vsi_ctx ctxt; + uint8_t qinq_flags; + int ret = 0; + + /* Check if it has been already on or off */ + if (vsi->info.valid_sections & + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID)) { + if (on) { + if ((vsi->info.outer_tag_flags & + ICE_AQ_VSI_OUTER_TAG_MODE_M) == + ICE_AQ_VSI_OUTER_TAG_COPY) + return 0; /* already on */ + } else { + if ((vsi->info.outer_tag_flags & + ICE_AQ_VSI_OUTER_TAG_MODE_M) == + ICE_AQ_VSI_OUTER_TAG_NOTHING) + return 0; /* already off */ + } + } + + if (on) + qinq_flags = ICE_AQ_VSI_OUTER_TAG_COPY; + else + qinq_flags = ICE_AQ_VSI_OUTER_TAG_NOTHING; + vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_MODE_M); + vsi->info.outer_tag_flags |= qinq_flags; + /* use default vlan type 0x8100 */ + vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_TYPE_M); + vsi->info.outer_tag_flags |= ICE_DFLT_OUTER_TAG_TYPE << + ICE_AQ_VSI_OUTER_TAG_TYPE_S; + (void)rte_memcpy(&ctxt.info, &vsi->info, sizeof(vsi->info)); + ctxt.info.valid_sections = + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID); + ctxt.vsi_num = vsi->vsi_id; + ret = ice_update_vsi(hw, vsi->idx, &ctxt, NULL); + if (ret) { + PMD_DRV_LOG(INFO, + "Update VSI failed to %s qinq stripping", + on ? "enable" : "disable"); + return -EINVAL; + } + + vsi->info.valid_sections |= + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID); + + return ret; +} + +static int +ice_vsi_config_double_vlan(struct ice_vsi *vsi, int on) +{ + int ret; + + ret = ice_vsi_config_qinq_stripping(vsi, on); + if (ret) + PMD_DRV_LOG(ERR, "Fail to set qinq stripping - %d", ret); + + ret = ice_vsi_config_qinq_insertion(vsi, on); + if (ret) + PMD_DRV_LOG(ERR, "Fail to set qinq insertion - %d", ret); + + return ret; +} + /* Enable IRQ0 */ static void ice_pf_enable_irq0(struct ice_hw *hw) @@ -829,6 +1133,7 @@ static int ice_macaddr_add(struct rte_eth_dev *dev, struct rte_intr_handle *intr_handle; struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private); struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private); + struct ice_vsi *vsi; int ret; dev->dev_ops = &ice_eth_dev_ops; @@ -881,6 +1186,11 @@ static int ice_macaddr_add(struct rte_eth_dev *dev, goto err_pf_setup; } + vsi = pf->main_vsi; + + /* Disable double vlan by default */ + ice_vsi_config_double_vlan(vsi, FALSE); + /* register callback func to eal lib */ rte_intr_callback_register(intr_handle, ice_interrupt_handler, dev); @@ -916,6 +1226,8 @@ static int ice_macaddr_add(struct rte_eth_dev *dev, hw = ICE_VSI_TO_HW(vsi); + ice_remove_all_mac_vlan_filters(vsi); + memset(&vsi_ctx, 0, sizeof(vsi_ctx)); vsi_ctx.vsi_num = vsi->vsi_id; @@ -1498,6 +1810,284 @@ static int ice_macaddr_set(struct rte_eth_dev *dev, } static int +ice_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on) +{ + struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private); + struct ice_vsi *vsi = pf->main_vsi; + int ret; + + PMD_INIT_FUNC_TRACE(); + + if (on) { + ret = ice_add_vlan_filter(vsi, vlan_id); + if (ret < 0) { + PMD_DRV_LOG(ERR, "Failed to add vlan filter"); + return -EINVAL; + } + } else { + ret = ice_remove_vlan_filter(vsi, vlan_id); + if (ret < 0) { + PMD_DRV_LOG(ERR, "Failed to remove vlan filter"); + return -EINVAL; + } + } + + return 0; +} + +/* Configure vlan filter on or off */ +static int +ice_vsi_config_vlan_filter(struct ice_vsi *vsi, bool on) +{ + struct ice_hw *hw = ICE_VSI_TO_HW(vsi); + struct ice_vsi_ctx ctxt; + uint8_t sec_flags, sw_flags2; + int ret = 0; + + sec_flags = ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA << + ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S; + sw_flags2 = ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA; + + if (on) { + vsi->info.sec_flags |= sec_flags; + vsi->info.sw_flags2 |= sw_flags2; + } else { + vsi->info.sec_flags &= ~sec_flags; + vsi->info.sw_flags2 &= ~sw_flags2; + } + vsi->info.sw_id = hw->port_info->sw_id; + (void)rte_memcpy(&ctxt.info, &vsi->info, sizeof(vsi->info)); + ctxt.info.valid_sections = + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_SW_VALID | + ICE_AQ_VSI_PROP_SECURITY_VALID); + ctxt.vsi_num = vsi->vsi_id; + + ret = ice_update_vsi(hw, vsi->idx, &ctxt, NULL); + if (ret) { + PMD_DRV_LOG(INFO, "Update VSI failed to %s vlan rx pruning", + on ? "enable" : "disable"); + ret = -EINVAL; + } else { + vsi->info.valid_sections |= + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_SW_VALID | + ICE_AQ_VSI_PROP_SECURITY_VALID); + } + + return ret; +} + +static int +ice_vsi_config_vlan_stripping(struct ice_vsi *vsi, bool on) +{ + struct ice_hw *hw = ICE_VSI_TO_HW(vsi); + struct ice_vsi_ctx ctxt; + uint8_t vlan_flags; + int ret = 0; + + /* Check if it has been already on or off */ + if (vsi->info.valid_sections & + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_VLAN_VALID)) { + if (on) { + if ((vsi->info.vlan_flags & + ICE_AQ_VSI_VLAN_EMOD_M) == + ICE_AQ_VSI_VLAN_EMOD_STR_BOTH) + return 0; /* already on */ + } else { + if ((vsi->info.vlan_flags & + ICE_AQ_VSI_VLAN_EMOD_M) == + ICE_AQ_VSI_VLAN_EMOD_NOTHING) + return 0; /* already off */ + } + } + + if (on) + vlan_flags = ICE_AQ_VSI_VLAN_EMOD_STR_BOTH; + else + vlan_flags = ICE_AQ_VSI_VLAN_EMOD_NOTHING; + vsi->info.vlan_flags &= ~(ICE_AQ_VSI_VLAN_EMOD_M); + vsi->info.vlan_flags |= vlan_flags; + (void)rte_memcpy(&ctxt.info, &vsi->info, sizeof(vsi->info)); + ctxt.info.valid_sections = + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_VLAN_VALID); + ctxt.vsi_num = vsi->vsi_id; + ret = ice_update_vsi(hw, vsi->idx, &ctxt, NULL); + if (ret) { + PMD_DRV_LOG(INFO, "Update VSI failed to %s vlan stripping", + on ? "enable" : "disable"); + return -EINVAL; + } + + vsi->info.valid_sections |= + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_VLAN_VALID); + + return ret; +} + +static int +ice_vlan_offload_set(struct rte_eth_dev *dev, int mask) +{ + struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private); + struct ice_vsi *vsi = pf->main_vsi; + struct rte_eth_rxmode *rxmode; + + rxmode = &dev->data->dev_conf.rxmode; + if (mask & ETH_VLAN_FILTER_MASK) { + if (rxmode->offloads & DEV_RX_OFFLOAD_VLAN_FILTER) + ice_vsi_config_vlan_filter(vsi, TRUE); + else + ice_vsi_config_vlan_filter(vsi, FALSE); + } + + if (mask & ETH_VLAN_STRIP_MASK) { + if (rxmode->offloads & DEV_RX_OFFLOAD_VLAN_STRIP) + ice_vsi_config_vlan_stripping(vsi, TRUE); + else + ice_vsi_config_vlan_stripping(vsi, FALSE); + } + + if (mask & ETH_VLAN_EXTEND_MASK) { + if (rxmode->offloads & DEV_RX_OFFLOAD_VLAN_EXTEND) + ice_vsi_config_double_vlan(vsi, TRUE); + else + ice_vsi_config_double_vlan(vsi, FALSE); + } + + return 0; +} + +static int +ice_vlan_tpid_set(struct rte_eth_dev *dev, + enum rte_vlan_type vlan_type, + uint16_t tpid) +{ + struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private); + uint64_t reg_r = 0, reg_w = 0; + uint16_t reg_id = 0; + int ret = 0; + int qinq = dev->data->dev_conf.rxmode.offloads & + DEV_RX_OFFLOAD_VLAN_EXTEND; + + switch (vlan_type) { + case ETH_VLAN_TYPE_OUTER: + if (qinq) + reg_id = 3; + else + reg_id = 5; + break; + case ETH_VLAN_TYPE_INNER: + if (qinq) { + reg_id = 5; + } else { + PMD_DRV_LOG(ERR, + "Unsupported vlan type in single vlan."); + return -EINVAL; + } + break; + default: + PMD_DRV_LOG(ERR, "Unsupported vlan type %d", vlan_type); + return -EINVAL; + } + reg_r = ICE_READ_REG(hw, GL_SWT_L2TAGCTRL(reg_id)); + PMD_DRV_LOG(DEBUG, "Debug read from ICE GL_SWT_L2TAGCTRL[%d]: " + "0x%08"PRIx64"", reg_id, reg_r); + + reg_w = reg_r & (~(GL_SWT_L2TAGCTRL_ETHERTYPE_M)); + reg_w |= ((uint64_t)tpid << GL_SWT_L2TAGCTRL_ETHERTYPE_S); + if (reg_r == reg_w) { + PMD_DRV_LOG(DEBUG, "No need to write"); + return 0; + } + + ICE_WRITE_REG(hw, GL_SWT_L2TAGCTRL(reg_id), reg_w); + PMD_DRV_LOG(DEBUG, "Debug write 0x%08"PRIx64" to " + "ICE GL_SWT_L2TAGCTRL[%d]", reg_w, reg_id); + + return ret; +} + +static int +ice_vsi_vlan_pvid_set(struct ice_vsi *vsi, struct ice_vsi_vlan_pvid_info *info) +{ + struct ice_hw *hw; + struct ice_vsi_ctx ctxt; + uint8_t vlan_flags = 0; + int ret; + + if (!vsi || !info) { + PMD_DRV_LOG(ERR, "invalid parameters"); + return -EINVAL; + } + + if (info->on) { + vsi->info.pvid = info->config.pvid; + /** + * If insert pvid is enabled, only tagged pkts are + * allowed to be sent out. + */ + vlan_flags = ICE_AQ_VSI_PVLAN_INSERT_PVID | + ICE_AQ_VSI_VLAN_MODE_UNTAGGED; + } else { + vsi->info.pvid = 0; + if (info->config.reject.tagged == 0) + vlan_flags |= ICE_AQ_VSI_VLAN_MODE_TAGGED; + + if (info->config.reject.untagged == 0) + vlan_flags |= ICE_AQ_VSI_VLAN_MODE_UNTAGGED; + } + vsi->info.vlan_flags &= ~(ICE_AQ_VSI_PVLAN_INSERT_PVID | + ICE_AQ_VSI_VLAN_MODE_M); + vsi->info.vlan_flags |= vlan_flags; + memset(&ctxt, 0, sizeof(ctxt)); + rte_memcpy(&ctxt.info, &vsi->info, sizeof(vsi->info)); + ctxt.info.valid_sections = + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_VLAN_VALID); + ctxt.vsi_num = vsi->vsi_id; + + hw = ICE_VSI_TO_HW(vsi); + ret = ice_update_vsi(hw, vsi->idx, &ctxt, NULL); + if (ret != ICE_SUCCESS) { + PMD_DRV_LOG(ERR, + "update VSI for VLAN insert failed, err %d", + ret); + return -EINVAL; + } + + vsi->info.valid_sections |= + rte_cpu_to_le_16(ICE_AQ_VSI_PROP_VLAN_VALID); + + return ret; +} + +static int +ice_vlan_pvid_set(struct rte_eth_dev *dev, uint16_t pvid, int on) +{ + struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private); + struct ice_vsi *vsi = pf->main_vsi; + struct rte_eth_dev_data *data = pf->dev_data; + struct ice_vsi_vlan_pvid_info info; + int ret; + + memset(&info, 0, sizeof(info)); + info.on = on; + if (info.on) { + info.config.pvid = pvid; + } else { + info.config.reject.tagged = + data->dev_conf.txmode.hw_vlan_reject_tagged; + info.config.reject.untagged = + data->dev_conf.txmode.hw_vlan_reject_untagged; + } + + ret = ice_vsi_vlan_pvid_set(vsi, &info); + if (ret < 0) { + PMD_DRV_LOG(ERR, "Failed to set pvid."); + return -EINVAL; + } + + return 0; +} + +static int ice_pci_probe(struct rte_pci_driver *pci_drv __rte_unused, struct rte_pci_device *pci_dev) { -- 1.9.3