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_TURBO_C_SUBBLOCK (32) 30 /* Maximum size of Transport Block (36.213, Table, Table 7.1.7.2.5-1) */ 31 #define RTE_BBDEV_TURBO_MAX_TB_SIZE (391656) 32 /* Maximum size of Code Block (36.212, Table 5.1.3-3) */ 33 #define RTE_BBDEV_TURBO_MAX_CB_SIZE (6144) 34 /* Maximum size of Code Block */ 35 #define RTE_BBDEV_LDPC_MAX_CB_SIZE (8448) 36 /* Minimum size of Code Block (36.212, Table 5.1.3-3) */ 37 #define RTE_BBDEV_TURBO_MIN_CB_SIZE (40) 38 /* Maximum size of circular buffer */ 39 #define RTE_BBDEV_TURBO_MAX_KW (18528) 40 /* 41 * Turbo: Maximum number of Code Blocks in Transport Block. It is calculated 42 * based on maximum size of one Code Block and one Transport Block 43 * (considering CRC24A and CRC24B): 44 * (391656 + 24) / (6144 - 24) = 64 45 */ 46 #define RTE_BBDEV_TURBO_MAX_CODE_BLOCKS (64) 47 /* LDPC: Maximum number of Code Blocks in Transport Block.*/ 48 #define RTE_BBDEV_LDPC_MAX_CODE_BLOCKS (256) 49 50 /** Flags for turbo decoder operation and capability structure */ 51 enum rte_bbdev_op_td_flag_bitmasks { 52 /** If sub block de-interleaving is to be performed. */ 53 RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE = (1ULL << 0), 54 /** To use CRC Type 24B (otherwise use CRC Type 24A). */ 55 RTE_BBDEV_TURBO_CRC_TYPE_24B = (1ULL << 1), 56 /** If turbo equalization is to be performed. */ 57 RTE_BBDEV_TURBO_EQUALIZER = (1ULL << 2), 58 /** If set, saturate soft output to +/-127 */ 59 RTE_BBDEV_TURBO_SOFT_OUT_SATURATE = (1ULL << 3), 60 /** Set to 1 to start iteration from even, else odd; one iteration = 61 * max_iteration + 0.5 62 */ 63 RTE_BBDEV_TURBO_HALF_ITERATION_EVEN = (1ULL << 4), 64 /** If 0, TD stops after CRC matches; else if 1, runs to end of next 65 * odd iteration after CRC matches 66 */ 67 RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH = (1ULL << 5), 68 /** Set if soft output is required to be output */ 69 RTE_BBDEV_TURBO_SOFT_OUTPUT = (1ULL << 6), 70 /** Set to enable early termination mode */ 71 RTE_BBDEV_TURBO_EARLY_TERMINATION = (1ULL << 7), 72 /** Set if a device supports decoder dequeue interrupts */ 73 RTE_BBDEV_TURBO_DEC_INTERRUPTS = (1ULL << 9), 74 /** Set if positive LLR encoded input is supported. Positive LLR value 75 * represents the level of confidence for bit '1', and vice versa for 76 * bit '0'. 77 * This is mutually exclusive with RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN 78 * when used to formalize the input data format. 79 */ 80 RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN = (1ULL << 10), 81 /** Set if negative LLR encoded input is supported. Negative LLR value 82 * represents the level of confidence for bit '1', and vice versa for 83 * bit '0'. 84 * This is mutually exclusive with RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN 85 * when used to formalize the input data format. 86 */ 87 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN = (1ULL << 11), 88 /** Set if positive LLR soft output is supported. Positive LLR value 89 * represents the level of confidence for bit '1', and vice versa for 90 * bit '0'. 91 * This is mutually exclusive with 92 * RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT when used to formalize 93 * the input data format. 94 */ 95 RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT = (1ULL << 12), 96 /** Set if negative LLR soft output is supported. Negative LLR value 97 * represents the level of confidence for bit '1', and vice versa for 98 * bit '0'. 99 * This is mutually exclusive with 100 * RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT when used to formalize the 101 * input data format. 102 */ 103 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT = (1ULL << 13), 104 /** Set if driver supports flexible parallel MAP engine decoding. If 105 * not supported, num_maps (number of MAP engines) argument is unusable. 106 */ 107 RTE_BBDEV_TURBO_MAP_DEC = (1ULL << 14), 108 /** Set if a device supports scatter-gather functionality */ 109 RTE_BBDEV_TURBO_DEC_SCATTER_GATHER = (1ULL << 15), 110 /** Set to keep CRC24B bits appended while decoding. Only usable when 111 * decoding Transport Blocks (code_block_mode = 0). 112 */ 113 RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP = (1ULL << 16) 114 }; 115 116 117 /** Flags for turbo encoder operation and capability structure */ 118 enum rte_bbdev_op_te_flag_bitmasks { 119 /** Ignore rv_index and set K0 = 0 */ 120 RTE_BBDEV_TURBO_RV_INDEX_BYPASS = (1ULL << 0), 121 /** If rate matching is to be performed */ 122 RTE_BBDEV_TURBO_RATE_MATCH = (1ULL << 1), 123 /** This bit must be set to enable CRC-24B generation */ 124 RTE_BBDEV_TURBO_CRC_24B_ATTACH = (1ULL << 2), 125 /** This bit must be set to enable CRC-24A generation */ 126 RTE_BBDEV_TURBO_CRC_24A_ATTACH = (1ULL << 3), 127 /** Set if a device supports encoder dequeue interrupts */ 128 RTE_BBDEV_TURBO_ENC_INTERRUPTS = (1ULL << 4), 129 /** Set if a device supports scatter-gather functionality */ 130 RTE_BBDEV_TURBO_ENC_SCATTER_GATHER = (1ULL << 5) 131 }; 132 133 /** Flags for LDPC decoder operation and capability structure */ 134 enum rte_bbdev_op_ldpcdec_flag_bitmasks { 135 /** Set for transport block CRC-24A checking */ 136 RTE_BBDEV_LDPC_CRC_TYPE_24A_CHECK = (1ULL << 0), 137 /** Set for code block CRC-24B checking */ 138 RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK = (1ULL << 1), 139 /** Set to drop the last CRC bits decoding output */ 140 RTE_BBDEV_LDPC_CRC_TYPE_24B_DROP = (1ULL << 2), 141 /** Set for bit-level de-interleaver bypass on Rx stream. */ 142 RTE_BBDEV_LDPC_DEINTERLEAVER_BYPASS = (1ULL << 3), 143 /** Set for HARQ combined input stream enable. */ 144 RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE = (1ULL << 4), 145 /** Set for HARQ combined output stream enable. */ 146 RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE = (1ULL << 5), 147 /** Set for LDPC decoder bypass. 148 * RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE must be set. 149 */ 150 RTE_BBDEV_LDPC_DECODE_BYPASS = (1ULL << 6), 151 /** Set for soft-output stream enable */ 152 RTE_BBDEV_LDPC_SOFT_OUT_ENABLE = (1ULL << 7), 153 /** Set for Rate-Matching bypass on soft-out stream. */ 154 RTE_BBDEV_LDPC_SOFT_OUT_RM_BYPASS = (1ULL << 8), 155 /** Set for bit-level de-interleaver bypass on soft-output stream. */ 156 RTE_BBDEV_LDPC_SOFT_OUT_DEINTERLEAVER_BYPASS = (1ULL << 9), 157 /** Set for iteration stopping on successful decode condition 158 * i.e. a successful syndrome check. 159 */ 160 RTE_BBDEV_LDPC_ITERATION_STOP_ENABLE = (1ULL << 10), 161 /** Set if a device supports decoder dequeue interrupts. */ 162 RTE_BBDEV_LDPC_DEC_INTERRUPTS = (1ULL << 11), 163 /** Set if a device supports scatter-gather functionality. */ 164 RTE_BBDEV_LDPC_DEC_SCATTER_GATHER = (1ULL << 12), 165 /** Set if a device supports input/output HARQ compression. */ 166 RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION = (1ULL << 13), 167 /** Set if a device supports input LLR compression. */ 168 RTE_BBDEV_LDPC_LLR_COMPRESSION = (1ULL << 14), 169 /** Set if a device supports HARQ input from 170 * device's internal memory. 171 */ 172 RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE = (1ULL << 15), 173 /** Set if a device supports HARQ output to 174 * device's internal memory. 175 */ 176 RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE = (1ULL << 16), 177 /** Set if a device supports loop-back access to 178 * HARQ internal memory. Intended for troubleshooting. 179 */ 180 RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK = (1ULL << 17) 181 }; 182 183 /** Flags for LDPC encoder operation and capability structure */ 184 enum rte_bbdev_op_ldpcenc_flag_bitmasks { 185 /** Set for bit-level interleaver bypass on output stream. */ 186 RTE_BBDEV_LDPC_INTERLEAVER_BYPASS = (1ULL << 0), 187 /** If rate matching is to be performed */ 188 RTE_BBDEV_LDPC_RATE_MATCH = (1ULL << 1), 189 /** Set for transport block CRC-24A attach */ 190 RTE_BBDEV_LDPC_CRC_24A_ATTACH = (1ULL << 2), 191 /** Set for code block CRC-24B attach */ 192 RTE_BBDEV_LDPC_CRC_24B_ATTACH = (1ULL << 3), 193 /** Set for code block CRC-16 attach */ 194 RTE_BBDEV_LDPC_CRC_16_ATTACH = (1ULL << 4), 195 /** Set if a device supports encoder dequeue interrupts. */ 196 RTE_BBDEV_LDPC_ENC_INTERRUPTS = (1ULL << 5), 197 /** Set if a device supports scatter-gather functionality. */ 198 RTE_BBDEV_LDPC_ENC_SCATTER_GATHER = (1ULL << 6), 199 /** Set if a device supports concatenation of non byte aligned output */ 200 RTE_BBDEV_LDPC_ENC_CONCATENATION = (1ULL << 7) 201 }; 202 203 /** Data input and output buffer for BBDEV operations */ 204 struct rte_bbdev_op_data { 205 /** The mbuf data structure representing the data for BBDEV operation. 206 * 207 * This mbuf pointer can point to one Code Block (CB) data buffer or 208 * multiple CBs contiguously located next to each other. 209 * A Transport Block (TB) represents a whole piece of data that is 210 * divided into one or more CBs. Maximum number of CBs can be contained 211 * in one TB is defined by RTE_BBDEV_(TURBO/LDPC)_MAX_CODE_BLOCKS. 212 * 213 * An mbuf data structure cannot represent more than one TB. The 214 * smallest piece of data that can be contained in one mbuf is one CB. 215 * An mbuf can include one contiguous CB, subset of contiguous CBs that 216 * are belonging to one TB, or all contiguous CBs that are belonging to 217 * one TB. 218 * 219 * If a BBDEV PMD supports the extended capability "Scatter-Gather", 220 * then it is capable of collecting (gathering) non-contiguous 221 * (scattered) data from multiple locations in the memory. 222 * This capability is reported by the capability flags: 223 * - RTE_BBDEV_(TURBO/LDPC)_ENC_SCATTER_GATHER and 224 * - RTE_BBDEV_(TURBO/LDPC)_DEC_SCATTER_GATHER. 225 * Only if a BBDEV PMD supports this feature, chained mbuf data 226 * structures are accepted. A chained mbuf can represent one 227 * non-contiguous CB or multiple non-contiguous CBs. 228 * If BBDEV PMD does not support this feature, it will assume inbound 229 * mbuf data contains one segment. 230 * 231 * The output mbuf data though is always one segment, even if the input 232 * was a chained mbuf. 233 */ 234 struct rte_mbuf *data; 235 /** The starting point of the BBDEV (encode/decode) operation, 236 * in bytes. 237 * 238 * BBDEV starts to read data past this offset. 239 * In case of chained mbuf, this offset applies only to the first mbuf 240 * segment. 241 */ 242 uint32_t offset; 243 /** The total data length to be processed in one operation, in bytes. 244 * 245 * In case the mbuf data is representing one CB, this is the length of 246 * the CB undergoing the operation. 247 * If it's for multiple CBs, this is the total length of those CBs 248 * undergoing the operation. 249 * If it is for one TB, this is the total length of the TB under 250 * operation. 251 * 252 * In case of chained mbuf, this data length includes the lengths of the 253 * "scattered" data segments undergoing the operation. 254 */ 255 uint32_t length; 256 }; 257 258 /** Turbo decode code block parameters */ 259 struct rte_bbdev_op_dec_turbo_cb_params { 260 /** The K size of the input CB, in bits [40:6144], as specified in 261 * 3GPP TS 36.212. 262 * This size is inclusive of CRC bits, regardless whether it was 263 * pre-calculated by the application or not. 264 */ 265 uint16_t k; 266 /** The E length of the CB rate matched LLR output, in bytes, as in 267 * 3GPP TS 36.212. 268 */ 269 uint32_t e; 270 }; 271 272 /** LDPC decode code block parameters */ 273 struct rte_bbdev_op_dec_ldpc_cb_params { 274 /** Rate matching output sequence length in bits or LLRs. 275 * [3GPP TS38.212, section 5.4.2.1] 276 */ 277 uint32_t e; 278 }; 279 280 /** Turbo decode transport block parameters */ 281 struct rte_bbdev_op_dec_turbo_tb_params { 282 /** The K- size of the input CB, in bits [40:6144], that is in the 283 * Turbo operation when r < C-, as in 3GPP TS 36.212. 284 */ 285 uint16_t k_neg; 286 /** The K+ size of the input CB, in bits [40:6144], that is in the 287 * Turbo operation when r >= C-, as in 3GPP TS 36.212. 288 */ 289 uint16_t k_pos; 290 /** The number of CBs that have K- size, [0:63] */ 291 uint8_t c_neg; 292 /** The total number of CBs in the TB, 293 * [1:RTE_BBDEV_TURBO_MAX_CODE_BLOCKS] 294 */ 295 uint8_t c; 296 /** The number of CBs that uses Ea before switching to Eb, [0:63] */ 297 uint8_t cab; 298 /** The E size of the CB rate matched output to use in the Turbo 299 * operation when r < cab 300 */ 301 uint32_t ea; 302 /** The E size of the CB rate matched output to use in the Turbo 303 * operation when r >= cab 304 */ 305 uint32_t eb; 306 /** The index of the first CB in the inbound mbuf data, default is 0 */ 307 uint8_t r; 308 }; 309 310 /** LDPC decode transport block parameters */ 311 struct rte_bbdev_op_dec_ldpc_tb_params { 312 /** Ea, length after rate matching in bits, r < cab. 313 * [3GPP TS38.212, section 5.4.2.1] 314 */ 315 uint32_t ea; 316 /** Eb, length after rate matching in bits, r >= cab. 317 * [3GPP TS38.212, section 5.4.2.1] 318 */ 319 uint32_t eb; 320 /** The total number of CBs in the TB or partial TB 321 * [1:RTE_BBDEV_LDPC_MAX_CODE_BLOCKS] 322 */ 323 uint8_t c; 324 /** The index of the first CB in the inbound mbuf data, default is 0 */ 325 uint8_t r; 326 /** The number of CBs that use Ea before switching to Eb, [0:63] */ 327 uint8_t cab; 328 }; 329 330 /** Operation structure for Turbo decode. 331 * An operation can be performed on one CB at a time "CB-mode". 332 * An operation can be performed on one or multiple CBs that logically 333 * belong to one TB "TB-mode". 334 * The provided K size parameter of the CB is its size coming from the 335 * decode operation. 336 * CRC24A/B check is requested by the application by setting the flag 337 * RTE_BBDEV_TURBO_CRC_TYPE_24B for CRC24B check or CRC24A otherwise. 338 * In TB-mode, BBDEV concatenates the decoded CBs one next to the other with 339 * relevant CRC24B in between. 340 * 341 * The input encoded CB data is the Virtual Circular Buffer data stream, wk, 342 * with the null padding included as described in 3GPP TS 36.212 343 * section 5.1.4.1.2 and shown in 3GPP TS 36.212 section 5.1.4.1 Figure 5.1.4-1. 344 * The size of the virtual circular buffer is 3*Kpi, where Kpi is the 32 byte 345 * aligned value of K, as specified in 3GPP TS 36.212 section 5.1.4.1.1. 346 * 347 * Each byte in the input circular buffer is the LLR value of each bit of the 348 * original CB. 349 * 350 * Hard output is a mandatory capability that all BBDEV PMDs support. This is 351 * the decoded CBs of K sizes (CRC24A/B is the last 24-bit in each decoded CB). 352 * Soft output is an optional capability for BBDEV PMDs. If supported, an LLR 353 * rate matched output is computed in the soft_output buffer structure. 354 * 355 * The output mbuf data structure is expected to be allocated by the 356 * application with enough room for the output data. 357 */ 358 struct rte_bbdev_op_turbo_dec { 359 /** The Virtual Circular Buffer, wk, size 3*Kpi for each CB */ 360 struct rte_bbdev_op_data input; 361 /** The hard decisions buffer for the decoded output, 362 * size K for each CB 363 */ 364 struct rte_bbdev_op_data hard_output; 365 /** The soft LLR output buffer - optional */ 366 struct rte_bbdev_op_data soft_output; 367 368 /** Flags from rte_bbdev_op_td_flag_bitmasks */ 369 uint32_t op_flags; 370 371 /** Rv index for rate matching [0:3] */ 372 uint8_t rv_index; 373 /** The minimum number of iterations to perform in decoding all CBs in 374 * this operation - input 375 */ 376 uint8_t iter_min:4; 377 /** The maximum number of iterations to perform in decoding all CBs in 378 * this operation - input 379 */ 380 uint8_t iter_max:4; 381 /** The maximum number of iterations that were performed in decoding 382 * all CBs in this decode operation - output 383 */ 384 uint8_t iter_count; 385 /** 5 bit extrinsic scale (scale factor on extrinsic info) */ 386 uint8_t ext_scale; 387 /** Number of MAP engines to use in decode, 388 * must be power of 2 (or 0 to auto-select) 389 */ 390 uint8_t num_maps; 391 392 /** [0 - TB : 1 - CB] */ 393 uint8_t code_block_mode; 394 union { 395 /** Struct which stores Code Block specific parameters */ 396 struct rte_bbdev_op_dec_turbo_cb_params cb_params; 397 /** Struct which stores Transport Block specific parameters */ 398 struct rte_bbdev_op_dec_turbo_tb_params tb_params; 399 }; 400 }; 401 402 /** Operation structure for LDPC decode. 403 * 404 * An operation can be performed on one CB at a time "CB-mode". 405 * An operation can also be performed on one or multiple CBs that logically 406 * belong to a TB "TB-mode" (Currently not supported). 407 * 408 * The input encoded CB data is the Virtual Circular Buffer data stream. 409 * 410 * Each byte in the input circular buffer is the LLR value of each bit of the 411 * original CB. 412 * 413 * Hard output is a mandatory capability that all BBDEV PMDs support. This is 414 * the decoded CBs (CRC24A/B is the last 24-bit in each decoded CB). 415 * 416 * Soft output is an optional capability for BBDEV PMDs. If supported, an LLR 417 * rate matched output is computed in the soft_output buffer structure. 418 * These are A Posteriori Probabilities (APP) LLR samples for coded bits. 419 * 420 * HARQ combined output is an optional capability for BBDEV PMDs. 421 * If supported, a LLR output is streamed to the harq_combined_output 422 * buffer. 423 * 424 * HARQ combined input is an optional capability for BBDEV PMDs. 425 * If supported, a LLR input is streamed from the harq_combined_input 426 * buffer. 427 * 428 * The output mbuf data structure is expected to be allocated by the 429 * application with enough room for the output data. 430 */ 431 struct rte_bbdev_op_ldpc_dec { 432 /** The Virtual Circular Buffer for this code block, one LLR 433 * per bit of the original CB. 434 */ 435 struct rte_bbdev_op_data input; 436 /** The hard decisions buffer for the decoded output, 437 * size K for each CB 438 */ 439 struct rte_bbdev_op_data hard_output; 440 /** The soft LLR output LLR stream buffer - optional */ 441 struct rte_bbdev_op_data soft_output; 442 /** The HARQ combined LLR stream input buffer - optional */ 443 struct rte_bbdev_op_data harq_combined_input; 444 /** The HARQ combined LLR stream output buffer - optional */ 445 struct rte_bbdev_op_data harq_combined_output; 446 447 /** Flags from rte_bbdev_op_ldpcdec_flag_bitmasks */ 448 uint32_t op_flags; 449 450 /** Rate matching redundancy version 451 * [3GPP TS38.212, section 5.4.2.1] 452 */ 453 uint8_t rv_index; 454 /** The maximum number of iterations to perform in decoding CB in 455 * this operation - input 456 */ 457 uint8_t iter_max; 458 /** The number of iterations that were performed in decoding 459 * CB in this decode operation - output 460 */ 461 uint8_t iter_count; 462 /** 1: LDPC Base graph 1, 2: LDPC Base graph 2. 463 * [3GPP TS38.212, section 5.2.2] 464 */ 465 uint8_t basegraph; 466 /** Zc, LDPC lifting size. 467 * [3GPP TS38.212, section 5.2.2] 468 */ 469 uint16_t z_c; 470 /** Ncb, length of the circular buffer in bits. 471 * [3GPP TS38.212, section 5.4.2.1] 472 */ 473 uint16_t n_cb; 474 /** Qm, modulation order {1,2,4,6,8}. 475 * [3GPP TS38.212, section 5.4.2.2] 476 */ 477 uint8_t q_m; 478 /** Number of Filler bits, n_filler = K – K’ 479 * [3GPP TS38.212 section 5.2.2] 480 */ 481 uint16_t n_filler; 482 /** [0 - TB : 1 - CB] */ 483 uint8_t code_block_mode; 484 union { 485 /** Struct which stores Code Block specific parameters */ 486 struct rte_bbdev_op_dec_ldpc_cb_params cb_params; 487 /** Struct which stores Transport Block specific parameters */ 488 struct rte_bbdev_op_dec_ldpc_tb_params tb_params; 489 }; 490 }; 491 492 /** Turbo encode code block parameters */ 493 struct rte_bbdev_op_enc_turbo_cb_params { 494 /** The K size of the input CB, in bits [40:6144], as specified in 495 * 3GPP TS 36.212. 496 * This size is inclusive of CRC24A, regardless whether it was 497 * pre-calculated by the application or not. 498 */ 499 uint16_t k; 500 /** The E length of the CB rate matched output, in bits, as in 501 * 3GPP TS 36.212. 502 */ 503 uint32_t e; 504 /** The Ncb soft buffer size of the CB rate matched output [K:3*Kpi], 505 * in bits, as specified in 3GPP TS 36.212. 506 */ 507 uint16_t ncb; 508 }; 509 510 /** Turbo encode transport block parameters */ 511 struct rte_bbdev_op_enc_turbo_tb_params { 512 /** The K- size of the input CB, in bits [40:6144], that is in the 513 * Turbo operation when r < C-, as in 3GPP TS 36.212. 514 * This size is inclusive of CRC24B, regardless whether it was 515 * pre-calculated and appended by the application or not. 516 */ 517 uint16_t k_neg; 518 /** The K+ size of the input CB, in bits [40:6144], that is in the 519 * Turbo operation when r >= C-, as in 3GPP TS 36.212. 520 * This size is inclusive of CRC24B, regardless whether it was 521 * pre-calculated and appended by the application or not. 522 */ 523 uint16_t k_pos; 524 /** The number of CBs that have K- size, [0:63] */ 525 uint8_t c_neg; 526 /** The total number of CBs in the TB, 527 * [1:RTE_BBDEV_TURBO_MAX_CODE_BLOCKS] 528 */ 529 uint8_t c; 530 /** The number of CBs that uses Ea before switching to Eb, [0:63] */ 531 uint8_t cab; 532 /** The E size of the CB rate matched output to use in the Turbo 533 * operation when r < cab 534 */ 535 uint32_t ea; 536 /** The E size of the CB rate matched output to use in the Turbo 537 * operation when r >= cab 538 */ 539 uint32_t eb; 540 /** The Ncb soft buffer size for the rate matched CB that is used in 541 * the Turbo operation when r < C-, [K:3*Kpi] 542 */ 543 uint16_t ncb_neg; 544 /** The Ncb soft buffer size for the rate matched CB that is used in 545 * the Turbo operation when r >= C-, [K:3*Kpi] 546 */ 547 uint16_t ncb_pos; 548 /** The index of the first CB in the inbound mbuf data, default is 0 */ 549 uint8_t r; 550 }; 551 552 /** LDPC encode code block parameters */ 553 struct rte_bbdev_op_enc_ldpc_cb_params { 554 /** E, length after rate matching in bits. 555 * [3GPP TS38.212, section 5.4.2.1] 556 */ 557 uint32_t e; 558 }; 559 560 /** LDPC encode transport block parameters */ 561 struct rte_bbdev_op_enc_ldpc_tb_params { 562 /** Ea, length after rate matching in bits, r < cab. 563 * [3GPP TS38.212, section 5.4.2.1] 564 */ 565 uint32_t ea; 566 /** Eb, length after rate matching in bits, r >= cab. 567 * [3GPP TS38.212, section 5.4.2.1] 568 */ 569 uint32_t eb; 570 /** The total number of CBs in the TB or partial TB 571 * [1:RTE_BBDEV_LDPC_MAX_CODE_BLOCKS] 572 */ 573 uint8_t c; 574 /** The index of the first CB in the inbound mbuf data, default is 0 */ 575 uint8_t r; 576 /** The number of CBs that use Ea before switching to Eb, [0:63] */ 577 uint8_t cab; 578 }; 579 580 /** Operation structure for Turbo encode. 581 * An operation can be performed on one CB at a time "CB-mode". 582 * An operation can pbe erformd on one or multiple CBs that logically 583 * belong to one TB "TB-mode". 584 * 585 * In CB-mode, CRC24A/B is an optional operation. K size parameter is not 586 * affected by CRC24A/B inclusion, this only affects the inbound mbuf data 587 * length. Not all BBDEV PMDs are capable of CRC24A/B calculation. Flags 588 * RTE_BBDEV_TURBO_CRC_24A_ATTACH and RTE_BBDEV_TURBO_CRC_24B_ATTACH informs 589 * the application with relevant capability. These flags can be set in the 590 * op_flags parameter to indicate BBDEV to calculate and append CRC24A to CB 591 * before going forward with Turbo encoding. 592 * 593 * In TB-mode, CRC24A is assumed to be pre-calculated and appended to the 594 * inbound TB mbuf data buffer. 595 * 596 * The output mbuf data structure is expected to be allocated by the 597 * application with enough room for the output data. 598 */ 599 struct rte_bbdev_op_turbo_enc { 600 /** The input CB or TB data */ 601 struct rte_bbdev_op_data input; 602 /** The rate matched CB or TB output buffer */ 603 struct rte_bbdev_op_data output; 604 /** Flags from rte_bbdev_op_te_flag_bitmasks */ 605 uint32_t op_flags; 606 607 /** Rv index for rate matching [0:3] */ 608 uint8_t rv_index; 609 /** [0 - TB : 1 - CB] */ 610 uint8_t code_block_mode; 611 union { 612 /** Struct which stores Code Block specific parameters */ 613 struct rte_bbdev_op_enc_turbo_cb_params cb_params; 614 /** Struct which stores Transport Block specific parameters */ 615 struct rte_bbdev_op_enc_turbo_tb_params tb_params; 616 }; 617 }; 618 619 /** Operation structure for LDPC encode. 620 * An operation can be performed on one CB at a time "CB-mode". 621 * An operation can be performed on one or multiple CBs that logically 622 * belong to a TB "TB-mode". 623 * 624 * The input data is the CB or TB input to the decoder. 625 * 626 * The output data is the ratematched CB or TB data, or the output after 627 * bit-selection if RTE_BBDEV_LDPC_INTERLEAVER_BYPASS is set. 628 * 629 * The output mbuf data structure is expected to be allocated by the 630 * application with enough room for the output data. 631 */ 632 struct rte_bbdev_op_ldpc_enc { 633 /** The input TB or CB data */ 634 struct rte_bbdev_op_data input; 635 /** The rate matched TB or CB output buffer */ 636 struct rte_bbdev_op_data output; 637 638 /** Flags from rte_bbdev_op_ldpcenc_flag_bitmasks */ 639 uint32_t op_flags; 640 641 /** Rate matching redundancy version */ 642 uint8_t rv_index; 643 /** 1: LDPC Base graph 1, 2: LDPC Base graph 2. 644 * [3GPP TS38.212, section 5.2.2] 645 */ 646 uint8_t basegraph; 647 /** Zc, LDPC lifting size. 648 * [3GPP TS38.212, section 5.2.2] 649 */ 650 uint16_t z_c; 651 /** Ncb, length of the circular buffer in bits. 652 * [3GPP TS38.212, section 5.4.2.1] 653 */ 654 uint16_t n_cb; 655 /** Qm, modulation order {2,4,6,8,10}. 656 * [3GPP TS38.212, section 5.4.2.2] 657 */ 658 uint8_t q_m; 659 /** Number of Filler bits, n_filler = K – K’ 660 * [3GPP TS38.212 section 5.2.2] 661 */ 662 uint16_t n_filler; 663 /** [0 - TB : 1 - CB] */ 664 uint8_t code_block_mode; 665 union { 666 /** Struct which stores Code Block specific parameters */ 667 struct rte_bbdev_op_enc_ldpc_cb_params cb_params; 668 /** Struct which stores Transport Block specific parameters */ 669 struct rte_bbdev_op_enc_ldpc_tb_params tb_params; 670 }; 671 }; 672 673 /** List of the capabilities for the Turbo Decoder */ 674 struct rte_bbdev_op_cap_turbo_dec { 675 /** Flags from rte_bbdev_op_td_flag_bitmasks */ 676 uint32_t capability_flags; 677 /** Maximal LLR absolute value. Acceptable LLR values lie in range 678 * [-max_llr_modulus, max_llr_modulus]. 679 */ 680 int8_t max_llr_modulus; 681 /** Num input code block buffers */ 682 uint8_t num_buffers_src; /**< Num input code block buffers */ 683 /** Num hard output code block buffers */ 684 uint8_t num_buffers_hard_out; 685 /** Num soft output code block buffers if supported by the driver */ 686 uint8_t num_buffers_soft_out; 687 }; 688 689 /** List of the capabilities for the Turbo Encoder */ 690 struct rte_bbdev_op_cap_turbo_enc { 691 /** Flags from rte_bbdev_op_te_flag_bitmasks */ 692 uint32_t capability_flags; 693 /** Num input code block buffers */ 694 uint8_t num_buffers_src; 695 /** Num output code block buffers */ 696 uint8_t num_buffers_dst; 697 }; 698 699 /** List of the capabilities for the LDPC Decoder */ 700 struct rte_bbdev_op_cap_ldpc_dec { 701 /** Flags from rte_bbdev_op_ldpcdec_flag_bitmasks */ 702 uint32_t capability_flags; 703 /** LLR size in bits. LLR is a two’s complement number. */ 704 int8_t llr_size; 705 /** LLR numbers of decimals bit for arithmetic representation */ 706 int8_t llr_decimals; 707 /** Amount of memory for HARQ in external DDR in MB */ 708 uint16_t harq_memory_size; 709 /** Num input code block buffers */ 710 uint16_t num_buffers_src; 711 /** Num hard output code block buffers */ 712 uint16_t num_buffers_hard_out; 713 /** Num soft output code block buffers if supported by the driver */ 714 uint16_t num_buffers_soft_out; 715 }; 716 717 /** List of the capabilities for the LDPC Encoder */ 718 struct rte_bbdev_op_cap_ldpc_enc { 719 /** Flags from rte_bbdev_op_ldpcenc_flag_bitmasks */ 720 uint32_t capability_flags; 721 /** Num input code block buffers */ 722 uint16_t num_buffers_src; 723 /** Num output code block buffers */ 724 uint16_t num_buffers_dst; 725 }; 726 727 /** Different operation types supported by the device */ 728 enum rte_bbdev_op_type { 729 RTE_BBDEV_OP_NONE, /**< Dummy operation that does nothing */ 730 RTE_BBDEV_OP_TURBO_DEC, /**< Turbo decode */ 731 RTE_BBDEV_OP_TURBO_ENC, /**< Turbo encode */ 732 RTE_BBDEV_OP_LDPC_DEC, /**< LDPC decode */ 733 RTE_BBDEV_OP_LDPC_ENC, /**< LDPC encode */ 734 RTE_BBDEV_OP_TYPE_COUNT, /**< Count of different op types */ 735 }; 736 737 /** Bit indexes of possible errors reported through status field */ 738 enum { 739 RTE_BBDEV_DRV_ERROR, 740 RTE_BBDEV_DATA_ERROR, 741 RTE_BBDEV_CRC_ERROR, 742 RTE_BBDEV_SYNDROME_ERROR 743 }; 744 745 /** Structure specifying a single encode operation */ 746 struct rte_bbdev_enc_op { 747 /** Status of operation that was performed */ 748 int status; 749 /** Mempool which op instance is in */ 750 struct rte_mempool *mempool; 751 /** Opaque pointer for user data */ 752 void *opaque_data; 753 union { 754 /** Contains turbo decoder specific parameters */ 755 struct rte_bbdev_op_turbo_enc turbo_enc; 756 /** Contains LDPC decoder specific parameters */ 757 struct rte_bbdev_op_ldpc_enc ldpc_enc; 758 }; 759 }; 760 761 /** Structure specifying a single decode operation */ 762 struct rte_bbdev_dec_op { 763 /** Status of operation that was performed */ 764 int status; 765 /** Mempool which op instance is in */ 766 struct rte_mempool *mempool; 767 /** Opaque pointer for user data */ 768 void *opaque_data; 769 union { 770 /** Contains turbo decoder specific parameters */ 771 struct rte_bbdev_op_turbo_dec turbo_dec; 772 /** Contains LDPC decoder specific parameters */ 773 struct rte_bbdev_op_ldpc_dec ldpc_dec; 774 }; 775 }; 776 777 /** Operation capabilities supported by a device */ 778 struct rte_bbdev_op_cap { 779 enum rte_bbdev_op_type type; /**< Type of operation */ 780 union { 781 struct rte_bbdev_op_cap_turbo_dec turbo_dec; 782 struct rte_bbdev_op_cap_turbo_enc turbo_enc; 783 struct rte_bbdev_op_cap_ldpc_dec ldpc_dec; 784 struct rte_bbdev_op_cap_ldpc_enc ldpc_enc; 785 } cap; /**< Operation-type specific capabilities */ 786 }; 787 788 /** @internal Private data structure stored with operation pool. */ 789 struct rte_bbdev_op_pool_private { 790 enum rte_bbdev_op_type type; /**< Type of operations in a pool */ 791 }; 792 793 /** 794 * Converts queue operation type from enum to string 795 * 796 * @param op_type 797 * Operation type as enum 798 * 799 * @returns 800 * Operation type as string or NULL if op_type is invalid 801 * 802 */ 803 __rte_experimental 804 const char* 805 rte_bbdev_op_type_str(enum rte_bbdev_op_type op_type); 806 807 /** 808 * Creates a bbdev operation mempool 809 * 810 * @param name 811 * Pool name. 812 * @param type 813 * Operation type, use RTE_BBDEV_OP_NONE for a pool which supports all 814 * operation types. 815 * @param num_elements 816 * Number of elements in the pool. 817 * @param cache_size 818 * Number of elements to cache on an lcore, see rte_mempool_create() for 819 * further details about cache size. 820 * @param socket_id 821 * Socket to allocate memory on. 822 * 823 * @return 824 * - Pointer to a mempool on success, 825 * - NULL pointer on failure. 826 */ 827 __rte_experimental 828 struct rte_mempool * 829 rte_bbdev_op_pool_create(const char *name, enum rte_bbdev_op_type type, 830 unsigned int num_elements, unsigned int cache_size, 831 int socket_id); 832 833 /** 834 * Bulk allocate encode operations from a mempool with parameter defaults reset. 835 * 836 * @param mempool 837 * Operation mempool, created by rte_bbdev_op_pool_create(). 838 * @param ops 839 * Output array to place allocated operations 840 * @param num_ops 841 * Number of operations to allocate 842 * 843 * @returns 844 * - 0 on success 845 * - EINVAL if invalid mempool is provided 846 */ 847 __rte_experimental 848 static inline int 849 rte_bbdev_enc_op_alloc_bulk(struct rte_mempool *mempool, 850 struct rte_bbdev_enc_op **ops, uint16_t num_ops) 851 { 852 struct rte_bbdev_op_pool_private *priv; 853 int ret; 854 855 /* Check type */ 856 priv = (struct rte_bbdev_op_pool_private *) 857 rte_mempool_get_priv(mempool); 858 if (unlikely((priv->type != RTE_BBDEV_OP_TURBO_ENC) && 859 (priv->type != RTE_BBDEV_OP_LDPC_ENC))) 860 return -EINVAL; 861 862 /* Get elements */ 863 ret = rte_mempool_get_bulk(mempool, (void **)ops, num_ops); 864 if (unlikely(ret < 0)) 865 return ret; 866 867 return 0; 868 } 869 870 /** 871 * Bulk allocate decode operations from a mempool with parameter defaults reset. 872 * 873 * @param mempool 874 * Operation mempool, created by rte_bbdev_op_pool_create(). 875 * @param ops 876 * Output array to place allocated operations 877 * @param num_ops 878 * Number of operations to allocate 879 * 880 * @returns 881 * - 0 on success 882 * - EINVAL if invalid mempool is provided 883 */ 884 __rte_experimental 885 static inline int 886 rte_bbdev_dec_op_alloc_bulk(struct rte_mempool *mempool, 887 struct rte_bbdev_dec_op **ops, uint16_t num_ops) 888 { 889 struct rte_bbdev_op_pool_private *priv; 890 int ret; 891 892 /* Check type */ 893 priv = (struct rte_bbdev_op_pool_private *) 894 rte_mempool_get_priv(mempool); 895 if (unlikely((priv->type != RTE_BBDEV_OP_TURBO_DEC) && 896 (priv->type != RTE_BBDEV_OP_LDPC_DEC))) 897 return -EINVAL; 898 899 /* Get elements */ 900 ret = rte_mempool_get_bulk(mempool, (void **)ops, num_ops); 901 if (unlikely(ret < 0)) 902 return ret; 903 904 return 0; 905 } 906 907 /** 908 * Free decode operation structures that were allocated by 909 * rte_bbdev_dec_op_alloc_bulk(). 910 * All structures must belong to the same mempool. 911 * 912 * @param ops 913 * Operation structures 914 * @param num_ops 915 * Number of structures 916 */ 917 __rte_experimental 918 static inline void 919 rte_bbdev_dec_op_free_bulk(struct rte_bbdev_dec_op **ops, unsigned int num_ops) 920 { 921 if (num_ops > 0) 922 rte_mempool_put_bulk(ops[0]->mempool, (void **)ops, num_ops); 923 } 924 925 /** 926 * Free encode operation structures that were allocated by 927 * rte_bbdev_enc_op_alloc_bulk(). 928 * All structures must belong to the same mempool. 929 * 930 * @param ops 931 * Operation structures 932 * @param num_ops 933 * Number of structures 934 */ 935 __rte_experimental 936 static inline void 937 rte_bbdev_enc_op_free_bulk(struct rte_bbdev_enc_op **ops, unsigned int num_ops) 938 { 939 if (num_ops > 0) 940 rte_mempool_put_bulk(ops[0]->mempool, (void **)ops, num_ops); 941 } 942 943 #ifdef __cplusplus 944 } 945 #endif 946 947 #endif /* _RTE_BBDEV_OP_H_ */ 948