1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * PCI Endpoint *Function* (EPF) library
4  *
5  * Copyright (C) 2017 Texas Instruments
6  * Author: Kishon Vijay Abraham I <kishon@ti.com>
7  */
8 
9 #include <linux/device.h>
10 #include <linux/dma-mapping.h>
11 #include <linux/slab.h>
12 #include <linux/module.h>
13 
14 #include <linux/pci-epc.h>
15 #include <linux/pci-epf.h>
16 #include <linux/pci-ep-cfs.h>
17 
18 static DEFINE_MUTEX(pci_epf_mutex);
19 
20 static struct bus_type pci_epf_bus_type;
21 static const struct device_type pci_epf_type;
22 
23 /**
24  * pci_epf_unbind() - Notify the function driver that the binding between the
25  *		      EPF device and EPC device has been lost
26  * @epf: the EPF device which has lost the binding with the EPC device
27  *
28  * Invoke to notify the function driver that the binding between the EPF device
29  * and EPC device has been lost.
30  */
31 void pci_epf_unbind(struct pci_epf *epf)
32 {
33 	struct pci_epf *epf_vf;
34 
35 	if (!epf->driver) {
36 		dev_WARN(&epf->dev, "epf device not bound to driver\n");
37 		return;
38 	}
39 
40 	mutex_lock(&epf->lock);
41 	list_for_each_entry(epf_vf, &epf->pci_vepf, list) {
42 		if (epf_vf->is_bound)
43 			epf_vf->driver->ops->unbind(epf_vf);
44 	}
45 	if (epf->is_bound)
46 		epf->driver->ops->unbind(epf);
47 	mutex_unlock(&epf->lock);
48 	module_put(epf->driver->owner);
49 }
50 EXPORT_SYMBOL_GPL(pci_epf_unbind);
51 
52 /**
53  * pci_epf_bind() - Notify the function driver that the EPF device has been
54  *		    bound to a EPC device
55  * @epf: the EPF device which has been bound to the EPC device
56  *
57  * Invoke to notify the function driver that it has been bound to a EPC device
58  */
59 int pci_epf_bind(struct pci_epf *epf)
60 {
61 	struct device *dev = &epf->dev;
62 	struct pci_epf *epf_vf;
63 	u8 func_no, vfunc_no;
64 	struct pci_epc *epc;
65 	int ret;
66 
67 	if (!epf->driver) {
68 		dev_WARN(dev, "epf device not bound to driver\n");
69 		return -EINVAL;
70 	}
71 
72 	if (!try_module_get(epf->driver->owner))
73 		return -EAGAIN;
74 
75 	mutex_lock(&epf->lock);
76 	list_for_each_entry(epf_vf, &epf->pci_vepf, list) {
77 		vfunc_no = epf_vf->vfunc_no;
78 
79 		if (vfunc_no < 1) {
80 			dev_err(dev, "Invalid virtual function number\n");
81 			ret = -EINVAL;
82 			goto ret;
83 		}
84 
85 		epc = epf->epc;
86 		func_no = epf->func_no;
87 		if (!IS_ERR_OR_NULL(epc)) {
88 			if (!epc->max_vfs) {
89 				dev_err(dev, "No support for virt function\n");
90 				ret = -EINVAL;
91 				goto ret;
92 			}
93 
94 			if (vfunc_no > epc->max_vfs[func_no]) {
95 				dev_err(dev, "PF%d: Exceeds max vfunc number\n",
96 					func_no);
97 				ret = -EINVAL;
98 				goto ret;
99 			}
100 		}
101 
102 		epc = epf->sec_epc;
103 		func_no = epf->sec_epc_func_no;
104 		if (!IS_ERR_OR_NULL(epc)) {
105 			if (!epc->max_vfs) {
106 				dev_err(dev, "No support for virt function\n");
107 				ret = -EINVAL;
108 				goto ret;
109 			}
110 
111 			if (vfunc_no > epc->max_vfs[func_no]) {
112 				dev_err(dev, "PF%d: Exceeds max vfunc number\n",
113 					func_no);
114 				ret = -EINVAL;
115 				goto ret;
116 			}
117 		}
118 
119 		epf_vf->func_no = epf->func_no;
120 		epf_vf->sec_epc_func_no = epf->sec_epc_func_no;
121 		epf_vf->epc = epf->epc;
122 		epf_vf->sec_epc = epf->sec_epc;
123 		ret = epf_vf->driver->ops->bind(epf_vf);
124 		if (ret)
125 			goto ret;
126 		epf_vf->is_bound = true;
127 	}
128 
129 	ret = epf->driver->ops->bind(epf);
130 	if (ret)
131 		goto ret;
132 	epf->is_bound = true;
133 
134 	mutex_unlock(&epf->lock);
135 	return 0;
136 
137 ret:
138 	mutex_unlock(&epf->lock);
139 	pci_epf_unbind(epf);
140 
141 	return ret;
142 }
143 EXPORT_SYMBOL_GPL(pci_epf_bind);
144 
145 /**
146  * pci_epf_add_vepf() - associate virtual EP function to physical EP function
147  * @epf_pf: the physical EP function to which the virtual EP function should be
148  *   associated
149  * @epf_vf: the virtual EP function to be added
150  *
151  * A physical endpoint function can be associated with multiple virtual
152  * endpoint functions. Invoke pci_epf_add_epf() to add a virtual PCI endpoint
153  * function to a physical PCI endpoint function.
154  */
155 int pci_epf_add_vepf(struct pci_epf *epf_pf, struct pci_epf *epf_vf)
156 {
157 	u32 vfunc_no;
158 
159 	if (IS_ERR_OR_NULL(epf_pf) || IS_ERR_OR_NULL(epf_vf))
160 		return -EINVAL;
161 
162 	if (epf_pf->epc || epf_vf->epc || epf_vf->epf_pf)
163 		return -EBUSY;
164 
165 	if (epf_pf->sec_epc || epf_vf->sec_epc)
166 		return -EBUSY;
167 
168 	mutex_lock(&epf_pf->lock);
169 	vfunc_no = find_first_zero_bit(&epf_pf->vfunction_num_map,
170 				       BITS_PER_LONG);
171 	if (vfunc_no >= BITS_PER_LONG) {
172 		mutex_unlock(&epf_pf->lock);
173 		return -EINVAL;
174 	}
175 
176 	set_bit(vfunc_no, &epf_pf->vfunction_num_map);
177 	epf_vf->vfunc_no = vfunc_no;
178 
179 	epf_vf->epf_pf = epf_pf;
180 	epf_vf->is_vf = true;
181 
182 	list_add_tail(&epf_vf->list, &epf_pf->pci_vepf);
183 	mutex_unlock(&epf_pf->lock);
184 
185 	return 0;
186 }
187 EXPORT_SYMBOL_GPL(pci_epf_add_vepf);
188 
189 /**
190  * pci_epf_remove_vepf() - remove virtual EP function from physical EP function
191  * @epf_pf: the physical EP function from which the virtual EP function should
192  *   be removed
193  * @epf_vf: the virtual EP function to be removed
194  *
195  * Invoke to remove a virtual endpoint function from the physical endpoint
196  * function.
197  */
198 void pci_epf_remove_vepf(struct pci_epf *epf_pf, struct pci_epf *epf_vf)
199 {
200 	if (IS_ERR_OR_NULL(epf_pf) || IS_ERR_OR_NULL(epf_vf))
201 		return;
202 
203 	mutex_lock(&epf_pf->lock);
204 	clear_bit(epf_vf->vfunc_no, &epf_pf->vfunction_num_map);
205 	list_del(&epf_vf->list);
206 	mutex_unlock(&epf_pf->lock);
207 }
208 EXPORT_SYMBOL_GPL(pci_epf_remove_vepf);
209 
210 /**
211  * pci_epf_free_space() - free the allocated PCI EPF register space
212  * @epf: the EPF device from whom to free the memory
213  * @addr: the virtual address of the PCI EPF register space
214  * @bar: the BAR number corresponding to the register space
215  * @type: Identifies if the allocated space is for primary EPC or secondary EPC
216  *
217  * Invoke to free the allocated PCI EPF register space.
218  */
219 void pci_epf_free_space(struct pci_epf *epf, void *addr, enum pci_barno bar,
220 			enum pci_epc_interface_type type)
221 {
222 	struct device *dev;
223 	struct pci_epf_bar *epf_bar;
224 	struct pci_epc *epc;
225 
226 	if (!addr)
227 		return;
228 
229 	if (type == PRIMARY_INTERFACE) {
230 		epc = epf->epc;
231 		epf_bar = epf->bar;
232 	} else {
233 		epc = epf->sec_epc;
234 		epf_bar = epf->sec_epc_bar;
235 	}
236 
237 	dev = epc->dev.parent;
238 	dma_free_coherent(dev, epf_bar[bar].size, addr,
239 			  epf_bar[bar].phys_addr);
240 
241 	epf_bar[bar].phys_addr = 0;
242 	epf_bar[bar].addr = NULL;
243 	epf_bar[bar].size = 0;
244 	epf_bar[bar].barno = 0;
245 	epf_bar[bar].flags = 0;
246 }
247 EXPORT_SYMBOL_GPL(pci_epf_free_space);
248 
249 /**
250  * pci_epf_alloc_space() - allocate memory for the PCI EPF register space
251  * @epf: the EPF device to whom allocate the memory
252  * @size: the size of the memory that has to be allocated
253  * @bar: the BAR number corresponding to the allocated register space
254  * @align: alignment size for the allocation region
255  * @type: Identifies if the allocation is for primary EPC or secondary EPC
256  *
257  * Invoke to allocate memory for the PCI EPF register space.
258  */
259 void *pci_epf_alloc_space(struct pci_epf *epf, size_t size, enum pci_barno bar,
260 			  size_t align, enum pci_epc_interface_type type)
261 {
262 	struct pci_epf_bar *epf_bar;
263 	dma_addr_t phys_addr;
264 	struct pci_epc *epc;
265 	struct device *dev;
266 	void *space;
267 
268 	if (size < 128)
269 		size = 128;
270 
271 	if (align)
272 		size = ALIGN(size, align);
273 	else
274 		size = roundup_pow_of_two(size);
275 
276 	if (type == PRIMARY_INTERFACE) {
277 		epc = epf->epc;
278 		epf_bar = epf->bar;
279 	} else {
280 		epc = epf->sec_epc;
281 		epf_bar = epf->sec_epc_bar;
282 	}
283 
284 	dev = epc->dev.parent;
285 	space = dma_alloc_coherent(dev, size, &phys_addr, GFP_KERNEL);
286 	if (!space) {
287 		dev_err(dev, "failed to allocate mem space\n");
288 		return NULL;
289 	}
290 
291 	epf_bar[bar].phys_addr = phys_addr;
292 	epf_bar[bar].addr = space;
293 	epf_bar[bar].size = size;
294 	epf_bar[bar].barno = bar;
295 	epf_bar[bar].flags |= upper_32_bits(size) ?
296 				PCI_BASE_ADDRESS_MEM_TYPE_64 :
297 				PCI_BASE_ADDRESS_MEM_TYPE_32;
298 
299 	return space;
300 }
301 EXPORT_SYMBOL_GPL(pci_epf_alloc_space);
302 
303 static void pci_epf_remove_cfs(struct pci_epf_driver *driver)
304 {
305 	struct config_group *group, *tmp;
306 
307 	if (!IS_ENABLED(CONFIG_PCI_ENDPOINT_CONFIGFS))
308 		return;
309 
310 	mutex_lock(&pci_epf_mutex);
311 	list_for_each_entry_safe(group, tmp, &driver->epf_group, group_entry)
312 		pci_ep_cfs_remove_epf_group(group);
313 	list_del(&driver->epf_group);
314 	mutex_unlock(&pci_epf_mutex);
315 }
316 
317 /**
318  * pci_epf_unregister_driver() - unregister the PCI EPF driver
319  * @driver: the PCI EPF driver that has to be unregistered
320  *
321  * Invoke to unregister the PCI EPF driver.
322  */
323 void pci_epf_unregister_driver(struct pci_epf_driver *driver)
324 {
325 	pci_epf_remove_cfs(driver);
326 	driver_unregister(&driver->driver);
327 }
328 EXPORT_SYMBOL_GPL(pci_epf_unregister_driver);
329 
330 static int pci_epf_add_cfs(struct pci_epf_driver *driver)
331 {
332 	struct config_group *group;
333 	const struct pci_epf_device_id *id;
334 
335 	if (!IS_ENABLED(CONFIG_PCI_ENDPOINT_CONFIGFS))
336 		return 0;
337 
338 	INIT_LIST_HEAD(&driver->epf_group);
339 
340 	id = driver->id_table;
341 	while (id->name[0]) {
342 		group = pci_ep_cfs_add_epf_group(id->name);
343 		if (IS_ERR(group)) {
344 			pci_epf_remove_cfs(driver);
345 			return PTR_ERR(group);
346 		}
347 
348 		mutex_lock(&pci_epf_mutex);
349 		list_add_tail(&group->group_entry, &driver->epf_group);
350 		mutex_unlock(&pci_epf_mutex);
351 		id++;
352 	}
353 
354 	return 0;
355 }
356 
357 /**
358  * __pci_epf_register_driver() - register a new PCI EPF driver
359  * @driver: structure representing PCI EPF driver
360  * @owner: the owner of the module that registers the PCI EPF driver
361  *
362  * Invoke to register a new PCI EPF driver.
363  */
364 int __pci_epf_register_driver(struct pci_epf_driver *driver,
365 			      struct module *owner)
366 {
367 	int ret;
368 
369 	if (!driver->ops)
370 		return -EINVAL;
371 
372 	if (!driver->ops->bind || !driver->ops->unbind)
373 		return -EINVAL;
374 
375 	driver->driver.bus = &pci_epf_bus_type;
376 	driver->driver.owner = owner;
377 
378 	ret = driver_register(&driver->driver);
379 	if (ret)
380 		return ret;
381 
382 	pci_epf_add_cfs(driver);
383 
384 	return 0;
385 }
386 EXPORT_SYMBOL_GPL(__pci_epf_register_driver);
387 
388 /**
389  * pci_epf_destroy() - destroy the created PCI EPF device
390  * @epf: the PCI EPF device that has to be destroyed.
391  *
392  * Invoke to destroy the PCI EPF device created by invoking pci_epf_create().
393  */
394 void pci_epf_destroy(struct pci_epf *epf)
395 {
396 	device_unregister(&epf->dev);
397 }
398 EXPORT_SYMBOL_GPL(pci_epf_destroy);
399 
400 /**
401  * pci_epf_create() - create a new PCI EPF device
402  * @name: the name of the PCI EPF device. This name will be used to bind the
403  *	  EPF device to a EPF driver
404  *
405  * Invoke to create a new PCI EPF device by providing the name of the function
406  * device.
407  */
408 struct pci_epf *pci_epf_create(const char *name)
409 {
410 	int ret;
411 	struct pci_epf *epf;
412 	struct device *dev;
413 	int len;
414 
415 	epf = kzalloc(sizeof(*epf), GFP_KERNEL);
416 	if (!epf)
417 		return ERR_PTR(-ENOMEM);
418 
419 	len = strchrnul(name, '.') - name;
420 	epf->name = kstrndup(name, len, GFP_KERNEL);
421 	if (!epf->name) {
422 		kfree(epf);
423 		return ERR_PTR(-ENOMEM);
424 	}
425 
426 	/* VFs are numbered starting with 1. So set BIT(0) by default */
427 	epf->vfunction_num_map = 1;
428 	INIT_LIST_HEAD(&epf->pci_vepf);
429 
430 	dev = &epf->dev;
431 	device_initialize(dev);
432 	dev->bus = &pci_epf_bus_type;
433 	dev->type = &pci_epf_type;
434 	mutex_init(&epf->lock);
435 
436 	ret = dev_set_name(dev, "%s", name);
437 	if (ret) {
438 		put_device(dev);
439 		return ERR_PTR(ret);
440 	}
441 
442 	ret = device_add(dev);
443 	if (ret) {
444 		put_device(dev);
445 		return ERR_PTR(ret);
446 	}
447 
448 	return epf;
449 }
450 EXPORT_SYMBOL_GPL(pci_epf_create);
451 
452 static void pci_epf_dev_release(struct device *dev)
453 {
454 	struct pci_epf *epf = to_pci_epf(dev);
455 
456 	kfree(epf->name);
457 	kfree(epf);
458 }
459 
460 static const struct device_type pci_epf_type = {
461 	.release	= pci_epf_dev_release,
462 };
463 
464 static const struct pci_epf_device_id *
465 pci_epf_match_id(const struct pci_epf_device_id *id, const struct pci_epf *epf)
466 {
467 	while (id->name[0]) {
468 		if (strcmp(epf->name, id->name) == 0)
469 			return id;
470 		id++;
471 	}
472 
473 	return NULL;
474 }
475 
476 static int pci_epf_device_match(struct device *dev, struct device_driver *drv)
477 {
478 	struct pci_epf *epf = to_pci_epf(dev);
479 	struct pci_epf_driver *driver = to_pci_epf_driver(drv);
480 
481 	if (driver->id_table)
482 		return !!pci_epf_match_id(driver->id_table, epf);
483 
484 	return !strcmp(epf->name, drv->name);
485 }
486 
487 static int pci_epf_device_probe(struct device *dev)
488 {
489 	struct pci_epf *epf = to_pci_epf(dev);
490 	struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
491 
492 	if (!driver->probe)
493 		return -ENODEV;
494 
495 	epf->driver = driver;
496 
497 	return driver->probe(epf, pci_epf_match_id(driver->id_table, epf));
498 }
499 
500 static void pci_epf_device_remove(struct device *dev)
501 {
502 	struct pci_epf *epf = to_pci_epf(dev);
503 	struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
504 
505 	if (driver->remove)
506 		driver->remove(epf);
507 	epf->driver = NULL;
508 }
509 
510 static struct bus_type pci_epf_bus_type = {
511 	.name		= "pci-epf",
512 	.match		= pci_epf_device_match,
513 	.probe		= pci_epf_device_probe,
514 	.remove		= pci_epf_device_remove,
515 };
516 
517 static int __init pci_epf_init(void)
518 {
519 	int ret;
520 
521 	ret = bus_register(&pci_epf_bus_type);
522 	if (ret) {
523 		pr_err("failed to register pci epf bus --> %d\n", ret);
524 		return ret;
525 	}
526 
527 	return 0;
528 }
529 module_init(pci_epf_init);
530 
531 static void __exit pci_epf_exit(void)
532 {
533 	bus_unregister(&pci_epf_bus_type);
534 }
535 module_exit(pci_epf_exit);
536 
537 MODULE_DESCRIPTION("PCI EPF Library");
538 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
539