1
2
3
4
5
6
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
18static DEFINE_MUTEX(pci_epf_mutex);
19
20static struct bus_type pci_epf_bus_type;
21static const struct device_type pci_epf_type;
22
23
24
25
26
27
28
29
30
31
32
33
34struct 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}
53EXPORT_SYMBOL_GPL(pci_epf_type_add_cfs);
54
55
56
57
58
59
60
61
62
63void 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}
82EXPORT_SYMBOL_GPL(pci_epf_unbind);
83
84
85
86
87
88
89
90
91int 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
169ret:
170 mutex_unlock(&epf->lock);
171 pci_epf_unbind(epf);
172
173 return ret;
174}
175EXPORT_SYMBOL_GPL(pci_epf_bind);
176
177
178
179
180
181
182
183
184
185
186
187int 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}
219EXPORT_SYMBOL_GPL(pci_epf_add_vepf);
220
221
222
223
224
225
226
227
228
229
230void 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}
240EXPORT_SYMBOL_GPL(pci_epf_remove_vepf);
241
242
243
244
245
246
247
248
249
250
251void 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}
279EXPORT_SYMBOL_GPL(pci_epf_free_space);
280
281
282
283
284
285
286
287
288
289
290
291void *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}
333EXPORT_SYMBOL_GPL(pci_epf_alloc_space);
334
335static 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
351
352
353
354
355void pci_epf_unregister_driver(struct pci_epf_driver *driver)
356{
357 pci_epf_remove_cfs(driver);
358 driver_unregister(&driver->driver);
359}
360EXPORT_SYMBOL_GPL(pci_epf_unregister_driver);
361
362static 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
391
392
393
394
395
396int __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}
418EXPORT_SYMBOL_GPL(__pci_epf_register_driver);
419
420
421
422
423
424
425
426void pci_epf_destroy(struct pci_epf *epf)
427{
428 device_unregister(&epf->dev);
429}
430EXPORT_SYMBOL_GPL(pci_epf_destroy);
431
432
433
434
435
436
437
438
439
440struct 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
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}
482EXPORT_SYMBOL_GPL(pci_epf_create);
483
484static 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
492static const struct device_type pci_epf_type = {
493 .release = pci_epf_dev_release,
494};
495
496static int
497pci_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
508static 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
519static 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
532static 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
542static 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
549static 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}
561module_init(pci_epf_init);
562
563static void __exit pci_epf_exit(void)
564{
565 bus_unregister(&pci_epf_bus_type);
566}
567module_exit(pci_epf_exit);
568
569MODULE_DESCRIPTION("PCI EPF Library");
570MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
571MODULE_LICENSE("GPL v2");
572