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, max_inflight_ops, socket_id);
578 : : }
579 : :
580 : : uint16_t
581 : 0 : rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
582 : : struct rte_comp_op **ops, uint16_t nb_ops)
583 : : {
584 : 0 : struct rte_compressdev *dev = &rte_comp_devices[dev_id];
585 : :
586 : 0 : return dev->dequeue_burst(dev->data->queue_pairs[qp_id], ops, nb_ops);
587 : : }
588 : :
589 : : uint16_t
590 : 0 : rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
591 : : struct rte_comp_op **ops, uint16_t nb_ops)
592 : : {
593 : 0 : struct rte_compressdev *dev = &rte_comp_devices[dev_id];
594 : :
595 : 0 : return dev->enqueue_burst(dev->data->queue_pairs[qp_id], ops, nb_ops);
596 : : }
597 : :
598 : : int
599 : 0 : rte_compressdev_stats_get(uint8_t dev_id, struct rte_compressdev_stats *stats)
600 : : {
601 : : struct rte_compressdev *dev;
602 : :
603 [ # # ]: 0 : if (!rte_compressdev_is_valid_dev(dev_id)) {
604 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
605 : 0 : return -ENODEV;
606 : : }
607 : :
608 [ # # ]: 0 : if (stats == NULL) {
609 : 0 : COMPRESSDEV_LOG(ERR, "Invalid stats ptr");
610 : 0 : return -EINVAL;
611 : : }
612 : :
613 [ # # ]: 0 : dev = &rte_comp_devices[dev_id];
614 : : memset(stats, 0, sizeof(*stats));
615 : :
616 [ # # ]: 0 : if (dev->dev_ops->stats_get == NULL)
617 : : return -ENOTSUP;
618 : 0 : dev->dev_ops->stats_get(dev, stats);
619 : 0 : return 0;
620 : : }
621 : :
622 : : void
623 : 0 : rte_compressdev_stats_reset(uint8_t dev_id)
624 : : {
625 : : struct rte_compressdev *dev;
626 : :
627 [ # # ]: 0 : if (!rte_compressdev_is_valid_dev(dev_id)) {
628 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
629 : 0 : return;
630 : : }
631 : :
632 : 0 : dev = &rte_comp_devices[dev_id];
633 : :
634 [ # # ]: 0 : if (dev->dev_ops->stats_reset == NULL)
635 : : return;
636 : 0 : dev->dev_ops->stats_reset(dev);
637 : : }
638 : :
639 : :
640 : : void
641 : 0 : rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
642 : : {
643 : : struct rte_compressdev *dev;
644 : :
645 [ # # ]: 0 : if (dev_id >= compressdev_globals.nb_devs) {
646 : 0 : COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
647 : 0 : return;
648 : : }
649 : :
650 [ # # ]: 0 : dev = &rte_comp_devices[dev_id];
651 : :
652 : : memset(dev_info, 0, sizeof(struct rte_compressdev_info));
653 : :
654 [ # # ]: 0 : if (dev->dev_ops->dev_infos_get == NULL)
655 : : return;
656 : 0 : dev->dev_ops->dev_infos_get(dev, dev_info);
657 : :
658 : 0 : dev_info->driver_name = dev->device->driver->name;
659 : : }
660 : :
661 : : int
662 : 0 : rte_compressdev_private_xform_create(uint8_t dev_id,
663 : : const struct rte_comp_xform *xform,
664 : : void **priv_xform)
665 : : {
666 : : struct rte_compressdev *dev;
667 : : int ret;
668 : :
669 : 0 : dev = rte_compressdev_get_dev(dev_id);
670 : :
671 [ # # # # ]: 0 : if (xform == NULL || priv_xform == NULL || dev == NULL)
672 : : return -EINVAL;
673 : :
674 [ # # ]: 0 : if (dev->dev_ops->private_xform_create == NULL)
675 : : return -ENOTSUP;
676 : 0 : ret = dev->dev_ops->private_xform_create(dev, xform, priv_xform);
677 [ # # ]: 0 : if (ret < 0) {
678 : 0 : COMPRESSDEV_LOG(ERR,
679 : : "dev_id %d failed to create private_xform: err=%d",
680 : : dev_id, ret);
681 : 0 : return ret;
682 : : };
683 : :
684 : : return 0;
685 : : }
686 : :
687 : : int
688 : 0 : rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
689 : : {
690 : : struct rte_compressdev *dev;
691 : : int ret;
692 : :
693 : 0 : dev = rte_compressdev_get_dev(dev_id);
694 : :
695 [ # # ]: 0 : if (dev == NULL || priv_xform == NULL)
696 : : return -EINVAL;
697 : :
698 [ # # ]: 0 : if (dev->dev_ops->private_xform_free == NULL)
699 : : return -ENOTSUP;
700 : 0 : ret = dev->dev_ops->private_xform_free(dev, priv_xform);
701 [ # # ]: 0 : if (ret < 0) {
702 : 0 : COMPRESSDEV_LOG(ERR,
703 : : "dev_id %d failed to free private xform: err=%d",
704 : : dev_id, ret);
705 : 0 : return ret;
706 : : };
707 : :
708 : : return 0;
709 : : }
710 : :
711 : : int
712 : 0 : rte_compressdev_stream_create(uint8_t dev_id,
713 : : const struct rte_comp_xform *xform,
714 : : void **stream)
715 : : {
716 : : struct rte_compressdev *dev;
717 : : int ret;
718 : :
719 : 0 : dev = rte_compressdev_get_dev(dev_id);
720 : :
721 [ # # # # ]: 0 : if (xform == NULL || dev == NULL || stream == NULL)
722 : : return -EINVAL;
723 : :
724 [ # # ]: 0 : if (dev->dev_ops->stream_create == NULL)
725 : : return -ENOTSUP;
726 : 0 : ret = dev->dev_ops->stream_create(dev, xform, stream);
727 [ # # ]: 0 : if (ret < 0) {
728 : 0 : COMPRESSDEV_LOG(ERR,
729 : : "dev_id %d failed to create stream: err=%d",
730 : : dev_id, ret);
731 : 0 : return ret;
732 : : };
733 : :
734 : : return 0;
735 : : }
736 : :
737 : :
738 : : int
739 : 0 : rte_compressdev_stream_free(uint8_t dev_id, void *stream)
740 : : {
741 : : struct rte_compressdev *dev;
742 : : int ret;
743 : :
744 : 0 : dev = rte_compressdev_get_dev(dev_id);
745 : :
746 [ # # ]: 0 : if (dev == NULL || stream == NULL)
747 : : return -EINVAL;
748 : :
749 [ # # ]: 0 : if (dev->dev_ops->stream_free == NULL)
750 : : return -ENOTSUP;
751 : 0 : ret = dev->dev_ops->stream_free(dev, stream);
752 [ # # ]: 0 : if (ret < 0) {
753 : 0 : COMPRESSDEV_LOG(ERR,
754 : : "dev_id %d failed to free stream: err=%d",
755 : : dev_id, ret);
756 : 0 : return ret;
757 : : };
758 : :
759 : : return 0;
760 : : }
761 : :
762 : : const char *
763 : 0 : rte_compressdev_name_get(uint8_t dev_id)
764 : : {
765 : : struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
766 : :
767 [ # # ]: 0 : if (dev == NULL)
768 : : return NULL;
769 : :
770 : 0 : return dev->data->name;
771 : : }
772 : :
773 [ - + ]: 252 : RTE_LOG_REGISTER_DEFAULT(compressdev_logtype, NOTICE);
|
