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