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
trim_space(char * str)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
starts_with(const char * str,const char * pre)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
parse_values(char * tokens,uint32_t ** data,uint32_t * data_length)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
op_decoder_flag_strtoul(char * token,uint32_t * op_flag_value)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
op_ldpc_decoder_flag_strtoul(char * token,uint32_t * op_flag_value)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
op_encoder_flag_strtoul(char * token,uint32_t * op_flag_value)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
op_ldpc_encoder_flag_strtoul(char * token,uint32_t * op_flag_value)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
parse_turbo_flags(char * tokens,uint32_t * op_flags,enum rte_bbdev_op_type op_type)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
op_turbo_type_strtol(char * token,enum rte_bbdev_op_type * op_type)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
parse_expected_status(char * tokens,int * status,enum rte_bbdev_op_type op_type)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
parse_data_entry(const char * key_token,char * token,struct test_bbdev_vector * vector,enum op_data_type type,const char * prefix)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
parse_decoder_params(const char * key_token,char * token,struct test_bbdev_vector * vector)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
parse_encoder_params(const char * key_token,char * token,struct test_bbdev_vector * vector)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
parse_ldpc_encoder_params(const char * key_token,char * token,struct test_bbdev_vector * vector)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
parse_ldpc_decoder_params(const char * key_token,char * token,struct test_bbdev_vector * vector)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
parse_entry(char * entry,struct test_bbdev_vector * vector)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
check_decoder_segments(struct test_bbdev_vector * vector)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
check_ldpc_decoder_segments(struct test_bbdev_vector * vector)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
check_decoder_llr_spec(struct test_bbdev_vector * vector)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
check_decoder_op_flags(struct test_bbdev_vector * vector)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
check_decoder(struct test_bbdev_vector * vector)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
check_ldpc_decoder(struct test_bbdev_vector * vector)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
check_encoder(struct test_bbdev_vector * vector)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
check_ldpc_encoder(struct test_bbdev_vector * vector)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
bbdev_check_vector(struct test_bbdev_vector * vector)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
test_bbdev_vector_read(const char * filename,struct test_bbdev_vector * vector)1360 test_bbdev_vector_read(const char *filename,
1361 struct test_bbdev_vector *vector)
1362 {
1363 int ret = 0;
1364 size_t len = 0;
1365
1366 FILE *fp = NULL;
1367 char *line = NULL;
1368 char *entry = NULL;
1369
1370 fp = fopen(filename, "r");
1371 if (fp == NULL) {
1372 printf("File %s does not exist\n", filename);
1373 return -1;
1374 }
1375
1376 while (getline(&line, &len, fp) != -1) {
1377
1378 /* ignore comments and new lines */
1379 if (line[0] == '#' || line[0] == '/' || line[0] == '\n'
1380 || line[0] == '\r')
1381 continue;
1382
1383 trim_space(line);
1384
1385 /* buffer for multiline */
1386 entry = realloc(entry, strlen(line) + 1);
1387 if (entry == NULL) {
1388 printf("Fail to realloc %zu bytes\n", strlen(line) + 1);
1389 ret = -ENOMEM;
1390 goto exit;
1391 }
1392
1393 strcpy(entry, line);
1394
1395 /* check if entry ends with , or = */
1396 if (entry[strlen(entry) - 1] == ','
1397 || entry[strlen(entry) - 1] == '=') {
1398 while (getline(&line, &len, fp) != -1) {
1399 trim_space(line);
1400
1401 /* extend entry about length of new line */
1402 char *entry_extended = realloc(entry,
1403 strlen(line) +
1404 strlen(entry) + 1);
1405
1406 if (entry_extended == NULL) {
1407 printf("Fail to allocate %zu bytes\n",
1408 strlen(line) +
1409 strlen(entry) + 1);
1410 ret = -ENOMEM;
1411 goto exit;
1412 }
1413
1414 entry = entry_extended;
1415 /* entry has been allocated accordingly */
1416 strcpy(&entry[strlen(entry)], line);
1417
1418 if (entry[strlen(entry) - 1] != ',')
1419 break;
1420 }
1421 }
1422 ret = parse_entry(entry, vector);
1423 if (ret != 0) {
1424 printf("An error occurred while parsing!\n");
1425 goto exit;
1426 }
1427 }
1428 ret = bbdev_check_vector(vector);
1429 if (ret != 0)
1430 printf("An error occurred while checking!\n");
1431
1432 exit:
1433 fclose(fp);
1434 free(line);
1435 free(entry);
1436
1437 return ret;
1438 }
1439