aal/spec/rte_bbdev_op.h

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