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