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_max")) { 536 vector->mask |= TEST_BBDEV_VF_ITER_MAX; 537 turbo_dec->iter_max = (uint8_t) strtoul(token, &err, 0); 538 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 539 } else if (!strcmp(key_token, "iter_min")) { 540 vector->mask |= TEST_BBDEV_VF_ITER_MIN; 541 turbo_dec->iter_min = (uint8_t) strtoul(token, &err, 0); 542 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 543 } else if (!strcmp(key_token, "expected_iter_count")) { 544 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT; 545 turbo_dec->iter_count = (uint8_t) strtoul(token, &err, 0); 546 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 547 } else if (!strcmp(key_token, "ext_scale")) { 548 vector->mask |= TEST_BBDEV_VF_EXT_SCALE; 549 turbo_dec->ext_scale = (uint8_t) strtoul(token, &err, 0); 550 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 551 } else if (!strcmp(key_token, "num_maps")) { 552 vector->mask |= TEST_BBDEV_VF_NUM_MAPS; 553 turbo_dec->num_maps = (uint8_t) strtoul(token, &err, 0); 554 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 555 } else if (!strcmp(key_token, "r")) { 556 vector->mask |= TEST_BBDEV_VF_R; 557 turbo_dec->tb_params.r = (uint8_t)strtoul(token, &err, 0); 558 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 559 } else if (!strcmp(key_token, "code_block_mode")) { 560 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 561 turbo_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0); 562 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 563 } else if (!strcmp(key_token, "op_flags")) { 564 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 565 ret = parse_turbo_flags(token, &op_flags, 566 vector->op_type); 567 if (!ret) 568 turbo_dec->op_flags = op_flags; 569 } else if (!strcmp(key_token, "expected_status")) { 570 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 571 ret = parse_expected_status(token, &status, vector->op_type); 572 if (!ret) 573 vector->expected_status = status; 574 } else { 575 printf("Not valid dec key: '%s'\n", key_token); 576 return -1; 577 } 578 579 if (ret != 0) { 580 printf("Failed with convert '%s\t%s'\n", key_token, token); 581 return -1; 582 } 583 584 return 0; 585 } 586 587 /* parses turbo encoder parameters and assigns to global variable */ 588 static int 589 parse_encoder_params(const char *key_token, char *token, 590 struct test_bbdev_vector *vector) 591 { 592 int ret = 0, status = 0; 593 uint32_t op_flags = 0; 594 char *err = NULL; 595 596 597 struct rte_bbdev_op_turbo_enc *turbo_enc = &vector->turbo_enc; 598 599 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 600 ret = parse_data_entry(key_token, token, vector, 601 DATA_INPUT, op_data_prefixes[DATA_INPUT]); 602 else if (starts_with(key_token, "output")) 603 ret = parse_data_entry(key_token, token, vector, 604 DATA_HARD_OUTPUT, "output"); 605 else if (!strcmp(key_token, "e")) { 606 vector->mask |= TEST_BBDEV_VF_E; 607 turbo_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0); 608 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 609 } else if (!strcmp(key_token, "ea")) { 610 vector->mask |= TEST_BBDEV_VF_EA; 611 turbo_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 612 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 613 } else if (!strcmp(key_token, "eb")) { 614 vector->mask |= TEST_BBDEV_VF_EB; 615 turbo_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 616 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 617 } else if (!strcmp(key_token, "k")) { 618 vector->mask |= TEST_BBDEV_VF_K; 619 turbo_enc->cb_params.k = (uint16_t) strtoul(token, &err, 0); 620 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 621 } else if (!strcmp(key_token, "k_neg")) { 622 vector->mask |= TEST_BBDEV_VF_K_NEG; 623 turbo_enc->tb_params.k_neg = (uint16_t) strtoul(token, &err, 0); 624 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 625 } else if (!strcmp(key_token, "k_pos")) { 626 vector->mask |= TEST_BBDEV_VF_K_POS; 627 turbo_enc->tb_params.k_pos = (uint16_t) strtoul(token, &err, 0); 628 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 629 } else if (!strcmp(key_token, "c_neg")) { 630 vector->mask |= TEST_BBDEV_VF_C_NEG; 631 turbo_enc->tb_params.c_neg = (uint8_t) strtoul(token, &err, 0); 632 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 633 } else if (!strcmp(key_token, "c")) { 634 vector->mask |= TEST_BBDEV_VF_C; 635 turbo_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0); 636 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 637 } else if (!strcmp(key_token, "cab")) { 638 vector->mask |= TEST_BBDEV_VF_CAB; 639 turbo_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 640 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 641 } else if (!strcmp(key_token, "rv_index")) { 642 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 643 turbo_enc->rv_index = (uint8_t) strtoul(token, &err, 0); 644 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 645 } else if (!strcmp(key_token, "ncb")) { 646 vector->mask |= TEST_BBDEV_VF_NCB; 647 turbo_enc->cb_params.ncb = (uint16_t) strtoul(token, &err, 0); 648 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 649 } else if (!strcmp(key_token, "ncb_neg")) { 650 vector->mask |= TEST_BBDEV_VF_NCB_NEG; 651 turbo_enc->tb_params.ncb_neg = 652 (uint16_t) strtoul(token, &err, 0); 653 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 654 } else if (!strcmp(key_token, "ncb_pos")) { 655 vector->mask |= TEST_BBDEV_VF_NCB_POS; 656 turbo_enc->tb_params.ncb_pos = 657 (uint16_t) strtoul(token, &err, 0); 658 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 659 } else if (!strcmp(key_token, "r")) { 660 vector->mask |= TEST_BBDEV_VF_R; 661 turbo_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0); 662 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 663 } else if (!strcmp(key_token, "code_block_mode")) { 664 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 665 turbo_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0); 666 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 667 } else if (!strcmp(key_token, "op_flags")) { 668 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 669 ret = parse_turbo_flags(token, &op_flags, 670 vector->op_type); 671 if (!ret) 672 turbo_enc->op_flags = op_flags; 673 } else if (!strcmp(key_token, "expected_status")) { 674 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 675 ret = parse_expected_status(token, &status, vector->op_type); 676 if (!ret) 677 vector->expected_status = status; 678 } else { 679 printf("Not valid enc key: '%s'\n", key_token); 680 return -1; 681 } 682 683 if (ret != 0) { 684 printf("Failed with convert '%s\t%s'\n", key_token, token); 685 return -1; 686 } 687 688 return 0; 689 } 690 691 692 /* parses LDPC encoder parameters and assigns to global variable */ 693 static int 694 parse_ldpc_encoder_params(const char *key_token, char *token, 695 struct test_bbdev_vector *vector) 696 { 697 int ret = 0, status = 0; 698 uint32_t op_flags = 0; 699 char *err = NULL; 700 701 struct rte_bbdev_op_ldpc_enc *ldpc_enc = &vector->ldpc_enc; 702 703 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 704 ret = parse_data_entry(key_token, token, vector, 705 DATA_INPUT, 706 op_data_prefixes[DATA_INPUT]); 707 else if (starts_with(key_token, "output")) 708 ret = parse_data_entry(key_token, token, vector, 709 DATA_HARD_OUTPUT, 710 "output"); 711 else if (!strcmp(key_token, "e")) { 712 vector->mask |= TEST_BBDEV_VF_E; 713 ldpc_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0); 714 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 715 } else if (!strcmp(key_token, "ea")) { 716 vector->mask |= TEST_BBDEV_VF_EA; 717 ldpc_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 718 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 719 } else if (!strcmp(key_token, "eb")) { 720 vector->mask |= TEST_BBDEV_VF_EB; 721 ldpc_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 722 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 723 } else if (!strcmp(key_token, "c")) { 724 vector->mask |= TEST_BBDEV_VF_C; 725 ldpc_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0); 726 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 727 } else if (!strcmp(key_token, "cab")) { 728 vector->mask |= TEST_BBDEV_VF_CAB; 729 ldpc_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 730 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 731 } else if (!strcmp(key_token, "rv_index")) { 732 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 733 ldpc_enc->rv_index = (uint8_t) strtoul(token, &err, 0); 734 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 735 } else if (!strcmp(key_token, "n_cb")) { 736 vector->mask |= TEST_BBDEV_VF_NCB; 737 ldpc_enc->n_cb = (uint16_t) strtoul(token, &err, 0); 738 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 739 } else if (!strcmp(key_token, "r")) { 740 vector->mask |= TEST_BBDEV_VF_R; 741 ldpc_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0); 742 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 743 } else if (!strcmp(key_token, "q_m")) { 744 vector->mask |= TEST_BBDEV_VF_QM; 745 ldpc_enc->q_m = (uint8_t) strtoul(token, &err, 0); 746 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 747 } else if (!strcmp(key_token, "basegraph")) { 748 vector->mask |= TEST_BBDEV_VF_BG; 749 ldpc_enc->basegraph = (uint8_t) strtoul(token, &err, 0); 750 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 751 } else if (!strcmp(key_token, "z_c")) { 752 vector->mask |= TEST_BBDEV_VF_ZC; 753 ldpc_enc->z_c = (uint16_t) strtoul(token, &err, 0); 754 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 755 } else if (!strcmp(key_token, "n_filler")) { 756 vector->mask |= TEST_BBDEV_VF_F; 757 ldpc_enc->n_filler = (uint16_t) strtoul(token, &err, 0); 758 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 759 } else if (!strcmp(key_token, "code_block_mode")) { 760 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 761 ldpc_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0); 762 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 763 } else if (!strcmp(key_token, "op_flags")) { 764 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 765 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 766 if (!ret) 767 ldpc_enc->op_flags = op_flags; 768 } else if (!strcmp(key_token, "expected_status")) { 769 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 770 ret = parse_expected_status(token, &status, vector->op_type); 771 if (!ret) 772 vector->expected_status = status; 773 } else { 774 printf("Not valid ldpc enc key: '%s'\n", key_token); 775 return -1; 776 } 777 778 if (ret != 0) { 779 printf("Failed with convert '%s\t%s'\n", key_token, token); 780 return -1; 781 } 782 783 return 0; 784 } 785 786 /* parses LDPC decoder parameters and assigns to global variable */ 787 static int 788 parse_ldpc_decoder_params(const char *key_token, char *token, 789 struct test_bbdev_vector *vector) 790 { 791 int ret = 0, status = 0; 792 uint32_t op_flags = 0; 793 char *err = NULL; 794 795 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 796 797 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 798 ret = parse_data_entry(key_token, token, vector, 799 DATA_INPUT, 800 op_data_prefixes[DATA_INPUT]); 801 else if (starts_with(key_token, "output")) 802 ret = parse_data_entry(key_token, token, vector, 803 DATA_HARD_OUTPUT, 804 "output"); 805 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_INPUT])) 806 ret = parse_data_entry(key_token, token, vector, 807 DATA_HARQ_INPUT, 808 op_data_prefixes[DATA_HARQ_INPUT]); 809 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_OUTPUT])) 810 ret = parse_data_entry(key_token, token, vector, 811 DATA_HARQ_OUTPUT, 812 op_data_prefixes[DATA_HARQ_OUTPUT]); 813 else if (!strcmp(key_token, "e")) { 814 vector->mask |= TEST_BBDEV_VF_E; 815 ldpc_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0); 816 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 817 } else if (!strcmp(key_token, "ea")) { 818 vector->mask |= TEST_BBDEV_VF_EA; 819 ldpc_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 820 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 821 } else if (!strcmp(key_token, "eb")) { 822 vector->mask |= TEST_BBDEV_VF_EB; 823 ldpc_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 824 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 825 } else if (!strcmp(key_token, "c")) { 826 vector->mask |= TEST_BBDEV_VF_C; 827 ldpc_dec->tb_params.c = (uint8_t) strtoul(token, &err, 0); 828 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 829 } else if (!strcmp(key_token, "cab")) { 830 vector->mask |= TEST_BBDEV_VF_CAB; 831 ldpc_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 832 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 833 } else if (!strcmp(key_token, "rv_index")) { 834 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 835 ldpc_dec->rv_index = (uint8_t) strtoul(token, &err, 0); 836 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 837 } else if (!strcmp(key_token, "n_cb")) { 838 vector->mask |= TEST_BBDEV_VF_NCB; 839 ldpc_dec->n_cb = (uint16_t) strtoul(token, &err, 0); 840 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 841 } else if (!strcmp(key_token, "r")) { 842 vector->mask |= TEST_BBDEV_VF_R; 843 ldpc_dec->tb_params.r = (uint8_t) strtoul(token, &err, 0); 844 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 845 } else if (!strcmp(key_token, "q_m")) { 846 vector->mask |= TEST_BBDEV_VF_QM; 847 ldpc_dec->q_m = (uint8_t) strtoul(token, &err, 0); 848 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 849 } else if (!strcmp(key_token, "basegraph")) { 850 vector->mask |= TEST_BBDEV_VF_BG; 851 ldpc_dec->basegraph = (uint8_t) strtoul(token, &err, 0); 852 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 853 } else if (!strcmp(key_token, "z_c")) { 854 vector->mask |= TEST_BBDEV_VF_ZC; 855 ldpc_dec->z_c = (uint16_t) strtoul(token, &err, 0); 856 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 857 } else if (!strcmp(key_token, "n_filler")) { 858 vector->mask |= TEST_BBDEV_VF_F; 859 ldpc_dec->n_filler = (uint16_t) strtoul(token, &err, 0); 860 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 861 } else if (!strcmp(key_token, "expected_iter_count")) { 862 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT; 863 ldpc_dec->iter_count = (uint8_t) strtoul(token, &err, 0); 864 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 865 } else if (!strcmp(key_token, "iter_max")) { 866 vector->mask |= TEST_BBDEV_VF_ITER_MAX; 867 ldpc_dec->iter_max = (uint8_t) strtoul(token, &err, 0); 868 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 869 } else if (!strcmp(key_token, "code_block_mode")) { 870 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 871 ldpc_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0); 872 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 873 } else if (!strcmp(key_token, "op_flags")) { 874 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 875 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 876 if (!ret) 877 ldpc_dec->op_flags = op_flags; 878 } else if (!strcmp(key_token, "expected_status")) { 879 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 880 ret = parse_expected_status(token, &status, vector->op_type); 881 if (!ret) 882 vector->expected_status = status; 883 } else { 884 printf("Not valid ldpc dec key: '%s'\n", key_token); 885 return -1; 886 } 887 888 if (ret != 0) { 889 printf("Failed with convert '%s\t%s'\n", key_token, token); 890 return -1; 891 } 892 893 return 0; 894 } 895 896 897 /* Parse FFT parameters and assigns to global variable. */ 898 static int 899 parse_fft_params(const char *key_token, char *token, 900 struct test_bbdev_vector *vector) 901 { 902 int ret = 0, status = 0, i, shift; 903 uint32_t op_flags = 0; 904 char *tok, *err = NULL; 905 906 struct rte_bbdev_op_fft *fft = &vector->fft; 907 908 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) { 909 ret = parse_data_entry(key_token, token, vector, 910 DATA_INPUT, 911 op_data_prefixes[DATA_INPUT]); 912 } else if (starts_with(key_token, "output")) { 913 ret = parse_data_entry(key_token, token, vector, 914 DATA_HARD_OUTPUT, 915 "output"); 916 } else if (starts_with(key_token, "power_output")) { 917 ret = parse_data_entry(key_token, token, vector, 918 DATA_SOFT_OUTPUT, 919 "power_output"); 920 } else if (!strcmp(key_token, "in_sequence_size")) { 921 fft->input_sequence_size = (uint32_t) strtoul(token, &err, 0); 922 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 923 } else if (!strcmp(key_token, "in_leading_padding")) { 924 fft->input_leading_padding = (uint32_t) strtoul(token, &err, 0); 925 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 926 } else if (!strcmp(key_token, "out_sequence_size")) { 927 fft->output_sequence_size = (uint32_t) strtoul(token, &err, 0); 928 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 929 } else if (!strcmp(key_token, "out_leading_depadding")) { 930 fft->output_leading_depadding = (uint32_t) strtoul(token, &err, 0); 931 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 932 } else if (!strcmp(key_token, "window_index")) { 933 tok = strtok(token, VALUE_DELIMITER); 934 if (tok == NULL) 935 return -1; 936 for (i = 0; i < FFT_WIN_SIZE; i++) { 937 shift = (i % 2) ? 4 : 0; 938 fft->window_index[i / 2] |= (uint32_t) strtoul(tok, &err, 0) 939 << shift; 940 if (i < (FFT_WIN_SIZE - 1)) { 941 tok = strtok(NULL, VALUE_DELIMITER); 942 if (tok == NULL) 943 return -1; 944 } 945 } 946 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 947 } else if (!strcmp(key_token, "cs_bitmap")) { 948 fft->cs_bitmap = (uint32_t) strtoul(token, &err, 0); 949 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 950 } else if (!strcmp(key_token, "num_antennas_log2")) { 951 fft->num_antennas_log2 = (uint32_t) strtoul(token, &err, 0); 952 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 953 } else if (!strcmp(key_token, "ifft_log2")) { 954 fft->idft_log2 = (uint32_t) strtoul(token, &err, 0); 955 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 956 } else if (!strcmp(key_token, "fft_log2")) { 957 fft->dft_log2 = (uint32_t) strtoul(token, &err, 0); 958 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 959 } else if (!strcmp(key_token, "cs_time_adjustment")) { 960 fft->cs_time_adjustment = (uint32_t) strtoul(token, &err, 0); 961 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 962 } else if (!strcmp(key_token, "ifft_shift")) { 963 fft->idft_shift = (uint32_t) strtoul(token, &err, 0); 964 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 965 } else if (!strcmp(key_token, "fft_shift")) { 966 fft->dft_shift = (uint32_t) strtoul(token, &err, 0); 967 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 968 } else if (!strcmp(key_token, "ncs_reciprocal")) { 969 fft->ncs_reciprocal = (uint32_t) strtoul(token, &err, 0); 970 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 971 } else if (!strcmp(key_token, "power_shift")) { 972 fft->power_shift = (uint32_t) strtoul(token, &err, 0); 973 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 974 } else if (!strcmp(key_token, "fp16_exponent_adjust")) { 975 fft->fp16_exp_adjust = (uint32_t) strtoul(token, &err, 0); 976 printf("%d\n", fft->fp16_exp_adjust); 977 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 978 } else if (!strcmp(key_token, "op_flags")) { 979 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 980 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 981 if (!ret) 982 fft->op_flags = op_flags; 983 } else if (!strcmp(key_token, "expected_status")) { 984 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 985 ret = parse_expected_status(token, &status, vector->op_type); 986 if (!ret) 987 vector->expected_status = status; 988 } else { 989 printf("Not valid fft key: '%s'\n", key_token); 990 return -1; 991 } 992 993 if (ret != 0) { 994 printf("Failed with convert '%s\t%s'\n", key_token, token); 995 return -1; 996 } 997 998 return 0; 999 } 1000 1001 /* checks the type of key and assigns data */ 1002 static int 1003 parse_entry(char *entry, struct test_bbdev_vector *vector) 1004 { 1005 int ret = 0; 1006 char *token, *key_token; 1007 enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_NONE; 1008 1009 if (entry == NULL) { 1010 printf("Expected entry value\n"); 1011 return -1; 1012 } 1013 1014 /* get key */ 1015 token = strtok(entry, ENTRY_DELIMITER); 1016 key_token = token; 1017 /* get values for key */ 1018 token = strtok(NULL, ENTRY_DELIMITER); 1019 1020 if (key_token == NULL || token == NULL) { 1021 printf("Expected 'key = values' but was '%.40s'..\n", entry); 1022 return -1; 1023 } 1024 trim_space(key_token); 1025 1026 /* first key_token has to specify type of operation */ 1027 if (vector->op_type == RTE_BBDEV_OP_NONE) { 1028 if (!strcmp(key_token, "op_type")) { 1029 ret = op_turbo_type_strtol(token, &op_type); 1030 if (!ret) 1031 vector->op_type = op_type; 1032 return (!ret) ? 0 : -1; 1033 } 1034 printf("First key_token (%s) does not specify op_type\n", 1035 key_token); 1036 return -1; 1037 } 1038 1039 /* compare keys */ 1040 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) { 1041 if (parse_decoder_params(key_token, token, vector) == -1) 1042 return -1; 1043 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) { 1044 if (parse_encoder_params(key_token, token, vector) == -1) 1045 return -1; 1046 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) { 1047 if (parse_ldpc_encoder_params(key_token, token, vector) == -1) 1048 return -1; 1049 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { 1050 if (parse_ldpc_decoder_params(key_token, token, vector) == -1) 1051 return -1; 1052 } else if (vector->op_type == RTE_BBDEV_OP_FFT) { 1053 if (parse_fft_params(key_token, token, vector) == -1) 1054 return -1; 1055 } 1056 1057 return 0; 1058 } 1059 1060 static int 1061 check_decoder_segments(struct test_bbdev_vector *vector) 1062 { 1063 unsigned char i; 1064 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1065 1066 if (vector->entries[DATA_INPUT].nb_segments == 0) 1067 return -1; 1068 1069 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1070 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1071 return -1; 1072 1073 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1074 return -1; 1075 1076 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; 1077 i++) 1078 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1079 return -1; 1080 1081 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT) && 1082 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0)) 1083 return -1; 1084 1085 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; 1086 i++) 1087 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL) 1088 return -1; 1089 1090 return 0; 1091 } 1092 1093 static int 1094 check_ldpc_decoder_segments(struct test_bbdev_vector *vector) 1095 { 1096 unsigned char i; 1097 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 1098 1099 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1100 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1101 return -1; 1102 1103 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1104 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1105 return -1; 1106 1107 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_SOFT_OUT_ENABLE) && 1108 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0)) 1109 return -1; 1110 1111 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; i++) 1112 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL) 1113 return -1; 1114 1115 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE) && 1116 (vector->entries[DATA_HARQ_OUTPUT].nb_segments == 0)) 1117 return -1; 1118 1119 for (i = 0; i < vector->entries[DATA_HARQ_OUTPUT].nb_segments; i++) 1120 if (vector->entries[DATA_HARQ_OUTPUT].segments[i].addr == NULL) 1121 return -1; 1122 1123 return 0; 1124 } 1125 1126 static int 1127 check_fft_segments(struct test_bbdev_vector *vector) 1128 { 1129 unsigned char i; 1130 1131 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1132 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1133 return -1; 1134 1135 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1136 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1137 return -1; 1138 return 0; 1139 } 1140 1141 static int 1142 check_decoder_llr_spec(struct test_bbdev_vector *vector) 1143 { 1144 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1145 1146 /* Check input LLR sign formalism specification */ 1147 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) && 1148 (turbo_dec->op_flags & 1149 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) { 1150 printf( 1151 "Both positive and negative LLR input flags were set!\n"); 1152 return -1; 1153 } 1154 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) && 1155 !(turbo_dec->op_flags & 1156 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) { 1157 printf( 1158 "INFO: input LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n"); 1159 turbo_dec->op_flags |= RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN; 1160 } 1161 1162 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT)) 1163 return 0; 1164 1165 /* Check output LLR sign formalism specification */ 1166 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) && 1167 (turbo_dec->op_flags & 1168 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) { 1169 printf( 1170 "Both positive and negative LLR output flags were set!\n"); 1171 return -1; 1172 } 1173 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) && 1174 !(turbo_dec->op_flags & 1175 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) { 1176 printf( 1177 "INFO: soft output LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n"); 1178 turbo_dec->op_flags |= 1179 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT; 1180 } 1181 1182 return 0; 1183 } 1184 1185 static int 1186 check_decoder_op_flags(struct test_bbdev_vector *vector) 1187 { 1188 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1189 1190 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP) && 1191 !(turbo_dec->op_flags & RTE_BBDEV_TURBO_CRC_TYPE_24B)) { 1192 printf( 1193 "WARNING: RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP flag is missing RTE_BBDEV_TURBO_CRC_TYPE_24B\n"); 1194 return -1; 1195 } 1196 1197 return 0; 1198 } 1199 1200 /* checks decoder parameters */ 1201 static int 1202 check_decoder(struct test_bbdev_vector *vector) 1203 { 1204 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1205 const int mask = vector->mask; 1206 1207 if (check_decoder_segments(vector) < 0) 1208 return -1; 1209 1210 if (check_decoder_llr_spec(vector) < 0) 1211 return -1; 1212 1213 if (check_decoder_op_flags(vector) < 0) 1214 return -1; 1215 1216 /* Check which params were set */ 1217 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1218 printf( 1219 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n"); 1220 turbo_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK; 1221 } 1222 if (turbo_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1223 if (!(mask & TEST_BBDEV_VF_EA)) 1224 printf( 1225 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1226 if (!(mask & TEST_BBDEV_VF_EB)) 1227 printf( 1228 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1229 if (!(mask & TEST_BBDEV_VF_K_NEG)) 1230 printf( 1231 "WARNING: k_neg was not specified in vector file and will be set to 0\n"); 1232 if (!(mask & TEST_BBDEV_VF_K_POS)) 1233 printf( 1234 "WARNING: k_pos was not specified in vector file and will be set to 0\n"); 1235 if (!(mask & TEST_BBDEV_VF_C_NEG)) 1236 printf( 1237 "WARNING: c_neg was not specified in vector file and will be set to 0\n"); 1238 if (!(mask & TEST_BBDEV_VF_C)) { 1239 printf( 1240 "WARNING: c was not specified in vector file and will be set to 1\n"); 1241 turbo_dec->tb_params.c = 1; 1242 } 1243 if (!(mask & TEST_BBDEV_VF_CAB)) 1244 printf( 1245 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1246 if (!(mask & TEST_BBDEV_VF_R)) 1247 printf( 1248 "WARNING: r was not specified in vector file and will be set to 0\n"); 1249 } else { 1250 if (!(mask & TEST_BBDEV_VF_E)) 1251 printf( 1252 "WARNING: e was not specified in vector file and will be set to 0\n"); 1253 if (!(mask & TEST_BBDEV_VF_K)) 1254 printf( 1255 "WARNING: k was not specified in vector file and will be set to 0\n"); 1256 } 1257 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1258 printf( 1259 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1260 if (!(mask & TEST_BBDEV_VF_ITER_MIN)) 1261 printf( 1262 "WARNING: iter_min was not specified in vector file and will be set to 0\n"); 1263 if (!(mask & TEST_BBDEV_VF_ITER_MAX)) 1264 printf( 1265 "WARNING: iter_max was not specified in vector file and will be set to 0\n"); 1266 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT)) 1267 printf( 1268 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n"); 1269 if (!(mask & TEST_BBDEV_VF_EXT_SCALE)) 1270 printf( 1271 "WARNING: ext_scale was not specified in vector file and will be set to 0\n"); 1272 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1273 printf( 1274 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1275 turbo_dec->num_maps = 0; 1276 } else if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_MAP_DEC) && 1277 mask & TEST_BBDEV_VF_NUM_MAPS) { 1278 printf( 1279 "INFO: RTE_BBDEV_TURBO_MAP_DEC was not set in vector file and num_maps will be set to 0\n"); 1280 turbo_dec->num_maps = 0; 1281 } 1282 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1283 printf( 1284 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1285 return 0; 1286 } 1287 1288 /* checks LDPC decoder parameters */ 1289 static int 1290 check_ldpc_decoder(struct test_bbdev_vector *vector) 1291 { 1292 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 1293 const int mask = vector->mask; 1294 1295 if (check_ldpc_decoder_segments(vector) < 0) 1296 return -1; 1297 1298 /* 1299 * if (check_ldpc_decoder_llr_spec(vector) < 0) 1300 * return -1; 1301 * 1302 * if (check_ldpc_decoder_op_flags(vector) < 0) 1303 * return -1; 1304 */ 1305 1306 /* Check which params were set */ 1307 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1308 printf( 1309 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n"); 1310 ldpc_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK; 1311 } 1312 if (ldpc_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1313 if (!(mask & TEST_BBDEV_VF_EA)) 1314 printf( 1315 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1316 if (!(mask & TEST_BBDEV_VF_EB)) 1317 printf( 1318 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1319 if (!(mask & TEST_BBDEV_VF_C)) { 1320 printf( 1321 "WARNING: c was not specified in vector file and will be set to 1\n"); 1322 ldpc_dec->tb_params.c = 1; 1323 } 1324 if (!(mask & TEST_BBDEV_VF_CAB)) 1325 printf( 1326 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1327 if (!(mask & TEST_BBDEV_VF_R)) 1328 printf( 1329 "WARNING: r was not specified in vector file and will be set to 0\n"); 1330 } else { 1331 if (!(mask & TEST_BBDEV_VF_E)) 1332 printf( 1333 "WARNING: e was not specified in vector file and will be set to 0\n"); 1334 } 1335 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1336 printf( 1337 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1338 if (!(mask & TEST_BBDEV_VF_ITER_MAX)) 1339 printf( 1340 "WARNING: iter_max was not specified in vector file and will be set to 0\n"); 1341 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT)) 1342 printf( 1343 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n"); 1344 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1345 printf( 1346 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1347 } 1348 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1349 printf( 1350 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1351 return 0; 1352 } 1353 1354 /* Checks fft parameters. */ 1355 static int 1356 check_fft(struct test_bbdev_vector *vector) 1357 { 1358 const int mask = vector->mask; 1359 1360 if (check_fft_segments(vector) < 0) 1361 return -1; 1362 1363 /* Check which params were set. */ 1364 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1365 printf( 1366 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1367 } 1368 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1369 printf( 1370 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1371 return 0; 1372 } 1373 1374 /* checks encoder parameters */ 1375 static int 1376 check_encoder(struct test_bbdev_vector *vector) 1377 { 1378 unsigned char i; 1379 const int mask = vector->mask; 1380 1381 if (vector->entries[DATA_INPUT].nb_segments == 0) 1382 return -1; 1383 1384 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1385 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1386 return -1; 1387 1388 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1389 return -1; 1390 1391 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1392 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1393 return -1; 1394 1395 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1396 printf( 1397 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n"); 1398 vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK; 1399 } 1400 if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1401 if (!(mask & TEST_BBDEV_VF_EA) && (vector->turbo_enc.op_flags & 1402 RTE_BBDEV_TURBO_RATE_MATCH)) 1403 printf( 1404 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1405 if (!(mask & TEST_BBDEV_VF_EB) && (vector->turbo_enc.op_flags & 1406 RTE_BBDEV_TURBO_RATE_MATCH)) 1407 printf( 1408 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1409 if (!(mask & TEST_BBDEV_VF_K_NEG)) 1410 printf( 1411 "WARNING: k_neg was not specified in vector file and will be set to 0\n"); 1412 if (!(mask & TEST_BBDEV_VF_K_POS)) 1413 printf( 1414 "WARNING: k_pos was not specified in vector file and will be set to 0\n"); 1415 if (!(mask & TEST_BBDEV_VF_C_NEG)) 1416 printf( 1417 "WARNING: c_neg was not specified in vector file and will be set to 0\n"); 1418 if (!(mask & TEST_BBDEV_VF_C)) { 1419 printf( 1420 "WARNING: c was not specified in vector file and will be set to 1\n"); 1421 vector->turbo_enc.tb_params.c = 1; 1422 } 1423 if (!(mask & TEST_BBDEV_VF_CAB) && (vector->turbo_enc.op_flags & 1424 RTE_BBDEV_TURBO_RATE_MATCH)) 1425 printf( 1426 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1427 if (!(mask & TEST_BBDEV_VF_NCB_NEG)) 1428 printf( 1429 "WARNING: ncb_neg was not specified in vector file and will be set to 0\n"); 1430 if (!(mask & TEST_BBDEV_VF_NCB_POS)) 1431 printf( 1432 "WARNING: ncb_pos was not specified in vector file and will be set to 0\n"); 1433 if (!(mask & TEST_BBDEV_VF_R)) 1434 printf( 1435 "WARNING: r was not specified in vector file and will be set to 0\n"); 1436 } else { 1437 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags & 1438 RTE_BBDEV_TURBO_RATE_MATCH)) 1439 printf( 1440 "WARNING: e was not specified in vector file and will be set to 0\n"); 1441 if (!(mask & TEST_BBDEV_VF_K)) 1442 printf( 1443 "WARNING: k was not specified in vector file and will be set to 0\n"); 1444 if (!(mask & TEST_BBDEV_VF_NCB)) 1445 printf( 1446 "WARNING: ncb was not specified in vector file and will be set to 0\n"); 1447 } 1448 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1449 printf( 1450 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1451 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) 1452 printf( 1453 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n"); 1454 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1455 printf( 1456 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1457 1458 return 0; 1459 } 1460 1461 1462 /* checks encoder parameters */ 1463 static int 1464 check_ldpc_encoder(struct test_bbdev_vector *vector) 1465 { 1466 unsigned char i; 1467 const int mask = vector->mask; 1468 1469 if (vector->entries[DATA_INPUT].nb_segments == 0) 1470 return -1; 1471 1472 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1473 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1474 return -1; 1475 1476 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1477 return -1; 1478 1479 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1480 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1481 return -1; 1482 1483 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1484 printf( 1485 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n"); 1486 vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK; 1487 } 1488 if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1489 } else { 1490 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags & 1491 RTE_BBDEV_TURBO_RATE_MATCH)) 1492 printf( 1493 "WARNING: e was not specified in vector file and will be set to 0\n"); 1494 if (!(mask & TEST_BBDEV_VF_NCB)) 1495 printf( 1496 "WARNING: ncb was not specified in vector file and will be set to 0\n"); 1497 } 1498 if (!(mask & TEST_BBDEV_VF_BG)) 1499 printf( 1500 "WARNING: BG was not specified in vector file and will be set to 0\n"); 1501 if (!(mask & TEST_BBDEV_VF_ZC)) 1502 printf( 1503 "WARNING: Zc was not specified in vector file and will be set to 0\n"); 1504 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1505 printf( 1506 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1507 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) 1508 printf( 1509 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n"); 1510 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1511 printf( 1512 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1513 1514 return 0; 1515 } 1516 1517 static int 1518 bbdev_check_vector(struct test_bbdev_vector *vector) 1519 { 1520 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) { 1521 if (check_decoder(vector) == -1) 1522 return -1; 1523 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) { 1524 if (check_encoder(vector) == -1) 1525 return -1; 1526 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) { 1527 if (check_ldpc_encoder(vector) == -1) 1528 return -1; 1529 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { 1530 if (check_ldpc_decoder(vector) == -1) 1531 return -1; 1532 } else if (vector->op_type == RTE_BBDEV_OP_FFT) { 1533 if (check_fft(vector) == -1) 1534 return -1; 1535 } else if (vector->op_type != RTE_BBDEV_OP_NONE) { 1536 printf("Vector was not filled\n"); 1537 return -1; 1538 } 1539 1540 return 0; 1541 } 1542 1543 int 1544 test_bbdev_vector_read(const char *filename, 1545 struct test_bbdev_vector *vector) 1546 { 1547 int ret = 0; 1548 size_t len = 0; 1549 1550 FILE *fp = NULL; 1551 char *line = NULL; 1552 char *entry = NULL; 1553 1554 fp = fopen(filename, "r"); 1555 if (fp == NULL) { 1556 printf("File %s does not exist\n", filename); 1557 return -1; 1558 } 1559 1560 while (getline(&line, &len, fp) != -1) { 1561 1562 /* ignore comments and new lines */ 1563 if (line[0] == '#' || line[0] == '/' || line[0] == '\n' 1564 || line[0] == '\r') 1565 continue; 1566 1567 trim_space(line); 1568 1569 /* buffer for multiline */ 1570 entry = realloc(entry, strlen(line) + 1); 1571 if (entry == NULL) { 1572 printf("Fail to realloc %zu bytes\n", strlen(line) + 1); 1573 ret = -ENOMEM; 1574 goto exit; 1575 } 1576 1577 strcpy(entry, line); 1578 1579 /* check if entry ends with , or = */ 1580 if (entry[strlen(entry) - 1] == ',' 1581 || entry[strlen(entry) - 1] == '=') { 1582 while (getline(&line, &len, fp) != -1) { 1583 trim_space(line); 1584 1585 /* extend entry about length of new line */ 1586 char *entry_extended = realloc(entry, 1587 strlen(line) + 1588 strlen(entry) + 1); 1589 1590 if (entry_extended == NULL) { 1591 printf("Fail to allocate %zu bytes\n", 1592 strlen(line) + 1593 strlen(entry) + 1); 1594 ret = -ENOMEM; 1595 goto exit; 1596 } 1597 1598 entry = entry_extended; 1599 /* entry has been allocated accordingly */ 1600 strcpy(&entry[strlen(entry)], line); 1601 1602 if (entry[strlen(entry) - 1] != ',') 1603 break; 1604 } 1605 } 1606 ret = parse_entry(entry, vector); 1607 if (ret != 0) { 1608 printf("An error occurred while parsing!\n"); 1609 goto exit; 1610 } 1611 } 1612 ret = bbdev_check_vector(vector); 1613 if (ret != 0) 1614 printf("An error occurred while checking!\n"); 1615 1616 exit: 1617 fclose(fp); 1618 free(line); 1619 free(entry); 1620 1621 return ret; 1622 } 1623