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