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 (starts_with(key_token, op_data_prefixes[DATA_SOFT_OUTPUT]))
841 : 0 : ret = parse_data_entry(key_token, token, vector,
842 : : DATA_SOFT_OUTPUT,
843 : : op_data_prefixes[DATA_SOFT_OUTPUT]);
844 : 0 : else if (!strcmp(key_token, "e")) {
845 : 0 : vector->mask |= TEST_BBDEV_VF_E;
846 : 0 : ldpc_dec->cb_params.e = (uint32_t) strtoul(token, &err, 0);
847 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
848 : 0 : } else if (!strcmp(key_token, "ea")) {
849 : 0 : vector->mask |= TEST_BBDEV_VF_EA;
850 : 0 : ldpc_dec->tb_params.ea = (uint32_t) strtoul(token, &err, 0);
851 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
852 : 0 : } else if (!strcmp(key_token, "eb")) {
853 : 0 : vector->mask |= TEST_BBDEV_VF_EB;
854 : 0 : ldpc_dec->tb_params.eb = (uint32_t) strtoul(token, &err, 0);
855 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
856 : 0 : } else if (!strcmp(key_token, "c")) {
857 : 0 : vector->mask |= TEST_BBDEV_VF_C;
858 : 0 : ldpc_dec->tb_params.c = (uint8_t) strtoul(token, &err, 0);
859 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
860 : 0 : } else if (!strcmp(key_token, "cab")) {
861 : 0 : vector->mask |= TEST_BBDEV_VF_CAB;
862 : 0 : ldpc_dec->tb_params.cab = (uint8_t) strtoul(token, &err, 0);
863 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
864 : 0 : } else if (!strcmp(key_token, "rv_index")) {
865 : 0 : vector->mask |= TEST_BBDEV_VF_RV_INDEX;
866 : 0 : ldpc_dec->rv_index = (uint8_t) strtoul(token, &err, 0);
867 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
868 : 0 : } else if (!strcmp(key_token, "k0")) {
869 : 0 : vector->mask |= TEST_BBDEV_VF_K0;
870 : 0 : ldpc_dec->k0 = (uint16_t) strtoul(token, &err, 0);
871 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
872 : 0 : } else if (!strcmp(key_token, "n_cb")) {
873 : 0 : vector->mask |= TEST_BBDEV_VF_NCB;
874 : 0 : ldpc_dec->n_cb = (uint16_t) strtoul(token, &err, 0);
875 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
876 : 0 : } else if (!strcmp(key_token, "r")) {
877 : 0 : vector->mask |= TEST_BBDEV_VF_R;
878 : 0 : ldpc_dec->tb_params.r = (uint8_t) strtoul(token, &err, 0);
879 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
880 : 0 : } else if (!strcmp(key_token, "q_m")) {
881 : 0 : vector->mask |= TEST_BBDEV_VF_QM;
882 : 0 : ldpc_dec->q_m = (uint8_t) strtoul(token, &err, 0);
883 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
884 : 0 : } else if (!strcmp(key_token, "basegraph")) {
885 : 0 : vector->mask |= TEST_BBDEV_VF_BG;
886 : 0 : ldpc_dec->basegraph = (uint8_t) strtoul(token, &err, 0);
887 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
888 : 0 : } else if (!strcmp(key_token, "z_c")) {
889 : 0 : vector->mask |= TEST_BBDEV_VF_ZC;
890 : 0 : ldpc_dec->z_c = (uint16_t) strtoul(token, &err, 0);
891 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
892 : 0 : } else if (!strcmp(key_token, "n_filler")) {
893 : 0 : vector->mask |= TEST_BBDEV_VF_F;
894 : 0 : ldpc_dec->n_filler = (uint16_t) strtoul(token, &err, 0);
895 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
896 : 0 : } else if (!strcmp(key_token, "expected_iter_count")) {
897 : 0 : vector->mask |= TEST_BBDEV_VF_EXPECTED_ITER_COUNT;
898 : 0 : ldpc_dec->iter_count = (uint8_t) strtoul(token, &err, 0);
899 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
900 : 0 : } else if (!strcmp(key_token, "code_block_mode")) {
901 : 0 : vector->mask |= TEST_BBDEV_VF_CODE_BLOCK_MODE;
902 : 0 : ldpc_dec->code_block_mode = (uint8_t) strtoul(token, &err, 0);
903 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
904 : 0 : } else if (!strcmp(key_token, "op_flags")) {
905 : 0 : vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
906 : 0 : ret = parse_turbo_flags(token, &op_flags, vector->op_type);
907 : 0 : if (!ret)
908 : 0 : ldpc_dec->op_flags = op_flags;
909 : 0 : } else if (!strcmp(key_token, "expected_status")) {
910 : 0 : vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
911 : 0 : ret = parse_expected_status(token, &status, vector->op_type);
912 : 0 : if (!ret)
913 : 0 : vector->expected_status = status;
914 : : } else {
915 : : printf("Not valid ldpc dec key: '%s'\n", key_token);
916 : 0 : return -1;
917 : : }
918 : :
919 : 0 : if (ret != 0) {
920 : : printf("Failed with convert '%s\t%s'\n", key_token, token);
921 : 0 : return -1;
922 : : }
923 : :
924 : : return 0;
925 : : }
926 : :
927 : : /* Parses FFT parameters and assigns to global variable. */
928 : : static int
929 : 0 : parse_fft_params(const char *key_token, char *token,
930 : : struct test_bbdev_vector *vector)
931 : : {
932 : 0 : int ret = 0, status = 0, i, shift;
933 : 0 : uint32_t op_flags = 0;
934 : 0 : char *tok, *err = NULL;
935 : :
936 : : struct rte_bbdev_op_fft *fft = &vector->fft;
937 : :
938 : 0 : if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) {
939 : 0 : ret = parse_data_entry(key_token, token, vector,
940 : : DATA_INPUT,
941 : : op_data_prefixes[DATA_INPUT]);
942 : 0 : } else if (starts_with(key_token, "dewin_input")) {
943 : 0 : ret = parse_data_entry(key_token, token, vector,
944 : : DATA_HARQ_INPUT,
945 : : "dewin_input");
946 : 0 : } else if (starts_with(key_token, "output")) {
947 : 0 : ret = parse_data_entry(key_token, token, vector,
948 : : DATA_HARD_OUTPUT,
949 : : "output");
950 : 0 : } else if (starts_with(key_token, "power_output")) {
951 : 0 : ret = parse_data_entry(key_token, token, vector,
952 : : DATA_SOFT_OUTPUT,
953 : : "power_output");
954 : 0 : } else if (!strcmp(key_token, "in_sequence_size")) {
955 : 0 : fft->input_sequence_size = (uint32_t) strtoul(token, &err, 0);
956 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
957 : 0 : } else if (!strcmp(key_token, "in_leading_padding")) {
958 : 0 : fft->input_leading_padding = (uint32_t) strtoul(token, &err, 0);
959 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
960 : 0 : } else if (!strcmp(key_token, "out_sequence_size")) {
961 : 0 : fft->output_sequence_size = (uint32_t) strtoul(token, &err, 0);
962 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
963 : 0 : } else if (!strcmp(key_token, "out_leading_depadding")) {
964 : 0 : fft->output_leading_depadding = (uint32_t) strtoul(token, &err, 0);
965 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
966 : 0 : } else if (!strcmp(key_token, "window_index")) {
967 : 0 : tok = strtok(token, VALUE_DELIMITER);
968 : 0 : if (tok == NULL)
969 : : return -1;
970 : 0 : for (i = 0; i < FFT_WIN_SIZE; i++) {
971 : 0 : shift = (i % 2) ? 4 : 0;
972 : 0 : fft->window_index[i / 2] |= (uint32_t) strtoul(tok, &err, 0)
973 : 0 : << shift;
974 : 0 : if (i < (FFT_WIN_SIZE - 1)) {
975 : 0 : tok = strtok(NULL, VALUE_DELIMITER);
976 : 0 : if (tok == NULL)
977 : : return -1;
978 : : }
979 : : }
980 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
981 : 0 : } else if (!strcmp(key_token, "cs_bitmap")) {
982 : 0 : fft->cs_bitmap = (uint32_t) strtoul(token, &err, 0);
983 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
984 : 0 : } else if (!strcmp(key_token, "num_antennas_log2")) {
985 : 0 : fft->num_antennas_log2 = (uint32_t) strtoul(token, &err, 0);
986 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
987 : 0 : } else if (!strcmp(key_token, "ifft_log2")) {
988 : 0 : fft->idft_log2 = (uint32_t) strtoul(token, &err, 0);
989 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
990 : 0 : } else if (!strcmp(key_token, "fft_log2")) {
991 : 0 : fft->dft_log2 = (uint32_t) strtoul(token, &err, 0);
992 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
993 : 0 : } else if (!strcmp(key_token, "cs_time_adjustment")) {
994 : 0 : fft->cs_time_adjustment = (uint32_t) strtoul(token, &err, 0);
995 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
996 : 0 : } else if (!strcmp(key_token, "ifft_shift")) {
997 : 0 : fft->idft_shift = (uint32_t) strtoul(token, &err, 0);
998 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
999 : 0 : } else if (!strcmp(key_token, "fft_shift")) {
1000 : 0 : fft->dft_shift = (uint32_t) strtoul(token, &err, 0);
1001 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1002 : 0 : } else if (!strcmp(key_token, "ncs_reciprocal")) {
1003 : 0 : fft->ncs_reciprocal = (uint32_t) strtoul(token, &err, 0);
1004 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1005 : 0 : } else if (!strcmp(key_token, "power_shift")) {
1006 : 0 : fft->power_shift = (uint32_t) strtoul(token, &err, 0);
1007 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1008 : 0 : } else if (!strcmp(key_token, "fp16_exponent_adjust")) {
1009 : 0 : fft->fp16_exp_adjust = (uint32_t) strtoul(token, &err, 0);
1010 : 0 : printf("%d\n", fft->fp16_exp_adjust);
1011 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1012 : 0 : } else if (!strcmp(key_token, "freq_resample_mode")) {
1013 : 0 : fft->freq_resample_mode = (uint32_t) strtoul(token, &err, 0);
1014 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1015 : 0 : } else if (!strcmp(key_token, "out_depadded_size")) {
1016 : 0 : fft->output_depadded_size = (uint32_t) strtoul(token, &err, 0);
1017 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1018 : 0 : } else if (!strcmp(key_token, "cs_theta_0")) {
1019 : 0 : tok = strtok(token, VALUE_DELIMITER);
1020 : 0 : if (tok == NULL)
1021 : : return -1;
1022 : 0 : for (i = 0; i < FFT_WIN_SIZE; i++) {
1023 : 0 : fft->cs_theta_0[i] = (uint32_t) strtoul(tok, &err, 0);
1024 : 0 : if (i < (FFT_WIN_SIZE - 1)) {
1025 : 0 : tok = strtok(NULL, VALUE_DELIMITER);
1026 : 0 : if (tok == NULL)
1027 : : return -1;
1028 : : }
1029 : : }
1030 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1031 : 0 : } else if (!strcmp(key_token, "cs_theta_d")) {
1032 : 0 : tok = strtok(token, VALUE_DELIMITER);
1033 : 0 : if (tok == NULL)
1034 : : return -1;
1035 : 0 : for (i = 0; i < FFT_WIN_SIZE; i++) {
1036 : 0 : fft->cs_theta_d[i] = (uint32_t) strtoul(tok, &err, 0);
1037 : 0 : if (i < (FFT_WIN_SIZE - 1)) {
1038 : 0 : tok = strtok(NULL, VALUE_DELIMITER);
1039 : 0 : if (tok == NULL)
1040 : : return -1;
1041 : : }
1042 : : }
1043 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1044 : 0 : } else if (!strcmp(key_token, "time_offset")) {
1045 : 0 : tok = strtok(token, VALUE_DELIMITER);
1046 : 0 : if (tok == NULL)
1047 : : return -1;
1048 : 0 : for (i = 0; i < FFT_WIN_SIZE; i++) {
1049 : 0 : fft->time_offset[i] = (uint32_t) strtoul(tok, &err, 0);
1050 : 0 : if (i < (FFT_WIN_SIZE - 1)) {
1051 : 0 : tok = strtok(NULL, VALUE_DELIMITER);
1052 : 0 : if (tok == NULL)
1053 : : return -1;
1054 : : }
1055 : : }
1056 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1057 : 0 : } else if (!strcmp(key_token, "fft_window_width")) {
1058 : 0 : tok = strtok(token, VALUE_DELIMITER);
1059 : 0 : if (tok == NULL)
1060 : : return -1;
1061 : 0 : for (i = 0; i < FFT_WIN_SIZE; i++) {
1062 : 0 : if (i == 0)
1063 : 0 : vector->fft_window_width_vec = (uint32_t) strtoul(tok, &err, 0);
1064 : 0 : if (i < (FFT_WIN_SIZE - 1)) {
1065 : 0 : tok = strtok(NULL, VALUE_DELIMITER);
1066 : 0 : if (tok == NULL)
1067 : : return -1;
1068 : : }
1069 : : }
1070 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1071 : 0 : } else if (!strcmp(key_token, "op_flags")) {
1072 : 0 : vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
1073 : 0 : ret = parse_turbo_flags(token, &op_flags, vector->op_type);
1074 : 0 : if (!ret)
1075 : 0 : fft->op_flags = op_flags;
1076 : 0 : } else if (!strcmp(key_token, "expected_status")) {
1077 : 0 : vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
1078 : 0 : ret = parse_expected_status(token, &status, vector->op_type);
1079 : 0 : if (!ret)
1080 : 0 : vector->expected_status = status;
1081 : : } else {
1082 : : printf("Not valid fft key: '%s'\n", key_token);
1083 : 0 : return -1;
1084 : : }
1085 : :
1086 : 0 : if (ret != 0) {
1087 : : printf("Failed with convert '%s\t%s'\n", key_token, token);
1088 : 0 : return -1;
1089 : : }
1090 : :
1091 : : return 0;
1092 : : }
1093 : :
1094 : : /* parses MLD parameters and assigns to global variable */
1095 : : static int
1096 : 0 : parse_mld_params(const char *key_token, char *token,
1097 : : struct test_bbdev_vector *vector)
1098 : : {
1099 : 0 : int ret = 0, status = 0;
1100 : 0 : uint32_t op_flags = 0;
1101 : 0 : char *err = NULL;
1102 : :
1103 : : struct rte_bbdev_op_mldts *mld = &vector->mldts;
1104 : :
1105 : 0 : if (starts_with(key_token, "qhy_input")) {
1106 : 0 : ret = parse_data_entry(key_token, token, vector,
1107 : : DATA_INPUT, "qhy_input");
1108 : 0 : } else if (starts_with(key_token, "r_input")) {
1109 : 0 : ret = parse_data_entry(key_token, token, vector,
1110 : : DATA_HARQ_INPUT, "r_input");
1111 : 0 : } else if (starts_with(key_token, "output")) {
1112 : 0 : ret = parse_data_entry(key_token, token, vector,
1113 : : DATA_HARD_OUTPUT, "output");
1114 : 0 : } else if (!strcmp(key_token, "layers")) {
1115 : 0 : mld->num_layers = (uint32_t) strtoul(token, &err, 0);
1116 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1117 : 0 : } else if (!strcmp(key_token, "layer1")) {
1118 : 0 : mld->q_m[0] = (uint32_t) strtoul(token, &err, 0);
1119 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1120 : 0 : } else if (!strcmp(key_token, "layer2")) {
1121 : 0 : mld->q_m[1] = (uint32_t) strtoul(token, &err, 0);
1122 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1123 : 0 : } else if (!strcmp(key_token, "layer3")) {
1124 : 0 : mld->q_m[2] = (uint32_t) strtoul(token, &err, 0);
1125 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1126 : 0 : } else if (!strcmp(key_token, "layer4")) {
1127 : 0 : mld->q_m[3] = (uint32_t) strtoul(token, &err, 0);
1128 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1129 : 0 : } else if (!strcmp(key_token, "crep")) {
1130 : 0 : mld->c_rep = (uint32_t) strtoul(token, &err, 0);
1131 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1132 : 0 : } else if (!strcmp(key_token, "rrep")) {
1133 : 0 : mld->r_rep = (uint32_t) strtoul(token, &err, 0);
1134 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1135 : 0 : } else if (!strcmp(key_token, "rbs")) {
1136 : 0 : mld->num_rbs = (uint32_t) strtoul(token, &err, 0);
1137 : 0 : ret = ((err == NULL) || (*err != '\0')) ? -1 : 0;
1138 : 0 : } else if (!strcmp(key_token, "op_flags")) {
1139 : 0 : vector->mask |= TEST_BBDEV_VF_OP_FLAGS;
1140 : 0 : ret = parse_turbo_flags(token, &op_flags, vector->op_type);
1141 : 0 : if (!ret)
1142 : 0 : mld->op_flags = op_flags;
1143 : 0 : } else if (!strcmp(key_token, "expected_status")) {
1144 : 0 : vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS;
1145 : 0 : ret = parse_expected_status(token, &status, vector->op_type);
1146 : 0 : if (!ret)
1147 : 0 : vector->expected_status = status;
1148 : : } else {
1149 : : printf("Not valid mld key: '%s'\n", key_token);
1150 : 0 : return -1;
1151 : : }
1152 : :
1153 : 0 : if (ret != 0) {
1154 : : printf("Failed with convert '%s\t%s'\n", key_token, token);
1155 : 0 : return -1;
1156 : : }
1157 : :
1158 : : return 0;
1159 : : }
1160 : :
1161 : : /* checks the type of key and assigns data */
1162 : : static int
1163 : 0 : parse_entry(char *entry, struct test_bbdev_vector *vector)
1164 : : {
1165 : : int ret = 0;
1166 : : char *token, *key_token;
1167 : 0 : enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_NONE;
1168 : :
1169 : 0 : if (entry == NULL) {
1170 : : printf("Expected entry value\n");
1171 : 0 : return -1;
1172 : : }
1173 : :
1174 : : /* get key */
1175 : 0 : token = strtok(entry, ENTRY_DELIMITER);
1176 : : key_token = token;
1177 : : /* get values for key */
1178 : 0 : token = strtok(NULL, ENTRY_DELIMITER);
1179 : :
1180 : 0 : if (key_token == NULL || token == NULL) {
1181 : : printf("Expected 'key = values' but was '%.40s'..\n", entry);
1182 : 0 : return -1;
1183 : : }
1184 : 0 : trim_space(key_token);
1185 : :
1186 : : /* first key_token has to specify type of operation */
1187 : 0 : if (vector->op_type == RTE_BBDEV_OP_NONE) {
1188 : 0 : if (!strcmp(key_token, "op_type")) {
1189 : 0 : ret = op_turbo_type_strtol(token, &op_type);
1190 : 0 : if (!ret)
1191 : 0 : vector->op_type = op_type;
1192 : 0 : return (!ret) ? 0 : -1;
1193 : : }
1194 : : printf("First key_token (%s) does not specify op_type\n",
1195 : : key_token);
1196 : 0 : return -1;
1197 : : }
1198 : :
1199 : : /* compare keys */
1200 : : if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) {
1201 : 0 : if (parse_decoder_params(key_token, token, vector) == -1)
1202 : 0 : return -1;
1203 : : } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) {
1204 : 0 : if (parse_encoder_params(key_token, token, vector) == -1)
1205 : 0 : return -1;
1206 : : } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) {
1207 : 0 : if (parse_ldpc_encoder_params(key_token, token, vector) == -1)
1208 : 0 : return -1;
1209 : : } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) {
1210 : 0 : if (parse_ldpc_decoder_params(key_token, token, vector) == -1)
1211 : 0 : return -1;
1212 : : } else if (vector->op_type == RTE_BBDEV_OP_FFT) {
1213 : 0 : if (parse_fft_params(key_token, token, vector) == -1)
1214 : 0 : return -1;
1215 : : } else if (vector->op_type == RTE_BBDEV_OP_MLDTS) {
1216 : 0 : if (parse_mld_params(key_token, token, vector) == -1)
1217 : 0 : return -1;
1218 : : }
1219 : :
1220 : : return 0;
1221 : : }
1222 : :
1223 : : static int
1224 : 0 : check_decoder_segments(struct test_bbdev_vector *vector)
1225 : : {
1226 : : unsigned char i;
1227 : : struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
1228 : :
1229 : 0 : if (vector->entries[DATA_INPUT].nb_segments == 0)
1230 : : return -1;
1231 : :
1232 : 0 : for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1233 : 0 : if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1234 : : return -1;
1235 : :
1236 : 0 : if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
1237 : : return -1;
1238 : :
1239 : 0 : for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments;
1240 : 0 : i++)
1241 : 0 : if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1242 : : return -1;
1243 : :
1244 : 0 : if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT) &&
1245 : 0 : (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0))
1246 : : return -1;
1247 : :
1248 : 0 : for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments;
1249 : 0 : i++)
1250 : 0 : if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL)
1251 : : return -1;
1252 : :
1253 : : return 0;
1254 : : }
1255 : :
1256 : : static int
1257 : 0 : check_ldpc_decoder_segments(struct test_bbdev_vector *vector)
1258 : : {
1259 : : unsigned char i;
1260 : : struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec;
1261 : :
1262 : 0 : for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1263 : 0 : if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1264 : : return -1;
1265 : :
1266 : 0 : for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
1267 : 0 : if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1268 : : return -1;
1269 : :
1270 : 0 : if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_SOFT_OUT_ENABLE) &&
1271 : 0 : (vector->entries[DATA_SOFT_OUTPUT].nb_segments == 0))
1272 : : return -1;
1273 : :
1274 : 0 : for (i = 0; i < vector->entries[DATA_SOFT_OUTPUT].nb_segments; i++)
1275 : 0 : if (vector->entries[DATA_SOFT_OUTPUT].segments[i].addr == NULL)
1276 : : return -1;
1277 : :
1278 : 0 : if ((ldpc_dec->op_flags & RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE) &&
1279 : 0 : (vector->entries[DATA_HARQ_OUTPUT].nb_segments == 0))
1280 : : return -1;
1281 : :
1282 : 0 : for (i = 0; i < vector->entries[DATA_HARQ_OUTPUT].nb_segments; i++)
1283 : 0 : if (vector->entries[DATA_HARQ_OUTPUT].segments[i].addr == NULL)
1284 : : return -1;
1285 : :
1286 : : return 0;
1287 : : }
1288 : :
1289 : : static int
1290 : : check_fft_segments(struct test_bbdev_vector *vector)
1291 : : {
1292 : : unsigned char i;
1293 : :
1294 : 0 : for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1295 : 0 : if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1296 : : return -1;
1297 : :
1298 : 0 : for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
1299 : 0 : if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1300 : : return -1;
1301 : : return 0;
1302 : : }
1303 : :
1304 : : static int
1305 : 0 : check_mld_segments(struct test_bbdev_vector *vector)
1306 : : {
1307 : : unsigned char i;
1308 : :
1309 : 0 : for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1310 : 0 : if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1311 : : return -1;
1312 : :
1313 : 0 : for (i = 0; i < vector->entries[DATA_HARQ_INPUT].nb_segments; i++)
1314 : 0 : if (vector->entries[DATA_HARQ_INPUT].segments[i].addr == NULL)
1315 : : return -1;
1316 : :
1317 : 0 : for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
1318 : 0 : if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1319 : : return -1;
1320 : : return 0;
1321 : : }
1322 : :
1323 : : static int
1324 : 0 : check_decoder_llr_spec(struct test_bbdev_vector *vector)
1325 : : {
1326 : : struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
1327 : :
1328 : : /* Check input LLR sign formalism specification */
1329 : 0 : if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) &&
1330 : : (turbo_dec->op_flags &
1331 : : RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) {
1332 : : printf(
1333 : : "Both positive and negative LLR input flags were set!\n");
1334 : 0 : return -1;
1335 : : }
1336 : 0 : if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN) &&
1337 : : !(turbo_dec->op_flags &
1338 : : RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN)) {
1339 : : printf(
1340 : : "INFO: input LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n");
1341 : 0 : turbo_dec->op_flags |= RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN;
1342 : : }
1343 : :
1344 : 0 : if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT))
1345 : : return 0;
1346 : :
1347 : : /* Check output LLR sign formalism specification */
1348 : 0 : if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) &&
1349 : : (turbo_dec->op_flags &
1350 : : RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) {
1351 : : printf(
1352 : : "Both positive and negative LLR output flags were set!\n");
1353 : 0 : return -1;
1354 : : }
1355 : 0 : if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT) &&
1356 : : !(turbo_dec->op_flags &
1357 : : RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT)) {
1358 : : printf(
1359 : : "INFO: soft output LLR sign formalism was not specified and will be set to negative LLR for '1' bit\n");
1360 : 0 : turbo_dec->op_flags |=
1361 : : RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT;
1362 : : }
1363 : :
1364 : : return 0;
1365 : : }
1366 : :
1367 : : static int
1368 : : check_decoder_op_flags(struct test_bbdev_vector *vector)
1369 : : {
1370 : : struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
1371 : :
1372 : 0 : if ((turbo_dec->op_flags & RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP) &&
1373 : : !(turbo_dec->op_flags & RTE_BBDEV_TURBO_CRC_TYPE_24B)) {
1374 : : printf(
1375 : : "WARNING: RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP flag is missing RTE_BBDEV_TURBO_CRC_TYPE_24B\n");
1376 : : return -1;
1377 : : }
1378 : :
1379 : : return 0;
1380 : : }
1381 : :
1382 : : /* checks decoder parameters */
1383 : : static int
1384 : 0 : check_decoder(struct test_bbdev_vector *vector)
1385 : : {
1386 : : struct rte_bbdev_op_turbo_dec *turbo_dec = &vector->turbo_dec;
1387 : 0 : const int mask = vector->mask;
1388 : :
1389 : 0 : if (check_decoder_segments(vector) < 0)
1390 : : return -1;
1391 : :
1392 : 0 : if (check_decoder_llr_spec(vector) < 0)
1393 : : return -1;
1394 : :
1395 : : if (check_decoder_op_flags(vector) < 0)
1396 : 0 : return -1;
1397 : :
1398 : : /* Check which params were set */
1399 : 0 : if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1400 : : printf(
1401 : : "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n");
1402 : 0 : turbo_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK;
1403 : : }
1404 : 0 : if (turbo_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) {
1405 : 0 : if (!(mask & TEST_BBDEV_VF_EA))
1406 : : printf(
1407 : : "WARNING: ea was not specified in vector file and will be set to 0\n");
1408 : 0 : if (!(mask & TEST_BBDEV_VF_EB))
1409 : : printf(
1410 : : "WARNING: eb was not specified in vector file and will be set to 0\n");
1411 : 0 : if (!(mask & TEST_BBDEV_VF_K_NEG))
1412 : : printf(
1413 : : "WARNING: k_neg was not specified in vector file and will be set to 0\n");
1414 : 0 : if (!(mask & TEST_BBDEV_VF_K_POS))
1415 : : printf(
1416 : : "WARNING: k_pos was not specified in vector file and will be set to 0\n");
1417 : 0 : if (!(mask & TEST_BBDEV_VF_C_NEG))
1418 : : printf(
1419 : : "WARNING: c_neg was not specified in vector file and will be set to 0\n");
1420 : 0 : if (!(mask & TEST_BBDEV_VF_C)) {
1421 : : printf(
1422 : : "WARNING: c was not specified in vector file and will be set to 1\n");
1423 : 0 : turbo_dec->tb_params.c = 1;
1424 : : }
1425 : 0 : if (!(mask & TEST_BBDEV_VF_CAB))
1426 : : printf(
1427 : : "WARNING: cab was not specified in vector file and will be set to 0\n");
1428 : 0 : if (!(mask & TEST_BBDEV_VF_R))
1429 : : printf(
1430 : : "WARNING: r was not specified in vector file and will be set to 0\n");
1431 : : } else {
1432 : 0 : if (!(mask & TEST_BBDEV_VF_E))
1433 : : printf(
1434 : : "WARNING: e was not specified in vector file and will be set to 0\n");
1435 : 0 : if (!(mask & TEST_BBDEV_VF_K))
1436 : : printf(
1437 : : "WARNING: k was not specified in vector file and will be set to 0\n");
1438 : : }
1439 : 0 : if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1440 : : printf(
1441 : : "INFO: rv_index was not specified in vector file and will be set to 0\n");
1442 : 0 : if (!(mask & TEST_BBDEV_VF_ITER_MIN))
1443 : : printf(
1444 : : "WARNING: iter_min was not specified in vector file and will be set to 0\n");
1445 : 0 : if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT))
1446 : : printf(
1447 : : "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n");
1448 : 0 : if (!(mask & TEST_BBDEV_VF_EXT_SCALE))
1449 : : printf(
1450 : : "WARNING: ext_scale was not specified in vector file and will be set to 0\n");
1451 : 0 : if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) {
1452 : : printf(
1453 : : "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n");
1454 : 0 : turbo_dec->num_maps = 0;
1455 : 0 : } else if (!(turbo_dec->op_flags & RTE_BBDEV_TURBO_MAP_DEC) &&
1456 : 0 : mask & TEST_BBDEV_VF_NUM_MAPS) {
1457 : : printf(
1458 : : "INFO: RTE_BBDEV_TURBO_MAP_DEC was not set in vector file and num_maps will be set to 0\n");
1459 : 0 : turbo_dec->num_maps = 0;
1460 : : }
1461 : 0 : if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1462 : : printf(
1463 : : "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1464 : : return 0;
1465 : : }
1466 : :
1467 : : /* checks LDPC decoder parameters */
1468 : : static int
1469 : 0 : check_ldpc_decoder(struct test_bbdev_vector *vector)
1470 : : {
1471 : : struct rte_bbdev_op_ldpc_dec *ldpc_dec = &vector->ldpc_dec;
1472 : 0 : const int mask = vector->mask;
1473 : :
1474 : 0 : if (check_ldpc_decoder_segments(vector) < 0)
1475 : : return -1;
1476 : :
1477 : : /*
1478 : : * if (check_ldpc_decoder_llr_spec(vector) < 0)
1479 : : * return -1;
1480 : : *
1481 : : * if (check_ldpc_decoder_op_flags(vector) < 0)
1482 : : * return -1;
1483 : : */
1484 : :
1485 : : /* Check which params were set */
1486 : 0 : if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1487 : : printf(
1488 : : "WARNING: code_block_mode was not specified in vector file and will be set to 1 (0 - TB Mode, 1 - CB mode)\n");
1489 : 0 : ldpc_dec->code_block_mode = RTE_BBDEV_CODE_BLOCK;
1490 : : }
1491 : 0 : if (ldpc_dec->code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) {
1492 : 0 : if (!(mask & TEST_BBDEV_VF_EA))
1493 : : printf(
1494 : : "WARNING: ea was not specified in vector file and will be set to 0\n");
1495 : 0 : if (!(mask & TEST_BBDEV_VF_EB))
1496 : : printf(
1497 : : "WARNING: eb was not specified in vector file and will be set to 0\n");
1498 : 0 : if (!(mask & TEST_BBDEV_VF_C)) {
1499 : : printf(
1500 : : "WARNING: c was not specified in vector file and will be set to 1\n");
1501 : 0 : ldpc_dec->tb_params.c = 1;
1502 : : }
1503 : 0 : if (!(mask & TEST_BBDEV_VF_CAB))
1504 : : printf(
1505 : : "WARNING: cab was not specified in vector file and will be set to 0\n");
1506 : 0 : if (!(mask & TEST_BBDEV_VF_R))
1507 : : printf(
1508 : : "WARNING: r was not specified in vector file and will be set to 0\n");
1509 : : } else {
1510 : 0 : if (!(mask & TEST_BBDEV_VF_E))
1511 : : printf(
1512 : : "WARNING: e was not specified in vector file and will be set to 0\n");
1513 : : }
1514 : 0 : if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1515 : : printf(
1516 : : "INFO: rv_index was not specified in vector file and will be set to 0\n");
1517 : 0 : if (!(mask & TEST_BBDEV_VF_EXPECTED_ITER_COUNT))
1518 : : printf(
1519 : : "WARNING: expected_iter_count was not specified in vector file and iter_count will not be validated\n");
1520 : 0 : if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) {
1521 : : printf(
1522 : : "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n");
1523 : : }
1524 : 0 : if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1525 : : printf(
1526 : : "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1527 : : return 0;
1528 : : }
1529 : :
1530 : : /* Checks fft parameters. */
1531 : : static int
1532 : 0 : check_fft(struct test_bbdev_vector *vector)
1533 : : {
1534 : 0 : const int mask = vector->mask;
1535 : :
1536 : 0 : if (check_fft_segments(vector) < 0)
1537 : : return -1;
1538 : :
1539 : : /* Check which params were set. */
1540 : 0 : if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) {
1541 : : printf(
1542 : : "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n");
1543 : : }
1544 : 0 : if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1545 : : printf(
1546 : : "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1547 : : return 0;
1548 : : }
1549 : :
1550 : : /* checks mld parameters */
1551 : : static int
1552 : 0 : check_mld(struct test_bbdev_vector *vector)
1553 : : {
1554 : 0 : const int mask = vector->mask;
1555 : :
1556 : 0 : if (check_mld_segments(vector) < 0)
1557 : : return -1;
1558 : :
1559 : : /* Check which params were set */
1560 : 0 : if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) {
1561 : : printf(
1562 : : "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n");
1563 : : }
1564 : 0 : if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1565 : : printf(
1566 : : "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1567 : : return 0;
1568 : : }
1569 : :
1570 : : /* checks encoder parameters */
1571 : : static int
1572 : 0 : check_encoder(struct test_bbdev_vector *vector)
1573 : : {
1574 : : unsigned char i;
1575 : 0 : const int mask = vector->mask;
1576 : :
1577 : 0 : if (vector->entries[DATA_INPUT].nb_segments == 0)
1578 : : return -1;
1579 : :
1580 : 0 : for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1581 : 0 : if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1582 : : return -1;
1583 : :
1584 : 0 : if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
1585 : : return -1;
1586 : :
1587 : 0 : for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
1588 : 0 : if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1589 : : return -1;
1590 : :
1591 : 0 : if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1592 : : printf(
1593 : : "WARNING: code_block_mode was not specified in vector file and will be set to 1\n");
1594 : 0 : vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK;
1595 : : }
1596 : 0 : if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) {
1597 : 0 : if (!(mask & TEST_BBDEV_VF_EA) && (vector->turbo_enc.op_flags &
1598 : : RTE_BBDEV_TURBO_RATE_MATCH))
1599 : : printf(
1600 : : "WARNING: ea was not specified in vector file and will be set to 0\n");
1601 : 0 : if (!(mask & TEST_BBDEV_VF_EB) && (vector->turbo_enc.op_flags &
1602 : : RTE_BBDEV_TURBO_RATE_MATCH))
1603 : : printf(
1604 : : "WARNING: eb was not specified in vector file and will be set to 0\n");
1605 : 0 : if (!(mask & TEST_BBDEV_VF_K_NEG))
1606 : : printf(
1607 : : "WARNING: k_neg was not specified in vector file and will be set to 0\n");
1608 : 0 : if (!(mask & TEST_BBDEV_VF_K_POS))
1609 : : printf(
1610 : : "WARNING: k_pos was not specified in vector file and will be set to 0\n");
1611 : 0 : if (!(mask & TEST_BBDEV_VF_C_NEG))
1612 : : printf(
1613 : : "WARNING: c_neg was not specified in vector file and will be set to 0\n");
1614 : 0 : if (!(mask & TEST_BBDEV_VF_C)) {
1615 : : printf(
1616 : : "WARNING: c was not specified in vector file and will be set to 1\n");
1617 : 0 : vector->turbo_enc.tb_params.c = 1;
1618 : : }
1619 : 0 : if (!(mask & TEST_BBDEV_VF_CAB) && (vector->turbo_enc.op_flags &
1620 : : RTE_BBDEV_TURBO_RATE_MATCH))
1621 : : printf(
1622 : : "WARNING: cab was not specified in vector file and will be set to 0\n");
1623 : 0 : if (!(mask & TEST_BBDEV_VF_NCB_NEG))
1624 : : printf(
1625 : : "WARNING: ncb_neg was not specified in vector file and will be set to 0\n");
1626 : 0 : if (!(mask & TEST_BBDEV_VF_NCB_POS))
1627 : : printf(
1628 : : "WARNING: ncb_pos was not specified in vector file and will be set to 0\n");
1629 : 0 : if (!(mask & TEST_BBDEV_VF_R))
1630 : : printf(
1631 : : "WARNING: r was not specified in vector file and will be set to 0\n");
1632 : : } else {
1633 : 0 : if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags &
1634 : : RTE_BBDEV_TURBO_RATE_MATCH))
1635 : : printf(
1636 : : "WARNING: e was not specified in vector file and will be set to 0\n");
1637 : 0 : if (!(mask & TEST_BBDEV_VF_K))
1638 : : printf(
1639 : : "WARNING: k was not specified in vector file and will be set to 0\n");
1640 : 0 : if (!(mask & TEST_BBDEV_VF_NCB))
1641 : : printf(
1642 : : "WARNING: ncb was not specified in vector file and will be set to 0\n");
1643 : : }
1644 : 0 : if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1645 : : printf(
1646 : : "INFO: rv_index was not specified in vector file and will be set to 0\n");
1647 : 0 : if (!(mask & TEST_BBDEV_VF_OP_FLAGS))
1648 : : printf(
1649 : : "INFO: op_flags was not specified in vector file and capabilities will not be validated\n");
1650 : 0 : if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1651 : : printf(
1652 : : "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1653 : :
1654 : : return 0;
1655 : : }
1656 : :
1657 : :
1658 : : /* checks encoder parameters */
1659 : : static int
1660 : 0 : check_ldpc_encoder(struct test_bbdev_vector *vector)
1661 : : {
1662 : : unsigned char i;
1663 : 0 : const int mask = vector->mask;
1664 : :
1665 : 0 : if (vector->entries[DATA_INPUT].nb_segments == 0)
1666 : : return -1;
1667 : :
1668 : 0 : for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++)
1669 : 0 : if (vector->entries[DATA_INPUT].segments[i].addr == NULL)
1670 : : return -1;
1671 : :
1672 : 0 : if (vector->entries[DATA_HARD_OUTPUT].nb_segments == 0)
1673 : : return -1;
1674 : :
1675 : 0 : for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++)
1676 : 0 : if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL)
1677 : : return -1;
1678 : :
1679 : 0 : if (!(mask & TEST_BBDEV_VF_CODE_BLOCK_MODE)) {
1680 : : printf(
1681 : : "WARNING: code_block_mode was not specified in vector file and will be set to 1\n");
1682 : 0 : vector->turbo_enc.code_block_mode = RTE_BBDEV_CODE_BLOCK;
1683 : : }
1684 : 0 : if (vector->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) {
1685 : : } else {
1686 : 0 : if (!(mask & TEST_BBDEV_VF_E) && (vector->turbo_enc.op_flags &
1687 : : RTE_BBDEV_TURBO_RATE_MATCH))
1688 : : printf(
1689 : : "WARNING: e was not specified in vector file and will be set to 0\n");
1690 : 0 : if (!(mask & TEST_BBDEV_VF_NCB))
1691 : : printf(
1692 : : "WARNING: ncb was not specified in vector file and will be set to 0\n");
1693 : : }
1694 : 0 : if (!(mask & TEST_BBDEV_VF_BG))
1695 : : printf(
1696 : : "WARNING: BG was not specified in vector file and will be set to 0\n");
1697 : 0 : if (!(mask & TEST_BBDEV_VF_ZC))
1698 : : printf(
1699 : : "WARNING: Zc was not specified in vector file and will be set to 0\n");
1700 : 0 : if (!(mask & TEST_BBDEV_VF_RV_INDEX))
1701 : : printf(
1702 : : "INFO: rv_index was not specified in vector file and will be set to 0\n");
1703 : 0 : if (!(mask & TEST_BBDEV_VF_OP_FLAGS))
1704 : : printf(
1705 : : "INFO: op_flags was not specified in vector file and capabilities will not be validated\n");
1706 : 0 : if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS))
1707 : : printf(
1708 : : "WARNING: expected_status was not specified in vector file and will be set to 0\n");
1709 : :
1710 : : return 0;
1711 : : }
1712 : :
1713 : : static int
1714 : 0 : bbdev_check_vector(struct test_bbdev_vector *vector)
1715 : : {
1716 : 0 : if (vector->op_type == RTE_BBDEV_OP_TURBO_DEC) {
1717 : 0 : if (check_decoder(vector) == -1)
1718 : 0 : return -1;
1719 : : } else if (vector->op_type == RTE_BBDEV_OP_TURBO_ENC) {
1720 : 0 : if (check_encoder(vector) == -1)
1721 : 0 : return -1;
1722 : : } else if (vector->op_type == RTE_BBDEV_OP_LDPC_ENC) {
1723 : 0 : if (check_ldpc_encoder(vector) == -1)
1724 : 0 : return -1;
1725 : : } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) {
1726 : 0 : if (check_ldpc_decoder(vector) == -1)
1727 : 0 : return -1;
1728 : : } else if (vector->op_type == RTE_BBDEV_OP_FFT) {
1729 : 0 : if (check_fft(vector) == -1)
1730 : 0 : return -1;
1731 : : } else if (vector->op_type == RTE_BBDEV_OP_MLDTS) {
1732 : 0 : if (check_mld(vector) == -1)
1733 : 0 : return -1;
1734 : 0 : } else if (vector->op_type != RTE_BBDEV_OP_NONE) {
1735 : : printf("Vector was not filled\n");
1736 : 0 : return -1;
1737 : : }
1738 : :
1739 : : return 0;
1740 : : }
1741 : :
1742 : : int
1743 : 0 : test_bbdev_vector_read(const char *filename,
1744 : : struct test_bbdev_vector *vector)
1745 : : {
1746 : : int ret = 0;
1747 : 0 : size_t len = 0;
1748 : :
1749 : : FILE *fp = NULL;
1750 : 0 : char *line = NULL;
1751 : : char *entry = NULL;
1752 : :
1753 : 0 : fp = fopen(filename, "r");
1754 : 0 : if (fp == NULL) {
1755 : : printf("File %s does not exist\n", filename);
1756 : 0 : return -1;
1757 : : }
1758 : :
1759 : 0 : while (getline(&line, &len, fp) != -1) {
1760 : :
1761 : : /* ignore comments and new lines */
1762 : 0 : if (line[0] == '#' || line[0] == '/' || line[0] == '\n'
1763 : 0 : || line[0] == '\r')
1764 : 0 : continue;
1765 : :
1766 : 0 : trim_space(line);
1767 : :
1768 : : /* buffer for multiline */
1769 : 0 : entry = realloc(entry, strlen(line) + 1);
1770 : 0 : if (entry == NULL) {
1771 : 0 : printf("Fail to realloc %zu bytes\n", strlen(line) + 1);
1772 : : ret = -ENOMEM;
1773 : 0 : goto exit;
1774 : : }
1775 : :
1776 : : strcpy(entry, line);
1777 : :
1778 : : /* check if entry ends with , or = */
1779 : 0 : if (entry[strlen(entry) - 1] == ','
1780 : 0 : || entry[strlen(entry) - 1] == '=') {
1781 : 0 : while (getline(&line, &len, fp) != -1) {
1782 : 0 : trim_space(line);
1783 : :
1784 : : /* extend entry about length of new line */
1785 : 0 : char *entry_extended = realloc(entry,
1786 : 0 : strlen(line) +
1787 : 0 : strlen(entry) + 1);
1788 : :
1789 : 0 : if (entry_extended == NULL) {
1790 : 0 : printf("Fail to allocate %zu bytes\n",
1791 : 0 : strlen(line) +
1792 : 0 : strlen(entry) + 1);
1793 : : ret = -ENOMEM;
1794 : 0 : goto exit;
1795 : : }
1796 : :
1797 : : entry = entry_extended;
1798 : : /* entry has been allocated accordingly */
1799 : 0 : strcpy(&entry[strlen(entry)], line);
1800 : :
1801 : 0 : if (entry[strlen(entry) - 1] != ',')
1802 : : break;
1803 : : }
1804 : : }
1805 : 0 : ret = parse_entry(entry, vector);
1806 : 0 : if (ret != 0) {
1807 : : printf("An error occurred while parsing!\n");
1808 : 0 : goto exit;
1809 : : }
1810 : : }
1811 : 0 : ret = bbdev_check_vector(vector);
1812 : 0 : if (ret != 0)
1813 : : printf("An error occurred while checking!\n");
1814 : :
1815 : 0 : exit:
1816 : 0 : fclose(fp);
1817 : 0 : free(line);
1818 : 0 : free(entry);
1819 : :
1820 : 0 : return ret;
1821 : : }
|
