1
2
3
4
5
6
7
8#include <linux/fpga/fpga-bridge.h>
9#include <linux/idr.h>
10#include <linux/kernel.h>
11#include <linux/module.h>
12#include <linux/of_platform.h>
13#include <linux/slab.h>
14#include <linux/spinlock.h>
15
16
17#ifdef CONFIG_DEBUG_KERNEL
18#undef DEBUG
19#define DEBUG
20#endif
21
22static DEFINE_IDA(fpga_bridge_ida);
23static struct class *fpga_bridge_class;
24
25
26static spinlock_t bridge_list_lock;
27
28
29
30
31
32
33
34
35int fpga_bridge_enable(struct fpga_bridge *bridge)
36{
37 dev_dbg(&bridge->dev, "enable\n");
38
39 if (bridge->br_ops && bridge->br_ops->enable_set)
40 return bridge->br_ops->enable_set(bridge, 1);
41
42 return 0;
43}
44EXPORT_SYMBOL_GPL(fpga_bridge_enable);
45
46
47
48
49
50
51
52
53int fpga_bridge_disable(struct fpga_bridge *bridge)
54{
55 dev_dbg(&bridge->dev, "disable\n");
56
57 if (bridge->br_ops && bridge->br_ops->enable_set)
58 return bridge->br_ops->enable_set(bridge, 0);
59
60 return 0;
61}
62EXPORT_SYMBOL_GPL(fpga_bridge_disable);
63
64static struct fpga_bridge *__fpga_bridge_get(struct device *dev,
65 struct fpga_image_info *info)
66{
67 struct fpga_bridge *bridge;
68 int ret = -ENODEV;
69
70 bridge = to_fpga_bridge(dev);
71
72 bridge->info = info;
73
74 if (!mutex_trylock(&bridge->mutex)) {
75 ret = -EBUSY;
76 goto err_dev;
77 }
78
79 if (!try_module_get(dev->parent->driver->owner))
80 goto err_ll_mod;
81
82 dev_dbg(&bridge->dev, "get\n");
83
84 return bridge;
85
86err_ll_mod:
87 mutex_unlock(&bridge->mutex);
88err_dev:
89 put_device(dev);
90 return ERR_PTR(ret);
91}
92
93
94
95
96
97
98
99
100
101
102
103struct fpga_bridge *of_fpga_bridge_get(struct device_node *np,
104 struct fpga_image_info *info)
105{
106 struct device *dev;
107
108 dev = class_find_device_by_of_node(fpga_bridge_class, np);
109 if (!dev)
110 return ERR_PTR(-ENODEV);
111
112 return __fpga_bridge_get(dev, info);
113}
114EXPORT_SYMBOL_GPL(of_fpga_bridge_get);
115
116static int fpga_bridge_dev_match(struct device *dev, const void *data)
117{
118 return dev->parent == data;
119}
120
121
122
123
124
125
126
127
128
129
130struct fpga_bridge *fpga_bridge_get(struct device *dev,
131 struct fpga_image_info *info)
132{
133 struct device *bridge_dev;
134
135 bridge_dev = class_find_device(fpga_bridge_class, NULL, dev,
136 fpga_bridge_dev_match);
137 if (!bridge_dev)
138 return ERR_PTR(-ENODEV);
139
140 return __fpga_bridge_get(bridge_dev, info);
141}
142EXPORT_SYMBOL_GPL(fpga_bridge_get);
143
144
145
146
147
148
149void fpga_bridge_put(struct fpga_bridge *bridge)
150{
151 dev_dbg(&bridge->dev, "put\n");
152
153 bridge->info = NULL;
154 module_put(bridge->dev.parent->driver->owner);
155 mutex_unlock(&bridge->mutex);
156 put_device(&bridge->dev);
157}
158EXPORT_SYMBOL_GPL(fpga_bridge_put);
159
160
161
162
163
164
165
166
167
168int fpga_bridges_enable(struct list_head *bridge_list)
169{
170 struct fpga_bridge *bridge;
171 int ret;
172
173 list_for_each_entry(bridge, bridge_list, node) {
174 ret = fpga_bridge_enable(bridge);
175 if (ret)
176 return ret;
177 }
178
179 return 0;
180}
181EXPORT_SYMBOL_GPL(fpga_bridges_enable);
182
183
184
185
186
187
188
189
190
191
192int fpga_bridges_disable(struct list_head *bridge_list)
193{
194 struct fpga_bridge *bridge;
195 int ret;
196
197 list_for_each_entry(bridge, bridge_list, node) {
198 ret = fpga_bridge_disable(bridge);
199 if (ret)
200 return ret;
201 }
202
203 return 0;
204}
205EXPORT_SYMBOL_GPL(fpga_bridges_disable);
206
207
208
209
210
211
212
213
214
215void fpga_bridges_put(struct list_head *bridge_list)
216{
217 struct fpga_bridge *bridge, *next;
218 unsigned long flags;
219
220 list_for_each_entry_safe(bridge, next, bridge_list, node) {
221 fpga_bridge_put(bridge);
222
223 spin_lock_irqsave(&bridge_list_lock, flags);
224 list_del(&bridge->node);
225 spin_unlock_irqrestore(&bridge_list_lock, flags);
226 }
227}
228EXPORT_SYMBOL_GPL(fpga_bridges_put);
229
230
231
232
233
234
235
236
237
238
239
240
241int of_fpga_bridge_get_to_list(struct device_node *np,
242 struct fpga_image_info *info,
243 struct list_head *bridge_list)
244{
245 struct fpga_bridge *bridge;
246 unsigned long flags;
247
248 bridge = of_fpga_bridge_get(np, info);
249 if (IS_ERR(bridge))
250 return PTR_ERR(bridge);
251
252 spin_lock_irqsave(&bridge_list_lock, flags);
253 list_add(&bridge->node, bridge_list);
254 spin_unlock_irqrestore(&bridge_list_lock, flags);
255
256 return 0;
257}
258EXPORT_SYMBOL_GPL(of_fpga_bridge_get_to_list);
259
260
261
262
263
264
265
266
267
268
269
270
271int fpga_bridge_get_to_list(struct device *dev,
272 struct fpga_image_info *info,
273 struct list_head *bridge_list)
274{
275 struct fpga_bridge *bridge;
276 unsigned long flags;
277
278 bridge = fpga_bridge_get(dev, info);
279 if (IS_ERR(bridge))
280 return PTR_ERR(bridge);
281
282 spin_lock_irqsave(&bridge_list_lock, flags);
283 list_add(&bridge->node, bridge_list);
284 spin_unlock_irqrestore(&bridge_list_lock, flags);
285
286 return 0;
287}
288EXPORT_SYMBOL_GPL(fpga_bridge_get_to_list);
289
290static ssize_t name_show(struct device *dev,
291 struct device_attribute *attr, char *buf)
292{
293 struct fpga_bridge *bridge = to_fpga_bridge(dev);
294
295 return sprintf(buf, "%s\n", bridge->name);
296}
297
298static ssize_t state_show(struct device *dev,
299 struct device_attribute *attr, char *buf)
300{
301 struct fpga_bridge *bridge = to_fpga_bridge(dev);
302 int enable = 1;
303
304 if (bridge->br_ops && bridge->br_ops->enable_show)
305 enable = bridge->br_ops->enable_show(bridge);
306
307 return sprintf(buf, "%s\n", enable ? "enabled" : "disabled");
308}
309
310static DEVICE_ATTR_RO(name);
311static DEVICE_ATTR_RO(state);
312
313#ifdef DEBUG
314static ssize_t set_store(struct device *dev,
315 struct device_attribute *attr,
316 const char *buf, size_t count)
317{
318 struct fpga_bridge *bridge = to_fpga_bridge(dev);
319 long enable;
320 int ret;
321
322 ret = kstrtol(buf, 16, &enable);
323 if (ret)
324 return ret;
325
326 if (bridge->br_ops && bridge->br_ops->enable_set)
327 enable = bridge->br_ops->enable_set(bridge, !!enable);
328
329 return count;
330}
331static DEVICE_ATTR_WO(set);
332#endif
333
334static struct attribute *fpga_bridge_attrs[] = {
335 &dev_attr_name.attr,
336 &dev_attr_state.attr,
337#ifdef DEBUG
338 &dev_attr_set.attr,
339#endif
340 NULL,
341};
342ATTRIBUTE_GROUPS(fpga_bridge);
343
344
345
346
347
348
349
350
351
352
353
354
355
356struct fpga_bridge *fpga_bridge_create(struct device *dev, const char *name,
357 const struct fpga_bridge_ops *br_ops,
358 void *priv)
359{
360 struct fpga_bridge *bridge;
361 int id, ret;
362
363 if (!name || !strlen(name)) {
364 dev_err(dev, "Attempt to register with no name!\n");
365 return NULL;
366 }
367
368 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
369 if (!bridge)
370 return NULL;
371
372 id = ida_simple_get(&fpga_bridge_ida, 0, 0, GFP_KERNEL);
373 if (id < 0)
374 goto error_kfree;
375
376 mutex_init(&bridge->mutex);
377 INIT_LIST_HEAD(&bridge->node);
378
379 bridge->name = name;
380 bridge->br_ops = br_ops;
381 bridge->priv = priv;
382
383 device_initialize(&bridge->dev);
384 bridge->dev.groups = br_ops->groups;
385 bridge->dev.class = fpga_bridge_class;
386 bridge->dev.parent = dev;
387 bridge->dev.of_node = dev->of_node;
388 bridge->dev.id = id;
389
390 ret = dev_set_name(&bridge->dev, "br%d", id);
391 if (ret)
392 goto error_device;
393
394 return bridge;
395
396error_device:
397 ida_simple_remove(&fpga_bridge_ida, id);
398error_kfree:
399 kfree(bridge);
400
401 return NULL;
402}
403EXPORT_SYMBOL_GPL(fpga_bridge_create);
404
405
406
407
408
409void fpga_bridge_free(struct fpga_bridge *bridge)
410{
411 ida_simple_remove(&fpga_bridge_ida, bridge->dev.id);
412 kfree(bridge);
413}
414EXPORT_SYMBOL_GPL(fpga_bridge_free);
415
416static void devm_fpga_bridge_release(struct device *dev, void *res)
417{
418 struct fpga_bridge *bridge = *(struct fpga_bridge **)res;
419
420 fpga_bridge_free(bridge);
421}
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440struct fpga_bridge
441*devm_fpga_bridge_create(struct device *dev, const char *name,
442 const struct fpga_bridge_ops *br_ops, void *priv)
443{
444 struct fpga_bridge **ptr, *bridge;
445
446 ptr = devres_alloc(devm_fpga_bridge_release, sizeof(*ptr), GFP_KERNEL);
447 if (!ptr)
448 return NULL;
449
450 bridge = fpga_bridge_create(dev, name, br_ops, priv);
451 if (!bridge) {
452 devres_free(ptr);
453 } else {
454 *ptr = bridge;
455 devres_add(dev, ptr);
456 }
457
458 return bridge;
459}
460EXPORT_SYMBOL_GPL(devm_fpga_bridge_create);
461
462
463
464
465
466
467
468
469int fpga_bridge_register(struct fpga_bridge *bridge)
470{
471 struct device *dev = &bridge->dev;
472 int ret;
473
474 ret = device_add(dev);
475 if (ret)
476 return ret;
477
478 of_platform_populate(dev->of_node, NULL, NULL, dev);
479
480 dev_info(dev->parent, "fpga bridge [%s] registered\n", bridge->name);
481
482 return 0;
483}
484EXPORT_SYMBOL_GPL(fpga_bridge_register);
485
486
487
488
489
490
491
492
493void fpga_bridge_unregister(struct fpga_bridge *bridge)
494{
495
496
497
498
499 if (bridge->br_ops && bridge->br_ops->fpga_bridge_remove)
500 bridge->br_ops->fpga_bridge_remove(bridge);
501
502 device_unregister(&bridge->dev);
503}
504EXPORT_SYMBOL_GPL(fpga_bridge_unregister);
505
506static void fpga_bridge_dev_release(struct device *dev)
507{
508}
509
510static int __init fpga_bridge_dev_init(void)
511{
512 spin_lock_init(&bridge_list_lock);
513
514 fpga_bridge_class = class_create(THIS_MODULE, "fpga_bridge");
515 if (IS_ERR(fpga_bridge_class))
516 return PTR_ERR(fpga_bridge_class);
517
518 fpga_bridge_class->dev_groups = fpga_bridge_groups;
519 fpga_bridge_class->dev_release = fpga_bridge_dev_release;
520
521 return 0;
522}
523
524static void __exit fpga_bridge_dev_exit(void)
525{
526 class_destroy(fpga_bridge_class);
527 ida_destroy(&fpga_bridge_ida);
528}
529
530MODULE_DESCRIPTION("FPGA Bridge Driver");
531MODULE_AUTHOR("Alan Tull <atull@kernel.org>");
532MODULE_LICENSE("GPL v2");
533
534subsys_initcall(fpga_bridge_dev_init);
535module_exit(fpga_bridge_dev_exit);
536