Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2017-2018 Intel Corporation
3 : : */
4 : :
5 : : #include <string.h>
6 : : #include <stdio.h>
7 : : #include <inttypes.h>
8 : :
9 : : #include <rte_string_fns.h>
10 : : #include <rte_malloc.h>
11 : : #include <dev_driver.h>
12 : : #include <rte_eal.h>
13 : : #include <rte_memzone.h>
14 : :
15 : : #include "rte_compressdev.h"
16 : : #include "rte_compressdev_internal.h"
17 : : #include "rte_compressdev_pmd.h"
18 : :
19 : : #define RTE_COMPRESSDEV_DETACHED (0)
20 : : #define RTE_COMPRESSDEV_ATTACHED (1)
21 : :
22 : : static struct rte_compressdev rte_comp_devices[RTE_COMPRESS_MAX_DEVS];
23 : :
24 : : static struct rte_compressdev_global compressdev_globals = {
25 : : .devs = rte_comp_devices,
26 : : .data = { NULL },
27 : : .nb_devs = 0,
28 : : .max_devs = RTE_COMPRESS_MAX_DEVS
29 : : };
30 : :
31 : : const struct rte_compressdev_capabilities *
32 : 0 : rte_compressdev_capability_get(uint8_t dev_id,
33 : : enum rte_comp_algorithm algo)
34 : : {
35 : : const struct rte_compressdev_capabilities *capability;
36 : : struct rte_compressdev_info dev_info;
37 : : int i = 0;
38 : :
39 [ # # ]: 0 : if (dev_id >= compressdev_globals.nb_devs) {
40 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
41 : 0 : return NULL;
42 : : }
43 : 0 : rte_compressdev_info_get(dev_id, &dev_info);
44 : :
45 [ # # ]: 0 : while ((capability = &dev_info.capabilities[i++])->algo !=
46 : : RTE_COMP_ALGO_UNSPECIFIED){
47 [ # # ]: 0 : if (capability->algo == algo)
48 : 0 : return capability;
49 : : }
50 : :
51 : : return NULL;
52 : : }
53 : :
54 : : const char *
55 : 0 : rte_compressdev_get_feature_name(uint64_t flag)
56 : : {
57 [ # # # # : 0 : switch (flag) {
# # # # ]
58 : : case RTE_COMPDEV_FF_HW_ACCELERATED:
59 : : return "HW_ACCELERATED";
60 : 0 : case RTE_COMPDEV_FF_CPU_SSE:
61 : 0 : return "CPU_SSE";
62 : 0 : case RTE_COMPDEV_FF_CPU_AVX:
63 : 0 : return "CPU_AVX";
64 : 0 : case RTE_COMPDEV_FF_CPU_AVX2:
65 : 0 : return "CPU_AVX2";
66 : 0 : case RTE_COMPDEV_FF_CPU_AVX512:
67 : 0 : return "CPU_AVX512";
68 : 0 : case RTE_COMPDEV_FF_CPU_NEON:
69 : 0 : return "CPU_NEON";
70 : 0 : case RTE_COMPDEV_FF_OP_DONE_IN_DEQUEUE:
71 : 0 : return "OP_DONE_IN_DEQ";
72 : 0 : default:
73 : 0 : return NULL;
74 : : }
75 : : }
76 : :
77 : : static struct rte_compressdev *
78 : : rte_compressdev_get_dev(uint8_t dev_id)
79 : : {
80 : 0 : return &compressdev_globals.devs[dev_id];
81 : : }
82 : :
83 : : struct rte_compressdev *
84 : 0 : rte_compressdev_pmd_get_named_dev(const char *name)
85 : : {
86 : : struct rte_compressdev *dev;
87 : : unsigned int i;
88 : :
89 [ # # ]: 0 : if (name == NULL)
90 : : return NULL;
91 : :
92 [ # # ]: 0 : for (i = 0; i < compressdev_globals.max_devs; i++) {
93 : 0 : dev = &compressdev_globals.devs[i];
94 : :
95 [ # # ]: 0 : if ((dev->attached == RTE_COMPRESSDEV_ATTACHED) &&
96 [ # # ]: 0 : (strcmp(dev->data->name, name) == 0))
97 : 0 : return dev;
98 : : }
99 : :
100 : : return NULL;
101 : : }
102 : :
103 : : static unsigned int
104 : : rte_compressdev_is_valid_dev(uint8_t dev_id)
105 : : {
106 : : struct rte_compressdev *dev = NULL;
107 : :
108 [ # # ]: 0 : if (dev_id >= compressdev_globals.nb_devs)
109 : : return 0;
110 : :
111 : : dev = rte_compressdev_get_dev(dev_id);
112 [ # # # # : 0 : if (dev->attached != RTE_COMPRESSDEV_ATTACHED)
# # # # #
# # # # #
# # ]
113 : : return 0;
114 : : else
115 : : return 1;
116 : : }
117 : :
118 : :
119 : : int
120 : 0 : rte_compressdev_get_dev_id(const char *name)
121 : : {
122 : : unsigned int i;
123 : :
124 [ # # ]: 0 : if (name == NULL)
125 : : return -1;
126 : :
127 [ # # ]: 0 : for (i = 0; i < compressdev_globals.nb_devs; i++)
128 [ # # ]: 0 : if ((strcmp(compressdev_globals.devs[i].data->name, name)
129 : 0 : == 0) &&
130 [ # # ]: 0 : (compressdev_globals.devs[i].attached ==
131 : : RTE_COMPRESSDEV_ATTACHED))
132 : 0 : return i;
133 : :
134 : : return -1;
135 : : }
136 : :
137 : : uint8_t
138 : 1 : rte_compressdev_count(void)
139 : : {
140 : 1 : return compressdev_globals.nb_devs;
141 : : }
142 : :
143 : : uint8_t
144 : 0 : rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
145 : : uint8_t nb_devices)
146 : : {
147 : : uint8_t i, count = 0;
148 : 0 : struct rte_compressdev *devs = compressdev_globals.devs;
149 : 0 : uint8_t max_devs = compressdev_globals.max_devs;
150 : :
151 [ # # ]: 0 : for (i = 0; i < max_devs && count < nb_devices; i++) {
152 : :
153 [ # # ]: 0 : if (devs[i].attached == RTE_COMPRESSDEV_ATTACHED) {
154 : : int cmp;
155 : :
156 : 0 : cmp = strncmp(devs[i].device->driver->name,
157 : : driver_name,
158 : : strlen(driver_name));
159 : :
160 [ # # ]: 0 : if (cmp == 0)
161 : 0 : devices[count++] = devs[i].data->dev_id;
162 : : }
163 : : }
164 : :
165 : 0 : return count;
166 : : }
167 : :
168 : : int
169 [ # # ]: 0 : rte_compressdev_socket_id(uint8_t dev_id)
170 : : {
171 : : struct rte_compressdev *dev;
172 : :
173 : : if (!rte_compressdev_is_valid_dev(dev_id))
174 : : return -1;
175 : :
176 : : dev = rte_compressdev_get_dev(dev_id);
177 : :
178 : 0 : return dev->data->socket_id;
179 : : }
180 : :
181 : : static inline int
182 : 0 : rte_compressdev_data_alloc(uint8_t dev_id, struct rte_compressdev_data **data,
183 : : int socket_id)
184 : : {
185 : : char mz_name[RTE_COMPRESSDEV_NAME_MAX_LEN];
186 : : const struct rte_memzone *mz;
187 : : int n;
188 : :
189 : : /* generate memzone name */
190 [ # # ]: 0 : n = snprintf(mz_name, sizeof(mz_name),
191 : : "rte_compressdev_data_%u", dev_id);
192 [ # # ]: 0 : if (n >= (int)sizeof(mz_name))
193 : : return -EINVAL;
194 : :
195 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
196 : 0 : mz = rte_memzone_reserve(mz_name,
197 : : sizeof(struct rte_compressdev_data),
198 : : socket_id, 0);
199 : : } else
200 : 0 : mz = rte_memzone_lookup(mz_name);
201 : :
202 [ # # ]: 0 : if (mz == NULL)
203 : : return -ENOMEM;
204 : :
205 : 0 : *data = mz->addr;
206 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY)
207 : 0 : memset(*data, 0, sizeof(struct rte_compressdev_data));
208 : :
209 : : return 0;
210 : : }
211 : :
212 : : static uint8_t
213 : : rte_compressdev_find_free_device_index(void)
214 : : {
215 : : uint8_t dev_id;
216 : :
217 [ # # ]: 0 : for (dev_id = 0; dev_id < RTE_COMPRESS_MAX_DEVS; dev_id++) {
218 [ # # ]: 0 : if (rte_comp_devices[dev_id].attached ==
219 : : RTE_COMPRESSDEV_DETACHED)
220 : : return dev_id;
221 : : }
222 : : return RTE_COMPRESS_MAX_DEVS;
223 : : }
224 : :
225 : : struct rte_compressdev *
226 : 0 : rte_compressdev_pmd_allocate(const char *name, int socket_id)
227 : : {
228 : : struct rte_compressdev *compressdev;
229 : : uint8_t dev_id;
230 : :
231 [ # # ]: 0 : if (rte_compressdev_pmd_get_named_dev(name) != NULL) {
232 : 0 : COMPRESSDEV_LOG(ERR,
233 : : "comp device with name %s already allocated!", name);
234 : 0 : return NULL;
235 : : }
236 : :
237 : : dev_id = rte_compressdev_find_free_device_index();
238 [ # # ]: 0 : if (dev_id == RTE_COMPRESS_MAX_DEVS) {
239 : 0 : COMPRESSDEV_LOG(ERR, "Reached maximum number of comp devices");
240 : 0 : return NULL;
241 : : }
242 : 0 : compressdev = rte_compressdev_get_dev(dev_id);
243 : :
244 [ # # ]: 0 : if (compressdev->data == NULL) {
245 : 0 : struct rte_compressdev_data *compressdev_data =
246 : 0 : compressdev_globals.data[dev_id];
247 : :
248 : 0 : int retval = rte_compressdev_data_alloc(dev_id,
249 : : &compressdev_data, socket_id);
250 : :
251 [ # # # # ]: 0 : if (retval < 0 || compressdev_data == NULL)
252 : 0 : return NULL;
253 : :
254 : 0 : compressdev->data = compressdev_data;
255 : :
256 : 0 : strlcpy(compressdev->data->name, name,
257 : : RTE_COMPRESSDEV_NAME_MAX_LEN);
258 : :
259 : 0 : compressdev->data->dev_id = dev_id;
260 : 0 : compressdev->data->socket_id = socket_id;
261 : 0 : compressdev->data->dev_started = 0;
262 : :
263 : 0 : compressdev->attached = RTE_COMPRESSDEV_ATTACHED;
264 : :
265 : 0 : compressdev_globals.nb_devs++;
266 : : }
267 : :
268 : : return compressdev;
269 : : }
270 : :
271 : : int
272 : 0 : rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
273 : : {
274 : : int ret;
275 : :
276 [ # # ]: 0 : if (compressdev == NULL)
277 : : return -EINVAL;
278 : :
279 : : /* Close device only if device operations have been set */
280 [ # # ]: 0 : if (compressdev->dev_ops) {
281 : 0 : ret = rte_compressdev_close(compressdev->data->dev_id);
282 [ # # ]: 0 : if (ret < 0)
283 : : return ret;
284 : : }
285 : :
286 : 0 : compressdev->attached = RTE_COMPRESSDEV_DETACHED;
287 : 0 : compressdev_globals.nb_devs--;
288 : 0 : return 0;
289 : : }
290 : :
291 : : uint16_t
292 : 0 : rte_compressdev_queue_pair_count(uint8_t dev_id)
293 : : {
294 : : struct rte_compressdev *dev;
295 : :
296 : 0 : dev = &rte_comp_devices[dev_id];
297 : 0 : return dev->data->nb_queue_pairs;
298 : : }
299 : :
300 : : static int
301 : 0 : rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
302 : : uint16_t nb_qpairs, int socket_id)
303 : : {
304 : : struct rte_compressdev_info dev_info;
305 : : void **qp;
306 : : unsigned int i;
307 : :
308 [ # # ]: 0 : if ((dev == NULL) || (nb_qpairs < 1)) {
309 : 0 : COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",
310 : : dev, nb_qpairs);
311 : 0 : return -EINVAL;
312 : : }
313 : :
314 : 0 : COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",
315 : : nb_qpairs, dev->data->dev_id);
316 : :
317 : : memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
318 : :
319 [ # # ]: 0 : if (*dev->dev_ops->dev_infos_get == NULL)
320 : : return -ENOTSUP;
321 : 0 : (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
322 : :
323 [ # # # # ]: 0 : if ((dev_info.max_nb_queue_pairs != 0) &&
324 : : (nb_qpairs > dev_info.max_nb_queue_pairs)) {
325 : 0 : COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",
326 : : nb_qpairs, dev->data->dev_id);
327 : 0 : return -EINVAL;
328 : : }
329 : :
330 [ # # ]: 0 : if (dev->data->queue_pairs == NULL) { /* first time configuration */
331 : 0 : dev->data->queue_pairs = rte_zmalloc_socket(
332 : : "compressdev->queue_pairs",
333 : : sizeof(dev->data->queue_pairs[0]) * nb_qpairs,
334 : : RTE_CACHE_LINE_SIZE, socket_id);
335 : :
336 [ # # ]: 0 : if (dev->data->queue_pairs == NULL) {
337 : 0 : dev->data->nb_queue_pairs = 0;
338 : 0 : COMPRESSDEV_LOG(ERR,
339 : : "failed to get memory for qp meta data, nb_queues %u",
340 : : nb_qpairs);
341 : 0 : return -(ENOMEM);
342 : : }
343 : : } else { /* re-configure */
344 : : int ret;
345 : 0 : uint16_t old_nb_queues = dev->data->nb_queue_pairs;
346 : :
347 : : qp = dev->data->queue_pairs;
348 : :
349 [ # # ]: 0 : if (*dev->dev_ops->queue_pair_release == NULL)
350 : : return -ENOTSUP;
351 : :
352 [ # # ]: 0 : for (i = nb_qpairs; i < old_nb_queues; i++) {
353 : 0 : ret = (*dev->dev_ops->queue_pair_release)(dev, i);
354 [ # # ]: 0 : if (ret < 0)
355 : 0 : return ret;
356 : : }
357 : :
358 : 0 : qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
359 : : RTE_CACHE_LINE_SIZE);
360 [ # # ]: 0 : if (qp == NULL) {
361 : 0 : COMPRESSDEV_LOG(ERR,
362 : : "failed to realloc qp meta data, nb_queues %u",
363 : : nb_qpairs);
364 : 0 : return -(ENOMEM);
365 : : }
366 : :
367 [ # # ]: 0 : if (nb_qpairs > old_nb_queues) {
368 : 0 : uint16_t new_qs = nb_qpairs - old_nb_queues;
369 : :
370 : 0 : memset(qp + old_nb_queues, 0,
371 : : sizeof(qp[0]) * new_qs);
372 : : }
373 : :
374 : 0 : dev->data->queue_pairs = qp;
375 : :
376 : : }
377 : 0 : dev->data->nb_queue_pairs = nb_qpairs;
378 : 0 : return 0;
379 : : }
380 : :
381 : : static int
382 : 0 : rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
383 : : {
384 : : uint16_t num_qps, i;
385 : : int ret;
386 : :
387 [ # # ]: 0 : if (dev == NULL) {
388 : 0 : COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev);
389 : 0 : return -EINVAL;
390 : : }
391 : :
392 : 0 : num_qps = dev->data->nb_queue_pairs;
393 : :
394 [ # # ]: 0 : if (num_qps == 0)
395 : : return 0;
396 : :
397 : 0 : COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",
398 : : dev->data->nb_queue_pairs, dev->data->dev_id);
399 : :
400 [ # # ]: 0 : if (*dev->dev_ops->queue_pair_release == NULL)
401 : : return -ENOTSUP;
402 : :
403 [ # # ]: 0 : for (i = 0; i < num_qps; i++) {
404 : 0 : ret = (*dev->dev_ops->queue_pair_release)(dev, i);
405 [ # # ]: 0 : if (ret < 0)
406 : 0 : return ret;
407 : : }
408 : :
409 : 0 : rte_free(dev->data->queue_pairs);
410 : 0 : dev->data->queue_pairs = NULL;
411 : 0 : dev->data->nb_queue_pairs = 0;
412 : :
413 : 0 : return 0;
414 : : }
415 : :
416 : : int
417 : 0 : rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
418 : : {
419 : : struct rte_compressdev *dev;
420 : : int diag;
421 : :
422 [ # # ]: 0 : if (!rte_compressdev_is_valid_dev(dev_id)) {
423 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
424 : 0 : return -EINVAL;
425 : : }
426 : :
427 : 0 : dev = &rte_comp_devices[dev_id];
428 : :
429 [ # # ]: 0 : if (dev->data->dev_started) {
430 : 0 : COMPRESSDEV_LOG(ERR,
431 : : "device %d must be stopped to allow configuration", dev_id);
432 : 0 : return -EBUSY;
433 : : }
434 : :
435 [ # # ]: 0 : if (*dev->dev_ops->dev_configure == NULL)
436 : : return -ENOTSUP;
437 : :
438 : : /* Setup new number of queue pairs and reconfigure device. */
439 : 0 : diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
440 : : config->socket_id);
441 [ # # ]: 0 : if (diag != 0) {
442 : 0 : COMPRESSDEV_LOG(ERR,
443 : : "dev%d rte_comp_dev_queue_pairs_config = %d",
444 : : dev_id, diag);
445 : 0 : return diag;
446 : : }
447 : :
448 : 0 : return (*dev->dev_ops->dev_configure)(dev, config);
449 : : }
450 : :
451 : : int
452 : 0 : rte_compressdev_start(uint8_t dev_id)
453 : : {
454 : : struct rte_compressdev *dev;
455 : : int diag;
456 : :
457 : 0 : COMPRESSDEV_LOG(DEBUG, "Start dev_id=%" PRIu8, dev_id);
458 : :
459 : : if (!rte_compressdev_is_valid_dev(dev_id)) {
460 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
461 : 0 : return -EINVAL;
462 : : }
463 : :
464 : 0 : dev = &rte_comp_devices[dev_id];
465 : :
466 [ # # ]: 0 : if (*dev->dev_ops->dev_start == NULL)
467 : : return -ENOTSUP;
468 : :
469 [ # # ]: 0 : if (dev->data->dev_started != 0) {
470 : 0 : COMPRESSDEV_LOG(ERR,
471 : : "Device with dev_id=%" PRIu8 " already started", dev_id);
472 : 0 : return 0;
473 : : }
474 : :
475 : 0 : diag = (*dev->dev_ops->dev_start)(dev);
476 [ # # ]: 0 : if (diag == 0)
477 : 0 : dev->data->dev_started = 1;
478 : : else
479 : : return diag;
480 : :
481 : 0 : return 0;
482 : : }
483 : :
484 : : void
485 : 0 : rte_compressdev_stop(uint8_t dev_id)
486 : : {
487 : : struct rte_compressdev *dev;
488 : :
489 [ # # ]: 0 : if (!rte_compressdev_is_valid_dev(dev_id)) {
490 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
491 : 0 : return;
492 : : }
493 : :
494 : 0 : dev = &rte_comp_devices[dev_id];
495 : :
496 [ # # ]: 0 : if (*dev->dev_ops->dev_stop == NULL)
497 : : return;
498 : :
499 [ # # ]: 0 : if (dev->data->dev_started == 0) {
500 : 0 : COMPRESSDEV_LOG(ERR,
501 : : "Device with dev_id=%" PRIu8 " already stopped", dev_id);
502 : 0 : return;
503 : : }
504 : :
505 : 0 : (*dev->dev_ops->dev_stop)(dev);
506 : 0 : dev->data->dev_started = 0;
507 : : }
508 : :
509 : : int
510 : 0 : rte_compressdev_close(uint8_t dev_id)
511 : : {
512 : : struct rte_compressdev *dev;
513 : : int retval;
514 : :
515 [ # # ]: 0 : if (!rte_compressdev_is_valid_dev(dev_id)) {
516 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
517 : 0 : return -1;
518 : : }
519 : :
520 : 0 : dev = &rte_comp_devices[dev_id];
521 : :
522 : : /* Device must be stopped before it can be closed */
523 [ # # ]: 0 : if (dev->data->dev_started == 1) {
524 : 0 : COMPRESSDEV_LOG(ERR, "Device %u must be stopped before closing",
525 : : dev_id);
526 : 0 : return -EBUSY;
527 : : }
528 : :
529 : : /* Free queue pairs memory */
530 : 0 : retval = rte_compressdev_queue_pairs_release(dev);
531 : :
532 [ # # ]: 0 : if (retval < 0)
533 : : return retval;
534 : :
535 [ # # ]: 0 : if (*dev->dev_ops->dev_close == NULL)
536 : : return -ENOTSUP;
537 : 0 : retval = (*dev->dev_ops->dev_close)(dev);
538 : :
539 : : if (retval < 0)
540 : : return retval;
541 : :
542 : : return 0;
543 : : }
544 : :
545 : : int
546 : 0 : rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
547 : : uint32_t max_inflight_ops, int socket_id)
548 : : {
549 : : struct rte_compressdev *dev;
550 : :
551 [ # # ]: 0 : if (!rte_compressdev_is_valid_dev(dev_id)) {
552 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
553 : 0 : return -EINVAL;
554 : : }
555 : :
556 : 0 : dev = &rte_comp_devices[dev_id];
557 [ # # ]: 0 : if (queue_pair_id >= dev->data->nb_queue_pairs) {
558 : 0 : COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id);
559 : 0 : return -EINVAL;
560 : : }
561 : :
562 [ # # ]: 0 : if (dev->data->dev_started) {
563 : 0 : COMPRESSDEV_LOG(ERR,
564 : : "device %d must be stopped to allow configuration", dev_id);
565 : 0 : return -EBUSY;
566 : : }
567 : :
568 [ # # ]: 0 : if (max_inflight_ops == 0) {
569 : 0 : COMPRESSDEV_LOG(ERR,
570 : : "Invalid maximum number of inflight operations");
571 : 0 : return -EINVAL;
572 : : }
573 : :
574 [ # # ]: 0 : if (*dev->dev_ops->queue_pair_setup == NULL)
575 : : return -ENOTSUP;
576 : :
577 : 0 : return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
578 : : max_inflight_ops, socket_id);
579 : : }
580 : :
581 : : uint16_t
582 : 0 : rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
583 : : struct rte_comp_op **ops, uint16_t nb_ops)
584 : : {
585 : 0 : struct rte_compressdev *dev = &rte_comp_devices[dev_id];
586 : :
587 : 0 : nb_ops = (*dev->dequeue_burst)
588 : 0 : (dev->data->queue_pairs[qp_id], ops, nb_ops);
589 : :
590 : 0 : return nb_ops;
591 : : }
592 : :
593 : : uint16_t
594 : 0 : rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
595 : : struct rte_comp_op **ops, uint16_t nb_ops)
596 : : {
597 : 0 : struct rte_compressdev *dev = &rte_comp_devices[dev_id];
598 : :
599 : 0 : return (*dev->enqueue_burst)(
600 : 0 : dev->data->queue_pairs[qp_id], ops, nb_ops);
601 : : }
602 : :
603 : : int
604 : 0 : rte_compressdev_stats_get(uint8_t dev_id, struct rte_compressdev_stats *stats)
605 : : {
606 : : struct rte_compressdev *dev;
607 : :
608 [ # # ]: 0 : if (!rte_compressdev_is_valid_dev(dev_id)) {
609 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
610 : 0 : return -ENODEV;
611 : : }
612 : :
613 [ # # ]: 0 : if (stats == NULL) {
614 : 0 : COMPRESSDEV_LOG(ERR, "Invalid stats ptr");
615 : 0 : return -EINVAL;
616 : : }
617 : :
618 [ # # ]: 0 : dev = &rte_comp_devices[dev_id];
619 : : memset(stats, 0, sizeof(*stats));
620 : :
621 [ # # ]: 0 : if (*dev->dev_ops->stats_get == NULL)
622 : : return -ENOTSUP;
623 : 0 : (*dev->dev_ops->stats_get)(dev, stats);
624 : 0 : return 0;
625 : : }
626 : :
627 : : void
628 : 0 : rte_compressdev_stats_reset(uint8_t dev_id)
629 : : {
630 : : struct rte_compressdev *dev;
631 : :
632 [ # # ]: 0 : if (!rte_compressdev_is_valid_dev(dev_id)) {
633 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
634 : 0 : return;
635 : : }
636 : :
637 : 0 : dev = &rte_comp_devices[dev_id];
638 : :
639 [ # # ]: 0 : if (*dev->dev_ops->stats_reset == NULL)
640 : : return;
641 : 0 : (*dev->dev_ops->stats_reset)(dev);
642 : : }
643 : :
644 : :
645 : : void
646 : 0 : rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
647 : : {
648 : : struct rte_compressdev *dev;
649 : :
650 [ # # ]: 0 : if (dev_id >= compressdev_globals.nb_devs) {
651 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
652 : 0 : return;
653 : : }
654 : :
655 [ # # ]: 0 : dev = &rte_comp_devices[dev_id];
656 : :
657 : : memset(dev_info, 0, sizeof(struct rte_compressdev_info));
658 : :
659 [ # # ]: 0 : if (*dev->dev_ops->dev_infos_get == NULL)
660 : : return;
661 : 0 : (*dev->dev_ops->dev_infos_get)(dev, dev_info);
662 : :
663 : 0 : dev_info->driver_name = dev->device->driver->name;
664 : : }
665 : :
666 : : int
667 : 0 : rte_compressdev_private_xform_create(uint8_t dev_id,
668 : : const struct rte_comp_xform *xform,
669 : : void **priv_xform)
670 : : {
671 : : struct rte_compressdev *dev;
672 : : int ret;
673 : :
674 : 0 : dev = rte_compressdev_get_dev(dev_id);
675 : :
676 [ # # # # ]: 0 : if (xform == NULL || priv_xform == NULL || dev == NULL)
677 : : return -EINVAL;
678 : :
679 [ # # ]: 0 : if (*dev->dev_ops->private_xform_create == NULL)
680 : : return -ENOTSUP;
681 : 0 : ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
682 [ # # ]: 0 : if (ret < 0) {
683 : 0 : COMPRESSDEV_LOG(ERR,
684 : : "dev_id %d failed to create private_xform: err=%d",
685 : : dev_id, ret);
686 : 0 : return ret;
687 : : };
688 : :
689 : : return 0;
690 : : }
691 : :
692 : : int
693 : 0 : rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
694 : : {
695 : : struct rte_compressdev *dev;
696 : : int ret;
697 : :
698 : 0 : dev = rte_compressdev_get_dev(dev_id);
699 : :
700 [ # # ]: 0 : if (dev == NULL || priv_xform == NULL)
701 : : return -EINVAL;
702 : :
703 [ # # ]: 0 : if (*dev->dev_ops->private_xform_free == NULL)
704 : : return -ENOTSUP;
705 : 0 : ret = dev->dev_ops->private_xform_free(dev, priv_xform);
706 [ # # ]: 0 : if (ret < 0) {
707 : 0 : COMPRESSDEV_LOG(ERR,
708 : : "dev_id %d failed to free private xform: err=%d",
709 : : dev_id, ret);
710 : 0 : return ret;
711 : : };
712 : :
713 : : return 0;
714 : : }
715 : :
716 : : int
717 : 0 : rte_compressdev_stream_create(uint8_t dev_id,
718 : : const struct rte_comp_xform *xform,
719 : : void **stream)
720 : : {
721 : : struct rte_compressdev *dev;
722 : : int ret;
723 : :
724 : 0 : dev = rte_compressdev_get_dev(dev_id);
725 : :
726 [ # # # # ]: 0 : if (xform == NULL || dev == NULL || stream == NULL)
727 : : return -EINVAL;
728 : :
729 [ # # ]: 0 : if (*dev->dev_ops->stream_create == NULL)
730 : : return -ENOTSUP;
731 : 0 : ret = (*dev->dev_ops->stream_create)(dev, xform, stream);
732 [ # # ]: 0 : if (ret < 0) {
733 : 0 : COMPRESSDEV_LOG(ERR,
734 : : "dev_id %d failed to create stream: err=%d",
735 : : dev_id, ret);
736 : 0 : return ret;
737 : : };
738 : :
739 : : return 0;
740 : : }
741 : :
742 : :
743 : : int
744 : 0 : rte_compressdev_stream_free(uint8_t dev_id, void *stream)
745 : : {
746 : : struct rte_compressdev *dev;
747 : : int ret;
748 : :
749 : 0 : dev = rte_compressdev_get_dev(dev_id);
750 : :
751 [ # # ]: 0 : if (dev == NULL || stream == NULL)
752 : : return -EINVAL;
753 : :
754 [ # # ]: 0 : if (*dev->dev_ops->stream_free == NULL)
755 : : return -ENOTSUP;
756 : 0 : ret = dev->dev_ops->stream_free(dev, stream);
757 [ # # ]: 0 : if (ret < 0) {
758 : 0 : COMPRESSDEV_LOG(ERR,
759 : : "dev_id %d failed to free stream: err=%d",
760 : : dev_id, ret);
761 : 0 : return ret;
762 : : };
763 : :
764 : : return 0;
765 : : }
766 : :
767 : : const char *
768 : 0 : rte_compressdev_name_get(uint8_t dev_id)
769 : : {
770 : : struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
771 : :
772 [ # # ]: 0 : if (dev == NULL)
773 : : return NULL;
774 : :
775 : 0 : return dev->data->name;
776 : : }
777 : :
778 [ - + ]: 251 : RTE_LOG_REGISTER_DEFAULT(compressdev_logtype, NOTICE);
|
