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 char * __rte_experimental
35 rte_compressdev_get_feature_name(uint64_t flag)
38 case RTE_COMPDEV_FF_HW_ACCELERATED:
39 return "HW_ACCELERATED";
40 case RTE_COMPDEV_FF_CPU_SSE:
42 case RTE_COMPDEV_FF_CPU_AVX:
44 case RTE_COMPDEV_FF_CPU_AVX2:
46 case RTE_COMPDEV_FF_CPU_AVX512:
48 case RTE_COMPDEV_FF_CPU_NEON:
55 static struct rte_compressdev *
56 rte_compressdev_get_dev(uint8_t dev_id)
58 return &rte_compressdev_globals->devs[dev_id];
61 struct rte_compressdev * __rte_experimental
62 rte_compressdev_pmd_get_named_dev(const char *name)
64 struct rte_compressdev *dev;
70 for (i = 0; i < rte_compressdev_globals->max_devs; i++) {
71 dev = &rte_compressdev_globals->devs[i];
73 if ((dev->attached == RTE_COMPRESSDEV_ATTACHED) &&
74 (strcmp(dev->data->name, name) == 0))
82 rte_compressdev_is_valid_dev(uint8_t dev_id)
84 struct rte_compressdev *dev = NULL;
86 if (dev_id >= rte_compressdev_globals->nb_devs)
89 dev = rte_compressdev_get_dev(dev_id);
90 if (dev->attached != RTE_COMPRESSDEV_ATTACHED)
97 uint8_t __rte_experimental
98 rte_compressdev_count(void)
100 return rte_compressdev_globals->nb_devs;
103 uint8_t __rte_experimental
104 rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
107 uint8_t i, count = 0;
108 struct rte_compressdev *devs = rte_compressdev_globals->devs;
109 uint8_t max_devs = rte_compressdev_globals->max_devs;
111 for (i = 0; i < max_devs && count < nb_devices; i++) {
113 if (devs[i].attached == RTE_COMPRESSDEV_ATTACHED) {
116 cmp = strncmp(devs[i].device->driver->name,
118 strlen(driver_name));
121 devices[count++] = devs[i].data->dev_id;
128 int __rte_experimental
129 rte_compressdev_socket_id(uint8_t dev_id)
131 struct rte_compressdev *dev;
133 if (!rte_compressdev_is_valid_dev(dev_id))
136 dev = rte_compressdev_get_dev(dev_id);
138 return dev->data->socket_id;
142 rte_compressdev_data_alloc(uint8_t dev_id, struct rte_compressdev_data **data,
145 char mz_name[RTE_COMPRESSDEV_NAME_MAX_LEN];
146 const struct rte_memzone *mz;
149 /* generate memzone name */
150 n = snprintf(mz_name, sizeof(mz_name),
151 "rte_compressdev_data_%u", dev_id);
152 if (n >= (int)sizeof(mz_name))
155 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
156 mz = rte_memzone_reserve(mz_name,
157 sizeof(struct rte_compressdev_data),
160 mz = rte_memzone_lookup(mz_name);
166 if (rte_eal_process_type() == RTE_PROC_PRIMARY)
167 memset(*data, 0, sizeof(struct rte_compressdev_data));
173 rte_compressdev_find_free_device_index(void)
177 for (dev_id = 0; dev_id < RTE_COMPRESS_MAX_DEVS; dev_id++) {
178 if (rte_comp_devices[dev_id].attached ==
179 RTE_COMPRESSDEV_DETACHED)
182 return RTE_COMPRESS_MAX_DEVS;
185 struct rte_compressdev * __rte_experimental
186 rte_compressdev_pmd_allocate(const char *name, int socket_id)
188 struct rte_compressdev *compressdev;
191 if (rte_compressdev_pmd_get_named_dev(name) != NULL) {
193 "comp device with name %s already allocated!", name);
197 dev_id = rte_compressdev_find_free_device_index();
198 if (dev_id == RTE_COMPRESS_MAX_DEVS) {
199 COMPRESSDEV_LOG(ERR, "Reached maximum number of comp devices");
202 compressdev = rte_compressdev_get_dev(dev_id);
204 if (compressdev->data == NULL) {
205 struct rte_compressdev_data *compressdev_data =
206 compressdev_globals.data[dev_id];
208 int retval = rte_compressdev_data_alloc(dev_id,
209 &compressdev_data, socket_id);
211 if (retval < 0 || compressdev_data == NULL)
214 compressdev->data = compressdev_data;
216 snprintf(compressdev->data->name, RTE_COMPRESSDEV_NAME_MAX_LEN,
219 compressdev->data->dev_id = dev_id;
220 compressdev->data->socket_id = socket_id;
221 compressdev->data->dev_started = 0;
223 compressdev->attached = RTE_COMPRESSDEV_ATTACHED;
225 compressdev_globals.nb_devs++;
231 int __rte_experimental
232 rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
236 if (compressdev == NULL)
239 /* Close device only if device operations have been set */
240 if (compressdev->dev_ops) {
241 ret = rte_compressdev_close(compressdev->data->dev_id);
246 compressdev->attached = RTE_COMPRESSDEV_DETACHED;
247 compressdev_globals.nb_devs--;
251 uint16_t __rte_experimental
252 rte_compressdev_queue_pair_count(uint8_t dev_id)
254 struct rte_compressdev *dev;
256 dev = &rte_comp_devices[dev_id];
257 return dev->data->nb_queue_pairs;
261 rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
262 uint16_t nb_qpairs, int socket_id)
264 struct rte_compressdev_info dev_info;
268 if ((dev == NULL) || (nb_qpairs < 1)) {
269 COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",
274 COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",
275 nb_qpairs, dev->data->dev_id);
277 memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
279 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
280 (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
282 if ((dev_info.max_nb_queue_pairs != 0) &&
283 (nb_qpairs > dev_info.max_nb_queue_pairs)) {
284 COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",
285 nb_qpairs, dev->data->dev_id);
289 if (dev->data->queue_pairs == NULL) { /* first time configuration */
290 dev->data->queue_pairs = rte_zmalloc_socket(
291 "compressdev->queue_pairs",
292 sizeof(dev->data->queue_pairs[0]) * nb_qpairs,
293 RTE_CACHE_LINE_SIZE, socket_id);
295 if (dev->data->queue_pairs == NULL) {
296 dev->data->nb_queue_pairs = 0;
298 "failed to get memory for qp meta data, nb_queues %u",
302 } else { /* re-configure */
304 uint16_t old_nb_queues = dev->data->nb_queue_pairs;
306 qp = dev->data->queue_pairs;
308 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
311 for (i = nb_qpairs; i < old_nb_queues; i++) {
312 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
317 qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
318 RTE_CACHE_LINE_SIZE);
321 "failed to realloc qp meta data, nb_queues %u",
326 if (nb_qpairs > old_nb_queues) {
327 uint16_t new_qs = nb_qpairs - old_nb_queues;
329 memset(qp + old_nb_queues, 0,
330 sizeof(qp[0]) * new_qs);
333 dev->data->queue_pairs = qp;
336 dev->data->nb_queue_pairs = nb_qpairs;
341 rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
347 COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev);
351 num_qps = dev->data->nb_queue_pairs;
356 COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",
357 dev->data->nb_queue_pairs, dev->data->dev_id);
359 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
362 for (i = 0; i < num_qps; i++) {
363 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
368 if (dev->data->queue_pairs != NULL)
369 rte_free(dev->data->queue_pairs);
370 dev->data->queue_pairs = NULL;
371 dev->data->nb_queue_pairs = 0;
376 int __rte_experimental
377 rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
379 struct rte_compressdev *dev;
382 if (!rte_compressdev_is_valid_dev(dev_id)) {
383 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
387 dev = &rte_comp_devices[dev_id];
389 if (dev->data->dev_started) {
391 "device %d must be stopped to allow configuration", dev_id);
395 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
397 /* Setup new number of queue pairs and reconfigure device. */
398 diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
402 "dev%d rte_comp_dev_queue_pairs_config = %d",
407 return (*dev->dev_ops->dev_configure)(dev, config);
410 int __rte_experimental
411 rte_compressdev_start(uint8_t dev_id)
413 struct rte_compressdev *dev;
416 COMPRESSDEV_LOG(DEBUG, "Start dev_id=%" PRIu8, dev_id);
418 if (!rte_compressdev_is_valid_dev(dev_id)) {
419 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
423 dev = &rte_comp_devices[dev_id];
425 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP);
427 if (dev->data->dev_started != 0) {
429 "Device with dev_id=%" PRIu8 " already started", dev_id);
433 diag = (*dev->dev_ops->dev_start)(dev);
435 dev->data->dev_started = 1;
442 void __rte_experimental
443 rte_compressdev_stop(uint8_t dev_id)
445 struct rte_compressdev *dev;
447 if (!rte_compressdev_is_valid_dev(dev_id)) {
448 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
452 dev = &rte_comp_devices[dev_id];
454 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop);
456 if (dev->data->dev_started == 0) {
458 "Device with dev_id=%" PRIu8 " already stopped", dev_id);
462 (*dev->dev_ops->dev_stop)(dev);
463 dev->data->dev_started = 0;
466 int __rte_experimental
467 rte_compressdev_close(uint8_t dev_id)
469 struct rte_compressdev *dev;
472 if (!rte_compressdev_is_valid_dev(dev_id)) {
473 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
477 dev = &rte_comp_devices[dev_id];
479 /* Device must be stopped before it can be closed */
480 if (dev->data->dev_started == 1) {
481 COMPRESSDEV_LOG(ERR, "Device %u must be stopped before closing",
486 /* Free queue pairs memory */
487 retval = rte_compressdev_queue_pairs_release(dev);
492 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP);
493 retval = (*dev->dev_ops->dev_close)(dev);
501 int __rte_experimental
502 rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
503 uint32_t max_inflight_ops, int socket_id)
505 struct rte_compressdev *dev;
507 if (!rte_compressdev_is_valid_dev(dev_id)) {
508 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
512 dev = &rte_comp_devices[dev_id];
513 if (queue_pair_id >= dev->data->nb_queue_pairs) {
514 COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id);
518 if (dev->data->dev_started) {
520 "device %d must be stopped to allow configuration", dev_id);
524 if (max_inflight_ops == 0) {
526 "Invalid maximum number of inflight operations");
530 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP);
532 return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
533 max_inflight_ops, socket_id);
536 uint16_t __rte_experimental
537 rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
538 struct rte_comp_op **ops, uint16_t nb_ops)
540 struct rte_compressdev *dev = &rte_compressdevs[dev_id];
542 nb_ops = (*dev->dequeue_burst)
543 (dev->data->queue_pairs[qp_id], ops, nb_ops);
548 uint16_t __rte_experimental
549 rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
550 struct rte_comp_op **ops, uint16_t nb_ops)
552 struct rte_compressdev *dev = &rte_compressdevs[dev_id];
554 return (*dev->enqueue_burst)(
555 dev->data->queue_pairs[qp_id], ops, nb_ops);
558 void __rte_experimental
559 rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
561 struct rte_compressdev *dev;
563 if (dev_id >= compressdev_globals.nb_devs) {
564 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
568 dev = &rte_comp_devices[dev_id];
570 memset(dev_info, 0, sizeof(struct rte_compressdev_info));
572 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get);
573 (*dev->dev_ops->dev_infos_get)(dev, dev_info);
575 dev_info->driver_name = dev->device->driver->name;
578 int __rte_experimental
579 rte_compressdev_private_xform_create(uint8_t dev_id,
580 const struct rte_comp_xform *xform,
583 struct rte_compressdev *dev;
586 dev = rte_compressdev_get_dev(dev_id);
588 if (xform == NULL || priv_xform == NULL || dev == NULL)
591 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_create, -ENOTSUP);
592 ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
595 "dev_id %d failed to create private_xform: err=%d",
603 int __rte_experimental
604 rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
606 struct rte_compressdev *dev;
609 dev = rte_compressdev_get_dev(dev_id);
611 if (dev == NULL || priv_xform == NULL)
614 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_free, -ENOTSUP);
615 ret = dev->dev_ops->private_xform_free(dev, priv_xform);
618 "dev_id %d failed to free private xform: err=%d",
626 int __rte_experimental
627 rte_compressdev_stream_create(uint8_t dev_id,
628 const struct rte_comp_xform *xform,
631 struct rte_compressdev *dev;
634 dev = rte_compressdev_get_dev(dev_id);
636 if (xform == NULL || dev == NULL || stream == NULL)
639 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_create, -ENOTSUP);
640 ret = (*dev->dev_ops->stream_create)(dev, xform, stream);
643 "dev_id %d failed to create stream: err=%d",
652 int __rte_experimental
653 rte_compressdev_stream_free(uint8_t dev_id, void *stream)
655 struct rte_compressdev *dev;
658 dev = rte_compressdev_get_dev(dev_id);
660 if (dev == NULL || stream == NULL)
663 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_free, -ENOTSUP);
664 ret = dev->dev_ops->stream_free(dev, stream);
667 "dev_id %d failed to free stream: err=%d",
675 const char * __rte_experimental
676 rte_compressdev_name_get(uint8_t dev_id)
678 struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
683 return dev->data->name;
686 RTE_INIT(rte_compressdev_log);
689 rte_compressdev_log(void)
691 compressdev_logtype = rte_log_register("lib.compressdev");
692 if (compressdev_logtype >= 0)
693 rte_log_set_level(compressdev_logtype, RTE_LOG_NOTICE);