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