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