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