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_UNIMAC_HASH_INDEX(index) (ZXDH_SDT_L2_ENTRY_TABLE0 + (index))
12 : : #define ZXDH_MULTIMAC_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 : : uint32_t ret;
248 : : uint16_t group_id = 0;
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_UNIMAC_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_MULTIMAC_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 : if (ret == 0) {
305 [ # # ]: 0 : if (vport_num.vf_flag) {
306 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
307 : 0 : multicast_table.entry.mc_bitmap[index] |=
308 [ # # ]: 0 : rte_cpu_to_be_32(UINT32_C(1) <<
309 : : (31 - index));
310 : : } else {
311 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
312 : 0 : multicast_table.entry.mc_pf_enable =
313 : : rte_cpu_to_be_32((1 << 30));
314 : : }
315 : : } else {
316 [ # # ]: 0 : if (vport_num.vf_flag) {
317 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
318 : 0 : multicast_table.entry.mc_bitmap[index] |=
319 [ # # ]: 0 : rte_cpu_to_be_32(UINT32_C(1) <<
320 : : (31 - index));
321 : : else
322 : 0 : multicast_table.entry.mc_bitmap[index] =
323 : : false;
324 : : } else {
325 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
326 : 0 : multicast_table.entry.mc_pf_enable =
327 : : rte_cpu_to_be_32((1 << 30));
328 : : else
329 : 0 : multicast_table.entry.mc_pf_enable = false;
330 : : }
331 : : }
332 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
333 : : 1, &entry_get);
334 [ # # ]: 0 : if (ret) {
335 : 0 : PMD_DRV_LOG(ERR, "add mac_table failed, code:%d", ret);
336 : 0 : return -ret;
337 : : }
338 : : }
339 : : }
340 : : return 0;
341 : : }
342 : :
343 : : int
344 : 0 : zxdh_del_mac_table(struct zxdh_hw *hw, uint16_t vport, struct rte_ether_addr *addr,
345 : : uint8_t hash_search_idx, uint16_t srv_tpid, uint16_t srv_vlanid)
346 : : {
347 : 0 : struct zxdh_mac_unicast_table unicast_table = {0};
348 : 0 : struct zxdh_mac_multicast_table multicast_table = {0};
349 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
350 : 0 : union zxdh_virport_num port = (union zxdh_virport_num)vport;
351 : 0 : uint16_t vfid = zxdh_vport_to_vfid(port);
352 : : uint32_t ret, del_flag = 0;
353 : : uint16_t group_id = 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_UNIMAC_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_MULTIMAC_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 : if (vport_num.vf_flag)
404 : 0 : multicast_table.entry.mc_bitmap[index] &=
405 [ # # ]: 0 : ~(rte_cpu_to_be_32(UINT32_C(1) << (31 - index)));
406 : : else
407 : 0 : multicast_table.entry.mc_pf_enable = 0;
408 : :
409 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
410 : : 1, &entry_get);
411 [ # # ]: 0 : if (ret) {
412 : 0 : PMD_DRV_LOG(ERR, "mac_addr_add mc_table failed, code:%d", ret);
413 : 0 : return -ret;
414 : : }
415 : :
416 [ # # ]: 0 : for (group_id = 0; group_id < ZXDH_MC_GROUP_NUM; group_id++) {
417 : 0 : multicast_table.key.vf_group_id = group_id;
418 : : rte_memcpy(multicast_table.key.mac_addr, addr,
419 : : sizeof(struct rte_ether_addr));
420 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
421 : : .p_actu_key = (uint8_t *)&multicast_table.key,
422 : : .p_rst = (uint8_t *)&multicast_table.entry
423 : : };
424 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
425 : : .sdt_no = ZXDH_MULTIMAC_HASH_INDEX(hash_search_idx),
426 : : .p_entry_data = (void *)&dtb_hash_entry
427 : : };
428 : :
429 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
430 : : &entry_get, 1);
431 [ # # ]: 0 : if (multicast_table.entry.mc_bitmap[0] == 0 &&
432 [ # # ]: 0 : multicast_table.entry.mc_bitmap[1] == 0 &&
433 [ # # ]: 0 : multicast_table.entry.mc_pf_enable == 0) {
434 [ # # ]: 0 : if (group_id == (ZXDH_MC_GROUP_NUM - 1))
435 : : del_flag = 1;
436 : : } else {
437 : : break;
438 : : }
439 : : }
440 [ # # ]: 0 : if (del_flag) {
441 [ # # ]: 0 : for (group_id = 0; group_id < ZXDH_MC_GROUP_NUM; group_id++) {
442 : 0 : multicast_table.key.vf_group_id = group_id;
443 : : rte_memcpy(multicast_table.key.mac_addr, addr,
444 : : sizeof(struct rte_ether_addr));
445 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
446 : : .p_actu_key = (uint8_t *)&multicast_table.key,
447 : : .p_rst = (uint8_t *)&multicast_table.entry
448 : : };
449 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
450 : : .sdt_no = ZXDH_MULTIMAC_HASH_INDEX(hash_search_idx),
451 : : .p_entry_data = (void *)&dtb_hash_entry
452 : : };
453 : :
454 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id,
455 : 0 : hw->dev_sd->dtb_sd.queueid, 1, &entry_get);
456 : : }
457 : : }
458 : : }
459 : : return 0;
460 : : }
461 : :
462 : : int
463 : 0 : zxdh_promisc_table_init(struct rte_eth_dev *dev)
464 : : {
465 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
466 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
467 : : uint32_t ret, vf_group_id = 0;
468 : 0 : struct zxdh_brocast_table brocast_table = {0};
469 : 0 : struct zxdh_unitcast_table uc_table = {0};
470 : 0 : struct zxdh_multicast_table mc_table = {0};
471 : :
472 [ # # ]: 0 : if (!hw->is_pf)
473 : : return 0;
474 : :
475 [ # # ]: 0 : for (; vf_group_id < 4; vf_group_id++) {
476 : 0 : brocast_table.flag = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
477 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_brocast_entry = {
478 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
479 : : .p_data = (uint32_t *)&brocast_table
480 : : };
481 : 0 : ZXDH_DTB_USER_ENTRY_T entry_brocast = {
482 : : .sdt_no = ZXDH_SDT_BROCAST_ATT_TABLE,
483 : : .p_entry_data = (void *)&eram_brocast_entry
484 : : };
485 : :
486 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
487 : 0 : dtb_data->queueid, 1, &entry_brocast);
488 [ # # ]: 0 : if (ret) {
489 : 0 : PMD_DRV_LOG(ERR, "write brocast table failed");
490 : 0 : return ret;
491 : : }
492 : :
493 : 0 : uc_table.uc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
494 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_uc_entry = {
495 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
496 : : .p_data = (uint32_t *)&uc_table
497 : : };
498 : 0 : ZXDH_DTB_USER_ENTRY_T entry_unicast = {
499 : : .sdt_no = ZXDH_SDT_UNICAST_ATT_TABLE,
500 : : .p_entry_data = (void *)&eram_uc_entry
501 : : };
502 : :
503 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
504 : 0 : dtb_data->queueid, 1, &entry_unicast);
505 [ # # ]: 0 : if (ret) {
506 : 0 : PMD_DRV_LOG(ERR, "write unicast table failed");
507 : 0 : return ret;
508 : : }
509 : :
510 : 0 : mc_table.mc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
511 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_mc_entry = {
512 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
513 : : .p_data = (uint32_t *)&mc_table
514 : : };
515 : 0 : ZXDH_DTB_USER_ENTRY_T entry_multicast = {
516 : : .sdt_no = ZXDH_SDT_MULTICAST_ATT_TABLE,
517 : : .p_entry_data = (void *)&eram_mc_entry
518 : : };
519 : :
520 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid,
521 : : 1, &entry_multicast);
522 [ # # ]: 0 : if (ret) {
523 : 0 : PMD_DRV_LOG(ERR, "write multicast table failed");
524 : 0 : return ret;
525 : : }
526 : : }
527 : :
528 : 0 : return ret;
529 : : }
530 : :
531 : : int
532 : 0 : zxdh_promisc_table_uninit(struct rte_eth_dev *dev)
533 : : {
534 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
535 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
536 : : uint32_t ret, vf_group_id = 0;
537 : 0 : struct zxdh_brocast_table brocast_table = {0};
538 : 0 : struct zxdh_unitcast_table uc_table = {0};
539 : 0 : struct zxdh_multicast_table mc_table = {0};
540 : :
541 [ # # ]: 0 : if (!hw->is_pf)
542 : : return 0;
543 : :
544 [ # # ]: 0 : for (; vf_group_id < 4; vf_group_id++) {
545 : 0 : brocast_table.flag = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
546 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_brocast_entry = {
547 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
548 : : .p_data = (uint32_t *)&brocast_table
549 : : };
550 : 0 : ZXDH_DTB_USER_ENTRY_T entry_brocast = {
551 : : .sdt_no = ZXDH_SDT_BROCAST_ATT_TABLE,
552 : : .p_entry_data = (void *)&eram_brocast_entry
553 : : };
554 : :
555 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id,
556 : 0 : dtb_data->queueid, 1, &entry_brocast);
557 [ # # ]: 0 : if (ret) {
558 : 0 : PMD_DRV_LOG(ERR, "write brocast table failed");
559 : 0 : return ret;
560 : : }
561 : :
562 : 0 : uc_table.uc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
563 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_uc_entry = {
564 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
565 : : .p_data = (uint32_t *)&uc_table
566 : : };
567 : 0 : ZXDH_DTB_USER_ENTRY_T entry_unicast = {
568 : : .sdt_no = ZXDH_SDT_UNICAST_ATT_TABLE,
569 : : .p_entry_data = (void *)&eram_uc_entry
570 : : };
571 : :
572 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id,
573 : 0 : dtb_data->queueid, 1, &entry_unicast);
574 [ # # ]: 0 : if (ret) {
575 : 0 : PMD_DRV_LOG(ERR, "write unicast table failed");
576 : 0 : return ret;
577 : : }
578 : :
579 : 0 : mc_table.mc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
580 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_mc_entry = {
581 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
582 : : .p_data = (uint32_t *)&mc_table
583 : : };
584 : 0 : ZXDH_DTB_USER_ENTRY_T entry_multicast = {
585 : : .sdt_no = ZXDH_SDT_MULTICAST_ATT_TABLE,
586 : : .p_entry_data = (void *)&eram_mc_entry
587 : : };
588 : :
589 : 0 : ret = zxdh_np_dtb_table_entry_delete(hw->slot_id, dtb_data->queueid,
590 : : 1, &entry_multicast);
591 [ # # ]: 0 : if (ret) {
592 : 0 : PMD_DRV_LOG(ERR, "write multicast table failed");
593 : 0 : return ret;
594 : : }
595 : : }
596 : :
597 : 0 : return ret;
598 : : }
599 : :
600 : : int
601 : 0 : zxdh_dev_unicast_table_set(struct zxdh_hw *hw, uint16_t vport, bool enable)
602 : : {
603 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
604 : 0 : struct zxdh_unitcast_table uc_table = {0};
605 : 0 : struct zxdh_port_attr_table port_attr = {0};
606 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
607 : : int16_t ret = 0;
608 : :
609 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T uc_table_entry = {
610 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vport_num.vfid / 64,
611 : : .p_data = (uint32_t *)&uc_table
612 : : };
613 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
614 : : .sdt_no = ZXDH_SDT_UNICAST_ATT_TABLE,
615 : : .p_entry_data = (void *)&uc_table_entry
616 : : };
617 : :
618 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &entry, 1);
619 [ # # ]: 0 : if (ret) {
620 : 0 : PMD_DRV_LOG(ERR, "unicast_table_get_failed:%d", hw->vfid);
621 : 0 : return -ret;
622 : : }
623 : :
624 [ # # ]: 0 : if (vport_num.vf_flag) {
625 [ # # ]: 0 : if (enable)
626 : 0 : uc_table.bitmap[(vport_num.vfid % 64) / 32] |=
627 : 0 : UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32);
628 : : else
629 : 0 : uc_table.bitmap[(vport_num.vfid % 64) / 32] &=
630 : 0 : ~(UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32));
631 : : } else {
632 [ # # ]: 0 : uc_table.uc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG + (enable << 6));
633 : : }
634 : :
635 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid, 1, &entry);
636 [ # # ]: 0 : if (ret) {
637 : 0 : PMD_DRV_LOG(ERR, "unicast_table_set_failed:%d", hw->vfid);
638 : 0 : return -ret;
639 : : }
640 : :
641 : 0 : ret = zxdh_get_port_attr(hw, vport, &port_attr);
642 [ # # ]: 0 : if (ret) {
643 : 0 : PMD_DRV_LOG(ERR, "port_attr_table_get_failed:%d", hw->vfid);
644 : 0 : return -ret;
645 : : }
646 : :
647 : 0 : port_attr.promisc_enable = enable;
648 : 0 : ret = zxdh_set_port_attr(hw, vport, &port_attr);
649 [ # # ]: 0 : if (ret) {
650 : 0 : PMD_DRV_LOG(ERR, "port_attr_table_set_failed:%d", hw->vfid);
651 : 0 : return -ret;
652 : : }
653 : :
654 : : return 0;
655 : : }
656 : :
657 : : int
658 : 0 : zxdh_dev_multicast_table_set(struct zxdh_hw *hw, uint16_t vport, bool enable)
659 : : {
660 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
661 : 0 : struct zxdh_multicast_table mc_table = {0};
662 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
663 : : int16_t ret = 0;
664 : :
665 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T mc_table_entry = {
666 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vport_num.vfid / 64,
667 : : .p_data = (uint32_t *)&mc_table
668 : : };
669 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
670 : : .sdt_no = ZXDH_SDT_MULTICAST_ATT_TABLE,
671 : : .p_entry_data = (void *)&mc_table_entry
672 : : };
673 : :
674 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &entry, 1);
675 [ # # ]: 0 : if (ret) {
676 : 0 : PMD_DRV_LOG(ERR, "allmulti_table_get_failed:%d", hw->vfid);
677 : 0 : return -ret;
678 : : }
679 : :
680 [ # # ]: 0 : if (vport_num.vf_flag) {
681 [ # # ]: 0 : if (enable)
682 : 0 : mc_table.bitmap[(vport_num.vfid % 64) / 32] |=
683 : 0 : UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32);
684 : : else
685 : 0 : mc_table.bitmap[(vport_num.vfid % 64) / 32] &=
686 : 0 : ~(UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32));
687 : :
688 : : } else {
689 [ # # ]: 0 : mc_table.mc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG + (enable << 6));
690 : : }
691 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid, 1, &entry);
692 [ # # ]: 0 : if (ret) {
693 : 0 : PMD_DRV_LOG(ERR, "allmulti_table_set_failed:%d", hw->vfid);
694 : 0 : return -ret;
695 : : }
696 : : return 0;
697 : : }
698 : :
699 : : int
700 : 0 : zxdh_vlan_filter_table_init(struct rte_eth_dev *dev)
701 : : {
702 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
703 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
704 : 0 : struct zxdh_vlan_filter_table vlan_table = {0};
705 : : int16_t ret = 0;
706 : :
707 [ # # ]: 0 : if (!hw->is_pf)
708 : : return 0;
709 : :
710 [ # # ]: 0 : for (uint8_t vlan_group = 0; vlan_group < ZXDH_VLAN_GROUP_NUM; vlan_group++) {
711 [ # # ]: 0 : if (vlan_group == 0) {
712 : 0 : vlan_table.vlans[0] |= (1 << ZXDH_FIRST_VLAN_GROUP_BITS);
713 : 0 : vlan_table.vlans[0] |= (1 << ZXDH_VLAN_GROUP_BITS);
714 : :
715 : : } else {
716 : 0 : vlan_table.vlans[0] = 0;
717 : : }
718 : 0 : uint32_t index = (vlan_group << 11) | hw->vport.vfid;
719 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry_data = {
720 : : .index = index,
721 : : .p_data = (uint32_t *)&vlan_table
722 : : };
723 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry = {ZXDH_SDT_VLAN_ATT_TABLE, &entry_data};
724 : :
725 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
726 : 0 : dtb_data->queueid, 1, &user_entry);
727 [ # # ]: 0 : if (ret != 0) {
728 : 0 : PMD_DRV_LOG(ERR,
729 : : "[vfid:%d], vlan_group:%d, init vlan filter table failed",
730 : : hw->vport.vfid, vlan_group);
731 : : ret = -1;
732 : : }
733 : : }
734 : :
735 : 0 : return ret;
736 : : }
737 : :
738 : : int
739 : 0 : zxdh_vlan_filter_table_set(struct zxdh_hw *hw, uint16_t vport, uint16_t vlan_id, uint8_t enable)
740 : : {
741 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
742 : 0 : struct zxdh_vlan_filter_table vlan_table = {0};
743 : 0 : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
744 : 0 : uint16_t vfid = zxdh_vport_to_vfid(vport_num);
745 : : int ret = 0;
746 : :
747 : : memset(&vlan_table, 0, sizeof(struct zxdh_vlan_filter_table));
748 : 0 : int table_num = vlan_id / ZXDH_VLAN_FILTER_VLANID_STEP;
749 : 0 : uint32_t index = (table_num << 11) | vfid;
750 : 0 : uint16_t group = (vlan_id - table_num * ZXDH_VLAN_FILTER_VLANID_STEP) / 8 + 1;
751 : :
752 : : uint8_t val = sizeof(struct zxdh_vlan_filter_table) / sizeof(uint32_t);
753 : 0 : uint8_t vlan_tbl_index = group / val;
754 : 0 : uint16_t used_group = vlan_tbl_index * val;
755 : :
756 [ # # ]: 0 : used_group = (used_group == 0 ? 0 : (used_group - 1));
757 : :
758 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry_data = {index, (uint32_t *)&vlan_table};
759 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_get = {ZXDH_SDT_VLAN_ATT_TABLE, &entry_data};
760 : :
761 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &user_entry_get, 1);
762 [ # # ]: 0 : if (ret) {
763 : 0 : PMD_DRV_LOG(ERR, "get vlan table failed");
764 : 0 : return -1;
765 : : }
766 : 0 : uint16_t relative_vlan_id = vlan_id - table_num * ZXDH_VLAN_FILTER_VLANID_STEP;
767 : : uint32_t *base_group = &vlan_table.vlans[0];
768 : :
769 : 0 : *base_group |= 1 << 31;
770 : : base_group = &vlan_table.vlans[vlan_tbl_index];
771 [ # # ]: 0 : uint8_t valid_bits = (vlan_tbl_index == 0 ?
772 : : ZXDH_FIRST_VLAN_GROUP_BITS : ZXDH_VLAN_GROUP_BITS) + 1;
773 : :
774 : 0 : uint8_t shift_left = (valid_bits - (relative_vlan_id - used_group * 8) % valid_bits) - 1;
775 : :
776 [ # # ]: 0 : if (enable)
777 : 0 : *base_group |= 1 << shift_left;
778 : : else
779 : 0 : *base_group &= ~(1 << shift_left);
780 : :
781 : :
782 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_write = {
783 : : .sdt_no = ZXDH_SDT_VLAN_ATT_TABLE,
784 : : .p_entry_data = &entry_data
785 : : };
786 : :
787 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
788 : 0 : dtb_data->queueid, 1, &user_entry_write);
789 [ # # ]: 0 : if (ret != 0) {
790 : 0 : PMD_DRV_LOG(ERR, "write vlan table failed");
791 : 0 : return -1;
792 : : }
793 : : return 0;
794 : : }
795 : :
796 : : int
797 : 0 : zxdh_rss_table_set(struct zxdh_hw *hw, uint16_t vport, struct zxdh_rss_reta *rss_reta)
798 : : {
799 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
800 : 0 : struct zxdh_rss_to_vqid_table rss_vqid = {0};
801 : 0 : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
802 : 0 : uint16_t vfid = zxdh_vport_to_vfid(vport_num);
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 = 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", 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 : 0 : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
846 : 0 : uint16_t vfid = zxdh_vport_to_vfid(vport_num);
847 : : int ret = 0;
848 : :
849 [ # # ]: 0 : for (uint16_t i = 0; i < RTE_ETH_RSS_RETA_SIZE_256 / 8; i++) {
850 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vfid * 32 + i, (uint32_t *)&rss_vqid};
851 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry = {ZXDH_SDT_RSS_ATT_TABLE, &entry};
852 : :
853 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id,
854 : 0 : dtb_data->queueid, &user_entry, 1);
855 [ # # ]: 0 : if (ret != 0) {
856 : 0 : PMD_DRV_LOG(ERR, "get rss tbl failed, vfid:%d", vfid);
857 : 0 : return -1;
858 : : }
859 : :
860 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
861 : 0 : rss_vqid.vqm_qid[1] &= 0x7FFF;
862 : : #else
863 : : rss_vqid.vqm_qid[0] &= 0x7FFF;
864 : : #endif
865 : : uint8_t size = sizeof(struct zxdh_rss_to_vqid_table) / sizeof(uint16_t);
866 : :
867 [ # # ]: 0 : for (int j = 0; j < size; j++) {
868 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
869 [ # # ]: 0 : if (j % 2 == 0)
870 : 0 : rss_reta->reta[i * 8 + j] = rss_vqid.vqm_qid[j + 1];
871 : : else
872 : 0 : rss_reta->reta[i * 8 + j] = rss_vqid.vqm_qid[j - 1];
873 : : #else
874 : : rss_reta->reta[i * 8 + j] = rss_vqid.vqm_qid[j];
875 : : #endif
876 : : }
877 : : }
878 : : return 0;
879 : : }
880 : :
881 : : int
882 : 0 : zxdh_dev_broadcast_set(struct zxdh_hw *hw, uint16_t vport, bool enable)
883 : : {
884 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
885 : 0 : struct zxdh_brocast_table brocast_table = {0};
886 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
887 : 0 : int16_t vf_group_id = vport_num.vfid / 64;
888 : : int16_t ret = 0;
889 : :
890 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_entry = {
891 : 0 : ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
892 : : (uint32_t *)&brocast_table};
893 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
894 : : .sdt_no = ZXDH_SDT_BROCAST_ATT_TABLE,
895 : : .p_entry_data = (void *)&eram_entry};
896 : :
897 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &entry_get, 1);
898 [ # # ]: 0 : if (ret == 0) {
899 [ # # ]: 0 : if (enable)
900 : 0 : brocast_table.bitmap[(vport_num.vfid % 64) / 32] |=
901 : 0 : ((UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32)));
902 : : else
903 : 0 : brocast_table.bitmap[(vport_num.vfid % 64) / 32] &=
904 : 0 : ~((UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32)));
905 : :
906 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, dtb_data->queueid, 1, &entry_get);
907 [ # # ]: 0 : if (ret) {
908 : 0 : PMD_DRV_LOG(ERR, "brocast_table_write_failed. code:%d", ret);
909 : 0 : return -ret;
910 : : }
911 : : }
912 : : return 0;
913 : : }
914 : :
915 : : static int
916 : 0 : zxdh_vlan_relate_vport(struct rte_eth_dev *dev, uint16_t vport,
917 : : struct zxdh_port_attr_table *vport_attr,
918 : : struct zxdh_port_vlan_table *port_vlan, uint8_t on)
919 : : {
920 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
921 : : union zxdh_virport_num port = (union zxdh_virport_num)vport;
922 : : int ret = 0;
923 : :
924 [ # # ]: 0 : if (on) {
925 [ # # ]: 0 : if (!vport_attr->business_vlan_enable) {
926 : 0 : vport_attr->business_vlan_enable = 1;
927 : 0 : ret = zxdh_set_port_attr(hw, vport, vport_attr);
928 [ # # ]: 0 : if (ret) {
929 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] vlan offload set failedd, set vport tbl ret:%d",
930 : : port.vfid, ret);
931 : 0 : return ret;
932 : : }
933 : : }
934 : : } else {
935 [ # # ]: 0 : if (no_business_offload(port_vlan))
936 [ # # ]: 0 : if (vport_attr->business_vlan_enable) {
937 : 0 : PMD_DRV_LOG(INFO, "port vlan no business offload, vport business_vlan_enable set 0");
938 : 0 : vport_attr->business_vlan_enable = 0;
939 : 0 : ret = zxdh_set_port_attr(hw, vport, vport_attr);
940 [ # # ]: 0 : if (ret) {
941 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] vlan offload set failedd, set vport tbl ret:%d",
942 : : port.vfid, ret);
943 : 0 : return ret;
944 : : }
945 : : }
946 : : }
947 : :
948 : : return 0;
949 : : }
950 : :
951 : : static int
952 : 0 : zxdh_set_port_vlan_attr(struct zxdh_hw *hw, uint16_t vport,
953 : : struct zxdh_port_vlan_table *port_vlan)
954 : : {
955 : 0 : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
956 : 0 : uint16_t vfid = zxdh_vport_to_vfid(vport_num);
957 : : int ret = 0;
958 : :
959 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T port_entry = {
960 : : .index = vfid,
961 : : .p_data = (uint32_t *)port_vlan
962 : : };
963 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
964 : : .sdt_no = ZXDH_SDT_PORT_VLAN_ATT_TABLE,
965 : : .p_entry_data = (void *)&port_entry
966 : : };
967 : :
968 : 0 : ret = zxdh_np_dtb_table_entry_write(hw->slot_id, hw->dev_sd->dtb_sd.queueid, 1, &entry);
969 [ # # ]: 0 : if (ret)
970 : 0 : PMD_DRV_LOG(ERR, "write port_vlan tbl failed, ret:%d ", ret);
971 : 0 : return ret;
972 : : }
973 : :
974 : : static int
975 : 0 : zxdh_get_port_vlan_attr(struct zxdh_hw *hw, uint16_t vport,
976 : : struct zxdh_port_vlan_table *port_vlan)
977 : : {
978 : 0 : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
979 : 0 : uint16_t vfid = zxdh_vport_to_vfid(vport_num);
980 : : int ret = 0;
981 : :
982 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T port_entry = {
983 : : .index = vfid,
984 : : .p_data = (uint32_t *)port_vlan
985 : : };
986 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
987 : : .sdt_no = ZXDH_SDT_PORT_VLAN_ATT_TABLE,
988 : : .p_entry_data = (void *)&port_entry
989 : : };
990 : :
991 : 0 : ret = zxdh_np_dtb_table_entry_get(hw->slot_id, hw->dev_sd->dtb_sd.queueid,
992 : : &entry, 1);
993 [ # # ]: 0 : if (ret)
994 : 0 : PMD_DRV_LOG(ERR, "get port vlan tbl failed, ret:%d ", ret);
995 : :
996 : 0 : return ret;
997 : : }
998 : :
999 : : static int
1000 : 0 : set_vlan_config(struct zxdh_hw *hw, uint16_t vport, uint8_t type, uint8_t enable)
1001 : : {
1002 : 0 : struct zxdh_port_attr_table vport_attr = {0};
1003 : 0 : struct zxdh_port_vlan_table port_vlan_attr = {0};
1004 : : union zxdh_virport_num port = (union zxdh_virport_num)vport;
1005 : : uint16_t vfid = port.vfid;
1006 : : int ret = 0;
1007 : :
1008 : 0 : ret = zxdh_get_port_vlan_attr(hw, vport, &port_vlan_attr);
1009 [ # # ]: 0 : if (ret) {
1010 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] get port vlan ret:%d", vfid, ret);
1011 : 0 : return ret;
1012 : : }
1013 : 0 : ret = zxdh_get_port_attr(hw, vport, &vport_attr);
1014 [ # # ]: 0 : if (ret) {
1015 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] get port ret:%d", vfid, ret);
1016 : 0 : return ret;
1017 : : }
1018 : :
1019 [ # # ]: 0 : if (type == ZXDH_VLAN_STRIP_TYPE)
1020 : 0 : port_vlan_attr.business_vlan_strip = !!enable;
1021 [ # # ]: 0 : else if (type == ZXDH_QINQ_STRIP_TYPE)
1022 : 0 : port_vlan_attr.business_qinq_strip = !!enable;
1023 [ # # ]: 0 : else if (type == ZXDH_VLAN_FILTER_TYPE)
1024 : 0 : port_vlan_attr.business_vlan_filter = !!enable;
1025 : :
1026 : 0 : port_vlan_attr.hit_flag = 1;
1027 : :
1028 : 0 : ret = zxdh_set_port_vlan_attr(hw, vport, &port_vlan_attr);
1029 [ # # ]: 0 : if (ret) {
1030 : 0 : PMD_DRV_LOG(ERR, "[vfid:%d] set port vlan ret:%d", vfid, ret);
1031 : 0 : return ret;
1032 : : }
1033 : :
1034 : 0 : return zxdh_vlan_relate_vport(hw->eth_dev, vport, &vport_attr, &port_vlan_attr, enable);
1035 : : }
1036 : :
1037 : 0 : int zxdh_set_vlan_filter(struct zxdh_hw *hw, uint16_t vport, uint8_t enable)
1038 : : {
1039 : 0 : return set_vlan_config(hw, vport, ZXDH_VLAN_FILTER_TYPE, enable);
1040 : : }
1041 : :
1042 : 0 : int zxdh_set_vlan_offload(struct zxdh_hw *hw, uint16_t vport, uint8_t type, uint8_t enable)
1043 : : {
1044 : 0 : return set_vlan_config(hw, vport, type, enable);
1045 : : }
|
