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