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