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