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 (starts_with(key_token, op_data_prefixes[DATA_SOFT_OUTPUT])) 841 ret = parse_data_entry(key_token, token, vector, 842 DATA_SOFT_OUTPUT, 843 op_data_prefixes[DATA_SOFT_OUTPUT]); 844 else if (!strcmp(key_token, "e")) { 845 vector->mask |= TEST_BBDEV_VF_E; 846 ldpc_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0); 847 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 848 } else if (!strcmp(key_token, "ea")) { 849 vector->mask |= TEST_BBDEV_VF_EA; 850 ldpc_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0); 851 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 852 } else if (!strcmp(key_token, "eb")) { 853 vector->mask |= TEST_BBDEV_VF_EB; 854 ldpc_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0); 855 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 856 } else if (!strcmp(key_token, "c")) { 857 vector->mask |= TEST_BBDEV_VF_C; 858 ldpc_dec->tb_params.c = (uint8_t) strtoul(token, &err, 0); 859 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 860 } else if (!strcmp(key_token, "cab")) { 861 vector->mask |= TEST_BBDEV_VF_CAB; 862 ldpc_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0); 863 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 864 } else if (!strcmp(key_token, "rv_index")) { 865 vector->mask |= TEST_BBDEV_VF_RV_INDEX; 866 ldpc_dec->rv_index = (uint8_t) strtoul(token, &err, 0); 867 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 868 } else if (!strcmp(key_token, "n_cb")) { 869 vector->mask |= TEST_BBDEV_VF_NCB; 870 ldpc_dec->n_cb = (uint16_t) strtoul(token, &err, 0); 871 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 872 } else if (!strcmp(key_token, "r")) { 873 vector->mask |= TEST_BBDEV_VF_R; 874 ldpc_dec->tb_params.r = (uint8_t) strtoul(token, &err, 0); 875 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 876 } else if (!strcmp(key_token, "q_m")) { 877 vector->mask |= TEST_BBDEV_VF_QM; 878 ldpc_dec->q_m = (uint8_t) strtoul(token, &err, 0); 879 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 880 } else if (!strcmp(key_token, "basegraph")) { 881 vector->mask |= TEST_BBDEV_VF_BG; 882 ldpc_dec->basegraph = (uint8_t) strtoul(token, &err, 0); 883 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 884 } else if (!strcmp(key_token, "z_c")) { 885 vector->mask |= TEST_BBDEV_VF_ZC; 886 ldpc_dec->z_c = (uint16_t) strtoul(token, &err, 0); 887 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 888 } else if (!strcmp(key_token, "n_filler")) { 889 vector->mask |= TEST_BBDEV_VF_F; 890 ldpc_dec->n_filler = (uint16_t) strtoul(token, &err, 0); 891 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 892 } else if (!strcmp(key_token, "expected_iter_count")) { 893 vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT; 894 ldpc_dec->iter_count = (uint8_t) strtoul(token, &err, 0); 895 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 896 } else if (!strcmp(key_token, "code_block_mode")) { 897 vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE; 898 ldpc_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0); 899 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 900 } else if (!strcmp(key_token, "op_flags")) { 901 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 902 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 903 if (!ret) 904 ldpc_dec->op_flags = op_flags; 905 } else if (!strcmp(key_token, "expected_status")) { 906 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 907 ret = parse_expected_status(token, &status, vector->op_type); 908 if (!ret) 909 vector->expected_status = status; 910 } else { 911 printf("Not valid ldpc dec key: '%s'\n", key_token); 912 return -1; 913 } 914 915 if (ret != 0) { 916 printf("Failed with convert '%s\t%s'\n", key_token, token); 917 return -1; 918 } 919 920 return 0; 921 } 922 923 /* Parses FFT parameters and assigns to global variable. */ 924 static int 925 parse_fft_params(const char *key_token, char *token, 926 struct test_bbdev_vector *vector) 927 { 928 int ret = 0, status = 0, i, shift; 929 uint32_t op_flags = 0; 930 char *tok, *err = NULL; 931 932 struct rte_bbdev_op_fft *fft = &vector->fft; 933 934 if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) { 935 ret = parse_data_entry(key_token, token, vector, 936 DATA_INPUT, 937 op_data_prefixes[DATA_INPUT]); 938 } else if (starts_with(key_token, "dewin_input")) { 939 ret = parse_data_entry(key_token, token, vector, 940 DATA_HARQ_INPUT, 941 "dewin_input"); 942 } else if (starts_with(key_token, "output")) { 943 ret = parse_data_entry(key_token, token, vector, 944 DATA_HARD_OUTPUT, 945 "output"); 946 } else if (starts_with(key_token, "power_output")) { 947 ret = parse_data_entry(key_token, token, vector, 948 DATA_SOFT_OUTPUT, 949 "power_output"); 950 } else if (!strcmp(key_token, "in_sequence_size")) { 951 fft->input_sequence_size = (uint32_t) strtoul(token, &err, 0); 952 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 953 } else if (!strcmp(key_token, "in_leading_padding")) { 954 fft->input_leading_padding = (uint32_t) strtoul(token, &err, 0); 955 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 956 } else if (!strcmp(key_token, "out_sequence_size")) { 957 fft->output_sequence_size = (uint32_t) strtoul(token, &err, 0); 958 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 959 } else if (!strcmp(key_token, "out_leading_depadding")) { 960 fft->output_leading_depadding = (uint32_t) strtoul(token, &err, 0); 961 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 962 } else if (!strcmp(key_token, "window_index")) { 963 tok = strtok(token, VALUE_DELIMITER); 964 if (tok == NULL) 965 return -1; 966 for (i = 0; i < FFT_WIN_SIZE; i++) { 967 shift = (i % 2) ? 4 : 0; 968 fft->window_index[i / 2] |= (uint32_t) strtoul(tok, &err, 0) 969 << shift; 970 if (i < (FFT_WIN_SIZE - 1)) { 971 tok = strtok(NULL, VALUE_DELIMITER); 972 if (tok == NULL) 973 return -1; 974 } 975 } 976 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 977 } else if (!strcmp(key_token, "cs_bitmap")) { 978 fft->cs_bitmap = (uint32_t) strtoul(token, &err, 0); 979 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 980 } else if (!strcmp(key_token, "num_antennas_log2")) { 981 fft->num_antennas_log2 = (uint32_t) strtoul(token, &err, 0); 982 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 983 } else if (!strcmp(key_token, "ifft_log2")) { 984 fft->idft_log2 = (uint32_t) strtoul(token, &err, 0); 985 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 986 } else if (!strcmp(key_token, "fft_log2")) { 987 fft->dft_log2 = (uint32_t) strtoul(token, &err, 0); 988 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 989 } else if (!strcmp(key_token, "cs_time_adjustment")) { 990 fft->cs_time_adjustment = (uint32_t) strtoul(token, &err, 0); 991 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 992 } else if (!strcmp(key_token, "ifft_shift")) { 993 fft->idft_shift = (uint32_t) strtoul(token, &err, 0); 994 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 995 } else if (!strcmp(key_token, "fft_shift")) { 996 fft->dft_shift = (uint32_t) strtoul(token, &err, 0); 997 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 998 } else if (!strcmp(key_token, "ncs_reciprocal")) { 999 fft->ncs_reciprocal = (uint32_t) strtoul(token, &err, 0); 1000 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1001 } else if (!strcmp(key_token, "power_shift")) { 1002 fft->power_shift = (uint32_t) strtoul(token, &err, 0); 1003 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1004 } else if (!strcmp(key_token, "fp16_exponent_adjust")) { 1005 fft->fp16_exp_adjust = (uint32_t) strtoul(token, &err, 0); 1006 printf("%d\n", fft->fp16_exp_adjust); 1007 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1008 } else if (!strcmp(key_token, "freq_resample_mode")) { 1009 fft->freq_resample_mode = (uint32_t) strtoul(token, &err, 0); 1010 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1011 } else if (!strcmp(key_token, "out_depadded_size")) { 1012 fft->output_depadded_size = (uint32_t) strtoul(token, &err, 0); 1013 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1014 } else if (!strcmp(key_token, "cs_theta_0")) { 1015 tok = strtok(token, VALUE_DELIMITER); 1016 if (tok == NULL) 1017 return -1; 1018 for (i = 0; i < FFT_WIN_SIZE; i++) { 1019 fft->cs_theta_0[i] = (uint32_t) strtoul(tok, &err, 0); 1020 if (i < (FFT_WIN_SIZE - 1)) { 1021 tok = strtok(NULL, VALUE_DELIMITER); 1022 if (tok == NULL) 1023 return -1; 1024 } 1025 } 1026 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1027 } else if (!strcmp(key_token, "cs_theta_d")) { 1028 tok = strtok(token, VALUE_DELIMITER); 1029 if (tok == NULL) 1030 return -1; 1031 for (i = 0; i < FFT_WIN_SIZE; i++) { 1032 fft->cs_theta_d[i] = (uint32_t) strtoul(tok, &err, 0); 1033 if (i < (FFT_WIN_SIZE - 1)) { 1034 tok = strtok(NULL, VALUE_DELIMITER); 1035 if (tok == NULL) 1036 return -1; 1037 } 1038 } 1039 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1040 } else if (!strcmp(key_token, "time_offset")) { 1041 tok = strtok(token, VALUE_DELIMITER); 1042 if (tok == NULL) 1043 return -1; 1044 for (i = 0; i < FFT_WIN_SIZE; i++) { 1045 fft->time_offset[i] = (uint32_t) strtoul(tok, &err, 0); 1046 if (i < (FFT_WIN_SIZE - 1)) { 1047 tok = strtok(NULL, VALUE_DELIMITER); 1048 if (tok == NULL) 1049 return -1; 1050 } 1051 } 1052 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1053 } else if (!strcmp(key_token, "fft_window_width")) { 1054 tok = strtok(token, VALUE_DELIMITER); 1055 if (tok == NULL) 1056 return -1; 1057 for (i = 0; i < FFT_WIN_SIZE; i++) { 1058 if (i == 0) 1059 vector->fft_window_width_vec = (uint32_t) strtoul(tok, &err, 0); 1060 if (i < (FFT_WIN_SIZE - 1)) { 1061 tok = strtok(NULL, VALUE_DELIMITER); 1062 if (tok == NULL) 1063 return -1; 1064 } 1065 } 1066 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1067 } else if (!strcmp(key_token, "op_flags")) { 1068 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 1069 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 1070 if (!ret) 1071 fft->op_flags = op_flags; 1072 } else if (!strcmp(key_token, "expected_status")) { 1073 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 1074 ret = parse_expected_status(token, &status, vector->op_type); 1075 if (!ret) 1076 vector->expected_status = status; 1077 } else { 1078 printf("Not valid fft key: '%s'\n", key_token); 1079 return -1; 1080 } 1081 1082 if (ret != 0) { 1083 printf("Failed with convert '%s\t%s'\n", key_token, token); 1084 return -1; 1085 } 1086 1087 return 0; 1088 } 1089 1090 /* parses MLD parameters and assigns to global variable */ 1091 static int 1092 parse_mld_params(const char *key_token, char *token, 1093 struct test_bbdev_vector *vector) 1094 { 1095 int ret = 0, status = 0; 1096 uint32_t op_flags = 0; 1097 char *err = NULL; 1098 1099 struct rte_bbdev_op_mldts *mld = &vector->mldts; 1100 1101 if (starts_with(key_token, "qhy_input")) { 1102 ret = parse_data_entry(key_token, token, vector, 1103 DATA_INPUT, "qhy_input"); 1104 } else if (starts_with(key_token, "r_input")) { 1105 ret = parse_data_entry(key_token, token, vector, 1106 DATA_HARQ_INPUT, "r_input"); 1107 } else if (starts_with(key_token, "output")) { 1108 ret = parse_data_entry(key_token, token, vector, 1109 DATA_HARD_OUTPUT, "output"); 1110 } else if (!strcmp(key_token, "layers")) { 1111 mld->num_layers = (uint32_t) strtoul(token, &err, 0); 1112 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1113 } else if (!strcmp(key_token, "layer1")) { 1114 mld->q_m[0] = (uint32_t) strtoul(token, &err, 0); 1115 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1116 } else if (!strcmp(key_token, "layer2")) { 1117 mld->q_m[1] = (uint32_t) strtoul(token, &err, 0); 1118 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1119 } else if (!strcmp(key_token, "layer3")) { 1120 mld->q_m[2] = (uint32_t) strtoul(token, &err, 0); 1121 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1122 } else if (!strcmp(key_token, "layer4")) { 1123 mld->q_m[3] = (uint32_t) strtoul(token, &err, 0); 1124 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1125 } else if (!strcmp(key_token, "crep")) { 1126 mld->c_rep = (uint32_t) strtoul(token, &err, 0); 1127 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1128 } else if (!strcmp(key_token, "rrep")) { 1129 mld->r_rep = (uint32_t) strtoul(token, &err, 0); 1130 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1131 } else if (!strcmp(key_token, "rbs")) { 1132 mld->num_rbs = (uint32_t) strtoul(token, &err, 0); 1133 ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; 1134 } else if (!strcmp(key_token, "op_flags")) { 1135 vector->mask |= TEST_BBDEV_VF_OP_FLAGS; 1136 ret = parse_turbo_flags(token, &op_flags, vector->op_type); 1137 if (!ret) 1138 mld->op_flags = op_flags; 1139 } else if (!strcmp(key_token, "expected_status")) { 1140 vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; 1141 ret = parse_expected_status(token, &status, vector->op_type); 1142 if (!ret) 1143 vector->expected_status = status; 1144 } else { 1145 printf("Not valid mld key: '%s'\n", key_token); 1146 return -1; 1147 } 1148 1149 if (ret != 0) { 1150 printf("Failed with convert '%s\t%s'\n", key_token, token); 1151 return -1; 1152 } 1153 1154 return 0; 1155 } 1156 1157 /* checks the type of key and assigns data */ 1158 static int 1159 parse_entry(char *entry, struct test_bbdev_vector *vector) 1160 { 1161 int ret = 0; 1162 char *token, *key_token; 1163 enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_NONE; 1164 1165 if (entry == NULL) { 1166 printf("Expected entry value\n"); 1167 return -1; 1168 } 1169 1170 /* get key */ 1171 token = strtok(entry, ENTRY_DELIMITER); 1172 key_token = token; 1173 /* get values for key */ 1174 token = strtok(NULL, ENTRY_DELIMITER); 1175 1176 if (key_token == NULL || token == NULL) { 1177 printf("Expected 'key = values' but was '%.40s'..\n", entry); 1178 return -1; 1179 } 1180 trim_space(key_token); 1181 1182 /* first key_token has to specify type of operation */ 1183 if (vector->op_type == RTE_BBDEV_OP_NONE) { 1184 if (!strcmp(key_token, "op_type")) { 1185 ret = op_turbo_type_strtol(token, &op_type); 1186 if (!ret) 1187 vector->op_type = op_type; 1188 return (!ret) ? 0 : -1; 1189 } 1190 printf("First key_token (%s) does not specify op_type\n", 1191 key_token); 1192 return -1; 1193 } 1194 1195 /* compare keys */ 1196 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) { 1197 if (parse_decoder_params(key_token, token, vector) == -1) 1198 return -1; 1199 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) { 1200 if (parse_encoder_params(key_token, token, vector) == -1) 1201 return -1; 1202 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) { 1203 if (parse_ldpc_encoder_params(key_token, token, vector) == -1) 1204 return -1; 1205 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { 1206 if (parse_ldpc_decoder_params(key_token, token, vector) == -1) 1207 return -1; 1208 } else if (vector->op_type == RTE_BBDEV_OP_FFT) { 1209 if (parse_fft_params(key_token, token, vector) == -1) 1210 return -1; 1211 } else if (vector->op_type == RTE_BBDEV_OP_MLDTS) { 1212 if (parse_mld_params(key_token, token, vector) == -1) 1213 return -1; 1214 } 1215 1216 return 0; 1217 } 1218 1219 static int 1220 check_decoder_segments(struct test_bbdev_vector *vector) 1221 { 1222 unsigned char i; 1223 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1224 1225 if (vector->entries[DATA_INPUT].nb_segments == 0) 1226 return -1; 1227 1228 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1229 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1230 return -1; 1231 1232 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1233 return -1; 1234 1235 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; 1236 i++) 1237 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1238 return -1; 1239 1240 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT) && 1241 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0)) 1242 return -1; 1243 1244 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; 1245 i++) 1246 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL) 1247 return -1; 1248 1249 return 0; 1250 } 1251 1252 static int 1253 check_ldpc_decoder_segments(struct test_bbdev_vector *vector) 1254 { 1255 unsigned char i; 1256 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 1257 1258 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1259 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1260 return -1; 1261 1262 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1263 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1264 return -1; 1265 1266 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_SOFT_OUT_ENABLE) && 1267 (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0)) 1268 return -1; 1269 1270 for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; i++) 1271 if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL) 1272 return -1; 1273 1274 if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE) && 1275 (vector->entries[DATA_HARQ_OUTPUT].nb_segments == 0)) 1276 return -1; 1277 1278 for (i = 0; i < vector->entries[DATA_HARQ_OUTPUT].nb_segments; i++) 1279 if (vector->entries[DATA_HARQ_OUTPUT].segments[i].addr == NULL) 1280 return -1; 1281 1282 return 0; 1283 } 1284 1285 static int 1286 check_fft_segments(struct test_bbdev_vector *vector) 1287 { 1288 unsigned char i; 1289 1290 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1291 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1292 return -1; 1293 1294 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1295 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1296 return -1; 1297 return 0; 1298 } 1299 1300 static int 1301 check_mld_segments(struct test_bbdev_vector *vector) 1302 { 1303 unsigned char i; 1304 1305 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1306 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1307 return -1; 1308 1309 for (i = 0; i < vector->entries[DATA_HARQ_INPUT].nb_segments; i++) 1310 if (vector->entries[DATA_HARQ_INPUT].segments[i].addr == NULL) 1311 return -1; 1312 1313 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1314 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1315 return -1; 1316 return 0; 1317 } 1318 1319 static int 1320 check_decoder_llr_spec(struct test_bbdev_vector *vector) 1321 { 1322 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1323 1324 /* Check input LLR sign formalism specification */ 1325 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) && 1326 (turbo_dec->op_flags & 1327 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) { 1328 printf( 1329 "Both positive and negative LLR input flags were set!\n"); 1330 return -1; 1331 } 1332 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) && 1333 !(turbo_dec->op_flags & 1334 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) { 1335 printf( 1336 "INFO: input LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n"); 1337 turbo_dec->op_flags |= RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN; 1338 } 1339 1340 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT)) 1341 return 0; 1342 1343 /* Check output LLR sign formalism specification */ 1344 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) && 1345 (turbo_dec->op_flags & 1346 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) { 1347 printf( 1348 "Both positive and negative LLR output flags were set!\n"); 1349 return -1; 1350 } 1351 if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) && 1352 !(turbo_dec->op_flags & 1353 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) { 1354 printf( 1355 "INFO: soft output LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n"); 1356 turbo_dec->op_flags |= 1357 RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT; 1358 } 1359 1360 return 0; 1361 } 1362 1363 static int 1364 check_decoder_op_flags(struct test_bbdev_vector *vector) 1365 { 1366 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1367 1368 if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP) && 1369 !(turbo_dec->op_flags & RTE_BBDEV_TURBO_CRC_TYPE_24B)) { 1370 printf( 1371 "WARNING: RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP flag is missing RTE_BBDEV_TURBO_CRC_TYPE_24B\n"); 1372 return -1; 1373 } 1374 1375 return 0; 1376 } 1377 1378 /* checks decoder parameters */ 1379 static int 1380 check_decoder(struct test_bbdev_vector *vector) 1381 { 1382 struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec; 1383 const int mask = vector->mask; 1384 1385 if (check_decoder_segments(vector) < 0) 1386 return -1; 1387 1388 if (check_decoder_llr_spec(vector) < 0) 1389 return -1; 1390 1391 if (check_decoder_op_flags(vector) < 0) 1392 return -1; 1393 1394 /* Check which params were set */ 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 (0 - TB Mode, 1 - CB mode)\n"); 1398 turbo_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK; 1399 } 1400 if (turbo_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1401 if (!(mask & TEST_BBDEV_VF_EA)) 1402 printf( 1403 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1404 if (!(mask & TEST_BBDEV_VF_EB)) 1405 printf( 1406 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1407 if (!(mask & TEST_BBDEV_VF_K_NEG)) 1408 printf( 1409 "WARNING: k_neg was not specified in vector file and will be set to 0\n"); 1410 if (!(mask & TEST_BBDEV_VF_K_POS)) 1411 printf( 1412 "WARNING: k_pos was not specified in vector file and will be set to 0\n"); 1413 if (!(mask & TEST_BBDEV_VF_C_NEG)) 1414 printf( 1415 "WARNING: c_neg was not specified in vector file and will be set to 0\n"); 1416 if (!(mask & TEST_BBDEV_VF_C)) { 1417 printf( 1418 "WARNING: c was not specified in vector file and will be set to 1\n"); 1419 turbo_dec->tb_params.c = 1; 1420 } 1421 if (!(mask & TEST_BBDEV_VF_CAB)) 1422 printf( 1423 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1424 if (!(mask & TEST_BBDEV_VF_R)) 1425 printf( 1426 "WARNING: r was not specified in vector file and will be set to 0\n"); 1427 } else { 1428 if (!(mask & TEST_BBDEV_VF_E)) 1429 printf( 1430 "WARNING: e was not specified in vector file and will be set to 0\n"); 1431 if (!(mask & TEST_BBDEV_VF_K)) 1432 printf( 1433 "WARNING: k was not specified in vector file and will be set to 0\n"); 1434 } 1435 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1436 printf( 1437 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1438 if (!(mask & TEST_BBDEV_VF_ITER_MIN)) 1439 printf( 1440 "WARNING: iter_min was not specified in vector file and will be set to 0\n"); 1441 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT)) 1442 printf( 1443 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n"); 1444 if (!(mask & TEST_BBDEV_VF_EXT_SCALE)) 1445 printf( 1446 "WARNING: ext_scale was not specified in vector file and will be set to 0\n"); 1447 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1448 printf( 1449 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1450 turbo_dec->num_maps = 0; 1451 } else if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_MAP_DEC) && 1452 mask & TEST_BBDEV_VF_NUM_MAPS) { 1453 printf( 1454 "INFO: RTE_BBDEV_TURBO_MAP_DEC was not set in vector file and num_maps will be set to 0\n"); 1455 turbo_dec->num_maps = 0; 1456 } 1457 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1458 printf( 1459 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1460 return 0; 1461 } 1462 1463 /* checks LDPC decoder parameters */ 1464 static int 1465 check_ldpc_decoder(struct test_bbdev_vector *vector) 1466 { 1467 struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec; 1468 const int mask = vector->mask; 1469 1470 if (check_ldpc_decoder_segments(vector) < 0) 1471 return -1; 1472 1473 /* 1474 * if (check_ldpc_decoder_llr_spec(vector) < 0) 1475 * return -1; 1476 * 1477 * if (check_ldpc_decoder_op_flags(vector) < 0) 1478 * return -1; 1479 */ 1480 1481 /* Check which params were set */ 1482 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1483 printf( 1484 "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n"); 1485 ldpc_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK; 1486 } 1487 if (ldpc_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1488 if (!(mask & TEST_BBDEV_VF_EA)) 1489 printf( 1490 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1491 if (!(mask & TEST_BBDEV_VF_EB)) 1492 printf( 1493 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1494 if (!(mask & TEST_BBDEV_VF_C)) { 1495 printf( 1496 "WARNING: c was not specified in vector file and will be set to 1\n"); 1497 ldpc_dec->tb_params.c = 1; 1498 } 1499 if (!(mask & TEST_BBDEV_VF_CAB)) 1500 printf( 1501 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1502 if (!(mask & TEST_BBDEV_VF_R)) 1503 printf( 1504 "WARNING: r was not specified in vector file and will be set to 0\n"); 1505 } else { 1506 if (!(mask & TEST_BBDEV_VF_E)) 1507 printf( 1508 "WARNING: e was not specified in vector file and will be set to 0\n"); 1509 } 1510 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1511 printf( 1512 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1513 if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT)) 1514 printf( 1515 "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n"); 1516 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1517 printf( 1518 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1519 } 1520 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1521 printf( 1522 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1523 return 0; 1524 } 1525 1526 /* Checks fft parameters. */ 1527 static int 1528 check_fft(struct test_bbdev_vector *vector) 1529 { 1530 const int mask = vector->mask; 1531 1532 if (check_fft_segments(vector) < 0) 1533 return -1; 1534 1535 /* Check which params were set. */ 1536 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1537 printf( 1538 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1539 } 1540 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1541 printf( 1542 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1543 return 0; 1544 } 1545 1546 /* checks mld parameters */ 1547 static int 1548 check_mld(struct test_bbdev_vector *vector) 1549 { 1550 const int mask = vector->mask; 1551 1552 if (check_mld_segments(vector) < 0) 1553 return -1; 1554 1555 /* Check which params were set */ 1556 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { 1557 printf( 1558 "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); 1559 } 1560 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1561 printf( 1562 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1563 return 0; 1564 } 1565 1566 /* checks encoder parameters */ 1567 static int 1568 check_encoder(struct test_bbdev_vector *vector) 1569 { 1570 unsigned char i; 1571 const int mask = vector->mask; 1572 1573 if (vector->entries[DATA_INPUT].nb_segments == 0) 1574 return -1; 1575 1576 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1577 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1578 return -1; 1579 1580 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1581 return -1; 1582 1583 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1584 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1585 return -1; 1586 1587 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1588 printf( 1589 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n"); 1590 vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK; 1591 } 1592 if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1593 if (!(mask & TEST_BBDEV_VF_EA) && (vector->turbo_enc.op_flags & 1594 RTE_BBDEV_TURBO_RATE_MATCH)) 1595 printf( 1596 "WARNING: ea was not specified in vector file and will be set to 0\n"); 1597 if (!(mask & TEST_BBDEV_VF_EB) && (vector->turbo_enc.op_flags & 1598 RTE_BBDEV_TURBO_RATE_MATCH)) 1599 printf( 1600 "WARNING: eb was not specified in vector file and will be set to 0\n"); 1601 if (!(mask & TEST_BBDEV_VF_K_NEG)) 1602 printf( 1603 "WARNING: k_neg was not specified in vector file and will be set to 0\n"); 1604 if (!(mask & TEST_BBDEV_VF_K_POS)) 1605 printf( 1606 "WARNING: k_pos was not specified in vector file and will be set to 0\n"); 1607 if (!(mask & TEST_BBDEV_VF_C_NEG)) 1608 printf( 1609 "WARNING: c_neg was not specified in vector file and will be set to 0\n"); 1610 if (!(mask & TEST_BBDEV_VF_C)) { 1611 printf( 1612 "WARNING: c was not specified in vector file and will be set to 1\n"); 1613 vector->turbo_enc.tb_params.c = 1; 1614 } 1615 if (!(mask & TEST_BBDEV_VF_CAB) && (vector->turbo_enc.op_flags & 1616 RTE_BBDEV_TURBO_RATE_MATCH)) 1617 printf( 1618 "WARNING: cab was not specified in vector file and will be set to 0\n"); 1619 if (!(mask & TEST_BBDEV_VF_NCB_NEG)) 1620 printf( 1621 "WARNING: ncb_neg was not specified in vector file and will be set to 0\n"); 1622 if (!(mask & TEST_BBDEV_VF_NCB_POS)) 1623 printf( 1624 "WARNING: ncb_pos was not specified in vector file and will be set to 0\n"); 1625 if (!(mask & TEST_BBDEV_VF_R)) 1626 printf( 1627 "WARNING: r was not specified in vector file and will be set to 0\n"); 1628 } else { 1629 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags & 1630 RTE_BBDEV_TURBO_RATE_MATCH)) 1631 printf( 1632 "WARNING: e was not specified in vector file and will be set to 0\n"); 1633 if (!(mask & TEST_BBDEV_VF_K)) 1634 printf( 1635 "WARNING: k was not specified in vector file and will be set to 0\n"); 1636 if (!(mask & TEST_BBDEV_VF_NCB)) 1637 printf( 1638 "WARNING: ncb was not specified in vector file and will be set to 0\n"); 1639 } 1640 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1641 printf( 1642 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1643 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) 1644 printf( 1645 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n"); 1646 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1647 printf( 1648 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1649 1650 return 0; 1651 } 1652 1653 1654 /* checks encoder parameters */ 1655 static int 1656 check_ldpc_encoder(struct test_bbdev_vector *vector) 1657 { 1658 unsigned char i; 1659 const int mask = vector->mask; 1660 1661 if (vector->entries[DATA_INPUT].nb_segments == 0) 1662 return -1; 1663 1664 for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) 1665 if (vector->entries[DATA_INPUT].segments[i].addr == NULL) 1666 return -1; 1667 1668 if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0) 1669 return -1; 1670 1671 for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) 1672 if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) 1673 return -1; 1674 1675 if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) { 1676 printf( 1677 "WARNING: code_block_mode was not specified in vector file and will be set to 1\n"); 1678 vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK; 1679 } 1680 if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) { 1681 } else { 1682 if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags & 1683 RTE_BBDEV_TURBO_RATE_MATCH)) 1684 printf( 1685 "WARNING: e was not specified in vector file and will be set to 0\n"); 1686 if (!(mask & TEST_BBDEV_VF_NCB)) 1687 printf( 1688 "WARNING: ncb was not specified in vector file and will be set to 0\n"); 1689 } 1690 if (!(mask & TEST_BBDEV_VF_BG)) 1691 printf( 1692 "WARNING: BG was not specified in vector file and will be set to 0\n"); 1693 if (!(mask & TEST_BBDEV_VF_ZC)) 1694 printf( 1695 "WARNING: Zc was not specified in vector file and will be set to 0\n"); 1696 if (!(mask & TEST_BBDEV_VF_RV_INDEX)) 1697 printf( 1698 "INFO: rv_index was not specified in vector file and will be set to 0\n"); 1699 if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) 1700 printf( 1701 "INFO: op_flags was not specified in vector file and capabilities will not be validated\n"); 1702 if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) 1703 printf( 1704 "WARNING: expected_status was not specified in vector file and will be set to 0\n"); 1705 1706 return 0; 1707 } 1708 1709 static int 1710 bbdev_check_vector(struct test_bbdev_vector *vector) 1711 { 1712 if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) { 1713 if (check_decoder(vector) == -1) 1714 return -1; 1715 } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) { 1716 if (check_encoder(vector) == -1) 1717 return -1; 1718 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) { 1719 if (check_ldpc_encoder(vector) == -1) 1720 return -1; 1721 } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { 1722 if (check_ldpc_decoder(vector) == -1) 1723 return -1; 1724 } else if (vector->op_type == RTE_BBDEV_OP_FFT) { 1725 if (check_fft(vector) == -1) 1726 return -1; 1727 } else if (vector->op_type == RTE_BBDEV_OP_MLDTS) { 1728 if (check_mld(vector) == -1) 1729 return -1; 1730 } else if (vector->op_type != RTE_BBDEV_OP_NONE) { 1731 printf("Vector was not filled\n"); 1732 return -1; 1733 } 1734 1735 return 0; 1736 } 1737 1738 int 1739 test_bbdev_vector_read(const char *filename, 1740 struct test_bbdev_vector *vector) 1741 { 1742 int ret = 0; 1743 size_t len = 0; 1744 1745 FILE *fp = NULL; 1746 char *line = NULL; 1747 char *entry = NULL; 1748 1749 fp = fopen(filename, "r"); 1750 if (fp == NULL) { 1751 printf("File %s does not exist\n", filename); 1752 return -1; 1753 } 1754 1755 while (getline(&line, &len, fp) != -1) { 1756 1757 /* ignore comments and new lines */ 1758 if (line[0] == '#' || line[0] == '/' || line[0] == '\n' 1759 || line[0] == '\r') 1760 continue; 1761 1762 trim_space(line); 1763 1764 /* buffer for multiline */ 1765 entry = realloc(entry, strlen(line) + 1); 1766 if (entry == NULL) { 1767 printf("Fail to realloc %zu bytes\n", strlen(line) + 1); 1768 ret = -ENOMEM; 1769 goto exit; 1770 } 1771 1772 strcpy(entry, line); 1773 1774 /* check if entry ends with , or = */ 1775 if (entry[strlen(entry) - 1] == ',' 1776 || entry[strlen(entry) - 1] == '=') { 1777 while (getline(&line, &len, fp) != -1) { 1778 trim_space(line); 1779 1780 /* extend entry about length of new line */ 1781 char *entry_extended = realloc(entry, 1782 strlen(line) + 1783 strlen(entry) + 1); 1784 1785 if (entry_extended == NULL) { 1786 printf("Fail to allocate %zu bytes\n", 1787 strlen(line) + 1788 strlen(entry) + 1); 1789 ret = -ENOMEM; 1790 goto exit; 1791 } 1792 1793 entry = entry_extended; 1794 /* entry has been allocated accordingly */ 1795 strcpy(&entry[strlen(entry)], line); 1796 1797 if (entry[strlen(entry) - 1] != ',') 1798 break; 1799 } 1800 } 1801 ret = parse_entry(entry, vector); 1802 if (ret != 0) { 1803 printf("An error occurred while parsing!\n"); 1804 goto exit; 1805 } 1806 } 1807 ret = bbdev_check_vector(vector); 1808 if (ret != 0) 1809 printf("An error occurred while checking!\n"); 1810 1811 exit: 1812 fclose(fp); 1813 free(line); 1814 free(entry); 1815 1816 return ret; 1817 } 1818