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