Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : *
3 : : * Copyright (c) 2016 Freescale Semiconductor, Inc. All rights reserved.
4 : : * Copyright 2016-2019,2022-2025 NXP
5 : : *
6 : : */
7 : :
8 : : #include <unistd.h>
9 : : #include <stdio.h>
10 : : #include <sys/types.h>
11 : : #include <string.h>
12 : : #include <stdlib.h>
13 : : #include <fcntl.h>
14 : : #include <errno.h>
15 : :
16 : : #include <eal_export.h>
17 : : #include <rte_mbuf.h>
18 : : #include <ethdev_driver.h>
19 : : #include <rte_malloc.h>
20 : : #include <rte_memcpy.h>
21 : : #include <rte_string_fns.h>
22 : : #include <rte_cycles.h>
23 : : #include <rte_kvargs.h>
24 : : #include <dev_driver.h>
25 : : #include "rte_dpaa2_mempool.h"
26 : :
27 : : #include <bus_fslmc_driver.h>
28 : : #include <fslmc_logs.h>
29 : : #include <mc/fsl_dpbp.h>
30 : : #include <portal/dpaa2_hw_pvt.h>
31 : : #include <portal/dpaa2_hw_dpio.h>
32 : : #include "dpaa2_hw_mempool.h"
33 : : #include "dpaa2_hw_mempool_logs.h"
34 : :
35 : : #include <dpaax_iova_table.h>
36 : :
37 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_dpaa2_bpid_info)
38 : : struct dpaa2_bp_info *rte_dpaa2_bpid_info;
39 : : static struct dpaa2_bp_list *h_bp_list;
40 : :
41 : : static int16_t s_dpaa2_pool_ops_idx = RTE_MEMPOOL_MAX_OPS_IDX;
42 : :
43 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_dpaa2_mpool_get_ops_idx)
44 : 0 : int rte_dpaa2_mpool_get_ops_idx(void)
45 : : {
46 : 0 : return s_dpaa2_pool_ops_idx;
47 : : }
48 : :
49 : : static int
50 : 0 : rte_hw_mbuf_create_pool(struct rte_mempool *mp)
51 : : {
52 : : struct dpaa2_bp_list *bp_list;
53 : : struct dpaa2_dpbp_dev *avail_dpbp;
54 : : struct dpaa2_bp_info *bp_info;
55 : : struct dpbp_attr dpbp_attr;
56 : : uint32_t bpid;
57 : : int ret;
58 : :
59 : 0 : avail_dpbp = dpaa2_alloc_dpbp_dev();
60 : :
61 [ # # ]: 0 : if (rte_dpaa2_bpid_info == NULL) {
62 : 0 : rte_dpaa2_bpid_info = (struct dpaa2_bp_info *)rte_malloc(NULL,
63 : : sizeof(struct dpaa2_bp_info) * MAX_BPID,
64 : : RTE_CACHE_LINE_SIZE);
65 [ # # ]: 0 : if (rte_dpaa2_bpid_info == NULL)
66 : : return -ENOMEM;
67 : : memset(rte_dpaa2_bpid_info, 0,
68 : : sizeof(struct dpaa2_bp_info) * MAX_BPID);
69 : : }
70 : :
71 [ # # ]: 0 : if (!avail_dpbp) {
72 : 0 : DPAA2_MEMPOOL_ERR("DPAA2 pool not available!");
73 : 0 : return -ENOENT;
74 : : }
75 : :
76 [ # # ]: 0 : if (unlikely(!DPAA2_PER_LCORE_DPIO)) {
77 : 0 : ret = dpaa2_affine_qbman_swp();
78 [ # # ]: 0 : if (ret) {
79 : 0 : DPAA2_MEMPOOL_ERR(
80 : : "Failed to allocate IO portal, tid: %d",
81 : : rte_gettid());
82 : 0 : goto err1;
83 : : }
84 : : }
85 : :
86 : 0 : ret = dpbp_enable(&avail_dpbp->dpbp, CMD_PRI_LOW, avail_dpbp->token);
87 [ # # ]: 0 : if (ret != 0) {
88 : 0 : DPAA2_MEMPOOL_ERR("Resource enable failure with err code: %d",
89 : : ret);
90 : 0 : goto err1;
91 : : }
92 : :
93 : 0 : ret = dpbp_get_attributes(&avail_dpbp->dpbp, CMD_PRI_LOW,
94 : 0 : avail_dpbp->token, &dpbp_attr);
95 [ # # ]: 0 : if (ret != 0) {
96 : 0 : DPAA2_MEMPOOL_ERR("Resource read failure with err code: %d",
97 : : ret);
98 : 0 : goto err2;
99 : : }
100 : :
101 : 0 : bp_info = rte_malloc(NULL,
102 : : sizeof(struct dpaa2_bp_info),
103 : : RTE_CACHE_LINE_SIZE);
104 [ # # ]: 0 : if (!bp_info) {
105 : 0 : DPAA2_MEMPOOL_ERR("Unable to allocate buffer pool memory");
106 : : ret = -ENOMEM;
107 : 0 : goto err2;
108 : : }
109 : :
110 : : /* Allocate the bp_list which will be added into global_bp_list */
111 : 0 : bp_list = rte_malloc(NULL, sizeof(struct dpaa2_bp_list),
112 : : RTE_CACHE_LINE_SIZE);
113 [ # # ]: 0 : if (!bp_list) {
114 : 0 : DPAA2_MEMPOOL_ERR("Unable to allocate buffer pool memory");
115 : : ret = -ENOMEM;
116 : 0 : goto err3;
117 : : }
118 : :
119 : : /* Set parameters of buffer pool list */
120 : 0 : bp_list->buf_pool.num_bufs = mp->size;
121 [ # # ]: 0 : bp_list->buf_pool.size = mp->elt_size
122 : 0 : - sizeof(struct rte_mbuf) - rte_pktmbuf_priv_size(mp);
123 : 0 : bp_list->buf_pool.bpid = dpbp_attr.bpid;
124 : 0 : bp_list->buf_pool.h_bpool_mem = NULL;
125 : 0 : bp_list->buf_pool.dpbp_node = avail_dpbp;
126 : : /* Identification for our offloaded pool_data structure */
127 : 0 : bp_list->dpaa2_ops_index = mp->ops_index;
128 [ # # ]: 0 : if (s_dpaa2_pool_ops_idx == RTE_MEMPOOL_MAX_OPS_IDX) {
129 : 0 : s_dpaa2_pool_ops_idx = mp->ops_index;
130 [ # # ]: 0 : } else if (s_dpaa2_pool_ops_idx != mp->ops_index) {
131 : 0 : DPAA2_MEMPOOL_ERR("Only single ops index only");
132 : : ret = -EINVAL;
133 : 0 : goto err4;
134 : : }
135 : :
136 : 0 : bp_list->next = h_bp_list;
137 : 0 : bp_list->mp = mp;
138 : :
139 : 0 : bpid = dpbp_attr.bpid;
140 : :
141 : 0 : rte_dpaa2_bpid_info[bpid].meta_data_size = sizeof(struct rte_mbuf)
142 : 0 : + rte_pktmbuf_priv_size(mp);
143 : 0 : rte_dpaa2_bpid_info[bpid].bp_list = bp_list;
144 : 0 : rte_dpaa2_bpid_info[bpid].bpid = bpid;
145 : :
146 : : rte_memcpy(bp_info, (void *)&rte_dpaa2_bpid_info[bpid],
147 : : sizeof(struct dpaa2_bp_info));
148 : 0 : mp->pool_data = (void *)bp_info;
149 : :
150 : 0 : DPAA2_MEMPOOL_DEBUG("BP List created for bpid =%d", dpbp_attr.bpid);
151 : :
152 : 0 : h_bp_list = bp_list;
153 : :
154 : 0 : return 0;
155 : : err4:
156 : 0 : rte_free(bp_list);
157 : 0 : err3:
158 : 0 : rte_free(bp_info);
159 : 0 : err2:
160 : 0 : dpbp_disable(&avail_dpbp->dpbp, CMD_PRI_LOW, avail_dpbp->token);
161 : 0 : err1:
162 : 0 : dpaa2_free_dpbp_dev(avail_dpbp);
163 : :
164 : 0 : return ret;
165 : : }
166 : :
167 : : static void
168 : 0 : rte_hw_mbuf_free_pool(struct rte_mempool *mp)
169 : : {
170 : : struct dpaa2_bp_info *bpinfo;
171 : : struct dpaa2_bp_list *bp;
172 : : struct dpaa2_dpbp_dev *dpbp_node;
173 : :
174 [ # # ]: 0 : if (!mp->pool_data) {
175 : 0 : DPAA2_MEMPOOL_ERR("Not a valid dpaa2 buffer pool");
176 : 0 : return;
177 : : }
178 : :
179 : : bpinfo = (struct dpaa2_bp_info *)mp->pool_data;
180 : 0 : bp = bpinfo->bp_list;
181 : 0 : dpbp_node = bp->buf_pool.dpbp_node;
182 : :
183 : 0 : dpbp_disable(&(dpbp_node->dpbp), CMD_PRI_LOW, dpbp_node->token);
184 : :
185 [ # # ]: 0 : if (h_bp_list == bp) {
186 : 0 : h_bp_list = h_bp_list->next;
187 : : } else { /* if it is not the first node */
188 : : struct dpaa2_bp_list *prev = h_bp_list, *temp;
189 : 0 : temp = h_bp_list->next;
190 [ # # ]: 0 : while (temp) {
191 [ # # ]: 0 : if (temp == bp) {
192 : 0 : prev->next = temp->next;
193 : 0 : rte_free(bp);
194 : 0 : break;
195 : : }
196 : : prev = temp;
197 : 0 : temp = temp->next;
198 : : }
199 : : }
200 : :
201 : 0 : rte_free(mp->pool_data);
202 : 0 : dpaa2_free_dpbp_dev(dpbp_node);
203 : : }
204 : :
205 : : static inline int
206 : 0 : dpaa2_bman_multi_release(uint64_t *bufs, int num,
207 : : struct qbman_swp *swp,
208 : : const struct qbman_release_desc *releasedesc)
209 : : {
210 : : int retry_count = 0, ret;
211 : :
212 : 0 : release_again:
213 : 0 : ret = qbman_swp_release(swp, releasedesc, bufs, num);
214 [ # # ]: 0 : if (unlikely(ret == -EBUSY)) {
215 : 0 : retry_count++;
216 [ # # ]: 0 : if (retry_count <= DPAA2_MAX_TX_RETRY_COUNT)
217 : 0 : goto release_again;
218 : :
219 : 0 : DPAA2_MEMPOOL_ERR("bman release retry exceeded, low fbpr?");
220 : 0 : return ret;
221 : : }
222 [ # # ]: 0 : if (unlikely(ret)) {
223 : 0 : DPAA2_MEMPOOL_ERR("bman release failed(err=%d)", ret);
224 : 0 : return ret;
225 : : }
226 : :
227 : : return 0;
228 : : }
229 : :
230 : : static int
231 : 0 : dpaa2_mbuf_release(void * const *obj_table, uint32_t bpid,
232 : : uint32_t meta_data_size, int count)
233 : : {
234 : : struct qbman_release_desc releasedesc;
235 : : struct qbman_swp *swp;
236 : : int ret;
237 : : int i, n;
238 : : uint64_t bufs[DPAA2_MBUF_MAX_ACQ_REL];
239 : :
240 [ # # ]: 0 : if (unlikely(!DPAA2_PER_LCORE_DPIO)) {
241 : 0 : ret = dpaa2_affine_qbman_swp();
242 [ # # ]: 0 : if (ret) {
243 : 0 : DPAA2_MEMPOOL_ERR("affine portal err: %d, tid: %d",
244 : : ret, rte_gettid());
245 : 0 : return -EIO;
246 : : }
247 : : }
248 : 0 : swp = DPAA2_PER_LCORE_PORTAL;
249 : :
250 : : /* Create a release descriptor required for releasing
251 : : * buffers into QBMAN
252 : : */
253 : 0 : qbman_release_desc_clear(&releasedesc);
254 : 0 : qbman_release_desc_set_bpid(&releasedesc, bpid);
255 : :
256 : 0 : n = count % DPAA2_MBUF_MAX_ACQ_REL;
257 [ # # ]: 0 : if (unlikely(!n))
258 : 0 : goto aligned;
259 : :
260 : : /* convert mbuf to buffers for the remainder */
261 [ # # ]: 0 : if (likely(rte_eal_iova_mode() == RTE_IOVA_VA)) {
262 [ # # ]: 0 : for (i = 0; i < n ; i++) {
263 : 0 : bufs[i] = DPAA2_VAMODE_VADDR_TO_IOVA(obj_table[i]) +
264 : : meta_data_size;
265 : : }
266 : : } else {
267 [ # # ]: 0 : for (i = 0; i < n ; i++) {
268 : 0 : bufs[i] = DPAA2_PAMODE_VADDR_TO_IOVA(obj_table[i]) +
269 : : meta_data_size;
270 : : }
271 : : }
272 : :
273 : : /* feed them to bman */
274 : 0 : ret = dpaa2_bman_multi_release(bufs, n, swp, &releasedesc);
275 [ # # ]: 0 : if (unlikely(ret))
276 : : return 0;
277 : :
278 : 0 : aligned:
279 : : /* if there are more buffers to free */
280 [ # # ]: 0 : if (unlikely(rte_eal_iova_mode() != RTE_IOVA_VA))
281 : 0 : goto iova_pa_release;
282 : :
283 [ # # ]: 0 : while (n < count) {
284 : : /* convert mbuf to buffers */
285 [ # # ]: 0 : for (i = 0; i < DPAA2_MBUF_MAX_ACQ_REL; i++) {
286 : 0 : bufs[i] = DPAA2_VAMODE_VADDR_TO_IOVA(obj_table[n + i]) +
287 : : meta_data_size;
288 : : }
289 : :
290 : 0 : ret = dpaa2_bman_multi_release(bufs,
291 : : DPAA2_MBUF_MAX_ACQ_REL, swp, &releasedesc);
292 [ # # ]: 0 : if (unlikely(ret))
293 : 0 : return n;
294 : :
295 : 0 : n += DPAA2_MBUF_MAX_ACQ_REL;
296 : : }
297 : :
298 : : return count;
299 : :
300 : : iova_pa_release:
301 [ # # ]: 0 : while (n < count) {
302 : : /* convert mbuf to buffers */
303 [ # # ]: 0 : for (i = 0; i < DPAA2_MBUF_MAX_ACQ_REL; i++) {
304 : 0 : bufs[i] = DPAA2_PAMODE_VADDR_TO_IOVA(obj_table[n + i]) +
305 : : meta_data_size;
306 : : }
307 : :
308 : 0 : ret = dpaa2_bman_multi_release(bufs,
309 : : DPAA2_MBUF_MAX_ACQ_REL, swp, &releasedesc);
310 [ # # ]: 0 : if (unlikely(ret))
311 : 0 : return n;
312 : :
313 : 0 : n += DPAA2_MBUF_MAX_ACQ_REL;
314 : : }
315 : :
316 : : return count;
317 : : }
318 : :
319 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_dpaa2_bpid_info_init)
320 : 0 : int rte_dpaa2_bpid_info_init(struct rte_mempool *mp)
321 : : {
322 : 0 : struct dpaa2_bp_info *bp_info = mempool_to_bpinfo(mp);
323 : 0 : uint32_t bpid = bp_info->bpid;
324 : :
325 [ # # ]: 0 : if (!rte_dpaa2_bpid_info) {
326 : 0 : rte_dpaa2_bpid_info = (struct dpaa2_bp_info *)rte_malloc(NULL,
327 : : sizeof(struct dpaa2_bp_info) * MAX_BPID,
328 : : RTE_CACHE_LINE_SIZE);
329 [ # # ]: 0 : if (rte_dpaa2_bpid_info == NULL)
330 : : return -ENOMEM;
331 : : memset(rte_dpaa2_bpid_info, 0,
332 : : sizeof(struct dpaa2_bp_info) * MAX_BPID);
333 : : }
334 : :
335 : 0 : rte_dpaa2_bpid_info[bpid].meta_data_size = sizeof(struct rte_mbuf)
336 : 0 : + rte_pktmbuf_priv_size(mp);
337 : 0 : rte_dpaa2_bpid_info[bpid].bp_list = bp_info->bp_list;
338 : 0 : rte_dpaa2_bpid_info[bpid].bpid = bpid;
339 : :
340 : 0 : return 0;
341 : : }
342 : :
343 : : RTE_EXPORT_SYMBOL(rte_dpaa2_mbuf_pool_bpid)
344 : : uint16_t
345 : 0 : rte_dpaa2_mbuf_pool_bpid(struct rte_mempool *mp)
346 : : {
347 : : struct dpaa2_bp_info *bp_info;
348 : :
349 : 0 : bp_info = mempool_to_bpinfo(mp);
350 [ # # ]: 0 : if (!(bp_info->bp_list)) {
351 : 0 : DPAA2_MEMPOOL_ERR("DPAA2 buffer pool not configured");
352 : 0 : return -ENOMEM;
353 : : }
354 : :
355 : 0 : return bp_info->bpid;
356 : : }
357 : :
358 : : RTE_EXPORT_SYMBOL(rte_dpaa2_mbuf_from_buf_addr)
359 : : struct rte_mbuf *
360 : 0 : rte_dpaa2_mbuf_from_buf_addr(struct rte_mempool *mp, void *buf_addr)
361 : : {
362 : : struct dpaa2_bp_info *bp_info;
363 : :
364 : 0 : bp_info = mempool_to_bpinfo(mp);
365 [ # # ]: 0 : if (!(bp_info->bp_list)) {
366 : 0 : DPAA2_MEMPOOL_ERR("DPAA2 buffer pool not configured");
367 : 0 : return NULL;
368 : : }
369 : :
370 : 0 : return (struct rte_mbuf *)((uint8_t *)buf_addr -
371 : 0 : bp_info->meta_data_size);
372 : : }
373 : :
374 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_dpaa2_mbuf_alloc_bulk)
375 : : int
376 : 0 : rte_dpaa2_mbuf_alloc_bulk(struct rte_mempool *pool,
377 : : void **obj_table, unsigned int count)
378 : : {
379 : : #ifdef RTE_LIBRTE_DPAA2_DEBUG_DRIVER
380 : : static int alloc;
381 : : #endif
382 : : struct qbman_swp *swp;
383 : : uint16_t bpid;
384 : : uint64_t bufs[DPAA2_MBUF_MAX_ACQ_REL];
385 : : int i, ret;
386 : : unsigned int n = 0;
387 : : struct dpaa2_bp_info *bp_info;
388 : :
389 : 0 : bp_info = mempool_to_bpinfo(pool);
390 : :
391 [ # # ]: 0 : if (!(bp_info->bp_list)) {
392 : 0 : DPAA2_MEMPOOL_ERR("DPAA2 buffer pool not configured");
393 : 0 : return -ENOENT;
394 : : }
395 : :
396 : 0 : bpid = bp_info->bpid;
397 : :
398 [ # # ]: 0 : if (unlikely(!DPAA2_PER_LCORE_DPIO)) {
399 : 0 : ret = dpaa2_affine_qbman_swp();
400 [ # # ]: 0 : if (ret) {
401 : 0 : DPAA2_MEMPOOL_ERR("affine portal err: %d, tid: %d",
402 : : ret, rte_gettid());
403 : 0 : return ret;
404 : : }
405 : : }
406 : 0 : swp = DPAA2_PER_LCORE_PORTAL;
407 : :
408 [ # # ]: 0 : if (unlikely(rte_eal_iova_mode() != RTE_IOVA_VA))
409 : 0 : goto iova_pa_acquire;
410 : :
411 [ # # ]: 0 : while (n < count) {
412 : : /* Acquire is all-or-nothing, so we drain in 7s,
413 : : * then the remainder.
414 : : */
415 : 0 : ret = qbman_swp_acquire(swp, bpid, bufs,
416 : 0 : (count - n) > DPAA2_MBUF_MAX_ACQ_REL ?
417 : : DPAA2_MBUF_MAX_ACQ_REL : (count - n));
418 [ # # ]: 0 : if (unlikely(ret <= 0))
419 : 0 : goto acquire_failed;
420 : :
421 : : /* assigning mbuf from the acquired objects */
422 [ # # ]: 0 : for (i = 0; i < ret; i++) {
423 : 0 : DPAA2_VAMODE_MODIFY_IOVA_TO_VADDR(bufs[i],
424 : : size_t);
425 : 0 : obj_table[n] = (void *)(uintptr_t)(bufs[i] -
426 : 0 : bp_info->meta_data_size);
427 : 0 : n++;
428 : : }
429 : : }
430 : 0 : goto acquire_success;
431 : :
432 : : iova_pa_acquire:
433 : :
434 [ # # ]: 0 : while (n < count) {
435 : : /* Acquire is all-or-nothing, so we drain in 7s,
436 : : * then the remainder.
437 : : */
438 : 0 : ret = qbman_swp_acquire(swp, bpid, bufs,
439 : 0 : (count - n) > DPAA2_MBUF_MAX_ACQ_REL ?
440 : : DPAA2_MBUF_MAX_ACQ_REL : (count - n));
441 [ # # ]: 0 : if (unlikely(ret <= 0))
442 : 0 : goto acquire_failed;
443 : :
444 : : /* assigning mbuf from the acquired objects */
445 [ # # ]: 0 : for (i = 0; i < ret; i++) {
446 : 0 : DPAA2_PAMODE_MODIFY_IOVA_TO_VADDR(bufs[i],
447 : : size_t);
448 : 0 : obj_table[n] = (void *)(uintptr_t)(bufs[i] -
449 : 0 : bp_info->meta_data_size);
450 : 0 : n++;
451 : : }
452 : : }
453 : :
454 : 0 : acquire_success:
455 : : #ifdef RTE_LIBRTE_DPAA2_DEBUG_DRIVER
456 : : alloc += n;
457 : : DPAA2_MEMPOOL_DP_DEBUG("Total = %d , req = %d done = %d",
458 : : alloc, count, n);
459 : : #endif
460 : : return 0;
461 : :
462 : 0 : acquire_failed:
463 : : DPAA2_MEMPOOL_DP_DEBUG("Buffer acquire err: %d", ret);
464 : : /* The API expect the exact number of requested bufs */
465 : : /* Releasing all buffers allocated */
466 : 0 : ret = dpaa2_mbuf_release(obj_table, bpid,
467 : : bp_info->meta_data_size, n);
468 [ # # ]: 0 : if (ret != (int)n) {
469 : 0 : DPAA2_MEMPOOL_ERR("%s: expect to free %d!= %d",
470 : : __func__, n, ret);
471 : : }
472 : : return -ENOBUFS;
473 : : }
474 : :
475 : : static int
476 : 0 : rte_hw_mbuf_free_bulk(struct rte_mempool *pool,
477 : : void * const *obj_table, unsigned int n)
478 : : {
479 : : struct dpaa2_bp_info *bp_info;
480 : : int ret;
481 : :
482 : 0 : bp_info = mempool_to_bpinfo(pool);
483 [ # # ]: 0 : if (!(bp_info->bp_list)) {
484 : 0 : DPAA2_MEMPOOL_ERR("DPAA2 buffer pool not configured");
485 : 0 : return -ENOENT;
486 : : }
487 : 0 : ret = dpaa2_mbuf_release(obj_table, bp_info->bpid,
488 : : bp_info->meta_data_size, n);
489 [ # # ]: 0 : if (unlikely(ret != (int)n)) {
490 : 0 : DPAA2_MEMPOOL_ERR("%s: expect to free %d!= %d",
491 : : __func__, n, ret);
492 : :
493 : 0 : return -EIO;
494 : : }
495 : :
496 : : return 0;
497 : : }
498 : :
499 : : static unsigned int
500 : 0 : rte_hw_mbuf_get_count(const struct rte_mempool *mp)
501 : : {
502 : : int ret;
503 : 0 : unsigned int num_of_bufs = 0;
504 : : struct dpaa2_bp_info *bp_info;
505 : : struct dpaa2_dpbp_dev *dpbp_node;
506 : : struct fsl_mc_io mc_io;
507 : :
508 [ # # # # ]: 0 : if (!mp || !mp->pool_data) {
509 : 0 : DPAA2_MEMPOOL_ERR("Invalid mempool provided");
510 : 0 : return 0;
511 : : }
512 : :
513 : : bp_info = (struct dpaa2_bp_info *)mp->pool_data;
514 : 0 : dpbp_node = bp_info->bp_list->buf_pool.dpbp_node;
515 : :
516 : : /* In case as secondary process access stats, MCP portal in priv-hw may
517 : : * have primary process address. Need the secondary process based MCP
518 : : * portal address for this object.
519 : : */
520 : 0 : mc_io.regs = dpaa2_get_mcp_ptr(MC_PORTAL_INDEX);
521 : 0 : ret = dpbp_get_num_free_bufs(&mc_io, CMD_PRI_LOW,
522 : 0 : dpbp_node->token, &num_of_bufs);
523 [ # # ]: 0 : if (ret) {
524 : 0 : DPAA2_MEMPOOL_ERR("Unable to obtain free buf count (err=%d)",
525 : : ret);
526 : 0 : return 0;
527 : : }
528 : :
529 : : DPAA2_MEMPOOL_DP_DEBUG("Free bufs = %u\n", num_of_bufs);
530 : :
531 : 0 : return num_of_bufs;
532 : : }
533 : :
534 : : static int
535 : 0 : dpaa2_populate(struct rte_mempool *mp, unsigned int max_objs,
536 : : void *vaddr, rte_iova_t paddr, size_t len,
537 : : rte_mempool_populate_obj_cb_t *obj_cb, void *obj_cb_arg)
538 : : {
539 : : struct rte_memseg_list *msl;
540 : : int ret;
541 : : /* The memsegment list exists incase the memory is not external.
542 : : * So, DMA-Map is required only when memory is provided by user,
543 : : * i.e. External.
544 : : */
545 : 0 : msl = rte_mem_virt2memseg_list(vaddr);
546 : :
547 [ # # ]: 0 : if (!msl) {
548 : 0 : DPAA2_MEMPOOL_DEBUG("Memsegment is External.");
549 : 0 : ret = rte_fslmc_vfio_mem_dmamap((size_t)vaddr, paddr, len);
550 [ # # ]: 0 : if (ret)
551 : : return ret;
552 : : }
553 : :
554 : 0 : return rte_mempool_op_populate_helper(mp, 0, max_objs, vaddr, paddr,
555 : : len, obj_cb, obj_cb_arg);
556 : : }
557 : :
558 : : static const struct rte_mempool_ops dpaa2_mpool_ops = {
559 : : .name = DPAA2_MEMPOOL_OPS_NAME,
560 : : .alloc = rte_hw_mbuf_create_pool,
561 : : .free = rte_hw_mbuf_free_pool,
562 : : .enqueue = rte_hw_mbuf_free_bulk,
563 : : .dequeue = rte_dpaa2_mbuf_alloc_bulk,
564 : : .get_count = rte_hw_mbuf_get_count,
565 : : .populate = dpaa2_populate,
566 : : };
567 : :
568 : 301 : RTE_MEMPOOL_REGISTER_OPS(dpaa2_mpool_ops);
569 : :
570 [ - + ]: 301 : RTE_LOG_REGISTER_DEFAULT(dpaa2_logtype_mempool, NOTICE);
|
