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