Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2024 ZTE Corporation
3 : : */
4 : :
5 : : #include <stdlib.h>
6 : : #include <string.h>
7 : :
8 : : #include <rte_common.h>
9 : : #include <rte_log.h>
10 : : #include <rte_debug.h>
11 : : #include <rte_malloc.h>
12 : : #include <rte_memcpy.h>
13 : :
14 : : #include "zxdh_np.h"
15 : : #include "zxdh_logs.h"
16 : : #include "zxdh_msg.h"
17 : :
18 : : static ZXDH_DEV_MGR_T g_dev_mgr;
19 : : static ZXDH_SDT_MGR_T g_sdt_mgr;
20 : : static uint32_t g_table_type[ZXDH_DEV_CHANNEL_MAX][ZXDH_DEV_SDT_ID_MAX];
21 : : static ZXDH_PPU_CLS_BITMAP_T g_ppu_cls_bit_map[ZXDH_DEV_CHANNEL_MAX];
22 : : static ZXDH_DTB_MGR_T *p_dpp_dtb_mgr[ZXDH_DEV_CHANNEL_MAX];
23 : : static ZXDH_SDT_TBL_DATA_T g_sdt_info[ZXDH_DEV_CHANNEL_MAX][ZXDH_DEV_SDT_ID_MAX];
24 : : static ZXDH_PPU_STAT_CFG_T g_ppu_stat_cfg[ZXDH_DEV_CHANNEL_MAX];
25 : : static SE_APT_CALLBACK_T g_apt_se_callback[ZXDH_DEV_CHANNEL_MAX][ZXDH_DEV_SDT_ID_MAX];
26 : : static ZXDH_ACL_CFG_EX_T g_apt_acl_cfg[ZXDH_DEV_CHANNEL_MAX] = {0};
27 : : static ZXDH_ACL_CFG_EX_T *g_p_acl_ex_cfg[ZXDH_DEV_CHANNEL_MAX] = {NULL};
28 : : static uint64_t g_np_fw_compat_addr[ZXDH_DEV_CHANNEL_MAX];
29 : : static const ZXDH_VERSION_COMPATIBLE_REG_T g_np_sdk_version = {
30 : : ZXDH_NPSDK_COMPAT_ITEM_ID, 1, 0, 0, 0, {0} };
31 : : static const uint32_t hardware_ep_id[5] = {5, 6, 7, 8, 9};
32 : : static ZXDH_RB_CFG *g_dtb_dump_addr_rb[ZXDH_DEV_CHANNEL_MAX][ZXDH_DTB_QUEUE_NUM_MAX];
33 : : static const char * const g_dpp_dtb_name[] = {
34 : : "DOWN TAB",
35 : : "UP TAB",
36 : : };
37 : : static ZXDH_SE_CFG *g_apt_se_cfg[ZXDH_DEV_CHANNEL_MAX];
38 : : static ZXDH_SE_CFG *dpp_se_cfg[ZXDH_DEV_CHANNEL_MAX];
39 : : static const uint16_t g_lpm_crc[ZXDH_SE_ZBLK_NUM] = {
40 : : 0x1021, 0x8005, 0x3D65, 0xab47, 0x3453, 0x0357, 0x0589, 0xa02b,
41 : : 0x1021, 0x8005, 0x3D65, 0xab47, 0x3453, 0x0357, 0x0589, 0xa02b,
42 : : 0x1021, 0x8005, 0x3D65, 0xab47, 0x3453, 0x0357, 0x0589, 0xa02b,
43 : : 0x1021, 0x8005, 0x3D65, 0xab47, 0x3453, 0x0357, 0x0589, 0xa02b
44 : : };
45 : : static uint32_t g_hash_zblk_idx[ZXDH_DEV_CHANNEL_MAX]
46 : : [ZXDH_HASH_FUNC_ID_NUM]
47 : : [ZXDH_HASH_TBL_ID_NUM] = {0};
48 : : static const uint32_t g_ddr_hash_arg[ZXDH_HASH_DDR_CRC_NUM] = {
49 : : 0x04C11DB7,
50 : : 0xF4ACFB13,
51 : : 0x20044009,
52 : : 0x00210801
53 : : };
54 : :
55 : : static ZXDH_HASH_TBL_ID_INFO g_tbl_id_info[ZXDH_DEV_CHANNEL_MAX]
56 : : [ZXDH_HASH_FUNC_ID_NUM]
57 : : [ZXDH_HASH_TBL_ID_NUM];
58 : :
59 : : static const ZXDH_FIELD_T g_smmu0_smmu0_cpu_ind_cmd_reg[] = {
60 : : {"cpu_ind_rw", ZXDH_FIELD_FLAG_RW, 31, 1, 0x0, 0x0},
61 : : {"cpu_ind_rd_mode", ZXDH_FIELD_FLAG_RW, 30, 1, 0x0, 0x0},
62 : : {"cpu_req_mode", ZXDH_FIELD_FLAG_RW, 27, 2, 0x0, 0x0},
63 : : {"cpu_ind_addr", ZXDH_FIELD_FLAG_RW, 25, 26, 0x0, 0x0},
64 : : };
65 : :
66 : : static const ZXDH_FIELD_T g_smmu0_smmu0_cpu_ind_rd_done_reg[] = {
67 : : {"cpu_ind_rd_done", ZXDH_FIELD_FLAG_RO, 0, 1, 0x0, 0x0},
68 : : };
69 : :
70 : : static const ZXDH_FIELD_T g_smmu0_smmu0_cpu_ind_rdat0_reg[] = {
71 : : {"cpu_ind_rdat0", ZXDH_FIELD_FLAG_RO, 31, 32, 0x0, 0x0},
72 : : };
73 : :
74 : : static const ZXDH_FIELD_T g_smmu0_smmu0_cpu_ind_rdat1_reg[] = {
75 : : {"cpu_ind_rdat1", ZXDH_FIELD_FLAG_RO, 31, 32, 0x0, 0x0},
76 : : };
77 : :
78 : : static const ZXDH_FIELD_T g_smmu0_smmu0_cpu_ind_rdat2_reg[] = {
79 : : {"cpu_ind_rdat2", ZXDH_FIELD_FLAG_RO, 31, 32, 0x0, 0x0},
80 : : };
81 : :
82 : : static const ZXDH_FIELD_T g_smmu0_smmu0_cpu_ind_rdat3_reg[] = {
83 : : {"cpu_ind_rdat3", ZXDH_FIELD_FLAG_RO, 31, 32, 0x0, 0x0},
84 : : };
85 : :
86 : : static const ZXDH_FIELD_T g_smmu0_smmu0_wr_arb_cpu_rdy_reg[] = {
87 : : {"wr_arb_cpu_rdy", ZXDH_FIELD_FLAG_RO, 0, 1, 0x1, 0x0},
88 : : };
89 : :
90 : : static const ZXDH_FIELD_T g_dtb4k_dtb_enq_info_queue_buf_space_left_0_127_reg[] = {
91 : : {"info_queue_buf_space_left", ZXDH_FIELD_FLAG_RO, 5, 6, 0x20, 0x0},
92 : : };
93 : :
94 : : static const ZXDH_FIELD_T g_dtb4k_dtb_enq_cfg_epid_v_func_num_0_127_reg[] = {
95 : : {"dbi_en", ZXDH_FIELD_FLAG_RW, 31, 1, 0x0, 0x0},
96 : : {"queue_en", ZXDH_FIELD_FLAG_RW, 30, 1, 0x0, 0x0},
97 : : {"cfg_epid", ZXDH_FIELD_FLAG_RW, 27, 4, 0x0, 0x0},
98 : : {"cfg_vfunc_num", ZXDH_FIELD_FLAG_RW, 23, 8, 0x0, 0x0},
99 : : {"cfg_vector", ZXDH_FIELD_FLAG_RW, 14, 7, 0x0, 0x0},
100 : : {"cfg_func_num", ZXDH_FIELD_FLAG_RW, 7, 3, 0x0, 0x0},
101 : : {"cfg_vfunc_active", ZXDH_FIELD_FLAG_RW, 0, 1, 0x0, 0x0},
102 : : };
103 : :
104 : : static const ZXDH_DTB_FIELD_T g_dtb_ddr_table_cmd_info[] = {
105 : : {"valid", 127, 1},
106 : : {"type_mode", 126, 3},
107 : : {"rw_len", 123, 2},
108 : : {"v46_flag", 121, 1},
109 : : {"lpm_wr_vld", 120, 1},
110 : : {"baddr", 119, 20},
111 : : {"ecc_en", 99, 1},
112 : : {"rw_addr", 29, 30},
113 : : };
114 : :
115 : : static const ZXDH_DTB_FIELD_T g_dtb_eram_table_cmd_1_info[] = {
116 : : {"valid", 127, 1},
117 : : {"type_mode", 126, 3},
118 : : {"data_mode", 123, 2},
119 : : {"cpu_wr", 121, 1},
120 : : {"cpu_rd", 120, 1},
121 : : {"cpu_rd_mode", 119, 1},
122 : : {"addr", 113, 26},
123 : : {"data_h", 0, 1},
124 : : };
125 : :
126 : : static const ZXDH_DTB_FIELD_T g_dtb_eram_table_cmd_64_info[] = {
127 : : {"valid", 127, 1},
128 : : {"type_mode", 126, 3},
129 : : {"data_mode", 123, 2},
130 : : {"cpu_wr", 121, 1},
131 : : {"cpu_rd", 120, 1},
132 : : {"cpu_rd_mode", 119, 1},
133 : : {"addr", 113, 26},
134 : : {"data_h", 63, 32},
135 : : {"data_l", 31, 32},
136 : : };
137 : :
138 : : static const ZXDH_DTB_FIELD_T g_dtb_eram_table_cmd_128_info[] = {
139 : : {"valid", 127, 1},
140 : : {"type_mode", 126, 3},
141 : : {"data_mode", 123, 2},
142 : : {"cpu_wr", 121, 1},
143 : : {"cpu_rd", 120, 1},
144 : : {"cpu_rd_mode", 119, 1},
145 : : {"addr", 113, 26},
146 : : };
147 : :
148 : : static const ZXDH_DTB_FIELD_T g_dtb_zcam_table_cmd_info[] = {
149 : : {"valid", 127, 1},
150 : : {"type_mode", 126, 3},
151 : : {"ram_reg_flag", 123, 1},
152 : : {"zgroup_id", 122, 2},
153 : : {"zblock_id", 120, 3},
154 : : {"zcell_id", 117, 2},
155 : : {"mask", 115, 4},
156 : : {"sram_addr", 111, 9},
157 : : };
158 : :
159 : : static const ZXDH_DTB_FIELD_T g_dtb_etcam_table_cmd_info[] = {
160 : : {"valid", 127, 1},
161 : : {"type_mode", 126, 3},
162 : : {"block_sel", 123, 3},
163 : : {"init_en", 120, 1},
164 : : {"row_or_col_msk", 119, 1},
165 : : {"vben", 118, 1},
166 : : {"reg_tcam_flag", 117, 1},
167 : : {"uload", 116, 8},
168 : : {"rd_wr", 108, 1},
169 : : {"wr_mode", 107, 8},
170 : : {"data_or_mask", 99, 1},
171 : : {"addr", 98, 9},
172 : : {"vbit", 89, 8},
173 : : };
174 : :
175 : : static const ZXDH_DTB_FIELD_T g_dtb_mc_hash_table_cmd_info[] = {
176 : : {"valid", 127, 1},
177 : : {"type_mode", 126, 3},
178 : : {"std_h", 63, 32},
179 : : {"std_l", 31, 32},
180 : : };
181 : :
182 : : static const ZXDH_DTB_TABLE_T g_dpp_dtb_table_info[] = {
183 : : {
184 : : "ddr",
185 : : ZXDH_DTB_TABLE_DDR,
186 : : 8,
187 : : g_dtb_ddr_table_cmd_info,
188 : : },
189 : : {
190 : : "eram 1 bit",
191 : : ZXDH_DTB_TABLE_ERAM_1,
192 : : 8,
193 : : g_dtb_eram_table_cmd_1_info,
194 : : },
195 : : {
196 : : "eram 64 bit",
197 : : ZXDH_DTB_TABLE_ERAM_64,
198 : : 9,
199 : : g_dtb_eram_table_cmd_64_info,
200 : : },
201 : : {
202 : : "eram 128 bit",
203 : : ZXDH_DTB_TABLE_ERAM_128,
204 : : 7,
205 : : g_dtb_eram_table_cmd_128_info,
206 : : },
207 : : {
208 : : "zcam",
209 : : ZXDH_DTB_TABLE_ZCAM,
210 : : 8,
211 : : g_dtb_zcam_table_cmd_info,
212 : : },
213 : : {
214 : : "etcam",
215 : : ZXDH_DTB_TABLE_ETCAM,
216 : : 13,
217 : : g_dtb_etcam_table_cmd_info,
218 : : },
219 : : {
220 : : "mc_hash",
221 : : ZXDH_DTB_TABLE_MC_HASH,
222 : : 4,
223 : : g_dtb_mc_hash_table_cmd_info
224 : : },
225 : : };
226 : :
227 : : static const ZXDH_DTB_FIELD_T g_dtb_eram_dump_cmd_info[] = {
228 : : {"valid", 127, 1},
229 : : {"up_type", 126, 2},
230 : : {"base_addr", 106, 19},
231 : : {"tb_depth", 83, 20},
232 : : {"tb_dst_addr_h", 63, 32},
233 : : {"tb_dst_addr_l", 31, 32},
234 : : };
235 : :
236 : : static const ZXDH_DTB_FIELD_T g_dtb_ddr_dump_cmd_info[] = {
237 : : {"valid", 127, 1},
238 : : {"up_type", 126, 2},
239 : : {"base_addr", 117, 30},
240 : : {"tb_depth", 83, 20},
241 : : {"tb_dst_addr_h", 63, 32},
242 : : {"tb_dst_addr_l", 31, 32},
243 : :
244 : : };
245 : :
246 : : static const ZXDH_DTB_FIELD_T g_dtb_zcam_dump_cmd_info[] = {
247 : : {"valid", 127, 1},
248 : : {"up_type", 126, 2},
249 : : {"zgroup_id", 124, 2},
250 : : {"zblock_id", 122, 3},
251 : : {"ram_reg_flag", 119, 1},
252 : : {"z_reg_cell_id", 118, 2},
253 : : {"sram_addr", 116, 9},
254 : : {"tb_depth", 97, 10},
255 : : {"tb_width", 65, 2},
256 : : {"tb_dst_addr_h", 63, 32},
257 : : {"tb_dst_addr_l", 31, 32},
258 : :
259 : : };
260 : :
261 : : static const ZXDH_DTB_FIELD_T g_dtb_etcam_dump_cmd_info[] = {
262 : : {"valid", 127, 1},
263 : : {"up_type", 126, 2},
264 : : {"block_sel", 124, 3},
265 : : {"addr", 121, 9},
266 : : {"rd_mode", 112, 8},
267 : : {"data_or_mask", 104, 1},
268 : : {"tb_depth", 91, 10},
269 : : {"tb_width", 81, 2},
270 : : {"tb_dst_addr_h", 63, 32},
271 : : {"tb_dst_addr_l", 31, 32},
272 : :
273 : : };
274 : :
275 : : static const ZXDH_DTB_TABLE_T g_dpp_dtb_dump_info[] = {
276 : : {
277 : : "eram",
278 : : ZXDH_DTB_DUMP_ERAM,
279 : : 6,
280 : : g_dtb_eram_dump_cmd_info,
281 : : },
282 : : {
283 : : "ddr",
284 : : ZXDH_DTB_DUMP_DDR,
285 : : 6,
286 : : g_dtb_ddr_dump_cmd_info,
287 : : },
288 : : {
289 : : "zcam",
290 : : ZXDH_DTB_DUMP_ZCAM,
291 : : 11,
292 : : g_dtb_zcam_dump_cmd_info,
293 : : },
294 : : {
295 : : "etcam",
296 : : ZXDH_DTB_DUMP_ETCAM,
297 : : 10,
298 : : g_dtb_etcam_dump_cmd_info,
299 : : },
300 : : };
301 : :
302 : : #define ZXDH_SDT_MGR_PTR_GET() (&g_sdt_mgr)
303 : : #define ZXDH_SDT_SOFT_TBL_GET(id) (g_sdt_mgr.sdt_tbl_array[ZXDH_DEV_SLOT_ID(id)])
304 : : #define ZXDH_DEV_INFO_GET(id) (g_dev_mgr.p_dev_array[ZXDH_DEV_SLOT_ID(id)])
305 : :
306 : : #define ZXDH_DTB_LEN(cmd_type, int_en, data_len) \
307 : : (((data_len) & 0x3ff) | \
308 : : ((int_en) << 29) | \
309 : : ((cmd_type) << 30))
310 : :
311 : : static inline uint32_t
312 : : zxdh_np_comm_mask_bit(uint32_t bitnum) {
313 : 0 : return (uint32_t)(0x1U << bitnum);
314 : : }
315 : :
316 : : static inline uint32_t
317 : : zxdh_np_comm_get_bit_mask(uint32_t bit_quantity) {
318 : 0 : if (bit_quantity < 32)
319 : 0 : return zxdh_np_comm_mask_bit(bit_quantity & 0x1F) - 1;
320 : : else
321 : : return 0xFFFFFFFF;
322 : : }
323 : :
324 : : #define ZXDH_COMM_UINT32_GET_BITS(_uidst_, _uisrc_, _uistartpos_, _uilen_)\
325 : : ((_uidst_) = (((_uisrc_) >> (_uistartpos_)) & \
326 : : (zxdh_np_comm_get_bit_mask((_uilen_)))))
327 : :
328 : : #define ZXDH_REG_DATA_MAX (128)
329 : :
330 : : #define ZXDH_COMM_CHECK_DEV_POINT(dev_id, point)\
331 : : do {\
332 : : if (NULL == (point)) {\
333 : : PMD_DRV_LOG(ERR, "dev: %u [POINT NULL]", (dev_id));\
334 : : RTE_ASSERT(0);\
335 : : } \
336 : : } while (0)
337 : :
338 : : #define ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, becall)\
339 : : do {\
340 : : if ((rc) != 0) {\
341 : : PMD_DRV_LOG(ERR, "dev: %u, %s failed!", (dev_id), becall);\
342 : : RTE_ASSERT(0);\
343 : : } \
344 : : } while (0)
345 : :
346 : : #define ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, becall)\
347 : : do {\
348 : : if ((rc) != 0) {\
349 : : PMD_DRV_LOG(ERR, "%s failed!", becall);\
350 : : } \
351 : : } while (0)
352 : :
353 : : #define ZXDH_COMM_CHECK_RC(rc, becall)\
354 : : do {\
355 : : if ((rc) != 0) {\
356 : : PMD_DRV_LOG(ERR, "%s failed!", becall);\
357 : : RTE_ASSERT(0);\
358 : : } \
359 : : } while (0)
360 : :
361 : : #define ZXDH_COMM_CHECK_POINT(point)\
362 : : do {\
363 : : if ((point) == NULL) {\
364 : : PMD_DRV_LOG(ERR, "[POINT NULL]");\
365 : : RTE_ASSERT(0);\
366 : : } \
367 : : } while (0)
368 : :
369 : : static inline uint16_t zxdh_np_comm_convert16(uint16_t w_data)
370 : : {
371 : 0 : return ((w_data) & 0xff) << 8 | ((w_data) & 0xff00) >> 8;
372 : : }
373 : :
374 : : static inline uint32_t
375 : : zxdh_np_comm_convert32(uint32_t dw_data)
376 : : {
377 : 0 : return ((dw_data) & 0xff) << 24 | ((dw_data) & 0xff00) << 8 |
378 : 0 : ((dw_data) & 0xff0000) >> 8 | ((dw_data) & 0xff000000) >> 24;
379 : : }
380 : :
381 : : #define ZXDH_COMM_CONVERT16(w_data) \
382 : : zxdh_np_comm_convert16(w_data)
383 : :
384 : : #define ZXDH_COMM_CONVERT32(w_data) \
385 : : zxdh_np_comm_convert32(w_data)
386 : :
387 : : #define ZXDH_DTB_TAB_UP_WR_INDEX_GET(DEV_ID, QUEUE_ID) \
388 : : (p_dpp_dtb_mgr[(ZXDH_DEV_SLOT_ID(DEV_ID))]->queue_info[(QUEUE_ID)].tab_up.wr_index)
389 : :
390 : : #define ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(DEV_ID, QUEUE_ID, INDEX) \
391 : : (p_dpp_dtb_mgr[(ZXDH_DEV_SLOT_ID(DEV_ID))]-> \
392 : : queue_info[(QUEUE_ID)].tab_up.user_addr[(INDEX)].user_flag)
393 : :
394 : : #define ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
395 : : (p_dpp_dtb_mgr[(ZXDH_DEV_SLOT_ID(DEV_ID))]-> \
396 : : queue_info[(QUEUE_ID)].tab_up.user_addr[(INDEX)].phy_addr)
397 : :
398 : : #define ZXDH_DTB_TAB_UP_DATA_LEN_GET(DEV_ID, QUEUE_ID, INDEX) \
399 : : (p_dpp_dtb_mgr[(ZXDH_DEV_SLOT_ID(DEV_ID))]-> \
400 : : queue_info[(QUEUE_ID)].tab_up.data_len[(INDEX)])
401 : :
402 : : #define ZXDH_DTB_TAB_UP_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
403 : : (p_dpp_dtb_mgr[(ZXDH_DEV_SLOT_ID(DEV_ID))]-> \
404 : : queue_info[(QUEUE_ID)].tab_up.start_vir_addr + \
405 : : (INDEX) * p_dpp_dtb_mgr[(ZXDH_DEV_SLOT_ID(DEV_ID))]-> \
406 : : queue_info[(QUEUE_ID)].tab_up.item_size)
407 : :
408 : : #define ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
409 : : (p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(DEV_ID)]-> \
410 : : queue_info[QUEUE_ID].tab_down.start_vir_addr + \
411 : : (INDEX) * p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(DEV_ID)]-> \
412 : : queue_info[QUEUE_ID].tab_down.item_size)
413 : :
414 : : #define ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(DEV_ID, QUEUE_ID) \
415 : : (p_dpp_dtb_mgr[(ZXDH_DEV_SLOT_ID(DEV_ID))]-> \
416 : : queue_info[(QUEUE_ID)].tab_down.wr_index)
417 : :
418 : : #define ZXDH_DTB_QUEUE_INIT_FLAG_GET(DEV_ID, QUEUE_ID) \
419 : : (p_dpp_dtb_mgr[(ZXDH_DEV_SLOT_ID(DEV_ID))]-> \
420 : : queue_info[(QUEUE_ID)].init_flag)
421 : :
422 : : #define ZXDH_DTB_TAB_UP_USER_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
423 : : (p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(DEV_ID)]-> \
424 : : queue_info[QUEUE_ID].tab_up.user_addr[INDEX].vir_addr)
425 : :
426 : : #define ZXDH_DTB_TAB_UP_USER_ADDR_FLAG_SET(DEV_ID, QUEUE_ID, INDEX, VAL) \
427 : : (p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(DEV_ID)]-> \
428 : : queue_info[QUEUE_ID].tab_up.user_addr[INDEX].user_flag = VAL)
429 : :
430 : : static inline uint64_t
431 : : zxdh_np_dtb_tab_down_phy_addr_get(uint32_t DEV_ID, uint32_t QUEUE_ID,
432 : : uint32_t INDEX)
433 : : {
434 : 0 : return p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(DEV_ID)]->queue_info[QUEUE_ID].tab_down.start_phy_addr
435 : 0 : + INDEX * p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(DEV_ID)]->queue_info[QUEUE_ID].tab_down.item_size;
436 : : }
437 : :
438 : : #define ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
439 : : zxdh_np_dtb_tab_down_phy_addr_get(DEV_ID, QUEUE_ID, INDEX)
440 : :
441 : : static inline uint64_t
442 : : zxdh_np_dtb_tab_up_phy_addr_get(uint32_t DEV_ID, uint32_t QUEUE_ID,
443 : : uint32_t INDEX)
444 : : {
445 : 0 : return p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(DEV_ID)]->queue_info[QUEUE_ID].tab_up.start_phy_addr
446 : 0 : + INDEX * p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(DEV_ID)]->queue_info[QUEUE_ID].tab_up.item_size;
447 : : }
448 : :
449 : : #define ZXDH_DTB_TAB_UP_PHY_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
450 : : zxdh_np_dtb_tab_up_phy_addr_get(DEV_ID, QUEUE_ID, INDEX)
451 : :
452 : : static inline void
453 : : zxdh_np_init_d_node(ZXDH_D_NODE *ptr, void *pdata)
454 : : {
455 : 0 : ptr->data = pdata;
456 : 0 : ptr->prev = NULL;
457 : 0 : ptr->next = NULL;
458 : 0 : }
459 : :
460 : : static inline void
461 : : zxdh_np_init_rbt_tn(ZXDH_RB_TN *p_tn, void *p_newkey)
462 : : {
463 : 0 : p_tn->p_key = p_newkey;
464 : 0 : p_tn->color_lsv = 0;
465 : 0 : p_tn->p_left = NULL;
466 : 0 : p_tn->p_right = NULL;
467 : 0 : p_tn->p_parent = NULL;
468 : : zxdh_np_init_d_node(&p_tn->tn_ln, p_tn);
469 : : }
470 : :
471 : : static inline uint32_t
472 : : zxdh_np_get_tn_lsv(ZXDH_RB_TN *p_tn)
473 : : {
474 : 0 : return p_tn->color_lsv >> 2;
475 : : }
476 : :
477 : : static inline void
478 : : zxdh_np_set_tn_lsv(ZXDH_RB_TN *p_tn, uint32_t list_val)
479 : : {
480 : 0 : p_tn->color_lsv &= 0x3;
481 : 0 : p_tn->color_lsv |= (list_val << 2);
482 : : }
483 : :
484 : : static inline void
485 : : zxdh_np_set_tn_color(ZXDH_RB_TN *p_tn, uint32_t color)
486 : : {
487 : 0 : p_tn->color_lsv &= 0xfffffffc;
488 : 0 : p_tn->color_lsv |= (color & 0x3);
489 : 0 : }
490 : :
491 : : static inline uint32_t
492 : : zxdh_np_get_tn_color(ZXDH_RB_TN *p_tn)
493 : : {
494 [ # # # # ]: 0 : return ((p_tn == NULL) ? ZXDH_RBT_BLACK : (p_tn)->color_lsv & 0x3);
495 : : }
496 : :
497 : : #define ZXDH_SE_GET_ZBLK_CFG(p_se, zblk_idx) \
498 : : (&(((ZXDH_SE_CFG *)(p_se))->zblk_info[zblk_idx]))
499 : :
500 : : #define GET_ZBLK_IDX(zcell_idx) \
501 : : (((zcell_idx) & 0x7F) >> 2)
502 : :
503 : : #define GET_ZCELL_IDX(zcell_idx) \
504 : : ((zcell_idx) & 0x3)
505 : :
506 : : #define ZXDH_GET_FUN_INFO(p_se, fun_id) \
507 : : (&(((ZXDH_SE_CFG *)(p_se))->fun_info[fun_id]))
508 : :
509 : : #define GET_DDR_HASH_ARG(ddr_crc_sel) (g_ddr_hash_arg[ddr_crc_sel])
510 : :
511 : : #define ZXDH_SDT_GET_LOW_DATA(source_value, low_width) \
512 : : ((source_value) & ((1 << (low_width)) - 1))
513 : :
514 : : #define ZXDH_ACL_AS_RSLT_SIZE_GET_EX(mode) (2U << (mode))
515 : :
516 : : #define ZXDH_GET_ACTU_KEY_BY_SIZE(actu_key_size) \
517 : : ((actu_key_size) * ZXDH_HASH_ACTU_KEY_STEP)
518 : :
519 : : #define ZXDH_GET_KEY_SIZE(actu_key_size) \
520 : : (ZXDH_GET_ACTU_KEY_BY_SIZE(actu_key_size) + ZXDH_HASH_KEY_CTR_SIZE)
521 : :
522 : : #define ZXDH_ACL_ENTRY_MAX_GET(key_mode, block_num) \
523 : : ((block_num) * ZXDH_ETCAM_RAM_DEPTH * (1U << (key_mode)))
524 : :
525 : : #define ZXDH_ETCAM_ENTRY_SIZE_GET(entry_mode) \
526 : : ((ZXDH_ETCAM_RAM_WIDTH << (3 - (entry_mode))) / 8)
527 : :
528 : : #define ZXDH_ACL_KEYSIZE_GET(key_mode) (2 * ZXDH_ETCAM_ENTRY_SIZE_GET(key_mode))
529 : :
530 : : #define GET_HASH_TBL_ID_INFO(dev_id, fun_id, tbl_id) \
531 : : (&g_tbl_id_info[ZXDH_DEV_SLOT_ID(dev_id)][fun_id][tbl_id])
532 : :
533 : : #define ZXDH_GET_HASH_TBL_ID(p_key) ((p_key)[0] & 0x1F)
534 : :
535 : : static inline uint32_t
536 : : zxdh_np_get_hash_entry_size(uint32_t key_type)
537 : : {
538 : : return ((key_type == ZXDH_HASH_KEY_128b) ? 16U : ((key_type == ZXDH_HASH_KEY_256b) ? 32U :
539 : : ((key_type == ZXDH_HASH_KEY_512b) ? 64U : 0)));
540 : : }
541 : :
542 : : #define ZXDH_GET_HASH_ENTRY_SIZE(key_type) \
543 : : zxdh_np_get_hash_entry_size(key_type)
544 : :
545 : : static inline void
546 : : zxdh_np_comm_uint32_write_bits(uint32_t *dst, uint32_t src,
547 : : uint32_t start_pos, uint32_t len)
548 : : {
549 : : uint32_t mask = zxdh_np_comm_get_bit_mask(len);
550 : 0 : *dst = (*dst & ~(mask << start_pos)) | ((src & mask) << start_pos);
551 : 0 : }
552 : :
553 : : #define ZXDH_COMM_UINT32_WRITE_BITS(dst, src, start_pos, len)\
554 : : zxdh_np_comm_uint32_write_bits(&(dst), src, start_pos, len)
555 : :
556 : : static inline uint32_t
557 : : zxdh_np_zblk_addr_conv(uint32_t zblk_idx)
558 : : {
559 : : uint32_t group_size = 1 << ZXDH_ZBLK_IDX_BT_WIDTH;
560 : : uint32_t group_number = zblk_idx / ZXDH_ZBLK_NUM_PER_ZGRP;
561 : : uint32_t offset_in_group = zblk_idx % ZXDH_ZBLK_NUM_PER_ZGRP;
562 : :
563 : : return group_number * group_size + offset_in_group;
564 : : }
565 : :
566 : : static inline uint32_t
567 : : zxdh_np_zcell_addr_conv(uint32_t zcell_idx)
568 : : {
569 : : uint32_t blk_grp_idx = (zcell_idx >> ZXDH_ZCELL_IDX_BT_WIDTH) &
570 : : ((1 << (ZXDH_ZBLK_IDX_BT_WIDTH + ZXDH_ZGRP_IDX_BT_WIDTH)) - 1);
571 : :
572 : : uint32_t cell_idx = zcell_idx & ((1 << ZXDH_ZCELL_IDX_BT_WIDTH) - 1);
573 : :
574 : 0 : return (zxdh_np_zblk_addr_conv(blk_grp_idx) << ZXDH_ZCELL_IDX_BT_WIDTH) | cell_idx;
575 : : }
576 : :
577 : : #define ZXDH_ZBLK_REG_ADDR_CALC(zblk_idx, offset) \
578 : : ((0xF << ZXDH_ZBLK_WRT_MASK_BT_START) | \
579 : : (0x1 << ZXDH_REG_SRAM_FLAG_BT_START) | \
580 : : ((zxdh_np_zblk_addr_conv(zblk_idx) & 0x1F) << ZXDH_ZBLK_IDX_BT_START) | \
581 : : ((offset) & 0x1FF))
582 : :
583 : : #define ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx, reg_idx) \
584 : : (ZXDH_ZBLK_REG_ADDR_CALC((zblk_idx), (0xD + (reg_idx))))
585 : :
586 : : #define ZXDH_ZCELL_BASE_ADDR_CALC(zcell_idx) \
587 : : ((0xF << ZXDH_ZBLK_WRT_MASK_BT_START) | (((zxdh_np_zcell_addr_conv(zcell_idx)) & \
588 : : ((1 << (ZXDH_ZCELL_IDX_BT_WIDTH + ZXDH_ZBLK_IDX_BT_WIDTH + ZXDH_ZGRP_IDX_BT_WIDTH)) - 1)) \
589 : : << ZXDH_ZCELL_ADDR_BT_WIDTH))
590 : : #define ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_idx, item_idx) \
591 : : ((ZXDH_ZCELL_BASE_ADDR_CALC(zcell_idx)) | ((item_idx) & (ZXDH_SE_RAM_DEPTH - 1)))
592 : :
593 : : static inline uint32_t
594 : : zxdh_np_get_rst_size(uint32_t key_type, uint32_t actu_key_size)
595 : : {
596 : : return ((ZXDH_GET_HASH_ENTRY_SIZE(key_type) != 0) ?
597 : 0 : (ZXDH_GET_HASH_ENTRY_SIZE(key_type) - ZXDH_GET_ACTU_KEY_BY_SIZE(actu_key_size) -
598 [ # # # # ]: 0 : ZXDH_HASH_KEY_CTR_SIZE) : 0xFF);
599 : : }
600 : :
601 : : #define ZXDH_GET_RST_SIZE(key_type, actu_key_size) \
602 : : zxdh_np_get_rst_size(key_type, actu_key_size)
603 : :
604 : : #define ZXDH_GET_HASH_KEY_TYPE(p_key) (((p_key)[0] >> 5) & 0x3)
605 : :
606 : : #define ZXDH_GET_HASH_KEY_VALID(p_key) (((p_key)[0] >> 7) & 0x1)
607 : :
608 : : #define ZXDH_GET_HASH_KEY_CTRL(valid, type, tbl_id) \
609 : : ((((valid) & 0x1) << 7) | (((type) & 0x3) << 5) | ((tbl_id) & 0x1f))
610 : :
611 : : static inline uint32_t
612 : : zxdh_np_get_hash_entry_mask(uint32_t entry_size, uint32_t entry_pos)
613 : : {
614 : 0 : return (((1U << (entry_size / 16U)) - 1U) << (4U - entry_size / 16U - entry_pos)) & 0xF;
615 : : }
616 : :
617 : : #define ZXDH_GET_HASH_ENTRY_MASK(entry_size, entry_pos) \
618 : : zxdh_np_get_hash_entry_mask(entry_size, entry_pos)
619 : :
620 : : #define GET_HASH_DDR_HW_ADDR(base_addr, item_idx) \
621 : : ((base_addr) + (item_idx))
622 : :
623 : : #define GET_ZCELL_CRC_VAL(zcell_id, crc16_val) \
624 : : (((crc16_val) >> (zcell_id)) & (ZXDH_SE_RAM_DEPTH - 1))
625 : :
626 : : #define ZXDH_COMM_DM_TO_X(d, m) ((d) & ~(m))
627 : : #define ZXDH_COMM_DM_TO_Y(d, m) (~(d) & ~(m))
628 : : #define ZXDH_COMM_XY_TO_MASK(x, y) (~(x) & ~(y))
629 : : #define ZXDH_COMM_XY_TO_DATA(x, y) (x)
630 : :
631 : : static ZXDH_FIELD_T g_stat_car0_cara_queue_ram0_159_0_reg[] = {
632 : : {"cara_drop", ZXDH_FIELD_FLAG_RW, 147, 1, 0x0, 0x0},
633 : : {"cara_plcr_en", ZXDH_FIELD_FLAG_RW, 146, 1, 0x0, 0x0},
634 : : {"cara_profile_id", ZXDH_FIELD_FLAG_RW, 145, 9, 0x0, 0x0},
635 : : {"cara_tq_h", ZXDH_FIELD_FLAG_RO, 136, 13, 0x0, 0x0},
636 : : {"cara_tq_l", ZXDH_FIELD_FLAG_RO, 123, 32, 0x0, 0x0},
637 : : {"cara_ted", ZXDH_FIELD_FLAG_RO, 91, 19, 0x0, 0x0},
638 : : {"cara_tcd", ZXDH_FIELD_FLAG_RO, 72, 19, 0x0, 0x0},
639 : : {"cara_tei", ZXDH_FIELD_FLAG_RO, 53, 27, 0x0, 0x0},
640 : : {"cara_tci", ZXDH_FIELD_FLAG_RO, 26, 27, 0x0, 0x0},
641 : : };
642 : :
643 : : static ZXDH_FIELD_T g_stat_car0_carb_queue_ram0_159_0_reg[] = {
644 : : {"carb_drop", ZXDH_FIELD_FLAG_RW, 147, 1, 0x0, 0x0},
645 : : {"carb_plcr_en", ZXDH_FIELD_FLAG_RW, 146, 1, 0x0, 0x0},
646 : : {"carb_profile_id", ZXDH_FIELD_FLAG_RW, 145, 9, 0x0, 0x0},
647 : : {"carb_tq_h", ZXDH_FIELD_FLAG_RO, 136, 13, 0x0, 0x0},
648 : : {"carb_tq_l", ZXDH_FIELD_FLAG_RO, 123, 32, 0x0, 0x0},
649 : : {"carb_ted", ZXDH_FIELD_FLAG_RO, 91, 19, 0x0, 0x0},
650 : : {"carb_tcd", ZXDH_FIELD_FLAG_RO, 72, 19, 0x0, 0x0},
651 : : {"carb_tei", ZXDH_FIELD_FLAG_RO, 53, 27, 0x0, 0x0},
652 : : {"carb_tci", ZXDH_FIELD_FLAG_RO, 26, 27, 0x0, 0x0},
653 : : };
654 : :
655 : : static ZXDH_FIELD_T g_stat_car0_carc_queue_ram0_159_0_reg[] = {
656 : : {"carc_drop", ZXDH_FIELD_FLAG_RW, 147, 1, 0x0, 0x0},
657 : : {"carc_plcr_en", ZXDH_FIELD_FLAG_RW, 146, 1, 0x0, 0x0},
658 : : {"carc_profile_id", ZXDH_FIELD_FLAG_RW, 145, 9, 0x0, 0x0},
659 : : {"carc_tq_h", ZXDH_FIELD_FLAG_RO, 136, 13, 0x0, 0x0},
660 : : {"carc_tq_l", ZXDH_FIELD_FLAG_RO, 123, 32, 0x0, 0x0},
661 : : {"carc_ted", ZXDH_FIELD_FLAG_RO, 91, 19, 0x0, 0x0},
662 : : {"carc_tcd", ZXDH_FIELD_FLAG_RO, 72, 19, 0x0, 0x0},
663 : : {"carc_tei", ZXDH_FIELD_FLAG_RO, 53, 27, 0x0, 0x0},
664 : : {"carc_tci", ZXDH_FIELD_FLAG_RO, 26, 27, 0x0, 0x0},
665 : : };
666 : :
667 : : static ZXDH_FIELD_T g_nppu_pktrx_cfg_pktrx_glbal_cfg_0_reg[] = {
668 : : {"pktrx_glbal_cfg_0", ZXDH_FIELD_FLAG_RW, 31, 32, 0x0, 0x0},
669 : : };
670 : :
671 : 0 : static uint32_t zxdh_dtb_info_print(uint32_t dev_id,
672 : : uint32_t queue_id,
673 : : uint32_t item_index,
674 : : ZXDH_DTB_QUEUE_ITEM_INFO_T *item_info)
675 : : {
676 : : uint64_t element_start_addr = 0;
677 : : uint64_t ack_start_addr = 0;
678 : : uint64_t data_addr = 0;
679 : : uint32_t data = 0;
680 : : uint32_t i = 0;
681 : : uint32_t j = 0;
682 : :
683 [ # # ]: 0 : PMD_DRV_LOG(DEBUG, "queue: %u, element:%u, %s table info is:",
684 : : queue_id, item_index, (item_info->cmd_type) ? "up" : "down");
685 : 0 : PMD_DRV_LOG(DEBUG, "cmd_vld : %u", item_info->cmd_vld);
686 [ # # ]: 0 : PMD_DRV_LOG(DEBUG, "cmd_type : %s", (item_info->cmd_type) ? "up" : "down");
687 : 0 : PMD_DRV_LOG(DEBUG, "int_en : %u", item_info->int_en);
688 : 0 : PMD_DRV_LOG(DEBUG, "data_len : %u", item_info->data_len);
689 : 0 : PMD_DRV_LOG(DEBUG, "data_hddr : 0x%x", item_info->data_hddr);
690 : 0 : PMD_DRV_LOG(DEBUG, "data_laddr : 0x%x", item_info->data_laddr);
691 : :
692 [ # # ]: 0 : if (item_info->cmd_type == ZXDH_DTB_DIR_UP_TYPE) {
693 : 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
694 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE) {
695 : : ack_start_addr =
696 : : ZXDH_DTB_TAB_UP_USER_VIR_ADDR_GET(dev_id, queue_id, item_index);
697 : : }
698 : 0 : ack_start_addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, item_index);
699 : 0 : element_start_addr =
700 : : ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, item_index) + ZXDH_DTB_ITEM_ACK_SIZE;
701 : : } else {
702 : 0 : ack_start_addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, item_index);
703 : 0 : element_start_addr =
704 : : ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, item_index)
705 : : + ZXDH_DTB_ITEM_ACK_SIZE;
706 : : }
707 : 0 : PMD_DRV_LOG(DEBUG, "dtb data:");
708 : :
709 : 0 : PMD_DRV_LOG(DEBUG, "ack info:");
710 [ # # ]: 0 : for (j = 0; j < 4; j++) {
711 : 0 : data = ZXDH_COMM_CONVERT32(*((uint32_t *)(ack_start_addr + 4 * j)));
712 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", data);
713 : : }
714 : :
715 [ # # ]: 0 : for (i = 0; i < item_info->data_len; i++) {
716 : 0 : data_addr = element_start_addr + 16 * i;
717 : :
718 : 0 : PMD_DRV_LOG(DEBUG, "row_%u:", i);
719 : :
720 [ # # ]: 0 : for (j = 0; j < 4; j++) {
721 : 0 : data = ZXDH_COMM_CONVERT32(*((uint32_t *)(data_addr + 4 * j)));
722 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", data);
723 : : }
724 : : }
725 : :
726 : 0 : PMD_DRV_LOG(DEBUG, "zxdh dtb info print end.");
727 : 0 : return ZXDH_OK;
728 : : }
729 : :
730 : : static uint32_t
731 : : zxdh_np_comm_is_big_endian(void)
732 : : {
733 : : ZXDH_ENDIAN_U c_data;
734 : :
735 : : c_data.a = 1;
736 : :
737 : : if (c_data.b == 1)
738 : : return 0;
739 : : else
740 : : return 1;
741 : : }
742 : :
743 : : static void
744 : 0 : zxdh_np_comm_swap(uint8_t *p_uc_data, uint32_t dw_byte_len)
745 : : {
746 : : uint16_t *p_w_tmp = NULL;
747 : : uint32_t *p_dw_tmp = NULL;
748 : : uint32_t dw_byte_num;
749 : : uint8_t uc_byte_mode;
750 : : uint32_t uc_is_big_flag;
751 : : uint32_t i;
752 : :
753 : : p_dw_tmp = (uint32_t *)(p_uc_data);
754 : : uc_is_big_flag = zxdh_np_comm_is_big_endian();
755 : : if (uc_is_big_flag)
756 : : return;
757 : :
758 : 0 : dw_byte_num = dw_byte_len >> 2;
759 : 0 : uc_byte_mode = dw_byte_len % 4 & 0xff;
760 : :
761 [ # # # # : 0 : for (i = 0; i < dw_byte_num; i++) {
# # # # #
# # # # #
# # # # ]
762 : 0 : (*p_dw_tmp) = ZXDH_COMM_CONVERT32(*p_dw_tmp);
763 : 0 : p_dw_tmp++;
764 : : }
765 : :
766 [ # # ]: 0 : if (uc_byte_mode > 1) {
767 : : p_w_tmp = (uint16_t *)(p_dw_tmp);
768 : 0 : (*p_w_tmp) = ZXDH_COMM_CONVERT16(*p_w_tmp);
769 : : }
770 : : }
771 : :
772 : : static uint32_t
773 : 0 : zxdh_comm_double_link_init(uint32_t elmemtnum, ZXDH_D_HEAD *p_head)
774 : : {
775 : : uint32_t err_code = 0;
776 : :
777 [ # # ]: 0 : if (elmemtnum == 0) {
778 : : err_code = ZXDH_DOUBLE_LINK_INIT_ELEMENT_NUM_ERR;
779 : 0 : PMD_DRV_LOG(ERR, "Error:[0x%x] doule_link_init Element Num Err !",
780 : : err_code);
781 : 0 : return err_code;
782 : : }
783 : :
784 : 0 : p_head->maxnum = elmemtnum;
785 : 0 : p_head->used = 0;
786 : 0 : p_head->p_next = NULL;
787 : 0 : p_head->p_prev = NULL;
788 : :
789 : 0 : return ZXDH_OK;
790 : : }
791 : :
792 : : static uint32_t
793 : 0 : zxdh_np_comm_liststack_create(uint32_t element_num, ZXDH_LISTSTACK_MANAGER **p_list)
794 : : {
795 : : ZXDH_LISTSTACK_MANAGER *p_local_list = NULL;
796 : : uint32_t dw_list_size = 0;
797 : : uint32_t dw_manage_size = 0;
798 : : uint32_t dw_actual_element_num = 0;
799 : : uint32_t i = 0;
800 : :
801 [ # # ]: 0 : if (p_list == NULL) {
802 : 0 : PMD_DRV_LOG(ERR, " p_list is NULL!");
803 : 0 : return ZXDH_LIST_STACK_POINT_NULL;
804 : : }
805 [ # # ]: 0 : if (element_num <= 0) {
806 : 0 : *p_list = NULL;
807 : 0 : PMD_DRV_LOG(ERR, " FtmComm_ListStackCreat_dwElementNum <=0");
808 : 0 : return ZXDH_LIST_STACK_ELEMENT_NUM_ERR;
809 : : }
810 : :
811 [ # # ]: 0 : if (element_num > ZXDH_LISTSTACK_MAX_ELEMENT - 1)
812 : : dw_actual_element_num = ZXDH_LISTSTACK_MAX_ELEMENT;
813 : : else
814 : 0 : dw_actual_element_num = element_num + 1;
815 : :
816 : 0 : dw_list_size = (dw_actual_element_num * sizeof(ZXDH_COMM_FREELINK)) & 0xffffffff;
817 : 0 : dw_manage_size = ((sizeof(ZXDH_LISTSTACK_MANAGER) & 0xFFFFFFFFU) + dw_list_size) &
818 : : 0xffffffff;
819 : :
820 : 0 : p_local_list = rte_zmalloc(NULL, dw_manage_size, 0);
821 [ # # ]: 0 : if (p_local_list == NULL) {
822 : 0 : *p_list = NULL;
823 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
824 : 0 : return ZXDH_LIST_STACK_ALLOC_MEMORY_FAIL;
825 : : }
826 : :
827 : 0 : p_local_list->p_array = (ZXDH_COMM_FREELINK *)((uint8_t *)p_local_list +
828 : : sizeof(ZXDH_LISTSTACK_MANAGER));
829 : :
830 : 0 : p_local_list->capacity = dw_actual_element_num;
831 : 0 : p_local_list->free_num = dw_actual_element_num - 1;
832 : 0 : p_local_list->used_num = 0;
833 : :
834 [ # # ]: 0 : for (i = 1; i < (dw_actual_element_num - 1); i++) {
835 : 0 : p_local_list->p_array[i].index = i;
836 : 0 : p_local_list->p_array[i].next = i + 1;
837 : : }
838 : :
839 : 0 : p_local_list->p_array[0].index = 0;
840 : 0 : p_local_list->p_array[0].next = 0;
841 : :
842 : 0 : p_local_list->p_array[dw_actual_element_num - 1].index = dw_actual_element_num - 1;
843 : 0 : p_local_list->p_array[dw_actual_element_num - 1].next = 0xffffffff;
844 : :
845 : 0 : p_local_list->p_head = p_local_list->p_array[1].index;
846 : :
847 : 0 : *p_list = p_local_list;
848 : :
849 : 0 : return ZXDH_OK;
850 : : }
851 : :
852 : : static uint32_t
853 : 0 : zxdh_np_comm_liststack_alloc(ZXDH_LISTSTACK_MANAGER *p_list, uint32_t *p_index)
854 : : {
855 : : uint32_t dw_alloc_index = 0;
856 : : uint32_t dw_next_free = 0;
857 : :
858 [ # # ]: 0 : if (p_list == NULL) {
859 : 0 : *p_index = ZXDH_LISTSTACK_INVALID_INDEX;
860 : 0 : return ZXDH_LIST_STACK_POINT_NULL;
861 : : }
862 : :
863 [ # # ]: 0 : if (p_list->p_head == ZXDH_LISTSTACK_INVALID_INDEX) {
864 : 0 : *p_index = ZXDH_LISTSTACK_INVALID_INDEX;
865 : 0 : return ZXDH_LIST_STACK_ISEMPTY_ERR;
866 : : }
867 : :
868 : : dw_alloc_index = p_list->p_head;
869 : :
870 : 0 : dw_next_free = p_list->p_array[dw_alloc_index].next;
871 : 0 : p_list->p_array[dw_alloc_index].next = ZXDH_LISTSTACK_INVALID_INDEX;
872 : :
873 [ # # ]: 0 : if (dw_next_free != 0xffffffff)
874 : 0 : p_list->p_head = p_list->p_array[dw_next_free].index;
875 : : else
876 : 0 : p_list->p_head = ZXDH_LISTSTACK_INVALID_INDEX;
877 : :
878 : 0 : *p_index = dw_alloc_index - 1;
879 : :
880 : 0 : p_list->free_num--;
881 : 0 : p_list->used_num++;
882 : :
883 [ # # # # ]: 0 : if (p_list->free_num == 0 || (p_list->used_num == (p_list->capacity - 1)))
884 : 0 : p_list->p_head = ZXDH_LISTSTACK_INVALID_INDEX;
885 : :
886 : : return ZXDH_OK;
887 : : }
888 : :
889 : : static uint32_t
890 : 0 : zxdh_comm_liststack_free(ZXDH_LISTSTACK_MANAGER *p_list, uint32_t index)
891 : : {
892 : : uint32_t dw_free_index = 0;
893 : : uint32_t dw_prev_free = 0;
894 : : uint32_t dw_index = 0;
895 : :
896 : 0 : dw_index = index + 1;
897 : :
898 [ # # ]: 0 : if (p_list == NULL) {
899 : 0 : PMD_DRV_LOG(ERR, " p_list is null");
900 : 0 : return ZXDH_LIST_STACK_POINT_NULL;
901 : : }
902 : :
903 [ # # ]: 0 : if (dw_index >= p_list->capacity) {
904 : 0 : PMD_DRV_LOG(ERR, "dw_index is invalid");
905 : 0 : return ZXDH_LIST_STACK_FREE_INDEX_INVALID;
906 : : }
907 : :
908 [ # # ]: 0 : if (p_list->p_array[dw_index].next != ZXDH_LISTSTACK_INVALID_INDEX)
909 : : return ZXDH_OK;
910 : :
911 : : dw_free_index = dw_index;
912 : 0 : dw_prev_free = p_list->p_head;
913 : :
914 [ # # ]: 0 : if (dw_prev_free != 0)
915 : 0 : p_list->p_array[dw_free_index].next = p_list->p_array[dw_prev_free].index;
916 : : else
917 : 0 : p_list->p_array[dw_free_index].next = 0xffffffff;
918 : :
919 : 0 : p_list->p_head = p_list->p_array[dw_free_index].index;
920 : :
921 : 0 : p_list->free_num++;
922 : 0 : p_list->used_num--;
923 : :
924 : 0 : return ZXDH_OK;
925 : : }
926 : :
927 : : static uint32_t
928 : : zxdh_comm_double_link_insert_1st(ZXDH_D_NODE *p_newnode, ZXDH_D_HEAD *p_head)
929 : : {
930 : : RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
931 : : RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
932 : :
933 : 0 : p_newnode->next = p_head->p_next;
934 : 0 : p_newnode->prev = NULL;
935 : :
936 [ # # ]: 0 : if (p_head->p_next)
937 : 0 : p_head->p_next->prev = p_newnode;
938 : : else
939 : 0 : p_head->p_prev = p_newnode;
940 : :
941 : 0 : p_head->p_next = p_newnode;
942 : 0 : p_head->used++;
943 : :
944 : : return ZXDH_OK;
945 : : }
946 : :
947 : : static uint32_t
948 : : zxdh_comm_double_link_insert_aft(ZXDH_D_NODE *p_newnode,
949 : : ZXDH_D_NODE *p_oldnode,
950 : : ZXDH_D_HEAD *p_head)
951 : : {
952 : : RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
953 : : RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
954 : :
955 : 0 : p_newnode->next = p_oldnode->next;
956 : 0 : p_newnode->prev = p_oldnode;
957 : :
958 : 0 : if (p_oldnode->next)
959 : 0 : p_oldnode->next->prev = p_newnode;
960 : : else
961 : 0 : p_head->p_prev = p_newnode;
962 : :
963 : 0 : p_oldnode->next = p_newnode;
964 : 0 : p_head->used++;
965 : :
966 : : return ZXDH_OK;
967 : : }
968 : :
969 : : static uint32_t
970 : : zxdh_comm_double_link_insert_pre(ZXDH_D_NODE *p_newnode,
971 : : ZXDH_D_NODE *p_oldnode, ZXDH_D_HEAD *p_head)
972 : : {
973 : : RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
974 : : RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
975 : :
976 : 0 : p_newnode->next = p_oldnode;
977 : 0 : p_newnode->prev = p_oldnode->prev;
978 : :
979 [ # # ]: 0 : if (p_oldnode->prev)
980 : 0 : p_oldnode->prev->next = p_newnode;
981 : : else
982 : 0 : p_head->p_next = p_newnode;
983 : :
984 : 0 : p_oldnode->prev = p_newnode;
985 : 0 : p_head->used++;
986 : :
987 : : return ZXDH_OK;
988 : : }
989 : :
990 : : static uint32_t
991 : : zxdh_comm_double_link_insert_last(ZXDH_D_NODE *p_newnode, ZXDH_D_HEAD *p_head)
992 : : {
993 : : ZXDH_D_NODE *p_dnode = NULL;
994 : :
995 : : RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
996 : : RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
997 : :
998 : 0 : p_dnode = p_head->p_prev;
999 : :
1000 [ # # ]: 0 : if (!p_dnode) {
1001 : 0 : p_head->p_next = p_newnode;
1002 : 0 : p_head->p_prev = p_newnode;
1003 : 0 : p_newnode->next = NULL;
1004 : 0 : p_newnode->prev = NULL;
1005 : : } else {
1006 : 0 : p_newnode->prev = p_dnode;
1007 : 0 : p_newnode->next = NULL;
1008 : 0 : p_head->p_prev = p_newnode;
1009 : 0 : p_dnode->next = p_newnode;
1010 : : }
1011 : :
1012 : 0 : p_head->used++;
1013 : :
1014 : : return ZXDH_OK;
1015 : : }
1016 : :
1017 : : static uint32_t
1018 : : zxdh_comm_double_link_del(ZXDH_D_NODE *delnode, ZXDH_D_HEAD *p_head)
1019 : : {
1020 : : ZXDH_D_NODE *next = NULL;
1021 : : ZXDH_D_NODE *pre = NULL;
1022 : :
1023 : 0 : next = delnode->next;
1024 : 0 : pre = delnode->prev;
1025 : :
1026 [ # # ]: 0 : if (next)
1027 : 0 : next->prev = delnode->prev;
1028 : : else
1029 : 0 : p_head->p_prev = delnode->prev;
1030 : :
1031 [ # # # # : 0 : if (pre)
# # # # #
# ]
1032 : 0 : pre->next = delnode->next;
1033 : : else
1034 : 0 : p_head->p_next = delnode->next;
1035 : :
1036 : 0 : p_head->used--;
1037 : 0 : delnode->next = NULL;
1038 : 0 : delnode->prev = NULL;
1039 : : return ZXDH_OK;
1040 : : }
1041 : :
1042 : : static int32_t
1043 : 0 : zxdh_comm_double_link_default_cmp_fuc(ZXDH_D_NODE *p_data1,
1044 : : ZXDH_D_NODE *p_data2, __rte_unused void *p_data)
1045 : : {
1046 : 0 : uint32_t data1 = *(uint32_t *)p_data1->data;
1047 : 0 : uint32_t data2 = *(uint32_t *)p_data2->data;
1048 : :
1049 [ # # ]: 0 : if (data1 > data2)
1050 : : return 1;
1051 [ # # ]: 0 : else if (data1 == data2)
1052 : : return 0;
1053 : : else
1054 : 0 : return -1;
1055 : : }
1056 : :
1057 : : static uint32_t
1058 : 0 : zxdh_comm_double_link_insert_sort(ZXDH_D_NODE *p_newnode,
1059 : : ZXDH_D_HEAD *p_head, ZXDH_CMP_FUNC cmp_fuc, void *cmp_data)
1060 : : {
1061 : : ZXDH_D_NODE *pre_node = NULL;
1062 : :
1063 [ # # ]: 0 : if (cmp_fuc == NULL)
1064 : : cmp_fuc = zxdh_comm_double_link_default_cmp_fuc;
1065 : :
1066 [ # # ]: 0 : if (p_head->used == 0)
1067 : 0 : return zxdh_comm_double_link_insert_1st(p_newnode, p_head);
1068 : :
1069 : 0 : pre_node = p_head->p_next;
1070 : :
1071 [ # # ]: 0 : while (pre_node != NULL) {
1072 [ # # ]: 0 : if (cmp_fuc(p_newnode, pre_node, cmp_data) <= 0)
1073 : 0 : return zxdh_comm_double_link_insert_pre(p_newnode,
1074 : : pre_node, p_head);
1075 : : else
1076 : 0 : pre_node = pre_node->next;
1077 : : }
1078 : :
1079 : 0 : return zxdh_comm_double_link_insert_last(p_newnode, p_head);
1080 : : }
1081 : :
1082 : : static int32_t
1083 : 0 : zxdh_comm_rb_def_cmp(void *p_new, void *p_old, uint32_t key_size)
1084 : : {
1085 : 0 : return memcmp(p_new, p_old, key_size);
1086 : : }
1087 : :
1088 : : static void
1089 : : zxdh_comm_rb_switch_color(ZXDH_RB_TN *p_tn1, ZXDH_RB_TN *p_tn2)
1090 : : {
1091 : : uint32_t color1, color2;
1092 : :
1093 : : color1 = zxdh_np_get_tn_color(p_tn1);
1094 : : color2 = zxdh_np_get_tn_color(p_tn2);
1095 : :
1096 : : zxdh_np_set_tn_color(p_tn1, color2);
1097 : : zxdh_np_set_tn_color(p_tn2, color1);
1098 : 0 : }
1099 : :
1100 : : static ZXDH_RB_TN *
1101 : : zxdh_comm_rb_get_brotn(ZXDH_RB_TN *p_cur_tn)
1102 : : {
1103 [ # # # # ]: 0 : return (p_cur_tn->p_parent->p_left == p_cur_tn) ? p_cur_tn->p_parent->p_right :
1104 : : p_cur_tn->p_parent->p_left;
1105 : : }
1106 : :
1107 : : static uint32_t
1108 : 0 : zxdh_comm_rb_handle_ins(__rte_unused ZXDH_RB_CFG *p_rb_cfg,
1109 : : ZXDH_RB_TN ***stack_tn,
1110 : : uint32_t stack_top)
1111 : : {
1112 : : ZXDH_RB_TN **pp_cur_tn = NULL;
1113 : : ZXDH_RB_TN *p_cur_tn = NULL;
1114 : : ZXDH_RB_TN **pp_tmp_tn = NULL;
1115 : : ZXDH_RB_TN *p_tmp_tn = NULL;
1116 : :
1117 [ # # ]: 0 : while (stack_top > 0) {
1118 : 0 : pp_cur_tn = stack_tn[stack_top];
1119 : 0 : p_cur_tn = *pp_cur_tn;
1120 : :
1121 [ # # ]: 0 : if (!p_cur_tn->p_parent) {
1122 : : zxdh_np_set_tn_color(p_cur_tn, ZXDH_RBT_BLACK);
1123 : : break;
1124 [ # # ]: 0 : } else if (zxdh_np_get_tn_color(p_cur_tn->p_parent) == ZXDH_RBT_RED) {
1125 : : ZXDH_RB_TN *p_unc_tn = zxdh_comm_rb_get_brotn(p_cur_tn->p_parent);
1126 : :
1127 : : RTE_ASSERT(p_cur_tn->p_parent == *stack_tn[stack_top - 1]);
1128 : :
1129 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn) == ZXDH_RBT_RED) {
1130 : : RTE_ASSERT(p_unc_tn);
1131 : : zxdh_np_set_tn_color(p_cur_tn->p_parent, ZXDH_RBT_BLACK);
1132 : : zxdh_np_set_tn_color(p_unc_tn, ZXDH_RBT_BLACK);
1133 : :
1134 : : RTE_ASSERT(p_cur_tn->p_parent->p_parent ==
1135 : : *stack_tn[stack_top - 2]);
1136 : :
1137 : : zxdh_np_set_tn_color(p_cur_tn->p_parent->p_parent, ZXDH_RBT_RED);
1138 : 0 : stack_top -= 2;
1139 : : } else {
1140 : : ZXDH_RB_TN *p_bro_tn = NULL;
1141 : :
1142 : 0 : pp_tmp_tn = stack_tn[stack_top - 2];
1143 : 0 : p_tmp_tn = *pp_tmp_tn;
1144 : :
1145 [ # # ]: 0 : if (p_cur_tn->p_parent == p_tmp_tn->p_left && p_cur_tn ==
1146 [ # # ]: 0 : p_cur_tn->p_parent->p_left) {
1147 [ # # ]: 0 : *pp_tmp_tn = p_cur_tn->p_parent;
1148 : :
1149 : : p_bro_tn = zxdh_comm_rb_get_brotn(p_cur_tn);
1150 : 0 : p_cur_tn->p_parent->p_parent = p_tmp_tn->p_parent;
1151 : :
1152 : 0 : p_tmp_tn->p_left = p_bro_tn;
1153 : 0 : p_tmp_tn->p_parent = p_cur_tn->p_parent;
1154 : 0 : p_cur_tn->p_parent->p_right = p_tmp_tn;
1155 : :
1156 [ # # ]: 0 : if (p_bro_tn)
1157 : 0 : p_bro_tn->p_parent = p_tmp_tn;
1158 : :
1159 [ # # ]: 0 : zxdh_comm_rb_switch_color(*pp_tmp_tn, p_tmp_tn);
1160 [ # # ]: 0 : } else if (p_cur_tn->p_parent == p_tmp_tn->p_left && p_cur_tn ==
1161 [ # # ]: 0 : p_cur_tn->p_parent->p_right) {
1162 : 0 : *pp_tmp_tn = p_cur_tn;
1163 : :
1164 : 0 : p_cur_tn->p_parent->p_right = p_cur_tn->p_left;
1165 : :
1166 [ # # ]: 0 : if (p_cur_tn->p_left)
1167 : 0 : p_cur_tn->p_left->p_parent = p_cur_tn->p_parent;
1168 : :
1169 : 0 : p_cur_tn->p_parent->p_parent = p_cur_tn;
1170 : 0 : p_tmp_tn->p_left = p_cur_tn->p_right;
1171 : :
1172 [ # # ]: 0 : if (p_cur_tn->p_right)
1173 : 0 : p_cur_tn->p_right->p_parent = p_tmp_tn;
1174 : :
1175 : 0 : p_cur_tn->p_left = p_cur_tn->p_parent;
1176 : 0 : p_cur_tn->p_right = p_tmp_tn;
1177 : :
1178 : 0 : p_cur_tn->p_parent = p_tmp_tn->p_parent;
1179 : 0 : p_tmp_tn->p_parent = p_cur_tn;
1180 : :
1181 [ # # ]: 0 : zxdh_comm_rb_switch_color(*pp_tmp_tn, p_tmp_tn);
1182 [ # # ]: 0 : } else if (p_cur_tn->p_parent == p_tmp_tn->p_right && p_cur_tn ==
1183 [ # # ]: 0 : p_cur_tn->p_parent->p_right) {
1184 [ # # ]: 0 : *pp_tmp_tn = p_cur_tn->p_parent;
1185 : : p_bro_tn = zxdh_comm_rb_get_brotn(p_cur_tn);
1186 : :
1187 : 0 : p_cur_tn->p_parent->p_parent = p_tmp_tn->p_parent;
1188 : :
1189 : 0 : p_tmp_tn->p_right = p_cur_tn->p_parent->p_left;
1190 : 0 : p_tmp_tn->p_parent = p_cur_tn->p_parent;
1191 : 0 : p_cur_tn->p_parent->p_left = p_tmp_tn;
1192 : :
1193 [ # # ]: 0 : if (p_bro_tn)
1194 : 0 : p_bro_tn->p_parent = p_tmp_tn;
1195 : :
1196 [ # # ]: 0 : zxdh_comm_rb_switch_color(*pp_tmp_tn, p_tmp_tn);
1197 : : } else {
1198 : 0 : *pp_tmp_tn = p_cur_tn;
1199 : 0 : p_cur_tn->p_parent->p_left = p_cur_tn->p_right;
1200 : :
1201 [ # # ]: 0 : if (p_cur_tn->p_right)
1202 : 0 : p_cur_tn->p_right->p_parent = p_cur_tn->p_parent;
1203 : :
1204 : 0 : p_cur_tn->p_parent->p_parent = p_cur_tn;
1205 : 0 : p_tmp_tn->p_right = p_cur_tn->p_left;
1206 : :
1207 [ # # ]: 0 : if (p_cur_tn->p_left)
1208 : 0 : p_cur_tn->p_left->p_parent = p_tmp_tn;
1209 : :
1210 : 0 : p_cur_tn->p_right = p_cur_tn->p_parent;
1211 : 0 : p_cur_tn->p_left = p_tmp_tn;
1212 : :
1213 : 0 : p_cur_tn->p_parent = p_tmp_tn->p_parent;
1214 : 0 : p_tmp_tn->p_parent = p_cur_tn;
1215 : :
1216 [ # # ]: 0 : zxdh_comm_rb_switch_color(*pp_tmp_tn, p_tmp_tn);
1217 : : }
1218 : : break;
1219 : : }
1220 : : } else {
1221 : : break;
1222 : : }
1223 : : }
1224 : :
1225 : 0 : return ZXDH_OK;
1226 : : }
1227 : :
1228 : : static uint32_t
1229 : 0 : zxdh_comm_rb_init(ZXDH_RB_CFG *p_rb_cfg,
1230 : : uint32_t total_num,
1231 : : uint32_t key_size,
1232 : : ZXDH_RB_CMPFUN cmpfun)
1233 : : {
1234 : : uint32_t rtn = ZXDH_OK;
1235 : : uint32_t malloc_size = 0;
1236 : :
1237 [ # # ]: 0 : if (p_rb_cfg->is_init) {
1238 : 0 : PMD_DRV_LOG(ERR, " p_rb_cfg already init!");
1239 : 0 : return ZXDH_OK;
1240 : : }
1241 : :
1242 : 0 : p_rb_cfg->key_size = key_size;
1243 : 0 : p_rb_cfg->p_root = NULL;
1244 : :
1245 [ # # ]: 0 : if (cmpfun)
1246 : 0 : p_rb_cfg->p_cmpfun = cmpfun;
1247 : : else
1248 : 0 : p_rb_cfg->p_cmpfun = zxdh_comm_rb_def_cmp;
1249 : :
1250 [ # # ]: 0 : if (total_num) {
1251 : 0 : p_rb_cfg->is_dynamic = 0;
1252 : :
1253 : 0 : rtn = zxdh_comm_double_link_init(total_num, &p_rb_cfg->tn_list);
1254 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_init");
1255 : :
1256 : 0 : rtn = zxdh_np_comm_liststack_create(total_num, &p_rb_cfg->p_lsm);
1257 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_np_comm_liststack_create");
1258 : :
1259 : 0 : p_rb_cfg->p_keybase = rte_zmalloc(NULL,
1260 : 0 : total_num * p_rb_cfg->key_size, 0);
1261 [ # # ]: 0 : if (p_rb_cfg->p_keybase == NULL) {
1262 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
1263 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1264 : : }
1265 : :
1266 : 0 : malloc_size = ((sizeof(ZXDH_RB_TN) & 0xFFFFFFFFU) * total_num) & UINT32_MAX;
1267 : :
1268 : 0 : p_rb_cfg->p_tnbase = rte_zmalloc(NULL, malloc_size, 0);
1269 [ # # ]: 0 : if (p_rb_cfg->p_tnbase == NULL) {
1270 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
1271 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1272 : : }
1273 : : } else {
1274 : 0 : p_rb_cfg->is_dynamic = 1;
1275 : :
1276 : : rtn = zxdh_comm_double_link_init(0xFFFFFFFF, &p_rb_cfg->tn_list);
1277 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_init");
1278 : : }
1279 : 0 : p_rb_cfg->is_init = 1;
1280 : :
1281 : 0 : return ZXDH_OK;
1282 : : }
1283 : :
1284 : : static uint32_t
1285 : 0 : zxdh_comm_rb_insert(ZXDH_RB_CFG *p_rb_cfg,
1286 : : void *p_key,
1287 : : void *out_val)
1288 : : {
1289 : : uint32_t rtn = 0;
1290 : : uint32_t stack_top = 1;
1291 : : int32_t cmprtn = 0;
1292 : 0 : uint32_t lsm_out = 0;
1293 : :
1294 : 0 : ZXDH_RB_TN **stack_tn[ZXDH_RBT_MAX_DEPTH] = {0};
1295 : : ZXDH_RB_TN *p_cur_tn = NULL;
1296 : : ZXDH_RB_TN *p_pre_tn = NULL;
1297 : : ZXDH_RB_TN **pp_cur_tn = NULL;
1298 : : void *p_cur_key = NULL;
1299 : : ZXDH_RB_TN *p_ins_tn = p_key;
1300 : :
1301 [ # # ]: 0 : p_cur_key = p_rb_cfg->is_dynamic ? ((ZXDH_RB_TN *)p_key)->p_key : p_key;
1302 : :
1303 : 0 : pp_cur_tn = &p_rb_cfg->p_root;
1304 : :
1305 : : for (;;) {
1306 : 0 : p_cur_tn = *pp_cur_tn;
1307 : :
1308 [ # # ]: 0 : if (!p_cur_tn) {
1309 [ # # ]: 0 : if (p_rb_cfg->is_dynamic == 0) {
1310 : 0 : rtn = zxdh_np_comm_liststack_alloc(p_rb_cfg->p_lsm, &lsm_out);
1311 : :
1312 [ # # ]: 0 : if (rtn == ZXDH_LIST_STACK_ISEMPTY_ERR)
1313 : : return ZXDH_RBT_RC_FULL;
1314 : :
1315 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_np_comm_liststack_alloc");
1316 : :
1317 : 0 : p_ins_tn = p_rb_cfg->p_tnbase + lsm_out;
1318 : :
1319 : 0 : zxdh_np_init_rbt_tn(p_ins_tn, p_rb_cfg->key_size * lsm_out +
1320 : 0 : p_rb_cfg->p_keybase);
1321 : :
1322 [ # # ]: 0 : memcpy(p_ins_tn->p_key, p_key, p_rb_cfg->key_size);
1323 : :
1324 : : zxdh_np_set_tn_lsv(p_ins_tn, lsm_out);
1325 : :
1326 [ # # ]: 0 : if (out_val)
1327 : 0 : *((uint32_t *)out_val) = lsm_out;
1328 : : } else {
1329 : : zxdh_np_init_d_node(&p_ins_tn->tn_ln, p_ins_tn);
1330 : : }
1331 : :
1332 : : zxdh_np_set_tn_color(p_ins_tn, ZXDH_RBT_RED);
1333 : :
1334 [ # # ]: 0 : if (cmprtn < 0) {
1335 [ # # ]: 0 : rtn = zxdh_comm_double_link_insert_pre(&p_ins_tn->tn_ln,
1336 : : &p_pre_tn->tn_ln, &p_rb_cfg->tn_list);
1337 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_insert_pre");
1338 [ # # ]: 0 : } else if (cmprtn > 0) {
1339 [ # # ]: 0 : rtn = zxdh_comm_double_link_insert_aft(&p_ins_tn->tn_ln,
1340 : : &p_pre_tn->tn_ln, &p_rb_cfg->tn_list);
1341 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_insert_aft");
1342 : : } else {
1343 : : RTE_ASSERT(!p_pre_tn);
1344 : :
1345 [ # # ]: 0 : rtn = zxdh_comm_double_link_insert_1st(&p_ins_tn->tn_ln,
1346 : : &p_rb_cfg->tn_list);
1347 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_insert_1st");
1348 : : }
1349 : :
1350 : : break;
1351 : : }
1352 : :
1353 : 0 : stack_tn[stack_top++] = pp_cur_tn;
1354 : : p_pre_tn = p_cur_tn;
1355 : 0 : cmprtn = p_rb_cfg->p_cmpfun(p_cur_key, p_cur_tn->p_key, p_rb_cfg->key_size);
1356 : :
1357 [ # # ]: 0 : if (cmprtn > 0) {
1358 : 0 : pp_cur_tn = &p_cur_tn->p_right;
1359 [ # # ]: 0 : } else if (cmprtn < 0) {
1360 : 0 : pp_cur_tn = &p_cur_tn->p_left;
1361 : : } else {
1362 : 0 : PMD_DRV_LOG(ERR, "rb_key is same");
1363 : :
1364 [ # # ]: 0 : if (p_rb_cfg->is_dynamic) {
1365 [ # # ]: 0 : if (out_val)
1366 : 0 : *((ZXDH_RB_TN **)out_val) = p_cur_tn;
1367 : : } else {
1368 [ # # ]: 0 : if (out_val)
1369 : 0 : *((uint32_t *)out_val) = zxdh_np_get_tn_lsv(p_cur_tn);
1370 : : }
1371 : :
1372 : 0 : return ZXDH_RBT_RC_UPDATE;
1373 : : }
1374 : : }
1375 : :
1376 [ # # ]: 0 : p_ins_tn->p_parent = (stack_top > 1) ? *stack_tn[stack_top - 1] : NULL;
1377 : 0 : stack_tn[stack_top] = pp_cur_tn;
1378 : :
1379 : 0 : *pp_cur_tn = p_ins_tn;
1380 : :
1381 : 0 : rtn = zxdh_comm_rb_handle_ins(p_rb_cfg, stack_tn, stack_top);
1382 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_rb_handle_ins");
1383 : :
1384 [ # # ]: 0 : if (p_rb_cfg->is_dynamic) {
1385 [ # # ]: 0 : if (out_val)
1386 : 0 : *((ZXDH_RB_TN **)out_val) = p_ins_tn;
1387 : : }
1388 : :
1389 : : return ZXDH_OK;
1390 : : }
1391 : :
1392 : : static uint32_t
1393 : 0 : zxdh_comm_rb_search(ZXDH_RB_CFG *p_rb_cfg,
1394 : : void *p_key,
1395 : : void *out_val)
1396 : : {
1397 : : int32_t cmprtn = 0;
1398 : : ZXDH_RB_TN *p_cur_tn = NULL;
1399 : :
1400 : 0 : p_cur_tn = p_rb_cfg->p_root;
1401 : :
1402 [ # # ]: 0 : while (p_cur_tn) {
1403 : 0 : cmprtn = p_rb_cfg->p_cmpfun(p_key, p_cur_tn->p_key, p_rb_cfg->key_size);
1404 : :
1405 [ # # ]: 0 : if (cmprtn > 0)
1406 : 0 : p_cur_tn = p_cur_tn->p_right;
1407 [ # # ]: 0 : else if (cmprtn < 0)
1408 : 0 : p_cur_tn = p_cur_tn->p_left;
1409 : : else
1410 : : break;
1411 : : }
1412 : :
1413 [ # # ]: 0 : if (!p_cur_tn) {
1414 : 0 : PMD_DRV_LOG(DEBUG, "rb srh fail");
1415 : 0 : return ZXDH_RBT_RC_SRHFAIL;
1416 : : }
1417 : :
1418 [ # # ]: 0 : if (p_rb_cfg->is_dynamic)
1419 : 0 : *(ZXDH_RB_TN **)out_val = p_cur_tn;
1420 : : else
1421 : 0 : *(uint32_t *)out_val = zxdh_np_get_tn_lsv(p_cur_tn);
1422 : :
1423 : : return ZXDH_OK;
1424 : : }
1425 : :
1426 : : static uint32_t
1427 : 0 : zxdh_comm_rb_handle_del(__rte_unused ZXDH_RB_CFG *p_rb_cfg,
1428 : : ZXDH_RB_TN ***stack_tn,
1429 : : uint32_t stack_top)
1430 : : {
1431 : : ZXDH_RB_TN **pp_cur_tn = NULL;
1432 : : ZXDH_RB_TN *p_cur_tn = NULL;
1433 : : ZXDH_RB_TN *p_tmp_tn = NULL;
1434 : : ZXDH_RB_TN *p_unc_tn = NULL;
1435 : : ZXDH_RB_TN *p_par_tn = NULL;
1436 : :
1437 [ # # ]: 0 : while (stack_top > 1) {
1438 : 0 : pp_cur_tn = stack_tn[stack_top];
1439 : 0 : p_cur_tn = *pp_cur_tn;
1440 : :
1441 : 0 : p_par_tn = *stack_tn[stack_top - 1];
1442 : :
1443 [ # # # # ]: 0 : if (p_cur_tn && p_cur_tn->p_parent) {
1444 : : p_unc_tn = zxdh_comm_rb_get_brotn(p_cur_tn);
1445 [ # # # # ]: 0 : } else if (p_cur_tn && !p_cur_tn->p_parent) {
1446 : : RTE_ASSERT(p_par_tn == p_cur_tn->p_parent);
1447 : :
1448 : : zxdh_np_set_tn_color(p_cur_tn, ZXDH_RBT_BLACK);
1449 : :
1450 : : break;
1451 : : }
1452 [ # # ]: 0 : if (!p_cur_tn) {
1453 : : RTE_ASSERT(!p_cur_tn);
1454 : :
1455 [ # # ]: 0 : if (p_par_tn)
1456 [ # # ]: 0 : p_unc_tn = p_par_tn->p_left ? p_par_tn->p_left : p_par_tn->p_right;
1457 : : else
1458 : : break;
1459 : : }
1460 : :
1461 : : if (p_unc_tn)
1462 : : RTE_ASSERT(p_unc_tn->p_parent == p_par_tn);
1463 : :
1464 [ # # ]: 0 : if (!p_unc_tn) {
1465 : : RTE_ASSERT(0);
1466 : : RTE_ASSERT(zxdh_np_get_tn_color(p_par_tn) == ZXDH_RBT_RED);
1467 : :
1468 : : zxdh_np_set_tn_color(p_par_tn, ZXDH_RBT_BLACK);
1469 : :
1470 : : break;
1471 : : }
1472 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn) == ZXDH_RBT_RED) {
1473 [ # # ]: 0 : if (p_unc_tn == p_par_tn->p_left) {
1474 : 0 : *stack_tn[stack_top - 1] = p_unc_tn;
1475 : 0 : p_unc_tn->p_parent = p_par_tn->p_parent;
1476 : 0 : p_par_tn->p_left = p_unc_tn->p_right;
1477 : :
1478 [ # # ]: 0 : if (p_unc_tn->p_right)
1479 : 0 : p_unc_tn->p_right->p_parent = p_par_tn;
1480 : :
1481 : 0 : p_par_tn->p_parent = p_unc_tn;
1482 : 0 : p_unc_tn->p_right = p_par_tn;
1483 : :
1484 : 0 : stack_tn[stack_top++] = &p_unc_tn->p_right;
1485 : 0 : stack_tn[stack_top] = &p_par_tn->p_right;
1486 : : } else {
1487 : : RTE_ASSERT(p_unc_tn == p_par_tn->p_right);
1488 : 0 : *stack_tn[stack_top - 1] = p_unc_tn;
1489 : 0 : p_unc_tn->p_parent = p_par_tn->p_parent;
1490 : 0 : p_par_tn->p_right = p_unc_tn->p_left;
1491 : :
1492 [ # # ]: 0 : if (p_unc_tn->p_left)
1493 : 0 : p_unc_tn->p_left->p_parent = p_par_tn;
1494 : :
1495 : 0 : p_par_tn->p_parent = p_unc_tn;
1496 : 0 : p_unc_tn->p_left = p_par_tn;
1497 : :
1498 : 0 : stack_tn[stack_top++] = &p_unc_tn->p_left;
1499 : 0 : stack_tn[stack_top] = &p_par_tn->p_left;
1500 : : }
1501 : :
1502 : : zxdh_comm_rb_switch_color(p_unc_tn, p_par_tn);
1503 : : } else {
1504 [ # # # # : 0 : if (zxdh_np_get_tn_color(p_unc_tn->p_left) == ZXDH_RBT_BLACK &&
# # ]
1505 [ # # ]: 0 : zxdh_np_get_tn_color(p_unc_tn->p_right) == ZXDH_RBT_BLACK) {
1506 [ # # # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn->p_parent) == ZXDH_RBT_BLACK) {
1507 : : zxdh_np_set_tn_color(p_unc_tn, ZXDH_RBT_RED);
1508 : : stack_top--;
1509 : : } else {
1510 : : RTE_ASSERT(zxdh_np_get_tn_color(p_unc_tn->p_parent)
1511 : : == ZXDH_RBT_RED);
1512 : :
1513 : : zxdh_comm_rb_switch_color(p_unc_tn->p_parent, p_unc_tn);
1514 : :
1515 : : break;
1516 : : }
1517 [ # # ]: 0 : } else if (p_unc_tn == p_par_tn->p_right) {
1518 [ # # # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn->p_right) == ZXDH_RBT_RED) {
1519 : 0 : *stack_tn[stack_top - 1] = p_unc_tn;
1520 : 0 : p_unc_tn->p_parent = p_par_tn->p_parent;
1521 : 0 : p_par_tn->p_right = p_unc_tn->p_left;
1522 : :
1523 [ # # ]: 0 : if (p_unc_tn->p_left)
1524 : 0 : p_unc_tn->p_left->p_parent = p_par_tn;
1525 : :
1526 : 0 : p_par_tn->p_parent = p_unc_tn;
1527 : 0 : p_unc_tn->p_left = p_par_tn;
1528 : :
1529 : : zxdh_comm_rb_switch_color(p_unc_tn, p_par_tn);
1530 : :
1531 : 0 : zxdh_np_set_tn_color(p_unc_tn->p_right, ZXDH_RBT_BLACK);
1532 : :
1533 : : break;
1534 : : }
1535 : : RTE_ASSERT(zxdh_np_get_tn_color(p_unc_tn->p_left)
1536 : : == ZXDH_RBT_RED);
1537 : :
1538 : : p_tmp_tn = p_unc_tn->p_left;
1539 : :
1540 : 0 : p_par_tn->p_right = p_tmp_tn;
1541 : 0 : p_tmp_tn->p_parent = p_par_tn;
1542 : 0 : p_unc_tn->p_left = p_tmp_tn->p_right;
1543 : :
1544 [ # # ]: 0 : if (p_tmp_tn->p_right)
1545 : 0 : p_tmp_tn->p_right->p_parent = p_unc_tn;
1546 : :
1547 : 0 : p_tmp_tn->p_right = p_unc_tn;
1548 : 0 : p_unc_tn->p_parent = p_tmp_tn;
1549 : :
1550 : : zxdh_comm_rb_switch_color(p_tmp_tn, p_unc_tn);
1551 : : } else {
1552 : : RTE_ASSERT(p_unc_tn == p_par_tn->p_left);
1553 : :
1554 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn->p_left) == ZXDH_RBT_RED) {
1555 : 0 : *stack_tn[stack_top - 1] = p_unc_tn;
1556 : 0 : p_unc_tn->p_parent = p_par_tn->p_parent;
1557 : 0 : p_par_tn->p_left = p_unc_tn->p_right;
1558 : :
1559 [ # # ]: 0 : if (p_unc_tn->p_right)
1560 : 0 : p_unc_tn->p_right->p_parent = p_par_tn;
1561 : :
1562 : 0 : p_par_tn->p_parent = p_unc_tn;
1563 : 0 : p_unc_tn->p_right = p_par_tn;
1564 : :
1565 : : zxdh_comm_rb_switch_color(p_unc_tn, p_par_tn);
1566 : :
1567 : 0 : zxdh_np_set_tn_color(p_unc_tn->p_left, ZXDH_RBT_BLACK);
1568 : : break;
1569 : : }
1570 : : RTE_ASSERT(zxdh_np_get_tn_color(p_unc_tn->p_right)
1571 : : == ZXDH_RBT_RED);
1572 : :
1573 : 0 : p_tmp_tn = p_unc_tn->p_right;
1574 : :
1575 : 0 : p_par_tn->p_left = p_tmp_tn;
1576 : 0 : p_tmp_tn->p_parent = p_par_tn;
1577 : 0 : p_unc_tn->p_right = p_tmp_tn->p_left;
1578 : :
1579 [ # # ]: 0 : if (p_tmp_tn->p_left)
1580 : 0 : p_tmp_tn->p_left->p_parent = p_unc_tn;
1581 : :
1582 : 0 : p_tmp_tn->p_left = p_unc_tn;
1583 : 0 : p_unc_tn->p_parent = p_tmp_tn;
1584 : :
1585 : : zxdh_comm_rb_switch_color(p_tmp_tn, p_unc_tn);
1586 : : }
1587 : : }
1588 : : }
1589 : :
1590 : 0 : return ZXDH_OK;
1591 : : }
1592 : :
1593 : : static uint32_t
1594 : 0 : zxdh_comm_rb_delete(ZXDH_RB_CFG *p_rb_cfg,
1595 : : void *p_key,
1596 : : void *out_val)
1597 : : {
1598 : : uint32_t rtn = 0;
1599 : : uint32_t stack_top = 1;
1600 : : int32_t cmprtn = 0;
1601 : : uint32_t rsv_stack = 0;
1602 : : uint32_t del_is_red = 0;
1603 : 0 : ZXDH_RB_TN **stack_tn[ZXDH_RBT_MAX_DEPTH] = {0};
1604 : : ZXDH_RB_TN *p_cur_tn = NULL;
1605 : : ZXDH_RB_TN **pp_cur_tn = NULL;
1606 : : void *p_cur_key = NULL;
1607 : : ZXDH_RB_TN *p_rsv_tn = NULL;
1608 : : ZXDH_RB_TN *p_del_tn = NULL;
1609 : :
1610 : : p_cur_key = p_key;
1611 : :
1612 : 0 : pp_cur_tn = &p_rb_cfg->p_root;
1613 : :
1614 : : for (;;) {
1615 : 0 : p_cur_tn = *pp_cur_tn;
1616 : :
1617 [ # # ]: 0 : if (!p_cur_tn)
1618 : : return ZXDH_RBT_RC_SRHFAIL;
1619 : :
1620 : 0 : stack_tn[stack_top++] = pp_cur_tn;
1621 : :
1622 : 0 : cmprtn = p_rb_cfg->p_cmpfun(p_cur_key, p_cur_tn->p_key, p_rb_cfg->key_size);
1623 : :
1624 [ # # ]: 0 : if (cmprtn > 0) {
1625 : 0 : pp_cur_tn = &p_cur_tn->p_right;
1626 [ # # ]: 0 : } else if (cmprtn < 0) {
1627 : 0 : pp_cur_tn = &p_cur_tn->p_left;
1628 : : } else {
1629 : 0 : PMD_DRV_LOG(DEBUG, " find the key!");
1630 : :
1631 : : break;
1632 : : }
1633 : : }
1634 : :
1635 : : rsv_stack = stack_top - 1;
1636 : : p_rsv_tn = p_cur_tn;
1637 : :
1638 : 0 : pp_cur_tn = &p_cur_tn->p_right;
1639 : 0 : p_cur_tn = *pp_cur_tn;
1640 : :
1641 [ # # ]: 0 : if (p_cur_tn) {
1642 : 0 : stack_tn[stack_top++] = pp_cur_tn;
1643 : :
1644 : 0 : pp_cur_tn = &p_cur_tn->p_left;
1645 : 0 : p_cur_tn = *pp_cur_tn;
1646 : :
1647 [ # # ]: 0 : while (p_cur_tn) {
1648 : 0 : stack_tn[stack_top++] = pp_cur_tn;
1649 : 0 : pp_cur_tn = &p_cur_tn->p_left;
1650 : 0 : p_cur_tn = *pp_cur_tn;
1651 : : }
1652 : :
1653 : 0 : p_del_tn = *stack_tn[stack_top - 1];
1654 : :
1655 : 0 : *stack_tn[stack_top - 1] = p_del_tn->p_right;
1656 : :
1657 [ # # ]: 0 : if (p_del_tn->p_right)
1658 : 0 : p_del_tn->p_right->p_parent = p_del_tn->p_parent;
1659 : :
1660 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_del_tn) == ZXDH_RBT_RED)
1661 : : del_is_red = 1;
1662 : :
1663 : 0 : *stack_tn[rsv_stack] = p_del_tn;
1664 : :
1665 : 0 : stack_tn[rsv_stack + 1] = &p_del_tn->p_right;
1666 : :
1667 : : zxdh_np_set_tn_color(p_del_tn, zxdh_np_get_tn_color(p_rsv_tn));
1668 : 0 : p_del_tn->p_parent = p_rsv_tn->p_parent;
1669 : :
1670 : 0 : p_del_tn->p_left = p_rsv_tn->p_left;
1671 : :
1672 [ # # ]: 0 : if (p_rsv_tn->p_left)
1673 : 0 : p_rsv_tn->p_left->p_parent = p_del_tn;
1674 : :
1675 : 0 : p_del_tn->p_right = p_rsv_tn->p_right;
1676 : :
1677 [ # # ]: 0 : if (p_rsv_tn->p_right)
1678 : 0 : p_rsv_tn->p_right->p_parent = p_del_tn;
1679 : : } else {
1680 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_rsv_tn) == ZXDH_RBT_RED)
1681 : : del_is_red = 1;
1682 : :
1683 : 0 : *stack_tn[stack_top - 1] = p_rsv_tn->p_left;
1684 : :
1685 [ # # ]: 0 : if (p_rsv_tn->p_left)
1686 : 0 : p_rsv_tn->p_left->p_parent = p_rsv_tn->p_parent;
1687 : : }
1688 : :
1689 : 0 : stack_top--;
1690 [ # # # # ]: 0 : if (zxdh_np_get_tn_color(*stack_tn[stack_top]) == ZXDH_RBT_RED) {
1691 : : zxdh_np_set_tn_color(*stack_tn[stack_top], ZXDH_RBT_BLACK);
1692 [ # # ]: 0 : } else if (!del_is_red) {
1693 : 0 : rtn = zxdh_comm_rb_handle_del(p_rb_cfg, stack_tn, stack_top);
1694 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_rb_handle_del");
1695 : : }
1696 : :
1697 : : rtn = zxdh_comm_double_link_del(&p_rsv_tn->tn_ln, &p_rb_cfg->tn_list);
1698 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_del");
1699 : :
1700 [ # # ]: 0 : if (p_rb_cfg->is_dynamic) {
1701 : 0 : *(ZXDH_RB_TN **)out_val = p_rsv_tn;
1702 : : } else {
1703 : 0 : rtn = zxdh_comm_liststack_free(p_rb_cfg->p_lsm, zxdh_np_get_tn_lsv(p_rsv_tn));
1704 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_liststack_free");
1705 : :
1706 : 0 : *(uint32_t *)out_val = zxdh_np_get_tn_lsv(p_rsv_tn);
1707 : :
1708 : 0 : memset(p_rsv_tn->p_key, 0, p_rb_cfg->key_size);
1709 : : memset(p_rsv_tn, 0, sizeof(ZXDH_RB_TN));
1710 : : }
1711 : :
1712 : : return ZXDH_OK;
1713 : : }
1714 : :
1715 : : static uint32_t
1716 : 0 : zxdh_comm_liststack_destroy(ZXDH_LISTSTACK_MANAGER *p_list)
1717 : : {
1718 [ # # ]: 0 : if (p_list == NULL) {
1719 : 0 : PMD_DRV_LOG(ERR, "p_list point null");
1720 : 0 : return ZXDH_LIST_STACK_POINT_NULL;
1721 : : }
1722 : 0 : rte_free(p_list);
1723 : :
1724 : 0 : return ZXDH_OK;
1725 : : }
1726 : :
1727 : : static uint32_t
1728 : 0 : zxdh_comm_rb_destroy(ZXDH_RB_CFG *p_rb_cfg)
1729 : : {
1730 : : uint32_t rtn = 0;
1731 : :
1732 [ # # ]: 0 : if (p_rb_cfg->is_dynamic == 0)
1733 : 0 : zxdh_comm_liststack_destroy(p_rb_cfg->p_lsm);
1734 : :
1735 [ # # ]: 0 : if (p_rb_cfg->p_keybase != NULL) {
1736 : 0 : rte_free(p_rb_cfg->p_keybase);
1737 : 0 : p_rb_cfg->p_keybase = NULL;
1738 : : }
1739 : :
1740 [ # # ]: 0 : if (p_rb_cfg->p_tnbase != NULL) {
1741 : 0 : rte_free(p_rb_cfg->p_tnbase);
1742 : : p_rb_cfg->p_tnbase = NULL;
1743 : : }
1744 : :
1745 : : memset(p_rb_cfg, 0, sizeof(ZXDH_RB_CFG));
1746 : :
1747 : 0 : return rtn;
1748 : : }
1749 : :
1750 : : static int
1751 : 0 : zxdh_np_se_apt_key_default_cmp(void *p_new_key,
1752 : : void *p_old_key, __rte_unused uint32_t key_len)
1753 : : {
1754 : 0 : return memcmp((uint32_t *)p_new_key, (uint32_t *)p_old_key, sizeof(uint32_t));
1755 : : }
1756 : :
1757 : : static uint32_t
1758 : 0 : zxdh_np_se_apt_rb_insert(ZXDH_RB_CFG *rb_cfg, void *p_data, uint32_t len)
1759 : : {
1760 : : uint8_t *p_rb_key = NULL;
1761 : : ZXDH_RB_TN *p_rb_new = NULL;
1762 : 0 : ZXDH_RB_TN *p_rb_rtn = NULL;
1763 : : uint32_t rc = ZXDH_OK;
1764 : :
1765 : 0 : p_rb_key = rte_zmalloc(NULL, len, 0);
1766 [ # # ]: 0 : if (p_rb_key == NULL) {
1767 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
1768 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1769 : : }
1770 : : memcpy(p_rb_key, p_data, len);
1771 : :
1772 : 0 : p_rb_new = rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
1773 [ # # ]: 0 : if (NULL == (p_rb_new)) {
1774 : 0 : rte_free(p_rb_key);
1775 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
1776 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1777 : : }
1778 : : zxdh_np_init_rbt_tn(p_rb_new, p_rb_key);
1779 : :
1780 : 0 : rc = zxdh_comm_rb_insert(rb_cfg, p_rb_new, &p_rb_rtn);
1781 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_UPDATE) {
1782 [ # # ]: 0 : if (p_rb_rtn == NULL) {
1783 : 0 : PMD_DRV_LOG(ERR, "p_rb_rtn point null!");
1784 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1785 : : }
1786 : :
1787 : 0 : memcpy(p_rb_rtn->p_key, p_data, len);
1788 : 0 : rte_free(p_rb_new);
1789 : 0 : rte_free(p_rb_key);
1790 : 0 : PMD_DRV_LOG(DEBUG, "update exist entry!");
1791 : 0 : return ZXDH_OK;
1792 : : }
1793 : :
1794 : : return rc;
1795 : : }
1796 : :
1797 : : static uint32_t
1798 : 0 : zxdh_np_se_apt_rb_delete(ZXDH_RB_CFG *rb_cfg, void *p_data, __rte_unused uint32_t len)
1799 : : {
1800 : : uint32_t rc = ZXDH_OK;
1801 : 0 : ZXDH_RB_TN *p_rb_rtn = NULL;
1802 : :
1803 : 0 : rc = zxdh_comm_rb_delete(rb_cfg, p_data, &p_rb_rtn);
1804 [ # # ]: 0 : if (rc != ZXDH_OK)
1805 : : return rc;
1806 : 0 : rte_free(p_rb_rtn->p_key);
1807 : 0 : rte_free(p_rb_rtn);
1808 : :
1809 : 0 : return rc;
1810 : : }
1811 : :
1812 : : static uint32_t
1813 : 0 : zxdh_np_se_apt_rb_search(ZXDH_RB_CFG *rb_cfg, void *p_data, uint32_t len)
1814 : : {
1815 : : uint32_t rc = ZXDH_OK;
1816 : 0 : ZXDH_RB_TN *p_rb_rtn = NULL;
1817 : :
1818 : 0 : rc = zxdh_comm_rb_search(rb_cfg, p_data, &p_rb_rtn);
1819 [ # # ]: 0 : if (rc != ZXDH_OK)
1820 : : return rc;
1821 : :
1822 : 0 : memcpy(p_data, p_rb_rtn->p_key, len);
1823 : 0 : return rc;
1824 : : }
1825 : :
1826 : : static uint32_t
1827 : 0 : zxdh_np_dev_init(void)
1828 : : {
1829 [ # # ]: 0 : if (g_dev_mgr.is_init) {
1830 : 0 : PMD_DRV_LOG(ERR, "Dev is already initialized");
1831 : 0 : return 0;
1832 : : }
1833 : :
1834 : 0 : g_dev_mgr.device_num = 0;
1835 : 0 : g_dev_mgr.is_init = 1;
1836 : :
1837 : 0 : return 0;
1838 : : }
1839 : :
1840 : : static void
1841 : : zxdh_np_dev_vport_get(uint32_t dev_id, uint32_t *vport)
1842 : : {
1843 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1844 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
1845 : :
1846 : 0 : *vport = p_dev_info->vport[ZXDH_DEV_PF_INDEX(dev_id)];
1847 : : }
1848 : :
1849 : : static void
1850 : : zxdh_np_dev_agent_addr_get(uint32_t dev_id, uint64_t *agent_addr)
1851 : : {
1852 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1853 : : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
1854 : :
1855 : 0 : *agent_addr = p_dev_info->agent_addr[ZXDH_DEV_PF_INDEX(dev_id)];
1856 : : }
1857 : :
1858 : : static void
1859 : : zxdh_np_dev_bar_pcie_id_get(uint32_t dev_id, uint16_t *p_pcie_id)
1860 : : {
1861 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1862 : : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
1863 : :
1864 : 0 : *p_pcie_id = p_dev_info->pcie_id[ZXDH_DEV_PF_INDEX(dev_id)];
1865 : : }
1866 : :
1867 : : static void
1868 : 0 : zxdh_np_dev_fw_bar_msg_num_set(uint32_t dev_id, uint32_t bar_msg_num)
1869 : : {
1870 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1871 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
1872 : :
1873 : 0 : p_dev_info->fw_bar_msg_num = bar_msg_num;
1874 : :
1875 : 0 : PMD_DRV_LOG(INFO, "fw_bar_msg_num_set:fw support agent msg num = %u!", bar_msg_num);
1876 : 0 : }
1877 : :
1878 : : static void
1879 : : zxdh_np_dev_fw_bar_msg_num_get(uint32_t dev_id, uint32_t *bar_msg_num)
1880 : : {
1881 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1882 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
1883 : :
1884 : 0 : *bar_msg_num = p_dev_info->fw_bar_msg_num;
1885 : : }
1886 : :
1887 : : static uint32_t
1888 : 0 : zxdh_np_dev_opr_spinlock_get(uint32_t dev_id, uint32_t type, ZXDH_SPINLOCK_T **p_spinlock_out)
1889 : : {
1890 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1891 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
1892 : :
1893 [ # # ]: 0 : if (p_dev_info == NULL) {
1894 : 0 : PMD_DRV_LOG(ERR, "Get dev_info[ %u ] fail!", dev_id);
1895 : 0 : return ZXDH_DEV_TYPE_INVALID;
1896 : : }
1897 : :
1898 [ # # # ]: 0 : switch (type) {
1899 : 0 : case ZXDH_DEV_SPINLOCK_T_DTB:
1900 : 0 : *p_spinlock_out = &p_dev_info->dtb_spinlock;
1901 : 0 : break;
1902 : 0 : case ZXDH_DEV_SPINLOCK_T_SMMU0:
1903 : 0 : *p_spinlock_out = &p_dev_info->smmu0_spinlock;
1904 : 0 : break;
1905 : 0 : default:
1906 : 0 : PMD_DRV_LOG(ERR, "spinlock type is invalid!");
1907 : 0 : return ZXDH_ERR;
1908 : : }
1909 : :
1910 : : return ZXDH_OK;
1911 : : }
1912 : :
1913 : : static uint32_t
1914 : : zxdh_np_dev_dtb_opr_spinlock_get(uint32_t dev_id, uint32_t type,
1915 : : uint32_t index, ZXDH_SPINLOCK_T **p_spinlock_out)
1916 : : {
1917 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1918 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
1919 : :
1920 : : switch (type) {
1921 : : case ZXDH_DEV_SPINLOCK_T_DTB:
1922 : : *p_spinlock_out = &p_dev_info->dtb_queue_spinlock[index];
1923 : : break;
1924 : : default:
1925 : : PMD_DRV_LOG(ERR, "spinlock type is invalid!");
1926 : : return ZXDH_ERR;
1927 : : }
1928 : :
1929 : : return ZXDH_OK;
1930 : : }
1931 : :
1932 : : static void
1933 : : zxdh_np_dev_hash_opr_spinlock_get(uint32_t dev_id,
1934 : : uint32_t fun_id, ZXDH_SPINLOCK_T **p_spinlock_out)
1935 : : {
1936 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1937 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
1938 : :
1939 : : *p_spinlock_out = &p_dev_info->hash_spinlock[fun_id];
1940 : : }
1941 : :
1942 : : static uint32_t
1943 : 0 : zxdh_np_dev_read_channel(uint32_t dev_id, uint32_t addr, uint32_t size, uint32_t *p_data)
1944 : : {
1945 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
1946 : :
1947 : 0 : p_dev_info = ZXDH_DEV_INFO_GET(dev_id);
1948 : :
1949 [ # # ]: 0 : if (p_dev_info == NULL) {
1950 : 0 : PMD_DRV_LOG(ERR, "Error: Channel[%u] dev is not exist",
1951 : : dev_id);
1952 : 0 : return ZXDH_ERR;
1953 : : }
1954 [ # # ]: 0 : if (p_dev_info->access_type == ZXDH_DEV_ACCESS_TYPE_PCIE) {
1955 : 0 : p_dev_info->p_pcie_read_fun(dev_id, addr, size, p_data);
1956 : : } else {
1957 : 0 : PMD_DRV_LOG(ERR, "Dev access type[ %u ] is invalid",
1958 : : p_dev_info->access_type);
1959 : 0 : return ZXDH_ERR;
1960 : : }
1961 : :
1962 : 0 : return ZXDH_OK;
1963 : : }
1964 : :
1965 : : static uint32_t
1966 : 0 : zxdh_np_dev_write_channel(uint32_t dev_id, uint32_t addr, uint32_t size, uint32_t *p_data)
1967 : : {
1968 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
1969 : :
1970 : 0 : p_dev_info = ZXDH_DEV_INFO_GET(dev_id);
1971 : :
1972 [ # # ]: 0 : if (p_dev_info == NULL) {
1973 : 0 : PMD_DRV_LOG(ERR, "Error: Channel[%u] dev is not exist", dev_id);
1974 : 0 : return ZXDH_ERR;
1975 : : }
1976 [ # # ]: 0 : if (p_dev_info->access_type == ZXDH_DEV_ACCESS_TYPE_PCIE) {
1977 : 0 : p_dev_info->p_pcie_write_fun(dev_id, addr, size, p_data);
1978 : : } else {
1979 : 0 : PMD_DRV_LOG(ERR, "Dev access type[ %u ] is invalid", p_dev_info->access_type);
1980 : 0 : return ZXDH_ERR;
1981 : : }
1982 : :
1983 : 0 : return ZXDH_OK;
1984 : : }
1985 : :
1986 : : static void
1987 : : zxdh_np_pci_write32(uint64_t abs_addr, uint32_t *p_data)
1988 : : {
1989 : : uint32_t data = 0;
1990 : : uint64_t addr = 0;
1991 : :
1992 : 0 : data = *p_data;
1993 : :
1994 : : if (zxdh_np_comm_is_big_endian())
1995 : : data = ZXDH_COMM_CONVERT32(data);
1996 : :
1997 : : addr = abs_addr + ZXDH_SYS_VF_NP_BASE_OFFSET;
1998 : 0 : *((volatile uint32_t *)addr) = data;
1999 : : }
2000 : :
2001 : : static void
2002 : : zxdh_np_pci_read32(uint64_t abs_addr, uint32_t *p_data)
2003 : : {
2004 : : uint32_t data = 0;
2005 : : uint64_t addr = 0;
2006 : :
2007 : : addr = abs_addr + ZXDH_SYS_VF_NP_BASE_OFFSET;
2008 : 0 : data = *((volatile uint32_t *)addr);
2009 : :
2010 : : if (zxdh_np_comm_is_big_endian())
2011 : : data = ZXDH_COMM_CONVERT32(data);
2012 : :
2013 : 0 : *p_data = data;
2014 : : }
2015 : :
2016 : : static uint64_t
2017 : : zxdh_np_dev_get_pcie_addr(uint32_t dev_id)
2018 : : {
2019 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
2020 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
2021 : :
2022 : : p_dev_mgr = &g_dev_mgr;
2023 : 0 : p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
2024 : :
2025 : 0 : if (p_dev_info == NULL)
2026 : : return ZXDH_DEV_TYPE_INVALID;
2027 : :
2028 : 0 : return p_dev_info->pcie_addr[ZXDH_DEV_PF_INDEX(dev_id)];
2029 : : }
2030 : :
2031 : : static void
2032 [ # # ]: 0 : zxdh_np_dev_pcie_default_write(uint32_t dev_id, uint32_t addr, uint32_t size, uint32_t *p_data)
2033 : : {
2034 : : uint32_t i;
2035 : : uint64_t abs_addr = 0;
2036 : :
2037 : 0 : abs_addr = zxdh_np_dev_get_pcie_addr(dev_id) + addr;
2038 : :
2039 [ # # ]: 0 : for (i = 0; i < size; i++)
2040 : 0 : zxdh_np_pci_write32(abs_addr + 4 * i, p_data + i);
2041 : 0 : }
2042 : :
2043 : : static void
2044 [ # # ]: 0 : zxdh_np_dev_pcie_default_read(uint32_t dev_id, uint32_t addr, uint32_t size, uint32_t *p_data)
2045 : : {
2046 : : uint32_t i;
2047 : : uint64_t abs_addr = 0;
2048 : :
2049 : 0 : abs_addr = zxdh_np_dev_get_pcie_addr(dev_id) + addr;
2050 : :
2051 [ # # ]: 0 : for (i = 0; i < size; i++)
2052 : 0 : zxdh_np_pci_read32(abs_addr + 4 * i, p_data + i);
2053 : 0 : }
2054 : :
2055 : : static uint32_t
2056 : 0 : zxdh_np_read(uint32_t dev_id, uint32_t addr, uint32_t *p_data)
2057 : : {
2058 : 0 : return zxdh_np_dev_read_channel(dev_id, addr, 1, p_data);
2059 : : }
2060 : :
2061 : : static uint32_t
2062 : 0 : zxdh_np_write(uint32_t dev_id, uint32_t addr, uint32_t *p_data)
2063 : : {
2064 : 0 : return zxdh_np_dev_write_channel(dev_id, addr, 1, p_data);
2065 : : }
2066 : :
2067 : : static uint32_t
2068 : 0 : zxdh_np_se_smmu0_write(uint32_t dev_id, uint32_t addr, uint32_t *p_data)
2069 : : {
2070 : 0 : return zxdh_np_write(dev_id, addr, p_data);
2071 : : }
2072 : :
2073 : : static uint32_t
2074 : 0 : zxdh_np_se_smmu0_read(uint32_t dev_id, uint32_t addr, uint32_t *p_data)
2075 : : {
2076 : 0 : return zxdh_np_read(dev_id, addr, p_data);
2077 : : }
2078 : :
2079 : : static ZXDH_REG_T g_dpp_reg_info[] = {
2080 : : {
2081 : : .reg_name = "cpu_ind_cmd",
2082 : : .reg_no = 669,
2083 : : .module_no = SMMU0,
2084 : : .flags = ZXDH_REG_FLAG_DIRECT,
2085 : : .array_type = ZXDH_REG_NUL_ARRAY,
2086 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x14,
2087 : : .width = (32 / 8),
2088 : : .m_size = 0,
2089 : : .n_size = 0,
2090 : : .m_step = 0,
2091 : : .n_step = 0,
2092 : : .field_num = 4,
2093 : : .p_fields = g_smmu0_smmu0_cpu_ind_cmd_reg,
2094 : : .p_write_fun = zxdh_np_se_smmu0_write,
2095 : : .p_read_fun = zxdh_np_se_smmu0_read,
2096 : : },
2097 : : {
2098 : : .reg_name = "cpu_ind_rd_done",
2099 : : .reg_no = 670,
2100 : : .module_no = SMMU0,
2101 : : .flags = ZXDH_REG_FLAG_DIRECT,
2102 : : .array_type = ZXDH_REG_NUL_ARRAY,
2103 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x40,
2104 : : .width = (32 / 8),
2105 : : .m_size = 0,
2106 : : .n_size = 0,
2107 : : .m_step = 0,
2108 : : .n_step = 0,
2109 : : .field_num = 1,
2110 : : .p_fields = g_smmu0_smmu0_cpu_ind_rd_done_reg,
2111 : : .p_write_fun = zxdh_np_se_smmu0_write,
2112 : : .p_read_fun = zxdh_np_se_smmu0_read,
2113 : : },
2114 : : {
2115 : : .reg_name = "cpu_ind_rdat0",
2116 : : .reg_no = 671,
2117 : : .module_no = SMMU0,
2118 : : .flags = ZXDH_REG_FLAG_DIRECT,
2119 : : .array_type = ZXDH_REG_NUL_ARRAY,
2120 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x44,
2121 : : .width = (32 / 8),
2122 : : .m_size = 0,
2123 : : .n_size = 0,
2124 : : .m_step = 0,
2125 : : .n_step = 0,
2126 : : .field_num = 1,
2127 : : .p_fields = g_smmu0_smmu0_cpu_ind_rdat0_reg,
2128 : : .p_write_fun = zxdh_np_se_smmu0_write,
2129 : : .p_read_fun = zxdh_np_se_smmu0_read,
2130 : : },
2131 : : {
2132 : : .reg_name = "cpu_ind_rdat1",
2133 : : .reg_no = 672,
2134 : : .module_no = SMMU0,
2135 : : .flags = ZXDH_REG_FLAG_DIRECT,
2136 : : .array_type = ZXDH_REG_NUL_ARRAY,
2137 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x48,
2138 : : .width = (32 / 8),
2139 : : .m_size = 0,
2140 : : .n_size = 0,
2141 : : .m_step = 0,
2142 : : .n_step = 0,
2143 : : .field_num = 1,
2144 : : .p_fields = g_smmu0_smmu0_cpu_ind_rdat1_reg,
2145 : : .p_write_fun = zxdh_np_se_smmu0_write,
2146 : : .p_read_fun = zxdh_np_se_smmu0_read,
2147 : : },
2148 : : {
2149 : : .reg_name = "cpu_ind_rdat2",
2150 : : .reg_no = 673,
2151 : : .module_no = SMMU0,
2152 : : .flags = ZXDH_REG_FLAG_DIRECT,
2153 : : .array_type = ZXDH_REG_NUL_ARRAY,
2154 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x4c,
2155 : : .width = (32 / 8),
2156 : : .m_size = 0,
2157 : : .n_size = 0,
2158 : : .m_step = 0,
2159 : : .n_step = 0,
2160 : : .field_num = 1,
2161 : : .p_fields = g_smmu0_smmu0_cpu_ind_rdat2_reg,
2162 : : .p_write_fun = zxdh_np_se_smmu0_write,
2163 : : .p_read_fun = zxdh_np_se_smmu0_read,
2164 : : },
2165 : : {
2166 : : .reg_name = "cpu_ind_rdat3",
2167 : : .reg_no = 674,
2168 : : .module_no = SMMU0,
2169 : : .flags = ZXDH_REG_FLAG_DIRECT,
2170 : : .array_type = ZXDH_REG_NUL_ARRAY,
2171 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x50,
2172 : : .width = (32 / 8),
2173 : : .m_size = 0,
2174 : : .n_size = 0,
2175 : : .m_step = 0,
2176 : : .n_step = 0,
2177 : : .field_num = 1,
2178 : : .p_fields = g_smmu0_smmu0_cpu_ind_rdat3_reg,
2179 : : .p_write_fun = zxdh_np_se_smmu0_write,
2180 : : .p_read_fun = zxdh_np_se_smmu0_read,
2181 : : },
2182 : : {
2183 : : .reg_name = "wr_arb_cpu_rdy",
2184 : : .reg_no = 676,
2185 : : .module_no = SMMU0,
2186 : : .flags = ZXDH_REG_FLAG_DIRECT,
2187 : : .array_type = ZXDH_REG_NUL_ARRAY,
2188 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x10c,
2189 : : .width = (32 / 8),
2190 : : .m_size = 0,
2191 : : .n_size = 0,
2192 : : .m_step = 0,
2193 : : .n_step = 0,
2194 : : .field_num = 1,
2195 : : .p_fields = g_smmu0_smmu0_wr_arb_cpu_rdy_reg,
2196 : : .p_write_fun = zxdh_np_se_smmu0_write,
2197 : : .p_read_fun = zxdh_np_se_smmu0_read,
2198 : : },
2199 : : {
2200 : : .reg_name = "info_queue_buf_space_left_0_127",
2201 : : .reg_no = 820,
2202 : : .module_no = DTB4K,
2203 : : .flags = ZXDH_REG_FLAG_DIRECT,
2204 : : .array_type = ZXDH_REG_UNI_ARRAY,
2205 : : .addr = ZXDH_SYS_DTB_BASE_ADDR + ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0xc,
2206 : : .width = (32 / 8),
2207 : : .m_size = 0,
2208 : : .n_size = 127 + 1,
2209 : : .m_step = 0,
2210 : : .n_step = 32,
2211 : : .field_num = 1,
2212 : : .p_fields = g_dtb4k_dtb_enq_info_queue_buf_space_left_0_127_reg,
2213 : : .p_write_fun = zxdh_np_write,
2214 : : .p_read_fun = zxdh_np_read,
2215 : : },
2216 : : {
2217 : : .reg_name = "cfg_epid_v_func_num_0_127",
2218 : : .reg_no = 821,
2219 : : .module_no = DTB4K,
2220 : : .flags = ZXDH_REG_FLAG_DIRECT,
2221 : : .array_type = ZXDH_REG_UNI_ARRAY,
2222 : : .addr = ZXDH_SYS_DTB_BASE_ADDR + ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x10,
2223 : : .width = (32 / 8),
2224 : : .m_size = 0,
2225 : : .n_size = 127 + 1,
2226 : : .m_step = 0,
2227 : : .n_step = 32,
2228 : : .field_num = 7,
2229 : : .p_fields = g_dtb4k_dtb_enq_cfg_epid_v_func_num_0_127_reg,
2230 : : .p_write_fun = zxdh_np_write,
2231 : : .p_read_fun = zxdh_np_read,
2232 : : },
2233 : : {
2234 : : .reg_name = "cara_queue_ram0_159_0",
2235 : : .reg_no = 721,
2236 : : .module_no = STAT,
2237 : : .flags = ZXDH_REG_FLAG_INDIRECT,
2238 : : .array_type = ZXDH_REG_UNI_ARRAY,
2239 : : .addr = 0x000000 + 0x14000000,
2240 : : .width = (160 / 8),
2241 : : .m_size = 0,
2242 : : .n_size = 0x7FFF + 1,
2243 : : .m_step = 0,
2244 : : .n_step = 8,
2245 : : .field_num = 9,
2246 : : .p_fields = g_stat_car0_cara_queue_ram0_159_0_reg,
2247 : : .p_write_fun = NULL,
2248 : : .p_read_fun = NULL,
2249 : : },
2250 : : {
2251 : : .reg_name = "carb_queue_ram0_159_0",
2252 : : .reg_no = 738,
2253 : : .module_no = STAT,
2254 : : .flags = ZXDH_REG_FLAG_INDIRECT,
2255 : : .array_type = ZXDH_REG_UNI_ARRAY,
2256 : : .addr = 0x100000 + 0x14000000,
2257 : : .width = (160 / 8),
2258 : : .m_size = 0,
2259 : : .n_size = 0xFFF + 1,
2260 : : .m_step = 0,
2261 : : .n_step = 8,
2262 : : .field_num = 9,
2263 : : .p_fields = g_stat_car0_carb_queue_ram0_159_0_reg,
2264 : : .p_write_fun = NULL,
2265 : : .p_read_fun = NULL,
2266 : : },
2267 : : {
2268 : : .reg_name = "carc_queue_ram0_159_0",
2269 : : .reg_no = 755,
2270 : : .module_no = STAT,
2271 : : .flags = ZXDH_REG_FLAG_INDIRECT,
2272 : : .array_type = ZXDH_REG_UNI_ARRAY,
2273 : : .addr = 0x200000 + 0x14000000,
2274 : : .width = (160 / 8),
2275 : : .m_size = 0,
2276 : : .n_size = 0x3FF + 1,
2277 : : .m_step = 0,
2278 : : .n_step = 8,
2279 : : .field_num = 9,
2280 : : .p_fields = g_stat_car0_carc_queue_ram0_159_0_reg,
2281 : : .p_write_fun = NULL,
2282 : : .p_read_fun = NULL,
2283 : : },
2284 : : {
2285 : : .reg_name = "pktrx_glbal_cfg_0",
2286 : : .reg_no = 448,
2287 : : .module_no = NPPU,
2288 : : .flags = ZXDH_REG_FLAG_DIRECT,
2289 : : .array_type = ZXDH_REG_NUL_ARRAY,
2290 : : .addr = ZXDH_SYS_NPPU_BASE_ADDR + ZXDH_MODULE_NPPU_PKTRX_CFG_BASE_ADDR + 0x01f8,
2291 : : .width = (32 / 8),
2292 : : .m_size = 0,
2293 : : .n_size = 0,
2294 : : .m_step = 0,
2295 : : .n_step = 0,
2296 : : .field_num = 1,
2297 : : .p_fields = g_nppu_pktrx_cfg_pktrx_glbal_cfg_0_reg,
2298 : : .p_write_fun = NULL,
2299 : : .p_read_fun = NULL,
2300 : : },
2301 : : };
2302 : :
2303 : : static uint32_t
2304 : 0 : zxdh_np_reg_get_reg_addr(uint32_t reg_no, uint32_t m_offset, uint32_t n_offset)
2305 : : {
2306 : : uint32_t addr = 0;
2307 : : ZXDH_REG_T *p_reg_info = NULL;
2308 : :
2309 : : p_reg_info = &g_dpp_reg_info[reg_no];
2310 : :
2311 : 0 : addr = p_reg_info->addr;
2312 : :
2313 [ # # ]: 0 : if (p_reg_info->array_type & ZXDH_REG_UNI_ARRAY) {
2314 [ # # ]: 0 : if (n_offset > (p_reg_info->n_size - 1))
2315 : 0 : PMD_DRV_LOG(ERR, "reg n_offset is out of range, reg_no:%u", reg_no);
2316 : :
2317 : 0 : addr += n_offset * p_reg_info->n_step;
2318 [ # # ]: 0 : } else if (p_reg_info->array_type & ZXDH_REG_BIN_ARRAY) {
2319 [ # # # # ]: 0 : if ((n_offset > (p_reg_info->n_size - 1)) || (m_offset > (p_reg_info->m_size - 1)))
2320 : 0 : PMD_DRV_LOG(ERR, "reg n_offset/m_offset out of range, reg_no:%u", reg_no);
2321 : :
2322 : 0 : addr += m_offset * p_reg_info->m_step + n_offset * p_reg_info->n_step;
2323 : : }
2324 : :
2325 : 0 : return addr;
2326 : : }
2327 : :
2328 : : static uint32_t
2329 : 0 : zxdh_np_dev_add(uint32_t dev_id, ZXDH_DEV_TYPE_E dev_type,
2330 : : ZXDH_DEV_ACCESS_TYPE_E access_type, uint64_t pcie_addr,
2331 : : uint64_t riscv_addr, uint64_t dma_vir_addr,
2332 : : uint64_t dma_phy_addr)
2333 : : {
2334 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
2335 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
2336 : : uint32_t i = 0;
2337 : :
2338 : : p_dev_mgr = &g_dev_mgr;
2339 [ # # ]: 0 : if (!p_dev_mgr->is_init) {
2340 : 0 : PMD_DRV_LOG(ERR, "ErrorCode[ 0x%x]: Device Manager is not init",
2341 : : ZXDH_RC_DEV_MGR_NOT_INIT);
2342 : 0 : return ZXDH_RC_DEV_MGR_NOT_INIT;
2343 : : }
2344 : :
2345 [ # # ]: 0 : if (p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)] != NULL) {
2346 : : /* device is already exist. */
2347 : 0 : PMD_DRV_LOG(ERR, "Device is added again");
2348 : 0 : p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
2349 : : } else {
2350 : : /* device is new. */
2351 : 0 : p_dev_info = rte_malloc(NULL, sizeof(ZXDH_DEV_CFG_T), 0);
2352 [ # # ]: 0 : if (p_dev_info == NULL) {
2353 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
2354 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2355 : : }
2356 : 0 : p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)] = p_dev_info;
2357 : 0 : p_dev_mgr->device_num++;
2358 : : }
2359 : :
2360 : 0 : p_dev_info->slot_id = ZXDH_DEV_SLOT_ID(dev_id);
2361 : 0 : p_dev_info->dev_type = dev_type;
2362 : 0 : p_dev_info->access_type = access_type;
2363 : 0 : p_dev_info->pcie_addr[ZXDH_DEV_PF_INDEX(dev_id)] = pcie_addr;
2364 : 0 : p_dev_info->pcie_id[ZXDH_DEV_PF_INDEX(dev_id)] = ZXDH_DEV_PCIE_ID(dev_id);
2365 : 0 : p_dev_info->riscv_addr = riscv_addr;
2366 : 0 : p_dev_info->dma_vir_addr = dma_vir_addr;
2367 : 0 : p_dev_info->dma_phy_addr = dma_phy_addr;
2368 : :
2369 : 0 : p_dev_info->p_pcie_write_fun = zxdh_np_dev_pcie_default_write;
2370 : 0 : p_dev_info->p_pcie_read_fun = zxdh_np_dev_pcie_default_read;
2371 : :
2372 : : rte_spinlock_init(&p_dev_info->dtb_spinlock.spinlock);
2373 : :
2374 : : rte_spinlock_init(&p_dev_info->smmu0_spinlock.spinlock);
2375 : :
2376 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_NUM_MAX; i++)
2377 : : rte_spinlock_init(&p_dev_info->dtb_queue_spinlock[i].spinlock);
2378 : :
2379 [ # # ]: 0 : for (i = 0; i < ZXDH_HASH_FUNC_ID_NUM; i++)
2380 : : rte_spinlock_init(&p_dev_info->hash_spinlock[i].spinlock);
2381 : :
2382 : : return ZXDH_OK;
2383 : : }
2384 : :
2385 : : static uint32_t
2386 : : zxdh_np_dev_agent_status_set(uint32_t dev_id, uint32_t agent_flag)
2387 : : {
2388 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
2389 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
2390 : :
2391 : : p_dev_mgr = &g_dev_mgr;
2392 : 0 : p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
2393 : :
2394 [ # # ]: 0 : if (p_dev_info == NULL)
2395 : : return ZXDH_DEV_TYPE_INVALID;
2396 : 0 : p_dev_info->agent_flag = agent_flag;
2397 : :
2398 : : return 0;
2399 : : }
2400 : :
2401 : : static void
2402 : 0 : zxdh_np_sdt_mgr_init(void)
2403 : : {
2404 [ # # ]: 0 : if (!g_sdt_mgr.is_init) {
2405 : 0 : g_sdt_mgr.channel_num = 0;
2406 : 0 : g_sdt_mgr.is_init = 1;
2407 : : memset(g_sdt_mgr.sdt_tbl_array, 0, ZXDH_DEV_CHANNEL_MAX *
2408 : : sizeof(ZXDH_SDT_SOFT_TABLE_T *));
2409 : : }
2410 : 0 : }
2411 : :
2412 : : static uint32_t
2413 : 0 : zxdh_np_sdt_mgr_create(uint32_t dev_id)
2414 : : {
2415 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_tbl_temp = NULL;
2416 : : ZXDH_SDT_MGR_T *p_sdt_mgr = NULL;
2417 : :
2418 : : p_sdt_mgr = ZXDH_SDT_MGR_PTR_GET();
2419 : :
2420 [ # # ]: 0 : if (ZXDH_SDT_SOFT_TBL_GET(dev_id) == NULL) {
2421 : 0 : p_sdt_tbl_temp = rte_malloc(NULL, sizeof(ZXDH_SDT_SOFT_TABLE_T), 0);
2422 : :
2423 : 0 : p_sdt_tbl_temp->device_id = dev_id;
2424 : 0 : memset(p_sdt_tbl_temp->sdt_array, 0, ZXDH_DEV_SDT_ID_MAX * sizeof(ZXDH_SDT_ITEM_T));
2425 : :
2426 : 0 : ZXDH_SDT_SOFT_TBL_GET(dev_id) = p_sdt_tbl_temp;
2427 : :
2428 : 0 : p_sdt_mgr->channel_num++;
2429 : : } else {
2430 : 0 : PMD_DRV_LOG(ERR, "called repeatedly!");
2431 : 0 : return 1;
2432 : : }
2433 : :
2434 : 0 : return 0;
2435 : : }
2436 : :
2437 : : static uint32_t
2438 : 0 : zxdh_np_sdt_init(uint32_t dev_num, uint32_t *dev_id_array)
2439 : : {
2440 : : uint32_t rc;
2441 : : uint32_t i;
2442 : :
2443 : 0 : zxdh_np_sdt_mgr_init();
2444 : :
2445 [ # # ]: 0 : for (i = 0; i < dev_num; i++) {
2446 : 0 : rc = zxdh_np_sdt_mgr_create(dev_id_array[i]);
2447 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_sdt_mgr_create");
2448 : : }
2449 : :
2450 : 0 : return rc;
2451 : : }
2452 : :
2453 : : static uint32_t
2454 : 0 : zxdh_np_sdt_mgr_sdt_item_add(uint32_t dev_id, uint32_t sdt_no,
2455 : : uint32_t sdt_hig32, uint32_t sdt_low32)
2456 : : {
2457 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_soft_tbl = NULL;
2458 : : ZXDH_SDT_ITEM_T *p_sdt_item = NULL;
2459 : :
2460 : 0 : p_sdt_soft_tbl = ZXDH_SDT_SOFT_TBL_GET(dev_id);
2461 : :
2462 [ # # ]: 0 : if (p_sdt_soft_tbl == NULL) {
2463 : 0 : PMD_DRV_LOG(ERR, "soft sdt table not init!");
2464 : : RTE_ASSERT(0);
2465 : 0 : return ZXDH_RC_TABLE_SDT_MGR_INVALID;
2466 : : }
2467 : :
2468 [ # # ]: 0 : if (dev_id != p_sdt_soft_tbl->device_id) {
2469 : 0 : PMD_DRV_LOG(ERR, "soft sdt table item invalid!");
2470 : : RTE_ASSERT(0);
2471 : 0 : return ZXDH_RC_TABLE_PARA_INVALID;
2472 : : }
2473 : :
2474 : : p_sdt_item = &p_sdt_soft_tbl->sdt_array[sdt_no];
2475 : 0 : p_sdt_item->valid = ZXDH_SDT_VALID;
2476 : 0 : p_sdt_item->table_cfg[0] = sdt_hig32;
2477 : 0 : p_sdt_item->table_cfg[1] = sdt_low32;
2478 : :
2479 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x 0x%08x", p_sdt_item->table_cfg[0], p_sdt_item->table_cfg[1]);
2480 : :
2481 : 0 : return ZXDH_OK;
2482 : : }
2483 : :
2484 : : static uint32_t
2485 : 0 : zxdh_np_sdt_mgr_sdt_item_del(uint32_t dev_id, uint32_t sdt_no)
2486 : : {
2487 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_soft_tbl = NULL;
2488 : : ZXDH_SDT_ITEM_T *p_sdt_item = NULL;
2489 : :
2490 : 0 : p_sdt_soft_tbl = ZXDH_SDT_SOFT_TBL_GET(dev_id);
2491 : :
2492 [ # # ]: 0 : if (p_sdt_soft_tbl != NULL) {
2493 [ # # ]: 0 : if (dev_id != p_sdt_soft_tbl->device_id) {
2494 : 0 : PMD_DRV_LOG(ERR, "soft table item invalid !");
2495 : : RTE_ASSERT(0);
2496 : 0 : return ZXDH_RC_TABLE_PARA_INVALID;
2497 : : }
2498 : :
2499 : : p_sdt_item = &p_sdt_soft_tbl->sdt_array[sdt_no];
2500 : 0 : p_sdt_item->valid = ZXDH_SDT_INVALID;
2501 : 0 : p_sdt_item->table_cfg[0] = 0;
2502 : 0 : p_sdt_item->table_cfg[1] = 0;
2503 : : }
2504 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no: 0x%08x", sdt_no);
2505 : 0 : return ZXDH_OK;
2506 : : }
2507 : :
2508 : : static void
2509 : : zxdh_np_soft_sdt_tbl_set(uint32_t dev_id,
2510 : : uint32_t sdt_no,
2511 : : uint32_t table_type,
2512 : : ZXDH_SDT_TBL_DATA_T *p_sdt_info)
2513 : : {
2514 : 0 : g_table_type[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no] = table_type;
2515 : 0 : g_sdt_info[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no].data_high32 = p_sdt_info->data_high32;
2516 : 0 : g_sdt_info[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no].data_low32 = p_sdt_info->data_low32;
2517 : : }
2518 : :
2519 : : static uint32_t
2520 : 0 : zxdh_np_sdt_tbl_write(uint32_t dev_id,
2521 : : uint32_t sdt_no,
2522 : : uint32_t table_type,
2523 : : void *p_sdt_info,
2524 : : uint32_t opr_type)
2525 : : {
2526 : : uint32_t rtn = 0;
2527 : :
2528 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
2529 : : ZXDH_SDT_TBL_ERAM_T *p_sdt_eram = NULL;
2530 : : ZXDH_SDT_TBL_HASH_T *p_sdt_hash = NULL;
2531 : : ZXDH_SDT_TBL_ETCAM_T *p_sdt_etcam = NULL;
2532 : : ZXDH_SDT_TBL_PORTTBL_T *p_sdt_porttbl = NULL;
2533 : :
2534 : 0 : PMD_DRV_LOG(DEBUG, "sdt: %u", sdt_no);
2535 : :
2536 [ # # ]: 0 : if (opr_type) {
2537 : : zxdh_np_soft_sdt_tbl_set(dev_id, sdt_no, 0, &sdt_tbl);
2538 : :
2539 : 0 : rtn = zxdh_np_sdt_mgr_sdt_item_del(dev_id, sdt_no);
2540 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rtn, "zxdh_np_sdt_mgr_sdt_item_del");
2541 : : } else {
2542 [ # # # # : 0 : switch (table_type) {
# ]
2543 : 0 : case ZXDH_SDT_TBLT_ERAM:
2544 : : p_sdt_eram = (ZXDH_SDT_TBL_ERAM_T *)p_sdt_info;
2545 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2546 : : p_sdt_eram->eram_mode,
2547 : : ZXDH_SDT_H_ERAM_MODE_BT_POS,
2548 : : ZXDH_SDT_H_ERAM_MODE_BT_LEN);
2549 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2550 : : p_sdt_eram->eram_base_addr,
2551 : : ZXDH_SDT_H_ERAM_BASE_ADDR_BT_POS,
2552 : : ZXDH_SDT_H_ERAM_BASE_ADDR_BT_LEN);
2553 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2554 : : p_sdt_eram->eram_table_depth,
2555 : : ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_POS,
2556 : : ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_LEN);
2557 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2558 : : p_sdt_eram->eram_clutch_en,
2559 : : ZXDH_SDT_L_CLUTCH_EN_BT_POS,
2560 : : ZXDH_SDT_L_CLUTCH_EN_BT_LEN);
2561 : : break;
2562 : :
2563 : 0 : case ZXDH_SDT_TBLT_HASH:
2564 : : p_sdt_hash = (ZXDH_SDT_TBL_HASH_T *)p_sdt_info;
2565 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2566 : : p_sdt_hash->hash_id,
2567 : : ZXDH_SDT_H_HASH_ID_BT_POS,
2568 : : ZXDH_SDT_H_HASH_ID_BT_LEN);
2569 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2570 : : p_sdt_hash->hash_table_width,
2571 : : ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_POS,
2572 : : ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_LEN);
2573 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2574 : : p_sdt_hash->key_size,
2575 : : ZXDH_SDT_H_HASH_KEY_SIZE_BT_POS,
2576 : : ZXDH_SDT_H_HASH_KEY_SIZE_BT_LEN);
2577 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2578 : : p_sdt_hash->hash_table_id,
2579 : : ZXDH_SDT_H_HASH_TABLE_ID_BT_POS,
2580 : : ZXDH_SDT_H_HASH_TABLE_ID_BT_LEN);
2581 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2582 : : p_sdt_hash->learn_en,
2583 : : ZXDH_SDT_H_LEARN_EN_BT_POS,
2584 : : ZXDH_SDT_H_LEARN_EN_BT_LEN);
2585 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2586 : : p_sdt_hash->keep_alive,
2587 : : ZXDH_SDT_H_KEEP_ALIVE_BT_POS,
2588 : : ZXDH_SDT_H_KEEP_ALIVE_BT_LEN);
2589 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2590 : : ((p_sdt_hash->keep_alive_baddr) >>
2591 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN),
2592 : : ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_POS,
2593 : : ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_LEN);
2594 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2595 : : ZXDH_SDT_GET_LOW_DATA((p_sdt_hash->keep_alive_baddr),
2596 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN),
2597 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_POS,
2598 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN);
2599 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2600 : : p_sdt_hash->rsp_mode,
2601 : : ZXDH_SDT_L_RSP_MODE_BT_POS,
2602 : : ZXDH_SDT_L_RSP_MODE_BT_LEN);
2603 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2604 : : p_sdt_hash->hash_clutch_en,
2605 : : ZXDH_SDT_L_CLUTCH_EN_BT_POS,
2606 : : ZXDH_SDT_L_CLUTCH_EN_BT_LEN);
2607 : : break;
2608 : :
2609 : 0 : case ZXDH_SDT_TBLT_ETCAM:
2610 : : p_sdt_etcam = (ZXDH_SDT_TBL_ETCAM_T *)p_sdt_info;
2611 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2612 : : p_sdt_etcam->etcam_id,
2613 : : ZXDH_SDT_H_ETCAM_ID_BT_POS,
2614 : : ZXDH_SDT_H_ETCAM_ID_BT_LEN);
2615 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2616 : : p_sdt_etcam->etcam_key_mode,
2617 : : ZXDH_SDT_H_ETCAM_KEY_MODE_BT_POS,
2618 : : ZXDH_SDT_H_ETCAM_KEY_MODE_BT_LEN);
2619 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2620 : : p_sdt_etcam->etcam_table_id,
2621 : : ZXDH_SDT_H_ETCAM_TABLE_ID_BT_POS,
2622 : : ZXDH_SDT_H_ETCAM_TABLE_ID_BT_LEN);
2623 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2624 : : p_sdt_etcam->no_as_rsp_mode,
2625 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_POS,
2626 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_LEN);
2627 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2628 : : p_sdt_etcam->as_en,
2629 : : ZXDH_SDT_H_ETCAM_AS_EN_BT_POS,
2630 : : ZXDH_SDT_H_ETCAM_AS_EN_BT_LEN);
2631 : :
2632 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2633 : : ((p_sdt_etcam->as_eram_baddr) >>
2634 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN),
2635 : : ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_POS,
2636 : : ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_LEN);
2637 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2638 : : ZXDH_SDT_GET_LOW_DATA((p_sdt_etcam->as_eram_baddr),
2639 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN),
2640 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_POS,
2641 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN);
2642 : :
2643 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32, p_sdt_etcam->as_rsp_mode,
2644 : : ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_POS,
2645 : : ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_LEN);
2646 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2647 : : p_sdt_etcam->etcam_table_depth, ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_POS,
2648 : : ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_LEN);
2649 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2650 : : p_sdt_etcam->etcam_clutch_en, ZXDH_SDT_L_CLUTCH_EN_BT_POS,
2651 : : ZXDH_SDT_L_CLUTCH_EN_BT_LEN);
2652 : : break;
2653 : :
2654 : 0 : case ZXDH_SDT_TBLT_PORTTBL:
2655 : : p_sdt_porttbl = (ZXDH_SDT_TBL_PORTTBL_T *)p_sdt_info;
2656 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2657 : : p_sdt_porttbl->porttbl_clutch_en, ZXDH_SDT_L_CLUTCH_EN_BT_POS,
2658 : : ZXDH_SDT_L_CLUTCH_EN_BT_LEN);
2659 : : break;
2660 : :
2661 : 0 : default:
2662 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!",
2663 : : table_type);
2664 : 0 : return ZXDH_ERR;
2665 : : }
2666 : :
2667 : : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32, table_type,
2668 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
2669 : : zxdh_np_soft_sdt_tbl_set(dev_id, sdt_no, table_type, &sdt_tbl);
2670 : :
2671 : 0 : rtn = zxdh_np_sdt_mgr_sdt_item_add(dev_id, sdt_no, sdt_tbl.data_high32,
2672 : : sdt_tbl.data_low32);
2673 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rtn, "zxdh_np_sdt_mgr_sdt_item_add");
2674 : : }
2675 : :
2676 : : return ZXDH_OK;
2677 : : }
2678 : :
2679 : : static void
2680 : 0 : zxdh_np_ppu_parse_cls_bitmap(uint32_t dev_id,
2681 : : uint32_t bitmap)
2682 : : {
2683 : : uint32_t cls_id;
2684 : : uint32_t mem_id;
2685 : : uint32_t cls_use;
2686 : : uint32_t instr_mem;
2687 : :
2688 [ # # ]: 0 : for (cls_id = 0; cls_id < ZXDH_PPU_CLUSTER_NUM; cls_id++) {
2689 : 0 : cls_use = (bitmap >> cls_id) & 0x1;
2690 : 0 : g_ppu_cls_bit_map[ZXDH_DEV_SLOT_ID(dev_id)].cls_use[cls_id] = cls_use;
2691 : : }
2692 : :
2693 [ # # ]: 0 : for (mem_id = 0; mem_id < ZXDH_PPU_INSTR_MEM_NUM; mem_id++) {
2694 : 0 : instr_mem = (bitmap >> (mem_id * 2)) & 0x3;
2695 : 0 : g_ppu_cls_bit_map[ZXDH_DEV_SLOT_ID(dev_id)].instr_mem[mem_id] =
2696 : 0 : ((instr_mem > 0) ? 1 : 0);
2697 : : }
2698 : 0 : }
2699 : :
2700 : : static void
2701 : 0 : zxdh_np_agent_msg_prt(uint8_t type, uint32_t rtn)
2702 : : {
2703 [ # # # # : 0 : switch (rtn) {
# # ]
2704 : 0 : case ZXDH_RC_CTRLCH_MSG_LEN_ZERO:
2705 : 0 : PMD_DRV_LOG(ERR, "type[%u]:msg len is zero!", type);
2706 : 0 : break;
2707 : 0 : case ZXDH_RC_CTRLCH_MSG_PRO_ERR:
2708 : 0 : PMD_DRV_LOG(ERR, "type[%u]:msg process error!", type);
2709 : 0 : break;
2710 : 0 : case ZXDH_RC_CTRLCH_MSG_TYPE_NOT_SUPPORT:
2711 : 0 : PMD_DRV_LOG(ERR, "type[%u]:fw not support the msg!", type);
2712 : 0 : break;
2713 : 0 : case ZXDH_RC_CTRLCH_MSG_OPER_NOT_SUPPORT:
2714 : 0 : PMD_DRV_LOG(ERR, "type[%u]:fw not support opr of the msg!", type);
2715 : 0 : break;
2716 : 0 : case ZXDH_RC_CTRLCH_MSG_DROP:
2717 : 0 : PMD_DRV_LOG(ERR, "type[%u]:fw not support,drop msg!", type);
2718 : 0 : break;
2719 : : default:
2720 : : break;
2721 : : }
2722 : 0 : }
2723 : :
2724 : : static uint32_t
2725 : 0 : zxdh_np_agent_bar_msg_check(uint32_t dev_id, ZXDH_AGENT_CHANNEL_MSG_T *p_msg)
2726 : : {
2727 : : uint8_t type = 0;
2728 : : uint32_t bar_msg_num = 0;
2729 : :
2730 : 0 : type = *((uint8_t *)(p_msg->msg) + 1);
2731 [ # # ]: 0 : if (type != ZXDH_PCIE_BAR_MSG) {
2732 : : zxdh_np_dev_fw_bar_msg_num_get(dev_id, &bar_msg_num);
2733 [ # # ]: 0 : if (type >= bar_msg_num) {
2734 : 0 : PMD_DRV_LOG(ERR, "type[%u] > fw_bar_msg_num[%u]!", type, bar_msg_num);
2735 : 0 : return ZXDH_RC_CTRLCH_MSG_TYPE_NOT_SUPPORT;
2736 : : }
2737 : : }
2738 : :
2739 : : return ZXDH_OK;
2740 : : }
2741 : :
2742 : : static uint32_t
2743 : 0 : zxdh_np_agent_channel_sync_send(uint32_t dev_id,
2744 : : ZXDH_AGENT_CHANNEL_MSG_T *p_msg,
2745 : : uint32_t *p_data,
2746 : : uint32_t rep_len)
2747 : : {
2748 : : uint32_t ret = ZXDH_OK;
2749 : : uint32_t vport = 0;
2750 : 0 : struct zxdh_pci_bar_msg in = {0};
2751 : 0 : struct zxdh_msg_recviver_mem result = {0};
2752 : : uint32_t *recv_buffer = NULL;
2753 : : uint8_t *reply_ptr = NULL;
2754 : : uint16_t reply_msg_len = 0;
2755 : : uint64_t agent_addr = 0;
2756 : : uint16_t bar_pcie_id = 0;
2757 : :
2758 : 0 : ret = zxdh_np_agent_bar_msg_check(dev_id, p_msg);
2759 [ # # ]: 0 : if (ret != ZXDH_OK) {
2760 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_bar_msg_check failed!");
2761 : 0 : return ret;
2762 : : }
2763 : :
2764 : : zxdh_np_dev_vport_get(dev_id, &vport);
2765 : : zxdh_np_dev_agent_addr_get(dev_id, &agent_addr);
2766 : : zxdh_np_dev_bar_pcie_id_get(dev_id, &bar_pcie_id);
2767 : :
2768 [ # # ]: 0 : if (ZXDH_IS_PF(vport))
2769 : 0 : in.src = ZXDH_MSG_CHAN_END_PF;
2770 : : else
2771 : 0 : in.src = ZXDH_MSG_CHAN_END_VF;
2772 : :
2773 : 0 : in.virt_addr = agent_addr;
2774 : 0 : in.payload_addr = p_msg->msg;
2775 : 0 : in.payload_len = p_msg->msg_len;
2776 : 0 : in.dst = ZXDH_MSG_CHAN_END_RISC;
2777 : 0 : in.module_id = ZXDH_BAR_MDOULE_NPSDK;
2778 : 0 : in.src_pcieid = bar_pcie_id;
2779 : :
2780 : 0 : recv_buffer = rte_zmalloc(NULL, rep_len + ZXDH_CHANNEL_REPS_LEN, 0);
2781 [ # # ]: 0 : if (recv_buffer == NULL) {
2782 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
2783 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2784 : : }
2785 : :
2786 : 0 : result.buffer_len = rep_len + ZXDH_CHANNEL_REPS_LEN;
2787 : 0 : result.recv_buffer = recv_buffer;
2788 : :
2789 : 0 : ret = zxdh_bar_chan_sync_msg_send(&in, &result);
2790 [ # # ]: 0 : if (ret == ZXDH_BAR_MSG_OK) {
2791 : 0 : reply_ptr = (uint8_t *)(result.recv_buffer);
2792 [ # # ]: 0 : if (*reply_ptr == 0XFF) {
2793 : 0 : reply_msg_len = *(uint16_t *)(reply_ptr + 1);
2794 : 0 : memcpy(p_data, reply_ptr + 4,
2795 : 0 : ((reply_msg_len > rep_len) ? rep_len : reply_msg_len));
2796 : : } else {
2797 : 0 : PMD_DRV_LOG(ERR, "Message not replied");
2798 : : }
2799 : : } else {
2800 : 0 : PMD_DRV_LOG(ERR, "Error[0x%x], bar msg send failed!", ret);
2801 : : }
2802 : :
2803 : 0 : rte_free(recv_buffer);
2804 : 0 : return ret;
2805 : : }
2806 : :
2807 : : static uint32_t
2808 : 0 : zxdh_np_agent_channel_reg_sync_send(uint32_t dev_id,
2809 : : ZXDH_AGENT_CHANNEL_REG_MSG_T *p_msg, uint32_t *p_data, uint32_t rep_len)
2810 : : {
2811 : : uint32_t ret = ZXDH_OK;
2812 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_msg);
2813 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
2814 : : .msg = (void *)p_msg,
2815 : : .msg_len = sizeof(ZXDH_AGENT_CHANNEL_REG_MSG_T),
2816 : : };
2817 : :
2818 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_data, rep_len);
2819 [ # # ]: 0 : if (ret != ZXDH_OK) {
2820 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed");
2821 : 0 : return ZXDH_ERR;
2822 : : }
2823 : :
2824 : 0 : ret = *p_data;
2825 [ # # ]: 0 : if (ret != ZXDH_OK) {
2826 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed in buffer");
2827 : 0 : return ZXDH_ERR;
2828 : : }
2829 : :
2830 : : return ret;
2831 : : }
2832 : :
2833 : : static uint32_t
2834 : 0 : zxdh_np_agent_channel_pcie_bar_request(uint32_t dev_id,
2835 : : uint32_t *p_bar_msg_num)
2836 : : {
2837 : : uint32_t rc = ZXDH_OK;
2838 : 0 : uint32_t rsp_buff[2] = {0};
2839 : : uint32_t msg_result = 0;
2840 : : uint32_t bar_msg_num = 0;
2841 : 0 : ZXDH_AGENT_PCIE_BAR_MSG_T msgcfg = {
2842 : : .dev_id = 0,
2843 : : .type = ZXDH_PCIE_BAR_MSG,
2844 : : .oper = ZXDH_BAR_MSG_NUM_REQ,
2845 : : };
2846 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
2847 : : .msg = (void *)&msgcfg,
2848 : : .msg_len = sizeof(ZXDH_AGENT_PCIE_BAR_MSG_T),
2849 : : };
2850 : :
2851 : 0 : rc = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, rsp_buff, sizeof(rsp_buff));
2852 [ # # ]: 0 : if (rc != ZXDH_OK) {
2853 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed!");
2854 : 0 : return rc;
2855 : : }
2856 : :
2857 : 0 : msg_result = rsp_buff[0];
2858 : 0 : bar_msg_num = rsp_buff[1];
2859 : :
2860 : 0 : zxdh_np_agent_msg_prt(msgcfg.type, msg_result);
2861 : :
2862 : 0 : *p_bar_msg_num = bar_msg_num;
2863 : :
2864 : 0 : return msg_result;
2865 : : }
2866 : :
2867 : : static uint32_t
2868 : 0 : zxdh_np_agent_channel_reg_read(uint32_t dev_id,
2869 : : uint32_t reg_type,
2870 : : uint32_t reg_no,
2871 : : uint32_t reg_width,
2872 : : uint32_t addr,
2873 : : uint32_t *p_data)
2874 : : {
2875 : : uint32_t ret = 0;
2876 : 0 : ZXDH_AGENT_CHANNEL_REG_MSG_T msgcfg = {
2877 : : .dev_id = 0,
2878 : : .type = ZXDH_REG_MSG,
2879 : : .subtype = reg_type,
2880 : : .oper = ZXDH_RD,
2881 : : .reg_no = reg_no,
2882 : : .addr = addr,
2883 : 0 : .val_len = reg_width / 4,
2884 : : };
2885 : :
2886 : 0 : uint32_t resp_len = reg_width + 4;
2887 : 0 : uint8_t *resp_buffer = rte_zmalloc(NULL, resp_len, 0);
2888 [ # # ]: 0 : if (resp_buffer == NULL) {
2889 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
2890 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2891 : : }
2892 : :
2893 : 0 : ret = zxdh_np_agent_channel_reg_sync_send(dev_id,
2894 : : &msgcfg, (uint32_t *)resp_buffer, resp_len);
2895 [ # # ]: 0 : if (ret != ZXDH_OK) {
2896 : 0 : PMD_DRV_LOG(ERR, "dev id %u reg_no %u send agent read failed.", dev_id, reg_no);
2897 : 0 : rte_free(resp_buffer);
2898 : 0 : return ZXDH_ERR;
2899 : : }
2900 : :
2901 [ # # ]: 0 : if (*((uint32_t *)resp_buffer) != ZXDH_OK) {
2902 : 0 : PMD_DRV_LOG(ERR, "dev id %u reg_no %u agent read resp err %u .",
2903 : : dev_id, reg_no, *((uint32_t *)resp_buffer));
2904 : 0 : rte_free(resp_buffer);
2905 : 0 : return ZXDH_ERR;
2906 : : }
2907 : :
2908 : 0 : memcpy(p_data, resp_buffer + 4, reg_width);
2909 : :
2910 : 0 : rte_free(resp_buffer);
2911 : :
2912 : 0 : return ret;
2913 : : }
2914 : :
2915 : : static uint32_t
2916 : 0 : zxdh_np_agent_channel_reg_write(uint32_t dev_id,
2917 : : uint32_t reg_type,
2918 : : uint32_t reg_no,
2919 : : uint32_t reg_width,
2920 : : uint32_t addr,
2921 : : uint32_t *p_data)
2922 : : {
2923 : : uint32_t ret = ZXDH_OK;
2924 : 0 : ZXDH_AGENT_CHANNEL_REG_MSG_T msgcfg = {
2925 : : .dev_id = 0,
2926 : : .type = ZXDH_REG_MSG,
2927 : : .subtype = reg_type,
2928 : : .oper = ZXDH_WR,
2929 : : .reg_no = reg_no,
2930 : : .addr = addr,
2931 : 0 : .val_len = reg_width / 4,
2932 : : };
2933 : :
2934 : 0 : memcpy(msgcfg.val, p_data, reg_width);
2935 : :
2936 : 0 : uint32_t resp_len = reg_width + 4;
2937 : 0 : uint8_t *resp_buffer = rte_zmalloc(NULL, resp_len, 0);
2938 [ # # ]: 0 : if (resp_buffer == NULL) {
2939 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
2940 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2941 : : }
2942 : :
2943 : 0 : ret = zxdh_np_agent_channel_reg_sync_send(dev_id,
2944 : : &msgcfg, (uint32_t *)resp_buffer, resp_len);
2945 : :
2946 [ # # ]: 0 : if (ret != ZXDH_OK) {
2947 : 0 : PMD_DRV_LOG(ERR, "dev id %u reg_no %u send agent write failed.", dev_id, reg_no);
2948 : 0 : rte_free(resp_buffer);
2949 : 0 : return ZXDH_ERR;
2950 : : }
2951 : :
2952 [ # # ]: 0 : if (*((uint32_t *)resp_buffer) != ZXDH_OK) {
2953 : 0 : PMD_DRV_LOG(ERR, "dev id %u reg_no %u agent write resp err %u .",
2954 : : dev_id, reg_no, *((uint32_t *)resp_buffer));
2955 : 0 : rte_free(resp_buffer);
2956 : 0 : return ZXDH_ERR;
2957 : : }
2958 : :
2959 : 0 : memcpy(p_data, resp_buffer + 4, reg_width);
2960 : :
2961 : 0 : rte_free(resp_buffer);
2962 : :
2963 : 0 : return ret;
2964 : : }
2965 : :
2966 : : static uint32_t
2967 : 0 : zxdh_np_agent_channel_dtb_sync_send(uint32_t dev_id,
2968 : : ZXDH_AGENT_CHANNEL_DTB_MSG_T *p_msg,
2969 : : uint32_t *p_data,
2970 : : uint32_t rep_len)
2971 : : {
2972 : : uint32_t ret = ZXDH_OK;
2973 : :
2974 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {0};
2975 : 0 : agent_msg.msg = (void *)p_msg;
2976 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CHANNEL_DTB_MSG_T);
2977 : :
2978 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_data, rep_len);
2979 [ # # ]: 0 : if (ret != ZXDH_OK) {
2980 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed");
2981 : 0 : return ZXDH_ERR;
2982 : : }
2983 : :
2984 : : return ZXDH_OK;
2985 : : }
2986 : :
2987 : : static uint32_t
2988 : 0 : zxdh_np_agent_channel_dtb_queue_request(uint32_t dev_id,
2989 : : char p_name[32],
2990 : : uint32_t vport_info,
2991 : : uint32_t *p_queue_id)
2992 : : {
2993 : : uint32_t rc = ZXDH_OK;
2994 : :
2995 : 0 : uint32_t rsp_buff[2] = {0};
2996 : : uint32_t msg_result = 0;
2997 : : uint32_t queue_id = 0;
2998 : 0 : ZXDH_AGENT_CHANNEL_DTB_MSG_T msgcfg = {
2999 : : .dev_id = 0,
3000 : : .type = ZXDH_DTB_MSG,
3001 : : .oper = ZXDH_QUEUE_REQUEST,
3002 : : .vport = vport_info,
3003 : : };
3004 : 0 : memcpy(msgcfg.name, p_name, strnlen(p_name, ZXDH_PORT_NAME_MAX));
3005 : :
3006 : 0 : PMD_DRV_LOG(DEBUG, "msgcfg.name=%s", msgcfg.name);
3007 : :
3008 : 0 : rc = zxdh_np_agent_channel_dtb_sync_send(dev_id, &msgcfg, rsp_buff, sizeof(rsp_buff));
3009 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_dtb_sync_send");
3010 : :
3011 : 0 : msg_result = rsp_buff[0];
3012 : 0 : queue_id = rsp_buff[1];
3013 : :
3014 : 0 : PMD_DRV_LOG(DEBUG, "dev_id: %u, msg_result: %u", dev_id, msg_result);
3015 : 0 : PMD_DRV_LOG(DEBUG, "dev_id: %u, queue_id: %u", dev_id, queue_id);
3016 : :
3017 : 0 : *p_queue_id = queue_id;
3018 : :
3019 : 0 : return msg_result;
3020 : : }
3021 : :
3022 : : static uint32_t
3023 : 0 : zxdh_np_agent_channel_dtb_queue_release(uint32_t dev_id,
3024 : : char p_name[32],
3025 : : __rte_unused uint32_t queue_id)
3026 : : {
3027 : : uint32_t rc = ZXDH_OK;
3028 : :
3029 : : uint32_t msg_result = 0;
3030 : 0 : uint32_t rsp_buff[2] = {0};
3031 : 0 : ZXDH_AGENT_CHANNEL_DTB_MSG_T msgcfg = {
3032 : : .dev_id = 0,
3033 : : .type = ZXDH_DTB_MSG,
3034 : : .oper = ZXDH_QUEUE_RELEASE,
3035 : : .queue_id = queue_id,
3036 : : };
3037 : :
3038 : 0 : memcpy(msgcfg.name, p_name, strnlen(p_name, ZXDH_PORT_NAME_MAX));
3039 : :
3040 : 0 : rc = zxdh_np_agent_channel_dtb_sync_send(dev_id, &msgcfg, rsp_buff, sizeof(rsp_buff));
3041 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_dtb_sync_send");
3042 : :
3043 : 0 : msg_result = rsp_buff[0];
3044 : 0 : PMD_DRV_LOG(DEBUG, "msg_result: %u", msg_result);
3045 : :
3046 : 0 : return msg_result;
3047 : : }
3048 : :
3049 : : static uint32_t
3050 : 0 : zxdh_np_agent_channel_se_res_get(uint32_t dev_id,
3051 : : uint32_t sub_type,
3052 : : uint32_t opr,
3053 : : uint32_t *p_rsp_buff,
3054 : : uint32_t buff_size)
3055 : : {
3056 : : uint32_t rc = ZXDH_OK;
3057 : :
3058 : : uint32_t msg_result = 0;
3059 : 0 : ZXDH_AGENT_SE_RES_MSG_T msgcfg = {
3060 : : .dev_id = 0,
3061 : : .type = ZXDH_RES_MSG,
3062 : : .sub_type = sub_type,
3063 : : .oper = opr,
3064 : : };
3065 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
3066 : : .msg = (void *)&msgcfg,
3067 : : .msg_len = sizeof(ZXDH_AGENT_SE_RES_MSG_T),
3068 : : };
3069 : :
3070 : 0 : rc = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_rsp_buff, buff_size);
3071 [ # # ]: 0 : if (rc != ZXDH_OK) {
3072 : 0 : PMD_DRV_LOG(ERR, "agent send msg failed");
3073 : 0 : return ZXDH_ERR;
3074 : : }
3075 : :
3076 : 0 : msg_result = p_rsp_buff[0];
3077 : 0 : PMD_DRV_LOG(DEBUG, "msg_result: 0x%x", msg_result);
3078 : 0 : zxdh_np_agent_msg_prt(msgcfg.type, msg_result);
3079 : :
3080 : 0 : return msg_result;
3081 : : }
3082 : :
3083 : : static uint32_t
3084 : 0 : zxdh_np_agent_channel_acl_index_request(uint32_t dev_id, uint32_t sdt_no,
3085 : : uint32_t vport, uint32_t *p_index)
3086 : : {
3087 : 0 : uint32_t rsp_buff[2] = {0};
3088 : 0 : ZXDH_AGENT_CHANNEL_ACL_MSG_T msgcfg = {
3089 : : .dev_id = 0,
3090 : : .type = ZXDH_ACL_MSG,
3091 : : .oper = ZXDH_ACL_INDEX_REQUEST,
3092 : : .vport = vport,
3093 : : .sdt_no = sdt_no,
3094 : : };
3095 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
3096 : : .msg = (void *)&msgcfg,
3097 : : .msg_len = sizeof(ZXDH_AGENT_CHANNEL_ACL_MSG_T),
3098 : : };
3099 : :
3100 : 0 : uint32_t rc = zxdh_np_agent_channel_sync_send(dev_id,
3101 : : &agent_msg, rsp_buff, sizeof(rsp_buff));
3102 [ # # ]: 0 : if (rc != ZXDH_OK) {
3103 : 0 : PMD_DRV_LOG(ERR, "agent send msg failed");
3104 : 0 : return ZXDH_ERR;
3105 : : }
3106 : :
3107 : 0 : uint32_t msg_result = rsp_buff[0];
3108 : 0 : uint32_t acl_index = rsp_buff[1];
3109 : :
3110 : 0 : PMD_DRV_LOG(DEBUG, "dev_id: %u, msg_result: %u", dev_id, msg_result);
3111 : 0 : PMD_DRV_LOG(DEBUG, "dev_id: %u, acl_index: %u", dev_id, acl_index);
3112 : :
3113 : 0 : *p_index = acl_index;
3114 : :
3115 : 0 : return msg_result;
3116 : : }
3117 : :
3118 : : static uint32_t
3119 : 0 : zxdh_np_agent_channel_acl_index_release(uint32_t dev_id, uint32_t rel_type,
3120 : : uint32_t sdt_no, uint32_t vport, uint32_t index)
3121 : : {
3122 : 0 : uint32_t rsp_buff[2] = {0};
3123 : 0 : ZXDH_AGENT_CHANNEL_ACL_MSG_T msgcfg = {
3124 : : .dev_id = 0,
3125 : : .type = ZXDH_ACL_MSG,
3126 : : .oper = rel_type,
3127 : : .index = index,
3128 : : .sdt_no = sdt_no,
3129 : : .vport = vport,
3130 : : };
3131 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
3132 : : .msg = (void *)&msgcfg,
3133 : : .msg_len = sizeof(ZXDH_AGENT_CHANNEL_ACL_MSG_T),
3134 : : };
3135 : :
3136 : 0 : uint32_t rc = zxdh_np_agent_channel_sync_send(dev_id,
3137 : : &agent_msg, rsp_buff, sizeof(rsp_buff));
3138 [ # # ]: 0 : if (rc != ZXDH_OK) {
3139 : 0 : PMD_DRV_LOG(ERR, "agent send msg failed");
3140 : 0 : return ZXDH_ERR;
3141 : : }
3142 : :
3143 : 0 : uint32_t msg_result = rsp_buff[0];
3144 : 0 : PMD_DRV_LOG(DEBUG, "msg_result: %u", msg_result);
3145 : :
3146 : 0 : return msg_result;
3147 : : }
3148 : :
3149 : : static ZXDH_DTB_MGR_T *
3150 : : zxdh_np_dtb_mgr_get(uint32_t dev_id)
3151 : : {
3152 : : if (ZXDH_DEV_SLOT_ID(dev_id) >= ZXDH_DEV_CHANNEL_MAX)
3153 : : return NULL;
3154 : : else
3155 : 0 : return p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)];
3156 : : }
3157 : :
3158 : : static uint32_t
3159 : 0 : zxdh_np_dtb_mgr_create(uint32_t dev_id)
3160 : : {
3161 [ # # ]: 0 : if (p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)] != NULL) {
3162 : 0 : PMD_DRV_LOG(ERR, "ErrorCode[0x%x]: Dma Manager"
3163 : : " is exist!!!", ZXDH_RC_DTB_MGR_EXIST);
3164 : 0 : return ZXDH_RC_DTB_MGR_EXIST;
3165 : : }
3166 : :
3167 : 0 : p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)] = rte_zmalloc(NULL, sizeof(ZXDH_DTB_MGR_T), 0);
3168 [ # # ]: 0 : if (p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)] == NULL) {
3169 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
3170 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
3171 : : }
3172 : :
3173 : : return ZXDH_OK;
3174 : : }
3175 : :
3176 : : static uint32_t
3177 : 0 : zxdh_np_dtb_soft_init(uint32_t dev_id)
3178 : : {
3179 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
3180 : :
3181 : : if (ZXDH_DEV_SLOT_ID(dev_id) >= ZXDH_DEV_CHANNEL_MAX)
3182 : : return 1;
3183 : :
3184 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
3185 [ # # ]: 0 : if (p_dtb_mgr == NULL) {
3186 : 0 : zxdh_np_dtb_mgr_create(dev_id);
3187 : :
3188 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
3189 [ # # ]: 0 : if (p_dtb_mgr == NULL)
3190 : 0 : return ZXDH_RC_DTB_MGR_NOT_EXIST;
3191 : : }
3192 : :
3193 : : return 0;
3194 : : }
3195 : :
3196 : : static uint32_t
3197 : 0 : zxdh_np_base_soft_init(uint32_t dev_id, ZXDH_SYS_INIT_CTRL_T *p_init_ctrl)
3198 : : {
3199 : 0 : uint32_t dev_id_array[ZXDH_DEV_CHANNEL_MAX] = {0};
3200 : : uint32_t rt;
3201 : : uint32_t access_type;
3202 : : uint32_t agent_flag;
3203 : :
3204 : 0 : rt = zxdh_np_dev_init();
3205 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_init");
3206 : :
3207 [ # # ]: 0 : if (p_init_ctrl->flags & ZXDH_INIT_FLAG_ACCESS_TYPE)
3208 : : access_type = ZXDH_DEV_ACCESS_TYPE_RISCV;
3209 : : else
3210 : : access_type = ZXDH_DEV_ACCESS_TYPE_PCIE;
3211 : :
3212 [ # # ]: 0 : if (p_init_ctrl->flags & ZXDH_INIT_FLAG_AGENT_FLAG)
3213 : : agent_flag = ZXDH_DEV_AGENT_ENABLE;
3214 : : else
3215 : : agent_flag = ZXDH_DEV_AGENT_DISABLE;
3216 : :
3217 : 0 : rt = zxdh_np_dev_add(dev_id,
3218 : : p_init_ctrl->device_type,
3219 : : access_type,
3220 : : p_init_ctrl->pcie_vir_baddr,
3221 : : p_init_ctrl->riscv_vir_baddr,
3222 : : p_init_ctrl->dma_vir_baddr,
3223 : : p_init_ctrl->dma_phy_baddr);
3224 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_add");
3225 : :
3226 : : rt = zxdh_np_dev_agent_status_set(dev_id, agent_flag);
3227 : 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_agent_status_set");
3228 : :
3229 : 0 : dev_id_array[0] = dev_id;
3230 : 0 : rt = zxdh_np_sdt_init(1, dev_id_array);
3231 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_sdt_init");
3232 : :
3233 : 0 : zxdh_np_ppu_parse_cls_bitmap(dev_id, ZXDH_PPU_CLS_ALL_START);
3234 : :
3235 : 0 : rt = zxdh_np_dtb_soft_init(dev_id);
3236 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dtb_soft_init");
3237 : :
3238 : 0 : return rt;
3239 : : }
3240 : :
3241 : : static void
3242 : : zxdh_np_dev_vport_set(uint32_t dev_id, uint32_t vport)
3243 : : {
3244 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
3245 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
3246 : :
3247 : : p_dev_mgr = &g_dev_mgr;
3248 : 0 : p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
3249 : 0 : p_dev_info->vport[ZXDH_DEV_PF_INDEX(dev_id)] = vport;
3250 : : }
3251 : :
3252 : : static void
3253 : : zxdh_np_dev_agent_addr_set(uint32_t dev_id, uint64_t agent_addr)
3254 : : {
3255 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
3256 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
3257 : :
3258 : : p_dev_mgr = &g_dev_mgr;
3259 : : p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
3260 : 0 : p_dev_info->agent_addr[ZXDH_DEV_PF_INDEX(dev_id)] = agent_addr;
3261 : : }
3262 : :
3263 : : static uint64_t
3264 : : zxdh_np_addr_calc(uint64_t pcie_vir_baddr, uint32_t bar_offset)
3265 : : {
3266 : : uint64_t np_addr;
3267 : :
3268 : 0 : np_addr = ((pcie_vir_baddr + bar_offset) > ZXDH_PCIE_NP_MEM_SIZE)
3269 : 0 : ? (pcie_vir_baddr + bar_offset - ZXDH_PCIE_NP_MEM_SIZE) : 0;
3270 : : return np_addr;
3271 : : }
3272 : :
3273 : : static uint64_t
3274 : : zxdh_np_fw_compatible_addr_calc(uint64_t pcie_vir_baddr, uint64_t compatible_offset)
3275 : : {
3276 : 0 : return (pcie_vir_baddr + compatible_offset);
3277 : : }
3278 : :
3279 : : static void
3280 : : zxdh_np_pf_fw_compatible_addr_set(uint32_t dev_id, uint64_t pcie_vir_baddr)
3281 : : {
3282 : : uint64_t compatible_offset = ZXDH_DPU_NO_DEBUG_PF_COMPAT_REG_OFFSET;
3283 : : uint64_t compatible_addr = 0;
3284 : :
3285 : : compatible_addr = zxdh_np_fw_compatible_addr_calc(pcie_vir_baddr, compatible_offset);
3286 : :
3287 : 0 : g_np_fw_compat_addr[ZXDH_DEV_SLOT_ID(dev_id)] = compatible_addr;
3288 : : }
3289 : :
3290 : : static void
3291 : : zxdh_np_fw_compatible_addr_get(uint32_t dev_id, uint64_t *p_compatible_addr)
3292 : : {
3293 : 0 : *p_compatible_addr = g_np_fw_compat_addr[ZXDH_DEV_SLOT_ID(dev_id)];
3294 : : }
3295 : :
3296 : : static void
3297 : : zxdh_np_fw_version_data_read(uint64_t compatible_base_addr,
3298 : : ZXDH_VERSION_COMPATIBLE_REG_T *p_fw_version_data, uint32_t module_id)
3299 : : {
3300 : : void *fw_addr = NULL;
3301 : : uint64_t module_compatible_addr = 0;
3302 : :
3303 : 0 : module_compatible_addr = compatible_base_addr +
3304 : : sizeof(ZXDH_VERSION_COMPATIBLE_REG_T) * (module_id - 1);
3305 : :
3306 : 0 : fw_addr = (void *)module_compatible_addr;
3307 : :
3308 : : memcpy(p_fw_version_data, fw_addr, sizeof(ZXDH_VERSION_COMPATIBLE_REG_T));
3309 : : }
3310 : :
3311 : : static void
3312 : : zxdh_np_fw_version_compatible_data_get(uint32_t dev_id,
3313 : : ZXDH_VERSION_COMPATIBLE_REG_T *p_version_compatible_value,
3314 : : uint32_t module_id)
3315 : : {
3316 : : uint64_t compatible_addr = 0;
3317 : :
3318 : : zxdh_np_fw_compatible_addr_get(dev_id, &compatible_addr);
3319 : :
3320 : : zxdh_np_fw_version_data_read(compatible_addr, p_version_compatible_value, module_id);
3321 : : }
3322 : :
3323 : : static uint32_t
3324 : 0 : zxdh_np_np_sdk_version_compatible_check(uint32_t dev_id)
3325 : : {
3326 : : ZXDH_VERSION_COMPATIBLE_REG_T fw_version = {0};
3327 : :
3328 : : zxdh_np_fw_version_compatible_data_get(dev_id, &fw_version, ZXDH_NPSDK_COMPAT_ITEM_ID);
3329 : :
3330 [ # # ]: 0 : if (fw_version.version_compatible_item != ZXDH_NPSDK_COMPAT_ITEM_ID) {
3331 : 0 : PMD_DRV_LOG(ERR, "version_compatible_item is not DH_NPSDK.");
3332 : 0 : return ZXDH_ERR;
3333 : : }
3334 : :
3335 [ # # ]: 0 : if (g_np_sdk_version.major != fw_version.major) {
3336 : 0 : PMD_DRV_LOG(ERR, "dh_npsdk major:%hhu: is not match fw:%hhu!",
3337 : : g_np_sdk_version.major, fw_version.major);
3338 : 0 : return ZXDH_ERR;
3339 : : }
3340 : :
3341 : : if (g_np_sdk_version.fw_minor > fw_version.fw_minor) {
3342 : : PMD_DRV_LOG(ERR, "dh_npsdk fw_minor:%hhu is higher than fw:%hhu!",
3343 : : g_np_sdk_version.fw_minor, fw_version.fw_minor);
3344 : : return ZXDH_ERR;
3345 : : }
3346 : :
3347 [ # # ]: 0 : if (g_np_sdk_version.drv_minor < fw_version.drv_minor) {
3348 : 0 : PMD_DRV_LOG(ERR, "dh_npsdk drv_minor:%hhu is lower than fw:%hhu!",
3349 : : g_np_sdk_version.drv_minor, fw_version.drv_minor);
3350 : 0 : return ZXDH_ERR;
3351 : : }
3352 : :
3353 : 0 : PMD_DRV_LOG(INFO, "dh_npsdk compatible check success!");
3354 : :
3355 : 0 : return ZXDH_OK;
3356 : : }
3357 : :
3358 : : static uint32_t
3359 : 0 : zxdh_np_pcie_bar_msg_num_get(uint32_t dev_id, uint32_t *p_bar_msg_num)
3360 : : {
3361 : : uint32_t rc = ZXDH_OK;
3362 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
3363 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
3364 : :
3365 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
3366 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
3367 : :
3368 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
3369 : 0 : rc = zxdh_np_agent_channel_pcie_bar_request(dev_id, p_bar_msg_num);
3370 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_pcie_bar_request");
3371 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3372 : :
3373 : 0 : return rc;
3374 : : }
3375 : :
3376 : : static uint32_t
3377 : 0 : zxdh_np_comm_read_bits(uint8_t *p_base, uint32_t base_size_bit,
3378 : : uint32_t *p_data, uint32_t start_bit, uint32_t end_bit)
3379 : : {
3380 : : uint32_t start_byte_index;
3381 : : uint32_t end_byte_index;
3382 : : uint32_t byte_num;
3383 : : uint32_t buffer_size;
3384 : : uint32_t len;
3385 : :
3386 [ # # ]: 0 : if (0 != (base_size_bit % 8))
3387 : : return 1;
3388 : :
3389 [ # # ]: 0 : if (start_bit > end_bit)
3390 : : return 1;
3391 : :
3392 [ # # ]: 0 : if (base_size_bit < end_bit)
3393 : : return 1;
3394 : :
3395 : 0 : len = end_bit - start_bit + 1;
3396 : 0 : buffer_size = base_size_bit / 8;
3397 [ # # ]: 0 : while (0 != (buffer_size & (buffer_size - 1)))
3398 : 0 : buffer_size += 1;
3399 : :
3400 : 0 : *p_data = 0;
3401 : 0 : end_byte_index = (end_bit >> 3);
3402 : 0 : start_byte_index = (start_bit >> 3);
3403 : :
3404 [ # # ]: 0 : if (start_byte_index == end_byte_index) {
3405 : 0 : *p_data = (uint32_t)(((p_base[start_byte_index] >> (7U - (end_bit & 7)))
3406 : 0 : & (0xff >> (8U - len))) & 0xff);
3407 : 0 : return 0;
3408 : : }
3409 : :
3410 [ # # ]: 0 : if (start_bit & 7) {
3411 : 0 : *p_data = (p_base[start_byte_index] & (0xff >> (start_bit & 7))) & UINT8_MAX;
3412 : 0 : start_byte_index++;
3413 : : }
3414 : :
3415 [ # # ]: 0 : for (byte_num = start_byte_index; byte_num < end_byte_index; byte_num++) {
3416 : 0 : *p_data <<= 8;
3417 : 0 : *p_data += p_base[byte_num];
3418 : : }
3419 : :
3420 : 0 : *p_data <<= 1 + (end_bit & 7);
3421 : 0 : *p_data += ((p_base[byte_num & (buffer_size - 1)] & (0xff << (7 - (end_bit & 7)))) >>
3422 : 0 : (7 - (end_bit & 7))) & 0xff;
3423 : :
3424 : 0 : return 0;
3425 : : }
3426 : :
3427 : : static uint32_t
3428 : : zxdh_np_comm_read_bits_ex(uint8_t *p_base, uint32_t base_size_bit,
3429 : : uint32_t *p_data, uint32_t msb_start_pos, uint32_t len)
3430 : : {
3431 : : uint32_t rtn;
3432 : :
3433 : 0 : rtn = zxdh_np_comm_read_bits(p_base,
3434 : : base_size_bit,
3435 : : p_data,
3436 : : (base_size_bit - 1 - msb_start_pos),
3437 : 0 : (base_size_bit - 1 - msb_start_pos + len - 1));
3438 : : return rtn;
3439 : : }
3440 : :
3441 : : static uint32_t
3442 : 0 : zxdh_np_reg_read(uint32_t dev_id, uint32_t reg_no,
3443 : : uint32_t m_offset, uint32_t n_offset, void *p_data)
3444 : : {
3445 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
3446 : : ZXDH_REG_T *p_reg_info = &g_dpp_reg_info[reg_no];
3447 : 0 : const ZXDH_FIELD_T *p_field_info = p_reg_info->p_fields;
3448 : : uint32_t rc = 0;
3449 : : uint32_t i;
3450 : : uint32_t addr = 0;
3451 : 0 : uint32_t reg_module = p_reg_info->module_no;
3452 : 0 : uint32_t reg_width = p_reg_info->width;
3453 : 0 : uint32_t reg_real_no = p_reg_info->reg_no;
3454 : 0 : uint32_t reg_type = p_reg_info->flags;
3455 : :
3456 : 0 : addr = zxdh_np_reg_get_reg_addr(reg_no, m_offset, n_offset);
3457 : :
3458 [ # # ]: 0 : if (reg_module == DTB4K) {
3459 : 0 : rc = p_reg_info->p_read_fun(dev_id, addr, p_buff);
3460 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "p_reg_info->p_read_fun");
3461 : : } else {
3462 : 0 : rc = zxdh_np_agent_channel_reg_read(dev_id,
3463 : : reg_type, reg_real_no, reg_width, addr, p_buff);
3464 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_reg_read");
3465 : : }
3466 : :
3467 : : if (!zxdh_np_comm_is_big_endian()) {
3468 [ # # ]: 0 : for (i = 0; i < p_reg_info->width / 4; i++) {
3469 : 0 : PMD_DRV_LOG(DEBUG, "data = 0x%08x.", p_buff[i]);
3470 : 0 : p_buff[i] = ZXDH_COMM_CONVERT32(p_buff[i]);
3471 : : }
3472 : : }
3473 : :
3474 [ # # ]: 0 : for (i = 0; i < p_reg_info->field_num; i++) {
3475 : 0 : rc = zxdh_np_comm_read_bits_ex((uint8_t *)p_buff,
3476 : 0 : p_reg_info->width * 8,
3477 : 0 : (uint32_t *)p_data + i,
3478 : 0 : p_field_info[i].msb_pos,
3479 : 0 : p_field_info[i].len);
3480 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_comm_read_bits_ex");
3481 : 0 : PMD_DRV_LOG(DEBUG, "dev_id %u(%u)(%u)is ok!", dev_id, m_offset, n_offset);
3482 : : }
3483 : :
3484 : 0 : return rc;
3485 : : }
3486 : :
3487 : : static uint32_t
3488 : 0 : zxdh_np_reg_read32(uint32_t dev_id, uint32_t reg_no,
3489 : : uint32_t m_offset, uint32_t n_offset, uint32_t *p_data)
3490 : : {
3491 : : uint32_t rc = 0;
3492 : : uint32_t addr = 0;
3493 : : ZXDH_REG_T *p_reg_info = &g_dpp_reg_info[reg_no];
3494 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
3495 : 0 : uint32_t reg_real_no = p_reg_info->reg_no;
3496 : 0 : uint32_t reg_type = p_reg_info->flags;
3497 : 0 : uint32_t reg_module = p_reg_info->module_no;
3498 : :
3499 : 0 : addr = zxdh_np_reg_get_reg_addr(reg_no, m_offset, n_offset);
3500 : :
3501 [ # # ]: 0 : if (reg_module == DTB4K) {
3502 : 0 : rc = p_reg_info->p_read_fun(dev_id, addr, p_data);
3503 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "p_reg_info->p_read_fun");
3504 : : } else {
3505 : 0 : rc = zxdh_np_agent_channel_reg_read(dev_id, reg_type, reg_real_no, 4, addr, p_buff);
3506 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_reg_read");
3507 : 0 : *p_data = p_buff[0];
3508 : : }
3509 : :
3510 : 0 : return rc;
3511 : : }
3512 : :
3513 : : static uint32_t
3514 : 0 : zxdh_np_dtb_queue_vm_info_get(uint32_t dev_id,
3515 : : uint32_t queue_id,
3516 : : ZXDH_DTB_QUEUE_VM_INFO_T *p_vm_info)
3517 : : {
3518 : : uint32_t rc = 0;
3519 : : uint32_t dtb_epid_v_func_reg = ZXDH_SYS_DTB_BASE_ADDR +
3520 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0010;
3521 : 0 : uint32_t epid_v_func = 0;
3522 : :
3523 : 0 : rc = zxdh_np_dev_read_channel(dev_id, dtb_epid_v_func_reg + queue_id * 32, 1, &epid_v_func);
3524 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_read_channel");
3525 : :
3526 : 0 : p_vm_info->dbi_en = (epid_v_func >> 31 & 0x1);
3527 : 0 : p_vm_info->queue_en = (epid_v_func >> 30 & 0x1);
3528 : 0 : p_vm_info->epid = (epid_v_func >> 24 & 0xF);
3529 : 0 : p_vm_info->vfunc_num = (epid_v_func >> 16 & 0xFF);
3530 : 0 : p_vm_info->vector = (epid_v_func >> 8 & 0x7);
3531 : 0 : p_vm_info->func_num = (epid_v_func >> 5 & 0x7);
3532 : 0 : p_vm_info->vfunc_active = (epid_v_func & 0x1);
3533 : :
3534 : 0 : return rc;
3535 : : }
3536 : :
3537 : : static uint32_t
3538 : 0 : zxdh_np_comm_write_bits(uint8_t *p_base, uint32_t base_size_bit,
3539 : : uint32_t data, uint32_t start_bit, uint32_t end_bit)
3540 : : {
3541 : : uint32_t start_byte_index;
3542 : : uint32_t end_byte_index;
3543 : : uint8_t mask_value;
3544 : : uint32_t byte_num;
3545 : : uint32_t buffer_size;
3546 : :
3547 [ # # ]: 0 : if (0 != (base_size_bit % 8))
3548 : : return 1;
3549 : :
3550 [ # # ]: 0 : if (start_bit > end_bit)
3551 : : return 1;
3552 : :
3553 [ # # ]: 0 : if (base_size_bit < end_bit)
3554 : : return 1;
3555 : :
3556 : 0 : buffer_size = base_size_bit / 8;
3557 : :
3558 [ # # ]: 0 : while (0 != (buffer_size & (buffer_size - 1)))
3559 : 0 : buffer_size += 1;
3560 : :
3561 : 0 : end_byte_index = (end_bit >> 3);
3562 : 0 : start_byte_index = (start_bit >> 3);
3563 : :
3564 [ # # ]: 0 : if (start_byte_index == end_byte_index) {
3565 : 0 : mask_value = ((0xFE << (7 - (start_bit & 7))) & 0xff);
3566 : 0 : mask_value |= (((1 << (7 - (end_bit & 7))) - 1) & 0xff);
3567 : 0 : p_base[end_byte_index] &= mask_value;
3568 : 0 : p_base[end_byte_index] |= (((data << (7 - (end_bit & 7)))) & 0xff);
3569 : 0 : return 0;
3570 : : }
3571 : :
3572 [ # # ]: 0 : if (7 != (end_bit & 7)) {
3573 : 0 : mask_value = ((0x7f >> (end_bit & 7)) & 0xff);
3574 : 0 : p_base[end_byte_index] &= mask_value;
3575 : 0 : p_base[end_byte_index] |= ((data << (7 - (end_bit & 7))) & 0xff);
3576 : 0 : end_byte_index--;
3577 : 0 : data >>= 1 + (end_bit & 7);
3578 : : }
3579 : :
3580 [ # # ]: 0 : for (byte_num = end_byte_index; byte_num > start_byte_index; byte_num--) {
3581 : 0 : p_base[byte_num & (buffer_size - 1)] = data & 0xff;
3582 : 0 : data >>= 8;
3583 : : }
3584 : :
3585 : 0 : mask_value = ((0xFE << (7 - (start_bit & 7))) & 0xff);
3586 : 0 : p_base[byte_num] &= mask_value;
3587 : 0 : p_base[byte_num] |= data;
3588 : :
3589 : 0 : return 0;
3590 : : }
3591 : :
3592 : : static uint32_t
3593 : : zxdh_np_comm_write_bits_ex(uint8_t *p_base,
3594 : : uint32_t base_size_bit,
3595 : : uint32_t data,
3596 : : uint32_t msb_start_pos,
3597 : : uint32_t len)
3598 : : {
3599 : : uint32_t rtn;
3600 : :
3601 : 0 : rtn = zxdh_np_comm_write_bits(p_base,
3602 : : base_size_bit,
3603 : : data,
3604 : : (base_size_bit - 1 - msb_start_pos),
3605 : 0 : (base_size_bit - 1 - msb_start_pos + len - 1));
3606 : :
3607 : : return rtn;
3608 : : }
3609 : :
3610 : : static uint32_t
3611 : 0 : zxdh_np_reg_write(uint32_t dev_id, uint32_t reg_no,
3612 : : uint32_t m_offset, uint32_t n_offset, void *p_data)
3613 : : {
3614 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
3615 : : ZXDH_REG_T *p_reg_info = &g_dpp_reg_info[reg_no];
3616 : 0 : const ZXDH_FIELD_T *p_field_info = p_reg_info->p_fields;
3617 : : uint32_t temp_data;
3618 : : uint32_t rc = ZXDH_OK;
3619 : : uint32_t i;
3620 : : uint32_t addr = 0;
3621 : 0 : uint32_t reg_module = p_reg_info->module_no;
3622 : 0 : uint32_t reg_width = p_reg_info->width;
3623 : 0 : uint32_t reg_type = p_reg_info->flags;
3624 : 0 : uint32_t reg_real_no = p_reg_info->reg_no;
3625 : :
3626 [ # # ]: 0 : for (i = 0; i < p_reg_info->field_num; i++) {
3627 [ # # ]: 0 : if (p_field_info[i].len <= 32) {
3628 : 0 : temp_data = *((uint32_t *)p_data + i) &
3629 [ # # ]: 0 : zxdh_np_comm_get_bit_mask(p_field_info[i].len);
3630 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_buff,
3631 : 0 : p_reg_info->width * 8,
3632 : : temp_data,
3633 : 0 : p_field_info[i].msb_pos,
3634 : : p_field_info[i].len);
3635 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_comm_write_bits_ex");
3636 : : }
3637 : : }
3638 : :
3639 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_np_comm_write_bits_ex data = 0x%08x.", p_buff[0]);
3640 : :
3641 : : if (!zxdh_np_comm_is_big_endian()) {
3642 [ # # ]: 0 : for (i = 0; i < p_reg_info->width / 4; i++) {
3643 : 0 : p_buff[i] = ZXDH_COMM_CONVERT32(p_buff[i]);
3644 : :
3645 : 0 : PMD_DRV_LOG(DEBUG, "ZXDH_COMM_CONVERT32 data = 0x%08x.",
3646 : : p_buff[i]);
3647 : : }
3648 : : }
3649 : :
3650 : 0 : addr = zxdh_np_reg_get_reg_addr(reg_no, m_offset, n_offset);
3651 : :
3652 : 0 : PMD_DRV_LOG(DEBUG, "reg_no = %u. m_offset = %u n_offset = %u",
3653 : : reg_no, m_offset, n_offset);
3654 : 0 : PMD_DRV_LOG(DEBUG, "baseaddr = 0x%08x.", addr);
3655 : :
3656 [ # # ]: 0 : if (reg_module == DTB4K) {
3657 : 0 : rc = p_reg_info->p_write_fun(dev_id, addr, p_buff);
3658 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "p_reg_info->p_write_fun");
3659 : : } else {
3660 : 0 : rc = zxdh_np_agent_channel_reg_write(dev_id,
3661 : : reg_type, reg_real_no, reg_width, addr, p_buff);
3662 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_reg_write");
3663 : : }
3664 : :
3665 : 0 : return rc;
3666 : : }
3667 : :
3668 : : static uint32_t
3669 : 0 : zxdh_np_dtb_queue_vm_info_set(uint32_t dev_id,
3670 : : uint32_t queue_id,
3671 : : ZXDH_DTB_QUEUE_VM_INFO_T *p_vm_info)
3672 : : {
3673 : : uint32_t rc = 0;
3674 : : ZXDH_DTB4K_DTB_ENQ_CFG_EPID_V_FUNC_NUM_0_127_T vm_info = {0};
3675 : :
3676 : 0 : vm_info.dbi_en = p_vm_info->dbi_en;
3677 : 0 : vm_info.queue_en = p_vm_info->queue_en;
3678 : 0 : vm_info.cfg_epid = p_vm_info->epid;
3679 : 0 : vm_info.cfg_vector = p_vm_info->vector;
3680 : 0 : vm_info.cfg_vfunc_num = p_vm_info->vfunc_num;
3681 : 0 : vm_info.cfg_func_num = p_vm_info->func_num;
3682 : 0 : vm_info.cfg_vfunc_active = p_vm_info->vfunc_active;
3683 : :
3684 : 0 : rc = zxdh_np_reg_write(dev_id, ZXDH_DTB_CFG_EPID_V_FUNC_NUM,
3685 : : 0, queue_id, &vm_info);
3686 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_reg_write");
3687 : :
3688 : 0 : return rc;
3689 : : }
3690 : :
3691 : : static uint32_t
3692 : 0 : zxdh_np_dtb_queue_unused_item_num_get(uint32_t dev_id,
3693 : : uint32_t queue_id,
3694 : : uint32_t *p_item_num)
3695 : : {
3696 : : uint32_t rc;
3697 : :
3698 : 0 : rc = zxdh_np_reg_read(dev_id, ZXDH_DTB_INFO_QUEUE_BUF_SPACE,
3699 : : 0, queue_id, p_item_num);
3700 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_reg_read");
3701 : 0 : return rc;
3702 : : }
3703 : :
3704 : : static uint32_t
3705 : 0 : zxdh_np_dtb_queue_id_free(uint32_t dev_id,
3706 : : uint32_t queue_id)
3707 : : {
3708 : 0 : uint32_t item_num = 0;
3709 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
3710 : : uint32_t rc;
3711 : :
3712 : 0 : p_dtb_mgr = p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)];
3713 [ # # ]: 0 : if (p_dtb_mgr == NULL)
3714 : : return 1;
3715 : :
3716 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &item_num);
3717 : :
3718 [ # # ]: 0 : if (item_num != ZXDH_DTB_QUEUE_ITEM_NUM_MAX)
3719 : : return ZXDH_RC_DTB_QUEUE_IS_WORKING;
3720 : :
3721 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 0;
3722 : 0 : p_dtb_mgr->queue_info[queue_id].vport = 0;
3723 : 0 : p_dtb_mgr->queue_info[queue_id].vector = 0;
3724 : :
3725 : 0 : memset(&p_dtb_mgr->queue_info[queue_id].tab_up, 0, sizeof(ZXDH_DTB_TAB_UP_INFO_T));
3726 : 0 : memset(&p_dtb_mgr->queue_info[queue_id].tab_down, 0, sizeof(ZXDH_DTB_TAB_DOWN_INFO_T));
3727 : :
3728 : 0 : return rc;
3729 : : }
3730 : :
3731 : : static ZXDH_RB_CFG *
3732 : : zxdh_np_dtb_dump_addr_rb_get(uint32_t dev_id, uint32_t queue_id)
3733 : : {
3734 : 0 : return g_dtb_dump_addr_rb[ZXDH_DEV_SLOT_ID(dev_id)][queue_id];
3735 : : }
3736 : :
3737 : : static uint32_t
3738 : : zxdh_np_dtb_dump_addr_rb_set(uint32_t dev_id, uint32_t queue_id, ZXDH_RB_CFG *p_dump_addr_rb)
3739 : : {
3740 : 0 : g_dtb_dump_addr_rb[ZXDH_DEV_SLOT_ID(dev_id)][queue_id] = p_dump_addr_rb;
3741 : : return ZXDH_OK;
3742 : : }
3743 : :
3744 : : static uint32_t
3745 : 0 : zxdh_np_dtb_dump_sdt_addr_clear(uint32_t dev_id,
3746 : : uint32_t queue_id,
3747 : : uint32_t sdt_no)
3748 : : {
3749 : : uint32_t rc = ZXDH_OK;
3750 : :
3751 : 0 : ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {0};
3752 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
3753 : :
3754 : 0 : dtb_dump_addr_info.sdt_no = sdt_no;
3755 : :
3756 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
3757 : 0 : rc = zxdh_np_se_apt_rb_delete(p_dtb_dump_addr_rb, &dtb_dump_addr_info,
3758 : : sizeof(ZXDH_DTB_ADDR_INFO_T));
3759 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_apt_rb_delete");
3760 : :
3761 : 0 : return rc;
3762 : : }
3763 : :
3764 : : static uint32_t
3765 : 0 : zxdh_np_dtb_dump_addr_rb_destroy(uint32_t dev_id, uint32_t queue_id)
3766 : : {
3767 : : uint32_t rc = ZXDH_OK;
3768 : : ZXDH_D_NODE *p_node = NULL;
3769 : : ZXDH_RB_TN *p_rb_tn = NULL;
3770 : : ZXDH_DTB_ADDR_INFO_T *p_rbkey = NULL;
3771 : : ZXDH_D_HEAD *p_head_dtb_rb = NULL;
3772 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
3773 : : uint32_t sdt_no = 0;
3774 : :
3775 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
3776 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dtb_dump_addr_rb);
3777 : :
3778 : : p_head_dtb_rb = &p_dtb_dump_addr_rb->tn_list;
3779 : :
3780 [ # # ]: 0 : while (p_head_dtb_rb->used) {
3781 : 0 : p_node = p_head_dtb_rb->p_next;
3782 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
3783 : 0 : p_rbkey = (ZXDH_DTB_ADDR_INFO_T *)p_rb_tn->p_key;
3784 : :
3785 : 0 : sdt_no = p_rbkey->sdt_no;
3786 : 0 : rc = zxdh_np_dtb_dump_sdt_addr_clear(dev_id, queue_id, sdt_no);
3787 : :
3788 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
3789 : 0 : PMD_DRV_LOG(ERR, "dtb dump delete key is not exist,"
3790 : : "std:%u", sdt_no);
3791 : : else
3792 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_clear");
3793 : : }
3794 : :
3795 : 0 : rc = zxdh_comm_rb_destroy(p_dtb_dump_addr_rb);
3796 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
3797 : :
3798 : 0 : return rc;
3799 : : }
3800 : :
3801 : : static uint32_t
3802 : 0 : zxdh_np_dtb_dump_addr_rb_init(uint32_t dev_id, uint32_t queue_id)
3803 : : {
3804 : : uint32_t rc = ZXDH_OK;
3805 : :
3806 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
3807 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
3808 : :
3809 [ # # ]: 0 : if (p_dtb_dump_addr_rb == NULL) {
3810 : 0 : p_dtb_dump_addr_rb = rte_zmalloc(NULL, sizeof(ZXDH_RB_CFG), 0);
3811 [ # # ]: 0 : if (p_dtb_dump_addr_rb == NULL) {
3812 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
3813 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
3814 : : }
3815 : :
3816 : : rc = zxdh_np_dtb_dump_addr_rb_set(dev_id, queue_id, p_dtb_dump_addr_rb);
3817 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_rb_set");
3818 : : }
3819 : :
3820 : 0 : rc = zxdh_comm_rb_init(p_dtb_dump_addr_rb, 0,
3821 : : sizeof(ZXDH_DTB_ADDR_INFO_T), zxdh_np_se_apt_key_default_cmp);
3822 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
3823 : :
3824 : : return rc;
3825 : : }
3826 : :
3827 : : static uint32_t
3828 : 0 : zxdh_np_dtb_queue_request(uint32_t dev_id, char p_name[32],
3829 : : uint16_t vport, uint32_t *p_queue_id)
3830 : : {
3831 : : uint32_t rc = ZXDH_OK;
3832 : 0 : uint32_t queue_id = 0xFF;
3833 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
3834 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
3835 : 0 : uint32_t vport_info = (uint32_t)vport;
3836 : :
3837 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
3838 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
3839 : :
3840 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
3841 : :
3842 : 0 : rc = zxdh_np_agent_channel_dtb_queue_request(dev_id, p_name, vport_info, &queue_id);
3843 [ # # ]: 0 : if (rc == ZXDH_RC_DTB_QUEUE_RES_EMPTY) {
3844 : 0 : PMD_DRV_LOG(ERR, "dtb queue is locked full.");
3845 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3846 : 0 : return ZXDH_RC_DTB_QUEUE_RES_EMPTY;
3847 : : }
3848 : :
3849 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3850 : :
3851 : 0 : PMD_DRV_LOG(DEBUG, "dtb request queue is %u.", queue_id);
3852 : :
3853 : 0 : rc = zxdh_np_dtb_dump_addr_rb_init(dev_id, queue_id);
3854 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_rb_init");
3855 : :
3856 : 0 : *p_queue_id = queue_id;
3857 : :
3858 : 0 : PMD_DRV_LOG(INFO, "dev_id %u vport 0x%x name %s queue_id %u done.",
3859 : : dev_id, vport_info, p_name, queue_id);
3860 : :
3861 : 0 : return rc;
3862 : : }
3863 : :
3864 : : static uint32_t
3865 : 0 : zxdh_np_dtb_queue_release(uint32_t devid,
3866 : : char pname[32],
3867 : : uint32_t queueid)
3868 : : {
3869 : : uint32_t rc = ZXDH_OK;
3870 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
3871 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
3872 : :
3873 : 0 : rc = zxdh_np_dev_opr_spinlock_get(devid, (uint32_t)spinlock, &p_dtb_spinlock);
3874 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dev_opr_spinlock_get");
3875 : :
3876 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
3877 : :
3878 : 0 : rc = zxdh_np_agent_channel_dtb_queue_release(devid, pname, queueid);
3879 : :
3880 [ # # ]: 0 : if (rc == ZXDH_RC_DTB_QUEUE_NOT_ALLOC) {
3881 : 0 : PMD_DRV_LOG(ERR, "dtb queue id %u not request.", queueid);
3882 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3883 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ALLOC;
3884 : : }
3885 : :
3886 [ # # ]: 0 : if (rc == ZXDH_RC_DTB_QUEUE_NAME_ERROR) {
3887 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u name error.", queueid);
3888 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3889 : 0 : return ZXDH_RC_DTB_QUEUE_NAME_ERROR;
3890 : : }
3891 : :
3892 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3893 : :
3894 : 0 : rc = zxdh_np_dtb_dump_addr_rb_destroy(devid, queueid);
3895 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dtb_dump_addr_rb_destroy");
3896 : :
3897 : 0 : rc = zxdh_np_dtb_queue_id_free(devid, queueid);
3898 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dtb_queue_id_free");
3899 : :
3900 : 0 : PMD_DRV_LOG(INFO, "release queueid %u", queueid);
3901 : :
3902 : 0 : return rc;
3903 : : }
3904 : :
3905 : : static void
3906 : : zxdh_np_dtb_mgr_destroy(uint32_t dev_id)
3907 : : {
3908 [ # # ]: 0 : if (p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)] != NULL) {
3909 : 0 : rte_free(p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)]);
3910 : 0 : p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)] = NULL;
3911 : : }
3912 : : }
3913 : :
3914 : : static void
3915 : 0 : zxdh_np_sdt_mgr_destroy(uint32_t dev_id)
3916 : : {
3917 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_tbl_temp = NULL;
3918 : : ZXDH_SDT_MGR_T *p_sdt_mgr = NULL;
3919 : :
3920 : 0 : p_sdt_tbl_temp = ZXDH_SDT_SOFT_TBL_GET(dev_id);
3921 : : p_sdt_mgr = ZXDH_SDT_MGR_PTR_GET();
3922 : :
3923 : 0 : rte_free(p_sdt_tbl_temp);
3924 : :
3925 : 0 : ZXDH_SDT_SOFT_TBL_GET(dev_id) = NULL;
3926 : :
3927 : 0 : p_sdt_mgr->channel_num--;
3928 : 0 : }
3929 : :
3930 : : static void
3931 : 0 : zxdh_np_dev_del(uint32_t dev_id)
3932 : : {
3933 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
3934 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
3935 : :
3936 : : p_dev_mgr = &g_dev_mgr;
3937 : 0 : p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
3938 : :
3939 [ # # ]: 0 : if (p_dev_info != NULL) {
3940 : 0 : rte_free(p_dev_info);
3941 : 0 : p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)] = NULL;
3942 : 0 : p_dev_mgr->device_num--;
3943 : : }
3944 : 0 : }
3945 : :
3946 : : static uint32_t
3947 : 0 : zxdh_np_hash_soft_all_entry_delete(ZXDH_SE_CFG *p_se_cfg, uint32_t hash_id)
3948 : : {
3949 : : uint32_t rc = 0;
3950 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
3951 : : uint8_t table_id = 0;
3952 : : uint32_t bulk_id = 0;
3953 : :
3954 : : ZXDH_D_NODE *p_node = NULL;
3955 : : ZXDH_RB_TN *p_rb_tn = NULL;
3956 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
3957 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
3958 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
3959 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
3960 : : ZXDH_FUNC_ID_INFO *p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, hash_id);
3961 : 0 : ZXDH_HASH_CFG *p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
3962 : : ZXDH_D_HEAD *p_head_hash_rb = &p_hash_cfg->hash_rb.tn_list;
3963 : :
3964 [ # # ]: 0 : while (p_head_hash_rb->used) {
3965 : 0 : p_node = p_head_hash_rb->p_next;
3966 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
3967 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_rb_tn->p_key;
3968 : 0 : table_id = ZXDH_GET_HASH_TBL_ID(p_rbkey->key);
3969 : 0 : bulk_id = ((table_id >> 2) & 0x7);
3970 : :
3971 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, p_rbkey, &p_rb_tn_rtn);
3972 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL) {
3973 : 0 : p_hash_cfg->hash_stat.delete_fail++;
3974 : 0 : PMD_DRV_LOG(DEBUG, "Error!there is not item in hash!");
3975 : 0 : return ZXDH_HASH_RC_DEL_SRHFAIL;
3976 : : }
3977 : :
3978 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
3979 : 0 : p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
3980 [ # # ]: 0 : p_item = p_rbkey_rtn->p_item_info;
3981 : :
3982 : : rc = zxdh_comm_double_link_del(&p_rbkey_rtn->entry_dn, &p_item->item_list);
3983 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
3984 : 0 : p_item->wrt_mask &= ~(ZXDH_GET_HASH_ENTRY_MASK(p_rbkey_rtn->entry_size,
3985 : 0 : p_rbkey_rtn->entry_pos)) & 0xF;
3986 : :
3987 [ # # ]: 0 : if (p_item->item_list.used == 0) {
3988 [ # # ]: 0 : if (p_item->item_type == ZXDH_ITEM_DDR_256 ||
3989 : : p_item->item_type == ZXDH_ITEM_DDR_512) {
3990 : 0 : p_hash_cfg->p_bulk_ddr_info[bulk_id]->p_item_array
3991 : 0 : [p_item->item_index] = NULL;
3992 : 0 : rte_free(p_item);
3993 : : } else {
3994 : 0 : p_item->valid = 0;
3995 : : }
3996 : : }
3997 : :
3998 : 0 : rte_free(p_rbkey_rtn);
3999 : 0 : rte_free(p_rb_tn_rtn);
4000 : 0 : p_hash_cfg->hash_stat.delete_ok++;
4001 : : }
4002 : :
4003 : : return rc;
4004 : : }
4005 : :
4006 : : static uint32_t
4007 : 0 : zxdh_np_hash_zcam_resource_deinit(ZXDH_HASH_CFG *p_hash_cfg)
4008 : : {
4009 : : uint32_t rc = 0;
4010 : 0 : uint32_t dev_id = p_hash_cfg->p_se_info->dev_id;
4011 : : uint32_t i = 0;
4012 : :
4013 : : ZXDH_D_NODE *p_node = NULL;
4014 : : ZXDH_D_HEAD *p_head = &p_hash_cfg->hash_shareram.zcell_free_list;
4015 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
4016 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
4017 : :
4018 [ # # ]: 0 : while (p_head->used) {
4019 [ # # ]: 0 : p_node = p_head->p_next;
4020 : :
4021 : : rc = zxdh_comm_double_link_del(p_node, p_head);
4022 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
4023 : 0 : p_zcell_cfg = (ZXDH_SE_ZCELL_CFG *)p_node->data;
4024 : 0 : p_zcell_cfg->is_used = 0;
4025 : 0 : p_zcell_cfg->flag = 0;
4026 : : }
4027 : :
4028 : : p_head = &p_hash_cfg->hash_shareram.zblk_list;
4029 : :
4030 [ # # ]: 0 : while (p_head->used) {
4031 [ # # ]: 0 : p_node = p_head->p_next;
4032 : :
4033 : : rc = zxdh_comm_double_link_del(p_node, p_head);
4034 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
4035 : :
4036 : 0 : p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_hash_cfg->p_se_info,
4037 : : ((ZXDH_SE_ZBLK_CFG *)p_node->data)->zblk_idx);
4038 : 0 : p_zblk_cfg->is_used = 0;
4039 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++)
4040 : 0 : p_zblk_cfg->zreg_info[i].flag = 0;
4041 : : }
4042 : :
4043 : 0 : return rc;
4044 : : }
4045 : :
4046 : : static uint32_t
4047 : 0 : zxdh_np_se_fun_deinit(ZXDH_SE_CFG *p_se_cfg,
4048 : : uint8_t id,
4049 : : uint32_t fun_type)
4050 : : {
4051 : 0 : ZXDH_FUNC_ID_INFO *p_fun_info = ZXDH_GET_FUN_INFO(p_se_cfg, id);
4052 : :
4053 [ # # ]: 0 : if (p_fun_info->is_used == 0) {
4054 : 0 : PMD_DRV_LOG(ERR, " Error[0x%x], fun_id [%u] is already deinit!",
4055 : : ZXDH_SE_RC_FUN_INVALID, id);
4056 : 0 : return ZXDH_OK;
4057 : : }
4058 : :
4059 [ # # ]: 0 : switch (fun_type) {
4060 : 0 : case (ZXDH_FUN_HASH):
4061 [ # # ]: 0 : if (p_fun_info->fun_ptr) {
4062 : 0 : rte_free(p_fun_info->fun_ptr);
4063 : 0 : p_fun_info->fun_ptr = NULL;
4064 : : }
4065 : : break;
4066 : 0 : default:
4067 : 0 : PMD_DRV_LOG(ERR, " Error, unrecgnized fun_type[ %u] ", fun_type);
4068 : : RTE_ASSERT(0);
4069 : 0 : return ZXDH_SE_RC_BASE;
4070 : : }
4071 : :
4072 : 0 : p_fun_info->fun_id = id;
4073 : 0 : p_fun_info->is_used = 0;
4074 : :
4075 : 0 : return ZXDH_OK;
4076 : : }
4077 : :
4078 : : static uint32_t
4079 : 0 : zxdh_np_one_hash_soft_uninstall(uint32_t dev_id, uint32_t hash_id)
4080 : : {
4081 : : uint32_t rc = 0;
4082 : : uint32_t i = 0;
4083 : :
4084 : : ZXDH_D_NODE *p_node = NULL;
4085 : 0 : ZXDH_SE_CFG *p_se_cfg = dpp_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
4086 : : ZXDH_RB_TN *p_rb_tn = NULL;
4087 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
4088 : : HASH_DDR_CFG *p_rbkey = NULL;
4089 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
4090 : : ZXDH_FUNC_ID_INFO *p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, hash_id);
4091 : : ZXDH_D_HEAD *p_head_ddr_cfg_rb = NULL;
4092 : : HASH_DDR_CFG *p_temp_rbkey = NULL;
4093 : :
4094 [ # # ]: 0 : if (p_func_info->is_used == 0) {
4095 : 0 : PMD_DRV_LOG(ERR, "Error[0x%x], fun_id [%u] is not init!",
4096 : : ZXDH_SE_RC_FUN_INVALID, hash_id);
4097 : 0 : return ZXDH_OK;
4098 : : }
4099 : :
4100 : 0 : rc = zxdh_np_hash_soft_all_entry_delete(p_se_cfg, hash_id);
4101 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_soft_all_entry_delete");
4102 : :
4103 : 0 : p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
4104 [ # # ]: 0 : for (i = 0; i < ZXDH_HASH_BULK_NUM; i++) {
4105 [ # # ]: 0 : if (p_hash_cfg->hash_stat.p_bulk_zcam_mono[i] != NULL) {
4106 : 0 : rte_free((&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[i]);
4107 : 0 : (&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[i] = NULL;
4108 : : }
4109 : : }
4110 : :
4111 : : p_head_ddr_cfg_rb = &p_hash_cfg->ddr_cfg_rb.tn_list;
4112 [ # # ]: 0 : while (p_head_ddr_cfg_rb->used) {
4113 : 0 : p_node = p_head_ddr_cfg_rb->p_next;
4114 : :
4115 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
4116 : 0 : p_rbkey = p_rb_tn->p_key;
4117 : :
4118 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->ddr_cfg_rb, p_rbkey, &p_rb_tn_rtn);
4119 : :
4120 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL)
4121 : 0 : PMD_DRV_LOG(ERR, "ddr_cfg_rb delete key is not exist, key: 0x");
4122 : : else
4123 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_delete");
4124 : :
4125 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
4126 : 0 : p_temp_rbkey = (HASH_DDR_CFG *)(p_rb_tn_rtn->p_key);
4127 : 0 : rte_free(p_temp_rbkey->p_item_array);
4128 : 0 : p_temp_rbkey->p_item_array = NULL;
4129 : 0 : rte_free(p_temp_rbkey);
4130 : 0 : rte_free(p_rb_tn_rtn);
4131 : : }
4132 : :
4133 : 0 : rc = zxdh_np_hash_zcam_resource_deinit(p_hash_cfg);
4134 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_zcam_resource_deinit");
4135 : :
4136 : 0 : rc = zxdh_np_se_fun_deinit(p_se_cfg, (hash_id & 0xff), ZXDH_FUN_HASH);
4137 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_fun_deinit");
4138 : :
4139 : 0 : memset(g_tbl_id_info[ZXDH_DEV_SLOT_ID(dev_id)][hash_id], 0,
4140 : : ZXDH_HASH_TBL_ID_NUM * sizeof(ZXDH_HASH_TBL_ID_INFO));
4141 : :
4142 : 0 : return rc;
4143 : : }
4144 : :
4145 : : static uint32_t
4146 : 0 : zxdh_np_hash_soft_uninstall(uint32_t dev_id)
4147 : : {
4148 : : uint32_t rc = ZXDH_OK;
4149 : : uint32_t hash_id = 0;
4150 : :
4151 [ # # ]: 0 : for (hash_id = 0; hash_id < ZXDH_HASH_FUNC_ID_NUM; hash_id++) {
4152 : 0 : rc = zxdh_np_one_hash_soft_uninstall(dev_id, hash_id);
4153 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_one_hash_soft_uninstall");
4154 : : }
4155 : :
4156 : 0 : return rc;
4157 : : }
4158 : :
4159 : : static uint32_t
4160 : 0 : zxdh_np_acl_cfg_get(uint32_t dev_id, ZXDH_ACL_CFG_EX_T **p_acl_cfg)
4161 : : {
4162 [ # # ]: 0 : if (g_p_acl_ex_cfg[ZXDH_DEV_SLOT_ID(dev_id)] == NULL) {
4163 : 0 : PMD_DRV_LOG(ERR, "etcam_is not init!");
4164 : : RTE_ASSERT(0);
4165 : 0 : return ZXDH_ACL_RC_ETCAMID_NOT_INIT;
4166 : : }
4167 : :
4168 : 0 : *p_acl_cfg = g_p_acl_ex_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
4169 : :
4170 : 0 : return ZXDH_OK;
4171 : : }
4172 : :
4173 : : static uint32_t
4174 : 0 : zxdh_np_acl_res_destroy(uint32_t dev_id)
4175 : : {
4176 : : uint32_t table_id = 0;
4177 : : uint32_t as_enable = 0;
4178 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
4179 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
4180 : :
4181 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
4182 : :
4183 [ # # ]: 0 : if (!p_acl_cfg->acl_etcamids.is_valid) {
4184 : 0 : PMD_DRV_LOG(DEBUG, "etcam is not init!");
4185 : 0 : return ZXDH_OK;
4186 : : }
4187 : :
4188 [ # # ]: 0 : for (table_id = ZXDH_ACL_TBL_ID_MIN; table_id <= ZXDH_ACL_TBL_ID_MAX; table_id++) {
4189 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + table_id;
4190 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
4191 : 0 : PMD_DRV_LOG(DEBUG, "table_id[ %u ] is not used!", table_id);
4192 : 0 : continue;
4193 : : }
4194 : :
4195 : 0 : zxdh_comm_rb_destroy(&p_tbl_cfg->acl_rb);
4196 : :
4197 : 0 : as_enable = p_tbl_cfg->as_enable;
4198 [ # # ]: 0 : if (as_enable) {
4199 [ # # ]: 0 : if (p_tbl_cfg->as_rslt_buff) {
4200 : 0 : rte_free(p_tbl_cfg->as_rslt_buff);
4201 : 0 : p_tbl_cfg->as_rslt_buff = NULL;
4202 : : }
4203 : : }
4204 : :
4205 [ # # ]: 0 : if (p_tbl_cfg->block_array) {
4206 : 0 : rte_free(p_tbl_cfg->block_array);
4207 : 0 : p_tbl_cfg->block_array = NULL;
4208 : : }
4209 : :
4210 : 0 : p_tbl_cfg->is_used = 0;
4211 : : }
4212 : :
4213 : 0 : p_acl_cfg->acl_etcamids.is_valid = 0;
4214 : :
4215 : 0 : return ZXDH_OK;
4216 : : }
4217 : :
4218 : : static void
4219 : 0 : zxdh_np_apt_hash_global_res_uninit(uint32_t dev_id)
4220 : : {
4221 [ # # ]: 0 : if (g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] != NULL) {
4222 : 0 : rte_free(g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)]);
4223 : 0 : g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] = NULL;
4224 : 0 : dpp_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] = NULL;
4225 : : }
4226 : 0 : }
4227 : :
4228 : : int
4229 : 0 : zxdh_np_online_uninit(uint32_t dev_id,
4230 : : char *port_name,
4231 : : uint32_t queue_id)
4232 : : {
4233 : : uint32_t rc;
4234 : :
4235 : 0 : rc = zxdh_np_dtb_queue_release(dev_id, port_name, queue_id);
4236 [ # # ]: 0 : if (rc != 0)
4237 : 0 : PMD_DRV_LOG(ERR, "dtb release port name %s queue id %u", port_name, queue_id);
4238 : :
4239 : 0 : rc = zxdh_np_soft_res_uninstall(dev_id);
4240 [ # # ]: 0 : if (rc != 0)
4241 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_soft_res_uninstall failed");
4242 : :
4243 : 0 : return 0;
4244 : : }
4245 : :
4246 : : uint32_t
4247 : 0 : zxdh_np_soft_res_uninstall(uint32_t dev_id)
4248 : : {
4249 : : uint32_t rc;
4250 : :
4251 : 0 : rc = zxdh_np_hash_soft_uninstall(dev_id);
4252 [ # # ]: 0 : if (rc != ZXDH_OK)
4253 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_hash_soft_uninstall error! ");
4254 : :
4255 : 0 : zxdh_np_apt_hash_global_res_uninit(dev_id);
4256 : 0 : zxdh_np_acl_res_destroy(dev_id);
4257 : : zxdh_np_dtb_mgr_destroy(dev_id);
4258 : 0 : zxdh_np_sdt_mgr_destroy(dev_id);
4259 : 0 : zxdh_np_dev_del(dev_id);
4260 : :
4261 : 0 : return rc;
4262 : : }
4263 : :
4264 : : static uint32_t
4265 : : zxdh_np_sdt_tbl_type_get(uint32_t dev_id, uint32_t sdt_no)
4266 : : {
4267 : 0 : return g_table_type[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no];
4268 : : }
4269 : :
4270 : :
4271 : : static const ZXDH_DTB_TABLE_T *
4272 : : zxdh_np_dtb_table_info_get(uint32_t table_type)
4273 : : {
4274 : : return &g_dpp_dtb_table_info[table_type];
4275 : : }
4276 : :
4277 : : static const ZXDH_DTB_TABLE_T *
4278 : : zxdh_np_dtb_dump_info_get(uint32_t up_type)
4279 : : {
4280 : : return &g_dpp_dtb_dump_info[up_type];
4281 : : }
4282 : :
4283 : : static uint32_t
4284 : 0 : zxdh_np_dtb_write_table_cmd(uint32_t dev_id,
4285 : : ZXDH_DTB_TABLE_INFO_E table_type,
4286 : : void *p_cmd_data,
4287 : : void *p_cmd_buff)
4288 : : {
4289 : : uint32_t field_cnt;
4290 : : const ZXDH_DTB_TABLE_T *p_table_info = NULL;
4291 : : const ZXDH_DTB_FIELD_T *p_field_info = NULL;
4292 : : uint32_t temp_data;
4293 : : uint32_t rc = 0;
4294 : :
4295 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_data);
4296 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_buff);
4297 : : p_table_info = zxdh_np_dtb_table_info_get(table_type);
4298 : 0 : p_field_info = p_table_info->p_fields;
4299 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_table_info);
4300 : :
4301 [ # # ]: 0 : for (field_cnt = 0; field_cnt < p_table_info->field_num; field_cnt++) {
4302 : 0 : temp_data = *((uint32_t *)p_cmd_data + field_cnt) &
4303 [ # # ]: 0 : zxdh_np_comm_get_bit_mask(p_field_info[field_cnt].len);
4304 : :
4305 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_cmd_buff,
4306 : : ZXDH_DTB_TABLE_CMD_SIZE_BIT,
4307 : : temp_data,
4308 : 0 : p_field_info[field_cnt].lsb_pos,
4309 : : p_field_info[field_cnt].len);
4310 : :
4311 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_comm_write_bits_ex");
4312 : : }
4313 : :
4314 : 0 : return rc;
4315 : : }
4316 : :
4317 : : static uint32_t
4318 : 0 : zxdh_np_dtb_write_dump_cmd(uint32_t dev_id,
4319 : : ZXDH_DTB_DUMP_INFO_E dump_type,
4320 : : void *p_cmd_data,
4321 : : void *p_cmd_buff)
4322 : : {
4323 : : uint32_t rc = ZXDH_OK;
4324 : : uint32_t field_cnt = 0;
4325 : : const ZXDH_DTB_TABLE_T *p_table_info = NULL;
4326 : : const ZXDH_DTB_FIELD_T *p_field_info = NULL;
4327 : : uint32_t temp_data = 0;
4328 : :
4329 : : p_table_info = zxdh_np_dtb_dump_info_get(dump_type);
4330 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_table_info);
4331 : 0 : p_field_info = p_table_info->p_fields;
4332 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_field_info);
4333 : :
4334 [ # # ]: 0 : for (field_cnt = 0; field_cnt < p_table_info->field_num; field_cnt++) {
4335 : 0 : temp_data = *((uint32_t *)p_cmd_data + field_cnt) &
4336 [ # # ]: 0 : zxdh_np_comm_get_bit_mask(p_field_info[field_cnt].len);
4337 : :
4338 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_cmd_buff,
4339 : : ZXDH_DTB_TABLE_CMD_SIZE_BIT,
4340 : : temp_data,
4341 : 0 : p_field_info[field_cnt].lsb_pos,
4342 : : p_field_info[field_cnt].len);
4343 : :
4344 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_comm_write_bits");
4345 : : }
4346 : :
4347 : 0 : return rc;
4348 : : }
4349 : :
4350 : : static uint32_t
4351 : 0 : zxdh_np_dtb_smmu0_write_entry_data(uint32_t dev_id,
4352 : : uint32_t mode,
4353 : : uint32_t addr,
4354 : : uint32_t *p_data,
4355 : : ZXDH_DTB_ENTRY_T *p_entry)
4356 : : {
4357 : 0 : ZXDH_DTB_ERAM_TABLE_FORM_T dtb_eram_form_info = {0};
4358 : : uint32_t rc = 0;
4359 : :
4360 : 0 : dtb_eram_form_info.valid = ZXDH_DTB_TABLE_VALID;
4361 : : dtb_eram_form_info.type_mode = ZXDH_DTB_TABLE_MODE_ERAM;
4362 : 0 : dtb_eram_form_info.data_mode = mode;
4363 : 0 : dtb_eram_form_info.cpu_wr = 1;
4364 : 0 : dtb_eram_form_info.addr = addr;
4365 : : dtb_eram_form_info.cpu_rd = 0;
4366 : : dtb_eram_form_info.cpu_rd_mode = 0;
4367 : :
4368 [ # # ]: 0 : if (ZXDH_ERAM128_OPR_128b == mode) {
4369 : 0 : p_entry->data_in_cmd_flag = 0;
4370 : 0 : p_entry->data_size = 128 / 8;
4371 : :
4372 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_128,
4373 : 0 : &dtb_eram_form_info, p_entry->cmd);
4374 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
4375 : :
4376 : 0 : memcpy(p_entry->data, p_data, 128 / 8);
4377 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_64b == mode) {
4378 : 0 : p_entry->data_in_cmd_flag = 1;
4379 : 0 : p_entry->data_size = 64 / 8;
4380 : 0 : dtb_eram_form_info.data_l = *(p_data + 1);
4381 : 0 : dtb_eram_form_info.data_h = *(p_data);
4382 : :
4383 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_64,
4384 : 0 : &dtb_eram_form_info, p_entry->cmd);
4385 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
4386 : :
4387 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_1b == mode) {
4388 : 0 : p_entry->data_in_cmd_flag = 1;
4389 : 0 : p_entry->data_size = 1;
4390 : 0 : dtb_eram_form_info.data_h = *(p_data);
4391 : :
4392 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_1,
4393 : 0 : &dtb_eram_form_info, p_entry->cmd);
4394 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
4395 : : }
4396 : :
4397 : 0 : return rc;
4398 : : }
4399 : :
4400 : : static uint32_t
4401 : 0 : zxdh_np_dtb_zcam_write_entry_data(uint32_t dev_id,
4402 : : uint32_t reg_sram_flag,
4403 : : uint32_t zgroup_id,
4404 : : uint32_t zblock_id,
4405 : : uint32_t zcell_id,
4406 : : uint32_t sram_addr,
4407 : : uint32_t mask,
4408 : : uint8_t *p_data,
4409 : : ZXDH_DTB_ENTRY_T *p_entry)
4410 : : {
4411 : : uint32_t rc = ZXDH_OK;
4412 : :
4413 : 0 : ZXDH_DTB_ZCAM_TABLE_FORM_T dtb_zcam_form_info = {
4414 : : .valid = 1,
4415 : : .type_mode = ZXDH_DTB_TABLE_MODE_ZCAM,
4416 : : .ram_reg_flag = reg_sram_flag,
4417 : : .zgroup_id = zgroup_id,
4418 : : .zblock_id = zblock_id,
4419 : : .zcell_id = zcell_id,
4420 : : .mask = mask,
4421 : 0 : .sram_addr = sram_addr & 0x1FF,
4422 : : };
4423 : :
4424 : 0 : p_entry->data_in_cmd_flag = 0;
4425 : 0 : p_entry->data_size = ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ZCAM_LEN_SIZE - 1);
4426 : :
4427 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ZCAM,
4428 : 0 : &dtb_zcam_form_info, p_entry->cmd);
4429 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_table_cmd");
4430 : :
4431 : 0 : memcpy(p_entry->data, p_data,
4432 : : ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ZCAM_LEN_SIZE - 1));
4433 : :
4434 : 0 : return rc;
4435 : : }
4436 : :
4437 : : static uint32_t
4438 : 0 : zxdh_np_dtb_se_alg_zcam_data_write(uint32_t dev_id,
4439 : : uint32_t addr,
4440 : : uint8_t *p_data,
4441 : : ZXDH_DTB_ENTRY_T *p_entry)
4442 : : {
4443 : : uint32_t rc = ZXDH_OK;
4444 : 0 : uint32_t reg_sram_flag = (addr >> 16) & 0x1;
4445 : 0 : uint32_t zgroup_id = (addr >> 14) & 0x3;
4446 : 0 : uint32_t zblock_id = (addr >> 11) & 0x7;
4447 : 0 : uint32_t zcell_id = (addr >> 9) & 0x3;
4448 : 0 : uint32_t mask = (addr >> 17) & 0xF;
4449 : 0 : uint32_t sram_addr = addr & 0x1FF;
4450 : :
4451 : 0 : rc = zxdh_np_dtb_zcam_write_entry_data(dev_id, reg_sram_flag, zgroup_id, zblock_id,
4452 : : zcell_id, sram_addr, mask, p_data, p_entry);
4453 : :
4454 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_zcam_write_entry_data");
4455 : :
4456 : 0 : return rc;
4457 : : }
4458 : :
4459 : : static uint32_t
4460 : 0 : zxdh_np_dtb_etcam_write_entry_data(uint32_t dev_id,
4461 : : uint32_t block_idx,
4462 : : uint32_t row_or_col_msk,
4463 : : uint32_t vben,
4464 : : uint32_t reg_tcam_flag,
4465 : : uint32_t flush,
4466 : : uint32_t rd_wr,
4467 : : uint32_t wr_mode,
4468 : : uint32_t data_or_mask,
4469 : : uint32_t ram_addr,
4470 : : uint32_t vbit,
4471 : : uint8_t *p_data,
4472 : : ZXDH_DTB_ENTRY_T *p_entry)
4473 : : {
4474 : : uint32_t rc = ZXDH_OK;
4475 : : uint32_t i = 0;
4476 : : uint32_t offset = 0;
4477 : : uint8_t *p_temp = NULL;
4478 : :
4479 : 0 : uint8_t buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
4480 : :
4481 : 0 : ZXDH_DTB_ETCAM_TABLE_FORM_T dtb_etcam_form_info = {
4482 : : .valid = 1,
4483 : : .type_mode = ZXDH_DTB_TABLE_MODE_ETCAM,
4484 : : .block_sel = block_idx,
4485 : : .init_en = 0,
4486 : : .row_or_col_msk = row_or_col_msk,
4487 : : .vben = vben,
4488 : : .reg_tcam_flag = reg_tcam_flag,
4489 : : .uload = flush,
4490 : : .rd_wr = rd_wr,
4491 : : .wr_mode = wr_mode,
4492 : : .data_or_mask = data_or_mask,
4493 : : .addr = ram_addr,
4494 : : .vbit = vbit,
4495 : : };
4496 : :
4497 : 0 : p_entry->data_in_cmd_flag = 0;
4498 : 0 : p_entry->data_size = ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ETCAM_LEN_SIZE - 1);
4499 : :
4500 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ETCAM,
4501 : 0 : &dtb_etcam_form_info, p_entry->cmd);
4502 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_table_cmd");
4503 : :
4504 : : p_temp = p_data;
4505 : :
4506 [ # # ]: 0 : for (i = 0; i < ZXDH_ETCAM_RAM_NUM; i++) {
4507 : 0 : offset = i * ((uint32_t)ZXDH_ETCAM_WIDTH_MIN / 8);
4508 : :
4509 [ # # ]: 0 : if ((wr_mode >> (ZXDH_ETCAM_RAM_NUM - 1 - i)) & 0x1) {
4510 : 0 : memcpy(buff + offset, p_temp, ZXDH_ETCAM_WIDTH_MIN / 8);
4511 : 0 : p_temp += ZXDH_ETCAM_WIDTH_MIN / 8;
4512 : : }
4513 : : }
4514 : :
4515 : : zxdh_np_comm_swap((uint8_t *)buff, ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ETCAM_LEN_SIZE - 1));
4516 : :
4517 : 0 : memcpy(p_entry->data, buff,
4518 : : ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ETCAM_LEN_SIZE - 1));
4519 : :
4520 : 0 : return rc;
4521 : : }
4522 : :
4523 : : static uint32_t
4524 : 0 : zxdh_np_dtb_smmu0_dump_info_write(uint32_t dev_id,
4525 : : uint32_t base_addr,
4526 : : uint32_t depth,
4527 : : uint32_t addr_high32,
4528 : : uint32_t addr_low32,
4529 : : uint32_t *p_dump_info)
4530 : : {
4531 : : uint32_t rc = ZXDH_OK;
4532 : :
4533 : 0 : ZXDH_DTB_ERAM_DUMP_FORM_T dtb_eram_dump_form_info = {
4534 : : .valid = 1,
4535 : : .up_type = ZXDH_DTB_DUMP_MODE_ERAM,
4536 : : .base_addr = base_addr,
4537 : : .tb_depth = depth,
4538 : : .tb_dst_addr_h = addr_high32,
4539 : : .tb_dst_addr_l = addr_low32,
4540 : : };
4541 : :
4542 : 0 : PMD_DRV_LOG(DEBUG, "valid: %u", dtb_eram_dump_form_info.valid);
4543 : 0 : PMD_DRV_LOG(DEBUG, "up_type: %u", dtb_eram_dump_form_info.up_type);
4544 : 0 : PMD_DRV_LOG(DEBUG, "base_addr: 0x%x", dtb_eram_dump_form_info.base_addr);
4545 : 0 : PMD_DRV_LOG(DEBUG, "tb_depth: %u", dtb_eram_dump_form_info.tb_depth);
4546 : 0 : PMD_DRV_LOG(DEBUG, "tb_dst_addr_h: 0x%x", dtb_eram_dump_form_info.tb_dst_addr_h);
4547 : 0 : PMD_DRV_LOG(DEBUG, "tb_dst_addr_l: 0x%x", dtb_eram_dump_form_info.tb_dst_addr_l);
4548 : :
4549 : 0 : rc = zxdh_np_dtb_write_dump_cmd(dev_id, ZXDH_DTB_DUMP_ERAM,
4550 : : &dtb_eram_dump_form_info, p_dump_info);
4551 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_cmd");
4552 : :
4553 : 0 : return rc;
4554 : : }
4555 : :
4556 : : static uint32_t
4557 : 0 : zxdh_np_dtb_zcam_dump_info_write(uint32_t dev_id,
4558 : : uint32_t addr,
4559 : : uint32_t tb_width,
4560 : : uint32_t depth,
4561 : : uint32_t addr_high32,
4562 : : uint32_t addr_low32,
4563 : : uint32_t *p_dump_info)
4564 : : {
4565 : : uint32_t rc = ZXDH_OK;
4566 : :
4567 : 0 : ZXDH_DTB_ZCAM_DUMP_FORM_T dtb_zcam_dump_form_info = {
4568 : : .valid = 1,
4569 : : .up_type = ZXDH_DTB_DUMP_MODE_ZCAM,
4570 : : .tb_width = tb_width,
4571 : 0 : .sram_addr = addr & 0x1FF,
4572 : 0 : .ram_reg_flag = (addr >> 16) & 0x1,
4573 : 0 : .z_reg_cell_id = (addr >> 9) & 0x3,
4574 : 0 : .zblock_id = (addr >> 11) & 0x7,
4575 : 0 : .zgroup_id = (addr >> 14) & 0x3,
4576 : : .tb_depth = depth,
4577 : : .tb_dst_addr_h = addr_high32,
4578 : : .tb_dst_addr_l = addr_low32,
4579 : : };
4580 : :
4581 : 0 : rc = zxdh_np_dtb_write_dump_cmd(dev_id, ZXDH_DTB_DUMP_ZCAM,
4582 : : &dtb_zcam_dump_form_info, p_dump_info);
4583 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_cmd");
4584 : :
4585 : 0 : return rc;
4586 : : }
4587 : :
4588 : : static uint32_t
4589 : 0 : zxdh_np_dtb_etcam_dump_info_write(uint32_t dev_id,
4590 : : ZXDH_ETCAM_DUMP_INFO_T *p_etcam_dump_info,
4591 : : uint32_t addr_high32,
4592 : : uint32_t addr_low32,
4593 : : uint32_t *p_dump_info)
4594 : : {
4595 : : uint32_t rc = ZXDH_OK;
4596 : :
4597 : 0 : ZXDH_DTB_ETCAM_DUMP_FORM_T dtb_etcam_dump_form_info = {
4598 : : .valid = 1,
4599 : : .up_type = ZXDH_DTB_DUMP_MODE_ETCAM,
4600 : 0 : .block_sel = p_etcam_dump_info->block_sel,
4601 : 0 : .addr = p_etcam_dump_info->addr,
4602 : 0 : .rd_mode = p_etcam_dump_info->rd_mode,
4603 : 0 : .data_or_mask = p_etcam_dump_info->data_or_mask,
4604 : 0 : .tb_depth = p_etcam_dump_info->tb_depth,
4605 : 0 : .tb_width = p_etcam_dump_info->tb_width,
4606 : : .tb_dst_addr_h = addr_high32,
4607 : : .tb_dst_addr_l = addr_low32,
4608 : : };
4609 : :
4610 : 0 : rc = zxdh_np_dtb_write_dump_cmd(dev_id, ZXDH_DTB_DUMP_ETCAM,
4611 : : &dtb_etcam_dump_form_info, p_dump_info);
4612 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_cmd");
4613 : :
4614 : 0 : return rc;
4615 : : }
4616 : :
4617 : : static void
4618 : : zxdh_np_dtb_zcam_dump_entry(uint32_t dev_id,
4619 : : uint32_t addr,
4620 : : uint32_t tb_width,
4621 : : uint32_t depth,
4622 : : uint32_t addr_high32,
4623 : : uint32_t addr_low32,
4624 : : ZXDH_DTB_ENTRY_T *p_entry)
4625 : : {
4626 : 0 : zxdh_np_dtb_zcam_dump_info_write(dev_id,
4627 : : addr,
4628 : : tb_width,
4629 : : depth,
4630 : : addr_high32,
4631 : : addr_low32,
4632 : 0 : (uint32_t *)p_entry->cmd);
4633 : 0 : p_entry->data_in_cmd_flag = 1;
4634 : : }
4635 : :
4636 : : static void
4637 : 0 : zxdh_np_dtb_smmu0_dump_entry(uint32_t dev_id,
4638 : : uint32_t base_addr,
4639 : : uint32_t depth,
4640 : : uint32_t addr_high32,
4641 : : uint32_t addr_low32,
4642 : : ZXDH_DTB_ENTRY_T *p_entry)
4643 : : {
4644 : 0 : zxdh_np_dtb_smmu0_dump_info_write(dev_id,
4645 : : base_addr,
4646 : : depth,
4647 : : addr_high32,
4648 : : addr_low32,
4649 : 0 : (uint32_t *)p_entry->cmd);
4650 : 0 : p_entry->data_in_cmd_flag = 1;
4651 : 0 : }
4652 : :
4653 : : static void
4654 : : zxdh_np_dtb_etcam_dump_entry(uint32_t dev_id,
4655 : : ZXDH_ETCAM_DUMP_INFO_T *p_etcam_dump_info,
4656 : : uint32_t addr_high32,
4657 : : uint32_t addr_low32,
4658 : : ZXDH_DTB_ENTRY_T *p_entry)
4659 : : {
4660 : 0 : zxdh_np_dtb_etcam_dump_info_write(dev_id,
4661 : : p_etcam_dump_info,
4662 : : addr_high32,
4663 : : addr_low32,
4664 : 0 : (uint32_t *)p_entry->cmd);
4665 : 0 : p_entry->data_in_cmd_flag = 1;
4666 : : }
4667 : :
4668 : : static uint32_t
4669 : 0 : zxdh_np_dtb_se_smmu0_ind_write(uint32_t dev_id,
4670 : : uint32_t base_addr,
4671 : : uint32_t index,
4672 : : uint32_t wrt_mode,
4673 : : uint32_t *p_data,
4674 : : ZXDH_DTB_ENTRY_T *p_entry)
4675 : : {
4676 : : uint32_t temp_idx = 0;
4677 : : uint32_t dtb_ind_addr;
4678 : : uint32_t rc = 0;
4679 : :
4680 [ # # # # ]: 0 : switch (wrt_mode) {
4681 : 0 : case ZXDH_ERAM128_OPR_128b:
4682 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
4683 : 0 : PMD_DRV_LOG(ERR, "base addr:0x%x, index:0x%x invalid", base_addr, index);
4684 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
4685 : : }
4686 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
4687 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
4688 : 0 : return 1;
4689 : : }
4690 : 0 : temp_idx = index << 7;
4691 : 0 : break;
4692 : 0 : case ZXDH_ERAM128_OPR_64b:
4693 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
4694 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
4695 : 0 : return 1;
4696 : : }
4697 : 0 : temp_idx = index << 6;
4698 : 0 : break;
4699 : 0 : case ZXDH_ERAM128_OPR_1b:
4700 [ # # ]: 0 : if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
4701 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
4702 : 0 : return 1;
4703 : : }
4704 : :
4705 : : temp_idx = index;
4706 : : break;
4707 : : default:
4708 : : break;
4709 : : }
4710 : :
4711 : 0 : dtb_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + temp_idx;
4712 : :
4713 : 0 : PMD_DRV_LOG(DEBUG, "dtb eram item 1bit addr: 0x%x", dtb_ind_addr);
4714 : :
4715 : 0 : rc = zxdh_np_dtb_smmu0_write_entry_data(dev_id,
4716 : : wrt_mode,
4717 : : dtb_ind_addr,
4718 : : p_data,
4719 : : p_entry);
4720 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_smmu0_write_entry_data");
4721 : :
4722 : : return rc;
4723 : : }
4724 : :
4725 : : static uint32_t
4726 : : zxdh_np_eram_dtb_len_get(uint32_t mode)
4727 : : {
4728 : : uint32_t dtb_len = 0;
4729 : :
4730 [ # # # ]: 0 : switch (mode) {
4731 : 0 : case ZXDH_ERAM128_OPR_128b:
4732 : : dtb_len += 2;
4733 : 0 : break;
4734 : 0 : case ZXDH_ERAM128_OPR_64b:
4735 : : case ZXDH_ERAM128_OPR_1b:
4736 : : dtb_len += 1;
4737 : 0 : break;
4738 : : default:
4739 : : break;
4740 : : }
4741 : :
4742 : : return dtb_len;
4743 : : }
4744 : :
4745 : : static void
4746 : : zxdh_np_sdt_tbl_data_get(uint32_t dev_id, uint32_t sdt_no, ZXDH_SDT_TBL_DATA_T *p_sdt_data)
4747 : : {
4748 : 0 : p_sdt_data->data_high32 = g_sdt_info[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no].data_high32;
4749 : 0 : p_sdt_data->data_low32 = g_sdt_info[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no].data_low32;
4750 : : }
4751 : :
4752 : : static uint32_t
4753 : 0 : zxdh_np_sdt_tbl_data_parser(uint32_t sdt_hig32, uint32_t sdt_low32, void *p_sdt_info)
4754 : : {
4755 : : uint32_t tbl_type = 0;
4756 : : uint32_t clutch_en = 0;
4757 : : uint32_t tmp = 0;
4758 : :
4759 : : ZXDH_SDT_TBL_ERAM_T *p_sdt_eram = NULL;
4760 : : ZXDH_SDT_TBL_HASH_T *p_sdt_hash = NULL;
4761 : : ZXDH_SDT_TBL_ETCAM_T *p_sdt_etcam = NULL;
4762 : : ZXDH_SDT_TBL_PORTTBL_T *p_sdt_porttbl = NULL;
4763 : :
4764 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_hig32,
4765 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
4766 : 0 : ZXDH_COMM_UINT32_GET_BITS(clutch_en, sdt_low32, 0, 1);
4767 : :
4768 [ # # # # : 0 : switch (tbl_type) {
# ]
4769 : 0 : case ZXDH_SDT_TBLT_ERAM:
4770 : : p_sdt_eram = (ZXDH_SDT_TBL_ERAM_T *)p_sdt_info;
4771 : 0 : p_sdt_eram->table_type = tbl_type;
4772 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_eram->eram_mode, sdt_hig32,
4773 : : ZXDH_SDT_H_ERAM_MODE_BT_POS, ZXDH_SDT_H_ERAM_MODE_BT_LEN);
4774 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_eram->eram_base_addr, sdt_hig32,
4775 : : ZXDH_SDT_H_ERAM_BASE_ADDR_BT_POS, ZXDH_SDT_H_ERAM_BASE_ADDR_BT_LEN);
4776 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_eram->eram_table_depth, sdt_low32,
4777 : : ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_POS, ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_LEN);
4778 : 0 : p_sdt_eram->eram_clutch_en = clutch_en;
4779 : 0 : break;
4780 : 0 : case ZXDH_SDT_TBLT_HASH:
4781 : : p_sdt_hash = (ZXDH_SDT_TBL_HASH_T *)p_sdt_info;
4782 : 0 : p_sdt_hash->table_type = tbl_type;
4783 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->hash_id, sdt_hig32,
4784 : : ZXDH_SDT_H_HASH_ID_BT_POS, ZXDH_SDT_H_HASH_ID_BT_LEN);
4785 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->hash_table_width, sdt_hig32,
4786 : : ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_POS, ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_LEN);
4787 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->key_size, sdt_hig32,
4788 : : ZXDH_SDT_H_HASH_KEY_SIZE_BT_POS, ZXDH_SDT_H_HASH_KEY_SIZE_BT_LEN);
4789 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->hash_table_id, sdt_hig32,
4790 : : ZXDH_SDT_H_HASH_TABLE_ID_BT_POS, ZXDH_SDT_H_HASH_TABLE_ID_BT_LEN);
4791 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->learn_en, sdt_hig32,
4792 : : ZXDH_SDT_H_LEARN_EN_BT_POS, ZXDH_SDT_H_LEARN_EN_BT_LEN);
4793 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->keep_alive, sdt_hig32,
4794 : : ZXDH_SDT_H_KEEP_ALIVE_BT_POS, ZXDH_SDT_H_KEEP_ALIVE_BT_LEN);
4795 : : ZXDH_COMM_UINT32_GET_BITS(tmp, sdt_hig32,
4796 : : ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_POS, ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_LEN);
4797 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->keep_alive_baddr, sdt_low32,
4798 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_POS, ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN);
4799 : 0 : p_sdt_hash->keep_alive_baddr += (tmp << ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN);
4800 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->rsp_mode, sdt_low32,
4801 : : ZXDH_SDT_L_RSP_MODE_BT_POS, ZXDH_SDT_L_RSP_MODE_BT_LEN);
4802 : 0 : p_sdt_hash->hash_clutch_en = clutch_en;
4803 : 0 : break;
4804 : :
4805 : 0 : case ZXDH_SDT_TBLT_ETCAM:
4806 : : p_sdt_etcam = (ZXDH_SDT_TBL_ETCAM_T *)p_sdt_info;
4807 : 0 : p_sdt_etcam->table_type = tbl_type;
4808 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_id, sdt_hig32,
4809 : : ZXDH_SDT_H_ETCAM_ID_BT_POS, ZXDH_SDT_H_ETCAM_ID_BT_LEN);
4810 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_key_mode, sdt_hig32,
4811 : : ZXDH_SDT_H_ETCAM_KEY_MODE_BT_POS, ZXDH_SDT_H_ETCAM_KEY_MODE_BT_LEN);
4812 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_table_id, sdt_hig32,
4813 : : ZXDH_SDT_H_ETCAM_TABLE_ID_BT_POS, ZXDH_SDT_H_ETCAM_TABLE_ID_BT_LEN);
4814 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->no_as_rsp_mode, sdt_hig32,
4815 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_POS,
4816 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_LEN);
4817 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->as_en, sdt_hig32,
4818 : : ZXDH_SDT_H_ETCAM_AS_EN_BT_POS, ZXDH_SDT_H_ETCAM_AS_EN_BT_LEN);
4819 : : ZXDH_COMM_UINT32_GET_BITS(tmp, sdt_hig32, ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_POS,
4820 : : ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_LEN);
4821 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->as_eram_baddr, sdt_low32,
4822 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_POS,
4823 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN);
4824 : 0 : p_sdt_etcam->as_eram_baddr += (tmp << ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN);
4825 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->as_rsp_mode, sdt_low32,
4826 : : ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_POS, ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_LEN);
4827 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_table_depth, sdt_low32,
4828 : : ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_POS, ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_LEN);
4829 : 0 : p_sdt_etcam->etcam_clutch_en = clutch_en;
4830 : 0 : break;
4831 : :
4832 : 0 : case ZXDH_SDT_TBLT_PORTTBL:
4833 : : p_sdt_porttbl = (ZXDH_SDT_TBL_PORTTBL_T *)p_sdt_info;
4834 : 0 : p_sdt_porttbl->table_type = tbl_type;
4835 : 0 : p_sdt_porttbl->porttbl_clutch_en = clutch_en;
4836 : 0 : break;
4837 : 0 : default:
4838 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
4839 : 0 : return 1;
4840 : : }
4841 : :
4842 : : return 0;
4843 : : }
4844 : :
4845 : : static uint32_t
4846 : 0 : zxdh_np_soft_sdt_tbl_get(uint32_t dev_id, uint32_t sdt_no, void *p_sdt_info)
4847 : : {
4848 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
4849 : : uint32_t rc;
4850 : :
4851 [ # # ]: 0 : if (sdt_no > ZXDH_DEV_SDT_ID_MAX - 1) {
4852 : 0 : PMD_DRV_LOG(ERR, "SDT NO [ %u ] is invalid!", sdt_no);
4853 : 0 : return ZXDH_PAR_CHK_INVALID_PARA;
4854 : : }
4855 : :
4856 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
4857 : :
4858 : 0 : rc = zxdh_np_sdt_tbl_data_parser(sdt_tbl.data_high32, sdt_tbl.data_low32, p_sdt_info);
4859 [ # # ]: 0 : if (rc != 0)
4860 : 0 : PMD_DRV_LOG(ERR, "dpp sdt [%u] tbl_data_parser error.", sdt_no);
4861 : :
4862 : : return rc;
4863 : : }
4864 : :
4865 : : static uint32_t
4866 : 0 : zxdh_np_dtb_eram_one_entry(uint32_t dev_id,
4867 : : uint32_t sdt_no,
4868 : : uint32_t del_en,
4869 : : void *pdata,
4870 : : uint32_t *p_dtb_len,
4871 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
4872 : : {
4873 : 0 : uint32_t buff[ZXDH_SMMU0_READ_REG_MAX_NUM] = {0};
4874 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
4875 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *peramdata = NULL;
4876 : : uint32_t base_addr;
4877 : : uint32_t index;
4878 : : uint32_t opr_mode;
4879 : : uint32_t rc = ZXDH_OK;
4880 : :
4881 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(pdata);
4882 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_one_entry);
4883 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_len);
4884 : :
4885 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
4886 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram);
4887 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_soft_sdt_tbl_get");
4888 : :
4889 : : peramdata = (ZXDH_DTB_ERAM_ENTRY_INFO_T *)pdata;
4890 : 0 : index = peramdata->index;
4891 : 0 : base_addr = sdt_eram.eram_base_addr;
4892 : 0 : opr_mode = sdt_eram.eram_mode;
4893 : :
4894 [ # # # # ]: 0 : switch (opr_mode) {
4895 : 0 : case ZXDH_ERAM128_TBL_128b:
4896 : : opr_mode = ZXDH_ERAM128_OPR_128b;
4897 : 0 : break;
4898 : 0 : case ZXDH_ERAM128_TBL_64b:
4899 : : opr_mode = ZXDH_ERAM128_OPR_64b;
4900 : 0 : break;
4901 : 0 : case ZXDH_ERAM128_TBL_1b:
4902 : : opr_mode = ZXDH_ERAM128_OPR_1b;
4903 : 0 : break;
4904 : : default:
4905 : : break;
4906 : : }
4907 : :
4908 : 0 : PMD_DRV_LOG(DEBUG, "std no:0x%x, index:0x%x, base addr:0x%x", sdt_no, index, base_addr);
4909 [ # # ]: 0 : if (opr_mode == ZXDH_ERAM128_OPR_128b)
4910 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x 0x%08x 0x%08x]",
4911 : : peramdata->p_data[0], peramdata->p_data[1],
4912 : : peramdata->p_data[2], peramdata->p_data[3]);
4913 [ # # ]: 0 : else if (opr_mode == ZXDH_ERAM128_OPR_64b)
4914 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x]",
4915 : : peramdata->p_data[0], peramdata->p_data[1]);
4916 : :
4917 [ # # ]: 0 : if (del_en) {
4918 : : memset((uint8_t *)buff, 0, sizeof(buff));
4919 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
4920 : : base_addr,
4921 : : index,
4922 : : opr_mode,
4923 : : buff,
4924 : : p_dtb_one_entry);
4925 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(sdt_no, rc, "zxdh_dtb_se_smmu0_ind_write");
4926 : : } else {
4927 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
4928 : : base_addr,
4929 : : index,
4930 : : opr_mode,
4931 : : peramdata->p_data,
4932 : : p_dtb_one_entry);
4933 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_dtb_se_smmu0_ind_write");
4934 : : }
4935 : 0 : *p_dtb_len = zxdh_np_eram_dtb_len_get(opr_mode);
4936 : :
4937 : 0 : return rc;
4938 : : }
4939 : :
4940 : : static uint32_t
4941 : 0 : zxdh_np_dtb_data_write(uint8_t *p_data_buff,
4942 : : uint32_t addr_offset,
4943 : : ZXDH_DTB_ENTRY_T *entry)
4944 : : {
4945 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
4946 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(entry);
4947 : :
4948 : 0 : uint8_t *p_cmd = p_data_buff + addr_offset;
4949 : : uint32_t cmd_size = ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8;
4950 : :
4951 : 0 : uint8_t *p_data = p_cmd + cmd_size;
4952 : 0 : uint32_t data_size = entry->data_size;
4953 : :
4954 : 0 : uint8_t *cmd = (uint8_t *)entry->cmd;
4955 [ # # ]: 0 : uint8_t *data = (uint8_t *)entry->data;
4956 : :
4957 : : memcpy(p_cmd, cmd, cmd_size);
4958 : :
4959 [ # # ]: 0 : if (!entry->data_in_cmd_flag) {
4960 : 0 : zxdh_np_comm_swap(data, data_size);
4961 : 0 : memcpy(p_data, data, data_size);
4962 : : }
4963 : :
4964 : 0 : return 0;
4965 : : }
4966 : :
4967 : : static uint32_t
4968 : 0 : zxdh_np_dtb_queue_enable_get(uint32_t dev_id,
4969 : : uint32_t queue_id,
4970 : : uint32_t *enable)
4971 : : {
4972 : : uint32_t rc = 0;
4973 : 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
4974 : :
4975 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
4976 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_vm_info_get");
4977 : :
4978 : 0 : *enable = vm_info.queue_en;
4979 : 0 : return rc;
4980 : : }
4981 : :
4982 : : static uint32_t
4983 : 0 : zxdh_np_dtb_item_buff_wr(uint32_t dev_id,
4984 : : uint32_t queue_id,
4985 : : uint32_t dir_flag,
4986 : : uint32_t index,
4987 : : uint32_t pos,
4988 : : uint32_t len,
4989 : : uint32_t *p_data)
4990 : : {
4991 : : uint64_t addr;
4992 : :
4993 [ # # ]: 0 : if (dir_flag == 1)
4994 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) +
4995 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
4996 : : else
4997 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) +
4998 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
4999 : :
5000 : 0 : memcpy((uint8_t *)(addr), p_data, len * 4);
5001 : :
5002 : 0 : return 0;
5003 : : }
5004 : :
5005 : : static uint32_t
5006 : 0 : zxdh_np_dtb_item_ack_rd(uint32_t dev_id,
5007 : : uint32_t queue_id,
5008 : : uint32_t dir_flag,
5009 : : uint32_t index,
5010 : : uint32_t pos,
5011 : : uint32_t *p_data)
5012 : : {
5013 : : uint64_t addr;
5014 : : uint32_t val;
5015 : :
5016 [ # # ]: 0 : if (dir_flag == 1)
5017 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5018 : : else
5019 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5020 : :
5021 : 0 : val = *((volatile uint32_t *)(addr));
5022 : :
5023 : : if (!zxdh_np_comm_is_big_endian())
5024 : : val = ZXDH_COMM_CONVERT32(val);
5025 : :
5026 : 0 : *p_data = val;
5027 : :
5028 : 0 : return 0;
5029 : : }
5030 : :
5031 : : static uint32_t
5032 : : zxdh_np_dtb_item_ack_wr(uint32_t dev_id,
5033 : : uint32_t queue_id,
5034 : : uint32_t dir_flag,
5035 : : uint32_t index,
5036 : : uint32_t pos,
5037 : : uint32_t data)
5038 : : {
5039 : : uint64_t addr;
5040 : :
5041 : : if (dir_flag == 1)
5042 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5043 : : else
5044 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5045 : :
5046 : : if (!zxdh_np_comm_is_big_endian())
5047 : : data = ZXDH_COMM_CONVERT32(data);
5048 : :
5049 : 0 : *((volatile uint32_t *)addr) = data;
5050 : :
5051 : 0 : return 0;
5052 : : }
5053 : :
5054 : : static uint32_t
5055 : 0 : zxdh_np_dtb_item_ack_prt(uint32_t dev_id,
5056 : : uint32_t queue_id,
5057 : : uint32_t dir_flag,
5058 : : uint32_t index)
5059 : : {
5060 : : uint32_t rc = 0;
5061 : : uint32_t i = 0;
5062 : 0 : uint32_t ack_data[4] = {0};
5063 : :
5064 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_ITEM_ACK_SIZE / 4; i++) {
5065 : 0 : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, dir_flag, index, i, ack_data + i);
5066 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_rd");
5067 : : }
5068 : :
5069 : 0 : PMD_DRV_LOG(DEBUG, "[%s] BD INFO:", g_dpp_dtb_name[dir_flag]);
5070 : 0 : PMD_DRV_LOG(DEBUG, "[index : %u] : 0x%08x 0x%08x 0x%08x 0x%08x", index,
5071 : : ack_data[0], ack_data[1], ack_data[2], ack_data[3]);
5072 : :
5073 : 0 : return rc;
5074 : : }
5075 : :
5076 : : static uint32_t
5077 : 0 : zxdh_np_dtb_item_buff_rd(uint32_t dev_id,
5078 : : uint32_t queue_id,
5079 : : uint32_t dir_flag,
5080 : : uint32_t index,
5081 : : uint32_t pos,
5082 : : uint32_t len,
5083 : : uint32_t *p_data)
5084 : : {
5085 : : uint64_t addr = 0;
5086 : :
5087 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
5088 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
5089 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
5090 : : }
5091 : :
5092 [ # # ]: 0 : if (dir_flag == ZXDH_DTB_DIR_UP_TYPE) {
5093 [ # # ]: 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, index) ==
5094 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE) {
5095 : 0 : addr = ZXDH_DTB_TAB_UP_USER_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5096 : 0 : ZXDH_DTB_TAB_UP_USER_ADDR_FLAG_SET(dev_id, queue_id, index, 0);
5097 : : } else {
5098 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) +
5099 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
5100 : : }
5101 : : } else {
5102 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) +
5103 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
5104 : : }
5105 : :
5106 : 0 : memcpy(p_data, (uint8_t *)(addr), len * 4);
5107 : :
5108 : 0 : zxdh_np_comm_swap((uint8_t *)p_data, len * 4);
5109 : :
5110 : 0 : return ZXDH_OK;
5111 : : }
5112 : :
5113 : : static uint32_t
5114 : 0 : zxdh_np_dtb_item_buff_prt(uint32_t dev_id,
5115 : : uint32_t queue_id,
5116 : : uint32_t dir_flag,
5117 : : uint32_t index,
5118 : : uint32_t len)
5119 : : {
5120 : : uint32_t rc = 0;
5121 : : uint32_t i = 0;
5122 : : uint32_t j = 0;
5123 : : uint32_t *p_item_buff = NULL;
5124 : :
5125 : 0 : p_item_buff = rte_zmalloc(NULL, len * sizeof(uint32_t), 0);
5126 [ # # ]: 0 : if (p_item_buff == NULL) {
5127 : 0 : PMD_DRV_LOG(ERR, "Alloc dtb item buffer failed!!!");
5128 : 0 : return ZXDH_RC_DTB_MEMORY_ALLOC_ERR;
5129 : : }
5130 : :
5131 : 0 : zxdh_np_dtb_item_buff_rd(dev_id, queue_id, dir_flag, index, 0, len, p_item_buff);
5132 : :
5133 : 0 : PMD_DRV_LOG(DEBUG, "[%s] BUFF INFO:", g_dpp_dtb_name[dir_flag]);
5134 [ # # ]: 0 : for (i = 0, j = 0; i < len; i++, j++) {
5135 [ # # ]: 0 : if (j % 4 == 0)
5136 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", (*(p_item_buff + i)));
5137 : : else
5138 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", (*(p_item_buff + i)));
5139 : : }
5140 : :
5141 : 0 : rte_free(p_item_buff);
5142 : :
5143 : 0 : return rc;
5144 : : }
5145 : :
5146 : : static uint32_t
5147 : 0 : zxdh_np_dtb_queue_item_info_set(uint32_t dev_id,
5148 : : uint32_t queue_id,
5149 : : ZXDH_DTB_QUEUE_ITEM_INFO_T *p_item_info)
5150 : : {
5151 : : uint32_t rc;
5152 : :
5153 : : uint32_t dtb_addr_h_reg = ZXDH_SYS_DTB_BASE_ADDR +
5154 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0000;
5155 : : uint32_t dtb_addr_l_reg = ZXDH_SYS_DTB_BASE_ADDR +
5156 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0004;
5157 : : uint32_t dtb_len_reg = ZXDH_SYS_DTB_BASE_ADDR +
5158 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0008;
5159 : 0 : uint32_t dtb_len = 0;
5160 : :
5161 : 0 : rc = zxdh_np_dev_write_channel(dev_id, dtb_addr_h_reg + queue_id * 32,
5162 : : 1, &p_item_info->data_hddr);
5163 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_write_channel Fail");
5164 : 0 : rc = zxdh_np_dev_write_channel(dev_id, dtb_addr_l_reg + queue_id * 32,
5165 : : 1, &p_item_info->data_laddr);
5166 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_write_channel Fail");
5167 : 0 : dtb_len = ZXDH_DTB_LEN(p_item_info->cmd_type, p_item_info->int_en, p_item_info->data_len);
5168 : 0 : rc = zxdh_np_dev_write_channel(dev_id, dtb_len_reg + queue_id * 32, 1, &dtb_len);
5169 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_write_channel Fail");
5170 : :
5171 : 0 : return rc;
5172 : : }
5173 : :
5174 : : static uint32_t
5175 : 0 : zxdh_np_dtb_tab_down_info_set(uint32_t dev_id,
5176 : : uint32_t queue_id,
5177 : : uint32_t int_flag,
5178 : : uint32_t data_len,
5179 : : uint32_t *p_data,
5180 : : uint32_t *p_item_index)
5181 : : {
5182 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
5183 : 0 : uint32_t unused_item_num = 0;
5184 : 0 : uint32_t queue_en = 0;
5185 : : uint32_t ack_vale = 0;
5186 : : uint64_t phy_addr;
5187 : : uint32_t item_index;
5188 : : uint32_t i;
5189 : : uint32_t rc;
5190 : : ZXDH_SPINLOCK_T *p_spinlock = NULL;
5191 : :
5192 : : zxdh_np_dev_dtb_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_DTB, queue_id, &p_spinlock);
5193 : 0 : rte_spinlock_lock(&p_spinlock->spinlock);
5194 : :
5195 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
5196 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
5197 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5198 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
5199 : : }
5200 : :
5201 [ # # ]: 0 : if (data_len % 4 != 0) {
5202 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5203 : 0 : return ZXDH_RC_DTB_PARA_INVALID;
5204 : : }
5205 : :
5206 : 0 : rc = zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
5207 [ # # ]: 0 : if (!queue_en) {
5208 : 0 : PMD_DRV_LOG(ERR, "the queue %u is not enable!,rc=%u", queue_id, rc);
5209 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5210 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
5211 : : }
5212 : :
5213 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
5214 [ # # ]: 0 : if (unused_item_num == 0) {
5215 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5216 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
5217 : : }
5218 : :
5219 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
5220 : 0 : item_index = ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id) %
5221 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
5222 : :
5223 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, 0,
5224 : : item_index, 0, &ack_vale);
5225 : :
5226 : 0 : ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id)++;
5227 : :
5228 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
5229 : : break;
5230 : : }
5231 : :
5232 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX) {
5233 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5234 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
5235 : : }
5236 : :
5237 : 0 : rc = zxdh_np_dtb_item_buff_wr(dev_id, queue_id, 0,
5238 : : item_index, 0, data_len, p_data);
5239 : :
5240 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, 0,
5241 : : item_index, 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
5242 : :
5243 : 0 : item_info.cmd_vld = 1;
5244 : 0 : item_info.cmd_type = 0;
5245 : 0 : item_info.int_en = int_flag;
5246 : 0 : item_info.data_len = data_len / 4;
5247 : 0 : phy_addr = p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)]->queue_info[queue_id].
5248 : 0 : tab_down.start_phy_addr +
5249 : 0 : item_index * p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)]->queue_info[queue_id].
5250 : 0 : tab_down.item_size;
5251 : 0 : item_info.data_hddr = ((phy_addr >> 4) >> 32) & 0xffffffff;
5252 : 0 : item_info.data_laddr = (phy_addr >> 4) & 0xffffffff;
5253 : :
5254 : 0 : zxdh_dtb_info_print(dev_id, queue_id, item_index, &item_info);
5255 : :
5256 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
5257 : 0 : *p_item_index = item_index;
5258 : :
5259 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5260 : :
5261 : 0 : return rc;
5262 : : }
5263 : :
5264 : : static uint32_t
5265 : : zxdh_np_dtb_write_down_table_data(uint32_t dev_id,
5266 : : uint32_t queue_id,
5267 : : uint32_t down_table_len,
5268 : : uint8_t *p_down_table_buff,
5269 : : uint32_t *p_element_id)
5270 : : {
5271 : : uint32_t rc = 0;
5272 : : uint32_t dtb_interrupt_status = 0;
5273 : :
5274 : 0 : rc = zxdh_np_dtb_tab_down_info_set(dev_id,
5275 : : queue_id,
5276 : : dtb_interrupt_status,
5277 : : down_table_len / 4,
5278 : : (uint32_t *)p_down_table_buff,
5279 : : p_element_id);
5280 : : return rc;
5281 : : }
5282 : :
5283 : : static void
5284 : : zxdh_np_dtb_down_table_element_addr_get(uint32_t dev_id,
5285 : : uint32_t queue_id,
5286 : : uint32_t element_id,
5287 : : uint32_t *p_element_start_addr_h,
5288 : : uint32_t *p_element_start_addr_l,
5289 : : uint32_t *p_element_table_addr_h,
5290 : : uint32_t *p_element_table_addr_l)
5291 : : {
5292 : : uint32_t addr_h = 0;
5293 : : uint32_t addr_l = 0;
5294 : :
5295 : 0 : addr_h = (ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) >> 32) & 0xffffffff;
5296 : 0 : addr_l = ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) & 0xffffffff;
5297 : :
5298 : : *p_element_start_addr_h = addr_h;
5299 : : *p_element_start_addr_l = addr_l;
5300 : :
5301 : 0 : addr_h = ((ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) +
5302 : 0 : ZXDH_DTB_ITEM_ACK_SIZE) >> 32) & 0xffffffff;
5303 : 0 : addr_l = (ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) +
5304 : : ZXDH_DTB_ITEM_ACK_SIZE) & 0xffffffff;
5305 : :
5306 : : *p_element_table_addr_h = addr_h;
5307 : : *p_element_table_addr_l = addr_l;
5308 : : }
5309 : :
5310 : : static uint32_t
5311 : 0 : zxdh_np_dtb_down_table_element_info_prt(uint32_t dev_id,
5312 : : uint32_t queue_id,
5313 : : uint32_t element_id)
5314 : : {
5315 : : uint32_t rc = 0;
5316 : : uint32_t element_start_addr_h = 0;
5317 : : uint32_t element_start_addr_l = 0;
5318 : : uint32_t element_table_addr_h = 0;
5319 : : uint32_t element_table_addr_l = 0;
5320 : :
5321 : : zxdh_np_dtb_down_table_element_addr_get(dev_id,
5322 : : queue_id,
5323 : : element_id,
5324 : : &element_start_addr_h,
5325 : : &element_start_addr_l,
5326 : : &element_table_addr_h,
5327 : : &element_table_addr_l);
5328 : :
5329 : 0 : PMD_DRV_LOG(DEBUG, "queue_id %u.", queue_id);
5330 : 0 : PMD_DRV_LOG(DEBUG, "element_id %u.", element_id);
5331 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_h 0x%x.", element_start_addr_h);
5332 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_l 0x%x.", element_start_addr_l);
5333 : 0 : PMD_DRV_LOG(DEBUG, "element_table_addr_h 0x%x..", element_table_addr_h);
5334 : 0 : PMD_DRV_LOG(DEBUG, "element_table_addr_l 0x%x.", element_table_addr_l);
5335 : :
5336 : 0 : rc = zxdh_np_dtb_item_ack_prt(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE, element_id);
5337 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_prt");
5338 : :
5339 : 0 : rc = zxdh_np_dtb_item_buff_prt(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE, element_id, 24);
5340 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_prt");
5341 : :
5342 : 0 : return rc;
5343 : : }
5344 : :
5345 : : static uint32_t
5346 : 0 : zxdh_np_dtb_tab_down_success_status_check(uint32_t dev_id,
5347 : : uint32_t queue_id,
5348 : : uint32_t element_id)
5349 : : {
5350 : : uint32_t rc = 0;
5351 : : uint32_t rd_cnt = 0;
5352 : : uint32_t ack_value = 0;
5353 : : uint32_t success_flag = 0;
5354 : :
5355 : 0 : while (!success_flag) {
5356 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5357 : : element_id, 0, &ack_value);
5358 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_rd");
5359 : :
5360 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_np_dtb_item_ack_rd ack_value:0x%08x", ack_value);
5361 : :
5362 [ # # ]: 0 : if (((ack_value >> 8) & 0xffffff) == ZXDH_DTB_TAB_DOWN_ACK_VLD_MASK) {
5363 : : success_flag = 1;
5364 : : break;
5365 : : }
5366 : :
5367 [ # # ]: 0 : if (rd_cnt > ZXDH_DTB_DOWN_OVER_TIME) {
5368 : 0 : PMD_DRV_LOG(ERR, "down queue %u item %u overtime!", queue_id, element_id);
5369 : :
5370 : 0 : rc = zxdh_np_dtb_down_table_element_info_prt(dev_id, queue_id, element_id);
5371 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_down_table_element_info_prt");
5372 : :
5373 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5374 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
5375 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
5376 : :
5377 : 0 : return ZXDH_ERR;
5378 : : }
5379 : :
5380 : 0 : rd_cnt++;
5381 : 0 : rte_delay_us(ZXDH_DTB_DELAY_TIME);
5382 : : }
5383 : :
5384 [ # # ]: 0 : if ((ack_value & 0xff) != ZXDH_DTB_TAB_ACK_SUCCESS_MASK) {
5385 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5386 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
5387 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
5388 : 0 : return ack_value & 0xff;
5389 : : }
5390 : :
5391 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5392 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
5393 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
5394 : :
5395 : 0 : return rc;
5396 : : }
5397 : :
5398 : : static uint32_t
5399 : 0 : zxdh_np_hash_get_hash_info_from_sdt(uint32_t dev_id,
5400 : : uint32_t sdt_no, HASH_ENTRY_CFG *p_hash_entry_cfg)
5401 : : {
5402 : : uint32_t rc = ZXDH_OK;
5403 : : ZXDH_FUNC_ID_INFO *p_func_info = NULL;
5404 : : ZXDH_SE_CFG *p_se_cfg = NULL;
5405 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash_info = {0};
5406 : :
5407 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
5408 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash_info);
5409 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_read");
5410 : :
5411 : 0 : p_hash_entry_cfg->fun_id = sdt_hash_info.hash_id;
5412 : 0 : p_hash_entry_cfg->table_id = sdt_hash_info.hash_table_id;
5413 : 0 : p_hash_entry_cfg->bulk_id = ((p_hash_entry_cfg->table_id >> 2) & 0x7);
5414 : 0 : p_hash_entry_cfg->key_type = sdt_hash_info.hash_table_width;
5415 : 0 : p_hash_entry_cfg->rsp_mode = sdt_hash_info.rsp_mode;
5416 : 0 : p_hash_entry_cfg->actu_key_size = sdt_hash_info.key_size;
5417 : 0 : p_hash_entry_cfg->key_by_size = ZXDH_GET_KEY_SIZE(p_hash_entry_cfg->actu_key_size);
5418 [ # # ]: 0 : p_hash_entry_cfg->rst_by_size = ZXDH_GET_RST_SIZE(p_hash_entry_cfg->key_type,
5419 : : p_hash_entry_cfg->actu_key_size);
5420 : :
5421 : 0 : p_se_cfg = dpp_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
5422 : 0 : p_hash_entry_cfg->p_se_cfg = p_se_cfg;
5423 : :
5424 : : p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, p_hash_entry_cfg->fun_id);
5425 : :
5426 : 0 : p_hash_entry_cfg->p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
5427 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_entry_cfg->p_hash_cfg);
5428 : :
5429 : 0 : return ZXDH_OK;
5430 : : }
5431 : :
5432 : : static void
5433 : 0 : zxdh_np_hash_set_crc_key(HASH_ENTRY_CFG *p_hash_entry_cfg,
5434 : : ZXDH_HASH_ENTRY *p_entry, uint8_t *p_temp_key)
5435 : : {
5436 : : uint32_t key_by_size = 0;
5437 : : uint8_t temp_tbl_id = 0;
5438 : :
5439 : 0 : key_by_size = p_hash_entry_cfg->key_by_size;
5440 : 0 : memcpy(p_temp_key, p_entry->p_key, key_by_size);
5441 : :
5442 : 0 : temp_tbl_id = (*p_temp_key) & 0x1F;
5443 : 0 : memmove(p_temp_key, p_temp_key + 1, key_by_size - ZXDH_HASH_KEY_CTR_SIZE);
5444 : 0 : p_temp_key[key_by_size - ZXDH_HASH_KEY_CTR_SIZE] = temp_tbl_id;
5445 : 0 : }
5446 : :
5447 : : static uint8_t
5448 : 0 : zxdh_np_hash_sdt_partner_valid(uint32_t sdt_no, uint32_t sdt_partner, uint8_t *p_key)
5449 : : {
5450 : : uint32_t rc = ZXDH_OK;
5451 : : uint32_t dev_id = 0;
5452 : : uint32_t key_valid = 1;
5453 : :
5454 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash1 = {0};
5455 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash2 = {0};
5456 : :
5457 : 0 : if (sdt_no == sdt_partner ||
5458 [ # # # # ]: 0 : sdt_partner <= ZXDH_DEV_SDT_ID_MAX ||
5459 : : p_key == NULL) {
5460 : : return ZXDH_FALSE;
5461 : : }
5462 : :
5463 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
5464 : 0 : PMD_DRV_LOG(DEBUG, "sdt_partner:%u", sdt_partner);
5465 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash1);
5466 : 0 : rc |= zxdh_np_soft_sdt_tbl_get(dev_id, sdt_partner, &sdt_hash2);
5467 [ # # ]: 0 : if (rc != ZXDH_OK)
5468 : : return ZXDH_FALSE;
5469 : :
5470 [ # # ]: 0 : if (sdt_hash1.table_type != (ZXDH_SDT_TBLT_HASH) ||
5471 [ # # ]: 0 : sdt_hash2.table_type != ZXDH_SDT_TBLT_HASH ||
5472 [ # # ]: 0 : sdt_hash1.hash_table_width != sdt_hash2.hash_table_width ||
5473 [ # # ]: 0 : sdt_hash1.key_size != sdt_hash2.key_size ||
5474 [ # # ]: 0 : sdt_hash1.rsp_mode != sdt_hash2.rsp_mode) {
5475 : : return ZXDH_FALSE;
5476 : : }
5477 : :
5478 : 0 : *p_key = ZXDH_GET_HASH_KEY_CTRL(key_valid,
5479 : : sdt_hash2.hash_table_width,
5480 : : sdt_hash2.hash_table_id);
5481 : :
5482 : 0 : return ZXDH_TRUE;
5483 : : }
5484 : :
5485 : : static uint32_t
5486 : 0 : zxdh_np_hash_red_black_node_alloc(ZXDH_RB_TN **p_rb_tn_new,
5487 : : ZXDH_HASH_RBKEY_INFO **p_rbkey_new)
5488 : : {
5489 : : ZXDH_RB_TN *p_rb_tn_new_temp = NULL;
5490 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_new_temp = NULL;
5491 : :
5492 : 0 : p_rbkey_new_temp = rte_zmalloc(NULL, sizeof(ZXDH_HASH_RBKEY_INFO), 0);
5493 [ # # ]: 0 : if (p_rbkey_new_temp == NULL) {
5494 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
5495 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5496 : : }
5497 : :
5498 : 0 : p_rb_tn_new_temp = rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
5499 [ # # ]: 0 : if (p_rb_tn_new_temp == NULL) {
5500 : 0 : rte_free(p_rbkey_new_temp);
5501 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
5502 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5503 : : }
5504 : :
5505 : : zxdh_np_init_rbt_tn(p_rb_tn_new_temp, p_rbkey_new_temp);
5506 : :
5507 : 0 : *p_rb_tn_new = p_rb_tn_new_temp;
5508 : 0 : *p_rbkey_new = p_rbkey_new_temp;
5509 : :
5510 : 0 : return ZXDH_OK;
5511 : : }
5512 : :
5513 : : static uint32_t
5514 : 0 : zxdh_np_hash_rb_insert(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5515 : : ZXDH_HASH_ENTRY *p_entry)
5516 : : {
5517 : : uint32_t rc = ZXDH_OK;
5518 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
5519 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
5520 : 0 : ZXDH_HASH_RBKEY_INFO *p_rbkey_new = p_hash_entry_cfg->p_rbkey_new;
5521 : 0 : ZXDH_RB_TN *p_rb_tn_new = p_hash_entry_cfg->p_rb_tn_new;
5522 : 0 : ZXDH_HASH_CFG *p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5523 : 0 : uint32_t rst_actual_size = ((p_hash_entry_cfg->rst_by_size) > ZXDH_HASH_RST_MAX) ?
5524 : : ZXDH_HASH_RST_MAX : p_hash_entry_cfg->rst_by_size;
5525 : :
5526 : 0 : rc = zxdh_comm_rb_insert(&p_hash_cfg->hash_rb, (void *)p_rb_tn_new, (void *)(&p_rb_tn_rtn));
5527 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_FULL) {
5528 : 0 : PMD_DRV_LOG(ERR, "The red black tree is full!");
5529 : 0 : rte_free(p_rbkey_new);
5530 : 0 : rte_free(p_rb_tn_new);
5531 : : RTE_ASSERT(0);
5532 : 0 : return ZXDH_HASH_RC_RB_TREE_FULL;
5533 [ # # ]: 0 : } else if (rc == ZXDH_RBT_RC_UPDATE) {
5534 : 0 : p_hash_cfg->hash_stat.insert_same++;
5535 : 0 : PMD_DRV_LOG(DEBUG, "Hash update exist entry!");
5536 : :
5537 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
5538 : 0 : p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
5539 : :
5540 : 0 : memcpy(p_rbkey_rtn->rst, p_entry->p_rst, rst_actual_size);
5541 : :
5542 : 0 : rte_free(p_rbkey_new);
5543 : 0 : rte_free(p_rb_tn_new);
5544 : 0 : p_hash_entry_cfg->p_rbkey_new = p_rbkey_rtn;
5545 : 0 : p_hash_entry_cfg->p_rb_tn_new = p_rb_tn_rtn;
5546 : :
5547 : 0 : return ZXDH_HASH_RC_ADD_UPDATE;
5548 : : }
5549 : 0 : PMD_DRV_LOG(DEBUG, "Hash insert new entry!");
5550 : :
5551 [ # # ]: 0 : memcpy(p_rbkey_new->rst, p_entry->p_rst, rst_actual_size);
5552 [ # # ]: 0 : p_rbkey_new->entry_size = ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type);
5553 : : zxdh_np_init_d_node(&p_rbkey_new->entry_dn, p_rbkey_new);
5554 : :
5555 : 0 : return rc;
5556 : : }
5557 : :
5558 : : static uint32_t
5559 : : zxdh_np_hash_get_item_free_pos(uint32_t item_entry_max,
5560 : : uint32_t wrt_mask, uint32_t entry_size)
5561 : : {
5562 : : uint32_t i = 0;
5563 : : uint32_t pos = 0xFFFFFFFF;
5564 : : uint32_t mask = 0;
5565 : :
5566 [ # # ]: 0 : for (i = 0; i < item_entry_max; i += entry_size / ZXDH_HASH_ENTRY_POS_STEP) {
5567 : : mask = ZXDH_GET_HASH_ENTRY_MASK(entry_size, i);
5568 : :
5569 [ # # ]: 0 : if (0 == (mask & wrt_mask)) {
5570 : : pos = i;
5571 : : break;
5572 : : }
5573 : : }
5574 : :
5575 : : return pos;
5576 : : }
5577 : :
5578 : : static uint32_t
5579 : 0 : zxdh_np_hash_insrt_to_item(ZXDH_HASH_CFG *p_hash_cfg,
5580 : : ZXDH_HASH_RBKEY_INFO *p_rbkey,
5581 : : ZXDH_SE_ITEM_CFG *p_item,
5582 : : uint32_t item_idx,
5583 : : uint32_t item_type,
5584 : : __rte_unused uint32_t insrt_key_type)
5585 : : {
5586 : : uint32_t rc = ZXDH_OK;
5587 : :
5588 : : uint32_t free_pos = 0;
5589 : 0 : uint32_t dev_id = p_hash_cfg->p_se_info->dev_id;
5590 : : uint32_t item_entry_max = 4;
5591 : :
5592 [ # # ]: 0 : if (item_type == ZXDH_ITEM_DDR_256)
5593 : : item_entry_max = 2;
5594 : :
5595 [ # # ]: 0 : if (!p_item->valid) {
5596 : 0 : rc = zxdh_comm_double_link_init(item_entry_max, &p_item->item_list);
5597 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
5598 : :
5599 : 0 : p_rbkey->entry_pos = 0;
5600 : 0 : p_item->wrt_mask = ZXDH_GET_HASH_ENTRY_MASK(p_rbkey->entry_size,
5601 : : p_rbkey->entry_pos);
5602 : 0 : p_item->item_index = item_idx;
5603 : 0 : p_item->item_type = item_type;
5604 : 0 : p_item->valid = 1;
5605 : : } else {
5606 : 0 : free_pos = zxdh_np_hash_get_item_free_pos(item_entry_max,
5607 : 0 : p_item->wrt_mask, p_rbkey->entry_size);
5608 : :
5609 [ # # ]: 0 : if (free_pos == 0xFFFFFFFF)
5610 : : return ZXDH_HASH_RC_ITEM_FULL;
5611 : 0 : p_rbkey->entry_pos = free_pos;
5612 : 0 : p_item->wrt_mask |=
5613 : : ZXDH_GET_HASH_ENTRY_MASK(p_rbkey->entry_size, p_rbkey->entry_pos);
5614 : : }
5615 : :
5616 : 0 : PMD_DRV_LOG(DEBUG, "pos is[%u], size is[%u]", free_pos, p_rbkey->entry_size);
5617 : :
5618 [ # # ]: 0 : rc = zxdh_comm_double_link_insert_last(&p_rbkey->entry_dn, &p_item->item_list);
5619 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_last");
5620 : :
5621 : 0 : p_rbkey->p_item_info = p_item;
5622 : :
5623 : 0 : return rc;
5624 : : }
5625 : :
5626 : : static uint32_t
5627 : 0 : zxdh_np_hash_insert_ddr(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5628 : : uint8_t *p_temp_key, uint8_t *p_end_flag)
5629 : : {
5630 : 0 : ZXDH_HASH_CFG *p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5631 : 0 : uint8_t bulk_id = p_hash_entry_cfg->bulk_id;
5632 : 0 : HASH_DDR_CFG *p_ddr_cfg = p_hash_cfg->p_bulk_ddr_info[bulk_id];
5633 : : uint8_t key_type = 0;
5634 : 0 : uint8_t table_id = p_hash_entry_cfg->table_id;
5635 : : uint32_t key_by_size = 0;
5636 : : uint32_t crc_value = 0;
5637 : : uint32_t item_idx = 0xFFFFFFFF;
5638 : : uint32_t item_type = 0;
5639 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5640 : : uint32_t rc = ZXDH_OK;
5641 : :
5642 : 0 : key_type = p_hash_entry_cfg->key_type;
5643 [ # # # # ]: 0 : if (ZXDH_HASH_KEY_512b == key_type && ZXDH_DDR_WIDTH_256b == p_ddr_cfg->width_mode) {
5644 : 0 : PMD_DRV_LOG(ERR, "hash ddr width mode is not match to the key type.");
5645 : 0 : return ZXDH_HASH_RC_DDR_WIDTH_MODE_ERR;
5646 : : }
5647 : :
5648 : 0 : key_by_size = p_hash_entry_cfg->key_by_size;
5649 : 0 : crc_value = p_hash_cfg->p_hash32_fun(p_temp_key, key_by_size, p_ddr_cfg->hash_ddr_arg);
5650 : 0 : PMD_DRV_LOG(DEBUG, "hash ddr arg is: 0x%x.crc_value is 0x%x",
5651 : : p_ddr_cfg->hash_ddr_arg, crc_value);
5652 : :
5653 : 0 : item_idx = crc_value % p_ddr_cfg->item_num;
5654 : : item_type = ZXDH_ITEM_DDR_256;
5655 [ # # ]: 0 : if (ZXDH_DDR_WIDTH_512b == p_ddr_cfg->width_mode) {
5656 : : item_idx = crc_value % p_ddr_cfg->item_num;
5657 : : item_type = ZXDH_ITEM_DDR_512;
5658 : : }
5659 : :
5660 : 0 : PMD_DRV_LOG(DEBUG, "Hash insert in ITEM_DDR_%s, item_idx is: 0x%x.",
5661 : : ((item_type == ZXDH_ITEM_DDR_256) ? "256" : "512"), item_idx);
5662 : :
5663 : 0 : p_item = p_ddr_cfg->p_item_array[item_idx];
5664 [ # # ]: 0 : if (p_item == NULL) {
5665 : 0 : p_item = rte_zmalloc(NULL, sizeof(ZXDH_SE_ITEM_CFG), 0);
5666 [ # # ]: 0 : if (p_item == NULL) {
5667 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
5668 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5669 : : }
5670 : 0 : p_ddr_cfg->p_item_array[item_idx] = p_item;
5671 : : }
5672 : :
5673 : 0 : rc = zxdh_np_hash_insrt_to_item(p_hash_cfg,
5674 : : p_hash_entry_cfg->p_rbkey_new,
5675 : : p_item,
5676 : : item_idx,
5677 : : item_type,
5678 : : key_type);
5679 : :
5680 [ # # ]: 0 : if (rc != ZXDH_HASH_RC_ITEM_FULL) {
5681 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_insrt_to_item");
5682 : 0 : *p_end_flag = 1;
5683 : :
5684 : 0 : p_hash_cfg->hash_stat.insert_ddr++;
5685 : 0 : p_hash_cfg->hash_stat.insert_table[table_id].ddr++;
5686 : :
5687 : 0 : p_item->hw_addr = GET_HASH_DDR_HW_ADDR(p_ddr_cfg->hw_baddr, item_idx);
5688 : 0 : p_item->bulk_id = p_hash_entry_cfg->bulk_id;
5689 : : }
5690 : :
5691 : : return rc;
5692 : : }
5693 : :
5694 : : static uint32_t
5695 : 0 : zxdh_np_hash_insert_zcell(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5696 : : uint8_t *p_temp_key, uint8_t *p_end_flag)
5697 : : {
5698 : 0 : uint8_t bulk_id = p_hash_entry_cfg->bulk_id;
5699 : : ZXDH_D_NODE *p_zcell_dn = NULL;
5700 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
5701 : : uint32_t zblk_idx = 0;
5702 : : uint32_t zcell_id = 0;
5703 : : uint32_t pre_zblk_idx = 0xFFFFFFFF;
5704 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5705 : : uint32_t item_idx = 0xFFFFFFFF;
5706 : : uint32_t item_type = 0;
5707 : : uint32_t rc = ZXDH_OK;
5708 : : uint32_t crc_value = 0;
5709 : 0 : uint8_t table_id = p_hash_entry_cfg->table_id;
5710 : : ZXDH_SE_CFG *p_se_cfg = NULL;
5711 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
5712 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
5713 : :
5714 : 0 : PMD_DRV_LOG(DEBUG, "insert zcell start");
5715 : 0 : p_se_cfg = p_hash_entry_cfg->p_se_cfg;
5716 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
5717 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5718 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
5719 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
5720 : :
5721 [ # # ]: 0 : while (p_zcell_dn) {
5722 : 0 : p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
5723 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_zcell);
5724 : :
5725 [ # # # # : 0 : if (((p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO) && p_zcell->bulk_id != bulk_id) ||
# # ]
5726 : 0 : ((!(p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO)) &&
5727 [ # # ]: 0 : p_hash_cfg->bulk_ram_mono[bulk_id])) {
5728 : 0 : p_zcell_dn = p_zcell_dn->next;
5729 : 0 : continue;
5730 : : }
5731 : :
5732 : 0 : zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
5733 : : p_zblk = &p_se_cfg->zblk_info[zblk_idx];
5734 [ # # ]: 0 : if (zblk_idx != pre_zblk_idx) {
5735 : : pre_zblk_idx = zblk_idx;
5736 : 0 : crc_value = p_hash_cfg->p_hash16_fun(p_temp_key,
5737 : 0 : p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
5738 : : }
5739 : :
5740 : 0 : PMD_DRV_LOG(DEBUG, "zblk_idx:[0x%x] hash_arg:[0x%x] crc_value:[0x%x]",
5741 : : zblk_idx, p_zblk->hash_arg, crc_value);
5742 : :
5743 : 0 : zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
5744 : 0 : item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc_value);
5745 : 0 : p_item = &p_zcell->item_info[item_idx];
5746 : : item_type = ZXDH_ITEM_RAM;
5747 : :
5748 : 0 : PMD_DRV_LOG(DEBUG, "zcell_id:[0x%x] item_idx:[0x%x]", zcell_id, item_idx);
5749 : :
5750 : 0 : rc = zxdh_np_hash_insrt_to_item(p_hash_cfg,
5751 : : p_hash_entry_cfg->p_rbkey_new,
5752 : : p_item,
5753 : : item_idx,
5754 : : item_type,
5755 : 0 : p_hash_entry_cfg->key_type);
5756 : :
5757 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_ITEM_FULL) {
5758 : 0 : PMD_DRV_LOG(DEBUG, "The item is full, check next.");
5759 : : } else {
5760 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_insrt_to_item");
5761 : 0 : *p_end_flag = 1;
5762 : :
5763 : 0 : p_hash_cfg->hash_stat.insert_zcell++;
5764 : 0 : p_hash_cfg->hash_stat.insert_table[table_id].zcell++;
5765 : :
5766 : 0 : p_item->hw_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
5767 : 0 : break;
5768 : : }
5769 : :
5770 : 0 : p_zcell_dn = p_zcell_dn->next;
5771 : : }
5772 : :
5773 : 0 : return rc;
5774 : : }
5775 : :
5776 : : static uint32_t
5777 : 0 : zxdh_np_hash_insert_zreg(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5778 : : __rte_unused uint8_t *p_temp_key, uint8_t *p_end_flag)
5779 : : {
5780 : 0 : ZXDH_HASH_CFG *p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5781 : 0 : ZXDH_D_NODE *p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
5782 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
5783 : : ZXDH_SE_ZREG_CFG *p_zreg = NULL;
5784 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5785 : : uint8_t reg_index = 0;
5786 : : uint32_t zblk_idx = 0;
5787 : : uint32_t rc = ZXDH_OK;
5788 : 0 : uint8_t bulk_id = p_hash_entry_cfg->bulk_id;
5789 : : uint32_t item_idx = 0xFFFFFFFF;
5790 : : uint32_t item_type = 0;
5791 : 0 : uint32_t table_id = p_hash_entry_cfg->table_id;
5792 : :
5793 [ # # ]: 0 : while (p_zblk_dn) {
5794 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
5795 : 0 : zblk_idx = p_zblk->zblk_idx;
5796 : :
5797 [ # # ]: 0 : for (reg_index = 0; reg_index < ZXDH_SE_ZREG_NUM; reg_index++) {
5798 : 0 : p_zreg = &p_zblk->zreg_info[reg_index];
5799 : :
5800 [ # # ]: 0 : if (((p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO) &&
5801 [ # # # # ]: 0 : p_zreg->bulk_id != bulk_id) ||
5802 : 0 : ((!(p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO)) &&
5803 [ # # ]: 0 : p_hash_cfg->bulk_ram_mono[bulk_id])) {
5804 : 0 : continue;
5805 : : }
5806 : :
5807 : 0 : p_item = &p_zblk->zreg_info[reg_index].item_info;
5808 : : item_type = ZXDH_ITEM_REG;
5809 : 0 : item_idx = reg_index;
5810 : 0 : rc = zxdh_np_hash_insrt_to_item(p_hash_cfg,
5811 : : p_hash_entry_cfg->p_rbkey_new,
5812 : : p_item,
5813 : : item_idx,
5814 : : item_type,
5815 : 0 : p_hash_entry_cfg->key_type);
5816 : :
5817 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_ITEM_FULL) {
5818 : 0 : PMD_DRV_LOG(DEBUG, "The item is full, check next.");
5819 : : } else {
5820 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_insrt_to_item");
5821 : 0 : *p_end_flag = 1;
5822 : :
5823 : 0 : p_hash_cfg->hash_stat.insert_zreg++;
5824 : 0 : p_hash_cfg->hash_stat.insert_table[table_id].zreg++;
5825 : :
5826 : 0 : p_item->hw_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx,
5827 : : reg_index);
5828 : 0 : break;
5829 : : }
5830 : : }
5831 : :
5832 [ # # ]: 0 : if (*p_end_flag)
5833 : : break;
5834 : :
5835 : 0 : p_zblk_dn = p_zblk_dn->next;
5836 : : }
5837 : :
5838 : 0 : return rc;
5839 : : }
5840 : :
5841 : : static uint32_t
5842 : 0 : zxdh_np_dtb_hash_form_write(ZXDH_HASH_CFG *p_hash_cfg,
5843 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_new,
5844 : : uint32_t actu_key_size,
5845 : : ZXDH_DTB_ENTRY_T *p_entry,
5846 : : __rte_unused uint32_t opr_mode)
5847 : : {
5848 : : uint32_t key_type = 0;
5849 : : uint32_t key_by_size = 0;
5850 : : uint32_t rst_by_size = 0;
5851 : : uint32_t byte_offset = 0;
5852 : 0 : uint32_t dev_id = p_hash_cfg->p_se_info->dev_id;
5853 : : uint32_t addr;
5854 : :
5855 : : ZXDH_D_NODE *p_entry_dn = NULL;
5856 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
5857 : 0 : uint8_t entry_data[ZXDH_SE_ENTRY_WIDTH_MAX] = {0};
5858 : 0 : ZXDH_SE_ITEM_CFG *p_item_info = p_rbkey_new->p_item_info;
5859 : :
5860 [ # # ]: 0 : if (p_item_info == NULL) {
5861 : 0 : PMD_DRV_LOG(ERR, "p_item_info point null!");
5862 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5863 : : }
5864 : :
5865 : 0 : PMD_DRV_LOG(DEBUG, "zcam p_item_info->hw_addr is 0x%x",
5866 : : p_item_info->hw_addr);
5867 : 0 : addr = p_item_info->hw_addr;
5868 : :
5869 : 0 : p_entry_dn = p_item_info->item_list.p_next;
5870 : :
5871 [ # # ]: 0 : while (p_entry_dn) {
5872 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)(p_entry_dn->data);
5873 : 0 : key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
5874 [ # # ]: 0 : key_by_size = ZXDH_GET_KEY_SIZE(actu_key_size);
5875 : : rst_by_size = ZXDH_GET_RST_SIZE(key_type, actu_key_size);
5876 : :
5877 : 0 : byte_offset = p_rbkey->entry_pos * ZXDH_HASH_ENTRY_POS_STEP;
5878 : 0 : memcpy(entry_data + byte_offset, p_rbkey->key, key_by_size);
5879 : :
5880 : 0 : byte_offset += key_by_size;
5881 : 0 : memcpy(entry_data + byte_offset, p_rbkey->rst,
5882 : 0 : ((rst_by_size > ZXDH_HASH_RST_MAX) ? ZXDH_HASH_RST_MAX : rst_by_size));
5883 : :
5884 : 0 : p_entry_dn = p_entry_dn->next;
5885 : : }
5886 : :
5887 : : zxdh_np_comm_swap(entry_data, ZXDH_SE_ENTRY_WIDTH_MAX);
5888 : :
5889 : 0 : zxdh_np_dtb_se_alg_zcam_data_write(dev_id,
5890 : : addr,
5891 : : entry_data,
5892 : : p_entry);
5893 : :
5894 : 0 : return ZXDH_OK;
5895 : : }
5896 : :
5897 : : static uint32_t
5898 : 0 : zxdh_np_dtb_hash_delete(uint32_t dev_id,
5899 : : uint32_t sdt_no,
5900 : : ZXDH_HASH_ENTRY *p_hash_entry,
5901 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
5902 : : {
5903 : : uint32_t rc = ZXDH_OK;
5904 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
5905 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5906 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
5907 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
5908 : : ZXDH_SPINLOCK_T *p_hash_spinlock = NULL;
5909 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
5910 : 0 : ZXDH_HASH_RBKEY_INFO temp_rbkey = {0};
5911 : : HASH_DDR_CFG *bulk_ddr_info = NULL;
5912 : :
5913 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
5914 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
5915 : :
5916 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
5917 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
5918 : :
5919 : 0 : zxdh_np_dev_hash_opr_spinlock_get(dev_id, p_hash_cfg->fun_id, &p_hash_spinlock);
5920 : 0 : rte_spinlock_lock(&p_hash_spinlock->spinlock);
5921 : :
5922 : 0 : memcpy(temp_rbkey.key, p_hash_entry->p_key, hash_entry_cfg.key_by_size);
5923 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, &temp_rbkey, &p_rb_tn_rtn);
5924 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL) {
5925 : 0 : p_hash_cfg->hash_stat.delete_fail++;
5926 : 0 : PMD_DRV_LOG(ERR, "Error!there is not item in hash!");
5927 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5928 : 0 : return ZXDH_HASH_RC_DEL_SRHFAIL;
5929 : : }
5930 : :
5931 : 0 : p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
5932 [ # # ]: 0 : memset(p_rbkey_rtn->rst, 0, sizeof(p_rbkey_rtn->rst));
5933 : 0 : hash_entry_cfg.p_rbkey_new = p_rbkey_rtn;
5934 : 0 : hash_entry_cfg.p_rb_tn_new = p_rb_tn_rtn;
5935 : :
5936 [ # # ]: 0 : p_item = p_rbkey_rtn->p_item_info;
5937 : : rc = zxdh_comm_double_link_del(&p_rbkey_rtn->entry_dn, &p_item->item_list);
5938 : : if (rc != ZXDH_OK) {
5939 : : PMD_DRV_LOG(ERR, "zxdh_comm_double_link_del failed, rc=0x%x.", rc);
5940 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5941 : : return ZXDH_ERR;
5942 : : }
5943 : 0 : p_item->wrt_mask &= ~(ZXDH_GET_HASH_ENTRY_MASK(p_rbkey_rtn->entry_size,
5944 : 0 : p_rbkey_rtn->entry_pos)) & 0xF;
5945 : :
5946 : 0 : rc = zxdh_np_dtb_hash_form_write(hash_entry_cfg.p_hash_cfg,
5947 : : hash_entry_cfg.p_rbkey_new,
5948 : : hash_entry_cfg.actu_key_size,
5949 : : p_dtb_one_entry,
5950 : : ZXDH_DTB_ITEM_DELETE);
5951 [ # # ]: 0 : if (rc != ZXDH_OK) {
5952 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_dtb_hash_form_write failed, rc=0x%x.", rc);
5953 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5954 : 0 : return ZXDH_ERR;
5955 : : }
5956 : :
5957 [ # # ]: 0 : if (p_item->item_list.used == 0) {
5958 [ # # ]: 0 : if (p_item->item_type == ZXDH_ITEM_DDR_256 ||
5959 : : p_item->item_type == ZXDH_ITEM_DDR_512) {
5960 : 0 : bulk_ddr_info = p_hash_cfg->p_bulk_ddr_info[hash_entry_cfg.bulk_id];
5961 [ # # ]: 0 : if (p_item->item_index > bulk_ddr_info->item_num) {
5962 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5963 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
5964 : : }
5965 : 0 : bulk_ddr_info->p_item_array[p_item->item_index] = NULL;
5966 : 0 : rte_free(p_item);
5967 : : } else {
5968 : 0 : p_item->valid = 0;
5969 : : }
5970 : : }
5971 : :
5972 : 0 : rte_free(p_rbkey_rtn);
5973 : 0 : rte_free(p_rb_tn_rtn);
5974 : 0 : p_hash_cfg->hash_stat.delete_ok++;
5975 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5976 : 0 : return rc;
5977 : : }
5978 : :
5979 : : static uint32_t
5980 : 0 : zxdh_np_dtb_hash_insert(uint32_t dev_id,
5981 : : uint32_t sdt_no,
5982 : : ZXDH_HASH_ENTRY *p_hash_entry,
5983 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
5984 : : {
5985 : : uint32_t rc = ZXDH_OK;
5986 : 0 : uint8_t end_flag = 0;
5987 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
5988 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
5989 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
5990 : 0 : ZXDH_RB_TN *p_rb_tn_new = NULL;
5991 : 0 : ZXDH_HASH_RBKEY_INFO *p_rbkey_new = NULL;
5992 : : ZXDH_SPINLOCK_T *p_hash_spinlock = NULL;
5993 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
5994 : :
5995 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
5996 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
5997 : :
5998 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
5999 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
6000 : :
6001 : 0 : zxdh_np_dev_hash_opr_spinlock_get(dev_id, p_hash_cfg->fun_id, &p_hash_spinlock);
6002 : 0 : rte_spinlock_lock(&p_hash_spinlock->spinlock);
6003 : :
6004 : 0 : rc = zxdh_np_hash_red_black_node_alloc(&p_rb_tn_new, &p_rbkey_new);
6005 [ # # ]: 0 : if (rc != ZXDH_OK) {
6006 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_hash_red_black_node_alloc failed, rc=0x%x.", rc);
6007 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6008 : 0 : return ZXDH_ERR;
6009 : : }
6010 : 0 : memcpy(p_rbkey_new->key, p_hash_entry->p_key,
6011 : 0 : hash_entry_cfg.key_by_size);
6012 : 0 : hash_entry_cfg.p_rbkey_new = p_rbkey_new;
6013 : 0 : hash_entry_cfg.p_rb_tn_new = p_rb_tn_new;
6014 : :
6015 : 0 : rc = zxdh_np_hash_rb_insert(dev_id, &hash_entry_cfg, p_hash_entry);
6016 [ # # ]: 0 : if (rc != ZXDH_OK) {
6017 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_ADD_UPDATE) {
6018 : 0 : rc = zxdh_np_dtb_hash_form_write(p_hash_cfg,
6019 : : hash_entry_cfg.p_rbkey_new,
6020 : : hash_entry_cfg.actu_key_size,
6021 : : p_dtb_one_entry,
6022 : : ZXDH_DTB_ITEM_ADD_OR_UPDATE);
6023 [ # # ]: 0 : if (rc != ZXDH_OK) {
6024 : 0 : PMD_DRV_LOG(ERR, "dtb_hash_form_write failed, rc=0x%x.", rc);
6025 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6026 : 0 : return ZXDH_ERR;
6027 : : }
6028 : : }
6029 : :
6030 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6031 : 0 : return rc;
6032 : : }
6033 : :
6034 : 0 : zxdh_np_hash_set_crc_key(&hash_entry_cfg, p_hash_entry, temp_key);
6035 : :
6036 [ # # ]: 0 : if (p_hash_cfg->ddr_valid) {
6037 : 0 : rc = zxdh_np_hash_insert_ddr(dev_id, &hash_entry_cfg, temp_key, &end_flag);
6038 [ # # ]: 0 : if (rc != ZXDH_OK) {
6039 : 0 : PMD_DRV_LOG(ERR, "hash_insert_ddr failed, rc=0x%x.", rc);
6040 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6041 : 0 : return ZXDH_ERR;
6042 : : }
6043 : : }
6044 : :
6045 [ # # ]: 0 : if (!end_flag) {
6046 : 0 : rc = zxdh_np_hash_insert_zcell(dev_id, &hash_entry_cfg, temp_key, &end_flag);
6047 [ # # ]: 0 : if (rc != ZXDH_OK) {
6048 : 0 : PMD_DRV_LOG(ERR, "hash_insert_zcell failed, rc=0x%x.", rc);
6049 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6050 : 0 : return ZXDH_ERR;
6051 : : }
6052 : : }
6053 : :
6054 [ # # ]: 0 : if (!end_flag) {
6055 : 0 : rc = zxdh_np_hash_insert_zreg(dev_id, &hash_entry_cfg, temp_key, &end_flag);
6056 [ # # ]: 0 : if (rc != ZXDH_OK) {
6057 : 0 : PMD_DRV_LOG(ERR, "hash_insert_zreg failed, rc=0x%x.", rc);
6058 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6059 : 0 : return ZXDH_ERR;
6060 : : }
6061 : : }
6062 : :
6063 [ # # ]: 0 : if (!end_flag) {
6064 : 0 : p_hash_cfg->hash_stat.insert_fail++;
6065 : 0 : memcpy(temp_key, p_hash_entry->p_key, hash_entry_cfg.key_by_size);
6066 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, p_rbkey_new, &p_rb_tn_rtn);
6067 [ # # ]: 0 : if (rc != ZXDH_OK) {
6068 : 0 : PMD_DRV_LOG(ERR, "hash_insert_zreg failed, rc=0x%x.", rc);
6069 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6070 : 0 : return ZXDH_ERR;
6071 : : }
6072 : : RTE_ASSERT(p_rb_tn_new == p_rb_tn_rtn);
6073 : 0 : rte_free(p_rbkey_new);
6074 : 0 : rte_free(p_rb_tn_rtn);
6075 : 0 : PMD_DRV_LOG(ERR, "ZXDH_HASH_RC_TBL_FULL.sdt_no=%u", sdt_no);
6076 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6077 : 0 : return ZXDH_RC_DTB_DOWN_HASH_CONFLICT;
6078 : : }
6079 : :
6080 : 0 : rc = zxdh_np_dtb_hash_form_write(p_hash_cfg,
6081 : : hash_entry_cfg.p_rbkey_new,
6082 : : hash_entry_cfg.actu_key_size,
6083 : : p_dtb_one_entry,
6084 : : ZXDH_DTB_ITEM_ADD_OR_UPDATE);
6085 [ # # ]: 0 : if (rc != ZXDH_OK) {
6086 : 0 : PMD_DRV_LOG(ERR, "hash form write failed, rc=0x%x.", rc);
6087 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6088 : 0 : return ZXDH_ERR;
6089 : : }
6090 : :
6091 : 0 : p_hash_cfg->hash_stat.insert_ok++;
6092 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6093 : 0 : return rc;
6094 : : }
6095 : :
6096 : : static uint32_t
6097 : : zxdh_np_apt_get_sdt_partner(uint32_t dev_id, uint32_t sdt_no)
6098 : : {
6099 : : SE_APT_CALLBACK_T *p_apt_callback = NULL;
6100 : :
6101 : 0 : p_apt_callback = &g_apt_se_callback[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no];
6102 : :
6103 [ # # # # : 0 : if (p_apt_callback->table_type == ZXDH_SDT_TBLT_HASH)
# # # # #
# # # # #
# # ]
6104 : 0 : return p_apt_callback->se_func_info.hash_func.sdt_partner;
6105 : :
6106 [ # # # # : 0 : if (p_apt_callback->table_type == ZXDH_SDT_TBLT_ETCAM)
# # # # #
# # # # #
# # ]
6107 : 0 : return p_apt_callback->se_func_info.acl_func.sdt_partner;
6108 : :
6109 : : return UINT32_MAX;
6110 : : }
6111 : :
6112 : : static uint32_t
6113 : 0 : zxdh_np_dtb_hash_one_entry(uint32_t dev_id,
6114 : : uint32_t sdt_no,
6115 : : uint32_t del_en,
6116 : : void *p_data,
6117 : : uint32_t *p_dtb_len,
6118 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
6119 : : {
6120 : : uint32_t rc = ZXDH_OK;
6121 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
6122 : 0 : uint8_t temp_rst[ZXDH_HASH_RST_MAX] = {0};
6123 : : uint8_t key_valid = 1;
6124 : 0 : uint8_t key = 0;
6125 : : uint32_t sdt_partner = 0;
6126 : : uint8_t valid = 0;
6127 : :
6128 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash = {0};
6129 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_entry = NULL;
6130 : : ZXDH_HASH_ENTRY entry = {0};
6131 : :
6132 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6133 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash);
6134 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
6135 : :
6136 : 0 : entry.p_key = temp_key;
6137 : 0 : entry.p_rst = temp_rst;
6138 : 0 : entry.p_key[0] = ZXDH_GET_HASH_KEY_CTRL(key_valid,
6139 : : sdt_hash.hash_table_width,
6140 : : sdt_hash.hash_table_id);
6141 : : p_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_data;
6142 : 0 : memcpy(&entry.p_key[1], p_entry->p_actu_key,
6143 [ # # ]: 0 : ZXDH_GET_ACTU_KEY_BY_SIZE(sdt_hash.key_size));
6144 : 0 : memcpy(entry.p_rst, p_entry->p_rst, 4 * (0x1 << sdt_hash.rsp_mode));
6145 : :
6146 [ # # ]: 0 : if (del_en) {
6147 : : do {
6148 : 0 : rc = zxdh_np_dtb_hash_delete(dev_id, sdt_no, &entry, p_dtb_one_entry);
6149 : : sdt_partner = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
6150 : 0 : valid = zxdh_np_hash_sdt_partner_valid(sdt_no, sdt_partner, &key);
6151 : 0 : entry.p_key[0] = key;
6152 : : sdt_no = sdt_partner;
6153 [ # # ]: 0 : } while ((rc == ZXDH_HASH_RC_DEL_SRHFAIL) && (valid == ZXDH_TRUE));
6154 : :
6155 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_delete");
6156 : : } else {
6157 : : do {
6158 : 0 : rc = zxdh_np_dtb_hash_insert(dev_id, sdt_no, &entry, p_dtb_one_entry);
6159 : : sdt_partner = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
6160 : 0 : valid = zxdh_np_hash_sdt_partner_valid(sdt_no, sdt_partner, &key);
6161 : 0 : entry.p_key[0] = key;
6162 : : sdt_no = sdt_partner;
6163 [ # # ]: 0 : } while ((rc == ZXDH_RC_DTB_DOWN_HASH_CONFLICT) && (valid == ZXDH_TRUE));
6164 : :
6165 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_insert");
6166 : : }
6167 : :
6168 : 0 : *p_dtb_len = p_dtb_one_entry->data_size / ZXDH_DTB_LEN_POS_SETP + 1;
6169 : :
6170 : 0 : return rc;
6171 : : }
6172 : :
6173 : : static void
6174 : 0 : zxdh_np_acl_hdw_addr_get(ZXDH_ACL_TBL_CFG_T *p_tbl_cfg, uint32_t handle,
6175 : : uint32_t *p_block_idx, uint32_t *p_addr, uint32_t *p_wr_mask)
6176 : : {
6177 : 0 : uint32_t block_entry_num = ZXDH_ACL_ENTRY_MAX_GET(p_tbl_cfg->key_mode, 1);
6178 : 0 : uint32_t entry_pos = (handle % block_entry_num) % (1U << p_tbl_cfg->key_mode);
6179 : :
6180 : 0 : *p_block_idx = p_tbl_cfg->block_array[handle / block_entry_num];
6181 : 0 : *p_addr = (handle % block_entry_num) / (1U << p_tbl_cfg->key_mode);
6182 : 0 : *p_wr_mask = (((1U << (8U >> (p_tbl_cfg->key_mode))) - 1) <<
6183 : 0 : ((8U >> (p_tbl_cfg->key_mode)) * (entry_pos))) & 0xFF;
6184 : 0 : }
6185 : :
6186 : : static void
6187 : 0 : zxdh_np_etcam_dm_to_xy(ZXDH_ETCAM_ENTRY_T *p_dm,
6188 : : ZXDH_ETCAM_ENTRY_T *p_xy,
6189 : : uint32_t len)
6190 : : {
6191 : : uint32_t i = 0;
6192 : :
6193 : : RTE_ASSERT(p_dm->p_data && p_dm->p_mask && p_xy->p_data && p_xy->p_mask);
6194 : :
6195 [ # # ]: 0 : for (i = 0; i < len; i++) {
6196 : 0 : p_xy->p_data[i] = ZXDH_COMM_DM_TO_X(p_dm->p_data[i], p_dm->p_mask[i]);
6197 : 0 : p_xy->p_mask[i] = ZXDH_COMM_DM_TO_Y(p_dm->p_data[i], p_dm->p_mask[i]);
6198 : : }
6199 : 0 : }
6200 : :
6201 : : static uint32_t
6202 : : zxdh_np_eram_opr_mode_get(uint32_t as_mode)
6203 : : {
6204 : : uint32_t opr_mode = 0;
6205 : :
6206 [ # # # # : 0 : switch (as_mode) {
# # ]
6207 : : case ZXDH_ERAM128_TBL_128b:
6208 : : opr_mode = ZXDH_ERAM128_OPR_128b;
6209 : : break;
6210 : 0 : case ZXDH_ERAM128_TBL_64b:
6211 : : opr_mode = ZXDH_ERAM128_OPR_64b;
6212 : 0 : break;
6213 : 0 : case ZXDH_ERAM128_TBL_1b:
6214 : : opr_mode = ZXDH_ERAM128_OPR_1b;
6215 : 0 : break;
6216 : : default:
6217 : : break;
6218 : : }
6219 : :
6220 : : return opr_mode;
6221 : : }
6222 : :
6223 : : static uint32_t
6224 : 0 : zxdh_np_dtb_etcam_entry_add(uint32_t dev_id,
6225 : : uint32_t addr,
6226 : : uint32_t block_idx,
6227 : : uint32_t wr_mask,
6228 : : uint32_t opr_type,
6229 : : ZXDH_ETCAM_ENTRY_T *p_entry,
6230 : : ZXDH_DTB_ENTRY_T *p_entry_data,
6231 : : ZXDH_DTB_ENTRY_T *p_entry_mask)
6232 : : {
6233 : : uint32_t rc = ZXDH_OK;
6234 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6235 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6236 : 0 : ZXDH_ETCAM_ENTRY_T entry_xy = {0};
6237 : :
6238 : : RTE_ASSERT(p_entry->p_data && p_entry->p_mask);
6239 : :
6240 : 0 : entry_xy.p_data = temp_data;
6241 : 0 : entry_xy.p_mask = temp_mask;
6242 : :
6243 [ # # ]: 0 : if (opr_type == ZXDH_ETCAM_OPR_DM) {
6244 : 0 : zxdh_np_etcam_dm_to_xy(p_entry, &entry_xy,
6245 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
6246 : : } else {
6247 : 0 : memcpy(entry_xy.p_data, p_entry->p_data,
6248 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
6249 : 0 : memcpy(entry_xy.p_mask, p_entry->p_mask,
6250 : : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
6251 : : }
6252 : :
6253 : 0 : rc = zxdh_np_dtb_etcam_write_entry_data(dev_id, block_idx, 0, 1, 0, 0, 0,
6254 : : wr_mask, ZXDH_ETCAM_DTYPE_DATA, addr, 0, entry_xy.p_data, p_entry_data);
6255 : :
6256 : 0 : rc = zxdh_np_dtb_etcam_write_entry_data(dev_id, block_idx, 0, 1, 0, 0, 0,
6257 : : wr_mask, ZXDH_ETCAM_DTYPE_MASK, addr, 0xFF, entry_xy.p_mask, p_entry_mask);
6258 : :
6259 : 0 : return rc;
6260 : : }
6261 : :
6262 : : static uint32_t
6263 : 0 : zxdh_np_dtb_acl_delete(uint32_t dev_id,
6264 : : uint32_t sdt_no,
6265 : : ZXDH_ACL_ENTRY_EX_T *p_acl_entry,
6266 : : ZXDH_DTB_ENTRY_T *p_dtb_data_entry,
6267 : : ZXDH_DTB_ENTRY_T *p_dtb_mask_entry,
6268 : : ZXDH_DTB_ENTRY_T *p_dtb_as_entry)
6269 : : {
6270 : : uint32_t rc = ZXDH_OK;
6271 : : uint32_t as_eram_baddr = 0;
6272 : : uint32_t as_enable = 0;
6273 : : uint32_t etcam_table_id = 0;
6274 : : uint32_t etcam_as_mode = 0;
6275 : : uint32_t opr_mode = 0;
6276 : 0 : uint32_t block_idx = 0;
6277 : 0 : uint32_t ram_addr = 0;
6278 : 0 : uint32_t etcam_wr_mask = 0;
6279 : : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8];
6280 : : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8];
6281 : 0 : uint8_t temp_buf[16] = {0};
6282 : :
6283 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
6284 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
6285 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
6286 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry = {0};
6287 : :
6288 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6289 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
6290 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
6291 : :
6292 : 0 : etcam_as_mode = sdt_acl.as_rsp_mode;
6293 : 0 : etcam_table_id = sdt_acl.etcam_table_id;
6294 : 0 : as_enable = sdt_acl.as_en;
6295 : 0 : as_eram_baddr = sdt_acl.as_eram_baddr;
6296 : :
6297 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
6298 : :
6299 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
6300 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
6301 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
6302 : : RTE_ASSERT(0);
6303 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
6304 : : }
6305 : :
6306 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_acl_entry->pri,
6307 : : &block_idx, &ram_addr, &etcam_wr_mask);
6308 : :
6309 : : memset(temp_data, 0xff, ZXDH_ETCAM_WIDTH_MAX / 8);
6310 : : memset(temp_mask, 0, ZXDH_ETCAM_WIDTH_MAX / 8);
6311 : 0 : etcam_entry.mode = p_tbl_cfg->key_mode;
6312 : 0 : etcam_entry.p_data = temp_data;
6313 : 0 : etcam_entry.p_mask = temp_mask;
6314 : 0 : rc = zxdh_np_dtb_etcam_entry_add(dev_id,
6315 : : ram_addr,
6316 : : block_idx,
6317 : : etcam_wr_mask,
6318 : : ZXDH_ETCAM_OPR_DM,
6319 : : &etcam_entry,
6320 : : p_dtb_data_entry,
6321 : : p_dtb_mask_entry);
6322 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_etcam_entry_add");
6323 : :
6324 [ # # ]: 0 : if (as_enable) {
6325 : : memset(temp_buf, 0, sizeof(temp_buf));
6326 : : opr_mode = zxdh_np_eram_opr_mode_get(etcam_as_mode);
6327 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
6328 : : as_eram_baddr,
6329 : : p_acl_entry->pri,
6330 : : opr_mode,
6331 : : (uint32_t *)temp_buf,
6332 : : p_dtb_as_entry);
6333 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_smmu0_ind_write");
6334 : : }
6335 : :
6336 : : return rc;
6337 : : }
6338 : :
6339 : : static uint32_t
6340 : 0 : zxdh_np_dtb_acl_insert(uint32_t dev_id,
6341 : : uint32_t sdt_no,
6342 : : ZXDH_ACL_ENTRY_EX_T *p_acl_entry,
6343 : : ZXDH_DTB_ENTRY_T *p_dtb_data_entry,
6344 : : ZXDH_DTB_ENTRY_T *p_dtb_mask_entry,
6345 : : ZXDH_DTB_ENTRY_T *p_dtb_as_entry)
6346 : : {
6347 : : uint32_t rc = ZXDH_OK;
6348 : : uint32_t as_eram_baddr = 0;
6349 : : uint32_t as_enable = 0;
6350 : : uint32_t etcam_table_id = 0;
6351 : : uint32_t etcam_as_mode = 0;
6352 : : uint32_t opr_mode = 0;
6353 : 0 : uint32_t block_idx = 0;
6354 : 0 : uint32_t ram_addr = 0;
6355 : 0 : uint32_t etcam_wr_mask = 0;
6356 : :
6357 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
6358 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
6359 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
6360 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry = {0};
6361 : :
6362 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6363 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
6364 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
6365 : :
6366 : 0 : etcam_as_mode = sdt_acl.as_rsp_mode;
6367 : 0 : etcam_table_id = sdt_acl.etcam_table_id;
6368 : 0 : as_enable = sdt_acl.as_en;
6369 : 0 : as_eram_baddr = sdt_acl.as_eram_baddr;
6370 : :
6371 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
6372 : :
6373 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
6374 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
6375 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
6376 : : RTE_ASSERT(0);
6377 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
6378 : : }
6379 : :
6380 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_acl_entry->pri,
6381 : : &block_idx, &ram_addr, &etcam_wr_mask);
6382 : :
6383 : 0 : etcam_entry.mode = p_tbl_cfg->key_mode;
6384 : 0 : etcam_entry.p_data = p_acl_entry->key_data;
6385 : 0 : etcam_entry.p_mask = p_acl_entry->key_mask;
6386 : :
6387 : 0 : rc = zxdh_np_dtb_etcam_entry_add(dev_id,
6388 : : ram_addr,
6389 : : block_idx,
6390 : : etcam_wr_mask,
6391 : : ZXDH_ETCAM_OPR_DM,
6392 : : &etcam_entry,
6393 : : p_dtb_data_entry,
6394 : : p_dtb_mask_entry);
6395 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_etcam_entry_add");
6396 : :
6397 [ # # ]: 0 : if (as_enable) {
6398 : : opr_mode = zxdh_np_eram_opr_mode_get(etcam_as_mode);
6399 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
6400 : : as_eram_baddr,
6401 : : p_acl_entry->pri,
6402 : : opr_mode,
6403 : 0 : (uint32_t *)p_acl_entry->p_as_rslt,
6404 : : p_dtb_as_entry);
6405 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_smmu0_ind_write");
6406 : : }
6407 : :
6408 : : return rc;
6409 : : }
6410 : :
6411 : : static uint32_t
6412 : 0 : zxdh_np_dtb_acl_one_entry(uint32_t dev_id,
6413 : : uint32_t sdt_no,
6414 : : uint32_t del_en,
6415 : : void *p_data,
6416 : : uint32_t *p_dtb_len,
6417 : : uint8_t *p_data_buff)
6418 : : {
6419 : : uint32_t rc = ZXDH_OK;
6420 : : uint32_t addr_offset = 0;
6421 : 0 : ZXDH_ACL_ENTRY_EX_T acl_entry = {0};
6422 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_entry = NULL;
6423 : :
6424 : 0 : uint8_t data_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6425 : 0 : uint8_t mask_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6426 : 0 : uint8_t data_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6427 : 0 : uint8_t mask_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6428 : 0 : uint8_t as_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6429 : 0 : uint32_t as_data_buff[4] = {0};
6430 : :
6431 : 0 : ZXDH_DTB_ENTRY_T dtb_data_entry = {0};
6432 : 0 : ZXDH_DTB_ENTRY_T dtb_mask_entry = {0};
6433 : 0 : ZXDH_DTB_ENTRY_T dtb_as_entry = {0};
6434 : :
6435 : 0 : dtb_data_entry.cmd = data_cmd_buff;
6436 : 0 : dtb_data_entry.data = data_buff;
6437 : 0 : dtb_mask_entry.cmd = mask_cmd_buff;
6438 : 0 : dtb_mask_entry.data = mask_buff;
6439 : 0 : dtb_as_entry.cmd = as_cmd_buff;
6440 : 0 : dtb_as_entry.data = (uint8_t *)as_data_buff;
6441 : :
6442 : : p_entry = (ZXDH_DTB_ACL_ENTRY_INFO_T *)p_data;
6443 : 0 : acl_entry.pri = p_entry->handle;
6444 : 0 : acl_entry.key_data = p_entry->key_data;
6445 : 0 : acl_entry.key_mask = p_entry->key_mask;
6446 : 0 : acl_entry.p_as_rslt = p_entry->p_as_rslt;
6447 [ # # ]: 0 : if (del_en) {
6448 : 0 : rc = zxdh_np_dtb_acl_delete(dev_id,
6449 : : sdt_no,
6450 : : &acl_entry,
6451 : : &dtb_data_entry,
6452 : : &dtb_mask_entry,
6453 : : &dtb_as_entry);
6454 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_delete");
6455 : : } else {
6456 : 0 : rc = zxdh_np_dtb_acl_insert(dev_id,
6457 : : sdt_no,
6458 : : &acl_entry,
6459 : : &dtb_data_entry,
6460 : : &dtb_mask_entry,
6461 : : &dtb_as_entry);
6462 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_insert");
6463 : : }
6464 : :
6465 : 0 : addr_offset = (*p_dtb_len) * ZXDH_DTB_LEN_POS_SETP;
6466 : 0 : *p_dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
6467 : :
6468 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_data_entry);
6469 : :
6470 : 0 : addr_offset = (*p_dtb_len) * ZXDH_DTB_LEN_POS_SETP;
6471 : 0 : *p_dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
6472 : :
6473 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_mask_entry);
6474 : :
6475 : 0 : addr_offset = (*p_dtb_len) * ZXDH_DTB_LEN_POS_SETP;
6476 [ # # ]: 0 : if (dtb_as_entry.data_in_cmd_flag)
6477 : 0 : *p_dtb_len += 1;
6478 : : else
6479 : 0 : *p_dtb_len += 2;
6480 : :
6481 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_as_entry);
6482 : :
6483 : 0 : return ZXDH_OK;
6484 : : }
6485 : :
6486 : : int
6487 : 0 : zxdh_np_dtb_table_entry_write(uint32_t dev_id,
6488 : : uint32_t queue_id,
6489 : : uint32_t entrynum,
6490 : : ZXDH_DTB_USER_ENTRY_T *down_entries)
6491 : : {
6492 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
6493 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
6494 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT] = {0};
6495 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX] = {0};
6496 : : uint8_t *p_data_buff;
6497 : 0 : uint32_t element_id = 0xff;
6498 : 0 : uint32_t one_dtb_len = 0;
6499 : 0 : uint32_t dtb_len = 0;
6500 : : uint32_t entry_index;
6501 : : uint32_t sdt_no;
6502 : : uint32_t tbl_type;
6503 : : uint32_t addr_offset;
6504 : : uint32_t max_size;
6505 : : uint32_t rc = 0;
6506 : :
6507 : 0 : p_data_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
6508 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
6509 : :
6510 : 0 : dtb_one_entry.cmd = entry_cmd;
6511 : 0 : dtb_one_entry.data = entry_data;
6512 : :
6513 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
6514 : :
6515 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
6516 : 0 : pentry = down_entries + entry_index;
6517 : 0 : sdt_no = pentry->sdt_no;
6518 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6519 : : tbl_type = zxdh_np_sdt_tbl_type_get(dev_id, sdt_no);
6520 [ # # # # ]: 0 : switch (tbl_type) {
6521 : 0 : case ZXDH_SDT_TBLT_ERAM:
6522 : 0 : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
6523 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
6524 : 0 : break;
6525 : 0 : case ZXDH_SDT_TBLT_HASH:
6526 : 0 : rc = zxdh_np_dtb_hash_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
6527 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
6528 : 0 : break;
6529 : 0 : case ZXDH_SDT_TBLT_ETCAM:
6530 : 0 : rc = zxdh_np_dtb_acl_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
6531 : : pentry->p_entry_data, &dtb_len, p_data_buff);
6532 : 0 : continue;
6533 : 0 : default:
6534 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
6535 : 0 : rte_free(p_data_buff);
6536 : 0 : return 1;
6537 : : }
6538 : :
6539 : 0 : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
6540 : 0 : dtb_len += one_dtb_len;
6541 [ # # ]: 0 : if (dtb_len > max_size) {
6542 : 0 : rte_free(p_data_buff);
6543 : 0 : PMD_DRV_LOG(ERR, "error dtb_len>%u!", max_size);
6544 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6545 : : }
6546 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
6547 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
6548 : : memset(entry_data, 0x0, sizeof(entry_data));
6549 : : }
6550 : :
6551 [ # # ]: 0 : if (dtb_len == 0) {
6552 : 0 : rte_free(p_data_buff);
6553 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6554 : : }
6555 : :
6556 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
6557 : : queue_id,
6558 : : dtb_len * 16,
6559 : : p_data_buff,
6560 : : &element_id);
6561 : 0 : rte_free(p_data_buff);
6562 : :
6563 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, element_id);
6564 : :
6565 : 0 : return rc;
6566 : : }
6567 : :
6568 : : int
6569 : 0 : zxdh_np_dtb_table_entry_delete(uint32_t dev_id,
6570 : : uint32_t queue_id,
6571 : : uint32_t entrynum,
6572 : : ZXDH_DTB_USER_ENTRY_T *delete_entries)
6573 : : {
6574 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
6575 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
6576 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
6577 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6578 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6579 : : uint8_t *p_data_buff = NULL;
6580 : : uint32_t tbl_type = 0;
6581 : 0 : uint32_t element_id = 0xff;
6582 : 0 : uint32_t one_dtb_len = 0;
6583 : 0 : uint32_t dtb_len = 0;
6584 : : uint32_t entry_index;
6585 : : uint32_t sdt_no;
6586 : : uint32_t addr_offset;
6587 : : uint32_t max_size;
6588 : : uint32_t rc;
6589 : :
6590 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(delete_entries);
6591 : :
6592 : 0 : p_data_buff = rte_calloc(NULL, 1, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
6593 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
6594 : :
6595 : 0 : dtb_one_entry.cmd = entry_cmd;
6596 : 0 : dtb_one_entry.data = entry_data;
6597 : :
6598 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
6599 : :
6600 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
6601 : 0 : pentry = delete_entries + entry_index;
6602 : :
6603 : 0 : sdt_no = pentry->sdt_no;
6604 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6605 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
6606 : : tbl_type = zxdh_np_sdt_tbl_type_get(dev_id, sdt_no);
6607 [ # # # # ]: 0 : switch (tbl_type) {
6608 : 0 : case ZXDH_SDT_TBLT_ERAM:
6609 : 0 : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_DELETE,
6610 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
6611 : 0 : break;
6612 : 0 : case ZXDH_SDT_TBLT_HASH:
6613 : 0 : rc = zxdh_np_dtb_hash_one_entry(dev_id, sdt_no,
6614 : : ZXDH_DTB_ITEM_DELETE, pentry->p_entry_data,
6615 : : &one_dtb_len, &dtb_one_entry);
6616 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
6617 : 0 : continue;
6618 : : break;
6619 : 0 : case ZXDH_SDT_TBLT_ETCAM:
6620 : 0 : rc = zxdh_np_dtb_acl_one_entry(dev_id, sdt_no,
6621 : : ZXDH_DTB_ITEM_DELETE, pentry->p_entry_data,
6622 : : &dtb_len, p_data_buff);
6623 : 0 : continue;
6624 : 0 : default:
6625 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
6626 : 0 : rte_free(p_data_buff);
6627 : 0 : return 1;
6628 : : }
6629 : :
6630 : 0 : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
6631 : 0 : dtb_len += one_dtb_len;
6632 [ # # ]: 0 : if (dtb_len > max_size) {
6633 : 0 : rte_free(p_data_buff);
6634 : 0 : PMD_DRV_LOG(ERR, "error dtb_len>%u!", max_size);
6635 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6636 : : }
6637 : :
6638 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
6639 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
6640 : : memset(entry_data, 0x0, sizeof(entry_data));
6641 : : }
6642 : :
6643 [ # # ]: 0 : if (dtb_len == 0) {
6644 : 0 : rte_free(p_data_buff);
6645 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6646 : : }
6647 : :
6648 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
6649 : : queue_id,
6650 : : dtb_len * 16,
6651 : : p_data_buff,
6652 : : &element_id);
6653 : 0 : rte_free(p_data_buff);
6654 : :
6655 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, element_id);
6656 : :
6657 : 0 : return rc;
6658 : : }
6659 : :
6660 : : static void
6661 : : zxdh_np_eram_index_cal(uint32_t eram_mode, uint32_t index,
6662 : : uint32_t *p_row_index, uint32_t *p_col_index)
6663 : : {
6664 : : uint32_t row_index = 0;
6665 : : uint32_t col_index = 0;
6666 : :
6667 [ # # # # : 0 : switch (eram_mode) {
# # # # #
# # # # #
# # ]
6668 : 0 : case ZXDH_ERAM128_TBL_128b:
6669 : : row_index = index;
6670 : 0 : break;
6671 : 0 : case ZXDH_ERAM128_TBL_64b:
6672 : 0 : row_index = (index >> 1);
6673 : 0 : col_index = index & 0x1;
6674 : 0 : break;
6675 : 0 : case ZXDH_ERAM128_TBL_1b:
6676 : 0 : row_index = (index >> 7);
6677 : 0 : col_index = index & 0x7F;
6678 : 0 : break;
6679 : : default:
6680 : : break;
6681 : : }
6682 : : *p_row_index = row_index;
6683 : : *p_col_index = col_index;
6684 : : }
6685 : :
6686 : : static void
6687 : 0 : zxdh_np_stat_cfg_soft_get(uint32_t dev_id,
6688 : : ZXDH_PPU_STAT_CFG_T *p_stat_cfg)
6689 : : {
6690 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_stat_cfg);
6691 : :
6692 : 0 : p_stat_cfg->ddr_base_addr = g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].ddr_base_addr;
6693 : 0 : p_stat_cfg->eram_baddr = g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].eram_baddr;
6694 : 0 : p_stat_cfg->eram_depth = g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].eram_depth;
6695 : 0 : p_stat_cfg->ppu_addr_offset = g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].ppu_addr_offset;
6696 : 0 : }
6697 : :
6698 : : static uint32_t
6699 : 0 : zxdh_np_dtb_tab_up_info_set(uint32_t dev_id,
6700 : : uint32_t queue_id,
6701 : : uint32_t item_index,
6702 : : uint32_t int_flag,
6703 : : uint32_t data_len,
6704 : : uint32_t desc_len,
6705 : : uint32_t *p_desc_data)
6706 : : {
6707 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
6708 : 0 : uint32_t queue_en = 0;
6709 : : uint32_t rc;
6710 : : ZXDH_SPINLOCK_T *p_spinlock = NULL;
6711 : :
6712 : : zxdh_np_dev_dtb_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_DTB, queue_id, &p_spinlock);
6713 : 0 : rte_spinlock_lock(&p_spinlock->spinlock);
6714 : :
6715 : 0 : zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
6716 [ # # ]: 0 : if (!queue_en) {
6717 : 0 : PMD_DRV_LOG(ERR, "the queue %u is not enable!", queue_id);
6718 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6719 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
6720 : : }
6721 : :
6722 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6723 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init", queue_id);
6724 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6725 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6726 : : }
6727 : :
6728 [ # # ]: 0 : if (desc_len % 4 != 0) {
6729 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6730 : 0 : return ZXDH_RC_DTB_PARA_INVALID;
6731 : : }
6732 : :
6733 : 0 : zxdh_np_dtb_item_buff_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6734 : : item_index, 0, desc_len, p_desc_data);
6735 : :
6736 : 0 : ZXDH_DTB_TAB_UP_DATA_LEN_GET(dev_id, queue_id, item_index) = data_len;
6737 : :
6738 : 0 : item_info.cmd_vld = 1;
6739 : 0 : item_info.cmd_type = ZXDH_DTB_DIR_UP_TYPE;
6740 : 0 : item_info.int_en = int_flag;
6741 : 0 : item_info.data_len = desc_len / 4;
6742 : 0 : item_info.data_hddr =
6743 : 0 : ((ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) >> 4) >> 32) & 0xffffffff;
6744 : 0 : item_info.data_laddr =
6745 : 0 : (ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) >> 4) & 0xffffffff;
6746 : 0 : zxdh_dtb_info_print(dev_id, queue_id, item_index, &item_info);
6747 : :
6748 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
6749 : :
6750 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6751 : :
6752 : 0 : return rc;
6753 : : }
6754 : :
6755 : : static uint32_t
6756 : 0 : zxdh_np_dtb_tab_up_data_get(uint32_t dev_id,
6757 : : uint32_t queue_id,
6758 : : uint32_t item_index,
6759 : : uint32_t data_len,
6760 : : uint32_t *p_data)
6761 : : {
6762 : : uint32_t rc = 0;
6763 : :
6764 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6765 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
6766 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6767 : : }
6768 : :
6769 : 0 : rc = zxdh_np_dtb_item_buff_rd(dev_id,
6770 : : queue_id,
6771 : : ZXDH_DTB_DIR_UP_TYPE,
6772 : : item_index,
6773 : : 0,
6774 : : data_len,
6775 : : p_data);
6776 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_rd");
6777 : :
6778 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6779 : : item_index, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
6780 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
6781 : :
6782 : 0 : return rc;
6783 : : }
6784 : :
6785 : : static uint32_t
6786 : 0 : zxdh_np_dtb_tab_up_item_addr_get(uint32_t dev_id,
6787 : : uint32_t queue_id,
6788 : : uint32_t item_index,
6789 : : uint32_t *p_phy_haddr,
6790 : : uint32_t *p_phy_laddr)
6791 : : {
6792 : : uint32_t rc = 0;
6793 : : uint64_t addr;
6794 : :
6795 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6796 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
6797 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6798 : : }
6799 : :
6800 [ # # ]: 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
6801 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE)
6802 : 0 : addr = ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(dev_id, queue_id, item_index);
6803 : : else
6804 : 0 : addr = ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index)
6805 : : + ZXDH_DTB_ITEM_ACK_SIZE;
6806 : :
6807 : 0 : *p_phy_haddr = (addr >> 32) & 0xffffffff;
6808 : 0 : *p_phy_laddr = addr & 0xffffffff;
6809 : :
6810 : 0 : return rc;
6811 : : }
6812 : :
6813 : : static void
6814 : : zxdh_np_dtb_tab_up_item_offset_addr_get(uint32_t dev_id,
6815 : : uint32_t queue_id,
6816 : : uint32_t item_index,
6817 : : uint32_t addr_offset,
6818 : : uint32_t *p_phy_haddr,
6819 : : uint32_t *p_phy_laddr)
6820 : : {
6821 : : uint64_t addr = 0;
6822 : :
6823 : 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
6824 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE)
6825 : 0 : addr = ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(dev_id, queue_id, item_index);
6826 : : else
6827 : 0 : addr = ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) +
6828 : : ZXDH_DTB_ITEM_ACK_SIZE;
6829 : :
6830 : 0 : addr = addr + addr_offset;
6831 : :
6832 : 0 : *p_phy_haddr = (addr >> 32) & 0xffffffff;
6833 : 0 : *p_phy_laddr = addr & 0xffffffff;
6834 : : }
6835 : :
6836 : : static uint32_t
6837 : 0 : zxdh_np_dtb_dump_table_element_addr_get(uint32_t dev_id,
6838 : : uint32_t queue_id,
6839 : : uint32_t element_id,
6840 : : uint32_t *p_element_start_addr_h,
6841 : : uint32_t *p_element_start_addr_l,
6842 : : uint32_t *p_element_dump_addr_h,
6843 : : uint32_t *p_element_dump_addr_l,
6844 : : uint32_t *p_element_table_info_addr_h,
6845 : : uint32_t *p_element_table_info_addr_l)
6846 : : {
6847 : : uint32_t rc = ZXDH_OK;
6848 : : uint32_t addr_h = 0;
6849 : : uint32_t addr_l = 0;
6850 : :
6851 : 0 : addr_h = ((ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id)) >> 32) & 0xffffffff;
6852 : 0 : addr_l = (ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id)) & 0xffffffff;
6853 : :
6854 : 0 : *p_element_start_addr_h = addr_h;
6855 : 0 : *p_element_start_addr_l = addr_l;
6856 : :
6857 : 0 : addr_h = ((ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id) +
6858 : 0 : ZXDH_DTB_ITEM_ACK_SIZE) >> 32) & 0xffffffff;
6859 : 0 : addr_l = (ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id) +
6860 : : ZXDH_DTB_ITEM_ACK_SIZE) & 0xffffffff;
6861 : :
6862 : 0 : *p_element_dump_addr_h = addr_h;
6863 : 0 : *p_element_dump_addr_l = addr_l;
6864 : :
6865 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, element_id,
6866 : : p_element_table_info_addr_h, p_element_table_info_addr_l);
6867 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_get");
6868 : :
6869 : 0 : return rc;
6870 : : }
6871 : :
6872 : : static uint32_t
6873 : 0 : zxdh_np_dtb_dump_table_element_info_prt(uint32_t dev_id,
6874 : : uint32_t queue_id,
6875 : : uint32_t element_id)
6876 : : {
6877 : : uint32_t rc = 0;
6878 : :
6879 : 0 : uint32_t element_start_addr_h = 0;
6880 : 0 : uint32_t element_start_addr_l = 0;
6881 : 0 : uint32_t element_dump_addr_h = 0;
6882 : 0 : uint32_t element_dump_addr_l = 0;
6883 : 0 : uint32_t element_table_info_addr_h = 0;
6884 : 0 : uint32_t element_table_info_addr_l = 0;
6885 : :
6886 : 0 : zxdh_np_dtb_dump_table_element_addr_get(dev_id,
6887 : : queue_id,
6888 : : element_id,
6889 : : &element_start_addr_h,
6890 : : &element_start_addr_l,
6891 : : &element_dump_addr_h,
6892 : : &element_dump_addr_l,
6893 : : &element_table_info_addr_h,
6894 : : &element_table_info_addr_l);
6895 : 0 : PMD_DRV_LOG(DEBUG, "queue_id %u.", queue_id);
6896 : 0 : PMD_DRV_LOG(DEBUG, "element_id %u.", element_id);
6897 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_h 0x%x.", element_start_addr_h);
6898 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_l 0x%x.", element_start_addr_l);
6899 : 0 : PMD_DRV_LOG(DEBUG, "element_dump_addr_h 0x%x.", element_dump_addr_h);
6900 : 0 : PMD_DRV_LOG(DEBUG, "element_dump_addr_l 0x%x.", element_dump_addr_l);
6901 : 0 : PMD_DRV_LOG(DEBUG, "element_table_info_addr_h 0x%x.", element_table_info_addr_h);
6902 : 0 : PMD_DRV_LOG(DEBUG, "element_table_info_addr_l 0x%x.", element_table_info_addr_l);
6903 : :
6904 : 0 : rc = zxdh_np_dtb_item_ack_prt(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, element_id);
6905 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_prt");
6906 : :
6907 : 0 : rc = zxdh_np_dtb_item_buff_prt(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, element_id, 32);
6908 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_prt");
6909 : :
6910 : 0 : return rc;
6911 : : }
6912 : :
6913 : : static uint32_t
6914 : 0 : zxdh_np_dtb_tab_up_success_status_check(uint32_t dev_id,
6915 : : uint32_t queue_id,
6916 : : uint32_t element_id)
6917 : : {
6918 : : uint32_t rc = 0;
6919 : : uint32_t rd_cnt = 0;
6920 : : uint32_t ack_value = 0;
6921 : : uint32_t success_flag = 0;
6922 : :
6923 : 0 : while (!success_flag) {
6924 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6925 : : element_id, 0, &ack_value);
6926 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_rd");
6927 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_np_dtb_item_ack_rd ack_value:0x%08x", ack_value);
6928 : :
6929 [ # # ]: 0 : if ((((ack_value >> 8) & 0xffffff) == ZXDH_DTB_TAB_UP_ACK_VLD_MASK) &&
6930 [ # # ]: 0 : ((ack_value & 0xff) == ZXDH_DTB_TAB_ACK_SUCCESS_MASK)) {
6931 : : success_flag = 1;
6932 : : break;
6933 : : }
6934 : :
6935 [ # # ]: 0 : if (rd_cnt > ZXDH_DTB_DUMP_OVER_TIME) {
6936 : 0 : PMD_DRV_LOG(ERR, "dump queue %u item %u overtime!", queue_id, element_id);
6937 : :
6938 : 0 : rc = zxdh_np_dtb_dump_table_element_info_prt(dev_id, queue_id, element_id);
6939 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_table_element_info_prt");
6940 : :
6941 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6942 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
6943 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
6944 : :
6945 : 0 : return ZXDH_ERR;
6946 : : }
6947 : :
6948 : 0 : rd_cnt++;
6949 : 0 : rte_delay_us(ZXDH_DTB_DELAY_TIME);
6950 : : }
6951 : :
6952 : : return rc;
6953 : : }
6954 : :
6955 : : static uint32_t
6956 : 0 : zxdh_np_dtb_write_dump_desc_info(uint32_t dev_id,
6957 : : uint32_t queue_id,
6958 : : uint32_t queue_element_id,
6959 : : uint32_t *p_dump_info,
6960 : : uint32_t data_len,
6961 : : uint32_t desc_len,
6962 : : uint32_t *p_dump_data)
6963 : : {
6964 : : uint32_t dtb_interrupt_status = 0;
6965 : : uint32_t rc;
6966 : :
6967 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dump_data);
6968 : 0 : rc = zxdh_np_dtb_tab_up_info_set(dev_id,
6969 : : queue_id,
6970 : : queue_element_id,
6971 : : dtb_interrupt_status,
6972 : : data_len,
6973 : : desc_len,
6974 : : p_dump_info);
6975 [ # # ]: 0 : if (rc != 0) {
6976 : 0 : PMD_DRV_LOG(ERR, "queue %u element %u dump info set failed!",
6977 : : queue_id, queue_element_id);
6978 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6979 : : queue_element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
6980 : : }
6981 : :
6982 : 0 : rc = zxdh_np_dtb_tab_up_success_status_check(dev_id,
6983 : : queue_id, queue_element_id);
6984 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_success_status_check");
6985 : :
6986 : 0 : rc = zxdh_np_dtb_tab_up_data_get(dev_id, queue_id, queue_element_id,
6987 : : data_len, p_dump_data);
6988 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_data_get");
6989 : :
6990 : 0 : PMD_DRV_LOG(DEBUG, "queue %u element %u dump done.", queue_id, queue_element_id);
6991 : :
6992 : 0 : return rc;
6993 : : }
6994 : :
6995 : : static uint32_t
6996 : 0 : zxdh_np_dtb_tab_up_free_item_get(uint32_t dev_id,
6997 : : uint32_t queue_id,
6998 : : uint32_t *p_item_index)
6999 : : {
7000 : : uint32_t ack_vale = 0;
7001 : : uint32_t item_index = 0;
7002 : 0 : uint32_t unused_item_num = 0;
7003 : : uint32_t i;
7004 : : ZXDH_SPINLOCK_T *p_spinlock = NULL;
7005 : :
7006 : : zxdh_np_dev_dtb_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_DTB, queue_id, &p_spinlock);
7007 : 0 : rte_spinlock_lock(&p_spinlock->spinlock);
7008 : :
7009 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
7010 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init", queue_id);
7011 : : rte_spinlock_unlock(&p_spinlock->spinlock);
7012 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
7013 : : }
7014 : :
7015 : 0 : zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
7016 : :
7017 [ # # ]: 0 : if (unused_item_num == 0) {
7018 : : rte_spinlock_unlock(&p_spinlock->spinlock);
7019 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
7020 : : }
7021 : :
7022 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
7023 : 0 : item_index = ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id) %
7024 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
7025 : :
7026 : : zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
7027 : : 0, &ack_vale);
7028 : :
7029 : 0 : ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id)++;
7030 : :
7031 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
7032 : : break;
7033 : : }
7034 : :
7035 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX) {
7036 : : rte_spinlock_unlock(&p_spinlock->spinlock);
7037 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7038 : : }
7039 : :
7040 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
7041 : : 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
7042 : :
7043 : 0 : *p_item_index = item_index;
7044 : :
7045 : : rte_spinlock_unlock(&p_spinlock->spinlock);
7046 : :
7047 : 0 : return 0;
7048 : : }
7049 : :
7050 : : static uint32_t
7051 : 0 : zxdh_np_dtb_tab_up_item_user_addr_set(uint32_t dev_id,
7052 : : uint32_t queue_id,
7053 : : uint32_t item_index,
7054 : : uint64_t phy_addr,
7055 : : uint64_t vir_addr)
7056 : : {
7057 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
7058 : :
7059 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
7060 [ # # ]: 0 : if (p_dtb_mgr == NULL) {
7061 : 0 : PMD_DRV_LOG(ERR, "DTB Manager is not exist!");
7062 : 0 : return ZXDH_RC_DTB_MGR_NOT_EXIST;
7063 : : }
7064 : :
7065 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
7066 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
7067 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
7068 : : }
7069 : :
7070 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].phy_addr = phy_addr;
7071 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].vir_addr = vir_addr;
7072 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].user_flag =
7073 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE;
7074 : :
7075 : 0 : return ZXDH_OK;
7076 : : }
7077 : :
7078 : : static uint32_t
7079 : 0 : zxdh_np_dtb_dump_sdt_addr_get(uint32_t dev_id,
7080 : : uint32_t queue_id,
7081 : : uint32_t sdt_no,
7082 : : uint64_t *phy_addr,
7083 : : uint64_t *vir_addr,
7084 : : uint32_t *size)
7085 : : {
7086 : : uint32_t rc = ZXDH_OK;
7087 : :
7088 : 0 : ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {0};
7089 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
7090 : :
7091 : 0 : dtb_dump_addr_info.sdt_no = sdt_no;
7092 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
7093 : 0 : rc = zxdh_np_se_apt_rb_search(p_dtb_dump_addr_rb, &dtb_dump_addr_info,
7094 : : sizeof(ZXDH_DTB_ADDR_INFO_T));
7095 [ # # ]: 0 : if (rc == ZXDH_OK) {
7096 : 0 : PMD_DRV_LOG(INFO, "search sdt_no %u success.", sdt_no);
7097 : : } else {
7098 : 0 : PMD_DRV_LOG(ERR, "search sdt_no %u fail.", sdt_no);
7099 : 0 : return rc;
7100 : : }
7101 : :
7102 : 0 : *phy_addr = dtb_dump_addr_info.phy_addr;
7103 : 0 : *vir_addr = dtb_dump_addr_info.vir_addr;
7104 : 0 : *size = dtb_dump_addr_info.size;
7105 : :
7106 : 0 : return rc;
7107 : : }
7108 : :
7109 : : static uint32_t
7110 : 0 : zxdh_np_dtb_dump_addr_set(uint32_t dev_id,
7111 : : uint32_t queue_id,
7112 : : uint32_t sdt_no,
7113 : : uint32_t *element_id)
7114 : : {
7115 : : uint32_t rc = ZXDH_OK;
7116 : 0 : uint32_t dump_element_id = 0;
7117 : 0 : uint64_t phy_addr = 0;
7118 : 0 : uint64_t vir_addr = 0;
7119 : 0 : uint32_t size = 0;
7120 : :
7121 : 0 : rc = zxdh_np_dtb_dump_sdt_addr_get(dev_id,
7122 : : queue_id,
7123 : : sdt_no,
7124 : : &phy_addr,
7125 : : &vir_addr,
7126 : : &size);
7127 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_get");
7128 : 0 : memset((uint8_t *)vir_addr, 0, size);
7129 : :
7130 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &dump_element_id);
7131 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_free_item_get");
7132 : :
7133 : 0 : rc = zxdh_np_dtb_tab_up_item_user_addr_set(dev_id,
7134 : : queue_id,
7135 : : dump_element_id,
7136 : : phy_addr,
7137 : : vir_addr);
7138 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_set");
7139 : :
7140 : 0 : *element_id = dump_element_id;
7141 : :
7142 : 0 : return rc;
7143 : : }
7144 : :
7145 : : static uint32_t
7146 : 0 : zxdh_np_dtb_se_smmu0_dma_dump(uint32_t dev_id,
7147 : : uint32_t queue_id,
7148 : : uint32_t base_addr,
7149 : : uint32_t depth,
7150 : : uint32_t *p_data,
7151 : : uint32_t *element_id)
7152 : : {
7153 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
7154 : 0 : uint32_t dump_dst_phy_haddr = 0;
7155 : 0 : uint32_t dump_dst_phy_laddr = 0;
7156 : 0 : uint32_t queue_item_index = 0;
7157 : : uint32_t data_len;
7158 : : uint32_t desc_len;
7159 : : uint32_t rc;
7160 : :
7161 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &queue_item_index);
7162 [ # # ]: 0 : if (rc != 0) {
7163 : 0 : PMD_DRV_LOG(ERR, "dpp_dtb_tab_up_free_item_get failed = %u!", base_addr);
7164 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7165 : : }
7166 : :
7167 : 0 : *element_id = queue_item_index;
7168 : :
7169 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, queue_item_index,
7170 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
7171 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_tab_up_item_addr_get");
7172 : :
7173 : 0 : rc = zxdh_np_dtb_smmu0_dump_info_write(dev_id,
7174 : : base_addr,
7175 : : depth,
7176 : : dump_dst_phy_haddr,
7177 : : dump_dst_phy_laddr,
7178 : : (uint32_t *)form_buff);
7179 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_dump_info_write");
7180 : :
7181 : 0 : data_len = depth * 128 / 32;
7182 : : desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
7183 : :
7184 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id, queue_id, queue_item_index,
7185 : : (uint32_t *)form_buff, data_len, desc_len, p_data);
7186 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_dump_desc_info");
7187 : :
7188 : : return rc;
7189 : : }
7190 : :
7191 : : static uint32_t
7192 : 0 : zxdh_np_dtb_eram_data_get(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no,
7193 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_eram_entry)
7194 : : {
7195 : 0 : uint32_t index = p_dump_eram_entry->index;
7196 : 0 : uint32_t *p_data = p_dump_eram_entry->p_data;
7197 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram_info = {0};
7198 : 0 : uint32_t temp_data[4] = {0};
7199 : : uint32_t row_index = 0;
7200 : : uint32_t col_index = 0;
7201 : : uint32_t rd_mode;
7202 : : uint32_t rc;
7203 : : uint32_t eram_dump_base_addr = 0;
7204 : : uint32_t eram_base_addr = 0;
7205 : 0 : uint32_t element_id = 0;
7206 : :
7207 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
7208 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram_info);
7209 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_soft_sdt_tbl_get");
7210 : 0 : eram_base_addr = sdt_eram_info.eram_base_addr;
7211 [ # # # # ]: 0 : rd_mode = sdt_eram_info.eram_mode;
7212 : :
7213 : : zxdh_np_eram_index_cal(rd_mode, index, &row_index, &col_index);
7214 : :
7215 : 0 : eram_dump_base_addr = eram_base_addr + row_index;
7216 : :
7217 : 0 : rc = zxdh_np_dtb_se_smmu0_dma_dump(dev_id,
7218 : : queue_id,
7219 : : eram_dump_base_addr,
7220 : : 1,
7221 : : temp_data,
7222 : : &element_id);
7223 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_smmu0_dma_dump");
7224 : :
7225 [ # # # # ]: 0 : switch (rd_mode) {
7226 : : case ZXDH_ERAM128_TBL_128b:
7227 : : memcpy(p_data, temp_data, (128 / 8));
7228 : : break;
7229 : 0 : case ZXDH_ERAM128_TBL_64b:
7230 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
7231 : : break;
7232 : 0 : case ZXDH_ERAM128_TBL_1b:
7233 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
7234 : : (3 - col_index / 32)), (col_index % 32), 1);
7235 : 0 : break;
7236 : : default:
7237 : : break;
7238 : : }
7239 : :
7240 : 0 : PMD_DRV_LOG(DEBUG, "[eram_dump]std no:0x%x, index:0x%x, base addr:0x%x",
7241 : : sdt_no, p_dump_eram_entry->index, eram_dump_base_addr);
7242 [ # # ]: 0 : if (rd_mode == ZXDH_ERAM128_TBL_128b)
7243 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x 0x%08x 0x%08x]",
7244 : : p_dump_eram_entry->p_data[0], p_dump_eram_entry->p_data[1],
7245 : : p_dump_eram_entry->p_data[2], p_dump_eram_entry->p_data[3]);
7246 [ # # ]: 0 : else if (rd_mode == ZXDH_ERAM128_TBL_64b)
7247 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x]",
7248 : : p_dump_eram_entry->p_data[0], p_dump_eram_entry->p_data[1]);
7249 : :
7250 : 0 : return rc;
7251 : : }
7252 : :
7253 : : static uint32_t
7254 : 0 : zxdh_np_dtb_se_zcam_dma_dump(uint32_t dev_id,
7255 : : uint32_t queue_id,
7256 : : uint32_t addr,
7257 : : uint32_t tb_width,
7258 : : uint32_t depth,
7259 : : uint32_t *p_data,
7260 : : uint32_t *element_id)
7261 : : {
7262 : : uint32_t rc = ZXDH_OK;
7263 : 0 : uint32_t dump_dst_phy_haddr = 0;
7264 : 0 : uint32_t dump_dst_phy_laddr = 0;
7265 : 0 : uint32_t queue_item_index = 0;
7266 : : uint32_t data_len = 0;
7267 : : uint32_t desc_len = 0;
7268 : : uint32_t tb_width_len = 0;
7269 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
7270 : :
7271 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &queue_item_index);
7272 [ # # ]: 0 : if (rc != ZXDH_OK) {
7273 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_dtb_tab_up_free_item_get failed!");
7274 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7275 : : }
7276 : :
7277 : 0 : PMD_DRV_LOG(DEBUG, "table up item queue_element_id is: %u.",
7278 : : queue_item_index);
7279 : :
7280 : 0 : *element_id = queue_item_index;
7281 : :
7282 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, queue_item_index,
7283 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
7284 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_get");
7285 : :
7286 : 0 : rc = zxdh_np_dtb_zcam_dump_info_write(dev_id,
7287 : : addr,
7288 : : tb_width,
7289 : : depth,
7290 : : dump_dst_phy_haddr,
7291 : : dump_dst_phy_laddr,
7292 : : (uint32_t *)form_buff);
7293 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_zcam_dump_info_write");
7294 : :
7295 : 0 : tb_width_len = ZXDH_DTB_LEN_POS_SETP << tb_width;
7296 : 0 : data_len = depth * tb_width_len / 4;
7297 : : desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
7298 : :
7299 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id, queue_id, queue_item_index,
7300 : : (uint32_t *)form_buff, data_len, desc_len, p_data);
7301 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_desc_info");
7302 : :
7303 : : return rc;
7304 : : }
7305 : :
7306 : : static uint32_t
7307 : 0 : zxdh_np_dtb_hash_data_parse(uint32_t item_type,
7308 : : uint32_t key_by_size,
7309 : : ZXDH_HASH_ENTRY *p_entry,
7310 : : uint8_t *p_item_data,
7311 : : uint32_t *p_data_offset)
7312 : : {
7313 : : uint32_t data_offset = 0;
7314 : : uint8_t temp_key_valid = 0;
7315 : : uint8_t temp_key_type = 0;
7316 : : uint32_t temp_entry_size = 0;
7317 : : uint8_t srh_key_type = 0;
7318 : : uint32_t srh_entry_size = 0;
7319 : : uint32_t rst_by_size = 0;
7320 : : uint8_t srh_succ = 0;
7321 : : uint32_t item_width = ZXDH_SE_ITEM_WIDTH_MAX;
7322 : : uint8_t *p_srh_key = NULL;
7323 : : uint8_t *p_temp_key = NULL;
7324 : :
7325 [ # # ]: 0 : if (item_type == ZXDH_ITEM_DDR_256)
7326 : : item_width = item_width / 2;
7327 : :
7328 : : p_temp_key = p_item_data;
7329 : 0 : p_srh_key = p_entry->p_key;
7330 : 0 : srh_key_type = ZXDH_GET_HASH_KEY_TYPE(p_srh_key);
7331 [ # # ]: 0 : srh_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(srh_key_type);
7332 : :
7333 [ # # ]: 0 : while (data_offset < item_width) {
7334 : 0 : temp_key_valid = ZXDH_GET_HASH_KEY_VALID(p_temp_key);
7335 : 0 : temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_temp_key);
7336 : :
7337 [ # # ]: 0 : if (temp_key_valid && srh_key_type == temp_key_type) {
7338 [ # # ]: 0 : if (memcmp(p_srh_key, p_temp_key, key_by_size) == 0) {
7339 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware successfully.");
7340 : : srh_succ = 1;
7341 : : break;
7342 : : }
7343 : :
7344 : 0 : data_offset += srh_entry_size;
7345 [ # # ]: 0 : } else if (temp_key_valid && (srh_key_type != temp_key_type)) {
7346 [ # # ]: 0 : temp_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(temp_key_type);
7347 : 0 : data_offset += temp_entry_size;
7348 : : } else {
7349 : 0 : data_offset += ZXDH_HASH_ENTRY_POS_STEP;
7350 : : }
7351 : :
7352 : : p_temp_key = p_item_data;
7353 : 0 : p_temp_key += data_offset;
7354 : : }
7355 : :
7356 : : if (!srh_succ) {
7357 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware fail.");
7358 : 0 : return ZXDH_HASH_RC_MATCH_ITEM_FAIL;
7359 : : }
7360 : :
7361 : 0 : rst_by_size = srh_entry_size - key_by_size;
7362 : 0 : memcpy(p_entry->p_rst, p_temp_key + key_by_size,
7363 : 0 : (rst_by_size > ZXDH_HASH_RST_MAX) ? ZXDH_HASH_RST_MAX : rst_by_size);
7364 : 0 : *p_data_offset = data_offset;
7365 : :
7366 : 0 : return ZXDH_OK;
7367 : : }
7368 : :
7369 : : static uint32_t
7370 : 0 : zxdh_np_dtb_hash_zcam_get_hardware(uint32_t dev_id,
7371 : : uint32_t queue_id,
7372 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
7373 : : ZXDH_HASH_ENTRY *p_hash_entry,
7374 : : uint8_t *p_srh_succ)
7375 : : {
7376 : : uint32_t rc = ZXDH_OK;
7377 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
7378 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
7379 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
7380 : : uint32_t zblk_idx = 0;
7381 : : uint32_t pre_zblk_idx = 0xFFFFFFFF;
7382 : : uint16_t crc16_value = 0;
7383 : : uint32_t zcell_id = 0;
7384 : : uint32_t item_idx = 0;
7385 : 0 : uint32_t element_id = 0;
7386 : 0 : uint32_t byte_offset = 0;
7387 : : uint32_t addr = 0;
7388 : : uint32_t i = 0;
7389 : : uint8_t srh_succ = 0;
7390 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
7391 : 0 : uint8_t rd_buff[ZXDH_SE_ITEM_WIDTH_MAX] = {0};
7392 : : ZXDH_D_NODE *p_zblk_dn = NULL;
7393 : : ZXDH_D_NODE *p_zcell_dn = NULL;
7394 : : ZXDH_SE_CFG *p_se_cfg = NULL;
7395 : :
7396 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
7397 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
7398 : :
7399 : 0 : p_se_cfg = p_hash_entry_cfg->p_se_cfg;
7400 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
7401 : :
7402 : 0 : zxdh_np_hash_set_crc_key(p_hash_entry_cfg, p_hash_entry, temp_key);
7403 : :
7404 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
7405 [ # # ]: 0 : while (p_zcell_dn) {
7406 : 0 : p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
7407 : 0 : zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
7408 : : p_zblk = &p_se_cfg->zblk_info[zblk_idx];
7409 : :
7410 [ # # ]: 0 : if (zblk_idx != pre_zblk_idx) {
7411 : : pre_zblk_idx = zblk_idx;
7412 : 0 : crc16_value = p_hash_cfg->p_hash16_fun(temp_key,
7413 : 0 : p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
7414 : : }
7415 : :
7416 : 0 : zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
7417 : 0 : item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc16_value);
7418 : 0 : addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
7419 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
7420 : : queue_id,
7421 : : addr,
7422 : : ZXDH_DTB_DUMP_ZCAM_512b,
7423 : : 1,
7424 : : (uint32_t *)rd_buff,
7425 : : &element_id);
7426 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
7427 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
7428 : :
7429 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM, p_hash_entry_cfg->key_by_size,
7430 : : p_hash_entry, rd_buff, &byte_offset);
7431 [ # # ]: 0 : if (rc == ZXDH_OK) {
7432 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zcell.");
7433 : : srh_succ = 1;
7434 : 0 : p_hash_cfg->hash_stat.search_ok++;
7435 : : break;
7436 : : }
7437 : :
7438 : 0 : p_zcell_dn = p_zcell_dn->next;
7439 : : }
7440 : :
7441 : : if (srh_succ == 0) {
7442 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
7443 [ # # ]: 0 : while (p_zblk_dn) {
7444 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
7445 : 0 : zblk_idx = p_zblk->zblk_idx;
7446 : :
7447 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
7448 : : item_idx = i;
7449 : 0 : addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx, item_idx);
7450 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
7451 : : queue_id,
7452 : : addr,
7453 : : ZXDH_DTB_DUMP_ZCAM_512b,
7454 : : 1,
7455 : : (uint32_t *)rd_buff,
7456 : : &element_id);
7457 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
7458 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
7459 : :
7460 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM,
7461 : : p_hash_entry_cfg->key_by_size, p_hash_entry,
7462 : : rd_buff, &byte_offset);
7463 [ # # ]: 0 : if (rc == ZXDH_OK) {
7464 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zreg.");
7465 : : srh_succ = 1;
7466 : 0 : p_hash_cfg->hash_stat.search_ok++;
7467 : 0 : break;
7468 : : }
7469 : : }
7470 : 0 : p_zblk_dn = p_zblk_dn->next;
7471 : : }
7472 : : }
7473 : :
7474 : 0 : *p_srh_succ = srh_succ;
7475 : :
7476 : 0 : return rc;
7477 : : }
7478 : :
7479 : : static uint32_t
7480 : 0 : zxdh_np_dtb_hash_software_item_check(ZXDH_HASH_ENTRY *p_entry,
7481 : : uint32_t key_by_size,
7482 : : uint32_t rst_by_size,
7483 : : ZXDH_SE_ITEM_CFG *p_item_info)
7484 : : {
7485 : : uint8_t srh_succ = 0;
7486 : : uint8_t temp_key_type = 0;
7487 : : uint8_t srh_key_type = 0;
7488 : : uint32_t dev_id = 0;
7489 : : ZXDH_D_NODE *p_entry_dn = NULL;
7490 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
7491 : :
7492 : 0 : srh_key_type = ZXDH_GET_HASH_KEY_TYPE(p_entry->p_key);
7493 : 0 : p_entry_dn = p_item_info->item_list.p_next;
7494 [ # # ]: 0 : while (p_entry_dn) {
7495 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_entry_dn->data;
7496 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rbkey);
7497 : :
7498 : : RTE_ASSERT(p_rbkey->p_item_info == p_item_info);
7499 : :
7500 : 0 : temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
7501 : :
7502 [ # # # # ]: 0 : if (ZXDH_GET_HASH_KEY_VALID(p_rbkey->key) && srh_key_type == temp_key_type) {
7503 [ # # ]: 0 : if (memcmp(p_entry->p_key, p_rbkey->key, key_by_size) == 0) {
7504 : : srh_succ = 1;
7505 : : break;
7506 : : }
7507 : : }
7508 : :
7509 : 0 : p_entry_dn = p_entry_dn->next;
7510 : : }
7511 : :
7512 [ # # ]: 0 : if (p_rbkey == NULL)
7513 : : return ZXDH_PAR_CHK_POINT_NULL;
7514 : :
7515 [ # # ]: 0 : if (!srh_succ) {
7516 : 0 : PMD_DRV_LOG(DEBUG, "hash search failed!");
7517 : 0 : return ZXDH_HASH_RC_MATCH_ITEM_FAIL;
7518 : : }
7519 : :
7520 : 0 : memcpy(p_entry->p_rst, p_rbkey->rst,
7521 : 0 : (rst_by_size > ZXDH_HASH_RST_MAX) ? ZXDH_HASH_RST_MAX : rst_by_size);
7522 : :
7523 : 0 : return ZXDH_OK;
7524 : : }
7525 : :
7526 : : static uint32_t
7527 : 0 : zxdh_np_dtb_hash_get_software(uint32_t dev_id,
7528 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
7529 : : ZXDH_HASH_ENTRY *p_hash_entry,
7530 : : uint8_t *p_srh_succ)
7531 : : {
7532 : : uint32_t rc = ZXDH_OK;
7533 : 0 : ZXDH_HASH_RBKEY_INFO srh_rbkey = {0};
7534 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
7535 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
7536 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
7537 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
7538 : : ZXDH_SPINLOCK_T *p_hash_spinlock = NULL;
7539 : :
7540 [ # # ]: 0 : memcpy(srh_rbkey.key, p_hash_entry->p_key, p_hash_entry_cfg->key_by_size);
7541 : :
7542 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
7543 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
7544 : :
7545 : 0 : zxdh_np_dev_hash_opr_spinlock_get(dev_id, p_hash_cfg->fun_id, &p_hash_spinlock);
7546 : 0 : rte_spinlock_lock(&p_hash_spinlock->spinlock);
7547 : :
7548 : 0 : rc = zxdh_comm_rb_search(&p_hash_cfg->hash_rb, (void *)&srh_rbkey, (void *)(&p_rb_tn_rtn));
7549 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL) {
7550 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_comm_rb_search fail.");
7551 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
7552 : 0 : return ZXDH_OK;
7553 : : }
7554 : :
7555 : 0 : p_rbkey = p_rb_tn_rtn->p_key;
7556 : 0 : p_item = p_rbkey->p_item_info;
7557 : :
7558 : 0 : rc = zxdh_np_dtb_hash_software_item_check(p_hash_entry,
7559 : : p_hash_entry_cfg->key_by_size,
7560 : : p_hash_entry_cfg->rst_by_size,
7561 : : p_item);
7562 [ # # ]: 0 : if (rc == ZXDH_OK) {
7563 : 0 : PMD_DRV_LOG(DEBUG, "Hash search software succ.");
7564 : 0 : *p_srh_succ = 1;
7565 : 0 : p_hash_cfg->hash_stat.search_ok++;
7566 : : }
7567 : :
7568 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
7569 : 0 : return rc;
7570 : : }
7571 : :
7572 : : static uint32_t
7573 : 0 : zxdh_np_dtb_hash_zcam_get(uint32_t dev_id,
7574 : : uint32_t queue_id,
7575 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
7576 : : ZXDH_HASH_ENTRY *p_hash_entry,
7577 : : uint32_t srh_mode,
7578 : : uint8_t *p_srh_succ)
7579 : : {
7580 : : uint32_t rc = ZXDH_OK;
7581 : :
7582 [ # # ]: 0 : if (srh_mode == ZXDH_HASH_SRH_MODE_HDW) {
7583 : 0 : rc = zxdh_np_dtb_hash_zcam_get_hardware(dev_id, queue_id,
7584 : : p_hash_entry_cfg, p_hash_entry, p_srh_succ);
7585 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_zcam_get_hardware");
7586 : : } else {
7587 : 0 : rc = zxdh_np_dtb_hash_get_software(dev_id, p_hash_entry_cfg,
7588 : : p_hash_entry, p_srh_succ);
7589 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_get_software");
7590 : : }
7591 : :
7592 : 0 : return rc;
7593 : : }
7594 : :
7595 : : static uint32_t
7596 : 0 : zxdh_np_dtb_hash_data_get(uint32_t dev_id,
7597 : : uint32_t queue_id,
7598 : : uint32_t sdt_no,
7599 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry,
7600 : : uint32_t srh_mode)
7601 : : {
7602 : : uint32_t rc = ZXDH_OK;
7603 : 0 : uint8_t srh_succ = 0;
7604 : : uint8_t key_valid = 1;
7605 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
7606 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
7607 : 0 : ZXDH_HASH_ENTRY hash_entry = {0};
7608 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
7609 : 0 : uint8_t temp_rst[ZXDH_HASH_RST_MAX] = {0};
7610 : :
7611 : 0 : PMD_DRV_LOG(DEBUG, "hash get sdt_no:%u", sdt_no);
7612 : :
7613 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
7614 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
7615 : :
7616 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
7617 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
7618 : :
7619 : 0 : hash_entry.p_key = temp_key;
7620 : 0 : hash_entry.p_rst = temp_rst;
7621 : 0 : hash_entry.p_key[0] = ZXDH_GET_HASH_KEY_CTRL(key_valid,
7622 : : hash_entry_cfg.key_type,
7623 : : hash_entry_cfg.table_id);
7624 : :
7625 : 0 : memcpy(&hash_entry.p_key[1], p_dtb_hash_entry->p_actu_key,
7626 : 0 : hash_entry_cfg.actu_key_size);
7627 : :
7628 : : if (!srh_succ) {
7629 : 0 : rc = zxdh_np_dtb_hash_zcam_get(dev_id, queue_id, &hash_entry_cfg,
7630 : : &hash_entry, srh_mode, &srh_succ);
7631 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_zcam_get");
7632 : : }
7633 : :
7634 [ # # ]: 0 : if (!srh_succ) {
7635 : 0 : p_hash_cfg->hash_stat.search_fail++;
7636 : 0 : PMD_DRV_LOG(DEBUG, "Hash search key fail!");
7637 : 0 : return ZXDH_HASH_RC_SRH_FAIL;
7638 : : }
7639 : :
7640 : 0 : memcpy(p_dtb_hash_entry->p_rst, hash_entry.p_rst,
7641 : 0 : 1 << (hash_entry_cfg.rsp_mode + 2));
7642 : :
7643 : 0 : return rc;
7644 : : }
7645 : :
7646 : : static void
7647 : : dtb_etcam_dump_data_len(uint32_t etcam_key_mode,
7648 : : uint32_t *p_etcam_dump_len,
7649 : : uint32_t *p_etcam_dump_inerval)
7650 : : {
7651 : : uint32_t dump_data_len = 0;
7652 : : uint8_t etcam_dump_inerval = 0;
7653 : :
7654 [ # # ]: 0 : if (ZXDH_ETCAM_KEY_640b == etcam_key_mode) {
7655 : : dump_data_len = 5 * ZXDH_DTB_LEN_POS_SETP;
7656 : : etcam_dump_inerval = 0;
7657 [ # # ]: 0 : } else if (ZXDH_ETCAM_KEY_320b == etcam_key_mode) {
7658 : : dump_data_len = 3 * ZXDH_DTB_LEN_POS_SETP;
7659 : : etcam_dump_inerval = 8;
7660 [ # # ]: 0 : } else if (ZXDH_ETCAM_KEY_160b == etcam_key_mode) {
7661 : : dump_data_len = 2 * ZXDH_DTB_LEN_POS_SETP;
7662 : : etcam_dump_inerval = 12;
7663 [ # # ]: 0 : } else if (ZXDH_ETCAM_KEY_80b == etcam_key_mode) {
7664 : : dump_data_len = 1 * ZXDH_DTB_LEN_POS_SETP;
7665 : : etcam_dump_inerval = 6;
7666 : : }
7667 : :
7668 : : *p_etcam_dump_len = dump_data_len;
7669 : 0 : *p_etcam_dump_inerval = etcam_dump_inerval;
7670 : : }
7671 : :
7672 : : static void
7673 : 0 : zxdh_np_dtb_get_etcam_xy_from_dump_data(uint8_t *p_data,
7674 : : uint8_t *p_mask,
7675 : : uint32_t etcam_dump_len,
7676 : : uint32_t etcam_dump_inerval,
7677 : : ZXDH_ETCAM_ENTRY_T *p_entry_xy)
7678 : : {
7679 : : uint8_t *p_entry_data = NULL;
7680 : : uint8_t *p_entry_mask = NULL;
7681 : :
7682 : 0 : zxdh_np_comm_swap(p_data, etcam_dump_len);
7683 : 0 : zxdh_np_comm_swap(p_mask, etcam_dump_len);
7684 : :
7685 : 0 : p_entry_data = p_data + etcam_dump_inerval;
7686 : 0 : p_entry_mask = p_mask + etcam_dump_inerval;
7687 : :
7688 : 0 : memcpy(p_entry_xy->p_data, p_entry_data,
7689 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry_xy->mode));
7690 : 0 : memcpy(p_entry_xy->p_mask, p_entry_mask,
7691 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry_xy->mode));
7692 : 0 : }
7693 : :
7694 : :
7695 : : static void
7696 : : zxdh_np_etcam_xy_to_dm(ZXDH_ETCAM_ENTRY_T *p_dm,
7697 : : ZXDH_ETCAM_ENTRY_T *p_xy,
7698 : : uint32_t len)
7699 : : {
7700 : : uint32_t i = 0;
7701 : :
7702 : : RTE_ASSERT(p_dm->p_data && p_dm->p_mask && p_xy->p_data && p_xy->p_mask);
7703 : :
7704 [ # # # # ]: 0 : for (i = 0; i < len; i++) {
7705 : 0 : p_dm->p_data[i] = ZXDH_COMM_XY_TO_DATA(p_xy->p_data[i], p_xy->p_mask[i]);
7706 : 0 : p_dm->p_mask[i] = ZXDH_COMM_XY_TO_MASK(p_xy->p_data[i], p_xy->p_mask[i]);
7707 : : }
7708 : : }
7709 : :
7710 : : static uint32_t
7711 : 0 : zxdh_np_dtb_etcam_entry_get(uint32_t dev_id,
7712 : : uint32_t queue_id,
7713 : : uint32_t block_idx,
7714 : : uint32_t addr,
7715 : : uint32_t rd_mode,
7716 : : uint32_t opr_type,
7717 : : uint32_t as_en,
7718 : : uint32_t as_eram_baddr,
7719 : : uint32_t as_eram_index,
7720 : : uint32_t as_rsp_mode,
7721 : : ZXDH_ETCAM_ENTRY_T *p_entry,
7722 : : uint8_t *p_as_rslt)
7723 : : {
7724 : : uint32_t rc = ZXDH_OK;
7725 : :
7726 : : uint32_t etcam_key_mode = 0;
7727 : :
7728 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7729 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7730 : 0 : ZXDH_ETCAM_ENTRY_T entry_xy = {0};
7731 : :
7732 : : uint32_t etcam_data_dst_phy_haddr = 0;
7733 : : uint32_t etcam_data_dst_phy_laddr = 0;
7734 : : uint32_t etcam_mask_dst_phy_haddr = 0;
7735 : : uint32_t etcam_mask_dst_phy_laddr = 0;
7736 : : uint32_t as_rst_dst_phy_haddr = 0;
7737 : : uint32_t as_rst_dst_phy_laddr = 0;
7738 : :
7739 : 0 : uint32_t dump_element_id = 0;
7740 : : uint32_t etcam_dump_one_data_len = 0;
7741 : : uint32_t etcam_dump_inerval = 0;
7742 : : uint32_t dtb_desc_addr_offset = 0;
7743 : : uint32_t dump_data_len = 0;
7744 : : uint32_t dtb_desc_len = 0;
7745 : :
7746 : : uint32_t eram_dump_base_addr = 0;
7747 : : uint32_t row_index = 0;
7748 : : uint32_t col_index = 0;
7749 : :
7750 : : uint8_t *p_data = NULL;
7751 : : uint8_t *p_mask = NULL;
7752 : : uint8_t *p_rst = NULL;
7753 : : uint8_t *temp_dump_out_data = NULL;
7754 : : uint8_t *dump_info_buff = NULL;
7755 : 0 : ZXDH_ETCAM_DUMP_INFO_T etcam_dump_info = {0};
7756 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
7757 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
7758 : :
7759 : 0 : dtb_dump_entry.cmd = cmd_buff;
7760 : :
7761 : 0 : entry_xy.p_data = temp_data;
7762 : 0 : entry_xy.p_mask = temp_mask;
7763 : :
7764 : 0 : etcam_key_mode = p_entry->mode;
7765 : :
7766 : 0 : etcam_dump_info.block_sel = block_idx;
7767 : 0 : etcam_dump_info.addr = addr;
7768 : 0 : etcam_dump_info.tb_width = 3 - etcam_key_mode;
7769 : 0 : etcam_dump_info.rd_mode = rd_mode;
7770 : 0 : etcam_dump_info.tb_depth = 1;
7771 : :
7772 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &dump_element_id);
7773 [ # # ]: 0 : if (rc != ZXDH_OK) {
7774 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_dtb_tab_up_free_item_get failed!");
7775 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7776 : : }
7777 : :
7778 : : dtb_etcam_dump_data_len(etcam_key_mode, &etcam_dump_one_data_len, &etcam_dump_inerval);
7779 : :
7780 : 0 : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_DATA;
7781 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
7782 : : queue_id,
7783 : : dump_element_id,
7784 : : dump_data_len,
7785 : : &etcam_data_dst_phy_haddr,
7786 : : &etcam_data_dst_phy_laddr);
7787 : :
7788 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
7789 : : &etcam_dump_info,
7790 : : etcam_data_dst_phy_haddr,
7791 : : etcam_data_dst_phy_laddr,
7792 : : &dtb_dump_entry);
7793 : :
7794 : 0 : dump_info_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
7795 [ # # ]: 0 : if (dump_info_buff == NULL) {
7796 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
7797 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
7798 : : }
7799 : :
7800 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
7801 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
7802 : : dtb_desc_len += 1;
7803 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
7804 : : dump_data_len += etcam_dump_one_data_len;
7805 : :
7806 [ # # ]: 0 : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_MASK;
7807 : : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
7808 : : queue_id,
7809 : : dump_element_id,
7810 : : dump_data_len,
7811 : : &etcam_mask_dst_phy_haddr,
7812 : : &etcam_mask_dst_phy_laddr);
7813 : :
7814 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
7815 : : &etcam_dump_info,
7816 : : etcam_mask_dst_phy_haddr,
7817 : : etcam_mask_dst_phy_laddr,
7818 : : &dtb_dump_entry);
7819 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
7820 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
7821 : : dtb_desc_len += 1;
7822 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
7823 : 0 : dump_data_len += etcam_dump_one_data_len;
7824 : :
7825 [ # # ]: 0 : if (as_en) {
7826 : : zxdh_np_eram_index_cal(as_rsp_mode, as_eram_index, &row_index, &col_index);
7827 : :
7828 [ # # ]: 0 : eram_dump_base_addr = as_eram_baddr + row_index;
7829 : : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
7830 : : queue_id,
7831 : : dump_element_id,
7832 : : dump_data_len,
7833 : : &as_rst_dst_phy_haddr,
7834 : : &as_rst_dst_phy_laddr);
7835 : :
7836 : 0 : zxdh_np_dtb_smmu0_dump_entry(dev_id,
7837 : : eram_dump_base_addr,
7838 : : 1,
7839 : : as_rst_dst_phy_haddr,
7840 : : as_rst_dst_phy_laddr,
7841 : : &dtb_dump_entry);
7842 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
7843 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
7844 : : dtb_desc_len += 1;
7845 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
7846 : 0 : dump_data_len += ZXDH_DTB_LEN_POS_SETP;
7847 : : }
7848 : :
7849 : 0 : temp_dump_out_data = rte_zmalloc(NULL, dump_data_len, 0);
7850 [ # # ]: 0 : if (temp_dump_out_data == NULL) {
7851 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
7852 : 0 : rte_free(dump_info_buff);
7853 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
7854 : : }
7855 : : p_data = temp_dump_out_data;
7856 : :
7857 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id,
7858 : : queue_id,
7859 : : dump_element_id,
7860 : : (uint32_t *)dump_info_buff,
7861 : : dump_data_len / 4,
7862 : : dtb_desc_len * 4,
7863 : : (uint32_t *)temp_dump_out_data);
7864 : :
7865 : : p_data = temp_dump_out_data;
7866 : 0 : p_mask = p_data + etcam_dump_one_data_len;
7867 : :
7868 : 0 : zxdh_np_dtb_get_etcam_xy_from_dump_data(p_data,
7869 : : p_mask,
7870 : : etcam_dump_one_data_len,
7871 : : etcam_dump_inerval,
7872 : : &entry_xy);
7873 : :
7874 [ # # ]: 0 : if (opr_type == ZXDH_ETCAM_OPR_DM) {
7875 : 0 : zxdh_np_etcam_xy_to_dm(p_entry, &entry_xy,
7876 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
7877 : : } else {
7878 : 0 : memcpy(p_entry->p_data, entry_xy.p_data,
7879 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
7880 : 0 : memcpy(p_entry->p_mask, entry_xy.p_mask,
7881 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
7882 : : }
7883 : :
7884 [ # # ]: 0 : if (as_en) {
7885 : 0 : p_rst = p_mask + etcam_dump_one_data_len;
7886 : : memcpy(p_as_rslt, p_rst, (128 / 8));
7887 : : }
7888 : :
7889 : 0 : rte_free(dump_info_buff);
7890 : 0 : rte_free(temp_dump_out_data);
7891 : :
7892 : 0 : return rc;
7893 : : }
7894 : :
7895 : : static uint32_t
7896 : 0 : zxdh_np_etcam_entry_cmp(ZXDH_ETCAM_ENTRY_T *p_entry_dm, ZXDH_ETCAM_ENTRY_T *p_entry_xy)
7897 : : {
7898 : : uint32_t data_mask_len = 0;
7899 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7900 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7901 : 0 : ZXDH_ETCAM_ENTRY_T entry_xy_temp = {0};
7902 : :
7903 : 0 : entry_xy_temp.mode = p_entry_dm->mode;
7904 : 0 : entry_xy_temp.p_data = temp_data;
7905 : 0 : entry_xy_temp.p_mask = temp_mask;
7906 : :
7907 : 0 : data_mask_len = ZXDH_ETCAM_ENTRY_SIZE_GET(entry_xy_temp.mode);
7908 : :
7909 : 0 : zxdh_np_etcam_dm_to_xy(p_entry_dm, &entry_xy_temp, data_mask_len);
7910 : :
7911 [ # # ]: 0 : if ((memcmp(entry_xy_temp.p_data, p_entry_xy->p_data, data_mask_len) != 0) ||
7912 [ # # ]: 0 : (memcmp(entry_xy_temp.p_mask, p_entry_xy->p_mask, data_mask_len) != 0)) {
7913 : 0 : return ZXDH_ERR;
7914 : : }
7915 : :
7916 : : return ZXDH_OK;
7917 : : }
7918 : :
7919 : : static uint32_t
7920 : 0 : zxdh_np_dtb_acl_data_get(uint32_t dev_id,
7921 : : uint32_t queue_id,
7922 : : uint32_t sdt_no,
7923 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dump_acl_entry)
7924 : : {
7925 : : uint32_t rc = ZXDH_OK;
7926 : 0 : uint32_t block_idx = 0;
7927 : 0 : uint32_t ram_addr = 0;
7928 : 0 : uint32_t etcam_wr_mode = 0;
7929 : : uint32_t etcam_key_mode = 0;
7930 : : uint32_t etcam_table_id = 0;
7931 : : uint32_t as_enable = 0;
7932 : : uint32_t as_eram_baddr = 0;
7933 : : uint32_t etcam_as_mode = 0;
7934 : : uint32_t row_index = 0;
7935 : : uint32_t col_index = 0;
7936 : :
7937 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry_dm = {0};
7938 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry_xy = {0};
7939 : 0 : uint32_t as_eram_data[4] = {0};
7940 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7941 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7942 : :
7943 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
7944 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
7945 : :
7946 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
7947 : :
7948 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
7949 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
7950 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
7951 : 0 : etcam_key_mode = sdt_etcam_info.etcam_key_mode;
7952 : 0 : etcam_as_mode = sdt_etcam_info.as_rsp_mode;
7953 : 0 : etcam_table_id = sdt_etcam_info.etcam_table_id;
7954 : 0 : as_enable = sdt_etcam_info.as_en;
7955 : 0 : as_eram_baddr = sdt_etcam_info.as_eram_baddr;
7956 : :
7957 : 0 : etcam_entry_xy.mode = etcam_key_mode;
7958 : 0 : etcam_entry_xy.p_data = temp_data;
7959 : 0 : etcam_entry_xy.p_mask = temp_mask;
7960 : 0 : etcam_entry_dm.mode = etcam_key_mode;
7961 : 0 : etcam_entry_dm.p_data = p_dump_acl_entry->key_data;
7962 : 0 : etcam_entry_dm.p_mask = p_dump_acl_entry->key_mask;
7963 : :
7964 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
7965 : :
7966 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
7967 : :
7968 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
7969 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
7970 : : RTE_ASSERT(0);
7971 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
7972 : : }
7973 : :
7974 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_dump_acl_entry->handle,
7975 : : &block_idx, &ram_addr, &etcam_wr_mode);
7976 : :
7977 : 0 : rc = zxdh_np_dtb_etcam_entry_get(dev_id,
7978 : : queue_id,
7979 : : block_idx,
7980 : : ram_addr,
7981 : : etcam_wr_mode,
7982 : : ZXDH_ETCAM_OPR_XY,
7983 : : as_enable,
7984 : : as_eram_baddr,
7985 : : p_dump_acl_entry->handle,
7986 : : etcam_as_mode,
7987 : : &etcam_entry_xy,
7988 : : (uint8_t *)as_eram_data);
7989 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_etcam_entry_get");
7990 : :
7991 [ # # ]: 0 : if (zxdh_np_etcam_entry_cmp(&etcam_entry_dm, &etcam_entry_xy) == 0) {
7992 : 0 : PMD_DRV_LOG(DEBUG, "get done, handle:0x%x block:%u ram_addr:%u rd_mode:%x",
7993 : : p_dump_acl_entry->handle, block_idx, ram_addr, etcam_wr_mode);
7994 : : } else {
7995 : 0 : PMD_DRV_LOG(DEBUG, "get fail, handle:0x%x block:%u ram_addr:%u rd_mode:%x",
7996 : : p_dump_acl_entry->handle, block_idx, ram_addr, etcam_wr_mode);
7997 : :
7998 : 0 : return ZXDH_ERR;
7999 : : }
8000 : :
8001 [ # # ]: 0 : if (as_enable) {
8002 [ # # # ]: 0 : zxdh_np_eram_index_cal(etcam_as_mode, p_dump_acl_entry->handle,
8003 : : &row_index, &col_index);
8004 [ # # # # ]: 0 : switch (etcam_as_mode) {
8005 : 0 : case ZXDH_ERAM128_TBL_128b:
8006 : 0 : memcpy(p_dump_acl_entry->p_as_rslt, as_eram_data, (128 / 8));
8007 : : break;
8008 : :
8009 : 0 : case ZXDH_ERAM128_TBL_64b:
8010 : 0 : memcpy(p_dump_acl_entry->p_as_rslt, as_eram_data +
8011 : 0 : ((1 - col_index) << 1), (64 / 8));
8012 : : break;
8013 : :
8014 : 0 : case ZXDH_ERAM128_TBL_1b:
8015 : 0 : ZXDH_COMM_UINT32_GET_BITS(*(uint32_t *)p_dump_acl_entry->p_as_rslt,
8016 : : *(as_eram_data + (3 - col_index / 32)), (col_index % 32), 1);
8017 : 0 : break;
8018 : : default:
8019 : : break;
8020 : : }
8021 : : }
8022 : :
8023 : : return rc;
8024 : : }
8025 : :
8026 : : int
8027 : 0 : zxdh_np_dtb_table_entry_get(uint32_t dev_id,
8028 : : uint32_t queue_id,
8029 : : ZXDH_DTB_USER_ENTRY_T *get_entry,
8030 : : uint32_t srh_mode)
8031 : : {
8032 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
8033 : : uint32_t tbl_type = 0;
8034 : : uint32_t rc;
8035 : : uint32_t sdt_no;
8036 : : uint32_t sdt_partner = 0;
8037 : : uint32_t valid = 0;
8038 : 0 : uint8_t key = 0;
8039 : :
8040 : 0 : sdt_no = get_entry->sdt_no;
8041 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
8042 : :
8043 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
8044 : :
8045 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_tbl.data_high32,
8046 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
8047 [ # # # # ]: 0 : switch (tbl_type) {
8048 : 0 : case ZXDH_SDT_TBLT_ERAM:
8049 : 0 : rc = zxdh_np_dtb_eram_data_get(dev_id,
8050 : : queue_id,
8051 : : sdt_no,
8052 : 0 : (ZXDH_DTB_ERAM_ENTRY_INFO_T *)get_entry->p_entry_data);
8053 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_eram_data_get");
8054 : : break;
8055 : 0 : case ZXDH_SDT_TBLT_HASH:
8056 : : do {
8057 : 0 : rc = zxdh_np_dtb_hash_data_get(dev_id,
8058 : : queue_id,
8059 : : sdt_no,
8060 : 0 : (ZXDH_DTB_HASH_ENTRY_INFO_T *)get_entry->p_entry_data,
8061 : : srh_mode);
8062 : : sdt_partner = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
8063 : 0 : valid = zxdh_np_hash_sdt_partner_valid(sdt_no, sdt_partner, &key);
8064 : : sdt_no = sdt_partner;
8065 [ # # ]: 0 : } while ((rc == ZXDH_HASH_RC_SRH_FAIL) && (valid == ZXDH_TRUE));
8066 : :
8067 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_SRH_FAIL) {
8068 : 0 : PMD_DRV_LOG(DEBUG, "hash search failed");
8069 : 0 : return rc;
8070 : : }
8071 : :
8072 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_data_get");
8073 : : break;
8074 : 0 : case ZXDH_SDT_TBLT_ETCAM:
8075 : 0 : rc = zxdh_np_dtb_acl_data_get(dev_id,
8076 : : queue_id,
8077 : : sdt_no,
8078 : 0 : (ZXDH_DTB_ACL_ENTRY_INFO_T *)get_entry->p_entry_data);
8079 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_data_get");
8080 : : break;
8081 : 0 : default:
8082 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
8083 : 0 : return 1;
8084 : : }
8085 : :
8086 : : return 0;
8087 : : }
8088 : :
8089 : : static uint32_t
8090 : 0 : zxdh_np_dtb_se_smmu0_ind_read(uint32_t dev_id,
8091 : : uint32_t queue_id,
8092 : : uint32_t base_addr,
8093 : : uint32_t index,
8094 : : uint32_t rd_mode,
8095 : : uint32_t *p_data)
8096 : : {
8097 : 0 : uint32_t temp_data[4] = {0};
8098 : 0 : uint32_t element_id = 0;
8099 : : uint32_t row_index = 0;
8100 : : uint32_t col_index = 0;
8101 : : uint32_t eram_dump_base_addr;
8102 : : uint32_t rc;
8103 : :
8104 [ # # # # ]: 0 : switch (rd_mode) {
8105 : 0 : case ZXDH_ERAM128_OPR_128b:
8106 : : row_index = index;
8107 : 0 : break;
8108 : 0 : case ZXDH_ERAM128_OPR_64b:
8109 : 0 : row_index = (index >> 1);
8110 : 0 : col_index = index & 0x1;
8111 : 0 : break;
8112 : 0 : case ZXDH_ERAM128_OPR_1b:
8113 : 0 : row_index = (index >> 7);
8114 : 0 : col_index = index & 0x7F;
8115 : 0 : break;
8116 : : default:
8117 : : break;
8118 : : }
8119 : :
8120 : 0 : eram_dump_base_addr = base_addr + row_index;
8121 : 0 : rc = zxdh_np_dtb_se_smmu0_dma_dump(dev_id,
8122 : : queue_id,
8123 : : eram_dump_base_addr,
8124 : : 1,
8125 : : temp_data,
8126 : : &element_id);
8127 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_dma_dump");
8128 : :
8129 [ # # # # ]: 0 : switch (rd_mode) {
8130 : : case ZXDH_ERAM128_OPR_128b:
8131 : : memcpy(p_data, temp_data, (128 / 8));
8132 : : break;
8133 : 0 : case ZXDH_ERAM128_OPR_64b:
8134 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
8135 : : break;
8136 : 0 : case ZXDH_ERAM128_OPR_1b:
8137 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
8138 : : (3 - col_index / 32)), (col_index % 32), 1);
8139 : 0 : break;
8140 : : default:
8141 : : break;
8142 : : }
8143 : :
8144 : 0 : return rc;
8145 : : }
8146 : :
8147 : : static uint32_t
8148 : 0 : zxdh_np_dtb_stat_smmu0_int_read(uint32_t dev_id,
8149 : : uint32_t queue_id,
8150 : : uint32_t smmu0_base_addr,
8151 : : ZXDH_STAT_CNT_MODE_E rd_mode,
8152 : : uint32_t index,
8153 : : uint32_t *p_data)
8154 : : {
8155 : : uint32_t eram_rd_mode;
8156 : : uint32_t rc;
8157 : :
8158 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
8159 : :
8160 [ # # ]: 0 : if (rd_mode == ZXDH_STAT_128_MODE)
8161 : : eram_rd_mode = ZXDH_ERAM128_OPR_128b;
8162 : : else
8163 : : eram_rd_mode = ZXDH_ERAM128_OPR_64b;
8164 : :
8165 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_read(dev_id,
8166 : : queue_id,
8167 : : smmu0_base_addr,
8168 : : index,
8169 : : eram_rd_mode,
8170 : : p_data);
8171 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_ind_read");
8172 : :
8173 : 0 : return rc;
8174 : : }
8175 : :
8176 : : int
8177 : 0 : zxdh_np_dtb_stats_get(uint32_t dev_id,
8178 : : uint32_t queue_id,
8179 : : ZXDH_STAT_CNT_MODE_E rd_mode,
8180 : : uint32_t index,
8181 : : uint32_t *p_data)
8182 : : {
8183 : : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
8184 : : uint32_t ppu_eram_baddr;
8185 : : uint32_t ppu_eram_depth;
8186 : : uint32_t rc = 0;
8187 : :
8188 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
8189 : :
8190 : : memset(&stat_cfg, 0x0, sizeof(stat_cfg));
8191 : :
8192 : 0 : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
8193 : :
8194 : 0 : ppu_eram_depth = stat_cfg.eram_depth;
8195 : 0 : ppu_eram_baddr = stat_cfg.eram_baddr;
8196 : :
8197 [ # # ]: 0 : if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) {
8198 : 0 : rc = zxdh_np_dtb_stat_smmu0_int_read(dev_id,
8199 : : queue_id,
8200 : : ppu_eram_baddr,
8201 : : rd_mode,
8202 : : index,
8203 : : p_data);
8204 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_stat_smmu0_int_read");
8205 : : }
8206 : :
8207 : 0 : return rc;
8208 : : }
8209 : :
8210 : : static uint32_t
8211 : 0 : zxdh_np_dtb_queue_down_init(uint32_t dev_id,
8212 : : uint32_t queue_id,
8213 : : ZXDH_DTB_QUEUE_CFG_T *p_queue_cfg)
8214 : : {
8215 : : uint32_t rc = 0;
8216 : : uint32_t i = 0;
8217 : : uint32_t ack_vale = 0;
8218 : : uint32_t tab_down_item_size = 0;
8219 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
8220 : :
8221 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
8222 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 1;
8223 : :
8224 : 0 : tab_down_item_size = (p_queue_cfg->down_item_size == 0) ?
8225 [ # # ]: 0 : ZXDH_DTB_ITEM_SIZE : p_queue_cfg->down_item_size;
8226 : :
8227 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.item_size = tab_down_item_size;
8228 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.start_phy_addr = p_queue_cfg->down_start_phy_addr;
8229 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.start_vir_addr = p_queue_cfg->down_start_vir_addr;
8230 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.wr_index = 0;
8231 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.rd_index = 0;
8232 : :
8233 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8234 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id,
8235 : : ZXDH_DTB_DIR_DOWN_TYPE, i, 0, ZXDH_DTB_TAB_ACK_CHECK_VALUE);
8236 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
8237 : : }
8238 : :
8239 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8240 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id,
8241 : : ZXDH_DTB_DIR_DOWN_TYPE, i, 0, &ack_vale);
8242 [ # # ]: 0 : if (ack_vale != ZXDH_DTB_TAB_ACK_CHECK_VALUE) {
8243 : 0 : PMD_DRV_LOG(ERR, "dtb queue [%u] down init failed!", queue_id);
8244 : 0 : return ZXDH_RC_DTB_MEMORY_ALLOC_ERR;
8245 : : }
8246 : : }
8247 : :
8248 : 0 : memset((uint8_t *)(p_queue_cfg->down_start_vir_addr), 0,
8249 : 0 : tab_down_item_size * ZXDH_DTB_QUEUE_ITEM_NUM_MAX);
8250 : :
8251 : 0 : PMD_DRV_LOG(INFO, "dtb queue [%u] down init success!!!", queue_id);
8252 : :
8253 : 0 : return ZXDH_OK;
8254 : : }
8255 : :
8256 : : static uint32_t
8257 : 0 : zxdh_np_dtb_queue_dump_init(uint32_t dev_id,
8258 : : uint32_t queue_id,
8259 : : ZXDH_DTB_QUEUE_CFG_T *p_queue_cfg)
8260 : : {
8261 : : uint32_t i = 0;
8262 : : uint32_t ack_vale = 0;
8263 : : uint32_t tab_up_item_size = 0;
8264 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
8265 : :
8266 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
8267 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 1;
8268 : :
8269 : 0 : tab_up_item_size = (p_queue_cfg->up_item_size == 0) ?
8270 [ # # ]: 0 : ZXDH_DTB_ITEM_SIZE : p_queue_cfg->up_item_size;
8271 : :
8272 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.item_size = tab_up_item_size;
8273 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.start_phy_addr = p_queue_cfg->up_start_phy_addr;
8274 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.start_vir_addr = p_queue_cfg->up_start_vir_addr;
8275 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.wr_index = 0;
8276 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.rd_index = 0;
8277 : :
8278 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8279 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id,
8280 : : ZXDH_DTB_DIR_UP_TYPE, i, 0, ZXDH_DTB_TAB_ACK_CHECK_VALUE);
8281 : : }
8282 : :
8283 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8284 : : zxdh_np_dtb_item_ack_rd(dev_id, queue_id,
8285 : : ZXDH_DTB_DIR_UP_TYPE, i, 0, &ack_vale);
8286 [ # # ]: 0 : if (ack_vale != ZXDH_DTB_TAB_ACK_CHECK_VALUE) {
8287 : 0 : PMD_DRV_LOG(ERR, "dtb queue [%u] dump init failed!!!", queue_id);
8288 : 0 : return ZXDH_RC_DTB_MEMORY_ALLOC_ERR;
8289 : : }
8290 : : }
8291 : :
8292 : 0 : memset((uint8_t *)(p_queue_cfg->up_start_vir_addr), 0,
8293 : 0 : tab_up_item_size * ZXDH_DTB_QUEUE_ITEM_NUM_MAX);
8294 : :
8295 : 0 : PMD_DRV_LOG(INFO, "dtb queue [%u] up init success!!!", queue_id);
8296 : :
8297 : 0 : return ZXDH_OK;
8298 : : }
8299 : :
8300 : : static void
8301 : : zxdh_np_dtb_down_channel_addr_set(uint32_t dev_id,
8302 : : uint32_t channel_id,
8303 : : uint64_t phy_addr,
8304 : : uint64_t vir_addr,
8305 : : uint32_t size)
8306 : : {
8307 : 0 : ZXDH_DTB_QUEUE_CFG_T down_queue_cfg = {
8308 : : .down_start_phy_addr = phy_addr,
8309 : : .down_start_vir_addr = vir_addr,
8310 : : .down_item_size = size,
8311 : : };
8312 : :
8313 : 0 : zxdh_np_dtb_queue_down_init(dev_id, channel_id, &down_queue_cfg);
8314 : : }
8315 : :
8316 : : static void
8317 : : zxdh_np_dtb_dump_channel_addr_set(uint32_t dev_id,
8318 : : uint32_t channel_id,
8319 : : uint64_t phy_addr,
8320 : : uint64_t vir_addr,
8321 : : uint32_t size)
8322 : : {
8323 : 0 : ZXDH_DTB_QUEUE_CFG_T dump_queue_cfg = {
8324 : : .up_start_phy_addr = phy_addr,
8325 : : .up_start_vir_addr = vir_addr,
8326 : : .up_item_size = size,
8327 : : };
8328 : :
8329 : 0 : zxdh_np_dtb_queue_dump_init(dev_id, channel_id, &dump_queue_cfg);
8330 : : }
8331 : :
8332 : : static uint32_t
8333 : 0 : zxdh_np_dtb_user_info_set(uint32_t dev_id, uint32_t queue_id, uint16_t vport, uint32_t vector)
8334 : : {
8335 : : uint32_t rc = ZXDH_OK;
8336 : :
8337 : 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
8338 : : ZXDH_DTB_MGR_T *p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
8339 : :
8340 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
8341 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_queue_vm_info_get");
8342 : :
8343 : 0 : vm_info.dbi_en = 1;
8344 : 0 : vm_info.epid = hardware_ep_id[ZXDH_EPID_BY(vport)];
8345 : 0 : vm_info.vfunc_num = ZXDH_VFUNC_NUM(vport);
8346 : 0 : vm_info.func_num = ZXDH_FUNC_NUM(vport);
8347 : 0 : vm_info.vfunc_active = ZXDH_VF_ACTIVE(vport);
8348 : 0 : vm_info.vector = vector;
8349 : :
8350 : 0 : p_dtb_mgr->queue_info[queue_id].vport = vport;
8351 : 0 : p_dtb_mgr->queue_info[queue_id].vector = vector;
8352 : :
8353 : 0 : rc = zxdh_np_dtb_queue_vm_info_set(dev_id, queue_id, &vm_info);
8354 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_queue_vm_info_set");
8355 : :
8356 : 0 : return rc;
8357 : : }
8358 : :
8359 : : static uint32_t
8360 : 0 : zxdh_np_dtb_dump_sdt_addr_set(uint32_t dev_id,
8361 : : uint32_t queue_id,
8362 : : uint32_t sdt_no,
8363 : : uint64_t phy_addr,
8364 : : uint64_t vir_addr,
8365 : : uint32_t size)
8366 : : {
8367 : : uint32_t rc = ZXDH_OK;
8368 : :
8369 : 0 : ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {
8370 : : .sdt_no = sdt_no,
8371 : : .phy_addr = phy_addr,
8372 : : .vir_addr = vir_addr,
8373 : : .size = size,
8374 : : };
8375 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
8376 : :
8377 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
8378 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dtb_dump_addr_rb);
8379 : :
8380 : 0 : rc = zxdh_np_se_apt_rb_insert(p_dtb_dump_addr_rb,
8381 : : &dtb_dump_addr_info, sizeof(ZXDH_DTB_ADDR_INFO_T));
8382 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_apt_rb_insert");
8383 : :
8384 : 0 : return rc;
8385 : : }
8386 : :
8387 : : static uint32_t
8388 : 0 : zxdh_np_apt_dtb_res_init(uint32_t dev_id, ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
8389 : : {
8390 : : uint32_t rc = ZXDH_OK;
8391 : :
8392 : 0 : uint32_t queue_id = 0;
8393 : : uint32_t index = 0;
8394 : : uint32_t dump_sdt_num = 0;
8395 : : ZXDH_DTB_ADDR_INFO_T *p_dump_info = NULL;
8396 : :
8397 : 0 : rc = zxdh_np_dtb_queue_request(dev_id, p_dev_init_ctrl->port_name,
8398 : 0 : p_dev_init_ctrl->vport, &queue_id);
8399 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_queue_request");
8400 : :
8401 : 0 : p_dev_init_ctrl->queue_id = queue_id;
8402 : :
8403 : 0 : rc = zxdh_np_dtb_user_info_set(dev_id, queue_id,
8404 : 0 : p_dev_init_ctrl->vport, p_dev_init_ctrl->vector);
8405 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_user_info_set");
8406 : :
8407 : 0 : zxdh_np_dtb_down_channel_addr_set(dev_id, queue_id,
8408 : : p_dev_init_ctrl->down_phy_addr, p_dev_init_ctrl->down_vir_addr, 0);
8409 : :
8410 : 0 : zxdh_np_dtb_dump_channel_addr_set(dev_id, queue_id,
8411 : : p_dev_init_ctrl->dump_phy_addr, p_dev_init_ctrl->dump_vir_addr, 0);
8412 : :
8413 : 0 : dump_sdt_num = p_dev_init_ctrl->dump_sdt_num;
8414 [ # # ]: 0 : for (index = 0; index < dump_sdt_num; index++) {
8415 : 0 : p_dump_info = p_dev_init_ctrl->dump_addr_info + index;
8416 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dump_info);
8417 : 0 : rc = zxdh_np_dtb_dump_sdt_addr_set(dev_id,
8418 : : queue_id,
8419 : : p_dump_info->sdt_no,
8420 : : p_dump_info->phy_addr,
8421 : : p_dump_info->vir_addr,
8422 : : p_dump_info->size);
8423 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_set");
8424 : : }
8425 : :
8426 : 0 : return ZXDH_OK;
8427 : : }
8428 : :
8429 : : int
8430 : 0 : zxdh_np_host_init(uint32_t dev_id,
8431 : : ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
8432 : : {
8433 : 0 : ZXDH_SYS_INIT_CTRL_T sys_init_ctrl = {0};
8434 : : uint32_t rc;
8435 : : uint64_t agent_addr;
8436 : 0 : uint32_t bar_msg_num = 0;
8437 : :
8438 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dev_init_ctrl);
8439 : :
8440 : 0 : sys_init_ctrl.flags = (ZXDH_DEV_ACCESS_TYPE_PCIE << 0) | (ZXDH_DEV_AGENT_ENABLE << 10);
8441 : 0 : sys_init_ctrl.pcie_vir_baddr = zxdh_np_addr_calc(p_dev_init_ctrl->pcie_vir_addr,
8442 : : p_dev_init_ctrl->np_bar_offset);
8443 : 0 : sys_init_ctrl.device_type = ZXDH_DEV_TYPE_CHIP;
8444 : :
8445 : 0 : rc = zxdh_np_base_soft_init(dev_id, &sys_init_ctrl);
8446 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_base_soft_init");
8447 : :
8448 : 0 : zxdh_np_dev_vport_set(dev_id, p_dev_init_ctrl->vport);
8449 : :
8450 : 0 : agent_addr = ZXDH_PCIE_AGENT_ADDR_OFFSET + p_dev_init_ctrl->pcie_vir_addr;
8451 : : zxdh_np_dev_agent_addr_set(dev_id, agent_addr);
8452 : :
8453 : : zxdh_np_pf_fw_compatible_addr_set(dev_id, p_dev_init_ctrl->pcie_vir_addr);
8454 : :
8455 : 0 : rc = zxdh_np_np_sdk_version_compatible_check(dev_id);
8456 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_np_sdk_version_compatible_check");
8457 : :
8458 : 0 : rc = zxdh_np_pcie_bar_msg_num_get(dev_id, &bar_msg_num);
8459 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_pcie_bar_msg_num_get");
8460 : :
8461 : 0 : zxdh_np_dev_fw_bar_msg_num_set(dev_id, bar_msg_num);
8462 : :
8463 : 0 : rc = zxdh_np_apt_dtb_res_init(dev_id, p_dev_init_ctrl);
8464 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_dtb_res_init");
8465 : 0 : PMD_DRV_LOG(INFO, "host init done, queue_id = %u", p_dev_init_ctrl->queue_id);
8466 : :
8467 : 0 : return 0;
8468 : : }
8469 : :
8470 : : static uint32_t
8471 : : zxdh_np_get_se_buff_size(uint32_t opr)
8472 : : {
8473 : : uint32_t buff_size = 0;
8474 : :
8475 : : switch (opr) {
8476 : : case ZXDH_HASH_FUNC_BULK_REQ:
8477 : : buff_size = sizeof(ZXDH_NP_SE_HASH_FUNC_BULK_T);
8478 : : break;
8479 : : case ZXDH_HASH_TBL_REQ:
8480 : : buff_size = sizeof(ZXDH_NP_SE_HASH_TBL_T);
8481 : : break;
8482 : : case ZXDH_ERAM_TBL_REQ:
8483 : : buff_size = sizeof(ZXDH_NP_SE_ERAM_TBL_T);
8484 : : break;
8485 : : case ZXDH_ACL_TBL_REQ:
8486 : : buff_size = sizeof(ZXDH_NP_SE_ACL_TBL_T);
8487 : : break;
8488 : : case ZXDH_STAT_CFG_REQ:
8489 : : buff_size = sizeof(ZXDH_NP_SE_STAT_CFG_T);
8490 : : break;
8491 : : default:
8492 : : break;
8493 : : }
8494 : :
8495 : : return buff_size;
8496 : : }
8497 : :
8498 : : static void
8499 : 0 : zxdh_np_hash_func_bulk_set(ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init,
8500 : : ZXDH_NP_SE_HASH_FUNC_BULK_T *p_func_bulk)
8501 : : {
8502 : : uint32_t index = 0;
8503 : : ZXDH_APT_HASH_FUNC_RES_T *p_func_res = NULL;
8504 : : ZXDH_APT_HASH_BULK_RES_T *p_bulk_res = NULL;
8505 : :
8506 : 0 : p_hash_res_init->func_num = p_func_bulk->func_num;
8507 : 0 : p_hash_res_init->bulk_num = p_func_bulk->bulk_num;
8508 [ # # ]: 0 : for (index = 0; index < (p_hash_res_init->func_num); index++) {
8509 : 0 : p_func_res = p_hash_res_init->func_res + index;
8510 : :
8511 : 0 : p_func_res->func_id = p_func_bulk->fun[index].func_id;
8512 : 0 : p_func_res->ddr_dis = p_func_bulk->fun[index].ddr_dis;
8513 : 0 : p_func_res->zblk_num = p_func_bulk->fun[index].zblk_num;
8514 : 0 : p_func_res->zblk_bitmap = p_func_bulk->fun[index].zblk_bitmap;
8515 : : }
8516 : :
8517 [ # # ]: 0 : for (index = 0; index < (p_hash_res_init->bulk_num); index++) {
8518 : 0 : p_bulk_res = p_hash_res_init->bulk_res + index;
8519 : :
8520 : 0 : p_bulk_res->func_id = p_func_bulk->bulk[index].func_id;
8521 : 0 : p_bulk_res->bulk_id = p_func_bulk->bulk[index].bulk_id;
8522 : 0 : p_bulk_res->zcell_num = p_func_bulk->bulk[index].zcell_num;
8523 : 0 : p_bulk_res->zreg_num = p_func_bulk->bulk[index].zreg_num;
8524 : 0 : p_bulk_res->ddr_baddr = p_func_bulk->bulk[index].ddr_baddr;
8525 : 0 : p_bulk_res->ddr_item_num = p_func_bulk->bulk[index].ddr_item_num;
8526 : 0 : p_bulk_res->ddr_width_mode = p_func_bulk->bulk[index].ddr_width_mode;
8527 : 0 : p_bulk_res->ddr_crc_sel = p_func_bulk->bulk[index].ddr_crc_sel;
8528 : 0 : p_bulk_res->ddr_ecc_en = p_func_bulk->bulk[index].ddr_ecc_en;
8529 : : }
8530 : 0 : }
8531 : :
8532 : : static void
8533 : 0 : zxdh_np_hash_tbl_set(ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init, ZXDH_NP_SE_HASH_TBL_T *p_hash_tbl)
8534 : : {
8535 : : uint32_t index = 0;
8536 : : ZXDH_APT_HASH_TABLE_T *p_tbl_res = NULL;
8537 : :
8538 : 0 : p_hash_res_init->tbl_num = p_hash_tbl->tbl_num;
8539 [ # # ]: 0 : for (index = 0; index < (p_hash_res_init->tbl_num); index++) {
8540 : 0 : p_tbl_res = p_hash_res_init->tbl_res + index;
8541 : :
8542 : 0 : p_tbl_res->sdt_no = p_hash_tbl->table[index].sdt_no;
8543 : 0 : p_tbl_res->sdt_partner = p_hash_tbl->table[index].sdt_partner;
8544 : 0 : p_tbl_res->tbl_flag = p_hash_tbl->table[index].tbl_flag;
8545 : 0 : p_tbl_res->hash_sdt.table_type =
8546 : 0 : p_hash_tbl->table[index].hash_sdt.table_type;
8547 : 0 : p_tbl_res->hash_sdt.hash_id = p_hash_tbl->table[index].hash_sdt.hash_id;
8548 : 0 : p_tbl_res->hash_sdt.hash_table_width =
8549 : 0 : p_hash_tbl->table[index].hash_sdt.hash_table_width;
8550 : 0 : p_tbl_res->hash_sdt.key_size = p_hash_tbl->table[index].hash_sdt.key_size;
8551 : 0 : p_tbl_res->hash_sdt.hash_table_id =
8552 : 0 : p_hash_tbl->table[index].hash_sdt.hash_table_id;
8553 : 0 : p_tbl_res->hash_sdt.learn_en = p_hash_tbl->table[index].hash_sdt.learn_en;
8554 : 0 : p_tbl_res->hash_sdt.keep_alive =
8555 : 0 : p_hash_tbl->table[index].hash_sdt.keep_alive;
8556 : 0 : p_tbl_res->hash_sdt.keep_alive_baddr =
8557 : 0 : p_hash_tbl->table[index].hash_sdt.keep_alive_baddr;
8558 : 0 : p_tbl_res->hash_sdt.rsp_mode =
8559 : 0 : p_hash_tbl->table[index].hash_sdt.rsp_mode;
8560 : 0 : p_tbl_res->hash_sdt.hash_clutch_en =
8561 : 0 : p_hash_tbl->table[index].hash_sdt.hash_clutch_en;
8562 : : }
8563 : 0 : }
8564 : :
8565 : : static void
8566 : 0 : zxdh_np_eram_tbl_set(ZXDH_APT_ERAM_RES_INIT_T *p_eam_res_init, ZXDH_NP_SE_ERAM_TBL_T *p_eram_tbl)
8567 : : {
8568 : : uint32_t index = 0;
8569 : : ZXDH_APT_ERAM_TABLE_T *p_eram_res = NULL;
8570 : :
8571 : 0 : p_eam_res_init->tbl_num = p_eram_tbl->tbl_num;
8572 [ # # ]: 0 : for (index = 0; index < (p_eam_res_init->tbl_num); index++) {
8573 : 0 : p_eram_res = p_eam_res_init->eram_res + index;
8574 : :
8575 : 0 : p_eram_res->sdt_no = p_eram_tbl->eram[index].sdt_no;
8576 : 0 : p_eram_res->opr_mode = p_eram_tbl->eram[index].opr_mode;
8577 : 0 : p_eram_res->rd_mode = p_eram_tbl->eram[index].rd_mode;
8578 : 0 : p_eram_res->eram_sdt.table_type = p_eram_tbl->eram[index].eram_sdt.table_type;
8579 : 0 : p_eram_res->eram_sdt.eram_mode = p_eram_tbl->eram[index].eram_sdt.eram_mode;
8580 : 0 : p_eram_res->eram_sdt.eram_base_addr =
8581 : 0 : p_eram_tbl->eram[index].eram_sdt.eram_base_addr;
8582 : 0 : p_eram_res->eram_sdt.eram_table_depth =
8583 : 0 : p_eram_tbl->eram[index].eram_sdt.eram_table_depth;
8584 : 0 : p_eram_res->eram_sdt.eram_clutch_en =
8585 : 0 : p_eram_tbl->eram[index].eram_sdt.eram_clutch_en;
8586 : : }
8587 : 0 : }
8588 : :
8589 : : static void
8590 : 0 : zxdh_np_acl_tbl_set(ZXDH_APT_ACL_RES_INIT_T *p_acl_res_init, ZXDH_NP_SE_ACL_TBL_T *p_acl_tbl)
8591 : : {
8592 : : uint32_t index = 0;
8593 : : ZXDH_APT_ACL_TABLE_T *p_acl_res = NULL;
8594 : :
8595 : 0 : p_acl_res_init->tbl_num = p_acl_tbl->tbl_num;
8596 [ # # ]: 0 : for (index = 0; index < (p_acl_tbl->tbl_num); index++) {
8597 : 0 : p_acl_res = p_acl_res_init->acl_res + index;
8598 : :
8599 : 0 : p_acl_res->sdt_no = p_acl_tbl->acl[index].sdt_no;
8600 : 0 : p_acl_res->sdt_partner = p_acl_tbl->acl[index].sdt_partner;
8601 : 0 : p_acl_res->acl_res.block_num = p_acl_tbl->acl[index].acl_res.block_num;
8602 : 0 : p_acl_res->acl_res.entry_num = p_acl_tbl->acl[index].acl_res.entry_num;
8603 : 0 : p_acl_res->acl_res.pri_mode = p_acl_tbl->acl[index].acl_res.pri_mode;
8604 : 0 : memcpy(p_acl_res->acl_res.block_index,
8605 : 0 : p_acl_tbl->acl[index].acl_res.block_index,
8606 : : sizeof(uint32_t) * ZXDH_ETCAM_BLOCK_NUM);
8607 : 0 : p_acl_res->acl_sdt.table_type = p_acl_tbl->acl[index].acl_sdt.table_type;
8608 : 0 : p_acl_res->acl_sdt.etcam_id = p_acl_tbl->acl[index].acl_sdt.etcam_id;
8609 : 0 : p_acl_res->acl_sdt.etcam_key_mode = p_acl_tbl->acl[index].acl_sdt.etcam_key_mode;
8610 : 0 : p_acl_res->acl_sdt.etcam_table_id = p_acl_tbl->acl[index].acl_sdt.etcam_table_id;
8611 : 0 : p_acl_res->acl_sdt.no_as_rsp_mode = p_acl_tbl->acl[index].acl_sdt.no_as_rsp_mode;
8612 : 0 : p_acl_res->acl_sdt.as_en = p_acl_tbl->acl[index].acl_sdt.as_en;
8613 : 0 : p_acl_res->acl_sdt.as_eram_baddr = p_acl_tbl->acl[index].acl_sdt.as_eram_baddr;
8614 : 0 : p_acl_res->acl_sdt.as_rsp_mode = p_acl_tbl->acl[index].acl_sdt.as_rsp_mode;
8615 : 0 : p_acl_res->acl_sdt.etcam_table_depth =
8616 : 0 : p_acl_tbl->acl[index].acl_sdt.etcam_table_depth;
8617 : 0 : p_acl_res->acl_sdt.etcam_clutch_en = p_acl_tbl->acl[index].acl_sdt.etcam_clutch_en;
8618 : : }
8619 : 0 : }
8620 : :
8621 : : static void
8622 : : zxdh_np_stat_cfg_set(ZXDH_APT_STAT_RES_INIT_T *p_stat_res_init, ZXDH_NP_SE_STAT_CFG_T *p_stat_cfg)
8623 : : {
8624 : 0 : p_stat_res_init->eram_baddr = p_stat_cfg->eram_baddr;
8625 : 0 : p_stat_res_init->eram_depth = p_stat_cfg->eram_depth;
8626 : 0 : p_stat_res_init->ddr_baddr = p_stat_cfg->ddr_baddr;
8627 : 0 : p_stat_res_init->ppu_ddr_offset = p_stat_cfg->ppu_ddr_offset;
8628 : : }
8629 : :
8630 : : static uint32_t
8631 : 0 : zxdh_np_agent_hash_func_bulk_get(uint32_t dev_id, uint32_t type,
8632 : : ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init)
8633 : : {
8634 : : uint32_t rc = ZXDH_OK;
8635 : : uint32_t opr = ZXDH_HASH_FUNC_BULK_REQ;
8636 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8637 : : uint32_t buff_size = 0;
8638 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8639 : : uint32_t *p_rsp_buff = NULL;
8640 : : ZXDH_NP_SE_HASH_FUNC_BULK_T *p_func_bulk = NULL;
8641 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8642 : :
8643 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8644 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8645 : :
8646 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8647 : :
8648 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8649 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8650 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8651 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8652 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8653 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8654 : : }
8655 : :
8656 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ? ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8657 : :
8658 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8659 [ # # ]: 0 : if (rc != ZXDH_OK) {
8660 : 0 : rte_free(p_rsp_buff);
8661 : 0 : PMD_DRV_LOG(ERR, "hash func&bulk res get fail rc=0x%x.", rc);
8662 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8663 : 0 : return ZXDH_ERR;
8664 : : }
8665 : :
8666 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8667 : :
8668 : 0 : p_func_bulk = (ZXDH_NP_SE_HASH_FUNC_BULK_T *)(p_rsp_buff + 1);
8669 : 0 : zxdh_np_hash_func_bulk_set(p_hash_res_init, p_func_bulk);
8670 : 0 : rte_free(p_rsp_buff);
8671 : :
8672 : 0 : return rc;
8673 : : }
8674 : :
8675 : : static uint32_t
8676 : 0 : zxdh_np_agent_hash_tbl_get(uint32_t dev_id,
8677 : : uint32_t type,
8678 : : ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init)
8679 : : {
8680 : : uint32_t rc = ZXDH_OK;
8681 : : uint32_t opr = ZXDH_HASH_TBL_REQ;
8682 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8683 : : uint32_t buff_size = 0;
8684 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8685 : : uint32_t *p_rsp_buff = NULL;
8686 : : ZXDH_NP_SE_HASH_TBL_T *p_hash_tbl = NULL;
8687 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8688 : :
8689 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8690 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8691 : :
8692 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8693 : :
8694 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8695 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8696 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8697 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8698 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8699 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8700 : : }
8701 : :
8702 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ?
8703 : 0 : ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8704 : :
8705 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8706 [ # # ]: 0 : if (rc != ZXDH_OK) {
8707 : 0 : rte_free(p_rsp_buff);
8708 : 0 : PMD_DRV_LOG(ERR, "hash table res get fail rc=0x%x.", rc);
8709 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8710 : 0 : return ZXDH_ERR;
8711 : : }
8712 : :
8713 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8714 : :
8715 : 0 : p_hash_tbl = (ZXDH_NP_SE_HASH_TBL_T *)(p_rsp_buff + 1);
8716 : 0 : zxdh_np_hash_tbl_set(p_hash_res_init, p_hash_tbl);
8717 : 0 : rte_free(p_rsp_buff);
8718 : :
8719 : 0 : return rc;
8720 : : }
8721 : :
8722 : : static uint32_t
8723 : 0 : zxdh_np_agent_eram_tbl_get(uint32_t dev_id, uint32_t type, ZXDH_APT_ERAM_RES_INIT_T *p_eam_res_init)
8724 : : {
8725 : : uint32_t rc = ZXDH_OK;
8726 : : uint32_t opr = ZXDH_ERAM_TBL_REQ;
8727 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8728 : : uint32_t buff_size = 0;
8729 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8730 : : uint32_t *p_rsp_buff = NULL;
8731 : : ZXDH_NP_SE_ERAM_TBL_T *p_eram_tbl = NULL;
8732 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8733 : :
8734 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8735 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8736 : :
8737 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8738 : :
8739 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8740 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8741 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8742 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8743 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8744 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8745 : : }
8746 : :
8747 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ?
8748 : 0 : ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8749 : :
8750 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8751 [ # # ]: 0 : if (rc != ZXDH_OK) {
8752 : 0 : rte_free(p_rsp_buff);
8753 : 0 : PMD_DRV_LOG(ERR, "eram table res get fail rc=0x%x.", rc);
8754 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8755 : 0 : return ZXDH_ERR;
8756 : : }
8757 : :
8758 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8759 : :
8760 : 0 : p_eram_tbl = (ZXDH_NP_SE_ERAM_TBL_T *)(p_rsp_buff + 1);
8761 : 0 : zxdh_np_eram_tbl_set(p_eam_res_init, p_eram_tbl);
8762 : 0 : rte_free(p_rsp_buff);
8763 : :
8764 : 0 : return rc;
8765 : : }
8766 : :
8767 : : static uint32_t
8768 : 0 : zxdh_np_agent_acl_tbl_get(uint32_t dev_id, uint32_t type, ZXDH_APT_ACL_RES_INIT_T *p_acl_res_init)
8769 : : {
8770 : : uint32_t rc = ZXDH_OK;
8771 : : uint32_t opr = ZXDH_ACL_TBL_REQ;
8772 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8773 : : uint32_t buff_size = 0;
8774 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8775 : : uint32_t *p_rsp_buff = NULL;
8776 : : ZXDH_NP_SE_ACL_TBL_T *p_acl_tbl = NULL;
8777 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8778 : :
8779 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8780 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8781 : :
8782 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8783 : :
8784 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8785 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8786 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8787 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8788 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8789 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8790 : : }
8791 : :
8792 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ?
8793 : 0 : ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8794 : :
8795 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8796 [ # # ]: 0 : if (rc != ZXDH_OK) {
8797 : 0 : rte_free(p_rsp_buff);
8798 : 0 : PMD_DRV_LOG(ERR, "acl table res get fail rc=0x%x.", rc);
8799 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8800 : 0 : return ZXDH_ERR;
8801 : : }
8802 : :
8803 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8804 : :
8805 : 0 : p_acl_tbl = (ZXDH_NP_SE_ACL_TBL_T *)(p_rsp_buff + 1);
8806 : 0 : zxdh_np_acl_tbl_set(p_acl_res_init, p_acl_tbl);
8807 : 0 : rte_free(p_rsp_buff);
8808 : :
8809 : 0 : return rc;
8810 : : }
8811 : :
8812 : : static uint32_t
8813 : 0 : zxdh_np_agent_stat_cfg_get(uint32_t dev_id,
8814 : : uint32_t type,
8815 : : ZXDH_APT_STAT_RES_INIT_T *p_stat_cfg_init)
8816 : : {
8817 : : uint32_t rc = ZXDH_OK;
8818 : : uint32_t opr = ZXDH_STAT_CFG_REQ;
8819 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8820 : : uint32_t buff_size = 0;
8821 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8822 : : uint32_t *p_rsp_buff = NULL;
8823 : : ZXDH_NP_SE_STAT_CFG_T *p_stat_cfg = NULL;
8824 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8825 : :
8826 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8827 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8828 : :
8829 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8830 : :
8831 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8832 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8833 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8834 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8835 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8836 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8837 : : }
8838 : :
8839 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ? ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8840 : :
8841 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8842 [ # # ]: 0 : if (rc != ZXDH_OK) {
8843 : 0 : rte_free(p_rsp_buff);
8844 : 0 : PMD_DRV_LOG(ERR, "ddr table res get fail rc = 0x%x.", rc);
8845 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8846 : 0 : return ZXDH_ERR;
8847 : : }
8848 : :
8849 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8850 : :
8851 : : p_stat_cfg = (ZXDH_NP_SE_STAT_CFG_T *)(p_rsp_buff + 1);
8852 : : zxdh_np_stat_cfg_set(p_stat_cfg_init, p_stat_cfg);
8853 : 0 : rte_free(p_rsp_buff);
8854 : :
8855 : 0 : return rc;
8856 : : }
8857 : :
8858 : : static void *
8859 : : zxdh_np_dev_get_se_res_ptr(uint32_t dev_id, uint32_t type)
8860 : : {
8861 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
8862 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
8863 : :
8864 : 0 : if (type == ZXDH_SE_STD_NIC_RES_TYPE)
8865 : 0 : return (void *)&p_dev_info->dev_apt_se_tbl_res.std_nic_res;
8866 : : else
8867 : 0 : return (void *)&p_dev_info->dev_apt_se_tbl_res.offload_res;
8868 : : }
8869 : :
8870 : : static uint32_t
8871 : 0 : zxdh_np_agent_se_res_get(uint32_t dev_id, uint32_t type)
8872 : : {
8873 : : uint32_t rc = ZXDH_OK;
8874 : : ZXDH_APT_SE_RES_T *p_se_res = NULL;
8875 : 0 : ZXDH_APT_HASH_RES_INIT_T hash_res = {0};
8876 : 0 : ZXDH_APT_ERAM_RES_INIT_T eram_res = {0};
8877 [ # # ]: 0 : ZXDH_APT_ACL_RES_INIT_T acl_res = {0};
8878 : :
8879 : : p_se_res = (ZXDH_APT_SE_RES_T *)zxdh_np_dev_get_se_res_ptr(dev_id, type);
8880 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_res);
8881 : :
8882 [ # # ]: 0 : if (p_se_res->valid) {
8883 : 0 : PMD_DRV_LOG(INFO, "dev_id [0x%x] res_type [%u] status ready", dev_id, type);
8884 : 0 : return ZXDH_OK;
8885 : : }
8886 : :
8887 : 0 : hash_res.func_res = p_se_res->hash_func;
8888 : 0 : hash_res.bulk_res = p_se_res->hash_bulk;
8889 : 0 : hash_res.tbl_res = p_se_res->hash_tbl;
8890 : 0 : rc = zxdh_np_agent_hash_func_bulk_get(dev_id, type, &hash_res);
8891 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_hash_func_bulk_get");
8892 : :
8893 : 0 : rc = zxdh_np_agent_hash_tbl_get(dev_id, type, &hash_res);
8894 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_hash_tbl_get");
8895 : 0 : p_se_res->hash_func_num = hash_res.func_num;
8896 : 0 : p_se_res->hash_bulk_num = hash_res.bulk_num;
8897 : 0 : p_se_res->hash_tbl_num = hash_res.tbl_num;
8898 : :
8899 : 0 : eram_res.eram_res = p_se_res->eram_tbl;
8900 : 0 : rc = zxdh_np_agent_eram_tbl_get(dev_id, type, &eram_res);
8901 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_eram_tbl_get");
8902 : 0 : p_se_res->eram_num = eram_res.tbl_num;
8903 : :
8904 : 0 : acl_res.acl_res = p_se_res->acl_tbl;
8905 : 0 : rc = zxdh_np_agent_acl_tbl_get(dev_id, type, &acl_res);
8906 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_acl_tbl_get");
8907 : 0 : p_se_res->acl_num = acl_res.tbl_num;
8908 : :
8909 : 0 : rc = zxdh_np_agent_stat_cfg_get(dev_id, type, &p_se_res->stat_cfg);
8910 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_stat_cfg_get");
8911 : :
8912 : 0 : p_se_res->valid = 1;
8913 : 0 : return rc;
8914 : : }
8915 : :
8916 : : static uint32_t
8917 : 0 : zxdh_np_se_init_ex(uint32_t dev_id, ZXDH_SE_CFG *p_se_cfg)
8918 : : {
8919 : : uint32_t i = 0;
8920 : : uint32_t j = 0;
8921 : :
8922 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
8923 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
8924 : :
8925 [ # # ]: 0 : if (dpp_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] != NULL) {
8926 : 0 : PMD_DRV_LOG(DEBUG, "SE global config is already initialized.");
8927 : 0 : return ZXDH_OK;
8928 : : }
8929 : :
8930 : : memset(p_se_cfg, 0, sizeof(ZXDH_SE_CFG));
8931 : :
8932 : 0 : p_se_cfg->dev_id = dev_id;
8933 : 0 : dpp_se_cfg[ZXDH_DEV_SLOT_ID(p_se_cfg->dev_id)] = p_se_cfg;
8934 : :
8935 : : p_se_cfg->p_as_rslt_wrt_fun = NULL;
8936 : 0 : p_se_cfg->p_client = ZXDH_COMM_VAL_TO_PTR(dev_id);
8937 : :
8938 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZBLK_NUM; i++) {
8939 : 0 : p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_se_cfg, i);
8940 : :
8941 : 0 : p_zblk_cfg->zblk_idx = i;
8942 : 0 : p_zblk_cfg->is_used = 0;
8943 : 0 : p_zblk_cfg->hash_arg = g_lpm_crc[i];
8944 : 0 : p_zblk_cfg->zcell_bm = 0;
8945 : : zxdh_np_init_d_node(&p_zblk_cfg->zblk_dn, p_zblk_cfg);
8946 : :
8947 [ # # ]: 0 : for (j = 0; j < ZXDH_SE_ZCELL_NUM; j++) {
8948 : 0 : p_zcell_cfg = &p_zblk_cfg->zcell_info[j];
8949 : :
8950 : 0 : p_zcell_cfg->zcell_idx = (i << 2) + j;
8951 : 0 : p_zcell_cfg->item_used = 0;
8952 : 0 : p_zcell_cfg->mask_len = 0;
8953 : :
8954 : : zxdh_np_init_d_node(&p_zcell_cfg->zcell_dn, p_zcell_cfg);
8955 : :
8956 : 0 : p_zcell_cfg->zcell_avl.p_key = p_zcell_cfg;
8957 : : }
8958 : : }
8959 : :
8960 : : return ZXDH_OK;
8961 : : }
8962 : :
8963 : : static uint32_t
8964 : 0 : zxdh_np_apt_hash_global_res_init(uint32_t dev_id)
8965 : : {
8966 [ # # ]: 0 : if (g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] == NULL) {
8967 : 0 : g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] = rte_zmalloc(NULL, sizeof(ZXDH_SE_CFG), 0);
8968 [ # # ]: 0 : if (g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] == NULL) {
8969 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8970 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8971 : : }
8972 : :
8973 : 0 : zxdh_np_se_init_ex(dev_id, g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)]);
8974 : :
8975 : 0 : g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)]->p_client = ZXDH_COMM_VAL_TO_PTR(dev_id);
8976 : : }
8977 : :
8978 : : return ZXDH_OK;
8979 : : }
8980 : :
8981 : : static void
8982 : : se_apt_get_zblock_index(uint32_t zblock_bitmap, uint32_t *zblk_idx)
8983 : : {
8984 : : uint32_t index0 = 0;
8985 : : uint32_t index1 = 0;
8986 : :
8987 [ # # ]: 0 : for (index0 = 0; index0 < 32; index0++) {
8988 [ # # ]: 0 : if ((zblock_bitmap >> index0) & 0x1) {
8989 : 0 : *(zblk_idx + index1) = index0;
8990 : 0 : index1++;
8991 : : }
8992 : : }
8993 : : }
8994 : :
8995 : : static uint32_t
8996 : 0 : zxdh_np_crc32_calc(uint8_t *p_input_key, uint32_t dw_byte_num, uint32_t dw_crc_poly)
8997 : : {
8998 : : uint32_t dw_result = 0;
8999 : : uint32_t dw_data_type = 0;
9000 : :
9001 : : uint32_t i = 0;
9002 : : uint32_t j = 0;
9003 : :
9004 [ # # ]: 0 : while (i < dw_byte_num) {
9005 : 0 : dw_data_type = (uint32_t)((dw_result & 0xff000000) ^ (p_input_key[i] << 24));
9006 [ # # ]: 0 : for (j = 0; j < 8; j++) {
9007 [ # # ]: 0 : if (dw_data_type & 0x80000000) {
9008 : 0 : dw_data_type <<= 1;
9009 : 0 : dw_data_type ^= dw_crc_poly;
9010 : : } else {
9011 : 0 : dw_data_type <<= 1;
9012 : : }
9013 : : }
9014 : 0 : dw_result <<= 8;
9015 : 0 : dw_result ^= dw_data_type;
9016 : :
9017 : 0 : i++;
9018 : : }
9019 : :
9020 : 0 : return dw_result;
9021 : : }
9022 : :
9023 : : static uint16_t
9024 : 0 : zxdh_np_crc16_calc(uint8_t *p_input_key, uint32_t dw_byte_num, uint16_t dw_crc_poly)
9025 : : {
9026 : : uint16_t dw_result = 0;
9027 : : uint16_t dw_data_type = 0;
9028 : :
9029 : : uint32_t i = 0;
9030 : : uint32_t j = 0;
9031 : :
9032 [ # # ]: 0 : while (i < dw_byte_num) {
9033 : 0 : dw_data_type = (uint16_t)(((dw_result & 0xff00) ^ (p_input_key[i] << 8)) & 0xFFFF);
9034 [ # # ]: 0 : for (j = 0; j < 8; j++) {
9035 [ # # ]: 0 : if (dw_data_type & 0x8000) {
9036 : 0 : dw_data_type <<= 1;
9037 : 0 : dw_data_type ^= dw_crc_poly;
9038 : : } else {
9039 : 0 : dw_data_type <<= 1;
9040 : : }
9041 : : }
9042 : 0 : dw_result <<= 8;
9043 : 0 : dw_result ^= dw_data_type;
9044 : :
9045 : 0 : i++;
9046 : : }
9047 : :
9048 : 0 : return dw_result;
9049 : : }
9050 : :
9051 : : static uint32_t
9052 : 0 : zxdh_np_se_fun_init(ZXDH_SE_CFG *p_se_cfg,
9053 : : uint8_t id,
9054 : : uint32_t fun_type)
9055 : : {
9056 : : ZXDH_FUNC_ID_INFO *p_fun_info = NULL;
9057 : :
9058 : 0 : p_fun_info = ZXDH_GET_FUN_INFO(p_se_cfg, id);
9059 : :
9060 [ # # ]: 0 : if (p_fun_info->is_used) {
9061 : 0 : PMD_DRV_LOG(ERR, "Error[0x%x], fun_id [%u] is already used!",
9062 : : ZXDH_SE_RC_FUN_INVALID, id);
9063 : 0 : return ZXDH_SE_RC_FUN_INVALID;
9064 : : }
9065 : :
9066 : 0 : p_fun_info->fun_id = id;
9067 : 0 : p_fun_info->is_used = 1;
9068 : :
9069 [ # # ]: 0 : switch (fun_type) {
9070 : 0 : case (ZXDH_FUN_HASH):
9071 : 0 : p_fun_info->fun_type = ZXDH_FUN_HASH;
9072 : 0 : p_fun_info->fun_ptr = rte_zmalloc(NULL, sizeof(ZXDH_HASH_CFG), 0);
9073 [ # # ]: 0 : if (p_fun_info->fun_ptr == NULL) {
9074 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9075 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9076 : : }
9077 : 0 : ((ZXDH_HASH_CFG *)(p_fun_info->fun_ptr))->p_se_info = p_se_cfg;
9078 : : break;
9079 : 0 : default:
9080 : 0 : PMD_DRV_LOG(ERR, "Error, unrecgnized fun_type[ %u]", fun_type);
9081 : : RTE_ASSERT(0);
9082 : 0 : return ZXDH_SE_RC_BASE;
9083 : : }
9084 : :
9085 : 0 : return ZXDH_OK;
9086 : : }
9087 : :
9088 : : static int32_t
9089 : 0 : zxdh_np_hash_list_cmp(ZXDH_D_NODE *data1, ZXDH_D_NODE *data2, void *data)
9090 : : {
9091 : : uint32_t flag = 0;
9092 : : uint32_t data_new = 0;
9093 : : uint32_t data_pre = 0;
9094 : :
9095 : 0 : flag = *(uint32_t *)data;
9096 : :
9097 [ # # ]: 0 : if (flag == ZXDH_HASH_CMP_ZCELL) {
9098 : 0 : data_new = ((ZXDH_SE_ZCELL_CFG *)data1->data)->zcell_idx;
9099 : 0 : data_pre = ((ZXDH_SE_ZCELL_CFG *)data2->data)->zcell_idx;
9100 [ # # ]: 0 : } else if (flag == ZXDH_HASH_CMP_ZBLK) {
9101 : 0 : data_new = ((ZXDH_SE_ZBLK_CFG *)data1->data)->zblk_idx;
9102 : 0 : data_pre = ((ZXDH_SE_ZBLK_CFG *)data2->data)->zblk_idx;
9103 : : }
9104 : :
9105 [ # # ]: 0 : if (data_new > data_pre)
9106 : : return 1;
9107 [ # # ]: 0 : else if (data_new == data_pre)
9108 : : return 0;
9109 : : else
9110 : 0 : return -1;
9111 : : }
9112 : :
9113 : : static int32_t
9114 : 0 : zxdh_np_hash_rb_key_cmp(void *p_new, void *p_old, __rte_unused uint32_t key_size)
9115 : : {
9116 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_new = NULL;
9117 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_old = NULL;
9118 : :
9119 : : p_rbkey_new = (ZXDH_HASH_RBKEY_INFO *)(p_new);
9120 : : p_rbkey_old = (ZXDH_HASH_RBKEY_INFO *)(p_old);
9121 : :
9122 : 0 : return memcmp(p_rbkey_new->key, p_rbkey_old->key, ZXDH_HASH_KEY_MAX);
9123 : : }
9124 : :
9125 : : static int32_t
9126 : 0 : zxdh_np_hash_ddr_cfg_rb_key_cmp(void *p_new, void *p_old, __rte_unused uint32_t key_size)
9127 : : {
9128 : : HASH_DDR_CFG *p_rbkey_new = NULL;
9129 : : HASH_DDR_CFG *p_rbkey_old = NULL;
9130 : :
9131 : : p_rbkey_new = (HASH_DDR_CFG *)(p_new);
9132 : : p_rbkey_old = (HASH_DDR_CFG *)(p_old);
9133 : :
9134 : 0 : return memcmp(&p_rbkey_new->ddr_baddr, &p_rbkey_old->ddr_baddr, sizeof(uint32_t));
9135 : : }
9136 : :
9137 : : static uint32_t
9138 : 0 : zxdh_np_hash_zcam_resource_init(ZXDH_HASH_CFG *p_hash_cfg,
9139 : : uint32_t zblk_num, uint32_t *zblk_idx_array)
9140 : : {
9141 : : uint32_t rc = ZXDH_OK;
9142 : :
9143 : : uint32_t i = 0;
9144 : : uint32_t j = 0;
9145 : 0 : uint32_t cmp_type = 0;
9146 : : uint32_t zblk_idx = 0;
9147 : : uint32_t zcell_idx = 0;
9148 : : uint32_t dev_id = 0;
9149 : :
9150 : : ZXDH_D_HEAD *p_zblk_list = NULL;
9151 : : ZXDH_D_HEAD *p_zcell_free = NULL;
9152 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
9153 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
9154 : :
9155 : 0 : dev_id = p_hash_cfg->p_se_info->dev_id;
9156 : :
9157 : 0 : p_zblk_list = &p_hash_cfg->hash_shareram.zblk_list;
9158 : : rc = zxdh_comm_double_link_init(ZXDH_SE_ZBLK_NUM, p_zblk_list);
9159 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
9160 : :
9161 : 0 : p_zcell_free = &p_hash_cfg->hash_shareram.zcell_free_list;
9162 : : rc = zxdh_comm_double_link_init(ZXDH_SE_ZBLK_NUM * ZXDH_SE_ZCELL_NUM, p_zcell_free);
9163 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
9164 : :
9165 [ # # ]: 0 : for (i = 0; i < zblk_num; i++) {
9166 : 0 : zblk_idx = zblk_idx_array[i];
9167 : :
9168 : 0 : p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_hash_cfg->p_se_info, zblk_idx);
9169 : :
9170 [ # # ]: 0 : if (p_zblk_cfg->is_used) {
9171 : 0 : PMD_DRV_LOG(ERR, "ZBlock[%u] is already used", zblk_idx);
9172 : : RTE_ASSERT(0);
9173 : 0 : return ZXDH_HASH_RC_INVALID_ZBLCK;
9174 : : }
9175 : :
9176 [ # # ]: 0 : for (j = 0; j < ZXDH_SE_ZCELL_NUM; j++) {
9177 : 0 : zcell_idx = p_zblk_cfg->zcell_info[j].zcell_idx;
9178 : 0 : p_zcell_cfg = &(((ZXDH_SE_CFG *)(p_hash_cfg->p_se_info))->
9179 : 0 : zblk_info[GET_ZBLK_IDX(zcell_idx)].zcell_info[GET_ZCELL_IDX(zcell_idx)]);
9180 : :
9181 [ # # ]: 0 : if (p_zcell_cfg->is_used) {
9182 : 0 : PMD_DRV_LOG(ERR, "ZBlk[%u], ZCell[%u] is already used",
9183 : : zblk_idx, zcell_idx);
9184 : : RTE_ASSERT(0);
9185 : 0 : return ZXDH_HASH_RC_INVALID_ZCELL;
9186 : : }
9187 : :
9188 : 0 : p_zcell_cfg->is_used = 1;
9189 : :
9190 : 0 : cmp_type = ZXDH_HASH_CMP_ZCELL;
9191 : 0 : rc = zxdh_comm_double_link_insert_sort(&p_zcell_cfg->zcell_dn,
9192 : : p_zcell_free, zxdh_np_hash_list_cmp, &cmp_type);
9193 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_sort");
9194 : : }
9195 : :
9196 : 0 : p_zblk_cfg->is_used = 1;
9197 : 0 : cmp_type = ZXDH_HASH_CMP_ZBLK;
9198 : 0 : rc = zxdh_comm_double_link_insert_sort(&p_zblk_cfg->zblk_dn,
9199 : : p_zblk_list, zxdh_np_hash_list_cmp, &cmp_type);
9200 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_last");
9201 : : }
9202 : :
9203 : : return rc;
9204 : : }
9205 : :
9206 : : static uint32_t
9207 : 0 : zxdh_np_hash_init(ZXDH_SE_CFG *p_se_cfg,
9208 : : uint32_t fun_id,
9209 : : uint32_t zblk_num,
9210 : : uint32_t *zblk_idx,
9211 : : uint32_t ddr_dis)
9212 : : {
9213 : : uint32_t rc = ZXDH_OK;
9214 : : uint32_t i = 0;
9215 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
9216 : : ZXDH_FUNC_ID_INFO *p_func_info = NULL;
9217 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
9218 : :
9219 : 0 : rc = zxdh_np_se_fun_init(p_se_cfg, (fun_id & 0xff), ZXDH_FUN_HASH);
9220 [ # # ]: 0 : if (rc == ZXDH_SE_RC_FUN_INVALID)
9221 : : return ZXDH_OK;
9222 : :
9223 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_fun_init");
9224 : :
9225 : : p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, fun_id);
9226 : 0 : p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
9227 : 0 : p_hash_cfg->fun_id = fun_id;
9228 : 0 : p_hash_cfg->p_hash32_fun = zxdh_np_crc32_calc;
9229 : 0 : p_hash_cfg->p_hash16_fun = zxdh_np_crc16_calc;
9230 : 0 : p_hash_cfg->p_se_info = p_se_cfg;
9231 : :
9232 [ # # ]: 0 : if (ddr_dis == 1)
9233 : 0 : p_hash_cfg->ddr_valid = 0;
9234 : : else
9235 : 0 : p_hash_cfg->ddr_valid = 1;
9236 : :
9237 : 0 : p_hash_cfg->hash_stat.zblock_num = zblk_num;
9238 : 0 : rc = zxdh_np_hash_zcam_resource_init(p_hash_cfg, zblk_num, zblk_idx);
9239 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_zcam_resource_init");
9240 : :
9241 [ # # ]: 0 : for (i = 0; i < zblk_num; i++)
9242 : 0 : p_hash_cfg->hash_stat.zblock_array[i] = zblk_idx[i];
9243 : :
9244 : 0 : rc = (uint32_t)zxdh_comm_rb_init(&p_hash_cfg->hash_rb,
9245 : : 0,
9246 : : sizeof(ZXDH_HASH_RBKEY_INFO),
9247 : : zxdh_np_hash_rb_key_cmp);
9248 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
9249 : :
9250 : 0 : rc = (uint32_t)zxdh_comm_rb_init(&p_hash_cfg->ddr_cfg_rb,
9251 : : 0,
9252 : : sizeof(HASH_DDR_CFG),
9253 : : zxdh_np_hash_ddr_cfg_rb_key_cmp);
9254 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
9255 : :
9256 [ # # ]: 0 : for (i = 0; i < zblk_num; i++)
9257 : 0 : g_hash_zblk_idx[ZXDH_DEV_SLOT_ID(dev_id)][fun_id][i] = zblk_idx[i];
9258 : :
9259 : : return rc;
9260 : : }
9261 : :
9262 : : static uint32_t
9263 : 0 : zxdh_np_apt_hash_func_res_init(uint32_t dev_id, uint32_t func_num,
9264 : : ZXDH_APT_HASH_FUNC_RES_T *p_hash_func_res)
9265 : : {
9266 : : uint32_t rc = ZXDH_OK;
9267 : : uint32_t index = 0;
9268 : : uint32_t zblk_idx[32] = {0};
9269 : : ZXDH_APT_HASH_FUNC_RES_T *p_hash_func_res_temp = NULL;
9270 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9271 : :
9272 : 0 : p_se_cfg = g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
9273 : :
9274 [ # # ]: 0 : for (index = 0; index < func_num; index++) {
9275 : : memset(zblk_idx, 0, sizeof(zblk_idx));
9276 : 0 : p_hash_func_res_temp = p_hash_func_res + index;
9277 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_func_res_temp);
9278 : :
9279 : 0 : se_apt_get_zblock_index(p_hash_func_res_temp->zblk_bitmap, zblk_idx);
9280 : :
9281 : 0 : rc = zxdh_np_hash_init(p_se_cfg,
9282 : : p_hash_func_res_temp->func_id,
9283 : : p_hash_func_res_temp->zblk_num,
9284 : : zblk_idx,
9285 : : p_hash_func_res_temp->ddr_dis);
9286 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_init");
9287 : : }
9288 : :
9289 : 0 : return rc;
9290 : : }
9291 : :
9292 : : static uint32_t
9293 : 0 : zxdh_np_hash_bulk_init(ZXDH_SE_CFG *p_se_cfg,
9294 : : uint32_t fun_id,
9295 : : uint32_t bulk_id,
9296 : : ZXDH_HASH_DDR_RESC_CFG_T *p_ddr_resc_cfg,
9297 : : uint32_t zcell_num,
9298 : : uint32_t zreg_num)
9299 : : {
9300 : : uint32_t rc = ZXDH_OK;
9301 : :
9302 : : uint32_t i = 0;
9303 : : uint32_t j = 0;
9304 : : uint32_t zblk_idx = 0;
9305 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
9306 : : uint32_t ddr_item_num = 0;
9307 : :
9308 : : ZXDH_D_NODE *p_zblk_dn = NULL;
9309 : : ZXDH_D_NODE *p_zcell_dn = NULL;
9310 : : ZXDH_RB_TN *p_rb_tn_new = NULL;
9311 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
9312 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
9313 : : ZXDH_SE_ZREG_CFG *p_zreg_cfg = NULL;
9314 : : HASH_DDR_CFG *p_ddr_cfg = NULL;
9315 : : HASH_DDR_CFG *p_rbkey_new = NULL;
9316 : : HASH_DDR_CFG *p_rbkey_rtn = NULL;
9317 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
9318 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
9319 : : ZXDH_FUNC_ID_INFO *p_func_info = NULL;
9320 : : ZXDH_SE_ITEM_CFG **p_item_array = NULL;
9321 : : ZXDH_HASH_BULK_ZCAM_STAT *p_bulk_zcam_mono = NULL;
9322 : :
9323 : : p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, fun_id);
9324 : 0 : p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
9325 [ # # ]: 0 : if (p_hash_cfg == NULL) {
9326 : 0 : PMD_DRV_LOG(ERR, "p_hash_cfg point null!");
9327 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9328 : : }
9329 : :
9330 [ # # ]: 0 : if (p_hash_cfg->hash_stat.p_bulk_zcam_mono[bulk_id] != NULL) {
9331 : 0 : PMD_DRV_LOG(ERR, "fun_id[%u] bulk_id[%u] is already init", fun_id, bulk_id);
9332 : 0 : return ZXDH_OK;
9333 : : }
9334 : :
9335 : 0 : PMD_DRV_LOG(DEBUG, "p_hash_cfg->ddr_valid = %u!", p_hash_cfg->ddr_valid);
9336 [ # # ]: 0 : if (p_hash_cfg->ddr_valid == 1) {
9337 : 0 : ddr_item_num = p_ddr_resc_cfg->ddr_item_num;
9338 [ # # ]: 0 : if (ZXDH_DDR_WIDTH_512b == p_ddr_resc_cfg->ddr_width_mode)
9339 : 0 : ddr_item_num = p_ddr_resc_cfg->ddr_item_num >> 1;
9340 : :
9341 : 0 : p_rbkey_new = rte_zmalloc(NULL, sizeof(HASH_DDR_CFG), 0);
9342 [ # # ]: 0 : if (p_rbkey_new == NULL) {
9343 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9344 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9345 : : }
9346 : :
9347 : 0 : p_rbkey_new->ddr_baddr = p_ddr_resc_cfg->ddr_baddr;
9348 : :
9349 : 0 : p_rb_tn_new = rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
9350 [ # # ]: 0 : if (p_rb_tn_new == NULL) {
9351 : 0 : rte_free(p_rbkey_new);
9352 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9353 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9354 : : }
9355 : : zxdh_np_init_rbt_tn(p_rb_tn_new, p_rbkey_new);
9356 : :
9357 : 0 : rc = zxdh_comm_rb_insert(&p_hash_cfg->ddr_cfg_rb,
9358 : : (void *)p_rb_tn_new, (void *)(&p_rb_tn_rtn));
9359 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_FULL) {
9360 : 0 : PMD_DRV_LOG(ERR, "The red black tree is full!");
9361 : 0 : rte_free(p_rbkey_new);
9362 : 0 : rte_free(p_rb_tn_new);
9363 : : RTE_ASSERT(0);
9364 : 0 : return ZXDH_HASH_RC_RB_TREE_FULL;
9365 [ # # ]: 0 : } else if (rc == ZXDH_RBT_RC_UPDATE) {
9366 : 0 : PMD_DRV_LOG(DEBUG, "some bulk_id share one bulk!");
9367 : :
9368 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
9369 : 0 : p_rbkey_rtn = (HASH_DDR_CFG *)(p_rb_tn_rtn->p_key);
9370 : :
9371 : 0 : p_ddr_cfg = p_hash_cfg->p_bulk_ddr_info[p_rbkey_rtn->bulk_id];
9372 : :
9373 : 0 : if (p_ddr_cfg->hash_ddr_arg !=
9374 [ # # ]: 0 : GET_DDR_HASH_ARG(p_ddr_resc_cfg->ddr_crc_sel) ||
9375 [ # # ]: 0 : p_ddr_cfg->width_mode != p_ddr_resc_cfg->ddr_width_mode ||
9376 [ # # ]: 0 : p_ddr_cfg->ddr_ecc_en != p_ddr_resc_cfg->ddr_ecc_en ||
9377 [ # # ]: 0 : p_ddr_cfg->item_num != ddr_item_num) {
9378 : 0 : PMD_DRV_LOG(ERR, "The base address is same");
9379 : 0 : rte_free(p_rbkey_new);
9380 : 0 : rte_free(p_rb_tn_new);
9381 : : RTE_ASSERT(0);
9382 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9383 : : }
9384 : :
9385 : 0 : p_hash_cfg->p_bulk_ddr_info[bulk_id] =
9386 : : p_hash_cfg->p_bulk_ddr_info[p_rbkey_rtn->bulk_id];
9387 : :
9388 : 0 : rte_free(p_rbkey_new);
9389 : 0 : rte_free(p_rb_tn_new);
9390 : : } else {
9391 : 0 : p_item_array = rte_zmalloc(NULL, ddr_item_num *
9392 : : sizeof(ZXDH_SE_ITEM_CFG *), 0);
9393 [ # # ]: 0 : if (NULL == (p_item_array)) {
9394 : 0 : rte_free(p_rbkey_new);
9395 : 0 : rte_free(p_rb_tn_new);
9396 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9397 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9398 : : }
9399 : :
9400 : 0 : p_rbkey_new->p_item_array = p_item_array;
9401 : 0 : p_rbkey_new->bulk_id = bulk_id;
9402 : 0 : p_rbkey_new->hw_baddr = 0;
9403 : 0 : p_rbkey_new->width_mode = p_ddr_resc_cfg->ddr_width_mode;
9404 : 0 : p_rbkey_new->item_num = ddr_item_num;
9405 : 0 : p_rbkey_new->ddr_ecc_en = p_ddr_resc_cfg->ddr_ecc_en;
9406 : 0 : p_rbkey_new->hash_ddr_arg = GET_DDR_HASH_ARG(p_ddr_resc_cfg->ddr_crc_sel);
9407 : 0 : p_rbkey_new->bulk_use = 1;
9408 : 0 : p_rbkey_new->zcell_num = zcell_num;
9409 : 0 : p_rbkey_new->zreg_num = zreg_num;
9410 : 0 : p_hash_cfg->p_bulk_ddr_info[bulk_id] = p_rbkey_new;
9411 : :
9412 : 0 : PMD_DRV_LOG(DEBUG, "one new ddr_bulk init!");
9413 : : }
9414 : : }
9415 : :
9416 : 0 : p_bulk_zcam_mono = rte_zmalloc(NULL, sizeof(ZXDH_HASH_BULK_ZCAM_STAT), 0);
9417 [ # # ]: 0 : if (NULL == (p_bulk_zcam_mono)) {
9418 : 0 : rte_free(p_rbkey_new);
9419 : 0 : rte_free(p_rb_tn_new);
9420 : 0 : rte_free(p_item_array);
9421 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9422 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9423 : : }
9424 : 0 : (&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[bulk_id] = p_bulk_zcam_mono;
9425 : :
9426 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZBLK_NUM * ZXDH_SE_ZCELL_NUM; i++)
9427 : 0 : p_bulk_zcam_mono->zcell_mono_idx[i] = 0xffffffff;
9428 : :
9429 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZBLK_NUM; i++) {
9430 [ # # ]: 0 : for (j = 0; j < ZXDH_SE_ZREG_NUM; j++) {
9431 : 0 : p_bulk_zcam_mono->zreg_mono_id[i][j].zblk_id = 0xffffffff;
9432 : 0 : p_bulk_zcam_mono->zreg_mono_id[i][j].zreg_id = 0xffffffff;
9433 : : }
9434 : : }
9435 : :
9436 [ # # ]: 0 : if (zcell_num > 0) {
9437 : 0 : p_hash_cfg->bulk_ram_mono[bulk_id] = 1;
9438 : :
9439 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
9440 : :
9441 : : i = 0;
9442 : :
9443 [ # # ]: 0 : while (p_zcell_dn) {
9444 : 0 : p_zcell_cfg = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
9445 : :
9446 [ # # ]: 0 : if (p_zcell_cfg->is_used) {
9447 [ # # ]: 0 : if (!(p_zcell_cfg->flag & ZXDH_ZCELL_FLAG_IS_MONO)) {
9448 : 0 : p_zcell_cfg->flag |= ZXDH_ZCELL_FLAG_IS_MONO;
9449 : 0 : p_zcell_cfg->bulk_id = bulk_id;
9450 : :
9451 : 0 : p_bulk_zcam_mono->zcell_mono_idx[p_zcell_cfg->zcell_idx] =
9452 : : p_zcell_cfg->zcell_idx;
9453 : :
9454 [ # # ]: 0 : if (++i >= zcell_num)
9455 : : break;
9456 : : }
9457 : : } else {
9458 : 0 : PMD_DRV_LOG(ERR, "zcell[ %u ] is not init", p_zcell_cfg->zcell_idx);
9459 : : RTE_ASSERT(0);
9460 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9461 : : }
9462 : :
9463 : 0 : p_zcell_dn = p_zcell_dn->next;
9464 : : }
9465 : :
9466 [ # # ]: 0 : if (i < zcell_num)
9467 : 0 : PMD_DRV_LOG(ERR, "Input zcell_num is %u, bulk %u monopolize zcells is %u",
9468 : : zcell_num, bulk_id, i);
9469 : : }
9470 : :
9471 [ # # ]: 0 : if (zreg_num > 0) {
9472 : 0 : p_hash_cfg->bulk_ram_mono[bulk_id] = 1;
9473 : :
9474 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
9475 : : j = 0;
9476 : :
9477 [ # # ]: 0 : while (p_zblk_dn) {
9478 : 0 : p_zblk_cfg = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
9479 : 0 : zblk_idx = p_zblk_cfg->zblk_idx;
9480 : :
9481 [ # # ]: 0 : if (p_zblk_cfg->is_used) {
9482 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
9483 : : p_zreg_cfg = &p_zblk_cfg->zreg_info[i];
9484 : :
9485 [ # # ]: 0 : if (!(p_zreg_cfg->flag & ZXDH_ZREG_FLAG_IS_MONO)) {
9486 : 0 : p_zreg_cfg->flag = ZXDH_ZREG_FLAG_IS_MONO;
9487 : 0 : p_zreg_cfg->bulk_id = bulk_id;
9488 : :
9489 : 0 : p_bulk_zcam_mono->zreg_mono_id[zblk_idx][i].zblk_id =
9490 : : zblk_idx;
9491 : 0 : p_bulk_zcam_mono->zreg_mono_id[zblk_idx][i].zreg_id = i;
9492 : :
9493 [ # # ]: 0 : if (++j >= zreg_num)
9494 : : break;
9495 : : }
9496 : : }
9497 : :
9498 [ # # ]: 0 : if (j >= zreg_num)
9499 : : break;
9500 : : } else {
9501 : 0 : PMD_DRV_LOG(ERR, "zblk [ %u ] is not init", p_zblk_cfg->zblk_idx);
9502 : : RTE_ASSERT(0);
9503 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9504 : : }
9505 : :
9506 : 0 : p_zblk_dn = p_zblk_dn->next;
9507 : : }
9508 : :
9509 [ # # ]: 0 : if (j < zreg_num)
9510 : 0 : PMD_DRV_LOG(ERR, "Input zreg_num' is %u, actually bulk %u monopolize zregs is %u",
9511 : : zreg_num, bulk_id, j);
9512 : : }
9513 : :
9514 : : return ZXDH_OK;
9515 : : }
9516 : :
9517 : : static uint32_t
9518 : 0 : zxdh_np_apt_hash_bulk_res_init(uint32_t dev_id, uint32_t bulk_num,
9519 : : ZXDH_APT_HASH_BULK_RES_T *p_bulk_res)
9520 : : {
9521 : : uint32_t rc = ZXDH_OK;
9522 : : uint32_t index = 0;
9523 : : ZXDH_APT_HASH_BULK_RES_T *p_hash_bulk_res_temp = NULL;
9524 : : ZXDH_HASH_DDR_RESC_CFG_T ddr_resc_cfg = {0};
9525 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9526 : :
9527 : 0 : p_se_cfg = g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
9528 : :
9529 [ # # ]: 0 : for (index = 0; index < bulk_num; index++) {
9530 : : memset(&ddr_resc_cfg, 0, sizeof(ZXDH_HASH_DDR_RESC_CFG_T));
9531 : 0 : p_hash_bulk_res_temp = p_bulk_res + index;
9532 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_bulk_res_temp);
9533 : :
9534 : 0 : ddr_resc_cfg.ddr_baddr = p_hash_bulk_res_temp->ddr_baddr;
9535 : 0 : ddr_resc_cfg.ddr_item_num = p_hash_bulk_res_temp->ddr_item_num;
9536 : 0 : ddr_resc_cfg.ddr_width_mode = p_hash_bulk_res_temp->ddr_width_mode;
9537 : 0 : ddr_resc_cfg.ddr_crc_sel = p_hash_bulk_res_temp->ddr_crc_sel;
9538 : 0 : ddr_resc_cfg.ddr_ecc_en = p_hash_bulk_res_temp->ddr_ecc_en;
9539 : :
9540 : 0 : rc = zxdh_np_hash_bulk_init(p_se_cfg,
9541 : : p_hash_bulk_res_temp->func_id,
9542 : : p_hash_bulk_res_temp->bulk_id,
9543 : : &ddr_resc_cfg,
9544 : : p_hash_bulk_res_temp->zcell_num,
9545 : : p_hash_bulk_res_temp->zreg_num);
9546 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_bulk_init");
9547 : : }
9548 : :
9549 : 0 : return rc;
9550 : : }
9551 : :
9552 : : static uint32_t
9553 : 0 : zxdh_np_apt_set_callback(uint32_t dev_id, uint32_t sdt_no, uint32_t table_type, void *p_data)
9554 : : {
9555 : : SE_APT_CALLBACK_T *apt_func = NULL;
9556 : :
9557 : 0 : apt_func = &g_apt_se_callback[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no];
9558 : :
9559 : 0 : apt_func->sdt_no = sdt_no;
9560 : 0 : apt_func->table_type = table_type;
9561 [ # # # # ]: 0 : switch (table_type) {
9562 : 0 : case ZXDH_SDT_TBLT_ERAM:
9563 : 0 : apt_func->se_func_info.eram_func.opr_mode =
9564 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->opr_mode;
9565 : 0 : apt_func->se_func_info.eram_func.rd_mode =
9566 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->rd_mode;
9567 : 0 : apt_func->se_func_info.eram_func.eram_set_func =
9568 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->eram_set_func;
9569 : 0 : apt_func->se_func_info.eram_func.eram_get_func =
9570 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->eram_get_func;
9571 : 0 : break;
9572 : 0 : case ZXDH_SDT_TBLT_HASH:
9573 : 0 : apt_func->se_func_info.hash_func.sdt_partner =
9574 : 0 : ((ZXDH_APT_HASH_TABLE_T *)p_data)->sdt_partner;
9575 : 0 : apt_func->se_func_info.hash_func.hash_set_func =
9576 : 0 : ((ZXDH_APT_HASH_TABLE_T *)p_data)->hash_set_func;
9577 : 0 : apt_func->se_func_info.hash_func.hash_get_func =
9578 : 0 : ((ZXDH_APT_HASH_TABLE_T *)p_data)->hash_get_func;
9579 : 0 : break;
9580 : 0 : case ZXDH_SDT_TBLT_ETCAM:
9581 : 0 : apt_func->se_func_info.acl_func.sdt_partner =
9582 : 0 : ((ZXDH_APT_ACL_TABLE_T *)p_data)->sdt_partner;
9583 : 0 : apt_func->se_func_info.acl_func.acl_set_func =
9584 : 0 : ((ZXDH_APT_ACL_TABLE_T *)p_data)->acl_set_func;
9585 : 0 : apt_func->se_func_info.acl_func.acl_get_func =
9586 : 0 : ((ZXDH_APT_ACL_TABLE_T *)p_data)->acl_get_func;
9587 : 0 : break;
9588 : 0 : default:
9589 : 0 : PMD_DRV_LOG(ERR, "table_type[ %u ] is invalid!", table_type);
9590 : 0 : return ZXDH_ERR;
9591 : : }
9592 : :
9593 : : return ZXDH_OK;
9594 : : }
9595 : :
9596 : : static uint32_t
9597 : 0 : zxdh_np_hash_tbl_id_info_init(ZXDH_SE_CFG *p_se_cfg,
9598 : : uint32_t fun_id,
9599 : : uint32_t tbl_id,
9600 : : uint32_t tbl_flag,
9601 : : uint32_t key_type,
9602 : : uint32_t actu_key_size)
9603 : : {
9604 [ # # ]: 0 : uint32_t key_by_size = ZXDH_GET_KEY_SIZE(actu_key_size);
9605 : : uint32_t entry_size = ZXDH_GET_HASH_ENTRY_SIZE(key_type);
9606 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
9607 : : ZXDH_HASH_TBL_ID_INFO *p_tbl_id_info = NULL;
9608 : :
9609 [ # # ]: 0 : if (key_by_size > entry_size) {
9610 : 0 : PMD_DRV_LOG(ERR, "ErrorCode[%x]: actu_key_size[%u] not match to key_type[%u].",
9611 : : ZXDH_HASH_RC_INVALID_PARA,
9612 : : key_by_size,
9613 : : entry_size);
9614 : : RTE_ASSERT(0);
9615 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9616 : : }
9617 : :
9618 : 0 : p_tbl_id_info = GET_HASH_TBL_ID_INFO(dev_id, fun_id, tbl_id);
9619 : :
9620 [ # # ]: 0 : if (p_tbl_id_info->is_init) {
9621 : 0 : PMD_DRV_LOG(ERR, "fun_id[%u], table_id[%u] is already init", fun_id, tbl_id);
9622 : 0 : return ZXDH_OK;
9623 : : }
9624 : :
9625 : 0 : p_tbl_id_info->fun_id = fun_id;
9626 : 0 : p_tbl_id_info->actu_key_size = actu_key_size;
9627 : 0 : p_tbl_id_info->key_type = key_type;
9628 : 0 : p_tbl_id_info->is_init = 1;
9629 : :
9630 [ # # ]: 0 : if (tbl_flag & ZXDH_HASH_TBL_FLAG_AGE)
9631 : 0 : p_tbl_id_info->is_age = 1;
9632 : :
9633 [ # # ]: 0 : if (tbl_flag & ZXDH_HASH_TBL_FLAG_LEARN)
9634 : 0 : p_tbl_id_info->is_lrn = 1;
9635 : :
9636 [ # # ]: 0 : if (tbl_flag & ZXDH_HASH_TBL_FLAG_MC_WRT)
9637 : 0 : p_tbl_id_info->is_mc_wrt = 1;
9638 : :
9639 : : return ZXDH_OK;
9640 : : }
9641 : :
9642 : : static uint32_t
9643 : 0 : zxdh_np_apt_hash_tbl_res_init(uint32_t dev_id, uint32_t tbl_num,
9644 : : ZXDH_APT_HASH_TABLE_T *p_hash_tbl)
9645 : : {
9646 : : uint32_t rc = ZXDH_OK;
9647 : : uint32_t index = 0;
9648 : : ZXDH_APT_HASH_TABLE_T *p_hash_tbl_temp = NULL;
9649 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9650 : :
9651 : 0 : p_se_cfg = g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
9652 : :
9653 [ # # ]: 0 : for (index = 0; index < tbl_num; index++) {
9654 : 0 : p_hash_tbl_temp = p_hash_tbl + index;
9655 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_tbl_temp);
9656 : 0 : rc = zxdh_np_sdt_tbl_write(dev_id,
9657 : : p_hash_tbl_temp->sdt_no,
9658 : : p_hash_tbl_temp->hash_sdt.table_type,
9659 : 0 : &p_hash_tbl_temp->hash_sdt,
9660 : : ZXDH_SDT_OPER_ADD);
9661 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_sdt_tbl_write");
9662 : :
9663 : 0 : rc = zxdh_np_hash_tbl_id_info_init(p_se_cfg,
9664 : : p_hash_tbl_temp->hash_sdt.hash_id,
9665 : : p_hash_tbl_temp->hash_sdt.hash_table_id,
9666 : : p_hash_tbl_temp->tbl_flag,
9667 : : p_hash_tbl_temp->hash_sdt.hash_table_width,
9668 : : p_hash_tbl_temp->hash_sdt.key_size);
9669 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_tbl_id_info_init_ex");
9670 : :
9671 : 0 : rc = zxdh_np_apt_set_callback(dev_id,
9672 : : p_hash_tbl_temp->sdt_no,
9673 : : p_hash_tbl_temp->hash_sdt.table_type,
9674 : : (void *)p_hash_tbl_temp);
9675 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_set_callback");
9676 : : }
9677 : :
9678 : 0 : return rc;
9679 : : }
9680 : :
9681 : : static uint32_t
9682 : 0 : zxdh_np_apt_eram_res_init(uint32_t dev_id, uint32_t tbl_num, ZXDH_APT_ERAM_TABLE_T *p_eram_tbl)
9683 : : {
9684 : : uint32_t rc = ZXDH_OK;
9685 : : uint32_t index = 0;
9686 : : ZXDH_APT_ERAM_TABLE_T *p_temp_eram_tbl = NULL;
9687 : :
9688 [ # # ]: 0 : for (index = 0; index < tbl_num; index++) {
9689 : 0 : p_temp_eram_tbl = p_eram_tbl + index;
9690 : 0 : rc = zxdh_np_sdt_tbl_write(dev_id,
9691 : : p_temp_eram_tbl->sdt_no,
9692 : : p_temp_eram_tbl->eram_sdt.table_type,
9693 : 0 : &p_temp_eram_tbl->eram_sdt,
9694 : : ZXDH_SDT_OPER_ADD);
9695 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_sdt_tbl_write");
9696 : :
9697 : 0 : rc = zxdh_np_apt_set_callback(dev_id,
9698 : : p_temp_eram_tbl->sdt_no,
9699 : : p_temp_eram_tbl->eram_sdt.table_type,
9700 : : (void *)p_temp_eram_tbl);
9701 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_set_callback");
9702 : : }
9703 : :
9704 : 0 : return rc;
9705 : : }
9706 : :
9707 : : static uint32_t
9708 : : zxdh_np_acl_entrynum_to_blocknum(uint32_t entry_num, uint32_t key_mode)
9709 : : {
9710 : : uint32_t value = 0;
9711 : :
9712 : 0 : value = entry_num % (ZXDH_ETCAM_RAM_DEPTH * ((uint32_t)1 << key_mode));
9713 : :
9714 [ # # ]: 0 : if (value == 0)
9715 : 0 : return (entry_num / (ZXDH_ETCAM_RAM_DEPTH * ((uint32_t)1 << key_mode)));
9716 : : else
9717 : 0 : return (entry_num / (ZXDH_ETCAM_RAM_DEPTH * ((uint32_t)1 << key_mode)) + 1);
9718 : : }
9719 : :
9720 : : static int32_t
9721 : 0 : zxdh_np_acl_key_cmp(void *p_new_key, void *p_old_key, uint32_t key_len)
9722 : : {
9723 : 0 : return memcmp(&(((ZXDH_ACL_KEY_INFO_T *)p_new_key)->pri),
9724 : 0 : &(((ZXDH_ACL_KEY_INFO_T *)p_old_key)->pri), key_len - sizeof(uint32_t));
9725 : : }
9726 : :
9727 : : static uint32_t
9728 : : zxdh_np_acl_cfg_init_ex(ZXDH_ACL_CFG_EX_T *p_acl_cfg,
9729 : : void *p_client,
9730 : : uint32_t flags,
9731 : : ZXDH_ACL_AS_RSLT_WRT_FUNCTION p_as_wrt_fun)
9732 : : {
9733 : : uint32_t rc = 0;
9734 : :
9735 : : memset(p_acl_cfg, 0, sizeof(ZXDH_ACL_CFG_EX_T));
9736 : :
9737 : 0 : p_acl_cfg->p_client = p_client;
9738 : 0 : p_acl_cfg->dev_id = (uint32_t)(ZXDH_COMM_PTR_TO_VAL(p_acl_cfg->p_client) & 0xFFFFFFFF);
9739 : 0 : p_acl_cfg->flags = flags;
9740 : :
9741 : 0 : g_p_acl_ex_cfg[ZXDH_DEV_SLOT_ID(p_acl_cfg->dev_id)] = p_acl_cfg;
9742 : :
9743 : : if (flags & ZXDH_ACL_FLAG_ETCAM0_EN) {
9744 : 0 : p_acl_cfg->acl_etcamids.is_valid = 1;
9745 : :
9746 : : p_acl_cfg->acl_etcamids.as_eram_base = 0;
9747 : :
9748 : : rc = zxdh_comm_double_link_init(ZXDH_ACL_TBL_ID_NUM,
9749 : : &p_acl_cfg->acl_etcamids.tbl_list);
9750 : : ZXDH_COMM_CHECK_RC(rc, "zxdh_comm_double_link_init");
9751 : : }
9752 : :
9753 : : if (p_as_wrt_fun == NULL) {
9754 : 0 : p_acl_cfg->p_as_rslt_write_fun = NULL;
9755 : 0 : p_acl_cfg->p_as_rslt_read_fun = NULL;
9756 : :
9757 : : } else {
9758 : : p_acl_cfg->p_as_rslt_write_fun = p_as_wrt_fun;
9759 : : }
9760 : :
9761 : : return rc;
9762 : : }
9763 : :
9764 : : static uint32_t
9765 : 0 : zxdh_np_acl_tbl_init_ex(ZXDH_ACL_CFG_EX_T *p_acl_cfg,
9766 : : uint32_t table_id,
9767 : : uint32_t as_enable,
9768 : : uint32_t entry_num,
9769 : : ZXDH_ACL_PRI_MODE_E pri_mode,
9770 : : uint32_t key_mode,
9771 : : ZXDH_ACL_AS_MODE_E as_mode,
9772 : : uint32_t as_baddr,
9773 : : uint32_t block_num,
9774 : : uint32_t *p_block_idx)
9775 : : {
9776 : : uint32_t rc = 0;
9777 : : uint32_t i = 0;
9778 : :
9779 : 0 : g_p_acl_ex_cfg[ZXDH_DEV_SLOT_ID(p_acl_cfg->dev_id)] = p_acl_cfg;
9780 : :
9781 [ # # ]: 0 : if (p_acl_cfg->acl_tbls[table_id].is_used) {
9782 : 0 : PMD_DRV_LOG(ERR, "table_id[ %u ] is already used!", table_id);
9783 : : RTE_ASSERT(0);
9784 : 0 : return ZXDH_ACL_RC_INVALID_TBLID;
9785 : : }
9786 : :
9787 [ # # ]: 0 : if (!p_acl_cfg->acl_etcamids.is_valid) {
9788 : 0 : PMD_DRV_LOG(ERR, "etcam is not init!");
9789 : : RTE_ASSERT(0);
9790 : 0 : return ZXDH_ACL_RC_ETCAMID_NOT_INIT;
9791 : : }
9792 : :
9793 [ # # ]: 0 : if (zxdh_np_acl_entrynum_to_blocknum(entry_num, key_mode) > block_num) {
9794 : 0 : PMD_DRV_LOG(ERR, "key_mode %u, etcam block_num %u is not enough for entry_num 0x%x",
9795 : : key_mode, block_num, entry_num);
9796 : : RTE_ASSERT(0);
9797 : 0 : return ZXDH_ACL_RC_INVALID_BLOCKNUM;
9798 [ # # ]: 0 : } else if (zxdh_np_acl_entrynum_to_blocknum(entry_num, key_mode) < block_num) {
9799 : 0 : PMD_DRV_LOG(DEBUG, "key_mode %u, etcam block_num %u is more than entry_num 0x%x",
9800 : : key_mode, block_num, entry_num);
9801 : : } else {
9802 : 0 : PMD_DRV_LOG(DEBUG, "key_mode %u, etcam block_num %u is match with entry_num 0x%x",
9803 : : key_mode, block_num, entry_num);
9804 : : }
9805 : :
9806 : 0 : p_acl_cfg->acl_tbls[table_id].as_enable = as_enable;
9807 : :
9808 [ # # ]: 0 : if (as_enable) {
9809 : 0 : p_acl_cfg->acl_tbls[table_id].as_idx_base = as_baddr;
9810 : 0 : p_acl_cfg->acl_tbls[table_id].as_rslt_buff =
9811 : 0 : rte_zmalloc(NULL, entry_num * ZXDH_ACL_AS_RSLT_SIZE_GET_EX(as_mode), 0);
9812 [ # # ]: 0 : if (p_acl_cfg->acl_tbls[table_id].as_rslt_buff == NULL) {
9813 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9814 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9815 : : }
9816 : : }
9817 : :
9818 : 0 : rc = (uint32_t)zxdh_comm_rb_init(&p_acl_cfg->acl_tbls[table_id].acl_rb, 0,
9819 : 0 : (sizeof(ZXDH_ACL_KEY_INFO_T) & 0xFFFFFFFFU) + ZXDH_ACL_KEYSIZE_GET(key_mode),
9820 : : zxdh_np_acl_key_cmp);
9821 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_comm_rb_init");
9822 : :
9823 : 0 : p_acl_cfg->acl_tbls[table_id].table_id = table_id;
9824 : 0 : p_acl_cfg->acl_tbls[table_id].pri_mode = pri_mode;
9825 : 0 : p_acl_cfg->acl_tbls[table_id].key_mode = key_mode;
9826 : 0 : p_acl_cfg->acl_tbls[table_id].entry_num = entry_num;
9827 : 0 : p_acl_cfg->acl_tbls[table_id].as_mode = as_mode;
9828 : 0 : p_acl_cfg->acl_tbls[table_id].is_used = 1;
9829 : :
9830 : 0 : zxdh_np_init_d_node(&p_acl_cfg->acl_tbls[table_id].entry_dn,
9831 [ # # ]: 0 : &p_acl_cfg->acl_tbls[table_id]);
9832 : : rc = zxdh_comm_double_link_insert_last(&p_acl_cfg->acl_tbls[table_id].entry_dn,
9833 : : &p_acl_cfg->acl_etcamids.tbl_list);
9834 : : ZXDH_COMM_CHECK_RC(rc, "zxdh_comm_double_link_insert_last");
9835 : :
9836 : 0 : p_acl_cfg->acl_tbls[table_id].block_num = block_num;
9837 : 0 : p_acl_cfg->acl_tbls[table_id].block_array =
9838 : 0 : rte_zmalloc(NULL, block_num * sizeof(uint32_t), 0);
9839 [ # # ]: 0 : if (p_acl_cfg->acl_tbls[table_id].block_array == NULL) {
9840 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9841 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9842 : : }
9843 : :
9844 [ # # ]: 0 : for (i = 0; i < block_num; i++) {
9845 [ # # ]: 0 : if (p_acl_cfg->acl_blocks[p_block_idx[i]].is_used) {
9846 : 0 : PMD_DRV_LOG(ERR, "the block[ %u ] is already used by table[ %u ]!",
9847 : : p_block_idx[i], p_acl_cfg->acl_blocks[p_block_idx[i]].tbl_id);
9848 : : RTE_ASSERT(0);
9849 : 0 : return ZXDH_ACL_RC_INVALID_BLOCKID;
9850 : : }
9851 : :
9852 : 0 : p_acl_cfg->acl_tbls[table_id].block_array[i] = p_block_idx[i];
9853 : 0 : p_acl_cfg->acl_blocks[p_block_idx[i]].is_used = 1;
9854 : 0 : p_acl_cfg->acl_blocks[p_block_idx[i]].tbl_id = table_id;
9855 : 0 : p_acl_cfg->acl_blocks[p_block_idx[i]].idx_base =
9856 : 0 : ((ZXDH_ACL_ENTRY_MAX_GET(key_mode, i)) >> ZXDH_BLOCK_IDXBASE_BIT_OFF) &
9857 : : ZXDH_BLOCK_IDXBASE_BIT_MASK;
9858 : : }
9859 : :
9860 : : return ZXDH_OK;
9861 : : }
9862 : :
9863 : : static uint32_t
9864 : 0 : zxdh_np_apt_acl_res_init(uint32_t dev_id, uint32_t tbl_num, ZXDH_APT_ACL_TABLE_T *p_acl_tbl_res)
9865 : : {
9866 : : uint32_t rc = ZXDH_OK;
9867 : : uint8_t index = 0;
9868 : : ZXDH_APT_ACL_TABLE_T *p_temp_acl_tbl = NULL;
9869 : :
9870 : 0 : rc = zxdh_np_acl_cfg_init_ex(&g_apt_acl_cfg[ZXDH_DEV_SLOT_ID(dev_id)],
9871 : 0 : (void *)ZXDH_COMM_VAL_TO_PTR(dev_id),
9872 : : ZXDH_ACL_FLAG_ETCAM0_EN,
9873 : : NULL);
9874 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_acl_cfg_init_ex");
9875 : :
9876 [ # # ]: 0 : for (index = 0; index < tbl_num; index++) {
9877 : 0 : p_temp_acl_tbl = p_acl_tbl_res + index;
9878 : 0 : rc = zxdh_np_sdt_tbl_write(dev_id,
9879 : : p_temp_acl_tbl->sdt_no,
9880 : : p_temp_acl_tbl->acl_sdt.table_type,
9881 : 0 : &p_temp_acl_tbl->acl_sdt,
9882 : : ZXDH_SDT_OPER_ADD);
9883 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_sdt_tbl_write");
9884 : :
9885 : 0 : rc = zxdh_np_acl_tbl_init_ex(&g_apt_acl_cfg[ZXDH_DEV_SLOT_ID(dev_id)],
9886 : : p_temp_acl_tbl->acl_sdt.etcam_table_id,
9887 : : p_temp_acl_tbl->acl_sdt.as_en,
9888 : : p_temp_acl_tbl->acl_res.entry_num,
9889 : 0 : p_temp_acl_tbl->acl_res.pri_mode,
9890 : : p_temp_acl_tbl->acl_sdt.etcam_key_mode,
9891 : 0 : p_temp_acl_tbl->acl_sdt.as_rsp_mode,
9892 : : p_temp_acl_tbl->acl_sdt.as_eram_baddr,
9893 : : p_temp_acl_tbl->acl_res.block_num,
9894 : 0 : p_temp_acl_tbl->acl_res.block_index);
9895 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_acl_tbl_init_ex");
9896 : :
9897 : 0 : rc = zxdh_np_apt_set_callback(dev_id,
9898 : : p_temp_acl_tbl->sdt_no,
9899 : : p_temp_acl_tbl->acl_sdt.table_type,
9900 : : (void *)p_temp_acl_tbl);
9901 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_set_callback");
9902 : : }
9903 : :
9904 : 0 : return rc;
9905 : : }
9906 : :
9907 : : static void
9908 : : zxdh_np_apt_stat_res_init(uint32_t dev_id, uint32_t type, ZXDH_APT_STAT_RES_INIT_T *stat_res_init)
9909 : : {
9910 : 0 : g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].eram_baddr = stat_res_init->eram_baddr;
9911 : 0 : g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].eram_depth = stat_res_init->eram_depth;
9912 : :
9913 [ # # ]: 0 : if (type == ZXDH_SE_NON_STD_NIC_RES_TYPE) {
9914 : 0 : g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].ddr_base_addr = stat_res_init->ddr_baddr;
9915 : 0 : g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].ppu_addr_offset =
9916 : 0 : stat_res_init->ppu_ddr_offset;
9917 : : }
9918 : : }
9919 : :
9920 : : static uint32_t
9921 [ # # ]: 0 : zxdh_np_se_res_init(uint32_t dev_id, uint32_t type)
9922 : : {
9923 : : uint32_t rc = ZXDH_OK;
9924 : : ZXDH_APT_SE_RES_T *p_se_res = NULL;
9925 : : ZXDH_APT_HASH_RES_INIT_T hash_res_init = {0};
9926 : : ZXDH_APT_ERAM_RES_INIT_T eram_res_init = {0};
9927 : : ZXDH_APT_ACL_RES_INIT_T acl_res_init = {0};
9928 : :
9929 : : p_se_res = (ZXDH_APT_SE_RES_T *)zxdh_np_dev_get_se_res_ptr(dev_id, type);
9930 [ # # ]: 0 : if (!p_se_res->valid) {
9931 : 0 : PMD_DRV_LOG(ERR, "dev_id[0x%x],se_type[0x%x] invalid!", dev_id, type);
9932 : 0 : return ZXDH_ERR;
9933 : : }
9934 : :
9935 : 0 : hash_res_init.func_num = p_se_res->hash_func_num;
9936 : 0 : hash_res_init.bulk_num = p_se_res->hash_bulk_num;
9937 : 0 : hash_res_init.tbl_num = p_se_res->hash_tbl_num;
9938 : 0 : hash_res_init.func_res = p_se_res->hash_func;
9939 : 0 : hash_res_init.bulk_res = p_se_res->hash_bulk;
9940 : 0 : hash_res_init.tbl_res = p_se_res->hash_tbl;
9941 : 0 : eram_res_init.tbl_num = p_se_res->eram_num;
9942 : 0 : eram_res_init.eram_res = p_se_res->eram_tbl;
9943 : 0 : acl_res_init.tbl_num = p_se_res->acl_num;
9944 : 0 : acl_res_init.acl_res = p_se_res->acl_tbl;
9945 : :
9946 : 0 : rc = zxdh_np_apt_hash_global_res_init(dev_id);
9947 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_global_res_init");
9948 : :
9949 [ # # ]: 0 : if (hash_res_init.func_num) {
9950 : 0 : rc = zxdh_np_apt_hash_func_res_init(dev_id, hash_res_init.func_num,
9951 : : hash_res_init.func_res);
9952 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_func_res_init");
9953 : : }
9954 : :
9955 [ # # ]: 0 : if (hash_res_init.bulk_num) {
9956 : 0 : rc = zxdh_np_apt_hash_bulk_res_init(dev_id, hash_res_init.bulk_num,
9957 : : hash_res_init.bulk_res);
9958 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_bulk_res_init");
9959 : : }
9960 : :
9961 [ # # ]: 0 : if (hash_res_init.tbl_num) {
9962 : 0 : rc = zxdh_np_apt_hash_tbl_res_init(dev_id, hash_res_init.tbl_num,
9963 : : hash_res_init.tbl_res);
9964 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_tbl_res_init");
9965 : : }
9966 : :
9967 [ # # ]: 0 : if (eram_res_init.tbl_num) {
9968 : 0 : rc = zxdh_np_apt_eram_res_init(dev_id, eram_res_init.tbl_num,
9969 : : eram_res_init.eram_res);
9970 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_eram_res_init");
9971 : : }
9972 : :
9973 [ # # ]: 0 : if (acl_res_init.tbl_num) {
9974 : 0 : rc = zxdh_np_apt_acl_res_init(dev_id, acl_res_init.tbl_num,
9975 : : acl_res_init.acl_res);
9976 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_acl_res_init");
9977 : : }
9978 : :
9979 : : zxdh_np_apt_stat_res_init(dev_id, type, &p_se_res->stat_cfg);
9980 : :
9981 : : return rc;
9982 : : }
9983 : :
9984 : : uint32_t
9985 : 0 : zxdh_np_se_res_get_and_init(uint32_t dev_id, uint32_t type)
9986 : : {
9987 : : uint32_t rc = ZXDH_OK;
9988 : :
9989 : 0 : rc = zxdh_np_agent_se_res_get(dev_id, type);
9990 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_se_res_get");
9991 : 0 : PMD_DRV_LOG(DEBUG, "se res get success.");
9992 : :
9993 : 0 : rc = zxdh_np_se_res_init(dev_id, type);
9994 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_res_init");
9995 : 0 : PMD_DRV_LOG(DEBUG, "se res init success.");
9996 : :
9997 : 0 : return rc;
9998 : : }
9999 : :
10000 : : static uint32_t
10001 : 0 : zxdh_np_dtb_hash_zcam_del_one_hw(uint32_t dev_id,
10002 : : uint32_t queue_id,
10003 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
10004 : : ZXDH_HASH_ENTRY *p_hash_entry,
10005 : : ZXDH_DTB_ENTRY_T *p_entry,
10006 : : uint8_t *p_srh_succ)
10007 : : {
10008 : : uint32_t rc = ZXDH_OK;
10009 : 0 : ZXDH_HASH_RBKEY_INFO srh_rbkey = {0};
10010 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10011 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
10012 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
10013 : :
10014 : : uint32_t zblk_idx = 0;
10015 : : uint32_t pre_zblk_idx = 0xFFFFFFFF;
10016 : : uint16_t crc16_value = 0;
10017 : : uint32_t zcell_id = 0;
10018 : : uint32_t item_idx = 0;
10019 : 0 : uint32_t element_id = 0;
10020 : 0 : uint32_t byte_offset = 0;
10021 : : uint32_t addr = 0;
10022 : : uint32_t i = 0;
10023 : : uint8_t srh_succ = 0;
10024 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
10025 : 0 : uint8_t rd_buff[ZXDH_SE_ITEM_WIDTH_MAX] = {0};
10026 : :
10027 : : ZXDH_D_NODE *p_zblk_dn = NULL;
10028 : : ZXDH_D_NODE *p_zcell_dn = NULL;
10029 : : ZXDH_SE_CFG *p_se_cfg = NULL;
10030 : :
10031 [ # # ]: 0 : memcpy(srh_rbkey.key, p_hash_entry->p_key, p_hash_entry_cfg->key_by_size);
10032 : :
10033 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
10034 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
10035 : :
10036 : 0 : p_se_cfg = p_hash_entry_cfg->p_se_cfg;
10037 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
10038 : :
10039 : 0 : zxdh_np_hash_set_crc_key(p_hash_entry_cfg, p_hash_entry, temp_key);
10040 : :
10041 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
10042 : :
10043 [ # # ]: 0 : while (p_zcell_dn) {
10044 : 0 : p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
10045 : 0 : zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
10046 : : p_zblk = &p_se_cfg->zblk_info[zblk_idx];
10047 : :
10048 [ # # ]: 0 : if (zblk_idx != pre_zblk_idx) {
10049 : : pre_zblk_idx = zblk_idx;
10050 : 0 : crc16_value = p_hash_cfg->p_hash16_fun(temp_key,
10051 : 0 : p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
10052 : : }
10053 : :
10054 : 0 : zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
10055 : 0 : item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc16_value);
10056 : 0 : addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
10057 : :
10058 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
10059 : : queue_id,
10060 : : addr,
10061 : : ZXDH_DTB_DUMP_ZCAM_512b,
10062 : : 1,
10063 : : (uint32_t *)rd_buff,
10064 : : &element_id);
10065 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
10066 : :
10067 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
10068 : :
10069 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM, p_hash_entry_cfg->key_by_size,
10070 : : p_hash_entry, rd_buff, &byte_offset);
10071 [ # # ]: 0 : if (rc == ZXDH_OK) {
10072 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zcell.");
10073 : : srh_succ = 1;
10074 : 0 : p_hash_cfg->hash_stat.search_ok++;
10075 : 0 : break;
10076 : : }
10077 : :
10078 : 0 : p_zcell_dn = p_zcell_dn->next;
10079 : : }
10080 : :
10081 [ # # ]: 0 : if (srh_succ == 0) {
10082 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
10083 [ # # ]: 0 : while (p_zblk_dn) {
10084 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
10085 : 0 : zblk_idx = p_zblk->zblk_idx;
10086 : :
10087 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
10088 : : item_idx = i;
10089 : 0 : addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx, item_idx);
10090 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
10091 : : queue_id,
10092 : : addr,
10093 : : ZXDH_DTB_DUMP_ZCAM_512b,
10094 : : 1,
10095 : : (uint32_t *)rd_buff,
10096 : : &element_id);
10097 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
10098 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
10099 : :
10100 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM,
10101 : : p_hash_entry_cfg->key_by_size, p_hash_entry,
10102 : : rd_buff, &byte_offset);
10103 [ # # ]: 0 : if (rc == ZXDH_OK) {
10104 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zreg.");
10105 : : srh_succ = 1;
10106 : 0 : p_hash_cfg->hash_stat.search_ok++;
10107 : 0 : break;
10108 : : }
10109 : : }
10110 : 0 : p_zblk_dn = p_zblk_dn->next;
10111 : : }
10112 : : }
10113 : :
10114 [ # # ]: 0 : if (srh_succ) {
10115 : 0 : memset(rd_buff + byte_offset, 0,
10116 [ # # ]: 0 : ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type));
10117 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
10118 : 0 : rc = zxdh_np_dtb_se_alg_zcam_data_write(dev_id,
10119 : : addr,
10120 : : rd_buff,
10121 : : p_entry);
10122 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_alg_zcam_data_write");
10123 : 0 : p_hash_cfg->hash_stat.delete_ok++;
10124 : : }
10125 : :
10126 : 0 : *p_srh_succ = srh_succ;
10127 : :
10128 : 0 : return rc;
10129 : : }
10130 : :
10131 : : static uint32_t
10132 : 0 : zxdh_np_dtb_hash_zcam_del_hw(uint32_t dev_id,
10133 : : uint32_t queue_id,
10134 : : uint32_t sdt_no,
10135 : : uint32_t entry_num,
10136 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_arr_hash_entry,
10137 : : uint32_t *element_id)
10138 : : {
10139 : : uint32_t rc = ZXDH_OK;
10140 : : uint32_t item_cnt = 0;
10141 : : uint32_t key_valid = 1;
10142 : : uint32_t dtb_len = 0;
10143 : 0 : uint8_t srh_succ = 0;
10144 : 0 : uint8_t key[ZXDH_HASH_KEY_MAX] = {0};
10145 : 0 : uint8_t rst[ZXDH_HASH_RST_MAX] = {0};
10146 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
10147 : :
10148 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
10149 : : uint8_t *p_data_buff = NULL;
10150 : :
10151 : : ZXDH_HASH_ENTRY entry = {0};
10152 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
10153 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
10154 : :
10155 : 0 : dtb_one_entry.cmd = entry_cmd;
10156 : 0 : dtb_one_entry.data = entry_data;
10157 : 0 : entry.p_key = key;
10158 : 0 : entry.p_rst = rst;
10159 : :
10160 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
10161 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
10162 : :
10163 : 0 : p_data_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
10164 [ # # ]: 0 : if (p_data_buff == NULL) {
10165 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10166 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10167 : : }
10168 : :
10169 [ # # ]: 0 : for (item_cnt = 0; item_cnt < entry_num; ++item_cnt) {
10170 : 0 : srh_succ = 0;
10171 : : memset(key, 0, sizeof(key));
10172 : : memset(rst, 0, sizeof(rst));
10173 : : memset(entry_cmd, 0, sizeof(entry_cmd));
10174 : : memset(entry_data, 0, sizeof(entry_data));
10175 : 0 : entry.p_key[0] = (uint8_t)(((key_valid & 0x1) << 7)
10176 : 0 : | ((hash_entry_cfg.key_type & 0x3) << 5)
10177 : 0 : | (hash_entry_cfg.table_id & 0x1f));
10178 : 0 : memcpy(&entry.p_key[1], p_arr_hash_entry[item_cnt].p_actu_key,
10179 : 0 : hash_entry_cfg.actu_key_size);
10180 : :
10181 : 0 : rc = zxdh_np_dtb_hash_zcam_del_one_hw(dev_id,
10182 : : queue_id,
10183 : : &hash_entry_cfg,
10184 : : &entry,
10185 : : &dtb_one_entry,
10186 : : &srh_succ);
10187 : :
10188 [ # # ]: 0 : if (srh_succ) {
10189 : 0 : zxdh_np_dtb_data_write(p_data_buff, 0, &dtb_one_entry);
10190 : 0 : dtb_len = dtb_one_entry.data_size / ZXDH_DTB_LEN_POS_SETP + 1;
10191 : 0 : zxdh_np_dtb_write_down_table_data(dev_id, queue_id,
10192 : : dtb_len * ZXDH_DTB_LEN_POS_SETP, p_data_buff, element_id);
10193 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id,
10194 : : queue_id, *element_id);
10195 : : }
10196 : : }
10197 : :
10198 : 0 : rte_free(p_data_buff);
10199 : :
10200 : 0 : return rc;
10201 : : }
10202 : :
10203 : : static uint32_t
10204 : 0 : zxdh_np_dtb_sdt_hash_zcam_mono_space_dump(uint32_t dev_id,
10205 : : uint32_t queue_id,
10206 : : uint32_t sdt_no,
10207 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
10208 : : uint8_t *p_data,
10209 : : uint32_t *p_dump_len)
10210 : : {
10211 : : uint32_t rc = ZXDH_OK;
10212 : :
10213 : : uint32_t i = 0;
10214 : : uint32_t zblock_id = 0;
10215 : : uint32_t zcell_id = 0;
10216 : : uint32_t start_addr = 0;
10217 : : uint32_t dtb_desc_len = 0;
10218 : : uint32_t dump_pa_h = 0;
10219 : : uint32_t dump_pa_l = 0;
10220 : : uint32_t dma_addr_offset = 0;
10221 : : uint32_t desc_addr_offset = 0;
10222 : 0 : uint32_t element_id = 0;
10223 : : uint8_t *p_dump_desc_buf = NULL;
10224 : :
10225 : : ZXDH_D_NODE *p_zblk_dn = NULL;
10226 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
10227 : : ZXDH_SE_ZREG_CFG *p_zreg = NULL;
10228 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
10229 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10230 : :
10231 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
10232 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
10233 : :
10234 : 0 : rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &element_id);
10235 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
10236 : :
10237 : 0 : p_dump_desc_buf = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
10238 [ # # ]: 0 : if (p_dump_desc_buf == NULL) {
10239 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10240 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10241 : : }
10242 : 0 : dtb_dump_entry.cmd = cmd_buff;
10243 : :
10244 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
10245 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
10246 : :
10247 [ # # ]: 0 : while (p_zblk_dn) {
10248 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
10249 : 0 : zblock_id = p_zblk->zblk_idx;
10250 : :
10251 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZCELL_NUM; i++) {
10252 : : p_zcell = &p_zblk->zcell_info[i];
10253 : :
10254 [ # # ]: 0 : if ((p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO) &&
10255 [ # # ]: 0 : p_zcell->bulk_id == p_hash_entry_cfg->bulk_id) {
10256 : 0 : zcell_id = p_zcell->zcell_idx;
10257 : :
10258 : 0 : start_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_id, 0);
10259 : :
10260 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10261 : : queue_id,
10262 : : element_id,
10263 : : dma_addr_offset,
10264 : : &dump_pa_h,
10265 : : &dump_pa_l);
10266 : :
10267 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
10268 : : ZXDH_DTB_DUMP_ZCAM_512b, ZXDH_SE_RAM_DEPTH,
10269 : : dump_pa_h, dump_pa_l, &dtb_dump_entry);
10270 : :
10271 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset,
10272 : : &dtb_dump_entry);
10273 : :
10274 : 0 : dtb_desc_len++;
10275 : 0 : dma_addr_offset += ZXDH_SE_RAM_DEPTH * 512 / 8;
10276 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10277 : :
10278 : 0 : PMD_DRV_LOG(DEBUG, "the Zblock[%u]'s bulk_id:%u Mono Zcell_id :%u",
10279 : : zblock_id, p_hash_entry_cfg->bulk_id, zcell_id);
10280 : : }
10281 : : }
10282 : :
10283 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
10284 : : p_zreg = &p_zblk->zreg_info[i];
10285 : :
10286 [ # # ]: 0 : if ((p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO) &&
10287 [ # # ]: 0 : p_zreg->bulk_id == p_hash_entry_cfg->bulk_id) {
10288 : 0 : start_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblock_id, i);
10289 : :
10290 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10291 : : queue_id,
10292 : : element_id,
10293 : : dma_addr_offset,
10294 : : &dump_pa_h,
10295 : : &dump_pa_l);
10296 : :
10297 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
10298 : : ZXDH_DTB_DUMP_ZCAM_512b, 1, dump_pa_h, dump_pa_l, &dtb_dump_entry);
10299 : :
10300 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset,
10301 : : &dtb_dump_entry);
10302 : :
10303 : 0 : dtb_desc_len++;
10304 : 0 : dma_addr_offset += 512 / 8;
10305 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10306 : :
10307 : 0 : PMD_DRV_LOG(DEBUG, "the Zblock[%u]'s bulk_id:%u Mono Zreg_id :%u",
10308 : : zblock_id, p_zreg->bulk_id, i);
10309 : : }
10310 : : }
10311 : :
10312 : 0 : p_zblk_dn = p_zblk_dn->next;
10313 : : }
10314 : :
10315 : 0 : zxdh_np_dtb_write_dump_desc_info(dev_id,
10316 : : queue_id,
10317 : : element_id,
10318 : : (uint32_t *)p_dump_desc_buf,
10319 : : dma_addr_offset / 4,
10320 : : dtb_desc_len * 4,
10321 : : (uint32_t *)p_data);
10322 : :
10323 : 0 : zxdh_np_comm_swap(p_data, dma_addr_offset);
10324 : 0 : rte_free(p_dump_desc_buf);
10325 : :
10326 : 0 : *p_dump_len = dma_addr_offset;
10327 : :
10328 : 0 : return rc;
10329 : : }
10330 : :
10331 : : static uint32_t
10332 : 0 : zxdh_np_dtb_hash_table_zcam_dump(uint32_t dev_id,
10333 : : uint32_t queue_id,
10334 : : uint32_t sdt_no,
10335 : : uint32_t zblock_num,
10336 : : uint32_t zblock_array[ZXDH_SE_ZBLK_NUM],
10337 : : uint8_t *p_data,
10338 : : uint32_t *p_dump_len)
10339 : : {
10340 : : uint32_t rc = ZXDH_OK;
10341 : : uint32_t zblk_idx = 0;
10342 : : uint32_t index = 0;
10343 : : uint32_t zblock_id = 0;
10344 : : uint32_t zcell_id = 0;
10345 : : uint32_t start_addr = 0;
10346 : : uint32_t dtb_desc_len = 0;
10347 : : uint32_t dump_pa_h = 0;
10348 : : uint32_t dump_pa_l = 0;
10349 : : uint32_t dma_addr_offset = 0;
10350 : : uint32_t desc_addr_offset = 0;
10351 : 0 : uint32_t element_id = 0;
10352 : : uint8_t *p_dump_desc_buf = NULL;
10353 : :
10354 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
10355 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
10356 : :
10357 : 0 : rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &element_id);
10358 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
10359 : :
10360 : 0 : p_dump_desc_buf = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
10361 [ # # ]: 0 : if (p_dump_desc_buf == NULL) {
10362 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10363 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10364 : : }
10365 : :
10366 : 0 : dtb_dump_entry.cmd = cmd_buff;
10367 [ # # ]: 0 : for (zblk_idx = 0; zblk_idx < zblock_num; zblk_idx++) {
10368 : 0 : zblock_id = zblock_array[zblk_idx];
10369 [ # # ]: 0 : for (index = 0; index < ZXDH_SE_ZCELL_NUM; index++) {
10370 : 0 : zcell_id = zblock_id * ZXDH_SE_ZCELL_NUM + index;
10371 : 0 : start_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_id, 0);
10372 : :
10373 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10374 : : queue_id,
10375 : : element_id,
10376 : : dma_addr_offset,
10377 : : &dump_pa_h,
10378 : : &dump_pa_l);
10379 : :
10380 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
10381 : : ZXDH_DTB_DUMP_ZCAM_512b, ZXDH_SE_RAM_DEPTH,
10382 : : dump_pa_h, dump_pa_l, &dtb_dump_entry);
10383 : :
10384 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf,
10385 : : desc_addr_offset, &dtb_dump_entry);
10386 : :
10387 : 0 : dtb_desc_len++;
10388 : 0 : dma_addr_offset += ZXDH_SE_RAM_DEPTH * 512 / 8;
10389 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10390 : : }
10391 : :
10392 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10393 : : queue_id,
10394 : : element_id,
10395 : : dma_addr_offset,
10396 : : &dump_pa_h,
10397 : : &dump_pa_l);
10398 : :
10399 : 0 : start_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblock_id, 0);
10400 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr, ZXDH_DTB_DUMP_ZCAM_512b,
10401 : : ZXDH_SE_ZREG_NUM, dump_pa_h, dump_pa_l, &dtb_dump_entry);
10402 : :
10403 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset, &dtb_dump_entry);
10404 : :
10405 : 0 : dtb_desc_len++;
10406 : 0 : dma_addr_offset += ZXDH_SE_ZREG_NUM * 512 / 8;
10407 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10408 : : }
10409 : :
10410 : 0 : zxdh_np_dtb_write_dump_desc_info(dev_id,
10411 : : queue_id,
10412 : : element_id,
10413 : : (uint32_t *)p_dump_desc_buf,
10414 : : dma_addr_offset / 4,
10415 : : dtb_desc_len * 4,
10416 : : (uint32_t *)p_data);
10417 : :
10418 : 0 : zxdh_np_comm_swap(p_data, dma_addr_offset);
10419 : 0 : rte_free(p_dump_desc_buf);
10420 : :
10421 : 0 : *p_dump_len = dma_addr_offset;
10422 : :
10423 : 0 : return rc;
10424 : : }
10425 : :
10426 : : static void
10427 : 0 : zxdh_np_dtb_dump_hash_parse(HASH_ENTRY_CFG *p_hash_entry_cfg,
10428 : : uint32_t item_type,
10429 : : uint8_t *pdata,
10430 : : uint32_t dump_len,
10431 : : uint8_t *p_outdata,
10432 : : uint32_t *p_item_num)
10433 : : {
10434 : : uint32_t item_num = 0;
10435 : : uint32_t data_offset = 0;
10436 : : uint32_t index = 0;
10437 : : uint8_t temp_key_valid = 0;
10438 : : uint8_t temp_key_type = 0;
10439 : : uint8_t temp_tbl_id = 0;
10440 : : uint32_t srh_entry_size = 0;
10441 : : uint32_t item_width = ZXDH_SE_ITEM_WIDTH_MAX;
10442 : : uint8_t *p_temp_key = NULL;
10443 : : uint8_t *p_hash_item = NULL;
10444 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry = NULL;
10445 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_temp_entry = NULL;
10446 : :
10447 [ # # ]: 0 : if (item_type == ZXDH_ITEM_DDR_256)
10448 : : item_width = item_width / 2;
10449 : :
10450 : : p_dtb_hash_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_outdata;
10451 [ # # ]: 0 : srh_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type);
10452 : :
10453 [ # # ]: 0 : for (index = 0; index < (dump_len / item_width); index++) {
10454 : : data_offset = 0;
10455 : 0 : p_hash_item = pdata + index * item_width;
10456 [ # # ]: 0 : while (data_offset < item_width) {
10457 : 0 : p_temp_key = p_hash_item + data_offset;
10458 : 0 : temp_key_valid = ZXDH_GET_HASH_KEY_VALID(p_temp_key);
10459 : 0 : temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_temp_key);
10460 : 0 : temp_tbl_id = ZXDH_GET_HASH_TBL_ID(p_temp_key);
10461 : 0 : p_temp_entry = p_dtb_hash_entry + item_num;
10462 : :
10463 [ # # # # ]: 0 : if (temp_key_valid && temp_key_type == p_hash_entry_cfg->key_type &&
10464 [ # # ]: 0 : temp_tbl_id == p_hash_entry_cfg->table_id) {
10465 : 0 : memcpy(p_temp_entry->p_actu_key, p_temp_key + 1,
10466 : 0 : p_hash_entry_cfg->actu_key_size);
10467 : 0 : memcpy(p_temp_entry->p_rst,
10468 : 0 : p_temp_key + p_hash_entry_cfg->key_by_size,
10469 : 0 : p_hash_entry_cfg->rst_by_size);
10470 : 0 : item_num++;
10471 : : }
10472 : :
10473 : 0 : data_offset += srh_entry_size;
10474 : : }
10475 : : }
10476 : :
10477 : 0 : *p_item_num = item_num;
10478 : 0 : }
10479 : :
10480 : : static uint32_t
10481 : 0 : zxdh_np_dtb_hash_table_dump(uint32_t dev_id,
10482 : : uint32_t queue_id,
10483 : : uint32_t sdt_no,
10484 : : ZXDH_DTB_DUMP_INDEX_T start_index,
10485 : : uint8_t *p_dump_data,
10486 : : uint32_t *p_entry_num,
10487 : : ZXDH_DTB_DUMP_INDEX_T *next_start_index,
10488 : : uint32_t *finish_flag)
10489 : : {
10490 : : uint32_t rc = ZXDH_OK;
10491 : : uint8_t *p_data = NULL;
10492 : 0 : uint32_t data_len = 0;
10493 : 0 : uint32_t entry_num = 0;
10494 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10495 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
10496 : :
10497 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
10498 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
10499 : :
10500 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
10501 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
10502 : :
10503 : 0 : p_data = rte_zmalloc(NULL, ZXDH_DTB_DMUP_DATA_MAX, 0);
10504 [ # # ]: 0 : if (p_data == NULL) {
10505 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10506 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10507 : : }
10508 : :
10509 [ # # ]: 0 : if (start_index.index_type == ZXDH_DTB_DUMP_ZCAM_TYPE) {
10510 [ # # ]: 0 : if (p_hash_cfg->bulk_ram_mono[hash_entry_cfg.bulk_id]) {
10511 : 0 : rc = zxdh_np_dtb_sdt_hash_zcam_mono_space_dump(dev_id,
10512 : : queue_id,
10513 : : sdt_no,
10514 : : &hash_entry_cfg,
10515 : : p_data,
10516 : : &data_len);
10517 : : } else {
10518 : 0 : rc = zxdh_np_dtb_hash_table_zcam_dump(dev_id,
10519 : : queue_id,
10520 : : sdt_no,
10521 : : p_hash_cfg->hash_stat.zblock_num,
10522 : 0 : p_hash_cfg->hash_stat.zblock_array,
10523 : : p_data,
10524 : : &data_len);
10525 : : }
10526 : :
10527 : 0 : zxdh_np_dtb_dump_hash_parse(&hash_entry_cfg,
10528 : : ZXDH_ITEM_RAM,
10529 : : p_data,
10530 : : data_len,
10531 : : p_dump_data,
10532 : : &entry_num);
10533 : :
10534 [ # # ]: 0 : if (p_hash_cfg->ddr_valid) {
10535 : 0 : next_start_index->index = 0;
10536 : 0 : next_start_index->index_type = ZXDH_DTB_DUMP_DDR_TYPE;
10537 : : } else {
10538 : 0 : *finish_flag = 1;
10539 : : }
10540 : 0 : *p_entry_num = entry_num;
10541 : : }
10542 : :
10543 : 0 : rte_free(p_data);
10544 : 0 : return rc;
10545 : : }
10546 : :
10547 : : static uint32_t
10548 : 0 : zxdh_np_dtb_hash_offline_zcam_delete(uint32_t dev_id,
10549 : : uint32_t queue_id,
10550 : : uint32_t sdt_no)
10551 : : {
10552 : : uint32_t rc = ZXDH_OK;
10553 : 0 : uint32_t entry_num = 0;
10554 : 0 : uint32_t finish_flag = 0;
10555 : : uint32_t index = 0;
10556 : : uint32_t max_item_num = 1024 * 1024;
10557 : : uint8_t *p_dump_data = NULL;
10558 : : uint8_t *p_key = NULL;
10559 : : uint8_t *p_rst = NULL;
10560 : 0 : uint32_t element_id = 0;
10561 : :
10562 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry = NULL;
10563 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_temp_entry = NULL;
10564 : 0 : ZXDH_DTB_DUMP_INDEX_T start_index = {0};
10565 : 0 : ZXDH_DTB_DUMP_INDEX_T next_start_index = {0};
10566 : :
10567 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash = {0};
10568 : : start_index.index = 0;
10569 : : start_index.index_type = ZXDH_DTB_DUMP_ZCAM_TYPE;
10570 : :
10571 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
10572 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash);
10573 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
10574 : :
10575 : 0 : p_dump_data = rte_zmalloc(NULL, max_item_num * sizeof(ZXDH_DTB_HASH_ENTRY_INFO_T), 0);
10576 [ # # ]: 0 : if (p_dump_data == NULL) {
10577 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10578 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10579 : : }
10580 : 0 : p_key = rte_zmalloc(NULL, max_item_num * ZXDH_HASH_KEY_MAX, 0);
10581 [ # # ]: 0 : if (p_key == NULL) {
10582 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10583 : 0 : rte_free(p_dump_data);
10584 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10585 : : }
10586 : 0 : p_rst = rte_zmalloc(NULL, max_item_num * ZXDH_HASH_RST_MAX, 0);
10587 : : if (p_key == NULL) {
10588 : : PMD_DRV_LOG(ERR, "malloc memory failed");
10589 : : rte_free(p_dump_data);
10590 : : rte_free(p_key);
10591 : : return ZXDH_PAR_CHK_POINT_NULL;
10592 : : }
10593 : :
10594 : : p_dtb_hash_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_dump_data;
10595 [ # # ]: 0 : for (index = 0; index < max_item_num; index++) {
10596 : 0 : p_temp_entry = p_dtb_hash_entry + index;
10597 : 0 : p_temp_entry->p_actu_key = p_key + index * ZXDH_HASH_KEY_MAX;
10598 : 0 : p_temp_entry->p_rst = p_rst + index * ZXDH_HASH_RST_MAX;
10599 : : }
10600 : :
10601 : 0 : rc = zxdh_np_dtb_hash_table_dump(dev_id, queue_id, sdt_no, start_index,
10602 : : p_dump_data, &entry_num, &next_start_index, &finish_flag);
10603 : :
10604 [ # # ]: 0 : if (entry_num) {
10605 : 0 : rc = zxdh_np_dtb_hash_zcam_del_hw(dev_id, queue_id, sdt_no,
10606 : : entry_num, p_dtb_hash_entry, &element_id);
10607 : : }
10608 : :
10609 : 0 : rte_free(p_dtb_hash_entry);
10610 : 0 : rte_free(p_key);
10611 : 0 : rte_free(p_rst);
10612 : :
10613 : 0 : return rc;
10614 : : }
10615 : :
10616 : : uint32_t
10617 : 0 : zxdh_np_dtb_hash_online_delete(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no)
10618 : : {
10619 : : uint32_t rc = 0;
10620 : : uint8_t key_valid = 0;
10621 : : uint32_t table_id = 0;
10622 : : uint32_t key_type = 0;
10623 : :
10624 : : ZXDH_D_NODE *p_node = NULL;
10625 : : ZXDH_RB_TN *p_rb_tn = NULL;
10626 : : ZXDH_D_HEAD *p_head_hash_rb = NULL;
10627 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10628 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
10629 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
10630 : 0 : ZXDH_DTB_USER_ENTRY_T del_entry = {0};
10631 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T hash_entry = {0};
10632 : :
10633 : 0 : del_entry.sdt_no = sdt_no;
10634 : 0 : del_entry.p_entry_data = &hash_entry;
10635 : :
10636 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
10637 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
10638 : :
10639 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
10640 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
10641 : :
10642 : : p_head_hash_rb = &p_hash_cfg->hash_rb.tn_list;
10643 : 0 : p_node = p_head_hash_rb->p_next;
10644 [ # # ]: 0 : while (p_node) {
10645 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
10646 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn);
10647 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_rb_tn->p_key;
10648 : 0 : hash_entry.p_actu_key = p_rbkey->key + 1;
10649 : 0 : hash_entry.p_rst = p_rbkey->key;
10650 : :
10651 : 0 : key_valid = ZXDH_GET_HASH_KEY_VALID(p_rbkey->key);
10652 : : table_id = ZXDH_GET_HASH_TBL_ID(p_rbkey->key);
10653 : 0 : key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
10654 [ # # ]: 0 : if (!key_valid ||
10655 [ # # ]: 0 : table_id != hash_entry_cfg.table_id ||
10656 [ # # ]: 0 : key_type != hash_entry_cfg.key_type) {
10657 : 0 : p_node = p_node->next;
10658 : 0 : continue;
10659 : : }
10660 : 0 : p_node = p_node->next;
10661 : :
10662 : 0 : rc = zxdh_np_dtb_table_entry_delete(dev_id, queue_id, 1, &del_entry);
10663 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
10664 : 0 : continue;
10665 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_table_entry_delete");
10666 : : }
10667 : :
10668 : 0 : return rc;
10669 : : }
10670 : :
10671 : : uint32_t
10672 : 0 : zxdh_np_dtb_hash_offline_delete(uint32_t dev_id,
10673 : : uint32_t queue_id,
10674 : : uint32_t sdt_no,
10675 : : __rte_unused uint32_t flush_mode)
10676 : : {
10677 : : uint32_t rc = ZXDH_OK;
10678 : :
10679 : 0 : rc = zxdh_np_dtb_hash_offline_zcam_delete(dev_id, queue_id, sdt_no);
10680 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_offline_zcam_delete");
10681 : :
10682 : 0 : return rc;
10683 : : }
10684 : :
10685 : : static uint32_t
10686 : 0 : zxdh_np_se_done_status_check(uint32_t dev_id, uint32_t reg_no, uint32_t pos)
10687 : : {
10688 : : uint32_t rc = 0;
10689 : :
10690 : 0 : uint32_t data = 0;
10691 : : uint32_t rd_cnt = 0;
10692 : : uint32_t done_flag = 0;
10693 : :
10694 : 0 : while (!done_flag) {
10695 : 0 : rc = zxdh_np_reg_read32(dev_id, reg_no, 0, 0, &data);
10696 [ # # ]: 0 : if (rc != 0) {
10697 : 0 : PMD_DRV_LOG(ERR, "reg_read32 fail!");
10698 : 0 : return rc;
10699 : : }
10700 : :
10701 : 0 : done_flag = (data >> pos) & 0x1;
10702 : :
10703 [ # # ]: 0 : if (done_flag)
10704 : : break;
10705 : :
10706 [ # # ]: 0 : if (rd_cnt > ZXDH_RD_CNT_MAX * ZXDH_RD_CNT_MAX)
10707 : : return -1;
10708 : :
10709 : 0 : rd_cnt++;
10710 : : }
10711 : :
10712 : : return rc;
10713 : : }
10714 : :
10715 : : static uint32_t
10716 : 0 : zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
10717 : : uint32_t base_addr,
10718 : : uint32_t index,
10719 : : uint32_t rd_mode,
10720 : : uint32_t rd_clr_mode,
10721 : : uint32_t *p_data)
10722 : : {
10723 : : uint32_t rc = ZXDH_OK;
10724 : : uint32_t i = 0;
10725 : : uint32_t row_index = 0;
10726 : : uint32_t col_index = 0;
10727 : 0 : uint32_t temp_data[4] = {0};
10728 : : uint32_t *p_temp_data = NULL;
10729 : 0 : ZXDH_SMMU0_SMMU0_CPU_IND_CMD_T cpu_ind_cmd = {0};
10730 : 0 : ZXDH_SPINLOCK_T *p_ind_spinlock = NULL;
10731 : :
10732 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_SMMU0, &p_ind_spinlock);
10733 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
10734 : :
10735 : 0 : rte_spinlock_lock(&p_ind_spinlock->spinlock);
10736 : :
10737 : 0 : rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_WR_ARB_CPU_RDYR, 0);
10738 [ # # ]: 0 : if (rc != ZXDH_OK) {
10739 : 0 : PMD_DRV_LOG(ERR, "se done status check failed, rc=0x%x.", rc);
10740 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10741 : 0 : return ZXDH_ERR;
10742 : : }
10743 : :
10744 [ # # ]: 0 : if (rd_clr_mode == ZXDH_RD_MODE_HOLD) {
10745 : 0 : cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD;
10746 : 0 : cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_HOLD;
10747 : 0 : cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b;
10748 : :
10749 [ # # # # : 0 : switch (rd_mode) {
# ]
10750 : 0 : case ZXDH_ERAM128_OPR_128b:
10751 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
10752 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10753 : 0 : PMD_DRV_LOG(ERR, "index 0x%x is invalid!", index);
10754 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
10755 : : }
10756 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10757 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10758 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10759 : 0 : return ZXDH_ERR;
10760 : : }
10761 : 0 : row_index = (index << 7) & ZXDH_ERAM128_BADDR_MASK;
10762 : 0 : break;
10763 : 0 : case ZXDH_ERAM128_OPR_64b:
10764 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10765 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10766 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10767 : 0 : return ZXDH_ERR;
10768 : : }
10769 : 0 : row_index = (index << 6) & ZXDH_ERAM128_BADDR_MASK;
10770 : 0 : col_index = index & 0x1;
10771 : 0 : break;
10772 : 0 : case ZXDH_ERAM128_OPR_32b:
10773 [ # # ]: 0 : if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10774 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10775 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10776 : 0 : return ZXDH_ERR;
10777 : : }
10778 : 0 : row_index = (index << 5) & ZXDH_ERAM128_BADDR_MASK;
10779 : 0 : col_index = index & 0x3;
10780 : 0 : break;
10781 : 0 : case ZXDH_ERAM128_OPR_1b:
10782 [ # # ]: 0 : if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10783 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10784 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10785 : 0 : return ZXDH_ERR;
10786 : : }
10787 : 0 : row_index = index & ZXDH_ERAM128_BADDR_MASK;
10788 : 0 : col_index = index & 0x7F;
10789 : 0 : break;
10790 : : default:
10791 : : break;
10792 : : }
10793 : :
10794 : 0 : cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index;
10795 : : } else {
10796 : 0 : cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD;
10797 : 0 : cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_CLEAR;
10798 : :
10799 [ # # # # : 0 : switch (rd_mode) {
# ]
10800 : 0 : case ZXDH_ERAM128_OPR_128b:
10801 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
10802 : 0 : PMD_DRV_LOG(ERR, "index 0x%x is invalid!", index);
10803 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10804 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
10805 : : }
10806 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10807 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10808 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10809 : 0 : return ZXDH_ERR;
10810 : : }
10811 : 0 : row_index = (index << 7);
10812 : 0 : cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b;
10813 : 0 : break;
10814 : 0 : case ZXDH_ERAM128_OPR_64b:
10815 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10816 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10817 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10818 : 0 : return ZXDH_ERR;
10819 : : }
10820 : 0 : row_index = (index << 6);
10821 : 0 : cpu_ind_cmd.cpu_req_mode = 2;
10822 : 0 : break;
10823 : 0 : case ZXDH_ERAM128_OPR_32b:
10824 [ # # ]: 0 : if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10825 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10826 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10827 : 0 : return ZXDH_ERR;
10828 : : }
10829 : 0 : row_index = (index << 5);
10830 : 0 : cpu_ind_cmd.cpu_req_mode = 1;
10831 : 0 : break;
10832 : 0 : case ZXDH_ERAM128_OPR_1b:
10833 : 0 : PMD_DRV_LOG(ERR, "rd_clr_mode[%u] or rd_mode[%u] error!",
10834 : : rd_clr_mode, rd_mode);
10835 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10836 : 0 : return ZXDH_ERR;
10837 : : default:
10838 : : break;
10839 : : }
10840 : 0 : cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index;
10841 : : }
10842 : :
10843 : 0 : rc = zxdh_np_reg_write(dev_id,
10844 : : ZXDH_SMMU0_SMMU0_CPU_IND_CMDR,
10845 : : 0,
10846 : : 0,
10847 : : &cpu_ind_cmd);
10848 [ # # ]: 0 : if (rc != ZXDH_OK) {
10849 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_reg_write failed, rc=0x%x.", rc);
10850 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10851 : 0 : return ZXDH_ERR;
10852 : : }
10853 : :
10854 : 0 : rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_CPU_IND_RD_DONER, 0);
10855 [ # # ]: 0 : if (rc != ZXDH_OK) {
10856 : 0 : PMD_DRV_LOG(ERR, "se done status check failed, rc=0x%x.", rc);
10857 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10858 : 0 : return ZXDH_ERR;
10859 : : }
10860 : :
10861 : : p_temp_data = temp_data;
10862 [ # # ]: 0 : for (i = 0; i < 4; i++) {
10863 : 0 : rc = zxdh_np_reg_read(dev_id,
10864 : : ZXDH_SMMU0_SMMU0_CPU_IND_RDAT0R + i,
10865 : : 0,
10866 : : 0,
10867 : 0 : p_temp_data + 3 - i);
10868 [ # # ]: 0 : if (rc != ZXDH_OK) {
10869 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_reg_write failed, rc=0x%x.", rc);
10870 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10871 : 0 : return ZXDH_ERR;
10872 : : }
10873 : : }
10874 : :
10875 [ # # ]: 0 : if (rd_clr_mode == ZXDH_RD_MODE_HOLD) {
10876 [ # # # # : 0 : switch (rd_mode) {
# ]
10877 : : case ZXDH_ERAM128_OPR_128b:
10878 : : memcpy(p_data, p_temp_data, (128 / 8));
10879 : : break;
10880 : 0 : case ZXDH_ERAM128_OPR_64b:
10881 : 0 : memcpy(p_data, p_temp_data + ((1 - col_index) << 1), (64 / 8));
10882 : : break;
10883 : 0 : case ZXDH_ERAM128_OPR_32b:
10884 : 0 : memcpy(p_data, p_temp_data + ((3 - col_index)), (32 / 8));
10885 : : break;
10886 : 0 : case ZXDH_ERAM128_OPR_1b:
10887 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0],
10888 : : *(p_temp_data + (3 - col_index / 32)), (col_index % 32), 1);
10889 : 0 : break;
10890 : : default:
10891 : : break;
10892 : : }
10893 : : } else {
10894 [ # # # # ]: 0 : switch (rd_mode) {
10895 : : case ZXDH_ERAM128_OPR_128b:
10896 : : memcpy(p_data, p_temp_data, (128 / 8));
10897 : : break;
10898 : : case ZXDH_ERAM128_OPR_64b:
10899 : : memcpy(p_data, p_temp_data, (64 / 8));
10900 : : break;
10901 : : case ZXDH_ERAM128_OPR_32b:
10902 : : memcpy(p_data, p_temp_data, (64 / 8));
10903 : : break;
10904 : : default:
10905 : : break;
10906 : : }
10907 : : }
10908 : :
10909 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10910 : :
10911 : 0 : return rc;
10912 : : }
10913 : :
10914 : : uint32_t
10915 : 0 : zxdh_np_stat_ppu_cnt_get_ex(uint32_t dev_id,
10916 : : ZXDH_STAT_CNT_MODE_E rd_mode,
10917 : : uint32_t index,
10918 : : uint32_t clr_mode,
10919 : : uint32_t *p_data)
10920 : : {
10921 : : uint32_t rc = 0;
10922 : : uint32_t ppu_eram_baddr = 0;
10923 : : uint32_t ppu_eram_depth = 0;
10924 : : uint32_t eram_rd_mode = 0;
10925 : : uint32_t eram_clr_mode = 0;
10926 : 0 : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
10927 : :
10928 : 0 : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
10929 : :
10930 : 0 : ppu_eram_depth = stat_cfg.eram_depth;
10931 : 0 : ppu_eram_baddr = stat_cfg.eram_baddr;
10932 : :
10933 [ # # ]: 0 : if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) {
10934 [ # # ]: 0 : if (rd_mode == ZXDH_STAT_128_MODE)
10935 : : eram_rd_mode = ZXDH_ERAM128_OPR_128b;
10936 : : else
10937 : : eram_rd_mode = ZXDH_ERAM128_OPR_64b;
10938 : :
10939 [ # # ]: 0 : if (clr_mode == ZXDH_STAT_RD_CLR_MODE_UNCLR)
10940 : : eram_clr_mode = ZXDH_RD_MODE_HOLD;
10941 : : else
10942 : : eram_clr_mode = ZXDH_RD_MODE_CLEAR;
10943 : :
10944 : 0 : rc = zxdh_np_se_smmu0_ind_read(dev_id,
10945 : : ppu_eram_baddr,
10946 : : index,
10947 : : eram_rd_mode,
10948 : : eram_clr_mode,
10949 : : p_data);
10950 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_smmu0_ind_read");
10951 : : } else {
10952 : 0 : PMD_DRV_LOG(ERR, "DPDK DON'T HAVE DDR STAT.");
10953 : : }
10954 : :
10955 : 0 : return rc;
10956 : : }
10957 : :
10958 : : static uint32_t
10959 : 0 : zxdh_np_agent_channel_plcr_sync_send(uint32_t dev_id, ZXDH_AGENT_CHANNEL_PLCR_MSG_T *p_msg,
10960 : : uint32_t *p_data, uint32_t rep_len)
10961 : : {
10962 : : uint32_t ret = 0;
10963 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
10964 : : .msg = (void *)p_msg,
10965 : : .msg_len = sizeof(ZXDH_AGENT_CHANNEL_PLCR_MSG_T),
10966 : : };
10967 : :
10968 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_data, rep_len);
10969 [ # # ]: 0 : if (ret != 0) {
10970 : 0 : PMD_DRV_LOG(ERR, "agent_channel_sync_send failed.");
10971 : 0 : return 1;
10972 : : }
10973 : :
10974 : : return 0;
10975 : : }
10976 : :
10977 : : static uint32_t
10978 : 0 : zxdh_np_agent_channel_plcr_profileid_request(uint32_t dev_id, uint32_t vport,
10979 : : uint32_t car_type, uint32_t *p_profileid)
10980 : : {
10981 : : uint32_t ret = 0;
10982 : 0 : uint32_t resp_buffer[2] = {0};
10983 : :
10984 : 0 : ZXDH_AGENT_CHANNEL_PLCR_MSG_T msgcfg = {
10985 : : .dev_id = 0,
10986 : : .type = ZXDH_PLCR_MSG,
10987 : : .oper = ZXDH_PROFILEID_REQUEST,
10988 : : .vport = vport,
10989 : : .car_type = car_type,
10990 : : .profile_id = 0xFFFF,
10991 : : };
10992 : :
10993 : 0 : ret = zxdh_np_agent_channel_plcr_sync_send(dev_id, &msgcfg,
10994 : : resp_buffer, sizeof(resp_buffer));
10995 [ # # ]: 0 : if (ret != 0) {
10996 : 0 : PMD_DRV_LOG(ERR, "agent_channel_plcr_sync_send failed.");
10997 : 0 : return 1;
10998 : : }
10999 : :
11000 : : memcpy(p_profileid, resp_buffer, sizeof(uint32_t) * ZXDH_SCHE_RSP_LEN);
11001 : :
11002 : 0 : return ret;
11003 : : }
11004 : :
11005 : : static uint32_t
11006 : 0 : zxdh_np_agent_channel_plcr_car_rate(uint32_t dev_id,
11007 : : uint32_t car_type,
11008 : : uint32_t pkt_sign,
11009 : : uint32_t profile_id __rte_unused,
11010 : : void *p_car_profile_cfg)
11011 : : {
11012 : : uint32_t ret = 0;
11013 : 0 : uint32_t resp_buffer[2] = {0};
11014 : : uint32_t resp_len = 8;
11015 : : uint32_t i = 0;
11016 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {0};
11017 : 0 : ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T msgpktcfg = {0};
11018 : 0 : ZXDH_AGENT_CAR_PROFILE_MSG_T msgcfg = {0};
11019 : : ZXDH_STAT_CAR_PROFILE_CFG_T *p_stat_car_profile_cfg = NULL;
11020 : : ZXDH_STAT_CAR_PKT_PROFILE_CFG_T *p_stat_pkt_car_profile_cfg = NULL;
11021 : :
11022 [ # # ]: 0 : if (car_type == ZXDH_STAT_CAR_A_TYPE && pkt_sign == 1) {
11023 : : p_stat_pkt_car_profile_cfg = (ZXDH_STAT_CAR_PKT_PROFILE_CFG_T *)p_car_profile_cfg;
11024 : : msgpktcfg.dev_id = 0;
11025 : 0 : msgpktcfg.type = ZXDH_PLCR_CAR_PKT_RATE;
11026 : 0 : msgpktcfg.car_level = car_type;
11027 : 0 : msgpktcfg.cir = p_stat_pkt_car_profile_cfg->cir;
11028 : 0 : msgpktcfg.cbs = p_stat_pkt_car_profile_cfg->cbs;
11029 : 0 : msgpktcfg.profile_id = p_stat_pkt_car_profile_cfg->profile_id;
11030 : 0 : msgpktcfg.pkt_sign = p_stat_pkt_car_profile_cfg->pkt_sign;
11031 [ # # ]: 0 : for (i = 0; i < ZXDH_CAR_PRI_MAX; i++)
11032 : 0 : msgpktcfg.pri[i] = p_stat_pkt_car_profile_cfg->pri[i];
11033 : :
11034 : 0 : agent_msg.msg = (void *)&msgpktcfg;
11035 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T);
11036 : :
11037 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, resp_buffer, resp_len);
11038 [ # # ]: 0 : if (ret != 0) {
11039 : 0 : PMD_DRV_LOG(ERR, "stat_car_a_type failed.");
11040 : 0 : return 1;
11041 : : }
11042 : :
11043 : 0 : ret = *(uint8_t *)resp_buffer;
11044 : : } else {
11045 : : p_stat_car_profile_cfg = (ZXDH_STAT_CAR_PROFILE_CFG_T *)p_car_profile_cfg;
11046 : : msgcfg.dev_id = 0;
11047 : 0 : msgcfg.type = ZXDH_PLCR_CAR_RATE;
11048 : 0 : msgcfg.car_level = car_type;
11049 : 0 : msgcfg.cir = p_stat_car_profile_cfg->cir;
11050 : 0 : msgcfg.cbs = p_stat_car_profile_cfg->cbs;
11051 : 0 : msgcfg.profile_id = p_stat_car_profile_cfg->profile_id;
11052 : 0 : msgcfg.pkt_sign = p_stat_car_profile_cfg->pkt_sign;
11053 : 0 : msgcfg.cd = p_stat_car_profile_cfg->cd;
11054 : 0 : msgcfg.cf = p_stat_car_profile_cfg->cf;
11055 : 0 : msgcfg.cm = p_stat_car_profile_cfg->cm;
11056 : : msgcfg.cir = p_stat_car_profile_cfg->cir;
11057 : : msgcfg.cbs = p_stat_car_profile_cfg->cbs;
11058 : 0 : msgcfg.eir = p_stat_car_profile_cfg->eir;
11059 : 0 : msgcfg.ebs = p_stat_car_profile_cfg->ebs;
11060 : 0 : msgcfg.random_disc_e = p_stat_car_profile_cfg->random_disc_e;
11061 : 0 : msgcfg.random_disc_c = p_stat_car_profile_cfg->random_disc_c;
11062 [ # # ]: 0 : for (i = 0; i < ZXDH_CAR_PRI_MAX; i++) {
11063 : 0 : msgcfg.c_pri[i] = p_stat_car_profile_cfg->c_pri[i];
11064 : 0 : msgcfg.e_green_pri[i] = p_stat_car_profile_cfg->e_green_pri[i];
11065 : 0 : msgcfg.e_yellow_pri[i] = p_stat_car_profile_cfg->e_yellow_pri[i];
11066 : : }
11067 : :
11068 : 0 : agent_msg.msg = (void *)&msgcfg;
11069 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PROFILE_MSG_T);
11070 : :
11071 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, resp_buffer, resp_len);
11072 [ # # ]: 0 : if (ret != 0) {
11073 : 0 : PMD_DRV_LOG(ERR, "stat_car_b_type failed.");
11074 : 0 : return 1;
11075 : : }
11076 : :
11077 : 0 : ret = *(uint8_t *)resp_buffer;
11078 : : }
11079 : :
11080 : : return ret;
11081 : : }
11082 : :
11083 : : static uint32_t
11084 : 0 : zxdh_np_agent_channel_plcr_profileid_release(uint32_t dev_id, uint32_t vport,
11085 : : uint32_t car_type __rte_unused,
11086 : : uint32_t profileid)
11087 : : {
11088 : : uint32_t ret = 0;
11089 : 0 : uint32_t resp_buffer[2] = {0};
11090 : :
11091 : 0 : ZXDH_AGENT_CHANNEL_PLCR_MSG_T msgcfg = {
11092 : : .dev_id = 0,
11093 : : .type = ZXDH_PLCR_MSG,
11094 : : .oper = ZXDH_PROFILEID_RELEASE,
11095 : : .vport = vport,
11096 : : .profile_id = profileid,
11097 : : };
11098 : :
11099 : 0 : ret = zxdh_np_agent_channel_plcr_sync_send(dev_id, &msgcfg,
11100 : : resp_buffer, sizeof(resp_buffer));
11101 [ # # ]: 0 : if (ret != 0) {
11102 : 0 : PMD_DRV_LOG(ERR, "agent_channel_plcr_sync_send failed.");
11103 : 0 : return 1;
11104 : : }
11105 : :
11106 : 0 : ret = *(uint8_t *)resp_buffer;
11107 : :
11108 : 0 : return ret;
11109 : : }
11110 : :
11111 : : static uint32_t
11112 : 0 : zxdh_np_stat_cara_queue_cfg_set(uint32_t dev_id,
11113 : : uint32_t flow_id,
11114 : : uint32_t drop_flag,
11115 : : uint32_t plcr_en,
11116 : : uint32_t profile_id)
11117 : : {
11118 : : uint32_t rc = 0;
11119 : :
11120 : 0 : ZXDH_STAT_CAR0_CARA_QUEUE_RAM0_159_0_T queue_cfg = {
11121 : : .cara_drop = drop_flag,
11122 : : .cara_plcr_en = plcr_en,
11123 : : .cara_profile_id = profile_id,
11124 : : };
11125 : :
11126 : 0 : rc = zxdh_np_reg_write(dev_id,
11127 : : ZXDH_STAT_CAR0_CARA_QUEUE_RAM0,
11128 : : 0,
11129 : : flow_id,
11130 : : &queue_cfg);
11131 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
11132 : :
11133 : 0 : return rc;
11134 : : }
11135 : :
11136 : : static uint32_t
11137 : 0 : zxdh_np_stat_carb_queue_cfg_set(uint32_t dev_id,
11138 : : uint32_t flow_id,
11139 : : uint32_t drop_flag,
11140 : : uint32_t plcr_en,
11141 : : uint32_t profile_id)
11142 : : {
11143 : : uint32_t rc = 0;
11144 : :
11145 : 0 : ZXDH_STAT_CAR0_CARB_QUEUE_RAM0_159_0_T queue_cfg = {
11146 : : .carb_drop = drop_flag,
11147 : : .carb_plcr_en = plcr_en,
11148 : : .carb_profile_id = profile_id,
11149 : : };
11150 : :
11151 : 0 : rc = zxdh_np_reg_write(dev_id,
11152 : : ZXDH_STAT_CAR0_CARB_QUEUE_RAM0,
11153 : : 0,
11154 : : flow_id,
11155 : : &queue_cfg);
11156 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
11157 : :
11158 : 0 : return rc;
11159 : : }
11160 : :
11161 : : static uint32_t
11162 : 0 : zxdh_np_stat_carc_queue_cfg_set(uint32_t dev_id,
11163 : : uint32_t flow_id,
11164 : : uint32_t drop_flag,
11165 : : uint32_t plcr_en,
11166 : : uint32_t profile_id)
11167 : : {
11168 : : uint32_t rc = 0;
11169 : :
11170 : 0 : ZXDH_STAT_CAR0_CARC_QUEUE_RAM0_159_0_T queue_cfg = {
11171 : : .carc_drop = drop_flag,
11172 : : .carc_plcr_en = plcr_en,
11173 : : .carc_profile_id = profile_id,
11174 : : };
11175 : :
11176 : 0 : rc = zxdh_np_reg_write(dev_id,
11177 : : ZXDH_STAT_CAR0_CARC_QUEUE_RAM0,
11178 : : 0,
11179 : : flow_id,
11180 : : &queue_cfg);
11181 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
11182 : :
11183 : 0 : return rc;
11184 : : }
11185 : :
11186 : : uint32_t
11187 : 0 : zxdh_np_car_profile_id_add(uint32_t dev_id,
11188 : : uint32_t vport_id,
11189 : : uint32_t flags,
11190 : : uint64_t *p_profile_id)
11191 : : {
11192 : : uint32_t ret = 0;
11193 : : uint32_t *profile_id;
11194 : : uint32_t profile_id_h = 0;
11195 : : uint32_t profile_id_l = 0;
11196 : : uint64_t temp_profile_id = 0;
11197 : :
11198 : 0 : profile_id = rte_zmalloc(NULL, ZXDH_G_PROFILE_ID_LEN, 0);
11199 [ # # ]: 0 : if (profile_id == NULL) {
11200 : 0 : PMD_DRV_LOG(ERR, "profile_id point null!");
11201 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11202 : : }
11203 : 0 : ret = zxdh_np_agent_channel_plcr_profileid_request(dev_id, vport_id, flags, profile_id);
11204 : :
11205 : 0 : profile_id_h = *(profile_id + 1);
11206 : 0 : profile_id_l = *profile_id;
11207 : 0 : rte_free(profile_id);
11208 : :
11209 : 0 : temp_profile_id = (((uint64_t)profile_id_l) << 32) | ((uint64_t)profile_id_h);
11210 [ # # ]: 0 : if (0 != (uint32_t)(temp_profile_id >> 56)) {
11211 : 0 : PMD_DRV_LOG(ERR, "profile_id is overflow!");
11212 : 0 : return 1;
11213 : : }
11214 : :
11215 : 0 : *p_profile_id = temp_profile_id;
11216 : :
11217 : 0 : return ret;
11218 : : }
11219 : :
11220 : : uint32_t
11221 : 0 : zxdh_np_car_profile_cfg_set(uint32_t dev_id,
11222 : : uint32_t vport_id __rte_unused,
11223 : : uint32_t car_type,
11224 : : uint32_t pkt_sign,
11225 : : uint32_t profile_id,
11226 : : void *p_car_profile_cfg)
11227 : : {
11228 : : uint32_t ret = 0;
11229 : :
11230 : 0 : ret = zxdh_np_agent_channel_plcr_car_rate(dev_id, car_type,
11231 : : pkt_sign, profile_id, p_car_profile_cfg);
11232 [ # # ]: 0 : if (ret != 0) {
11233 : 0 : PMD_DRV_LOG(ERR, "plcr_car_rate set failed!");
11234 : 0 : return 1;
11235 : : }
11236 : :
11237 : : return ret;
11238 : : }
11239 : :
11240 : : uint32_t
11241 : 0 : zxdh_np_car_profile_id_delete(uint32_t dev_id, uint32_t vport_id,
11242 : : uint32_t flags, uint64_t profile_id)
11243 : : {
11244 : : uint32_t ret = 0;
11245 : 0 : uint32_t profileid = profile_id & 0xFFFF;
11246 : :
11247 : 0 : ret = zxdh_np_agent_channel_plcr_profileid_release(dev_id, vport_id, flags, profileid);
11248 [ # # ]: 0 : if (ret != 0) {
11249 : 0 : PMD_DRV_LOG(ERR, "plcr profiled id release failed!");
11250 : 0 : return 1;
11251 : : }
11252 : :
11253 : : return 0;
11254 : : }
11255 : :
11256 : : uint32_t
11257 : 0 : zxdh_np_stat_car_queue_cfg_set(uint32_t dev_id,
11258 : : uint32_t car_type,
11259 : : uint32_t flow_id,
11260 : : uint32_t drop_flag,
11261 : : uint32_t plcr_en,
11262 : : uint32_t profile_id)
11263 : : {
11264 : : uint32_t rc = 0;
11265 : :
11266 [ # # ]: 0 : if (car_type == ZXDH_STAT_CAR_A_TYPE) {
11267 [ # # ]: 0 : if (flow_id > ZXDH_CAR_A_FLOW_ID_MAX) {
11268 : 0 : PMD_DRV_LOG(ERR, "stat car a type flow_id invalid!");
11269 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11270 : : }
11271 : :
11272 [ # # ]: 0 : if (profile_id > ZXDH_CAR_A_PROFILE_ID_MAX) {
11273 : 0 : PMD_DRV_LOG(ERR, "stat car a type profile_id invalid!");
11274 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11275 : : }
11276 [ # # ]: 0 : } else if (car_type == ZXDH_STAT_CAR_B_TYPE) {
11277 [ # # ]: 0 : if (flow_id > ZXDH_CAR_B_FLOW_ID_MAX) {
11278 : 0 : PMD_DRV_LOG(ERR, "stat car b type flow_id invalid!");
11279 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11280 : : }
11281 : :
11282 [ # # ]: 0 : if (profile_id > ZXDH_CAR_B_PROFILE_ID_MAX) {
11283 : 0 : PMD_DRV_LOG(ERR, "stat car b type profile_id invalid!");
11284 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11285 : : }
11286 : : } else {
11287 [ # # ]: 0 : if (flow_id > ZXDH_CAR_C_FLOW_ID_MAX) {
11288 : 0 : PMD_DRV_LOG(ERR, "stat car c type flow_id invalid!");
11289 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11290 : : }
11291 : :
11292 [ # # ]: 0 : if (profile_id > ZXDH_CAR_C_PROFILE_ID_MAX) {
11293 : 0 : PMD_DRV_LOG(ERR, "stat car c type profile_id invalid!");
11294 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11295 : : }
11296 : : }
11297 : :
11298 [ # # # # ]: 0 : switch (car_type) {
11299 : 0 : case ZXDH_STAT_CAR_A_TYPE:
11300 : 0 : rc = zxdh_np_stat_cara_queue_cfg_set(dev_id,
11301 : : flow_id,
11302 : : drop_flag,
11303 : : plcr_en,
11304 : : profile_id);
11305 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_cara_queue_cfg_set");
11306 : : break;
11307 : :
11308 : 0 : case ZXDH_STAT_CAR_B_TYPE:
11309 : 0 : rc = zxdh_np_stat_carb_queue_cfg_set(dev_id,
11310 : : flow_id,
11311 : : drop_flag,
11312 : : plcr_en,
11313 : : profile_id);
11314 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_carb_queue_cfg_set");
11315 : : break;
11316 : :
11317 : 0 : case ZXDH_STAT_CAR_C_TYPE:
11318 : 0 : rc = zxdh_np_stat_carc_queue_cfg_set(dev_id,
11319 : : flow_id,
11320 : : drop_flag,
11321 : : plcr_en,
11322 : : profile_id);
11323 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_carc_queue_cfg_set");
11324 : : break;
11325 : : }
11326 : :
11327 : : return rc;
11328 : : }
11329 : :
11330 : : uint32_t
11331 : 0 : zxdh_np_dtb_acl_index_request(uint32_t dev_id,
11332 : : uint32_t sdt_no, uint32_t vport, uint32_t *p_index)
11333 : : {
11334 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
11335 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11336 : :
11337 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
11338 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11339 [ # # ]: 0 : if (sdt_acl.table_type != ZXDH_SDT_TBLT_ETCAM) {
11340 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
11341 : : sdt_no, sdt_acl.table_type);
11342 : 0 : return ZXDH_ERR;
11343 : : }
11344 : :
11345 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
11346 : :
11347 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
11348 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11349 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
11350 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
11351 : : eram_sdt_no, sdt_eram.table_type);
11352 : 0 : return ZXDH_ERR;
11353 : : }
11354 : :
11355 : 0 : uint32_t index = 0;
11356 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
11357 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
11358 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
11359 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
11360 : :
11361 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
11362 : 0 : rc = zxdh_np_agent_channel_acl_index_request(dev_id, sdt_no, vport, &index);
11363 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
11364 : :
11365 : 0 : *p_index = index;
11366 : :
11367 : 0 : return rc;
11368 : : }
11369 : :
11370 : : uint32_t
11371 : 0 : zxdh_np_dtb_acl_index_release(uint32_t dev_id,
11372 : : uint32_t sdt_no, uint32_t vport, uint32_t index)
11373 : : {
11374 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
11375 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11376 : :
11377 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
11378 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11379 [ # # ]: 0 : if (sdt_acl.table_type != ZXDH_SDT_TBLT_ETCAM) {
11380 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
11381 : : sdt_no, sdt_acl.table_type);
11382 : 0 : return ZXDH_ERR;
11383 : : }
11384 : :
11385 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
11386 : :
11387 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
11388 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11389 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
11390 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
11391 : : eram_sdt_no, sdt_eram.table_type);
11392 : 0 : return ZXDH_ERR;
11393 : : }
11394 : :
11395 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
11396 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
11397 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
11398 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
11399 : :
11400 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
11401 : :
11402 : 0 : rc = zxdh_np_agent_channel_acl_index_release(dev_id,
11403 : : ZXDH_ACL_INDEX_RELEASE, sdt_no, vport, index);
11404 : :
11405 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
11406 : :
11407 : 0 : return rc;
11408 : : }
11409 : :
11410 : : static uint32_t
11411 : 0 : zxdh_np_dtb_sdt_eram_table_dump(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no,
11412 : : uint32_t start_index, uint32_t depth, uint32_t *p_data, uint32_t *element_id)
11413 : : {
11414 : 0 : uint32_t dump_item_index = 0;
11415 : 0 : uint64_t dump_sdt_phy_addr = 0;
11416 : 0 : uint64_t dump_sdt_vir_addr = 0;
11417 : 0 : uint32_t dump_addr_size = 0;
11418 : :
11419 : 0 : uint32_t rc = zxdh_np_dtb_dump_sdt_addr_get(dev_id,
11420 : : queue_id,
11421 : : sdt_no,
11422 : : &dump_sdt_phy_addr,
11423 : : &dump_sdt_vir_addr,
11424 : : &dump_addr_size);
11425 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_get");
11426 : :
11427 : 0 : memset((uint8_t *)dump_sdt_vir_addr, 0, dump_addr_size);
11428 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &dump_item_index);
11429 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_free_item_get");
11430 : 0 : PMD_DRV_LOG(DEBUG, "dump queue id %u, element_id is: %u.",
11431 : : queue_id, dump_item_index);
11432 : :
11433 : 0 : *element_id = dump_item_index;
11434 : :
11435 : 0 : rc = zxdh_np_dtb_tab_up_item_user_addr_set(dev_id,
11436 : : queue_id,
11437 : : dump_item_index,
11438 : : dump_sdt_phy_addr,
11439 : : dump_sdt_vir_addr);
11440 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_set");
11441 : :
11442 : 0 : uint32_t dump_dst_phy_haddr = 0;
11443 : 0 : uint32_t dump_dst_phy_laddr = 0;
11444 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, dump_item_index,
11445 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
11446 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_get");
11447 : :
11448 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
11449 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11450 : :
11451 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram);
11452 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11453 : :
11454 : 0 : uint32_t eram_base_addr = sdt_eram.eram_base_addr;
11455 : 0 : uint32_t dump_addr_128bit = eram_base_addr + start_index;
11456 : :
11457 : 0 : rc = zxdh_np_dtb_smmu0_dump_info_write(dev_id,
11458 : : dump_addr_128bit,
11459 : : depth,
11460 : : dump_dst_phy_haddr,
11461 : : dump_dst_phy_laddr,
11462 : : (uint32_t *)form_buff);
11463 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_dump_info_write");
11464 : :
11465 : 0 : uint32_t dump_data_len = depth * 128 / 32;
11466 : : uint32_t dump_desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
11467 : :
11468 [ # # ]: 0 : if (dump_data_len * 4 > dump_addr_size) {
11469 : 0 : PMD_DRV_LOG(ERR, "eram dump size is too small!");
11470 : 0 : return ZXDH_RC_DTB_DUMP_SIZE_SMALL;
11471 : : }
11472 : :
11473 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id,
11474 : : queue_id,
11475 : : dump_item_index,
11476 : : (uint32_t *)form_buff,
11477 : : dump_data_len,
11478 : : dump_desc_len,
11479 : : p_data);
11480 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_desc_info");
11481 : :
11482 : : return rc;
11483 : : }
11484 : :
11485 : : static uint32_t
11486 : 0 : zxdh_np_dtb_eram_table_dump(uint32_t dev_id,
11487 : : uint32_t queue_id,
11488 : : uint32_t sdt_no,
11489 : : ZXDH_DTB_DUMP_INDEX_T start_index,
11490 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_data_arr,
11491 : : uint32_t *entry_num,
11492 : : __rte_unused ZXDH_DTB_DUMP_INDEX_T *next_start_index,
11493 : : uint32_t *finish_flag)
11494 : : {
11495 : : uint32_t start_index_128bit = 0;
11496 : : uint32_t col_index = 0;
11497 : : uint32_t dump_depth_128bit = 0;
11498 : 0 : uint32_t element_id = 0;
11499 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11500 : :
11501 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram);
11502 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11503 : :
11504 : 0 : uint32_t dump_mode = sdt_eram.eram_mode;
11505 [ # # # # ]: 0 : uint32_t eram_table_depth = sdt_eram.eram_table_depth;
11506 : :
11507 : : zxdh_np_eram_index_cal(dump_mode, eram_table_depth,
11508 : : &dump_depth_128bit, &col_index);
11509 : :
11510 : : zxdh_np_eram_index_cal(dump_mode, start_index.index,
11511 : : &start_index_128bit, &col_index);
11512 : :
11513 : 0 : uint32_t dump_depth = dump_depth_128bit - start_index_128bit;
11514 : :
11515 : 0 : uint8_t *dump_data_buff = malloc(dump_depth * ZXDH_DTB_LEN_POS_SETP);
11516 [ # # ]: 0 : if (dump_data_buff == NULL) {
11517 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
11518 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11519 : : }
11520 : :
11521 : 0 : rc = zxdh_np_dtb_sdt_eram_table_dump(dev_id,
11522 : : queue_id,
11523 : : sdt_no,
11524 : : start_index_128bit,
11525 : : dump_depth,
11526 : : (uint32_t *)dump_data_buff,
11527 : : &element_id);
11528 : :
11529 [ # # ]: 0 : if (dump_mode == ZXDH_ERAM128_TBL_128b) {
11530 [ # # ]: 0 : for (uint32_t i = 0; i < dump_depth; i++) {
11531 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_user_data = p_dump_data_arr + i;
11532 : 0 : uint8_t *temp_data = dump_data_buff + i * ZXDH_DTB_LEN_POS_SETP;
11533 [ # # # # ]: 0 : if (p_dump_user_data == NULL || p_dump_user_data->p_data == NULL) {
11534 : 0 : PMD_DRV_LOG(ERR, "data buff is NULL!");
11535 : 0 : free(dump_data_buff);
11536 : 0 : return ZXDH_ERR;
11537 : : }
11538 : :
11539 : 0 : p_dump_user_data->index = start_index.index + i;
11540 : : memcpy(p_dump_user_data->p_data, temp_data, (128 / 8));
11541 : : }
11542 [ # # ]: 0 : } else if (dump_mode == ZXDH_ERAM128_TBL_64b) {
11543 : : uint32_t row_index = 0;
11544 : 0 : uint32_t remain = start_index.index % 2;
11545 [ # # ]: 0 : for (uint32_t i = 0; i < eram_table_depth - start_index.index; i++) {
11546 : : zxdh_np_eram_index_cal(dump_mode, remain, &row_index, &col_index);
11547 : 0 : uint8_t *temp_data = dump_data_buff + row_index * ZXDH_DTB_LEN_POS_SETP;
11548 : :
11549 : : uint32_t *buff = (uint32_t *)temp_data;
11550 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_user_data = p_dump_data_arr + i;
11551 : :
11552 [ # # # # ]: 0 : if (p_dump_user_data == NULL || p_dump_user_data->p_data == NULL) {
11553 : 0 : PMD_DRV_LOG(ERR, "data buff is NULL!");
11554 : 0 : free(dump_data_buff);
11555 : : return ZXDH_ERR;
11556 : : }
11557 : :
11558 : 0 : p_dump_user_data->index = start_index.index + i;
11559 : : memcpy(p_dump_user_data->p_data,
11560 : 0 : buff + ((1 - col_index) << 1), (64 / 8));
11561 : :
11562 : 0 : remain++;
11563 : : }
11564 : : }
11565 : :
11566 : 0 : *entry_num = eram_table_depth - start_index.index;
11567 : 0 : *finish_flag = 1;
11568 : 0 : PMD_DRV_LOG(DEBUG, "dump entry num %u, finish flag %u", *entry_num, *finish_flag);
11569 : :
11570 : 0 : free(dump_data_buff);
11571 : :
11572 : 0 : return ZXDH_OK;
11573 : : }
11574 : :
11575 : : static uint32_t
11576 : 0 : zxdh_np_dtb_acl_index_parse(uint32_t dev_id,
11577 : : uint32_t queue_id,
11578 : : uint32_t eram_sdt_no,
11579 : : uint32_t vport,
11580 : : uint32_t *index_num,
11581 : : uint32_t *p_index_array)
11582 : : {
11583 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11584 : :
11585 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
11586 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11587 : :
11588 [ # # ]: 0 : uint32_t byte_num = (sdt_eram.eram_mode == ZXDH_ERAM128_TBL_64b) ? 8 : 16;
11589 : 0 : uint32_t eram_table_depth = sdt_eram.eram_table_depth;
11590 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_data_arr = malloc(eram_table_depth *
11591 : : sizeof(ZXDH_DTB_ERAM_ENTRY_INFO_T));
11592 [ # # ]: 0 : if (p_dump_data_arr == NULL) {
11593 : 0 : PMD_DRV_LOG(ERR, "p_dump_data_arr point null!");
11594 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11595 : : }
11596 : :
11597 : 0 : uint8_t *data_buff = malloc(byte_num * eram_table_depth);
11598 [ # # ]: 0 : if (data_buff == NULL) {
11599 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
11600 : 0 : free(p_dump_data_arr);
11601 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11602 : : }
11603 : :
11604 [ # # ]: 0 : for (uint32_t i = 0; i < eram_table_depth; i++) {
11605 : 0 : p_dump_data_arr[i].index = i;
11606 : 0 : p_dump_data_arr[i].p_data = (uint32_t *)(data_buff + i * byte_num);
11607 : : }
11608 : :
11609 : 0 : uint32_t entry_num = 0;
11610 : : uint32_t valid_entry_num = 0;
11611 : 0 : uint32_t finish_flag = 0;
11612 : 0 : ZXDH_DTB_DUMP_INDEX_T start_index = {0};
11613 : 0 : ZXDH_DTB_DUMP_INDEX_T next_start_index = {0};
11614 : 0 : rc = zxdh_np_dtb_eram_table_dump(dev_id,
11615 : : queue_id,
11616 : : eram_sdt_no,
11617 : : start_index,
11618 : : p_dump_data_arr,
11619 : : &entry_num,
11620 : : &next_start_index,
11621 : : &finish_flag);
11622 : :
11623 [ # # ]: 0 : for (uint32_t i = 0; i < entry_num; i++) {
11624 : 0 : uint8_t valid = (p_dump_data_arr[i].p_data[0] >> 31) & 0x1;
11625 : 0 : uint32_t temp_vport = p_dump_data_arr[i].p_data[0] & 0x7fffffff;
11626 [ # # ]: 0 : if (valid && temp_vport == vport) {
11627 : 0 : p_index_array[valid_entry_num] = i;
11628 : 0 : valid_entry_num++;
11629 : : }
11630 : : }
11631 : :
11632 : 0 : *index_num = valid_entry_num;
11633 : 0 : free(data_buff);
11634 : 0 : free(p_dump_data_arr);
11635 : :
11636 : 0 : return rc;
11637 : : }
11638 : :
11639 : : static uint32_t
11640 : 0 : zxdh_np_dtb_etcam_ind_data_get(uint8_t *p_in_data, uint32_t rd_mode, uint8_t *p_out_data)
11641 : : {
11642 : : uint8_t buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11643 : :
11644 : : memcpy(buff, p_in_data, ZXDH_ETCAM_WIDTH_MAX / 8);
11645 : : zxdh_np_comm_swap(buff, ZXDH_ETCAM_WIDTH_MAX / 8);
11646 : :
11647 : : uint8_t *p_temp = p_out_data;
11648 [ # # ]: 0 : for (uint32_t i = 0; i < ZXDH_ETCAM_RAM_NUM; i++) {
11649 : 0 : uint32_t offset = i * (ZXDH_ETCAM_WIDTH_MIN / 8);
11650 : :
11651 [ # # ]: 0 : if ((rd_mode >> (ZXDH_ETCAM_RAM_NUM - 1 - i)) & 0x1) {
11652 : 0 : memcpy(p_temp, buff + offset, ZXDH_ETCAM_WIDTH_MIN / 8);
11653 : 0 : p_temp += ZXDH_ETCAM_WIDTH_MIN / 8;
11654 : : }
11655 : : }
11656 : :
11657 : 0 : return ZXDH_OK;
11658 : : }
11659 : :
11660 : : static uint32_t
11661 : 0 : zxdh_np_dtb_acl_table_dump(uint32_t dev_id,
11662 : : uint32_t queue_id,
11663 : : uint32_t sdt_no,
11664 : : __rte_unused ZXDH_DTB_DUMP_INDEX_T start_index,
11665 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dump_data_arr,
11666 : : uint32_t *p_entry_num,
11667 : : __rte_unused ZXDH_DTB_DUMP_INDEX_T *next_start_index,
11668 : : uint32_t *p_finish_flag)
11669 : : {
11670 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
11671 : :
11672 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
11673 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11674 : 0 : uint32_t etcam_key_mode = sdt_etcam_info.etcam_key_mode;
11675 : 0 : uint32_t etcam_as_mode = sdt_etcam_info.as_rsp_mode;
11676 : 0 : uint32_t etcam_table_id = sdt_etcam_info.etcam_table_id;
11677 : 0 : uint32_t as_enable = sdt_etcam_info.as_en;
11678 : 0 : uint32_t as_eram_baddr = sdt_etcam_info.as_eram_baddr;
11679 : 0 : uint32_t etcam_table_depth = sdt_etcam_info.etcam_table_depth;
11680 : :
11681 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
11682 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
11683 : 0 : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
11684 : :
11685 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
11686 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
11687 : : RTE_ASSERT(0);
11688 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
11689 : : }
11690 : :
11691 : 0 : uint32_t data_byte_size = ZXDH_ETCAM_ENTRY_SIZE_GET(etcam_key_mode);
11692 [ # # ]: 0 : if (data_byte_size > ZXDH_ETCAM_RAM_WIDTH) {
11693 : 0 : PMD_DRV_LOG(ERR, "etcam date size is over 80B!");
11694 : 0 : return ZXDH_ACL_RC_INVALID_PARA;
11695 : : }
11696 : :
11697 : 0 : uint32_t dump_element_id = 0;
11698 : 0 : rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &dump_element_id);
11699 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
11700 : :
11701 : 0 : uint8_t *dump_info_buff = malloc(ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE);
11702 [ # # ]: 0 : if (dump_info_buff == NULL) {
11703 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
11704 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11705 : : }
11706 : :
11707 : : uint32_t dtb_desc_addr_offset = 0;
11708 : : uint32_t dump_data_len = 0;
11709 : : uint32_t dtb_desc_len = 0;
11710 : : uint32_t etcam_data_len_offset = 0;
11711 : : uint32_t etcam_mask_len_offset = 0;
11712 : 0 : uint32_t block_num = p_tbl_cfg->block_num;
11713 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
11714 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
11715 : 0 : dtb_dump_entry.cmd = cmd_buff;
11716 : :
11717 [ # # ]: 0 : for (uint32_t i = 0; i < block_num; i++) {
11718 : 0 : ZXDH_ETCAM_DUMP_INFO_T etcam_dump_info = {0};
11719 : : uint32_t etcam_data_dst_phy_haddr = 0;
11720 : : uint32_t etcam_data_dst_phy_laddr = 0;
11721 : 0 : uint32_t block_idx = p_tbl_cfg->block_array[i];
11722 : :
11723 : 0 : PMD_DRV_LOG(DEBUG, "block_idx: %u", block_idx);
11724 : :
11725 : 0 : etcam_dump_info.block_sel = block_idx;
11726 : : etcam_dump_info.addr = 0;
11727 : 0 : etcam_dump_info.tb_width = 3;
11728 : 0 : etcam_dump_info.rd_mode = 0xFF;
11729 : 0 : etcam_dump_info.tb_depth = ZXDH_ETCAM_RAM_DEPTH;
11730 : 0 : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_DATA;
11731 : :
11732 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
11733 : : queue_id,
11734 : : dump_element_id,
11735 : : dump_data_len,
11736 : : &etcam_data_dst_phy_haddr,
11737 : : &etcam_data_dst_phy_laddr);
11738 : :
11739 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
11740 : : &etcam_dump_info,
11741 : : etcam_data_dst_phy_haddr,
11742 : : etcam_data_dst_phy_laddr,
11743 : : &dtb_dump_entry);
11744 : :
11745 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
11746 : :
11747 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
11748 : :
11749 : 0 : dtb_desc_len += 1;
11750 : 0 : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
11751 : 0 : dump_data_len += ZXDH_ETCAM_RAM_DEPTH * 640 / 8;
11752 : : }
11753 : :
11754 : : etcam_data_len_offset = dump_data_len;
11755 : :
11756 [ # # ]: 0 : for (uint32_t i = 0; i < block_num; i++) {
11757 : 0 : ZXDH_ETCAM_DUMP_INFO_T etcam_dump_info = {0};
11758 : : uint32_t etcam_mask_dst_phy_haddr = 0;
11759 : : uint32_t etcam_mask_dst_phy_laddr = 0;
11760 : 0 : uint32_t block_idx = p_tbl_cfg->block_array[i];
11761 : :
11762 : 0 : PMD_DRV_LOG(DEBUG, "mask: block_idx: %u", block_idx);
11763 : :
11764 : 0 : etcam_dump_info.block_sel = block_idx;
11765 : : etcam_dump_info.addr = 0;
11766 : 0 : etcam_dump_info.tb_width = 3;
11767 : 0 : etcam_dump_info.rd_mode = 0xFF;
11768 : 0 : etcam_dump_info.tb_depth = ZXDH_ETCAM_RAM_DEPTH;
11769 : : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_MASK;
11770 : :
11771 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
11772 : : queue_id,
11773 : : dump_element_id,
11774 : : dump_data_len,
11775 : : &etcam_mask_dst_phy_haddr,
11776 : : &etcam_mask_dst_phy_laddr);
11777 : :
11778 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
11779 : : &etcam_dump_info,
11780 : : etcam_mask_dst_phy_haddr,
11781 : : etcam_mask_dst_phy_laddr,
11782 : : &dtb_dump_entry);
11783 : :
11784 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
11785 : :
11786 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
11787 : :
11788 : 0 : dtb_desc_len += 1;
11789 : 0 : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
11790 : 0 : dump_data_len += ZXDH_ETCAM_RAM_DEPTH * 640 / 8;
11791 : : }
11792 : : etcam_mask_len_offset = dump_data_len;
11793 : :
11794 [ # # ]: 0 : if (as_enable) {
11795 : : uint32_t as_rst_dst_phy_haddr = 0;
11796 : : uint32_t as_rst_dst_phy_laddr = 0;
11797 : : uint32_t dump_eram_depth_128bit = 0;
11798 : : uint32_t eram_col_index = 0;
11799 : :
11800 : : zxdh_np_eram_index_cal(etcam_as_mode,
11801 : : etcam_table_depth, &dump_eram_depth_128bit, &eram_col_index);
11802 : :
11803 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
11804 : : queue_id,
11805 : : dump_element_id,
11806 : : dump_data_len,
11807 : : &as_rst_dst_phy_haddr,
11808 : : &as_rst_dst_phy_laddr);
11809 : :
11810 : 0 : zxdh_np_dtb_smmu0_dump_entry(dev_id,
11811 : : as_eram_baddr,
11812 : : dump_eram_depth_128bit,
11813 : : as_rst_dst_phy_haddr,
11814 : : as_rst_dst_phy_laddr,
11815 : : &dtb_dump_entry);
11816 : :
11817 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
11818 : :
11819 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
11820 : 0 : dtb_desc_len += 1;
11821 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
11822 : 0 : dump_data_len += dump_eram_depth_128bit * 128 / 8;
11823 : : }
11824 : :
11825 : 0 : uint8_t *temp_dump_out_data = malloc(dump_data_len * sizeof(uint8_t));
11826 [ # # ]: 0 : if (temp_dump_out_data == NULL) {
11827 : 0 : PMD_DRV_LOG(ERR, "temp_dump_out_data point null!");
11828 : 0 : free(dump_info_buff);
11829 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11830 : : }
11831 : :
11832 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id,
11833 : : queue_id,
11834 : : dump_element_id,
11835 : : (uint32_t *)dump_info_buff,
11836 : : dump_data_len / 4,
11837 : : dtb_desc_len * 4,
11838 : : (uint32_t *)temp_dump_out_data);
11839 : 0 : free(dump_info_buff);
11840 : :
11841 : : uint8_t *p_data_start = temp_dump_out_data;
11842 : 0 : uint8_t *p_mask_start = temp_dump_out_data + etcam_data_len_offset;
11843 : : uint8_t *p_rst_start = NULL;
11844 [ # # ]: 0 : if (as_enable)
11845 : 0 : p_rst_start = temp_dump_out_data + etcam_mask_len_offset;
11846 : :
11847 [ # # ]: 0 : for (uint32_t handle = 0; handle < etcam_table_depth; handle++) {
11848 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dump_user_data = p_dump_data_arr + handle;
11849 : :
11850 [ # # ]: 0 : if (p_dump_user_data == NULL ||
11851 [ # # ]: 0 : p_dump_user_data->key_data == NULL ||
11852 [ # # ]: 0 : p_dump_user_data->key_mask == NULL) {
11853 : 0 : PMD_DRV_LOG(ERR, "etcam handle 0x%x data user buff is NULL!", handle);
11854 : 0 : free(temp_dump_out_data);
11855 : 0 : return ZXDH_ERR;
11856 : : }
11857 : :
11858 [ # # ]: 0 : if (as_enable) {
11859 [ # # ]: 0 : if (p_dump_user_data->p_as_rslt == NULL) {
11860 : 0 : PMD_DRV_LOG(ERR, "handle 0x%x data buff is NULL!", handle);
11861 : 0 : free(temp_dump_out_data);
11862 : 0 : return ZXDH_ERR;
11863 : : }
11864 : : }
11865 : :
11866 : 0 : p_dump_user_data->handle = handle;
11867 : :
11868 : 0 : uint32_t shift_amount = 8U >> etcam_key_mode;
11869 : 0 : uint32_t mask_base = (1U << shift_amount) - 1;
11870 : 0 : uint32_t offset = shift_amount * (handle % (1U << etcam_key_mode));
11871 : 0 : uint32_t rd_mask = (mask_base << offset) & 0xFF;
11872 : :
11873 : 0 : uint32_t addr_640bit = handle / (1U << etcam_key_mode);
11874 : 0 : uint8_t *p_data_640bit = p_data_start + addr_640bit * 640 / 8;
11875 : 0 : uint8_t *p_mask_640bit = p_mask_start + addr_640bit * 640 / 8;
11876 : :
11877 : 0 : uint8_t xy_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11878 : 0 : uint8_t xy_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11879 : 0 : uint8_t dm_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11880 : 0 : uint8_t dm_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11881 : : ZXDH_ETCAM_ENTRY_T entry_xy = {
11882 : : .p_data = xy_data,
11883 : : .p_mask = xy_mask,
11884 : : .mode = 0,
11885 : : };
11886 : : ZXDH_ETCAM_ENTRY_T entry_dm = {
11887 : : .p_data = dm_data,
11888 : : .p_mask = dm_mask,
11889 : : .mode = 0,
11890 : : };
11891 : :
11892 : 0 : zxdh_np_dtb_etcam_ind_data_get(p_data_640bit, rd_mask, entry_xy.p_data);
11893 : 0 : zxdh_np_dtb_etcam_ind_data_get(p_mask_640bit, rd_mask, entry_xy.p_mask);
11894 : :
11895 : : zxdh_np_etcam_xy_to_dm(&entry_dm, &entry_xy, data_byte_size);
11896 : :
11897 [ # # ]: 0 : memcpy(p_dump_user_data->key_data, entry_dm.p_data, data_byte_size);
11898 : 0 : memcpy(p_dump_user_data->key_mask, entry_dm.p_mask, data_byte_size);
11899 : :
11900 [ # # ]: 0 : if (as_enable) {
11901 : : uint32_t eram_row_index = 0;
11902 : : uint32_t eram_col_index = 0;
11903 : :
11904 : : zxdh_np_eram_index_cal(etcam_as_mode,
11905 : : handle, &eram_row_index, &eram_col_index);
11906 : :
11907 : 0 : uint8_t *p_rst_128bit = p_rst_start +
11908 : 0 : eram_row_index * ZXDH_DTB_LEN_POS_SETP;
11909 : : uint32_t *eram_buff = (uint32_t *)p_rst_128bit;
11910 : :
11911 [ # # ]: 0 : if (etcam_as_mode == ZXDH_ERAM128_TBL_128b)
11912 : 0 : memcpy(p_dump_user_data->p_as_rslt, eram_buff, (128 / 8));
11913 [ # # ]: 0 : else if (etcam_as_mode == ZXDH_ERAM128_TBL_64b)
11914 : 0 : memcpy(p_dump_user_data->p_as_rslt,
11915 : 0 : eram_buff + ((1 - eram_col_index) << 1), (64 / 8));
11916 : : }
11917 : : }
11918 : :
11919 : 0 : *p_entry_num = etcam_table_depth;
11920 : 0 : *p_finish_flag = 1;
11921 : :
11922 : 0 : free(temp_dump_out_data);
11923 : :
11924 : 0 : return ZXDH_OK;
11925 : : }
11926 : :
11927 : : static uint32_t
11928 : : zxdh_np_smmu0_tbl_size_get(uint32_t eram_mode)
11929 : : {
11930 : : uint32_t size = 0;
11931 : : if (eram_mode == ZXDH_ERAM128_TBL_128b)
11932 : : size = 16;
11933 : : else if (eram_mode == ZXDH_ERAM128_TBL_64b)
11934 : : size = 8;
11935 : : else if (eram_mode == ZXDH_ERAM128_TBL_32b)
11936 : : size = 4;
11937 : : else
11938 : : size = 1;
11939 : :
11940 : : return size;
11941 : : }
11942 : :
11943 : : static uint32_t
11944 : 0 : zxdh_np_dtb_acl_data_get_by_handle(uint32_t dev_id,
11945 : : uint32_t queue_id,
11946 : : uint32_t sdt_no,
11947 : : uint32_t index_num,
11948 : : uint32_t *p_index_array,
11949 : : uint8_t *p_dump_data)
11950 : : {
11951 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
11952 : :
11953 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
11954 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11955 [ # # ]: 0 : if (sdt_etcam_info.table_type != ZXDH_SDT_TBLT_ETCAM) {
11956 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
11957 : : sdt_no, sdt_etcam_info.table_type);
11958 : 0 : return ZXDH_ERR;
11959 : : }
11960 : :
11961 : 0 : uint32_t etcam_key_mode = sdt_etcam_info.etcam_key_mode;
11962 : 0 : uint32_t etcam_table_depth = sdt_etcam_info.etcam_table_depth;
11963 [ # # ]: 0 : uint32_t as_len = zxdh_np_smmu0_tbl_size_get(sdt_etcam_info.as_rsp_mode);
11964 : 0 : uint32_t data_byte_size = ZXDH_ETCAM_ENTRY_SIZE_GET(etcam_key_mode);
11965 : :
11966 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dtb_acl_entry = malloc(etcam_table_depth *
11967 : : sizeof(ZXDH_DTB_ACL_ENTRY_INFO_T));
11968 [ # # ]: 0 : if (p_dtb_acl_entry == NULL) {
11969 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
11970 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11971 : : }
11972 : :
11973 : 0 : uint8_t *data_buff = malloc(etcam_table_depth * data_byte_size);
11974 [ # # ]: 0 : if (data_buff == NULL) {
11975 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
11976 : 0 : free(p_dtb_acl_entry);
11977 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11978 : : }
11979 : :
11980 : 0 : uint8_t *mask_buff = malloc(etcam_table_depth * data_byte_size);
11981 [ # # ]: 0 : if (mask_buff == NULL) {
11982 : 0 : PMD_DRV_LOG(ERR, "mask_buff point null!");
11983 : 0 : free(data_buff);
11984 : 0 : free(p_dtb_acl_entry);
11985 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11986 : : }
11987 : :
11988 : 0 : uint8_t *eram_buff = malloc(etcam_table_depth * as_len);
11989 [ # # ]: 0 : if (eram_buff == NULL) {
11990 : 0 : PMD_DRV_LOG(ERR, "eram_buff point null!");
11991 : 0 : free(mask_buff);
11992 : 0 : free(data_buff);
11993 : 0 : free(p_dtb_acl_entry);
11994 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11995 : : }
11996 : :
11997 [ # # ]: 0 : for (uint32_t i = 0; i < etcam_table_depth; i++) {
11998 : 0 : p_dtb_acl_entry[i].handle = i;
11999 : 0 : p_dtb_acl_entry[i].key_data = data_buff + i * data_byte_size;
12000 : 0 : p_dtb_acl_entry[i].key_mask = mask_buff + i * data_byte_size;
12001 : 0 : p_dtb_acl_entry[i].p_as_rslt = eram_buff + i * as_len;
12002 : : }
12003 : :
12004 : 0 : uint32_t entry_num = 0;
12005 : 0 : uint32_t finish_flag = 0;
12006 : 0 : ZXDH_DTB_DUMP_INDEX_T start_index = {0};
12007 : 0 : ZXDH_DTB_DUMP_INDEX_T next_start_index = {0};
12008 : 0 : rc = zxdh_np_dtb_acl_table_dump(dev_id,
12009 : : queue_id,
12010 : : sdt_no,
12011 : : start_index,
12012 : : p_dtb_acl_entry,
12013 : : &entry_num,
12014 : : &next_start_index,
12015 : : &finish_flag);
12016 [ # # ]: 0 : if (rc != ZXDH_OK) {
12017 : 0 : PMD_DRV_LOG(ERR, "acl sdt[%u] dump fail, rc:0x%x", sdt_no, rc);
12018 : 0 : free(data_buff);
12019 : 0 : free(mask_buff);
12020 : 0 : free(eram_buff);
12021 : 0 : free(p_dtb_acl_entry);
12022 : 0 : return rc;
12023 : : }
12024 : :
12025 [ # # ]: 0 : for (uint32_t i = 0; i < index_num; i++) {
12026 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dump_entry =
12027 : 0 : ((ZXDH_DTB_ACL_ENTRY_INFO_T *)p_dump_data) + i;
12028 : 0 : p_dump_entry->handle = p_index_array[i];
12029 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_temp_entry = p_dtb_acl_entry + p_index_array[i];
12030 : 0 : memcpy(p_dump_entry->key_data, p_temp_entry->key_data, data_byte_size);
12031 : 0 : memcpy(p_dump_entry->key_mask, p_temp_entry->key_mask, data_byte_size);
12032 : 0 : memcpy(p_dump_entry->p_as_rslt, p_temp_entry->p_as_rslt, as_len);
12033 : : }
12034 : :
12035 : 0 : free(data_buff);
12036 : 0 : free(mask_buff);
12037 : 0 : free(eram_buff);
12038 : 0 : free(p_dtb_acl_entry);
12039 : :
12040 : 0 : return rc;
12041 : : }
12042 : :
12043 : : uint32_t
12044 : 0 : zxdh_np_dtb_acl_table_dump_by_vport(uint32_t dev_id, uint32_t queue_id,
12045 : : uint32_t sdt_no, uint32_t vport, uint32_t *entry_num, uint8_t *p_dump_data)
12046 : : {
12047 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
12048 : :
12049 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
12050 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12051 [ # # ]: 0 : if (sdt_etcam_info.table_type != ZXDH_SDT_TBLT_ETCAM) {
12052 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
12053 : : sdt_no, sdt_etcam_info.table_type);
12054 : 0 : return ZXDH_ERR;
12055 : : }
12056 : :
12057 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
12058 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
12059 : :
12060 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
12061 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12062 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
12063 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
12064 : : eram_sdt_no, sdt_eram.table_type);
12065 : 0 : return ZXDH_ERR;
12066 : : }
12067 : :
12068 : 0 : uint32_t *p_index_array = malloc(sizeof(uint32_t) * sdt_eram.eram_table_depth);
12069 [ # # ]: 0 : if (p_index_array == NULL) {
12070 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12071 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12072 : : }
12073 : :
12074 : 0 : uint32_t index_num = 0;
12075 : 0 : rc = zxdh_np_dtb_acl_index_parse(dev_id, queue_id,
12076 : : eram_sdt_no, vport, &index_num, p_index_array);
12077 [ # # ]: 0 : if (rc != ZXDH_OK) {
12078 : 0 : free(p_index_array);
12079 : 0 : PMD_DRV_LOG(ERR, "acl index parse failed");
12080 : 0 : return ZXDH_ERR;
12081 : : }
12082 : :
12083 [ # # ]: 0 : if (!index_num) {
12084 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] vport[0x%x] item num is zero!", sdt_no, vport);
12085 : 0 : free(p_index_array);
12086 : 0 : return ZXDH_OK;
12087 : : }
12088 : :
12089 : 0 : rc = zxdh_np_dtb_acl_data_get_by_handle(dev_id, queue_id, sdt_no,
12090 : : index_num, p_index_array, p_dump_data);
12091 [ # # ]: 0 : if (rc != ZXDH_OK) {
12092 : 0 : free(p_index_array);
12093 : 0 : PMD_DRV_LOG(ERR, "acl date by handle failed");
12094 : 0 : return ZXDH_ERR;
12095 : : }
12096 : :
12097 : 0 : *entry_num = index_num;
12098 : 0 : free(p_index_array);
12099 : :
12100 : 0 : return ZXDH_OK;
12101 : : }
12102 : :
12103 : : static uint32_t
12104 : 0 : zxdh_np_dtb_acl_dma_insert_cycle(uint32_t dev_id,
12105 : : uint32_t queue_id,
12106 : : uint32_t sdt_no,
12107 : : uint32_t entry_num,
12108 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_acl_entry_arr,
12109 : : uint32_t *element_id)
12110 : : {
12111 : : uint32_t eram_wrt_mode = 0;
12112 : : uint32_t addr_offset_bk = 0;
12113 : : uint32_t dtb_len = 0;
12114 : : uint32_t as_addr_offset = 0;
12115 : : uint32_t as_dtb_len = 0;
12116 : :
12117 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
12118 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
12119 : :
12120 : 0 : ZXDH_DTB_ENTRY_T entry_data = {0};
12121 : 0 : ZXDH_DTB_ENTRY_T entry_mask = {0};
12122 : :
12123 : 0 : uint8_t entry_data_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
12124 : 0 : uint8_t entry_mask_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
12125 : 0 : uint8_t entry_data_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
12126 : 0 : uint8_t entry_mask_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
12127 : :
12128 : 0 : entry_data.cmd = entry_data_cmd_buff;
12129 : 0 : entry_data.data = entry_data_buff;
12130 : 0 : entry_mask.cmd = entry_mask_cmd_buff;
12131 : 0 : entry_mask.data = entry_mask_buff;
12132 : :
12133 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
12134 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12135 : 0 : uint32_t etcam_as_mode = sdt_etcam_info.as_rsp_mode;
12136 : 0 : uint32_t etcam_table_id = sdt_etcam_info.etcam_table_id;
12137 : 0 : uint32_t as_enable = sdt_etcam_info.as_en;
12138 : 0 : uint32_t as_eram_baddr = sdt_etcam_info.as_eram_baddr;
12139 : :
12140 [ # # ]: 0 : if (as_enable) {
12141 [ # # # # ]: 0 : switch (etcam_as_mode) {
12142 : : case ZXDH_ERAM128_TBL_128b:
12143 : : eram_wrt_mode = ZXDH_ERAM128_OPR_128b;
12144 : : break;
12145 : 0 : case ZXDH_ERAM128_TBL_64b:
12146 : : eram_wrt_mode = ZXDH_ERAM128_OPR_64b;
12147 : 0 : break;
12148 : 0 : case ZXDH_ERAM128_TBL_1b:
12149 : : eram_wrt_mode = ZXDH_ERAM128_OPR_1b;
12150 : 0 : break;
12151 : :
12152 : 0 : default:
12153 : 0 : PMD_DRV_LOG(ERR, "etcam_as_mode is invalid!");
12154 : 0 : return ZXDH_ERR;
12155 : : }
12156 : : }
12157 : :
12158 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
12159 : 0 : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
12160 : :
12161 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
12162 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
12163 : : RTE_ASSERT(0);
12164 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
12165 : : }
12166 : :
12167 : 0 : uint8_t *table_data_buff = malloc(ZXDH_DTB_TABLE_DATA_BUFF_SIZE);
12168 [ # # ]: 0 : if (table_data_buff == NULL) {
12169 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12170 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12171 : : }
12172 : :
12173 [ # # ]: 0 : for (uint32_t item_cnt = 0; item_cnt < entry_num; ++item_cnt) {
12174 : 0 : uint32_t block_idx = 0;
12175 : 0 : uint32_t ram_addr = 0;
12176 : 0 : uint32_t etcam_wr_mode = 0;
12177 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry = {0};
12178 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_acl_entry = p_acl_entry_arr + item_cnt;
12179 : :
12180 : 0 : etcam_entry.mode = p_tbl_cfg->key_mode;
12181 : 0 : etcam_entry.p_data = p_acl_entry->key_data;
12182 : 0 : etcam_entry.p_mask = p_acl_entry->key_mask;
12183 : :
12184 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_acl_entry->handle,
12185 : : &block_idx, &ram_addr, &etcam_wr_mode);
12186 : :
12187 : 0 : zxdh_np_dtb_etcam_entry_add(dev_id,
12188 : : ram_addr,
12189 : : block_idx,
12190 : : etcam_wr_mode,
12191 : : ZXDH_ETCAM_OPR_DM,
12192 : : &etcam_entry,
12193 : : &entry_data,
12194 : : &entry_mask);
12195 : :
12196 : : dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
12197 : 0 : zxdh_np_dtb_data_write(table_data_buff, addr_offset_bk, &entry_data);
12198 : :
12199 : : memset(entry_data_cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
12200 : : memset(entry_data_buff, 0, ZXDH_ETCAM_WIDTH_MAX / 8);
12201 : 0 : addr_offset_bk = addr_offset_bk + ZXDH_DTB_ETCAM_LEN_SIZE * ZXDH_DTB_LEN_POS_SETP;
12202 : :
12203 : 0 : dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
12204 : 0 : zxdh_np_dtb_data_write(table_data_buff, addr_offset_bk, &entry_mask);
12205 : :
12206 : : memset(entry_mask_cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
12207 : : memset(entry_mask_buff, 0, ZXDH_ETCAM_WIDTH_MAX / 8);
12208 : 0 : addr_offset_bk = addr_offset_bk + ZXDH_DTB_ETCAM_LEN_SIZE * ZXDH_DTB_LEN_POS_SETP;
12209 : :
12210 [ # # ]: 0 : if (as_enable) {
12211 : 0 : uint32_t as_eram_data_buff[4] = {0};
12212 : 0 : uint8_t as_eram_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
12213 : 0 : ZXDH_DTB_ENTRY_T dtb_as_data_entry = {0};
12214 : 0 : uint32_t *p_as_eram_data = (uint32_t *)(p_acl_entry->p_as_rslt);
12215 : 0 : uint32_t eram_index = p_acl_entry->handle;
12216 : :
12217 : 0 : dtb_as_data_entry.cmd = as_eram_cmd_buff;
12218 : 0 : dtb_as_data_entry.data = (uint8_t *)as_eram_data_buff;
12219 : :
12220 : 0 : zxdh_np_dtb_se_smmu0_ind_write(dev_id,
12221 : : as_eram_baddr,
12222 : : eram_index,
12223 : : eram_wrt_mode,
12224 : : p_as_eram_data,
12225 : : &dtb_as_data_entry);
12226 : :
12227 [ # # # ]: 0 : switch (eram_wrt_mode) {
12228 : : case ZXDH_ERAM128_OPR_128b:
12229 : : as_dtb_len = 2;
12230 : : as_addr_offset = ZXDH_DTB_LEN_POS_SETP * 2;
12231 : : break;
12232 : 0 : case ZXDH_ERAM128_OPR_64b:
12233 : : as_dtb_len = 1;
12234 : : as_addr_offset = ZXDH_DTB_LEN_POS_SETP;
12235 : 0 : break;
12236 : 0 : case ZXDH_ERAM128_OPR_1b:
12237 : : as_dtb_len = 1;
12238 : : as_addr_offset = ZXDH_DTB_LEN_POS_SETP;
12239 : 0 : break;
12240 : : }
12241 : :
12242 : 0 : zxdh_np_dtb_data_write(table_data_buff,
12243 : : addr_offset_bk, &dtb_as_data_entry);
12244 : 0 : addr_offset_bk = addr_offset_bk + as_addr_offset;
12245 : 0 : dtb_len += as_dtb_len;
12246 : :
12247 : : memset(as_eram_cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
12248 : : memset(as_eram_data_buff, 0, 4 * sizeof(uint32_t));
12249 : : }
12250 : : }
12251 : :
12252 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
12253 : : queue_id,
12254 : : dtb_len * 16,
12255 : : table_data_buff,
12256 : : element_id);
12257 : 0 : free(table_data_buff);
12258 : :
12259 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, *element_id);
12260 : :
12261 : 0 : return rc;
12262 : : }
12263 : :
12264 : : static uint32_t
12265 : 0 : zxdh_np_dtb_acl_dma_insert(uint32_t dev_id,
12266 : : uint32_t queue_id,
12267 : : uint32_t sdt_no,
12268 : : uint32_t entry_num,
12269 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_acl_entry_arr,
12270 : : uint32_t *element_id)
12271 : : {
12272 : : uint32_t entry_num_max = 0;
12273 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
12274 : :
12275 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
12276 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_data_write");
12277 : :
12278 : 0 : uint32_t as_enable = sdt_etcam_info.as_en;
12279 : 0 : uint32_t etcam_as_mode = sdt_etcam_info.as_rsp_mode;
12280 : :
12281 [ # # ]: 0 : if (!as_enable) {
12282 : : entry_num_max = 0x55;
12283 : : } else {
12284 [ # # ]: 0 : if (etcam_as_mode == ZXDH_ERAM128_TBL_128b)
12285 : : entry_num_max = 0x49;
12286 : : else
12287 : : entry_num_max = 0x4e;
12288 : : }
12289 : :
12290 : 0 : uint32_t entry_cycle = entry_num / entry_num_max;
12291 : 0 : uint32_t entry_remains = entry_num % entry_num_max;
12292 : :
12293 [ # # ]: 0 : for (uint32_t i = 0; i < entry_cycle; ++i) {
12294 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_entry = p_acl_entry_arr + entry_num_max * i;
12295 : 0 : rc = zxdh_np_dtb_acl_dma_insert_cycle(dev_id,
12296 : : queue_id,
12297 : : sdt_no,
12298 : : entry_num_max,
12299 : : p_entry,
12300 : : element_id);
12301 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_dma_insert_cycle");
12302 : : }
12303 : :
12304 [ # # ]: 0 : if (entry_remains) {
12305 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_entry = p_acl_entry_arr + entry_num_max * entry_cycle;
12306 : 0 : rc = zxdh_np_dtb_acl_dma_insert_cycle(dev_id,
12307 : : queue_id,
12308 : : sdt_no,
12309 : : entry_remains,
12310 : : p_entry,
12311 : : element_id);
12312 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_dma_insert_cycle");
12313 : : }
12314 : :
12315 : 0 : return rc;
12316 : : }
12317 : :
12318 : : static uint32_t
12319 : 0 : zxdh_np_dtb_acl_data_clear(uint32_t dev_id, uint32_t queue_id,
12320 : : uint32_t sdt_no, uint32_t index_num, uint32_t *p_index_array)
12321 : : {
12322 : 0 : uint32_t element_id = 0;
12323 : : uint32_t *eram_buff = NULL;
12324 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
12325 : :
12326 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
12327 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12328 : :
12329 : 0 : uint32_t etcam_key_mode = sdt_etcam_info.etcam_key_mode;
12330 : 0 : uint32_t as_enable = sdt_etcam_info.as_en;
12331 : 0 : uint32_t data_byte_size = ZXDH_ETCAM_ENTRY_SIZE_GET(etcam_key_mode);
12332 : :
12333 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_entry_arr = malloc(index_num *
12334 : : sizeof(ZXDH_DTB_ACL_ENTRY_INFO_T));
12335 [ # # ]: 0 : if (p_entry_arr == NULL) {
12336 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12337 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12338 : : }
12339 : :
12340 : 0 : uint8_t *data_buff = malloc(data_byte_size);
12341 [ # # ]: 0 : if (data_buff == NULL) {
12342 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
12343 : 0 : free(p_entry_arr);
12344 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12345 : : }
12346 : :
12347 : 0 : uint8_t *mask_buff = malloc(data_byte_size);
12348 [ # # ]: 0 : if (mask_buff == NULL) {
12349 : 0 : PMD_DRV_LOG(ERR, "mask_buff point null!");
12350 : 0 : free(data_buff);
12351 : 0 : free(p_entry_arr);
12352 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12353 : : }
12354 : :
12355 [ # # ]: 0 : if (as_enable) {
12356 : 0 : eram_buff = malloc(4 * sizeof(uint32_t));
12357 [ # # ]: 0 : if (eram_buff == NULL) {
12358 : 0 : PMD_DRV_LOG(ERR, "eram_buff point null!");
12359 : 0 : free(mask_buff);
12360 : 0 : free(data_buff);
12361 : 0 : free(p_entry_arr);
12362 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12363 : : }
12364 : : memset(eram_buff, 0, 4 * sizeof(uint32_t));
12365 : : }
12366 : :
12367 [ # # ]: 0 : for (uint32_t index = 0; index < index_num; index++) {
12368 : 0 : p_entry_arr[index].handle = p_index_array[index];
12369 : 0 : p_entry_arr[index].key_data = data_buff;
12370 : 0 : p_entry_arr[index].key_mask = mask_buff;
12371 : :
12372 [ # # ]: 0 : if (as_enable)
12373 : 0 : p_entry_arr[index].p_as_rslt = (uint8_t *)eram_buff;
12374 : : }
12375 : :
12376 : 0 : rc = zxdh_np_dtb_acl_dma_insert(dev_id,
12377 : : queue_id,
12378 : : sdt_no,
12379 : : index_num,
12380 : : p_entry_arr,
12381 : : &element_id);
12382 : 0 : free(data_buff);
12383 : 0 : free(mask_buff);
12384 [ # # ]: 0 : if (eram_buff)
12385 : 0 : free(eram_buff);
12386 : :
12387 : 0 : free(p_entry_arr);
12388 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_dma_insert");
12389 : :
12390 : : return rc;
12391 : : }
12392 : :
12393 : : static uint32_t
12394 : 0 : zxdh_np_dtb_acl_index_release_by_vport(uint32_t dev_id,
12395 : : uint32_t sdt_no, uint32_t vport)
12396 : : {
12397 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
12398 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
12399 : :
12400 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
12401 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12402 [ # # ]: 0 : if (sdt_acl.table_type != ZXDH_SDT_TBLT_ETCAM) {
12403 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
12404 : : sdt_no, sdt_acl.table_type);
12405 : 0 : return ZXDH_ERR;
12406 : : }
12407 : :
12408 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
12409 : :
12410 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
12411 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12412 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
12413 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
12414 : : eram_sdt_no, sdt_eram.table_type);
12415 : 0 : return ZXDH_ERR;
12416 : : }
12417 : :
12418 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
12419 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
12420 : :
12421 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
12422 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
12423 : :
12424 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
12425 : :
12426 : 0 : rc = zxdh_np_agent_channel_acl_index_release(dev_id,
12427 : : ZXDH_ACL_INDEX_VPORT_REL, sdt_no, vport, 0);
12428 [ # # ]: 0 : if (rc == ZXDH_ACL_RC_SRH_FAIL)
12429 : 0 : PMD_DRV_LOG(ERR, "ACL_INDEX_VPORT_REL[vport:0x%x] index is not exist.", vport);
12430 : :
12431 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
12432 : :
12433 : 0 : return rc;
12434 : : }
12435 : :
12436 : : static uint32_t
12437 : 0 : zxdh_np_dtb_smmu0_data_write_cycle(uint32_t dev_id,
12438 : : uint32_t queue_id,
12439 : : uint32_t smmu0_base_addr,
12440 : : uint32_t smmu0_wr_mode,
12441 : : uint32_t entry_num,
12442 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry_arr,
12443 : : uint32_t *element_id)
12444 : : {
12445 : 0 : uint32_t entry_data_buff[4] = {0};
12446 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
12447 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
12448 : :
12449 : 0 : uint8_t *table_data_buff = malloc(ZXDH_DTB_TABLE_DATA_BUFF_SIZE);
12450 [ # # ]: 0 : if (table_data_buff == NULL) {
12451 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12452 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12453 : : }
12454 : :
12455 : 0 : dtb_one_entry.cmd = cmd_buff;
12456 : 0 : dtb_one_entry.data = (uint8_t *)entry_data_buff;
12457 : :
12458 : : uint32_t rc = ZXDH_OK;
12459 : : uint32_t addr_offset = 0;
12460 : : uint32_t dtb_len = 0;
12461 : :
12462 [ # # ]: 0 : for (uint32_t item_cnt = 0; item_cnt < entry_num; ++item_cnt) {
12463 : 0 : uint32_t *p_entry_data = (uint32_t *)p_entry_arr[item_cnt].p_data;
12464 : 0 : uint32_t index = p_entry_arr[item_cnt].index;
12465 : :
12466 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
12467 : : smmu0_base_addr,
12468 : : index,
12469 : : smmu0_wr_mode,
12470 : : p_entry_data,
12471 : : &dtb_one_entry);
12472 : :
12473 [ # # # # ]: 0 : switch (smmu0_wr_mode) {
12474 : 0 : case ZXDH_ERAM128_OPR_128b:
12475 : 0 : dtb_len += 2;
12476 : 0 : addr_offset = item_cnt * ZXDH_DTB_LEN_POS_SETP * 2;
12477 : 0 : break;
12478 : 0 : case ZXDH_ERAM128_OPR_64b:
12479 : 0 : dtb_len += 1;
12480 : 0 : addr_offset = item_cnt * ZXDH_DTB_LEN_POS_SETP;
12481 : 0 : break;
12482 : 0 : case ZXDH_ERAM128_OPR_1b:
12483 : 0 : dtb_len += 1;
12484 : 0 : addr_offset = item_cnt * ZXDH_DTB_LEN_POS_SETP;
12485 : 0 : break;
12486 : : }
12487 : :
12488 : 0 : zxdh_np_dtb_data_write(table_data_buff, addr_offset, &dtb_one_entry);
12489 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
12490 : : memset(entry_data_buff, 0, 4 * sizeof(uint32_t));
12491 : : }
12492 : :
12493 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
12494 : : queue_id,
12495 : : dtb_len * 16,
12496 : : table_data_buff,
12497 : : element_id);
12498 : 0 : free(table_data_buff);
12499 : :
12500 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, *element_id);
12501 : :
12502 : 0 : return rc;
12503 : : }
12504 : :
12505 : : static uint32_t
12506 [ # # ]: 0 : zxdh_np_dtb_smmu0_data_write(uint32_t dev_id,
12507 : : uint32_t queue_id,
12508 : : uint32_t smmu0_base_addr,
12509 : : uint32_t smmu0_wr_mode,
12510 : : uint32_t entry_num,
12511 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry_arr,
12512 : : uint32_t *element_id)
12513 : : {
12514 : : uint32_t entry_num_max = 0;
12515 : :
12516 : : switch (smmu0_wr_mode) {
12517 : : case ZXDH_ERAM128_OPR_128b:
12518 : : entry_num_max = 0x1ff;
12519 : : break;
12520 : : case ZXDH_ERAM128_OPR_64b:
12521 : : entry_num_max = 0x3ff;
12522 : : break;
12523 : : case ZXDH_ERAM128_OPR_1b:
12524 : : entry_num_max = 0x3ff;
12525 : : break;
12526 : : }
12527 : :
12528 : 0 : uint32_t entry_cycle = entry_num / entry_num_max;
12529 : 0 : uint32_t entry_remains = entry_num % entry_num_max;
12530 : : uint32_t rc = ZXDH_OK;
12531 : :
12532 [ # # ]: 0 : for (uint32_t i = 0; i < entry_cycle; ++i) {
12533 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry = p_entry_arr + entry_num_max * i;
12534 : 0 : rc = zxdh_np_dtb_smmu0_data_write_cycle(dev_id,
12535 : : queue_id,
12536 : : smmu0_base_addr,
12537 : : smmu0_wr_mode,
12538 : : entry_num_max,
12539 : : p_entry,
12540 : : element_id);
12541 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_data_write_cycle");
12542 : : }
12543 : :
12544 [ # # ]: 0 : if (entry_remains) {
12545 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry = p_entry_arr + entry_num_max * entry_cycle;
12546 : 0 : rc = zxdh_np_dtb_smmu0_data_write_cycle(dev_id,
12547 : : queue_id,
12548 : : smmu0_base_addr,
12549 : : smmu0_wr_mode,
12550 : : entry_remains,
12551 : : p_entry,
12552 : : element_id);
12553 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_data_write_cycle");
12554 : : }
12555 : :
12556 : 0 : return rc;
12557 : : }
12558 : :
12559 : : static uint32_t
12560 : 0 : zxdh_np_dtb_eram_dma_write(uint32_t dev_id,
12561 : : uint32_t queue_id,
12562 : : uint32_t sdt_no,
12563 : : uint32_t entry_num,
12564 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry_arr,
12565 : : uint32_t *element_id)
12566 : : {
12567 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram_info = {0};
12568 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram_info);
12569 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12570 : :
12571 : 0 : uint32_t base_addr = sdt_eram_info.eram_base_addr;
12572 : 0 : uint32_t wrt_mode = sdt_eram_info.eram_mode;
12573 : :
12574 [ # # # # ]: 0 : switch (wrt_mode) {
12575 : 0 : case ZXDH_ERAM128_TBL_128b:
12576 : : wrt_mode = ZXDH_ERAM128_OPR_128b;
12577 : 0 : break;
12578 : 0 : case ZXDH_ERAM128_TBL_64b:
12579 : : wrt_mode = ZXDH_ERAM128_OPR_64b;
12580 : 0 : break;
12581 : 0 : case ZXDH_ERAM128_TBL_1b:
12582 : : wrt_mode = ZXDH_ERAM128_OPR_1b;
12583 : 0 : break;
12584 : : }
12585 : :
12586 : 0 : rc = zxdh_np_dtb_smmu0_data_write(dev_id,
12587 : : queue_id,
12588 : : base_addr,
12589 : : wrt_mode,
12590 : : entry_num,
12591 : : p_entry_arr,
12592 : : element_id);
12593 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_data_write");
12594 : :
12595 : 0 : return ZXDH_OK;
12596 : : }
12597 : :
12598 : : static uint32_t
12599 : 0 : zxdh_np_dtb_eram_data_clear(uint32_t dev_id,
12600 : : uint32_t queue_id,
12601 : : uint32_t sdt_no,
12602 : : uint32_t index_num,
12603 : : uint32_t *p_index_array)
12604 : : {
12605 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_eram_data_arr = malloc(index_num *
12606 : : sizeof(ZXDH_DTB_ERAM_ENTRY_INFO_T));
12607 [ # # ]: 0 : if (p_eram_data_arr == NULL) {
12608 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12609 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12610 : : }
12611 : :
12612 : 0 : uint8_t *data_buff = malloc(4 * sizeof(uint32_t));
12613 [ # # ]: 0 : if (data_buff == NULL) {
12614 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
12615 : 0 : free(p_eram_data_arr);
12616 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12617 : : }
12618 : :
12619 [ # # ]: 0 : for (uint32_t i = 0; i < index_num; i++) {
12620 : 0 : p_eram_data_arr[i].index = p_index_array[i];
12621 : 0 : p_eram_data_arr[i].p_data = (uint32_t *)data_buff;
12622 : : }
12623 : :
12624 : 0 : uint32_t element_id = 0;
12625 : 0 : uint32_t rc = zxdh_np_dtb_eram_dma_write(dev_id, queue_id,
12626 : : sdt_no, index_num, p_eram_data_arr, &element_id);
12627 : 0 : free(data_buff);
12628 : 0 : free(p_eram_data_arr);
12629 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_eram_dma_write");
12630 : :
12631 : : return rc;
12632 : : }
12633 : :
12634 : : static uint32_t
12635 : 0 : zxdh_np_dtb_eram_stat_data_clear(uint32_t dev_id,
12636 : : uint32_t queue_id,
12637 : : uint32_t counter_id,
12638 : : ZXDH_STAT_CNT_MODE_E rd_mode,
12639 : : uint32_t index_num,
12640 : : uint32_t *p_index_array)
12641 : : {
12642 : 0 : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
12643 : 0 : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
12644 : :
12645 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_eram_data_arr = malloc(index_num *
12646 : : sizeof(ZXDH_DTB_ERAM_ENTRY_INFO_T));
12647 [ # # ]: 0 : if (p_eram_data_arr == NULL) {
12648 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12649 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12650 : : }
12651 : :
12652 : 0 : uint8_t *data_buff = malloc(4 * sizeof(uint32_t));
12653 [ # # ]: 0 : if (data_buff == NULL) {
12654 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
12655 : 0 : free(p_eram_data_arr);
12656 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12657 : : }
12658 : :
12659 [ # # ]: 0 : for (uint32_t i = 0; i < index_num; i++) {
12660 : 0 : p_eram_data_arr[i].index = p_index_array[i];
12661 : 0 : p_eram_data_arr[i].p_data = (uint32_t *)data_buff;
12662 : : }
12663 : :
12664 : 0 : uint32_t wrt_mode = (rd_mode == ZXDH_STAT_128_MODE) ?
12665 : 0 : ZXDH_ERAM128_OPR_128b : ZXDH_ERAM128_OPR_64b;
12666 : : uint32_t counter_id_128bit = (rd_mode == ZXDH_STAT_128_MODE) ?
12667 [ # # ]: 0 : counter_id : (counter_id >> 1);
12668 : 0 : uint32_t start_addr = stat_cfg.eram_baddr + counter_id_128bit;
12669 : 0 : uint32_t element_id = 0;
12670 : 0 : uint32_t rc = zxdh_np_dtb_smmu0_data_write(dev_id,
12671 : : queue_id,
12672 : : start_addr,
12673 : : wrt_mode,
12674 : : index_num,
12675 : : p_eram_data_arr,
12676 : : &element_id);
12677 : 0 : free(data_buff);
12678 : 0 : free(p_eram_data_arr);
12679 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_data_write");
12680 : :
12681 : : return rc;
12682 : : }
12683 : :
12684 : : uint32_t
12685 : 0 : zxdh_np_dtb_acl_offline_delete(uint32_t dev_id, uint32_t queue_id,
12686 : : uint32_t sdt_no, uint32_t vport, uint32_t counter_id, uint32_t rd_mode)
12687 : : {
12688 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
12689 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
12690 : 0 : uint32_t index_num = 0;
12691 : :
12692 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
12693 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12694 [ # # ]: 0 : if (sdt_acl.table_type != ZXDH_SDT_TBLT_ETCAM) {
12695 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
12696 : : sdt_no, sdt_acl.table_type);
12697 : 0 : return ZXDH_ERR;
12698 : : }
12699 : :
12700 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
12701 : :
12702 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
12703 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12704 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
12705 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
12706 : : eram_sdt_no, sdt_eram.table_type);
12707 : 0 : return ZXDH_ERR;
12708 : : }
12709 : :
12710 : 0 : uint32_t *p_index_array = malloc(sizeof(uint32_t) * sdt_eram.eram_table_depth);
12711 [ # # ]: 0 : if (p_index_array == NULL) {
12712 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12713 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12714 : : }
12715 : :
12716 : 0 : rc = zxdh_np_dtb_acl_index_parse(dev_id, queue_id,
12717 : : eram_sdt_no, vport, &index_num, p_index_array);
12718 [ # # ]: 0 : if (rc != ZXDH_OK) {
12719 : 0 : free(p_index_array);
12720 : 0 : PMD_DRV_LOG(ERR, "acl index parse failed");
12721 : 0 : return ZXDH_ERR;
12722 : : }
12723 : :
12724 [ # # ]: 0 : if (!index_num) {
12725 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] vport[0x%x] item num is zero!", sdt_no, vport);
12726 : 0 : free(p_index_array);
12727 : 0 : return ZXDH_OK;
12728 : : }
12729 : :
12730 : 0 : rc = zxdh_np_dtb_acl_data_clear(dev_id, queue_id, sdt_no, index_num, p_index_array);
12731 : 0 : rc = zxdh_np_dtb_eram_data_clear(dev_id, queue_id, eram_sdt_no, index_num, p_index_array);
12732 : 0 : rc = zxdh_np_dtb_eram_stat_data_clear(dev_id, queue_id,
12733 : : counter_id, rd_mode, index_num, p_index_array);
12734 : 0 : free(p_index_array);
12735 : :
12736 : 0 : rc = zxdh_np_dtb_acl_index_release_by_vport(dev_id, sdt_no, vport);
12737 : :
12738 : 0 : return rc;
12739 : : }
|
