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_HARQ_4BIT_COMPRESSION")) 200 *op_flag_value = RTE_BBDEV_LDPC_HARQ_4BIT_COMPRESSION; 201 else if (!strcmp(token, "RTE_BBDEV_LDPC_LLR_COMPRESSION")) 202 *op_flag_value = RTE_BBDEV_LDPC_LLR_COMPRESSION; 203 else if (!strcmp(token, 204 "RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE")) 205 *op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE; 206 else if (!strcmp(token, 207 "RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE")) 208 *op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE; 209 else if (!strcmp(token, 210 "RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK")) 211 *op_flag_value = RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK; 212 else { 213 printf("The given value is not a LDPC decoder flag\n"); 214 return -1; 215 } 216 217 return 0; 218 } 219 220 /* Convert FFT flag from string to unsigned long int. */ 221 static int 222 op_fft_flag_strtoul(char *token, uint32_t *op_flag_value) 223 { 224 if (!strcmp(token, "RTE_BBDEV_FFT_WINDOWING")) 225 *op_flag_value = RTE_BBDEV_FFT_WINDOWING; 226 else if (!strcmp(token, "RTE_BBDEV_FFT_CS_ADJUSTMENT")) 227 *op_flag_value = RTE_BBDEV_FFT_CS_ADJUSTMENT; 228 else if (!strcmp(token, "RTE_BBDEV_FFT_DFT_BYPASS")) 229 *op_flag_value = RTE_BBDEV_FFT_DFT_BYPASS; 230 else if (!strcmp(token, "RTE_BBDEV_FFT_IDFT_BYPASS")) 231 *op_flag_value = RTE_BBDEV_FFT_IDFT_BYPASS; 232 else if (!strcmp(token, "RTE_BBDEV_FFT_WINDOWING_BYPASS")) 233 *op_flag_value = RTE_BBDEV_FFT_WINDOWING_BYPASS; 234 else if (!strcmp(token, "RTE_BBDEV_FFT_POWER_MEAS")) 235 *op_flag_value = RTE_BBDEV_FFT_POWER_MEAS; 236 else if (!strcmp(token, "RTE_BBDEV_FFT_FP16_INPUT")) 237 *op_flag_value = RTE_BBDEV_FFT_FP16_INPUT; 238 else if (!strcmp(token, "RTE_BBDEV_FFT_FP16_OUTPUT")) 239 *op_flag_value = RTE_BBDEV_FFT_FP16_OUTPUT; 240 else if (!strcmp(token, "RTE_BBDEV_FFT_TIMING_OFFSET_PER_CS")) 241 *op_flag_value = RTE_BBDEV_FFT_TIMING_OFFSET_PER_CS; 242 else if (!strcmp(token, "RTE_BBDEV_FFT_TIMING_ERROR")) 243 *op_flag_value = RTE_BBDEV_FFT_TIMING_ERROR; 244 else if (!strcmp(token, "RTE_BBDEV_FFT_DEWINDOWING")) 245 *op_flag_value = RTE_BBDEV_FFT_DEWINDOWING; 246 else if (!strcmp(token, "RTE_BBDEV_FFT_FREQ_RESAMPLING")) 247 *op_flag_value = RTE_BBDEV_FFT_FREQ_RESAMPLING; 248 else { 249 printf("The given value is not a FFT flag\n"); 250 return -1; 251 } 252 253 return 0; 254 } 255 256 /* convert MLD flag from string to unsigned long int*/ 257 static int 258 op_mld_flag_strtoul(char *token, uint32_t *op_flag_value) 259 { 260 if (!strcmp(token, "RTE_BBDEV_MLDTS_REP")) 261 *op_flag_value = RTE_BBDEV_MLDTS_REP; 262 else { 263 printf("The given value is not a MLD flag\n"); 264 return -1; 265 } 266 267 return 0; 268 } 269 270 /* convert turbo encoder flag from string to unsigned long int*/ 271 static int 272 op_encoder_flag_strtoul(char *token, uint32_t *op_flag_value) 273 { 274 if (!strcmp(token, "RTE_BBDEV_TURBO_RV_INDEX_BYPASS")) 275 *op_flag_value = RTE_BBDEV_TURBO_RV_INDEX_BYPASS; 276 else if (!strcmp(token, "RTE_BBDEV_TURBO_RATE_MATCH")) 277 *op_flag_value = RTE_BBDEV_TURBO_RATE_MATCH; 278 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_24B_ATTACH")) 279 *op_flag_value = RTE_BBDEV_TURBO_CRC_24B_ATTACH; 280 else if (!strcmp(token, "RTE_BBDEV_TURBO_CRC_24A_ATTACH")) 281 *op_flag_value = RTE_BBDEV_TURBO_CRC_24A_ATTACH; 282 else if (!strcmp(token, "RTE_BBDEV_TURBO_ENC_SCATTER_GATHER")) 283 *op_flag_value = RTE_BBDEV_TURBO_ENC_SCATTER_GATHER; 284 else { 285 printf("The given value is not a turbo encoder flag\n"); 286 return -1; 287 } 288 289 return 0; 290 } 291 292 /* convert LDPC encoder flag from string to unsigned long int*/ 293 static int 294 op_ldpc_encoder_flag_strtoul(char *token, uint32_t *op_flag_value) 295 { 296 if (!strcmp(token, "RTE_BBDEV_LDPC_INTERLEAVER_BYPASS")) 297 *op_flag_value = RTE_BBDEV_LDPC_INTERLEAVER_BYPASS; 298 else if (!strcmp(token, "RTE_BBDEV_LDPC_RATE_MATCH")) 299 *op_flag_value = RTE_BBDEV_LDPC_RATE_MATCH; 300 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_24A_ATTACH")) 301 *op_flag_value = RTE_BBDEV_LDPC_CRC_24A_ATTACH; 302 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_24B_ATTACH")) 303 *op_flag_value = RTE_BBDEV_LDPC_CRC_24B_ATTACH; 304 else if (!strcmp(token, "RTE_BBDEV_LDPC_CRC_16_ATTACH")) 305 *op_flag_value = RTE_BBDEV_LDPC_CRC_16_ATTACH; 306 else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_INTERRUPTS")) 307 *op_flag_value = RTE_BBDEV_LDPC_ENC_INTERRUPTS; 308 else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_SCATTER_GATHER")) 309 *op_flag_value = RTE_BBDEV_LDPC_ENC_SCATTER_GATHER; 310 else if (!strcmp(token, "RTE_BBDEV_LDPC_ENC_CONCATENATION")) 311 *op_flag_value = RTE_BBDEV_LDPC_ENC_CONCATENATION; 312 else { 313 printf("The given value is not a LDPC encoder flag - %s\n", token); 314 return -1; 315 } 316 317 return 0; 318 } 319 320 /* tokenization turbo decoder/encoder flags values separated by a comma */ 321 static int 322 parse_turbo_flags(char *tokens, uint32_t *op_flags, 323 enum rte_bbdev_op_type op_type) 324 { 325 char *tok = NULL; 326 uint32_t op_flag_value = 0; 327 328 tok = strtok(tokens, VALUE_DELIMITER); 329 if (tok == NULL) 330 return -1; 331 332 while (tok != NULL) { 333 trim_space(tok); 334 if (op_type == RTE_BBDEV_OP_TURBO_DEC) { 335 if (op_decoder_flag_strtoul(tok, &op_flag_value) == -1) 336 return -1; 337 } else if (op_type == RTE_BBDEV_OP_TURBO_ENC) { 338 if (op_encoder_flag_strtoul(tok, &op_flag_value) == -1) 339 return -1; 340 } else if (op_type == RTE_BBDEV_OP_LDPC_ENC) { 341 if (op_ldpc_encoder_flag_strtoul(tok, &op_flag_value) 342 == -1) 343 return -1; 344 } else if (op_type == RTE_BBDEV_OP_LDPC_DEC) { 345 if (op_ldpc_decoder_flag_strtoul(tok, &op_flag_value) 346 == -1) 347 return -1; 348 } else if (op_type == RTE_BBDEV_OP_FFT) { 349 if (op_fft_flag_strtoul(tok, &op_flag_value) 350 == -1) 351 return -1; 352 } else if (op_type == RTE_BBDEV_OP_MLDTS) { 353 if (op_mld_flag_strtoul(tok, &op_flag_value) 354 == -1) 355 return -1; 356 } else { 357 return -1; 358 } 359 360 *op_flags = *op_flags | op_flag_value; 361 362 tok = strtok(NULL, VALUE_DELIMITER); 363 if (tok == NULL) 364 break; 365 } 366 367 return 0; 368 } 369 370 /* convert turbo encoder/decoder op_type from string to enum*/ 371 static int 372 op_turbo_type_strtol(char *token, enum rte_bbdev_op_type *op_type) 373 { 374 trim_space(token); 375 if (!strcmp(token, "RTE_BBDEV_OP_TURBO_DEC")) 376 *op_type = RTE_BBDEV_OP_TURBO_DEC; 377 else if (!strcmp(token, "RTE_BBDEV_OP_TURBO_ENC")) 378 *op_type = RTE_BBDEV_OP_TURBO_ENC; 379 else if (!strcmp(token, "RTE_BBDEV_OP_LDPC_ENC")) 380 *op_type = RTE_BBDEV_OP_LDPC_ENC; 381 else if (!strcmp(token, "RTE_BBDEV_OP_LDPC_DEC")) 382 *op_type = RTE_BBDEV_OP_LDPC_DEC; 383 else if (!strcmp(token, "RTE_BBDEV_OP_FFT")) 384 *op_type = RTE_BBDEV_OP_FFT; 385 else if (!strcmp(token, "RTE_BBDEV_OP_MLDTS")) 386 *op_type = RTE_BBDEV_OP_MLDTS; 387 else if (!strcmp(token, "RTE_BBDEV_OP_NONE")) 388 *op_type = RTE_BBDEV_OP_NONE; 389 else { 390 printf("Not valid turbo op_type: '%s'\n", token); 391 return -1; 392 } 393 394 return 0; 395 } 396 397 /* tokenization expected status values separated by a comma */ 398 static int 399 parse_expected_status(char *tokens, int *status, enum rte_bbdev_op_type op_type) 400 { 401 char *tok = NULL; 402 bool status_ok = false; 403 404 tok = strtok(tokens, VALUE_DELIMITER); 405 if (tok == NULL) 406 return -1; 407 408 while (tok != NULL) { 409 trim_space(tok); 410 if (!strcmp(tok, "OK")) 411 status_ok = true; 412 else if (!strcmp(tok, "DMA")) 413 *status = *status | (1 << RTE_BBDEV_DRV_ERROR); 414 else if (!strcmp(tok, "FCW")) 415 *status = *status | (1 << RTE_BBDEV_DATA_ERROR); 416 else if (!strcmp(tok, "SYNCRC")) { 417 *status = *status | (1 << RTE_BBDEV_SYNDROME_ERROR); 418 *status = *status | (1 << RTE_BBDEV_CRC_ERROR); 419 } else if (!strcmp(tok, "SYN")) 420 *status = *status | (1 << RTE_BBDEV_SYNDROME_ERROR); 421 else if (!strcmp(tok, "CRC")) { 422 if ((op_type == RTE_BBDEV_OP_TURBO_DEC) || 423 (op_type == RTE_BBDEV_OP_LDPC_DEC)) 424 *status = *status | (1 << RTE_BBDEV_CRC_ERROR); 425 else { 426 printf( 427 "CRC is only a valid value for decoder\n"); 428 return -1; 429 } 430 } else { 431 printf("Not valid status: '%s'\n", tok); 432 return -1; 433 } 434 435 tok = strtok(NULL, VALUE_DELIMITER); 436 if (tok == NULL) 437 break; 438 } 439 440 if (status_ok && *status != 0) { 441 printf( 442 "Not valid status values. Cannot be OK and ERROR at the same time.\n"); 443 return -1; 444 } 445 446 return 0; 447 } 448 449 /* parse ops data entry (there can be more than 1 input entry, each will be 450 * contained in a separate op_data_buf struct) 451 */ 452 static int 453 parse_data_entry(const char *key_token, char *token, 454 struct test_bbdev_vector *vector, enum op_data_type type, 455 const char *prefix) 456 { 457 int ret; 458 uint32_t data_length = 0; 459 uint32_t *data = NULL; 460 unsigned int id; 461 struct op_data_buf *op_data; 462 unsigned int *nb_ops; 463 464 if (type >= DATA_NUM_TYPES) { 465 printf("Unknown op type: %d!\n", type); 466 return -1; 467 } 468 469 op_data = vector->entries[type].segments; 470 nb_ops = &vector->entries[type].nb_segments; 471 472 if (*nb_ops >= RTE_BBDEV_TURBO_MAX_CODE_BLOCKS) { 473 printf("Too many segments (code blocks defined): %u, max %d!\n", 474 *nb_ops, RTE_BBDEV_TURBO_MAX_CODE_BLOCKS); 475 return -1; 476 } 477 478 if (sscanf(key_token + strlen(prefix), "%u", &id) != 1) { 479 printf("Missing ID of %s\n", prefix); 480 return -1; 481 } 482 if (id != *nb_ops) { 483 printf( 484 "Please order data entries sequentially, i.e. %s0, %s1, ...\n", 485 prefix, prefix); 486 return -1; 487 } 488 489 /* Clear new op data struct */ 490 memset(op_data + *nb_ops, 0, sizeof(struct op_data_buf)); 491 492 ret = parse_values(token, &data, &data_length); 493 if (!ret) { 494 op_data[*nb_ops].addr = data; 495 op_data[*nb_ops].length = data_length; 496 ++(*nb_ops); 497 } 498 499 return ret; 500 } 501 502 /* parses turbo decoder parameters and assigns to global variable */ 503 static int 504 parse_decoder_params(const char *key_token, char *token, 505 struct test_bbdev_vector *vector) 506 { 507 int ret = 0, status = 0; 508 uint32_t op_flags = 0; 509 char *err = NULL; 510 511 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 512 513 /* compare keys */ 514 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 515 ret = parse_data_entry(key_token, token, vector, 516 DATA_INPUT, op_data_prefixes[DATA_INPUT]); 517 518 else if (starts_with(key_token, op_data_prefixes[DATA_SOFT_OUTPUT])) 519 ret = parse_data_entry(key_token, token, vector, 520 DATA_SOFT_OUTPUT, 521 op_data_prefixes[DATA_SOFT_OUTPUT]); 522 523 else if (starts_with(key_token, op_data_prefixes[DATA_HARD_OUTPUT])) 524 ret = parse_data_entry(key_token, token, vector, 525 DATA_HARD_OUTPUT, 526 op_data_prefixes[DATA_HARD_OUTPUT]); 527 else if (!strcmp(key_token, "e")) { 528 vector->mask |= TEST_BBDEV_VF_E; 529 turbo_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0); 530 } else if (!strcmp(key_token, "ea")) { 531 vector->mask |= TEST_BBDEV_VF_EA; 532 turbo_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 533 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 534 } else if (!strcmp(key_token, "eb")) { 535 vector->mask |= TEST_BBDEV_VF_EB; 536 turbo_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 537 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 538 } else if (!strcmp(key_token, "k")) { 539 vector->mask |= TEST_BBDEV_VF_K; 540 turbo_dec->cb_params.k = (uint16_t) strtoul(token, &err, 0); 541 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 542 } else if (!strcmp(key_token, "k_pos")) { 543 vector->mask |= TEST_BBDEV_VF_K_POS; 544 turbo_dec->tb_params.k_pos = (uint16_t) strtoul(token, &err, 0); 545 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 546 } else if (!strcmp(key_token, "k_neg")) { 547 vector->mask |= TEST_BBDEV_VF_K_NEG; 548 turbo_dec->tb_params.k_neg = (uint16_t) strtoul(token, &err, 0); 549 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 550 } else if (!strcmp(key_token, "c")) { 551 vector->mask |= TEST_BBDEV_VF_C; 552 turbo_dec->tb_params.c = (uint16_t) strtoul(token, &err, 0); 553 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 554 } else if (!strcmp(key_token, "c_neg")) { 555 vector->mask |= TEST_BBDEV_VF_C_NEG; 556 turbo_dec->tb_params.c_neg = (uint16_t) strtoul(token, &err, 0); 557 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 558 } else if (!strcmp(key_token, "cab")) { 559 vector->mask |= TEST_BBDEV_VF_CAB; 560 turbo_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 561 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 562 } else if (!strcmp(key_token, "rv_index")) { 563 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 564 turbo_dec->rv_index = (uint8_t) strtoul(token, &err, 0); 565 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 566 } else if (!strcmp(key_token, "iter_min")) { 567 vector->mask |= TEST_BBDEV_VF_ITER_MIN; 568 turbo_dec->iter_min = (uint8_t) strtoul(token, &err, 0); 569 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 570 } else if (!strcmp(key_token, "expected_iter_count")) { 571 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT; 572 turbo_dec->iter_count = (uint8_t) strtoul(token, &err, 0); 573 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 574 } else if (!strcmp(key_token, "ext_scale")) { 575 vector->mask |= TEST_BBDEV_VF_EXT_SCALE; 576 turbo_dec->ext_scale = (uint8_t) strtoul(token, &err, 0); 577 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 578 } else if (!strcmp(key_token, "num_maps")) { 579 vector->mask |= TEST_BBDEV_VF_NUM_MAPS; 580 turbo_dec->num_maps = (uint8_t) strtoul(token, &err, 0); 581 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 582 } else if (!strcmp(key_token, "r")) { 583 vector->mask |= TEST_BBDEV_VF_R; 584 turbo_dec->tb_params.r = (uint8_t)strtoul(token, &err, 0); 585 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 586 } else if (!strcmp(key_token, "code_block_mode")) { 587 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 588 turbo_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0); 589 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 590 } else if (!strcmp(key_token, "op_flags")) { 591 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 592 ret = parse_turbo_flags(token, &op_flags, 593 vector->op_type); 594 if (!ret) 595 turbo_dec->op_flags = op_flags; 596 } else if (!strcmp(key_token, "expected_status")) { 597 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 598 ret = parse_expected_status(token, &status, vector->op_type); 599 if (!ret) 600 vector->expected_status = status; 601 } else { 602 printf("Not valid dec key: '%s'\n", key_token); 603 return -1; 604 } 605 606 if (ret != 0) { 607 printf("Failed with convert '%s\t%s'\n", key_token, token); 608 return -1; 609 } 610 611 return 0; 612 } 613 614 /* parses turbo encoder parameters and assigns to global variable */ 615 static int 616 parse_encoder_params(const char *key_token, char *token, 617 struct test_bbdev_vector *vector) 618 { 619 int ret = 0, status = 0; 620 uint32_t op_flags = 0; 621 char *err = NULL; 622 623 624 struct rte_bbdev_op_turbo_enc *turbo_enc = &vector->turbo_enc; 625 626 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 627 ret = parse_data_entry(key_token, token, vector, 628 DATA_INPUT, op_data_prefixes[DATA_INPUT]); 629 else if (starts_with(key_token, "output")) 630 ret = parse_data_entry(key_token, token, vector, 631 DATA_HARD_OUTPUT, "output"); 632 else if (!strcmp(key_token, "e")) { 633 vector->mask |= TEST_BBDEV_VF_E; 634 turbo_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0); 635 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 636 } else if (!strcmp(key_token, "ea")) { 637 vector->mask |= TEST_BBDEV_VF_EA; 638 turbo_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 639 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 640 } else if (!strcmp(key_token, "eb")) { 641 vector->mask |= TEST_BBDEV_VF_EB; 642 turbo_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 643 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 644 } else if (!strcmp(key_token, "k")) { 645 vector->mask |= TEST_BBDEV_VF_K; 646 turbo_enc->cb_params.k = (uint16_t) strtoul(token, &err, 0); 647 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 648 } else if (!strcmp(key_token, "k_neg")) { 649 vector->mask |= TEST_BBDEV_VF_K_NEG; 650 turbo_enc->tb_params.k_neg = (uint16_t) strtoul(token, &err, 0); 651 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 652 } else if (!strcmp(key_token, "k_pos")) { 653 vector->mask |= TEST_BBDEV_VF_K_POS; 654 turbo_enc->tb_params.k_pos = (uint16_t) strtoul(token, &err, 0); 655 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 656 } else if (!strcmp(key_token, "c_neg")) { 657 vector->mask |= TEST_BBDEV_VF_C_NEG; 658 turbo_enc->tb_params.c_neg = (uint8_t) strtoul(token, &err, 0); 659 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 660 } else if (!strcmp(key_token, "c")) { 661 vector->mask |= TEST_BBDEV_VF_C; 662 turbo_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0); 663 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 664 } else if (!strcmp(key_token, "cab")) { 665 vector->mask |= TEST_BBDEV_VF_CAB; 666 turbo_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 667 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 668 } else if (!strcmp(key_token, "rv_index")) { 669 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 670 turbo_enc->rv_index = (uint8_t) strtoul(token, &err, 0); 671 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 672 } else if (!strcmp(key_token, "ncb")) { 673 vector->mask |= TEST_BBDEV_VF_NCB; 674 turbo_enc->cb_params.ncb = (uint16_t) strtoul(token, &err, 0); 675 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 676 } else if (!strcmp(key_token, "ncb_neg")) { 677 vector->mask |= TEST_BBDEV_VF_NCB_NEG; 678 turbo_enc->tb_params.ncb_neg = 679 (uint16_t) strtoul(token, &err, 0); 680 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 681 } else if (!strcmp(key_token, "ncb_pos")) { 682 vector->mask |= TEST_BBDEV_VF_NCB_POS; 683 turbo_enc->tb_params.ncb_pos = 684 (uint16_t) strtoul(token, &err, 0); 685 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 686 } else if (!strcmp(key_token, "r")) { 687 vector->mask |= TEST_BBDEV_VF_R; 688 turbo_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0); 689 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 690 } else if (!strcmp(key_token, "code_block_mode")) { 691 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 692 turbo_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0); 693 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 694 } else if (!strcmp(key_token, "op_flags")) { 695 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 696 ret = parse_turbo_flags(token, &op_flags, 697 vector->op_type); 698 if (!ret) 699 turbo_enc->op_flags = op_flags; 700 } else if (!strcmp(key_token, "expected_status")) { 701 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 702 ret = parse_expected_status(token, &status, vector->op_type); 703 if (!ret) 704 vector->expected_status = status; 705 } else { 706 printf("Not valid enc key: '%s'\n", key_token); 707 return -1; 708 } 709 710 if (ret != 0) { 711 printf("Failed with convert '%s\t%s'\n", key_token, token); 712 return -1; 713 } 714 715 return 0; 716 } 717 718 719 /* parses LDPC encoder parameters and assigns to global variable */ 720 static int 721 parse_ldpc_encoder_params(const char *key_token, char *token, 722 struct test_bbdev_vector *vector) 723 { 724 int ret = 0, status = 0; 725 uint32_t op_flags = 0; 726 char *err = NULL; 727 728 struct rte_bbdev_op_ldpc_enc *ldpc_enc = &vector->ldpc_enc; 729 730 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 731 ret = parse_data_entry(key_token, token, vector, 732 DATA_INPUT, 733 op_data_prefixes[DATA_INPUT]); 734 else if (starts_with(key_token, "output")) 735 ret = parse_data_entry(key_token, token, vector, 736 DATA_HARD_OUTPUT, 737 "output"); 738 else if (!strcmp(key_token, "e")) { 739 vector->mask |= TEST_BBDEV_VF_E; 740 ldpc_enc->cb_params.e = (uint32_t) strtoul(token, &err, 0); 741 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 742 } else if (!strcmp(key_token, "ea")) { 743 vector->mask |= TEST_BBDEV_VF_EA; 744 ldpc_enc->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 745 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 746 } else if (!strcmp(key_token, "eb")) { 747 vector->mask |= TEST_BBDEV_VF_EB; 748 ldpc_enc->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 749 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 750 } else if (!strcmp(key_token, "c")) { 751 vector->mask |= TEST_BBDEV_VF_C; 752 ldpc_enc->tb_params.c = (uint8_t) strtoul(token, &err, 0); 753 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 754 } else if (!strcmp(key_token, "cab")) { 755 vector->mask |= TEST_BBDEV_VF_CAB; 756 ldpc_enc->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 757 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 758 } else if (!strcmp(key_token, "rv_index")) { 759 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 760 ldpc_enc->rv_index = (uint8_t) strtoul(token, &err, 0); 761 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 762 } else if (!strcmp(key_token, "n_cb")) { 763 vector->mask |= TEST_BBDEV_VF_NCB; 764 ldpc_enc->n_cb = (uint16_t) strtoul(token, &err, 0); 765 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 766 } else if (!strcmp(key_token, "r")) { 767 vector->mask |= TEST_BBDEV_VF_R; 768 ldpc_enc->tb_params.r = (uint8_t) strtoul(token, &err, 0); 769 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 770 } else if (!strcmp(key_token, "q_m")) { 771 vector->mask |= TEST_BBDEV_VF_QM; 772 ldpc_enc->q_m = (uint8_t) strtoul(token, &err, 0); 773 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 774 } else if (!strcmp(key_token, "basegraph")) { 775 vector->mask |= TEST_BBDEV_VF_BG; 776 ldpc_enc->basegraph = (uint8_t) strtoul(token, &err, 0); 777 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 778 } else if (!strcmp(key_token, "z_c")) { 779 vector->mask |= TEST_BBDEV_VF_ZC; 780 ldpc_enc->z_c = (uint16_t) strtoul(token, &err, 0); 781 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 782 } else if (!strcmp(key_token, "n_filler")) { 783 vector->mask |= TEST_BBDEV_VF_F; 784 ldpc_enc->n_filler = (uint16_t) strtoul(token, &err, 0); 785 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 786 } else if (!strcmp(key_token, "code_block_mode")) { 787 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 788 ldpc_enc->code_block_mode = (uint8_t) strtoul(token, &err, 0); 789 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 790 } else if (!strcmp(key_token, "op_flags")) { 791 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 792 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 793 if (!ret) 794 ldpc_enc->op_flags = op_flags; 795 } else if (!strcmp(key_token, "expected_status")) { 796 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 797 ret = parse_expected_status(token, &status, vector->op_type); 798 if (!ret) 799 vector->expected_status = status; 800 } else { 801 printf("Not valid ldpc enc key: '%s'\n", key_token); 802 return -1; 803 } 804 805 if (ret != 0) { 806 printf("Failed with convert '%s\t%s'\n", key_token, token); 807 return -1; 808 } 809 810 return 0; 811 } 812 813 /* parses LDPC decoder parameters and assigns to global variable */ 814 static int 815 parse_ldpc_decoder_params(const char *key_token, char *token, 816 struct test_bbdev_vector *vector) 817 { 818 int ret = 0, status = 0; 819 uint32_t op_flags = 0; 820 char *err = NULL; 821 822 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 823 824 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) 825 ret = parse_data_entry(key_token, token, vector, 826 DATA_INPUT, 827 op_data_prefixes[DATA_INPUT]); 828 else if (starts_with(key_token, "output")) 829 ret = parse_data_entry(key_token, token, vector, 830 DATA_HARD_OUTPUT, 831 "output"); 832 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_INPUT])) 833 ret = parse_data_entry(key_token, token, vector, 834 DATA_HARQ_INPUT, 835 op_data_prefixes[DATA_HARQ_INPUT]); 836 else if (starts_with(key_token, op_data_prefixes[DATA_HARQ_OUTPUT])) 837 ret = parse_data_entry(key_token, token, vector, 838 DATA_HARQ_OUTPUT, 839 op_data_prefixes[DATA_HARQ_OUTPUT]); 840 else if (!strcmp(key_token, "e")) { 841 vector->mask |= TEST_BBDEV_VF_E; 842 ldpc_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0); 843 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 844 } else if (!strcmp(key_token, "ea")) { 845 vector->mask |= TEST_BBDEV_VF_EA; 846 ldpc_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 847 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 848 } else if (!strcmp(key_token, "eb")) { 849 vector->mask |= TEST_BBDEV_VF_EB; 850 ldpc_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 851 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 852 } else if (!strcmp(key_token, "c")) { 853 vector->mask |= TEST_BBDEV_VF_C; 854 ldpc_dec->tb_params.c = (uint8_t) strtoul(token, &err, 0); 855 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 856 } else if (!strcmp(key_token, "cab")) { 857 vector->mask |= TEST_BBDEV_VF_CAB; 858 ldpc_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 859 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 860 } else if (!strcmp(key_token, "rv_index")) { 861 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 862 ldpc_dec->rv_index = (uint8_t) strtoul(token, &err, 0); 863 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 864 } else if (!strcmp(key_token, "n_cb")) { 865 vector->mask |= TEST_BBDEV_VF_NCB; 866 ldpc_dec->n_cb = (uint16_t) strtoul(token, &err, 0); 867 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 868 } else if (!strcmp(key_token, "r")) { 869 vector->mask |= TEST_BBDEV_VF_R; 870 ldpc_dec->tb_params.r = (uint8_t) strtoul(token, &err, 0); 871 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 872 } else if (!strcmp(key_token, "q_m")) { 873 vector->mask |= TEST_BBDEV_VF_QM; 874 ldpc_dec->q_m = (uint8_t) strtoul(token, &err, 0); 875 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 876 } else if (!strcmp(key_token, "basegraph")) { 877 vector->mask |= TEST_BBDEV_VF_BG; 878 ldpc_dec->basegraph = (uint8_t) strtoul(token, &err, 0); 879 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 880 } else if (!strcmp(key_token, "z_c")) { 881 vector->mask |= TEST_BBDEV_VF_ZC; 882 ldpc_dec->z_c = (uint16_t) strtoul(token, &err, 0); 883 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 884 } else if (!strcmp(key_token, "n_filler")) { 885 vector->mask |= TEST_BBDEV_VF_F; 886 ldpc_dec->n_filler = (uint16_t) strtoul(token, &err, 0); 887 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 888 } else if (!strcmp(key_token, "expected_iter_count")) { 889 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT; 890 ldpc_dec->iter_count = (uint8_t) strtoul(token, &err, 0); 891 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 892 } else if (!strcmp(key_token, "code_block_mode")) { 893 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 894 ldpc_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0); 895 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 896 } else if (!strcmp(key_token, "op_flags")) { 897 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 898 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 899 if (!ret) 900 ldpc_dec->op_flags = op_flags; 901 } else if (!strcmp(key_token, "expected_status")) { 902 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 903 ret = parse_expected_status(token, &status, vector->op_type); 904 if (!ret) 905 vector->expected_status = status; 906 } else { 907 printf("Not valid ldpc dec key: '%s'\n", key_token); 908 return -1; 909 } 910 911 if (ret != 0) { 912 printf("Failed with convert '%s\t%s'\n", key_token, token); 913 return -1; 914 } 915 916 return 0; 917 } 918 919 /* Parses FFT parameters and assigns to global variable. */ 920 static int 921 parse_fft_params(const char *key_token, char *token, 922 struct test_bbdev_vector *vector) 923 { 924 int ret = 0, status = 0, i, shift; 925 uint32_t op_flags = 0; 926 char *tok, *err = NULL; 927 928 struct rte_bbdev_op_fft *fft = &vector->fft; 929 930 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) { 931 ret = parse_data_entry(key_token, token, vector, 932 DATA_INPUT, 933 op_data_prefixes[DATA_INPUT]); 934 } else if (starts_with(key_token, "dewin_input")) { 935 ret = parse_data_entry(key_token, token, vector, 936 DATA_HARQ_INPUT, 937 "dewin_input"); 938 } else if (starts_with(key_token, "output")) { 939 ret = parse_data_entry(key_token, token, vector, 940 DATA_HARD_OUTPUT, 941 "output"); 942 } else if (starts_with(key_token, "power_output")) { 943 ret = parse_data_entry(key_token, token, vector, 944 DATA_SOFT_OUTPUT, 945 "power_output"); 946 } else if (!strcmp(key_token, "in_sequence_size")) { 947 fft->input_sequence_size = (uint32_t) strtoul(token, &err, 0); 948 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 949 } else if (!strcmp(key_token, "in_leading_padding")) { 950 fft->input_leading_padding = (uint32_t) strtoul(token, &err, 0); 951 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 952 } else if (!strcmp(key_token, "out_sequence_size")) { 953 fft->output_sequence_size = (uint32_t) strtoul(token, &err, 0); 954 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 955 } else if (!strcmp(key_token, "out_leading_depadding")) { 956 fft->output_leading_depadding = (uint32_t) strtoul(token, &err, 0); 957 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 958 } else if (!strcmp(key_token, "window_index")) { 959 tok = strtok(token, VALUE_DELIMITER); 960 if (tok == NULL) 961 return -1; 962 for (i = 0; i < FFT_WIN_SIZE; i++) { 963 shift = (i % 2) ? 4 : 0; 964 fft->window_index[i / 2] |= (uint32_t) strtoul(tok, &err, 0) 965 << shift; 966 if (i < (FFT_WIN_SIZE - 1)) { 967 tok = strtok(NULL, VALUE_DELIMITER); 968 if (tok == NULL) 969 return -1; 970 } 971 } 972 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 973 } else if (!strcmp(key_token, "cs_bitmap")) { 974 fft->cs_bitmap = (uint32_t) strtoul(token, &err, 0); 975 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 976 } else if (!strcmp(key_token, "num_antennas_log2")) { 977 fft->num_antennas_log2 = (uint32_t) strtoul(token, &err, 0); 978 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 979 } else if (!strcmp(key_token, "ifft_log2")) { 980 fft->idft_log2 = (uint32_t) strtoul(token, &err, 0); 981 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 982 } else if (!strcmp(key_token, "fft_log2")) { 983 fft->dft_log2 = (uint32_t) strtoul(token, &err, 0); 984 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 985 } else if (!strcmp(key_token, "cs_time_adjustment")) { 986 fft->cs_time_adjustment = (uint32_t) strtoul(token, &err, 0); 987 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 988 } else if (!strcmp(key_token, "ifft_shift")) { 989 fft->idft_shift = (uint32_t) strtoul(token, &err, 0); 990 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 991 } else if (!strcmp(key_token, "fft_shift")) { 992 fft->dft_shift = (uint32_t) strtoul(token, &err, 0); 993 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 994 } else if (!strcmp(key_token, "ncs_reciprocal")) { 995 fft->ncs_reciprocal = (uint32_t) strtoul(token, &err, 0); 996 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 997 } else if (!strcmp(key_token, "power_shift")) { 998 fft->power_shift = (uint32_t) strtoul(token, &err, 0); 999 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1000 } else if (!strcmp(key_token, "fp16_exponent_adjust")) { 1001 fft->fp16_exp_adjust = (uint32_t) strtoul(token, &err, 0); 1002 printf("%d\n", fft->fp16_exp_adjust); 1003 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1004 } else if (!strcmp(key_token, "freq_resample_mode")) { 1005 fft->freq_resample_mode = (uint32_t) strtoul(token, &err, 0); 1006 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1007 } else if (!strcmp(key_token, "out_depadded_size")) { 1008 fft->output_depadded_size = (uint32_t) strtoul(token, &err, 0); 1009 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1010 } else if (!strcmp(key_token, "cs_theta_0")) { 1011 tok = strtok(token, VALUE_DELIMITER); 1012 if (tok == NULL) 1013 return -1; 1014 for (i = 0; i < FFT_WIN_SIZE; i++) { 1015 fft->cs_theta_0[i] = (uint32_t) strtoul(tok, &err, 0); 1016 if (i < (FFT_WIN_SIZE - 1)) { 1017 tok = strtok(NULL, VALUE_DELIMITER); 1018 if (tok == NULL) 1019 return -1; 1020 } 1021 } 1022 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1023 } else if (!strcmp(key_token, "cs_theta_d")) { 1024 tok = strtok(token, VALUE_DELIMITER); 1025 if (tok == NULL) 1026 return -1; 1027 for (i = 0; i < FFT_WIN_SIZE; i++) { 1028 fft->cs_theta_d[i] = (uint32_t) strtoul(tok, &err, 0); 1029 if (i < (FFT_WIN_SIZE - 1)) { 1030 tok = strtok(NULL, VALUE_DELIMITER); 1031 if (tok == NULL) 1032 return -1; 1033 } 1034 } 1035 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1036 } else if (!strcmp(key_token, "time_offset")) { 1037 tok = strtok(token, VALUE_DELIMITER); 1038 if (tok == NULL) 1039 return -1; 1040 for (i = 0; i < FFT_WIN_SIZE; i++) { 1041 fft->time_offset[i] = (uint32_t) strtoul(tok, &err, 0); 1042 if (i < (FFT_WIN_SIZE - 1)) { 1043 tok = strtok(NULL, VALUE_DELIMITER); 1044 if (tok == NULL) 1045 return -1; 1046 } 1047 } 1048 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1049 } else if (!strcmp(key_token, "op_flags")) { 1050 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 1051 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 1052 if (!ret) 1053 fft->op_flags = op_flags; 1054 } else if (!strcmp(key_token, "expected_status")) { 1055 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 1056 ret = parse_expected_status(token, &status, vector->op_type); 1057 if (!ret) 1058 vector->expected_status = status; 1059 } else { 1060 printf("Not valid fft key: '%s'\n", key_token); 1061 return -1; 1062 } 1063 1064 if (ret != 0) { 1065 printf("Failed with convert '%s\t%s'\n", key_token, token); 1066 return -1; 1067 } 1068 1069 return 0; 1070 } 1071 1072 /* parses MLD parameters and assigns to global variable */ 1073 static int 1074 parse_mld_params(const char *key_token, char *token, 1075 struct test_bbdev_vector *vector) 1076 { 1077 int ret = 0, status = 0; 1078 uint32_t op_flags = 0; 1079 char *err = NULL; 1080 1081 struct rte_bbdev_op_mldts *mld = &vector->mldts; 1082 1083 if (starts_with(key_token, "qhy_input")) { 1084 ret = parse_data_entry(key_token, token, vector, 1085 DATA_INPUT, "qhy_input"); 1086 } else if (starts_with(key_token, "r_input")) { 1087 ret = parse_data_entry(key_token, token, vector, 1088 DATA_HARQ_INPUT, "r_input"); 1089 } else if (starts_with(key_token, "output")) { 1090 ret = parse_data_entry(key_token, token, vector, 1091 DATA_HARD_OUTPUT, "output"); 1092 } else if (!strcmp(key_token, "layers")) { 1093 mld->num_layers = (uint32_t) strtoul(token, &err, 0); 1094 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1095 } else if (!strcmp(key_token, "layer1")) { 1096 mld->q_m[0] = (uint32_t) strtoul(token, &err, 0); 1097 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1098 } else if (!strcmp(key_token, "layer2")) { 1099 mld->q_m[1] = (uint32_t) strtoul(token, &err, 0); 1100 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1101 } else if (!strcmp(key_token, "layer3")) { 1102 mld->q_m[2] = (uint32_t) strtoul(token, &err, 0); 1103 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1104 } else if (!strcmp(key_token, "layer4")) { 1105 mld->q_m[3] = (uint32_t) strtoul(token, &err, 0); 1106 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1107 } else if (!strcmp(key_token, "crep")) { 1108 mld->c_rep = (uint32_t) strtoul(token, &err, 0); 1109 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1110 } else if (!strcmp(key_token, "rrep")) { 1111 mld->r_rep = (uint32_t) strtoul(token, &err, 0); 1112 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1113 } else if (!strcmp(key_token, "rbs")) { 1114 mld->num_rbs = (uint32_t) strtoul(token, &err, 0); 1115 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1116 } else if (!strcmp(key_token, "op_flags")) { 1117 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 1118 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 1119 if (!ret) 1120 mld->op_flags = op_flags; 1121 } else if (!strcmp(key_token, "expected_status")) { 1122 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 1123 ret = parse_expected_status(token, &status, vector->op_type); 1124 if (!ret) 1125 vector->expected_status = status; 1126 } else { 1127 printf("Not valid mld key: '%s'\n", key_token); 1128 return -1; 1129 } 1130 1131 if (ret != 0) { 1132 printf("Failed with convert '%s\t%s'\n", key_token, token); 1133 return -1; 1134 } 1135 1136 return 0; 1137 } 1138 1139 /* checks the type of key and assigns data */ 1140 static int 1141 parse_entry(char *entry, struct test_bbdev_vector *vector) 1142 { 1143 int ret = 0; 1144 char *token, *key_token; 1145 enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_NONE; 1146 1147 if (entry == NULL) { 1148 printf("Expected entry value\n"); 1149 return -1; 1150 } 1151 1152 /* get key */ 1153 token = strtok(entry, ENTRY_DELIMITER); 1154 key_token = token; 1155 /* get values for key */ 1156 token = strtok(NULL, ENTRY_DELIMITER); 1157 1158 if (key_token == NULL || token == NULL) { 1159 printf("Expected 'key = values' but was '%.40s'..\n", entry); 1160 return -1; 1161 } 1162 trim_space(key_token); 1163 1164 /* first key_token has to specify type of operation */ 1165 if (vector->op_type == RTE_BBDEV_OP_NONE) { 1166 if (!strcmp(key_token, "op_type")) { 1167 ret = op_turbo_type_strtol(token, &op_type); 1168 if (!ret) 1169 vector->op_type = op_type; 1170 return (!ret) ? 0 : -1; 1171 } 1172 printf("First key_token (%s) does not specify op_type\n", 1173 key_token); 1174 return -1; 1175 } 1176 1177 /* compare keys */ 1178 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) { 1179 if (parse_decoder_params(key_token, token, vector) == -1) 1180 return -1; 1181 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) { 1182 if (parse_encoder_params(key_token, token, vector) == -1) 1183 return -1; 1184 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) { 1185 if (parse_ldpc_encoder_params(key_token, token, vector) == -1) 1186 return -1; 1187 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { 1188 if (parse_ldpc_decoder_params(key_token, token, vector) == -1) 1189 return -1; 1190 } else if (vector->op_type == RTE_BBDEV_OP_FFT) { 1191 if (parse_fft_params(key_token, token, vector) == -1) 1192 return -1; 1193 } else if (vector->op_type == RTE_BBDEV_OP_MLDTS) { 1194 if (parse_mld_params(key_token, token, vector) == -1) 1195 return -1; 1196 } 1197 1198 return 0; 1199 } 1200 1201 static int 1202 check_decoder_segments(struct test_bbdev_vector *vector) 1203 { 1204 unsigned char i; 1205 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1206 1207 if (vector->entries[DATA_INPUT].nb_segments == 0) 1208 return -1; 1209 1210 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1211 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1212 return -1; 1213 1214 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1215 return -1; 1216 1217 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; 1218 i++) 1219 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1220 return -1; 1221 1222 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT) && 1223 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0)) 1224 return -1; 1225 1226 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; 1227 i++) 1228 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL) 1229 return -1; 1230 1231 return 0; 1232 } 1233 1234 static int 1235 check_ldpc_decoder_segments(struct test_bbdev_vector *vector) 1236 { 1237 unsigned char i; 1238 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 1239 1240 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1241 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1242 return -1; 1243 1244 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1245 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1246 return -1; 1247 1248 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_SOFT_OUT_ENABLE) && 1249 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0)) 1250 return -1; 1251 1252 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; i++) 1253 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL) 1254 return -1; 1255 1256 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE) && 1257 (vector->entries[DATA_HARQ_OUTPUT].nb_segments == 0)) 1258 return -1; 1259 1260 for (i = 0; i < vector->entries[DATA_HARQ_OUTPUT].nb_segments; i++) 1261 if (vector->entries[DATA_HARQ_OUTPUT].segments[i].addr == NULL) 1262 return -1; 1263 1264 return 0; 1265 } 1266 1267 static int 1268 check_fft_segments(struct test_bbdev_vector *vector) 1269 { 1270 unsigned char i; 1271 1272 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1273 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1274 return -1; 1275 1276 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1277 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1278 return -1; 1279 return 0; 1280 } 1281 1282 static int 1283 check_mld_segments(struct test_bbdev_vector *vector) 1284 { 1285 unsigned char i; 1286 1287 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1288 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1289 return -1; 1290 1291 for (i = 0; i < vector->entries[DATA_HARQ_INPUT].nb_segments; i++) 1292 if (vector->entries[DATA_HARQ_INPUT].segments[i].addr == NULL) 1293 return -1; 1294 1295 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1296 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1297 return -1; 1298 return 0; 1299 } 1300 1301 static int 1302 check_decoder_llr_spec(struct test_bbdev_vector *vector) 1303 { 1304 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1305 1306 /* Check input LLR sign formalism specification */ 1307 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) && 1308 (turbo_dec->op_flags & 1309 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) { 1310 printf( 1311 "Both positive and negative LLR input flags were set!\n"); 1312 return -1; 1313 } 1314 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) && 1315 !(turbo_dec->op_flags & 1316 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) { 1317 printf( 1318 "INFO: input LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n"); 1319 turbo_dec->op_flags |= RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN; 1320 } 1321 1322 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT)) 1323 return 0; 1324 1325 /* Check output LLR sign formalism specification */ 1326 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) && 1327 (turbo_dec->op_flags & 1328 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) { 1329 printf( 1330 "Both positive and negative LLR output flags were set!\n"); 1331 return -1; 1332 } 1333 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) && 1334 !(turbo_dec->op_flags & 1335 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) { 1336 printf( 1337 "INFO: soft output LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n"); 1338 turbo_dec->op_flags |= 1339 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT; 1340 } 1341 1342 return 0; 1343 } 1344 1345 static int 1346 check_decoder_op_flags(struct test_bbdev_vector *vector) 1347 { 1348 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1349 1350 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP) && 1351 !(turbo_dec->op_flags & RTE_BBDEV_TURBO_CRC_TYPE_24B)) { 1352 printf( 1353 "WARNING: RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP flag is missing RTE_BBDEV_TURBO_CRC_TYPE_24B\n"); 1354 return -1; 1355 } 1356 1357 return 0; 1358 } 1359 1360 /* checks decoder parameters */ 1361 static int 1362 check_decoder(struct test_bbdev_vector *vector) 1363 { 1364 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1365 const int mask = vector->mask; 1366 1367 if (check_decoder_segments(vector) < 0) 1368 return -1; 1369 1370 if (check_decoder_llr_spec(vector) < 0) 1371 return -1; 1372 1373 if (check_decoder_op_flags(vector) < 0) 1374 return -1; 1375 1376 /* Check which params were set */ 1377 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1378 printf( 1379 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n"); 1380 turbo_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK; 1381 } 1382 if (turbo_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1383 if (!(mask & TEST_BBDEV_VF_EA)) 1384 printf( 1385 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1386 if (!(mask & TEST_BBDEV_VF_EB)) 1387 printf( 1388 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1389 if (!(mask & TEST_BBDEV_VF_K_NEG)) 1390 printf( 1391 "WARNING: k_neg was not specified in vector file and will be set to 0\n"); 1392 if (!(mask & TEST_BBDEV_VF_K_POS)) 1393 printf( 1394 "WARNING: k_pos was not specified in vector file and will be set to 0\n"); 1395 if (!(mask & TEST_BBDEV_VF_C_NEG)) 1396 printf( 1397 "WARNING: c_neg was not specified in vector file and will be set to 0\n"); 1398 if (!(mask & TEST_BBDEV_VF_C)) { 1399 printf( 1400 "WARNING: c was not specified in vector file and will be set to 1\n"); 1401 turbo_dec->tb_params.c = 1; 1402 } 1403 if (!(mask & TEST_BBDEV_VF_CAB)) 1404 printf( 1405 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1406 if (!(mask & TEST_BBDEV_VF_R)) 1407 printf( 1408 "WARNING: r was not specified in vector file and will be set to 0\n"); 1409 } else { 1410 if (!(mask & TEST_BBDEV_VF_E)) 1411 printf( 1412 "WARNING: e was not specified in vector file and will be set to 0\n"); 1413 if (!(mask & TEST_BBDEV_VF_K)) 1414 printf( 1415 "WARNING: k was not specified in vector file and will be set to 0\n"); 1416 } 1417 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1418 printf( 1419 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1420 if (!(mask & TEST_BBDEV_VF_ITER_MIN)) 1421 printf( 1422 "WARNING: iter_min was not specified in vector file and will be set to 0\n"); 1423 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT)) 1424 printf( 1425 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n"); 1426 if (!(mask & TEST_BBDEV_VF_EXT_SCALE)) 1427 printf( 1428 "WARNING: ext_scale was not specified in vector file and will be set to 0\n"); 1429 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1430 printf( 1431 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1432 turbo_dec->num_maps = 0; 1433 } else if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_MAP_DEC) && 1434 mask & TEST_BBDEV_VF_NUM_MAPS) { 1435 printf( 1436 "INFO: RTE_BBDEV_TURBO_MAP_DEC was not set in vector file and num_maps will be set to 0\n"); 1437 turbo_dec->num_maps = 0; 1438 } 1439 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1440 printf( 1441 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1442 return 0; 1443 } 1444 1445 /* checks LDPC decoder parameters */ 1446 static int 1447 check_ldpc_decoder(struct test_bbdev_vector *vector) 1448 { 1449 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 1450 const int mask = vector->mask; 1451 1452 if (check_ldpc_decoder_segments(vector) < 0) 1453 return -1; 1454 1455 /* 1456 * if (check_ldpc_decoder_llr_spec(vector) < 0) 1457 * return -1; 1458 * 1459 * if (check_ldpc_decoder_op_flags(vector) < 0) 1460 * return -1; 1461 */ 1462 1463 /* Check which params were set */ 1464 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1465 printf( 1466 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n"); 1467 ldpc_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK; 1468 } 1469 if (ldpc_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1470 if (!(mask & TEST_BBDEV_VF_EA)) 1471 printf( 1472 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1473 if (!(mask & TEST_BBDEV_VF_EB)) 1474 printf( 1475 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1476 if (!(mask & TEST_BBDEV_VF_C)) { 1477 printf( 1478 "WARNING: c was not specified in vector file and will be set to 1\n"); 1479 ldpc_dec->tb_params.c = 1; 1480 } 1481 if (!(mask & TEST_BBDEV_VF_CAB)) 1482 printf( 1483 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1484 if (!(mask & TEST_BBDEV_VF_R)) 1485 printf( 1486 "WARNING: r was not specified in vector file and will be set to 0\n"); 1487 } else { 1488 if (!(mask & TEST_BBDEV_VF_E)) 1489 printf( 1490 "WARNING: e was not specified in vector file and will be set to 0\n"); 1491 } 1492 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1493 printf( 1494 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1495 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT)) 1496 printf( 1497 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n"); 1498 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1499 printf( 1500 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1501 } 1502 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1503 printf( 1504 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1505 return 0; 1506 } 1507 1508 /* Checks fft parameters. */ 1509 static int 1510 check_fft(struct test_bbdev_vector *vector) 1511 { 1512 const int mask = vector->mask; 1513 1514 if (check_fft_segments(vector) < 0) 1515 return -1; 1516 1517 /* Check which params were set. */ 1518 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1519 printf( 1520 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1521 } 1522 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1523 printf( 1524 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1525 return 0; 1526 } 1527 1528 /* checks mld parameters */ 1529 static int 1530 check_mld(struct test_bbdev_vector *vector) 1531 { 1532 const int mask = vector->mask; 1533 1534 if (check_mld_segments(vector) < 0) 1535 return -1; 1536 1537 /* Check which params were set */ 1538 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1539 printf( 1540 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1541 } 1542 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1543 printf( 1544 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1545 return 0; 1546 } 1547 1548 /* checks encoder parameters */ 1549 static int 1550 check_encoder(struct test_bbdev_vector *vector) 1551 { 1552 unsigned char i; 1553 const int mask = vector->mask; 1554 1555 if (vector->entries[DATA_INPUT].nb_segments == 0) 1556 return -1; 1557 1558 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1559 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1560 return -1; 1561 1562 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1563 return -1; 1564 1565 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1566 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1567 return -1; 1568 1569 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1570 printf( 1571 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n"); 1572 vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK; 1573 } 1574 if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1575 if (!(mask & TEST_BBDEV_VF_EA) && (vector->turbo_enc.op_flags & 1576 RTE_BBDEV_TURBO_RATE_MATCH)) 1577 printf( 1578 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1579 if (!(mask & TEST_BBDEV_VF_EB) && (vector->turbo_enc.op_flags & 1580 RTE_BBDEV_TURBO_RATE_MATCH)) 1581 printf( 1582 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1583 if (!(mask & TEST_BBDEV_VF_K_NEG)) 1584 printf( 1585 "WARNING: k_neg was not specified in vector file and will be set to 0\n"); 1586 if (!(mask & TEST_BBDEV_VF_K_POS)) 1587 printf( 1588 "WARNING: k_pos was not specified in vector file and will be set to 0\n"); 1589 if (!(mask & TEST_BBDEV_VF_C_NEG)) 1590 printf( 1591 "WARNING: c_neg was not specified in vector file and will be set to 0\n"); 1592 if (!(mask & TEST_BBDEV_VF_C)) { 1593 printf( 1594 "WARNING: c was not specified in vector file and will be set to 1\n"); 1595 vector->turbo_enc.tb_params.c = 1; 1596 } 1597 if (!(mask & TEST_BBDEV_VF_CAB) && (vector->turbo_enc.op_flags & 1598 RTE_BBDEV_TURBO_RATE_MATCH)) 1599 printf( 1600 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1601 if (!(mask & TEST_BBDEV_VF_NCB_NEG)) 1602 printf( 1603 "WARNING: ncb_neg was not specified in vector file and will be set to 0\n"); 1604 if (!(mask & TEST_BBDEV_VF_NCB_POS)) 1605 printf( 1606 "WARNING: ncb_pos was not specified in vector file and will be set to 0\n"); 1607 if (!(mask & TEST_BBDEV_VF_R)) 1608 printf( 1609 "WARNING: r was not specified in vector file and will be set to 0\n"); 1610 } else { 1611 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags & 1612 RTE_BBDEV_TURBO_RATE_MATCH)) 1613 printf( 1614 "WARNING: e was not specified in vector file and will be set to 0\n"); 1615 if (!(mask & TEST_BBDEV_VF_K)) 1616 printf( 1617 "WARNING: k was not specified in vector file and will be set to 0\n"); 1618 if (!(mask & TEST_BBDEV_VF_NCB)) 1619 printf( 1620 "WARNING: ncb was not specified in vector file and will be set to 0\n"); 1621 } 1622 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1623 printf( 1624 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1625 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) 1626 printf( 1627 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n"); 1628 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1629 printf( 1630 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1631 1632 return 0; 1633 } 1634 1635 1636 /* checks encoder parameters */ 1637 static int 1638 check_ldpc_encoder(struct test_bbdev_vector *vector) 1639 { 1640 unsigned char i; 1641 const int mask = vector->mask; 1642 1643 if (vector->entries[DATA_INPUT].nb_segments == 0) 1644 return -1; 1645 1646 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1647 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1648 return -1; 1649 1650 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1651 return -1; 1652 1653 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1654 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1655 return -1; 1656 1657 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1658 printf( 1659 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n"); 1660 vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK; 1661 } 1662 if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1663 } else { 1664 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags & 1665 RTE_BBDEV_TURBO_RATE_MATCH)) 1666 printf( 1667 "WARNING: e was not specified in vector file and will be set to 0\n"); 1668 if (!(mask & TEST_BBDEV_VF_NCB)) 1669 printf( 1670 "WARNING: ncb was not specified in vector file and will be set to 0\n"); 1671 } 1672 if (!(mask & TEST_BBDEV_VF_BG)) 1673 printf( 1674 "WARNING: BG was not specified in vector file and will be set to 0\n"); 1675 if (!(mask & TEST_BBDEV_VF_ZC)) 1676 printf( 1677 "WARNING: Zc was not specified in vector file and will be set to 0\n"); 1678 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1679 printf( 1680 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1681 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) 1682 printf( 1683 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n"); 1684 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1685 printf( 1686 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1687 1688 return 0; 1689 } 1690 1691 static int 1692 bbdev_check_vector(struct test_bbdev_vector *vector) 1693 { 1694 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) { 1695 if (check_decoder(vector) == -1) 1696 return -1; 1697 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) { 1698 if (check_encoder(vector) == -1) 1699 return -1; 1700 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) { 1701 if (check_ldpc_encoder(vector) == -1) 1702 return -1; 1703 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { 1704 if (check_ldpc_decoder(vector) == -1) 1705 return -1; 1706 } else if (vector->op_type == RTE_BBDEV_OP_FFT) { 1707 if (check_fft(vector) == -1) 1708 return -1; 1709 } else if (vector->op_type == RTE_BBDEV_OP_MLDTS) { 1710 if (check_mld(vector) == -1) 1711 return -1; 1712 } else if (vector->op_type != RTE_BBDEV_OP_NONE) { 1713 printf("Vector was not filled\n"); 1714 return -1; 1715 } 1716 1717 return 0; 1718 } 1719 1720 int 1721 test_bbdev_vector_read(const char *filename, 1722 struct test_bbdev_vector *vector) 1723 { 1724 int ret = 0; 1725 size_t len = 0; 1726 1727 FILE *fp = NULL; 1728 char *line = NULL; 1729 char *entry = NULL; 1730 1731 fp = fopen(filename, "r"); 1732 if (fp == NULL) { 1733 printf("File %s does not exist\n", filename); 1734 return -1; 1735 } 1736 1737 while (getline(&line, &len, fp) != -1) { 1738 1739 /* ignore comments and new lines */ 1740 if (line[0] == '#' || line[0] == '/' || line[0] == '\n' 1741 || line[0] == '\r') 1742 continue; 1743 1744 trim_space(line); 1745 1746 /* buffer for multiline */ 1747 entry = realloc(entry, strlen(line) + 1); 1748 if (entry == NULL) { 1749 printf("Fail to realloc %zu bytes\n", strlen(line) + 1); 1750 ret = -ENOMEM; 1751 goto exit; 1752 } 1753 1754 strcpy(entry, line); 1755 1756 /* check if entry ends with , or = */ 1757 if (entry[strlen(entry) - 1] == ',' 1758 || entry[strlen(entry) - 1] == '=') { 1759 while (getline(&line, &len, fp) != -1) { 1760 trim_space(line); 1761 1762 /* extend entry about length of new line */ 1763 char *entry_extended = realloc(entry, 1764 strlen(line) + 1765 strlen(entry) + 1); 1766 1767 if (entry_extended == NULL) { 1768 printf("Fail to allocate %zu bytes\n", 1769 strlen(line) + 1770 strlen(entry) + 1); 1771 ret = -ENOMEM; 1772 goto exit; 1773 } 1774 1775 entry = entry_extended; 1776 /* entry has been allocated accordingly */ 1777 strcpy(&entry[strlen(entry)], line); 1778 1779 if (entry[strlen(entry) - 1] != ',') 1780 break; 1781 } 1782 } 1783 ret = parse_entry(entry, vector); 1784 if (ret != 0) { 1785 printf("An error occurred while parsing!\n"); 1786 goto exit; 1787 } 1788 } 1789 ret = bbdev_check_vector(vector); 1790 if (ret != 0) 1791 printf("An error occurred while checking!\n"); 1792 1793 exit: 1794 fclose(fp); 1795 free(line); 1796 free(entry); 1797 1798 return ret; 1799 } 1800