Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2024 ZTE Corporation
3 : : */
4 : :
5 : : #include "zxdh_ethdev.h"
6 : : #include "zxdh_msg.h"
7 : : #include "zxdh_np.h"
8 : : #include "zxdh_tables.h"
9 : : #include "zxdh_logs.h"
10 : :
11 : : #define ZXDH_SDT_VPORT_ATT_TABLE 1
12 : : #define ZXDH_SDT_PANEL_ATT_TABLE 2
13 : : #define ZXDH_SDT_RSS_ATT_TABLE 3
14 : : #define ZXDH_SDT_VLAN_ATT_TABLE 4
15 : : #define ZXDH_SDT_BROCAST_ATT_TABLE 6
16 : : #define ZXDH_SDT_UNICAST_ATT_TABLE 10
17 : : #define ZXDH_SDT_MULTICAST_ATT_TABLE 11
18 : : #define ZXDH_SDT_PORT_VLAN_ATT_TABLE 16
19 : :
20 : : #define ZXDH_MAC_HASH_INDEX_BASE 64
21 : : #define ZXDH_MAC_HASH_INDEX(index) (ZXDH_MAC_HASH_INDEX_BASE + (index))
22 : : #define ZXDH_MC_GROUP_NUM 4
23 : : #define ZXDH_BASE_VFID 1152
24 : : #define ZXDH_TABLE_HIT_FLAG 128
25 : : #define ZXDH_FIRST_VLAN_GROUP_BITS 23
26 : : #define ZXDH_VLAN_GROUP_BITS 31
27 : : #define ZXDH_VLAN_GROUP_NUM 35
28 : : #define ZXDH_VLAN_FILTER_VLANID_STEP 120
29 : :
30 : : static inline int32_t
31 : : no_business_offload(struct zxdh_port_vlan_table *port_vlan)
32 : : {
33 : : return (port_vlan->business_qinq_strip == 0 &&
34 : 0 : port_vlan->business_vlan_filter == 0 &&
35 : : port_vlan->business_vlan_strip == 0);
36 : : }
37 : :
38 : : int
39 : 0 : zxdh_set_port_attr(struct zxdh_hw *hw, uint16_t vport, struct zxdh_port_attr_table *port_attr)
40 : : {
41 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
42 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
43 : : int ret = 0;
44 : :
45 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vport_num.vfid, (uint32_t *)port_attr};
46 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_write = {ZXDH_SDT_VPORT_ATT_TABLE, (void *)&entry};
47 : :
48 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
49 : 0 : dtb_data->queueid, 1, &user_entry_write);
50 [ # # ]: 0 : if (ret != 0)
51 : 0 : PMD_DRV_LOG(ERR, "write vport_att failed vfid:%d failed", vport_num.vfid);
52 : :
53 : 0 : return ret;
54 : : }
55 : :
56 : : int
57 : 0 : zxdh_port_attr_init(struct rte_eth_dev *dev)
58 : : {
59 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
60 : 0 : struct zxdh_port_attr_table port_attr = {0};
61 : 0 : struct zxdh_msg_info msg_info = {0};
62 : : int ret;
63 : :
64 [ # # ]: 0 : if (hw->is_pf) {
65 : 0 : port_attr.hit_flag = 1;
66 : 0 : port_attr.phy_port = hw->phyport;
67 : 0 : port_attr.pf_vfid = zxdh_vport_to_vfid(hw->vport);
68 : 0 : port_attr.rss_enable = 0;
69 [ # # ]: 0 : if (!hw->is_pf)
70 : 0 : port_attr.is_vf = 1;
71 : :
72 : 0 : port_attr.mtu = dev->data->mtu;
73 : 0 : port_attr.mtu_enable = 1;
74 : 0 : port_attr.is_up = 0;
75 : : if (!port_attr.rss_enable)
76 : 0 : port_attr.port_base_qid = 0;
77 : :
78 : 0 : ret = zxdh_set_port_attr(hw, hw->vport.vport, &port_attr);
79 [ # # ]: 0 : if (ret) {
80 : 0 : PMD_DRV_LOG(ERR, "write port_attr failed");
81 : : ret = -1;
82 : : }
83 : : } else {
84 : : struct zxdh_vf_init_msg *vf_init_msg = &msg_info.data.vf_init_msg;
85 : :
86 : 0 : zxdh_msg_head_build(hw, ZXDH_VF_PORT_INIT, &msg_info);
87 : 0 : msg_info.msg_head.msg_type = ZXDH_VF_PORT_INIT;
88 : 0 : vf_init_msg->link_up = 1;
89 : 0 : vf_init_msg->base_qid = 0;
90 : 0 : vf_init_msg->rss_enable = 0;
91 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
92 [ # # ]: 0 : if (ret) {
93 : 0 : PMD_DRV_LOG(ERR, "vf port_init failed");
94 : : ret = -1;
95 : : }
96 : : }
97 : 0 : return ret;
98 : : };
99 : :
100 : : int
101 : 0 : zxdh_port_attr_uninit(struct rte_eth_dev *dev)
102 : : {
103 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
104 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
105 : 0 : struct zxdh_msg_info msg_info = {0};
106 : 0 : struct zxdh_port_attr_table port_attr = {0};
107 : : int ret = 0;
108 : :
109 [ # # ]: 0 : if (hw->is_pf == 1) {
110 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T port_attr_entry = {hw->vfid, (uint32_t *)&port_attr};
111 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
112 : : .sdt_no = ZXDH_SDT_VPORT_ATT_TABLE,
113 : : .p_entry_data = (void *)&port_attr_entry
114 : : };
115 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id, dtb_data->queueid, 1, &entry);
116 [ # # ]: 0 : if (ret) {
117 : 0 : PMD_DRV_LOG(ERR, "delete port attr table failed");
118 : : ret = -1;
119 : : }
120 : : } else {
121 : 0 : zxdh_msg_head_build(hw, ZXDH_VF_PORT_UNINIT, &msg_info);
122 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
123 [ # # ]: 0 : if (ret) {
124 : 0 : PMD_DRV_LOG(ERR, "vf port tables uninit failed");
125 : : ret = -1;
126 : : }
127 : : }
128 : 0 : return ret;
129 : : }
130 : :
131 : 0 : int zxdh_panel_table_init(struct rte_eth_dev *dev)
132 : : {
133 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
134 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
135 : : int ret;
136 : :
137 [ # # ]: 0 : if (!hw->is_pf)
138 : : return 0;
139 : :
140 : : struct zxdh_panel_table panel;
141 : :
142 : : memset(&panel, 0, sizeof(panel));
143 : 0 : panel.hit_flag = 1;
144 : 0 : panel.pf_vfid = zxdh_vport_to_vfid(hw->vport);
145 : 0 : panel.mtu_enable = 1;
146 : 0 : panel.mtu = dev->data->mtu;
147 : :
148 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T panel_entry = {
149 : 0 : .index = hw->phyport,
150 : : .p_data = (uint32_t *)&panel
151 : : };
152 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
153 : : .sdt_no = ZXDH_SDT_PANEL_ATT_TABLE,
154 : : .p_entry_data = (void *)&panel_entry
155 : : };
156 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid, 1, &entry);
157 : :
158 [ # # ]: 0 : if (ret) {
159 : 0 : PMD_DRV_LOG(ERR, "Insert eram-panel failed, code:%u", ret);
160 : : ret = -1;
161 : : }
162 : :
163 : : return ret;
164 : : }
165 : :
166 : 0 : int zxdh_get_panel_attr(struct rte_eth_dev *dev, struct zxdh_panel_table *panel_attr)
167 : : {
168 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
169 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
170 : 0 : uint8_t index_phy_port = hw->phyport;
171 : :
172 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T panel_entry = {
173 : : .index = index_phy_port,
174 : : .p_data = (uint32_t *)panel_attr
175 : : };
176 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
177 : : .sdt_no = ZXDH_SDT_PANEL_ATT_TABLE,
178 : : .p_entry_data = (void *)&panel_entry
179 : : };
180 : 0 : int ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &entry, 1);
181 : :
182 [ # # ]: 0 : if (ret != 0)
183 : 0 : PMD_DRV_LOG(ERR, "get panel table failed");
184 : :
185 : 0 : return ret;
186 : : }
187 : :
188 : 0 : int zxdh_set_panel_attr(struct rte_eth_dev *dev, struct zxdh_panel_table *panel_attr)
189 : : {
190 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
191 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
192 : 0 : uint8_t index_phy_port = hw->phyport;
193 : :
194 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T panel_entry = {
195 : : .index = index_phy_port,
196 : : .p_data = (uint32_t *)panel_attr
197 : : };
198 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
199 : : .sdt_no = ZXDH_SDT_PANEL_ATT_TABLE,
200 : : .p_entry_data = (void *)&panel_entry
201 : : };
202 : 0 : int ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid, 1, &entry);
203 : :
204 [ # # ]: 0 : if (ret)
205 : 0 : PMD_DRV_LOG(ERR, "Insert panel table failed");
206 : :
207 : 0 : return ret;
208 : : }
209 : :
210 : : int
211 : 0 : zxdh_get_port_attr(struct zxdh_hw *hw, uint16_t vport, struct zxdh_port_attr_table *port_attr)
212 : : {
213 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
214 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
215 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vport_num.vfid, (uint32_t *)port_attr};
216 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_get = {ZXDH_SDT_VPORT_ATT_TABLE, &entry};
217 : : int ret;
218 : :
219 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &user_entry_get, 1);
220 [ # # ]: 0 : if (ret != 0)
221 : 0 : PMD_DRV_LOG(ERR, "get port_attr vfid:%d failed, ret:%d", vport_num.vfid, ret);
222 : :
223 : 0 : return ret;
224 : : }
225 : :
226 : : int
227 : 0 : zxdh_delete_port_attr(struct zxdh_hw *hw, uint16_t vport,
228 : : struct zxdh_port_attr_table *port_attr)
229 : : {
230 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
231 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
232 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vport_num.vfid, (uint32_t *)port_attr};
233 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry = {
234 : : .sdt_no = ZXDH_SDT_VPORT_ATT_TABLE,
235 : : .p_entry_data = (void *)&entry
236 : : };
237 : 0 : int ret = zxdh_np_dtb_table_entry_delete(hw->slot_id, dtb_data->queueid, 1, &user_entry);
238 [ # # ]: 0 : if (ret != 0)
239 : 0 : PMD_DRV_LOG(ERR, "delete port attr failed, vfid:%u", vport_num.vfid);
240 : 0 : return ret;
241 : : }
242 : :
243 : : int
244 : 0 : zxdh_add_mac_table(struct zxdh_hw *hw, uint16_t vport, struct rte_ether_addr *addr,
245 : : uint8_t hash_search_idx, uint16_t srv_tpid, uint16_t srv_vlanid)
246 : : {
247 : 0 : struct zxdh_mac_unicast_table unicast_table = {0};
248 : 0 : struct zxdh_mac_multicast_table multicast_table = {0};
249 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
250 : : uint32_t ret;
251 : : uint16_t group_id = 0;
252 [ # # ]: 0 : uint16_t vfid = vport_num.vfid;
253 : :
254 [ # # ]: 0 : if (rte_is_unicast_ether_addr(addr)) {
255 : : rte_memcpy(unicast_table.key.dmac_addr, addr, sizeof(struct rte_ether_addr));
256 : 0 : unicast_table.key.sriov_vlan_tpid = srv_tpid;
257 : 0 : unicast_table.key.sriov_vlan_id = srv_vlanid;
258 : :
259 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
260 : : .p_actu_key = (uint8_t *)&unicast_table.key,
261 : : .p_rst = (uint8_t *)&unicast_table.entry
262 : : };
263 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
264 : 0 : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
265 : : .p_entry_data = (void *)&dtb_hash_entry
266 : : };
267 : :
268 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
269 : : &entry_get, 1);
270 [ # # ]: 0 : if (ret == 0) {
271 [ # # ]: 0 : if (unicast_table.entry.hit_flag != 0 &&
272 [ # # # # ]: 0 : rte_be_to_cpu_16(unicast_table.entry.vfid) != vfid) {
273 : 0 : return -EADDRINUSE;
274 [ # # ]: 0 : } else if (unicast_table.entry.hit_flag != 0 &&
275 [ # # # # ]: 0 : rte_be_to_cpu_16(unicast_table.entry.vfid) == vfid) {
276 : 0 : PMD_DRV_LOG(DEBUG, "vfid:%d, equals to itself mac, ret:%d",
277 : : vfid, ret);
278 : 0 : return 0;
279 : : }
280 : : }
281 : :
282 [ # # ]: 0 : unicast_table.entry.vfid = rte_cpu_to_be_16(vfid);
283 : 0 : unicast_table.entry.hit_flag = 1;
284 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
285 : 0 : hw->dev_sd->dtb_sd.queueid, 1, &entry_get);
286 [ # # ]: 0 : if (ret) {
287 : 0 : PMD_DRV_LOG(ERR, "Insert mac_table failed");
288 : 0 : return -ret;
289 : : }
290 : : } else {
291 [ # # ]: 0 : for (group_id = 0; group_id < 4; group_id++) {
292 : 0 : multicast_table.key.vf_group_id = group_id;
293 : : rte_memcpy(multicast_table.key.mac_addr,
294 : : addr, sizeof(struct rte_ether_addr));
295 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
296 : : .p_actu_key = (uint8_t *)&multicast_table.key,
297 : : .p_rst = (uint8_t *)&multicast_table.entry
298 : : };
299 : :
300 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
301 : 0 : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
302 : : .p_entry_data = (void *)&dtb_hash_entry
303 : : };
304 : :
305 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
306 : : &entry_get, 1);
307 : 0 : uint8_t index = (vport_num.vfid % 64) / 32;
308 [ # # ]: 0 : if (ret == 0) {
309 [ # # ]: 0 : if (vport_num.vf_flag) {
310 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
311 : 0 : multicast_table.entry.mc_bitmap[index] |=
312 [ # # ]: 0 : rte_cpu_to_be_32(UINT32_C(1) <<
313 : : (31 - index));
314 : : } else {
315 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
316 : 0 : multicast_table.entry.mc_pf_enable =
317 : : rte_cpu_to_be_32((1 << 30));
318 : : }
319 : : } else {
320 [ # # ]: 0 : if (vport_num.vf_flag) {
321 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
322 : 0 : multicast_table.entry.mc_bitmap[index] |=
323 [ # # ]: 0 : rte_cpu_to_be_32(UINT32_C(1) <<
324 : : (31 - index));
325 : : else
326 : 0 : multicast_table.entry.mc_bitmap[index] =
327 : : false;
328 : : } else {
329 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
330 : 0 : multicast_table.entry.mc_pf_enable =
331 : : rte_cpu_to_be_32((1 << 30));
332 : : else
333 : 0 : multicast_table.entry.mc_pf_enable = false;
334 : : }
335 : : }
336 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
337 : : 1, &entry_get);
338 [ # # ]: 0 : if (ret) {
339 : 0 : PMD_DRV_LOG(ERR, "add mac_table failed, code:%d", ret);
340 : 0 : return -ret;
341 : : }
342 : : }
343 : : }
344 : : return 0;
345 : : }
346 : :
347 : : int
348 : 0 : zxdh_del_mac_table(struct zxdh_hw *hw, uint16_t vport, struct rte_ether_addr *addr,
349 : : uint8_t hash_search_idx, uint16_t srv_tpid, uint16_t srv_vlanid)
350 : : {
351 : 0 : struct zxdh_mac_unicast_table unicast_table = {0};
352 : 0 : struct zxdh_mac_multicast_table multicast_table = {0};
353 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
354 : : uint32_t ret, del_flag = 0;
355 : : uint16_t group_id = 0;
356 : 0 : union zxdh_virport_num port = (union zxdh_virport_num)vport;
357 : 0 : uint16_t vfid = zxdh_vport_to_vfid(port);
358 : :
359 [ # # ]: 0 : if (rte_is_unicast_ether_addr(addr)) {
360 : : rte_memcpy(unicast_table.key.dmac_addr, addr, sizeof(struct rte_ether_addr));
361 : 0 : unicast_table.key.sriov_vlan_id = srv_vlanid;
362 : 0 : unicast_table.key.sriov_vlan_tpid = srv_tpid;
363 : :
364 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
365 : : .p_actu_key = (uint8_t *)&unicast_table.key,
366 : : .p_rst = (uint8_t *)&unicast_table.entry
367 : : };
368 : :
369 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
370 : 0 : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
371 : : .p_entry_data = (void *)&dtb_hash_entry
372 : : };
373 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
374 : : &entry_get, 1);
375 [ # # ]: 0 : if (ret == 0) {
376 [ # # ]: 0 : if (unicast_table.entry.hit_flag != 0 &&
377 [ # # # # ]: 0 : rte_be_to_cpu_16(unicast_table.entry.vfid) != vfid) {
378 : 0 : return -EADDRINUSE;
379 : : }
380 : : }
381 : :
382 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
383 : : 1, &entry_get);
384 [ # # ]: 0 : if (ret) {
385 : 0 : PMD_DRV_LOG(ERR, "delete l2_fwd_hash_table failed, code:%d", ret);
386 : 0 : return -ret;
387 : : }
388 : : } else {
389 : 0 : multicast_table.key.vf_group_id = vport_num.vfid / 64;
390 : : rte_memcpy(multicast_table.key.mac_addr, addr, sizeof(struct rte_ether_addr));
391 : :
392 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
393 : : .p_actu_key = (uint8_t *)&multicast_table.key,
394 : : .p_rst = (uint8_t *)&multicast_table.entry
395 : : };
396 : :
397 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
398 : 0 : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
399 : : .p_entry_data = (void *)&dtb_hash_entry
400 : : };
401 : :
402 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
403 : : &entry_get, 1);
404 : 0 : uint8_t index = (vport_num.vfid % 64) / 32;
405 [ # # ]: 0 : if (vport_num.vf_flag)
406 : 0 : multicast_table.entry.mc_bitmap[index] &=
407 [ # # ]: 0 : ~(rte_cpu_to_be_32(UINT32_C(1) << (31 - index)));
408 : : else
409 : 0 : multicast_table.entry.mc_pf_enable = 0;
410 : :
411 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
412 : : 1, &entry_get);
413 [ # # ]: 0 : if (ret) {
414 : 0 : PMD_DRV_LOG(ERR, "mac_addr_add mc_table failed, code:%d", ret);
415 : 0 : return -ret;
416 : : }
417 : :
418 [ # # ]: 0 : for (group_id = 0; group_id < ZXDH_MC_GROUP_NUM; group_id++) {
419 : 0 : multicast_table.key.vf_group_id = group_id;
420 : : rte_memcpy(multicast_table.key.mac_addr, addr,
421 : : sizeof(struct rte_ether_addr));
422 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
423 : : .p_actu_key = (uint8_t *)&multicast_table.key,
424 : : .p_rst = (uint8_t *)&multicast_table.entry
425 : : };
426 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
427 : : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
428 : : .p_entry_data = (void *)&dtb_hash_entry
429 : : };
430 : :
431 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
432 : : &entry_get, 1);
433 [ # # ]: 0 : if (multicast_table.entry.mc_bitmap[0] == 0 &&
434 [ # # ]: 0 : multicast_table.entry.mc_bitmap[1] == 0 &&
435 [ # # ]: 0 : multicast_table.entry.mc_pf_enable == 0) {
436 [ # # ]: 0 : if (group_id == (ZXDH_MC_GROUP_NUM - 1))
437 : : del_flag = 1;
438 : : } else {
439 : : break;
440 : : }
441 : : }
442 [ # # ]: 0 : if (del_flag) {
443 [ # # ]: 0 : for (group_id = 0; group_id < ZXDH_MC_GROUP_NUM; group_id++) {
444 : 0 : multicast_table.key.vf_group_id = group_id;
445 : : rte_memcpy(multicast_table.key.mac_addr, addr,
446 : : sizeof(struct rte_ether_addr));
447 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
448 : : .p_actu_key = (uint8_t *)&multicast_table.key,
449 : : .p_rst = (uint8_t *)&multicast_table.entry
450 : : };
451 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
452 : : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
453 : : .p_entry_data = (void *)&dtb_hash_entry
454 : : };
455 : :
456 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id,
457 : 0 : hw->dev_sd->dtb_sd.queueid, 1, &entry_get);
458 : : }
459 : : }
460 : : }
461 : : return 0;
462 : : }
463 : :
464 : : int
465 : 0 : zxdh_promisc_table_init(struct rte_eth_dev *dev)
466 : : {
467 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
468 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
469 : : uint32_t ret, vf_group_id = 0;
470 : 0 : struct zxdh_brocast_table brocast_table = {0};
471 : 0 : struct zxdh_unitcast_table uc_table = {0};
472 : 0 : struct zxdh_multicast_table mc_table = {0};
473 : :
474 [ # # ]: 0 : if (!hw->is_pf)
475 : : return 0;
476 : :
477 [ # # ]: 0 : for (; vf_group_id < 4; vf_group_id++) {
478 : 0 : brocast_table.flag = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
479 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_brocast_entry = {
480 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
481 : : .p_data = (uint32_t *)&brocast_table
482 : : };
483 : 0 : ZXDH_DTB_USER_ENTRY_T entry_brocast = {
484 : : .sdt_no = ZXDH_SDT_BROCAST_ATT_TABLE,
485 : : .p_entry_data = (void *)&eram_brocast_entry
486 : : };
487 : :
488 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
489 : 0 : dtb_data->queueid, 1, &entry_brocast);
490 [ # # ]: 0 : if (ret) {
491 : 0 : PMD_DRV_LOG(ERR, "write brocast table failed");
492 : 0 : return ret;
493 : : }
494 : :
495 : 0 : uc_table.uc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
496 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_uc_entry = {
497 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
498 : : .p_data = (uint32_t *)&uc_table
499 : : };
500 : 0 : ZXDH_DTB_USER_ENTRY_T entry_unicast = {
501 : : .sdt_no = ZXDH_SDT_UNICAST_ATT_TABLE,
502 : : .p_entry_data = (void *)&eram_uc_entry
503 : : };
504 : :
505 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
506 : 0 : dtb_data->queueid, 1, &entry_unicast);
507 [ # # ]: 0 : if (ret) {
508 : 0 : PMD_DRV_LOG(ERR, "write unicast table failed");
509 : 0 : return ret;
510 : : }
511 : :
512 : 0 : mc_table.mc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
513 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_mc_entry = {
514 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
515 : : .p_data = (uint32_t *)&mc_table
516 : : };
517 : 0 : ZXDH_DTB_USER_ENTRY_T entry_multicast = {
518 : : .sdt_no = ZXDH_SDT_MULTICAST_ATT_TABLE,
519 : : .p_entry_data = (void *)&eram_mc_entry
520 : : };
521 : :
522 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid,
523 : : 1, &entry_multicast);
524 [ # # ]: 0 : if (ret) {
525 : 0 : PMD_DRV_LOG(ERR, "write multicast table failed");
526 : 0 : return ret;
527 : : }
528 : : }
529 : :
530 : 0 : return ret;
531 : : }
532 : :
533 : : int
534 : 0 : zxdh_promisc_table_uninit(struct rte_eth_dev *dev)
535 : : {
536 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
537 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
538 : : uint32_t ret, vf_group_id = 0;
539 : 0 : struct zxdh_brocast_table brocast_table = {0};
540 : 0 : struct zxdh_unitcast_table uc_table = {0};
541 : 0 : struct zxdh_multicast_table mc_table = {0};
542 : :
543 [ # # ]: 0 : if (!hw->is_pf)
544 : : return 0;
545 : :
546 [ # # ]: 0 : for (; vf_group_id < 4; vf_group_id++) {
547 : 0 : brocast_table.flag = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
548 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_brocast_entry = {
549 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
550 : : .p_data = (uint32_t *)&brocast_table
551 : : };
552 : 0 : ZXDH_DTB_USER_ENTRY_T entry_brocast = {
553 : : .sdt_no = ZXDH_SDT_BROCAST_ATT_TABLE,
554 : : .p_entry_data = (void *)&eram_brocast_entry
555 : : };
556 : :
557 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id,
558 : 0 : dtb_data->queueid, 1, &entry_brocast);
559 [ # # ]: 0 : if (ret) {
560 : 0 : PMD_DRV_LOG(ERR, "write brocast table failed");
561 : 0 : return ret;
562 : : }
563 : :
564 : 0 : uc_table.uc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
565 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_uc_entry = {
566 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
567 : : .p_data = (uint32_t *)&uc_table
568 : : };
569 : 0 : ZXDH_DTB_USER_ENTRY_T entry_unicast = {
570 : : .sdt_no = ZXDH_SDT_UNICAST_ATT_TABLE,
571 : : .p_entry_data = (void *)&eram_uc_entry
572 : : };
573 : :
574 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id,
575 : 0 : dtb_data->queueid, 1, &entry_unicast);
576 [ # # ]: 0 : if (ret) {
577 : 0 : PMD_DRV_LOG(ERR, "write unicast table failed");
578 : 0 : return ret;
579 : : }
580 : :
581 : 0 : mc_table.mc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
582 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_mc_entry = {
583 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
584 : : .p_data = (uint32_t *)&mc_table
585 : : };
586 : 0 : ZXDH_DTB_USER_ENTRY_T entry_multicast = {
587 : : .sdt_no = ZXDH_SDT_MULTICAST_ATT_TABLE,
588 : : .p_entry_data = (void *)&eram_mc_entry
589 : : };
590 : :
591 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id, dtb_data->queueid,
592 : : 1, &entry_multicast);
593 [ # # ]: 0 : if (ret) {
594 : 0 : PMD_DRV_LOG(ERR, "write multicast table failed");
595 : 0 : return ret;
596 : : }
597 : : }
598 : :
599 : 0 : return ret;
600 : : }
601 : :
602 : : int
603 : 0 : zxdh_dev_unicast_table_set(struct zxdh_hw *hw, uint16_t vport, bool enable)
604 : : {
605 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
606 : 0 : struct zxdh_unitcast_table uc_table = {0};
607 : 0 : struct zxdh_port_attr_table port_attr = {0};
608 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
609 : : int16_t ret = 0;
610 : :
611 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T uc_table_entry = {
612 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vport_num.vfid / 64,
613 : : .p_data = (uint32_t *)&uc_table
614 : : };
615 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
616 : : .sdt_no = ZXDH_SDT_UNICAST_ATT_TABLE,
617 : : .p_entry_data = (void *)&uc_table_entry
618 : : };
619 : :
620 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &entry, 1);
621 [ # # ]: 0 : if (ret) {
622 : 0 : PMD_DRV_LOG(ERR, "unicast_table_get_failed:%d", hw->vfid);
623 : 0 : return -ret;
624 : : }
625 : :
626 [ # # ]: 0 : if (vport_num.vf_flag) {
627 [ # # ]: 0 : if (enable)
628 : 0 : uc_table.bitmap[(vport_num.vfid % 64) / 32] |=
629 : 0 : UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32);
630 : : else
631 : 0 : uc_table.bitmap[(vport_num.vfid % 64) / 32] &=
632 : 0 : ~(UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32));
633 : : } else {
634 [ # # ]: 0 : uc_table.uc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG + (enable << 6));
635 : : }
636 : :
637 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid, 1, &entry);
638 [ # # ]: 0 : if (ret) {
639 : 0 : PMD_DRV_LOG(ERR, "unicast_table_set_failed:%d", hw->vfid);
640 : 0 : return -ret;
641 : : }
642 : :
643 : 0 : ret = zxdh_get_port_attr(hw, vport, &port_attr);
644 [ # # ]: 0 : if (ret) {
645 : 0 : PMD_DRV_LOG(ERR, "port_attr_table_get_failed:%d", hw->vfid);
646 : 0 : return -ret;
647 : : }
648 : :
649 : 0 : port_attr.promisc_enable = enable;
650 : 0 : ret = zxdh_set_port_attr(hw, vport, &port_attr);
651 [ # # ]: 0 : if (ret) {
652 : 0 : PMD_DRV_LOG(ERR, "port_attr_table_set_failed:%d", hw->vfid);
653 : 0 : return -ret;
654 : : }
655 : :
656 : : return 0;
657 : : }
658 : :
659 : : int
660 : 0 : zxdh_dev_multicast_table_set(struct zxdh_hw *hw, uint16_t vport, bool enable)
661 : : {
662 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
663 : 0 : struct zxdh_multicast_table mc_table = {0};
664 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
665 : : int16_t ret = 0;
666 : :
667 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T mc_table_entry = {
668 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vport_num.vfid / 64,
669 : : .p_data = (uint32_t *)&mc_table
670 : : };
671 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
672 : : .sdt_no = ZXDH_SDT_MULTICAST_ATT_TABLE,
673 : : .p_entry_data = (void *)&mc_table_entry
674 : : };
675 : :
676 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &entry, 1);
677 [ # # ]: 0 : if (ret) {
678 : 0 : PMD_DRV_LOG(ERR, "allmulti_table_get_failed:%d", hw->vfid);
679 : 0 : return -ret;
680 : : }
681 : :
682 [ # # ]: 0 : if (vport_num.vf_flag) {
683 [ # # ]: 0 : if (enable)
684 : 0 : mc_table.bitmap[(vport_num.vfid % 64) / 32] |=
685 : 0 : UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32);
686 : : else
687 : 0 : mc_table.bitmap[(vport_num.vfid % 64) / 32] &=
688 : 0 : ~(UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32));
689 : :
690 : : } else {
691 [ # # ]: 0 : mc_table.mc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG + (enable << 6));
692 : : }
693 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid, 1, &entry);
694 [ # # ]: 0 : if (ret) {
695 : 0 : PMD_DRV_LOG(ERR, "allmulti_table_set_failed:%d", hw->vfid);
696 : 0 : return -ret;
697 : : }
698 : : return 0;
699 : : }
700 : :
701 : : int
702 : 0 : zxdh_vlan_filter_table_init(struct rte_eth_dev *dev)
703 : : {
704 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
705 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
706 : 0 : struct zxdh_vlan_filter_table vlan_table = {0};
707 : : int16_t ret = 0;
708 : :
709 [ # # ]: 0 : if (!hw->is_pf)
710 : : return 0;
711 : :
712 [ # # ]: 0 : for (uint8_t vlan_group = 0; vlan_group < ZXDH_VLAN_GROUP_NUM; vlan_group++) {
713 [ # # ]: 0 : if (vlan_group == 0) {
714 : 0 : vlan_table.vlans[0] |= (1 << ZXDH_FIRST_VLAN_GROUP_BITS);
715 : 0 : vlan_table.vlans[0] |= (1 << ZXDH_VLAN_GROUP_BITS);
716 : :
717 : : } else {
718 : 0 : vlan_table.vlans[0] = 0;
719 : : }
720 : 0 : uint32_t index = (vlan_group << 11) | hw->vport.vfid;
721 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry_data = {
722 : : .index = index,
723 : : .p_data = (uint32_t *)&vlan_table
724 : : };
725 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry = {ZXDH_SDT_VLAN_ATT_TABLE, &entry_data};
726 : :
727 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
728 : 0 : dtb_data->queueid, 1, &user_entry);
729 [ # # ]: 0 : if (ret != 0) {
730 : 0 : PMD_DRV_LOG(ERR,
731 : : "[vfid:%d], vlan_group:%d, init vlan filter table failed",
732 : : hw->vport.vfid, vlan_group);
733 : : ret = -1;
734 : : }
735 : : }
736 : :
737 : 0 : return ret;
738 : : }
739 : :
740 : : int
741 : 0 : zxdh_vlan_filter_table_set(struct zxdh_hw *hw, uint16_t vport, uint16_t vlan_id, uint8_t enable)
742 : : {
743 [ # # ]: 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
744 : : struct zxdh_vlan_filter_table vlan_table = {0};
745 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
746 : : int ret = 0;
747 : :
748 : : memset(&vlan_table, 0, sizeof(struct zxdh_vlan_filter_table));
749 : 0 : int table_num = vlan_id / ZXDH_VLAN_FILTER_VLANID_STEP;
750 : 0 : uint32_t index = (table_num << 11) | vport_num.vfid;
751 : 0 : uint16_t group = (vlan_id - table_num * ZXDH_VLAN_FILTER_VLANID_STEP) / 8 + 1;
752 : :
753 : : uint8_t val = sizeof(struct zxdh_vlan_filter_table) / sizeof(uint32_t);
754 : 0 : uint8_t vlan_tbl_index = group / val;
755 : 0 : uint16_t used_group = vlan_tbl_index * val;
756 : :
757 [ # # ]: 0 : used_group = (used_group == 0 ? 0 : (used_group - 1));
758 : :
759 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry_data = {index, (uint32_t *)&vlan_table};
760 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_get = {ZXDH_SDT_VLAN_ATT_TABLE, &entry_data};
761 : :
762 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &user_entry_get, 1);
763 [ # # ]: 0 : if (ret) {
764 : 0 : PMD_DRV_LOG(ERR, "get vlan table failed");
765 : 0 : return -1;
766 : : }
767 : 0 : uint16_t relative_vlan_id = vlan_id - table_num * ZXDH_VLAN_FILTER_VLANID_STEP;
768 : : uint32_t *base_group = &vlan_table.vlans[0];
769 : :
770 : 0 : *base_group |= 1 << 31;
771 : : base_group = &vlan_table.vlans[vlan_tbl_index];
772 [ # # ]: 0 : uint8_t valid_bits = (vlan_tbl_index == 0 ?
773 : : ZXDH_FIRST_VLAN_GROUP_BITS : ZXDH_VLAN_GROUP_BITS) + 1;
774 : :
775 : 0 : uint8_t shift_left = (valid_bits - (relative_vlan_id - used_group * 8) % valid_bits) - 1;
776 : :
777 [ # # ]: 0 : if (enable)
778 : 0 : *base_group |= 1 << shift_left;
779 : : else
780 : 0 : *base_group &= ~(1 << shift_left);
781 : :
782 : :
783 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_write = {
784 : : .sdt_no = ZXDH_SDT_VLAN_ATT_TABLE,
785 : : .p_entry_data = &entry_data
786 : : };
787 : :
788 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
789 : 0 : dtb_data->queueid, 1, &user_entry_write);
790 [ # # ]: 0 : if (ret != 0) {
791 : 0 : PMD_DRV_LOG(ERR, "write vlan table failed");
792 : 0 : return -1;
793 : : }
794 : : return 0;
795 : : }
796 : :
797 : : int
798 : 0 : zxdh_rss_table_set(struct zxdh_hw *hw, uint16_t vport, struct zxdh_rss_reta *rss_reta)
799 : : {
800 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
801 : 0 : struct zxdh_rss_to_vqid_table rss_vqid = {0};
802 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
803 : : int ret = 0;
804 : :
805 [ # # ]: 0 : for (uint16_t i = 0; i < RTE_ETH_RSS_RETA_SIZE_256 / 8; i++) {
806 [ # # ]: 0 : for (uint16_t j = 0; j < 8; j++) {
807 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
808 [ # # ]: 0 : if (j % 2 == 0)
809 : 0 : rss_vqid.vqm_qid[j + 1] = rss_reta->reta[i * 8 + j];
810 : : else
811 : 0 : rss_vqid.vqm_qid[j - 1] = rss_reta->reta[i * 8 + j];
812 : : #else
813 : : rss_vqid.vqm_qid[j] = rss_init->reta[i * 8 + j];
814 : : #endif
815 : : }
816 : :
817 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
818 : 0 : rss_vqid.vqm_qid[1] |= 0x8000;
819 : : #else
820 : : rss_vqid.vqm_qid[0] |= 0x8000;
821 : : #endif
822 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {
823 : 0 : .index = vport_num.vfid * 32 + i,
824 : : .p_data = (uint32_t *)&rss_vqid
825 : : };
826 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_write = {
827 : : .sdt_no = ZXDH_SDT_RSS_ATT_TABLE,
828 : : .p_entry_data = &entry
829 : : };
830 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
831 : 0 : dtb_data->queueid, 1, &user_entry_write);
832 [ # # ]: 0 : if (ret != 0) {
833 : 0 : PMD_DRV_LOG(ERR, "write rss base qid failed vfid:%d", vport_num.vfid);
834 : 0 : return ret;
835 : : }
836 : : }
837 : : return 0;
838 : : }
839 : :
840 : : int
841 : 0 : zxdh_rss_table_get(struct zxdh_hw *hw, uint16_t vport, struct zxdh_rss_reta *rss_reta)
842 : : {
843 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
844 : 0 : struct zxdh_rss_to_vqid_table rss_vqid = {0};
845 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
846 : : int ret = 0;
847 : :
848 [ # # ]: 0 : for (uint16_t i = 0; i < RTE_ETH_RSS_RETA_SIZE_256 / 8; i++) {
849 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vport_num.vfid * 32 + i, (uint32_t *)&rss_vqid};
850 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry = {ZXDH_SDT_RSS_ATT_TABLE, &entry};
851 : :
852 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id,
853 : 0 : dtb_data->queueid, &user_entry, 1);
854 [ # # ]: 0 : if (ret != 0) {
855 : 0 : PMD_DRV_LOG(ERR, "get rss tbl failed, vfid:%d", vport_num.vfid);
856 : 0 : return -1;
857 : : }
858 : :
859 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
860 : 0 : rss_vqid.vqm_qid[1] &= 0x7FFF;
861 : : #else
862 : : rss_vqid.vqm_qid[0] &= 0x7FFF;
863 : : #endif
864 : : uint8_t size = sizeof(struct zxdh_rss_to_vqid_table) / sizeof(uint16_t);
865 : :
866 [ # # ]: 0 : for (int j = 0; j < size; j++) {
867 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
868 [ # # ]: 0 : if (j % 2 == 0)
869 : 0 : rss_reta->reta[i * 8 + j] = rss_vqid.vqm_qid[j + 1];
870 : : else
871 : 0 : rss_reta->reta[i * 8 + j] = rss_vqid.vqm_qid[j - 1];
872 : : #else
873 : : rss_reta->reta[i * 8 + j] = rss_vqid.vqm_qid[j];
874 : : #endif
875 : : }
876 : : }
877 : : return 0;
878 : : }
879 : :
880 : : int
881 : 0 : zxdh_dev_broadcast_set(struct zxdh_hw *hw, uint16_t vport, bool enable)
882 : : {
883 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
884 : 0 : struct zxdh_brocast_table brocast_table = {0};
885 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
886 : 0 : int16_t vf_group_id = vport_num.vfid / 64;
887 : : int16_t ret = 0;
888 : :
889 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_entry = {
890 : 0 : ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
891 : : (uint32_t *)&brocast_table};
892 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
893 : : .sdt_no = ZXDH_SDT_BROCAST_ATT_TABLE,
894 : : .p_entry_data = (void *)&eram_entry};
895 : :
896 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &entry_get, 1);
897 [ # # ]: 0 : if (ret == 0) {
898 [ # # ]: 0 : if (enable)
899 : 0 : brocast_table.bitmap[(vport_num.vfid % 64) / 32] |=
900 : 0 : ((UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32)));
901 : : else
902 : 0 : brocast_table.bitmap[(vport_num.vfid % 64) / 32] &=
903 : 0 : ~((UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32)));
904 : :
905 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid, 1, &entry_get);
906 [ # # ]: 0 : if (ret) {
907 : 0 : PMD_DRV_LOG(ERR, "brocast_table_write_failed. code:%d", ret);
908 : 0 : return -ret;
909 : : }
910 : : }
911 : : return 0;
912 : : }
913 : :
914 : : static int
915 : 0 : zxdh_vlan_relate_vport(struct rte_eth_dev *dev, uint16_t vport,
916 : : struct zxdh_port_attr_table *vport_attr,
917 : : struct zxdh_port_vlan_table *port_vlan, uint8_t on)
918 : : {
919 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
920 : : union zxdh_virport_num port = (union zxdh_virport_num)vport;
921 : : int ret = 0;
922 : :
923 [ # # ]: 0 : if (on) {
924 [ # # ]: 0 : if (!vport_attr->business_vlan_enable) {
925 : 0 : vport_attr->business_vlan_enable = 1;
926 : 0 : ret = zxdh_set_port_attr(hw, vport, vport_attr);
927 [ # # ]: 0 : if (ret) {
928 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] vlan offload set failedd, set vport tbl ret:%d",
929 : : port.vfid, ret);
930 : 0 : return ret;
931 : : }
932 : : }
933 : : } else {
934 [ # # ]: 0 : if (no_business_offload(port_vlan))
935 [ # # ]: 0 : if (vport_attr->business_vlan_enable) {
936 : 0 : PMD_DRV_LOG(INFO, "port vlan no business offload, vport business_vlan_enable set 0");
937 : 0 : vport_attr->business_vlan_enable = 0;
938 : 0 : ret = zxdh_set_port_attr(hw, vport, vport_attr);
939 [ # # ]: 0 : if (ret) {
940 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] vlan offload set failedd, set vport tbl ret:%d",
941 : : port.vfid, ret);
942 : 0 : return ret;
943 : : }
944 : : }
945 : : }
946 : :
947 : : return 0;
948 : : }
949 : :
950 : : static int
951 : 0 : zxdh_set_port_vlan_attr(struct zxdh_hw *hw, uint16_t vport,
952 : : struct zxdh_port_vlan_table *port_vlan)
953 : : {
954 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
955 : : int ret = 0;
956 : :
957 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T port_entry = {
958 : 0 : .index = vport_num.vfid,
959 : : .p_data = (uint32_t *)port_vlan
960 : : };
961 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
962 : : .sdt_no = ZXDH_SDT_PORT_VLAN_ATT_TABLE,
963 : : .p_entry_data = (void *)&port_entry
964 : : };
965 : :
966 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, hw->dev_sd->dtb_sd.queueid, 1, &entry);
967 [ # # ]: 0 : if (ret)
968 : 0 : PMD_DRV_LOG(ERR, "write port_vlan tbl failed, ret:%d ", ret);
969 : 0 : return ret;
970 : : }
971 : :
972 : : static int
973 : 0 : zxdh_get_port_vlan_attr(struct zxdh_hw *hw, uint16_t vport,
974 : : struct zxdh_port_vlan_table *port_vlan)
975 : : {
976 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
977 : : int ret = 0;
978 : :
979 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T port_entry = {
980 : 0 : .index = vport_num.vfid,
981 : : .p_data = (uint32_t *)port_vlan
982 : : };
983 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
984 : : .sdt_no = ZXDH_SDT_PORT_VLAN_ATT_TABLE,
985 : : .p_entry_data = (void *)&port_entry
986 : : };
987 : :
988 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
989 : : &entry, 1);
990 [ # # ]: 0 : if (ret)
991 : 0 : PMD_DRV_LOG(ERR, "get port vlan tbl failed, ret:%d ", ret);
992 : :
993 : 0 : return ret;
994 : : }
995 : :
996 : : static int
997 : 0 : set_vlan_config(struct zxdh_hw *hw, uint16_t vport, uint8_t type, uint8_t enable)
998 : : {
999 : 0 : struct zxdh_port_attr_table vport_attr = {0};
1000 : 0 : struct zxdh_port_vlan_table port_vlan_attr = {0};
1001 : : union zxdh_virport_num port = (union zxdh_virport_num)vport;
1002 : : uint16_t vfid = port.vfid;
1003 : : int ret = 0;
1004 : :
1005 : 0 : ret = zxdh_get_port_vlan_attr(hw, vport, &port_vlan_attr);
1006 [ # # ]: 0 : if (ret) {
1007 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] get port vlan ret:%d", vfid, ret);
1008 : 0 : return ret;
1009 : : }
1010 : 0 : ret = zxdh_get_port_attr(hw, vport, &vport_attr);
1011 [ # # ]: 0 : if (ret) {
1012 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] get port ret:%d", vfid, ret);
1013 : 0 : return ret;
1014 : : }
1015 : :
1016 [ # # ]: 0 : if (type == ZXDH_VLAN_STRIP_TYPE)
1017 : 0 : port_vlan_attr.business_vlan_strip = !!enable;
1018 [ # # ]: 0 : else if (type == ZXDH_QINQ_STRIP_TYPE)
1019 : 0 : port_vlan_attr.business_qinq_strip = !!enable;
1020 [ # # ]: 0 : else if (type == ZXDH_VLAN_FILTER_TYPE)
1021 : 0 : port_vlan_attr.business_vlan_filter = !!enable;
1022 : :
1023 : 0 : port_vlan_attr.hit_flag = 1;
1024 : :
1025 : 0 : ret = zxdh_set_port_vlan_attr(hw, vport, &port_vlan_attr);
1026 [ # # ]: 0 : if (ret) {
1027 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] set port vlan ret:%d", vfid, ret);
1028 : 0 : return ret;
1029 : : }
1030 : :
1031 : 0 : return zxdh_vlan_relate_vport(hw->eth_dev, vport, &vport_attr, &port_vlan_attr, enable);
1032 : : }
1033 : :
1034 : 0 : int zxdh_set_vlan_filter(struct zxdh_hw *hw, uint16_t vport, uint8_t enable)
1035 : : {
1036 : 0 : return set_vlan_config(hw, vport, ZXDH_VLAN_FILTER_TYPE, enable);
1037 : : }
1038 : :
1039 : 0 : int zxdh_set_vlan_offload(struct zxdh_hw *hw, uint16_t vport, uint8_t type, uint8_t enable)
1040 : : {
1041 : 0 : return set_vlan_config(hw, vport, type, enable);
1042 : : }
|
