1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017-2018 Intel Corporation
10 #include <rte_malloc.h>
12 #include <rte_memzone.h>
14 #include "rte_compressdev.h"
15 #include "rte_compressdev_internal.h"
16 #include "rte_compressdev_pmd.h"
18 #define RTE_COMPRESSDEV_DETACHED (0)
19 #define RTE_COMPRESSDEV_ATTACHED (1)
21 static struct rte_compressdev rte_comp_devices[RTE_COMPRESS_MAX_DEVS];
23 static struct rte_compressdev_global compressdev_globals = {
24 .devs = rte_comp_devices,
27 .max_devs = RTE_COMPRESS_MAX_DEVS
30 const struct rte_compressdev_capabilities * __rte_experimental
31 rte_compressdev_capability_get(uint8_t dev_id,
32 enum rte_comp_algorithm algo)
34 const struct rte_compressdev_capabilities *capability;
35 struct rte_compressdev_info dev_info;
38 if (dev_id >= compressdev_globals.nb_devs) {
39 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
42 rte_compressdev_info_get(dev_id, &dev_info);
44 while ((capability = &dev_info.capabilities[i++])->algo !=
45 RTE_COMP_ALGO_UNSPECIFIED){
46 if (capability->algo == algo)
53 const char * __rte_experimental
54 rte_compressdev_get_feature_name(uint64_t flag)
57 case RTE_COMPDEV_FF_HW_ACCELERATED:
58 return "HW_ACCELERATED";
59 case RTE_COMPDEV_FF_CPU_SSE:
61 case RTE_COMPDEV_FF_CPU_AVX:
63 case RTE_COMPDEV_FF_CPU_AVX2:
65 case RTE_COMPDEV_FF_CPU_AVX512:
67 case RTE_COMPDEV_FF_CPU_NEON:
74 static struct rte_compressdev *
75 rte_compressdev_get_dev(uint8_t dev_id)
77 return &compressdev_globals.devs[dev_id];
80 struct rte_compressdev * __rte_experimental
81 rte_compressdev_pmd_get_named_dev(const char *name)
83 struct rte_compressdev *dev;
89 for (i = 0; i < compressdev_globals.max_devs; i++) {
90 dev = &compressdev_globals.devs[i];
92 if ((dev->attached == RTE_COMPRESSDEV_ATTACHED) &&
93 (strcmp(dev->data->name, name) == 0))
101 rte_compressdev_is_valid_dev(uint8_t dev_id)
103 struct rte_compressdev *dev = NULL;
105 if (dev_id >= compressdev_globals.nb_devs)
108 dev = rte_compressdev_get_dev(dev_id);
109 if (dev->attached != RTE_COMPRESSDEV_ATTACHED)
116 int __rte_experimental
117 rte_compressdev_get_dev_id(const char *name)
124 for (i = 0; i < compressdev_globals.nb_devs; i++)
125 if ((strcmp(compressdev_globals.devs[i].data->name, name)
127 (compressdev_globals.devs[i].attached ==
128 RTE_COMPRESSDEV_ATTACHED))
134 uint8_t __rte_experimental
135 rte_compressdev_count(void)
137 return compressdev_globals.nb_devs;
140 uint8_t __rte_experimental
141 rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
144 uint8_t i, count = 0;
145 struct rte_compressdev *devs = compressdev_globals.devs;
146 uint8_t max_devs = compressdev_globals.max_devs;
148 for (i = 0; i < max_devs && count < nb_devices; i++) {
150 if (devs[i].attached == RTE_COMPRESSDEV_ATTACHED) {
153 cmp = strncmp(devs[i].device->driver->name,
155 strlen(driver_name));
158 devices[count++] = devs[i].data->dev_id;
165 int __rte_experimental
166 rte_compressdev_socket_id(uint8_t dev_id)
168 struct rte_compressdev *dev;
170 if (!rte_compressdev_is_valid_dev(dev_id))
173 dev = rte_compressdev_get_dev(dev_id);
175 return dev->data->socket_id;
179 rte_compressdev_data_alloc(uint8_t dev_id, struct rte_compressdev_data **data,
182 char mz_name[RTE_COMPRESSDEV_NAME_MAX_LEN];
183 const struct rte_memzone *mz;
186 /* generate memzone name */
187 n = snprintf(mz_name, sizeof(mz_name),
188 "rte_compressdev_data_%u", dev_id);
189 if (n >= (int)sizeof(mz_name))
192 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
193 mz = rte_memzone_reserve(mz_name,
194 sizeof(struct rte_compressdev_data),
197 mz = rte_memzone_lookup(mz_name);
203 if (rte_eal_process_type() == RTE_PROC_PRIMARY)
204 memset(*data, 0, sizeof(struct rte_compressdev_data));
210 rte_compressdev_find_free_device_index(void)
214 for (dev_id = 0; dev_id < RTE_COMPRESS_MAX_DEVS; dev_id++) {
215 if (rte_comp_devices[dev_id].attached ==
216 RTE_COMPRESSDEV_DETACHED)
219 return RTE_COMPRESS_MAX_DEVS;
222 struct rte_compressdev * __rte_experimental
223 rte_compressdev_pmd_allocate(const char *name, int socket_id)
225 struct rte_compressdev *compressdev;
228 if (rte_compressdev_pmd_get_named_dev(name) != NULL) {
230 "comp device with name %s already allocated!", name);
234 dev_id = rte_compressdev_find_free_device_index();
235 if (dev_id == RTE_COMPRESS_MAX_DEVS) {
236 COMPRESSDEV_LOG(ERR, "Reached maximum number of comp devices");
239 compressdev = rte_compressdev_get_dev(dev_id);
241 if (compressdev->data == NULL) {
242 struct rte_compressdev_data *compressdev_data =
243 compressdev_globals.data[dev_id];
245 int retval = rte_compressdev_data_alloc(dev_id,
246 &compressdev_data, socket_id);
248 if (retval < 0 || compressdev_data == NULL)
251 compressdev->data = compressdev_data;
253 snprintf(compressdev->data->name, RTE_COMPRESSDEV_NAME_MAX_LEN,
256 compressdev->data->dev_id = dev_id;
257 compressdev->data->socket_id = socket_id;
258 compressdev->data->dev_started = 0;
260 compressdev->attached = RTE_COMPRESSDEV_ATTACHED;
262 compressdev_globals.nb_devs++;
268 int __rte_experimental
269 rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
273 if (compressdev == NULL)
276 /* Close device only if device operations have been set */
277 if (compressdev->dev_ops) {
278 ret = rte_compressdev_close(compressdev->data->dev_id);
283 compressdev->attached = RTE_COMPRESSDEV_DETACHED;
284 compressdev_globals.nb_devs--;
288 uint16_t __rte_experimental
289 rte_compressdev_queue_pair_count(uint8_t dev_id)
291 struct rte_compressdev *dev;
293 dev = &rte_comp_devices[dev_id];
294 return dev->data->nb_queue_pairs;
298 rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
299 uint16_t nb_qpairs, int socket_id)
301 struct rte_compressdev_info dev_info;
305 if ((dev == NULL) || (nb_qpairs < 1)) {
306 COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",
311 COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",
312 nb_qpairs, dev->data->dev_id);
314 memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
316 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
317 (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
319 if ((dev_info.max_nb_queue_pairs != 0) &&
320 (nb_qpairs > dev_info.max_nb_queue_pairs)) {
321 COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",
322 nb_qpairs, dev->data->dev_id);
326 if (dev->data->queue_pairs == NULL) { /* first time configuration */
327 dev->data->queue_pairs = rte_zmalloc_socket(
328 "compressdev->queue_pairs",
329 sizeof(dev->data->queue_pairs[0]) * nb_qpairs,
330 RTE_CACHE_LINE_SIZE, socket_id);
332 if (dev->data->queue_pairs == NULL) {
333 dev->data->nb_queue_pairs = 0;
335 "failed to get memory for qp meta data, nb_queues %u",
339 } else { /* re-configure */
341 uint16_t old_nb_queues = dev->data->nb_queue_pairs;
343 qp = dev->data->queue_pairs;
345 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
348 for (i = nb_qpairs; i < old_nb_queues; i++) {
349 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
354 qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
355 RTE_CACHE_LINE_SIZE);
358 "failed to realloc qp meta data, nb_queues %u",
363 if (nb_qpairs > old_nb_queues) {
364 uint16_t new_qs = nb_qpairs - old_nb_queues;
366 memset(qp + old_nb_queues, 0,
367 sizeof(qp[0]) * new_qs);
370 dev->data->queue_pairs = qp;
373 dev->data->nb_queue_pairs = nb_qpairs;
378 rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
384 COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev);
388 num_qps = dev->data->nb_queue_pairs;
393 COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",
394 dev->data->nb_queue_pairs, dev->data->dev_id);
396 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
399 for (i = 0; i < num_qps; i++) {
400 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
405 if (dev->data->queue_pairs != NULL)
406 rte_free(dev->data->queue_pairs);
407 dev->data->queue_pairs = NULL;
408 dev->data->nb_queue_pairs = 0;
413 int __rte_experimental
414 rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
416 struct rte_compressdev *dev;
419 if (!rte_compressdev_is_valid_dev(dev_id)) {
420 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
424 dev = &rte_comp_devices[dev_id];
426 if (dev->data->dev_started) {
428 "device %d must be stopped to allow configuration", dev_id);
432 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
434 /* Setup new number of queue pairs and reconfigure device. */
435 diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
439 "dev%d rte_comp_dev_queue_pairs_config = %d",
444 return (*dev->dev_ops->dev_configure)(dev, config);
447 int __rte_experimental
448 rte_compressdev_start(uint8_t dev_id)
450 struct rte_compressdev *dev;
453 COMPRESSDEV_LOG(DEBUG, "Start dev_id=%" PRIu8, dev_id);
455 if (!rte_compressdev_is_valid_dev(dev_id)) {
456 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
460 dev = &rte_comp_devices[dev_id];
462 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP);
464 if (dev->data->dev_started != 0) {
466 "Device with dev_id=%" PRIu8 " already started", dev_id);
470 diag = (*dev->dev_ops->dev_start)(dev);
472 dev->data->dev_started = 1;
479 void __rte_experimental
480 rte_compressdev_stop(uint8_t dev_id)
482 struct rte_compressdev *dev;
484 if (!rte_compressdev_is_valid_dev(dev_id)) {
485 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
489 dev = &rte_comp_devices[dev_id];
491 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop);
493 if (dev->data->dev_started == 0) {
495 "Device with dev_id=%" PRIu8 " already stopped", dev_id);
499 (*dev->dev_ops->dev_stop)(dev);
500 dev->data->dev_started = 0;
503 int __rte_experimental
504 rte_compressdev_close(uint8_t dev_id)
506 struct rte_compressdev *dev;
509 if (!rte_compressdev_is_valid_dev(dev_id)) {
510 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
514 dev = &rte_comp_devices[dev_id];
516 /* Device must be stopped before it can be closed */
517 if (dev->data->dev_started == 1) {
518 COMPRESSDEV_LOG(ERR, "Device %u must be stopped before closing",
523 /* Free queue pairs memory */
524 retval = rte_compressdev_queue_pairs_release(dev);
529 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP);
530 retval = (*dev->dev_ops->dev_close)(dev);
538 int __rte_experimental
539 rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
540 uint32_t max_inflight_ops, int socket_id)
542 struct rte_compressdev *dev;
544 if (!rte_compressdev_is_valid_dev(dev_id)) {
545 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
549 dev = &rte_comp_devices[dev_id];
550 if (queue_pair_id >= dev->data->nb_queue_pairs) {
551 COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id);
555 if (dev->data->dev_started) {
557 "device %d must be stopped to allow configuration", dev_id);
561 if (max_inflight_ops == 0) {
563 "Invalid maximum number of inflight operations");
567 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP);
569 return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
570 max_inflight_ops, socket_id);
573 uint16_t __rte_experimental
574 rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
575 struct rte_comp_op **ops, uint16_t nb_ops)
577 struct rte_compressdev *dev = &rte_comp_devices[dev_id];
579 nb_ops = (*dev->dequeue_burst)
580 (dev->data->queue_pairs[qp_id], ops, nb_ops);
585 uint16_t __rte_experimental
586 rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
587 struct rte_comp_op **ops, uint16_t nb_ops)
589 struct rte_compressdev *dev = &rte_comp_devices[dev_id];
591 return (*dev->enqueue_burst)(
592 dev->data->queue_pairs[qp_id], ops, nb_ops);
595 int __rte_experimental
596 rte_compressdev_stats_get(uint8_t dev_id, struct rte_compressdev_stats *stats)
598 struct rte_compressdev *dev;
600 if (!rte_compressdev_is_valid_dev(dev_id)) {
601 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
606 COMPRESSDEV_LOG(ERR, "Invalid stats ptr");
610 dev = &rte_comp_devices[dev_id];
611 memset(stats, 0, sizeof(*stats));
613 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stats_get, -ENOTSUP);
614 (*dev->dev_ops->stats_get)(dev, stats);
618 void __rte_experimental
619 rte_compressdev_stats_reset(uint8_t dev_id)
621 struct rte_compressdev *dev;
623 if (!rte_compressdev_is_valid_dev(dev_id)) {
624 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
628 dev = &rte_comp_devices[dev_id];
630 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->stats_reset);
631 (*dev->dev_ops->stats_reset)(dev);
635 void __rte_experimental
636 rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
638 struct rte_compressdev *dev;
640 if (dev_id >= compressdev_globals.nb_devs) {
641 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
645 dev = &rte_comp_devices[dev_id];
647 memset(dev_info, 0, sizeof(struct rte_compressdev_info));
649 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get);
650 (*dev->dev_ops->dev_infos_get)(dev, dev_info);
652 dev_info->driver_name = dev->device->driver->name;
655 int __rte_experimental
656 rte_compressdev_private_xform_create(uint8_t dev_id,
657 const struct rte_comp_xform *xform,
660 struct rte_compressdev *dev;
663 dev = rte_compressdev_get_dev(dev_id);
665 if (xform == NULL || priv_xform == NULL || dev == NULL)
668 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_create, -ENOTSUP);
669 ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
672 "dev_id %d failed to create private_xform: err=%d",
680 int __rte_experimental
681 rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
683 struct rte_compressdev *dev;
686 dev = rte_compressdev_get_dev(dev_id);
688 if (dev == NULL || priv_xform == NULL)
691 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_free, -ENOTSUP);
692 ret = dev->dev_ops->private_xform_free(dev, priv_xform);
695 "dev_id %d failed to free private xform: err=%d",
703 int __rte_experimental
704 rte_compressdev_stream_create(uint8_t dev_id,
705 const struct rte_comp_xform *xform,
708 struct rte_compressdev *dev;
711 dev = rte_compressdev_get_dev(dev_id);
713 if (xform == NULL || dev == NULL || stream == NULL)
716 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_create, -ENOTSUP);
717 ret = (*dev->dev_ops->stream_create)(dev, xform, stream);
720 "dev_id %d failed to create stream: err=%d",
729 int __rte_experimental
730 rte_compressdev_stream_free(uint8_t dev_id, void *stream)
732 struct rte_compressdev *dev;
735 dev = rte_compressdev_get_dev(dev_id);
737 if (dev == NULL || stream == NULL)
740 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_free, -ENOTSUP);
741 ret = dev->dev_ops->stream_free(dev, stream);
744 "dev_id %d failed to free stream: err=%d",
752 const char * __rte_experimental
753 rte_compressdev_name_get(uint8_t dev_id)
755 struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
760 return dev->data->name;
763 RTE_INIT(rte_compressdev_log)
765 compressdev_logtype = rte_log_register("lib.compressdev");
766 if (compressdev_logtype >= 0)
767 rte_log_set_level(compressdev_logtype, RTE_LOG_NOTICE);