1 // SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only)
2 /* Copyright(c) 2014 - 2020 Intel Corporation */
3 #include <linux/mutex.h>
4 #include <linux/slab.h>
5 #include <linux/list.h>
6 #include <linux/seq_file.h>
7 #include "adf_accel_devices.h"
8 #include "adf_cfg.h"
9 #include "adf_common_drv.h"
10 
11 static DEFINE_MUTEX(qat_cfg_read_lock);
12 
13 static void *qat_dev_cfg_start(struct seq_file *sfile, loff_t *pos)
14 {
15 	struct adf_cfg_device_data *dev_cfg = sfile->private;
16 
17 	mutex_lock(&qat_cfg_read_lock);
18 	return seq_list_start(&dev_cfg->sec_list, *pos);
19 }
20 
21 static int qat_dev_cfg_show(struct seq_file *sfile, void *v)
22 {
23 	struct list_head *list;
24 	struct adf_cfg_section *sec =
25 				list_entry(v, struct adf_cfg_section, list);
26 
27 	seq_printf(sfile, "[%s]\n", sec->name);
28 	list_for_each(list, &sec->param_head) {
29 		struct adf_cfg_key_val *ptr =
30 			list_entry(list, struct adf_cfg_key_val, list);
31 		seq_printf(sfile, "%s = %s\n", ptr->key, ptr->val);
32 	}
33 	return 0;
34 }
35 
36 static void *qat_dev_cfg_next(struct seq_file *sfile, void *v, loff_t *pos)
37 {
38 	struct adf_cfg_device_data *dev_cfg = sfile->private;
39 
40 	return seq_list_next(v, &dev_cfg->sec_list, pos);
41 }
42 
43 static void qat_dev_cfg_stop(struct seq_file *sfile, void *v)
44 {
45 	mutex_unlock(&qat_cfg_read_lock);
46 }
47 
48 static const struct seq_operations qat_dev_cfg_sops = {
49 	.start = qat_dev_cfg_start,
50 	.next = qat_dev_cfg_next,
51 	.stop = qat_dev_cfg_stop,
52 	.show = qat_dev_cfg_show
53 };
54 
55 DEFINE_SEQ_ATTRIBUTE(qat_dev_cfg);
56 
57 /**
58  * adf_cfg_dev_add() - Create an acceleration device configuration table.
59  * @accel_dev:  Pointer to acceleration device.
60  *
61  * Function creates a configuration table for the given acceleration device.
62  * The table stores device specific config values.
63  * To be used by QAT device specific drivers.
64  *
65  * Return: 0 on success, error code otherwise.
66  */
67 int adf_cfg_dev_add(struct adf_accel_dev *accel_dev)
68 {
69 	struct adf_cfg_device_data *dev_cfg_data;
70 
71 	dev_cfg_data = kzalloc(sizeof(*dev_cfg_data), GFP_KERNEL);
72 	if (!dev_cfg_data)
73 		return -ENOMEM;
74 	INIT_LIST_HEAD(&dev_cfg_data->sec_list);
75 	init_rwsem(&dev_cfg_data->lock);
76 	accel_dev->cfg = dev_cfg_data;
77 	return 0;
78 }
79 EXPORT_SYMBOL_GPL(adf_cfg_dev_add);
80 
81 void adf_cfg_dev_dbgfs_add(struct adf_accel_dev *accel_dev)
82 {
83 	struct adf_cfg_device_data *dev_cfg_data = accel_dev->cfg;
84 
85 	dev_cfg_data->debug = debugfs_create_file("dev_cfg", 0400,
86 						  accel_dev->debugfs_dir,
87 						  dev_cfg_data,
88 						  &qat_dev_cfg_fops);
89 }
90 
91 void adf_cfg_dev_dbgfs_rm(struct adf_accel_dev *accel_dev)
92 {
93 	struct adf_cfg_device_data *dev_cfg_data = accel_dev->cfg;
94 
95 	if (!dev_cfg_data)
96 		return;
97 
98 	debugfs_remove(dev_cfg_data->debug);
99 	dev_cfg_data->debug = NULL;
100 }
101 
102 static void adf_cfg_section_del_all(struct list_head *head);
103 
104 void adf_cfg_del_all(struct adf_accel_dev *accel_dev)
105 {
106 	struct adf_cfg_device_data *dev_cfg_data = accel_dev->cfg;
107 
108 	down_write(&dev_cfg_data->lock);
109 	adf_cfg_section_del_all(&dev_cfg_data->sec_list);
110 	up_write(&dev_cfg_data->lock);
111 	clear_bit(ADF_STATUS_CONFIGURED, &accel_dev->status);
112 }
113 
114 /**
115  * adf_cfg_dev_remove() - Clears acceleration device configuration table.
116  * @accel_dev:  Pointer to acceleration device.
117  *
118  * Function removes configuration table from the given acceleration device
119  * and frees all allocated memory.
120  * To be used by QAT device specific drivers.
121  *
122  * Return: void
123  */
124 void adf_cfg_dev_remove(struct adf_accel_dev *accel_dev)
125 {
126 	struct adf_cfg_device_data *dev_cfg_data = accel_dev->cfg;
127 
128 	if (!dev_cfg_data)
129 		return;
130 
131 	down_write(&dev_cfg_data->lock);
132 	adf_cfg_section_del_all(&dev_cfg_data->sec_list);
133 	up_write(&dev_cfg_data->lock);
134 	kfree(dev_cfg_data);
135 	accel_dev->cfg = NULL;
136 }
137 EXPORT_SYMBOL_GPL(adf_cfg_dev_remove);
138 
139 static void adf_cfg_keyval_add(struct adf_cfg_key_val *new,
140 			       struct adf_cfg_section *sec)
141 {
142 	list_add_tail(&new->list, &sec->param_head);
143 }
144 
145 static void adf_cfg_keyval_remove(const char *key, struct adf_cfg_section *sec)
146 {
147 	struct list_head *head = &sec->param_head;
148 	struct list_head *list_ptr, *tmp;
149 
150 	list_for_each_prev_safe(list_ptr, tmp, head) {
151 		struct adf_cfg_key_val *ptr =
152 			list_entry(list_ptr, struct adf_cfg_key_val, list);
153 
154 		if (strncmp(ptr->key, key, sizeof(ptr->key)))
155 			continue;
156 
157 		list_del(list_ptr);
158 		kfree(ptr);
159 		break;
160 	}
161 }
162 
163 static void adf_cfg_keyval_del_all(struct list_head *head)
164 {
165 	struct list_head *list_ptr, *tmp;
166 
167 	list_for_each_prev_safe(list_ptr, tmp, head) {
168 		struct adf_cfg_key_val *ptr =
169 			list_entry(list_ptr, struct adf_cfg_key_val, list);
170 		list_del(list_ptr);
171 		kfree(ptr);
172 	}
173 }
174 
175 static void adf_cfg_section_del_all(struct list_head *head)
176 {
177 	struct adf_cfg_section *ptr;
178 	struct list_head *list, *tmp;
179 
180 	list_for_each_prev_safe(list, tmp, head) {
181 		ptr = list_entry(list, struct adf_cfg_section, list);
182 		adf_cfg_keyval_del_all(&ptr->param_head);
183 		list_del(list);
184 		kfree(ptr);
185 	}
186 }
187 
188 static struct adf_cfg_key_val *adf_cfg_key_value_find(struct adf_cfg_section *s,
189 						      const char *key)
190 {
191 	struct list_head *list;
192 
193 	list_for_each(list, &s->param_head) {
194 		struct adf_cfg_key_val *ptr =
195 			list_entry(list, struct adf_cfg_key_val, list);
196 		if (!strcmp(ptr->key, key))
197 			return ptr;
198 	}
199 	return NULL;
200 }
201 
202 static struct adf_cfg_section *adf_cfg_sec_find(struct adf_accel_dev *accel_dev,
203 						const char *sec_name)
204 {
205 	struct adf_cfg_device_data *cfg = accel_dev->cfg;
206 	struct list_head *list;
207 
208 	list_for_each(list, &cfg->sec_list) {
209 		struct adf_cfg_section *ptr =
210 			list_entry(list, struct adf_cfg_section, list);
211 		if (!strcmp(ptr->name, sec_name))
212 			return ptr;
213 	}
214 	return NULL;
215 }
216 
217 static int adf_cfg_key_val_get(struct adf_accel_dev *accel_dev,
218 			       const char *sec_name,
219 			       const char *key_name,
220 			       char *val)
221 {
222 	struct adf_cfg_section *sec = adf_cfg_sec_find(accel_dev, sec_name);
223 	struct adf_cfg_key_val *keyval = NULL;
224 
225 	if (sec)
226 		keyval = adf_cfg_key_value_find(sec, key_name);
227 	if (keyval) {
228 		memcpy(val, keyval->val, ADF_CFG_MAX_VAL_LEN_IN_BYTES);
229 		return 0;
230 	}
231 	return -ENODATA;
232 }
233 
234 /**
235  * adf_cfg_add_key_value_param() - Add key-value config entry to config table.
236  * @accel_dev:  Pointer to acceleration device.
237  * @section_name: Name of the section where the param will be added
238  * @key: The key string
239  * @val: Value pain for the given @key
240  * @type: Type - string, int or address
241  *
242  * Function adds configuration key - value entry in the appropriate section
243  * in the given acceleration device. If the key exists already, the value
244  * is updated.
245  * To be used by QAT device specific drivers.
246  *
247  * Return: 0 on success, error code otherwise.
248  */
249 int adf_cfg_add_key_value_param(struct adf_accel_dev *accel_dev,
250 				const char *section_name,
251 				const char *key, const void *val,
252 				enum adf_cfg_val_type type)
253 {
254 	struct adf_cfg_device_data *cfg = accel_dev->cfg;
255 	struct adf_cfg_key_val *key_val;
256 	struct adf_cfg_section *section = adf_cfg_sec_find(accel_dev,
257 							   section_name);
258 	char temp_val[ADF_CFG_MAX_VAL_LEN_IN_BYTES];
259 
260 	if (!section)
261 		return -EFAULT;
262 
263 	key_val = kzalloc(sizeof(*key_val), GFP_KERNEL);
264 	if (!key_val)
265 		return -ENOMEM;
266 
267 	INIT_LIST_HEAD(&key_val->list);
268 	strscpy(key_val->key, key, sizeof(key_val->key));
269 
270 	if (type == ADF_DEC) {
271 		snprintf(key_val->val, ADF_CFG_MAX_VAL_LEN_IN_BYTES,
272 			 "%ld", (*((long *)val)));
273 	} else if (type == ADF_STR) {
274 		strscpy(key_val->val, (char *)val, sizeof(key_val->val));
275 	} else if (type == ADF_HEX) {
276 		snprintf(key_val->val, ADF_CFG_MAX_VAL_LEN_IN_BYTES,
277 			 "0x%lx", (unsigned long)val);
278 	} else {
279 		dev_err(&GET_DEV(accel_dev), "Unknown type given.\n");
280 		kfree(key_val);
281 		return -EINVAL;
282 	}
283 	key_val->type = type;
284 
285 	/* Add the key-value pair as below policy:
286 	 * 1. if the key doesn't exist, add it;
287 	 * 2. if the key already exists with a different value then update it
288 	 *    to the new value (the key is deleted and the newly created
289 	 *    key_val containing the new value is added to the database);
290 	 * 3. if the key exists with the same value, then return without doing
291 	 *    anything (the newly created key_val is freed).
292 	 */
293 	if (!adf_cfg_key_val_get(accel_dev, section_name, key, temp_val)) {
294 		if (strncmp(temp_val, key_val->val, sizeof(temp_val))) {
295 			adf_cfg_keyval_remove(key, section);
296 		} else {
297 			kfree(key_val);
298 			return 0;
299 		}
300 	}
301 
302 	down_write(&cfg->lock);
303 	adf_cfg_keyval_add(key_val, section);
304 	up_write(&cfg->lock);
305 	return 0;
306 }
307 EXPORT_SYMBOL_GPL(adf_cfg_add_key_value_param);
308 
309 /**
310  * adf_cfg_section_add() - Add config section entry to config table.
311  * @accel_dev:  Pointer to acceleration device.
312  * @name: Name of the section
313  *
314  * Function adds configuration section where key - value entries
315  * will be stored.
316  * To be used by QAT device specific drivers.
317  *
318  * Return: 0 on success, error code otherwise.
319  */
320 int adf_cfg_section_add(struct adf_accel_dev *accel_dev, const char *name)
321 {
322 	struct adf_cfg_device_data *cfg = accel_dev->cfg;
323 	struct adf_cfg_section *sec = adf_cfg_sec_find(accel_dev, name);
324 
325 	if (sec)
326 		return 0;
327 
328 	sec = kzalloc(sizeof(*sec), GFP_KERNEL);
329 	if (!sec)
330 		return -ENOMEM;
331 
332 	strscpy(sec->name, name, sizeof(sec->name));
333 	INIT_LIST_HEAD(&sec->param_head);
334 	down_write(&cfg->lock);
335 	list_add_tail(&sec->list, &cfg->sec_list);
336 	up_write(&cfg->lock);
337 	return 0;
338 }
339 EXPORT_SYMBOL_GPL(adf_cfg_section_add);
340 
341 int adf_cfg_get_param_value(struct adf_accel_dev *accel_dev,
342 			    const char *section, const char *name,
343 			    char *value)
344 {
345 	struct adf_cfg_device_data *cfg = accel_dev->cfg;
346 	int ret;
347 
348 	down_read(&cfg->lock);
349 	ret = adf_cfg_key_val_get(accel_dev, section, name, value);
350 	up_read(&cfg->lock);
351 	return ret;
352 }
353 EXPORT_SYMBOL_GPL(adf_cfg_get_param_value);
354