1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/device.h>
21#include <linux/dma-mapping.h>
22#include <linux/slab.h>
23#include <linux/module.h>
24
25#include <linux/pci-epc.h>
26#include <linux/pci-epf.h>
27#include <linux/pci-ep-cfs.h>
28
29static struct bus_type pci_epf_bus_type;
30static const struct device_type pci_epf_type;
31
32
33
34
35
36
37
38
39
40
41void pci_epf_linkup(struct pci_epf *epf)
42{
43 if (!epf->driver) {
44 dev_WARN(&epf->dev, "epf device not bound to driver\n");
45 return;
46 }
47
48 epf->driver->ops->linkup(epf);
49}
50EXPORT_SYMBOL_GPL(pci_epf_linkup);
51
52
53
54
55
56
57
58
59
60void pci_epf_unbind(struct pci_epf *epf)
61{
62 if (!epf->driver) {
63 dev_WARN(&epf->dev, "epf device not bound to driver\n");
64 return;
65 }
66
67 epf->driver->ops->unbind(epf);
68 module_put(epf->driver->owner);
69}
70EXPORT_SYMBOL_GPL(pci_epf_unbind);
71
72
73
74
75
76
77
78
79int pci_epf_bind(struct pci_epf *epf)
80{
81 if (!epf->driver) {
82 dev_WARN(&epf->dev, "epf device not bound to driver\n");
83 return -EINVAL;
84 }
85
86 if (!try_module_get(epf->driver->owner))
87 return -EAGAIN;
88
89 return epf->driver->ops->bind(epf);
90}
91EXPORT_SYMBOL_GPL(pci_epf_bind);
92
93
94
95
96
97
98
99
100void pci_epf_free_space(struct pci_epf *epf, void *addr, enum pci_barno bar)
101{
102 struct device *dev = &epf->dev;
103
104 if (!addr)
105 return;
106
107 dma_free_coherent(dev, epf->bar[bar].size, addr,
108 epf->bar[bar].phys_addr);
109
110 epf->bar[bar].phys_addr = 0;
111 epf->bar[bar].size = 0;
112}
113EXPORT_SYMBOL_GPL(pci_epf_free_space);
114
115
116
117
118
119
120
121
122void *pci_epf_alloc_space(struct pci_epf *epf, size_t size, enum pci_barno bar)
123{
124 void *space;
125 struct device *dev = &epf->dev;
126 dma_addr_t phys_addr;
127
128 if (size < 128)
129 size = 128;
130 size = roundup_pow_of_two(size);
131
132 space = dma_alloc_coherent(dev, size, &phys_addr, GFP_KERNEL);
133 if (!space) {
134 dev_err(dev, "failed to allocate mem space\n");
135 return NULL;
136 }
137
138 epf->bar[bar].phys_addr = phys_addr;
139 epf->bar[bar].size = size;
140
141 return space;
142}
143EXPORT_SYMBOL_GPL(pci_epf_alloc_space);
144
145
146
147
148
149
150
151void pci_epf_unregister_driver(struct pci_epf_driver *driver)
152{
153 pci_ep_cfs_remove_epf_group(driver->group);
154 driver_unregister(&driver->driver);
155}
156EXPORT_SYMBOL_GPL(pci_epf_unregister_driver);
157
158
159
160
161
162
163
164
165int __pci_epf_register_driver(struct pci_epf_driver *driver,
166 struct module *owner)
167{
168 int ret;
169
170 if (!driver->ops)
171 return -EINVAL;
172
173 if (!driver->ops->bind || !driver->ops->unbind || !driver->ops->linkup)
174 return -EINVAL;
175
176 driver->driver.bus = &pci_epf_bus_type;
177 driver->driver.owner = owner;
178
179 ret = driver_register(&driver->driver);
180 if (ret)
181 return ret;
182
183 driver->group = pci_ep_cfs_add_epf_group(driver->driver.name);
184
185 return 0;
186}
187EXPORT_SYMBOL_GPL(__pci_epf_register_driver);
188
189
190
191
192
193
194
195void pci_epf_destroy(struct pci_epf *epf)
196{
197 device_unregister(&epf->dev);
198}
199EXPORT_SYMBOL_GPL(pci_epf_destroy);
200
201
202
203
204
205
206
207
208
209struct pci_epf *pci_epf_create(const char *name)
210{
211 int ret;
212 struct pci_epf *epf;
213 struct device *dev;
214 char *func_name;
215 char *buf;
216
217 epf = kzalloc(sizeof(*epf), GFP_KERNEL);
218 if (!epf) {
219 ret = -ENOMEM;
220 goto err_ret;
221 }
222
223 buf = kstrdup(name, GFP_KERNEL);
224 if (!buf) {
225 ret = -ENOMEM;
226 goto free_epf;
227 }
228
229 func_name = buf;
230 buf = strchrnul(buf, '.');
231 *buf = '\0';
232
233 epf->name = kstrdup(func_name, GFP_KERNEL);
234 if (!epf->name) {
235 ret = -ENOMEM;
236 goto free_func_name;
237 }
238
239 dev = &epf->dev;
240 device_initialize(dev);
241 dev->bus = &pci_epf_bus_type;
242 dev->type = &pci_epf_type;
243
244 ret = dev_set_name(dev, "%s", name);
245 if (ret)
246 goto put_dev;
247
248 ret = device_add(dev);
249 if (ret)
250 goto put_dev;
251
252 kfree(func_name);
253 return epf;
254
255put_dev:
256 put_device(dev);
257 kfree(epf->name);
258
259free_func_name:
260 kfree(func_name);
261
262free_epf:
263 kfree(epf);
264
265err_ret:
266 return ERR_PTR(ret);
267}
268EXPORT_SYMBOL_GPL(pci_epf_create);
269
270const struct pci_epf_device_id *
271pci_epf_match_device(const struct pci_epf_device_id *id, struct pci_epf *epf)
272{
273 if (!id || !epf)
274 return NULL;
275
276 while (*id->name) {
277 if (strcmp(epf->name, id->name) == 0)
278 return id;
279 id++;
280 }
281
282 return NULL;
283}
284EXPORT_SYMBOL_GPL(pci_epf_match_device);
285
286static void pci_epf_dev_release(struct device *dev)
287{
288 struct pci_epf *epf = to_pci_epf(dev);
289
290 kfree(epf->name);
291 kfree(epf);
292}
293
294static const struct device_type pci_epf_type = {
295 .release = pci_epf_dev_release,
296};
297
298static int
299pci_epf_match_id(const struct pci_epf_device_id *id, const struct pci_epf *epf)
300{
301 while (id->name[0]) {
302 if (strcmp(epf->name, id->name) == 0)
303 return true;
304 id++;
305 }
306
307 return false;
308}
309
310static int pci_epf_device_match(struct device *dev, struct device_driver *drv)
311{
312 struct pci_epf *epf = to_pci_epf(dev);
313 struct pci_epf_driver *driver = to_pci_epf_driver(drv);
314
315 if (driver->id_table)
316 return pci_epf_match_id(driver->id_table, epf);
317
318 return !strcmp(epf->name, drv->name);
319}
320
321static int pci_epf_device_probe(struct device *dev)
322{
323 struct pci_epf *epf = to_pci_epf(dev);
324 struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
325
326 if (!driver->probe)
327 return -ENODEV;
328
329 epf->driver = driver;
330
331 return driver->probe(epf);
332}
333
334static int pci_epf_device_remove(struct device *dev)
335{
336 int ret = 0;
337 struct pci_epf *epf = to_pci_epf(dev);
338 struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
339
340 if (driver->remove)
341 ret = driver->remove(epf);
342 epf->driver = NULL;
343
344 return ret;
345}
346
347static struct bus_type pci_epf_bus_type = {
348 .name = "pci-epf",
349 .match = pci_epf_device_match,
350 .probe = pci_epf_device_probe,
351 .remove = pci_epf_device_remove,
352};
353
354static int __init pci_epf_init(void)
355{
356 int ret;
357
358 ret = bus_register(&pci_epf_bus_type);
359 if (ret) {
360 pr_err("failed to register pci epf bus --> %d\n", ret);
361 return ret;
362 }
363
364 return 0;
365}
366module_init(pci_epf_init);
367
368static void __exit pci_epf_exit(void)
369{
370 bus_unregister(&pci_epf_bus_type);
371}
372module_exit(pci_epf_exit);
373
374MODULE_DESCRIPTION("PCI EPF Library");
375MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
376MODULE_LICENSE("GPL v2");
377