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 uint64_t g_np_bar_offset;
19 : : static ZXDH_DEV_MGR_T g_dev_mgr;
20 : : static ZXDH_SDT_MGR_T g_sdt_mgr;
21 : : static uint32_t g_dpp_dtb_int_enable;
22 : : static uint32_t g_table_type[ZXDH_DEV_CHANNEL_MAX][ZXDH_DEV_SDT_ID_MAX];
23 : : static ZXDH_PPU_CLS_BITMAP_T g_ppu_cls_bit_map[ZXDH_DEV_CHANNEL_MAX];
24 : : static ZXDH_DTB_MGR_T *p_dpp_dtb_mgr[ZXDH_DEV_CHANNEL_MAX];
25 : : static ZXDH_RISCV_DTB_MGR *p_riscv_dtb_queue_mgr[ZXDH_DEV_CHANNEL_MAX];
26 : : static ZXDH_TLB_MGR_T *g_p_dpp_tlb_mgr[ZXDH_DEV_CHANNEL_MAX];
27 : : static ZXDH_REG_T g_dpp_reg_info[4];
28 : : static ZXDH_DTB_TABLE_T g_dpp_dtb_table_info[4];
29 : : static ZXDH_SDT_TBL_DATA_T g_sdt_info[ZXDH_DEV_CHANNEL_MAX][ZXDH_DEV_SDT_ID_MAX];
30 : : static ZXDH_PPU_STAT_CFG_T g_ppu_stat_cfg;
31 : :
32 : : #define ZXDH_SDT_MGR_PTR_GET() (&g_sdt_mgr)
33 : : #define ZXDH_SDT_SOFT_TBL_GET(id) (g_sdt_mgr.sdt_tbl_array[id])
34 : :
35 : : #define ZXDH_COMM_MASK_BIT(_bitnum_)\
36 : : (0x1U << (_bitnum_))
37 : :
38 : : #define ZXDH_COMM_GET_BIT_MASK(_inttype_, _bitqnt_)\
39 : : ((_inttype_)(((_bitqnt_) < 32)))
40 : :
41 : : #define ZXDH_COMM_UINT32_GET_BITS(_uidst_, _uisrc_, _uistartpos_, _uilen_)\
42 : : ((_uidst_) = (((_uisrc_) >> (_uistartpos_)) & \
43 : : (ZXDH_COMM_GET_BIT_MASK(uint32_t, (_uilen_)))))
44 : :
45 : : #define ZXDH_REG_DATA_MAX (128)
46 : :
47 : : #define ZXDH_COMM_CHECK_DEV_POINT(dev_id, point)\
48 : : do {\
49 : : if (NULL == (point)) {\
50 : : PMD_DRV_LOG(ERR, "dev: %d ZXIC %s:%d[Error:POINT NULL] !"\
51 : : "FUNCTION : %s!", (dev_id), __FILE__, __LINE__, __func__);\
52 : : RTE_ASSERT(0);\
53 : : } \
54 : : } while (0)
55 : :
56 : : #define ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, becall)\
57 : : do {\
58 : : if ((rc) != 0) {\
59 : : PMD_DRV_LOG(ERR, "dev: %d ZXIC %s:%d !"\
60 : : "-- %s Call %s Fail!", (dev_id), __FILE__, __LINE__, __func__, becall);\
61 : : RTE_ASSERT(0);\
62 : : } \
63 : : } while (0)
64 : :
65 : : #define ZXDH_COMM_CHECK_POINT_NO_ASSERT(point)\
66 : : do {\
67 : : if ((point) == NULL) {\
68 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d[Error:POINT NULL] ! FUNCTION : %s!",\
69 : : __FILE__, __LINE__, __func__);\
70 : : } \
71 : : } while (0)
72 : :
73 : : #define ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, becall)\
74 : : do {\
75 : : if ((rc) != 0) {\
76 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d !-- %s Call %s"\
77 : : " Fail!", __FILE__, __LINE__, __func__, becall);\
78 : : } \
79 : : } while (0)
80 : :
81 : : #define ZXDH_COMM_CHECK_RC(rc, becall)\
82 : : do {\
83 : : if ((rc) != 0) {\
84 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d!-- %s Call %s "\
85 : : "Fail!", __FILE__, __LINE__, __func__, becall);\
86 : : RTE_ASSERT(0);\
87 : : } \
88 : : } while (0)
89 : :
90 : : #define ZXDH_COMM_CHECK_POINT(point)\
91 : : do {\
92 : : if ((point) == NULL) {\
93 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d[Error:POINT NULL] ! FUNCTION : %s!",\
94 : : __FILE__, __LINE__, __func__);\
95 : : RTE_ASSERT(0);\
96 : : } \
97 : : } while (0)
98 : :
99 : :
100 : : #define ZXDH_COMM_CHECK_POINT_MEMORY_FREE(point, ptr)\
101 : : do {\
102 : : if ((point) == NULL) {\
103 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d[Error:POINT NULL] !"\
104 : : "FUNCTION : %s!", __FILE__, __LINE__, __func__);\
105 : : rte_free(ptr);\
106 : : RTE_ASSERT(0);\
107 : : } \
108 : : } while (0)
109 : :
110 : : #define ZXDH_COMM_CHECK_RC_MEMORY_FREE_NO_ASSERT(rc, becall, ptr)\
111 : : do {\
112 : : if ((rc) != 0) {\
113 : : PMD_DRV_LOG(ERR, "ZXICP %s:%d, %s Call"\
114 : : " %s Fail!", __FILE__, __LINE__, __func__, becall);\
115 : : rte_free(ptr);\
116 : : } \
117 : : } while (0)
118 : :
119 : : #define ZXDH_COMM_CONVERT16(w_data) \
120 : : (((w_data) & 0xff) << 8)
121 : :
122 : : #define ZXDH_DTB_TAB_UP_WR_INDEX_GET(DEV_ID, QUEUE_ID) \
123 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.wr_index)
124 : :
125 : : #define ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(DEV_ID, QUEUE_ID, INDEX) \
126 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.user_addr[(INDEX)].user_flag)
127 : :
128 : : #define ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
129 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.user_addr[(INDEX)].phy_addr)
130 : :
131 : : #define ZXDH_DTB_TAB_UP_DATA_LEN_GET(DEV_ID, QUEUE_ID, INDEX) \
132 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.data_len[(INDEX)])
133 : :
134 : : #define ZXDH_DTB_TAB_UP_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
135 : : ((INDEX) * p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.item_size)
136 : :
137 : : #define ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
138 : : ((INDEX) * p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_down.item_size)
139 : :
140 : : #define ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(DEV_ID, QUEUE_ID) \
141 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_down.wr_index)
142 : :
143 : : #define ZXDH_DTB_QUEUE_INIT_FLAG_GET(DEV_ID, QUEUE_ID) \
144 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].init_flag)
145 : :
146 : : ZXDH_FIELD_T g_stat_car0_cara_queue_ram0_159_0_reg[] = {
147 : : {"cara_drop", ZXDH_FIELD_FLAG_RW, 147, 1, 0x0, 0x0},
148 : : {"cara_plcr_en", ZXDH_FIELD_FLAG_RW, 146, 1, 0x0, 0x0},
149 : : {"cara_profile_id", ZXDH_FIELD_FLAG_RW, 145, 9, 0x0, 0x0},
150 : : {"cara_tq_h", ZXDH_FIELD_FLAG_RO, 136, 13, 0x0, 0x0},
151 : : {"cara_tq_l", ZXDH_FIELD_FLAG_RO, 123, 32, 0x0, 0x0},
152 : : {"cara_ted", ZXDH_FIELD_FLAG_RO, 91, 19, 0x0, 0x0},
153 : : {"cara_tcd", ZXDH_FIELD_FLAG_RO, 72, 19, 0x0, 0x0},
154 : : {"cara_tei", ZXDH_FIELD_FLAG_RO, 53, 27, 0x0, 0x0},
155 : : {"cara_tci", ZXDH_FIELD_FLAG_RO, 26, 27, 0x0, 0x0},
156 : : };
157 : :
158 : : ZXDH_FIELD_T g_stat_car0_carb_queue_ram0_159_0_reg[] = {
159 : : {"carb_drop", ZXDH_FIELD_FLAG_RW, 147, 1, 0x0, 0x0},
160 : : {"carb_plcr_en", ZXDH_FIELD_FLAG_RW, 146, 1, 0x0, 0x0},
161 : : {"carb_profile_id", ZXDH_FIELD_FLAG_RW, 145, 9, 0x0, 0x0},
162 : : {"carb_tq_h", ZXDH_FIELD_FLAG_RO, 136, 13, 0x0, 0x0},
163 : : {"carb_tq_l", ZXDH_FIELD_FLAG_RO, 123, 32, 0x0, 0x0},
164 : : {"carb_ted", ZXDH_FIELD_FLAG_RO, 91, 19, 0x0, 0x0},
165 : : {"carb_tcd", ZXDH_FIELD_FLAG_RO, 72, 19, 0x0, 0x0},
166 : : {"carb_tei", ZXDH_FIELD_FLAG_RO, 53, 27, 0x0, 0x0},
167 : : {"carb_tci", ZXDH_FIELD_FLAG_RO, 26, 27, 0x0, 0x0},
168 : : };
169 : :
170 : : ZXDH_FIELD_T g_stat_car0_carc_queue_ram0_159_0_reg[] = {
171 : : {"carc_drop", ZXDH_FIELD_FLAG_RW, 147, 1, 0x0, 0x0},
172 : : {"carc_plcr_en", ZXDH_FIELD_FLAG_RW, 146, 1, 0x0, 0x0},
173 : : {"carc_profile_id", ZXDH_FIELD_FLAG_RW, 145, 9, 0x0, 0x0},
174 : : {"carc_tq_h", ZXDH_FIELD_FLAG_RO, 136, 13, 0x0, 0x0},
175 : : {"carc_tq_l", ZXDH_FIELD_FLAG_RO, 123, 32, 0x0, 0x0},
176 : : {"carc_ted", ZXDH_FIELD_FLAG_RO, 91, 19, 0x0, 0x0},
177 : : {"carc_tcd", ZXDH_FIELD_FLAG_RO, 72, 19, 0x0, 0x0},
178 : : {"carc_tei", ZXDH_FIELD_FLAG_RO, 53, 27, 0x0, 0x0},
179 : : {"carc_tci", ZXDH_FIELD_FLAG_RO, 26, 27, 0x0, 0x0},
180 : : };
181 : :
182 : : ZXDH_FIELD_T g_nppu_pktrx_cfg_pktrx_glbal_cfg_0_reg[] = {
183 : : {"pktrx_glbal_cfg_0", ZXDH_FIELD_FLAG_RW, 31, 32, 0x0, 0x0},
184 : : };
185 : :
186 : : static uint32_t
187 : : zxdh_np_comm_is_big_endian(void)
188 : : {
189 : : ZXDH_ENDIAN_U c_data;
190 : :
191 : : c_data.a = 1;
192 : :
193 : : if (c_data.b == 1)
194 : : return 0;
195 : : else
196 : : return 1;
197 : : }
198 : :
199 : : static void
200 : : zxdh_np_comm_swap(uint8_t *p_uc_data, uint32_t dw_byte_len)
201 : : {
202 : : uint16_t *p_w_tmp = NULL;
203 : : uint32_t *p_dw_tmp = NULL;
204 : : uint32_t dw_byte_num;
205 : : uint8_t uc_byte_mode;
206 : : uint32_t uc_is_big_flag;
207 : : uint32_t i;
208 : :
209 : : p_dw_tmp = (uint32_t *)(p_uc_data);
210 : : uc_is_big_flag = zxdh_np_comm_is_big_endian();
211 : : if (uc_is_big_flag)
212 : : return;
213 : :
214 : 0 : dw_byte_num = dw_byte_len >> 2;
215 : 0 : uc_byte_mode = dw_byte_len % 4 & 0xff;
216 : :
217 [ # # ]: 0 : for (i = 0; i < dw_byte_num; i++) {
218 : 0 : (*p_dw_tmp) = ZXDH_COMM_CONVERT16(*p_dw_tmp);
219 : 0 : p_dw_tmp++;
220 : : }
221 : :
222 [ # # ]: 0 : if (uc_byte_mode > 1) {
223 : : p_w_tmp = (uint16_t *)(p_dw_tmp);
224 : 0 : (*p_w_tmp) = ZXDH_COMM_CONVERT16(*p_w_tmp);
225 : : }
226 : : }
227 : :
228 : : static uint32_t
229 : 0 : zxdh_np_dev_init(void)
230 : : {
231 [ # # ]: 0 : if (g_dev_mgr.is_init) {
232 : 0 : PMD_DRV_LOG(ERR, "Dev is already initialized");
233 : 0 : return 0;
234 : : }
235 : :
236 : 0 : g_dev_mgr.device_num = 0;
237 : 0 : g_dev_mgr.is_init = 1;
238 : :
239 : 0 : return 0;
240 : : }
241 : :
242 : : static uint32_t
243 : 0 : zxdh_np_dev_add(uint32_t dev_id, ZXDH_DEV_TYPE_E dev_type,
244 : : ZXDH_DEV_ACCESS_TYPE_E access_type, uint64_t pcie_addr,
245 : : uint64_t riscv_addr, uint64_t dma_vir_addr,
246 : : uint64_t dma_phy_addr)
247 : : {
248 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
249 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
250 : :
251 : : p_dev_mgr = &g_dev_mgr;
252 [ # # ]: 0 : if (!p_dev_mgr->is_init) {
253 : 0 : PMD_DRV_LOG(ERR, "ErrorCode[ 0x%x]: Device Manager is not init",
254 : : ZXDH_RC_DEV_MGR_NOT_INIT);
255 : 0 : return ZXDH_RC_DEV_MGR_NOT_INIT;
256 : : }
257 : :
258 [ # # ]: 0 : if (p_dev_mgr->p_dev_array[dev_id] != NULL) {
259 : : /* device is already exist. */
260 : 0 : PMD_DRV_LOG(ERR, "Device is added again");
261 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
262 : : } else {
263 : : /* device is new. */
264 : 0 : p_dev_info = rte_malloc(NULL, sizeof(ZXDH_DEV_CFG_T), 0);
265 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dev_info);
266 : 0 : p_dev_mgr->p_dev_array[dev_id] = p_dev_info;
267 : 0 : p_dev_mgr->device_num++;
268 : : }
269 : :
270 : 0 : p_dev_info->device_id = dev_id;
271 : 0 : p_dev_info->dev_type = dev_type;
272 : 0 : p_dev_info->access_type = access_type;
273 : 0 : p_dev_info->pcie_addr = pcie_addr;
274 : 0 : p_dev_info->riscv_addr = riscv_addr;
275 : 0 : p_dev_info->dma_vir_addr = dma_vir_addr;
276 : 0 : p_dev_info->dma_phy_addr = dma_phy_addr;
277 : :
278 : 0 : return 0;
279 : : }
280 : :
281 : : static uint32_t
282 : : zxdh_np_dev_agent_status_set(uint32_t dev_id, uint32_t agent_flag)
283 : : {
284 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
285 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
286 : :
287 : : p_dev_mgr = &g_dev_mgr;
288 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
289 : :
290 [ # # ]: 0 : if (p_dev_info == NULL)
291 : : return ZXDH_DEV_TYPE_INVALID;
292 : 0 : p_dev_info->agent_flag = agent_flag;
293 : :
294 : : return 0;
295 : : }
296 : :
297 : : static void
298 : 0 : zxdh_np_sdt_mgr_init(void)
299 : : {
300 [ # # ]: 0 : if (!g_sdt_mgr.is_init) {
301 : 0 : g_sdt_mgr.channel_num = 0;
302 : 0 : g_sdt_mgr.is_init = 1;
303 : : memset(g_sdt_mgr.sdt_tbl_array, 0, ZXDH_DEV_CHANNEL_MAX *
304 : : sizeof(ZXDH_SDT_SOFT_TABLE_T *));
305 : : }
306 : 0 : }
307 : :
308 : : static uint32_t
309 : 0 : zxdh_np_sdt_mgr_create(uint32_t dev_id)
310 : : {
311 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_tbl_temp = NULL;
312 : : ZXDH_SDT_MGR_T *p_sdt_mgr = NULL;
313 : :
314 : : p_sdt_mgr = ZXDH_SDT_MGR_PTR_GET();
315 : :
316 [ # # ]: 0 : if (ZXDH_SDT_SOFT_TBL_GET(dev_id) == NULL) {
317 : 0 : p_sdt_tbl_temp = rte_malloc(NULL, sizeof(ZXDH_SDT_SOFT_TABLE_T), 0);
318 : :
319 : 0 : p_sdt_tbl_temp->device_id = dev_id;
320 : 0 : memset(p_sdt_tbl_temp->sdt_array, 0, ZXDH_DEV_SDT_ID_MAX * sizeof(ZXDH_SDT_ITEM_T));
321 : :
322 : 0 : ZXDH_SDT_SOFT_TBL_GET(dev_id) = p_sdt_tbl_temp;
323 : :
324 : 0 : p_sdt_mgr->channel_num++;
325 : : } else {
326 : 0 : PMD_DRV_LOG(ERR, "Error: %s for dev[%d]"
327 : : "is called repeatedly!", __func__, dev_id);
328 : 0 : return 1;
329 : : }
330 : :
331 : 0 : return 0;
332 : : }
333 : :
334 : : static uint32_t
335 : 0 : zxdh_np_sdt_init(uint32_t dev_num, uint32_t *dev_id_array)
336 : : {
337 : : uint32_t rc;
338 : : uint32_t i;
339 : :
340 : 0 : zxdh_np_sdt_mgr_init();
341 : :
342 [ # # ]: 0 : for (i = 0; i < dev_num; i++) {
343 : 0 : rc = zxdh_np_sdt_mgr_create(dev_id_array[i]);
344 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_sdt_mgr_create");
345 : : }
346 : :
347 : 0 : return rc;
348 : : }
349 : :
350 : : static void
351 : 0 : zxdh_np_ppu_parse_cls_bitmap(uint32_t dev_id,
352 : : uint32_t bitmap)
353 : : {
354 : : uint32_t cls_id;
355 : : uint32_t mem_id;
356 : : uint32_t cls_use;
357 : : uint32_t instr_mem;
358 : :
359 [ # # ]: 0 : for (cls_id = 0; cls_id < ZXDH_PPU_CLUSTER_NUM; cls_id++) {
360 : 0 : cls_use = (bitmap >> cls_id) & 0x1;
361 : 0 : g_ppu_cls_bit_map[dev_id].cls_use[cls_id] = cls_use;
362 : : }
363 : :
364 [ # # ]: 0 : for (mem_id = 0; mem_id < ZXDH_PPU_INSTR_MEM_NUM; mem_id++) {
365 : 0 : instr_mem = (bitmap >> (mem_id * 2)) & 0x3;
366 : 0 : g_ppu_cls_bit_map[dev_id].instr_mem[mem_id] = ((instr_mem > 0) ? 1 : 0);
367 : : }
368 : 0 : }
369 : :
370 : : static ZXDH_DTB_MGR_T *
371 : : zxdh_np_dtb_mgr_get(uint32_t dev_id)
372 : : {
373 : : if (dev_id >= ZXDH_DEV_CHANNEL_MAX)
374 : : return NULL;
375 : : else
376 : 0 : return p_dpp_dtb_mgr[dev_id];
377 : : }
378 : :
379 : : static uint32_t
380 : 0 : zxdh_np_dtb_soft_init(uint32_t dev_id)
381 : : {
382 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
383 : :
384 [ # # ]: 0 : if (dev_id >= ZXDH_DEV_CHANNEL_MAX)
385 : : return 1;
386 : :
387 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
388 [ # # ]: 0 : if (p_dtb_mgr == NULL) {
389 : 0 : p_dpp_dtb_mgr[dev_id] = rte_zmalloc(NULL, sizeof(ZXDH_DTB_MGR_T), 0);
390 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
391 [ # # ]: 0 : if (p_dtb_mgr == NULL)
392 : 0 : return 1;
393 : : }
394 : :
395 : : return 0;
396 : : }
397 : :
398 : : static uint32_t
399 : 0 : zxdh_np_base_soft_init(uint32_t dev_id, ZXDH_SYS_INIT_CTRL_T *p_init_ctrl)
400 : : {
401 : 0 : uint32_t dev_id_array[ZXDH_DEV_CHANNEL_MAX] = {0};
402 : : uint32_t rt;
403 : : uint32_t access_type;
404 : : uint32_t agent_flag;
405 : :
406 : 0 : rt = zxdh_np_dev_init();
407 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_init");
408 : :
409 [ # # ]: 0 : if (p_init_ctrl->flags & ZXDH_INIT_FLAG_ACCESS_TYPE)
410 : : access_type = ZXDH_DEV_ACCESS_TYPE_RISCV;
411 : : else
412 : : access_type = ZXDH_DEV_ACCESS_TYPE_PCIE;
413 : :
414 [ # # ]: 0 : if (p_init_ctrl->flags & ZXDH_INIT_FLAG_AGENT_FLAG)
415 : : agent_flag = ZXDH_DEV_AGENT_ENABLE;
416 : : else
417 : : agent_flag = ZXDH_DEV_AGENT_DISABLE;
418 : :
419 : 0 : rt = zxdh_np_dev_add(dev_id,
420 : : p_init_ctrl->device_type,
421 : : access_type,
422 : : p_init_ctrl->pcie_vir_baddr,
423 : : p_init_ctrl->riscv_vir_baddr,
424 : : p_init_ctrl->dma_vir_baddr,
425 : : p_init_ctrl->dma_phy_baddr);
426 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_add");
427 : :
428 : : rt = zxdh_np_dev_agent_status_set(dev_id, agent_flag);
429 : 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_agent_status_set");
430 : :
431 : 0 : dev_id_array[0] = dev_id;
432 : 0 : rt = zxdh_np_sdt_init(1, dev_id_array);
433 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_sdt_init");
434 : :
435 : 0 : zxdh_np_ppu_parse_cls_bitmap(dev_id, ZXDH_PPU_CLS_ALL_START);
436 : :
437 : 0 : rt = zxdh_np_dtb_soft_init(dev_id);
438 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dtb_soft_init");
439 : :
440 : 0 : return rt;
441 : : }
442 : :
443 : : static void
444 : : zxdh_np_dev_vport_set(uint32_t dev_id, uint32_t vport)
445 : : {
446 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
447 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
448 : :
449 : : p_dev_mgr = &g_dev_mgr;
450 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
451 : 0 : p_dev_info->vport = vport;
452 : : }
453 : :
454 : : static void
455 : : zxdh_np_dev_agent_addr_set(uint32_t dev_id, uint64_t agent_addr)
456 : : {
457 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
458 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
459 : :
460 : : p_dev_mgr = &g_dev_mgr;
461 : : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
462 : 0 : p_dev_info->agent_addr = agent_addr;
463 : : }
464 : :
465 : : static uint64_t
466 : : zxdh_np_addr_calc(uint64_t pcie_vir_baddr, uint32_t bar_offset)
467 : : {
468 : : uint64_t np_addr;
469 : :
470 : 0 : np_addr = ((pcie_vir_baddr + bar_offset) > ZXDH_PCIE_NP_MEM_SIZE)
471 : 0 : ? (pcie_vir_baddr + bar_offset - ZXDH_PCIE_NP_MEM_SIZE) : 0;
472 : 0 : g_np_bar_offset = bar_offset;
473 : :
474 : : return np_addr;
475 : : }
476 : :
477 : : int
478 : 0 : zxdh_np_host_init(uint32_t dev_id,
479 : : ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
480 : : {
481 : 0 : ZXDH_SYS_INIT_CTRL_T sys_init_ctrl = {0};
482 : : uint32_t rc;
483 : : uint64_t agent_addr;
484 : :
485 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT_NO_ASSERT(p_dev_init_ctrl);
486 : :
487 : 0 : sys_init_ctrl.flags = (ZXDH_DEV_ACCESS_TYPE_PCIE << 0) | (ZXDH_DEV_AGENT_ENABLE << 10);
488 : 0 : sys_init_ctrl.pcie_vir_baddr = zxdh_np_addr_calc(p_dev_init_ctrl->pcie_vir_addr,
489 : : p_dev_init_ctrl->np_bar_offset);
490 : 0 : sys_init_ctrl.device_type = ZXDH_DEV_TYPE_CHIP;
491 : 0 : rc = zxdh_np_base_soft_init(dev_id, &sys_init_ctrl);
492 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_base_soft_init");
493 : :
494 : 0 : zxdh_np_dev_vport_set(dev_id, p_dev_init_ctrl->vport);
495 : :
496 : 0 : agent_addr = ZXDH_PCIE_AGENT_ADDR_OFFSET + p_dev_init_ctrl->pcie_vir_addr;
497 : : zxdh_np_dev_agent_addr_set(dev_id, agent_addr);
498 : :
499 : 0 : return 0;
500 : : }
501 : :
502 : : static ZXDH_RISCV_DTB_MGR *
503 : : zxdh_np_riscv_dtb_queue_mgr_get(uint32_t dev_id)
504 : : {
505 : 0 : if (dev_id >= ZXDH_DEV_CHANNEL_MAX)
506 : : return NULL;
507 : : else
508 : 0 : return p_riscv_dtb_queue_mgr[dev_id];
509 : : }
510 : :
511 : : static uint32_t
512 [ # # ]: 0 : zxdh_np_riscv_dtb_mgr_queue_info_delete(uint32_t dev_id, uint32_t queue_id)
513 : : {
514 : : ZXDH_RISCV_DTB_MGR *p_riscv_dtb_mgr = NULL;
515 : :
516 : : p_riscv_dtb_mgr = zxdh_np_riscv_dtb_queue_mgr_get(dev_id);
517 [ # # ]: 0 : if (p_riscv_dtb_mgr == NULL)
518 : : return 1;
519 : :
520 : 0 : p_riscv_dtb_mgr->queue_alloc_count--;
521 : 0 : p_riscv_dtb_mgr->queue_user_info[queue_id].alloc_flag = 0;
522 : 0 : p_riscv_dtb_mgr->queue_user_info[queue_id].queue_id = 0xFF;
523 : 0 : p_riscv_dtb_mgr->queue_user_info[queue_id].vport = 0;
524 : 0 : memset(p_riscv_dtb_mgr->queue_user_info[queue_id].user_name, 0, ZXDH_PORT_NAME_MAX);
525 : :
526 : 0 : return 0;
527 : : }
528 : :
529 : : static uint32_t
530 : : zxdh_np_dev_get_dev_type(uint32_t dev_id)
531 : : {
532 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
533 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
534 : :
535 : : p_dev_mgr = &g_dev_mgr;
536 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
537 : :
538 [ # # ]: 0 : if (p_dev_info == NULL)
539 : : return 0xffff;
540 : :
541 : 0 : return p_dev_info->dev_type;
542 : : }
543 : :
544 : : static uint32_t
545 : 0 : zxdh_np_comm_read_bits(uint8_t *p_base, uint32_t base_size_bit,
546 : : uint32_t *p_data, uint32_t start_bit, uint32_t end_bit)
547 : : {
548 : : uint32_t start_byte_index;
549 : : uint32_t end_byte_index;
550 : : uint32_t byte_num;
551 : : uint32_t buffer_size;
552 : : uint32_t len;
553 : :
554 [ # # ]: 0 : if (0 != (base_size_bit % 8))
555 : : return 1;
556 : :
557 [ # # ]: 0 : if (start_bit > end_bit)
558 : : return 1;
559 : :
560 [ # # ]: 0 : if (base_size_bit < end_bit)
561 : : return 1;
562 : :
563 : 0 : len = end_bit - start_bit + 1;
564 : 0 : buffer_size = base_size_bit / 8;
565 [ # # ]: 0 : while (0 != (buffer_size & (buffer_size - 1)))
566 : 0 : buffer_size += 1;
567 : :
568 : 0 : *p_data = 0;
569 : 0 : end_byte_index = (end_bit >> 3);
570 : 0 : start_byte_index = (start_bit >> 3);
571 : :
572 [ # # ]: 0 : if (start_byte_index == end_byte_index) {
573 : 0 : *p_data = (uint32_t)(((p_base[start_byte_index] >> (7U - (end_bit & 7)))
574 : 0 : & (0xff >> (8U - len))) & 0xff);
575 : 0 : return 0;
576 : : }
577 : :
578 [ # # ]: 0 : if (start_bit & 7) {
579 : 0 : *p_data = (p_base[start_byte_index] & (0xff >> (start_bit & 7))) & UINT8_MAX;
580 : 0 : start_byte_index++;
581 : : }
582 : :
583 [ # # ]: 0 : for (byte_num = start_byte_index; byte_num < end_byte_index; byte_num++) {
584 : 0 : *p_data <<= 8;
585 : 0 : *p_data += p_base[byte_num];
586 : : }
587 : :
588 : 0 : *p_data <<= 1 + (end_bit & 7);
589 : 0 : *p_data += ((p_base[byte_num & (buffer_size - 1)] & (0xff << (7 - (end_bit & 7)))) >>
590 : 0 : (7 - (end_bit & 7))) & 0xff;
591 : :
592 : 0 : return 0;
593 : : }
594 : :
595 : : static uint32_t
596 : : zxdh_np_comm_read_bits_ex(uint8_t *p_base, uint32_t base_size_bit,
597 : : uint32_t *p_data, uint32_t msb_start_pos, uint32_t len)
598 : : {
599 : : uint32_t rtn;
600 : :
601 : 0 : rtn = zxdh_np_comm_read_bits(p_base,
602 : : base_size_bit,
603 : : p_data,
604 : : (base_size_bit - 1 - msb_start_pos),
605 : 0 : (base_size_bit - 1 - msb_start_pos + len - 1));
606 : : return rtn;
607 : : }
608 : :
609 : : static uint32_t
610 : 0 : zxdh_np_reg_read(uint32_t dev_id, uint32_t reg_no,
611 : : uint32_t m_offset, uint32_t n_offset, void *p_data)
612 : : {
613 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
614 : : ZXDH_REG_T *p_reg_info = NULL;
615 : : ZXDH_FIELD_T *p_field_info = NULL;
616 : : uint32_t rc = 0;
617 : : uint32_t i;
618 : :
619 [ # # ]: 0 : if (reg_no < 4) {
620 : : p_reg_info = &g_dpp_reg_info[reg_no];
621 : 0 : p_field_info = p_reg_info->p_fields;
622 [ # # ]: 0 : for (i = 0; i < p_reg_info->field_num; i++) {
623 : 0 : rc = zxdh_np_comm_read_bits_ex((uint8_t *)p_buff,
624 : 0 : p_reg_info->width * 8,
625 : 0 : (uint32_t *)p_data + i,
626 : 0 : p_field_info[i].msb_pos,
627 : 0 : p_field_info[i].len);
628 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxic_comm_read_bits_ex");
629 : 0 : PMD_DRV_LOG(ERR, "dev_id %d(%d)(%d)is ok!", dev_id, m_offset, n_offset);
630 : : }
631 : : }
632 : 0 : return rc;
633 : : }
634 : :
635 : : static uint32_t
636 : 0 : zxdh_np_dtb_queue_vm_info_get(uint32_t dev_id,
637 : : uint32_t queue_id,
638 : : ZXDH_DTB_QUEUE_VM_INFO_T *p_vm_info)
639 : : {
640 : 0 : ZXDH_DTB4K_DTB_ENQ_CFG_EPID_V_FUNC_NUM_0_127_T vm_info = {0};
641 : : uint32_t rc;
642 : :
643 : 0 : rc = zxdh_np_reg_read(dev_id, ZXDH_DTB_CFG_EPID_V_FUNC_NUM,
644 : : 0, queue_id, &vm_info);
645 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_reg_read");
646 : :
647 : 0 : p_vm_info->dbi_en = vm_info.dbi_en;
648 : 0 : p_vm_info->queue_en = vm_info.queue_en;
649 : 0 : p_vm_info->epid = vm_info.cfg_epid;
650 : 0 : p_vm_info->vector = vm_info.cfg_vector;
651 : 0 : p_vm_info->vfunc_num = vm_info.cfg_vfunc_num;
652 : 0 : p_vm_info->func_num = vm_info.cfg_func_num;
653 : 0 : p_vm_info->vfunc_active = vm_info.cfg_vfunc_active;
654 : :
655 : 0 : return rc;
656 : : }
657 : :
658 : : static uint32_t
659 : 0 : zxdh_np_comm_write_bits(uint8_t *p_base, uint32_t base_size_bit,
660 : : uint32_t data, uint32_t start_bit, uint32_t end_bit)
661 : : {
662 : : uint32_t start_byte_index;
663 : : uint32_t end_byte_index;
664 : : uint8_t mask_value;
665 : : uint32_t byte_num;
666 : : uint32_t buffer_size;
667 : :
668 [ # # ]: 0 : if (0 != (base_size_bit % 8))
669 : : return 1;
670 : :
671 [ # # ]: 0 : if (start_bit > end_bit)
672 : : return 1;
673 : :
674 [ # # ]: 0 : if (base_size_bit < end_bit)
675 : : return 1;
676 : :
677 : 0 : buffer_size = base_size_bit / 8;
678 : :
679 [ # # ]: 0 : while (0 != (buffer_size & (buffer_size - 1)))
680 : 0 : buffer_size += 1;
681 : :
682 : 0 : end_byte_index = (end_bit >> 3);
683 : 0 : start_byte_index = (start_bit >> 3);
684 : :
685 [ # # ]: 0 : if (start_byte_index == end_byte_index) {
686 : 0 : mask_value = ((0xFE << (7 - (start_bit & 7))) & 0xff);
687 : 0 : mask_value |= (((1 << (7 - (end_bit & 7))) - 1) & 0xff);
688 : 0 : p_base[end_byte_index] &= mask_value;
689 : 0 : p_base[end_byte_index] |= (((data << (7 - (end_bit & 7)))) & 0xff);
690 : 0 : return 0;
691 : : }
692 : :
693 [ # # ]: 0 : if (7 != (end_bit & 7)) {
694 : 0 : mask_value = ((0x7f >> (end_bit & 7)) & 0xff);
695 : 0 : p_base[end_byte_index] &= mask_value;
696 : 0 : p_base[end_byte_index] |= ((data << (7 - (end_bit & 7))) & 0xff);
697 : 0 : end_byte_index--;
698 : 0 : data >>= 1 + (end_bit & 7);
699 : : }
700 : :
701 [ # # ]: 0 : for (byte_num = end_byte_index; byte_num > start_byte_index; byte_num--) {
702 : 0 : p_base[byte_num & (buffer_size - 1)] = data & 0xff;
703 : 0 : data >>= 8;
704 : : }
705 : :
706 : 0 : mask_value = ((0xFE << (7 - (start_bit & 7))) & 0xff);
707 : 0 : p_base[byte_num] &= mask_value;
708 : 0 : p_base[byte_num] |= data;
709 : :
710 : 0 : return 0;
711 : : }
712 : :
713 : : static uint32_t
714 : : zxdh_np_comm_write_bits_ex(uint8_t *p_base,
715 : : uint32_t base_size_bit,
716 : : uint32_t data,
717 : : uint32_t msb_start_pos,
718 : : uint32_t len)
719 : : {
720 : : uint32_t rtn;
721 : :
722 : 0 : rtn = zxdh_np_comm_write_bits(p_base,
723 : : base_size_bit,
724 : : data,
725 : : (base_size_bit - 1 - msb_start_pos),
726 : 0 : (base_size_bit - 1 - msb_start_pos + len - 1));
727 : :
728 : : return rtn;
729 : : }
730 : :
731 : : static uint32_t
732 : 0 : zxdh_np_reg_write(uint32_t dev_id, uint32_t reg_no,
733 : : uint32_t m_offset, uint32_t n_offset, void *p_data)
734 : : {
735 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
736 : : ZXDH_REG_T *p_reg_info = NULL;
737 : : ZXDH_FIELD_T *p_field_info = NULL;
738 : : uint32_t temp_data;
739 : : uint32_t rc;
740 : : uint32_t i;
741 : :
742 [ # # ]: 0 : if (reg_no < 4) {
743 : : p_reg_info = &g_dpp_reg_info[reg_no];
744 : 0 : p_field_info = p_reg_info->p_fields;
745 : :
746 [ # # ]: 0 : for (i = 0; i < p_reg_info->field_num; i++) {
747 [ # # ]: 0 : if (p_field_info[i].len <= 32) {
748 : 0 : temp_data = *((uint32_t *)p_data + i);
749 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_buff,
750 : 0 : p_reg_info->width * 8,
751 : : temp_data,
752 : 0 : p_field_info[i].msb_pos,
753 : : p_field_info[i].len);
754 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_comm_write_bits_ex");
755 : 0 : PMD_DRV_LOG(ERR, "dev_id %d(%d)(%d)is ok!",
756 : : dev_id, m_offset, n_offset);
757 : : }
758 : : }
759 : : }
760 : :
761 : 0 : return 0;
762 : : }
763 : :
764 : : static uint32_t
765 : 0 : zxdh_np_dtb_queue_vm_info_set(uint32_t dev_id,
766 : : uint32_t queue_id,
767 : : ZXDH_DTB_QUEUE_VM_INFO_T *p_vm_info)
768 : : {
769 : : uint32_t rc = 0;
770 : : ZXDH_DTB4K_DTB_ENQ_CFG_EPID_V_FUNC_NUM_0_127_T vm_info = {0};
771 : :
772 : 0 : vm_info.dbi_en = p_vm_info->dbi_en;
773 : 0 : vm_info.queue_en = p_vm_info->queue_en;
774 : 0 : vm_info.cfg_epid = p_vm_info->epid;
775 : 0 : vm_info.cfg_vector = p_vm_info->vector;
776 : 0 : vm_info.cfg_vfunc_num = p_vm_info->vfunc_num;
777 : 0 : vm_info.cfg_func_num = p_vm_info->func_num;
778 : 0 : vm_info.cfg_vfunc_active = p_vm_info->vfunc_active;
779 : :
780 : 0 : rc = zxdh_np_reg_write(dev_id, ZXDH_DTB_CFG_EPID_V_FUNC_NUM,
781 : : 0, queue_id, &vm_info);
782 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_reg_write");
783 : :
784 : 0 : return rc;
785 : : }
786 : :
787 : : static uint32_t
788 : 0 : zxdh_np_dtb_queue_enable_set(uint32_t dev_id,
789 : : uint32_t queue_id,
790 : : uint32_t enable)
791 : : {
792 : 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
793 : : uint32_t rc;
794 : :
795 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
796 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_vm_info_get");
797 : :
798 : 0 : vm_info.queue_en = enable;
799 : 0 : rc = zxdh_np_dtb_queue_vm_info_set(dev_id, queue_id, &vm_info);
800 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_vm_info_set");
801 : :
802 : 0 : return rc;
803 : : }
804 : :
805 : : static uint32_t
806 [ # # ]: 0 : zxdh_np_riscv_dpp_dtb_queue_id_release(uint32_t dev_id,
807 : : char name[ZXDH_PORT_NAME_MAX], uint32_t queue_id)
808 : : {
809 : : ZXDH_RISCV_DTB_MGR *p_riscv_dtb_mgr = NULL;
810 : :
811 : : p_riscv_dtb_mgr = zxdh_np_riscv_dtb_queue_mgr_get(dev_id);
812 [ # # ]: 0 : if (p_riscv_dtb_mgr == NULL)
813 : : return 1;
814 : :
815 [ # # ]: 0 : if (zxdh_np_dev_get_dev_type(dev_id) == ZXDH_DEV_TYPE_SIM)
816 : : return 0;
817 : :
818 [ # # ]: 0 : if (p_riscv_dtb_mgr->queue_user_info[queue_id].alloc_flag != 1) {
819 : 0 : PMD_DRV_LOG(ERR, "queue %d not alloc!", queue_id);
820 : 0 : return 2;
821 : : }
822 : :
823 [ # # ]: 0 : if (strcmp(p_riscv_dtb_mgr->queue_user_info[queue_id].user_name, name) != 0) {
824 : 0 : PMD_DRV_LOG(ERR, "queue %d name %s error!", queue_id, name);
825 : 0 : return 3;
826 : : }
827 : 0 : zxdh_np_dtb_queue_enable_set(dev_id, queue_id, 0);
828 : 0 : zxdh_np_riscv_dtb_mgr_queue_info_delete(dev_id, queue_id);
829 : :
830 : 0 : return 0;
831 : : }
832 : :
833 : : static uint32_t
834 [ # # ]: 0 : zxdh_np_dtb_queue_unused_item_num_get(uint32_t dev_id,
835 : : uint32_t queue_id,
836 : : uint32_t *p_item_num)
837 : : {
838 : : uint32_t rc;
839 : :
840 [ # # ]: 0 : if (zxdh_np_dev_get_dev_type(dev_id) == ZXDH_DEV_TYPE_SIM) {
841 : 0 : *p_item_num = 32;
842 : 0 : return 0;
843 : : }
844 : :
845 : 0 : rc = zxdh_np_reg_read(dev_id, ZXDH_DTB_INFO_QUEUE_BUF_SPACE,
846 : : 0, queue_id, p_item_num);
847 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_reg_read");
848 : : return rc;
849 : : }
850 : :
851 : : static uint32_t
852 : 0 : zxdh_np_dtb_queue_id_free(uint32_t dev_id,
853 : : uint32_t queue_id)
854 : : {
855 : 0 : uint32_t item_num = 0;
856 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
857 : : uint32_t rc;
858 : :
859 : 0 : p_dtb_mgr = p_dpp_dtb_mgr[dev_id];
860 [ # # ]: 0 : if (p_dtb_mgr == NULL)
861 : : return 1;
862 : :
863 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &item_num);
864 : :
865 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 0;
866 : 0 : p_dtb_mgr->queue_info[queue_id].vport = 0;
867 : 0 : p_dtb_mgr->queue_info[queue_id].vector = 0;
868 : :
869 : 0 : return rc;
870 : : }
871 : :
872 : : static uint32_t
873 : 0 : zxdh_np_dtb_queue_release(uint32_t devid,
874 : : char pname[32],
875 : : uint32_t queueid)
876 : : {
877 : : uint32_t rc;
878 : :
879 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(devid, pname);
880 : :
881 : 0 : rc = zxdh_np_riscv_dpp_dtb_queue_id_release(devid, pname, queueid);
882 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_riscv_dpp_dtb_queue_id_release");
883 : :
884 : 0 : rc = zxdh_np_dtb_queue_id_free(devid, queueid);
885 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_id_free");
886 : :
887 : 0 : return rc;
888 : : }
889 : :
890 : : static void
891 : : zxdh_np_dtb_mgr_destroy(uint32_t dev_id)
892 : : {
893 [ # # ]: 0 : if (p_dpp_dtb_mgr[dev_id] != NULL) {
894 : 0 : free(p_dpp_dtb_mgr[dev_id]);
895 : 0 : p_dpp_dtb_mgr[dev_id] = NULL;
896 : : }
897 : : }
898 : :
899 : : static void
900 : : zxdh_np_tlb_mgr_destroy(uint32_t dev_id)
901 : : {
902 [ # # ]: 0 : if (g_p_dpp_tlb_mgr[dev_id] != NULL) {
903 : 0 : free(g_p_dpp_tlb_mgr[dev_id]);
904 : 0 : g_p_dpp_tlb_mgr[dev_id] = NULL;
905 : : }
906 : : }
907 : :
908 : : static void
909 : : zxdh_np_sdt_mgr_destroy(uint32_t dev_id)
910 : : {
911 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_tbl_temp = NULL;
912 : : ZXDH_SDT_MGR_T *p_sdt_mgr = NULL;
913 : :
914 : 0 : p_sdt_tbl_temp = ZXDH_SDT_SOFT_TBL_GET(dev_id);
915 : : p_sdt_mgr = ZXDH_SDT_MGR_PTR_GET();
916 : :
917 : 0 : free(p_sdt_tbl_temp);
918 : :
919 : 0 : ZXDH_SDT_SOFT_TBL_GET(dev_id) = NULL;
920 : :
921 : 0 : p_sdt_mgr->channel_num--;
922 : : }
923 : :
924 : : static void
925 : 0 : zxdh_np_dev_del(uint32_t dev_id)
926 : : {
927 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
928 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
929 : :
930 : : p_dev_mgr = &g_dev_mgr;
931 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
932 : :
933 [ # # ]: 0 : if (p_dev_info != NULL) {
934 : 0 : free(p_dev_info);
935 : 0 : p_dev_mgr->p_dev_array[dev_id] = NULL;
936 : 0 : p_dev_mgr->device_num--;
937 : : }
938 : 0 : }
939 : :
940 : : int
941 : 0 : zxdh_np_online_uninit(uint32_t dev_id,
942 : : char *port_name,
943 : : uint32_t queue_id)
944 : : {
945 : : uint32_t rc;
946 : :
947 : 0 : rc = zxdh_np_dtb_queue_release(dev_id, port_name, queue_id);
948 [ # # ]: 0 : if (rc != 0)
949 : 0 : PMD_DRV_LOG(ERR, "%s:dtb release error,"
950 : : "port name %s queue id %d", __func__, port_name, queue_id);
951 : :
952 : : zxdh_np_dtb_mgr_destroy(dev_id);
953 : : zxdh_np_tlb_mgr_destroy(dev_id);
954 : : zxdh_np_sdt_mgr_destroy(dev_id);
955 : 0 : zxdh_np_dev_del(dev_id);
956 : :
957 : 0 : return 0;
958 : : }
959 : :
960 : : static uint32_t
961 : : zxdh_np_sdt_tbl_type_get(uint32_t dev_id, uint32_t sdt_no)
962 : : {
963 : 0 : return g_table_type[dev_id][sdt_no];
964 : : }
965 : :
966 : :
967 : : static ZXDH_DTB_TABLE_T *
968 : : zxdh_np_table_info_get(uint32_t table_type)
969 : : {
970 : : return &g_dpp_dtb_table_info[table_type];
971 : : }
972 : :
973 : : static uint32_t
974 : 0 : zxdh_np_dtb_write_table_cmd(uint32_t dev_id,
975 : : ZXDH_DTB_TABLE_INFO_E table_type,
976 : : void *p_cmd_data,
977 : : void *p_cmd_buff)
978 : : {
979 : : uint32_t field_cnt;
980 : : ZXDH_DTB_TABLE_T *p_table_info = NULL;
981 : : ZXDH_DTB_FIELD_T *p_field_info = NULL;
982 : : uint32_t temp_data;
983 : : uint32_t rc = 0;
984 : :
985 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_data);
986 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_buff);
987 : : p_table_info = zxdh_np_table_info_get(table_type);
988 : 0 : p_field_info = p_table_info->p_fields;
989 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_table_info);
990 : :
991 [ # # ]: 0 : for (field_cnt = 0; field_cnt < p_table_info->field_num; field_cnt++) {
992 : 0 : temp_data = *((uint32_t *)p_cmd_data + field_cnt) & ZXDH_COMM_GET_BIT_MASK(uint32_t,
993 : : p_field_info[field_cnt].len);
994 : :
995 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_cmd_buff,
996 : : ZXDH_DTB_TABLE_CMD_SIZE_BIT,
997 : : temp_data,
998 : 0 : p_field_info[field_cnt].lsb_pos,
999 : : p_field_info[field_cnt].len);
1000 : :
1001 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxic_comm_write_bits");
1002 : : }
1003 : :
1004 : 0 : return rc;
1005 : : }
1006 : :
1007 : : static uint32_t
1008 : 0 : zxdh_np_dtb_smmu0_write_entry_data(uint32_t dev_id,
1009 : : uint32_t mode,
1010 : : uint32_t addr,
1011 : : uint32_t *p_data,
1012 : : ZXDH_DTB_ENTRY_T *p_entry)
1013 : : {
1014 : 0 : ZXDH_DTB_ERAM_TABLE_FORM_T dtb_eram_form_info = {0};
1015 : : uint32_t rc = 0;
1016 : :
1017 : 0 : dtb_eram_form_info.valid = ZXDH_DTB_TABLE_VALID;
1018 : : dtb_eram_form_info.type_mode = ZXDH_DTB_TABLE_MODE_ERAM;
1019 : 0 : dtb_eram_form_info.data_mode = mode;
1020 : 0 : dtb_eram_form_info.cpu_wr = 1;
1021 : 0 : dtb_eram_form_info.addr = addr;
1022 : : dtb_eram_form_info.cpu_rd = 0;
1023 : : dtb_eram_form_info.cpu_rd_mode = 0;
1024 : :
1025 [ # # ]: 0 : if (ZXDH_ERAM128_OPR_128b == mode) {
1026 : 0 : p_entry->data_in_cmd_flag = 0;
1027 : 0 : p_entry->data_size = 128 / 8;
1028 : :
1029 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_128,
1030 : 0 : &dtb_eram_form_info, p_entry->cmd);
1031 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
1032 : :
1033 : 0 : memcpy(p_entry->data, p_data, 128 / 8);
1034 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_64b == mode) {
1035 : 0 : p_entry->data_in_cmd_flag = 1;
1036 : 0 : p_entry->data_size = 64 / 8;
1037 : 0 : dtb_eram_form_info.data_l = *(p_data + 1);
1038 : 0 : dtb_eram_form_info.data_h = *(p_data);
1039 : :
1040 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_64,
1041 : 0 : &dtb_eram_form_info, p_entry->cmd);
1042 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
1043 : :
1044 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_1b == mode) {
1045 : 0 : p_entry->data_in_cmd_flag = 1;
1046 : 0 : p_entry->data_size = 1;
1047 : 0 : dtb_eram_form_info.data_h = *(p_data);
1048 : :
1049 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_1,
1050 : 0 : &dtb_eram_form_info, p_entry->cmd);
1051 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
1052 : : }
1053 : :
1054 : 0 : return rc;
1055 : : }
1056 : :
1057 : : static uint32_t
1058 : 0 : zxdh_np_dtb_se_smmu0_ind_write(uint32_t dev_id,
1059 : : uint32_t base_addr,
1060 : : uint32_t index,
1061 : : uint32_t wrt_mode,
1062 : : uint32_t *p_data,
1063 : : ZXDH_DTB_ENTRY_T *p_entry)
1064 : : {
1065 : : uint32_t temp_idx;
1066 : : uint32_t dtb_ind_addr;
1067 : : uint32_t rc = 0;
1068 : :
1069 [ # # # # ]: 0 : switch (wrt_mode) {
1070 : 0 : case ZXDH_ERAM128_OPR_128b:
1071 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
1072 : 0 : PMD_DRV_LOG(ERR, "ICM %s:%d[Error:VALUE[val0=0x%x]"
1073 : : "INVALID] [val1=0x%x] FUNCTION :%s", __FILE__, __LINE__,
1074 : : base_addr, index, __func__);
1075 : :
1076 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
1077 : : }
1078 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
1079 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
1080 : 0 : return 1;
1081 : : }
1082 : 0 : temp_idx = index << 7;
1083 : 0 : break;
1084 : 0 : case ZXDH_ERAM128_OPR_64b:
1085 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
1086 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
1087 : 0 : return 1;
1088 : : }
1089 : 0 : temp_idx = index << 6;
1090 : 0 : break;
1091 : 0 : case ZXDH_ERAM128_OPR_1b:
1092 [ # # ]: 0 : if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
1093 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
1094 : 0 : return 1;
1095 : : }
1096 : :
1097 : : temp_idx = index;
1098 : : }
1099 : :
1100 : 0 : dtb_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + temp_idx;
1101 : :
1102 : 0 : PMD_DRV_LOG(INFO, "dtb eram item 1bit addr: 0x%x", dtb_ind_addr);
1103 : :
1104 : 0 : rc = zxdh_np_dtb_smmu0_write_entry_data(dev_id,
1105 : : wrt_mode,
1106 : : dtb_ind_addr,
1107 : : p_data,
1108 : : p_entry);
1109 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_smmu0_write_entry_data");
1110 : :
1111 : : return rc;
1112 : : }
1113 : :
1114 : : static uint32_t
1115 : : zxdh_np_eram_dtb_len_get(uint32_t mode)
1116 : : {
1117 : : uint32_t dtb_len = 0;
1118 : :
1119 : : switch (mode) {
1120 : : case ZXDH_ERAM128_OPR_128b:
1121 : : dtb_len += 2;
1122 : : break;
1123 : : case ZXDH_ERAM128_OPR_64b:
1124 : : case ZXDH_ERAM128_OPR_1b:
1125 : : dtb_len += 1;
1126 : : break;
1127 : : default:
1128 : : break;
1129 : : }
1130 : :
1131 : : return dtb_len;
1132 : : }
1133 : :
1134 : : static uint32_t
1135 : 0 : zxdh_np_dtb_eram_one_entry(uint32_t dev_id,
1136 : : uint32_t sdt_no,
1137 : : uint32_t del_en,
1138 : : void *pdata,
1139 : : uint32_t *p_dtb_len,
1140 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
1141 : : {
1142 : 0 : uint32_t buff[ZXDH_SMMU0_READ_REG_MAX_NUM] = {0};
1143 : : ZXDH_SDTTBL_ERAM_T sdt_eram = {0};
1144 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *peramdata = NULL;
1145 : : uint32_t base_addr;
1146 : : uint32_t index;
1147 : : uint32_t opr_mode;
1148 : : uint32_t rc;
1149 : :
1150 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(pdata);
1151 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_one_entry);
1152 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_len);
1153 : :
1154 : : peramdata = (ZXDH_DTB_ERAM_ENTRY_INFO_T *)pdata;
1155 : 0 : index = peramdata->index;
1156 : : base_addr = sdt_eram.eram_base_addr;
1157 : : opr_mode = sdt_eram.eram_mode;
1158 : :
1159 : : switch (opr_mode) {
1160 : : case ZXDH_ERAM128_TBL_128b:
1161 : : opr_mode = ZXDH_ERAM128_OPR_128b;
1162 : : break;
1163 : : case ZXDH_ERAM128_TBL_64b:
1164 : : opr_mode = ZXDH_ERAM128_OPR_64b;
1165 : : break;
1166 : : case ZXDH_ERAM128_TBL_1b:
1167 : : opr_mode = ZXDH_ERAM128_OPR_1b;
1168 : : break;
1169 : : }
1170 : :
1171 [ # # ]: 0 : if (del_en) {
1172 : : memset((uint8_t *)buff, 0, sizeof(buff));
1173 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
1174 : : base_addr,
1175 : : index,
1176 : : opr_mode,
1177 : : buff,
1178 : : p_dtb_one_entry);
1179 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(sdt_no, rc, "zxdh_dtb_se_smmu0_ind_write");
1180 : : } else {
1181 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
1182 : : base_addr,
1183 : : index,
1184 : : opr_mode,
1185 : : peramdata->p_data,
1186 : : p_dtb_one_entry);
1187 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_dtb_se_smmu0_ind_write");
1188 : : }
1189 : 0 : *p_dtb_len = zxdh_np_eram_dtb_len_get(opr_mode);
1190 : :
1191 : 0 : return rc;
1192 : : }
1193 : :
1194 : : static uint32_t
1195 : 0 : zxdh_np_dtb_data_write(uint8_t *p_data_buff,
1196 : : uint32_t addr_offset,
1197 : : ZXDH_DTB_ENTRY_T *entry)
1198 : : {
1199 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
1200 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(entry);
1201 : :
1202 : 0 : uint8_t *p_cmd = p_data_buff + addr_offset;
1203 : : uint32_t cmd_size = ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8;
1204 : :
1205 : 0 : uint8_t *p_data = p_cmd + cmd_size;
1206 : 0 : uint32_t data_size = entry->data_size;
1207 : :
1208 : 0 : uint8_t *cmd = (uint8_t *)entry->cmd;
1209 [ # # ]: 0 : uint8_t *data = (uint8_t *)entry->data;
1210 : :
1211 : : memcpy(p_cmd, cmd, cmd_size);
1212 : :
1213 [ # # ]: 0 : if (!entry->data_in_cmd_flag) {
1214 : : zxdh_np_comm_swap(data, data_size);
1215 : 0 : memcpy(p_data, data, data_size);
1216 : : }
1217 : :
1218 : 0 : return 0;
1219 : : }
1220 : :
1221 : : static uint32_t
1222 : 0 : zxdh_np_dtb_queue_enable_get(uint32_t dev_id,
1223 : : uint32_t queue_id,
1224 : : uint32_t *enable)
1225 : : {
1226 : : uint32_t rc = 0;
1227 : 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
1228 : :
1229 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
1230 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_vm_info_get");
1231 : :
1232 : 0 : *enable = vm_info.queue_en;
1233 : 0 : return rc;
1234 : : }
1235 : :
1236 : : static uint32_t
1237 : : zxdh_np_dtb_item_buff_wr(uint32_t dev_id,
1238 : : uint32_t queue_id,
1239 : : uint32_t dir_flag,
1240 : : uint32_t index,
1241 : : uint32_t pos,
1242 : : uint32_t len,
1243 : : uint32_t *p_data)
1244 : : {
1245 : : uint64_t addr;
1246 : :
1247 : : if (dir_flag == 1)
1248 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) +
1249 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
1250 : : else
1251 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) +
1252 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
1253 : :
1254 [ # # ]: 0 : memcpy((uint8_t *)(addr), p_data, len * 4);
1255 : :
1256 : : return 0;
1257 : : }
1258 : :
1259 : : static uint32_t
1260 : : zxdh_np_dtb_item_ack_rd(uint32_t dev_id,
1261 : : uint32_t queue_id,
1262 : : uint32_t dir_flag,
1263 : : uint32_t index,
1264 : : uint32_t pos,
1265 : : uint32_t *p_data)
1266 : : {
1267 : : uint64_t addr;
1268 : : uint32_t val;
1269 : :
1270 : : if (dir_flag == 1)
1271 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
1272 : : else
1273 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
1274 : :
1275 : 0 : val = *((volatile uint32_t *)(addr));
1276 : :
1277 : : *p_data = val;
1278 : :
1279 : : return 0;
1280 : : }
1281 : :
1282 : : static uint32_t
1283 : : zxdh_np_dtb_item_ack_wr(uint32_t dev_id,
1284 : : uint32_t queue_id,
1285 : : uint32_t dir_flag,
1286 : : uint32_t index,
1287 : : uint32_t pos,
1288 : : uint32_t data)
1289 : : {
1290 : : uint64_t addr;
1291 : :
1292 : : if (dir_flag == 1)
1293 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
1294 : : else
1295 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
1296 : :
1297 : 0 : *((volatile uint32_t *)(addr)) = data;
1298 : :
1299 : 0 : return 0;
1300 : : }
1301 : :
1302 : : static uint32_t
1303 : 0 : zxdh_np_dtb_queue_item_info_set(uint32_t dev_id,
1304 : : uint32_t queue_id,
1305 : : ZXDH_DTB_QUEUE_ITEM_INFO_T *p_item_info)
1306 : : {
1307 : : ZXDH_DTB_QUEUE_LEN_T dtb_len = {0};
1308 : : uint32_t rc;
1309 : :
1310 : 0 : dtb_len.cfg_dtb_cmd_type = p_item_info->cmd_type;
1311 : 0 : dtb_len.cfg_dtb_cmd_int_en = p_item_info->int_en;
1312 : 0 : dtb_len.cfg_queue_dtb_len = p_item_info->data_len;
1313 : :
1314 : 0 : rc = zxdh_np_reg_write(dev_id, ZXDH_DTB_CFG_QUEUE_DTB_LEN,
1315 : : 0, queue_id, (void *)&dtb_len);
1316 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_reg_write");
1317 : 0 : return rc;
1318 : : }
1319 : :
1320 : : static uint32_t
1321 : 0 : zxdh_np_dtb_tab_down_info_set(uint32_t dev_id,
1322 : : uint32_t queue_id,
1323 : : uint32_t int_flag,
1324 : : uint32_t data_len,
1325 : : uint32_t *p_data,
1326 : : uint32_t *p_item_index)
1327 : : {
1328 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
1329 : 0 : uint32_t unused_item_num = 0;
1330 : 0 : uint32_t queue_en = 0;
1331 : : uint32_t ack_vale = 0;
1332 : : uint64_t phy_addr;
1333 : : uint32_t item_index;
1334 : : uint32_t i;
1335 : : uint32_t rc;
1336 : :
1337 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
1338 : 0 : PMD_DRV_LOG(ERR, "dtb queue %d is not init", queue_id);
1339 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
1340 : : }
1341 : :
1342 [ # # ]: 0 : if (data_len % 4 != 0)
1343 : : return ZXDH_RC_DTB_PARA_INVALID;
1344 : :
1345 : 0 : rc = zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
1346 [ # # ]: 0 : if (!queue_en) {
1347 : 0 : PMD_DRV_LOG(ERR, "the queue %d is not enable!,rc=%d", queue_id, rc);
1348 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
1349 : : }
1350 : :
1351 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
1352 [ # # ]: 0 : if (unused_item_num == 0)
1353 : : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
1354 : :
1355 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
1356 : 0 : item_index = ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id) %
1357 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
1358 : :
1359 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, 0,
1360 : : item_index, 0, &ack_vale);
1361 : :
1362 : 0 : ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id)++;
1363 : :
1364 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
1365 : : break;
1366 : : }
1367 : :
1368 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX)
1369 : : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
1370 : :
1371 : : rc = zxdh_np_dtb_item_buff_wr(dev_id, queue_id, 0,
1372 : : item_index, 0, data_len, p_data);
1373 : :
1374 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, 0,
1375 : : item_index, 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
1376 : :
1377 : 0 : item_info.cmd_vld = 1;
1378 : : item_info.cmd_type = 0;
1379 : 0 : item_info.int_en = int_flag;
1380 : 0 : item_info.data_len = data_len / 4;
1381 : 0 : phy_addr = p_dpp_dtb_mgr[dev_id]->queue_info[queue_id].tab_down.start_phy_addr +
1382 : 0 : item_index * p_dpp_dtb_mgr[dev_id]->queue_info[queue_id].tab_down.item_size;
1383 : 0 : item_info.data_hddr = ((phy_addr >> 4) >> 32) & 0xffffffff;
1384 : 0 : item_info.data_laddr = (phy_addr >> 4) & 0xffffffff;
1385 : :
1386 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
1387 : 0 : *p_item_index = item_index;
1388 : :
1389 : 0 : return rc;
1390 : : }
1391 : :
1392 : : static uint32_t
1393 : : zxdh_np_dtb_write_down_table_data(uint32_t dev_id,
1394 : : uint32_t queue_id,
1395 : : uint32_t down_table_len,
1396 : : uint8_t *p_down_table_buff,
1397 : : uint32_t *p_element_id)
1398 : : {
1399 : : uint32_t rc = 0;
1400 : : uint32_t dtb_interrupt_status = 0;
1401 : :
1402 : 0 : dtb_interrupt_status = g_dpp_dtb_int_enable;
1403 : :
1404 : 0 : rc = zxdh_np_dtb_tab_down_info_set(dev_id,
1405 : : queue_id,
1406 : : dtb_interrupt_status,
1407 : : down_table_len / 4,
1408 : : (uint32_t *)p_down_table_buff,
1409 : : p_element_id);
1410 : : return rc;
1411 : : }
1412 : :
1413 : : int
1414 : 0 : zxdh_np_dtb_table_entry_write(uint32_t dev_id,
1415 : : uint32_t queue_id,
1416 : : uint32_t entrynum,
1417 : : ZXDH_DTB_USER_ENTRY_T *down_entries)
1418 : : {
1419 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
1420 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
1421 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT] = {0};
1422 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX] = {0};
1423 : : uint8_t *p_data_buff;
1424 : : uint8_t *p_data_buff_ex;
1425 : 0 : uint32_t element_id = 0xff;
1426 : 0 : uint32_t one_dtb_len = 0;
1427 : : uint32_t dtb_len = 0;
1428 : : uint32_t entry_index;
1429 : : uint32_t sdt_no;
1430 : : uint32_t tbl_type;
1431 : : uint32_t addr_offset;
1432 : : uint32_t max_size;
1433 : : uint32_t rc = 0;
1434 : :
1435 : 0 : p_data_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
1436 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
1437 : :
1438 : 0 : p_data_buff_ex = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
1439 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT_MEMORY_FREE(p_data_buff_ex, p_data_buff);
1440 : :
1441 : 0 : dtb_one_entry.cmd = entry_cmd;
1442 : 0 : dtb_one_entry.data = entry_data;
1443 : :
1444 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
1445 : :
1446 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
1447 : 0 : pentry = down_entries + entry_index;
1448 : 0 : sdt_no = pentry->sdt_no;
1449 : : tbl_type = zxdh_np_sdt_tbl_type_get(dev_id, sdt_no);
1450 [ # # ]: 0 : switch (tbl_type) {
1451 : 0 : case ZXDH_SDT_TBLT_ERAM:
1452 : 0 : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
1453 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
1454 : : break;
1455 : 0 : default:
1456 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type);
1457 : 0 : rte_free(p_data_buff);
1458 : 0 : rte_free(p_data_buff_ex);
1459 : 0 : return 1;
1460 : : }
1461 : :
1462 : 0 : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
1463 : 0 : dtb_len += one_dtb_len;
1464 [ # # ]: 0 : if (dtb_len > max_size) {
1465 : 0 : rte_free(p_data_buff);
1466 : 0 : rte_free(p_data_buff_ex);
1467 : 0 : PMD_DRV_LOG(ERR, "%s error dtb_len>%u!", __func__,
1468 : : max_size);
1469 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
1470 : : }
1471 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
1472 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
1473 : : memset(entry_data, 0x0, sizeof(entry_data));
1474 : : }
1475 : :
1476 [ # # ]: 0 : if (dtb_len == 0) {
1477 : 0 : rte_free(p_data_buff);
1478 : 0 : rte_free(p_data_buff_ex);
1479 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
1480 : : }
1481 : :
1482 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
1483 : : queue_id,
1484 : : dtb_len * 16,
1485 : : p_data_buff,
1486 : : &element_id);
1487 : 0 : rte_free(p_data_buff);
1488 : 0 : rte_free(p_data_buff_ex);
1489 : :
1490 : 0 : return rc;
1491 : : }
1492 : :
1493 : : static void
1494 : : zxdh_np_sdt_tbl_data_get(uint32_t dev_id, uint32_t sdt_no, ZXDH_SDT_TBL_DATA_T *p_sdt_data)
1495 : : {
1496 : 0 : p_sdt_data->data_high32 = g_sdt_info[dev_id][sdt_no].data_high32;
1497 : 0 : p_sdt_data->data_low32 = g_sdt_info[dev_id][sdt_no].data_low32;
1498 : : }
1499 : :
1500 : : int
1501 : 0 : zxdh_np_dtb_table_entry_delete(uint32_t dev_id,
1502 : : uint32_t queue_id,
1503 : : uint32_t entrynum,
1504 : : ZXDH_DTB_USER_ENTRY_T *delete_entries)
1505 : : {
1506 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
1507 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
1508 : : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
1509 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
1510 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
1511 : : uint8_t *p_data_buff = NULL;
1512 : : uint8_t *p_data_buff_ex = NULL;
1513 : : uint32_t tbl_type = 0;
1514 : : uint32_t element_id = 0xff;
1515 : : uint32_t one_dtb_len = 0;
1516 : : uint32_t dtb_len = 0;
1517 : : uint32_t entry_index;
1518 : : uint32_t sdt_no;
1519 : : uint32_t addr_offset;
1520 : : uint32_t max_size;
1521 : : uint32_t rc;
1522 : :
1523 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(delete_entries);
1524 : :
1525 : 0 : p_data_buff = rte_calloc(NULL, 1, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
1526 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
1527 : :
1528 : 0 : p_data_buff_ex = rte_calloc(NULL, 1, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
1529 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT_MEMORY_FREE(p_data_buff_ex, p_data_buff);
1530 : :
1531 : : dtb_one_entry.cmd = entry_cmd;
1532 : : dtb_one_entry.data = entry_data;
1533 : :
1534 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
1535 : :
1536 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
1537 : : pentry = delete_entries + entry_index;
1538 : :
1539 : : sdt_no = pentry->sdt_no;
1540 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
1541 : : switch (tbl_type) {
1542 : : case ZXDH_SDT_TBLT_ERAM:
1543 : : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_DELETE,
1544 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
1545 : : break;
1546 : : default:
1547 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type);
1548 : 0 : rte_free(p_data_buff);
1549 : 0 : rte_free(p_data_buff_ex);
1550 : 0 : return 1;
1551 : : }
1552 : :
1553 : : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
1554 : : dtb_len += one_dtb_len;
1555 : : if (dtb_len > max_size) {
1556 : : rte_free(p_data_buff);
1557 : : rte_free(p_data_buff_ex);
1558 : : PMD_DRV_LOG(ERR, "%s error dtb_len>%u!", __func__,
1559 : : max_size);
1560 : : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
1561 : : }
1562 : :
1563 : : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
1564 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
1565 : : memset(entry_data, 0x0, sizeof(entry_data));
1566 : : }
1567 : :
1568 : : if (dtb_len == 0) {
1569 : 0 : rte_free(p_data_buff);
1570 : 0 : rte_free(p_data_buff_ex);
1571 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
1572 : : }
1573 : :
1574 : : rc = zxdh_np_dtb_write_down_table_data(dev_id,
1575 : : queue_id,
1576 : : dtb_len * 16,
1577 : : p_data_buff_ex,
1578 : : &element_id);
1579 : : rte_free(p_data_buff);
1580 : : ZXDH_COMM_CHECK_RC_MEMORY_FREE_NO_ASSERT(rc,
1581 : : "dpp_dtb_write_down_table_data", p_data_buff_ex);
1582 : :
1583 : : rte_free(p_data_buff_ex);
1584 : : return 0;
1585 : : }
1586 : :
1587 : : static uint32_t
1588 : 0 : zxdh_np_sdt_tbl_data_parser(uint32_t sdt_hig32, uint32_t sdt_low32, void *p_sdt_info)
1589 : : {
1590 : : uint32_t tbl_type = 0;
1591 : : uint32_t clutch_en = 0;
1592 : :
1593 : : ZXDH_SDTTBL_ERAM_T *p_sdt_eram = NULL;
1594 : : ZXDH_SDTTBL_PORTTBL_T *p_sdt_porttbl = NULL;
1595 : :
1596 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_hig32,
1597 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
1598 : 0 : ZXDH_COMM_UINT32_GET_BITS(clutch_en, sdt_low32, 0, 1);
1599 : :
1600 [ # # ]: 0 : switch (tbl_type) {
1601 : 0 : case ZXDH_SDT_TBLT_ERAM:
1602 : : p_sdt_eram = (ZXDH_SDTTBL_ERAM_T *)p_sdt_info;
1603 : 0 : p_sdt_eram->table_type = tbl_type;
1604 : 0 : p_sdt_eram->eram_clutch_en = clutch_en;
1605 : : break;
1606 : : case ZXDH_SDT_TBLT_PORTTBL:
1607 : : p_sdt_porttbl = (ZXDH_SDTTBL_PORTTBL_T *)p_sdt_info;
1608 : : p_sdt_porttbl->table_type = tbl_type;
1609 : : p_sdt_porttbl->porttbl_clutch_en = clutch_en;
1610 : : break;
1611 : 0 : default:
1612 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type);
1613 : 0 : return 1;
1614 : : }
1615 : :
1616 : 0 : return 0;
1617 : : }
1618 : :
1619 : : static uint32_t
1620 : 0 : zxdh_np_soft_sdt_tbl_get(uint32_t dev_id, uint32_t sdt_no, void *p_sdt_info)
1621 : : {
1622 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
1623 : : uint32_t rc;
1624 : :
1625 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
1626 : :
1627 : 0 : rc = zxdh_np_sdt_tbl_data_parser(sdt_tbl.data_high32, sdt_tbl.data_low32, p_sdt_info);
1628 [ # # ]: 0 : if (rc != 0)
1629 : 0 : PMD_DRV_LOG(ERR, "dpp sdt [%d] tbl_data_parser error", sdt_no);
1630 : :
1631 : 0 : return rc;
1632 : : }
1633 : :
1634 : : static void
1635 : : zxdh_np_eram_index_cal(uint32_t eram_mode, uint32_t index,
1636 : : uint32_t *p_row_index, uint32_t *p_col_index)
1637 : : {
1638 : : uint32_t row_index = 0;
1639 : : uint32_t col_index = 0;
1640 : :
1641 : 0 : switch (eram_mode) {
1642 : : case ZXDH_ERAM128_TBL_128b:
1643 : : row_index = index;
1644 : : break;
1645 : 0 : case ZXDH_ERAM128_TBL_64b:
1646 : : row_index = (index >> 1);
1647 : 0 : col_index = index & 0x1;
1648 : 0 : break;
1649 : 0 : case ZXDH_ERAM128_TBL_1b:
1650 : : row_index = (index >> 7);
1651 : 0 : col_index = index & 0x7F;
1652 : 0 : break;
1653 : : }
1654 : : *p_row_index = row_index;
1655 : : *p_col_index = col_index;
1656 : : }
1657 : :
1658 : : static uint32_t
1659 : 0 : zxdh_np_dtb_eram_data_get(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no,
1660 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_eram_entry)
1661 : : {
1662 : 0 : uint32_t index = p_dump_eram_entry->index;
1663 : 0 : uint32_t *p_data = p_dump_eram_entry->p_data;
1664 : 0 : ZXDH_SDTTBL_ERAM_T sdt_eram_info = {0};
1665 : 0 : uint32_t temp_data[4] = {0};
1666 : : uint32_t row_index = 0;
1667 : : uint32_t col_index = 0;
1668 : : uint32_t rd_mode;
1669 : : uint32_t rc;
1670 : :
1671 : 0 : rc = zxdh_np_soft_sdt_tbl_get(queue_id, sdt_no, &sdt_eram_info);
1672 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_soft_sdt_tbl_get");
1673 [ # # # ]: 0 : rd_mode = sdt_eram_info.eram_mode;
1674 : :
1675 : : zxdh_np_eram_index_cal(rd_mode, index, &row_index, &col_index);
1676 : :
1677 [ # # # # ]: 0 : switch (rd_mode) {
1678 : : case ZXDH_ERAM128_TBL_128b:
1679 : : memcpy(p_data, temp_data, (128 / 8));
1680 : : break;
1681 : 0 : case ZXDH_ERAM128_TBL_64b:
1682 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
1683 : : break;
1684 : 0 : case ZXDH_ERAM128_TBL_1b:
1685 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
1686 : : (3 - col_index / 32)), (col_index % 32), 1);
1687 : 0 : break;
1688 : : }
1689 : 0 : return rc;
1690 : : }
1691 : :
1692 : : int
1693 : 0 : zxdh_np_dtb_table_entry_get(uint32_t dev_id,
1694 : : uint32_t queue_id,
1695 : : ZXDH_DTB_USER_ENTRY_T *get_entry,
1696 : : uint32_t srh_mode)
1697 : : {
1698 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
1699 : : uint32_t tbl_type = 0;
1700 : : uint32_t rc = 0;
1701 : : uint32_t sdt_no;
1702 : :
1703 : 0 : sdt_no = get_entry->sdt_no;
1704 : : zxdh_np_sdt_tbl_data_get(srh_mode, sdt_no, &sdt_tbl);
1705 : :
1706 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_tbl.data_high32,
1707 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
1708 [ # # ]: 0 : switch (tbl_type) {
1709 : 0 : case ZXDH_SDT_TBLT_ERAM:
1710 : 0 : rc = zxdh_np_dtb_eram_data_get(dev_id,
1711 : : queue_id,
1712 : : sdt_no,
1713 : 0 : (ZXDH_DTB_ERAM_ENTRY_INFO_T *)get_entry->p_entry_data);
1714 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_eram_data_get");
1715 : : break;
1716 : 0 : default:
1717 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type);
1718 : 0 : return 1;
1719 : : }
1720 : :
1721 : : return 0;
1722 : : }
1723 : :
1724 : : static void
1725 : : zxdh_np_stat_cfg_soft_get(uint32_t dev_id,
1726 : : ZXDH_PPU_STAT_CFG_T *p_stat_cfg)
1727 : : {
1728 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_stat_cfg);
1729 : :
1730 : 0 : p_stat_cfg->ddr_base_addr = g_ppu_stat_cfg.ddr_base_addr;
1731 : 0 : p_stat_cfg->eram_baddr = g_ppu_stat_cfg.eram_baddr;
1732 : 0 : p_stat_cfg->eram_depth = g_ppu_stat_cfg.eram_depth;
1733 : 0 : p_stat_cfg->ppu_addr_offset = g_ppu_stat_cfg.ppu_addr_offset;
1734 : : }
1735 : :
1736 : : static uint32_t
1737 : 0 : zxdh_np_dtb_tab_up_info_set(uint32_t dev_id,
1738 : : uint32_t queue_id,
1739 : : uint32_t item_index,
1740 : : uint32_t int_flag,
1741 : : uint32_t data_len,
1742 : : uint32_t desc_len,
1743 : : uint32_t *p_desc_data)
1744 : : {
1745 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
1746 : 0 : uint32_t queue_en = 0;
1747 : : uint32_t rc;
1748 : :
1749 : 0 : zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
1750 [ # # ]: 0 : if (!queue_en) {
1751 : 0 : PMD_DRV_LOG(ERR, "the queue %d is not enable!", queue_id);
1752 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
1753 : : }
1754 : :
1755 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
1756 : 0 : PMD_DRV_LOG(ERR, "dtb queue %d is not init", queue_id);
1757 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
1758 : : }
1759 : :
1760 [ # # ]: 0 : if (desc_len % 4 != 0)
1761 : : return ZXDH_RC_DTB_PARA_INVALID;
1762 : :
1763 : : zxdh_np_dtb_item_buff_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
1764 : : item_index, 0, desc_len, p_desc_data);
1765 : :
1766 : 0 : ZXDH_DTB_TAB_UP_DATA_LEN_GET(dev_id, queue_id, item_index) = data_len;
1767 : :
1768 : 0 : item_info.cmd_vld = 1;
1769 : 0 : item_info.cmd_type = ZXDH_DTB_DIR_UP_TYPE;
1770 : 0 : item_info.int_en = int_flag;
1771 [ # # ]: 0 : item_info.data_len = desc_len / 4;
1772 : :
1773 [ # # ]: 0 : if (zxdh_np_dev_get_dev_type(dev_id) == ZXDH_DEV_TYPE_SIM)
1774 : : return 0;
1775 : :
1776 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
1777 : :
1778 : 0 : return rc;
1779 : : }
1780 : :
1781 : : static uint32_t
1782 : 0 : zxdh_np_dtb_write_dump_desc_info(uint32_t dev_id,
1783 : : uint32_t queue_id,
1784 : : uint32_t queue_element_id,
1785 : : uint32_t *p_dump_info,
1786 : : uint32_t data_len,
1787 : : uint32_t desc_len,
1788 : : uint32_t *p_dump_data)
1789 : : {
1790 : : uint32_t dtb_interrupt_status = 0;
1791 : : uint32_t rc;
1792 : :
1793 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dump_data);
1794 : 0 : rc = zxdh_np_dtb_tab_up_info_set(dev_id,
1795 : : queue_id,
1796 : : queue_element_id,
1797 : : dtb_interrupt_status,
1798 : : data_len,
1799 : : desc_len,
1800 : : p_dump_info);
1801 [ # # ]: 0 : if (rc != 0) {
1802 : 0 : PMD_DRV_LOG(ERR, "the queue %d element id %d dump"
1803 : : " info set failed!", queue_id, queue_element_id);
1804 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
1805 : : queue_element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
1806 : : }
1807 : :
1808 : 0 : return rc;
1809 : : }
1810 : :
1811 : : static uint32_t
1812 : 0 : zxdh_np_dtb_tab_up_free_item_get(uint32_t dev_id,
1813 : : uint32_t queue_id,
1814 : : uint32_t *p_item_index)
1815 : : {
1816 : : uint32_t ack_vale = 0;
1817 : : uint32_t item_index = 0;
1818 : 0 : uint32_t unused_item_num = 0;
1819 : : uint32_t i;
1820 : :
1821 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
1822 : 0 : PMD_DRV_LOG(ERR, "dtb queue %d is not init", queue_id);
1823 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
1824 : : }
1825 : :
1826 : 0 : zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
1827 : :
1828 [ # # ]: 0 : if (unused_item_num == 0)
1829 : : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
1830 : :
1831 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
1832 : 0 : item_index = ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id) %
1833 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
1834 : :
1835 : : zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
1836 : : 0, &ack_vale);
1837 : :
1838 : 0 : ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id)++;
1839 : :
1840 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
1841 : : break;
1842 : : }
1843 : :
1844 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX)
1845 : : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
1846 : :
1847 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
1848 : : 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
1849 : :
1850 : 0 : *p_item_index = item_index;
1851 : :
1852 : :
1853 : 0 : return 0;
1854 : : }
1855 : :
1856 : : static uint32_t
1857 : 0 : zxdh_np_dtb_tab_up_item_addr_get(uint32_t dev_id,
1858 : : uint32_t queue_id,
1859 : : uint32_t item_index,
1860 : : uint32_t *p_phy_haddr,
1861 : : uint32_t *p_phy_laddr)
1862 : : {
1863 : : uint32_t rc = 0;
1864 : : uint64_t addr;
1865 : :
1866 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
1867 : 0 : PMD_DRV_LOG(ERR, "dtb queue %d is not init", queue_id);
1868 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
1869 : : }
1870 : :
1871 [ # # ]: 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
1872 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE)
1873 : 0 : addr = ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(dev_id, queue_id, item_index);
1874 : : else
1875 : : addr = ZXDH_DTB_ITEM_ACK_SIZE;
1876 : :
1877 : 0 : *p_phy_haddr = (addr >> 32) & 0xffffffff;
1878 : 0 : *p_phy_laddr = addr & 0xffffffff;
1879 : :
1880 : 0 : return rc;
1881 : : }
1882 : :
1883 : : static uint32_t
1884 : 0 : zxdh_np_dtb_se_smmu0_dma_dump(uint32_t dev_id,
1885 : : uint32_t queue_id,
1886 : : uint32_t base_addr,
1887 : : uint32_t depth,
1888 : : uint32_t *p_data,
1889 : : uint32_t *element_id)
1890 : : {
1891 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
1892 : 0 : uint32_t dump_dst_phy_haddr = 0;
1893 : 0 : uint32_t dump_dst_phy_laddr = 0;
1894 : 0 : uint32_t queue_item_index = 0;
1895 : : uint32_t data_len;
1896 : : uint32_t desc_len;
1897 : : uint32_t rc;
1898 : :
1899 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &queue_item_index);
1900 [ # # ]: 0 : if (rc != 0) {
1901 : 0 : PMD_DRV_LOG(ERR, "dpp_dtb_tab_up_free_item_get failed = %d!", base_addr);
1902 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
1903 : : }
1904 : :
1905 : 0 : *element_id = queue_item_index;
1906 : :
1907 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, queue_item_index,
1908 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
1909 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_tab_up_item_addr_get");
1910 : :
1911 : 0 : data_len = depth * 128 / 32;
1912 : : desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
1913 : :
1914 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id, queue_id, queue_item_index,
1915 : : (uint32_t *)form_buff, data_len, desc_len, p_data);
1916 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_dump_desc_info");
1917 : :
1918 : : return rc;
1919 : : }
1920 : :
1921 : : static uint32_t
1922 : 0 : zxdh_np_dtb_se_smmu0_ind_read(uint32_t dev_id,
1923 : : uint32_t queue_id,
1924 : : uint32_t base_addr,
1925 : : uint32_t index,
1926 : : uint32_t rd_mode,
1927 : : uint32_t *p_data)
1928 : : {
1929 : 0 : uint32_t temp_data[4] = {0};
1930 : 0 : uint32_t element_id = 0;
1931 : : uint32_t row_index = 0;
1932 : : uint32_t col_index = 0;
1933 : : uint32_t eram_dump_base_addr;
1934 : : uint32_t rc;
1935 : :
1936 [ # # # # ]: 0 : switch (rd_mode) {
1937 : 0 : case ZXDH_ERAM128_OPR_128b:
1938 : : row_index = index;
1939 : 0 : break;
1940 : 0 : case ZXDH_ERAM128_OPR_64b:
1941 : 0 : row_index = (index >> 1);
1942 : 0 : col_index = index & 0x1;
1943 : 0 : break;
1944 : 0 : case ZXDH_ERAM128_OPR_1b:
1945 : 0 : row_index = (index >> 7);
1946 : 0 : col_index = index & 0x7F;
1947 : 0 : break;
1948 : : }
1949 : :
1950 : 0 : eram_dump_base_addr = base_addr + row_index;
1951 : 0 : rc = zxdh_np_dtb_se_smmu0_dma_dump(dev_id,
1952 : : queue_id,
1953 : : eram_dump_base_addr,
1954 : : 1,
1955 : : temp_data,
1956 : : &element_id);
1957 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_dma_dump");
1958 : :
1959 [ # # # # ]: 0 : switch (rd_mode) {
1960 : : case ZXDH_ERAM128_OPR_128b:
1961 : : memcpy(p_data, temp_data, (128 / 8));
1962 : : break;
1963 : 0 : case ZXDH_ERAM128_OPR_64b:
1964 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
1965 : : break;
1966 : 0 : case ZXDH_ERAM128_OPR_1b:
1967 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
1968 : : (3 - col_index / 32)), (col_index % 32), 1);
1969 : 0 : break;
1970 : : }
1971 : :
1972 : 0 : return rc;
1973 : : }
1974 : :
1975 : : static uint32_t
1976 : 0 : zxdh_np_dtb_stat_smmu0_int_read(uint32_t dev_id,
1977 : : uint32_t queue_id,
1978 : : uint32_t smmu0_base_addr,
1979 : : ZXDH_STAT_CNT_MODE_E rd_mode,
1980 : : uint32_t index,
1981 : : uint32_t *p_data)
1982 : : {
1983 : : uint32_t eram_rd_mode;
1984 : : uint32_t rc;
1985 : :
1986 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
1987 : :
1988 [ # # ]: 0 : if (rd_mode == ZXDH_STAT_128_MODE)
1989 : : eram_rd_mode = ZXDH_ERAM128_OPR_128b;
1990 : : else
1991 : : eram_rd_mode = ZXDH_ERAM128_OPR_64b;
1992 : :
1993 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_read(dev_id,
1994 : : queue_id,
1995 : : smmu0_base_addr,
1996 : : index,
1997 : : eram_rd_mode,
1998 : : p_data);
1999 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_ind_read");
2000 : :
2001 : 0 : return rc;
2002 : : }
2003 : :
2004 : : int
2005 : 0 : zxdh_np_dtb_stats_get(uint32_t dev_id,
2006 : : uint32_t queue_id,
2007 : : ZXDH_STAT_CNT_MODE_E rd_mode,
2008 : : uint32_t index,
2009 : : uint32_t *p_data)
2010 : : {
2011 : : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
2012 : : uint32_t ppu_eram_baddr;
2013 : : uint32_t ppu_eram_depth;
2014 : : uint32_t rc = 0;
2015 : :
2016 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
2017 : :
2018 : : memset(&stat_cfg, 0x0, sizeof(stat_cfg));
2019 : :
2020 : : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
2021 : :
2022 : : ppu_eram_depth = stat_cfg.eram_depth;
2023 : : ppu_eram_baddr = stat_cfg.eram_baddr;
2024 : :
2025 [ # # ]: 0 : if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) {
2026 : 0 : rc = zxdh_np_dtb_stat_smmu0_int_read(dev_id,
2027 : : queue_id,
2028 : : ppu_eram_baddr,
2029 : : rd_mode,
2030 : : index,
2031 : : p_data);
2032 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_stat_smmu0_int_read");
2033 : : }
2034 : :
2035 : 0 : return rc;
2036 : : }
2037 : :
2038 : : static uint32_t
2039 : 0 : zxdh_np_se_done_status_check(uint32_t dev_id, uint32_t reg_no, uint32_t pos)
2040 : : {
2041 : : uint32_t rc = 0;
2042 : :
2043 : 0 : uint32_t data = 0;
2044 : : uint32_t rd_cnt = 0;
2045 : : uint32_t done_flag = 0;
2046 : :
2047 : 0 : while (!done_flag) {
2048 : 0 : rc = zxdh_np_reg_read(dev_id, reg_no, 0, 0, &data);
2049 [ # # ]: 0 : if (rc != 0) {
2050 : 0 : PMD_DRV_LOG(ERR, " [ErrorCode:0x%x] !-- zxdh_np_reg_read Fail!", rc);
2051 : 0 : return rc;
2052 : : }
2053 : :
2054 : 0 : done_flag = (data >> pos) & 0x1;
2055 : :
2056 [ # # ]: 0 : if (done_flag)
2057 : : break;
2058 : :
2059 [ # # ]: 0 : if (rd_cnt > ZXDH_RD_CNT_MAX * ZXDH_RD_CNT_MAX)
2060 : : return -1;
2061 : :
2062 : 0 : rd_cnt++;
2063 : : }
2064 : :
2065 : : return rc;
2066 : : }
2067 : :
2068 : : static uint32_t
2069 : 0 : zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
2070 : : uint32_t base_addr,
2071 : : uint32_t index,
2072 : : uint32_t rd_mode,
2073 : : uint32_t rd_clr_mode,
2074 : : uint32_t *p_data)
2075 : : {
2076 : : uint32_t rc = 0;
2077 : : uint32_t i = 0;
2078 : : uint32_t row_index = 0;
2079 : : uint32_t col_index = 0;
2080 : 0 : uint32_t temp_data[4] = {0};
2081 : : uint32_t *p_temp_data = NULL;
2082 : 0 : ZXDH_SMMU0_SMMU0_CPU_IND_CMD_T cpu_ind_cmd = {0};
2083 : :
2084 : 0 : rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_WR_ARB_CPU_RDYR, 0);
2085 : :
2086 [ # # ]: 0 : if (rd_clr_mode == ZXDH_RD_MODE_HOLD) {
2087 : : cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD;
2088 : : cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_HOLD;
2089 : : cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b;
2090 : :
2091 [ # # # # : 0 : switch (rd_mode) {
# ]
2092 : 0 : case ZXDH_ERAM128_OPR_128b:
2093 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index))
2094 : : return ZXDH_PAR_CHK_INVALID_INDEX;
2095 : :
2096 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
2097 : 0 : PMD_DRV_LOG(ERR, "%s : index out of range !", __func__);
2098 : 0 : return -1;
2099 : : }
2100 : :
2101 : 0 : row_index = (index << 7) & ZXDH_ERAM128_BADDR_MASK;
2102 : 0 : break;
2103 : 0 : case ZXDH_ERAM128_OPR_64b:
2104 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
2105 : 0 : PMD_DRV_LOG(ERR, "%s : index out of range !", __func__);
2106 : 0 : return -1;
2107 : : }
2108 : :
2109 : 0 : row_index = (index << 6) & ZXDH_ERAM128_BADDR_MASK;
2110 : 0 : col_index = index & 0x1;
2111 : 0 : break;
2112 : 0 : case ZXDH_ERAM128_OPR_32b:
2113 [ # # ]: 0 : if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
2114 : 0 : PMD_DRV_LOG(ERR, "%s : index out of range !", __func__);
2115 : 0 : return -1;
2116 : : }
2117 : :
2118 : 0 : row_index = (index << 5) & ZXDH_ERAM128_BADDR_MASK;
2119 : 0 : col_index = index & 0x3;
2120 : 0 : break;
2121 : 0 : case ZXDH_ERAM128_OPR_1b:
2122 [ # # ]: 0 : if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
2123 : 0 : PMD_DRV_LOG(ERR, "%s : index out of range !", __func__);
2124 : 0 : return -1;
2125 : : }
2126 : 0 : row_index = index & ZXDH_ERAM128_BADDR_MASK;
2127 : 0 : col_index = index & 0x7F;
2128 : 0 : break;
2129 : : }
2130 : :
2131 : 0 : cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index;
2132 : : } else {
2133 : : cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD;
2134 : 0 : cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_CLEAR;
2135 : :
2136 [ # # # # : 0 : switch (rd_mode) {
# ]
2137 : 0 : case ZXDH_ERAM128_OPR_128b:
2138 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
2139 : 0 : PMD_DRV_LOG(ERR, "%s : index 0x%x is invalid!", __func__, index);
2140 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
2141 : : }
2142 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
2143 : 0 : PMD_DRV_LOG(ERR, "%s : index out of range !", __func__);
2144 : 0 : return -1;
2145 : : }
2146 : 0 : row_index = (index << 7);
2147 : : cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b;
2148 : 0 : break;
2149 : 0 : case ZXDH_ERAM128_OPR_64b:
2150 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
2151 : 0 : PMD_DRV_LOG(ERR, "%s : index out of range !", __func__);
2152 : 0 : return -1;
2153 : : }
2154 : :
2155 : 0 : row_index = (index << 6);
2156 : 0 : cpu_ind_cmd.cpu_req_mode = 2;
2157 : 0 : break;
2158 : 0 : case ZXDH_ERAM128_OPR_32b:
2159 [ # # ]: 0 : if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
2160 : 0 : PMD_DRV_LOG(ERR, "%s : index out of range !", __func__);
2161 : 0 : return -1;
2162 : : }
2163 : 0 : row_index = (index << 5);
2164 : 0 : cpu_ind_cmd.cpu_req_mode = 1;
2165 : 0 : break;
2166 : 0 : case ZXDH_ERAM128_OPR_1b:
2167 : 0 : PMD_DRV_LOG(ERR, "rd_clr_mode[%d] or rd_mode[%d] error! ",
2168 : : rd_clr_mode, rd_mode);
2169 : 0 : return -1;
2170 : : }
2171 : 0 : cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index;
2172 : : }
2173 : :
2174 : 0 : rc = zxdh_np_reg_write(dev_id,
2175 : : ZXDH_SMMU0_SMMU0_CPU_IND_CMDR,
2176 : : 0,
2177 : : 0,
2178 : : &cpu_ind_cmd);
2179 : :
2180 : 0 : rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_RD_CPU_IND_DONER, 0);
2181 : :
2182 : : p_temp_data = temp_data;
2183 [ # # ]: 0 : for (i = 0; i < 4; i++) {
2184 : 0 : rc = zxdh_np_reg_read(dev_id,
2185 : : ZXDH_SMMU0_SMMU0_CPU_IND_RDAT0R + i,
2186 : : 0,
2187 : : 0,
2188 : 0 : p_temp_data + 3 - i);
2189 : : }
2190 : :
2191 [ # # ]: 0 : if (rd_clr_mode == ZXDH_RD_MODE_HOLD) {
2192 [ # # # # : 0 : switch (rd_mode) {
# ]
2193 : : case ZXDH_ERAM128_OPR_128b:
2194 : : memcpy(p_data, p_temp_data, (128 / 8));
2195 : : break;
2196 : 0 : case ZXDH_ERAM128_OPR_64b:
2197 : 0 : memcpy(p_data, p_temp_data + ((1 - col_index) << 1), (64 / 8));
2198 : : break;
2199 : 0 : case ZXDH_ERAM128_OPR_32b:
2200 : 0 : memcpy(p_data, p_temp_data + ((3 - col_index)), (32 / 8));
2201 : : break;
2202 : 0 : case ZXDH_ERAM128_OPR_1b:
2203 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0],
2204 : : *(p_temp_data + (3 - col_index / 32)), (col_index % 32), 1);
2205 : 0 : break;
2206 : : }
2207 : : } else {
2208 [ # # # # ]: 0 : switch (rd_mode) {
2209 : : case ZXDH_ERAM128_OPR_128b:
2210 : : memcpy(p_data, p_temp_data, (128 / 8));
2211 : : break;
2212 : : case ZXDH_ERAM128_OPR_64b:
2213 : : memcpy(p_data, p_temp_data, (64 / 8));
2214 : : break;
2215 : : case ZXDH_ERAM128_OPR_32b:
2216 : : memcpy(p_data, p_temp_data, (64 / 8));
2217 : : break;
2218 : : }
2219 : : }
2220 : :
2221 : : return rc;
2222 : : }
2223 : :
2224 : : uint32_t
2225 : 0 : zxdh_np_stat_ppu_cnt_get_ex(uint32_t dev_id,
2226 : : ZXDH_STAT_CNT_MODE_E rd_mode,
2227 : : uint32_t index,
2228 : : uint32_t clr_mode,
2229 : : uint32_t *p_data)
2230 : : {
2231 : : uint32_t rc = 0;
2232 : : uint32_t ppu_eram_baddr = 0;
2233 : : uint32_t ppu_eram_depth = 0;
2234 : : uint32_t eram_rd_mode = 0;
2235 : : uint32_t eram_clr_mode = 0;
2236 : : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
2237 : :
2238 : : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
2239 : :
2240 : : ppu_eram_depth = stat_cfg.eram_depth;
2241 : : ppu_eram_baddr = stat_cfg.eram_baddr;
2242 : :
2243 [ # # ]: 0 : if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) {
2244 [ # # ]: 0 : if (rd_mode == ZXDH_STAT_128_MODE)
2245 : : eram_rd_mode = ZXDH_ERAM128_OPR_128b;
2246 : : else
2247 : : eram_rd_mode = ZXDH_ERAM128_OPR_64b;
2248 : :
2249 [ # # ]: 0 : if (clr_mode == ZXDH_STAT_RD_CLR_MODE_UNCLR)
2250 : : eram_clr_mode = ZXDH_RD_MODE_HOLD;
2251 : : else
2252 : : eram_clr_mode = ZXDH_RD_MODE_CLEAR;
2253 : :
2254 : 0 : rc = zxdh_np_se_smmu0_ind_read(dev_id,
2255 : : ppu_eram_baddr,
2256 : : index,
2257 : : eram_rd_mode,
2258 : : eram_clr_mode,
2259 : : p_data);
2260 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_smmu0_ind_read");
2261 : : } else {
2262 : 0 : PMD_DRV_LOG(ERR, "DPDK DON'T HAVE DDR STAT.");
2263 : : }
2264 : :
2265 : 0 : return rc;
2266 : : }
2267 : :
2268 : : static uint32_t
2269 : 0 : zxdh_np_agent_channel_sync_send(ZXDH_AGENT_CHANNEL_MSG_T *p_msg,
2270 : : uint32_t *p_data,
2271 : : uint32_t rep_len)
2272 : : {
2273 : : uint32_t ret = 0;
2274 : : uint32_t vport = 0;
2275 : 0 : struct zxdh_pci_bar_msg in = {0};
2276 : 0 : struct zxdh_msg_recviver_mem result = {0};
2277 : : uint32_t *recv_buffer;
2278 : : uint8_t *reply_ptr = NULL;
2279 : : uint16_t reply_msg_len = 0;
2280 : : uint64_t agent_addr = 0;
2281 : :
2282 : : if (ZXDH_IS_PF(vport))
2283 : 0 : in.src = ZXDH_MSG_CHAN_END_PF;
2284 : : else
2285 : : in.src = ZXDH_MSG_CHAN_END_VF;
2286 : :
2287 : : in.virt_addr = agent_addr;
2288 : 0 : in.payload_addr = p_msg->msg;
2289 : 0 : in.payload_len = p_msg->msg_len;
2290 : 0 : in.dst = ZXDH_MSG_CHAN_END_RISC;
2291 : 0 : in.module_id = ZXDH_BAR_MDOULE_NPSDK;
2292 : :
2293 : 0 : recv_buffer = (uint32_t *)rte_zmalloc(NULL, rep_len + ZXDH_CHANNEL_REPS_LEN, 0);
2294 [ # # ]: 0 : if (recv_buffer == NULL) {
2295 : 0 : PMD_DRV_LOG(ERR, "%s point null!", __func__);
2296 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2297 : : }
2298 : :
2299 : 0 : result.buffer_len = rep_len + ZXDH_CHANNEL_REPS_LEN;
2300 : 0 : result.recv_buffer = recv_buffer;
2301 : :
2302 : 0 : ret = zxdh_bar_chan_sync_msg_send(&in, &result);
2303 [ # # ]: 0 : if (ret == ZXDH_BAR_MSG_OK) {
2304 : 0 : reply_ptr = (uint8_t *)(result.recv_buffer);
2305 [ # # ]: 0 : if (*reply_ptr == 0XFF) {
2306 : 0 : reply_msg_len = *(uint16_t *)(reply_ptr + 1);
2307 : 0 : memcpy(p_data, reply_ptr + 4,
2308 : 0 : ((reply_msg_len > rep_len) ? rep_len : reply_msg_len));
2309 : : } else {
2310 : 0 : PMD_DRV_LOG(ERR, "Message not replied");
2311 : : }
2312 : : } else {
2313 : 0 : PMD_DRV_LOG(ERR, "Error[0x%x], %s failed!", ret, __func__);
2314 : : }
2315 : :
2316 : 0 : rte_free(recv_buffer);
2317 : 0 : return ret;
2318 : : }
2319 : :
2320 : : static uint32_t
2321 : 0 : zxdh_np_agent_channel_plcr_sync_send(ZXDH_AGENT_CHANNEL_PLCR_MSG_T *p_msg,
2322 : : uint32_t *p_data, uint32_t rep_len)
2323 : : {
2324 : : uint32_t ret = 0;
2325 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {0};
2326 : :
2327 : 0 : agent_msg.msg = (void *)p_msg;
2328 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CHANNEL_PLCR_MSG_T);
2329 : :
2330 : 0 : ret = zxdh_np_agent_channel_sync_send(&agent_msg, p_data, rep_len);
2331 [ # # ]: 0 : if (ret != 0) {
2332 : 0 : PMD_DRV_LOG(ERR, "%s: agent_channel_sync_send failed.", __func__);
2333 : 0 : return 1;
2334 : : }
2335 : :
2336 : : return 0;
2337 : : }
2338 : :
2339 : : static uint32_t
2340 : 0 : zxdh_np_agent_channel_plcr_profileid_request(uint32_t vport,
2341 : : uint32_t car_type, uint32_t *p_profileid)
2342 : : {
2343 : : uint32_t ret = 0;
2344 : 0 : uint32_t resp_buffer[2] = {0};
2345 : :
2346 : 0 : ZXDH_AGENT_CHANNEL_PLCR_MSG_T msgcfg = {0};
2347 : :
2348 : : msgcfg.dev_id = 0;
2349 : 0 : msgcfg.type = ZXDH_PLCR_MSG;
2350 : : msgcfg.oper = ZXDH_PROFILEID_REQUEST;
2351 : 0 : msgcfg.vport = vport;
2352 : 0 : msgcfg.car_type = car_type;
2353 : 0 : msgcfg.profile_id = 0xFFFF;
2354 : :
2355 : 0 : ret = zxdh_np_agent_channel_plcr_sync_send(&msgcfg,
2356 : : resp_buffer, sizeof(resp_buffer));
2357 [ # # ]: 0 : if (ret != 0) {
2358 : 0 : PMD_DRV_LOG(ERR, "%s: agent_channel_plcr_sync_send failed.", __func__);
2359 : 0 : return 1;
2360 : : }
2361 : :
2362 : : memcpy(p_profileid, resp_buffer, sizeof(uint32_t) * ZXDH_SCHE_RSP_LEN);
2363 : :
2364 : 0 : return ret;
2365 : : }
2366 : :
2367 : : static uint32_t
2368 : 0 : zxdh_np_agent_channel_plcr_car_rate(uint32_t car_type,
2369 : : uint32_t pkt_sign,
2370 : : uint32_t profile_id __rte_unused,
2371 : : void *p_car_profile_cfg)
2372 : : {
2373 : : uint32_t ret = 0;
2374 : 0 : uint32_t resp_buffer[2] = {0};
2375 : : uint32_t resp_len = 8;
2376 : : uint32_t i = 0;
2377 : 0 : ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {0};
2378 : 0 : ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T msgpktcfg = {0};
2379 : 0 : ZXDH_AGENT_CAR_PROFILE_MSG_T msgcfg = {0};
2380 : : ZXDH_STAT_CAR_PROFILE_CFG_T *p_stat_car_profile_cfg = NULL;
2381 : : ZXDH_STAT_CAR_PKT_PROFILE_CFG_T *p_stat_pkt_car_profile_cfg = NULL;
2382 : :
2383 [ # # ]: 0 : if (car_type == ZXDH_STAT_CAR_A_TYPE && pkt_sign == 1) {
2384 : : p_stat_pkt_car_profile_cfg = (ZXDH_STAT_CAR_PKT_PROFILE_CFG_T *)p_car_profile_cfg;
2385 : : msgpktcfg.dev_id = 0;
2386 : 0 : msgpktcfg.type = ZXDH_PLCR_CAR_PKT_RATE;
2387 : 0 : msgpktcfg.car_level = car_type;
2388 : 0 : msgpktcfg.cir = p_stat_pkt_car_profile_cfg->cir;
2389 : 0 : msgpktcfg.cbs = p_stat_pkt_car_profile_cfg->cbs;
2390 : 0 : msgpktcfg.profile_id = p_stat_pkt_car_profile_cfg->profile_id;
2391 : 0 : msgpktcfg.pkt_sign = p_stat_pkt_car_profile_cfg->pkt_sign;
2392 [ # # ]: 0 : for (i = 0; i < ZXDH_CAR_PRI_MAX; i++)
2393 : 0 : msgpktcfg.pri[i] = p_stat_pkt_car_profile_cfg->pri[i];
2394 : :
2395 : 0 : agent_msg.msg = (void *)&msgpktcfg;
2396 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T);
2397 : :
2398 : 0 : ret = zxdh_np_agent_channel_sync_send(&agent_msg, resp_buffer, resp_len);
2399 [ # # ]: 0 : if (ret != 0) {
2400 : 0 : PMD_DRV_LOG(ERR, "%s: stat_car_a_type failed.", __func__);
2401 : 0 : return 1;
2402 : : }
2403 : :
2404 : 0 : ret = *(uint8_t *)resp_buffer;
2405 : : } else {
2406 : : p_stat_car_profile_cfg = (ZXDH_STAT_CAR_PROFILE_CFG_T *)p_car_profile_cfg;
2407 : : msgcfg.dev_id = 0;
2408 : 0 : msgcfg.type = ZXDH_PLCR_CAR_RATE;
2409 : 0 : msgcfg.car_level = car_type;
2410 : 0 : msgcfg.cir = p_stat_car_profile_cfg->cir;
2411 : 0 : msgcfg.cbs = p_stat_car_profile_cfg->cbs;
2412 : 0 : msgcfg.profile_id = p_stat_car_profile_cfg->profile_id;
2413 : 0 : msgcfg.pkt_sign = p_stat_car_profile_cfg->pkt_sign;
2414 : 0 : msgcfg.cd = p_stat_car_profile_cfg->cd;
2415 : 0 : msgcfg.cf = p_stat_car_profile_cfg->cf;
2416 : 0 : msgcfg.cm = p_stat_car_profile_cfg->cm;
2417 : : msgcfg.cir = p_stat_car_profile_cfg->cir;
2418 : : msgcfg.cbs = p_stat_car_profile_cfg->cbs;
2419 : 0 : msgcfg.eir = p_stat_car_profile_cfg->eir;
2420 : 0 : msgcfg.ebs = p_stat_car_profile_cfg->ebs;
2421 : 0 : msgcfg.random_disc_e = p_stat_car_profile_cfg->random_disc_e;
2422 : 0 : msgcfg.random_disc_c = p_stat_car_profile_cfg->random_disc_c;
2423 [ # # ]: 0 : for (i = 0; i < ZXDH_CAR_PRI_MAX; i++) {
2424 : 0 : msgcfg.c_pri[i] = p_stat_car_profile_cfg->c_pri[i];
2425 : 0 : msgcfg.e_green_pri[i] = p_stat_car_profile_cfg->e_green_pri[i];
2426 : 0 : msgcfg.e_yellow_pri[i] = p_stat_car_profile_cfg->e_yellow_pri[i];
2427 : : }
2428 : :
2429 : 0 : agent_msg.msg = (void *)&msgcfg;
2430 : 0 : agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PROFILE_MSG_T);
2431 : :
2432 : 0 : ret = zxdh_np_agent_channel_sync_send(&agent_msg, resp_buffer, resp_len);
2433 [ # # ]: 0 : if (ret != 0) {
2434 : 0 : PMD_DRV_LOG(ERR, "%s: stat_car_b_type failed.", __func__);
2435 : 0 : return 1;
2436 : : }
2437 : :
2438 : 0 : ret = *(uint8_t *)resp_buffer;
2439 : : }
2440 : :
2441 : : return ret;
2442 : : }
2443 : :
2444 : : static uint32_t
2445 : 0 : zxdh_np_agent_channel_plcr_profileid_release(uint32_t vport,
2446 : : uint32_t car_type __rte_unused,
2447 : : uint32_t profileid)
2448 : : {
2449 : : uint32_t ret = 0;
2450 : 0 : uint32_t resp_buffer[2] = {0};
2451 : :
2452 : 0 : ZXDH_AGENT_CHANNEL_PLCR_MSG_T msgcfg = {0};
2453 : :
2454 : : msgcfg.dev_id = 0;
2455 : 0 : msgcfg.type = ZXDH_PLCR_MSG;
2456 : 0 : msgcfg.oper = ZXDH_PROFILEID_RELEASE;
2457 : 0 : msgcfg.vport = vport;
2458 : 0 : msgcfg.profile_id = profileid;
2459 : :
2460 : 0 : ret = zxdh_np_agent_channel_plcr_sync_send(&msgcfg,
2461 : : resp_buffer, sizeof(resp_buffer));
2462 [ # # ]: 0 : if (ret != 0) {
2463 : 0 : PMD_DRV_LOG(ERR, "%s: agent_channel_plcr_sync_send failed.", __func__);
2464 : 0 : return 1;
2465 : : }
2466 : :
2467 : 0 : ret = *(uint8_t *)resp_buffer;
2468 : :
2469 : 0 : return ret;
2470 : : }
2471 : :
2472 : : static uint32_t
2473 : 0 : zxdh_np_stat_cara_queue_cfg_set(uint32_t dev_id,
2474 : : uint32_t flow_id,
2475 : : uint32_t drop_flag,
2476 : : uint32_t plcr_en,
2477 : : uint32_t profile_id)
2478 : : {
2479 : : uint32_t rc = 0;
2480 : :
2481 : 0 : ZXDH_STAT_CAR0_CARA_QUEUE_RAM0_159_0_T queue_cfg = {0};
2482 : :
2483 : 0 : queue_cfg.cara_drop = drop_flag;
2484 : 0 : queue_cfg.cara_plcr_en = plcr_en;
2485 : 0 : queue_cfg.cara_profile_id = profile_id;
2486 : 0 : rc = zxdh_np_reg_write(dev_id,
2487 : : ZXDH_STAT_CAR0_CARA_QUEUE_RAM0,
2488 : : 0,
2489 : : flow_id,
2490 : : &queue_cfg);
2491 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
2492 : :
2493 : 0 : return rc;
2494 : : }
2495 : :
2496 : : static uint32_t
2497 : 0 : zxdh_np_stat_carb_queue_cfg_set(uint32_t dev_id,
2498 : : uint32_t flow_id,
2499 : : uint32_t drop_flag,
2500 : : uint32_t plcr_en,
2501 : : uint32_t profile_id)
2502 : : {
2503 : : uint32_t rc = 0;
2504 : :
2505 : 0 : ZXDH_STAT_CAR0_CARB_QUEUE_RAM0_159_0_T queue_cfg = {0};
2506 : :
2507 : 0 : queue_cfg.carb_drop = drop_flag;
2508 : 0 : queue_cfg.carb_plcr_en = plcr_en;
2509 : 0 : queue_cfg.carb_profile_id = profile_id;
2510 : :
2511 : 0 : rc = zxdh_np_reg_write(dev_id,
2512 : : ZXDH_STAT_CAR0_CARB_QUEUE_RAM0,
2513 : : 0,
2514 : : flow_id,
2515 : : &queue_cfg);
2516 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
2517 : :
2518 : 0 : return rc;
2519 : : }
2520 : :
2521 : : static uint32_t
2522 : 0 : zxdh_np_stat_carc_queue_cfg_set(uint32_t dev_id,
2523 : : uint32_t flow_id,
2524 : : uint32_t drop_flag,
2525 : : uint32_t plcr_en,
2526 : : uint32_t profile_id)
2527 : : {
2528 : : uint32_t rc = 0;
2529 : :
2530 : 0 : ZXDH_STAT_CAR0_CARC_QUEUE_RAM0_159_0_T queue_cfg = {0};
2531 : 0 : queue_cfg.carc_drop = drop_flag;
2532 : 0 : queue_cfg.carc_plcr_en = plcr_en;
2533 : 0 : queue_cfg.carc_profile_id = profile_id;
2534 : :
2535 : 0 : rc = zxdh_np_reg_write(dev_id,
2536 : : ZXDH_STAT_CAR0_CARC_QUEUE_RAM0,
2537 : : 0,
2538 : : flow_id,
2539 : : &queue_cfg);
2540 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_reg_write");
2541 : :
2542 : 0 : return rc;
2543 : : }
2544 : :
2545 : : uint32_t
2546 : 0 : zxdh_np_car_profile_id_add(uint32_t vport_id,
2547 : : uint32_t flags,
2548 : : uint64_t *p_profile_id)
2549 : : {
2550 : : uint32_t ret = 0;
2551 : : uint32_t *profile_id;
2552 : : uint32_t profile_id_h = 0;
2553 : : uint32_t profile_id_l = 0;
2554 : : uint64_t temp_profile_id = 0;
2555 : :
2556 : 0 : profile_id = (uint32_t *)rte_zmalloc(NULL, ZXDH_G_PROFILE_ID_LEN, 0);
2557 [ # # ]: 0 : if (profile_id == NULL) {
2558 : 0 : PMD_DRV_LOG(ERR, "%s: profile_id point null!", __func__);
2559 : 0 : return ZXDH_PAR_CHK_POINT_NULL;
2560 : : }
2561 : 0 : ret = zxdh_np_agent_channel_plcr_profileid_request(vport_id, flags, profile_id);
2562 : :
2563 : 0 : profile_id_h = *(profile_id + 1);
2564 : 0 : profile_id_l = *profile_id;
2565 : 0 : rte_free(profile_id);
2566 : :
2567 : 0 : temp_profile_id = (((uint64_t)profile_id_l) << 32) | ((uint64_t)profile_id_h);
2568 [ # # ]: 0 : if (0 != (uint32_t)(temp_profile_id >> 56)) {
2569 : 0 : PMD_DRV_LOG(ERR, "%s: profile_id is overflow!", __func__);
2570 : 0 : return 1;
2571 : : }
2572 : :
2573 : 0 : *p_profile_id = temp_profile_id;
2574 : :
2575 : 0 : return ret;
2576 : : }
2577 : :
2578 : : uint32_t
2579 : 0 : zxdh_np_car_profile_cfg_set(uint32_t vport_id __rte_unused,
2580 : : uint32_t car_type,
2581 : : uint32_t pkt_sign,
2582 : : uint32_t profile_id,
2583 : : void *p_car_profile_cfg)
2584 : : {
2585 : : uint32_t ret = 0;
2586 : :
2587 : 0 : ret = zxdh_np_agent_channel_plcr_car_rate(car_type,
2588 : : pkt_sign, profile_id, p_car_profile_cfg);
2589 [ # # ]: 0 : if (ret != 0) {
2590 : 0 : PMD_DRV_LOG(ERR, "%s: plcr_car_rate set failed!", __func__);
2591 : 0 : return 1;
2592 : : }
2593 : :
2594 : : return ret;
2595 : : }
2596 : :
2597 : : uint32_t
2598 : 0 : zxdh_np_car_profile_id_delete(uint32_t vport_id,
2599 : : uint32_t flags, uint64_t profile_id)
2600 : : {
2601 : : uint32_t ret = 0;
2602 : : uint32_t profileid = 0;
2603 : :
2604 : 0 : profileid = profile_id & 0xFFFF;
2605 : :
2606 : 0 : ret = zxdh_np_agent_channel_plcr_profileid_release(vport_id, flags, profileid);
2607 [ # # ]: 0 : if (ret != 0) {
2608 : 0 : PMD_DRV_LOG(ERR, "%s: plcr profiled id release failed!", __func__);
2609 : 0 : return 1;
2610 : : }
2611 : :
2612 : : return 0;
2613 : : }
2614 : :
2615 : : uint32_t
2616 : 0 : zxdh_np_stat_car_queue_cfg_set(uint32_t dev_id,
2617 : : uint32_t car_type,
2618 : : uint32_t flow_id,
2619 : : uint32_t drop_flag,
2620 : : uint32_t plcr_en,
2621 : : uint32_t profile_id)
2622 : : {
2623 : : uint32_t rc = 0;
2624 : :
2625 [ # # ]: 0 : if (car_type == ZXDH_STAT_CAR_A_TYPE) {
2626 [ # # ]: 0 : if (flow_id > ZXDH_CAR_A_FLOW_ID_MAX) {
2627 : 0 : PMD_DRV_LOG(ERR, "%s: stat car a type flow_id invalid!", __func__);
2628 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
2629 : : }
2630 : :
2631 [ # # ]: 0 : if (profile_id > ZXDH_CAR_A_PROFILE_ID_MAX) {
2632 : 0 : PMD_DRV_LOG(ERR, "%s: stat car a type profile_id invalid!", __func__);
2633 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
2634 : : }
2635 [ # # ]: 0 : } else if (car_type == ZXDH_STAT_CAR_B_TYPE) {
2636 [ # # ]: 0 : if (flow_id > ZXDH_CAR_B_FLOW_ID_MAX) {
2637 : 0 : PMD_DRV_LOG(ERR, "%s: stat car b type flow_id invalid!", __func__);
2638 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
2639 : : }
2640 : :
2641 [ # # ]: 0 : if (profile_id > ZXDH_CAR_B_PROFILE_ID_MAX) {
2642 : 0 : PMD_DRV_LOG(ERR, "%s: stat car b type profile_id invalid!", __func__);
2643 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
2644 : : }
2645 : : } else {
2646 [ # # ]: 0 : if (flow_id > ZXDH_CAR_C_FLOW_ID_MAX) {
2647 : 0 : PMD_DRV_LOG(ERR, "%s: stat car c type flow_id invalid!", __func__);
2648 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
2649 : : }
2650 : :
2651 [ # # ]: 0 : if (profile_id > ZXDH_CAR_C_PROFILE_ID_MAX) {
2652 : 0 : PMD_DRV_LOG(ERR, "%s: stat car c type profile_id invalid!", __func__);
2653 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
2654 : : }
2655 : : }
2656 : :
2657 [ # # # # ]: 0 : switch (car_type) {
2658 : 0 : case ZXDH_STAT_CAR_A_TYPE:
2659 : 0 : rc = zxdh_np_stat_cara_queue_cfg_set(dev_id,
2660 : : flow_id,
2661 : : drop_flag,
2662 : : plcr_en,
2663 : : profile_id);
2664 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_cara_queue_cfg_set");
2665 : : break;
2666 : :
2667 : 0 : case ZXDH_STAT_CAR_B_TYPE:
2668 : 0 : rc = zxdh_np_stat_carb_queue_cfg_set(dev_id,
2669 : : flow_id,
2670 : : drop_flag,
2671 : : plcr_en,
2672 : : profile_id);
2673 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_carb_queue_cfg_set");
2674 : : break;
2675 : :
2676 : 0 : case ZXDH_STAT_CAR_C_TYPE:
2677 : 0 : rc = zxdh_np_stat_carc_queue_cfg_set(dev_id,
2678 : : flow_id,
2679 : : drop_flag,
2680 : : plcr_en,
2681 : : profile_id);
2682 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "stat_carc_queue_cfg_set");
2683 : : break;
2684 : : }
2685 : :
2686 : : return rc;
2687 : : }
|
