1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2017 Intel Corporation 3 */ 4 5 #ifdef RTE_EXEC_ENV_FREEBSD 6 #define _WITH_GETLINE 7 #endif 8 #include <ctype.h> 9 #include <stdio.h> 10 #include <stdlib.h> 11 #include <stdbool.h> 12 #include <rte_malloc.h> 13 14 #include "test_bbdev_vector.h" 15 16 #define VALUE_DELIMITER "," 17 #define ENTRY_DELIMITER "=" 18 #define FFT_WIN_SIZE 12 19 20 const char *op_data_prefixes[] = { 21 "input", 22 "soft_output", 23 "hard_output", 24 "harq_input", 25 "harq_output", 26 }; 27 28 /* trim leading and trailing spaces */ 29 static void 30 trim_space(char *str) 31 { 32 char *start, *end; 33 34 for (start = str; *start; start++) { 35 if (!isspace((unsigned char) start[0])) 36 break; 37 } 38 39 for (end = start + strlen(start); end > start + 1; end--) { 40 if (!isspace((unsigned char) end[-1])) 41 break; 42 } 43 44 *end = 0; 45 46 /* Shift from "start" to the beginning of the string */ 47 if (start > str) 48 memmove(str, start, (end - start) + 1); 49 } 50 51 static bool 52 starts_with(const char *str, const char *pre) 53 { 54 return strncmp(pre, str, strlen(pre)) == 0; 55 } 56 57 /* tokenization test values separated by a comma */ 58 static int 59 parse_values(char *tokens, uint32_t **data, uint32_t *data_length) 60 { 61 uint32_t n_tokens = 0; 62 uint32_t data_size = 32; 63 64 uint32_t *values, *values_resized; 65 char *tok, *error = NULL; 66 67 tok = strtok(tokens, VALUE_DELIMITER); 68 if (tok == NULL) 69 return -1; 70 71 values = (uint32_t *) 72 rte_zmalloc(NULL, sizeof(uint32_t) * data_size, 0); 73 if (values == NULL) 74 return -1; 75 76 while (tok != NULL) { 77 values_resized = NULL; 78 79 if (n_tokens >= data_size) { 80 data_size *= 2; 81 82 values_resized = (uint32_t *) rte_realloc(values, 83 sizeof(uint32_t) * data_size, 0); 84 if (values_resized == NULL) { 85 rte_free(values); 86 return -1; 87 } 88 values = values_resized; 89 } 90 91 values[n_tokens] = (uint32_t) strtoul(tok, &error, 0); 92 93 if ((error == NULL) || (*error != '\0')) { 94 printf("Failed with convert '%s'\n", tok); 95 rte_free(values); 96 return -1; 97 } 98 99 *data_length = *data_length + (strlen(tok) - strlen("0x"))/2; 100 101 tok = strtok(NULL, VALUE_DELIMITER); 102 if (tok == NULL) 103 break; 104 105 n_tokens++; 106 } 107 108 values_resized = (uint32_t *) rte_realloc(values, 109 sizeof(uint32_t) * (n_tokens + 1), 0); 110 111 if (values_resized == NULL) { 112 rte_free(values); 113 return -1; 114 } 115 116 *data = values_resized; 117 118 return 0; 119 } 120 121 /* convert turbo decoder flag from string to unsigned long int*/ 122 static int 123 op_decoder_flag_strtoul(char *token, uint32_t *op_flag_value) 124 { 125 if (!strcmp(token, "RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE")) 126 *op_flag_value = RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE; 127 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_TYPE_24B")) 128 *op_flag_value = RTE_BBDEV_TURBO_CRC_TYPE_24B; 129 else if (!strcmp(token, "RTE_BBDEV_TURBO_EQUALIZER")) 130 *op_flag_value = RTE_BBDEV_TURBO_EQUALIZER; 131 else if (!strcmp(token, "RTE_BBDEV_TURBO_SOFT_OUT_SATURATE")) 132 *op_flag_value = RTE_BBDEV_TURBO_SOFT_OUT_SATURATE; 133 else if (!strcmp(token, "RTE_BBDEV_TURBO_HALF_ITERATION_EVEN")) 134 *op_flag_value = RTE_BBDEV_TURBO_HALF_ITERATION_EVEN; 135 else if (!strcmp(token, "RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH")) 136 *op_flag_value = RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH; 137 else if (!strcmp(token, "RTE_BBDEV_TURBO_SOFT_OUTPUT")) 138 *op_flag_value = RTE_BBDEV_TURBO_SOFT_OUTPUT; 139 else if (!strcmp(token, "RTE_BBDEV_TURBO_EARLY_TERMINATION")) 140 *op_flag_value = RTE_BBDEV_TURBO_EARLY_TERMINATION; 141 else if (!strcmp(token, "RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN")) 142 *op_flag_value = RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN; 143 else if (!strcmp(token, "RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN")) 144 *op_flag_value = RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN; 145 else if (!strcmp(token, "RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT")) 146 *op_flag_value = RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT; 147 else if (!strcmp(token, "RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT")) 148 *op_flag_value = RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT; 149 else if (!strcmp(token, "RTE_BBDEV_TURBO_MAP_DEC")) 150 *op_flag_value = RTE_BBDEV_TURBO_MAP_DEC; 151 else if (!strcmp(token, "RTE_BBDEV_TURBO_DEC_SCATTER_GATHER")) 152 *op_flag_value = RTE_BBDEV_TURBO_DEC_SCATTER_GATHER; 153 else if (!strcmp(token, "RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP")) 154 *op_flag_value = RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP; 155 else if (!strcmp(token, "RTE_BBDEV_TURBO_DEC_CRC_24B_DROP")) 156 *op_flag_value = RTE_BBDEV_TURBO_DEC_CRC_24B_DROP; 157 else { 158 printf("The given value is not a turbo decoder flag\n"); 159 return -1; 160 } 161 162 return 0; 163 } 164 165 /* convert LDPC flag from string to unsigned long int*/ 166 static int 167 op_ldpc_decoder_flag_strtoul(char *token, uint32_t *op_flag_value) 168 { 169 if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_TYPE_24A_CHECK")) 170 *op_flag_value = RTE_BBDEV_LDPC_CRC_TYPE_24A_CHECK; 171 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK")) 172 *op_flag_value = RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK; 173 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_TYPE_24B_DROP")) 174 *op_flag_value = RTE_BBDEV_LDPC_CRC_TYPE_24B_DROP; 175 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_TYPE_16_CHECK")) 176 *op_flag_value = RTE_BBDEV_LDPC_CRC_TYPE_16_CHECK; 177 else if (!strcmp(token, "RTE_BBDEV_LDPC_DEINTERLEAVER_BYPASS")) 178 *op_flag_value = RTE_BBDEV_LDPC_DEINTERLEAVER_BYPASS; 179 else if (!strcmp(token, "RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE")) 180 *op_flag_value = RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE; 181 else if (!strcmp(token, "RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE")) 182 *op_flag_value = RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE; 183 else if (!strcmp(token, "RTE_BBDEV_LDPC_DECODE_BYPASS")) 184 *op_flag_value = RTE_BBDEV_LDPC_DECODE_BYPASS; 185 else if (!strcmp(token, "RTE_BBDEV_LDPC_SOFT_OUT_ENABLE")) 186 *op_flag_value = RTE_BBDEV_LDPC_SOFT_OUT_ENABLE; 187 else if (!strcmp(token, "RTE_BBDEV_LDPC_SOFT_OUT_RM_BYPASS")) 188 *op_flag_value = RTE_BBDEV_LDPC_SOFT_OUT_RM_BYPASS; 189 else if (!strcmp(token, "RTE_BBDEV_LDPC_SOFT_OUT_DEINTERLEAVER_BYPASS")) 190 *op_flag_value = RTE_BBDEV_LDPC_SOFT_OUT_DEINTERLEAVER_BYPASS; 191 else if (!strcmp(token, "RTE_BBDEV_LDPC_ITERATION_STOP_ENABLE")) 192 *op_flag_value = RTE_BBDEV_LDPC_ITERATION_STOP_ENABLE; 193 else if (!strcmp(token, "RTE_BBDEV_LDPC_DEC_INTERRUPTS")) 194 *op_flag_value = RTE_BBDEV_LDPC_DEC_INTERRUPTS; 195 else if (!strcmp(token, "RTE_BBDEV_LDPC_DEC_SCATTER_GATHER")) 196 *op_flag_value = RTE_BBDEV_LDPC_DEC_SCATTER_GATHER; 197 else if (!strcmp(token, "RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION")) 198 *op_flag_value = RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION; 199 else if (!strcmp(token, "RTE_BBDEV_LDPC_LLR_COMPRESSION")) 200 *op_flag_value = RTE_BBDEV_LDPC_LLR_COMPRESSION; 201 else if (!strcmp(token, 202 "RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE")) 203 *op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE; 204 else if (!strcmp(token, 205 "RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE")) 206 *op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE; 207 else if (!strcmp(token, 208 "RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK")) 209 *op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK; 210 else { 211 printf("The given value is not a LDPC decoder flag\n"); 212 return -1; 213 } 214 215 return 0; 216 } 217 218 219 /* Convert FFT flag from string to unsigned long int. */ 220 static int 221 op_fft_flag_strtoul(char *token, uint32_t *op_flag_value) 222 { 223 if (!strcmp(token, "RTE_BBDEV_FFT_WINDOWING")) 224 *op_flag_value = RTE_BBDEV_FFT_WINDOWING; 225 else if (!strcmp(token, "RTE_BBDEV_FFT_CS_ADJUSTMENT")) 226 *op_flag_value = RTE_BBDEV_FFT_CS_ADJUSTMENT; 227 else if (!strcmp(token, "RTE_BBDEV_FFT_DFT_BYPASS")) 228 *op_flag_value = RTE_BBDEV_FFT_DFT_BYPASS; 229 else if (!strcmp(token, "RTE_BBDEV_FFT_IDFT_BYPASS")) 230 *op_flag_value = RTE_BBDEV_FFT_IDFT_BYPASS; 231 else if (!strcmp(token, "RTE_BBDEV_FFT_WINDOWING_BYPASS")) 232 *op_flag_value = RTE_BBDEV_FFT_WINDOWING_BYPASS; 233 else if (!strcmp(token, "RTE_BBDEV_FFT_POWER_MEAS")) 234 *op_flag_value = RTE_BBDEV_FFT_POWER_MEAS; 235 else if (!strcmp(token, "RTE_BBDEV_FFT_FP16_INPUT")) 236 *op_flag_value = RTE_BBDEV_FFT_FP16_INPUT; 237 else if (!strcmp(token, "RTE_BBDEV_FFT_FP16_OUTPUT")) 238 *op_flag_value = RTE_BBDEV_FFT_FP16_OUTPUT; 239 else { 240 printf("The given value is not a FFT flag\n"); 241 return -1; 242 } 243 244 return 0; 245 } 246 247 /* convert turbo encoder flag from string to unsigned long int*/ 248 static int 249 op_encoder_flag_strtoul(char *token, uint32_t *op_flag_value) 250 { 251 if (!strcmp(token, "RTE_BBDEV_TURBO_RV_INDEX_BYPASS")) 252 *op_flag_value = RTE_BBDEV_TURBO_RV_INDEX_BYPASS; 253 else if (!strcmp(token, "RTE_BBDEV_TURBO_RATE_MATCH")) 254 *op_flag_value = RTE_BBDEV_TURBO_RATE_MATCH; 255 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_24B_ATTACH")) 256 *op_flag_value = RTE_BBDEV_TURBO_CRC_24B_ATTACH; 257 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_24A_ATTACH")) 258 *op_flag_value = RTE_BBDEV_TURBO_CRC_24A_ATTACH; 259 else if (!strcmp(token, "RTE_BBDEV_TURBO_ENC_SCATTER_GATHER")) 260 *op_flag_value = RTE_BBDEV_TURBO_ENC_SCATTER_GATHER; 261 else { 262 printf("The given value is not a turbo encoder flag\n"); 263 return -1; 264 } 265 266 return 0; 267 } 268 269 /* convert LDPC encoder flag from string to unsigned long int*/ 270 static int 271 op_ldpc_encoder_flag_strtoul(char *token, uint32_t *op_flag_value) 272 { 273 if (!strcmp(token, "RTE_BBDEV_LDPC_INTERLEAVER_BYPASS")) 274 *op_flag_value = RTE_BBDEV_LDPC_INTERLEAVER_BYPASS; 275 else if (!strcmp(token, "RTE_BBDEV_LDPC_RATE_MATCH")) 276 *op_flag_value = RTE_BBDEV_LDPC_RATE_MATCH; 277 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_24A_ATTACH")) 278 *op_flag_value = RTE_BBDEV_LDPC_CRC_24A_ATTACH; 279 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_24B_ATTACH")) 280 *op_flag_value = RTE_BBDEV_LDPC_CRC_24B_ATTACH; 281 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_16_ATTACH")) 282 *op_flag_value = RTE_BBDEV_LDPC_CRC_16_ATTACH; 283 else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_INTERRUPTS")) 284 *op_flag_value = RTE_BBDEV_LDPC_ENC_INTERRUPTS; 285 else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_SCATTER_GATHER")) 286 *op_flag_value = RTE_BBDEV_LDPC_ENC_SCATTER_GATHER; 287 else { 288 printf("The given value is not a turbo encoder flag\n"); 289 return -1; 290 } 291 292 return 0; 293 } 294 295 /* tokenization turbo decoder/encoder flags values separated by a comma */ 296 static int 297 parse_turbo_flags(char *tokens, uint32_t *op_flags, 298 enum rte_bbdev_op_type op_type) 299 { 300 char *tok = NULL; 301 uint32_t op_flag_value = 0; 302 303 tok = strtok(tokens, VALUE_DELIMITER); 304 if (tok == NULL) 305 return -1; 306 307 while (tok != NULL) { 308 trim_space(tok); 309 if (op_type == RTE_BBDEV_OP_TURBO_DEC) { 310 if (op_decoder_flag_strtoul(tok, &op_flag_value) == -1) 311 return -1; 312 } else if (op_type == RTE_BBDEV_OP_TURBO_ENC) { 313 if (op_encoder_flag_strtoul(tok, &op_flag_value) == -1) 314 return -1; 315 } else if (op_type == RTE_BBDEV_OP_LDPC_ENC) { 316 if (op_ldpc_encoder_flag_strtoul(tok, &op_flag_value) 317 == -1) 318 return -1; 319 } else if (op_type == RTE_BBDEV_OP_LDPC_DEC) { 320 if (op_ldpc_decoder_flag_strtoul(tok, &op_flag_value) 321 == -1) 322 return -1; 323 } else if (op_type == RTE_BBDEV_OP_FFT) { 324 if (op_fft_flag_strtoul(tok, &op_flag_value) 325 == -1) 326 return -1; 327 } else { 328 return -1; 329 } 330 331 *op_flags = *op_flags | op_flag_value; 332 333 tok = strtok(NULL, VALUE_DELIMITER); 334 if (tok == NULL) 335 break; 336 } 337 338 return 0; 339 } 340 341 /* convert turbo encoder/decoder op_type from string to enum*/ 342 static int 343 op_turbo_type_strtol(char *token, enum rte_bbdev_op_type *op_type) 344 { 345 trim_space(token); 346 if (!strcmp(token, "RTE_BBDEV_OP_TURBO_DEC")) 347 *op_type = RTE_BBDEV_OP_TURBO_DEC; 348 else if (!strcmp(token, "RTE_BBDEV_OP_TURBO_ENC")) 349 *op_type = RTE_BBDEV_OP_TURBO_ENC; 350 else if (!strcmp(token, "RTE_BBDEV_OP_LDPC_ENC")) 351 *op_type = RTE_BBDEV_OP_LDPC_ENC; 352 else if (!strcmp(token, "RTE_BBDEV_OP_LDPC_DEC")) 353 *op_type = RTE_BBDEV_OP_LDPC_DEC; 354 else if (!strcmp(token, "RTE_BBDEV_OP_FFT")) 355 *op_type = RTE_BBDEV_OP_FFT; 356 else if (!strcmp(token, "RTE_BBDEV_OP_NONE")) 357 *op_type = RTE_BBDEV_OP_NONE; 358 else { 359 printf("Not valid turbo op_type: '%s'\n", token); 360 return -1; 361 } 362 363 return 0; 364 } 365 366 /* tokenization expected status values separated by a comma */ 367 static int 368 parse_expected_status(char *tokens, int *status, enum rte_bbdev_op_type op_type) 369 { 370 char *tok = NULL; 371 bool status_ok = false; 372 373 tok = strtok(tokens, VALUE_DELIMITER); 374 if (tok == NULL) 375 return -1; 376 377 while (tok != NULL) { 378 trim_space(tok); 379 if (!strcmp(tok, "OK")) 380 status_ok = true; 381 else if (!strcmp(tok, "DMA")) 382 *status = *status | (1 << RTE_BBDEV_DRV_ERROR); 383 else if (!strcmp(tok, "FCW")) 384 *status = *status | (1 << RTE_BBDEV_DATA_ERROR); 385 else if (!strcmp(tok, "SYNCRC")) { 386 *status = *status | (1 << RTE_BBDEV_SYNDROME_ERROR); 387 *status = *status | (1 << RTE_BBDEV_CRC_ERROR); 388 } else if (!strcmp(tok, "SYN")) 389 *status = *status | (1 << RTE_BBDEV_SYNDROME_ERROR); 390 else if (!strcmp(tok, "CRC")) { 391 if ((op_type == RTE_BBDEV_OP_TURBO_DEC) || 392 (op_type == RTE_BBDEV_OP_LDPC_DEC)) 393 *status = *status | (1 << RTE_BBDEV_CRC_ERROR); 394 else { 395 printf( 396 "CRC is only a valid value for decoder\n"); 397 return -1; 398 } 399 } else { 400 printf("Not valid status: '%s'\n", tok); 401 return -1; 402 } 403 404 tok = strtok(NULL, VALUE_DELIMITER); 405 if (tok == NULL) 406 break; 407 } 408 409 if (status_ok && *status != 0) { 410 printf( 411 "Not valid status values. Cannot be OK and ERROR at the same time.\n"); 412 return -1; 413 } 414 415 return 0; 416 } 417 418 /* parse ops data entry (there can be more than 1 input entry, each will be 419 * contained in a separate op_data_buf struct) 420 */ 421 static int 422 parse_data_entry(const char *key_token, char *token, 423 struct test_bbdev_vector *vector, enum op_data_type type, 424 const char *prefix) 425 { 426 int ret; 427 uint32_t data_length = 0; 428 uint32_t *data = NULL; 429 unsigned int id; 430 struct op_data_buf *op_data; 431 unsigned int *nb_ops; 432 433 if (type >= DATA_NUM_TYPES) { 434 printf("Unknown op type: %d!\n", type); 435 return -1; 436 } 437 438 op_data = vector->entries[type].segments; 439 nb_ops = &vector->entries[type].nb_segments; 440 441 if (*nb_ops >= RTE_BBDEV_TURBO_MAX_CODE_BLOCKS) { 442 printf("Too many segments (code blocks defined): %u, max %d!\n", 443 *nb_ops, RTE_BBDEV_TURBO_MAX_CODE_BLOCKS); 444 return -1; 445 } 446 447 if (sscanf(key_token + strlen(prefix), "%u", &id) != 1) { 448 printf("Missing ID of %s\n", prefix); 449 return -1; 450 } 451 if (id != *nb_ops) { 452 printf( 453 "Please order data entries sequentially, i.e. %s0, %s1, ...\n", 454 prefix, prefix); 455 return -1; 456 } 457 458 /* Clear new op data struct */ 459 memset(op_data + *nb_ops, 0, sizeof(struct op_data_buf)); 460 461 ret = parse_values(token, &data, &data_length); 462 if (!ret) { 463 op_data[*nb_ops].addr = data; 464 op_data[*nb_ops].length = data_length; 465 ++(*nb_ops); 466 } 467 468 return ret; 469 } 470 471 /* parses turbo decoder parameters and assigns to global variable */ 472 static int 473 parse_decoder_params(const char *key_token, char *token, 474 struct test_bbdev_vector *vector) 475 { 476 int ret = 0, status = 0; 477 uint32_t op_flags = 0; 478 char *err = NULL; 479 480 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 481 482 /* compare keys */ 483 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 484 ret = parse_data_entry(key_token, token, vector, 485 DATA_INPUT, op_data_prefixes[DATA_INPUT]); 486 487 else if (starts_with(key_token, op_data_prefixes[DATA_SOFT_OUTPUT])) 488 ret = parse_data_entry(key_token, token, vector, 489 DATA_SOFT_OUTPUT, 490 op_data_prefixes[DATA_SOFT_OUTPUT]); 491 492 else if (starts_with(key_token, op_data_prefixes[DATA_HARD_OUTPUT])) 493 ret = parse_data_entry(key_token, token, vector, 494 DATA_HARD_OUTPUT, 495 op_data_prefixes[DATA_HARD_OUTPUT]); 496 else if (!strcmp(key_token, "e")) { 497 vector->mask |= TEST_BBDEV_VF_E; 498 turbo_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0); 499 } else if (!strcmp(key_token, "ea")) { 500 vector->mask |= TEST_BBDEV_VF_EA; 501 turbo_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 502 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 503 } else if (!strcmp(key_token, "eb")) { 504 vector->mask |= TEST_BBDEV_VF_EB; 505 turbo_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 506 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 507 } else if (!strcmp(key_token, "k")) { 508 vector->mask |= TEST_BBDEV_VF_K; 509 turbo_dec->cb_params.k = (uint16_t) strtoul(token, &err, 0); 510 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 511 } else if (!strcmp(key_token, "k_pos")) { 512 vector->mask |= TEST_BBDEV_VF_K_POS; 513 turbo_dec->tb_params.k_pos = (uint16_t) strtoul(token, &err, 0); 514 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 515 } else if (!strcmp(key_token, "k_neg")) { 516 vector->mask |= TEST_BBDEV_VF_K_NEG; 517 turbo_dec->tb_params.k_neg = (uint16_t) strtoul(token, &err, 0); 518 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 519 } else if (!strcmp(key_token, "c")) { 520 vector->mask |= TEST_BBDEV_VF_C; 521 turbo_dec->tb_params.c = (uint16_t) strtoul(token, &err, 0); 522 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 523 } else if (!strcmp(key_token, "c_neg")) { 524 vector->mask |= TEST_BBDEV_VF_C_NEG; 525 turbo_dec->tb_params.c_neg = (uint16_t) strtoul(token, &err, 0); 526 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 527 } else if (!strcmp(key_token, "cab")) { 528 vector->mask |= TEST_BBDEV_VF_CAB; 529 turbo_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 530 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 531 } else if (!strcmp(key_token, "rv_index")) { 532 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 533 turbo_dec->rv_index = (uint8_t) strtoul(token, &err, 0); 534 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 535 } else if (!strcmp(key_token, "iter_min")) { 536 vector->mask |= TEST_BBDEV_VF_ITER_MIN; 537 turbo_dec->iter_min = (uint8_t) strtoul(token, &err, 0); 538 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 539 } else if (!strcmp(key_token, "expected_iter_count")) { 540 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT; 541 turbo_dec->iter_count = (uint8_t) strtoul(token, &err, 0); 542 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 543 } else if (!strcmp(key_token, "ext_scale")) { 544 vector->mask |= TEST_BBDEV_VF_EXT_SCALE; 545 turbo_dec->ext_scale = (uint8_t) strtoul(token, &err, 0); 546 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 547 } else if (!strcmp(key_token, "num_maps")) { 548 vector->mask |= TEST_BBDEV_VF_NUM_MAPS; 549 turbo_dec->num_maps = (uint8_t) strtoul(token, &err, 0); 550 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 551 } else if (!strcmp(key_token, "r")) { 552 vector->mask |= TEST_BBDEV_VF_R; 553 turbo_dec->tb_params.r = (uint8_t)strtoul(token, &err, 0); 554 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 555 } else if (!strcmp(key_token, "code_block_mode")) { 556 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 557 turbo_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0); 558 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 559 } else if (!strcmp(key_token, "op_flags")) { 560 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 561 ret = parse_turbo_flags(token, &op_flags, 562 vector->op_type); 563 if (!ret) 564 turbo_dec->op_flags = op_flags; 565 } else if (!strcmp(key_token, "expected_status")) { 566 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 567 ret = parse_expected_status(token, &status, vector->op_type); 568 if (!ret) 569 vector->expected_status = status; 570 } else { 571 printf("Not valid dec key: '%s'\n", key_token); 572 return -1; 573 } 574 575 if (ret != 0) { 576 printf("Failed with convert '%s\t%s'\n", key_token, token); 577 return -1; 578 } 579 580 return 0; 581 } 582 583 /* parses turbo encoder parameters and assigns to global variable */ 584 static int 585 parse_encoder_params(const char *key_token, char *token, 586 struct test_bbdev_vector *vector) 587 { 588 int ret = 0, status = 0; 589 uint32_t op_flags = 0; 590 char *err = NULL; 591 592 593 struct rte_bbdev_op_turbo_enc *turbo_enc = &vector->turbo_enc; 594 595 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 596 ret = parse_data_entry(key_token, token, vector, 597 DATA_INPUT, op_data_prefixes[DATA_INPUT]); 598 else if (starts_with(key_token, "output")) 599 ret = parse_data_entry(key_token, token, vector, 600 DATA_HARD_OUTPUT, "output"); 601 else if (!strcmp(key_token, "e")) { 602 vector->mask |= TEST_BBDEV_VF_E; 603 turbo_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0); 604 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 605 } else if (!strcmp(key_token, "ea")) { 606 vector->mask |= TEST_BBDEV_VF_EA; 607 turbo_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 608 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 609 } else if (!strcmp(key_token, "eb")) { 610 vector->mask |= TEST_BBDEV_VF_EB; 611 turbo_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 612 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 613 } else if (!strcmp(key_token, "k")) { 614 vector->mask |= TEST_BBDEV_VF_K; 615 turbo_enc->cb_params.k = (uint16_t) strtoul(token, &err, 0); 616 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 617 } else if (!strcmp(key_token, "k_neg")) { 618 vector->mask |= TEST_BBDEV_VF_K_NEG; 619 turbo_enc->tb_params.k_neg = (uint16_t) strtoul(token, &err, 0); 620 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 621 } else if (!strcmp(key_token, "k_pos")) { 622 vector->mask |= TEST_BBDEV_VF_K_POS; 623 turbo_enc->tb_params.k_pos = (uint16_t) strtoul(token, &err, 0); 624 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 625 } else if (!strcmp(key_token, "c_neg")) { 626 vector->mask |= TEST_BBDEV_VF_C_NEG; 627 turbo_enc->tb_params.c_neg = (uint8_t) strtoul(token, &err, 0); 628 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 629 } else if (!strcmp(key_token, "c")) { 630 vector->mask |= TEST_BBDEV_VF_C; 631 turbo_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0); 632 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 633 } else if (!strcmp(key_token, "cab")) { 634 vector->mask |= TEST_BBDEV_VF_CAB; 635 turbo_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 636 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 637 } else if (!strcmp(key_token, "rv_index")) { 638 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 639 turbo_enc->rv_index = (uint8_t) strtoul(token, &err, 0); 640 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 641 } else if (!strcmp(key_token, "ncb")) { 642 vector->mask |= TEST_BBDEV_VF_NCB; 643 turbo_enc->cb_params.ncb = (uint16_t) strtoul(token, &err, 0); 644 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 645 } else if (!strcmp(key_token, "ncb_neg")) { 646 vector->mask |= TEST_BBDEV_VF_NCB_NEG; 647 turbo_enc->tb_params.ncb_neg = 648 (uint16_t) strtoul(token, &err, 0); 649 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 650 } else if (!strcmp(key_token, "ncb_pos")) { 651 vector->mask |= TEST_BBDEV_VF_NCB_POS; 652 turbo_enc->tb_params.ncb_pos = 653 (uint16_t) strtoul(token, &err, 0); 654 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 655 } else if (!strcmp(key_token, "r")) { 656 vector->mask |= TEST_BBDEV_VF_R; 657 turbo_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0); 658 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 659 } else if (!strcmp(key_token, "code_block_mode")) { 660 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 661 turbo_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0); 662 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 663 } else if (!strcmp(key_token, "op_flags")) { 664 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 665 ret = parse_turbo_flags(token, &op_flags, 666 vector->op_type); 667 if (!ret) 668 turbo_enc->op_flags = op_flags; 669 } else if (!strcmp(key_token, "expected_status")) { 670 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 671 ret = parse_expected_status(token, &status, vector->op_type); 672 if (!ret) 673 vector->expected_status = status; 674 } else { 675 printf("Not valid enc key: '%s'\n", key_token); 676 return -1; 677 } 678 679 if (ret != 0) { 680 printf("Failed with convert '%s\t%s'\n", key_token, token); 681 return -1; 682 } 683 684 return 0; 685 } 686 687 688 /* parses LDPC encoder parameters and assigns to global variable */ 689 static int 690 parse_ldpc_encoder_params(const char *key_token, char *token, 691 struct test_bbdev_vector *vector) 692 { 693 int ret = 0, status = 0; 694 uint32_t op_flags = 0; 695 char *err = NULL; 696 697 struct rte_bbdev_op_ldpc_enc *ldpc_enc = &vector->ldpc_enc; 698 699 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 700 ret = parse_data_entry(key_token, token, vector, 701 DATA_INPUT, 702 op_data_prefixes[DATA_INPUT]); 703 else if (starts_with(key_token, "output")) 704 ret = parse_data_entry(key_token, token, vector, 705 DATA_HARD_OUTPUT, 706 "output"); 707 else if (!strcmp(key_token, "e")) { 708 vector->mask |= TEST_BBDEV_VF_E; 709 ldpc_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0); 710 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 711 } else if (!strcmp(key_token, "ea")) { 712 vector->mask |= TEST_BBDEV_VF_EA; 713 ldpc_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 714 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 715 } else if (!strcmp(key_token, "eb")) { 716 vector->mask |= TEST_BBDEV_VF_EB; 717 ldpc_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 718 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 719 } else if (!strcmp(key_token, "c")) { 720 vector->mask |= TEST_BBDEV_VF_C; 721 ldpc_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0); 722 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 723 } else if (!strcmp(key_token, "cab")) { 724 vector->mask |= TEST_BBDEV_VF_CAB; 725 ldpc_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 726 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 727 } else if (!strcmp(key_token, "rv_index")) { 728 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 729 ldpc_enc->rv_index = (uint8_t) strtoul(token, &err, 0); 730 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 731 } else if (!strcmp(key_token, "n_cb")) { 732 vector->mask |= TEST_BBDEV_VF_NCB; 733 ldpc_enc->n_cb = (uint16_t) strtoul(token, &err, 0); 734 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 735 } else if (!strcmp(key_token, "r")) { 736 vector->mask |= TEST_BBDEV_VF_R; 737 ldpc_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0); 738 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 739 } else if (!strcmp(key_token, "q_m")) { 740 vector->mask |= TEST_BBDEV_VF_QM; 741 ldpc_enc->q_m = (uint8_t) strtoul(token, &err, 0); 742 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 743 } else if (!strcmp(key_token, "basegraph")) { 744 vector->mask |= TEST_BBDEV_VF_BG; 745 ldpc_enc->basegraph = (uint8_t) strtoul(token, &err, 0); 746 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 747 } else if (!strcmp(key_token, "z_c")) { 748 vector->mask |= TEST_BBDEV_VF_ZC; 749 ldpc_enc->z_c = (uint16_t) strtoul(token, &err, 0); 750 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 751 } else if (!strcmp(key_token, "n_filler")) { 752 vector->mask |= TEST_BBDEV_VF_F; 753 ldpc_enc->n_filler = (uint16_t) strtoul(token, &err, 0); 754 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 755 } else if (!strcmp(key_token, "code_block_mode")) { 756 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 757 ldpc_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0); 758 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 759 } else if (!strcmp(key_token, "op_flags")) { 760 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 761 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 762 if (!ret) 763 ldpc_enc->op_flags = op_flags; 764 } else if (!strcmp(key_token, "expected_status")) { 765 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 766 ret = parse_expected_status(token, &status, vector->op_type); 767 if (!ret) 768 vector->expected_status = status; 769 } else { 770 printf("Not valid ldpc enc key: '%s'\n", key_token); 771 return -1; 772 } 773 774 if (ret != 0) { 775 printf("Failed with convert '%s\t%s'\n", key_token, token); 776 return -1; 777 } 778 779 return 0; 780 } 781 782 /* parses LDPC decoder parameters and assigns to global variable */ 783 static int 784 parse_ldpc_decoder_params(const char *key_token, char *token, 785 struct test_bbdev_vector *vector) 786 { 787 int ret = 0, status = 0; 788 uint32_t op_flags = 0; 789 char *err = NULL; 790 791 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 792 793 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 794 ret = parse_data_entry(key_token, token, vector, 795 DATA_INPUT, 796 op_data_prefixes[DATA_INPUT]); 797 else if (starts_with(key_token, "output")) 798 ret = parse_data_entry(key_token, token, vector, 799 DATA_HARD_OUTPUT, 800 "output"); 801 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_INPUT])) 802 ret = parse_data_entry(key_token, token, vector, 803 DATA_HARQ_INPUT, 804 op_data_prefixes[DATA_HARQ_INPUT]); 805 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_OUTPUT])) 806 ret = parse_data_entry(key_token, token, vector, 807 DATA_HARQ_OUTPUT, 808 op_data_prefixes[DATA_HARQ_OUTPUT]); 809 else if (!strcmp(key_token, "e")) { 810 vector->mask |= TEST_BBDEV_VF_E; 811 ldpc_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0); 812 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 813 } else if (!strcmp(key_token, "ea")) { 814 vector->mask |= TEST_BBDEV_VF_EA; 815 ldpc_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 816 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 817 } else if (!strcmp(key_token, "eb")) { 818 vector->mask |= TEST_BBDEV_VF_EB; 819 ldpc_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 820 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 821 } else if (!strcmp(key_token, "c")) { 822 vector->mask |= TEST_BBDEV_VF_C; 823 ldpc_dec->tb_params.c = (uint8_t) strtoul(token, &err, 0); 824 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 825 } else if (!strcmp(key_token, "cab")) { 826 vector->mask |= TEST_BBDEV_VF_CAB; 827 ldpc_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 828 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 829 } else if (!strcmp(key_token, "rv_index")) { 830 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 831 ldpc_dec->rv_index = (uint8_t) strtoul(token, &err, 0); 832 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 833 } else if (!strcmp(key_token, "n_cb")) { 834 vector->mask |= TEST_BBDEV_VF_NCB; 835 ldpc_dec->n_cb = (uint16_t) strtoul(token, &err, 0); 836 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 837 } else if (!strcmp(key_token, "r")) { 838 vector->mask |= TEST_BBDEV_VF_R; 839 ldpc_dec->tb_params.r = (uint8_t) strtoul(token, &err, 0); 840 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 841 } else if (!strcmp(key_token, "q_m")) { 842 vector->mask |= TEST_BBDEV_VF_QM; 843 ldpc_dec->q_m = (uint8_t) strtoul(token, &err, 0); 844 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 845 } else if (!strcmp(key_token, "basegraph")) { 846 vector->mask |= TEST_BBDEV_VF_BG; 847 ldpc_dec->basegraph = (uint8_t) strtoul(token, &err, 0); 848 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 849 } else if (!strcmp(key_token, "z_c")) { 850 vector->mask |= TEST_BBDEV_VF_ZC; 851 ldpc_dec->z_c = (uint16_t) strtoul(token, &err, 0); 852 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 853 } else if (!strcmp(key_token, "n_filler")) { 854 vector->mask |= TEST_BBDEV_VF_F; 855 ldpc_dec->n_filler = (uint16_t) strtoul(token, &err, 0); 856 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 857 } else if (!strcmp(key_token, "expected_iter_count")) { 858 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT; 859 ldpc_dec->iter_count = (uint8_t) strtoul(token, &err, 0); 860 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 861 } else if (!strcmp(key_token, "code_block_mode")) { 862 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 863 ldpc_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0); 864 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 865 } else if (!strcmp(key_token, "op_flags")) { 866 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 867 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 868 if (!ret) 869 ldpc_dec->op_flags = op_flags; 870 } else if (!strcmp(key_token, "expected_status")) { 871 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 872 ret = parse_expected_status(token, &status, vector->op_type); 873 if (!ret) 874 vector->expected_status = status; 875 } else { 876 printf("Not valid ldpc dec key: '%s'\n", key_token); 877 return -1; 878 } 879 880 if (ret != 0) { 881 printf("Failed with convert '%s\t%s'\n", key_token, token); 882 return -1; 883 } 884 885 return 0; 886 } 887 888 889 /* Parse FFT parameters and assigns to global variable. */ 890 static int 891 parse_fft_params(const char *key_token, char *token, 892 struct test_bbdev_vector *vector) 893 { 894 int ret = 0, status = 0, i, shift; 895 uint32_t op_flags = 0; 896 char *tok, *err = NULL; 897 898 struct rte_bbdev_op_fft *fft = &vector->fft; 899 900 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) { 901 ret = parse_data_entry(key_token, token, vector, 902 DATA_INPUT, 903 op_data_prefixes[DATA_INPUT]); 904 } else if (starts_with(key_token, "output")) { 905 ret = parse_data_entry(key_token, token, vector, 906 DATA_HARD_OUTPUT, 907 "output"); 908 } else if (starts_with(key_token, "power_output")) { 909 ret = parse_data_entry(key_token, token, vector, 910 DATA_SOFT_OUTPUT, 911 "power_output"); 912 } else if (!strcmp(key_token, "in_sequence_size")) { 913 fft->input_sequence_size = (uint32_t) strtoul(token, &err, 0); 914 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 915 } else if (!strcmp(key_token, "in_leading_padding")) { 916 fft->input_leading_padding = (uint32_t) strtoul(token, &err, 0); 917 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 918 } else if (!strcmp(key_token, "out_sequence_size")) { 919 fft->output_sequence_size = (uint32_t) strtoul(token, &err, 0); 920 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 921 } else if (!strcmp(key_token, "out_leading_depadding")) { 922 fft->output_leading_depadding = (uint32_t) strtoul(token, &err, 0); 923 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 924 } else if (!strcmp(key_token, "window_index")) { 925 tok = strtok(token, VALUE_DELIMITER); 926 if (tok == NULL) 927 return -1; 928 for (i = 0; i < FFT_WIN_SIZE; i++) { 929 shift = (i % 2) ? 4 : 0; 930 fft->window_index[i / 2] |= (uint32_t) strtoul(tok, &err, 0) 931 << shift; 932 if (i < (FFT_WIN_SIZE - 1)) { 933 tok = strtok(NULL, VALUE_DELIMITER); 934 if (tok == NULL) 935 return -1; 936 } 937 } 938 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 939 } else if (!strcmp(key_token, "cs_bitmap")) { 940 fft->cs_bitmap = (uint32_t) strtoul(token, &err, 0); 941 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 942 } else if (!strcmp(key_token, "num_antennas_log2")) { 943 fft->num_antennas_log2 = (uint32_t) strtoul(token, &err, 0); 944 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 945 } else if (!strcmp(key_token, "ifft_log2")) { 946 fft->idft_log2 = (uint32_t) strtoul(token, &err, 0); 947 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 948 } else if (!strcmp(key_token, "fft_log2")) { 949 fft->dft_log2 = (uint32_t) strtoul(token, &err, 0); 950 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 951 } else if (!strcmp(key_token, "cs_time_adjustment")) { 952 fft->cs_time_adjustment = (uint32_t) strtoul(token, &err, 0); 953 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 954 } else if (!strcmp(key_token, "ifft_shift")) { 955 fft->idft_shift = (uint32_t) strtoul(token, &err, 0); 956 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 957 } else if (!strcmp(key_token, "fft_shift")) { 958 fft->dft_shift = (uint32_t) strtoul(token, &err, 0); 959 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 960 } else if (!strcmp(key_token, "ncs_reciprocal")) { 961 fft->ncs_reciprocal = (uint32_t) strtoul(token, &err, 0); 962 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 963 } else if (!strcmp(key_token, "power_shift")) { 964 fft->power_shift = (uint32_t) strtoul(token, &err, 0); 965 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 966 } else if (!strcmp(key_token, "fp16_exponent_adjust")) { 967 fft->fp16_exp_adjust = (uint32_t) strtoul(token, &err, 0); 968 printf("%d\n", fft->fp16_exp_adjust); 969 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 970 } else if (!strcmp(key_token, "op_flags")) { 971 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 972 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 973 if (!ret) 974 fft->op_flags = op_flags; 975 } else if (!strcmp(key_token, "expected_status")) { 976 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 977 ret = parse_expected_status(token, &status, vector->op_type); 978 if (!ret) 979 vector->expected_status = status; 980 } else { 981 printf("Not valid fft key: '%s'\n", key_token); 982 return -1; 983 } 984 985 if (ret != 0) { 986 printf("Failed with convert '%s\t%s'\n", key_token, token); 987 return -1; 988 } 989 990 return 0; 991 } 992 993 /* checks the type of key and assigns data */ 994 static int 995 parse_entry(char *entry, struct test_bbdev_vector *vector) 996 { 997 int ret = 0; 998 char *token, *key_token; 999 enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_NONE; 1000 1001 if (entry == NULL) { 1002 printf("Expected entry value\n"); 1003 return -1; 1004 } 1005 1006 /* get key */ 1007 token = strtok(entry, ENTRY_DELIMITER); 1008 key_token = token; 1009 /* get values for key */ 1010 token = strtok(NULL, ENTRY_DELIMITER); 1011 1012 if (key_token == NULL || token == NULL) { 1013 printf("Expected 'key = values' but was '%.40s'..\n", entry); 1014 return -1; 1015 } 1016 trim_space(key_token); 1017 1018 /* first key_token has to specify type of operation */ 1019 if (vector->op_type == RTE_BBDEV_OP_NONE) { 1020 if (!strcmp(key_token, "op_type")) { 1021 ret = op_turbo_type_strtol(token, &op_type); 1022 if (!ret) 1023 vector->op_type = op_type; 1024 return (!ret) ? 0 : -1; 1025 } 1026 printf("First key_token (%s) does not specify op_type\n", 1027 key_token); 1028 return -1; 1029 } 1030 1031 /* compare keys */ 1032 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) { 1033 if (parse_decoder_params(key_token, token, vector) == -1) 1034 return -1; 1035 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) { 1036 if (parse_encoder_params(key_token, token, vector) == -1) 1037 return -1; 1038 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) { 1039 if (parse_ldpc_encoder_params(key_token, token, vector) == -1) 1040 return -1; 1041 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { 1042 if (parse_ldpc_decoder_params(key_token, token, vector) == -1) 1043 return -1; 1044 } else if (vector->op_type == RTE_BBDEV_OP_FFT) { 1045 if (parse_fft_params(key_token, token, vector) == -1) 1046 return -1; 1047 } 1048 1049 return 0; 1050 } 1051 1052 static int 1053 check_decoder_segments(struct test_bbdev_vector *vector) 1054 { 1055 unsigned char i; 1056 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1057 1058 if (vector->entries[DATA_INPUT].nb_segments == 0) 1059 return -1; 1060 1061 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1062 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1063 return -1; 1064 1065 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1066 return -1; 1067 1068 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; 1069 i++) 1070 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1071 return -1; 1072 1073 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT) && 1074 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0)) 1075 return -1; 1076 1077 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; 1078 i++) 1079 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL) 1080 return -1; 1081 1082 return 0; 1083 } 1084 1085 static int 1086 check_ldpc_decoder_segments(struct test_bbdev_vector *vector) 1087 { 1088 unsigned char i; 1089 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 1090 1091 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1092 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1093 return -1; 1094 1095 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1096 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1097 return -1; 1098 1099 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_SOFT_OUT_ENABLE) && 1100 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0)) 1101 return -1; 1102 1103 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; i++) 1104 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL) 1105 return -1; 1106 1107 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE) && 1108 (vector->entries[DATA_HARQ_OUTPUT].nb_segments == 0)) 1109 return -1; 1110 1111 for (i = 0; i < vector->entries[DATA_HARQ_OUTPUT].nb_segments; i++) 1112 if (vector->entries[DATA_HARQ_OUTPUT].segments[i].addr == NULL) 1113 return -1; 1114 1115 return 0; 1116 } 1117 1118 static int 1119 check_fft_segments(struct test_bbdev_vector *vector) 1120 { 1121 unsigned char i; 1122 1123 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1124 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1125 return -1; 1126 1127 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1128 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1129 return -1; 1130 return 0; 1131 } 1132 1133 static int 1134 check_decoder_llr_spec(struct test_bbdev_vector *vector) 1135 { 1136 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1137 1138 /* Check input LLR sign formalism specification */ 1139 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) && 1140 (turbo_dec->op_flags & 1141 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) { 1142 printf( 1143 "Both positive and negative LLR input flags were set!\n"); 1144 return -1; 1145 } 1146 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) && 1147 !(turbo_dec->op_flags & 1148 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) { 1149 printf( 1150 "INFO: input LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n"); 1151 turbo_dec->op_flags |= RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN; 1152 } 1153 1154 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT)) 1155 return 0; 1156 1157 /* Check output LLR sign formalism specification */ 1158 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) && 1159 (turbo_dec->op_flags & 1160 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) { 1161 printf( 1162 "Both positive and negative LLR output flags were set!\n"); 1163 return -1; 1164 } 1165 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) && 1166 !(turbo_dec->op_flags & 1167 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) { 1168 printf( 1169 "INFO: soft output LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n"); 1170 turbo_dec->op_flags |= 1171 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT; 1172 } 1173 1174 return 0; 1175 } 1176 1177 static int 1178 check_decoder_op_flags(struct test_bbdev_vector *vector) 1179 { 1180 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1181 1182 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP) && 1183 !(turbo_dec->op_flags & RTE_BBDEV_TURBO_CRC_TYPE_24B)) { 1184 printf( 1185 "WARNING: RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP flag is missing RTE_BBDEV_TURBO_CRC_TYPE_24B\n"); 1186 return -1; 1187 } 1188 1189 return 0; 1190 } 1191 1192 /* checks decoder parameters */ 1193 static int 1194 check_decoder(struct test_bbdev_vector *vector) 1195 { 1196 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1197 const int mask = vector->mask; 1198 1199 if (check_decoder_segments(vector) < 0) 1200 return -1; 1201 1202 if (check_decoder_llr_spec(vector) < 0) 1203 return -1; 1204 1205 if (check_decoder_op_flags(vector) < 0) 1206 return -1; 1207 1208 /* Check which params were set */ 1209 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1210 printf( 1211 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n"); 1212 turbo_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK; 1213 } 1214 if (turbo_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1215 if (!(mask & TEST_BBDEV_VF_EA)) 1216 printf( 1217 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1218 if (!(mask & TEST_BBDEV_VF_EB)) 1219 printf( 1220 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1221 if (!(mask & TEST_BBDEV_VF_K_NEG)) 1222 printf( 1223 "WARNING: k_neg was not specified in vector file and will be set to 0\n"); 1224 if (!(mask & TEST_BBDEV_VF_K_POS)) 1225 printf( 1226 "WARNING: k_pos was not specified in vector file and will be set to 0\n"); 1227 if (!(mask & TEST_BBDEV_VF_C_NEG)) 1228 printf( 1229 "WARNING: c_neg was not specified in vector file and will be set to 0\n"); 1230 if (!(mask & TEST_BBDEV_VF_C)) { 1231 printf( 1232 "WARNING: c was not specified in vector file and will be set to 1\n"); 1233 turbo_dec->tb_params.c = 1; 1234 } 1235 if (!(mask & TEST_BBDEV_VF_CAB)) 1236 printf( 1237 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1238 if (!(mask & TEST_BBDEV_VF_R)) 1239 printf( 1240 "WARNING: r was not specified in vector file and will be set to 0\n"); 1241 } else { 1242 if (!(mask & TEST_BBDEV_VF_E)) 1243 printf( 1244 "WARNING: e was not specified in vector file and will be set to 0\n"); 1245 if (!(mask & TEST_BBDEV_VF_K)) 1246 printf( 1247 "WARNING: k was not specified in vector file and will be set to 0\n"); 1248 } 1249 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1250 printf( 1251 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1252 if (!(mask & TEST_BBDEV_VF_ITER_MIN)) 1253 printf( 1254 "WARNING: iter_min was not specified in vector file and will be set to 0\n"); 1255 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT)) 1256 printf( 1257 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n"); 1258 if (!(mask & TEST_BBDEV_VF_EXT_SCALE)) 1259 printf( 1260 "WARNING: ext_scale was not specified in vector file and will be set to 0\n"); 1261 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1262 printf( 1263 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1264 turbo_dec->num_maps = 0; 1265 } else if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_MAP_DEC) && 1266 mask & TEST_BBDEV_VF_NUM_MAPS) { 1267 printf( 1268 "INFO: RTE_BBDEV_TURBO_MAP_DEC was not set in vector file and num_maps will be set to 0\n"); 1269 turbo_dec->num_maps = 0; 1270 } 1271 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1272 printf( 1273 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1274 return 0; 1275 } 1276 1277 /* checks LDPC decoder parameters */ 1278 static int 1279 check_ldpc_decoder(struct test_bbdev_vector *vector) 1280 { 1281 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 1282 const int mask = vector->mask; 1283 1284 if (check_ldpc_decoder_segments(vector) < 0) 1285 return -1; 1286 1287 /* 1288 * if (check_ldpc_decoder_llr_spec(vector) < 0) 1289 * return -1; 1290 * 1291 * if (check_ldpc_decoder_op_flags(vector) < 0) 1292 * return -1; 1293 */ 1294 1295 /* Check which params were set */ 1296 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1297 printf( 1298 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n"); 1299 ldpc_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK; 1300 } 1301 if (ldpc_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1302 if (!(mask & TEST_BBDEV_VF_EA)) 1303 printf( 1304 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1305 if (!(mask & TEST_BBDEV_VF_EB)) 1306 printf( 1307 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1308 if (!(mask & TEST_BBDEV_VF_C)) { 1309 printf( 1310 "WARNING: c was not specified in vector file and will be set to 1\n"); 1311 ldpc_dec->tb_params.c = 1; 1312 } 1313 if (!(mask & TEST_BBDEV_VF_CAB)) 1314 printf( 1315 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1316 if (!(mask & TEST_BBDEV_VF_R)) 1317 printf( 1318 "WARNING: r was not specified in vector file and will be set to 0\n"); 1319 } else { 1320 if (!(mask & TEST_BBDEV_VF_E)) 1321 printf( 1322 "WARNING: e was not specified in vector file and will be set to 0\n"); 1323 } 1324 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1325 printf( 1326 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1327 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT)) 1328 printf( 1329 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n"); 1330 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1331 printf( 1332 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1333 } 1334 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1335 printf( 1336 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1337 return 0; 1338 } 1339 1340 /* Checks fft parameters. */ 1341 static int 1342 check_fft(struct test_bbdev_vector *vector) 1343 { 1344 const int mask = vector->mask; 1345 1346 if (check_fft_segments(vector) < 0) 1347 return -1; 1348 1349 /* Check which params were set. */ 1350 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1351 printf( 1352 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1353 } 1354 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1355 printf( 1356 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1357 return 0; 1358 } 1359 1360 /* checks encoder parameters */ 1361 static int 1362 check_encoder(struct test_bbdev_vector *vector) 1363 { 1364 unsigned char i; 1365 const int mask = vector->mask; 1366 1367 if (vector->entries[DATA_INPUT].nb_segments == 0) 1368 return -1; 1369 1370 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1371 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1372 return -1; 1373 1374 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1375 return -1; 1376 1377 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1378 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1379 return -1; 1380 1381 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1382 printf( 1383 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n"); 1384 vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK; 1385 } 1386 if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1387 if (!(mask & TEST_BBDEV_VF_EA) && (vector->turbo_enc.op_flags & 1388 RTE_BBDEV_TURBO_RATE_MATCH)) 1389 printf( 1390 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1391 if (!(mask & TEST_BBDEV_VF_EB) && (vector->turbo_enc.op_flags & 1392 RTE_BBDEV_TURBO_RATE_MATCH)) 1393 printf( 1394 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1395 if (!(mask & TEST_BBDEV_VF_K_NEG)) 1396 printf( 1397 "WARNING: k_neg was not specified in vector file and will be set to 0\n"); 1398 if (!(mask & TEST_BBDEV_VF_K_POS)) 1399 printf( 1400 "WARNING: k_pos was not specified in vector file and will be set to 0\n"); 1401 if (!(mask & TEST_BBDEV_VF_C_NEG)) 1402 printf( 1403 "WARNING: c_neg was not specified in vector file and will be set to 0\n"); 1404 if (!(mask & TEST_BBDEV_VF_C)) { 1405 printf( 1406 "WARNING: c was not specified in vector file and will be set to 1\n"); 1407 vector->turbo_enc.tb_params.c = 1; 1408 } 1409 if (!(mask & TEST_BBDEV_VF_CAB) && (vector->turbo_enc.op_flags & 1410 RTE_BBDEV_TURBO_RATE_MATCH)) 1411 printf( 1412 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1413 if (!(mask & TEST_BBDEV_VF_NCB_NEG)) 1414 printf( 1415 "WARNING: ncb_neg was not specified in vector file and will be set to 0\n"); 1416 if (!(mask & TEST_BBDEV_VF_NCB_POS)) 1417 printf( 1418 "WARNING: ncb_pos was not specified in vector file and will be set to 0\n"); 1419 if (!(mask & TEST_BBDEV_VF_R)) 1420 printf( 1421 "WARNING: r was not specified in vector file and will be set to 0\n"); 1422 } else { 1423 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags & 1424 RTE_BBDEV_TURBO_RATE_MATCH)) 1425 printf( 1426 "WARNING: e was not specified in vector file and will be set to 0\n"); 1427 if (!(mask & TEST_BBDEV_VF_K)) 1428 printf( 1429 "WARNING: k was not specified in vector file and will be set to 0\n"); 1430 if (!(mask & TEST_BBDEV_VF_NCB)) 1431 printf( 1432 "WARNING: ncb was not specified in vector file and will be set to 0\n"); 1433 } 1434 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1435 printf( 1436 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1437 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) 1438 printf( 1439 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n"); 1440 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1441 printf( 1442 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1443 1444 return 0; 1445 } 1446 1447 1448 /* checks encoder parameters */ 1449 static int 1450 check_ldpc_encoder(struct test_bbdev_vector *vector) 1451 { 1452 unsigned char i; 1453 const int mask = vector->mask; 1454 1455 if (vector->entries[DATA_INPUT].nb_segments == 0) 1456 return -1; 1457 1458 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1459 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1460 return -1; 1461 1462 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1463 return -1; 1464 1465 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1466 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1467 return -1; 1468 1469 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1470 printf( 1471 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n"); 1472 vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK; 1473 } 1474 if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1475 } else { 1476 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags & 1477 RTE_BBDEV_TURBO_RATE_MATCH)) 1478 printf( 1479 "WARNING: e was not specified in vector file and will be set to 0\n"); 1480 if (!(mask & TEST_BBDEV_VF_NCB)) 1481 printf( 1482 "WARNING: ncb was not specified in vector file and will be set to 0\n"); 1483 } 1484 if (!(mask & TEST_BBDEV_VF_BG)) 1485 printf( 1486 "WARNING: BG was not specified in vector file and will be set to 0\n"); 1487 if (!(mask & TEST_BBDEV_VF_ZC)) 1488 printf( 1489 "WARNING: Zc was not specified in vector file and will be set to 0\n"); 1490 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1491 printf( 1492 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1493 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) 1494 printf( 1495 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n"); 1496 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1497 printf( 1498 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1499 1500 return 0; 1501 } 1502 1503 static int 1504 bbdev_check_vector(struct test_bbdev_vector *vector) 1505 { 1506 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) { 1507 if (check_decoder(vector) == -1) 1508 return -1; 1509 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) { 1510 if (check_encoder(vector) == -1) 1511 return -1; 1512 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) { 1513 if (check_ldpc_encoder(vector) == -1) 1514 return -1; 1515 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { 1516 if (check_ldpc_decoder(vector) == -1) 1517 return -1; 1518 } else if (vector->op_type == RTE_BBDEV_OP_FFT) { 1519 if (check_fft(vector) == -1) 1520 return -1; 1521 } else if (vector->op_type != RTE_BBDEV_OP_NONE) { 1522 printf("Vector was not filled\n"); 1523 return -1; 1524 } 1525 1526 return 0; 1527 } 1528 1529 int 1530 test_bbdev_vector_read(const char *filename, 1531 struct test_bbdev_vector *vector) 1532 { 1533 int ret = 0; 1534 size_t len = 0; 1535 1536 FILE *fp = NULL; 1537 char *line = NULL; 1538 char *entry = NULL; 1539 1540 fp = fopen(filename, "r"); 1541 if (fp == NULL) { 1542 printf("File %s does not exist\n", filename); 1543 return -1; 1544 } 1545 1546 while (getline(&line, &len, fp) != -1) { 1547 1548 /* ignore comments and new lines */ 1549 if (line[0] == '#' || line[0] == '/' || line[0] == '\n' 1550 || line[0] == '\r') 1551 continue; 1552 1553 trim_space(line); 1554 1555 /* buffer for multiline */ 1556 entry = realloc(entry, strlen(line) + 1); 1557 if (entry == NULL) { 1558 printf("Fail to realloc %zu bytes\n", strlen(line) + 1); 1559 ret = -ENOMEM; 1560 goto exit; 1561 } 1562 1563 strcpy(entry, line); 1564 1565 /* check if entry ends with , or = */ 1566 if (entry[strlen(entry) - 1] == ',' 1567 || entry[strlen(entry) - 1] == '=') { 1568 while (getline(&line, &len, fp) != -1) { 1569 trim_space(line); 1570 1571 /* extend entry about length of new line */ 1572 char *entry_extended = realloc(entry, 1573 strlen(line) + 1574 strlen(entry) + 1); 1575 1576 if (entry_extended == NULL) { 1577 printf("Fail to allocate %zu bytes\n", 1578 strlen(line) + 1579 strlen(entry) + 1); 1580 ret = -ENOMEM; 1581 goto exit; 1582 } 1583 1584 entry = entry_extended; 1585 /* entry has been allocated accordingly */ 1586 strcpy(&entry[strlen(entry)], line); 1587 1588 if (entry[strlen(entry) - 1] != ',') 1589 break; 1590 } 1591 } 1592 ret = parse_entry(entry, vector); 1593 if (ret != 0) { 1594 printf("An error occurred while parsing!\n"); 1595 goto exit; 1596 } 1597 } 1598 ret = bbdev_check_vector(vector); 1599 if (ret != 0) 1600 printf("An error occurred while checking!\n"); 1601 1602 exit: 1603 fclose(fp); 1604 free(line); 1605 free(entry); 1606 1607 return ret; 1608 } 1609