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 : :
19 : : #define ZXDH_MAC_HASH_INDEX_BASE 64
20 : : #define ZXDH_MAC_HASH_INDEX(index) (ZXDH_MAC_HASH_INDEX_BASE + (index))
21 : : #define ZXDH_MC_GROUP_NUM 4
22 : : #define ZXDH_BASE_VFID 1152
23 : : #define ZXDH_TABLE_HIT_FLAG 128
24 : : #define ZXDH_FIRST_VLAN_GROUP_BITS 23
25 : : #define ZXDH_VLAN_GROUP_BITS 31
26 : : #define ZXDH_VLAN_GROUP_NUM 35
27 : : #define ZXDH_VLAN_FILTER_VLANID_STEP 120
28 : :
29 : : int
30 : 0 : zxdh_set_port_attr(uint16_t vfid, struct zxdh_port_attr_table *port_attr)
31 : : {
32 : : int ret = 0;
33 : :
34 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vfid, (uint32_t *)port_attr};
35 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_write = {ZXDH_SDT_VPORT_ATT_TABLE, (void *)&entry};
36 : :
37 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO,
38 : 0 : g_dtb_data.queueid, 1, &user_entry_write);
39 [ # # ]: 0 : if (ret != 0)
40 : 0 : PMD_DRV_LOG(ERR, "write vport_att failed vfid:%d failed", vfid);
41 : :
42 : 0 : return ret;
43 : : }
44 : :
45 : : int
46 : 0 : zxdh_port_attr_init(struct rte_eth_dev *dev)
47 : : {
48 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
49 : 0 : struct zxdh_port_attr_table port_attr = {0};
50 : 0 : struct zxdh_msg_info msg_info = {0};
51 : : int ret;
52 : :
53 [ # # ]: 0 : if (hw->is_pf) {
54 : 0 : port_attr.hit_flag = 1;
55 : 0 : port_attr.phy_port = hw->phyport;
56 : 0 : port_attr.pf_vfid = zxdh_vport_to_vfid(hw->vport);
57 : 0 : port_attr.rss_enable = 0;
58 [ # # ]: 0 : if (!hw->is_pf)
59 : 0 : port_attr.is_vf = 1;
60 : :
61 : 0 : port_attr.mtu = dev->data->mtu;
62 : 0 : port_attr.mtu_enable = 1;
63 : 0 : port_attr.is_up = 0;
64 : : if (!port_attr.rss_enable)
65 : 0 : port_attr.port_base_qid = 0;
66 : :
67 : 0 : ret = zxdh_set_port_attr(hw->vfid, &port_attr);
68 [ # # ]: 0 : if (ret) {
69 : 0 : PMD_DRV_LOG(ERR, "write port_attr failed");
70 : : ret = -1;
71 : : }
72 : : } else {
73 : : struct zxdh_vf_init_msg *vf_init_msg = &msg_info.data.vf_init_msg;
74 : :
75 : 0 : zxdh_msg_head_build(hw, ZXDH_VF_PORT_INIT, &msg_info);
76 : 0 : msg_info.msg_head.msg_type = ZXDH_VF_PORT_INIT;
77 : 0 : vf_init_msg->link_up = 1;
78 : 0 : vf_init_msg->base_qid = 0;
79 : 0 : vf_init_msg->rss_enable = 0;
80 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
81 [ # # ]: 0 : if (ret) {
82 : 0 : PMD_DRV_LOG(ERR, "vf port_init failed");
83 : : ret = -1;
84 : : }
85 : : }
86 : 0 : return ret;
87 : : };
88 : :
89 : : int
90 : 0 : zxdh_port_attr_uninit(struct rte_eth_dev *dev)
91 : : {
92 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
93 : 0 : struct zxdh_msg_info msg_info = {0};
94 : 0 : struct zxdh_port_attr_table port_attr = {0};
95 : : int ret = 0;
96 : :
97 [ # # ]: 0 : if (hw->is_pf == 1) {
98 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T port_attr_entry = {hw->vfid, (uint32_t *)&port_attr};
99 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
100 : : .sdt_no = ZXDH_SDT_VPORT_ATT_TABLE,
101 : : .p_entry_data = (void *)&port_attr_entry
102 : : };
103 : 0 : ret = zxdh_np_dtb_table_entry_delete(ZXDH_DEVICE_NO, g_dtb_data.queueid, 1, &entry);
104 [ # # ]: 0 : if (ret) {
105 : 0 : PMD_DRV_LOG(ERR, "delete port attr table failed");
106 : : ret = -1;
107 : : }
108 : : } else {
109 : 0 : zxdh_msg_head_build(hw, ZXDH_VF_PORT_UNINIT, &msg_info);
110 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
111 [ # # ]: 0 : if (ret) {
112 : 0 : PMD_DRV_LOG(ERR, "vf port tables uninit failed");
113 : : ret = -1;
114 : : }
115 : : }
116 : 0 : return ret;
117 : : }
118 : :
119 : 0 : int zxdh_panel_table_init(struct rte_eth_dev *dev)
120 : : {
121 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
122 : : int ret;
123 : :
124 [ # # ]: 0 : if (!hw->is_pf)
125 : : return 0;
126 : :
127 : : struct zxdh_panel_table panel;
128 : :
129 : : memset(&panel, 0, sizeof(panel));
130 : 0 : panel.hit_flag = 1;
131 : 0 : panel.pf_vfid = zxdh_vport_to_vfid(hw->vport);
132 : 0 : panel.mtu_enable = 1;
133 : 0 : panel.mtu = dev->data->mtu;
134 : :
135 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T panel_entry = {
136 : 0 : .index = hw->phyport,
137 : : .p_data = (uint32_t *)&panel
138 : : };
139 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
140 : : .sdt_no = ZXDH_SDT_PANEL_ATT_TABLE,
141 : : .p_entry_data = (void *)&panel_entry
142 : : };
143 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO, g_dtb_data.queueid, 1, &entry);
144 : :
145 [ # # ]: 0 : if (ret) {
146 : 0 : PMD_DRV_LOG(ERR, "Insert eram-panel failed, code:%u", ret);
147 : : ret = -1;
148 : : }
149 : :
150 : : return ret;
151 : : }
152 : :
153 : 0 : int zxdh_get_panel_attr(struct rte_eth_dev *dev, struct zxdh_panel_table *panel_attr)
154 : : {
155 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
156 : 0 : uint8_t index_phy_port = hw->phyport;
157 : :
158 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T panel_entry = {
159 : : .index = index_phy_port,
160 : : .p_data = (uint32_t *)panel_attr
161 : : };
162 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
163 : : .sdt_no = ZXDH_SDT_PANEL_ATT_TABLE,
164 : : .p_entry_data = (void *)&panel_entry
165 : : };
166 : 0 : int ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO, g_dtb_data.queueid, &entry, 1);
167 : :
168 [ # # ]: 0 : if (ret != 0)
169 : 0 : PMD_DRV_LOG(ERR, "get panel table failed");
170 : :
171 : 0 : return ret;
172 : : }
173 : :
174 : 0 : int zxdh_set_panel_attr(struct rte_eth_dev *dev, struct zxdh_panel_table *panel_attr)
175 : : {
176 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
177 : 0 : uint8_t index_phy_port = hw->phyport;
178 : :
179 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T panel_entry = {
180 : : .index = index_phy_port,
181 : : .p_data = (uint32_t *)panel_attr
182 : : };
183 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
184 : : .sdt_no = ZXDH_SDT_PANEL_ATT_TABLE,
185 : : .p_entry_data = (void *)&panel_entry
186 : : };
187 : 0 : int ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO, g_dtb_data.queueid, 1, &entry);
188 : :
189 [ # # ]: 0 : if (ret)
190 : 0 : PMD_DRV_LOG(ERR, "Insert panel table failed");
191 : :
192 : 0 : return ret;
193 : : }
194 : :
195 : : int
196 : 0 : zxdh_get_port_attr(uint16_t vfid, struct zxdh_port_attr_table *port_attr)
197 : : {
198 : : int ret;
199 : :
200 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vfid, (uint32_t *)port_attr};
201 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_get = {ZXDH_SDT_VPORT_ATT_TABLE, &entry};
202 : :
203 : 0 : ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO, g_dtb_data.queueid, &user_entry_get, 1);
204 [ # # ]: 0 : if (ret != 0)
205 : 0 : PMD_DRV_LOG(ERR, "get port_attr vfid:%d failed, ret:%d", vfid, ret);
206 : :
207 : 0 : return ret;
208 : : }
209 : :
210 : : int
211 : 0 : zxdh_set_mac_table(uint16_t vport, struct rte_ether_addr *addr, uint8_t hash_search_idx)
212 : : {
213 : 0 : struct zxdh_mac_unicast_table unicast_table = {0};
214 [ # # ]: 0 : struct zxdh_mac_multicast_table multicast_table = {0};
215 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
216 : : uint32_t ret;
217 : : uint16_t group_id = 0;
218 : :
219 [ # # ]: 0 : if (rte_is_unicast_ether_addr(addr)) {
220 : : rte_memcpy(unicast_table.key.dmac_addr, addr, sizeof(struct rte_ether_addr));
221 : : unicast_table.entry.hit_flag = 0;
222 : 0 : unicast_table.entry.vfid = vport_num.vfid;
223 : :
224 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
225 : : .p_actu_key = (uint8_t *)&unicast_table.key,
226 : : .p_rst = (uint8_t *)&unicast_table.entry
227 : : };
228 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
229 : 0 : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
230 : : .p_entry_data = (void *)&dtb_hash_entry
231 : : };
232 : :
233 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO,
234 : 0 : g_dtb_data.queueid, 1, &entry_get);
235 [ # # ]: 0 : if (ret) {
236 : 0 : PMD_DRV_LOG(ERR, "Insert mac_table failed");
237 : 0 : return -ret;
238 : : }
239 : : } else {
240 [ # # ]: 0 : for (group_id = 0; group_id < 4; group_id++) {
241 : 0 : multicast_table.key.vf_group_id = group_id;
242 : : rte_memcpy(multicast_table.key.mac_addr,
243 : : addr, sizeof(struct rte_ether_addr));
244 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
245 : : .p_actu_key = (uint8_t *)&multicast_table.key,
246 : : .p_rst = (uint8_t *)&multicast_table.entry
247 : : };
248 : :
249 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
250 : 0 : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
251 : : .p_entry_data = (void *)&dtb_hash_entry
252 : : };
253 : :
254 : 0 : ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO, g_dtb_data.queueid,
255 : : &entry_get, 1);
256 : 0 : uint8_t index = (vport_num.vfid % 64) / 32;
257 [ # # ]: 0 : if (ret == 0) {
258 [ # # ]: 0 : if (vport_num.vf_flag) {
259 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
260 : 0 : multicast_table.entry.mc_bitmap[index] |=
261 [ # # ]: 0 : rte_cpu_to_be_32(UINT32_C(1) <<
262 : : (31 - index));
263 : : } else {
264 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
265 : 0 : multicast_table.entry.mc_pf_enable =
266 : : rte_cpu_to_be_32((1 << 30));
267 : : }
268 : : } else {
269 [ # # ]: 0 : if (vport_num.vf_flag) {
270 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
271 : 0 : multicast_table.entry.mc_bitmap[index] |=
272 [ # # ]: 0 : rte_cpu_to_be_32(UINT32_C(1) <<
273 : : (31 - index));
274 : : else
275 : 0 : multicast_table.entry.mc_bitmap[index] =
276 : : false;
277 : : } else {
278 [ # # ]: 0 : if (group_id == vport_num.vfid / 64)
279 : 0 : multicast_table.entry.mc_pf_enable =
280 : : rte_cpu_to_be_32((1 << 30));
281 : : else
282 : 0 : multicast_table.entry.mc_pf_enable = false;
283 : : }
284 : : }
285 : :
286 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO, g_dtb_data.queueid,
287 : : 1, &entry_get);
288 [ # # ]: 0 : if (ret) {
289 : 0 : PMD_DRV_LOG(ERR, "add mac_table failed, code:%d", ret);
290 : 0 : return -ret;
291 : : }
292 : : }
293 : : }
294 : : return 0;
295 : : }
296 : :
297 : : int
298 : 0 : zxdh_del_mac_table(uint16_t vport, struct rte_ether_addr *addr, uint8_t hash_search_idx)
299 : : {
300 : 0 : struct zxdh_mac_unicast_table unicast_table = {0};
301 [ # # ]: 0 : struct zxdh_mac_multicast_table multicast_table = {0};
302 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
303 : : uint32_t ret, del_flag = 0;
304 : : uint16_t group_id = 0;
305 : :
306 [ # # ]: 0 : if (rte_is_unicast_ether_addr(addr)) {
307 : : rte_memcpy(unicast_table.key.dmac_addr, addr, sizeof(struct rte_ether_addr));
308 : : unicast_table.entry.hit_flag = 0;
309 : 0 : unicast_table.entry.vfid = vport_num.vfid;
310 : :
311 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
312 : : .p_actu_key = (uint8_t *)&unicast_table.key,
313 : : .p_rst = (uint8_t *)&unicast_table.entry
314 : : };
315 : :
316 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
317 : 0 : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
318 : : .p_entry_data = (void *)&dtb_hash_entry
319 : : };
320 : :
321 : 0 : ret = zxdh_np_dtb_table_entry_delete(ZXDH_DEVICE_NO,
322 : 0 : g_dtb_data.queueid, 1, &entry_get);
323 [ # # ]: 0 : if (ret) {
324 : 0 : PMD_DRV_LOG(ERR, "delete l2_fwd_hash_table failed, code:%d", ret);
325 : 0 : return -ret;
326 : : }
327 : : } else {
328 : 0 : multicast_table.key.vf_group_id = vport_num.vfid / 64;
329 : : rte_memcpy(multicast_table.key.mac_addr, addr, sizeof(struct rte_ether_addr));
330 : :
331 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
332 : : .p_actu_key = (uint8_t *)&multicast_table.key,
333 : : .p_rst = (uint8_t *)&multicast_table.entry
334 : : };
335 : :
336 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
337 : 0 : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
338 : : .p_entry_data = (void *)&dtb_hash_entry
339 : : };
340 : :
341 : 0 : ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO,
342 : 0 : g_dtb_data.queueid, &entry_get, 1);
343 : 0 : uint8_t index = (vport_num.vfid % 64) / 32;
344 [ # # ]: 0 : if (vport_num.vf_flag)
345 : 0 : multicast_table.entry.mc_bitmap[index] &=
346 [ # # ]: 0 : ~(rte_cpu_to_be_32(UINT32_C(1) << (31 - index)));
347 : : else
348 : 0 : multicast_table.entry.mc_pf_enable = 0;
349 : :
350 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO,
351 : 0 : g_dtb_data.queueid, 1, &entry_get);
352 [ # # ]: 0 : if (ret) {
353 : 0 : PMD_DRV_LOG(ERR, "mac_addr_add mc_table failed, code:%d", ret);
354 : 0 : return -ret;
355 : : }
356 : :
357 [ # # ]: 0 : for (group_id = 0; group_id < ZXDH_MC_GROUP_NUM; group_id++) {
358 : 0 : multicast_table.key.vf_group_id = group_id;
359 : : rte_memcpy(multicast_table.key.mac_addr, addr,
360 : : sizeof(struct rte_ether_addr));
361 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
362 : : .p_actu_key = (uint8_t *)&multicast_table.key,
363 : : .p_rst = (uint8_t *)&multicast_table.entry
364 : : };
365 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
366 : : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
367 : : .p_entry_data = (void *)&dtb_hash_entry
368 : : };
369 : :
370 : 0 : ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO, g_dtb_data.queueid,
371 : : &entry_get, 1);
372 [ # # ]: 0 : if (multicast_table.entry.mc_bitmap[0] == 0 &&
373 [ # # ]: 0 : multicast_table.entry.mc_bitmap[1] == 0 &&
374 [ # # ]: 0 : multicast_table.entry.mc_pf_enable == 0) {
375 [ # # ]: 0 : if (group_id == (ZXDH_MC_GROUP_NUM - 1))
376 : : del_flag = 1;
377 : : } else {
378 : : break;
379 : : }
380 : : }
381 [ # # ]: 0 : if (del_flag) {
382 [ # # ]: 0 : for (group_id = 0; group_id < ZXDH_MC_GROUP_NUM; group_id++) {
383 : 0 : multicast_table.key.vf_group_id = group_id;
384 : : rte_memcpy(multicast_table.key.mac_addr, addr,
385 : : sizeof(struct rte_ether_addr));
386 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
387 : : .p_actu_key = (uint8_t *)&multicast_table.key,
388 : : .p_rst = (uint8_t *)&multicast_table.entry
389 : : };
390 : 0 : ZXDH_DTB_USER_ENTRY_T entry_get = {
391 : : .sdt_no = ZXDH_MAC_HASH_INDEX(hash_search_idx),
392 : : .p_entry_data = (void *)&dtb_hash_entry
393 : : };
394 : :
395 : 0 : ret = zxdh_np_dtb_table_entry_delete(ZXDH_DEVICE_NO,
396 : 0 : g_dtb_data.queueid, 1, &entry_get);
397 : : }
398 : : }
399 : : }
400 : : return 0;
401 : : }
402 : :
403 : : int
404 : 0 : zxdh_promisc_table_init(struct rte_eth_dev *dev)
405 : : {
406 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
407 : : uint32_t ret, vf_group_id = 0;
408 : 0 : struct zxdh_brocast_table brocast_table = {0};
409 : 0 : struct zxdh_unitcast_table uc_table = {0};
410 : 0 : struct zxdh_multicast_table mc_table = {0};
411 : :
412 [ # # ]: 0 : if (!hw->is_pf)
413 : : return 0;
414 : :
415 [ # # ]: 0 : for (; vf_group_id < 4; vf_group_id++) {
416 : 0 : brocast_table.flag = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
417 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_brocast_entry = {
418 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
419 : : .p_data = (uint32_t *)&brocast_table
420 : : };
421 : 0 : ZXDH_DTB_USER_ENTRY_T entry_brocast = {
422 : : .sdt_no = ZXDH_SDT_BROCAST_ATT_TABLE,
423 : : .p_entry_data = (void *)&eram_brocast_entry
424 : : };
425 : :
426 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO,
427 : 0 : g_dtb_data.queueid, 1, &entry_brocast);
428 [ # # ]: 0 : if (ret) {
429 : 0 : PMD_DRV_LOG(ERR, "write brocast table failed");
430 : 0 : return ret;
431 : : }
432 : :
433 : 0 : uc_table.uc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
434 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_uc_entry = {
435 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
436 : : .p_data = (uint32_t *)&uc_table
437 : : };
438 : 0 : ZXDH_DTB_USER_ENTRY_T entry_unicast = {
439 : : .sdt_no = ZXDH_SDT_UNICAST_ATT_TABLE,
440 : : .p_entry_data = (void *)&eram_uc_entry
441 : : };
442 : :
443 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO,
444 : 0 : g_dtb_data.queueid, 1, &entry_unicast);
445 [ # # ]: 0 : if (ret) {
446 : 0 : PMD_DRV_LOG(ERR, "write unicast table failed");
447 : 0 : return ret;
448 : : }
449 : :
450 : 0 : mc_table.mc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
451 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_mc_entry = {
452 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
453 : : .p_data = (uint32_t *)&mc_table
454 : : };
455 : 0 : ZXDH_DTB_USER_ENTRY_T entry_multicast = {
456 : : .sdt_no = ZXDH_SDT_MULTICAST_ATT_TABLE,
457 : : .p_entry_data = (void *)&eram_mc_entry
458 : : };
459 : :
460 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO, g_dtb_data.queueid,
461 : : 1, &entry_multicast);
462 [ # # ]: 0 : if (ret) {
463 : 0 : PMD_DRV_LOG(ERR, "write multicast table failed");
464 : 0 : return ret;
465 : : }
466 : : }
467 : :
468 : 0 : return ret;
469 : : }
470 : :
471 : : int
472 : 0 : zxdh_promisc_table_uninit(struct rte_eth_dev *dev)
473 : : {
474 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
475 : : uint32_t ret, vf_group_id = 0;
476 : 0 : struct zxdh_brocast_table brocast_table = {0};
477 : 0 : struct zxdh_unitcast_table uc_table = {0};
478 : 0 : struct zxdh_multicast_table mc_table = {0};
479 : :
480 [ # # ]: 0 : if (!hw->is_pf)
481 : : return 0;
482 : :
483 [ # # ]: 0 : for (; vf_group_id < 4; vf_group_id++) {
484 : 0 : brocast_table.flag = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
485 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_brocast_entry = {
486 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
487 : : .p_data = (uint32_t *)&brocast_table
488 : : };
489 : 0 : ZXDH_DTB_USER_ENTRY_T entry_brocast = {
490 : : .sdt_no = ZXDH_SDT_BROCAST_ATT_TABLE,
491 : : .p_entry_data = (void *)&eram_brocast_entry
492 : : };
493 : :
494 : 0 : ret = zxdh_np_dtb_table_entry_delete(ZXDH_DEVICE_NO,
495 : 0 : g_dtb_data.queueid, 1, &entry_brocast);
496 [ # # ]: 0 : if (ret) {
497 : 0 : PMD_DRV_LOG(ERR, "write brocast table failed");
498 : 0 : return ret;
499 : : }
500 : :
501 : 0 : uc_table.uc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
502 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_uc_entry = {
503 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
504 : : .p_data = (uint32_t *)&uc_table
505 : : };
506 : 0 : ZXDH_DTB_USER_ENTRY_T entry_unicast = {
507 : : .sdt_no = ZXDH_SDT_UNICAST_ATT_TABLE,
508 : : .p_entry_data = (void *)&eram_uc_entry
509 : : };
510 : :
511 : 0 : ret = zxdh_np_dtb_table_entry_delete(ZXDH_DEVICE_NO,
512 : 0 : g_dtb_data.queueid, 1, &entry_unicast);
513 [ # # ]: 0 : if (ret) {
514 : 0 : PMD_DRV_LOG(ERR, "write unicast table failed");
515 : 0 : return ret;
516 : : }
517 : :
518 : 0 : mc_table.mc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG);
519 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T eram_mc_entry = {
520 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vf_group_id,
521 : : .p_data = (uint32_t *)&mc_table
522 : : };
523 : 0 : ZXDH_DTB_USER_ENTRY_T entry_multicast = {
524 : : .sdt_no = ZXDH_SDT_MULTICAST_ATT_TABLE,
525 : : .p_entry_data = (void *)&eram_mc_entry
526 : : };
527 : :
528 : 0 : ret = zxdh_np_dtb_table_entry_delete(ZXDH_DEVICE_NO, g_dtb_data.queueid,
529 : : 1, &entry_multicast);
530 [ # # ]: 0 : if (ret) {
531 : 0 : PMD_DRV_LOG(ERR, "write multicast table failed");
532 : 0 : return ret;
533 : : }
534 : : }
535 : :
536 : 0 : return ret;
537 : : }
538 : :
539 : : int
540 : 0 : zxdh_dev_unicast_table_set(struct zxdh_hw *hw, uint16_t vport, bool enable)
541 : : {
542 : : int16_t ret = 0;
543 : 0 : struct zxdh_unitcast_table uc_table = {0};
544 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
545 : :
546 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T uc_table_entry = {
547 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vport_num.vfid / 64,
548 : : .p_data = (uint32_t *)&uc_table
549 : : };
550 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
551 : : .sdt_no = ZXDH_SDT_UNICAST_ATT_TABLE,
552 : : .p_entry_data = (void *)&uc_table_entry
553 : : };
554 : :
555 : 0 : ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO, g_dtb_data.queueid, &entry, 1);
556 [ # # ]: 0 : if (ret) {
557 : 0 : PMD_DRV_LOG(ERR, "unicast_table_get_failed:%d", hw->vfid);
558 : 0 : return -ret;
559 : : }
560 : :
561 [ # # ]: 0 : if (vport_num.vf_flag) {
562 [ # # ]: 0 : if (enable)
563 : 0 : uc_table.bitmap[(vport_num.vfid % 64) / 32] |=
564 : 0 : UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32);
565 : : else
566 : 0 : uc_table.bitmap[(vport_num.vfid % 64) / 32] &=
567 : 0 : ~(UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32));
568 : : } else {
569 [ # # ]: 0 : uc_table.uc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG + (enable << 6));
570 : : }
571 : :
572 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO, g_dtb_data.queueid, 1, &entry);
573 [ # # ]: 0 : if (ret) {
574 : 0 : PMD_DRV_LOG(ERR, "unicast_table_set_failed:%d", hw->vfid);
575 : 0 : return -ret;
576 : : }
577 : : return 0;
578 : : }
579 : :
580 : : int
581 : 0 : zxdh_dev_multicast_table_set(struct zxdh_hw *hw, uint16_t vport, bool enable)
582 : : {
583 : : int16_t ret = 0;
584 : 0 : struct zxdh_multicast_table mc_table = {0};
585 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
586 : :
587 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T mc_table_entry = {
588 : 0 : .index = ((hw->vfid - ZXDH_BASE_VFID) << 2) + vport_num.vfid / 64,
589 : : .p_data = (uint32_t *)&mc_table
590 : : };
591 : 0 : ZXDH_DTB_USER_ENTRY_T entry = {
592 : : .sdt_no = ZXDH_SDT_MULTICAST_ATT_TABLE,
593 : : .p_entry_data = (void *)&mc_table_entry
594 : : };
595 : :
596 : 0 : ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO, g_dtb_data.queueid, &entry, 1);
597 [ # # ]: 0 : if (ret) {
598 : 0 : PMD_DRV_LOG(ERR, "allmulti_table_get_failed:%d", hw->vfid);
599 : 0 : return -ret;
600 : : }
601 : :
602 [ # # ]: 0 : if (vport_num.vf_flag) {
603 [ # # ]: 0 : if (enable)
604 : 0 : mc_table.bitmap[(vport_num.vfid % 64) / 32] |=
605 : 0 : UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32);
606 : : else
607 : 0 : mc_table.bitmap[(vport_num.vfid % 64) / 32] &=
608 : 0 : ~(UINT32_C(1) << (31 - (vport_num.vfid % 64) % 32));
609 : :
610 : : } else {
611 [ # # ]: 0 : mc_table.mc_flood_pf_enable = rte_be_to_cpu_32(ZXDH_TABLE_HIT_FLAG + (enable << 6));
612 : : }
613 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO, g_dtb_data.queueid, 1, &entry);
614 [ # # ]: 0 : if (ret) {
615 : 0 : PMD_DRV_LOG(ERR, "allmulti_table_set_failed:%d", hw->vfid);
616 : 0 : return -ret;
617 : : }
618 : : return 0;
619 : : }
620 : :
621 : : int
622 : 0 : zxdh_vlan_filter_table_init(struct rte_eth_dev *dev)
623 : : {
624 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
625 : 0 : struct zxdh_vlan_filter_table vlan_table = {0};
626 : : int16_t ret = 0;
627 : :
628 [ # # ]: 0 : if (!hw->is_pf)
629 : : return 0;
630 : :
631 [ # # ]: 0 : for (uint8_t vlan_group = 0; vlan_group < ZXDH_VLAN_GROUP_NUM; vlan_group++) {
632 [ # # ]: 0 : if (vlan_group == 0) {
633 : 0 : vlan_table.vlans[0] |= (1 << ZXDH_FIRST_VLAN_GROUP_BITS);
634 : 0 : vlan_table.vlans[0] |= (1 << ZXDH_VLAN_GROUP_BITS);
635 : :
636 : : } else {
637 : 0 : vlan_table.vlans[0] = 0;
638 : : }
639 : 0 : uint32_t index = (vlan_group << 11) | hw->vport.vfid;
640 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry_data = {
641 : : .index = index,
642 : : .p_data = (uint32_t *)&vlan_table
643 : : };
644 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry = {ZXDH_SDT_VLAN_ATT_TABLE, &entry_data};
645 : :
646 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO,
647 : 0 : g_dtb_data.queueid, 1, &user_entry);
648 [ # # ]: 0 : if (ret != 0) {
649 : 0 : PMD_DRV_LOG(ERR,
650 : : "[vfid:%d], vlan_group:%d, init vlan filter table failed",
651 : : hw->vport.vfid, vlan_group);
652 : : ret = -1;
653 : : }
654 : : }
655 : :
656 : 0 : return ret;
657 : : }
658 : :
659 : : int
660 [ # # ]: 0 : zxdh_vlan_filter_table_set(uint16_t vport, uint16_t vlan_id, uint8_t enable)
661 : : {
662 : : struct zxdh_vlan_filter_table vlan_table = {0};
663 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
664 : : int ret = 0;
665 : :
666 : : memset(&vlan_table, 0, sizeof(struct zxdh_vlan_filter_table));
667 : 0 : int table_num = vlan_id / ZXDH_VLAN_FILTER_VLANID_STEP;
668 : 0 : uint32_t index = (table_num << 11) | vport_num.vfid;
669 : 0 : uint16_t group = (vlan_id - table_num * ZXDH_VLAN_FILTER_VLANID_STEP) / 8 + 1;
670 : :
671 : : uint8_t val = sizeof(struct zxdh_vlan_filter_table) / sizeof(uint32_t);
672 : 0 : uint8_t vlan_tbl_index = group / val;
673 : 0 : uint16_t used_group = vlan_tbl_index * val;
674 : :
675 [ # # ]: 0 : used_group = (used_group == 0 ? 0 : (used_group - 1));
676 : :
677 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry_data = {index, (uint32_t *)&vlan_table};
678 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_get = {ZXDH_SDT_VLAN_ATT_TABLE, &entry_data};
679 : :
680 : 0 : ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO, g_dtb_data.queueid, &user_entry_get, 1);
681 [ # # ]: 0 : if (ret) {
682 : 0 : PMD_DRV_LOG(ERR, "get vlan table failed");
683 : 0 : return -1;
684 : : }
685 : 0 : uint16_t relative_vlan_id = vlan_id - table_num * ZXDH_VLAN_FILTER_VLANID_STEP;
686 : : uint32_t *base_group = &vlan_table.vlans[0];
687 : :
688 : 0 : *base_group |= 1 << 31;
689 : : base_group = &vlan_table.vlans[vlan_tbl_index];
690 [ # # ]: 0 : uint8_t valid_bits = (vlan_tbl_index == 0 ?
691 : : ZXDH_FIRST_VLAN_GROUP_BITS : ZXDH_VLAN_GROUP_BITS) + 1;
692 : :
693 : 0 : uint8_t shift_left = (valid_bits - (relative_vlan_id - used_group * 8) % valid_bits) - 1;
694 : :
695 [ # # ]: 0 : if (enable)
696 : 0 : *base_group |= 1 << shift_left;
697 : : else
698 : 0 : *base_group &= ~(1 << shift_left);
699 : :
700 : :
701 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_write = {
702 : : .sdt_no = ZXDH_SDT_VLAN_ATT_TABLE,
703 : : .p_entry_data = &entry_data
704 : : };
705 : :
706 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO,
707 : 0 : g_dtb_data.queueid, 1, &user_entry_write);
708 [ # # ]: 0 : if (ret != 0) {
709 : 0 : PMD_DRV_LOG(ERR, "write vlan table failed");
710 : 0 : return -1;
711 : : }
712 : : return 0;
713 : : }
714 : :
715 : : int
716 : 0 : zxdh_rss_table_set(uint16_t vport, struct zxdh_rss_reta *rss_reta)
717 : : {
718 : 0 : struct zxdh_rss_to_vqid_table rss_vqid = {0};
719 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
720 : : int ret = 0;
721 : :
722 [ # # ]: 0 : for (uint16_t i = 0; i < RTE_ETH_RSS_RETA_SIZE_256 / 8; i++) {
723 [ # # ]: 0 : for (uint16_t j = 0; j < 8; j++) {
724 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
725 [ # # ]: 0 : if (j % 2 == 0)
726 : 0 : rss_vqid.vqm_qid[j + 1] = rss_reta->reta[i * 8 + j];
727 : : else
728 : 0 : rss_vqid.vqm_qid[j - 1] = rss_reta->reta[i * 8 + j];
729 : : #else
730 : : rss_vqid.vqm_qid[j] = rss_init->reta[i * 8 + j];
731 : : #endif
732 : : }
733 : :
734 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
735 : 0 : rss_vqid.vqm_qid[1] |= 0x8000;
736 : : #else
737 : : rss_vqid.vqm_qid[0] |= 0x8000;
738 : : #endif
739 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {
740 : 0 : .index = vport_num.vfid * 32 + i,
741 : : .p_data = (uint32_t *)&rss_vqid
742 : : };
743 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry_write = {
744 : : .sdt_no = ZXDH_SDT_RSS_ATT_TABLE,
745 : : .p_entry_data = &entry
746 : : };
747 : 0 : ret = zxdh_np_dtb_table_entry_write(ZXDH_DEVICE_NO,
748 : 0 : g_dtb_data.queueid, 1, &user_entry_write);
749 [ # # ]: 0 : if (ret != 0) {
750 : 0 : PMD_DRV_LOG(ERR, "write rss base qid failed vfid:%d", vport_num.vfid);
751 : 0 : return ret;
752 : : }
753 : : }
754 : : return 0;
755 : : }
756 : :
757 : : int
758 : 0 : zxdh_rss_table_get(uint16_t vport, struct zxdh_rss_reta *rss_reta)
759 : : {
760 : 0 : struct zxdh_rss_to_vqid_table rss_vqid = {0};
761 : : union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
762 : : int ret = 0;
763 : :
764 [ # # ]: 0 : for (uint16_t i = 0; i < RTE_ETH_RSS_RETA_SIZE_256 / 8; i++) {
765 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vport_num.vfid * 32 + i, (uint32_t *)&rss_vqid};
766 : 0 : ZXDH_DTB_USER_ENTRY_T user_entry = {ZXDH_SDT_RSS_ATT_TABLE, &entry};
767 : :
768 : 0 : ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO,
769 : 0 : g_dtb_data.queueid, &user_entry, 1);
770 [ # # ]: 0 : if (ret != 0) {
771 : 0 : PMD_DRV_LOG(ERR, "get rss tbl failed, vfid:%d", vport_num.vfid);
772 : 0 : return -1;
773 : : }
774 : :
775 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
776 : 0 : rss_vqid.vqm_qid[1] &= 0x7FFF;
777 : : #else
778 : : rss_vqid.vqm_qid[0] &= 0x7FFF;
779 : : #endif
780 : : uint8_t size = sizeof(struct zxdh_rss_to_vqid_table) / sizeof(uint16_t);
781 : :
782 [ # # ]: 0 : for (int j = 0; j < size; j++) {
783 : : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
784 [ # # ]: 0 : if (j % 2 == 0)
785 : 0 : rss_reta->reta[i * 8 + j] = rss_vqid.vqm_qid[j + 1];
786 : : else
787 : 0 : rss_reta->reta[i * 8 + j] = rss_vqid.vqm_qid[j - 1];
788 : : #else
789 : : rss_reta->reta[i * 8 + j] = rss_vqid.vqm_qid[j];
790 : : #endif
791 : : }
792 : : }
793 : : return 0;
794 : : }
|
