Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright 2025 Yunsilicon Technology Co., Ltd.
3 : : */
4 : :
5 : : #include <rte_io.h>
6 : :
7 : : #include "xsc_log.h"
8 : : #include "xsc_defs.h"
9 : : #include "xsc_dev.h"
10 : : #include "xsc_ethdev.h"
11 : : #include "xsc_cmd.h"
12 : : #include "xsc_rx.h"
13 : :
14 : : #define XSC_MAX_RECV_LEN 9800
15 : :
16 : : static inline void
17 : : xsc_cq_to_mbuf(struct xsc_rxq_data *rxq, struct rte_mbuf *pkt,
18 : : volatile struct xsc_cqe *cqe)
19 : : {
20 : : uint32_t rss_hash_res = 0;
21 : :
22 : 0 : pkt->port = rxq->port_id;
23 : 0 : if (rxq->rss_hash) {
24 : 0 : rss_hash_res = rte_be_to_cpu_32(cqe->vni);
25 [ # # ]: 0 : if (rss_hash_res) {
26 : 0 : pkt->hash.rss = rss_hash_res;
27 : 0 : pkt->ol_flags |= RTE_MBUF_F_RX_RSS_HASH;
28 : : }
29 : : }
30 : : }
31 : :
32 : : static inline int
33 : 0 : xsc_rx_poll_len(struct xsc_rxq_data *rxq, volatile struct xsc_cqe *cqe)
34 : : {
35 : : int len;
36 : :
37 : : do {
38 : : len = 0;
39 : : int ret;
40 : :
41 [ # # ]: 0 : ret = xsc_check_cqe_own(cqe, rxq->cqe_n, rxq->cq_ci);
42 [ # # ]: 0 : if (unlikely(ret != XSC_CQE_OWNER_SW)) {
43 [ # # ]: 0 : if (unlikely(ret == XSC_CQE_OWNER_ERR)) {
44 : 0 : ++rxq->stats.rx_errors;
45 [ # # ]: 0 : if (ret == XSC_CQE_OWNER_HW || ret == -1)
46 : : return 0;
47 : : } else {
48 : : return 0;
49 : : }
50 : : }
51 : :
52 : 0 : rxq->cq_ci += 1;
53 : 0 : len = rte_le_to_cpu_32(cqe->msg_len);
54 : 0 : return len;
55 : : } while (1);
56 : : }
57 : :
58 : : static __rte_always_inline void
59 : : xsc_pkt_info_sync(struct rte_mbuf *rep, struct rte_mbuf *seg)
60 : : {
61 : 0 : if (rep != NULL && seg != NULL) {
62 : 0 : rep->data_len = seg->data_len;
63 : 0 : rep->pkt_len = seg->pkt_len;
64 : 0 : rep->data_off = seg->data_off;
65 : 0 : rep->port = seg->port;
66 : : }
67 : : }
68 : :
69 : : uint16_t
70 : 0 : xsc_rx_burst(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
71 : : {
72 : : struct xsc_rxq_data *rxq = dpdk_rxq;
73 : 0 : const uint32_t wqe_m = rxq->wqe_m;
74 : 0 : const uint32_t cqe_m = rxq->cqe_m;
75 : 0 : const uint32_t sge_n = rxq->sge_n;
76 : : struct rte_mbuf *pkt = NULL;
77 : : struct rte_mbuf *seg = NULL;
78 : 0 : volatile struct xsc_cqe *cqe = &(*rxq->cqes)[rxq->cq_ci & cqe_m];
79 : : uint32_t nb_pkts = 0;
80 : : uint64_t nb_bytes = 0;
81 : 0 : uint32_t rq_ci = rxq->rq_ci;
82 : : int len = 0;
83 : : uint32_t cq_ci_two = 0;
84 : : int valid_cqe_num = 0;
85 : : int cqe_msg_len = 0;
86 : : volatile struct xsc_cqe_u64 *cqe_u64 = NULL;
87 : : struct rte_mbuf *rep;
88 : :
89 [ # # ]: 0 : while (pkts_n) {
90 : 0 : uint32_t idx = rq_ci & wqe_m;
91 : 0 : volatile struct xsc_wqe_data_seg *wqe =
92 : 0 : &((volatile struct xsc_wqe_data_seg *)rxq->wqes)[idx << sge_n];
93 : :
94 : 0 : seg = (*rxq->elts)[idx];
95 : : rte_prefetch0(cqe);
96 : : rte_prefetch0(wqe);
97 : :
98 : 0 : rep = rte_mbuf_raw_alloc(seg->pool);
99 [ # # ]: 0 : if (unlikely(rep == NULL)) {
100 : 0 : ++rxq->stats.rx_nombuf;
101 : 0 : break;
102 : : }
103 : :
104 : : if (!pkt) {
105 [ # # ]: 0 : if (valid_cqe_num) {
106 : 0 : cqe = cqe + 1;
107 : : len = cqe_msg_len;
108 : : valid_cqe_num = 0;
109 [ # # # # ]: 0 : } else if ((rxq->cq_ci % 2 == 0) && (pkts_n > 1)) {
110 : 0 : cq_ci_two = (rxq->cq_ci & rxq->cqe_m) / 2;
111 : 0 : cqe_u64 = &(*rxq->cqes_u64)[cq_ci_two];
112 : : cqe = (volatile struct xsc_cqe *)cqe_u64;
113 : 0 : len = xsc_rx_poll_len(rxq, cqe);
114 [ # # ]: 0 : if (len > 0) {
115 : 0 : cqe_msg_len = xsc_rx_poll_len(rxq, cqe + 1);
116 [ # # ]: 0 : if (cqe_msg_len > 0)
117 : : valid_cqe_num = 1;
118 : : }
119 : : } else {
120 : 0 : cqe = &(*rxq->cqes)[rxq->cq_ci & rxq->cqe_m];
121 : 0 : len = xsc_rx_poll_len(rxq, cqe);
122 : : }
123 : :
124 [ # # ]: 0 : if (!len) {
125 : : rte_mbuf_raw_free(rep);
126 : : break;
127 : : }
128 : :
129 [ # # ]: 0 : if (len > rte_pktmbuf_data_len(seg)) {
130 : : rte_mbuf_raw_free(rep);
131 : : pkt = NULL;
132 : 0 : ++rq_ci;
133 : 0 : continue;
134 : : }
135 : :
136 : : pkt = seg;
137 [ # # ]: 0 : pkt->ol_flags &= RTE_MBUF_F_EXTERNAL;
138 : : xsc_cq_to_mbuf(rxq, pkt, cqe);
139 : :
140 [ # # ]: 0 : if (rxq->crc_present)
141 : 0 : len -= RTE_ETHER_CRC_LEN;
142 [ # # ]: 0 : rte_pktmbuf_pkt_len(pkt) = len;
143 : : }
144 : :
145 : : xsc_pkt_info_sync(rep, seg);
146 : 0 : (*rxq->elts)[idx] = rep;
147 : :
148 : : /* Fill wqe */
149 : 0 : wqe->va = rte_cpu_to_le_64(rte_pktmbuf_iova(rep));
150 : 0 : rte_pktmbuf_data_len(seg) = len;
151 : 0 : nb_bytes += rte_pktmbuf_pkt_len(pkt);
152 : :
153 : 0 : *(pkts++) = pkt;
154 : : pkt = NULL;
155 : 0 : --pkts_n;
156 : 0 : ++nb_pkts;
157 : 0 : ++rq_ci;
158 : : }
159 : :
160 [ # # # # ]: 0 : if (unlikely(nb_pkts == 0 && rq_ci == rxq->rq_ci))
161 : : return 0;
162 : :
163 : 0 : rxq->rq_ci = rq_ci;
164 : 0 : rxq->nb_rx_hold += nb_pkts;
165 : :
166 [ # # ]: 0 : if (rxq->nb_rx_hold >= rxq->rx_free_thresh) {
167 : 0 : union xsc_cq_doorbell cq_db = {
168 : : .cq_data = 0
169 : : };
170 : 0 : cq_db.next_cid = rxq->cq_ci;
171 : 0 : cq_db.cq_num = rxq->cqn;
172 : :
173 : 0 : union xsc_recv_doorbell rq_db = {
174 : : .recv_data = 0
175 : : };
176 : 0 : rq_db.next_pid = (rxq->rq_ci << sge_n);
177 : 0 : rq_db.qp_num = rxq->qpn;
178 : :
179 : 0 : rte_write32(rte_cpu_to_le_32(cq_db.cq_data), rxq->cq_db);
180 : 0 : rte_write32(rte_cpu_to_le_32(rq_db.recv_data), rxq->rq_db);
181 : 0 : rxq->nb_rx_hold = 0;
182 : : }
183 : :
184 : 0 : rxq->stats.rx_pkts += nb_pkts;
185 : 0 : rxq->stats.rx_bytes += nb_bytes;
186 : :
187 : 0 : return nb_pkts;
188 : : }
189 : :
190 : : static void
191 : 0 : xsc_rxq_initialize(struct xsc_dev *xdev, struct xsc_rxq_data *rxq_data)
192 : : {
193 : 0 : const uint32_t wqe_n = rxq_data->wqe_s;
194 : : uint32_t i;
195 : : uint32_t seg_len = 0;
196 : : struct xsc_hwinfo *hwinfo = &xdev->hwinfo;
197 [ # # ]: 0 : uint32_t rx_ds_num = hwinfo->recv_seg_num;
198 : : uint32_t log2ds = rte_log2_u32(rx_ds_num);
199 : : uintptr_t addr;
200 : : struct rte_mbuf *mbuf;
201 : : void *jumbo_buffer_pa = xdev->jumbo_buffer_pa;
202 : 0 : void *jumbo_buffer_va = xdev->jumbo_buffer_va;
203 : : volatile struct xsc_wqe_data_seg *seg;
204 : : volatile struct xsc_wqe_data_seg *seg_next;
205 : :
206 [ # # ]: 0 : for (i = 0; (i != wqe_n); ++i) {
207 : 0 : mbuf = (*rxq_data->elts)[i];
208 [ # # ]: 0 : seg = &((volatile struct xsc_wqe_data_seg *)rxq_data->wqes)[i * rx_ds_num];
209 : 0 : addr = (uintptr_t)rte_pktmbuf_iova(mbuf);
210 [ # # ]: 0 : if (rx_ds_num == 1)
211 : : seg_len = XSC_MAX_RECV_LEN;
212 : : else
213 : 0 : seg_len = rte_pktmbuf_data_len(mbuf);
214 : 0 : *seg = (struct xsc_wqe_data_seg){
215 : : .va = rte_cpu_to_le_64(addr),
216 : : .seg_len = rte_cpu_to_le_32(seg_len),
217 : : .lkey = 0,
218 : : };
219 : :
220 [ # # ]: 0 : if (rx_ds_num != 1) {
221 : : seg_next = seg + 1;
222 [ # # ]: 0 : if (jumbo_buffer_va == NULL) {
223 : 0 : jumbo_buffer_pa = rte_malloc(NULL, XSC_MAX_RECV_LEN, 0);
224 [ # # ]: 0 : if (jumbo_buffer_pa == NULL) {
225 : : /* Rely on mtu */
226 : 0 : seg->seg_len = XSC_MAX_RECV_LEN;
227 : 0 : PMD_DRV_LOG(ERR, "Failed to malloc jumbo_buffer");
228 : 0 : continue;
229 : : } else {
230 : 0 : jumbo_buffer_va =
231 : 0 : (void *)rte_malloc_virt2iova(jumbo_buffer_pa);
232 [ # # ]: 0 : if ((rte_iova_t)jumbo_buffer_va == RTE_BAD_IOVA) {
233 : 0 : seg->seg_len = XSC_MAX_RECV_LEN;
234 : 0 : PMD_DRV_LOG(ERR, "Failed to turn jumbo_buffer");
235 : 0 : continue;
236 : : }
237 : : }
238 : 0 : xdev->jumbo_buffer_pa = jumbo_buffer_pa;
239 : 0 : xdev->jumbo_buffer_va = jumbo_buffer_va;
240 : : }
241 : 0 : *seg_next = (struct xsc_wqe_data_seg){
242 : 0 : .va = rte_cpu_to_le_64((uint64_t)jumbo_buffer_va),
243 : 0 : .seg_len = rte_cpu_to_le_32(XSC_MAX_RECV_LEN - seg_len),
244 : : .lkey = 0,
245 : : };
246 : : }
247 : : }
248 : :
249 : 0 : rxq_data->rq_ci = wqe_n;
250 : 0 : rxq_data->sge_n = log2ds;
251 : :
252 : 0 : union xsc_recv_doorbell recv_db = {
253 : : .recv_data = 0
254 : : };
255 : :
256 : 0 : recv_db.next_pid = wqe_n << log2ds;
257 : 0 : recv_db.qp_num = rxq_data->qpn;
258 : 0 : rte_write32(rte_cpu_to_le_32(recv_db.recv_data), rxq_data->rq_db);
259 : 0 : }
260 : :
261 : : static int
262 : 0 : xsc_rss_qp_create(struct xsc_ethdev_priv *priv, int port_id)
263 : : {
264 : : struct xsc_cmd_create_multiqp_mbox_in *in;
265 : : struct xsc_cmd_create_qp_request *req;
266 : : struct xsc_cmd_create_multiqp_mbox_out *out;
267 : : uint8_t log_ele;
268 : : uint64_t iova;
269 : : int wqe_n;
270 : : int in_len, out_len, cmd_len;
271 : : int entry_total_len, entry_len;
272 : : uint8_t log_rq_sz, log_sq_sz = 0;
273 : : uint32_t wqe_total_len;
274 : : int j, ret;
275 : : uint16_t i, pa_num;
276 : : int rqn_base;
277 : : struct xsc_rxq_data *rxq_data;
278 : 0 : struct xsc_dev *xdev = priv->xdev;
279 : : struct xsc_hwinfo *hwinfo = &xdev->hwinfo;
280 [ # # ]: 0 : char name[RTE_ETH_NAME_MAX_LEN] = { 0 };
281 : :
282 : : rxq_data = xsc_rxq_get(priv, 0);
283 : : log_ele = rte_log2_u32(sizeof(struct xsc_wqe_data_seg));
284 : 0 : wqe_n = rxq_data->wqe_s;
285 [ # # ]: 0 : log_rq_sz = rte_log2_u32(wqe_n * hwinfo->recv_seg_num);
286 : 0 : wqe_total_len = 1 << (log_rq_sz + log_sq_sz + log_ele);
287 : :
288 : 0 : pa_num = (wqe_total_len + XSC_PAGE_SIZE - 1) / XSC_PAGE_SIZE;
289 : 0 : entry_len = sizeof(struct xsc_cmd_create_qp_request) + sizeof(uint64_t) * pa_num;
290 : 0 : entry_total_len = entry_len * priv->num_rq;
291 : :
292 : 0 : in_len = sizeof(struct xsc_cmd_create_multiqp_mbox_in) + entry_total_len;
293 : 0 : out_len = sizeof(struct xsc_cmd_create_multiqp_mbox_out) + entry_total_len;
294 : 0 : cmd_len = RTE_MAX(in_len, out_len);
295 [ # # ]: 0 : in = malloc(cmd_len);
296 : : memset(in, 0, cmd_len);
297 : : if (in == NULL) {
298 : : rte_errno = ENOMEM;
299 : : PMD_DRV_LOG(ERR, "Alloc rss qp create cmd memory failed");
300 : : goto error;
301 : : }
302 : :
303 [ # # ]: 0 : in->qp_num = rte_cpu_to_be_16((uint16_t)priv->num_rq);
304 : 0 : in->qp_type = XSC_QUEUE_TYPE_RAW;
305 [ # # ]: 0 : in->req_len = rte_cpu_to_be_32(cmd_len);
306 : :
307 [ # # ]: 0 : for (i = 0; i < priv->num_rq; i++) {
308 : 0 : rxq_data = (*priv->rxqs)[i];
309 : 0 : req = (struct xsc_cmd_create_qp_request *)(&in->data[0] + entry_len * i);
310 : 0 : req->input_qpn = rte_cpu_to_be_16(0); /* useless for eth */
311 [ # # ]: 0 : req->pa_num = rte_cpu_to_be_16(pa_num);
312 : 0 : req->qp_type = XSC_QUEUE_TYPE_RAW;
313 : 0 : req->log_rq_sz = log_rq_sz;
314 [ # # ]: 0 : req->cqn_recv = rte_cpu_to_be_16((uint16_t)rxq_data->cqn);
315 : 0 : req->cqn_send = req->cqn_recv;
316 [ # # ]: 0 : req->glb_funcid = rte_cpu_to_be_16((uint16_t)hwinfo->func_id);
317 : : /* Alloc pas addr */
318 : : snprintf(name, sizeof(name), "wqe_mem_rx_%d_%d", port_id, i);
319 : 0 : rxq_data->rq_pas = rte_memzone_reserve_aligned(name,
320 : 0 : (XSC_PAGE_SIZE * pa_num),
321 : : SOCKET_ID_ANY,
322 : : 0, XSC_PAGE_SIZE);
323 [ # # ]: 0 : if (rxq_data->rq_pas == NULL) {
324 : 0 : rte_errno = ENOMEM;
325 : 0 : PMD_DRV_LOG(ERR, "Alloc rxq pas memory failed");
326 : 0 : goto error;
327 : : }
328 : :
329 : 0 : iova = rxq_data->rq_pas->iova;
330 [ # # ]: 0 : for (j = 0; j < pa_num; j++)
331 [ # # ]: 0 : req->pas[j] = rte_cpu_to_be_64(iova + j * XSC_PAGE_SIZE);
332 : : }
333 : :
334 : 0 : in->hdr.opcode = rte_cpu_to_be_16(XSC_CMD_OP_CREATE_MULTI_QP);
335 : : out = (struct xsc_cmd_create_multiqp_mbox_out *)in;
336 : 0 : ret = xsc_dev_mailbox_exec(xdev, in, in_len, out, out_len);
337 [ # # # # ]: 0 : if (ret != 0 || out->hdr.status != 0) {
338 : 0 : PMD_DRV_LOG(ERR,
339 : : "Create rss rq failed, port id=%d, qp_num=%d, ret=%d, out.status=%u",
340 : : port_id, priv->num_rq, ret, out->hdr.status);
341 : 0 : rte_errno = ENOEXEC;
342 : 0 : goto error;
343 : : }
344 [ # # ]: 0 : rqn_base = rte_be_to_cpu_32(out->qpn_base) & 0xffffff;
345 : :
346 [ # # ]: 0 : for (i = 0; i < priv->num_rq; i++) {
347 [ # # ]: 0 : rxq_data = xsc_rxq_get(priv, i);
348 : 0 : rxq_data->wqes = rxq_data->rq_pas->addr;
349 [ # # ]: 0 : if (!xsc_dev_is_vf(xdev))
350 : 0 : rxq_data->rq_db = (uint32_t *)((uint8_t *)xdev->bar_addr +
351 : : XSC_PF_RX_DB_ADDR);
352 : : else
353 : 0 : rxq_data->rq_db = (uint32_t *)((uint8_t *)xdev->bar_addr +
354 : : XSC_VF_RX_DB_ADDR);
355 : :
356 : 0 : rxq_data->qpn = rqn_base + i;
357 : 0 : xsc_dev_modify_qp_status(xdev, rxq_data->qpn, 1, XSC_CMD_OP_RTR2RTS_QP);
358 : 0 : xsc_rxq_initialize(xdev, rxq_data);
359 : 0 : rxq_data->cq_ci = 0;
360 : 0 : priv->dev_data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
361 : 0 : PMD_DRV_LOG(INFO, "Port %u create rx qp, wqe_s:%d, wqe_n:%d, qp_db=%p, qpn:%d",
362 : : port_id,
363 : : rxq_data->wqe_s, rxq_data->wqe_n,
364 : : rxq_data->rq_db, rxq_data->qpn);
365 : : }
366 : :
367 : 0 : free(in);
368 : 0 : return 0;
369 : :
370 : 0 : error:
371 : 0 : free(in);
372 : 0 : return -rte_errno;
373 : : }
374 : :
375 : : int
376 : 0 : xsc_rxq_rss_obj_new(struct xsc_ethdev_priv *priv, uint16_t port_id)
377 : : {
378 : : int ret;
379 : : uint32_t i;
380 : 0 : struct xsc_dev *xdev = priv->xdev;
381 : : struct xsc_rxq_data *rxq_data;
382 : 0 : struct xsc_rx_cq_params cq_params = {0};
383 : 0 : struct xsc_rx_cq_info cq_info = {0};
384 : :
385 : : /* Create CQ */
386 [ # # ]: 0 : for (i = 0; i < priv->num_rq; ++i) {
387 [ # # ]: 0 : rxq_data = xsc_rxq_get(priv, i);
388 : :
389 : : memset(&cq_params, 0, sizeof(cq_params));
390 : : memset(&cq_info, 0, sizeof(cq_info));
391 : 0 : cq_params.port_id = rxq_data->port_id;
392 : 0 : cq_params.qp_id = rxq_data->idx;
393 : 0 : cq_params.wqe_s = rxq_data->wqe_s;
394 : :
395 : 0 : ret = xsc_dev_rx_cq_create(xdev, &cq_params, &cq_info);
396 [ # # ]: 0 : if (ret) {
397 : 0 : PMD_DRV_LOG(ERR, "Port %u rxq %u create cq fail", port_id, i);
398 : 0 : rte_errno = errno;
399 : 0 : goto error;
400 : : }
401 : :
402 : 0 : rxq_data->cq = cq_info.cq;
403 : 0 : rxq_data->cqe_n = cq_info.cqe_n;
404 : 0 : rxq_data->cqe_s = 1 << rxq_data->cqe_n;
405 : 0 : rxq_data->cqe_m = rxq_data->cqe_s - 1;
406 : 0 : rxq_data->cqes = cq_info.cqes;
407 : 0 : rxq_data->cq_db = cq_info.cq_db;
408 : 0 : rxq_data->cqn = cq_info.cqn;
409 : :
410 : 0 : PMD_DRV_LOG(INFO, "Port %u create rx cq, cqe_s:%d, cqe_n:%d, cq_db=%p, cqn:%d",
411 : : port_id,
412 : : rxq_data->cqe_s, rxq_data->cqe_n,
413 : : rxq_data->cq_db, rxq_data->cqn);
414 : : }
415 : :
416 : 0 : ret = xsc_rss_qp_create(priv, port_id);
417 [ # # ]: 0 : if (ret != 0) {
418 : 0 : PMD_DRV_LOG(ERR, "Port %u rss rxq create fail", port_id);
419 : 0 : goto error;
420 : : }
421 : : return 0;
422 : :
423 : 0 : error:
424 : 0 : return -rte_errno;
425 : : }
426 : :
427 : : int
428 : 0 : xsc_rxq_elts_alloc(struct xsc_rxq_data *rxq_data)
429 : : {
430 : 0 : uint32_t elts_s = rxq_data->wqe_s;
431 : : struct rte_mbuf *mbuf;
432 : : uint32_t i;
433 : :
434 [ # # ]: 0 : for (i = 0; (i != elts_s); ++i) {
435 : 0 : mbuf = rte_pktmbuf_alloc(rxq_data->mp);
436 [ # # ]: 0 : if (mbuf == NULL) {
437 : 0 : PMD_DRV_LOG(ERR, "Port %u rxq %u empty mbuf pool",
438 : : rxq_data->port_id, rxq_data->idx);
439 : 0 : rte_errno = ENOMEM;
440 : 0 : goto error;
441 : : }
442 : :
443 : 0 : mbuf->port = rxq_data->port_id;
444 : 0 : mbuf->nb_segs = 1;
445 [ # # ]: 0 : rte_pktmbuf_data_len(mbuf) = rte_pktmbuf_data_room_size(rxq_data->mp)
446 : 0 : - mbuf->data_off;
447 : 0 : rte_pktmbuf_pkt_len(mbuf) = rte_pktmbuf_data_room_size(rxq_data->mp)
448 : 0 : - mbuf->data_off;
449 : 0 : (*rxq_data->elts)[i] = mbuf;
450 : : }
451 : :
452 : : return 0;
453 : : error:
454 : : elts_s = i;
455 [ # # ]: 0 : for (i = 0; (i != elts_s); ++i) {
456 [ # # ]: 0 : if ((*rxq_data->elts)[i] != NULL)
457 : : rte_pktmbuf_free_seg((*rxq_data->elts)[i]);
458 : 0 : (*rxq_data->elts)[i] = NULL;
459 : : }
460 : :
461 : 0 : PMD_DRV_LOG(ERR, "Port %u rxq %u start failed, free elts",
462 : : rxq_data->port_id, rxq_data->idx);
463 : :
464 : 0 : return -rte_errno;
465 : : }
466 : :
467 : : void
468 : 0 : xsc_rxq_elts_free(struct xsc_rxq_data *rxq_data)
469 : : {
470 : : uint16_t i;
471 : :
472 [ # # ]: 0 : if (rxq_data->elts == NULL)
473 : : return;
474 [ # # ]: 0 : for (i = 0; i != rxq_data->wqe_s; ++i) {
475 [ # # ]: 0 : if ((*rxq_data->elts)[i] != NULL)
476 : : rte_pktmbuf_free_seg((*rxq_data->elts)[i]);
477 : 0 : (*rxq_data->elts)[i] = NULL;
478 : : }
479 : :
480 : 0 : PMD_DRV_LOG(DEBUG, "Port %u rxq %u free elts", rxq_data->port_id, rxq_data->idx);
481 : : }
482 : :
483 : : void
484 : 0 : xsc_rxq_rss_obj_release(struct xsc_dev *xdev, struct xsc_rxq_data *rxq_data)
485 : : {
486 : 0 : struct xsc_cmd_destroy_qp_mbox_in in = { .hdr = { 0 } };
487 : 0 : struct xsc_cmd_destroy_qp_mbox_out out = { .hdr = { 0 } };
488 : : int ret, in_len, out_len;
489 : 0 : uint32_t qpn = rxq_data->qpn;
490 : :
491 : 0 : xsc_dev_modify_qp_status(xdev, qpn, 1, XSC_CMD_OP_QP_2RST);
492 : :
493 : : in_len = sizeof(struct xsc_cmd_destroy_qp_mbox_in);
494 : : out_len = sizeof(struct xsc_cmd_destroy_qp_mbox_out);
495 : 0 : in.hdr.opcode = rte_cpu_to_be_16(XSC_CMD_OP_DESTROY_QP);
496 [ # # ]: 0 : in.qpn = rte_cpu_to_be_32(rxq_data->qpn);
497 : :
498 : 0 : ret = xsc_dev_mailbox_exec(xdev, &in, in_len, &out, out_len);
499 [ # # # # ]: 0 : if (ret != 0 || out.hdr.status != 0) {
500 : 0 : PMD_DRV_LOG(ERR,
501 : : "Release rss rq failed, port id=%d, qid=%d, err=%d, out.status=%u",
502 : : rxq_data->port_id, rxq_data->idx, ret, out.hdr.status);
503 : 0 : rte_errno = ENOEXEC;
504 : 0 : return;
505 : : }
506 : :
507 : 0 : rte_memzone_free(rxq_data->rq_pas);
508 : :
509 [ # # ]: 0 : if (rxq_data->cq != NULL)
510 : 0 : xsc_dev_destroy_cq(xdev, rxq_data->cq);
511 : 0 : rxq_data->cq = NULL;
512 : : }
|
