Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2021 HiSilicon Limited
3 : : * Copyright(c) 2021 Intel Corporation
4 : : */
5 : :
6 : : #include <ctype.h>
7 : : #include <inttypes.h>
8 : : #include <stdlib.h>
9 : :
10 : : #include <rte_eal.h>
11 : : #include <rte_lcore.h>
12 : : #include <rte_log.h>
13 : : #include <rte_malloc.h>
14 : : #include <rte_memzone.h>
15 : : #include <rte_string_fns.h>
16 : : #include <rte_telemetry.h>
17 : :
18 : : #include "rte_dmadev.h"
19 : : #include "rte_dmadev_pmd.h"
20 : : #include "rte_dmadev_trace.h"
21 : :
22 : : static int16_t dma_devices_max;
23 : :
24 : : struct rte_dma_fp_object *rte_dma_fp_objs;
25 : : static struct rte_dma_dev *rte_dma_devices;
26 : : static struct {
27 : : /* Hold the dev_max information of the primary process. This field is
28 : : * set by the primary process and is read by the secondary process.
29 : : */
30 : : int16_t dev_max;
31 : : struct rte_dma_dev_data data[0];
32 : : } *dma_devices_shared_data;
33 : :
34 [ - + ]: 235 : RTE_LOG_REGISTER_DEFAULT(rte_dma_logtype, INFO);
35 : : #define RTE_LOGTYPE_DMA rte_dma_logtype
36 : :
37 : : #define RTE_DMA_LOG(level, ...) \
38 : : RTE_LOG_LINE(level, DMA, RTE_FMT("dma: " RTE_FMT_HEAD(__VA_ARGS__ ,), \
39 : : RTE_FMT_TAIL(__VA_ARGS__ ,)))
40 : :
41 : : int
42 : 0 : rte_dma_dev_max(size_t dev_max)
43 : : {
44 : : /* This function may be called before rte_eal_init(), so no rte library
45 : : * function can be called in this function.
46 : : */
47 [ # # ]: 0 : if (dev_max == 0 || dev_max > INT16_MAX)
48 : : return -EINVAL;
49 : :
50 [ # # ]: 0 : if (dma_devices_max > 0)
51 : : return -EINVAL;
52 : :
53 : 0 : dma_devices_max = dev_max;
54 : :
55 : 0 : return 0;
56 : : }
57 : :
58 : : int16_t
59 : 0 : rte_dma_next_dev(int16_t start_dev_id)
60 : : {
61 : : int16_t dev_id = start_dev_id;
62 [ # # # # ]: 0 : while (dev_id < dma_devices_max && rte_dma_devices[dev_id].state == RTE_DMA_DEV_UNUSED)
63 : 0 : dev_id++;
64 : :
65 [ # # ]: 0 : if (dev_id < dma_devices_max)
66 : 0 : return dev_id;
67 : :
68 : : return -1;
69 : : }
70 : :
71 : : static int
72 : 2 : dma_check_name(const char *name)
73 : : {
74 : : size_t name_len;
75 : :
76 [ - + ]: 2 : if (name == NULL) {
77 : 0 : RTE_DMA_LOG(ERR, "Name can't be NULL");
78 : 0 : return -EINVAL;
79 : : }
80 : :
81 : 2 : name_len = strnlen(name, RTE_DEV_NAME_MAX_LEN);
82 [ - + ]: 2 : if (name_len == 0) {
83 : 0 : RTE_DMA_LOG(ERR, "Zero length DMA device name");
84 : 0 : return -EINVAL;
85 : : }
86 [ - + ]: 2 : if (name_len >= RTE_DEV_NAME_MAX_LEN) {
87 : 0 : RTE_DMA_LOG(ERR, "DMA device name is too long");
88 : 0 : return -EINVAL;
89 : : }
90 : :
91 : : return 0;
92 : : }
93 : :
94 : : static int16_t
95 : : dma_find_free_id(void)
96 : : {
97 : : int16_t i;
98 : :
99 [ + - + - ]: 1 : if (rte_dma_devices == NULL || dma_devices_shared_data == NULL)
100 : : return -1;
101 : :
102 [ + - ]: 1 : for (i = 0; i < dma_devices_max; i++) {
103 [ - + ]: 1 : if (dma_devices_shared_data->data[i].dev_name[0] == '\0')
104 : : return i;
105 : : }
106 : :
107 : : return -1;
108 : : }
109 : :
110 : : static struct rte_dma_dev*
111 : 2 : dma_find_by_name(const char *name)
112 : : {
113 : : int16_t i;
114 : :
115 [ + - ]: 2 : if (rte_dma_devices == NULL)
116 : : return NULL;
117 : :
118 [ + + ]: 66 : for (i = 0; i < dma_devices_max; i++) {
119 [ + + ]: 65 : if ((rte_dma_devices[i].state != RTE_DMA_DEV_UNUSED) &&
120 [ + - ]: 1 : (!strcmp(name, rte_dma_devices[i].data->dev_name)))
121 : 1 : return &rte_dma_devices[i];
122 : : }
123 : :
124 : : return NULL;
125 : : }
126 : :
127 : : static void dma_fp_object_dummy(struct rte_dma_fp_object *obj);
128 : :
129 : : static int
130 : 1 : dma_fp_data_prepare(void)
131 : : {
132 : : size_t size;
133 : : void *ptr;
134 : : int i;
135 : :
136 [ + - ]: 1 : if (rte_dma_fp_objs != NULL)
137 : : return 0;
138 : :
139 : : /* Fast-path object must align cacheline, but the return value of malloc
140 : : * may not be aligned to the cache line. Therefore, extra memory is
141 : : * applied for realignment.
142 : : * note: We do not call posix_memalign/aligned_alloc because it is
143 : : * version dependent on libc.
144 : : */
145 : 1 : size = dma_devices_max * sizeof(struct rte_dma_fp_object) +
146 : : RTE_CACHE_LINE_SIZE;
147 : 1 : ptr = malloc(size);
148 [ + - ]: 1 : if (ptr == NULL)
149 : : return -ENOMEM;
150 : : memset(ptr, 0, size);
151 : :
152 : 1 : rte_dma_fp_objs = RTE_PTR_ALIGN(ptr, RTE_CACHE_LINE_SIZE);
153 [ + + ]: 65 : for (i = 0; i < dma_devices_max; i++)
154 : 64 : dma_fp_object_dummy(&rte_dma_fp_objs[i]);
155 : :
156 : : return 0;
157 : : }
158 : :
159 : : static int
160 : 1 : dma_dev_data_prepare(void)
161 : : {
162 : : size_t size;
163 : :
164 [ + - ]: 1 : if (rte_dma_devices != NULL)
165 : : return 0;
166 : :
167 : 1 : size = dma_devices_max * sizeof(struct rte_dma_dev);
168 : 1 : rte_dma_devices = malloc(size);
169 [ + - ]: 1 : if (rte_dma_devices == NULL)
170 : : return -ENOMEM;
171 : : memset(rte_dma_devices, 0, size);
172 : :
173 : 1 : return 0;
174 : : }
175 : :
176 : : static int
177 : 1 : dma_shared_data_prepare(void)
178 : : {
179 : : const char *mz_name = "rte_dma_dev_data";
180 : : const struct rte_memzone *mz;
181 : : size_t size;
182 : :
183 [ + - ]: 1 : if (dma_devices_shared_data != NULL)
184 : : return 0;
185 : :
186 : 1 : size = sizeof(*dma_devices_shared_data) +
187 : 1 : sizeof(struct rte_dma_dev_data) * dma_devices_max;
188 : :
189 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY)
190 : 1 : mz = rte_memzone_reserve(mz_name, size, rte_socket_id(), 0);
191 : : else
192 : 0 : mz = rte_memzone_lookup(mz_name);
193 [ + - ]: 1 : if (mz == NULL)
194 : : return -ENOMEM;
195 : :
196 : 1 : dma_devices_shared_data = mz->addr;
197 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
198 : 1 : memset(dma_devices_shared_data, 0, size);
199 : 1 : dma_devices_shared_data->dev_max = dma_devices_max;
200 : : } else {
201 : 0 : dma_devices_max = dma_devices_shared_data->dev_max;
202 : : }
203 : :
204 : : return 0;
205 : : }
206 : :
207 : : static int
208 : 1 : dma_data_prepare(void)
209 : : {
210 : : int ret;
211 : :
212 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
213 [ + - ]: 1 : if (dma_devices_max == 0)
214 : 1 : dma_devices_max = RTE_DMADEV_DEFAULT_MAX;
215 : 1 : ret = dma_fp_data_prepare();
216 [ + - ]: 1 : if (ret)
217 : : return ret;
218 : 1 : ret = dma_dev_data_prepare();
219 [ + - ]: 1 : if (ret)
220 : : return ret;
221 : 1 : ret = dma_shared_data_prepare();
222 [ - + ]: 1 : if (ret)
223 : 0 : return ret;
224 : : } else {
225 : 0 : ret = dma_shared_data_prepare();
226 [ # # ]: 0 : if (ret)
227 : : return ret;
228 : 0 : ret = dma_fp_data_prepare();
229 [ # # ]: 0 : if (ret)
230 : : return ret;
231 : 0 : ret = dma_dev_data_prepare();
232 [ # # ]: 0 : if (ret)
233 : 0 : return ret;
234 : : }
235 : :
236 : : return 0;
237 : : }
238 : :
239 : : static struct rte_dma_dev *
240 : 1 : dma_allocate_primary(const char *name, int numa_node, size_t private_data_size)
241 : : {
242 : : struct rte_dma_dev *dev;
243 : : void *dev_private;
244 : : int16_t dev_id;
245 : : int ret;
246 : :
247 : 1 : ret = dma_data_prepare();
248 [ - + ]: 1 : if (ret < 0) {
249 : 0 : RTE_DMA_LOG(ERR, "Cannot initialize dmadevs data");
250 : 0 : return NULL;
251 : : }
252 : :
253 : 1 : dev = dma_find_by_name(name);
254 [ - + ]: 1 : if (dev != NULL) {
255 : 0 : RTE_DMA_LOG(ERR, "DMA device already allocated");
256 : 0 : return NULL;
257 : : }
258 : :
259 : 1 : dev_private = rte_zmalloc_socket(name, private_data_size,
260 : : RTE_CACHE_LINE_SIZE, numa_node);
261 [ - + ]: 1 : if (dev_private == NULL) {
262 : 0 : RTE_DMA_LOG(ERR, "Cannot allocate private data");
263 : 0 : return NULL;
264 : : }
265 : :
266 : : dev_id = dma_find_free_id();
267 [ - + ]: 1 : if (dev_id < 0) {
268 : 0 : RTE_DMA_LOG(ERR, "Reached maximum number of DMA devices");
269 : 0 : rte_free(dev_private);
270 : 0 : return NULL;
271 : : }
272 : :
273 : 1 : dev = &rte_dma_devices[dev_id];
274 : 1 : dev->data = &dma_devices_shared_data->data[dev_id];
275 : 1 : rte_strscpy(dev->data->dev_name, name, sizeof(dev->data->dev_name));
276 : 1 : dev->data->dev_id = dev_id;
277 : 1 : dev->data->numa_node = numa_node;
278 : 1 : dev->data->dev_private = dev_private;
279 : :
280 : 1 : return dev;
281 : : }
282 : :
283 : : static struct rte_dma_dev *
284 : 0 : dma_attach_secondary(const char *name)
285 : : {
286 : : struct rte_dma_dev *dev;
287 : : int16_t i;
288 : : int ret;
289 : :
290 : 0 : ret = dma_data_prepare();
291 [ # # ]: 0 : if (ret < 0) {
292 : 0 : RTE_DMA_LOG(ERR, "Cannot initialize dmadevs data");
293 : 0 : return NULL;
294 : : }
295 : :
296 [ # # ]: 0 : for (i = 0; i < dma_devices_max; i++) {
297 [ # # ]: 0 : if (!strcmp(dma_devices_shared_data->data[i].dev_name, name))
298 : : break;
299 : : }
300 [ # # ]: 0 : if (i == dma_devices_max) {
301 : 0 : RTE_DMA_LOG(ERR,
302 : : "Device %s is not driven by the primary process",
303 : : name);
304 : 0 : return NULL;
305 : : }
306 : :
307 : 0 : dev = &rte_dma_devices[i];
308 : 0 : dev->data = &dma_devices_shared_data->data[i];
309 : :
310 : 0 : return dev;
311 : : }
312 : :
313 : : static struct rte_dma_dev *
314 : 1 : dma_allocate(const char *name, int numa_node, size_t private_data_size)
315 : : {
316 : : struct rte_dma_dev *dev;
317 : :
318 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY)
319 : 1 : dev = dma_allocate_primary(name, numa_node, private_data_size);
320 : : else
321 : 0 : dev = dma_attach_secondary(name);
322 : :
323 [ + - ]: 1 : if (dev) {
324 : 1 : dev->fp_obj = &rte_dma_fp_objs[dev->data->dev_id];
325 : : dma_fp_object_dummy(dev->fp_obj);
326 : : }
327 : :
328 : 1 : return dev;
329 : : }
330 : :
331 : : static void
332 : 1 : dma_release(struct rte_dma_dev *dev)
333 : : {
334 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
335 : 1 : rte_free(dev->data->dev_private);
336 : 1 : memset(dev->data, 0, sizeof(struct rte_dma_dev_data));
337 : : }
338 : :
339 : 1 : dma_fp_object_dummy(dev->fp_obj);
340 : : memset(dev, 0, sizeof(struct rte_dma_dev));
341 : 1 : }
342 : :
343 : : struct rte_dma_dev *
344 : 1 : rte_dma_pmd_allocate(const char *name, int numa_node, size_t private_data_size)
345 : : {
346 : : struct rte_dma_dev *dev;
347 : :
348 [ + - + - ]: 1 : if (dma_check_name(name) != 0 || private_data_size == 0)
349 : : return NULL;
350 : :
351 : 1 : dev = dma_allocate(name, numa_node, private_data_size);
352 [ + - ]: 1 : if (dev == NULL)
353 : : return NULL;
354 : :
355 : 1 : dev->state = RTE_DMA_DEV_REGISTERED;
356 : :
357 : 1 : return dev;
358 : : }
359 : :
360 : : int
361 : 1 : rte_dma_pmd_release(const char *name)
362 : : {
363 : : struct rte_dma_dev *dev;
364 : :
365 [ + - ]: 1 : if (dma_check_name(name) != 0)
366 : : return -EINVAL;
367 : :
368 : 1 : dev = dma_find_by_name(name);
369 [ + - ]: 1 : if (dev == NULL)
370 : : return -EINVAL;
371 : :
372 [ + - ]: 1 : if (dev->state == RTE_DMA_DEV_READY)
373 : 1 : return rte_dma_close(dev->data->dev_id);
374 : :
375 : 0 : dma_release(dev);
376 : 0 : return 0;
377 : : }
378 : :
379 : : int
380 : 0 : rte_dma_get_dev_id_by_name(const char *name)
381 : : {
382 : : struct rte_dma_dev *dev;
383 : :
384 [ # # ]: 0 : if (dma_check_name(name) != 0)
385 : : return -EINVAL;
386 : :
387 : 0 : dev = dma_find_by_name(name);
388 [ # # ]: 0 : if (dev == NULL)
389 : : return -EINVAL;
390 : :
391 : 0 : return dev->data->dev_id;
392 : : }
393 : :
394 : : bool
395 : 1 : rte_dma_is_valid(int16_t dev_id)
396 : : {
397 [ + - ]: 1 : return (dev_id >= 0) && (dev_id < dma_devices_max) &&
398 [ + - + - ]: 2 : rte_dma_devices != NULL &&
399 [ - + ]: 1 : rte_dma_devices[dev_id].state != RTE_DMA_DEV_UNUSED;
400 : : }
401 : :
402 : : uint16_t
403 : 0 : rte_dma_count_avail(void)
404 : : {
405 : : uint16_t count = 0;
406 : : uint16_t i;
407 : :
408 [ # # ]: 0 : if (rte_dma_devices == NULL)
409 : : return count;
410 : :
411 [ # # ]: 0 : for (i = 0; i < dma_devices_max; i++) {
412 [ # # ]: 0 : if (rte_dma_devices[i].state != RTE_DMA_DEV_UNUSED)
413 : 0 : count++;
414 : : }
415 : :
416 : : return count;
417 : : }
418 : :
419 : : int
420 : 0 : rte_dma_info_get(int16_t dev_id, struct rte_dma_info *dev_info)
421 : : {
422 : 0 : const struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
423 : : int ret;
424 : :
425 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || dev_info == NULL)
426 : : return -EINVAL;
427 : :
428 [ # # ]: 0 : if (*dev->dev_ops->dev_info_get == NULL)
429 : : return -ENOTSUP;
430 : : memset(dev_info, 0, sizeof(struct rte_dma_info));
431 : 0 : ret = (*dev->dev_ops->dev_info_get)(dev, dev_info,
432 : : sizeof(struct rte_dma_info));
433 [ # # ]: 0 : if (ret != 0)
434 : : return ret;
435 : :
436 : 0 : dev_info->dev_name = dev->data->dev_name;
437 : 0 : dev_info->numa_node = dev->device->numa_node;
438 [ # # ]: 0 : dev_info->nb_vchans = dev->data->dev_conf.nb_vchans;
439 : :
440 : 0 : rte_dma_trace_info_get(dev_id, dev_info);
441 : :
442 : 0 : return 0;
443 : : }
444 : :
445 : : int
446 : 0 : rte_dma_configure(int16_t dev_id, const struct rte_dma_conf *dev_conf)
447 : : {
448 : 0 : struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
449 : : struct rte_dma_info dev_info;
450 : : int ret;
451 : :
452 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || dev_conf == NULL)
453 : : return -EINVAL;
454 : :
455 [ # # ]: 0 : if (dev->data->dev_started != 0) {
456 : 0 : RTE_DMA_LOG(ERR,
457 : : "Device %d must be stopped to allow configuration",
458 : : dev_id);
459 : 0 : return -EBUSY;
460 : : }
461 : :
462 : 0 : ret = rte_dma_info_get(dev_id, &dev_info);
463 [ # # ]: 0 : if (ret != 0) {
464 : 0 : RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
465 : 0 : return -EINVAL;
466 : : }
467 [ # # ]: 0 : if (dev_conf->nb_vchans == 0) {
468 : 0 : RTE_DMA_LOG(ERR,
469 : : "Device %d configure zero vchans", dev_id);
470 : 0 : return -EINVAL;
471 : : }
472 [ # # ]: 0 : if (dev_conf->nb_vchans > dev_info.max_vchans) {
473 : 0 : RTE_DMA_LOG(ERR,
474 : : "Device %d configure too many vchans", dev_id);
475 : 0 : return -EINVAL;
476 : : }
477 [ # # ]: 0 : if (dev_conf->enable_silent &&
478 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_SILENT)) {
479 : 0 : RTE_DMA_LOG(ERR, "Device %d don't support silent", dev_id);
480 : 0 : return -EINVAL;
481 : : }
482 : :
483 [ # # ]: 0 : if (*dev->dev_ops->dev_configure == NULL)
484 : : return -ENOTSUP;
485 : 0 : ret = (*dev->dev_ops->dev_configure)(dev, dev_conf,
486 : : sizeof(struct rte_dma_conf));
487 [ # # ]: 0 : if (ret == 0)
488 : 0 : memcpy(&dev->data->dev_conf, dev_conf,
489 : : sizeof(struct rte_dma_conf));
490 : :
491 : 0 : rte_dma_trace_configure(dev_id, dev_conf, ret);
492 : :
493 : 0 : return ret;
494 : : }
495 : :
496 : : int
497 : 0 : rte_dma_start(int16_t dev_id)
498 : : {
499 : 0 : struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
500 : : int ret;
501 : :
502 [ # # ]: 0 : if (!rte_dma_is_valid(dev_id))
503 : : return -EINVAL;
504 : :
505 [ # # ]: 0 : if (dev->data->dev_conf.nb_vchans == 0) {
506 : 0 : RTE_DMA_LOG(ERR, "Device %d must be configured first", dev_id);
507 : 0 : return -EINVAL;
508 : : }
509 : :
510 [ # # ]: 0 : if (dev->data->dev_started != 0) {
511 : 0 : RTE_DMA_LOG(WARNING, "Device %d already started", dev_id);
512 : 0 : return 0;
513 : : }
514 : :
515 [ # # ]: 0 : if (dev->dev_ops->dev_start == NULL)
516 : 0 : goto mark_started;
517 : :
518 : 0 : ret = (*dev->dev_ops->dev_start)(dev);
519 : 0 : rte_dma_trace_start(dev_id, ret);
520 [ # # ]: 0 : if (ret != 0)
521 : : return ret;
522 : :
523 : 0 : mark_started:
524 : 0 : dev->data->dev_started = 1;
525 : 0 : return 0;
526 : : }
527 : :
528 : : int
529 : 0 : rte_dma_stop(int16_t dev_id)
530 : : {
531 : 0 : struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
532 : : int ret;
533 : :
534 [ # # ]: 0 : if (!rte_dma_is_valid(dev_id))
535 : : return -EINVAL;
536 : :
537 [ # # ]: 0 : if (dev->data->dev_started == 0) {
538 : 0 : RTE_DMA_LOG(WARNING, "Device %d already stopped", dev_id);
539 : 0 : return 0;
540 : : }
541 : :
542 [ # # ]: 0 : if (dev->dev_ops->dev_stop == NULL)
543 : 0 : goto mark_stopped;
544 : :
545 : 0 : ret = (*dev->dev_ops->dev_stop)(dev);
546 : 0 : rte_dma_trace_stop(dev_id, ret);
547 [ # # ]: 0 : if (ret != 0)
548 : : return ret;
549 : :
550 : 0 : mark_stopped:
551 : 0 : dev->data->dev_started = 0;
552 : 0 : return 0;
553 : : }
554 : :
555 : : int
556 : 1 : rte_dma_close(int16_t dev_id)
557 : : {
558 : 1 : struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
559 : : int ret;
560 : :
561 [ + - ]: 1 : if (!rte_dma_is_valid(dev_id))
562 : : return -EINVAL;
563 : :
564 : : /* Device must be stopped before it can be closed */
565 [ - + ]: 1 : if (dev->data->dev_started == 1) {
566 : 0 : RTE_DMA_LOG(ERR,
567 : : "Device %d must be stopped before closing", dev_id);
568 : 0 : return -EBUSY;
569 : : }
570 : :
571 [ + - ]: 1 : if (*dev->dev_ops->dev_close == NULL)
572 : : return -ENOTSUP;
573 : 1 : ret = (*dev->dev_ops->dev_close)(dev);
574 [ + - ]: 1 : if (ret == 0)
575 : 1 : dma_release(dev);
576 : :
577 : 1 : rte_dma_trace_close(dev_id, ret);
578 : :
579 : 1 : return ret;
580 : : }
581 : :
582 : : int
583 : 0 : rte_dma_vchan_setup(int16_t dev_id, uint16_t vchan,
584 : : const struct rte_dma_vchan_conf *conf)
585 : : {
586 : 0 : struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
587 : : struct rte_dma_info dev_info;
588 : : bool src_is_dev, dst_is_dev;
589 : : int ret;
590 : :
591 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || conf == NULL)
592 : : return -EINVAL;
593 : :
594 [ # # ]: 0 : if (dev->data->dev_started != 0) {
595 : 0 : RTE_DMA_LOG(ERR,
596 : : "Device %d must be stopped to allow configuration",
597 : : dev_id);
598 : 0 : return -EBUSY;
599 : : }
600 : :
601 : 0 : ret = rte_dma_info_get(dev_id, &dev_info);
602 [ # # ]: 0 : if (ret != 0) {
603 : 0 : RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
604 : 0 : return -EINVAL;
605 : : }
606 [ # # ]: 0 : if (dev->data->dev_conf.nb_vchans == 0) {
607 : 0 : RTE_DMA_LOG(ERR, "Device %d must be configured first", dev_id);
608 : 0 : return -EINVAL;
609 : : }
610 [ # # ]: 0 : if (vchan >= dev_info.nb_vchans) {
611 : 0 : RTE_DMA_LOG(ERR, "Device %d vchan out range!", dev_id);
612 : 0 : return -EINVAL;
613 : : }
614 [ # # ]: 0 : if (conf->direction != RTE_DMA_DIR_MEM_TO_MEM &&
615 : : conf->direction != RTE_DMA_DIR_MEM_TO_DEV &&
616 : : conf->direction != RTE_DMA_DIR_DEV_TO_MEM &&
617 : : conf->direction != RTE_DMA_DIR_DEV_TO_DEV) {
618 : 0 : RTE_DMA_LOG(ERR, "Device %d direction invalid!", dev_id);
619 : 0 : return -EINVAL;
620 : : }
621 [ # # ]: 0 : if (conf->direction == RTE_DMA_DIR_MEM_TO_MEM &&
622 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_MEM_TO_MEM)) {
623 : 0 : RTE_DMA_LOG(ERR,
624 : : "Device %d don't support mem2mem transfer", dev_id);
625 : 0 : return -EINVAL;
626 : : }
627 [ # # ]: 0 : if (conf->direction == RTE_DMA_DIR_MEM_TO_DEV &&
628 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_MEM_TO_DEV)) {
629 : 0 : RTE_DMA_LOG(ERR,
630 : : "Device %d don't support mem2dev transfer", dev_id);
631 : 0 : return -EINVAL;
632 : : }
633 [ # # ]: 0 : if (conf->direction == RTE_DMA_DIR_DEV_TO_MEM &&
634 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_DEV_TO_MEM)) {
635 : 0 : RTE_DMA_LOG(ERR,
636 : : "Device %d don't support dev2mem transfer", dev_id);
637 : 0 : return -EINVAL;
638 : : }
639 [ # # ]: 0 : if (conf->direction == RTE_DMA_DIR_DEV_TO_DEV &&
640 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_DEV_TO_DEV)) {
641 : 0 : RTE_DMA_LOG(ERR,
642 : : "Device %d don't support dev2dev transfer", dev_id);
643 : 0 : return -EINVAL;
644 : : }
645 [ # # ]: 0 : if (conf->nb_desc < dev_info.min_desc ||
646 [ # # ]: 0 : conf->nb_desc > dev_info.max_desc) {
647 : 0 : RTE_DMA_LOG(ERR,
648 : : "Device %d number of descriptors invalid", dev_id);
649 : 0 : return -EINVAL;
650 : : }
651 : 0 : src_is_dev = conf->direction == RTE_DMA_DIR_DEV_TO_MEM ||
652 : : conf->direction == RTE_DMA_DIR_DEV_TO_DEV;
653 [ # # # # : 0 : if ((conf->src_port.port_type == RTE_DMA_PORT_NONE && src_is_dev) ||
# # ]
654 [ # # ]: 0 : (conf->src_port.port_type != RTE_DMA_PORT_NONE && !src_is_dev)) {
655 : 0 : RTE_DMA_LOG(ERR, "Device %d source port type invalid", dev_id);
656 : 0 : return -EINVAL;
657 : : }
658 : 0 : dst_is_dev = conf->direction == RTE_DMA_DIR_MEM_TO_DEV ||
659 : : conf->direction == RTE_DMA_DIR_DEV_TO_DEV;
660 [ # # # # : 0 : if ((conf->dst_port.port_type == RTE_DMA_PORT_NONE && dst_is_dev) ||
# # ]
661 [ # # ]: 0 : (conf->dst_port.port_type != RTE_DMA_PORT_NONE && !dst_is_dev)) {
662 : 0 : RTE_DMA_LOG(ERR,
663 : : "Device %d destination port type invalid", dev_id);
664 : 0 : return -EINVAL;
665 : : }
666 : :
667 [ # # ]: 0 : if (*dev->dev_ops->vchan_setup == NULL)
668 : : return -ENOTSUP;
669 : 0 : ret = (*dev->dev_ops->vchan_setup)(dev, vchan, conf,
670 : : sizeof(struct rte_dma_vchan_conf));
671 : 0 : rte_dma_trace_vchan_setup(dev_id, vchan, conf, ret);
672 : :
673 : 0 : return ret;
674 : : }
675 : :
676 : : int
677 : 0 : rte_dma_stats_get(int16_t dev_id, uint16_t vchan, struct rte_dma_stats *stats)
678 : : {
679 : 0 : const struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
680 : :
681 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || stats == NULL)
682 : : return -EINVAL;
683 : :
684 [ # # # # ]: 0 : if (vchan >= dev->data->dev_conf.nb_vchans &&
685 : : vchan != RTE_DMA_ALL_VCHAN) {
686 : 0 : RTE_DMA_LOG(ERR,
687 : : "Device %d vchan %u out of range", dev_id, vchan);
688 : 0 : return -EINVAL;
689 : : }
690 : :
691 [ # # ]: 0 : if (*dev->dev_ops->stats_get == NULL)
692 : : return -ENOTSUP;
693 : : memset(stats, 0, sizeof(struct rte_dma_stats));
694 : 0 : return (*dev->dev_ops->stats_get)(dev, vchan, stats,
695 : : sizeof(struct rte_dma_stats));
696 : : }
697 : :
698 : : int
699 : 0 : rte_dma_stats_reset(int16_t dev_id, uint16_t vchan)
700 : : {
701 : 0 : struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
702 : : int ret;
703 : :
704 [ # # ]: 0 : if (!rte_dma_is_valid(dev_id))
705 : : return -EINVAL;
706 : :
707 [ # # # # ]: 0 : if (vchan >= dev->data->dev_conf.nb_vchans &&
708 : : vchan != RTE_DMA_ALL_VCHAN) {
709 : 0 : RTE_DMA_LOG(ERR,
710 : : "Device %d vchan %u out of range", dev_id, vchan);
711 : 0 : return -EINVAL;
712 : : }
713 : :
714 [ # # ]: 0 : if (*dev->dev_ops->stats_reset == NULL)
715 : : return -ENOTSUP;
716 : 0 : ret = (*dev->dev_ops->stats_reset)(dev, vchan);
717 : 0 : rte_dma_trace_stats_reset(dev_id, vchan, ret);
718 : :
719 : 0 : return ret;
720 : : }
721 : :
722 : : int
723 : 0 : rte_dma_vchan_status(int16_t dev_id, uint16_t vchan, enum rte_dma_vchan_status *status)
724 : : {
725 : 0 : struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
726 : :
727 [ # # ]: 0 : if (!rte_dma_is_valid(dev_id))
728 : : return -EINVAL;
729 : :
730 [ # # ]: 0 : if (vchan >= dev->data->dev_conf.nb_vchans) {
731 : 0 : RTE_DMA_LOG(ERR, "Device %u vchan %u out of range", dev_id, vchan);
732 : 0 : return -EINVAL;
733 : : }
734 : :
735 [ # # ]: 0 : if (*dev->dev_ops->vchan_status == NULL)
736 : : return -ENOTSUP;
737 : 0 : return (*dev->dev_ops->vchan_status)(dev, vchan, status);
738 : : }
739 : :
740 : : static const char *
741 : : dma_capability_name(uint64_t capability)
742 : : {
743 : : static const struct {
744 : : uint64_t capability;
745 : : const char *name;
746 : : } capa_names[] = {
747 : : { RTE_DMA_CAPA_MEM_TO_MEM, "mem2mem" },
748 : : { RTE_DMA_CAPA_MEM_TO_DEV, "mem2dev" },
749 : : { RTE_DMA_CAPA_DEV_TO_MEM, "dev2mem" },
750 : : { RTE_DMA_CAPA_DEV_TO_DEV, "dev2dev" },
751 : : { RTE_DMA_CAPA_SVA, "sva" },
752 : : { RTE_DMA_CAPA_SILENT, "silent" },
753 : : { RTE_DMA_CAPA_HANDLES_ERRORS, "handles_errors" },
754 : : { RTE_DMA_CAPA_OPS_COPY, "copy" },
755 : : { RTE_DMA_CAPA_OPS_COPY_SG, "copy_sg" },
756 : : { RTE_DMA_CAPA_OPS_FILL, "fill" },
757 : : };
758 : :
759 : : const char *name = "unknown";
760 : : uint32_t i;
761 : :
762 [ # # # # : 0 : for (i = 0; i < RTE_DIM(capa_names); i++) {
# # # # #
# # # # #
# # # # #
# ]
763 [ # # # # : 0 : if (capability == capa_names[i].capability) {
# # # # #
# # # # #
# # # # #
# ]
764 : 0 : name = capa_names[i].name;
765 : 0 : break;
766 : : }
767 : : }
768 : :
769 : : return name;
770 : : }
771 : :
772 : : static void
773 : 0 : dma_dump_capability(FILE *f, uint64_t dev_capa)
774 : : {
775 : : uint64_t capa;
776 : :
777 : : (void)fprintf(f, " dev_capa: 0x%" PRIx64 " -", dev_capa);
778 [ # # ]: 0 : while (dev_capa > 0) {
779 : 0 : capa = 1ull << rte_ctz64(dev_capa);
780 : : (void)fprintf(f, " %s", dma_capability_name(capa));
781 : 0 : dev_capa &= ~capa;
782 : : }
783 : : (void)fprintf(f, "\n");
784 : 0 : }
785 : :
786 : : int
787 : 0 : rte_dma_dump(int16_t dev_id, FILE *f)
788 : : {
789 : 0 : const struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
790 : : struct rte_dma_info dev_info;
791 : : int ret;
792 : :
793 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || f == NULL)
794 : : return -EINVAL;
795 : :
796 : 0 : ret = rte_dma_info_get(dev_id, &dev_info);
797 [ # # ]: 0 : if (ret != 0) {
798 : 0 : RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
799 : 0 : return -EINVAL;
800 : : }
801 : :
802 : 0 : (void)fprintf(f, "DMA Dev %d, '%s' [%s]\n",
803 : 0 : dev->data->dev_id,
804 : 0 : dev->data->dev_name,
805 [ # # ]: 0 : dev->data->dev_started ? "started" : "stopped");
806 : 0 : dma_dump_capability(f, dev_info.dev_capa);
807 : 0 : (void)fprintf(f, " max_vchans_supported: %u\n", dev_info.max_vchans);
808 : 0 : (void)fprintf(f, " nb_vchans_configured: %u\n", dev_info.nb_vchans);
809 : 0 : (void)fprintf(f, " silent_mode: %s\n",
810 [ # # ]: 0 : dev->data->dev_conf.enable_silent ? "on" : "off");
811 : :
812 [ # # ]: 0 : if (dev->dev_ops->dev_dump != NULL)
813 : 0 : ret = (*dev->dev_ops->dev_dump)(dev, f);
814 : 0 : rte_dma_trace_dump(dev_id, f, ret);
815 : :
816 : 0 : return ret;
817 : : }
818 : :
819 : : static int
820 : 0 : dummy_copy(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
821 : : __rte_unused rte_iova_t src, __rte_unused rte_iova_t dst,
822 : : __rte_unused uint32_t length, __rte_unused uint64_t flags)
823 : : {
824 : 0 : RTE_DMA_LOG(ERR, "copy is not configured or not supported.");
825 : 0 : return -EINVAL;
826 : : }
827 : :
828 : : static int
829 : 0 : dummy_copy_sg(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
830 : : __rte_unused const struct rte_dma_sge *src,
831 : : __rte_unused const struct rte_dma_sge *dst,
832 : : __rte_unused uint16_t nb_src, __rte_unused uint16_t nb_dst,
833 : : __rte_unused uint64_t flags)
834 : : {
835 : 0 : RTE_DMA_LOG(ERR, "copy_sg is not configured or not supported.");
836 : 0 : return -EINVAL;
837 : : }
838 : :
839 : : static int
840 : 0 : dummy_fill(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
841 : : __rte_unused uint64_t pattern, __rte_unused rte_iova_t dst,
842 : : __rte_unused uint32_t length, __rte_unused uint64_t flags)
843 : : {
844 : 0 : RTE_DMA_LOG(ERR, "fill is not configured or not supported.");
845 : 0 : return -EINVAL;
846 : : }
847 : :
848 : : static int
849 : 0 : dummy_submit(__rte_unused void *dev_private, __rte_unused uint16_t vchan)
850 : : {
851 : 0 : RTE_DMA_LOG(ERR, "submit is not configured or not supported.");
852 : 0 : return -EINVAL;
853 : : }
854 : :
855 : : static uint16_t
856 : 0 : dummy_completed(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
857 : : __rte_unused const uint16_t nb_cpls,
858 : : __rte_unused uint16_t *last_idx, __rte_unused bool *has_error)
859 : : {
860 : 0 : RTE_DMA_LOG(ERR, "completed is not configured or not supported.");
861 : 0 : return 0;
862 : : }
863 : :
864 : : static uint16_t
865 : 0 : dummy_completed_status(__rte_unused void *dev_private,
866 : : __rte_unused uint16_t vchan,
867 : : __rte_unused const uint16_t nb_cpls,
868 : : __rte_unused uint16_t *last_idx,
869 : : __rte_unused enum rte_dma_status_code *status)
870 : : {
871 : 0 : RTE_DMA_LOG(ERR,
872 : : "completed_status is not configured or not supported.");
873 : 0 : return 0;
874 : : }
875 : :
876 : : static uint16_t
877 : 0 : dummy_burst_capacity(__rte_unused const void *dev_private,
878 : : __rte_unused uint16_t vchan)
879 : : {
880 : 0 : RTE_DMA_LOG(ERR, "burst_capacity is not configured or not supported.");
881 : 0 : return 0;
882 : : }
883 : :
884 : : static void
885 : : dma_fp_object_dummy(struct rte_dma_fp_object *obj)
886 : : {
887 : 66 : obj->dev_private = NULL;
888 : 66 : obj->copy = dummy_copy;
889 : 66 : obj->copy_sg = dummy_copy_sg;
890 : 66 : obj->fill = dummy_fill;
891 : 66 : obj->submit = dummy_submit;
892 : 66 : obj->completed = dummy_completed;
893 : 66 : obj->completed_status = dummy_completed_status;
894 : 64 : obj->burst_capacity = dummy_burst_capacity;
895 : 1 : }
896 : :
897 : : static int
898 : 0 : dmadev_handle_dev_list(const char *cmd __rte_unused,
899 : : const char *params __rte_unused,
900 : : struct rte_tel_data *d)
901 : : {
902 : : int dev_id;
903 : :
904 : 0 : rte_tel_data_start_array(d, RTE_TEL_INT_VAL);
905 [ # # ]: 0 : for (dev_id = 0; dev_id < dma_devices_max; dev_id++)
906 [ # # ]: 0 : if (rte_dma_is_valid(dev_id))
907 : 0 : rte_tel_data_add_array_int(d, dev_id);
908 : :
909 : 0 : return 0;
910 : : }
911 : :
912 : : #define ADD_CAPA(td, dc, c) rte_tel_data_add_dict_int(td, dma_capability_name(c), !!(dc & c))
913 : :
914 : : static int
915 : 0 : dmadev_handle_dev_info(const char *cmd __rte_unused,
916 : : const char *params, struct rte_tel_data *d)
917 : : {
918 : : struct rte_dma_info dma_info;
919 : : struct rte_tel_data *dma_caps;
920 : : int dev_id, ret;
921 : : uint64_t dev_capa;
922 : : char *end_param;
923 : :
924 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
925 : : return -EINVAL;
926 : :
927 : 0 : dev_id = strtoul(params, &end_param, 0);
928 [ # # ]: 0 : if (*end_param != '\0')
929 : 0 : RTE_DMA_LOG(WARNING, "Extra parameters passed to dmadev telemetry command, ignoring");
930 : :
931 : : /* Function info_get validates dev_id so we don't need to. */
932 : 0 : ret = rte_dma_info_get(dev_id, &dma_info);
933 [ # # ]: 0 : if (ret < 0)
934 : : return -EINVAL;
935 : 0 : dev_capa = dma_info.dev_capa;
936 : :
937 : 0 : rte_tel_data_start_dict(d);
938 : 0 : rte_tel_data_add_dict_string(d, "name", dma_info.dev_name);
939 : 0 : rte_tel_data_add_dict_int(d, "nb_vchans", dma_info.nb_vchans);
940 : 0 : rte_tel_data_add_dict_int(d, "numa_node", dma_info.numa_node);
941 : 0 : rte_tel_data_add_dict_int(d, "max_vchans", dma_info.max_vchans);
942 : 0 : rte_tel_data_add_dict_int(d, "max_desc", dma_info.max_desc);
943 : 0 : rte_tel_data_add_dict_int(d, "min_desc", dma_info.min_desc);
944 : 0 : rte_tel_data_add_dict_int(d, "max_sges", dma_info.max_sges);
945 : :
946 : 0 : dma_caps = rte_tel_data_alloc();
947 [ # # ]: 0 : if (!dma_caps)
948 : : return -ENOMEM;
949 : :
950 : 0 : rte_tel_data_start_dict(dma_caps);
951 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_MEM_TO_MEM);
952 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_MEM_TO_DEV);
953 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_DEV_TO_MEM);
954 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_DEV_TO_DEV);
955 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_SVA);
956 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_SILENT);
957 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_HANDLES_ERRORS);
958 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_COPY);
959 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_COPY_SG);
960 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_FILL);
961 : 0 : rte_tel_data_add_dict_container(d, "capabilities", dma_caps, 0);
962 : :
963 : 0 : return 0;
964 : : }
965 : :
966 : : #define ADD_DICT_STAT(s) rte_tel_data_add_dict_uint(d, #s, dma_stats.s)
967 : :
968 : : static int
969 : 0 : dmadev_handle_dev_stats(const char *cmd __rte_unused,
970 : : const char *params,
971 : : struct rte_tel_data *d)
972 : : {
973 : : struct rte_dma_info dma_info;
974 : : struct rte_dma_stats dma_stats;
975 : : int dev_id, ret, vchan_id;
976 : : char *end_param;
977 : : const char *vchan_param;
978 : :
979 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
980 : : return -EINVAL;
981 : :
982 : 0 : dev_id = strtoul(params, &end_param, 0);
983 : :
984 : : /* Function info_get validates dev_id so we don't need to. */
985 : 0 : ret = rte_dma_info_get(dev_id, &dma_info);
986 [ # # ]: 0 : if (ret < 0)
987 : : return -EINVAL;
988 : :
989 : : /* If the device has one vchan the user does not need to supply the
990 : : * vchan id and only the device id is needed, no extra parameters.
991 : : */
992 [ # # # # ]: 0 : if (dma_info.nb_vchans == 1 && *end_param == '\0')
993 : : vchan_id = 0;
994 : : else {
995 : 0 : vchan_param = strtok(end_param, ",");
996 [ # # # # : 0 : if (!vchan_param || strlen(vchan_param) == 0 || !isdigit(*vchan_param))
# # ]
997 : : return -EINVAL;
998 : :
999 : 0 : vchan_id = strtoul(vchan_param, &end_param, 0);
1000 : : }
1001 [ # # ]: 0 : if (*end_param != '\0')
1002 : 0 : RTE_DMA_LOG(WARNING, "Extra parameters passed to dmadev telemetry command, ignoring");
1003 : :
1004 : 0 : ret = rte_dma_stats_get(dev_id, vchan_id, &dma_stats);
1005 [ # # ]: 0 : if (ret < 0)
1006 : : return -EINVAL;
1007 : :
1008 : 0 : rte_tel_data_start_dict(d);
1009 : 0 : ADD_DICT_STAT(submitted);
1010 : 0 : ADD_DICT_STAT(completed);
1011 : 0 : ADD_DICT_STAT(errors);
1012 : :
1013 : 0 : return 0;
1014 : : }
1015 : :
1016 : : #ifndef RTE_EXEC_ENV_WINDOWS
1017 : : static int
1018 : 0 : dmadev_handle_dev_dump(const char *cmd __rte_unused,
1019 : : const char *params,
1020 : : struct rte_tel_data *d)
1021 : : {
1022 : : char *buf, *end_param;
1023 : : int dev_id, ret;
1024 : : FILE *f;
1025 : :
1026 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
1027 : : return -EINVAL;
1028 : :
1029 : 0 : dev_id = strtoul(params, &end_param, 0);
1030 [ # # ]: 0 : if (*end_param != '\0')
1031 : 0 : RTE_DMA_LOG(WARNING, "Extra parameters passed to dmadev telemetry command, ignoring");
1032 : :
1033 : 0 : buf = calloc(sizeof(char), RTE_TEL_MAX_SINGLE_STRING_LEN);
1034 [ # # ]: 0 : if (buf == NULL)
1035 : : return -ENOMEM;
1036 : :
1037 : 0 : f = fmemopen(buf, RTE_TEL_MAX_SINGLE_STRING_LEN - 1, "w+");
1038 [ # # ]: 0 : if (f == NULL) {
1039 : 0 : free(buf);
1040 : 0 : return -EINVAL;
1041 : : }
1042 : :
1043 : 0 : ret = rte_dma_dump(dev_id, f);
1044 : 0 : fclose(f);
1045 [ # # ]: 0 : if (ret == 0) {
1046 : 0 : rte_tel_data_start_dict(d);
1047 : 0 : rte_tel_data_string(d, buf);
1048 : : }
1049 : :
1050 : 0 : free(buf);
1051 : 0 : return ret;
1052 : : }
1053 : : #endif /* !RTE_EXEC_ENV_WINDOWS */
1054 : :
1055 : 235 : RTE_INIT(dmadev_init_telemetry)
1056 : : {
1057 : 235 : rte_telemetry_register_cmd("/dmadev/list", dmadev_handle_dev_list,
1058 : : "Returns list of available dmadev devices by IDs. No parameters.");
1059 : 235 : rte_telemetry_register_cmd("/dmadev/info", dmadev_handle_dev_info,
1060 : : "Returns information for a dmadev. Parameters: int dev_id");
1061 : 235 : rte_telemetry_register_cmd("/dmadev/stats", dmadev_handle_dev_stats,
1062 : : "Returns the stats for a dmadev vchannel. Parameters: int dev_id, vchan_id (Optional if only one vchannel)");
1063 : : #ifndef RTE_EXEC_ENV_WINDOWS
1064 : 235 : rte_telemetry_register_cmd("/dmadev/dump", dmadev_handle_dev_dump,
1065 : : "Returns dump information for a dmadev. Parameters: int dev_id");
1066 : : #endif
1067 : 235 : }
|