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 } 769