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