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