xref: /linux/drivers/crypto/intel/qat/qat_common/adf_gen4_config.c (revision c532de5a67a70f8533d495f8f2aaa9a0491c3ad0)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright(c) 2023 Intel Corporation */
3 #include "adf_accel_devices.h"
4 #include "adf_cfg.h"
5 #include "adf_cfg_services.h"
6 #include "adf_cfg_strings.h"
7 #include "adf_common_drv.h"
8 #include "adf_gen4_config.h"
9 #include "adf_heartbeat.h"
10 #include "adf_transport_access_macros.h"
11 #include "qat_compression.h"
12 #include "qat_crypto.h"
13 
14 static int adf_crypto_dev_config(struct adf_accel_dev *accel_dev)
15 {
16 	char key[ADF_CFG_MAX_KEY_LEN_IN_BYTES];
17 	int banks = GET_MAX_BANKS(accel_dev);
18 	int cpus = num_online_cpus();
19 	unsigned long bank, val;
20 	int instances;
21 	int ret;
22 	int i;
23 
24 	if (adf_hw_dev_has_crypto(accel_dev))
25 		instances = min(cpus, banks / 2);
26 	else
27 		instances = 0;
28 
29 	for (i = 0; i < instances; i++) {
30 		val = i;
31 		bank = i * 2;
32 		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_BANK_NUM, i);
33 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
34 						  key, &bank, ADF_DEC);
35 		if (ret)
36 			goto err;
37 
38 		bank += 1;
39 		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_BANK_NUM, i);
40 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
41 						  key, &bank, ADF_DEC);
42 		if (ret)
43 			goto err;
44 
45 		snprintf(key, sizeof(key), ADF_CY "%d" ADF_ETRMGR_CORE_AFFINITY,
46 			 i);
47 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
48 						  key, &val, ADF_DEC);
49 		if (ret)
50 			goto err;
51 
52 		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_SIZE, i);
53 		val = 128;
54 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
55 						  key, &val, ADF_DEC);
56 		if (ret)
57 			goto err;
58 
59 		val = 512;
60 		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_SIZE, i);
61 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
62 						  key, &val, ADF_DEC);
63 		if (ret)
64 			goto err;
65 
66 		val = 0;
67 		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_TX, i);
68 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
69 						  key, &val, ADF_DEC);
70 		if (ret)
71 			goto err;
72 
73 		val = 0;
74 		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_TX, i);
75 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
76 						  key, &val, ADF_DEC);
77 		if (ret)
78 			goto err;
79 
80 		val = 1;
81 		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_RX, i);
82 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
83 						  key, &val, ADF_DEC);
84 		if (ret)
85 			goto err;
86 
87 		val = 1;
88 		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_RX, i);
89 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
90 						  key, &val, ADF_DEC);
91 		if (ret)
92 			goto err;
93 
94 		val = ADF_COALESCING_DEF_TIME;
95 		snprintf(key, sizeof(key), ADF_ETRMGR_COALESCE_TIMER_FORMAT, i);
96 		ret = adf_cfg_add_key_value_param(accel_dev, "Accelerator0",
97 						  key, &val, ADF_DEC);
98 		if (ret)
99 			goto err;
100 	}
101 
102 	val = i;
103 	ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC, ADF_NUM_CY,
104 					  &val, ADF_DEC);
105 	if (ret)
106 		goto err;
107 
108 	val = 0;
109 	ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC, ADF_NUM_DC,
110 					  &val, ADF_DEC);
111 	if (ret)
112 		goto err;
113 
114 	return 0;
115 err:
116 	dev_err(&GET_DEV(accel_dev), "Failed to add configuration for crypto\n");
117 	return ret;
118 }
119 
120 static int adf_comp_dev_config(struct adf_accel_dev *accel_dev)
121 {
122 	char key[ADF_CFG_MAX_KEY_LEN_IN_BYTES];
123 	int banks = GET_MAX_BANKS(accel_dev);
124 	int cpus = num_online_cpus();
125 	unsigned long val;
126 	int instances;
127 	int ret;
128 	int i;
129 
130 	if (adf_hw_dev_has_compression(accel_dev))
131 		instances = min(cpus, banks);
132 	else
133 		instances = 0;
134 
135 	for (i = 0; i < instances; i++) {
136 		val = i;
137 		snprintf(key, sizeof(key), ADF_DC "%d" ADF_RING_DC_BANK_NUM, i);
138 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
139 						  key, &val, ADF_DEC);
140 		if (ret)
141 			goto err;
142 
143 		val = 512;
144 		snprintf(key, sizeof(key), ADF_DC "%d" ADF_RING_DC_SIZE, i);
145 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
146 						  key, &val, ADF_DEC);
147 		if (ret)
148 			goto err;
149 
150 		val = 0;
151 		snprintf(key, sizeof(key), ADF_DC "%d" ADF_RING_DC_TX, i);
152 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
153 						  key, &val, ADF_DEC);
154 		if (ret)
155 			goto err;
156 
157 		val = 1;
158 		snprintf(key, sizeof(key), ADF_DC "%d" ADF_RING_DC_RX, i);
159 		ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
160 						  key, &val, ADF_DEC);
161 		if (ret)
162 			goto err;
163 
164 		val = ADF_COALESCING_DEF_TIME;
165 		snprintf(key, sizeof(key), ADF_ETRMGR_COALESCE_TIMER_FORMAT, i);
166 		ret = adf_cfg_add_key_value_param(accel_dev, "Accelerator0",
167 						  key, &val, ADF_DEC);
168 		if (ret)
169 			goto err;
170 	}
171 
172 	val = i;
173 	ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC, ADF_NUM_DC,
174 					  &val, ADF_DEC);
175 	if (ret)
176 		goto err;
177 
178 	val = 0;
179 	ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC, ADF_NUM_CY,
180 					  &val, ADF_DEC);
181 	if (ret)
182 		goto err;
183 
184 	return 0;
185 err:
186 	dev_err(&GET_DEV(accel_dev), "Failed to add configuration for compression\n");
187 	return ret;
188 }
189 
190 static int adf_no_dev_config(struct adf_accel_dev *accel_dev)
191 {
192 	unsigned long val;
193 	int ret;
194 
195 	val = 0;
196 	ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC, ADF_NUM_DC,
197 					  &val, ADF_DEC);
198 	if (ret)
199 		return ret;
200 
201 	return adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC, ADF_NUM_CY,
202 					  &val, ADF_DEC);
203 }
204 
205 /**
206  * adf_gen4_dev_config() - create dev config required to create instances
207  *
208  * @accel_dev: Pointer to acceleration device.
209  *
210  * Function creates device configuration required to create instances
211  *
212  * Return: 0 on success, error code otherwise.
213  */
214 int adf_gen4_dev_config(struct adf_accel_dev *accel_dev)
215 {
216 	char services[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = {0};
217 	int ret;
218 
219 	ret = adf_cfg_section_add(accel_dev, ADF_KERNEL_SEC);
220 	if (ret)
221 		goto err;
222 
223 	ret = adf_cfg_section_add(accel_dev, "Accelerator0");
224 	if (ret)
225 		goto err;
226 
227 	ret = adf_cfg_get_param_value(accel_dev, ADF_GENERAL_SEC,
228 				      ADF_SERVICES_ENABLED, services);
229 	if (ret)
230 		goto err;
231 
232 	ret = sysfs_match_string(adf_cfg_services, services);
233 	if (ret < 0)
234 		goto err;
235 
236 	switch (ret) {
237 	case SVC_CY:
238 	case SVC_CY2:
239 		ret = adf_crypto_dev_config(accel_dev);
240 		break;
241 	case SVC_DC:
242 	case SVC_DCC:
243 		ret = adf_comp_dev_config(accel_dev);
244 		break;
245 	default:
246 		ret = adf_no_dev_config(accel_dev);
247 		break;
248 	}
249 
250 	if (ret)
251 		goto err;
252 
253 	set_bit(ADF_STATUS_CONFIGURED, &accel_dev->status);
254 
255 	return ret;
256 
257 err:
258 	dev_err(&GET_DEV(accel_dev), "Failed to configure QAT driver\n");
259 	return ret;
260 }
261 EXPORT_SYMBOL_GPL(adf_gen4_dev_config);
262 
263 int adf_gen4_cfg_dev_init(struct adf_accel_dev *accel_dev)
264 {
265 	const char *config;
266 	int ret;
267 
268 	config = accel_dev->accel_id % 2 ? ADF_CFG_DC : ADF_CFG_CY;
269 
270 	ret = adf_cfg_section_add(accel_dev, ADF_GENERAL_SEC);
271 	if (ret)
272 		return ret;
273 
274 	/* Default configuration is crypto only for even devices
275 	 * and compression for odd devices
276 	 */
277 	ret = adf_cfg_add_key_value_param(accel_dev, ADF_GENERAL_SEC,
278 					  ADF_SERVICES_ENABLED, config,
279 					  ADF_STR);
280 	if (ret)
281 		return ret;
282 
283 	adf_heartbeat_save_cfg_param(accel_dev, ADF_CFG_HB_TIMER_MIN_MS);
284 
285 	return 0;
286 }
287 EXPORT_SYMBOL_GPL(adf_gen4_cfg_dev_init);
288