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 */
pci_epf_unbind(struct pci_epf * epf)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 */
pci_epf_bind(struct pci_epf * epf)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 */
pci_epf_add_vepf(struct pci_epf * epf_pf,struct pci_epf * epf_vf)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 */
pci_epf_remove_vepf(struct pci_epf * epf_pf,struct pci_epf * epf_vf)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 epf_vf->epf_pf = NULL;
206 list_del(&epf_vf->list);
207 mutex_unlock(&epf_pf->lock);
208 }
209 EXPORT_SYMBOL_GPL(pci_epf_remove_vepf);
210
211 /**
212 * pci_epf_free_space() - free the allocated PCI EPF register space
213 * @epf: the EPF device from whom to free the memory
214 * @addr: the virtual address of the PCI EPF register space
215 * @bar: the BAR number corresponding to the register space
216 * @type: Identifies if the allocated space is for primary EPC or secondary EPC
217 *
218 * Invoke to free the allocated PCI EPF register space.
219 */
pci_epf_free_space(struct pci_epf * epf,void * addr,enum pci_barno bar,enum pci_epc_interface_type type)220 void pci_epf_free_space(struct pci_epf *epf, void *addr, enum pci_barno bar,
221 enum pci_epc_interface_type type)
222 {
223 struct device *dev;
224 struct pci_epf_bar *epf_bar;
225 struct pci_epc *epc;
226
227 if (!addr)
228 return;
229
230 if (type == PRIMARY_INTERFACE) {
231 epc = epf->epc;
232 epf_bar = epf->bar;
233 } else {
234 epc = epf->sec_epc;
235 epf_bar = epf->sec_epc_bar;
236 }
237
238 dev = epc->dev.parent;
239 dma_free_coherent(dev, epf_bar[bar].size, addr,
240 epf_bar[bar].phys_addr);
241
242 epf_bar[bar].phys_addr = 0;
243 epf_bar[bar].addr = NULL;
244 epf_bar[bar].size = 0;
245 epf_bar[bar].barno = 0;
246 epf_bar[bar].flags = 0;
247 }
248 EXPORT_SYMBOL_GPL(pci_epf_free_space);
249
250 /**
251 * pci_epf_alloc_space() - allocate memory for the PCI EPF register space
252 * @epf: the EPF device to whom allocate the memory
253 * @size: the size of the memory that has to be allocated
254 * @bar: the BAR number corresponding to the allocated register space
255 * @align: alignment size for the allocation region
256 * @type: Identifies if the allocation is for primary EPC or secondary EPC
257 *
258 * Invoke to allocate memory for the PCI EPF register space.
259 */
pci_epf_alloc_space(struct pci_epf * epf,size_t size,enum pci_barno bar,size_t align,enum pci_epc_interface_type type)260 void *pci_epf_alloc_space(struct pci_epf *epf, size_t size, enum pci_barno bar,
261 size_t align, enum pci_epc_interface_type type)
262 {
263 struct pci_epf_bar *epf_bar;
264 dma_addr_t phys_addr;
265 struct pci_epc *epc;
266 struct device *dev;
267 void *space;
268
269 if (size < 128)
270 size = 128;
271
272 if (align)
273 size = ALIGN(size, align);
274 else
275 size = roundup_pow_of_two(size);
276
277 if (type == PRIMARY_INTERFACE) {
278 epc = epf->epc;
279 epf_bar = epf->bar;
280 } else {
281 epc = epf->sec_epc;
282 epf_bar = epf->sec_epc_bar;
283 }
284
285 dev = epc->dev.parent;
286 space = dma_alloc_coherent(dev, size, &phys_addr, GFP_KERNEL);
287 if (!space) {
288 dev_err(dev, "failed to allocate mem space\n");
289 return NULL;
290 }
291
292 epf_bar[bar].phys_addr = phys_addr;
293 epf_bar[bar].addr = space;
294 epf_bar[bar].size = size;
295 epf_bar[bar].barno = bar;
296 epf_bar[bar].flags |= upper_32_bits(size) ?
297 PCI_BASE_ADDRESS_MEM_TYPE_64 :
298 PCI_BASE_ADDRESS_MEM_TYPE_32;
299
300 return space;
301 }
302 EXPORT_SYMBOL_GPL(pci_epf_alloc_space);
303
pci_epf_remove_cfs(struct pci_epf_driver * driver)304 static void pci_epf_remove_cfs(struct pci_epf_driver *driver)
305 {
306 struct config_group *group, *tmp;
307
308 if (!IS_ENABLED(CONFIG_PCI_ENDPOINT_CONFIGFS))
309 return;
310
311 mutex_lock(&pci_epf_mutex);
312 list_for_each_entry_safe(group, tmp, &driver->epf_group, group_entry)
313 pci_ep_cfs_remove_epf_group(group);
314 list_del(&driver->epf_group);
315 mutex_unlock(&pci_epf_mutex);
316 }
317
318 /**
319 * pci_epf_unregister_driver() - unregister the PCI EPF driver
320 * @driver: the PCI EPF driver that has to be unregistered
321 *
322 * Invoke to unregister the PCI EPF driver.
323 */
pci_epf_unregister_driver(struct pci_epf_driver * driver)324 void pci_epf_unregister_driver(struct pci_epf_driver *driver)
325 {
326 pci_epf_remove_cfs(driver);
327 driver_unregister(&driver->driver);
328 }
329 EXPORT_SYMBOL_GPL(pci_epf_unregister_driver);
330
pci_epf_add_cfs(struct pci_epf_driver * driver)331 static int pci_epf_add_cfs(struct pci_epf_driver *driver)
332 {
333 struct config_group *group;
334 const struct pci_epf_device_id *id;
335
336 if (!IS_ENABLED(CONFIG_PCI_ENDPOINT_CONFIGFS))
337 return 0;
338
339 INIT_LIST_HEAD(&driver->epf_group);
340
341 id = driver->id_table;
342 while (id->name[0]) {
343 group = pci_ep_cfs_add_epf_group(id->name);
344 if (IS_ERR(group)) {
345 pci_epf_remove_cfs(driver);
346 return PTR_ERR(group);
347 }
348
349 mutex_lock(&pci_epf_mutex);
350 list_add_tail(&group->group_entry, &driver->epf_group);
351 mutex_unlock(&pci_epf_mutex);
352 id++;
353 }
354
355 return 0;
356 }
357
358 /**
359 * __pci_epf_register_driver() - register a new PCI EPF driver
360 * @driver: structure representing PCI EPF driver
361 * @owner: the owner of the module that registers the PCI EPF driver
362 *
363 * Invoke to register a new PCI EPF driver.
364 */
__pci_epf_register_driver(struct pci_epf_driver * driver,struct module * owner)365 int __pci_epf_register_driver(struct pci_epf_driver *driver,
366 struct module *owner)
367 {
368 int ret;
369
370 if (!driver->ops)
371 return -EINVAL;
372
373 if (!driver->ops->bind || !driver->ops->unbind)
374 return -EINVAL;
375
376 driver->driver.bus = &pci_epf_bus_type;
377 driver->driver.owner = owner;
378
379 ret = driver_register(&driver->driver);
380 if (ret)
381 return ret;
382
383 pci_epf_add_cfs(driver);
384
385 return 0;
386 }
387 EXPORT_SYMBOL_GPL(__pci_epf_register_driver);
388
389 /**
390 * pci_epf_destroy() - destroy the created PCI EPF device
391 * @epf: the PCI EPF device that has to be destroyed.
392 *
393 * Invoke to destroy the PCI EPF device created by invoking pci_epf_create().
394 */
pci_epf_destroy(struct pci_epf * epf)395 void pci_epf_destroy(struct pci_epf *epf)
396 {
397 device_unregister(&epf->dev);
398 }
399 EXPORT_SYMBOL_GPL(pci_epf_destroy);
400
401 /**
402 * pci_epf_create() - create a new PCI EPF device
403 * @name: the name of the PCI EPF device. This name will be used to bind the
404 * EPF device to a EPF driver
405 *
406 * Invoke to create a new PCI EPF device by providing the name of the function
407 * device.
408 */
pci_epf_create(const char * name)409 struct pci_epf *pci_epf_create(const char *name)
410 {
411 int ret;
412 struct pci_epf *epf;
413 struct device *dev;
414 int len;
415
416 epf = kzalloc(sizeof(*epf), GFP_KERNEL);
417 if (!epf)
418 return ERR_PTR(-ENOMEM);
419
420 len = strchrnul(name, '.') - name;
421 epf->name = kstrndup(name, len, GFP_KERNEL);
422 if (!epf->name) {
423 kfree(epf);
424 return ERR_PTR(-ENOMEM);
425 }
426
427 /* VFs are numbered starting with 1. So set BIT(0) by default */
428 epf->vfunction_num_map = 1;
429 INIT_LIST_HEAD(&epf->pci_vepf);
430
431 dev = &epf->dev;
432 device_initialize(dev);
433 dev->bus = &pci_epf_bus_type;
434 dev->type = &pci_epf_type;
435 mutex_init(&epf->lock);
436
437 ret = dev_set_name(dev, "%s", name);
438 if (ret) {
439 put_device(dev);
440 return ERR_PTR(ret);
441 }
442
443 ret = device_add(dev);
444 if (ret) {
445 put_device(dev);
446 return ERR_PTR(ret);
447 }
448
449 return epf;
450 }
451 EXPORT_SYMBOL_GPL(pci_epf_create);
452
pci_epf_dev_release(struct device * dev)453 static void pci_epf_dev_release(struct device *dev)
454 {
455 struct pci_epf *epf = to_pci_epf(dev);
456
457 kfree(epf->name);
458 kfree(epf);
459 }
460
461 static const struct device_type pci_epf_type = {
462 .release = pci_epf_dev_release,
463 };
464
465 static const struct pci_epf_device_id *
pci_epf_match_id(const struct pci_epf_device_id * id,const struct pci_epf * epf)466 pci_epf_match_id(const struct pci_epf_device_id *id, const struct pci_epf *epf)
467 {
468 while (id->name[0]) {
469 if (strcmp(epf->name, id->name) == 0)
470 return id;
471 id++;
472 }
473
474 return NULL;
475 }
476
pci_epf_device_match(struct device * dev,struct device_driver * drv)477 static int pci_epf_device_match(struct device *dev, struct device_driver *drv)
478 {
479 struct pci_epf *epf = to_pci_epf(dev);
480 struct pci_epf_driver *driver = to_pci_epf_driver(drv);
481
482 if (driver->id_table)
483 return !!pci_epf_match_id(driver->id_table, epf);
484
485 return !strcmp(epf->name, drv->name);
486 }
487
pci_epf_device_probe(struct device * dev)488 static int pci_epf_device_probe(struct device *dev)
489 {
490 struct pci_epf *epf = to_pci_epf(dev);
491 struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
492
493 if (!driver->probe)
494 return -ENODEV;
495
496 epf->driver = driver;
497
498 return driver->probe(epf, pci_epf_match_id(driver->id_table, epf));
499 }
500
pci_epf_device_remove(struct device * dev)501 static void pci_epf_device_remove(struct device *dev)
502 {
503 struct pci_epf *epf = to_pci_epf(dev);
504 struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
505
506 if (driver->remove)
507 driver->remove(epf);
508 epf->driver = NULL;
509 }
510
511 static struct bus_type pci_epf_bus_type = {
512 .name = "pci-epf",
513 .match = pci_epf_device_match,
514 .probe = pci_epf_device_probe,
515 .remove = pci_epf_device_remove,
516 };
517
pci_epf_init(void)518 static int __init pci_epf_init(void)
519 {
520 int ret;
521
522 ret = bus_register(&pci_epf_bus_type);
523 if (ret) {
524 pr_err("failed to register pci epf bus --> %d\n", ret);
525 return ret;
526 }
527
528 return 0;
529 }
530 module_init(pci_epf_init);
531
pci_epf_exit(void)532 static void __exit pci_epf_exit(void)
533 {
534 bus_unregister(&pci_epf_bus_type);
535 }
536 module_exit(pci_epf_exit);
537
538 MODULE_DESCRIPTION("PCI EPF Library");
539 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
540