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[id])
304 : : #define ZXDH_DEV_INFO_GET(id) (g_dev_mgr.p_dev_array[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[(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[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.user_addr[(INDEX)].user_flag)
392 : :
393 : : #define ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
394 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.user_addr[(INDEX)].phy_addr)
395 : :
396 : : #define ZXDH_DTB_TAB_UP_DATA_LEN_GET(DEV_ID, QUEUE_ID, INDEX) \
397 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.data_len[(INDEX)])
398 : :
399 : : #define ZXDH_DTB_TAB_UP_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
400 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.start_vir_addr + \
401 : : (INDEX) * p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.item_size)
402 : :
403 : : #define ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
404 : : (p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_down.start_vir_addr + \
405 : : INDEX * p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_down.item_size)
406 : :
407 : : #define ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(DEV_ID, QUEUE_ID) \
408 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_down.wr_index)
409 : :
410 : : #define ZXDH_DTB_QUEUE_INIT_FLAG_GET(DEV_ID, QUEUE_ID) \
411 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].init_flag)
412 : :
413 : : #define ZXDH_DTB_TAB_UP_USER_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
414 : : (p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_up.user_addr[INDEX].vir_addr)
415 : :
416 : : #define ZXDH_DTB_TAB_UP_USER_ADDR_FLAG_SET(DEV_ID, QUEUE_ID, INDEX, VAL) \
417 : : (p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_up.user_addr[INDEX].user_flag = \
418 : : VAL)
419 : :
420 : : static inline uint64_t
421 : : zxdh_np_dtb_tab_down_phy_addr_get(uint32_t DEV_ID, uint32_t QUEUE_ID,
422 : : uint32_t INDEX)
423 : : {
424 : 0 : return p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_down.start_phy_addr +
425 : 0 : INDEX * p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_down.item_size;
426 : : }
427 : :
428 : : #define ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
429 : : zxdh_np_dtb_tab_down_phy_addr_get(DEV_ID, QUEUE_ID, INDEX)
430 : :
431 : : static inline uint64_t
432 : : zxdh_np_dtb_tab_up_phy_addr_get(uint32_t DEV_ID, uint32_t QUEUE_ID,
433 : : uint32_t INDEX)
434 : : {
435 : 0 : return p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_up.start_phy_addr +
436 : 0 : INDEX * p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_up.item_size;
437 : : }
438 : :
439 : : #define ZXDH_DTB_TAB_UP_PHY_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
440 : : zxdh_np_dtb_tab_up_phy_addr_get(DEV_ID, QUEUE_ID, INDEX)
441 : :
442 : : static inline void
443 : : zxdh_np_init_d_node(ZXDH_D_NODE *ptr, void *pdata)
444 : : {
445 : 0 : ptr->data = pdata;
446 : 0 : ptr->prev = NULL;
447 : 0 : ptr->next = NULL;
448 : 0 : }
449 : :
450 : : static inline void
451 : : zxdh_np_init_rbt_tn(ZXDH_RB_TN *p_tn, void *p_newkey)
452 : : {
453 : 0 : p_tn->p_key = p_newkey;
454 : 0 : p_tn->color_lsv = 0;
455 : 0 : p_tn->p_left = NULL;
456 : 0 : p_tn->p_right = NULL;
457 : 0 : p_tn->p_parent = NULL;
458 : : zxdh_np_init_d_node(&p_tn->tn_ln, p_tn);
459 : : }
460 : :
461 : : static inline uint32_t
462 : : zxdh_np_get_tn_lsv(ZXDH_RB_TN *p_tn)
463 : : {
464 : 0 : return p_tn->color_lsv >> 2;
465 : : }
466 : :
467 : : static inline void
468 : : zxdh_np_set_tn_lsv(ZXDH_RB_TN *p_tn, uint32_t list_val)
469 : : {
470 : 0 : p_tn->color_lsv &= 0x3;
471 : 0 : p_tn->color_lsv |= (list_val << 2);
472 : : }
473 : :
474 : : static inline void
475 : : zxdh_np_set_tn_color(ZXDH_RB_TN *p_tn, uint32_t color)
476 : : {
477 : 0 : p_tn->color_lsv &= 0xfffffffc;
478 : 0 : p_tn->color_lsv |= (color & 0x3);
479 : 0 : }
480 : :
481 : : static inline uint32_t
482 : : zxdh_np_get_tn_color(ZXDH_RB_TN *p_tn)
483 : : {
484 [ # # # # ]: 0 : return ((p_tn == NULL) ? ZXDH_RBT_BLACK : (p_tn)->color_lsv & 0x3);
485 : : }
486 : :
487 : : #define ZXDH_SE_GET_ZBLK_CFG(p_se, zblk_idx) \
488 : : (&(((ZXDH_SE_CFG *)(p_se))->zblk_info[zblk_idx]))
489 : :
490 : : #define GET_ZBLK_IDX(zcell_idx) \
491 : : (((zcell_idx) & 0x7F) >> 2)
492 : :
493 : : #define GET_ZCELL_IDX(zcell_idx) \
494 : : ((zcell_idx) & 0x3)
495 : :
496 : : #define ZXDH_GET_FUN_INFO(p_se, fun_id) \
497 : : (&(((ZXDH_SE_CFG *)(p_se))->fun_info[fun_id]))
498 : :
499 : : #define GET_DDR_HASH_ARG(ddr_crc_sel) (g_ddr_hash_arg[ddr_crc_sel])
500 : :
501 : : #define ZXDH_SDT_GET_LOW_DATA(source_value, low_width) \
502 : : ((source_value) & ((1 << (low_width)) - 1))
503 : :
504 : : #define ZXDH_ACL_AS_RSLT_SIZE_GET_EX(mode) (2U << (mode))
505 : :
506 : : #define ZXDH_GET_ACTU_KEY_BY_SIZE(actu_key_size) \
507 : : ((actu_key_size) * ZXDH_HASH_ACTU_KEY_STEP)
508 : :
509 : : #define ZXDH_GET_KEY_SIZE(actu_key_size) \
510 : : (ZXDH_GET_ACTU_KEY_BY_SIZE(actu_key_size) + ZXDH_HASH_KEY_CTR_SIZE)
511 : :
512 : : #define ZXDH_ACL_ENTRY_MAX_GET(key_mode, block_num) \
513 : : ((block_num) * ZXDH_ETCAM_RAM_DEPTH * (1U << (key_mode)))
514 : :
515 : : #define ZXDH_ETCAM_ENTRY_SIZE_GET(entry_mode) \
516 : : ((ZXDH_ETCAM_RAM_WIDTH << (3 - (entry_mode))) / 8)
517 : :
518 : : #define ZXDH_ACL_KEYSIZE_GET(key_mode) (2 * ZXDH_ETCAM_ENTRY_SIZE_GET(key_mode))
519 : :
520 : : #define GET_HASH_TBL_ID_INFO(dev_id, fun_id, tbl_id) (&g_tbl_id_info[dev_id][fun_id][tbl_id])
521 : :
522 : : #define ZXDH_GET_HASH_TBL_ID(p_key) ((p_key)[0] & 0x1F)
523 : :
524 : : static inline uint32_t
525 : : zxdh_np_get_hash_entry_size(uint32_t key_type)
526 : : {
527 : : return ((key_type == ZXDH_HASH_KEY_128b) ? 16U : ((key_type == ZXDH_HASH_KEY_256b) ? 32U :
528 : : ((key_type == ZXDH_HASH_KEY_512b) ? 64U : 0)));
529 : : }
530 : :
531 : : #define ZXDH_GET_HASH_ENTRY_SIZE(key_type) \
532 : : zxdh_np_get_hash_entry_size(key_type)
533 : :
534 : : static inline void
535 : : zxdh_np_comm_uint32_write_bits(uint32_t *dst, uint32_t src,
536 : : uint32_t start_pos, uint32_t len)
537 : : {
538 : : uint32_t mask = zxdh_np_comm_get_bit_mask(len);
539 : 0 : *dst = (*dst & ~(mask << start_pos)) | ((src & mask) << start_pos);
540 : 0 : }
541 : :
542 : : #define ZXDH_COMM_UINT32_WRITE_BITS(dst, src, start_pos, len)\
543 : : zxdh_np_comm_uint32_write_bits(&(dst), src, start_pos, len)
544 : :
545 : : static inline uint32_t
546 : : zxdh_np_zblk_addr_conv(uint32_t zblk_idx)
547 : : {
548 : : uint32_t group_size = 1 << ZXDH_ZBLK_IDX_BT_WIDTH;
549 : : uint32_t group_number = zblk_idx / ZXDH_ZBLK_NUM_PER_ZGRP;
550 : : uint32_t offset_in_group = zblk_idx % ZXDH_ZBLK_NUM_PER_ZGRP;
551 : :
552 : : return group_number * group_size + offset_in_group;
553 : : }
554 : :
555 : : static inline uint32_t
556 : : zxdh_np_zcell_addr_conv(uint32_t zcell_idx)
557 : : {
558 : : uint32_t blk_grp_idx = (zcell_idx >> ZXDH_ZCELL_IDX_BT_WIDTH) &
559 : : ((1 << (ZXDH_ZBLK_IDX_BT_WIDTH + ZXDH_ZGRP_IDX_BT_WIDTH)) - 1);
560 : :
561 : : uint32_t cell_idx = zcell_idx & ((1 << ZXDH_ZCELL_IDX_BT_WIDTH) - 1);
562 : :
563 : 0 : return (zxdh_np_zblk_addr_conv(blk_grp_idx) << ZXDH_ZCELL_IDX_BT_WIDTH) | cell_idx;
564 : : }
565 : :
566 : : #define ZXDH_ZBLK_REG_ADDR_CALC(zblk_idx, offset) \
567 : : ((0xF << ZXDH_ZBLK_WRT_MASK_BT_START) | \
568 : : (0x1 << ZXDH_REG_SRAM_FLAG_BT_START) | \
569 : : ((zxdh_np_zblk_addr_conv(zblk_idx) & 0x1F) << ZXDH_ZBLK_IDX_BT_START) | \
570 : : ((offset) & 0x1FF))
571 : :
572 : : #define ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx, reg_idx) \
573 : : (ZXDH_ZBLK_REG_ADDR_CALC((zblk_idx), (0xD + (reg_idx))))
574 : :
575 : : #define ZXDH_ZCELL_BASE_ADDR_CALC(zcell_idx) \
576 : : ((0xF << ZXDH_ZBLK_WRT_MASK_BT_START) | (((zxdh_np_zcell_addr_conv(zcell_idx)) & \
577 : : ((1 << (ZXDH_ZCELL_IDX_BT_WIDTH + ZXDH_ZBLK_IDX_BT_WIDTH + ZXDH_ZGRP_IDX_BT_WIDTH)) - 1)) \
578 : : << ZXDH_ZCELL_ADDR_BT_WIDTH))
579 : : #define ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_idx, item_idx) \
580 : : ((ZXDH_ZCELL_BASE_ADDR_CALC(zcell_idx)) | ((item_idx) & (ZXDH_SE_RAM_DEPTH - 1)))
581 : :
582 : : static inline uint32_t
583 : : zxdh_np_get_rst_size(uint32_t key_type, uint32_t actu_key_size)
584 : : {
585 : : return ((ZXDH_GET_HASH_ENTRY_SIZE(key_type) != 0) ?
586 : 0 : (ZXDH_GET_HASH_ENTRY_SIZE(key_type) - ZXDH_GET_ACTU_KEY_BY_SIZE(actu_key_size) -
587 [ # # # # ]: 0 : ZXDH_HASH_KEY_CTR_SIZE) : 0xFF);
588 : : }
589 : :
590 : : #define ZXDH_GET_RST_SIZE(key_type, actu_key_size) \
591 : : zxdh_np_get_rst_size(key_type, actu_key_size)
592 : :
593 : : #define ZXDH_GET_HASH_KEY_TYPE(p_key) (((p_key)[0] >> 5) & 0x3)
594 : :
595 : : #define ZXDH_GET_HASH_KEY_VALID(p_key) (((p_key)[0] >> 7) & 0x1)
596 : :
597 : : #define ZXDH_GET_HASH_KEY_CTRL(valid, type, tbl_id) \
598 : : ((((valid) & 0x1) << 7) | (((type) & 0x3) << 5) | ((tbl_id) & 0x1f))
599 : :
600 : : static inline uint32_t
601 : : zxdh_np_get_hash_entry_mask(uint32_t entry_size, uint32_t entry_pos)
602 : : {
603 : 0 : return (((1U << (entry_size / 16U)) - 1U) << (4U - entry_size / 16U - entry_pos)) & 0xF;
604 : : }
605 : :
606 : : #define ZXDH_GET_HASH_ENTRY_MASK(entry_size, entry_pos) \
607 : : zxdh_np_get_hash_entry_mask(entry_size, entry_pos)
608 : :
609 : : #define GET_HASH_DDR_HW_ADDR(base_addr, item_idx) \
610 : : ((base_addr) + (item_idx))
611 : :
612 : : #define GET_ZCELL_CRC_VAL(zcell_id, crc16_val) \
613 : : (((crc16_val) >> (zcell_id)) & (ZXDH_SE_RAM_DEPTH - 1))
614 : :
615 : : #define ZXDH_COMM_DM_TO_X(d, m) ((d) & ~(m))
616 : : #define ZXDH_COMM_DM_TO_Y(d, m) (~(d) & ~(m))
617 : : #define ZXDH_COMM_XY_TO_MASK(x, y) (~(x) & ~(y))
618 : : #define ZXDH_COMM_XY_TO_DATA(x, y) (x)
619 : :
620 : : static ZXDH_FIELD_T g_stat_car0_cara_queue_ram0_159_0_reg[] = {
621 : : {"cara_drop", ZXDH_FIELD_FLAG_RW, 147, 1, 0x0, 0x0},
622 : : {"cara_plcr_en", ZXDH_FIELD_FLAG_RW, 146, 1, 0x0, 0x0},
623 : : {"cara_profile_id", ZXDH_FIELD_FLAG_RW, 145, 9, 0x0, 0x0},
624 : : {"cara_tq_h", ZXDH_FIELD_FLAG_RO, 136, 13, 0x0, 0x0},
625 : : {"cara_tq_l", ZXDH_FIELD_FLAG_RO, 123, 32, 0x0, 0x0},
626 : : {"cara_ted", ZXDH_FIELD_FLAG_RO, 91, 19, 0x0, 0x0},
627 : : {"cara_tcd", ZXDH_FIELD_FLAG_RO, 72, 19, 0x0, 0x0},
628 : : {"cara_tei", ZXDH_FIELD_FLAG_RO, 53, 27, 0x0, 0x0},
629 : : {"cara_tci", ZXDH_FIELD_FLAG_RO, 26, 27, 0x0, 0x0},
630 : : };
631 : :
632 : : static ZXDH_FIELD_T g_stat_car0_carb_queue_ram0_159_0_reg[] = {
633 : : {"carb_drop", ZXDH_FIELD_FLAG_RW, 147, 1, 0x0, 0x0},
634 : : {"carb_plcr_en", ZXDH_FIELD_FLAG_RW, 146, 1, 0x0, 0x0},
635 : : {"carb_profile_id", ZXDH_FIELD_FLAG_RW, 145, 9, 0x0, 0x0},
636 : : {"carb_tq_h", ZXDH_FIELD_FLAG_RO, 136, 13, 0x0, 0x0},
637 : : {"carb_tq_l", ZXDH_FIELD_FLAG_RO, 123, 32, 0x0, 0x0},
638 : : {"carb_ted", ZXDH_FIELD_FLAG_RO, 91, 19, 0x0, 0x0},
639 : : {"carb_tcd", ZXDH_FIELD_FLAG_RO, 72, 19, 0x0, 0x0},
640 : : {"carb_tei", ZXDH_FIELD_FLAG_RO, 53, 27, 0x0, 0x0},
641 : : {"carb_tci", ZXDH_FIELD_FLAG_RO, 26, 27, 0x0, 0x0},
642 : : };
643 : :
644 : : static ZXDH_FIELD_T g_stat_car0_carc_queue_ram0_159_0_reg[] = {
645 : : {"carc_drop", ZXDH_FIELD_FLAG_RW, 147, 1, 0x0, 0x0},
646 : : {"carc_plcr_en", ZXDH_FIELD_FLAG_RW, 146, 1, 0x0, 0x0},
647 : : {"carc_profile_id", ZXDH_FIELD_FLAG_RW, 145, 9, 0x0, 0x0},
648 : : {"carc_tq_h", ZXDH_FIELD_FLAG_RO, 136, 13, 0x0, 0x0},
649 : : {"carc_tq_l", ZXDH_FIELD_FLAG_RO, 123, 32, 0x0, 0x0},
650 : : {"carc_ted", ZXDH_FIELD_FLAG_RO, 91, 19, 0x0, 0x0},
651 : : {"carc_tcd", ZXDH_FIELD_FLAG_RO, 72, 19, 0x0, 0x0},
652 : : {"carc_tei", ZXDH_FIELD_FLAG_RO, 53, 27, 0x0, 0x0},
653 : : {"carc_tci", ZXDH_FIELD_FLAG_RO, 26, 27, 0x0, 0x0},
654 : : };
655 : :
656 : : static ZXDH_FIELD_T g_nppu_pktrx_cfg_pktrx_glbal_cfg_0_reg[] = {
657 : : {"pktrx_glbal_cfg_0", ZXDH_FIELD_FLAG_RW, 31, 32, 0x0, 0x0},
658 : : };
659 : :
660 : 0 : static uint32_t zxdh_dtb_info_print(uint32_t dev_id,
661 : : uint32_t queue_id,
662 : : uint32_t item_index,
663 : : ZXDH_DTB_QUEUE_ITEM_INFO_T *item_info)
664 : : {
665 : : uint64_t element_start_addr = 0;
666 : : uint64_t ack_start_addr = 0;
667 : : uint64_t data_addr = 0;
668 : : uint32_t data = 0;
669 : : uint32_t i = 0;
670 : : uint32_t j = 0;
671 : :
672 [ # # ]: 0 : PMD_DRV_LOG(DEBUG, "queue: %u, element:%u, %s table info is:",
673 : : queue_id, item_index, (item_info->cmd_type) ? "up" : "down");
674 : 0 : PMD_DRV_LOG(DEBUG, "cmd_vld : %u", item_info->cmd_vld);
675 [ # # ]: 0 : PMD_DRV_LOG(DEBUG, "cmd_type : %s", (item_info->cmd_type) ? "up" : "down");
676 : 0 : PMD_DRV_LOG(DEBUG, "int_en : %u", item_info->int_en);
677 : 0 : PMD_DRV_LOG(DEBUG, "data_len : %u", item_info->data_len);
678 : 0 : PMD_DRV_LOG(DEBUG, "data_hddr : 0x%x", item_info->data_hddr);
679 : 0 : PMD_DRV_LOG(DEBUG, "data_laddr : 0x%x", item_info->data_laddr);
680 : :
681 [ # # ]: 0 : if (item_info->cmd_type == ZXDH_DTB_DIR_UP_TYPE) {
682 : 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
683 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE) {
684 : : ack_start_addr =
685 : : ZXDH_DTB_TAB_UP_USER_VIR_ADDR_GET(dev_id, queue_id, item_index);
686 : : }
687 : 0 : ack_start_addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, item_index);
688 : 0 : element_start_addr =
689 : : ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, item_index) + ZXDH_DTB_ITEM_ACK_SIZE;
690 : : } else {
691 : 0 : ack_start_addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, item_index);
692 : 0 : element_start_addr =
693 : : ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, item_index)
694 : : + ZXDH_DTB_ITEM_ACK_SIZE;
695 : : }
696 : 0 : PMD_DRV_LOG(DEBUG, "dtb data:");
697 : :
698 : 0 : PMD_DRV_LOG(DEBUG, "ack info:");
699 [ # # ]: 0 : for (j = 0; j < 4; j++) {
700 : 0 : data = ZXDH_COMM_CONVERT32(*((uint32_t *)(ack_start_addr + 4 * j)));
701 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", data);
702 : : }
703 : :
704 [ # # ]: 0 : for (i = 0; i < item_info->data_len; i++) {
705 : 0 : data_addr = element_start_addr + 16 * i;
706 : :
707 : 0 : PMD_DRV_LOG(DEBUG, "row_%u:", i);
708 : :
709 [ # # ]: 0 : for (j = 0; j < 4; j++) {
710 : 0 : data = ZXDH_COMM_CONVERT32(*((uint32_t *)(data_addr + 4 * j)));
711 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", data);
712 : : }
713 : : }
714 : :
715 : 0 : PMD_DRV_LOG(DEBUG, "zxdh dtb info print end.");
716 : 0 : return ZXDH_OK;
717 : : }
718 : :
719 : : static uint32_t
720 : : zxdh_np_comm_is_big_endian(void)
721 : : {
722 : : ZXDH_ENDIAN_U c_data;
723 : :
724 : : c_data.a = 1;
725 : :
726 : : if (c_data.b == 1)
727 : : return 0;
728 : : else
729 : : return 1;
730 : : }
731 : :
732 : : static void
733 : 0 : zxdh_np_comm_swap(uint8_t *p_uc_data, uint32_t dw_byte_len)
734 : : {
735 : : uint16_t *p_w_tmp = NULL;
736 : : uint32_t *p_dw_tmp = NULL;
737 : : uint32_t dw_byte_num;
738 : : uint8_t uc_byte_mode;
739 : : uint32_t uc_is_big_flag;
740 : : uint32_t i;
741 : :
742 : : p_dw_tmp = (uint32_t *)(p_uc_data);
743 : : uc_is_big_flag = zxdh_np_comm_is_big_endian();
744 : : if (uc_is_big_flag)
745 : : return;
746 : :
747 : 0 : dw_byte_num = dw_byte_len >> 2;
748 : 0 : uc_byte_mode = dw_byte_len % 4 & 0xff;
749 : :
750 [ # # # # : 0 : for (i = 0; i < dw_byte_num; i++) {
# # # # #
# # # # #
# # ]
751 : 0 : (*p_dw_tmp) = ZXDH_COMM_CONVERT32(*p_dw_tmp);
752 : 0 : p_dw_tmp++;
753 : : }
754 : :
755 [ # # ]: 0 : if (uc_byte_mode > 1) {
756 : : p_w_tmp = (uint16_t *)(p_dw_tmp);
757 : 0 : (*p_w_tmp) = ZXDH_COMM_CONVERT16(*p_w_tmp);
758 : : }
759 : : }
760 : :
761 : : static uint32_t
762 : 0 : zxdh_comm_double_link_init(uint32_t elmemtnum, ZXDH_D_HEAD *p_head)
763 : : {
764 : : uint32_t err_code = 0;
765 : :
766 [ # # ]: 0 : if (elmemtnum == 0) {
767 : : err_code = ZXDH_DOUBLE_LINK_INIT_ELEMENT_NUM_ERR;
768 : 0 : PMD_DRV_LOG(ERR, "Error:[0x%x] doule_link_init Element Num Err !",
769 : : err_code);
770 : 0 : return err_code;
771 : : }
772 : :
773 : 0 : p_head->maxnum = elmemtnum;
774 : 0 : p_head->used = 0;
775 : 0 : p_head->p_next = NULL;
776 : 0 : p_head->p_prev = NULL;
777 : :
778 : 0 : return ZXDH_OK;
779 : : }
780 : :
781 : : static uint32_t
782 : 0 : zxdh_np_comm_liststack_create(uint32_t element_num, ZXDH_LISTSTACK_MANAGER **p_list)
783 : : {
784 : : ZXDH_LISTSTACK_MANAGER *p_local_list = NULL;
785 : : uint32_t dw_list_size = 0;
786 : : uint32_t dw_manage_size = 0;
787 : : uint32_t dw_actual_element_num = 0;
788 : : uint32_t i = 0;
789 : :
790 [ # # ]: 0 : if (p_list == NULL) {
791 : 0 : PMD_DRV_LOG(ERR, " p_list is NULL!");
792 : 0 : return ZXDH_LIST_STACK_POINT_NULL;
793 : : }
794 [ # # ]: 0 : if (element_num <= 0) {
795 : 0 : *p_list = NULL;
796 : 0 : PMD_DRV_LOG(ERR, " FtmComm_ListStackCreat_dwElementNum <=0");
797 : 0 : return ZXDH_LIST_STACK_ELEMENT_NUM_ERR;
798 : : }
799 : :
800 [ # # ]: 0 : if (element_num > ZXDH_LISTSTACK_MAX_ELEMENT - 1)
801 : : dw_actual_element_num = ZXDH_LISTSTACK_MAX_ELEMENT;
802 : : else
803 : 0 : dw_actual_element_num = element_num + 1;
804 : :
805 : 0 : dw_list_size = (dw_actual_element_num * sizeof(ZXDH_COMM_FREELINK)) & 0xffffffff;
806 : 0 : dw_manage_size = ((sizeof(ZXDH_LISTSTACK_MANAGER) & 0xFFFFFFFFU) + dw_list_size) &
807 : : 0xffffffff;
808 : :
809 : 0 : p_local_list = rte_zmalloc(NULL, dw_manage_size, 0);
810 [ # # ]: 0 : if (p_local_list == NULL) {
811 : 0 : *p_list = NULL;
812 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
813 : 0 : return ZXDH_LIST_STACK_ALLOC_MEMORY_FAIL;
814 : : }
815 : :
816 : 0 : p_local_list->p_array = (ZXDH_COMM_FREELINK *)((uint8_t *)p_local_list +
817 : : sizeof(ZXDH_LISTSTACK_MANAGER));
818 : :
819 : 0 : p_local_list->capacity = dw_actual_element_num;
820 : 0 : p_local_list->free_num = dw_actual_element_num - 1;
821 : 0 : p_local_list->used_num = 0;
822 : :
823 [ # # ]: 0 : for (i = 1; i < (dw_actual_element_num - 1); i++) {
824 : 0 : p_local_list->p_array[i].index = i;
825 : 0 : p_local_list->p_array[i].next = i + 1;
826 : : }
827 : :
828 : 0 : p_local_list->p_array[0].index = 0;
829 : 0 : p_local_list->p_array[0].next = 0;
830 : :
831 : 0 : p_local_list->p_array[dw_actual_element_num - 1].index = dw_actual_element_num - 1;
832 : 0 : p_local_list->p_array[dw_actual_element_num - 1].next = 0xffffffff;
833 : :
834 : 0 : p_local_list->p_head = p_local_list->p_array[1].index;
835 : :
836 : 0 : *p_list = p_local_list;
837 : :
838 : 0 : return ZXDH_OK;
839 : : }
840 : :
841 : : static uint32_t
842 : 0 : zxdh_np_comm_liststack_alloc(ZXDH_LISTSTACK_MANAGER *p_list, uint32_t *p_index)
843 : : {
844 : : uint32_t dw_alloc_index = 0;
845 : : uint32_t dw_next_free = 0;
846 : :
847 [ # # ]: 0 : if (p_list == NULL) {
848 : 0 : *p_index = ZXDH_LISTSTACK_INVALID_INDEX;
849 : 0 : return ZXDH_LIST_STACK_POINT_NULL;
850 : : }
851 : :
852 [ # # ]: 0 : if (p_list->p_head == ZXDH_LISTSTACK_INVALID_INDEX) {
853 : 0 : *p_index = ZXDH_LISTSTACK_INVALID_INDEX;
854 : 0 : return ZXDH_LIST_STACK_ISEMPTY_ERR;
855 : : }
856 : :
857 : : dw_alloc_index = p_list->p_head;
858 : :
859 : 0 : dw_next_free = p_list->p_array[dw_alloc_index].next;
860 : 0 : p_list->p_array[dw_alloc_index].next = ZXDH_LISTSTACK_INVALID_INDEX;
861 : :
862 [ # # ]: 0 : if (dw_next_free != 0xffffffff)
863 : 0 : p_list->p_head = p_list->p_array[dw_next_free].index;
864 : : else
865 : 0 : p_list->p_head = ZXDH_LISTSTACK_INVALID_INDEX;
866 : :
867 : 0 : *p_index = dw_alloc_index - 1;
868 : :
869 : 0 : p_list->free_num--;
870 : 0 : p_list->used_num++;
871 : :
872 [ # # # # ]: 0 : if (p_list->free_num == 0 || (p_list->used_num == (p_list->capacity - 1)))
873 : 0 : p_list->p_head = ZXDH_LISTSTACK_INVALID_INDEX;
874 : :
875 : : return ZXDH_OK;
876 : : }
877 : :
878 : : static uint32_t
879 : 0 : zxdh_comm_liststack_free(ZXDH_LISTSTACK_MANAGER *p_list, uint32_t index)
880 : : {
881 : : uint32_t dw_free_index = 0;
882 : : uint32_t dw_prev_free = 0;
883 : : uint32_t dw_index = 0;
884 : :
885 : 0 : dw_index = index + 1;
886 : :
887 [ # # ]: 0 : if (p_list == NULL) {
888 : 0 : PMD_DRV_LOG(ERR, " p_list is null");
889 : 0 : return ZXDH_LIST_STACK_POINT_NULL;
890 : : }
891 : :
892 [ # # ]: 0 : if (dw_index >= p_list->capacity) {
893 : 0 : PMD_DRV_LOG(ERR, "dw_index is invalid");
894 : 0 : return ZXDH_LIST_STACK_FREE_INDEX_INVALID;
895 : : }
896 : :
897 [ # # ]: 0 : if (p_list->p_array[dw_index].next != ZXDH_LISTSTACK_INVALID_INDEX)
898 : : return ZXDH_OK;
899 : :
900 : : dw_free_index = dw_index;
901 : 0 : dw_prev_free = p_list->p_head;
902 : :
903 [ # # ]: 0 : if (dw_prev_free != 0)
904 : 0 : p_list->p_array[dw_free_index].next = p_list->p_array[dw_prev_free].index;
905 : : else
906 : 0 : p_list->p_array[dw_free_index].next = 0xffffffff;
907 : :
908 : 0 : p_list->p_head = p_list->p_array[dw_free_index].index;
909 : :
910 : 0 : p_list->free_num++;
911 : 0 : p_list->used_num--;
912 : :
913 : 0 : return ZXDH_OK;
914 : : }
915 : :
916 : : static uint32_t
917 : : zxdh_comm_double_link_insert_1st(ZXDH_D_NODE *p_newnode, ZXDH_D_HEAD *p_head)
918 : : {
919 : : RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
920 : : RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
921 : :
922 : 0 : p_newnode->next = p_head->p_next;
923 : 0 : p_newnode->prev = NULL;
924 : :
925 [ # # ]: 0 : if (p_head->p_next)
926 : 0 : p_head->p_next->prev = p_newnode;
927 : : else
928 : 0 : p_head->p_prev = p_newnode;
929 : :
930 : 0 : p_head->p_next = p_newnode;
931 : 0 : p_head->used++;
932 : :
933 : : return ZXDH_OK;
934 : : }
935 : :
936 : : static uint32_t
937 : : zxdh_comm_double_link_insert_aft(ZXDH_D_NODE *p_newnode,
938 : : ZXDH_D_NODE *p_oldnode,
939 : : ZXDH_D_HEAD *p_head)
940 : : {
941 : : RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
942 : : RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
943 : :
944 : 0 : p_newnode->next = p_oldnode->next;
945 : 0 : p_newnode->prev = p_oldnode;
946 : :
947 : 0 : if (p_oldnode->next)
948 : 0 : p_oldnode->next->prev = p_newnode;
949 : : else
950 : 0 : p_head->p_prev = p_newnode;
951 : :
952 : 0 : p_oldnode->next = p_newnode;
953 : 0 : p_head->used++;
954 : :
955 : : return ZXDH_OK;
956 : : }
957 : :
958 : : static uint32_t
959 : : zxdh_comm_double_link_insert_pre(ZXDH_D_NODE *p_newnode,
960 : : ZXDH_D_NODE *p_oldnode, ZXDH_D_HEAD *p_head)
961 : : {
962 : : RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
963 : : RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
964 : :
965 : 0 : p_newnode->next = p_oldnode;
966 : 0 : p_newnode->prev = p_oldnode->prev;
967 : :
968 [ # # ]: 0 : if (p_oldnode->prev)
969 : 0 : p_oldnode->prev->next = p_newnode;
970 : : else
971 : 0 : p_head->p_next = p_newnode;
972 : :
973 : 0 : p_oldnode->prev = p_newnode;
974 : 0 : p_head->used++;
975 : :
976 : : return ZXDH_OK;
977 : : }
978 : :
979 : : static uint32_t
980 : : zxdh_comm_double_link_insert_last(ZXDH_D_NODE *p_newnode, ZXDH_D_HEAD *p_head)
981 : : {
982 : : ZXDH_D_NODE *p_dnode = NULL;
983 : :
984 : : RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
985 : : RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
986 : :
987 : 0 : p_dnode = p_head->p_prev;
988 : :
989 [ # # ]: 0 : if (!p_dnode) {
990 : 0 : p_head->p_next = p_newnode;
991 : 0 : p_head->p_prev = p_newnode;
992 : 0 : p_newnode->next = NULL;
993 : 0 : p_newnode->prev = NULL;
994 : : } else {
995 : 0 : p_newnode->prev = p_dnode;
996 : 0 : p_newnode->next = NULL;
997 : 0 : p_head->p_prev = p_newnode;
998 : 0 : p_dnode->next = p_newnode;
999 : : }
1000 : :
1001 : 0 : p_head->used++;
1002 : :
1003 : : return ZXDH_OK;
1004 : : }
1005 : :
1006 : : static uint32_t
1007 : : zxdh_comm_double_link_del(ZXDH_D_NODE *delnode, ZXDH_D_HEAD *p_head)
1008 : : {
1009 : : ZXDH_D_NODE *next = NULL;
1010 : : ZXDH_D_NODE *pre = NULL;
1011 : :
1012 : 0 : next = delnode->next;
1013 : 0 : pre = delnode->prev;
1014 : :
1015 [ # # ]: 0 : if (next)
1016 : 0 : next->prev = delnode->prev;
1017 : : else
1018 : 0 : p_head->p_prev = delnode->prev;
1019 : :
1020 [ # # # # : 0 : if (pre)
# # # # #
# ]
1021 : 0 : pre->next = delnode->next;
1022 : : else
1023 : 0 : p_head->p_next = delnode->next;
1024 : :
1025 : 0 : p_head->used--;
1026 : 0 : delnode->next = NULL;
1027 : 0 : delnode->prev = NULL;
1028 : : return ZXDH_OK;
1029 : : }
1030 : :
1031 : : static int32_t
1032 : 0 : zxdh_comm_double_link_default_cmp_fuc(ZXDH_D_NODE *p_data1,
1033 : : ZXDH_D_NODE *p_data2, __rte_unused void *p_data)
1034 : : {
1035 : 0 : uint32_t data1 = *(uint32_t *)p_data1->data;
1036 : 0 : uint32_t data2 = *(uint32_t *)p_data2->data;
1037 : :
1038 [ # # ]: 0 : if (data1 > data2)
1039 : : return 1;
1040 [ # # ]: 0 : else if (data1 == data2)
1041 : : return 0;
1042 : : else
1043 : 0 : return -1;
1044 : : }
1045 : :
1046 : : static uint32_t
1047 : 0 : zxdh_comm_double_link_insert_sort(ZXDH_D_NODE *p_newnode,
1048 : : ZXDH_D_HEAD *p_head, ZXDH_CMP_FUNC cmp_fuc, void *cmp_data)
1049 : : {
1050 : : ZXDH_D_NODE *pre_node = NULL;
1051 : :
1052 [ # # ]: 0 : if (cmp_fuc == NULL)
1053 : : cmp_fuc = zxdh_comm_double_link_default_cmp_fuc;
1054 : :
1055 [ # # ]: 0 : if (p_head->used == 0)
1056 : 0 : return zxdh_comm_double_link_insert_1st(p_newnode, p_head);
1057 : :
1058 : 0 : pre_node = p_head->p_next;
1059 : :
1060 [ # # ]: 0 : while (pre_node != NULL) {
1061 [ # # ]: 0 : if (cmp_fuc(p_newnode, pre_node, cmp_data) <= 0)
1062 : 0 : return zxdh_comm_double_link_insert_pre(p_newnode,
1063 : : pre_node, p_head);
1064 : : else
1065 : 0 : pre_node = pre_node->next;
1066 : : }
1067 : :
1068 : 0 : return zxdh_comm_double_link_insert_last(p_newnode, p_head);
1069 : : }
1070 : :
1071 : : static int32_t
1072 : 0 : zxdh_comm_rb_def_cmp(void *p_new, void *p_old, uint32_t key_size)
1073 : : {
1074 : 0 : return memcmp(p_new, p_old, key_size);
1075 : : }
1076 : :
1077 : : static void
1078 : : zxdh_comm_rb_switch_color(ZXDH_RB_TN *p_tn1, ZXDH_RB_TN *p_tn2)
1079 : : {
1080 : : uint32_t color1, color2;
1081 : :
1082 : : color1 = zxdh_np_get_tn_color(p_tn1);
1083 : : color2 = zxdh_np_get_tn_color(p_tn2);
1084 : :
1085 : : zxdh_np_set_tn_color(p_tn1, color2);
1086 : : zxdh_np_set_tn_color(p_tn2, color1);
1087 : 0 : }
1088 : :
1089 : : static ZXDH_RB_TN *
1090 : : zxdh_comm_rb_get_brotn(ZXDH_RB_TN *p_cur_tn)
1091 : : {
1092 [ # # # # ]: 0 : return (p_cur_tn->p_parent->p_left == p_cur_tn) ? p_cur_tn->p_parent->p_right :
1093 : : p_cur_tn->p_parent->p_left;
1094 : : }
1095 : :
1096 : : static uint32_t
1097 : 0 : zxdh_comm_rb_handle_ins(__rte_unused ZXDH_RB_CFG *p_rb_cfg,
1098 : : ZXDH_RB_TN ***stack_tn,
1099 : : uint32_t stack_top)
1100 : : {
1101 : : ZXDH_RB_TN **pp_cur_tn = NULL;
1102 : : ZXDH_RB_TN *p_cur_tn = NULL;
1103 : : ZXDH_RB_TN **pp_tmp_tn = NULL;
1104 : : ZXDH_RB_TN *p_tmp_tn = NULL;
1105 : :
1106 [ # # ]: 0 : while (stack_top > 0) {
1107 : 0 : pp_cur_tn = stack_tn[stack_top];
1108 : 0 : p_cur_tn = *pp_cur_tn;
1109 : :
1110 [ # # ]: 0 : if (!p_cur_tn->p_parent) {
1111 : : zxdh_np_set_tn_color(p_cur_tn, ZXDH_RBT_BLACK);
1112 : : break;
1113 [ # # ]: 0 : } else if (zxdh_np_get_tn_color(p_cur_tn->p_parent) == ZXDH_RBT_RED) {
1114 : : ZXDH_RB_TN *p_unc_tn = zxdh_comm_rb_get_brotn(p_cur_tn->p_parent);
1115 : :
1116 : : RTE_ASSERT(p_cur_tn->p_parent == *stack_tn[stack_top - 1]);
1117 : :
1118 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn) == ZXDH_RBT_RED) {
1119 : : RTE_ASSERT(p_unc_tn);
1120 : : zxdh_np_set_tn_color(p_cur_tn->p_parent, ZXDH_RBT_BLACK);
1121 : : zxdh_np_set_tn_color(p_unc_tn, ZXDH_RBT_BLACK);
1122 : :
1123 : : RTE_ASSERT(p_cur_tn->p_parent->p_parent ==
1124 : : *stack_tn[stack_top - 2]);
1125 : :
1126 : : zxdh_np_set_tn_color(p_cur_tn->p_parent->p_parent, ZXDH_RBT_RED);
1127 : 0 : stack_top -= 2;
1128 : : } else {
1129 : : ZXDH_RB_TN *p_bro_tn = NULL;
1130 : :
1131 : 0 : pp_tmp_tn = stack_tn[stack_top - 2];
1132 : 0 : p_tmp_tn = *pp_tmp_tn;
1133 : :
1134 [ # # ]: 0 : if (p_cur_tn->p_parent == p_tmp_tn->p_left && p_cur_tn ==
1135 [ # # ]: 0 : p_cur_tn->p_parent->p_left) {
1136 [ # # ]: 0 : *pp_tmp_tn = p_cur_tn->p_parent;
1137 : :
1138 : : p_bro_tn = zxdh_comm_rb_get_brotn(p_cur_tn);
1139 : 0 : p_cur_tn->p_parent->p_parent = p_tmp_tn->p_parent;
1140 : :
1141 : 0 : p_tmp_tn->p_left = p_bro_tn;
1142 : 0 : p_tmp_tn->p_parent = p_cur_tn->p_parent;
1143 : 0 : p_cur_tn->p_parent->p_right = p_tmp_tn;
1144 : :
1145 [ # # ]: 0 : if (p_bro_tn)
1146 : 0 : p_bro_tn->p_parent = p_tmp_tn;
1147 : :
1148 [ # # ]: 0 : zxdh_comm_rb_switch_color(*pp_tmp_tn, p_tmp_tn);
1149 [ # # ]: 0 : } else if (p_cur_tn->p_parent == p_tmp_tn->p_left && p_cur_tn ==
1150 [ # # ]: 0 : p_cur_tn->p_parent->p_right) {
1151 : 0 : *pp_tmp_tn = p_cur_tn;
1152 : :
1153 : 0 : p_cur_tn->p_parent->p_right = p_cur_tn->p_left;
1154 : :
1155 [ # # ]: 0 : if (p_cur_tn->p_left)
1156 : 0 : p_cur_tn->p_left->p_parent = p_cur_tn->p_parent;
1157 : :
1158 : 0 : p_cur_tn->p_parent->p_parent = p_cur_tn;
1159 : 0 : p_tmp_tn->p_left = p_cur_tn->p_right;
1160 : :
1161 [ # # ]: 0 : if (p_cur_tn->p_right)
1162 : 0 : p_cur_tn->p_right->p_parent = p_tmp_tn;
1163 : :
1164 : 0 : p_cur_tn->p_left = p_cur_tn->p_parent;
1165 : 0 : p_cur_tn->p_right = p_tmp_tn;
1166 : :
1167 : 0 : p_cur_tn->p_parent = p_tmp_tn->p_parent;
1168 : 0 : p_tmp_tn->p_parent = p_cur_tn;
1169 : :
1170 [ # # ]: 0 : zxdh_comm_rb_switch_color(*pp_tmp_tn, p_tmp_tn);
1171 [ # # ]: 0 : } else if (p_cur_tn->p_parent == p_tmp_tn->p_right && p_cur_tn ==
1172 [ # # ]: 0 : p_cur_tn->p_parent->p_right) {
1173 [ # # ]: 0 : *pp_tmp_tn = p_cur_tn->p_parent;
1174 : : p_bro_tn = zxdh_comm_rb_get_brotn(p_cur_tn);
1175 : :
1176 : 0 : p_cur_tn->p_parent->p_parent = p_tmp_tn->p_parent;
1177 : :
1178 : 0 : p_tmp_tn->p_right = p_cur_tn->p_parent->p_left;
1179 : 0 : p_tmp_tn->p_parent = p_cur_tn->p_parent;
1180 : 0 : p_cur_tn->p_parent->p_left = p_tmp_tn;
1181 : :
1182 [ # # ]: 0 : if (p_bro_tn)
1183 : 0 : p_bro_tn->p_parent = p_tmp_tn;
1184 : :
1185 [ # # ]: 0 : zxdh_comm_rb_switch_color(*pp_tmp_tn, p_tmp_tn);
1186 : : } else {
1187 : 0 : *pp_tmp_tn = p_cur_tn;
1188 : 0 : p_cur_tn->p_parent->p_left = p_cur_tn->p_right;
1189 : :
1190 [ # # ]: 0 : if (p_cur_tn->p_right)
1191 : 0 : p_cur_tn->p_right->p_parent = p_cur_tn->p_parent;
1192 : :
1193 : 0 : p_cur_tn->p_parent->p_parent = p_cur_tn;
1194 : 0 : p_tmp_tn->p_right = p_cur_tn->p_left;
1195 : :
1196 [ # # ]: 0 : if (p_cur_tn->p_left)
1197 : 0 : p_cur_tn->p_left->p_parent = p_tmp_tn;
1198 : :
1199 : 0 : p_cur_tn->p_right = p_cur_tn->p_parent;
1200 : 0 : p_cur_tn->p_left = p_tmp_tn;
1201 : :
1202 : 0 : p_cur_tn->p_parent = p_tmp_tn->p_parent;
1203 : 0 : p_tmp_tn->p_parent = p_cur_tn;
1204 : :
1205 [ # # ]: 0 : zxdh_comm_rb_switch_color(*pp_tmp_tn, p_tmp_tn);
1206 : : }
1207 : : break;
1208 : : }
1209 : : } else {
1210 : : break;
1211 : : }
1212 : : }
1213 : :
1214 : 0 : return ZXDH_OK;
1215 : : }
1216 : :
1217 : : static uint32_t
1218 : 0 : zxdh_comm_rb_init(ZXDH_RB_CFG *p_rb_cfg,
1219 : : uint32_t total_num,
1220 : : uint32_t key_size,
1221 : : ZXDH_RB_CMPFUN cmpfun)
1222 : : {
1223 : : uint32_t rtn = ZXDH_OK;
1224 : : uint32_t malloc_size = 0;
1225 : :
1226 [ # # ]: 0 : if (p_rb_cfg->is_init) {
1227 : 0 : PMD_DRV_LOG(ERR, " p_rb_cfg already init!");
1228 : 0 : return ZXDH_OK;
1229 : : }
1230 : :
1231 : 0 : p_rb_cfg->key_size = key_size;
1232 : 0 : p_rb_cfg->p_root = NULL;
1233 : :
1234 [ # # ]: 0 : if (cmpfun)
1235 : 0 : p_rb_cfg->p_cmpfun = cmpfun;
1236 : : else
1237 : 0 : p_rb_cfg->p_cmpfun = zxdh_comm_rb_def_cmp;
1238 : :
1239 [ # # ]: 0 : if (total_num) {
1240 : 0 : p_rb_cfg->is_dynamic = 0;
1241 : :
1242 : 0 : rtn = zxdh_comm_double_link_init(total_num, &p_rb_cfg->tn_list);
1243 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_init");
1244 : :
1245 : 0 : rtn = zxdh_np_comm_liststack_create(total_num, &p_rb_cfg->p_lsm);
1246 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_np_comm_liststack_create");
1247 : :
1248 : 0 : p_rb_cfg->p_keybase = rte_zmalloc(NULL,
1249 : 0 : total_num * p_rb_cfg->key_size, 0);
1250 [ # # ]: 0 : if (p_rb_cfg->p_keybase == NULL) {
1251 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
1252 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1253 : : }
1254 : :
1255 : 0 : malloc_size = ((sizeof(ZXDH_RB_TN) & 0xFFFFFFFFU) * total_num) & UINT32_MAX;
1256 : :
1257 : 0 : p_rb_cfg->p_tnbase = rte_zmalloc(NULL, malloc_size, 0);
1258 [ # # ]: 0 : if (p_rb_cfg->p_tnbase == NULL) {
1259 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
1260 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1261 : : }
1262 : : } else {
1263 : 0 : p_rb_cfg->is_dynamic = 1;
1264 : :
1265 : : rtn = zxdh_comm_double_link_init(0xFFFFFFFF, &p_rb_cfg->tn_list);
1266 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_init");
1267 : : }
1268 : 0 : p_rb_cfg->is_init = 1;
1269 : :
1270 : 0 : return ZXDH_OK;
1271 : : }
1272 : :
1273 : : static uint32_t
1274 : 0 : zxdh_comm_rb_insert(ZXDH_RB_CFG *p_rb_cfg,
1275 : : void *p_key,
1276 : : void *out_val)
1277 : : {
1278 : : uint32_t rtn = 0;
1279 : : uint32_t stack_top = 1;
1280 : : int32_t cmprtn = 0;
1281 : 0 : uint32_t lsm_out = 0;
1282 : :
1283 : 0 : ZXDH_RB_TN **stack_tn[ZXDH_RBT_MAX_DEPTH] = {0};
1284 : : ZXDH_RB_TN *p_cur_tn = NULL;
1285 : : ZXDH_RB_TN *p_pre_tn = NULL;
1286 : : ZXDH_RB_TN **pp_cur_tn = NULL;
1287 : : void *p_cur_key = NULL;
1288 : : ZXDH_RB_TN *p_ins_tn = p_key;
1289 : :
1290 [ # # ]: 0 : p_cur_key = p_rb_cfg->is_dynamic ? ((ZXDH_RB_TN *)p_key)->p_key : p_key;
1291 : :
1292 : 0 : pp_cur_tn = &p_rb_cfg->p_root;
1293 : :
1294 : : for (;;) {
1295 : 0 : p_cur_tn = *pp_cur_tn;
1296 : :
1297 [ # # ]: 0 : if (!p_cur_tn) {
1298 [ # # ]: 0 : if (p_rb_cfg->is_dynamic == 0) {
1299 : 0 : rtn = zxdh_np_comm_liststack_alloc(p_rb_cfg->p_lsm, &lsm_out);
1300 : :
1301 [ # # ]: 0 : if (rtn == ZXDH_LIST_STACK_ISEMPTY_ERR)
1302 : : return ZXDH_RBT_RC_FULL;
1303 : :
1304 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_np_comm_liststack_alloc");
1305 : :
1306 : 0 : p_ins_tn = p_rb_cfg->p_tnbase + lsm_out;
1307 : :
1308 : 0 : zxdh_np_init_rbt_tn(p_ins_tn, p_rb_cfg->key_size * lsm_out +
1309 : 0 : p_rb_cfg->p_keybase);
1310 : :
1311 [ # # ]: 0 : memcpy(p_ins_tn->p_key, p_key, p_rb_cfg->key_size);
1312 : :
1313 : : zxdh_np_set_tn_lsv(p_ins_tn, lsm_out);
1314 : :
1315 [ # # ]: 0 : if (out_val)
1316 : 0 : *((uint32_t *)out_val) = lsm_out;
1317 : : } else {
1318 : : zxdh_np_init_d_node(&p_ins_tn->tn_ln, p_ins_tn);
1319 : : }
1320 : :
1321 : : zxdh_np_set_tn_color(p_ins_tn, ZXDH_RBT_RED);
1322 : :
1323 [ # # ]: 0 : if (cmprtn < 0) {
1324 [ # # ]: 0 : rtn = zxdh_comm_double_link_insert_pre(&p_ins_tn->tn_ln,
1325 : : &p_pre_tn->tn_ln, &p_rb_cfg->tn_list);
1326 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_insert_pre");
1327 [ # # ]: 0 : } else if (cmprtn > 0) {
1328 [ # # ]: 0 : rtn = zxdh_comm_double_link_insert_aft(&p_ins_tn->tn_ln,
1329 : : &p_pre_tn->tn_ln, &p_rb_cfg->tn_list);
1330 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_insert_aft");
1331 : : } else {
1332 : : RTE_ASSERT(!p_pre_tn);
1333 : :
1334 [ # # ]: 0 : rtn = zxdh_comm_double_link_insert_1st(&p_ins_tn->tn_ln,
1335 : : &p_rb_cfg->tn_list);
1336 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_insert_1st");
1337 : : }
1338 : :
1339 : : break;
1340 : : }
1341 : :
1342 : 0 : stack_tn[stack_top++] = pp_cur_tn;
1343 : : p_pre_tn = p_cur_tn;
1344 : 0 : cmprtn = p_rb_cfg->p_cmpfun(p_cur_key, p_cur_tn->p_key, p_rb_cfg->key_size);
1345 : :
1346 [ # # ]: 0 : if (cmprtn > 0) {
1347 : 0 : pp_cur_tn = &p_cur_tn->p_right;
1348 [ # # ]: 0 : } else if (cmprtn < 0) {
1349 : 0 : pp_cur_tn = &p_cur_tn->p_left;
1350 : : } else {
1351 : 0 : PMD_DRV_LOG(ERR, "rb_key is same");
1352 : :
1353 [ # # ]: 0 : if (p_rb_cfg->is_dynamic) {
1354 [ # # ]: 0 : if (out_val)
1355 : 0 : *((ZXDH_RB_TN **)out_val) = p_cur_tn;
1356 : : } else {
1357 [ # # ]: 0 : if (out_val)
1358 : 0 : *((uint32_t *)out_val) = zxdh_np_get_tn_lsv(p_cur_tn);
1359 : : }
1360 : :
1361 : 0 : return ZXDH_RBT_RC_UPDATE;
1362 : : }
1363 : : }
1364 : :
1365 [ # # ]: 0 : p_ins_tn->p_parent = (stack_top > 1) ? *stack_tn[stack_top - 1] : NULL;
1366 : 0 : stack_tn[stack_top] = pp_cur_tn;
1367 : :
1368 : 0 : *pp_cur_tn = p_ins_tn;
1369 : :
1370 : 0 : rtn = zxdh_comm_rb_handle_ins(p_rb_cfg, stack_tn, stack_top);
1371 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_rb_handle_ins");
1372 : :
1373 [ # # ]: 0 : if (p_rb_cfg->is_dynamic) {
1374 [ # # ]: 0 : if (out_val)
1375 : 0 : *((ZXDH_RB_TN **)out_val) = p_ins_tn;
1376 : : }
1377 : :
1378 : : return ZXDH_OK;
1379 : : }
1380 : :
1381 : : static uint32_t
1382 : 0 : zxdh_comm_rb_search(ZXDH_RB_CFG *p_rb_cfg,
1383 : : void *p_key,
1384 : : void *out_val)
1385 : : {
1386 : : int32_t cmprtn = 0;
1387 : : ZXDH_RB_TN *p_cur_tn = NULL;
1388 : :
1389 : 0 : p_cur_tn = p_rb_cfg->p_root;
1390 : :
1391 [ # # ]: 0 : while (p_cur_tn) {
1392 : 0 : cmprtn = p_rb_cfg->p_cmpfun(p_key, p_cur_tn->p_key, p_rb_cfg->key_size);
1393 : :
1394 [ # # ]: 0 : if (cmprtn > 0)
1395 : 0 : p_cur_tn = p_cur_tn->p_right;
1396 [ # # ]: 0 : else if (cmprtn < 0)
1397 : 0 : p_cur_tn = p_cur_tn->p_left;
1398 : : else
1399 : : break;
1400 : : }
1401 : :
1402 [ # # ]: 0 : if (!p_cur_tn) {
1403 : 0 : PMD_DRV_LOG(DEBUG, "rb srh fail");
1404 : 0 : return ZXDH_RBT_RC_SRHFAIL;
1405 : : }
1406 : :
1407 [ # # ]: 0 : if (p_rb_cfg->is_dynamic)
1408 : 0 : *(ZXDH_RB_TN **)out_val = p_cur_tn;
1409 : : else
1410 : 0 : *(uint32_t *)out_val = zxdh_np_get_tn_lsv(p_cur_tn);
1411 : :
1412 : : return ZXDH_OK;
1413 : : }
1414 : :
1415 : : static uint32_t
1416 : 0 : zxdh_comm_rb_handle_del(__rte_unused ZXDH_RB_CFG *p_rb_cfg,
1417 : : ZXDH_RB_TN ***stack_tn,
1418 : : uint32_t stack_top)
1419 : : {
1420 : : ZXDH_RB_TN **pp_cur_tn = NULL;
1421 : : ZXDH_RB_TN *p_cur_tn = NULL;
1422 : : ZXDH_RB_TN *p_tmp_tn = NULL;
1423 : : ZXDH_RB_TN *p_unc_tn = NULL;
1424 : : ZXDH_RB_TN *p_par_tn = NULL;
1425 : :
1426 [ # # ]: 0 : while (stack_top > 1) {
1427 : 0 : pp_cur_tn = stack_tn[stack_top];
1428 : 0 : p_cur_tn = *pp_cur_tn;
1429 : :
1430 : 0 : p_par_tn = *stack_tn[stack_top - 1];
1431 : :
1432 [ # # # # ]: 0 : if (p_cur_tn && p_cur_tn->p_parent) {
1433 : : p_unc_tn = zxdh_comm_rb_get_brotn(p_cur_tn);
1434 [ # # # # ]: 0 : } else if (p_cur_tn && !p_cur_tn->p_parent) {
1435 : : RTE_ASSERT(p_par_tn == p_cur_tn->p_parent);
1436 : :
1437 : : zxdh_np_set_tn_color(p_cur_tn, ZXDH_RBT_BLACK);
1438 : :
1439 : : break;
1440 : : }
1441 [ # # ]: 0 : if (!p_cur_tn) {
1442 : : RTE_ASSERT(!p_cur_tn);
1443 : :
1444 [ # # ]: 0 : if (p_par_tn)
1445 [ # # ]: 0 : p_unc_tn = p_par_tn->p_left ? p_par_tn->p_left : p_par_tn->p_right;
1446 : : else
1447 : : break;
1448 : : }
1449 : :
1450 : : if (p_unc_tn)
1451 : : RTE_ASSERT(p_unc_tn->p_parent == p_par_tn);
1452 : :
1453 [ # # ]: 0 : if (!p_unc_tn) {
1454 : : RTE_ASSERT(0);
1455 : : RTE_ASSERT(zxdh_np_get_tn_color(p_par_tn) == ZXDH_RBT_RED);
1456 : :
1457 : : zxdh_np_set_tn_color(p_par_tn, ZXDH_RBT_BLACK);
1458 : :
1459 : : break;
1460 : : }
1461 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn) == ZXDH_RBT_RED) {
1462 [ # # ]: 0 : if (p_unc_tn == p_par_tn->p_left) {
1463 : 0 : *stack_tn[stack_top - 1] = p_unc_tn;
1464 : 0 : p_unc_tn->p_parent = p_par_tn->p_parent;
1465 : 0 : p_par_tn->p_left = p_unc_tn->p_right;
1466 : :
1467 [ # # ]: 0 : if (p_unc_tn->p_right)
1468 : 0 : p_unc_tn->p_right->p_parent = p_par_tn;
1469 : :
1470 : 0 : p_par_tn->p_parent = p_unc_tn;
1471 : 0 : p_unc_tn->p_right = p_par_tn;
1472 : :
1473 : 0 : stack_tn[stack_top++] = &p_unc_tn->p_right;
1474 : 0 : stack_tn[stack_top] = &p_par_tn->p_right;
1475 : : } else {
1476 : : RTE_ASSERT(p_unc_tn == p_par_tn->p_right);
1477 : 0 : *stack_tn[stack_top - 1] = p_unc_tn;
1478 : 0 : p_unc_tn->p_parent = p_par_tn->p_parent;
1479 : 0 : p_par_tn->p_right = p_unc_tn->p_left;
1480 : :
1481 [ # # ]: 0 : if (p_unc_tn->p_left)
1482 : 0 : p_unc_tn->p_left->p_parent = p_par_tn;
1483 : :
1484 : 0 : p_par_tn->p_parent = p_unc_tn;
1485 : 0 : p_unc_tn->p_left = p_par_tn;
1486 : :
1487 : 0 : stack_tn[stack_top++] = &p_unc_tn->p_left;
1488 : 0 : stack_tn[stack_top] = &p_par_tn->p_left;
1489 : : }
1490 : :
1491 : : zxdh_comm_rb_switch_color(p_unc_tn, p_par_tn);
1492 : : } else {
1493 [ # # # # : 0 : if (zxdh_np_get_tn_color(p_unc_tn->p_left) == ZXDH_RBT_BLACK &&
# # ]
1494 [ # # ]: 0 : zxdh_np_get_tn_color(p_unc_tn->p_right) == ZXDH_RBT_BLACK) {
1495 [ # # # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn->p_parent) == ZXDH_RBT_BLACK) {
1496 : : zxdh_np_set_tn_color(p_unc_tn, ZXDH_RBT_RED);
1497 : : stack_top--;
1498 : : } else {
1499 : : RTE_ASSERT(zxdh_np_get_tn_color(p_unc_tn->p_parent)
1500 : : == ZXDH_RBT_RED);
1501 : :
1502 : : zxdh_comm_rb_switch_color(p_unc_tn->p_parent, p_unc_tn);
1503 : :
1504 : : break;
1505 : : }
1506 [ # # ]: 0 : } else if (p_unc_tn == p_par_tn->p_right) {
1507 [ # # # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn->p_right) == ZXDH_RBT_RED) {
1508 : 0 : *stack_tn[stack_top - 1] = p_unc_tn;
1509 : 0 : p_unc_tn->p_parent = p_par_tn->p_parent;
1510 : 0 : p_par_tn->p_right = p_unc_tn->p_left;
1511 : :
1512 [ # # ]: 0 : if (p_unc_tn->p_left)
1513 : 0 : p_unc_tn->p_left->p_parent = p_par_tn;
1514 : :
1515 : 0 : p_par_tn->p_parent = p_unc_tn;
1516 : 0 : p_unc_tn->p_left = p_par_tn;
1517 : :
1518 : : zxdh_comm_rb_switch_color(p_unc_tn, p_par_tn);
1519 : :
1520 : 0 : zxdh_np_set_tn_color(p_unc_tn->p_right, ZXDH_RBT_BLACK);
1521 : :
1522 : : break;
1523 : : }
1524 : : RTE_ASSERT(zxdh_np_get_tn_color(p_unc_tn->p_left)
1525 : : == ZXDH_RBT_RED);
1526 : :
1527 : : p_tmp_tn = p_unc_tn->p_left;
1528 : :
1529 : 0 : p_par_tn->p_right = p_tmp_tn;
1530 : 0 : p_tmp_tn->p_parent = p_par_tn;
1531 : 0 : p_unc_tn->p_left = p_tmp_tn->p_right;
1532 : :
1533 [ # # ]: 0 : if (p_tmp_tn->p_right)
1534 : 0 : p_tmp_tn->p_right->p_parent = p_unc_tn;
1535 : :
1536 : 0 : p_tmp_tn->p_right = p_unc_tn;
1537 : 0 : p_unc_tn->p_parent = p_tmp_tn;
1538 : :
1539 : : zxdh_comm_rb_switch_color(p_tmp_tn, p_unc_tn);
1540 : : } else {
1541 : : RTE_ASSERT(p_unc_tn == p_par_tn->p_left);
1542 : :
1543 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_unc_tn->p_left) == ZXDH_RBT_RED) {
1544 : 0 : *stack_tn[stack_top - 1] = p_unc_tn;
1545 : 0 : p_unc_tn->p_parent = p_par_tn->p_parent;
1546 : 0 : p_par_tn->p_left = p_unc_tn->p_right;
1547 : :
1548 [ # # ]: 0 : if (p_unc_tn->p_right)
1549 : 0 : p_unc_tn->p_right->p_parent = p_par_tn;
1550 : :
1551 : 0 : p_par_tn->p_parent = p_unc_tn;
1552 : 0 : p_unc_tn->p_right = p_par_tn;
1553 : :
1554 : : zxdh_comm_rb_switch_color(p_unc_tn, p_par_tn);
1555 : :
1556 : 0 : zxdh_np_set_tn_color(p_unc_tn->p_left, ZXDH_RBT_BLACK);
1557 : : break;
1558 : : }
1559 : : RTE_ASSERT(zxdh_np_get_tn_color(p_unc_tn->p_right)
1560 : : == ZXDH_RBT_RED);
1561 : :
1562 : 0 : p_tmp_tn = p_unc_tn->p_right;
1563 : :
1564 : 0 : p_par_tn->p_left = p_tmp_tn;
1565 : 0 : p_tmp_tn->p_parent = p_par_tn;
1566 : 0 : p_unc_tn->p_right = p_tmp_tn->p_left;
1567 : :
1568 [ # # ]: 0 : if (p_tmp_tn->p_left)
1569 : 0 : p_tmp_tn->p_left->p_parent = p_unc_tn;
1570 : :
1571 : 0 : p_tmp_tn->p_left = p_unc_tn;
1572 : 0 : p_unc_tn->p_parent = p_tmp_tn;
1573 : :
1574 : : zxdh_comm_rb_switch_color(p_tmp_tn, p_unc_tn);
1575 : : }
1576 : : }
1577 : : }
1578 : :
1579 : 0 : return ZXDH_OK;
1580 : : }
1581 : :
1582 : : static uint32_t
1583 : 0 : zxdh_comm_rb_delete(ZXDH_RB_CFG *p_rb_cfg,
1584 : : void *p_key,
1585 : : void *out_val)
1586 : : {
1587 : : uint32_t rtn = 0;
1588 : : uint32_t stack_top = 1;
1589 : : int32_t cmprtn = 0;
1590 : : uint32_t rsv_stack = 0;
1591 : : uint32_t del_is_red = 0;
1592 : 0 : ZXDH_RB_TN **stack_tn[ZXDH_RBT_MAX_DEPTH] = {0};
1593 : : ZXDH_RB_TN *p_cur_tn = NULL;
1594 : : ZXDH_RB_TN **pp_cur_tn = NULL;
1595 : : void *p_cur_key = NULL;
1596 : : ZXDH_RB_TN *p_rsv_tn = NULL;
1597 : : ZXDH_RB_TN *p_del_tn = NULL;
1598 : :
1599 : : p_cur_key = p_key;
1600 : :
1601 : 0 : pp_cur_tn = &p_rb_cfg->p_root;
1602 : :
1603 : : for (;;) {
1604 : 0 : p_cur_tn = *pp_cur_tn;
1605 : :
1606 [ # # ]: 0 : if (!p_cur_tn)
1607 : : return ZXDH_RBT_RC_SRHFAIL;
1608 : :
1609 : 0 : stack_tn[stack_top++] = pp_cur_tn;
1610 : :
1611 : 0 : cmprtn = p_rb_cfg->p_cmpfun(p_cur_key, p_cur_tn->p_key, p_rb_cfg->key_size);
1612 : :
1613 [ # # ]: 0 : if (cmprtn > 0) {
1614 : 0 : pp_cur_tn = &p_cur_tn->p_right;
1615 [ # # ]: 0 : } else if (cmprtn < 0) {
1616 : 0 : pp_cur_tn = &p_cur_tn->p_left;
1617 : : } else {
1618 : 0 : PMD_DRV_LOG(DEBUG, " find the key!");
1619 : :
1620 : : break;
1621 : : }
1622 : : }
1623 : :
1624 : : rsv_stack = stack_top - 1;
1625 : : p_rsv_tn = p_cur_tn;
1626 : :
1627 : 0 : pp_cur_tn = &p_cur_tn->p_right;
1628 : 0 : p_cur_tn = *pp_cur_tn;
1629 : :
1630 [ # # ]: 0 : if (p_cur_tn) {
1631 : 0 : stack_tn[stack_top++] = pp_cur_tn;
1632 : :
1633 : 0 : pp_cur_tn = &p_cur_tn->p_left;
1634 : 0 : p_cur_tn = *pp_cur_tn;
1635 : :
1636 [ # # ]: 0 : while (p_cur_tn) {
1637 : 0 : stack_tn[stack_top++] = pp_cur_tn;
1638 : 0 : pp_cur_tn = &p_cur_tn->p_left;
1639 : 0 : p_cur_tn = *pp_cur_tn;
1640 : : }
1641 : :
1642 : 0 : p_del_tn = *stack_tn[stack_top - 1];
1643 : :
1644 : 0 : *stack_tn[stack_top - 1] = p_del_tn->p_right;
1645 : :
1646 [ # # ]: 0 : if (p_del_tn->p_right)
1647 : 0 : p_del_tn->p_right->p_parent = p_del_tn->p_parent;
1648 : :
1649 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_del_tn) == ZXDH_RBT_RED)
1650 : : del_is_red = 1;
1651 : :
1652 : 0 : *stack_tn[rsv_stack] = p_del_tn;
1653 : :
1654 : 0 : stack_tn[rsv_stack + 1] = &p_del_tn->p_right;
1655 : :
1656 : : zxdh_np_set_tn_color(p_del_tn, zxdh_np_get_tn_color(p_rsv_tn));
1657 : 0 : p_del_tn->p_parent = p_rsv_tn->p_parent;
1658 : :
1659 : 0 : p_del_tn->p_left = p_rsv_tn->p_left;
1660 : :
1661 [ # # ]: 0 : if (p_rsv_tn->p_left)
1662 : 0 : p_rsv_tn->p_left->p_parent = p_del_tn;
1663 : :
1664 : 0 : p_del_tn->p_right = p_rsv_tn->p_right;
1665 : :
1666 [ # # ]: 0 : if (p_rsv_tn->p_right)
1667 : 0 : p_rsv_tn->p_right->p_parent = p_del_tn;
1668 : : } else {
1669 [ # # ]: 0 : if (zxdh_np_get_tn_color(p_rsv_tn) == ZXDH_RBT_RED)
1670 : : del_is_red = 1;
1671 : :
1672 : 0 : *stack_tn[stack_top - 1] = p_rsv_tn->p_left;
1673 : :
1674 [ # # ]: 0 : if (p_rsv_tn->p_left)
1675 : 0 : p_rsv_tn->p_left->p_parent = p_rsv_tn->p_parent;
1676 : : }
1677 : :
1678 : 0 : stack_top--;
1679 [ # # # # ]: 0 : if (zxdh_np_get_tn_color(*stack_tn[stack_top]) == ZXDH_RBT_RED) {
1680 : : zxdh_np_set_tn_color(*stack_tn[stack_top], ZXDH_RBT_BLACK);
1681 [ # # ]: 0 : } else if (!del_is_red) {
1682 : 0 : rtn = zxdh_comm_rb_handle_del(p_rb_cfg, stack_tn, stack_top);
1683 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_rb_handle_del");
1684 : : }
1685 : :
1686 : : rtn = zxdh_comm_double_link_del(&p_rsv_tn->tn_ln, &p_rb_cfg->tn_list);
1687 : : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_del");
1688 : :
1689 [ # # ]: 0 : if (p_rb_cfg->is_dynamic) {
1690 : 0 : *(ZXDH_RB_TN **)out_val = p_rsv_tn;
1691 : : } else {
1692 : 0 : rtn = zxdh_comm_liststack_free(p_rb_cfg->p_lsm, zxdh_np_get_tn_lsv(p_rsv_tn));
1693 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_liststack_free");
1694 : :
1695 : 0 : *(uint32_t *)out_val = zxdh_np_get_tn_lsv(p_rsv_tn);
1696 : :
1697 : 0 : memset(p_rsv_tn->p_key, 0, p_rb_cfg->key_size);
1698 : : memset(p_rsv_tn, 0, sizeof(ZXDH_RB_TN));
1699 : : }
1700 : :
1701 : : return ZXDH_OK;
1702 : : }
1703 : :
1704 : : static uint32_t
1705 : 0 : zxdh_comm_liststack_destroy(ZXDH_LISTSTACK_MANAGER *p_list)
1706 : : {
1707 [ # # ]: 0 : if (p_list == NULL) {
1708 : 0 : PMD_DRV_LOG(ERR, "p_list point null");
1709 : 0 : return ZXDH_LIST_STACK_POINT_NULL;
1710 : : }
1711 : 0 : rte_free(p_list);
1712 : :
1713 : 0 : return ZXDH_OK;
1714 : : }
1715 : :
1716 : : static uint32_t
1717 : 0 : zxdh_comm_rb_destroy(ZXDH_RB_CFG *p_rb_cfg)
1718 : : {
1719 : : uint32_t rtn = 0;
1720 : :
1721 [ # # ]: 0 : if (p_rb_cfg->is_dynamic == 0)
1722 : 0 : zxdh_comm_liststack_destroy(p_rb_cfg->p_lsm);
1723 : :
1724 [ # # ]: 0 : if (p_rb_cfg->p_keybase != NULL) {
1725 : 0 : rte_free(p_rb_cfg->p_keybase);
1726 : 0 : p_rb_cfg->p_keybase = NULL;
1727 : : }
1728 : :
1729 [ # # ]: 0 : if (p_rb_cfg->p_tnbase != NULL) {
1730 : 0 : rte_free(p_rb_cfg->p_tnbase);
1731 : : p_rb_cfg->p_tnbase = NULL;
1732 : : }
1733 : :
1734 : : memset(p_rb_cfg, 0, sizeof(ZXDH_RB_CFG));
1735 : :
1736 : 0 : return rtn;
1737 : : }
1738 : :
1739 : : static int
1740 : 0 : zxdh_np_se_apt_key_default_cmp(void *p_new_key,
1741 : : void *p_old_key, __rte_unused uint32_t key_len)
1742 : : {
1743 : 0 : return memcmp((uint32_t *)p_new_key, (uint32_t *)p_old_key, sizeof(uint32_t));
1744 : : }
1745 : :
1746 : : static uint32_t
1747 : 0 : zxdh_np_se_apt_rb_insert(ZXDH_RB_CFG *rb_cfg, void *p_data, uint32_t len)
1748 : : {
1749 : : uint8_t *p_rb_key = NULL;
1750 : : ZXDH_RB_TN *p_rb_new = NULL;
1751 : 0 : ZXDH_RB_TN *p_rb_rtn = NULL;
1752 : : uint32_t rc = ZXDH_OK;
1753 : :
1754 : 0 : p_rb_key = rte_zmalloc(NULL, len, 0);
1755 [ # # ]: 0 : if (p_rb_key == NULL) {
1756 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
1757 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1758 : : }
1759 : : memcpy(p_rb_key, p_data, len);
1760 : :
1761 : 0 : p_rb_new = rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
1762 [ # # ]: 0 : if (NULL == (p_rb_new)) {
1763 : 0 : rte_free(p_rb_key);
1764 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
1765 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1766 : : }
1767 : : zxdh_np_init_rbt_tn(p_rb_new, p_rb_key);
1768 : :
1769 : 0 : rc = zxdh_comm_rb_insert(rb_cfg, p_rb_new, &p_rb_rtn);
1770 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_UPDATE) {
1771 [ # # ]: 0 : if (p_rb_rtn == NULL) {
1772 : 0 : PMD_DRV_LOG(ERR, "p_rb_rtn point null!");
1773 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
1774 : : }
1775 : :
1776 : 0 : memcpy(p_rb_rtn->p_key, p_data, len);
1777 : 0 : rte_free(p_rb_new);
1778 : 0 : rte_free(p_rb_key);
1779 : 0 : PMD_DRV_LOG(DEBUG, "update exist entry!");
1780 : 0 : return ZXDH_OK;
1781 : : }
1782 : :
1783 : : return rc;
1784 : : }
1785 : :
1786 : : static uint32_t
1787 : 0 : zxdh_np_se_apt_rb_delete(ZXDH_RB_CFG *rb_cfg, void *p_data, __rte_unused uint32_t len)
1788 : : {
1789 : : uint32_t rc = ZXDH_OK;
1790 : 0 : ZXDH_RB_TN *p_rb_rtn = NULL;
1791 : :
1792 : 0 : rc = zxdh_comm_rb_delete(rb_cfg, p_data, &p_rb_rtn);
1793 [ # # ]: 0 : if (rc != ZXDH_OK)
1794 : : return rc;
1795 : 0 : rte_free(p_rb_rtn->p_key);
1796 : 0 : rte_free(p_rb_rtn);
1797 : :
1798 : 0 : return rc;
1799 : : }
1800 : :
1801 : : static uint32_t
1802 : 0 : zxdh_np_se_apt_rb_search(ZXDH_RB_CFG *rb_cfg, void *p_data, uint32_t len)
1803 : : {
1804 : : uint32_t rc = ZXDH_OK;
1805 : 0 : ZXDH_RB_TN *p_rb_rtn = NULL;
1806 : :
1807 : 0 : rc = zxdh_comm_rb_search(rb_cfg, p_data, &p_rb_rtn);
1808 [ # # ]: 0 : if (rc != ZXDH_OK)
1809 : : return rc;
1810 : :
1811 : 0 : memcpy(p_data, p_rb_rtn->p_key, len);
1812 : 0 : return rc;
1813 : : }
1814 : :
1815 : : static uint32_t
1816 : 0 : zxdh_np_dev_init(void)
1817 : : {
1818 [ # # ]: 0 : if (g_dev_mgr.is_init) {
1819 : 0 : PMD_DRV_LOG(ERR, "Dev is already initialized");
1820 : 0 : return 0;
1821 : : }
1822 : :
1823 : 0 : g_dev_mgr.device_num = 0;
1824 : 0 : g_dev_mgr.is_init = 1;
1825 : :
1826 : 0 : return 0;
1827 : : }
1828 : :
1829 : : static void
1830 : : zxdh_np_dev_vport_get(uint32_t dev_id, uint32_t *vport)
1831 : : {
1832 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1833 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
1834 : :
1835 : 0 : *vport = p_dev_info->vport;
1836 : : }
1837 : :
1838 : : static void
1839 : : zxdh_np_dev_agent_addr_get(uint32_t dev_id, uint64_t *agent_addr)
1840 : : {
1841 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1842 : : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
1843 : :
1844 : 0 : *agent_addr = p_dev_info->agent_addr;
1845 : : }
1846 : :
1847 : : static void
1848 : 0 : zxdh_np_dev_fw_bar_msg_num_set(uint32_t dev_id, uint32_t bar_msg_num)
1849 : : {
1850 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1851 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
1852 : :
1853 : 0 : p_dev_info->fw_bar_msg_num = bar_msg_num;
1854 : :
1855 : 0 : PMD_DRV_LOG(INFO, "fw_bar_msg_num_set:fw support agent msg num = %u!", bar_msg_num);
1856 : 0 : }
1857 : :
1858 : : static void
1859 : : zxdh_np_dev_fw_bar_msg_num_get(uint32_t dev_id, uint32_t *bar_msg_num)
1860 : : {
1861 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1862 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
1863 : :
1864 : 0 : *bar_msg_num = p_dev_info->fw_bar_msg_num;
1865 : : }
1866 : :
1867 : : static uint32_t
1868 : 0 : zxdh_np_dev_opr_spinlock_get(uint32_t dev_id, uint32_t type, ZXDH_SPINLOCK_T **p_spinlock_out)
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[dev_id];
1872 : :
1873 [ # # ]: 0 : if (p_dev_info == NULL) {
1874 : 0 : PMD_DRV_LOG(ERR, "Get dev_info[ %u ] fail!", dev_id);
1875 : 0 : return ZXDH_DEV_TYPE_INVALID;
1876 : : }
1877 : :
1878 [ # # # ]: 0 : switch (type) {
1879 : 0 : case ZXDH_DEV_SPINLOCK_T_DTB:
1880 : 0 : *p_spinlock_out = &p_dev_info->dtb_spinlock;
1881 : 0 : break;
1882 : 0 : case ZXDH_DEV_SPINLOCK_T_SMMU0:
1883 : 0 : *p_spinlock_out = &p_dev_info->smmu0_spinlock;
1884 : 0 : break;
1885 : 0 : default:
1886 : 0 : PMD_DRV_LOG(ERR, "spinlock type is invalid!");
1887 : 0 : return ZXDH_ERR;
1888 : : }
1889 : :
1890 : : return ZXDH_OK;
1891 : : }
1892 : :
1893 : : static uint32_t
1894 : : zxdh_np_dev_dtb_opr_spinlock_get(uint32_t dev_id, uint32_t type,
1895 : : uint32_t index, ZXDH_SPINLOCK_T **p_spinlock_out)
1896 : : {
1897 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1898 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
1899 : :
1900 : : switch (type) {
1901 : : case ZXDH_DEV_SPINLOCK_T_DTB:
1902 : : *p_spinlock_out = &p_dev_info->dtb_queue_spinlock[index];
1903 : : break;
1904 : : default:
1905 : : PMD_DRV_LOG(ERR, "spinlock type is invalid!");
1906 : : return ZXDH_ERR;
1907 : : }
1908 : :
1909 : : return ZXDH_OK;
1910 : : }
1911 : :
1912 : : static void
1913 : : zxdh_np_dev_hash_opr_spinlock_get(uint32_t dev_id,
1914 : : uint32_t fun_id, ZXDH_SPINLOCK_T **p_spinlock_out)
1915 : : {
1916 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
1917 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
1918 : :
1919 : : *p_spinlock_out = &p_dev_info->hash_spinlock[fun_id];
1920 : : }
1921 : :
1922 : : static uint32_t
1923 : 0 : zxdh_np_dev_read_channel(uint32_t dev_id, uint32_t addr, uint32_t size, uint32_t *p_data)
1924 : : {
1925 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
1926 : :
1927 : 0 : p_dev_info = ZXDH_DEV_INFO_GET(dev_id);
1928 : :
1929 [ # # ]: 0 : if (p_dev_info == NULL) {
1930 : 0 : PMD_DRV_LOG(ERR, "Error: Channel[%u] dev is not exist",
1931 : : dev_id);
1932 : 0 : return ZXDH_ERR;
1933 : : }
1934 [ # # ]: 0 : if (p_dev_info->access_type == ZXDH_DEV_ACCESS_TYPE_PCIE) {
1935 : 0 : p_dev_info->p_pcie_read_fun(dev_id, addr, size, p_data);
1936 : : } else {
1937 : 0 : PMD_DRV_LOG(ERR, "Dev access type[ %u ] is invalid",
1938 : : p_dev_info->access_type);
1939 : 0 : return ZXDH_ERR;
1940 : : }
1941 : :
1942 : 0 : return ZXDH_OK;
1943 : : }
1944 : :
1945 : : static uint32_t
1946 : 0 : zxdh_np_dev_write_channel(uint32_t dev_id, uint32_t addr, uint32_t size, uint32_t *p_data)
1947 : : {
1948 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
1949 : :
1950 : 0 : p_dev_info = ZXDH_DEV_INFO_GET(dev_id);
1951 : :
1952 [ # # ]: 0 : if (p_dev_info == NULL) {
1953 : 0 : PMD_DRV_LOG(ERR, "Error: Channel[%u] dev is not exist", dev_id);
1954 : 0 : return ZXDH_ERR;
1955 : : }
1956 [ # # ]: 0 : if (p_dev_info->access_type == ZXDH_DEV_ACCESS_TYPE_PCIE) {
1957 : 0 : p_dev_info->p_pcie_write_fun(dev_id, addr, size, p_data);
1958 : : } else {
1959 : 0 : PMD_DRV_LOG(ERR, "Dev access type[ %u ] is invalid", p_dev_info->access_type);
1960 : 0 : return ZXDH_ERR;
1961 : : }
1962 : :
1963 : 0 : return ZXDH_OK;
1964 : : }
1965 : :
1966 : : static void
1967 : : zxdh_np_pci_write32(uint64_t abs_addr, uint32_t *p_data)
1968 : : {
1969 : : uint32_t data = 0;
1970 : : uint64_t addr = 0;
1971 : :
1972 : 0 : data = *p_data;
1973 : :
1974 : : if (zxdh_np_comm_is_big_endian())
1975 : : data = ZXDH_COMM_CONVERT32(data);
1976 : :
1977 : : addr = abs_addr + ZXDH_SYS_VF_NP_BASE_OFFSET;
1978 : 0 : *((volatile uint32_t *)addr) = data;
1979 : : }
1980 : :
1981 : : static void
1982 : : zxdh_np_pci_read32(uint64_t abs_addr, uint32_t *p_data)
1983 : : {
1984 : : uint32_t data = 0;
1985 : : uint64_t addr = 0;
1986 : :
1987 : : addr = abs_addr + ZXDH_SYS_VF_NP_BASE_OFFSET;
1988 : 0 : data = *((volatile uint32_t *)addr);
1989 : :
1990 : : if (zxdh_np_comm_is_big_endian())
1991 : : data = ZXDH_COMM_CONVERT32(data);
1992 : :
1993 : 0 : *p_data = data;
1994 : : }
1995 : :
1996 : : static uint64_t
1997 : : zxdh_np_dev_get_pcie_addr(uint32_t dev_id)
1998 : : {
1999 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
2000 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
2001 : :
2002 : : p_dev_mgr = &g_dev_mgr;
2003 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
2004 : :
2005 : 0 : if (p_dev_info == NULL)
2006 : : return ZXDH_DEV_TYPE_INVALID;
2007 : :
2008 : 0 : return p_dev_info->pcie_addr;
2009 : : }
2010 : :
2011 : : static void
2012 [ # # ]: 0 : zxdh_np_dev_pcie_default_write(uint32_t dev_id, uint32_t addr, uint32_t size, uint32_t *p_data)
2013 : : {
2014 : : uint32_t i;
2015 : : uint64_t abs_addr = 0;
2016 : :
2017 : 0 : abs_addr = zxdh_np_dev_get_pcie_addr(dev_id) + addr;
2018 : :
2019 [ # # ]: 0 : for (i = 0; i < size; i++)
2020 : 0 : zxdh_np_pci_write32(abs_addr + 4 * i, p_data + i);
2021 : 0 : }
2022 : :
2023 : : static void
2024 [ # # ]: 0 : zxdh_np_dev_pcie_default_read(uint32_t dev_id, uint32_t addr, uint32_t size, uint32_t *p_data)
2025 : : {
2026 : : uint32_t i;
2027 : : uint64_t abs_addr = 0;
2028 : :
2029 : 0 : abs_addr = zxdh_np_dev_get_pcie_addr(dev_id) + addr;
2030 : :
2031 [ # # ]: 0 : for (i = 0; i < size; i++)
2032 : 0 : zxdh_np_pci_read32(abs_addr + 4 * i, p_data + i);
2033 : 0 : }
2034 : :
2035 : : static uint32_t
2036 : 0 : zxdh_np_read(uint32_t dev_id, uint32_t addr, uint32_t *p_data)
2037 : : {
2038 : 0 : return zxdh_np_dev_read_channel(dev_id, addr, 1, p_data);
2039 : : }
2040 : :
2041 : : static uint32_t
2042 : 0 : zxdh_np_write(uint32_t dev_id, uint32_t addr, uint32_t *p_data)
2043 : : {
2044 : 0 : return zxdh_np_dev_write_channel(dev_id, addr, 1, p_data);
2045 : : }
2046 : :
2047 : : static uint32_t
2048 : 0 : zxdh_np_se_smmu0_write(uint32_t dev_id, uint32_t addr, uint32_t *p_data)
2049 : : {
2050 : 0 : return zxdh_np_write(dev_id, addr, p_data);
2051 : : }
2052 : :
2053 : : static uint32_t
2054 : 0 : zxdh_np_se_smmu0_read(uint32_t dev_id, uint32_t addr, uint32_t *p_data)
2055 : : {
2056 : 0 : return zxdh_np_read(dev_id, addr, p_data);
2057 : : }
2058 : :
2059 : : static ZXDH_REG_T g_dpp_reg_info[] = {
2060 : : {
2061 : : .reg_name = "cpu_ind_cmd",
2062 : : .reg_no = 669,
2063 : : .module_no = SMMU0,
2064 : : .flags = ZXDH_REG_FLAG_DIRECT,
2065 : : .array_type = ZXDH_REG_NUL_ARRAY,
2066 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x14,
2067 : : .width = (32 / 8),
2068 : : .m_size = 0,
2069 : : .n_size = 0,
2070 : : .m_step = 0,
2071 : : .n_step = 0,
2072 : : .field_num = 4,
2073 : : .p_fields = g_smmu0_smmu0_cpu_ind_cmd_reg,
2074 : : .p_write_fun = zxdh_np_se_smmu0_write,
2075 : : .p_read_fun = zxdh_np_se_smmu0_read,
2076 : : },
2077 : : {
2078 : : .reg_name = "cpu_ind_rd_done",
2079 : : .reg_no = 670,
2080 : : .module_no = SMMU0,
2081 : : .flags = ZXDH_REG_FLAG_DIRECT,
2082 : : .array_type = ZXDH_REG_NUL_ARRAY,
2083 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x40,
2084 : : .width = (32 / 8),
2085 : : .m_size = 0,
2086 : : .n_size = 0,
2087 : : .m_step = 0,
2088 : : .n_step = 0,
2089 : : .field_num = 1,
2090 : : .p_fields = g_smmu0_smmu0_cpu_ind_rd_done_reg,
2091 : : .p_write_fun = zxdh_np_se_smmu0_write,
2092 : : .p_read_fun = zxdh_np_se_smmu0_read,
2093 : : },
2094 : : {
2095 : : .reg_name = "cpu_ind_rdat0",
2096 : : .reg_no = 671,
2097 : : .module_no = SMMU0,
2098 : : .flags = ZXDH_REG_FLAG_DIRECT,
2099 : : .array_type = ZXDH_REG_NUL_ARRAY,
2100 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x44,
2101 : : .width = (32 / 8),
2102 : : .m_size = 0,
2103 : : .n_size = 0,
2104 : : .m_step = 0,
2105 : : .n_step = 0,
2106 : : .field_num = 1,
2107 : : .p_fields = g_smmu0_smmu0_cpu_ind_rdat0_reg,
2108 : : .p_write_fun = zxdh_np_se_smmu0_write,
2109 : : .p_read_fun = zxdh_np_se_smmu0_read,
2110 : : },
2111 : : {
2112 : : .reg_name = "cpu_ind_rdat1",
2113 : : .reg_no = 672,
2114 : : .module_no = SMMU0,
2115 : : .flags = ZXDH_REG_FLAG_DIRECT,
2116 : : .array_type = ZXDH_REG_NUL_ARRAY,
2117 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x48,
2118 : : .width = (32 / 8),
2119 : : .m_size = 0,
2120 : : .n_size = 0,
2121 : : .m_step = 0,
2122 : : .n_step = 0,
2123 : : .field_num = 1,
2124 : : .p_fields = g_smmu0_smmu0_cpu_ind_rdat1_reg,
2125 : : .p_write_fun = zxdh_np_se_smmu0_write,
2126 : : .p_read_fun = zxdh_np_se_smmu0_read,
2127 : : },
2128 : : {
2129 : : .reg_name = "cpu_ind_rdat2",
2130 : : .reg_no = 673,
2131 : : .module_no = SMMU0,
2132 : : .flags = ZXDH_REG_FLAG_DIRECT,
2133 : : .array_type = ZXDH_REG_NUL_ARRAY,
2134 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x4c,
2135 : : .width = (32 / 8),
2136 : : .m_size = 0,
2137 : : .n_size = 0,
2138 : : .m_step = 0,
2139 : : .n_step = 0,
2140 : : .field_num = 1,
2141 : : .p_fields = g_smmu0_smmu0_cpu_ind_rdat2_reg,
2142 : : .p_write_fun = zxdh_np_se_smmu0_write,
2143 : : .p_read_fun = zxdh_np_se_smmu0_read,
2144 : : },
2145 : : {
2146 : : .reg_name = "cpu_ind_rdat3",
2147 : : .reg_no = 674,
2148 : : .module_no = SMMU0,
2149 : : .flags = ZXDH_REG_FLAG_DIRECT,
2150 : : .array_type = ZXDH_REG_NUL_ARRAY,
2151 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x50,
2152 : : .width = (32 / 8),
2153 : : .m_size = 0,
2154 : : .n_size = 0,
2155 : : .m_step = 0,
2156 : : .n_step = 0,
2157 : : .field_num = 1,
2158 : : .p_fields = g_smmu0_smmu0_cpu_ind_rdat3_reg,
2159 : : .p_write_fun = zxdh_np_se_smmu0_write,
2160 : : .p_read_fun = zxdh_np_se_smmu0_read,
2161 : : },
2162 : : {
2163 : : .reg_name = "wr_arb_cpu_rdy",
2164 : : .reg_no = 676,
2165 : : .module_no = SMMU0,
2166 : : .flags = ZXDH_REG_FLAG_DIRECT,
2167 : : .array_type = ZXDH_REG_NUL_ARRAY,
2168 : : .addr = ZXDH_SYS_SE_SMMU0_BASE_ADDR + ZXDH_MODULE_SE_SMMU0_BASE_ADDR + 0x10c,
2169 : : .width = (32 / 8),
2170 : : .m_size = 0,
2171 : : .n_size = 0,
2172 : : .m_step = 0,
2173 : : .n_step = 0,
2174 : : .field_num = 1,
2175 : : .p_fields = g_smmu0_smmu0_wr_arb_cpu_rdy_reg,
2176 : : .p_write_fun = zxdh_np_se_smmu0_write,
2177 : : .p_read_fun = zxdh_np_se_smmu0_read,
2178 : : },
2179 : : {
2180 : : .reg_name = "info_queue_buf_space_left_0_127",
2181 : : .reg_no = 820,
2182 : : .module_no = DTB4K,
2183 : : .flags = ZXDH_REG_FLAG_DIRECT,
2184 : : .array_type = ZXDH_REG_UNI_ARRAY,
2185 : : .addr = ZXDH_SYS_DTB_BASE_ADDR + ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0xc,
2186 : : .width = (32 / 8),
2187 : : .m_size = 0,
2188 : : .n_size = 127 + 1,
2189 : : .m_step = 0,
2190 : : .n_step = 32,
2191 : : .field_num = 1,
2192 : : .p_fields = g_dtb4k_dtb_enq_info_queue_buf_space_left_0_127_reg,
2193 : : .p_write_fun = zxdh_np_write,
2194 : : .p_read_fun = zxdh_np_read,
2195 : : },
2196 : : {
2197 : : .reg_name = "cfg_epid_v_func_num_0_127",
2198 : : .reg_no = 821,
2199 : : .module_no = DTB4K,
2200 : : .flags = ZXDH_REG_FLAG_DIRECT,
2201 : : .array_type = ZXDH_REG_UNI_ARRAY,
2202 : : .addr = ZXDH_SYS_DTB_BASE_ADDR + ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x10,
2203 : : .width = (32 / 8),
2204 : : .m_size = 0,
2205 : : .n_size = 127 + 1,
2206 : : .m_step = 0,
2207 : : .n_step = 32,
2208 : : .field_num = 7,
2209 : : .p_fields = g_dtb4k_dtb_enq_cfg_epid_v_func_num_0_127_reg,
2210 : : .p_write_fun = zxdh_np_write,
2211 : : .p_read_fun = zxdh_np_read,
2212 : : },
2213 : : {
2214 : : .reg_name = "cara_queue_ram0_159_0",
2215 : : .reg_no = 721,
2216 : : .module_no = STAT,
2217 : : .flags = ZXDH_REG_FLAG_INDIRECT,
2218 : : .array_type = ZXDH_REG_UNI_ARRAY,
2219 : : .addr = 0x000000 + 0x14000000,
2220 : : .width = (160 / 8),
2221 : : .m_size = 0,
2222 : : .n_size = 0x7FFF + 1,
2223 : : .m_step = 0,
2224 : : .n_step = 8,
2225 : : .field_num = 9,
2226 : : .p_fields = g_stat_car0_cara_queue_ram0_159_0_reg,
2227 : : .p_write_fun = NULL,
2228 : : .p_read_fun = NULL,
2229 : : },
2230 : : {
2231 : : .reg_name = "carb_queue_ram0_159_0",
2232 : : .reg_no = 738,
2233 : : .module_no = STAT,
2234 : : .flags = ZXDH_REG_FLAG_INDIRECT,
2235 : : .array_type = ZXDH_REG_UNI_ARRAY,
2236 : : .addr = 0x100000 + 0x14000000,
2237 : : .width = (160 / 8),
2238 : : .m_size = 0,
2239 : : .n_size = 0xFFF + 1,
2240 : : .m_step = 0,
2241 : : .n_step = 8,
2242 : : .field_num = 9,
2243 : : .p_fields = g_stat_car0_carb_queue_ram0_159_0_reg,
2244 : : .p_write_fun = NULL,
2245 : : .p_read_fun = NULL,
2246 : : },
2247 : : {
2248 : : .reg_name = "carc_queue_ram0_159_0",
2249 : : .reg_no = 755,
2250 : : .module_no = STAT,
2251 : : .flags = ZXDH_REG_FLAG_INDIRECT,
2252 : : .array_type = ZXDH_REG_UNI_ARRAY,
2253 : : .addr = 0x200000 + 0x14000000,
2254 : : .width = (160 / 8),
2255 : : .m_size = 0,
2256 : : .n_size = 0x3FF + 1,
2257 : : .m_step = 0,
2258 : : .n_step = 8,
2259 : : .field_num = 9,
2260 : : .p_fields = g_stat_car0_carc_queue_ram0_159_0_reg,
2261 : : .p_write_fun = NULL,
2262 : : .p_read_fun = NULL,
2263 : : },
2264 : : {
2265 : : .reg_name = "pktrx_glbal_cfg_0",
2266 : : .reg_no = 448,
2267 : : .module_no = NPPU,
2268 : : .flags = ZXDH_REG_FLAG_DIRECT,
2269 : : .array_type = ZXDH_REG_NUL_ARRAY,
2270 : : .addr = ZXDH_SYS_NPPU_BASE_ADDR + ZXDH_MODULE_NPPU_PKTRX_CFG_BASE_ADDR + 0x01f8,
2271 : : .width = (32 / 8),
2272 : : .m_size = 0,
2273 : : .n_size = 0,
2274 : : .m_step = 0,
2275 : : .n_step = 0,
2276 : : .field_num = 1,
2277 : : .p_fields = g_nppu_pktrx_cfg_pktrx_glbal_cfg_0_reg,
2278 : : .p_write_fun = NULL,
2279 : : .p_read_fun = NULL,
2280 : : },
2281 : : };
2282 : :
2283 : : static uint32_t
2284 : 0 : zxdh_np_reg_get_reg_addr(uint32_t reg_no, uint32_t m_offset, uint32_t n_offset)
2285 : : {
2286 : : uint32_t addr = 0;
2287 : : ZXDH_REG_T *p_reg_info = NULL;
2288 : :
2289 : : p_reg_info = &g_dpp_reg_info[reg_no];
2290 : :
2291 : 0 : addr = p_reg_info->addr;
2292 : :
2293 [ # # ]: 0 : if (p_reg_info->array_type & ZXDH_REG_UNI_ARRAY) {
2294 [ # # ]: 0 : if (n_offset > (p_reg_info->n_size - 1))
2295 : 0 : PMD_DRV_LOG(ERR, "reg n_offset is out of range, reg_no:%u", reg_no);
2296 : :
2297 : 0 : addr += n_offset * p_reg_info->n_step;
2298 [ # # ]: 0 : } else if (p_reg_info->array_type & ZXDH_REG_BIN_ARRAY) {
2299 [ # # # # ]: 0 : if ((n_offset > (p_reg_info->n_size - 1)) || (m_offset > (p_reg_info->m_size - 1)))
2300 : 0 : PMD_DRV_LOG(ERR, "reg n_offset/m_offset out of range, reg_no:%u", reg_no);
2301 : :
2302 : 0 : addr += m_offset * p_reg_info->m_step + n_offset * p_reg_info->n_step;
2303 : : }
2304 : :
2305 : 0 : return addr;
2306 : : }
2307 : :
2308 : : static uint32_t
2309 : 0 : zxdh_np_dev_add(uint32_t dev_id, ZXDH_DEV_TYPE_E dev_type,
2310 : : ZXDH_DEV_ACCESS_TYPE_E access_type, uint64_t pcie_addr,
2311 : : uint64_t riscv_addr, uint64_t dma_vir_addr,
2312 : : uint64_t dma_phy_addr)
2313 : : {
2314 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
2315 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
2316 : : uint32_t i = 0;
2317 : :
2318 : : p_dev_mgr = &g_dev_mgr;
2319 [ # # ]: 0 : if (!p_dev_mgr->is_init) {
2320 : 0 : PMD_DRV_LOG(ERR, "ErrorCode[ 0x%x]: Device Manager is not init",
2321 : : ZXDH_RC_DEV_MGR_NOT_INIT);
2322 : 0 : return ZXDH_RC_DEV_MGR_NOT_INIT;
2323 : : }
2324 : :
2325 [ # # ]: 0 : if (p_dev_mgr->p_dev_array[dev_id] != NULL) {
2326 : : /* device is already exist. */
2327 : 0 : PMD_DRV_LOG(ERR, "Device is added again");
2328 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
2329 : : } else {
2330 : : /* device is new. */
2331 : 0 : p_dev_info = rte_malloc(NULL, sizeof(ZXDH_DEV_CFG_T), 0);
2332 [ # # ]: 0 : if (p_dev_info == NULL) {
2333 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
2334 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2335 : : }
2336 : 0 : p_dev_mgr->p_dev_array[dev_id] = p_dev_info;
2337 : 0 : p_dev_mgr->device_num++;
2338 : : }
2339 : :
2340 : 0 : p_dev_info->device_id = dev_id;
2341 : 0 : p_dev_info->dev_type = dev_type;
2342 : 0 : p_dev_info->access_type = access_type;
2343 : 0 : p_dev_info->pcie_addr = pcie_addr;
2344 : 0 : p_dev_info->riscv_addr = riscv_addr;
2345 : 0 : p_dev_info->dma_vir_addr = dma_vir_addr;
2346 : 0 : p_dev_info->dma_phy_addr = dma_phy_addr;
2347 : :
2348 : 0 : p_dev_info->p_pcie_write_fun = zxdh_np_dev_pcie_default_write;
2349 : 0 : p_dev_info->p_pcie_read_fun = zxdh_np_dev_pcie_default_read;
2350 : :
2351 : : rte_spinlock_init(&p_dev_info->dtb_spinlock.spinlock);
2352 : :
2353 : : rte_spinlock_init(&p_dev_info->smmu0_spinlock.spinlock);
2354 : :
2355 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_NUM_MAX; i++)
2356 : : rte_spinlock_init(&p_dev_info->dtb_queue_spinlock[i].spinlock);
2357 : :
2358 [ # # ]: 0 : for (i = 0; i < ZXDH_HASH_FUNC_ID_NUM; i++)
2359 : : rte_spinlock_init(&p_dev_info->hash_spinlock[i].spinlock);
2360 : :
2361 : : return ZXDH_OK;
2362 : : }
2363 : :
2364 : : static uint32_t
2365 : : zxdh_np_dev_agent_status_set(uint32_t dev_id, uint32_t agent_flag)
2366 : : {
2367 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
2368 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
2369 : :
2370 : : p_dev_mgr = &g_dev_mgr;
2371 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
2372 : :
2373 [ # # ]: 0 : if (p_dev_info == NULL)
2374 : : return ZXDH_DEV_TYPE_INVALID;
2375 : 0 : p_dev_info->agent_flag = agent_flag;
2376 : :
2377 : : return 0;
2378 : : }
2379 : :
2380 : : static void
2381 : 0 : zxdh_np_sdt_mgr_init(void)
2382 : : {
2383 [ # # ]: 0 : if (!g_sdt_mgr.is_init) {
2384 : 0 : g_sdt_mgr.channel_num = 0;
2385 : 0 : g_sdt_mgr.is_init = 1;
2386 : : memset(g_sdt_mgr.sdt_tbl_array, 0, ZXDH_DEV_CHANNEL_MAX *
2387 : : sizeof(ZXDH_SDT_SOFT_TABLE_T *));
2388 : : }
2389 : 0 : }
2390 : :
2391 : : static uint32_t
2392 : 0 : zxdh_np_sdt_mgr_create(uint32_t dev_id)
2393 : : {
2394 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_tbl_temp = NULL;
2395 : : ZXDH_SDT_MGR_T *p_sdt_mgr = NULL;
2396 : :
2397 : : p_sdt_mgr = ZXDH_SDT_MGR_PTR_GET();
2398 : :
2399 [ # # ]: 0 : if (ZXDH_SDT_SOFT_TBL_GET(dev_id) == NULL) {
2400 : 0 : p_sdt_tbl_temp = rte_malloc(NULL, sizeof(ZXDH_SDT_SOFT_TABLE_T), 0);
2401 : :
2402 : 0 : p_sdt_tbl_temp->device_id = dev_id;
2403 : 0 : memset(p_sdt_tbl_temp->sdt_array, 0, ZXDH_DEV_SDT_ID_MAX * sizeof(ZXDH_SDT_ITEM_T));
2404 : :
2405 : 0 : ZXDH_SDT_SOFT_TBL_GET(dev_id) = p_sdt_tbl_temp;
2406 : :
2407 : 0 : p_sdt_mgr->channel_num++;
2408 : : } else {
2409 : 0 : PMD_DRV_LOG(ERR, "called repeatedly!");
2410 : 0 : return 1;
2411 : : }
2412 : :
2413 : 0 : return 0;
2414 : : }
2415 : :
2416 : : static uint32_t
2417 : 0 : zxdh_np_sdt_init(uint32_t dev_num, uint32_t *dev_id_array)
2418 : : {
2419 : : uint32_t rc;
2420 : : uint32_t i;
2421 : :
2422 : 0 : zxdh_np_sdt_mgr_init();
2423 : :
2424 [ # # ]: 0 : for (i = 0; i < dev_num; i++) {
2425 : 0 : rc = zxdh_np_sdt_mgr_create(dev_id_array[i]);
2426 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_sdt_mgr_create");
2427 : : }
2428 : :
2429 : 0 : return rc;
2430 : : }
2431 : :
2432 : : static uint32_t
2433 : 0 : zxdh_np_sdt_mgr_sdt_item_add(uint32_t dev_id, uint32_t sdt_no,
2434 : : uint32_t sdt_hig32, uint32_t sdt_low32)
2435 : : {
2436 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_soft_tbl = NULL;
2437 : : ZXDH_SDT_ITEM_T *p_sdt_item = NULL;
2438 : :
2439 : 0 : p_sdt_soft_tbl = ZXDH_SDT_SOFT_TBL_GET(dev_id);
2440 : :
2441 [ # # ]: 0 : if (p_sdt_soft_tbl == NULL) {
2442 : 0 : PMD_DRV_LOG(ERR, "soft sdt table not init!");
2443 : : RTE_ASSERT(0);
2444 : 0 : return ZXDH_RC_TABLE_SDT_MGR_INVALID;
2445 : : }
2446 : :
2447 [ # # ]: 0 : if (dev_id != p_sdt_soft_tbl->device_id) {
2448 : 0 : PMD_DRV_LOG(ERR, "soft sdt table item invalid!");
2449 : : RTE_ASSERT(0);
2450 : 0 : return ZXDH_RC_TABLE_PARA_INVALID;
2451 : : }
2452 : :
2453 : : p_sdt_item = &p_sdt_soft_tbl->sdt_array[sdt_no];
2454 : 0 : p_sdt_item->valid = ZXDH_SDT_VALID;
2455 : 0 : p_sdt_item->table_cfg[0] = sdt_hig32;
2456 : 0 : p_sdt_item->table_cfg[1] = sdt_low32;
2457 : :
2458 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x 0x%08x", p_sdt_item->table_cfg[0], p_sdt_item->table_cfg[1]);
2459 : :
2460 : 0 : return ZXDH_OK;
2461 : : }
2462 : :
2463 : : static uint32_t
2464 : 0 : zxdh_np_sdt_mgr_sdt_item_del(uint32_t dev_id, uint32_t sdt_no)
2465 : : {
2466 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_soft_tbl = NULL;
2467 : : ZXDH_SDT_ITEM_T *p_sdt_item = NULL;
2468 : :
2469 : 0 : p_sdt_soft_tbl = ZXDH_SDT_SOFT_TBL_GET(dev_id);
2470 : :
2471 [ # # ]: 0 : if (p_sdt_soft_tbl != NULL) {
2472 [ # # ]: 0 : if (dev_id != p_sdt_soft_tbl->device_id) {
2473 : 0 : PMD_DRV_LOG(ERR, "soft table item invalid !");
2474 : : RTE_ASSERT(0);
2475 : 0 : return ZXDH_RC_TABLE_PARA_INVALID;
2476 : : }
2477 : :
2478 : : p_sdt_item = &p_sdt_soft_tbl->sdt_array[sdt_no];
2479 : 0 : p_sdt_item->valid = ZXDH_SDT_INVALID;
2480 : 0 : p_sdt_item->table_cfg[0] = 0;
2481 : 0 : p_sdt_item->table_cfg[1] = 0;
2482 : : }
2483 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no: 0x%08x", sdt_no);
2484 : 0 : return ZXDH_OK;
2485 : : }
2486 : :
2487 : : static void
2488 : : zxdh_np_soft_sdt_tbl_set(uint32_t dev_id,
2489 : : uint32_t sdt_no,
2490 : : uint32_t table_type,
2491 : : ZXDH_SDT_TBL_DATA_T *p_sdt_info)
2492 : : {
2493 : 0 : g_table_type[dev_id][sdt_no] = table_type;
2494 : 0 : g_sdt_info[dev_id][sdt_no].data_high32 = p_sdt_info->data_high32;
2495 : 0 : g_sdt_info[dev_id][sdt_no].data_low32 = p_sdt_info->data_low32;
2496 : : }
2497 : :
2498 : : static uint32_t
2499 : 0 : zxdh_np_sdt_tbl_write(uint32_t dev_id,
2500 : : uint32_t sdt_no,
2501 : : uint32_t table_type,
2502 : : void *p_sdt_info,
2503 : : uint32_t opr_type)
2504 : : {
2505 : : uint32_t rtn = 0;
2506 : :
2507 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
2508 : : ZXDH_SDT_TBL_ERAM_T *p_sdt_eram = NULL;
2509 : : ZXDH_SDT_TBL_HASH_T *p_sdt_hash = NULL;
2510 : : ZXDH_SDT_TBL_ETCAM_T *p_sdt_etcam = NULL;
2511 : : ZXDH_SDT_TBL_PORTTBL_T *p_sdt_porttbl = NULL;
2512 : :
2513 : 0 : PMD_DRV_LOG(DEBUG, "sdt: %u", sdt_no);
2514 : :
2515 [ # # ]: 0 : if (opr_type) {
2516 : : zxdh_np_soft_sdt_tbl_set(dev_id, sdt_no, 0, &sdt_tbl);
2517 : :
2518 : 0 : rtn = zxdh_np_sdt_mgr_sdt_item_del(dev_id, sdt_no);
2519 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rtn, "zxdh_np_sdt_mgr_sdt_item_del");
2520 : : } else {
2521 [ # # # # : 0 : switch (table_type) {
# ]
2522 : 0 : case ZXDH_SDT_TBLT_ERAM:
2523 : : p_sdt_eram = (ZXDH_SDT_TBL_ERAM_T *)p_sdt_info;
2524 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2525 : : p_sdt_eram->eram_mode,
2526 : : ZXDH_SDT_H_ERAM_MODE_BT_POS,
2527 : : ZXDH_SDT_H_ERAM_MODE_BT_LEN);
2528 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2529 : : p_sdt_eram->eram_base_addr,
2530 : : ZXDH_SDT_H_ERAM_BASE_ADDR_BT_POS,
2531 : : ZXDH_SDT_H_ERAM_BASE_ADDR_BT_LEN);
2532 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2533 : : p_sdt_eram->eram_table_depth,
2534 : : ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_POS,
2535 : : ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_LEN);
2536 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2537 : : p_sdt_eram->eram_clutch_en,
2538 : : ZXDH_SDT_L_CLUTCH_EN_BT_POS,
2539 : : ZXDH_SDT_L_CLUTCH_EN_BT_LEN);
2540 : : break;
2541 : :
2542 : 0 : case ZXDH_SDT_TBLT_HASH:
2543 : : p_sdt_hash = (ZXDH_SDT_TBL_HASH_T *)p_sdt_info;
2544 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2545 : : p_sdt_hash->hash_id,
2546 : : ZXDH_SDT_H_HASH_ID_BT_POS,
2547 : : ZXDH_SDT_H_HASH_ID_BT_LEN);
2548 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2549 : : p_sdt_hash->hash_table_width,
2550 : : ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_POS,
2551 : : ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_LEN);
2552 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2553 : : p_sdt_hash->key_size,
2554 : : ZXDH_SDT_H_HASH_KEY_SIZE_BT_POS,
2555 : : ZXDH_SDT_H_HASH_KEY_SIZE_BT_LEN);
2556 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2557 : : p_sdt_hash->hash_table_id,
2558 : : ZXDH_SDT_H_HASH_TABLE_ID_BT_POS,
2559 : : ZXDH_SDT_H_HASH_TABLE_ID_BT_LEN);
2560 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2561 : : p_sdt_hash->learn_en,
2562 : : ZXDH_SDT_H_LEARN_EN_BT_POS,
2563 : : ZXDH_SDT_H_LEARN_EN_BT_LEN);
2564 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2565 : : p_sdt_hash->keep_alive,
2566 : : ZXDH_SDT_H_KEEP_ALIVE_BT_POS,
2567 : : ZXDH_SDT_H_KEEP_ALIVE_BT_LEN);
2568 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2569 : : ((p_sdt_hash->keep_alive_baddr) >>
2570 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN),
2571 : : ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_POS,
2572 : : ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_LEN);
2573 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2574 : : ZXDH_SDT_GET_LOW_DATA((p_sdt_hash->keep_alive_baddr),
2575 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN),
2576 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_POS,
2577 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN);
2578 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2579 : : p_sdt_hash->rsp_mode,
2580 : : ZXDH_SDT_L_RSP_MODE_BT_POS,
2581 : : ZXDH_SDT_L_RSP_MODE_BT_LEN);
2582 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2583 : : p_sdt_hash->hash_clutch_en,
2584 : : ZXDH_SDT_L_CLUTCH_EN_BT_POS,
2585 : : ZXDH_SDT_L_CLUTCH_EN_BT_LEN);
2586 : : break;
2587 : :
2588 : 0 : case ZXDH_SDT_TBLT_ETCAM:
2589 : : p_sdt_etcam = (ZXDH_SDT_TBL_ETCAM_T *)p_sdt_info;
2590 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2591 : : p_sdt_etcam->etcam_id,
2592 : : ZXDH_SDT_H_ETCAM_ID_BT_POS,
2593 : : ZXDH_SDT_H_ETCAM_ID_BT_LEN);
2594 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2595 : : p_sdt_etcam->etcam_key_mode,
2596 : : ZXDH_SDT_H_ETCAM_KEY_MODE_BT_POS,
2597 : : ZXDH_SDT_H_ETCAM_KEY_MODE_BT_LEN);
2598 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2599 : : p_sdt_etcam->etcam_table_id,
2600 : : ZXDH_SDT_H_ETCAM_TABLE_ID_BT_POS,
2601 : : ZXDH_SDT_H_ETCAM_TABLE_ID_BT_LEN);
2602 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2603 : : p_sdt_etcam->no_as_rsp_mode,
2604 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_POS,
2605 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_LEN);
2606 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2607 : : p_sdt_etcam->as_en,
2608 : : ZXDH_SDT_H_ETCAM_AS_EN_BT_POS,
2609 : : ZXDH_SDT_H_ETCAM_AS_EN_BT_LEN);
2610 : :
2611 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32,
2612 : : ((p_sdt_etcam->as_eram_baddr) >>
2613 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN),
2614 : : ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_POS,
2615 : : ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_LEN);
2616 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2617 : : ZXDH_SDT_GET_LOW_DATA((p_sdt_etcam->as_eram_baddr),
2618 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN),
2619 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_POS,
2620 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN);
2621 : :
2622 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32, p_sdt_etcam->as_rsp_mode,
2623 : : ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_POS,
2624 : : ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_LEN);
2625 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2626 : : p_sdt_etcam->etcam_table_depth, ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_POS,
2627 : : ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_LEN);
2628 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2629 : : p_sdt_etcam->etcam_clutch_en, ZXDH_SDT_L_CLUTCH_EN_BT_POS,
2630 : : ZXDH_SDT_L_CLUTCH_EN_BT_LEN);
2631 : : break;
2632 : :
2633 : 0 : case ZXDH_SDT_TBLT_PORTTBL:
2634 : : p_sdt_porttbl = (ZXDH_SDT_TBL_PORTTBL_T *)p_sdt_info;
2635 : 0 : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_low32,
2636 : : p_sdt_porttbl->porttbl_clutch_en, ZXDH_SDT_L_CLUTCH_EN_BT_POS,
2637 : : ZXDH_SDT_L_CLUTCH_EN_BT_LEN);
2638 : : break;
2639 : :
2640 : 0 : default:
2641 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!",
2642 : : table_type);
2643 : 0 : return ZXDH_ERR;
2644 : : }
2645 : :
2646 : : ZXDH_COMM_UINT32_WRITE_BITS(sdt_tbl.data_high32, table_type,
2647 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
2648 : : zxdh_np_soft_sdt_tbl_set(dev_id, sdt_no, table_type, &sdt_tbl);
2649 : :
2650 : 0 : rtn = zxdh_np_sdt_mgr_sdt_item_add(dev_id, sdt_no, sdt_tbl.data_high32,
2651 : : sdt_tbl.data_low32);
2652 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rtn, "zxdh_np_sdt_mgr_sdt_item_add");
2653 : : }
2654 : :
2655 : : return ZXDH_OK;
2656 : : }
2657 : :
2658 : : static void
2659 : 0 : zxdh_np_ppu_parse_cls_bitmap(uint32_t dev_id,
2660 : : uint32_t bitmap)
2661 : : {
2662 : : uint32_t cls_id;
2663 : : uint32_t mem_id;
2664 : : uint32_t cls_use;
2665 : : uint32_t instr_mem;
2666 : :
2667 [ # # ]: 0 : for (cls_id = 0; cls_id < ZXDH_PPU_CLUSTER_NUM; cls_id++) {
2668 : 0 : cls_use = (bitmap >> cls_id) & 0x1;
2669 : 0 : g_ppu_cls_bit_map[dev_id].cls_use[cls_id] = cls_use;
2670 : : }
2671 : :
2672 [ # # ]: 0 : for (mem_id = 0; mem_id < ZXDH_PPU_INSTR_MEM_NUM; mem_id++) {
2673 : 0 : instr_mem = (bitmap >> (mem_id * 2)) & 0x3;
2674 : 0 : g_ppu_cls_bit_map[dev_id].instr_mem[mem_id] = ((instr_mem > 0) ? 1 : 0);
2675 : : }
2676 : 0 : }
2677 : :
2678 : : static void
2679 : 0 : zxdh_np_agent_msg_prt(uint8_t type, uint32_t rtn)
2680 : : {
2681 [ # # # # : 0 : switch (rtn) {
# # ]
2682 : 0 : case ZXDH_RC_CTRLCH_MSG_LEN_ZERO:
2683 : 0 : PMD_DRV_LOG(ERR, "type[%u]:msg len is zero!", type);
2684 : 0 : break;
2685 : 0 : case ZXDH_RC_CTRLCH_MSG_PRO_ERR:
2686 : 0 : PMD_DRV_LOG(ERR, "type[%u]:msg process error!", type);
2687 : 0 : break;
2688 : 0 : case ZXDH_RC_CTRLCH_MSG_TYPE_NOT_SUPPORT:
2689 : 0 : PMD_DRV_LOG(ERR, "type[%u]:fw not support the msg!", type);
2690 : 0 : break;
2691 : 0 : case ZXDH_RC_CTRLCH_MSG_OPER_NOT_SUPPORT:
2692 : 0 : PMD_DRV_LOG(ERR, "type[%u]:fw not support opr of the msg!", type);
2693 : 0 : break;
2694 : 0 : case ZXDH_RC_CTRLCH_MSG_DROP:
2695 : 0 : PMD_DRV_LOG(ERR, "type[%u]:fw not support,drop msg!", type);
2696 : 0 : break;
2697 : : default:
2698 : : break;
2699 : : }
2700 : 0 : }
2701 : :
2702 : : static uint32_t
2703 : 0 : zxdh_np_agent_bar_msg_check(uint32_t dev_id, ZXDH_AGENT_CHANNEL_MSG_T *p_msg)
2704 : : {
2705 : : uint8_t type = 0;
2706 : : uint32_t bar_msg_num = 0;
2707 : :
2708 : 0 : type = *((uint8_t *)(p_msg->msg) + 1);
2709 [ # # ]: 0 : if (type != ZXDH_PCIE_BAR_MSG) {
2710 : : zxdh_np_dev_fw_bar_msg_num_get(dev_id, &bar_msg_num);
2711 [ # # ]: 0 : if (type >= bar_msg_num) {
2712 : 0 : PMD_DRV_LOG(ERR, "type[%u] > fw_bar_msg_num[%u]!", type, bar_msg_num);
2713 : 0 : return ZXDH_RC_CTRLCH_MSG_TYPE_NOT_SUPPORT;
2714 : : }
2715 : : }
2716 : :
2717 : : return ZXDH_OK;
2718 : : }
2719 : :
2720 : : static uint32_t
2721 : 0 : zxdh_np_agent_channel_sync_send(uint32_t dev_id,
2722 : : ZXDH_AGENT_CHANNEL_MSG_T *p_msg,
2723 : : uint32_t *p_data,
2724 : : uint32_t rep_len)
2725 : : {
2726 : : uint32_t ret = ZXDH_OK;
2727 : : uint32_t vport = 0;
2728 : 0 : struct zxdh_pci_bar_msg in = {0};
2729 : 0 : struct zxdh_msg_recviver_mem result = {0};
2730 : : uint32_t *recv_buffer = NULL;
2731 : : uint8_t *reply_ptr = NULL;
2732 : : uint16_t reply_msg_len = 0;
2733 : : uint64_t agent_addr = 0;
2734 : :
2735 : 0 : ret = zxdh_np_agent_bar_msg_check(dev_id, p_msg);
2736 [ # # ]: 0 : if (ret != ZXDH_OK) {
2737 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_bar_msg_check failed!");
2738 : 0 : return ret;
2739 : : }
2740 : :
2741 : : zxdh_np_dev_vport_get(dev_id, &vport);
2742 : : zxdh_np_dev_agent_addr_get(dev_id, &agent_addr);
2743 : :
2744 [ # # ]: 0 : if (ZXDH_IS_PF(vport))
2745 : 0 : in.src = ZXDH_MSG_CHAN_END_PF;
2746 : : else
2747 : 0 : in.src = ZXDH_MSG_CHAN_END_VF;
2748 : :
2749 : 0 : in.virt_addr = agent_addr;
2750 : 0 : in.payload_addr = p_msg->msg;
2751 : 0 : in.payload_len = p_msg->msg_len;
2752 : 0 : in.dst = ZXDH_MSG_CHAN_END_RISC;
2753 : 0 : in.module_id = ZXDH_BAR_MDOULE_NPSDK;
2754 : :
2755 : 0 : recv_buffer = rte_zmalloc(NULL, rep_len + ZXDH_CHANNEL_REPS_LEN, 0);
2756 [ # # ]: 0 : if (recv_buffer == NULL) {
2757 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
2758 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2759 : : }
2760 : :
2761 : 0 : result.buffer_len = rep_len + ZXDH_CHANNEL_REPS_LEN;
2762 : 0 : result.recv_buffer = recv_buffer;
2763 : :
2764 : 0 : ret = zxdh_bar_chan_sync_msg_send(&in, &result);
2765 [ # # ]: 0 : if (ret == ZXDH_BAR_MSG_OK) {
2766 : 0 : reply_ptr = (uint8_t *)(result.recv_buffer);
2767 [ # # ]: 0 : if (*reply_ptr == 0XFF) {
2768 : 0 : reply_msg_len = *(uint16_t *)(reply_ptr + 1);
2769 : 0 : memcpy(p_data, reply_ptr + 4,
2770 : 0 : ((reply_msg_len > rep_len) ? rep_len : reply_msg_len));
2771 : : } else {
2772 : 0 : PMD_DRV_LOG(ERR, "Message not replied");
2773 : : }
2774 : : } else {
2775 : 0 : PMD_DRV_LOG(ERR, "Error[0x%x], bar msg send failed!", ret);
2776 : : }
2777 : :
2778 : 0 : rte_free(recv_buffer);
2779 : 0 : return ret;
2780 : : }
2781 : :
2782 : : static uint32_t
2783 : 0 : zxdh_np_agent_channel_reg_sync_send(uint32_t dev_id,
2784 : : ZXDH_AGENT_CHANNEL_REG_MSG_T *p_msg, uint32_t *p_data, uint32_t rep_len)
2785 : : {
2786 : : uint32_t ret = ZXDH_OK;
2787 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_msg);
2788 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
2789 : : .msg = (void *)p_msg,
2790 : : .msg_len = sizeof(ZXDH_AGENT_CHANNEL_REG_MSG_T),
2791 : : };
2792 : :
2793 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_data, rep_len);
2794 [ # # ]: 0 : if (ret != ZXDH_OK) {
2795 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed");
2796 : 0 : return ZXDH_ERR;
2797 : : }
2798 : :
2799 : 0 : ret = *p_data;
2800 [ # # ]: 0 : if (ret != ZXDH_OK) {
2801 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed in buffer");
2802 : 0 : return ZXDH_ERR;
2803 : : }
2804 : :
2805 : : return ret;
2806 : : }
2807 : :
2808 : : static uint32_t
2809 : 0 : zxdh_np_agent_channel_pcie_bar_request(uint32_t dev_id,
2810 : : uint32_t *p_bar_msg_num)
2811 : : {
2812 : : uint32_t rc = ZXDH_OK;
2813 : 0 : uint32_t rsp_buff[2] = {0};
2814 : : uint32_t msg_result = 0;
2815 : : uint32_t bar_msg_num = 0;
2816 : 0 : ZXDH_AGENT_PCIE_BAR_MSG_T msgcfg = {
2817 : : .dev_id = 0,
2818 : : .type = ZXDH_PCIE_BAR_MSG,
2819 : : .oper = ZXDH_BAR_MSG_NUM_REQ,
2820 : : };
2821 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
2822 : : .msg = (void *)&msgcfg,
2823 : : .msg_len = sizeof(ZXDH_AGENT_PCIE_BAR_MSG_T),
2824 : : };
2825 : :
2826 : 0 : rc = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, rsp_buff, sizeof(rsp_buff));
2827 [ # # ]: 0 : if (rc != ZXDH_OK) {
2828 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed!");
2829 : 0 : return rc;
2830 : : }
2831 : :
2832 : 0 : msg_result = rsp_buff[0];
2833 : 0 : bar_msg_num = rsp_buff[1];
2834 : :
2835 : 0 : zxdh_np_agent_msg_prt(msgcfg.type, msg_result);
2836 : :
2837 : 0 : *p_bar_msg_num = bar_msg_num;
2838 : :
2839 : 0 : return msg_result;
2840 : : }
2841 : :
2842 : : static uint32_t
2843 : 0 : zxdh_np_agent_channel_reg_read(uint32_t dev_id,
2844 : : uint32_t reg_type,
2845 : : uint32_t reg_no,
2846 : : uint32_t reg_width,
2847 : : uint32_t addr,
2848 : : uint32_t *p_data)
2849 : : {
2850 : : uint32_t ret = 0;
2851 : 0 : ZXDH_AGENT_CHANNEL_REG_MSG_T msgcfg = {
2852 : : .dev_id = 0,
2853 : : .type = ZXDH_REG_MSG,
2854 : : .subtype = reg_type,
2855 : : .oper = ZXDH_RD,
2856 : : .reg_no = reg_no,
2857 : : .addr = addr,
2858 : 0 : .val_len = reg_width / 4,
2859 : : };
2860 : :
2861 : 0 : uint32_t resp_len = reg_width + 4;
2862 : 0 : uint8_t *resp_buffer = rte_zmalloc(NULL, resp_len, 0);
2863 [ # # ]: 0 : if (resp_buffer == NULL) {
2864 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
2865 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2866 : : }
2867 : :
2868 : 0 : ret = zxdh_np_agent_channel_reg_sync_send(dev_id,
2869 : : &msgcfg, (uint32_t *)resp_buffer, resp_len);
2870 [ # # ]: 0 : if (ret != ZXDH_OK) {
2871 : 0 : PMD_DRV_LOG(ERR, "dev id %u reg_no %u send agent read failed.", dev_id, reg_no);
2872 : 0 : rte_free(resp_buffer);
2873 : 0 : return ZXDH_ERR;
2874 : : }
2875 : :
2876 [ # # ]: 0 : if (*((uint32_t *)resp_buffer) != ZXDH_OK) {
2877 : 0 : PMD_DRV_LOG(ERR, "dev id %u reg_no %u agent read resp err %u .",
2878 : : dev_id, reg_no, *((uint32_t *)resp_buffer));
2879 : 0 : rte_free(resp_buffer);
2880 : 0 : return ZXDH_ERR;
2881 : : }
2882 : :
2883 : 0 : memcpy(p_data, resp_buffer + 4, reg_width);
2884 : :
2885 : 0 : rte_free(resp_buffer);
2886 : :
2887 : 0 : return ret;
2888 : : }
2889 : :
2890 : : static uint32_t
2891 : 0 : zxdh_np_agent_channel_reg_write(uint32_t dev_id,
2892 : : uint32_t reg_type,
2893 : : uint32_t reg_no,
2894 : : uint32_t reg_width,
2895 : : uint32_t addr,
2896 : : uint32_t *p_data)
2897 : : {
2898 : : uint32_t ret = ZXDH_OK;
2899 : 0 : ZXDH_AGENT_CHANNEL_REG_MSG_T msgcfg = {
2900 : : .dev_id = 0,
2901 : : .type = ZXDH_REG_MSG,
2902 : : .subtype = reg_type,
2903 : : .oper = ZXDH_WR,
2904 : : .reg_no = reg_no,
2905 : : .addr = addr,
2906 : 0 : .val_len = reg_width / 4,
2907 : : };
2908 : :
2909 : 0 : memcpy(msgcfg.val, p_data, reg_width);
2910 : :
2911 : 0 : uint32_t resp_len = reg_width + 4;
2912 : 0 : uint8_t *resp_buffer = rte_zmalloc(NULL, resp_len, 0);
2913 [ # # ]: 0 : if (resp_buffer == NULL) {
2914 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
2915 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2916 : : }
2917 : :
2918 : 0 : ret = zxdh_np_agent_channel_reg_sync_send(dev_id,
2919 : : &msgcfg, (uint32_t *)resp_buffer, resp_len);
2920 : :
2921 [ # # ]: 0 : if (ret != ZXDH_OK) {
2922 : 0 : PMD_DRV_LOG(ERR, "dev id %u reg_no %u send agent write failed.", dev_id, reg_no);
2923 : 0 : rte_free(resp_buffer);
2924 : 0 : return ZXDH_ERR;
2925 : : }
2926 : :
2927 [ # # ]: 0 : if (*((uint32_t *)resp_buffer) != ZXDH_OK) {
2928 : 0 : PMD_DRV_LOG(ERR, "dev id %u reg_no %u agent write resp err %u .",
2929 : : dev_id, reg_no, *((uint32_t *)resp_buffer));
2930 : 0 : rte_free(resp_buffer);
2931 : 0 : return ZXDH_ERR;
2932 : : }
2933 : :
2934 : 0 : memcpy(p_data, resp_buffer + 4, reg_width);
2935 : :
2936 : 0 : rte_free(resp_buffer);
2937 : :
2938 : 0 : return ret;
2939 : : }
2940 : :
2941 : : static uint32_t
2942 : 0 : zxdh_np_agent_channel_dtb_sync_send(uint32_t dev_id,
2943 : : ZXDH_AGENT_CHANNEL_DTB_MSG_T *p_msg,
2944 : : uint32_t *p_data,
2945 : : uint32_t rep_len)
2946 : : {
2947 : : uint32_t ret = ZXDH_OK;
2948 : :
2949 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {0};
2950 : 0 : agent_msg.msg = (void *)p_msg;
2951 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CHANNEL_DTB_MSG_T);
2952 : :
2953 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_data, rep_len);
2954 [ # # ]: 0 : if (ret != ZXDH_OK) {
2955 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed");
2956 : 0 : return ZXDH_ERR;
2957 : : }
2958 : :
2959 : : return ZXDH_OK;
2960 : : }
2961 : :
2962 : : static uint32_t
2963 : 0 : zxdh_np_agent_channel_dtb_queue_request(uint32_t dev_id,
2964 : : char p_name[32],
2965 : : uint32_t vport_info,
2966 : : uint32_t *p_queue_id)
2967 : : {
2968 : : uint32_t rc = ZXDH_OK;
2969 : :
2970 : 0 : uint32_t rsp_buff[2] = {0};
2971 : : uint32_t msg_result = 0;
2972 : : uint32_t queue_id = 0;
2973 : 0 : ZXDH_AGENT_CHANNEL_DTB_MSG_T msgcfg = {
2974 : : .dev_id = 0,
2975 : : .type = ZXDH_DTB_MSG,
2976 : : .oper = ZXDH_QUEUE_REQUEST,
2977 : : .vport = vport_info,
2978 : : };
2979 : 0 : memcpy(msgcfg.name, p_name, strnlen(p_name, ZXDH_PORT_NAME_MAX));
2980 : :
2981 : 0 : PMD_DRV_LOG(DEBUG, "msgcfg.name=%s", msgcfg.name);
2982 : :
2983 : 0 : rc = zxdh_np_agent_channel_dtb_sync_send(dev_id, &msgcfg, rsp_buff, sizeof(rsp_buff));
2984 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_dtb_sync_send");
2985 : :
2986 : 0 : msg_result = rsp_buff[0];
2987 : 0 : queue_id = rsp_buff[1];
2988 : :
2989 : 0 : PMD_DRV_LOG(DEBUG, "dev_id: %u, msg_result: %u", dev_id, msg_result);
2990 : 0 : PMD_DRV_LOG(DEBUG, "dev_id: %u, queue_id: %u", dev_id, queue_id);
2991 : :
2992 : 0 : *p_queue_id = queue_id;
2993 : :
2994 : 0 : return msg_result;
2995 : : }
2996 : :
2997 : : static uint32_t
2998 : 0 : zxdh_np_agent_channel_dtb_queue_release(uint32_t dev_id,
2999 : : char p_name[32],
3000 : : __rte_unused uint32_t queue_id)
3001 : : {
3002 : : uint32_t rc = ZXDH_OK;
3003 : :
3004 : : uint32_t msg_result = 0;
3005 : 0 : uint32_t rsp_buff[2] = {0};
3006 : 0 : ZXDH_AGENT_CHANNEL_DTB_MSG_T msgcfg = {
3007 : : .dev_id = 0,
3008 : : .type = ZXDH_DTB_MSG,
3009 : : .oper = ZXDH_QUEUE_RELEASE,
3010 : : .queue_id = queue_id,
3011 : : };
3012 : :
3013 : 0 : memcpy(msgcfg.name, p_name, strnlen(p_name, ZXDH_PORT_NAME_MAX));
3014 : :
3015 : 0 : rc = zxdh_np_agent_channel_dtb_sync_send(dev_id, &msgcfg, rsp_buff, sizeof(rsp_buff));
3016 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_dtb_sync_send");
3017 : :
3018 : 0 : msg_result = rsp_buff[0];
3019 : 0 : PMD_DRV_LOG(DEBUG, "msg_result: %u", msg_result);
3020 : :
3021 : 0 : return msg_result;
3022 : : }
3023 : :
3024 : : static uint32_t
3025 : 0 : zxdh_np_agent_channel_se_res_get(uint32_t dev_id,
3026 : : uint32_t sub_type,
3027 : : uint32_t opr,
3028 : : uint32_t *p_rsp_buff,
3029 : : uint32_t buff_size)
3030 : : {
3031 : : uint32_t rc = ZXDH_OK;
3032 : :
3033 : : uint32_t msg_result = 0;
3034 : 0 : ZXDH_AGENT_SE_RES_MSG_T msgcfg = {
3035 : : .dev_id = 0,
3036 : : .type = ZXDH_RES_MSG,
3037 : : .sub_type = sub_type,
3038 : : .oper = opr,
3039 : : };
3040 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
3041 : : .msg = (void *)&msgcfg,
3042 : : .msg_len = sizeof(ZXDH_AGENT_SE_RES_MSG_T),
3043 : : };
3044 : :
3045 : 0 : rc = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_rsp_buff, buff_size);
3046 [ # # ]: 0 : if (rc != ZXDH_OK) {
3047 : 0 : PMD_DRV_LOG(ERR, "agent send msg failed");
3048 : 0 : return ZXDH_ERR;
3049 : : }
3050 : :
3051 : 0 : msg_result = p_rsp_buff[0];
3052 : 0 : PMD_DRV_LOG(DEBUG, "msg_result: 0x%x", msg_result);
3053 : 0 : zxdh_np_agent_msg_prt(msgcfg.type, msg_result);
3054 : :
3055 : 0 : return msg_result;
3056 : : }
3057 : :
3058 : : static ZXDH_DTB_MGR_T *
3059 : : zxdh_np_dtb_mgr_get(uint32_t dev_id)
3060 : : {
3061 : 0 : if (dev_id >= ZXDH_DEV_CHANNEL_MAX)
3062 : : return NULL;
3063 : : else
3064 : 0 : return p_dpp_dtb_mgr[dev_id];
3065 : : }
3066 : :
3067 : : static uint32_t
3068 : 0 : zxdh_np_dtb_mgr_create(uint32_t dev_id)
3069 : : {
3070 [ # # ]: 0 : if (p_dpp_dtb_mgr[dev_id] != NULL) {
3071 : 0 : PMD_DRV_LOG(ERR, "ErrorCode[0x%x]: Dma Manager"
3072 : : " is exist!!!", ZXDH_RC_DTB_MGR_EXIST);
3073 : 0 : return ZXDH_RC_DTB_MGR_EXIST;
3074 : : }
3075 : :
3076 : 0 : p_dpp_dtb_mgr[dev_id] = rte_zmalloc(NULL, sizeof(ZXDH_DTB_MGR_T), 0);
3077 [ # # ]: 0 : if (p_dpp_dtb_mgr[dev_id] == NULL) {
3078 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
3079 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
3080 : : }
3081 : :
3082 : : return ZXDH_OK;
3083 : : }
3084 : :
3085 : : static uint32_t
3086 : 0 : zxdh_np_dtb_soft_init(uint32_t dev_id)
3087 : : {
3088 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
3089 : :
3090 [ # # ]: 0 : if (dev_id >= ZXDH_DEV_CHANNEL_MAX)
3091 : : return 1;
3092 : :
3093 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
3094 [ # # ]: 0 : if (p_dtb_mgr == NULL) {
3095 : 0 : zxdh_np_dtb_mgr_create(dev_id);
3096 : :
3097 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
3098 [ # # ]: 0 : if (p_dtb_mgr == NULL)
3099 : 0 : return ZXDH_RC_DTB_MGR_NOT_EXIST;
3100 : : }
3101 : :
3102 : : return 0;
3103 : : }
3104 : :
3105 : : static uint32_t
3106 : 0 : zxdh_np_base_soft_init(uint32_t dev_id, ZXDH_SYS_INIT_CTRL_T *p_init_ctrl)
3107 : : {
3108 : 0 : uint32_t dev_id_array[ZXDH_DEV_CHANNEL_MAX] = {0};
3109 : : uint32_t rt;
3110 : : uint32_t access_type;
3111 : : uint32_t agent_flag;
3112 : :
3113 : 0 : rt = zxdh_np_dev_init();
3114 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_init");
3115 : :
3116 [ # # ]: 0 : if (p_init_ctrl->flags & ZXDH_INIT_FLAG_ACCESS_TYPE)
3117 : : access_type = ZXDH_DEV_ACCESS_TYPE_RISCV;
3118 : : else
3119 : : access_type = ZXDH_DEV_ACCESS_TYPE_PCIE;
3120 : :
3121 [ # # ]: 0 : if (p_init_ctrl->flags & ZXDH_INIT_FLAG_AGENT_FLAG)
3122 : : agent_flag = ZXDH_DEV_AGENT_ENABLE;
3123 : : else
3124 : : agent_flag = ZXDH_DEV_AGENT_DISABLE;
3125 : :
3126 : 0 : rt = zxdh_np_dev_add(dev_id,
3127 : : p_init_ctrl->device_type,
3128 : : access_type,
3129 : : p_init_ctrl->pcie_vir_baddr,
3130 : : p_init_ctrl->riscv_vir_baddr,
3131 : : p_init_ctrl->dma_vir_baddr,
3132 : : p_init_ctrl->dma_phy_baddr);
3133 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_add");
3134 : :
3135 : : rt = zxdh_np_dev_agent_status_set(dev_id, agent_flag);
3136 : 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_agent_status_set");
3137 : :
3138 : 0 : dev_id_array[0] = dev_id;
3139 : 0 : rt = zxdh_np_sdt_init(1, dev_id_array);
3140 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_sdt_init");
3141 : :
3142 : 0 : zxdh_np_ppu_parse_cls_bitmap(dev_id, ZXDH_PPU_CLS_ALL_START);
3143 : :
3144 : 0 : rt = zxdh_np_dtb_soft_init(dev_id);
3145 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dtb_soft_init");
3146 : :
3147 : 0 : return rt;
3148 : : }
3149 : :
3150 : : static void
3151 : : zxdh_np_dev_vport_set(uint32_t dev_id, uint32_t vport)
3152 : : {
3153 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
3154 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
3155 : :
3156 : : p_dev_mgr = &g_dev_mgr;
3157 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
3158 : 0 : p_dev_info->vport = vport;
3159 : : }
3160 : :
3161 : : static void
3162 : : zxdh_np_dev_agent_addr_set(uint32_t dev_id, uint64_t agent_addr)
3163 : : {
3164 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
3165 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
3166 : :
3167 : : p_dev_mgr = &g_dev_mgr;
3168 : : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
3169 : 0 : p_dev_info->agent_addr = agent_addr;
3170 : : }
3171 : :
3172 : : static uint64_t
3173 : : zxdh_np_addr_calc(uint64_t pcie_vir_baddr, uint32_t bar_offset)
3174 : : {
3175 : : uint64_t np_addr;
3176 : :
3177 : 0 : np_addr = ((pcie_vir_baddr + bar_offset) > ZXDH_PCIE_NP_MEM_SIZE)
3178 : 0 : ? (pcie_vir_baddr + bar_offset - ZXDH_PCIE_NP_MEM_SIZE) : 0;
3179 : : return np_addr;
3180 : : }
3181 : :
3182 : : static uint64_t
3183 : : zxdh_np_fw_compatible_addr_calc(uint64_t pcie_vir_baddr, uint64_t compatible_offset)
3184 : : {
3185 : 0 : return (pcie_vir_baddr + compatible_offset);
3186 : : }
3187 : :
3188 : : static void
3189 : : zxdh_np_pf_fw_compatible_addr_set(uint32_t dev_id, uint64_t pcie_vir_baddr)
3190 : : {
3191 : : uint64_t compatible_offset = ZXDH_DPU_NO_DEBUG_PF_COMPAT_REG_OFFSET;
3192 : : uint64_t compatible_addr = 0;
3193 : :
3194 : : compatible_addr = zxdh_np_fw_compatible_addr_calc(pcie_vir_baddr, compatible_offset);
3195 : :
3196 : 0 : g_np_fw_compat_addr[dev_id] = compatible_addr;
3197 : : }
3198 : :
3199 : : static void
3200 : : zxdh_np_fw_compatible_addr_get(uint32_t dev_id, uint64_t *p_compatible_addr)
3201 : : {
3202 : 0 : *p_compatible_addr = g_np_fw_compat_addr[dev_id];
3203 : : }
3204 : :
3205 : : static void
3206 : : zxdh_np_fw_version_data_read(uint64_t compatible_base_addr,
3207 : : ZXDH_VERSION_COMPATIBLE_REG_T *p_fw_version_data, uint32_t module_id)
3208 : : {
3209 : : void *fw_addr = NULL;
3210 : : uint64_t module_compatible_addr = 0;
3211 : :
3212 : 0 : module_compatible_addr = compatible_base_addr +
3213 : : sizeof(ZXDH_VERSION_COMPATIBLE_REG_T) * (module_id - 1);
3214 : :
3215 : 0 : fw_addr = (void *)module_compatible_addr;
3216 : :
3217 : : memcpy(p_fw_version_data, fw_addr, sizeof(ZXDH_VERSION_COMPATIBLE_REG_T));
3218 : : }
3219 : :
3220 : : static void
3221 : : zxdh_np_fw_version_compatible_data_get(uint32_t dev_id,
3222 : : ZXDH_VERSION_COMPATIBLE_REG_T *p_version_compatible_value,
3223 : : uint32_t module_id)
3224 : : {
3225 : : uint64_t compatible_addr = 0;
3226 : :
3227 : : zxdh_np_fw_compatible_addr_get(dev_id, &compatible_addr);
3228 : :
3229 : : zxdh_np_fw_version_data_read(compatible_addr, p_version_compatible_value, module_id);
3230 : : }
3231 : :
3232 : : static uint32_t
3233 : 0 : zxdh_np_np_sdk_version_compatible_check(uint32_t dev_id)
3234 : : {
3235 : : ZXDH_VERSION_COMPATIBLE_REG_T fw_version = {0};
3236 : :
3237 : : zxdh_np_fw_version_compatible_data_get(dev_id, &fw_version, ZXDH_NPSDK_COMPAT_ITEM_ID);
3238 : :
3239 [ # # ]: 0 : if (fw_version.version_compatible_item != ZXDH_NPSDK_COMPAT_ITEM_ID) {
3240 : 0 : PMD_DRV_LOG(ERR, "version_compatible_item is not DH_NPSDK.");
3241 : 0 : return ZXDH_ERR;
3242 : : }
3243 : :
3244 [ # # ]: 0 : if (g_np_sdk_version.major != fw_version.major) {
3245 : 0 : PMD_DRV_LOG(ERR, "dh_npsdk major:%hhu: is not match fw:%hhu!",
3246 : : g_np_sdk_version.major, fw_version.major);
3247 : 0 : return ZXDH_ERR;
3248 : : }
3249 : :
3250 : : if (g_np_sdk_version.fw_minor > fw_version.fw_minor) {
3251 : : PMD_DRV_LOG(ERR, "dh_npsdk fw_minor:%hhu is higher than fw:%hhu!",
3252 : : g_np_sdk_version.fw_minor, fw_version.fw_minor);
3253 : : return ZXDH_ERR;
3254 : : }
3255 : :
3256 [ # # ]: 0 : if (g_np_sdk_version.drv_minor < fw_version.drv_minor) {
3257 : 0 : PMD_DRV_LOG(ERR, "dh_npsdk drv_minor:%hhu is lower than fw:%hhu!",
3258 : : g_np_sdk_version.drv_minor, fw_version.drv_minor);
3259 : 0 : return ZXDH_ERR;
3260 : : }
3261 : :
3262 : 0 : PMD_DRV_LOG(INFO, "dh_npsdk compatible check success!");
3263 : :
3264 : 0 : return ZXDH_OK;
3265 : : }
3266 : :
3267 : : static uint32_t
3268 : 0 : zxdh_np_pcie_bar_msg_num_get(uint32_t dev_id, uint32_t *p_bar_msg_num)
3269 : : {
3270 : : uint32_t rc = ZXDH_OK;
3271 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
3272 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
3273 : :
3274 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
3275 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
3276 : :
3277 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
3278 : 0 : rc = zxdh_np_agent_channel_pcie_bar_request(dev_id, p_bar_msg_num);
3279 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_pcie_bar_request");
3280 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3281 : :
3282 : 0 : return rc;
3283 : : }
3284 : :
3285 : : static uint32_t
3286 : 0 : zxdh_np_comm_read_bits(uint8_t *p_base, uint32_t base_size_bit,
3287 : : uint32_t *p_data, uint32_t start_bit, uint32_t end_bit)
3288 : : {
3289 : : uint32_t start_byte_index;
3290 : : uint32_t end_byte_index;
3291 : : uint32_t byte_num;
3292 : : uint32_t buffer_size;
3293 : : uint32_t len;
3294 : :
3295 [ # # ]: 0 : if (0 != (base_size_bit % 8))
3296 : : return 1;
3297 : :
3298 [ # # ]: 0 : if (start_bit > end_bit)
3299 : : return 1;
3300 : :
3301 [ # # ]: 0 : if (base_size_bit < end_bit)
3302 : : return 1;
3303 : :
3304 : 0 : len = end_bit - start_bit + 1;
3305 : 0 : buffer_size = base_size_bit / 8;
3306 [ # # ]: 0 : while (0 != (buffer_size & (buffer_size - 1)))
3307 : 0 : buffer_size += 1;
3308 : :
3309 : 0 : *p_data = 0;
3310 : 0 : end_byte_index = (end_bit >> 3);
3311 : 0 : start_byte_index = (start_bit >> 3);
3312 : :
3313 [ # # ]: 0 : if (start_byte_index == end_byte_index) {
3314 : 0 : *p_data = (uint32_t)(((p_base[start_byte_index] >> (7U - (end_bit & 7)))
3315 : 0 : & (0xff >> (8U - len))) & 0xff);
3316 : 0 : return 0;
3317 : : }
3318 : :
3319 [ # # ]: 0 : if (start_bit & 7) {
3320 : 0 : *p_data = (p_base[start_byte_index] & (0xff >> (start_bit & 7))) & UINT8_MAX;
3321 : 0 : start_byte_index++;
3322 : : }
3323 : :
3324 [ # # ]: 0 : for (byte_num = start_byte_index; byte_num < end_byte_index; byte_num++) {
3325 : 0 : *p_data <<= 8;
3326 : 0 : *p_data += p_base[byte_num];
3327 : : }
3328 : :
3329 : 0 : *p_data <<= 1 + (end_bit & 7);
3330 : 0 : *p_data += ((p_base[byte_num & (buffer_size - 1)] & (0xff << (7 - (end_bit & 7)))) >>
3331 : 0 : (7 - (end_bit & 7))) & 0xff;
3332 : :
3333 : 0 : return 0;
3334 : : }
3335 : :
3336 : : static uint32_t
3337 : : zxdh_np_comm_read_bits_ex(uint8_t *p_base, uint32_t base_size_bit,
3338 : : uint32_t *p_data, uint32_t msb_start_pos, uint32_t len)
3339 : : {
3340 : : uint32_t rtn;
3341 : :
3342 : 0 : rtn = zxdh_np_comm_read_bits(p_base,
3343 : : base_size_bit,
3344 : : p_data,
3345 : : (base_size_bit - 1 - msb_start_pos),
3346 : 0 : (base_size_bit - 1 - msb_start_pos + len - 1));
3347 : : return rtn;
3348 : : }
3349 : :
3350 : : static uint32_t
3351 : 0 : zxdh_np_reg_read(uint32_t dev_id, uint32_t reg_no,
3352 : : uint32_t m_offset, uint32_t n_offset, void *p_data)
3353 : : {
3354 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
3355 : : ZXDH_REG_T *p_reg_info = &g_dpp_reg_info[reg_no];
3356 : 0 : const ZXDH_FIELD_T *p_field_info = p_reg_info->p_fields;
3357 : : uint32_t rc = 0;
3358 : : uint32_t i;
3359 : : uint32_t addr = 0;
3360 : 0 : uint32_t reg_module = p_reg_info->module_no;
3361 : 0 : uint32_t reg_width = p_reg_info->width;
3362 : 0 : uint32_t reg_real_no = p_reg_info->reg_no;
3363 : 0 : uint32_t reg_type = p_reg_info->flags;
3364 : :
3365 : 0 : addr = zxdh_np_reg_get_reg_addr(reg_no, m_offset, n_offset);
3366 : :
3367 [ # # ]: 0 : if (reg_module == DTB4K) {
3368 : 0 : rc = p_reg_info->p_read_fun(dev_id, addr, p_buff);
3369 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "p_reg_info->p_read_fun");
3370 : : } else {
3371 : 0 : rc = zxdh_np_agent_channel_reg_read(dev_id,
3372 : : reg_type, reg_real_no, reg_width, addr, p_buff);
3373 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_reg_read");
3374 : : }
3375 : :
3376 : : if (!zxdh_np_comm_is_big_endian()) {
3377 [ # # ]: 0 : for (i = 0; i < p_reg_info->width / 4; i++) {
3378 : 0 : PMD_DRV_LOG(DEBUG, "data = 0x%08x.", p_buff[i]);
3379 : 0 : p_buff[i] = ZXDH_COMM_CONVERT32(p_buff[i]);
3380 : : }
3381 : : }
3382 : :
3383 [ # # ]: 0 : for (i = 0; i < p_reg_info->field_num; i++) {
3384 : 0 : rc = zxdh_np_comm_read_bits_ex((uint8_t *)p_buff,
3385 : 0 : p_reg_info->width * 8,
3386 : 0 : (uint32_t *)p_data + i,
3387 : 0 : p_field_info[i].msb_pos,
3388 : 0 : p_field_info[i].len);
3389 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_comm_read_bits_ex");
3390 : 0 : PMD_DRV_LOG(DEBUG, "dev_id %u(%u)(%u)is ok!", dev_id, m_offset, n_offset);
3391 : : }
3392 : :
3393 : 0 : return rc;
3394 : : }
3395 : :
3396 : : static uint32_t
3397 : 0 : zxdh_np_reg_read32(uint32_t dev_id, uint32_t reg_no,
3398 : : uint32_t m_offset, uint32_t n_offset, uint32_t *p_data)
3399 : : {
3400 : : uint32_t rc = 0;
3401 : : uint32_t addr = 0;
3402 : : ZXDH_REG_T *p_reg_info = &g_dpp_reg_info[reg_no];
3403 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
3404 : 0 : uint32_t reg_real_no = p_reg_info->reg_no;
3405 : 0 : uint32_t reg_type = p_reg_info->flags;
3406 : 0 : uint32_t reg_module = p_reg_info->module_no;
3407 : :
3408 : 0 : addr = zxdh_np_reg_get_reg_addr(reg_no, m_offset, n_offset);
3409 : :
3410 [ # # ]: 0 : if (reg_module == DTB4K) {
3411 : 0 : rc = p_reg_info->p_read_fun(dev_id, addr, p_data);
3412 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "p_reg_info->p_read_fun");
3413 : : } else {
3414 : 0 : rc = zxdh_np_agent_channel_reg_read(dev_id, reg_type, reg_real_no, 4, addr, p_buff);
3415 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_reg_read");
3416 : 0 : *p_data = p_buff[0];
3417 : : }
3418 : :
3419 : 0 : return rc;
3420 : : }
3421 : :
3422 : : static uint32_t
3423 : 0 : zxdh_np_dtb_queue_vm_info_get(uint32_t dev_id,
3424 : : uint32_t queue_id,
3425 : : ZXDH_DTB_QUEUE_VM_INFO_T *p_vm_info)
3426 : : {
3427 : : uint32_t rc = 0;
3428 : : uint32_t dtb_epid_v_func_reg = ZXDH_SYS_DTB_BASE_ADDR +
3429 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0010;
3430 : 0 : uint32_t epid_v_func = 0;
3431 : :
3432 : 0 : rc = zxdh_np_dev_read_channel(dev_id, dtb_epid_v_func_reg + queue_id * 32, 1, &epid_v_func);
3433 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_read_channel");
3434 : :
3435 : 0 : p_vm_info->dbi_en = (epid_v_func >> 31 & 0x1);
3436 : 0 : p_vm_info->queue_en = (epid_v_func >> 30 & 0x1);
3437 : 0 : p_vm_info->epid = (epid_v_func >> 24 & 0xF);
3438 : 0 : p_vm_info->vfunc_num = (epid_v_func >> 16 & 0xFF);
3439 : 0 : p_vm_info->vector = (epid_v_func >> 8 & 0x7);
3440 : 0 : p_vm_info->func_num = (epid_v_func >> 5 & 0x7);
3441 : 0 : p_vm_info->vfunc_active = (epid_v_func & 0x1);
3442 : :
3443 : 0 : return rc;
3444 : : }
3445 : :
3446 : : static uint32_t
3447 : 0 : zxdh_np_comm_write_bits(uint8_t *p_base, uint32_t base_size_bit,
3448 : : uint32_t data, uint32_t start_bit, uint32_t end_bit)
3449 : : {
3450 : : uint32_t start_byte_index;
3451 : : uint32_t end_byte_index;
3452 : : uint8_t mask_value;
3453 : : uint32_t byte_num;
3454 : : uint32_t buffer_size;
3455 : :
3456 [ # # ]: 0 : if (0 != (base_size_bit % 8))
3457 : : return 1;
3458 : :
3459 [ # # ]: 0 : if (start_bit > end_bit)
3460 : : return 1;
3461 : :
3462 [ # # ]: 0 : if (base_size_bit < end_bit)
3463 : : return 1;
3464 : :
3465 : 0 : buffer_size = base_size_bit / 8;
3466 : :
3467 [ # # ]: 0 : while (0 != (buffer_size & (buffer_size - 1)))
3468 : 0 : buffer_size += 1;
3469 : :
3470 : 0 : end_byte_index = (end_bit >> 3);
3471 : 0 : start_byte_index = (start_bit >> 3);
3472 : :
3473 [ # # ]: 0 : if (start_byte_index == end_byte_index) {
3474 : 0 : mask_value = ((0xFE << (7 - (start_bit & 7))) & 0xff);
3475 : 0 : mask_value |= (((1 << (7 - (end_bit & 7))) - 1) & 0xff);
3476 : 0 : p_base[end_byte_index] &= mask_value;
3477 : 0 : p_base[end_byte_index] |= (((data << (7 - (end_bit & 7)))) & 0xff);
3478 : 0 : return 0;
3479 : : }
3480 : :
3481 [ # # ]: 0 : if (7 != (end_bit & 7)) {
3482 : 0 : mask_value = ((0x7f >> (end_bit & 7)) & 0xff);
3483 : 0 : p_base[end_byte_index] &= mask_value;
3484 : 0 : p_base[end_byte_index] |= ((data << (7 - (end_bit & 7))) & 0xff);
3485 : 0 : end_byte_index--;
3486 : 0 : data >>= 1 + (end_bit & 7);
3487 : : }
3488 : :
3489 [ # # ]: 0 : for (byte_num = end_byte_index; byte_num > start_byte_index; byte_num--) {
3490 : 0 : p_base[byte_num & (buffer_size - 1)] = data & 0xff;
3491 : 0 : data >>= 8;
3492 : : }
3493 : :
3494 : 0 : mask_value = ((0xFE << (7 - (start_bit & 7))) & 0xff);
3495 : 0 : p_base[byte_num] &= mask_value;
3496 : 0 : p_base[byte_num] |= data;
3497 : :
3498 : 0 : return 0;
3499 : : }
3500 : :
3501 : : static uint32_t
3502 : : zxdh_np_comm_write_bits_ex(uint8_t *p_base,
3503 : : uint32_t base_size_bit,
3504 : : uint32_t data,
3505 : : uint32_t msb_start_pos,
3506 : : uint32_t len)
3507 : : {
3508 : : uint32_t rtn;
3509 : :
3510 : 0 : rtn = zxdh_np_comm_write_bits(p_base,
3511 : : base_size_bit,
3512 : : data,
3513 : : (base_size_bit - 1 - msb_start_pos),
3514 : 0 : (base_size_bit - 1 - msb_start_pos + len - 1));
3515 : :
3516 : : return rtn;
3517 : : }
3518 : :
3519 : : static uint32_t
3520 : 0 : zxdh_np_reg_write(uint32_t dev_id, uint32_t reg_no,
3521 : : uint32_t m_offset, uint32_t n_offset, void *p_data)
3522 : : {
3523 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
3524 : : ZXDH_REG_T *p_reg_info = &g_dpp_reg_info[reg_no];
3525 : 0 : const ZXDH_FIELD_T *p_field_info = p_reg_info->p_fields;
3526 : : uint32_t temp_data;
3527 : : uint32_t rc = ZXDH_OK;
3528 : : uint32_t i;
3529 : : uint32_t addr = 0;
3530 : 0 : uint32_t reg_module = p_reg_info->module_no;
3531 : 0 : uint32_t reg_width = p_reg_info->width;
3532 : 0 : uint32_t reg_type = p_reg_info->flags;
3533 : 0 : uint32_t reg_real_no = p_reg_info->reg_no;
3534 : :
3535 [ # # ]: 0 : for (i = 0; i < p_reg_info->field_num; i++) {
3536 [ # # ]: 0 : if (p_field_info[i].len <= 32) {
3537 : 0 : temp_data = *((uint32_t *)p_data + i) &
3538 [ # # ]: 0 : zxdh_np_comm_get_bit_mask(p_field_info[i].len);
3539 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_buff,
3540 : 0 : p_reg_info->width * 8,
3541 : : temp_data,
3542 : 0 : p_field_info[i].msb_pos,
3543 : : p_field_info[i].len);
3544 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_comm_write_bits_ex");
3545 : : }
3546 : : }
3547 : :
3548 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_np_comm_write_bits_ex data = 0x%08x.", p_buff[0]);
3549 : :
3550 : : if (!zxdh_np_comm_is_big_endian()) {
3551 [ # # ]: 0 : for (i = 0; i < p_reg_info->width / 4; i++) {
3552 : 0 : p_buff[i] = ZXDH_COMM_CONVERT32(p_buff[i]);
3553 : :
3554 : 0 : PMD_DRV_LOG(DEBUG, "ZXDH_COMM_CONVERT32 data = 0x%08x.",
3555 : : p_buff[i]);
3556 : : }
3557 : : }
3558 : :
3559 : 0 : addr = zxdh_np_reg_get_reg_addr(reg_no, m_offset, n_offset);
3560 : :
3561 : 0 : PMD_DRV_LOG(DEBUG, "reg_no = %u. m_offset = %u n_offset = %u",
3562 : : reg_no, m_offset, n_offset);
3563 : 0 : PMD_DRV_LOG(DEBUG, "baseaddr = 0x%08x.", addr);
3564 : :
3565 [ # # ]: 0 : if (reg_module == DTB4K) {
3566 : 0 : rc = p_reg_info->p_write_fun(dev_id, addr, p_buff);
3567 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "p_reg_info->p_write_fun");
3568 : : } else {
3569 : 0 : rc = zxdh_np_agent_channel_reg_write(dev_id,
3570 : : reg_type, reg_real_no, reg_width, addr, p_buff);
3571 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_reg_write");
3572 : : }
3573 : :
3574 : 0 : return rc;
3575 : : }
3576 : :
3577 : : static uint32_t
3578 : 0 : zxdh_np_dtb_queue_vm_info_set(uint32_t dev_id,
3579 : : uint32_t queue_id,
3580 : : ZXDH_DTB_QUEUE_VM_INFO_T *p_vm_info)
3581 : : {
3582 : : uint32_t rc = 0;
3583 : : ZXDH_DTB4K_DTB_ENQ_CFG_EPID_V_FUNC_NUM_0_127_T vm_info = {0};
3584 : :
3585 : 0 : vm_info.dbi_en = p_vm_info->dbi_en;
3586 : 0 : vm_info.queue_en = p_vm_info->queue_en;
3587 : 0 : vm_info.cfg_epid = p_vm_info->epid;
3588 : 0 : vm_info.cfg_vector = p_vm_info->vector;
3589 : 0 : vm_info.cfg_vfunc_num = p_vm_info->vfunc_num;
3590 : 0 : vm_info.cfg_func_num = p_vm_info->func_num;
3591 : 0 : vm_info.cfg_vfunc_active = p_vm_info->vfunc_active;
3592 : :
3593 : 0 : rc = zxdh_np_reg_write(dev_id, ZXDH_DTB_CFG_EPID_V_FUNC_NUM,
3594 : : 0, queue_id, &vm_info);
3595 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_reg_write");
3596 : :
3597 : 0 : return rc;
3598 : : }
3599 : :
3600 : : static uint32_t
3601 : 0 : zxdh_np_dtb_queue_unused_item_num_get(uint32_t dev_id,
3602 : : uint32_t queue_id,
3603 : : uint32_t *p_item_num)
3604 : : {
3605 : : uint32_t rc;
3606 : :
3607 : 0 : rc = zxdh_np_reg_read(dev_id, ZXDH_DTB_INFO_QUEUE_BUF_SPACE,
3608 : : 0, queue_id, p_item_num);
3609 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_reg_read");
3610 : 0 : return rc;
3611 : : }
3612 : :
3613 : : static uint32_t
3614 : 0 : zxdh_np_dtb_queue_id_free(uint32_t dev_id,
3615 : : uint32_t queue_id)
3616 : : {
3617 : 0 : uint32_t item_num = 0;
3618 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
3619 : : uint32_t rc;
3620 : :
3621 : 0 : p_dtb_mgr = p_dpp_dtb_mgr[dev_id];
3622 [ # # ]: 0 : if (p_dtb_mgr == NULL)
3623 : : return 1;
3624 : :
3625 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &item_num);
3626 : :
3627 [ # # ]: 0 : if (item_num != ZXDH_DTB_QUEUE_ITEM_NUM_MAX)
3628 : : return ZXDH_RC_DTB_QUEUE_IS_WORKING;
3629 : :
3630 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 0;
3631 : 0 : p_dtb_mgr->queue_info[queue_id].vport = 0;
3632 : 0 : p_dtb_mgr->queue_info[queue_id].vector = 0;
3633 : :
3634 : 0 : memset(&p_dtb_mgr->queue_info[queue_id].tab_up, 0, sizeof(ZXDH_DTB_TAB_UP_INFO_T));
3635 : 0 : memset(&p_dtb_mgr->queue_info[queue_id].tab_down, 0, sizeof(ZXDH_DTB_TAB_DOWN_INFO_T));
3636 : :
3637 : 0 : return rc;
3638 : : }
3639 : :
3640 : : static ZXDH_RB_CFG *
3641 : : zxdh_np_dtb_dump_addr_rb_get(uint32_t dev_id, uint32_t queue_id)
3642 : : {
3643 : 0 : return g_dtb_dump_addr_rb[dev_id][queue_id];
3644 : : }
3645 : :
3646 : : static uint32_t
3647 : : zxdh_np_dtb_dump_addr_rb_set(uint32_t dev_id, uint32_t queue_id, ZXDH_RB_CFG *p_dump_addr_rb)
3648 : : {
3649 : 0 : g_dtb_dump_addr_rb[dev_id][queue_id] = p_dump_addr_rb;
3650 : : return ZXDH_OK;
3651 : : }
3652 : :
3653 : : static uint32_t
3654 : 0 : zxdh_np_dtb_dump_sdt_addr_clear(uint32_t dev_id,
3655 : : uint32_t queue_id,
3656 : : uint32_t sdt_no)
3657 : : {
3658 : : uint32_t rc = ZXDH_OK;
3659 : :
3660 : 0 : ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {0};
3661 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
3662 : :
3663 : 0 : dtb_dump_addr_info.sdt_no = sdt_no;
3664 : :
3665 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
3666 : 0 : rc = zxdh_np_se_apt_rb_delete(p_dtb_dump_addr_rb, &dtb_dump_addr_info,
3667 : : sizeof(ZXDH_DTB_ADDR_INFO_T));
3668 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_apt_rb_delete");
3669 : :
3670 : 0 : return rc;
3671 : : }
3672 : :
3673 : : static uint32_t
3674 : 0 : zxdh_np_dtb_dump_addr_rb_destroy(uint32_t dev_id, uint32_t queue_id)
3675 : : {
3676 : : uint32_t rc = ZXDH_OK;
3677 : : ZXDH_D_NODE *p_node = NULL;
3678 : : ZXDH_RB_TN *p_rb_tn = NULL;
3679 : : ZXDH_DTB_ADDR_INFO_T *p_rbkey = NULL;
3680 : : ZXDH_D_HEAD *p_head_dtb_rb = NULL;
3681 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
3682 : : uint32_t sdt_no = 0;
3683 : :
3684 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
3685 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dtb_dump_addr_rb);
3686 : :
3687 : : p_head_dtb_rb = &p_dtb_dump_addr_rb->tn_list;
3688 : :
3689 [ # # ]: 0 : while (p_head_dtb_rb->used) {
3690 : 0 : p_node = p_head_dtb_rb->p_next;
3691 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
3692 : 0 : p_rbkey = (ZXDH_DTB_ADDR_INFO_T *)p_rb_tn->p_key;
3693 : :
3694 : 0 : sdt_no = p_rbkey->sdt_no;
3695 : 0 : rc = zxdh_np_dtb_dump_sdt_addr_clear(dev_id, queue_id, sdt_no);
3696 : :
3697 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
3698 : 0 : PMD_DRV_LOG(ERR, "dtb dump delete key is not exist,"
3699 : : "std:%u", sdt_no);
3700 : : else
3701 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_clear");
3702 : : }
3703 : :
3704 : 0 : rc = zxdh_comm_rb_destroy(p_dtb_dump_addr_rb);
3705 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
3706 : :
3707 : 0 : return rc;
3708 : : }
3709 : :
3710 : : static uint32_t
3711 : 0 : zxdh_np_dtb_dump_addr_rb_init(uint32_t dev_id, uint32_t queue_id)
3712 : : {
3713 : : uint32_t rc = ZXDH_OK;
3714 : :
3715 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
3716 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
3717 : :
3718 [ # # ]: 0 : if (p_dtb_dump_addr_rb == NULL) {
3719 : 0 : p_dtb_dump_addr_rb = rte_zmalloc(NULL, sizeof(ZXDH_RB_CFG), 0);
3720 [ # # ]: 0 : if (p_dtb_dump_addr_rb == NULL) {
3721 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
3722 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
3723 : : }
3724 : :
3725 : : rc = zxdh_np_dtb_dump_addr_rb_set(dev_id, queue_id, p_dtb_dump_addr_rb);
3726 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_rb_set");
3727 : : }
3728 : :
3729 : 0 : rc = zxdh_comm_rb_init(p_dtb_dump_addr_rb, 0,
3730 : : sizeof(ZXDH_DTB_ADDR_INFO_T), zxdh_np_se_apt_key_default_cmp);
3731 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
3732 : :
3733 : : return rc;
3734 : : }
3735 : :
3736 : : static uint32_t
3737 : 0 : zxdh_np_dtb_queue_request(uint32_t dev_id, char p_name[32],
3738 : : uint16_t vport, uint32_t *p_queue_id)
3739 : : {
3740 : : uint32_t rc = ZXDH_OK;
3741 : 0 : uint32_t queue_id = 0xFF;
3742 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
3743 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
3744 : 0 : uint32_t vport_info = (uint32_t)vport;
3745 : :
3746 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
3747 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
3748 : :
3749 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
3750 : :
3751 : 0 : rc = zxdh_np_agent_channel_dtb_queue_request(dev_id, p_name, vport_info, &queue_id);
3752 [ # # ]: 0 : if (rc == ZXDH_RC_DTB_QUEUE_RES_EMPTY) {
3753 : 0 : PMD_DRV_LOG(ERR, "dtb queue is locked full.");
3754 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3755 : 0 : return ZXDH_RC_DTB_QUEUE_RES_EMPTY;
3756 : : }
3757 : :
3758 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3759 : :
3760 : 0 : PMD_DRV_LOG(DEBUG, "dtb request queue is %u.", queue_id);
3761 : :
3762 : 0 : rc = zxdh_np_dtb_dump_addr_rb_init(dev_id, queue_id);
3763 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_rb_init");
3764 : :
3765 : 0 : *p_queue_id = queue_id;
3766 : :
3767 : 0 : PMD_DRV_LOG(INFO, "dev_id %u vport 0x%x name %s queue_id %u done.",
3768 : : dev_id, vport_info, p_name, queue_id);
3769 : :
3770 : 0 : return rc;
3771 : : }
3772 : :
3773 : : static uint32_t
3774 : 0 : zxdh_np_dtb_queue_release(uint32_t devid,
3775 : : char pname[32],
3776 : : uint32_t queueid)
3777 : : {
3778 : : uint32_t rc = ZXDH_OK;
3779 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
3780 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
3781 : :
3782 : 0 : rc = zxdh_np_dev_opr_spinlock_get(devid, (uint32_t)spinlock, &p_dtb_spinlock);
3783 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dev_opr_spinlock_get");
3784 : :
3785 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
3786 : :
3787 : 0 : rc = zxdh_np_agent_channel_dtb_queue_release(devid, pname, queueid);
3788 : :
3789 [ # # ]: 0 : if (rc == ZXDH_RC_DTB_QUEUE_NOT_ALLOC) {
3790 : 0 : PMD_DRV_LOG(ERR, "dtb queue id %u not request.", queueid);
3791 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3792 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ALLOC;
3793 : : }
3794 : :
3795 [ # # ]: 0 : if (rc == ZXDH_RC_DTB_QUEUE_NAME_ERROR) {
3796 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u name error.", queueid);
3797 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3798 : 0 : return ZXDH_RC_DTB_QUEUE_NAME_ERROR;
3799 : : }
3800 : :
3801 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
3802 : :
3803 : 0 : rc = zxdh_np_dtb_dump_addr_rb_destroy(devid, queueid);
3804 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dtb_dump_addr_rb_destroy");
3805 : :
3806 : 0 : rc = zxdh_np_dtb_queue_id_free(devid, queueid);
3807 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dtb_queue_id_free");
3808 : :
3809 : 0 : PMD_DRV_LOG(INFO, "release queueid %u", queueid);
3810 : :
3811 : 0 : return rc;
3812 : : }
3813 : :
3814 : : static void
3815 : : zxdh_np_dtb_mgr_destroy(uint32_t dev_id)
3816 : : {
3817 [ # # ]: 0 : if (p_dpp_dtb_mgr[dev_id] != NULL) {
3818 : 0 : rte_free(p_dpp_dtb_mgr[dev_id]);
3819 : 0 : p_dpp_dtb_mgr[dev_id] = NULL;
3820 : : }
3821 : : }
3822 : :
3823 : : static void
3824 : : zxdh_np_sdt_mgr_destroy(uint32_t dev_id)
3825 : : {
3826 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_tbl_temp = NULL;
3827 : : ZXDH_SDT_MGR_T *p_sdt_mgr = NULL;
3828 : :
3829 : 0 : p_sdt_tbl_temp = ZXDH_SDT_SOFT_TBL_GET(dev_id);
3830 : : p_sdt_mgr = ZXDH_SDT_MGR_PTR_GET();
3831 : :
3832 : 0 : rte_free(p_sdt_tbl_temp);
3833 : :
3834 : 0 : ZXDH_SDT_SOFT_TBL_GET(dev_id) = NULL;
3835 : :
3836 : 0 : p_sdt_mgr->channel_num--;
3837 : : }
3838 : :
3839 : : static void
3840 : 0 : zxdh_np_dev_del(uint32_t dev_id)
3841 : : {
3842 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
3843 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
3844 : :
3845 : : p_dev_mgr = &g_dev_mgr;
3846 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
3847 : :
3848 [ # # ]: 0 : if (p_dev_info != NULL) {
3849 : 0 : rte_free(p_dev_info);
3850 : 0 : p_dev_mgr->p_dev_array[dev_id] = NULL;
3851 : 0 : p_dev_mgr->device_num--;
3852 : : }
3853 : 0 : }
3854 : :
3855 : : static uint32_t
3856 : 0 : zxdh_np_hash_soft_all_entry_delete(ZXDH_SE_CFG *p_se_cfg, uint32_t hash_id)
3857 : : {
3858 : : uint32_t rc = 0;
3859 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
3860 : : uint8_t table_id = 0;
3861 : : uint32_t bulk_id = 0;
3862 : :
3863 : : ZXDH_D_NODE *p_node = NULL;
3864 : : ZXDH_RB_TN *p_rb_tn = NULL;
3865 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
3866 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
3867 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
3868 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
3869 : : ZXDH_FUNC_ID_INFO *p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, hash_id);
3870 : 0 : ZXDH_HASH_CFG *p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
3871 : : ZXDH_D_HEAD *p_head_hash_rb = &p_hash_cfg->hash_rb.tn_list;
3872 : :
3873 [ # # ]: 0 : while (p_head_hash_rb->used) {
3874 : 0 : p_node = p_head_hash_rb->p_next;
3875 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
3876 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_rb_tn->p_key;
3877 : 0 : table_id = ZXDH_GET_HASH_TBL_ID(p_rbkey->key);
3878 : 0 : bulk_id = ((table_id >> 2) & 0x7);
3879 : :
3880 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, p_rbkey, &p_rb_tn_rtn);
3881 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL) {
3882 : 0 : p_hash_cfg->hash_stat.delete_fail++;
3883 : 0 : PMD_DRV_LOG(DEBUG, "Error!there is not item in hash!");
3884 : 0 : return ZXDH_HASH_RC_DEL_SRHFAIL;
3885 : : }
3886 : :
3887 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
3888 : 0 : p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
3889 [ # # ]: 0 : p_item = p_rbkey_rtn->p_item_info;
3890 : :
3891 : : rc = zxdh_comm_double_link_del(&p_rbkey_rtn->entry_dn, &p_item->item_list);
3892 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
3893 : 0 : p_item->wrt_mask &= ~(ZXDH_GET_HASH_ENTRY_MASK(p_rbkey_rtn->entry_size,
3894 : 0 : p_rbkey_rtn->entry_pos)) & 0xF;
3895 : :
3896 [ # # ]: 0 : if (p_item->item_list.used == 0) {
3897 [ # # ]: 0 : if (p_item->item_type == ZXDH_ITEM_DDR_256 ||
3898 : : p_item->item_type == ZXDH_ITEM_DDR_512) {
3899 : 0 : p_hash_cfg->p_bulk_ddr_info[bulk_id]->p_item_array
3900 : 0 : [p_item->item_index] = NULL;
3901 : 0 : rte_free(p_item);
3902 : : } else {
3903 : 0 : p_item->valid = 0;
3904 : : }
3905 : : }
3906 : :
3907 : 0 : rte_free(p_rbkey_rtn);
3908 : 0 : rte_free(p_rb_tn_rtn);
3909 : 0 : p_hash_cfg->hash_stat.delete_ok++;
3910 : : }
3911 : :
3912 : : return rc;
3913 : : }
3914 : :
3915 : : static uint32_t
3916 : 0 : zxdh_np_hash_zcam_resource_deinit(ZXDH_HASH_CFG *p_hash_cfg)
3917 : : {
3918 : : uint32_t rc = 0;
3919 : 0 : uint32_t dev_id = p_hash_cfg->p_se_info->dev_id;
3920 : : uint32_t i = 0;
3921 : :
3922 : : ZXDH_D_NODE *p_node = NULL;
3923 : : ZXDH_D_HEAD *p_head = &p_hash_cfg->hash_shareram.zcell_free_list;
3924 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
3925 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
3926 : :
3927 [ # # ]: 0 : while (p_head->used) {
3928 [ # # ]: 0 : p_node = p_head->p_next;
3929 : :
3930 : : rc = zxdh_comm_double_link_del(p_node, p_head);
3931 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
3932 : 0 : p_zcell_cfg = (ZXDH_SE_ZCELL_CFG *)p_node->data;
3933 : 0 : p_zcell_cfg->is_used = 0;
3934 : 0 : p_zcell_cfg->flag = 0;
3935 : : }
3936 : :
3937 : : p_head = &p_hash_cfg->hash_shareram.zblk_list;
3938 : :
3939 [ # # ]: 0 : while (p_head->used) {
3940 [ # # ]: 0 : p_node = p_head->p_next;
3941 : :
3942 : : rc = zxdh_comm_double_link_del(p_node, p_head);
3943 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
3944 : :
3945 : 0 : p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_hash_cfg->p_se_info,
3946 : : ((ZXDH_SE_ZBLK_CFG *)p_node->data)->zblk_idx);
3947 : 0 : p_zblk_cfg->is_used = 0;
3948 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++)
3949 : 0 : p_zblk_cfg->zreg_info[i].flag = 0;
3950 : : }
3951 : :
3952 : 0 : return rc;
3953 : : }
3954 : :
3955 : : static uint32_t
3956 : 0 : zxdh_np_se_fun_deinit(ZXDH_SE_CFG *p_se_cfg,
3957 : : uint8_t id,
3958 : : uint32_t fun_type)
3959 : : {
3960 : 0 : ZXDH_FUNC_ID_INFO *p_fun_info = ZXDH_GET_FUN_INFO(p_se_cfg, id);
3961 : :
3962 [ # # ]: 0 : if (p_fun_info->is_used == 0) {
3963 : 0 : PMD_DRV_LOG(ERR, " Error[0x%x], fun_id [%u] is already deinit!",
3964 : : ZXDH_SE_RC_FUN_INVALID, id);
3965 : 0 : return ZXDH_OK;
3966 : : }
3967 : :
3968 [ # # ]: 0 : switch (fun_type) {
3969 : 0 : case (ZXDH_FUN_HASH):
3970 [ # # ]: 0 : if (p_fun_info->fun_ptr) {
3971 : 0 : rte_free(p_fun_info->fun_ptr);
3972 : 0 : p_fun_info->fun_ptr = NULL;
3973 : : }
3974 : : break;
3975 : 0 : default:
3976 : 0 : PMD_DRV_LOG(ERR, " Error, unrecgnized fun_type[ %u] ", fun_type);
3977 : : RTE_ASSERT(0);
3978 : 0 : return ZXDH_SE_RC_BASE;
3979 : : }
3980 : :
3981 : 0 : p_fun_info->fun_id = id;
3982 : 0 : p_fun_info->is_used = 0;
3983 : :
3984 : 0 : return ZXDH_OK;
3985 : : }
3986 : :
3987 : : static uint32_t
3988 : 0 : zxdh_np_one_hash_soft_uninstall(uint32_t dev_id, uint32_t hash_id)
3989 : : {
3990 : : uint32_t rc = 0;
3991 : : uint32_t i = 0;
3992 : :
3993 : : ZXDH_D_NODE *p_node = NULL;
3994 : 0 : ZXDH_SE_CFG *p_se_cfg = dpp_se_cfg[dev_id];
3995 : : ZXDH_RB_TN *p_rb_tn = NULL;
3996 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
3997 : : HASH_DDR_CFG *p_rbkey = NULL;
3998 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
3999 : : ZXDH_FUNC_ID_INFO *p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, hash_id);
4000 : : ZXDH_D_HEAD *p_head_ddr_cfg_rb = NULL;
4001 : : HASH_DDR_CFG *p_temp_rbkey = NULL;
4002 : :
4003 [ # # ]: 0 : if (p_func_info->is_used == 0) {
4004 : 0 : PMD_DRV_LOG(ERR, "Error[0x%x], fun_id [%u] is not init!",
4005 : : ZXDH_SE_RC_FUN_INVALID, hash_id);
4006 : 0 : return ZXDH_OK;
4007 : : }
4008 : :
4009 : 0 : rc = zxdh_np_hash_soft_all_entry_delete(p_se_cfg, hash_id);
4010 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_soft_all_entry_delete");
4011 : :
4012 : 0 : p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
4013 [ # # ]: 0 : for (i = 0; i < ZXDH_HASH_BULK_NUM; i++) {
4014 [ # # ]: 0 : if (p_hash_cfg->hash_stat.p_bulk_zcam_mono[i] != NULL) {
4015 : 0 : rte_free((&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[i]);
4016 : 0 : (&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[i] = NULL;
4017 : : }
4018 : : }
4019 : :
4020 : : p_head_ddr_cfg_rb = &p_hash_cfg->ddr_cfg_rb.tn_list;
4021 [ # # ]: 0 : while (p_head_ddr_cfg_rb->used) {
4022 : 0 : p_node = p_head_ddr_cfg_rb->p_next;
4023 : :
4024 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
4025 : 0 : p_rbkey = p_rb_tn->p_key;
4026 : :
4027 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->ddr_cfg_rb, p_rbkey, &p_rb_tn_rtn);
4028 : :
4029 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL)
4030 : 0 : PMD_DRV_LOG(ERR, "ddr_cfg_rb delete key is not exist, key: 0x");
4031 : : else
4032 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_delete");
4033 : :
4034 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
4035 : 0 : p_temp_rbkey = (HASH_DDR_CFG *)(p_rb_tn_rtn->p_key);
4036 : 0 : rte_free(p_temp_rbkey->p_item_array);
4037 : 0 : p_temp_rbkey->p_item_array = NULL;
4038 : 0 : rte_free(p_temp_rbkey);
4039 : 0 : rte_free(p_rb_tn_rtn);
4040 : : }
4041 : :
4042 : 0 : rc = zxdh_np_hash_zcam_resource_deinit(p_hash_cfg);
4043 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_zcam_resource_deinit");
4044 : :
4045 : 0 : rc = zxdh_np_se_fun_deinit(p_se_cfg, (hash_id & 0xff), ZXDH_FUN_HASH);
4046 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_fun_deinit");
4047 : :
4048 : 0 : memset(g_tbl_id_info[dev_id][hash_id], 0,
4049 : : ZXDH_HASH_TBL_ID_NUM * sizeof(ZXDH_HASH_TBL_ID_INFO));
4050 : :
4051 : 0 : return rc;
4052 : : }
4053 : :
4054 : : static uint32_t
4055 : 0 : zxdh_np_hash_soft_uninstall(uint32_t dev_id)
4056 : : {
4057 : : uint32_t rc = ZXDH_OK;
4058 : : uint32_t hash_id = 0;
4059 : :
4060 [ # # ]: 0 : for (hash_id = 0; hash_id < ZXDH_HASH_FUNC_ID_NUM; hash_id++) {
4061 : 0 : rc = zxdh_np_one_hash_soft_uninstall(dev_id, hash_id);
4062 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_one_hash_soft_uninstall");
4063 : : }
4064 : :
4065 : 0 : return rc;
4066 : : }
4067 : :
4068 : : static uint32_t
4069 : 0 : zxdh_np_acl_cfg_get(uint32_t dev_id, ZXDH_ACL_CFG_EX_T **p_acl_cfg)
4070 : : {
4071 [ # # ]: 0 : if (g_p_acl_ex_cfg[dev_id] == NULL) {
4072 : 0 : PMD_DRV_LOG(ERR, "etcam_is not init!");
4073 : : RTE_ASSERT(0);
4074 : 0 : return ZXDH_ACL_RC_ETCAMID_NOT_INIT;
4075 : : }
4076 : :
4077 : 0 : *p_acl_cfg = g_p_acl_ex_cfg[dev_id];
4078 : :
4079 : 0 : return ZXDH_OK;
4080 : : }
4081 : :
4082 : : static uint32_t
4083 : 0 : zxdh_np_acl_res_destroy(uint32_t dev_id)
4084 : : {
4085 : : uint32_t table_id = 0;
4086 : : uint32_t as_enable = 0;
4087 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
4088 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
4089 : :
4090 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
4091 : :
4092 [ # # ]: 0 : if (!p_acl_cfg->acl_etcamids.is_valid) {
4093 : 0 : PMD_DRV_LOG(DEBUG, "etcam is not init!");
4094 : 0 : return ZXDH_OK;
4095 : : }
4096 : :
4097 [ # # ]: 0 : for (table_id = ZXDH_ACL_TBL_ID_MIN; table_id <= ZXDH_ACL_TBL_ID_MAX; table_id++) {
4098 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + table_id;
4099 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
4100 : 0 : PMD_DRV_LOG(DEBUG, "table_id[ %u ] is not used!", table_id);
4101 : 0 : continue;
4102 : : }
4103 : :
4104 : 0 : zxdh_comm_rb_destroy(&p_tbl_cfg->acl_rb);
4105 : :
4106 : 0 : as_enable = p_tbl_cfg->as_enable;
4107 [ # # ]: 0 : if (as_enable) {
4108 [ # # ]: 0 : if (p_tbl_cfg->as_rslt_buff) {
4109 : 0 : rte_free(p_tbl_cfg->as_rslt_buff);
4110 : 0 : p_tbl_cfg->as_rslt_buff = NULL;
4111 : : }
4112 : : }
4113 : :
4114 [ # # ]: 0 : if (p_tbl_cfg->block_array) {
4115 : 0 : rte_free(p_tbl_cfg->block_array);
4116 : 0 : p_tbl_cfg->block_array = NULL;
4117 : : }
4118 : :
4119 : 0 : p_tbl_cfg->is_used = 0;
4120 : : }
4121 : :
4122 : 0 : p_acl_cfg->acl_etcamids.is_valid = 0;
4123 : :
4124 : 0 : return ZXDH_OK;
4125 : : }
4126 : :
4127 : : int
4128 : 0 : zxdh_np_online_uninit(uint32_t dev_id,
4129 : : char *port_name,
4130 : : uint32_t queue_id)
4131 : : {
4132 : : uint32_t rc;
4133 : :
4134 : 0 : rc = zxdh_np_dtb_queue_release(dev_id, port_name, queue_id);
4135 [ # # ]: 0 : if (rc != 0)
4136 : 0 : PMD_DRV_LOG(ERR, "dtb release port name %s queue id %u", port_name, queue_id);
4137 : :
4138 : 0 : rc = zxdh_np_hash_soft_uninstall(dev_id);
4139 [ # # ]: 0 : if (rc != ZXDH_OK)
4140 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_hash_soft_uninstall error! ");
4141 : :
4142 : 0 : zxdh_np_acl_res_destroy(dev_id);
4143 : : zxdh_np_dtb_mgr_destroy(dev_id);
4144 : : zxdh_np_sdt_mgr_destroy(dev_id);
4145 : 0 : zxdh_np_dev_del(dev_id);
4146 : :
4147 : 0 : return 0;
4148 : : }
4149 : :
4150 : : static uint32_t
4151 : : zxdh_np_sdt_tbl_type_get(uint32_t dev_id, uint32_t sdt_no)
4152 : : {
4153 : 0 : return g_table_type[dev_id][sdt_no];
4154 : : }
4155 : :
4156 : :
4157 : : static const ZXDH_DTB_TABLE_T *
4158 : : zxdh_np_dtb_table_info_get(uint32_t table_type)
4159 : : {
4160 : : return &g_dpp_dtb_table_info[table_type];
4161 : : }
4162 : :
4163 : : static const ZXDH_DTB_TABLE_T *
4164 : : zxdh_np_dtb_dump_info_get(uint32_t up_type)
4165 : : {
4166 : : return &g_dpp_dtb_dump_info[up_type];
4167 : : }
4168 : :
4169 : : static uint32_t
4170 : 0 : zxdh_np_dtb_write_table_cmd(uint32_t dev_id,
4171 : : ZXDH_DTB_TABLE_INFO_E table_type,
4172 : : void *p_cmd_data,
4173 : : void *p_cmd_buff)
4174 : : {
4175 : : uint32_t field_cnt;
4176 : : const ZXDH_DTB_TABLE_T *p_table_info = NULL;
4177 : : const ZXDH_DTB_FIELD_T *p_field_info = NULL;
4178 : : uint32_t temp_data;
4179 : : uint32_t rc = 0;
4180 : :
4181 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_data);
4182 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_buff);
4183 : : p_table_info = zxdh_np_dtb_table_info_get(table_type);
4184 : 0 : p_field_info = p_table_info->p_fields;
4185 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_table_info);
4186 : :
4187 [ # # ]: 0 : for (field_cnt = 0; field_cnt < p_table_info->field_num; field_cnt++) {
4188 : 0 : temp_data = *((uint32_t *)p_cmd_data + field_cnt) &
4189 [ # # ]: 0 : zxdh_np_comm_get_bit_mask(p_field_info[field_cnt].len);
4190 : :
4191 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_cmd_buff,
4192 : : ZXDH_DTB_TABLE_CMD_SIZE_BIT,
4193 : : temp_data,
4194 : 0 : p_field_info[field_cnt].lsb_pos,
4195 : : p_field_info[field_cnt].len);
4196 : :
4197 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_comm_write_bits_ex");
4198 : : }
4199 : :
4200 : 0 : return rc;
4201 : : }
4202 : :
4203 : : static uint32_t
4204 : 0 : zxdh_np_dtb_write_dump_cmd(uint32_t dev_id,
4205 : : ZXDH_DTB_DUMP_INFO_E dump_type,
4206 : : void *p_cmd_data,
4207 : : void *p_cmd_buff)
4208 : : {
4209 : : uint32_t rc = ZXDH_OK;
4210 : : uint32_t field_cnt = 0;
4211 : : const ZXDH_DTB_TABLE_T *p_table_info = NULL;
4212 : : const ZXDH_DTB_FIELD_T *p_field_info = NULL;
4213 : : uint32_t temp_data = 0;
4214 : :
4215 : : p_table_info = zxdh_np_dtb_dump_info_get(dump_type);
4216 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_table_info);
4217 : 0 : p_field_info = p_table_info->p_fields;
4218 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_field_info);
4219 : :
4220 [ # # ]: 0 : for (field_cnt = 0; field_cnt < p_table_info->field_num; field_cnt++) {
4221 : 0 : temp_data = *((uint32_t *)p_cmd_data + field_cnt) &
4222 [ # # ]: 0 : zxdh_np_comm_get_bit_mask(p_field_info[field_cnt].len);
4223 : :
4224 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_cmd_buff,
4225 : : ZXDH_DTB_TABLE_CMD_SIZE_BIT,
4226 : : temp_data,
4227 : 0 : p_field_info[field_cnt].lsb_pos,
4228 : : p_field_info[field_cnt].len);
4229 : :
4230 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_comm_write_bits");
4231 : : }
4232 : :
4233 : 0 : return rc;
4234 : : }
4235 : :
4236 : : static uint32_t
4237 : 0 : zxdh_np_dtb_smmu0_write_entry_data(uint32_t dev_id,
4238 : : uint32_t mode,
4239 : : uint32_t addr,
4240 : : uint32_t *p_data,
4241 : : ZXDH_DTB_ENTRY_T *p_entry)
4242 : : {
4243 : 0 : ZXDH_DTB_ERAM_TABLE_FORM_T dtb_eram_form_info = {0};
4244 : : uint32_t rc = 0;
4245 : :
4246 : 0 : dtb_eram_form_info.valid = ZXDH_DTB_TABLE_VALID;
4247 : : dtb_eram_form_info.type_mode = ZXDH_DTB_TABLE_MODE_ERAM;
4248 : 0 : dtb_eram_form_info.data_mode = mode;
4249 : 0 : dtb_eram_form_info.cpu_wr = 1;
4250 : 0 : dtb_eram_form_info.addr = addr;
4251 : : dtb_eram_form_info.cpu_rd = 0;
4252 : : dtb_eram_form_info.cpu_rd_mode = 0;
4253 : :
4254 [ # # ]: 0 : if (ZXDH_ERAM128_OPR_128b == mode) {
4255 : 0 : p_entry->data_in_cmd_flag = 0;
4256 : 0 : p_entry->data_size = 128 / 8;
4257 : :
4258 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_128,
4259 : 0 : &dtb_eram_form_info, p_entry->cmd);
4260 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
4261 : :
4262 : 0 : memcpy(p_entry->data, p_data, 128 / 8);
4263 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_64b == mode) {
4264 : 0 : p_entry->data_in_cmd_flag = 1;
4265 : 0 : p_entry->data_size = 64 / 8;
4266 : 0 : dtb_eram_form_info.data_l = *(p_data + 1);
4267 : 0 : dtb_eram_form_info.data_h = *(p_data);
4268 : :
4269 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_64,
4270 : 0 : &dtb_eram_form_info, p_entry->cmd);
4271 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
4272 : :
4273 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_1b == mode) {
4274 : 0 : p_entry->data_in_cmd_flag = 1;
4275 : 0 : p_entry->data_size = 1;
4276 : 0 : dtb_eram_form_info.data_h = *(p_data);
4277 : :
4278 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_1,
4279 : 0 : &dtb_eram_form_info, p_entry->cmd);
4280 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
4281 : : }
4282 : :
4283 : 0 : return rc;
4284 : : }
4285 : :
4286 : : static uint32_t
4287 : 0 : zxdh_np_dtb_zcam_write_entry_data(uint32_t dev_id,
4288 : : uint32_t reg_sram_flag,
4289 : : uint32_t zgroup_id,
4290 : : uint32_t zblock_id,
4291 : : uint32_t zcell_id,
4292 : : uint32_t sram_addr,
4293 : : uint32_t mask,
4294 : : uint8_t *p_data,
4295 : : ZXDH_DTB_ENTRY_T *p_entry)
4296 : : {
4297 : : uint32_t rc = ZXDH_OK;
4298 : :
4299 : 0 : ZXDH_DTB_ZCAM_TABLE_FORM_T dtb_zcam_form_info = {
4300 : : .valid = 1,
4301 : : .type_mode = ZXDH_DTB_TABLE_MODE_ZCAM,
4302 : : .ram_reg_flag = reg_sram_flag,
4303 : : .zgroup_id = zgroup_id,
4304 : : .zblock_id = zblock_id,
4305 : : .zcell_id = zcell_id,
4306 : : .mask = mask,
4307 : 0 : .sram_addr = sram_addr & 0x1FF,
4308 : : };
4309 : :
4310 : 0 : p_entry->data_in_cmd_flag = 0;
4311 : 0 : p_entry->data_size = ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ZCAM_LEN_SIZE - 1);
4312 : :
4313 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ZCAM,
4314 : 0 : &dtb_zcam_form_info, p_entry->cmd);
4315 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_table_cmd");
4316 : :
4317 : 0 : memcpy(p_entry->data, p_data,
4318 : : ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ZCAM_LEN_SIZE - 1));
4319 : :
4320 : 0 : return rc;
4321 : : }
4322 : :
4323 : : static uint32_t
4324 : 0 : zxdh_np_dtb_se_alg_zcam_data_write(uint32_t dev_id,
4325 : : uint32_t addr,
4326 : : uint8_t *p_data,
4327 : : ZXDH_DTB_ENTRY_T *p_entry)
4328 : : {
4329 : : uint32_t rc = ZXDH_OK;
4330 : 0 : uint32_t reg_sram_flag = (addr >> 16) & 0x1;
4331 : 0 : uint32_t zgroup_id = (addr >> 14) & 0x3;
4332 : 0 : uint32_t zblock_id = (addr >> 11) & 0x7;
4333 : 0 : uint32_t zcell_id = (addr >> 9) & 0x3;
4334 : 0 : uint32_t mask = (addr >> 17) & 0xF;
4335 : 0 : uint32_t sram_addr = addr & 0x1FF;
4336 : :
4337 : 0 : rc = zxdh_np_dtb_zcam_write_entry_data(dev_id, reg_sram_flag, zgroup_id, zblock_id,
4338 : : zcell_id, sram_addr, mask, p_data, p_entry);
4339 : :
4340 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_zcam_write_entry_data");
4341 : :
4342 : 0 : return rc;
4343 : : }
4344 : :
4345 : : static uint32_t
4346 : 0 : zxdh_np_dtb_etcam_write_entry_data(uint32_t dev_id,
4347 : : uint32_t block_idx,
4348 : : uint32_t row_or_col_msk,
4349 : : uint32_t vben,
4350 : : uint32_t reg_tcam_flag,
4351 : : uint32_t flush,
4352 : : uint32_t rd_wr,
4353 : : uint32_t wr_mode,
4354 : : uint32_t data_or_mask,
4355 : : uint32_t ram_addr,
4356 : : uint32_t vbit,
4357 : : uint8_t *p_data,
4358 : : ZXDH_DTB_ENTRY_T *p_entry)
4359 : : {
4360 : : uint32_t rc = ZXDH_OK;
4361 : : uint32_t i = 0;
4362 : : uint32_t offset = 0;
4363 : : uint8_t *p_temp = NULL;
4364 : :
4365 : 0 : uint8_t buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
4366 : :
4367 : 0 : ZXDH_DTB_ETCAM_TABLE_FORM_T dtb_etcam_form_info = {
4368 : : .valid = 1,
4369 : : .type_mode = ZXDH_DTB_TABLE_MODE_ETCAM,
4370 : : .block_sel = block_idx,
4371 : : .init_en = 0,
4372 : : .row_or_col_msk = row_or_col_msk,
4373 : : .vben = vben,
4374 : : .reg_tcam_flag = reg_tcam_flag,
4375 : : .uload = flush,
4376 : : .rd_wr = rd_wr,
4377 : : .wr_mode = wr_mode,
4378 : : .data_or_mask = data_or_mask,
4379 : : .addr = ram_addr,
4380 : : .vbit = vbit,
4381 : : };
4382 : :
4383 : 0 : p_entry->data_in_cmd_flag = 0;
4384 : 0 : p_entry->data_size = ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ETCAM_LEN_SIZE - 1);
4385 : :
4386 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ETCAM,
4387 : 0 : &dtb_etcam_form_info, p_entry->cmd);
4388 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_table_cmd");
4389 : :
4390 : : p_temp = p_data;
4391 : :
4392 [ # # ]: 0 : for (i = 0; i < ZXDH_ETCAM_RAM_NUM; i++) {
4393 : 0 : offset = i * ((uint32_t)ZXDH_ETCAM_WIDTH_MIN / 8);
4394 : :
4395 [ # # ]: 0 : if ((wr_mode >> (ZXDH_ETCAM_RAM_NUM - 1 - i)) & 0x1) {
4396 : 0 : memcpy(buff + offset, p_temp, ZXDH_ETCAM_WIDTH_MIN / 8);
4397 : 0 : p_temp += ZXDH_ETCAM_WIDTH_MIN / 8;
4398 : : }
4399 : : }
4400 : :
4401 : : zxdh_np_comm_swap((uint8_t *)buff, ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ETCAM_LEN_SIZE - 1));
4402 : :
4403 : 0 : memcpy(p_entry->data, buff,
4404 : : ZXDH_DTB_LEN_POS_SETP * (ZXDH_DTB_ETCAM_LEN_SIZE - 1));
4405 : :
4406 : 0 : return rc;
4407 : : }
4408 : :
4409 : : static uint32_t
4410 : 0 : zxdh_np_dtb_smmu0_dump_info_write(uint32_t dev_id,
4411 : : uint32_t base_addr,
4412 : : uint32_t depth,
4413 : : uint32_t addr_high32,
4414 : : uint32_t addr_low32,
4415 : : uint32_t *p_dump_info)
4416 : : {
4417 : : uint32_t rc = ZXDH_OK;
4418 : :
4419 : 0 : ZXDH_DTB_ERAM_DUMP_FORM_T dtb_eram_dump_form_info = {
4420 : : .valid = 1,
4421 : : .up_type = ZXDH_DTB_DUMP_MODE_ERAM,
4422 : : .base_addr = base_addr,
4423 : : .tb_depth = depth,
4424 : : .tb_dst_addr_h = addr_high32,
4425 : : .tb_dst_addr_l = addr_low32,
4426 : : };
4427 : :
4428 : 0 : PMD_DRV_LOG(DEBUG, "valid: %u", dtb_eram_dump_form_info.valid);
4429 : 0 : PMD_DRV_LOG(DEBUG, "up_type: %u", dtb_eram_dump_form_info.up_type);
4430 : 0 : PMD_DRV_LOG(DEBUG, "base_addr: 0x%x", dtb_eram_dump_form_info.base_addr);
4431 : 0 : PMD_DRV_LOG(DEBUG, "tb_depth: %u", dtb_eram_dump_form_info.tb_depth);
4432 : 0 : PMD_DRV_LOG(DEBUG, "tb_dst_addr_h: 0x%x", dtb_eram_dump_form_info.tb_dst_addr_h);
4433 : 0 : PMD_DRV_LOG(DEBUG, "tb_dst_addr_l: 0x%x", dtb_eram_dump_form_info.tb_dst_addr_l);
4434 : :
4435 : 0 : rc = zxdh_np_dtb_write_dump_cmd(dev_id, ZXDH_DTB_DUMP_ERAM,
4436 : : &dtb_eram_dump_form_info, p_dump_info);
4437 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_cmd");
4438 : :
4439 : 0 : return rc;
4440 : : }
4441 : :
4442 : : static uint32_t
4443 : 0 : zxdh_np_dtb_zcam_dump_info_write(uint32_t dev_id,
4444 : : uint32_t addr,
4445 : : uint32_t tb_width,
4446 : : uint32_t depth,
4447 : : uint32_t addr_high32,
4448 : : uint32_t addr_low32,
4449 : : uint32_t *p_dump_info)
4450 : : {
4451 : : uint32_t rc = ZXDH_OK;
4452 : :
4453 : 0 : ZXDH_DTB_ZCAM_DUMP_FORM_T dtb_zcam_dump_form_info = {
4454 : : .valid = 1,
4455 : : .up_type = ZXDH_DTB_DUMP_MODE_ZCAM,
4456 : : .tb_width = tb_width,
4457 : 0 : .sram_addr = addr & 0x1FF,
4458 : 0 : .ram_reg_flag = (addr >> 16) & 0x1,
4459 : 0 : .z_reg_cell_id = (addr >> 9) & 0x3,
4460 : 0 : .zblock_id = (addr >> 11) & 0x7,
4461 : 0 : .zgroup_id = (addr >> 14) & 0x3,
4462 : : .tb_depth = depth,
4463 : : .tb_dst_addr_h = addr_high32,
4464 : : .tb_dst_addr_l = addr_low32,
4465 : : };
4466 : :
4467 : 0 : rc = zxdh_np_dtb_write_dump_cmd(dev_id, ZXDH_DTB_DUMP_ZCAM,
4468 : : &dtb_zcam_dump_form_info, p_dump_info);
4469 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_cmd");
4470 : :
4471 : 0 : return rc;
4472 : : }
4473 : :
4474 : : static uint32_t
4475 : 0 : zxdh_np_dtb_etcam_dump_info_write(uint32_t dev_id,
4476 : : ZXDH_ETCAM_DUMP_INFO_T *p_etcam_dump_info,
4477 : : uint32_t addr_high32,
4478 : : uint32_t addr_low32,
4479 : : uint32_t *p_dump_info)
4480 : : {
4481 : : uint32_t rc = ZXDH_OK;
4482 : :
4483 : 0 : ZXDH_DTB_ETCAM_DUMP_FORM_T dtb_etcam_dump_form_info = {
4484 : : .valid = 1,
4485 : : .up_type = ZXDH_DTB_DUMP_MODE_ETCAM,
4486 : 0 : .block_sel = p_etcam_dump_info->block_sel,
4487 : 0 : .addr = p_etcam_dump_info->addr,
4488 : 0 : .rd_mode = p_etcam_dump_info->rd_mode,
4489 : 0 : .data_or_mask = p_etcam_dump_info->data_or_mask,
4490 : 0 : .tb_depth = p_etcam_dump_info->tb_depth,
4491 : 0 : .tb_width = p_etcam_dump_info->tb_width,
4492 : : .tb_dst_addr_h = addr_high32,
4493 : : .tb_dst_addr_l = addr_low32,
4494 : : };
4495 : :
4496 : 0 : rc = zxdh_np_dtb_write_dump_cmd(dev_id, ZXDH_DTB_DUMP_ETCAM,
4497 : : &dtb_etcam_dump_form_info, p_dump_info);
4498 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_cmd");
4499 : :
4500 : 0 : return rc;
4501 : : }
4502 : :
4503 : : static void
4504 : : zxdh_np_dtb_zcam_dump_entry(uint32_t dev_id,
4505 : : uint32_t addr,
4506 : : uint32_t tb_width,
4507 : : uint32_t depth,
4508 : : uint32_t addr_high32,
4509 : : uint32_t addr_low32,
4510 : : ZXDH_DTB_ENTRY_T *p_entry)
4511 : : {
4512 : 0 : zxdh_np_dtb_zcam_dump_info_write(dev_id,
4513 : : addr,
4514 : : tb_width,
4515 : : depth,
4516 : : addr_high32,
4517 : : addr_low32,
4518 : 0 : (uint32_t *)p_entry->cmd);
4519 : 0 : p_entry->data_in_cmd_flag = 1;
4520 : : }
4521 : :
4522 : : static void
4523 : 0 : zxdh_np_dtb_smmu0_dump_entry(uint32_t dev_id,
4524 : : uint32_t base_addr,
4525 : : uint32_t depth,
4526 : : uint32_t addr_high32,
4527 : : uint32_t addr_low32,
4528 : : ZXDH_DTB_ENTRY_T *p_entry)
4529 : : {
4530 : 0 : zxdh_np_dtb_smmu0_dump_info_write(dev_id,
4531 : : base_addr,
4532 : : depth,
4533 : : addr_high32,
4534 : : addr_low32,
4535 : 0 : (uint32_t *)p_entry->cmd);
4536 : 0 : p_entry->data_in_cmd_flag = 1;
4537 : 0 : }
4538 : :
4539 : : static void
4540 : : zxdh_np_dtb_etcam_dump_entry(uint32_t dev_id,
4541 : : ZXDH_ETCAM_DUMP_INFO_T *p_etcam_dump_info,
4542 : : uint32_t addr_high32,
4543 : : uint32_t addr_low32,
4544 : : ZXDH_DTB_ENTRY_T *p_entry)
4545 : : {
4546 : 0 : zxdh_np_dtb_etcam_dump_info_write(dev_id,
4547 : : p_etcam_dump_info,
4548 : : addr_high32,
4549 : : addr_low32,
4550 : 0 : (uint32_t *)p_entry->cmd);
4551 : 0 : p_entry->data_in_cmd_flag = 1;
4552 : : }
4553 : :
4554 : : static uint32_t
4555 : 0 : zxdh_np_dtb_se_smmu0_ind_write(uint32_t dev_id,
4556 : : uint32_t base_addr,
4557 : : uint32_t index,
4558 : : uint32_t wrt_mode,
4559 : : uint32_t *p_data,
4560 : : ZXDH_DTB_ENTRY_T *p_entry)
4561 : : {
4562 : : uint32_t temp_idx = 0;
4563 : : uint32_t dtb_ind_addr;
4564 : : uint32_t rc = 0;
4565 : :
4566 [ # # # # ]: 0 : switch (wrt_mode) {
4567 : 0 : case ZXDH_ERAM128_OPR_128b:
4568 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
4569 : 0 : PMD_DRV_LOG(ERR, "base addr:0x%x, index:0x%x invalid", base_addr, index);
4570 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
4571 : : }
4572 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
4573 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
4574 : 0 : return 1;
4575 : : }
4576 : 0 : temp_idx = index << 7;
4577 : 0 : break;
4578 : 0 : case ZXDH_ERAM128_OPR_64b:
4579 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
4580 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
4581 : 0 : return 1;
4582 : : }
4583 : 0 : temp_idx = index << 6;
4584 : 0 : break;
4585 : 0 : case ZXDH_ERAM128_OPR_1b:
4586 [ # # ]: 0 : if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
4587 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
4588 : 0 : return 1;
4589 : : }
4590 : :
4591 : : temp_idx = index;
4592 : : break;
4593 : : default:
4594 : : break;
4595 : : }
4596 : :
4597 : 0 : dtb_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + temp_idx;
4598 : :
4599 : 0 : PMD_DRV_LOG(DEBUG, "dtb eram item 1bit addr: 0x%x", dtb_ind_addr);
4600 : :
4601 : 0 : rc = zxdh_np_dtb_smmu0_write_entry_data(dev_id,
4602 : : wrt_mode,
4603 : : dtb_ind_addr,
4604 : : p_data,
4605 : : p_entry);
4606 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_smmu0_write_entry_data");
4607 : :
4608 : : return rc;
4609 : : }
4610 : :
4611 : : static uint32_t
4612 : : zxdh_np_eram_dtb_len_get(uint32_t mode)
4613 : : {
4614 : : uint32_t dtb_len = 0;
4615 : :
4616 [ # # # ]: 0 : switch (mode) {
4617 : 0 : case ZXDH_ERAM128_OPR_128b:
4618 : : dtb_len += 2;
4619 : 0 : break;
4620 : 0 : case ZXDH_ERAM128_OPR_64b:
4621 : : case ZXDH_ERAM128_OPR_1b:
4622 : : dtb_len += 1;
4623 : 0 : break;
4624 : : default:
4625 : : break;
4626 : : }
4627 : :
4628 : : return dtb_len;
4629 : : }
4630 : :
4631 : : static void
4632 : : zxdh_np_sdt_tbl_data_get(uint32_t dev_id, uint32_t sdt_no, ZXDH_SDT_TBL_DATA_T *p_sdt_data)
4633 : : {
4634 : 0 : p_sdt_data->data_high32 = g_sdt_info[dev_id][sdt_no].data_high32;
4635 : 0 : p_sdt_data->data_low32 = g_sdt_info[dev_id][sdt_no].data_low32;
4636 : : }
4637 : :
4638 : : static uint32_t
4639 : 0 : zxdh_np_sdt_tbl_data_parser(uint32_t sdt_hig32, uint32_t sdt_low32, void *p_sdt_info)
4640 : : {
4641 : : uint32_t tbl_type = 0;
4642 : : uint32_t clutch_en = 0;
4643 : : uint32_t tmp = 0;
4644 : :
4645 : : ZXDH_SDT_TBL_ERAM_T *p_sdt_eram = NULL;
4646 : : ZXDH_SDT_TBL_HASH_T *p_sdt_hash = NULL;
4647 : : ZXDH_SDT_TBL_ETCAM_T *p_sdt_etcam = NULL;
4648 : : ZXDH_SDT_TBL_PORTTBL_T *p_sdt_porttbl = NULL;
4649 : :
4650 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_hig32,
4651 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
4652 : 0 : ZXDH_COMM_UINT32_GET_BITS(clutch_en, sdt_low32, 0, 1);
4653 : :
4654 [ # # # # : 0 : switch (tbl_type) {
# ]
4655 : 0 : case ZXDH_SDT_TBLT_ERAM:
4656 : : p_sdt_eram = (ZXDH_SDT_TBL_ERAM_T *)p_sdt_info;
4657 : 0 : p_sdt_eram->table_type = tbl_type;
4658 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_eram->eram_mode, sdt_hig32,
4659 : : ZXDH_SDT_H_ERAM_MODE_BT_POS, ZXDH_SDT_H_ERAM_MODE_BT_LEN);
4660 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_eram->eram_base_addr, sdt_hig32,
4661 : : ZXDH_SDT_H_ERAM_BASE_ADDR_BT_POS, ZXDH_SDT_H_ERAM_BASE_ADDR_BT_LEN);
4662 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_eram->eram_table_depth, sdt_low32,
4663 : : ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_POS, ZXDH_SDT_L_ERAM_TABLE_DEPTH_BT_LEN);
4664 : 0 : p_sdt_eram->eram_clutch_en = clutch_en;
4665 : 0 : break;
4666 : 0 : case ZXDH_SDT_TBLT_HASH:
4667 : : p_sdt_hash = (ZXDH_SDT_TBL_HASH_T *)p_sdt_info;
4668 : 0 : p_sdt_hash->table_type = tbl_type;
4669 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->hash_id, sdt_hig32,
4670 : : ZXDH_SDT_H_HASH_ID_BT_POS, ZXDH_SDT_H_HASH_ID_BT_LEN);
4671 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->hash_table_width, sdt_hig32,
4672 : : ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_POS, ZXDH_SDT_H_HASH_TABLE_WIDTH_BT_LEN);
4673 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->key_size, sdt_hig32,
4674 : : ZXDH_SDT_H_HASH_KEY_SIZE_BT_POS, ZXDH_SDT_H_HASH_KEY_SIZE_BT_LEN);
4675 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->hash_table_id, sdt_hig32,
4676 : : ZXDH_SDT_H_HASH_TABLE_ID_BT_POS, ZXDH_SDT_H_HASH_TABLE_ID_BT_LEN);
4677 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->learn_en, sdt_hig32,
4678 : : ZXDH_SDT_H_LEARN_EN_BT_POS, ZXDH_SDT_H_LEARN_EN_BT_LEN);
4679 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->keep_alive, sdt_hig32,
4680 : : ZXDH_SDT_H_KEEP_ALIVE_BT_POS, ZXDH_SDT_H_KEEP_ALIVE_BT_LEN);
4681 : : ZXDH_COMM_UINT32_GET_BITS(tmp, sdt_hig32,
4682 : : ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_POS, ZXDH_SDT_H_KEEP_ALIVE_BADDR_BT_LEN);
4683 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->keep_alive_baddr, sdt_low32,
4684 : : ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_POS, ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN);
4685 : 0 : p_sdt_hash->keep_alive_baddr += (tmp << ZXDH_SDT_L_KEEP_ALIVE_BADDR_BT_LEN);
4686 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_hash->rsp_mode, sdt_low32,
4687 : : ZXDH_SDT_L_RSP_MODE_BT_POS, ZXDH_SDT_L_RSP_MODE_BT_LEN);
4688 : 0 : p_sdt_hash->hash_clutch_en = clutch_en;
4689 : 0 : break;
4690 : :
4691 : 0 : case ZXDH_SDT_TBLT_ETCAM:
4692 : : p_sdt_etcam = (ZXDH_SDT_TBL_ETCAM_T *)p_sdt_info;
4693 : 0 : p_sdt_etcam->table_type = tbl_type;
4694 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_id, sdt_hig32,
4695 : : ZXDH_SDT_H_ETCAM_ID_BT_POS, ZXDH_SDT_H_ETCAM_ID_BT_LEN);
4696 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_key_mode, sdt_hig32,
4697 : : ZXDH_SDT_H_ETCAM_KEY_MODE_BT_POS, ZXDH_SDT_H_ETCAM_KEY_MODE_BT_LEN);
4698 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_table_id, sdt_hig32,
4699 : : ZXDH_SDT_H_ETCAM_TABLE_ID_BT_POS, ZXDH_SDT_H_ETCAM_TABLE_ID_BT_LEN);
4700 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->no_as_rsp_mode, sdt_hig32,
4701 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_POS,
4702 : : ZXDH_SDT_H_ETCAM_NOAS_RSP_MODE_BT_LEN);
4703 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->as_en, sdt_hig32,
4704 : : ZXDH_SDT_H_ETCAM_AS_EN_BT_POS, ZXDH_SDT_H_ETCAM_AS_EN_BT_LEN);
4705 : : ZXDH_COMM_UINT32_GET_BITS(tmp, sdt_hig32, ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_POS,
4706 : : ZXDH_SDT_H_ETCAM_AS_ERAM_BADDR_BT_LEN);
4707 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->as_eram_baddr, sdt_low32,
4708 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_POS,
4709 : : ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN);
4710 : 0 : p_sdt_etcam->as_eram_baddr += (tmp << ZXDH_SDT_L_ETCAM_AS_ERAM_BADDR_BT_LEN);
4711 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->as_rsp_mode, sdt_low32,
4712 : : ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_POS, ZXDH_SDT_L_ETCAM_AS_RSP_MODE_BT_LEN);
4713 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_sdt_etcam->etcam_table_depth, sdt_low32,
4714 : : ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_POS, ZXDH_SDT_L_ETCAM_TABLE_DEPTH_BT_LEN);
4715 : 0 : p_sdt_etcam->etcam_clutch_en = clutch_en;
4716 : 0 : break;
4717 : :
4718 : 0 : case ZXDH_SDT_TBLT_PORTTBL:
4719 : : p_sdt_porttbl = (ZXDH_SDT_TBL_PORTTBL_T *)p_sdt_info;
4720 : 0 : p_sdt_porttbl->table_type = tbl_type;
4721 : 0 : p_sdt_porttbl->porttbl_clutch_en = clutch_en;
4722 : 0 : break;
4723 : 0 : default:
4724 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
4725 : 0 : return 1;
4726 : : }
4727 : :
4728 : : return 0;
4729 : : }
4730 : :
4731 : : static uint32_t
4732 : 0 : zxdh_np_soft_sdt_tbl_get(uint32_t dev_id, uint32_t sdt_no, void *p_sdt_info)
4733 : : {
4734 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
4735 : : uint32_t rc;
4736 : :
4737 [ # # ]: 0 : if (sdt_no > ZXDH_DEV_SDT_ID_MAX - 1) {
4738 : 0 : PMD_DRV_LOG(ERR, "SDT NO [ %u ] is invalid!", sdt_no);
4739 : 0 : return ZXDH_PAR_CHK_INVALID_PARA;
4740 : : }
4741 : :
4742 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
4743 : :
4744 : 0 : rc = zxdh_np_sdt_tbl_data_parser(sdt_tbl.data_high32, sdt_tbl.data_low32, p_sdt_info);
4745 [ # # ]: 0 : if (rc != 0)
4746 : 0 : PMD_DRV_LOG(ERR, "dpp sdt [%u] tbl_data_parser error.", sdt_no);
4747 : :
4748 : : return rc;
4749 : : }
4750 : :
4751 : : static uint32_t
4752 : 0 : zxdh_np_dtb_eram_one_entry(uint32_t dev_id,
4753 : : uint32_t sdt_no,
4754 : : uint32_t del_en,
4755 : : void *pdata,
4756 : : uint32_t *p_dtb_len,
4757 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
4758 : : {
4759 : 0 : uint32_t buff[ZXDH_SMMU0_READ_REG_MAX_NUM] = {0};
4760 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram = {0};
4761 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *peramdata = NULL;
4762 : : uint32_t base_addr;
4763 : : uint32_t index;
4764 : : uint32_t opr_mode;
4765 : : uint32_t rc = ZXDH_OK;
4766 : :
4767 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(pdata);
4768 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_one_entry);
4769 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_len);
4770 : :
4771 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
4772 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram);
4773 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_soft_sdt_tbl_get");
4774 : :
4775 : : peramdata = (ZXDH_DTB_ERAM_ENTRY_INFO_T *)pdata;
4776 : 0 : index = peramdata->index;
4777 : 0 : base_addr = sdt_eram.eram_base_addr;
4778 : 0 : opr_mode = sdt_eram.eram_mode;
4779 : :
4780 [ # # # # ]: 0 : switch (opr_mode) {
4781 : 0 : case ZXDH_ERAM128_TBL_128b:
4782 : : opr_mode = ZXDH_ERAM128_OPR_128b;
4783 : 0 : break;
4784 : 0 : case ZXDH_ERAM128_TBL_64b:
4785 : : opr_mode = ZXDH_ERAM128_OPR_64b;
4786 : 0 : break;
4787 : 0 : case ZXDH_ERAM128_TBL_1b:
4788 : : opr_mode = ZXDH_ERAM128_OPR_1b;
4789 : 0 : break;
4790 : : default:
4791 : : break;
4792 : : }
4793 : :
4794 : 0 : PMD_DRV_LOG(DEBUG, "std no:0x%x, index:0x%x, base addr:0x%x", sdt_no, index, base_addr);
4795 [ # # ]: 0 : if (opr_mode == ZXDH_ERAM128_OPR_128b)
4796 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x 0x%08x 0x%08x]",
4797 : : peramdata->p_data[0], peramdata->p_data[1],
4798 : : peramdata->p_data[2], peramdata->p_data[3]);
4799 [ # # ]: 0 : else if (opr_mode == ZXDH_ERAM128_OPR_64b)
4800 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x]",
4801 : : peramdata->p_data[0], peramdata->p_data[1]);
4802 : :
4803 [ # # ]: 0 : if (del_en) {
4804 : : memset((uint8_t *)buff, 0, sizeof(buff));
4805 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
4806 : : base_addr,
4807 : : index,
4808 : : opr_mode,
4809 : : buff,
4810 : : p_dtb_one_entry);
4811 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(sdt_no, rc, "zxdh_dtb_se_smmu0_ind_write");
4812 : : } else {
4813 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
4814 : : base_addr,
4815 : : index,
4816 : : opr_mode,
4817 : : peramdata->p_data,
4818 : : p_dtb_one_entry);
4819 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_dtb_se_smmu0_ind_write");
4820 : : }
4821 : 0 : *p_dtb_len = zxdh_np_eram_dtb_len_get(opr_mode);
4822 : :
4823 : 0 : return rc;
4824 : : }
4825 : :
4826 : : static uint32_t
4827 : 0 : zxdh_np_dtb_data_write(uint8_t *p_data_buff,
4828 : : uint32_t addr_offset,
4829 : : ZXDH_DTB_ENTRY_T *entry)
4830 : : {
4831 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
4832 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(entry);
4833 : :
4834 : 0 : uint8_t *p_cmd = p_data_buff + addr_offset;
4835 : : uint32_t cmd_size = ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8;
4836 : :
4837 : 0 : uint8_t *p_data = p_cmd + cmd_size;
4838 : 0 : uint32_t data_size = entry->data_size;
4839 : :
4840 : 0 : uint8_t *cmd = (uint8_t *)entry->cmd;
4841 [ # # ]: 0 : uint8_t *data = (uint8_t *)entry->data;
4842 : :
4843 : : memcpy(p_cmd, cmd, cmd_size);
4844 : :
4845 [ # # ]: 0 : if (!entry->data_in_cmd_flag) {
4846 : 0 : zxdh_np_comm_swap(data, data_size);
4847 : 0 : memcpy(p_data, data, data_size);
4848 : : }
4849 : :
4850 : 0 : return 0;
4851 : : }
4852 : :
4853 : : static uint32_t
4854 : 0 : zxdh_np_dtb_queue_enable_get(uint32_t dev_id,
4855 : : uint32_t queue_id,
4856 : : uint32_t *enable)
4857 : : {
4858 : : uint32_t rc = 0;
4859 : 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
4860 : :
4861 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
4862 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_vm_info_get");
4863 : :
4864 : 0 : *enable = vm_info.queue_en;
4865 : 0 : return rc;
4866 : : }
4867 : :
4868 : : static uint32_t
4869 : 0 : zxdh_np_dtb_item_buff_wr(uint32_t dev_id,
4870 : : uint32_t queue_id,
4871 : : uint32_t dir_flag,
4872 : : uint32_t index,
4873 : : uint32_t pos,
4874 : : uint32_t len,
4875 : : uint32_t *p_data)
4876 : : {
4877 : : uint64_t addr;
4878 : :
4879 [ # # ]: 0 : if (dir_flag == 1)
4880 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) +
4881 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
4882 : : else
4883 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) +
4884 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
4885 : :
4886 : 0 : memcpy((uint8_t *)(addr), p_data, len * 4);
4887 : :
4888 : 0 : return 0;
4889 : : }
4890 : :
4891 : : static uint32_t
4892 : 0 : zxdh_np_dtb_item_ack_rd(uint32_t dev_id,
4893 : : uint32_t queue_id,
4894 : : uint32_t dir_flag,
4895 : : uint32_t index,
4896 : : uint32_t pos,
4897 : : uint32_t *p_data)
4898 : : {
4899 : : uint64_t addr;
4900 : : uint32_t val;
4901 : :
4902 [ # # ]: 0 : if (dir_flag == 1)
4903 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
4904 : : else
4905 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
4906 : :
4907 : 0 : val = *((volatile uint32_t *)(addr));
4908 : :
4909 : : if (!zxdh_np_comm_is_big_endian())
4910 : : val = ZXDH_COMM_CONVERT32(val);
4911 : :
4912 : 0 : *p_data = val;
4913 : :
4914 : 0 : return 0;
4915 : : }
4916 : :
4917 : : static uint32_t
4918 : : zxdh_np_dtb_item_ack_wr(uint32_t dev_id,
4919 : : uint32_t queue_id,
4920 : : uint32_t dir_flag,
4921 : : uint32_t index,
4922 : : uint32_t pos,
4923 : : uint32_t data)
4924 : : {
4925 : : uint64_t addr;
4926 : :
4927 : : if (dir_flag == 1)
4928 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
4929 : : else
4930 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
4931 : :
4932 : : if (!zxdh_np_comm_is_big_endian())
4933 : : data = ZXDH_COMM_CONVERT32(data);
4934 : :
4935 : 0 : *((volatile uint32_t *)addr) = data;
4936 : :
4937 : 0 : return 0;
4938 : : }
4939 : :
4940 : : static uint32_t
4941 : 0 : zxdh_np_dtb_item_ack_prt(uint32_t dev_id,
4942 : : uint32_t queue_id,
4943 : : uint32_t dir_flag,
4944 : : uint32_t index)
4945 : : {
4946 : : uint32_t rc = 0;
4947 : : uint32_t i = 0;
4948 : 0 : uint32_t ack_data[4] = {0};
4949 : :
4950 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_ITEM_ACK_SIZE / 4; i++) {
4951 : 0 : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, dir_flag, index, i, ack_data + i);
4952 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_rd");
4953 : : }
4954 : :
4955 : 0 : PMD_DRV_LOG(DEBUG, "[%s] BD INFO:", g_dpp_dtb_name[dir_flag]);
4956 : 0 : PMD_DRV_LOG(DEBUG, "[index : %u] : 0x%08x 0x%08x 0x%08x 0x%08x", index,
4957 : : ack_data[0], ack_data[1], ack_data[2], ack_data[3]);
4958 : :
4959 : 0 : return rc;
4960 : : }
4961 : :
4962 : : static uint32_t
4963 : 0 : zxdh_np_dtb_item_buff_rd(uint32_t dev_id,
4964 : : uint32_t queue_id,
4965 : : uint32_t dir_flag,
4966 : : uint32_t index,
4967 : : uint32_t pos,
4968 : : uint32_t len,
4969 : : uint32_t *p_data)
4970 : : {
4971 : : uint64_t addr = 0;
4972 : :
4973 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
4974 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
4975 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
4976 : : }
4977 : :
4978 [ # # ]: 0 : if (dir_flag == ZXDH_DTB_DIR_UP_TYPE) {
4979 [ # # ]: 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, index) ==
4980 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE) {
4981 : 0 : addr = ZXDH_DTB_TAB_UP_USER_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
4982 : 0 : ZXDH_DTB_TAB_UP_USER_ADDR_FLAG_SET(dev_id, queue_id, index, 0);
4983 : : } else {
4984 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) +
4985 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
4986 : : }
4987 : : } else {
4988 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) +
4989 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
4990 : : }
4991 : :
4992 : 0 : memcpy(p_data, (uint8_t *)(addr), len * 4);
4993 : :
4994 : 0 : zxdh_np_comm_swap((uint8_t *)p_data, len * 4);
4995 : :
4996 : 0 : return ZXDH_OK;
4997 : : }
4998 : :
4999 : : static uint32_t
5000 : 0 : zxdh_np_dtb_item_buff_prt(uint32_t dev_id,
5001 : : uint32_t queue_id,
5002 : : uint32_t dir_flag,
5003 : : uint32_t index,
5004 : : uint32_t len)
5005 : : {
5006 : : uint32_t rc = 0;
5007 : : uint32_t i = 0;
5008 : : uint32_t j = 0;
5009 : : uint32_t *p_item_buff = NULL;
5010 : :
5011 : 0 : p_item_buff = rte_zmalloc(NULL, len * sizeof(uint32_t), 0);
5012 [ # # ]: 0 : if (p_item_buff == NULL) {
5013 : 0 : PMD_DRV_LOG(ERR, "Alloc dtb item buffer failed!!!");
5014 : 0 : return ZXDH_RC_DTB_MEMORY_ALLOC_ERR;
5015 : : }
5016 : :
5017 : 0 : zxdh_np_dtb_item_buff_rd(dev_id, queue_id, dir_flag, index, 0, len, p_item_buff);
5018 : :
5019 : 0 : PMD_DRV_LOG(DEBUG, "[%s] BUFF INFO:", g_dpp_dtb_name[dir_flag]);
5020 [ # # ]: 0 : for (i = 0, j = 0; i < len; i++, j++) {
5021 [ # # ]: 0 : if (j % 4 == 0)
5022 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", (*(p_item_buff + i)));
5023 : : else
5024 : 0 : PMD_DRV_LOG(DEBUG, "0x%08x ", (*(p_item_buff + i)));
5025 : : }
5026 : :
5027 : 0 : rte_free(p_item_buff);
5028 : :
5029 : 0 : return rc;
5030 : : }
5031 : :
5032 : : static uint32_t
5033 : 0 : zxdh_np_dtb_queue_item_info_set(uint32_t dev_id,
5034 : : uint32_t queue_id,
5035 : : ZXDH_DTB_QUEUE_ITEM_INFO_T *p_item_info)
5036 : : {
5037 : : uint32_t rc;
5038 : :
5039 : : uint32_t dtb_addr_h_reg = ZXDH_SYS_DTB_BASE_ADDR +
5040 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0000;
5041 : : uint32_t dtb_addr_l_reg = ZXDH_SYS_DTB_BASE_ADDR +
5042 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0004;
5043 : : uint32_t dtb_len_reg = ZXDH_SYS_DTB_BASE_ADDR +
5044 : : ZXDH_MODULE_DTB_ENQ_BASE_ADDR + 0x0008;
5045 : 0 : uint32_t dtb_len = 0;
5046 : :
5047 : 0 : rc = zxdh_np_dev_write_channel(dev_id, dtb_addr_h_reg + queue_id * 32,
5048 : : 1, &p_item_info->data_hddr);
5049 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_write_channel Fail");
5050 : 0 : rc = zxdh_np_dev_write_channel(dev_id, dtb_addr_l_reg + queue_id * 32,
5051 : : 1, &p_item_info->data_laddr);
5052 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_write_channel Fail");
5053 : 0 : dtb_len = ZXDH_DTB_LEN(p_item_info->cmd_type, p_item_info->int_en, p_item_info->data_len);
5054 : 0 : rc = zxdh_np_dev_write_channel(dev_id, dtb_len_reg + queue_id * 32, 1, &dtb_len);
5055 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_write_channel Fail");
5056 : :
5057 : 0 : return rc;
5058 : : }
5059 : :
5060 : : static uint32_t
5061 : 0 : zxdh_np_dtb_tab_down_info_set(uint32_t dev_id,
5062 : : uint32_t queue_id,
5063 : : uint32_t int_flag,
5064 : : uint32_t data_len,
5065 : : uint32_t *p_data,
5066 : : uint32_t *p_item_index)
5067 : : {
5068 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
5069 : 0 : uint32_t unused_item_num = 0;
5070 : 0 : uint32_t queue_en = 0;
5071 : : uint32_t ack_vale = 0;
5072 : : uint64_t phy_addr;
5073 : : uint32_t item_index;
5074 : : uint32_t i;
5075 : : uint32_t rc;
5076 : : ZXDH_SPINLOCK_T *p_spinlock = NULL;
5077 : :
5078 : : zxdh_np_dev_dtb_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_DTB, queue_id, &p_spinlock);
5079 : 0 : rte_spinlock_lock(&p_spinlock->spinlock);
5080 : :
5081 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
5082 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
5083 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5084 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
5085 : : }
5086 : :
5087 [ # # ]: 0 : if (data_len % 4 != 0) {
5088 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5089 : 0 : return ZXDH_RC_DTB_PARA_INVALID;
5090 : : }
5091 : :
5092 : 0 : rc = zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
5093 [ # # ]: 0 : if (!queue_en) {
5094 : 0 : PMD_DRV_LOG(ERR, "the queue %u is not enable!,rc=%u", queue_id, rc);
5095 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5096 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
5097 : : }
5098 : :
5099 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
5100 [ # # ]: 0 : if (unused_item_num == 0) {
5101 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5102 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
5103 : : }
5104 : :
5105 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
5106 : 0 : item_index = ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id) %
5107 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
5108 : :
5109 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, 0,
5110 : : item_index, 0, &ack_vale);
5111 : :
5112 : 0 : ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id)++;
5113 : :
5114 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
5115 : : break;
5116 : : }
5117 : :
5118 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX) {
5119 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5120 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
5121 : : }
5122 : :
5123 : : rc = zxdh_np_dtb_item_buff_wr(dev_id, queue_id, 0,
5124 : : item_index, 0, data_len, p_data);
5125 : :
5126 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, 0,
5127 : : item_index, 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
5128 : :
5129 : 0 : item_info.cmd_vld = 1;
5130 : 0 : item_info.cmd_type = 0;
5131 : 0 : item_info.int_en = int_flag;
5132 : 0 : item_info.data_len = data_len / 4;
5133 : 0 : phy_addr = p_dpp_dtb_mgr[dev_id]->queue_info[queue_id].tab_down.start_phy_addr +
5134 : 0 : item_index * p_dpp_dtb_mgr[dev_id]->queue_info[queue_id].tab_down.item_size;
5135 : 0 : item_info.data_hddr = ((phy_addr >> 4) >> 32) & 0xffffffff;
5136 : 0 : item_info.data_laddr = (phy_addr >> 4) & 0xffffffff;
5137 : :
5138 : 0 : zxdh_dtb_info_print(dev_id, queue_id, item_index, &item_info);
5139 : :
5140 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
5141 : 0 : *p_item_index = item_index;
5142 : :
5143 : : rte_spinlock_unlock(&p_spinlock->spinlock);
5144 : :
5145 : 0 : return rc;
5146 : : }
5147 : :
5148 : : static uint32_t
5149 : : zxdh_np_dtb_write_down_table_data(uint32_t dev_id,
5150 : : uint32_t queue_id,
5151 : : uint32_t down_table_len,
5152 : : uint8_t *p_down_table_buff,
5153 : : uint32_t *p_element_id)
5154 : : {
5155 : : uint32_t rc = 0;
5156 : : uint32_t dtb_interrupt_status = 0;
5157 : :
5158 : 0 : rc = zxdh_np_dtb_tab_down_info_set(dev_id,
5159 : : queue_id,
5160 : : dtb_interrupt_status,
5161 : : down_table_len / 4,
5162 : : (uint32_t *)p_down_table_buff,
5163 : : p_element_id);
5164 : : return rc;
5165 : : }
5166 : :
5167 : : static void
5168 : : zxdh_np_dtb_down_table_element_addr_get(uint32_t dev_id,
5169 : : uint32_t queue_id,
5170 : : uint32_t element_id,
5171 : : uint32_t *p_element_start_addr_h,
5172 : : uint32_t *p_element_start_addr_l,
5173 : : uint32_t *p_element_table_addr_h,
5174 : : uint32_t *p_element_table_addr_l)
5175 : : {
5176 : : uint32_t addr_h = 0;
5177 : : uint32_t addr_l = 0;
5178 : :
5179 : 0 : addr_h = (ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) >> 32) & 0xffffffff;
5180 : 0 : addr_l = ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) & 0xffffffff;
5181 : :
5182 : : *p_element_start_addr_h = addr_h;
5183 : : *p_element_start_addr_l = addr_l;
5184 : :
5185 : 0 : addr_h = ((ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) +
5186 : 0 : ZXDH_DTB_ITEM_ACK_SIZE) >> 32) & 0xffffffff;
5187 : 0 : addr_l = (ZXDH_DTB_TAB_DOWN_PHY_ADDR_GET(dev_id, queue_id, element_id) +
5188 : : ZXDH_DTB_ITEM_ACK_SIZE) & 0xffffffff;
5189 : :
5190 : : *p_element_table_addr_h = addr_h;
5191 : : *p_element_table_addr_l = addr_l;
5192 : : }
5193 : :
5194 : : static uint32_t
5195 : 0 : zxdh_np_dtb_down_table_element_info_prt(uint32_t dev_id,
5196 : : uint32_t queue_id,
5197 : : uint32_t element_id)
5198 : : {
5199 : : uint32_t rc = 0;
5200 : : uint32_t element_start_addr_h = 0;
5201 : : uint32_t element_start_addr_l = 0;
5202 : : uint32_t element_table_addr_h = 0;
5203 : : uint32_t element_table_addr_l = 0;
5204 : :
5205 : : zxdh_np_dtb_down_table_element_addr_get(dev_id,
5206 : : queue_id,
5207 : : element_id,
5208 : : &element_start_addr_h,
5209 : : &element_start_addr_l,
5210 : : &element_table_addr_h,
5211 : : &element_table_addr_l);
5212 : :
5213 : 0 : PMD_DRV_LOG(DEBUG, "queue_id %u.", queue_id);
5214 : 0 : PMD_DRV_LOG(DEBUG, "element_id %u.", element_id);
5215 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_h 0x%x.", element_start_addr_h);
5216 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_l 0x%x.", element_start_addr_l);
5217 : 0 : PMD_DRV_LOG(DEBUG, "element_table_addr_h 0x%x..", element_table_addr_h);
5218 : 0 : PMD_DRV_LOG(DEBUG, "element_table_addr_l 0x%x.", element_table_addr_l);
5219 : :
5220 : 0 : rc = zxdh_np_dtb_item_ack_prt(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE, element_id);
5221 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_prt");
5222 : :
5223 : 0 : rc = zxdh_np_dtb_item_buff_prt(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE, element_id, 24);
5224 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_prt");
5225 : :
5226 : 0 : return rc;
5227 : : }
5228 : :
5229 : : static uint32_t
5230 : 0 : zxdh_np_dtb_tab_down_success_status_check(uint32_t dev_id,
5231 : : uint32_t queue_id,
5232 : : uint32_t element_id)
5233 : : {
5234 : : uint32_t rc = 0;
5235 : : uint32_t rd_cnt = 0;
5236 : : uint32_t ack_value = 0;
5237 : : uint32_t success_flag = 0;
5238 : :
5239 : 0 : while (!success_flag) {
5240 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5241 : : element_id, 0, &ack_value);
5242 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_rd");
5243 : :
5244 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_np_dtb_item_ack_rd ack_value:0x%08x", ack_value);
5245 : :
5246 [ # # ]: 0 : if (((ack_value >> 8) & 0xffffff) == ZXDH_DTB_TAB_DOWN_ACK_VLD_MASK) {
5247 : : success_flag = 1;
5248 : : break;
5249 : : }
5250 : :
5251 [ # # ]: 0 : if (rd_cnt > ZXDH_DTB_DOWN_OVER_TIME) {
5252 : 0 : PMD_DRV_LOG(ERR, "down queue %u item %u overtime!", queue_id, element_id);
5253 : :
5254 : 0 : rc = zxdh_np_dtb_down_table_element_info_prt(dev_id, queue_id, element_id);
5255 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_down_table_element_info_prt");
5256 : :
5257 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5258 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
5259 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
5260 : :
5261 : 0 : return ZXDH_ERR;
5262 : : }
5263 : :
5264 : 0 : rd_cnt++;
5265 : 0 : rte_delay_us(ZXDH_DTB_DELAY_TIME);
5266 : : }
5267 : :
5268 [ # # ]: 0 : if ((ack_value & 0xff) != ZXDH_DTB_TAB_ACK_SUCCESS_MASK) {
5269 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5270 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
5271 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
5272 : 0 : return ack_value & 0xff;
5273 : : }
5274 : :
5275 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_DOWN_TYPE,
5276 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
5277 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
5278 : :
5279 : 0 : return rc;
5280 : : }
5281 : :
5282 : : static uint32_t
5283 : 0 : zxdh_np_hash_get_hash_info_from_sdt(uint32_t dev_id,
5284 : : uint32_t sdt_no, HASH_ENTRY_CFG *p_hash_entry_cfg)
5285 : : {
5286 : : uint32_t rc = ZXDH_OK;
5287 : : ZXDH_FUNC_ID_INFO *p_func_info = NULL;
5288 : : ZXDH_SE_CFG *p_se_cfg = NULL;
5289 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash_info = {0};
5290 : :
5291 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
5292 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash_info);
5293 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_read");
5294 : :
5295 : 0 : p_hash_entry_cfg->fun_id = sdt_hash_info.hash_id;
5296 : 0 : p_hash_entry_cfg->table_id = sdt_hash_info.hash_table_id;
5297 : 0 : p_hash_entry_cfg->bulk_id = ((p_hash_entry_cfg->table_id >> 2) & 0x7);
5298 : 0 : p_hash_entry_cfg->key_type = sdt_hash_info.hash_table_width;
5299 : 0 : p_hash_entry_cfg->rsp_mode = sdt_hash_info.rsp_mode;
5300 : 0 : p_hash_entry_cfg->actu_key_size = sdt_hash_info.key_size;
5301 : 0 : p_hash_entry_cfg->key_by_size = ZXDH_GET_KEY_SIZE(p_hash_entry_cfg->actu_key_size);
5302 [ # # ]: 0 : p_hash_entry_cfg->rst_by_size = ZXDH_GET_RST_SIZE(p_hash_entry_cfg->key_type,
5303 : : p_hash_entry_cfg->actu_key_size);
5304 : :
5305 : 0 : p_se_cfg = dpp_se_cfg[dev_id];
5306 : 0 : p_hash_entry_cfg->p_se_cfg = p_se_cfg;
5307 : :
5308 : : p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, p_hash_entry_cfg->fun_id);
5309 : :
5310 : 0 : p_hash_entry_cfg->p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
5311 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_entry_cfg->p_hash_cfg);
5312 : :
5313 : 0 : return ZXDH_OK;
5314 : : }
5315 : :
5316 : : static void
5317 : 0 : zxdh_np_hash_set_crc_key(HASH_ENTRY_CFG *p_hash_entry_cfg,
5318 : : ZXDH_HASH_ENTRY *p_entry, uint8_t *p_temp_key)
5319 : : {
5320 : : uint32_t key_by_size = 0;
5321 : : uint8_t temp_tbl_id = 0;
5322 : :
5323 : 0 : key_by_size = p_hash_entry_cfg->key_by_size;
5324 : 0 : memcpy(p_temp_key, p_entry->p_key, key_by_size);
5325 : :
5326 : 0 : temp_tbl_id = (*p_temp_key) & 0x1F;
5327 : 0 : memmove(p_temp_key, p_temp_key + 1, key_by_size - ZXDH_HASH_KEY_CTR_SIZE);
5328 : 0 : p_temp_key[key_by_size - ZXDH_HASH_KEY_CTR_SIZE] = temp_tbl_id;
5329 : 0 : }
5330 : :
5331 : : static uint8_t
5332 : 0 : zxdh_np_hash_sdt_partner_valid(uint32_t sdt_no, uint32_t sdt_partner, uint8_t *p_key)
5333 : : {
5334 : : uint32_t rc = ZXDH_OK;
5335 : : uint32_t dev_id = 0;
5336 : : uint32_t key_valid = 1;
5337 : :
5338 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash1 = {0};
5339 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash2 = {0};
5340 : :
5341 : 0 : if (sdt_no == sdt_partner ||
5342 [ # # # # ]: 0 : sdt_partner <= ZXDH_DEV_SDT_ID_MAX ||
5343 : : p_key == NULL) {
5344 : : return ZXDH_FALSE;
5345 : : }
5346 : :
5347 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
5348 : 0 : PMD_DRV_LOG(DEBUG, "sdt_partner:%u", sdt_partner);
5349 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash1);
5350 : 0 : rc |= zxdh_np_soft_sdt_tbl_get(dev_id, sdt_partner, &sdt_hash2);
5351 [ # # ]: 0 : if (rc != ZXDH_OK)
5352 : : return ZXDH_FALSE;
5353 : :
5354 [ # # ]: 0 : if (sdt_hash1.table_type != (ZXDH_SDT_TBLT_HASH) ||
5355 [ # # ]: 0 : sdt_hash2.table_type != ZXDH_SDT_TBLT_HASH ||
5356 [ # # ]: 0 : sdt_hash1.hash_table_width != sdt_hash2.hash_table_width ||
5357 [ # # ]: 0 : sdt_hash1.key_size != sdt_hash2.key_size ||
5358 [ # # ]: 0 : sdt_hash1.rsp_mode != sdt_hash2.rsp_mode) {
5359 : : return ZXDH_FALSE;
5360 : : }
5361 : :
5362 : 0 : *p_key = ZXDH_GET_HASH_KEY_CTRL(key_valid,
5363 : : sdt_hash2.hash_table_width,
5364 : : sdt_hash2.hash_table_id);
5365 : :
5366 : 0 : return ZXDH_TRUE;
5367 : : }
5368 : :
5369 : : static uint32_t
5370 : 0 : zxdh_np_hash_red_black_node_alloc(ZXDH_RB_TN **p_rb_tn_new,
5371 : : ZXDH_HASH_RBKEY_INFO **p_rbkey_new)
5372 : : {
5373 : : ZXDH_RB_TN *p_rb_tn_new_temp = NULL;
5374 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_new_temp = NULL;
5375 : :
5376 : 0 : p_rbkey_new_temp = rte_zmalloc(NULL, sizeof(ZXDH_HASH_RBKEY_INFO), 0);
5377 [ # # ]: 0 : if (p_rbkey_new_temp == NULL) {
5378 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
5379 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5380 : : }
5381 : :
5382 : 0 : p_rb_tn_new_temp = rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
5383 [ # # ]: 0 : if (p_rb_tn_new_temp == NULL) {
5384 : 0 : rte_free(p_rbkey_new_temp);
5385 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
5386 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5387 : : }
5388 : :
5389 : : zxdh_np_init_rbt_tn(p_rb_tn_new_temp, p_rbkey_new_temp);
5390 : :
5391 : 0 : *p_rb_tn_new = p_rb_tn_new_temp;
5392 : 0 : *p_rbkey_new = p_rbkey_new_temp;
5393 : :
5394 : 0 : return ZXDH_OK;
5395 : : }
5396 : :
5397 : : static uint32_t
5398 : 0 : zxdh_np_hash_rb_insert(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5399 : : ZXDH_HASH_ENTRY *p_entry)
5400 : : {
5401 : : uint32_t rc = ZXDH_OK;
5402 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
5403 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
5404 : 0 : ZXDH_HASH_RBKEY_INFO *p_rbkey_new = p_hash_entry_cfg->p_rbkey_new;
5405 : 0 : ZXDH_RB_TN *p_rb_tn_new = p_hash_entry_cfg->p_rb_tn_new;
5406 : 0 : ZXDH_HASH_CFG *p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5407 : 0 : uint32_t rst_actual_size = ((p_hash_entry_cfg->rst_by_size) > ZXDH_HASH_RST_MAX) ?
5408 : : ZXDH_HASH_RST_MAX : p_hash_entry_cfg->rst_by_size;
5409 : :
5410 : 0 : rc = zxdh_comm_rb_insert(&p_hash_cfg->hash_rb, (void *)p_rb_tn_new, (void *)(&p_rb_tn_rtn));
5411 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_FULL) {
5412 : 0 : PMD_DRV_LOG(ERR, "The red black tree is full!");
5413 : 0 : rte_free(p_rbkey_new);
5414 : 0 : rte_free(p_rb_tn_new);
5415 : : RTE_ASSERT(0);
5416 : 0 : return ZXDH_HASH_RC_RB_TREE_FULL;
5417 [ # # ]: 0 : } else if (rc == ZXDH_RBT_RC_UPDATE) {
5418 : 0 : p_hash_cfg->hash_stat.insert_same++;
5419 : 0 : PMD_DRV_LOG(DEBUG, "Hash update exist entry!");
5420 : :
5421 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
5422 : 0 : p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
5423 : :
5424 : 0 : memcpy(p_rbkey_rtn->rst, p_entry->p_rst, rst_actual_size);
5425 : :
5426 : 0 : rte_free(p_rbkey_new);
5427 : 0 : rte_free(p_rb_tn_new);
5428 : 0 : p_hash_entry_cfg->p_rbkey_new = p_rbkey_rtn;
5429 : 0 : p_hash_entry_cfg->p_rb_tn_new = p_rb_tn_rtn;
5430 : :
5431 : 0 : return ZXDH_HASH_RC_ADD_UPDATE;
5432 : : }
5433 : 0 : PMD_DRV_LOG(DEBUG, "Hash insert new entry!");
5434 : :
5435 [ # # ]: 0 : memcpy(p_rbkey_new->rst, p_entry->p_rst, rst_actual_size);
5436 [ # # ]: 0 : p_rbkey_new->entry_size = ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type);
5437 : : zxdh_np_init_d_node(&p_rbkey_new->entry_dn, p_rbkey_new);
5438 : :
5439 : 0 : return rc;
5440 : : }
5441 : :
5442 : : static uint32_t
5443 : : zxdh_np_hash_get_item_free_pos(uint32_t item_entry_max,
5444 : : uint32_t wrt_mask, uint32_t entry_size)
5445 : : {
5446 : : uint32_t i = 0;
5447 : : uint32_t pos = 0xFFFFFFFF;
5448 : : uint32_t mask = 0;
5449 : :
5450 [ # # ]: 0 : for (i = 0; i < item_entry_max; i += entry_size / ZXDH_HASH_ENTRY_POS_STEP) {
5451 : : mask = ZXDH_GET_HASH_ENTRY_MASK(entry_size, i);
5452 : :
5453 [ # # ]: 0 : if (0 == (mask & wrt_mask)) {
5454 : : pos = i;
5455 : : break;
5456 : : }
5457 : : }
5458 : :
5459 : : return pos;
5460 : : }
5461 : :
5462 : : static uint32_t
5463 : 0 : zxdh_np_hash_insrt_to_item(ZXDH_HASH_CFG *p_hash_cfg,
5464 : : ZXDH_HASH_RBKEY_INFO *p_rbkey,
5465 : : ZXDH_SE_ITEM_CFG *p_item,
5466 : : uint32_t item_idx,
5467 : : uint32_t item_type,
5468 : : __rte_unused uint32_t insrt_key_type)
5469 : : {
5470 : : uint32_t rc = ZXDH_OK;
5471 : :
5472 : : uint32_t free_pos = 0;
5473 : 0 : uint32_t dev_id = p_hash_cfg->p_se_info->dev_id;
5474 : : uint32_t item_entry_max = 4;
5475 : :
5476 [ # # ]: 0 : if (item_type == ZXDH_ITEM_DDR_256)
5477 : : item_entry_max = 2;
5478 : :
5479 [ # # ]: 0 : if (!p_item->valid) {
5480 : 0 : rc = zxdh_comm_double_link_init(item_entry_max, &p_item->item_list);
5481 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
5482 : :
5483 : 0 : p_rbkey->entry_pos = 0;
5484 : 0 : p_item->wrt_mask = ZXDH_GET_HASH_ENTRY_MASK(p_rbkey->entry_size,
5485 : : p_rbkey->entry_pos);
5486 : 0 : p_item->item_index = item_idx;
5487 : 0 : p_item->item_type = item_type;
5488 : 0 : p_item->valid = 1;
5489 : : } else {
5490 : 0 : free_pos = zxdh_np_hash_get_item_free_pos(item_entry_max,
5491 : 0 : p_item->wrt_mask, p_rbkey->entry_size);
5492 : :
5493 [ # # ]: 0 : if (free_pos == 0xFFFFFFFF)
5494 : : return ZXDH_HASH_RC_ITEM_FULL;
5495 : 0 : p_rbkey->entry_pos = free_pos;
5496 : 0 : p_item->wrt_mask |=
5497 : : ZXDH_GET_HASH_ENTRY_MASK(p_rbkey->entry_size, p_rbkey->entry_pos);
5498 : : }
5499 : :
5500 : 0 : PMD_DRV_LOG(DEBUG, "pos is[%u], size is[%u]", free_pos, p_rbkey->entry_size);
5501 : :
5502 [ # # ]: 0 : rc = zxdh_comm_double_link_insert_last(&p_rbkey->entry_dn, &p_item->item_list);
5503 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_last");
5504 : :
5505 : 0 : p_rbkey->p_item_info = p_item;
5506 : :
5507 : 0 : return rc;
5508 : : }
5509 : :
5510 : : static uint32_t
5511 : 0 : zxdh_np_hash_insert_ddr(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5512 : : uint8_t *p_temp_key, uint8_t *p_end_flag)
5513 : : {
5514 : 0 : ZXDH_HASH_CFG *p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5515 : 0 : uint8_t bulk_id = p_hash_entry_cfg->bulk_id;
5516 : 0 : HASH_DDR_CFG *p_ddr_cfg = p_hash_cfg->p_bulk_ddr_info[bulk_id];
5517 : : uint8_t key_type = 0;
5518 : 0 : uint8_t table_id = p_hash_entry_cfg->table_id;
5519 : : uint32_t key_by_size = 0;
5520 : : uint32_t crc_value = 0;
5521 : : uint32_t item_idx = 0xFFFFFFFF;
5522 : : uint32_t item_type = 0;
5523 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5524 : : uint32_t rc = ZXDH_OK;
5525 : :
5526 : 0 : key_type = p_hash_entry_cfg->key_type;
5527 [ # # # # ]: 0 : if (ZXDH_HASH_KEY_512b == key_type && ZXDH_DDR_WIDTH_256b == p_ddr_cfg->width_mode) {
5528 : 0 : PMD_DRV_LOG(ERR, "hash ddr width mode is not match to the key type.");
5529 : 0 : return ZXDH_HASH_RC_DDR_WIDTH_MODE_ERR;
5530 : : }
5531 : :
5532 : 0 : key_by_size = p_hash_entry_cfg->key_by_size;
5533 : 0 : crc_value = p_hash_cfg->p_hash32_fun(p_temp_key, key_by_size, p_ddr_cfg->hash_ddr_arg);
5534 : 0 : PMD_DRV_LOG(DEBUG, "hash ddr arg is: 0x%x.crc_value is 0x%x",
5535 : : p_ddr_cfg->hash_ddr_arg, crc_value);
5536 : :
5537 : 0 : item_idx = crc_value % p_ddr_cfg->item_num;
5538 : : item_type = ZXDH_ITEM_DDR_256;
5539 [ # # ]: 0 : if (ZXDH_DDR_WIDTH_512b == p_ddr_cfg->width_mode) {
5540 : : item_idx = crc_value % p_ddr_cfg->item_num;
5541 : : item_type = ZXDH_ITEM_DDR_512;
5542 : : }
5543 : :
5544 : 0 : PMD_DRV_LOG(DEBUG, "Hash insert in ITEM_DDR_%s, item_idx is: 0x%x.",
5545 : : ((item_type == ZXDH_ITEM_DDR_256) ? "256" : "512"), item_idx);
5546 : :
5547 : 0 : p_item = p_ddr_cfg->p_item_array[item_idx];
5548 [ # # ]: 0 : if (p_item == NULL) {
5549 : 0 : p_item = rte_zmalloc(NULL, sizeof(ZXDH_SE_ITEM_CFG), 0);
5550 [ # # ]: 0 : if (p_item == NULL) {
5551 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
5552 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5553 : : }
5554 : 0 : p_ddr_cfg->p_item_array[item_idx] = p_item;
5555 : : }
5556 : :
5557 : 0 : rc = zxdh_np_hash_insrt_to_item(p_hash_cfg,
5558 : : p_hash_entry_cfg->p_rbkey_new,
5559 : : p_item,
5560 : : item_idx,
5561 : : item_type,
5562 : : key_type);
5563 : :
5564 [ # # ]: 0 : if (rc != ZXDH_HASH_RC_ITEM_FULL) {
5565 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_insrt_to_item");
5566 : 0 : *p_end_flag = 1;
5567 : :
5568 : 0 : p_hash_cfg->hash_stat.insert_ddr++;
5569 : 0 : p_hash_cfg->hash_stat.insert_table[table_id].ddr++;
5570 : :
5571 : 0 : p_item->hw_addr = GET_HASH_DDR_HW_ADDR(p_ddr_cfg->hw_baddr, item_idx);
5572 : 0 : p_item->bulk_id = p_hash_entry_cfg->bulk_id;
5573 : : }
5574 : :
5575 : : return rc;
5576 : : }
5577 : :
5578 : : static uint32_t
5579 : 0 : zxdh_np_hash_insert_zcell(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5580 : : uint8_t *p_temp_key, uint8_t *p_end_flag)
5581 : : {
5582 : 0 : uint8_t bulk_id = p_hash_entry_cfg->bulk_id;
5583 : : ZXDH_D_NODE *p_zcell_dn = NULL;
5584 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
5585 : : uint32_t zblk_idx = 0;
5586 : : uint32_t zcell_id = 0;
5587 : : uint32_t pre_zblk_idx = 0xFFFFFFFF;
5588 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5589 : : uint32_t item_idx = 0xFFFFFFFF;
5590 : : uint32_t item_type = 0;
5591 : : uint32_t rc = ZXDH_OK;
5592 : : uint32_t crc_value = 0;
5593 : 0 : uint8_t table_id = p_hash_entry_cfg->table_id;
5594 : : ZXDH_SE_CFG *p_se_cfg = NULL;
5595 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
5596 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
5597 : :
5598 : 0 : PMD_DRV_LOG(DEBUG, "insert zcell start");
5599 : 0 : p_se_cfg = p_hash_entry_cfg->p_se_cfg;
5600 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
5601 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5602 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
5603 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
5604 : :
5605 [ # # ]: 0 : while (p_zcell_dn) {
5606 : 0 : p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
5607 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_zcell);
5608 : :
5609 [ # # # # : 0 : if (((p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO) && p_zcell->bulk_id != bulk_id) ||
# # ]
5610 : 0 : ((!(p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO)) &&
5611 [ # # ]: 0 : p_hash_cfg->bulk_ram_mono[bulk_id])) {
5612 : 0 : p_zcell_dn = p_zcell_dn->next;
5613 : 0 : continue;
5614 : : }
5615 : :
5616 : 0 : zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
5617 : : p_zblk = &p_se_cfg->zblk_info[zblk_idx];
5618 [ # # ]: 0 : if (zblk_idx != pre_zblk_idx) {
5619 : : pre_zblk_idx = zblk_idx;
5620 : 0 : crc_value = p_hash_cfg->p_hash16_fun(p_temp_key,
5621 : 0 : p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
5622 : : }
5623 : :
5624 : 0 : PMD_DRV_LOG(DEBUG, "zblk_idx:[0x%x] hash_arg:[0x%x] crc_value:[0x%x]",
5625 : : zblk_idx, p_zblk->hash_arg, crc_value);
5626 : :
5627 : 0 : zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
5628 : 0 : item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc_value);
5629 : 0 : p_item = &p_zcell->item_info[item_idx];
5630 : : item_type = ZXDH_ITEM_RAM;
5631 : :
5632 : 0 : PMD_DRV_LOG(DEBUG, "zcell_id:[0x%x] item_idx:[0x%x]", zcell_id, item_idx);
5633 : :
5634 : 0 : rc = zxdh_np_hash_insrt_to_item(p_hash_cfg,
5635 : : p_hash_entry_cfg->p_rbkey_new,
5636 : : p_item,
5637 : : item_idx,
5638 : : item_type,
5639 : 0 : p_hash_entry_cfg->key_type);
5640 : :
5641 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_ITEM_FULL) {
5642 : 0 : PMD_DRV_LOG(DEBUG, "The item is full, check next.");
5643 : : } else {
5644 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_insrt_to_item");
5645 : 0 : *p_end_flag = 1;
5646 : :
5647 : 0 : p_hash_cfg->hash_stat.insert_zcell++;
5648 : 0 : p_hash_cfg->hash_stat.insert_table[table_id].zcell++;
5649 : :
5650 : 0 : p_item->hw_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
5651 : 0 : break;
5652 : : }
5653 : :
5654 : 0 : p_zcell_dn = p_zcell_dn->next;
5655 : : }
5656 : :
5657 : 0 : return rc;
5658 : : }
5659 : :
5660 : : static uint32_t
5661 : 0 : zxdh_np_hash_insert_zreg(uint32_t dev_id, HASH_ENTRY_CFG *p_hash_entry_cfg,
5662 : : __rte_unused uint8_t *p_temp_key, uint8_t *p_end_flag)
5663 : : {
5664 : 0 : ZXDH_HASH_CFG *p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
5665 : 0 : ZXDH_D_NODE *p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
5666 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
5667 : : ZXDH_SE_ZREG_CFG *p_zreg = NULL;
5668 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5669 : : uint8_t reg_index = 0;
5670 : : uint32_t zblk_idx = 0;
5671 : : uint32_t rc = ZXDH_OK;
5672 : 0 : uint8_t bulk_id = p_hash_entry_cfg->bulk_id;
5673 : : uint32_t item_idx = 0xFFFFFFFF;
5674 : : uint32_t item_type = 0;
5675 : 0 : uint32_t table_id = p_hash_entry_cfg->table_id;
5676 : :
5677 [ # # ]: 0 : while (p_zblk_dn) {
5678 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
5679 : 0 : zblk_idx = p_zblk->zblk_idx;
5680 : :
5681 [ # # ]: 0 : for (reg_index = 0; reg_index < ZXDH_SE_ZREG_NUM; reg_index++) {
5682 : 0 : p_zreg = &p_zblk->zreg_info[reg_index];
5683 : :
5684 [ # # ]: 0 : if (((p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO) &&
5685 [ # # # # ]: 0 : p_zreg->bulk_id != bulk_id) ||
5686 : 0 : ((!(p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO)) &&
5687 [ # # ]: 0 : p_hash_cfg->bulk_ram_mono[bulk_id])) {
5688 : 0 : continue;
5689 : : }
5690 : :
5691 : 0 : p_item = &p_zblk->zreg_info[reg_index].item_info;
5692 : : item_type = ZXDH_ITEM_REG;
5693 : 0 : item_idx = reg_index;
5694 : 0 : rc = zxdh_np_hash_insrt_to_item(p_hash_cfg,
5695 : : p_hash_entry_cfg->p_rbkey_new,
5696 : : p_item,
5697 : : item_idx,
5698 : : item_type,
5699 : 0 : p_hash_entry_cfg->key_type);
5700 : :
5701 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_ITEM_FULL) {
5702 : 0 : PMD_DRV_LOG(DEBUG, "The item is full, check next.");
5703 : : } else {
5704 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_insrt_to_item");
5705 : 0 : *p_end_flag = 1;
5706 : :
5707 : 0 : p_hash_cfg->hash_stat.insert_zreg++;
5708 : 0 : p_hash_cfg->hash_stat.insert_table[table_id].zreg++;
5709 : :
5710 : 0 : p_item->hw_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx,
5711 : : reg_index);
5712 : 0 : break;
5713 : : }
5714 : : }
5715 : :
5716 [ # # ]: 0 : if (*p_end_flag)
5717 : : break;
5718 : :
5719 : 0 : p_zblk_dn = p_zblk_dn->next;
5720 : : }
5721 : :
5722 : 0 : return rc;
5723 : : }
5724 : :
5725 : : static uint32_t
5726 : 0 : zxdh_np_dtb_hash_form_write(ZXDH_HASH_CFG *p_hash_cfg,
5727 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_new,
5728 : : uint32_t actu_key_size,
5729 : : ZXDH_DTB_ENTRY_T *p_entry,
5730 : : __rte_unused uint32_t opr_mode)
5731 : : {
5732 : : uint32_t key_type = 0;
5733 : : uint32_t key_by_size = 0;
5734 : : uint32_t rst_by_size = 0;
5735 : : uint32_t byte_offset = 0;
5736 : 0 : uint32_t dev_id = p_hash_cfg->p_se_info->dev_id;
5737 : : uint32_t addr;
5738 : :
5739 : : ZXDH_D_NODE *p_entry_dn = NULL;
5740 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
5741 : 0 : uint8_t entry_data[ZXDH_SE_ENTRY_WIDTH_MAX] = {0};
5742 : 0 : ZXDH_SE_ITEM_CFG *p_item_info = p_rbkey_new->p_item_info;
5743 : :
5744 [ # # ]: 0 : if (p_item_info == NULL) {
5745 : 0 : PMD_DRV_LOG(ERR, "p_item_info point null!");
5746 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
5747 : : }
5748 : :
5749 : 0 : PMD_DRV_LOG(DEBUG, "zcam p_item_info->hw_addr is 0x%x",
5750 : : p_item_info->hw_addr);
5751 : 0 : addr = p_item_info->hw_addr;
5752 : :
5753 : 0 : p_entry_dn = p_item_info->item_list.p_next;
5754 : :
5755 [ # # ]: 0 : while (p_entry_dn) {
5756 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)(p_entry_dn->data);
5757 : 0 : key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
5758 [ # # ]: 0 : key_by_size = ZXDH_GET_KEY_SIZE(actu_key_size);
5759 : : rst_by_size = ZXDH_GET_RST_SIZE(key_type, actu_key_size);
5760 : :
5761 : 0 : byte_offset = p_rbkey->entry_pos * ZXDH_HASH_ENTRY_POS_STEP;
5762 : 0 : memcpy(entry_data + byte_offset, p_rbkey->key, key_by_size);
5763 : :
5764 : 0 : byte_offset += key_by_size;
5765 : 0 : memcpy(entry_data + byte_offset, p_rbkey->rst,
5766 : 0 : ((rst_by_size > ZXDH_HASH_RST_MAX) ? ZXDH_HASH_RST_MAX : rst_by_size));
5767 : :
5768 : 0 : p_entry_dn = p_entry_dn->next;
5769 : : }
5770 : :
5771 : : zxdh_np_comm_swap(entry_data, ZXDH_SE_ENTRY_WIDTH_MAX);
5772 : :
5773 : 0 : zxdh_np_dtb_se_alg_zcam_data_write(dev_id,
5774 : : addr,
5775 : : entry_data,
5776 : : p_entry);
5777 : :
5778 : 0 : return ZXDH_OK;
5779 : : }
5780 : :
5781 : : static uint32_t
5782 : 0 : zxdh_np_dtb_hash_delete(uint32_t dev_id,
5783 : : uint32_t sdt_no,
5784 : : ZXDH_HASH_ENTRY *p_hash_entry,
5785 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
5786 : : {
5787 : : uint32_t rc = ZXDH_OK;
5788 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
5789 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
5790 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
5791 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
5792 : : ZXDH_SPINLOCK_T *p_hash_spinlock = NULL;
5793 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
5794 : 0 : ZXDH_HASH_RBKEY_INFO temp_rbkey = {0};
5795 : : HASH_DDR_CFG *bulk_ddr_info = NULL;
5796 : :
5797 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
5798 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
5799 : :
5800 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
5801 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
5802 : :
5803 : 0 : zxdh_np_dev_hash_opr_spinlock_get(dev_id, p_hash_cfg->fun_id, &p_hash_spinlock);
5804 : 0 : rte_spinlock_lock(&p_hash_spinlock->spinlock);
5805 : :
5806 : 0 : memcpy(temp_rbkey.key, p_hash_entry->p_key, hash_entry_cfg.key_by_size);
5807 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, &temp_rbkey, &p_rb_tn_rtn);
5808 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL) {
5809 : 0 : p_hash_cfg->hash_stat.delete_fail++;
5810 : 0 : PMD_DRV_LOG(ERR, "Error!there is not item in hash!");
5811 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5812 : 0 : return ZXDH_HASH_RC_DEL_SRHFAIL;
5813 : : }
5814 : :
5815 : 0 : p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
5816 [ # # ]: 0 : memset(p_rbkey_rtn->rst, 0, sizeof(p_rbkey_rtn->rst));
5817 : 0 : hash_entry_cfg.p_rbkey_new = p_rbkey_rtn;
5818 : 0 : hash_entry_cfg.p_rb_tn_new = p_rb_tn_rtn;
5819 : :
5820 [ # # ]: 0 : p_item = p_rbkey_rtn->p_item_info;
5821 : : rc = zxdh_comm_double_link_del(&p_rbkey_rtn->entry_dn, &p_item->item_list);
5822 : : if (rc != ZXDH_OK) {
5823 : : PMD_DRV_LOG(ERR, "zxdh_comm_double_link_del failed, rc=0x%x.", rc);
5824 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5825 : : return ZXDH_ERR;
5826 : : }
5827 : 0 : p_item->wrt_mask &= ~(ZXDH_GET_HASH_ENTRY_MASK(p_rbkey_rtn->entry_size,
5828 : 0 : p_rbkey_rtn->entry_pos)) & 0xF;
5829 : :
5830 : 0 : rc = zxdh_np_dtb_hash_form_write(hash_entry_cfg.p_hash_cfg,
5831 : : hash_entry_cfg.p_rbkey_new,
5832 : : hash_entry_cfg.actu_key_size,
5833 : : p_dtb_one_entry,
5834 : : ZXDH_DTB_ITEM_DELETE);
5835 [ # # ]: 0 : if (rc != ZXDH_OK) {
5836 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_dtb_hash_form_write failed, rc=0x%x.", rc);
5837 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5838 : 0 : return ZXDH_ERR;
5839 : : }
5840 : :
5841 [ # # ]: 0 : if (p_item->item_list.used == 0) {
5842 [ # # ]: 0 : if (p_item->item_type == ZXDH_ITEM_DDR_256 ||
5843 : : p_item->item_type == ZXDH_ITEM_DDR_512) {
5844 : 0 : bulk_ddr_info = p_hash_cfg->p_bulk_ddr_info[hash_entry_cfg.bulk_id];
5845 [ # # ]: 0 : if (p_item->item_index > bulk_ddr_info->item_num) {
5846 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5847 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
5848 : : }
5849 : 0 : bulk_ddr_info->p_item_array[p_item->item_index] = NULL;
5850 : 0 : rte_free(p_item);
5851 : : } else {
5852 : 0 : p_item->valid = 0;
5853 : : }
5854 : : }
5855 : :
5856 : 0 : rte_free(p_rbkey_rtn);
5857 : 0 : rte_free(p_rb_tn_rtn);
5858 : 0 : p_hash_cfg->hash_stat.delete_ok++;
5859 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5860 : 0 : return rc;
5861 : : }
5862 : :
5863 : : static uint32_t
5864 : 0 : zxdh_np_dtb_hash_insert(uint32_t dev_id,
5865 : : uint32_t sdt_no,
5866 : : ZXDH_HASH_ENTRY *p_hash_entry,
5867 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
5868 : : {
5869 : : uint32_t rc = ZXDH_OK;
5870 : 0 : uint8_t end_flag = 0;
5871 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
5872 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
5873 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
5874 : 0 : ZXDH_RB_TN *p_rb_tn_new = NULL;
5875 : 0 : ZXDH_HASH_RBKEY_INFO *p_rbkey_new = NULL;
5876 : : ZXDH_SPINLOCK_T *p_hash_spinlock = NULL;
5877 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
5878 : :
5879 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
5880 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
5881 : :
5882 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
5883 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
5884 : :
5885 : 0 : zxdh_np_dev_hash_opr_spinlock_get(dev_id, p_hash_cfg->fun_id, &p_hash_spinlock);
5886 : 0 : rte_spinlock_lock(&p_hash_spinlock->spinlock);
5887 : :
5888 : 0 : rc = zxdh_np_hash_red_black_node_alloc(&p_rb_tn_new, &p_rbkey_new);
5889 [ # # ]: 0 : if (rc != ZXDH_OK) {
5890 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_hash_red_black_node_alloc failed, rc=0x%x.", rc);
5891 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5892 : 0 : return ZXDH_ERR;
5893 : : }
5894 : 0 : memcpy(p_rbkey_new->key, p_hash_entry->p_key,
5895 : 0 : hash_entry_cfg.key_by_size);
5896 : 0 : hash_entry_cfg.p_rbkey_new = p_rbkey_new;
5897 : 0 : hash_entry_cfg.p_rb_tn_new = p_rb_tn_new;
5898 : :
5899 : 0 : rc = zxdh_np_hash_rb_insert(dev_id, &hash_entry_cfg, p_hash_entry);
5900 [ # # ]: 0 : if (rc != ZXDH_OK) {
5901 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_ADD_UPDATE) {
5902 : 0 : rc = zxdh_np_dtb_hash_form_write(p_hash_cfg,
5903 : : hash_entry_cfg.p_rbkey_new,
5904 : : hash_entry_cfg.actu_key_size,
5905 : : p_dtb_one_entry,
5906 : : ZXDH_DTB_ITEM_ADD_OR_UPDATE);
5907 [ # # ]: 0 : if (rc != ZXDH_OK) {
5908 : 0 : PMD_DRV_LOG(ERR, "dtb_hash_form_write failed, rc=0x%x.", rc);
5909 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5910 : 0 : return ZXDH_ERR;
5911 : : }
5912 : : }
5913 : :
5914 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5915 : 0 : return rc;
5916 : : }
5917 : :
5918 : 0 : zxdh_np_hash_set_crc_key(&hash_entry_cfg, p_hash_entry, temp_key);
5919 : :
5920 [ # # ]: 0 : if (p_hash_cfg->ddr_valid) {
5921 : 0 : rc = zxdh_np_hash_insert_ddr(dev_id, &hash_entry_cfg, temp_key, &end_flag);
5922 [ # # ]: 0 : if (rc != ZXDH_OK) {
5923 : 0 : PMD_DRV_LOG(ERR, "hash_insert_ddr failed, rc=0x%x.", rc);
5924 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5925 : 0 : return ZXDH_ERR;
5926 : : }
5927 : : }
5928 : :
5929 [ # # ]: 0 : if (!end_flag) {
5930 : 0 : rc = zxdh_np_hash_insert_zcell(dev_id, &hash_entry_cfg, temp_key, &end_flag);
5931 [ # # ]: 0 : if (rc != ZXDH_OK) {
5932 : 0 : PMD_DRV_LOG(ERR, "hash_insert_zcell failed, rc=0x%x.", rc);
5933 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5934 : 0 : return ZXDH_ERR;
5935 : : }
5936 : : }
5937 : :
5938 [ # # ]: 0 : if (!end_flag) {
5939 : 0 : rc = zxdh_np_hash_insert_zreg(dev_id, &hash_entry_cfg, temp_key, &end_flag);
5940 [ # # ]: 0 : if (rc != ZXDH_OK) {
5941 : 0 : PMD_DRV_LOG(ERR, "hash_insert_zreg failed, rc=0x%x.", rc);
5942 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5943 : 0 : return ZXDH_ERR;
5944 : : }
5945 : : }
5946 : :
5947 [ # # ]: 0 : if (!end_flag) {
5948 : 0 : p_hash_cfg->hash_stat.insert_fail++;
5949 : 0 : memcpy(temp_key, p_hash_entry->p_key, hash_entry_cfg.key_by_size);
5950 : 0 : rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, p_rbkey_new, &p_rb_tn_rtn);
5951 [ # # ]: 0 : if (rc != ZXDH_OK) {
5952 : 0 : PMD_DRV_LOG(ERR, "hash_insert_zreg failed, rc=0x%x.", rc);
5953 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5954 : 0 : return ZXDH_ERR;
5955 : : }
5956 : : RTE_ASSERT(p_rb_tn_new == p_rb_tn_rtn);
5957 : 0 : rte_free(p_rbkey_new);
5958 : 0 : rte_free(p_rb_tn_rtn);
5959 : 0 : PMD_DRV_LOG(ERR, "ZXDH_HASH_RC_TBL_FULL.sdt_no=%u", sdt_no);
5960 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5961 : 0 : return ZXDH_RC_DTB_DOWN_HASH_CONFLICT;
5962 : : }
5963 : :
5964 : 0 : rc = zxdh_np_dtb_hash_form_write(p_hash_cfg,
5965 : : hash_entry_cfg.p_rbkey_new,
5966 : : hash_entry_cfg.actu_key_size,
5967 : : p_dtb_one_entry,
5968 : : ZXDH_DTB_ITEM_ADD_OR_UPDATE);
5969 [ # # ]: 0 : if (rc != ZXDH_OK) {
5970 : 0 : PMD_DRV_LOG(ERR, "hash form write failed, rc=0x%x.", rc);
5971 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5972 : 0 : return ZXDH_ERR;
5973 : : }
5974 : :
5975 : 0 : p_hash_cfg->hash_stat.insert_ok++;
5976 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
5977 : 0 : return rc;
5978 : : }
5979 : :
5980 : : static uint32_t
5981 : : zxdh_np_apt_get_sdt_partner(uint32_t dev_id, uint32_t sdt_no)
5982 : : {
5983 : : SE_APT_CALLBACK_T *p_apt_callback = NULL;
5984 : :
5985 : : p_apt_callback = &g_apt_se_callback[dev_id][sdt_no];
5986 : :
5987 [ # # # # : 0 : if (p_apt_callback->table_type == ZXDH_SDT_TBLT_HASH)
# # ]
5988 : 0 : return p_apt_callback->se_func_info.hash_func.sdt_partner;
5989 : :
5990 [ # # # # : 0 : if (p_apt_callback->table_type == ZXDH_SDT_TBLT_ETCAM)
# # ]
5991 : 0 : return p_apt_callback->se_func_info.acl_func.sdt_partner;
5992 : :
5993 : : return UINT32_MAX;
5994 : : }
5995 : :
5996 : : static uint32_t
5997 : 0 : zxdh_np_dtb_hash_one_entry(uint32_t dev_id,
5998 : : uint32_t sdt_no,
5999 : : uint32_t del_en,
6000 : : void *p_data,
6001 : : uint32_t *p_dtb_len,
6002 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
6003 : : {
6004 : : uint32_t rc = ZXDH_OK;
6005 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
6006 : 0 : uint8_t temp_rst[ZXDH_HASH_RST_MAX] = {0};
6007 : : uint8_t key_valid = 1;
6008 : 0 : uint8_t key = 0;
6009 : : uint32_t sdt_partner = 0;
6010 : : uint8_t valid = 0;
6011 : :
6012 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash = {0};
6013 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_entry = NULL;
6014 : : ZXDH_HASH_ENTRY entry = {0};
6015 : :
6016 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6017 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash);
6018 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
6019 : :
6020 : 0 : entry.p_key = temp_key;
6021 : 0 : entry.p_rst = temp_rst;
6022 : 0 : entry.p_key[0] = ZXDH_GET_HASH_KEY_CTRL(key_valid,
6023 : : sdt_hash.hash_table_width,
6024 : : sdt_hash.hash_table_id);
6025 : : p_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_data;
6026 : 0 : memcpy(&entry.p_key[1], p_entry->p_actu_key,
6027 [ # # ]: 0 : ZXDH_GET_ACTU_KEY_BY_SIZE(sdt_hash.key_size));
6028 : 0 : memcpy(entry.p_rst, p_entry->p_rst, 4 * (0x1 << sdt_hash.rsp_mode));
6029 : :
6030 [ # # ]: 0 : if (del_en) {
6031 : : do {
6032 : 0 : rc = zxdh_np_dtb_hash_delete(dev_id, sdt_no, &entry, p_dtb_one_entry);
6033 : : sdt_partner = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
6034 : 0 : valid = zxdh_np_hash_sdt_partner_valid(sdt_no, sdt_partner, &key);
6035 : 0 : entry.p_key[0] = key;
6036 : : sdt_no = sdt_partner;
6037 [ # # ]: 0 : } while ((rc == ZXDH_HASH_RC_DEL_SRHFAIL) && (valid == ZXDH_TRUE));
6038 : :
6039 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_delete");
6040 : : } else {
6041 : : do {
6042 : 0 : rc = zxdh_np_dtb_hash_insert(dev_id, sdt_no, &entry, p_dtb_one_entry);
6043 : : sdt_partner = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
6044 : 0 : valid = zxdh_np_hash_sdt_partner_valid(sdt_no, sdt_partner, &key);
6045 : 0 : entry.p_key[0] = key;
6046 : : sdt_no = sdt_partner;
6047 [ # # ]: 0 : } while ((rc == ZXDH_RC_DTB_DOWN_HASH_CONFLICT) && (valid == ZXDH_TRUE));
6048 : :
6049 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_insert");
6050 : : }
6051 : :
6052 : 0 : *p_dtb_len = p_dtb_one_entry->data_size / ZXDH_DTB_LEN_POS_SETP + 1;
6053 : :
6054 : 0 : return rc;
6055 : : }
6056 : :
6057 : : static void
6058 : 0 : zxdh_np_acl_hdw_addr_get(ZXDH_ACL_TBL_CFG_T *p_tbl_cfg, uint32_t handle,
6059 : : uint32_t *p_block_idx, uint32_t *p_addr, uint32_t *p_wr_mask)
6060 : : {
6061 : 0 : uint32_t block_entry_num = ZXDH_ACL_ENTRY_MAX_GET(p_tbl_cfg->key_mode, 1);
6062 : 0 : uint32_t entry_pos = (handle % block_entry_num) % (1U << p_tbl_cfg->key_mode);
6063 : :
6064 : 0 : *p_block_idx = p_tbl_cfg->block_array[handle / block_entry_num];
6065 : 0 : *p_addr = (handle % block_entry_num) / (1U << p_tbl_cfg->key_mode);
6066 : 0 : *p_wr_mask = (((1U << (8U >> (p_tbl_cfg->key_mode))) - 1) <<
6067 : 0 : ((8U >> (p_tbl_cfg->key_mode)) * (entry_pos))) & 0xFF;
6068 : 0 : }
6069 : :
6070 : : static void
6071 : 0 : zxdh_np_etcam_dm_to_xy(ZXDH_ETCAM_ENTRY_T *p_dm,
6072 : : ZXDH_ETCAM_ENTRY_T *p_xy,
6073 : : uint32_t len)
6074 : : {
6075 : : uint32_t i = 0;
6076 : :
6077 : : RTE_ASSERT(p_dm->p_data && p_dm->p_mask && p_xy->p_data && p_xy->p_mask);
6078 : :
6079 [ # # ]: 0 : for (i = 0; i < len; i++) {
6080 : 0 : p_xy->p_data[i] = ZXDH_COMM_DM_TO_X(p_dm->p_data[i], p_dm->p_mask[i]);
6081 : 0 : p_xy->p_mask[i] = ZXDH_COMM_DM_TO_Y(p_dm->p_data[i], p_dm->p_mask[i]);
6082 : : }
6083 : 0 : }
6084 : :
6085 : : static uint32_t
6086 : : zxdh_np_eram_opr_mode_get(uint32_t as_mode)
6087 : : {
6088 : : uint32_t opr_mode = 0;
6089 : :
6090 [ # # # # : 0 : switch (as_mode) {
# # ]
6091 : : case ZXDH_ERAM128_TBL_128b:
6092 : : opr_mode = ZXDH_ERAM128_OPR_128b;
6093 : : break;
6094 : 0 : case ZXDH_ERAM128_TBL_64b:
6095 : : opr_mode = ZXDH_ERAM128_OPR_64b;
6096 : 0 : break;
6097 : 0 : case ZXDH_ERAM128_TBL_1b:
6098 : : opr_mode = ZXDH_ERAM128_OPR_1b;
6099 : 0 : break;
6100 : : default:
6101 : : break;
6102 : : }
6103 : :
6104 : : return opr_mode;
6105 : : }
6106 : :
6107 : : static uint32_t
6108 : 0 : zxdh_np_dtb_etcam_entry_add(uint32_t dev_id,
6109 : : uint32_t addr,
6110 : : uint32_t block_idx,
6111 : : uint32_t wr_mask,
6112 : : uint32_t opr_type,
6113 : : ZXDH_ETCAM_ENTRY_T *p_entry,
6114 : : ZXDH_DTB_ENTRY_T *p_entry_data,
6115 : : ZXDH_DTB_ENTRY_T *p_entry_mask)
6116 : : {
6117 : : uint32_t rc = ZXDH_OK;
6118 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6119 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6120 : 0 : ZXDH_ETCAM_ENTRY_T entry_xy = {0};
6121 : :
6122 : : RTE_ASSERT(p_entry->p_data && p_entry->p_mask);
6123 : :
6124 : 0 : entry_xy.p_data = temp_data;
6125 : 0 : entry_xy.p_mask = temp_mask;
6126 : :
6127 [ # # ]: 0 : if (opr_type == ZXDH_ETCAM_OPR_DM) {
6128 : 0 : zxdh_np_etcam_dm_to_xy(p_entry, &entry_xy,
6129 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
6130 : : } else {
6131 : 0 : memcpy(entry_xy.p_data, p_entry->p_data,
6132 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
6133 : 0 : memcpy(entry_xy.p_mask, p_entry->p_mask,
6134 : : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
6135 : : }
6136 : :
6137 : 0 : rc = zxdh_np_dtb_etcam_write_entry_data(dev_id, block_idx, 0, 1, 0, 0, 0,
6138 : : wr_mask, ZXDH_ETCAM_DTYPE_DATA, addr, 0, entry_xy.p_data, p_entry_data);
6139 : :
6140 : 0 : rc = zxdh_np_dtb_etcam_write_entry_data(dev_id, block_idx, 0, 1, 0, 0, 0,
6141 : : wr_mask, ZXDH_ETCAM_DTYPE_MASK, addr, 0xFF, entry_xy.p_mask, p_entry_mask);
6142 : :
6143 : 0 : return rc;
6144 : : }
6145 : :
6146 : : static uint32_t
6147 : 0 : zxdh_np_dtb_acl_delete(uint32_t dev_id,
6148 : : uint32_t sdt_no,
6149 : : ZXDH_ACL_ENTRY_EX_T *p_acl_entry,
6150 : : ZXDH_DTB_ENTRY_T *p_dtb_data_entry,
6151 : : ZXDH_DTB_ENTRY_T *p_dtb_mask_entry,
6152 : : ZXDH_DTB_ENTRY_T *p_dtb_as_entry)
6153 : : {
6154 : : uint32_t rc = ZXDH_OK;
6155 : : uint32_t as_eram_baddr = 0;
6156 : : uint32_t as_enable = 0;
6157 : : uint32_t etcam_table_id = 0;
6158 : : uint32_t etcam_as_mode = 0;
6159 : : uint32_t opr_mode = 0;
6160 : 0 : uint32_t block_idx = 0;
6161 : 0 : uint32_t ram_addr = 0;
6162 : 0 : uint32_t etcam_wr_mask = 0;
6163 : : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8];
6164 : : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8];
6165 : 0 : uint8_t temp_buf[16] = {0};
6166 : :
6167 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
6168 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
6169 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
6170 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry = {0};
6171 : :
6172 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6173 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
6174 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
6175 : :
6176 : 0 : etcam_as_mode = sdt_acl.as_rsp_mode;
6177 : 0 : etcam_table_id = sdt_acl.etcam_table_id;
6178 : 0 : as_enable = sdt_acl.as_en;
6179 : 0 : as_eram_baddr = sdt_acl.as_eram_baddr;
6180 : :
6181 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
6182 : :
6183 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
6184 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
6185 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
6186 : : RTE_ASSERT(0);
6187 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
6188 : : }
6189 : :
6190 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_acl_entry->pri,
6191 : : &block_idx, &ram_addr, &etcam_wr_mask);
6192 : :
6193 : : memset(temp_data, 0xff, ZXDH_ETCAM_WIDTH_MAX / 8);
6194 : : memset(temp_mask, 0, ZXDH_ETCAM_WIDTH_MAX / 8);
6195 : 0 : etcam_entry.mode = p_tbl_cfg->key_mode;
6196 : 0 : etcam_entry.p_data = temp_data;
6197 : 0 : etcam_entry.p_mask = temp_mask;
6198 : 0 : rc = zxdh_np_dtb_etcam_entry_add(dev_id,
6199 : : ram_addr,
6200 : : block_idx,
6201 : : etcam_wr_mask,
6202 : : ZXDH_ETCAM_OPR_DM,
6203 : : &etcam_entry,
6204 : : p_dtb_data_entry,
6205 : : p_dtb_mask_entry);
6206 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_etcam_entry_add");
6207 : :
6208 [ # # ]: 0 : if (as_enable) {
6209 : : memset(temp_buf, 0, sizeof(temp_buf));
6210 : : opr_mode = zxdh_np_eram_opr_mode_get(etcam_as_mode);
6211 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
6212 : : as_eram_baddr,
6213 : : p_acl_entry->pri,
6214 : : opr_mode,
6215 : : (uint32_t *)temp_buf,
6216 : : p_dtb_as_entry);
6217 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_smmu0_ind_write");
6218 : : }
6219 : :
6220 : : return rc;
6221 : : }
6222 : :
6223 : : static uint32_t
6224 : 0 : zxdh_np_dtb_acl_insert(uint32_t dev_id,
6225 : : uint32_t sdt_no,
6226 : : ZXDH_ACL_ENTRY_EX_T *p_acl_entry,
6227 : : ZXDH_DTB_ENTRY_T *p_dtb_data_entry,
6228 : : ZXDH_DTB_ENTRY_T *p_dtb_mask_entry,
6229 : : ZXDH_DTB_ENTRY_T *p_dtb_as_entry)
6230 : : {
6231 : : uint32_t rc = ZXDH_OK;
6232 : : uint32_t as_eram_baddr = 0;
6233 : : uint32_t as_enable = 0;
6234 : : uint32_t etcam_table_id = 0;
6235 : : uint32_t etcam_as_mode = 0;
6236 : : uint32_t opr_mode = 0;
6237 : 0 : uint32_t block_idx = 0;
6238 : 0 : uint32_t ram_addr = 0;
6239 : 0 : uint32_t etcam_wr_mask = 0;
6240 : :
6241 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_acl = {0};
6242 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
6243 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
6244 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry = {0};
6245 : :
6246 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6247 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_acl);
6248 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
6249 : :
6250 : 0 : etcam_as_mode = sdt_acl.as_rsp_mode;
6251 : 0 : etcam_table_id = sdt_acl.etcam_table_id;
6252 : 0 : as_enable = sdt_acl.as_en;
6253 : 0 : as_eram_baddr = sdt_acl.as_eram_baddr;
6254 : :
6255 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
6256 : :
6257 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
6258 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
6259 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
6260 : : RTE_ASSERT(0);
6261 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
6262 : : }
6263 : :
6264 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_acl_entry->pri,
6265 : : &block_idx, &ram_addr, &etcam_wr_mask);
6266 : :
6267 : 0 : etcam_entry.mode = p_tbl_cfg->key_mode;
6268 : 0 : etcam_entry.p_data = p_acl_entry->key_data;
6269 : 0 : etcam_entry.p_mask = p_acl_entry->key_mask;
6270 : :
6271 : 0 : rc = zxdh_np_dtb_etcam_entry_add(dev_id,
6272 : : ram_addr,
6273 : : block_idx,
6274 : : etcam_wr_mask,
6275 : : ZXDH_ETCAM_OPR_DM,
6276 : : &etcam_entry,
6277 : : p_dtb_data_entry,
6278 : : p_dtb_mask_entry);
6279 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_etcam_entry_add");
6280 : :
6281 [ # # ]: 0 : if (as_enable) {
6282 : : opr_mode = zxdh_np_eram_opr_mode_get(etcam_as_mode);
6283 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
6284 : : as_eram_baddr,
6285 : : p_acl_entry->pri,
6286 : : opr_mode,
6287 : 0 : (uint32_t *)p_acl_entry->p_as_rslt,
6288 : : p_dtb_as_entry);
6289 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_smmu0_ind_write");
6290 : : }
6291 : :
6292 : : return rc;
6293 : : }
6294 : :
6295 : : static uint32_t
6296 : 0 : zxdh_np_dtb_acl_one_entry(uint32_t dev_id,
6297 : : uint32_t sdt_no,
6298 : : uint32_t del_en,
6299 : : void *p_data,
6300 : : uint32_t *p_dtb_len,
6301 : : uint8_t *p_data_buff)
6302 : : {
6303 : : uint32_t rc = ZXDH_OK;
6304 : : uint32_t addr_offset = 0;
6305 : 0 : ZXDH_ACL_ENTRY_EX_T acl_entry = {0};
6306 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_entry = NULL;
6307 : :
6308 : 0 : uint8_t data_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6309 : 0 : uint8_t mask_buff[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6310 : 0 : uint8_t data_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6311 : 0 : uint8_t mask_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6312 : 0 : uint8_t as_cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6313 : 0 : uint32_t as_data_buff[4] = {0};
6314 : :
6315 : 0 : ZXDH_DTB_ENTRY_T dtb_data_entry = {0};
6316 : 0 : ZXDH_DTB_ENTRY_T dtb_mask_entry = {0};
6317 : 0 : ZXDH_DTB_ENTRY_T dtb_as_entry = {0};
6318 : :
6319 : 0 : dtb_data_entry.cmd = data_cmd_buff;
6320 : 0 : dtb_data_entry.data = data_buff;
6321 : 0 : dtb_mask_entry.cmd = mask_cmd_buff;
6322 : 0 : dtb_mask_entry.data = mask_buff;
6323 : 0 : dtb_as_entry.cmd = as_cmd_buff;
6324 : 0 : dtb_as_entry.data = (uint8_t *)as_data_buff;
6325 : :
6326 : : p_entry = (ZXDH_DTB_ACL_ENTRY_INFO_T *)p_data;
6327 : 0 : acl_entry.pri = p_entry->handle;
6328 : 0 : acl_entry.key_data = p_entry->key_data;
6329 : 0 : acl_entry.key_mask = p_entry->key_mask;
6330 : 0 : acl_entry.p_as_rslt = p_entry->p_as_rslt;
6331 [ # # ]: 0 : if (del_en) {
6332 : 0 : rc = zxdh_np_dtb_acl_delete(dev_id,
6333 : : sdt_no,
6334 : : &acl_entry,
6335 : : &dtb_data_entry,
6336 : : &dtb_mask_entry,
6337 : : &dtb_as_entry);
6338 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_delete");
6339 : : } else {
6340 : 0 : rc = zxdh_np_dtb_acl_insert(dev_id,
6341 : : sdt_no,
6342 : : &acl_entry,
6343 : : &dtb_data_entry,
6344 : : &dtb_mask_entry,
6345 : : &dtb_as_entry);
6346 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_insert");
6347 : : }
6348 : :
6349 : 0 : addr_offset = (*p_dtb_len) * ZXDH_DTB_LEN_POS_SETP;
6350 : 0 : *p_dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
6351 : :
6352 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_data_entry);
6353 : :
6354 : 0 : addr_offset = (*p_dtb_len) * ZXDH_DTB_LEN_POS_SETP;
6355 : 0 : *p_dtb_len += ZXDH_DTB_ETCAM_LEN_SIZE;
6356 : :
6357 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_mask_entry);
6358 : :
6359 : 0 : addr_offset = (*p_dtb_len) * ZXDH_DTB_LEN_POS_SETP;
6360 [ # # ]: 0 : if (dtb_as_entry.data_in_cmd_flag)
6361 : 0 : *p_dtb_len += 1;
6362 : : else
6363 : 0 : *p_dtb_len += 2;
6364 : :
6365 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_as_entry);
6366 : :
6367 : 0 : return ZXDH_OK;
6368 : : }
6369 : :
6370 : : int
6371 : 0 : zxdh_np_dtb_table_entry_write(uint32_t dev_id,
6372 : : uint32_t queue_id,
6373 : : uint32_t entrynum,
6374 : : ZXDH_DTB_USER_ENTRY_T *down_entries)
6375 : : {
6376 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
6377 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
6378 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT] = {0};
6379 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX] = {0};
6380 : : uint8_t *p_data_buff;
6381 : 0 : uint32_t element_id = 0xff;
6382 : 0 : uint32_t one_dtb_len = 0;
6383 : 0 : uint32_t dtb_len = 0;
6384 : : uint32_t entry_index;
6385 : : uint32_t sdt_no;
6386 : : uint32_t tbl_type;
6387 : : uint32_t addr_offset;
6388 : : uint32_t max_size;
6389 : : uint32_t rc = 0;
6390 : :
6391 : 0 : p_data_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
6392 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
6393 : :
6394 : 0 : dtb_one_entry.cmd = entry_cmd;
6395 : 0 : dtb_one_entry.data = entry_data;
6396 : :
6397 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
6398 : :
6399 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
6400 : 0 : pentry = down_entries + entry_index;
6401 : 0 : sdt_no = pentry->sdt_no;
6402 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6403 : : tbl_type = zxdh_np_sdt_tbl_type_get(dev_id, sdt_no);
6404 [ # # # # ]: 0 : switch (tbl_type) {
6405 : 0 : case ZXDH_SDT_TBLT_ERAM:
6406 : 0 : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
6407 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
6408 : 0 : break;
6409 : 0 : case ZXDH_SDT_TBLT_HASH:
6410 : 0 : rc = zxdh_np_dtb_hash_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
6411 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
6412 : 0 : break;
6413 : 0 : case ZXDH_SDT_TBLT_ETCAM:
6414 : 0 : rc = zxdh_np_dtb_acl_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
6415 : : pentry->p_entry_data, &dtb_len, p_data_buff);
6416 : 0 : continue;
6417 : 0 : default:
6418 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
6419 : 0 : rte_free(p_data_buff);
6420 : 0 : return 1;
6421 : : }
6422 : :
6423 : 0 : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
6424 : 0 : dtb_len += one_dtb_len;
6425 [ # # ]: 0 : if (dtb_len > max_size) {
6426 : 0 : rte_free(p_data_buff);
6427 : 0 : PMD_DRV_LOG(ERR, "error dtb_len>%u!", max_size);
6428 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6429 : : }
6430 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
6431 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
6432 : : memset(entry_data, 0x0, sizeof(entry_data));
6433 : : }
6434 : :
6435 [ # # ]: 0 : if (dtb_len == 0) {
6436 : 0 : rte_free(p_data_buff);
6437 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6438 : : }
6439 : :
6440 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
6441 : : queue_id,
6442 : : dtb_len * 16,
6443 : : p_data_buff,
6444 : : &element_id);
6445 : 0 : rte_free(p_data_buff);
6446 : :
6447 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, element_id);
6448 : :
6449 : 0 : return rc;
6450 : : }
6451 : :
6452 : : int
6453 : 0 : zxdh_np_dtb_table_entry_delete(uint32_t dev_id,
6454 : : uint32_t queue_id,
6455 : : uint32_t entrynum,
6456 : : ZXDH_DTB_USER_ENTRY_T *delete_entries)
6457 : : {
6458 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
6459 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
6460 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
6461 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
6462 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
6463 : : uint8_t *p_data_buff = NULL;
6464 : : uint32_t tbl_type = 0;
6465 : 0 : uint32_t element_id = 0xff;
6466 : 0 : uint32_t one_dtb_len = 0;
6467 : : uint32_t dtb_len = 0;
6468 : : uint32_t entry_index;
6469 : : uint32_t sdt_no;
6470 : : uint32_t addr_offset;
6471 : : uint32_t max_size;
6472 : : uint32_t rc;
6473 : :
6474 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(delete_entries);
6475 : :
6476 : 0 : p_data_buff = rte_calloc(NULL, 1, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
6477 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
6478 : :
6479 : 0 : dtb_one_entry.cmd = entry_cmd;
6480 : 0 : dtb_one_entry.data = entry_data;
6481 : :
6482 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
6483 : :
6484 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
6485 : 0 : pentry = delete_entries + entry_index;
6486 : :
6487 : 0 : sdt_no = pentry->sdt_no;
6488 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
6489 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
6490 : : tbl_type = zxdh_np_sdt_tbl_type_get(dev_id, sdt_no);
6491 [ # # # ]: 0 : switch (tbl_type) {
6492 : 0 : case ZXDH_SDT_TBLT_ERAM:
6493 : 0 : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_DELETE,
6494 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
6495 : 0 : break;
6496 : 0 : case ZXDH_SDT_TBLT_HASH:
6497 : 0 : rc = zxdh_np_dtb_hash_one_entry(dev_id, sdt_no,
6498 : : ZXDH_DTB_ITEM_DELETE, pentry->p_entry_data,
6499 : : &one_dtb_len, &dtb_one_entry);
6500 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
6501 : 0 : continue;
6502 : : break;
6503 : 0 : default:
6504 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
6505 : 0 : rte_free(p_data_buff);
6506 : 0 : return 1;
6507 : : }
6508 : :
6509 : 0 : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
6510 : 0 : dtb_len += one_dtb_len;
6511 [ # # ]: 0 : if (dtb_len > max_size) {
6512 : 0 : rte_free(p_data_buff);
6513 : 0 : PMD_DRV_LOG(ERR, "error dtb_len>%u!", max_size);
6514 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6515 : : }
6516 : :
6517 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
6518 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
6519 : : memset(entry_data, 0x0, sizeof(entry_data));
6520 : : }
6521 : :
6522 [ # # ]: 0 : if (dtb_len == 0) {
6523 : 0 : rte_free(p_data_buff);
6524 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
6525 : : }
6526 : :
6527 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
6528 : : queue_id,
6529 : : dtb_len * 16,
6530 : : p_data_buff,
6531 : : &element_id);
6532 : 0 : rte_free(p_data_buff);
6533 : :
6534 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id, queue_id, element_id);
6535 : :
6536 : 0 : return rc;
6537 : : }
6538 : :
6539 : : static void
6540 : : zxdh_np_eram_index_cal(uint32_t eram_mode, uint32_t index,
6541 : : uint32_t *p_row_index, uint32_t *p_col_index)
6542 : : {
6543 : : uint32_t row_index = 0;
6544 : : uint32_t col_index = 0;
6545 : :
6546 [ # # # # ]: 0 : switch (eram_mode) {
6547 : 0 : case ZXDH_ERAM128_TBL_128b:
6548 : : row_index = index;
6549 : 0 : break;
6550 : 0 : case ZXDH_ERAM128_TBL_64b:
6551 : 0 : row_index = (index >> 1);
6552 : 0 : col_index = index & 0x1;
6553 : 0 : break;
6554 : 0 : case ZXDH_ERAM128_TBL_1b:
6555 : 0 : row_index = (index >> 7);
6556 : 0 : col_index = index & 0x7F;
6557 : 0 : break;
6558 : : default:
6559 : : break;
6560 : : }
6561 : : *p_row_index = row_index;
6562 : : *p_col_index = col_index;
6563 : : }
6564 : :
6565 : : static void
6566 : : zxdh_np_stat_cfg_soft_get(uint32_t dev_id,
6567 : : ZXDH_PPU_STAT_CFG_T *p_stat_cfg)
6568 : : {
6569 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_stat_cfg);
6570 : :
6571 : 0 : p_stat_cfg->ddr_base_addr = g_ppu_stat_cfg[dev_id].ddr_base_addr;
6572 : 0 : p_stat_cfg->eram_baddr = g_ppu_stat_cfg[dev_id].eram_baddr;
6573 : 0 : p_stat_cfg->eram_depth = g_ppu_stat_cfg[dev_id].eram_depth;
6574 : 0 : p_stat_cfg->ppu_addr_offset = g_ppu_stat_cfg[dev_id].ppu_addr_offset;
6575 : : }
6576 : :
6577 : : static uint32_t
6578 : 0 : zxdh_np_dtb_tab_up_info_set(uint32_t dev_id,
6579 : : uint32_t queue_id,
6580 : : uint32_t item_index,
6581 : : uint32_t int_flag,
6582 : : uint32_t data_len,
6583 : : uint32_t desc_len,
6584 : : uint32_t *p_desc_data)
6585 : : {
6586 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
6587 : 0 : uint32_t queue_en = 0;
6588 : : uint32_t rc;
6589 : : ZXDH_SPINLOCK_T *p_spinlock = NULL;
6590 : :
6591 : : zxdh_np_dev_dtb_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_DTB, queue_id, &p_spinlock);
6592 : 0 : rte_spinlock_lock(&p_spinlock->spinlock);
6593 : :
6594 : 0 : zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
6595 [ # # ]: 0 : if (!queue_en) {
6596 : 0 : PMD_DRV_LOG(ERR, "the queue %u is not enable!", queue_id);
6597 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6598 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
6599 : : }
6600 : :
6601 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6602 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init", queue_id);
6603 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6604 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6605 : : }
6606 : :
6607 [ # # ]: 0 : if (desc_len % 4 != 0) {
6608 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6609 : 0 : return ZXDH_RC_DTB_PARA_INVALID;
6610 : : }
6611 : :
6612 : 0 : zxdh_np_dtb_item_buff_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6613 : : item_index, 0, desc_len, p_desc_data);
6614 : :
6615 : 0 : ZXDH_DTB_TAB_UP_DATA_LEN_GET(dev_id, queue_id, item_index) = data_len;
6616 : :
6617 : 0 : item_info.cmd_vld = 1;
6618 : 0 : item_info.cmd_type = ZXDH_DTB_DIR_UP_TYPE;
6619 : 0 : item_info.int_en = int_flag;
6620 : 0 : item_info.data_len = desc_len / 4;
6621 : 0 : item_info.data_hddr =
6622 : 0 : ((ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) >> 4) >> 32) & 0xffffffff;
6623 : 0 : item_info.data_laddr =
6624 : 0 : (ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) >> 4) & 0xffffffff;
6625 : 0 : zxdh_dtb_info_print(dev_id, queue_id, item_index, &item_info);
6626 : :
6627 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
6628 : :
6629 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6630 : :
6631 : 0 : return rc;
6632 : : }
6633 : :
6634 : : static uint32_t
6635 : 0 : zxdh_np_dtb_tab_up_data_get(uint32_t dev_id,
6636 : : uint32_t queue_id,
6637 : : uint32_t item_index,
6638 : : uint32_t data_len,
6639 : : uint32_t *p_data)
6640 : : {
6641 : : uint32_t rc = 0;
6642 : :
6643 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6644 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
6645 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6646 : : }
6647 : :
6648 : 0 : rc = zxdh_np_dtb_item_buff_rd(dev_id,
6649 : : queue_id,
6650 : : ZXDH_DTB_DIR_UP_TYPE,
6651 : : item_index,
6652 : : 0,
6653 : : data_len,
6654 : : p_data);
6655 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_rd");
6656 : :
6657 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6658 : : item_index, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
6659 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
6660 : :
6661 : 0 : return rc;
6662 : : }
6663 : :
6664 : : static uint32_t
6665 : 0 : zxdh_np_dtb_tab_up_item_addr_get(uint32_t dev_id,
6666 : : uint32_t queue_id,
6667 : : uint32_t item_index,
6668 : : uint32_t *p_phy_haddr,
6669 : : uint32_t *p_phy_laddr)
6670 : : {
6671 : : uint32_t rc = 0;
6672 : : uint64_t addr;
6673 : :
6674 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6675 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
6676 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6677 : : }
6678 : :
6679 [ # # ]: 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
6680 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE)
6681 : 0 : addr = ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(dev_id, queue_id, item_index);
6682 : : else
6683 : 0 : addr = ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index)
6684 : : + ZXDH_DTB_ITEM_ACK_SIZE;
6685 : :
6686 : 0 : *p_phy_haddr = (addr >> 32) & 0xffffffff;
6687 : 0 : *p_phy_laddr = addr & 0xffffffff;
6688 : :
6689 : 0 : return rc;
6690 : : }
6691 : :
6692 : : static void
6693 : : zxdh_np_dtb_tab_up_item_offset_addr_get(uint32_t dev_id,
6694 : : uint32_t queue_id,
6695 : : uint32_t item_index,
6696 : : uint32_t addr_offset,
6697 : : uint32_t *p_phy_haddr,
6698 : : uint32_t *p_phy_laddr)
6699 : : {
6700 : : uint64_t addr = 0;
6701 : :
6702 : 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
6703 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE)
6704 : 0 : addr = ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(dev_id, queue_id, item_index);
6705 : : else
6706 : 0 : addr = ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) +
6707 : : ZXDH_DTB_ITEM_ACK_SIZE;
6708 : :
6709 : 0 : addr = addr + addr_offset;
6710 : :
6711 : 0 : *p_phy_haddr = (addr >> 32) & 0xffffffff;
6712 : 0 : *p_phy_laddr = addr & 0xffffffff;
6713 : : }
6714 : :
6715 : : static uint32_t
6716 : 0 : zxdh_np_dtb_dump_table_element_addr_get(uint32_t dev_id,
6717 : : uint32_t queue_id,
6718 : : uint32_t element_id,
6719 : : uint32_t *p_element_start_addr_h,
6720 : : uint32_t *p_element_start_addr_l,
6721 : : uint32_t *p_element_dump_addr_h,
6722 : : uint32_t *p_element_dump_addr_l,
6723 : : uint32_t *p_element_table_info_addr_h,
6724 : : uint32_t *p_element_table_info_addr_l)
6725 : : {
6726 : : uint32_t rc = ZXDH_OK;
6727 : : uint32_t addr_h = 0;
6728 : : uint32_t addr_l = 0;
6729 : :
6730 : 0 : addr_h = ((ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id)) >> 32) & 0xffffffff;
6731 : 0 : addr_l = (ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id)) & 0xffffffff;
6732 : :
6733 : 0 : *p_element_start_addr_h = addr_h;
6734 : 0 : *p_element_start_addr_l = addr_l;
6735 : :
6736 : 0 : addr_h = ((ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id) +
6737 : 0 : ZXDH_DTB_ITEM_ACK_SIZE) >> 32) & 0xffffffff;
6738 : 0 : addr_l = (ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, element_id) +
6739 : : ZXDH_DTB_ITEM_ACK_SIZE) & 0xffffffff;
6740 : :
6741 : 0 : *p_element_dump_addr_h = addr_h;
6742 : 0 : *p_element_dump_addr_l = addr_l;
6743 : :
6744 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, element_id,
6745 : : p_element_table_info_addr_h, p_element_table_info_addr_l);
6746 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_get");
6747 : :
6748 : 0 : return rc;
6749 : : }
6750 : :
6751 : : static uint32_t
6752 : 0 : zxdh_np_dtb_dump_table_element_info_prt(uint32_t dev_id,
6753 : : uint32_t queue_id,
6754 : : uint32_t element_id)
6755 : : {
6756 : : uint32_t rc = 0;
6757 : :
6758 : 0 : uint32_t element_start_addr_h = 0;
6759 : 0 : uint32_t element_start_addr_l = 0;
6760 : 0 : uint32_t element_dump_addr_h = 0;
6761 : 0 : uint32_t element_dump_addr_l = 0;
6762 : 0 : uint32_t element_table_info_addr_h = 0;
6763 : 0 : uint32_t element_table_info_addr_l = 0;
6764 : :
6765 : 0 : zxdh_np_dtb_dump_table_element_addr_get(dev_id,
6766 : : queue_id,
6767 : : element_id,
6768 : : &element_start_addr_h,
6769 : : &element_start_addr_l,
6770 : : &element_dump_addr_h,
6771 : : &element_dump_addr_l,
6772 : : &element_table_info_addr_h,
6773 : : &element_table_info_addr_l);
6774 : 0 : PMD_DRV_LOG(DEBUG, "queue_id %u.", queue_id);
6775 : 0 : PMD_DRV_LOG(DEBUG, "element_id %u.", element_id);
6776 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_h 0x%x.", element_start_addr_h);
6777 : 0 : PMD_DRV_LOG(DEBUG, "element_start_addr_l 0x%x.", element_start_addr_l);
6778 : 0 : PMD_DRV_LOG(DEBUG, "element_dump_addr_h 0x%x.", element_dump_addr_h);
6779 : 0 : PMD_DRV_LOG(DEBUG, "element_dump_addr_l 0x%x.", element_dump_addr_l);
6780 : 0 : PMD_DRV_LOG(DEBUG, "element_table_info_addr_h 0x%x.", element_table_info_addr_h);
6781 : 0 : PMD_DRV_LOG(DEBUG, "element_table_info_addr_l 0x%x.", element_table_info_addr_l);
6782 : :
6783 : 0 : rc = zxdh_np_dtb_item_ack_prt(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, element_id);
6784 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_prt");
6785 : :
6786 : 0 : rc = zxdh_np_dtb_item_buff_prt(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, element_id, 32);
6787 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_buff_prt");
6788 : :
6789 : 0 : return rc;
6790 : : }
6791 : :
6792 : : static uint32_t
6793 : 0 : zxdh_np_dtb_tab_up_success_status_check(uint32_t dev_id,
6794 : : uint32_t queue_id,
6795 : : uint32_t element_id)
6796 : : {
6797 : : uint32_t rc = 0;
6798 : : uint32_t rd_cnt = 0;
6799 : : uint32_t ack_value = 0;
6800 : : uint32_t success_flag = 0;
6801 : :
6802 : 0 : while (!success_flag) {
6803 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6804 : : element_id, 0, &ack_value);
6805 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_rd");
6806 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_np_dtb_item_ack_rd ack_value:0x%08x", ack_value);
6807 : :
6808 [ # # ]: 0 : if ((((ack_value >> 8) & 0xffffff) == ZXDH_DTB_TAB_UP_ACK_VLD_MASK) &&
6809 [ # # ]: 0 : ((ack_value & 0xff) == ZXDH_DTB_TAB_ACK_SUCCESS_MASK)) {
6810 : : success_flag = 1;
6811 : : break;
6812 : : }
6813 : :
6814 [ # # ]: 0 : if (rd_cnt > ZXDH_DTB_DUMP_OVER_TIME) {
6815 : 0 : PMD_DRV_LOG(ERR, "dump queue %u item %u overtime!", queue_id, element_id);
6816 : :
6817 : 0 : rc = zxdh_np_dtb_dump_table_element_info_prt(dev_id, queue_id, element_id);
6818 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_table_element_info_prt");
6819 : :
6820 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6821 : : element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
6822 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
6823 : :
6824 : 0 : return ZXDH_ERR;
6825 : : }
6826 : :
6827 : 0 : rd_cnt++;
6828 : 0 : rte_delay_us(ZXDH_DTB_DELAY_TIME);
6829 : : }
6830 : :
6831 : : return rc;
6832 : : }
6833 : :
6834 : : static uint32_t
6835 : 0 : zxdh_np_dtb_write_dump_desc_info(uint32_t dev_id,
6836 : : uint32_t queue_id,
6837 : : uint32_t queue_element_id,
6838 : : uint32_t *p_dump_info,
6839 : : uint32_t data_len,
6840 : : uint32_t desc_len,
6841 : : uint32_t *p_dump_data)
6842 : : {
6843 : : uint32_t dtb_interrupt_status = 0;
6844 : : uint32_t rc;
6845 : :
6846 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dump_data);
6847 : 0 : rc = zxdh_np_dtb_tab_up_info_set(dev_id,
6848 : : queue_id,
6849 : : queue_element_id,
6850 : : dtb_interrupt_status,
6851 : : data_len,
6852 : : desc_len,
6853 : : p_dump_info);
6854 [ # # ]: 0 : if (rc != 0) {
6855 : 0 : PMD_DRV_LOG(ERR, "queue %u element %u dump info set failed!",
6856 : : queue_id, queue_element_id);
6857 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
6858 : : queue_element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
6859 : : }
6860 : :
6861 : 0 : rc = zxdh_np_dtb_tab_up_success_status_check(dev_id,
6862 : : queue_id, queue_element_id);
6863 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_success_status_check");
6864 : :
6865 : 0 : rc = zxdh_np_dtb_tab_up_data_get(dev_id, queue_id, queue_element_id,
6866 : : data_len, p_dump_data);
6867 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_data_get");
6868 : :
6869 : 0 : PMD_DRV_LOG(DEBUG, "queue %u element %u dump done.", queue_id, queue_element_id);
6870 : :
6871 : 0 : return rc;
6872 : : }
6873 : :
6874 : : static uint32_t
6875 : 0 : zxdh_np_dtb_tab_up_free_item_get(uint32_t dev_id,
6876 : : uint32_t queue_id,
6877 : : uint32_t *p_item_index)
6878 : : {
6879 : : uint32_t ack_vale = 0;
6880 : : uint32_t item_index = 0;
6881 : 0 : uint32_t unused_item_num = 0;
6882 : : uint32_t i;
6883 : : ZXDH_SPINLOCK_T *p_spinlock = NULL;
6884 : :
6885 : : zxdh_np_dev_dtb_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_DTB, queue_id, &p_spinlock);
6886 : 0 : rte_spinlock_lock(&p_spinlock->spinlock);
6887 : :
6888 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6889 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init", queue_id);
6890 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6891 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6892 : : }
6893 : :
6894 : 0 : zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
6895 : :
6896 [ # # ]: 0 : if (unused_item_num == 0) {
6897 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6898 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
6899 : : }
6900 : :
6901 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
6902 : 0 : item_index = ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id) %
6903 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
6904 : :
6905 : : zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
6906 : : 0, &ack_vale);
6907 : :
6908 : 0 : ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id)++;
6909 : :
6910 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
6911 : : break;
6912 : : }
6913 : :
6914 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX) {
6915 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6916 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
6917 : : }
6918 : :
6919 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
6920 : : 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
6921 : :
6922 : 0 : *p_item_index = item_index;
6923 : :
6924 : : rte_spinlock_unlock(&p_spinlock->spinlock);
6925 : :
6926 : 0 : return 0;
6927 : : }
6928 : :
6929 : : static uint32_t
6930 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_user_addr_set(uint32_t dev_id,
6931 : : uint32_t queue_id,
6932 : : uint32_t item_index,
6933 : : uint64_t phy_addr,
6934 : : uint64_t vir_addr)
6935 : : {
6936 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
6937 : :
6938 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
6939 [ # # ]: 0 : if (p_dtb_mgr == NULL) {
6940 : 0 : PMD_DRV_LOG(ERR, "DTB Manager is not exist!");
6941 : 0 : return ZXDH_RC_DTB_MGR_NOT_EXIST;
6942 : : }
6943 : :
6944 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
6945 : 0 : PMD_DRV_LOG(ERR, "dtb queue %u is not init.", queue_id);
6946 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
6947 : : }
6948 : :
6949 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].phy_addr = phy_addr;
6950 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].vir_addr = vir_addr;
6951 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].user_flag =
6952 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE;
6953 : :
6954 : 0 : return ZXDH_OK;
6955 : : }
6956 : :
6957 : : static uint32_t
6958 : 0 : zxdh_np_dtb_dump_sdt_addr_get(uint32_t dev_id,
6959 : : uint32_t queue_id,
6960 : : uint32_t sdt_no,
6961 : : uint64_t *phy_addr,
6962 : : uint64_t *vir_addr,
6963 : : uint32_t *size)
6964 : : {
6965 : : uint32_t rc = ZXDH_OK;
6966 : :
6967 : 0 : ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {0};
6968 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
6969 : :
6970 : 0 : dtb_dump_addr_info.sdt_no = sdt_no;
6971 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
6972 : 0 : rc = zxdh_np_se_apt_rb_search(p_dtb_dump_addr_rb, &dtb_dump_addr_info,
6973 : : sizeof(ZXDH_DTB_ADDR_INFO_T));
6974 [ # # ]: 0 : if (rc == ZXDH_OK) {
6975 : 0 : PMD_DRV_LOG(INFO, "search sdt_no %u success.", sdt_no);
6976 : : } else {
6977 : 0 : PMD_DRV_LOG(ERR, "search sdt_no %u fail.", sdt_no);
6978 : 0 : return rc;
6979 : : }
6980 : :
6981 : 0 : *phy_addr = dtb_dump_addr_info.phy_addr;
6982 : 0 : *vir_addr = dtb_dump_addr_info.vir_addr;
6983 : 0 : *size = dtb_dump_addr_info.size;
6984 : :
6985 : 0 : return rc;
6986 : : }
6987 : :
6988 : : static uint32_t
6989 : 0 : zxdh_np_dtb_dump_addr_set(uint32_t dev_id,
6990 : : uint32_t queue_id,
6991 : : uint32_t sdt_no,
6992 : : uint32_t *element_id)
6993 : : {
6994 : : uint32_t rc = ZXDH_OK;
6995 : 0 : uint32_t dump_element_id = 0;
6996 : 0 : uint64_t phy_addr = 0;
6997 : 0 : uint64_t vir_addr = 0;
6998 : 0 : uint32_t size = 0;
6999 : :
7000 : 0 : rc = zxdh_np_dtb_dump_sdt_addr_get(dev_id,
7001 : : queue_id,
7002 : : sdt_no,
7003 : : &phy_addr,
7004 : : &vir_addr,
7005 : : &size);
7006 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_get");
7007 : 0 : memset((uint8_t *)vir_addr, 0, size);
7008 : :
7009 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &dump_element_id);
7010 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_free_item_get");
7011 : :
7012 : 0 : rc = zxdh_np_dtb_tab_up_item_user_addr_set(dev_id,
7013 : : queue_id,
7014 : : dump_element_id,
7015 : : phy_addr,
7016 : : vir_addr);
7017 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_set");
7018 : :
7019 : 0 : *element_id = dump_element_id;
7020 : :
7021 : 0 : return rc;
7022 : : }
7023 : :
7024 : : static uint32_t
7025 : 0 : zxdh_np_dtb_se_smmu0_dma_dump(uint32_t dev_id,
7026 : : uint32_t queue_id,
7027 : : uint32_t base_addr,
7028 : : uint32_t depth,
7029 : : uint32_t *p_data,
7030 : : uint32_t *element_id)
7031 : : {
7032 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
7033 : 0 : uint32_t dump_dst_phy_haddr = 0;
7034 : 0 : uint32_t dump_dst_phy_laddr = 0;
7035 : 0 : uint32_t queue_item_index = 0;
7036 : : uint32_t data_len;
7037 : : uint32_t desc_len;
7038 : : uint32_t rc;
7039 : :
7040 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &queue_item_index);
7041 [ # # ]: 0 : if (rc != 0) {
7042 : 0 : PMD_DRV_LOG(ERR, "dpp_dtb_tab_up_free_item_get failed = %u!", base_addr);
7043 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7044 : : }
7045 : :
7046 : 0 : *element_id = queue_item_index;
7047 : :
7048 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, queue_item_index,
7049 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
7050 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_tab_up_item_addr_get");
7051 : :
7052 : 0 : rc = zxdh_np_dtb_smmu0_dump_info_write(dev_id,
7053 : : base_addr,
7054 : : depth,
7055 : : dump_dst_phy_haddr,
7056 : : dump_dst_phy_laddr,
7057 : : (uint32_t *)form_buff);
7058 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_smmu0_dump_info_write");
7059 : :
7060 : 0 : data_len = depth * 128 / 32;
7061 : : desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
7062 : :
7063 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id, queue_id, queue_item_index,
7064 : : (uint32_t *)form_buff, data_len, desc_len, p_data);
7065 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_dump_desc_info");
7066 : :
7067 : : return rc;
7068 : : }
7069 : :
7070 : : static uint32_t
7071 : 0 : zxdh_np_dtb_eram_data_get(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no,
7072 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_eram_entry)
7073 : : {
7074 : 0 : uint32_t index = p_dump_eram_entry->index;
7075 : 0 : uint32_t *p_data = p_dump_eram_entry->p_data;
7076 : 0 : ZXDH_SDT_TBL_ERAM_T sdt_eram_info = {0};
7077 : 0 : uint32_t temp_data[4] = {0};
7078 : : uint32_t row_index = 0;
7079 : : uint32_t col_index = 0;
7080 : : uint32_t rd_mode;
7081 : : uint32_t rc;
7082 : : uint32_t eram_dump_base_addr = 0;
7083 : : uint32_t eram_base_addr = 0;
7084 : 0 : uint32_t element_id = 0;
7085 : :
7086 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
7087 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_eram_info);
7088 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_soft_sdt_tbl_get");
7089 : 0 : eram_base_addr = sdt_eram_info.eram_base_addr;
7090 [ # # # # ]: 0 : rd_mode = sdt_eram_info.eram_mode;
7091 : :
7092 : : zxdh_np_eram_index_cal(rd_mode, index, &row_index, &col_index);
7093 : :
7094 : 0 : eram_dump_base_addr = eram_base_addr + row_index;
7095 : :
7096 : 0 : rc = zxdh_np_dtb_se_smmu0_dma_dump(dev_id,
7097 : : queue_id,
7098 : : eram_dump_base_addr,
7099 : : 1,
7100 : : temp_data,
7101 : : &element_id);
7102 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_smmu0_dma_dump");
7103 : :
7104 [ # # # # ]: 0 : switch (rd_mode) {
7105 : : case ZXDH_ERAM128_TBL_128b:
7106 : : memcpy(p_data, temp_data, (128 / 8));
7107 : : break;
7108 : 0 : case ZXDH_ERAM128_TBL_64b:
7109 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
7110 : : break;
7111 : 0 : case ZXDH_ERAM128_TBL_1b:
7112 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
7113 : : (3 - col_index / 32)), (col_index % 32), 1);
7114 : 0 : break;
7115 : : default:
7116 : : break;
7117 : : }
7118 : :
7119 : 0 : PMD_DRV_LOG(DEBUG, "[eram_dump]std no:0x%x, index:0x%x, base addr:0x%x",
7120 : : sdt_no, p_dump_eram_entry->index, eram_dump_base_addr);
7121 [ # # ]: 0 : if (rd_mode == ZXDH_ERAM128_TBL_128b)
7122 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x 0x%08x 0x%08x]",
7123 : : p_dump_eram_entry->p_data[0], p_dump_eram_entry->p_data[1],
7124 : : p_dump_eram_entry->p_data[2], p_dump_eram_entry->p_data[3]);
7125 [ # # ]: 0 : else if (rd_mode == ZXDH_ERAM128_TBL_64b)
7126 : 0 : PMD_DRV_LOG(DEBUG, "value[0x%08x 0x%08x]",
7127 : : p_dump_eram_entry->p_data[0], p_dump_eram_entry->p_data[1]);
7128 : :
7129 : 0 : return rc;
7130 : : }
7131 : :
7132 : : static uint32_t
7133 : 0 : zxdh_np_dtb_se_zcam_dma_dump(uint32_t dev_id,
7134 : : uint32_t queue_id,
7135 : : uint32_t addr,
7136 : : uint32_t tb_width,
7137 : : uint32_t depth,
7138 : : uint32_t *p_data,
7139 : : uint32_t *element_id)
7140 : : {
7141 : : uint32_t rc = ZXDH_OK;
7142 : 0 : uint32_t dump_dst_phy_haddr = 0;
7143 : 0 : uint32_t dump_dst_phy_laddr = 0;
7144 : 0 : uint32_t queue_item_index = 0;
7145 : : uint32_t data_len = 0;
7146 : : uint32_t desc_len = 0;
7147 : : uint32_t tb_width_len = 0;
7148 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
7149 : :
7150 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &queue_item_index);
7151 [ # # ]: 0 : if (rc != ZXDH_OK) {
7152 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_dtb_tab_up_free_item_get failed!");
7153 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7154 : : }
7155 : :
7156 : 0 : PMD_DRV_LOG(DEBUG, "table up item queue_element_id is: %u.",
7157 : : queue_item_index);
7158 : :
7159 : 0 : *element_id = queue_item_index;
7160 : :
7161 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, queue_item_index,
7162 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
7163 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_get");
7164 : :
7165 : 0 : rc = zxdh_np_dtb_zcam_dump_info_write(dev_id,
7166 : : addr,
7167 : : tb_width,
7168 : : depth,
7169 : : dump_dst_phy_haddr,
7170 : : dump_dst_phy_laddr,
7171 : : (uint32_t *)form_buff);
7172 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_zcam_dump_info_write");
7173 : :
7174 : 0 : tb_width_len = ZXDH_DTB_LEN_POS_SETP << tb_width;
7175 : 0 : data_len = depth * tb_width_len / 4;
7176 : : desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
7177 : :
7178 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id, queue_id, queue_item_index,
7179 : : (uint32_t *)form_buff, data_len, desc_len, p_data);
7180 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_write_dump_desc_info");
7181 : :
7182 : : return rc;
7183 : : }
7184 : :
7185 : : static uint32_t
7186 : 0 : zxdh_np_dtb_hash_data_parse(uint32_t item_type,
7187 : : uint32_t key_by_size,
7188 : : ZXDH_HASH_ENTRY *p_entry,
7189 : : uint8_t *p_item_data,
7190 : : uint32_t *p_data_offset)
7191 : : {
7192 : : uint32_t data_offset = 0;
7193 : : uint8_t temp_key_valid = 0;
7194 : : uint8_t temp_key_type = 0;
7195 : : uint32_t temp_entry_size = 0;
7196 : : uint8_t srh_key_type = 0;
7197 : : uint32_t srh_entry_size = 0;
7198 : : uint32_t rst_by_size = 0;
7199 : : uint8_t srh_succ = 0;
7200 : : uint32_t item_width = ZXDH_SE_ITEM_WIDTH_MAX;
7201 : : uint8_t *p_srh_key = NULL;
7202 : : uint8_t *p_temp_key = NULL;
7203 : :
7204 [ # # ]: 0 : if (item_type == ZXDH_ITEM_DDR_256)
7205 : : item_width = item_width / 2;
7206 : :
7207 : : p_temp_key = p_item_data;
7208 : 0 : p_srh_key = p_entry->p_key;
7209 : 0 : srh_key_type = ZXDH_GET_HASH_KEY_TYPE(p_srh_key);
7210 [ # # ]: 0 : srh_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(srh_key_type);
7211 : :
7212 [ # # ]: 0 : while (data_offset < item_width) {
7213 : 0 : temp_key_valid = ZXDH_GET_HASH_KEY_VALID(p_temp_key);
7214 : 0 : temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_temp_key);
7215 : :
7216 [ # # ]: 0 : if (temp_key_valid && srh_key_type == temp_key_type) {
7217 [ # # ]: 0 : if (memcmp(p_srh_key, p_temp_key, key_by_size) == 0) {
7218 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware successfully.");
7219 : : srh_succ = 1;
7220 : : break;
7221 : : }
7222 : :
7223 : 0 : data_offset += srh_entry_size;
7224 [ # # ]: 0 : } else if (temp_key_valid && (srh_key_type != temp_key_type)) {
7225 [ # # ]: 0 : temp_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(temp_key_type);
7226 : 0 : data_offset += temp_entry_size;
7227 : : } else {
7228 : 0 : data_offset += ZXDH_HASH_ENTRY_POS_STEP;
7229 : : }
7230 : :
7231 : : p_temp_key = p_item_data;
7232 : 0 : p_temp_key += data_offset;
7233 : : }
7234 : :
7235 : : if (!srh_succ) {
7236 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware fail.");
7237 : 0 : return ZXDH_HASH_RC_MATCH_ITEM_FAIL;
7238 : : }
7239 : :
7240 : 0 : rst_by_size = srh_entry_size - key_by_size;
7241 : 0 : memcpy(p_entry->p_rst, p_temp_key + key_by_size,
7242 : 0 : (rst_by_size > ZXDH_HASH_RST_MAX) ? ZXDH_HASH_RST_MAX : rst_by_size);
7243 : 0 : *p_data_offset = data_offset;
7244 : :
7245 : 0 : return ZXDH_OK;
7246 : : }
7247 : :
7248 : : static uint32_t
7249 : 0 : zxdh_np_dtb_hash_zcam_get_hardware(uint32_t dev_id,
7250 : : uint32_t queue_id,
7251 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
7252 : : ZXDH_HASH_ENTRY *p_hash_entry,
7253 : : uint8_t *p_srh_succ)
7254 : : {
7255 : : uint32_t rc = ZXDH_OK;
7256 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
7257 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
7258 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
7259 : : uint32_t zblk_idx = 0;
7260 : : uint32_t pre_zblk_idx = 0xFFFFFFFF;
7261 : : uint16_t crc16_value = 0;
7262 : : uint32_t zcell_id = 0;
7263 : : uint32_t item_idx = 0;
7264 : 0 : uint32_t element_id = 0;
7265 : 0 : uint32_t byte_offset = 0;
7266 : : uint32_t addr = 0;
7267 : : uint32_t i = 0;
7268 : : uint8_t srh_succ = 0;
7269 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
7270 : 0 : uint8_t rd_buff[ZXDH_SE_ITEM_WIDTH_MAX] = {0};
7271 : : ZXDH_D_NODE *p_zblk_dn = NULL;
7272 : : ZXDH_D_NODE *p_zcell_dn = NULL;
7273 : : ZXDH_SE_CFG *p_se_cfg = NULL;
7274 : :
7275 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
7276 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
7277 : :
7278 : 0 : p_se_cfg = p_hash_entry_cfg->p_se_cfg;
7279 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
7280 : :
7281 : 0 : zxdh_np_hash_set_crc_key(p_hash_entry_cfg, p_hash_entry, temp_key);
7282 : :
7283 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
7284 [ # # ]: 0 : while (p_zcell_dn) {
7285 : 0 : p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
7286 : 0 : zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
7287 : : p_zblk = &p_se_cfg->zblk_info[zblk_idx];
7288 : :
7289 [ # # ]: 0 : if (zblk_idx != pre_zblk_idx) {
7290 : : pre_zblk_idx = zblk_idx;
7291 : 0 : crc16_value = p_hash_cfg->p_hash16_fun(temp_key,
7292 : 0 : p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
7293 : : }
7294 : :
7295 : 0 : zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
7296 : 0 : item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc16_value);
7297 : 0 : addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
7298 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
7299 : : queue_id,
7300 : : addr,
7301 : : ZXDH_DTB_DUMP_ZCAM_512b,
7302 : : 1,
7303 : : (uint32_t *)rd_buff,
7304 : : &element_id);
7305 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
7306 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
7307 : :
7308 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM, p_hash_entry_cfg->key_by_size,
7309 : : p_hash_entry, rd_buff, &byte_offset);
7310 [ # # ]: 0 : if (rc == ZXDH_OK) {
7311 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zcell.");
7312 : : srh_succ = 1;
7313 : 0 : p_hash_cfg->hash_stat.search_ok++;
7314 : : break;
7315 : : }
7316 : :
7317 : 0 : p_zcell_dn = p_zcell_dn->next;
7318 : : }
7319 : :
7320 : : if (srh_succ == 0) {
7321 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
7322 [ # # ]: 0 : while (p_zblk_dn) {
7323 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
7324 : 0 : zblk_idx = p_zblk->zblk_idx;
7325 : :
7326 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
7327 : : item_idx = i;
7328 : 0 : addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx, item_idx);
7329 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
7330 : : queue_id,
7331 : : addr,
7332 : : ZXDH_DTB_DUMP_ZCAM_512b,
7333 : : 1,
7334 : : (uint32_t *)rd_buff,
7335 : : &element_id);
7336 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
7337 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
7338 : :
7339 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM,
7340 : : p_hash_entry_cfg->key_by_size, p_hash_entry,
7341 : : rd_buff, &byte_offset);
7342 [ # # ]: 0 : if (rc == ZXDH_OK) {
7343 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zreg.");
7344 : : srh_succ = 1;
7345 : 0 : p_hash_cfg->hash_stat.search_ok++;
7346 : 0 : break;
7347 : : }
7348 : : }
7349 : 0 : p_zblk_dn = p_zblk_dn->next;
7350 : : }
7351 : : }
7352 : :
7353 : 0 : *p_srh_succ = srh_succ;
7354 : :
7355 : 0 : return rc;
7356 : : }
7357 : :
7358 : : static uint32_t
7359 : 0 : zxdh_np_dtb_hash_software_item_check(ZXDH_HASH_ENTRY *p_entry,
7360 : : uint32_t key_by_size,
7361 : : uint32_t rst_by_size,
7362 : : ZXDH_SE_ITEM_CFG *p_item_info)
7363 : : {
7364 : : uint8_t srh_succ = 0;
7365 : : uint8_t temp_key_type = 0;
7366 : : uint8_t srh_key_type = 0;
7367 : : uint32_t dev_id = 0;
7368 : : ZXDH_D_NODE *p_entry_dn = NULL;
7369 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
7370 : :
7371 : 0 : srh_key_type = ZXDH_GET_HASH_KEY_TYPE(p_entry->p_key);
7372 : 0 : p_entry_dn = p_item_info->item_list.p_next;
7373 [ # # ]: 0 : while (p_entry_dn) {
7374 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_entry_dn->data;
7375 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rbkey);
7376 : :
7377 : : RTE_ASSERT(p_rbkey->p_item_info == p_item_info);
7378 : :
7379 : 0 : temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
7380 : :
7381 [ # # # # ]: 0 : if (ZXDH_GET_HASH_KEY_VALID(p_rbkey->key) && srh_key_type == temp_key_type) {
7382 [ # # ]: 0 : if (memcmp(p_entry->p_key, p_rbkey->key, key_by_size) == 0) {
7383 : : srh_succ = 1;
7384 : : break;
7385 : : }
7386 : : }
7387 : :
7388 : 0 : p_entry_dn = p_entry_dn->next;
7389 : : }
7390 : :
7391 [ # # ]: 0 : if (p_rbkey == NULL)
7392 : : return ZXDH_PAR_CHK_POINT_NULL;
7393 : :
7394 [ # # ]: 0 : if (!srh_succ) {
7395 : 0 : PMD_DRV_LOG(DEBUG, "hash search failed!");
7396 : 0 : return ZXDH_HASH_RC_MATCH_ITEM_FAIL;
7397 : : }
7398 : :
7399 : 0 : memcpy(p_entry->p_rst, p_rbkey->rst,
7400 : 0 : (rst_by_size > ZXDH_HASH_RST_MAX) ? ZXDH_HASH_RST_MAX : rst_by_size);
7401 : :
7402 : 0 : return ZXDH_OK;
7403 : : }
7404 : :
7405 : : static uint32_t
7406 : 0 : zxdh_np_dtb_hash_get_software(uint32_t dev_id,
7407 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
7408 : : ZXDH_HASH_ENTRY *p_hash_entry,
7409 : : uint8_t *p_srh_succ)
7410 : : {
7411 : : uint32_t rc = ZXDH_OK;
7412 : 0 : ZXDH_HASH_RBKEY_INFO srh_rbkey = {0};
7413 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
7414 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
7415 : : ZXDH_SE_ITEM_CFG *p_item = NULL;
7416 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
7417 : : ZXDH_SPINLOCK_T *p_hash_spinlock = NULL;
7418 : :
7419 [ # # ]: 0 : memcpy(srh_rbkey.key, p_hash_entry->p_key, p_hash_entry_cfg->key_by_size);
7420 : :
7421 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
7422 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
7423 : :
7424 : 0 : zxdh_np_dev_hash_opr_spinlock_get(dev_id, p_hash_cfg->fun_id, &p_hash_spinlock);
7425 : 0 : rte_spinlock_lock(&p_hash_spinlock->spinlock);
7426 : :
7427 : 0 : rc = zxdh_comm_rb_search(&p_hash_cfg->hash_rb, (void *)&srh_rbkey, (void *)(&p_rb_tn_rtn));
7428 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_SRHFAIL) {
7429 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_comm_rb_search fail.");
7430 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
7431 : 0 : return ZXDH_OK;
7432 : : }
7433 : :
7434 : 0 : p_rbkey = p_rb_tn_rtn->p_key;
7435 : 0 : p_item = p_rbkey->p_item_info;
7436 : :
7437 : 0 : rc = zxdh_np_dtb_hash_software_item_check(p_hash_entry,
7438 : : p_hash_entry_cfg->key_by_size,
7439 : : p_hash_entry_cfg->rst_by_size,
7440 : : p_item);
7441 [ # # ]: 0 : if (rc == ZXDH_OK) {
7442 : 0 : PMD_DRV_LOG(DEBUG, "Hash search software succ.");
7443 : 0 : *p_srh_succ = 1;
7444 : 0 : p_hash_cfg->hash_stat.search_ok++;
7445 : : }
7446 : :
7447 : : rte_spinlock_unlock(&p_hash_spinlock->spinlock);
7448 : 0 : return rc;
7449 : : }
7450 : :
7451 : : static uint32_t
7452 : 0 : zxdh_np_dtb_hash_zcam_get(uint32_t dev_id,
7453 : : uint32_t queue_id,
7454 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
7455 : : ZXDH_HASH_ENTRY *p_hash_entry,
7456 : : uint32_t srh_mode,
7457 : : uint8_t *p_srh_succ)
7458 : : {
7459 : : uint32_t rc = ZXDH_OK;
7460 : :
7461 [ # # ]: 0 : if (srh_mode == ZXDH_HASH_SRH_MODE_HDW) {
7462 : 0 : rc = zxdh_np_dtb_hash_zcam_get_hardware(dev_id, queue_id,
7463 : : p_hash_entry_cfg, p_hash_entry, p_srh_succ);
7464 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_zcam_get_hardware");
7465 : : } else {
7466 : 0 : rc = zxdh_np_dtb_hash_get_software(dev_id, p_hash_entry_cfg,
7467 : : p_hash_entry, p_srh_succ);
7468 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_get_software");
7469 : : }
7470 : :
7471 : 0 : return rc;
7472 : : }
7473 : :
7474 : : static uint32_t
7475 : 0 : zxdh_np_dtb_hash_data_get(uint32_t dev_id,
7476 : : uint32_t queue_id,
7477 : : uint32_t sdt_no,
7478 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry,
7479 : : uint32_t srh_mode)
7480 : : {
7481 : : uint32_t rc = ZXDH_OK;
7482 : 0 : uint8_t srh_succ = 0;
7483 : : uint8_t key_valid = 1;
7484 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
7485 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
7486 : 0 : ZXDH_HASH_ENTRY hash_entry = {0};
7487 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
7488 : 0 : uint8_t temp_rst[ZXDH_HASH_RST_MAX] = {0};
7489 : :
7490 : 0 : PMD_DRV_LOG(DEBUG, "hash get sdt_no:%u", sdt_no);
7491 : :
7492 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
7493 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
7494 : :
7495 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
7496 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
7497 : :
7498 : 0 : hash_entry.p_key = temp_key;
7499 : 0 : hash_entry.p_rst = temp_rst;
7500 : 0 : hash_entry.p_key[0] = ZXDH_GET_HASH_KEY_CTRL(key_valid,
7501 : : hash_entry_cfg.key_type,
7502 : : hash_entry_cfg.table_id);
7503 : :
7504 : 0 : memcpy(&hash_entry.p_key[1], p_dtb_hash_entry->p_actu_key,
7505 : 0 : hash_entry_cfg.actu_key_size);
7506 : :
7507 : : if (!srh_succ) {
7508 : 0 : rc = zxdh_np_dtb_hash_zcam_get(dev_id, queue_id, &hash_entry_cfg,
7509 : : &hash_entry, srh_mode, &srh_succ);
7510 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_zcam_get");
7511 : : }
7512 : :
7513 [ # # ]: 0 : if (!srh_succ) {
7514 : 0 : p_hash_cfg->hash_stat.search_fail++;
7515 : 0 : PMD_DRV_LOG(DEBUG, "Hash search key fail!");
7516 : 0 : return ZXDH_HASH_RC_SRH_FAIL;
7517 : : }
7518 : :
7519 : 0 : memcpy(p_dtb_hash_entry->p_rst, hash_entry.p_rst,
7520 : 0 : 1 << (hash_entry_cfg.rsp_mode + 2));
7521 : :
7522 : 0 : return rc;
7523 : : }
7524 : :
7525 : : static void
7526 : : dtb_etcam_dump_data_len(uint32_t etcam_key_mode,
7527 : : uint32_t *p_etcam_dump_len,
7528 : : uint32_t *p_etcam_dump_inerval)
7529 : : {
7530 : : uint32_t dump_data_len = 0;
7531 : : uint8_t etcam_dump_inerval = 0;
7532 : :
7533 [ # # ]: 0 : if (ZXDH_ETCAM_KEY_640b == etcam_key_mode) {
7534 : : dump_data_len = 5 * ZXDH_DTB_LEN_POS_SETP;
7535 : : etcam_dump_inerval = 0;
7536 [ # # ]: 0 : } else if (ZXDH_ETCAM_KEY_320b == etcam_key_mode) {
7537 : : dump_data_len = 3 * ZXDH_DTB_LEN_POS_SETP;
7538 : : etcam_dump_inerval = 8;
7539 [ # # ]: 0 : } else if (ZXDH_ETCAM_KEY_160b == etcam_key_mode) {
7540 : : dump_data_len = 2 * ZXDH_DTB_LEN_POS_SETP;
7541 : : etcam_dump_inerval = 12;
7542 [ # # ]: 0 : } else if (ZXDH_ETCAM_KEY_80b == etcam_key_mode) {
7543 : : dump_data_len = 1 * ZXDH_DTB_LEN_POS_SETP;
7544 : : etcam_dump_inerval = 6;
7545 : : }
7546 : :
7547 : : *p_etcam_dump_len = dump_data_len;
7548 : 0 : *p_etcam_dump_inerval = etcam_dump_inerval;
7549 : : }
7550 : :
7551 : : static void
7552 : 0 : zxdh_np_dtb_get_etcam_xy_from_dump_data(uint8_t *p_data,
7553 : : uint8_t *p_mask,
7554 : : uint32_t etcam_dump_len,
7555 : : uint32_t etcam_dump_inerval,
7556 : : ZXDH_ETCAM_ENTRY_T *p_entry_xy)
7557 : : {
7558 : : uint8_t *p_entry_data = NULL;
7559 : : uint8_t *p_entry_mask = NULL;
7560 : :
7561 : 0 : zxdh_np_comm_swap(p_data, etcam_dump_len);
7562 : 0 : zxdh_np_comm_swap(p_mask, etcam_dump_len);
7563 : :
7564 : 0 : p_entry_data = p_data + etcam_dump_inerval;
7565 : 0 : p_entry_mask = p_mask + etcam_dump_inerval;
7566 : :
7567 : 0 : memcpy(p_entry_xy->p_data, p_entry_data,
7568 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry_xy->mode));
7569 : 0 : memcpy(p_entry_xy->p_mask, p_entry_mask,
7570 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry_xy->mode));
7571 : 0 : }
7572 : :
7573 : :
7574 : : static void
7575 : : zxdh_np_etcam_xy_to_dm(ZXDH_ETCAM_ENTRY_T *p_dm,
7576 : : ZXDH_ETCAM_ENTRY_T *p_xy,
7577 : : uint32_t len)
7578 : : {
7579 : : uint32_t i = 0;
7580 : :
7581 : : RTE_ASSERT(p_dm->p_data && p_dm->p_mask && p_xy->p_data && p_xy->p_mask);
7582 : :
7583 [ # # ]: 0 : for (i = 0; i < len; i++) {
7584 : 0 : p_dm->p_data[i] = ZXDH_COMM_XY_TO_DATA(p_xy->p_data[i], p_xy->p_mask[i]);
7585 : 0 : p_dm->p_mask[i] = ZXDH_COMM_XY_TO_MASK(p_xy->p_data[i], p_xy->p_mask[i]);
7586 : : }
7587 : : }
7588 : :
7589 : : static uint32_t
7590 : 0 : zxdh_np_dtb_etcam_entry_get(uint32_t dev_id,
7591 : : uint32_t queue_id,
7592 : : uint32_t block_idx,
7593 : : uint32_t addr,
7594 : : uint32_t rd_mode,
7595 : : uint32_t opr_type,
7596 : : uint32_t as_en,
7597 : : uint32_t as_eram_baddr,
7598 : : uint32_t as_eram_index,
7599 : : uint32_t as_rsp_mode,
7600 : : ZXDH_ETCAM_ENTRY_T *p_entry,
7601 : : uint8_t *p_as_rslt)
7602 : : {
7603 : : uint32_t rc = ZXDH_OK;
7604 : :
7605 : : uint32_t etcam_key_mode = 0;
7606 : :
7607 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7608 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7609 : 0 : ZXDH_ETCAM_ENTRY_T entry_xy = {0};
7610 : :
7611 : : uint32_t etcam_data_dst_phy_haddr = 0;
7612 : : uint32_t etcam_data_dst_phy_laddr = 0;
7613 : : uint32_t etcam_mask_dst_phy_haddr = 0;
7614 : : uint32_t etcam_mask_dst_phy_laddr = 0;
7615 : : uint32_t as_rst_dst_phy_haddr = 0;
7616 : : uint32_t as_rst_dst_phy_laddr = 0;
7617 : :
7618 : 0 : uint32_t dump_element_id = 0;
7619 : : uint32_t etcam_dump_one_data_len = 0;
7620 : : uint32_t etcam_dump_inerval = 0;
7621 : : uint32_t dtb_desc_addr_offset = 0;
7622 : : uint32_t dump_data_len = 0;
7623 : : uint32_t dtb_desc_len = 0;
7624 : :
7625 : : uint32_t eram_dump_base_addr = 0;
7626 : : uint32_t row_index = 0;
7627 : : uint32_t col_index = 0;
7628 : :
7629 : : uint8_t *p_data = NULL;
7630 : : uint8_t *p_mask = NULL;
7631 : : uint8_t *p_rst = NULL;
7632 : : uint8_t *temp_dump_out_data = NULL;
7633 : : uint8_t *dump_info_buff = NULL;
7634 : 0 : ZXDH_ETCAM_DUMP_INFO_T etcam_dump_info = {0};
7635 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
7636 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
7637 : :
7638 : 0 : dtb_dump_entry.cmd = cmd_buff;
7639 : :
7640 : 0 : entry_xy.p_data = temp_data;
7641 : 0 : entry_xy.p_mask = temp_mask;
7642 : :
7643 : 0 : etcam_key_mode = p_entry->mode;
7644 : :
7645 : 0 : etcam_dump_info.block_sel = block_idx;
7646 : 0 : etcam_dump_info.addr = addr;
7647 : 0 : etcam_dump_info.tb_width = 3 - etcam_key_mode;
7648 : 0 : etcam_dump_info.rd_mode = rd_mode;
7649 : 0 : etcam_dump_info.tb_depth = 1;
7650 : :
7651 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &dump_element_id);
7652 [ # # ]: 0 : if (rc != ZXDH_OK) {
7653 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_dtb_tab_up_free_item_get failed!");
7654 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
7655 : : }
7656 : :
7657 : : dtb_etcam_dump_data_len(etcam_key_mode, &etcam_dump_one_data_len, &etcam_dump_inerval);
7658 : :
7659 : 0 : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_DATA;
7660 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
7661 : : queue_id,
7662 : : dump_element_id,
7663 : : dump_data_len,
7664 : : &etcam_data_dst_phy_haddr,
7665 : : &etcam_data_dst_phy_laddr);
7666 : :
7667 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
7668 : : &etcam_dump_info,
7669 : : etcam_data_dst_phy_haddr,
7670 : : etcam_data_dst_phy_laddr,
7671 : : &dtb_dump_entry);
7672 : :
7673 : 0 : dump_info_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
7674 [ # # ]: 0 : if (dump_info_buff == NULL) {
7675 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
7676 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
7677 : : }
7678 : :
7679 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
7680 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
7681 : : dtb_desc_len += 1;
7682 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
7683 : : dump_data_len += etcam_dump_one_data_len;
7684 : :
7685 [ # # ]: 0 : etcam_dump_info.data_or_mask = ZXDH_ETCAM_DTYPE_MASK;
7686 : : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
7687 : : queue_id,
7688 : : dump_element_id,
7689 : : dump_data_len,
7690 : : &etcam_mask_dst_phy_haddr,
7691 : : &etcam_mask_dst_phy_laddr);
7692 : :
7693 : : zxdh_np_dtb_etcam_dump_entry(dev_id,
7694 : : &etcam_dump_info,
7695 : : etcam_mask_dst_phy_haddr,
7696 : : etcam_mask_dst_phy_laddr,
7697 : : &dtb_dump_entry);
7698 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
7699 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
7700 : : dtb_desc_len += 1;
7701 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
7702 : 0 : dump_data_len += etcam_dump_one_data_len;
7703 : :
7704 [ # # ]: 0 : if (as_en) {
7705 : : zxdh_np_eram_index_cal(as_rsp_mode, as_eram_index, &row_index, &col_index);
7706 : :
7707 [ # # ]: 0 : eram_dump_base_addr = as_eram_baddr + row_index;
7708 : : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
7709 : : queue_id,
7710 : : dump_element_id,
7711 : : dump_data_len,
7712 : : &as_rst_dst_phy_haddr,
7713 : : &as_rst_dst_phy_laddr);
7714 : :
7715 : 0 : zxdh_np_dtb_smmu0_dump_entry(dev_id,
7716 : : eram_dump_base_addr,
7717 : : 1,
7718 : : as_rst_dst_phy_haddr,
7719 : : as_rst_dst_phy_laddr,
7720 : : &dtb_dump_entry);
7721 : 0 : zxdh_np_dtb_data_write(dump_info_buff, dtb_desc_addr_offset, &dtb_dump_entry);
7722 : : memset(cmd_buff, 0, ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8);
7723 : : dtb_desc_len += 1;
7724 : : dtb_desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
7725 : 0 : dump_data_len += ZXDH_DTB_LEN_POS_SETP;
7726 : : }
7727 : :
7728 : 0 : temp_dump_out_data = rte_zmalloc(NULL, dump_data_len, 0);
7729 [ # # ]: 0 : if (temp_dump_out_data == NULL) {
7730 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
7731 : 0 : rte_free(dump_info_buff);
7732 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
7733 : : }
7734 : : p_data = temp_dump_out_data;
7735 : :
7736 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id,
7737 : : queue_id,
7738 : : dump_element_id,
7739 : : (uint32_t *)dump_info_buff,
7740 : : dump_data_len / 4,
7741 : : dtb_desc_len * 4,
7742 : : (uint32_t *)temp_dump_out_data);
7743 : :
7744 : : p_data = temp_dump_out_data;
7745 : 0 : p_mask = p_data + etcam_dump_one_data_len;
7746 : :
7747 : 0 : zxdh_np_dtb_get_etcam_xy_from_dump_data(p_data,
7748 : : p_mask,
7749 : : etcam_dump_one_data_len,
7750 : : etcam_dump_inerval,
7751 : : &entry_xy);
7752 : :
7753 [ # # ]: 0 : if (opr_type == ZXDH_ETCAM_OPR_DM) {
7754 : 0 : zxdh_np_etcam_xy_to_dm(p_entry, &entry_xy,
7755 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
7756 : : } else {
7757 : 0 : memcpy(p_entry->p_data, entry_xy.p_data,
7758 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
7759 : 0 : memcpy(p_entry->p_mask, entry_xy.p_mask,
7760 : 0 : ZXDH_ETCAM_ENTRY_SIZE_GET(p_entry->mode));
7761 : : }
7762 : :
7763 [ # # ]: 0 : if (as_en) {
7764 : 0 : p_rst = p_mask + etcam_dump_one_data_len;
7765 : : memcpy(p_as_rslt, p_rst, (128 / 8));
7766 : : }
7767 : :
7768 : 0 : rte_free(dump_info_buff);
7769 : 0 : rte_free(temp_dump_out_data);
7770 : :
7771 : 0 : return rc;
7772 : : }
7773 : :
7774 : : static uint32_t
7775 : 0 : zxdh_np_etcam_entry_cmp(ZXDH_ETCAM_ENTRY_T *p_entry_dm, ZXDH_ETCAM_ENTRY_T *p_entry_xy)
7776 : : {
7777 : : uint32_t data_mask_len = 0;
7778 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7779 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7780 : 0 : ZXDH_ETCAM_ENTRY_T entry_xy_temp = {0};
7781 : :
7782 : 0 : entry_xy_temp.mode = p_entry_dm->mode;
7783 : 0 : entry_xy_temp.p_data = temp_data;
7784 : 0 : entry_xy_temp.p_mask = temp_mask;
7785 : :
7786 : 0 : data_mask_len = ZXDH_ETCAM_ENTRY_SIZE_GET(entry_xy_temp.mode);
7787 : :
7788 : 0 : zxdh_np_etcam_dm_to_xy(p_entry_dm, &entry_xy_temp, data_mask_len);
7789 : :
7790 [ # # ]: 0 : if ((memcmp(entry_xy_temp.p_data, p_entry_xy->p_data, data_mask_len) != 0) ||
7791 [ # # ]: 0 : (memcmp(entry_xy_temp.p_mask, p_entry_xy->p_mask, data_mask_len) != 0)) {
7792 : 0 : return ZXDH_ERR;
7793 : : }
7794 : :
7795 : : return ZXDH_OK;
7796 : : }
7797 : :
7798 : : static uint32_t
7799 : 0 : zxdh_np_dtb_acl_data_get(uint32_t dev_id,
7800 : : uint32_t queue_id,
7801 : : uint32_t sdt_no,
7802 : : ZXDH_DTB_ACL_ENTRY_INFO_T *p_dump_acl_entry)
7803 : : {
7804 : : uint32_t rc = ZXDH_OK;
7805 : 0 : uint32_t block_idx = 0;
7806 : 0 : uint32_t ram_addr = 0;
7807 : 0 : uint32_t etcam_wr_mode = 0;
7808 : : uint32_t etcam_key_mode = 0;
7809 : : uint32_t etcam_table_id = 0;
7810 : : uint32_t as_enable = 0;
7811 : : uint32_t as_eram_baddr = 0;
7812 : : uint32_t etcam_as_mode = 0;
7813 : : uint32_t row_index = 0;
7814 : : uint32_t col_index = 0;
7815 : :
7816 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry_dm = {0};
7817 : 0 : ZXDH_ETCAM_ENTRY_T etcam_entry_xy = {0};
7818 : 0 : uint32_t as_eram_data[4] = {0};
7819 : 0 : uint8_t temp_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7820 : 0 : uint8_t temp_mask[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
7821 : :
7822 : 0 : ZXDH_ACL_CFG_EX_T *p_acl_cfg = NULL;
7823 : : ZXDH_ACL_TBL_CFG_T *p_tbl_cfg = NULL;
7824 : :
7825 : 0 : ZXDH_SDT_TBL_ETCAM_T sdt_etcam_info = {0};
7826 : :
7827 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
7828 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_etcam_info);
7829 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
7830 : 0 : etcam_key_mode = sdt_etcam_info.etcam_key_mode;
7831 : 0 : etcam_as_mode = sdt_etcam_info.as_rsp_mode;
7832 : 0 : etcam_table_id = sdt_etcam_info.etcam_table_id;
7833 : 0 : as_enable = sdt_etcam_info.as_en;
7834 : 0 : as_eram_baddr = sdt_etcam_info.as_eram_baddr;
7835 : :
7836 : 0 : etcam_entry_xy.mode = etcam_key_mode;
7837 : 0 : etcam_entry_xy.p_data = temp_data;
7838 : 0 : etcam_entry_xy.p_mask = temp_mask;
7839 : 0 : etcam_entry_dm.mode = etcam_key_mode;
7840 : 0 : etcam_entry_dm.p_data = p_dump_acl_entry->key_data;
7841 : 0 : etcam_entry_dm.p_mask = p_dump_acl_entry->key_mask;
7842 : :
7843 : 0 : zxdh_np_acl_cfg_get(dev_id, &p_acl_cfg);
7844 : :
7845 : 0 : p_tbl_cfg = p_acl_cfg->acl_tbls + etcam_table_id;
7846 : :
7847 [ # # ]: 0 : if (!p_tbl_cfg->is_used) {
7848 : 0 : PMD_DRV_LOG(ERR, "table[ %u ] is not init!", etcam_table_id);
7849 : : RTE_ASSERT(0);
7850 : 0 : return ZXDH_ACL_RC_TBL_NOT_INIT;
7851 : : }
7852 : :
7853 : 0 : zxdh_np_acl_hdw_addr_get(p_tbl_cfg, p_dump_acl_entry->handle,
7854 : : &block_idx, &ram_addr, &etcam_wr_mode);
7855 : :
7856 : 0 : rc = zxdh_np_dtb_etcam_entry_get(dev_id,
7857 : : queue_id,
7858 : : block_idx,
7859 : : ram_addr,
7860 : : etcam_wr_mode,
7861 : : ZXDH_ETCAM_OPR_XY,
7862 : : as_enable,
7863 : : as_eram_baddr,
7864 : : p_dump_acl_entry->handle,
7865 : : etcam_as_mode,
7866 : : &etcam_entry_xy,
7867 : : (uint8_t *)as_eram_data);
7868 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_etcam_entry_get");
7869 : :
7870 [ # # ]: 0 : if (zxdh_np_etcam_entry_cmp(&etcam_entry_dm, &etcam_entry_xy) == 0) {
7871 : 0 : PMD_DRV_LOG(DEBUG, "get done, handle:0x%x block:%u ram_addr:%u rd_mode:%x",
7872 : : p_dump_acl_entry->handle, block_idx, ram_addr, etcam_wr_mode);
7873 : : } else {
7874 : 0 : PMD_DRV_LOG(DEBUG, "get fail, handle:0x%x block:%u ram_addr:%u rd_mode:%x",
7875 : : p_dump_acl_entry->handle, block_idx, ram_addr, etcam_wr_mode);
7876 : :
7877 : 0 : return ZXDH_ERR;
7878 : : }
7879 : :
7880 [ # # ]: 0 : if (as_enable) {
7881 [ # # # ]: 0 : zxdh_np_eram_index_cal(etcam_as_mode, p_dump_acl_entry->handle,
7882 : : &row_index, &col_index);
7883 [ # # # # ]: 0 : switch (etcam_as_mode) {
7884 : 0 : case ZXDH_ERAM128_TBL_128b:
7885 : 0 : memcpy(p_dump_acl_entry->p_as_rslt, as_eram_data, (128 / 8));
7886 : : break;
7887 : :
7888 : 0 : case ZXDH_ERAM128_TBL_64b:
7889 : 0 : memcpy(p_dump_acl_entry->p_as_rslt, as_eram_data +
7890 : 0 : ((1 - col_index) << 1), (64 / 8));
7891 : : break;
7892 : :
7893 : 0 : case ZXDH_ERAM128_TBL_1b:
7894 : 0 : ZXDH_COMM_UINT32_GET_BITS(*(uint32_t *)p_dump_acl_entry->p_as_rslt,
7895 : : *(as_eram_data + (3 - col_index / 32)), (col_index % 32), 1);
7896 : 0 : break;
7897 : : default:
7898 : : break;
7899 : : }
7900 : : }
7901 : :
7902 : : return rc;
7903 : : }
7904 : :
7905 : : int
7906 : 0 : zxdh_np_dtb_table_entry_get(uint32_t dev_id,
7907 : : uint32_t queue_id,
7908 : : ZXDH_DTB_USER_ENTRY_T *get_entry,
7909 : : uint32_t srh_mode)
7910 : : {
7911 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
7912 : : uint32_t tbl_type = 0;
7913 : : uint32_t rc;
7914 : : uint32_t sdt_no;
7915 : : uint32_t sdt_partner = 0;
7916 : : uint32_t valid = 0;
7917 : 0 : uint8_t key = 0;
7918 : :
7919 : 0 : sdt_no = get_entry->sdt_no;
7920 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
7921 : :
7922 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
7923 : :
7924 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_tbl.data_high32,
7925 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
7926 [ # # # # ]: 0 : switch (tbl_type) {
7927 : 0 : case ZXDH_SDT_TBLT_ERAM:
7928 : 0 : rc = zxdh_np_dtb_eram_data_get(dev_id,
7929 : : queue_id,
7930 : : sdt_no,
7931 : 0 : (ZXDH_DTB_ERAM_ENTRY_INFO_T *)get_entry->p_entry_data);
7932 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_eram_data_get");
7933 : : break;
7934 : 0 : case ZXDH_SDT_TBLT_HASH:
7935 : : do {
7936 : 0 : rc = zxdh_np_dtb_hash_data_get(dev_id,
7937 : : queue_id,
7938 : : sdt_no,
7939 : 0 : (ZXDH_DTB_HASH_ENTRY_INFO_T *)get_entry->p_entry_data,
7940 : : srh_mode);
7941 : : sdt_partner = zxdh_np_apt_get_sdt_partner(dev_id, sdt_no);
7942 : 0 : valid = zxdh_np_hash_sdt_partner_valid(sdt_no, sdt_partner, &key);
7943 : : sdt_no = sdt_partner;
7944 [ # # ]: 0 : } while ((rc == ZXDH_HASH_RC_SRH_FAIL) && (valid == ZXDH_TRUE));
7945 : :
7946 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_SRH_FAIL) {
7947 : 0 : PMD_DRV_LOG(DEBUG, "hash search failed");
7948 : 0 : return rc;
7949 : : }
7950 : :
7951 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_data_get");
7952 : : break;
7953 : 0 : case ZXDH_SDT_TBLT_ETCAM:
7954 : 0 : rc = zxdh_np_dtb_acl_data_get(dev_id,
7955 : : queue_id,
7956 : : sdt_no,
7957 : 0 : (ZXDH_DTB_ACL_ENTRY_INFO_T *)get_entry->p_entry_data);
7958 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_acl_data_get");
7959 : : break;
7960 : 0 : default:
7961 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %u ] is invalid!", tbl_type);
7962 : 0 : return 1;
7963 : : }
7964 : :
7965 : : return 0;
7966 : : }
7967 : :
7968 : : static uint32_t
7969 : 0 : zxdh_np_dtb_se_smmu0_ind_read(uint32_t dev_id,
7970 : : uint32_t queue_id,
7971 : : uint32_t base_addr,
7972 : : uint32_t index,
7973 : : uint32_t rd_mode,
7974 : : uint32_t *p_data)
7975 : : {
7976 : 0 : uint32_t temp_data[4] = {0};
7977 : 0 : uint32_t element_id = 0;
7978 : : uint32_t row_index = 0;
7979 : : uint32_t col_index = 0;
7980 : : uint32_t eram_dump_base_addr;
7981 : : uint32_t rc;
7982 : :
7983 [ # # # # ]: 0 : switch (rd_mode) {
7984 : 0 : case ZXDH_ERAM128_OPR_128b:
7985 : : row_index = index;
7986 : 0 : break;
7987 : 0 : case ZXDH_ERAM128_OPR_64b:
7988 : 0 : row_index = (index >> 1);
7989 : 0 : col_index = index & 0x1;
7990 : 0 : break;
7991 : 0 : case ZXDH_ERAM128_OPR_1b:
7992 : 0 : row_index = (index >> 7);
7993 : 0 : col_index = index & 0x7F;
7994 : 0 : break;
7995 : : default:
7996 : : break;
7997 : : }
7998 : :
7999 : 0 : eram_dump_base_addr = base_addr + row_index;
8000 : 0 : rc = zxdh_np_dtb_se_smmu0_dma_dump(dev_id,
8001 : : queue_id,
8002 : : eram_dump_base_addr,
8003 : : 1,
8004 : : temp_data,
8005 : : &element_id);
8006 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_dma_dump");
8007 : :
8008 [ # # # # ]: 0 : switch (rd_mode) {
8009 : : case ZXDH_ERAM128_OPR_128b:
8010 : : memcpy(p_data, temp_data, (128 / 8));
8011 : : break;
8012 : 0 : case ZXDH_ERAM128_OPR_64b:
8013 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
8014 : : break;
8015 : 0 : case ZXDH_ERAM128_OPR_1b:
8016 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
8017 : : (3 - col_index / 32)), (col_index % 32), 1);
8018 : 0 : break;
8019 : : default:
8020 : : break;
8021 : : }
8022 : :
8023 : 0 : return rc;
8024 : : }
8025 : :
8026 : : static uint32_t
8027 : 0 : zxdh_np_dtb_stat_smmu0_int_read(uint32_t dev_id,
8028 : : uint32_t queue_id,
8029 : : uint32_t smmu0_base_addr,
8030 : : ZXDH_STAT_CNT_MODE_E rd_mode,
8031 : : uint32_t index,
8032 : : uint32_t *p_data)
8033 : : {
8034 : : uint32_t eram_rd_mode;
8035 : : uint32_t rc;
8036 : :
8037 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
8038 : :
8039 [ # # ]: 0 : if (rd_mode == ZXDH_STAT_128_MODE)
8040 : : eram_rd_mode = ZXDH_ERAM128_OPR_128b;
8041 : : else
8042 : : eram_rd_mode = ZXDH_ERAM128_OPR_64b;
8043 : :
8044 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_read(dev_id,
8045 : : queue_id,
8046 : : smmu0_base_addr,
8047 : : index,
8048 : : eram_rd_mode,
8049 : : p_data);
8050 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_ind_read");
8051 : :
8052 : 0 : return rc;
8053 : : }
8054 : :
8055 : : int
8056 : 0 : zxdh_np_dtb_stats_get(uint32_t dev_id,
8057 : : uint32_t queue_id,
8058 : : ZXDH_STAT_CNT_MODE_E rd_mode,
8059 : : uint32_t index,
8060 : : uint32_t *p_data)
8061 : : {
8062 : : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
8063 : : uint32_t ppu_eram_baddr;
8064 : : uint32_t ppu_eram_depth;
8065 : : uint32_t rc = 0;
8066 : :
8067 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
8068 : :
8069 : : memset(&stat_cfg, 0x0, sizeof(stat_cfg));
8070 : :
8071 : : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
8072 : :
8073 : : ppu_eram_depth = stat_cfg.eram_depth;
8074 : : ppu_eram_baddr = stat_cfg.eram_baddr;
8075 : :
8076 [ # # ]: 0 : if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) {
8077 : 0 : rc = zxdh_np_dtb_stat_smmu0_int_read(dev_id,
8078 : : queue_id,
8079 : : ppu_eram_baddr,
8080 : : rd_mode,
8081 : : index,
8082 : : p_data);
8083 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_stat_smmu0_int_read");
8084 : : }
8085 : :
8086 : 0 : return rc;
8087 : : }
8088 : :
8089 : : static uint32_t
8090 [ # # ]: 0 : zxdh_np_dtb_queue_down_init(uint32_t dev_id,
8091 : : uint32_t queue_id,
8092 : : ZXDH_DTB_QUEUE_CFG_T *p_queue_cfg)
8093 : : {
8094 : : uint32_t rc = 0;
8095 : : uint32_t i = 0;
8096 : : uint32_t ack_vale = 0;
8097 : : uint32_t tab_down_item_size = 0;
8098 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
8099 : :
8100 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
8101 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 1;
8102 : :
8103 : 0 : tab_down_item_size = (p_queue_cfg->down_item_size == 0) ?
8104 [ # # ]: 0 : ZXDH_DTB_ITEM_SIZE : p_queue_cfg->down_item_size;
8105 : :
8106 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.item_size = tab_down_item_size;
8107 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.start_phy_addr = p_queue_cfg->down_start_phy_addr;
8108 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.start_vir_addr = p_queue_cfg->down_start_vir_addr;
8109 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.wr_index = 0;
8110 : 0 : p_dtb_mgr->queue_info[queue_id].tab_down.rd_index = 0;
8111 : :
8112 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8113 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id,
8114 : : ZXDH_DTB_DIR_DOWN_TYPE, i, 0, ZXDH_DTB_TAB_ACK_CHECK_VALUE);
8115 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_item_ack_wr");
8116 : : }
8117 : :
8118 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8119 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id,
8120 : : ZXDH_DTB_DIR_DOWN_TYPE, i, 0, &ack_vale);
8121 [ # # ]: 0 : if (ack_vale != ZXDH_DTB_TAB_ACK_CHECK_VALUE) {
8122 : 0 : PMD_DRV_LOG(ERR, "dtb queue [%u] down init failed!", queue_id);
8123 : 0 : return ZXDH_RC_DTB_MEMORY_ALLOC_ERR;
8124 : : }
8125 : : }
8126 : :
8127 : 0 : memset((uint8_t *)(p_queue_cfg->down_start_vir_addr), 0,
8128 : 0 : tab_down_item_size * ZXDH_DTB_QUEUE_ITEM_NUM_MAX);
8129 : :
8130 : 0 : PMD_DRV_LOG(INFO, "dtb queue [%u] down init success!!!", queue_id);
8131 : :
8132 : 0 : return ZXDH_OK;
8133 : : }
8134 : :
8135 : : static uint32_t
8136 [ # # ]: 0 : zxdh_np_dtb_queue_dump_init(uint32_t dev_id,
8137 : : uint32_t queue_id,
8138 : : ZXDH_DTB_QUEUE_CFG_T *p_queue_cfg)
8139 : : {
8140 : : uint32_t i = 0;
8141 : : uint32_t ack_vale = 0;
8142 : : uint32_t tab_up_item_size = 0;
8143 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
8144 : :
8145 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
8146 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 1;
8147 : :
8148 : 0 : tab_up_item_size = (p_queue_cfg->up_item_size == 0) ?
8149 [ # # ]: 0 : ZXDH_DTB_ITEM_SIZE : p_queue_cfg->up_item_size;
8150 : :
8151 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.item_size = tab_up_item_size;
8152 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.start_phy_addr = p_queue_cfg->up_start_phy_addr;
8153 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.start_vir_addr = p_queue_cfg->up_start_vir_addr;
8154 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.wr_index = 0;
8155 : 0 : p_dtb_mgr->queue_info[queue_id].tab_up.rd_index = 0;
8156 : :
8157 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8158 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id,
8159 : : ZXDH_DTB_DIR_UP_TYPE, i, 0, ZXDH_DTB_TAB_ACK_CHECK_VALUE);
8160 : : }
8161 : :
8162 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
8163 : : zxdh_np_dtb_item_ack_rd(dev_id, queue_id,
8164 : : ZXDH_DTB_DIR_UP_TYPE, i, 0, &ack_vale);
8165 [ # # ]: 0 : if (ack_vale != ZXDH_DTB_TAB_ACK_CHECK_VALUE) {
8166 : 0 : PMD_DRV_LOG(ERR, "dtb queue [%u] dump init failed!!!", queue_id);
8167 : 0 : return ZXDH_RC_DTB_MEMORY_ALLOC_ERR;
8168 : : }
8169 : : }
8170 : :
8171 : 0 : memset((uint8_t *)(p_queue_cfg->up_start_vir_addr), 0,
8172 : 0 : tab_up_item_size * ZXDH_DTB_QUEUE_ITEM_NUM_MAX);
8173 : :
8174 : 0 : PMD_DRV_LOG(INFO, "dtb queue [%u] up init success!!!", queue_id);
8175 : :
8176 : 0 : return ZXDH_OK;
8177 : : }
8178 : :
8179 : : static void
8180 : : zxdh_np_dtb_down_channel_addr_set(uint32_t dev_id,
8181 : : uint32_t channel_id,
8182 : : uint64_t phy_addr,
8183 : : uint64_t vir_addr,
8184 : : uint32_t size)
8185 : : {
8186 : 0 : ZXDH_DTB_QUEUE_CFG_T down_queue_cfg = {
8187 : : .down_start_phy_addr = phy_addr,
8188 : : .down_start_vir_addr = vir_addr,
8189 : : .down_item_size = size,
8190 : : };
8191 : :
8192 : 0 : zxdh_np_dtb_queue_down_init(dev_id, channel_id, &down_queue_cfg);
8193 : : }
8194 : :
8195 : : static void
8196 : : zxdh_np_dtb_dump_channel_addr_set(uint32_t dev_id,
8197 : : uint32_t channel_id,
8198 : : uint64_t phy_addr,
8199 : : uint64_t vir_addr,
8200 : : uint32_t size)
8201 : : {
8202 : 0 : ZXDH_DTB_QUEUE_CFG_T dump_queue_cfg = {
8203 : : .up_start_phy_addr = phy_addr,
8204 : : .up_start_vir_addr = vir_addr,
8205 : : .up_item_size = size,
8206 : : };
8207 : :
8208 : 0 : zxdh_np_dtb_queue_dump_init(dev_id, channel_id, &dump_queue_cfg);
8209 : : }
8210 : :
8211 : : static uint32_t
8212 : 0 : zxdh_np_dtb_user_info_set(uint32_t dev_id, uint32_t queue_id, uint16_t vport, uint32_t vector)
8213 : : {
8214 : : uint32_t rc = ZXDH_OK;
8215 : :
8216 [ # # ]: 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
8217 : : ZXDH_DTB_MGR_T *p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
8218 : :
8219 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
8220 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_queue_vm_info_get");
8221 : :
8222 : 0 : vm_info.dbi_en = 1;
8223 : 0 : vm_info.epid = hardware_ep_id[ZXDH_EPID_BY(vport)];
8224 : 0 : vm_info.vfunc_num = ZXDH_VFUNC_NUM(vport);
8225 : 0 : vm_info.func_num = ZXDH_FUNC_NUM(vport);
8226 : 0 : vm_info.vfunc_active = ZXDH_VF_ACTIVE(vport);
8227 : 0 : vm_info.vector = vector;
8228 : :
8229 : 0 : p_dtb_mgr->queue_info[queue_id].vport = vport;
8230 : 0 : p_dtb_mgr->queue_info[queue_id].vector = vector;
8231 : :
8232 : 0 : rc = zxdh_np_dtb_queue_vm_info_set(dev_id, queue_id, &vm_info);
8233 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_queue_vm_info_set");
8234 : :
8235 : 0 : return rc;
8236 : : }
8237 : :
8238 : : static uint32_t
8239 : 0 : zxdh_np_dtb_dump_sdt_addr_set(uint32_t dev_id,
8240 : : uint32_t queue_id,
8241 : : uint32_t sdt_no,
8242 : : uint64_t phy_addr,
8243 : : uint64_t vir_addr,
8244 : : uint32_t size)
8245 : : {
8246 : : uint32_t rc = ZXDH_OK;
8247 : :
8248 : 0 : ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {
8249 : : .sdt_no = sdt_no,
8250 : : .phy_addr = phy_addr,
8251 : : .vir_addr = vir_addr,
8252 : : .size = size,
8253 : : };
8254 : : ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
8255 : :
8256 : : p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
8257 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dtb_dump_addr_rb);
8258 : :
8259 : 0 : rc = zxdh_np_se_apt_rb_insert(p_dtb_dump_addr_rb,
8260 : : &dtb_dump_addr_info, sizeof(ZXDH_DTB_ADDR_INFO_T));
8261 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_apt_rb_insert");
8262 : :
8263 : 0 : return rc;
8264 : : }
8265 : :
8266 : : static uint32_t
8267 : 0 : zxdh_np_apt_dtb_res_init(uint32_t dev_id, ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
8268 : : {
8269 : : uint32_t rc = ZXDH_OK;
8270 : :
8271 : 0 : uint32_t queue_id = 0;
8272 : : uint32_t index = 0;
8273 : : uint32_t dump_sdt_num = 0;
8274 : : ZXDH_DTB_ADDR_INFO_T *p_dump_info = NULL;
8275 : :
8276 : 0 : rc = zxdh_np_dtb_queue_request(dev_id, p_dev_init_ctrl->port_name,
8277 : 0 : p_dev_init_ctrl->vport, &queue_id);
8278 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_queue_request");
8279 : :
8280 : 0 : p_dev_init_ctrl->queue_id = queue_id;
8281 : :
8282 : 0 : rc = zxdh_np_dtb_user_info_set(dev_id, queue_id,
8283 : 0 : p_dev_init_ctrl->vport, p_dev_init_ctrl->vector);
8284 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_user_info_set");
8285 : :
8286 : 0 : zxdh_np_dtb_down_channel_addr_set(dev_id, queue_id,
8287 : : p_dev_init_ctrl->down_phy_addr, p_dev_init_ctrl->down_vir_addr, 0);
8288 : :
8289 : 0 : zxdh_np_dtb_dump_channel_addr_set(dev_id, queue_id,
8290 : : p_dev_init_ctrl->dump_phy_addr, p_dev_init_ctrl->dump_vir_addr, 0);
8291 : :
8292 : 0 : dump_sdt_num = p_dev_init_ctrl->dump_sdt_num;
8293 [ # # ]: 0 : for (index = 0; index < dump_sdt_num; index++) {
8294 : 0 : p_dump_info = p_dev_init_ctrl->dump_addr_info + index;
8295 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dump_info);
8296 : 0 : rc = zxdh_np_dtb_dump_sdt_addr_set(dev_id,
8297 : : queue_id,
8298 : : p_dump_info->sdt_no,
8299 : : p_dump_info->phy_addr,
8300 : : p_dump_info->vir_addr,
8301 : : p_dump_info->size);
8302 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_set");
8303 : : }
8304 : :
8305 : 0 : return ZXDH_OK;
8306 : : }
8307 : :
8308 : : int
8309 : 0 : zxdh_np_host_init(uint32_t dev_id,
8310 : : ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
8311 : : {
8312 : 0 : ZXDH_SYS_INIT_CTRL_T sys_init_ctrl = {0};
8313 : : uint32_t rc;
8314 : : uint64_t agent_addr;
8315 : 0 : uint32_t bar_msg_num = 0;
8316 : :
8317 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dev_init_ctrl);
8318 : :
8319 : 0 : sys_init_ctrl.flags = (ZXDH_DEV_ACCESS_TYPE_PCIE << 0) | (ZXDH_DEV_AGENT_ENABLE << 10);
8320 : 0 : sys_init_ctrl.pcie_vir_baddr = zxdh_np_addr_calc(p_dev_init_ctrl->pcie_vir_addr,
8321 : : p_dev_init_ctrl->np_bar_offset);
8322 : 0 : sys_init_ctrl.device_type = ZXDH_DEV_TYPE_CHIP;
8323 : :
8324 : 0 : rc = zxdh_np_base_soft_init(dev_id, &sys_init_ctrl);
8325 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_base_soft_init");
8326 : :
8327 : 0 : zxdh_np_dev_vport_set(dev_id, p_dev_init_ctrl->vport);
8328 : :
8329 : 0 : agent_addr = ZXDH_PCIE_AGENT_ADDR_OFFSET + p_dev_init_ctrl->pcie_vir_addr;
8330 : : zxdh_np_dev_agent_addr_set(dev_id, agent_addr);
8331 : :
8332 : : zxdh_np_pf_fw_compatible_addr_set(dev_id, p_dev_init_ctrl->pcie_vir_addr);
8333 : :
8334 : 0 : rc = zxdh_np_np_sdk_version_compatible_check(dev_id);
8335 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_np_sdk_version_compatible_check");
8336 : :
8337 : 0 : rc = zxdh_np_pcie_bar_msg_num_get(dev_id, &bar_msg_num);
8338 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_pcie_bar_msg_num_get");
8339 : :
8340 : 0 : zxdh_np_dev_fw_bar_msg_num_set(dev_id, bar_msg_num);
8341 : :
8342 : 0 : rc = zxdh_np_apt_dtb_res_init(dev_id, p_dev_init_ctrl);
8343 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_dtb_res_init");
8344 : 0 : PMD_DRV_LOG(INFO, "host init done, queue_id = %u", p_dev_init_ctrl->queue_id);
8345 : :
8346 : 0 : return 0;
8347 : : }
8348 : :
8349 : : static uint32_t
8350 : : zxdh_np_get_se_buff_size(uint32_t opr)
8351 : : {
8352 : : uint32_t buff_size = 0;
8353 : :
8354 : : switch (opr) {
8355 : : case ZXDH_HASH_FUNC_BULK_REQ:
8356 : : buff_size = sizeof(ZXDH_NP_SE_HASH_FUNC_BULK_T);
8357 : : break;
8358 : : case ZXDH_HASH_TBL_REQ:
8359 : : buff_size = sizeof(ZXDH_NP_SE_HASH_TBL_T);
8360 : : break;
8361 : : case ZXDH_ERAM_TBL_REQ:
8362 : : buff_size = sizeof(ZXDH_NP_SE_ERAM_TBL_T);
8363 : : break;
8364 : : case ZXDH_ACL_TBL_REQ:
8365 : : buff_size = sizeof(ZXDH_NP_SE_ACL_TBL_T);
8366 : : break;
8367 : : case ZXDH_STAT_CFG_REQ:
8368 : : buff_size = sizeof(ZXDH_NP_SE_STAT_CFG_T);
8369 : : break;
8370 : : default:
8371 : : break;
8372 : : }
8373 : :
8374 : : return buff_size;
8375 : : }
8376 : :
8377 : : static void
8378 : 0 : zxdh_np_hash_func_bulk_set(ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init,
8379 : : ZXDH_NP_SE_HASH_FUNC_BULK_T *p_func_bulk)
8380 : : {
8381 : : uint32_t index = 0;
8382 : : ZXDH_APT_HASH_FUNC_RES_T *p_func_res = NULL;
8383 : : ZXDH_APT_HASH_BULK_RES_T *p_bulk_res = NULL;
8384 : :
8385 : 0 : p_hash_res_init->func_num = p_func_bulk->func_num;
8386 : 0 : p_hash_res_init->bulk_num = p_func_bulk->bulk_num;
8387 [ # # ]: 0 : for (index = 0; index < (p_hash_res_init->func_num); index++) {
8388 : 0 : p_func_res = p_hash_res_init->func_res + index;
8389 : :
8390 : 0 : p_func_res->func_id = p_func_bulk->fun[index].func_id;
8391 : 0 : p_func_res->ddr_dis = p_func_bulk->fun[index].ddr_dis;
8392 : 0 : p_func_res->zblk_num = p_func_bulk->fun[index].zblk_num;
8393 : 0 : p_func_res->zblk_bitmap = p_func_bulk->fun[index].zblk_bitmap;
8394 : : }
8395 : :
8396 [ # # ]: 0 : for (index = 0; index < (p_hash_res_init->bulk_num); index++) {
8397 : 0 : p_bulk_res = p_hash_res_init->bulk_res + index;
8398 : :
8399 : 0 : p_bulk_res->func_id = p_func_bulk->bulk[index].func_id;
8400 : 0 : p_bulk_res->bulk_id = p_func_bulk->bulk[index].bulk_id;
8401 : 0 : p_bulk_res->zcell_num = p_func_bulk->bulk[index].zcell_num;
8402 : 0 : p_bulk_res->zreg_num = p_func_bulk->bulk[index].zreg_num;
8403 : 0 : p_bulk_res->ddr_baddr = p_func_bulk->bulk[index].ddr_baddr;
8404 : 0 : p_bulk_res->ddr_item_num = p_func_bulk->bulk[index].ddr_item_num;
8405 : 0 : p_bulk_res->ddr_width_mode = p_func_bulk->bulk[index].ddr_width_mode;
8406 : 0 : p_bulk_res->ddr_crc_sel = p_func_bulk->bulk[index].ddr_crc_sel;
8407 : 0 : p_bulk_res->ddr_ecc_en = p_func_bulk->bulk[index].ddr_ecc_en;
8408 : : }
8409 : 0 : }
8410 : :
8411 : : static void
8412 : 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)
8413 : : {
8414 : : uint32_t index = 0;
8415 : : ZXDH_APT_HASH_TABLE_T *p_tbl_res = NULL;
8416 : :
8417 : 0 : p_hash_res_init->tbl_num = p_hash_tbl->tbl_num;
8418 [ # # ]: 0 : for (index = 0; index < (p_hash_res_init->tbl_num); index++) {
8419 : 0 : p_tbl_res = p_hash_res_init->tbl_res + index;
8420 : :
8421 : 0 : p_tbl_res->sdt_no = p_hash_tbl->table[index].sdt_no;
8422 : 0 : p_tbl_res->sdt_partner = p_hash_tbl->table[index].sdt_partner;
8423 : 0 : p_tbl_res->tbl_flag = p_hash_tbl->table[index].tbl_flag;
8424 : 0 : p_tbl_res->hash_sdt.table_type =
8425 : 0 : p_hash_tbl->table[index].hash_sdt.table_type;
8426 : 0 : p_tbl_res->hash_sdt.hash_id = p_hash_tbl->table[index].hash_sdt.hash_id;
8427 : 0 : p_tbl_res->hash_sdt.hash_table_width =
8428 : 0 : p_hash_tbl->table[index].hash_sdt.hash_table_width;
8429 : 0 : p_tbl_res->hash_sdt.key_size = p_hash_tbl->table[index].hash_sdt.key_size;
8430 : 0 : p_tbl_res->hash_sdt.hash_table_id =
8431 : 0 : p_hash_tbl->table[index].hash_sdt.hash_table_id;
8432 : 0 : p_tbl_res->hash_sdt.learn_en = p_hash_tbl->table[index].hash_sdt.learn_en;
8433 : 0 : p_tbl_res->hash_sdt.keep_alive =
8434 : 0 : p_hash_tbl->table[index].hash_sdt.keep_alive;
8435 : 0 : p_tbl_res->hash_sdt.keep_alive_baddr =
8436 : 0 : p_hash_tbl->table[index].hash_sdt.keep_alive_baddr;
8437 : 0 : p_tbl_res->hash_sdt.rsp_mode =
8438 : 0 : p_hash_tbl->table[index].hash_sdt.rsp_mode;
8439 : 0 : p_tbl_res->hash_sdt.hash_clutch_en =
8440 : 0 : p_hash_tbl->table[index].hash_sdt.hash_clutch_en;
8441 : : }
8442 : 0 : }
8443 : :
8444 : : static void
8445 : 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)
8446 : : {
8447 : : uint32_t index = 0;
8448 : : ZXDH_APT_ERAM_TABLE_T *p_eram_res = NULL;
8449 : :
8450 : 0 : p_eam_res_init->tbl_num = p_eram_tbl->tbl_num;
8451 [ # # ]: 0 : for (index = 0; index < (p_eam_res_init->tbl_num); index++) {
8452 : 0 : p_eram_res = p_eam_res_init->eram_res + index;
8453 : :
8454 : 0 : p_eram_res->sdt_no = p_eram_tbl->eram[index].sdt_no;
8455 : 0 : p_eram_res->opr_mode = p_eram_tbl->eram[index].opr_mode;
8456 : 0 : p_eram_res->rd_mode = p_eram_tbl->eram[index].rd_mode;
8457 : 0 : p_eram_res->eram_sdt.table_type = p_eram_tbl->eram[index].eram_sdt.table_type;
8458 : 0 : p_eram_res->eram_sdt.eram_mode = p_eram_tbl->eram[index].eram_sdt.eram_mode;
8459 : 0 : p_eram_res->eram_sdt.eram_base_addr =
8460 : 0 : p_eram_tbl->eram[index].eram_sdt.eram_base_addr;
8461 : 0 : p_eram_res->eram_sdt.eram_table_depth =
8462 : 0 : p_eram_tbl->eram[index].eram_sdt.eram_table_depth;
8463 : 0 : p_eram_res->eram_sdt.eram_clutch_en =
8464 : 0 : p_eram_tbl->eram[index].eram_sdt.eram_clutch_en;
8465 : : }
8466 : 0 : }
8467 : :
8468 : : static void
8469 : 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)
8470 : : {
8471 : : uint32_t index = 0;
8472 : : ZXDH_APT_ACL_TABLE_T *p_acl_res = NULL;
8473 : :
8474 : 0 : p_acl_res_init->tbl_num = p_acl_tbl->tbl_num;
8475 [ # # ]: 0 : for (index = 0; index < (p_acl_tbl->tbl_num); index++) {
8476 : 0 : p_acl_res = p_acl_res_init->acl_res + index;
8477 : :
8478 : 0 : p_acl_res->sdt_no = p_acl_tbl->acl[index].sdt_no;
8479 : 0 : p_acl_res->sdt_partner = p_acl_tbl->acl[index].sdt_partner;
8480 : 0 : p_acl_res->acl_res.block_num = p_acl_tbl->acl[index].acl_res.block_num;
8481 : 0 : p_acl_res->acl_res.entry_num = p_acl_tbl->acl[index].acl_res.entry_num;
8482 : 0 : p_acl_res->acl_res.pri_mode = p_acl_tbl->acl[index].acl_res.pri_mode;
8483 : 0 : memcpy(p_acl_res->acl_res.block_index,
8484 : 0 : p_acl_tbl->acl[index].acl_res.block_index,
8485 : : sizeof(uint32_t) * ZXDH_ETCAM_BLOCK_NUM);
8486 : 0 : p_acl_res->acl_sdt.table_type = p_acl_tbl->acl[index].acl_sdt.table_type;
8487 : 0 : p_acl_res->acl_sdt.etcam_id = p_acl_tbl->acl[index].acl_sdt.etcam_id;
8488 : 0 : p_acl_res->acl_sdt.etcam_key_mode = p_acl_tbl->acl[index].acl_sdt.etcam_key_mode;
8489 : 0 : p_acl_res->acl_sdt.etcam_table_id = p_acl_tbl->acl[index].acl_sdt.etcam_table_id;
8490 : 0 : p_acl_res->acl_sdt.no_as_rsp_mode = p_acl_tbl->acl[index].acl_sdt.no_as_rsp_mode;
8491 : 0 : p_acl_res->acl_sdt.as_en = p_acl_tbl->acl[index].acl_sdt.as_en;
8492 : 0 : p_acl_res->acl_sdt.as_eram_baddr = p_acl_tbl->acl[index].acl_sdt.as_eram_baddr;
8493 : 0 : p_acl_res->acl_sdt.as_rsp_mode = p_acl_tbl->acl[index].acl_sdt.as_rsp_mode;
8494 : 0 : p_acl_res->acl_sdt.etcam_table_depth =
8495 : 0 : p_acl_tbl->acl[index].acl_sdt.etcam_table_depth;
8496 : 0 : p_acl_res->acl_sdt.etcam_clutch_en = p_acl_tbl->acl[index].acl_sdt.etcam_clutch_en;
8497 : : }
8498 : 0 : }
8499 : :
8500 : : static void
8501 : : zxdh_np_stat_cfg_set(ZXDH_APT_STAT_RES_INIT_T *p_stat_res_init, ZXDH_NP_SE_STAT_CFG_T *p_stat_cfg)
8502 : : {
8503 : 0 : p_stat_res_init->eram_baddr = p_stat_cfg->eram_baddr;
8504 : 0 : p_stat_res_init->eram_depth = p_stat_cfg->eram_depth;
8505 : 0 : p_stat_res_init->ddr_baddr = p_stat_cfg->ddr_baddr;
8506 : 0 : p_stat_res_init->ppu_ddr_offset = p_stat_cfg->ppu_ddr_offset;
8507 : : }
8508 : :
8509 : : static uint32_t
8510 : 0 : zxdh_np_agent_hash_func_bulk_get(uint32_t dev_id, uint32_t type,
8511 : : ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init)
8512 : : {
8513 : : uint32_t rc = ZXDH_OK;
8514 : : uint32_t opr = ZXDH_HASH_FUNC_BULK_REQ;
8515 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8516 : : uint32_t buff_size = 0;
8517 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8518 : : uint32_t *p_rsp_buff = NULL;
8519 : : ZXDH_NP_SE_HASH_FUNC_BULK_T *p_func_bulk = NULL;
8520 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8521 : :
8522 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8523 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8524 : :
8525 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8526 : :
8527 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8528 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8529 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8530 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8531 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8532 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8533 : : }
8534 : :
8535 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ? ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8536 : :
8537 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8538 [ # # ]: 0 : if (rc != ZXDH_OK) {
8539 : 0 : rte_free(p_rsp_buff);
8540 : 0 : PMD_DRV_LOG(ERR, "hash func&bulk res get fail rc=0x%x.", rc);
8541 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8542 : 0 : return ZXDH_ERR;
8543 : : }
8544 : :
8545 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8546 : :
8547 : 0 : p_func_bulk = (ZXDH_NP_SE_HASH_FUNC_BULK_T *)(p_rsp_buff + 1);
8548 : 0 : zxdh_np_hash_func_bulk_set(p_hash_res_init, p_func_bulk);
8549 : 0 : rte_free(p_rsp_buff);
8550 : :
8551 : 0 : return rc;
8552 : : }
8553 : :
8554 : : static uint32_t
8555 : 0 : zxdh_np_agent_hash_tbl_get(uint32_t dev_id,
8556 : : uint32_t type,
8557 : : ZXDH_APT_HASH_RES_INIT_T *p_hash_res_init)
8558 : : {
8559 : : uint32_t rc = ZXDH_OK;
8560 : : uint32_t opr = ZXDH_HASH_TBL_REQ;
8561 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8562 : : uint32_t buff_size = 0;
8563 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8564 : : uint32_t *p_rsp_buff = NULL;
8565 : : ZXDH_NP_SE_HASH_TBL_T *p_hash_tbl = NULL;
8566 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8567 : :
8568 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8569 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8570 : :
8571 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8572 : :
8573 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8574 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8575 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8576 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8577 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8578 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8579 : : }
8580 : :
8581 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ?
8582 : 0 : ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8583 : :
8584 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8585 [ # # ]: 0 : if (rc != ZXDH_OK) {
8586 : 0 : rte_free(p_rsp_buff);
8587 : 0 : PMD_DRV_LOG(ERR, "hash table res get fail rc=0x%x.", rc);
8588 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8589 : 0 : return ZXDH_ERR;
8590 : : }
8591 : :
8592 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8593 : :
8594 : 0 : p_hash_tbl = (ZXDH_NP_SE_HASH_TBL_T *)(p_rsp_buff + 1);
8595 : 0 : zxdh_np_hash_tbl_set(p_hash_res_init, p_hash_tbl);
8596 : 0 : rte_free(p_rsp_buff);
8597 : :
8598 : 0 : return rc;
8599 : : }
8600 : :
8601 : : static uint32_t
8602 : 0 : zxdh_np_agent_eram_tbl_get(uint32_t dev_id, uint32_t type, ZXDH_APT_ERAM_RES_INIT_T *p_eam_res_init)
8603 : : {
8604 : : uint32_t rc = ZXDH_OK;
8605 : : uint32_t opr = ZXDH_ERAM_TBL_REQ;
8606 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8607 : : uint32_t buff_size = 0;
8608 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8609 : : uint32_t *p_rsp_buff = NULL;
8610 : : ZXDH_NP_SE_ERAM_TBL_T *p_eram_tbl = NULL;
8611 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8612 : :
8613 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8614 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8615 : :
8616 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8617 : :
8618 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8619 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8620 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8621 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8622 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8623 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8624 : : }
8625 : :
8626 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ?
8627 : 0 : ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8628 : :
8629 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8630 [ # # ]: 0 : if (rc != ZXDH_OK) {
8631 : 0 : rte_free(p_rsp_buff);
8632 : 0 : PMD_DRV_LOG(ERR, "eram table res get fail rc=0x%x.", rc);
8633 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8634 : 0 : return ZXDH_ERR;
8635 : : }
8636 : :
8637 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8638 : :
8639 : 0 : p_eram_tbl = (ZXDH_NP_SE_ERAM_TBL_T *)(p_rsp_buff + 1);
8640 : 0 : zxdh_np_eram_tbl_set(p_eam_res_init, p_eram_tbl);
8641 : 0 : rte_free(p_rsp_buff);
8642 : :
8643 : 0 : return rc;
8644 : : }
8645 : :
8646 : : static uint32_t
8647 : 0 : zxdh_np_agent_acl_tbl_get(uint32_t dev_id, uint32_t type, ZXDH_APT_ACL_RES_INIT_T *p_acl_res_init)
8648 : : {
8649 : : uint32_t rc = ZXDH_OK;
8650 : : uint32_t opr = ZXDH_ACL_TBL_REQ;
8651 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8652 : : uint32_t buff_size = 0;
8653 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8654 : : uint32_t *p_rsp_buff = NULL;
8655 : : ZXDH_NP_SE_ACL_TBL_T *p_acl_tbl = NULL;
8656 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8657 : :
8658 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8659 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8660 : :
8661 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8662 : :
8663 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8664 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8665 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8666 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8667 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8668 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8669 : : }
8670 : :
8671 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ?
8672 : 0 : ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8673 : :
8674 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8675 [ # # ]: 0 : if (rc != ZXDH_OK) {
8676 : 0 : rte_free(p_rsp_buff);
8677 : 0 : PMD_DRV_LOG(ERR, "acl table res get fail rc=0x%x.", rc);
8678 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8679 : 0 : return ZXDH_ERR;
8680 : : }
8681 : :
8682 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8683 : :
8684 : 0 : p_acl_tbl = (ZXDH_NP_SE_ACL_TBL_T *)(p_rsp_buff + 1);
8685 : 0 : zxdh_np_acl_tbl_set(p_acl_res_init, p_acl_tbl);
8686 : 0 : rte_free(p_rsp_buff);
8687 : :
8688 : 0 : return rc;
8689 : : }
8690 : :
8691 : : static uint32_t
8692 : 0 : zxdh_np_agent_stat_cfg_get(uint32_t dev_id,
8693 : : uint32_t type,
8694 : : ZXDH_APT_STAT_RES_INIT_T *p_stat_cfg_init)
8695 : : {
8696 : : uint32_t rc = ZXDH_OK;
8697 : : uint32_t opr = ZXDH_STAT_CFG_REQ;
8698 : : uint32_t sub_type = ZXDH_RES_STD_NIC_MSG;
8699 : : uint32_t buff_size = 0;
8700 : 0 : ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
8701 : : uint32_t *p_rsp_buff = NULL;
8702 : : ZXDH_NP_SE_STAT_CFG_T *p_stat_cfg = NULL;
8703 : : ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
8704 : :
8705 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
8706 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
8707 : :
8708 : 0 : rte_spinlock_lock(&p_dtb_spinlock->spinlock);
8709 : :
8710 : : buff_size = zxdh_np_get_se_buff_size(opr) + sizeof(uint32_t);
8711 : 0 : p_rsp_buff = rte_zmalloc(NULL, buff_size, 0);
8712 [ # # ]: 0 : if (p_rsp_buff == NULL) {
8713 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8714 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8715 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8716 : : }
8717 : :
8718 : 0 : sub_type = (type == ZXDH_SE_STD_NIC_RES_TYPE) ? ZXDH_RES_STD_NIC_MSG : ZXDH_RES_OFFLOAD_MSG;
8719 : :
8720 : 0 : rc = zxdh_np_agent_channel_se_res_get(dev_id, sub_type, opr, p_rsp_buff, buff_size);
8721 [ # # ]: 0 : if (rc != ZXDH_OK) {
8722 : 0 : rte_free(p_rsp_buff);
8723 : 0 : PMD_DRV_LOG(ERR, "ddr table res get fail rc = 0x%x.", rc);
8724 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8725 : 0 : return ZXDH_ERR;
8726 : : }
8727 : :
8728 : 0 : rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
8729 : :
8730 : : p_stat_cfg = (ZXDH_NP_SE_STAT_CFG_T *)(p_rsp_buff + 1);
8731 : : zxdh_np_stat_cfg_set(p_stat_cfg_init, p_stat_cfg);
8732 : 0 : rte_free(p_rsp_buff);
8733 : :
8734 : 0 : return rc;
8735 : : }
8736 : :
8737 : : static void *
8738 : : zxdh_np_dev_get_se_res_ptr(uint32_t dev_id, uint32_t type)
8739 : : {
8740 : : ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
8741 : 0 : ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
8742 : :
8743 : 0 : if (type == ZXDH_SE_STD_NIC_RES_TYPE)
8744 : 0 : return (void *)&p_dev_info->dev_apt_se_tbl_res.std_nic_res;
8745 : : else
8746 : 0 : return (void *)&p_dev_info->dev_apt_se_tbl_res.offload_res;
8747 : : }
8748 : :
8749 : : static uint32_t
8750 : 0 : zxdh_np_agent_se_res_get(uint32_t dev_id, uint32_t type)
8751 : : {
8752 : : uint32_t rc = ZXDH_OK;
8753 : : ZXDH_APT_SE_RES_T *p_se_res = NULL;
8754 : 0 : ZXDH_APT_HASH_RES_INIT_T hash_res = {0};
8755 : 0 : ZXDH_APT_ERAM_RES_INIT_T eram_res = {0};
8756 [ # # ]: 0 : ZXDH_APT_ACL_RES_INIT_T acl_res = {0};
8757 : :
8758 : : p_se_res = (ZXDH_APT_SE_RES_T *)zxdh_np_dev_get_se_res_ptr(dev_id, type);
8759 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_res);
8760 : :
8761 [ # # ]: 0 : if (p_se_res->valid) {
8762 : 0 : PMD_DRV_LOG(INFO, "dev_id [0x%x] res_type [%u] status ready", dev_id, type);
8763 : 0 : return ZXDH_OK;
8764 : : }
8765 : :
8766 : 0 : hash_res.func_res = p_se_res->hash_func;
8767 : 0 : hash_res.bulk_res = p_se_res->hash_bulk;
8768 : 0 : hash_res.tbl_res = p_se_res->hash_tbl;
8769 : 0 : rc = zxdh_np_agent_hash_func_bulk_get(dev_id, type, &hash_res);
8770 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_hash_func_bulk_get");
8771 : :
8772 : 0 : rc = zxdh_np_agent_hash_tbl_get(dev_id, type, &hash_res);
8773 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_hash_tbl_get");
8774 : 0 : p_se_res->hash_func_num = hash_res.func_num;
8775 : 0 : p_se_res->hash_bulk_num = hash_res.bulk_num;
8776 : 0 : p_se_res->hash_tbl_num = hash_res.tbl_num;
8777 : :
8778 : 0 : eram_res.eram_res = p_se_res->eram_tbl;
8779 : 0 : rc = zxdh_np_agent_eram_tbl_get(dev_id, type, &eram_res);
8780 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_eram_tbl_get");
8781 : 0 : p_se_res->eram_num = eram_res.tbl_num;
8782 : :
8783 : 0 : acl_res.acl_res = p_se_res->acl_tbl;
8784 : 0 : rc = zxdh_np_agent_acl_tbl_get(dev_id, type, &acl_res);
8785 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_acl_tbl_get");
8786 : 0 : p_se_res->acl_num = acl_res.tbl_num;
8787 : :
8788 : 0 : rc = zxdh_np_agent_stat_cfg_get(dev_id, type, &p_se_res->stat_cfg);
8789 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_stat_cfg_get");
8790 : :
8791 : 0 : p_se_res->valid = 1;
8792 : 0 : return rc;
8793 : : }
8794 : :
8795 : : static uint32_t
8796 : 0 : zxdh_np_se_init_ex(uint32_t dev_id, ZXDH_SE_CFG *p_se_cfg)
8797 : : {
8798 : : uint32_t i = 0;
8799 : : uint32_t j = 0;
8800 : :
8801 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
8802 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
8803 : :
8804 [ # # ]: 0 : if (dpp_se_cfg[dev_id] != NULL) {
8805 : 0 : PMD_DRV_LOG(DEBUG, "SE global config is already initialized.");
8806 : 0 : return ZXDH_OK;
8807 : : }
8808 : :
8809 : : memset(p_se_cfg, 0, sizeof(ZXDH_SE_CFG));
8810 : :
8811 : 0 : p_se_cfg->dev_id = dev_id;
8812 : 0 : dpp_se_cfg[p_se_cfg->dev_id] = p_se_cfg;
8813 : :
8814 : : p_se_cfg->p_as_rslt_wrt_fun = NULL;
8815 : 0 : p_se_cfg->p_client = ZXDH_COMM_VAL_TO_PTR(dev_id);
8816 : :
8817 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZBLK_NUM; i++) {
8818 : 0 : p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_se_cfg, i);
8819 : :
8820 : 0 : p_zblk_cfg->zblk_idx = i;
8821 : 0 : p_zblk_cfg->is_used = 0;
8822 : 0 : p_zblk_cfg->hash_arg = g_lpm_crc[i];
8823 : 0 : p_zblk_cfg->zcell_bm = 0;
8824 : : zxdh_np_init_d_node(&p_zblk_cfg->zblk_dn, p_zblk_cfg);
8825 : :
8826 [ # # ]: 0 : for (j = 0; j < ZXDH_SE_ZCELL_NUM; j++) {
8827 : 0 : p_zcell_cfg = &p_zblk_cfg->zcell_info[j];
8828 : :
8829 : 0 : p_zcell_cfg->zcell_idx = (i << 2) + j;
8830 : 0 : p_zcell_cfg->item_used = 0;
8831 : 0 : p_zcell_cfg->mask_len = 0;
8832 : :
8833 : : zxdh_np_init_d_node(&p_zcell_cfg->zcell_dn, p_zcell_cfg);
8834 : :
8835 : 0 : p_zcell_cfg->zcell_avl.p_key = p_zcell_cfg;
8836 : : }
8837 : : }
8838 : :
8839 : : return ZXDH_OK;
8840 : : }
8841 : :
8842 : : static uint32_t
8843 : 0 : zxdh_np_apt_hash_global_res_init(uint32_t dev_id)
8844 : : {
8845 [ # # ]: 0 : if (g_apt_se_cfg[dev_id] == NULL) {
8846 : 0 : g_apt_se_cfg[dev_id] = rte_zmalloc(NULL, sizeof(ZXDH_SE_CFG), 0);
8847 [ # # ]: 0 : if (g_apt_se_cfg[dev_id] == NULL) {
8848 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8849 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8850 : : }
8851 : :
8852 : 0 : zxdh_np_se_init_ex(dev_id, g_apt_se_cfg[dev_id]);
8853 : :
8854 : 0 : g_apt_se_cfg[dev_id]->p_client = ZXDH_COMM_VAL_TO_PTR(dev_id);
8855 : : }
8856 : :
8857 : : return ZXDH_OK;
8858 : : }
8859 : :
8860 : : static void
8861 : : se_apt_get_zblock_index(uint32_t zblock_bitmap, uint32_t *zblk_idx)
8862 : : {
8863 : : uint32_t index0 = 0;
8864 : : uint32_t index1 = 0;
8865 : :
8866 [ # # ]: 0 : for (index0 = 0; index0 < 32; index0++) {
8867 [ # # ]: 0 : if ((zblock_bitmap >> index0) & 0x1) {
8868 : 0 : *(zblk_idx + index1) = index0;
8869 : 0 : index1++;
8870 : : }
8871 : : }
8872 : : }
8873 : :
8874 : : static uint32_t
8875 : 0 : zxdh_np_crc32_calc(uint8_t *p_input_key, uint32_t dw_byte_num, uint32_t dw_crc_poly)
8876 : : {
8877 : : uint32_t dw_result = 0;
8878 : : uint32_t dw_data_type = 0;
8879 : :
8880 : : uint32_t i = 0;
8881 : : uint32_t j = 0;
8882 : :
8883 [ # # ]: 0 : while (i < dw_byte_num) {
8884 : 0 : dw_data_type = (uint32_t)((dw_result & 0xff000000) ^ (p_input_key[i] << 24));
8885 [ # # ]: 0 : for (j = 0; j < 8; j++) {
8886 [ # # ]: 0 : if (dw_data_type & 0x80000000) {
8887 : 0 : dw_data_type <<= 1;
8888 : 0 : dw_data_type ^= dw_crc_poly;
8889 : : } else {
8890 : 0 : dw_data_type <<= 1;
8891 : : }
8892 : : }
8893 : 0 : dw_result <<= 8;
8894 : 0 : dw_result ^= dw_data_type;
8895 : :
8896 : 0 : i++;
8897 : : }
8898 : :
8899 : 0 : return dw_result;
8900 : : }
8901 : :
8902 : : static uint16_t
8903 : 0 : zxdh_np_crc16_calc(uint8_t *p_input_key, uint32_t dw_byte_num, uint16_t dw_crc_poly)
8904 : : {
8905 : : uint16_t dw_result = 0;
8906 : : uint16_t dw_data_type = 0;
8907 : :
8908 : : uint32_t i = 0;
8909 : : uint32_t j = 0;
8910 : :
8911 [ # # ]: 0 : while (i < dw_byte_num) {
8912 : 0 : dw_data_type = (uint16_t)(((dw_result & 0xff00) ^ (p_input_key[i] << 8)) & 0xFFFF);
8913 [ # # ]: 0 : for (j = 0; j < 8; j++) {
8914 [ # # ]: 0 : if (dw_data_type & 0x8000) {
8915 : 0 : dw_data_type <<= 1;
8916 : 0 : dw_data_type ^= dw_crc_poly;
8917 : : } else {
8918 : 0 : dw_data_type <<= 1;
8919 : : }
8920 : : }
8921 : 0 : dw_result <<= 8;
8922 : 0 : dw_result ^= dw_data_type;
8923 : :
8924 : 0 : i++;
8925 : : }
8926 : :
8927 : 0 : return dw_result;
8928 : : }
8929 : :
8930 : : static uint32_t
8931 : 0 : zxdh_np_se_fun_init(ZXDH_SE_CFG *p_se_cfg,
8932 : : uint8_t id,
8933 : : uint32_t fun_type)
8934 : : {
8935 : : ZXDH_FUNC_ID_INFO *p_fun_info = NULL;
8936 : :
8937 : 0 : p_fun_info = ZXDH_GET_FUN_INFO(p_se_cfg, id);
8938 : :
8939 [ # # ]: 0 : if (p_fun_info->is_used) {
8940 : 0 : PMD_DRV_LOG(ERR, "Error[0x%x], fun_id [%u] is already used!",
8941 : : ZXDH_SE_RC_FUN_INVALID, id);
8942 : 0 : return ZXDH_SE_RC_FUN_INVALID;
8943 : : }
8944 : :
8945 : 0 : p_fun_info->fun_id = id;
8946 : 0 : p_fun_info->is_used = 1;
8947 : :
8948 [ # # ]: 0 : switch (fun_type) {
8949 : 0 : case (ZXDH_FUN_HASH):
8950 : 0 : p_fun_info->fun_type = ZXDH_FUN_HASH;
8951 : 0 : p_fun_info->fun_ptr = rte_zmalloc(NULL, sizeof(ZXDH_HASH_CFG), 0);
8952 [ # # ]: 0 : if (p_fun_info->fun_ptr == NULL) {
8953 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
8954 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
8955 : : }
8956 : 0 : ((ZXDH_HASH_CFG *)(p_fun_info->fun_ptr))->p_se_info = p_se_cfg;
8957 : : break;
8958 : 0 : default:
8959 : 0 : PMD_DRV_LOG(ERR, "Error, unrecgnized fun_type[ %u]", fun_type);
8960 : : RTE_ASSERT(0);
8961 : 0 : return ZXDH_SE_RC_BASE;
8962 : : }
8963 : :
8964 : 0 : return ZXDH_OK;
8965 : : }
8966 : :
8967 : : static int32_t
8968 : 0 : zxdh_np_hash_list_cmp(ZXDH_D_NODE *data1, ZXDH_D_NODE *data2, void *data)
8969 : : {
8970 : : uint32_t flag = 0;
8971 : : uint32_t data_new = 0;
8972 : : uint32_t data_pre = 0;
8973 : :
8974 : 0 : flag = *(uint32_t *)data;
8975 : :
8976 [ # # ]: 0 : if (flag == ZXDH_HASH_CMP_ZCELL) {
8977 : 0 : data_new = ((ZXDH_SE_ZCELL_CFG *)data1->data)->zcell_idx;
8978 : 0 : data_pre = ((ZXDH_SE_ZCELL_CFG *)data2->data)->zcell_idx;
8979 [ # # ]: 0 : } else if (flag == ZXDH_HASH_CMP_ZBLK) {
8980 : 0 : data_new = ((ZXDH_SE_ZBLK_CFG *)data1->data)->zblk_idx;
8981 : 0 : data_pre = ((ZXDH_SE_ZBLK_CFG *)data2->data)->zblk_idx;
8982 : : }
8983 : :
8984 [ # # ]: 0 : if (data_new > data_pre)
8985 : : return 1;
8986 [ # # ]: 0 : else if (data_new == data_pre)
8987 : : return 0;
8988 : : else
8989 : 0 : return -1;
8990 : : }
8991 : :
8992 : : static int32_t
8993 : 0 : zxdh_np_hash_rb_key_cmp(void *p_new, void *p_old, __rte_unused uint32_t key_size)
8994 : : {
8995 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_new = NULL;
8996 : : ZXDH_HASH_RBKEY_INFO *p_rbkey_old = NULL;
8997 : :
8998 : : p_rbkey_new = (ZXDH_HASH_RBKEY_INFO *)(p_new);
8999 : : p_rbkey_old = (ZXDH_HASH_RBKEY_INFO *)(p_old);
9000 : :
9001 : 0 : return memcmp(p_rbkey_new->key, p_rbkey_old->key, ZXDH_HASH_KEY_MAX);
9002 : : }
9003 : :
9004 : : static int32_t
9005 : 0 : zxdh_np_hash_ddr_cfg_rb_key_cmp(void *p_new, void *p_old, __rte_unused uint32_t key_size)
9006 : : {
9007 : : HASH_DDR_CFG *p_rbkey_new = NULL;
9008 : : HASH_DDR_CFG *p_rbkey_old = NULL;
9009 : :
9010 : : p_rbkey_new = (HASH_DDR_CFG *)(p_new);
9011 : : p_rbkey_old = (HASH_DDR_CFG *)(p_old);
9012 : :
9013 : 0 : return memcmp(&p_rbkey_new->ddr_baddr, &p_rbkey_old->ddr_baddr, sizeof(uint32_t));
9014 : : }
9015 : :
9016 : : static uint32_t
9017 : 0 : zxdh_np_hash_zcam_resource_init(ZXDH_HASH_CFG *p_hash_cfg,
9018 : : uint32_t zblk_num, uint32_t *zblk_idx_array)
9019 : : {
9020 : : uint32_t rc = ZXDH_OK;
9021 : :
9022 : : uint32_t i = 0;
9023 : : uint32_t j = 0;
9024 : 0 : uint32_t cmp_type = 0;
9025 : : uint32_t zblk_idx = 0;
9026 : : uint32_t zcell_idx = 0;
9027 : : uint32_t dev_id = 0;
9028 : :
9029 : : ZXDH_D_HEAD *p_zblk_list = NULL;
9030 : : ZXDH_D_HEAD *p_zcell_free = NULL;
9031 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
9032 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
9033 : :
9034 : 0 : dev_id = p_hash_cfg->p_se_info->dev_id;
9035 : :
9036 : 0 : p_zblk_list = &p_hash_cfg->hash_shareram.zblk_list;
9037 : : rc = zxdh_comm_double_link_init(ZXDH_SE_ZBLK_NUM, p_zblk_list);
9038 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
9039 : :
9040 : 0 : p_zcell_free = &p_hash_cfg->hash_shareram.zcell_free_list;
9041 : : rc = zxdh_comm_double_link_init(ZXDH_SE_ZBLK_NUM * ZXDH_SE_ZCELL_NUM, p_zcell_free);
9042 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
9043 : :
9044 [ # # ]: 0 : for (i = 0; i < zblk_num; i++) {
9045 : 0 : zblk_idx = zblk_idx_array[i];
9046 : :
9047 : 0 : p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_hash_cfg->p_se_info, zblk_idx);
9048 : :
9049 [ # # ]: 0 : if (p_zblk_cfg->is_used) {
9050 : 0 : PMD_DRV_LOG(ERR, "ZBlock[%u] is already used", zblk_idx);
9051 : : RTE_ASSERT(0);
9052 : 0 : return ZXDH_HASH_RC_INVALID_ZBLCK;
9053 : : }
9054 : :
9055 [ # # ]: 0 : for (j = 0; j < ZXDH_SE_ZCELL_NUM; j++) {
9056 : 0 : zcell_idx = p_zblk_cfg->zcell_info[j].zcell_idx;
9057 : 0 : p_zcell_cfg = &(((ZXDH_SE_CFG *)(p_hash_cfg->p_se_info))->
9058 : 0 : zblk_info[GET_ZBLK_IDX(zcell_idx)].zcell_info[GET_ZCELL_IDX(zcell_idx)]);
9059 : :
9060 [ # # ]: 0 : if (p_zcell_cfg->is_used) {
9061 : 0 : PMD_DRV_LOG(ERR, "ZBlk[%u], ZCell[%u] is already used",
9062 : : zblk_idx, zcell_idx);
9063 : : RTE_ASSERT(0);
9064 : 0 : return ZXDH_HASH_RC_INVALID_ZCELL;
9065 : : }
9066 : :
9067 : 0 : p_zcell_cfg->is_used = 1;
9068 : :
9069 : 0 : cmp_type = ZXDH_HASH_CMP_ZCELL;
9070 : 0 : rc = zxdh_comm_double_link_insert_sort(&p_zcell_cfg->zcell_dn,
9071 : : p_zcell_free, zxdh_np_hash_list_cmp, &cmp_type);
9072 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_sort");
9073 : : }
9074 : :
9075 : 0 : p_zblk_cfg->is_used = 1;
9076 : 0 : cmp_type = ZXDH_HASH_CMP_ZBLK;
9077 : 0 : rc = zxdh_comm_double_link_insert_sort(&p_zblk_cfg->zblk_dn,
9078 : : p_zblk_list, zxdh_np_hash_list_cmp, &cmp_type);
9079 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_last");
9080 : : }
9081 : :
9082 : : return rc;
9083 : : }
9084 : :
9085 : : static uint32_t
9086 : 0 : zxdh_np_hash_init(ZXDH_SE_CFG *p_se_cfg,
9087 : : uint32_t fun_id,
9088 : : uint32_t zblk_num,
9089 : : uint32_t *zblk_idx,
9090 : : uint32_t ddr_dis)
9091 : : {
9092 : : uint32_t rc = ZXDH_OK;
9093 : : uint32_t i = 0;
9094 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
9095 : : ZXDH_FUNC_ID_INFO *p_func_info = NULL;
9096 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
9097 : :
9098 : 0 : rc = zxdh_np_se_fun_init(p_se_cfg, (fun_id & 0xff), ZXDH_FUN_HASH);
9099 [ # # ]: 0 : if (rc == ZXDH_SE_RC_FUN_INVALID)
9100 : : return ZXDH_OK;
9101 : :
9102 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_fun_init");
9103 : :
9104 : : p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, fun_id);
9105 : 0 : p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
9106 : 0 : p_hash_cfg->fun_id = fun_id;
9107 : 0 : p_hash_cfg->p_hash32_fun = zxdh_np_crc32_calc;
9108 : 0 : p_hash_cfg->p_hash16_fun = zxdh_np_crc16_calc;
9109 : 0 : p_hash_cfg->p_se_info = p_se_cfg;
9110 : :
9111 [ # # ]: 0 : if (ddr_dis == 1)
9112 : 0 : p_hash_cfg->ddr_valid = 0;
9113 : : else
9114 : 0 : p_hash_cfg->ddr_valid = 1;
9115 : :
9116 : 0 : p_hash_cfg->hash_stat.zblock_num = zblk_num;
9117 : 0 : rc = zxdh_np_hash_zcam_resource_init(p_hash_cfg, zblk_num, zblk_idx);
9118 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_zcam_resource_init");
9119 : :
9120 [ # # ]: 0 : for (i = 0; i < zblk_num; i++)
9121 : 0 : p_hash_cfg->hash_stat.zblock_array[i] = zblk_idx[i];
9122 : :
9123 : 0 : rc = (uint32_t)zxdh_comm_rb_init(&p_hash_cfg->hash_rb,
9124 : : 0,
9125 : : sizeof(ZXDH_HASH_RBKEY_INFO),
9126 : : zxdh_np_hash_rb_key_cmp);
9127 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
9128 : :
9129 : 0 : rc = (uint32_t)zxdh_comm_rb_init(&p_hash_cfg->ddr_cfg_rb,
9130 : : 0,
9131 : : sizeof(HASH_DDR_CFG),
9132 : : zxdh_np_hash_ddr_cfg_rb_key_cmp);
9133 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
9134 : :
9135 [ # # ]: 0 : for (i = 0; i < zblk_num; i++)
9136 : 0 : g_hash_zblk_idx[dev_id][fun_id][i] = zblk_idx[i];
9137 : :
9138 : : return rc;
9139 : : }
9140 : :
9141 : : static uint32_t
9142 : 0 : zxdh_np_apt_hash_func_res_init(uint32_t dev_id, uint32_t func_num,
9143 : : ZXDH_APT_HASH_FUNC_RES_T *p_hash_func_res)
9144 : : {
9145 : : uint32_t rc = ZXDH_OK;
9146 : : uint32_t index = 0;
9147 : : uint32_t zblk_idx[32] = {0};
9148 : : ZXDH_APT_HASH_FUNC_RES_T *p_hash_func_res_temp = NULL;
9149 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9150 : :
9151 : 0 : p_se_cfg = g_apt_se_cfg[dev_id];
9152 : :
9153 [ # # ]: 0 : for (index = 0; index < func_num; index++) {
9154 : : memset(zblk_idx, 0, sizeof(zblk_idx));
9155 : 0 : p_hash_func_res_temp = p_hash_func_res + index;
9156 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_func_res_temp);
9157 : :
9158 : 0 : se_apt_get_zblock_index(p_hash_func_res_temp->zblk_bitmap, zblk_idx);
9159 : :
9160 : 0 : rc = zxdh_np_hash_init(p_se_cfg,
9161 : : p_hash_func_res_temp->func_id,
9162 : : p_hash_func_res_temp->zblk_num,
9163 : : zblk_idx,
9164 : : p_hash_func_res_temp->ddr_dis);
9165 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_init");
9166 : : }
9167 : :
9168 : 0 : return rc;
9169 : : }
9170 : :
9171 : : static uint32_t
9172 : 0 : zxdh_np_hash_bulk_init(ZXDH_SE_CFG *p_se_cfg,
9173 : : uint32_t fun_id,
9174 : : uint32_t bulk_id,
9175 : : ZXDH_HASH_DDR_RESC_CFG_T *p_ddr_resc_cfg,
9176 : : uint32_t zcell_num,
9177 : : uint32_t zreg_num)
9178 : : {
9179 : : uint32_t rc = ZXDH_OK;
9180 : :
9181 : : uint32_t i = 0;
9182 : : uint32_t j = 0;
9183 : : uint32_t zblk_idx = 0;
9184 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
9185 : : uint32_t ddr_item_num = 0;
9186 : :
9187 : : ZXDH_D_NODE *p_zblk_dn = NULL;
9188 : : ZXDH_D_NODE *p_zcell_dn = NULL;
9189 : : ZXDH_RB_TN *p_rb_tn_new = NULL;
9190 : 0 : ZXDH_RB_TN *p_rb_tn_rtn = NULL;
9191 : : ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
9192 : : ZXDH_SE_ZREG_CFG *p_zreg_cfg = NULL;
9193 : : HASH_DDR_CFG *p_ddr_cfg = NULL;
9194 : : HASH_DDR_CFG *p_rbkey_new = NULL;
9195 : : HASH_DDR_CFG *p_rbkey_rtn = NULL;
9196 : : ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
9197 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
9198 : : ZXDH_FUNC_ID_INFO *p_func_info = NULL;
9199 : : ZXDH_SE_ITEM_CFG **p_item_array = NULL;
9200 : : ZXDH_HASH_BULK_ZCAM_STAT *p_bulk_zcam_mono = NULL;
9201 : :
9202 : : p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, fun_id);
9203 : 0 : p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
9204 [ # # ]: 0 : if (p_hash_cfg == NULL) {
9205 : 0 : PMD_DRV_LOG(ERR, "p_hash_cfg point null!");
9206 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9207 : : }
9208 : :
9209 [ # # ]: 0 : if (p_hash_cfg->hash_stat.p_bulk_zcam_mono[bulk_id] != NULL) {
9210 : 0 : PMD_DRV_LOG(ERR, "fun_id[%u] bulk_id[%u] is already init", fun_id, bulk_id);
9211 : 0 : return ZXDH_OK;
9212 : : }
9213 : :
9214 : 0 : PMD_DRV_LOG(DEBUG, "p_hash_cfg->ddr_valid = %u!", p_hash_cfg->ddr_valid);
9215 [ # # ]: 0 : if (p_hash_cfg->ddr_valid == 1) {
9216 : 0 : ddr_item_num = p_ddr_resc_cfg->ddr_item_num;
9217 [ # # ]: 0 : if (ZXDH_DDR_WIDTH_512b == p_ddr_resc_cfg->ddr_width_mode)
9218 : 0 : ddr_item_num = p_ddr_resc_cfg->ddr_item_num >> 1;
9219 : :
9220 : 0 : p_rbkey_new = rte_zmalloc(NULL, sizeof(HASH_DDR_CFG), 0);
9221 [ # # ]: 0 : if (p_rbkey_new == NULL) {
9222 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9223 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9224 : : }
9225 : :
9226 : 0 : p_rbkey_new->ddr_baddr = p_ddr_resc_cfg->ddr_baddr;
9227 : :
9228 : 0 : p_rb_tn_new = rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
9229 [ # # ]: 0 : if (p_rb_tn_new == NULL) {
9230 : 0 : rte_free(p_rbkey_new);
9231 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9232 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9233 : : }
9234 : : zxdh_np_init_rbt_tn(p_rb_tn_new, p_rbkey_new);
9235 : :
9236 : 0 : rc = zxdh_comm_rb_insert(&p_hash_cfg->ddr_cfg_rb,
9237 : : (void *)p_rb_tn_new, (void *)(&p_rb_tn_rtn));
9238 [ # # ]: 0 : if (rc == ZXDH_RBT_RC_FULL) {
9239 : 0 : PMD_DRV_LOG(ERR, "The red black tree is full!");
9240 : 0 : rte_free(p_rbkey_new);
9241 : 0 : rte_free(p_rb_tn_new);
9242 : : RTE_ASSERT(0);
9243 : 0 : return ZXDH_HASH_RC_RB_TREE_FULL;
9244 [ # # ]: 0 : } else if (rc == ZXDH_RBT_RC_UPDATE) {
9245 : 0 : PMD_DRV_LOG(DEBUG, "some bulk_id share one bulk!");
9246 : :
9247 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
9248 : 0 : p_rbkey_rtn = (HASH_DDR_CFG *)(p_rb_tn_rtn->p_key);
9249 : :
9250 : 0 : p_ddr_cfg = p_hash_cfg->p_bulk_ddr_info[p_rbkey_rtn->bulk_id];
9251 : :
9252 : 0 : if (p_ddr_cfg->hash_ddr_arg !=
9253 [ # # ]: 0 : GET_DDR_HASH_ARG(p_ddr_resc_cfg->ddr_crc_sel) ||
9254 [ # # ]: 0 : p_ddr_cfg->width_mode != p_ddr_resc_cfg->ddr_width_mode ||
9255 [ # # ]: 0 : p_ddr_cfg->ddr_ecc_en != p_ddr_resc_cfg->ddr_ecc_en ||
9256 [ # # ]: 0 : p_ddr_cfg->item_num != ddr_item_num) {
9257 : 0 : PMD_DRV_LOG(ERR, "The base address is same");
9258 : 0 : rte_free(p_rbkey_new);
9259 : 0 : rte_free(p_rb_tn_new);
9260 : : RTE_ASSERT(0);
9261 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9262 : : }
9263 : :
9264 : 0 : p_hash_cfg->p_bulk_ddr_info[bulk_id] =
9265 : : p_hash_cfg->p_bulk_ddr_info[p_rbkey_rtn->bulk_id];
9266 : :
9267 : 0 : rte_free(p_rbkey_new);
9268 : 0 : rte_free(p_rb_tn_new);
9269 : : } else {
9270 : 0 : p_item_array = rte_zmalloc(NULL, ddr_item_num *
9271 : : sizeof(ZXDH_SE_ITEM_CFG *), 0);
9272 [ # # ]: 0 : if (NULL == (p_item_array)) {
9273 : 0 : rte_free(p_rbkey_new);
9274 : 0 : rte_free(p_rb_tn_new);
9275 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9276 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9277 : : }
9278 : :
9279 : 0 : p_rbkey_new->p_item_array = p_item_array;
9280 : 0 : p_rbkey_new->bulk_id = bulk_id;
9281 : 0 : p_rbkey_new->hw_baddr = 0;
9282 : 0 : p_rbkey_new->width_mode = p_ddr_resc_cfg->ddr_width_mode;
9283 : 0 : p_rbkey_new->item_num = ddr_item_num;
9284 : 0 : p_rbkey_new->ddr_ecc_en = p_ddr_resc_cfg->ddr_ecc_en;
9285 : 0 : p_rbkey_new->hash_ddr_arg = GET_DDR_HASH_ARG(p_ddr_resc_cfg->ddr_crc_sel);
9286 : 0 : p_rbkey_new->bulk_use = 1;
9287 : 0 : p_rbkey_new->zcell_num = zcell_num;
9288 : 0 : p_rbkey_new->zreg_num = zreg_num;
9289 : 0 : p_hash_cfg->p_bulk_ddr_info[bulk_id] = p_rbkey_new;
9290 : :
9291 : 0 : PMD_DRV_LOG(DEBUG, "one new ddr_bulk init!");
9292 : : }
9293 : : }
9294 : :
9295 : 0 : p_bulk_zcam_mono = rte_zmalloc(NULL, sizeof(ZXDH_HASH_BULK_ZCAM_STAT), 0);
9296 [ # # ]: 0 : if (NULL == (p_bulk_zcam_mono)) {
9297 : 0 : rte_free(p_rbkey_new);
9298 : 0 : rte_free(p_rb_tn_new);
9299 : 0 : rte_free(p_item_array);
9300 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9301 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9302 : : }
9303 : 0 : (&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[bulk_id] = p_bulk_zcam_mono;
9304 : :
9305 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZBLK_NUM * ZXDH_SE_ZCELL_NUM; i++)
9306 : 0 : p_bulk_zcam_mono->zcell_mono_idx[i] = 0xffffffff;
9307 : :
9308 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZBLK_NUM; i++) {
9309 [ # # ]: 0 : for (j = 0; j < ZXDH_SE_ZREG_NUM; j++) {
9310 : 0 : p_bulk_zcam_mono->zreg_mono_id[i][j].zblk_id = 0xffffffff;
9311 : 0 : p_bulk_zcam_mono->zreg_mono_id[i][j].zreg_id = 0xffffffff;
9312 : : }
9313 : : }
9314 : :
9315 [ # # ]: 0 : if (zcell_num > 0) {
9316 : 0 : p_hash_cfg->bulk_ram_mono[bulk_id] = 1;
9317 : :
9318 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
9319 : :
9320 : : i = 0;
9321 : :
9322 [ # # ]: 0 : while (p_zcell_dn) {
9323 : 0 : p_zcell_cfg = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
9324 : :
9325 [ # # ]: 0 : if (p_zcell_cfg->is_used) {
9326 [ # # ]: 0 : if (!(p_zcell_cfg->flag & ZXDH_ZCELL_FLAG_IS_MONO)) {
9327 : 0 : p_zcell_cfg->flag |= ZXDH_ZCELL_FLAG_IS_MONO;
9328 : 0 : p_zcell_cfg->bulk_id = bulk_id;
9329 : :
9330 : 0 : p_bulk_zcam_mono->zcell_mono_idx[p_zcell_cfg->zcell_idx] =
9331 : : p_zcell_cfg->zcell_idx;
9332 : :
9333 [ # # ]: 0 : if (++i >= zcell_num)
9334 : : break;
9335 : : }
9336 : : } else {
9337 : 0 : PMD_DRV_LOG(ERR, "zcell[ %u ] is not init", p_zcell_cfg->zcell_idx);
9338 : : RTE_ASSERT(0);
9339 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9340 : : }
9341 : :
9342 : 0 : p_zcell_dn = p_zcell_dn->next;
9343 : : }
9344 : :
9345 [ # # ]: 0 : if (i < zcell_num)
9346 : 0 : PMD_DRV_LOG(ERR, "Input zcell_num is %u, bulk %u monopolize zcells is %u",
9347 : : zcell_num, bulk_id, i);
9348 : : }
9349 : :
9350 [ # # ]: 0 : if (zreg_num > 0) {
9351 : 0 : p_hash_cfg->bulk_ram_mono[bulk_id] = 1;
9352 : :
9353 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
9354 : : j = 0;
9355 : :
9356 [ # # ]: 0 : while (p_zblk_dn) {
9357 : 0 : p_zblk_cfg = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
9358 : 0 : zblk_idx = p_zblk_cfg->zblk_idx;
9359 : :
9360 [ # # ]: 0 : if (p_zblk_cfg->is_used) {
9361 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
9362 : : p_zreg_cfg = &p_zblk_cfg->zreg_info[i];
9363 : :
9364 [ # # ]: 0 : if (!(p_zreg_cfg->flag & ZXDH_ZREG_FLAG_IS_MONO)) {
9365 : 0 : p_zreg_cfg->flag = ZXDH_ZREG_FLAG_IS_MONO;
9366 : 0 : p_zreg_cfg->bulk_id = bulk_id;
9367 : :
9368 : 0 : p_bulk_zcam_mono->zreg_mono_id[zblk_idx][i].zblk_id =
9369 : : zblk_idx;
9370 : 0 : p_bulk_zcam_mono->zreg_mono_id[zblk_idx][i].zreg_id = i;
9371 : :
9372 [ # # ]: 0 : if (++j >= zreg_num)
9373 : : break;
9374 : : }
9375 : : }
9376 : :
9377 [ # # ]: 0 : if (j >= zreg_num)
9378 : : break;
9379 : : } else {
9380 : 0 : PMD_DRV_LOG(ERR, "zblk [ %u ] is not init", p_zblk_cfg->zblk_idx);
9381 : : RTE_ASSERT(0);
9382 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9383 : : }
9384 : :
9385 : 0 : p_zblk_dn = p_zblk_dn->next;
9386 : : }
9387 : :
9388 [ # # ]: 0 : if (j < zreg_num)
9389 : 0 : PMD_DRV_LOG(ERR, "Input zreg_num' is %u, actually bulk %u monopolize zregs is %u",
9390 : : zreg_num, bulk_id, j);
9391 : : }
9392 : :
9393 : : return ZXDH_OK;
9394 : : }
9395 : :
9396 : : static uint32_t
9397 : 0 : zxdh_np_apt_hash_bulk_res_init(uint32_t dev_id, uint32_t bulk_num,
9398 : : ZXDH_APT_HASH_BULK_RES_T *p_bulk_res)
9399 : : {
9400 : : uint32_t rc = ZXDH_OK;
9401 : : uint32_t index = 0;
9402 : : ZXDH_APT_HASH_BULK_RES_T *p_hash_bulk_res_temp = NULL;
9403 : : ZXDH_HASH_DDR_RESC_CFG_T ddr_resc_cfg = {0};
9404 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9405 : :
9406 : 0 : p_se_cfg = g_apt_se_cfg[dev_id];
9407 : :
9408 [ # # ]: 0 : for (index = 0; index < bulk_num; index++) {
9409 : : memset(&ddr_resc_cfg, 0, sizeof(ZXDH_HASH_DDR_RESC_CFG_T));
9410 : 0 : p_hash_bulk_res_temp = p_bulk_res + index;
9411 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_bulk_res_temp);
9412 : :
9413 : 0 : ddr_resc_cfg.ddr_baddr = p_hash_bulk_res_temp->ddr_baddr;
9414 : 0 : ddr_resc_cfg.ddr_item_num = p_hash_bulk_res_temp->ddr_item_num;
9415 : 0 : ddr_resc_cfg.ddr_width_mode = p_hash_bulk_res_temp->ddr_width_mode;
9416 : 0 : ddr_resc_cfg.ddr_crc_sel = p_hash_bulk_res_temp->ddr_crc_sel;
9417 : 0 : ddr_resc_cfg.ddr_ecc_en = p_hash_bulk_res_temp->ddr_ecc_en;
9418 : :
9419 : 0 : rc = zxdh_np_hash_bulk_init(p_se_cfg,
9420 : : p_hash_bulk_res_temp->func_id,
9421 : : p_hash_bulk_res_temp->bulk_id,
9422 : : &ddr_resc_cfg,
9423 : : p_hash_bulk_res_temp->zcell_num,
9424 : : p_hash_bulk_res_temp->zreg_num);
9425 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_bulk_init");
9426 : : }
9427 : :
9428 : 0 : return rc;
9429 : : }
9430 : :
9431 : : static uint32_t
9432 : 0 : zxdh_np_apt_set_callback(uint32_t dev_id, uint32_t sdt_no, uint32_t table_type, void *p_data)
9433 : : {
9434 : : SE_APT_CALLBACK_T *apt_func = NULL;
9435 : :
9436 : : apt_func = &g_apt_se_callback[dev_id][sdt_no];
9437 : :
9438 : 0 : apt_func->sdt_no = sdt_no;
9439 : 0 : apt_func->table_type = table_type;
9440 [ # # # # ]: 0 : switch (table_type) {
9441 : 0 : case ZXDH_SDT_TBLT_ERAM:
9442 : 0 : apt_func->se_func_info.eram_func.opr_mode =
9443 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->opr_mode;
9444 : 0 : apt_func->se_func_info.eram_func.rd_mode =
9445 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->rd_mode;
9446 : 0 : apt_func->se_func_info.eram_func.eram_set_func =
9447 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->eram_set_func;
9448 : 0 : apt_func->se_func_info.eram_func.eram_get_func =
9449 : 0 : ((ZXDH_APT_ERAM_TABLE_T *)p_data)->eram_get_func;
9450 : 0 : break;
9451 : 0 : case ZXDH_SDT_TBLT_HASH:
9452 : 0 : apt_func->se_func_info.hash_func.sdt_partner =
9453 : 0 : ((ZXDH_APT_HASH_TABLE_T *)p_data)->sdt_partner;
9454 : 0 : apt_func->se_func_info.hash_func.hash_set_func =
9455 : 0 : ((ZXDH_APT_HASH_TABLE_T *)p_data)->hash_set_func;
9456 : 0 : apt_func->se_func_info.hash_func.hash_get_func =
9457 : 0 : ((ZXDH_APT_HASH_TABLE_T *)p_data)->hash_get_func;
9458 : 0 : break;
9459 : 0 : case ZXDH_SDT_TBLT_ETCAM:
9460 : 0 : apt_func->se_func_info.acl_func.sdt_partner =
9461 : 0 : ((ZXDH_APT_ACL_TABLE_T *)p_data)->sdt_partner;
9462 : 0 : apt_func->se_func_info.acl_func.acl_set_func =
9463 : 0 : ((ZXDH_APT_ACL_TABLE_T *)p_data)->acl_set_func;
9464 : 0 : apt_func->se_func_info.acl_func.acl_get_func =
9465 : 0 : ((ZXDH_APT_ACL_TABLE_T *)p_data)->acl_get_func;
9466 : 0 : break;
9467 : 0 : default:
9468 : 0 : PMD_DRV_LOG(ERR, "table_type[ %u ] is invalid!", table_type);
9469 : 0 : return ZXDH_ERR;
9470 : : }
9471 : :
9472 : : return ZXDH_OK;
9473 : : }
9474 : :
9475 : : static uint32_t
9476 : 0 : zxdh_np_hash_tbl_id_info_init(ZXDH_SE_CFG *p_se_cfg,
9477 : : uint32_t fun_id,
9478 : : uint32_t tbl_id,
9479 : : uint32_t tbl_flag,
9480 : : uint32_t key_type,
9481 : : uint32_t actu_key_size)
9482 : : {
9483 [ # # ]: 0 : uint32_t key_by_size = ZXDH_GET_KEY_SIZE(actu_key_size);
9484 : : uint32_t entry_size = ZXDH_GET_HASH_ENTRY_SIZE(key_type);
9485 : 0 : uint32_t dev_id = p_se_cfg->dev_id;
9486 : : ZXDH_HASH_TBL_ID_INFO *p_tbl_id_info = NULL;
9487 : :
9488 [ # # ]: 0 : if (key_by_size > entry_size) {
9489 : 0 : PMD_DRV_LOG(ERR, "ErrorCode[%x]: actu_key_size[%u] not match to key_type[%u].",
9490 : : ZXDH_HASH_RC_INVALID_PARA,
9491 : : key_by_size,
9492 : : entry_size);
9493 : : RTE_ASSERT(0);
9494 : 0 : return ZXDH_HASH_RC_INVALID_PARA;
9495 : : }
9496 : :
9497 : : p_tbl_id_info = GET_HASH_TBL_ID_INFO(dev_id, fun_id, tbl_id);
9498 : :
9499 [ # # ]: 0 : if (p_tbl_id_info->is_init) {
9500 : 0 : PMD_DRV_LOG(ERR, "fun_id[%u], table_id[%u] is already init", fun_id, tbl_id);
9501 : 0 : return ZXDH_OK;
9502 : : }
9503 : :
9504 : 0 : p_tbl_id_info->fun_id = fun_id;
9505 : 0 : p_tbl_id_info->actu_key_size = actu_key_size;
9506 : 0 : p_tbl_id_info->key_type = key_type;
9507 : 0 : p_tbl_id_info->is_init = 1;
9508 : :
9509 [ # # ]: 0 : if (tbl_flag & ZXDH_HASH_TBL_FLAG_AGE)
9510 : 0 : p_tbl_id_info->is_age = 1;
9511 : :
9512 [ # # ]: 0 : if (tbl_flag & ZXDH_HASH_TBL_FLAG_LEARN)
9513 : 0 : p_tbl_id_info->is_lrn = 1;
9514 : :
9515 [ # # ]: 0 : if (tbl_flag & ZXDH_HASH_TBL_FLAG_MC_WRT)
9516 : 0 : p_tbl_id_info->is_mc_wrt = 1;
9517 : :
9518 : : return ZXDH_OK;
9519 : : }
9520 : :
9521 : : static uint32_t
9522 : 0 : zxdh_np_apt_hash_tbl_res_init(uint32_t dev_id, uint32_t tbl_num,
9523 : : ZXDH_APT_HASH_TABLE_T *p_hash_tbl)
9524 : : {
9525 : : uint32_t rc = ZXDH_OK;
9526 : : uint32_t index = 0;
9527 : : ZXDH_APT_HASH_TABLE_T *p_hash_tbl_temp = NULL;
9528 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9529 : :
9530 : 0 : p_se_cfg = g_apt_se_cfg[dev_id];
9531 : :
9532 [ # # ]: 0 : for (index = 0; index < tbl_num; index++) {
9533 : 0 : p_hash_tbl_temp = p_hash_tbl + index;
9534 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_tbl_temp);
9535 : 0 : rc = zxdh_np_sdt_tbl_write(dev_id,
9536 : : p_hash_tbl_temp->sdt_no,
9537 : : p_hash_tbl_temp->hash_sdt.table_type,
9538 : 0 : &p_hash_tbl_temp->hash_sdt,
9539 : : ZXDH_SDT_OPER_ADD);
9540 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_sdt_tbl_write");
9541 : :
9542 : 0 : rc = zxdh_np_hash_tbl_id_info_init(p_se_cfg,
9543 : : p_hash_tbl_temp->hash_sdt.hash_id,
9544 : : p_hash_tbl_temp->hash_sdt.hash_table_id,
9545 : : p_hash_tbl_temp->tbl_flag,
9546 : : p_hash_tbl_temp->hash_sdt.hash_table_width,
9547 : : p_hash_tbl_temp->hash_sdt.key_size);
9548 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_tbl_id_info_init_ex");
9549 : :
9550 : 0 : rc = zxdh_np_apt_set_callback(dev_id,
9551 : : p_hash_tbl_temp->sdt_no,
9552 : : p_hash_tbl_temp->hash_sdt.table_type,
9553 : : (void *)p_hash_tbl_temp);
9554 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_set_callback");
9555 : : }
9556 : :
9557 : 0 : return rc;
9558 : : }
9559 : :
9560 : : static uint32_t
9561 : 0 : zxdh_np_apt_eram_res_init(uint32_t dev_id, uint32_t tbl_num, ZXDH_APT_ERAM_TABLE_T *p_eram_tbl)
9562 : : {
9563 : : uint32_t rc = ZXDH_OK;
9564 : : uint32_t index = 0;
9565 : : ZXDH_APT_ERAM_TABLE_T *p_temp_eram_tbl = NULL;
9566 : :
9567 [ # # ]: 0 : for (index = 0; index < tbl_num; index++) {
9568 : 0 : p_temp_eram_tbl = p_eram_tbl + index;
9569 : 0 : rc = zxdh_np_sdt_tbl_write(dev_id,
9570 : : p_temp_eram_tbl->sdt_no,
9571 : : p_temp_eram_tbl->eram_sdt.table_type,
9572 : 0 : &p_temp_eram_tbl->eram_sdt,
9573 : : ZXDH_SDT_OPER_ADD);
9574 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_sdt_tbl_write");
9575 : :
9576 : 0 : rc = zxdh_np_apt_set_callback(dev_id,
9577 : : p_temp_eram_tbl->sdt_no,
9578 : : p_temp_eram_tbl->eram_sdt.table_type,
9579 : : (void *)p_temp_eram_tbl);
9580 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_set_callback");
9581 : : }
9582 : :
9583 : 0 : return rc;
9584 : : }
9585 : :
9586 : : static uint32_t
9587 : : zxdh_np_acl_entrynum_to_blocknum(uint32_t entry_num, uint32_t key_mode)
9588 : : {
9589 : : uint32_t value = 0;
9590 : :
9591 : 0 : value = entry_num % (ZXDH_ETCAM_RAM_DEPTH * ((uint32_t)1 << key_mode));
9592 : :
9593 [ # # ]: 0 : if (value == 0)
9594 : 0 : return (entry_num / (ZXDH_ETCAM_RAM_DEPTH * ((uint32_t)1 << key_mode)));
9595 : : else
9596 : 0 : return (entry_num / (ZXDH_ETCAM_RAM_DEPTH * ((uint32_t)1 << key_mode)) + 1);
9597 : : }
9598 : :
9599 : : static int32_t
9600 : 0 : zxdh_np_acl_key_cmp(void *p_new_key, void *p_old_key, uint32_t key_len)
9601 : : {
9602 : 0 : return memcmp(&(((ZXDH_ACL_KEY_INFO_T *)p_new_key)->pri),
9603 : 0 : &(((ZXDH_ACL_KEY_INFO_T *)p_old_key)->pri), key_len - sizeof(uint32_t));
9604 : : }
9605 : :
9606 : : static uint32_t
9607 : : zxdh_np_acl_cfg_init_ex(ZXDH_ACL_CFG_EX_T *p_acl_cfg,
9608 : : void *p_client,
9609 : : uint32_t flags,
9610 : : ZXDH_ACL_AS_RSLT_WRT_FUNCTION p_as_wrt_fun)
9611 : : {
9612 : : uint32_t rc = 0;
9613 : :
9614 : : memset(p_acl_cfg, 0, sizeof(ZXDH_ACL_CFG_EX_T));
9615 : :
9616 : 0 : p_acl_cfg->p_client = p_client;
9617 : 0 : p_acl_cfg->dev_id = (uint32_t)(ZXDH_COMM_PTR_TO_VAL(p_acl_cfg->p_client) & 0xFFFFFFFF);
9618 : 0 : p_acl_cfg->flags = flags;
9619 : :
9620 : 0 : g_p_acl_ex_cfg[p_acl_cfg->dev_id] = p_acl_cfg;
9621 : :
9622 : : if (flags & ZXDH_ACL_FLAG_ETCAM0_EN) {
9623 : 0 : p_acl_cfg->acl_etcamids.is_valid = 1;
9624 : :
9625 : : p_acl_cfg->acl_etcamids.as_eram_base = 0;
9626 : :
9627 : : rc = zxdh_comm_double_link_init(ZXDH_ACL_TBL_ID_NUM,
9628 : : &p_acl_cfg->acl_etcamids.tbl_list);
9629 : : ZXDH_COMM_CHECK_RC(rc, "zxdh_comm_double_link_init");
9630 : : }
9631 : :
9632 : : if (p_as_wrt_fun == NULL) {
9633 : : p_acl_cfg->p_as_rslt_write_fun = NULL;
9634 : : p_acl_cfg->p_as_rslt_read_fun = NULL;
9635 : :
9636 : : } else {
9637 : : p_acl_cfg->p_as_rslt_write_fun = p_as_wrt_fun;
9638 : : }
9639 : :
9640 : : return rc;
9641 : : }
9642 : :
9643 : : static uint32_t
9644 : 0 : zxdh_np_acl_tbl_init_ex(ZXDH_ACL_CFG_EX_T *p_acl_cfg,
9645 : : uint32_t table_id,
9646 : : uint32_t as_enable,
9647 : : uint32_t entry_num,
9648 : : ZXDH_ACL_PRI_MODE_E pri_mode,
9649 : : uint32_t key_mode,
9650 : : ZXDH_ACL_AS_MODE_E as_mode,
9651 : : uint32_t as_baddr,
9652 : : uint32_t block_num,
9653 : : uint32_t *p_block_idx)
9654 : : {
9655 : : uint32_t rc = 0;
9656 : : uint32_t i = 0;
9657 : :
9658 : 0 : g_p_acl_ex_cfg[p_acl_cfg->dev_id] = p_acl_cfg;
9659 : :
9660 [ # # ]: 0 : if (p_acl_cfg->acl_tbls[table_id].is_used) {
9661 : 0 : PMD_DRV_LOG(ERR, "table_id[ %u ] is already used!", table_id);
9662 : : RTE_ASSERT(0);
9663 : 0 : return ZXDH_ACL_RC_INVALID_TBLID;
9664 : : }
9665 : :
9666 [ # # ]: 0 : if (!p_acl_cfg->acl_etcamids.is_valid) {
9667 : 0 : PMD_DRV_LOG(ERR, "etcam is not init!");
9668 : : RTE_ASSERT(0);
9669 : 0 : return ZXDH_ACL_RC_ETCAMID_NOT_INIT;
9670 : : }
9671 : :
9672 [ # # ]: 0 : if (zxdh_np_acl_entrynum_to_blocknum(entry_num, key_mode) > block_num) {
9673 : 0 : PMD_DRV_LOG(ERR, "key_mode %u, etcam block_num %u is not enough for entry_num 0x%x",
9674 : : key_mode, block_num, entry_num);
9675 : : RTE_ASSERT(0);
9676 : 0 : return ZXDH_ACL_RC_INVALID_BLOCKNUM;
9677 [ # # ]: 0 : } else if (zxdh_np_acl_entrynum_to_blocknum(entry_num, key_mode) < block_num) {
9678 : 0 : PMD_DRV_LOG(DEBUG, "key_mode %u, etcam block_num %u is more than entry_num 0x%x",
9679 : : key_mode, block_num, entry_num);
9680 : : } else {
9681 : 0 : PMD_DRV_LOG(DEBUG, "key_mode %u, etcam block_num %u is match with entry_num 0x%x",
9682 : : key_mode, block_num, entry_num);
9683 : : }
9684 : :
9685 : 0 : p_acl_cfg->acl_tbls[table_id].as_enable = as_enable;
9686 : :
9687 [ # # ]: 0 : if (as_enable) {
9688 : 0 : p_acl_cfg->acl_tbls[table_id].as_idx_base = as_baddr;
9689 : 0 : p_acl_cfg->acl_tbls[table_id].as_rslt_buff =
9690 : 0 : rte_zmalloc(NULL, entry_num * ZXDH_ACL_AS_RSLT_SIZE_GET_EX(as_mode), 0);
9691 [ # # ]: 0 : if (p_acl_cfg->acl_tbls[table_id].as_rslt_buff == NULL) {
9692 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9693 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9694 : : }
9695 : : }
9696 : :
9697 : 0 : rc = (uint32_t)zxdh_comm_rb_init(&p_acl_cfg->acl_tbls[table_id].acl_rb, 0,
9698 : 0 : (sizeof(ZXDH_ACL_KEY_INFO_T) & 0xFFFFFFFFU) + ZXDH_ACL_KEYSIZE_GET(key_mode),
9699 : : zxdh_np_acl_key_cmp);
9700 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_comm_rb_init");
9701 : :
9702 : 0 : p_acl_cfg->acl_tbls[table_id].table_id = table_id;
9703 : 0 : p_acl_cfg->acl_tbls[table_id].pri_mode = pri_mode;
9704 : 0 : p_acl_cfg->acl_tbls[table_id].key_mode = key_mode;
9705 : 0 : p_acl_cfg->acl_tbls[table_id].entry_num = entry_num;
9706 : 0 : p_acl_cfg->acl_tbls[table_id].as_mode = as_mode;
9707 : 0 : p_acl_cfg->acl_tbls[table_id].is_used = 1;
9708 : :
9709 : 0 : zxdh_np_init_d_node(&p_acl_cfg->acl_tbls[table_id].entry_dn,
9710 [ # # ]: 0 : &p_acl_cfg->acl_tbls[table_id]);
9711 : : rc = zxdh_comm_double_link_insert_last(&p_acl_cfg->acl_tbls[table_id].entry_dn,
9712 : : &p_acl_cfg->acl_etcamids.tbl_list);
9713 : : ZXDH_COMM_CHECK_RC(rc, "zxdh_comm_double_link_insert_last");
9714 : :
9715 : 0 : p_acl_cfg->acl_tbls[table_id].block_num = block_num;
9716 : 0 : p_acl_cfg->acl_tbls[table_id].block_array =
9717 : 0 : rte_zmalloc(NULL, block_num * sizeof(uint32_t), 0);
9718 [ # # ]: 0 : if (p_acl_cfg->acl_tbls[table_id].block_array == NULL) {
9719 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
9720 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
9721 : : }
9722 : :
9723 [ # # ]: 0 : for (i = 0; i < block_num; i++) {
9724 [ # # ]: 0 : if (p_acl_cfg->acl_blocks[p_block_idx[i]].is_used) {
9725 : 0 : PMD_DRV_LOG(ERR, "the block[ %u ] is already used by table[ %u ]!",
9726 : : p_block_idx[i], p_acl_cfg->acl_blocks[p_block_idx[i]].tbl_id);
9727 : : RTE_ASSERT(0);
9728 : 0 : return ZXDH_ACL_RC_INVALID_BLOCKID;
9729 : : }
9730 : :
9731 : 0 : p_acl_cfg->acl_tbls[table_id].block_array[i] = p_block_idx[i];
9732 : 0 : p_acl_cfg->acl_blocks[p_block_idx[i]].is_used = 1;
9733 : 0 : p_acl_cfg->acl_blocks[p_block_idx[i]].tbl_id = table_id;
9734 : 0 : p_acl_cfg->acl_blocks[p_block_idx[i]].idx_base =
9735 : 0 : ((ZXDH_ACL_ENTRY_MAX_GET(key_mode, i)) >> ZXDH_BLOCK_IDXBASE_BIT_OFF) &
9736 : : ZXDH_BLOCK_IDXBASE_BIT_MASK;
9737 : : }
9738 : :
9739 : : return ZXDH_OK;
9740 : : }
9741 : :
9742 : : static uint32_t
9743 : 0 : zxdh_np_apt_acl_res_init(uint32_t dev_id, uint32_t tbl_num, ZXDH_APT_ACL_TABLE_T *p_acl_tbl_res)
9744 : : {
9745 : : uint32_t rc = ZXDH_OK;
9746 : : uint8_t index = 0;
9747 : : ZXDH_APT_ACL_TABLE_T *p_temp_acl_tbl = NULL;
9748 : :
9749 : 0 : rc = zxdh_np_acl_cfg_init_ex(&g_apt_acl_cfg[dev_id],
9750 : 0 : (void *)ZXDH_COMM_VAL_TO_PTR(dev_id),
9751 : : ZXDH_ACL_FLAG_ETCAM0_EN,
9752 : : NULL);
9753 : : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_acl_cfg_init_ex");
9754 : :
9755 [ # # ]: 0 : for (index = 0; index < tbl_num; index++) {
9756 : 0 : p_temp_acl_tbl = p_acl_tbl_res + index;
9757 : 0 : rc = zxdh_np_sdt_tbl_write(dev_id,
9758 : : p_temp_acl_tbl->sdt_no,
9759 : : p_temp_acl_tbl->acl_sdt.table_type,
9760 : 0 : &p_temp_acl_tbl->acl_sdt,
9761 : : ZXDH_SDT_OPER_ADD);
9762 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_sdt_tbl_write");
9763 : :
9764 : 0 : rc = zxdh_np_acl_tbl_init_ex(&g_apt_acl_cfg[dev_id],
9765 : : p_temp_acl_tbl->acl_sdt.etcam_table_id,
9766 : : p_temp_acl_tbl->acl_sdt.as_en,
9767 : : p_temp_acl_tbl->acl_res.entry_num,
9768 : 0 : p_temp_acl_tbl->acl_res.pri_mode,
9769 : : p_temp_acl_tbl->acl_sdt.etcam_key_mode,
9770 : 0 : p_temp_acl_tbl->acl_sdt.as_rsp_mode,
9771 : : p_temp_acl_tbl->acl_sdt.as_eram_baddr,
9772 : : p_temp_acl_tbl->acl_res.block_num,
9773 : 0 : p_temp_acl_tbl->acl_res.block_index);
9774 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_acl_tbl_init_ex");
9775 : :
9776 : 0 : rc = zxdh_np_apt_set_callback(dev_id,
9777 : : p_temp_acl_tbl->sdt_no,
9778 : : p_temp_acl_tbl->acl_sdt.table_type,
9779 : : (void *)p_temp_acl_tbl);
9780 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_apt_set_callback");
9781 : : }
9782 : :
9783 : 0 : return rc;
9784 : : }
9785 : :
9786 : : static void
9787 : : zxdh_np_apt_stat_res_init(uint32_t dev_id, uint32_t type, ZXDH_APT_STAT_RES_INIT_T *stat_res_init)
9788 : : {
9789 : 0 : g_ppu_stat_cfg[dev_id].eram_baddr = stat_res_init->eram_baddr;
9790 : 0 : g_ppu_stat_cfg[dev_id].eram_depth = stat_res_init->eram_depth;
9791 : :
9792 [ # # ]: 0 : if (type == ZXDH_SE_NON_STD_NIC_RES_TYPE) {
9793 : 0 : g_ppu_stat_cfg[dev_id].ddr_base_addr = stat_res_init->ddr_baddr;
9794 : 0 : g_ppu_stat_cfg[dev_id].ppu_addr_offset = stat_res_init->ppu_ddr_offset;
9795 : : }
9796 : : }
9797 : :
9798 : : static uint32_t
9799 [ # # ]: 0 : zxdh_np_se_res_init(uint32_t dev_id, uint32_t type)
9800 : : {
9801 : : uint32_t rc = ZXDH_OK;
9802 : : ZXDH_APT_SE_RES_T *p_se_res = NULL;
9803 : : ZXDH_APT_HASH_RES_INIT_T hash_res_init = {0};
9804 : : ZXDH_APT_ERAM_RES_INIT_T eram_res_init = {0};
9805 : : ZXDH_APT_ACL_RES_INIT_T acl_res_init = {0};
9806 : :
9807 : : p_se_res = (ZXDH_APT_SE_RES_T *)zxdh_np_dev_get_se_res_ptr(dev_id, type);
9808 [ # # ]: 0 : if (!p_se_res->valid) {
9809 : 0 : PMD_DRV_LOG(ERR, "dev_id[0x%x],se_type[0x%x] invalid!", dev_id, type);
9810 : 0 : return ZXDH_ERR;
9811 : : }
9812 : :
9813 : 0 : hash_res_init.func_num = p_se_res->hash_func_num;
9814 : 0 : hash_res_init.bulk_num = p_se_res->hash_bulk_num;
9815 : 0 : hash_res_init.tbl_num = p_se_res->hash_tbl_num;
9816 : 0 : hash_res_init.func_res = p_se_res->hash_func;
9817 : 0 : hash_res_init.bulk_res = p_se_res->hash_bulk;
9818 : 0 : hash_res_init.tbl_res = p_se_res->hash_tbl;
9819 : 0 : eram_res_init.tbl_num = p_se_res->eram_num;
9820 : 0 : eram_res_init.eram_res = p_se_res->eram_tbl;
9821 : 0 : acl_res_init.tbl_num = p_se_res->acl_num;
9822 : 0 : acl_res_init.acl_res = p_se_res->acl_tbl;
9823 : :
9824 : 0 : rc = zxdh_np_apt_hash_global_res_init(dev_id);
9825 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_global_res_init");
9826 : :
9827 [ # # ]: 0 : if (hash_res_init.func_num) {
9828 : 0 : rc = zxdh_np_apt_hash_func_res_init(dev_id, hash_res_init.func_num,
9829 : : hash_res_init.func_res);
9830 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_func_res_init");
9831 : : }
9832 : :
9833 [ # # ]: 0 : if (hash_res_init.bulk_num) {
9834 : 0 : rc = zxdh_np_apt_hash_bulk_res_init(dev_id, hash_res_init.bulk_num,
9835 : : hash_res_init.bulk_res);
9836 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_bulk_res_init");
9837 : : }
9838 : :
9839 [ # # ]: 0 : if (hash_res_init.tbl_num) {
9840 : 0 : rc = zxdh_np_apt_hash_tbl_res_init(dev_id, hash_res_init.tbl_num,
9841 : : hash_res_init.tbl_res);
9842 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_tbl_res_init");
9843 : : }
9844 : :
9845 [ # # ]: 0 : if (eram_res_init.tbl_num) {
9846 : 0 : rc = zxdh_np_apt_eram_res_init(dev_id, eram_res_init.tbl_num,
9847 : : eram_res_init.eram_res);
9848 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_eram_res_init");
9849 : : }
9850 : :
9851 [ # # ]: 0 : if (acl_res_init.tbl_num) {
9852 : 0 : rc = zxdh_np_apt_acl_res_init(dev_id, acl_res_init.tbl_num,
9853 : : acl_res_init.acl_res);
9854 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_acl_res_init");
9855 : : }
9856 : :
9857 : : zxdh_np_apt_stat_res_init(dev_id, type, &p_se_res->stat_cfg);
9858 : :
9859 : : return rc;
9860 : : }
9861 : :
9862 : : uint32_t
9863 : 0 : zxdh_np_se_res_get_and_init(uint32_t dev_id, uint32_t type)
9864 : : {
9865 : : uint32_t rc = ZXDH_OK;
9866 : :
9867 : 0 : rc = zxdh_np_agent_se_res_get(dev_id, type);
9868 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_se_res_get");
9869 : 0 : PMD_DRV_LOG(DEBUG, "se res get success.");
9870 : :
9871 : 0 : rc = zxdh_np_se_res_init(dev_id, type);
9872 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_res_init");
9873 : 0 : PMD_DRV_LOG(DEBUG, "se res init success.");
9874 : :
9875 : 0 : return rc;
9876 : : }
9877 : :
9878 : : static uint32_t
9879 : 0 : zxdh_np_dtb_hash_zcam_del_one_hw(uint32_t dev_id,
9880 : : uint32_t queue_id,
9881 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
9882 : : ZXDH_HASH_ENTRY *p_hash_entry,
9883 : : ZXDH_DTB_ENTRY_T *p_entry,
9884 : : uint8_t *p_srh_succ)
9885 : : {
9886 : : uint32_t rc = ZXDH_OK;
9887 : 0 : ZXDH_HASH_RBKEY_INFO srh_rbkey = {0};
9888 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
9889 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
9890 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
9891 : :
9892 : : uint32_t zblk_idx = 0;
9893 : : uint32_t pre_zblk_idx = 0xFFFFFFFF;
9894 : : uint16_t crc16_value = 0;
9895 : : uint32_t zcell_id = 0;
9896 : : uint32_t item_idx = 0;
9897 : 0 : uint32_t element_id = 0;
9898 : 0 : uint32_t byte_offset = 0;
9899 : : uint32_t addr = 0;
9900 : : uint32_t i = 0;
9901 : : uint8_t srh_succ = 0;
9902 : 0 : uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
9903 : 0 : uint8_t rd_buff[ZXDH_SE_ITEM_WIDTH_MAX] = {0};
9904 : :
9905 : : ZXDH_D_NODE *p_zblk_dn = NULL;
9906 : : ZXDH_D_NODE *p_zcell_dn = NULL;
9907 : : ZXDH_SE_CFG *p_se_cfg = NULL;
9908 : :
9909 [ # # ]: 0 : memcpy(srh_rbkey.key, p_hash_entry->p_key, p_hash_entry_cfg->key_by_size);
9910 : :
9911 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
9912 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
9913 : :
9914 : 0 : p_se_cfg = p_hash_entry_cfg->p_se_cfg;
9915 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
9916 : :
9917 : 0 : zxdh_np_hash_set_crc_key(p_hash_entry_cfg, p_hash_entry, temp_key);
9918 : :
9919 : 0 : p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
9920 : :
9921 [ # # ]: 0 : while (p_zcell_dn) {
9922 : 0 : p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
9923 : 0 : zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
9924 : : p_zblk = &p_se_cfg->zblk_info[zblk_idx];
9925 : :
9926 [ # # ]: 0 : if (zblk_idx != pre_zblk_idx) {
9927 : : pre_zblk_idx = zblk_idx;
9928 : 0 : crc16_value = p_hash_cfg->p_hash16_fun(temp_key,
9929 : 0 : p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
9930 : : }
9931 : :
9932 : 0 : zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
9933 : 0 : item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc16_value);
9934 : 0 : addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
9935 : :
9936 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
9937 : : queue_id,
9938 : : addr,
9939 : : ZXDH_DTB_DUMP_ZCAM_512b,
9940 : : 1,
9941 : : (uint32_t *)rd_buff,
9942 : : &element_id);
9943 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
9944 : :
9945 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
9946 : :
9947 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM, p_hash_entry_cfg->key_by_size,
9948 : : p_hash_entry, rd_buff, &byte_offset);
9949 [ # # ]: 0 : if (rc == ZXDH_OK) {
9950 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zcell.");
9951 : : srh_succ = 1;
9952 : 0 : p_hash_cfg->hash_stat.search_ok++;
9953 : 0 : break;
9954 : : }
9955 : :
9956 : 0 : p_zcell_dn = p_zcell_dn->next;
9957 : : }
9958 : :
9959 [ # # ]: 0 : if (srh_succ == 0) {
9960 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
9961 [ # # ]: 0 : while (p_zblk_dn) {
9962 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
9963 : 0 : zblk_idx = p_zblk->zblk_idx;
9964 : :
9965 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
9966 : : item_idx = i;
9967 : 0 : addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx, item_idx);
9968 : 0 : rc = zxdh_np_dtb_se_zcam_dma_dump(dev_id,
9969 : : queue_id,
9970 : : addr,
9971 : : ZXDH_DTB_DUMP_ZCAM_512b,
9972 : : 1,
9973 : : (uint32_t *)rd_buff,
9974 : : &element_id);
9975 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
9976 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
9977 : :
9978 : 0 : rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM,
9979 : : p_hash_entry_cfg->key_by_size, p_hash_entry,
9980 : : rd_buff, &byte_offset);
9981 [ # # ]: 0 : if (rc == ZXDH_OK) {
9982 : 0 : PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zreg.");
9983 : : srh_succ = 1;
9984 : 0 : p_hash_cfg->hash_stat.search_ok++;
9985 : 0 : break;
9986 : : }
9987 : : }
9988 : 0 : p_zblk_dn = p_zblk_dn->next;
9989 : : }
9990 : : }
9991 : :
9992 [ # # ]: 0 : if (srh_succ) {
9993 : 0 : memset(rd_buff + byte_offset, 0,
9994 [ # # ]: 0 : ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type));
9995 : : zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
9996 : 0 : rc = zxdh_np_dtb_se_alg_zcam_data_write(dev_id,
9997 : : addr,
9998 : : rd_buff,
9999 : : p_entry);
10000 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_alg_zcam_data_write");
10001 : 0 : p_hash_cfg->hash_stat.delete_ok++;
10002 : : }
10003 : :
10004 : 0 : *p_srh_succ = srh_succ;
10005 : :
10006 : 0 : return rc;
10007 : : }
10008 : :
10009 : : static uint32_t
10010 : 0 : zxdh_np_dtb_hash_zcam_del_hw(uint32_t dev_id,
10011 : : uint32_t queue_id,
10012 : : uint32_t sdt_no,
10013 : : uint32_t entry_num,
10014 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_arr_hash_entry,
10015 : : uint32_t *element_id)
10016 : : {
10017 : : uint32_t rc = ZXDH_OK;
10018 : : uint32_t item_cnt = 0;
10019 : : uint32_t key_valid = 1;
10020 : : uint32_t dtb_len = 0;
10021 : 0 : uint8_t srh_succ = 0;
10022 : 0 : uint8_t key[ZXDH_HASH_KEY_MAX] = {0};
10023 : 0 : uint8_t rst[ZXDH_HASH_RST_MAX] = {0};
10024 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
10025 : :
10026 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
10027 : : uint8_t *p_data_buff = NULL;
10028 : :
10029 : : ZXDH_HASH_ENTRY entry = {0};
10030 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
10031 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
10032 : :
10033 : 0 : dtb_one_entry.cmd = entry_cmd;
10034 : 0 : dtb_one_entry.data = entry_data;
10035 : 0 : entry.p_key = key;
10036 : 0 : entry.p_rst = rst;
10037 : :
10038 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
10039 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
10040 : :
10041 : 0 : p_data_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
10042 [ # # ]: 0 : if (p_data_buff == NULL) {
10043 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10044 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10045 : : }
10046 : :
10047 [ # # ]: 0 : for (item_cnt = 0; item_cnt < entry_num; ++item_cnt) {
10048 : 0 : srh_succ = 0;
10049 : : memset(key, 0, sizeof(key));
10050 : : memset(rst, 0, sizeof(rst));
10051 : : memset(entry_cmd, 0, sizeof(entry_cmd));
10052 : : memset(entry_data, 0, sizeof(entry_data));
10053 : 0 : entry.p_key[0] = (uint8_t)(((key_valid & 0x1) << 7)
10054 : 0 : | ((hash_entry_cfg.key_type & 0x3) << 5)
10055 : 0 : | (hash_entry_cfg.table_id & 0x1f));
10056 : 0 : memcpy(&entry.p_key[1], p_arr_hash_entry[item_cnt].p_actu_key,
10057 : 0 : hash_entry_cfg.actu_key_size);
10058 : :
10059 : 0 : rc = zxdh_np_dtb_hash_zcam_del_one_hw(dev_id,
10060 : : queue_id,
10061 : : &hash_entry_cfg,
10062 : : &entry,
10063 : : &dtb_one_entry,
10064 : : &srh_succ);
10065 : :
10066 [ # # ]: 0 : if (srh_succ) {
10067 : 0 : zxdh_np_dtb_data_write(p_data_buff, 0, &dtb_one_entry);
10068 : 0 : dtb_len = dtb_one_entry.data_size / ZXDH_DTB_LEN_POS_SETP + 1;
10069 : 0 : zxdh_np_dtb_write_down_table_data(dev_id, queue_id,
10070 : : dtb_len * ZXDH_DTB_LEN_POS_SETP, p_data_buff, element_id);
10071 : 0 : rc = zxdh_np_dtb_tab_down_success_status_check(dev_id,
10072 : : queue_id, *element_id);
10073 : : }
10074 : : }
10075 : :
10076 : 0 : rte_free(p_data_buff);
10077 : :
10078 : 0 : return rc;
10079 : : }
10080 : :
10081 : : static uint32_t
10082 : 0 : zxdh_np_dtb_sdt_hash_zcam_mono_space_dump(uint32_t dev_id,
10083 : : uint32_t queue_id,
10084 : : uint32_t sdt_no,
10085 : : HASH_ENTRY_CFG *p_hash_entry_cfg,
10086 : : uint8_t *p_data,
10087 : : uint32_t *p_dump_len)
10088 : : {
10089 : : uint32_t rc = ZXDH_OK;
10090 : :
10091 : : uint32_t i = 0;
10092 : : uint32_t zblock_id = 0;
10093 : : uint32_t zcell_id = 0;
10094 : : uint32_t start_addr = 0;
10095 : : uint32_t dtb_desc_len = 0;
10096 : : uint32_t dump_pa_h = 0;
10097 : : uint32_t dump_pa_l = 0;
10098 : : uint32_t dma_addr_offset = 0;
10099 : : uint32_t desc_addr_offset = 0;
10100 : 0 : uint32_t element_id = 0;
10101 : : uint8_t *p_dump_desc_buf = NULL;
10102 : :
10103 : : ZXDH_D_NODE *p_zblk_dn = NULL;
10104 : : ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
10105 : : ZXDH_SE_ZREG_CFG *p_zreg = NULL;
10106 : : ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
10107 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10108 : :
10109 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
10110 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
10111 : :
10112 : 0 : rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &element_id);
10113 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
10114 : :
10115 : 0 : p_dump_desc_buf = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
10116 [ # # ]: 0 : if (p_dump_desc_buf == NULL) {
10117 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10118 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10119 : : }
10120 : 0 : dtb_dump_entry.cmd = cmd_buff;
10121 : :
10122 : 0 : p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
10123 : 0 : p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
10124 : :
10125 [ # # ]: 0 : while (p_zblk_dn) {
10126 : 0 : p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
10127 : 0 : zblock_id = p_zblk->zblk_idx;
10128 : :
10129 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZCELL_NUM; i++) {
10130 : : p_zcell = &p_zblk->zcell_info[i];
10131 : :
10132 [ # # ]: 0 : if ((p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO) &&
10133 [ # # ]: 0 : p_zcell->bulk_id == p_hash_entry_cfg->bulk_id) {
10134 : 0 : zcell_id = p_zcell->zcell_idx;
10135 : :
10136 : 0 : start_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_id, 0);
10137 : :
10138 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10139 : : queue_id,
10140 : : element_id,
10141 : : dma_addr_offset,
10142 : : &dump_pa_h,
10143 : : &dump_pa_l);
10144 : :
10145 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
10146 : : ZXDH_DTB_DUMP_ZCAM_512b, ZXDH_SE_RAM_DEPTH,
10147 : : dump_pa_h, dump_pa_l, &dtb_dump_entry);
10148 : :
10149 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset,
10150 : : &dtb_dump_entry);
10151 : :
10152 : 0 : dtb_desc_len++;
10153 : 0 : dma_addr_offset += ZXDH_SE_RAM_DEPTH * 512 / 8;
10154 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10155 : :
10156 : 0 : PMD_DRV_LOG(DEBUG, "the Zblock[%u]'s bulk_id:%u Mono Zcell_id :%u",
10157 : : zblock_id, p_hash_entry_cfg->bulk_id, zcell_id);
10158 : : }
10159 : : }
10160 : :
10161 [ # # ]: 0 : for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
10162 : : p_zreg = &p_zblk->zreg_info[i];
10163 : :
10164 [ # # ]: 0 : if ((p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO) &&
10165 [ # # ]: 0 : p_zreg->bulk_id == p_hash_entry_cfg->bulk_id) {
10166 : 0 : start_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblock_id, i);
10167 : :
10168 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10169 : : queue_id,
10170 : : element_id,
10171 : : dma_addr_offset,
10172 : : &dump_pa_h,
10173 : : &dump_pa_l);
10174 : :
10175 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
10176 : : ZXDH_DTB_DUMP_ZCAM_512b, 1, dump_pa_h, dump_pa_l, &dtb_dump_entry);
10177 : :
10178 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset,
10179 : : &dtb_dump_entry);
10180 : :
10181 : 0 : dtb_desc_len++;
10182 : 0 : dma_addr_offset += 512 / 8;
10183 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10184 : :
10185 : 0 : PMD_DRV_LOG(DEBUG, "the Zblock[%u]'s bulk_id:%u Mono Zreg_id :%u",
10186 : : zblock_id, p_zreg->bulk_id, i);
10187 : : }
10188 : : }
10189 : :
10190 : 0 : p_zblk_dn = p_zblk_dn->next;
10191 : : }
10192 : :
10193 : 0 : zxdh_np_dtb_write_dump_desc_info(dev_id,
10194 : : queue_id,
10195 : : element_id,
10196 : : (uint32_t *)p_dump_desc_buf,
10197 : : dma_addr_offset / 4,
10198 : : dtb_desc_len * 4,
10199 : : (uint32_t *)p_data);
10200 : :
10201 : 0 : zxdh_np_comm_swap(p_data, dma_addr_offset);
10202 : 0 : rte_free(p_dump_desc_buf);
10203 : :
10204 : 0 : *p_dump_len = dma_addr_offset;
10205 : :
10206 : 0 : return rc;
10207 : : }
10208 : :
10209 : : static uint32_t
10210 : 0 : zxdh_np_dtb_hash_table_zcam_dump(uint32_t dev_id,
10211 : : uint32_t queue_id,
10212 : : uint32_t sdt_no,
10213 : : uint32_t zblock_num,
10214 : : uint32_t zblock_array[ZXDH_SE_ZBLK_NUM],
10215 : : uint8_t *p_data,
10216 : : uint32_t *p_dump_len)
10217 : : {
10218 : : uint32_t rc = ZXDH_OK;
10219 : : uint32_t zblk_idx = 0;
10220 : : uint32_t index = 0;
10221 : : uint32_t zblock_id = 0;
10222 : : uint32_t zcell_id = 0;
10223 : : uint32_t start_addr = 0;
10224 : : uint32_t dtb_desc_len = 0;
10225 : : uint32_t dump_pa_h = 0;
10226 : : uint32_t dump_pa_l = 0;
10227 : : uint32_t dma_addr_offset = 0;
10228 : : uint32_t desc_addr_offset = 0;
10229 : 0 : uint32_t element_id = 0;
10230 : : uint8_t *p_dump_desc_buf = NULL;
10231 : :
10232 : 0 : ZXDH_DTB_ENTRY_T dtb_dump_entry = {0};
10233 : 0 : uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
10234 : :
10235 : 0 : rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &element_id);
10236 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
10237 : :
10238 : 0 : p_dump_desc_buf = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
10239 [ # # ]: 0 : if (p_dump_desc_buf == NULL) {
10240 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10241 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10242 : : }
10243 : :
10244 : 0 : dtb_dump_entry.cmd = cmd_buff;
10245 [ # # ]: 0 : for (zblk_idx = 0; zblk_idx < zblock_num; zblk_idx++) {
10246 : 0 : zblock_id = zblock_array[zblk_idx];
10247 [ # # ]: 0 : for (index = 0; index < ZXDH_SE_ZCELL_NUM; index++) {
10248 : 0 : zcell_id = zblock_id * ZXDH_SE_ZCELL_NUM + index;
10249 : 0 : start_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_id, 0);
10250 : :
10251 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10252 : : queue_id,
10253 : : element_id,
10254 : : dma_addr_offset,
10255 : : &dump_pa_h,
10256 : : &dump_pa_l);
10257 : :
10258 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
10259 : : ZXDH_DTB_DUMP_ZCAM_512b, ZXDH_SE_RAM_DEPTH,
10260 : : dump_pa_h, dump_pa_l, &dtb_dump_entry);
10261 : :
10262 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf,
10263 : : desc_addr_offset, &dtb_dump_entry);
10264 : :
10265 : 0 : dtb_desc_len++;
10266 : 0 : dma_addr_offset += ZXDH_SE_RAM_DEPTH * 512 / 8;
10267 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10268 : : }
10269 : :
10270 [ # # ]: 0 : zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
10271 : : queue_id,
10272 : : element_id,
10273 : : dma_addr_offset,
10274 : : &dump_pa_h,
10275 : : &dump_pa_l);
10276 : :
10277 : 0 : start_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblock_id, 0);
10278 : : zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr, ZXDH_DTB_DUMP_ZCAM_512b,
10279 : : ZXDH_SE_ZREG_NUM, dump_pa_h, dump_pa_l, &dtb_dump_entry);
10280 : :
10281 : 0 : zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset, &dtb_dump_entry);
10282 : :
10283 : 0 : dtb_desc_len++;
10284 : 0 : dma_addr_offset += ZXDH_SE_ZREG_NUM * 512 / 8;
10285 : 0 : desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
10286 : : }
10287 : :
10288 : 0 : zxdh_np_dtb_write_dump_desc_info(dev_id,
10289 : : queue_id,
10290 : : element_id,
10291 : : (uint32_t *)p_dump_desc_buf,
10292 : : dma_addr_offset / 4,
10293 : : dtb_desc_len * 4,
10294 : : (uint32_t *)p_data);
10295 : :
10296 : 0 : zxdh_np_comm_swap(p_data, dma_addr_offset);
10297 : 0 : rte_free(p_dump_desc_buf);
10298 : :
10299 : 0 : *p_dump_len = dma_addr_offset;
10300 : :
10301 : 0 : return rc;
10302 : : }
10303 : :
10304 : : static void
10305 : 0 : zxdh_np_dtb_dump_hash_parse(HASH_ENTRY_CFG *p_hash_entry_cfg,
10306 : : uint32_t item_type,
10307 : : uint8_t *pdata,
10308 : : uint32_t dump_len,
10309 : : uint8_t *p_outdata,
10310 : : uint32_t *p_item_num)
10311 : : {
10312 : : uint32_t item_num = 0;
10313 : : uint32_t data_offset = 0;
10314 : : uint32_t index = 0;
10315 : : uint8_t temp_key_valid = 0;
10316 : : uint8_t temp_key_type = 0;
10317 : : uint8_t temp_tbl_id = 0;
10318 : : uint32_t srh_entry_size = 0;
10319 : : uint32_t item_width = ZXDH_SE_ITEM_WIDTH_MAX;
10320 : : uint8_t *p_temp_key = NULL;
10321 : : uint8_t *p_hash_item = NULL;
10322 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry = NULL;
10323 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_temp_entry = NULL;
10324 : :
10325 [ # # ]: 0 : if (item_type == ZXDH_ITEM_DDR_256)
10326 : : item_width = item_width / 2;
10327 : :
10328 : : p_dtb_hash_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_outdata;
10329 [ # # ]: 0 : srh_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type);
10330 : :
10331 [ # # ]: 0 : for (index = 0; index < (dump_len / item_width); index++) {
10332 : : data_offset = 0;
10333 : 0 : p_hash_item = pdata + index * item_width;
10334 [ # # ]: 0 : while (data_offset < item_width) {
10335 : 0 : p_temp_key = p_hash_item + data_offset;
10336 : 0 : temp_key_valid = ZXDH_GET_HASH_KEY_VALID(p_temp_key);
10337 : 0 : temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_temp_key);
10338 : 0 : temp_tbl_id = ZXDH_GET_HASH_TBL_ID(p_temp_key);
10339 : 0 : p_temp_entry = p_dtb_hash_entry + item_num;
10340 : :
10341 [ # # # # ]: 0 : if (temp_key_valid && temp_key_type == p_hash_entry_cfg->key_type &&
10342 [ # # ]: 0 : temp_tbl_id == p_hash_entry_cfg->table_id) {
10343 : 0 : memcpy(p_temp_entry->p_actu_key, p_temp_key + 1,
10344 : 0 : p_hash_entry_cfg->actu_key_size);
10345 : 0 : memcpy(p_temp_entry->p_rst,
10346 : 0 : p_temp_key + p_hash_entry_cfg->key_by_size,
10347 : 0 : p_hash_entry_cfg->rst_by_size);
10348 : 0 : item_num++;
10349 : : }
10350 : :
10351 : 0 : data_offset += srh_entry_size;
10352 : : }
10353 : : }
10354 : :
10355 : 0 : *p_item_num = item_num;
10356 : 0 : }
10357 : :
10358 : : static uint32_t
10359 : 0 : zxdh_np_dtb_hash_table_dump(uint32_t dev_id,
10360 : : uint32_t queue_id,
10361 : : uint32_t sdt_no,
10362 : : ZXDH_DTB_DUMP_INDEX_T start_index,
10363 : : uint8_t *p_dump_data,
10364 : : uint32_t *p_entry_num,
10365 : : ZXDH_DTB_DUMP_INDEX_T *next_start_index,
10366 : : uint32_t *finish_flag)
10367 : : {
10368 : : uint32_t rc = ZXDH_OK;
10369 : : uint8_t *p_data = NULL;
10370 : 0 : uint32_t data_len = 0;
10371 : 0 : uint32_t entry_num = 0;
10372 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10373 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
10374 : :
10375 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
10376 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
10377 : :
10378 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
10379 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
10380 : :
10381 : 0 : p_data = rte_zmalloc(NULL, ZXDH_DTB_DMUP_DATA_MAX, 0);
10382 [ # # ]: 0 : if (p_data == NULL) {
10383 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10384 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10385 : : }
10386 : :
10387 [ # # ]: 0 : if (start_index.index_type == ZXDH_DTB_DUMP_ZCAM_TYPE) {
10388 [ # # ]: 0 : if (p_hash_cfg->bulk_ram_mono[hash_entry_cfg.bulk_id]) {
10389 : 0 : rc = zxdh_np_dtb_sdt_hash_zcam_mono_space_dump(dev_id,
10390 : : queue_id,
10391 : : sdt_no,
10392 : : &hash_entry_cfg,
10393 : : p_data,
10394 : : &data_len);
10395 : : } else {
10396 : 0 : rc = zxdh_np_dtb_hash_table_zcam_dump(dev_id,
10397 : : queue_id,
10398 : : sdt_no,
10399 : : p_hash_cfg->hash_stat.zblock_num,
10400 : 0 : p_hash_cfg->hash_stat.zblock_array,
10401 : : p_data,
10402 : : &data_len);
10403 : : }
10404 : :
10405 : 0 : zxdh_np_dtb_dump_hash_parse(&hash_entry_cfg,
10406 : : ZXDH_ITEM_RAM,
10407 : : p_data,
10408 : : data_len,
10409 : : p_dump_data,
10410 : : &entry_num);
10411 : :
10412 [ # # ]: 0 : if (p_hash_cfg->ddr_valid) {
10413 : 0 : next_start_index->index = 0;
10414 : 0 : next_start_index->index_type = ZXDH_DTB_DUMP_DDR_TYPE;
10415 : : } else {
10416 : 0 : *finish_flag = 1;
10417 : : }
10418 : 0 : *p_entry_num = entry_num;
10419 : : }
10420 : :
10421 : 0 : rte_free(p_data);
10422 : 0 : return rc;
10423 : : }
10424 : :
10425 : : static uint32_t
10426 : 0 : zxdh_np_dtb_hash_offline_zcam_delete(uint32_t dev_id,
10427 : : uint32_t queue_id,
10428 : : uint32_t sdt_no)
10429 : : {
10430 : : uint32_t rc = ZXDH_OK;
10431 : 0 : uint32_t entry_num = 0;
10432 : 0 : uint32_t finish_flag = 0;
10433 : : uint32_t index = 0;
10434 : : uint32_t max_item_num = 1024 * 1024;
10435 : : uint8_t *p_dump_data = NULL;
10436 : : uint8_t *p_key = NULL;
10437 : : uint8_t *p_rst = NULL;
10438 : 0 : uint32_t element_id = 0;
10439 : :
10440 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry = NULL;
10441 : : ZXDH_DTB_HASH_ENTRY_INFO_T *p_temp_entry = NULL;
10442 : 0 : ZXDH_DTB_DUMP_INDEX_T start_index = {0};
10443 : 0 : ZXDH_DTB_DUMP_INDEX_T next_start_index = {0};
10444 : :
10445 : 0 : ZXDH_SDT_TBL_HASH_T sdt_hash = {0};
10446 : : start_index.index = 0;
10447 : : start_index.index_type = ZXDH_DTB_DUMP_ZCAM_TYPE;
10448 : :
10449 : 0 : PMD_DRV_LOG(DEBUG, "sdt_no:%u", sdt_no);
10450 : 0 : rc = zxdh_np_soft_sdt_tbl_get(dev_id, sdt_no, &sdt_hash);
10451 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
10452 : :
10453 : 0 : p_dump_data = rte_zmalloc(NULL, max_item_num * sizeof(ZXDH_DTB_HASH_ENTRY_INFO_T), 0);
10454 [ # # ]: 0 : if (p_dump_data == NULL) {
10455 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10456 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10457 : : }
10458 : 0 : p_key = rte_zmalloc(NULL, max_item_num * ZXDH_HASH_KEY_MAX, 0);
10459 [ # # ]: 0 : if (p_key == NULL) {
10460 : 0 : PMD_DRV_LOG(ERR, "malloc memory failed");
10461 : 0 : rte_free(p_dump_data);
10462 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
10463 : : }
10464 : 0 : p_rst = rte_zmalloc(NULL, max_item_num * ZXDH_HASH_RST_MAX, 0);
10465 : : if (p_key == NULL) {
10466 : : PMD_DRV_LOG(ERR, "malloc memory failed");
10467 : : rte_free(p_dump_data);
10468 : : rte_free(p_key);
10469 : : return ZXDH_PAR_CHK_POINT_NULL;
10470 : : }
10471 : :
10472 : : p_dtb_hash_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_dump_data;
10473 [ # # ]: 0 : for (index = 0; index < max_item_num; index++) {
10474 : 0 : p_temp_entry = p_dtb_hash_entry + index;
10475 : 0 : p_temp_entry->p_actu_key = p_key + index * ZXDH_HASH_KEY_MAX;
10476 : 0 : p_temp_entry->p_rst = p_rst + index * ZXDH_HASH_RST_MAX;
10477 : : }
10478 : :
10479 : 0 : rc = zxdh_np_dtb_hash_table_dump(dev_id, queue_id, sdt_no, start_index,
10480 : : p_dump_data, &entry_num, &next_start_index, &finish_flag);
10481 : :
10482 [ # # ]: 0 : if (entry_num) {
10483 : 0 : rc = zxdh_np_dtb_hash_zcam_del_hw(dev_id, queue_id, sdt_no,
10484 : : entry_num, p_dtb_hash_entry, &element_id);
10485 : : }
10486 : :
10487 : 0 : rte_free(p_dtb_hash_entry);
10488 : 0 : rte_free(p_key);
10489 : 0 : rte_free(p_rst);
10490 : :
10491 : 0 : return rc;
10492 : : }
10493 : :
10494 : : uint32_t
10495 : 0 : zxdh_np_dtb_hash_online_delete(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no)
10496 : : {
10497 : : uint32_t rc = 0;
10498 : : uint8_t key_valid = 0;
10499 : : uint32_t table_id = 0;
10500 : : uint32_t key_type = 0;
10501 : :
10502 : : ZXDH_D_NODE *p_node = NULL;
10503 : : ZXDH_RB_TN *p_rb_tn = NULL;
10504 : : ZXDH_D_HEAD *p_head_hash_rb = NULL;
10505 : : ZXDH_HASH_CFG *p_hash_cfg = NULL;
10506 : : ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
10507 : 0 : HASH_ENTRY_CFG hash_entry_cfg = {0};
10508 : 0 : ZXDH_DTB_USER_ENTRY_T del_entry = {0};
10509 : 0 : ZXDH_DTB_HASH_ENTRY_INFO_T hash_entry = {0};
10510 : :
10511 : 0 : del_entry.sdt_no = sdt_no;
10512 : 0 : del_entry.p_entry_data = &hash_entry;
10513 : :
10514 : 0 : rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
10515 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
10516 : :
10517 : 0 : p_hash_cfg = hash_entry_cfg.p_hash_cfg;
10518 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
10519 : :
10520 : : p_head_hash_rb = &p_hash_cfg->hash_rb.tn_list;
10521 : 0 : p_node = p_head_hash_rb->p_next;
10522 [ # # ]: 0 : while (p_node) {
10523 : 0 : p_rb_tn = (ZXDH_RB_TN *)p_node->data;
10524 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn);
10525 : 0 : p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_rb_tn->p_key;
10526 : 0 : hash_entry.p_actu_key = p_rbkey->key + 1;
10527 : 0 : hash_entry.p_rst = p_rbkey->key;
10528 : :
10529 : 0 : key_valid = ZXDH_GET_HASH_KEY_VALID(p_rbkey->key);
10530 : : table_id = ZXDH_GET_HASH_TBL_ID(p_rbkey->key);
10531 : 0 : key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
10532 [ # # ]: 0 : if (!key_valid ||
10533 [ # # ]: 0 : table_id != hash_entry_cfg.table_id ||
10534 [ # # ]: 0 : key_type != hash_entry_cfg.key_type) {
10535 : 0 : p_node = p_node->next;
10536 : 0 : continue;
10537 : : }
10538 : 0 : p_node = p_node->next;
10539 : :
10540 : 0 : rc = zxdh_np_dtb_table_entry_delete(dev_id, queue_id, 1, &del_entry);
10541 [ # # ]: 0 : if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
10542 : 0 : continue;
10543 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_table_entry_delete");
10544 : : }
10545 : :
10546 : 0 : return rc;
10547 : : }
10548 : :
10549 : : uint32_t
10550 : 0 : zxdh_np_dtb_hash_offline_delete(uint32_t dev_id,
10551 : : uint32_t queue_id,
10552 : : uint32_t sdt_no,
10553 : : __rte_unused uint32_t flush_mode)
10554 : : {
10555 : : uint32_t rc = ZXDH_OK;
10556 : :
10557 : 0 : rc = zxdh_np_dtb_hash_offline_zcam_delete(dev_id, queue_id, sdt_no);
10558 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_offline_zcam_delete");
10559 : :
10560 : 0 : return rc;
10561 : : }
10562 : :
10563 : : static uint32_t
10564 : 0 : zxdh_np_se_done_status_check(uint32_t dev_id, uint32_t reg_no, uint32_t pos)
10565 : : {
10566 : : uint32_t rc = 0;
10567 : :
10568 : 0 : uint32_t data = 0;
10569 : : uint32_t rd_cnt = 0;
10570 : : uint32_t done_flag = 0;
10571 : :
10572 : 0 : while (!done_flag) {
10573 : 0 : rc = zxdh_np_reg_read32(dev_id, reg_no, 0, 0, &data);
10574 [ # # ]: 0 : if (rc != 0) {
10575 : 0 : PMD_DRV_LOG(ERR, "reg_read32 fail!");
10576 : 0 : return rc;
10577 : : }
10578 : :
10579 : 0 : done_flag = (data >> pos) & 0x1;
10580 : :
10581 [ # # ]: 0 : if (done_flag)
10582 : : break;
10583 : :
10584 [ # # ]: 0 : if (rd_cnt > ZXDH_RD_CNT_MAX * ZXDH_RD_CNT_MAX)
10585 : : return -1;
10586 : :
10587 : 0 : rd_cnt++;
10588 : : }
10589 : :
10590 : : return rc;
10591 : : }
10592 : :
10593 : : static uint32_t
10594 : 0 : zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
10595 : : uint32_t base_addr,
10596 : : uint32_t index,
10597 : : uint32_t rd_mode,
10598 : : uint32_t rd_clr_mode,
10599 : : uint32_t *p_data)
10600 : : {
10601 : : uint32_t rc = ZXDH_OK;
10602 : : uint32_t i = 0;
10603 : : uint32_t row_index = 0;
10604 : : uint32_t col_index = 0;
10605 : 0 : uint32_t temp_data[4] = {0};
10606 : : uint32_t *p_temp_data = NULL;
10607 : 0 : ZXDH_SMMU0_SMMU0_CPU_IND_CMD_T cpu_ind_cmd = {0};
10608 : 0 : ZXDH_SPINLOCK_T *p_ind_spinlock = NULL;
10609 : :
10610 : 0 : rc = zxdh_np_dev_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_SMMU0, &p_ind_spinlock);
10611 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
10612 : :
10613 : 0 : rte_spinlock_lock(&p_ind_spinlock->spinlock);
10614 : :
10615 : 0 : rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_WR_ARB_CPU_RDYR, 0);
10616 [ # # ]: 0 : if (rc != ZXDH_OK) {
10617 : 0 : PMD_DRV_LOG(ERR, "se done status check failed, rc=0x%x.", rc);
10618 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10619 : 0 : return ZXDH_ERR;
10620 : : }
10621 : :
10622 [ # # ]: 0 : if (rd_clr_mode == ZXDH_RD_MODE_HOLD) {
10623 : 0 : cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD;
10624 : 0 : cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_HOLD;
10625 : 0 : cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b;
10626 : :
10627 [ # # # # : 0 : switch (rd_mode) {
# ]
10628 : 0 : case ZXDH_ERAM128_OPR_128b:
10629 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
10630 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10631 : 0 : PMD_DRV_LOG(ERR, "index 0x%x is invalid!", index);
10632 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
10633 : : }
10634 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10635 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10636 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10637 : 0 : return ZXDH_ERR;
10638 : : }
10639 : 0 : row_index = (index << 7) & ZXDH_ERAM128_BADDR_MASK;
10640 : 0 : break;
10641 : 0 : case ZXDH_ERAM128_OPR_64b:
10642 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10643 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10644 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10645 : 0 : return ZXDH_ERR;
10646 : : }
10647 : 0 : row_index = (index << 6) & ZXDH_ERAM128_BADDR_MASK;
10648 : 0 : col_index = index & 0x1;
10649 : 0 : break;
10650 : 0 : case ZXDH_ERAM128_OPR_32b:
10651 [ # # ]: 0 : if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10652 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10653 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10654 : 0 : return ZXDH_ERR;
10655 : : }
10656 : 0 : row_index = (index << 5) & ZXDH_ERAM128_BADDR_MASK;
10657 : 0 : col_index = index & 0x3;
10658 : 0 : break;
10659 : 0 : case ZXDH_ERAM128_OPR_1b:
10660 [ # # ]: 0 : if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10661 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10662 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10663 : 0 : return ZXDH_ERR;
10664 : : }
10665 : 0 : row_index = index & ZXDH_ERAM128_BADDR_MASK;
10666 : 0 : col_index = index & 0x7F;
10667 : 0 : break;
10668 : : default:
10669 : : break;
10670 : : }
10671 : :
10672 : 0 : cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index;
10673 : : } else {
10674 : 0 : cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD;
10675 : 0 : cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_CLEAR;
10676 : :
10677 [ # # # # : 0 : switch (rd_mode) {
# ]
10678 : 0 : case ZXDH_ERAM128_OPR_128b:
10679 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
10680 : 0 : PMD_DRV_LOG(ERR, "index 0x%x is invalid!", index);
10681 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10682 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
10683 : : }
10684 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10685 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10686 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10687 : 0 : return ZXDH_ERR;
10688 : : }
10689 : 0 : row_index = (index << 7);
10690 : 0 : cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b;
10691 : 0 : break;
10692 : 0 : case ZXDH_ERAM128_OPR_64b:
10693 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10694 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10695 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10696 : 0 : return ZXDH_ERR;
10697 : : }
10698 : 0 : row_index = (index << 6);
10699 : 0 : cpu_ind_cmd.cpu_req_mode = 2;
10700 : 0 : break;
10701 : 0 : case ZXDH_ERAM128_OPR_32b:
10702 [ # # ]: 0 : if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
10703 : 0 : PMD_DRV_LOG(ERR, "index out of range!");
10704 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10705 : 0 : return ZXDH_ERR;
10706 : : }
10707 : 0 : row_index = (index << 5);
10708 : 0 : cpu_ind_cmd.cpu_req_mode = 1;
10709 : 0 : break;
10710 : 0 : case ZXDH_ERAM128_OPR_1b:
10711 : 0 : PMD_DRV_LOG(ERR, "rd_clr_mode[%u] or rd_mode[%u] error!",
10712 : : rd_clr_mode, rd_mode);
10713 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10714 : 0 : return ZXDH_ERR;
10715 : : default:
10716 : : break;
10717 : : }
10718 : 0 : cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index;
10719 : : }
10720 : :
10721 : 0 : rc = zxdh_np_reg_write(dev_id,
10722 : : ZXDH_SMMU0_SMMU0_CPU_IND_CMDR,
10723 : : 0,
10724 : : 0,
10725 : : &cpu_ind_cmd);
10726 [ # # ]: 0 : if (rc != ZXDH_OK) {
10727 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_reg_write failed, rc=0x%x.", rc);
10728 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10729 : 0 : return ZXDH_ERR;
10730 : : }
10731 : :
10732 : 0 : rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_CPU_IND_RD_DONER, 0);
10733 [ # # ]: 0 : if (rc != ZXDH_OK) {
10734 : 0 : PMD_DRV_LOG(ERR, "se done status check failed, rc=0x%x.", rc);
10735 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10736 : 0 : return ZXDH_ERR;
10737 : : }
10738 : :
10739 : : p_temp_data = temp_data;
10740 [ # # ]: 0 : for (i = 0; i < 4; i++) {
10741 : 0 : rc = zxdh_np_reg_read(dev_id,
10742 : : ZXDH_SMMU0_SMMU0_CPU_IND_RDAT0R + i,
10743 : : 0,
10744 : : 0,
10745 : 0 : p_temp_data + 3 - i);
10746 [ # # ]: 0 : if (rc != ZXDH_OK) {
10747 : 0 : PMD_DRV_LOG(ERR, "zxdh_np_reg_write failed, rc=0x%x.", rc);
10748 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10749 : 0 : return ZXDH_ERR;
10750 : : }
10751 : : }
10752 : :
10753 [ # # ]: 0 : if (rd_clr_mode == ZXDH_RD_MODE_HOLD) {
10754 [ # # # # : 0 : switch (rd_mode) {
# ]
10755 : : case ZXDH_ERAM128_OPR_128b:
10756 : : memcpy(p_data, p_temp_data, (128 / 8));
10757 : : break;
10758 : 0 : case ZXDH_ERAM128_OPR_64b:
10759 : 0 : memcpy(p_data, p_temp_data + ((1 - col_index) << 1), (64 / 8));
10760 : : break;
10761 : 0 : case ZXDH_ERAM128_OPR_32b:
10762 : 0 : memcpy(p_data, p_temp_data + ((3 - col_index)), (32 / 8));
10763 : : break;
10764 : 0 : case ZXDH_ERAM128_OPR_1b:
10765 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0],
10766 : : *(p_temp_data + (3 - col_index / 32)), (col_index % 32), 1);
10767 : 0 : break;
10768 : : default:
10769 : : break;
10770 : : }
10771 : : } else {
10772 [ # # # # ]: 0 : switch (rd_mode) {
10773 : : case ZXDH_ERAM128_OPR_128b:
10774 : : memcpy(p_data, p_temp_data, (128 / 8));
10775 : : break;
10776 : : case ZXDH_ERAM128_OPR_64b:
10777 : : memcpy(p_data, p_temp_data, (64 / 8));
10778 : : break;
10779 : : case ZXDH_ERAM128_OPR_32b:
10780 : : memcpy(p_data, p_temp_data, (64 / 8));
10781 : : break;
10782 : : default:
10783 : : break;
10784 : : }
10785 : : }
10786 : :
10787 : 0 : rte_spinlock_unlock(&p_ind_spinlock->spinlock);
10788 : :
10789 : 0 : return rc;
10790 : : }
10791 : :
10792 : : uint32_t
10793 : 0 : zxdh_np_stat_ppu_cnt_get_ex(uint32_t dev_id,
10794 : : ZXDH_STAT_CNT_MODE_E rd_mode,
10795 : : uint32_t index,
10796 : : uint32_t clr_mode,
10797 : : uint32_t *p_data)
10798 : : {
10799 : : uint32_t rc = 0;
10800 : : uint32_t ppu_eram_baddr = 0;
10801 : : uint32_t ppu_eram_depth = 0;
10802 : : uint32_t eram_rd_mode = 0;
10803 : : uint32_t eram_clr_mode = 0;
10804 : : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
10805 : :
10806 : : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
10807 : :
10808 : : ppu_eram_depth = stat_cfg.eram_depth;
10809 : : ppu_eram_baddr = stat_cfg.eram_baddr;
10810 : :
10811 [ # # ]: 0 : if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) {
10812 [ # # ]: 0 : if (rd_mode == ZXDH_STAT_128_MODE)
10813 : : eram_rd_mode = ZXDH_ERAM128_OPR_128b;
10814 : : else
10815 : : eram_rd_mode = ZXDH_ERAM128_OPR_64b;
10816 : :
10817 [ # # ]: 0 : if (clr_mode == ZXDH_STAT_RD_CLR_MODE_UNCLR)
10818 : : eram_clr_mode = ZXDH_RD_MODE_HOLD;
10819 : : else
10820 : : eram_clr_mode = ZXDH_RD_MODE_CLEAR;
10821 : :
10822 : 0 : rc = zxdh_np_se_smmu0_ind_read(dev_id,
10823 : : ppu_eram_baddr,
10824 : : index,
10825 : : eram_rd_mode,
10826 : : eram_clr_mode,
10827 : : p_data);
10828 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_smmu0_ind_read");
10829 : : } else {
10830 : 0 : PMD_DRV_LOG(ERR, "DPDK DON'T HAVE DDR STAT.");
10831 : : }
10832 : :
10833 : 0 : return rc;
10834 : : }
10835 : :
10836 : : static uint32_t
10837 : 0 : zxdh_np_agent_channel_plcr_sync_send(uint32_t dev_id, ZXDH_AGENT_CHANNEL_PLCR_MSG_T *p_msg,
10838 : : uint32_t *p_data, uint32_t rep_len)
10839 : : {
10840 : : uint32_t ret = 0;
10841 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
10842 : : .msg = (void *)p_msg,
10843 : : .msg_len = sizeof(ZXDH_AGENT_CHANNEL_PLCR_MSG_T),
10844 : : };
10845 : :
10846 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_data, rep_len);
10847 [ # # ]: 0 : if (ret != 0) {
10848 : 0 : PMD_DRV_LOG(ERR, "agent_channel_sync_send failed.");
10849 : 0 : return 1;
10850 : : }
10851 : :
10852 : : return 0;
10853 : : }
10854 : :
10855 : : static uint32_t
10856 : 0 : zxdh_np_agent_channel_plcr_profileid_request(uint32_t dev_id, uint32_t vport,
10857 : : uint32_t car_type, uint32_t *p_profileid)
10858 : : {
10859 : : uint32_t ret = 0;
10860 : 0 : uint32_t resp_buffer[2] = {0};
10861 : :
10862 : 0 : ZXDH_AGENT_CHANNEL_PLCR_MSG_T msgcfg = {
10863 : : .dev_id = 0,
10864 : : .type = ZXDH_PLCR_MSG,
10865 : : .oper = ZXDH_PROFILEID_REQUEST,
10866 : : .vport = vport,
10867 : : .car_type = car_type,
10868 : : .profile_id = 0xFFFF,
10869 : : };
10870 : :
10871 : 0 : ret = zxdh_np_agent_channel_plcr_sync_send(dev_id, &msgcfg,
10872 : : resp_buffer, sizeof(resp_buffer));
10873 [ # # ]: 0 : if (ret != 0) {
10874 : 0 : PMD_DRV_LOG(ERR, "agent_channel_plcr_sync_send failed.");
10875 : 0 : return 1;
10876 : : }
10877 : :
10878 : : memcpy(p_profileid, resp_buffer, sizeof(uint32_t) * ZXDH_SCHE_RSP_LEN);
10879 : :
10880 : 0 : return ret;
10881 : : }
10882 : :
10883 : : static uint32_t
10884 : 0 : zxdh_np_agent_channel_plcr_car_rate(uint32_t dev_id,
10885 : : uint32_t car_type,
10886 : : uint32_t pkt_sign,
10887 : : uint32_t profile_id __rte_unused,
10888 : : void *p_car_profile_cfg)
10889 : : {
10890 : : uint32_t ret = 0;
10891 : 0 : uint32_t resp_buffer[2] = {0};
10892 : : uint32_t resp_len = 8;
10893 : : uint32_t i = 0;
10894 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {0};
10895 : 0 : ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T msgpktcfg = {0};
10896 : 0 : ZXDH_AGENT_CAR_PROFILE_MSG_T msgcfg = {0};
10897 : : ZXDH_STAT_CAR_PROFILE_CFG_T *p_stat_car_profile_cfg = NULL;
10898 : : ZXDH_STAT_CAR_PKT_PROFILE_CFG_T *p_stat_pkt_car_profile_cfg = NULL;
10899 : :
10900 [ # # ]: 0 : if (car_type == ZXDH_STAT_CAR_A_TYPE && pkt_sign == 1) {
10901 : : p_stat_pkt_car_profile_cfg = (ZXDH_STAT_CAR_PKT_PROFILE_CFG_T *)p_car_profile_cfg;
10902 : : msgpktcfg.dev_id = 0;
10903 : 0 : msgpktcfg.type = ZXDH_PLCR_CAR_PKT_RATE;
10904 : 0 : msgpktcfg.car_level = car_type;
10905 : 0 : msgpktcfg.cir = p_stat_pkt_car_profile_cfg->cir;
10906 : 0 : msgpktcfg.cbs = p_stat_pkt_car_profile_cfg->cbs;
10907 : 0 : msgpktcfg.profile_id = p_stat_pkt_car_profile_cfg->profile_id;
10908 : 0 : msgpktcfg.pkt_sign = p_stat_pkt_car_profile_cfg->pkt_sign;
10909 [ # # ]: 0 : for (i = 0; i < ZXDH_CAR_PRI_MAX; i++)
10910 : 0 : msgpktcfg.pri[i] = p_stat_pkt_car_profile_cfg->pri[i];
10911 : :
10912 : 0 : agent_msg.msg = (void *)&msgpktcfg;
10913 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T);
10914 : :
10915 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, resp_buffer, resp_len);
10916 [ # # ]: 0 : if (ret != 0) {
10917 : 0 : PMD_DRV_LOG(ERR, "stat_car_a_type failed.");
10918 : 0 : return 1;
10919 : : }
10920 : :
10921 : 0 : ret = *(uint8_t *)resp_buffer;
10922 : : } else {
10923 : : p_stat_car_profile_cfg = (ZXDH_STAT_CAR_PROFILE_CFG_T *)p_car_profile_cfg;
10924 : : msgcfg.dev_id = 0;
10925 : 0 : msgcfg.type = ZXDH_PLCR_CAR_RATE;
10926 : 0 : msgcfg.car_level = car_type;
10927 : 0 : msgcfg.cir = p_stat_car_profile_cfg->cir;
10928 : 0 : msgcfg.cbs = p_stat_car_profile_cfg->cbs;
10929 : 0 : msgcfg.profile_id = p_stat_car_profile_cfg->profile_id;
10930 : 0 : msgcfg.pkt_sign = p_stat_car_profile_cfg->pkt_sign;
10931 : 0 : msgcfg.cd = p_stat_car_profile_cfg->cd;
10932 : 0 : msgcfg.cf = p_stat_car_profile_cfg->cf;
10933 : 0 : msgcfg.cm = p_stat_car_profile_cfg->cm;
10934 : : msgcfg.cir = p_stat_car_profile_cfg->cir;
10935 : : msgcfg.cbs = p_stat_car_profile_cfg->cbs;
10936 : 0 : msgcfg.eir = p_stat_car_profile_cfg->eir;
10937 : 0 : msgcfg.ebs = p_stat_car_profile_cfg->ebs;
10938 : 0 : msgcfg.random_disc_e = p_stat_car_profile_cfg->random_disc_e;
10939 : 0 : msgcfg.random_disc_c = p_stat_car_profile_cfg->random_disc_c;
10940 [ # # ]: 0 : for (i = 0; i < ZXDH_CAR_PRI_MAX; i++) {
10941 : 0 : msgcfg.c_pri[i] = p_stat_car_profile_cfg->c_pri[i];
10942 : 0 : msgcfg.e_green_pri[i] = p_stat_car_profile_cfg->e_green_pri[i];
10943 : 0 : msgcfg.e_yellow_pri[i] = p_stat_car_profile_cfg->e_yellow_pri[i];
10944 : : }
10945 : :
10946 : 0 : agent_msg.msg = (void *)&msgcfg;
10947 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PROFILE_MSG_T);
10948 : :
10949 : 0 : ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, resp_buffer, resp_len);
10950 [ # # ]: 0 : if (ret != 0) {
10951 : 0 : PMD_DRV_LOG(ERR, "stat_car_b_type failed.");
10952 : 0 : return 1;
10953 : : }
10954 : :
10955 : 0 : ret = *(uint8_t *)resp_buffer;
10956 : : }
10957 : :
10958 : : return ret;
10959 : : }
10960 : :
10961 : : static uint32_t
10962 : 0 : zxdh_np_agent_channel_plcr_profileid_release(uint32_t dev_id, uint32_t vport,
10963 : : uint32_t car_type __rte_unused,
10964 : : uint32_t profileid)
10965 : : {
10966 : : uint32_t ret = 0;
10967 : 0 : uint32_t resp_buffer[2] = {0};
10968 : :
10969 : 0 : ZXDH_AGENT_CHANNEL_PLCR_MSG_T msgcfg = {
10970 : : .dev_id = 0,
10971 : : .type = ZXDH_PLCR_MSG,
10972 : : .oper = ZXDH_PROFILEID_RELEASE,
10973 : : .vport = vport,
10974 : : .profile_id = profileid,
10975 : : };
10976 : :
10977 : 0 : ret = zxdh_np_agent_channel_plcr_sync_send(dev_id, &msgcfg,
10978 : : resp_buffer, sizeof(resp_buffer));
10979 [ # # ]: 0 : if (ret != 0) {
10980 : 0 : PMD_DRV_LOG(ERR, "agent_channel_plcr_sync_send failed.");
10981 : 0 : return 1;
10982 : : }
10983 : :
10984 : 0 : ret = *(uint8_t *)resp_buffer;
10985 : :
10986 : 0 : return ret;
10987 : : }
10988 : :
10989 : : static uint32_t
10990 : 0 : zxdh_np_stat_cara_queue_cfg_set(uint32_t dev_id,
10991 : : uint32_t flow_id,
10992 : : uint32_t drop_flag,
10993 : : uint32_t plcr_en,
10994 : : uint32_t profile_id)
10995 : : {
10996 : : uint32_t rc = 0;
10997 : :
10998 : 0 : ZXDH_STAT_CAR0_CARA_QUEUE_RAM0_159_0_T queue_cfg = {
10999 : : .cara_drop = drop_flag,
11000 : : .cara_plcr_en = plcr_en,
11001 : : .cara_profile_id = profile_id,
11002 : : };
11003 : :
11004 : 0 : rc = zxdh_np_reg_write(dev_id,
11005 : : ZXDH_STAT_CAR0_CARA_QUEUE_RAM0,
11006 : : 0,
11007 : : flow_id,
11008 : : &queue_cfg);
11009 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
11010 : :
11011 : 0 : return rc;
11012 : : }
11013 : :
11014 : : static uint32_t
11015 : 0 : zxdh_np_stat_carb_queue_cfg_set(uint32_t dev_id,
11016 : : uint32_t flow_id,
11017 : : uint32_t drop_flag,
11018 : : uint32_t plcr_en,
11019 : : uint32_t profile_id)
11020 : : {
11021 : : uint32_t rc = 0;
11022 : :
11023 : 0 : ZXDH_STAT_CAR0_CARB_QUEUE_RAM0_159_0_T queue_cfg = {
11024 : : .carb_drop = drop_flag,
11025 : : .carb_plcr_en = plcr_en,
11026 : : .carb_profile_id = profile_id,
11027 : : };
11028 : :
11029 : 0 : rc = zxdh_np_reg_write(dev_id,
11030 : : ZXDH_STAT_CAR0_CARB_QUEUE_RAM0,
11031 : : 0,
11032 : : flow_id,
11033 : : &queue_cfg);
11034 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
11035 : :
11036 : 0 : return rc;
11037 : : }
11038 : :
11039 : : static uint32_t
11040 : 0 : zxdh_np_stat_carc_queue_cfg_set(uint32_t dev_id,
11041 : : uint32_t flow_id,
11042 : : uint32_t drop_flag,
11043 : : uint32_t plcr_en,
11044 : : uint32_t profile_id)
11045 : : {
11046 : : uint32_t rc = 0;
11047 : :
11048 : 0 : ZXDH_STAT_CAR0_CARC_QUEUE_RAM0_159_0_T queue_cfg = {
11049 : : .carc_drop = drop_flag,
11050 : : .carc_plcr_en = plcr_en,
11051 : : .carc_profile_id = profile_id,
11052 : : };
11053 : :
11054 : 0 : rc = zxdh_np_reg_write(dev_id,
11055 : : ZXDH_STAT_CAR0_CARC_QUEUE_RAM0,
11056 : : 0,
11057 : : flow_id,
11058 : : &queue_cfg);
11059 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
11060 : :
11061 : 0 : return rc;
11062 : : }
11063 : :
11064 : : uint32_t
11065 : 0 : zxdh_np_car_profile_id_add(uint32_t dev_id,
11066 : : uint32_t vport_id,
11067 : : uint32_t flags,
11068 : : uint64_t *p_profile_id)
11069 : : {
11070 : : uint32_t ret = 0;
11071 : : uint32_t *profile_id;
11072 : : uint32_t profile_id_h = 0;
11073 : : uint32_t profile_id_l = 0;
11074 : : uint64_t temp_profile_id = 0;
11075 : :
11076 : 0 : profile_id = rte_zmalloc(NULL, ZXDH_G_PROFILE_ID_LEN, 0);
11077 [ # # ]: 0 : if (profile_id == NULL) {
11078 : 0 : PMD_DRV_LOG(ERR, "profile_id point null!");
11079 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
11080 : : }
11081 : 0 : ret = zxdh_np_agent_channel_plcr_profileid_request(dev_id, vport_id, flags, profile_id);
11082 : :
11083 : 0 : profile_id_h = *(profile_id + 1);
11084 : 0 : profile_id_l = *profile_id;
11085 : 0 : rte_free(profile_id);
11086 : :
11087 : 0 : temp_profile_id = (((uint64_t)profile_id_l) << 32) | ((uint64_t)profile_id_h);
11088 [ # # ]: 0 : if (0 != (uint32_t)(temp_profile_id >> 56)) {
11089 : 0 : PMD_DRV_LOG(ERR, "profile_id is overflow!");
11090 : 0 : return 1;
11091 : : }
11092 : :
11093 : 0 : *p_profile_id = temp_profile_id;
11094 : :
11095 : 0 : return ret;
11096 : : }
11097 : :
11098 : : uint32_t
11099 : 0 : zxdh_np_car_profile_cfg_set(uint32_t dev_id,
11100 : : uint32_t vport_id __rte_unused,
11101 : : uint32_t car_type,
11102 : : uint32_t pkt_sign,
11103 : : uint32_t profile_id,
11104 : : void *p_car_profile_cfg)
11105 : : {
11106 : : uint32_t ret = 0;
11107 : :
11108 : 0 : ret = zxdh_np_agent_channel_plcr_car_rate(dev_id, car_type,
11109 : : pkt_sign, profile_id, p_car_profile_cfg);
11110 [ # # ]: 0 : if (ret != 0) {
11111 : 0 : PMD_DRV_LOG(ERR, "plcr_car_rate set failed!");
11112 : 0 : return 1;
11113 : : }
11114 : :
11115 : : return ret;
11116 : : }
11117 : :
11118 : : uint32_t
11119 : 0 : zxdh_np_car_profile_id_delete(uint32_t dev_id, uint32_t vport_id,
11120 : : uint32_t flags, uint64_t profile_id)
11121 : : {
11122 : : uint32_t ret = 0;
11123 : 0 : uint32_t profileid = profile_id & 0xFFFF;
11124 : :
11125 : 0 : ret = zxdh_np_agent_channel_plcr_profileid_release(dev_id, vport_id, flags, profileid);
11126 [ # # ]: 0 : if (ret != 0) {
11127 : 0 : PMD_DRV_LOG(ERR, "plcr profiled id release failed!");
11128 : 0 : return 1;
11129 : : }
11130 : :
11131 : : return 0;
11132 : : }
11133 : :
11134 : : uint32_t
11135 : 0 : zxdh_np_stat_car_queue_cfg_set(uint32_t dev_id,
11136 : : uint32_t car_type,
11137 : : uint32_t flow_id,
11138 : : uint32_t drop_flag,
11139 : : uint32_t plcr_en,
11140 : : uint32_t profile_id)
11141 : : {
11142 : : uint32_t rc = 0;
11143 : :
11144 [ # # ]: 0 : if (car_type == ZXDH_STAT_CAR_A_TYPE) {
11145 [ # # ]: 0 : if (flow_id > ZXDH_CAR_A_FLOW_ID_MAX) {
11146 : 0 : PMD_DRV_LOG(ERR, "stat car a type flow_id invalid!");
11147 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11148 : : }
11149 : :
11150 [ # # ]: 0 : if (profile_id > ZXDH_CAR_A_PROFILE_ID_MAX) {
11151 : 0 : PMD_DRV_LOG(ERR, "stat car a type profile_id invalid!");
11152 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11153 : : }
11154 [ # # ]: 0 : } else if (car_type == ZXDH_STAT_CAR_B_TYPE) {
11155 [ # # ]: 0 : if (flow_id > ZXDH_CAR_B_FLOW_ID_MAX) {
11156 : 0 : PMD_DRV_LOG(ERR, "stat car b type flow_id invalid!");
11157 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11158 : : }
11159 : :
11160 [ # # ]: 0 : if (profile_id > ZXDH_CAR_B_PROFILE_ID_MAX) {
11161 : 0 : PMD_DRV_LOG(ERR, "stat car b type profile_id invalid!");
11162 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11163 : : }
11164 : : } else {
11165 [ # # ]: 0 : if (flow_id > ZXDH_CAR_C_FLOW_ID_MAX) {
11166 : 0 : PMD_DRV_LOG(ERR, "stat car c type flow_id invalid!");
11167 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11168 : : }
11169 : :
11170 [ # # ]: 0 : if (profile_id > ZXDH_CAR_C_PROFILE_ID_MAX) {
11171 : 0 : PMD_DRV_LOG(ERR, "stat car c type profile_id invalid!");
11172 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
11173 : : }
11174 : : }
11175 : :
11176 [ # # # # ]: 0 : switch (car_type) {
11177 : 0 : case ZXDH_STAT_CAR_A_TYPE:
11178 : 0 : rc = zxdh_np_stat_cara_queue_cfg_set(dev_id,
11179 : : flow_id,
11180 : : drop_flag,
11181 : : plcr_en,
11182 : : profile_id);
11183 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_cara_queue_cfg_set");
11184 : : break;
11185 : :
11186 : 0 : case ZXDH_STAT_CAR_B_TYPE:
11187 : 0 : rc = zxdh_np_stat_carb_queue_cfg_set(dev_id,
11188 : : flow_id,
11189 : : drop_flag,
11190 : : plcr_en,
11191 : : profile_id);
11192 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_carb_queue_cfg_set");
11193 : : break;
11194 : :
11195 : 0 : case ZXDH_STAT_CAR_C_TYPE:
11196 : 0 : rc = zxdh_np_stat_carc_queue_cfg_set(dev_id,
11197 : : flow_id,
11198 : : drop_flag,
11199 : : plcr_en,
11200 : : profile_id);
11201 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_carc_queue_cfg_set");
11202 : : break;
11203 : : }
11204 : :
11205 : : return rc;
11206 : : }
|
