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 static struct rte_compressdev *
35 rte_compressdev_get_dev(uint8_t dev_id)
37 return &rte_compressdev_globals->devs[dev_id];
40 struct rte_compressdev * __rte_experimental
41 rte_compressdev_pmd_get_named_dev(const char *name)
43 struct rte_compressdev *dev;
49 for (i = 0; i < rte_compressdev_globals->max_devs; i++) {
50 dev = &rte_compressdev_globals->devs[i];
52 if ((dev->attached == RTE_COMPRESSDEV_ATTACHED) &&
53 (strcmp(dev->data->name, name) == 0))
61 rte_compressdev_is_valid_dev(uint8_t dev_id)
63 struct rte_compressdev *dev = NULL;
65 if (dev_id >= rte_compressdev_globals->nb_devs)
68 dev = rte_compressdev_get_dev(dev_id);
69 if (dev->attached != RTE_COMPRESSDEV_ATTACHED)
76 uint8_t __rte_experimental
77 rte_compressdev_count(void)
79 return rte_compressdev_globals->nb_devs;
82 uint8_t __rte_experimental
83 rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
87 struct rte_compressdev *devs = rte_compressdev_globals->devs;
88 uint8_t max_devs = rte_compressdev_globals->max_devs;
90 for (i = 0; i < max_devs && count < nb_devices; i++) {
92 if (devs[i].attached == RTE_COMPRESSDEV_ATTACHED) {
95 cmp = strncmp(devs[i].device->driver->name,
100 devices[count++] = devs[i].data->dev_id;
107 int __rte_experimental
108 rte_compressdev_socket_id(uint8_t dev_id)
110 struct rte_compressdev *dev;
112 if (!rte_compressdev_is_valid_dev(dev_id))
115 dev = rte_compressdev_get_dev(dev_id);
117 return dev->data->socket_id;
121 rte_compressdev_data_alloc(uint8_t dev_id, struct rte_compressdev_data **data,
124 char mz_name[RTE_COMPRESSDEV_NAME_MAX_LEN];
125 const struct rte_memzone *mz;
128 /* generate memzone name */
129 n = snprintf(mz_name, sizeof(mz_name),
130 "rte_compressdev_data_%u", dev_id);
131 if (n >= (int)sizeof(mz_name))
134 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
135 mz = rte_memzone_reserve(mz_name,
136 sizeof(struct rte_compressdev_data),
139 mz = rte_memzone_lookup(mz_name);
145 if (rte_eal_process_type() == RTE_PROC_PRIMARY)
146 memset(*data, 0, sizeof(struct rte_compressdev_data));
152 rte_compressdev_find_free_device_index(void)
156 for (dev_id = 0; dev_id < RTE_COMPRESS_MAX_DEVS; dev_id++) {
157 if (rte_comp_devices[dev_id].attached ==
158 RTE_COMPRESSDEV_DETACHED)
161 return RTE_COMPRESS_MAX_DEVS;
164 struct rte_compressdev * __rte_experimental
165 rte_compressdev_pmd_allocate(const char *name, int socket_id)
167 struct rte_compressdev *compressdev;
170 if (rte_compressdev_pmd_get_named_dev(name) != NULL) {
172 "comp device with name %s already allocated!", name);
176 dev_id = rte_compressdev_find_free_device_index();
177 if (dev_id == RTE_COMPRESS_MAX_DEVS) {
178 COMPRESSDEV_LOG(ERR, "Reached maximum number of comp devices");
181 compressdev = rte_compressdev_get_dev(dev_id);
183 if (compressdev->data == NULL) {
184 struct rte_compressdev_data *compressdev_data =
185 compressdev_globals.data[dev_id];
187 int retval = rte_compressdev_data_alloc(dev_id,
188 &compressdev_data, socket_id);
190 if (retval < 0 || compressdev_data == NULL)
193 compressdev->data = compressdev_data;
195 snprintf(compressdev->data->name, RTE_COMPRESSDEV_NAME_MAX_LEN,
198 compressdev->data->dev_id = dev_id;
199 compressdev->data->socket_id = socket_id;
200 compressdev->data->dev_started = 0;
202 compressdev->attached = RTE_COMPRESSDEV_ATTACHED;
204 compressdev_globals.nb_devs++;
210 int __rte_experimental
211 rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
215 if (compressdev == NULL)
218 /* Close device only if device operations have been set */
219 if (compressdev->dev_ops) {
220 ret = rte_compressdev_close(compressdev->data->dev_id);
225 compressdev->attached = RTE_COMPRESSDEV_DETACHED;
226 compressdev_globals.nb_devs--;
230 uint16_t __rte_experimental
231 rte_compressdev_queue_pair_count(uint8_t dev_id)
233 struct rte_compressdev *dev;
235 dev = &rte_comp_devices[dev_id];
236 return dev->data->nb_queue_pairs;
240 rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
241 uint16_t nb_qpairs, int socket_id)
243 struct rte_compressdev_info dev_info;
247 if ((dev == NULL) || (nb_qpairs < 1)) {
248 COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",
253 COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",
254 nb_qpairs, dev->data->dev_id);
256 memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
258 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
259 (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
261 if ((dev_info.max_nb_queue_pairs != 0) &&
262 (nb_qpairs > dev_info.max_nb_queue_pairs)) {
263 COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",
264 nb_qpairs, dev->data->dev_id);
268 if (dev->data->queue_pairs == NULL) { /* first time configuration */
269 dev->data->queue_pairs = rte_zmalloc_socket(
270 "compressdev->queue_pairs",
271 sizeof(dev->data->queue_pairs[0]) * nb_qpairs,
272 RTE_CACHE_LINE_SIZE, socket_id);
274 if (dev->data->queue_pairs == NULL) {
275 dev->data->nb_queue_pairs = 0;
277 "failed to get memory for qp meta data, nb_queues %u",
281 } else { /* re-configure */
283 uint16_t old_nb_queues = dev->data->nb_queue_pairs;
285 qp = dev->data->queue_pairs;
287 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
290 for (i = nb_qpairs; i < old_nb_queues; i++) {
291 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
296 qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
297 RTE_CACHE_LINE_SIZE);
300 "failed to realloc qp meta data, nb_queues %u",
305 if (nb_qpairs > old_nb_queues) {
306 uint16_t new_qs = nb_qpairs - old_nb_queues;
308 memset(qp + old_nb_queues, 0,
309 sizeof(qp[0]) * new_qs);
312 dev->data->queue_pairs = qp;
315 dev->data->nb_queue_pairs = nb_qpairs;
320 rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
326 COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev);
330 num_qps = dev->data->nb_queue_pairs;
335 COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",
336 dev->data->nb_queue_pairs, dev->data->dev_id);
338 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
341 for (i = 0; i < num_qps; i++) {
342 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
347 if (dev->data->queue_pairs != NULL)
348 rte_free(dev->data->queue_pairs);
349 dev->data->queue_pairs = NULL;
350 dev->data->nb_queue_pairs = 0;
355 int __rte_experimental
356 rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
358 struct rte_compressdev *dev;
361 if (!rte_compressdev_is_valid_dev(dev_id)) {
362 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
366 dev = &rte_comp_devices[dev_id];
368 if (dev->data->dev_started) {
370 "device %d must be stopped to allow configuration", dev_id);
374 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
376 /* Setup new number of queue pairs and reconfigure device. */
377 diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
381 "dev%d rte_comp_dev_queue_pairs_config = %d",
386 return (*dev->dev_ops->dev_configure)(dev, config);
389 int __rte_experimental
390 rte_compressdev_start(uint8_t dev_id)
392 struct rte_compressdev *dev;
395 COMPRESSDEV_LOG(DEBUG, "Start dev_id=%" PRIu8, dev_id);
397 if (!rte_compressdev_is_valid_dev(dev_id)) {
398 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
402 dev = &rte_comp_devices[dev_id];
404 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP);
406 if (dev->data->dev_started != 0) {
408 "Device with dev_id=%" PRIu8 " already started", dev_id);
412 diag = (*dev->dev_ops->dev_start)(dev);
414 dev->data->dev_started = 1;
421 void __rte_experimental
422 rte_compressdev_stop(uint8_t dev_id)
424 struct rte_compressdev *dev;
426 if (!rte_compressdev_is_valid_dev(dev_id)) {
427 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
431 dev = &rte_comp_devices[dev_id];
433 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop);
435 if (dev->data->dev_started == 0) {
437 "Device with dev_id=%" PRIu8 " already stopped", dev_id);
441 (*dev->dev_ops->dev_stop)(dev);
442 dev->data->dev_started = 0;
445 int __rte_experimental
446 rte_compressdev_close(uint8_t dev_id)
448 struct rte_compressdev *dev;
451 if (!rte_compressdev_is_valid_dev(dev_id)) {
452 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
456 dev = &rte_comp_devices[dev_id];
458 /* Device must be stopped before it can be closed */
459 if (dev->data->dev_started == 1) {
460 COMPRESSDEV_LOG(ERR, "Device %u must be stopped before closing",
465 /* Free queue pairs memory */
466 retval = rte_compressdev_queue_pairs_release(dev);
471 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP);
472 retval = (*dev->dev_ops->dev_close)(dev);
480 int __rte_experimental
481 rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
482 uint32_t max_inflight_ops, int socket_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];
492 if (queue_pair_id >= dev->data->nb_queue_pairs) {
493 COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id);
497 if (dev->data->dev_started) {
499 "device %d must be stopped to allow configuration", dev_id);
503 if (max_inflight_ops == 0) {
505 "Invalid maximum number of inflight operations");
509 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP);
511 return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
512 max_inflight_ops, socket_id);
515 uint16_t __rte_experimental
516 rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
517 struct rte_comp_op **ops, uint16_t nb_ops)
519 struct rte_compressdev *dev = &rte_compressdevs[dev_id];
521 nb_ops = (*dev->dequeue_burst)
522 (dev->data->queue_pairs[qp_id], ops, nb_ops);
527 uint16_t __rte_experimental
528 rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
529 struct rte_comp_op **ops, uint16_t nb_ops)
531 struct rte_compressdev *dev = &rte_compressdevs[dev_id];
533 return (*dev->enqueue_burst)(
534 dev->data->queue_pairs[qp_id], ops, nb_ops);
537 void __rte_experimental
538 rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
540 struct rte_compressdev *dev;
542 if (dev_id >= compressdev_globals.nb_devs) {
543 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
547 dev = &rte_comp_devices[dev_id];
549 memset(dev_info, 0, sizeof(struct rte_compressdev_info));
551 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get);
552 (*dev->dev_ops->dev_infos_get)(dev, dev_info);
554 dev_info->driver_name = dev->device->driver->name;
557 int __rte_experimental
558 rte_compressdev_private_xform_create(uint8_t dev_id,
559 const struct rte_comp_xform *xform,
562 struct rte_compressdev *dev;
565 dev = rte_compressdev_get_dev(dev_id);
567 if (xform == NULL || priv_xform == NULL || dev == NULL)
570 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_create, -ENOTSUP);
571 ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
574 "dev_id %d failed to create private_xform: err=%d",
582 int __rte_experimental
583 rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
585 struct rte_compressdev *dev;
588 dev = rte_compressdev_get_dev(dev_id);
590 if (dev == NULL || priv_xform == NULL)
593 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_free, -ENOTSUP);
594 ret = dev->dev_ops->private_xform_free(dev, priv_xform);
597 "dev_id %d failed to free private xform: err=%d",
605 int __rte_experimental
606 rte_compressdev_stream_create(uint8_t dev_id,
607 const struct rte_comp_xform *xform,
610 struct rte_compressdev *dev;
613 dev = rte_compressdev_get_dev(dev_id);
615 if (xform == NULL || dev == NULL || stream == NULL)
618 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_create, -ENOTSUP);
619 ret = (*dev->dev_ops->stream_create)(dev, xform, stream);
622 "dev_id %d failed to create stream: err=%d",
631 int __rte_experimental
632 rte_compressdev_stream_free(uint8_t dev_id, void *stream)
634 struct rte_compressdev *dev;
637 dev = rte_compressdev_get_dev(dev_id);
639 if (dev == NULL || stream == NULL)
642 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_free, -ENOTSUP);
643 ret = dev->dev_ops->stream_free(dev, stream);
646 "dev_id %d failed to free stream: err=%d",
654 const char * __rte_experimental
655 rte_compressdev_name_get(uint8_t dev_id)
657 struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
662 return dev->data->name;
665 RTE_INIT(rte_compressdev_log);
668 rte_compressdev_log(void)
670 compressdev_logtype = rte_log_register("lib.compressdev");
671 if (compressdev_logtype >= 0)
672 rte_log_set_level(compressdev_logtype, RTE_LOG_NOTICE);