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