From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by dpdk.space (Postfix) with ESMTP id 30732A046B for ; Mon, 24 Jun 2019 04:53:47 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id F3CC31BF7C; Mon, 24 Jun 2019 04:53:16 +0200 (CEST) Received: from mga14.intel.com (mga14.intel.com [192.55.52.115]) by dpdk.org (Postfix) with ESMTP id EA7FF1BF6B for ; Mon, 24 Jun 2019 04:53:02 +0200 (CEST) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga103.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 23 Jun 2019 19:52:59 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.63,410,1557212400"; d="scan'208";a="183991194" Received: from skx-5gnr-sc12-4.sc.intel.com ([172.25.69.210]) by fmsmga004.fm.intel.com with ESMTP; 23 Jun 2019 19:52:59 -0700 From: Nicolas Chautru To: akhil.goyal@nxp.com, dev@dpdk.org Cc: thomas@monjalon.net, ferruh.yigit@intel.com, amr.mokhtar@intel.com, Nicolas Chautru Date: Sun, 23 Jun 2019 19:52:50 -0700 Message-Id: <1561344776-43990-5-git-send-email-nicolas.chautru@intel.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1561344776-43990-1-git-send-email-nicolas.chautru@intel.com> References: <1561136352-32198-2-git-send-email-nicolas.chautru@intel.com> <1561344776-43990-1-git-send-email-nicolas.chautru@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=a Content-Transfer-Encoding: 8bit Subject: [dpdk-dev] [PATCH v4 04/10] bbdev: extension of BBDEV API for 5G FEC X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Extension to BBDEV operations to support 5G on top of existing 4G operations. Signed-off-by: Nicolas Chautru --- lib/librte_bbdev/rte_bbdev.c | 22 +- lib/librte_bbdev/rte_bbdev.h | 135 +++++++++- lib/librte_bbdev/rte_bbdev_op.h | 567 ++++++++++++++++++++++++++++++++-------- 3 files changed, 602 insertions(+), 122 deletions(-) diff --git a/lib/librte_bbdev/rte_bbdev.c b/lib/librte_bbdev/rte_bbdev.c index a3ab5d9..7e4acfc 100644 --- a/lib/librte_bbdev/rte_bbdev.c +++ b/lib/librte_bbdev/rte_bbdev.c @@ -6,7 +6,6 @@ #include #include -#include #include #include #include @@ -215,7 +214,7 @@ struct rte_bbdev * __rte_experimental bbdev->data->dev_id = dev_id; bbdev->state = RTE_BBDEV_INITIALIZED; - ret = strlcpy(bbdev->data->name, name, RTE_BBDEV_NAME_MAX_LEN); + ret = snprintf(bbdev->data->name, RTE_BBDEV_NAME_MAX_LEN, "%s", name); if ((ret < 0) || (ret >= RTE_BBDEV_NAME_MAX_LEN)) { rte_bbdev_log(ERR, "Copying device name \"%s\" failed", name); return NULL; @@ -499,7 +498,7 @@ struct rte_bbdev * __rte_experimental if (conf->op_type == RTE_BBDEV_OP_TURBO_DEC && conf->priority > dev_info.max_ul_queue_priority) { rte_bbdev_log(ERR, - "Priority (%u) of queue %u of bdev %u must be <= %u", + "Priority (%u) of queue %u of bbdev %u must be <= %u", conf->priority, queue_id, dev_id, dev_info.max_ul_queue_priority); return -EINVAL; @@ -507,7 +506,7 @@ struct rte_bbdev * __rte_experimental if (conf->op_type == RTE_BBDEV_OP_TURBO_ENC && conf->priority > dev_info.max_dl_queue_priority) { rte_bbdev_log(ERR, - "Priority (%u) of queue %u of bdev %u must be <= %u", + "Priority (%u) of queue %u of bbdev %u must be <= %u", conf->priority, queue_id, dev_id, dev_info.max_dl_queue_priority); return -EINVAL; @@ -796,7 +795,7 @@ struct rte_bbdev * __rte_experimental memset(dev_info, 0, sizeof(*dev_info)); dev_info->dev_name = dev->data->name; dev_info->num_queues = dev->data->num_queues; - dev_info->bus = rte_bus_find_by_device(dev->device); + dev_info->device = dev->device; dev_info->socket_id = dev->data->socket_id; dev_info->started = dev->data->started; @@ -847,6 +846,12 @@ struct rte_bbdev * __rte_experimental case RTE_BBDEV_OP_TURBO_ENC: result = sizeof(struct rte_bbdev_enc_op); break; + case RTE_BBDEV_OP_LDPC_DEC: + result = sizeof(struct rte_bbdev_dec_op); + break; + case RTE_BBDEV_OP_LDPC_ENC: + result = sizeof(struct rte_bbdev_enc_op); + break; default: break; } @@ -861,11 +866,12 @@ struct rte_bbdev * __rte_experimental { enum rte_bbdev_op_type type = *(enum rte_bbdev_op_type *)arg; - if (type == RTE_BBDEV_OP_TURBO_DEC) { + if (type == RTE_BBDEV_OP_TURBO_DEC || type == RTE_BBDEV_OP_LDPC_DEC) { struct rte_bbdev_dec_op *op = element; memset(op, 0, mempool->elt_size); op->mempool = mempool; - } else if (type == RTE_BBDEV_OP_TURBO_ENC) { + } else if (type == RTE_BBDEV_OP_TURBO_ENC || + type == RTE_BBDEV_OP_LDPC_ENC) { struct rte_bbdev_enc_op *op = element; memset(op, 0, mempool->elt_size); op->mempool = mempool; @@ -1117,6 +1123,8 @@ struct rte_mempool * __rte_experimental "RTE_BBDEV_OP_NONE", "RTE_BBDEV_OP_TURBO_DEC", "RTE_BBDEV_OP_TURBO_ENC", + "RTE_BBDEV_OP_LDPC_DEC", + "RTE_BBDEV_OP_LDPC_ENC", }; if (op_type < RTE_BBDEV_OP_TYPE_COUNT) diff --git a/lib/librte_bbdev/rte_bbdev.h b/lib/librte_bbdev/rte_bbdev.h index d131692..a0e9b1a 100644 --- a/lib/librte_bbdev/rte_bbdev.h +++ b/lib/librte_bbdev/rte_bbdev.h @@ -161,7 +161,7 @@ struct rte_bbdev_queue_conf { /** * Start a device. - * This is the last step needed before enqueuing operations is possible. + * This is the last step needed before enqueueing operations is possible. * * @param dev_id * The identifier of the device. @@ -313,7 +313,7 @@ struct rte_bbdev_driver_info { struct rte_bbdev_info { int socket_id; /**< NUMA socket that device is on */ const char *dev_name; /**< Unique device name */ - const struct rte_bus *bus; /**< Bus information */ + const struct rte_device *device; /**< Device Information */ uint16_t num_queues; /**< Number of queues currently configured */ bool started; /**< Set if device is currently started */ struct rte_bbdev_driver_info drv; /**< Info from device driver */ @@ -433,6 +433,14 @@ struct __rte_cache_aligned rte_bbdev { rte_bbdev_dequeue_enc_ops_t dequeue_enc_ops; /**< Dequeue decode function */ rte_bbdev_dequeue_dec_ops_t dequeue_dec_ops; + /**< Enqueue encode function */ + rte_bbdev_enqueue_enc_ops_t enqueue_ldpc_enc_ops; + /**< Enqueue decode function */ + rte_bbdev_enqueue_dec_ops_t enqueue_ldpc_dec_ops; + /**< Dequeue encode function */ + rte_bbdev_dequeue_enc_ops_t dequeue_ldpc_enc_ops; + /**< Dequeue decode function */ + rte_bbdev_dequeue_dec_ops_t dequeue_ldpc_dec_ops; const struct rte_bbdev_ops *dev_ops; /**< Functions exported by PMD */ struct rte_bbdev_data *data; /**< Pointer to device data */ enum rte_bbdev_state state; /**< If device is currently used or not */ @@ -506,6 +514,67 @@ struct __rte_cache_aligned rte_bbdev { } /** + * Enqueue a burst of processed encode operations to a queue of the device. + * This functions only enqueues as many operations as currently possible and + * does not block until @p num_ops entries in the queue are available. + * This function does not provide any error notification to avoid the + * corresponding overhead. + * + * @param dev_id + * The identifier of the device. + * @param queue_id + * The index of the queue. + * @param ops + * Pointer array containing operations to be enqueued Must have at least + * @p num_ops entries + * @param num_ops + * The maximum number of operations to enqueue. + * + * @return + * The number of operations actually enqueued (this is the number of processed + * entries in the @p ops array). + */ +static inline uint16_t __rte_experimental +rte_bbdev_enqueue_ldpc_enc_ops(uint16_t dev_id, uint16_t queue_id, + struct rte_bbdev_enc_op **ops, uint16_t num_ops) +{ + struct rte_bbdev *dev = &rte_bbdev_devices[dev_id]; + struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id]; + return dev->enqueue_ldpc_enc_ops(q_data, ops, num_ops); +} + +/** + * Enqueue a burst of processed decode operations to a queue of the device. + * This functions only enqueues as many operations as currently possible and + * does not block until @p num_ops entries in the queue are available. + * This function does not provide any error notification to avoid the + * corresponding overhead. + * + * @param dev_id + * The identifier of the device. + * @param queue_id + * The index of the queue. + * @param ops + * Pointer array containing operations to be enqueued Must have at least + * @p num_ops entries + * @param num_ops + * The maximum number of operations to enqueue. + * + * @return + * The number of operations actually enqueued (this is the number of processed + * entries in the @p ops array). + */ +static inline uint16_t __rte_experimental +rte_bbdev_enqueue_ldpc_dec_ops(uint16_t dev_id, uint16_t queue_id, + struct rte_bbdev_dec_op **ops, uint16_t num_ops) +{ + struct rte_bbdev *dev = &rte_bbdev_devices[dev_id]; + struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id]; + return dev->enqueue_ldpc_dec_ops(q_data, ops, num_ops); +} + + +/** * Dequeue a burst of processed encode operations from a queue of the device. * This functions returns only the current contents of the queue, and does not * block until @ num_ops is available. @@ -566,6 +635,68 @@ struct __rte_cache_aligned rte_bbdev { return dev->dequeue_dec_ops(q_data, ops, num_ops); } + +/** + * Dequeue a burst of processed encode operations from a queue of the device. + * This functions returns only the current contents of the queue, and does not + * block until @ num_ops is available. + * This function does not provide any error notification to avoid the + * corresponding overhead. + * + * @param dev_id + * The identifier of the device. + * @param queue_id + * The index of the queue. + * @param ops + * Pointer array where operations will be dequeued to. Must have at least + * @p num_ops entries + * @param num_ops + * The maximum number of operations to dequeue. + * + * @return + * The number of operations actually dequeued (this is the number of entries + * copied into the @p ops array). + */ +static inline uint16_t __rte_experimental +rte_bbdev_dequeue_ldpc_enc_ops(uint16_t dev_id, uint16_t queue_id, + struct rte_bbdev_enc_op **ops, uint16_t num_ops) +{ + struct rte_bbdev *dev = &rte_bbdev_devices[dev_id]; + struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id]; + return dev->dequeue_ldpc_enc_ops(q_data, ops, num_ops); +} + +/** + * Dequeue a burst of processed decode operations from a queue of the device. + * This functions returns only the current contents of the queue, and does not + * block until @ num_ops is available. + * This function does not provide any error notification to avoid the + * corresponding overhead. + * + * @param dev_id + * The identifier of the device. + * @param queue_id + * The index of the queue. + * @param ops + * Pointer array where operations will be dequeued to. Must have at least + * @p num_ops entries + * @param num_ops + * The maximum number of operations to dequeue. + * + * @return + * The number of operations actually dequeued (this is the number of entries + * copied into the @p ops array). + */ + +static inline uint16_t __rte_experimental +rte_bbdev_dequeue_ldpc_dec_ops(uint16_t dev_id, uint16_t queue_id, + struct rte_bbdev_dec_op **ops, uint16_t num_ops) +{ + struct rte_bbdev *dev = &rte_bbdev_devices[dev_id]; + struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id]; + return dev->dequeue_ldpc_dec_ops(q_data, ops, num_ops); +} + /** Definitions of device event types */ enum rte_bbdev_event_type { RTE_BBDEV_EVENT_UNKNOWN, /**< unknown event type */ diff --git a/lib/librte_bbdev/rte_bbdev_op.h b/lib/librte_bbdev/rte_bbdev_op.h index f61c115..e80d2ce 100644 --- a/lib/librte_bbdev/rte_bbdev_op.h +++ b/lib/librte_bbdev/rte_bbdev_op.h @@ -31,57 +31,61 @@ #define RTE_BBDEV_TURBO_MAX_TB_SIZE (391656) /* Maximum size of Code Block (36.212, Table 5.1.3-3) */ #define RTE_BBDEV_TURBO_MAX_CB_SIZE (6144) +/* Maximum size of Code Block */ +#define RTE_BBDEV_LDPC_MAX_CB_SIZE (8448) /* Minimum size of Code Block (36.212, Table 5.1.3-3) */ #define RTE_BBDEV_TURBO_MIN_CB_SIZE (40) /* Maximum size of circular buffer */ #define RTE_BBDEV_TURBO_MAX_KW (18528) /* - * Maximum number of Code Blocks in Transport Block. It is calculated based on - * maximum size of one Code Block and one Transport Block (considering CRC24A - * and CRC24B): + * Turbo: Maximum number of Code Blocks in Transport Block. It is calculated + * based on maximum size of one Code Block and one Transport Block + * (considering CRC24A and CRC24B): * (391656 + 24) / (6144 - 24) = 64 */ #define RTE_BBDEV_TURBO_MAX_CODE_BLOCKS (64) +/* LDPC: Maximum number of Code Blocks in Transport Block.*/ +#define RTE_BBDEV_LDPC_MAX_CODE_BLOCKS (256) /** Flags for turbo decoder operation and capability structure */ enum rte_bbdev_op_td_flag_bitmasks { - /**< If sub block de-interleaving is to be performed. */ + /** If sub block de-interleaving is to be performed. */ RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE = (1ULL << 0), - /**< To use CRC Type 24B (otherwise use CRC Type 24A). */ + /** To use CRC Type 24B (otherwise use CRC Type 24A). */ RTE_BBDEV_TURBO_CRC_TYPE_24B = (1ULL << 1), - /**< If turbo equalization is to be performed. */ + /** If turbo equalization is to be performed. */ RTE_BBDEV_TURBO_EQUALIZER = (1ULL << 2), - /**< If set, saturate soft output to +/-127 */ + /** If set, saturate soft output to +/-127 */ RTE_BBDEV_TURBO_SOFT_OUT_SATURATE = (1ULL << 3), - /**< Set to 1 to start iteration from even, else odd; one iteration = + /** Set to 1 to start iteration from even, else odd; one iteration = * max_iteration + 0.5 */ RTE_BBDEV_TURBO_HALF_ITERATION_EVEN = (1ULL << 4), - /**< If 0, TD stops after CRC matches; else if 1, runs to end of next + /** If 0, TD stops after CRC matches; else if 1, runs to end of next * odd iteration after CRC matches */ RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH = (1ULL << 5), - /**< Set if soft output is required to be output */ + /** Set if soft output is required to be output */ RTE_BBDEV_TURBO_SOFT_OUTPUT = (1ULL << 6), - /**< Set to enable early termination mode */ + /** Set to enable early termination mode */ RTE_BBDEV_TURBO_EARLY_TERMINATION = (1ULL << 7), - /**< Set if a device supports decoder dequeue interrupts */ + /** Set if a device supports decoder dequeue interrupts */ RTE_BBDEV_TURBO_DEC_INTERRUPTS = (1ULL << 9), - /**< Set if positive LLR encoded input is supported. Positive LLR value + /** Set if positive LLR encoded input is supported. Positive LLR value * represents the level of confidence for bit '1', and vice versa for * bit '0'. * This is mutually exclusive with RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN * when used to formalize the input data format. */ RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN = (1ULL << 10), - /**< Set if negative LLR encoded input is supported. Negative LLR value + /** Set if negative LLR encoded input is supported. Negative LLR value * represents the level of confidence for bit '1', and vice versa for * bit '0'. * This is mutually exclusive with RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN * when used to formalize the input data format. */ RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN = (1ULL << 11), - /**< Set if positive LLR soft output is supported. Positive LLR value + /** Set if positive LLR soft output is supported. Positive LLR value * represents the level of confidence for bit '1', and vice versa for * bit '0'. * This is mutually exclusive with @@ -89,7 +93,7 @@ enum rte_bbdev_op_td_flag_bitmasks { * the input data format. */ RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT = (1ULL << 12), - /**< Set if negative LLR soft output is supported. Negative LLR value + /** Set if negative LLR soft output is supported. Negative LLR value * represents the level of confidence for bit '1', and vice versa for * bit '0'. * This is mutually exclusive with @@ -97,43 +101,114 @@ enum rte_bbdev_op_td_flag_bitmasks { * input data format. */ RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT = (1ULL << 13), - /**< Set if driver supports flexible parallel MAP engine decoding. If + /** Set if driver supports flexible parallel MAP engine decoding. If * not supported, num_maps (number of MAP engines) argument is unusable. */ RTE_BBDEV_TURBO_MAP_DEC = (1ULL << 14), - /**< Set if a device supports scatter-gather functionality */ + /** Set if a device supports scatter-gather functionality */ RTE_BBDEV_TURBO_DEC_SCATTER_GATHER = (1ULL << 15), - /**< Set to keep CRC24B bits appended while decoding. Only usable when + /** Set to keep CRC24B bits appended while decoding. Only usable when * decoding Transport Blocks (code_block_mode = 0). */ RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP = (1ULL << 16) }; + /** Flags for turbo encoder operation and capability structure */ enum rte_bbdev_op_te_flag_bitmasks { - /**< Ignore rv_index and set K0 = 0 */ + /** Ignore rv_index and set K0 = 0 */ RTE_BBDEV_TURBO_RV_INDEX_BYPASS = (1ULL << 0), - /**< If rate matching is to be performed */ + /** If rate matching is to be performed */ RTE_BBDEV_TURBO_RATE_MATCH = (1ULL << 1), - /**< This bit must be set to enable CRC-24B generation */ + /** This bit must be set to enable CRC-24B generation */ RTE_BBDEV_TURBO_CRC_24B_ATTACH = (1ULL << 2), - /**< This bit must be set to enable CRC-24A generation */ + /** This bit must be set to enable CRC-24A generation */ RTE_BBDEV_TURBO_CRC_24A_ATTACH = (1ULL << 3), - /**< Set if a device supports encoder dequeue interrupts */ + /** Set if a device supports encoder dequeue interrupts */ RTE_BBDEV_TURBO_ENC_INTERRUPTS = (1ULL << 4), - /**< Set if a device supports scatter-gather functionality */ + /** Set if a device supports scatter-gather functionality */ RTE_BBDEV_TURBO_ENC_SCATTER_GATHER = (1ULL << 5) }; -/**< Data input and output buffer for BBDEV operations */ +/** Flags for LDPC decoder operation and capability structure */ +enum rte_bbdev_op_ldpcdec_flag_bitmasks { + /** Set for transport block CRC-24A checking */ + RTE_BBDEV_LDPC_CRC_TYPE_24A_CHECK = (1ULL << 0), + /** Set for code block CRC-24B checking */ + RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK = (1ULL << 1), + /** Set to drop the last CRC bits decoding output */ + RTE_BBDEV_LDPC_CRC_TYPE_24B_DROP = (1ULL << 2), + /** Set for bit-level de-interleaver bypass on Rx stream. */ + RTE_BBDEV_LDPC_DEINTERLEAVER_BYPASS = (1ULL << 3), + /** Set for HARQ combined input stream enable. */ + RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE = (1ULL << 4), + /** Set for HARQ combined output stream enable. */ + RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE = (1ULL << 5), + /** Set for LDPC decoder bypass. + * RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE must be set. + */ + RTE_BBDEV_LDPC_DECODE_BYPASS = (1ULL << 6), + /** Set for soft-output stream enable */ + RTE_BBDEV_LDPC_SOFT_OUT_ENABLE = (1ULL << 7), + /** Set for Rate-Matching bypass on soft-out stream. */ + RTE_BBDEV_LDPC_SOFT_OUT_RM_BYPASS = (1ULL << 8), + /** Set for bit-level de-interleaver bypass on soft-output stream. */ + RTE_BBDEV_LDPC_SOFT_OUT_DEINTERLEAVER_BYPASS = (1ULL << 9), + /** Set for iteration stopping on successful decode condition + * i.e. a successful syndrome check. + */ + RTE_BBDEV_LDPC_ITERATION_STOP_ENABLE = (1ULL << 10), + /** Set if a device supports decoder dequeue interrupts. */ + RTE_BBDEV_LDPC_DEC_INTERRUPTS = (1ULL << 11), + /** Set if a device supports scatter-gather functionality. */ + RTE_BBDEV_LDPC_DEC_SCATTER_GATHER = (1ULL << 12), + /** Set if a device supports input/output HARQ compression. */ + RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION = (1ULL << 13), + /** Set if a device supports input LLR compression. */ + RTE_BBDEV_LDPC_LLR_COMPRESSION = (1ULL << 14), + /** Set if a device supports HARQ input from + * device's internal memory. + */ + RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE = (1ULL << 15), + /** Set if a device supports HARQ output to + * device's internal memory. + */ + RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE = (1ULL << 16), + /** Set if a device supports loop-back access to + * HARQ internal memory. Intended for troubleshooting. + */ + RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK = (1ULL << 17) +}; + +/** Flags for LDPC encoder operation and capability structure */ +enum rte_bbdev_op_ldpcenc_flag_bitmasks { + /** Set for bit-level interleaver bypass on output stream. */ + RTE_BBDEV_LDPC_INTERLEAVER_BYPASS = (1ULL << 0), + /** If rate matching is to be performed */ + RTE_BBDEV_LDPC_RATE_MATCH = (1ULL << 1), + /** Set for transport block CRC-24A attach */ + RTE_BBDEV_LDPC_CRC_24A_ATTACH = (1ULL << 2), + /** Set for code block CRC-24B attach */ + RTE_BBDEV_LDPC_CRC_24B_ATTACH = (1ULL << 3), + /** Set for code block CRC-16 attach */ + RTE_BBDEV_LDPC_CRC_16_ATTACH = (1ULL << 4), + /** Set if a device supports encoder dequeue interrupts. */ + RTE_BBDEV_LDPC_ENC_INTERRUPTS = (1ULL << 5), + /** Set if a device supports scatter-gather functionality. */ + RTE_BBDEV_LDPC_ENC_SCATTER_GATHER = (1ULL << 6), + /** Set if a device supports concatenation of non byte aligned output */ + RTE_BBDEV_LDPC_ENC_CONCATENATION = (1ULL << 7) +}; + +/** Data input and output buffer for BBDEV operations */ struct rte_bbdev_op_data { - /**< The mbuf data structure representing the data for BBDEV operation. + /** The mbuf data structure representing the data for BBDEV operation. * * This mbuf pointer can point to one Code Block (CB) data buffer or * multiple CBs contiguously located next to each other. * A Transport Block (TB) represents a whole piece of data that is * divided into one or more CBs. Maximum number of CBs can be contained - * in one TB is defined by RTE_BBDEV_TURBO_MAX_CODE_BLOCKS. + * in one TB is defined by RTE_BBDEV_(TURBO/LDPC)_MAX_CODE_BLOCKS. * * An mbuf data structure cannot represent more than one TB. The * smallest piece of data that can be contained in one mbuf is one CB. @@ -145,8 +220,8 @@ struct rte_bbdev_op_data { * then it is capable of collecting (gathering) non-contiguous * (scattered) data from multiple locations in the memory. * This capability is reported by the capability flags: - * - RTE_BBDEV_TURBO_ENC_SCATTER_GATHER and - * - RTE_BBDEV_TURBO_DEC_SCATTER_GATHER. + * - RTE_BBDEV_(TURBO/LDPC)_ENC_SCATTER_GATHER and + * - RTE_BBDEV_(TURBO/LDPC)_DEC_SCATTER_GATHER. * Only if a BBDEV PMD supports this feature, chained mbuf data * structures are accepted. A chained mbuf can represent one * non-contiguous CB or multiple non-contiguous CBs. @@ -157,7 +232,7 @@ struct rte_bbdev_op_data { * was a chained mbuf. */ struct rte_mbuf *data; - /**< The starting point of the BBDEV (encode/decode) operation, + /** The starting point of the BBDEV (encode/decode) operation, * in bytes. * * BBDEV starts to read data past this offset. @@ -165,13 +240,13 @@ struct rte_bbdev_op_data { * segment. */ uint32_t offset; - /**< The total data length to be processed in one operation, in bytes. + /** The total data length to be processed in one operation, in bytes. * * In case the mbuf data is representing one CB, this is the length of * the CB undergoing the operation. * If it's for multiple CBs, this is the total length of those CBs * undergoing the operation. - * If it's for one TB, this is the total length of the TB under + * If it is for one TB, this is the total length of the TB under * operation. * * In case of chained mbuf, this data length includes the lengths of the @@ -180,51 +255,83 @@ struct rte_bbdev_op_data { uint32_t length; }; -struct rte_bbdev_op_dec_cb_params { - /**< The K size of the input CB, in bits [40:6144], as specified in +/** Turbo decode code block parameters */ +struct rte_bbdev_op_dec_turbo_cb_params { + /** The K size of the input CB, in bits [40:6144], as specified in * 3GPP TS 36.212. * This size is inclusive of CRC bits, regardless whether it was * pre-calculated by the application or not. */ uint16_t k; - /**< The E length of the CB rate matched LLR output, in bytes, as in + /** The E length of the CB rate matched LLR output, in bytes, as in * 3GPP TS 36.212. */ uint32_t e; }; -struct rte_bbdev_op_dec_tb_params { - /**< The K- size of the input CB, in bits [40:6144], that is in the +/** LDPC decode code block parameters */ +struct rte_bbdev_op_dec_ldpc_cb_params { + /** Rate matching output sequence length in bits or LLRs. + * [3GPP TS38.212, section 5.4.2.1] + */ + uint32_t e; +}; + +/** Turbo decode transport block parameters */ +struct rte_bbdev_op_dec_turbo_tb_params { + /** The K- size of the input CB, in bits [40:6144], that is in the * Turbo operation when r < C-, as in 3GPP TS 36.212. */ uint16_t k_neg; - /**< The K+ size of the input CB, in bits [40:6144], that is in the + /** The K+ size of the input CB, in bits [40:6144], that is in the * Turbo operation when r >= C-, as in 3GPP TS 36.212. */ uint16_t k_pos; - /**< The number of CBs that have K- size, [0:63] */ + /** The number of CBs that have K- size, [0:63] */ uint8_t c_neg; - /**< The total number of CBs in the TB, [1:RTE_BBDEV_TURBO_MAX_CODE_BLOCKS] */ + /** The total number of CBs in the TB, + * [1:RTE_BBDEV_TURBO_MAX_CODE_BLOCKS] + */ uint8_t c; - /**< The number of CBs that uses Ea before switching to Eb, [0:63] */ + /** The number of CBs that uses Ea before switching to Eb, [0:63] */ uint8_t cab; - /**< The E size of the CB rate matched output to use in the Turbo + /** The E size of the CB rate matched output to use in the Turbo * operation when r < cab */ uint32_t ea; - /**< The E size of the CB rate matched output to use in the Turbo + /** The E size of the CB rate matched output to use in the Turbo * operation when r >= cab */ uint32_t eb; - /**< The index of the first CB in the inbound mbuf data, default is 0 */ + /** The index of the first CB in the inbound mbuf data, default is 0 */ uint8_t r; }; -/**< Operation structure for Turbo decode. - * An operation can perform on one CB at a time "CB-mode". - * An operation can perform on one or multiple CBs that are logically belonging - * to one TB "TB-mode". - * The provided K size parameter of the CB is its size out coming from the +/** LDPC decode transport block parameters */ +struct rte_bbdev_op_dec_ldpc_tb_params { + /** Ea, length after rate matching in bits, r < cab. + * [3GPP TS38.212, section 5.4.2.1] + */ + uint32_t ea; + /** Eb, length after rate matching in bits, r >= cab. + * [3GPP TS38.212, section 5.4.2.1] + */ + uint32_t eb; + /** The total number of CBs in the TB or partial TB + * [1:RTE_BBDEV_LDPC_MAX_CODE_BLOCKS] + */ + uint8_t c; + /** The index of the first CB in the inbound mbuf data, default is 0 */ + uint8_t r; + /** The number of CBs that use Ea before switching to Eb, [0:63] */ + uint8_t cab; +}; + +/** Operation structure for Turbo decode. + * An operation can be performed on one CB at a time "CB-mode". + * An operation can be performed on one or multiple CBs that logically + * belong to one TB "TB-mode". + * The provided K size parameter of the CB is its size coming from the * decode operation. * CRC24A/B check is requested by the application by setting the flag * RTE_BBDEV_TURBO_CRC_TYPE_24B for CRC24B check or CRC24A otherwise. @@ -249,94 +356,192 @@ struct rte_bbdev_op_dec_tb_params { * application with enough room for the output data. */ struct rte_bbdev_op_turbo_dec { - /**< The Virtual Circular Buffer, wk, size 3*Kpi for each CB */ + /** The Virtual Circular Buffer, wk, size 3*Kpi for each CB */ struct rte_bbdev_op_data input; - /**< The hard decisions buffer for the decoded output, + /** The hard decisions buffer for the decoded output, * size K for each CB */ struct rte_bbdev_op_data hard_output; - /**< The soft LLR output buffer - optional */ + /** The soft LLR output buffer - optional */ struct rte_bbdev_op_data soft_output; - uint32_t op_flags; /**< Flags from rte_bbdev_op_td_flag_bitmasks */ - uint8_t rv_index; /**< Rv index for rate matching [0:3] */ - /**< The minimum number of iterations to perform in decoding all CBs in + /** Flags from rte_bbdev_op_td_flag_bitmasks */ + uint32_t op_flags; + + /** Rv index for rate matching [0:3] */ + uint8_t rv_index; + /** The minimum number of iterations to perform in decoding all CBs in * this operation - input */ uint8_t iter_min:4; - /**< The maximum number of iterations to perform in decoding all CBs in + /** The maximum number of iterations to perform in decoding all CBs in * this operation - input */ uint8_t iter_max:4; - /**< The maximum number of iterations that were perform in decoding all - * CBs in this decode operation - output + /** The maximum number of iterations that were performed in decoding + * all CBs in this decode operation - output */ uint8_t iter_count; - /**< 5 bit extrinsic scale (scale factor on extrinsic info) */ + /** 5 bit extrinsic scale (scale factor on extrinsic info) */ uint8_t ext_scale; - /**< Number of MAP engines to use in decode, - * must be power of 2 (or 0 to auto-select) + /** Number of MAP engines to use in decode, + * must be power of 2 (or 0 to auto-select) */ uint8_t num_maps; - uint8_t code_block_mode; /**< [0 - TB : 1 - CB] */ + /**< [0 - TB : 1 - CB] */ + uint8_t code_block_mode; union { /**< Struct which stores Code Block specific parameters */ - struct rte_bbdev_op_dec_cb_params cb_params; + struct rte_bbdev_op_dec_turbo_cb_params cb_params; /**< Struct which stores Transport Block specific parameters */ - struct rte_bbdev_op_dec_tb_params tb_params; + struct rte_bbdev_op_dec_turbo_tb_params tb_params; }; }; +/** Operation structure for LDPC decode. + * + * An operation can be performed on one CB at a time "CB-mode". + * An operation can also be performed on one or multiple CBs that logically + * belong to a TB "TB-mode" (Currently not supported). + * + * The input encoded CB data is the Virtual Circular Buffer data stream. + * + * Each byte in the input circular buffer is the LLR value of each bit of the + * original CB. + * + * Hard output is a mandatory capability that all BBDEV PMDs support. This is + * the decoded CBs (CRC24A/B is the last 24-bit in each decoded CB). + * + * Soft output is an optional capability for BBDEV PMDs. If supported, an LLR + * rate matched output is computed in the soft_output buffer structure. + * These are A Posteriori Probabilities (APP) LLR samples for coded bits. + * + * HARQ combined output is an optional capability for BBDEV PMDs. + * If supported, a LLR output is streamed to the harq_combined_output + * buffer. + * + * HARQ combined input is an optional capability for BBDEV PMDs. + * If supported, a LLR input is streamed from the harq_combined_input + * buffer. + * + * The output mbuf data structure is expected to be allocated by the + * application with enough room for the output data. + */ +struct rte_bbdev_op_ldpc_dec { + /** The Virtual Circular Buffer for this code block, one LLR + * per bit of the original CB. + */ + struct rte_bbdev_op_data input; + /** The hard decisions buffer for the decoded output, + * size K for each CB + */ + struct rte_bbdev_op_data hard_output; + /** The soft LLR output LLR stream buffer - optional */ + struct rte_bbdev_op_data soft_output; + /** The HARQ combined LLR stream input buffer - optional */ + struct rte_bbdev_op_data harq_combined_input; + /** The HARQ combined LLR stream output buffer - optional */ + struct rte_bbdev_op_data harq_combined_output; + + /** Flags from rte_bbdev_op_ldpcdec_flag_bitmasks */ + uint32_t op_flags; + + /** Rate matching redundancy version + * [3GPP TS38.212, section 5.4.2.1] + */ + uint8_t rv_index; + /** The maximum number of iterations to perform in decoding CB in + * this operation - input + */ + uint8_t iter_max; + /** The number of iterations that were performed in decoding + * CB in this decode operation - output + */ + uint8_t iter_count; + /** 1: LDPC Base graph 1, 2: LDPC Base graph 2. + * [3GPP TS38.212, section 5.2.2] + */ + uint8_t basegraph; + /** Zc, LDPC lifting size. + * [3GPP TS38.212, section 5.2.2] + */ + uint16_t z_c; + /** Ncb, length of the circular buffer in bits. + * [3GPP TS38.212, section 5.4.2.1] + */ + uint16_t n_cb; + /** Qm, modulation order {1,2,4,6,8}. + * [3GPP TS38.212, section 5.4.2.2] + */ + uint8_t q_m; + /** Number of Filler bits, n_filler = K – K’ + * [3GPP TS38.212 section 5.2.2] + */ + uint16_t n_filler; + /** [0 - TB : 1 - CB] */ + uint8_t code_block_mode; + union { + /** Struct which stores Code Block specific parameters */ + struct rte_bbdev_op_dec_ldpc_cb_params cb_params; + /** Struct which stores Transport Block specific parameters */ + struct rte_bbdev_op_dec_ldpc_tb_params tb_params; + }; +}; + +/** Turbo encode code block parameters */ struct rte_bbdev_op_enc_turbo_cb_params { - /**< The K size of the input CB, in bits [40:6144], as specified in + /** The K size of the input CB, in bits [40:6144], as specified in * 3GPP TS 36.212. * This size is inclusive of CRC24A, regardless whether it was * pre-calculated by the application or not. */ uint16_t k; - /**< The E length of the CB rate matched output, in bits, as in + /** The E length of the CB rate matched output, in bits, as in * 3GPP TS 36.212. */ uint32_t e; - /**< The Ncb soft buffer size of the CB rate matched output [K:3*Kpi], + /** The Ncb soft buffer size of the CB rate matched output [K:3*Kpi], * in bits, as specified in 3GPP TS 36.212. */ uint16_t ncb; }; +/** Turbo encode transport block parameters */ struct rte_bbdev_op_enc_turbo_tb_params { - /**< The K- size of the input CB, in bits [40:6144], that is in the + /** The K- size of the input CB, in bits [40:6144], that is in the * Turbo operation when r < C-, as in 3GPP TS 36.212. * This size is inclusive of CRC24B, regardless whether it was * pre-calculated and appended by the application or not. */ uint16_t k_neg; - /**< The K+ size of the input CB, in bits [40:6144], that is in the + /** The K+ size of the input CB, in bits [40:6144], that is in the * Turbo operation when r >= C-, as in 3GPP TS 36.212. * This size is inclusive of CRC24B, regardless whether it was * pre-calculated and appended by the application or not. */ uint16_t k_pos; - /**< The number of CBs that have K- size, [0:63] */ + /** The number of CBs that have K- size, [0:63] */ uint8_t c_neg; - /**< The total number of CBs in the TB, [1:RTE_BBDEV_TURBO_MAX_CODE_BLOCKS] */ + /** The total number of CBs in the TB, + * [1:RTE_BBDEV_TURBO_MAX_CODE_BLOCKS] + */ uint8_t c; - /**< The number of CBs that uses Ea before switching to Eb, [0:63] */ + /** The number of CBs that uses Ea before switching to Eb, [0:63] */ uint8_t cab; - /**< The E size of the CB rate matched output to use in the Turbo + /** The E size of the CB rate matched output to use in the Turbo * operation when r < cab */ uint32_t ea; - /**< The E size of the CB rate matched output to use in the Turbo + /** The E size of the CB rate matched output to use in the Turbo * operation when r >= cab */ uint32_t eb; - /**< The Ncb soft buffer size for the rate matched CB that is used in + /** The Ncb soft buffer size for the rate matched CB that is used in * the Turbo operation when r < C-, [K:3*Kpi] */ uint16_t ncb_neg; - /**< The Ncb soft buffer size for the rate matched CB that is used in + /** The Ncb soft buffer size for the rate matched CB that is used in * the Turbo operation when r >= C-, [K:3*Kpi] */ uint16_t ncb_pos; @@ -344,10 +549,38 @@ struct rte_bbdev_op_enc_turbo_tb_params { uint8_t r; }; -/**< Operation structure for Turbo encode. - * An operation can perform on one CB at a time "CB-mode". - * An operation can perform on one or multiple CBs that are logically - * belonging to one TB "TB-mode". +/** LDPC encode code block parameters */ +struct rte_bbdev_op_enc_ldpc_cb_params { + /** E, length after rate matching in bits. + * [3GPP TS38.212, section 5.4.2.1] + */ + uint32_t e; +}; + +/** LDPC encode transport block parameters */ +struct rte_bbdev_op_enc_ldpc_tb_params { + /** Ea, length after rate matching in bits, r < cab. + * [3GPP TS38.212, section 5.4.2.1] + */ + uint32_t ea; + /** Eb, length after rate matching in bits, r >= cab. + * [3GPP TS38.212, section 5.4.2.1] + */ + uint32_t eb; + /** The total number of CBs in the TB or partial TB + * [1:RTE_BBDEV_LDPC_MAX_CODE_BLOCKS] + */ + uint8_t c; + /** The index of the first CB in the inbound mbuf data, default is 0 */ + uint8_t r; + /** The number of CBs that use Ea before switching to Eb, [0:63] */ + uint8_t cab; +}; + +/** Operation structure for Turbo encode. + * An operation can be performed on one CB at a time "CB-mode". + * An operation can pbe erformd on one or multiple CBs that logically + * belong to one TB "TB-mode". * * In CB-mode, CRC24A/B is an optional operation. K size parameter is not * affected by CRC24A/B inclusion, this only affects the inbound mbuf data @@ -364,44 +597,131 @@ struct rte_bbdev_op_enc_turbo_tb_params { * application with enough room for the output data. */ struct rte_bbdev_op_turbo_enc { - /**< The input CB or TB data */ + /** The input CB or TB data */ struct rte_bbdev_op_data input; - /**< The rate matched CB or TB output buffer */ + /** The rate matched CB or TB output buffer */ struct rte_bbdev_op_data output; + /** Flags from rte_bbdev_op_te_flag_bitmasks */ + uint32_t op_flags; - uint32_t op_flags; /**< Flags from rte_bbdev_op_te_flag_bitmasks */ - uint8_t rv_index; /**< Rv index for rate matching [0:3] */ - - uint8_t code_block_mode; /**< [0 - TB : 1 - CB] */ + /** Rv index for rate matching [0:3] */ + uint8_t rv_index; + /** [0 - TB : 1 - CB] */ + uint8_t code_block_mode; union { - /**< Struct which stores Code Block specific parameters */ + /** Struct which stores Code Block specific parameters */ struct rte_bbdev_op_enc_turbo_cb_params cb_params; - /**< Struct which stores Transport Block specific parameters */ + /** Struct which stores Transport Block specific parameters */ struct rte_bbdev_op_enc_turbo_tb_params tb_params; }; }; -/**< List of the capabilities for the Turbo Decoder */ +/** Operation structure for LDPC encode. + * An operation can be performed on one CB at a time "CB-mode". + * An operation can be performed on one or multiple CBs that logically + * belong to a TB "TB-mode". + * + * The input data is the CB or TB input to the decoder. + * + * The output data is the ratematched CB or TB data, or the output after + * bit-selection if RTE_BBDEV_LDPC_INTERLEAVER_BYPASS is set. + * + * The output mbuf data structure is expected to be allocated by the + * application with enough room for the output data. + */ +struct rte_bbdev_op_ldpc_enc { + /** The input TB or CB data */ + struct rte_bbdev_op_data input; + /** The rate matched TB or CB output buffer */ + struct rte_bbdev_op_data output; + + /** Flags from rte_bbdev_op_ldpcenc_flag_bitmasks */ + uint32_t op_flags; + + /** Rate matching redundancy version */ + uint8_t rv_index; + /** 1: LDPC Base graph 1, 2: LDPC Base graph 2. + * [3GPP TS38.212, section 5.2.2] + */ + uint8_t basegraph; + /** Zc, LDPC lifting size. + * [3GPP TS38.212, section 5.2.2] + */ + uint16_t z_c; + /** Ncb, length of the circular buffer in bits. + * [3GPP TS38.212, section 5.4.2.1] + */ + uint16_t n_cb; + /** Qm, modulation order {2,4,6,8,10}. + * [3GPP TS38.212, section 5.4.2.2] + */ + uint8_t q_m; + /** Number of Filler bits, n_filler = K – K’ + * [3GPP TS38.212 section 5.2.2] + */ + uint16_t n_filler; + /** [0 - TB : 1 - CB] */ + uint8_t code_block_mode; + union { + /** Struct which stores Code Block specific parameters */ + struct rte_bbdev_op_enc_ldpc_cb_params cb_params; + /** Struct which stores Transport Block specific parameters */ + struct rte_bbdev_op_enc_ldpc_tb_params tb_params; + }; +}; + +/** List of the capabilities for the Turbo Decoder */ struct rte_bbdev_op_cap_turbo_dec { - /**< Flags from rte_bbdev_op_td_flag_bitmasks */ + /** Flags from rte_bbdev_op_td_flag_bitmasks */ uint32_t capability_flags; /** Maximal LLR absolute value. Acceptable LLR values lie in range * [-max_llr_modulus, max_llr_modulus]. */ int8_t max_llr_modulus; + /** Num input code block buffers */ uint8_t num_buffers_src; /**< Num input code block buffers */ - /**< Num hard output code block buffers */ + /** Num hard output code block buffers */ uint8_t num_buffers_hard_out; - /**< Num soft output code block buffers if supported by the driver */ + /** Num soft output code block buffers if supported by the driver */ uint8_t num_buffers_soft_out; }; -/**< List of the capabilities for the Turbo Encoder */ +/** List of the capabilities for the Turbo Encoder */ struct rte_bbdev_op_cap_turbo_enc { - /**< Flags from rte_bbdev_op_te_flag_bitmasks */ + /** Flags from rte_bbdev_op_te_flag_bitmasks */ uint32_t capability_flags; - uint8_t num_buffers_src; /**< Num input code block buffers */ - uint8_t num_buffers_dst; /**< Num output code block buffers */ + /** Num input code block buffers */ + uint8_t num_buffers_src; + /** Num output code block buffers */ + uint8_t num_buffers_dst; +}; + +/** List of the capabilities for the LDPC Decoder */ +struct rte_bbdev_op_cap_ldpc_dec { + /** Flags from rte_bbdev_op_ldpcdec_flag_bitmasks */ + uint32_t capability_flags; + /** LLR size in bits. LLR is a two’s complement number. */ + int8_t llr_size; + /** LLR numbers of decimals bit for arithmetic representation */ + int8_t llr_decimals; + /** Amount of memory for HARQ in external DDR in MB */ + uint16_t harq_memory_size; + /** Num input code block buffers */ + uint16_t num_buffers_src; + /** Num hard output code block buffers */ + uint16_t num_buffers_hard_out; + /** Num soft output code block buffers if supported by the driver */ + uint16_t num_buffers_soft_out; +}; + +/** List of the capabilities for the LDPC Encoder */ +struct rte_bbdev_op_cap_ldpc_enc { + /** Flags from rte_bbdev_op_ldpcenc_flag_bitmasks */ + uint32_t capability_flags; + /** Num input code block buffers */ + uint16_t num_buffers_src; + /** Num output code block buffers */ + uint16_t num_buffers_dst; }; /** Different operation types supported by the device */ @@ -409,40 +729,59 @@ enum rte_bbdev_op_type { RTE_BBDEV_OP_NONE, /**< Dummy operation that does nothing */ RTE_BBDEV_OP_TURBO_DEC, /**< Turbo decode */ RTE_BBDEV_OP_TURBO_ENC, /**< Turbo encode */ + RTE_BBDEV_OP_LDPC_DEC, /**< LDPC decode */ + RTE_BBDEV_OP_LDPC_ENC, /**< LDPC encode */ RTE_BBDEV_OP_TYPE_COUNT, /**< Count of different op types */ }; -/**< Bit indexes of possible errors reported through status field */ +/** Bit indexes of possible errors reported through status field */ enum { RTE_BBDEV_DRV_ERROR, RTE_BBDEV_DATA_ERROR, RTE_BBDEV_CRC_ERROR, + RTE_BBDEV_SYNDROME_ERROR }; -/**< Structure specifying a single encode operation */ +/** Structure specifying a single encode operation */ struct rte_bbdev_enc_op { - int status; /**< Status of operation that was performed */ - struct rte_mempool *mempool; /**< Mempool which op instance is in */ - void *opaque_data; /**< Opaque pointer for user data */ - /**< Contains encoder specific parameters */ - struct rte_bbdev_op_turbo_enc turbo_enc; + /**< Status of operation that was performed */ + int status; + /**< Mempool which op instance is in */ + struct rte_mempool *mempool; + /**< Opaque pointer for user data */ + void *opaque_data; + union { + /** Contains turbo decoder specific parameters */ + struct rte_bbdev_op_turbo_enc turbo_enc; + /** Contains LDPC decoder specific parameters */ + struct rte_bbdev_op_ldpc_enc ldpc_enc; + }; }; -/**< Structure specifying a single decode operation */ +/** Structure specifying a single decode operation */ struct rte_bbdev_dec_op { - int status; /**< Status of operation that was performed */ - struct rte_mempool *mempool; /**< Mempool which op instance is in */ - void *opaque_data; /**< Opaque pointer for user data */ - /**< Contains decoder specific parameters */ - struct rte_bbdev_op_turbo_dec turbo_dec; + /** Status of operation that was performed */ + int status; + /** Mempool which op instance is in */ + struct rte_mempool *mempool; + /** Opaque pointer for user data */ + void *opaque_data; + union { + /** Contains turbo decoder specific parameters */ + struct rte_bbdev_op_turbo_dec turbo_dec; + /** Contains LDPC decoder specific parameters */ + struct rte_bbdev_op_ldpc_dec ldpc_dec; + }; }; -/**< Operation capabilities supported by a device */ +/** Operation capabilities supported by a device */ struct rte_bbdev_op_cap { enum rte_bbdev_op_type type; /**< Type of operation */ union { struct rte_bbdev_op_cap_turbo_dec turbo_dec; struct rte_bbdev_op_cap_turbo_enc turbo_enc; + struct rte_bbdev_op_cap_ldpc_dec ldpc_dec; + struct rte_bbdev_op_cap_ldpc_enc ldpc_enc; } cap; /**< Operation-type specific capabilities */ }; @@ -513,7 +852,8 @@ struct rte_mempool * __rte_experimental /* Check type */ priv = (struct rte_bbdev_op_pool_private *) rte_mempool_get_priv(mempool); - if (unlikely(priv->type != RTE_BBDEV_OP_TURBO_ENC)) + if (unlikely((priv->type != RTE_BBDEV_OP_TURBO_ENC) && + (priv->type != RTE_BBDEV_OP_LDPC_ENC))) return -EINVAL; /* Get elements */ @@ -548,7 +888,8 @@ struct rte_mempool * __rte_experimental /* Check type */ priv = (struct rte_bbdev_op_pool_private *) rte_mempool_get_priv(mempool); - if (unlikely(priv->type != RTE_BBDEV_OP_TURBO_DEC)) + if (unlikely((priv->type != RTE_BBDEV_OP_TURBO_DEC) && + (priv->type != RTE_BBDEV_OP_LDPC_DEC))) return -EINVAL; /* Get elements */ -- 1.8.3.1