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