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