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