1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017-2018 Intel Corporation
10 #include <rte_string_fns.h>
11 #include <rte_malloc.h>
13 #include <rte_memzone.h>
15 #include "rte_compressdev.h"
16 #include "rte_compressdev_internal.h"
17 #include "rte_compressdev_pmd.h"
19 #define RTE_COMPRESSDEV_DETACHED (0)
20 #define RTE_COMPRESSDEV_ATTACHED (1)
22 static struct rte_compressdev rte_comp_devices[RTE_COMPRESS_MAX_DEVS];
24 static struct rte_compressdev_global compressdev_globals = {
25 .devs = rte_comp_devices,
28 .max_devs = RTE_COMPRESS_MAX_DEVS
31 const struct rte_compressdev_capabilities *
32 rte_compressdev_capability_get(uint8_t dev_id,
33 enum rte_comp_algorithm algo)
35 const struct rte_compressdev_capabilities *capability;
36 struct rte_compressdev_info dev_info;
39 if (dev_id >= compressdev_globals.nb_devs) {
40 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
43 rte_compressdev_info_get(dev_id, &dev_info);
45 while ((capability = &dev_info.capabilities[i++])->algo !=
46 RTE_COMP_ALGO_UNSPECIFIED){
47 if (capability->algo == algo)
55 rte_compressdev_get_feature_name(uint64_t flag)
58 case RTE_COMPDEV_FF_HW_ACCELERATED:
59 return "HW_ACCELERATED";
60 case RTE_COMPDEV_FF_CPU_SSE:
62 case RTE_COMPDEV_FF_CPU_AVX:
64 case RTE_COMPDEV_FF_CPU_AVX2:
66 case RTE_COMPDEV_FF_CPU_AVX512:
68 case RTE_COMPDEV_FF_CPU_NEON:
70 case RTE_COMPDEV_FF_OP_DONE_IN_DEQUEUE:
71 return "OP_DONE_IN_DEQ";
77 static struct rte_compressdev *
78 rte_compressdev_get_dev(uint8_t dev_id)
80 return &compressdev_globals.devs[dev_id];
83 struct rte_compressdev *
84 rte_compressdev_pmd_get_named_dev(const char *name)
86 struct rte_compressdev *dev;
92 for (i = 0; i < compressdev_globals.max_devs; i++) {
93 dev = &compressdev_globals.devs[i];
95 if ((dev->attached == RTE_COMPRESSDEV_ATTACHED) &&
96 (strcmp(dev->data->name, name) == 0))
104 rte_compressdev_is_valid_dev(uint8_t dev_id)
106 struct rte_compressdev *dev = NULL;
108 if (dev_id >= compressdev_globals.nb_devs)
111 dev = rte_compressdev_get_dev(dev_id);
112 if (dev->attached != RTE_COMPRESSDEV_ATTACHED)
120 rte_compressdev_get_dev_id(const char *name)
127 for (i = 0; i < compressdev_globals.nb_devs; i++)
128 if ((strcmp(compressdev_globals.devs[i].data->name, name)
130 (compressdev_globals.devs[i].attached ==
131 RTE_COMPRESSDEV_ATTACHED))
138 rte_compressdev_count(void)
140 return compressdev_globals.nb_devs;
144 rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
147 uint8_t i, count = 0;
148 struct rte_compressdev *devs = compressdev_globals.devs;
149 uint8_t max_devs = compressdev_globals.max_devs;
151 for (i = 0; i < max_devs && count < nb_devices; i++) {
153 if (devs[i].attached == RTE_COMPRESSDEV_ATTACHED) {
156 cmp = strncmp(devs[i].device->driver->name,
158 strlen(driver_name));
161 devices[count++] = devs[i].data->dev_id;
169 rte_compressdev_socket_id(uint8_t dev_id)
171 struct rte_compressdev *dev;
173 if (!rte_compressdev_is_valid_dev(dev_id))
176 dev = rte_compressdev_get_dev(dev_id);
178 return dev->data->socket_id;
182 rte_compressdev_data_alloc(uint8_t dev_id, struct rte_compressdev_data **data,
185 char mz_name[RTE_COMPRESSDEV_NAME_MAX_LEN];
186 const struct rte_memzone *mz;
189 /* generate memzone name */
190 n = snprintf(mz_name, sizeof(mz_name),
191 "rte_compressdev_data_%u", dev_id);
192 if (n >= (int)sizeof(mz_name))
195 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
196 mz = rte_memzone_reserve(mz_name,
197 sizeof(struct rte_compressdev_data),
200 mz = rte_memzone_lookup(mz_name);
206 if (rte_eal_process_type() == RTE_PROC_PRIMARY)
207 memset(*data, 0, sizeof(struct rte_compressdev_data));
213 rte_compressdev_find_free_device_index(void)
217 for (dev_id = 0; dev_id < RTE_COMPRESS_MAX_DEVS; dev_id++) {
218 if (rte_comp_devices[dev_id].attached ==
219 RTE_COMPRESSDEV_DETACHED)
222 return RTE_COMPRESS_MAX_DEVS;
225 struct rte_compressdev *
226 rte_compressdev_pmd_allocate(const char *name, int socket_id)
228 struct rte_compressdev *compressdev;
231 if (rte_compressdev_pmd_get_named_dev(name) != NULL) {
233 "comp device with name %s already allocated!", name);
237 dev_id = rte_compressdev_find_free_device_index();
238 if (dev_id == RTE_COMPRESS_MAX_DEVS) {
239 COMPRESSDEV_LOG(ERR, "Reached maximum number of comp devices");
242 compressdev = rte_compressdev_get_dev(dev_id);
244 if (compressdev->data == NULL) {
245 struct rte_compressdev_data *compressdev_data =
246 compressdev_globals.data[dev_id];
248 int retval = rte_compressdev_data_alloc(dev_id,
249 &compressdev_data, socket_id);
251 if (retval < 0 || compressdev_data == NULL)
254 compressdev->data = compressdev_data;
256 strlcpy(compressdev->data->name, name,
257 RTE_COMPRESSDEV_NAME_MAX_LEN);
259 compressdev->data->dev_id = dev_id;
260 compressdev->data->socket_id = socket_id;
261 compressdev->data->dev_started = 0;
263 compressdev->attached = RTE_COMPRESSDEV_ATTACHED;
265 compressdev_globals.nb_devs++;
272 rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
276 if (compressdev == NULL)
279 /* Close device only if device operations have been set */
280 if (compressdev->dev_ops) {
281 ret = rte_compressdev_close(compressdev->data->dev_id);
286 compressdev->attached = RTE_COMPRESSDEV_DETACHED;
287 compressdev_globals.nb_devs--;
292 rte_compressdev_queue_pair_count(uint8_t dev_id)
294 struct rte_compressdev *dev;
296 dev = &rte_comp_devices[dev_id];
297 return dev->data->nb_queue_pairs;
301 rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
302 uint16_t nb_qpairs, int socket_id)
304 struct rte_compressdev_info dev_info;
308 if ((dev == NULL) || (nb_qpairs < 1)) {
309 COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",
314 COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",
315 nb_qpairs, dev->data->dev_id);
317 memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
319 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
320 (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
322 if ((dev_info.max_nb_queue_pairs != 0) &&
323 (nb_qpairs > dev_info.max_nb_queue_pairs)) {
324 COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",
325 nb_qpairs, dev->data->dev_id);
329 if (dev->data->queue_pairs == NULL) { /* first time configuration */
330 dev->data->queue_pairs = rte_zmalloc_socket(
331 "compressdev->queue_pairs",
332 sizeof(dev->data->queue_pairs[0]) * nb_qpairs,
333 RTE_CACHE_LINE_SIZE, socket_id);
335 if (dev->data->queue_pairs == NULL) {
336 dev->data->nb_queue_pairs = 0;
338 "failed to get memory for qp meta data, nb_queues %u",
342 } else { /* re-configure */
344 uint16_t old_nb_queues = dev->data->nb_queue_pairs;
346 qp = dev->data->queue_pairs;
348 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
351 for (i = nb_qpairs; i < old_nb_queues; i++) {
352 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
357 qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
358 RTE_CACHE_LINE_SIZE);
361 "failed to realloc qp meta data, nb_queues %u",
366 if (nb_qpairs > old_nb_queues) {
367 uint16_t new_qs = nb_qpairs - old_nb_queues;
369 memset(qp + old_nb_queues, 0,
370 sizeof(qp[0]) * new_qs);
373 dev->data->queue_pairs = qp;
376 dev->data->nb_queue_pairs = nb_qpairs;
381 rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
387 COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev);
391 num_qps = dev->data->nb_queue_pairs;
396 COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",
397 dev->data->nb_queue_pairs, dev->data->dev_id);
399 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
402 for (i = 0; i < num_qps; i++) {
403 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
408 rte_free(dev->data->queue_pairs);
409 dev->data->queue_pairs = NULL;
410 dev->data->nb_queue_pairs = 0;
416 rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
418 struct rte_compressdev *dev;
421 if (!rte_compressdev_is_valid_dev(dev_id)) {
422 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
426 dev = &rte_comp_devices[dev_id];
428 if (dev->data->dev_started) {
430 "device %d must be stopped to allow configuration", dev_id);
434 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
436 /* Setup new number of queue pairs and reconfigure device. */
437 diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
441 "dev%d rte_comp_dev_queue_pairs_config = %d",
446 return (*dev->dev_ops->dev_configure)(dev, config);
450 rte_compressdev_start(uint8_t dev_id)
452 struct rte_compressdev *dev;
455 COMPRESSDEV_LOG(DEBUG, "Start dev_id=%" PRIu8, dev_id);
457 if (!rte_compressdev_is_valid_dev(dev_id)) {
458 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
462 dev = &rte_comp_devices[dev_id];
464 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP);
466 if (dev->data->dev_started != 0) {
468 "Device with dev_id=%" PRIu8 " already started", dev_id);
472 diag = (*dev->dev_ops->dev_start)(dev);
474 dev->data->dev_started = 1;
482 rte_compressdev_stop(uint8_t dev_id)
484 struct rte_compressdev *dev;
486 if (!rte_compressdev_is_valid_dev(dev_id)) {
487 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
491 dev = &rte_comp_devices[dev_id];
493 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop);
495 if (dev->data->dev_started == 0) {
497 "Device with dev_id=%" PRIu8 " already stopped", dev_id);
501 (*dev->dev_ops->dev_stop)(dev);
502 dev->data->dev_started = 0;
506 rte_compressdev_close(uint8_t dev_id)
508 struct rte_compressdev *dev;
511 if (!rte_compressdev_is_valid_dev(dev_id)) {
512 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
516 dev = &rte_comp_devices[dev_id];
518 /* Device must be stopped before it can be closed */
519 if (dev->data->dev_started == 1) {
520 COMPRESSDEV_LOG(ERR, "Device %u must be stopped before closing",
525 /* Free queue pairs memory */
526 retval = rte_compressdev_queue_pairs_release(dev);
531 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP);
532 retval = (*dev->dev_ops->dev_close)(dev);
541 rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
542 uint32_t max_inflight_ops, int socket_id)
544 struct rte_compressdev *dev;
546 if (!rte_compressdev_is_valid_dev(dev_id)) {
547 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
551 dev = &rte_comp_devices[dev_id];
552 if (queue_pair_id >= dev->data->nb_queue_pairs) {
553 COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id);
557 if (dev->data->dev_started) {
559 "device %d must be stopped to allow configuration", dev_id);
563 if (max_inflight_ops == 0) {
565 "Invalid maximum number of inflight operations");
569 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP);
571 return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
572 max_inflight_ops, socket_id);
576 rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
577 struct rte_comp_op **ops, uint16_t nb_ops)
579 struct rte_compressdev *dev = &rte_comp_devices[dev_id];
581 nb_ops = (*dev->dequeue_burst)
582 (dev->data->queue_pairs[qp_id], ops, nb_ops);
588 rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
589 struct rte_comp_op **ops, uint16_t nb_ops)
591 struct rte_compressdev *dev = &rte_comp_devices[dev_id];
593 return (*dev->enqueue_burst)(
594 dev->data->queue_pairs[qp_id], ops, nb_ops);
598 rte_compressdev_stats_get(uint8_t dev_id, struct rte_compressdev_stats *stats)
600 struct rte_compressdev *dev;
602 if (!rte_compressdev_is_valid_dev(dev_id)) {
603 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
608 COMPRESSDEV_LOG(ERR, "Invalid stats ptr");
612 dev = &rte_comp_devices[dev_id];
613 memset(stats, 0, sizeof(*stats));
615 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stats_get, -ENOTSUP);
616 (*dev->dev_ops->stats_get)(dev, stats);
621 rte_compressdev_stats_reset(uint8_t dev_id)
623 struct rte_compressdev *dev;
625 if (!rte_compressdev_is_valid_dev(dev_id)) {
626 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
630 dev = &rte_comp_devices[dev_id];
632 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->stats_reset);
633 (*dev->dev_ops->stats_reset)(dev);
638 rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
640 struct rte_compressdev *dev;
642 if (dev_id >= compressdev_globals.nb_devs) {
643 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
647 dev = &rte_comp_devices[dev_id];
649 memset(dev_info, 0, sizeof(struct rte_compressdev_info));
651 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get);
652 (*dev->dev_ops->dev_infos_get)(dev, dev_info);
654 dev_info->driver_name = dev->device->driver->name;
658 rte_compressdev_private_xform_create(uint8_t dev_id,
659 const struct rte_comp_xform *xform,
662 struct rte_compressdev *dev;
665 dev = rte_compressdev_get_dev(dev_id);
667 if (xform == NULL || priv_xform == NULL || dev == NULL)
670 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_create, -ENOTSUP);
671 ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
674 "dev_id %d failed to create private_xform: err=%d",
683 rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
685 struct rte_compressdev *dev;
688 dev = rte_compressdev_get_dev(dev_id);
690 if (dev == NULL || priv_xform == NULL)
693 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_free, -ENOTSUP);
694 ret = dev->dev_ops->private_xform_free(dev, priv_xform);
697 "dev_id %d failed to free private xform: err=%d",
706 rte_compressdev_stream_create(uint8_t dev_id,
707 const struct rte_comp_xform *xform,
710 struct rte_compressdev *dev;
713 dev = rte_compressdev_get_dev(dev_id);
715 if (xform == NULL || dev == NULL || stream == NULL)
718 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_create, -ENOTSUP);
719 ret = (*dev->dev_ops->stream_create)(dev, xform, stream);
722 "dev_id %d failed to create stream: err=%d",
732 rte_compressdev_stream_free(uint8_t dev_id, void *stream)
734 struct rte_compressdev *dev;
737 dev = rte_compressdev_get_dev(dev_id);
739 if (dev == NULL || stream == NULL)
742 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_free, -ENOTSUP);
743 ret = dev->dev_ops->stream_free(dev, stream);
746 "dev_id %d failed to free stream: err=%d",
755 rte_compressdev_name_get(uint8_t dev_id)
757 struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
762 return dev->data->name;
765 RTE_LOG_REGISTER_DEFAULT(compressdev_logtype, NOTICE);