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 : :
3702 [ # # ]: 0 : if ((*p_item_num & ZXDH_DTB_SPACE_LEFT_MASK) == ZXDH_DTB_SPACE_LEFT_MASK) {
3703 : 0 : PMD_DRV_LOG(ERR, "pcie bar abnormal.");
3704 : 0 : return ZXDH_RC_DTB_BAR_ABNORMAL;
3705 : : }
3706 : :
3707 : : return rc;
3708 : : }
3709 : :
3710 : : static uint32_t
3711 : 0 : zxdh_np_dtb_queue_id_free(uint32_t dev_id,
3712 : : uint32_t queue_id)
3713 : : {
3714 : 0 : uint32_t item_num = 0;
3715 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
3716 : : uint32_t rc;
3717 : :
3718 : 0 : p_dtb_mgr = p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)];
3719 [ # # ]: 0 : if (p_dtb_mgr == NULL)
3720 : : return 1;
3721 : :
3722 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &item_num);
3723 : :
3724 [ # # ]: 0 : if (item_num != ZXDH_DTB_QUEUE_ITEM_NUM_MAX)
3725 : : return ZXDH_RC_DTB_QUEUE_IS_WORKING;
3726 : :
3727 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 0;
3728 : 0 : p_dtb_mgr->queue_info[queue_id].vport = 0;
3729 : 0 : p_dtb_mgr->queue_info[queue_id].vector = 0;
3730 : :
3731 : 0 : memset(&p_dtb_mgr->queue_info[queue_id].tab_up, 0, sizeof(ZXDH_DTB_TAB_UP_INFO_T));
3732 : 0 : memset(&p_dtb_mgr->queue_info[queue_id].tab_down, 0, sizeof(ZXDH_DTB_TAB_DOWN_INFO_T));
3733 : :
3734 : 0 : return rc;
3735 : : }
3736 : :
3737 : : static ZXDH_RB_CFG *
3738 : : zxdh_np_dtb_dump_addr_rb_get(uint32_t dev_id, uint32_t queue_id)
3739 : : {
3740 : 0 : return g_dtb_dump_addr_rb[ZXDH_DEV_SLOT_ID(dev_id)][queue_id];
3741 : : }
3742 : :
3743 : : static uint32_t
3744 : : zxdh_np_dtb_dump_addr_rb_set(uint32_t dev_id, uint32_t queue_id, ZXDH_RB_CFG *p_dump_addr_rb)
3745 : : {
3746 : 0 : g_dtb_dump_addr_rb[ZXDH_DEV_SLOT_ID(dev_id)][queue_id] = p_dump_addr_rb;
3747 : : return ZXDH_OK;
3748 : : }
3749 : :
3750 : : static uint32_t
3751 : 0 : zxdh_np_dtb_dump_sdt_addr_clear(uint32_t dev_id,
3752 : : uint32_t queue_id,
3753 : : uint32_t sdt_no)
3754 : : {
3755 : : uint32_t rc = ZXDH_OK;
3756 : :
3757 : 0 : ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {0};
3758 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
3759 : :
3760 : 0 : dtb_dump_addr_info.sdt_no = sdt_no;
3761 : :
3762 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
3763 : 0 : rc = zxdh_np_se_apt_rb_delete(p_dtb_dump_addr_rb, &dtb_dump_addr_info,
3764 : : sizeof(ZXDH_DTB_ADDR_INFO_T));
3765 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_apt_rb_delete");
3766 : :
3767 : 0 : return rc;
3768 : : }
3769 : :
3770 : : static uint32_t
3771 : 0 : zxdh_np_dtb_dump_addr_rb_destroy(uint32_t dev_id, uint32_t queue_id)
3772 : : {
3773 : : uint32_t rc = ZXDH_OK;
3774 : : ZXDH_D_NODE *p_node = NULL;
3775 : : ZXDH_RB_TN *p_rb_tn = NULL;
3776 : : ZXDH_DTB_ADDR_INFO_T *p_rbkey = NULL;
3777 : : ZXDH_D_HEAD *p_head_dtb_rb = NULL;
3778 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
3779 : : uint32_t sdt_no = 0;
3780 : :
3781 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
3782 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dtb_dump_addr_rb);
3783 : :
3784 : : p_head_dtb_rb = &p_dtb_dump_addr_rb->tn_list;
3785 : :
3786 [ # # ]: 0 : while (p_head_dtb_rb->used) {
3787 : 0 : p_node = p_head_dtb_rb->p_next;
3788 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
3789 : 0 : p_rbkey = (ZXDH_DTB_ADDR_INFO_T *)p_rb_tn->p_key;
3790 : :
3791 : 0 : sdt_no = p_rbkey->sdt_no;
3792 : 0 : rc = zxdh_np_dtb_dump_sdt_addr_clear(dev_id, queue_id, sdt_no);
3793 : :
3794 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
3795 : 0 : PMD_DRV_LOG(ERR, "dtb dump delete key is not exist,"
3796 : : "std:%u", sdt_no);
3797 : : else
3798 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_clear");
3799 : : }
3800 : :
3801 : 0 : rc = zxdh_comm_rb_destroy(p_dtb_dump_addr_rb);
3802 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
3803 : :
3804 : 0 : return rc;
3805 : : }
3806 : :
3807 : : static uint32_t
3808 : 0 : zxdh_np_dtb_dump_addr_rb_init(uint32_t dev_id, uint32_t queue_id)
3809 : : {
3810 : : uint32_t rc = ZXDH_OK;
3811 : :
3812 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
3813 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
3814 : :
3815 [ # # ]: 0 : if (p_dtb_dump_addr_rb == NULL) {
3816 : 0 : p_dtb_dump_addr_rb = rte_zmalloc(NULL, sizeof(ZXDH_RB_CFG), 0);
3817 [ # # ]: 0 : if (p_dtb_dump_addr_rb == NULL) {
3818 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
3819 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
3820 : : }
3821 : :
3822 : : rc = zxdh_np_dtb_dump_addr_rb_set(dev_id, queue_id, p_dtb_dump_addr_rb);
3823 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_rb_set");
3824 : : }
3825 : :
3826 : 0 : rc = zxdh_comm_rb_init(p_dtb_dump_addr_rb, 0,
3827 : : sizeof(ZXDH_DTB_ADDR_INFO_T), zxdh_np_se_apt_key_default_cmp);
3828 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
3829 : :
3830 : : return rc;
3831 : : }
3832 : :
3833 : : static uint32_t
3834 : 0 : zxdh_np_dtb_queue_request(uint32_t dev_id, char p_name[32],
3835 : : uint16_t vport, uint32_t *p_queue_id)
3836 : : {
3837 : : uint32_t rc = ZXDH_OK;
3838 : 0 : uint32_t queue_id = 0xFF;
3839 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
3840 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
3841 : 0 : uint32_t vport_info = (uint32_t)vport;
3842 : :
3843 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
3844 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
3845 : :
3846 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
3847 : :
3848 : 0 : rc = zxdh_np_agent_channel_dtb_queue_request(dev_id, p_name, vport_info, &queue_id);
3849 [ # # ]: 0 : if (rc == ZXDH_RC_DTB_QUEUE_RES_EMPTY) {
3850 : 0 : PMD_DRV_LOG(ERR, "dtb queue is locked full.");
3851 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3852 : 0 : return ZXDH_RC_DTB_QUEUE_RES_EMPTY;
3853 : : }
3854 : :
3855 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3856 : :
3857 : 0 : PMD_DRV_LOG(DEBUG, "dtb request queue is %u.", queue_id);
3858 : :
3859 : 0 : rc = zxdh_np_dtb_dump_addr_rb_init(dev_id, queue_id);
3860 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_rb_init");
3861 : :
3862 : 0 : *p_queue_id = queue_id;
3863 : :
3864 : 0 : PMD_DRV_LOG(INFO, "dev_id %u vport 0x%x name %s queue_id %u done.",
3865 : : dev_id, vport_info, p_name, queue_id);
3866 : :
3867 : 0 : return rc;
3868 : : }
3869 : :
3870 : : static uint32_t
3871 : 0 : zxdh_np_dtb_queue_release(uint32_t devid,
3872 : : char pname[32],
3873 : : uint32_t queueid)
3874 : : {
3875 : : uint32_t rc = ZXDH_OK;
3876 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
3877 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
3878 : :
3879 : 0 : rc = zxdh_np_dev_opr_spinlock_get(devid, (uint32_t)spinlock, &p_dtb_spinlock);
3880 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dev_opr_spinlock_get");
3881 : :
3882 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
3883 : :
3884 : 0 : rc = zxdh_np_agent_channel_dtb_queue_release(devid, pname, queueid);
3885 : :
3886 [ # # ]: 0 : if (rc == ZXDH_RC_DTB_QUEUE_NOT_ALLOC) {
3887 : 0 : PMD_DRV_LOG(ERR, "dtb queue id %u not request.", queueid);
3888 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3889 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ALLOC;
3890 : : }
3891 : :
3892 [ # # ]: 0 : if (rc == ZXDH_RC_DTB_QUEUE_NAME_ERROR) {
3893 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u name error.", queueid);
3894 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3895 : 0 : return ZXDH_RC_DTB_QUEUE_NAME_ERROR;
3896 : : }
3897 : :
3898 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3899 : :
3900 : 0 : rc = zxdh_np_dtb_dump_addr_rb_destroy(devid, queueid);
3901 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dtb_dump_addr_rb_destroy");
3902 : :
3903 : 0 : rc = zxdh_np_dtb_queue_id_free(devid, queueid);
3904 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dtb_queue_id_free");
3905 : :
3906 : 0 : PMD_DRV_LOG(INFO, "release queueid %u", queueid);
3907 : :
3908 : 0 : return rc;
3909 : : }
3910 : :
3911 : : static void
3912 : : zxdh_np_dtb_mgr_destroy(uint32_t dev_id)
3913 : : {
3914 [ # # ]: 0 : if (p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)] != NULL) {
3915 : 0 : rte_free(p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)]);
3916 : 0 : p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)] = NULL;
3917 : : }
3918 : : }
3919 : :
3920 : : static void
3921 : 0 : zxdh_np_sdt_mgr_destroy(uint32_t dev_id)
3922 : : {
3923 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_tbl_temp = NULL;
3924 : : ZXDH_SDT_MGR_T *p_sdt_mgr = NULL;
3925 : :
3926 : 0 : p_sdt_tbl_temp = ZXDH_SDT_SOFT_TBL_GET(dev_id);
3927 : : p_sdt_mgr = ZXDH_SDT_MGR_PTR_GET();
3928 : :
3929 : 0 : rte_free(p_sdt_tbl_temp);
3930 : :
3931 : 0 : ZXDH_SDT_SOFT_TBL_GET(dev_id) = NULL;
3932 : :
3933 : 0 : p_sdt_mgr->channel_num--;
3934 : 0 : }
3935 : :
3936 : : static void
3937 : 0 : zxdh_np_dev_del(uint32_t dev_id)
3938 : : {
3939 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
3940 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
3941 : :
3942 : : p_dev_mgr = &g_dev_mgr;
3943 : 0 : p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
3944 : :
3945 [ # # ]: 0 : if (p_dev_info != NULL) {
3946 : 0 : rte_free(p_dev_info);
3947 : 0 : p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)] = NULL;
3948 : 0 : p_dev_mgr->device_num--;
3949 : : }
3950 : 0 : }
3951 : :
3952 : : static uint32_t
3953 : 0 : zxdh_np_hash_soft_all_entry_delete(ZXDH_SE_CFG *p_se_cfg, uint32_t hash_id)
3954 : : {
3955 : : uint32_t rc = 0;
3956 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
3957 : : uint8_t table_id = 0;
3958 : : uint32_t bulk_id = 0;
3959 : :
3960 : : ZXDH_D_NODE *p_node = NULL;
3961 : : ZXDH_RB_TN *p_rb_tn = NULL;
3962 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
3963 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
3964 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
3965 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
3966 : : ZXDH_FUNC_ID_INFO *p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, hash_id);
3967 : 0 : ZXDH_HASH_CFG *p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
3968 : : ZXDH_D_HEAD *p_head_hash_rb = &p_hash_cfg->hash_rb.tn_list;
3969 : :
3970 [ # # ]: 0 : while (p_head_hash_rb->used) {
3971 : 0 : p_node = p_head_hash_rb->p_next;
3972 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
3973 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_rb_tn->p_key;
3974 : 0 : table_id = ZXDH_GET_HASH_TBL_ID(p_rbkey->key);
3975 : 0 : bulk_id = ((table_id >> 2) & 0x7);
3976 : :
3977 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, p_rbkey, &p_rb_tn_rtn);
3978 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL) {
3979 : 0 : p_hash_cfg->hash_stat.delete_fail++;
3980 : 0 : PMD_DRV_LOG(DEBUG, "Error!there is not item in hash!");
3981 : 0 : return ZXDH_HASH_RC_DEL_SRHFAIL;
3982 : : }
3983 : :
3984 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
3985 : 0 : p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
3986 [ # # ]: 0 : p_item = p_rbkey_rtn->p_item_info;
3987 : :
3988 : : rc = zxdh_comm_double_link_del(&p_rbkey_rtn->entry_dn, &p_item->item_list);
3989 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
3990 : 0 : p_item->wrt_mask &= ~(ZXDH_GET_HASH_ENTRY_MASK(p_rbkey_rtn->entry_size,
3991 : 0 : p_rbkey_rtn->entry_pos)) & 0xF;
3992 : :
3993 [ # # ]: 0 : if (p_item->item_list.used == 0) {
3994 [ # # ]: 0 : if (p_item->item_type == ZXDH_ITEM_DDR_256 ||
3995 : : p_item->item_type == ZXDH_ITEM_DDR_512) {
3996 : 0 : p_hash_cfg->p_bulk_ddr_info[bulk_id]->p_item_array
3997 : 0 : [p_item->item_index] = NULL;
3998 : 0 : rte_free(p_item);
3999 : : } else {
4000 : 0 : p_item->valid = 0;
4001 : : }
4002 : : }
4003 : :
4004 : 0 : rte_free(p_rbkey_rtn);
4005 : 0 : rte_free(p_rb_tn_rtn);
4006 : 0 : p_hash_cfg->hash_stat.delete_ok++;
4007 : : }
4008 : :
4009 : : return rc;
4010 : : }
4011 : :
4012 : : static uint32_t
4013 : 0 : zxdh_np_hash_zcam_resource_deinit(ZXDH_HASH_CFG *p_hash_cfg)
4014 : : {
4015 : : uint32_t rc = 0;
4016 : 0 : uint32_t dev_id = p_hash_cfg->p_se_info->dev_id;
4017 : : uint32_t i = 0;
4018 : :
4019 : : ZXDH_D_NODE *p_node = NULL;
4020 : : ZXDH_D_HEAD *p_head = &p_hash_cfg->hash_shareram.zcell_free_list;
4021 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
4022 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
4023 : :
4024 [ # # ]: 0 : while (p_head->used) {
4025 [ # # ]: 0 : p_node = p_head->p_next;
4026 : :
4027 : : rc = zxdh_comm_double_link_del(p_node, p_head);
4028 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
4029 : 0 : p_zcell_cfg = (ZXDH_SE_ZCELL_CFG *)p_node->data;
4030 : 0 : p_zcell_cfg->is_used = 0;
4031 : 0 : p_zcell_cfg->flag = 0;
4032 : : }
4033 : :
4034 : : p_head = &p_hash_cfg->hash_shareram.zblk_list;
4035 : :
4036 [ # # ]: 0 : while (p_head->used) {
4037 [ # # ]: 0 : p_node = p_head->p_next;
4038 : :
4039 : : rc = zxdh_comm_double_link_del(p_node, p_head);
4040 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
4041 : :
4042 : 0 : p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_hash_cfg->p_se_info,
4043 : : ((ZXDH_SE_ZBLK_CFG *)p_node->data)->zblk_idx);
4044 : 0 : p_zblk_cfg->is_used = 0;
4045 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++)
4046 : 0 : p_zblk_cfg->zreg_info[i].flag = 0;
4047 : : }
4048 : :
4049 : 0 : return rc;
4050 : : }
4051 : :
4052 : : static uint32_t
4053 : 0 : zxdh_np_se_fun_deinit(ZXDH_SE_CFG *p_se_cfg,
4054 : : uint8_t id,
4055 : : uint32_t fun_type)
4056 : : {
4057 : 0 : ZXDH_FUNC_ID_INFO *p_fun_info = ZXDH_GET_FUN_INFO(p_se_cfg, id);
4058 : :
4059 [ # # ]: 0 : if (p_fun_info->is_used == 0) {
4060 : 0 : PMD_DRV_LOG(ERR, " Error[0x%x], fun_id [%u] is already deinit!",
4061 : : ZXDH_SE_RC_FUN_INVALID, id);
4062 : 0 : return ZXDH_OK;
4063 : : }
4064 : :
4065 [ # # ]: 0 : switch (fun_type) {
4066 : 0 : case (ZXDH_FUN_HASH):
4067 [ # # ]: 0 : if (p_fun_info->fun_ptr) {
4068 : 0 : rte_free(p_fun_info->fun_ptr);
4069 : 0 : p_fun_info->fun_ptr = NULL;
4070 : : }
4071 : : break;
4072 : 0 : default:
4073 : 0 : PMD_DRV_LOG(ERR, " Error, unrecgnized fun_type[ %u] ", fun_type);
4074 : : RTE_ASSERT(0);
4075 : 0 : return ZXDH_SE_RC_BASE;
4076 : : }
4077 : :
4078 : 0 : p_fun_info->fun_id = id;
4079 : 0 : p_fun_info->is_used = 0;
4080 : :
4081 : 0 : return ZXDH_OK;
4082 : : }
4083 : :
4084 : : static uint32_t
4085 : 0 : zxdh_np_one_hash_soft_uninstall(uint32_t dev_id, uint32_t hash_id)
4086 : : {
4087 : : uint32_t rc = 0;
4088 : : uint32_t i = 0;
4089 : :
4090 : : ZXDH_D_NODE *p_node = NULL;
4091 : 0 : ZXDH_SE_CFG *p_se_cfg = dpp_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
4092 : : ZXDH_RB_TN *p_rb_tn = NULL;
4093 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
4094 : : HASH_DDR_CFG *p_rbkey = NULL;
4095 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
4096 : : ZXDH_FUNC_ID_INFO *p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, hash_id);
4097 : : ZXDH_D_HEAD *p_head_ddr_cfg_rb = NULL;
4098 : : HASH_DDR_CFG *p_temp_rbkey = NULL;
4099 : :
4100 [ # # ]: 0 : if (p_func_info->is_used == 0) {
4101 : 0 : PMD_DRV_LOG(DEBUG, "Error[0x%x], fun_id [%u] is not init!",
4102 : : ZXDH_SE_RC_FUN_INVALID, hash_id);
4103 : 0 : return ZXDH_OK;
4104 : : }
4105 : :
4106 : 0 : rc = zxdh_np_hash_soft_all_entry_delete(p_se_cfg, hash_id);
4107 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_soft_all_entry_delete");
4108 : :
4109 : 0 : p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
4110 [ # # ]: 0 : for (i = 0; i < ZXDH_HASH_BULK_NUM; i++) {
4111 [ # # ]: 0 : if (p_hash_cfg->hash_stat.p_bulk_zcam_mono[i] != NULL) {
4112 : 0 : rte_free((&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[i]);
4113 : 0 : (&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[i] = NULL;
4114 : : }
4115 : : }
4116 : :
4117 : : p_head_ddr_cfg_rb = &p_hash_cfg->ddr_cfg_rb.tn_list;
4118 [ # # ]: 0 : while (p_head_ddr_cfg_rb->used) {
4119 : 0 : p_node = p_head_ddr_cfg_rb->p_next;
4120 : :
4121 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
4122 : 0 : p_rbkey = p_rb_tn->p_key;
4123 : :
4124 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->ddr_cfg_rb, p_rbkey, &p_rb_tn_rtn);
4125 : :
4126 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL)
4127 : 0 : PMD_DRV_LOG(ERR, "ddr_cfg_rb delete key is not exist, key: 0x");
4128 : : else
4129 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_delete");
4130 : :
4131 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
4132 : 0 : p_temp_rbkey = (HASH_DDR_CFG *)(p_rb_tn_rtn->p_key);
4133 : 0 : rte_free(p_temp_rbkey->p_item_array);
4134 : 0 : p_temp_rbkey->p_item_array = NULL;
4135 : 0 : rte_free(p_temp_rbkey);
4136 : 0 : rte_free(p_rb_tn_rtn);
4137 : : }
4138 : :
4139 : 0 : rc = zxdh_np_hash_zcam_resource_deinit(p_hash_cfg);
4140 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_zcam_resource_deinit");
4141 : :
4142 : 0 : rc = zxdh_np_se_fun_deinit(p_se_cfg, (hash_id & 0xff), ZXDH_FUN_HASH);
4143 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_fun_deinit");
4144 : :
4145 : 0 : memset(g_tbl_id_info[ZXDH_DEV_SLOT_ID(dev_id)][hash_id], 0,
4146 : : ZXDH_HASH_TBL_ID_NUM * sizeof(ZXDH_HASH_TBL_ID_INFO));
4147 : :
4148 : 0 : return rc;
4149 : : }
4150 : :
4151 : : static uint32_t
4152 : 0 : zxdh_np_hash_soft_uninstall(uint32_t dev_id)
4153 : : {
4154 : : uint32_t rc = ZXDH_OK;
4155 : : uint32_t hash_id = 0;
4156 : :
4157 [ # # ]: 0 : for (hash_id = 0; hash_id < ZXDH_HASH_FUNC_ID_NUM; hash_id++) {
4158 : 0 : rc = zxdh_np_one_hash_soft_uninstall(dev_id, hash_id);
4159 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_one_hash_soft_uninstall");
4160 : : }
4161 : :
4162 : 0 : return rc;
4163 : : }
4164 : :
4165 : : static uint32_t
4166 : 0 : zxdh_np_acl_cfg_get(uint32_t dev_id, ZXDH_ACL_CFG_EX_T **p_acl_cfg)
4167 : : {
4168 [ # # ]: 0 : if (g_p_acl_ex_cfg[ZXDH_DEV_SLOT_ID(dev_id)] == NULL) {
4169 : 0 : PMD_DRV_LOG(ERR, "etcam_is not init!");
4170 : : RTE_ASSERT(0);
4171 : 0 : return ZXDH_ACL_RC_ETCAMID_NOT_INIT;
4172 : : }
4173 : :
4174 : 0 : *p_acl_cfg = g_p_acl_ex_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
4175 : :
4176 : 0 : return ZXDH_OK;
4177 : : }
4178 : :
4179 : : static uint32_t
4180 : 0 : zxdh_np_acl_res_destroy(uint32_t dev_id)
4181 : : {
4182 : : uint32_t table_id = 0;
4183 : : uint32_t as_enable = 0;
4184 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
4185 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
4186 : :
4187 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
4188 : :
4189 [ # # ]: 0 : if (!p_acl_cfg->acl_etcamids.is_valid) {
4190 : 0 : PMD_DRV_LOG(DEBUG, "etcam is not init!");
4191 : 0 : return ZXDH_OK;
4192 : : }
4193 : :
4194 [ # # ]: 0 : for (table_id = ZXDH_ACL_TBL_ID_MIN; table_id <= ZXDH_ACL_TBL_ID_MAX; table_id++) {
4195 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + table_id;
4196 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
4197 : 0 : PMD_DRV_LOG(DEBUG, "table_id[ %u ] is not used!", table_id);
4198 : 0 : continue;
4199 : : }
4200 : :
4201 : 0 : zxdh_comm_rb_destroy(&p_tbl_cfg->acl_rb);
4202 : :
4203 : 0 : as_enable = p_tbl_cfg->as_enable;
4204 [ # # ]: 0 : if (as_enable) {
4205 [ # # ]: 0 : if (p_tbl_cfg->as_rslt_buff) {
4206 : 0 : rte_free(p_tbl_cfg->as_rslt_buff);
4207 : 0 : p_tbl_cfg->as_rslt_buff = NULL;
4208 : : }
4209 : : }
4210 : :
4211 [ # # ]: 0 : if (p_tbl_cfg->block_array) {
4212 : 0 : rte_free(p_tbl_cfg->block_array);
4213 : 0 : p_tbl_cfg->block_array = NULL;
4214 : : }
4215 : :
4216 : 0 : p_tbl_cfg->is_used = 0;
4217 : : }
4218 : :
4219 : 0 : p_acl_cfg->acl_etcamids.is_valid = 0;
4220 : :
4221 : 0 : return ZXDH_OK;
4222 : : }
4223 : :
4224 : : static void
4225 : 0 : zxdh_np_apt_hash_global_res_uninit(uint32_t dev_id)
4226 : : {
4227 [ # # ]: 0 : if (g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] != NULL) {
4228 : 0 : rte_free(g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)]);
4229 : 0 : g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] = NULL;
4230 : 0 : dpp_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] = NULL;
4231 : : }
4232 : 0 : }
4233 : :
4234 : : int
4235 : 0 : zxdh_np_online_uninit(uint32_t dev_id,
4236 : : char *port_name,
4237 : : uint32_t queue_id)
4238 : : {
4239 : : uint32_t rc;
4240 : :
4241 : 0 : rc = zxdh_np_dtb_queue_release(dev_id, port_name, queue_id);
4242 [ # # ]: 0 : if (rc != 0)
4243 : 0 : PMD_DRV_LOG(ERR, "dtb release port name %s queue id %u", port_name, queue_id);
4244 : :
4245 : 0 : return 0;
4246 : : }
4247 : :
4248 : : uint32_t
4249 : 0 : zxdh_np_soft_res_uninstall(uint32_t dev_id)
4250 : : {
4251 : : uint32_t rc;
4252 : :
4253 : 0 : rc = zxdh_np_hash_soft_uninstall(dev_id);
4254 [ # # ]: 0 : if (rc != ZXDH_OK)
4255 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_hash_soft_uninstall error! ");
4256 : :
4257 : 0 : zxdh_np_apt_hash_global_res_uninit(dev_id);
4258 : 0 : zxdh_np_acl_res_destroy(dev_id);
4259 : : zxdh_np_dtb_mgr_destroy(dev_id);
4260 : 0 : zxdh_np_sdt_mgr_destroy(dev_id);
4261 : 0 : zxdh_np_dev_del(dev_id);
4262 : :
4263 : 0 : return rc;
4264 : : }
4265 : :
4266 : : static uint32_t
4267 : : zxdh_np_sdt_tbl_type_get(uint32_t dev_id, uint32_t sdt_no)
4268 : : {
4269 : 0 : return g_table_type[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no];
4270 : : }
4271 : :
4272 : :
4273 : : static const ZXDH_DTB_TABLE_T *
4274 : : zxdh_np_dtb_table_info_get(uint32_t table_type)
4275 : : {
4276 : : return &g_dpp_dtb_table_info[table_type];
4277 : : }
4278 : :
4279 : : static const ZXDH_DTB_TABLE_T *
4280 : : zxdh_np_dtb_dump_info_get(uint32_t up_type)
4281 : : {
4282 : : return &g_dpp_dtb_dump_info[up_type];
4283 : : }
4284 : :
4285 : : static uint32_t
4286 : 0 : zxdh_np_dtb_write_table_cmd(uint32_t dev_id,
4287 : : ZXDH_DTB_TABLE_INFO_E table_type,
4288 : : void *p_cmd_data,
4289 : : void *p_cmd_buff)
4290 : : {
4291 : : uint32_t field_cnt;
4292 : : const ZXDH_DTB_TABLE_T *p_table_info = NULL;
4293 : : const ZXDH_DTB_FIELD_T *p_field_info = NULL;
4294 : : uint32_t temp_data;
4295 : : uint32_t rc = 0;
4296 : :
4297 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_data);
4298 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_buff);
4299 : : p_table_info = zxdh_np_dtb_table_info_get(table_type);
4300 : 0 : p_field_info = p_table_info->p_fields;
4301 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_table_info);
4302 : :
4303 [ # # ]: 0 : for (field_cnt = 0; field_cnt < p_table_info->field_num; field_cnt++) {
4304 : 0 : temp_data = *((uint32_t *)p_cmd_data + field_cnt) &
4305 [ # # ]: 0 : zxdh_np_comm_get_bit_mask(p_field_info[field_cnt].len);
4306 : :
4307 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_cmd_buff,
4308 : : ZXDH_DTB_TABLE_CMD_SIZE_BIT,
4309 : : temp_data,
4310 : 0 : p_field_info[field_cnt].lsb_pos,
4311 : : p_field_info[field_cnt].len);
4312 : :
4313 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_comm_write_bits_ex");
4314 : : }
4315 : :
4316 : 0 : return rc;
4317 : : }
4318 : :
4319 : : static uint32_t
4320 : 0 : zxdh_np_dtb_write_dump_cmd(uint32_t dev_id,
4321 : : ZXDH_DTB_DUMP_INFO_E dump_type,
4322 : : void *p_cmd_data,
4323 : : void *p_cmd_buff)
4324 : : {
4325 : : uint32_t rc = ZXDH_OK;
4326 : : uint32_t field_cnt = 0;
4327 : : const ZXDH_DTB_TABLE_T *p_table_info = NULL;
4328 : : const ZXDH_DTB_FIELD_T *p_field_info = NULL;
4329 : : uint32_t temp_data = 0;
4330 : :
4331 : : p_table_info = zxdh_np_dtb_dump_info_get(dump_type);
4332 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_table_info);
4333 : 0 : p_field_info = p_table_info->p_fields;
4334 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_field_info);
4335 : :
4336 [ # # ]: 0 : for (field_cnt = 0; field_cnt < p_table_info->field_num; field_cnt++) {
4337 : 0 : temp_data = *((uint32_t *)p_cmd_data + field_cnt) &
4338 [ # # ]: 0 : zxdh_np_comm_get_bit_mask(p_field_info[field_cnt].len);
4339 : :
4340 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_cmd_buff,
4341 : : ZXDH_DTB_TABLE_CMD_SIZE_BIT,
4342 : : temp_data,
4343 : 0 : p_field_info[field_cnt].lsb_pos,
4344 : : p_field_info[field_cnt].len);
4345 : :
4346 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_comm_write_bits");
4347 : : }
4348 : :
4349 : 0 : return rc;
4350 : : }
4351 : :
4352 : : static uint32_t
4353 : 0 : zxdh_np_dtb_smmu0_write_entry_data(uint32_t dev_id,
4354 : : uint32_t mode,
4355 : : uint32_t addr,
4356 : : uint32_t *p_data,
4357 : : ZXDH_DTB_ENTRY_T *p_entry)
4358 : : {
4359 : 0 : ZXDH_DTB_ERAM_TABLE_FORM_T dtb_eram_form_info = {0};
4360 : : uint32_t rc = 0;
4361 : :
4362 : 0 : dtb_eram_form_info.valid = ZXDH_DTB_TABLE_VALID;
4363 : : dtb_eram_form_info.type_mode = ZXDH_DTB_TABLE_MODE_ERAM;
4364 : 0 : dtb_eram_form_info.data_mode = mode;
4365 : 0 : dtb_eram_form_info.cpu_wr = 1;
4366 : 0 : dtb_eram_form_info.addr = addr;
4367 : : dtb_eram_form_info.cpu_rd = 0;
4368 : : dtb_eram_form_info.cpu_rd_mode = 0;
4369 : :
4370 [ # # ]: 0 : if (ZXDH_ERAM128_OPR_128b == mode) {
4371 : 0 : p_entry->data_in_cmd_flag = 0;
4372 : 0 : p_entry->data_size = 128 / 8;
4373 : :
4374 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_128,
4375 : 0 : &dtb_eram_form_info, p_entry->cmd);
4376 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
4377 : :
4378 : 0 : memcpy(p_entry->data, p_data, 128 / 8);
4379 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_64b == mode) {
4380 : 0 : p_entry->data_in_cmd_flag = 1;
4381 : 0 : p_entry->data_size = 64 / 8;
4382 : 0 : dtb_eram_form_info.data_l = *(p_data + 1);
4383 : 0 : dtb_eram_form_info.data_h = *(p_data);
4384 : :
4385 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_64,
4386 : 0 : &dtb_eram_form_info, p_entry->cmd);
4387 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
4388 : :
4389 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_1b == mode) {
4390 : 0 : p_entry->data_in_cmd_flag = 1;
4391 : 0 : p_entry->data_size = 1;
4392 : 0 : dtb_eram_form_info.data_h = *(p_data);
4393 : :
4394 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_1,
4395 : 0 : &dtb_eram_form_info, p_entry->cmd);
4396 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
4397 : : }
4398 : :
4399 : 0 : return rc;
4400 : : }
4401 : :
4402 : : static uint32_t
4403 : 0 : zxdh_np_dtb_zcam_write_entry_data(uint32_t dev_id,
4404 : : uint32_t reg_sram_flag,
4405 : : uint32_t zgroup_id,
4406 : : uint32_t zblock_id,
4407 : : uint32_t zcell_id,
4408 : : uint32_t sram_addr,
4409 : : uint32_t mask,
4410 : : uint8_t *p_data,
4411 : : ZXDH_DTB_ENTRY_T *p_entry)
4412 : : {
4413 : : uint32_t rc = ZXDH_OK;
4414 : :
4415 : 0 : ZXDH_DTB_ZCAM_TABLE_FORM_T dtb_zcam_form_info = {
4416 : : .valid = 1,
4417 : : .type_mode = ZXDH_DTB_TABLE_MODE_ZCAM,
4418 : : .ram_reg_flag = reg_sram_flag,
4419 : : .zgroup_id = zgroup_id,
4420 : : .zblock_id = zblock_id,
4421 : : .zcell_id = zcell_id,
4422 : : .mask = mask,
4423 : 0 : .sram_addr = sram_addr & 0x1FF,
4424 : : };
4425 : :
4426 : 0 : p_entry->data_in_cmd_flag = 0;
4427 : 0 : p_entry->data_size = ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ZCAM_LEN_SIZE - 1);
4428 : :
4429 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ZCAM,
4430 : 0 : &dtb_zcam_form_info, p_entry->cmd);
4431 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_table_cmd");
4432 : :
4433 : 0 : memcpy(p_entry->data, p_data,
4434 : : ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ZCAM_LEN_SIZE - 1));
4435 : :
4436 : 0 : return rc;
4437 : : }
4438 : :
4439 : : static uint32_t
4440 : 0 : zxdh_np_dtb_se_alg_zcam_data_write(uint32_t dev_id,
4441 : : uint32_t addr,
4442 : : uint8_t *p_data,
4443 : : ZXDH_DTB_ENTRY_T *p_entry)
4444 : : {
4445 : : uint32_t rc = ZXDH_OK;
4446 : 0 : uint32_t reg_sram_flag = (addr >> 16) & 0x1;
4447 : 0 : uint32_t zgroup_id = (addr >> 14) & 0x3;
4448 : 0 : uint32_t zblock_id = (addr >> 11) & 0x7;
4449 : 0 : uint32_t zcell_id = (addr >> 9) & 0x3;
4450 : 0 : uint32_t mask = (addr >> 17) & 0xF;
4451 : 0 : uint32_t sram_addr = addr & 0x1FF;
4452 : :
4453 : 0 : rc = zxdh_np_dtb_zcam_write_entry_data(dev_id, reg_sram_flag, zgroup_id, zblock_id,
4454 : : zcell_id, sram_addr, mask, p_data, p_entry);
4455 : :
4456 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_zcam_write_entry_data");
4457 : :
4458 : 0 : return rc;
4459 : : }
4460 : :
4461 : : static uint32_t
4462 : 0 : zxdh_np_dtb_etcam_write_entry_data(uint32_t dev_id,
4463 : : uint32_t block_idx,
4464 : : uint32_t row_or_col_msk,
4465 : : uint32_t vben,
4466 : : uint32_t reg_tcam_flag,
4467 : : uint32_t flush,
4468 : : uint32_t rd_wr,
4469 : : uint32_t wr_mode,
4470 : : uint32_t data_or_mask,
4471 : : uint32_t ram_addr,
4472 : : uint32_t vbit,
4473 : : uint8_t *p_data,
4474 : : ZXDH_DTB_ENTRY_T *p_entry)
4475 : : {
4476 : : uint32_t rc = ZXDH_OK;
4477 : : uint32_t i = 0;
4478 : : uint32_t offset = 0;
4479 : : uint8_t *p_temp = NULL;
4480 : :
4481 : 0 : uint8_t buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
4482 : :
4483 : 0 : ZXDH_DTB_ETCAM_TABLE_FORM_T dtb_etcam_form_info = {
4484 : : .valid = 1,
4485 : : .type_mode = ZXDH_DTB_TABLE_MODE_ETCAM,
4486 : : .block_sel = block_idx,
4487 : : .init_en = 0,
4488 : : .row_or_col_msk = row_or_col_msk,
4489 : : .vben = vben,
4490 : : .reg_tcam_flag = reg_tcam_flag,
4491 : : .uload = flush,
4492 : : .rd_wr = rd_wr,
4493 : : .wr_mode = wr_mode,
4494 : : .data_or_mask = data_or_mask,
4495 : : .addr = ram_addr,
4496 : : .vbit = vbit,
4497 : : };
4498 : :
4499 : 0 : p_entry->data_in_cmd_flag = 0;
4500 : 0 : p_entry->data_size = ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ETCAM_LEN_SIZE - 1);
4501 : :
4502 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ETCAM,
4503 : 0 : &dtb_etcam_form_info, p_entry->cmd);
4504 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_table_cmd");
4505 : :
4506 : : p_temp = p_data;
4507 : :
4508 [ # # ]: 0 : for (i = 0; i < ZXDH_ETCAM_RAM_NUM; i++) {
4509 : 0 : offset = i * ((uint32_t)ZXDH_ETCAM_WIDTH_MIN / 8);
4510 : :
4511 [ # # ]: 0 : if ((wr_mode >> (ZXDH_ETCAM_RAM_NUM - 1 - i)) & 0x1) {
4512 : 0 : memcpy(buff + offset, p_temp, ZXDH_ETCAM_WIDTH_MIN / 8);
4513 : 0 : p_temp += ZXDH_ETCAM_WIDTH_MIN / 8;
4514 : : }
4515 : : }
4516 : :
4517 : : zxdh_np_comm_swap((uint8_t *)buff, ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ETCAM_LEN_SIZE - 1));
4518 : :
4519 : 0 : memcpy(p_entry->data, buff,
4520 : : ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ETCAM_LEN_SIZE - 1));
4521 : :
4522 : 0 : return rc;
4523 : : }
4524 : :
4525 : : static uint32_t
4526 : 0 : zxdh_np_dtb_smmu0_dump_info_write(uint32_t dev_id,
4527 : : uint32_t base_addr,
4528 : : uint32_t depth,
4529 : : uint32_t addr_high32,
4530 : : uint32_t addr_low32,
4531 : : uint32_t *p_dump_info)
4532 : : {
4533 : : uint32_t rc = ZXDH_OK;
4534 : :
4535 : 0 : ZXDH_DTB_ERAM_DUMP_FORM_T dtb_eram_dump_form_info = {
4536 : : .valid = 1,
4537 : : .up_type = ZXDH_DTB_DUMP_MODE_ERAM,
4538 : : .base_addr = base_addr,
4539 : : .tb_depth = depth,
4540 : : .tb_dst_addr_h = addr_high32,
4541 : : .tb_dst_addr_l = addr_low32,
4542 : : };
4543 : :
4544 : 0 : PMD_DRV_LOG(DEBUG, "valid: %u", dtb_eram_dump_form_info.valid);
4545 : 0 : PMD_DRV_LOG(DEBUG, "up_type: %u", dtb_eram_dump_form_info.up_type);
4546 : 0 : PMD_DRV_LOG(DEBUG, "base_addr: 0x%x", dtb_eram_dump_form_info.base_addr);
4547 : 0 : PMD_DRV_LOG(DEBUG, "tb_depth: %u", dtb_eram_dump_form_info.tb_depth);
4548 : 0 : PMD_DRV_LOG(DEBUG, "tb_dst_addr_h: 0x%x", dtb_eram_dump_form_info.tb_dst_addr_h);
4549 : 0 : PMD_DRV_LOG(DEBUG, "tb_dst_addr_l: 0x%x", dtb_eram_dump_form_info.tb_dst_addr_l);
4550 : :
4551 : 0 : rc = zxdh_np_dtb_write_dump_cmd(dev_id, ZXDH_DTB_DUMP_ERAM,
4552 : : &dtb_eram_dump_form_info, p_dump_info);
4553 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_cmd");
4554 : :
4555 : 0 : return rc;
4556 : : }
4557 : :
4558 : : static uint32_t
4559 : 0 : zxdh_np_dtb_zcam_dump_info_write(uint32_t dev_id,
4560 : : uint32_t addr,
4561 : : uint32_t tb_width,
4562 : : uint32_t depth,
4563 : : uint32_t addr_high32,
4564 : : uint32_t addr_low32,
4565 : : uint32_t *p_dump_info)
4566 : : {
4567 : : uint32_t rc = ZXDH_OK;
4568 : :
4569 : 0 : ZXDH_DTB_ZCAM_DUMP_FORM_T dtb_zcam_dump_form_info = {
4570 : : .valid = 1,
4571 : : .up_type = ZXDH_DTB_DUMP_MODE_ZCAM,
4572 : : .tb_width = tb_width,
4573 : 0 : .sram_addr = addr & 0x1FF,
4574 : 0 : .ram_reg_flag = (addr >> 16) & 0x1,
4575 : 0 : .z_reg_cell_id = (addr >> 9) & 0x3,
4576 : 0 : .zblock_id = (addr >> 11) & 0x7,
4577 : 0 : .zgroup_id = (addr >> 14) & 0x3,
4578 : : .tb_depth = depth,
4579 : : .tb_dst_addr_h = addr_high32,
4580 : : .tb_dst_addr_l = addr_low32,
4581 : : };
4582 : :
4583 : 0 : rc = zxdh_np_dtb_write_dump_cmd(dev_id, ZXDH_DTB_DUMP_ZCAM,
4584 : : &dtb_zcam_dump_form_info, p_dump_info);
4585 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_cmd");
4586 : :
4587 : 0 : return rc;
4588 : : }
4589 : :
4590 : : static uint32_t
4591 : 0 : zxdh_np_dtb_etcam_dump_info_write(uint32_t dev_id,
4592 : : ZXDH_ETCAM_DUMP_INFO_T *p_etcam_dump_info,
4593 : : uint32_t addr_high32,
4594 : : uint32_t addr_low32,
4595 : : uint32_t *p_dump_info)
4596 : : {
4597 : : uint32_t rc = ZXDH_OK;
4598 : :
4599 : 0 : ZXDH_DTB_ETCAM_DUMP_FORM_T dtb_etcam_dump_form_info = {
4600 : : .valid = 1,
4601 : : .up_type = ZXDH_DTB_DUMP_MODE_ETCAM,
4602 : 0 : .block_sel = p_etcam_dump_info->block_sel,
4603 : 0 : .addr = p_etcam_dump_info->addr,
4604 : 0 : .rd_mode = p_etcam_dump_info->rd_mode,
4605 : 0 : .data_or_mask = p_etcam_dump_info->data_or_mask,
4606 : 0 : .tb_depth = p_etcam_dump_info->tb_depth,
4607 : 0 : .tb_width = p_etcam_dump_info->tb_width,
4608 : : .tb_dst_addr_h = addr_high32,
4609 : : .tb_dst_addr_l = addr_low32,
4610 : : };
4611 : :
4612 : 0 : rc = zxdh_np_dtb_write_dump_cmd(dev_id, ZXDH_DTB_DUMP_ETCAM,
4613 : : &dtb_etcam_dump_form_info, p_dump_info);
4614 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_cmd");
4615 : :
4616 : 0 : return rc;
4617 : : }
4618 : :
4619 : : static void
4620 : : zxdh_np_dtb_zcam_dump_entry(uint32_t dev_id,
4621 : : uint32_t addr,
4622 : : uint32_t tb_width,
4623 : : uint32_t depth,
4624 : : uint32_t addr_high32,
4625 : : uint32_t addr_low32,
4626 : : ZXDH_DTB_ENTRY_T *p_entry)
4627 : : {
4628 : 0 : zxdh_np_dtb_zcam_dump_info_write(dev_id,
4629 : : addr,
4630 : : tb_width,
4631 : : depth,
4632 : : addr_high32,
4633 : : addr_low32,
4634 : 0 : (uint32_t *)p_entry->cmd);
4635 : 0 : p_entry->data_in_cmd_flag = 1;
4636 : : }
4637 : :
4638 : : static void
4639 : 0 : zxdh_np_dtb_smmu0_dump_entry(uint32_t dev_id,
4640 : : uint32_t base_addr,
4641 : : uint32_t depth,
4642 : : uint32_t addr_high32,
4643 : : uint32_t addr_low32,
4644 : : ZXDH_DTB_ENTRY_T *p_entry)
4645 : : {
4646 : 0 : zxdh_np_dtb_smmu0_dump_info_write(dev_id,
4647 : : base_addr,
4648 : : depth,
4649 : : addr_high32,
4650 : : addr_low32,
4651 : 0 : (uint32_t *)p_entry->cmd);
4652 : 0 : p_entry->data_in_cmd_flag = 1;
4653 : 0 : }
4654 : :
4655 : : static void
4656 : : zxdh_np_dtb_etcam_dump_entry(uint32_t dev_id,
4657 : : ZXDH_ETCAM_DUMP_INFO_T *p_etcam_dump_info,
4658 : : uint32_t addr_high32,
4659 : : uint32_t addr_low32,
4660 : : ZXDH_DTB_ENTRY_T *p_entry)
4661 : : {
4662 : 0 : zxdh_np_dtb_etcam_dump_info_write(dev_id,
4663 : : p_etcam_dump_info,
4664 : : addr_high32,
4665 : : addr_low32,
4666 : 0 : (uint32_t *)p_entry->cmd);
4667 : 0 : p_entry->data_in_cmd_flag = 1;
4668 : : }
4669 : :
4670 : : static uint32_t
4671 : 0 : zxdh_np_dtb_se_smmu0_ind_write(uint32_t dev_id,
4672 : : uint32_t base_addr,
4673 : : uint32_t index,
4674 : : uint32_t wrt_mode,
4675 : : uint32_t *p_data,
4676 : : ZXDH_DTB_ENTRY_T *p_entry)
4677 : : {
4678 : : uint32_t temp_idx = 0;
4679 : : uint32_t dtb_ind_addr;
4680 : : uint32_t rc = 0;
4681 : :
4682 [ # # # # ]: 0 : switch (wrt_mode) {
4683 : 0 : case ZXDH_ERAM128_OPR_128b:
4684 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
4685 : 0 : PMD_DRV_LOG(ERR, "base addr:0x%x, index:0x%x invalid", base_addr, index);
4686 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
4687 : : }
4688 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
4689 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
4690 : 0 : return 1;
4691 : : }
4692 : 0 : temp_idx = index << 7;
4693 : 0 : break;
4694 : 0 : case ZXDH_ERAM128_OPR_64b:
4695 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
4696 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
4697 : 0 : return 1;
4698 : : }
4699 : 0 : temp_idx = index << 6;
4700 : 0 : break;
4701 : 0 : case ZXDH_ERAM128_OPR_1b:
4702 [ # # ]: 0 : if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
4703 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
4704 : 0 : return 1;
4705 : : }
4706 : :
4707 : : temp_idx = index;
4708 : : break;
4709 : : default:
4710 : : break;
4711 : : }
4712 : :
4713 : 0 : dtb_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + temp_idx;
4714 : :
4715 : 0 : PMD_DRV_LOG(DEBUG, "dtb eram item 1bit addr: 0x%x", dtb_ind_addr);
4716 : :
4717 : 0 : rc = zxdh_np_dtb_smmu0_write_entry_data(dev_id,
4718 : : wrt_mode,
4719 : : dtb_ind_addr,
4720 : : p_data,
4721 : : p_entry);
4722 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_smmu0_write_entry_data");
4723 : :
4724 : : return rc;
4725 : : }
4726 : :
4727 : : static uint32_t
4728 : : zxdh_np_eram_dtb_len_get(uint32_t mode)
4729 : : {
4730 : : uint32_t dtb_len = 0;
4731 : :
4732 [ # # # ]: 0 : switch (mode) {
4733 : 0 : case ZXDH_ERAM128_OPR_128b:
4734 : : dtb_len += 2;
4735 : 0 : break;
4736 : 0 : case ZXDH_ERAM128_OPR_64b:
4737 : : case ZXDH_ERAM128_OPR_1b:
4738 : : dtb_len += 1;
4739 : 0 : break;
4740 : : default:
4741 : : break;
4742 : : }
4743 : :
4744 : : return dtb_len;
4745 : : }
4746 : :
4747 : : static void
4748 : : zxdh_np_sdt_tbl_data_get(uint32_t dev_id, uint32_t sdt_no, ZXDH_SDT_TBL_DATA_T *p_sdt_data)
4749 : : {
4750 : 0 : p_sdt_data->data_high32 = g_sdt_info[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no].data_high32;
4751 : 0 : p_sdt_data->data_low32 = g_sdt_info[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no].data_low32;
4752 : : }
4753 : :
4754 : : static uint32_t
4755 : 0 : zxdh_np_sdt_tbl_data_parser(uint32_t sdt_hig32, uint32_t sdt_low32, void *p_sdt_info)
4756 : : {
4757 : : uint32_t tbl_type = 0;
4758 : : uint32_t clutch_en = 0;
4759 : : uint32_t tmp = 0;
4760 : :
4761 : : ZXDH_SDT_TBL_ERAM_T *p_sdt_eram = NULL;
4762 : : ZXDH_SDT_TBL_HASH_T *p_sdt_hash = NULL;
4763 : : ZXDH_SDT_TBL_ETCAM_T *p_sdt_etcam = NULL;
4764 : : ZXDH_SDT_TBL_PORTTBL_T *p_sdt_porttbl = NULL;
4765 : :
4766 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_hig32,
4767 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
4768 : 0 : ZXDH_COMM_UINT32_GET_BITS(clutch_en, sdt_low32, 0, 1);
4769 : :
4770 [ # # # # : 0 : switch (tbl_type) {
# ]
4771 : 0 : case ZXDH_SDT_TBLT_ERAM:
4772 : : p_sdt_eram = (ZXDH_SDT_TBL_ERAM_T *)p_sdt_info;
4773 : 0 : p_sdt_eram->table_type = tbl_type;
4774 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_eram->eram_mode, sdt_hig32,
4775 : : ZXDH_SDT_H_ERAM_MODE_BT_POS, ZXDH_SDT_H_ERAM_MODE_BT_LEN);
4776 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_eram->eram_base_addr, sdt_hig32,
4777 : : ZXDH_SDT_H_ERAM_BASE_ADDR_BT_POS, ZXDH_SDT_H_ERAM_BASE_ADDR_BT_LEN);
4778 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_eram->eram_table_depth, sdt_low32,
4779 : : ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_POS, ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_LEN);
4780 : 0 : p_sdt_eram->eram_clutch_en = clutch_en;
4781 : 0 : break;
4782 : 0 : case ZXDH_SDT_TBLT_HASH:
4783 : : p_sdt_hash = (ZXDH_SDT_TBL_HASH_T *)p_sdt_info;
4784 : 0 : p_sdt_hash->table_type = tbl_type;
4785 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->hash_id, sdt_hig32,
4786 : : ZXDH_SDT_H_HASH_ID_BT_POS, ZXDH_SDT_H_HASH_ID_BT_LEN);
4787 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->hash_table_width, sdt_hig32,
4788 : : ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_POS, ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_LEN);
4789 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->key_size, sdt_hig32,
4790 : : ZXDH_SDT_H_HASH_KEY_SIZE_BT_POS, ZXDH_SDT_H_HASH_KEY_SIZE_BT_LEN);
4791 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->hash_table_id, sdt_hig32,
4792 : : ZXDH_SDT_H_HASH_TABLE_ID_BT_POS, ZXDH_SDT_H_HASH_TABLE_ID_BT_LEN);
4793 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->learn_en, sdt_hig32,
4794 : : ZXDH_SDT_H_LEARN_EN_BT_POS, ZXDH_SDT_H_LEARN_EN_BT_LEN);
4795 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->keep_alive, sdt_hig32,
4796 : : ZXDH_SDT_H_KEEP_ALIVE_BT_POS, ZXDH_SDT_H_KEEP_ALIVE_BT_LEN);
4797 : : ZXDH_COMM_UINT32_GET_BITS(tmp, sdt_hig32,
4798 : : ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_POS, ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_LEN);
4799 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->keep_alive_baddr, sdt_low32,
4800 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_POS, ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN);
4801 : 0 : p_sdt_hash->keep_alive_baddr += (tmp << ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN);
4802 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->rsp_mode, sdt_low32,
4803 : : ZXDH_SDT_L_RSP_MODE_BT_POS, ZXDH_SDT_L_RSP_MODE_BT_LEN);
4804 : 0 : p_sdt_hash->hash_clutch_en = clutch_en;
4805 : 0 : break;
4806 : :
4807 : 0 : case ZXDH_SDT_TBLT_ETCAM:
4808 : : p_sdt_etcam = (ZXDH_SDT_TBL_ETCAM_T *)p_sdt_info;
4809 : 0 : p_sdt_etcam->table_type = tbl_type;
4810 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_id, sdt_hig32,
4811 : : ZXDH_SDT_H_ETCAM_ID_BT_POS, ZXDH_SDT_H_ETCAM_ID_BT_LEN);
4812 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_key_mode, sdt_hig32,
4813 : : ZXDH_SDT_H_ETCAM_KEY_MODE_BT_POS, ZXDH_SDT_H_ETCAM_KEY_MODE_BT_LEN);
4814 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_table_id, sdt_hig32,
4815 : : ZXDH_SDT_H_ETCAM_TABLE_ID_BT_POS, ZXDH_SDT_H_ETCAM_TABLE_ID_BT_LEN);
4816 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->no_as_rsp_mode, sdt_hig32,
4817 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_POS,
4818 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_LEN);
4819 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->as_en, sdt_hig32,
4820 : : ZXDH_SDT_H_ETCAM_AS_EN_BT_POS, ZXDH_SDT_H_ETCAM_AS_EN_BT_LEN);
4821 : : ZXDH_COMM_UINT32_GET_BITS(tmp, sdt_hig32, ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_POS,
4822 : : ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_LEN);
4823 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->as_eram_baddr, sdt_low32,
4824 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_POS,
4825 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN);
4826 : 0 : p_sdt_etcam->as_eram_baddr += (tmp << ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN);
4827 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->as_rsp_mode, sdt_low32,
4828 : : ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_POS, ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_LEN);
4829 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_table_depth, sdt_low32,
4830 : : ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_POS, ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_LEN);
4831 : 0 : p_sdt_etcam->etcam_clutch_en = clutch_en;
4832 : 0 : break;
4833 : :
4834 : 0 : case ZXDH_SDT_TBLT_PORTTBL:
4835 : : p_sdt_porttbl = (ZXDH_SDT_TBL_PORTTBL_T *)p_sdt_info;
4836 : 0 : p_sdt_porttbl->table_type = tbl_type;
4837 : 0 : p_sdt_porttbl->porttbl_clutch_en = clutch_en;
4838 : 0 : break;
4839 : 0 : default:
4840 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
4841 : 0 : return 1;
4842 : : }
4843 : :
4844 : : return 0;
4845 : : }
4846 : :
4847 : : static uint32_t
4848 : 0 : zxdh_np_soft_sdt_tbl_get(uint32_t dev_id, uint32_t sdt_no, void *p_sdt_info)
4849 : : {
4850 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
4851 : : uint32_t rc;
4852 : :
4853 [ # # ]: 0 : if (sdt_no > ZXDH_DEV_SDT_ID_MAX - 1) {
4854 : 0 : PMD_DRV_LOG(DEBUG, "SDT NO [ %u ] is invalid!", sdt_no);
4855 : 0 : return ZXDH_PAR_CHK_INVALID_PARA;
4856 : : }
4857 : :
4858 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
4859 : :
4860 : 0 : rc = zxdh_np_sdt_tbl_data_parser(sdt_tbl.data_high32, sdt_tbl.data_low32, p_sdt_info);
4861 [ # # ]: 0 : if (rc != 0)
4862 : 0 : PMD_DRV_LOG(ERR, "dpp sdt [%u] tbl_data_parser error.", sdt_no);
4863 : :
4864 : : return rc;
4865 : : }
4866 : :
4867 : : static uint32_t
4868 : 0 : zxdh_np_dtb_eram_one_entry(uint32_t dev_id,
4869 : : uint32_t sdt_no,
4870 : : uint32_t del_en,
4871 : : void *pdata,
4872 : : uint32_t *p_dtb_len,
4873 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
4874 : : {
4875 : 0 : uint32_t buff[ZXDH_SMMU0_READ_REG_MAX_NUM] = {0};
4876 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
4877 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *peramdata = NULL;
4878 : : uint32_t base_addr;
4879 : : uint32_t index;
4880 : : uint32_t opr_mode;
4881 : : uint32_t rc = ZXDH_OK;
4882 : :
4883 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(pdata);
4884 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_one_entry);
4885 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_len);
4886 : :
4887 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
4888 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram);
4889 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_soft_sdt_tbl_get");
4890 : :
4891 : : peramdata = (ZXDH_DTB_ERAM_ENTRY_INFO_T *)pdata;
4892 : 0 : index = peramdata->index;
4893 : 0 : base_addr = sdt_eram.eram_base_addr;
4894 : 0 : opr_mode = sdt_eram.eram_mode;
4895 : :
4896 [ # # # # ]: 0 : switch (opr_mode) {
4897 : 0 : case ZXDH_ERAM128_TBL_128b:
4898 : : opr_mode = ZXDH_ERAM128_OPR_128b;
4899 : 0 : break;
4900 : 0 : case ZXDH_ERAM128_TBL_64b:
4901 : : opr_mode = ZXDH_ERAM128_OPR_64b;
4902 : 0 : break;
4903 : 0 : case ZXDH_ERAM128_TBL_1b:
4904 : : opr_mode = ZXDH_ERAM128_OPR_1b;
4905 : 0 : break;
4906 : : default:
4907 : : break;
4908 : : }
4909 : :
4910 : 0 : PMD_DRV_LOG(DEBUG, "std no:0x%x, index:0x%x, base addr:0x%x", sdt_no, index, base_addr);
4911 [ # # ]: 0 : if (opr_mode == ZXDH_ERAM128_OPR_128b)
4912 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x 0x%08x 0x%08x]",
4913 : : peramdata->p_data[0], peramdata->p_data[1],
4914 : : peramdata->p_data[2], peramdata->p_data[3]);
4915 [ # # ]: 0 : else if (opr_mode == ZXDH_ERAM128_OPR_64b)
4916 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x]",
4917 : : peramdata->p_data[0], peramdata->p_data[1]);
4918 : :
4919 [ # # ]: 0 : if (del_en) {
4920 : : memset((uint8_t *)buff, 0, sizeof(buff));
4921 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
4922 : : base_addr,
4923 : : index,
4924 : : opr_mode,
4925 : : buff,
4926 : : p_dtb_one_entry);
4927 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(sdt_no, rc, "zxdh_dtb_se_smmu0_ind_write");
4928 : : } else {
4929 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
4930 : : base_addr,
4931 : : index,
4932 : : opr_mode,
4933 : : peramdata->p_data,
4934 : : p_dtb_one_entry);
4935 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_dtb_se_smmu0_ind_write");
4936 : : }
4937 : 0 : *p_dtb_len = zxdh_np_eram_dtb_len_get(opr_mode);
4938 : :
4939 : 0 : return rc;
4940 : : }
4941 : :
4942 : : static uint32_t
4943 : 0 : zxdh_np_dtb_data_write(uint8_t *p_data_buff,
4944 : : uint32_t addr_offset,
4945 : : ZXDH_DTB_ENTRY_T *entry)
4946 : : {
4947 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
4948 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(entry);
4949 : :
4950 : 0 : uint8_t *p_cmd = p_data_buff + addr_offset;
4951 : : uint32_t cmd_size = ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8;
4952 : :
4953 : 0 : uint8_t *p_data = p_cmd + cmd_size;
4954 : 0 : uint32_t data_size = entry->data_size;
4955 : :
4956 : 0 : uint8_t *cmd = (uint8_t *)entry->cmd;
4957 [ # # ]: 0 : uint8_t *data = (uint8_t *)entry->data;
4958 : :
4959 : : memcpy(p_cmd, cmd, cmd_size);
4960 : :
4961 [ # # ]: 0 : if (!entry->data_in_cmd_flag) {
4962 : 0 : zxdh_np_comm_swap(data, data_size);
4963 : 0 : memcpy(p_data, data, data_size);
4964 : : }
4965 : :
4966 : 0 : return 0;
4967 : : }
4968 : :
4969 : : static uint32_t
4970 : 0 : zxdh_np_dtb_queue_enable_get(uint32_t dev_id,
4971 : : uint32_t queue_id,
4972 : : uint32_t *enable)
4973 : : {
4974 : : uint32_t rc = 0;
4975 : 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
4976 : :
4977 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
4978 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_vm_info_get");
4979 : :
4980 : 0 : *enable = vm_info.queue_en;
4981 : 0 : return rc;
4982 : : }
4983 : :
4984 : : static uint32_t
4985 : 0 : zxdh_np_dtb_item_buff_wr(uint32_t dev_id,
4986 : : uint32_t queue_id,
4987 : : uint32_t dir_flag,
4988 : : uint32_t index,
4989 : : uint32_t pos,
4990 : : uint32_t len,
4991 : : uint32_t *p_data)
4992 : : {
4993 : : uint64_t addr;
4994 : :
4995 [ # # ]: 0 : if (dir_flag == 1)
4996 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) +
4997 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
4998 : : else
4999 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) +
5000 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
5001 : :
5002 : 0 : memcpy((uint8_t *)(addr), p_data, len * 4);
5003 : :
5004 : 0 : return 0;
5005 : : }
5006 : :
5007 : : static uint32_t
5008 : 0 : zxdh_np_dtb_item_ack_rd(uint32_t dev_id,
5009 : : uint32_t queue_id,
5010 : : uint32_t dir_flag,
5011 : : uint32_t index,
5012 : : uint32_t pos,
5013 : : uint32_t *p_data)
5014 : : {
5015 : : uint64_t addr;
5016 : : uint32_t val;
5017 : :
5018 [ # # ]: 0 : if (dir_flag == 1)
5019 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5020 : : else
5021 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5022 : :
5023 : 0 : val = *((volatile uint32_t *)(addr));
5024 : :
5025 : : if (!zxdh_np_comm_is_big_endian())
5026 : : val = ZXDH_COMM_CONVERT32(val);
5027 : :
5028 : 0 : *p_data = val;
5029 : :
5030 : 0 : return 0;
5031 : : }
5032 : :
5033 : : static uint32_t
5034 : : zxdh_np_dtb_item_ack_wr(uint32_t dev_id,
5035 : : uint32_t queue_id,
5036 : : uint32_t dir_flag,
5037 : : uint32_t index,
5038 : : uint32_t pos,
5039 : : uint32_t data)
5040 : : {
5041 : : uint64_t addr;
5042 : :
5043 : : if (dir_flag == 1)
5044 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5045 : : else
5046 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5047 : :
5048 : : if (!zxdh_np_comm_is_big_endian())
5049 : : data = ZXDH_COMM_CONVERT32(data);
5050 : :
5051 : 0 : *((volatile uint32_t *)addr) = data;
5052 : :
5053 : 0 : return 0;
5054 : : }
5055 : :
5056 : : static uint32_t
5057 : 0 : zxdh_np_dtb_item_ack_prt(uint32_t dev_id,
5058 : : uint32_t queue_id,
5059 : : uint32_t dir_flag,
5060 : : uint32_t index)
5061 : : {
5062 : : uint32_t rc = 0;
5063 : : uint32_t i = 0;
5064 : 0 : uint32_t ack_data[4] = {0};
5065 : :
5066 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_ITEM_ACK_SIZE / 4; i++) {
5067 : 0 : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, dir_flag, index, i, ack_data + i);
5068 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_rd");
5069 : : }
5070 : :
5071 : 0 : PMD_DRV_LOG(DEBUG, "[%s] BD INFO:", g_dpp_dtb_name[dir_flag]);
5072 : 0 : PMD_DRV_LOG(DEBUG, "[index : %u] : 0x%08x 0x%08x 0x%08x 0x%08x", index,
5073 : : ack_data[0], ack_data[1], ack_data[2], ack_data[3]);
5074 : :
5075 : 0 : return rc;
5076 : : }
5077 : :
5078 : : static uint32_t
5079 : 0 : zxdh_np_dtb_item_buff_rd(uint32_t dev_id,
5080 : : uint32_t queue_id,
5081 : : uint32_t dir_flag,
5082 : : uint32_t index,
5083 : : uint32_t pos,
5084 : : uint32_t len,
5085 : : uint32_t *p_data)
5086 : : {
5087 : : uint64_t addr = 0;
5088 : :
5089 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
5090 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
5091 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
5092 : : }
5093 : :
5094 [ # # ]: 0 : if (dir_flag == ZXDH_DTB_DIR_UP_TYPE) {
5095 [ # # ]: 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, index) ==
5096 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE) {
5097 : 0 : addr = ZXDH_DTB_TAB_UP_USER_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
5098 : 0 : ZXDH_DTB_TAB_UP_USER_ADDR_FLAG_SET(dev_id, queue_id, index, 0);
5099 : : } else {
5100 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) +
5101 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
5102 : : }
5103 : : } else {
5104 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) +
5105 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
5106 : : }
5107 : :
5108 : 0 : memcpy(p_data, (uint8_t *)(addr), len * 4);
5109 : :
5110 : 0 : zxdh_np_comm_swap((uint8_t *)p_data, len * 4);
5111 : :
5112 : 0 : return ZXDH_OK;
5113 : : }
5114 : :
5115 : : static uint32_t
5116 : 0 : zxdh_np_dtb_item_buff_prt(uint32_t dev_id,
5117 : : uint32_t queue_id,
5118 : : uint32_t dir_flag,
5119 : : uint32_t index,
5120 : : uint32_t len)
5121 : : {
5122 : : uint32_t rc = 0;
5123 : : uint32_t i = 0;
5124 : : uint32_t j = 0;
5125 : : uint32_t *p_item_buff = NULL;
5126 : :
5127 : 0 : p_item_buff = rte_zmalloc(NULL, len * sizeof(uint32_t), 0);
5128 [ # # ]: 0 : if (p_item_buff == NULL) {
5129 : 0 : PMD_DRV_LOG(ERR, "Alloc dtb item buffer failed!!!");
5130 : 0 : return ZXDH_RC_DTB_MEMORY_ALLOC_ERR;
5131 : : }
5132 : :
5133 : 0 : zxdh_np_dtb_item_buff_rd(dev_id, queue_id, dir_flag, index, 0, len, p_item_buff);
5134 : :
5135 : 0 : PMD_DRV_LOG(DEBUG, "[%s] BUFF INFO:", g_dpp_dtb_name[dir_flag]);
5136 [ # # ]: 0 : for (i = 0, j = 0; i < len; i++, j++) {
5137 [ # # ]: 0 : if (j % 4 == 0)
5138 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", (*(p_item_buff + i)));
5139 : : else
5140 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", (*(p_item_buff + i)));
5141 : : }
5142 : :
5143 : 0 : rte_free(p_item_buff);
5144 : :
5145 : 0 : return rc;
5146 : : }
5147 : :
5148 : : static uint32_t
5149 : 0 : zxdh_np_dtb_queue_item_info_set(uint32_t dev_id,
5150 : : uint32_t queue_id,
5151 : : ZXDH_DTB_QUEUE_ITEM_INFO_T *p_item_info)
5152 : : {
5153 : : uint32_t rc;
5154 : :
5155 : : uint32_t dtb_addr_h_reg = ZXDH_SYS_DTB_BASE_ADDR +
5156 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0000;
5157 : : uint32_t dtb_addr_l_reg = ZXDH_SYS_DTB_BASE_ADDR +
5158 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0004;
5159 : : uint32_t dtb_len_reg = ZXDH_SYS_DTB_BASE_ADDR +
5160 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0008;
5161 : 0 : uint32_t dtb_len = 0;
5162 : :
5163 : 0 : rc = zxdh_np_dev_write_channel(dev_id, dtb_addr_h_reg + queue_id * 32,
5164 : : 1, &p_item_info->data_hddr);
5165 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_write_channel Fail");
5166 : 0 : rc = zxdh_np_dev_write_channel(dev_id, dtb_addr_l_reg + queue_id * 32,
5167 : : 1, &p_item_info->data_laddr);
5168 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_write_channel Fail");
5169 : 0 : dtb_len = ZXDH_DTB_LEN(p_item_info->cmd_type, p_item_info->int_en, p_item_info->data_len);
5170 : 0 : rc = zxdh_np_dev_write_channel(dev_id, dtb_len_reg + queue_id * 32, 1, &dtb_len);
5171 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_write_channel Fail");
5172 : :
5173 : 0 : return rc;
5174 : : }
5175 : :
5176 : : static uint32_t
5177 : 0 : zxdh_np_dtb_tab_down_info_set(uint32_t dev_id,
5178 : : uint32_t queue_id,
5179 : : uint32_t int_flag,
5180 : : uint32_t data_len,
5181 : : uint32_t *p_data,
5182 : : uint32_t *p_item_index)
5183 : : {
5184 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
5185 : 0 : uint32_t unused_item_num = 0;
5186 : 0 : uint32_t queue_en = 0;
5187 : : uint32_t ack_vale = 0;
5188 : : uint64_t phy_addr;
5189 : : uint32_t item_index;
5190 : : uint32_t i;
5191 : : uint32_t rc;
5192 : : ZXDH_SPINLOCK_T *p_spinlock = NULL;
5193 : :
5194 : : zxdh_np_dev_dtb_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_DTB, queue_id, &p_spinlock);
5195 : 0 : rte_spinlock_lock(&p_spinlock->spinlock);
5196 : :
5197 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
5198 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
5199 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5200 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
5201 : : }
5202 : :
5203 [ # # ]: 0 : if (data_len % 4 != 0) {
5204 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5205 : 0 : return ZXDH_RC_DTB_PARA_INVALID;
5206 : : }
5207 : :
5208 : 0 : rc = zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
5209 [ # # ]: 0 : if (!queue_en) {
5210 : 0 : PMD_DRV_LOG(ERR, "the queue %u is not enable!,rc=%u", queue_id, rc);
5211 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5212 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
5213 : : }
5214 : :
5215 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
5216 [ # # ]: 0 : if (unused_item_num == 0) {
5217 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5218 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
5219 : : }
5220 : :
5221 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
5222 : 0 : item_index = ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id) %
5223 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
5224 : :
5225 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, 0,
5226 : : item_index, 0, &ack_vale);
5227 : :
5228 : 0 : ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id)++;
5229 : :
5230 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
5231 : : break;
5232 : : }
5233 : :
5234 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX) {
5235 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5236 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
5237 : : }
5238 : :
5239 : 0 : rc = zxdh_np_dtb_item_buff_wr(dev_id, queue_id, 0,
5240 : : item_index, 0, data_len, p_data);
5241 : :
5242 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, 0,
5243 : : item_index, 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
5244 : :
5245 : 0 : item_info.cmd_vld = 1;
5246 : 0 : item_info.cmd_type = 0;
5247 : 0 : item_info.int_en = int_flag;
5248 : 0 : item_info.data_len = data_len / 4;
5249 : 0 : phy_addr = p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)]->queue_info[queue_id].
5250 : 0 : tab_down.start_phy_addr +
5251 : 0 : item_index * p_dpp_dtb_mgr[ZXDH_DEV_SLOT_ID(dev_id)]->queue_info[queue_id].
5252 : 0 : tab_down.item_size;
5253 : 0 : item_info.data_hddr = ((phy_addr >> 4) >> 32) & 0xffffffff;
5254 : 0 : item_info.data_laddr = (phy_addr >> 4) & 0xffffffff;
5255 : :
5256 : 0 : zxdh_dtb_info_print(dev_id, queue_id, item_index, &item_info);
5257 : :
5258 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
5259 : 0 : *p_item_index = item_index;
5260 : :
5261 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5262 : :
5263 : 0 : return rc;
5264 : : }
5265 : :
5266 : : static uint32_t
5267 : : zxdh_np_dtb_write_down_table_data(uint32_t dev_id,
5268 : : uint32_t queue_id,
5269 : : uint32_t down_table_len,
5270 : : uint8_t *p_down_table_buff,
5271 : : uint32_t *p_element_id)
5272 : : {
5273 : : uint32_t rc = 0;
5274 : : uint32_t dtb_interrupt_status = 0;
5275 : :
5276 : 0 : rc = zxdh_np_dtb_tab_down_info_set(dev_id,
5277 : : queue_id,
5278 : : dtb_interrupt_status,
5279 : : down_table_len / 4,
5280 : : (uint32_t *)p_down_table_buff,
5281 : : p_element_id);
5282 : : return rc;
5283 : : }
5284 : :
5285 : : static void
5286 : : zxdh_np_dtb_down_table_element_addr_get(uint32_t dev_id,
5287 : : uint32_t queue_id,
5288 : : uint32_t element_id,
5289 : : uint32_t *p_element_start_addr_h,
5290 : : uint32_t *p_element_start_addr_l,
5291 : : uint32_t *p_element_table_addr_h,
5292 : : uint32_t *p_element_table_addr_l)
5293 : : {
5294 : : uint32_t addr_h = 0;
5295 : : uint32_t addr_l = 0;
5296 : :
5297 : 0 : addr_h = (ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) >> 32) & 0xffffffff;
5298 : 0 : addr_l = ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) & 0xffffffff;
5299 : :
5300 : : *p_element_start_addr_h = addr_h;
5301 : : *p_element_start_addr_l = addr_l;
5302 : :
5303 : 0 : addr_h = ((ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) +
5304 : 0 : ZXDH_DTB_ITEM_ACK_SIZE) >> 32) & 0xffffffff;
5305 : 0 : addr_l = (ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) +
5306 : : ZXDH_DTB_ITEM_ACK_SIZE) & 0xffffffff;
5307 : :
5308 : : *p_element_table_addr_h = addr_h;
5309 : : *p_element_table_addr_l = addr_l;
5310 : : }
5311 : :
5312 : : static uint32_t
5313 : 0 : zxdh_np_dtb_down_table_element_info_prt(uint32_t dev_id,
5314 : : uint32_t queue_id,
5315 : : uint32_t element_id)
5316 : : {
5317 : : uint32_t rc = 0;
5318 : : uint32_t element_start_addr_h = 0;
5319 : : uint32_t element_start_addr_l = 0;
5320 : : uint32_t element_table_addr_h = 0;
5321 : : uint32_t element_table_addr_l = 0;
5322 : :
5323 : : zxdh_np_dtb_down_table_element_addr_get(dev_id,
5324 : : queue_id,
5325 : : element_id,
5326 : : &element_start_addr_h,
5327 : : &element_start_addr_l,
5328 : : &element_table_addr_h,
5329 : : &element_table_addr_l);
5330 : :
5331 : 0 : PMD_DRV_LOG(DEBUG, "queue_id %u.", queue_id);
5332 : 0 : PMD_DRV_LOG(DEBUG, "element_id %u.", element_id);
5333 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_h 0x%x.", element_start_addr_h);
5334 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_l 0x%x.", element_start_addr_l);
5335 : 0 : PMD_DRV_LOG(DEBUG, "element_table_addr_h 0x%x..", element_table_addr_h);
5336 : 0 : PMD_DRV_LOG(DEBUG, "element_table_addr_l 0x%x.", element_table_addr_l);
5337 : :
5338 : 0 : rc = zxdh_np_dtb_item_ack_prt(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE, element_id);
5339 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_prt");
5340 : :
5341 : 0 : rc = zxdh_np_dtb_item_buff_prt(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE, element_id, 24);
5342 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_prt");
5343 : :
5344 : 0 : return rc;
5345 : : }
5346 : :
5347 : : static uint32_t
5348 : 0 : zxdh_np_dtb_tab_down_success_status_check(uint32_t dev_id,
5349 : : uint32_t queue_id,
5350 : : uint32_t element_id)
5351 : : {
5352 : : uint32_t rc = 0;
5353 : : uint32_t rd_cnt = 0;
5354 : : uint32_t ack_value = 0;
5355 : : uint32_t success_flag = 0;
5356 : :
5357 : 0 : while (!success_flag) {
5358 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5359 : : element_id, 0, &ack_value);
5360 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_rd");
5361 : :
5362 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_np_dtb_item_ack_rd ack_value:0x%08x", ack_value);
5363 : :
5364 [ # # ]: 0 : if (((ack_value >> 8) & 0xffffff) == ZXDH_DTB_TAB_DOWN_ACK_VLD_MASK) {
5365 : : success_flag = 1;
5366 : : break;
5367 : : }
5368 : :
5369 [ # # ]: 0 : if (rd_cnt > ZXDH_DTB_DOWN_OVER_TIME) {
5370 : 0 : PMD_DRV_LOG(ERR, "down queue %u item %u overtime!", queue_id, element_id);
5371 : :
5372 : 0 : rc = zxdh_np_dtb_down_table_element_info_prt(dev_id, queue_id, element_id);
5373 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_down_table_element_info_prt");
5374 : :
5375 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5376 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
5377 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
5378 : :
5379 : 0 : return ZXDH_RC_DTB_OVER_TIME;
5380 : : }
5381 : :
5382 : 0 : rd_cnt++;
5383 : 0 : rte_delay_us(ZXDH_DTB_DELAY_TIME);
5384 : : }
5385 : :
5386 [ # # ]: 0 : if ((ack_value & 0xff) != ZXDH_DTB_TAB_ACK_SUCCESS_MASK) {
5387 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5388 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
5389 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
5390 : 0 : return ack_value & 0xff;
5391 : : }
5392 : :
5393 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5394 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
5395 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
5396 : :
5397 : 0 : return rc;
5398 : : }
5399 : :
5400 : : static uint32_t
5401 : 0 : zxdh_np_hash_get_hash_info_from_sdt(uint32_t dev_id,
5402 : : uint32_t sdt_no, HASH_ENTRY_CFG *p_hash_entry_cfg)
5403 : : {
5404 : : uint32_t rc = ZXDH_OK;
5405 : : ZXDH_FUNC_ID_INFO *p_func_info = NULL;
5406 : : ZXDH_SE_CFG *p_se_cfg = NULL;
5407 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash_info = {0};
5408 : :
5409 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
5410 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash_info);
5411 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_read");
5412 : :
5413 : 0 : p_hash_entry_cfg->fun_id = sdt_hash_info.hash_id;
5414 : 0 : p_hash_entry_cfg->table_id = sdt_hash_info.hash_table_id;
5415 : 0 : p_hash_entry_cfg->bulk_id = ((p_hash_entry_cfg->table_id >> 2) & 0x7);
5416 : 0 : p_hash_entry_cfg->key_type = sdt_hash_info.hash_table_width;
5417 : 0 : p_hash_entry_cfg->rsp_mode = sdt_hash_info.rsp_mode;
5418 : 0 : p_hash_entry_cfg->actu_key_size = sdt_hash_info.key_size;
5419 : 0 : p_hash_entry_cfg->key_by_size = ZXDH_GET_KEY_SIZE(p_hash_entry_cfg->actu_key_size);
5420 [ # # ]: 0 : p_hash_entry_cfg->rst_by_size = ZXDH_GET_RST_SIZE(p_hash_entry_cfg->key_type,
5421 : : p_hash_entry_cfg->actu_key_size);
5422 : :
5423 : 0 : p_se_cfg = dpp_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
5424 : 0 : p_hash_entry_cfg->p_se_cfg = p_se_cfg;
5425 : :
5426 : : p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, p_hash_entry_cfg->fun_id);
5427 : :
5428 : 0 : p_hash_entry_cfg->p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
5429 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_entry_cfg->p_hash_cfg);
5430 : :
5431 : 0 : return ZXDH_OK;
5432 : : }
5433 : :
5434 : : static void
5435 : 0 : zxdh_np_hash_set_crc_key(HASH_ENTRY_CFG *p_hash_entry_cfg,
5436 : : ZXDH_HASH_ENTRY *p_entry, uint8_t *p_temp_key)
5437 : : {
5438 : : uint32_t key_by_size = 0;
5439 : : uint8_t temp_tbl_id = 0;
5440 : :
5441 : 0 : key_by_size = p_hash_entry_cfg->key_by_size;
5442 : 0 : memcpy(p_temp_key, p_entry->p_key, key_by_size);
5443 : :
5444 : 0 : temp_tbl_id = (*p_temp_key) & 0x1F;
5445 : 0 : memmove(p_temp_key, p_temp_key + 1, key_by_size - ZXDH_HASH_KEY_CTR_SIZE);
5446 : 0 : p_temp_key[key_by_size - ZXDH_HASH_KEY_CTR_SIZE] = temp_tbl_id;
5447 : 0 : }
5448 : :
5449 : : static uint8_t
5450 : 0 : zxdh_np_hash_sdt_partner_valid(uint32_t sdt_no, uint32_t sdt_partner, uint8_t *p_key)
5451 : : {
5452 : : uint32_t rc = ZXDH_OK;
5453 : : uint32_t dev_id = 0;
5454 : : uint32_t key_valid = 1;
5455 : :
5456 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash1 = {0};
5457 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash2 = {0};
5458 : :
5459 : 0 : if (sdt_no == sdt_partner ||
5460 [ # # # # ]: 0 : sdt_partner <= ZXDH_DEV_SDT_ID_MAX ||
5461 : : p_key == NULL) {
5462 : : return ZXDH_FALSE;
5463 : : }
5464 : :
5465 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
5466 : 0 : PMD_DRV_LOG(DEBUG, "sdt_partner:%u", sdt_partner);
5467 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash1);
5468 : 0 : rc |= zxdh_np_soft_sdt_tbl_get(dev_id, sdt_partner, &sdt_hash2);
5469 [ # # ]: 0 : if (rc != ZXDH_OK)
5470 : : return ZXDH_FALSE;
5471 : :
5472 [ # # ]: 0 : if (sdt_hash1.table_type != (ZXDH_SDT_TBLT_HASH) ||
5473 [ # # ]: 0 : sdt_hash2.table_type != ZXDH_SDT_TBLT_HASH ||
5474 [ # # ]: 0 : sdt_hash1.hash_table_width != sdt_hash2.hash_table_width ||
5475 [ # # ]: 0 : sdt_hash1.key_size != sdt_hash2.key_size ||
5476 [ # # ]: 0 : sdt_hash1.rsp_mode != sdt_hash2.rsp_mode) {
5477 : : return ZXDH_FALSE;
5478 : : }
5479 : :
5480 : 0 : *p_key = ZXDH_GET_HASH_KEY_CTRL(key_valid,
5481 : : sdt_hash2.hash_table_width,
5482 : : sdt_hash2.hash_table_id);
5483 : :
5484 : 0 : return ZXDH_TRUE;
5485 : : }
5486 : :
5487 : : static uint32_t
5488 : 0 : zxdh_np_hash_red_black_node_alloc(ZXDH_RB_TN **p_rb_tn_new,
5489 : : ZXDH_HASH_RBKEY_INFO **p_rbkey_new)
5490 : : {
5491 : : ZXDH_RB_TN *p_rb_tn_new_temp = NULL;
5492 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_new_temp = NULL;
5493 : :
5494 : 0 : p_rbkey_new_temp = rte_zmalloc(NULL, sizeof(ZXDH_HASH_RBKEY_INFO), 0);
5495 [ # # ]: 0 : if (p_rbkey_new_temp == NULL) {
5496 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
5497 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5498 : : }
5499 : :
5500 : 0 : p_rb_tn_new_temp = rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
5501 [ # # ]: 0 : if (p_rb_tn_new_temp == NULL) {
5502 : 0 : rte_free(p_rbkey_new_temp);
5503 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
5504 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5505 : : }
5506 : :
5507 : : zxdh_np_init_rbt_tn(p_rb_tn_new_temp, p_rbkey_new_temp);
5508 : :
5509 : 0 : *p_rb_tn_new = p_rb_tn_new_temp;
5510 : 0 : *p_rbkey_new = p_rbkey_new_temp;
5511 : :
5512 : 0 : return ZXDH_OK;
5513 : : }
5514 : :
5515 : : static uint32_t
5516 : 0 : zxdh_np_hash_rb_insert(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5517 : : ZXDH_HASH_ENTRY *p_entry)
5518 : : {
5519 : : uint32_t rc = ZXDH_OK;
5520 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
5521 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
5522 : 0 : ZXDH_HASH_RBKEY_INFO *p_rbkey_new = p_hash_entry_cfg->p_rbkey_new;
5523 : 0 : ZXDH_RB_TN *p_rb_tn_new = p_hash_entry_cfg->p_rb_tn_new;
5524 : 0 : ZXDH_HASH_CFG *p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5525 : 0 : uint32_t rst_actual_size = ((p_hash_entry_cfg->rst_by_size) > ZXDH_HASH_RST_MAX) ?
5526 : : ZXDH_HASH_RST_MAX : p_hash_entry_cfg->rst_by_size;
5527 : :
5528 : 0 : rc = zxdh_comm_rb_insert(&p_hash_cfg->hash_rb, (void *)p_rb_tn_new, (void *)(&p_rb_tn_rtn));
5529 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_FULL) {
5530 : 0 : PMD_DRV_LOG(ERR, "The red black tree is full!");
5531 : 0 : rte_free(p_rbkey_new);
5532 : 0 : rte_free(p_rb_tn_new);
5533 : : RTE_ASSERT(0);
5534 : 0 : return ZXDH_HASH_RC_RB_TREE_FULL;
5535 [ # # ]: 0 : } else if (rc == ZXDH_RBT_RC_UPDATE) {
5536 : 0 : p_hash_cfg->hash_stat.insert_same++;
5537 : 0 : PMD_DRV_LOG(DEBUG, "Hash update exist entry!");
5538 : :
5539 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
5540 : 0 : p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
5541 : :
5542 : 0 : memcpy(p_rbkey_rtn->rst, p_entry->p_rst, rst_actual_size);
5543 : :
5544 : 0 : rte_free(p_rbkey_new);
5545 : 0 : rte_free(p_rb_tn_new);
5546 : 0 : p_hash_entry_cfg->p_rbkey_new = p_rbkey_rtn;
5547 : 0 : p_hash_entry_cfg->p_rb_tn_new = p_rb_tn_rtn;
5548 : :
5549 : 0 : return ZXDH_HASH_RC_ADD_UPDATE;
5550 : : }
5551 : 0 : PMD_DRV_LOG(DEBUG, "Hash insert new entry!");
5552 : :
5553 [ # # ]: 0 : memcpy(p_rbkey_new->rst, p_entry->p_rst, rst_actual_size);
5554 [ # # ]: 0 : p_rbkey_new->entry_size = ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type);
5555 : : zxdh_np_init_d_node(&p_rbkey_new->entry_dn, p_rbkey_new);
5556 : :
5557 : 0 : return rc;
5558 : : }
5559 : :
5560 : : static uint32_t
5561 : : zxdh_np_hash_get_item_free_pos(uint32_t item_entry_max,
5562 : : uint32_t wrt_mask, uint32_t entry_size)
5563 : : {
5564 : : uint32_t i = 0;
5565 : : uint32_t pos = 0xFFFFFFFF;
5566 : : uint32_t mask = 0;
5567 : :
5568 [ # # ]: 0 : for (i = 0; i < item_entry_max; i += entry_size / ZXDH_HASH_ENTRY_POS_STEP) {
5569 : : mask = ZXDH_GET_HASH_ENTRY_MASK(entry_size, i);
5570 : :
5571 [ # # ]: 0 : if (0 == (mask & wrt_mask)) {
5572 : : pos = i;
5573 : : break;
5574 : : }
5575 : : }
5576 : :
5577 : : return pos;
5578 : : }
5579 : :
5580 : : static uint32_t
5581 : 0 : zxdh_np_hash_insrt_to_item(ZXDH_HASH_CFG *p_hash_cfg,
5582 : : ZXDH_HASH_RBKEY_INFO *p_rbkey,
5583 : : ZXDH_SE_ITEM_CFG *p_item,
5584 : : uint32_t item_idx,
5585 : : uint32_t item_type,
5586 : : __rte_unused uint32_t insrt_key_type)
5587 : : {
5588 : : uint32_t rc = ZXDH_OK;
5589 : :
5590 : : uint32_t free_pos = 0;
5591 : 0 : uint32_t dev_id = p_hash_cfg->p_se_info->dev_id;
5592 : : uint32_t item_entry_max = 4;
5593 : :
5594 [ # # ]: 0 : if (item_type == ZXDH_ITEM_DDR_256)
5595 : : item_entry_max = 2;
5596 : :
5597 [ # # ]: 0 : if (!p_item->valid) {
5598 : 0 : rc = zxdh_comm_double_link_init(item_entry_max, &p_item->item_list);
5599 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
5600 : :
5601 : 0 : p_rbkey->entry_pos = 0;
5602 : 0 : p_item->wrt_mask = ZXDH_GET_HASH_ENTRY_MASK(p_rbkey->entry_size,
5603 : : p_rbkey->entry_pos);
5604 : 0 : p_item->item_index = item_idx;
5605 : 0 : p_item->item_type = item_type;
5606 : 0 : p_item->valid = 1;
5607 : : } else {
5608 : 0 : free_pos = zxdh_np_hash_get_item_free_pos(item_entry_max,
5609 : 0 : p_item->wrt_mask, p_rbkey->entry_size);
5610 : :
5611 [ # # ]: 0 : if (free_pos == 0xFFFFFFFF)
5612 : : return ZXDH_HASH_RC_ITEM_FULL;
5613 : 0 : p_rbkey->entry_pos = free_pos;
5614 : 0 : p_item->wrt_mask |=
5615 : : ZXDH_GET_HASH_ENTRY_MASK(p_rbkey->entry_size, p_rbkey->entry_pos);
5616 : : }
5617 : :
5618 : 0 : PMD_DRV_LOG(DEBUG, "pos is[%u], size is[%u]", free_pos, p_rbkey->entry_size);
5619 : :
5620 [ # # ]: 0 : rc = zxdh_comm_double_link_insert_last(&p_rbkey->entry_dn, &p_item->item_list);
5621 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_last");
5622 : :
5623 : 0 : p_rbkey->p_item_info = p_item;
5624 : :
5625 : 0 : return rc;
5626 : : }
5627 : :
5628 : : static uint32_t
5629 : 0 : zxdh_np_hash_insert_ddr(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5630 : : uint8_t *p_temp_key, uint8_t *p_end_flag)
5631 : : {
5632 : 0 : ZXDH_HASH_CFG *p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5633 : 0 : uint8_t bulk_id = p_hash_entry_cfg->bulk_id;
5634 : 0 : HASH_DDR_CFG *p_ddr_cfg = p_hash_cfg->p_bulk_ddr_info[bulk_id];
5635 : : uint8_t key_type = 0;
5636 : 0 : uint8_t table_id = p_hash_entry_cfg->table_id;
5637 : : uint32_t key_by_size = 0;
5638 : : uint32_t crc_value = 0;
5639 : : uint32_t item_idx = 0xFFFFFFFF;
5640 : : uint32_t item_type = 0;
5641 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5642 : : uint32_t rc = ZXDH_OK;
5643 : :
5644 : 0 : key_type = p_hash_entry_cfg->key_type;
5645 [ # # # # ]: 0 : if (ZXDH_HASH_KEY_512b == key_type && ZXDH_DDR_WIDTH_256b == p_ddr_cfg->width_mode) {
5646 : 0 : PMD_DRV_LOG(ERR, "hash ddr width mode is not match to the key type.");
5647 : 0 : return ZXDH_HASH_RC_DDR_WIDTH_MODE_ERR;
5648 : : }
5649 : :
5650 : 0 : key_by_size = p_hash_entry_cfg->key_by_size;
5651 : 0 : crc_value = p_hash_cfg->p_hash32_fun(p_temp_key, key_by_size, p_ddr_cfg->hash_ddr_arg);
5652 : 0 : PMD_DRV_LOG(DEBUG, "hash ddr arg is: 0x%x.crc_value is 0x%x",
5653 : : p_ddr_cfg->hash_ddr_arg, crc_value);
5654 : :
5655 : 0 : item_idx = crc_value % p_ddr_cfg->item_num;
5656 : : item_type = ZXDH_ITEM_DDR_256;
5657 [ # # ]: 0 : if (ZXDH_DDR_WIDTH_512b == p_ddr_cfg->width_mode) {
5658 : : item_idx = crc_value % p_ddr_cfg->item_num;
5659 : : item_type = ZXDH_ITEM_DDR_512;
5660 : : }
5661 : :
5662 : 0 : PMD_DRV_LOG(DEBUG, "Hash insert in ITEM_DDR_%s, item_idx is: 0x%x.",
5663 : : ((item_type == ZXDH_ITEM_DDR_256) ? "256" : "512"), item_idx);
5664 : :
5665 : 0 : p_item = p_ddr_cfg->p_item_array[item_idx];
5666 [ # # ]: 0 : if (p_item == NULL) {
5667 : 0 : p_item = rte_zmalloc(NULL, sizeof(ZXDH_SE_ITEM_CFG), 0);
5668 [ # # ]: 0 : if (p_item == NULL) {
5669 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
5670 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5671 : : }
5672 : 0 : p_ddr_cfg->p_item_array[item_idx] = p_item;
5673 : : }
5674 : :
5675 : 0 : rc = zxdh_np_hash_insrt_to_item(p_hash_cfg,
5676 : : p_hash_entry_cfg->p_rbkey_new,
5677 : : p_item,
5678 : : item_idx,
5679 : : item_type,
5680 : : key_type);
5681 : :
5682 [ # # ]: 0 : if (rc != ZXDH_HASH_RC_ITEM_FULL) {
5683 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_insrt_to_item");
5684 : 0 : *p_end_flag = 1;
5685 : :
5686 : 0 : p_hash_cfg->hash_stat.insert_ddr++;
5687 : 0 : p_hash_cfg->hash_stat.insert_table[table_id].ddr++;
5688 : :
5689 : 0 : p_item->hw_addr = GET_HASH_DDR_HW_ADDR(p_ddr_cfg->hw_baddr, item_idx);
5690 : 0 : p_item->bulk_id = p_hash_entry_cfg->bulk_id;
5691 : : }
5692 : :
5693 : : return rc;
5694 : : }
5695 : :
5696 : : static uint32_t
5697 : 0 : zxdh_np_hash_insert_zcell(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5698 : : uint8_t *p_temp_key, uint8_t *p_end_flag)
5699 : : {
5700 : 0 : uint8_t bulk_id = p_hash_entry_cfg->bulk_id;
5701 : : ZXDH_D_NODE *p_zcell_dn = NULL;
5702 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
5703 : : uint32_t zblk_idx = 0;
5704 : : uint32_t zcell_id = 0;
5705 : : uint32_t pre_zblk_idx = 0xFFFFFFFF;
5706 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5707 : : uint32_t item_idx = 0xFFFFFFFF;
5708 : : uint32_t item_type = 0;
5709 : : uint32_t rc = ZXDH_OK;
5710 : : uint32_t crc_value = 0;
5711 : 0 : uint8_t table_id = p_hash_entry_cfg->table_id;
5712 : : ZXDH_SE_CFG *p_se_cfg = NULL;
5713 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
5714 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
5715 : :
5716 : 0 : PMD_DRV_LOG(DEBUG, "insert zcell start");
5717 : 0 : p_se_cfg = p_hash_entry_cfg->p_se_cfg;
5718 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
5719 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5720 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
5721 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
5722 : :
5723 [ # # ]: 0 : while (p_zcell_dn) {
5724 : 0 : p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
5725 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_zcell);
5726 : :
5727 [ # # # # : 0 : if (((p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO) && p_zcell->bulk_id != bulk_id) ||
# # ]
5728 : 0 : ((!(p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO)) &&
5729 [ # # ]: 0 : p_hash_cfg->bulk_ram_mono[bulk_id])) {
5730 : 0 : p_zcell_dn = p_zcell_dn->next;
5731 : 0 : continue;
5732 : : }
5733 : :
5734 : 0 : zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
5735 : : p_zblk = &p_se_cfg->zblk_info[zblk_idx];
5736 [ # # ]: 0 : if (zblk_idx != pre_zblk_idx) {
5737 : : pre_zblk_idx = zblk_idx;
5738 : 0 : crc_value = p_hash_cfg->p_hash16_fun(p_temp_key,
5739 : 0 : p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
5740 : : }
5741 : :
5742 : 0 : PMD_DRV_LOG(DEBUG, "zblk_idx:[0x%x] hash_arg:[0x%x] crc_value:[0x%x]",
5743 : : zblk_idx, p_zblk->hash_arg, crc_value);
5744 : :
5745 : 0 : zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
5746 : 0 : item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc_value);
5747 : 0 : p_item = &p_zcell->item_info[item_idx];
5748 : : item_type = ZXDH_ITEM_RAM;
5749 : :
5750 : 0 : PMD_DRV_LOG(DEBUG, "zcell_id:[0x%x] item_idx:[0x%x]", zcell_id, item_idx);
5751 : :
5752 : 0 : rc = zxdh_np_hash_insrt_to_item(p_hash_cfg,
5753 : : p_hash_entry_cfg->p_rbkey_new,
5754 : : p_item,
5755 : : item_idx,
5756 : : item_type,
5757 : 0 : p_hash_entry_cfg->key_type);
5758 : :
5759 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_ITEM_FULL) {
5760 : 0 : PMD_DRV_LOG(DEBUG, "The item is full, check next.");
5761 : : } else {
5762 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_insrt_to_item");
5763 : 0 : *p_end_flag = 1;
5764 : :
5765 : 0 : p_hash_cfg->hash_stat.insert_zcell++;
5766 : 0 : p_hash_cfg->hash_stat.insert_table[table_id].zcell++;
5767 : :
5768 : 0 : p_item->hw_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
5769 : 0 : break;
5770 : : }
5771 : :
5772 : 0 : p_zcell_dn = p_zcell_dn->next;
5773 : : }
5774 : :
5775 : 0 : return rc;
5776 : : }
5777 : :
5778 : : static uint32_t
5779 : 0 : zxdh_np_hash_insert_zreg(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5780 : : __rte_unused uint8_t *p_temp_key, uint8_t *p_end_flag)
5781 : : {
5782 : 0 : ZXDH_HASH_CFG *p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5783 : 0 : ZXDH_D_NODE *p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
5784 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
5785 : : ZXDH_SE_ZREG_CFG *p_zreg = NULL;
5786 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5787 : : uint8_t reg_index = 0;
5788 : : uint32_t zblk_idx = 0;
5789 : : uint32_t rc = ZXDH_OK;
5790 : 0 : uint8_t bulk_id = p_hash_entry_cfg->bulk_id;
5791 : : uint32_t item_idx = 0xFFFFFFFF;
5792 : : uint32_t item_type = 0;
5793 : 0 : uint32_t table_id = p_hash_entry_cfg->table_id;
5794 : :
5795 [ # # ]: 0 : while (p_zblk_dn) {
5796 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
5797 : 0 : zblk_idx = p_zblk->zblk_idx;
5798 : :
5799 [ # # ]: 0 : for (reg_index = 0; reg_index < ZXDH_SE_ZREG_NUM; reg_index++) {
5800 : 0 : p_zreg = &p_zblk->zreg_info[reg_index];
5801 : :
5802 [ # # ]: 0 : if (((p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO) &&
5803 [ # # # # ]: 0 : p_zreg->bulk_id != bulk_id) ||
5804 : 0 : ((!(p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO)) &&
5805 [ # # ]: 0 : p_hash_cfg->bulk_ram_mono[bulk_id])) {
5806 : 0 : continue;
5807 : : }
5808 : :
5809 : 0 : p_item = &p_zblk->zreg_info[reg_index].item_info;
5810 : : item_type = ZXDH_ITEM_REG;
5811 : 0 : item_idx = reg_index;
5812 : 0 : rc = zxdh_np_hash_insrt_to_item(p_hash_cfg,
5813 : : p_hash_entry_cfg->p_rbkey_new,
5814 : : p_item,
5815 : : item_idx,
5816 : : item_type,
5817 : 0 : p_hash_entry_cfg->key_type);
5818 : :
5819 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_ITEM_FULL) {
5820 : 0 : PMD_DRV_LOG(DEBUG, "The item is full, check next.");
5821 : : } else {
5822 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_insrt_to_item");
5823 : 0 : *p_end_flag = 1;
5824 : :
5825 : 0 : p_hash_cfg->hash_stat.insert_zreg++;
5826 : 0 : p_hash_cfg->hash_stat.insert_table[table_id].zreg++;
5827 : :
5828 : 0 : p_item->hw_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx,
5829 : : reg_index);
5830 : 0 : break;
5831 : : }
5832 : : }
5833 : :
5834 [ # # ]: 0 : if (*p_end_flag)
5835 : : break;
5836 : :
5837 : 0 : p_zblk_dn = p_zblk_dn->next;
5838 : : }
5839 : :
5840 : 0 : return rc;
5841 : : }
5842 : :
5843 : : static uint32_t
5844 : 0 : zxdh_np_dtb_hash_form_write(ZXDH_HASH_CFG *p_hash_cfg,
5845 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_new,
5846 : : uint32_t actu_key_size,
5847 : : ZXDH_DTB_ENTRY_T *p_entry,
5848 : : __rte_unused uint32_t opr_mode)
5849 : : {
5850 : : uint32_t key_type = 0;
5851 : : uint32_t key_by_size = 0;
5852 : : uint32_t rst_by_size = 0;
5853 : : uint32_t byte_offset = 0;
5854 : 0 : uint32_t dev_id = p_hash_cfg->p_se_info->dev_id;
5855 : : uint32_t addr;
5856 : :
5857 : : ZXDH_D_NODE *p_entry_dn = NULL;
5858 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
5859 : 0 : uint8_t entry_data[ZXDH_SE_ENTRY_WIDTH_MAX] = {0};
5860 : 0 : ZXDH_SE_ITEM_CFG *p_item_info = p_rbkey_new->p_item_info;
5861 : :
5862 [ # # ]: 0 : if (p_item_info == NULL) {
5863 : 0 : PMD_DRV_LOG(ERR, "p_item_info point null!");
5864 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5865 : : }
5866 : :
5867 : 0 : PMD_DRV_LOG(DEBUG, "zcam p_item_info->hw_addr is 0x%x",
5868 : : p_item_info->hw_addr);
5869 : 0 : addr = p_item_info->hw_addr;
5870 : :
5871 : 0 : p_entry_dn = p_item_info->item_list.p_next;
5872 : :
5873 [ # # ]: 0 : while (p_entry_dn) {
5874 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)(p_entry_dn->data);
5875 : 0 : key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
5876 [ # # ]: 0 : key_by_size = ZXDH_GET_KEY_SIZE(actu_key_size);
5877 : : rst_by_size = ZXDH_GET_RST_SIZE(key_type, actu_key_size);
5878 : :
5879 : 0 : byte_offset = p_rbkey->entry_pos * ZXDH_HASH_ENTRY_POS_STEP;
5880 : 0 : memcpy(entry_data + byte_offset, p_rbkey->key, key_by_size);
5881 : :
5882 : 0 : byte_offset += key_by_size;
5883 : 0 : memcpy(entry_data + byte_offset, p_rbkey->rst,
5884 : 0 : ((rst_by_size > ZXDH_HASH_RST_MAX) ? ZXDH_HASH_RST_MAX : rst_by_size));
5885 : :
5886 : 0 : p_entry_dn = p_entry_dn->next;
5887 : : }
5888 : :
5889 : : zxdh_np_comm_swap(entry_data, ZXDH_SE_ENTRY_WIDTH_MAX);
5890 : :
5891 : 0 : zxdh_np_dtb_se_alg_zcam_data_write(dev_id,
5892 : : addr,
5893 : : entry_data,
5894 : : p_entry);
5895 : :
5896 : 0 : return ZXDH_OK;
5897 : : }
5898 : :
5899 : : static uint32_t
5900 : 0 : zxdh_np_dtb_hash_delete(uint32_t dev_id,
5901 : : uint32_t sdt_no,
5902 : : ZXDH_HASH_ENTRY *p_hash_entry,
5903 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
5904 : : {
5905 : : uint32_t rc = ZXDH_OK;
5906 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
5907 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5908 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
5909 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
5910 : : ZXDH_SPINLOCK_T *p_hash_spinlock = NULL;
5911 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
5912 : 0 : ZXDH_HASH_RBKEY_INFO temp_rbkey = {0};
5913 : : HASH_DDR_CFG *bulk_ddr_info = NULL;
5914 : :
5915 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
5916 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
5917 : :
5918 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
5919 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
5920 : :
5921 : 0 : zxdh_np_dev_hash_opr_spinlock_get(dev_id, p_hash_cfg->fun_id, &p_hash_spinlock);
5922 : 0 : rte_spinlock_lock(&p_hash_spinlock->spinlock);
5923 : :
5924 : 0 : memcpy(temp_rbkey.key, p_hash_entry->p_key, hash_entry_cfg.key_by_size);
5925 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, &temp_rbkey, &p_rb_tn_rtn);
5926 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL) {
5927 : 0 : p_hash_cfg->hash_stat.delete_fail++;
5928 : 0 : PMD_DRV_LOG(ERR, "Error!there is not item in hash!");
5929 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5930 : 0 : return ZXDH_HASH_RC_DEL_SRHFAIL;
5931 : : }
5932 : :
5933 : 0 : p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
5934 [ # # ]: 0 : memset(p_rbkey_rtn->rst, 0, sizeof(p_rbkey_rtn->rst));
5935 : 0 : hash_entry_cfg.p_rbkey_new = p_rbkey_rtn;
5936 : 0 : hash_entry_cfg.p_rb_tn_new = p_rb_tn_rtn;
5937 : :
5938 [ # # ]: 0 : p_item = p_rbkey_rtn->p_item_info;
5939 : : rc = zxdh_comm_double_link_del(&p_rbkey_rtn->entry_dn, &p_item->item_list);
5940 : : if (rc != ZXDH_OK) {
5941 : : PMD_DRV_LOG(ERR, "zxdh_comm_double_link_del failed, rc=0x%x.", rc);
5942 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5943 : : return ZXDH_ERR;
5944 : : }
5945 : 0 : p_item->wrt_mask &= ~(ZXDH_GET_HASH_ENTRY_MASK(p_rbkey_rtn->entry_size,
5946 : 0 : p_rbkey_rtn->entry_pos)) & 0xF;
5947 : :
5948 : 0 : rc = zxdh_np_dtb_hash_form_write(hash_entry_cfg.p_hash_cfg,
5949 : : hash_entry_cfg.p_rbkey_new,
5950 : : hash_entry_cfg.actu_key_size,
5951 : : p_dtb_one_entry,
5952 : : ZXDH_DTB_ITEM_DELETE);
5953 [ # # ]: 0 : if (rc != ZXDH_OK) {
5954 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_dtb_hash_form_write failed, rc=0x%x.", rc);
5955 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5956 : 0 : return ZXDH_ERR;
5957 : : }
5958 : :
5959 [ # # ]: 0 : if (p_item->item_list.used == 0) {
5960 [ # # ]: 0 : if (p_item->item_type == ZXDH_ITEM_DDR_256 ||
5961 : : p_item->item_type == ZXDH_ITEM_DDR_512) {
5962 : 0 : bulk_ddr_info = p_hash_cfg->p_bulk_ddr_info[hash_entry_cfg.bulk_id];
5963 [ # # ]: 0 : if (p_item->item_index > bulk_ddr_info->item_num) {
5964 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5965 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
5966 : : }
5967 : 0 : bulk_ddr_info->p_item_array[p_item->item_index] = NULL;
5968 : 0 : rte_free(p_item);
5969 : : } else {
5970 : 0 : p_item->valid = 0;
5971 : : }
5972 : : }
5973 : :
5974 : 0 : rte_free(p_rbkey_rtn);
5975 : 0 : rte_free(p_rb_tn_rtn);
5976 : 0 : p_hash_cfg->hash_stat.delete_ok++;
5977 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5978 : 0 : return rc;
5979 : : }
5980 : :
5981 : : static uint32_t
5982 : 0 : zxdh_np_dtb_hash_insert(uint32_t dev_id,
5983 : : uint32_t sdt_no,
5984 : : ZXDH_HASH_ENTRY *p_hash_entry,
5985 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
5986 : : {
5987 : : uint32_t rc = ZXDH_OK;
5988 : 0 : uint8_t end_flag = 0;
5989 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
5990 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
5991 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
5992 : 0 : ZXDH_RB_TN *p_rb_tn_new = NULL;
5993 : 0 : ZXDH_HASH_RBKEY_INFO *p_rbkey_new = NULL;
5994 : : ZXDH_SPINLOCK_T *p_hash_spinlock = NULL;
5995 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
5996 : :
5997 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
5998 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
5999 : :
6000 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
6001 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
6002 : :
6003 : 0 : zxdh_np_dev_hash_opr_spinlock_get(dev_id, p_hash_cfg->fun_id, &p_hash_spinlock);
6004 : 0 : rte_spinlock_lock(&p_hash_spinlock->spinlock);
6005 : :
6006 : 0 : rc = zxdh_np_hash_red_black_node_alloc(&p_rb_tn_new, &p_rbkey_new);
6007 [ # # ]: 0 : if (rc != ZXDH_OK) {
6008 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_hash_red_black_node_alloc failed, rc=0x%x.", rc);
6009 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6010 : 0 : return ZXDH_ERR;
6011 : : }
6012 : 0 : memcpy(p_rbkey_new->key, p_hash_entry->p_key,
6013 : 0 : hash_entry_cfg.key_by_size);
6014 : 0 : hash_entry_cfg.p_rbkey_new = p_rbkey_new;
6015 : 0 : hash_entry_cfg.p_rb_tn_new = p_rb_tn_new;
6016 : :
6017 : 0 : rc = zxdh_np_hash_rb_insert(dev_id, &hash_entry_cfg, p_hash_entry);
6018 [ # # ]: 0 : if (rc != ZXDH_OK) {
6019 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_ADD_UPDATE) {
6020 : 0 : rc = zxdh_np_dtb_hash_form_write(p_hash_cfg,
6021 : : hash_entry_cfg.p_rbkey_new,
6022 : : hash_entry_cfg.actu_key_size,
6023 : : p_dtb_one_entry,
6024 : : ZXDH_DTB_ITEM_ADD_OR_UPDATE);
6025 [ # # ]: 0 : if (rc != ZXDH_OK) {
6026 : 0 : PMD_DRV_LOG(ERR, "dtb_hash_form_write failed, rc=0x%x.", rc);
6027 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6028 : 0 : return ZXDH_ERR;
6029 : : }
6030 : : }
6031 : :
6032 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6033 : 0 : return rc;
6034 : : }
6035 : :
6036 : 0 : zxdh_np_hash_set_crc_key(&hash_entry_cfg, p_hash_entry, temp_key);
6037 : :
6038 [ # # ]: 0 : if (p_hash_cfg->ddr_valid) {
6039 : 0 : rc = zxdh_np_hash_insert_ddr(dev_id, &hash_entry_cfg, temp_key, &end_flag);
6040 [ # # ]: 0 : if (rc != ZXDH_OK) {
6041 : 0 : PMD_DRV_LOG(ERR, "hash_insert_ddr failed, rc=0x%x.", rc);
6042 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6043 : 0 : return ZXDH_ERR;
6044 : : }
6045 : : }
6046 : :
6047 [ # # ]: 0 : if (!end_flag) {
6048 : 0 : rc = zxdh_np_hash_insert_zcell(dev_id, &hash_entry_cfg, temp_key, &end_flag);
6049 [ # # ]: 0 : if (rc != ZXDH_OK) {
6050 : 0 : PMD_DRV_LOG(ERR, "hash_insert_zcell failed, rc=0x%x.", rc);
6051 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6052 : 0 : return ZXDH_ERR;
6053 : : }
6054 : : }
6055 : :
6056 [ # # ]: 0 : if (!end_flag) {
6057 : 0 : rc = zxdh_np_hash_insert_zreg(dev_id, &hash_entry_cfg, temp_key, &end_flag);
6058 [ # # ]: 0 : if (rc != ZXDH_OK) {
6059 : 0 : PMD_DRV_LOG(ERR, "hash_insert_zreg failed, rc=0x%x.", rc);
6060 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6061 : 0 : return ZXDH_ERR;
6062 : : }
6063 : : }
6064 : :
6065 [ # # ]: 0 : if (!end_flag) {
6066 : 0 : p_hash_cfg->hash_stat.insert_fail++;
6067 : 0 : memcpy(temp_key, p_hash_entry->p_key, hash_entry_cfg.key_by_size);
6068 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, p_rbkey_new, &p_rb_tn_rtn);
6069 [ # # ]: 0 : if (rc != ZXDH_OK) {
6070 : 0 : PMD_DRV_LOG(ERR, "hash_insert_zreg failed, rc=0x%x.", rc);
6071 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6072 : 0 : return ZXDH_ERR;
6073 : : }
6074 : : RTE_ASSERT(p_rb_tn_new == p_rb_tn_rtn);
6075 : 0 : rte_free(p_rbkey_new);
6076 : 0 : rte_free(p_rb_tn_rtn);
6077 : 0 : PMD_DRV_LOG(ERR, "ZXDH_HASH_RC_TBL_FULL.sdt_no=%u", sdt_no);
6078 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6079 : 0 : return ZXDH_RC_DTB_DOWN_HASH_CONFLICT;
6080 : : }
6081 : :
6082 : 0 : rc = zxdh_np_dtb_hash_form_write(p_hash_cfg,
6083 : : hash_entry_cfg.p_rbkey_new,
6084 : : hash_entry_cfg.actu_key_size,
6085 : : p_dtb_one_entry,
6086 : : ZXDH_DTB_ITEM_ADD_OR_UPDATE);
6087 [ # # ]: 0 : if (rc != ZXDH_OK) {
6088 : 0 : PMD_DRV_LOG(ERR, "hash form write failed, rc=0x%x.", rc);
6089 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6090 : 0 : return ZXDH_ERR;
6091 : : }
6092 : :
6093 : 0 : p_hash_cfg->hash_stat.insert_ok++;
6094 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
6095 : 0 : return rc;
6096 : : }
6097 : :
6098 : : static uint32_t
6099 : : zxdh_np_apt_get_sdt_partner(uint32_t dev_id, uint32_t sdt_no)
6100 : : {
6101 : : SE_APT_CALLBACK_T *p_apt_callback = NULL;
6102 : :
6103 : 0 : p_apt_callback = &g_apt_se_callback[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no];
6104 : :
6105 [ # # # # : 0 : if (p_apt_callback->table_type == ZXDH_SDT_TBLT_HASH)
# # # # #
# # # # #
# # ]
6106 : 0 : return p_apt_callback->se_func_info.hash_func.sdt_partner;
6107 : :
6108 [ # # # # : 0 : if (p_apt_callback->table_type == ZXDH_SDT_TBLT_ETCAM)
# # # # #
# # # # #
# # ]
6109 : 0 : return p_apt_callback->se_func_info.acl_func.sdt_partner;
6110 : :
6111 : : return UINT32_MAX;
6112 : : }
6113 : :
6114 : : static uint32_t
6115 : 0 : zxdh_np_dtb_hash_one_entry(uint32_t dev_id,
6116 : : uint32_t sdt_no,
6117 : : uint32_t del_en,
6118 : : void *p_data,
6119 : : uint32_t *p_dtb_len,
6120 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
6121 : : {
6122 : : uint32_t rc = ZXDH_OK;
6123 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
6124 : 0 : uint8_t temp_rst[ZXDH_HASH_RST_MAX] = {0};
6125 : : uint8_t key_valid = 1;
6126 : 0 : uint8_t key = 0;
6127 : : uint32_t sdt_partner = 0;
6128 : : uint8_t valid = 0;
6129 : :
6130 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash = {0};
6131 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_entry = NULL;
6132 : : ZXDH_HASH_ENTRY entry = {0};
6133 : :
6134 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6135 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash);
6136 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
6137 : :
6138 : 0 : entry.p_key = temp_key;
6139 : 0 : entry.p_rst = temp_rst;
6140 : 0 : entry.p_key[0] = ZXDH_GET_HASH_KEY_CTRL(key_valid,
6141 : : sdt_hash.hash_table_width,
6142 : : sdt_hash.hash_table_id);
6143 : : p_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_data;
6144 : 0 : memcpy(&entry.p_key[1], p_entry->p_actu_key,
6145 [ # # ]: 0 : ZXDH_GET_ACTU_KEY_BY_SIZE(sdt_hash.key_size));
6146 : 0 : memcpy(entry.p_rst, p_entry->p_rst, 4 * (0x1 << sdt_hash.rsp_mode));
6147 : :
6148 [ # # ]: 0 : if (del_en) {
6149 : : do {
6150 : 0 : rc = zxdh_np_dtb_hash_delete(dev_id, sdt_no, &entry, p_dtb_one_entry);
6151 : : sdt_partner = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
6152 : 0 : valid = zxdh_np_hash_sdt_partner_valid(sdt_no, sdt_partner, &key);
6153 : 0 : entry.p_key[0] = key;
6154 : : sdt_no = sdt_partner;
6155 [ # # ]: 0 : } while ((rc == ZXDH_HASH_RC_DEL_SRHFAIL) && (valid == ZXDH_TRUE));
6156 : :
6157 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_delete");
6158 : : } else {
6159 : : do {
6160 : 0 : rc = zxdh_np_dtb_hash_insert(dev_id, sdt_no, &entry, p_dtb_one_entry);
6161 : : sdt_partner = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
6162 : 0 : valid = zxdh_np_hash_sdt_partner_valid(sdt_no, sdt_partner, &key);
6163 : 0 : entry.p_key[0] = key;
6164 : : sdt_no = sdt_partner;
6165 [ # # ]: 0 : } while ((rc == ZXDH_RC_DTB_DOWN_HASH_CONFLICT) && (valid == ZXDH_TRUE));
6166 : :
6167 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_insert");
6168 : : }
6169 : :
6170 : 0 : *p_dtb_len = p_dtb_one_entry->data_size / ZXDH_DTB_LEN_POS_SETP + 1;
6171 : :
6172 : 0 : return rc;
6173 : : }
6174 : :
6175 : : static void
6176 : 0 : zxdh_np_acl_hdw_addr_get(ZXDH_ACL_TBL_CFG_T *p_tbl_cfg, uint32_t handle,
6177 : : uint32_t *p_block_idx, uint32_t *p_addr, uint32_t *p_wr_mask)
6178 : : {
6179 : 0 : uint32_t block_entry_num = ZXDH_ACL_ENTRY_MAX_GET(p_tbl_cfg->key_mode, 1);
6180 : 0 : uint32_t entry_pos = (handle % block_entry_num) % (1U << p_tbl_cfg->key_mode);
6181 : :
6182 : 0 : *p_block_idx = p_tbl_cfg->block_array[handle / block_entry_num];
6183 : 0 : *p_addr = (handle % block_entry_num) / (1U << p_tbl_cfg->key_mode);
6184 : 0 : *p_wr_mask = (((1U << (8U >> (p_tbl_cfg->key_mode))) - 1) <<
6185 : 0 : ((8U >> (p_tbl_cfg->key_mode)) * (entry_pos))) & 0xFF;
6186 : 0 : }
6187 : :
6188 : : static void
6189 : 0 : zxdh_np_etcam_dm_to_xy(ZXDH_ETCAM_ENTRY_T *p_dm,
6190 : : ZXDH_ETCAM_ENTRY_T *p_xy,
6191 : : uint32_t len)
6192 : : {
6193 : : uint32_t i = 0;
6194 : :
6195 : : RTE_ASSERT(p_dm->p_data && p_dm->p_mask && p_xy->p_data && p_xy->p_mask);
6196 : :
6197 [ # # ]: 0 : for (i = 0; i < len; i++) {
6198 : 0 : p_xy->p_data[i] = ZXDH_COMM_DM_TO_X(p_dm->p_data[i], p_dm->p_mask[i]);
6199 : 0 : p_xy->p_mask[i] = ZXDH_COMM_DM_TO_Y(p_dm->p_data[i], p_dm->p_mask[i]);
6200 : : }
6201 : 0 : }
6202 : :
6203 : : static uint32_t
6204 : : zxdh_np_eram_opr_mode_get(uint32_t as_mode)
6205 : : {
6206 : : uint32_t opr_mode = 0;
6207 : :
6208 [ # # # # : 0 : switch (as_mode) {
# # ]
6209 : : case ZXDH_ERAM128_TBL_128b:
6210 : : opr_mode = ZXDH_ERAM128_OPR_128b;
6211 : : break;
6212 : 0 : case ZXDH_ERAM128_TBL_64b:
6213 : : opr_mode = ZXDH_ERAM128_OPR_64b;
6214 : 0 : break;
6215 : 0 : case ZXDH_ERAM128_TBL_1b:
6216 : : opr_mode = ZXDH_ERAM128_OPR_1b;
6217 : 0 : break;
6218 : : default:
6219 : : break;
6220 : : }
6221 : :
6222 : : return opr_mode;
6223 : : }
6224 : :
6225 : : static uint32_t
6226 : 0 : zxdh_np_dtb_etcam_entry_add(uint32_t dev_id,
6227 : : uint32_t addr,
6228 : : uint32_t block_idx,
6229 : : uint32_t wr_mask,
6230 : : uint32_t opr_type,
6231 : : ZXDH_ETCAM_ENTRY_T *p_entry,
6232 : : ZXDH_DTB_ENTRY_T *p_entry_data,
6233 : : ZXDH_DTB_ENTRY_T *p_entry_mask)
6234 : : {
6235 : : uint32_t rc = ZXDH_OK;
6236 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6237 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6238 : 0 : ZXDH_ETCAM_ENTRY_T entry_xy = {0};
6239 : :
6240 : : RTE_ASSERT(p_entry->p_data && p_entry->p_mask);
6241 : :
6242 : 0 : entry_xy.p_data = temp_data;
6243 : 0 : entry_xy.p_mask = temp_mask;
6244 : :
6245 [ # # ]: 0 : if (opr_type == ZXDH_ETCAM_OPR_DM) {
6246 : 0 : zxdh_np_etcam_dm_to_xy(p_entry, &entry_xy,
6247 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
6248 : : } else {
6249 : 0 : memcpy(entry_xy.p_data, p_entry->p_data,
6250 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
6251 : 0 : memcpy(entry_xy.p_mask, p_entry->p_mask,
6252 : : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
6253 : : }
6254 : :
6255 : 0 : rc = zxdh_np_dtb_etcam_write_entry_data(dev_id, block_idx, 0, 1, 0, 0, 0,
6256 : : wr_mask, ZXDH_ETCAM_DTYPE_DATA, addr, 0, entry_xy.p_data, p_entry_data);
6257 : :
6258 : 0 : rc = zxdh_np_dtb_etcam_write_entry_data(dev_id, block_idx, 0, 1, 0, 0, 0,
6259 : : wr_mask, ZXDH_ETCAM_DTYPE_MASK, addr, 0xFF, entry_xy.p_mask, p_entry_mask);
6260 : :
6261 : 0 : return rc;
6262 : : }
6263 : :
6264 : : static uint32_t
6265 : 0 : zxdh_np_dtb_acl_delete(uint32_t dev_id,
6266 : : uint32_t sdt_no,
6267 : : ZXDH_ACL_ENTRY_EX_T *p_acl_entry,
6268 : : ZXDH_DTB_ENTRY_T *p_dtb_data_entry,
6269 : : ZXDH_DTB_ENTRY_T *p_dtb_mask_entry,
6270 : : ZXDH_DTB_ENTRY_T *p_dtb_as_entry)
6271 : : {
6272 : : uint32_t rc = ZXDH_OK;
6273 : : uint32_t as_eram_baddr = 0;
6274 : : uint32_t as_enable = 0;
6275 : : uint32_t etcam_table_id = 0;
6276 : : uint32_t etcam_as_mode = 0;
6277 : : uint32_t opr_mode = 0;
6278 : 0 : uint32_t block_idx = 0;
6279 : 0 : uint32_t ram_addr = 0;
6280 : 0 : uint32_t etcam_wr_mask = 0;
6281 : : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8];
6282 : : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8];
6283 : 0 : uint8_t temp_buf[16] = {0};
6284 : :
6285 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
6286 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
6287 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
6288 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry = {0};
6289 : :
6290 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6291 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
6292 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
6293 : :
6294 : 0 : etcam_as_mode = sdt_acl.as_rsp_mode;
6295 : 0 : etcam_table_id = sdt_acl.etcam_table_id;
6296 : 0 : as_enable = sdt_acl.as_en;
6297 : 0 : as_eram_baddr = sdt_acl.as_eram_baddr;
6298 : :
6299 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
6300 : :
6301 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
6302 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
6303 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
6304 : : RTE_ASSERT(0);
6305 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
6306 : : }
6307 : :
6308 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_acl_entry->pri,
6309 : : &block_idx, &ram_addr, &etcam_wr_mask);
6310 : :
6311 : : memset(temp_data, 0xff, ZXDH_ETCAM_WIDTH_MAX / 8);
6312 : : memset(temp_mask, 0, ZXDH_ETCAM_WIDTH_MAX / 8);
6313 : 0 : etcam_entry.mode = p_tbl_cfg->key_mode;
6314 : 0 : etcam_entry.p_data = temp_data;
6315 : 0 : etcam_entry.p_mask = temp_mask;
6316 : 0 : rc = zxdh_np_dtb_etcam_entry_add(dev_id,
6317 : : ram_addr,
6318 : : block_idx,
6319 : : etcam_wr_mask,
6320 : : ZXDH_ETCAM_OPR_DM,
6321 : : &etcam_entry,
6322 : : p_dtb_data_entry,
6323 : : p_dtb_mask_entry);
6324 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_etcam_entry_add");
6325 : :
6326 [ # # ]: 0 : if (as_enable) {
6327 : : memset(temp_buf, 0, sizeof(temp_buf));
6328 : : opr_mode = zxdh_np_eram_opr_mode_get(etcam_as_mode);
6329 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
6330 : : as_eram_baddr,
6331 : : p_acl_entry->pri,
6332 : : opr_mode,
6333 : : (uint32_t *)temp_buf,
6334 : : p_dtb_as_entry);
6335 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_smmu0_ind_write");
6336 : : }
6337 : :
6338 : : return rc;
6339 : : }
6340 : :
6341 : : static uint32_t
6342 : 0 : zxdh_np_dtb_acl_insert(uint32_t dev_id,
6343 : : uint32_t sdt_no,
6344 : : ZXDH_ACL_ENTRY_EX_T *p_acl_entry,
6345 : : ZXDH_DTB_ENTRY_T *p_dtb_data_entry,
6346 : : ZXDH_DTB_ENTRY_T *p_dtb_mask_entry,
6347 : : ZXDH_DTB_ENTRY_T *p_dtb_as_entry)
6348 : : {
6349 : : uint32_t rc = ZXDH_OK;
6350 : : uint32_t as_eram_baddr = 0;
6351 : : uint32_t as_enable = 0;
6352 : : uint32_t etcam_table_id = 0;
6353 : : uint32_t etcam_as_mode = 0;
6354 : : uint32_t opr_mode = 0;
6355 : 0 : uint32_t block_idx = 0;
6356 : 0 : uint32_t ram_addr = 0;
6357 : 0 : uint32_t etcam_wr_mask = 0;
6358 : :
6359 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
6360 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
6361 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
6362 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry = {0};
6363 : :
6364 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6365 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
6366 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
6367 : :
6368 : 0 : etcam_as_mode = sdt_acl.as_rsp_mode;
6369 : 0 : etcam_table_id = sdt_acl.etcam_table_id;
6370 : 0 : as_enable = sdt_acl.as_en;
6371 : 0 : as_eram_baddr = sdt_acl.as_eram_baddr;
6372 : :
6373 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
6374 : :
6375 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
6376 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
6377 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
6378 : : RTE_ASSERT(0);
6379 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
6380 : : }
6381 : :
6382 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_acl_entry->pri,
6383 : : &block_idx, &ram_addr, &etcam_wr_mask);
6384 : :
6385 : 0 : etcam_entry.mode = p_tbl_cfg->key_mode;
6386 : 0 : etcam_entry.p_data = p_acl_entry->key_data;
6387 : 0 : etcam_entry.p_mask = p_acl_entry->key_mask;
6388 : :
6389 : 0 : rc = zxdh_np_dtb_etcam_entry_add(dev_id,
6390 : : ram_addr,
6391 : : block_idx,
6392 : : etcam_wr_mask,
6393 : : ZXDH_ETCAM_OPR_DM,
6394 : : &etcam_entry,
6395 : : p_dtb_data_entry,
6396 : : p_dtb_mask_entry);
6397 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_etcam_entry_add");
6398 : :
6399 [ # # ]: 0 : if (as_enable) {
6400 : : opr_mode = zxdh_np_eram_opr_mode_get(etcam_as_mode);
6401 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
6402 : : as_eram_baddr,
6403 : : p_acl_entry->pri,
6404 : : opr_mode,
6405 : 0 : (uint32_t *)p_acl_entry->p_as_rslt,
6406 : : p_dtb_as_entry);
6407 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_smmu0_ind_write");
6408 : : }
6409 : :
6410 : : return rc;
6411 : : }
6412 : :
6413 : : static uint32_t
6414 : 0 : zxdh_np_dtb_acl_one_entry(uint32_t dev_id,
6415 : : uint32_t sdt_no,
6416 : : uint32_t del_en,
6417 : : void *p_data,
6418 : : uint32_t *p_dtb_len,
6419 : : uint8_t *p_data_buff)
6420 : : {
6421 : : uint32_t rc = ZXDH_OK;
6422 : : uint32_t addr_offset = 0;
6423 : 0 : ZXDH_ACL_ENTRY_EX_T acl_entry = {0};
6424 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_entry = NULL;
6425 : :
6426 : 0 : uint8_t data_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6427 : 0 : uint8_t mask_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6428 : 0 : uint8_t data_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6429 : 0 : uint8_t mask_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6430 : 0 : uint8_t as_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6431 : 0 : uint32_t as_data_buff[4] = {0};
6432 : :
6433 : 0 : ZXDH_DTB_ENTRY_T dtb_data_entry = {0};
6434 : 0 : ZXDH_DTB_ENTRY_T dtb_mask_entry = {0};
6435 : 0 : ZXDH_DTB_ENTRY_T dtb_as_entry = {0};
6436 : :
6437 : 0 : dtb_data_entry.cmd = data_cmd_buff;
6438 : 0 : dtb_data_entry.data = data_buff;
6439 : 0 : dtb_mask_entry.cmd = mask_cmd_buff;
6440 : 0 : dtb_mask_entry.data = mask_buff;
6441 : 0 : dtb_as_entry.cmd = as_cmd_buff;
6442 : 0 : dtb_as_entry.data = (uint8_t *)as_data_buff;
6443 : :
6444 : : p_entry = (ZXDH_DTB_ACL_ENTRY_INFO_T *)p_data;
6445 : 0 : acl_entry.pri = p_entry->handle;
6446 : 0 : acl_entry.key_data = p_entry->key_data;
6447 : 0 : acl_entry.key_mask = p_entry->key_mask;
6448 : 0 : acl_entry.p_as_rslt = p_entry->p_as_rslt;
6449 [ # # ]: 0 : if (del_en) {
6450 : 0 : rc = zxdh_np_dtb_acl_delete(dev_id,
6451 : : sdt_no,
6452 : : &acl_entry,
6453 : : &dtb_data_entry,
6454 : : &dtb_mask_entry,
6455 : : &dtb_as_entry);
6456 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_delete");
6457 : : } else {
6458 : 0 : rc = zxdh_np_dtb_acl_insert(dev_id,
6459 : : sdt_no,
6460 : : &acl_entry,
6461 : : &dtb_data_entry,
6462 : : &dtb_mask_entry,
6463 : : &dtb_as_entry);
6464 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_insert");
6465 : : }
6466 : :
6467 : 0 : addr_offset = (*p_dtb_len) * ZXDH_DTB_LEN_POS_SETP;
6468 : 0 : *p_dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
6469 : :
6470 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_data_entry);
6471 : :
6472 : 0 : addr_offset = (*p_dtb_len) * ZXDH_DTB_LEN_POS_SETP;
6473 : 0 : *p_dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
6474 : :
6475 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_mask_entry);
6476 : :
6477 : 0 : addr_offset = (*p_dtb_len) * ZXDH_DTB_LEN_POS_SETP;
6478 [ # # ]: 0 : if (dtb_as_entry.data_in_cmd_flag)
6479 : 0 : *p_dtb_len += 1;
6480 : : else
6481 : 0 : *p_dtb_len += 2;
6482 : :
6483 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_as_entry);
6484 : :
6485 : 0 : return ZXDH_OK;
6486 : : }
6487 : :
6488 : : int
6489 : 0 : zxdh_np_dtb_table_entry_write(uint32_t dev_id,
6490 : : uint32_t queue_id,
6491 : : uint32_t entrynum,
6492 : : ZXDH_DTB_USER_ENTRY_T *down_entries)
6493 : : {
6494 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
6495 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
6496 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT] = {0};
6497 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX] = {0};
6498 : : uint8_t *p_data_buff;
6499 : 0 : uint32_t element_id = 0xff;
6500 : 0 : uint32_t one_dtb_len = 0;
6501 : 0 : uint32_t dtb_len = 0;
6502 : : uint32_t entry_index;
6503 : : uint32_t sdt_no;
6504 : : uint32_t tbl_type;
6505 : : uint32_t addr_offset;
6506 : : uint32_t max_size;
6507 : : uint32_t rc = 0;
6508 : :
6509 : 0 : p_data_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
6510 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
6511 : :
6512 : 0 : dtb_one_entry.cmd = entry_cmd;
6513 : 0 : dtb_one_entry.data = entry_data;
6514 : :
6515 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
6516 : :
6517 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
6518 : 0 : pentry = down_entries + entry_index;
6519 : 0 : sdt_no = pentry->sdt_no;
6520 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6521 : : tbl_type = zxdh_np_sdt_tbl_type_get(dev_id, sdt_no);
6522 [ # # # # ]: 0 : switch (tbl_type) {
6523 : 0 : case ZXDH_SDT_TBLT_ERAM:
6524 : 0 : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
6525 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
6526 : 0 : break;
6527 : 0 : case ZXDH_SDT_TBLT_HASH:
6528 : 0 : rc = zxdh_np_dtb_hash_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
6529 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
6530 : 0 : break;
6531 : 0 : case ZXDH_SDT_TBLT_ETCAM:
6532 : 0 : rc = zxdh_np_dtb_acl_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
6533 : : pentry->p_entry_data, &dtb_len, p_data_buff);
6534 : 0 : continue;
6535 : 0 : default:
6536 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
6537 : 0 : rte_free(p_data_buff);
6538 : 0 : return 1;
6539 : : }
6540 : :
6541 : 0 : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
6542 : 0 : dtb_len += one_dtb_len;
6543 [ # # ]: 0 : if (dtb_len > max_size) {
6544 : 0 : rte_free(p_data_buff);
6545 : 0 : PMD_DRV_LOG(ERR, "error dtb_len>%u!", max_size);
6546 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6547 : : }
6548 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
6549 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
6550 : : memset(entry_data, 0x0, sizeof(entry_data));
6551 : : }
6552 : :
6553 [ # # ]: 0 : if (dtb_len == 0) {
6554 : 0 : rte_free(p_data_buff);
6555 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6556 : : }
6557 : :
6558 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
6559 : : queue_id,
6560 : : dtb_len * 16,
6561 : : p_data_buff,
6562 : : &element_id);
6563 : 0 : rte_free(p_data_buff);
6564 : :
6565 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, element_id);
6566 : :
6567 : 0 : return rc;
6568 : : }
6569 : :
6570 : : int
6571 : 0 : zxdh_np_dtb_table_entry_delete(uint32_t dev_id,
6572 : : uint32_t queue_id,
6573 : : uint32_t entrynum,
6574 : : ZXDH_DTB_USER_ENTRY_T *delete_entries)
6575 : : {
6576 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
6577 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
6578 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
6579 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6580 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6581 : : uint8_t *p_data_buff = NULL;
6582 : : uint32_t tbl_type = 0;
6583 : 0 : uint32_t element_id = 0xff;
6584 : 0 : uint32_t one_dtb_len = 0;
6585 : 0 : uint32_t dtb_len = 0;
6586 : : uint32_t entry_index;
6587 : : uint32_t sdt_no;
6588 : : uint32_t addr_offset;
6589 : : uint32_t max_size;
6590 : : uint32_t rc;
6591 : :
6592 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(delete_entries);
6593 : :
6594 : 0 : p_data_buff = rte_calloc(NULL, 1, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
6595 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
6596 : :
6597 : 0 : dtb_one_entry.cmd = entry_cmd;
6598 : 0 : dtb_one_entry.data = entry_data;
6599 : :
6600 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
6601 : :
6602 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
6603 : 0 : pentry = delete_entries + entry_index;
6604 : :
6605 : 0 : sdt_no = pentry->sdt_no;
6606 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6607 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
6608 : : tbl_type = zxdh_np_sdt_tbl_type_get(dev_id, sdt_no);
6609 [ # # # # ]: 0 : switch (tbl_type) {
6610 : 0 : case ZXDH_SDT_TBLT_ERAM:
6611 : 0 : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_DELETE,
6612 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
6613 : 0 : break;
6614 : 0 : case ZXDH_SDT_TBLT_HASH:
6615 : 0 : rc = zxdh_np_dtb_hash_one_entry(dev_id, sdt_no,
6616 : : ZXDH_DTB_ITEM_DELETE, pentry->p_entry_data,
6617 : : &one_dtb_len, &dtb_one_entry);
6618 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
6619 : 0 : continue;
6620 : : break;
6621 : 0 : case ZXDH_SDT_TBLT_ETCAM:
6622 : 0 : rc = zxdh_np_dtb_acl_one_entry(dev_id, sdt_no,
6623 : : ZXDH_DTB_ITEM_DELETE, pentry->p_entry_data,
6624 : : &dtb_len, p_data_buff);
6625 : 0 : continue;
6626 : 0 : default:
6627 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
6628 : 0 : rte_free(p_data_buff);
6629 : 0 : return 1;
6630 : : }
6631 : :
6632 : 0 : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
6633 : 0 : dtb_len += one_dtb_len;
6634 [ # # ]: 0 : if (dtb_len > max_size) {
6635 : 0 : rte_free(p_data_buff);
6636 : 0 : PMD_DRV_LOG(ERR, "error dtb_len>%u!", max_size);
6637 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6638 : : }
6639 : :
6640 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
6641 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
6642 : : memset(entry_data, 0x0, sizeof(entry_data));
6643 : : }
6644 : :
6645 [ # # ]: 0 : if (dtb_len == 0) {
6646 : 0 : rte_free(p_data_buff);
6647 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6648 : : }
6649 : :
6650 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
6651 : : queue_id,
6652 : : dtb_len * 16,
6653 : : p_data_buff,
6654 : : &element_id);
6655 : 0 : rte_free(p_data_buff);
6656 : :
6657 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, element_id);
6658 : :
6659 : 0 : return rc;
6660 : : }
6661 : :
6662 : : static void
6663 : : zxdh_np_eram_index_cal(uint32_t eram_mode, uint32_t index,
6664 : : uint32_t *p_row_index, uint32_t *p_col_index)
6665 : : {
6666 : : uint32_t row_index = 0;
6667 : : uint32_t col_index = 0;
6668 : :
6669 [ # # # # : 0 : switch (eram_mode) {
# # # # #
# # # # #
# # ]
6670 : 0 : case ZXDH_ERAM128_TBL_128b:
6671 : : row_index = index;
6672 : 0 : break;
6673 : 0 : case ZXDH_ERAM128_TBL_64b:
6674 : 0 : row_index = (index >> 1);
6675 : 0 : col_index = index & 0x1;
6676 : 0 : break;
6677 : 0 : case ZXDH_ERAM128_TBL_1b:
6678 : 0 : row_index = (index >> 7);
6679 : 0 : col_index = index & 0x7F;
6680 : 0 : break;
6681 : : default:
6682 : : break;
6683 : : }
6684 : : *p_row_index = row_index;
6685 : : *p_col_index = col_index;
6686 : : }
6687 : :
6688 : : static void
6689 : 0 : zxdh_np_stat_cfg_soft_get(uint32_t dev_id,
6690 : : ZXDH_PPU_STAT_CFG_T *p_stat_cfg)
6691 : : {
6692 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_stat_cfg);
6693 : :
6694 : 0 : p_stat_cfg->ddr_base_addr = g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].ddr_base_addr;
6695 : 0 : p_stat_cfg->eram_baddr = g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].eram_baddr;
6696 : 0 : p_stat_cfg->eram_depth = g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].eram_depth;
6697 : 0 : p_stat_cfg->ppu_addr_offset = g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].ppu_addr_offset;
6698 : 0 : }
6699 : :
6700 : : static uint32_t
6701 : 0 : zxdh_np_dtb_tab_up_info_set(uint32_t dev_id,
6702 : : uint32_t queue_id,
6703 : : uint32_t item_index,
6704 : : uint32_t int_flag,
6705 : : uint32_t data_len,
6706 : : uint32_t desc_len,
6707 : : uint32_t *p_desc_data)
6708 : : {
6709 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
6710 : 0 : uint32_t queue_en = 0;
6711 : : uint32_t rc;
6712 : : ZXDH_SPINLOCK_T *p_spinlock = NULL;
6713 : :
6714 : : zxdh_np_dev_dtb_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_DTB, queue_id, &p_spinlock);
6715 : 0 : rte_spinlock_lock(&p_spinlock->spinlock);
6716 : :
6717 : 0 : zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
6718 [ # # ]: 0 : if (!queue_en) {
6719 : 0 : PMD_DRV_LOG(ERR, "the queue %u is not enable!", queue_id);
6720 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6721 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
6722 : : }
6723 : :
6724 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6725 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init", queue_id);
6726 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6727 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6728 : : }
6729 : :
6730 [ # # ]: 0 : if (desc_len % 4 != 0) {
6731 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6732 : 0 : return ZXDH_RC_DTB_PARA_INVALID;
6733 : : }
6734 : :
6735 : 0 : zxdh_np_dtb_item_buff_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6736 : : item_index, 0, desc_len, p_desc_data);
6737 : :
6738 : 0 : ZXDH_DTB_TAB_UP_DATA_LEN_GET(dev_id, queue_id, item_index) = data_len;
6739 : :
6740 : 0 : item_info.cmd_vld = 1;
6741 : 0 : item_info.cmd_type = ZXDH_DTB_DIR_UP_TYPE;
6742 : 0 : item_info.int_en = int_flag;
6743 : 0 : item_info.data_len = desc_len / 4;
6744 : 0 : item_info.data_hddr =
6745 : 0 : ((ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) >> 4) >> 32) & 0xffffffff;
6746 : 0 : item_info.data_laddr =
6747 : 0 : (ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) >> 4) & 0xffffffff;
6748 : 0 : zxdh_dtb_info_print(dev_id, queue_id, item_index, &item_info);
6749 : :
6750 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
6751 : :
6752 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6753 : :
6754 : 0 : return rc;
6755 : : }
6756 : :
6757 : : static uint32_t
6758 : 0 : zxdh_np_dtb_tab_up_data_get(uint32_t dev_id,
6759 : : uint32_t queue_id,
6760 : : uint32_t item_index,
6761 : : uint32_t data_len,
6762 : : uint32_t *p_data)
6763 : : {
6764 : : uint32_t rc = 0;
6765 : :
6766 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6767 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
6768 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6769 : : }
6770 : :
6771 : 0 : rc = zxdh_np_dtb_item_buff_rd(dev_id,
6772 : : queue_id,
6773 : : ZXDH_DTB_DIR_UP_TYPE,
6774 : : item_index,
6775 : : 0,
6776 : : data_len,
6777 : : p_data);
6778 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_rd");
6779 : :
6780 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6781 : : item_index, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
6782 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
6783 : :
6784 : 0 : return rc;
6785 : : }
6786 : :
6787 : : static uint32_t
6788 : 0 : zxdh_np_dtb_tab_up_item_addr_get(uint32_t dev_id,
6789 : : uint32_t queue_id,
6790 : : uint32_t item_index,
6791 : : uint32_t *p_phy_haddr,
6792 : : uint32_t *p_phy_laddr)
6793 : : {
6794 : : uint32_t rc = 0;
6795 : : uint64_t addr;
6796 : :
6797 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6798 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
6799 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6800 : : }
6801 : :
6802 [ # # ]: 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
6803 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE)
6804 : 0 : addr = ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(dev_id, queue_id, item_index);
6805 : : else
6806 : 0 : addr = ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index)
6807 : : + ZXDH_DTB_ITEM_ACK_SIZE;
6808 : :
6809 : 0 : *p_phy_haddr = (addr >> 32) & 0xffffffff;
6810 : 0 : *p_phy_laddr = addr & 0xffffffff;
6811 : :
6812 : 0 : return rc;
6813 : : }
6814 : :
6815 : : static void
6816 : : zxdh_np_dtb_tab_up_item_offset_addr_get(uint32_t dev_id,
6817 : : uint32_t queue_id,
6818 : : uint32_t item_index,
6819 : : uint32_t addr_offset,
6820 : : uint32_t *p_phy_haddr,
6821 : : uint32_t *p_phy_laddr)
6822 : : {
6823 : : uint64_t addr = 0;
6824 : :
6825 : 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
6826 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE)
6827 : 0 : addr = ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(dev_id, queue_id, item_index);
6828 : : else
6829 : 0 : addr = ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) +
6830 : : ZXDH_DTB_ITEM_ACK_SIZE;
6831 : :
6832 : 0 : addr = addr + addr_offset;
6833 : :
6834 : 0 : *p_phy_haddr = (addr >> 32) & 0xffffffff;
6835 : 0 : *p_phy_laddr = addr & 0xffffffff;
6836 : : }
6837 : :
6838 : : static uint32_t
6839 : 0 : zxdh_np_dtb_dump_table_element_addr_get(uint32_t dev_id,
6840 : : uint32_t queue_id,
6841 : : uint32_t element_id,
6842 : : uint32_t *p_element_start_addr_h,
6843 : : uint32_t *p_element_start_addr_l,
6844 : : uint32_t *p_element_dump_addr_h,
6845 : : uint32_t *p_element_dump_addr_l,
6846 : : uint32_t *p_element_table_info_addr_h,
6847 : : uint32_t *p_element_table_info_addr_l)
6848 : : {
6849 : : uint32_t rc = ZXDH_OK;
6850 : : uint32_t addr_h = 0;
6851 : : uint32_t addr_l = 0;
6852 : :
6853 : 0 : addr_h = ((ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id)) >> 32) & 0xffffffff;
6854 : 0 : addr_l = (ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id)) & 0xffffffff;
6855 : :
6856 : 0 : *p_element_start_addr_h = addr_h;
6857 : 0 : *p_element_start_addr_l = addr_l;
6858 : :
6859 : 0 : addr_h = ((ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id) +
6860 : 0 : ZXDH_DTB_ITEM_ACK_SIZE) >> 32) & 0xffffffff;
6861 : 0 : addr_l = (ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id) +
6862 : : ZXDH_DTB_ITEM_ACK_SIZE) & 0xffffffff;
6863 : :
6864 : 0 : *p_element_dump_addr_h = addr_h;
6865 : 0 : *p_element_dump_addr_l = addr_l;
6866 : :
6867 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, element_id,
6868 : : p_element_table_info_addr_h, p_element_table_info_addr_l);
6869 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_get");
6870 : :
6871 : 0 : return rc;
6872 : : }
6873 : :
6874 : : static uint32_t
6875 : 0 : zxdh_np_dtb_dump_table_element_info_prt(uint32_t dev_id,
6876 : : uint32_t queue_id,
6877 : : uint32_t element_id)
6878 : : {
6879 : : uint32_t rc = 0;
6880 : :
6881 : 0 : uint32_t element_start_addr_h = 0;
6882 : 0 : uint32_t element_start_addr_l = 0;
6883 : 0 : uint32_t element_dump_addr_h = 0;
6884 : 0 : uint32_t element_dump_addr_l = 0;
6885 : 0 : uint32_t element_table_info_addr_h = 0;
6886 : 0 : uint32_t element_table_info_addr_l = 0;
6887 : :
6888 : 0 : zxdh_np_dtb_dump_table_element_addr_get(dev_id,
6889 : : queue_id,
6890 : : element_id,
6891 : : &element_start_addr_h,
6892 : : &element_start_addr_l,
6893 : : &element_dump_addr_h,
6894 : : &element_dump_addr_l,
6895 : : &element_table_info_addr_h,
6896 : : &element_table_info_addr_l);
6897 : 0 : PMD_DRV_LOG(DEBUG, "queue_id %u.", queue_id);
6898 : 0 : PMD_DRV_LOG(DEBUG, "element_id %u.", element_id);
6899 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_h 0x%x.", element_start_addr_h);
6900 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_l 0x%x.", element_start_addr_l);
6901 : 0 : PMD_DRV_LOG(DEBUG, "element_dump_addr_h 0x%x.", element_dump_addr_h);
6902 : 0 : PMD_DRV_LOG(DEBUG, "element_dump_addr_l 0x%x.", element_dump_addr_l);
6903 : 0 : PMD_DRV_LOG(DEBUG, "element_table_info_addr_h 0x%x.", element_table_info_addr_h);
6904 : 0 : PMD_DRV_LOG(DEBUG, "element_table_info_addr_l 0x%x.", element_table_info_addr_l);
6905 : :
6906 : 0 : rc = zxdh_np_dtb_item_ack_prt(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, element_id);
6907 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_prt");
6908 : :
6909 : 0 : rc = zxdh_np_dtb_item_buff_prt(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, element_id, 32);
6910 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_prt");
6911 : :
6912 : 0 : return rc;
6913 : : }
6914 : :
6915 : : static uint32_t
6916 : 0 : zxdh_np_dtb_tab_up_success_status_check(uint32_t dev_id,
6917 : : uint32_t queue_id,
6918 : : uint32_t element_id)
6919 : : {
6920 : : uint32_t rc = 0;
6921 : : uint32_t rd_cnt = 0;
6922 : : uint32_t ack_value = 0;
6923 : : uint32_t success_flag = 0;
6924 : :
6925 : 0 : while (!success_flag) {
6926 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6927 : : element_id, 0, &ack_value);
6928 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_rd");
6929 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_np_dtb_item_ack_rd ack_value:0x%08x", ack_value);
6930 : :
6931 [ # # ]: 0 : if ((((ack_value >> 8) & 0xffffff) == ZXDH_DTB_TAB_UP_ACK_VLD_MASK) &&
6932 [ # # ]: 0 : ((ack_value & 0xff) == ZXDH_DTB_TAB_ACK_SUCCESS_MASK)) {
6933 : : success_flag = 1;
6934 : : break;
6935 : : }
6936 : :
6937 [ # # ]: 0 : if (rd_cnt > ZXDH_DTB_DUMP_OVER_TIME) {
6938 : 0 : PMD_DRV_LOG(ERR, "dump queue %u item %u overtime!", queue_id, element_id);
6939 : :
6940 : 0 : rc = zxdh_np_dtb_dump_table_element_info_prt(dev_id, queue_id, element_id);
6941 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_table_element_info_prt");
6942 : :
6943 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6944 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
6945 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
6946 : :
6947 : 0 : return ZXDH_ERR;
6948 : : }
6949 : :
6950 : 0 : rd_cnt++;
6951 : 0 : rte_delay_us(ZXDH_DTB_DELAY_TIME);
6952 : : }
6953 : :
6954 : : return rc;
6955 : : }
6956 : :
6957 : : static uint32_t
6958 : 0 : zxdh_np_dtb_write_dump_desc_info(uint32_t dev_id,
6959 : : uint32_t queue_id,
6960 : : uint32_t queue_element_id,
6961 : : uint32_t *p_dump_info,
6962 : : uint32_t data_len,
6963 : : uint32_t desc_len,
6964 : : uint32_t *p_dump_data)
6965 : : {
6966 : : uint32_t dtb_interrupt_status = 0;
6967 : : uint32_t rc;
6968 : :
6969 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dump_data);
6970 : 0 : rc = zxdh_np_dtb_tab_up_info_set(dev_id,
6971 : : queue_id,
6972 : : queue_element_id,
6973 : : dtb_interrupt_status,
6974 : : data_len,
6975 : : desc_len,
6976 : : p_dump_info);
6977 [ # # ]: 0 : if (rc != 0) {
6978 : 0 : PMD_DRV_LOG(ERR, "queue %u element %u dump info set failed!",
6979 : : queue_id, queue_element_id);
6980 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6981 : : queue_element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
6982 : : }
6983 : :
6984 : 0 : rc = zxdh_np_dtb_tab_up_success_status_check(dev_id,
6985 : : queue_id, queue_element_id);
6986 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_success_status_check");
6987 : :
6988 : 0 : rc = zxdh_np_dtb_tab_up_data_get(dev_id, queue_id, queue_element_id,
6989 : : data_len, p_dump_data);
6990 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_data_get");
6991 : :
6992 : 0 : PMD_DRV_LOG(DEBUG, "queue %u element %u dump done.", queue_id, queue_element_id);
6993 : :
6994 : 0 : return rc;
6995 : : }
6996 : :
6997 : : static uint32_t
6998 : 0 : zxdh_np_dtb_tab_up_free_item_get(uint32_t dev_id,
6999 : : uint32_t queue_id,
7000 : : uint32_t *p_item_index)
7001 : : {
7002 : : uint32_t ack_vale = 0;
7003 : : uint32_t item_index = 0;
7004 : 0 : uint32_t unused_item_num = 0;
7005 : : uint32_t i;
7006 : : ZXDH_SPINLOCK_T *p_spinlock = NULL;
7007 : :
7008 : : zxdh_np_dev_dtb_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_DTB, queue_id, &p_spinlock);
7009 : 0 : rte_spinlock_lock(&p_spinlock->spinlock);
7010 : :
7011 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
7012 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init", queue_id);
7013 : : rte_spinlock_unlock(&p_spinlock->spinlock);
7014 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
7015 : : }
7016 : :
7017 : 0 : zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
7018 : :
7019 [ # # ]: 0 : if (unused_item_num == 0) {
7020 : : rte_spinlock_unlock(&p_spinlock->spinlock);
7021 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
7022 : : }
7023 : :
7024 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
7025 : 0 : item_index = ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id) %
7026 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
7027 : :
7028 : : zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
7029 : : 0, &ack_vale);
7030 : :
7031 : 0 : ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id)++;
7032 : :
7033 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
7034 : : break;
7035 : : }
7036 : :
7037 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX) {
7038 : : rte_spinlock_unlock(&p_spinlock->spinlock);
7039 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7040 : : }
7041 : :
7042 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
7043 : : 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
7044 : :
7045 : 0 : *p_item_index = item_index;
7046 : :
7047 : : rte_spinlock_unlock(&p_spinlock->spinlock);
7048 : :
7049 : 0 : return 0;
7050 : : }
7051 : :
7052 : : static uint32_t
7053 : 0 : zxdh_np_dtb_tab_up_item_user_addr_set(uint32_t dev_id,
7054 : : uint32_t queue_id,
7055 : : uint32_t item_index,
7056 : : uint64_t phy_addr,
7057 : : uint64_t vir_addr)
7058 : : {
7059 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
7060 : :
7061 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
7062 [ # # ]: 0 : if (p_dtb_mgr == NULL) {
7063 : 0 : PMD_DRV_LOG(ERR, "DTB Manager is not exist!");
7064 : 0 : return ZXDH_RC_DTB_MGR_NOT_EXIST;
7065 : : }
7066 : :
7067 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
7068 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
7069 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
7070 : : }
7071 : :
7072 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].phy_addr = phy_addr;
7073 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].vir_addr = vir_addr;
7074 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].user_flag =
7075 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE;
7076 : :
7077 : 0 : return ZXDH_OK;
7078 : : }
7079 : :
7080 : : static uint32_t
7081 : 0 : zxdh_np_dtb_dump_sdt_addr_get(uint32_t dev_id,
7082 : : uint32_t queue_id,
7083 : : uint32_t sdt_no,
7084 : : uint64_t *phy_addr,
7085 : : uint64_t *vir_addr,
7086 : : uint32_t *size)
7087 : : {
7088 : : uint32_t rc = ZXDH_OK;
7089 : :
7090 : 0 : ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {0};
7091 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
7092 : :
7093 : 0 : dtb_dump_addr_info.sdt_no = sdt_no;
7094 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
7095 : 0 : rc = zxdh_np_se_apt_rb_search(p_dtb_dump_addr_rb, &dtb_dump_addr_info,
7096 : : sizeof(ZXDH_DTB_ADDR_INFO_T));
7097 [ # # ]: 0 : if (rc == ZXDH_OK) {
7098 : 0 : PMD_DRV_LOG(INFO, "search sdt_no %u success.", sdt_no);
7099 : : } else {
7100 : 0 : PMD_DRV_LOG(ERR, "search sdt_no %u fail.", sdt_no);
7101 : 0 : return rc;
7102 : : }
7103 : :
7104 : 0 : *phy_addr = dtb_dump_addr_info.phy_addr;
7105 : 0 : *vir_addr = dtb_dump_addr_info.vir_addr;
7106 : 0 : *size = dtb_dump_addr_info.size;
7107 : :
7108 : 0 : return rc;
7109 : : }
7110 : :
7111 : : static uint32_t
7112 : 0 : zxdh_np_dtb_dump_addr_set(uint32_t dev_id,
7113 : : uint32_t queue_id,
7114 : : uint32_t sdt_no,
7115 : : uint32_t *element_id)
7116 : : {
7117 : : uint32_t rc = ZXDH_OK;
7118 : 0 : uint32_t dump_element_id = 0;
7119 : 0 : uint64_t phy_addr = 0;
7120 : 0 : uint64_t vir_addr = 0;
7121 : 0 : uint32_t size = 0;
7122 : :
7123 : 0 : rc = zxdh_np_dtb_dump_sdt_addr_get(dev_id,
7124 : : queue_id,
7125 : : sdt_no,
7126 : : &phy_addr,
7127 : : &vir_addr,
7128 : : &size);
7129 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_get");
7130 : 0 : memset((uint8_t *)vir_addr, 0, size);
7131 : :
7132 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &dump_element_id);
7133 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_free_item_get");
7134 : :
7135 : 0 : rc = zxdh_np_dtb_tab_up_item_user_addr_set(dev_id,
7136 : : queue_id,
7137 : : dump_element_id,
7138 : : phy_addr,
7139 : : vir_addr);
7140 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_set");
7141 : :
7142 : 0 : *element_id = dump_element_id;
7143 : :
7144 : 0 : return rc;
7145 : : }
7146 : :
7147 : : static uint32_t
7148 : 0 : zxdh_np_dtb_se_smmu0_dma_dump(uint32_t dev_id,
7149 : : uint32_t queue_id,
7150 : : uint32_t base_addr,
7151 : : uint32_t depth,
7152 : : uint32_t *p_data,
7153 : : uint32_t *element_id)
7154 : : {
7155 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
7156 : 0 : uint32_t dump_dst_phy_haddr = 0;
7157 : 0 : uint32_t dump_dst_phy_laddr = 0;
7158 : 0 : uint32_t queue_item_index = 0;
7159 : : uint32_t data_len;
7160 : : uint32_t desc_len;
7161 : : uint32_t rc;
7162 : :
7163 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &queue_item_index);
7164 [ # # ]: 0 : if (rc != 0) {
7165 : 0 : PMD_DRV_LOG(ERR, "dpp_dtb_tab_up_free_item_get failed = %u!", base_addr);
7166 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7167 : : }
7168 : :
7169 : 0 : *element_id = queue_item_index;
7170 : :
7171 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, queue_item_index,
7172 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
7173 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_tab_up_item_addr_get");
7174 : :
7175 : 0 : rc = zxdh_np_dtb_smmu0_dump_info_write(dev_id,
7176 : : base_addr,
7177 : : depth,
7178 : : dump_dst_phy_haddr,
7179 : : dump_dst_phy_laddr,
7180 : : (uint32_t *)form_buff);
7181 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_dump_info_write");
7182 : :
7183 : 0 : data_len = depth * 128 / 32;
7184 : : desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
7185 : :
7186 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id, queue_id, queue_item_index,
7187 : : (uint32_t *)form_buff, data_len, desc_len, p_data);
7188 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_dump_desc_info");
7189 : :
7190 : : return rc;
7191 : : }
7192 : :
7193 : : static uint32_t
7194 : 0 : zxdh_np_dtb_eram_data_get(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no,
7195 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_eram_entry)
7196 : : {
7197 : 0 : uint32_t index = p_dump_eram_entry->index;
7198 : 0 : uint32_t *p_data = p_dump_eram_entry->p_data;
7199 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram_info = {0};
7200 : 0 : uint32_t temp_data[4] = {0};
7201 : : uint32_t row_index = 0;
7202 : : uint32_t col_index = 0;
7203 : : uint32_t rd_mode;
7204 : : uint32_t rc;
7205 : : uint32_t eram_dump_base_addr = 0;
7206 : : uint32_t eram_base_addr = 0;
7207 : 0 : uint32_t element_id = 0;
7208 : :
7209 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
7210 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram_info);
7211 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_soft_sdt_tbl_get");
7212 : 0 : eram_base_addr = sdt_eram_info.eram_base_addr;
7213 [ # # # # ]: 0 : rd_mode = sdt_eram_info.eram_mode;
7214 : :
7215 : : zxdh_np_eram_index_cal(rd_mode, index, &row_index, &col_index);
7216 : :
7217 : 0 : eram_dump_base_addr = eram_base_addr + row_index;
7218 : :
7219 : 0 : rc = zxdh_np_dtb_se_smmu0_dma_dump(dev_id,
7220 : : queue_id,
7221 : : eram_dump_base_addr,
7222 : : 1,
7223 : : temp_data,
7224 : : &element_id);
7225 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_smmu0_dma_dump");
7226 : :
7227 [ # # # # ]: 0 : switch (rd_mode) {
7228 : : case ZXDH_ERAM128_TBL_128b:
7229 : : memcpy(p_data, temp_data, (128 / 8));
7230 : : break;
7231 : 0 : case ZXDH_ERAM128_TBL_64b:
7232 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
7233 : : break;
7234 : 0 : case ZXDH_ERAM128_TBL_1b:
7235 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
7236 : : (3 - col_index / 32)), (col_index % 32), 1);
7237 : 0 : break;
7238 : : default:
7239 : : break;
7240 : : }
7241 : :
7242 : 0 : PMD_DRV_LOG(DEBUG, "[eram_dump]std no:0x%x, index:0x%x, base addr:0x%x",
7243 : : sdt_no, p_dump_eram_entry->index, eram_dump_base_addr);
7244 [ # # ]: 0 : if (rd_mode == ZXDH_ERAM128_TBL_128b)
7245 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x 0x%08x 0x%08x]",
7246 : : p_dump_eram_entry->p_data[0], p_dump_eram_entry->p_data[1],
7247 : : p_dump_eram_entry->p_data[2], p_dump_eram_entry->p_data[3]);
7248 [ # # ]: 0 : else if (rd_mode == ZXDH_ERAM128_TBL_64b)
7249 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x]",
7250 : : p_dump_eram_entry->p_data[0], p_dump_eram_entry->p_data[1]);
7251 : :
7252 : 0 : return rc;
7253 : : }
7254 : :
7255 : : static uint32_t
7256 : 0 : zxdh_np_dtb_se_zcam_dma_dump(uint32_t dev_id,
7257 : : uint32_t queue_id,
7258 : : uint32_t addr,
7259 : : uint32_t tb_width,
7260 : : uint32_t depth,
7261 : : uint32_t *p_data,
7262 : : uint32_t *element_id)
7263 : : {
7264 : : uint32_t rc = ZXDH_OK;
7265 : 0 : uint32_t dump_dst_phy_haddr = 0;
7266 : 0 : uint32_t dump_dst_phy_laddr = 0;
7267 : 0 : uint32_t queue_item_index = 0;
7268 : : uint32_t data_len = 0;
7269 : : uint32_t desc_len = 0;
7270 : : uint32_t tb_width_len = 0;
7271 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
7272 : :
7273 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &queue_item_index);
7274 [ # # ]: 0 : if (rc != ZXDH_OK) {
7275 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_dtb_tab_up_free_item_get failed!");
7276 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7277 : : }
7278 : :
7279 : 0 : PMD_DRV_LOG(DEBUG, "table up item queue_element_id is: %u.",
7280 : : queue_item_index);
7281 : :
7282 : 0 : *element_id = queue_item_index;
7283 : :
7284 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, queue_item_index,
7285 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
7286 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_get");
7287 : :
7288 : 0 : rc = zxdh_np_dtb_zcam_dump_info_write(dev_id,
7289 : : addr,
7290 : : tb_width,
7291 : : depth,
7292 : : dump_dst_phy_haddr,
7293 : : dump_dst_phy_laddr,
7294 : : (uint32_t *)form_buff);
7295 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_zcam_dump_info_write");
7296 : :
7297 : 0 : tb_width_len = ZXDH_DTB_LEN_POS_SETP << tb_width;
7298 : 0 : data_len = depth * tb_width_len / 4;
7299 : : desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
7300 : :
7301 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id, queue_id, queue_item_index,
7302 : : (uint32_t *)form_buff, data_len, desc_len, p_data);
7303 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_desc_info");
7304 : :
7305 : : return rc;
7306 : : }
7307 : :
7308 : : static uint32_t
7309 : 0 : zxdh_np_dtb_hash_data_parse(uint32_t item_type,
7310 : : uint32_t key_by_size,
7311 : : ZXDH_HASH_ENTRY *p_entry,
7312 : : uint8_t *p_item_data,
7313 : : uint32_t *p_data_offset)
7314 : : {
7315 : : uint32_t data_offset = 0;
7316 : : uint8_t temp_key_valid = 0;
7317 : : uint8_t temp_key_type = 0;
7318 : : uint32_t temp_entry_size = 0;
7319 : : uint8_t srh_key_type = 0;
7320 : : uint32_t srh_entry_size = 0;
7321 : : uint32_t rst_by_size = 0;
7322 : : uint8_t srh_succ = 0;
7323 : : uint32_t item_width = ZXDH_SE_ITEM_WIDTH_MAX;
7324 : : uint8_t *p_srh_key = NULL;
7325 : : uint8_t *p_temp_key = NULL;
7326 : :
7327 [ # # ]: 0 : if (item_type == ZXDH_ITEM_DDR_256)
7328 : : item_width = item_width / 2;
7329 : :
7330 : : p_temp_key = p_item_data;
7331 : 0 : p_srh_key = p_entry->p_key;
7332 : 0 : srh_key_type = ZXDH_GET_HASH_KEY_TYPE(p_srh_key);
7333 [ # # ]: 0 : srh_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(srh_key_type);
7334 : :
7335 [ # # ]: 0 : while (data_offset < item_width) {
7336 : 0 : temp_key_valid = ZXDH_GET_HASH_KEY_VALID(p_temp_key);
7337 : 0 : temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_temp_key);
7338 : :
7339 [ # # ]: 0 : if (temp_key_valid && srh_key_type == temp_key_type) {
7340 [ # # ]: 0 : if (memcmp(p_srh_key, p_temp_key, key_by_size) == 0) {
7341 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware successfully.");
7342 : : srh_succ = 1;
7343 : : break;
7344 : : }
7345 : :
7346 : 0 : data_offset += srh_entry_size;
7347 [ # # ]: 0 : } else if (temp_key_valid && (srh_key_type != temp_key_type)) {
7348 [ # # ]: 0 : temp_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(temp_key_type);
7349 : 0 : data_offset += temp_entry_size;
7350 : : } else {
7351 : 0 : data_offset += ZXDH_HASH_ENTRY_POS_STEP;
7352 : : }
7353 : :
7354 : : p_temp_key = p_item_data;
7355 : 0 : p_temp_key += data_offset;
7356 : : }
7357 : :
7358 : : if (!srh_succ) {
7359 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware fail.");
7360 : 0 : return ZXDH_HASH_RC_MATCH_ITEM_FAIL;
7361 : : }
7362 : :
7363 : 0 : rst_by_size = srh_entry_size - key_by_size;
7364 : 0 : memcpy(p_entry->p_rst, p_temp_key + key_by_size,
7365 : 0 : (rst_by_size > ZXDH_HASH_RST_MAX) ? ZXDH_HASH_RST_MAX : rst_by_size);
7366 : 0 : *p_data_offset = data_offset;
7367 : :
7368 : 0 : return ZXDH_OK;
7369 : : }
7370 : :
7371 : : static uint32_t
7372 : 0 : zxdh_np_dtb_hash_zcam_get_hardware(uint32_t dev_id,
7373 : : uint32_t queue_id,
7374 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
7375 : : ZXDH_HASH_ENTRY *p_hash_entry,
7376 : : uint8_t *p_srh_succ)
7377 : : {
7378 : : uint32_t rc = ZXDH_OK;
7379 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
7380 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
7381 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
7382 : : uint32_t zblk_idx = 0;
7383 : : uint32_t pre_zblk_idx = 0xFFFFFFFF;
7384 : : uint16_t crc16_value = 0;
7385 : : uint32_t zcell_id = 0;
7386 : : uint32_t item_idx = 0;
7387 : 0 : uint32_t element_id = 0;
7388 : 0 : uint32_t byte_offset = 0;
7389 : : uint32_t addr = 0;
7390 : : uint32_t i = 0;
7391 : : uint8_t srh_succ = 0;
7392 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
7393 : 0 : uint8_t rd_buff[ZXDH_SE_ITEM_WIDTH_MAX] = {0};
7394 : : ZXDH_D_NODE *p_zblk_dn = NULL;
7395 : : ZXDH_D_NODE *p_zcell_dn = NULL;
7396 : : ZXDH_SE_CFG *p_se_cfg = NULL;
7397 : :
7398 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
7399 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
7400 : :
7401 : 0 : p_se_cfg = p_hash_entry_cfg->p_se_cfg;
7402 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
7403 : :
7404 : 0 : zxdh_np_hash_set_crc_key(p_hash_entry_cfg, p_hash_entry, temp_key);
7405 : :
7406 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
7407 [ # # ]: 0 : while (p_zcell_dn) {
7408 : 0 : p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
7409 : 0 : zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
7410 : : p_zblk = &p_se_cfg->zblk_info[zblk_idx];
7411 : :
7412 [ # # ]: 0 : if (zblk_idx != pre_zblk_idx) {
7413 : : pre_zblk_idx = zblk_idx;
7414 : 0 : crc16_value = p_hash_cfg->p_hash16_fun(temp_key,
7415 : 0 : p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
7416 : : }
7417 : :
7418 : 0 : zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
7419 : 0 : item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc16_value);
7420 : 0 : addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
7421 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
7422 : : queue_id,
7423 : : addr,
7424 : : ZXDH_DTB_DUMP_ZCAM_512b,
7425 : : 1,
7426 : : (uint32_t *)rd_buff,
7427 : : &element_id);
7428 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
7429 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
7430 : :
7431 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM, p_hash_entry_cfg->key_by_size,
7432 : : p_hash_entry, rd_buff, &byte_offset);
7433 [ # # ]: 0 : if (rc == ZXDH_OK) {
7434 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zcell.");
7435 : : srh_succ = 1;
7436 : 0 : p_hash_cfg->hash_stat.search_ok++;
7437 : : break;
7438 : : }
7439 : :
7440 : 0 : p_zcell_dn = p_zcell_dn->next;
7441 : : }
7442 : :
7443 : : if (srh_succ == 0) {
7444 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
7445 [ # # ]: 0 : while (p_zblk_dn) {
7446 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
7447 : 0 : zblk_idx = p_zblk->zblk_idx;
7448 : :
7449 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
7450 : : item_idx = i;
7451 : 0 : addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx, item_idx);
7452 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
7453 : : queue_id,
7454 : : addr,
7455 : : ZXDH_DTB_DUMP_ZCAM_512b,
7456 : : 1,
7457 : : (uint32_t *)rd_buff,
7458 : : &element_id);
7459 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
7460 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
7461 : :
7462 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM,
7463 : : p_hash_entry_cfg->key_by_size, p_hash_entry,
7464 : : rd_buff, &byte_offset);
7465 [ # # ]: 0 : if (rc == ZXDH_OK) {
7466 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zreg.");
7467 : : srh_succ = 1;
7468 : 0 : p_hash_cfg->hash_stat.search_ok++;
7469 : 0 : break;
7470 : : }
7471 : : }
7472 : 0 : p_zblk_dn = p_zblk_dn->next;
7473 : : }
7474 : : }
7475 : :
7476 : 0 : *p_srh_succ = srh_succ;
7477 : :
7478 : 0 : return rc;
7479 : : }
7480 : :
7481 : : static uint32_t
7482 : 0 : zxdh_np_dtb_hash_software_item_check(ZXDH_HASH_ENTRY *p_entry,
7483 : : uint32_t key_by_size,
7484 : : uint32_t rst_by_size,
7485 : : ZXDH_SE_ITEM_CFG *p_item_info)
7486 : : {
7487 : : uint8_t srh_succ = 0;
7488 : : uint8_t temp_key_type = 0;
7489 : : uint8_t srh_key_type = 0;
7490 : : uint32_t dev_id = 0;
7491 : : ZXDH_D_NODE *p_entry_dn = NULL;
7492 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
7493 : :
7494 : 0 : srh_key_type = ZXDH_GET_HASH_KEY_TYPE(p_entry->p_key);
7495 : 0 : p_entry_dn = p_item_info->item_list.p_next;
7496 [ # # ]: 0 : while (p_entry_dn) {
7497 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_entry_dn->data;
7498 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rbkey);
7499 : :
7500 : : RTE_ASSERT(p_rbkey->p_item_info == p_item_info);
7501 : :
7502 : 0 : temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
7503 : :
7504 [ # # # # ]: 0 : if (ZXDH_GET_HASH_KEY_VALID(p_rbkey->key) && srh_key_type == temp_key_type) {
7505 [ # # ]: 0 : if (memcmp(p_entry->p_key, p_rbkey->key, key_by_size) == 0) {
7506 : : srh_succ = 1;
7507 : : break;
7508 : : }
7509 : : }
7510 : :
7511 : 0 : p_entry_dn = p_entry_dn->next;
7512 : : }
7513 : :
7514 [ # # ]: 0 : if (p_rbkey == NULL)
7515 : : return ZXDH_PAR_CHK_POINT_NULL;
7516 : :
7517 [ # # ]: 0 : if (!srh_succ) {
7518 : 0 : PMD_DRV_LOG(DEBUG, "hash search failed!");
7519 : 0 : return ZXDH_HASH_RC_MATCH_ITEM_FAIL;
7520 : : }
7521 : :
7522 : 0 : memcpy(p_entry->p_rst, p_rbkey->rst,
7523 : 0 : (rst_by_size > ZXDH_HASH_RST_MAX) ? ZXDH_HASH_RST_MAX : rst_by_size);
7524 : :
7525 : 0 : return ZXDH_OK;
7526 : : }
7527 : :
7528 : : static uint32_t
7529 : 0 : zxdh_np_dtb_hash_get_software(uint32_t dev_id,
7530 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
7531 : : ZXDH_HASH_ENTRY *p_hash_entry,
7532 : : uint8_t *p_srh_succ)
7533 : : {
7534 : : uint32_t rc = ZXDH_OK;
7535 : 0 : ZXDH_HASH_RBKEY_INFO srh_rbkey = {0};
7536 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
7537 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
7538 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
7539 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
7540 : : ZXDH_SPINLOCK_T *p_hash_spinlock = NULL;
7541 : :
7542 [ # # ]: 0 : memcpy(srh_rbkey.key, p_hash_entry->p_key, p_hash_entry_cfg->key_by_size);
7543 : :
7544 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
7545 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
7546 : :
7547 : 0 : zxdh_np_dev_hash_opr_spinlock_get(dev_id, p_hash_cfg->fun_id, &p_hash_spinlock);
7548 : 0 : rte_spinlock_lock(&p_hash_spinlock->spinlock);
7549 : :
7550 : 0 : rc = zxdh_comm_rb_search(&p_hash_cfg->hash_rb, (void *)&srh_rbkey, (void *)(&p_rb_tn_rtn));
7551 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL) {
7552 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_comm_rb_search fail.");
7553 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
7554 : 0 : return ZXDH_OK;
7555 : : }
7556 : :
7557 : 0 : p_rbkey = p_rb_tn_rtn->p_key;
7558 : 0 : p_item = p_rbkey->p_item_info;
7559 : :
7560 : 0 : rc = zxdh_np_dtb_hash_software_item_check(p_hash_entry,
7561 : : p_hash_entry_cfg->key_by_size,
7562 : : p_hash_entry_cfg->rst_by_size,
7563 : : p_item);
7564 [ # # ]: 0 : if (rc == ZXDH_OK) {
7565 : 0 : PMD_DRV_LOG(DEBUG, "Hash search software succ.");
7566 : 0 : *p_srh_succ = 1;
7567 : 0 : p_hash_cfg->hash_stat.search_ok++;
7568 : : }
7569 : :
7570 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
7571 : 0 : return rc;
7572 : : }
7573 : :
7574 : : static uint32_t
7575 : 0 : zxdh_np_dtb_hash_zcam_get(uint32_t dev_id,
7576 : : uint32_t queue_id,
7577 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
7578 : : ZXDH_HASH_ENTRY *p_hash_entry,
7579 : : uint32_t srh_mode,
7580 : : uint8_t *p_srh_succ)
7581 : : {
7582 : : uint32_t rc = ZXDH_OK;
7583 : :
7584 [ # # ]: 0 : if (srh_mode == ZXDH_HASH_SRH_MODE_HDW) {
7585 : 0 : rc = zxdh_np_dtb_hash_zcam_get_hardware(dev_id, queue_id,
7586 : : p_hash_entry_cfg, p_hash_entry, p_srh_succ);
7587 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_zcam_get_hardware");
7588 : : } else {
7589 : 0 : rc = zxdh_np_dtb_hash_get_software(dev_id, p_hash_entry_cfg,
7590 : : p_hash_entry, p_srh_succ);
7591 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_get_software");
7592 : : }
7593 : :
7594 : 0 : return rc;
7595 : : }
7596 : :
7597 : : static uint32_t
7598 : 0 : zxdh_np_dtb_hash_data_get(uint32_t dev_id,
7599 : : uint32_t queue_id,
7600 : : uint32_t sdt_no,
7601 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry,
7602 : : uint32_t srh_mode)
7603 : : {
7604 : : uint32_t rc = ZXDH_OK;
7605 : 0 : uint8_t srh_succ = 0;
7606 : : uint8_t key_valid = 1;
7607 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
7608 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
7609 : 0 : ZXDH_HASH_ENTRY hash_entry = {0};
7610 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
7611 : 0 : uint8_t temp_rst[ZXDH_HASH_RST_MAX] = {0};
7612 : :
7613 : 0 : PMD_DRV_LOG(DEBUG, "hash get sdt_no:%u", sdt_no);
7614 : :
7615 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
7616 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
7617 : :
7618 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
7619 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
7620 : :
7621 : 0 : hash_entry.p_key = temp_key;
7622 : 0 : hash_entry.p_rst = temp_rst;
7623 : 0 : hash_entry.p_key[0] = ZXDH_GET_HASH_KEY_CTRL(key_valid,
7624 : : hash_entry_cfg.key_type,
7625 : : hash_entry_cfg.table_id);
7626 : :
7627 : 0 : memcpy(&hash_entry.p_key[1], p_dtb_hash_entry->p_actu_key,
7628 : 0 : hash_entry_cfg.actu_key_size);
7629 : :
7630 : : if (!srh_succ) {
7631 : 0 : rc = zxdh_np_dtb_hash_zcam_get(dev_id, queue_id, &hash_entry_cfg,
7632 : : &hash_entry, srh_mode, &srh_succ);
7633 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_zcam_get");
7634 : : }
7635 : :
7636 [ # # ]: 0 : if (!srh_succ) {
7637 : 0 : p_hash_cfg->hash_stat.search_fail++;
7638 : 0 : PMD_DRV_LOG(DEBUG, "Hash search key fail!");
7639 : 0 : return ZXDH_HASH_RC_SRH_FAIL;
7640 : : }
7641 : :
7642 : 0 : memcpy(p_dtb_hash_entry->p_rst, hash_entry.p_rst,
7643 : 0 : 1 << (hash_entry_cfg.rsp_mode + 2));
7644 : :
7645 : 0 : return rc;
7646 : : }
7647 : :
7648 : : static void
7649 : : dtb_etcam_dump_data_len(uint32_t etcam_key_mode,
7650 : : uint32_t *p_etcam_dump_len,
7651 : : uint32_t *p_etcam_dump_inerval)
7652 : : {
7653 : : uint32_t dump_data_len = 0;
7654 : : uint8_t etcam_dump_inerval = 0;
7655 : :
7656 [ # # ]: 0 : if (ZXDH_ETCAM_KEY_640b == etcam_key_mode) {
7657 : : dump_data_len = 5 * ZXDH_DTB_LEN_POS_SETP;
7658 : : etcam_dump_inerval = 0;
7659 [ # # ]: 0 : } else if (ZXDH_ETCAM_KEY_320b == etcam_key_mode) {
7660 : : dump_data_len = 3 * ZXDH_DTB_LEN_POS_SETP;
7661 : : etcam_dump_inerval = 8;
7662 [ # # ]: 0 : } else if (ZXDH_ETCAM_KEY_160b == etcam_key_mode) {
7663 : : dump_data_len = 2 * ZXDH_DTB_LEN_POS_SETP;
7664 : : etcam_dump_inerval = 12;
7665 [ # # ]: 0 : } else if (ZXDH_ETCAM_KEY_80b == etcam_key_mode) {
7666 : : dump_data_len = 1 * ZXDH_DTB_LEN_POS_SETP;
7667 : : etcam_dump_inerval = 6;
7668 : : }
7669 : :
7670 : : *p_etcam_dump_len = dump_data_len;
7671 : 0 : *p_etcam_dump_inerval = etcam_dump_inerval;
7672 : : }
7673 : :
7674 : : static void
7675 : 0 : zxdh_np_dtb_get_etcam_xy_from_dump_data(uint8_t *p_data,
7676 : : uint8_t *p_mask,
7677 : : uint32_t etcam_dump_len,
7678 : : uint32_t etcam_dump_inerval,
7679 : : ZXDH_ETCAM_ENTRY_T *p_entry_xy)
7680 : : {
7681 : : uint8_t *p_entry_data = NULL;
7682 : : uint8_t *p_entry_mask = NULL;
7683 : :
7684 : 0 : zxdh_np_comm_swap(p_data, etcam_dump_len);
7685 : 0 : zxdh_np_comm_swap(p_mask, etcam_dump_len);
7686 : :
7687 : 0 : p_entry_data = p_data + etcam_dump_inerval;
7688 : 0 : p_entry_mask = p_mask + etcam_dump_inerval;
7689 : :
7690 : 0 : memcpy(p_entry_xy->p_data, p_entry_data,
7691 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry_xy->mode));
7692 : 0 : memcpy(p_entry_xy->p_mask, p_entry_mask,
7693 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry_xy->mode));
7694 : 0 : }
7695 : :
7696 : :
7697 : : static void
7698 : : zxdh_np_etcam_xy_to_dm(ZXDH_ETCAM_ENTRY_T *p_dm,
7699 : : ZXDH_ETCAM_ENTRY_T *p_xy,
7700 : : uint32_t len)
7701 : : {
7702 : : uint32_t i = 0;
7703 : :
7704 : : RTE_ASSERT(p_dm->p_data && p_dm->p_mask && p_xy->p_data && p_xy->p_mask);
7705 : :
7706 [ # # # # ]: 0 : for (i = 0; i < len; i++) {
7707 : 0 : p_dm->p_data[i] = ZXDH_COMM_XY_TO_DATA(p_xy->p_data[i], p_xy->p_mask[i]);
7708 : 0 : p_dm->p_mask[i] = ZXDH_COMM_XY_TO_MASK(p_xy->p_data[i], p_xy->p_mask[i]);
7709 : : }
7710 : : }
7711 : :
7712 : : static uint32_t
7713 : 0 : zxdh_np_dtb_etcam_entry_get(uint32_t dev_id,
7714 : : uint32_t queue_id,
7715 : : uint32_t block_idx,
7716 : : uint32_t addr,
7717 : : uint32_t rd_mode,
7718 : : uint32_t opr_type,
7719 : : uint32_t as_en,
7720 : : uint32_t as_eram_baddr,
7721 : : uint32_t as_eram_index,
7722 : : uint32_t as_rsp_mode,
7723 : : ZXDH_ETCAM_ENTRY_T *p_entry,
7724 : : uint8_t *p_as_rslt)
7725 : : {
7726 : : uint32_t rc = ZXDH_OK;
7727 : :
7728 : : uint32_t etcam_key_mode = 0;
7729 : :
7730 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7731 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7732 : 0 : ZXDH_ETCAM_ENTRY_T entry_xy = {0};
7733 : :
7734 : : uint32_t etcam_data_dst_phy_haddr = 0;
7735 : : uint32_t etcam_data_dst_phy_laddr = 0;
7736 : : uint32_t etcam_mask_dst_phy_haddr = 0;
7737 : : uint32_t etcam_mask_dst_phy_laddr = 0;
7738 : : uint32_t as_rst_dst_phy_haddr = 0;
7739 : : uint32_t as_rst_dst_phy_laddr = 0;
7740 : :
7741 : 0 : uint32_t dump_element_id = 0;
7742 : : uint32_t etcam_dump_one_data_len = 0;
7743 : : uint32_t etcam_dump_inerval = 0;
7744 : : uint32_t dtb_desc_addr_offset = 0;
7745 : : uint32_t dump_data_len = 0;
7746 : : uint32_t dtb_desc_len = 0;
7747 : :
7748 : : uint32_t eram_dump_base_addr = 0;
7749 : : uint32_t row_index = 0;
7750 : : uint32_t col_index = 0;
7751 : :
7752 : : uint8_t *p_data = NULL;
7753 : : uint8_t *p_mask = NULL;
7754 : : uint8_t *p_rst = NULL;
7755 : : uint8_t *temp_dump_out_data = NULL;
7756 : : uint8_t *dump_info_buff = NULL;
7757 : 0 : ZXDH_ETCAM_DUMP_INFO_T etcam_dump_info = {0};
7758 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
7759 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
7760 : :
7761 : 0 : dtb_dump_entry.cmd = cmd_buff;
7762 : :
7763 : 0 : entry_xy.p_data = temp_data;
7764 : 0 : entry_xy.p_mask = temp_mask;
7765 : :
7766 : 0 : etcam_key_mode = p_entry->mode;
7767 : :
7768 : 0 : etcam_dump_info.block_sel = block_idx;
7769 : 0 : etcam_dump_info.addr = addr;
7770 : 0 : etcam_dump_info.tb_width = 3 - etcam_key_mode;
7771 : 0 : etcam_dump_info.rd_mode = rd_mode;
7772 : 0 : etcam_dump_info.tb_depth = 1;
7773 : :
7774 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &dump_element_id);
7775 [ # # ]: 0 : if (rc != ZXDH_OK) {
7776 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_dtb_tab_up_free_item_get failed!");
7777 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7778 : : }
7779 : :
7780 : : dtb_etcam_dump_data_len(etcam_key_mode, &etcam_dump_one_data_len, &etcam_dump_inerval);
7781 : :
7782 : 0 : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_DATA;
7783 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
7784 : : queue_id,
7785 : : dump_element_id,
7786 : : dump_data_len,
7787 : : &etcam_data_dst_phy_haddr,
7788 : : &etcam_data_dst_phy_laddr);
7789 : :
7790 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
7791 : : &etcam_dump_info,
7792 : : etcam_data_dst_phy_haddr,
7793 : : etcam_data_dst_phy_laddr,
7794 : : &dtb_dump_entry);
7795 : :
7796 : 0 : dump_info_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
7797 [ # # ]: 0 : if (dump_info_buff == NULL) {
7798 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
7799 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
7800 : : }
7801 : :
7802 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
7803 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
7804 : : dtb_desc_len += 1;
7805 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
7806 : : dump_data_len += etcam_dump_one_data_len;
7807 : :
7808 [ # # ]: 0 : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_MASK;
7809 : : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
7810 : : queue_id,
7811 : : dump_element_id,
7812 : : dump_data_len,
7813 : : &etcam_mask_dst_phy_haddr,
7814 : : &etcam_mask_dst_phy_laddr);
7815 : :
7816 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
7817 : : &etcam_dump_info,
7818 : : etcam_mask_dst_phy_haddr,
7819 : : etcam_mask_dst_phy_laddr,
7820 : : &dtb_dump_entry);
7821 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
7822 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
7823 : : dtb_desc_len += 1;
7824 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
7825 : 0 : dump_data_len += etcam_dump_one_data_len;
7826 : :
7827 [ # # ]: 0 : if (as_en) {
7828 : : zxdh_np_eram_index_cal(as_rsp_mode, as_eram_index, &row_index, &col_index);
7829 : :
7830 [ # # ]: 0 : eram_dump_base_addr = as_eram_baddr + row_index;
7831 : : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
7832 : : queue_id,
7833 : : dump_element_id,
7834 : : dump_data_len,
7835 : : &as_rst_dst_phy_haddr,
7836 : : &as_rst_dst_phy_laddr);
7837 : :
7838 : 0 : zxdh_np_dtb_smmu0_dump_entry(dev_id,
7839 : : eram_dump_base_addr,
7840 : : 1,
7841 : : as_rst_dst_phy_haddr,
7842 : : as_rst_dst_phy_laddr,
7843 : : &dtb_dump_entry);
7844 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
7845 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
7846 : : dtb_desc_len += 1;
7847 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
7848 : 0 : dump_data_len += ZXDH_DTB_LEN_POS_SETP;
7849 : : }
7850 : :
7851 : 0 : temp_dump_out_data = rte_zmalloc(NULL, dump_data_len, 0);
7852 [ # # ]: 0 : if (temp_dump_out_data == NULL) {
7853 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
7854 : 0 : rte_free(dump_info_buff);
7855 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
7856 : : }
7857 : : p_data = temp_dump_out_data;
7858 : :
7859 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id,
7860 : : queue_id,
7861 : : dump_element_id,
7862 : : (uint32_t *)dump_info_buff,
7863 : : dump_data_len / 4,
7864 : : dtb_desc_len * 4,
7865 : : (uint32_t *)temp_dump_out_data);
7866 : :
7867 : : p_data = temp_dump_out_data;
7868 : 0 : p_mask = p_data + etcam_dump_one_data_len;
7869 : :
7870 : 0 : zxdh_np_dtb_get_etcam_xy_from_dump_data(p_data,
7871 : : p_mask,
7872 : : etcam_dump_one_data_len,
7873 : : etcam_dump_inerval,
7874 : : &entry_xy);
7875 : :
7876 [ # # ]: 0 : if (opr_type == ZXDH_ETCAM_OPR_DM) {
7877 : 0 : zxdh_np_etcam_xy_to_dm(p_entry, &entry_xy,
7878 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
7879 : : } else {
7880 : 0 : memcpy(p_entry->p_data, entry_xy.p_data,
7881 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
7882 : 0 : memcpy(p_entry->p_mask, entry_xy.p_mask,
7883 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
7884 : : }
7885 : :
7886 [ # # ]: 0 : if (as_en) {
7887 : 0 : p_rst = p_mask + etcam_dump_one_data_len;
7888 : : memcpy(p_as_rslt, p_rst, (128 / 8));
7889 : : }
7890 : :
7891 : 0 : rte_free(dump_info_buff);
7892 : 0 : rte_free(temp_dump_out_data);
7893 : :
7894 : 0 : return rc;
7895 : : }
7896 : :
7897 : : static uint32_t
7898 : 0 : zxdh_np_etcam_entry_cmp(ZXDH_ETCAM_ENTRY_T *p_entry_dm, ZXDH_ETCAM_ENTRY_T *p_entry_xy)
7899 : : {
7900 : : uint32_t data_mask_len = 0;
7901 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7902 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7903 : 0 : ZXDH_ETCAM_ENTRY_T entry_xy_temp = {0};
7904 : :
7905 : 0 : entry_xy_temp.mode = p_entry_dm->mode;
7906 : 0 : entry_xy_temp.p_data = temp_data;
7907 : 0 : entry_xy_temp.p_mask = temp_mask;
7908 : :
7909 : 0 : data_mask_len = ZXDH_ETCAM_ENTRY_SIZE_GET(entry_xy_temp.mode);
7910 : :
7911 : 0 : zxdh_np_etcam_dm_to_xy(p_entry_dm, &entry_xy_temp, data_mask_len);
7912 : :
7913 [ # # ]: 0 : if ((memcmp(entry_xy_temp.p_data, p_entry_xy->p_data, data_mask_len) != 0) ||
7914 [ # # ]: 0 : (memcmp(entry_xy_temp.p_mask, p_entry_xy->p_mask, data_mask_len) != 0)) {
7915 : 0 : return ZXDH_ERR;
7916 : : }
7917 : :
7918 : : return ZXDH_OK;
7919 : : }
7920 : :
7921 : : static uint32_t
7922 : 0 : zxdh_np_dtb_acl_data_get(uint32_t dev_id,
7923 : : uint32_t queue_id,
7924 : : uint32_t sdt_no,
7925 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dump_acl_entry)
7926 : : {
7927 : : uint32_t rc = ZXDH_OK;
7928 : 0 : uint32_t block_idx = 0;
7929 : 0 : uint32_t ram_addr = 0;
7930 : 0 : uint32_t etcam_wr_mode = 0;
7931 : : uint32_t etcam_key_mode = 0;
7932 : : uint32_t etcam_table_id = 0;
7933 : : uint32_t as_enable = 0;
7934 : : uint32_t as_eram_baddr = 0;
7935 : : uint32_t etcam_as_mode = 0;
7936 : : uint32_t row_index = 0;
7937 : : uint32_t col_index = 0;
7938 : :
7939 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry_dm = {0};
7940 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry_xy = {0};
7941 : 0 : uint32_t as_eram_data[4] = {0};
7942 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7943 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7944 : :
7945 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
7946 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
7947 : :
7948 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
7949 : :
7950 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
7951 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
7952 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
7953 : 0 : etcam_key_mode = sdt_etcam_info.etcam_key_mode;
7954 : 0 : etcam_as_mode = sdt_etcam_info.as_rsp_mode;
7955 : 0 : etcam_table_id = sdt_etcam_info.etcam_table_id;
7956 : 0 : as_enable = sdt_etcam_info.as_en;
7957 : 0 : as_eram_baddr = sdt_etcam_info.as_eram_baddr;
7958 : :
7959 : 0 : etcam_entry_xy.mode = etcam_key_mode;
7960 : 0 : etcam_entry_xy.p_data = temp_data;
7961 : 0 : etcam_entry_xy.p_mask = temp_mask;
7962 : 0 : etcam_entry_dm.mode = etcam_key_mode;
7963 : 0 : etcam_entry_dm.p_data = p_dump_acl_entry->key_data;
7964 : 0 : etcam_entry_dm.p_mask = p_dump_acl_entry->key_mask;
7965 : :
7966 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
7967 : :
7968 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
7969 : :
7970 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
7971 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
7972 : : RTE_ASSERT(0);
7973 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
7974 : : }
7975 : :
7976 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_dump_acl_entry->handle,
7977 : : &block_idx, &ram_addr, &etcam_wr_mode);
7978 : :
7979 : 0 : rc = zxdh_np_dtb_etcam_entry_get(dev_id,
7980 : : queue_id,
7981 : : block_idx,
7982 : : ram_addr,
7983 : : etcam_wr_mode,
7984 : : ZXDH_ETCAM_OPR_XY,
7985 : : as_enable,
7986 : : as_eram_baddr,
7987 : : p_dump_acl_entry->handle,
7988 : : etcam_as_mode,
7989 : : &etcam_entry_xy,
7990 : : (uint8_t *)as_eram_data);
7991 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_etcam_entry_get");
7992 : :
7993 [ # # ]: 0 : if (zxdh_np_etcam_entry_cmp(&etcam_entry_dm, &etcam_entry_xy) == 0) {
7994 : 0 : PMD_DRV_LOG(DEBUG, "get done, handle:0x%x block:%u ram_addr:%u rd_mode:%x",
7995 : : p_dump_acl_entry->handle, block_idx, ram_addr, etcam_wr_mode);
7996 : : } else {
7997 : 0 : PMD_DRV_LOG(DEBUG, "get fail, handle:0x%x block:%u ram_addr:%u rd_mode:%x",
7998 : : p_dump_acl_entry->handle, block_idx, ram_addr, etcam_wr_mode);
7999 : :
8000 : 0 : return ZXDH_ERR;
8001 : : }
8002 : :
8003 [ # # ]: 0 : if (as_enable) {
8004 [ # # # ]: 0 : zxdh_np_eram_index_cal(etcam_as_mode, p_dump_acl_entry->handle,
8005 : : &row_index, &col_index);
8006 [ # # # # ]: 0 : switch (etcam_as_mode) {
8007 : 0 : case ZXDH_ERAM128_TBL_128b:
8008 : 0 : memcpy(p_dump_acl_entry->p_as_rslt, as_eram_data, (128 / 8));
8009 : : break;
8010 : :
8011 : 0 : case ZXDH_ERAM128_TBL_64b:
8012 : 0 : memcpy(p_dump_acl_entry->p_as_rslt, as_eram_data +
8013 : 0 : ((1 - col_index) << 1), (64 / 8));
8014 : : break;
8015 : :
8016 : 0 : case ZXDH_ERAM128_TBL_1b:
8017 : 0 : ZXDH_COMM_UINT32_GET_BITS(*(uint32_t *)p_dump_acl_entry->p_as_rslt,
8018 : : *(as_eram_data + (3 - col_index / 32)), (col_index % 32), 1);
8019 : 0 : break;
8020 : : default:
8021 : : break;
8022 : : }
8023 : : }
8024 : :
8025 : : return rc;
8026 : : }
8027 : :
8028 : : int
8029 : 0 : zxdh_np_dtb_table_entry_get(uint32_t dev_id,
8030 : : uint32_t queue_id,
8031 : : ZXDH_DTB_USER_ENTRY_T *get_entry,
8032 : : uint32_t srh_mode)
8033 : : {
8034 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
8035 : : uint32_t tbl_type = 0;
8036 : : uint32_t rc;
8037 : : uint32_t sdt_no;
8038 : : uint32_t sdt_partner = 0;
8039 : : uint32_t valid = 0;
8040 : 0 : uint8_t key = 0;
8041 : :
8042 : 0 : sdt_no = get_entry->sdt_no;
8043 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
8044 : :
8045 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
8046 : :
8047 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_tbl.data_high32,
8048 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
8049 [ # # # # ]: 0 : switch (tbl_type) {
8050 : 0 : case ZXDH_SDT_TBLT_ERAM:
8051 : 0 : rc = zxdh_np_dtb_eram_data_get(dev_id,
8052 : : queue_id,
8053 : : sdt_no,
8054 : 0 : (ZXDH_DTB_ERAM_ENTRY_INFO_T *)get_entry->p_entry_data);
8055 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_eram_data_get");
8056 : : break;
8057 : 0 : case ZXDH_SDT_TBLT_HASH:
8058 : : do {
8059 : 0 : rc = zxdh_np_dtb_hash_data_get(dev_id,
8060 : : queue_id,
8061 : : sdt_no,
8062 : 0 : (ZXDH_DTB_HASH_ENTRY_INFO_T *)get_entry->p_entry_data,
8063 : : srh_mode);
8064 : : sdt_partner = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
8065 : 0 : valid = zxdh_np_hash_sdt_partner_valid(sdt_no, sdt_partner, &key);
8066 : : sdt_no = sdt_partner;
8067 [ # # ]: 0 : } while ((rc == ZXDH_HASH_RC_SRH_FAIL) && (valid == ZXDH_TRUE));
8068 : :
8069 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_SRH_FAIL) {
8070 : 0 : PMD_DRV_LOG(DEBUG, "hash search failed");
8071 : 0 : return rc;
8072 : : }
8073 : :
8074 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_data_get");
8075 : : break;
8076 : 0 : case ZXDH_SDT_TBLT_ETCAM:
8077 : 0 : rc = zxdh_np_dtb_acl_data_get(dev_id,
8078 : : queue_id,
8079 : : sdt_no,
8080 : 0 : (ZXDH_DTB_ACL_ENTRY_INFO_T *)get_entry->p_entry_data);
8081 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_data_get");
8082 : : break;
8083 : 0 : default:
8084 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
8085 : 0 : return 1;
8086 : : }
8087 : :
8088 : : return 0;
8089 : : }
8090 : :
8091 : : static uint32_t
8092 : 0 : zxdh_np_dtb_se_smmu0_ind_read(uint32_t dev_id,
8093 : : uint32_t queue_id,
8094 : : uint32_t base_addr,
8095 : : uint32_t index,
8096 : : uint32_t rd_mode,
8097 : : uint32_t *p_data)
8098 : : {
8099 : 0 : uint32_t temp_data[4] = {0};
8100 : 0 : uint32_t element_id = 0;
8101 : : uint32_t row_index = 0;
8102 : : uint32_t col_index = 0;
8103 : : uint32_t eram_dump_base_addr;
8104 : : uint32_t rc;
8105 : :
8106 [ # # # # ]: 0 : switch (rd_mode) {
8107 : 0 : case ZXDH_ERAM128_OPR_128b:
8108 : : row_index = index;
8109 : 0 : break;
8110 : 0 : case ZXDH_ERAM128_OPR_64b:
8111 : 0 : row_index = (index >> 1);
8112 : 0 : col_index = index & 0x1;
8113 : 0 : break;
8114 : 0 : case ZXDH_ERAM128_OPR_1b:
8115 : 0 : row_index = (index >> 7);
8116 : 0 : col_index = index & 0x7F;
8117 : 0 : break;
8118 : : default:
8119 : : break;
8120 : : }
8121 : :
8122 : 0 : eram_dump_base_addr = base_addr + row_index;
8123 : 0 : rc = zxdh_np_dtb_se_smmu0_dma_dump(dev_id,
8124 : : queue_id,
8125 : : eram_dump_base_addr,
8126 : : 1,
8127 : : temp_data,
8128 : : &element_id);
8129 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_dma_dump");
8130 : :
8131 [ # # # # ]: 0 : switch (rd_mode) {
8132 : : case ZXDH_ERAM128_OPR_128b:
8133 : : memcpy(p_data, temp_data, (128 / 8));
8134 : : break;
8135 : 0 : case ZXDH_ERAM128_OPR_64b:
8136 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
8137 : : break;
8138 : 0 : case ZXDH_ERAM128_OPR_1b:
8139 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
8140 : : (3 - col_index / 32)), (col_index % 32), 1);
8141 : 0 : break;
8142 : : default:
8143 : : break;
8144 : : }
8145 : :
8146 : 0 : return rc;
8147 : : }
8148 : :
8149 : : static uint32_t
8150 : 0 : zxdh_np_dtb_stat_smmu0_int_read(uint32_t dev_id,
8151 : : uint32_t queue_id,
8152 : : uint32_t smmu0_base_addr,
8153 : : ZXDH_STAT_CNT_MODE_E rd_mode,
8154 : : uint32_t index,
8155 : : uint32_t *p_data)
8156 : : {
8157 : : uint32_t eram_rd_mode;
8158 : : uint32_t rc;
8159 : :
8160 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
8161 : :
8162 [ # # ]: 0 : if (rd_mode == ZXDH_STAT_128_MODE)
8163 : : eram_rd_mode = ZXDH_ERAM128_OPR_128b;
8164 : : else
8165 : : eram_rd_mode = ZXDH_ERAM128_OPR_64b;
8166 : :
8167 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_read(dev_id,
8168 : : queue_id,
8169 : : smmu0_base_addr,
8170 : : index,
8171 : : eram_rd_mode,
8172 : : p_data);
8173 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_ind_read");
8174 : :
8175 : 0 : return rc;
8176 : : }
8177 : :
8178 : : int
8179 : 0 : zxdh_np_dtb_stats_get(uint32_t dev_id,
8180 : : uint32_t queue_id,
8181 : : ZXDH_STAT_CNT_MODE_E rd_mode,
8182 : : uint32_t index,
8183 : : uint32_t *p_data)
8184 : : {
8185 : : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
8186 : : uint32_t ppu_eram_baddr;
8187 : : uint32_t ppu_eram_depth;
8188 : : uint32_t rc = 0;
8189 : :
8190 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
8191 : :
8192 : : memset(&stat_cfg, 0x0, sizeof(stat_cfg));
8193 : :
8194 : 0 : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
8195 : :
8196 : 0 : ppu_eram_depth = stat_cfg.eram_depth;
8197 : 0 : ppu_eram_baddr = stat_cfg.eram_baddr;
8198 : :
8199 [ # # ]: 0 : if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) {
8200 : 0 : rc = zxdh_np_dtb_stat_smmu0_int_read(dev_id,
8201 : : queue_id,
8202 : : ppu_eram_baddr,
8203 : : rd_mode,
8204 : : index,
8205 : : p_data);
8206 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_stat_smmu0_int_read");
8207 : : }
8208 : :
8209 : 0 : return rc;
8210 : : }
8211 : :
8212 : : static uint32_t
8213 : 0 : zxdh_np_dtb_queue_down_init(uint32_t dev_id,
8214 : : uint32_t queue_id,
8215 : : ZXDH_DTB_QUEUE_CFG_T *p_queue_cfg)
8216 : : {
8217 : : uint32_t rc = 0;
8218 : : uint32_t i = 0;
8219 : : uint32_t ack_vale = 0;
8220 : : uint32_t tab_down_item_size = 0;
8221 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
8222 : :
8223 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
8224 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 1;
8225 : :
8226 : 0 : tab_down_item_size = (p_queue_cfg->down_item_size == 0) ?
8227 [ # # ]: 0 : ZXDH_DTB_ITEM_SIZE : p_queue_cfg->down_item_size;
8228 : :
8229 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.item_size = tab_down_item_size;
8230 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.start_phy_addr = p_queue_cfg->down_start_phy_addr;
8231 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.start_vir_addr = p_queue_cfg->down_start_vir_addr;
8232 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.wr_index = 0;
8233 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.rd_index = 0;
8234 : :
8235 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8236 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id,
8237 : : ZXDH_DTB_DIR_DOWN_TYPE, i, 0, ZXDH_DTB_TAB_ACK_CHECK_VALUE);
8238 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
8239 : : }
8240 : :
8241 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8242 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id,
8243 : : ZXDH_DTB_DIR_DOWN_TYPE, i, 0, &ack_vale);
8244 [ # # ]: 0 : if (ack_vale != ZXDH_DTB_TAB_ACK_CHECK_VALUE) {
8245 : 0 : PMD_DRV_LOG(ERR, "dtb queue [%u] down init failed!", queue_id);
8246 : 0 : return ZXDH_RC_DTB_MEMORY_ALLOC_ERR;
8247 : : }
8248 : : }
8249 : :
8250 : 0 : memset((uint8_t *)(p_queue_cfg->down_start_vir_addr), 0,
8251 : 0 : tab_down_item_size * ZXDH_DTB_QUEUE_ITEM_NUM_MAX);
8252 : :
8253 : 0 : PMD_DRV_LOG(INFO, "dtb queue [%u] down init success!!!", queue_id);
8254 : :
8255 : 0 : return ZXDH_OK;
8256 : : }
8257 : :
8258 : : static uint32_t
8259 : 0 : zxdh_np_dtb_queue_dump_init(uint32_t dev_id,
8260 : : uint32_t queue_id,
8261 : : ZXDH_DTB_QUEUE_CFG_T *p_queue_cfg)
8262 : : {
8263 : : uint32_t i = 0;
8264 : : uint32_t ack_vale = 0;
8265 : : uint32_t tab_up_item_size = 0;
8266 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
8267 : :
8268 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
8269 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 1;
8270 : :
8271 : 0 : tab_up_item_size = (p_queue_cfg->up_item_size == 0) ?
8272 [ # # ]: 0 : ZXDH_DTB_ITEM_SIZE : p_queue_cfg->up_item_size;
8273 : :
8274 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.item_size = tab_up_item_size;
8275 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.start_phy_addr = p_queue_cfg->up_start_phy_addr;
8276 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.start_vir_addr = p_queue_cfg->up_start_vir_addr;
8277 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.wr_index = 0;
8278 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.rd_index = 0;
8279 : :
8280 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8281 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id,
8282 : : ZXDH_DTB_DIR_UP_TYPE, i, 0, ZXDH_DTB_TAB_ACK_CHECK_VALUE);
8283 : : }
8284 : :
8285 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8286 : : zxdh_np_dtb_item_ack_rd(dev_id, queue_id,
8287 : : ZXDH_DTB_DIR_UP_TYPE, i, 0, &ack_vale);
8288 [ # # ]: 0 : if (ack_vale != ZXDH_DTB_TAB_ACK_CHECK_VALUE) {
8289 : 0 : PMD_DRV_LOG(ERR, "dtb queue [%u] dump init failed!!!", queue_id);
8290 : 0 : return ZXDH_RC_DTB_MEMORY_ALLOC_ERR;
8291 : : }
8292 : : }
8293 : :
8294 : 0 : memset((uint8_t *)(p_queue_cfg->up_start_vir_addr), 0,
8295 : 0 : tab_up_item_size * ZXDH_DTB_QUEUE_ITEM_NUM_MAX);
8296 : :
8297 : 0 : PMD_DRV_LOG(INFO, "dtb queue [%u] up init success!!!", queue_id);
8298 : :
8299 : 0 : return ZXDH_OK;
8300 : : }
8301 : :
8302 : : static void
8303 : : zxdh_np_dtb_down_channel_addr_set(uint32_t dev_id,
8304 : : uint32_t channel_id,
8305 : : uint64_t phy_addr,
8306 : : uint64_t vir_addr,
8307 : : uint32_t size)
8308 : : {
8309 : 0 : ZXDH_DTB_QUEUE_CFG_T down_queue_cfg = {
8310 : : .down_start_phy_addr = phy_addr,
8311 : : .down_start_vir_addr = vir_addr,
8312 : : .down_item_size = size,
8313 : : };
8314 : :
8315 : 0 : zxdh_np_dtb_queue_down_init(dev_id, channel_id, &down_queue_cfg);
8316 : : }
8317 : :
8318 : : static void
8319 : : zxdh_np_dtb_dump_channel_addr_set(uint32_t dev_id,
8320 : : uint32_t channel_id,
8321 : : uint64_t phy_addr,
8322 : : uint64_t vir_addr,
8323 : : uint32_t size)
8324 : : {
8325 : 0 : ZXDH_DTB_QUEUE_CFG_T dump_queue_cfg = {
8326 : : .up_start_phy_addr = phy_addr,
8327 : : .up_start_vir_addr = vir_addr,
8328 : : .up_item_size = size,
8329 : : };
8330 : :
8331 : 0 : zxdh_np_dtb_queue_dump_init(dev_id, channel_id, &dump_queue_cfg);
8332 : : }
8333 : :
8334 : : static uint32_t
8335 : 0 : zxdh_np_dtb_user_info_set(uint32_t dev_id, uint32_t queue_id, uint16_t vport, uint32_t vector)
8336 : : {
8337 : : uint32_t rc = ZXDH_OK;
8338 : :
8339 : 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
8340 : : ZXDH_DTB_MGR_T *p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
8341 : :
8342 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
8343 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_queue_vm_info_get");
8344 : :
8345 : 0 : vm_info.dbi_en = 1;
8346 : 0 : vm_info.epid = hardware_ep_id[ZXDH_EPID_BY(vport)];
8347 : 0 : vm_info.vfunc_num = ZXDH_VFUNC_NUM(vport);
8348 : 0 : vm_info.func_num = ZXDH_FUNC_NUM(vport);
8349 : 0 : vm_info.vfunc_active = ZXDH_VF_ACTIVE(vport);
8350 : 0 : vm_info.vector = vector;
8351 : :
8352 : 0 : p_dtb_mgr->queue_info[queue_id].vport = vport;
8353 : 0 : p_dtb_mgr->queue_info[queue_id].vector = vector;
8354 : :
8355 : 0 : rc = zxdh_np_dtb_queue_vm_info_set(dev_id, queue_id, &vm_info);
8356 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_queue_vm_info_set");
8357 : :
8358 : 0 : return rc;
8359 : : }
8360 : :
8361 : : static uint32_t
8362 : 0 : zxdh_np_dtb_dump_sdt_addr_set(uint32_t dev_id,
8363 : : uint32_t queue_id,
8364 : : uint32_t sdt_no,
8365 : : uint64_t phy_addr,
8366 : : uint64_t vir_addr,
8367 : : uint32_t size)
8368 : : {
8369 : : uint32_t rc = ZXDH_OK;
8370 : :
8371 : 0 : ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {
8372 : : .sdt_no = sdt_no,
8373 : : .phy_addr = phy_addr,
8374 : : .vir_addr = vir_addr,
8375 : : .size = size,
8376 : : };
8377 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
8378 : :
8379 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
8380 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dtb_dump_addr_rb);
8381 : :
8382 : 0 : rc = zxdh_np_se_apt_rb_insert(p_dtb_dump_addr_rb,
8383 : : &dtb_dump_addr_info, sizeof(ZXDH_DTB_ADDR_INFO_T));
8384 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_apt_rb_insert");
8385 : :
8386 : 0 : return rc;
8387 : : }
8388 : :
8389 : : static uint32_t
8390 : 0 : zxdh_np_apt_dtb_res_init(uint32_t dev_id, ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
8391 : : {
8392 : : uint32_t rc = ZXDH_OK;
8393 : :
8394 : 0 : uint32_t queue_id = 0;
8395 : : uint32_t index = 0;
8396 : : uint32_t dump_sdt_num = 0;
8397 : : ZXDH_DTB_ADDR_INFO_T *p_dump_info = NULL;
8398 : :
8399 : 0 : rc = zxdh_np_dtb_queue_request(dev_id, p_dev_init_ctrl->port_name,
8400 : 0 : p_dev_init_ctrl->vport, &queue_id);
8401 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_queue_request");
8402 : :
8403 : 0 : p_dev_init_ctrl->queue_id = queue_id;
8404 : :
8405 : 0 : rc = zxdh_np_dtb_user_info_set(dev_id, queue_id,
8406 : 0 : p_dev_init_ctrl->vport, p_dev_init_ctrl->vector);
8407 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_user_info_set");
8408 : :
8409 : 0 : zxdh_np_dtb_down_channel_addr_set(dev_id, queue_id,
8410 : : p_dev_init_ctrl->down_phy_addr, p_dev_init_ctrl->down_vir_addr, 0);
8411 : :
8412 : 0 : zxdh_np_dtb_dump_channel_addr_set(dev_id, queue_id,
8413 : : p_dev_init_ctrl->dump_phy_addr, p_dev_init_ctrl->dump_vir_addr, 0);
8414 : :
8415 : 0 : dump_sdt_num = p_dev_init_ctrl->dump_sdt_num;
8416 [ # # ]: 0 : for (index = 0; index < dump_sdt_num; index++) {
8417 : 0 : p_dump_info = p_dev_init_ctrl->dump_addr_info + index;
8418 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dump_info);
8419 : 0 : rc = zxdh_np_dtb_dump_sdt_addr_set(dev_id,
8420 : : queue_id,
8421 : : p_dump_info->sdt_no,
8422 : : p_dump_info->phy_addr,
8423 : : p_dump_info->vir_addr,
8424 : : p_dump_info->size);
8425 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_set");
8426 : : }
8427 : :
8428 : 0 : return ZXDH_OK;
8429 : : }
8430 : :
8431 : : int
8432 : 0 : zxdh_np_host_init(uint32_t dev_id,
8433 : : ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
8434 : : {
8435 : 0 : ZXDH_SYS_INIT_CTRL_T sys_init_ctrl = {0};
8436 : : uint32_t rc;
8437 : : uint64_t agent_addr;
8438 : 0 : uint32_t bar_msg_num = 0;
8439 : :
8440 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dev_init_ctrl);
8441 : :
8442 : 0 : sys_init_ctrl.flags = (ZXDH_DEV_ACCESS_TYPE_PCIE << 0) | (ZXDH_DEV_AGENT_ENABLE << 10);
8443 : 0 : sys_init_ctrl.pcie_vir_baddr = zxdh_np_addr_calc(p_dev_init_ctrl->pcie_vir_addr,
8444 : : p_dev_init_ctrl->np_bar_offset);
8445 : 0 : sys_init_ctrl.device_type = ZXDH_DEV_TYPE_CHIP;
8446 : :
8447 : 0 : rc = zxdh_np_base_soft_init(dev_id, &sys_init_ctrl);
8448 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_base_soft_init");
8449 : :
8450 : 0 : zxdh_np_dev_vport_set(dev_id, p_dev_init_ctrl->vport);
8451 : :
8452 : 0 : agent_addr = ZXDH_PCIE_AGENT_ADDR_OFFSET + p_dev_init_ctrl->pcie_vir_addr;
8453 : : zxdh_np_dev_agent_addr_set(dev_id, agent_addr);
8454 : :
8455 : : zxdh_np_pf_fw_compatible_addr_set(dev_id, p_dev_init_ctrl->pcie_vir_addr);
8456 : :
8457 : 0 : rc = zxdh_np_np_sdk_version_compatible_check(dev_id);
8458 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_np_sdk_version_compatible_check");
8459 : :
8460 : 0 : rc = zxdh_np_pcie_bar_msg_num_get(dev_id, &bar_msg_num);
8461 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_pcie_bar_msg_num_get");
8462 : :
8463 : 0 : zxdh_np_dev_fw_bar_msg_num_set(dev_id, bar_msg_num);
8464 : :
8465 : 0 : rc = zxdh_np_apt_dtb_res_init(dev_id, p_dev_init_ctrl);
8466 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_dtb_res_init");
8467 : 0 : PMD_DRV_LOG(INFO, "host init done, queue_id = %u", p_dev_init_ctrl->queue_id);
8468 : :
8469 : 0 : return 0;
8470 : : }
8471 : :
8472 : : static uint32_t
8473 : : zxdh_np_get_se_buff_size(uint32_t opr)
8474 : : {
8475 : : uint32_t buff_size = 0;
8476 : :
8477 : : switch (opr) {
8478 : : case ZXDH_HASH_FUNC_BULK_REQ:
8479 : : buff_size = sizeof(ZXDH_NP_SE_HASH_FUNC_BULK_T);
8480 : : break;
8481 : : case ZXDH_HASH_TBL_REQ:
8482 : : buff_size = sizeof(ZXDH_NP_SE_HASH_TBL_T);
8483 : : break;
8484 : : case ZXDH_ERAM_TBL_REQ:
8485 : : buff_size = sizeof(ZXDH_NP_SE_ERAM_TBL_T);
8486 : : break;
8487 : : case ZXDH_ACL_TBL_REQ:
8488 : : buff_size = sizeof(ZXDH_NP_SE_ACL_TBL_T);
8489 : : break;
8490 : : case ZXDH_STAT_CFG_REQ:
8491 : : buff_size = sizeof(ZXDH_NP_SE_STAT_CFG_T);
8492 : : break;
8493 : : default:
8494 : : break;
8495 : : }
8496 : :
8497 : : return buff_size;
8498 : : }
8499 : :
8500 : : static void
8501 : 0 : zxdh_np_hash_func_bulk_set(ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init,
8502 : : ZXDH_NP_SE_HASH_FUNC_BULK_T *p_func_bulk)
8503 : : {
8504 : : uint32_t index = 0;
8505 : : ZXDH_APT_HASH_FUNC_RES_T *p_func_res = NULL;
8506 : : ZXDH_APT_HASH_BULK_RES_T *p_bulk_res = NULL;
8507 : :
8508 : 0 : p_hash_res_init->func_num = p_func_bulk->func_num;
8509 : 0 : p_hash_res_init->bulk_num = p_func_bulk->bulk_num;
8510 [ # # ]: 0 : for (index = 0; index < (p_hash_res_init->func_num); index++) {
8511 : 0 : p_func_res = p_hash_res_init->func_res + index;
8512 : :
8513 : 0 : p_func_res->func_id = p_func_bulk->fun[index].func_id;
8514 : 0 : p_func_res->ddr_dis = p_func_bulk->fun[index].ddr_dis;
8515 : 0 : p_func_res->zblk_num = p_func_bulk->fun[index].zblk_num;
8516 : 0 : p_func_res->zblk_bitmap = p_func_bulk->fun[index].zblk_bitmap;
8517 : : }
8518 : :
8519 [ # # ]: 0 : for (index = 0; index < (p_hash_res_init->bulk_num); index++) {
8520 : 0 : p_bulk_res = p_hash_res_init->bulk_res + index;
8521 : :
8522 : 0 : p_bulk_res->func_id = p_func_bulk->bulk[index].func_id;
8523 : 0 : p_bulk_res->bulk_id = p_func_bulk->bulk[index].bulk_id;
8524 : 0 : p_bulk_res->zcell_num = p_func_bulk->bulk[index].zcell_num;
8525 : 0 : p_bulk_res->zreg_num = p_func_bulk->bulk[index].zreg_num;
8526 : 0 : p_bulk_res->ddr_baddr = p_func_bulk->bulk[index].ddr_baddr;
8527 : 0 : p_bulk_res->ddr_item_num = p_func_bulk->bulk[index].ddr_item_num;
8528 : 0 : p_bulk_res->ddr_width_mode = p_func_bulk->bulk[index].ddr_width_mode;
8529 : 0 : p_bulk_res->ddr_crc_sel = p_func_bulk->bulk[index].ddr_crc_sel;
8530 : 0 : p_bulk_res->ddr_ecc_en = p_func_bulk->bulk[index].ddr_ecc_en;
8531 : : }
8532 : 0 : }
8533 : :
8534 : : static void
8535 : 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)
8536 : : {
8537 : : uint32_t index = 0;
8538 : : ZXDH_APT_HASH_TABLE_T *p_tbl_res = NULL;
8539 : :
8540 : 0 : p_hash_res_init->tbl_num = p_hash_tbl->tbl_num;
8541 [ # # ]: 0 : for (index = 0; index < (p_hash_res_init->tbl_num); index++) {
8542 : 0 : p_tbl_res = p_hash_res_init->tbl_res + index;
8543 : :
8544 : 0 : p_tbl_res->sdt_no = p_hash_tbl->table[index].sdt_no;
8545 : 0 : p_tbl_res->sdt_partner = p_hash_tbl->table[index].sdt_partner;
8546 : 0 : p_tbl_res->tbl_flag = p_hash_tbl->table[index].tbl_flag;
8547 : 0 : p_tbl_res->hash_sdt.table_type =
8548 : 0 : p_hash_tbl->table[index].hash_sdt.table_type;
8549 : 0 : p_tbl_res->hash_sdt.hash_id = p_hash_tbl->table[index].hash_sdt.hash_id;
8550 : 0 : p_tbl_res->hash_sdt.hash_table_width =
8551 : 0 : p_hash_tbl->table[index].hash_sdt.hash_table_width;
8552 : 0 : p_tbl_res->hash_sdt.key_size = p_hash_tbl->table[index].hash_sdt.key_size;
8553 : 0 : p_tbl_res->hash_sdt.hash_table_id =
8554 : 0 : p_hash_tbl->table[index].hash_sdt.hash_table_id;
8555 : 0 : p_tbl_res->hash_sdt.learn_en = p_hash_tbl->table[index].hash_sdt.learn_en;
8556 : 0 : p_tbl_res->hash_sdt.keep_alive =
8557 : 0 : p_hash_tbl->table[index].hash_sdt.keep_alive;
8558 : 0 : p_tbl_res->hash_sdt.keep_alive_baddr =
8559 : 0 : p_hash_tbl->table[index].hash_sdt.keep_alive_baddr;
8560 : 0 : p_tbl_res->hash_sdt.rsp_mode =
8561 : 0 : p_hash_tbl->table[index].hash_sdt.rsp_mode;
8562 : 0 : p_tbl_res->hash_sdt.hash_clutch_en =
8563 : 0 : p_hash_tbl->table[index].hash_sdt.hash_clutch_en;
8564 : : }
8565 : 0 : }
8566 : :
8567 : : static void
8568 : 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)
8569 : : {
8570 : : uint32_t index = 0;
8571 : : ZXDH_APT_ERAM_TABLE_T *p_eram_res = NULL;
8572 : :
8573 : 0 : p_eam_res_init->tbl_num = p_eram_tbl->tbl_num;
8574 [ # # ]: 0 : for (index = 0; index < (p_eam_res_init->tbl_num); index++) {
8575 : 0 : p_eram_res = p_eam_res_init->eram_res + index;
8576 : :
8577 : 0 : p_eram_res->sdt_no = p_eram_tbl->eram[index].sdt_no;
8578 : 0 : p_eram_res->opr_mode = p_eram_tbl->eram[index].opr_mode;
8579 : 0 : p_eram_res->rd_mode = p_eram_tbl->eram[index].rd_mode;
8580 : 0 : p_eram_res->eram_sdt.table_type = p_eram_tbl->eram[index].eram_sdt.table_type;
8581 : 0 : p_eram_res->eram_sdt.eram_mode = p_eram_tbl->eram[index].eram_sdt.eram_mode;
8582 : 0 : p_eram_res->eram_sdt.eram_base_addr =
8583 : 0 : p_eram_tbl->eram[index].eram_sdt.eram_base_addr;
8584 : 0 : p_eram_res->eram_sdt.eram_table_depth =
8585 : 0 : p_eram_tbl->eram[index].eram_sdt.eram_table_depth;
8586 : 0 : p_eram_res->eram_sdt.eram_clutch_en =
8587 : 0 : p_eram_tbl->eram[index].eram_sdt.eram_clutch_en;
8588 : : }
8589 : 0 : }
8590 : :
8591 : : static void
8592 : 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)
8593 : : {
8594 : : uint32_t index = 0;
8595 : : ZXDH_APT_ACL_TABLE_T *p_acl_res = NULL;
8596 : :
8597 : 0 : p_acl_res_init->tbl_num = p_acl_tbl->tbl_num;
8598 [ # # ]: 0 : for (index = 0; index < (p_acl_tbl->tbl_num); index++) {
8599 : 0 : p_acl_res = p_acl_res_init->acl_res + index;
8600 : :
8601 : 0 : p_acl_res->sdt_no = p_acl_tbl->acl[index].sdt_no;
8602 : 0 : p_acl_res->sdt_partner = p_acl_tbl->acl[index].sdt_partner;
8603 : 0 : p_acl_res->acl_res.block_num = p_acl_tbl->acl[index].acl_res.block_num;
8604 : 0 : p_acl_res->acl_res.entry_num = p_acl_tbl->acl[index].acl_res.entry_num;
8605 : 0 : p_acl_res->acl_res.pri_mode = p_acl_tbl->acl[index].acl_res.pri_mode;
8606 : 0 : memcpy(p_acl_res->acl_res.block_index,
8607 : 0 : p_acl_tbl->acl[index].acl_res.block_index,
8608 : : sizeof(uint32_t) * ZXDH_ETCAM_BLOCK_NUM);
8609 : 0 : p_acl_res->acl_sdt.table_type = p_acl_tbl->acl[index].acl_sdt.table_type;
8610 : 0 : p_acl_res->acl_sdt.etcam_id = p_acl_tbl->acl[index].acl_sdt.etcam_id;
8611 : 0 : p_acl_res->acl_sdt.etcam_key_mode = p_acl_tbl->acl[index].acl_sdt.etcam_key_mode;
8612 : 0 : p_acl_res->acl_sdt.etcam_table_id = p_acl_tbl->acl[index].acl_sdt.etcam_table_id;
8613 : 0 : p_acl_res->acl_sdt.no_as_rsp_mode = p_acl_tbl->acl[index].acl_sdt.no_as_rsp_mode;
8614 : 0 : p_acl_res->acl_sdt.as_en = p_acl_tbl->acl[index].acl_sdt.as_en;
8615 : 0 : p_acl_res->acl_sdt.as_eram_baddr = p_acl_tbl->acl[index].acl_sdt.as_eram_baddr;
8616 : 0 : p_acl_res->acl_sdt.as_rsp_mode = p_acl_tbl->acl[index].acl_sdt.as_rsp_mode;
8617 : 0 : p_acl_res->acl_sdt.etcam_table_depth =
8618 : 0 : p_acl_tbl->acl[index].acl_sdt.etcam_table_depth;
8619 : 0 : p_acl_res->acl_sdt.etcam_clutch_en = p_acl_tbl->acl[index].acl_sdt.etcam_clutch_en;
8620 : : }
8621 : 0 : }
8622 : :
8623 : : static void
8624 : : zxdh_np_stat_cfg_set(ZXDH_APT_STAT_RES_INIT_T *p_stat_res_init, ZXDH_NP_SE_STAT_CFG_T *p_stat_cfg)
8625 : : {
8626 : 0 : p_stat_res_init->eram_baddr = p_stat_cfg->eram_baddr;
8627 : 0 : p_stat_res_init->eram_depth = p_stat_cfg->eram_depth;
8628 : 0 : p_stat_res_init->ddr_baddr = p_stat_cfg->ddr_baddr;
8629 : 0 : p_stat_res_init->ppu_ddr_offset = p_stat_cfg->ppu_ddr_offset;
8630 : : }
8631 : :
8632 : : static uint32_t
8633 : 0 : zxdh_np_agent_hash_func_bulk_get(uint32_t dev_id, uint32_t type,
8634 : : ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init)
8635 : : {
8636 : : uint32_t rc = ZXDH_OK;
8637 : : uint32_t opr = ZXDH_HASH_FUNC_BULK_REQ;
8638 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8639 : : uint32_t buff_size = 0;
8640 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8641 : : uint32_t *p_rsp_buff = NULL;
8642 : : ZXDH_NP_SE_HASH_FUNC_BULK_T *p_func_bulk = NULL;
8643 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8644 : :
8645 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8646 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8647 : :
8648 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8649 : :
8650 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8651 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8652 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8653 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8654 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8655 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8656 : : }
8657 : :
8658 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ? ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8659 : :
8660 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8661 [ # # ]: 0 : if (rc != ZXDH_OK) {
8662 : 0 : rte_free(p_rsp_buff);
8663 : 0 : PMD_DRV_LOG(ERR, "hash func&bulk res get fail rc=0x%x.", rc);
8664 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8665 : 0 : return ZXDH_ERR;
8666 : : }
8667 : :
8668 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8669 : :
8670 : 0 : p_func_bulk = (ZXDH_NP_SE_HASH_FUNC_BULK_T *)(p_rsp_buff + 1);
8671 : 0 : zxdh_np_hash_func_bulk_set(p_hash_res_init, p_func_bulk);
8672 : 0 : rte_free(p_rsp_buff);
8673 : :
8674 : 0 : return rc;
8675 : : }
8676 : :
8677 : : static uint32_t
8678 : 0 : zxdh_np_agent_hash_tbl_get(uint32_t dev_id,
8679 : : uint32_t type,
8680 : : ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init)
8681 : : {
8682 : : uint32_t rc = ZXDH_OK;
8683 : : uint32_t opr = ZXDH_HASH_TBL_REQ;
8684 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8685 : : uint32_t buff_size = 0;
8686 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8687 : : uint32_t *p_rsp_buff = NULL;
8688 : : ZXDH_NP_SE_HASH_TBL_T *p_hash_tbl = NULL;
8689 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8690 : :
8691 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8692 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8693 : :
8694 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8695 : :
8696 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8697 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8698 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8699 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8700 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8701 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8702 : : }
8703 : :
8704 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ?
8705 : 0 : ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8706 : :
8707 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8708 [ # # ]: 0 : if (rc != ZXDH_OK) {
8709 : 0 : rte_free(p_rsp_buff);
8710 : 0 : PMD_DRV_LOG(ERR, "hash table res get fail rc=0x%x.", rc);
8711 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8712 : 0 : return ZXDH_ERR;
8713 : : }
8714 : :
8715 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8716 : :
8717 : 0 : p_hash_tbl = (ZXDH_NP_SE_HASH_TBL_T *)(p_rsp_buff + 1);
8718 : 0 : zxdh_np_hash_tbl_set(p_hash_res_init, p_hash_tbl);
8719 : 0 : rte_free(p_rsp_buff);
8720 : :
8721 : 0 : return rc;
8722 : : }
8723 : :
8724 : : static uint32_t
8725 : 0 : zxdh_np_agent_eram_tbl_get(uint32_t dev_id, uint32_t type, ZXDH_APT_ERAM_RES_INIT_T *p_eam_res_init)
8726 : : {
8727 : : uint32_t rc = ZXDH_OK;
8728 : : uint32_t opr = ZXDH_ERAM_TBL_REQ;
8729 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8730 : : uint32_t buff_size = 0;
8731 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8732 : : uint32_t *p_rsp_buff = NULL;
8733 : : ZXDH_NP_SE_ERAM_TBL_T *p_eram_tbl = NULL;
8734 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8735 : :
8736 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8737 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8738 : :
8739 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8740 : :
8741 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8742 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8743 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8744 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8745 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8746 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8747 : : }
8748 : :
8749 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ?
8750 : 0 : ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8751 : :
8752 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8753 [ # # ]: 0 : if (rc != ZXDH_OK) {
8754 : 0 : rte_free(p_rsp_buff);
8755 : 0 : PMD_DRV_LOG(ERR, "eram table res get fail rc=0x%x.", rc);
8756 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8757 : 0 : return ZXDH_ERR;
8758 : : }
8759 : :
8760 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8761 : :
8762 : 0 : p_eram_tbl = (ZXDH_NP_SE_ERAM_TBL_T *)(p_rsp_buff + 1);
8763 : 0 : zxdh_np_eram_tbl_set(p_eam_res_init, p_eram_tbl);
8764 : 0 : rte_free(p_rsp_buff);
8765 : :
8766 : 0 : return rc;
8767 : : }
8768 : :
8769 : : static uint32_t
8770 : 0 : zxdh_np_agent_acl_tbl_get(uint32_t dev_id, uint32_t type, ZXDH_APT_ACL_RES_INIT_T *p_acl_res_init)
8771 : : {
8772 : : uint32_t rc = ZXDH_OK;
8773 : : uint32_t opr = ZXDH_ACL_TBL_REQ;
8774 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8775 : : uint32_t buff_size = 0;
8776 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8777 : : uint32_t *p_rsp_buff = NULL;
8778 : : ZXDH_NP_SE_ACL_TBL_T *p_acl_tbl = NULL;
8779 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8780 : :
8781 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8782 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8783 : :
8784 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8785 : :
8786 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8787 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8788 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8789 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8790 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8791 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8792 : : }
8793 : :
8794 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ?
8795 : 0 : ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8796 : :
8797 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8798 [ # # ]: 0 : if (rc != ZXDH_OK) {
8799 : 0 : rte_free(p_rsp_buff);
8800 : 0 : PMD_DRV_LOG(ERR, "acl table res get fail rc=0x%x.", rc);
8801 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8802 : 0 : return ZXDH_ERR;
8803 : : }
8804 : :
8805 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8806 : :
8807 : 0 : p_acl_tbl = (ZXDH_NP_SE_ACL_TBL_T *)(p_rsp_buff + 1);
8808 : 0 : zxdh_np_acl_tbl_set(p_acl_res_init, p_acl_tbl);
8809 : 0 : rte_free(p_rsp_buff);
8810 : :
8811 : 0 : return rc;
8812 : : }
8813 : :
8814 : : static uint32_t
8815 : 0 : zxdh_np_agent_stat_cfg_get(uint32_t dev_id,
8816 : : uint32_t type,
8817 : : ZXDH_APT_STAT_RES_INIT_T *p_stat_cfg_init)
8818 : : {
8819 : : uint32_t rc = ZXDH_OK;
8820 : : uint32_t opr = ZXDH_STAT_CFG_REQ;
8821 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8822 : : uint32_t buff_size = 0;
8823 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8824 : : uint32_t *p_rsp_buff = NULL;
8825 : : ZXDH_NP_SE_STAT_CFG_T *p_stat_cfg = NULL;
8826 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8827 : :
8828 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8829 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8830 : :
8831 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8832 : :
8833 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8834 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8835 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8836 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8837 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8838 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8839 : : }
8840 : :
8841 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ? ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8842 : :
8843 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8844 [ # # ]: 0 : if (rc != ZXDH_OK) {
8845 : 0 : rte_free(p_rsp_buff);
8846 : 0 : PMD_DRV_LOG(ERR, "ddr table res get fail rc = 0x%x.", rc);
8847 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8848 : 0 : return ZXDH_ERR;
8849 : : }
8850 : :
8851 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8852 : :
8853 : : p_stat_cfg = (ZXDH_NP_SE_STAT_CFG_T *)(p_rsp_buff + 1);
8854 : : zxdh_np_stat_cfg_set(p_stat_cfg_init, p_stat_cfg);
8855 : 0 : rte_free(p_rsp_buff);
8856 : :
8857 : 0 : return rc;
8858 : : }
8859 : :
8860 : : static void *
8861 : : zxdh_np_dev_get_se_res_ptr(uint32_t dev_id, uint32_t type)
8862 : : {
8863 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
8864 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[ZXDH_DEV_SLOT_ID(dev_id)];
8865 : :
8866 : 0 : if (type == ZXDH_SE_STD_NIC_RES_TYPE)
8867 : 0 : return (void *)&p_dev_info->dev_apt_se_tbl_res.std_nic_res;
8868 : : else
8869 : 0 : return (void *)&p_dev_info->dev_apt_se_tbl_res.offload_res;
8870 : : }
8871 : :
8872 : : static uint32_t
8873 : 0 : zxdh_np_agent_se_res_get(uint32_t dev_id, uint32_t type)
8874 : : {
8875 : : uint32_t rc = ZXDH_OK;
8876 : : ZXDH_APT_SE_RES_T *p_se_res = NULL;
8877 : 0 : ZXDH_APT_HASH_RES_INIT_T hash_res = {0};
8878 : 0 : ZXDH_APT_ERAM_RES_INIT_T eram_res = {0};
8879 [ # # ]: 0 : ZXDH_APT_ACL_RES_INIT_T acl_res = {0};
8880 : :
8881 : : p_se_res = (ZXDH_APT_SE_RES_T *)zxdh_np_dev_get_se_res_ptr(dev_id, type);
8882 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_res);
8883 : :
8884 [ # # ]: 0 : if (p_se_res->valid) {
8885 : 0 : PMD_DRV_LOG(INFO, "dev_id [0x%x] res_type [%u] status ready", dev_id, type);
8886 : 0 : return ZXDH_OK;
8887 : : }
8888 : :
8889 : 0 : hash_res.func_res = p_se_res->hash_func;
8890 : 0 : hash_res.bulk_res = p_se_res->hash_bulk;
8891 : 0 : hash_res.tbl_res = p_se_res->hash_tbl;
8892 : 0 : rc = zxdh_np_agent_hash_func_bulk_get(dev_id, type, &hash_res);
8893 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_hash_func_bulk_get");
8894 : :
8895 : 0 : rc = zxdh_np_agent_hash_tbl_get(dev_id, type, &hash_res);
8896 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_hash_tbl_get");
8897 : 0 : p_se_res->hash_func_num = hash_res.func_num;
8898 : 0 : p_se_res->hash_bulk_num = hash_res.bulk_num;
8899 : 0 : p_se_res->hash_tbl_num = hash_res.tbl_num;
8900 : :
8901 : 0 : eram_res.eram_res = p_se_res->eram_tbl;
8902 : 0 : rc = zxdh_np_agent_eram_tbl_get(dev_id, type, &eram_res);
8903 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_eram_tbl_get");
8904 : 0 : p_se_res->eram_num = eram_res.tbl_num;
8905 : :
8906 : 0 : acl_res.acl_res = p_se_res->acl_tbl;
8907 : 0 : rc = zxdh_np_agent_acl_tbl_get(dev_id, type, &acl_res);
8908 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_acl_tbl_get");
8909 : 0 : p_se_res->acl_num = acl_res.tbl_num;
8910 : :
8911 : 0 : rc = zxdh_np_agent_stat_cfg_get(dev_id, type, &p_se_res->stat_cfg);
8912 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_stat_cfg_get");
8913 : :
8914 : 0 : p_se_res->valid = 1;
8915 : 0 : return rc;
8916 : : }
8917 : :
8918 : : static uint32_t
8919 : 0 : zxdh_np_se_init_ex(uint32_t dev_id, ZXDH_SE_CFG *p_se_cfg)
8920 : : {
8921 : : uint32_t i = 0;
8922 : : uint32_t j = 0;
8923 : :
8924 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
8925 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
8926 : :
8927 [ # # ]: 0 : if (dpp_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] != NULL) {
8928 : 0 : PMD_DRV_LOG(DEBUG, "SE global config is already initialized.");
8929 : 0 : return ZXDH_OK;
8930 : : }
8931 : :
8932 : : memset(p_se_cfg, 0, sizeof(ZXDH_SE_CFG));
8933 : :
8934 : 0 : p_se_cfg->dev_id = dev_id;
8935 : 0 : dpp_se_cfg[ZXDH_DEV_SLOT_ID(p_se_cfg->dev_id)] = p_se_cfg;
8936 : :
8937 : : p_se_cfg->p_as_rslt_wrt_fun = NULL;
8938 : 0 : p_se_cfg->p_client = ZXDH_COMM_VAL_TO_PTR(dev_id);
8939 : :
8940 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZBLK_NUM; i++) {
8941 : 0 : p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_se_cfg, i);
8942 : :
8943 : 0 : p_zblk_cfg->zblk_idx = i;
8944 : 0 : p_zblk_cfg->is_used = 0;
8945 : 0 : p_zblk_cfg->hash_arg = g_lpm_crc[i];
8946 : 0 : p_zblk_cfg->zcell_bm = 0;
8947 : : zxdh_np_init_d_node(&p_zblk_cfg->zblk_dn, p_zblk_cfg);
8948 : :
8949 [ # # ]: 0 : for (j = 0; j < ZXDH_SE_ZCELL_NUM; j++) {
8950 : 0 : p_zcell_cfg = &p_zblk_cfg->zcell_info[j];
8951 : :
8952 : 0 : p_zcell_cfg->zcell_idx = (i << 2) + j;
8953 : 0 : p_zcell_cfg->item_used = 0;
8954 : 0 : p_zcell_cfg->mask_len = 0;
8955 : :
8956 : : zxdh_np_init_d_node(&p_zcell_cfg->zcell_dn, p_zcell_cfg);
8957 : :
8958 : 0 : p_zcell_cfg->zcell_avl.p_key = p_zcell_cfg;
8959 : : }
8960 : : }
8961 : :
8962 : : return ZXDH_OK;
8963 : : }
8964 : :
8965 : : static uint32_t
8966 : 0 : zxdh_np_apt_hash_global_res_init(uint32_t dev_id)
8967 : : {
8968 [ # # ]: 0 : if (g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] == NULL) {
8969 : 0 : g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] = rte_zmalloc(NULL, sizeof(ZXDH_SE_CFG), 0);
8970 [ # # ]: 0 : if (g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)] == NULL) {
8971 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8972 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8973 : : }
8974 : :
8975 : 0 : zxdh_np_se_init_ex(dev_id, g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)]);
8976 : :
8977 : 0 : g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)]->p_client = ZXDH_COMM_VAL_TO_PTR(dev_id);
8978 : : }
8979 : :
8980 : : return ZXDH_OK;
8981 : : }
8982 : :
8983 : : static void
8984 : : se_apt_get_zblock_index(uint32_t zblock_bitmap, uint32_t *zblk_idx)
8985 : : {
8986 : : uint32_t index0 = 0;
8987 : : uint32_t index1 = 0;
8988 : :
8989 [ # # ]: 0 : for (index0 = 0; index0 < 32; index0++) {
8990 [ # # ]: 0 : if ((zblock_bitmap >> index0) & 0x1) {
8991 : 0 : *(zblk_idx + index1) = index0;
8992 : 0 : index1++;
8993 : : }
8994 : : }
8995 : : }
8996 : :
8997 : : static uint32_t
8998 : 0 : zxdh_np_crc32_calc(uint8_t *p_input_key, uint32_t dw_byte_num, uint32_t dw_crc_poly)
8999 : : {
9000 : : uint32_t dw_result = 0;
9001 : : uint32_t dw_data_type = 0;
9002 : :
9003 : : uint32_t i = 0;
9004 : : uint32_t j = 0;
9005 : :
9006 [ # # ]: 0 : while (i < dw_byte_num) {
9007 : 0 : dw_data_type = (uint32_t)((dw_result & 0xff000000) ^ (p_input_key[i] << 24));
9008 [ # # ]: 0 : for (j = 0; j < 8; j++) {
9009 [ # # ]: 0 : if (dw_data_type & 0x80000000) {
9010 : 0 : dw_data_type <<= 1;
9011 : 0 : dw_data_type ^= dw_crc_poly;
9012 : : } else {
9013 : 0 : dw_data_type <<= 1;
9014 : : }
9015 : : }
9016 : 0 : dw_result <<= 8;
9017 : 0 : dw_result ^= dw_data_type;
9018 : :
9019 : 0 : i++;
9020 : : }
9021 : :
9022 : 0 : return dw_result;
9023 : : }
9024 : :
9025 : : static uint16_t
9026 : 0 : zxdh_np_crc16_calc(uint8_t *p_input_key, uint32_t dw_byte_num, uint16_t dw_crc_poly)
9027 : : {
9028 : : uint16_t dw_result = 0;
9029 : : uint16_t dw_data_type = 0;
9030 : :
9031 : : uint32_t i = 0;
9032 : : uint32_t j = 0;
9033 : :
9034 [ # # ]: 0 : while (i < dw_byte_num) {
9035 : 0 : dw_data_type = (uint16_t)(((dw_result & 0xff00) ^ (p_input_key[i] << 8)) & 0xFFFF);
9036 [ # # ]: 0 : for (j = 0; j < 8; j++) {
9037 [ # # ]: 0 : if (dw_data_type & 0x8000) {
9038 : 0 : dw_data_type <<= 1;
9039 : 0 : dw_data_type ^= dw_crc_poly;
9040 : : } else {
9041 : 0 : dw_data_type <<= 1;
9042 : : }
9043 : : }
9044 : 0 : dw_result <<= 8;
9045 : 0 : dw_result ^= dw_data_type;
9046 : :
9047 : 0 : i++;
9048 : : }
9049 : :
9050 : 0 : return dw_result;
9051 : : }
9052 : :
9053 : : static uint32_t
9054 : 0 : zxdh_np_se_fun_init(ZXDH_SE_CFG *p_se_cfg,
9055 : : uint8_t id,
9056 : : uint32_t fun_type)
9057 : : {
9058 : : ZXDH_FUNC_ID_INFO *p_fun_info = NULL;
9059 : :
9060 : 0 : p_fun_info = ZXDH_GET_FUN_INFO(p_se_cfg, id);
9061 : :
9062 [ # # ]: 0 : if (p_fun_info->is_used) {
9063 : 0 : PMD_DRV_LOG(ERR, "Error[0x%x], fun_id [%u] is already used!",
9064 : : ZXDH_SE_RC_FUN_INVALID, id);
9065 : 0 : return ZXDH_SE_RC_FUN_INVALID;
9066 : : }
9067 : :
9068 : 0 : p_fun_info->fun_id = id;
9069 : 0 : p_fun_info->is_used = 1;
9070 : :
9071 [ # # ]: 0 : switch (fun_type) {
9072 : 0 : case (ZXDH_FUN_HASH):
9073 : 0 : p_fun_info->fun_type = ZXDH_FUN_HASH;
9074 : 0 : p_fun_info->fun_ptr = rte_zmalloc(NULL, sizeof(ZXDH_HASH_CFG), 0);
9075 [ # # ]: 0 : if (p_fun_info->fun_ptr == NULL) {
9076 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9077 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9078 : : }
9079 : 0 : ((ZXDH_HASH_CFG *)(p_fun_info->fun_ptr))->p_se_info = p_se_cfg;
9080 : : break;
9081 : 0 : default:
9082 : 0 : PMD_DRV_LOG(ERR, "Error, unrecgnized fun_type[ %u]", fun_type);
9083 : : RTE_ASSERT(0);
9084 : 0 : return ZXDH_SE_RC_BASE;
9085 : : }
9086 : :
9087 : 0 : return ZXDH_OK;
9088 : : }
9089 : :
9090 : : static int32_t
9091 : 0 : zxdh_np_hash_list_cmp(ZXDH_D_NODE *data1, ZXDH_D_NODE *data2, void *data)
9092 : : {
9093 : : uint32_t flag = 0;
9094 : : uint32_t data_new = 0;
9095 : : uint32_t data_pre = 0;
9096 : :
9097 : 0 : flag = *(uint32_t *)data;
9098 : :
9099 [ # # ]: 0 : if (flag == ZXDH_HASH_CMP_ZCELL) {
9100 : 0 : data_new = ((ZXDH_SE_ZCELL_CFG *)data1->data)->zcell_idx;
9101 : 0 : data_pre = ((ZXDH_SE_ZCELL_CFG *)data2->data)->zcell_idx;
9102 [ # # ]: 0 : } else if (flag == ZXDH_HASH_CMP_ZBLK) {
9103 : 0 : data_new = ((ZXDH_SE_ZBLK_CFG *)data1->data)->zblk_idx;
9104 : 0 : data_pre = ((ZXDH_SE_ZBLK_CFG *)data2->data)->zblk_idx;
9105 : : }
9106 : :
9107 [ # # ]: 0 : if (data_new > data_pre)
9108 : : return 1;
9109 [ # # ]: 0 : else if (data_new == data_pre)
9110 : : return 0;
9111 : : else
9112 : 0 : return -1;
9113 : : }
9114 : :
9115 : : static int32_t
9116 : 0 : zxdh_np_hash_rb_key_cmp(void *p_new, void *p_old, __rte_unused uint32_t key_size)
9117 : : {
9118 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_new = NULL;
9119 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_old = NULL;
9120 : :
9121 : : p_rbkey_new = (ZXDH_HASH_RBKEY_INFO *)(p_new);
9122 : : p_rbkey_old = (ZXDH_HASH_RBKEY_INFO *)(p_old);
9123 : :
9124 : 0 : return memcmp(p_rbkey_new->key, p_rbkey_old->key, ZXDH_HASH_KEY_MAX);
9125 : : }
9126 : :
9127 : : static int32_t
9128 : 0 : zxdh_np_hash_ddr_cfg_rb_key_cmp(void *p_new, void *p_old, __rte_unused uint32_t key_size)
9129 : : {
9130 : : HASH_DDR_CFG *p_rbkey_new = NULL;
9131 : : HASH_DDR_CFG *p_rbkey_old = NULL;
9132 : :
9133 : : p_rbkey_new = (HASH_DDR_CFG *)(p_new);
9134 : : p_rbkey_old = (HASH_DDR_CFG *)(p_old);
9135 : :
9136 : 0 : return memcmp(&p_rbkey_new->ddr_baddr, &p_rbkey_old->ddr_baddr, sizeof(uint32_t));
9137 : : }
9138 : :
9139 : : static uint32_t
9140 : 0 : zxdh_np_hash_zcam_resource_init(ZXDH_HASH_CFG *p_hash_cfg,
9141 : : uint32_t zblk_num, uint32_t *zblk_idx_array)
9142 : : {
9143 : : uint32_t rc = ZXDH_OK;
9144 : :
9145 : : uint32_t i = 0;
9146 : : uint32_t j = 0;
9147 : 0 : uint32_t cmp_type = 0;
9148 : : uint32_t zblk_idx = 0;
9149 : : uint32_t zcell_idx = 0;
9150 : : uint32_t dev_id = 0;
9151 : :
9152 : : ZXDH_D_HEAD *p_zblk_list = NULL;
9153 : : ZXDH_D_HEAD *p_zcell_free = NULL;
9154 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
9155 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
9156 : :
9157 : 0 : dev_id = p_hash_cfg->p_se_info->dev_id;
9158 : :
9159 : 0 : p_zblk_list = &p_hash_cfg->hash_shareram.zblk_list;
9160 : : rc = zxdh_comm_double_link_init(ZXDH_SE_ZBLK_NUM, p_zblk_list);
9161 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
9162 : :
9163 : 0 : p_zcell_free = &p_hash_cfg->hash_shareram.zcell_free_list;
9164 : : rc = zxdh_comm_double_link_init(ZXDH_SE_ZBLK_NUM * ZXDH_SE_ZCELL_NUM, p_zcell_free);
9165 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
9166 : :
9167 [ # # ]: 0 : for (i = 0; i < zblk_num; i++) {
9168 : 0 : zblk_idx = zblk_idx_array[i];
9169 : :
9170 : 0 : p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_hash_cfg->p_se_info, zblk_idx);
9171 : :
9172 [ # # ]: 0 : if (p_zblk_cfg->is_used) {
9173 : 0 : PMD_DRV_LOG(ERR, "ZBlock[%u] is already used", zblk_idx);
9174 : : RTE_ASSERT(0);
9175 : 0 : return ZXDH_HASH_RC_INVALID_ZBLCK;
9176 : : }
9177 : :
9178 [ # # ]: 0 : for (j = 0; j < ZXDH_SE_ZCELL_NUM; j++) {
9179 : 0 : zcell_idx = p_zblk_cfg->zcell_info[j].zcell_idx;
9180 : 0 : p_zcell_cfg = &(((ZXDH_SE_CFG *)(p_hash_cfg->p_se_info))->
9181 : 0 : zblk_info[GET_ZBLK_IDX(zcell_idx)].zcell_info[GET_ZCELL_IDX(zcell_idx)]);
9182 : :
9183 [ # # ]: 0 : if (p_zcell_cfg->is_used) {
9184 : 0 : PMD_DRV_LOG(ERR, "ZBlk[%u], ZCell[%u] is already used",
9185 : : zblk_idx, zcell_idx);
9186 : : RTE_ASSERT(0);
9187 : 0 : return ZXDH_HASH_RC_INVALID_ZCELL;
9188 : : }
9189 : :
9190 : 0 : p_zcell_cfg->is_used = 1;
9191 : :
9192 : 0 : cmp_type = ZXDH_HASH_CMP_ZCELL;
9193 : 0 : rc = zxdh_comm_double_link_insert_sort(&p_zcell_cfg->zcell_dn,
9194 : : p_zcell_free, zxdh_np_hash_list_cmp, &cmp_type);
9195 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_sort");
9196 : : }
9197 : :
9198 : 0 : p_zblk_cfg->is_used = 1;
9199 : 0 : cmp_type = ZXDH_HASH_CMP_ZBLK;
9200 : 0 : rc = zxdh_comm_double_link_insert_sort(&p_zblk_cfg->zblk_dn,
9201 : : p_zblk_list, zxdh_np_hash_list_cmp, &cmp_type);
9202 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_last");
9203 : : }
9204 : :
9205 : : return rc;
9206 : : }
9207 : :
9208 : : static uint32_t
9209 : 0 : zxdh_np_hash_init(ZXDH_SE_CFG *p_se_cfg,
9210 : : uint32_t fun_id,
9211 : : uint32_t zblk_num,
9212 : : uint32_t *zblk_idx,
9213 : : uint32_t ddr_dis)
9214 : : {
9215 : : uint32_t rc = ZXDH_OK;
9216 : : uint32_t i = 0;
9217 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
9218 : : ZXDH_FUNC_ID_INFO *p_func_info = NULL;
9219 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
9220 : :
9221 : 0 : rc = zxdh_np_se_fun_init(p_se_cfg, (fun_id & 0xff), ZXDH_FUN_HASH);
9222 [ # # ]: 0 : if (rc == ZXDH_SE_RC_FUN_INVALID)
9223 : : return ZXDH_OK;
9224 : :
9225 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_fun_init");
9226 : :
9227 : : p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, fun_id);
9228 : 0 : p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
9229 : 0 : p_hash_cfg->fun_id = fun_id;
9230 : 0 : p_hash_cfg->p_hash32_fun = zxdh_np_crc32_calc;
9231 : 0 : p_hash_cfg->p_hash16_fun = zxdh_np_crc16_calc;
9232 : 0 : p_hash_cfg->p_se_info = p_se_cfg;
9233 : :
9234 [ # # ]: 0 : if (ddr_dis == 1)
9235 : 0 : p_hash_cfg->ddr_valid = 0;
9236 : : else
9237 : 0 : p_hash_cfg->ddr_valid = 1;
9238 : :
9239 : 0 : p_hash_cfg->hash_stat.zblock_num = zblk_num;
9240 : 0 : rc = zxdh_np_hash_zcam_resource_init(p_hash_cfg, zblk_num, zblk_idx);
9241 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_zcam_resource_init");
9242 : :
9243 [ # # ]: 0 : for (i = 0; i < zblk_num; i++)
9244 : 0 : p_hash_cfg->hash_stat.zblock_array[i] = zblk_idx[i];
9245 : :
9246 : 0 : rc = (uint32_t)zxdh_comm_rb_init(&p_hash_cfg->hash_rb,
9247 : : 0,
9248 : : sizeof(ZXDH_HASH_RBKEY_INFO),
9249 : : zxdh_np_hash_rb_key_cmp);
9250 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
9251 : :
9252 : 0 : rc = (uint32_t)zxdh_comm_rb_init(&p_hash_cfg->ddr_cfg_rb,
9253 : : 0,
9254 : : sizeof(HASH_DDR_CFG),
9255 : : zxdh_np_hash_ddr_cfg_rb_key_cmp);
9256 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
9257 : :
9258 [ # # ]: 0 : for (i = 0; i < zblk_num; i++)
9259 : 0 : g_hash_zblk_idx[ZXDH_DEV_SLOT_ID(dev_id)][fun_id][i] = zblk_idx[i];
9260 : :
9261 : : return rc;
9262 : : }
9263 : :
9264 : : static uint32_t
9265 : 0 : zxdh_np_apt_hash_func_res_init(uint32_t dev_id, uint32_t func_num,
9266 : : ZXDH_APT_HASH_FUNC_RES_T *p_hash_func_res)
9267 : : {
9268 : : uint32_t rc = ZXDH_OK;
9269 : : uint32_t index = 0;
9270 : : uint32_t zblk_idx[32] = {0};
9271 : : ZXDH_APT_HASH_FUNC_RES_T *p_hash_func_res_temp = NULL;
9272 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9273 : :
9274 : 0 : p_se_cfg = g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
9275 : :
9276 [ # # ]: 0 : for (index = 0; index < func_num; index++) {
9277 : : memset(zblk_idx, 0, sizeof(zblk_idx));
9278 : 0 : p_hash_func_res_temp = p_hash_func_res + index;
9279 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_func_res_temp);
9280 : :
9281 : 0 : se_apt_get_zblock_index(p_hash_func_res_temp->zblk_bitmap, zblk_idx);
9282 : :
9283 : 0 : rc = zxdh_np_hash_init(p_se_cfg,
9284 : : p_hash_func_res_temp->func_id,
9285 : : p_hash_func_res_temp->zblk_num,
9286 : : zblk_idx,
9287 : : p_hash_func_res_temp->ddr_dis);
9288 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_init");
9289 : : }
9290 : :
9291 : 0 : return rc;
9292 : : }
9293 : :
9294 : : static uint32_t
9295 : 0 : zxdh_np_hash_bulk_init(ZXDH_SE_CFG *p_se_cfg,
9296 : : uint32_t fun_id,
9297 : : uint32_t bulk_id,
9298 : : ZXDH_HASH_DDR_RESC_CFG_T *p_ddr_resc_cfg,
9299 : : uint32_t zcell_num,
9300 : : uint32_t zreg_num)
9301 : : {
9302 : : uint32_t rc = ZXDH_OK;
9303 : :
9304 : : uint32_t i = 0;
9305 : : uint32_t j = 0;
9306 : : uint32_t zblk_idx = 0;
9307 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
9308 : : uint32_t ddr_item_num = 0;
9309 : :
9310 : : ZXDH_D_NODE *p_zblk_dn = NULL;
9311 : : ZXDH_D_NODE *p_zcell_dn = NULL;
9312 : : ZXDH_RB_TN *p_rb_tn_new = NULL;
9313 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
9314 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
9315 : : ZXDH_SE_ZREG_CFG *p_zreg_cfg = NULL;
9316 : : HASH_DDR_CFG *p_ddr_cfg = NULL;
9317 : : HASH_DDR_CFG *p_rbkey_new = NULL;
9318 : : HASH_DDR_CFG *p_rbkey_rtn = NULL;
9319 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
9320 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
9321 : : ZXDH_FUNC_ID_INFO *p_func_info = NULL;
9322 : : ZXDH_SE_ITEM_CFG **p_item_array = NULL;
9323 : : ZXDH_HASH_BULK_ZCAM_STAT *p_bulk_zcam_mono = NULL;
9324 : :
9325 : : p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, fun_id);
9326 : 0 : p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
9327 [ # # ]: 0 : if (p_hash_cfg == NULL) {
9328 : 0 : PMD_DRV_LOG(ERR, "p_hash_cfg point null!");
9329 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9330 : : }
9331 : :
9332 [ # # ]: 0 : if (p_hash_cfg->hash_stat.p_bulk_zcam_mono[bulk_id] != NULL) {
9333 : 0 : PMD_DRV_LOG(ERR, "fun_id[%u] bulk_id[%u] is already init", fun_id, bulk_id);
9334 : 0 : return ZXDH_OK;
9335 : : }
9336 : :
9337 : 0 : PMD_DRV_LOG(DEBUG, "p_hash_cfg->ddr_valid = %u!", p_hash_cfg->ddr_valid);
9338 [ # # ]: 0 : if (p_hash_cfg->ddr_valid == 1) {
9339 : 0 : ddr_item_num = p_ddr_resc_cfg->ddr_item_num;
9340 [ # # ]: 0 : if (ZXDH_DDR_WIDTH_512b == p_ddr_resc_cfg->ddr_width_mode)
9341 : 0 : ddr_item_num = p_ddr_resc_cfg->ddr_item_num >> 1;
9342 : :
9343 : 0 : p_rbkey_new = rte_zmalloc(NULL, sizeof(HASH_DDR_CFG), 0);
9344 [ # # ]: 0 : if (p_rbkey_new == NULL) {
9345 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9346 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9347 : : }
9348 : :
9349 : 0 : p_rbkey_new->ddr_baddr = p_ddr_resc_cfg->ddr_baddr;
9350 : :
9351 : 0 : p_rb_tn_new = rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
9352 [ # # ]: 0 : if (p_rb_tn_new == NULL) {
9353 : 0 : rte_free(p_rbkey_new);
9354 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9355 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9356 : : }
9357 : : zxdh_np_init_rbt_tn(p_rb_tn_new, p_rbkey_new);
9358 : :
9359 : 0 : rc = zxdh_comm_rb_insert(&p_hash_cfg->ddr_cfg_rb,
9360 : : (void *)p_rb_tn_new, (void *)(&p_rb_tn_rtn));
9361 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_FULL) {
9362 : 0 : PMD_DRV_LOG(ERR, "The red black tree is full!");
9363 : 0 : rte_free(p_rbkey_new);
9364 : 0 : rte_free(p_rb_tn_new);
9365 : : RTE_ASSERT(0);
9366 : 0 : return ZXDH_HASH_RC_RB_TREE_FULL;
9367 [ # # ]: 0 : } else if (rc == ZXDH_RBT_RC_UPDATE) {
9368 : 0 : PMD_DRV_LOG(DEBUG, "some bulk_id share one bulk!");
9369 : :
9370 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
9371 : 0 : p_rbkey_rtn = (HASH_DDR_CFG *)(p_rb_tn_rtn->p_key);
9372 : :
9373 : 0 : p_ddr_cfg = p_hash_cfg->p_bulk_ddr_info[p_rbkey_rtn->bulk_id];
9374 : :
9375 : 0 : if (p_ddr_cfg->hash_ddr_arg !=
9376 [ # # ]: 0 : GET_DDR_HASH_ARG(p_ddr_resc_cfg->ddr_crc_sel) ||
9377 [ # # ]: 0 : p_ddr_cfg->width_mode != p_ddr_resc_cfg->ddr_width_mode ||
9378 [ # # ]: 0 : p_ddr_cfg->ddr_ecc_en != p_ddr_resc_cfg->ddr_ecc_en ||
9379 [ # # ]: 0 : p_ddr_cfg->item_num != ddr_item_num) {
9380 : 0 : PMD_DRV_LOG(ERR, "The base address is same");
9381 : 0 : rte_free(p_rbkey_new);
9382 : 0 : rte_free(p_rb_tn_new);
9383 : : RTE_ASSERT(0);
9384 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9385 : : }
9386 : :
9387 : 0 : p_hash_cfg->p_bulk_ddr_info[bulk_id] =
9388 : : p_hash_cfg->p_bulk_ddr_info[p_rbkey_rtn->bulk_id];
9389 : :
9390 : 0 : rte_free(p_rbkey_new);
9391 : 0 : rte_free(p_rb_tn_new);
9392 : : } else {
9393 : 0 : p_item_array = rte_zmalloc(NULL, ddr_item_num *
9394 : : sizeof(ZXDH_SE_ITEM_CFG *), 0);
9395 [ # # ]: 0 : if (NULL == (p_item_array)) {
9396 : 0 : rte_free(p_rbkey_new);
9397 : 0 : rte_free(p_rb_tn_new);
9398 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9399 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9400 : : }
9401 : :
9402 : 0 : p_rbkey_new->p_item_array = p_item_array;
9403 : 0 : p_rbkey_new->bulk_id = bulk_id;
9404 : 0 : p_rbkey_new->hw_baddr = 0;
9405 : 0 : p_rbkey_new->width_mode = p_ddr_resc_cfg->ddr_width_mode;
9406 : 0 : p_rbkey_new->item_num = ddr_item_num;
9407 : 0 : p_rbkey_new->ddr_ecc_en = p_ddr_resc_cfg->ddr_ecc_en;
9408 : 0 : p_rbkey_new->hash_ddr_arg = GET_DDR_HASH_ARG(p_ddr_resc_cfg->ddr_crc_sel);
9409 : 0 : p_rbkey_new->bulk_use = 1;
9410 : 0 : p_rbkey_new->zcell_num = zcell_num;
9411 : 0 : p_rbkey_new->zreg_num = zreg_num;
9412 : 0 : p_hash_cfg->p_bulk_ddr_info[bulk_id] = p_rbkey_new;
9413 : :
9414 : 0 : PMD_DRV_LOG(DEBUG, "one new ddr_bulk init!");
9415 : : }
9416 : : }
9417 : :
9418 : 0 : p_bulk_zcam_mono = rte_zmalloc(NULL, sizeof(ZXDH_HASH_BULK_ZCAM_STAT), 0);
9419 [ # # ]: 0 : if (NULL == (p_bulk_zcam_mono)) {
9420 : 0 : rte_free(p_rbkey_new);
9421 : 0 : rte_free(p_rb_tn_new);
9422 : 0 : rte_free(p_item_array);
9423 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9424 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9425 : : }
9426 : 0 : (&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[bulk_id] = p_bulk_zcam_mono;
9427 : :
9428 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZBLK_NUM * ZXDH_SE_ZCELL_NUM; i++)
9429 : 0 : p_bulk_zcam_mono->zcell_mono_idx[i] = 0xffffffff;
9430 : :
9431 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZBLK_NUM; i++) {
9432 [ # # ]: 0 : for (j = 0; j < ZXDH_SE_ZREG_NUM; j++) {
9433 : 0 : p_bulk_zcam_mono->zreg_mono_id[i][j].zblk_id = 0xffffffff;
9434 : 0 : p_bulk_zcam_mono->zreg_mono_id[i][j].zreg_id = 0xffffffff;
9435 : : }
9436 : : }
9437 : :
9438 [ # # ]: 0 : if (zcell_num > 0) {
9439 : 0 : p_hash_cfg->bulk_ram_mono[bulk_id] = 1;
9440 : :
9441 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
9442 : :
9443 : : i = 0;
9444 : :
9445 [ # # ]: 0 : while (p_zcell_dn) {
9446 : 0 : p_zcell_cfg = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
9447 : :
9448 [ # # ]: 0 : if (p_zcell_cfg->is_used) {
9449 [ # # ]: 0 : if (!(p_zcell_cfg->flag & ZXDH_ZCELL_FLAG_IS_MONO)) {
9450 : 0 : p_zcell_cfg->flag |= ZXDH_ZCELL_FLAG_IS_MONO;
9451 : 0 : p_zcell_cfg->bulk_id = bulk_id;
9452 : :
9453 : 0 : p_bulk_zcam_mono->zcell_mono_idx[p_zcell_cfg->zcell_idx] =
9454 : : p_zcell_cfg->zcell_idx;
9455 : :
9456 [ # # ]: 0 : if (++i >= zcell_num)
9457 : : break;
9458 : : }
9459 : : } else {
9460 : 0 : PMD_DRV_LOG(ERR, "zcell[ %u ] is not init", p_zcell_cfg->zcell_idx);
9461 : : RTE_ASSERT(0);
9462 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9463 : : }
9464 : :
9465 : 0 : p_zcell_dn = p_zcell_dn->next;
9466 : : }
9467 : :
9468 [ # # ]: 0 : if (i < zcell_num)
9469 : 0 : PMD_DRV_LOG(ERR, "Input zcell_num is %u, bulk %u monopolize zcells is %u",
9470 : : zcell_num, bulk_id, i);
9471 : : }
9472 : :
9473 [ # # ]: 0 : if (zreg_num > 0) {
9474 : 0 : p_hash_cfg->bulk_ram_mono[bulk_id] = 1;
9475 : :
9476 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
9477 : : j = 0;
9478 : :
9479 [ # # ]: 0 : while (p_zblk_dn) {
9480 : 0 : p_zblk_cfg = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
9481 : 0 : zblk_idx = p_zblk_cfg->zblk_idx;
9482 : :
9483 [ # # ]: 0 : if (p_zblk_cfg->is_used) {
9484 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
9485 : : p_zreg_cfg = &p_zblk_cfg->zreg_info[i];
9486 : :
9487 [ # # ]: 0 : if (!(p_zreg_cfg->flag & ZXDH_ZREG_FLAG_IS_MONO)) {
9488 : 0 : p_zreg_cfg->flag = ZXDH_ZREG_FLAG_IS_MONO;
9489 : 0 : p_zreg_cfg->bulk_id = bulk_id;
9490 : :
9491 : 0 : p_bulk_zcam_mono->zreg_mono_id[zblk_idx][i].zblk_id =
9492 : : zblk_idx;
9493 : 0 : p_bulk_zcam_mono->zreg_mono_id[zblk_idx][i].zreg_id = i;
9494 : :
9495 [ # # ]: 0 : if (++j >= zreg_num)
9496 : : break;
9497 : : }
9498 : : }
9499 : :
9500 [ # # ]: 0 : if (j >= zreg_num)
9501 : : break;
9502 : : } else {
9503 : 0 : PMD_DRV_LOG(ERR, "zblk [ %u ] is not init", p_zblk_cfg->zblk_idx);
9504 : : RTE_ASSERT(0);
9505 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9506 : : }
9507 : :
9508 : 0 : p_zblk_dn = p_zblk_dn->next;
9509 : : }
9510 : :
9511 [ # # ]: 0 : if (j < zreg_num)
9512 : 0 : PMD_DRV_LOG(ERR, "Input zreg_num' is %u, actually bulk %u monopolize zregs is %u",
9513 : : zreg_num, bulk_id, j);
9514 : : }
9515 : :
9516 : : return ZXDH_OK;
9517 : : }
9518 : :
9519 : : static uint32_t
9520 : 0 : zxdh_np_apt_hash_bulk_res_init(uint32_t dev_id, uint32_t bulk_num,
9521 : : ZXDH_APT_HASH_BULK_RES_T *p_bulk_res)
9522 : : {
9523 : : uint32_t rc = ZXDH_OK;
9524 : : uint32_t index = 0;
9525 : : ZXDH_APT_HASH_BULK_RES_T *p_hash_bulk_res_temp = NULL;
9526 : : ZXDH_HASH_DDR_RESC_CFG_T ddr_resc_cfg = {0};
9527 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9528 : :
9529 : 0 : p_se_cfg = g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
9530 : :
9531 [ # # ]: 0 : for (index = 0; index < bulk_num; index++) {
9532 : : memset(&ddr_resc_cfg, 0, sizeof(ZXDH_HASH_DDR_RESC_CFG_T));
9533 : 0 : p_hash_bulk_res_temp = p_bulk_res + index;
9534 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_bulk_res_temp);
9535 : :
9536 : 0 : ddr_resc_cfg.ddr_baddr = p_hash_bulk_res_temp->ddr_baddr;
9537 : 0 : ddr_resc_cfg.ddr_item_num = p_hash_bulk_res_temp->ddr_item_num;
9538 : 0 : ddr_resc_cfg.ddr_width_mode = p_hash_bulk_res_temp->ddr_width_mode;
9539 : 0 : ddr_resc_cfg.ddr_crc_sel = p_hash_bulk_res_temp->ddr_crc_sel;
9540 : 0 : ddr_resc_cfg.ddr_ecc_en = p_hash_bulk_res_temp->ddr_ecc_en;
9541 : :
9542 : 0 : rc = zxdh_np_hash_bulk_init(p_se_cfg,
9543 : : p_hash_bulk_res_temp->func_id,
9544 : : p_hash_bulk_res_temp->bulk_id,
9545 : : &ddr_resc_cfg,
9546 : : p_hash_bulk_res_temp->zcell_num,
9547 : : p_hash_bulk_res_temp->zreg_num);
9548 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_bulk_init");
9549 : : }
9550 : :
9551 : 0 : return rc;
9552 : : }
9553 : :
9554 : : static uint32_t
9555 : 0 : zxdh_np_apt_set_callback(uint32_t dev_id, uint32_t sdt_no, uint32_t table_type, void *p_data)
9556 : : {
9557 : : SE_APT_CALLBACK_T *apt_func = NULL;
9558 : :
9559 : 0 : apt_func = &g_apt_se_callback[ZXDH_DEV_SLOT_ID(dev_id)][sdt_no];
9560 : :
9561 : 0 : apt_func->sdt_no = sdt_no;
9562 : 0 : apt_func->table_type = table_type;
9563 [ # # # # ]: 0 : switch (table_type) {
9564 : 0 : case ZXDH_SDT_TBLT_ERAM:
9565 : 0 : apt_func->se_func_info.eram_func.opr_mode =
9566 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->opr_mode;
9567 : 0 : apt_func->se_func_info.eram_func.rd_mode =
9568 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->rd_mode;
9569 : 0 : apt_func->se_func_info.eram_func.eram_set_func =
9570 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->eram_set_func;
9571 : 0 : apt_func->se_func_info.eram_func.eram_get_func =
9572 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->eram_get_func;
9573 : 0 : break;
9574 : 0 : case ZXDH_SDT_TBLT_HASH:
9575 : 0 : apt_func->se_func_info.hash_func.sdt_partner =
9576 : 0 : ((ZXDH_APT_HASH_TABLE_T *)p_data)->sdt_partner;
9577 : 0 : apt_func->se_func_info.hash_func.hash_set_func =
9578 : 0 : ((ZXDH_APT_HASH_TABLE_T *)p_data)->hash_set_func;
9579 : 0 : apt_func->se_func_info.hash_func.hash_get_func =
9580 : 0 : ((ZXDH_APT_HASH_TABLE_T *)p_data)->hash_get_func;
9581 : 0 : break;
9582 : 0 : case ZXDH_SDT_TBLT_ETCAM:
9583 : 0 : apt_func->se_func_info.acl_func.sdt_partner =
9584 : 0 : ((ZXDH_APT_ACL_TABLE_T *)p_data)->sdt_partner;
9585 : 0 : apt_func->se_func_info.acl_func.acl_set_func =
9586 : 0 : ((ZXDH_APT_ACL_TABLE_T *)p_data)->acl_set_func;
9587 : 0 : apt_func->se_func_info.acl_func.acl_get_func =
9588 : 0 : ((ZXDH_APT_ACL_TABLE_T *)p_data)->acl_get_func;
9589 : 0 : break;
9590 : 0 : default:
9591 : 0 : PMD_DRV_LOG(ERR, "table_type[ %u ] is invalid!", table_type);
9592 : 0 : return ZXDH_ERR;
9593 : : }
9594 : :
9595 : : return ZXDH_OK;
9596 : : }
9597 : :
9598 : : static uint32_t
9599 : 0 : zxdh_np_hash_tbl_id_info_init(ZXDH_SE_CFG *p_se_cfg,
9600 : : uint32_t fun_id,
9601 : : uint32_t tbl_id,
9602 : : uint32_t tbl_flag,
9603 : : uint32_t key_type,
9604 : : uint32_t actu_key_size)
9605 : : {
9606 [ # # ]: 0 : uint32_t key_by_size = ZXDH_GET_KEY_SIZE(actu_key_size);
9607 : : uint32_t entry_size = ZXDH_GET_HASH_ENTRY_SIZE(key_type);
9608 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
9609 : : ZXDH_HASH_TBL_ID_INFO *p_tbl_id_info = NULL;
9610 : :
9611 [ # # ]: 0 : if (key_by_size > entry_size) {
9612 : 0 : PMD_DRV_LOG(ERR, "ErrorCode[%x]: actu_key_size[%u] not match to key_type[%u].",
9613 : : ZXDH_HASH_RC_INVALID_PARA,
9614 : : key_by_size,
9615 : : entry_size);
9616 : : RTE_ASSERT(0);
9617 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9618 : : }
9619 : :
9620 : 0 : p_tbl_id_info = GET_HASH_TBL_ID_INFO(dev_id, fun_id, tbl_id);
9621 : :
9622 [ # # ]: 0 : if (p_tbl_id_info->is_init) {
9623 : 0 : PMD_DRV_LOG(ERR, "fun_id[%u], table_id[%u] is already init", fun_id, tbl_id);
9624 : 0 : return ZXDH_OK;
9625 : : }
9626 : :
9627 : 0 : p_tbl_id_info->fun_id = fun_id;
9628 : 0 : p_tbl_id_info->actu_key_size = actu_key_size;
9629 : 0 : p_tbl_id_info->key_type = key_type;
9630 : 0 : p_tbl_id_info->is_init = 1;
9631 : :
9632 [ # # ]: 0 : if (tbl_flag & ZXDH_HASH_TBL_FLAG_AGE)
9633 : 0 : p_tbl_id_info->is_age = 1;
9634 : :
9635 [ # # ]: 0 : if (tbl_flag & ZXDH_HASH_TBL_FLAG_LEARN)
9636 : 0 : p_tbl_id_info->is_lrn = 1;
9637 : :
9638 [ # # ]: 0 : if (tbl_flag & ZXDH_HASH_TBL_FLAG_MC_WRT)
9639 : 0 : p_tbl_id_info->is_mc_wrt = 1;
9640 : :
9641 : : return ZXDH_OK;
9642 : : }
9643 : :
9644 : : static uint32_t
9645 : 0 : zxdh_np_apt_hash_tbl_res_init(uint32_t dev_id, uint32_t tbl_num,
9646 : : ZXDH_APT_HASH_TABLE_T *p_hash_tbl)
9647 : : {
9648 : : uint32_t rc = ZXDH_OK;
9649 : : uint32_t index = 0;
9650 : : ZXDH_APT_HASH_TABLE_T *p_hash_tbl_temp = NULL;
9651 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9652 : :
9653 : 0 : p_se_cfg = g_apt_se_cfg[ZXDH_DEV_SLOT_ID(dev_id)];
9654 : :
9655 [ # # ]: 0 : for (index = 0; index < tbl_num; index++) {
9656 : 0 : p_hash_tbl_temp = p_hash_tbl + index;
9657 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_tbl_temp);
9658 : 0 : rc = zxdh_np_sdt_tbl_write(dev_id,
9659 : : p_hash_tbl_temp->sdt_no,
9660 : : p_hash_tbl_temp->hash_sdt.table_type,
9661 : 0 : &p_hash_tbl_temp->hash_sdt,
9662 : : ZXDH_SDT_OPER_ADD);
9663 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_sdt_tbl_write");
9664 : :
9665 : 0 : rc = zxdh_np_hash_tbl_id_info_init(p_se_cfg,
9666 : : p_hash_tbl_temp->hash_sdt.hash_id,
9667 : : p_hash_tbl_temp->hash_sdt.hash_table_id,
9668 : : p_hash_tbl_temp->tbl_flag,
9669 : : p_hash_tbl_temp->hash_sdt.hash_table_width,
9670 : : p_hash_tbl_temp->hash_sdt.key_size);
9671 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_tbl_id_info_init_ex");
9672 : :
9673 : 0 : rc = zxdh_np_apt_set_callback(dev_id,
9674 : : p_hash_tbl_temp->sdt_no,
9675 : : p_hash_tbl_temp->hash_sdt.table_type,
9676 : : (void *)p_hash_tbl_temp);
9677 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_set_callback");
9678 : : }
9679 : :
9680 : 0 : return rc;
9681 : : }
9682 : :
9683 : : static uint32_t
9684 : 0 : zxdh_np_apt_eram_res_init(uint32_t dev_id, uint32_t tbl_num, ZXDH_APT_ERAM_TABLE_T *p_eram_tbl)
9685 : : {
9686 : : uint32_t rc = ZXDH_OK;
9687 : : uint32_t index = 0;
9688 : : ZXDH_APT_ERAM_TABLE_T *p_temp_eram_tbl = NULL;
9689 : :
9690 [ # # ]: 0 : for (index = 0; index < tbl_num; index++) {
9691 : 0 : p_temp_eram_tbl = p_eram_tbl + index;
9692 : 0 : rc = zxdh_np_sdt_tbl_write(dev_id,
9693 : : p_temp_eram_tbl->sdt_no,
9694 : : p_temp_eram_tbl->eram_sdt.table_type,
9695 : 0 : &p_temp_eram_tbl->eram_sdt,
9696 : : ZXDH_SDT_OPER_ADD);
9697 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_sdt_tbl_write");
9698 : :
9699 : 0 : rc = zxdh_np_apt_set_callback(dev_id,
9700 : : p_temp_eram_tbl->sdt_no,
9701 : : p_temp_eram_tbl->eram_sdt.table_type,
9702 : : (void *)p_temp_eram_tbl);
9703 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_set_callback");
9704 : : }
9705 : :
9706 : 0 : return rc;
9707 : : }
9708 : :
9709 : : static uint32_t
9710 : : zxdh_np_acl_entrynum_to_blocknum(uint32_t entry_num, uint32_t key_mode)
9711 : : {
9712 : : uint32_t value = 0;
9713 : :
9714 : 0 : value = entry_num % (ZXDH_ETCAM_RAM_DEPTH * ((uint32_t)1 << key_mode));
9715 : :
9716 [ # # ]: 0 : if (value == 0)
9717 : 0 : return (entry_num / (ZXDH_ETCAM_RAM_DEPTH * ((uint32_t)1 << key_mode)));
9718 : : else
9719 : 0 : return (entry_num / (ZXDH_ETCAM_RAM_DEPTH * ((uint32_t)1 << key_mode)) + 1);
9720 : : }
9721 : :
9722 : : static int32_t
9723 : 0 : zxdh_np_acl_key_cmp(void *p_new_key, void *p_old_key, uint32_t key_len)
9724 : : {
9725 : 0 : return memcmp(&(((ZXDH_ACL_KEY_INFO_T *)p_new_key)->pri),
9726 : 0 : &(((ZXDH_ACL_KEY_INFO_T *)p_old_key)->pri), key_len - sizeof(uint32_t));
9727 : : }
9728 : :
9729 : : static uint32_t
9730 : : zxdh_np_acl_cfg_init_ex(ZXDH_ACL_CFG_EX_T *p_acl_cfg,
9731 : : void *p_client,
9732 : : uint32_t flags,
9733 : : ZXDH_ACL_AS_RSLT_WRT_FUNCTION p_as_wrt_fun)
9734 : : {
9735 : : uint32_t rc = 0;
9736 : :
9737 : : memset(p_acl_cfg, 0, sizeof(ZXDH_ACL_CFG_EX_T));
9738 : :
9739 : 0 : p_acl_cfg->p_client = p_client;
9740 : 0 : p_acl_cfg->dev_id = (uint32_t)(ZXDH_COMM_PTR_TO_VAL(p_acl_cfg->p_client) & 0xFFFFFFFF);
9741 : 0 : p_acl_cfg->flags = flags;
9742 : :
9743 : 0 : g_p_acl_ex_cfg[ZXDH_DEV_SLOT_ID(p_acl_cfg->dev_id)] = p_acl_cfg;
9744 : :
9745 : : if (flags & ZXDH_ACL_FLAG_ETCAM0_EN) {
9746 : 0 : p_acl_cfg->acl_etcamids.is_valid = 1;
9747 : :
9748 : : p_acl_cfg->acl_etcamids.as_eram_base = 0;
9749 : :
9750 : : rc = zxdh_comm_double_link_init(ZXDH_ACL_TBL_ID_NUM,
9751 : : &p_acl_cfg->acl_etcamids.tbl_list);
9752 : : ZXDH_COMM_CHECK_RC(rc, "zxdh_comm_double_link_init");
9753 : : }
9754 : :
9755 : : if (p_as_wrt_fun == NULL) {
9756 : 0 : p_acl_cfg->p_as_rslt_write_fun = NULL;
9757 : 0 : p_acl_cfg->p_as_rslt_read_fun = NULL;
9758 : :
9759 : : } else {
9760 : : p_acl_cfg->p_as_rslt_write_fun = p_as_wrt_fun;
9761 : : }
9762 : :
9763 : : return rc;
9764 : : }
9765 : :
9766 : : static uint32_t
9767 : 0 : zxdh_np_acl_tbl_init_ex(ZXDH_ACL_CFG_EX_T *p_acl_cfg,
9768 : : uint32_t table_id,
9769 : : uint32_t as_enable,
9770 : : uint32_t entry_num,
9771 : : ZXDH_ACL_PRI_MODE_E pri_mode,
9772 : : uint32_t key_mode,
9773 : : ZXDH_ACL_AS_MODE_E as_mode,
9774 : : uint32_t as_baddr,
9775 : : uint32_t block_num,
9776 : : uint32_t *p_block_idx)
9777 : : {
9778 : : uint32_t rc = 0;
9779 : : uint32_t i = 0;
9780 : :
9781 : 0 : g_p_acl_ex_cfg[ZXDH_DEV_SLOT_ID(p_acl_cfg->dev_id)] = p_acl_cfg;
9782 : :
9783 [ # # ]: 0 : if (p_acl_cfg->acl_tbls[table_id].is_used) {
9784 : 0 : PMD_DRV_LOG(ERR, "table_id[ %u ] is already used!", table_id);
9785 : : RTE_ASSERT(0);
9786 : 0 : return ZXDH_ACL_RC_INVALID_TBLID;
9787 : : }
9788 : :
9789 [ # # ]: 0 : if (!p_acl_cfg->acl_etcamids.is_valid) {
9790 : 0 : PMD_DRV_LOG(ERR, "etcam is not init!");
9791 : : RTE_ASSERT(0);
9792 : 0 : return ZXDH_ACL_RC_ETCAMID_NOT_INIT;
9793 : : }
9794 : :
9795 [ # # ]: 0 : if (zxdh_np_acl_entrynum_to_blocknum(entry_num, key_mode) > block_num) {
9796 : 0 : PMD_DRV_LOG(ERR, "key_mode %u, etcam block_num %u is not enough for entry_num 0x%x",
9797 : : key_mode, block_num, entry_num);
9798 : : RTE_ASSERT(0);
9799 : 0 : return ZXDH_ACL_RC_INVALID_BLOCKNUM;
9800 [ # # ]: 0 : } else if (zxdh_np_acl_entrynum_to_blocknum(entry_num, key_mode) < block_num) {
9801 : 0 : PMD_DRV_LOG(DEBUG, "key_mode %u, etcam block_num %u is more than entry_num 0x%x",
9802 : : key_mode, block_num, entry_num);
9803 : : } else {
9804 : 0 : PMD_DRV_LOG(DEBUG, "key_mode %u, etcam block_num %u is match with entry_num 0x%x",
9805 : : key_mode, block_num, entry_num);
9806 : : }
9807 : :
9808 : 0 : p_acl_cfg->acl_tbls[table_id].as_enable = as_enable;
9809 : :
9810 [ # # ]: 0 : if (as_enable) {
9811 : 0 : p_acl_cfg->acl_tbls[table_id].as_idx_base = as_baddr;
9812 : 0 : p_acl_cfg->acl_tbls[table_id].as_rslt_buff =
9813 : 0 : rte_zmalloc(NULL, entry_num * ZXDH_ACL_AS_RSLT_SIZE_GET_EX(as_mode), 0);
9814 [ # # ]: 0 : if (p_acl_cfg->acl_tbls[table_id].as_rslt_buff == NULL) {
9815 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9816 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9817 : : }
9818 : : }
9819 : :
9820 : 0 : rc = (uint32_t)zxdh_comm_rb_init(&p_acl_cfg->acl_tbls[table_id].acl_rb, 0,
9821 : 0 : (sizeof(ZXDH_ACL_KEY_INFO_T) & 0xFFFFFFFFU) + ZXDH_ACL_KEYSIZE_GET(key_mode),
9822 : : zxdh_np_acl_key_cmp);
9823 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_comm_rb_init");
9824 : :
9825 : 0 : p_acl_cfg->acl_tbls[table_id].table_id = table_id;
9826 : 0 : p_acl_cfg->acl_tbls[table_id].pri_mode = pri_mode;
9827 : 0 : p_acl_cfg->acl_tbls[table_id].key_mode = key_mode;
9828 : 0 : p_acl_cfg->acl_tbls[table_id].entry_num = entry_num;
9829 : 0 : p_acl_cfg->acl_tbls[table_id].as_mode = as_mode;
9830 : 0 : p_acl_cfg->acl_tbls[table_id].is_used = 1;
9831 : :
9832 : 0 : zxdh_np_init_d_node(&p_acl_cfg->acl_tbls[table_id].entry_dn,
9833 [ # # ]: 0 : &p_acl_cfg->acl_tbls[table_id]);
9834 : : rc = zxdh_comm_double_link_insert_last(&p_acl_cfg->acl_tbls[table_id].entry_dn,
9835 : : &p_acl_cfg->acl_etcamids.tbl_list);
9836 : : ZXDH_COMM_CHECK_RC(rc, "zxdh_comm_double_link_insert_last");
9837 : :
9838 : 0 : p_acl_cfg->acl_tbls[table_id].block_num = block_num;
9839 : 0 : p_acl_cfg->acl_tbls[table_id].block_array =
9840 : 0 : rte_zmalloc(NULL, block_num * sizeof(uint32_t), 0);
9841 [ # # ]: 0 : if (p_acl_cfg->acl_tbls[table_id].block_array == NULL) {
9842 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9843 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9844 : : }
9845 : :
9846 [ # # ]: 0 : for (i = 0; i < block_num; i++) {
9847 [ # # ]: 0 : if (p_acl_cfg->acl_blocks[p_block_idx[i]].is_used) {
9848 : 0 : PMD_DRV_LOG(ERR, "the block[ %u ] is already used by table[ %u ]!",
9849 : : p_block_idx[i], p_acl_cfg->acl_blocks[p_block_idx[i]].tbl_id);
9850 : : RTE_ASSERT(0);
9851 : 0 : return ZXDH_ACL_RC_INVALID_BLOCKID;
9852 : : }
9853 : :
9854 : 0 : p_acl_cfg->acl_tbls[table_id].block_array[i] = p_block_idx[i];
9855 : 0 : p_acl_cfg->acl_blocks[p_block_idx[i]].is_used = 1;
9856 : 0 : p_acl_cfg->acl_blocks[p_block_idx[i]].tbl_id = table_id;
9857 : 0 : p_acl_cfg->acl_blocks[p_block_idx[i]].idx_base =
9858 : 0 : ((ZXDH_ACL_ENTRY_MAX_GET(key_mode, i)) >> ZXDH_BLOCK_IDXBASE_BIT_OFF) &
9859 : : ZXDH_BLOCK_IDXBASE_BIT_MASK;
9860 : : }
9861 : :
9862 : : return ZXDH_OK;
9863 : : }
9864 : :
9865 : : static uint32_t
9866 : 0 : zxdh_np_apt_acl_res_init(uint32_t dev_id, uint32_t tbl_num, ZXDH_APT_ACL_TABLE_T *p_acl_tbl_res)
9867 : : {
9868 : : uint32_t rc = ZXDH_OK;
9869 : : uint8_t index = 0;
9870 : : ZXDH_APT_ACL_TABLE_T *p_temp_acl_tbl = NULL;
9871 : :
9872 : 0 : rc = zxdh_np_acl_cfg_init_ex(&g_apt_acl_cfg[ZXDH_DEV_SLOT_ID(dev_id)],
9873 : 0 : (void *)ZXDH_COMM_VAL_TO_PTR(dev_id),
9874 : : ZXDH_ACL_FLAG_ETCAM0_EN,
9875 : : NULL);
9876 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_acl_cfg_init_ex");
9877 : :
9878 [ # # ]: 0 : for (index = 0; index < tbl_num; index++) {
9879 : 0 : p_temp_acl_tbl = p_acl_tbl_res + index;
9880 : 0 : rc = zxdh_np_sdt_tbl_write(dev_id,
9881 : : p_temp_acl_tbl->sdt_no,
9882 : : p_temp_acl_tbl->acl_sdt.table_type,
9883 : 0 : &p_temp_acl_tbl->acl_sdt,
9884 : : ZXDH_SDT_OPER_ADD);
9885 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_sdt_tbl_write");
9886 : :
9887 : 0 : rc = zxdh_np_acl_tbl_init_ex(&g_apt_acl_cfg[ZXDH_DEV_SLOT_ID(dev_id)],
9888 : : p_temp_acl_tbl->acl_sdt.etcam_table_id,
9889 : : p_temp_acl_tbl->acl_sdt.as_en,
9890 : : p_temp_acl_tbl->acl_res.entry_num,
9891 : 0 : p_temp_acl_tbl->acl_res.pri_mode,
9892 : : p_temp_acl_tbl->acl_sdt.etcam_key_mode,
9893 : 0 : p_temp_acl_tbl->acl_sdt.as_rsp_mode,
9894 : : p_temp_acl_tbl->acl_sdt.as_eram_baddr,
9895 : : p_temp_acl_tbl->acl_res.block_num,
9896 : 0 : p_temp_acl_tbl->acl_res.block_index);
9897 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_acl_tbl_init_ex");
9898 : :
9899 : 0 : rc = zxdh_np_apt_set_callback(dev_id,
9900 : : p_temp_acl_tbl->sdt_no,
9901 : : p_temp_acl_tbl->acl_sdt.table_type,
9902 : : (void *)p_temp_acl_tbl);
9903 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_set_callback");
9904 : : }
9905 : :
9906 : 0 : return rc;
9907 : : }
9908 : :
9909 : : static void
9910 : : zxdh_np_apt_stat_res_init(uint32_t dev_id, uint32_t type, ZXDH_APT_STAT_RES_INIT_T *stat_res_init)
9911 : : {
9912 : 0 : g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].eram_baddr = stat_res_init->eram_baddr;
9913 : 0 : g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].eram_depth = stat_res_init->eram_depth;
9914 : :
9915 [ # # ]: 0 : if (type == ZXDH_SE_NON_STD_NIC_RES_TYPE) {
9916 : 0 : g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].ddr_base_addr = stat_res_init->ddr_baddr;
9917 : 0 : g_ppu_stat_cfg[ZXDH_DEV_SLOT_ID(dev_id)].ppu_addr_offset =
9918 : 0 : stat_res_init->ppu_ddr_offset;
9919 : : }
9920 : : }
9921 : :
9922 : : static uint32_t
9923 [ # # ]: 0 : zxdh_np_se_res_init(uint32_t dev_id, uint32_t type)
9924 : : {
9925 : : uint32_t rc = ZXDH_OK;
9926 : : ZXDH_APT_SE_RES_T *p_se_res = NULL;
9927 : : ZXDH_APT_HASH_RES_INIT_T hash_res_init = {0};
9928 : : ZXDH_APT_ERAM_RES_INIT_T eram_res_init = {0};
9929 : : ZXDH_APT_ACL_RES_INIT_T acl_res_init = {0};
9930 : :
9931 : : p_se_res = (ZXDH_APT_SE_RES_T *)zxdh_np_dev_get_se_res_ptr(dev_id, type);
9932 [ # # ]: 0 : if (!p_se_res->valid) {
9933 : 0 : PMD_DRV_LOG(ERR, "dev_id[0x%x],se_type[0x%x] invalid!", dev_id, type);
9934 : 0 : return ZXDH_ERR;
9935 : : }
9936 : :
9937 : 0 : hash_res_init.func_num = p_se_res->hash_func_num;
9938 : 0 : hash_res_init.bulk_num = p_se_res->hash_bulk_num;
9939 : 0 : hash_res_init.tbl_num = p_se_res->hash_tbl_num;
9940 : 0 : hash_res_init.func_res = p_se_res->hash_func;
9941 : 0 : hash_res_init.bulk_res = p_se_res->hash_bulk;
9942 : 0 : hash_res_init.tbl_res = p_se_res->hash_tbl;
9943 : 0 : eram_res_init.tbl_num = p_se_res->eram_num;
9944 : 0 : eram_res_init.eram_res = p_se_res->eram_tbl;
9945 : 0 : acl_res_init.tbl_num = p_se_res->acl_num;
9946 : 0 : acl_res_init.acl_res = p_se_res->acl_tbl;
9947 : :
9948 : 0 : rc = zxdh_np_apt_hash_global_res_init(dev_id);
9949 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_global_res_init");
9950 : :
9951 [ # # ]: 0 : if (hash_res_init.func_num) {
9952 : 0 : rc = zxdh_np_apt_hash_func_res_init(dev_id, hash_res_init.func_num,
9953 : : hash_res_init.func_res);
9954 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_func_res_init");
9955 : : }
9956 : :
9957 [ # # ]: 0 : if (hash_res_init.bulk_num) {
9958 : 0 : rc = zxdh_np_apt_hash_bulk_res_init(dev_id, hash_res_init.bulk_num,
9959 : : hash_res_init.bulk_res);
9960 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_bulk_res_init");
9961 : : }
9962 : :
9963 [ # # ]: 0 : if (hash_res_init.tbl_num) {
9964 : 0 : rc = zxdh_np_apt_hash_tbl_res_init(dev_id, hash_res_init.tbl_num,
9965 : : hash_res_init.tbl_res);
9966 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_tbl_res_init");
9967 : : }
9968 : :
9969 [ # # ]: 0 : if (eram_res_init.tbl_num) {
9970 : 0 : rc = zxdh_np_apt_eram_res_init(dev_id, eram_res_init.tbl_num,
9971 : : eram_res_init.eram_res);
9972 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_eram_res_init");
9973 : : }
9974 : :
9975 [ # # ]: 0 : if (acl_res_init.tbl_num) {
9976 : 0 : rc = zxdh_np_apt_acl_res_init(dev_id, acl_res_init.tbl_num,
9977 : : acl_res_init.acl_res);
9978 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_acl_res_init");
9979 : : }
9980 : :
9981 : : zxdh_np_apt_stat_res_init(dev_id, type, &p_se_res->stat_cfg);
9982 : :
9983 : : return rc;
9984 : : }
9985 : :
9986 : : uint32_t
9987 : 0 : zxdh_np_se_res_get_and_init(uint32_t dev_id, uint32_t type)
9988 : : {
9989 : : uint32_t rc = ZXDH_OK;
9990 : :
9991 : 0 : rc = zxdh_np_agent_se_res_get(dev_id, type);
9992 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_se_res_get");
9993 : 0 : PMD_DRV_LOG(DEBUG, "se res get success.");
9994 : :
9995 : 0 : rc = zxdh_np_se_res_init(dev_id, type);
9996 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_res_init");
9997 : 0 : PMD_DRV_LOG(DEBUG, "se res init success.");
9998 : :
9999 : 0 : return rc;
10000 : : }
10001 : :
10002 : : static uint32_t
10003 : 0 : zxdh_np_dtb_hash_zcam_del_one_hw(uint32_t dev_id,
10004 : : uint32_t queue_id,
10005 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
10006 : : ZXDH_HASH_ENTRY *p_hash_entry,
10007 : : ZXDH_DTB_ENTRY_T *p_entry,
10008 : : uint8_t *p_srh_succ)
10009 : : {
10010 : : uint32_t rc = ZXDH_OK;
10011 : 0 : ZXDH_HASH_RBKEY_INFO srh_rbkey = {0};
10012 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10013 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
10014 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
10015 : :
10016 : : uint32_t zblk_idx = 0;
10017 : : uint32_t pre_zblk_idx = 0xFFFFFFFF;
10018 : : uint16_t crc16_value = 0;
10019 : : uint32_t zcell_id = 0;
10020 : : uint32_t item_idx = 0;
10021 : 0 : uint32_t element_id = 0;
10022 : 0 : uint32_t byte_offset = 0;
10023 : : uint32_t addr = 0;
10024 : : uint32_t i = 0;
10025 : : uint8_t srh_succ = 0;
10026 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
10027 : 0 : uint8_t rd_buff[ZXDH_SE_ITEM_WIDTH_MAX] = {0};
10028 : :
10029 : : ZXDH_D_NODE *p_zblk_dn = NULL;
10030 : : ZXDH_D_NODE *p_zcell_dn = NULL;
10031 : : ZXDH_SE_CFG *p_se_cfg = NULL;
10032 : :
10033 [ # # ]: 0 : memcpy(srh_rbkey.key, p_hash_entry->p_key, p_hash_entry_cfg->key_by_size);
10034 : :
10035 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
10036 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
10037 : :
10038 : 0 : p_se_cfg = p_hash_entry_cfg->p_se_cfg;
10039 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
10040 : :
10041 : 0 : zxdh_np_hash_set_crc_key(p_hash_entry_cfg, p_hash_entry, temp_key);
10042 : :
10043 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
10044 : :
10045 [ # # ]: 0 : while (p_zcell_dn) {
10046 : 0 : p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
10047 : 0 : zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
10048 : : p_zblk = &p_se_cfg->zblk_info[zblk_idx];
10049 : :
10050 [ # # ]: 0 : if (zblk_idx != pre_zblk_idx) {
10051 : : pre_zblk_idx = zblk_idx;
10052 : 0 : crc16_value = p_hash_cfg->p_hash16_fun(temp_key,
10053 : 0 : p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
10054 : : }
10055 : :
10056 : 0 : zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
10057 : 0 : item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc16_value);
10058 : 0 : addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
10059 : :
10060 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
10061 : : queue_id,
10062 : : addr,
10063 : : ZXDH_DTB_DUMP_ZCAM_512b,
10064 : : 1,
10065 : : (uint32_t *)rd_buff,
10066 : : &element_id);
10067 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
10068 : :
10069 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
10070 : :
10071 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM, p_hash_entry_cfg->key_by_size,
10072 : : p_hash_entry, rd_buff, &byte_offset);
10073 [ # # ]: 0 : if (rc == ZXDH_OK) {
10074 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zcell.");
10075 : : srh_succ = 1;
10076 : 0 : p_hash_cfg->hash_stat.search_ok++;
10077 : 0 : break;
10078 : : }
10079 : :
10080 : 0 : p_zcell_dn = p_zcell_dn->next;
10081 : : }
10082 : :
10083 [ # # ]: 0 : if (srh_succ == 0) {
10084 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
10085 [ # # ]: 0 : while (p_zblk_dn) {
10086 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
10087 : 0 : zblk_idx = p_zblk->zblk_idx;
10088 : :
10089 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
10090 : : item_idx = i;
10091 : 0 : addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx, item_idx);
10092 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
10093 : : queue_id,
10094 : : addr,
10095 : : ZXDH_DTB_DUMP_ZCAM_512b,
10096 : : 1,
10097 : : (uint32_t *)rd_buff,
10098 : : &element_id);
10099 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
10100 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
10101 : :
10102 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM,
10103 : : p_hash_entry_cfg->key_by_size, p_hash_entry,
10104 : : rd_buff, &byte_offset);
10105 [ # # ]: 0 : if (rc == ZXDH_OK) {
10106 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zreg.");
10107 : : srh_succ = 1;
10108 : 0 : p_hash_cfg->hash_stat.search_ok++;
10109 : 0 : break;
10110 : : }
10111 : : }
10112 : 0 : p_zblk_dn = p_zblk_dn->next;
10113 : : }
10114 : : }
10115 : :
10116 [ # # ]: 0 : if (srh_succ) {
10117 : 0 : memset(rd_buff + byte_offset, 0,
10118 [ # # ]: 0 : ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type));
10119 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
10120 : 0 : rc = zxdh_np_dtb_se_alg_zcam_data_write(dev_id,
10121 : : addr,
10122 : : rd_buff,
10123 : : p_entry);
10124 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_alg_zcam_data_write");
10125 : 0 : p_hash_cfg->hash_stat.delete_ok++;
10126 : : }
10127 : :
10128 : 0 : *p_srh_succ = srh_succ;
10129 : :
10130 : 0 : return rc;
10131 : : }
10132 : :
10133 : : static uint32_t
10134 : 0 : zxdh_np_dtb_hash_zcam_del_hw(uint32_t dev_id,
10135 : : uint32_t queue_id,
10136 : : uint32_t sdt_no,
10137 : : uint32_t entry_num,
10138 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_arr_hash_entry,
10139 : : uint32_t *element_id)
10140 : : {
10141 : : uint32_t rc = ZXDH_OK;
10142 : : uint32_t item_cnt = 0;
10143 : : uint32_t key_valid = 1;
10144 : : uint32_t dtb_len = 0;
10145 : 0 : uint8_t srh_succ = 0;
10146 : 0 : uint8_t key[ZXDH_HASH_KEY_MAX] = {0};
10147 : 0 : uint8_t rst[ZXDH_HASH_RST_MAX] = {0};
10148 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
10149 : :
10150 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
10151 : : uint8_t *p_data_buff = NULL;
10152 : :
10153 : : ZXDH_HASH_ENTRY entry = {0};
10154 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
10155 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
10156 : :
10157 : 0 : dtb_one_entry.cmd = entry_cmd;
10158 : 0 : dtb_one_entry.data = entry_data;
10159 : 0 : entry.p_key = key;
10160 : 0 : entry.p_rst = rst;
10161 : :
10162 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
10163 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
10164 : :
10165 : 0 : p_data_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
10166 [ # # ]: 0 : if (p_data_buff == NULL) {
10167 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10168 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10169 : : }
10170 : :
10171 [ # # ]: 0 : for (item_cnt = 0; item_cnt < entry_num; ++item_cnt) {
10172 : 0 : srh_succ = 0;
10173 : : memset(key, 0, sizeof(key));
10174 : : memset(rst, 0, sizeof(rst));
10175 : : memset(entry_cmd, 0, sizeof(entry_cmd));
10176 : : memset(entry_data, 0, sizeof(entry_data));
10177 : 0 : entry.p_key[0] = (uint8_t)(((key_valid & 0x1) << 7)
10178 : 0 : | ((hash_entry_cfg.key_type & 0x3) << 5)
10179 : 0 : | (hash_entry_cfg.table_id & 0x1f));
10180 : 0 : memcpy(&entry.p_key[1], p_arr_hash_entry[item_cnt].p_actu_key,
10181 : 0 : hash_entry_cfg.actu_key_size);
10182 : :
10183 : 0 : rc = zxdh_np_dtb_hash_zcam_del_one_hw(dev_id,
10184 : : queue_id,
10185 : : &hash_entry_cfg,
10186 : : &entry,
10187 : : &dtb_one_entry,
10188 : : &srh_succ);
10189 : :
10190 [ # # ]: 0 : if (srh_succ) {
10191 : 0 : zxdh_np_dtb_data_write(p_data_buff, 0, &dtb_one_entry);
10192 : 0 : dtb_len = dtb_one_entry.data_size / ZXDH_DTB_LEN_POS_SETP + 1;
10193 : 0 : zxdh_np_dtb_write_down_table_data(dev_id, queue_id,
10194 : : dtb_len * ZXDH_DTB_LEN_POS_SETP, p_data_buff, element_id);
10195 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id,
10196 : : queue_id, *element_id);
10197 : : }
10198 : : }
10199 : :
10200 : 0 : rte_free(p_data_buff);
10201 : :
10202 : 0 : return rc;
10203 : : }
10204 : :
10205 : : static uint32_t
10206 : 0 : zxdh_np_dtb_sdt_hash_zcam_mono_space_dump(uint32_t dev_id,
10207 : : uint32_t queue_id,
10208 : : uint32_t sdt_no,
10209 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
10210 : : uint8_t *p_data,
10211 : : uint32_t *p_dump_len)
10212 : : {
10213 : : uint32_t rc = ZXDH_OK;
10214 : :
10215 : : uint32_t i = 0;
10216 : : uint32_t zblock_id = 0;
10217 : : uint32_t zcell_id = 0;
10218 : : uint32_t start_addr = 0;
10219 : : uint32_t dtb_desc_len = 0;
10220 : : uint32_t dump_pa_h = 0;
10221 : : uint32_t dump_pa_l = 0;
10222 : : uint32_t dma_addr_offset = 0;
10223 : : uint32_t desc_addr_offset = 0;
10224 : 0 : uint32_t element_id = 0;
10225 : : uint8_t *p_dump_desc_buf = NULL;
10226 : :
10227 : : ZXDH_D_NODE *p_zblk_dn = NULL;
10228 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
10229 : : ZXDH_SE_ZREG_CFG *p_zreg = NULL;
10230 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
10231 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10232 : :
10233 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
10234 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
10235 : :
10236 : 0 : rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &element_id);
10237 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
10238 : :
10239 : 0 : p_dump_desc_buf = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
10240 [ # # ]: 0 : if (p_dump_desc_buf == NULL) {
10241 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10242 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10243 : : }
10244 : 0 : dtb_dump_entry.cmd = cmd_buff;
10245 : :
10246 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
10247 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
10248 : :
10249 [ # # ]: 0 : while (p_zblk_dn) {
10250 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
10251 : 0 : zblock_id = p_zblk->zblk_idx;
10252 : :
10253 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZCELL_NUM; i++) {
10254 : : p_zcell = &p_zblk->zcell_info[i];
10255 : :
10256 [ # # ]: 0 : if ((p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO) &&
10257 [ # # ]: 0 : p_zcell->bulk_id == p_hash_entry_cfg->bulk_id) {
10258 : 0 : zcell_id = p_zcell->zcell_idx;
10259 : :
10260 : 0 : start_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_id, 0);
10261 : :
10262 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10263 : : queue_id,
10264 : : element_id,
10265 : : dma_addr_offset,
10266 : : &dump_pa_h,
10267 : : &dump_pa_l);
10268 : :
10269 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
10270 : : ZXDH_DTB_DUMP_ZCAM_512b, ZXDH_SE_RAM_DEPTH,
10271 : : dump_pa_h, dump_pa_l, &dtb_dump_entry);
10272 : :
10273 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset,
10274 : : &dtb_dump_entry);
10275 : :
10276 : 0 : dtb_desc_len++;
10277 : 0 : dma_addr_offset += ZXDH_SE_RAM_DEPTH * 512 / 8;
10278 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10279 : :
10280 : 0 : PMD_DRV_LOG(DEBUG, "the Zblock[%u]'s bulk_id:%u Mono Zcell_id :%u",
10281 : : zblock_id, p_hash_entry_cfg->bulk_id, zcell_id);
10282 : : }
10283 : : }
10284 : :
10285 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
10286 : : p_zreg = &p_zblk->zreg_info[i];
10287 : :
10288 [ # # ]: 0 : if ((p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO) &&
10289 [ # # ]: 0 : p_zreg->bulk_id == p_hash_entry_cfg->bulk_id) {
10290 : 0 : start_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblock_id, i);
10291 : :
10292 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10293 : : queue_id,
10294 : : element_id,
10295 : : dma_addr_offset,
10296 : : &dump_pa_h,
10297 : : &dump_pa_l);
10298 : :
10299 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
10300 : : ZXDH_DTB_DUMP_ZCAM_512b, 1, dump_pa_h, dump_pa_l, &dtb_dump_entry);
10301 : :
10302 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset,
10303 : : &dtb_dump_entry);
10304 : :
10305 : 0 : dtb_desc_len++;
10306 : 0 : dma_addr_offset += 512 / 8;
10307 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10308 : :
10309 : 0 : PMD_DRV_LOG(DEBUG, "the Zblock[%u]'s bulk_id:%u Mono Zreg_id :%u",
10310 : : zblock_id, p_zreg->bulk_id, i);
10311 : : }
10312 : : }
10313 : :
10314 : 0 : p_zblk_dn = p_zblk_dn->next;
10315 : : }
10316 : :
10317 : 0 : zxdh_np_dtb_write_dump_desc_info(dev_id,
10318 : : queue_id,
10319 : : element_id,
10320 : : (uint32_t *)p_dump_desc_buf,
10321 : : dma_addr_offset / 4,
10322 : : dtb_desc_len * 4,
10323 : : (uint32_t *)p_data);
10324 : :
10325 : 0 : zxdh_np_comm_swap(p_data, dma_addr_offset);
10326 : 0 : rte_free(p_dump_desc_buf);
10327 : :
10328 : 0 : *p_dump_len = dma_addr_offset;
10329 : :
10330 : 0 : return rc;
10331 : : }
10332 : :
10333 : : static uint32_t
10334 : 0 : zxdh_np_dtb_hash_table_zcam_dump(uint32_t dev_id,
10335 : : uint32_t queue_id,
10336 : : uint32_t sdt_no,
10337 : : uint32_t zblock_num,
10338 : : uint32_t zblock_array[ZXDH_SE_ZBLK_NUM],
10339 : : uint8_t *p_data,
10340 : : uint32_t *p_dump_len)
10341 : : {
10342 : : uint32_t rc = ZXDH_OK;
10343 : : uint32_t zblk_idx = 0;
10344 : : uint32_t index = 0;
10345 : : uint32_t zblock_id = 0;
10346 : : uint32_t zcell_id = 0;
10347 : : uint32_t start_addr = 0;
10348 : : uint32_t dtb_desc_len = 0;
10349 : : uint32_t dump_pa_h = 0;
10350 : : uint32_t dump_pa_l = 0;
10351 : : uint32_t dma_addr_offset = 0;
10352 : : uint32_t desc_addr_offset = 0;
10353 : 0 : uint32_t element_id = 0;
10354 : : uint8_t *p_dump_desc_buf = NULL;
10355 : :
10356 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
10357 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
10358 : :
10359 : 0 : rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &element_id);
10360 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
10361 : :
10362 : 0 : p_dump_desc_buf = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
10363 [ # # ]: 0 : if (p_dump_desc_buf == NULL) {
10364 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10365 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10366 : : }
10367 : :
10368 : 0 : dtb_dump_entry.cmd = cmd_buff;
10369 [ # # ]: 0 : for (zblk_idx = 0; zblk_idx < zblock_num; zblk_idx++) {
10370 : 0 : zblock_id = zblock_array[zblk_idx];
10371 [ # # ]: 0 : for (index = 0; index < ZXDH_SE_ZCELL_NUM; index++) {
10372 : 0 : zcell_id = zblock_id * ZXDH_SE_ZCELL_NUM + index;
10373 : 0 : start_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_id, 0);
10374 : :
10375 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10376 : : queue_id,
10377 : : element_id,
10378 : : dma_addr_offset,
10379 : : &dump_pa_h,
10380 : : &dump_pa_l);
10381 : :
10382 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
10383 : : ZXDH_DTB_DUMP_ZCAM_512b, ZXDH_SE_RAM_DEPTH,
10384 : : dump_pa_h, dump_pa_l, &dtb_dump_entry);
10385 : :
10386 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf,
10387 : : desc_addr_offset, &dtb_dump_entry);
10388 : :
10389 : 0 : dtb_desc_len++;
10390 : 0 : dma_addr_offset += ZXDH_SE_RAM_DEPTH * 512 / 8;
10391 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10392 : : }
10393 : :
10394 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10395 : : queue_id,
10396 : : element_id,
10397 : : dma_addr_offset,
10398 : : &dump_pa_h,
10399 : : &dump_pa_l);
10400 : :
10401 : 0 : start_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblock_id, 0);
10402 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr, ZXDH_DTB_DUMP_ZCAM_512b,
10403 : : ZXDH_SE_ZREG_NUM, dump_pa_h, dump_pa_l, &dtb_dump_entry);
10404 : :
10405 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset, &dtb_dump_entry);
10406 : :
10407 : 0 : dtb_desc_len++;
10408 : 0 : dma_addr_offset += ZXDH_SE_ZREG_NUM * 512 / 8;
10409 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10410 : : }
10411 : :
10412 : 0 : zxdh_np_dtb_write_dump_desc_info(dev_id,
10413 : : queue_id,
10414 : : element_id,
10415 : : (uint32_t *)p_dump_desc_buf,
10416 : : dma_addr_offset / 4,
10417 : : dtb_desc_len * 4,
10418 : : (uint32_t *)p_data);
10419 : :
10420 : 0 : zxdh_np_comm_swap(p_data, dma_addr_offset);
10421 : 0 : rte_free(p_dump_desc_buf);
10422 : :
10423 : 0 : *p_dump_len = dma_addr_offset;
10424 : :
10425 : 0 : return rc;
10426 : : }
10427 : :
10428 : : static void
10429 : 0 : zxdh_np_dtb_dump_hash_parse(HASH_ENTRY_CFG *p_hash_entry_cfg,
10430 : : uint32_t item_type,
10431 : : uint8_t *pdata,
10432 : : uint32_t dump_len,
10433 : : uint8_t *p_outdata,
10434 : : uint32_t *p_item_num)
10435 : : {
10436 : : uint32_t item_num = 0;
10437 : : uint32_t data_offset = 0;
10438 : : uint32_t index = 0;
10439 : : uint8_t temp_key_valid = 0;
10440 : : uint8_t temp_key_type = 0;
10441 : : uint8_t temp_tbl_id = 0;
10442 : : uint32_t srh_entry_size = 0;
10443 : : uint32_t item_width = ZXDH_SE_ITEM_WIDTH_MAX;
10444 : : uint8_t *p_temp_key = NULL;
10445 : : uint8_t *p_hash_item = NULL;
10446 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry = NULL;
10447 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_temp_entry = NULL;
10448 : :
10449 [ # # ]: 0 : if (item_type == ZXDH_ITEM_DDR_256)
10450 : : item_width = item_width / 2;
10451 : :
10452 : : p_dtb_hash_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_outdata;
10453 [ # # ]: 0 : srh_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type);
10454 : :
10455 [ # # ]: 0 : for (index = 0; index < (dump_len / item_width); index++) {
10456 : : data_offset = 0;
10457 : 0 : p_hash_item = pdata + index * item_width;
10458 [ # # ]: 0 : while (data_offset < item_width) {
10459 : 0 : p_temp_key = p_hash_item + data_offset;
10460 : 0 : temp_key_valid = ZXDH_GET_HASH_KEY_VALID(p_temp_key);
10461 : 0 : temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_temp_key);
10462 : 0 : temp_tbl_id = ZXDH_GET_HASH_TBL_ID(p_temp_key);
10463 : 0 : p_temp_entry = p_dtb_hash_entry + item_num;
10464 : :
10465 [ # # # # ]: 0 : if (temp_key_valid && temp_key_type == p_hash_entry_cfg->key_type &&
10466 [ # # ]: 0 : temp_tbl_id == p_hash_entry_cfg->table_id) {
10467 : 0 : memcpy(p_temp_entry->p_actu_key, p_temp_key + 1,
10468 : 0 : p_hash_entry_cfg->actu_key_size);
10469 : 0 : memcpy(p_temp_entry->p_rst,
10470 : 0 : p_temp_key + p_hash_entry_cfg->key_by_size,
10471 : 0 : p_hash_entry_cfg->rst_by_size);
10472 : 0 : item_num++;
10473 : : }
10474 : :
10475 : 0 : data_offset += srh_entry_size;
10476 : : }
10477 : : }
10478 : :
10479 : 0 : *p_item_num = item_num;
10480 : 0 : }
10481 : :
10482 : : static uint32_t
10483 : 0 : zxdh_np_dtb_hash_table_dump(uint32_t dev_id,
10484 : : uint32_t queue_id,
10485 : : uint32_t sdt_no,
10486 : : ZXDH_DTB_DUMP_INDEX_T start_index,
10487 : : uint8_t *p_dump_data,
10488 : : uint32_t *p_entry_num,
10489 : : ZXDH_DTB_DUMP_INDEX_T *next_start_index,
10490 : : uint32_t *finish_flag)
10491 : : {
10492 : : uint32_t rc = ZXDH_OK;
10493 : : uint8_t *p_data = NULL;
10494 : 0 : uint32_t data_len = 0;
10495 : 0 : uint32_t entry_num = 0;
10496 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10497 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
10498 : :
10499 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
10500 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
10501 : :
10502 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
10503 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
10504 : :
10505 : 0 : p_data = rte_zmalloc(NULL, ZXDH_DTB_DMUP_DATA_MAX, 0);
10506 [ # # ]: 0 : if (p_data == NULL) {
10507 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10508 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10509 : : }
10510 : :
10511 [ # # ]: 0 : if (start_index.index_type == ZXDH_DTB_DUMP_ZCAM_TYPE) {
10512 [ # # ]: 0 : if (p_hash_cfg->bulk_ram_mono[hash_entry_cfg.bulk_id]) {
10513 : 0 : rc = zxdh_np_dtb_sdt_hash_zcam_mono_space_dump(dev_id,
10514 : : queue_id,
10515 : : sdt_no,
10516 : : &hash_entry_cfg,
10517 : : p_data,
10518 : : &data_len);
10519 : : } else {
10520 : 0 : rc = zxdh_np_dtb_hash_table_zcam_dump(dev_id,
10521 : : queue_id,
10522 : : sdt_no,
10523 : : p_hash_cfg->hash_stat.zblock_num,
10524 : 0 : p_hash_cfg->hash_stat.zblock_array,
10525 : : p_data,
10526 : : &data_len);
10527 : : }
10528 : :
10529 : 0 : zxdh_np_dtb_dump_hash_parse(&hash_entry_cfg,
10530 : : ZXDH_ITEM_RAM,
10531 : : p_data,
10532 : : data_len,
10533 : : p_dump_data,
10534 : : &entry_num);
10535 : :
10536 [ # # ]: 0 : if (p_hash_cfg->ddr_valid) {
10537 : 0 : next_start_index->index = 0;
10538 : 0 : next_start_index->index_type = ZXDH_DTB_DUMP_DDR_TYPE;
10539 : : } else {
10540 : 0 : *finish_flag = 1;
10541 : : }
10542 : 0 : *p_entry_num = entry_num;
10543 : : }
10544 : :
10545 : 0 : rte_free(p_data);
10546 : 0 : return rc;
10547 : : }
10548 : :
10549 : : static uint32_t
10550 : 0 : zxdh_np_dtb_hash_offline_zcam_delete(uint32_t dev_id,
10551 : : uint32_t queue_id,
10552 : : uint32_t sdt_no)
10553 : : {
10554 : : uint32_t rc = ZXDH_OK;
10555 : 0 : uint32_t entry_num = 0;
10556 : 0 : uint32_t finish_flag = 0;
10557 : : uint32_t index = 0;
10558 : : uint32_t max_item_num = 1024 * 1024;
10559 : : uint8_t *p_dump_data = NULL;
10560 : : uint8_t *p_key = NULL;
10561 : : uint8_t *p_rst = NULL;
10562 : 0 : uint32_t element_id = 0;
10563 : :
10564 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry = NULL;
10565 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_temp_entry = NULL;
10566 : 0 : ZXDH_DTB_DUMP_INDEX_T start_index = {0};
10567 : 0 : ZXDH_DTB_DUMP_INDEX_T next_start_index = {0};
10568 : :
10569 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash = {0};
10570 : : start_index.index = 0;
10571 : : start_index.index_type = ZXDH_DTB_DUMP_ZCAM_TYPE;
10572 : :
10573 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
10574 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash);
10575 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
10576 : :
10577 : 0 : p_dump_data = rte_zmalloc(NULL, max_item_num * sizeof(ZXDH_DTB_HASH_ENTRY_INFO_T), 0);
10578 [ # # ]: 0 : if (p_dump_data == NULL) {
10579 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10580 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10581 : : }
10582 : 0 : p_key = rte_zmalloc(NULL, max_item_num * ZXDH_HASH_KEY_MAX, 0);
10583 [ # # ]: 0 : if (p_key == NULL) {
10584 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10585 : 0 : rte_free(p_dump_data);
10586 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10587 : : }
10588 : 0 : p_rst = rte_zmalloc(NULL, max_item_num * ZXDH_HASH_RST_MAX, 0);
10589 : : if (p_key == NULL) {
10590 : : PMD_DRV_LOG(ERR, "malloc memory failed");
10591 : : rte_free(p_dump_data);
10592 : : rte_free(p_key);
10593 : : return ZXDH_PAR_CHK_POINT_NULL;
10594 : : }
10595 : :
10596 : : p_dtb_hash_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_dump_data;
10597 [ # # ]: 0 : for (index = 0; index < max_item_num; index++) {
10598 : 0 : p_temp_entry = p_dtb_hash_entry + index;
10599 : 0 : p_temp_entry->p_actu_key = p_key + index * ZXDH_HASH_KEY_MAX;
10600 : 0 : p_temp_entry->p_rst = p_rst + index * ZXDH_HASH_RST_MAX;
10601 : : }
10602 : :
10603 : 0 : rc = zxdh_np_dtb_hash_table_dump(dev_id, queue_id, sdt_no, start_index,
10604 : : p_dump_data, &entry_num, &next_start_index, &finish_flag);
10605 : :
10606 [ # # ]: 0 : if (entry_num) {
10607 : 0 : rc = zxdh_np_dtb_hash_zcam_del_hw(dev_id, queue_id, sdt_no,
10608 : : entry_num, p_dtb_hash_entry, &element_id);
10609 : : }
10610 : :
10611 : 0 : rte_free(p_dtb_hash_entry);
10612 : 0 : rte_free(p_key);
10613 : 0 : rte_free(p_rst);
10614 : :
10615 : 0 : return rc;
10616 : : }
10617 : :
10618 : : uint32_t
10619 : 0 : zxdh_np_dtb_hash_online_delete(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no)
10620 : : {
10621 : : uint32_t rc = 0;
10622 : : uint8_t key_valid = 0;
10623 : : uint32_t table_id = 0;
10624 : : uint32_t key_type = 0;
10625 : :
10626 : : ZXDH_D_NODE *p_node = NULL;
10627 : : ZXDH_RB_TN *p_rb_tn = NULL;
10628 : : ZXDH_D_HEAD *p_head_hash_rb = NULL;
10629 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10630 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
10631 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
10632 : 0 : ZXDH_DTB_USER_ENTRY_T del_entry = {0};
10633 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T hash_entry = {0};
10634 : :
10635 : 0 : del_entry.sdt_no = sdt_no;
10636 : 0 : del_entry.p_entry_data = &hash_entry;
10637 : :
10638 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
10639 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
10640 : :
10641 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
10642 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
10643 : :
10644 : : p_head_hash_rb = &p_hash_cfg->hash_rb.tn_list;
10645 : 0 : p_node = p_head_hash_rb->p_next;
10646 [ # # ]: 0 : while (p_node) {
10647 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
10648 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn);
10649 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_rb_tn->p_key;
10650 : 0 : hash_entry.p_actu_key = p_rbkey->key + 1;
10651 : 0 : hash_entry.p_rst = p_rbkey->key;
10652 : :
10653 : 0 : key_valid = ZXDH_GET_HASH_KEY_VALID(p_rbkey->key);
10654 : : table_id = ZXDH_GET_HASH_TBL_ID(p_rbkey->key);
10655 : 0 : key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
10656 [ # # ]: 0 : if (!key_valid ||
10657 [ # # ]: 0 : table_id != hash_entry_cfg.table_id ||
10658 [ # # ]: 0 : key_type != hash_entry_cfg.key_type) {
10659 : 0 : p_node = p_node->next;
10660 : 0 : continue;
10661 : : }
10662 : 0 : p_node = p_node->next;
10663 : :
10664 : 0 : rc = zxdh_np_dtb_table_entry_delete(dev_id, queue_id, 1, &del_entry);
10665 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
10666 : 0 : continue;
10667 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_table_entry_delete");
10668 : : }
10669 : :
10670 : 0 : return rc;
10671 : : }
10672 : :
10673 : : uint32_t
10674 : 0 : zxdh_np_dtb_hash_offline_delete(uint32_t dev_id,
10675 : : uint32_t queue_id,
10676 : : uint32_t sdt_no,
10677 : : __rte_unused uint32_t flush_mode)
10678 : : {
10679 : : uint32_t rc = ZXDH_OK;
10680 : :
10681 : 0 : rc = zxdh_np_dtb_hash_offline_zcam_delete(dev_id, queue_id, sdt_no);
10682 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_offline_zcam_delete");
10683 : :
10684 : 0 : return rc;
10685 : : }
10686 : :
10687 : : static uint32_t
10688 : 0 : zxdh_np_se_done_status_check(uint32_t dev_id, uint32_t reg_no, uint32_t pos)
10689 : : {
10690 : : uint32_t rc = 0;
10691 : :
10692 : 0 : uint32_t data = 0;
10693 : : uint32_t rd_cnt = 0;
10694 : : uint32_t done_flag = 0;
10695 : :
10696 : 0 : while (!done_flag) {
10697 : 0 : rc = zxdh_np_reg_read32(dev_id, reg_no, 0, 0, &data);
10698 [ # # ]: 0 : if (rc != 0) {
10699 : 0 : PMD_DRV_LOG(ERR, "reg_read32 fail!");
10700 : 0 : return rc;
10701 : : }
10702 : :
10703 : 0 : done_flag = (data >> pos) & 0x1;
10704 : :
10705 [ # # ]: 0 : if (done_flag)
10706 : : break;
10707 : :
10708 [ # # ]: 0 : if (rd_cnt > ZXDH_RD_CNT_MAX * ZXDH_RD_CNT_MAX)
10709 : : return -1;
10710 : :
10711 : 0 : rd_cnt++;
10712 : : }
10713 : :
10714 : : return rc;
10715 : : }
10716 : :
10717 : : static uint32_t
10718 : 0 : zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
10719 : : uint32_t base_addr,
10720 : : uint32_t index,
10721 : : uint32_t rd_mode,
10722 : : uint32_t rd_clr_mode,
10723 : : uint32_t *p_data)
10724 : : {
10725 : : uint32_t rc = ZXDH_OK;
10726 : : uint32_t i = 0;
10727 : : uint32_t row_index = 0;
10728 : : uint32_t col_index = 0;
10729 : 0 : uint32_t temp_data[4] = {0};
10730 : : uint32_t *p_temp_data = NULL;
10731 : 0 : ZXDH_SMMU0_SMMU0_CPU_IND_CMD_T cpu_ind_cmd = {0};
10732 : 0 : ZXDH_SPINLOCK_T *p_ind_spinlock = NULL;
10733 : :
10734 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_SMMU0, &p_ind_spinlock);
10735 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
10736 : :
10737 : 0 : rte_spinlock_lock(&p_ind_spinlock->spinlock);
10738 : :
10739 : 0 : rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_WR_ARB_CPU_RDYR, 0);
10740 [ # # ]: 0 : if (rc != ZXDH_OK) {
10741 : 0 : PMD_DRV_LOG(ERR, "se done status check failed, rc=0x%x.", rc);
10742 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10743 : 0 : return ZXDH_ERR;
10744 : : }
10745 : :
10746 [ # # ]: 0 : if (rd_clr_mode == ZXDH_RD_MODE_HOLD) {
10747 : 0 : cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD;
10748 : 0 : cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_HOLD;
10749 : 0 : cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b;
10750 : :
10751 [ # # # # : 0 : switch (rd_mode) {
# ]
10752 : 0 : case ZXDH_ERAM128_OPR_128b:
10753 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
10754 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10755 : 0 : PMD_DRV_LOG(ERR, "index 0x%x is invalid!", index);
10756 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
10757 : : }
10758 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10759 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10760 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10761 : 0 : return ZXDH_ERR;
10762 : : }
10763 : 0 : row_index = (index << 7) & ZXDH_ERAM128_BADDR_MASK;
10764 : 0 : break;
10765 : 0 : case ZXDH_ERAM128_OPR_64b:
10766 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10767 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10768 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10769 : 0 : return ZXDH_ERR;
10770 : : }
10771 : 0 : row_index = (index << 6) & ZXDH_ERAM128_BADDR_MASK;
10772 : 0 : col_index = index & 0x1;
10773 : 0 : break;
10774 : 0 : case ZXDH_ERAM128_OPR_32b:
10775 [ # # ]: 0 : if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10776 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10777 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10778 : 0 : return ZXDH_ERR;
10779 : : }
10780 : 0 : row_index = (index << 5) & ZXDH_ERAM128_BADDR_MASK;
10781 : 0 : col_index = index & 0x3;
10782 : 0 : break;
10783 : 0 : case ZXDH_ERAM128_OPR_1b:
10784 [ # # ]: 0 : if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10785 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10786 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10787 : 0 : return ZXDH_ERR;
10788 : : }
10789 : 0 : row_index = index & ZXDH_ERAM128_BADDR_MASK;
10790 : 0 : col_index = index & 0x7F;
10791 : 0 : break;
10792 : : default:
10793 : : break;
10794 : : }
10795 : :
10796 : 0 : cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index;
10797 : : } else {
10798 : 0 : cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD;
10799 : 0 : cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_CLEAR;
10800 : :
10801 [ # # # # : 0 : switch (rd_mode) {
# ]
10802 : 0 : case ZXDH_ERAM128_OPR_128b:
10803 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
10804 : 0 : PMD_DRV_LOG(ERR, "index 0x%x is invalid!", index);
10805 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10806 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
10807 : : }
10808 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10809 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10810 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10811 : 0 : return ZXDH_ERR;
10812 : : }
10813 : 0 : row_index = (index << 7);
10814 : 0 : cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b;
10815 : 0 : break;
10816 : 0 : case ZXDH_ERAM128_OPR_64b:
10817 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10818 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10819 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10820 : 0 : return ZXDH_ERR;
10821 : : }
10822 : 0 : row_index = (index << 6);
10823 : 0 : cpu_ind_cmd.cpu_req_mode = 2;
10824 : 0 : break;
10825 : 0 : case ZXDH_ERAM128_OPR_32b:
10826 [ # # ]: 0 : if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10827 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10828 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10829 : 0 : return ZXDH_ERR;
10830 : : }
10831 : 0 : row_index = (index << 5);
10832 : 0 : cpu_ind_cmd.cpu_req_mode = 1;
10833 : 0 : break;
10834 : 0 : case ZXDH_ERAM128_OPR_1b:
10835 : 0 : PMD_DRV_LOG(ERR, "rd_clr_mode[%u] or rd_mode[%u] error!",
10836 : : rd_clr_mode, rd_mode);
10837 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10838 : 0 : return ZXDH_ERR;
10839 : : default:
10840 : : break;
10841 : : }
10842 : 0 : cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index;
10843 : : }
10844 : :
10845 : 0 : rc = zxdh_np_reg_write(dev_id,
10846 : : ZXDH_SMMU0_SMMU0_CPU_IND_CMDR,
10847 : : 0,
10848 : : 0,
10849 : : &cpu_ind_cmd);
10850 [ # # ]: 0 : if (rc != ZXDH_OK) {
10851 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_reg_write failed, rc=0x%x.", rc);
10852 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10853 : 0 : return ZXDH_ERR;
10854 : : }
10855 : :
10856 : 0 : rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_CPU_IND_RD_DONER, 0);
10857 [ # # ]: 0 : if (rc != ZXDH_OK) {
10858 : 0 : PMD_DRV_LOG(ERR, "se done status check failed, rc=0x%x.", rc);
10859 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10860 : 0 : return ZXDH_ERR;
10861 : : }
10862 : :
10863 : : p_temp_data = temp_data;
10864 [ # # ]: 0 : for (i = 0; i < 4; i++) {
10865 : 0 : rc = zxdh_np_reg_read(dev_id,
10866 : : ZXDH_SMMU0_SMMU0_CPU_IND_RDAT0R + i,
10867 : : 0,
10868 : : 0,
10869 : 0 : p_temp_data + 3 - i);
10870 [ # # ]: 0 : if (rc != ZXDH_OK) {
10871 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_reg_write failed, rc=0x%x.", rc);
10872 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10873 : 0 : return ZXDH_ERR;
10874 : : }
10875 : : }
10876 : :
10877 [ # # ]: 0 : if (rd_clr_mode == ZXDH_RD_MODE_HOLD) {
10878 [ # # # # : 0 : switch (rd_mode) {
# ]
10879 : : case ZXDH_ERAM128_OPR_128b:
10880 : : memcpy(p_data, p_temp_data, (128 / 8));
10881 : : break;
10882 : 0 : case ZXDH_ERAM128_OPR_64b:
10883 : 0 : memcpy(p_data, p_temp_data + ((1 - col_index) << 1), (64 / 8));
10884 : : break;
10885 : 0 : case ZXDH_ERAM128_OPR_32b:
10886 : 0 : memcpy(p_data, p_temp_data + ((3 - col_index)), (32 / 8));
10887 : : break;
10888 : 0 : case ZXDH_ERAM128_OPR_1b:
10889 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0],
10890 : : *(p_temp_data + (3 - col_index / 32)), (col_index % 32), 1);
10891 : 0 : break;
10892 : : default:
10893 : : break;
10894 : : }
10895 : : } else {
10896 [ # # # # ]: 0 : switch (rd_mode) {
10897 : : case ZXDH_ERAM128_OPR_128b:
10898 : : memcpy(p_data, p_temp_data, (128 / 8));
10899 : : break;
10900 : : case ZXDH_ERAM128_OPR_64b:
10901 : : memcpy(p_data, p_temp_data, (64 / 8));
10902 : : break;
10903 : : case ZXDH_ERAM128_OPR_32b:
10904 : : memcpy(p_data, p_temp_data, (64 / 8));
10905 : : break;
10906 : : default:
10907 : : break;
10908 : : }
10909 : : }
10910 : :
10911 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10912 : :
10913 : 0 : return rc;
10914 : : }
10915 : :
10916 : : uint32_t
10917 : 0 : zxdh_np_stat_ppu_cnt_get_ex(uint32_t dev_id,
10918 : : ZXDH_STAT_CNT_MODE_E rd_mode,
10919 : : uint32_t index,
10920 : : uint32_t clr_mode,
10921 : : uint32_t *p_data)
10922 : : {
10923 : : uint32_t rc = 0;
10924 : : uint32_t ppu_eram_baddr = 0;
10925 : : uint32_t ppu_eram_depth = 0;
10926 : : uint32_t eram_rd_mode = 0;
10927 : : uint32_t eram_clr_mode = 0;
10928 : 0 : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
10929 : :
10930 : 0 : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
10931 : :
10932 : 0 : ppu_eram_depth = stat_cfg.eram_depth;
10933 : 0 : ppu_eram_baddr = stat_cfg.eram_baddr;
10934 : :
10935 [ # # ]: 0 : if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) {
10936 [ # # ]: 0 : if (rd_mode == ZXDH_STAT_128_MODE)
10937 : : eram_rd_mode = ZXDH_ERAM128_OPR_128b;
10938 : : else
10939 : : eram_rd_mode = ZXDH_ERAM128_OPR_64b;
10940 : :
10941 [ # # ]: 0 : if (clr_mode == ZXDH_STAT_RD_CLR_MODE_UNCLR)
10942 : : eram_clr_mode = ZXDH_RD_MODE_HOLD;
10943 : : else
10944 : : eram_clr_mode = ZXDH_RD_MODE_CLEAR;
10945 : :
10946 : 0 : rc = zxdh_np_se_smmu0_ind_read(dev_id,
10947 : : ppu_eram_baddr,
10948 : : index,
10949 : : eram_rd_mode,
10950 : : eram_clr_mode,
10951 : : p_data);
10952 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_smmu0_ind_read");
10953 : : } else {
10954 : 0 : PMD_DRV_LOG(ERR, "DPDK DON'T HAVE DDR STAT.");
10955 : : }
10956 : :
10957 : 0 : return rc;
10958 : : }
10959 : :
10960 : : static uint32_t
10961 : 0 : zxdh_np_agent_channel_plcr_sync_send(uint32_t dev_id, ZXDH_AGENT_CHANNEL_PLCR_MSG_T *p_msg,
10962 : : uint32_t *p_data, uint32_t rep_len)
10963 : : {
10964 : : uint32_t ret = 0;
10965 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
10966 : : .msg = (void *)p_msg,
10967 : : .msg_len = sizeof(ZXDH_AGENT_CHANNEL_PLCR_MSG_T),
10968 : : };
10969 : :
10970 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_data, rep_len);
10971 [ # # ]: 0 : if (ret != 0) {
10972 : 0 : PMD_DRV_LOG(ERR, "agent_channel_sync_send failed.");
10973 : 0 : return 1;
10974 : : }
10975 : :
10976 : : return 0;
10977 : : }
10978 : :
10979 : : static uint32_t
10980 : 0 : zxdh_np_agent_channel_plcr_profileid_request(uint32_t dev_id, uint32_t vport,
10981 : : uint32_t car_type, uint32_t *p_profileid)
10982 : : {
10983 : : uint32_t ret = 0;
10984 : 0 : uint32_t resp_buffer[2] = {0};
10985 : :
10986 : 0 : ZXDH_AGENT_CHANNEL_PLCR_MSG_T msgcfg = {
10987 : : .dev_id = 0,
10988 : : .type = ZXDH_PLCR_MSG,
10989 : : .oper = ZXDH_PROFILEID_REQUEST,
10990 : : .vport = vport,
10991 : : .car_type = car_type,
10992 : : .profile_id = 0xFFFF,
10993 : : };
10994 : :
10995 : 0 : ret = zxdh_np_agent_channel_plcr_sync_send(dev_id, &msgcfg,
10996 : : resp_buffer, sizeof(resp_buffer));
10997 [ # # ]: 0 : if (ret != 0) {
10998 : 0 : PMD_DRV_LOG(ERR, "agent_channel_plcr_sync_send failed.");
10999 : 0 : return 1;
11000 : : }
11001 : :
11002 : : memcpy(p_profileid, resp_buffer, sizeof(uint32_t) * ZXDH_SCHE_RSP_LEN);
11003 : :
11004 : 0 : return ret;
11005 : : }
11006 : :
11007 : : static uint32_t
11008 : 0 : zxdh_np_agent_channel_plcr_car_rate(uint32_t dev_id,
11009 : : uint32_t car_type,
11010 : : uint32_t pkt_sign,
11011 : : uint32_t profile_id __rte_unused,
11012 : : void *p_car_profile_cfg)
11013 : : {
11014 : : uint32_t ret = 0;
11015 : 0 : uint32_t resp_buffer[2] = {0};
11016 : : uint32_t resp_len = 8;
11017 : : uint32_t i = 0;
11018 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {0};
11019 : 0 : ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T msgpktcfg = {0};
11020 : 0 : ZXDH_AGENT_CAR_PROFILE_MSG_T msgcfg = {0};
11021 : : ZXDH_STAT_CAR_PROFILE_CFG_T *p_stat_car_profile_cfg = NULL;
11022 : : ZXDH_STAT_CAR_PKT_PROFILE_CFG_T *p_stat_pkt_car_profile_cfg = NULL;
11023 : :
11024 [ # # ]: 0 : if (car_type == ZXDH_STAT_CAR_A_TYPE && pkt_sign == 1) {
11025 : : p_stat_pkt_car_profile_cfg = (ZXDH_STAT_CAR_PKT_PROFILE_CFG_T *)p_car_profile_cfg;
11026 : : msgpktcfg.dev_id = 0;
11027 : 0 : msgpktcfg.type = ZXDH_PLCR_CAR_PKT_RATE;
11028 : 0 : msgpktcfg.car_level = car_type;
11029 : 0 : msgpktcfg.cir = p_stat_pkt_car_profile_cfg->cir;
11030 : 0 : msgpktcfg.cbs = p_stat_pkt_car_profile_cfg->cbs;
11031 : 0 : msgpktcfg.profile_id = p_stat_pkt_car_profile_cfg->profile_id;
11032 : 0 : msgpktcfg.pkt_sign = p_stat_pkt_car_profile_cfg->pkt_sign;
11033 [ # # ]: 0 : for (i = 0; i < ZXDH_CAR_PRI_MAX; i++)
11034 : 0 : msgpktcfg.pri[i] = p_stat_pkt_car_profile_cfg->pri[i];
11035 : :
11036 : 0 : agent_msg.msg = (void *)&msgpktcfg;
11037 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T);
11038 : :
11039 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, resp_buffer, resp_len);
11040 [ # # ]: 0 : if (ret != 0) {
11041 : 0 : PMD_DRV_LOG(ERR, "stat_car_a_type failed.");
11042 : 0 : return 1;
11043 : : }
11044 : :
11045 : 0 : ret = *(uint8_t *)resp_buffer;
11046 : : } else {
11047 : : p_stat_car_profile_cfg = (ZXDH_STAT_CAR_PROFILE_CFG_T *)p_car_profile_cfg;
11048 : : msgcfg.dev_id = 0;
11049 : 0 : msgcfg.type = ZXDH_PLCR_CAR_RATE;
11050 : 0 : msgcfg.car_level = car_type;
11051 : 0 : msgcfg.cir = p_stat_car_profile_cfg->cir;
11052 : 0 : msgcfg.cbs = p_stat_car_profile_cfg->cbs;
11053 : 0 : msgcfg.profile_id = p_stat_car_profile_cfg->profile_id;
11054 : 0 : msgcfg.pkt_sign = p_stat_car_profile_cfg->pkt_sign;
11055 : 0 : msgcfg.cd = p_stat_car_profile_cfg->cd;
11056 : 0 : msgcfg.cf = p_stat_car_profile_cfg->cf;
11057 : 0 : msgcfg.cm = p_stat_car_profile_cfg->cm;
11058 : : msgcfg.cir = p_stat_car_profile_cfg->cir;
11059 : : msgcfg.cbs = p_stat_car_profile_cfg->cbs;
11060 : 0 : msgcfg.eir = p_stat_car_profile_cfg->eir;
11061 : 0 : msgcfg.ebs = p_stat_car_profile_cfg->ebs;
11062 : 0 : msgcfg.random_disc_e = p_stat_car_profile_cfg->random_disc_e;
11063 : 0 : msgcfg.random_disc_c = p_stat_car_profile_cfg->random_disc_c;
11064 [ # # ]: 0 : for (i = 0; i < ZXDH_CAR_PRI_MAX; i++) {
11065 : 0 : msgcfg.c_pri[i] = p_stat_car_profile_cfg->c_pri[i];
11066 : 0 : msgcfg.e_green_pri[i] = p_stat_car_profile_cfg->e_green_pri[i];
11067 : 0 : msgcfg.e_yellow_pri[i] = p_stat_car_profile_cfg->e_yellow_pri[i];
11068 : : }
11069 : :
11070 : 0 : agent_msg.msg = (void *)&msgcfg;
11071 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PROFILE_MSG_T);
11072 : :
11073 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, resp_buffer, resp_len);
11074 [ # # ]: 0 : if (ret != 0) {
11075 : 0 : PMD_DRV_LOG(ERR, "stat_car_b_type failed.");
11076 : 0 : return 1;
11077 : : }
11078 : :
11079 : 0 : ret = *(uint8_t *)resp_buffer;
11080 : : }
11081 : :
11082 : : return ret;
11083 : : }
11084 : :
11085 : : static uint32_t
11086 : 0 : zxdh_np_agent_channel_plcr_profileid_release(uint32_t dev_id, uint32_t vport,
11087 : : uint32_t car_type __rte_unused,
11088 : : uint32_t profileid)
11089 : : {
11090 : : uint32_t ret = 0;
11091 : 0 : uint32_t resp_buffer[2] = {0};
11092 : :
11093 : 0 : ZXDH_AGENT_CHANNEL_PLCR_MSG_T msgcfg = {
11094 : : .dev_id = 0,
11095 : : .type = ZXDH_PLCR_MSG,
11096 : : .oper = ZXDH_PROFILEID_RELEASE,
11097 : : .vport = vport,
11098 : : .profile_id = profileid,
11099 : : };
11100 : :
11101 : 0 : ret = zxdh_np_agent_channel_plcr_sync_send(dev_id, &msgcfg,
11102 : : resp_buffer, sizeof(resp_buffer));
11103 [ # # ]: 0 : if (ret != 0) {
11104 : 0 : PMD_DRV_LOG(ERR, "agent_channel_plcr_sync_send failed.");
11105 : 0 : return 1;
11106 : : }
11107 : :
11108 : 0 : ret = *(uint8_t *)resp_buffer;
11109 : :
11110 : 0 : return ret;
11111 : : }
11112 : :
11113 : : static uint32_t
11114 : 0 : zxdh_np_stat_cara_queue_cfg_set(uint32_t dev_id,
11115 : : uint32_t flow_id,
11116 : : uint32_t drop_flag,
11117 : : uint32_t plcr_en,
11118 : : uint32_t profile_id)
11119 : : {
11120 : : uint32_t rc = 0;
11121 : :
11122 : 0 : ZXDH_STAT_CAR0_CARA_QUEUE_RAM0_159_0_T queue_cfg = {
11123 : : .cara_drop = drop_flag,
11124 : : .cara_plcr_en = plcr_en,
11125 : : .cara_profile_id = profile_id,
11126 : : };
11127 : :
11128 : 0 : rc = zxdh_np_reg_write(dev_id,
11129 : : ZXDH_STAT_CAR0_CARA_QUEUE_RAM0,
11130 : : 0,
11131 : : flow_id,
11132 : : &queue_cfg);
11133 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
11134 : :
11135 : 0 : return rc;
11136 : : }
11137 : :
11138 : : static uint32_t
11139 : 0 : zxdh_np_stat_carb_queue_cfg_set(uint32_t dev_id,
11140 : : uint32_t flow_id,
11141 : : uint32_t drop_flag,
11142 : : uint32_t plcr_en,
11143 : : uint32_t profile_id)
11144 : : {
11145 : : uint32_t rc = 0;
11146 : :
11147 : 0 : ZXDH_STAT_CAR0_CARB_QUEUE_RAM0_159_0_T queue_cfg = {
11148 : : .carb_drop = drop_flag,
11149 : : .carb_plcr_en = plcr_en,
11150 : : .carb_profile_id = profile_id,
11151 : : };
11152 : :
11153 : 0 : rc = zxdh_np_reg_write(dev_id,
11154 : : ZXDH_STAT_CAR0_CARB_QUEUE_RAM0,
11155 : : 0,
11156 : : flow_id,
11157 : : &queue_cfg);
11158 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
11159 : :
11160 : 0 : return rc;
11161 : : }
11162 : :
11163 : : static uint32_t
11164 : 0 : zxdh_np_stat_carc_queue_cfg_set(uint32_t dev_id,
11165 : : uint32_t flow_id,
11166 : : uint32_t drop_flag,
11167 : : uint32_t plcr_en,
11168 : : uint32_t profile_id)
11169 : : {
11170 : : uint32_t rc = 0;
11171 : :
11172 : 0 : ZXDH_STAT_CAR0_CARC_QUEUE_RAM0_159_0_T queue_cfg = {
11173 : : .carc_drop = drop_flag,
11174 : : .carc_plcr_en = plcr_en,
11175 : : .carc_profile_id = profile_id,
11176 : : };
11177 : :
11178 : 0 : rc = zxdh_np_reg_write(dev_id,
11179 : : ZXDH_STAT_CAR0_CARC_QUEUE_RAM0,
11180 : : 0,
11181 : : flow_id,
11182 : : &queue_cfg);
11183 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
11184 : :
11185 : 0 : return rc;
11186 : : }
11187 : :
11188 : : uint32_t
11189 : 0 : zxdh_np_car_profile_id_add(uint32_t dev_id,
11190 : : uint32_t vport_id,
11191 : : uint32_t flags,
11192 : : uint64_t *p_profile_id)
11193 : : {
11194 : : uint32_t ret = 0;
11195 : : uint32_t *profile_id;
11196 : : uint32_t profile_id_h = 0;
11197 : : uint32_t profile_id_l = 0;
11198 : : uint64_t temp_profile_id = 0;
11199 : :
11200 : 0 : profile_id = rte_zmalloc(NULL, ZXDH_G_PROFILE_ID_LEN, 0);
11201 [ # # ]: 0 : if (profile_id == NULL) {
11202 : 0 : PMD_DRV_LOG(ERR, "profile_id point null!");
11203 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11204 : : }
11205 : 0 : ret = zxdh_np_agent_channel_plcr_profileid_request(dev_id, vport_id, flags, profile_id);
11206 : :
11207 : 0 : profile_id_h = *(profile_id + 1);
11208 : 0 : profile_id_l = *profile_id;
11209 : 0 : rte_free(profile_id);
11210 : :
11211 : 0 : temp_profile_id = (((uint64_t)profile_id_l) << 32) | ((uint64_t)profile_id_h);
11212 [ # # ]: 0 : if (0 != (uint32_t)(temp_profile_id >> 56)) {
11213 : 0 : PMD_DRV_LOG(ERR, "profile_id is overflow!");
11214 : 0 : return 1;
11215 : : }
11216 : :
11217 : 0 : *p_profile_id = temp_profile_id;
11218 : :
11219 : 0 : return ret;
11220 : : }
11221 : :
11222 : : uint32_t
11223 : 0 : zxdh_np_car_profile_cfg_set(uint32_t dev_id,
11224 : : uint32_t vport_id __rte_unused,
11225 : : uint32_t car_type,
11226 : : uint32_t pkt_sign,
11227 : : uint32_t profile_id,
11228 : : void *p_car_profile_cfg)
11229 : : {
11230 : : uint32_t ret = 0;
11231 : :
11232 : 0 : ret = zxdh_np_agent_channel_plcr_car_rate(dev_id, car_type,
11233 : : pkt_sign, profile_id, p_car_profile_cfg);
11234 [ # # ]: 0 : if (ret != 0) {
11235 : 0 : PMD_DRV_LOG(ERR, "plcr_car_rate set failed!");
11236 : 0 : return 1;
11237 : : }
11238 : :
11239 : : return ret;
11240 : : }
11241 : :
11242 : : uint32_t
11243 : 0 : zxdh_np_car_profile_id_delete(uint32_t dev_id, uint32_t vport_id,
11244 : : uint32_t flags, uint64_t profile_id)
11245 : : {
11246 : : uint32_t ret = 0;
11247 : 0 : uint32_t profileid = profile_id & 0xFFFF;
11248 : :
11249 : 0 : ret = zxdh_np_agent_channel_plcr_profileid_release(dev_id, vport_id, flags, profileid);
11250 [ # # ]: 0 : if (ret != 0) {
11251 : 0 : PMD_DRV_LOG(ERR, "plcr profiled id release failed!");
11252 : 0 : return 1;
11253 : : }
11254 : :
11255 : : return 0;
11256 : : }
11257 : :
11258 : : uint32_t
11259 : 0 : zxdh_np_stat_car_queue_cfg_set(uint32_t dev_id,
11260 : : uint32_t car_type,
11261 : : uint32_t flow_id,
11262 : : uint32_t drop_flag,
11263 : : uint32_t plcr_en,
11264 : : uint32_t profile_id)
11265 : : {
11266 : : uint32_t rc = 0;
11267 : :
11268 [ # # ]: 0 : if (car_type == ZXDH_STAT_CAR_A_TYPE) {
11269 [ # # ]: 0 : if (flow_id > ZXDH_CAR_A_FLOW_ID_MAX) {
11270 : 0 : PMD_DRV_LOG(ERR, "stat car a type flow_id invalid!");
11271 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11272 : : }
11273 : :
11274 [ # # ]: 0 : if (profile_id > ZXDH_CAR_A_PROFILE_ID_MAX) {
11275 : 0 : PMD_DRV_LOG(ERR, "stat car a type profile_id invalid!");
11276 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11277 : : }
11278 [ # # ]: 0 : } else if (car_type == ZXDH_STAT_CAR_B_TYPE) {
11279 [ # # ]: 0 : if (flow_id > ZXDH_CAR_B_FLOW_ID_MAX) {
11280 : 0 : PMD_DRV_LOG(ERR, "stat car b type flow_id invalid!");
11281 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11282 : : }
11283 : :
11284 [ # # ]: 0 : if (profile_id > ZXDH_CAR_B_PROFILE_ID_MAX) {
11285 : 0 : PMD_DRV_LOG(ERR, "stat car b type profile_id invalid!");
11286 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11287 : : }
11288 : : } else {
11289 [ # # ]: 0 : if (flow_id > ZXDH_CAR_C_FLOW_ID_MAX) {
11290 : 0 : PMD_DRV_LOG(ERR, "stat car c type flow_id invalid!");
11291 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11292 : : }
11293 : :
11294 [ # # ]: 0 : if (profile_id > ZXDH_CAR_C_PROFILE_ID_MAX) {
11295 : 0 : PMD_DRV_LOG(ERR, "stat car c type profile_id invalid!");
11296 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11297 : : }
11298 : : }
11299 : :
11300 [ # # # # ]: 0 : switch (car_type) {
11301 : 0 : case ZXDH_STAT_CAR_A_TYPE:
11302 : 0 : rc = zxdh_np_stat_cara_queue_cfg_set(dev_id,
11303 : : flow_id,
11304 : : drop_flag,
11305 : : plcr_en,
11306 : : profile_id);
11307 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_cara_queue_cfg_set");
11308 : : break;
11309 : :
11310 : 0 : case ZXDH_STAT_CAR_B_TYPE:
11311 : 0 : rc = zxdh_np_stat_carb_queue_cfg_set(dev_id,
11312 : : flow_id,
11313 : : drop_flag,
11314 : : plcr_en,
11315 : : profile_id);
11316 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_carb_queue_cfg_set");
11317 : : break;
11318 : :
11319 : 0 : case ZXDH_STAT_CAR_C_TYPE:
11320 : 0 : rc = zxdh_np_stat_carc_queue_cfg_set(dev_id,
11321 : : flow_id,
11322 : : drop_flag,
11323 : : plcr_en,
11324 : : profile_id);
11325 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_carc_queue_cfg_set");
11326 : : break;
11327 : : }
11328 : :
11329 : : return rc;
11330 : : }
11331 : :
11332 : : uint32_t
11333 : 0 : zxdh_np_dtb_acl_index_request(uint32_t dev_id,
11334 : : uint32_t sdt_no, uint32_t vport, uint32_t *p_index)
11335 : : {
11336 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
11337 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11338 : :
11339 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
11340 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11341 [ # # ]: 0 : if (sdt_acl.table_type != ZXDH_SDT_TBLT_ETCAM) {
11342 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
11343 : : sdt_no, sdt_acl.table_type);
11344 : 0 : return ZXDH_ERR;
11345 : : }
11346 : :
11347 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
11348 : :
11349 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
11350 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11351 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
11352 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
11353 : : eram_sdt_no, sdt_eram.table_type);
11354 : 0 : return ZXDH_ERR;
11355 : : }
11356 : :
11357 : 0 : uint32_t index = 0;
11358 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
11359 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
11360 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
11361 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
11362 : :
11363 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
11364 : 0 : rc = zxdh_np_agent_channel_acl_index_request(dev_id, sdt_no, vport, &index);
11365 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
11366 : :
11367 : 0 : *p_index = index;
11368 : :
11369 : 0 : return rc;
11370 : : }
11371 : :
11372 : : uint32_t
11373 : 0 : zxdh_np_dtb_acl_index_release(uint32_t dev_id,
11374 : : uint32_t sdt_no, uint32_t vport, uint32_t index)
11375 : : {
11376 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
11377 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11378 : :
11379 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
11380 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11381 [ # # ]: 0 : if (sdt_acl.table_type != ZXDH_SDT_TBLT_ETCAM) {
11382 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
11383 : : sdt_no, sdt_acl.table_type);
11384 : 0 : return ZXDH_ERR;
11385 : : }
11386 : :
11387 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
11388 : :
11389 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
11390 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11391 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
11392 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
11393 : : eram_sdt_no, sdt_eram.table_type);
11394 : 0 : return ZXDH_ERR;
11395 : : }
11396 : :
11397 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
11398 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
11399 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
11400 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
11401 : :
11402 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
11403 : :
11404 : 0 : rc = zxdh_np_agent_channel_acl_index_release(dev_id,
11405 : : ZXDH_ACL_INDEX_RELEASE, sdt_no, vport, index);
11406 : :
11407 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
11408 : :
11409 : 0 : return rc;
11410 : : }
11411 : :
11412 : : static uint32_t
11413 : 0 : zxdh_np_dtb_sdt_eram_table_dump(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no,
11414 : : uint32_t start_index, uint32_t depth, uint32_t *p_data, uint32_t *element_id)
11415 : : {
11416 : 0 : uint32_t dump_item_index = 0;
11417 : 0 : uint64_t dump_sdt_phy_addr = 0;
11418 : 0 : uint64_t dump_sdt_vir_addr = 0;
11419 : 0 : uint32_t dump_addr_size = 0;
11420 : :
11421 : 0 : uint32_t rc = zxdh_np_dtb_dump_sdt_addr_get(dev_id,
11422 : : queue_id,
11423 : : sdt_no,
11424 : : &dump_sdt_phy_addr,
11425 : : &dump_sdt_vir_addr,
11426 : : &dump_addr_size);
11427 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_get");
11428 : :
11429 : 0 : memset((uint8_t *)dump_sdt_vir_addr, 0, dump_addr_size);
11430 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &dump_item_index);
11431 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_free_item_get");
11432 : 0 : PMD_DRV_LOG(DEBUG, "dump queue id %u, element_id is: %u.",
11433 : : queue_id, dump_item_index);
11434 : :
11435 : 0 : *element_id = dump_item_index;
11436 : :
11437 : 0 : rc = zxdh_np_dtb_tab_up_item_user_addr_set(dev_id,
11438 : : queue_id,
11439 : : dump_item_index,
11440 : : dump_sdt_phy_addr,
11441 : : dump_sdt_vir_addr);
11442 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_set");
11443 : :
11444 : 0 : uint32_t dump_dst_phy_haddr = 0;
11445 : 0 : uint32_t dump_dst_phy_laddr = 0;
11446 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, dump_item_index,
11447 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
11448 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_get");
11449 : :
11450 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
11451 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11452 : :
11453 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram);
11454 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11455 : :
11456 : 0 : uint32_t eram_base_addr = sdt_eram.eram_base_addr;
11457 : 0 : uint32_t dump_addr_128bit = eram_base_addr + start_index;
11458 : :
11459 : 0 : rc = zxdh_np_dtb_smmu0_dump_info_write(dev_id,
11460 : : dump_addr_128bit,
11461 : : depth,
11462 : : dump_dst_phy_haddr,
11463 : : dump_dst_phy_laddr,
11464 : : (uint32_t *)form_buff);
11465 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_dump_info_write");
11466 : :
11467 : 0 : uint32_t dump_data_len = depth * 128 / 32;
11468 : : uint32_t dump_desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
11469 : :
11470 [ # # ]: 0 : if (dump_data_len * 4 > dump_addr_size) {
11471 : 0 : PMD_DRV_LOG(ERR, "eram dump size is too small!");
11472 : 0 : return ZXDH_RC_DTB_DUMP_SIZE_SMALL;
11473 : : }
11474 : :
11475 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id,
11476 : : queue_id,
11477 : : dump_item_index,
11478 : : (uint32_t *)form_buff,
11479 : : dump_data_len,
11480 : : dump_desc_len,
11481 : : p_data);
11482 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_desc_info");
11483 : :
11484 : : return rc;
11485 : : }
11486 : :
11487 : : static uint32_t
11488 : 0 : zxdh_np_dtb_eram_table_dump(uint32_t dev_id,
11489 : : uint32_t queue_id,
11490 : : uint32_t sdt_no,
11491 : : ZXDH_DTB_DUMP_INDEX_T start_index,
11492 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_data_arr,
11493 : : uint32_t *entry_num,
11494 : : __rte_unused ZXDH_DTB_DUMP_INDEX_T *next_start_index,
11495 : : uint32_t *finish_flag)
11496 : : {
11497 : : uint32_t start_index_128bit = 0;
11498 : : uint32_t col_index = 0;
11499 : : uint32_t dump_depth_128bit = 0;
11500 : 0 : uint32_t element_id = 0;
11501 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11502 : :
11503 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram);
11504 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11505 : :
11506 : 0 : uint32_t dump_mode = sdt_eram.eram_mode;
11507 [ # # # # ]: 0 : uint32_t eram_table_depth = sdt_eram.eram_table_depth;
11508 : :
11509 : : zxdh_np_eram_index_cal(dump_mode, eram_table_depth,
11510 : : &dump_depth_128bit, &col_index);
11511 : :
11512 : : zxdh_np_eram_index_cal(dump_mode, start_index.index,
11513 : : &start_index_128bit, &col_index);
11514 : :
11515 : 0 : uint32_t dump_depth = dump_depth_128bit - start_index_128bit;
11516 : :
11517 : 0 : uint8_t *dump_data_buff = malloc(dump_depth * ZXDH_DTB_LEN_POS_SETP);
11518 [ # # ]: 0 : if (dump_data_buff == NULL) {
11519 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
11520 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11521 : : }
11522 : :
11523 : 0 : rc = zxdh_np_dtb_sdt_eram_table_dump(dev_id,
11524 : : queue_id,
11525 : : sdt_no,
11526 : : start_index_128bit,
11527 : : dump_depth,
11528 : : (uint32_t *)dump_data_buff,
11529 : : &element_id);
11530 : :
11531 [ # # ]: 0 : if (dump_mode == ZXDH_ERAM128_TBL_128b) {
11532 [ # # ]: 0 : for (uint32_t i = 0; i < dump_depth; i++) {
11533 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_user_data = p_dump_data_arr + i;
11534 : 0 : uint8_t *temp_data = dump_data_buff + i * ZXDH_DTB_LEN_POS_SETP;
11535 [ # # # # ]: 0 : if (p_dump_user_data == NULL || p_dump_user_data->p_data == NULL) {
11536 : 0 : PMD_DRV_LOG(ERR, "data buff is NULL!");
11537 : 0 : free(dump_data_buff);
11538 : 0 : return ZXDH_ERR;
11539 : : }
11540 : :
11541 : 0 : p_dump_user_data->index = start_index.index + i;
11542 : : memcpy(p_dump_user_data->p_data, temp_data, (128 / 8));
11543 : : }
11544 [ # # ]: 0 : } else if (dump_mode == ZXDH_ERAM128_TBL_64b) {
11545 : : uint32_t row_index = 0;
11546 : 0 : uint32_t remain = start_index.index % 2;
11547 [ # # ]: 0 : for (uint32_t i = 0; i < eram_table_depth - start_index.index; i++) {
11548 : : zxdh_np_eram_index_cal(dump_mode, remain, &row_index, &col_index);
11549 : 0 : uint8_t *temp_data = dump_data_buff + row_index * ZXDH_DTB_LEN_POS_SETP;
11550 : :
11551 : : uint32_t *buff = (uint32_t *)temp_data;
11552 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_user_data = p_dump_data_arr + i;
11553 : :
11554 [ # # # # ]: 0 : if (p_dump_user_data == NULL || p_dump_user_data->p_data == NULL) {
11555 : 0 : PMD_DRV_LOG(ERR, "data buff is NULL!");
11556 : 0 : free(dump_data_buff);
11557 : : return ZXDH_ERR;
11558 : : }
11559 : :
11560 : 0 : p_dump_user_data->index = start_index.index + i;
11561 : : memcpy(p_dump_user_data->p_data,
11562 : 0 : buff + ((1 - col_index) << 1), (64 / 8));
11563 : :
11564 : 0 : remain++;
11565 : : }
11566 : : }
11567 : :
11568 : 0 : *entry_num = eram_table_depth - start_index.index;
11569 : 0 : *finish_flag = 1;
11570 : 0 : PMD_DRV_LOG(DEBUG, "dump entry num %u, finish flag %u", *entry_num, *finish_flag);
11571 : :
11572 : 0 : free(dump_data_buff);
11573 : :
11574 : 0 : return ZXDH_OK;
11575 : : }
11576 : :
11577 : : static uint32_t
11578 : 0 : zxdh_np_dtb_acl_index_parse(uint32_t dev_id,
11579 : : uint32_t queue_id,
11580 : : uint32_t eram_sdt_no,
11581 : : uint32_t vport,
11582 : : uint32_t *index_num,
11583 : : uint32_t *p_index_array)
11584 : : {
11585 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
11586 : :
11587 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
11588 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11589 : :
11590 [ # # ]: 0 : uint32_t byte_num = (sdt_eram.eram_mode == ZXDH_ERAM128_TBL_64b) ? 8 : 16;
11591 : 0 : uint32_t eram_table_depth = sdt_eram.eram_table_depth;
11592 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_data_arr = malloc(eram_table_depth *
11593 : : sizeof(ZXDH_DTB_ERAM_ENTRY_INFO_T));
11594 [ # # ]: 0 : if (p_dump_data_arr == NULL) {
11595 : 0 : PMD_DRV_LOG(ERR, "p_dump_data_arr point null!");
11596 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11597 : : }
11598 : :
11599 : 0 : uint8_t *data_buff = malloc(byte_num * eram_table_depth);
11600 [ # # ]: 0 : if (data_buff == NULL) {
11601 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
11602 : 0 : free(p_dump_data_arr);
11603 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11604 : : }
11605 : :
11606 [ # # ]: 0 : for (uint32_t i = 0; i < eram_table_depth; i++) {
11607 : 0 : p_dump_data_arr[i].index = i;
11608 : 0 : p_dump_data_arr[i].p_data = (uint32_t *)(data_buff + i * byte_num);
11609 : : }
11610 : :
11611 : 0 : uint32_t entry_num = 0;
11612 : : uint32_t valid_entry_num = 0;
11613 : 0 : uint32_t finish_flag = 0;
11614 : 0 : ZXDH_DTB_DUMP_INDEX_T start_index = {0};
11615 : 0 : ZXDH_DTB_DUMP_INDEX_T next_start_index = {0};
11616 : 0 : rc = zxdh_np_dtb_eram_table_dump(dev_id,
11617 : : queue_id,
11618 : : eram_sdt_no,
11619 : : start_index,
11620 : : p_dump_data_arr,
11621 : : &entry_num,
11622 : : &next_start_index,
11623 : : &finish_flag);
11624 : :
11625 [ # # ]: 0 : for (uint32_t i = 0; i < entry_num; i++) {
11626 : 0 : uint8_t valid = (p_dump_data_arr[i].p_data[0] >> 31) & 0x1;
11627 : 0 : uint32_t temp_vport = p_dump_data_arr[i].p_data[0] & 0x7fffffff;
11628 [ # # ]: 0 : if (valid && temp_vport == vport) {
11629 : 0 : p_index_array[valid_entry_num] = i;
11630 : 0 : valid_entry_num++;
11631 : : }
11632 : : }
11633 : :
11634 : 0 : *index_num = valid_entry_num;
11635 : 0 : free(data_buff);
11636 : 0 : free(p_dump_data_arr);
11637 : :
11638 : 0 : return rc;
11639 : : }
11640 : :
11641 : : static uint32_t
11642 : 0 : zxdh_np_dtb_etcam_ind_data_get(uint8_t *p_in_data, uint32_t rd_mode, uint8_t *p_out_data)
11643 : : {
11644 : : uint8_t buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11645 : :
11646 : : memcpy(buff, p_in_data, ZXDH_ETCAM_WIDTH_MAX / 8);
11647 : : zxdh_np_comm_swap(buff, ZXDH_ETCAM_WIDTH_MAX / 8);
11648 : :
11649 : : uint8_t *p_temp = p_out_data;
11650 [ # # ]: 0 : for (uint32_t i = 0; i < ZXDH_ETCAM_RAM_NUM; i++) {
11651 : 0 : uint32_t offset = i * (ZXDH_ETCAM_WIDTH_MIN / 8);
11652 : :
11653 [ # # ]: 0 : if ((rd_mode >> (ZXDH_ETCAM_RAM_NUM - 1 - i)) & 0x1) {
11654 : 0 : memcpy(p_temp, buff + offset, ZXDH_ETCAM_WIDTH_MIN / 8);
11655 : 0 : p_temp += ZXDH_ETCAM_WIDTH_MIN / 8;
11656 : : }
11657 : : }
11658 : :
11659 : 0 : return ZXDH_OK;
11660 : : }
11661 : :
11662 : : static uint32_t
11663 : 0 : zxdh_np_dtb_acl_table_dump(uint32_t dev_id,
11664 : : uint32_t queue_id,
11665 : : uint32_t sdt_no,
11666 : : __rte_unused ZXDH_DTB_DUMP_INDEX_T start_index,
11667 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dump_data_arr,
11668 : : uint32_t *p_entry_num,
11669 : : __rte_unused ZXDH_DTB_DUMP_INDEX_T *next_start_index,
11670 : : uint32_t *p_finish_flag)
11671 : : {
11672 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
11673 : :
11674 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
11675 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11676 : 0 : uint32_t etcam_key_mode = sdt_etcam_info.etcam_key_mode;
11677 : 0 : uint32_t etcam_as_mode = sdt_etcam_info.as_rsp_mode;
11678 : 0 : uint32_t etcam_table_id = sdt_etcam_info.etcam_table_id;
11679 : 0 : uint32_t as_enable = sdt_etcam_info.as_en;
11680 : 0 : uint32_t as_eram_baddr = sdt_etcam_info.as_eram_baddr;
11681 : 0 : uint32_t etcam_table_depth = sdt_etcam_info.etcam_table_depth;
11682 : :
11683 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
11684 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
11685 : 0 : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
11686 : :
11687 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
11688 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
11689 : : RTE_ASSERT(0);
11690 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
11691 : : }
11692 : :
11693 : 0 : uint32_t data_byte_size = ZXDH_ETCAM_ENTRY_SIZE_GET(etcam_key_mode);
11694 [ # # ]: 0 : if (data_byte_size > ZXDH_ETCAM_RAM_WIDTH) {
11695 : 0 : PMD_DRV_LOG(ERR, "etcam date size is over 80B!");
11696 : 0 : return ZXDH_ACL_RC_INVALID_PARA;
11697 : : }
11698 : :
11699 : 0 : uint32_t dump_element_id = 0;
11700 : 0 : rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &dump_element_id);
11701 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
11702 : :
11703 : 0 : uint8_t *dump_info_buff = malloc(ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE);
11704 [ # # ]: 0 : if (dump_info_buff == NULL) {
11705 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
11706 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11707 : : }
11708 : :
11709 : : uint32_t dtb_desc_addr_offset = 0;
11710 : : uint32_t dump_data_len = 0;
11711 : : uint32_t dtb_desc_len = 0;
11712 : : uint32_t etcam_data_len_offset = 0;
11713 : : uint32_t etcam_mask_len_offset = 0;
11714 : 0 : uint32_t block_num = p_tbl_cfg->block_num;
11715 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
11716 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
11717 : 0 : dtb_dump_entry.cmd = cmd_buff;
11718 : :
11719 [ # # ]: 0 : for (uint32_t i = 0; i < block_num; i++) {
11720 : 0 : ZXDH_ETCAM_DUMP_INFO_T etcam_dump_info = {0};
11721 : : uint32_t etcam_data_dst_phy_haddr = 0;
11722 : : uint32_t etcam_data_dst_phy_laddr = 0;
11723 : 0 : uint32_t block_idx = p_tbl_cfg->block_array[i];
11724 : :
11725 : 0 : PMD_DRV_LOG(DEBUG, "block_idx: %u", block_idx);
11726 : :
11727 : 0 : etcam_dump_info.block_sel = block_idx;
11728 : : etcam_dump_info.addr = 0;
11729 : 0 : etcam_dump_info.tb_width = 3;
11730 : 0 : etcam_dump_info.rd_mode = 0xFF;
11731 : 0 : etcam_dump_info.tb_depth = ZXDH_ETCAM_RAM_DEPTH;
11732 : 0 : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_DATA;
11733 : :
11734 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
11735 : : queue_id,
11736 : : dump_element_id,
11737 : : dump_data_len,
11738 : : &etcam_data_dst_phy_haddr,
11739 : : &etcam_data_dst_phy_laddr);
11740 : :
11741 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
11742 : : &etcam_dump_info,
11743 : : etcam_data_dst_phy_haddr,
11744 : : etcam_data_dst_phy_laddr,
11745 : : &dtb_dump_entry);
11746 : :
11747 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
11748 : :
11749 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
11750 : :
11751 : 0 : dtb_desc_len += 1;
11752 : 0 : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
11753 : 0 : dump_data_len += ZXDH_ETCAM_RAM_DEPTH * 640 / 8;
11754 : : }
11755 : :
11756 : : etcam_data_len_offset = dump_data_len;
11757 : :
11758 [ # # ]: 0 : for (uint32_t i = 0; i < block_num; i++) {
11759 : 0 : ZXDH_ETCAM_DUMP_INFO_T etcam_dump_info = {0};
11760 : : uint32_t etcam_mask_dst_phy_haddr = 0;
11761 : : uint32_t etcam_mask_dst_phy_laddr = 0;
11762 : 0 : uint32_t block_idx = p_tbl_cfg->block_array[i];
11763 : :
11764 : 0 : PMD_DRV_LOG(DEBUG, "mask: block_idx: %u", block_idx);
11765 : :
11766 : 0 : etcam_dump_info.block_sel = block_idx;
11767 : : etcam_dump_info.addr = 0;
11768 : 0 : etcam_dump_info.tb_width = 3;
11769 : 0 : etcam_dump_info.rd_mode = 0xFF;
11770 : 0 : etcam_dump_info.tb_depth = ZXDH_ETCAM_RAM_DEPTH;
11771 : : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_MASK;
11772 : :
11773 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
11774 : : queue_id,
11775 : : dump_element_id,
11776 : : dump_data_len,
11777 : : &etcam_mask_dst_phy_haddr,
11778 : : &etcam_mask_dst_phy_laddr);
11779 : :
11780 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
11781 : : &etcam_dump_info,
11782 : : etcam_mask_dst_phy_haddr,
11783 : : etcam_mask_dst_phy_laddr,
11784 : : &dtb_dump_entry);
11785 : :
11786 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
11787 : :
11788 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
11789 : :
11790 : 0 : dtb_desc_len += 1;
11791 : 0 : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
11792 : 0 : dump_data_len += ZXDH_ETCAM_RAM_DEPTH * 640 / 8;
11793 : : }
11794 : : etcam_mask_len_offset = dump_data_len;
11795 : :
11796 [ # # ]: 0 : if (as_enable) {
11797 : : uint32_t as_rst_dst_phy_haddr = 0;
11798 : : uint32_t as_rst_dst_phy_laddr = 0;
11799 : : uint32_t dump_eram_depth_128bit = 0;
11800 : : uint32_t eram_col_index = 0;
11801 : :
11802 : : zxdh_np_eram_index_cal(etcam_as_mode,
11803 : : etcam_table_depth, &dump_eram_depth_128bit, &eram_col_index);
11804 : :
11805 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
11806 : : queue_id,
11807 : : dump_element_id,
11808 : : dump_data_len,
11809 : : &as_rst_dst_phy_haddr,
11810 : : &as_rst_dst_phy_laddr);
11811 : :
11812 : 0 : zxdh_np_dtb_smmu0_dump_entry(dev_id,
11813 : : as_eram_baddr,
11814 : : dump_eram_depth_128bit,
11815 : : as_rst_dst_phy_haddr,
11816 : : as_rst_dst_phy_laddr,
11817 : : &dtb_dump_entry);
11818 : :
11819 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
11820 : :
11821 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
11822 : 0 : dtb_desc_len += 1;
11823 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
11824 : 0 : dump_data_len += dump_eram_depth_128bit * 128 / 8;
11825 : : }
11826 : :
11827 : 0 : uint8_t *temp_dump_out_data = malloc(dump_data_len * sizeof(uint8_t));
11828 [ # # ]: 0 : if (temp_dump_out_data == NULL) {
11829 : 0 : PMD_DRV_LOG(ERR, "temp_dump_out_data point null!");
11830 : 0 : free(dump_info_buff);
11831 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11832 : : }
11833 : :
11834 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id,
11835 : : queue_id,
11836 : : dump_element_id,
11837 : : (uint32_t *)dump_info_buff,
11838 : : dump_data_len / 4,
11839 : : dtb_desc_len * 4,
11840 : : (uint32_t *)temp_dump_out_data);
11841 : 0 : free(dump_info_buff);
11842 : :
11843 : : uint8_t *p_data_start = temp_dump_out_data;
11844 : 0 : uint8_t *p_mask_start = temp_dump_out_data + etcam_data_len_offset;
11845 : : uint8_t *p_rst_start = NULL;
11846 [ # # ]: 0 : if (as_enable)
11847 : 0 : p_rst_start = temp_dump_out_data + etcam_mask_len_offset;
11848 : :
11849 [ # # ]: 0 : for (uint32_t handle = 0; handle < etcam_table_depth; handle++) {
11850 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dump_user_data = p_dump_data_arr + handle;
11851 : :
11852 [ # # ]: 0 : if (p_dump_user_data == NULL ||
11853 [ # # ]: 0 : p_dump_user_data->key_data == NULL ||
11854 [ # # ]: 0 : p_dump_user_data->key_mask == NULL) {
11855 : 0 : PMD_DRV_LOG(ERR, "etcam handle 0x%x data user buff is NULL!", handle);
11856 : 0 : free(temp_dump_out_data);
11857 : 0 : return ZXDH_ERR;
11858 : : }
11859 : :
11860 [ # # ]: 0 : if (as_enable) {
11861 [ # # ]: 0 : if (p_dump_user_data->p_as_rslt == NULL) {
11862 : 0 : PMD_DRV_LOG(ERR, "handle 0x%x data buff is NULL!", handle);
11863 : 0 : free(temp_dump_out_data);
11864 : 0 : return ZXDH_ERR;
11865 : : }
11866 : : }
11867 : :
11868 : 0 : p_dump_user_data->handle = handle;
11869 : :
11870 : 0 : uint32_t shift_amount = 8U >> etcam_key_mode;
11871 : 0 : uint32_t mask_base = (1U << shift_amount) - 1;
11872 : 0 : uint32_t offset = shift_amount * (handle % (1U << etcam_key_mode));
11873 : 0 : uint32_t rd_mask = (mask_base << offset) & 0xFF;
11874 : :
11875 : 0 : uint32_t addr_640bit = handle / (1U << etcam_key_mode);
11876 : 0 : uint8_t *p_data_640bit = p_data_start + addr_640bit * 640 / 8;
11877 : 0 : uint8_t *p_mask_640bit = p_mask_start + addr_640bit * 640 / 8;
11878 : :
11879 : 0 : uint8_t xy_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11880 : 0 : uint8_t xy_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11881 : 0 : uint8_t dm_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11882 : 0 : uint8_t dm_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
11883 : : ZXDH_ETCAM_ENTRY_T entry_xy = {
11884 : : .p_data = xy_data,
11885 : : .p_mask = xy_mask,
11886 : : .mode = 0,
11887 : : };
11888 : : ZXDH_ETCAM_ENTRY_T entry_dm = {
11889 : : .p_data = dm_data,
11890 : : .p_mask = dm_mask,
11891 : : .mode = 0,
11892 : : };
11893 : :
11894 : 0 : zxdh_np_dtb_etcam_ind_data_get(p_data_640bit, rd_mask, entry_xy.p_data);
11895 : 0 : zxdh_np_dtb_etcam_ind_data_get(p_mask_640bit, rd_mask, entry_xy.p_mask);
11896 : :
11897 : : zxdh_np_etcam_xy_to_dm(&entry_dm, &entry_xy, data_byte_size);
11898 : :
11899 [ # # ]: 0 : memcpy(p_dump_user_data->key_data, entry_dm.p_data, data_byte_size);
11900 : 0 : memcpy(p_dump_user_data->key_mask, entry_dm.p_mask, data_byte_size);
11901 : :
11902 [ # # ]: 0 : if (as_enable) {
11903 : : uint32_t eram_row_index = 0;
11904 : : uint32_t eram_col_index = 0;
11905 : :
11906 : : zxdh_np_eram_index_cal(etcam_as_mode,
11907 : : handle, &eram_row_index, &eram_col_index);
11908 : :
11909 : 0 : uint8_t *p_rst_128bit = p_rst_start +
11910 : 0 : eram_row_index * ZXDH_DTB_LEN_POS_SETP;
11911 : : uint32_t *eram_buff = (uint32_t *)p_rst_128bit;
11912 : :
11913 [ # # ]: 0 : if (etcam_as_mode == ZXDH_ERAM128_TBL_128b)
11914 : 0 : memcpy(p_dump_user_data->p_as_rslt, eram_buff, (128 / 8));
11915 [ # # ]: 0 : else if (etcam_as_mode == ZXDH_ERAM128_TBL_64b)
11916 : 0 : memcpy(p_dump_user_data->p_as_rslt,
11917 : 0 : eram_buff + ((1 - eram_col_index) << 1), (64 / 8));
11918 : : }
11919 : : }
11920 : :
11921 : 0 : *p_entry_num = etcam_table_depth;
11922 : 0 : *p_finish_flag = 1;
11923 : :
11924 : 0 : free(temp_dump_out_data);
11925 : :
11926 : 0 : return ZXDH_OK;
11927 : : }
11928 : :
11929 : : static uint32_t
11930 : : zxdh_np_smmu0_tbl_size_get(uint32_t eram_mode)
11931 : : {
11932 : : uint32_t size = 0;
11933 : : if (eram_mode == ZXDH_ERAM128_TBL_128b)
11934 : : size = 16;
11935 : : else if (eram_mode == ZXDH_ERAM128_TBL_64b)
11936 : : size = 8;
11937 : : else if (eram_mode == ZXDH_ERAM128_TBL_32b)
11938 : : size = 4;
11939 : : else
11940 : : size = 1;
11941 : :
11942 : : return size;
11943 : : }
11944 : :
11945 : : static uint32_t
11946 : 0 : zxdh_np_dtb_acl_data_get_by_handle(uint32_t dev_id,
11947 : : uint32_t queue_id,
11948 : : uint32_t sdt_no,
11949 : : uint32_t index_num,
11950 : : uint32_t *p_index_array,
11951 : : uint8_t *p_dump_data)
11952 : : {
11953 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
11954 : :
11955 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
11956 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
11957 [ # # ]: 0 : if (sdt_etcam_info.table_type != ZXDH_SDT_TBLT_ETCAM) {
11958 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
11959 : : sdt_no, sdt_etcam_info.table_type);
11960 : 0 : return ZXDH_ERR;
11961 : : }
11962 : :
11963 : 0 : uint32_t etcam_key_mode = sdt_etcam_info.etcam_key_mode;
11964 : 0 : uint32_t etcam_table_depth = sdt_etcam_info.etcam_table_depth;
11965 [ # # ]: 0 : uint32_t as_len = zxdh_np_smmu0_tbl_size_get(sdt_etcam_info.as_rsp_mode);
11966 : 0 : uint32_t data_byte_size = ZXDH_ETCAM_ENTRY_SIZE_GET(etcam_key_mode);
11967 : :
11968 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dtb_acl_entry = malloc(etcam_table_depth *
11969 : : sizeof(ZXDH_DTB_ACL_ENTRY_INFO_T));
11970 [ # # ]: 0 : if (p_dtb_acl_entry == NULL) {
11971 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
11972 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11973 : : }
11974 : :
11975 : 0 : uint8_t *data_buff = malloc(etcam_table_depth * data_byte_size);
11976 [ # # ]: 0 : if (data_buff == NULL) {
11977 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
11978 : 0 : free(p_dtb_acl_entry);
11979 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11980 : : }
11981 : :
11982 : 0 : uint8_t *mask_buff = malloc(etcam_table_depth * data_byte_size);
11983 [ # # ]: 0 : if (mask_buff == NULL) {
11984 : 0 : PMD_DRV_LOG(ERR, "mask_buff point null!");
11985 : 0 : free(data_buff);
11986 : 0 : free(p_dtb_acl_entry);
11987 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11988 : : }
11989 : :
11990 : 0 : uint8_t *eram_buff = malloc(etcam_table_depth * as_len);
11991 [ # # ]: 0 : if (eram_buff == NULL) {
11992 : 0 : PMD_DRV_LOG(ERR, "eram_buff point null!");
11993 : 0 : free(mask_buff);
11994 : 0 : free(data_buff);
11995 : 0 : free(p_dtb_acl_entry);
11996 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11997 : : }
11998 : :
11999 [ # # ]: 0 : for (uint32_t i = 0; i < etcam_table_depth; i++) {
12000 : 0 : p_dtb_acl_entry[i].handle = i;
12001 : 0 : p_dtb_acl_entry[i].key_data = data_buff + i * data_byte_size;
12002 : 0 : p_dtb_acl_entry[i].key_mask = mask_buff + i * data_byte_size;
12003 : 0 : p_dtb_acl_entry[i].p_as_rslt = eram_buff + i * as_len;
12004 : : }
12005 : :
12006 : 0 : uint32_t entry_num = 0;
12007 : 0 : uint32_t finish_flag = 0;
12008 : 0 : ZXDH_DTB_DUMP_INDEX_T start_index = {0};
12009 : 0 : ZXDH_DTB_DUMP_INDEX_T next_start_index = {0};
12010 : 0 : rc = zxdh_np_dtb_acl_table_dump(dev_id,
12011 : : queue_id,
12012 : : sdt_no,
12013 : : start_index,
12014 : : p_dtb_acl_entry,
12015 : : &entry_num,
12016 : : &next_start_index,
12017 : : &finish_flag);
12018 [ # # ]: 0 : if (rc != ZXDH_OK) {
12019 : 0 : PMD_DRV_LOG(ERR, "acl sdt[%u] dump fail, rc:0x%x", sdt_no, rc);
12020 : 0 : free(data_buff);
12021 : 0 : free(mask_buff);
12022 : 0 : free(eram_buff);
12023 : 0 : free(p_dtb_acl_entry);
12024 : 0 : return rc;
12025 : : }
12026 : :
12027 [ # # ]: 0 : for (uint32_t i = 0; i < index_num; i++) {
12028 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dump_entry =
12029 : 0 : ((ZXDH_DTB_ACL_ENTRY_INFO_T *)p_dump_data) + i;
12030 : 0 : p_dump_entry->handle = p_index_array[i];
12031 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_temp_entry = p_dtb_acl_entry + p_index_array[i];
12032 : 0 : memcpy(p_dump_entry->key_data, p_temp_entry->key_data, data_byte_size);
12033 : 0 : memcpy(p_dump_entry->key_mask, p_temp_entry->key_mask, data_byte_size);
12034 : 0 : memcpy(p_dump_entry->p_as_rslt, p_temp_entry->p_as_rslt, as_len);
12035 : : }
12036 : :
12037 : 0 : free(data_buff);
12038 : 0 : free(mask_buff);
12039 : 0 : free(eram_buff);
12040 : 0 : free(p_dtb_acl_entry);
12041 : :
12042 : 0 : return rc;
12043 : : }
12044 : :
12045 : : uint32_t
12046 : 0 : zxdh_np_dtb_acl_table_dump_by_vport(uint32_t dev_id, uint32_t queue_id,
12047 : : uint32_t sdt_no, uint32_t vport, uint32_t *entry_num, uint8_t *p_dump_data)
12048 : : {
12049 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
12050 : :
12051 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
12052 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12053 [ # # ]: 0 : if (sdt_etcam_info.table_type != ZXDH_SDT_TBLT_ETCAM) {
12054 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
12055 : : sdt_no, sdt_etcam_info.table_type);
12056 : 0 : return ZXDH_ERR;
12057 : : }
12058 : :
12059 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
12060 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
12061 : :
12062 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
12063 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12064 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
12065 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
12066 : : eram_sdt_no, sdt_eram.table_type);
12067 : 0 : return ZXDH_ERR;
12068 : : }
12069 : :
12070 : 0 : uint32_t *p_index_array = malloc(sizeof(uint32_t) * sdt_eram.eram_table_depth);
12071 [ # # ]: 0 : if (p_index_array == NULL) {
12072 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12073 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12074 : : }
12075 : :
12076 : 0 : uint32_t index_num = 0;
12077 : 0 : rc = zxdh_np_dtb_acl_index_parse(dev_id, queue_id,
12078 : : eram_sdt_no, vport, &index_num, p_index_array);
12079 [ # # ]: 0 : if (rc != ZXDH_OK) {
12080 : 0 : free(p_index_array);
12081 : 0 : PMD_DRV_LOG(ERR, "acl index parse failed");
12082 : 0 : return ZXDH_ERR;
12083 : : }
12084 : :
12085 [ # # ]: 0 : if (!index_num) {
12086 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] vport[0x%x] item num is zero!", sdt_no, vport);
12087 : 0 : free(p_index_array);
12088 : 0 : return ZXDH_OK;
12089 : : }
12090 : :
12091 : 0 : rc = zxdh_np_dtb_acl_data_get_by_handle(dev_id, queue_id, sdt_no,
12092 : : index_num, p_index_array, p_dump_data);
12093 [ # # ]: 0 : if (rc != ZXDH_OK) {
12094 : 0 : free(p_index_array);
12095 : 0 : PMD_DRV_LOG(ERR, "acl date by handle failed");
12096 : 0 : return ZXDH_ERR;
12097 : : }
12098 : :
12099 : 0 : *entry_num = index_num;
12100 : 0 : free(p_index_array);
12101 : :
12102 : 0 : return ZXDH_OK;
12103 : : }
12104 : :
12105 : : static uint32_t
12106 : 0 : zxdh_np_dtb_acl_dma_insert_cycle(uint32_t dev_id,
12107 : : uint32_t queue_id,
12108 : : uint32_t sdt_no,
12109 : : uint32_t entry_num,
12110 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_acl_entry_arr,
12111 : : uint32_t *element_id)
12112 : : {
12113 : : uint32_t eram_wrt_mode = 0;
12114 : : uint32_t addr_offset_bk = 0;
12115 : : uint32_t dtb_len = 0;
12116 : : uint32_t as_addr_offset = 0;
12117 : : uint32_t as_dtb_len = 0;
12118 : :
12119 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
12120 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
12121 : :
12122 : 0 : ZXDH_DTB_ENTRY_T entry_data = {0};
12123 : 0 : ZXDH_DTB_ENTRY_T entry_mask = {0};
12124 : :
12125 : 0 : uint8_t entry_data_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
12126 : 0 : uint8_t entry_mask_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
12127 : 0 : uint8_t entry_data_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
12128 : 0 : uint8_t entry_mask_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
12129 : :
12130 : 0 : entry_data.cmd = entry_data_cmd_buff;
12131 : 0 : entry_data.data = entry_data_buff;
12132 : 0 : entry_mask.cmd = entry_mask_cmd_buff;
12133 : 0 : entry_mask.data = entry_mask_buff;
12134 : :
12135 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
12136 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12137 : 0 : uint32_t etcam_as_mode = sdt_etcam_info.as_rsp_mode;
12138 : 0 : uint32_t etcam_table_id = sdt_etcam_info.etcam_table_id;
12139 : 0 : uint32_t as_enable = sdt_etcam_info.as_en;
12140 : 0 : uint32_t as_eram_baddr = sdt_etcam_info.as_eram_baddr;
12141 : :
12142 [ # # ]: 0 : if (as_enable) {
12143 [ # # # # ]: 0 : switch (etcam_as_mode) {
12144 : : case ZXDH_ERAM128_TBL_128b:
12145 : : eram_wrt_mode = ZXDH_ERAM128_OPR_128b;
12146 : : break;
12147 : 0 : case ZXDH_ERAM128_TBL_64b:
12148 : : eram_wrt_mode = ZXDH_ERAM128_OPR_64b;
12149 : 0 : break;
12150 : 0 : case ZXDH_ERAM128_TBL_1b:
12151 : : eram_wrt_mode = ZXDH_ERAM128_OPR_1b;
12152 : 0 : break;
12153 : :
12154 : 0 : default:
12155 : 0 : PMD_DRV_LOG(ERR, "etcam_as_mode is invalid!");
12156 : 0 : return ZXDH_ERR;
12157 : : }
12158 : : }
12159 : :
12160 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
12161 : 0 : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
12162 : :
12163 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
12164 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
12165 : : RTE_ASSERT(0);
12166 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
12167 : : }
12168 : :
12169 : 0 : uint8_t *table_data_buff = malloc(ZXDH_DTB_TABLE_DATA_BUFF_SIZE);
12170 [ # # ]: 0 : if (table_data_buff == NULL) {
12171 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12172 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12173 : : }
12174 : :
12175 [ # # ]: 0 : for (uint32_t item_cnt = 0; item_cnt < entry_num; ++item_cnt) {
12176 : 0 : uint32_t block_idx = 0;
12177 : 0 : uint32_t ram_addr = 0;
12178 : 0 : uint32_t etcam_wr_mode = 0;
12179 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry = {0};
12180 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_acl_entry = p_acl_entry_arr + item_cnt;
12181 : :
12182 : 0 : etcam_entry.mode = p_tbl_cfg->key_mode;
12183 : 0 : etcam_entry.p_data = p_acl_entry->key_data;
12184 : 0 : etcam_entry.p_mask = p_acl_entry->key_mask;
12185 : :
12186 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_acl_entry->handle,
12187 : : &block_idx, &ram_addr, &etcam_wr_mode);
12188 : :
12189 : 0 : zxdh_np_dtb_etcam_entry_add(dev_id,
12190 : : ram_addr,
12191 : : block_idx,
12192 : : etcam_wr_mode,
12193 : : ZXDH_ETCAM_OPR_DM,
12194 : : &etcam_entry,
12195 : : &entry_data,
12196 : : &entry_mask);
12197 : :
12198 : : dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
12199 : 0 : zxdh_np_dtb_data_write(table_data_buff, addr_offset_bk, &entry_data);
12200 : :
12201 : : memset(entry_data_cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
12202 : : memset(entry_data_buff, 0, ZXDH_ETCAM_WIDTH_MAX / 8);
12203 : 0 : addr_offset_bk = addr_offset_bk + ZXDH_DTB_ETCAM_LEN_SIZE * ZXDH_DTB_LEN_POS_SETP;
12204 : :
12205 : 0 : dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
12206 : 0 : zxdh_np_dtb_data_write(table_data_buff, addr_offset_bk, &entry_mask);
12207 : :
12208 : : memset(entry_mask_cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
12209 : : memset(entry_mask_buff, 0, ZXDH_ETCAM_WIDTH_MAX / 8);
12210 : 0 : addr_offset_bk = addr_offset_bk + ZXDH_DTB_ETCAM_LEN_SIZE * ZXDH_DTB_LEN_POS_SETP;
12211 : :
12212 [ # # ]: 0 : if (as_enable) {
12213 : 0 : uint32_t as_eram_data_buff[4] = {0};
12214 : 0 : uint8_t as_eram_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
12215 : 0 : ZXDH_DTB_ENTRY_T dtb_as_data_entry = {0};
12216 : 0 : uint32_t *p_as_eram_data = (uint32_t *)(p_acl_entry->p_as_rslt);
12217 : 0 : uint32_t eram_index = p_acl_entry->handle;
12218 : :
12219 : 0 : dtb_as_data_entry.cmd = as_eram_cmd_buff;
12220 : 0 : dtb_as_data_entry.data = (uint8_t *)as_eram_data_buff;
12221 : :
12222 : 0 : zxdh_np_dtb_se_smmu0_ind_write(dev_id,
12223 : : as_eram_baddr,
12224 : : eram_index,
12225 : : eram_wrt_mode,
12226 : : p_as_eram_data,
12227 : : &dtb_as_data_entry);
12228 : :
12229 [ # # # ]: 0 : switch (eram_wrt_mode) {
12230 : : case ZXDH_ERAM128_OPR_128b:
12231 : : as_dtb_len = 2;
12232 : : as_addr_offset = ZXDH_DTB_LEN_POS_SETP * 2;
12233 : : break;
12234 : 0 : case ZXDH_ERAM128_OPR_64b:
12235 : : as_dtb_len = 1;
12236 : : as_addr_offset = ZXDH_DTB_LEN_POS_SETP;
12237 : 0 : break;
12238 : 0 : case ZXDH_ERAM128_OPR_1b:
12239 : : as_dtb_len = 1;
12240 : : as_addr_offset = ZXDH_DTB_LEN_POS_SETP;
12241 : 0 : break;
12242 : : }
12243 : :
12244 : 0 : zxdh_np_dtb_data_write(table_data_buff,
12245 : : addr_offset_bk, &dtb_as_data_entry);
12246 : 0 : addr_offset_bk = addr_offset_bk + as_addr_offset;
12247 : 0 : dtb_len += as_dtb_len;
12248 : :
12249 : : memset(as_eram_cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
12250 : : memset(as_eram_data_buff, 0, 4 * sizeof(uint32_t));
12251 : : }
12252 : : }
12253 : :
12254 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
12255 : : queue_id,
12256 : : dtb_len * 16,
12257 : : table_data_buff,
12258 : : element_id);
12259 : 0 : free(table_data_buff);
12260 : :
12261 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, *element_id);
12262 : :
12263 : 0 : return rc;
12264 : : }
12265 : :
12266 : : static uint32_t
12267 : 0 : zxdh_np_dtb_acl_dma_insert(uint32_t dev_id,
12268 : : uint32_t queue_id,
12269 : : uint32_t sdt_no,
12270 : : uint32_t entry_num,
12271 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_acl_entry_arr,
12272 : : uint32_t *element_id)
12273 : : {
12274 : : uint32_t entry_num_max = 0;
12275 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
12276 : :
12277 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
12278 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_data_write");
12279 : :
12280 : 0 : uint32_t as_enable = sdt_etcam_info.as_en;
12281 : 0 : uint32_t etcam_as_mode = sdt_etcam_info.as_rsp_mode;
12282 : :
12283 [ # # ]: 0 : if (!as_enable) {
12284 : : entry_num_max = 0x55;
12285 : : } else {
12286 [ # # ]: 0 : if (etcam_as_mode == ZXDH_ERAM128_TBL_128b)
12287 : : entry_num_max = 0x49;
12288 : : else
12289 : : entry_num_max = 0x4e;
12290 : : }
12291 : :
12292 : 0 : uint32_t entry_cycle = entry_num / entry_num_max;
12293 : 0 : uint32_t entry_remains = entry_num % entry_num_max;
12294 : :
12295 [ # # ]: 0 : for (uint32_t i = 0; i < entry_cycle; ++i) {
12296 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_entry = p_acl_entry_arr + entry_num_max * i;
12297 : 0 : rc = zxdh_np_dtb_acl_dma_insert_cycle(dev_id,
12298 : : queue_id,
12299 : : sdt_no,
12300 : : entry_num_max,
12301 : : p_entry,
12302 : : element_id);
12303 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_dma_insert_cycle");
12304 : : }
12305 : :
12306 [ # # ]: 0 : if (entry_remains) {
12307 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_entry = p_acl_entry_arr + entry_num_max * entry_cycle;
12308 : 0 : rc = zxdh_np_dtb_acl_dma_insert_cycle(dev_id,
12309 : : queue_id,
12310 : : sdt_no,
12311 : : entry_remains,
12312 : : p_entry,
12313 : : element_id);
12314 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_dma_insert_cycle");
12315 : : }
12316 : :
12317 : 0 : return rc;
12318 : : }
12319 : :
12320 : : static uint32_t
12321 : 0 : zxdh_np_dtb_acl_data_clear(uint32_t dev_id, uint32_t queue_id,
12322 : : uint32_t sdt_no, uint32_t index_num, uint32_t *p_index_array)
12323 : : {
12324 : 0 : uint32_t element_id = 0;
12325 : : uint32_t *eram_buff = NULL;
12326 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
12327 : :
12328 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
12329 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12330 : :
12331 : 0 : uint32_t etcam_key_mode = sdt_etcam_info.etcam_key_mode;
12332 : 0 : uint32_t as_enable = sdt_etcam_info.as_en;
12333 : 0 : uint32_t data_byte_size = ZXDH_ETCAM_ENTRY_SIZE_GET(etcam_key_mode);
12334 : :
12335 : 0 : ZXDH_DTB_ACL_ENTRY_INFO_T *p_entry_arr = malloc(index_num *
12336 : : sizeof(ZXDH_DTB_ACL_ENTRY_INFO_T));
12337 [ # # ]: 0 : if (p_entry_arr == NULL) {
12338 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12339 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12340 : : }
12341 : :
12342 : 0 : uint8_t *data_buff = malloc(data_byte_size);
12343 [ # # ]: 0 : if (data_buff == NULL) {
12344 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
12345 : 0 : free(p_entry_arr);
12346 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12347 : : }
12348 : :
12349 : 0 : uint8_t *mask_buff = malloc(data_byte_size);
12350 [ # # ]: 0 : if (mask_buff == NULL) {
12351 : 0 : PMD_DRV_LOG(ERR, "mask_buff point null!");
12352 : 0 : free(data_buff);
12353 : 0 : free(p_entry_arr);
12354 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12355 : : }
12356 : :
12357 [ # # ]: 0 : if (as_enable) {
12358 : 0 : eram_buff = malloc(4 * sizeof(uint32_t));
12359 [ # # ]: 0 : if (eram_buff == NULL) {
12360 : 0 : PMD_DRV_LOG(ERR, "eram_buff point null!");
12361 : 0 : free(mask_buff);
12362 : 0 : free(data_buff);
12363 : 0 : free(p_entry_arr);
12364 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12365 : : }
12366 : : memset(eram_buff, 0, 4 * sizeof(uint32_t));
12367 : : }
12368 : :
12369 [ # # ]: 0 : for (uint32_t index = 0; index < index_num; index++) {
12370 : 0 : p_entry_arr[index].handle = p_index_array[index];
12371 : 0 : p_entry_arr[index].key_data = data_buff;
12372 : 0 : p_entry_arr[index].key_mask = mask_buff;
12373 : :
12374 [ # # ]: 0 : if (as_enable)
12375 : 0 : p_entry_arr[index].p_as_rslt = (uint8_t *)eram_buff;
12376 : : }
12377 : :
12378 : 0 : rc = zxdh_np_dtb_acl_dma_insert(dev_id,
12379 : : queue_id,
12380 : : sdt_no,
12381 : : index_num,
12382 : : p_entry_arr,
12383 : : &element_id);
12384 : 0 : free(data_buff);
12385 : 0 : free(mask_buff);
12386 [ # # ]: 0 : if (eram_buff)
12387 : 0 : free(eram_buff);
12388 : :
12389 : 0 : free(p_entry_arr);
12390 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_dma_insert");
12391 : :
12392 : : return rc;
12393 : : }
12394 : :
12395 : : static uint32_t
12396 : 0 : zxdh_np_dtb_acl_index_release_by_vport(uint32_t dev_id,
12397 : : uint32_t sdt_no, uint32_t vport)
12398 : : {
12399 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
12400 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
12401 : :
12402 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
12403 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12404 [ # # ]: 0 : if (sdt_acl.table_type != ZXDH_SDT_TBLT_ETCAM) {
12405 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
12406 : : sdt_no, sdt_acl.table_type);
12407 : 0 : return ZXDH_ERR;
12408 : : }
12409 : :
12410 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
12411 : :
12412 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
12413 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12414 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
12415 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
12416 : : eram_sdt_no, sdt_eram.table_type);
12417 : 0 : return ZXDH_ERR;
12418 : : }
12419 : :
12420 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
12421 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
12422 : :
12423 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
12424 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
12425 : :
12426 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
12427 : :
12428 : 0 : rc = zxdh_np_agent_channel_acl_index_release(dev_id,
12429 : : ZXDH_ACL_INDEX_VPORT_REL, sdt_no, vport, 0);
12430 [ # # ]: 0 : if (rc == ZXDH_ACL_RC_SRH_FAIL)
12431 : 0 : PMD_DRV_LOG(ERR, "ACL_INDEX_VPORT_REL[vport:0x%x] index is not exist.", vport);
12432 : :
12433 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
12434 : :
12435 : 0 : return rc;
12436 : : }
12437 : :
12438 : : static uint32_t
12439 : 0 : zxdh_np_dtb_smmu0_data_write_cycle(uint32_t dev_id,
12440 : : uint32_t queue_id,
12441 : : uint32_t smmu0_base_addr,
12442 : : uint32_t smmu0_wr_mode,
12443 : : uint32_t entry_num,
12444 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry_arr,
12445 : : uint32_t *element_id)
12446 : : {
12447 : 0 : uint32_t entry_data_buff[4] = {0};
12448 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
12449 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
12450 : :
12451 : 0 : uint8_t *table_data_buff = malloc(ZXDH_DTB_TABLE_DATA_BUFF_SIZE);
12452 [ # # ]: 0 : if (table_data_buff == NULL) {
12453 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12454 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12455 : : }
12456 : :
12457 : 0 : dtb_one_entry.cmd = cmd_buff;
12458 : 0 : dtb_one_entry.data = (uint8_t *)entry_data_buff;
12459 : :
12460 : : uint32_t rc = ZXDH_OK;
12461 : : uint32_t addr_offset = 0;
12462 : : uint32_t dtb_len = 0;
12463 : :
12464 [ # # ]: 0 : for (uint32_t item_cnt = 0; item_cnt < entry_num; ++item_cnt) {
12465 : 0 : uint32_t *p_entry_data = (uint32_t *)p_entry_arr[item_cnt].p_data;
12466 : 0 : uint32_t index = p_entry_arr[item_cnt].index;
12467 : :
12468 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
12469 : : smmu0_base_addr,
12470 : : index,
12471 : : smmu0_wr_mode,
12472 : : p_entry_data,
12473 : : &dtb_one_entry);
12474 : :
12475 [ # # # # ]: 0 : switch (smmu0_wr_mode) {
12476 : 0 : case ZXDH_ERAM128_OPR_128b:
12477 : 0 : dtb_len += 2;
12478 : 0 : addr_offset = item_cnt * ZXDH_DTB_LEN_POS_SETP * 2;
12479 : 0 : break;
12480 : 0 : case ZXDH_ERAM128_OPR_64b:
12481 : 0 : dtb_len += 1;
12482 : 0 : addr_offset = item_cnt * ZXDH_DTB_LEN_POS_SETP;
12483 : 0 : break;
12484 : 0 : case ZXDH_ERAM128_OPR_1b:
12485 : 0 : dtb_len += 1;
12486 : 0 : addr_offset = item_cnt * ZXDH_DTB_LEN_POS_SETP;
12487 : 0 : break;
12488 : : }
12489 : :
12490 : 0 : zxdh_np_dtb_data_write(table_data_buff, addr_offset, &dtb_one_entry);
12491 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
12492 : : memset(entry_data_buff, 0, 4 * sizeof(uint32_t));
12493 : : }
12494 : :
12495 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
12496 : : queue_id,
12497 : : dtb_len * 16,
12498 : : table_data_buff,
12499 : : element_id);
12500 : 0 : free(table_data_buff);
12501 : :
12502 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, *element_id);
12503 : :
12504 : 0 : return rc;
12505 : : }
12506 : :
12507 : : static uint32_t
12508 [ # # ]: 0 : zxdh_np_dtb_smmu0_data_write(uint32_t dev_id,
12509 : : uint32_t queue_id,
12510 : : uint32_t smmu0_base_addr,
12511 : : uint32_t smmu0_wr_mode,
12512 : : uint32_t entry_num,
12513 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry_arr,
12514 : : uint32_t *element_id)
12515 : : {
12516 : : uint32_t entry_num_max = 0;
12517 : :
12518 : : switch (smmu0_wr_mode) {
12519 : : case ZXDH_ERAM128_OPR_128b:
12520 : : entry_num_max = 0x1ff;
12521 : : break;
12522 : : case ZXDH_ERAM128_OPR_64b:
12523 : : entry_num_max = 0x3ff;
12524 : : break;
12525 : : case ZXDH_ERAM128_OPR_1b:
12526 : : entry_num_max = 0x3ff;
12527 : : break;
12528 : : }
12529 : :
12530 : 0 : uint32_t entry_cycle = entry_num / entry_num_max;
12531 : 0 : uint32_t entry_remains = entry_num % entry_num_max;
12532 : : uint32_t rc = ZXDH_OK;
12533 : :
12534 [ # # ]: 0 : for (uint32_t i = 0; i < entry_cycle; ++i) {
12535 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry = p_entry_arr + entry_num_max * i;
12536 : 0 : rc = zxdh_np_dtb_smmu0_data_write_cycle(dev_id,
12537 : : queue_id,
12538 : : smmu0_base_addr,
12539 : : smmu0_wr_mode,
12540 : : entry_num_max,
12541 : : p_entry,
12542 : : element_id);
12543 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_data_write_cycle");
12544 : : }
12545 : :
12546 [ # # ]: 0 : if (entry_remains) {
12547 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry = p_entry_arr + entry_num_max * entry_cycle;
12548 : 0 : rc = zxdh_np_dtb_smmu0_data_write_cycle(dev_id,
12549 : : queue_id,
12550 : : smmu0_base_addr,
12551 : : smmu0_wr_mode,
12552 : : entry_remains,
12553 : : p_entry,
12554 : : element_id);
12555 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_data_write_cycle");
12556 : : }
12557 : :
12558 : 0 : return rc;
12559 : : }
12560 : :
12561 : : static uint32_t
12562 : 0 : zxdh_np_dtb_eram_dma_write(uint32_t dev_id,
12563 : : uint32_t queue_id,
12564 : : uint32_t sdt_no,
12565 : : uint32_t entry_num,
12566 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_entry_arr,
12567 : : uint32_t *element_id)
12568 : : {
12569 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram_info = {0};
12570 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram_info);
12571 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12572 : :
12573 : 0 : uint32_t base_addr = sdt_eram_info.eram_base_addr;
12574 : 0 : uint32_t wrt_mode = sdt_eram_info.eram_mode;
12575 : :
12576 [ # # # # ]: 0 : switch (wrt_mode) {
12577 : 0 : case ZXDH_ERAM128_TBL_128b:
12578 : : wrt_mode = ZXDH_ERAM128_OPR_128b;
12579 : 0 : break;
12580 : 0 : case ZXDH_ERAM128_TBL_64b:
12581 : : wrt_mode = ZXDH_ERAM128_OPR_64b;
12582 : 0 : break;
12583 : 0 : case ZXDH_ERAM128_TBL_1b:
12584 : : wrt_mode = ZXDH_ERAM128_OPR_1b;
12585 : 0 : break;
12586 : : }
12587 : :
12588 : 0 : rc = zxdh_np_dtb_smmu0_data_write(dev_id,
12589 : : queue_id,
12590 : : base_addr,
12591 : : wrt_mode,
12592 : : entry_num,
12593 : : p_entry_arr,
12594 : : element_id);
12595 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_data_write");
12596 : :
12597 : 0 : return ZXDH_OK;
12598 : : }
12599 : :
12600 : : static uint32_t
12601 : 0 : zxdh_np_dtb_eram_data_clear(uint32_t dev_id,
12602 : : uint32_t queue_id,
12603 : : uint32_t sdt_no,
12604 : : uint32_t index_num,
12605 : : uint32_t *p_index_array)
12606 : : {
12607 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_eram_data_arr = malloc(index_num *
12608 : : sizeof(ZXDH_DTB_ERAM_ENTRY_INFO_T));
12609 [ # # ]: 0 : if (p_eram_data_arr == NULL) {
12610 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12611 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12612 : : }
12613 : :
12614 : 0 : uint8_t *data_buff = malloc(4 * sizeof(uint32_t));
12615 [ # # ]: 0 : if (data_buff == NULL) {
12616 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
12617 : 0 : free(p_eram_data_arr);
12618 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12619 : : }
12620 : :
12621 [ # # ]: 0 : for (uint32_t i = 0; i < index_num; i++) {
12622 : 0 : p_eram_data_arr[i].index = p_index_array[i];
12623 : 0 : p_eram_data_arr[i].p_data = (uint32_t *)data_buff;
12624 : : }
12625 : :
12626 : 0 : uint32_t element_id = 0;
12627 : 0 : uint32_t rc = zxdh_np_dtb_eram_dma_write(dev_id, queue_id,
12628 : : sdt_no, index_num, p_eram_data_arr, &element_id);
12629 : 0 : free(data_buff);
12630 : 0 : free(p_eram_data_arr);
12631 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_eram_dma_write");
12632 : :
12633 : : return rc;
12634 : : }
12635 : :
12636 : : static uint32_t
12637 : 0 : zxdh_np_dtb_eram_stat_data_clear(uint32_t dev_id,
12638 : : uint32_t queue_id,
12639 : : uint32_t counter_id,
12640 : : ZXDH_STAT_CNT_MODE_E rd_mode,
12641 : : uint32_t index_num,
12642 : : uint32_t *p_index_array)
12643 : : {
12644 : 0 : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
12645 : 0 : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
12646 : :
12647 : 0 : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_eram_data_arr = malloc(index_num *
12648 : : sizeof(ZXDH_DTB_ERAM_ENTRY_INFO_T));
12649 [ # # ]: 0 : if (p_eram_data_arr == NULL) {
12650 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12651 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12652 : : }
12653 : :
12654 : 0 : uint8_t *data_buff = malloc(4 * sizeof(uint32_t));
12655 [ # # ]: 0 : if (data_buff == NULL) {
12656 : 0 : PMD_DRV_LOG(ERR, "data_buff point null!");
12657 : 0 : free(p_eram_data_arr);
12658 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12659 : : }
12660 : :
12661 [ # # ]: 0 : for (uint32_t i = 0; i < index_num; i++) {
12662 : 0 : p_eram_data_arr[i].index = p_index_array[i];
12663 : 0 : p_eram_data_arr[i].p_data = (uint32_t *)data_buff;
12664 : : }
12665 : :
12666 : 0 : uint32_t wrt_mode = (rd_mode == ZXDH_STAT_128_MODE) ?
12667 : 0 : ZXDH_ERAM128_OPR_128b : ZXDH_ERAM128_OPR_64b;
12668 : : uint32_t counter_id_128bit = (rd_mode == ZXDH_STAT_128_MODE) ?
12669 [ # # ]: 0 : counter_id : (counter_id >> 1);
12670 : 0 : uint32_t start_addr = stat_cfg.eram_baddr + counter_id_128bit;
12671 : 0 : uint32_t element_id = 0;
12672 : 0 : uint32_t rc = zxdh_np_dtb_smmu0_data_write(dev_id,
12673 : : queue_id,
12674 : : start_addr,
12675 : : wrt_mode,
12676 : : index_num,
12677 : : p_eram_data_arr,
12678 : : &element_id);
12679 : 0 : free(data_buff);
12680 : 0 : free(p_eram_data_arr);
12681 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_data_write");
12682 : :
12683 : : return rc;
12684 : : }
12685 : :
12686 : : uint32_t
12687 : 0 : zxdh_np_dtb_acl_offline_delete(uint32_t dev_id, uint32_t queue_id,
12688 : : uint32_t sdt_no, uint32_t vport, uint32_t counter_id, uint32_t rd_mode)
12689 : : {
12690 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
12691 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
12692 : 0 : uint32_t index_num = 0;
12693 : :
12694 : 0 : uint32_t rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
12695 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12696 [ # # ]: 0 : if (sdt_acl.table_type != ZXDH_SDT_TBLT_ETCAM) {
12697 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not etcam table!",
12698 : : sdt_no, sdt_acl.table_type);
12699 : 0 : return ZXDH_ERR;
12700 : : }
12701 : :
12702 : : uint32_t eram_sdt_no = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
12703 : :
12704 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, eram_sdt_no, &sdt_eram);
12705 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
12706 [ # # ]: 0 : if (sdt_eram.table_type != ZXDH_SDT_TBLT_ERAM) {
12707 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] table_type[ %u ] is not eram table!",
12708 : : eram_sdt_no, sdt_eram.table_type);
12709 : 0 : return ZXDH_ERR;
12710 : : }
12711 : :
12712 : 0 : uint32_t *p_index_array = malloc(sizeof(uint32_t) * sdt_eram.eram_table_depth);
12713 [ # # ]: 0 : if (p_index_array == NULL) {
12714 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
12715 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
12716 : : }
12717 : :
12718 : 0 : rc = zxdh_np_dtb_acl_index_parse(dev_id, queue_id,
12719 : : eram_sdt_no, vport, &index_num, p_index_array);
12720 [ # # ]: 0 : if (rc != ZXDH_OK) {
12721 : 0 : free(p_index_array);
12722 : 0 : PMD_DRV_LOG(ERR, "acl index parse failed");
12723 : 0 : return ZXDH_ERR;
12724 : : }
12725 : :
12726 [ # # ]: 0 : if (!index_num) {
12727 : 0 : PMD_DRV_LOG(ERR, "SDT[%u] vport[0x%x] item num is zero!", sdt_no, vport);
12728 : 0 : free(p_index_array);
12729 : 0 : return ZXDH_OK;
12730 : : }
12731 : :
12732 : 0 : rc = zxdh_np_dtb_acl_data_clear(dev_id, queue_id, sdt_no, index_num, p_index_array);
12733 : 0 : rc = zxdh_np_dtb_eram_data_clear(dev_id, queue_id, eram_sdt_no, index_num, p_index_array);
12734 : 0 : rc = zxdh_np_dtb_eram_stat_data_clear(dev_id, queue_id,
12735 : : counter_id, rd_mode, index_num, p_index_array);
12736 : 0 : free(p_index_array);
12737 : :
12738 : 0 : rc = zxdh_np_dtb_acl_index_release_by_vport(dev_id, sdt_no, vport);
12739 : :
12740 : 0 : return rc;
12741 : : }
|
