1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2017 Intel Corporation 3 */ 4 5 #ifndef _RTE_BBDEV_OP_H_ 6 #define _RTE_BBDEV_OP_H_ 7 8 /** 9 * @file rte_bbdev_op.h 10 * 11 * Defines wireless base band layer 1 operations and capabilities 12 * 13 * @warning 14 * @b EXPERIMENTAL: this API may change without prior notice 15 */ 16 17 #ifdef __cplusplus 18 extern "C" { 19 #endif 20 21 #include <stdint.h> 22 23 #include <rte_common.h> 24 #include <rte_mbuf.h> 25 #include <rte_memory.h> 26 #include <rte_mempool.h> 27 28 /* Number of columns in sub-block interleaver (36.212, section 5.1.4.1.1) */ 29 #define RTE_BBDEV_C_SUBBLOCK (32) 30 /* Maximum size of Transport Block (36.213, Table, Table 7.1.7.2.5-1) */ 31 #define RTE_BBDEV_MAX_TB_SIZE (391656) 32 /* Maximum size of Code Block (36.212, Table 5.1.3-3) */ 33 #define RTE_BBDEV_MAX_CB_SIZE (6144) 34 /* Minimum size of Code Block (36.212, Table 5.1.3-3) */ 35 #define RTE_BBDEV_MIN_CB_SIZE (40) 36 /* Maximum size of circular buffer */ 37 #define RTE_BBDEV_MAX_KW (18528) 38 /* 39 * Maximum number of Code Blocks in Transport Block. It is calculated based on 40 * maximum size of one Code Block and one Transport Block (considering CRC24A 41 * and CRC24B): 42 * (391656 + 24) / (6144 - 24) = 64 43 */ 44 #define RTE_BBDEV_MAX_CODE_BLOCKS (64) 45 46 /** Flags for turbo decoder operation and capability structure */ 47 enum rte_bbdev_op_td_flag_bitmasks { 48 /**< If sub block de-interleaving is to be performed. */ 49 RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE = (1ULL << 0), 50 /**< To use CRC Type 24B (otherwise use CRC Type 24A). */ 51 RTE_BBDEV_TURBO_CRC_TYPE_24B = (1ULL << 1), 52 /**< If turbo equalization is to be performed. */ 53 RTE_BBDEV_TURBO_EQUALIZER = (1ULL << 2), 54 /**< If set, saturate soft output to +/-127 */ 55 RTE_BBDEV_TURBO_SOFT_OUT_SATURATE = (1ULL << 3), 56 /**< Set to 1 to start iteration from even, else odd; one iteration = 57 * max_iteration + 0.5 58 */ 59 RTE_BBDEV_TURBO_HALF_ITERATION_EVEN = (1ULL << 4), 60 /**< If 0, TD stops after CRC matches; else if 1, runs to end of next 61 * odd iteration after CRC matches 62 */ 63 RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH = (1ULL << 5), 64 /**< Set if soft output is required to be output */ 65 RTE_BBDEV_TURBO_SOFT_OUTPUT = (1ULL << 6), 66 /**< Set to enable early termination mode */ 67 RTE_BBDEV_TURBO_EARLY_TERMINATION = (1ULL << 7), 68 /**< Set if a device supports decoder dequeue interrupts */ 69 RTE_BBDEV_TURBO_DEC_INTERRUPTS = (1ULL << 9), 70 /**< Set if positive LLR encoded input is supported. Positive LLR value 71 * represents the level of confidence for bit '1', and vice versa for 72 * bit '0'. 73 * This is mutually exclusive with RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN 74 * when used to formalize the input data format. 75 */ 76 RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN = (1ULL << 10), 77 /**< Set if negative LLR encoded input is supported. Negative LLR value 78 * represents the level of confidence for bit '1', and vice versa for 79 * bit '0'. 80 * This is mutually exclusive with RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN 81 * when used to formalize the input data format. 82 */ 83 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN = (1ULL << 11), 84 /**< Set if positive LLR soft output is supported. Positive LLR value 85 * represents the level of confidence for bit '1', and vice versa for 86 * bit '0'. 87 * This is mutually exclusive with 88 * RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT when used to formalize 89 * the input data format. 90 */ 91 RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT = (1ULL << 12), 92 /**< Set if negative LLR soft output is supported. Negative LLR value 93 * represents the level of confidence for bit '1', and vice versa for 94 * bit '0'. 95 * This is mutually exclusive with 96 * RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT when used to formalize the 97 * input data format. 98 */ 99 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT = (1ULL << 13), 100 /**< Set if driver supports flexible parallel MAP engine decoding. If 101 * not supported, num_maps (number of MAP engines) argument is unusable. 102 */ 103 RTE_BBDEV_TURBO_MAP_DEC = (1ULL << 14), 104 /**< Set if a device supports scatter-gather functionality */ 105 RTE_BBDEV_TURBO_DEC_SCATTER_GATHER = (1ULL << 15), 106 /**< Set to keep CRC24B bits appended while decoding. Only usable when 107 * decoding Transport Blocks (code_block_mode = 0). 108 */ 109 RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP = (1ULL << 16) 110 }; 111 112 /** Flags for turbo encoder operation and capability structure */ 113 enum rte_bbdev_op_te_flag_bitmasks { 114 /**< Ignore rv_index and set K0 = 0 */ 115 RTE_BBDEV_TURBO_RV_INDEX_BYPASS = (1ULL << 0), 116 /**< If rate matching is to be performed */ 117 RTE_BBDEV_TURBO_RATE_MATCH = (1ULL << 1), 118 /**< This bit must be set to enable CRC-24B generation */ 119 RTE_BBDEV_TURBO_CRC_24B_ATTACH = (1ULL << 2), 120 /**< This bit must be set to enable CRC-24A generation */ 121 RTE_BBDEV_TURBO_CRC_24A_ATTACH = (1ULL << 3), 122 /**< Set if a device supports encoder dequeue interrupts */ 123 RTE_BBDEV_TURBO_ENC_INTERRUPTS = (1ULL << 4), 124 /**< Set if a device supports scatter-gather functionality */ 125 RTE_BBDEV_TURBO_ENC_SCATTER_GATHER = (1ULL << 5) 126 }; 127 128 /**< Data input and output buffer for BBDEV operations */ 129 struct rte_bbdev_op_data { 130 /**< The mbuf data structure representing the data for BBDEV operation. 131 * 132 * This mbuf pointer can point to one Code Block (CB) data buffer or 133 * multiple CBs contiguously located next to each other. 134 * A Transport Block (TB) represents a whole piece of data that is 135 * divided into one or more CBs. Maximum number of CBs can be contained 136 * in one TB is defined by RTE_BBDEV_MAX_CODE_BLOCKS. 137 * 138 * An mbuf data structure cannot represent more than one TB. The 139 * smallest piece of data that can be contained in one mbuf is one CB. 140 * An mbuf can include one contiguous CB, subset of contiguous CBs that 141 * are belonging to one TB, or all contiguous CBs that are belonging to 142 * one TB. 143 * 144 * If a BBDEV PMD supports the extended capability "Scatter-Gather", 145 * then it is capable of collecting (gathering) non-contiguous 146 * (scattered) data from multiple locations in the memory. 147 * This capability is reported by the capability flags: 148 * - RTE_BBDEV_TURBO_ENC_SCATTER_GATHER and 149 * - RTE_BBDEV_TURBO_DEC_SCATTER_GATHER. 150 * Only if a BBDEV PMD supports this feature, chained mbuf data 151 * structures are accepted. A chained mbuf can represent one 152 * non-contiguous CB or multiple non-contiguous CBs. 153 * If BBDEV PMD does not support this feature, it will assume inbound 154 * mbuf data contains one segment. 155 * 156 * The output mbuf data though is always one segment, even if the input 157 * was a chained mbuf. 158 */ 159 struct rte_mbuf *data; 160 /**< The starting point of the BBDEV (encode/decode) operation, 161 * in bytes. 162 * 163 * BBDEV starts to read data past this offset. 164 * In case of chained mbuf, this offset applies only to the first mbuf 165 * segment. 166 */ 167 uint32_t offset; 168 /**< The total data length to be processed in one operation, in bytes. 169 * 170 * In case the mbuf data is representing one CB, this is the length of 171 * the CB undergoing the operation. 172 * If it's for multiple CBs, this is the total length of those CBs 173 * undergoing the operation. 174 * If it's for one TB, this is the total length of the TB under 175 * operation. 176 * 177 * In case of chained mbuf, this data length includes the lengths of the 178 * "scattered" data segments undergoing the operation. 179 */ 180 uint32_t length; 181 }; 182 183 struct rte_bbdev_op_dec_cb_params { 184 /**< The K size of the input CB, in bits [40:6144], as specified in 185 * 3GPP TS 36.212. 186 * This size is inclusive of CRC bits, regardless whether it was 187 * pre-calculated by the application or not. 188 */ 189 uint16_t k; 190 /**< The E length of the CB rate matched LLR output, in bytes, as in 191 * 3GPP TS 36.212. 192 */ 193 uint32_t e; 194 }; 195 196 struct rte_bbdev_op_dec_tb_params { 197 /**< The K- size of the input CB, in bits [40:6144], that is in the 198 * Turbo operation when r < C-, as in 3GPP TS 36.212. 199 */ 200 uint16_t k_neg; 201 /**< The K+ size of the input CB, in bits [40:6144], that is in the 202 * Turbo operation when r >= C-, as in 3GPP TS 36.212. 203 */ 204 uint16_t k_pos; 205 /**< The number of CBs that have K- size, [0:63] */ 206 uint8_t c_neg; 207 /**< The total number of CBs in the TB, [1:RTE_BBDEV_MAX_CODE_BLOCKS] */ 208 uint8_t c; 209 /**< The number of CBs that uses Ea before switching to Eb, [0:63] */ 210 uint8_t cab; 211 /**< The E size of the CB rate matched output to use in the Turbo 212 * operation when r < cab 213 */ 214 uint32_t ea; 215 /**< The E size of the CB rate matched output to use in the Turbo 216 * operation when r >= cab 217 */ 218 uint32_t eb; 219 }; 220 221 /**< Operation structure for Turbo decode. 222 * An operation can perform on one CB at a time "CB-mode". 223 * An operation can perform on one or multiple CBs that are logically belonging 224 * to one TB "TB-mode". 225 * The provided K size parameter of the CB is its size out coming from the 226 * decode operation. 227 * CRC24A/B check is requested by the application by setting the flag 228 * RTE_BBDEV_TURBO_CRC_TYPE_24B for CRC24B check or CRC24A otherwise. 229 * In TB-mode, BBDEV concatenates the decoded CBs one next to the other with 230 * relevant CRC24B in between. 231 * 232 * The input encoded CB data is the Virtual Circular Buffer data stream, wk, 233 * with the null padding included as described in 3GPP TS 36.212 234 * section 5.1.4.1.2 and shown in 3GPP TS 36.212 section 5.1.4.1 Figure 5.1.4-1. 235 * The size of the virtual circular buffer is 3*Kpi, where Kpi is the 32 byte 236 * aligned value of K, as specified in 3GPP TS 36.212 section 5.1.4.1.1. 237 * 238 * Each byte in the input circular buffer is the LLR value of each bit of the 239 * original CB. 240 * 241 * Hard output is a mandatory capability that all BBDEV PMDs support. This is 242 * the decoded CBs of K sizes (CRC24A/B is the last 24-bit in each decoded CB). 243 * Soft output is an optional capability for BBDEV PMDs. If supported, an LLR 244 * rate matched output is computed in the soft_output buffer structure. 245 * 246 * The output mbuf data structure is expected to be allocated by the 247 * application with enough room for the output data. 248 */ 249 struct rte_bbdev_op_turbo_dec { 250 /**< The Virtual Circular Buffer, wk, size 3*Kpi for each CB */ 251 struct rte_bbdev_op_data input; 252 /**< The hard decisions buffer for the decoded output, 253 * size K for each CB 254 */ 255 struct rte_bbdev_op_data hard_output; 256 /**< The soft LLR output buffer - optional */ 257 struct rte_bbdev_op_data soft_output; 258 259 uint32_t op_flags; /**< Flags from rte_bbdev_op_td_flag_bitmasks */ 260 uint8_t rv_index; /**< Rv index for rate matching [0:3] */ 261 /**< The minimum number of iterations to perform in decoding all CBs in 262 * this operation - input 263 */ 264 uint8_t iter_min:4; 265 /**< The maximum number of iterations to perform in decoding all CBs in 266 * this operation - input 267 */ 268 uint8_t iter_max:4; 269 /**< The maximum number of iterations that were perform in decoding all 270 * CBs in this decode operation - output 271 */ 272 uint8_t iter_count; 273 /**< 5 bit extrinsic scale (scale factor on extrinsic info) */ 274 uint8_t ext_scale; 275 /**< Number of MAP engines to use in decode, 276 * must be power of 2 (or 0 to auto-select) 277 */ 278 uint8_t num_maps; 279 280 uint8_t code_block_mode; /**< [0 - TB : 1 - CB] */ 281 union { 282 /**< Struct which stores Code Block specific parameters */ 283 struct rte_bbdev_op_dec_cb_params cb_params; 284 /**< Struct which stores Transport Block specific parameters */ 285 struct rte_bbdev_op_dec_tb_params tb_params; 286 }; 287 }; 288 289 struct rte_bbdev_op_enc_cb_params { 290 /**< The K size of the input CB, in bits [40:6144], as specified in 291 * 3GPP TS 36.212. 292 * This size is inclusive of CRC24A, regardless whether it was 293 * pre-calculated by the application or not. 294 */ 295 uint16_t k; 296 /**< The E length of the CB rate matched output, in bits, as in 297 * 3GPP TS 36.212. 298 */ 299 uint32_t e; 300 /**< The Ncb soft buffer size of the CB rate matched output [K:3*Kpi], 301 * in bits, as specified in 3GPP TS 36.212. 302 */ 303 uint16_t ncb; 304 }; 305 306 struct rte_bbdev_op_enc_tb_params { 307 /**< The K- size of the input CB, in bits [40:6144], that is in the 308 * Turbo operation when r < C-, as in 3GPP TS 36.212. 309 * This size is inclusive of CRC24B, regardless whether it was 310 * pre-calculated and appended by the application or not. 311 */ 312 uint16_t k_neg; 313 /**< The K+ size of the input CB, in bits [40:6144], that is in the 314 * Turbo operation when r >= C-, as in 3GPP TS 36.212. 315 * This size is inclusive of CRC24B, regardless whether it was 316 * pre-calculated and appended by the application or not. 317 */ 318 uint16_t k_pos; 319 /**< The number of CBs that have K- size, [0:63] */ 320 uint8_t c_neg; 321 /**< The total number of CBs in the TB, [1:RTE_BBDEV_MAX_CODE_BLOCKS] */ 322 uint8_t c; 323 /**< The number of CBs that uses Ea before switching to Eb, [0:63] */ 324 uint8_t cab; 325 /**< The E size of the CB rate matched output to use in the Turbo 326 * operation when r < cab 327 */ 328 uint32_t ea; 329 /**< The E size of the CB rate matched output to use in the Turbo 330 * operation when r >= cab 331 */ 332 uint32_t eb; 333 /**< The Ncb soft buffer size for the rate matched CB that is used in 334 * the Turbo operation when r < C-, [K:3*Kpi] 335 */ 336 uint16_t ncb_neg; 337 /**< The Ncb soft buffer size for the rate matched CB that is used in 338 * the Turbo operation when r >= C-, [K:3*Kpi] 339 */ 340 uint16_t ncb_pos; 341 /**< The index of the first CB in the inbound mbuf data, default is 0 */ 342 uint8_t r; 343 }; 344 345 /**< Operation structure for Turbo encode. 346 * An operation can perform on one CB at a time "CB-mode". 347 * An operation can perform on one or multiple CBs that are logically 348 * belonging to one TB "TB-mode". 349 * 350 * In CB-mode, CRC24A/B is an optional operation. K size parameter is not 351 * affected by CRC24A/B inclusion, this only affects the inbound mbuf data 352 * length. Not all BBDEV PMDs are capable of CRC24A/B calculation. Flags 353 * RTE_BBDEV_TURBO_CRC_24A_ATTACH and RTE_BBDEV_TURBO_CRC_24B_ATTACH informs 354 * the application with relevant capability. These flags can be set in the 355 * op_flags parameter to indicate BBDEV to calculate and append CRC24A to CB 356 * before going forward with Turbo encoding. 357 * 358 * In TB-mode, CRC24A is assumed to be pre-calculated and appended to the 359 * inbound TB mbuf data buffer. 360 * 361 * The output mbuf data structure is expected to be allocated by the 362 * application with enough room for the output data. 363 */ 364 struct rte_bbdev_op_turbo_enc { 365 /**< The input CB or TB data */ 366 struct rte_bbdev_op_data input; 367 /**< The rate matched CB or TB output buffer */ 368 struct rte_bbdev_op_data output; 369 370 uint32_t op_flags; /**< Flags from rte_bbdev_op_te_flag_bitmasks */ 371 uint8_t rv_index; /**< Rv index for rate matching [0:3] */ 372 373 uint8_t code_block_mode; /**< [0 - TB : 1 - CB] */ 374 union { 375 /**< Struct which stores Code Block specific parameters */ 376 struct rte_bbdev_op_enc_cb_params cb_params; 377 /**< Struct which stores Transport Block specific parameters */ 378 struct rte_bbdev_op_enc_tb_params tb_params; 379 }; 380 }; 381 382 /**< List of the capabilities for the Turbo Decoder */ 383 struct rte_bbdev_op_cap_turbo_dec { 384 /**< Flags from rte_bbdev_op_td_flag_bitmasks */ 385 uint32_t capability_flags; 386 /** Maximal LLR absolute value. Acceptable LLR values lie in range 387 * [-max_llr_modulus, max_llr_modulus]. 388 */ 389 int8_t max_llr_modulus; 390 uint8_t num_buffers_src; /**< Num input code block buffers */ 391 /**< Num hard output code block buffers */ 392 uint8_t num_buffers_hard_out; 393 /**< Num soft output code block buffers if supported by the driver */ 394 uint8_t num_buffers_soft_out; 395 }; 396 397 /**< List of the capabilities for the Turbo Encoder */ 398 struct rte_bbdev_op_cap_turbo_enc { 399 /**< Flags from rte_bbdev_op_te_flag_bitmasks */ 400 uint32_t capability_flags; 401 uint8_t num_buffers_src; /**< Num input code block buffers */ 402 uint8_t num_buffers_dst; /**< Num output code block buffers */ 403 }; 404 405 /** Different operation types supported by the device */ 406 enum rte_bbdev_op_type { 407 RTE_BBDEV_OP_NONE, /**< Dummy operation that does nothing */ 408 RTE_BBDEV_OP_TURBO_DEC, /**< Turbo decode */ 409 RTE_BBDEV_OP_TURBO_ENC, /**< Turbo encode */ 410 RTE_BBDEV_OP_TYPE_COUNT, /**< Count of different op types */ 411 }; 412 413 /**< Bit indexes of possible errors reported through status field */ 414 enum { 415 RTE_BBDEV_DRV_ERROR, 416 RTE_BBDEV_DATA_ERROR, 417 RTE_BBDEV_CRC_ERROR, 418 }; 419 420 /**< Structure specifying a single encode operation */ 421 struct rte_bbdev_enc_op { 422 int status; /**< Status of operation that was performed */ 423 struct rte_mempool *mempool; /**< Mempool which op instance is in */ 424 void *opaque_data; /**< Opaque pointer for user data */ 425 /**< Contains encoder specific parameters */ 426 struct rte_bbdev_op_turbo_enc turbo_enc; 427 }; 428 429 /**< Structure specifying a single decode operation */ 430 struct rte_bbdev_dec_op { 431 int status; /**< Status of operation that was performed */ 432 struct rte_mempool *mempool; /**< Mempool which op instance is in */ 433 void *opaque_data; /**< Opaque pointer for user data */ 434 /**< Contains decoder specific parameters */ 435 struct rte_bbdev_op_turbo_dec turbo_dec; 436 }; 437 438 /**< Operation capabilities supported by a device */ 439 struct rte_bbdev_op_cap { 440 enum rte_bbdev_op_type type; /**< Type of operation */ 441 union { 442 struct rte_bbdev_op_cap_turbo_dec turbo_dec; 443 struct rte_bbdev_op_cap_turbo_enc turbo_enc; 444 } cap; /**< Operation-type specific capabilities */ 445 }; 446 447 /**< @internal Private data structure stored with operation pool. */ 448 struct rte_bbdev_op_pool_private { 449 enum rte_bbdev_op_type type; /**< Type of operations in a pool */ 450 }; 451 452 /** 453 * Converts queue operation type from enum to string 454 * 455 * @param op_type 456 * Operation type as enum 457 * 458 * @returns 459 * Operation type as string or NULL if op_type is invalid 460 * 461 */ 462 const char* 463 rte_bbdev_op_type_str(enum rte_bbdev_op_type op_type); 464 465 /** 466 * Creates a bbdev operation mempool 467 * 468 * @param name 469 * Pool name. 470 * @param type 471 * Operation type, use RTE_BBDEV_OP_NONE for a pool which supports all 472 * operation types. 473 * @param num_elements 474 * Number of elements in the pool. 475 * @param cache_size 476 * Number of elements to cache on an lcore, see rte_mempool_create() for 477 * further details about cache size. 478 * @param socket_id 479 * Socket to allocate memory on. 480 * 481 * @return 482 * - Pointer to a mempool on success, 483 * - NULL pointer on failure. 484 */ 485 struct rte_mempool * 486 rte_bbdev_op_pool_create(const char *name, enum rte_bbdev_op_type type, 487 unsigned int num_elements, unsigned int cache_size, 488 int socket_id); 489 490 /** 491 * Bulk allocate encode operations from a mempool with parameter defaults reset. 492 * 493 * @param mempool 494 * Operation mempool, created by rte_bbdev_op_pool_create(). 495 * @param ops 496 * Output array to place allocated operations 497 * @param num_ops 498 * Number of operations to allocate 499 * 500 * @returns 501 * - 0 on success 502 * - EINVAL if invalid mempool is provided 503 */ 504 static inline int 505 rte_bbdev_enc_op_alloc_bulk(struct rte_mempool *mempool, 506 struct rte_bbdev_enc_op **ops, uint16_t num_ops) 507 { 508 struct rte_bbdev_op_pool_private *priv; 509 int ret; 510 511 /* Check type */ 512 priv = (struct rte_bbdev_op_pool_private *) 513 rte_mempool_get_priv(mempool); 514 if (unlikely(priv->type != RTE_BBDEV_OP_TURBO_ENC)) 515 return -EINVAL; 516 517 /* Get elements */ 518 ret = rte_mempool_get_bulk(mempool, (void **)ops, num_ops); 519 if (unlikely(ret < 0)) 520 return ret; 521 522 return 0; 523 } 524 525 /** 526 * Bulk allocate decode operations from a mempool with parameter defaults reset. 527 * 528 * @param mempool 529 * Operation mempool, created by rte_bbdev_op_pool_create(). 530 * @param ops 531 * Output array to place allocated operations 532 * @param num_ops 533 * Number of operations to allocate 534 * 535 * @returns 536 * - 0 on success 537 * - EINVAL if invalid mempool is provided 538 */ 539 static inline int 540 rte_bbdev_dec_op_alloc_bulk(struct rte_mempool *mempool, 541 struct rte_bbdev_dec_op **ops, uint16_t num_ops) 542 { 543 struct rte_bbdev_op_pool_private *priv; 544 int ret; 545 546 /* Check type */ 547 priv = (struct rte_bbdev_op_pool_private *) 548 rte_mempool_get_priv(mempool); 549 if (unlikely(priv->type != RTE_BBDEV_OP_TURBO_DEC)) 550 return -EINVAL; 551 552 /* Get elements */ 553 ret = rte_mempool_get_bulk(mempool, (void **)ops, num_ops); 554 if (unlikely(ret < 0)) 555 return ret; 556 557 return 0; 558 } 559 560 /** 561 * Free decode operation structures that were allocated by 562 * rte_bbdev_dec_op_alloc_bulk(). 563 * All structures must belong to the same mempool. 564 * 565 * @param ops 566 * Operation structures 567 * @param num_ops 568 * Number of structures 569 */ 570 static inline void 571 rte_bbdev_dec_op_free_bulk(struct rte_bbdev_dec_op **ops, unsigned int num_ops) 572 { 573 if (num_ops > 0) 574 rte_mempool_put_bulk(ops[0]->mempool, (void **)ops, num_ops); 575 } 576 577 /** 578 * Free encode operation structures that were allocated by 579 * rte_bbdev_enc_op_alloc_bulk(). 580 * All structures must belong to the same mempool. 581 * 582 * @param ops 583 * Operation structures 584 * @param num_ops 585 * Number of structures 586 */ 587 static inline void 588 rte_bbdev_enc_op_free_bulk(struct rte_bbdev_enc_op **ops, unsigned int num_ops) 589 { 590 if (num_ops > 0) 591 rte_mempool_put_bulk(ops[0]->mempool, (void **)ops, num_ops); 592 } 593 594 #ifdef __cplusplus 595 } 596 #endif 597 598 #endif /* _RTE_BBDEV_OP_H_ */ 599