Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2024 ZTE Corporation
3 : : */
4 : :
5 : : #include <stdbool.h>
6 : :
7 : : #include <rte_common.h>
8 : : #include <rte_memcpy.h>
9 : : #include <rte_spinlock.h>
10 : : #include <rte_cycles.h>
11 : : #include <inttypes.h>
12 : : #include <rte_malloc.h>
13 : : #include "rte_mtr_driver.h"
14 : :
15 : : #include "zxdh_ethdev.h"
16 : : #include "zxdh_logs.h"
17 : : #include "zxdh_msg.h"
18 : : #include "zxdh_pci.h"
19 : : #include "zxdh_tables.h"
20 : : #include "zxdh_np.h"
21 : : #include "zxdh_common.h"
22 : :
23 : : #define ZXDH_REPS_INFO_FLAG_USABLE 0x00
24 : : #define ZXDH_BAR_SEQID_NUM_MAX 256
25 : : #define ZXDH_REPS_INFO_FLAG_USED 0xa0
26 : :
27 : : #define ZXDH_PCIEID_IS_PF_MASK (0x0800)
28 : : #define ZXDH_PCIEID_PF_IDX_MASK (0x0700)
29 : : #define ZXDH_PCIEID_VF_IDX_MASK (0x00ff)
30 : : #define ZXDH_PCIEID_EP_IDX_MASK (0x7000)
31 : : /* PCIEID bit field offset */
32 : : #define ZXDH_PCIEID_PF_IDX_OFFSET (8)
33 : : #define ZXDH_PCIEID_EP_IDX_OFFSET (12)
34 : :
35 : : #define ZXDH_MULTIPLY_BY_8(x) ((x) << 3)
36 : : #define ZXDH_MULTIPLY_BY_32(x) ((x) << 5)
37 : : #define ZXDH_MULTIPLY_BY_256(x) ((x) << 8)
38 : :
39 : : #define ZXDH_MAX_EP_NUM (4)
40 : : #define ZXDH_MAX_HARD_SPINLOCK_NUM (511)
41 : :
42 : : #define ZXDH_LOCK_PRIMARY_ID_MASK (0x8000)
43 : : /* bar offset */
44 : : #define ZXDH_BAR0_CHAN_RISC_OFFSET (0x2000)
45 : : #define ZXDH_BAR0_CHAN_PFVF_OFFSET (0x3000)
46 : : #define ZXDH_BAR0_SPINLOCK_OFFSET (0x4000)
47 : : #define ZXDH_FW_SHRD_OFFSET (0x5000)
48 : : #define ZXDH_FW_SHRD_INNER_HW_LABEL_PAT (0x800)
49 : : #define ZXDH_HW_LABEL_OFFSET \
50 : : (ZXDH_FW_SHRD_OFFSET + ZXDH_FW_SHRD_INNER_HW_LABEL_PAT)
51 : :
52 : : #define ZXDH_CHAN_RISC_SPINLOCK_OFFSET \
53 : : (ZXDH_BAR0_SPINLOCK_OFFSET - ZXDH_BAR0_CHAN_RISC_OFFSET)
54 : : #define ZXDH_CHAN_PFVF_SPINLOCK_OFFSET \
55 : : (ZXDH_BAR0_SPINLOCK_OFFSET - ZXDH_BAR0_CHAN_PFVF_OFFSET)
56 : : #define ZXDH_CHAN_RISC_LABEL_OFFSET \
57 : : (ZXDH_HW_LABEL_OFFSET - ZXDH_BAR0_CHAN_RISC_OFFSET)
58 : : #define ZXDH_CHAN_PFVF_LABEL_OFFSET \
59 : : (ZXDH_HW_LABEL_OFFSET - ZXDH_BAR0_CHAN_PFVF_OFFSET)
60 : :
61 : : #define ZXDH_REPS_HEADER_LEN_OFFSET 1
62 : : #define ZXDH_REPS_HEADER_PAYLOAD_OFFSET 4
63 : : #define ZXDH_REPS_HEADER_REPLYED 0xff
64 : :
65 : : #define ZXDH_BAR_MSG_CHAN_USABLE 0
66 : : #define ZXDH_BAR_MSG_CHAN_USED 1
67 : :
68 : : #define ZXDH_BAR_MSG_POL_MASK (0x10)
69 : : #define ZXDH_BAR_MSG_POL_OFFSET (4)
70 : :
71 : : #define ZXDH_BAR_ALIGN_WORD_MASK 0xfffffffc
72 : : #define ZXDH_BAR_MSG_VALID_MASK 1
73 : : #define ZXDH_BAR_MSG_VALID_OFFSET 0
74 : :
75 : : #define ZXDH_BAR_PF_NUM 7
76 : : #define ZXDH_BAR_VF_NUM 256
77 : : #define ZXDH_BAR_INDEX_PF_TO_VF 0
78 : : #define ZXDH_BAR_INDEX_MPF_TO_MPF 0xff
79 : : #define ZXDH_BAR_INDEX_MPF_TO_PFVF 0
80 : : #define ZXDH_BAR_INDEX_PFVF_TO_MPF 0
81 : :
82 : : #define ZXDH_MAX_HARD_SPINLOCK_ASK_TIMES (1000)
83 : : #define ZXDH_SPINLOCK_POLLING_SPAN_US (100)
84 : :
85 : : #define ZXDH_BAR_MSG_SRC_NUM 3
86 : : #define ZXDH_BAR_MSG_SRC_MPF 0
87 : : #define ZXDH_BAR_MSG_SRC_PF 1
88 : : #define ZXDH_BAR_MSG_SRC_VF 2
89 : : #define ZXDH_BAR_MSG_SRC_ERR 0xff
90 : : #define ZXDH_BAR_MSG_DST_NUM 3
91 : : #define ZXDH_BAR_MSG_DST_RISC 0
92 : : #define ZXDH_BAR_MSG_DST_MPF 2
93 : : #define ZXDH_BAR_MSG_DST_PFVF 1
94 : : #define ZXDH_BAR_MSG_DST_ERR 0xff
95 : : #define ZXDH_BAR_INDEX_TO_RISC 0
96 : :
97 : : #define ZXDH_BAR_CHAN_INDEX_SEND 0
98 : : #define ZXDH_BAR_CHAN_INDEX_RECV 1
99 : :
100 : : #define ZXDH_BAR_CHAN_MSG_SYNC 0
101 : : #define ZXDH_BAR_CHAN_MSG_NO_EMEC 0
102 : : #define ZXDH_BAR_CHAN_MSG_EMEC 1
103 : : #define ZXDH_BAR_CHAN_MSG_NO_ACK 0
104 : : #define ZXDH_BAR_CHAN_MSG_ACK 1
105 : : #define ZXDH_MSG_REPS_OK 0xff
106 : :
107 : : static uint8_t subchan_id_tbl[ZXDH_BAR_MSG_SRC_NUM][ZXDH_BAR_MSG_DST_NUM] = {
108 : : {ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_SEND},
109 : : {ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_RECV},
110 : : {ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_RECV, ZXDH_BAR_CHAN_INDEX_RECV}
111 : : };
112 : :
113 : : static uint8_t chan_id_tbl[ZXDH_BAR_MSG_SRC_NUM][ZXDH_BAR_MSG_DST_NUM] = {
114 : : {ZXDH_BAR_INDEX_TO_RISC, ZXDH_BAR_INDEX_MPF_TO_PFVF, ZXDH_BAR_INDEX_MPF_TO_MPF},
115 : : {ZXDH_BAR_INDEX_TO_RISC, ZXDH_BAR_INDEX_PF_TO_VF, ZXDH_BAR_INDEX_PFVF_TO_MPF},
116 : : {ZXDH_BAR_INDEX_TO_RISC, ZXDH_BAR_INDEX_PF_TO_VF, ZXDH_BAR_INDEX_PFVF_TO_MPF}
117 : : };
118 : :
119 : : struct zxdh_dev_stat {
120 : : bool is_mpf_scanned;
121 : : bool is_res_init;
122 : : int16_t dev_cnt; /* probe cnt */
123 : : };
124 : :
125 : : struct zxdh_seqid_item {
126 : : void *reps_addr;
127 : : uint16_t id;
128 : : uint16_t buffer_len;
129 : : uint16_t flag;
130 : : };
131 : :
132 : : struct zxdh_seqid_ring {
133 : : uint16_t cur_id;
134 : : rte_spinlock_t lock;
135 : : struct zxdh_seqid_item reps_info_tbl[ZXDH_BAR_SEQID_NUM_MAX];
136 : : };
137 : :
138 : : static struct zxdh_dev_stat g_dev_stat;
139 : : static struct zxdh_seqid_ring g_seqid_ring;
140 : : static uint8_t tmp_msg_header[ZXDH_BAR_MSG_ADDR_CHAN_INTERVAL];
141 : : static rte_spinlock_t chan_lock;
142 : :
143 : : zxdh_bar_chan_msg_recv_callback zxdh_msg_recv_func_tbl[ZXDH_BAR_MSG_MODULE_NUM];
144 : :
145 : : static inline const char
146 : 0 : *zxdh_module_id_name(int val)
147 : : {
148 [ # # # # : 0 : switch (val) {
# # # # #
# # # # #
# # # # #
# # # #
# ]
149 : : case ZXDH_BAR_MODULE_DBG: return "ZXDH_BAR_MODULE_DBG";
150 : 0 : case ZXDH_BAR_MODULE_TBL: return "ZXDH_BAR_MODULE_TBL";
151 : 0 : case ZXDH_BAR_MODULE_MISX: return "ZXDH_BAR_MODULE_MISX";
152 : 0 : case ZXDH_BAR_MODULE_SDA: return "ZXDH_BAR_MODULE_SDA";
153 : 0 : case ZXDH_BAR_MODULE_RDMA: return "ZXDH_BAR_MODULE_RDMA";
154 : 0 : case ZXDH_BAR_MODULE_DEMO: return "ZXDH_BAR_MODULE_DEMO";
155 : 0 : case ZXDH_BAR_MODULE_SMMU: return "ZXDH_BAR_MODULE_SMMU";
156 : 0 : case ZXDH_BAR_MODULE_MAC: return "ZXDH_BAR_MODULE_MAC";
157 : 0 : case ZXDH_BAR_MODULE_VDPA: return "ZXDH_BAR_MODULE_VDPA";
158 : 0 : case ZXDH_BAR_MODULE_VQM: return "ZXDH_BAR_MODULE_VQM";
159 : 0 : case ZXDH_BAR_MODULE_NP: return "ZXDH_BAR_MODULE_NP";
160 : 0 : case ZXDH_BAR_MODULE_VPORT: return "ZXDH_BAR_MODULE_VPORT";
161 : 0 : case ZXDH_BAR_MODULE_BDF: return "ZXDH_BAR_MODULE_BDF";
162 : 0 : case ZXDH_BAR_MODULE_RISC_READY: return "ZXDH_BAR_MODULE_RISC_READY";
163 : 0 : case ZXDH_BAR_MODULE_REVERSE: return "ZXDH_BAR_MODULE_REVERSE";
164 : 0 : case ZXDH_BAR_MDOULE_NVME: return "ZXDH_BAR_MDOULE_NVME";
165 : 0 : case ZXDH_BAR_MDOULE_NPSDK: return "ZXDH_BAR_MDOULE_NPSDK";
166 : 0 : case ZXDH_BAR_MODULE_NP_TODO: return "ZXDH_BAR_MODULE_NP_TODO";
167 : 0 : case ZXDH_MODULE_BAR_MSG_TO_PF: return "ZXDH_MODULE_BAR_MSG_TO_PF";
168 : 0 : case ZXDH_MODULE_BAR_MSG_TO_VF: return "ZXDH_MODULE_BAR_MSG_TO_VF";
169 : 0 : case ZXDH_MODULE_FLASH: return "ZXDH_MODULE_FLASH";
170 : 0 : case ZXDH_BAR_MODULE_OFFSET_GET: return "ZXDH_BAR_MODULE_OFFSET_GET";
171 : 0 : case ZXDH_BAR_EVENT_OVS_WITH_VCB: return "ZXDH_BAR_EVENT_OVS_WITH_VCB";
172 : 0 : default: return "NA";
173 : : }
174 : : }
175 : :
176 : : static uint16_t
177 : : zxdh_pcie_id_to_hard_lock(uint16_t src_pcieid, uint8_t dst)
178 : : {
179 : : uint16_t lock_id = 0;
180 : 0 : uint16_t pf_idx = (src_pcieid & ZXDH_PCIEID_PF_IDX_MASK) >> ZXDH_PCIEID_PF_IDX_OFFSET;
181 : 0 : uint16_t ep_idx = (src_pcieid & ZXDH_PCIEID_EP_IDX_MASK) >> ZXDH_PCIEID_EP_IDX_OFFSET;
182 : :
183 : 0 : switch (dst) {
184 : : /* msg to risc */
185 : 0 : case ZXDH_MSG_CHAN_END_RISC:
186 : 0 : lock_id = ZXDH_MULTIPLY_BY_8(ep_idx) + pf_idx;
187 : 0 : break;
188 : : /* msg to pf/vf */
189 : 0 : case ZXDH_MSG_CHAN_END_VF:
190 : : case ZXDH_MSG_CHAN_END_PF:
191 : 0 : lock_id = ZXDH_MULTIPLY_BY_8(ep_idx) + pf_idx +
192 : : ZXDH_MULTIPLY_BY_8(1 + ZXDH_MAX_EP_NUM);
193 : 0 : break;
194 : : default:
195 : : lock_id = 0;
196 : : break;
197 : : }
198 : : if (lock_id >= ZXDH_MAX_HARD_SPINLOCK_NUM)
199 : : lock_id = 0;
200 : :
201 : : return lock_id;
202 : : }
203 : :
204 : : static void
205 : : label_write(uint64_t label_lock_addr, uint32_t lock_id, uint16_t value)
206 : : {
207 : 0 : *(volatile uint16_t *)(label_lock_addr + lock_id * 2) = value;
208 : 0 : }
209 : :
210 : : static void
211 : : spinlock_write(uint64_t virt_lock_addr, uint32_t lock_id, uint8_t data)
212 : : {
213 : 0 : *(volatile uint8_t *)((uint64_t)virt_lock_addr + (uint64_t)lock_id) = data;
214 : : }
215 : :
216 : : static uint8_t
217 : : spinlock_read(uint64_t virt_lock_addr, uint32_t lock_id)
218 : : {
219 : 0 : return *(volatile uint8_t *)((uint64_t)virt_lock_addr + (uint64_t)lock_id);
220 : : }
221 : :
222 : : static int32_t
223 : 0 : zxdh_spinlock_lock(uint32_t virt_lock_id, uint64_t virt_addr,
224 : : uint64_t label_addr, uint16_t primary_id)
225 : : {
226 : : uint32_t lock_rd_cnt = 0;
227 : :
228 : : do {
229 : : /* read to lock */
230 : : uint8_t spl_val = spinlock_read(virt_addr, virt_lock_id);
231 : :
232 [ # # ]: 0 : if (spl_val == 0) {
233 : : label_write((uint64_t)label_addr, virt_lock_id, primary_id);
234 : : break;
235 : : }
236 : 0 : rte_delay_us_block(ZXDH_SPINLOCK_POLLING_SPAN_US);
237 : 0 : lock_rd_cnt++;
238 [ # # ]: 0 : } while (lock_rd_cnt < ZXDH_MAX_HARD_SPINLOCK_ASK_TIMES);
239 [ # # ]: 0 : if (lock_rd_cnt >= ZXDH_MAX_HARD_SPINLOCK_ASK_TIMES)
240 : 0 : return -1;
241 : :
242 : : return 0;
243 : : }
244 : :
245 : : static int32_t
246 : : zxdh_spinlock_unlock(uint32_t virt_lock_id, uint64_t virt_addr, uint64_t label_addr)
247 : : {
248 : : label_write((uint64_t)label_addr, virt_lock_id, 0);
249 : : spinlock_write(virt_addr, virt_lock_id, 0);
250 : 0 : return 0;
251 : : }
252 : :
253 : : /**
254 : : * Fun: PF init hard_spinlock addr
255 : : */
256 : : static int
257 : 0 : bar_chan_pf_init_spinlock(uint16_t pcie_id, uint64_t bar_base_addr)
258 : : {
259 : 0 : int lock_id = zxdh_pcie_id_to_hard_lock(pcie_id, ZXDH_MSG_CHAN_END_RISC);
260 : :
261 : 0 : zxdh_spinlock_unlock(lock_id, bar_base_addr + ZXDH_BAR0_SPINLOCK_OFFSET,
262 : : bar_base_addr + ZXDH_HW_LABEL_OFFSET);
263 : : lock_id = zxdh_pcie_id_to_hard_lock(pcie_id, ZXDH_MSG_CHAN_END_VF);
264 : 0 : zxdh_spinlock_unlock(lock_id, bar_base_addr + ZXDH_BAR0_SPINLOCK_OFFSET,
265 : : bar_base_addr + ZXDH_HW_LABEL_OFFSET);
266 : 0 : return 0;
267 : : }
268 : :
269 : : int
270 : 0 : zxdh_msg_chan_hwlock_init(struct rte_eth_dev *dev)
271 : : {
272 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
273 : :
274 [ # # ]: 0 : if (!hw->is_pf)
275 : : return 0;
276 : 0 : return bar_chan_pf_init_spinlock(hw->pcie_id, (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX]));
277 : : }
278 : :
279 : : int
280 : 0 : zxdh_msg_chan_init(void)
281 : : {
282 : : uint16_t seq_id = 0;
283 : :
284 : 0 : g_dev_stat.dev_cnt++;
285 [ # # ]: 0 : if (g_dev_stat.is_res_init)
286 : : return ZXDH_BAR_MSG_OK;
287 : :
288 : : rte_spinlock_init(&chan_lock);
289 : 0 : g_seqid_ring.cur_id = 0;
290 : : rte_spinlock_init(&g_seqid_ring.lock);
291 : :
292 [ # # ]: 0 : for (seq_id = 0; seq_id < ZXDH_BAR_SEQID_NUM_MAX; seq_id++) {
293 : 0 : struct zxdh_seqid_item *reps_info = &g_seqid_ring.reps_info_tbl[seq_id];
294 : :
295 : 0 : reps_info->id = seq_id;
296 : 0 : reps_info->flag = ZXDH_REPS_INFO_FLAG_USABLE;
297 : : }
298 : 0 : g_dev_stat.is_res_init = true;
299 : 0 : return ZXDH_BAR_MSG_OK;
300 : : }
301 : :
302 : : int
303 : 0 : zxdh_bar_msg_chan_exit(void)
304 : : {
305 [ # # # # ]: 0 : if (!g_dev_stat.is_res_init || (--g_dev_stat.dev_cnt > 0))
306 : 0 : return ZXDH_BAR_MSG_OK;
307 : :
308 : 0 : g_dev_stat.is_res_init = false;
309 : 0 : return ZXDH_BAR_MSG_OK;
310 : : }
311 : :
312 : : static int
313 : 0 : zxdh_bar_chan_msgid_allocate(uint16_t *msgid)
314 : : {
315 : : struct zxdh_seqid_item *seqid_reps_info = NULL;
316 : :
317 : : rte_spinlock_lock(&g_seqid_ring.lock);
318 : 0 : uint16_t g_id = g_seqid_ring.cur_id;
319 : : uint16_t count = 0;
320 : : int rc = 0;
321 : :
322 : : do {
323 : 0 : count++;
324 : 0 : ++g_id;
325 : 0 : g_id %= ZXDH_BAR_SEQID_NUM_MAX;
326 : 0 : seqid_reps_info = &g_seqid_ring.reps_info_tbl[g_id];
327 [ # # # # ]: 0 : } while ((seqid_reps_info->flag != ZXDH_REPS_INFO_FLAG_USABLE) &&
328 : : (count < ZXDH_BAR_SEQID_NUM_MAX));
329 : :
330 [ # # ]: 0 : if (count >= ZXDH_BAR_SEQID_NUM_MAX) {
331 : : rc = -1;
332 : 0 : goto out;
333 : : }
334 : 0 : seqid_reps_info->flag = ZXDH_REPS_INFO_FLAG_USED;
335 : 0 : g_seqid_ring.cur_id = g_id;
336 : 0 : *msgid = g_id;
337 : : rc = ZXDH_BAR_MSG_OK;
338 : :
339 : 0 : out:
340 : : rte_spinlock_unlock(&g_seqid_ring.lock);
341 : 0 : return rc;
342 : : }
343 : :
344 : : static uint16_t
345 : 0 : zxdh_bar_chan_save_recv_info(struct zxdh_msg_recviver_mem *result, uint16_t *msg_id)
346 : : {
347 : 0 : int ret = zxdh_bar_chan_msgid_allocate(msg_id);
348 : :
349 [ # # ]: 0 : if (ret != ZXDH_BAR_MSG_OK)
350 : : return ZXDH_BAR_MSG_ERR_MSGID;
351 : :
352 : 0 : PMD_MSG_LOG(DEBUG, "allocate msg_id: %u", *msg_id);
353 : 0 : struct zxdh_seqid_item *reps_info = &g_seqid_ring.reps_info_tbl[*msg_id];
354 : :
355 : 0 : reps_info->reps_addr = result->recv_buffer;
356 : 0 : reps_info->buffer_len = result->buffer_len;
357 : 0 : return ZXDH_BAR_MSG_OK;
358 : : }
359 : :
360 : : static uint8_t
361 : : zxdh_bar_msg_src_index_trans(uint8_t src)
362 : : {
363 : : uint8_t src_index = 0;
364 : :
365 : : switch (src) {
366 : : case ZXDH_MSG_CHAN_END_MPF:
367 : : src_index = ZXDH_BAR_MSG_SRC_MPF;
368 : : break;
369 : : case ZXDH_MSG_CHAN_END_PF:
370 : : src_index = ZXDH_BAR_MSG_SRC_PF;
371 : : break;
372 : : case ZXDH_MSG_CHAN_END_VF:
373 : : src_index = ZXDH_BAR_MSG_SRC_VF;
374 : : break;
375 : : default:
376 : : src_index = ZXDH_BAR_MSG_SRC_ERR;
377 : : break;
378 : : }
379 : : return src_index;
380 : : }
381 : :
382 : : static uint8_t
383 : : zxdh_bar_msg_dst_index_trans(uint8_t dst)
384 : : {
385 : : uint8_t dst_index = 0;
386 : :
387 : : switch (dst) {
388 : : case ZXDH_MSG_CHAN_END_MPF:
389 : : dst_index = ZXDH_BAR_MSG_DST_MPF;
390 : : break;
391 : : case ZXDH_MSG_CHAN_END_PF:
392 : : dst_index = ZXDH_BAR_MSG_DST_PFVF;
393 : : break;
394 : : case ZXDH_MSG_CHAN_END_VF:
395 : : dst_index = ZXDH_BAR_MSG_DST_PFVF;
396 : : break;
397 : : case ZXDH_MSG_CHAN_END_RISC:
398 : : dst_index = ZXDH_BAR_MSG_DST_RISC;
399 : : break;
400 : : default:
401 : : dst_index = ZXDH_BAR_MSG_SRC_ERR;
402 : : break;
403 : : }
404 : : return dst_index;
405 : : }
406 : :
407 : : static int
408 : 0 : zxdh_bar_chan_send_para_check(struct zxdh_pci_bar_msg *in,
409 : : struct zxdh_msg_recviver_mem *result)
410 : : {
411 : : uint8_t src_index = 0;
412 : : uint8_t dst_index = 0;
413 : :
414 [ # # ]: 0 : if (in == NULL || result == NULL) {
415 : 0 : PMD_MSG_LOG(ERR, "send para ERR: null para");
416 : 0 : return ZXDH_BAR_MSG_ERR_NULL_PARA;
417 : : }
418 [ # # ]: 0 : src_index = zxdh_bar_msg_src_index_trans(in->src);
419 [ # # ]: 0 : dst_index = zxdh_bar_msg_dst_index_trans(in->dst);
420 : :
421 [ # # ]: 0 : if (src_index == ZXDH_BAR_MSG_SRC_ERR || dst_index == ZXDH_BAR_MSG_DST_ERR) {
422 : 0 : PMD_MSG_LOG(ERR, "send para ERR: chan doesn't exist");
423 : 0 : return ZXDH_BAR_MSG_ERR_TYPE;
424 : : }
425 [ # # ]: 0 : if (in->module_id >= ZXDH_BAR_MSG_MODULE_NUM) {
426 : 0 : PMD_MSG_LOG(ERR, "send para ERR: invalid module_id: %d", in->module_id);
427 : 0 : return ZXDH_BAR_MSG_ERR_MODULE;
428 : : }
429 [ # # ]: 0 : if (in->payload_addr == NULL) {
430 : 0 : PMD_MSG_LOG(ERR, "send para ERR: null message");
431 : 0 : return ZXDH_BAR_MSG_ERR_BODY_NULL;
432 : : }
433 [ # # ]: 0 : if (in->payload_len > ZXDH_BAR_MSG_PAYLOAD_MAX_LEN) {
434 : 0 : PMD_MSG_LOG(ERR, "send para ERR: len %d is too long", in->payload_len);
435 : 0 : return ZXDH_BAR_MSG_ERR_LEN;
436 : : }
437 [ # # # # ]: 0 : if (in->virt_addr == 0 || result->recv_buffer == NULL) {
438 : 0 : PMD_MSG_LOG(ERR, "send para ERR: virt_addr or recv_buffer is NULL");
439 : 0 : return ZXDH_BAR_MSG_ERR_VIRTADDR_NULL;
440 : : }
441 [ # # ]: 0 : if (result->buffer_len < ZXDH_REPS_HEADER_PAYLOAD_OFFSET)
442 : 0 : PMD_MSG_LOG(ERR, "recv buffer len is short than minimal 4 bytes");
443 : :
444 : : return ZXDH_BAR_MSG_OK;
445 : : }
446 : :
447 : : static uint64_t
448 : : zxdh_subchan_addr_cal(uint64_t virt_addr, uint8_t chan_id, uint8_t subchan_id)
449 : : {
450 : 0 : return virt_addr + (2 * chan_id + subchan_id) * ZXDH_BAR_MSG_ADDR_CHAN_INTERVAL;
451 : : }
452 : :
453 : : static uint16_t
454 : 0 : zxdh_bar_chan_subchan_addr_get(struct zxdh_pci_bar_msg *in, uint64_t *subchan_addr)
455 : : {
456 [ # # ]: 0 : uint8_t src_index = zxdh_bar_msg_src_index_trans(in->src);
457 [ # # ]: 0 : uint8_t dst_index = zxdh_bar_msg_dst_index_trans(in->dst);
458 : 0 : uint16_t chan_id = chan_id_tbl[src_index][dst_index];
459 : 0 : uint16_t subchan_id = subchan_id_tbl[src_index][dst_index];
460 : :
461 : 0 : *subchan_addr = zxdh_subchan_addr_cal(in->virt_addr, chan_id, subchan_id);
462 : 0 : return ZXDH_BAR_MSG_OK;
463 : : }
464 : :
465 : : static int
466 : 0 : zxdh_bar_hard_lock(uint16_t src_pcieid, uint8_t dst, uint64_t virt_addr)
467 : : {
468 : : int ret = 0;
469 [ # # # ]: 0 : uint16_t lockid = zxdh_pcie_id_to_hard_lock(src_pcieid, dst);
470 : :
471 : 0 : PMD_MSG_LOG(DEBUG, "dev pcieid: 0x%x lock, get hardlockid: %u", src_pcieid, lockid);
472 [ # # ]: 0 : if (dst == ZXDH_MSG_CHAN_END_RISC)
473 : 0 : ret = zxdh_spinlock_lock(lockid, virt_addr + ZXDH_CHAN_RISC_SPINLOCK_OFFSET,
474 : : virt_addr + ZXDH_CHAN_RISC_LABEL_OFFSET,
475 : : src_pcieid | ZXDH_LOCK_PRIMARY_ID_MASK);
476 : : else
477 : 0 : ret = zxdh_spinlock_lock(lockid, virt_addr + ZXDH_CHAN_PFVF_SPINLOCK_OFFSET,
478 : : virt_addr + ZXDH_CHAN_PFVF_LABEL_OFFSET,
479 : : src_pcieid | ZXDH_LOCK_PRIMARY_ID_MASK);
480 : :
481 : 0 : return ret;
482 : : }
483 : :
484 : : static void
485 : 0 : zxdh_bar_hard_unlock(uint16_t src_pcieid, uint8_t dst, uint64_t virt_addr)
486 : : {
487 [ # # # ]: 0 : uint16_t lockid = zxdh_pcie_id_to_hard_lock(src_pcieid, dst);
488 : :
489 : 0 : PMD_MSG_LOG(DEBUG, "dev pcieid: 0x%x unlock, get hardlockid: %u", src_pcieid, lockid);
490 [ # # ]: 0 : if (dst == ZXDH_MSG_CHAN_END_RISC)
491 : 0 : zxdh_spinlock_unlock(lockid, virt_addr + ZXDH_CHAN_RISC_SPINLOCK_OFFSET,
492 : : virt_addr + ZXDH_CHAN_RISC_LABEL_OFFSET);
493 : : else
494 : 0 : zxdh_spinlock_unlock(lockid, virt_addr + ZXDH_CHAN_PFVF_SPINLOCK_OFFSET,
495 : : virt_addr + ZXDH_CHAN_PFVF_LABEL_OFFSET);
496 : 0 : }
497 : :
498 : : static int
499 [ # # ]: 0 : zxdh_bar_chan_lock(uint8_t src, uint8_t dst, uint16_t src_pcieid, uint64_t virt_addr)
500 : : {
501 : : int ret = 0;
502 : : uint8_t src_index = zxdh_bar_msg_src_index_trans(src);
503 [ # # ]: 0 : uint8_t dst_index = zxdh_bar_msg_dst_index_trans(dst);
504 : :
505 [ # # ]: 0 : if (src_index == ZXDH_BAR_MSG_SRC_ERR || dst_index == ZXDH_BAR_MSG_DST_ERR) {
506 : 0 : PMD_MSG_LOG(ERR, "lock ERR: chan doesn't exist");
507 : 0 : return ZXDH_BAR_MSG_ERR_TYPE;
508 : : }
509 : :
510 : 0 : ret = zxdh_bar_hard_lock(src_pcieid, dst, virt_addr);
511 [ # # ]: 0 : if (ret != 0)
512 : 0 : PMD_MSG_LOG(ERR, "dev: 0x%x failed to lock", src_pcieid);
513 : :
514 : : return ret;
515 : : }
516 : :
517 : : static int
518 [ # # ]: 0 : zxdh_bar_chan_unlock(uint8_t src, uint8_t dst, uint16_t src_pcieid, uint64_t virt_addr)
519 : : {
520 : : uint8_t src_index = zxdh_bar_msg_src_index_trans(src);
521 [ # # ]: 0 : uint8_t dst_index = zxdh_bar_msg_dst_index_trans(dst);
522 : :
523 [ # # ]: 0 : if (src_index == ZXDH_BAR_MSG_SRC_ERR || dst_index == ZXDH_BAR_MSG_DST_ERR) {
524 : 0 : PMD_MSG_LOG(ERR, "unlock ERR: chan doesn't exist");
525 : 0 : return ZXDH_BAR_MSG_ERR_TYPE;
526 : : }
527 : :
528 : 0 : zxdh_bar_hard_unlock(src_pcieid, dst, virt_addr);
529 : :
530 : 0 : return ZXDH_BAR_MSG_OK;
531 : : }
532 : :
533 : : static void
534 : 0 : zxdh_bar_chan_msgid_free(uint16_t msg_id)
535 : : {
536 : 0 : struct zxdh_seqid_item *seqid_reps_info = &g_seqid_ring.reps_info_tbl[msg_id];
537 : :
538 : : rte_spinlock_lock(&g_seqid_ring.lock);
539 : 0 : seqid_reps_info->flag = ZXDH_REPS_INFO_FLAG_USABLE;
540 : 0 : PMD_MSG_LOG(DEBUG, "free msg_id: %u", msg_id);
541 : : rte_spinlock_unlock(&g_seqid_ring.lock);
542 : 0 : }
543 : :
544 : : static int
545 : 0 : zxdh_bar_chan_reg_write(uint64_t subchan_addr, uint32_t offset, uint32_t data)
546 : : {
547 : 0 : uint32_t algin_offset = (offset & ZXDH_BAR_ALIGN_WORD_MASK);
548 : :
549 [ # # ]: 0 : if (unlikely(algin_offset >= ZXDH_BAR_MSG_ADDR_CHAN_INTERVAL)) {
550 : 0 : PMD_MSG_LOG(ERR, "algin_offset exceeds channel size!");
551 : 0 : return -1;
552 : : }
553 : 0 : *(uint32_t *)(subchan_addr + algin_offset) = data;
554 : 0 : return 0;
555 : : }
556 : :
557 : : static int
558 : 0 : zxdh_bar_chan_reg_read(uint64_t subchan_addr, uint32_t offset, uint32_t *pdata)
559 : : {
560 : 0 : uint32_t algin_offset = (offset & ZXDH_BAR_ALIGN_WORD_MASK);
561 : :
562 [ # # ]: 0 : if (unlikely(algin_offset >= ZXDH_BAR_MSG_ADDR_CHAN_INTERVAL)) {
563 : 0 : PMD_MSG_LOG(ERR, "algin_offset exceeds channel size!");
564 : 0 : return -1;
565 : : }
566 : 0 : *pdata = *(uint32_t *)(subchan_addr + algin_offset);
567 : 0 : return 0;
568 : : }
569 : :
570 : : static uint16_t
571 : 0 : zxdh_bar_chan_msg_header_set(uint64_t subchan_addr,
572 : : struct zxdh_bar_msg_header *msg_header)
573 : : {
574 : : uint32_t *data = (uint32_t *)msg_header;
575 : : uint16_t i;
576 : :
577 [ # # # # ]: 0 : for (i = 0; i < (ZXDH_BAR_MSG_PLAYLOAD_OFFSET >> 2); i++)
578 : 0 : zxdh_bar_chan_reg_write(subchan_addr, i * 4, *(data + i));
579 : :
580 : 0 : return ZXDH_BAR_MSG_OK;
581 : : }
582 : :
583 : : static uint16_t
584 : : zxdh_bar_chan_msg_header_get(uint64_t subchan_addr,
585 : : struct zxdh_bar_msg_header *msg_header)
586 : : {
587 : : uint32_t *data = (uint32_t *)msg_header;
588 : : uint16_t i;
589 : :
590 [ # # # # : 0 : for (i = 0; i < (ZXDH_BAR_MSG_PLAYLOAD_OFFSET >> 2); i++)
# # ]
591 : 0 : zxdh_bar_chan_reg_read(subchan_addr, i * 4, data + i);
592 : :
593 : : return ZXDH_BAR_MSG_OK;
594 : : }
595 : :
596 : : static uint16_t
597 : 0 : zxdh_bar_chan_msg_payload_set(uint64_t subchan_addr, uint8_t *msg, uint16_t len)
598 : : {
599 : : uint32_t *data = (uint32_t *)msg;
600 : 0 : uint32_t count = (len >> 2);
601 : 0 : uint32_t remain = (len & 0x3);
602 : : uint32_t remain_data = 0;
603 : : uint32_t i;
604 : :
605 [ # # ]: 0 : for (i = 0; i < count; i++)
606 : 0 : zxdh_bar_chan_reg_write(subchan_addr, 4 * i +
607 : 0 : ZXDH_BAR_MSG_PLAYLOAD_OFFSET, *(data + i));
608 [ # # ]: 0 : if (remain) {
609 [ # # ]: 0 : for (i = 0; i < remain; i++)
610 : 0 : remain_data |= *((uint8_t *)(msg + len - remain + i)) << (8 * i);
611 : :
612 : 0 : zxdh_bar_chan_reg_write(subchan_addr, 4 * count +
613 : : ZXDH_BAR_MSG_PLAYLOAD_OFFSET, remain_data);
614 : : }
615 : 0 : return ZXDH_BAR_MSG_OK;
616 : : }
617 : :
618 : : static uint16_t
619 : 0 : zxdh_bar_chan_msg_payload_get(uint64_t subchan_addr, uint8_t *msg, uint16_t len)
620 : : {
621 : : uint32_t *data = (uint32_t *)msg;
622 : 0 : uint32_t count = (len >> 2);
623 : 0 : uint32_t remain_data = 0;
624 : 0 : uint32_t remain = (len & 0x3);
625 : : uint32_t i;
626 : :
627 [ # # ]: 0 : for (i = 0; i < count; i++)
628 : 0 : zxdh_bar_chan_reg_read(subchan_addr, 4 * i +
629 : 0 : ZXDH_BAR_MSG_PLAYLOAD_OFFSET, (data + i));
630 [ # # ]: 0 : if (remain) {
631 : 0 : zxdh_bar_chan_reg_read(subchan_addr, 4 * count +
632 : : ZXDH_BAR_MSG_PLAYLOAD_OFFSET, &remain_data);
633 [ # # ]: 0 : for (i = 0; i < remain; i++)
634 : 0 : *((uint8_t *)(msg + (len - remain + i))) = remain_data >> (8 * i);
635 : : }
636 : 0 : return ZXDH_BAR_MSG_OK;
637 : : }
638 : :
639 : : static uint16_t
640 : : zxdh_bar_chan_msg_valid_set(uint64_t subchan_addr, uint8_t valid_label)
641 : : {
642 : : uint32_t data;
643 : :
644 : : zxdh_bar_chan_reg_read(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, &data);
645 : 0 : data &= (~ZXDH_BAR_MSG_VALID_MASK);
646 : 0 : data |= (uint32_t)valid_label;
647 : : zxdh_bar_chan_reg_write(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, data);
648 : : return ZXDH_BAR_MSG_OK;
649 : : }
650 : :
651 : : static uint16_t
652 : 0 : zxdh_bar_chan_msg_send(uint64_t subchan_addr, void *payload_addr,
653 : : uint16_t payload_len, struct zxdh_bar_msg_header *msg_header)
654 : : {
655 : : uint16_t ret = 0;
656 : : ret = zxdh_bar_chan_msg_header_set(subchan_addr, msg_header);
657 : :
658 : : ret = zxdh_bar_chan_msg_header_get(subchan_addr,
659 : : (struct zxdh_bar_msg_header *)tmp_msg_header);
660 : :
661 : 0 : ret = zxdh_bar_chan_msg_payload_set(subchan_addr,
662 : : (uint8_t *)(payload_addr), payload_len);
663 : :
664 : 0 : ret = zxdh_bar_chan_msg_payload_get(subchan_addr,
665 : : tmp_msg_header, payload_len);
666 : :
667 : : ret = zxdh_bar_chan_msg_valid_set(subchan_addr, ZXDH_BAR_MSG_CHAN_USED);
668 : 0 : return ret;
669 : : }
670 : :
671 : : static uint16_t
672 : : zxdh_bar_msg_valid_stat_get(uint64_t subchan_addr)
673 : : {
674 : : uint32_t data;
675 : :
676 : : zxdh_bar_chan_reg_read(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, &data);
677 [ # # ]: 0 : if (ZXDH_BAR_MSG_CHAN_USABLE == (data & ZXDH_BAR_MSG_VALID_MASK))
678 : 0 : return ZXDH_BAR_MSG_CHAN_USABLE;
679 : :
680 : : return ZXDH_BAR_MSG_CHAN_USED;
681 : : }
682 : :
683 : : static uint16_t
684 : : zxdh_bar_chan_msg_poltag_set(uint64_t subchan_addr, uint8_t label)
685 : : {
686 : : uint32_t data;
687 : :
688 : : zxdh_bar_chan_reg_read(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, &data);
689 : 0 : data &= (~(uint32_t)ZXDH_BAR_MSG_POL_MASK);
690 : : data |= ((uint32_t)label << ZXDH_BAR_MSG_POL_OFFSET);
691 : : zxdh_bar_chan_reg_write(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, data);
692 : : return ZXDH_BAR_MSG_OK;
693 : : }
694 : :
695 : : static uint16_t
696 : 0 : zxdh_bar_chan_sync_msg_reps_get(uint64_t subchan_addr,
697 : : uint64_t recv_buffer, uint16_t buffer_len)
698 : : {
699 : : struct zxdh_bar_msg_header msg_header;
700 : : uint16_t msg_id = 0;
701 : : uint16_t msg_len = 0;
702 : :
703 : : zxdh_bar_chan_msg_header_get(subchan_addr, &msg_header);
704 : 0 : msg_id = msg_header.msg_id;
705 : 0 : struct zxdh_seqid_item *reps_info = &g_seqid_ring.reps_info_tbl[msg_id];
706 : :
707 [ # # ]: 0 : if (reps_info->flag != ZXDH_REPS_INFO_FLAG_USED) {
708 : 0 : PMD_MSG_LOG(ERR, "msg_id %u unused", msg_id);
709 : 0 : return ZXDH_BAR_MSG_ERR_REPLY;
710 : : }
711 : 0 : msg_len = msg_header.len;
712 : :
713 [ # # ]: 0 : if (msg_len > buffer_len - 4) {
714 : 0 : PMD_MSG_LOG(ERR, "recv buffer len is: %u, but reply msg len is: %u",
715 : : buffer_len, msg_len + 4);
716 : 0 : return ZXDH_BAR_MSG_ERR_REPSBUFF_LEN;
717 : : }
718 : 0 : uint8_t *recv_msg = (uint8_t *)recv_buffer;
719 : :
720 : 0 : zxdh_bar_chan_msg_payload_get(subchan_addr,
721 : : recv_msg + ZXDH_REPS_HEADER_PAYLOAD_OFFSET, msg_len);
722 : 0 : *(uint16_t *)(recv_msg + ZXDH_REPS_HEADER_LEN_OFFSET) = msg_len;
723 : 0 : *recv_msg = ZXDH_REPS_HEADER_REPLYED; /* set reps's valid */
724 : 0 : return ZXDH_BAR_MSG_OK;
725 : : }
726 : :
727 : : int
728 : 0 : zxdh_bar_chan_sync_msg_send(struct zxdh_pci_bar_msg *in, struct zxdh_msg_recviver_mem *result)
729 : : {
730 : 0 : struct zxdh_bar_msg_header msg_header = {0};
731 : 0 : uint16_t seq_id = 0;
732 : 0 : uint64_t subchan_addr = 0;
733 : : uint32_t time_out_cnt = 0;
734 : : uint16_t valid = 0;
735 : : int ret = 0;
736 : :
737 : 0 : ret = zxdh_bar_chan_send_para_check(in, result);
738 [ # # ]: 0 : if (ret != ZXDH_BAR_MSG_OK)
739 : 0 : goto exit;
740 : :
741 : 0 : ret = zxdh_bar_chan_save_recv_info(result, &seq_id);
742 [ # # ]: 0 : if (ret != ZXDH_BAR_MSG_OK)
743 : 0 : goto exit;
744 : :
745 : 0 : zxdh_bar_chan_subchan_addr_get(in, &subchan_addr);
746 : :
747 : : msg_header.sync = ZXDH_BAR_CHAN_MSG_SYNC;
748 : 0 : msg_header.emec = in->emec;
749 : : msg_header.usr = 0;
750 : : msg_header.rsv = 0;
751 : 0 : msg_header.module_id = in->module_id;
752 : 0 : msg_header.len = in->payload_len;
753 : 0 : msg_header.msg_id = seq_id;
754 : 0 : msg_header.src_pcieid = in->src_pcieid;
755 : 0 : msg_header.dst_pcieid = in->dst_pcieid;
756 : :
757 : 0 : ret = zxdh_bar_chan_lock(in->src, in->dst, in->src_pcieid, in->virt_addr);
758 [ # # ]: 0 : if (ret != ZXDH_BAR_MSG_OK) {
759 : 0 : zxdh_bar_chan_msgid_free(seq_id);
760 : 0 : goto exit;
761 : : }
762 : 0 : zxdh_bar_chan_msg_send(subchan_addr, in->payload_addr, in->payload_len, &msg_header);
763 : :
764 : : do {
765 : 0 : rte_delay_us_block(ZXDH_BAR_MSG_POLLING_SPAN);
766 : : valid = zxdh_bar_msg_valid_stat_get(subchan_addr);
767 : 0 : ++time_out_cnt;
768 [ # # ]: 0 : } while ((time_out_cnt < ZXDH_BAR_MSG_TIMEOUT_TH) && (valid == ZXDH_BAR_MSG_CHAN_USED));
769 : :
770 [ # # ]: 0 : if (time_out_cnt == ZXDH_BAR_MSG_TIMEOUT_TH && valid != ZXDH_BAR_MSG_CHAN_USABLE) {
771 : : zxdh_bar_chan_msg_valid_set(subchan_addr, ZXDH_BAR_MSG_CHAN_USABLE);
772 : : zxdh_bar_chan_msg_poltag_set(subchan_addr, 0);
773 : 0 : PMD_MSG_LOG(ERR, "BAR MSG ERR: chan type time out");
774 : : ret = ZXDH_BAR_MSG_ERR_TIME_OUT;
775 : : } else {
776 : 0 : ret = zxdh_bar_chan_sync_msg_reps_get(subchan_addr,
777 : 0 : (uint64_t)result->recv_buffer, result->buffer_len);
778 : : }
779 : 0 : zxdh_bar_chan_msgid_free(seq_id);
780 : 0 : zxdh_bar_chan_unlock(in->src, in->dst, in->src_pcieid, in->virt_addr);
781 : :
782 : 0 : exit:
783 : 0 : return ret;
784 : : }
785 : :
786 : : static int
787 : : zxdh_bar_get_sum(uint8_t *ptr, uint8_t len)
788 : : {
789 : : uint64_t sum = 0;
790 : : int idx;
791 : :
792 [ # # # # ]: 0 : for (idx = 0; idx < len; idx++)
793 : 0 : sum += *(ptr + idx);
794 : :
795 : 0 : return (uint16_t)sum;
796 : : }
797 : :
798 : : static int
799 : 0 : zxdh_bar_chan_enable(struct zxdh_msix_para *para, uint16_t *vport)
800 : : {
801 : 0 : struct zxdh_bar_recv_msg recv_msg = {0};
802 : : int ret = 0;
803 : : int check_token = 0;
804 : : int sum_res = 0;
805 : :
806 [ # # ]: 0 : if (!para)
807 : : return ZXDH_BAR_MSG_ERR_NULL;
808 : :
809 : 0 : struct zxdh_msix_msg msix_msg = {
810 : 0 : .pcie_id = para->pcie_id,
811 : 0 : .vector_risc = para->vector_risc,
812 : 0 : .vector_pfvf = para->vector_pfvf,
813 : 0 : .vector_mpf = para->vector_mpf,
814 : : };
815 : 0 : struct zxdh_pci_bar_msg in = {
816 : 0 : .virt_addr = para->virt_addr,
817 : : .payload_addr = &msix_msg,
818 : : .payload_len = sizeof(msix_msg),
819 : : .emec = 0,
820 : 0 : .src = para->driver_type,
821 : : .dst = ZXDH_MSG_CHAN_END_RISC,
822 : : .module_id = ZXDH_BAR_MODULE_MISX,
823 : : .src_pcieid = para->pcie_id,
824 : : .dst_pcieid = 0,
825 : : .usr = 0,
826 : : };
827 : :
828 : 0 : struct zxdh_msg_recviver_mem result = {
829 : : .recv_buffer = &recv_msg,
830 : : .buffer_len = sizeof(recv_msg),
831 : : };
832 : :
833 : 0 : ret = zxdh_bar_chan_sync_msg_send(&in, &result);
834 [ # # ]: 0 : if (ret != ZXDH_BAR_MSG_OK)
835 : 0 : return -ret;
836 : :
837 : 0 : check_token = recv_msg.msix_reps.check;
838 : : sum_res = zxdh_bar_get_sum((uint8_t *)&msix_msg, sizeof(msix_msg));
839 : :
840 [ # # ]: 0 : if (check_token != sum_res) {
841 : 0 : PMD_MSG_LOG(ERR, "expect token: 0x%x, get token: 0x%x", sum_res, check_token);
842 : 0 : return ZXDH_BAR_MSG_ERR_REPLY;
843 : : }
844 : 0 : *vport = recv_msg.msix_reps.vport;
845 : 0 : PMD_MSG_LOG(DEBUG, "vport of pcieid: 0x%x get success", para->pcie_id);
846 : 0 : return ZXDH_BAR_MSG_OK;
847 : : }
848 : :
849 : : int
850 : 0 : zxdh_msg_chan_enable(struct rte_eth_dev *dev)
851 : : {
852 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
853 : 0 : struct zxdh_msix_para misx_info = {
854 : : .vector_risc = ZXDH_MSIX_FROM_RISCV,
855 : : .vector_pfvf = ZXDH_MSIX_FROM_PFVF,
856 : : .vector_mpf = ZXDH_MSIX_FROM_MPF,
857 : 0 : .pcie_id = hw->pcie_id,
858 : 0 : .driver_type = hw->is_pf ? ZXDH_MSG_CHAN_END_PF : ZXDH_MSG_CHAN_END_VF,
859 [ # # ]: 0 : .virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] + ZXDH_CTRLCH_OFFSET),
860 : : };
861 : :
862 : 0 : return zxdh_bar_chan_enable(&misx_info, &hw->vport.vport);
863 : : }
864 : :
865 : : static uint64_t
866 [ # # ]: 0 : zxdh_recv_addr_get(uint8_t src_type, uint8_t dst_type, uint64_t virt_addr)
867 : : {
868 : : uint8_t chan_id = 0;
869 : : uint8_t subchan_id = 0;
870 : : uint8_t src = 0;
871 : : uint8_t dst = 0;
872 : :
873 : : src = zxdh_bar_msg_dst_index_trans(src_type);
874 : : dst = zxdh_bar_msg_src_index_trans(dst_type);
875 [ # # ]: 0 : if (src == ZXDH_BAR_MSG_SRC_ERR || dst == ZXDH_BAR_MSG_DST_ERR)
876 : : return 0;
877 : :
878 : 0 : chan_id = chan_id_tbl[dst][src];
879 : 0 : subchan_id = 1 - subchan_id_tbl[dst][src];
880 : :
881 : 0 : return zxdh_subchan_addr_cal(virt_addr, chan_id, subchan_id);
882 : : }
883 : :
884 : : static void
885 : 0 : zxdh_bar_msg_ack_async_msg_proc(struct zxdh_bar_msg_header *msg_header,
886 : : uint8_t *receiver_buff)
887 : : {
888 : 0 : struct zxdh_seqid_item *reps_info = &g_seqid_ring.reps_info_tbl[msg_header->msg_id];
889 : :
890 [ # # ]: 0 : if (reps_info->flag != ZXDH_REPS_INFO_FLAG_USED) {
891 : 0 : PMD_MSG_LOG(ERR, "msg_id: %u is released", msg_header->msg_id);
892 : 0 : return;
893 : : }
894 [ # # ]: 0 : if (msg_header->len > reps_info->buffer_len - 4) {
895 : 0 : PMD_MSG_LOG(ERR, "reps_buf_len is %u, but reps_msg_len is %u",
896 : : reps_info->buffer_len, msg_header->len + 4);
897 : 0 : goto free_id;
898 : : }
899 : 0 : uint8_t *reps_buffer = (uint8_t *)reps_info->reps_addr;
900 : :
901 [ # # ]: 0 : rte_memcpy(reps_buffer + 4, receiver_buff, msg_header->len);
902 : 0 : *(uint16_t *)(reps_buffer + 1) = msg_header->len;
903 : 0 : *(uint8_t *)(reps_info->reps_addr) = ZXDH_REPS_HEADER_REPLYED;
904 : :
905 : 0 : free_id:
906 : 0 : zxdh_bar_chan_msgid_free(msg_header->msg_id);
907 : : }
908 : :
909 : : static void
910 : 0 : zxdh_bar_msg_sync_msg_proc(uint64_t reply_addr,
911 : : struct zxdh_bar_msg_header *msg_header,
912 : : uint8_t *receiver_buff, void *dev)
913 : : {
914 : 0 : uint16_t reps_len = 0;
915 : : uint8_t *reps_buffer = NULL;
916 : :
917 : 0 : reps_buffer = rte_malloc(NULL, ZXDH_BAR_MSG_PAYLOAD_MAX_LEN, 0);
918 [ # # ]: 0 : if (reps_buffer == NULL)
919 : 0 : return;
920 : :
921 : 0 : zxdh_bar_chan_msg_recv_callback recv_func = zxdh_msg_recv_func_tbl[msg_header->module_id];
922 : :
923 : 0 : recv_func(receiver_buff, msg_header->len, reps_buffer, &reps_len, dev);
924 : 0 : msg_header->ack = ZXDH_BAR_CHAN_MSG_ACK;
925 : 0 : msg_header->len = reps_len;
926 : 0 : zxdh_bar_chan_msg_header_set(reply_addr, msg_header);
927 : 0 : zxdh_bar_chan_msg_payload_set(reply_addr, reps_buffer, reps_len);
928 : : zxdh_bar_chan_msg_valid_set(reply_addr, ZXDH_BAR_MSG_CHAN_USABLE);
929 : 0 : rte_free(reps_buffer);
930 : : }
931 : :
932 : : static uint64_t
933 [ # # ]: 0 : zxdh_reply_addr_get(uint8_t sync, uint8_t src_type,
934 : : uint8_t dst_type, uint64_t virt_addr)
935 : : {
936 : : uint64_t recv_rep_addr = 0;
937 : : uint8_t chan_id = 0;
938 : : uint8_t subchan_id = 0;
939 : : uint8_t src = 0;
940 : : uint8_t dst = 0;
941 : :
942 : : src = zxdh_bar_msg_dst_index_trans(src_type);
943 : : dst = zxdh_bar_msg_src_index_trans(dst_type);
944 [ # # ]: 0 : if (src == ZXDH_BAR_MSG_SRC_ERR || dst == ZXDH_BAR_MSG_DST_ERR)
945 : : return 0;
946 : :
947 : 0 : chan_id = chan_id_tbl[dst][src];
948 : 0 : subchan_id = 1 - subchan_id_tbl[dst][src];
949 : :
950 [ # # ]: 0 : if (sync == ZXDH_BAR_CHAN_MSG_SYNC)
951 : 0 : recv_rep_addr = zxdh_subchan_addr_cal(virt_addr, chan_id, subchan_id);
952 : : else
953 : 0 : recv_rep_addr = zxdh_subchan_addr_cal(virt_addr, chan_id, 1 - subchan_id);
954 : :
955 : : return recv_rep_addr;
956 : : }
957 : :
958 : : static uint16_t
959 : 0 : zxdh_bar_chan_msg_header_check(struct zxdh_bar_msg_header *msg_header)
960 : : {
961 : : uint16_t len = 0;
962 : : uint8_t module_id = 0;
963 : :
964 [ # # ]: 0 : if (msg_header->valid != ZXDH_BAR_MSG_CHAN_USED) {
965 : 0 : PMD_MSG_LOG(ERR, "recv header ERR: valid label is not used");
966 : 0 : return ZXDH_BAR_MSG_ERR_MODULE;
967 : : }
968 : 0 : module_id = msg_header->module_id;
969 : :
970 [ # # ]: 0 : if (module_id >= (uint8_t)ZXDH_BAR_MSG_MODULE_NUM) {
971 : 0 : PMD_MSG_LOG(ERR, "recv header ERR: invalid module_id: %u", module_id);
972 : 0 : return ZXDH_BAR_MSG_ERR_MODULE;
973 : : }
974 : 0 : len = msg_header->len;
975 : :
976 [ # # ]: 0 : if (len > ZXDH_BAR_MSG_PAYLOAD_MAX_LEN) {
977 : 0 : PMD_MSG_LOG(ERR, "recv header ERR: invalid mesg len: %u", len);
978 : 0 : return ZXDH_BAR_MSG_ERR_LEN;
979 : : }
980 [ # # ]: 0 : if (zxdh_msg_recv_func_tbl[msg_header->module_id] == NULL) {
981 : 0 : PMD_MSG_LOG(ERR, "recv header ERR: module:%s(%u) doesn't register",
982 : : zxdh_module_id_name(module_id), module_id);
983 : 0 : return ZXDH_BAR_MSG_ERR_MODULE_NOEXIST;
984 : : }
985 : : return ZXDH_BAR_MSG_OK;
986 : : }
987 : :
988 : : int
989 : 0 : zxdh_bar_irq_recv(uint8_t src, uint8_t dst, uint64_t virt_addr, void *dev)
990 : : {
991 : : struct zxdh_bar_msg_header msg_header;
992 : : uint64_t recv_addr = 0;
993 : : uint64_t reps_addr = 0;
994 : : uint16_t ret = 0;
995 : : uint8_t *recved_msg = NULL;
996 : :
997 : 0 : recv_addr = zxdh_recv_addr_get(src, dst, virt_addr);
998 [ # # ]: 0 : if (recv_addr == 0) {
999 : 0 : PMD_MSG_LOG(ERR, "invalid driver type(src:%u, dst:%u)", src, dst);
1000 : 0 : return -1;
1001 : : }
1002 : :
1003 : : zxdh_bar_chan_msg_header_get(recv_addr, &msg_header);
1004 : 0 : ret = zxdh_bar_chan_msg_header_check(&msg_header);
1005 : :
1006 [ # # ]: 0 : if (ret != ZXDH_BAR_MSG_OK) {
1007 : 0 : PMD_MSG_LOG(ERR, "recv msg_head err, ret: %u", ret);
1008 : 0 : return -1;
1009 : : }
1010 : :
1011 : 0 : recved_msg = rte_malloc(NULL, msg_header.len, 0);
1012 [ # # ]: 0 : if (recved_msg == NULL) {
1013 : 0 : PMD_MSG_LOG(ERR, "malloc temp buff failed");
1014 : 0 : return -1;
1015 : : }
1016 : 0 : zxdh_bar_chan_msg_payload_get(recv_addr, recved_msg, msg_header.len);
1017 : :
1018 : 0 : reps_addr = zxdh_reply_addr_get(msg_header.sync, src, dst, virt_addr);
1019 : :
1020 [ # # ]: 0 : if (msg_header.sync == ZXDH_BAR_CHAN_MSG_SYNC) {
1021 : 0 : zxdh_bar_msg_sync_msg_proc(reps_addr, &msg_header, recved_msg, dev);
1022 : 0 : goto exit;
1023 : : }
1024 : : zxdh_bar_chan_msg_valid_set(recv_addr, ZXDH_BAR_MSG_CHAN_USABLE);
1025 [ # # ]: 0 : if (msg_header.ack == ZXDH_BAR_CHAN_MSG_ACK) {
1026 : 0 : zxdh_bar_msg_ack_async_msg_proc(&msg_header, recved_msg);
1027 : 0 : goto exit;
1028 : : }
1029 : : return 0;
1030 : :
1031 : 0 : exit:
1032 : 0 : rte_free(recved_msg);
1033 : 0 : return ZXDH_BAR_MSG_OK;
1034 : : }
1035 : :
1036 : : int
1037 : 0 : zxdh_get_bar_offset(struct zxdh_bar_offset_params *paras,
1038 : : struct zxdh_bar_offset_res *res)
1039 : : {
1040 : : uint16_t check_token;
1041 : : uint16_t sum_res;
1042 : : int ret;
1043 : :
1044 [ # # ]: 0 : if (!paras)
1045 : : return ZXDH_BAR_MSG_ERR_NULL;
1046 : :
1047 : 0 : struct zxdh_offset_get_msg send_msg = {
1048 : 0 : .pcie_id = paras->pcie_id,
1049 : 0 : .type = paras->type,
1050 : : };
1051 : 0 : struct zxdh_pci_bar_msg in = {
1052 : : .payload_addr = &send_msg,
1053 : : .payload_len = sizeof(send_msg),
1054 : 0 : .virt_addr = paras->virt_addr,
1055 : : .src = ZXDH_MSG_CHAN_END_PF,
1056 : : .dst = ZXDH_MSG_CHAN_END_RISC,
1057 : : .module_id = ZXDH_BAR_MODULE_OFFSET_GET,
1058 : : .src_pcieid = paras->pcie_id,
1059 : : };
1060 : 0 : struct zxdh_bar_recv_msg recv_msg = {0};
1061 : 0 : struct zxdh_msg_recviver_mem result = {
1062 : : .recv_buffer = &recv_msg,
1063 : : .buffer_len = sizeof(recv_msg),
1064 : : };
1065 : 0 : ret = zxdh_bar_chan_sync_msg_send(&in, &result);
1066 [ # # ]: 0 : if (ret != ZXDH_BAR_MSG_OK)
1067 : 0 : return -ret;
1068 : :
1069 : 0 : check_token = recv_msg.offset_reps.check;
1070 : : sum_res = zxdh_bar_get_sum((uint8_t *)&send_msg, sizeof(send_msg));
1071 : :
1072 [ # # ]: 0 : if (check_token != sum_res) {
1073 : 0 : PMD_MSG_LOG(ERR, "expect token: 0x%x, get token: 0x%x", sum_res, check_token);
1074 : 0 : return ZXDH_BAR_MSG_ERR_REPLY;
1075 : : }
1076 : 0 : res->bar_offset = recv_msg.offset_reps.offset;
1077 : 0 : res->bar_length = recv_msg.offset_reps.length;
1078 : 0 : return ZXDH_BAR_MSG_OK;
1079 : : }
1080 : :
1081 : : int
1082 : 0 : zxdh_vf_send_msg_to_pf(struct rte_eth_dev *dev, void *msg_req,
1083 : : uint16_t msg_req_len, void *reply, uint16_t reply_len)
1084 : : {
1085 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
1086 : 0 : struct zxdh_msg_recviver_mem result = {0};
1087 : 0 : uint8_t zxdh_msg_reply_info[ZXDH_ST_SZ_BYTES(msg_reply_info)] = {0};
1088 : : int ret = 0;
1089 : :
1090 [ # # ]: 0 : if (reply) {
1091 : : RTE_ASSERT(reply_len < ZXDH_ST_SZ_BYTES(msg_reply_info));
1092 : 0 : result.recv_buffer = reply;
1093 : 0 : result.buffer_len = reply_len;
1094 : : } else {
1095 : 0 : result.recv_buffer = zxdh_msg_reply_info;
1096 : 0 : result.buffer_len = ZXDH_ST_SZ_BYTES(msg_reply_info);
1097 : : }
1098 : :
1099 : 0 : void *reply_head_addr = ZXDH_ADDR_OF(msg_reply_info, result.recv_buffer, reply_head);
1100 : 0 : void *reply_body_addr = ZXDH_ADDR_OF(msg_reply_info, result.recv_buffer, reply_body);
1101 : :
1102 : 0 : struct zxdh_pci_bar_msg in = {
1103 : 0 : .virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] +
1104 : : ZXDH_MSG_CHAN_PFVFSHARE_OFFSET),
1105 : : .payload_addr = msg_req,
1106 : : .payload_len = msg_req_len,
1107 : : .src = ZXDH_MSG_CHAN_END_VF,
1108 : : .dst = ZXDH_MSG_CHAN_END_PF,
1109 : : .module_id = ZXDH_MODULE_BAR_MSG_TO_PF,
1110 : 0 : .src_pcieid = hw->pcie_id,
1111 : 0 : .dst_pcieid = ZXDH_PF_PCIE_ID(hw->pcie_id),
1112 : : };
1113 : :
1114 : 0 : ret = zxdh_bar_chan_sync_msg_send(&in, &result);
1115 [ # # ]: 0 : if (ret != ZXDH_BAR_MSG_OK) {
1116 : 0 : PMD_MSG_LOG(ERR,
1117 : : "vf[%d] send bar msg to pf failed.ret %d", hw->vport.vfid, ret);
1118 : 0 : return -1;
1119 : : }
1120 : :
1121 : 0 : uint8_t flag = ZXDH_GET(msg_reply_head, reply_head_addr, flag);
1122 : 0 : uint16_t reps_len = ZXDH_GET(msg_reply_head, reply_head_addr, reps_len);
1123 [ # # ]: 0 : if (flag != ZXDH_MSG_REPS_OK) {
1124 : 0 : PMD_MSG_LOG(ERR, "vf[%d] get pf reply failed: reply_head flag : 0x%x(0xff is OK).replylen %d",
1125 : : hw->vport.vfid, flag, reps_len);
1126 : 0 : return -1;
1127 : : }
1128 : 0 : uint8_t reply_body_flag = ZXDH_GET(msg_reply_body, reply_body_addr, flag);
1129 [ # # ]: 0 : if (reply_body_flag != ZXDH_REPS_SUCC) {
1130 : 0 : PMD_MSG_LOG(ERR, "vf[%d] msg processing failed", hw->vfid);
1131 : 0 : return -1;
1132 : : }
1133 : : return 0;
1134 : : }
1135 : :
1136 : : int32_t
1137 : 0 : zxdh_send_msg_to_riscv(struct rte_eth_dev *dev, void *msg_req,
1138 : : uint16_t msg_req_len, void *reply, uint16_t reply_len,
1139 : : enum ZXDH_BAR_MODULE_ID module_id)
1140 : : {
1141 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
1142 : 0 : struct zxdh_msg_recviver_mem result = {0};
1143 : 0 : uint8_t zxdh_msg_reply_info[ZXDH_ST_SZ_BYTES(msg_reply_info)] = {0};
1144 : :
1145 [ # # ]: 0 : if (reply) {
1146 : : RTE_ASSERT(reply_len < ZXDH_ST_SZ_BYTES(msg_reply_info));
1147 : 0 : result.recv_buffer = reply;
1148 : 0 : result.buffer_len = reply_len;
1149 : : } else {
1150 : 0 : result.recv_buffer = zxdh_msg_reply_info;
1151 : 0 : result.buffer_len = ZXDH_ST_SZ_BYTES(msg_reply_info);
1152 : : }
1153 : :
1154 : 0 : struct zxdh_pci_bar_msg in = {
1155 : : .payload_addr = msg_req,
1156 : : .payload_len = msg_req_len,
1157 : 0 : .virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] + ZXDH_CTRLCH_OFFSET),
1158 [ # # ]: 0 : .src = hw->is_pf ? ZXDH_MSG_CHAN_END_PF : ZXDH_MSG_CHAN_END_VF,
1159 : : .dst = ZXDH_MSG_CHAN_END_RISC,
1160 : : .module_id = module_id,
1161 : 0 : .src_pcieid = hw->pcie_id,
1162 : : };
1163 : :
1164 [ # # ]: 0 : if (zxdh_bar_chan_sync_msg_send(&in, &result) != ZXDH_BAR_MSG_OK) {
1165 : 0 : PMD_MSG_LOG(ERR, "Failed to send sync messages or receive response");
1166 : 0 : return -1;
1167 : : }
1168 : :
1169 : : return 0;
1170 : : }
1171 : :
1172 : : void
1173 : 0 : zxdh_msg_head_build(struct zxdh_hw *hw, enum zxdh_msg_type type,
1174 : : struct zxdh_msg_info *msg_info)
1175 : : {
1176 : : struct zxdh_msg_head *msghead = &msg_info->msg_head;
1177 : :
1178 : 0 : msghead->msg_type = type;
1179 : 0 : msghead->vport = hw->vport.vport;
1180 : 0 : msghead->vf_id = hw->vport.vfid;
1181 : 0 : msghead->pcieid = hw->pcie_id;
1182 : 0 : }
1183 : :
1184 : : void
1185 : 0 : zxdh_agent_msg_build(struct zxdh_hw *hw, enum zxdh_agent_msg_type type,
1186 : : struct zxdh_msg_info *msg_info)
1187 : : {
1188 : : struct zxdh_agent_msg_head *agent_head = &msg_info->agent_msg_head;
1189 : :
1190 : 0 : agent_head->msg_type = type;
1191 : 0 : agent_head->panel_id = hw->panel_id;
1192 : 0 : agent_head->phyport = hw->phyport;
1193 : 0 : agent_head->vf_id = hw->vfid;
1194 : 0 : agent_head->pcie_id = hw->pcie_id;
1195 : 0 : }
1196 : :
1197 : : static int
1198 : 0 : zxdh_bar_chan_msg_recv_register(uint8_t module_id, zxdh_bar_chan_msg_recv_callback callback)
1199 : : {
1200 [ # # ]: 0 : if (module_id >= (uint16_t)ZXDH_BAR_MSG_MODULE_NUM) {
1201 : 0 : PMD_MSG_LOG(ERR, "register ERR: invalid module_id: %u.", module_id);
1202 : 0 : return ZXDH_BAR_MSG_ERR_MODULE;
1203 : : }
1204 [ # # ]: 0 : if (callback == NULL) {
1205 : 0 : PMD_MSG_LOG(ERR, "register %s(%u) error: null callback.",
1206 : : zxdh_module_id_name(module_id), module_id);
1207 : 0 : return ZXDH_BAR_MEG_ERR_NULL_FUNC;
1208 : : }
1209 [ # # ]: 0 : if (zxdh_msg_recv_func_tbl[module_id] != NULL) {
1210 : 0 : PMD_MSG_LOG(DEBUG, "register warning, event:%s(%u) already be registered.",
1211 : : zxdh_module_id_name(module_id), module_id);
1212 : 0 : return ZXDH_BAR_MSG_ERR_REPEAT_REGISTER;
1213 : : }
1214 : 0 : zxdh_msg_recv_func_tbl[module_id] = callback;
1215 : 0 : return ZXDH_BAR_MSG_OK;
1216 : : }
1217 : :
1218 : : static int
1219 : : zxdh_vf_promisc_init(struct zxdh_hw *hw, union zxdh_virport_num vport)
1220 : : {
1221 : : int16_t ret;
1222 : :
1223 : 0 : ret = zxdh_dev_broadcast_set(hw, vport.vport, true);
1224 : 0 : return ret;
1225 : : }
1226 : :
1227 : : static int
1228 : : zxdh_vf_promisc_uninit(struct zxdh_hw *hw, union zxdh_virport_num vport)
1229 : : {
1230 : : int16_t ret;
1231 : :
1232 : 0 : ret = zxdh_dev_broadcast_set(hw, vport.vport, false);
1233 : 0 : return ret;
1234 : : }
1235 : :
1236 : : static int
1237 : 0 : zxdh_vf_port_init(struct zxdh_hw *pf_hw, uint16_t vport, void *cfg_data,
1238 : : void *res_info, uint16_t *res_len)
1239 : : {
1240 : 0 : struct zxdh_port_attr_table port_attr = {0};
1241 : : union zxdh_virport_num port = {.vport = vport};
1242 : : struct zxdh_vf_init_msg *vf_init_msg = (struct zxdh_vf_init_msg *)cfg_data;
1243 : : int ret = 0;
1244 : :
1245 : : RTE_ASSERT(!cfg_data || !pf_hw || !res_info || !res_len);
1246 : 0 : *res_len = ZXDH_MSG_REPLYBODY_HEAD;
1247 : 0 : port_attr.hit_flag = 1;
1248 : 0 : port_attr.is_vf = 1;
1249 : 0 : port_attr.phy_port = pf_hw->phyport;
1250 : 0 : port_attr.is_up = 1;
1251 : : port_attr.rss_enable = 0;
1252 : 0 : port_attr.pf_vfid = pf_hw->vfid;
1253 : 0 : port_attr.hash_search_index = pf_hw->hash_search_index;
1254 : 0 : port_attr.port_base_qid = vf_init_msg->base_qid;
1255 : 0 : uint16_t vfid = zxdh_vport_to_vfid(port);
1256 : :
1257 : 0 : ret = zxdh_set_port_attr(pf_hw, vfid, &port_attr);
1258 [ # # ]: 0 : if (ret) {
1259 : 0 : PMD_DRV_LOG(ERR, "set vport attr failed, code:%d", ret);
1260 : 0 : goto proc_end;
1261 : : }
1262 : :
1263 : : ret = zxdh_vf_promisc_init(pf_hw, port);
1264 [ # # ]: 0 : if (ret) {
1265 : 0 : PMD_DRV_LOG(ERR, "vf_promisc_table_init failed, code:%d", ret);
1266 : 0 : goto proc_end;
1267 : : }
1268 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
1269 : 0 : *res_len = sizeof(uint8_t);
1270 : :
1271 : 0 : return ret;
1272 : 0 : proc_end:
1273 : 0 : *res_len = sizeof(uint8_t);
1274 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
1275 : 0 : return ret;
1276 : : }
1277 : :
1278 : : static int
1279 : 0 : zxdh_mac_clear(struct zxdh_hw *hw, union zxdh_virport_num vport)
1280 : : {
1281 : 0 : uint16_t vf_id = vport.vfid;
1282 : : int i;
1283 : : int ret = 0;
1284 : :
1285 [ # # ]: 0 : for (i = 0; (i != ZXDH_MAX_MAC_ADDRS); ++i) {
1286 [ # # ]: 0 : if (!rte_is_zero_ether_addr(&hw->vfinfo[vf_id].vf_mac[i])) {
1287 : 0 : ret = zxdh_del_mac_table(hw, vport.vport,
1288 : : &hw->vfinfo[vf_id].vf_mac[i],
1289 : 0 : hw->hash_search_index, 0, 0);
1290 [ # # ]: 0 : if (ret) {
1291 : 0 : PMD_DRV_LOG(ERR, "vf_del_mac_failed. code:%d", ret);
1292 : 0 : return ret;
1293 : : }
1294 : 0 : memset(&hw->vfinfo[vf_id].vf_mac[i], 0, sizeof(struct rte_ether_addr));
1295 : : }
1296 : : }
1297 : : return ret;
1298 : : }
1299 : :
1300 : : static int
1301 : 0 : zxdh_vf_port_uninit(struct zxdh_hw *pf_hw,
1302 : : uint16_t vport, void *cfg_data __rte_unused,
1303 : : void *res_info, uint16_t *res_len)
1304 : : {
1305 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "uninit";
1306 : 0 : struct zxdh_port_attr_table port_attr = {0};
1307 : : union zxdh_virport_num vport_num = {.vport = vport};
1308 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, reply_data);
1309 : : int ret = 0;
1310 : :
1311 : 0 : *res_len = ZXDH_MSG_REPLYBODY_HEAD;
1312 : : RTE_ASSERT(!cfg_data || !pf_hw || !res_info || !res_len);
1313 : :
1314 : 0 : ret = zxdh_delete_port_attr(pf_hw, vport, &port_attr);
1315 [ # # ]: 0 : if (ret) {
1316 : 0 : PMD_DRV_LOG(ERR, "write port_attr_eram failed, code:%d", ret);
1317 : 0 : goto proc_end;
1318 : : }
1319 : :
1320 : 0 : ret = zxdh_mac_clear(pf_hw, vport_num);
1321 [ # # ]: 0 : if (ret) {
1322 : 0 : PMD_DRV_LOG(ERR, "zxdh_mac_clear failed, code:%d", ret);
1323 : 0 : goto proc_end;
1324 : : }
1325 : :
1326 : : ret = zxdh_vf_promisc_uninit(pf_hw, vport_num);
1327 [ # # ]: 0 : if (ret) {
1328 : 0 : PMD_DRV_LOG(ERR, "vf_promisc_table_uninit failed, code:%d", ret);
1329 : 0 : goto proc_end;
1330 : : }
1331 : :
1332 : 0 : *res_len += strlen(str);
1333 [ # # ]: 0 : rte_memcpy(reply_data_addr, str, strlen(str) + 1);
1334 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
1335 : 0 : return ret;
1336 : :
1337 : 0 : proc_end:
1338 : 0 : *res_len += strlen(str);
1339 [ # # ]: 0 : rte_memcpy(reply_data_addr, str, strlen(str) + 1);
1340 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
1341 : 0 : return ret;
1342 : : }
1343 : :
1344 : : static int
1345 : 0 : zxdh_add_vf_mac_table(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1346 : : void *reply_body, uint16_t *reply_len)
1347 : : {
1348 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "add mac";
1349 : : union zxdh_virport_num port = {0};
1350 : : struct zxdh_mac_filter *mac_filter = (struct zxdh_mac_filter *)cfg_data;
1351 : 0 : struct rte_ether_addr *addr = &mac_filter->mac;
1352 : : int i = 0, ret = 0;
1353 : : uint16_t vf_id = port.vfid;
1354 : : port.vport = vport;
1355 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply_body, reply_data);
1356 : : void *mac_reply_msg_addr = ZXDH_ADDR_OF(msg_reply_body, reply_body, mac_reply_msg);
1357 : :
1358 [ # # ]: 0 : for (i = 0; i < ZXDH_MAX_MAC_ADDRS; i++)
1359 [ # # ]: 0 : if (rte_is_same_ether_addr(&hw->vfinfo[vf_id].vf_mac[i], addr))
1360 : 0 : goto success;
1361 : :
1362 : 0 : ret = zxdh_add_mac_table(hw, vport, addr, hw->hash_search_index, 0, 0);
1363 [ # # ]: 0 : if (ret == -EADDRINUSE) {
1364 : 0 : ZXDH_SET(mac_reply_msg, mac_reply_msg_addr, mac_flag, ZXDH_EEXIST_MAC_FLAG);
1365 : 0 : PMD_DRV_LOG(ERR, "vf vport 0x%x set mac ret 0x%x failed. mac is in used.",
1366 : : port.vport, ret);
1367 : 0 : goto failure;
1368 : : }
1369 [ # # ]: 0 : if (ret) {
1370 : : sprintf(str, "[PF GET MSG FROM VF]--VF add mac failed. code:%d\n", ret);
1371 : 0 : PMD_DRV_LOG(ERR, " %s", str);
1372 : 0 : goto failure;
1373 : : }
1374 [ # # ]: 0 : for (i = 0; i < ZXDH_MAX_MAC_ADDRS; i++) {
1375 [ # # ]: 0 : if (rte_is_zero_ether_addr(&hw->vfinfo[vf_id].vf_mac[i])) {
1376 : : memcpy(&hw->vfinfo[vf_id].vf_mac[i], addr, 6);
1377 : : break;
1378 : : }
1379 : : }
1380 : :
1381 : 0 : success:
1382 [ # # ]: 0 : sprintf(str, " vport 0x%x set mac ret 0x%x\n", port.vport, ret);
1383 : 0 : *reply_len = strlen(str) + ZXDH_MSG_REPLYBODY_HEAD;
1384 [ # # ]: 0 : rte_memcpy(reply_data_addr, str, strlen(str) + 1);
1385 : 0 : ZXDH_SET(msg_reply_body, reply_body, flag, ZXDH_REPS_SUCC);
1386 : 0 : PMD_DRV_LOG(DEBUG, " reply len %d", *reply_len);
1387 : 0 : return ret;
1388 : :
1389 : 0 : failure:
1390 : 0 : *reply_len = strlen(str) + ZXDH_MSG_REPLYBODY_HEAD;
1391 : 0 : ZXDH_SET(msg_reply_body, reply_body, flag, ZXDH_REPS_FAIL);
1392 : 0 : return ret;
1393 : : }
1394 : :
1395 : : static int
1396 : 0 : zxdh_del_vf_mac_table(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1397 : : void *res_info, uint16_t *res_len)
1398 : : {
1399 : : int ret, i = 0;
1400 : : struct zxdh_mac_filter *mac_filter = (struct zxdh_mac_filter *)cfg_data;
1401 : : union zxdh_virport_num port = (union zxdh_virport_num)vport;
1402 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "del mac";
1403 : : uint16_t vf_id = port.vfid;
1404 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, reply_data);
1405 : :
1406 : 0 : PMD_DRV_LOG(DEBUG, "[PF GET MSG FROM VF]--vf mac to del.");
1407 : 0 : ret = zxdh_del_mac_table(hw, vport, &mac_filter->mac, hw->hash_search_index, 0, 0);
1408 [ # # ]: 0 : if (ret == -EADDRINUSE)
1409 : : ret = 0;
1410 : :
1411 [ # # ]: 0 : if (ret) {
1412 : : sprintf(str, "[PF GET MSG FROM VF]--VF del mac failed. code:%d\n", ret);
1413 : 0 : PMD_DRV_LOG(ERR, "%s", str);
1414 : 0 : goto proc_end;
1415 : : }
1416 : :
1417 [ # # ]: 0 : for (i = 0; i < ZXDH_MAX_MAC_ADDRS; i++) {
1418 [ # # ]: 0 : if (rte_is_same_ether_addr(&hw->vfinfo[vf_id].vf_mac[i], &mac_filter->mac))
1419 : : memset(&hw->vfinfo[vf_id].vf_mac[i], 0, sizeof(struct rte_ether_addr));
1420 : : }
1421 : :
1422 : : sprintf(str, "vport 0x%x del mac ret 0x%x\n", port.vport, ret);
1423 : 0 : *res_len = strlen(str) + ZXDH_MSG_REPLYBODY_HEAD;
1424 [ # # ]: 0 : rte_memcpy(reply_data_addr, str, strlen(str) + 1);
1425 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
1426 : 0 : return ret;
1427 : :
1428 : : proc_end:
1429 : 0 : *res_len = strlen(str) + ZXDH_MSG_REPLYBODY_HEAD;
1430 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
1431 : 0 : return ret;
1432 : : }
1433 : :
1434 : : static int
1435 : 0 : zxdh_vf_promisc_set(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1436 : : void *reply, uint16_t *res_len)
1437 : : {
1438 : : struct zxdh_port_promisc_msg *promisc_msg = (struct zxdh_port_promisc_msg *)cfg_data;
1439 : : int ret = 0;
1440 : :
1441 : : RTE_ASSERT(!cfg_data || !hw || !reply || !res_len);
1442 : :
1443 [ # # ]: 0 : if (promisc_msg->mode == ZXDH_PROMISC_MODE) {
1444 : 0 : zxdh_dev_unicast_table_set(hw, vport, promisc_msg->value);
1445 [ # # ]: 0 : if (promisc_msg->mc_follow == 1)
1446 : 0 : ret = zxdh_dev_multicast_table_set(hw, vport, promisc_msg->value);
1447 [ # # ]: 0 : } else if (promisc_msg->mode == ZXDH_ALLMULTI_MODE) {
1448 : 0 : ret = zxdh_dev_multicast_table_set(hw, vport, promisc_msg->value);
1449 : : } else {
1450 : 0 : PMD_DRV_LOG(ERR, "promisc_set_msg mode[%u] error", promisc_msg->mode);
1451 : 0 : goto proc_end;
1452 : : }
1453 : :
1454 : 0 : *res_len = sizeof(struct zxdh_port_attr_set_msg) + sizeof(uint8_t);
1455 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
1456 : :
1457 : 0 : return ret;
1458 : :
1459 : : proc_end:
1460 : 0 : *res_len = sizeof(struct zxdh_port_attr_set_msg) + sizeof(uint8_t);
1461 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
1462 : 0 : return ret;
1463 : : }
1464 : :
1465 : : static int
1466 : 0 : zxdh_vf_vlan_filter_table_process(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1467 : : void *res_info, uint16_t *res_len, uint8_t enable)
1468 : : {
1469 : : struct zxdh_vlan_filter *vlan_filter = cfg_data;
1470 : 0 : uint16_t vlan_id = vlan_filter->vlan_id;
1471 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "vlan filter table";
1472 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, reply_data);
1473 : : int ret = 0;
1474 : :
1475 : 0 : ret = zxdh_vlan_filter_table_set(hw, vport, vlan_id, enable);
1476 [ # # ]: 0 : if (ret)
1477 : : sprintf(str, "vlan filter op-code[%d] vlan id:%d failed, code:%d\n",
1478 : : enable, vlan_id, ret);
1479 : :
1480 : 0 : *res_len = strlen(str) + sizeof(uint8_t);
1481 : :
1482 [ # # ]: 0 : memcpy(reply_data_addr, str, strlen(str) + 1);
1483 [ # # ]: 0 : if (ret == 0)
1484 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
1485 : : else
1486 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
1487 : 0 : return ret;
1488 : : }
1489 : :
1490 : : static int
1491 : 0 : zxdh_vf_vlan_filter_table_add(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1492 : : void *res_info, uint16_t *res_len)
1493 : : {
1494 : 0 : return zxdh_vf_vlan_filter_table_process(hw, vport, cfg_data, res_info, res_len, 1);
1495 : : }
1496 : :
1497 : : static int
1498 : 0 : zxdh_vf_vlan_filter_table_del(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1499 : : void *res_info, uint16_t *res_len)
1500 : : {
1501 : 0 : return zxdh_vf_vlan_filter_table_process(hw, vport, cfg_data, res_info, res_len, 0);
1502 : : }
1503 : :
1504 : : static int
1505 : 0 : zxdh_vf_set_vlan_filter(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1506 : : void *reply, uint16_t *res_len)
1507 : : {
1508 : : struct zxdh_vlan_filter_set *vlan_filter = cfg_data;
1509 : : union zxdh_virport_num port = (union zxdh_virport_num)vport;
1510 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "vlan filter";
1511 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
1512 : : int ret = 0;
1513 : : uint16_t vfid = port.vfid;
1514 : :
1515 : 0 : ret = zxdh_set_vlan_filter(hw, vport, vlan_filter->enable);
1516 [ # # ]: 0 : if (ret)
1517 : 0 : sprintf(str, "[vfid:%d] vlan filter. set failed, ret:%d\n", vfid, ret);
1518 : :
1519 : 0 : *res_len = strlen(str) + sizeof(uint8_t);
1520 [ # # ]: 0 : if (ret == 0)
1521 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
1522 : : else
1523 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
1524 : 0 : memcpy(reply_data_addr, str, strlen(str) + 1);
1525 : 0 : return ret;
1526 : : }
1527 : :
1528 : : static int
1529 : 0 : zxdh_vf_set_vlan_offload(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1530 : : void *reply, uint16_t *res_len)
1531 : : {
1532 : : struct zxdh_vlan_offload *vlan_offload = cfg_data;
1533 : : union zxdh_virport_num port = (union zxdh_virport_num)vport;
1534 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "vlan offload";
1535 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
1536 : : int ret = 0;
1537 : : uint16_t vfid = port.vfid;
1538 : :
1539 [ # # ]: 0 : PMD_DRV_LOG(DEBUG, "vfid:%d, type:%s, enable:%d",
1540 : : vfid, vlan_offload->type == ZXDH_VLAN_STRIP_TYPE ? "vlan-strip" : "qinq-strip",
1541 : : vlan_offload->enable);
1542 : 0 : ret = zxdh_set_vlan_offload(hw, vport, vlan_offload->type, vlan_offload->enable);
1543 [ # # ]: 0 : if (ret)
1544 : : sprintf(str, "[vfid:%d] vlan offload set failed, ret:%d\n", vfid, ret);
1545 : :
1546 : 0 : *res_len = strlen(str) + sizeof(uint8_t);
1547 [ # # ]: 0 : if (ret == 0)
1548 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
1549 : : else
1550 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
1551 : 0 : memcpy(reply_data_addr, str, strlen(str) + 1);
1552 : 0 : return ret;
1553 : : }
1554 : :
1555 : : static int
1556 : 0 : zxdh_vf_rss_hf_get(struct zxdh_hw *hw, uint16_t vport, void *cfg_data __rte_unused,
1557 : : void *reply, uint16_t *res_len)
1558 : : {
1559 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_hf";
1560 : 0 : struct zxdh_port_attr_table vport_att = {0};
1561 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
1562 : : void *rss_hf_msg_addr = ZXDH_ADDR_OF(msg_reply_body, reply, rss_hf_msg);
1563 : : int ret = 0;
1564 : :
1565 : 0 : ret = zxdh_get_port_attr(hw, vport, &vport_att);
1566 [ # # ]: 0 : if (ret) {
1567 : : sprintf(str, "get rss hash factor failed, ret:%d\n", ret);
1568 : 0 : PMD_DRV_LOG(ERR, "get rss hash factor failed.");
1569 : 0 : goto proc_end;
1570 : : }
1571 : :
1572 : 0 : ZXDH_SET(rss_hf, rss_hf_msg_addr, rss_hf, vport_att.rss_hash_factor);
1573 : :
1574 : 0 : proc_end:
1575 : 0 : *res_len = strlen(str) + sizeof(uint8_t);
1576 [ # # ]: 0 : if (ret == 0)
1577 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
1578 : : else
1579 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
1580 : 0 : memcpy(reply_data_addr, str, strlen(str) + 1);
1581 : 0 : return ret;
1582 : : }
1583 : :
1584 : : static int
1585 : 0 : zxdh_vf_rss_hf_set(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1586 : : void *reply, uint16_t *res_len)
1587 : : {
1588 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_hf";
1589 : : struct zxdh_rss_hf *rss_hf = cfg_data;
1590 : 0 : struct zxdh_port_attr_table vport_att = {0};
1591 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
1592 : : int ret = 0;
1593 : :
1594 : 0 : ret = zxdh_get_port_attr(hw, vport, &vport_att);
1595 [ # # ]: 0 : if (ret) {
1596 : 0 : sprintf(str, "set rss hash factor (set vport tbl failed, hf is %d). ret:%d\n",
1597 : : rss_hf->rss_hf, ret);
1598 : 0 : PMD_DRV_LOG(ERR, "rss enable hash factor set failed");
1599 : 0 : goto proc_end;
1600 : : }
1601 : :
1602 : 0 : vport_att.rss_hash_factor = rss_hf->rss_hf;
1603 : 0 : ret = zxdh_set_port_attr(hw, vport, &vport_att);
1604 [ # # ]: 0 : if (ret) {
1605 : 0 : sprintf(str, "set rss hash factor (set vport tbl failed, hf is %d). ret:%d\n",
1606 : : rss_hf->rss_hf, ret);
1607 : 0 : PMD_DRV_LOG(ERR, "rss config hf failed");
1608 : : }
1609 : :
1610 : 0 : proc_end:
1611 : 0 : *res_len = strlen(str) + sizeof(uint8_t);
1612 [ # # ]: 0 : if (ret == 0)
1613 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
1614 : : else
1615 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
1616 : 0 : memcpy(reply_data_addr, str, strlen(str) + 1);
1617 : 0 : return ret;
1618 : : }
1619 : :
1620 : : static int
1621 : 0 : zxdh_vf_rss_enable(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1622 : : void *reply, uint16_t *res_len)
1623 : : {
1624 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_enable";
1625 : : struct zxdh_rss_enable *rss_enable = cfg_data;
1626 : 0 : struct zxdh_port_attr_table vport_att = {0};
1627 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
1628 : : int ret = 0;
1629 : :
1630 : 0 : ret = zxdh_get_port_attr(hw, vport, &vport_att);
1631 [ # # ]: 0 : if (ret) {
1632 : 0 : sprintf(str, "set rss enable (get vport tbl failed, rss_enable is %d). ret:%d\n",
1633 : 0 : rss_enable->enable, ret);
1634 : 0 : PMD_DRV_LOG(ERR, "rss enable set failed");
1635 : 0 : goto proc_end;
1636 : : }
1637 : :
1638 : 0 : vport_att.rss_enable = rss_enable->enable;
1639 : 0 : ret = zxdh_set_port_attr(hw, vport, &vport_att);
1640 [ # # ]: 0 : if (ret) {
1641 : 0 : sprintf(str, "set rss enable (set vport tbl failed, rss_enable is %d). ret:%d\n",
1642 : 0 : rss_enable->enable, ret);
1643 : 0 : PMD_DRV_LOG(ERR, "rss enable set failed");
1644 : : }
1645 : :
1646 : 0 : proc_end:
1647 : 0 : *res_len = strlen(str) + sizeof(uint8_t);
1648 [ # # ]: 0 : if (ret == 0)
1649 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
1650 : : else
1651 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
1652 : 0 : memcpy(reply_data_addr, str, strlen(str) + 1);
1653 : 0 : return ret;
1654 : : }
1655 : :
1656 : : static int
1657 : 0 : zxdh_vf_rss_table_set(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
1658 : : void *reply, uint16_t *res_len)
1659 : : {
1660 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_table";
1661 : : struct zxdh_rss_reta *rss_reta = cfg_data;
1662 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
1663 : : int32_t ret = 0;
1664 : :
1665 : 0 : ret = zxdh_rss_table_set(hw, vport, rss_reta);
1666 [ # # ]: 0 : if (ret)
1667 : : sprintf(str, "set rss reta tbl failed, code:%d", ret);
1668 : :
1669 : 0 : *res_len = strlen(str) + sizeof(uint8_t);
1670 [ # # ]: 0 : if (ret == 0)
1671 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
1672 : : else
1673 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
1674 : 0 : memcpy(reply_data_addr, str, strlen(str) + 1);
1675 : 0 : return ret;
1676 : : }
1677 : :
1678 : : static int
1679 : 0 : zxdh_vf_rss_table_get(struct zxdh_hw *hw, uint16_t vport, void *cfg_data __rte_unused,
1680 : : void *reply, uint16_t *res_len)
1681 : : {
1682 : 0 : char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_table";
1683 : 0 : void *rss_reta_msg_addr = ZXDH_ADDR_OF(msg_reply_body, reply, rss_reta_msg);
1684 : : struct zxdh_rss_reta *rss_reta = (struct zxdh_rss_reta *)rss_reta_msg_addr;
1685 : : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
1686 : : int ret = 0;
1687 : :
1688 : 0 : ret = zxdh_rss_table_get(hw, vport, rss_reta);
1689 [ # # ]: 0 : if (ret)
1690 : : sprintf(str, "set rss reta tbl failed, code:%d", ret);
1691 : :
1692 : 0 : *res_len = strlen(str) + sizeof(uint8_t);
1693 [ # # ]: 0 : if (ret == 0)
1694 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
1695 : : else
1696 : 0 : ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
1697 : 0 : memcpy(reply_data_addr, str, strlen(str) + 1);
1698 : 0 : return ret;
1699 : : }
1700 : :
1701 : : static int
1702 : 0 : zxdh_vf_port_attr_set(struct zxdh_hw *pf_hw, uint16_t vport, void *cfg_data,
1703 : : void *res_info, uint16_t *res_len)
1704 : : {
1705 : : RTE_ASSERT(!cfg_data || !pf_hw);
1706 [ # # ]: 0 : if (res_info)
1707 : 0 : *res_len = 0;
1708 : : struct zxdh_port_attr_set_msg *attr_msg = (struct zxdh_port_attr_set_msg *)cfg_data;
1709 : : union zxdh_virport_num port = {.vport = vport};
1710 : 0 : struct zxdh_port_attr_table port_attr = {0};
1711 : :
1712 : 0 : int ret = zxdh_get_port_attr(pf_hw, vport, &port_attr);
1713 [ # # ]: 0 : if (ret) {
1714 : 0 : PMD_DRV_LOG(ERR, "get vport 0x%x(%d) attr failed", vport, port.vfid);
1715 : 0 : return ret;
1716 : : }
1717 [ # # # # : 0 : switch (attr_msg->mode) {
# # # # #
# # # ]
1718 : 0 : case ZXDH_PORT_BASE_QID_FLAG:
1719 : 0 : port_attr.port_base_qid = attr_msg->value;
1720 : 0 : break;
1721 : 0 : case ZXDH_PORT_MTU_OFFLOAD_EN_OFF_FLAG:
1722 : 0 : port_attr.mtu_enable = attr_msg->value;
1723 : 0 : break;
1724 : 0 : case ZXDH_PORT_MTU_FLAG:
1725 : 0 : port_attr.mtu = attr_msg->value;
1726 : 0 : break;
1727 : 0 : case ZXDH_PORT_VPORT_IS_UP_FLAG:
1728 : 0 : port_attr.is_up = attr_msg->value;
1729 : 0 : break;
1730 : 0 : case ZXDH_PORT_OUTER_IP_CHECKSUM_OFFLOAD_FLAG:
1731 : 0 : port_attr.outer_ip_checksum_offload = attr_msg->value;
1732 : 0 : break;
1733 : 0 : case ZXDH_PORT_IP_CHKSUM_FLAG:
1734 : 0 : port_attr.ip_checksum_offload = attr_msg->value;
1735 : 0 : break;
1736 : 0 : case ZXDH_PORT_TCP_UDP_CHKSUM_FLAG:
1737 : 0 : port_attr.tcp_udp_checksum_offload = attr_msg->value;
1738 : 0 : break;
1739 : 0 : case ZXDH_PORT_ACCELERATOR_OFFLOAD_FLAG_FLAG:
1740 : 0 : port_attr.accelerator_offload_flag = attr_msg->value;
1741 : 0 : break;
1742 : 0 : case ZXDH_PORT_LRO_OFFLOAD_FLAG:
1743 : 0 : port_attr.lro_offload = attr_msg->value;
1744 : 0 : break;
1745 : 0 : case ZXDH_PORT_EGRESS_METER_EN_OFF_FLAG:
1746 : 0 : port_attr.egress_meter_enable = attr_msg->value;
1747 : 0 : break;
1748 : 0 : case ZXDH_PORT_INGRESS_METER_EN_OFF_FLAG:
1749 : 0 : port_attr.ingress_meter_mode = attr_msg->value;
1750 : 0 : break;
1751 : 0 : default:
1752 : 0 : PMD_DRV_LOG(ERR, "unsupported attr 0x%x set", attr_msg->mode);
1753 : 0 : return -1;
1754 : : }
1755 : 0 : ret = zxdh_set_port_attr(pf_hw, vport, &port_attr);
1756 [ # # ]: 0 : if (ret) {
1757 : 0 : PMD_DRV_LOG(ERR, "set port attr failed. code:%d", ret);
1758 : 0 : return ret;
1759 : : }
1760 : : return ret;
1761 : : }
1762 : :
1763 : : static int
1764 : 0 : zxdh_vf_np_stats_update(struct zxdh_hw *pf_hw, uint16_t vport,
1765 : : void *cfg_data, void *res_info,
1766 : : uint16_t *res_len)
1767 : : {
1768 : : struct zxdh_np_stats_updata_msg *np_stats_query =
1769 : : (struct zxdh_np_stats_updata_msg *)cfg_data;
1770 : 0 : union zxdh_virport_num vport_num = {.vport = vport};
1771 : : struct zxdh_hw_stats_data stats_data;
1772 : 0 : uint32_t is_clr = np_stats_query->clear_mode;
1773 : : uint32_t idx = 0;
1774 : : int ret = 0;
1775 : :
1776 : 0 : void *hw_stats_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, hw_stats);
1777 : 0 : void *tx_unicast_pkts_addr =
1778 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_unicast_pkts);
1779 : : void *rx_unicast_pkts_addr =
1780 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_unicast_pkts);
1781 : 0 : void *tx_unicast_bytes_addr =
1782 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_unicast_bytes);
1783 : 0 : void *rx_unicast_bytes_addr =
1784 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_unicast_bytes);
1785 : 0 : void *tx_multicast_pkts_addr =
1786 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_multicast_pkts);
1787 : 0 : void *rx_multicast_pkts_addr =
1788 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_multicast_pkts);
1789 : 0 : void *tx_multicast_bytes_addr =
1790 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_multicast_bytes);
1791 : 0 : void *rx_multicast_bytes_addr =
1792 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_multicast_bytes);
1793 : 0 : void *tx_broadcast_pkts_addr =
1794 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_broadcast_pkts);
1795 : 0 : void *tx_broadcast_bytes_addr =
1796 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_broadcast_bytes);
1797 : 0 : void *rx_broadcast_pkts_addr =
1798 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_broadcast_pkts);
1799 : 0 : void *rx_broadcast_bytes_addr =
1800 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_broadcast_bytes);
1801 : 0 : void *tx_mtu_drop_pkts_addr =
1802 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_mtu_drop_pkts);
1803 : 0 : void *tx_mtu_drop_bytes_addr =
1804 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_mtu_drop_bytes);
1805 : 0 : void *rx_mtu_drop_pkts_addr =
1806 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_mtu_drop_pkts);
1807 : 0 : void *rx_mtu_drop_bytes_addr =
1808 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_mtu_drop_bytes);
1809 : 0 : void *tx_mtr_drop_pkts_addr =
1810 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_mtr_drop_pkts);
1811 : 0 : void *tx_mtr_drop_bytes_addr =
1812 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_mtr_drop_bytes);
1813 : 0 : void *rx_mtr_drop_pkts_addr =
1814 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_mtr_drop_pkts);
1815 : 0 : void *rx_mtr_drop_bytes_addr =
1816 : : ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_mtr_drop_bytes);
1817 [ # # ]: 0 : if (!res_len || !res_info) {
1818 : 0 : PMD_DRV_LOG(ERR, "get stat invalid inparams");
1819 : 0 : return -1;
1820 : : }
1821 [ # # ]: 0 : if (is_clr == 1) {
1822 : 0 : ret = zxdh_hw_np_stats_pf_reset(pf_hw->eth_dev, zxdh_vport_to_vfid(vport_num));
1823 : 0 : return ret;
1824 : : }
1825 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_UNICAST_STATS_EGRESS_BASE;
1826 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1827 : : 0, idx, (uint32_t *)&stats_data);
1828 [ # # ]: 0 : if (ret) {
1829 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1830 : 0 : return ret;
1831 : : }
1832 : 0 : zxdh_data_hi_to_lo(tx_unicast_pkts_addr);
1833 : 0 : zxdh_data_hi_to_lo(tx_unicast_bytes_addr);
1834 : :
1835 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_UNICAST_STATS_INGRESS_BASE;
1836 : : memset(&stats_data, 0, sizeof(stats_data));
1837 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1838 : : 0, idx, (uint32_t *)&stats_data);
1839 [ # # ]: 0 : if (ret) {
1840 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1841 : 0 : return ret;
1842 : : }
1843 : 0 : zxdh_data_hi_to_lo(rx_unicast_pkts_addr);
1844 : 0 : zxdh_data_hi_to_lo(rx_unicast_bytes_addr);
1845 : :
1846 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MULTICAST_STATS_EGRESS_BASE;
1847 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1848 : : 0, idx, (uint32_t *)&stats_data);
1849 [ # # ]: 0 : if (ret) {
1850 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1851 : 0 : return ret;
1852 : : }
1853 : 0 : zxdh_data_hi_to_lo(tx_multicast_pkts_addr);
1854 : 0 : zxdh_data_hi_to_lo(tx_multicast_bytes_addr);
1855 : :
1856 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MULTICAST_STATS_INGRESS_BASE;
1857 : : memset(&stats_data, 0, sizeof(stats_data));
1858 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1859 : : 0, idx, (uint32_t *)&stats_data);
1860 [ # # ]: 0 : if (ret) {
1861 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1862 : 0 : return ret;
1863 : : }
1864 : 0 : zxdh_data_hi_to_lo(rx_multicast_pkts_addr);
1865 : 0 : zxdh_data_hi_to_lo(rx_multicast_bytes_addr);
1866 : :
1867 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_BROAD_STATS_EGRESS_BASE;
1868 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1869 : : 0, idx, (uint32_t *)&stats_data);
1870 [ # # ]: 0 : if (ret) {
1871 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1872 : 0 : return ret;
1873 : : }
1874 : 0 : zxdh_data_hi_to_lo(tx_broadcast_pkts_addr);
1875 : 0 : zxdh_data_hi_to_lo(tx_broadcast_bytes_addr);
1876 : :
1877 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_BROAD_STATS_INGRESS_BASE;
1878 : : memset(&stats_data, 0, sizeof(stats_data));
1879 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1880 : : 0, idx, (uint32_t *)&stats_data);
1881 [ # # ]: 0 : if (ret) {
1882 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1883 : 0 : return ret;
1884 : : }
1885 : 0 : zxdh_data_hi_to_lo(rx_broadcast_pkts_addr);
1886 : 0 : zxdh_data_hi_to_lo(rx_broadcast_bytes_addr);
1887 : :
1888 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTU_STATS_EGRESS_BASE;
1889 : : memset(&stats_data, 0, sizeof(stats_data));
1890 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1891 : : 1, idx, (uint32_t *)&stats_data);
1892 [ # # ]: 0 : if (ret) {
1893 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1894 : 0 : return ret;
1895 : : }
1896 : 0 : ZXDH_SET(hw_np_stats, hw_stats_addr, tx_mtu_drop_pkts, stats_data.n_pkts_dropped);
1897 : 0 : ZXDH_SET(hw_np_stats, hw_stats_addr, tx_mtu_drop_bytes, stats_data.n_bytes_dropped);
1898 : 0 : zxdh_data_hi_to_lo(tx_mtu_drop_pkts_addr);
1899 : 0 : zxdh_data_hi_to_lo(tx_mtu_drop_bytes_addr);
1900 : :
1901 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTU_STATS_INGRESS_BASE;
1902 : : memset(&stats_data, 0, sizeof(stats_data));
1903 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1904 : : 1, idx, (uint32_t *)&stats_data);
1905 [ # # ]: 0 : if (ret) {
1906 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1907 : 0 : return ret;
1908 : : }
1909 : 0 : ZXDH_SET(hw_np_stats, hw_stats_addr, rx_mtu_drop_pkts, stats_data.n_pkts_dropped);
1910 : 0 : ZXDH_SET(hw_np_stats, hw_stats_addr, rx_mtu_drop_bytes, stats_data.n_bytes_dropped);
1911 : 0 : zxdh_data_hi_to_lo(rx_mtu_drop_pkts_addr);
1912 : 0 : zxdh_data_hi_to_lo(rx_mtu_drop_bytes_addr);
1913 : :
1914 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTR_STATS_EGRESS_BASE;
1915 : : memset(&stats_data, 0, sizeof(stats_data));
1916 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1917 : : 1, idx, (uint32_t *)&stats_data);
1918 [ # # ]: 0 : if (ret) {
1919 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1920 : 0 : return ret;
1921 : : }
1922 : 0 : ZXDH_SET(hw_np_stats, hw_stats_addr, tx_mtr_drop_pkts, stats_data.n_pkts_dropped);
1923 : 0 : ZXDH_SET(hw_np_stats, hw_stats_addr, tx_mtr_drop_bytes, stats_data.n_bytes_dropped);
1924 : :
1925 : 0 : zxdh_data_hi_to_lo(tx_mtr_drop_pkts_addr);
1926 : 0 : zxdh_data_hi_to_lo(tx_mtr_drop_bytes_addr);
1927 : :
1928 : 0 : idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTR_STATS_INGRESS_BASE;
1929 : : memset(&stats_data, 0, sizeof(stats_data));
1930 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1931 : : 1, idx, (uint32_t *)&stats_data);
1932 [ # # ]: 0 : if (ret) {
1933 : 0 : PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
1934 : 0 : return ret;
1935 : : }
1936 : 0 : ZXDH_SET(hw_np_stats, hw_stats_addr, rx_mtr_drop_pkts, stats_data.n_pkts_dropped);
1937 : 0 : ZXDH_SET(hw_np_stats, hw_stats_addr, rx_mtr_drop_bytes, stats_data.n_bytes_dropped);
1938 : :
1939 : 0 : zxdh_data_hi_to_lo(rx_mtr_drop_pkts_addr);
1940 : 0 : zxdh_data_hi_to_lo(rx_mtr_drop_bytes_addr);
1941 : 0 : *res_len = sizeof(struct zxdh_hw_np_stats);
1942 : :
1943 : 0 : return 0;
1944 : : }
1945 : :
1946 : : static int
1947 : 0 : zxdh_vf_mtr_hw_stats_get(struct zxdh_hw *pf_hw,
1948 : : uint16_t vport, void *cfg_data,
1949 : : void *res_info,
1950 : : uint16_t *res_len)
1951 : : {
1952 : : struct zxdh_mtr_stats_query *zxdh_mtr_stats_query =
1953 : : (struct zxdh_mtr_stats_query *)cfg_data;
1954 : 0 : union zxdh_virport_num v_port = {.vport = vport};
1955 : 0 : uint8_t *hw_mtr_stats_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, hw_mtr_stats);
1956 : : int ret = 0;
1957 : :
1958 : 0 : uint32_t stat_baseaddr = zxdh_mtr_stats_query->direction ==
1959 : : ZXDH_EGRESS ?
1960 [ # # ]: 0 : ZXDH_MTR_STATS_EGRESS_BASE : ZXDH_MTR_STATS_INGRESS_BASE;
1961 : 0 : uint32_t idx = zxdh_vport_to_vfid(v_port) + stat_baseaddr;
1962 : :
1963 [ # # ]: 0 : if (!res_len || !res_info) {
1964 : 0 : PMD_DRV_LOG(ERR, "get stat invalid in params");
1965 : 0 : return -1;
1966 : : }
1967 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
1968 : 0 : ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
1969 : : 1, idx, (uint32_t *)hw_mtr_stats_addr);
1970 [ # # ]: 0 : if (ret) {
1971 : 0 : PMD_DRV_LOG(ERR, "get dir %d stats failed", zxdh_mtr_stats_query->direction);
1972 : 0 : return ret;
1973 : : }
1974 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
1975 : 0 : *res_len = sizeof(struct zxdh_hw_mtr_stats);
1976 : 0 : return 0;
1977 : : }
1978 : :
1979 : : static int
1980 : 0 : zxdh_vf_mtr_hw_profile_add(struct zxdh_hw *pf_hw,
1981 : : uint16_t vport,
1982 : : void *cfg_data,
1983 : : void *res_info,
1984 : : uint16_t *res_len)
1985 : : {
1986 [ # # # # ]: 0 : if (!cfg_data || !res_len || !res_info) {
1987 : 0 : PMD_DRV_LOG(ERR, " get profileid invalid inparams");
1988 : 0 : return -1;
1989 : : }
1990 : 0 : struct rte_mtr_error error = {0};
1991 : : int ret = 0;
1992 : 0 : uint64_t hw_profile_id = HW_PROFILE_MAX;
1993 : 0 : void *mtr_profile_info_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, mtr_profile_info);
1994 : :
1995 : : struct zxdh_plcr_profile_add *zxdh_plcr_profile_add =
1996 : : (struct zxdh_plcr_profile_add *)cfg_data;
1997 : :
1998 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
1999 : :
2000 : 0 : *res_len = sizeof(struct zxdh_mtr_profile_info);
2001 : 0 : ret = zxdh_hw_profile_alloc_direct(pf_hw->eth_dev,
2002 : 0 : zxdh_plcr_profile_add->car_type,
2003 : : &hw_profile_id, &error);
2004 : :
2005 [ # # ]: 0 : if (ret) {
2006 : 0 : PMD_DRV_LOG(ERR, "pf 0x%x for vf 0x%x alloc hw profile failed",
2007 : : pf_hw->vport.vport,
2008 : : vport
2009 : : );
2010 : 0 : return -1;
2011 : : }
2012 : 0 : zxdh_hw_profile_ref(hw_profile_id);
2013 : 0 : ZXDH_SET(mtr_profile_info, mtr_profile_info_addr, profile_id, hw_profile_id);
2014 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
2015 : :
2016 : 0 : return 0;
2017 : : }
2018 : :
2019 : : static int
2020 : 0 : zxdh_vf_mtr_hw_profile_del(struct zxdh_hw *pf_hw,
2021 : : uint16_t vport,
2022 : : void *cfg_data,
2023 : : void *res_info,
2024 : : uint16_t *res_len)
2025 : : {
2026 [ # # # # ]: 0 : if (!cfg_data || !res_len || !res_info) {
2027 : 0 : PMD_DRV_LOG(ERR, " del profileid invalid inparams");
2028 : 0 : return -1;
2029 : : }
2030 : :
2031 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
2032 : 0 : *res_len = 0;
2033 : : struct zxdh_plcr_profile_free *mtr_profile_free = (struct zxdh_plcr_profile_free *)cfg_data;
2034 : 0 : uint64_t profile_id = mtr_profile_free->profile_id;
2035 : 0 : struct rte_mtr_error error = {0};
2036 : : int ret;
2037 : :
2038 [ # # ]: 0 : if (profile_id >= HW_PROFILE_MAX) {
2039 : 0 : PMD_DRV_LOG(ERR, " del profileid invalid inparams");
2040 : 0 : return -rte_mtr_error_set(&error, ENOTSUP,
2041 : : RTE_MTR_ERROR_TYPE_METER_PROFILE_ID, NULL,
2042 : : "Meter offload del profile failed profilie id invalid ");
2043 : : }
2044 : :
2045 : 0 : ret = zxdh_hw_profile_unref(pf_hw->eth_dev, mtr_profile_free->car_type, profile_id, &error);
2046 [ # # ]: 0 : if (ret) {
2047 : 0 : PMD_DRV_LOG(ERR,
2048 : : " del hw vport %d profile %d failed. code:%d",
2049 : : vport,
2050 : : mtr_profile_free->profile_id,
2051 : : ret
2052 : : );
2053 : 0 : return -rte_mtr_error_set(&error, ENOTSUP,
2054 : : RTE_MTR_ERROR_TYPE_METER_PROFILE_ID, NULL,
2055 : : "Meter offload del profile failed ");
2056 : : }
2057 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
2058 : 0 : return 0;
2059 : : }
2060 : :
2061 : : static int
2062 : 0 : zxdh_vf_mtr_hw_plcrflow_cfg(struct zxdh_hw *pf_hw,
2063 : : uint16_t vport,
2064 : : void *cfg_data,
2065 : : void *res_info,
2066 : : uint16_t *res_len)
2067 : : {
2068 : : int ret = 0;
2069 : :
2070 [ # # # # ]: 0 : if (!cfg_data || !res_info || !res_len) {
2071 : 0 : PMD_DRV_LOG(ERR, " (vport %d) flow bind failed invalid inparams", vport);
2072 : 0 : return -1;
2073 : : }
2074 : : struct rte_mtr_error error = {0};
2075 : : struct zxdh_plcr_flow_cfg *zxdh_plcr_flow_cfg = (struct zxdh_plcr_flow_cfg *)cfg_data;
2076 : :
2077 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
2078 : 0 : *res_len = 0;
2079 : 0 : ret = zxdh_np_stat_car_queue_cfg_set(pf_hw->dev_id,
2080 : 0 : zxdh_plcr_flow_cfg->car_type,
2081 : 0 : zxdh_plcr_flow_cfg->flow_id,
2082 : 0 : zxdh_plcr_flow_cfg->drop_flag,
2083 : 0 : zxdh_plcr_flow_cfg->plcr_en,
2084 : 0 : (uint64_t)zxdh_plcr_flow_cfg->profile_id);
2085 [ # # ]: 0 : if (ret) {
2086 : 0 : PMD_DRV_LOG(ERR,
2087 : : " dpp_stat_car_queue_cfg_set failed flowid %d profile id %d. code:%d",
2088 : : zxdh_plcr_flow_cfg->flow_id,
2089 : : zxdh_plcr_flow_cfg->profile_id,
2090 : : ret
2091 : : );
2092 : 0 : return -rte_mtr_error_set(&error, ENOTSUP,
2093 : : RTE_MTR_ERROR_TYPE_MTR_PARAMS,
2094 : : NULL, "Failed to bind plcr flow.");
2095 : : }
2096 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
2097 : 0 : return 0;
2098 : : }
2099 : :
2100 : : static int
2101 : 0 : zxdh_vf_mtr_hw_profile_cfg(struct zxdh_hw *pf_hw __rte_unused,
2102 : : uint16_t vport,
2103 : : void *cfg_data,
2104 : : void *res_info,
2105 : : uint16_t *res_len)
2106 : : {
2107 : : int ret = 0;
2108 : :
2109 [ # # # # ]: 0 : if (!cfg_data || !res_info || !res_len) {
2110 : 0 : PMD_DRV_LOG(ERR, " cfg profile invalid inparams");
2111 : 0 : return -1;
2112 : : }
2113 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
2114 : 0 : *res_len = 0;
2115 : : struct rte_mtr_error error = {0};
2116 : : struct zxdh_plcr_profile_cfg *zxdh_plcr_profile_cfg =
2117 : : (struct zxdh_plcr_profile_cfg *)cfg_data;
2118 : 0 : union zxdh_offload_profile_cfg *plcr_param = &zxdh_plcr_profile_cfg->plcr_param;
2119 : :
2120 : 0 : ret = zxdh_np_car_profile_cfg_set(pf_hw->dev_id,
2121 : : vport,
2122 : 0 : zxdh_plcr_profile_cfg->car_type,
2123 : 0 : zxdh_plcr_profile_cfg->packet_mode,
2124 : 0 : zxdh_plcr_profile_cfg->hw_profile_id,
2125 : : plcr_param);
2126 [ # # ]: 0 : if (ret) {
2127 : 0 : PMD_DRV_LOG(ERR, "(vport %d)config hw profilefailed", vport);
2128 : 0 : return -rte_mtr_error_set(&error, ENOTSUP, RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL, "Meter offload cfg profile failed");
2129 : : }
2130 : 0 : ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
2131 : 0 : return 0;
2132 : : }
2133 : :
2134 : : static const zxdh_msg_process_callback zxdh_proc_cb[] = {
2135 : : [ZXDH_NULL] = NULL,
2136 : : [ZXDH_VF_PORT_INIT] = zxdh_vf_port_init,
2137 : : [ZXDH_VF_PORT_UNINIT] = zxdh_vf_port_uninit,
2138 : : [ZXDH_MAC_ADD] = zxdh_add_vf_mac_table,
2139 : : [ZXDH_MAC_DEL] = zxdh_del_vf_mac_table,
2140 : : [ZXDH_PORT_PROMISC_SET] = zxdh_vf_promisc_set,
2141 : : [ZXDH_VLAN_FILTER_SET] = zxdh_vf_set_vlan_filter,
2142 : : [ZXDH_VLAN_FILTER_ADD] = zxdh_vf_vlan_filter_table_add,
2143 : : [ZXDH_VLAN_FILTER_DEL] = zxdh_vf_vlan_filter_table_del,
2144 : : [ZXDH_VLAN_OFFLOAD] = zxdh_vf_set_vlan_offload,
2145 : : [ZXDH_RSS_ENABLE] = zxdh_vf_rss_enable,
2146 : : [ZXDH_RSS_RETA_GET] = zxdh_vf_rss_table_get,
2147 : : [ZXDH_RSS_RETA_SET] = zxdh_vf_rss_table_set,
2148 : : [ZXDH_RSS_HF_SET] = zxdh_vf_rss_hf_set,
2149 : : [ZXDH_RSS_HF_GET] = zxdh_vf_rss_hf_get,
2150 : : [ZXDH_PORT_ATTRS_SET] = zxdh_vf_port_attr_set,
2151 : : [ZXDH_GET_NP_STATS] = zxdh_vf_np_stats_update,
2152 : : [ZXDH_PORT_METER_STAT_GET] = zxdh_vf_mtr_hw_stats_get,
2153 : : [ZXDH_PLCR_CAR_PROFILE_ID_ADD] = zxdh_vf_mtr_hw_profile_add,
2154 : : [ZXDH_PLCR_CAR_PROFILE_ID_DELETE] = zxdh_vf_mtr_hw_profile_del,
2155 : : [ZXDH_PLCR_CAR_QUEUE_CFG_SET] = zxdh_vf_mtr_hw_plcrflow_cfg,
2156 : : [ZXDH_PLCR_CAR_PROFILE_CFG_SET] = zxdh_vf_mtr_hw_profile_cfg,
2157 : : };
2158 : :
2159 : : static inline int
2160 : 0 : zxdh_config_process_callback(struct zxdh_hw *hw, struct zxdh_msg_info *msg_info,
2161 : : void *res, uint16_t *res_len)
2162 : : {
2163 : : struct zxdh_msg_head *msghead = &msg_info->msg_head;
2164 : : int ret = -1;
2165 : :
2166 [ # # ]: 0 : if (!res || !res_len) {
2167 : 0 : PMD_DRV_LOG(ERR, " invalid param");
2168 : 0 : return -1;
2169 : : }
2170 [ # # ]: 0 : if (zxdh_proc_cb[msghead->msg_type]) {
2171 : 0 : ret = zxdh_proc_cb[msghead->msg_type](hw, msghead->vport,
2172 : 0 : (void *)&msg_info->data, res, res_len);
2173 [ # # ]: 0 : if (!ret)
2174 : 0 : ZXDH_SET(msg_reply_body, res, flag, ZXDH_REPS_SUCC);
2175 : : else
2176 : 0 : ZXDH_SET(msg_reply_body, res, flag, ZXDH_REPS_FAIL);
2177 : : } else {
2178 : 0 : ZXDH_SET(msg_reply_body, res, flag, ZXDH_REPS_INVALID);
2179 : : }
2180 : 0 : *res_len += sizeof(uint8_t);
2181 : 0 : return ret;
2182 : : }
2183 : :
2184 : : static int
2185 : 0 : pf_recv_bar_msg(void *pay_load, uint16_t len, void *reps_buffer,
2186 : : uint16_t *reps_len, void *eth_dev)
2187 : : {
2188 : : struct zxdh_msg_info *msg_info = (struct zxdh_msg_info *)pay_load;
2189 : 0 : void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reps_buffer, reply_data);
2190 : : struct rte_eth_dev *dev = (struct rte_eth_dev *)eth_dev;
2191 : 0 : int32_t ret = 0;
2192 : : struct zxdh_hw *hw;
2193 : 0 : uint16_t reply_len = 0;
2194 : :
2195 [ # # ]: 0 : if (eth_dev == NULL) {
2196 : 0 : PMD_DRV_LOG(ERR, "param invalid, dev is null.");
2197 : 0 : ret = -2;
2198 : 0 : goto msg_proc_end;
2199 : : }
2200 : 0 : hw = dev->data->dev_private;
2201 : :
2202 [ # # ]: 0 : if (msg_info->msg_head.msg_type >= ZXDH_MSG_TYPE_END) {
2203 : 0 : PMD_DRV_LOG(ERR, "len %u msg_type %d unsupported",
2204 : : len, msg_info->msg_head.msg_type);
2205 : 0 : ret = -2;
2206 : 0 : goto msg_proc_end;
2207 : : }
2208 : :
2209 : 0 : ret = zxdh_config_process_callback(hw, msg_info, reps_buffer, &reply_len);
2210 : 0 : *reps_len = reply_len + ZXDH_ST_SZ_BYTES(msg_reply_head);
2211 : 0 : return ret;
2212 : :
2213 : 0 : msg_proc_end:
2214 : : memcpy(reply_data_addr, &ret, sizeof(ret));
2215 : : reply_len = sizeof(ret);
2216 : 0 : *reps_len = ZXDH_ST_SZ_BYTES(msg_reply_head) + reply_len;
2217 : 0 : return ret;
2218 : : }
2219 : :
2220 : : void
2221 : 0 : zxdh_msg_cb_reg(struct zxdh_hw *hw)
2222 : : {
2223 [ # # ]: 0 : if (hw->is_pf)
2224 : 0 : zxdh_bar_chan_msg_recv_register(ZXDH_MODULE_BAR_MSG_TO_PF, pf_recv_bar_msg);
2225 : 0 : }
|