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