diff mbox

[dpdk-dev] baseband/turbo_sw: optimization of turbo software driver

Message ID 20180404140602.9344-3-kamilx.chalupnik@intel.com (mailing list archive)
State Superseded, archived
Delegated to: Thomas Monjalon
Headers show

Checks

Context Check Description
ci/checkpatch success coding style OK
ci/Intel-compilation fail apply patch file failure

Commit Message

Kamil Chalupnik April 4, 2018, 2:05 p.m. UTC
From: "Chalupnik, KamilX" <kamilx.chalupnik@intel.com>

Optimization of Turbo Software driver:
- resource-hungry piece of code removed or optimized
- validation of decoder/encoder parameters put under debug flag

Signed-off-by: KamilX Chalupnik <kamilx.chalupnik@intel.com>
---
 drivers/baseband/turbo_sw/bbdev_turbo_software.c | 264 +++++++++++++----------
 lib/librte_bbdev/rte_bbdev_op.h                  |  18 +-
 2 files changed, 172 insertions(+), 110 deletions(-)

Comments

Mokhtar, Amr April 13, 2018, 7:56 p.m. UTC | #1
> -----Original Message-----
> From: Chalupnik, KamilX
> Sent: Wednesday 4 April 2018 15:06
> To: dev@dpdk.org
> Cc: Mokhtar, Amr <amr.mokhtar@intel.com>; Chalupnik, KamilX
> <kamilx.chalupnik@intel.com>
> Subject: [PATCH] baseband/turbo_sw: optimization of turbo software
> driver
> 
> From: "Chalupnik, KamilX" <kamilx.chalupnik@intel.com>
> 
> Optimization of Turbo Software driver:
> - resource-hungry piece of code removed or optimized
> - validation of decoder/encoder parameters put under debug flag
> 
> Signed-off-by: KamilX Chalupnik <kamilx.chalupnik@intel.com>

Hi Kamil,
Patch fails to apply. A conflict at line 21 in bbdev_turbo_software.c. Probably it's outdated.
An updated patch may solve the problem.

Thanks,
Amr
diff mbox

Patch

diff --git a/drivers/baseband/turbo_sw/bbdev_turbo_software.c b/drivers/baseband/turbo_sw/bbdev_turbo_software.c
index 70691f3..0d3b00f 100644
--- a/drivers/baseband/turbo_sw/bbdev_turbo_software.c
+++ b/drivers/baseband/turbo_sw/bbdev_turbo_software.c
@@ -21,12 +21,6 @@ 
 
 #define DRIVER_NAME turbo_sw
 
-/* Number of columns in sub-block interleaver (36.212, section 5.1.4.1.1) */
-#define C_SUBBLOCK (32)
-#define MAX_TB_SIZE (391656)
-#define MAX_CB_SIZE (6144)
-#define MAX_KW (18528)
-
 /* private data structure */
 struct bbdev_private {
 	unsigned int max_nb_queues;  /**< Max number of queues */
@@ -47,6 +41,13 @@  static const char * const turbo_sw_valid_params[] = {
 	TURBO_SW_SOCKET_ID_ARG
 };
 
+/* Turbo SW PMD logging ID */
+static int turbosw_pmd_logtype;
+
+/* Helper macro for logging */
+#define turbosw_pmd_log(level, fmt, ...) \
+	rte_log(RTE_LOG_ ## level, turbosw_pmd_logtype, fmt "\n", ##__VA_ARGS__)
+
 /* queue */
 struct turbo_sw_queue {
 	/* Ring for processed (encoded/decoded) operations which are ready to
@@ -79,7 +80,7 @@  compute_idx(uint16_t k)
 {
 	int32_t result = 0;
 
-	if (k < 40 || k > MAX_CB_SIZE)
+	if (k < RTE_BBDEV_MIN_CB_SIZE || k > RTE_BBDEV_MAX_CB_SIZE)
 		return -1;
 
 	if (k > 2048) {
@@ -169,7 +170,7 @@  info_get(struct rte_bbdev *dev, struct rte_bbdev_driver_info *dev_info)
 	dev_info->cpu_flag_reqs = &cpu_flag;
 	dev_info->min_alignment = 64;
 
-	rte_bbdev_log_debug("got device info from %u\n", dev->data->dev_id);
+	turbosw_pmd_log(DEBUG, "got device info from %u\n", dev->data->dev_id);
 }
 
 /* Release queue */
@@ -191,7 +192,7 @@  q_release(struct rte_bbdev *dev, uint16_t q_id)
 		dev->data->queues[q_id].queue_private = NULL;
 	}
 
-	rte_bbdev_log_debug("released device queue %u:%u",
+	turbosw_pmd_log(DEBUG, "released device queue %u:%u",
 			dev->data->dev_id, q_id);
 	return 0;
 }
@@ -209,7 +210,7 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 	q = rte_zmalloc_socket(RTE_STR(DRIVER_NAME), sizeof(*q),
 			RTE_CACHE_LINE_SIZE, queue_conf->socket);
 	if (q == NULL) {
-		rte_bbdev_log(ERR, "Failed to allocate queue memory");
+		turbosw_pmd_log(ERR, "Failed to allocate queue memory");
 		return -ENOMEM;
 	}
 
@@ -217,16 +218,17 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 	ret = snprintf(name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME)"_enc_out%u:%u",
 			dev->data->dev_id, q_id);
 	if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Creating queue name for device %u queue %u failed",
 				dev->data->dev_id, q_id);
 		return -ENAMETOOLONG;
 	}
 	q->enc_out = rte_zmalloc_socket(name,
-			((MAX_TB_SIZE >> 3) + 3) * sizeof(*q->enc_out) * 3,
+			((RTE_BBDEV_MAX_TB_SIZE >> 3) + 3) *
+			sizeof(*q->enc_out) * 3,
 			RTE_CACHE_LINE_SIZE, queue_conf->socket);
 	if (q->enc_out == NULL) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 			"Failed to allocate queue memory for %s", name);
 		goto free_q;
 	}
@@ -236,16 +238,16 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 			RTE_STR(DRIVER_NAME)"_enc_in%u:%u", dev->data->dev_id,
 			q_id);
 	if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Creating queue name for device %u queue %u failed",
 				dev->data->dev_id, q_id);
 		return -ENAMETOOLONG;
 	}
 	q->enc_in = rte_zmalloc_socket(name,
-			(MAX_CB_SIZE >> 3) * sizeof(*q->enc_in),
+			(RTE_BBDEV_MAX_CB_SIZE >> 3) * sizeof(*q->enc_in),
 			RTE_CACHE_LINE_SIZE, queue_conf->socket);
 	if (q->enc_in == NULL) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 			"Failed to allocate queue memory for %s", name);
 		goto free_q;
 	}
@@ -254,16 +256,16 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 	ret = snprintf(name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME)"_ag%u:%u",
 			dev->data->dev_id, q_id);
 	if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Creating queue name for device %u queue %u failed",
 				dev->data->dev_id, q_id);
 		return -ENAMETOOLONG;
 	}
 	q->ag = rte_zmalloc_socket(name,
-			MAX_CB_SIZE * 10 * sizeof(*q->ag),
+			RTE_BBDEV_MAX_CB_SIZE * 10 * sizeof(*q->ag),
 			RTE_CACHE_LINE_SIZE, queue_conf->socket);
 	if (q->ag == NULL) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 			"Failed to allocate queue memory for %s", name);
 		goto free_q;
 	}
@@ -272,7 +274,7 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 	ret = snprintf(name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME)"_cb%u:%u",
 			dev->data->dev_id, q_id);
 	if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Creating queue name for device %u queue %u failed",
 				dev->data->dev_id, q_id);
 		return -ENAMETOOLONG;
@@ -281,7 +283,7 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 			(6144 >> 3) * sizeof(*q->code_block),
 			RTE_CACHE_LINE_SIZE, queue_conf->socket);
 	if (q->code_block == NULL) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 			"Failed to allocate queue memory for %s", name);
 		goto free_q;
 	}
@@ -291,16 +293,16 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 			RTE_STR(DRIVER_NAME)"_deint_input%u:%u",
 			dev->data->dev_id, q_id);
 	if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Creating queue name for device %u queue %u failed",
 				dev->data->dev_id, q_id);
 		return -ENAMETOOLONG;
 	}
 	q->deint_input = rte_zmalloc_socket(name,
-			MAX_KW * sizeof(*q->deint_input),
+			RTE_BBDEV_MAX_KW * sizeof(*q->deint_input),
 			RTE_CACHE_LINE_SIZE, queue_conf->socket);
 	if (q->deint_input == NULL) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 			"Failed to allocate queue memory for %s", name);
 		goto free_q;
 	}
@@ -310,16 +312,16 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 			RTE_STR(DRIVER_NAME)"_deint_output%u:%u",
 			dev->data->dev_id, q_id);
 	if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Creating queue name for device %u queue %u failed",
 				dev->data->dev_id, q_id);
 		return -ENAMETOOLONG;
 	}
 	q->deint_output = rte_zmalloc_socket(NULL,
-			MAX_KW * sizeof(*q->deint_output),
+			RTE_BBDEV_MAX_KW * sizeof(*q->deint_output),
 			RTE_CACHE_LINE_SIZE, queue_conf->socket);
 	if (q->deint_output == NULL) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 			"Failed to allocate queue memory for %s", name);
 		goto free_q;
 	}
@@ -329,16 +331,16 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 			RTE_STR(DRIVER_NAME)"_adapter_output%u:%u",
 			dev->data->dev_id, q_id);
 	if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Creating queue name for device %u queue %u failed",
 				dev->data->dev_id, q_id);
 		return -ENAMETOOLONG;
 	}
 	q->adapter_output = rte_zmalloc_socket(NULL,
-			MAX_CB_SIZE * 6 * sizeof(*q->adapter_output),
+			RTE_BBDEV_MAX_CB_SIZE * 6 * sizeof(*q->adapter_output),
 			RTE_CACHE_LINE_SIZE, queue_conf->socket);
 	if (q->adapter_output == NULL) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 			"Failed to allocate queue memory for %s", name);
 		goto free_q;
 	}
@@ -347,7 +349,7 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 	ret = snprintf(name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME)"%u:%u",
 			dev->data->dev_id, q_id);
 	if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Creating queue name for device %u queue %u failed",
 				dev->data->dev_id, q_id);
 		return -ENAMETOOLONG;
@@ -355,14 +357,14 @@  q_setup(struct rte_bbdev *dev, uint16_t q_id,
 	q->processed_pkts = rte_ring_create(name, queue_conf->queue_size,
 			queue_conf->socket, RING_F_SP_ENQ | RING_F_SC_DEQ);
 	if (q->processed_pkts == NULL) {
-		rte_bbdev_log(ERR, "Failed to create ring for %s", name);
+		turbosw_pmd_log(ERR, "Failed to create ring for %s", name);
 		goto free_q;
 	}
 
 	q->type = queue_conf->op_type;
 
 	dev->data->queues[q_id].queue_private = q;
-	rte_bbdev_log_debug("setup device queue %s", name);
+	turbosw_pmd_log(DEBUG, "setup device queue %s", name);
 	return 0;
 
 free_q:
@@ -384,6 +386,7 @@  static const struct rte_bbdev_ops pmd_ops = {
 	.queue_release = q_release
 };
 
+#ifdef RTE_LIBRTE_BBDEV_DEBUG
 /* Checks if the encoder input buffer is correct.
  * Returns 0 if it's valid, -1 otherwise.
  */
@@ -392,26 +395,28 @@  is_enc_input_valid(const uint16_t k, const int32_t k_idx,
 		const uint16_t in_length)
 {
 	if (k_idx < 0) {
-		rte_bbdev_log(ERR, "K Index is invalid");
+		turbosw_pmd_log(ERR, "K Index is invalid");
 		return -1;
 	}
 
 	if (in_length - (k >> 3) < 0) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Mismatch between input length (%u bytes) and K (%u bits)",
 				in_length, k);
 		return -1;
 	}
 
-	if (k > MAX_CB_SIZE) {
-		rte_bbdev_log(ERR, "CB size (%u) is too big, max: %d",
-				k, MAX_CB_SIZE);
+	if (k > RTE_BBDEV_MAX_CB_SIZE) {
+		turbosw_pmd_log(ERR, "CB size (%u) is too big, max: %d",
+				k, RTE_BBDEV_MAX_CB_SIZE);
 		return -1;
 	}
 
 	return 0;
 }
+#endif
 
+#ifdef RTE_LIBRTE_BBDEV_DEBUG
 /* Checks if the decoder input buffer is correct.
  * Returns 0 if it's valid, -1 otherwise.
  */
@@ -419,37 +424,43 @@  static inline int
 is_dec_input_valid(int32_t k_idx, int16_t kw, int16_t in_length)
 {
 	if (k_idx < 0) {
-		rte_bbdev_log(ERR, "K index is invalid");
+		turbosw_pmd_log(ERR, "K index is invalid");
 		return -1;
 	}
 
 	if (in_length - kw < 0) {
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Mismatch between input length (%u) and kw (%u)",
 				in_length, kw);
 		return -1;
 	}
 
-	if (kw > MAX_KW) {
-		rte_bbdev_log(ERR, "Input length (%u) is too big, max: %d",
-				kw, MAX_KW);
+	if (kw > RTE_BBDEV_MAX_KW) {
+		turbosw_pmd_log(ERR, "Input length (%u) is too big, max: %d",
+				kw, RTE_BBDEV_MAX_KW);
 		return -1;
 	}
 
 	return 0;
 }
+#endif
 
 static inline void
 process_enc_cb(struct turbo_sw_queue *q, struct rte_bbdev_enc_op *op,
-		uint8_t cb_idx, uint8_t c, uint16_t k, uint16_t ncb,
+		uint8_t r, uint8_t c, uint16_t k, uint16_t ncb,
 		uint32_t e, struct rte_mbuf *m_in, struct rte_mbuf *m_out,
 		uint16_t in_offset, uint16_t out_offset, uint16_t total_left,
 		struct rte_bbdev_stats *q_stats)
 {
+#ifdef RTE_LIBRTE_BBDEV_DEBUG
 	int ret;
+#else
+	RTE_SET_USED(total_left);
+#endif
 	int16_t k_idx;
 	uint16_t m;
 	uint8_t *in, *out0, *out1, *out2, *tmp_out, *rm_out;
+	uint64_t first_3_bytes = 0;
 	struct rte_bbdev_op_turbo_enc *enc = &op->turbo_enc;
 	struct bblib_crc_request crc_req;
 	struct bblib_crc_response crc_resp;
@@ -469,73 +480,116 @@  process_enc_cb(struct turbo_sw_queue *q, struct rte_bbdev_enc_op *op,
 	/* CRC24A (for TB) */
 	if ((enc->op_flags & RTE_BBDEV_TURBO_CRC_24A_ATTACH) &&
 		(enc->code_block_mode == 1)) {
+#ifdef RTE_LIBRTE_BBDEV_DEBUG
 		ret = is_enc_input_valid(k - 24, k_idx, total_left);
 		if (ret != 0) {
 			op->status |= 1 << RTE_BBDEV_DATA_ERROR;
 			return;
 		}
-		/* copy the input to the temporary buffer to be able to extend
-		 * it by 3 CRC bytes
-		 */
-		rte_memcpy(q->enc_in, in, (k - 24) >> 3);
+#endif
+
 		crc_req.data = in;
 		crc_req.len = (k - 24) >> 3;
-		crc_resp.data = q->enc_in;
+		/* Check if there is a room for CRC bits if not use
+		 * the temporary buffer.
+		 */
+		if (rte_pktmbuf_append(m_in, 3) == NULL) {
+			rte_memcpy(q->enc_in, in, (k - 24) >> 3);
+			in = q->enc_in;
+		} else {
+			/* Store 3 first bytes of next CB as they will be
+			 * overwritten by CRC bytes. If it is the last CB then
+			 * there is no point to store 3 next bytes and this
+			 * if..else branch will be omitted.
+			 */
+			first_3_bytes = *((uint64_t *)&in[(k - 32) >> 3]);
+		}
 
+		crc_resp.data = in;
 #ifdef RTE_TEST_BBDEV
 		start_time = rte_rdtsc_precise();
 #endif
-
 		bblib_lte_crc24a_gen(&crc_req, &crc_resp);
-
 #ifdef RTE_TEST_BBDEV
 		q_stats->turbo_perf_time += rte_rdtsc_precise() - start_time;
 #endif
-
-		in = q->enc_in;
 	} else if (enc->op_flags & RTE_BBDEV_TURBO_CRC_24B_ATTACH) {
 		/* CRC24B */
+#ifdef RTE_LIBRTE_BBDEV_DEBUG
 		ret = is_enc_input_valid(k - 24, k_idx, total_left);
 		if (ret != 0) {
 			op->status |= 1 << RTE_BBDEV_DATA_ERROR;
 			return;
 		}
-		/* copy the input to the temporary buffer to be able to extend
-		 * it by 3 CRC bytes
-		 */
-		rte_memcpy(q->enc_in, in, (k - 24) >> 3);
+#endif
+
 		crc_req.data = in;
 		crc_req.len = (k - 24) >> 3;
-		crc_resp.data = q->enc_in;
+		/* Check if there is a room for CRC bits if this is the last
+		 * CB in TB. If not use temporary buffer.
+		 */
+		if ((c - r == 1) && (rte_pktmbuf_append(m_in, 3) == NULL)) {
+			rte_memcpy(q->enc_in, in, (k - 24) >> 3);
+			in = q->enc_in;
+		} else if (c - r > 1) {
+			/* Store 3 first bytes of next CB as they will be
+			 * overwritten by CRC bytes. If it is the last CB then
+			 * there is no point to store 3 next bytes and this
+			 * if..else branch will be omitted.
+			 */
+			first_3_bytes = *((uint64_t *)&in[(k - 32) >> 3]);
+		}
 
+		crc_resp.data = in;
 #ifdef RTE_TEST_BBDEV
 		start_time = rte_rdtsc_precise();
 #endif
-
 		bblib_lte_crc24b_gen(&crc_req, &crc_resp);
-
 #ifdef RTE_TEST_BBDEV
 		q_stats->turbo_perf_time += rte_rdtsc_precise() - start_time;
 #endif
-
-		in = q->enc_in;
-	} else {
+	}
+#ifdef RTE_LIBRTE_BBDEV_DEBUG
+	else {
 		ret = is_enc_input_valid(k, k_idx, total_left);
 		if (ret != 0) {
 			op->status |= 1 << RTE_BBDEV_DATA_ERROR;
 			return;
 		}
 	}
+#endif
 
 	/* Turbo encoder */
 
 	/* Each bit layer output from turbo encoder is (k+4) bits long, i.e.
 	 * input length + 4 tail bits. That's (k/8) + 1 bytes after rounding up.
 	 * So dst_data's length should be 3*(k/8) + 3 bytes.
+	 * In Rate-matching bypass case outputs pointers passed to encoder
+	 * (out0, out1 and out2) can directly point to addresses of output from
+	 * turbo_enc entity.
 	 */
-	out0 = q->enc_out;
-	out1 = RTE_PTR_ADD(out0, (k >> 3) + 1);
-	out2 = RTE_PTR_ADD(out1, (k >> 3) + 1);
+	if (enc->op_flags & RTE_BBDEV_TURBO_RATE_MATCH) {
+		out0 = q->enc_out;
+		out1 = RTE_PTR_ADD(out0, (k >> 3) + 1);
+		out2 = RTE_PTR_ADD(out1, (k >> 3) + 1);
+	} else {
+		out0 = (uint8_t *)rte_pktmbuf_append(m_out, (k >> 3) * 3 + 2);
+		if (out0 == NULL) {
+			op->status |= 1 << RTE_BBDEV_DATA_ERROR;
+			turbosw_pmd_log(ERR,
+					"Too little space in output mbuf");
+			return;
+		}
+		enc->output.length += (k >> 3) * 3 + 2;
+		/* rte_bbdev_op_data.offset can be different than the
+		 * offset of the appended bytes
+		 */
+		out0 = rte_pktmbuf_mtod_offset(m_out, uint8_t *, out_offset);
+		out1 = rte_pktmbuf_mtod_offset(m_out, uint8_t *,
+				out_offset + (k >> 3) + 1);
+		out2 = rte_pktmbuf_mtod_offset(m_out, uint8_t *,
+				out_offset + 2 * ((k >> 3) + 1));
+	}
 
 	turbo_req.case_id = k_idx;
 	turbo_req.input_win = in;
@@ -550,7 +604,7 @@  process_enc_cb(struct turbo_sw_queue *q, struct rte_bbdev_enc_op *op,
 
 	if (bblib_turbo_encoder(&turbo_req, &turbo_resp) != 0) {
 		op->status |= 1 << RTE_BBDEV_DRV_ERROR;
-		rte_bbdev_log(ERR, "Turbo Encoder failed");
+		turbosw_pmd_log(ERR, "Turbo Encoder failed");
 		return;
 	}
 
@@ -558,13 +612,17 @@  process_enc_cb(struct turbo_sw_queue *q, struct rte_bbdev_enc_op *op,
 	q_stats->turbo_perf_time += rte_rdtsc_precise() - start_time;
 #endif
 
+	/* Restore 3 first bytes of next CB if they were overwritten by CRC*/
+	if (first_3_bytes != 0)
+		*((uint64_t *)&in[(k - 32) >> 3]) = first_3_bytes;
+
 	/* Rate-matching */
 	if (enc->op_flags & RTE_BBDEV_TURBO_RATE_MATCH) {
 		/* get output data starting address */
 		rm_out = (uint8_t *)rte_pktmbuf_append(m_out, (e >> 3));
 		if (rm_out == NULL) {
 			op->status |= 1 << RTE_BBDEV_DATA_ERROR;
-			rte_bbdev_log(ERR,
+			turbosw_pmd_log(ERR,
 					"Too little space in output mbuf");
 			return;
 		}
@@ -574,7 +632,7 @@  process_enc_cb(struct turbo_sw_queue *q, struct rte_bbdev_enc_op *op,
 		rm_out = rte_pktmbuf_mtod_offset(m_out, uint8_t *, out_offset);
 
 		/* index of current code block */
-		rm_req.r = cb_idx;
+		rm_req.r = r;
 		/* total number of code block */
 		rm_req.C = c;
 		/* For DL - 1, UL - 0 */
@@ -613,7 +671,7 @@  process_enc_cb(struct turbo_sw_queue *q, struct rte_bbdev_enc_op *op,
 
 		if (bblib_rate_match_dl(&rm_req, &rm_resp) != 0) {
 			op->status |= 1 << RTE_BBDEV_DRV_ERROR;
-			rte_bbdev_log(ERR, "Rate matching failed");
+			turbosw_pmd_log(ERR, "Rate matching failed");
 			return;
 		}
 
@@ -644,23 +702,6 @@  process_enc_cb(struct turbo_sw_queue *q, struct rte_bbdev_enc_op *op,
 			tmp_out++;
 		}
 		*tmp_out = 0;
-
-		/* copy shifted output to turbo_enc entity */
-		out0 = (uint8_t *)rte_pktmbuf_append(m_out,
-				(k >> 3) * 3 + 2);
-		if (out0 == NULL) {
-			op->status |= 1 << RTE_BBDEV_DATA_ERROR;
-			rte_bbdev_log(ERR,
-					"Too little space in output mbuf");
-			return;
-		}
-		enc->output.length += (k >> 3) * 3 + 2;
-		/* rte_bbdev_op_data.offset can be different than the
-		 * offset of the appended bytes
-		 */
-		out0 = rte_pktmbuf_mtod_offset(m_out, uint8_t *,
-				out_offset);
-		rte_memcpy(out0, q->enc_out, (k >> 3) * 3 + 2);
 	}
 }
 
@@ -681,15 +722,15 @@  enqueue_enc_one_op(struct turbo_sw_queue *q, struct rte_bbdev_enc_op *op,
 	/* Clear op status */
 	op->status = 0;
 
-	if (total_left > MAX_TB_SIZE >> 3) {
-		rte_bbdev_log(ERR, "TB size (%u) is too big, max: %d",
-				total_left, MAX_TB_SIZE);
+	if (total_left > RTE_BBDEV_MAX_TB_SIZE >> 3) {
+		turbosw_pmd_log(ERR, "TB size (%u) is too big, max: %d",
+				total_left, RTE_BBDEV_MAX_TB_SIZE);
 		op->status = 1 << RTE_BBDEV_DATA_ERROR;
 		return;
 	}
 
 	if (m_in == NULL || m_out == NULL) {
-		rte_bbdev_log(ERR, "Invalid mbuf pointer");
+		turbosw_pmd_log(ERR, "Invalid mbuf pointer");
 		op->status = 1 << RTE_BBDEV_DATA_ERROR;
 		return;
 	}
@@ -737,7 +778,7 @@  enqueue_enc_one_op(struct turbo_sw_queue *q, struct rte_bbdev_enc_op *op,
 	/* check if all input data was processed */
 	if (total_left != 0) {
 		op->status |= 1 << RTE_BBDEV_DATA_ERROR;
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Mismatch between mbuf length and included CBs sizes");
 	}
 }
@@ -772,11 +813,11 @@  remove_nulls_from_circular_buf(const uint8_t *in, uint8_t *out, uint16_t k,
 	const uint32_t d = k + 4;
 	const uint32_t kw = (ncb / 3);
 	const uint32_t nd = kw - d;
-	const uint32_t r_subblock = kw / C_SUBBLOCK;
+	const uint32_t r_subblock = kw / RTE_BBDEV_C_SUBBLOCK;
 	/* Inter-column permutation pattern */
-	const uint32_t P[C_SUBBLOCK] = {0, 16, 8, 24, 4, 20, 12, 28, 2, 18, 10,
-			26, 6, 22, 14, 30, 1, 17, 9, 25, 5, 21, 13, 29, 3, 19,
-			11, 27, 7, 23, 15, 31};
+	const uint32_t P[RTE_BBDEV_C_SUBBLOCK] = {0, 16, 8, 24, 4, 20, 12, 28,
+			2, 18, 10, 26, 6, 22, 14, 30, 1, 17, 9, 25, 5, 21, 13,
+			29, 3, 19, 11, 27, 7, 23, 15, 31};
 	in_idx = 0;
 	out_idx = 0;
 
@@ -857,7 +898,11 @@  process_dec_cb(struct turbo_sw_queue *q, struct rte_bbdev_dec_op *op,
 		struct rte_mbuf *m_out, uint16_t in_offset, uint16_t out_offset,
 		bool check_crc_24b, uint16_t total_left)
 {
+#ifdef RTE_LIBRTE_BBDEV_DEBUG
 	int ret;
+#else
+	RTE_SET_USED(total_left);
+#endif
 	int32_t k_idx;
 	int32_t iter_cnt;
 	uint8_t *in, *out, *adapter_input;
@@ -870,11 +915,13 @@  process_dec_cb(struct turbo_sw_queue *q, struct rte_bbdev_dec_op *op,
 
 	k_idx = compute_idx(k);
 
+#ifdef RTE_LIBRTE_BBDEV_DEBUG
 	ret = is_dec_input_valid(k_idx, kw, total_left);
 	if (ret != 0) {
 		op->status |= 1 << RTE_BBDEV_DATA_ERROR;
 		return;
 	}
+#endif
 
 	in = rte_pktmbuf_mtod_offset(m_in, uint8_t *, in_offset);
 	ncb = kw;
@@ -904,7 +951,7 @@  process_dec_cb(struct turbo_sw_queue *q, struct rte_bbdev_dec_op *op,
 		adapter_req.isinverted = 0;
 	else {
 		op->status |= 1 << RTE_BBDEV_DRV_ERROR;
-		rte_bbdev_log(ERR, "LLR format wasn't specified");
+		turbosw_pmd_log(ERR, "LLR format wasn't specified");
 		return;
 	}
 
@@ -916,7 +963,7 @@  process_dec_cb(struct turbo_sw_queue *q, struct rte_bbdev_dec_op *op,
 	out = (uint8_t *)rte_pktmbuf_append(m_out, (k >> 3));
 	if (out == NULL) {
 		op->status |= 1 << RTE_BBDEV_DATA_ERROR;
-		rte_bbdev_log(ERR, "Too little space in output mbuf");
+		turbosw_pmd_log(ERR, "Too little space in output mbuf");
 		return;
 	}
 	/* rte_bbdev_op_data.offset can be different than the offset of the
@@ -945,7 +992,7 @@  process_dec_cb(struct turbo_sw_queue *q, struct rte_bbdev_dec_op *op,
 		dec->iter_count = RTE_MAX(iter_cnt, dec->iter_count);
 	} else {
 		op->status |= 1 << RTE_BBDEV_DATA_ERROR;
-		rte_bbdev_log(ERR, "Turbo Decoder failed");
+		turbosw_pmd_log(ERR, "Turbo Decoder failed");
 		return;
 	}
 }
@@ -966,7 +1013,7 @@  enqueue_dec_one_op(struct turbo_sw_queue *q, struct rte_bbdev_dec_op *op)
 	op->status = 0;
 
 	if (m_in == NULL || m_out == NULL) {
-		rte_bbdev_log(ERR, "Invalid mbuf pointer");
+		turbosw_pmd_log(ERR, "Invalid mbuf pointer");
 		op->status = 1 << RTE_BBDEV_DATA_ERROR;
 		return;
 	}
@@ -993,7 +1040,7 @@  enqueue_dec_one_op(struct turbo_sw_queue *q, struct rte_bbdev_dec_op *op)
 		 * where D is the size of each output from turbo encoder block
 		 * (k + 4).
 		 */
-		kw = RTE_ALIGN_CEIL(k + 4, C_SUBBLOCK) * 3;
+		kw = RTE_ALIGN_CEIL(k + 4, RTE_BBDEV_C_SUBBLOCK) * 3;
 
 		process_dec_cb(q, op, c, k, kw, m_in, m_out, in_offset,
 				out_offset, check_bit(dec->op_flags,
@@ -1012,7 +1059,7 @@  enqueue_dec_one_op(struct turbo_sw_queue *q, struct rte_bbdev_dec_op *op)
 	}
 	if (total_left != 0) {
 		op->status |= 1 << RTE_BBDEV_DATA_ERROR;
-		rte_bbdev_log(ERR,
+		turbosw_pmd_log(ERR,
 				"Mismatch between mbuf length and included Circular buffer sizes");
 	}
 }
@@ -1102,7 +1149,7 @@  parse_u16_arg(const char *key, const char *value, void *extra_args)
 	errno = 0;
 	result = strtoul(value, NULL, 0);
 	if ((result >= (1 << 16)) || (errno != 0)) {
-		rte_bbdev_log(ERR, "Invalid value %lu for %s", result, key);
+		turbosw_pmd_log(ERR, "Invalid value %lu for %s", result, key);
 		return -ERANGE;
 	}
 	*u16 = (uint16_t)result;
@@ -1134,7 +1181,7 @@  parse_turbo_sw_params(struct turbo_sw_params *params, const char *input_args)
 			goto exit;
 
 		if (params->socket_id >= RTE_MAX_NUMA_NODES) {
-			rte_bbdev_log(ERR, "Invalid socket, must be < %u",
+			turbosw_pmd_log(ERR, "Invalid socket, must be < %u",
 					RTE_MAX_NUMA_NODES);
 			goto exit;
 		}
@@ -1202,7 +1249,7 @@  turbo_sw_bbdev_probe(struct rte_vdev_device *vdev)
 	input_args = rte_vdev_device_args(vdev);
 	parse_turbo_sw_params(&init_params, input_args);
 
-	rte_bbdev_log_debug(
+	turbosw_pmd_log(DEBUG,
 			"Initialising %s on NUMA node %d with max queues: %d\n",
 			name, init_params.socket_id, init_params.queues_num);
 
@@ -1242,12 +1289,11 @@  RTE_PMD_REGISTER_PARAM_STRING(DRIVER_NAME,
 	TURBO_SW_MAX_NB_QUEUES_ARG"=<int> "
 	TURBO_SW_SOCKET_ID_ARG"=<int>");
 
-int bbdev_logtype;
 RTE_INIT(null_bbdev_init_log);
 static void
 null_bbdev_init_log(void)
 {
-	bbdev_logtype = rte_log_register("pmd.bbdev.turbo_sw");
-	if (bbdev_logtype >= 0)
-		rte_log_set_level(bbdev_logtype, RTE_LOG_NOTICE);
+	turbosw_pmd_logtype = rte_log_register("pmd.bbdev.turbo_sw");
+	if (turbosw_pmd_logtype >= 0)
+		rte_log_set_level(turbosw_pmd_logtype, RTE_LOG_NOTICE);
 }
diff --git a/lib/librte_bbdev/rte_bbdev_op.h b/lib/librte_bbdev/rte_bbdev_op.h
index 9a80c64..1a80588 100644
--- a/lib/librte_bbdev/rte_bbdev_op.h
+++ b/lib/librte_bbdev/rte_bbdev_op.h
@@ -25,7 +25,23 @@  extern "C" {
 #include <rte_memory.h>
 #include <rte_mempool.h>
 
-#define RTE_BBDEV_MAX_CODE_BLOCKS 64
+/* Number of columns in sub-block interleaver (36.212, section 5.1.4.1.1) */
+#define RTE_BBDEV_C_SUBBLOCK (32)
+/* Maximum size of Transport Block (36.213, Table, Table 7.1.7.2.5-1) */
+#define RTE_BBDEV_MAX_TB_SIZE (391656)
+/* Maximum size of Code Block (36.212, Table 5.1.3-3) */
+#define RTE_BBDEV_MAX_CB_SIZE (6144)
+/* Minimum size of Code Block (36.212, Table 5.1.3-3) */
+#define RTE_BBDEV_MIN_CB_SIZE (40)
+/* Maximum size of circular buffer */
+#define RTE_BBDEV_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):
+ * (391656 + 24) / (6144 - 24) = 64
+ */
+#define RTE_BBDEV_MAX_CODE_BLOCKS (64)
 
 /** Flags for turbo decoder operation and capability structure */
 enum rte_bbdev_op_td_flag_bitmasks {