1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /* Copyright(c) 2007-2022 Intel Corporation */
3 #include "adf_cfg_instance.h"
4 #include "adf_cfg_device.h"
5 #include "adf_cfg_section.h"
6
7 static bool
adf_cfg_is_svc_enabled(struct adf_accel_dev * accel_dev,const u8 svc)8 adf_cfg_is_svc_enabled(struct adf_accel_dev *accel_dev, const u8 svc)
9 {
10 int ring_pair_index = 0;
11 u8 serv_type = NA;
12 struct adf_hw_device_data *hw_data = GET_HW_DATA(accel_dev);
13
14 for (ring_pair_index = 0; ring_pair_index < ADF_CFG_NUM_SERVICES;
15 ring_pair_index++) {
16 serv_type =
17 GET_SRV_TYPE(hw_data->ring_to_svc_map, ring_pair_index);
18 if (serv_type == svc)
19 return true;
20 }
21 return false;
22 }
23
24 static int
adf_cfg_set_core_number_for_instance(struct adf_accel_dev * accel_dev,const char * sec_name,const char * inst_name,int process_num,unsigned long * core_number)25 adf_cfg_set_core_number_for_instance(struct adf_accel_dev *accel_dev,
26 const char *sec_name,
27 const char *inst_name,
28 int process_num,
29 unsigned long *core_number)
30 {
31 char *core_val = NULL;
32 char *pos = NULL;
33 char **tokens = NULL;
34 int token_index = 0;
35 int core_arr_index = 0;
36 int i = 0;
37 int ret = EFAULT;
38 unsigned long *core_num_arr = NULL;
39 unsigned long core_num;
40 unsigned long start, end;
41
42 /* do memory allocation */
43 core_val =
44 malloc(ADF_CFG_MAX_VAL_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
45
46 tokens = malloc(sizeof(char *) * ADF_CFG_MAX_TOKENS,
47 M_QAT,
48 M_WAITOK | M_ZERO);
49
50 for (i = 0; i < ADF_CFG_MAX_TOKENS; i++) {
51 tokens[i] =
52 malloc(ADF_CFG_MAX_TOKEN_LEN, M_QAT, M_WAITOK | M_ZERO);
53 }
54
55 core_num_arr = malloc(sizeof(unsigned long) * ADF_CFG_MAX_CORE_NUM,
56 M_QAT,
57 M_WAITOK | M_ZERO);
58
59 /* parse the core_val */
60 ret = EFAULT;
61 if (adf_cfg_get_param_value(accel_dev, sec_name, inst_name, core_val))
62 goto failed;
63
64 pos = strchr(core_val, ',');
65 while (pos) {
66 pos[0] = '\0';
67 strlcpy(tokens[token_index++], core_val, ADF_CFG_MAX_TOKEN_LEN);
68 strlcpy(core_val, pos + 1, ADF_CFG_MAX_VAL_LEN_IN_BYTES);
69 pos = strchr(core_val, ',');
70 if (!pos)
71 strlcpy(tokens[token_index++],
72 core_val,
73 ADF_CFG_MAX_VAL_LEN_IN_BYTES);
74 }
75
76 /* in case there is only N-M */
77 if (token_index == 0)
78 strlcpy(tokens[token_index++],
79 core_val,
80 ADF_CFG_MAX_VAL_LEN_IN_BYTES);
81
82 /* parse the tokens such as N-M */
83 for (i = 0; i < token_index; i++) {
84 pos = strchr(tokens[i], '-');
85 if (pos) {
86 pos[0] = '\0';
87 ret = compat_strtoul(tokens[i], 10, &start);
88 if (ret)
89 goto failed;
90 ret = compat_strtoul(pos + 1, 10, &end);
91 if (ret)
92 goto failed;
93 if (start > end) {
94 ret = EFAULT;
95 goto failed;
96 }
97 for (core_num = start; core_num < end + 1; core_num++)
98 core_num_arr[core_arr_index++] = core_num;
99 } else {
100 ret = compat_strtoul(tokens[i], 10, &core_num);
101 if (ret)
102 goto failed;
103 core_num_arr[core_arr_index++] = core_num;
104 }
105 }
106
107 if (core_arr_index == 0) {
108 ret = compat_strtoul(core_val, 10, &core_num);
109 if (ret)
110 goto failed;
111 else
112 core_num_arr[core_arr_index++] = core_num;
113 }
114
115 *core_number = core_num_arr[process_num % core_arr_index];
116 ret = 0;
117 failed:
118 free(core_val, M_QAT);
119 if (tokens) {
120 for (i = 0; i < ADF_CFG_MAX_TOKENS; i++)
121 free(tokens[i], M_QAT);
122 free(tokens, M_QAT);
123 }
124 free(core_num_arr, M_QAT);
125
126 if (ret)
127 device_printf(GET_DEV(accel_dev),
128 "Get core number failed with error %d\n",
129 ret);
130 return ret;
131 }
132
133 static int
adf_cfg_set_value(struct adf_accel_dev * accel_dev,const char * sec,const char * key,unsigned long * value)134 adf_cfg_set_value(struct adf_accel_dev *accel_dev,
135 const char *sec,
136 const char *key,
137 unsigned long *value)
138 {
139 char *val = NULL;
140 int ret = EFAULT;
141
142 val = malloc(ADF_CFG_MAX_VAL_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
143
144 if (adf_cfg_get_param_value(accel_dev, sec, key, val))
145 goto out;
146
147 /* as the key type can be either ADF_DEC or ADF_HEX */
148 if (compat_strtoul(val, 10, value) && compat_strtoul(val, 16, value))
149 goto out;
150
151 ret = 0;
152 out:
153 free(val, M_QAT);
154 return ret;
155 }
156
157 static void
adf_cfg_add_cy_inst_info(struct adf_accel_dev * accel_dev,struct adf_cfg_instance * crypto_inst,const char * derived_sec,int inst_index)158 adf_cfg_add_cy_inst_info(struct adf_accel_dev *accel_dev,
159 struct adf_cfg_instance *crypto_inst,
160 const char *derived_sec,
161 int inst_index)
162 {
163 char *key = NULL;
164 unsigned long bank_number = 0;
165 unsigned long ring_number = 0;
166 unsigned long asym_req = 0;
167 unsigned long sym_req = 0;
168
169 key = malloc(ADF_CFG_MAX_KEY_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
170
171 snprintf(key,
172 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
173 ADF_CY_BANK_NUM_FORMAT,
174 inst_index);
175 bank_number = crypto_inst->bundle;
176 adf_cfg_add_key_value_param(
177 accel_dev, derived_sec, key, (void *)&bank_number, ADF_DEC);
178
179 snprintf(key,
180 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
181 ADF_CY_ASYM_TX_FORMAT,
182 inst_index);
183 ring_number = crypto_inst->asym_tx;
184 adf_cfg_add_key_value_param(
185 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
186
187 snprintf(key,
188 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
189 ADF_CY_SYM_TX_FORMAT,
190 inst_index);
191 ring_number = crypto_inst->sym_tx;
192 adf_cfg_add_key_value_param(
193 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
194
195 snprintf(key,
196 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
197 ADF_CY_ASYM_RX_FORMAT,
198 inst_index);
199 ring_number = crypto_inst->asym_rx;
200 adf_cfg_add_key_value_param(
201 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
202
203 snprintf(key,
204 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
205 ADF_CY_SYM_RX_FORMAT,
206 inst_index);
207 ring_number = crypto_inst->sym_rx;
208 adf_cfg_add_key_value_param(
209 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
210
211 strlcpy(key, ADF_CY_RING_ASYM_SIZE, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
212 if (adf_cfg_set_value(accel_dev, ADF_GENERAL_SEC, key, &asym_req))
213 asym_req = ADF_CFG_DEF_CY_RING_ASYM_SIZE;
214
215 snprintf(key,
216 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
217 ADF_CY_RING_ASYM_SIZE_FORMAT,
218 inst_index);
219 adf_cfg_add_key_value_param(
220 accel_dev, derived_sec, key, (void *)&asym_req, ADF_DEC);
221
222 strlcpy(key, ADF_CY_RING_SYM_SIZE, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
223 if (adf_cfg_set_value(accel_dev, ADF_GENERAL_SEC, key, &sym_req))
224 sym_req = ADF_CFG_DEF_CY_RING_SYM_SIZE;
225
226 snprintf(key,
227 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
228 ADF_CY_RING_SYM_SIZE_FORMAT,
229 inst_index);
230 adf_cfg_add_key_value_param(
231 accel_dev, derived_sec, key, (void *)&sym_req, ADF_DEC);
232
233 free(key, M_QAT);
234 }
235
236 static void
adf_cfg_add_dc_inst_info(struct adf_accel_dev * accel_dev,struct adf_cfg_instance * dc_inst,const char * derived_sec,int inst_index)237 adf_cfg_add_dc_inst_info(struct adf_accel_dev *accel_dev,
238 struct adf_cfg_instance *dc_inst,
239 const char *derived_sec,
240 int inst_index)
241 {
242 char *key = NULL;
243 unsigned long bank_number = 0;
244 unsigned long ring_number = 0;
245 unsigned long dc_req = 0;
246
247 key = malloc(ADF_CFG_MAX_KEY_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
248
249 snprintf(key, ADF_CFG_MAX_STR_LEN, ADF_DC_BANK_NUM_FORMAT, inst_index);
250 bank_number = dc_inst->bundle;
251 adf_cfg_add_key_value_param(
252 accel_dev, derived_sec, key, (void *)&bank_number, ADF_DEC);
253
254 snprintf(key, ADF_CFG_MAX_STR_LEN, ADF_DC_TX_FORMAT, inst_index);
255 ring_number = dc_inst->dc_tx;
256 adf_cfg_add_key_value_param(
257 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
258
259 snprintf(key, ADF_CFG_MAX_STR_LEN, ADF_DC_RX_FORMAT, inst_index);
260 ring_number = dc_inst->dc_rx;
261 adf_cfg_add_key_value_param(
262 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
263
264 strlcpy(key, ADF_DC_RING_SIZE, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
265 if (adf_cfg_set_value(accel_dev, ADF_GENERAL_SEC, key, &dc_req))
266 dc_req = ADF_CFG_DEF_DC_RING_SIZE;
267
268 snprintf(key, ADF_CFG_MAX_STR_LEN, ADF_DC_RING_SIZE_FORMAT, inst_index);
269 adf_cfg_add_key_value_param(
270 accel_dev, derived_sec, key, (void *)&dc_req, ADF_DEC);
271
272 free(key, M_QAT);
273 }
274
275 static void
adf_cfg_add_asym_inst_info(struct adf_accel_dev * accel_dev,struct adf_cfg_instance * asym_inst,const char * derived_sec,int inst_index)276 adf_cfg_add_asym_inst_info(struct adf_accel_dev *accel_dev,
277 struct adf_cfg_instance *asym_inst,
278 const char *derived_sec,
279 int inst_index)
280 {
281 char *key = NULL;
282 unsigned long bank_number = 0;
283 unsigned long ring_number = 0;
284 unsigned long asym_req = 0;
285
286 key = malloc(ADF_CFG_MAX_KEY_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
287
288 if (adf_cy_inst_cross_banks(accel_dev))
289 snprintf(key,
290 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
291 ADF_CY_ASYM_BANK_NUM_FORMAT,
292 inst_index);
293 else
294 snprintf(key,
295 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
296 ADF_CY_BANK_NUM_FORMAT,
297 inst_index);
298 bank_number = asym_inst->bundle;
299 adf_cfg_add_key_value_param(
300 accel_dev, derived_sec, key, (void *)&bank_number, ADF_DEC);
301
302 snprintf(key,
303 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
304 ADF_CY_ASYM_TX_FORMAT,
305 inst_index);
306 ring_number = asym_inst->asym_tx;
307 adf_cfg_add_key_value_param(
308 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
309
310 snprintf(key,
311 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
312 ADF_CY_ASYM_RX_FORMAT,
313 inst_index);
314 ring_number = asym_inst->asym_rx;
315 adf_cfg_add_key_value_param(
316 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
317
318 strlcpy(key, ADF_CY_RING_ASYM_SIZE, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
319 if (adf_cfg_set_value(accel_dev, ADF_GENERAL_SEC, key, &asym_req))
320 asym_req = ADF_CFG_DEF_CY_RING_ASYM_SIZE;
321
322 snprintf(key,
323 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
324 ADF_CY_RING_ASYM_SIZE_FORMAT,
325 inst_index);
326 adf_cfg_add_key_value_param(
327 accel_dev, derived_sec, key, (void *)&asym_req, ADF_DEC);
328
329 free(key, M_QAT);
330 }
331
332 static void
adf_cfg_add_sym_inst_info(struct adf_accel_dev * accel_dev,struct adf_cfg_instance * sym_inst,const char * derived_sec,int inst_index)333 adf_cfg_add_sym_inst_info(struct adf_accel_dev *accel_dev,
334 struct adf_cfg_instance *sym_inst,
335 const char *derived_sec,
336 int inst_index)
337 {
338 char *key = NULL;
339 unsigned long bank_number = 0;
340 unsigned long ring_number = 0;
341 unsigned long sym_req = 0;
342
343 key = malloc(ADF_CFG_MAX_KEY_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
344
345 if (adf_cy_inst_cross_banks(accel_dev))
346 snprintf(key,
347 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
348 ADF_CY_SYM_BANK_NUM_FORMAT,
349 inst_index);
350 else
351 snprintf(key,
352 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
353 ADF_CY_BANK_NUM_FORMAT,
354 inst_index);
355
356 bank_number = sym_inst->bundle;
357 adf_cfg_add_key_value_param(
358 accel_dev, derived_sec, key, (void *)&bank_number, ADF_DEC);
359
360 snprintf(key,
361 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
362 ADF_CY_SYM_TX_FORMAT,
363 inst_index);
364 ring_number = sym_inst->sym_tx;
365 adf_cfg_add_key_value_param(
366 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
367
368 snprintf(key,
369 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
370 ADF_CY_SYM_RX_FORMAT,
371 inst_index);
372 ring_number = sym_inst->sym_rx;
373 adf_cfg_add_key_value_param(
374 accel_dev, derived_sec, key, (void *)&ring_number, ADF_DEC);
375
376 strlcpy(key, ADF_CY_RING_SYM_SIZE, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
377 if (adf_cfg_set_value(accel_dev, ADF_GENERAL_SEC, key, &sym_req))
378 sym_req = ADF_CFG_DEF_CY_RING_SYM_SIZE;
379
380 snprintf(key,
381 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
382 ADF_CY_RING_SYM_SIZE_FORMAT,
383 inst_index);
384 adf_cfg_add_key_value_param(
385 accel_dev, derived_sec, key, (void *)&sym_req, ADF_DEC);
386
387 free(key, M_QAT);
388 }
389
390 static int
adf_cfg_section_copy(struct adf_accel_dev * accel_dev,const char * processed_sec,const char * derived_sec)391 adf_cfg_section_copy(struct adf_accel_dev *accel_dev,
392 const char *processed_sec,
393 const char *derived_sec)
394 {
395 unsigned long val = 0;
396 struct list_head *list;
397 struct adf_cfg_section *sec_process =
398 adf_cfg_sec_find(accel_dev, processed_sec);
399 if (!sec_process)
400 return EFAULT;
401
402 list_for_each(list, &sec_process->param_head)
403 {
404 struct adf_cfg_key_val *ptr =
405 list_entry(list, struct adf_cfg_key_val, list);
406
407 /*
408 * ignore CoreAffinity since it will be generated later, and
409 * there is no need to keep NumProcesses and LimitDevAccess.
410 */
411 if (strstr(ptr->key, ADF_ETRMGR_CORE_AFFINITY) ||
412 strstr(ptr->key, ADF_NUM_PROCESSES) ||
413 strstr(ptr->key, ADF_LIMIT_DEV_ACCESS))
414 continue;
415
416 if (ptr->type == ADF_DEC) {
417 if (!compat_strtoul(ptr->val, 10, &val))
418 adf_cfg_add_key_value_param(accel_dev,
419 derived_sec,
420 ptr->key,
421 (void *)&val,
422 ptr->type);
423 } else if (ptr->type == ADF_STR) {
424 adf_cfg_add_key_value_param(accel_dev,
425 derived_sec,
426 ptr->key,
427 (void *)ptr->val,
428 ptr->type);
429 } else if (ptr->type == ADF_HEX) {
430 if (!compat_strtoul(ptr->val, 16, &val))
431 adf_cfg_add_key_value_param(accel_dev,
432 derived_sec,
433 ptr->key,
434 (void *)val,
435 ptr->type);
436 }
437 }
438 return 0;
439 }
440
441 static int
adf_cfg_create_rings_entries_for_cy_inst(struct adf_accel_dev * accel_dev,const char * processed_sec,const char * derived_sec,int process_num,enum adf_cfg_service_type serv_type)442 adf_cfg_create_rings_entries_for_cy_inst(struct adf_accel_dev *accel_dev,
443 const char *processed_sec,
444 const char *derived_sec,
445 int process_num,
446 enum adf_cfg_service_type serv_type)
447 {
448 int i = 0;
449 int ret = EFAULT;
450 unsigned long num_inst = 0, num_dc_inst = 0;
451 unsigned long core_number = 0;
452 unsigned long polling_mode = 0;
453 struct adf_cfg_instance *crypto_inst = NULL;
454
455 char *key = NULL;
456 char *val = NULL;
457
458 key = malloc(ADF_CFG_MAX_KEY_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
459
460 val = malloc(ADF_CFG_MAX_VAL_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
461
462 snprintf(key, ADF_CFG_MAX_KEY_LEN_IN_BYTES, ADF_SERVICES_ENABLED);
463 if (adf_cfg_get_param_value(accel_dev, ADF_GENERAL_SEC, key, val))
464 goto failed;
465 if ((!strncmp(val, ADF_CFG_CY, ADF_CFG_MAX_VAL_LEN_IN_BYTES)) ||
466 (!strncmp(val, ADF_CFG_ASYM, ADF_CFG_MAX_VAL_LEN_IN_BYTES)) ||
467 (!strncmp(val, ADF_CFG_SYM, ADF_CFG_MAX_VAL_LEN_IN_BYTES))) {
468 strlcpy(key, ADF_NUM_DC, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
469 if (adf_cfg_set_value(
470 accel_dev, processed_sec, key, &num_dc_inst))
471 goto failed;
472 if (num_dc_inst > 0) {
473 device_printf(
474 GET_DEV(accel_dev),
475 "NumDcInstances > 0,when CY only is enabled\n");
476 goto failed;
477 }
478 }
479 ret = EFAULT;
480
481 strlcpy(key, ADF_NUM_CY, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
482 if (adf_cfg_set_value(accel_dev, processed_sec, key, &num_inst))
483 goto failed;
484
485 crypto_inst = malloc(sizeof(*crypto_inst), M_QAT, M_WAITOK | M_ZERO);
486
487 for (i = 0; i < num_inst; i++) {
488 memset(crypto_inst, 0, sizeof(*crypto_inst));
489 crypto_inst->stype = serv_type;
490 snprintf(key,
491 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
492 ADF_CY_CORE_AFFINITY_FORMAT,
493 i);
494 if (adf_cfg_set_core_number_for_instance(accel_dev,
495 processed_sec,
496 key,
497 process_num,
498 &core_number))
499 goto failed;
500
501 if (strcmp(processed_sec, ADF_KERNEL_SEC) &&
502 strcmp(processed_sec, ADF_KERNEL_SAL_SEC))
503 adf_cfg_add_key_value_param(accel_dev,
504 derived_sec,
505 key,
506 (void *)&core_number,
507 ADF_DEC);
508
509 snprintf(key,
510 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
511 ADF_CY_NAME_FORMAT,
512 i);
513 if (adf_cfg_get_param_value(accel_dev, processed_sec, key, val))
514 goto failed;
515
516 strlcpy(crypto_inst->name, val, sizeof(crypto_inst->name));
517
518 snprintf(key,
519 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
520 ADF_CY_POLL_MODE_FORMAT,
521 i);
522 if (adf_cfg_set_value(
523 accel_dev, processed_sec, key, &polling_mode))
524 goto failed;
525
526 crypto_inst->polling_mode = polling_mode;
527 CPU_ZERO(&crypto_inst->affinity_mask);
528 CPU_SET(core_number, &crypto_inst->affinity_mask);
529
530 if (adf_cfg_get_ring_pairs(accel_dev->cfg->dev,
531 crypto_inst,
532 derived_sec,
533 accel_dev))
534 goto failed;
535
536 switch (serv_type) {
537 case CRYPTO:
538 adf_cfg_add_cy_inst_info(accel_dev,
539 crypto_inst,
540 derived_sec,
541 i);
542 break;
543 case ASYM:
544 adf_cfg_add_asym_inst_info(accel_dev,
545 crypto_inst,
546 derived_sec,
547 i);
548 break;
549 case SYM:
550 adf_cfg_add_sym_inst_info(accel_dev,
551 crypto_inst,
552 derived_sec,
553 i);
554 break;
555 default:
556 pr_err("unknown crypto instance type %d.\n", serv_type);
557 goto failed;
558 }
559 }
560
561 ret = 0;
562 failed:
563 free(crypto_inst, M_QAT);
564 free(val, M_QAT);
565 free(key, M_QAT);
566
567 if (ret)
568 device_printf(GET_DEV(accel_dev),
569 "Failed to create rings for cy\n");
570
571 return ret;
572 }
573
574 static int
adf_cfg_create_rings_entries_for_dc_inst(struct adf_accel_dev * accel_dev,const char * processed_sec,const char * derived_sec,int process_num)575 adf_cfg_create_rings_entries_for_dc_inst(struct adf_accel_dev *accel_dev,
576 const char *processed_sec,
577 const char *derived_sec,
578 int process_num)
579 {
580 int i = 0;
581 int ret = EFAULT;
582 unsigned long num_inst = 0, num_cy_inst = 0;
583 unsigned long core_number = 0;
584 unsigned long polling_mode = 0;
585 struct adf_cfg_instance *dc_inst = NULL;
586
587 char *key = NULL;
588 char *val = NULL;
589
590 key = malloc(ADF_CFG_MAX_KEY_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
591
592 val = malloc(ADF_CFG_MAX_VAL_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
593
594 ret = EFAULT;
595
596 snprintf(key, ADF_CFG_MAX_STR_LEN, ADF_SERVICES_ENABLED);
597 if (adf_cfg_get_param_value(accel_dev, ADF_GENERAL_SEC, key, val))
598 goto failed;
599
600 if (!strncmp(val, ADF_CFG_DC, ADF_CFG_MAX_VAL_LEN_IN_BYTES)) {
601 strlcpy(key, ADF_NUM_CY, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
602 if (adf_cfg_set_value(
603 accel_dev, processed_sec, key, &num_cy_inst))
604 goto failed;
605 if (num_cy_inst > 0) {
606 device_printf(
607 GET_DEV(accel_dev),
608 "NumCyInstances > 0,when DC only is enabled\n");
609 goto failed;
610 }
611 }
612
613 strlcpy(key, ADF_NUM_DC, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
614 if (adf_cfg_set_value(accel_dev, processed_sec, key, &num_inst))
615 goto failed;
616
617 dc_inst = malloc(sizeof(*dc_inst), M_QAT, M_WAITOK | M_ZERO);
618
619 for (i = 0; i < num_inst; i++) {
620 memset(dc_inst, 0, sizeof(*dc_inst));
621 dc_inst->stype = COMP;
622 snprintf(key,
623 ADF_CFG_MAX_STR_LEN,
624 ADF_DC_CORE_AFFINITY_FORMAT,
625 i);
626
627 if (adf_cfg_set_core_number_for_instance(accel_dev,
628 processed_sec,
629 key,
630 process_num,
631 &core_number))
632 goto failed;
633
634 if (strcmp(processed_sec, ADF_KERNEL_SEC) &&
635 strcmp(processed_sec, ADF_KERNEL_SAL_SEC)) {
636 adf_cfg_add_key_value_param(accel_dev,
637 derived_sec,
638 key,
639 (void *)&core_number,
640 ADF_DEC);
641 }
642
643 snprintf(key,
644 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
645 ADF_DC_NAME_FORMAT,
646 i);
647 if (adf_cfg_get_param_value(accel_dev, processed_sec, key, val))
648 goto failed;
649
650 strlcpy(dc_inst->name, val, sizeof(dc_inst->name));
651
652 snprintf(key,
653 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
654 ADF_DC_POLL_MODE_FORMAT,
655 i);
656 if (adf_cfg_set_value(
657 accel_dev, processed_sec, key, &polling_mode))
658 goto failed;
659
660 dc_inst->polling_mode = polling_mode;
661 CPU_ZERO(&dc_inst->affinity_mask);
662 CPU_SET(core_number, &dc_inst->affinity_mask);
663
664 if (adf_cfg_get_ring_pairs(
665 accel_dev->cfg->dev, dc_inst, derived_sec, accel_dev))
666 goto failed;
667
668 adf_cfg_add_dc_inst_info(accel_dev, dc_inst, derived_sec, i);
669 }
670
671 ret = 0;
672 failed:
673 free(dc_inst, M_QAT);
674 free(val, M_QAT);
675 free(key, M_QAT);
676
677 if (ret)
678 device_printf(GET_DEV(accel_dev),
679 "Failed to create rings for dc\n");
680
681 return ret;
682 }
683
684 static int
adf_cfg_process_user_section(struct adf_accel_dev * accel_dev,const char * sec_name,int dev)685 adf_cfg_process_user_section(struct adf_accel_dev *accel_dev,
686 const char *sec_name,
687 int dev)
688 {
689 int i = 0;
690 int ret = EFAULT;
691 unsigned long num_processes = 0;
692 unsigned long limit_dev_acc = 0;
693 u8 serv_type = 0;
694
695 char *key = NULL;
696 char *val = NULL;
697 char *derived_sec_name = NULL;
698
699 key = malloc(ADF_CFG_MAX_KEY_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
700
701 val = malloc(ADF_CFG_MAX_VAL_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
702
703 derived_sec_name =
704 malloc(ADF_CFG_MAX_STR_LEN, M_QAT, M_WAITOK | M_ZERO);
705
706 strlcpy(key, ADF_NUM_PROCESSES, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
707 if (adf_cfg_set_value(accel_dev, sec_name, key, &num_processes))
708 num_processes = 0;
709
710 strlcpy(key, ADF_LIMIT_DEV_ACCESS, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
711 if (adf_cfg_set_value(accel_dev, sec_name, key, &limit_dev_acc))
712 limit_dev_acc = 0;
713
714 for (i = 0; i < num_processes; i++) {
715 if (limit_dev_acc)
716 snprintf(derived_sec_name,
717 ADF_CFG_MAX_STR_LEN,
718 ADF_LIMITED_USER_SECTION_NAME_FORMAT,
719 sec_name,
720 dev,
721 i);
722 else
723 snprintf(derived_sec_name,
724 ADF_CFG_MAX_STR_LEN,
725 ADF_USER_SECTION_NAME_FORMAT,
726 sec_name,
727 i);
728
729 if (adf_cfg_derived_section_add(accel_dev, derived_sec_name))
730 goto failed;
731
732 /* copy items to the derived section */
733 adf_cfg_section_copy(accel_dev, sec_name, derived_sec_name);
734
735 for (serv_type = NA; serv_type <= USED; serv_type++) {
736 switch (serv_type) {
737 case NA:
738 break;
739 case CRYPTO:
740 case ASYM:
741 case SYM:
742 if (adf_cfg_is_svc_enabled(accel_dev,
743 serv_type))
744 if (adf_cfg_create_rings_entries_for_cy_inst(
745 accel_dev,
746 sec_name,
747 derived_sec_name,
748 i,
749 (enum adf_cfg_service_type)
750 serv_type))
751 goto failed;
752 break;
753 case COMP:
754 if (adf_cfg_is_svc_enabled(accel_dev,
755 serv_type))
756 if (adf_cfg_create_rings_entries_for_dc_inst(
757 accel_dev,
758 sec_name,
759 derived_sec_name,
760 i))
761 goto failed;
762 break;
763 case USED:
764 break;
765 default:
766 pr_err("Unknown service type %d.\n", serv_type);
767 }
768 }
769 }
770
771 ret = 0;
772 failed:
773
774 free(val, M_QAT);
775 free(key, M_QAT);
776 free(derived_sec_name, M_QAT);
777
778 if (ret)
779 device_printf(GET_DEV(accel_dev),
780 "Failed to process user section %s\n",
781 sec_name);
782
783 return ret;
784 }
785
786 static int
adf_cfg_cleanup_user_section(struct adf_accel_dev * accel_dev,const char * sec_name)787 adf_cfg_cleanup_user_section(struct adf_accel_dev *accel_dev,
788 const char *sec_name)
789 {
790 struct adf_cfg_section *sec = adf_cfg_sec_find(accel_dev, sec_name);
791 struct list_head *head;
792 struct list_head *list_ptr, *tmp;
793
794 if (!sec)
795 return EFAULT;
796
797 if (sec->is_derived)
798 return 0;
799
800 head = &sec->param_head;
801 list_for_each_prev_safe(list_ptr, tmp, head)
802 {
803 struct adf_cfg_key_val *ptr =
804 list_entry(list_ptr, struct adf_cfg_key_val, list);
805
806 if (!strcmp(ptr->key, ADF_LIMIT_DEV_ACCESS))
807 continue;
808
809 list_del(list_ptr);
810 free(ptr, M_QAT);
811 }
812 return 0;
813 }
814
815 static int
adf_cfg_process_section_no_op(struct adf_accel_dev * accel_dev,const char * sec_name)816 adf_cfg_process_section_no_op(struct adf_accel_dev *accel_dev,
817 const char *sec_name)
818 {
819 return 0;
820 }
821
822 static int
adf_cfg_cleanup_general_section(struct adf_accel_dev * accel_dev,const char * sec_name)823 adf_cfg_cleanup_general_section(struct adf_accel_dev *accel_dev,
824 const char *sec_name)
825 {
826 unsigned long first_used_bundle = 0;
827 int ret = EFAULT;
828 char *key = NULL;
829 char *val = NULL;
830
831 key = malloc(ADF_CFG_MAX_KEY_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
832
833 val = malloc(ADF_CFG_MAX_VAL_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
834
835 /* Remove sections that not needed after processing */
836 strlcpy(key, ADF_CONFIG_VERSION, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
837 if (adf_cfg_remove_key_param(accel_dev, sec_name, key))
838 goto failed;
839
840 strlcpy(key, ADF_CY ADF_RING_ASYM_SIZE, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
841 if (adf_cfg_remove_key_param(accel_dev, sec_name, key))
842 goto failed;
843
844 strlcpy(key, ADF_CY ADF_RING_SYM_SIZE, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
845 if (adf_cfg_remove_key_param(accel_dev, sec_name, key))
846 goto failed;
847
848 strlcpy(key, ADF_DC ADF_RING_DC_SIZE, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
849 if (adf_cfg_remove_key_param(accel_dev, sec_name, key))
850 goto failed;
851
852 /* After all processing done, set the "FirstUserBundle" value */
853 first_used_bundle = accel_dev->cfg->dev->max_kernel_bundle_nr + 1;
854 strlcpy(key, ADF_FIRST_USER_BUNDLE, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
855 if (adf_cfg_add_key_value_param(
856 accel_dev, sec_name, key, (void *)&first_used_bundle, ADF_DEC))
857 goto failed;
858
859 ret = 0;
860 failed:
861 free(key, M_QAT);
862 free(val, M_QAT);
863
864 if (ret)
865 device_printf(GET_DEV(accel_dev),
866 "Failed to clean up general section\n");
867
868 return ret;
869 }
870
871 static int
adf_cfg_process_kernel_section(struct adf_accel_dev * accel_dev,const char * sec_name)872 adf_cfg_process_kernel_section(struct adf_accel_dev *accel_dev,
873 const char *sec_name)
874 {
875 u8 serv_type = 0;
876
877 for (serv_type = NA; serv_type <= USED; serv_type++) {
878 switch (serv_type) {
879 case NA:
880 break;
881 case CRYPTO:
882 case ASYM:
883 case SYM:
884 if (adf_cfg_is_svc_enabled(accel_dev, serv_type))
885 if (adf_cfg_create_rings_entries_for_cy_inst(
886 accel_dev,
887 sec_name,
888 sec_name,
889 0,
890 (enum adf_cfg_service_type)serv_type))
891 goto failed;
892 break;
893 case COMP:
894 if (adf_cfg_is_svc_enabled(accel_dev, serv_type))
895 if (adf_cfg_create_rings_entries_for_dc_inst(
896 accel_dev, sec_name, sec_name, 0))
897 goto failed;
898 break;
899 case USED:
900 break;
901 default:
902 pr_err("Unknown service type of instance %d.\n",
903 serv_type);
904 }
905 }
906
907 return 0;
908
909 failed:
910 return EFAULT;
911 }
912
913 static int
adf_cfg_cleanup_kernel_section(struct adf_accel_dev * accel_dev,const char * sec_name)914 adf_cfg_cleanup_kernel_section(struct adf_accel_dev *accel_dev,
915 const char *sec_name)
916 {
917 return 0;
918 }
919
920 static int
adf_cfg_create_accel_section(struct adf_accel_dev * accel_dev,const char * sec_name)921 adf_cfg_create_accel_section(struct adf_accel_dev *accel_dev,
922 const char *sec_name)
923 {
924 /* Find global settings for coalescing. Use defaults if not found */
925 unsigned long accel_coales = 0;
926 unsigned long accel_coales_timer = 0;
927 unsigned long accel_coales_num_msg = 0;
928 unsigned long cpu;
929 char *key = NULL;
930 char *val = NULL;
931 int ret = EFAULT;
932 int index = 0;
933 struct adf_hw_device_data *hw_device = accel_dev->hw_device;
934
935 if (!hw_device)
936 goto failed;
937
938 key = malloc(ADF_CFG_MAX_KEY_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
939
940 val = malloc(ADF_CFG_MAX_VAL_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
941
942 strlcpy(key,
943 ADF_ETRMGR_COALESCING_ENABLED,
944 ADF_CFG_MAX_KEY_LEN_IN_BYTES);
945 if (adf_cfg_set_value(accel_dev, ADF_GENERAL_SEC, key, &accel_coales))
946 accel_coales = ADF_CFG_ACCEL_DEF_COALES;
947
948 strlcpy(key, ADF_ETRMGR_COALESCE_TIMER, ADF_CFG_MAX_KEY_LEN_IN_BYTES);
949 if (adf_cfg_set_value(
950 accel_dev, ADF_GENERAL_SEC, key, &accel_coales_timer))
951 accel_coales_timer = ADF_CFG_ACCEL_DEF_COALES_TIMER;
952
953 strlcpy(key,
954 ADF_ETRMGR_COALESCING_MSG_ENABLED,
955 ADF_CFG_MAX_KEY_LEN_IN_BYTES);
956 if (adf_cfg_set_value(
957 accel_dev, ADF_GENERAL_SEC, key, &accel_coales_num_msg))
958 accel_coales_num_msg = ADF_CFG_ACCEL_DEF_COALES_NUM_MSG;
959
960 for (index = 0; index < hw_device->num_banks; index++) {
961 snprintf(key,
962 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
963 ADF_ETRMGR_COALESCING_ENABLED_FORMAT,
964 index);
965 ret = adf_cfg_add_key_value_param(
966 accel_dev, sec_name, key, &accel_coales, ADF_DEC);
967 if (ret != 0)
968 goto failed;
969
970 snprintf(key,
971 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
972 ADF_ETRMGR_COALESCE_TIMER_FORMAT,
973 index);
974 ret = adf_cfg_add_key_value_param(
975 accel_dev, sec_name, key, &accel_coales_timer, ADF_DEC);
976 if (ret != 0)
977 goto failed;
978
979 snprintf(key,
980 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
981 ADF_ETRMGR_COALESCING_MSG_ENABLED_FORMAT,
982 index);
983 ret = adf_cfg_add_key_value_param(
984 accel_dev, sec_name, key, &accel_coales_num_msg, ADF_DEC);
985 if (ret != 0)
986 goto failed;
987
988 cpu = ADF_CFG_AFFINITY_WHATEVER;
989
990 snprintf(key,
991 ADF_CFG_MAX_KEY_LEN_IN_BYTES,
992 ADF_ETRMGR_CORE_AFFINITY_FORMAT,
993 index);
994 ret = adf_cfg_add_key_value_param(
995 accel_dev, sec_name, key, &cpu, ADF_DEC);
996 if (ret != 0)
997 goto failed;
998 }
999
1000 ret = 0;
1001
1002 failed:
1003 free(key, M_QAT);
1004 free(val, M_QAT);
1005
1006 if (ret)
1007 device_printf(GET_DEV(accel_dev),
1008 "Failed to create accel section\n");
1009
1010 return ret;
1011 }
1012
1013 static int
adf_cfg_cleanup_accel_section(struct adf_accel_dev * accel_dev,const char * sec_name)1014 adf_cfg_cleanup_accel_section(struct adf_accel_dev *accel_dev,
1015 const char *sec_name)
1016 {
1017 return 0;
1018 }
1019
1020 static int
adf_cfg_process_accel_section(struct adf_accel_dev * accel_dev,const char * sec_name)1021 adf_cfg_process_accel_section(struct adf_accel_dev *accel_dev,
1022 const char *sec_name)
1023 {
1024 int accel_num = 0;
1025 struct adf_hw_device_data *hw_device = accel_dev->hw_device;
1026 char *derived_name = NULL;
1027 int ret = EFAULT;
1028
1029 if (!hw_device)
1030 goto failed;
1031
1032 if (hw_device->num_logical_accel == 0)
1033 goto failed;
1034
1035 derived_name =
1036 malloc(ADF_CFG_MAX_SECTION_LEN_IN_BYTES, M_QAT, M_WAITOK | M_ZERO);
1037
1038 for (accel_num = 0; accel_num < hw_device->num_logical_accel;
1039 accel_num++) {
1040 snprintf(derived_name,
1041 ADF_CFG_MAX_SECTION_LEN_IN_BYTES,
1042 ADF_ACCEL_STR,
1043 accel_num);
1044 ret = adf_cfg_section_add(accel_dev, derived_name);
1045 if (ret != 0)
1046 goto failed;
1047
1048 ret = adf_cfg_create_accel_section(accel_dev, derived_name);
1049 if (ret != 0)
1050 goto failed;
1051 }
1052
1053 ret = 0;
1054 failed:
1055 free(derived_name, M_QAT);
1056
1057 if (ret)
1058 device_printf(GET_DEV(accel_dev),
1059 "Failed to process accel section\n");
1060
1061 return ret;
1062 }
1063
1064 int
adf_cfg_process_section(struct adf_accel_dev * accel_dev,const char * sec_name,int dev)1065 adf_cfg_process_section(struct adf_accel_dev *accel_dev,
1066 const char *sec_name,
1067 int dev)
1068 {
1069 if (!strcmp(sec_name, ADF_GENERAL_SEC) ||
1070 !strcmp(sec_name, ADF_INLINE_SEC))
1071 return adf_cfg_process_section_no_op(accel_dev, sec_name);
1072 else if (!strcmp(sec_name, ADF_KERNEL_SEC) ||
1073 !strcmp(sec_name, ADF_KERNEL_SAL_SEC))
1074 return adf_cfg_process_kernel_section(accel_dev, sec_name);
1075 else if (!strcmp(sec_name, ADF_ACCEL_SEC))
1076 return adf_cfg_process_accel_section(accel_dev, sec_name);
1077 else
1078 return adf_cfg_process_user_section(accel_dev, sec_name, dev);
1079 }
1080
1081 int
adf_cfg_cleanup_section(struct adf_accel_dev * accel_dev,const char * sec_name,int dev)1082 adf_cfg_cleanup_section(struct adf_accel_dev *accel_dev,
1083 const char *sec_name,
1084 int dev)
1085 {
1086 if (!strcmp(sec_name, ADF_GENERAL_SEC))
1087 return adf_cfg_cleanup_general_section(accel_dev, sec_name);
1088 else if (!strcmp(sec_name, ADF_INLINE_SEC))
1089 return adf_cfg_process_section_no_op(accel_dev, sec_name);
1090 else if (!strcmp(sec_name, ADF_KERNEL_SEC) ||
1091 !strcmp(sec_name, ADF_KERNEL_SAL_SEC))
1092 return adf_cfg_cleanup_kernel_section(accel_dev, sec_name);
1093 else if (strstr(sec_name, ADF_ACCEL_SEC))
1094 return adf_cfg_cleanup_accel_section(accel_dev, sec_name);
1095 else
1096 return adf_cfg_cleanup_user_section(accel_dev, sec_name);
1097 }
1098
1099 int
adf_cfg_setup_irq(struct adf_accel_dev * accel_dev)1100 adf_cfg_setup_irq(struct adf_accel_dev *accel_dev)
1101 {
1102 int ret = EFAULT;
1103 struct adf_accel_pci *info_pci_dev = &accel_dev->accel_pci_dev;
1104 struct adf_cfg_device *cfg_dev = NULL;
1105 struct msix_entry *msixe = NULL;
1106 u32 num_msix = 0;
1107 int index = 0;
1108 int computed_core = 0;
1109
1110 if (!accel_dev || !accel_dev->cfg || !accel_dev->hw_device)
1111 goto failed;
1112
1113 cfg_dev = accel_dev->cfg->dev;
1114 if (!cfg_dev)
1115 goto failed;
1116
1117 msixe =
1118 (struct msix_entry *)accel_dev->accel_pci_dev.msix_entries.entries;
1119 num_msix = accel_dev->accel_pci_dev.msix_entries.num_entries;
1120 if (!msixe)
1121 goto cleanup_and_fail;
1122
1123 /*
1124 * Here we want to set the affinity of kernel and epoll mode
1125 * bundle into user defined value.
1126 * Because in adf_isr.c we setup core affinity by round-robin
1127 * we need to reset it after device up done.
1128 */
1129 for (index = 0; index < accel_dev->hw_device->num_banks; index++) {
1130 struct adf_cfg_bundle *bundle = cfg_dev->bundles[index];
1131
1132 if (!bundle)
1133 continue;
1134
1135 if (bundle->type != KERNEL &&
1136 bundle->polling_mode != ADF_CFG_RESP_EPOLL)
1137 continue;
1138
1139 if (bundle->number >= num_msix)
1140 goto cleanup_and_fail;
1141
1142 computed_core = CPU_FFS(&bundle->affinity_mask) - 1;
1143 bus_bind_intr(info_pci_dev->pci_dev,
1144 msixe[index].irq,
1145 computed_core);
1146 }
1147 ret = 0;
1148
1149 cleanup_and_fail:
1150 adf_cfg_device_clear(cfg_dev, accel_dev);
1151 free(cfg_dev, M_QAT);
1152 accel_dev->cfg->dev = NULL;
1153
1154 failed:
1155 return ret;
1156 }
1157