provided vlan filter, vlan offload ops. Signed-off-by: Junlong Wang <wang.junlong1@zte.com.cn> --- doc/guides/nics/features/zxdh.ini | 3 + doc/guides/nics/zxdh.rst | 3 + drivers/net/zxdh/zxdh_ethdev.c | 40 +++++- drivers/net/zxdh/zxdh_ethdev_ops.c | 223 +++++++++++++++++++++++++++++ drivers/net/zxdh/zxdh_ethdev_ops.h | 2 + drivers/net/zxdh/zxdh_msg.h | 22 +++ drivers/net/zxdh/zxdh_rxtx.c | 18 +++ drivers/net/zxdh/zxdh_tables.c | 99 +++++++++++++ drivers/net/zxdh/zxdh_tables.h | 10 +- 9 files changed, 417 insertions(+), 3 deletions(-) diff --git a/doc/guides/nics/features/zxdh.ini b/doc/guides/nics/features/zxdh.ini index e9b237e102..6fb006c2da 100644 --- a/doc/guides/nics/features/zxdh.ini +++ b/doc/guides/nics/features/zxdh.ini @@ -16,3 +16,6 @@ Unicast MAC filter = Y Multicast MAC filter = Y Promiscuous mode = Y Allmulticast mode = Y +VLAN filter = Y +VLAN offload = Y +QinQ offload = Y diff --git a/doc/guides/nics/zxdh.rst b/doc/guides/nics/zxdh.rst index 0399df1302..3a7585d123 100644 --- a/doc/guides/nics/zxdh.rst +++ b/doc/guides/nics/zxdh.rst @@ -28,6 +28,9 @@ Features of the ZXDH PMD are: - Multicast MAC filter - Promiscuous mode - Multicast mode +- VLAN filter and VLAN offload +- VLAN stripping and inserting +- QINQ stripping and inserting Driver compilation and testing diff --git a/drivers/net/zxdh/zxdh_ethdev.c b/drivers/net/zxdh/zxdh_ethdev.c index 1dd6624e30..468f2165cb 100644 --- a/drivers/net/zxdh/zxdh_ethdev.c +++ b/drivers/net/zxdh/zxdh_ethdev.c @@ -759,6 +759,34 @@ zxdh_alloc_queues(struct rte_eth_dev *dev, uint16_t nr_vq) return 0; } +static int +zxdh_vlan_offload_configure(struct rte_eth_dev *dev) +{ + int ret; + int mask = RTE_ETH_VLAN_STRIP_MASK | RTE_ETH_VLAN_FILTER_MASK | RTE_ETH_QINQ_STRIP_MASK; + + ret = zxdh_dev_vlan_offload_set(dev, mask); + if (ret) { + PMD_DRV_LOG(ERR, "vlan offload set error"); + return -1; + } + + return 0; +} + +static int +zxdh_dev_conf_offload(struct rte_eth_dev *dev) +{ + int ret = 0; + + ret = zxdh_vlan_offload_configure(dev); + if (ret) { + PMD_DRV_LOG(ERR, "zxdh_vlan_offload_configure failed"); + return ret; + } + + return 0; +} static int32_t zxdh_dev_configure(struct rte_eth_dev *dev) @@ -816,7 +844,7 @@ zxdh_dev_configure(struct rte_eth_dev *dev) nr_vq = dev->data->nb_rx_queues + dev->data->nb_tx_queues; if (nr_vq == hw->queue_num) - return 0; + goto end; PMD_DRV_LOG(DEBUG, "queue changed need reset "); /* Reset the device although not necessary at startup */ @@ -848,6 +876,8 @@ zxdh_dev_configure(struct rte_eth_dev *dev) zxdh_pci_reinit_complete(hw); +end: + zxdh_dev_conf_offload(dev); return ret; } @@ -1088,6 +1118,8 @@ static const struct eth_dev_ops zxdh_eth_dev_ops = { .promiscuous_disable = zxdh_dev_promiscuous_disable, .allmulticast_enable = zxdh_dev_allmulticast_enable, .allmulticast_disable = zxdh_dev_allmulticast_disable, + .vlan_filter_set = zxdh_dev_vlan_filter_set, + .vlan_offload_set = zxdh_dev_vlan_offload_set, }; static int32_t @@ -1346,6 +1378,12 @@ zxdh_tables_init(struct rte_eth_dev *dev) return ret; } + ret = zxdh_vlan_filter_table_init(dev); + if (ret) { + PMD_DRV_LOG(ERR, " vlan filter table init failed"); + return ret; + } + return ret; } diff --git a/drivers/net/zxdh/zxdh_ethdev_ops.c b/drivers/net/zxdh/zxdh_ethdev_ops.c index ad3d10258c..c4a1521723 100644 --- a/drivers/net/zxdh/zxdh_ethdev_ops.c +++ b/drivers/net/zxdh/zxdh_ethdev_ops.c @@ -2,6 +2,8 @@ * Copyright(c) 2024 ZTE Corporation */ +#include <rte_malloc.h> + #include "zxdh_ethdev.h" #include "zxdh_pci.h" #include "zxdh_msg.h" @@ -9,6 +11,8 @@ #include "zxdh_tables.h" #include "zxdh_logs.h" +#define ZXDH_VLAN_FILTER_GROUPS 64 + static int32_t zxdh_config_port_status(struct rte_eth_dev *dev, uint16_t link_status) { struct zxdh_hw *hw = dev->data->dev_private; @@ -523,3 +527,222 @@ int zxdh_dev_allmulticast_disable(struct rte_eth_dev *dev) hw->allmulti_status = 0; return ret; } + +int +zxdh_dev_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on) +{ + struct zxdh_hw *hw = (struct zxdh_hw *)dev->data->dev_private; + uint16_t idx = 0; + uint16_t bit_idx = 0; + uint8_t msg_type = 0; + int ret = 0; + + vlan_id &= RTE_VLAN_ID_MASK; + if (vlan_id == 0 || vlan_id == RTE_ETHER_MAX_VLAN_ID) { + PMD_DRV_LOG(ERR, "vlan id (%d) is reserved", vlan_id); + return -EINVAL; + } + + if (dev->data->dev_started == 0) { + PMD_DRV_LOG(ERR, "vlan_filter dev not start"); + return -1; + } + + idx = vlan_id / ZXDH_VLAN_FILTER_GROUPS; + bit_idx = vlan_id % ZXDH_VLAN_FILTER_GROUPS; + + if (on) { + if (dev->data->vlan_filter_conf.ids[idx] & (1ULL << bit_idx)) { + PMD_DRV_LOG(ERR, "vlan:%d has already added.", vlan_id); + return 0; + } + msg_type = ZXDH_VLAN_FILTER_ADD; + } else { + if (!(dev->data->vlan_filter_conf.ids[idx] & (1ULL << bit_idx))) { + PMD_DRV_LOG(ERR, "vlan:%d has already deleted.", vlan_id); + return 0; + } + msg_type = ZXDH_VLAN_FILTER_DEL; + } + + if (hw->is_pf) { + ret = zxdh_vlan_filter_table_set(hw->vport.vport, vlan_id, on); + if (ret) { + PMD_DRV_LOG(ERR, "vlan_id:%d table set failed.", vlan_id); + return -1; + } + } else { + struct zxdh_msg_info msg = {0}; + zxdh_msg_head_build(hw, msg_type, &msg); + msg.data.vlan_filter_msg.vlan_id = vlan_id; + ret = zxdh_vf_send_msg_to_pf(dev, &msg, sizeof(struct zxdh_msg_info), NULL, 0); + if (ret) { + PMD_DRV_LOG(ERR, "Failed to send msg: port 0x%x msg type %d ", + hw->vport.vport, msg_type); + return ret; + } + } + + if (on) + dev->data->vlan_filter_conf.ids[idx] |= (1ULL << bit_idx); + else + dev->data->vlan_filter_conf.ids[idx] &= ~(1ULL << bit_idx); + + return 0; +} + +int +zxdh_dev_vlan_offload_set(struct rte_eth_dev *dev, int mask) +{ + struct zxdh_hw *hw = dev->data->dev_private; + struct rte_eth_rxmode *rxmode; + struct zxdh_msg_info msg = {0}; + struct zxdh_port_attr_table port_attr = {0}; + int ret = 0; + + rxmode = &dev->data->dev_conf.rxmode; + if (mask & RTE_ETH_VLAN_FILTER_MASK) { + if (rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_FILTER) { + if (hw->is_pf) { + ret = zxdh_get_port_attr(hw->vport.vfid, &port_attr); + port_attr.vlan_filter_enable = true; + ret = zxdh_set_port_attr(hw->vport.vfid, &port_attr); + if (ret) { + PMD_DRV_LOG(ERR, "port %d vlan filter set failed", + hw->vport.vfid); + return -EAGAIN; + } + } else { + msg.data.vlan_filter_set_msg.enable = true; + zxdh_msg_head_build(hw, ZXDH_VLAN_FILTER_SET, &msg); + ret = zxdh_vf_send_msg_to_pf(hw->eth_dev, &msg, + sizeof(struct zxdh_msg_info), NULL, 0); + if (ret) { + PMD_DRV_LOG(ERR, "port %d vlan filter set failed", + hw->vport.vfid); + return -EAGAIN; + } + } + } else { + if (hw->is_pf) { + ret = zxdh_get_port_attr(hw->vport.vfid, &port_attr); + port_attr.vlan_filter_enable = false; + ret = zxdh_set_port_attr(hw->vport.vfid, &port_attr); + if (ret) { + PMD_DRV_LOG(ERR, "port %d vlan filter set failed", + hw->vport.vfid); + return -EAGAIN; + } + } else { + msg.data.vlan_filter_set_msg.enable = true; + zxdh_msg_head_build(hw, ZXDH_VLAN_FILTER_SET, &msg); + ret = zxdh_vf_send_msg_to_pf(hw->eth_dev, &msg, + sizeof(struct zxdh_msg_info), NULL, 0); + if (ret) { + PMD_DRV_LOG(ERR, "port %d vlan filter set failed", + hw->vport.vfid); + return -EAGAIN; + } + } + } + } + + if (mask & RTE_ETH_VLAN_STRIP_MASK) { + if (rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP) { + if (hw->is_pf) { + ret = zxdh_get_port_attr(hw->vport.vfid, &port_attr); + port_attr.vlan_strip_offload = true; + ret = zxdh_set_port_attr(hw->vport.vfid, &port_attr); + if (ret) { + PMD_DRV_LOG(ERR, "port %d vlan strip set failed", + hw->vport.vfid); + return -EAGAIN; + } + } else { + msg.data.vlan_offload_msg.enable = true; + msg.data.vlan_offload_msg.type = ZXDH_VLAN_STRIP_MSG_TYPE; + zxdh_msg_head_build(hw, ZXDH_VLAN_OFFLOAD, &msg); + ret = zxdh_vf_send_msg_to_pf(hw->eth_dev, &msg, + sizeof(struct zxdh_msg_info), NULL, 0); + if (ret) { + PMD_DRV_LOG(ERR, "port %d vlan strip set failed", + hw->vport.vfid); + return -EAGAIN; + } + } + } else { + if (hw->is_pf) { + ret = zxdh_get_port_attr(hw->vport.vfid, &port_attr); + port_attr.vlan_strip_offload = false; + ret = zxdh_set_port_attr(hw->vport.vfid, &port_attr); + if (ret) { + PMD_DRV_LOG(ERR, "port %d vlan strip set failed", + hw->vport.vfid); + return -EAGAIN; + } + } else { + msg.data.vlan_offload_msg.enable = false; + msg.data.vlan_offload_msg.type = ZXDH_VLAN_STRIP_MSG_TYPE; + zxdh_msg_head_build(hw, ZXDH_VLAN_OFFLOAD, &msg); + ret = zxdh_vf_send_msg_to_pf(hw->eth_dev, &msg, + sizeof(struct zxdh_msg_info), NULL, 0); + if (ret) { + PMD_DRV_LOG(ERR, "port %d vlan strip set failed", + hw->vport.vfid); + return -EAGAIN; + } + } + } + } + + if (mask & RTE_ETH_QINQ_STRIP_MASK) { + memset(&msg, 0, sizeof(struct zxdh_msg_info)); + if (rxmode->offloads & RTE_ETH_RX_OFFLOAD_QINQ_STRIP) { + if (hw->is_pf) { + ret = zxdh_get_port_attr(hw->vport.vfid, &port_attr); + port_attr.qinq_strip_offload = true; + ret = zxdh_set_port_attr(hw->vport.vfid, &port_attr); + if (ret) { + PMD_DRV_LOG(ERR, "port %d qinq offload set failed", + hw->vport.vfid); + return -EAGAIN; + } + } else { + msg.data.vlan_offload_msg.enable = true; + msg.data.vlan_offload_msg.type = ZXDH_QINQ_STRIP_MSG_TYPE; + zxdh_msg_head_build(hw, ZXDH_VLAN_OFFLOAD, &msg); + ret = zxdh_vf_send_msg_to_pf(hw->eth_dev, &msg, + sizeof(struct zxdh_msg_info), NULL, 0); + if (ret) { + PMD_DRV_LOG(ERR, "port %d qinq offload set failed", + hw->vport.vfid); + return -EAGAIN; + } + } + } else { + if (hw->is_pf) { + ret = zxdh_get_port_attr(hw->vport.vfid, &port_attr); + port_attr.qinq_strip_offload = true; + ret = zxdh_set_port_attr(hw->vport.vfid, &port_attr); + if (ret) { + PMD_DRV_LOG(ERR, "port %d qinq offload set failed", + hw->vport.vfid); + return -EAGAIN; + } + } else { + msg.data.vlan_offload_msg.enable = false; + msg.data.vlan_offload_msg.type = ZXDH_QINQ_STRIP_MSG_TYPE; + zxdh_msg_head_build(hw, ZXDH_VLAN_OFFLOAD, &msg); + ret = zxdh_vf_send_msg_to_pf(hw->eth_dev, &msg, + sizeof(struct zxdh_msg_info), NULL, 0); + if (ret) { + PMD_DRV_LOG(ERR, "port %d qinq offload set failed", + hw->vport.vfid); + return -EAGAIN; + } + } + } + } + + return ret; +} diff --git a/drivers/net/zxdh/zxdh_ethdev_ops.h b/drivers/net/zxdh/zxdh_ethdev_ops.h index 394ddedc0e..058d271ab3 100644 --- a/drivers/net/zxdh/zxdh_ethdev_ops.h +++ b/drivers/net/zxdh/zxdh_ethdev_ops.h @@ -18,5 +18,7 @@ int zxdh_dev_promiscuous_enable(struct rte_eth_dev *dev); int zxdh_dev_promiscuous_disable(struct rte_eth_dev *dev); int zxdh_dev_allmulticast_enable(struct rte_eth_dev *dev); int zxdh_dev_allmulticast_disable(struct rte_eth_dev *dev); +int zxdh_dev_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on); +int zxdh_dev_vlan_offload_set(struct rte_eth_dev *dev, int mask); #endif /* ZXDH_ETHDEV_OPS_H */ diff --git a/drivers/net/zxdh/zxdh_msg.h b/drivers/net/zxdh/zxdh_msg.h index 418d790a27..959fe15d23 100644 --- a/drivers/net/zxdh/zxdh_msg.h +++ b/drivers/net/zxdh/zxdh_msg.h @@ -50,6 +50,8 @@ #define ZXDH_MAC_UNFILTER 0xff #define ZXDH_PROMISC_MODE 1 #define ZXDH_ALLMULTI_MODE 2 +#define ZXDH_VLAN_STRIP_MSG_TYPE 0 +#define ZXDH_QINQ_STRIP_MSG_TYPE 1 enum ZXDH_DRIVER_TYPE { ZXDH_MSG_CHAN_END_MPF = 0, @@ -180,6 +182,10 @@ enum zxdh_msg_type { ZXDH_VF_PORT_UNINIT = 2, ZXDH_MAC_ADD = 3, ZXDH_MAC_DEL = 4, + ZXDH_VLAN_FILTER_SET = 17, + ZXDH_VLAN_FILTER_ADD = 18, + ZXDH_VLAN_FILTER_DEL = 19, + ZXDH_VLAN_OFFLOAD = 21, ZXDH_PORT_ATTRS_SET = 25, ZXDH_PORT_PROMISC_SET = 26, @@ -341,6 +347,19 @@ struct __rte_packed_begin zxdh_port_promisc_msg { uint8_t mc_follow; } __rte_packed_end; +struct zxdh_vlan_filter { + uint16_t vlan_id; +}; + +struct zxdh_vlan_filter_set { + uint8_t enable; +}; + +struct __rte_packed_begin zxdh_vlan_offload { + uint8_t enable; + uint8_t type; +} __rte_packed_end; + struct __rte_packed_begin zxdh_agent_msg_head { enum zxdh_agent_msg_type msg_type; uint8_t panel_id; @@ -363,6 +382,9 @@ struct __rte_packed_begin zxdh_msg_info { struct zxdh_link_info_msg link_msg; struct zxdh_mac_filter mac_filter_msg; struct zxdh_port_promisc_msg port_promisc_msg; + struct zxdh_vlan_filter vlan_filter_msg; + struct zxdh_vlan_filter_set vlan_filter_set_msg; + struct zxdh_vlan_offload vlan_offload_msg; } __rte_packed_end data; } __rte_packed_end; diff --git a/drivers/net/zxdh/zxdh_rxtx.c b/drivers/net/zxdh/zxdh_rxtx.c index 06290d48bb..0ffce50042 100644 --- a/drivers/net/zxdh/zxdh_rxtx.c +++ b/drivers/net/zxdh/zxdh_rxtx.c @@ -11,6 +11,9 @@ #include "zxdh_pci.h" #include "zxdh_queue.h" +#define ZXDH_SVLAN_TPID 0x88a8 +#define ZXDH_CVLAN_TPID 0x8100 + #define ZXDH_PKT_FORM_CPU 0x20 /* 1-cpu 0-np */ #define ZXDH_NO_IP_FRAGMENT 0x2000 /* ip fragment flag */ #define ZXDH_NO_IPID_UPDATE 0x4000 /* ipid update flag */ @@ -21,6 +24,9 @@ #define ZXDH_PI_L3TYPE_RSV 0xC0 #define ZXDH_PI_L3TYPE_MASK 0xC0 +#define ZXDH_PD_OFFLOAD_SVLAN_INSERT (1 << 14) +#define ZXDH_PD_OFFLOAD_CVLAN_INSERT (1 << 13) + #define ZXDH_PCODE_MASK 0x1F #define ZXDH_PCODE_IP_PKT_TYPE 0x01 #define ZXDH_PCODE_TCP_PKT_TYPE 0x02 @@ -259,6 +265,18 @@ static void zxdh_xmit_fill_net_hdr(struct rte_mbuf *cookie, hdr->pi_hdr.l3_offset = rte_be_to_cpu_16(l3_offset); hdr->pi_hdr.l4_offset = rte_be_to_cpu_16(l3_offset + cookie->l3_len); + if (cookie->ol_flags & RTE_MBUF_F_TX_VLAN) { + ol_flag |= ZXDH_PD_OFFLOAD_CVLAN_INSERT; + hdr->pi_hdr.vlan_id = rte_be_to_cpu_16(cookie->vlan_tci); + hdr->pd_hdr.cvlan_insert = + rte_be_to_cpu_32((ZXDH_CVLAN_TPID << 16) | cookie->vlan_tci); + } + if (cookie->ol_flags & RTE_MBUF_F_TX_QINQ) { + ol_flag |= ZXDH_PD_OFFLOAD_SVLAN_INSERT; + hdr->pd_hdr.svlan_insert = + rte_be_to_cpu_32((ZXDH_SVLAN_TPID << 16) | cookie->vlan_tci_outer); + } + hdr->pd_hdr.ol_flag = rte_be_to_cpu_32(ol_flag); } diff --git a/drivers/net/zxdh/zxdh_tables.c b/drivers/net/zxdh/zxdh_tables.c index 45aeb3e3e4..ca98b36da2 100644 --- a/drivers/net/zxdh/zxdh_tables.c +++ b/drivers/net/zxdh/zxdh_tables.c @@ -10,6 +10,7 @@ #define ZXDH_SDT_VPORT_ATT_TABLE 1 #define ZXDH_SDT_PANEL_ATT_TABLE 2 +#define ZXDH_SDT_VLAN_ATT_TABLE 4 #define ZXDH_SDT_BROCAST_ATT_TABLE 6 #define ZXDH_SDT_UNICAST_ATT_TABLE 10 #define ZXDH_SDT_MULTICAST_ATT_TABLE 11 @@ -19,6 +20,10 @@ #define ZXDH_MC_GROUP_NUM 4 #define ZXDH_BASE_VFID 1152 #define ZXDH_TABLE_HIT_FLAG 128 +#define ZXDH_FIRST_VLAN_GROUP_BITS 23 +#define ZXDH_VLAN_GROUP_BITS 31 +#define ZXDH_VLAN_GROUP_NUM 35 +#define ZXDH_VLAN_FILTER_VLANID_STEP 120 int zxdh_set_port_attr(uint16_t vfid, struct zxdh_port_attr_table *port_attr) @@ -569,3 +574,97 @@ zxdh_dev_multicast_table_set(struct zxdh_hw *hw, uint16_t vport, bool enable) } return 0; } + +int +zxdh_vlan_filter_table_init(struct rte_eth_dev *dev) +{ + struct zxdh_hw *hw = dev->data->dev_private; + struct zxdh_vlan_filter_table vlan_table = {0}; + int16_t ret = 0; + + if (!hw->is_pf) + return 0; + + for (uint8_t vlan_group = 0; vlan_group < ZXDH_VLAN_GROUP_NUM; vlan_group++) { + if (vlan_group == 0) { + vlan_table.vlans[0] |= (1 << ZXDH_FIRST_VLAN_GROUP_BITS); + vlan_table.vlans[0] |= (1 << ZXDH_VLAN_GROUP_BITS); + + } else { + vlan_table.vlans[0] = 0; + } + uint32_t index = (vlan_group << 11) | hw->vport.vfid; + ZXDH_DTB_ERAM_ENTRY_INFO_T entry_data = { + .index = index, + .p_data = (uint32_t *)&vlan_table + }; + ZXDH_DTB_USER_ENTRY_T user_entry = {ZXDH_SDT_VLAN_ATT_TABLE, &entry_data}; + + ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO, + g_dtb_data.queueid, 1, &user_entry); + if (ret != 0) { + PMD_DRV_LOG(ERR, + "[vfid:%d], vlan_group:%d, init vlan filter table failed", + hw->vport.vfid, vlan_group); + ret = -1; + } + } + + return ret; +} + +int +zxdh_vlan_filter_table_set(uint16_t vport, uint16_t vlan_id, uint8_t enable) +{ + struct zxdh_vlan_filter_table vlan_table = {0}; + union zxdh_virport_num vport_num = (union zxdh_virport_num)vport; + int ret = 0; + + memset(&vlan_table, 0, sizeof(struct zxdh_vlan_filter_table)); + int table_num = vlan_id / ZXDH_VLAN_FILTER_VLANID_STEP; + uint32_t index = (table_num << 11) | vport_num.vfid; + uint16_t group = (vlan_id - table_num * ZXDH_VLAN_FILTER_VLANID_STEP) / 8 + 1; + + uint8_t val = sizeof(struct zxdh_vlan_filter_table) / sizeof(uint32_t); + uint8_t vlan_tbl_index = group / val; + uint16_t used_group = vlan_tbl_index * val; + + used_group = (used_group == 0 ? 0 : (used_group - 1)); + + ZXDH_DTB_ERAM_ENTRY_INFO_T entry_data = {index, (uint32_t *)&vlan_table}; + ZXDH_DTB_USER_ENTRY_T user_entry_get = {ZXDH_SDT_VLAN_ATT_TABLE, &entry_data}; + + ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO, g_dtb_data.queueid, &user_entry_get, 1); + if (ret) { + PMD_DRV_LOG(ERR, "get vlan table failed"); + return -1; + } + uint16_t relative_vlan_id = vlan_id - table_num * ZXDH_VLAN_FILTER_VLANID_STEP; + uint32_t *base_group = &vlan_table.vlans[0]; + + *base_group |= 1 << 31; + base_group = &vlan_table.vlans[vlan_tbl_index]; + uint8_t valid_bits = (vlan_tbl_index == 0 ? + ZXDH_FIRST_VLAN_GROUP_BITS : ZXDH_VLAN_GROUP_BITS) + 1; + + uint8_t shift_left = (valid_bits - (relative_vlan_id - used_group * 8) % valid_bits) - 1; + + if (enable) + *base_group |= 1 << shift_left; + else + *base_group &= ~(1 << shift_left); + + + ZXDH_DTB_USER_ENTRY_T user_entry_write = { + .sdt_no = ZXDH_SDT_VLAN_ATT_TABLE, + .p_entry_data = &entry_data + }; + + ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO, + g_dtb_data.queueid, 1, &user_entry_write); + if (ret != 0) { + PMD_DRV_LOG(ERR, "write vlan table failed"); + return -1; + } + return 0; +} diff --git a/drivers/net/zxdh/zxdh_tables.h b/drivers/net/zxdh/zxdh_tables.h index fb30c8f32e..8dac8f30dd 100644 --- a/drivers/net/zxdh/zxdh_tables.h +++ b/drivers/net/zxdh/zxdh_tables.h @@ -43,7 +43,7 @@ struct zxdh_port_attr_table { uint8_t rdma_offload_enable: 1; uint8_t vlan_filter_enable: 1; uint8_t vlan_strip_offload: 1; - uint8_t qinq_valn_strip_offload: 1; + uint8_t qinq_strip_offload: 1; uint8_t rss_enable: 1; uint8_t mtu_enable: 1; uint8_t hit_flag: 1; @@ -73,7 +73,7 @@ struct zxdh_port_attr_table { uint8_t rdma_offload_enable: 1; uint8_t vlan_filter_enable: 1; uint8_t vlan_strip_offload: 1; - uint8_t qinq_valn_strip_offload: 1; + uint8_t qinq_strip_offload: 1; uint8_t rss_enable: 1; uint8_t mtu_enable: 1; uint8_t hit_flag: 1; @@ -194,6 +194,10 @@ struct zxdh_multicast_table { uint32_t bitmap[2]; }; +struct zxdh_vlan_filter_table { + uint32_t vlans[4]; +}; + int zxdh_port_attr_init(struct rte_eth_dev *dev); int zxdh_panel_table_init(struct rte_eth_dev *dev); int zxdh_set_port_attr(uint16_t vfid, struct zxdh_port_attr_table *port_attr); @@ -205,5 +209,7 @@ int zxdh_promisc_table_init(struct rte_eth_dev *dev); int zxdh_promisc_table_uninit(struct rte_eth_dev *dev); int zxdh_dev_unicast_table_set(struct zxdh_hw *hw, uint16_t vport, bool enable); int zxdh_dev_multicast_table_set(struct zxdh_hw *hw, uint16_t vport, bool enable); +int zxdh_vlan_filter_table_init(struct rte_eth_dev *dev); +int zxdh_vlan_filter_table_set(uint16_t vport, uint16_t vlan_id, uint8_t enable); #endif /* ZXDH_TABLES_H */ -- 2.27.0