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/list.h>
5 #include "adf_cfg.h"
6 #include "adf_common_drv.h"
7 
8 static LIST_HEAD(accel_table);
9 static LIST_HEAD(vfs_table);
10 static DEFINE_MUTEX(table_lock);
11 static u32 num_devices;
12 static u8 id_map[ADF_MAX_DEVICES];
13 
14 struct vf_id_map {
15 	u32 bdf;
16 	u32 id;
17 	u32 fake_id;
18 	bool attached;
19 	struct list_head list;
20 };
21 
22 static int adf_get_vf_id(struct adf_accel_dev *vf)
23 {
24 	return ((7 * (PCI_SLOT(accel_to_pci_dev(vf)->devfn) - 1)) +
25 		PCI_FUNC(accel_to_pci_dev(vf)->devfn) +
26 		(PCI_SLOT(accel_to_pci_dev(vf)->devfn) - 1));
27 }
28 
29 static int adf_get_vf_num(struct adf_accel_dev *vf)
30 {
31 	return (accel_to_pci_dev(vf)->bus->number << 8) | adf_get_vf_id(vf);
32 }
33 
34 static struct vf_id_map *adf_find_vf(u32 bdf)
35 {
36 	struct list_head *itr;
37 
38 	list_for_each(itr, &vfs_table) {
39 		struct vf_id_map *ptr =
40 			list_entry(itr, struct vf_id_map, list);
41 
42 		if (ptr->bdf == bdf)
43 			return ptr;
44 	}
45 	return NULL;
46 }
47 
48 static int adf_get_vf_real_id(u32 fake)
49 {
50 	struct list_head *itr;
51 
52 	list_for_each(itr, &vfs_table) {
53 		struct vf_id_map *ptr =
54 			list_entry(itr, struct vf_id_map, list);
55 		if (ptr->fake_id == fake)
56 			return ptr->id;
57 	}
58 	return -1;
59 }
60 
61 /**
62  * adf_clean_vf_map() - Cleans VF id mapings
63  *
64  * Function cleans internal ids for virtual functions.
65  * @vf: flag indicating whether mappings is cleaned
66  *	for vfs only or for vfs and pfs
67  */
68 void adf_clean_vf_map(bool vf)
69 {
70 	struct vf_id_map *map;
71 	struct list_head *ptr, *tmp;
72 
73 	mutex_lock(&table_lock);
74 	list_for_each_safe(ptr, tmp, &vfs_table) {
75 		map = list_entry(ptr, struct vf_id_map, list);
76 		if (map->bdf != -1) {
77 			id_map[map->id] = 0;
78 			num_devices--;
79 		}
80 
81 		if (vf && map->bdf == -1)
82 			continue;
83 
84 		list_del(ptr);
85 		kfree(map);
86 	}
87 	mutex_unlock(&table_lock);
88 }
89 EXPORT_SYMBOL_GPL(adf_clean_vf_map);
90 
91 /**
92  * adf_devmgr_update_class_index() - Update internal index
93  * @hw_data:  Pointer to internal device data.
94  *
95  * Function updates internal dev index for VFs
96  */
97 void adf_devmgr_update_class_index(struct adf_hw_device_data *hw_data)
98 {
99 	struct adf_hw_device_class *class = hw_data->dev_class;
100 	struct list_head *itr;
101 	int i = 0;
102 
103 	list_for_each(itr, &accel_table) {
104 		struct adf_accel_dev *ptr =
105 				list_entry(itr, struct adf_accel_dev, list);
106 
107 		if (ptr->hw_device->dev_class == class)
108 			ptr->hw_device->instance_id = i++;
109 
110 		if (i == class->instances)
111 			break;
112 	}
113 }
114 EXPORT_SYMBOL_GPL(adf_devmgr_update_class_index);
115 
116 static unsigned int adf_find_free_id(void)
117 {
118 	unsigned int i;
119 
120 	for (i = 0; i < ADF_MAX_DEVICES; i++) {
121 		if (!id_map[i]) {
122 			id_map[i] = 1;
123 			return i;
124 		}
125 	}
126 	return ADF_MAX_DEVICES + 1;
127 }
128 
129 /**
130  * adf_devmgr_add_dev() - Add accel_dev to the acceleration framework
131  * @accel_dev:  Pointer to acceleration device.
132  * @pf:		Corresponding PF if the accel_dev is a VF
133  *
134  * Function adds acceleration device to the acceleration framework.
135  * To be used by QAT device specific drivers.
136  *
137  * Return: 0 on success, error code otherwise.
138  */
139 int adf_devmgr_add_dev(struct adf_accel_dev *accel_dev,
140 		       struct adf_accel_dev *pf)
141 {
142 	struct list_head *itr;
143 	int ret = 0;
144 
145 	if (num_devices == ADF_MAX_DEVICES) {
146 		dev_err(&GET_DEV(accel_dev), "Only support up to %d devices\n",
147 			ADF_MAX_DEVICES);
148 		return -EFAULT;
149 	}
150 
151 	mutex_lock(&table_lock);
152 	atomic_set(&accel_dev->ref_count, 0);
153 
154 	/* PF on host or VF on guest - optimized to remove redundant is_vf */
155 	if (!accel_dev->is_vf || !pf) {
156 		struct vf_id_map *map;
157 
158 		list_for_each(itr, &accel_table) {
159 			struct adf_accel_dev *ptr =
160 				list_entry(itr, struct adf_accel_dev, list);
161 
162 			if (ptr == accel_dev) {
163 				ret = -EEXIST;
164 				goto unlock;
165 			}
166 		}
167 
168 		list_add_tail(&accel_dev->list, &accel_table);
169 		accel_dev->accel_id = adf_find_free_id();
170 		if (accel_dev->accel_id > ADF_MAX_DEVICES) {
171 			ret = -EFAULT;
172 			goto unlock;
173 		}
174 		num_devices++;
175 		map = kzalloc(sizeof(*map), GFP_KERNEL);
176 		if (!map) {
177 			ret = -ENOMEM;
178 			goto unlock;
179 		}
180 		map->bdf = ~0;
181 		map->id = accel_dev->accel_id;
182 		map->fake_id = map->id;
183 		map->attached = true;
184 		list_add_tail(&map->list, &vfs_table);
185 	} else if (accel_dev->is_vf && pf) {
186 		/* VF on host */
187 		struct vf_id_map *map;
188 
189 		map = adf_find_vf(adf_get_vf_num(accel_dev));
190 		if (map) {
191 			struct vf_id_map *next;
192 
193 			accel_dev->accel_id = map->id;
194 			list_add_tail(&accel_dev->list, &accel_table);
195 			map->fake_id++;
196 			map->attached = true;
197 			next = list_next_entry(map, list);
198 			while (next && &next->list != &vfs_table) {
199 				next->fake_id++;
200 				next = list_next_entry(next, list);
201 			}
202 
203 			ret = 0;
204 			goto unlock;
205 		}
206 
207 		map = kzalloc(sizeof(*map), GFP_KERNEL);
208 		if (!map) {
209 			ret = -ENOMEM;
210 			goto unlock;
211 		}
212 		accel_dev->accel_id = adf_find_free_id();
213 		if (accel_dev->accel_id > ADF_MAX_DEVICES) {
214 			kfree(map);
215 			ret = -EFAULT;
216 			goto unlock;
217 		}
218 		num_devices++;
219 		list_add_tail(&accel_dev->list, &accel_table);
220 		map->bdf = adf_get_vf_num(accel_dev);
221 		map->id = accel_dev->accel_id;
222 		map->fake_id = map->id;
223 		map->attached = true;
224 		list_add_tail(&map->list, &vfs_table);
225 	}
226 	mutex_init(&accel_dev->state_lock);
227 unlock:
228 	mutex_unlock(&table_lock);
229 	return ret;
230 }
231 EXPORT_SYMBOL_GPL(adf_devmgr_add_dev);
232 
233 struct list_head *adf_devmgr_get_head(void)
234 {
235 	return &accel_table;
236 }
237 
238 /**
239  * adf_devmgr_rm_dev() - Remove accel_dev from the acceleration framework.
240  * @accel_dev:  Pointer to acceleration device.
241  * @pf:		Corresponding PF if the accel_dev is a VF
242  *
243  * Function removes acceleration device from the acceleration framework.
244  * To be used by QAT device specific drivers.
245  *
246  * Return: void
247  */
248 void adf_devmgr_rm_dev(struct adf_accel_dev *accel_dev,
249 		       struct adf_accel_dev *pf)
250 {
251 	mutex_lock(&table_lock);
252 	/* PF on host or VF on guest - optimized to remove redundant is_vf */
253 	if (!accel_dev->is_vf || !pf) {
254 		id_map[accel_dev->accel_id] = 0;
255 		num_devices--;
256 	} else if (accel_dev->is_vf && pf) {
257 		struct vf_id_map *map, *next;
258 
259 		map = adf_find_vf(adf_get_vf_num(accel_dev));
260 		if (!map) {
261 			dev_err(&GET_DEV(accel_dev), "Failed to find VF map\n");
262 			goto unlock;
263 		}
264 		map->fake_id--;
265 		map->attached = false;
266 		next = list_next_entry(map, list);
267 		while (next && &next->list != &vfs_table) {
268 			next->fake_id--;
269 			next = list_next_entry(next, list);
270 		}
271 	}
272 unlock:
273 	mutex_destroy(&accel_dev->state_lock);
274 	list_del(&accel_dev->list);
275 	mutex_unlock(&table_lock);
276 }
277 EXPORT_SYMBOL_GPL(adf_devmgr_rm_dev);
278 
279 struct adf_accel_dev *adf_devmgr_get_first(void)
280 {
281 	struct adf_accel_dev *dev = NULL;
282 
283 	if (!list_empty(&accel_table))
284 		dev = list_first_entry(&accel_table, struct adf_accel_dev,
285 				       list);
286 	return dev;
287 }
288 
289 /**
290  * adf_devmgr_pci_to_accel_dev() - Get accel_dev associated with the pci_dev.
291  * @pci_dev:  Pointer to PCI device.
292  *
293  * Function returns acceleration device associated with the given PCI device.
294  * To be used by QAT device specific drivers.
295  *
296  * Return: pointer to accel_dev or NULL if not found.
297  */
298 struct adf_accel_dev *adf_devmgr_pci_to_accel_dev(struct pci_dev *pci_dev)
299 {
300 	struct list_head *itr;
301 
302 	mutex_lock(&table_lock);
303 	list_for_each(itr, &accel_table) {
304 		struct adf_accel_dev *ptr =
305 				list_entry(itr, struct adf_accel_dev, list);
306 
307 		if (ptr->accel_pci_dev.pci_dev == pci_dev) {
308 			mutex_unlock(&table_lock);
309 			return ptr;
310 		}
311 	}
312 	mutex_unlock(&table_lock);
313 	return NULL;
314 }
315 EXPORT_SYMBOL_GPL(adf_devmgr_pci_to_accel_dev);
316 
317 struct adf_accel_dev *adf_devmgr_get_dev_by_id(u32 id)
318 {
319 	struct list_head *itr;
320 	int real_id;
321 
322 	mutex_lock(&table_lock);
323 	real_id = adf_get_vf_real_id(id);
324 	if (real_id < 0)
325 		goto unlock;
326 
327 	id = real_id;
328 
329 	list_for_each(itr, &accel_table) {
330 		struct adf_accel_dev *ptr =
331 				list_entry(itr, struct adf_accel_dev, list);
332 		if (ptr->accel_id == id) {
333 			mutex_unlock(&table_lock);
334 			return ptr;
335 		}
336 	}
337 unlock:
338 	mutex_unlock(&table_lock);
339 	return NULL;
340 }
341 
342 int adf_devmgr_verify_id(u32 id)
343 {
344 	if (id == ADF_CFG_ALL_DEVICES)
345 		return 0;
346 
347 	if (adf_devmgr_get_dev_by_id(id))
348 		return 0;
349 
350 	return -ENODEV;
351 }
352 
353 static int adf_get_num_dettached_vfs(void)
354 {
355 	struct list_head *itr;
356 	int vfs = 0;
357 
358 	mutex_lock(&table_lock);
359 	list_for_each(itr, &vfs_table) {
360 		struct vf_id_map *ptr =
361 			list_entry(itr, struct vf_id_map, list);
362 		if (ptr->bdf != ~0 && !ptr->attached)
363 			vfs++;
364 	}
365 	mutex_unlock(&table_lock);
366 	return vfs;
367 }
368 
369 void adf_devmgr_get_num_dev(u32 *num)
370 {
371 	*num = num_devices - adf_get_num_dettached_vfs();
372 }
373 
374 /**
375  * adf_dev_in_use() - Check whether accel_dev is currently in use
376  * @accel_dev: Pointer to acceleration device.
377  *
378  * To be used by QAT device specific drivers.
379  *
380  * Return: 1 when device is in use, 0 otherwise.
381  */
382 int adf_dev_in_use(struct adf_accel_dev *accel_dev)
383 {
384 	return atomic_read(&accel_dev->ref_count) != 0;
385 }
386 EXPORT_SYMBOL_GPL(adf_dev_in_use);
387 
388 /**
389  * adf_dev_get() - Increment accel_dev reference count
390  * @accel_dev: Pointer to acceleration device.
391  *
392  * Increment the accel_dev refcount and if this is the first time
393  * incrementing it during this period the accel_dev is in use,
394  * increment the module refcount too.
395  * To be used by QAT device specific drivers.
396  *
397  * Return: 0 when successful, EFAULT when fail to bump module refcount
398  */
399 int adf_dev_get(struct adf_accel_dev *accel_dev)
400 {
401 	if (atomic_add_return(1, &accel_dev->ref_count) == 1)
402 		if (!try_module_get(accel_dev->owner))
403 			return -EFAULT;
404 	return 0;
405 }
406 EXPORT_SYMBOL_GPL(adf_dev_get);
407 
408 /**
409  * adf_dev_put() - Decrement accel_dev reference count
410  * @accel_dev: Pointer to acceleration device.
411  *
412  * Decrement the accel_dev refcount and if this is the last time
413  * decrementing it during this period the accel_dev is in use,
414  * decrement the module refcount too.
415  * To be used by QAT device specific drivers.
416  *
417  * Return: void
418  */
419 void adf_dev_put(struct adf_accel_dev *accel_dev)
420 {
421 	if (atomic_sub_return(1, &accel_dev->ref_count) == 0)
422 		module_put(accel_dev->owner);
423 }
424 EXPORT_SYMBOL_GPL(adf_dev_put);
425 
426 /**
427  * adf_devmgr_in_reset() - Check whether device is in reset
428  * @accel_dev: Pointer to acceleration device.
429  *
430  * To be used by QAT device specific drivers.
431  *
432  * Return: 1 when the device is being reset, 0 otherwise.
433  */
434 int adf_devmgr_in_reset(struct adf_accel_dev *accel_dev)
435 {
436 	return test_bit(ADF_STATUS_RESTARTING, &accel_dev->status);
437 }
438 EXPORT_SYMBOL_GPL(adf_devmgr_in_reset);
439 
440 /**
441  * adf_dev_started() - Check whether device has started
442  * @accel_dev: Pointer to acceleration device.
443  *
444  * To be used by QAT device specific drivers.
445  *
446  * Return: 1 when the device has started, 0 otherwise
447  */
448 int adf_dev_started(struct adf_accel_dev *accel_dev)
449 {
450 	return test_bit(ADF_STATUS_STARTED, &accel_dev->status);
451 }
452 EXPORT_SYMBOL_GPL(adf_dev_started);
453