1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 Intel Corporation 3 */ 4 #include <isa-l.h> 5 6 #include <rte_bus_vdev.h> 7 #include <rte_common.h> 8 #include <rte_malloc.h> 9 #include <rte_mbuf.h> 10 #include <rte_compressdev_pmd.h> 11 12 #include "isal_compress_pmd_private.h" 13 14 #define RTE_COMP_ISAL_WINDOW_SIZE 15 15 #define RTE_COMP_ISAL_LEVEL_ZERO 0 /* ISA-L Level 0 used for fixed Huffman */ 16 #define RTE_COMP_ISAL_LEVEL_ONE 1 17 #define RTE_COMP_ISAL_LEVEL_TWO 2 18 #define RTE_COMP_ISAL_LEVEL_THREE 3 /* Optimised for AVX512 & AVX2 only */ 19 20 int isal_logtype_driver; 21 22 /* Verify and set private xform parameters */ 23 int 24 isal_comp_set_priv_xform_parameters(struct isal_priv_xform *priv_xform, 25 const struct rte_comp_xform *xform) 26 { 27 if (xform == NULL) 28 return -EINVAL; 29 30 /* Set compression private xform variables */ 31 if (xform->type == RTE_COMP_COMPRESS) { 32 /* Set private xform type - COMPRESS/DECOMPRESS */ 33 priv_xform->type = RTE_COMP_COMPRESS; 34 35 /* Set private xform algorithm */ 36 if (xform->compress.algo != RTE_COMP_ALGO_DEFLATE) { 37 if (xform->compress.algo == RTE_COMP_ALGO_NULL) { 38 ISAL_PMD_LOG(ERR, "By-pass not supported\n"); 39 return -ENOTSUP; 40 } 41 ISAL_PMD_LOG(ERR, "Algorithm not supported\n"); 42 return -ENOTSUP; 43 } 44 priv_xform->compress.algo = RTE_COMP_ALGO_DEFLATE; 45 46 /* Set private xform checksum - raw deflate by default */ 47 if (xform->compress.chksum != RTE_COMP_CHECKSUM_NONE) { 48 ISAL_PMD_LOG(ERR, "Checksum not supported\n"); 49 return -ENOTSUP; 50 } 51 52 /* Set private xform window size, 32K supported */ 53 if (xform->compress.window_size == RTE_COMP_ISAL_WINDOW_SIZE) 54 priv_xform->compress.window_size = 55 RTE_COMP_ISAL_WINDOW_SIZE; 56 else { 57 ISAL_PMD_LOG(ERR, "Window size not supported\n"); 58 return -ENOTSUP; 59 } 60 61 /* Set private xform huffman type */ 62 switch (xform->compress.deflate.huffman) { 63 case(RTE_COMP_HUFFMAN_DEFAULT): 64 priv_xform->compress.deflate.huffman = 65 RTE_COMP_HUFFMAN_DEFAULT; 66 break; 67 case(RTE_COMP_HUFFMAN_FIXED): 68 priv_xform->compress.deflate.huffman = 69 RTE_COMP_HUFFMAN_FIXED; 70 break; 71 case(RTE_COMP_HUFFMAN_DYNAMIC): 72 priv_xform->compress.deflate.huffman = 73 RTE_COMP_HUFFMAN_DYNAMIC; 74 break; 75 default: 76 ISAL_PMD_LOG(ERR, "Huffman code not supported\n"); 77 return -ENOTSUP; 78 } 79 80 /* Set private xform level. 81 * Checking compliance with compressdev API, -1 <= level => 9 82 */ 83 if (xform->compress.level < RTE_COMP_LEVEL_PMD_DEFAULT || 84 xform->compress.level > RTE_COMP_LEVEL_MAX) { 85 ISAL_PMD_LOG(ERR, "Compression level out of range\n"); 86 return -EINVAL; 87 } 88 /* Check for Compressdev API level 0, No compression 89 * not supported in ISA-L 90 */ 91 else if (xform->compress.level == RTE_COMP_LEVEL_NONE) { 92 ISAL_PMD_LOG(ERR, "No Compression not supported\n"); 93 return -ENOTSUP; 94 } 95 /* If using fixed huffman code, level must be 0 */ 96 else if (priv_xform->compress.deflate.huffman == 97 RTE_COMP_HUFFMAN_FIXED) { 98 ISAL_PMD_LOG(DEBUG, "ISA-L level 0 used due to a" 99 " fixed huffman code\n"); 100 priv_xform->compress.level = RTE_COMP_ISAL_LEVEL_ZERO; 101 priv_xform->level_buffer_size = 102 ISAL_DEF_LVL0_DEFAULT; 103 } else { 104 /* Mapping API levels to ISA-L levels 1,2 & 3 */ 105 switch (xform->compress.level) { 106 case RTE_COMP_LEVEL_PMD_DEFAULT: 107 /* Default is 1 if not using fixed huffman */ 108 priv_xform->compress.level = 109 RTE_COMP_ISAL_LEVEL_ONE; 110 priv_xform->level_buffer_size = 111 ISAL_DEF_LVL1_DEFAULT; 112 break; 113 case RTE_COMP_LEVEL_MIN: 114 priv_xform->compress.level = 115 RTE_COMP_ISAL_LEVEL_ONE; 116 priv_xform->level_buffer_size = 117 ISAL_DEF_LVL1_DEFAULT; 118 break; 119 case RTE_COMP_ISAL_LEVEL_TWO: 120 priv_xform->compress.level = 121 RTE_COMP_ISAL_LEVEL_TWO; 122 priv_xform->level_buffer_size = 123 ISAL_DEF_LVL2_DEFAULT; 124 break; 125 /* Level 3 or higher requested */ 126 default: 127 /* Check for AVX512, to use ISA-L level 3 */ 128 if (rte_cpu_get_flag_enabled( 129 RTE_CPUFLAG_AVX512F)) { 130 priv_xform->compress.level = 131 RTE_COMP_ISAL_LEVEL_THREE; 132 priv_xform->level_buffer_size = 133 ISAL_DEF_LVL3_DEFAULT; 134 } 135 /* Check for AVX2, to use ISA-L level 3 */ 136 else if (rte_cpu_get_flag_enabled( 137 RTE_CPUFLAG_AVX2)) { 138 priv_xform->compress.level = 139 RTE_COMP_ISAL_LEVEL_THREE; 140 priv_xform->level_buffer_size = 141 ISAL_DEF_LVL3_DEFAULT; 142 } else { 143 ISAL_PMD_LOG(DEBUG, "Requested ISA-L level" 144 " 3 or above; Level 3 optimized" 145 " for AVX512 & AVX2 only." 146 " level changed to 2.\n"); 147 priv_xform->compress.level = 148 RTE_COMP_ISAL_LEVEL_TWO; 149 priv_xform->level_buffer_size = 150 ISAL_DEF_LVL2_DEFAULT; 151 } 152 } 153 } 154 } 155 156 /* Set decompression private xform variables */ 157 else if (xform->type == RTE_COMP_DECOMPRESS) { 158 159 /* Set private xform type - COMPRESS/DECOMPRESS */ 160 priv_xform->type = RTE_COMP_DECOMPRESS; 161 162 /* Set private xform algorithm */ 163 if (xform->decompress.algo != RTE_COMP_ALGO_DEFLATE) { 164 if (xform->decompress.algo == RTE_COMP_ALGO_NULL) { 165 ISAL_PMD_LOG(ERR, "By pass not supported\n"); 166 return -ENOTSUP; 167 } 168 ISAL_PMD_LOG(ERR, "Algorithm not supported\n"); 169 return -ENOTSUP; 170 } 171 priv_xform->decompress.algo = RTE_COMP_ALGO_DEFLATE; 172 173 /* Set private xform checksum - raw deflate by default */ 174 if (xform->compress.chksum != RTE_COMP_CHECKSUM_NONE) { 175 ISAL_PMD_LOG(ERR, "Checksum not supported\n"); 176 return -ENOTSUP; 177 } 178 179 /* Set private xform window size, 32K supported */ 180 if (xform->decompress.window_size == RTE_COMP_ISAL_WINDOW_SIZE) 181 priv_xform->decompress.window_size = 182 RTE_COMP_ISAL_WINDOW_SIZE; 183 else { 184 ISAL_PMD_LOG(ERR, "Window size not supported\n"); 185 return -ENOTSUP; 186 } 187 } 188 return 0; 189 } 190 191 /* Compression using chained mbufs for input/output data */ 192 static int 193 chained_mbuf_compression(struct rte_comp_op *op, struct isal_comp_qp *qp) 194 { 195 int ret; 196 uint32_t remaining_offset; 197 uint32_t remaining_data = op->src.length; 198 struct rte_mbuf *src = op->m_src; 199 struct rte_mbuf *dst = op->m_dst; 200 201 /* check for source/destination offset passing multiple segments 202 * and point compression stream to input/output buffer. 203 */ 204 remaining_offset = op->src.offset; 205 while (remaining_offset >= src->data_len) { 206 remaining_offset -= src->data_len; 207 src = src->next; 208 } 209 qp->stream->avail_in = RTE_MIN(src->data_len - remaining_offset, 210 op->src.length); 211 qp->stream->next_in = rte_pktmbuf_mtod_offset(src, uint8_t *, 212 remaining_offset); 213 214 remaining_offset = op->dst.offset; 215 while (remaining_offset >= dst->data_len) { 216 remaining_offset -= dst->data_len; 217 dst = dst->next; 218 } 219 qp->stream->avail_out = dst->data_len - remaining_offset; 220 qp->stream->next_out = rte_pktmbuf_mtod_offset(dst, uint8_t *, 221 remaining_offset); 222 223 if (unlikely(!qp->stream->next_in || !qp->stream->next_out)) { 224 ISAL_PMD_LOG(ERR, "Invalid source or destination buffer\n"); 225 op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; 226 return -1; 227 } 228 229 while (qp->stream->internal_state.state != ZSTATE_END) { 230 /* Last segment of data */ 231 if (remaining_data <= src->data_len) 232 qp->stream->end_of_stream = 1; 233 234 /* Execute compression operation */ 235 ret = isal_deflate(qp->stream); 236 237 remaining_data = op->src.length - qp->stream->total_in; 238 239 if (ret != COMP_OK) { 240 ISAL_PMD_LOG(ERR, "Compression operation failed\n"); 241 op->status = RTE_COMP_OP_STATUS_ERROR; 242 return ret; 243 } 244 245 if (qp->stream->avail_in == 0 && 246 qp->stream->total_in != op->src.length) { 247 if (src->next != NULL) { 248 src = src->next; 249 qp->stream->next_in = 250 rte_pktmbuf_mtod(src, uint8_t *); 251 qp->stream->avail_in = 252 RTE_MIN(remaining_data, src->data_len); 253 } else { 254 ISAL_PMD_LOG(ERR, 255 "Not enough input buffer segments\n"); 256 op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; 257 return -1; 258 } 259 } 260 261 if (qp->stream->avail_out == 0 && 262 qp->stream->internal_state.state != ZSTATE_END) { 263 if (dst->next != NULL) { 264 dst = dst->next; 265 qp->stream->next_out = 266 rte_pktmbuf_mtod(dst, uint8_t *); 267 qp->stream->avail_out = dst->data_len; 268 } else { 269 ISAL_PMD_LOG(ERR, 270 "Not enough output buffer segments\n"); 271 op->status = 272 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED; 273 return -1; 274 } 275 } 276 } 277 278 return 0; 279 } 280 281 /* Decompression using chained mbufs for input/output data */ 282 static int 283 chained_mbuf_decompression(struct rte_comp_op *op, struct isal_comp_qp *qp) 284 { 285 int ret; 286 uint32_t consumed_data, src_remaining_offset, dst_remaining_offset; 287 uint32_t remaining_data = op->src.length; 288 struct rte_mbuf *src = op->m_src; 289 struct rte_mbuf *dst = op->m_dst; 290 291 /* check for offset passing multiple segments 292 * and point decompression state to input/output buffer 293 */ 294 src_remaining_offset = op->src.offset; 295 while (src_remaining_offset >= src->data_len) { 296 src_remaining_offset -= src->data_len; 297 src = src->next; 298 } 299 qp->state->avail_in = RTE_MIN(src->data_len - src_remaining_offset, 300 op->src.length); 301 qp->state->next_in = rte_pktmbuf_mtod_offset(src, uint8_t *, 302 src_remaining_offset); 303 304 dst_remaining_offset = op->dst.offset; 305 while (dst_remaining_offset >= dst->data_len) { 306 dst_remaining_offset -= dst->data_len; 307 dst = dst->next; 308 } 309 qp->state->avail_out = dst->data_len - dst_remaining_offset; 310 qp->state->next_out = rte_pktmbuf_mtod_offset(dst, uint8_t *, 311 dst_remaining_offset); 312 313 while (qp->state->block_state != ISAL_BLOCK_FINISH) { 314 315 ret = isal_inflate(qp->state); 316 317 if (ret != ISAL_DECOMP_OK) { 318 ISAL_PMD_LOG(ERR, "Decompression operation failed\n"); 319 op->status = RTE_COMP_OP_STATUS_ERROR; 320 return ret; 321 } 322 323 /* Check for first segment, offset needs to be accounted for */ 324 if (remaining_data == op->src.length) { 325 consumed_data = src->data_len - src_remaining_offset; 326 } else 327 consumed_data = src->data_len; 328 329 if (qp->state->avail_in == 0 330 && op->consumed != op->src.length) { 331 op->consumed += consumed_data; 332 remaining_data -= consumed_data; 333 334 if (src->next != NULL) { 335 src = src->next; 336 qp->state->next_in = 337 rte_pktmbuf_mtod(src, uint8_t *); 338 qp->state->avail_in = 339 RTE_MIN(remaining_data, src->data_len); 340 } 341 } 342 343 if (qp->state->avail_out == 0 && 344 qp->state->block_state != ISAL_BLOCK_FINISH) { 345 if (dst->next != NULL) { 346 dst = dst->next; 347 qp->state->next_out = 348 rte_pktmbuf_mtod(dst, uint8_t *); 349 qp->state->avail_out = dst->data_len; 350 } else { 351 ISAL_PMD_LOG(ERR, 352 "Not enough output buffer segments\n"); 353 op->status = 354 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED; 355 return -1; 356 } 357 } 358 } 359 360 return 0; 361 } 362 363 /* Stateless Compression Function */ 364 static int 365 process_isal_deflate(struct rte_comp_op *op, struct isal_comp_qp *qp, 366 struct isal_priv_xform *priv_xform) 367 { 368 int ret = 0; 369 op->status = RTE_COMP_OP_STATUS_SUCCESS; 370 371 /* Required due to init clearing level_buf */ 372 uint8_t *temp_level_buf = qp->stream->level_buf; 373 374 /* Initialize compression stream */ 375 isal_deflate_stateless_init(qp->stream); 376 377 qp->stream->level_buf = temp_level_buf; 378 379 /* Stateless operation, input will be consumed in one go */ 380 qp->stream->flush = NO_FLUSH; 381 382 /* set compression level & intermediate level buffer size */ 383 qp->stream->level = priv_xform->compress.level; 384 qp->stream->level_buf_size = priv_xform->level_buffer_size; 385 386 /* Set op huffman code */ 387 if (priv_xform->compress.deflate.huffman == RTE_COMP_HUFFMAN_FIXED) 388 isal_deflate_set_hufftables(qp->stream, NULL, 389 IGZIP_HUFFTABLE_STATIC); 390 else if (priv_xform->compress.deflate.huffman == 391 RTE_COMP_HUFFMAN_DEFAULT) 392 isal_deflate_set_hufftables(qp->stream, NULL, 393 IGZIP_HUFFTABLE_DEFAULT); 394 /* Dynamically change the huffman code to suit the input data */ 395 else if (priv_xform->compress.deflate.huffman == 396 RTE_COMP_HUFFMAN_DYNAMIC) 397 isal_deflate_set_hufftables(qp->stream, NULL, 398 IGZIP_HUFFTABLE_DEFAULT); 399 400 if (op->m_src->pkt_len < (op->src.length + op->src.offset)) { 401 ISAL_PMD_LOG(ERR, "Input mbuf(s) not big enough.\n"); 402 op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; 403 return -1; 404 } 405 406 if (op->dst.offset >= op->m_dst->pkt_len) { 407 ISAL_PMD_LOG(ERR, "Output mbuf(s) not big enough" 408 " for offset provided.\n"); 409 op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; 410 return -1; 411 } 412 413 /* Chained mbufs */ 414 if (op->m_src->nb_segs > 1 || op->m_dst->nb_segs > 1) { 415 ret = chained_mbuf_compression(op, qp); 416 if (ret < 0) 417 return ret; 418 } else { 419 /* Linear buffer */ 420 qp->stream->end_of_stream = 1; /* All input consumed in one */ 421 /* Point compression stream to input buffer */ 422 qp->stream->avail_in = op->src.length; 423 qp->stream->next_in = rte_pktmbuf_mtod_offset(op->m_src, 424 uint8_t *, op->src.offset); 425 426 /* Point compression stream to output buffer */ 427 qp->stream->avail_out = op->m_dst->data_len - op->dst.offset; 428 qp->stream->next_out = rte_pktmbuf_mtod_offset(op->m_dst, 429 uint8_t *, op->dst.offset); 430 431 if (unlikely(!qp->stream->next_in || !qp->stream->next_out)) { 432 ISAL_PMD_LOG(ERR, "Invalid source or destination" 433 " buffers\n"); 434 op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; 435 return -1; 436 } 437 438 /* Execute compression operation */ 439 ret = isal_deflate_stateless(qp->stream); 440 441 /* Check that output buffer did not run out of space */ 442 if (ret == STATELESS_OVERFLOW) { 443 ISAL_PMD_LOG(ERR, "Output buffer not big enough\n"); 444 op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED; 445 return ret; 446 } 447 448 /* Check that input buffer has been fully consumed */ 449 if (qp->stream->avail_in != (uint32_t)0) { 450 ISAL_PMD_LOG(ERR, "Input buffer could not be read" 451 " entirely\n"); 452 op->status = RTE_COMP_OP_STATUS_ERROR; 453 return -1; 454 } 455 456 if (ret != COMP_OK) { 457 ISAL_PMD_LOG(ERR, "Compression operation failed\n"); 458 op->status = RTE_COMP_OP_STATUS_ERROR; 459 return ret; 460 } 461 } 462 op->consumed = qp->stream->total_in; 463 op->produced = qp->stream->total_out; 464 isal_deflate_reset(qp->stream); 465 466 return ret; 467 } 468 469 /* Stateless Decompression Function */ 470 static int 471 process_isal_inflate(struct rte_comp_op *op, struct isal_comp_qp *qp) 472 { 473 int ret = 0; 474 475 op->status = RTE_COMP_OP_STATUS_SUCCESS; 476 477 /* Initialize decompression state */ 478 isal_inflate_init(qp->state); 479 480 if (op->m_src->pkt_len < (op->src.length + op->src.offset)) { 481 ISAL_PMD_LOG(ERR, "Input mbuf(s) not big enough.\n"); 482 op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; 483 return -1; 484 } 485 486 if (op->dst.offset >= op->m_dst->pkt_len) { 487 ISAL_PMD_LOG(ERR, "Output mbuf not big enough for " 488 "offset provided.\n"); 489 op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; 490 return -1; 491 } 492 493 /* Chained mbufs */ 494 if (op->m_src->nb_segs > 1 || op->m_dst->nb_segs > 1) { 495 ret = chained_mbuf_decompression(op, qp); 496 if (ret != 0) 497 return ret; 498 } else { 499 /* Linear buffer */ 500 /* Point decompression state to input buffer */ 501 qp->state->avail_in = op->src.length; 502 qp->state->next_in = rte_pktmbuf_mtod_offset(op->m_src, 503 uint8_t *, op->src.offset); 504 505 /* Point decompression state to output buffer */ 506 qp->state->avail_out = op->m_dst->data_len - op->dst.offset; 507 qp->state->next_out = rte_pktmbuf_mtod_offset(op->m_dst, 508 uint8_t *, op->dst.offset); 509 510 if (unlikely(!qp->state->next_in || !qp->state->next_out)) { 511 ISAL_PMD_LOG(ERR, "Invalid source or destination" 512 " buffers\n"); 513 op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; 514 return -1; 515 } 516 517 /* Execute decompression operation */ 518 ret = isal_inflate_stateless(qp->state); 519 520 if (ret == ISAL_OUT_OVERFLOW) { 521 ISAL_PMD_LOG(ERR, "Output buffer not big enough\n"); 522 op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED; 523 return ret; 524 } 525 526 /* Check that input buffer has been fully consumed */ 527 if (qp->state->avail_in != (uint32_t)0) { 528 ISAL_PMD_LOG(ERR, "Input buffer could not be read" 529 " entirely\n"); 530 op->status = RTE_COMP_OP_STATUS_ERROR; 531 return -1; 532 } 533 534 if (ret != ISAL_DECOMP_OK) { 535 op->status = RTE_COMP_OP_STATUS_ERROR; 536 return ret; 537 } 538 op->consumed = op->src.length - qp->state->avail_in; 539 } 540 op->produced = qp->state->total_out; 541 isal_inflate_reset(qp->state); 542 543 return ret; 544 } 545 546 /* Process compression/decompression operation */ 547 static int 548 process_op(struct isal_comp_qp *qp, struct rte_comp_op *op, 549 struct isal_priv_xform *priv_xform) 550 { 551 switch (priv_xform->type) { 552 case RTE_COMP_COMPRESS: 553 process_isal_deflate(op, qp, priv_xform); 554 break; 555 case RTE_COMP_DECOMPRESS: 556 process_isal_inflate(op, qp); 557 break; 558 default: 559 ISAL_PMD_LOG(ERR, "Operation Not Supported\n"); 560 return -ENOTSUP; 561 } 562 return 0; 563 } 564 565 /* Enqueue burst */ 566 static uint16_t 567 isal_comp_pmd_enqueue_burst(void *queue_pair, struct rte_comp_op **ops, 568 uint16_t nb_ops) 569 { 570 struct isal_comp_qp *qp = queue_pair; 571 uint16_t i; 572 int retval; 573 int16_t num_enq = RTE_MIN(qp->num_free_elements, nb_ops); 574 575 for (i = 0; i < num_enq; i++) { 576 if (unlikely(ops[i]->op_type != RTE_COMP_OP_STATELESS)) { 577 ops[i]->status = RTE_COMP_OP_STATUS_INVALID_ARGS; 578 ISAL_PMD_LOG(ERR, "Stateful operation not Supported\n"); 579 qp->qp_stats.enqueue_err_count++; 580 continue; 581 } 582 retval = process_op(qp, ops[i], ops[i]->private_xform); 583 if (unlikely(retval < 0) || 584 ops[i]->status != RTE_COMP_OP_STATUS_SUCCESS) { 585 qp->qp_stats.enqueue_err_count++; 586 } 587 } 588 589 retval = rte_ring_enqueue_burst(qp->processed_pkts, (void *)ops, 590 num_enq, NULL); 591 qp->num_free_elements -= retval; 592 qp->qp_stats.enqueued_count += retval; 593 594 return retval; 595 } 596 597 /* Dequeue burst */ 598 static uint16_t 599 isal_comp_pmd_dequeue_burst(void *queue_pair, struct rte_comp_op **ops, 600 uint16_t nb_ops) 601 { 602 struct isal_comp_qp *qp = queue_pair; 603 uint16_t nb_dequeued; 604 605 nb_dequeued = rte_ring_dequeue_burst(qp->processed_pkts, (void **)ops, 606 nb_ops, NULL); 607 qp->num_free_elements += nb_dequeued; 608 qp->qp_stats.dequeued_count += nb_dequeued; 609 610 return nb_dequeued; 611 } 612 613 /* Create ISA-L compression device */ 614 static int 615 compdev_isal_create(const char *name, struct rte_vdev_device *vdev, 616 struct rte_compressdev_pmd_init_params *init_params) 617 { 618 struct rte_compressdev *dev; 619 620 dev = rte_compressdev_pmd_create(name, &vdev->device, 621 sizeof(struct isal_comp_private), init_params); 622 if (dev == NULL) { 623 ISAL_PMD_LOG(ERR, "failed to create compressdev vdev"); 624 return -EFAULT; 625 } 626 627 dev->dev_ops = isal_compress_pmd_ops; 628 629 /* register rx/tx burst functions for data path */ 630 dev->dequeue_burst = isal_comp_pmd_dequeue_burst; 631 dev->enqueue_burst = isal_comp_pmd_enqueue_burst; 632 633 return 0; 634 } 635 636 /** Remove compression device */ 637 static int 638 compdev_isal_remove_dev(struct rte_vdev_device *vdev) 639 { 640 struct rte_compressdev *compdev; 641 const char *name; 642 643 name = rte_vdev_device_name(vdev); 644 if (name == NULL) 645 return -EINVAL; 646 647 compdev = rte_compressdev_pmd_get_named_dev(name); 648 if (compdev == NULL) 649 return -ENODEV; 650 651 return rte_compressdev_pmd_destroy(compdev); 652 } 653 654 /** Initialise ISA-L compression device */ 655 static int 656 compdev_isal_probe(struct rte_vdev_device *dev) 657 { 658 struct rte_compressdev_pmd_init_params init_params = { 659 "", 660 rte_socket_id(), 661 }; 662 const char *name, *args; 663 int retval; 664 665 name = rte_vdev_device_name(dev); 666 if (name == NULL) 667 return -EINVAL; 668 669 args = rte_vdev_device_args(dev); 670 671 retval = rte_compressdev_pmd_parse_input_args(&init_params, args); 672 if (retval) { 673 ISAL_PMD_LOG(ERR, 674 "Failed to parse initialisation arguments[%s]\n", args); 675 return -EINVAL; 676 } 677 678 return compdev_isal_create(name, dev, &init_params); 679 } 680 681 static struct rte_vdev_driver compdev_isal_pmd_drv = { 682 .probe = compdev_isal_probe, 683 .remove = compdev_isal_remove_dev, 684 }; 685 686 RTE_PMD_REGISTER_VDEV(COMPDEV_NAME_ISAL_PMD, compdev_isal_pmd_drv); 687 RTE_PMD_REGISTER_PARAM_STRING(COMPDEV_NAME_ISAL_PMD, 688 "socket_id=<int>"); 689 690 RTE_INIT(isal_init_log) 691 { 692 isal_logtype_driver = rte_log_register("pmd.compress.isal"); 693 if (isal_logtype_driver >= 0) 694 rte_log_set_level(isal_logtype_driver, RTE_LOG_INFO); 695 } 696