app/test-bbdev/test_bbdev_vector.c

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