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;
201 printf("The given value is not a LDPC decoder flag\n");
208 /* convert turbo encoder flag from string to unsigned long int*/
210 op_encoder_flag_strtoul(char *token, uint32_t *op_flag_value)
212 if (!strcmp(token, "RTE_BBDEV_TURBO_RV_INDEX_BYPASS"))
213 *op_flag_value = RTE_BBDEV_TURBO_RV_INDEX_BYPASS;
214 else if (!strcmp(token, "RTE_BBDEV_TURBO_RATE_MATCH"))
215 *op_flag_value = RTE_BBDEV_TURBO_RATE_MATCH;
216 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_24B_ATTACH"))
217 *op_flag_value = RTE_BBDEV_TURBO_CRC_24B_ATTACH;
218 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_24A_ATTACH"))
219 *op_flag_value = RTE_BBDEV_TURBO_CRC_24A_ATTACH;
220 else if (!strcmp(token, "RTE_BBDEV_TURBO_ENC_SCATTER_GATHER"))
221 *op_flag_value = RTE_BBDEV_TURBO_ENC_SCATTER_GATHER;
223 printf("The given value is not a turbo encoder flag\n");
230 /* convert LDPC encoder flag from string to unsigned long int*/
232 op_ldpc_encoder_flag_strtoul(char *token, uint32_t *op_flag_value)
234 if (!strcmp(token, "RTE_BBDEV_LDPC_INTERLEAVER_BYPASS"))
235 *op_flag_value = RTE_BBDEV_LDPC_INTERLEAVER_BYPASS;
236 else if (!strcmp(token, "RTE_BBDEV_LDPC_RATE_MATCH"))
237 *op_flag_value = RTE_BBDEV_LDPC_RATE_MATCH;
238 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_24A_ATTACH"))
239 *op_flag_value = RTE_BBDEV_LDPC_CRC_24A_ATTACH;
240 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_24B_ATTACH"))
241 *op_flag_value = RTE_BBDEV_LDPC_CRC_24B_ATTACH;
242 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_16_ATTACH"))
243 *op_flag_value = RTE_BBDEV_LDPC_CRC_16_ATTACH;
244 else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_INTERRUPTS"))
245 *op_flag_value = RTE_BBDEV_LDPC_ENC_INTERRUPTS;
246 else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_SCATTER_GATHER"))
247 *op_flag_value = RTE_BBDEV_LDPC_ENC_SCATTER_GATHER;
249 printf("The given value is not a turbo encoder flag\n");
256 /* tokenization turbo decoder/encoder flags values separated by a comma */
258 parse_turbo_flags(char *tokens, uint32_t *op_flags,
259 enum rte_bbdev_op_type op_type)
262 uint32_t op_flag_value = 0;
264 tok = strtok(tokens, VALUE_DELIMITER);
268 while (tok != NULL) {
270 if (op_type == RTE_BBDEV_OP_TURBO_DEC) {
271 if (op_decoder_flag_strtoul(tok, &op_flag_value) == -1)
273 } else if (op_type == RTE_BBDEV_OP_TURBO_ENC) {
274 if (op_encoder_flag_strtoul(tok, &op_flag_value) == -1)
276 } else if (op_type == RTE_BBDEV_OP_LDPC_ENC) {
277 if (op_ldpc_encoder_flag_strtoul(tok, &op_flag_value)
280 } else if (op_type == RTE_BBDEV_OP_LDPC_DEC) {
281 if (op_ldpc_decoder_flag_strtoul(tok, &op_flag_value)
288 *op_flags = *op_flags | op_flag_value;
290 tok = strtok(NULL, VALUE_DELIMITER);
298 /* convert turbo encoder/decoder op_type from string to enum*/
300 op_turbo_type_strtol(char *token, enum rte_bbdev_op_type *op_type)
303 if (!strcmp(token, "RTE_BBDEV_OP_TURBO_DEC"))
304 *op_type = RTE_BBDEV_OP_TURBO_DEC;
305 else if (!strcmp(token, "RTE_BBDEV_OP_TURBO_ENC"))
306 *op_type = RTE_BBDEV_OP_TURBO_ENC;
307 else if (!strcmp(token, "RTE_BBDEV_OP_LDPC_ENC"))
308 *op_type = RTE_BBDEV_OP_LDPC_ENC;
309 else if (!strcmp(token, "RTE_BBDEV_OP_LDPC_DEC"))
310 *op_type = RTE_BBDEV_OP_LDPC_DEC;
311 else if (!strcmp(token, "RTE_BBDEV_OP_NONE"))
312 *op_type = RTE_BBDEV_OP_NONE;
314 printf("Not valid turbo op_type: '%s'\n", token);
321 /* tokenization expected status values separated by a comma */
323 parse_expected_status(char *tokens, int *status, enum rte_bbdev_op_type op_type)
326 bool status_ok = false;
328 tok = strtok(tokens, VALUE_DELIMITER);
332 while (tok != NULL) {
334 if (!strcmp(tok, "OK"))
336 else if (!strcmp(tok, "DMA"))
337 *status = *status | (1 << RTE_BBDEV_DRV_ERROR);
338 else if (!strcmp(tok, "FCW"))
339 *status = *status | (1 << RTE_BBDEV_DATA_ERROR);
340 else if (!strcmp(tok, "SYNCRC")) {
341 *status = *status | (1 << RTE_BBDEV_SYNDROME_ERROR);
342 *status = *status | (1 << RTE_BBDEV_CRC_ERROR);
343 } else if (!strcmp(tok, "SYN"))
344 *status = *status | (1 << RTE_BBDEV_SYNDROME_ERROR);
345 else if (!strcmp(tok, "CRC")) {
346 if ((op_type == RTE_BBDEV_OP_TURBO_DEC) ||
347 (op_type == RTE_BBDEV_OP_LDPC_DEC))
348 *status = *status | (1 << RTE_BBDEV_CRC_ERROR);
351 "CRC is only a valid value for decoder\n");
355 printf("Not valid status: '%s'\n", tok);
359 tok = strtok(NULL, VALUE_DELIMITER);
364 if (status_ok && *status != 0) {
366 "Not valid status values. Cannot be OK and ERROR at the same time.\n");
373 /* parse ops data entry (there can be more than 1 input entry, each will be
374 * contained in a separate op_data_buf struct)
377 parse_data_entry(const char *key_token, char *token,
378 struct test_bbdev_vector *vector, enum op_data_type type,
382 uint32_t data_length = 0;
383 uint32_t *data = NULL;
385 struct op_data_buf *op_data;
386 unsigned int *nb_ops;
388 if (type >= DATA_NUM_TYPES) {
389 printf("Unknown op type: %d!\n", type);
393 op_data = vector->entries[type].segments;
394 nb_ops = &vector->entries[type].nb_segments;
396 if (*nb_ops >= RTE_BBDEV_TURBO_MAX_CODE_BLOCKS) {
397 printf("Too many segments (code blocks defined): %u, max %d!\n",
398 *nb_ops, RTE_BBDEV_TURBO_MAX_CODE_BLOCKS);
402 if (sscanf(key_token + strlen(prefix), "%u", &id) != 1) {
403 printf("Missing ID of %s\n", prefix);
408 "Please order data entries sequentially, i.e. %s0, %s1, ...\n",
413 /* Clear new op data struct */
414 memset(op_data + *nb_ops, 0, sizeof(struct op_data_buf));
416 ret = parse_values(token, &data, &data_length);
418 op_data[*nb_ops].addr = data;
419 op_data[*nb_ops].length = data_length;
426 /* parses turbo decoder parameters and assigns to global variable */
428 parse_decoder_params(const char *key_token, char *token,
429 struct test_bbdev_vector *vector)
431 int ret = 0, status = 0;
432 uint32_t op_flags = 0;
435 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
438 if (starts_with(key_token, op_data_prefixes[DATA_INPUT]))
439 ret = parse_data_entry(key_token, token, vector,
440 DATA_INPUT, op_data_prefixes[DATA_INPUT]);
442 else if (starts_with(key_token, op_data_prefixes[DATA_SOFT_OUTPUT]))
443 ret = parse_data_entry(key_token, token, vector,
445 op_data_prefixes[DATA_SOFT_OUTPUT]);
447 else if (starts_with(key_token, op_data_prefixes[DATA_HARD_OUTPUT]))
448 ret = parse_data_entry(key_token, token, vector,
450 op_data_prefixes[DATA_HARD_OUTPUT]);
451 else if (!strcmp(key_token, "e")) {
452 vector->mask |= TEST_BBDEV_VF_E;
453 turbo_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0);
454 } else if (!strcmp(key_token, "ea")) {
455 vector->mask |= TEST_BBDEV_VF_EA;
456 turbo_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0);
457 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
458 } else if (!strcmp(key_token, "eb")) {
459 vector->mask |= TEST_BBDEV_VF_EB;
460 turbo_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0);
461 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
462 } else if (!strcmp(key_token, "k")) {
463 vector->mask |= TEST_BBDEV_VF_K;
464 turbo_dec->cb_params.k = (uint16_t) strtoul(token, &err, 0);
465 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
466 } else if (!strcmp(key_token, "k_pos")) {
467 vector->mask |= TEST_BBDEV_VF_K_POS;
468 turbo_dec->tb_params.k_pos = (uint16_t) strtoul(token, &err, 0);
469 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
470 } else if (!strcmp(key_token, "k_neg")) {
471 vector->mask |= TEST_BBDEV_VF_K_NEG;
472 turbo_dec->tb_params.k_neg = (uint16_t) strtoul(token, &err, 0);
473 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
474 } else if (!strcmp(key_token, "c")) {
475 vector->mask |= TEST_BBDEV_VF_C;
476 turbo_dec->tb_params.c = (uint16_t) strtoul(token, &err, 0);
477 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
478 } else if (!strcmp(key_token, "c_neg")) {
479 vector->mask |= TEST_BBDEV_VF_C_NEG;
480 turbo_dec->tb_params.c_neg = (uint16_t) strtoul(token, &err, 0);
481 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
482 } else if (!strcmp(key_token, "cab")) {
483 vector->mask |= TEST_BBDEV_VF_CAB;
484 turbo_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0);
485 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
486 } else if (!strcmp(key_token, "rv_index")) {
487 vector->mask |= TEST_BBDEV_VF_RV_INDEX;
488 turbo_dec->rv_index = (uint8_t) strtoul(token, &err, 0);
489 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
490 } else if (!strcmp(key_token, "iter_max")) {
491 vector->mask |= TEST_BBDEV_VF_ITER_MAX;
492 turbo_dec->iter_max = (uint8_t) strtoul(token, &err, 0);
493 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
494 } else if (!strcmp(key_token, "iter_min")) {
495 vector->mask |= TEST_BBDEV_VF_ITER_MIN;
496 turbo_dec->iter_min = (uint8_t) strtoul(token, &err, 0);
497 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
498 } else if (!strcmp(key_token, "expected_iter_count")) {
499 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT;
500 turbo_dec->iter_count = (uint8_t) strtoul(token, &err, 0);
501 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
502 } else if (!strcmp(key_token, "ext_scale")) {
503 vector->mask |= TEST_BBDEV_VF_EXT_SCALE;
504 turbo_dec->ext_scale = (uint8_t) strtoul(token, &err, 0);
505 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
506 } else if (!strcmp(key_token, "num_maps")) {
507 vector->mask |= TEST_BBDEV_VF_NUM_MAPS;
508 turbo_dec->num_maps = (uint8_t) strtoul(token, &err, 0);
509 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
510 } else if (!strcmp(key_token, "r")) {
511 vector->mask |= TEST_BBDEV_VF_R;
512 turbo_dec->tb_params.r = (uint8_t)strtoul(token, &err, 0);
513 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
514 } else if (!strcmp(key_token, "code_block_mode")) {
515 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
516 turbo_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0);
517 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
518 } else if (!strcmp(key_token, "op_flags")) {
519 vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
520 ret = parse_turbo_flags(token, &op_flags,
523 turbo_dec->op_flags = op_flags;
524 } else if (!strcmp(key_token, "expected_status")) {
525 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
526 ret = parse_expected_status(token, &status, vector->op_type);
528 vector->expected_status = status;
530 printf("Not valid dec key: '%s'\n", key_token);
535 printf("Failed with convert '%s\t%s'\n", key_token, token);
542 /* parses turbo encoder parameters and assigns to global variable */
544 parse_encoder_params(const char *key_token, char *token,
545 struct test_bbdev_vector *vector)
547 int ret = 0, status = 0;
548 uint32_t op_flags = 0;
552 struct rte_bbdev_op_turbo_enc *turbo_enc = &vector->turbo_enc;
554 if (starts_with(key_token, op_data_prefixes[DATA_INPUT]))
555 ret = parse_data_entry(key_token, token, vector,
556 DATA_INPUT, op_data_prefixes[DATA_INPUT]);
557 else if (starts_with(key_token, "output"))
558 ret = parse_data_entry(key_token, token, vector,
559 DATA_HARD_OUTPUT, "output");
560 else if (!strcmp(key_token, "e")) {
561 vector->mask |= TEST_BBDEV_VF_E;
562 turbo_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0);
563 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
564 } else if (!strcmp(key_token, "ea")) {
565 vector->mask |= TEST_BBDEV_VF_EA;
566 turbo_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0);
567 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
568 } else if (!strcmp(key_token, "eb")) {
569 vector->mask |= TEST_BBDEV_VF_EB;
570 turbo_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0);
571 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
572 } else if (!strcmp(key_token, "k")) {
573 vector->mask |= TEST_BBDEV_VF_K;
574 turbo_enc->cb_params.k = (uint16_t) strtoul(token, &err, 0);
575 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
576 } else if (!strcmp(key_token, "k_neg")) {
577 vector->mask |= TEST_BBDEV_VF_K_NEG;
578 turbo_enc->tb_params.k_neg = (uint16_t) strtoul(token, &err, 0);
579 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
580 } else if (!strcmp(key_token, "k_pos")) {
581 vector->mask |= TEST_BBDEV_VF_K_POS;
582 turbo_enc->tb_params.k_pos = (uint16_t) strtoul(token, &err, 0);
583 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
584 } else if (!strcmp(key_token, "c_neg")) {
585 vector->mask |= TEST_BBDEV_VF_C_NEG;
586 turbo_enc->tb_params.c_neg = (uint8_t) strtoul(token, &err, 0);
587 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
588 } else if (!strcmp(key_token, "c")) {
589 vector->mask |= TEST_BBDEV_VF_C;
590 turbo_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0);
591 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
592 } else if (!strcmp(key_token, "cab")) {
593 vector->mask |= TEST_BBDEV_VF_CAB;
594 turbo_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0);
595 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
596 } else if (!strcmp(key_token, "rv_index")) {
597 vector->mask |= TEST_BBDEV_VF_RV_INDEX;
598 turbo_enc->rv_index = (uint8_t) strtoul(token, &err, 0);
599 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
600 } else if (!strcmp(key_token, "ncb")) {
601 vector->mask |= TEST_BBDEV_VF_NCB;
602 turbo_enc->cb_params.ncb = (uint16_t) strtoul(token, &err, 0);
603 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
604 } else if (!strcmp(key_token, "ncb_neg")) {
605 vector->mask |= TEST_BBDEV_VF_NCB_NEG;
606 turbo_enc->tb_params.ncb_neg =
607 (uint16_t) strtoul(token, &err, 0);
608 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
609 } else if (!strcmp(key_token, "ncb_pos")) {
610 vector->mask |= TEST_BBDEV_VF_NCB_POS;
611 turbo_enc->tb_params.ncb_pos =
612 (uint16_t) strtoul(token, &err, 0);
613 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
614 } else if (!strcmp(key_token, "r")) {
615 vector->mask |= TEST_BBDEV_VF_R;
616 turbo_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0);
617 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
618 } else if (!strcmp(key_token, "code_block_mode")) {
619 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
620 turbo_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0);
621 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
622 } else if (!strcmp(key_token, "op_flags")) {
623 vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
624 ret = parse_turbo_flags(token, &op_flags,
627 turbo_enc->op_flags = op_flags;
628 } else if (!strcmp(key_token, "expected_status")) {
629 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
630 ret = parse_expected_status(token, &status, vector->op_type);
632 vector->expected_status = status;
634 printf("Not valid enc key: '%s'\n", key_token);
639 printf("Failed with convert '%s\t%s'\n", key_token, token);
647 /* parses LDPC encoder parameters and assigns to global variable */
649 parse_ldpc_encoder_params(const char *key_token, char *token,
650 struct test_bbdev_vector *vector)
652 int ret = 0, status = 0;
653 uint32_t op_flags = 0;
656 struct rte_bbdev_op_ldpc_enc *ldpc_enc = &vector->ldpc_enc;
658 if (starts_with(key_token, op_data_prefixes[DATA_INPUT]))
659 ret = parse_data_entry(key_token, token, vector,
661 op_data_prefixes[DATA_INPUT]);
662 else if (starts_with(key_token, "output"))
663 ret = parse_data_entry(key_token, token, vector,
666 else if (!strcmp(key_token, "e")) {
667 vector->mask |= TEST_BBDEV_VF_E;
668 ldpc_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0);
669 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
670 } else if (!strcmp(key_token, "ea")) {
671 vector->mask |= TEST_BBDEV_VF_EA;
672 ldpc_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0);
673 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
674 } else if (!strcmp(key_token, "eb")) {
675 vector->mask |= TEST_BBDEV_VF_EB;
676 ldpc_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0);
677 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
678 } else if (!strcmp(key_token, "c")) {
679 vector->mask |= TEST_BBDEV_VF_C;
680 ldpc_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0);
681 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
682 } else if (!strcmp(key_token, "cab")) {
683 vector->mask |= TEST_BBDEV_VF_CAB;
684 ldpc_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0);
685 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
686 } else if (!strcmp(key_token, "rv_index")) {
687 vector->mask |= TEST_BBDEV_VF_RV_INDEX;
688 ldpc_enc->rv_index = (uint8_t) strtoul(token, &err, 0);
689 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
690 } else if (!strcmp(key_token, "n_cb")) {
691 vector->mask |= TEST_BBDEV_VF_NCB;
692 ldpc_enc->n_cb = (uint16_t) strtoul(token, &err, 0);
693 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
694 } else if (!strcmp(key_token, "r")) {
695 vector->mask |= TEST_BBDEV_VF_R;
696 ldpc_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0);
697 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
698 } else if (!strcmp(key_token, "q_m")) {
699 vector->mask |= TEST_BBDEV_VF_QM;
700 ldpc_enc->q_m = (uint8_t) strtoul(token, &err, 0);
701 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
702 } else if (!strcmp(key_token, "basegraph")) {
703 vector->mask |= TEST_BBDEV_VF_BG;
704 ldpc_enc->basegraph = (uint8_t) strtoul(token, &err, 0);
705 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
706 } else if (!strcmp(key_token, "z_c")) {
707 vector->mask |= TEST_BBDEV_VF_ZC;
708 ldpc_enc->z_c = (uint16_t) strtoul(token, &err, 0);
709 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
710 } else if (!strcmp(key_token, "n_filler")) {
711 vector->mask |= TEST_BBDEV_VF_F;
712 ldpc_enc->n_filler = (uint16_t) strtoul(token, &err, 0);
713 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
714 } else if (!strcmp(key_token, "code_block_mode")) {
715 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
716 ldpc_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0);
717 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
718 } else if (!strcmp(key_token, "op_flags")) {
719 vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
720 ret = parse_turbo_flags(token, &op_flags, vector->op_type);
722 ldpc_enc->op_flags = op_flags;
723 } else if (!strcmp(key_token, "expected_status")) {
724 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
725 ret = parse_expected_status(token, &status, vector->op_type);
727 vector->expected_status = status;
729 printf("Not valid ldpc enc key: '%s'\n", key_token);
734 printf("Failed with convert '%s\t%s'\n", key_token, token);
741 /* parses LDPC decoder parameters and assigns to global variable */
743 parse_ldpc_decoder_params(const char *key_token, char *token,
744 struct test_bbdev_vector *vector)
746 int ret = 0, status = 0;
747 uint32_t op_flags = 0;
750 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec;
752 if (starts_with(key_token, op_data_prefixes[DATA_INPUT]))
753 ret = parse_data_entry(key_token, token, vector,
755 op_data_prefixes[DATA_INPUT]);
756 else if (starts_with(key_token, "output"))
757 ret = parse_data_entry(key_token, token, vector,
760 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_INPUT]))
761 ret = parse_data_entry(key_token, token, vector,
763 op_data_prefixes[DATA_HARQ_INPUT]);
764 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_OUTPUT]))
765 ret = parse_data_entry(key_token, token, vector,
767 op_data_prefixes[DATA_HARQ_OUTPUT]);
768 else if (!strcmp(key_token, "e")) {
769 vector->mask |= TEST_BBDEV_VF_E;
770 ldpc_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0);
771 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
772 } else if (!strcmp(key_token, "ea")) {
773 vector->mask |= TEST_BBDEV_VF_EA;
774 ldpc_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0);
775 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
776 } else if (!strcmp(key_token, "eb")) {
777 vector->mask |= TEST_BBDEV_VF_EB;
778 ldpc_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0);
779 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
780 } else if (!strcmp(key_token, "c")) {
781 vector->mask |= TEST_BBDEV_VF_C;
782 ldpc_dec->tb_params.c = (uint8_t) strtoul(token, &err, 0);
783 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
784 } else if (!strcmp(key_token, "cab")) {
785 vector->mask |= TEST_BBDEV_VF_CAB;
786 ldpc_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0);
787 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
788 } else if (!strcmp(key_token, "rv_index")) {
789 vector->mask |= TEST_BBDEV_VF_RV_INDEX;
790 ldpc_dec->rv_index = (uint8_t) strtoul(token, &err, 0);
791 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
792 } else if (!strcmp(key_token, "n_cb")) {
793 vector->mask |= TEST_BBDEV_VF_NCB;
794 ldpc_dec->n_cb = (uint16_t) strtoul(token, &err, 0);
795 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
796 } else if (!strcmp(key_token, "r")) {
797 vector->mask |= TEST_BBDEV_VF_R;
798 ldpc_dec->tb_params.r = (uint8_t) strtoul(token, &err, 0);
799 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
800 } else if (!strcmp(key_token, "q_m")) {
801 vector->mask |= TEST_BBDEV_VF_QM;
802 ldpc_dec->q_m = (uint8_t) strtoul(token, &err, 0);
803 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
804 } else if (!strcmp(key_token, "basegraph")) {
805 vector->mask |= TEST_BBDEV_VF_BG;
806 ldpc_dec->basegraph = (uint8_t) strtoul(token, &err, 0);
807 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
808 } else if (!strcmp(key_token, "z_c")) {
809 vector->mask |= TEST_BBDEV_VF_ZC;
810 ldpc_dec->z_c = (uint16_t) strtoul(token, &err, 0);
811 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
812 } else if (!strcmp(key_token, "n_filler")) {
813 vector->mask |= TEST_BBDEV_VF_F;
814 ldpc_dec->n_filler = (uint16_t) strtoul(token, &err, 0);
815 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
816 } else if (!strcmp(key_token, "expected_iter_count")) {
817 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT;
818 ldpc_dec->iter_count = (uint8_t) strtoul(token, &err, 0);
819 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
820 } else if (!strcmp(key_token, "iter_max")) {
821 vector->mask |= TEST_BBDEV_VF_ITER_MAX;
822 ldpc_dec->iter_max = (uint8_t) strtoul(token, &err, 0);
823 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
824 } else if (!strcmp(key_token, "code_block_mode")) {
825 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
826 ldpc_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0);
827 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
828 } else if (!strcmp(key_token, "op_flags")) {
829 vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
830 ret = parse_turbo_flags(token, &op_flags, vector->op_type);
832 ldpc_dec->op_flags = op_flags;
833 } else if (!strcmp(key_token, "expected_status")) {
834 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
835 ret = parse_expected_status(token, &status, vector->op_type);
837 vector->expected_status = status;
839 printf("Not valid ldpc dec key: '%s'\n", key_token);
844 printf("Failed with convert '%s\t%s'\n", key_token, token);
851 /* checks the type of key and assigns data */
853 parse_entry(char *entry, struct test_bbdev_vector *vector)
856 char *token, *key_token;
857 enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_NONE;
860 printf("Expected entry value\n");
865 token = strtok(entry, ENTRY_DELIMITER);
867 /* get values for key */
868 token = strtok(NULL, ENTRY_DELIMITER);
870 if (key_token == NULL || token == NULL) {
871 printf("Expected 'key = values' but was '%.40s'..\n", entry);
874 trim_space(key_token);
876 /* first key_token has to specify type of operation */
877 if (vector->op_type == RTE_BBDEV_OP_NONE) {
878 if (!strcmp(key_token, "op_type")) {
879 ret = op_turbo_type_strtol(token, &op_type);
881 vector->op_type = op_type;
882 return (!ret) ? 0 : -1;
884 printf("First key_token (%s) does not specify op_type\n",
890 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) {
891 if (parse_decoder_params(key_token, token, vector) == -1)
893 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) {
894 if (parse_encoder_params(key_token, token, vector) == -1)
896 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) {
897 if (parse_ldpc_encoder_params(key_token, token, vector) == -1)
899 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) {
900 if (parse_ldpc_decoder_params(key_token, token, vector) == -1)
908 check_decoder_segments(struct test_bbdev_vector *vector)
911 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
913 if (vector->entries[DATA_INPUT].nb_segments == 0)
916 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
917 if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
920 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
923 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments;
925 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
928 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT) &&
929 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0))
932 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments;
934 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL)
941 check_ldpc_decoder_segments(struct test_bbdev_vector *vector)
944 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec;
946 if (vector->entries[DATA_INPUT].nb_segments == 0)
949 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
950 if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
953 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
956 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
957 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
960 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_SOFT_OUT_ENABLE) &&
961 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0))
964 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; i++)
965 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL)
968 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE) &&
969 (vector->entries[DATA_HARQ_OUTPUT].nb_segments == 0))
972 for (i = 0; i < vector->entries[DATA_HARQ_OUTPUT].nb_segments; i++)
973 if (vector->entries[DATA_HARQ_OUTPUT].segments[i].addr == NULL)
980 check_decoder_llr_spec(struct test_bbdev_vector *vector)
982 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
984 /* Check input LLR sign formalism specification */
985 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) &&
986 (turbo_dec->op_flags &
987 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) {
989 "Both positive and negative LLR input flags were set!\n");
992 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) &&
993 !(turbo_dec->op_flags &
994 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) {
996 "INFO: input LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n");
997 turbo_dec->op_flags |= RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN;
1000 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT))
1003 /* Check output LLR sign formalism specification */
1004 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) &&
1005 (turbo_dec->op_flags &
1006 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) {
1008 "Both positive and negative LLR output flags were set!\n");
1011 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) &&
1012 !(turbo_dec->op_flags &
1013 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) {
1015 "INFO: soft output LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n");
1016 turbo_dec->op_flags |=
1017 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT;
1024 check_decoder_op_flags(struct test_bbdev_vector *vector)
1026 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
1028 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP) &&
1029 !(turbo_dec->op_flags & RTE_BBDEV_TURBO_CRC_TYPE_24B)) {
1031 "WARNING: RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP flag is missing RTE_BBDEV_TURBO_CRC_TYPE_24B\n");
1038 /* checks decoder parameters */
1040 check_decoder(struct test_bbdev_vector *vector)
1042 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
1043 const int mask = vector->mask;
1045 if (check_decoder_segments(vector) < 0)
1048 if (check_decoder_llr_spec(vector) < 0)
1051 if (check_decoder_op_flags(vector) < 0)
1054 /* Check which params were set */
1055 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1057 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n");
1058 turbo_dec->code_block_mode = 1;
1060 if (turbo_dec->code_block_mode == 0) {
1061 if (!(mask & TEST_BBDEV_VF_EA))
1063 "WARNING: ea was not specified in vector file and will be set to 0\n");
1064 if (!(mask & TEST_BBDEV_VF_EB))
1066 "WARNING: eb was not specified in vector file and will be set to 0\n");
1067 if (!(mask & TEST_BBDEV_VF_K_NEG))
1069 "WARNING: k_neg was not specified in vector file and will be set to 0\n");
1070 if (!(mask & TEST_BBDEV_VF_K_POS))
1072 "WARNING: k_pos was not specified in vector file and will be set to 0\n");
1073 if (!(mask & TEST_BBDEV_VF_C_NEG))
1075 "WARNING: c_neg was not specified in vector file and will be set to 0\n");
1076 if (!(mask & TEST_BBDEV_VF_C)) {
1078 "WARNING: c was not specified in vector file and will be set to 1\n");
1079 turbo_dec->tb_params.c = 1;
1081 if (!(mask & TEST_BBDEV_VF_CAB))
1083 "WARNING: cab was not specified in vector file and will be set to 0\n");
1084 if (!(mask & TEST_BBDEV_VF_R))
1086 "WARNING: r was not specified in vector file and will be set to 0\n");
1088 if (!(mask & TEST_BBDEV_VF_E))
1090 "WARNING: e was not specified in vector file and will be set to 0\n");
1091 if (!(mask & TEST_BBDEV_VF_K))
1093 "WARNING: k was not specified in vector file and will be set to 0\n");
1095 if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1097 "INFO: rv_index was not specified in vector file and will be set to 0\n");
1098 if (!(mask & TEST_BBDEV_VF_ITER_MIN))
1100 "WARNING: iter_min was not specified in vector file and will be set to 0\n");
1101 if (!(mask & TEST_BBDEV_VF_ITER_MAX))
1103 "WARNING: iter_max was not specified in vector file and will be set to 0\n");
1104 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT))
1106 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n");
1107 if (!(mask & TEST_BBDEV_VF_EXT_SCALE))
1109 "WARNING: ext_scale was not specified in vector file and will be set to 0\n");
1110 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) {
1112 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n");
1113 turbo_dec->num_maps = 0;
1114 } else if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_MAP_DEC) &&
1115 mask & TEST_BBDEV_VF_NUM_MAPS) {
1117 "INFO: RTE_BBDEV_TURBO_MAP_DEC was not set in vector file and num_maps will be set to 0\n");
1118 turbo_dec->num_maps = 0;
1120 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1122 "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1126 /* checks LDPC decoder parameters */
1128 check_ldpc_decoder(struct test_bbdev_vector *vector)
1130 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec;
1131 const int mask = vector->mask;
1133 if (check_ldpc_decoder_segments(vector) < 0)
1137 * if (check_ldpc_decoder_llr_spec(vector) < 0)
1140 * if (check_ldpc_decoder_op_flags(vector) < 0)
1144 /* Check which params were set */
1145 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1147 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n");
1148 ldpc_dec->code_block_mode = 1;
1150 if (ldpc_dec->code_block_mode == 0) {
1151 if (!(mask & TEST_BBDEV_VF_EA))
1153 "WARNING: ea was not specified in vector file and will be set to 0\n");
1154 if (!(mask & TEST_BBDEV_VF_EB))
1156 "WARNING: eb was not specified in vector file and will be set to 0\n");
1157 if (!(mask & TEST_BBDEV_VF_C)) {
1159 "WARNING: c was not specified in vector file and will be set to 1\n");
1160 ldpc_dec->tb_params.c = 1;
1162 if (!(mask & TEST_BBDEV_VF_CAB))
1164 "WARNING: cab was not specified in vector file and will be set to 0\n");
1165 if (!(mask & TEST_BBDEV_VF_R))
1167 "WARNING: r was not specified in vector file and will be set to 0\n");
1169 if (!(mask & TEST_BBDEV_VF_E))
1171 "WARNING: e was not specified in vector file and will be set to 0\n");
1173 if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1175 "INFO: rv_index was not specified in vector file and will be set to 0\n");
1176 if (!(mask & TEST_BBDEV_VF_ITER_MAX))
1178 "WARNING: iter_max was not specified in vector file and will be set to 0\n");
1179 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT))
1181 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n");
1182 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) {
1184 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n");
1186 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1188 "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1192 /* checks encoder parameters */
1194 check_encoder(struct test_bbdev_vector *vector)
1197 const int mask = vector->mask;
1199 if (vector->entries[DATA_INPUT].nb_segments == 0)
1202 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1203 if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1206 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
1209 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
1210 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1213 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1215 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n");
1216 vector->turbo_enc.code_block_mode = 1;
1218 if (vector->turbo_enc.code_block_mode == 0) {
1219 if (!(mask & TEST_BBDEV_VF_EA) && (vector->turbo_enc.op_flags &
1220 RTE_BBDEV_TURBO_RATE_MATCH))
1222 "WARNING: ea was not specified in vector file and will be set to 0\n");
1223 if (!(mask & TEST_BBDEV_VF_EB) && (vector->turbo_enc.op_flags &
1224 RTE_BBDEV_TURBO_RATE_MATCH))
1226 "WARNING: eb was not specified in vector file and will be set to 0\n");
1227 if (!(mask & TEST_BBDEV_VF_K_NEG))
1229 "WARNING: k_neg was not specified in vector file and will be set to 0\n");
1230 if (!(mask & TEST_BBDEV_VF_K_POS))
1232 "WARNING: k_pos was not specified in vector file and will be set to 0\n");
1233 if (!(mask & TEST_BBDEV_VF_C_NEG))
1235 "WARNING: c_neg was not specified in vector file and will be set to 0\n");
1236 if (!(mask & TEST_BBDEV_VF_C)) {
1238 "WARNING: c was not specified in vector file and will be set to 1\n");
1239 vector->turbo_enc.tb_params.c = 1;
1241 if (!(mask & TEST_BBDEV_VF_CAB) && (vector->turbo_enc.op_flags &
1242 RTE_BBDEV_TURBO_RATE_MATCH))
1244 "WARNING: cab was not specified in vector file and will be set to 0\n");
1245 if (!(mask & TEST_BBDEV_VF_NCB_NEG))
1247 "WARNING: ncb_neg was not specified in vector file and will be set to 0\n");
1248 if (!(mask & TEST_BBDEV_VF_NCB_POS))
1250 "WARNING: ncb_pos was not specified in vector file and will be set to 0\n");
1251 if (!(mask & TEST_BBDEV_VF_R))
1253 "WARNING: r was not specified in vector file and will be set to 0\n");
1255 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags &
1256 RTE_BBDEV_TURBO_RATE_MATCH))
1258 "WARNING: e was not specified in vector file and will be set to 0\n");
1259 if (!(mask & TEST_BBDEV_VF_K))
1261 "WARNING: k was not specified in vector file and will be set to 0\n");
1262 if (!(mask & TEST_BBDEV_VF_NCB))
1264 "WARNING: ncb was not specified in vector file and will be set to 0\n");
1266 if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1268 "INFO: rv_index was not specified in vector file and will be set to 0\n");
1269 if (!(mask & TEST_BBDEV_VF_OP_FLAGS))
1271 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n");
1272 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1274 "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1280 /* checks encoder parameters */
1282 check_ldpc_encoder(struct test_bbdev_vector *vector)
1285 const int mask = vector->mask;
1287 if (vector->entries[DATA_INPUT].nb_segments == 0)
1290 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1291 if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1294 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
1297 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
1298 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1301 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1303 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n");
1304 vector->turbo_enc.code_block_mode = 1;
1306 if (vector->turbo_enc.code_block_mode == 0) {
1308 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags &
1309 RTE_BBDEV_TURBO_RATE_MATCH))
1311 "WARNING: e was not specified in vector file and will be set to 0\n");
1312 if (!(mask & TEST_BBDEV_VF_NCB))
1314 "WARNING: ncb was not specified in vector file and will be set to 0\n");
1316 if (!(mask & TEST_BBDEV_VF_BG))
1318 "WARNING: BG was not specified in vector file and will be set to 0\n");
1319 if (!(mask & TEST_BBDEV_VF_ZC))
1321 "WARNING: Zc was not specified in vector file and will be set to 0\n");
1322 if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1324 "INFO: rv_index was not specified in vector file and will be set to 0\n");
1325 if (!(mask & TEST_BBDEV_VF_OP_FLAGS))
1327 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n");
1328 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1330 "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1336 bbdev_check_vector(struct test_bbdev_vector *vector)
1338 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) {
1339 if (check_decoder(vector) == -1)
1341 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) {
1342 if (check_encoder(vector) == -1)
1344 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) {
1345 if (check_ldpc_encoder(vector) == -1)
1347 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) {
1348 if (check_ldpc_decoder(vector) == -1)
1350 } else if (vector->op_type != RTE_BBDEV_OP_NONE) {
1351 printf("Vector was not filled\n");
1359 test_bbdev_vector_read(const char *filename,
1360 struct test_bbdev_vector *vector)
1369 fp = fopen(filename, "r");
1371 printf("File %s does not exist\n", filename);
1375 while (getline(&line, &len, fp) != -1) {
1377 /* ignore comments and new lines */
1378 if (line[0] == '#' || line[0] == '/' || line[0] == '\n'
1384 /* buffer for multiline */
1385 entry = realloc(entry, strlen(line) + 1);
1386 if (entry == NULL) {
1387 printf("Fail to realloc %zu bytes\n", strlen(line) + 1);
1392 strcpy(entry, line);
1394 /* check if entry ends with , or = */
1395 if (entry[strlen(entry) - 1] == ','
1396 || entry[strlen(entry) - 1] == '=') {
1397 while (getline(&line, &len, fp) != -1) {
1400 /* extend entry about length of new line */
1401 char *entry_extended = realloc(entry,
1405 if (entry_extended == NULL) {
1406 printf("Fail to allocate %zu bytes\n",
1413 entry = entry_extended;
1414 /* entry has been allocated accordingly */
1415 strcpy(&entry[strlen(entry)], line);
1417 if (entry[strlen(entry) - 1] != ',')
1421 ret = parse_entry(entry, vector);
1423 printf("An error occurred while parsing!\n");
1427 ret = bbdev_check_vector(vector);
1429 printf("An error occurred while checking!\n");