lib/librte_compressdev/rte_compressdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017-2018 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <stdarg.h>
   7 #include <stdio.h>
   8 #include <inttypes.h>
   9
  10 #include <rte_malloc.h>
  11 #include <rte_eal.h>
  12 #include <rte_memzone.h>
  13
  14 #include "rte_compressdev.h"
  15 #include "rte_compressdev_internal.h"
  16 #include "rte_compressdev_pmd.h"
  17
  18 #define RTE_COMPRESSDEV_DETACHED  (0)
  19 #define RTE_COMPRESSDEV_ATTACHED  (1)
  20
  21 struct rte_compressdev rte_comp_devices[RTE_COMPRESS_MAX_DEVS];
  22
  23 struct rte_compressdev *rte_compressdevs = &rte_comp_devices[0];
  24
  25 static struct rte_compressdev_global compressdev_globals = {
  26                 .devs                   = &rte_comp_devices[0],
  27                 .data                   = { NULL },
  28                 .nb_devs                = 0,
  29                 .max_devs               = RTE_COMPRESS_MAX_DEVS
  30 };
  31
  32 struct rte_compressdev_global *rte_compressdev_globals = &compressdev_globals;
  33
  34 const struct rte_compressdev_capabilities * __rte_experimental
  35 rte_compressdev_capability_get(uint8_t dev_id,
  36                         enum rte_comp_algorithm algo)
  37 {
  38         const struct rte_compressdev_capabilities *capability;
  39         struct rte_compressdev_info dev_info;
  40         int i = 0;
  41
  42         if (dev_id >= compressdev_globals.nb_devs) {
  43                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
  44                 return NULL;
  45         }
  46         rte_compressdev_info_get(dev_id, &dev_info);
  47
  48         while ((capability = &dev_info.capabilities[i++])->algo !=
  49                         RTE_COMP_ALGO_UNSPECIFIED){
  50                 if (capability->algo == algo)
  51                         return capability;
  52         }
  53
  54         return NULL;
  55 }
  56
  57 const char * __rte_experimental
  58 rte_compressdev_get_feature_name(uint64_t flag)
  59 {
  60         switch (flag) {
  61         case RTE_COMPDEV_FF_HW_ACCELERATED:
  62                 return "HW_ACCELERATED";
  63         case RTE_COMPDEV_FF_CPU_SSE:
  64                 return "CPU_SSE";
  65         case RTE_COMPDEV_FF_CPU_AVX:
  66                 return "CPU_AVX";
  67         case RTE_COMPDEV_FF_CPU_AVX2:
  68                 return "CPU_AVX2";
  69         case RTE_COMPDEV_FF_CPU_AVX512:
  70                 return "CPU_AVX512";
  71         case RTE_COMPDEV_FF_CPU_NEON:
  72                 return "CPU_NEON";
  73         default:
  74                 return NULL;
  75         }
  76 }
  77
  78 static struct rte_compressdev *
  79 rte_compressdev_get_dev(uint8_t dev_id)
  80 {
  81         return &rte_compressdev_globals->devs[dev_id];
  82 }
  83
  84 struct rte_compressdev * __rte_experimental
  85 rte_compressdev_pmd_get_named_dev(const char *name)
  86 {
  87         struct rte_compressdev *dev;
  88         unsigned int i;
  89
  90         if (name == NULL)
  91                 return NULL;
  92
  93         for (i = 0; i < rte_compressdev_globals->max_devs; i++) {
  94                 dev = &rte_compressdev_globals->devs[i];
  95
  96                 if ((dev->attached == RTE_COMPRESSDEV_ATTACHED) &&
  97                                 (strcmp(dev->data->name, name) == 0))
  98                         return dev;
  99         }
 100
 101         return NULL;
 102 }
 103
 104 static unsigned int
 105 rte_compressdev_is_valid_dev(uint8_t dev_id)
 106 {
 107         struct rte_compressdev *dev = NULL;
 108
 109         if (dev_id >= rte_compressdev_globals->nb_devs)
 110                 return 0;
 111
 112         dev = rte_compressdev_get_dev(dev_id);
 113         if (dev->attached != RTE_COMPRESSDEV_ATTACHED)
 114                 return 0;
 115         else
 116                 return 1;
 117 }
 118
 119
 120 uint8_t __rte_experimental
 121 rte_compressdev_count(void)
 122 {
 123         return rte_compressdev_globals->nb_devs;
 124 }
 125
 126 uint8_t __rte_experimental
 127 rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
 128         uint8_t nb_devices)
 129 {
 130         uint8_t i, count = 0;
 131         struct rte_compressdev *devs = rte_compressdev_globals->devs;
 132         uint8_t max_devs = rte_compressdev_globals->max_devs;
 133
 134         for (i = 0; i < max_devs && count < nb_devices; i++) {
 135
 136                 if (devs[i].attached == RTE_COMPRESSDEV_ATTACHED) {
 137                         int cmp;
 138
 139                         cmp = strncmp(devs[i].device->driver->name,
 140                                         driver_name,
 141                                         strlen(driver_name));
 142
 143                         if (cmp == 0)
 144                                 devices[count++] = devs[i].data->dev_id;
 145                 }
 146         }
 147
 148         return count;
 149 }
 150
 151 int __rte_experimental
 152 rte_compressdev_socket_id(uint8_t dev_id)
 153 {
 154         struct rte_compressdev *dev;
 155
 156         if (!rte_compressdev_is_valid_dev(dev_id))
 157                 return -1;
 158
 159         dev = rte_compressdev_get_dev(dev_id);
 160
 161         return dev->data->socket_id;
 162 }
 163
 164 static inline int
 165 rte_compressdev_data_alloc(uint8_t dev_id, struct rte_compressdev_data **data,
 166                 int socket_id)
 167 {
 168         char mz_name[RTE_COMPRESSDEV_NAME_MAX_LEN];
 169         const struct rte_memzone *mz;
 170         int n;
 171
 172         /* generate memzone name */
 173         n = snprintf(mz_name, sizeof(mz_name),
 174                         "rte_compressdev_data_%u", dev_id);
 175         if (n >= (int)sizeof(mz_name))
 176                 return -EINVAL;
 177
 178         if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
 179                 mz = rte_memzone_reserve(mz_name,
 180                                 sizeof(struct rte_compressdev_data),
 181                                 socket_id, 0);
 182         } else
 183                 mz = rte_memzone_lookup(mz_name);
 184
 185         if (mz == NULL)
 186                 return -ENOMEM;
 187
 188         *data = mz->addr;
 189         if (rte_eal_process_type() == RTE_PROC_PRIMARY)
 190                 memset(*data, 0, sizeof(struct rte_compressdev_data));
 191
 192         return 0;
 193 }
 194
 195 static uint8_t
 196 rte_compressdev_find_free_device_index(void)
 197 {
 198         uint8_t dev_id;
 199
 200         for (dev_id = 0; dev_id < RTE_COMPRESS_MAX_DEVS; dev_id++) {
 201                 if (rte_comp_devices[dev_id].attached ==
 202                                 RTE_COMPRESSDEV_DETACHED)
 203                         return dev_id;
 204         }
 205         return RTE_COMPRESS_MAX_DEVS;
 206 }
 207
 208 struct rte_compressdev * __rte_experimental
 209 rte_compressdev_pmd_allocate(const char *name, int socket_id)
 210 {
 211         struct rte_compressdev *compressdev;
 212         uint8_t dev_id;
 213
 214         if (rte_compressdev_pmd_get_named_dev(name) != NULL) {
 215                 COMPRESSDEV_LOG(ERR,
 216                         "comp device with name %s already allocated!", name);
 217                 return NULL;
 218         }
 219
 220         dev_id = rte_compressdev_find_free_device_index();
 221         if (dev_id == RTE_COMPRESS_MAX_DEVS) {
 222                 COMPRESSDEV_LOG(ERR, "Reached maximum number of comp devices");
 223                 return NULL;
 224         }
 225         compressdev = rte_compressdev_get_dev(dev_id);
 226
 227         if (compressdev->data == NULL) {
 228                 struct rte_compressdev_data *compressdev_data =
 229                                 compressdev_globals.data[dev_id];
 230
 231                 int retval = rte_compressdev_data_alloc(dev_id,
 232                                 &compressdev_data, socket_id);
 233
 234                 if (retval < 0 || compressdev_data == NULL)
 235                         return NULL;
 236
 237                 compressdev->data = compressdev_data;
 238
 239                 snprintf(compressdev->data->name, RTE_COMPRESSDEV_NAME_MAX_LEN,
 240                                 "%s", name);
 241
 242                 compressdev->data->dev_id = dev_id;
 243                 compressdev->data->socket_id = socket_id;
 244                 compressdev->data->dev_started = 0;
 245
 246                 compressdev->attached = RTE_COMPRESSDEV_ATTACHED;
 247
 248                 compressdev_globals.nb_devs++;
 249         }
 250
 251         return compressdev;
 252 }
 253
 254 int __rte_experimental
 255 rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
 256 {
 257         int ret;
 258
 259         if (compressdev == NULL)
 260                 return -EINVAL;
 261
 262         /* Close device only if device operations have been set */
 263         if (compressdev->dev_ops) {
 264                 ret = rte_compressdev_close(compressdev->data->dev_id);
 265                 if (ret < 0)
 266                         return ret;
 267         }
 268
 269         compressdev->attached = RTE_COMPRESSDEV_DETACHED;
 270         compressdev_globals.nb_devs--;
 271         return 0;
 272 }
 273
 274 uint16_t __rte_experimental
 275 rte_compressdev_queue_pair_count(uint8_t dev_id)
 276 {
 277         struct rte_compressdev *dev;
 278
 279         dev = &rte_comp_devices[dev_id];
 280         return dev->data->nb_queue_pairs;
 281 }
 282
 283 static int
 284 rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
 285                 uint16_t nb_qpairs, int socket_id)
 286 {
 287         struct rte_compressdev_info dev_info;
 288         void **qp;
 289         unsigned int i;
 290
 291         if ((dev == NULL) || (nb_qpairs < 1)) {
 292                 COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",
 293                                                         dev, nb_qpairs);
 294                 return -EINVAL;
 295         }
 296
 297         COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",
 298                         nb_qpairs, dev->data->dev_id);
 299
 300         memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
 301
 302         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
 303         (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
 304
 305         if ((dev_info.max_nb_queue_pairs != 0) &&
 306                         (nb_qpairs > dev_info.max_nb_queue_pairs)) {
 307                 COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",
 308                                 nb_qpairs, dev->data->dev_id);
 309                 return -EINVAL;
 310         }
 311
 312         if (dev->data->queue_pairs == NULL) { /* first time configuration */
 313                 dev->data->queue_pairs = rte_zmalloc_socket(
 314                                 "compressdev->queue_pairs",
 315                                 sizeof(dev->data->queue_pairs[0]) * nb_qpairs,
 316                                 RTE_CACHE_LINE_SIZE, socket_id);
 317
 318                 if (dev->data->queue_pairs == NULL) {
 319                         dev->data->nb_queue_pairs = 0;
 320                         COMPRESSDEV_LOG(ERR,
 321                         "failed to get memory for qp meta data, nb_queues %u",
 322                                                         nb_qpairs);
 323                         return -(ENOMEM);
 324                 }
 325         } else { /* re-configure */
 326                 int ret;
 327                 uint16_t old_nb_queues = dev->data->nb_queue_pairs;
 328
 329                 qp = dev->data->queue_pairs;
 330
 331                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
 332                                 -ENOTSUP);
 333
 334                 for (i = nb_qpairs; i < old_nb_queues; i++) {
 335                         ret = (*dev->dev_ops->queue_pair_release)(dev, i);
 336                         if (ret < 0)
 337                                 return ret;
 338                 }
 339
 340                 qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
 341                                 RTE_CACHE_LINE_SIZE);
 342                 if (qp == NULL) {
 343                         COMPRESSDEV_LOG(ERR,
 344                         "failed to realloc qp meta data, nb_queues %u",
 345                                                 nb_qpairs);
 346                         return -(ENOMEM);
 347                 }
 348
 349                 if (nb_qpairs > old_nb_queues) {
 350                         uint16_t new_qs = nb_qpairs - old_nb_queues;
 351
 352                         memset(qp + old_nb_queues, 0,
 353                                 sizeof(qp[0]) * new_qs);
 354                 }
 355
 356                 dev->data->queue_pairs = qp;
 357
 358         }
 359         dev->data->nb_queue_pairs = nb_qpairs;
 360         return 0;
 361 }
 362
 363 static int
 364 rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
 365 {
 366         uint16_t num_qps, i;
 367         int ret;
 368
 369         if (dev == NULL) {
 370                 COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev);
 371                 return -EINVAL;
 372         }
 373
 374         num_qps = dev->data->nb_queue_pairs;
 375
 376         if (num_qps == 0)
 377                 return 0;
 378
 379         COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",
 380                         dev->data->nb_queue_pairs, dev->data->dev_id);
 381
 382         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,
 383                                 -ENOTSUP);
 384
 385         for (i = 0; i < num_qps; i++) {
 386                 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
 387                 if (ret < 0)
 388                         return ret;
 389         }
 390
 391         if (dev->data->queue_pairs != NULL)
 392                 rte_free(dev->data->queue_pairs);
 393         dev->data->queue_pairs = NULL;
 394         dev->data->nb_queue_pairs = 0;
 395
 396         return 0;
 397 }
 398
 399 int __rte_experimental
 400 rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
 401 {
 402         struct rte_compressdev *dev;
 403         int diag;
 404
 405         if (!rte_compressdev_is_valid_dev(dev_id)) {
 406                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 407                 return -EINVAL;
 408         }
 409
 410         dev = &rte_comp_devices[dev_id];
 411
 412         if (dev->data->dev_started) {
 413                 COMPRESSDEV_LOG(ERR,
 414                     "device %d must be stopped to allow configuration", dev_id);
 415                 return -EBUSY;
 416         }
 417
 418         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
 419
 420         /* Setup new number of queue pairs and reconfigure device. */
 421         diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
 422                         config->socket_id);
 423         if (diag != 0) {
 424                 COMPRESSDEV_LOG(ERR,
 425                         "dev%d rte_comp_dev_queue_pairs_config = %d",
 426                                 dev_id, diag);
 427                 return diag;
 428         }
 429
 430         return (*dev->dev_ops->dev_configure)(dev, config);
 431 }
 432
 433 int __rte_experimental
 434 rte_compressdev_start(uint8_t dev_id)
 435 {
 436         struct rte_compressdev *dev;
 437         int diag;
 438
 439         COMPRESSDEV_LOG(DEBUG, "Start dev_id=%" PRIu8, dev_id);
 440
 441         if (!rte_compressdev_is_valid_dev(dev_id)) {
 442                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 443                 return -EINVAL;
 444         }
 445
 446         dev = &rte_comp_devices[dev_id];
 447
 448         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP);
 449
 450         if (dev->data->dev_started != 0) {
 451                 COMPRESSDEV_LOG(ERR,
 452                     "Device with dev_id=%" PRIu8 " already started", dev_id);
 453                 return 0;
 454         }
 455
 456         diag = (*dev->dev_ops->dev_start)(dev);
 457         if (diag == 0)
 458                 dev->data->dev_started = 1;
 459         else
 460                 return diag;
 461
 462         return 0;
 463 }
 464
 465 void __rte_experimental
 466 rte_compressdev_stop(uint8_t dev_id)
 467 {
 468         struct rte_compressdev *dev;
 469
 470         if (!rte_compressdev_is_valid_dev(dev_id)) {
 471                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 472                 return;
 473         }
 474
 475         dev = &rte_comp_devices[dev_id];
 476
 477         RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop);
 478
 479         if (dev->data->dev_started == 0) {
 480                 COMPRESSDEV_LOG(ERR,
 481                     "Device with dev_id=%" PRIu8 " already stopped", dev_id);
 482                 return;
 483         }
 484
 485         (*dev->dev_ops->dev_stop)(dev);
 486         dev->data->dev_started = 0;
 487 }
 488
 489 int __rte_experimental
 490 rte_compressdev_close(uint8_t dev_id)
 491 {
 492         struct rte_compressdev *dev;
 493         int retval;
 494
 495         if (!rte_compressdev_is_valid_dev(dev_id)) {
 496                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 497                 return -1;
 498         }
 499
 500         dev = &rte_comp_devices[dev_id];
 501
 502         /* Device must be stopped before it can be closed */
 503         if (dev->data->dev_started == 1) {
 504                 COMPRESSDEV_LOG(ERR, "Device %u must be stopped before closing",
 505                                 dev_id);
 506                 return -EBUSY;
 507         }
 508
 509         /* Free queue pairs memory */
 510         retval = rte_compressdev_queue_pairs_release(dev);
 511
 512         if (retval < 0)
 513                 return retval;
 514
 515         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP);
 516         retval = (*dev->dev_ops->dev_close)(dev);
 517
 518         if (retval < 0)
 519                 return retval;
 520
 521         return 0;
 522 }
 523
 524 int __rte_experimental
 525 rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
 526                 uint32_t max_inflight_ops, int socket_id)
 527 {
 528         struct rte_compressdev *dev;
 529
 530         if (!rte_compressdev_is_valid_dev(dev_id)) {
 531                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 532                 return -EINVAL;
 533         }
 534
 535         dev = &rte_comp_devices[dev_id];
 536         if (queue_pair_id >= dev->data->nb_queue_pairs) {
 537                 COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id);
 538                 return -EINVAL;
 539         }
 540
 541         if (dev->data->dev_started) {
 542                 COMPRESSDEV_LOG(ERR,
 543                     "device %d must be stopped to allow configuration", dev_id);
 544                 return -EBUSY;
 545         }
 546
 547         if (max_inflight_ops == 0) {
 548                 COMPRESSDEV_LOG(ERR,
 549                         "Invalid maximum number of inflight operations");
 550                 return -EINVAL;
 551         }
 552
 553         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP);
 554
 555         return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
 556                         max_inflight_ops, socket_id);
 557 }
 558
 559 uint16_t __rte_experimental
 560 rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
 561                 struct rte_comp_op **ops, uint16_t nb_ops)
 562 {
 563         struct rte_compressdev *dev = &rte_compressdevs[dev_id];
 564
 565         nb_ops = (*dev->dequeue_burst)
 566                         (dev->data->queue_pairs[qp_id], ops, nb_ops);
 567
 568         return nb_ops;
 569 }
 570
 571 uint16_t __rte_experimental
 572 rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
 573                 struct rte_comp_op **ops, uint16_t nb_ops)
 574 {
 575         struct rte_compressdev *dev = &rte_compressdevs[dev_id];
 576
 577         return (*dev->enqueue_burst)(
 578                         dev->data->queue_pairs[qp_id], ops, nb_ops);
 579 }
 580
 581 int __rte_experimental
 582 rte_compressdev_stats_get(uint8_t dev_id, struct rte_compressdev_stats *stats)
 583 {
 584         struct rte_compressdev *dev;
 585
 586         if (!rte_compressdev_is_valid_dev(dev_id)) {
 587                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
 588                 return -ENODEV;
 589         }
 590
 591         if (stats == NULL) {
 592                 COMPRESSDEV_LOG(ERR, "Invalid stats ptr");
 593                 return -EINVAL;
 594         }
 595
 596         dev = &rte_comp_devices[dev_id];
 597         memset(stats, 0, sizeof(*stats));
 598
 599         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stats_get, -ENOTSUP);
 600         (*dev->dev_ops->stats_get)(dev, stats);
 601         return 0;
 602 }
 603
 604 void __rte_experimental
 605 rte_compressdev_stats_reset(uint8_t dev_id)
 606 {
 607         struct rte_compressdev *dev;
 608
 609         if (!rte_compressdev_is_valid_dev(dev_id)) {
 610                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id);
 611                 return;
 612         }
 613
 614         dev = &rte_comp_devices[dev_id];
 615
 616         RTE_FUNC_PTR_OR_RET(*dev->dev_ops->stats_reset);
 617         (*dev->dev_ops->stats_reset)(dev);
 618 }
 619
 620
 621 void __rte_experimental
 622 rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
 623 {
 624         struct rte_compressdev *dev;
 625
 626         if (dev_id >= compressdev_globals.nb_devs) {
 627                 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id);
 628                 return;
 629         }
 630
 631         dev = &rte_comp_devices[dev_id];
 632
 633         memset(dev_info, 0, sizeof(struct rte_compressdev_info));
 634
 635         RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get);
 636         (*dev->dev_ops->dev_infos_get)(dev, dev_info);
 637
 638         dev_info->driver_name = dev->device->driver->name;
 639 }
 640
 641 int __rte_experimental
 642 rte_compressdev_private_xform_create(uint8_t dev_id,
 643                 const struct rte_comp_xform *xform,
 644                 void **priv_xform)
 645 {
 646         struct rte_compressdev *dev;
 647         int ret;
 648
 649         dev = rte_compressdev_get_dev(dev_id);
 650
 651         if (xform == NULL || priv_xform == NULL || dev == NULL)
 652                 return -EINVAL;
 653
 654         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_create, -ENOTSUP);
 655         ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
 656         if (ret < 0) {
 657                 COMPRESSDEV_LOG(ERR,
 658                         "dev_id %d failed to create private_xform: err=%d",
 659                         dev_id, ret);
 660                 return ret;
 661         };
 662
 663         return 0;
 664 }
 665
 666 int __rte_experimental
 667 rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
 668 {
 669         struct rte_compressdev *dev;
 670         int ret;
 671
 672         dev = rte_compressdev_get_dev(dev_id);
 673
 674         if (dev == NULL || priv_xform == NULL)
 675                 return -EINVAL;
 676
 677         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_free, -ENOTSUP);
 678         ret = dev->dev_ops->private_xform_free(dev, priv_xform);
 679         if (ret < 0) {
 680                 COMPRESSDEV_LOG(ERR,
 681                         "dev_id %d failed to free private xform: err=%d",
 682                         dev_id, ret);
 683                 return ret;
 684         };
 685
 686         return 0;
 687 }
 688
 689 int __rte_experimental
 690 rte_compressdev_stream_create(uint8_t dev_id,
 691                 const struct rte_comp_xform *xform,
 692                 void **stream)
 693 {
 694         struct rte_compressdev *dev;
 695         int ret;
 696
 697         dev = rte_compressdev_get_dev(dev_id);
 698
 699         if (xform == NULL || dev == NULL || stream == NULL)
 700                 return -EINVAL;
 701
 702         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_create, -ENOTSUP);
 703         ret = (*dev->dev_ops->stream_create)(dev, xform, stream);
 704         if (ret < 0) {
 705                 COMPRESSDEV_LOG(ERR,
 706                         "dev_id %d failed to create stream: err=%d",
 707                         dev_id, ret);
 708                 return ret;
 709         };
 710
 711         return 0;
 712 }
 713
 714
 715 int __rte_experimental
 716 rte_compressdev_stream_free(uint8_t dev_id, void *stream)
 717 {
 718         struct rte_compressdev *dev;
 719         int ret;
 720
 721         dev = rte_compressdev_get_dev(dev_id);
 722
 723         if (dev == NULL || stream == NULL)
 724                 return -EINVAL;
 725
 726         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_free, -ENOTSUP);
 727         ret = dev->dev_ops->stream_free(dev, stream);
 728         if (ret < 0) {
 729                 COMPRESSDEV_LOG(ERR,
 730                         "dev_id %d failed to free stream: err=%d",
 731                         dev_id, ret);
 732                 return ret;
 733         };
 734
 735         return 0;
 736 }
 737
 738 const char * __rte_experimental
 739 rte_compressdev_name_get(uint8_t dev_id)
 740 {
 741         struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
 742
 743         if (dev == NULL)
 744                 return NULL;
 745
 746         return dev->data->name;
 747 }
 748
 749 RTE_INIT(rte_compressdev_log);
 750
 751 static void
 752 rte_compressdev_log(void)
 753 {
 754         compressdev_logtype = rte_log_register("lib.compressdev");
 755         if (compressdev_logtype >= 0)
 756                 rte_log_set_level(compressdev_logtype, RTE_LOG_NOTICE);
 757 }