[v3] BBDEV: add LDPC op parameters and flags to support CBGT
diff mbox series

Message ID 1604586344-25634-1-git-send-email-aidan.goddard@accelercomm.com
State Deferred
Delegated to: akhil goyal
Headers show
Series
  • [v3] BBDEV: add LDPC op parameters and flags to support CBGT
Related show

Checks

Context Check Description
ci/iol-mellanox-Performance success Performance Testing PASS
ci/iol-intel-Performance success Performance Testing PASS
ci/iol-intel-Functional fail Functional Testing issues
ci/travis-robot success Travis build: passed
ci/iol-testing success Testing PASS
ci/Intel-compilation success Compilation OK
ci/checkpatch success coding style OK

Commit Message

Aidan Goddard Nov. 5, 2020, 2:25 p.m. UTC
This commit adds support to BBDEV for LDPC Code Block Group Transmission
(CBGT) as defined in 3GPP TS 38.214. The following changes facilitate this:
- add RTE_BBDEV_LDPC_[ENC/DEC]_CBGT feature flag
- add CBGT input parameters to LDPC encode transport block op structure
- add CBGT input and output parameters to LDPC decode transport block op
- add support for reading these parameters from test vector files
- add sanity tests for RTE_BBDEV_LDPC_[ENC/DEC]_CBGT flag in test vector
- update user guide with the flags and parameters

CBGT parameters are only required when the RTE_BBDEV_LDPC_[ENC/DEC]_CBGT
op flag is specified.

Reported-by: Rob Maunder <rob.maunder@accelercomm.com>
Signed-off-by: Aidan Goddard <aidan.goddard@accelercomm.com>
Acked-by: Dave Burley <dave.burley@accelercomm.com>
---
 app/test-bbdev/test_bbdev_vector.c | 46 +++++++++++++++++++---
 app/test-bbdev/test_bbdev_vector.h |  3 ++
 doc/guides/prog_guide/bbdev.rst    | 29 ++++++++++++++
 lib/librte_bbdev/rte_bbdev_op.h    | 80 +++++++++++++++++++++++++++++++++++++-
 4 files changed, 151 insertions(+), 7 deletions(-)

Comments

Akhil Goyal Nov. 12, 2020, 9:13 p.m. UTC | #1
> This commit adds support to BBDEV for LDPC Code Block Group Transmission
> (CBGT) as defined in 3GPP TS 38.214. The following changes facilitate this:
> - add RTE_BBDEV_LDPC_[ENC/DEC]_CBGT feature flag
> - add CBGT input parameters to LDPC encode transport block op structure
> - add CBGT input and output parameters to LDPC decode transport block op
> - add support for reading these parameters from test vector files
> - add sanity tests for RTE_BBDEV_LDPC_[ENC/DEC]_CBGT flag in test vector
> - update user guide with the flags and parameters
> 
> CBGT parameters are only required when the
> RTE_BBDEV_LDPC_[ENC/DEC]_CBGT
> op flag is specified.
> 
> Reported-by: Rob Maunder <rob.maunder@accelercomm.com>
> Signed-off-by: Aidan Goddard <aidan.goddard@accelercomm.com>
> Acked-by: Dave Burley <dave.burley@accelercomm.com>
> ---
>  app/test-bbdev/test_bbdev_vector.c | 46 +++++++++++++++++++---
>  app/test-bbdev/test_bbdev_vector.h |  3 ++
>  doc/guides/prog_guide/bbdev.rst    | 29 ++++++++++++++
>  lib/librte_bbdev/rte_bbdev_op.h    | 80
> +++++++++++++++++++++++++++++++++++++-
>  4 files changed, 151 insertions(+), 7 deletions(-)
> 
I believe this patch is for next release.
Chautru, Nicolas Nov. 13, 2020, 11:19 p.m. UTC | #2
Hi Aidan,

Some general comments first as I see that this is a first DPDK contribution.
I suggest to add cover-later to provide more context for the serie
and incremental changes between patch versions (see https://doc.dpdk.org/guides/contributing/patches.html).
When do you plan on of providing a PMD version supporting that API? I assume this is more of an RFC at the moment?
It would be best for them to happen in the same cycle.
More comment below.

> -----Original Message-----
> From: Aidan Goddard <aidan.goddard@accelercomm.com>
> Sent: Thursday, November 5, 2020 6:26 AM
> To: akhil.goyal@nxp.com
> Cc: Chautru, Nicolas <nicolas.chautru@intel.com>; dev@dpdk.org; Aidan
> Goddard <aidan.goddard@accelercomm.com>
> Subject: [PATCH v3] BBDEV: add LDPC op parameters and flags to support
> CBGT
> 
> This commit adds support to BBDEV for LDPC Code Block Group Transmission
> (CBGT) as defined in 3GPP TS 38.214. The following changes facilitate this:
> - add RTE_BBDEV_LDPC_[ENC/DEC]_CBGT feature flag
> - add CBGT input parameters to LDPC encode transport block op structure
> - add CBGT input and output parameters to LDPC decode transport block op
> - add support for reading these parameters from test vector files
> - add sanity tests for RTE_BBDEV_LDPC_[ENC/DEC]_CBGT flag in test vector
> - update user guide with the flags and parameters
> 
> CBGT parameters are only required when the
> RTE_BBDEV_LDPC_[ENC/DEC]_CBGT op flag is specified.

Best to put the change for bbdev-test update in a separate commit from the first commit
limited to change to librte_bbdev and related doc. (in same serie)
The change to bbdev-test are not directly required for the api change, only to process a test vector format which is not provided yet. I assume you will provide one of such test vector.
Also (minor) don't capitalize bbdev in the commit message.

> 
> Reported-by: Rob Maunder <rob.maunder@accelercomm.com>
> Signed-off-by: Aidan Goddard <aidan.goddard@accelercomm.com>
> Acked-by: Dave Burley <dave.burley@accelercomm.com>
> ---
>  app/test-bbdev/test_bbdev_vector.c | 46 +++++++++++++++++++---
> app/test-bbdev/test_bbdev_vector.h |  3 ++
>  doc/guides/prog_guide/bbdev.rst    | 29 ++++++++++++++
>  lib/librte_bbdev/rte_bbdev_op.h    | 80
> +++++++++++++++++++++++++++++++++++++-
>  4 files changed, 151 insertions(+), 7 deletions(-)
> 
> diff --git a/app/test-bbdev/test_bbdev_vector.c b/app/test-
> bbdev/test_bbdev_vector.c
> index 50d1da0..e5808b2 100644
> --- a/app/test-bbdev/test_bbdev_vector.c
> +++ b/app/test-bbdev/test_bbdev_vector.c
> @@ -200,6 +200,8 @@
>  	else if (!strcmp(token,
> 
> 	"RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK"))
>  		*op_flag_value =
> RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK;
> +	else if (!strcmp(token, "RTE_BBDEV_LDPC_DEC_CBGT"))
> +		*op_flag_value = RTE_BBDEV_LDPC_DEC_CBGT;
>  	else {
>  		printf("The given value is not a LDPC decoder flag\n");
>  		return -1;
> @@ -248,8 +250,10 @@
>  		*op_flag_value = RTE_BBDEV_LDPC_ENC_INTERRUPTS;
>  	else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_SCATTER_GATHER"))
>  		*op_flag_value = RTE_BBDEV_LDPC_ENC_SCATTER_GATHER;
> +	else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_CBGT"))
> +		*op_flag_value = RTE_BBDEV_LDPC_ENC_CBGT;
>  	else {
> -		printf("The given value is not a turbo encoder flag\n");
> +		printf("The given value is not a LDPC encoder flag\n");
>  		return -1;
>  	}
> 
> @@ -718,6 +722,14 @@
>  		vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
>  		ldpc_enc->code_block_mode = (uint8_t) strtoul(token, &err,
> 0);
>  		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
> +	} else if (!strcmp(key_token, "max_cbg")) {
> +		vector->mask |= TEST_BBDEV_VF_MAX_CBG_PER_TB;
> +		ldpc_enc->tb_params.max_cbg = (uint8_t) strtoul(token,
> &err, 0);
> +		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
> +	} else if (!strcmp(key_token, "cbgti")) {
> +		vector->mask |= TEST_BBDEV_VF_CBGTI;
> +		ldpc_enc->tb_params.cbgti = (uint8_t) strtoul(token, &err, 0);
> +		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
>  	} else if (!strcmp(key_token, "op_flags")) {
>  		vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
>  		ret = parse_turbo_flags(token, &op_flags, vector->op_type);
> @@ -828,6 +840,18 @@
>  		vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
>  		ldpc_dec->code_block_mode = (uint8_t) strtoul(token, &err,
> 0);
>  		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
> +	} else if (!strcmp(key_token, "max_cbg")) {
> +		vector->mask |= TEST_BBDEV_VF_MAX_CBG_PER_TB;
> +		ldpc_dec->tb_params.max_cbg = (uint8_t) strtoul(token,
> &err, 0);
> +		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
> +	} else if (!strcmp(key_token, "cbgti")) {
> +		vector->mask |= TEST_BBDEV_VF_CBGTI;
> +		ldpc_dec->tb_params.cbgti = (uint8_t) strtoul(token, &err, 0);
> +		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
> +	} else if (!strcmp(key_token, "cbgfi")) {
> +		vector->mask |= TEST_BBDEV_VF_CBGFI;
> +		ldpc_dec->tb_params.cbgfi = (uint8_t) strtoul(token, &err, 0);
> +		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
>  	} else if (!strcmp(key_token, "op_flags")) {
>  		vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
>  		ret = parse_turbo_flags(token, &op_flags, vector->op_type);
> @@ -1162,6 +1186,12 @@
>  		if (!(mask & TEST_BBDEV_VF_R))
>  			printf(
>  				"WARNING: r was not specified in vector file
> and will be set to 0\n");
> +		if (!(mask & TEST_BBDEV_VF_MAX_CBG_PER_TB) &&
> (ldpc_dec->op_flags &
> +				RTE_BBDEV_LDPC_DEC_CBGT)) {
> +			printf(
> +				"WARNING: max_cbg was not specified in
> vector file and will be set to 1\n");
> +			ldpc_dec->tb_params.max_cbg = 1;
> +		}
>  	} else {
>  		if (!(mask & TEST_BBDEV_VF_E))
>  			printf(
> @@ -1298,12 +1328,18 @@
>  	if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
>  		printf(
>  			"WARNING: code_block_mode was not specified in
> vector file and will be set to 1\n");
> -		vector->turbo_enc.code_block_mode = 1;
> +		vector->ldpc_enc.code_block_mode = 1;
>  	}
> -	if (vector->turbo_enc.code_block_mode == 0) {
> +	if (vector->ldpc_enc.code_block_mode == 0) {
> +		if (!(mask & TEST_BBDEV_VF_MAX_CBG_PER_TB) && (vector-
> >ldpc_enc.op_flags &
> +				RTE_BBDEV_LDPC_ENC_CBGT)) {
> +			printf(
> +				"WARNING: max_cbg was not specified in
> vector file and will be set to 1\n");
> +			vector->ldpc_enc.tb_params.max_cbg = 1;
> +		}
>  	} else {
> -		if (!(mask & TEST_BBDEV_VF_E) && (vector-
> >turbo_enc.op_flags &
> -				RTE_BBDEV_TURBO_RATE_MATCH))
> +		if (!(mask & TEST_BBDEV_VF_E) && (vector-
> >ldpc_enc.op_flags &
> +				RTE_BBDEV_LDPC_RATE_MATCH))
>  			printf(
>  				"WARNING: e was not specified in vector file
> and will be set to 0\n");
>  		if (!(mask & TEST_BBDEV_VF_NCB))
> diff --git a/app/test-bbdev/test_bbdev_vector.h b/app/test-
> bbdev/test_bbdev_vector.h
> index 4e5dbf5..69f5b9c 100644
> --- a/app/test-bbdev/test_bbdev_vector.h
> +++ b/app/test-bbdev/test_bbdev_vector.h
> @@ -35,6 +35,9 @@ enum {
>  	TEST_BBDEV_VF_CODE_BLOCK_MODE = (1ULL << 23),
>  	TEST_BBDEV_VF_OP_FLAGS = (1ULL << 24),
>  	TEST_BBDEV_VF_EXPECTED_STATUS = (1ULL << 25),
> +	TEST_BBDEV_VF_MAX_CBG_PER_TB = (1ULL << 26),
> +	TEST_BBDEV_VF_CBGTI = (1ULL << 27),
> +	TEST_BBDEV_VF_CBGFI = (1ULL << 28),
>  };

A part of the test commit, good to have a vector for reference (a relatively small one).

> 
>  enum op_data_type {
> diff --git a/doc/guides/prog_guide/bbdev.rst
> b/doc/guides/prog_guide/bbdev.rst index 6b2bd54..0ff4039 100644
> --- a/doc/guides/prog_guide/bbdev.rst
> +++ b/doc/guides/prog_guide/bbdev.rst
> @@ -747,6 +747,9 @@ given below.
>  |RTE_BBDEV_LDPC_ENC_CONCATENATION                                    |
>  | Set if a device supports concatenation of non byte aligned output  |  +--------
> ------------------------------------------------------------+
> +|RTE_BBDEV_LDPC_ENC_CBGT                                             |
> +| Set if a device supports CB group transmission                     |
> ++--------------------------------------------------------------------+
> 
>  The structure passed for each LDPC encode operation is given below,  with
> the operation flags forming a bitmask in the ``op_flags`` field.
> @@ -815,6 +818,10 @@ The LDPC encode parameters are set out in the table
> below.
>  +----------------+------------+-------------------------------------------------------+
>  |                |eb          |Eb, length of the RM output sequence in bits, r >= cab |
>  +----------------+------------+-------------------------------------------------------+
> +|                |max_cbg     |maximum number of CB groups per TB: 1-8                |
> ++----------------+------------+-------------------------------------------------------+
> +|                |cbgti       |CB group transmission information bitfield             |
> ++----------------+------------+-------------------------------------------------------+
> 
>  The mbuf input ``input`` is mandatory for all BBDEV PMDs and is the
> incoming code block or transport block data.
> @@ -869,6 +876,11 @@ Figure :numref:`figure_turbo_tb_encode` above
> showing the Turbo encoding of CBs using BBDEV interface in TB-mode  is also
> valid for LDPC encode.
> 
> +In TB-mode, If the ``RTE_BBDEV_LDPC_ENC_CBGT`` flag is specified the
> +``max_cbg`` and ``cbgti`` parameters are used for CB group
> +transmission. If the ``RTE_BBDEV_LDPC_ENC_CBGT`` flag is not specified,
> +these parameters are ignored.
> +
>  BBDEV LDPC Decode Operation
>  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> 
> @@ -942,6 +954,9 @@ given below.
>  |RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK                        |
>  | Set if a device supports loopback access to HARQ internal memory   |
>  +--------------------------------------------------------------------+
> +|RTE_BBDEV_LDPC_DEC_CBGT                                             |
> +| Set if a device supports CB group transmission                     |
> ++--------------------------------------------------------------------+
> 
>  The structure passed for each LDPC decode operation is given below,  with
> the operation flags forming a bitmask in the ``op_flags`` field.
> @@ -1027,6 +1042,14 @@ The LDPC decode parameters are set out in the
> table below.
>  +----------------+------------+-------------------------------------------------------+
>  |                |eb          |Eb, length of the RM output sequence in bits  r >= cab |
>  +----------------+------------+-------------------------------------------------------+
> +|                |max_cbg     |maximum number of CB groups per TB: 1-8                |
> ++----------------+------------+-------------------------------------------------------+
> +|                |cbgti       |CB group transmission information bitfield             |
> ++----------------+------------+-------------------------------------------------------+
> +|                |cbgfi       |CB group Flushing out Information (CBGFI)              |
> ++----------------+------------+-------------------------------------------------------+
> +|                |cbg_crc_err |CB group CRC failure bitfield (output)                 |
> ++----------------+------------+-------------------------------------------------------+
> 
>  The mbuf input ``input`` encoded CB data is mandatory for all BBDEV PMDs
> and is the Virtual Circular Buffer data stream with null padding.
> @@ -1084,6 +1107,12 @@ Figure :numref:`figure_turbo_tb_decode` above
> showing the Turbo decoding of CBs using BBDEV interface in TB-mode  is also
> valid for LDPC decode.
> 
> +In TB-mode, If the ``RTE_BBDEV_LDPC_DEC_CBGT`` flag is specified the
> +``max_cbg`` and ``cbgti`` parameters are used for CB group
> +transmission. The ``cbg_crc_err`` output parameter is a bitfield used
> +to indicate crc failures in the respective CB groups. If the
> +``RTE_BBDEV_LDPC_DEC_CBGT`` flag is not specified, these parameters are
> ignored.
> +
> 
>  Sample code
>  -----------
> diff --git a/lib/librte_bbdev/rte_bbdev_op.h
> b/lib/librte_bbdev/rte_bbdev_op.h index f726d73..f3d00dc 100644
> --- a/lib/librte_bbdev/rte_bbdev_op.h
> +++ b/lib/librte_bbdev/rte_bbdev_op.h
> @@ -186,7 +186,9 @@ enum rte_bbdev_op_ldpcdec_flag_bitmasks {
>  	 *  for HARQ memory. If not set, it is assumed the filler bits are not
>  	 *  in HARQ memory and handled directly by the LDPC decoder.
>  	 */
> -	RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_FILLERS = (1ULL <<
> 18)
> +	RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_FILLERS = (1ULL <<
> 18),
> +	/** Set if a device supports CB group transmission. */
> +	RTE_BBDEV_LDPC_DEC_CBGT = (1ULL << 19)

Since this is not really a different processing per se, more a different API/mode option being proposed to indicate how to process each cbs (variant of existing cb/tb mode), I would suggest then something like RTE_BBDEV_LDPC_DEC_CBGT_MODE
Also to be explicit the assumption is that a device supporting that flag would also support standard TB mode and CB mode, is that your expectation? ie. not mutually exclusive

>  };
> 
>  /** Flags for LDPC encoder operation and capability structure */ @@ -206,7
> +208,9 @@ enum rte_bbdev_op_ldpcenc_flag_bitmasks {
>  	/** 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)
> +	RTE_BBDEV_LDPC_ENC_CONCATENATION = (1ULL << 7),
> +	/** Set if a device supports CB group transmission. */
> +	RTE_BBDEV_LDPC_ENC_CBGT = (1ULL << 8)
>  };
> 
>  /** Data input and output buffer for BBDEV operations */ @@ -334,6
> +338,56 @@ struct rte_bbdev_op_dec_ldpc_tb_params {
>  	uint8_t r;
>  	/** The number of CBs that use Ea before switching to Eb, [0:63] */
>  	uint8_t cab;
> +	/** If the RTE_BBDEV_LDPC_DEC_CBGT capability is not asserted,
> then
> +	 *  the value of max_cbg is ignored. Otherwise, a max_cbg value of
> +	 *  0 or 1 indicates that codeBlockGroupTransmission is disabled,
> +	 *  as defined in 3GPP TS 38.214.

I would suggest to refer more specifically to the 3gpp section/subclause (general comment for each 3gpp reference).

Here to you are refering max_cbg to be `maxCodeBlockGroupsPerTransportBlock` and not the `M` from 5.1.7.1?
Good to be explicit and use the 3gpp term once to be explicit.
Any reason not to use M instead of maxCodeBlockGroupsPerTransportBlock here?

> +	 *
> +	 *  A max_cbg value of 2, 4, 6, or 8 sets the value of

Are you assuming that 1 is not a legit value when that flag is enabled? Not the case in the doc.

> +	 *  maxCodeBlockGroupsPerTransportBlock and indicates that
> +	 *  codeBlockGroupTransmission is enabled, as defined in 3GPP TS
> 38.214.
> +	 */
> +	uint8_t max_cbg;
> +	/** If codeBlockGroupTransmission is disabled, then the value of cbgti
> +	 *  is ignored. Otherwise, cbgti represents the Code Block Group
> +	 *  Transmission Information (CBGTI), as defined in 3GPP TS 38.214.
> +	 *  In this case, the M = min(C, max_cbg) number of Most Significant
> +	 *  Bits (MSBs) of the uint8_t cbgti have an in-order one-to-one
> mapping
> +	 *  with the M code block groups (CBGs) of the transport block, with
> the
> +	 *  MSB mapped to CBG#0, as detailed in 3GPP TS 38.214.
> +	 *
> +	 *  Here, C is the total number of code blocks in the full transport
> block,
> +	 *  as defined in 3GPP TS 38.212.

Good to be explicit for the case when N_TBS = 2 as this may or not cause the api above to diverge from 3gpp terminology. This can be added in doc.

Good to be explicit on the assumption on input/output/harq `mbuf` notably for a given bitmap pattern where some CBG are not transmitted (0101...). ie. notably to confirm all data is concatenated back to back in same mbuf regardless and whether harq buffers of CBG not transmitted are skipped.

General comment is that the doc above has less information than the .h file (hence reviewing thia file only)

> +	 */
> +	uint8_t cbgti;
> +	/** If codeBlockGroupTransmission is disabled, then the value of cbgfi
> +	 * should be ignored. Otherwise, cbgfi represents the Code Block
> Group
> +	 * Flushing out Information (CBGFI), as defined in 3GPP TS 38.214. In
> this
> +	 * case, if the LSB of the uint8_t cbgfi is set to 0, this indicates that
> +	 * the earlier received instances of the same CBGs being decoded may
> be
> +	 * corrupted and that the corresponding contents of the HARQ
> memory should
> +	 * be flushed and not combined with the present CBGs being
> decoded. If the
> +	 * LSB of the uint8_t cbgfi is set to 1, this indicates that the earlier
> +	 * received instances of the same CBGs being decoded should be
> combined with
> +	 * the present CBGs being decoded.
> +	 */
> +	uint8_t cbgfi;
> +
> +	/** If codeBlockGroupTransmission is disabled or if
> +	 *  RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK is not asserted, then the
> value of
> +	 *  cbg_crc_err should be ignored. Otherwise, cbg_crc_err reports
> whether
> +	 *  any CRC24B failures have been encountered in each of the code
> block
> +	 *  groups (CBGs). In this case, the M = min(C, max_cbg) number of
> Most
> +	 *  Significant Bits (MSBs) of the uint8_t cbg_crc_error have an in-
> order
> +	 *  one-to-one mapping with the M CBGs of the transport block, with
> the MSB
> +	 *  mapped to CBG#0, as detailed in 3GPP TS 38.214. An asserted bit
> +	 *  indicates that a CRC24B failure was encountered among the code
> blocks
> +	 *  of the corresponding CBG.
> +	 *
> +	 *  Here, C is the total number of code blocks in the full transport
> block,
> +	 *  as defined in 3GPP TS 38.212.
> +	 */
> +	uint8_t cbg_crc_err;
>  };
> 
>  /** Operation structure for Turbo decode.
> @@ -584,6 +638,28 @@ struct rte_bbdev_op_enc_ldpc_tb_params {
>  	uint8_t r;
>  	/** The number of CBs that use Ea before switching to Eb, [0:63] */
>  	uint8_t cab;
> +	/** If the RTE_BBDEV_LDPC_ENC_CBGT capability is not asserted,
> then
> +	 *  the value of max_cbg is ignored. Otherwise, a max_cbg value of
> +	 *  0 or 1 indicates that codeBlockGroupTransmission is disabled,
> +	 *  as defined in 3GPP TS 38.214.
> +	 *
> +	 *  A max_cbg value of 2, 4, 6, or 8 sets the value of
> +	 *  maxCodeBlockGroupsPerTransportBlock and indicates that
> +	 *  codeBlockGroupTransmission is enabled, as defined in 3GPP TS
> 38.214.
> +	 */
> +	uint8_t max_cbg;
> +	/** If codeBlockGroupTransmission is disabled, then the value of cbgti
> +	 *  is ignored. Otherwise, cbgti represents the Code Block Group
> +	 *  Transmission Information (CBGTI), as defined in 3GPP TS 38.214.
> +	 *  In this case, the M = min(C, max_cbg) number of Most Significant
> +	 *  Bits (MSBs) of the uint8_t cbgti have an in-order one-to-one
> mapping
> +	 *  with the M code block groups (CBGs) of the transport block, with
> the
> +	 *  MSB mapped to CBG#0, as detailed in 3GPP TS 38.214.
> +	 *
> +	 *  Here, C is the total number of code blocks in the full transport
> block,
> +	 *  as defined in 3GPP TS 38.212.
> +	 */
> +	uint8_t cbgti;

Same comment as for uplink with regards to assumptions on mbuf input/output with regards to skipped CBG would be good to be explicit.
In case this is same as TB mode then this would already be supported by existing TB mode mode (partial TB with number of CBs with size Ea or Eb).

We can discuss more offline or on the mailing list.


>  };
> 
>  /** Operation structure for Turbo encode.
> --
> 1.8.3.1

Patch
diff mbox series

diff --git a/app/test-bbdev/test_bbdev_vector.c b/app/test-bbdev/test_bbdev_vector.c
index 50d1da0..e5808b2 100644
--- a/app/test-bbdev/test_bbdev_vector.c
+++ b/app/test-bbdev/test_bbdev_vector.c
@@ -200,6 +200,8 @@ 
 	else if (!strcmp(token,
 			"RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK"))
 		*op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK;
+	else if (!strcmp(token, "RTE_BBDEV_LDPC_DEC_CBGT"))
+		*op_flag_value = RTE_BBDEV_LDPC_DEC_CBGT;
 	else {
 		printf("The given value is not a LDPC decoder flag\n");
 		return -1;
@@ -248,8 +250,10 @@ 
 		*op_flag_value = RTE_BBDEV_LDPC_ENC_INTERRUPTS;
 	else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_SCATTER_GATHER"))
 		*op_flag_value = RTE_BBDEV_LDPC_ENC_SCATTER_GATHER;
+	else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_CBGT"))
+		*op_flag_value = RTE_BBDEV_LDPC_ENC_CBGT;
 	else {
-		printf("The given value is not a turbo encoder flag\n");
+		printf("The given value is not a LDPC encoder flag\n");
 		return -1;
 	}
 
@@ -718,6 +722,14 @@ 
 		vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
 		ldpc_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0);
 		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
+	} else if (!strcmp(key_token, "max_cbg")) {
+		vector->mask |= TEST_BBDEV_VF_MAX_CBG_PER_TB;
+		ldpc_enc->tb_params.max_cbg = (uint8_t) strtoul(token, &err, 0);
+		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
+	} else if (!strcmp(key_token, "cbgti")) {
+		vector->mask |= TEST_BBDEV_VF_CBGTI;
+		ldpc_enc->tb_params.cbgti = (uint8_t) strtoul(token, &err, 0);
+		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
 	} else if (!strcmp(key_token, "op_flags")) {
 		vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
 		ret = parse_turbo_flags(token, &op_flags, vector->op_type);
@@ -828,6 +840,18 @@ 
 		vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
 		ldpc_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0);
 		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
+	} else if (!strcmp(key_token, "max_cbg")) {
+		vector->mask |= TEST_BBDEV_VF_MAX_CBG_PER_TB;
+		ldpc_dec->tb_params.max_cbg = (uint8_t) strtoul(token, &err, 0);
+		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
+	} else if (!strcmp(key_token, "cbgti")) {
+		vector->mask |= TEST_BBDEV_VF_CBGTI;
+		ldpc_dec->tb_params.cbgti = (uint8_t) strtoul(token, &err, 0);
+		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
+	} else if (!strcmp(key_token, "cbgfi")) {
+		vector->mask |= TEST_BBDEV_VF_CBGFI;
+		ldpc_dec->tb_params.cbgfi = (uint8_t) strtoul(token, &err, 0);
+		ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
 	} else if (!strcmp(key_token, "op_flags")) {
 		vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
 		ret = parse_turbo_flags(token, &op_flags, vector->op_type);
@@ -1162,6 +1186,12 @@ 
 		if (!(mask & TEST_BBDEV_VF_R))
 			printf(
 				"WARNING: r was not specified in vector file and will be set to 0\n");
+		if (!(mask & TEST_BBDEV_VF_MAX_CBG_PER_TB) && (ldpc_dec->op_flags &
+				RTE_BBDEV_LDPC_DEC_CBGT)) {
+			printf(
+				"WARNING: max_cbg was not specified in vector file and will be set to 1\n");
+			ldpc_dec->tb_params.max_cbg = 1;
+		}
 	} else {
 		if (!(mask & TEST_BBDEV_VF_E))
 			printf(
@@ -1298,12 +1328,18 @@ 
 	if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
 		printf(
 			"WARNING: code_block_mode was not specified in vector file and will be set to 1\n");
-		vector->turbo_enc.code_block_mode = 1;
+		vector->ldpc_enc.code_block_mode = 1;
 	}
-	if (vector->turbo_enc.code_block_mode == 0) {
+	if (vector->ldpc_enc.code_block_mode == 0) {
+		if (!(mask & TEST_BBDEV_VF_MAX_CBG_PER_TB) && (vector->ldpc_enc.op_flags &
+				RTE_BBDEV_LDPC_ENC_CBGT)) {
+			printf(
+				"WARNING: max_cbg was not specified in vector file and will be set to 1\n");
+			vector->ldpc_enc.tb_params.max_cbg = 1;
+		}
 	} else {
-		if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags &
-				RTE_BBDEV_TURBO_RATE_MATCH))
+		if (!(mask & TEST_BBDEV_VF_E) && (vector->ldpc_enc.op_flags &
+				RTE_BBDEV_LDPC_RATE_MATCH))
 			printf(
 				"WARNING: e was not specified in vector file and will be set to 0\n");
 		if (!(mask & TEST_BBDEV_VF_NCB))
diff --git a/app/test-bbdev/test_bbdev_vector.h b/app/test-bbdev/test_bbdev_vector.h
index 4e5dbf5..69f5b9c 100644
--- a/app/test-bbdev/test_bbdev_vector.h
+++ b/app/test-bbdev/test_bbdev_vector.h
@@ -35,6 +35,9 @@  enum {
 	TEST_BBDEV_VF_CODE_BLOCK_MODE = (1ULL << 23),
 	TEST_BBDEV_VF_OP_FLAGS = (1ULL << 24),
 	TEST_BBDEV_VF_EXPECTED_STATUS = (1ULL << 25),
+	TEST_BBDEV_VF_MAX_CBG_PER_TB = (1ULL << 26),
+	TEST_BBDEV_VF_CBGTI = (1ULL << 27),
+	TEST_BBDEV_VF_CBGFI = (1ULL << 28),
 };
 
 enum op_data_type {
diff --git a/doc/guides/prog_guide/bbdev.rst b/doc/guides/prog_guide/bbdev.rst
index 6b2bd54..0ff4039 100644
--- a/doc/guides/prog_guide/bbdev.rst
+++ b/doc/guides/prog_guide/bbdev.rst
@@ -747,6 +747,9 @@  given below.
 |RTE_BBDEV_LDPC_ENC_CONCATENATION                                    |
 | Set if a device supports concatenation of non byte aligned output  |
 +--------------------------------------------------------------------+
+|RTE_BBDEV_LDPC_ENC_CBGT                                             |
+| Set if a device supports CB group transmission                     |
++--------------------------------------------------------------------+
 
 The structure passed for each LDPC encode operation is given below,
 with the operation flags forming a bitmask in the ``op_flags`` field.
@@ -815,6 +818,10 @@  The LDPC encode parameters are set out in the table below.
 +----------------+------------+-------------------------------------------------------+
 |                |eb          |Eb, length of the RM output sequence in bits, r >= cab |
 +----------------+------------+-------------------------------------------------------+
+|                |max_cbg     |maximum number of CB groups per TB: 1-8                |
++----------------+------------+-------------------------------------------------------+
+|                |cbgti       |CB group transmission information bitfield             |
++----------------+------------+-------------------------------------------------------+
 
 The mbuf input ``input`` is mandatory for all BBDEV PMDs and is the
 incoming code block or transport block data.
@@ -869,6 +876,11 @@  Figure :numref:`figure_turbo_tb_encode` above
 showing the Turbo encoding of CBs using BBDEV interface in TB-mode
 is also valid for LDPC encode.
 
+In TB-mode, If the ``RTE_BBDEV_LDPC_ENC_CBGT`` flag is specified the
+``max_cbg`` and ``cbgti`` parameters are used for CB group transmission. If
+the ``RTE_BBDEV_LDPC_ENC_CBGT`` flag is not specified, these parameters
+are ignored.
+
 BBDEV LDPC Decode Operation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -942,6 +954,9 @@  given below.
 |RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK                        |
 | Set if a device supports loopback access to HARQ internal memory   |
 +--------------------------------------------------------------------+
+|RTE_BBDEV_LDPC_DEC_CBGT                                             |
+| Set if a device supports CB group transmission                     |
++--------------------------------------------------------------------+
 
 The structure passed for each LDPC decode operation is given below,
 with the operation flags forming a bitmask in the ``op_flags`` field.
@@ -1027,6 +1042,14 @@  The LDPC decode parameters are set out in the table below.
 +----------------+------------+-------------------------------------------------------+
 |                |eb          |Eb, length of the RM output sequence in bits  r >= cab |
 +----------------+------------+-------------------------------------------------------+
+|                |max_cbg     |maximum number of CB groups per TB: 1-8                |
++----------------+------------+-------------------------------------------------------+
+|                |cbgti       |CB group transmission information bitfield             |
++----------------+------------+-------------------------------------------------------+
+|                |cbgfi       |CB group Flushing out Information (CBGFI)              |
++----------------+------------+-------------------------------------------------------+
+|                |cbg_crc_err |CB group CRC failure bitfield (output)                 |
++----------------+------------+-------------------------------------------------------+
 
 The mbuf input ``input`` encoded CB data is mandatory for all BBDEV PMDs
 and is the Virtual Circular Buffer data stream with null padding.
@@ -1084,6 +1107,12 @@  Figure :numref:`figure_turbo_tb_decode` above
 showing the Turbo decoding of CBs using BBDEV interface in TB-mode
 is also valid for LDPC decode.
 
+In TB-mode, If the ``RTE_BBDEV_LDPC_DEC_CBGT`` flag is specified the
+``max_cbg`` and ``cbgti`` parameters are used for CB group transmission. The
+``cbg_crc_err`` output parameter is a bitfield used to indicate crc failures
+in the respective CB groups. If the ``RTE_BBDEV_LDPC_DEC_CBGT`` flag is not
+specified, these parameters are ignored.
+
 
 Sample code
 -----------
diff --git a/lib/librte_bbdev/rte_bbdev_op.h b/lib/librte_bbdev/rte_bbdev_op.h
index f726d73..f3d00dc 100644
--- a/lib/librte_bbdev/rte_bbdev_op.h
+++ b/lib/librte_bbdev/rte_bbdev_op.h
@@ -186,7 +186,9 @@  enum rte_bbdev_op_ldpcdec_flag_bitmasks {
 	 *  for HARQ memory. If not set, it is assumed the filler bits are not
 	 *  in HARQ memory and handled directly by the LDPC decoder.
 	 */
-	RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_FILLERS = (1ULL << 18)
+	RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_FILLERS = (1ULL << 18),
+	/** Set if a device supports CB group transmission. */
+	RTE_BBDEV_LDPC_DEC_CBGT = (1ULL << 19)
 };
 
 /** Flags for LDPC encoder operation and capability structure */
@@ -206,7 +208,9 @@  enum rte_bbdev_op_ldpcenc_flag_bitmasks {
 	/** 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)
+	RTE_BBDEV_LDPC_ENC_CONCATENATION = (1ULL << 7),
+	/** Set if a device supports CB group transmission. */
+	RTE_BBDEV_LDPC_ENC_CBGT = (1ULL << 8)
 };
 
 /** Data input and output buffer for BBDEV operations */
@@ -334,6 +338,56 @@  struct rte_bbdev_op_dec_ldpc_tb_params {
 	uint8_t r;
 	/** The number of CBs that use Ea before switching to Eb, [0:63] */
 	uint8_t cab;
+	/** If the RTE_BBDEV_LDPC_DEC_CBGT capability is not asserted, then
+	 *  the value of max_cbg is ignored. Otherwise, a max_cbg value of
+	 *  0 or 1 indicates that codeBlockGroupTransmission is disabled,
+	 *  as defined in 3GPP TS 38.214.
+	 *
+	 *  A max_cbg value of 2, 4, 6, or 8 sets the value of
+	 *  maxCodeBlockGroupsPerTransportBlock and indicates that
+	 *  codeBlockGroupTransmission is enabled, as defined in 3GPP TS 38.214.
+	 */
+	uint8_t max_cbg;
+	/** If codeBlockGroupTransmission is disabled, then the value of cbgti
+	 *  is ignored. Otherwise, cbgti represents the Code Block Group
+	 *  Transmission Information (CBGTI), as defined in 3GPP TS 38.214.
+	 *  In this case, the M = min(C, max_cbg) number of Most Significant
+	 *  Bits (MSBs) of the uint8_t cbgti have an in-order one-to-one mapping
+	 *  with the M code block groups (CBGs) of the transport block, with the
+	 *  MSB mapped to CBG#0, as detailed in 3GPP TS 38.214.
+	 *
+	 *  Here, C is the total number of code blocks in the full transport block,
+	 *  as defined in 3GPP TS 38.212.
+	 */
+	uint8_t cbgti;
+	/** If codeBlockGroupTransmission is disabled, then the value of cbgfi
+	 * should be ignored. Otherwise, cbgfi represents the Code Block Group
+	 * Flushing out Information (CBGFI), as defined in 3GPP TS 38.214. In this
+	 * case, if the LSB of the uint8_t cbgfi is set to 0, this indicates that
+	 * the earlier received instances of the same CBGs being decoded may be
+	 * corrupted and that the corresponding contents of the HARQ memory should
+	 * be flushed and not combined with the present CBGs being decoded. If the
+	 * LSB of the uint8_t cbgfi is set to 1, this indicates that the earlier
+	 * received instances of the same CBGs being decoded should be combined with
+	 * the present CBGs being decoded.
+	 */
+	uint8_t cbgfi;
+
+	/** If codeBlockGroupTransmission is disabled or if
+	 *  RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK is not asserted, then the value of
+	 *  cbg_crc_err should be ignored. Otherwise, cbg_crc_err reports whether
+	 *  any CRC24B failures have been encountered in each of the code block
+	 *  groups (CBGs). In this case, the M = min(C, max_cbg) number of Most
+	 *  Significant Bits (MSBs) of the uint8_t cbg_crc_error have an in-order
+	 *  one-to-one mapping with the M CBGs of the transport block, with the MSB
+	 *  mapped to CBG#0, as detailed in 3GPP TS 38.214. An asserted bit
+	 *  indicates that a CRC24B failure was encountered among the code blocks
+	 *  of the corresponding CBG.
+	 *
+	 *  Here, C is the total number of code blocks in the full transport block,
+	 *  as defined in 3GPP TS 38.212.
+	 */
+	uint8_t cbg_crc_err;
 };
 
 /** Operation structure for Turbo decode.
@@ -584,6 +638,28 @@  struct rte_bbdev_op_enc_ldpc_tb_params {
 	uint8_t r;
 	/** The number of CBs that use Ea before switching to Eb, [0:63] */
 	uint8_t cab;
+	/** If the RTE_BBDEV_LDPC_ENC_CBGT capability is not asserted, then
+	 *  the value of max_cbg is ignored. Otherwise, a max_cbg value of
+	 *  0 or 1 indicates that codeBlockGroupTransmission is disabled,
+	 *  as defined in 3GPP TS 38.214.
+	 *
+	 *  A max_cbg value of 2, 4, 6, or 8 sets the value of
+	 *  maxCodeBlockGroupsPerTransportBlock and indicates that
+	 *  codeBlockGroupTransmission is enabled, as defined in 3GPP TS 38.214.
+	 */
+	uint8_t max_cbg;
+	/** If codeBlockGroupTransmission is disabled, then the value of cbgti
+	 *  is ignored. Otherwise, cbgti represents the Code Block Group
+	 *  Transmission Information (CBGTI), as defined in 3GPP TS 38.214.
+	 *  In this case, the M = min(C, max_cbg) number of Most Significant
+	 *  Bits (MSBs) of the uint8_t cbgti have an in-order one-to-one mapping
+	 *  with the M code block groups (CBGs) of the transport block, with the
+	 *  MSB mapped to CBG#0, as detailed in 3GPP TS 38.214.
+	 *
+	 *  Here, C is the total number of code blocks in the full transport block,
+	 *  as defined in 3GPP TS 38.212.
+	 */
+	uint8_t cbgti;
 };
 
 /** Operation structure for Turbo encode.