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