1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Intel Corporation
5 #ifdef RTE_EXEC_ENV_FREEBSD
10 #include <rte_malloc.h>
12 #include "test_bbdev_vector.h"
14 #define VALUE_DELIMITER ","
15 #define ENTRY_DELIMITER "="
17 const char *op_data_prefixes[] = {
25 /* trim leading and trailing spaces */
31 for (start = str; *start; start++) {
32 if (!isspace((unsigned char) start[0]))
36 for (end = start + strlen(start); end > start + 1; end--) {
37 if (!isspace((unsigned char) end[-1]))
43 /* Shift from "start" to the beginning of the string */
45 memmove(str, start, (end - start) + 1);
49 starts_with(const char *str, const char *pre)
51 return strncmp(pre, str, strlen(pre)) == 0;
54 /* tokenization test values separated by a comma */
56 parse_values(char *tokens, uint32_t **data, uint32_t *data_length)
58 uint32_t n_tokens = 0;
59 uint32_t data_size = 32;
61 uint32_t *values, *values_resized;
62 char *tok, *error = NULL;
64 tok = strtok(tokens, VALUE_DELIMITER);
69 rte_zmalloc(NULL, sizeof(uint32_t) * data_size, 0);
74 values_resized = NULL;
76 if (n_tokens >= data_size) {
79 values_resized = (uint32_t *) rte_realloc(values,
80 sizeof(uint32_t) * data_size, 0);
81 if (values_resized == NULL) {
85 values = values_resized;
88 values[n_tokens] = (uint32_t) strtoul(tok, &error, 0);
90 if ((error == NULL) || (*error != '\0')) {
91 printf("Failed with convert '%s'\n", tok);
96 *data_length = *data_length + (strlen(tok) - strlen("0x"))/2;
98 tok = strtok(NULL, VALUE_DELIMITER);
105 values_resized = (uint32_t *) rte_realloc(values,
106 sizeof(uint32_t) * (n_tokens + 1), 0);
108 if (values_resized == NULL) {
113 *data = values_resized;
118 /* convert turbo decoder flag from string to unsigned long int*/
120 op_decoder_flag_strtoul(char *token, uint32_t *op_flag_value)
122 if (!strcmp(token, "RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE"))
123 *op_flag_value = RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE;
124 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_TYPE_24B"))
125 *op_flag_value = RTE_BBDEV_TURBO_CRC_TYPE_24B;
126 else if (!strcmp(token, "RTE_BBDEV_TURBO_EQUALIZER"))
127 *op_flag_value = RTE_BBDEV_TURBO_EQUALIZER;
128 else if (!strcmp(token, "RTE_BBDEV_TURBO_SOFT_OUT_SATURATE"))
129 *op_flag_value = RTE_BBDEV_TURBO_SOFT_OUT_SATURATE;
130 else if (!strcmp(token, "RTE_BBDEV_TURBO_HALF_ITERATION_EVEN"))
131 *op_flag_value = RTE_BBDEV_TURBO_HALF_ITERATION_EVEN;
132 else if (!strcmp(token, "RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH"))
133 *op_flag_value = RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH;
134 else if (!strcmp(token, "RTE_BBDEV_TURBO_SOFT_OUTPUT"))
135 *op_flag_value = RTE_BBDEV_TURBO_SOFT_OUTPUT;
136 else if (!strcmp(token, "RTE_BBDEV_TURBO_EARLY_TERMINATION"))
137 *op_flag_value = RTE_BBDEV_TURBO_EARLY_TERMINATION;
138 else if (!strcmp(token, "RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN"))
139 *op_flag_value = RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN;
140 else if (!strcmp(token, "RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN"))
141 *op_flag_value = RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN;
142 else if (!strcmp(token, "RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT"))
143 *op_flag_value = RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT;
144 else if (!strcmp(token, "RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT"))
145 *op_flag_value = RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT;
146 else if (!strcmp(token, "RTE_BBDEV_TURBO_MAP_DEC"))
147 *op_flag_value = RTE_BBDEV_TURBO_MAP_DEC;
148 else if (!strcmp(token, "RTE_BBDEV_TURBO_DEC_SCATTER_GATHER"))
149 *op_flag_value = RTE_BBDEV_TURBO_DEC_SCATTER_GATHER;
150 else if (!strcmp(token, "RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP"))
151 *op_flag_value = RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP;
153 printf("The given value is not a turbo decoder flag\n");
160 /* convert LDPC flag from string to unsigned long int*/
162 op_ldpc_decoder_flag_strtoul(char *token, uint32_t *op_flag_value)
164 if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_TYPE_24A_CHECK"))
165 *op_flag_value = RTE_BBDEV_LDPC_CRC_TYPE_24A_CHECK;
166 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK"))
167 *op_flag_value = RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK;
168 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_TYPE_24B_DROP"))
169 *op_flag_value = RTE_BBDEV_LDPC_CRC_TYPE_24B_DROP;
170 else if (!strcmp(token, "RTE_BBDEV_LDPC_DEINTERLEAVER_BYPASS"))
171 *op_flag_value = RTE_BBDEV_LDPC_DEINTERLEAVER_BYPASS;
172 else if (!strcmp(token, "RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE"))
173 *op_flag_value = RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE;
174 else if (!strcmp(token, "RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE"))
175 *op_flag_value = RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE;
176 else if (!strcmp(token, "RTE_BBDEV_LDPC_DECODE_BYPASS"))
177 *op_flag_value = RTE_BBDEV_LDPC_DECODE_BYPASS;
178 else if (!strcmp(token, "RTE_BBDEV_LDPC_SOFT_OUT_ENABLE"))
179 *op_flag_value = RTE_BBDEV_LDPC_SOFT_OUT_ENABLE;
180 else if (!strcmp(token, "RTE_BBDEV_LDPC_SOFT_OUT_RM_BYPASS"))
181 *op_flag_value = RTE_BBDEV_LDPC_SOFT_OUT_RM_BYPASS;
182 else if (!strcmp(token, "RTE_BBDEV_LDPC_SOFT_OUT_DEINTERLEAVER_BYPASS"))
183 *op_flag_value = RTE_BBDEV_LDPC_SOFT_OUT_DEINTERLEAVER_BYPASS;
184 else if (!strcmp(token, "RTE_BBDEV_LDPC_ITERATION_STOP_ENABLE"))
185 *op_flag_value = RTE_BBDEV_LDPC_ITERATION_STOP_ENABLE;
186 else if (!strcmp(token, "RTE_BBDEV_LDPC_DEC_INTERRUPTS"))
187 *op_flag_value = RTE_BBDEV_LDPC_DEC_INTERRUPTS;
188 else if (!strcmp(token, "RTE_BBDEV_LDPC_DEC_SCATTER_GATHER"))
189 *op_flag_value = RTE_BBDEV_LDPC_DEC_SCATTER_GATHER;
190 else if (!strcmp(token, "RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION"))
191 *op_flag_value = RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION;
192 else if (!strcmp(token, "RTE_BBDEV_LDPC_LLR_COMPRESSION"))
193 *op_flag_value = RTE_BBDEV_LDPC_LLR_COMPRESSION;
194 else if (!strcmp(token,
195 "RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE"))
196 *op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE;
197 else if (!strcmp(token,
198 "RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE"))
199 *op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE;
200 else if (!strcmp(token,
201 "RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK"))
202 *op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK;
204 printf("The given value is not a LDPC decoder flag\n");
211 /* convert turbo encoder flag from string to unsigned long int*/
213 op_encoder_flag_strtoul(char *token, uint32_t *op_flag_value)
215 if (!strcmp(token, "RTE_BBDEV_TURBO_RV_INDEX_BYPASS"))
216 *op_flag_value = RTE_BBDEV_TURBO_RV_INDEX_BYPASS;
217 else if (!strcmp(token, "RTE_BBDEV_TURBO_RATE_MATCH"))
218 *op_flag_value = RTE_BBDEV_TURBO_RATE_MATCH;
219 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_24B_ATTACH"))
220 *op_flag_value = RTE_BBDEV_TURBO_CRC_24B_ATTACH;
221 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_24A_ATTACH"))
222 *op_flag_value = RTE_BBDEV_TURBO_CRC_24A_ATTACH;
223 else if (!strcmp(token, "RTE_BBDEV_TURBO_ENC_SCATTER_GATHER"))
224 *op_flag_value = RTE_BBDEV_TURBO_ENC_SCATTER_GATHER;
226 printf("The given value is not a turbo encoder flag\n");
233 /* convert LDPC encoder flag from string to unsigned long int*/
235 op_ldpc_encoder_flag_strtoul(char *token, uint32_t *op_flag_value)
237 if (!strcmp(token, "RTE_BBDEV_LDPC_INTERLEAVER_BYPASS"))
238 *op_flag_value = RTE_BBDEV_LDPC_INTERLEAVER_BYPASS;
239 else if (!strcmp(token, "RTE_BBDEV_LDPC_RATE_MATCH"))
240 *op_flag_value = RTE_BBDEV_LDPC_RATE_MATCH;
241 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_24A_ATTACH"))
242 *op_flag_value = RTE_BBDEV_LDPC_CRC_24A_ATTACH;
243 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_24B_ATTACH"))
244 *op_flag_value = RTE_BBDEV_LDPC_CRC_24B_ATTACH;
245 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_16_ATTACH"))
246 *op_flag_value = RTE_BBDEV_LDPC_CRC_16_ATTACH;
247 else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_INTERRUPTS"))
248 *op_flag_value = RTE_BBDEV_LDPC_ENC_INTERRUPTS;
249 else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_SCATTER_GATHER"))
250 *op_flag_value = RTE_BBDEV_LDPC_ENC_SCATTER_GATHER;
252 printf("The given value is not a turbo encoder flag\n");
259 /* tokenization turbo decoder/encoder flags values separated by a comma */
261 parse_turbo_flags(char *tokens, uint32_t *op_flags,
262 enum rte_bbdev_op_type op_type)
265 uint32_t op_flag_value = 0;
267 tok = strtok(tokens, VALUE_DELIMITER);
271 while (tok != NULL) {
273 if (op_type == RTE_BBDEV_OP_TURBO_DEC) {
274 if (op_decoder_flag_strtoul(tok, &op_flag_value) == -1)
276 } else if (op_type == RTE_BBDEV_OP_TURBO_ENC) {
277 if (op_encoder_flag_strtoul(tok, &op_flag_value) == -1)
279 } else if (op_type == RTE_BBDEV_OP_LDPC_ENC) {
280 if (op_ldpc_encoder_flag_strtoul(tok, &op_flag_value)
283 } else if (op_type == RTE_BBDEV_OP_LDPC_DEC) {
284 if (op_ldpc_decoder_flag_strtoul(tok, &op_flag_value)
291 *op_flags = *op_flags | op_flag_value;
293 tok = strtok(NULL, VALUE_DELIMITER);
301 /* convert turbo encoder/decoder op_type from string to enum*/
303 op_turbo_type_strtol(char *token, enum rte_bbdev_op_type *op_type)
306 if (!strcmp(token, "RTE_BBDEV_OP_TURBO_DEC"))
307 *op_type = RTE_BBDEV_OP_TURBO_DEC;
308 else if (!strcmp(token, "RTE_BBDEV_OP_TURBO_ENC"))
309 *op_type = RTE_BBDEV_OP_TURBO_ENC;
310 else if (!strcmp(token, "RTE_BBDEV_OP_LDPC_ENC"))
311 *op_type = RTE_BBDEV_OP_LDPC_ENC;
312 else if (!strcmp(token, "RTE_BBDEV_OP_LDPC_DEC"))
313 *op_type = RTE_BBDEV_OP_LDPC_DEC;
314 else if (!strcmp(token, "RTE_BBDEV_OP_NONE"))
315 *op_type = RTE_BBDEV_OP_NONE;
317 printf("Not valid turbo op_type: '%s'\n", token);
324 /* tokenization expected status values separated by a comma */
326 parse_expected_status(char *tokens, int *status, enum rte_bbdev_op_type op_type)
329 bool status_ok = false;
331 tok = strtok(tokens, VALUE_DELIMITER);
335 while (tok != NULL) {
337 if (!strcmp(tok, "OK"))
339 else if (!strcmp(tok, "DMA"))
340 *status = *status | (1 << RTE_BBDEV_DRV_ERROR);
341 else if (!strcmp(tok, "FCW"))
342 *status = *status | (1 << RTE_BBDEV_DATA_ERROR);
343 else if (!strcmp(tok, "SYNCRC")) {
344 *status = *status | (1 << RTE_BBDEV_SYNDROME_ERROR);
345 *status = *status | (1 << RTE_BBDEV_CRC_ERROR);
346 } else if (!strcmp(tok, "SYN"))
347 *status = *status | (1 << RTE_BBDEV_SYNDROME_ERROR);
348 else if (!strcmp(tok, "CRC")) {
349 if ((op_type == RTE_BBDEV_OP_TURBO_DEC) ||
350 (op_type == RTE_BBDEV_OP_LDPC_DEC))
351 *status = *status | (1 << RTE_BBDEV_CRC_ERROR);
354 "CRC is only a valid value for decoder\n");
358 printf("Not valid status: '%s'\n", tok);
362 tok = strtok(NULL, VALUE_DELIMITER);
367 if (status_ok && *status != 0) {
369 "Not valid status values. Cannot be OK and ERROR at the same time.\n");
376 /* parse ops data entry (there can be more than 1 input entry, each will be
377 * contained in a separate op_data_buf struct)
380 parse_data_entry(const char *key_token, char *token,
381 struct test_bbdev_vector *vector, enum op_data_type type,
385 uint32_t data_length = 0;
386 uint32_t *data = NULL;
388 struct op_data_buf *op_data;
389 unsigned int *nb_ops;
391 if (type >= DATA_NUM_TYPES) {
392 printf("Unknown op type: %d!\n", type);
396 op_data = vector->entries[type].segments;
397 nb_ops = &vector->entries[type].nb_segments;
399 if (*nb_ops >= RTE_BBDEV_TURBO_MAX_CODE_BLOCKS) {
400 printf("Too many segments (code blocks defined): %u, max %d!\n",
401 *nb_ops, RTE_BBDEV_TURBO_MAX_CODE_BLOCKS);
405 if (sscanf(key_token + strlen(prefix), "%u", &id) != 1) {
406 printf("Missing ID of %s\n", prefix);
411 "Please order data entries sequentially, i.e. %s0, %s1, ...\n",
416 /* Clear new op data struct */
417 memset(op_data + *nb_ops, 0, sizeof(struct op_data_buf));
419 ret = parse_values(token, &data, &data_length);
421 op_data[*nb_ops].addr = data;
422 op_data[*nb_ops].length = data_length;
429 /* parses turbo decoder parameters and assigns to global variable */
431 parse_decoder_params(const char *key_token, char *token,
432 struct test_bbdev_vector *vector)
434 int ret = 0, status = 0;
435 uint32_t op_flags = 0;
438 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
441 if (starts_with(key_token, op_data_prefixes[DATA_INPUT]))
442 ret = parse_data_entry(key_token, token, vector,
443 DATA_INPUT, op_data_prefixes[DATA_INPUT]);
445 else if (starts_with(key_token, op_data_prefixes[DATA_SOFT_OUTPUT]))
446 ret = parse_data_entry(key_token, token, vector,
448 op_data_prefixes[DATA_SOFT_OUTPUT]);
450 else if (starts_with(key_token, op_data_prefixes[DATA_HARD_OUTPUT]))
451 ret = parse_data_entry(key_token, token, vector,
453 op_data_prefixes[DATA_HARD_OUTPUT]);
454 else if (!strcmp(key_token, "e")) {
455 vector->mask |= TEST_BBDEV_VF_E;
456 turbo_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0);
457 } else if (!strcmp(key_token, "ea")) {
458 vector->mask |= TEST_BBDEV_VF_EA;
459 turbo_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0);
460 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
461 } else if (!strcmp(key_token, "eb")) {
462 vector->mask |= TEST_BBDEV_VF_EB;
463 turbo_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0);
464 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
465 } else if (!strcmp(key_token, "k")) {
466 vector->mask |= TEST_BBDEV_VF_K;
467 turbo_dec->cb_params.k = (uint16_t) strtoul(token, &err, 0);
468 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
469 } else if (!strcmp(key_token, "k_pos")) {
470 vector->mask |= TEST_BBDEV_VF_K_POS;
471 turbo_dec->tb_params.k_pos = (uint16_t) strtoul(token, &err, 0);
472 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
473 } else if (!strcmp(key_token, "k_neg")) {
474 vector->mask |= TEST_BBDEV_VF_K_NEG;
475 turbo_dec->tb_params.k_neg = (uint16_t) strtoul(token, &err, 0);
476 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
477 } else if (!strcmp(key_token, "c")) {
478 vector->mask |= TEST_BBDEV_VF_C;
479 turbo_dec->tb_params.c = (uint16_t) strtoul(token, &err, 0);
480 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
481 } else if (!strcmp(key_token, "c_neg")) {
482 vector->mask |= TEST_BBDEV_VF_C_NEG;
483 turbo_dec->tb_params.c_neg = (uint16_t) strtoul(token, &err, 0);
484 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
485 } else if (!strcmp(key_token, "cab")) {
486 vector->mask |= TEST_BBDEV_VF_CAB;
487 turbo_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0);
488 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
489 } else if (!strcmp(key_token, "rv_index")) {
490 vector->mask |= TEST_BBDEV_VF_RV_INDEX;
491 turbo_dec->rv_index = (uint8_t) strtoul(token, &err, 0);
492 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
493 } else if (!strcmp(key_token, "iter_max")) {
494 vector->mask |= TEST_BBDEV_VF_ITER_MAX;
495 turbo_dec->iter_max = (uint8_t) strtoul(token, &err, 0);
496 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
497 } else if (!strcmp(key_token, "iter_min")) {
498 vector->mask |= TEST_BBDEV_VF_ITER_MIN;
499 turbo_dec->iter_min = (uint8_t) strtoul(token, &err, 0);
500 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
501 } else if (!strcmp(key_token, "expected_iter_count")) {
502 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT;
503 turbo_dec->iter_count = (uint8_t) strtoul(token, &err, 0);
504 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
505 } else if (!strcmp(key_token, "ext_scale")) {
506 vector->mask |= TEST_BBDEV_VF_EXT_SCALE;
507 turbo_dec->ext_scale = (uint8_t) strtoul(token, &err, 0);
508 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
509 } else if (!strcmp(key_token, "num_maps")) {
510 vector->mask |= TEST_BBDEV_VF_NUM_MAPS;
511 turbo_dec->num_maps = (uint8_t) strtoul(token, &err, 0);
512 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
513 } else if (!strcmp(key_token, "r")) {
514 vector->mask |= TEST_BBDEV_VF_R;
515 turbo_dec->tb_params.r = (uint8_t)strtoul(token, &err, 0);
516 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
517 } else if (!strcmp(key_token, "code_block_mode")) {
518 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
519 turbo_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0);
520 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
521 } else if (!strcmp(key_token, "op_flags")) {
522 vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
523 ret = parse_turbo_flags(token, &op_flags,
526 turbo_dec->op_flags = op_flags;
527 } else if (!strcmp(key_token, "expected_status")) {
528 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
529 ret = parse_expected_status(token, &status, vector->op_type);
531 vector->expected_status = status;
533 printf("Not valid dec key: '%s'\n", key_token);
538 printf("Failed with convert '%s\t%s'\n", key_token, token);
545 /* parses turbo encoder parameters and assigns to global variable */
547 parse_encoder_params(const char *key_token, char *token,
548 struct test_bbdev_vector *vector)
550 int ret = 0, status = 0;
551 uint32_t op_flags = 0;
555 struct rte_bbdev_op_turbo_enc *turbo_enc = &vector->turbo_enc;
557 if (starts_with(key_token, op_data_prefixes[DATA_INPUT]))
558 ret = parse_data_entry(key_token, token, vector,
559 DATA_INPUT, op_data_prefixes[DATA_INPUT]);
560 else if (starts_with(key_token, "output"))
561 ret = parse_data_entry(key_token, token, vector,
562 DATA_HARD_OUTPUT, "output");
563 else if (!strcmp(key_token, "e")) {
564 vector->mask |= TEST_BBDEV_VF_E;
565 turbo_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0);
566 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
567 } else if (!strcmp(key_token, "ea")) {
568 vector->mask |= TEST_BBDEV_VF_EA;
569 turbo_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0);
570 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
571 } else if (!strcmp(key_token, "eb")) {
572 vector->mask |= TEST_BBDEV_VF_EB;
573 turbo_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0);
574 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
575 } else if (!strcmp(key_token, "k")) {
576 vector->mask |= TEST_BBDEV_VF_K;
577 turbo_enc->cb_params.k = (uint16_t) strtoul(token, &err, 0);
578 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
579 } else if (!strcmp(key_token, "k_neg")) {
580 vector->mask |= TEST_BBDEV_VF_K_NEG;
581 turbo_enc->tb_params.k_neg = (uint16_t) strtoul(token, &err, 0);
582 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
583 } else if (!strcmp(key_token, "k_pos")) {
584 vector->mask |= TEST_BBDEV_VF_K_POS;
585 turbo_enc->tb_params.k_pos = (uint16_t) strtoul(token, &err, 0);
586 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
587 } else if (!strcmp(key_token, "c_neg")) {
588 vector->mask |= TEST_BBDEV_VF_C_NEG;
589 turbo_enc->tb_params.c_neg = (uint8_t) strtoul(token, &err, 0);
590 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
591 } else if (!strcmp(key_token, "c")) {
592 vector->mask |= TEST_BBDEV_VF_C;
593 turbo_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0);
594 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
595 } else if (!strcmp(key_token, "cab")) {
596 vector->mask |= TEST_BBDEV_VF_CAB;
597 turbo_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0);
598 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
599 } else if (!strcmp(key_token, "rv_index")) {
600 vector->mask |= TEST_BBDEV_VF_RV_INDEX;
601 turbo_enc->rv_index = (uint8_t) strtoul(token, &err, 0);
602 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
603 } else if (!strcmp(key_token, "ncb")) {
604 vector->mask |= TEST_BBDEV_VF_NCB;
605 turbo_enc->cb_params.ncb = (uint16_t) strtoul(token, &err, 0);
606 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
607 } else if (!strcmp(key_token, "ncb_neg")) {
608 vector->mask |= TEST_BBDEV_VF_NCB_NEG;
609 turbo_enc->tb_params.ncb_neg =
610 (uint16_t) strtoul(token, &err, 0);
611 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
612 } else if (!strcmp(key_token, "ncb_pos")) {
613 vector->mask |= TEST_BBDEV_VF_NCB_POS;
614 turbo_enc->tb_params.ncb_pos =
615 (uint16_t) strtoul(token, &err, 0);
616 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
617 } else if (!strcmp(key_token, "r")) {
618 vector->mask |= TEST_BBDEV_VF_R;
619 turbo_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0);
620 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
621 } else if (!strcmp(key_token, "code_block_mode")) {
622 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
623 turbo_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0);
624 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
625 } else if (!strcmp(key_token, "op_flags")) {
626 vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
627 ret = parse_turbo_flags(token, &op_flags,
630 turbo_enc->op_flags = op_flags;
631 } else if (!strcmp(key_token, "expected_status")) {
632 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
633 ret = parse_expected_status(token, &status, vector->op_type);
635 vector->expected_status = status;
637 printf("Not valid enc key: '%s'\n", key_token);
642 printf("Failed with convert '%s\t%s'\n", key_token, token);
650 /* parses LDPC encoder parameters and assigns to global variable */
652 parse_ldpc_encoder_params(const char *key_token, char *token,
653 struct test_bbdev_vector *vector)
655 int ret = 0, status = 0;
656 uint32_t op_flags = 0;
659 struct rte_bbdev_op_ldpc_enc *ldpc_enc = &vector->ldpc_enc;
661 if (starts_with(key_token, op_data_prefixes[DATA_INPUT]))
662 ret = parse_data_entry(key_token, token, vector,
664 op_data_prefixes[DATA_INPUT]);
665 else if (starts_with(key_token, "output"))
666 ret = parse_data_entry(key_token, token, vector,
669 else if (!strcmp(key_token, "e")) {
670 vector->mask |= TEST_BBDEV_VF_E;
671 ldpc_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0);
672 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
673 } else if (!strcmp(key_token, "ea")) {
674 vector->mask |= TEST_BBDEV_VF_EA;
675 ldpc_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0);
676 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
677 } else if (!strcmp(key_token, "eb")) {
678 vector->mask |= TEST_BBDEV_VF_EB;
679 ldpc_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0);
680 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
681 } else if (!strcmp(key_token, "c")) {
682 vector->mask |= TEST_BBDEV_VF_C;
683 ldpc_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0);
684 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
685 } else if (!strcmp(key_token, "cab")) {
686 vector->mask |= TEST_BBDEV_VF_CAB;
687 ldpc_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0);
688 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
689 } else if (!strcmp(key_token, "rv_index")) {
690 vector->mask |= TEST_BBDEV_VF_RV_INDEX;
691 ldpc_enc->rv_index = (uint8_t) strtoul(token, &err, 0);
692 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
693 } else if (!strcmp(key_token, "n_cb")) {
694 vector->mask |= TEST_BBDEV_VF_NCB;
695 ldpc_enc->n_cb = (uint16_t) strtoul(token, &err, 0);
696 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
697 } else if (!strcmp(key_token, "r")) {
698 vector->mask |= TEST_BBDEV_VF_R;
699 ldpc_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0);
700 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
701 } else if (!strcmp(key_token, "q_m")) {
702 vector->mask |= TEST_BBDEV_VF_QM;
703 ldpc_enc->q_m = (uint8_t) strtoul(token, &err, 0);
704 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
705 } else if (!strcmp(key_token, "basegraph")) {
706 vector->mask |= TEST_BBDEV_VF_BG;
707 ldpc_enc->basegraph = (uint8_t) strtoul(token, &err, 0);
708 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
709 } else if (!strcmp(key_token, "z_c")) {
710 vector->mask |= TEST_BBDEV_VF_ZC;
711 ldpc_enc->z_c = (uint16_t) strtoul(token, &err, 0);
712 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
713 } else if (!strcmp(key_token, "n_filler")) {
714 vector->mask |= TEST_BBDEV_VF_F;
715 ldpc_enc->n_filler = (uint16_t) strtoul(token, &err, 0);
716 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
717 } else if (!strcmp(key_token, "code_block_mode")) {
718 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
719 ldpc_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0);
720 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
721 } else if (!strcmp(key_token, "op_flags")) {
722 vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
723 ret = parse_turbo_flags(token, &op_flags, vector->op_type);
725 ldpc_enc->op_flags = op_flags;
726 } else if (!strcmp(key_token, "expected_status")) {
727 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
728 ret = parse_expected_status(token, &status, vector->op_type);
730 vector->expected_status = status;
732 printf("Not valid ldpc enc key: '%s'\n", key_token);
737 printf("Failed with convert '%s\t%s'\n", key_token, token);
744 /* parses LDPC decoder parameters and assigns to global variable */
746 parse_ldpc_decoder_params(const char *key_token, char *token,
747 struct test_bbdev_vector *vector)
749 int ret = 0, status = 0;
750 uint32_t op_flags = 0;
753 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec;
755 if (starts_with(key_token, op_data_prefixes[DATA_INPUT]))
756 ret = parse_data_entry(key_token, token, vector,
758 op_data_prefixes[DATA_INPUT]);
759 else if (starts_with(key_token, "output"))
760 ret = parse_data_entry(key_token, token, vector,
763 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_INPUT]))
764 ret = parse_data_entry(key_token, token, vector,
766 op_data_prefixes[DATA_HARQ_INPUT]);
767 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_OUTPUT]))
768 ret = parse_data_entry(key_token, token, vector,
770 op_data_prefixes[DATA_HARQ_OUTPUT]);
771 else if (!strcmp(key_token, "e")) {
772 vector->mask |= TEST_BBDEV_VF_E;
773 ldpc_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0);
774 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
775 } else if (!strcmp(key_token, "ea")) {
776 vector->mask |= TEST_BBDEV_VF_EA;
777 ldpc_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0);
778 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
779 } else if (!strcmp(key_token, "eb")) {
780 vector->mask |= TEST_BBDEV_VF_EB;
781 ldpc_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0);
782 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
783 } else if (!strcmp(key_token, "c")) {
784 vector->mask |= TEST_BBDEV_VF_C;
785 ldpc_dec->tb_params.c = (uint8_t) strtoul(token, &err, 0);
786 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
787 } else if (!strcmp(key_token, "cab")) {
788 vector->mask |= TEST_BBDEV_VF_CAB;
789 ldpc_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0);
790 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
791 } else if (!strcmp(key_token, "rv_index")) {
792 vector->mask |= TEST_BBDEV_VF_RV_INDEX;
793 ldpc_dec->rv_index = (uint8_t) strtoul(token, &err, 0);
794 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
795 } else if (!strcmp(key_token, "n_cb")) {
796 vector->mask |= TEST_BBDEV_VF_NCB;
797 ldpc_dec->n_cb = (uint16_t) strtoul(token, &err, 0);
798 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
799 } else if (!strcmp(key_token, "r")) {
800 vector->mask |= TEST_BBDEV_VF_R;
801 ldpc_dec->tb_params.r = (uint8_t) strtoul(token, &err, 0);
802 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
803 } else if (!strcmp(key_token, "q_m")) {
804 vector->mask |= TEST_BBDEV_VF_QM;
805 ldpc_dec->q_m = (uint8_t) strtoul(token, &err, 0);
806 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
807 } else if (!strcmp(key_token, "basegraph")) {
808 vector->mask |= TEST_BBDEV_VF_BG;
809 ldpc_dec->basegraph = (uint8_t) strtoul(token, &err, 0);
810 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
811 } else if (!strcmp(key_token, "z_c")) {
812 vector->mask |= TEST_BBDEV_VF_ZC;
813 ldpc_dec->z_c = (uint16_t) strtoul(token, &err, 0);
814 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
815 } else if (!strcmp(key_token, "n_filler")) {
816 vector->mask |= TEST_BBDEV_VF_F;
817 ldpc_dec->n_filler = (uint16_t) strtoul(token, &err, 0);
818 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
819 } else if (!strcmp(key_token, "expected_iter_count")) {
820 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT;
821 ldpc_dec->iter_count = (uint8_t) strtoul(token, &err, 0);
822 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
823 } else if (!strcmp(key_token, "iter_max")) {
824 vector->mask |= TEST_BBDEV_VF_ITER_MAX;
825 ldpc_dec->iter_max = (uint8_t) strtoul(token, &err, 0);
826 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
827 } else if (!strcmp(key_token, "code_block_mode")) {
828 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
829 ldpc_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0);
830 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
831 } else if (!strcmp(key_token, "op_flags")) {
832 vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
833 ret = parse_turbo_flags(token, &op_flags, vector->op_type);
835 ldpc_dec->op_flags = op_flags;
836 } else if (!strcmp(key_token, "expected_status")) {
837 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
838 ret = parse_expected_status(token, &status, vector->op_type);
840 vector->expected_status = status;
842 printf("Not valid ldpc dec key: '%s'\n", key_token);
847 printf("Failed with convert '%s\t%s'\n", key_token, token);
854 /* checks the type of key and assigns data */
856 parse_entry(char *entry, struct test_bbdev_vector *vector)
859 char *token, *key_token;
860 enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_NONE;
863 printf("Expected entry value\n");
868 token = strtok(entry, ENTRY_DELIMITER);
870 /* get values for key */
871 token = strtok(NULL, ENTRY_DELIMITER);
873 if (key_token == NULL || token == NULL) {
874 printf("Expected 'key = values' but was '%.40s'..\n", entry);
877 trim_space(key_token);
879 /* first key_token has to specify type of operation */
880 if (vector->op_type == RTE_BBDEV_OP_NONE) {
881 if (!strcmp(key_token, "op_type")) {
882 ret = op_turbo_type_strtol(token, &op_type);
884 vector->op_type = op_type;
885 return (!ret) ? 0 : -1;
887 printf("First key_token (%s) does not specify op_type\n",
893 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) {
894 if (parse_decoder_params(key_token, token, vector) == -1)
896 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) {
897 if (parse_encoder_params(key_token, token, vector) == -1)
899 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) {
900 if (parse_ldpc_encoder_params(key_token, token, vector) == -1)
902 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) {
903 if (parse_ldpc_decoder_params(key_token, token, vector) == -1)
911 check_decoder_segments(struct test_bbdev_vector *vector)
914 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
916 if (vector->entries[DATA_INPUT].nb_segments == 0)
919 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
920 if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
923 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
926 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments;
928 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
931 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT) &&
932 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0))
935 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments;
937 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL)
944 check_ldpc_decoder_segments(struct test_bbdev_vector *vector)
947 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec;
949 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
950 if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
953 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
954 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
957 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_SOFT_OUT_ENABLE) &&
958 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0))
961 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; i++)
962 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL)
965 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE) &&
966 (vector->entries[DATA_HARQ_OUTPUT].nb_segments == 0))
969 for (i = 0; i < vector->entries[DATA_HARQ_OUTPUT].nb_segments; i++)
970 if (vector->entries[DATA_HARQ_OUTPUT].segments[i].addr == NULL)
977 check_decoder_llr_spec(struct test_bbdev_vector *vector)
979 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
981 /* Check input LLR sign formalism specification */
982 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) &&
983 (turbo_dec->op_flags &
984 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) {
986 "Both positive and negative LLR input flags were set!\n");
989 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) &&
990 !(turbo_dec->op_flags &
991 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) {
993 "INFO: input LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n");
994 turbo_dec->op_flags |= RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN;
997 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT))
1000 /* Check output LLR sign formalism specification */
1001 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) &&
1002 (turbo_dec->op_flags &
1003 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) {
1005 "Both positive and negative LLR output flags were set!\n");
1008 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) &&
1009 !(turbo_dec->op_flags &
1010 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) {
1012 "INFO: soft output LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n");
1013 turbo_dec->op_flags |=
1014 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT;
1021 check_decoder_op_flags(struct test_bbdev_vector *vector)
1023 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
1025 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP) &&
1026 !(turbo_dec->op_flags & RTE_BBDEV_TURBO_CRC_TYPE_24B)) {
1028 "WARNING: RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP flag is missing RTE_BBDEV_TURBO_CRC_TYPE_24B\n");
1035 /* checks decoder parameters */
1037 check_decoder(struct test_bbdev_vector *vector)
1039 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
1040 const int mask = vector->mask;
1042 if (check_decoder_segments(vector) < 0)
1045 if (check_decoder_llr_spec(vector) < 0)
1048 if (check_decoder_op_flags(vector) < 0)
1051 /* Check which params were set */
1052 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1054 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n");
1055 turbo_dec->code_block_mode = 1;
1057 if (turbo_dec->code_block_mode == 0) {
1058 if (!(mask & TEST_BBDEV_VF_EA))
1060 "WARNING: ea was not specified in vector file and will be set to 0\n");
1061 if (!(mask & TEST_BBDEV_VF_EB))
1063 "WARNING: eb was not specified in vector file and will be set to 0\n");
1064 if (!(mask & TEST_BBDEV_VF_K_NEG))
1066 "WARNING: k_neg was not specified in vector file and will be set to 0\n");
1067 if (!(mask & TEST_BBDEV_VF_K_POS))
1069 "WARNING: k_pos was not specified in vector file and will be set to 0\n");
1070 if (!(mask & TEST_BBDEV_VF_C_NEG))
1072 "WARNING: c_neg was not specified in vector file and will be set to 0\n");
1073 if (!(mask & TEST_BBDEV_VF_C)) {
1075 "WARNING: c was not specified in vector file and will be set to 1\n");
1076 turbo_dec->tb_params.c = 1;
1078 if (!(mask & TEST_BBDEV_VF_CAB))
1080 "WARNING: cab was not specified in vector file and will be set to 0\n");
1081 if (!(mask & TEST_BBDEV_VF_R))
1083 "WARNING: r was not specified in vector file and will be set to 0\n");
1085 if (!(mask & TEST_BBDEV_VF_E))
1087 "WARNING: e was not specified in vector file and will be set to 0\n");
1088 if (!(mask & TEST_BBDEV_VF_K))
1090 "WARNING: k was not specified in vector file and will be set to 0\n");
1092 if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1094 "INFO: rv_index was not specified in vector file and will be set to 0\n");
1095 if (!(mask & TEST_BBDEV_VF_ITER_MIN))
1097 "WARNING: iter_min was not specified in vector file and will be set to 0\n");
1098 if (!(mask & TEST_BBDEV_VF_ITER_MAX))
1100 "WARNING: iter_max was not specified in vector file and will be set to 0\n");
1101 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT))
1103 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n");
1104 if (!(mask & TEST_BBDEV_VF_EXT_SCALE))
1106 "WARNING: ext_scale was not specified in vector file and will be set to 0\n");
1107 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) {
1109 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n");
1110 turbo_dec->num_maps = 0;
1111 } else if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_MAP_DEC) &&
1112 mask & TEST_BBDEV_VF_NUM_MAPS) {
1114 "INFO: RTE_BBDEV_TURBO_MAP_DEC was not set in vector file and num_maps will be set to 0\n");
1115 turbo_dec->num_maps = 0;
1117 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1119 "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1123 /* checks LDPC decoder parameters */
1125 check_ldpc_decoder(struct test_bbdev_vector *vector)
1127 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec;
1128 const int mask = vector->mask;
1130 if (check_ldpc_decoder_segments(vector) < 0)
1134 * if (check_ldpc_decoder_llr_spec(vector) < 0)
1137 * if (check_ldpc_decoder_op_flags(vector) < 0)
1141 /* Check which params were set */
1142 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1144 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n");
1145 ldpc_dec->code_block_mode = 1;
1147 if (ldpc_dec->code_block_mode == 0) {
1148 if (!(mask & TEST_BBDEV_VF_EA))
1150 "WARNING: ea was not specified in vector file and will be set to 0\n");
1151 if (!(mask & TEST_BBDEV_VF_EB))
1153 "WARNING: eb was not specified in vector file and will be set to 0\n");
1154 if (!(mask & TEST_BBDEV_VF_C)) {
1156 "WARNING: c was not specified in vector file and will be set to 1\n");
1157 ldpc_dec->tb_params.c = 1;
1159 if (!(mask & TEST_BBDEV_VF_CAB))
1161 "WARNING: cab was not specified in vector file and will be set to 0\n");
1162 if (!(mask & TEST_BBDEV_VF_R))
1164 "WARNING: r was not specified in vector file and will be set to 0\n");
1166 if (!(mask & TEST_BBDEV_VF_E))
1168 "WARNING: e was not specified in vector file and will be set to 0\n");
1170 if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1172 "INFO: rv_index was not specified in vector file and will be set to 0\n");
1173 if (!(mask & TEST_BBDEV_VF_ITER_MAX))
1175 "WARNING: iter_max was not specified in vector file and will be set to 0\n");
1176 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT))
1178 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n");
1179 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) {
1181 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n");
1183 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1185 "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1189 /* checks encoder parameters */
1191 check_encoder(struct test_bbdev_vector *vector)
1194 const int mask = vector->mask;
1196 if (vector->entries[DATA_INPUT].nb_segments == 0)
1199 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1200 if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1203 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
1206 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
1207 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1210 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1212 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n");
1213 vector->turbo_enc.code_block_mode = 1;
1215 if (vector->turbo_enc.code_block_mode == 0) {
1216 if (!(mask & TEST_BBDEV_VF_EA) && (vector->turbo_enc.op_flags &
1217 RTE_BBDEV_TURBO_RATE_MATCH))
1219 "WARNING: ea was not specified in vector file and will be set to 0\n");
1220 if (!(mask & TEST_BBDEV_VF_EB) && (vector->turbo_enc.op_flags &
1221 RTE_BBDEV_TURBO_RATE_MATCH))
1223 "WARNING: eb was not specified in vector file and will be set to 0\n");
1224 if (!(mask & TEST_BBDEV_VF_K_NEG))
1226 "WARNING: k_neg was not specified in vector file and will be set to 0\n");
1227 if (!(mask & TEST_BBDEV_VF_K_POS))
1229 "WARNING: k_pos was not specified in vector file and will be set to 0\n");
1230 if (!(mask & TEST_BBDEV_VF_C_NEG))
1232 "WARNING: c_neg was not specified in vector file and will be set to 0\n");
1233 if (!(mask & TEST_BBDEV_VF_C)) {
1235 "WARNING: c was not specified in vector file and will be set to 1\n");
1236 vector->turbo_enc.tb_params.c = 1;
1238 if (!(mask & TEST_BBDEV_VF_CAB) && (vector->turbo_enc.op_flags &
1239 RTE_BBDEV_TURBO_RATE_MATCH))
1241 "WARNING: cab was not specified in vector file and will be set to 0\n");
1242 if (!(mask & TEST_BBDEV_VF_NCB_NEG))
1244 "WARNING: ncb_neg was not specified in vector file and will be set to 0\n");
1245 if (!(mask & TEST_BBDEV_VF_NCB_POS))
1247 "WARNING: ncb_pos was not specified in vector file and will be set to 0\n");
1248 if (!(mask & TEST_BBDEV_VF_R))
1250 "WARNING: r was not specified in vector file and will be set to 0\n");
1252 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags &
1253 RTE_BBDEV_TURBO_RATE_MATCH))
1255 "WARNING: e was not specified in vector file and will be set to 0\n");
1256 if (!(mask & TEST_BBDEV_VF_K))
1258 "WARNING: k was not specified in vector file and will be set to 0\n");
1259 if (!(mask & TEST_BBDEV_VF_NCB))
1261 "WARNING: ncb was not specified in vector file and will be set to 0\n");
1263 if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1265 "INFO: rv_index was not specified in vector file and will be set to 0\n");
1266 if (!(mask & TEST_BBDEV_VF_OP_FLAGS))
1268 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n");
1269 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1271 "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1277 /* checks encoder parameters */
1279 check_ldpc_encoder(struct test_bbdev_vector *vector)
1282 const int mask = vector->mask;
1284 if (vector->entries[DATA_INPUT].nb_segments == 0)
1287 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1288 if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1291 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
1294 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
1295 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1298 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1300 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n");
1301 vector->turbo_enc.code_block_mode = 1;
1303 if (vector->turbo_enc.code_block_mode == 0) {
1305 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags &
1306 RTE_BBDEV_TURBO_RATE_MATCH))
1308 "WARNING: e was not specified in vector file and will be set to 0\n");
1309 if (!(mask & TEST_BBDEV_VF_NCB))
1311 "WARNING: ncb was not specified in vector file and will be set to 0\n");
1313 if (!(mask & TEST_BBDEV_VF_BG))
1315 "WARNING: BG was not specified in vector file and will be set to 0\n");
1316 if (!(mask & TEST_BBDEV_VF_ZC))
1318 "WARNING: Zc was not specified in vector file and will be set to 0\n");
1319 if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1321 "INFO: rv_index was not specified in vector file and will be set to 0\n");
1322 if (!(mask & TEST_BBDEV_VF_OP_FLAGS))
1324 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n");
1325 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1327 "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1333 bbdev_check_vector(struct test_bbdev_vector *vector)
1335 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) {
1336 if (check_decoder(vector) == -1)
1338 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) {
1339 if (check_encoder(vector) == -1)
1341 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) {
1342 if (check_ldpc_encoder(vector) == -1)
1344 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) {
1345 if (check_ldpc_decoder(vector) == -1)
1347 } else if (vector->op_type != RTE_BBDEV_OP_NONE) {
1348 printf("Vector was not filled\n");
1356 test_bbdev_vector_read(const char *filename,
1357 struct test_bbdev_vector *vector)
1366 fp = fopen(filename, "r");
1368 printf("File %s does not exist\n", filename);
1372 while (getline(&line, &len, fp) != -1) {
1374 /* ignore comments and new lines */
1375 if (line[0] == '#' || line[0] == '/' || line[0] == '\n'
1381 /* buffer for multiline */
1382 entry = realloc(entry, strlen(line) + 1);
1383 if (entry == NULL) {
1384 printf("Fail to realloc %zu bytes\n", strlen(line) + 1);
1389 strcpy(entry, line);
1391 /* check if entry ends with , or = */
1392 if (entry[strlen(entry) - 1] == ','
1393 || entry[strlen(entry) - 1] == '=') {
1394 while (getline(&line, &len, fp) != -1) {
1397 /* extend entry about length of new line */
1398 char *entry_extended = realloc(entry,
1402 if (entry_extended == NULL) {
1403 printf("Fail to allocate %zu bytes\n",
1410 entry = entry_extended;
1411 /* entry has been allocated accordingly */
1412 strcpy(&entry[strlen(entry)], line);
1414 if (entry[strlen(entry) - 1] != ',')
1418 ret = parse_entry(entry, vector);
1420 printf("An error occurred while parsing!\n");
1424 ret = bbdev_check_vector(vector);
1426 printf("An error occurred while checking!\n");