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 : :
17 : : static uint64_t g_np_bar_offset;
18 : : static ZXDH_DEV_MGR_T g_dev_mgr;
19 : : static ZXDH_SDT_MGR_T g_sdt_mgr;
20 : : static uint32_t g_dpp_dtb_int_enable;
21 : : static uint32_t g_table_type[ZXDH_DEV_CHANNEL_MAX][ZXDH_DEV_SDT_ID_MAX];
22 : : ZXDH_PPU_CLS_BITMAP_T g_ppu_cls_bit_map[ZXDH_DEV_CHANNEL_MAX];
23 : : ZXDH_DTB_MGR_T *p_dpp_dtb_mgr[ZXDH_DEV_CHANNEL_MAX];
24 : : ZXDH_RISCV_DTB_MGR *p_riscv_dtb_queue_mgr[ZXDH_DEV_CHANNEL_MAX];
25 : : ZXDH_TLB_MGR_T *g_p_dpp_tlb_mgr[ZXDH_DEV_CHANNEL_MAX];
26 : : ZXDH_REG_T g_dpp_reg_info[4];
27 : : ZXDH_DTB_TABLE_T g_dpp_dtb_table_info[4];
28 : : ZXDH_SDT_TBL_DATA_T g_sdt_info[ZXDH_DEV_CHANNEL_MAX][ZXDH_DEV_SDT_ID_MAX];
29 : : ZXDH_PPU_STAT_CFG_T g_ppu_stat_cfg;
30 : :
31 : : #define ZXDH_SDT_MGR_PTR_GET() (&g_sdt_mgr)
32 : : #define ZXDH_SDT_SOFT_TBL_GET(id) (g_sdt_mgr.sdt_tbl_array[id])
33 : :
34 : : #define ZXDH_COMM_MASK_BIT(_bitnum_)\
35 : : (0x1U << (_bitnum_))
36 : :
37 : : #define ZXDH_COMM_GET_BIT_MASK(_inttype_, _bitqnt_)\
38 : : ((_inttype_)(((_bitqnt_) < 32)))
39 : :
40 : : #define ZXDH_COMM_UINT32_GET_BITS(_uidst_, _uisrc_, _uistartpos_, _uilen_)\
41 : : ((_uidst_) = (((_uisrc_) >> (_uistartpos_)) & \
42 : : (ZXDH_COMM_GET_BIT_MASK(uint32_t, (_uilen_)))))
43 : :
44 : : #define ZXDH_REG_DATA_MAX (128)
45 : :
46 : : #define ZXDH_COMM_CHECK_DEV_POINT(dev_id, point)\
47 : : do {\
48 : : if (NULL == (point)) {\
49 : : PMD_DRV_LOG(ERR, "dev: %d ZXIC %s:%d[Error:POINT NULL] !"\
50 : : "FUNCTION : %s!", (dev_id), __FILE__, __LINE__, __func__);\
51 : : RTE_ASSERT(0);\
52 : : } \
53 : : } while (0)
54 : :
55 : : #define ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, becall)\
56 : : do {\
57 : : if ((rc) != 0) {\
58 : : PMD_DRV_LOG(ERR, "dev: %d ZXIC %s:%d !"\
59 : : "-- %s Call %s Fail!", (dev_id), __FILE__, __LINE__, __func__, becall);\
60 : : RTE_ASSERT(0);\
61 : : } \
62 : : } while (0)
63 : :
64 : : #define ZXDH_COMM_CHECK_POINT_NO_ASSERT(point)\
65 : : do {\
66 : : if ((point) == NULL) {\
67 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d[Error:POINT NULL] ! FUNCTION : %s!",\
68 : : __FILE__, __LINE__, __func__);\
69 : : } \
70 : : } while (0)
71 : :
72 : : #define ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, becall)\
73 : : do {\
74 : : if ((rc) != 0) {\
75 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d !-- %s Call %s"\
76 : : " Fail!", __FILE__, __LINE__, __func__, becall);\
77 : : } \
78 : : } while (0)
79 : :
80 : : #define ZXDH_COMM_CHECK_RC(rc, becall)\
81 : : do {\
82 : : if ((rc) != 0) {\
83 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d!-- %s Call %s "\
84 : : "Fail!", __FILE__, __LINE__, __func__, becall);\
85 : : RTE_ASSERT(0);\
86 : : } \
87 : : } while (0)
88 : :
89 : : #define ZXDH_COMM_CHECK_POINT(point)\
90 : : do {\
91 : : if ((point) == NULL) {\
92 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d[Error:POINT NULL] ! FUNCTION : %s!",\
93 : : __FILE__, __LINE__, __func__);\
94 : : RTE_ASSERT(0);\
95 : : } \
96 : : } while (0)
97 : :
98 : :
99 : : #define ZXDH_COMM_CHECK_POINT_MEMORY_FREE(point, ptr)\
100 : : do {\
101 : : if ((point) == NULL) {\
102 : : PMD_DRV_LOG(ERR, "ZXIC %s:%d[Error:POINT NULL] !"\
103 : : "FUNCTION : %s!", __FILE__, __LINE__, __func__);\
104 : : rte_free(ptr);\
105 : : RTE_ASSERT(0);\
106 : : } \
107 : : } while (0)
108 : :
109 : : #define ZXDH_COMM_CHECK_RC_MEMORY_FREE_NO_ASSERT(rc, becall, ptr)\
110 : : do {\
111 : : if ((rc) != 0) {\
112 : : PMD_DRV_LOG(ERR, "ZXICP %s:%d, %s Call"\
113 : : " %s Fail!", __FILE__, __LINE__, __func__, becall);\
114 : : rte_free(ptr);\
115 : : } \
116 : : } while (0)
117 : :
118 : : #define ZXDH_COMM_CONVERT16(w_data) \
119 : : (((w_data) & 0xff) << 8)
120 : :
121 : : #define ZXDH_DTB_TAB_UP_WR_INDEX_GET(DEV_ID, QUEUE_ID) \
122 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.wr_index)
123 : :
124 : : #define ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(DEV_ID, QUEUE_ID, INDEX) \
125 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.user_addr[(INDEX)].user_flag)
126 : :
127 : : #define ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
128 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.user_addr[(INDEX)].phy_addr)
129 : :
130 : : #define ZXDH_DTB_TAB_UP_DATA_LEN_GET(DEV_ID, QUEUE_ID, INDEX) \
131 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.data_len[(INDEX)])
132 : :
133 : : #define ZXDH_DTB_TAB_UP_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
134 : : ((INDEX) * p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_up.item_size)
135 : :
136 : : #define ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX) \
137 : : ((INDEX) * p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_down.item_size)
138 : :
139 : : #define ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(DEV_ID, QUEUE_ID) \
140 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].tab_down.wr_index)
141 : :
142 : : #define ZXDH_DTB_QUEUE_INIT_FLAG_GET(DEV_ID, QUEUE_ID) \
143 : : (p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].init_flag)
144 : :
145 : : static uint32_t
146 : : zxdh_np_comm_is_big_endian(void)
147 : : {
148 : : ZXDH_ENDIAN_U c_data;
149 : :
150 : : c_data.a = 1;
151 : :
152 : : if (c_data.b == 1)
153 : : return 0;
154 : : else
155 : : return 1;
156 : : }
157 : :
158 : : static void
159 : : zxdh_np_comm_swap(uint8_t *p_uc_data, uint32_t dw_byte_len)
160 : : {
161 : : uint16_t *p_w_tmp = NULL;
162 : : uint32_t *p_dw_tmp = NULL;
163 : : uint32_t dw_byte_num;
164 : : uint8_t uc_byte_mode;
165 : : uint32_t uc_is_big_flag;
166 : : uint32_t i;
167 : :
168 : : p_dw_tmp = (uint32_t *)(p_uc_data);
169 : : uc_is_big_flag = zxdh_np_comm_is_big_endian();
170 : : if (uc_is_big_flag)
171 : : return;
172 : :
173 : 0 : dw_byte_num = dw_byte_len >> 2;
174 : 0 : uc_byte_mode = dw_byte_len % 4 & 0xff;
175 : :
176 [ # # ]: 0 : for (i = 0; i < dw_byte_num; i++) {
177 : 0 : (*p_dw_tmp) = ZXDH_COMM_CONVERT16(*p_dw_tmp);
178 : 0 : p_dw_tmp++;
179 : : }
180 : :
181 [ # # ]: 0 : if (uc_byte_mode > 1) {
182 : : p_w_tmp = (uint16_t *)(p_dw_tmp);
183 : 0 : (*p_w_tmp) = ZXDH_COMM_CONVERT16(*p_w_tmp);
184 : : }
185 : : }
186 : :
187 : : static uint32_t
188 : 0 : zxdh_np_dev_init(void)
189 : : {
190 [ # # ]: 0 : if (g_dev_mgr.is_init) {
191 : 0 : PMD_DRV_LOG(ERR, "Dev is already initialized");
192 : 0 : return 0;
193 : : }
194 : :
195 : 0 : g_dev_mgr.device_num = 0;
196 : 0 : g_dev_mgr.is_init = 1;
197 : :
198 : 0 : return 0;
199 : : }
200 : :
201 : : static uint32_t
202 : 0 : zxdh_np_dev_add(uint32_t dev_id, ZXDH_DEV_TYPE_E dev_type,
203 : : ZXDH_DEV_ACCESS_TYPE_E access_type, uint64_t pcie_addr,
204 : : uint64_t riscv_addr, uint64_t dma_vir_addr,
205 : : uint64_t dma_phy_addr)
206 : : {
207 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
208 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
209 : :
210 : : p_dev_mgr = &g_dev_mgr;
211 [ # # ]: 0 : if (!p_dev_mgr->is_init) {
212 : 0 : PMD_DRV_LOG(ERR, "ErrorCode[ 0x%x]: Device Manager is not init",
213 : : ZXDH_RC_DEV_MGR_NOT_INIT);
214 : 0 : return ZXDH_RC_DEV_MGR_NOT_INIT;
215 : : }
216 : :
217 [ # # ]: 0 : if (p_dev_mgr->p_dev_array[dev_id] != NULL) {
218 : : /* device is already exist. */
219 : 0 : PMD_DRV_LOG(ERR, "Device is added again");
220 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
221 : : } else {
222 : : /* device is new. */
223 : 0 : p_dev_info = rte_malloc(NULL, sizeof(ZXDH_DEV_CFG_T), 0);
224 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dev_info);
225 : 0 : p_dev_mgr->p_dev_array[dev_id] = p_dev_info;
226 : 0 : p_dev_mgr->device_num++;
227 : : }
228 : :
229 : 0 : p_dev_info->device_id = dev_id;
230 : 0 : p_dev_info->dev_type = dev_type;
231 : 0 : p_dev_info->access_type = access_type;
232 : 0 : p_dev_info->pcie_addr = pcie_addr;
233 : 0 : p_dev_info->riscv_addr = riscv_addr;
234 : 0 : p_dev_info->dma_vir_addr = dma_vir_addr;
235 : 0 : p_dev_info->dma_phy_addr = dma_phy_addr;
236 : :
237 : 0 : return 0;
238 : : }
239 : :
240 : : static uint32_t
241 : : zxdh_np_dev_agent_status_set(uint32_t dev_id, uint32_t agent_flag)
242 : : {
243 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
244 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
245 : :
246 : : p_dev_mgr = &g_dev_mgr;
247 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
248 : :
249 [ # # ]: 0 : if (p_dev_info == NULL)
250 : : return ZXDH_DEV_TYPE_INVALID;
251 : 0 : p_dev_info->agent_flag = agent_flag;
252 : :
253 : : return 0;
254 : : }
255 : :
256 : : static void
257 : 0 : zxdh_np_sdt_mgr_init(void)
258 : : {
259 [ # # ]: 0 : if (!g_sdt_mgr.is_init) {
260 : 0 : g_sdt_mgr.channel_num = 0;
261 : 0 : g_sdt_mgr.is_init = 1;
262 : : memset(g_sdt_mgr.sdt_tbl_array, 0, ZXDH_DEV_CHANNEL_MAX *
263 : : sizeof(ZXDH_SDT_SOFT_TABLE_T *));
264 : : }
265 : 0 : }
266 : :
267 : : static uint32_t
268 : 0 : zxdh_np_sdt_mgr_create(uint32_t dev_id)
269 : : {
270 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_tbl_temp = NULL;
271 : : ZXDH_SDT_MGR_T *p_sdt_mgr = NULL;
272 : :
273 : : p_sdt_mgr = ZXDH_SDT_MGR_PTR_GET();
274 : :
275 [ # # ]: 0 : if (ZXDH_SDT_SOFT_TBL_GET(dev_id) == NULL) {
276 : 0 : p_sdt_tbl_temp = rte_malloc(NULL, sizeof(ZXDH_SDT_SOFT_TABLE_T), 0);
277 : :
278 : 0 : p_sdt_tbl_temp->device_id = dev_id;
279 : 0 : memset(p_sdt_tbl_temp->sdt_array, 0, ZXDH_DEV_SDT_ID_MAX * sizeof(ZXDH_SDT_ITEM_T));
280 : :
281 : 0 : ZXDH_SDT_SOFT_TBL_GET(dev_id) = p_sdt_tbl_temp;
282 : :
283 : 0 : p_sdt_mgr->channel_num++;
284 : : } else {
285 : 0 : PMD_DRV_LOG(ERR, "Error: %s for dev[%d]"
286 : : "is called repeatedly!", __func__, dev_id);
287 : 0 : return 1;
288 : : }
289 : :
290 : 0 : return 0;
291 : : }
292 : :
293 : : static uint32_t
294 : 0 : zxdh_np_sdt_init(uint32_t dev_num, uint32_t *dev_id_array)
295 : : {
296 : : uint32_t rc;
297 : : uint32_t i;
298 : :
299 : 0 : zxdh_np_sdt_mgr_init();
300 : :
301 [ # # ]: 0 : for (i = 0; i < dev_num; i++) {
302 : 0 : rc = zxdh_np_sdt_mgr_create(dev_id_array[i]);
303 [ # # ]: 0 : ZXDH_COMM_CHECK_RC(rc, "zxdh_sdt_mgr_create");
304 : : }
305 : :
306 : 0 : return rc;
307 : : }
308 : :
309 : : static void
310 : 0 : zxdh_np_ppu_parse_cls_bitmap(uint32_t dev_id,
311 : : uint32_t bitmap)
312 : : {
313 : : uint32_t cls_id;
314 : : uint32_t mem_id;
315 : : uint32_t cls_use;
316 : : uint32_t instr_mem;
317 : :
318 [ # # ]: 0 : for (cls_id = 0; cls_id < ZXDH_PPU_CLUSTER_NUM; cls_id++) {
319 : 0 : cls_use = (bitmap >> cls_id) & 0x1;
320 : 0 : g_ppu_cls_bit_map[dev_id].cls_use[cls_id] = cls_use;
321 : : }
322 : :
323 [ # # ]: 0 : for (mem_id = 0; mem_id < ZXDH_PPU_INSTR_MEM_NUM; mem_id++) {
324 : 0 : instr_mem = (bitmap >> (mem_id * 2)) & 0x3;
325 : 0 : g_ppu_cls_bit_map[dev_id].instr_mem[mem_id] = ((instr_mem > 0) ? 1 : 0);
326 : : }
327 : 0 : }
328 : :
329 : : static ZXDH_DTB_MGR_T *
330 : : zxdh_np_dtb_mgr_get(uint32_t dev_id)
331 : : {
332 : : if (dev_id >= ZXDH_DEV_CHANNEL_MAX)
333 : : return NULL;
334 : : else
335 : 0 : return p_dpp_dtb_mgr[dev_id];
336 : : }
337 : :
338 : : static uint32_t
339 : 0 : zxdh_np_dtb_soft_init(uint32_t dev_id)
340 : : {
341 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
342 : :
343 [ # # ]: 0 : if (dev_id >= ZXDH_DEV_CHANNEL_MAX)
344 : : return 1;
345 : :
346 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
347 [ # # ]: 0 : if (p_dtb_mgr == NULL) {
348 : 0 : p_dpp_dtb_mgr[dev_id] = rte_zmalloc(NULL, sizeof(ZXDH_DTB_MGR_T), 0);
349 : : p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
350 [ # # ]: 0 : if (p_dtb_mgr == NULL)
351 : 0 : return 1;
352 : : }
353 : :
354 : : return 0;
355 : : }
356 : :
357 : : static uint32_t
358 : 0 : zxdh_np_base_soft_init(uint32_t dev_id, ZXDH_SYS_INIT_CTRL_T *p_init_ctrl)
359 : : {
360 : 0 : uint32_t dev_id_array[ZXDH_DEV_CHANNEL_MAX] = {0};
361 : : uint32_t rt;
362 : : uint32_t access_type;
363 : : uint32_t agent_flag;
364 : :
365 : 0 : rt = zxdh_np_dev_init();
366 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_init");
367 : :
368 [ # # ]: 0 : if (p_init_ctrl->flags & ZXDH_INIT_FLAG_ACCESS_TYPE)
369 : : access_type = ZXDH_DEV_ACCESS_TYPE_RISCV;
370 : : else
371 : : access_type = ZXDH_DEV_ACCESS_TYPE_PCIE;
372 : :
373 [ # # ]: 0 : if (p_init_ctrl->flags & ZXDH_INIT_FLAG_AGENT_FLAG)
374 : : agent_flag = ZXDH_DEV_AGENT_ENABLE;
375 : : else
376 : : agent_flag = ZXDH_DEV_AGENT_DISABLE;
377 : :
378 : 0 : rt = zxdh_np_dev_add(dev_id,
379 : : p_init_ctrl->device_type,
380 : : access_type,
381 : : p_init_ctrl->pcie_vir_baddr,
382 : : p_init_ctrl->riscv_vir_baddr,
383 : : p_init_ctrl->dma_vir_baddr,
384 : : p_init_ctrl->dma_phy_baddr);
385 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_add");
386 : :
387 : : rt = zxdh_np_dev_agent_status_set(dev_id, agent_flag);
388 : 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dev_agent_status_set");
389 : :
390 : 0 : dev_id_array[0] = dev_id;
391 : 0 : rt = zxdh_np_sdt_init(1, dev_id_array);
392 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_sdt_init");
393 : :
394 : 0 : zxdh_np_ppu_parse_cls_bitmap(dev_id, ZXDH_PPU_CLS_ALL_START);
395 : :
396 : 0 : rt = zxdh_np_dtb_soft_init(dev_id);
397 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rt, "zxdh_dtb_soft_init");
398 : :
399 : 0 : return rt;
400 : : }
401 : :
402 : : static void
403 : : zxdh_np_dev_vport_set(uint32_t dev_id, uint32_t vport)
404 : : {
405 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
406 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
407 : :
408 : : p_dev_mgr = &g_dev_mgr;
409 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
410 : 0 : p_dev_info->vport = vport;
411 : : }
412 : :
413 : : static void
414 : : zxdh_np_dev_agent_addr_set(uint32_t dev_id, uint64_t agent_addr)
415 : : {
416 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
417 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
418 : :
419 : : p_dev_mgr = &g_dev_mgr;
420 : : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
421 : 0 : p_dev_info->agent_addr = agent_addr;
422 : : }
423 : :
424 : : static uint64_t
425 : : zxdh_np_addr_calc(uint64_t pcie_vir_baddr, uint32_t bar_offset)
426 : : {
427 : : uint64_t np_addr;
428 : :
429 : 0 : np_addr = ((pcie_vir_baddr + bar_offset) > ZXDH_PCIE_NP_MEM_SIZE)
430 : 0 : ? (pcie_vir_baddr + bar_offset - ZXDH_PCIE_NP_MEM_SIZE) : 0;
431 : 0 : g_np_bar_offset = bar_offset;
432 : :
433 : : return np_addr;
434 : : }
435 : :
436 : : int
437 : 0 : zxdh_np_host_init(uint32_t dev_id,
438 : : ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
439 : : {
440 : 0 : ZXDH_SYS_INIT_CTRL_T sys_init_ctrl = {0};
441 : : uint32_t rc;
442 : : uint64_t agent_addr;
443 : :
444 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT_NO_ASSERT(p_dev_init_ctrl);
445 : :
446 : 0 : sys_init_ctrl.flags = (ZXDH_DEV_ACCESS_TYPE_PCIE << 0) | (ZXDH_DEV_AGENT_ENABLE << 10);
447 : 0 : sys_init_ctrl.pcie_vir_baddr = zxdh_np_addr_calc(p_dev_init_ctrl->pcie_vir_addr,
448 : : p_dev_init_ctrl->np_bar_offset);
449 : 0 : sys_init_ctrl.device_type = ZXDH_DEV_TYPE_CHIP;
450 : 0 : rc = zxdh_np_base_soft_init(dev_id, &sys_init_ctrl);
451 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_base_soft_init");
452 : :
453 : 0 : zxdh_np_dev_vport_set(dev_id, p_dev_init_ctrl->vport);
454 : :
455 : 0 : agent_addr = ZXDH_PCIE_AGENT_ADDR_OFFSET + p_dev_init_ctrl->pcie_vir_addr;
456 : : zxdh_np_dev_agent_addr_set(dev_id, agent_addr);
457 : :
458 : 0 : return 0;
459 : : }
460 : :
461 : : static ZXDH_RISCV_DTB_MGR *
462 : : zxdh_np_riscv_dtb_queue_mgr_get(uint32_t dev_id)
463 : : {
464 : 0 : if (dev_id >= ZXDH_DEV_CHANNEL_MAX)
465 : : return NULL;
466 : : else
467 : 0 : return p_riscv_dtb_queue_mgr[dev_id];
468 : : }
469 : :
470 : : static uint32_t
471 [ # # ]: 0 : zxdh_np_riscv_dtb_mgr_queue_info_delete(uint32_t dev_id, uint32_t queue_id)
472 : : {
473 : : ZXDH_RISCV_DTB_MGR *p_riscv_dtb_mgr = NULL;
474 : :
475 : : p_riscv_dtb_mgr = zxdh_np_riscv_dtb_queue_mgr_get(dev_id);
476 [ # # ]: 0 : if (p_riscv_dtb_mgr == NULL)
477 : : return 1;
478 : :
479 : 0 : p_riscv_dtb_mgr->queue_alloc_count--;
480 : 0 : p_riscv_dtb_mgr->queue_user_info[queue_id].alloc_flag = 0;
481 : 0 : p_riscv_dtb_mgr->queue_user_info[queue_id].queue_id = 0xFF;
482 : 0 : p_riscv_dtb_mgr->queue_user_info[queue_id].vport = 0;
483 : 0 : memset(p_riscv_dtb_mgr->queue_user_info[queue_id].user_name, 0, ZXDH_PORT_NAME_MAX);
484 : :
485 : 0 : return 0;
486 : : }
487 : :
488 : : static uint32_t
489 : : zxdh_np_dev_get_dev_type(uint32_t dev_id)
490 : : {
491 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
492 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
493 : :
494 : : p_dev_mgr = &g_dev_mgr;
495 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
496 : :
497 [ # # ]: 0 : if (p_dev_info == NULL)
498 : : return 0xffff;
499 : :
500 : 0 : return p_dev_info->dev_type;
501 : : }
502 : :
503 : : static uint32_t
504 : 0 : zxdh_np_comm_read_bits(uint8_t *p_base, uint32_t base_size_bit,
505 : : uint32_t *p_data, uint32_t start_bit, uint32_t end_bit)
506 : : {
507 : : uint32_t start_byte_index;
508 : : uint32_t end_byte_index;
509 : : uint32_t byte_num;
510 : : uint32_t buffer_size;
511 : : uint32_t len;
512 : :
513 [ # # ]: 0 : if (0 != (base_size_bit % 8))
514 : : return 1;
515 : :
516 [ # # ]: 0 : if (start_bit > end_bit)
517 : : return 1;
518 : :
519 [ # # ]: 0 : if (base_size_bit < end_bit)
520 : : return 1;
521 : :
522 : 0 : len = end_bit - start_bit + 1;
523 : 0 : buffer_size = base_size_bit / 8;
524 [ # # ]: 0 : while (0 != (buffer_size & (buffer_size - 1)))
525 : 0 : buffer_size += 1;
526 : :
527 : 0 : *p_data = 0;
528 : 0 : end_byte_index = (end_bit >> 3);
529 : 0 : start_byte_index = (start_bit >> 3);
530 : :
531 [ # # ]: 0 : if (start_byte_index == end_byte_index) {
532 : 0 : *p_data = (uint32_t)(((p_base[start_byte_index] >> (7U - (end_bit & 7)))
533 : 0 : & (0xff >> (8U - len))) & 0xff);
534 : 0 : return 0;
535 : : }
536 : :
537 [ # # ]: 0 : if (start_bit & 7) {
538 : 0 : *p_data = (p_base[start_byte_index] & (0xff >> (start_bit & 7))) & UINT8_MAX;
539 : 0 : start_byte_index++;
540 : : }
541 : :
542 [ # # ]: 0 : for (byte_num = start_byte_index; byte_num < end_byte_index; byte_num++) {
543 : 0 : *p_data <<= 8;
544 : 0 : *p_data += p_base[byte_num];
545 : : }
546 : :
547 : 0 : *p_data <<= 1 + (end_bit & 7);
548 : 0 : *p_data += ((p_base[byte_num & (buffer_size - 1)] & (0xff << (7 - (end_bit & 7)))) >>
549 : 0 : (7 - (end_bit & 7))) & 0xff;
550 : :
551 : 0 : return 0;
552 : : }
553 : :
554 : : static uint32_t
555 : : zxdh_np_comm_read_bits_ex(uint8_t *p_base, uint32_t base_size_bit,
556 : : uint32_t *p_data, uint32_t msb_start_pos, uint32_t len)
557 : : {
558 : : uint32_t rtn;
559 : :
560 : 0 : rtn = zxdh_np_comm_read_bits(p_base,
561 : : base_size_bit,
562 : : p_data,
563 : : (base_size_bit - 1 - msb_start_pos),
564 : 0 : (base_size_bit - 1 - msb_start_pos + len - 1));
565 : : return rtn;
566 : : }
567 : :
568 : : static uint32_t
569 : 0 : zxdh_np_reg_read(uint32_t dev_id, uint32_t reg_no,
570 : : uint32_t m_offset, uint32_t n_offset, void *p_data)
571 : : {
572 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
573 : : ZXDH_REG_T *p_reg_info = NULL;
574 : : ZXDH_FIELD_T *p_field_info = NULL;
575 : : uint32_t rc = 0;
576 : : uint32_t i;
577 : :
578 [ # # ]: 0 : if (reg_no < 4) {
579 : : p_reg_info = &g_dpp_reg_info[reg_no];
580 : 0 : p_field_info = p_reg_info->p_fields;
581 [ # # ]: 0 : for (i = 0; i < p_reg_info->field_num; i++) {
582 : 0 : rc = zxdh_np_comm_read_bits_ex((uint8_t *)p_buff,
583 : 0 : p_reg_info->width * 8,
584 : 0 : (uint32_t *)p_data + i,
585 : 0 : p_field_info[i].msb_pos,
586 : 0 : p_field_info[i].len);
587 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxic_comm_read_bits_ex");
588 : 0 : PMD_DRV_LOG(ERR, "dev_id %d(%d)(%d)is ok!", dev_id, m_offset, n_offset);
589 : : }
590 : : }
591 : 0 : return rc;
592 : : }
593 : :
594 : : static uint32_t
595 : 0 : zxdh_np_dtb_queue_vm_info_get(uint32_t dev_id,
596 : : uint32_t queue_id,
597 : : ZXDH_DTB_QUEUE_VM_INFO_T *p_vm_info)
598 : : {
599 : 0 : ZXDH_DTB4K_DTB_ENQ_CFG_EPID_V_FUNC_NUM_0_127_T vm_info = {0};
600 : : uint32_t rc;
601 : :
602 : 0 : rc = zxdh_np_reg_read(dev_id, ZXDH_DTB_CFG_EPID_V_FUNC_NUM,
603 : : 0, queue_id, &vm_info);
604 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_reg_read");
605 : :
606 : 0 : p_vm_info->dbi_en = vm_info.dbi_en;
607 : 0 : p_vm_info->queue_en = vm_info.queue_en;
608 : 0 : p_vm_info->epid = vm_info.cfg_epid;
609 : 0 : p_vm_info->vector = vm_info.cfg_vector;
610 : 0 : p_vm_info->vfunc_num = vm_info.cfg_vfunc_num;
611 : 0 : p_vm_info->func_num = vm_info.cfg_func_num;
612 : 0 : p_vm_info->vfunc_active = vm_info.cfg_vfunc_active;
613 : :
614 : 0 : return rc;
615 : : }
616 : :
617 : : static uint32_t
618 : 0 : zxdh_np_comm_write_bits(uint8_t *p_base, uint32_t base_size_bit,
619 : : uint32_t data, uint32_t start_bit, uint32_t end_bit)
620 : : {
621 : : uint32_t start_byte_index;
622 : : uint32_t end_byte_index;
623 : : uint8_t mask_value;
624 : : uint32_t byte_num;
625 : : uint32_t buffer_size;
626 : :
627 [ # # ]: 0 : if (0 != (base_size_bit % 8))
628 : : return 1;
629 : :
630 [ # # ]: 0 : if (start_bit > end_bit)
631 : : return 1;
632 : :
633 [ # # ]: 0 : if (base_size_bit < end_bit)
634 : : return 1;
635 : :
636 : 0 : buffer_size = base_size_bit / 8;
637 : :
638 [ # # ]: 0 : while (0 != (buffer_size & (buffer_size - 1)))
639 : 0 : buffer_size += 1;
640 : :
641 : 0 : end_byte_index = (end_bit >> 3);
642 : 0 : start_byte_index = (start_bit >> 3);
643 : :
644 [ # # ]: 0 : if (start_byte_index == end_byte_index) {
645 : 0 : mask_value = ((0xFE << (7 - (start_bit & 7))) & 0xff);
646 : 0 : mask_value |= (((1 << (7 - (end_bit & 7))) - 1) & 0xff);
647 : 0 : p_base[end_byte_index] &= mask_value;
648 : 0 : p_base[end_byte_index] |= (((data << (7 - (end_bit & 7)))) & 0xff);
649 : 0 : return 0;
650 : : }
651 : :
652 [ # # ]: 0 : if (7 != (end_bit & 7)) {
653 : 0 : mask_value = ((0x7f >> (end_bit & 7)) & 0xff);
654 : 0 : p_base[end_byte_index] &= mask_value;
655 : 0 : p_base[end_byte_index] |= ((data << (7 - (end_bit & 7))) & 0xff);
656 : 0 : end_byte_index--;
657 : 0 : data >>= 1 + (end_bit & 7);
658 : : }
659 : :
660 [ # # ]: 0 : for (byte_num = end_byte_index; byte_num > start_byte_index; byte_num--) {
661 : 0 : p_base[byte_num & (buffer_size - 1)] = data & 0xff;
662 : 0 : data >>= 8;
663 : : }
664 : :
665 : 0 : mask_value = ((0xFE << (7 - (start_bit & 7))) & 0xff);
666 : 0 : p_base[byte_num] &= mask_value;
667 : 0 : p_base[byte_num] |= data;
668 : :
669 : 0 : return 0;
670 : : }
671 : :
672 : : static uint32_t
673 : : zxdh_np_comm_write_bits_ex(uint8_t *p_base,
674 : : uint32_t base_size_bit,
675 : : uint32_t data,
676 : : uint32_t msb_start_pos,
677 : : uint32_t len)
678 : : {
679 : : uint32_t rtn;
680 : :
681 : 0 : rtn = zxdh_np_comm_write_bits(p_base,
682 : : base_size_bit,
683 : : data,
684 : : (base_size_bit - 1 - msb_start_pos),
685 : 0 : (base_size_bit - 1 - msb_start_pos + len - 1));
686 : :
687 : : return rtn;
688 : : }
689 : :
690 : : static uint32_t
691 : 0 : zxdh_np_reg_write(uint32_t dev_id, uint32_t reg_no,
692 : : uint32_t m_offset, uint32_t n_offset, void *p_data)
693 : : {
694 : 0 : uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
695 : : ZXDH_REG_T *p_reg_info = NULL;
696 : : ZXDH_FIELD_T *p_field_info = NULL;
697 : : uint32_t temp_data;
698 : : uint32_t rc;
699 : : uint32_t i;
700 : :
701 [ # # ]: 0 : if (reg_no < 4) {
702 : : p_reg_info = &g_dpp_reg_info[reg_no];
703 : 0 : p_field_info = p_reg_info->p_fields;
704 : :
705 [ # # ]: 0 : for (i = 0; i < p_reg_info->field_num; i++) {
706 [ # # ]: 0 : if (p_field_info[i].len <= 32) {
707 : 0 : temp_data = *((uint32_t *)p_data + i);
708 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_buff,
709 : 0 : p_reg_info->width * 8,
710 : : temp_data,
711 : 0 : p_field_info[i].msb_pos,
712 : : p_field_info[i].len);
713 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_comm_write_bits_ex");
714 : 0 : PMD_DRV_LOG(ERR, "dev_id %d(%d)(%d)is ok!",
715 : : dev_id, m_offset, n_offset);
716 : : }
717 : : }
718 : : }
719 : :
720 : 0 : return 0;
721 : : }
722 : :
723 : : static uint32_t
724 : 0 : zxdh_np_dtb_queue_vm_info_set(uint32_t dev_id,
725 : : uint32_t queue_id,
726 : : ZXDH_DTB_QUEUE_VM_INFO_T *p_vm_info)
727 : : {
728 : : uint32_t rc = 0;
729 : : ZXDH_DTB4K_DTB_ENQ_CFG_EPID_V_FUNC_NUM_0_127_T vm_info = {0};
730 : :
731 : 0 : vm_info.dbi_en = p_vm_info->dbi_en;
732 : 0 : vm_info.queue_en = p_vm_info->queue_en;
733 : 0 : vm_info.cfg_epid = p_vm_info->epid;
734 : 0 : vm_info.cfg_vector = p_vm_info->vector;
735 : 0 : vm_info.cfg_vfunc_num = p_vm_info->vfunc_num;
736 : 0 : vm_info.cfg_func_num = p_vm_info->func_num;
737 : 0 : vm_info.cfg_vfunc_active = p_vm_info->vfunc_active;
738 : :
739 : 0 : rc = zxdh_np_reg_write(dev_id, ZXDH_DTB_CFG_EPID_V_FUNC_NUM,
740 : : 0, queue_id, &vm_info);
741 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_reg_write");
742 : :
743 : 0 : return rc;
744 : : }
745 : :
746 : : static uint32_t
747 : 0 : zxdh_np_dtb_queue_enable_set(uint32_t dev_id,
748 : : uint32_t queue_id,
749 : : uint32_t enable)
750 : : {
751 : 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
752 : : uint32_t rc;
753 : :
754 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
755 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_vm_info_get");
756 : :
757 : 0 : vm_info.queue_en = enable;
758 : 0 : rc = zxdh_np_dtb_queue_vm_info_set(dev_id, queue_id, &vm_info);
759 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_vm_info_set");
760 : :
761 : 0 : return rc;
762 : : }
763 : :
764 : : static uint32_t
765 [ # # ]: 0 : zxdh_np_riscv_dpp_dtb_queue_id_release(uint32_t dev_id,
766 : : char name[ZXDH_PORT_NAME_MAX], uint32_t queue_id)
767 : : {
768 : : ZXDH_RISCV_DTB_MGR *p_riscv_dtb_mgr = NULL;
769 : :
770 : : p_riscv_dtb_mgr = zxdh_np_riscv_dtb_queue_mgr_get(dev_id);
771 [ # # ]: 0 : if (p_riscv_dtb_mgr == NULL)
772 : : return 1;
773 : :
774 [ # # ]: 0 : if (zxdh_np_dev_get_dev_type(dev_id) == ZXDH_DEV_TYPE_SIM)
775 : : return 0;
776 : :
777 [ # # ]: 0 : if (p_riscv_dtb_mgr->queue_user_info[queue_id].alloc_flag != 1) {
778 : 0 : PMD_DRV_LOG(ERR, "queue %d not alloc!", queue_id);
779 : 0 : return 2;
780 : : }
781 : :
782 [ # # ]: 0 : if (strcmp(p_riscv_dtb_mgr->queue_user_info[queue_id].user_name, name) != 0) {
783 : 0 : PMD_DRV_LOG(ERR, "queue %d name %s error!", queue_id, name);
784 : 0 : return 3;
785 : : }
786 : 0 : zxdh_np_dtb_queue_enable_set(dev_id, queue_id, 0);
787 : 0 : zxdh_np_riscv_dtb_mgr_queue_info_delete(dev_id, queue_id);
788 : :
789 : 0 : return 0;
790 : : }
791 : :
792 : : static uint32_t
793 [ # # ]: 0 : zxdh_np_dtb_queue_unused_item_num_get(uint32_t dev_id,
794 : : uint32_t queue_id,
795 : : uint32_t *p_item_num)
796 : : {
797 : : uint32_t rc;
798 : :
799 [ # # ]: 0 : if (zxdh_np_dev_get_dev_type(dev_id) == ZXDH_DEV_TYPE_SIM) {
800 : 0 : *p_item_num = 32;
801 : 0 : return 0;
802 : : }
803 : :
804 : 0 : rc = zxdh_np_reg_read(dev_id, ZXDH_DTB_INFO_QUEUE_BUF_SPACE,
805 : : 0, queue_id, p_item_num);
806 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_reg_read");
807 : : return rc;
808 : : }
809 : :
810 : : static uint32_t
811 : 0 : zxdh_np_dtb_queue_id_free(uint32_t dev_id,
812 : : uint32_t queue_id)
813 : : {
814 : 0 : uint32_t item_num = 0;
815 : : ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
816 : : uint32_t rc;
817 : :
818 : 0 : p_dtb_mgr = p_dpp_dtb_mgr[dev_id];
819 [ # # ]: 0 : if (p_dtb_mgr == NULL)
820 : : return 1;
821 : :
822 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &item_num);
823 : :
824 : 0 : p_dtb_mgr->queue_info[queue_id].init_flag = 0;
825 : 0 : p_dtb_mgr->queue_info[queue_id].vport = 0;
826 : 0 : p_dtb_mgr->queue_info[queue_id].vector = 0;
827 : :
828 : 0 : return rc;
829 : : }
830 : :
831 : : static uint32_t
832 : 0 : zxdh_np_dtb_queue_release(uint32_t devid,
833 : : char pname[32],
834 : : uint32_t queueid)
835 : : {
836 : : uint32_t rc;
837 : :
838 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(devid, pname);
839 : :
840 : 0 : rc = zxdh_np_riscv_dpp_dtb_queue_id_release(devid, pname, queueid);
841 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_riscv_dpp_dtb_queue_id_release");
842 : :
843 : 0 : rc = zxdh_np_dtb_queue_id_free(devid, queueid);
844 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_id_free");
845 : :
846 : 0 : return rc;
847 : : }
848 : :
849 : : static void
850 : : zxdh_np_dtb_mgr_destroy(uint32_t dev_id)
851 : : {
852 [ # # ]: 0 : if (p_dpp_dtb_mgr[dev_id] != NULL) {
853 : 0 : free(p_dpp_dtb_mgr[dev_id]);
854 : 0 : p_dpp_dtb_mgr[dev_id] = NULL;
855 : : }
856 : : }
857 : :
858 : : static void
859 : : zxdh_np_tlb_mgr_destroy(uint32_t dev_id)
860 : : {
861 [ # # ]: 0 : if (g_p_dpp_tlb_mgr[dev_id] != NULL) {
862 : 0 : free(g_p_dpp_tlb_mgr[dev_id]);
863 : 0 : g_p_dpp_tlb_mgr[dev_id] = NULL;
864 : : }
865 : : }
866 : :
867 : : static void
868 : 0 : zxdh_np_sdt_mgr_destroy(uint32_t dev_id)
869 : : {
870 : : ZXDH_SDT_SOFT_TABLE_T *p_sdt_tbl_temp = NULL;
871 : : ZXDH_SDT_MGR_T *p_sdt_mgr = NULL;
872 : :
873 : 0 : p_sdt_tbl_temp = ZXDH_SDT_SOFT_TBL_GET(dev_id);
874 : : p_sdt_mgr = ZXDH_SDT_MGR_PTR_GET();
875 : :
876 [ # # ]: 0 : if (p_sdt_tbl_temp != NULL)
877 : 0 : free(p_sdt_tbl_temp);
878 : :
879 : 0 : ZXDH_SDT_SOFT_TBL_GET(dev_id) = NULL;
880 : :
881 : 0 : p_sdt_mgr->channel_num--;
882 : 0 : }
883 : :
884 : : static void
885 : 0 : zxdh_np_dev_del(uint32_t dev_id)
886 : : {
887 : : ZXDH_DEV_CFG_T *p_dev_info = NULL;
888 : : ZXDH_DEV_MGR_T *p_dev_mgr = NULL;
889 : :
890 : : p_dev_mgr = &g_dev_mgr;
891 : 0 : p_dev_info = p_dev_mgr->p_dev_array[dev_id];
892 : :
893 [ # # ]: 0 : if (p_dev_info != NULL) {
894 : 0 : free(p_dev_info);
895 : 0 : p_dev_mgr->p_dev_array[dev_id] = NULL;
896 : 0 : p_dev_mgr->device_num--;
897 : : }
898 : 0 : }
899 : :
900 : : int
901 : 0 : zxdh_np_online_uninit(uint32_t dev_id,
902 : : char *port_name,
903 : : uint32_t queue_id)
904 : : {
905 : : uint32_t rc;
906 : :
907 : 0 : rc = zxdh_np_dtb_queue_release(dev_id, port_name, queue_id);
908 [ # # ]: 0 : if (rc != 0)
909 : 0 : PMD_DRV_LOG(ERR, "%s:dtb release error,"
910 : : "port name %s queue id %d", __func__, port_name, queue_id);
911 : :
912 : : zxdh_np_dtb_mgr_destroy(dev_id);
913 : : zxdh_np_tlb_mgr_destroy(dev_id);
914 : 0 : zxdh_np_sdt_mgr_destroy(dev_id);
915 : 0 : zxdh_np_dev_del(dev_id);
916 : :
917 : 0 : return 0;
918 : : }
919 : :
920 : : static uint32_t
921 : : zxdh_np_sdt_tbl_type_get(uint32_t dev_id, uint32_t sdt_no)
922 : : {
923 : 0 : return g_table_type[dev_id][sdt_no];
924 : : }
925 : :
926 : :
927 : : static ZXDH_DTB_TABLE_T *
928 : : zxdh_np_table_info_get(uint32_t table_type)
929 : : {
930 : : return &g_dpp_dtb_table_info[table_type];
931 : : }
932 : :
933 : : static uint32_t
934 : 0 : zxdh_np_dtb_write_table_cmd(uint32_t dev_id,
935 : : ZXDH_DTB_TABLE_INFO_E table_type,
936 : : void *p_cmd_data,
937 : : void *p_cmd_buff)
938 : : {
939 : : uint32_t field_cnt;
940 : : ZXDH_DTB_TABLE_T *p_table_info = NULL;
941 : : ZXDH_DTB_FIELD_T *p_field_info = NULL;
942 : : uint32_t temp_data;
943 : : uint32_t rc;
944 : :
945 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_data);
946 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_cmd_buff);
947 : : p_table_info = zxdh_np_table_info_get(table_type);
948 : 0 : p_field_info = p_table_info->p_fields;
949 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_table_info);
950 : :
951 [ # # ]: 0 : for (field_cnt = 0; field_cnt < p_table_info->field_num; field_cnt++) {
952 : 0 : temp_data = *((uint32_t *)p_cmd_data + field_cnt) & ZXDH_COMM_GET_BIT_MASK(uint32_t,
953 : : p_field_info[field_cnt].len);
954 : :
955 : 0 : rc = zxdh_np_comm_write_bits_ex((uint8_t *)p_cmd_buff,
956 : : ZXDH_DTB_TABLE_CMD_SIZE_BIT,
957 : : temp_data,
958 : 0 : p_field_info[field_cnt].lsb_pos,
959 : : p_field_info[field_cnt].len);
960 : :
961 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxic_comm_write_bits");
962 : : }
963 : :
964 : 0 : return rc;
965 : : }
966 : :
967 : : static uint32_t
968 : 0 : zxdh_np_dtb_smmu0_write_entry_data(uint32_t dev_id,
969 : : uint32_t mode,
970 : : uint32_t addr,
971 : : uint32_t *p_data,
972 : : ZXDH_DTB_ENTRY_T *p_entry)
973 : : {
974 : 0 : ZXDH_DTB_ERAM_TABLE_FORM_T dtb_eram_form_info = {0};
975 : : uint32_t rc = 0;
976 : :
977 : 0 : dtb_eram_form_info.valid = ZXDH_DTB_TABLE_VALID;
978 : : dtb_eram_form_info.type_mode = ZXDH_DTB_TABLE_MODE_ERAM;
979 : 0 : dtb_eram_form_info.data_mode = mode;
980 : 0 : dtb_eram_form_info.cpu_wr = 1;
981 : 0 : dtb_eram_form_info.addr = addr;
982 : : dtb_eram_form_info.cpu_rd = 0;
983 : : dtb_eram_form_info.cpu_rd_mode = 0;
984 : :
985 [ # # ]: 0 : if (ZXDH_ERAM128_OPR_128b == mode) {
986 : 0 : p_entry->data_in_cmd_flag = 0;
987 : 0 : p_entry->data_size = 128 / 8;
988 : :
989 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_128,
990 : 0 : &dtb_eram_form_info, p_entry->cmd);
991 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
992 : :
993 : 0 : memcpy(p_entry->data, p_data, 128 / 8);
994 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_64b == mode) {
995 : 0 : p_entry->data_in_cmd_flag = 1;
996 : 0 : p_entry->data_size = 64 / 8;
997 : 0 : dtb_eram_form_info.data_l = *(p_data + 1);
998 : 0 : dtb_eram_form_info.data_h = *(p_data);
999 : :
1000 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_64,
1001 : 0 : &dtb_eram_form_info, p_entry->cmd);
1002 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
1003 : :
1004 [ # # ]: 0 : } else if (ZXDH_ERAM128_OPR_1b == mode) {
1005 : 0 : p_entry->data_in_cmd_flag = 1;
1006 : 0 : p_entry->data_size = 1;
1007 : 0 : dtb_eram_form_info.data_h = *(p_data);
1008 : :
1009 : 0 : rc = zxdh_np_dtb_write_table_cmd(dev_id, ZXDH_DTB_TABLE_ERAM_1,
1010 : 0 : &dtb_eram_form_info, p_entry->cmd);
1011 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_table_cmd");
1012 : : }
1013 : :
1014 : 0 : return rc;
1015 : : }
1016 : :
1017 : : static uint32_t
1018 : 0 : zxdh_np_dtb_se_smmu0_ind_write(uint32_t dev_id,
1019 : : uint32_t base_addr,
1020 : : uint32_t index,
1021 : : uint32_t wrt_mode,
1022 : : uint32_t *p_data,
1023 : : ZXDH_DTB_ENTRY_T *p_entry)
1024 : : {
1025 : : uint32_t temp_idx;
1026 : : uint32_t dtb_ind_addr;
1027 : : uint32_t rc;
1028 : :
1029 [ # # # # ]: 0 : switch (wrt_mode) {
1030 : 0 : case ZXDH_ERAM128_OPR_128b:
1031 : : {
1032 [ # # ]: 0 : if ((0xFFFFFFFF - (base_addr)) < (index)) {
1033 : 0 : PMD_DRV_LOG(ERR, "ICM %s:%d[Error:VALUE[val0=0x%x]"
1034 : : "INVALID] [val1=0x%x] FUNCTION :%s", __FILE__, __LINE__,
1035 : : base_addr, index, __func__);
1036 : :
1037 : 0 : return ZXDH_PAR_CHK_INVALID_INDEX;
1038 : : }
1039 [ # # ]: 0 : if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
1040 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
1041 : 0 : return 1;
1042 : : }
1043 : 0 : temp_idx = index << 7;
1044 : 0 : break;
1045 : : }
1046 : :
1047 : 0 : case ZXDH_ERAM128_OPR_64b:
1048 : : {
1049 [ # # ]: 0 : if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
1050 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
1051 : 0 : return 1;
1052 : : }
1053 : 0 : temp_idx = index << 6;
1054 : 0 : break;
1055 : : }
1056 : :
1057 : 0 : case ZXDH_ERAM128_OPR_1b:
1058 : : {
1059 [ # # ]: 0 : if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
1060 : 0 : PMD_DRV_LOG(ERR, "dpp_se_smmu0_ind_write : index out of range");
1061 : 0 : return 1;
1062 : : }
1063 : :
1064 : : temp_idx = index;
1065 : : }
1066 : : }
1067 : :
1068 : 0 : dtb_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + temp_idx;
1069 : :
1070 : 0 : PMD_DRV_LOG(INFO, "dtb eram item 1bit addr: 0x%x", dtb_ind_addr);
1071 : :
1072 : 0 : rc = zxdh_np_dtb_smmu0_write_entry_data(dev_id,
1073 : : wrt_mode,
1074 : : dtb_ind_addr,
1075 : : p_data,
1076 : : p_entry);
1077 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_smmu0_write_entry_data");
1078 : :
1079 : : return rc;
1080 : : }
1081 : :
1082 : : static uint32_t
1083 : : zxdh_np_eram_dtb_len_get(uint32_t mode)
1084 : : {
1085 : : uint32_t dtb_len = 0;
1086 : :
1087 : : switch (mode) {
1088 : : case ZXDH_ERAM128_OPR_128b:
1089 : : {
1090 : : dtb_len += 2;
1091 : : break;
1092 : : }
1093 : : case ZXDH_ERAM128_OPR_64b:
1094 : : case ZXDH_ERAM128_OPR_1b:
1095 : : {
1096 : : dtb_len += 1;
1097 : : break;
1098 : : }
1099 : : default:
1100 : : break;
1101 : : }
1102 : :
1103 : : return dtb_len;
1104 : : }
1105 : :
1106 : : static uint32_t
1107 : 0 : zxdh_np_dtb_eram_one_entry(uint32_t dev_id,
1108 : : uint32_t sdt_no,
1109 : : uint32_t del_en,
1110 : : void *pdata,
1111 : : uint32_t *p_dtb_len,
1112 : : ZXDH_DTB_ENTRY_T *p_dtb_one_entry)
1113 : : {
1114 : 0 : uint32_t buff[ZXDH_SMMU0_READ_REG_MAX_NUM] = {0};
1115 : : ZXDH_SDTTBL_ERAM_T sdt_eram = {0};
1116 : : ZXDH_DTB_ERAM_ENTRY_INFO_T *peramdata = NULL;
1117 : : uint32_t base_addr;
1118 : : uint32_t index;
1119 : : uint32_t opr_mode;
1120 : : uint32_t rc;
1121 : :
1122 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(pdata);
1123 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_one_entry);
1124 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dtb_len);
1125 : :
1126 : : peramdata = (ZXDH_DTB_ERAM_ENTRY_INFO_T *)pdata;
1127 : 0 : index = peramdata->index;
1128 : : base_addr = sdt_eram.eram_base_addr;
1129 : : opr_mode = sdt_eram.eram_mode;
1130 : :
1131 : : switch (opr_mode) {
1132 : : case ZXDH_ERAM128_TBL_128b:
1133 : : {
1134 : : opr_mode = ZXDH_ERAM128_OPR_128b;
1135 : : break;
1136 : : }
1137 : : case ZXDH_ERAM128_TBL_64b:
1138 : : {
1139 : : opr_mode = ZXDH_ERAM128_OPR_64b;
1140 : : break;
1141 : : }
1142 : :
1143 : : case ZXDH_ERAM128_TBL_1b:
1144 : : {
1145 : : opr_mode = ZXDH_ERAM128_OPR_1b;
1146 : : break;
1147 : : }
1148 : : }
1149 : :
1150 [ # # ]: 0 : if (del_en) {
1151 : : memset((uint8_t *)buff, 0, sizeof(buff));
1152 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
1153 : : base_addr,
1154 : : index,
1155 : : opr_mode,
1156 : : buff,
1157 : : p_dtb_one_entry);
1158 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(sdt_no, rc, "zxdh_dtb_se_smmu0_ind_write");
1159 : : } else {
1160 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_write(dev_id,
1161 : : base_addr,
1162 : : index,
1163 : : opr_mode,
1164 : : peramdata->p_data,
1165 : : p_dtb_one_entry);
1166 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_dtb_se_smmu0_ind_write");
1167 : : }
1168 : 0 : *p_dtb_len = zxdh_np_eram_dtb_len_get(opr_mode);
1169 : :
1170 : 0 : return rc;
1171 : : }
1172 : :
1173 : : static uint32_t
1174 : 0 : zxdh_np_dtb_data_write(uint8_t *p_data_buff,
1175 : : uint32_t addr_offset,
1176 : : ZXDH_DTB_ENTRY_T *entry)
1177 : : {
1178 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
1179 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(entry);
1180 : :
1181 : 0 : uint8_t *p_cmd = p_data_buff + addr_offset;
1182 : : uint32_t cmd_size = ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8;
1183 : :
1184 : 0 : uint8_t *p_data = p_cmd + cmd_size;
1185 : 0 : uint32_t data_size = entry->data_size;
1186 : :
1187 : 0 : uint8_t *cmd = (uint8_t *)entry->cmd;
1188 [ # # ]: 0 : uint8_t *data = (uint8_t *)entry->data;
1189 : :
1190 : : rte_memcpy(p_cmd, cmd, cmd_size);
1191 : :
1192 [ # # ]: 0 : if (!entry->data_in_cmd_flag) {
1193 : : zxdh_np_comm_swap(data, data_size);
1194 [ # # ]: 0 : rte_memcpy(p_data, data, data_size);
1195 : : }
1196 : :
1197 : 0 : return 0;
1198 : : }
1199 : :
1200 : : static uint32_t
1201 : 0 : zxdh_np_dtb_queue_enable_get(uint32_t dev_id,
1202 : : uint32_t queue_id,
1203 : : uint32_t *enable)
1204 : : {
1205 : : uint32_t rc = 0;
1206 : 0 : ZXDH_DTB_QUEUE_VM_INFO_T vm_info = {0};
1207 : :
1208 : 0 : rc = zxdh_np_dtb_queue_vm_info_get(dev_id, queue_id, &vm_info);
1209 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_dtb_queue_vm_info_get");
1210 : :
1211 : 0 : *enable = vm_info.queue_en;
1212 : 0 : return rc;
1213 : : }
1214 : :
1215 : : static uint32_t
1216 : : zxdh_np_dtb_item_buff_wr(uint32_t dev_id,
1217 : : uint32_t queue_id,
1218 : : uint32_t dir_flag,
1219 : : uint32_t index,
1220 : : uint32_t pos,
1221 : : uint32_t len,
1222 : : uint32_t *p_data)
1223 : : {
1224 : : uint64_t addr;
1225 : :
1226 : : if (dir_flag == 1)
1227 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) +
1228 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
1229 : : else
1230 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) +
1231 : 0 : ZXDH_DTB_ITEM_ACK_SIZE + pos * 4;
1232 : :
1233 [ # # ]: 0 : memcpy((uint8_t *)(addr), p_data, len * 4);
1234 : :
1235 : : return 0;
1236 : : }
1237 : :
1238 : : static uint32_t
1239 : : zxdh_np_dtb_item_ack_rd(uint32_t dev_id,
1240 : : uint32_t queue_id,
1241 : : uint32_t dir_flag,
1242 : : uint32_t index,
1243 : : uint32_t pos,
1244 : : uint32_t *p_data)
1245 : : {
1246 : : uint64_t addr;
1247 : : uint32_t val;
1248 : :
1249 : : if (dir_flag == 1)
1250 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
1251 : : else
1252 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
1253 : :
1254 : 0 : val = *((volatile uint32_t *)(addr));
1255 : :
1256 : : *p_data = val;
1257 : :
1258 : : return 0;
1259 : : }
1260 : :
1261 : : static uint32_t
1262 : : zxdh_np_dtb_item_ack_wr(uint32_t dev_id,
1263 : : uint32_t queue_id,
1264 : : uint32_t dir_flag,
1265 : : uint32_t index,
1266 : : uint32_t pos,
1267 : : uint32_t data)
1268 : : {
1269 : : uint64_t addr;
1270 : :
1271 : : if (dir_flag == 1)
1272 : 0 : addr = ZXDH_DTB_TAB_UP_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
1273 : : else
1274 : 0 : addr = ZXDH_DTB_TAB_DOWN_VIR_ADDR_GET(dev_id, queue_id, index) + pos * 4;
1275 : :
1276 : 0 : *((volatile uint32_t *)(addr)) = data;
1277 : :
1278 : 0 : return 0;
1279 : : }
1280 : :
1281 : : static uint32_t
1282 : 0 : zxdh_np_dtb_queue_item_info_set(uint32_t dev_id,
1283 : : uint32_t queue_id,
1284 : : ZXDH_DTB_QUEUE_ITEM_INFO_T *p_item_info)
1285 : : {
1286 : : ZXDH_DTB_QUEUE_LEN_T dtb_len = {0};
1287 : : uint32_t rc;
1288 : :
1289 : 0 : dtb_len.cfg_dtb_cmd_type = p_item_info->cmd_type;
1290 : 0 : dtb_len.cfg_dtb_cmd_int_en = p_item_info->int_en;
1291 : 0 : dtb_len.cfg_queue_dtb_len = p_item_info->data_len;
1292 : :
1293 : 0 : rc = zxdh_np_reg_write(dev_id, ZXDH_DTB_CFG_QUEUE_DTB_LEN,
1294 : : 0, queue_id, (void *)&dtb_len);
1295 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_reg_write");
1296 : 0 : return rc;
1297 : : }
1298 : :
1299 : : static uint32_t
1300 : 0 : zxdh_np_dtb_tab_down_info_set(uint32_t dev_id,
1301 : : uint32_t queue_id,
1302 : : uint32_t int_flag,
1303 : : uint32_t data_len,
1304 : : uint32_t *p_data,
1305 : : uint32_t *p_item_index)
1306 : : {
1307 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
1308 : 0 : uint32_t unused_item_num = 0;
1309 : 0 : uint32_t queue_en = 0;
1310 : : uint32_t ack_vale = 0;
1311 : : uint64_t phy_addr;
1312 : : uint32_t item_index;
1313 : : uint32_t i;
1314 : : uint32_t rc;
1315 : :
1316 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
1317 : 0 : PMD_DRV_LOG(ERR, "dtb queue %d is not init", queue_id);
1318 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
1319 : : }
1320 : :
1321 [ # # ]: 0 : if (data_len % 4 != 0)
1322 : : return ZXDH_RC_DTB_PARA_INVALID;
1323 : :
1324 : 0 : rc = zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
1325 [ # # ]: 0 : if (!queue_en) {
1326 : 0 : PMD_DRV_LOG(ERR, "the queue %d is not enable!,rc=%d", queue_id, rc);
1327 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
1328 : : }
1329 : :
1330 : 0 : rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
1331 [ # # ]: 0 : if (unused_item_num == 0)
1332 : : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
1333 : :
1334 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
1335 : 0 : item_index = ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id) %
1336 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
1337 : :
1338 : : rc = zxdh_np_dtb_item_ack_rd(dev_id, queue_id, 0,
1339 : : item_index, 0, &ack_vale);
1340 : :
1341 : 0 : ZXDH_DTB_TAB_DOWN_WR_INDEX_GET(dev_id, queue_id)++;
1342 : :
1343 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
1344 : : break;
1345 : : }
1346 : :
1347 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX)
1348 : : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
1349 : :
1350 : : rc = zxdh_np_dtb_item_buff_wr(dev_id, queue_id, 0,
1351 : : item_index, 0, data_len, p_data);
1352 : :
1353 : : rc = zxdh_np_dtb_item_ack_wr(dev_id, queue_id, 0,
1354 : : item_index, 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
1355 : :
1356 : 0 : item_info.cmd_vld = 1;
1357 : : item_info.cmd_type = 0;
1358 : 0 : item_info.int_en = int_flag;
1359 : 0 : item_info.data_len = data_len / 4;
1360 : 0 : phy_addr = p_dpp_dtb_mgr[dev_id]->queue_info[queue_id].tab_down.start_phy_addr +
1361 : 0 : item_index * p_dpp_dtb_mgr[dev_id]->queue_info[queue_id].tab_down.item_size;
1362 : 0 : item_info.data_hddr = ((phy_addr >> 4) >> 32) & 0xffffffff;
1363 : 0 : item_info.data_laddr = (phy_addr >> 4) & 0xffffffff;
1364 : :
1365 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
1366 : 0 : *p_item_index = item_index;
1367 : :
1368 : 0 : return rc;
1369 : : }
1370 : :
1371 : : static uint32_t
1372 : : zxdh_np_dtb_write_down_table_data(uint32_t dev_id,
1373 : : uint32_t queue_id,
1374 : : uint32_t down_table_len,
1375 : : uint8_t *p_down_table_buff,
1376 : : uint32_t *p_element_id)
1377 : : {
1378 : : uint32_t rc = 0;
1379 : : uint32_t dtb_interrupt_status = 0;
1380 : :
1381 : 0 : dtb_interrupt_status = g_dpp_dtb_int_enable;
1382 : :
1383 : 0 : rc = zxdh_np_dtb_tab_down_info_set(dev_id,
1384 : : queue_id,
1385 : : dtb_interrupt_status,
1386 : : down_table_len / 4,
1387 : : (uint32_t *)p_down_table_buff,
1388 : : p_element_id);
1389 : : return rc;
1390 : : }
1391 : :
1392 : : int
1393 : 0 : zxdh_np_dtb_table_entry_write(uint32_t dev_id,
1394 : : uint32_t queue_id,
1395 : : uint32_t entrynum,
1396 : : ZXDH_DTB_USER_ENTRY_T *down_entries)
1397 : : {
1398 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
1399 : 0 : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
1400 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT] = {0};
1401 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX] = {0};
1402 : : uint8_t *p_data_buff = NULL;
1403 : : uint8_t *p_data_buff_ex = NULL;
1404 : 0 : uint32_t element_id = 0xff;
1405 : 0 : uint32_t one_dtb_len = 0;
1406 : : uint32_t dtb_len = 0;
1407 : : uint32_t entry_index;
1408 : : uint32_t sdt_no;
1409 : : uint32_t tbl_type;
1410 : : uint32_t addr_offset;
1411 : : uint32_t max_size;
1412 : : uint32_t rc;
1413 : :
1414 : 0 : p_data_buff = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
1415 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
1416 : :
1417 : 0 : p_data_buff_ex = rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
1418 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT_MEMORY_FREE(p_data_buff_ex, p_data_buff);
1419 : :
1420 : 0 : dtb_one_entry.cmd = entry_cmd;
1421 : 0 : dtb_one_entry.data = entry_data;
1422 : :
1423 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
1424 : :
1425 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
1426 : 0 : pentry = down_entries + entry_index;
1427 : 0 : sdt_no = pentry->sdt_no;
1428 : : tbl_type = zxdh_np_sdt_tbl_type_get(dev_id, sdt_no);
1429 [ # # ]: 0 : switch (tbl_type) {
1430 : 0 : case ZXDH_SDT_TBLT_ERAM:
1431 : : {
1432 : 0 : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_ADD_OR_UPDATE,
1433 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
1434 : : break;
1435 : : }
1436 : 0 : default:
1437 : : {
1438 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type);
1439 : 0 : rte_free(p_data_buff);
1440 : 0 : rte_free(p_data_buff_ex);
1441 : 0 : return 1;
1442 : : }
1443 : : }
1444 : :
1445 : 0 : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
1446 : 0 : dtb_len += one_dtb_len;
1447 [ # # ]: 0 : if (dtb_len > max_size) {
1448 : 0 : rte_free(p_data_buff);
1449 : 0 : rte_free(p_data_buff_ex);
1450 : 0 : PMD_DRV_LOG(ERR, "%s error dtb_len>%u!", __func__,
1451 : : max_size);
1452 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
1453 : : }
1454 : 0 : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
1455 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
1456 : : memset(entry_data, 0x0, sizeof(entry_data));
1457 : : }
1458 : :
1459 [ # # ]: 0 : if (dtb_len == 0) {
1460 : 0 : rte_free(p_data_buff);
1461 : 0 : rte_free(p_data_buff_ex);
1462 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
1463 : : }
1464 : :
1465 : 0 : rc = zxdh_np_dtb_write_down_table_data(dev_id,
1466 : : queue_id,
1467 : : dtb_len * 16,
1468 : : p_data_buff,
1469 : : &element_id);
1470 : 0 : rte_free(p_data_buff);
1471 : 0 : rte_free(p_data_buff_ex);
1472 : :
1473 : 0 : return rc;
1474 : : }
1475 : :
1476 : : static void
1477 : : zxdh_np_sdt_tbl_data_get(uint32_t dev_id, uint32_t sdt_no, ZXDH_SDT_TBL_DATA_T *p_sdt_data)
1478 : : {
1479 : 0 : p_sdt_data->data_high32 = g_sdt_info[dev_id][sdt_no].data_high32;
1480 : 0 : p_sdt_data->data_low32 = g_sdt_info[dev_id][sdt_no].data_low32;
1481 : : }
1482 : :
1483 : : int
1484 : 0 : zxdh_np_dtb_table_entry_delete(uint32_t dev_id,
1485 : : uint32_t queue_id,
1486 : : uint32_t entrynum,
1487 : : ZXDH_DTB_USER_ENTRY_T *delete_entries)
1488 : : {
1489 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
1490 : : ZXDH_DTB_USER_ENTRY_T *pentry = NULL;
1491 : : ZXDH_DTB_ENTRY_T dtb_one_entry = {0};
1492 : 0 : uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
1493 : 0 : uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
1494 : : uint8_t *p_data_buff = NULL;
1495 : : uint8_t *p_data_buff_ex = NULL;
1496 : : uint32_t tbl_type = 0;
1497 : : uint32_t element_id = 0xff;
1498 : : uint32_t one_dtb_len = 0;
1499 : : uint32_t dtb_len = 0;
1500 : : uint32_t entry_index;
1501 : : uint32_t sdt_no;
1502 : : uint32_t addr_offset;
1503 : : uint32_t max_size;
1504 : : uint32_t rc;
1505 : :
1506 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(delete_entries);
1507 : :
1508 : 0 : p_data_buff = rte_calloc(NULL, 1, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
1509 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_data_buff);
1510 : :
1511 : 0 : p_data_buff_ex = rte_calloc(NULL, 1, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
1512 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT_MEMORY_FREE(p_data_buff_ex, p_data_buff);
1513 : :
1514 : : dtb_one_entry.cmd = entry_cmd;
1515 : : dtb_one_entry.data = entry_data;
1516 : :
1517 : : max_size = (ZXDH_DTB_TABLE_DATA_BUFF_SIZE / 16) - 1;
1518 : :
1519 [ # # ]: 0 : for (entry_index = 0; entry_index < entrynum; entry_index++) {
1520 : : pentry = delete_entries + entry_index;
1521 : :
1522 : : sdt_no = pentry->sdt_no;
1523 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
1524 : : switch (tbl_type) {
1525 : : case ZXDH_SDT_TBLT_ERAM:
1526 : : {
1527 : : rc = zxdh_np_dtb_eram_one_entry(dev_id, sdt_no, ZXDH_DTB_ITEM_DELETE,
1528 : : pentry->p_entry_data, &one_dtb_len, &dtb_one_entry);
1529 : : break;
1530 : : }
1531 : : default:
1532 : : {
1533 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type);
1534 : 0 : rte_free(p_data_buff);
1535 : 0 : rte_free(p_data_buff_ex);
1536 : 0 : return 1;
1537 : : }
1538 : : }
1539 : :
1540 : : addr_offset = dtb_len * ZXDH_DTB_LEN_POS_SETP;
1541 : : dtb_len += one_dtb_len;
1542 : : if (dtb_len > max_size) {
1543 : : rte_free(p_data_buff);
1544 : : rte_free(p_data_buff_ex);
1545 : : PMD_DRV_LOG(ERR, "%s error dtb_len>%u!", __func__,
1546 : : max_size);
1547 : : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
1548 : : }
1549 : :
1550 : : rc = zxdh_np_dtb_data_write(p_data_buff, addr_offset, &dtb_one_entry);
1551 : : memset(entry_cmd, 0x0, sizeof(entry_cmd));
1552 : : memset(entry_data, 0x0, sizeof(entry_data));
1553 : : }
1554 : :
1555 : : if (dtb_len == 0) {
1556 : 0 : rte_free(p_data_buff);
1557 : 0 : rte_free(p_data_buff_ex);
1558 : 0 : return ZXDH_RC_DTB_DOWN_LEN_INVALID;
1559 : : }
1560 : :
1561 : : rc = zxdh_np_dtb_write_down_table_data(dev_id,
1562 : : queue_id,
1563 : : dtb_len * 16,
1564 : : p_data_buff_ex,
1565 : : &element_id);
1566 : : rte_free(p_data_buff);
1567 : : ZXDH_COMM_CHECK_RC_MEMORY_FREE_NO_ASSERT(rc,
1568 : : "dpp_dtb_write_down_table_data", p_data_buff_ex);
1569 : :
1570 : : rte_free(p_data_buff_ex);
1571 : : return 0;
1572 : : }
1573 : :
1574 : : static uint32_t
1575 : 0 : zxdh_np_sdt_tbl_data_parser(uint32_t sdt_hig32, uint32_t sdt_low32, void *p_sdt_info)
1576 : : {
1577 : : uint32_t tbl_type = 0;
1578 : : uint32_t clutch_en = 0;
1579 : :
1580 : : ZXDH_SDTTBL_ERAM_T *p_sdt_eram = NULL;
1581 : : ZXDH_SDTTBL_PORTTBL_T *p_sdt_porttbl = NULL;
1582 : :
1583 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_hig32,
1584 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
1585 : 0 : ZXDH_COMM_UINT32_GET_BITS(clutch_en, sdt_low32, 0, 1);
1586 : :
1587 [ # # ]: 0 : switch (tbl_type) {
1588 : 0 : case ZXDH_SDT_TBLT_ERAM:
1589 : : {
1590 : : p_sdt_eram = (ZXDH_SDTTBL_ERAM_T *)p_sdt_info;
1591 : 0 : p_sdt_eram->table_type = tbl_type;
1592 : 0 : p_sdt_eram->eram_clutch_en = clutch_en;
1593 : : break;
1594 : : }
1595 : :
1596 : : case ZXDH_SDT_TBLT_PORTTBL:
1597 : : {
1598 : : p_sdt_porttbl = (ZXDH_SDTTBL_PORTTBL_T *)p_sdt_info;
1599 : : p_sdt_porttbl->table_type = tbl_type;
1600 : : p_sdt_porttbl->porttbl_clutch_en = clutch_en;
1601 : : break;
1602 : : }
1603 : 0 : default:
1604 : : {
1605 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type);
1606 : 0 : return 1;
1607 : : }
1608 : : }
1609 : :
1610 : 0 : return 0;
1611 : : }
1612 : :
1613 : : static uint32_t
1614 : 0 : zxdh_np_soft_sdt_tbl_get(uint32_t dev_id, uint32_t sdt_no, void *p_sdt_info)
1615 : : {
1616 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
1617 : : uint32_t rc;
1618 : :
1619 : : zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl);
1620 : :
1621 : 0 : rc = zxdh_np_sdt_tbl_data_parser(sdt_tbl.data_high32, sdt_tbl.data_low32, p_sdt_info);
1622 [ # # ]: 0 : if (rc != 0)
1623 : 0 : PMD_DRV_LOG(ERR, "dpp sdt [%d] tbl_data_parser error", sdt_no);
1624 : :
1625 : 0 : return rc;
1626 : : }
1627 : :
1628 : : static void
1629 : : zxdh_np_eram_index_cal(uint32_t eram_mode, uint32_t index,
1630 : : uint32_t *p_row_index, uint32_t *p_col_index)
1631 : : {
1632 : : uint32_t row_index = 0;
1633 : : uint32_t col_index = 0;
1634 : :
1635 : 0 : switch (eram_mode) {
1636 : : case ZXDH_ERAM128_TBL_128b:
1637 : : {
1638 : : row_index = index;
1639 : : break;
1640 : : }
1641 : 0 : case ZXDH_ERAM128_TBL_64b:
1642 : : {
1643 : : row_index = (index >> 1);
1644 : 0 : col_index = index & 0x1;
1645 : 0 : break;
1646 : : }
1647 : 0 : case ZXDH_ERAM128_TBL_1b:
1648 : : {
1649 : : row_index = (index >> 7);
1650 : 0 : col_index = index & 0x7F;
1651 : 0 : break;
1652 : : }
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 : : {
1680 : : memcpy(p_data, temp_data, (128 / 8));
1681 : : break;
1682 : : }
1683 : 0 : case ZXDH_ERAM128_TBL_64b:
1684 : : {
1685 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
1686 : : break;
1687 : : }
1688 : 0 : case ZXDH_ERAM128_TBL_1b:
1689 : : {
1690 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
1691 : : (3 - col_index / 32)), (col_index % 32), 1);
1692 : 0 : break;
1693 : : }
1694 : : }
1695 : 0 : return rc;
1696 : : }
1697 : :
1698 : : int
1699 : 0 : zxdh_np_dtb_table_entry_get(uint32_t dev_id,
1700 : : uint32_t queue_id,
1701 : : ZXDH_DTB_USER_ENTRY_T *get_entry,
1702 : : uint32_t srh_mode)
1703 : : {
1704 : : ZXDH_SDT_TBL_DATA_T sdt_tbl = {0};
1705 : : uint32_t tbl_type = 0;
1706 : : uint32_t rc;
1707 : : uint32_t sdt_no;
1708 : :
1709 : 0 : sdt_no = get_entry->sdt_no;
1710 : : zxdh_np_sdt_tbl_data_get(srh_mode, sdt_no, &sdt_tbl);
1711 : :
1712 : 0 : ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_tbl.data_high32,
1713 : : ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN);
1714 [ # # ]: 0 : switch (tbl_type) {
1715 : 0 : case ZXDH_SDT_TBLT_ERAM:
1716 : : {
1717 : 0 : rc = zxdh_np_dtb_eram_data_get(dev_id,
1718 : : queue_id,
1719 : : sdt_no,
1720 : 0 : (ZXDH_DTB_ERAM_ENTRY_INFO_T *)get_entry->p_entry_data);
1721 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_eram_data_get");
1722 : : break;
1723 : : }
1724 : 0 : default:
1725 : : {
1726 : 0 : PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type);
1727 : 0 : return 1;
1728 : : }
1729 : : }
1730 : :
1731 : : return 0;
1732 : : }
1733 : :
1734 : : static void
1735 : : zxdh_np_stat_cfg_soft_get(uint32_t dev_id,
1736 : : ZXDH_PPU_STAT_CFG_T *p_stat_cfg)
1737 : : {
1738 : : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_stat_cfg);
1739 : :
1740 : 0 : p_stat_cfg->ddr_base_addr = g_ppu_stat_cfg.ddr_base_addr;
1741 : 0 : p_stat_cfg->eram_baddr = g_ppu_stat_cfg.eram_baddr;
1742 : 0 : p_stat_cfg->eram_depth = g_ppu_stat_cfg.eram_depth;
1743 : 0 : p_stat_cfg->ppu_addr_offset = g_ppu_stat_cfg.ppu_addr_offset;
1744 : : }
1745 : :
1746 : : static uint32_t
1747 : 0 : zxdh_np_dtb_tab_up_info_set(uint32_t dev_id,
1748 : : uint32_t queue_id,
1749 : : uint32_t item_index,
1750 : : uint32_t int_flag,
1751 : : uint32_t data_len,
1752 : : uint32_t desc_len,
1753 : : uint32_t *p_desc_data)
1754 : : {
1755 : 0 : ZXDH_DTB_QUEUE_ITEM_INFO_T item_info = {0};
1756 : 0 : uint32_t queue_en = 0;
1757 : : uint32_t rc;
1758 : :
1759 : 0 : zxdh_np_dtb_queue_enable_get(dev_id, queue_id, &queue_en);
1760 [ # # ]: 0 : if (!queue_en) {
1761 : 0 : PMD_DRV_LOG(ERR, "the queue %d is not enable!", queue_id);
1762 : 0 : return ZXDH_RC_DTB_QUEUE_NOT_ENABLE;
1763 : : }
1764 : :
1765 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
1766 : 0 : PMD_DRV_LOG(ERR, "dtb queue %d is not init", queue_id);
1767 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
1768 : : }
1769 : :
1770 [ # # ]: 0 : if (desc_len % 4 != 0)
1771 : : return ZXDH_RC_DTB_PARA_INVALID;
1772 : :
1773 : : zxdh_np_dtb_item_buff_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
1774 : : item_index, 0, desc_len, p_desc_data);
1775 : :
1776 : 0 : ZXDH_DTB_TAB_UP_DATA_LEN_GET(dev_id, queue_id, item_index) = data_len;
1777 : :
1778 : 0 : item_info.cmd_vld = 1;
1779 : 0 : item_info.cmd_type = ZXDH_DTB_DIR_UP_TYPE;
1780 : 0 : item_info.int_en = int_flag;
1781 [ # # ]: 0 : item_info.data_len = desc_len / 4;
1782 : :
1783 [ # # ]: 0 : if (zxdh_np_dev_get_dev_type(dev_id) == ZXDH_DEV_TYPE_SIM)
1784 : : return 0;
1785 : :
1786 : 0 : rc = zxdh_np_dtb_queue_item_info_set(dev_id, queue_id, &item_info);
1787 : :
1788 : 0 : return rc;
1789 : : }
1790 : :
1791 : : static uint32_t
1792 : 0 : zxdh_np_dtb_write_dump_desc_info(uint32_t dev_id,
1793 : : uint32_t queue_id,
1794 : : uint32_t queue_element_id,
1795 : : uint32_t *p_dump_info,
1796 : : uint32_t data_len,
1797 : : uint32_t desc_len,
1798 : : uint32_t *p_dump_data)
1799 : : {
1800 : : uint32_t dtb_interrupt_status = 0;
1801 : : uint32_t rc;
1802 : :
1803 [ # # ]: 0 : ZXDH_COMM_CHECK_POINT(p_dump_data);
1804 : 0 : rc = zxdh_np_dtb_tab_up_info_set(dev_id,
1805 : : queue_id,
1806 : : queue_element_id,
1807 : : dtb_interrupt_status,
1808 : : data_len,
1809 : : desc_len,
1810 : : p_dump_info);
1811 [ # # ]: 0 : if (rc != 0) {
1812 : 0 : PMD_DRV_LOG(ERR, "the queue %d element id %d dump"
1813 : : " info set failed!", queue_id, queue_element_id);
1814 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE,
1815 : : queue_element_id, 0, ZXDH_DTB_TAB_ACK_UNUSED_MASK);
1816 : : }
1817 : :
1818 : 0 : return rc;
1819 : : }
1820 : :
1821 : : static uint32_t
1822 : 0 : zxdh_np_dtb_tab_up_free_item_get(uint32_t dev_id,
1823 : : uint32_t queue_id,
1824 : : uint32_t *p_item_index)
1825 : : {
1826 : : uint32_t ack_vale = 0;
1827 : : uint32_t item_index = 0;
1828 : 0 : uint32_t unused_item_num = 0;
1829 : : uint32_t i;
1830 : :
1831 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
1832 : 0 : PMD_DRV_LOG(ERR, "dtb queue %d is not init", queue_id);
1833 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
1834 : : }
1835 : :
1836 : 0 : zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &unused_item_num);
1837 : :
1838 [ # # ]: 0 : if (unused_item_num == 0)
1839 : : return ZXDH_RC_DTB_QUEUE_ITEM_HW_EMPTY;
1840 : :
1841 [ # # ]: 0 : for (i = 0; i < ZXDH_DTB_QUEUE_ITEM_NUM_MAX; i++) {
1842 : 0 : item_index = ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id) %
1843 : : ZXDH_DTB_QUEUE_ITEM_NUM_MAX;
1844 : :
1845 : : zxdh_np_dtb_item_ack_rd(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
1846 : : 0, &ack_vale);
1847 : :
1848 : 0 : ZXDH_DTB_TAB_UP_WR_INDEX_GET(dev_id, queue_id)++;
1849 : :
1850 [ # # ]: 0 : if ((ack_vale >> 8) == ZXDH_DTB_TAB_ACK_UNUSED_MASK)
1851 : : break;
1852 : : }
1853 : :
1854 [ # # ]: 0 : if (i == ZXDH_DTB_QUEUE_ITEM_NUM_MAX)
1855 : : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
1856 : :
1857 : : zxdh_np_dtb_item_ack_wr(dev_id, queue_id, ZXDH_DTB_DIR_UP_TYPE, item_index,
1858 : : 0, ZXDH_DTB_TAB_ACK_IS_USING_MASK);
1859 : :
1860 : 0 : *p_item_index = item_index;
1861 : :
1862 : :
1863 : 0 : return 0;
1864 : : }
1865 : :
1866 : : static uint32_t
1867 : 0 : zxdh_np_dtb_tab_up_item_addr_get(uint32_t dev_id,
1868 : : uint32_t queue_id,
1869 : : uint32_t item_index,
1870 : : uint32_t *p_phy_haddr,
1871 : : uint32_t *p_phy_laddr)
1872 : : {
1873 : : uint32_t rc = 0;
1874 : : uint64_t addr;
1875 : :
1876 [ # # ]: 0 : if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
1877 : 0 : PMD_DRV_LOG(ERR, "dtb queue %d is not init", queue_id);
1878 : 0 : return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
1879 : : }
1880 : :
1881 [ # # ]: 0 : if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
1882 : : ZXDH_DTB_TAB_UP_USER_ADDR_TYPE)
1883 : 0 : addr = ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(dev_id, queue_id, item_index);
1884 : : else
1885 : : addr = ZXDH_DTB_ITEM_ACK_SIZE;
1886 : :
1887 : 0 : *p_phy_haddr = (addr >> 32) & 0xffffffff;
1888 : 0 : *p_phy_laddr = addr & 0xffffffff;
1889 : :
1890 : 0 : return rc;
1891 : : }
1892 : :
1893 : : static uint32_t
1894 : 0 : zxdh_np_dtb_se_smmu0_dma_dump(uint32_t dev_id,
1895 : : uint32_t queue_id,
1896 : : uint32_t base_addr,
1897 : : uint32_t depth,
1898 : : uint32_t *p_data,
1899 : : uint32_t *element_id)
1900 : : {
1901 : 0 : uint8_t form_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
1902 : 0 : uint32_t dump_dst_phy_haddr = 0;
1903 : 0 : uint32_t dump_dst_phy_laddr = 0;
1904 : 0 : uint32_t queue_item_index = 0;
1905 : : uint32_t data_len;
1906 : : uint32_t desc_len;
1907 : : uint32_t rc;
1908 : :
1909 : 0 : rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &queue_item_index);
1910 [ # # ]: 0 : if (rc != 0) {
1911 : 0 : PMD_DRV_LOG(ERR, "dpp_dtb_tab_up_free_item_get failed = %d!", base_addr);
1912 : 0 : return ZXDH_RC_DTB_QUEUE_ITEM_SW_EMPTY;
1913 : : }
1914 : :
1915 : 0 : *element_id = queue_item_index;
1916 : :
1917 : 0 : rc = zxdh_np_dtb_tab_up_item_addr_get(dev_id, queue_id, queue_item_index,
1918 : : &dump_dst_phy_haddr, &dump_dst_phy_laddr);
1919 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_tab_up_item_addr_get");
1920 : :
1921 : 0 : data_len = depth * 128 / 32;
1922 : : desc_len = ZXDH_DTB_LEN_POS_SETP / 4;
1923 : :
1924 : 0 : rc = zxdh_np_dtb_write_dump_desc_info(dev_id, queue_id, queue_item_index,
1925 : : (uint32_t *)form_buff, data_len, desc_len, p_data);
1926 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_write_dump_desc_info");
1927 : :
1928 : : return rc;
1929 : : }
1930 : :
1931 : : static uint32_t
1932 : 0 : zxdh_np_dtb_se_smmu0_ind_read(uint32_t dev_id,
1933 : : uint32_t queue_id,
1934 : : uint32_t base_addr,
1935 : : uint32_t index,
1936 : : uint32_t rd_mode,
1937 : : uint32_t *p_data)
1938 : : {
1939 : 0 : uint32_t temp_data[4] = {0};
1940 : 0 : uint32_t element_id = 0;
1941 : : uint32_t row_index = 0;
1942 : : uint32_t col_index = 0;
1943 : : uint32_t eram_dump_base_addr;
1944 : : uint32_t rc;
1945 : :
1946 [ # # # # ]: 0 : switch (rd_mode) {
1947 : 0 : case ZXDH_ERAM128_OPR_128b:
1948 : : {
1949 : : row_index = index;
1950 : 0 : break;
1951 : : }
1952 : 0 : case ZXDH_ERAM128_OPR_64b:
1953 : : {
1954 : 0 : row_index = (index >> 1);
1955 : 0 : col_index = index & 0x1;
1956 : 0 : break;
1957 : : }
1958 : 0 : case ZXDH_ERAM128_OPR_1b:
1959 : : {
1960 : 0 : row_index = (index >> 7);
1961 : 0 : col_index = index & 0x7F;
1962 : 0 : break;
1963 : : }
1964 : : }
1965 : :
1966 : 0 : eram_dump_base_addr = base_addr + row_index;
1967 : 0 : rc = zxdh_np_dtb_se_smmu0_dma_dump(dev_id,
1968 : : queue_id,
1969 : : eram_dump_base_addr,
1970 : : 1,
1971 : : temp_data,
1972 : : &element_id);
1973 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_dma_dump");
1974 : :
1975 [ # # # # ]: 0 : switch (rd_mode) {
1976 : : case ZXDH_ERAM128_OPR_128b:
1977 : : {
1978 : : memcpy(p_data, temp_data, (128 / 8));
1979 : : break;
1980 : : }
1981 : :
1982 : 0 : case ZXDH_ERAM128_OPR_64b:
1983 : : {
1984 : 0 : memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8));
1985 : : break;
1986 : : }
1987 : :
1988 : 0 : case ZXDH_ERAM128_OPR_1b:
1989 : : {
1990 : 0 : ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data +
1991 : : (3 - col_index / 32)), (col_index % 32), 1);
1992 : 0 : break;
1993 : : }
1994 : : }
1995 : :
1996 : 0 : return rc;
1997 : : }
1998 : :
1999 : : static uint32_t
2000 : 0 : zxdh_np_dtb_stat_smmu0_int_read(uint32_t dev_id,
2001 : : uint32_t queue_id,
2002 : : uint32_t smmu0_base_addr,
2003 : : ZXDH_STAT_CNT_MODE_E rd_mode,
2004 : : uint32_t index,
2005 : : uint32_t *p_data)
2006 : : {
2007 : : uint32_t eram_rd_mode;
2008 : : uint32_t rc;
2009 : :
2010 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
2011 : :
2012 [ # # ]: 0 : if (rd_mode == ZXDH_STAT_128_MODE)
2013 : : eram_rd_mode = ZXDH_ERAM128_OPR_128b;
2014 : : else
2015 : : eram_rd_mode = ZXDH_ERAM128_OPR_64b;
2016 : :
2017 : 0 : rc = zxdh_np_dtb_se_smmu0_ind_read(dev_id,
2018 : : queue_id,
2019 : : smmu0_base_addr,
2020 : : index,
2021 : : eram_rd_mode,
2022 : : p_data);
2023 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "zxdh_np_dtb_se_smmu0_ind_read");
2024 : :
2025 : 0 : return rc;
2026 : : }
2027 : :
2028 : : int
2029 : 0 : zxdh_np_dtb_stats_get(uint32_t dev_id,
2030 : : uint32_t queue_id,
2031 : : ZXDH_STAT_CNT_MODE_E rd_mode,
2032 : : uint32_t index,
2033 : : uint32_t *p_data)
2034 : : {
2035 : : ZXDH_PPU_STAT_CFG_T stat_cfg = {0};
2036 : : uint32_t ppu_eram_baddr;
2037 : : uint32_t ppu_eram_depth;
2038 : : uint32_t rc = 0;
2039 : :
2040 [ # # ]: 0 : ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_data);
2041 : :
2042 : : memset(&stat_cfg, 0x0, sizeof(stat_cfg));
2043 : :
2044 : : zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg);
2045 : :
2046 : : ppu_eram_depth = stat_cfg.eram_depth;
2047 : : ppu_eram_baddr = stat_cfg.eram_baddr;
2048 : :
2049 [ # # ]: 0 : if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) {
2050 : 0 : rc = zxdh_np_dtb_stat_smmu0_int_read(dev_id,
2051 : : queue_id,
2052 : : ppu_eram_baddr,
2053 : : rd_mode,
2054 : : index,
2055 : : p_data);
2056 [ # # ]: 0 : ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_stat_smmu0_int_read");
2057 : : }
2058 : :
2059 : 0 : return rc;
2060 : : }
|
