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 struct rte_compressdev rte_comp_devices[RTE_COMPRESS_MAX_DEVS];
23 struct rte_compressdev *rte_compressdevs = &rte_comp_devices[0];
25 static struct rte_compressdev_global compressdev_globals = {
26 .devs = &rte_comp_devices[0],
29 .max_devs = RTE_COMPRESS_MAX_DEVS
32 struct rte_compressdev_global *rte_compressdev_globals = &compressdev_globals;
34 const struct rte_compressdev_capabilities * __rte_experimental
35 rte_compressdev_capability_get(uint8_t dev_id,
36 enum rte_comp_algorithm algo)
38 const struct rte_compressdev_capabilities *capability;
39 struct rte_compressdev_info dev_info;
42 if (dev_id >= compressdev_globals.nb_devs) {
43 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
46 rte_compressdev_info_get(dev_id, &dev_info);
48 while ((capability = &dev_info.capabilities[i++])->algo !=
49 RTE_COMP_ALGO_UNSPECIFIED){
50 if (capability->algo == algo)
57 const char * __rte_experimental
58 rte_compressdev_get_feature_name(uint64_t flag)
61 case RTE_COMPDEV_FF_HW_ACCELERATED:
62 return "HW_ACCELERATED";
63 case RTE_COMPDEV_FF_CPU_SSE:
65 case RTE_COMPDEV_FF_CPU_AVX:
67 case RTE_COMPDEV_FF_CPU_AVX2:
69 case RTE_COMPDEV_FF_CPU_AVX512:
71 case RTE_COMPDEV_FF_CPU_NEON:
78 static struct rte_compressdev *
79 rte_compressdev_get_dev(uint8_t dev_id)
81 return &rte_compressdev_globals->devs[dev_id];
84 struct rte_compressdev * __rte_experimental
85 rte_compressdev_pmd_get_named_dev(const char *name)
87 struct rte_compressdev *dev;
93 for (i = 0; i < rte_compressdev_globals->max_devs; i++) {
94 dev = &rte_compressdev_globals->devs[i];
96 if ((dev->attached == RTE_COMPRESSDEV_ATTACHED) &&
97 (strcmp(dev->data->name, name) == 0))
105 rte_compressdev_is_valid_dev(uint8_t dev_id)
107 struct rte_compressdev *dev = NULL;
109 if (dev_id >= rte_compressdev_globals->nb_devs)
112 dev = rte_compressdev_get_dev(dev_id);
113 if (dev->attached != RTE_COMPRESSDEV_ATTACHED)
120 int __rte_experimental
121 rte_compressdev_get_dev_id(const char *name)
128 for (i = 0; i < rte_compressdev_globals->nb_devs; i++)
129 if ((strcmp(rte_compressdev_globals->devs[i].data->name, name)
131 (rte_compressdev_globals->devs[i].attached ==
132 RTE_COMPRESSDEV_ATTACHED))
138 uint8_t __rte_experimental
139 rte_compressdev_count(void)
141 return rte_compressdev_globals->nb_devs;
144 uint8_t __rte_experimental
145 rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
148 uint8_t i, count = 0;
149 struct rte_compressdev *devs = rte_compressdev_globals->devs;
150 uint8_t max_devs = rte_compressdev_globals->max_devs;
152 for (i = 0; i < max_devs && count < nb_devices; i++) {
154 if (devs[i].attached == RTE_COMPRESSDEV_ATTACHED) {
157 cmp = strncmp(devs[i].device->driver->name,
159 strlen(driver_name));
162 devices[count++] = devs[i].data->dev_id;
169 int __rte_experimental
170 rte_compressdev_socket_id(uint8_t dev_id)
172 struct rte_compressdev *dev;
174 if (!rte_compressdev_is_valid_dev(dev_id))
177 dev = rte_compressdev_get_dev(dev_id);
179 return dev->data->socket_id;
183 rte_compressdev_data_alloc(uint8_t dev_id, struct rte_compressdev_data **data,
186 char mz_name[RTE_COMPRESSDEV_NAME_MAX_LEN];
187 const struct rte_memzone *mz;
190 /* generate memzone name */
191 n = snprintf(mz_name, sizeof(mz_name),
192 "rte_compressdev_data_%u", dev_id);
193 if (n >= (int)sizeof(mz_name))
196 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
197 mz = rte_memzone_reserve(mz_name,
198 sizeof(struct rte_compressdev_data),
201 mz = rte_memzone_lookup(mz_name);
207 if (rte_eal_process_type() == RTE_PROC_PRIMARY)
208 memset(*data, 0, sizeof(struct rte_compressdev_data));
214 rte_compressdev_find_free_device_index(void)
218 for (dev_id = 0; dev_id < RTE_COMPRESS_MAX_DEVS; dev_id++) {
219 if (rte_comp_devices[dev_id].attached ==
220 RTE_COMPRESSDEV_DETACHED)
223 return RTE_COMPRESS_MAX_DEVS;
226 struct rte_compressdev * __rte_experimental
227 rte_compressdev_pmd_allocate(const char *name, int socket_id)
229 struct rte_compressdev *compressdev;
232 if (rte_compressdev_pmd_get_named_dev(name) != NULL) {
234 "comp device with name %s already allocated!", name);
238 dev_id = rte_compressdev_find_free_device_index();
239 if (dev_id == RTE_COMPRESS_MAX_DEVS) {
240 COMPRESSDEV_LOG(ERR, "Reached maximum number of comp devices");
243 compressdev = rte_compressdev_get_dev(dev_id);
245 if (compressdev->data == NULL) {
246 struct rte_compressdev_data *compressdev_data =
247 compressdev_globals.data[dev_id];
249 int retval = rte_compressdev_data_alloc(dev_id,
250 &compressdev_data, socket_id);
252 if (retval < 0 || compressdev_data == NULL)
255 compressdev->data = compressdev_data;
257 snprintf(compressdev->data->name, RTE_COMPRESSDEV_NAME_MAX_LEN,
260 compressdev->data->dev_id = dev_id;
261 compressdev->data->socket_id = socket_id;
262 compressdev->data->dev_started = 0;
264 compressdev->attached = RTE_COMPRESSDEV_ATTACHED;
266 compressdev_globals.nb_devs++;
272 int __rte_experimental
273 rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
277 if (compressdev == NULL)
280 /* Close device only if device operations have been set */
281 if (compressdev->dev_ops) {
282 ret = rte_compressdev_close(compressdev->data->dev_id);
287 compressdev->attached = RTE_COMPRESSDEV_DETACHED;
288 compressdev_globals.nb_devs--;
292 uint16_t __rte_experimental
293 rte_compressdev_queue_pair_count(uint8_t dev_id)
295 struct rte_compressdev *dev;
297 dev = &rte_comp_devices[dev_id];
298 return dev->data->nb_queue_pairs;
302 rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
303 uint16_t nb_qpairs, int socket_id)
305 struct rte_compressdev_info dev_info;
309 if ((dev == NULL) || (nb_qpairs < 1)) {
310 COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",
315 COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",
316 nb_qpairs, dev->data->dev_id);
318 memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
320 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
321 (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
323 if ((dev_info.max_nb_queue_pairs != 0) &&
324 (nb_qpairs > dev_info.max_nb_queue_pairs)) {
325 COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",
326 nb_qpairs, dev->data->dev_id);
330 if (dev->data->queue_pairs == NULL) { /* first time configuration */
331 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);
336 if (dev->data->queue_pairs == NULL) {
337 dev->data->nb_queue_pairs = 0;
339 "failed to get memory for qp meta data, nb_queues %u",
343 } else { /* re-configure */
345 uint16_t old_nb_queues = dev->data->nb_queue_pairs;
347 qp = dev->data->queue_pairs;
349 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
352 for (i = nb_qpairs; i < old_nb_queues; i++) {
353 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
358 qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
359 RTE_CACHE_LINE_SIZE);
362 "failed to realloc qp meta data, nb_queues %u",
367 if (nb_qpairs > old_nb_queues) {
368 uint16_t new_qs = nb_qpairs - old_nb_queues;
370 memset(qp + old_nb_queues, 0,
371 sizeof(qp[0]) * new_qs);
374 dev->data->queue_pairs = qp;
377 dev->data->nb_queue_pairs = nb_qpairs;
382 rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
388 COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev);
392 num_qps = dev->data->nb_queue_pairs;
397 COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",
398 dev->data->nb_queue_pairs, dev->data->dev_id);
400 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
403 for (i = 0; i < num_qps; i++) {
404 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
409 if (dev->data->queue_pairs != NULL)
410 rte_free(dev->data->queue_pairs);
411 dev->data->queue_pairs = NULL;
412 dev->data->nb_queue_pairs = 0;
417 int __rte_experimental
418 rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
420 struct rte_compressdev *dev;
423 if (!rte_compressdev_is_valid_dev(dev_id)) {
424 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
428 dev = &rte_comp_devices[dev_id];
430 if (dev->data->dev_started) {
432 "device %d must be stopped to allow configuration", dev_id);
436 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
438 /* Setup new number of queue pairs and reconfigure device. */
439 diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
443 "dev%d rte_comp_dev_queue_pairs_config = %d",
448 return (*dev->dev_ops->dev_configure)(dev, config);
451 int __rte_experimental
452 rte_compressdev_start(uint8_t dev_id)
454 struct rte_compressdev *dev;
457 COMPRESSDEV_LOG(DEBUG, "Start dev_id=%" PRIu8, dev_id);
459 if (!rte_compressdev_is_valid_dev(dev_id)) {
460 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
464 dev = &rte_comp_devices[dev_id];
466 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP);
468 if (dev->data->dev_started != 0) {
470 "Device with dev_id=%" PRIu8 " already started", dev_id);
474 diag = (*dev->dev_ops->dev_start)(dev);
476 dev->data->dev_started = 1;
483 void __rte_experimental
484 rte_compressdev_stop(uint8_t dev_id)
486 struct rte_compressdev *dev;
488 if (!rte_compressdev_is_valid_dev(dev_id)) {
489 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
493 dev = &rte_comp_devices[dev_id];
495 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop);
497 if (dev->data->dev_started == 0) {
499 "Device with dev_id=%" PRIu8 " already stopped", dev_id);
503 (*dev->dev_ops->dev_stop)(dev);
504 dev->data->dev_started = 0;
507 int __rte_experimental
508 rte_compressdev_close(uint8_t dev_id)
510 struct rte_compressdev *dev;
513 if (!rte_compressdev_is_valid_dev(dev_id)) {
514 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
518 dev = &rte_comp_devices[dev_id];
520 /* Device must be stopped before it can be closed */
521 if (dev->data->dev_started == 1) {
522 COMPRESSDEV_LOG(ERR, "Device %u must be stopped before closing",
527 /* Free queue pairs memory */
528 retval = rte_compressdev_queue_pairs_release(dev);
533 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP);
534 retval = (*dev->dev_ops->dev_close)(dev);
542 int __rte_experimental
543 rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
544 uint32_t max_inflight_ops, int socket_id)
546 struct rte_compressdev *dev;
548 if (!rte_compressdev_is_valid_dev(dev_id)) {
549 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
553 dev = &rte_comp_devices[dev_id];
554 if (queue_pair_id >= dev->data->nb_queue_pairs) {
555 COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id);
559 if (dev->data->dev_started) {
561 "device %d must be stopped to allow configuration", dev_id);
565 if (max_inflight_ops == 0) {
567 "Invalid maximum number of inflight operations");
571 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP);
573 return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
574 max_inflight_ops, socket_id);
577 uint16_t __rte_experimental
578 rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
579 struct rte_comp_op **ops, uint16_t nb_ops)
581 struct rte_compressdev *dev = &rte_compressdevs[dev_id];
583 nb_ops = (*dev->dequeue_burst)
584 (dev->data->queue_pairs[qp_id], ops, nb_ops);
589 uint16_t __rte_experimental
590 rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
591 struct rte_comp_op **ops, uint16_t nb_ops)
593 struct rte_compressdev *dev = &rte_compressdevs[dev_id];
595 return (*dev->enqueue_burst)(
596 dev->data->queue_pairs[qp_id], ops, nb_ops);
599 int __rte_experimental
600 rte_compressdev_stats_get(uint8_t dev_id, struct rte_compressdev_stats *stats)
602 struct rte_compressdev *dev;
604 if (!rte_compressdev_is_valid_dev(dev_id)) {
605 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
610 COMPRESSDEV_LOG(ERR, "Invalid stats ptr");
614 dev = &rte_comp_devices[dev_id];
615 memset(stats, 0, sizeof(*stats));
617 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stats_get, -ENOTSUP);
618 (*dev->dev_ops->stats_get)(dev, stats);
622 void __rte_experimental
623 rte_compressdev_stats_reset(uint8_t dev_id)
625 struct rte_compressdev *dev;
627 if (!rte_compressdev_is_valid_dev(dev_id)) {
628 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
632 dev = &rte_comp_devices[dev_id];
634 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->stats_reset);
635 (*dev->dev_ops->stats_reset)(dev);
639 void __rte_experimental
640 rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
642 struct rte_compressdev *dev;
644 if (dev_id >= compressdev_globals.nb_devs) {
645 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
649 dev = &rte_comp_devices[dev_id];
651 memset(dev_info, 0, sizeof(struct rte_compressdev_info));
653 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get);
654 (*dev->dev_ops->dev_infos_get)(dev, dev_info);
656 dev_info->driver_name = dev->device->driver->name;
659 int __rte_experimental
660 rte_compressdev_private_xform_create(uint8_t dev_id,
661 const struct rte_comp_xform *xform,
664 struct rte_compressdev *dev;
667 dev = rte_compressdev_get_dev(dev_id);
669 if (xform == NULL || priv_xform == NULL || dev == NULL)
672 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_create, -ENOTSUP);
673 ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
676 "dev_id %d failed to create private_xform: err=%d",
684 int __rte_experimental
685 rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
687 struct rte_compressdev *dev;
690 dev = rte_compressdev_get_dev(dev_id);
692 if (dev == NULL || priv_xform == NULL)
695 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_free, -ENOTSUP);
696 ret = dev->dev_ops->private_xform_free(dev, priv_xform);
699 "dev_id %d failed to free private xform: err=%d",
707 int __rte_experimental
708 rte_compressdev_stream_create(uint8_t dev_id,
709 const struct rte_comp_xform *xform,
712 struct rte_compressdev *dev;
715 dev = rte_compressdev_get_dev(dev_id);
717 if (xform == NULL || dev == NULL || stream == NULL)
720 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_create, -ENOTSUP);
721 ret = (*dev->dev_ops->stream_create)(dev, xform, stream);
724 "dev_id %d failed to create stream: err=%d",
733 int __rte_experimental
734 rte_compressdev_stream_free(uint8_t dev_id, void *stream)
736 struct rte_compressdev *dev;
739 dev = rte_compressdev_get_dev(dev_id);
741 if (dev == NULL || stream == NULL)
744 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_free, -ENOTSUP);
745 ret = dev->dev_ops->stream_free(dev, stream);
748 "dev_id %d failed to free stream: err=%d",
756 const char * __rte_experimental
757 rte_compressdev_name_get(uint8_t dev_id)
759 struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
764 return dev->data->name;
767 RTE_INIT(rte_compressdev_log)
769 compressdev_logtype = rte_log_register("lib.compressdev");
770 if (compressdev_logtype >= 0)
771 rte_log_set_level(compressdev_logtype, RTE_LOG_NOTICE);