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