Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * FPGA Bridge Framework Driver
4 *
5 * Copyright (C) 2013-2016 Altera Corporation, All Rights Reserved.
6 * Copyright (C) 2017 Intel Corporation
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
16static DEFINE_IDA(fpga_bridge_ida);
17static const struct class fpga_bridge_class;
18
19/* Lock for adding/removing bridges to linked lists*/
20static DEFINE_SPINLOCK(bridge_list_lock);
21
22/**
23 * fpga_bridge_enable - Enable transactions on the bridge
24 *
25 * @bridge: FPGA bridge
26 *
27 * Return: 0 for success, error code otherwise.
28 */
29int fpga_bridge_enable(struct fpga_bridge *bridge)
30{
31 dev_dbg(&bridge->dev, "enable\n");
32
33 if (bridge->br_ops && bridge->br_ops->enable_set)
34 return bridge->br_ops->enable_set(bridge, 1);
35
36 return 0;
37}
38EXPORT_SYMBOL_GPL(fpga_bridge_enable);
39
40/**
41 * fpga_bridge_disable - Disable transactions on the bridge
42 *
43 * @bridge: FPGA bridge
44 *
45 * Return: 0 for success, error code otherwise.
46 */
47int fpga_bridge_disable(struct fpga_bridge *bridge)
48{
49 dev_dbg(&bridge->dev, "disable\n");
50
51 if (bridge->br_ops && bridge->br_ops->enable_set)
52 return bridge->br_ops->enable_set(bridge, 0);
53
54 return 0;
55}
56EXPORT_SYMBOL_GPL(fpga_bridge_disable);
57
58static struct fpga_bridge *__fpga_bridge_get(struct device *dev,
59 struct fpga_image_info *info)
60{
61 struct fpga_bridge *bridge;
62 int ret = -ENODEV;
63
64 bridge = to_fpga_bridge(dev);
65
66 bridge->info = info;
67
68 if (!mutex_trylock(&bridge->mutex)) {
69 ret = -EBUSY;
70 goto err_dev;
71 }
72
73 if (!try_module_get(dev->parent->driver->owner))
74 goto err_ll_mod;
75
76 dev_dbg(&bridge->dev, "get\n");
77
78 return bridge;
79
80err_ll_mod:
81 mutex_unlock(&bridge->mutex);
82err_dev:
83 put_device(dev);
84 return ERR_PTR(ret);
85}
86
87/**
88 * of_fpga_bridge_get - get an exclusive reference to an fpga bridge
89 *
90 * @np: node pointer of an FPGA bridge.
91 * @info: fpga image specific information.
92 *
93 * Return:
94 * * fpga_bridge struct pointer if successful.
95 * * -EBUSY if someone already has a reference to the bridge.
96 * * -ENODEV if @np is not an FPGA Bridge or can't take parent driver refcount.
97 */
98struct fpga_bridge *of_fpga_bridge_get(struct device_node *np,
99 struct fpga_image_info *info)
100{
101 struct device *dev;
102
103 dev = class_find_device_by_of_node(&fpga_bridge_class, np);
104 if (!dev)
105 return ERR_PTR(-ENODEV);
106
107 return __fpga_bridge_get(dev, info);
108}
109EXPORT_SYMBOL_GPL(of_fpga_bridge_get);
110
111static int fpga_bridge_dev_match(struct device *dev, const void *data)
112{
113 return dev->parent == data;
114}
115
116/**
117 * fpga_bridge_get - get an exclusive reference to an fpga bridge
118 * @dev: parent device that fpga bridge was registered with
119 * @info: fpga image specific information
120 *
121 * Given a device, get an exclusive reference to an fpga bridge.
122 *
123 * Return: fpga bridge struct or IS_ERR() condition containing error code.
124 */
125struct fpga_bridge *fpga_bridge_get(struct device *dev,
126 struct fpga_image_info *info)
127{
128 struct device *bridge_dev;
129
130 bridge_dev = class_find_device(&fpga_bridge_class, NULL, dev,
131 fpga_bridge_dev_match);
132 if (!bridge_dev)
133 return ERR_PTR(-ENODEV);
134
135 return __fpga_bridge_get(bridge_dev, info);
136}
137EXPORT_SYMBOL_GPL(fpga_bridge_get);
138
139/**
140 * fpga_bridge_put - release a reference to a bridge
141 *
142 * @bridge: FPGA bridge
143 */
144void fpga_bridge_put(struct fpga_bridge *bridge)
145{
146 dev_dbg(&bridge->dev, "put\n");
147
148 bridge->info = NULL;
149 module_put(bridge->dev.parent->driver->owner);
150 mutex_unlock(&bridge->mutex);
151 put_device(&bridge->dev);
152}
153EXPORT_SYMBOL_GPL(fpga_bridge_put);
154
155/**
156 * fpga_bridges_enable - enable bridges in a list
157 * @bridge_list: list of FPGA bridges
158 *
159 * Enable each bridge in the list. If list is empty, do nothing.
160 *
161 * Return: 0 for success or empty bridge list or an error code otherwise.
162 */
163int fpga_bridges_enable(struct list_head *bridge_list)
164{
165 struct fpga_bridge *bridge;
166 int ret;
167
168 list_for_each_entry(bridge, bridge_list, node) {
169 ret = fpga_bridge_enable(bridge);
170 if (ret)
171 return ret;
172 }
173
174 return 0;
175}
176EXPORT_SYMBOL_GPL(fpga_bridges_enable);
177
178/**
179 * fpga_bridges_disable - disable bridges in a list
180 *
181 * @bridge_list: list of FPGA bridges
182 *
183 * Disable each bridge in the list. If list is empty, do nothing.
184 *
185 * Return: 0 for success or empty bridge list or an error code otherwise.
186 */
187int fpga_bridges_disable(struct list_head *bridge_list)
188{
189 struct fpga_bridge *bridge;
190 int ret;
191
192 list_for_each_entry(bridge, bridge_list, node) {
193 ret = fpga_bridge_disable(bridge);
194 if (ret)
195 return ret;
196 }
197
198 return 0;
199}
200EXPORT_SYMBOL_GPL(fpga_bridges_disable);
201
202/**
203 * fpga_bridges_put - put bridges
204 *
205 * @bridge_list: list of FPGA bridges
206 *
207 * For each bridge in the list, put the bridge and remove it from the list.
208 * If list is empty, do nothing.
209 */
210void fpga_bridges_put(struct list_head *bridge_list)
211{
212 struct fpga_bridge *bridge, *next;
213 unsigned long flags;
214
215 list_for_each_entry_safe(bridge, next, bridge_list, node) {
216 fpga_bridge_put(bridge);
217
218 spin_lock_irqsave(&bridge_list_lock, flags);
219 list_del(&bridge->node);
220 spin_unlock_irqrestore(&bridge_list_lock, flags);
221 }
222}
223EXPORT_SYMBOL_GPL(fpga_bridges_put);
224
225/**
226 * of_fpga_bridge_get_to_list - get a bridge, add it to a list
227 *
228 * @np: node pointer of an FPGA bridge
229 * @info: fpga image specific information
230 * @bridge_list: list of FPGA bridges
231 *
232 * Get an exclusive reference to the bridge and it to the list.
233 *
234 * Return: 0 for success, error code from of_fpga_bridge_get() otherwise.
235 */
236int of_fpga_bridge_get_to_list(struct device_node *np,
237 struct fpga_image_info *info,
238 struct list_head *bridge_list)
239{
240 struct fpga_bridge *bridge;
241 unsigned long flags;
242
243 bridge = of_fpga_bridge_get(np, info);
244 if (IS_ERR(bridge))
245 return PTR_ERR(bridge);
246
247 spin_lock_irqsave(&bridge_list_lock, flags);
248 list_add(&bridge->node, bridge_list);
249 spin_unlock_irqrestore(&bridge_list_lock, flags);
250
251 return 0;
252}
253EXPORT_SYMBOL_GPL(of_fpga_bridge_get_to_list);
254
255/**
256 * fpga_bridge_get_to_list - given device, get a bridge, add it to a list
257 *
258 * @dev: FPGA bridge device
259 * @info: fpga image specific information
260 * @bridge_list: list of FPGA bridges
261 *
262 * Get an exclusive reference to the bridge and it to the list.
263 *
264 * Return: 0 for success, error code from fpga_bridge_get() otherwise.
265 */
266int fpga_bridge_get_to_list(struct device *dev,
267 struct fpga_image_info *info,
268 struct list_head *bridge_list)
269{
270 struct fpga_bridge *bridge;
271 unsigned long flags;
272
273 bridge = fpga_bridge_get(dev, info);
274 if (IS_ERR(bridge))
275 return PTR_ERR(bridge);
276
277 spin_lock_irqsave(&bridge_list_lock, flags);
278 list_add(&bridge->node, bridge_list);
279 spin_unlock_irqrestore(&bridge_list_lock, flags);
280
281 return 0;
282}
283EXPORT_SYMBOL_GPL(fpga_bridge_get_to_list);
284
285static ssize_t name_show(struct device *dev,
286 struct device_attribute *attr, char *buf)
287{
288 struct fpga_bridge *bridge = to_fpga_bridge(dev);
289
290 return sprintf(buf, "%s\n", bridge->name);
291}
292
293static ssize_t state_show(struct device *dev,
294 struct device_attribute *attr, char *buf)
295{
296 struct fpga_bridge *bridge = to_fpga_bridge(dev);
297 int state = 1;
298
299 if (bridge->br_ops && bridge->br_ops->enable_show) {
300 state = bridge->br_ops->enable_show(bridge);
301 if (state < 0)
302 return state;
303 }
304
305 return sysfs_emit(buf, "%s\n", state ? "enabled" : "disabled");
306}
307
308static DEVICE_ATTR_RO(name);
309static DEVICE_ATTR_RO(state);
310
311static struct attribute *fpga_bridge_attrs[] = {
312 &dev_attr_name.attr,
313 &dev_attr_state.attr,
314 NULL,
315};
316ATTRIBUTE_GROUPS(fpga_bridge);
317
318/**
319 * fpga_bridge_register - create and register an FPGA Bridge device
320 * @parent: FPGA bridge device from pdev
321 * @name: FPGA bridge name
322 * @br_ops: pointer to structure of fpga bridge ops
323 * @priv: FPGA bridge private data
324 *
325 * Return: struct fpga_bridge pointer or ERR_PTR()
326 */
327struct fpga_bridge *
328fpga_bridge_register(struct device *parent, const char *name,
329 const struct fpga_bridge_ops *br_ops,
330 void *priv)
331{
332 struct fpga_bridge *bridge;
333 int id, ret;
334
335 if (!br_ops) {
336 dev_err(parent, "Attempt to register without fpga_bridge_ops\n");
337 return ERR_PTR(-EINVAL);
338 }
339
340 if (!name || !strlen(name)) {
341 dev_err(parent, "Attempt to register with no name!\n");
342 return ERR_PTR(-EINVAL);
343 }
344
345 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
346 if (!bridge)
347 return ERR_PTR(-ENOMEM);
348
349 id = ida_alloc(&fpga_bridge_ida, GFP_KERNEL);
350 if (id < 0) {
351 ret = id;
352 goto error_kfree;
353 }
354
355 mutex_init(&bridge->mutex);
356 INIT_LIST_HEAD(&bridge->node);
357
358 bridge->name = name;
359 bridge->br_ops = br_ops;
360 bridge->priv = priv;
361
362 bridge->dev.groups = br_ops->groups;
363 bridge->dev.class = &fpga_bridge_class;
364 bridge->dev.parent = parent;
365 bridge->dev.of_node = parent->of_node;
366 bridge->dev.id = id;
367
368 ret = dev_set_name(&bridge->dev, "br%d", id);
369 if (ret)
370 goto error_device;
371
372 ret = device_register(&bridge->dev);
373 if (ret) {
374 put_device(&bridge->dev);
375 return ERR_PTR(ret);
376 }
377
378 of_platform_populate(bridge->dev.of_node, NULL, NULL, &bridge->dev);
379
380 return bridge;
381
382error_device:
383 ida_free(&fpga_bridge_ida, id);
384error_kfree:
385 kfree(bridge);
386
387 return ERR_PTR(ret);
388}
389EXPORT_SYMBOL_GPL(fpga_bridge_register);
390
391/**
392 * fpga_bridge_unregister - unregister an FPGA bridge
393 *
394 * @bridge: FPGA bridge struct
395 *
396 * This function is intended for use in an FPGA bridge driver's remove function.
397 */
398void fpga_bridge_unregister(struct fpga_bridge *bridge)
399{
400 /*
401 * If the low level driver provides a method for putting bridge into
402 * a desired state upon unregister, do it.
403 */
404 if (bridge->br_ops && bridge->br_ops->fpga_bridge_remove)
405 bridge->br_ops->fpga_bridge_remove(bridge);
406
407 device_unregister(&bridge->dev);
408}
409EXPORT_SYMBOL_GPL(fpga_bridge_unregister);
410
411static void fpga_bridge_dev_release(struct device *dev)
412{
413 struct fpga_bridge *bridge = to_fpga_bridge(dev);
414
415 ida_free(&fpga_bridge_ida, bridge->dev.id);
416 kfree(bridge);
417}
418
419static const struct class fpga_bridge_class = {
420 .name = "fpga_bridge",
421 .dev_groups = fpga_bridge_groups,
422 .dev_release = fpga_bridge_dev_release,
423};
424
425static int __init fpga_bridge_dev_init(void)
426{
427 return class_register(&fpga_bridge_class);
428}
429
430static void __exit fpga_bridge_dev_exit(void)
431{
432 class_unregister(&fpga_bridge_class);
433 ida_destroy(&fpga_bridge_ida);
434}
435
436MODULE_DESCRIPTION("FPGA Bridge Driver");
437MODULE_AUTHOR("Alan Tull <atull@kernel.org>");
438MODULE_LICENSE("GPL v2");
439
440subsys_initcall(fpga_bridge_dev_init);
441module_exit(fpga_bridge_dev_exit);
1/*
2 * FPGA Bridge Framework Driver
3 *
4 * Copyright (C) 2013-2016 Altera Corporation, All Rights Reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18#include <linux/fpga/fpga-bridge.h>
19#include <linux/idr.h>
20#include <linux/kernel.h>
21#include <linux/module.h>
22#include <linux/of_platform.h>
23#include <linux/slab.h>
24#include <linux/spinlock.h>
25
26static DEFINE_IDA(fpga_bridge_ida);
27static struct class *fpga_bridge_class;
28
29/* Lock for adding/removing bridges to linked lists*/
30spinlock_t bridge_list_lock;
31
32static int fpga_bridge_of_node_match(struct device *dev, const void *data)
33{
34 return dev->of_node == data;
35}
36
37/**
38 * fpga_bridge_enable - Enable transactions on the bridge
39 *
40 * @bridge: FPGA bridge
41 *
42 * Return: 0 for success, error code otherwise.
43 */
44int fpga_bridge_enable(struct fpga_bridge *bridge)
45{
46 dev_dbg(&bridge->dev, "enable\n");
47
48 if (bridge->br_ops && bridge->br_ops->enable_set)
49 return bridge->br_ops->enable_set(bridge, 1);
50
51 return 0;
52}
53EXPORT_SYMBOL_GPL(fpga_bridge_enable);
54
55/**
56 * fpga_bridge_disable - Disable transactions on the bridge
57 *
58 * @bridge: FPGA bridge
59 *
60 * Return: 0 for success, error code otherwise.
61 */
62int fpga_bridge_disable(struct fpga_bridge *bridge)
63{
64 dev_dbg(&bridge->dev, "disable\n");
65
66 if (bridge->br_ops && bridge->br_ops->enable_set)
67 return bridge->br_ops->enable_set(bridge, 0);
68
69 return 0;
70}
71EXPORT_SYMBOL_GPL(fpga_bridge_disable);
72
73/**
74 * of_fpga_bridge_get - get an exclusive reference to a fpga bridge
75 *
76 * @np: node pointer of a FPGA bridge
77 * @info: fpga image specific information
78 *
79 * Return fpga_bridge struct if successful.
80 * Return -EBUSY if someone already has a reference to the bridge.
81 * Return -ENODEV if @np is not a FPGA Bridge.
82 */
83struct fpga_bridge *of_fpga_bridge_get(struct device_node *np,
84 struct fpga_image_info *info)
85
86{
87 struct device *dev;
88 struct fpga_bridge *bridge;
89 int ret = -ENODEV;
90
91 dev = class_find_device(fpga_bridge_class, NULL, np,
92 fpga_bridge_of_node_match);
93 if (!dev)
94 goto err_dev;
95
96 bridge = to_fpga_bridge(dev);
97 if (!bridge)
98 goto err_dev;
99
100 bridge->info = info;
101
102 if (!mutex_trylock(&bridge->mutex)) {
103 ret = -EBUSY;
104 goto err_dev;
105 }
106
107 if (!try_module_get(dev->parent->driver->owner))
108 goto err_ll_mod;
109
110 dev_dbg(&bridge->dev, "get\n");
111
112 return bridge;
113
114err_ll_mod:
115 mutex_unlock(&bridge->mutex);
116err_dev:
117 put_device(dev);
118 return ERR_PTR(ret);
119}
120EXPORT_SYMBOL_GPL(of_fpga_bridge_get);
121
122/**
123 * fpga_bridge_put - release a reference to a bridge
124 *
125 * @bridge: FPGA bridge
126 */
127void fpga_bridge_put(struct fpga_bridge *bridge)
128{
129 dev_dbg(&bridge->dev, "put\n");
130
131 bridge->info = NULL;
132 module_put(bridge->dev.parent->driver->owner);
133 mutex_unlock(&bridge->mutex);
134 put_device(&bridge->dev);
135}
136EXPORT_SYMBOL_GPL(fpga_bridge_put);
137
138/**
139 * fpga_bridges_enable - enable bridges in a list
140 * @bridge_list: list of FPGA bridges
141 *
142 * Enable each bridge in the list. If list is empty, do nothing.
143 *
144 * Return 0 for success or empty bridge list; return error code otherwise.
145 */
146int fpga_bridges_enable(struct list_head *bridge_list)
147{
148 struct fpga_bridge *bridge;
149 struct list_head *node;
150 int ret;
151
152 list_for_each(node, bridge_list) {
153 bridge = list_entry(node, struct fpga_bridge, node);
154 ret = fpga_bridge_enable(bridge);
155 if (ret)
156 return ret;
157 }
158
159 return 0;
160}
161EXPORT_SYMBOL_GPL(fpga_bridges_enable);
162
163/**
164 * fpga_bridges_disable - disable bridges in a list
165 *
166 * @bridge_list: list of FPGA bridges
167 *
168 * Disable each bridge in the list. If list is empty, do nothing.
169 *
170 * Return 0 for success or empty bridge list; return error code otherwise.
171 */
172int fpga_bridges_disable(struct list_head *bridge_list)
173{
174 struct fpga_bridge *bridge;
175 struct list_head *node;
176 int ret;
177
178 list_for_each(node, bridge_list) {
179 bridge = list_entry(node, struct fpga_bridge, node);
180 ret = fpga_bridge_disable(bridge);
181 if (ret)
182 return ret;
183 }
184
185 return 0;
186}
187EXPORT_SYMBOL_GPL(fpga_bridges_disable);
188
189/**
190 * fpga_bridges_put - put bridges
191 *
192 * @bridge_list: list of FPGA bridges
193 *
194 * For each bridge in the list, put the bridge and remove it from the list.
195 * If list is empty, do nothing.
196 */
197void fpga_bridges_put(struct list_head *bridge_list)
198{
199 struct fpga_bridge *bridge;
200 struct list_head *node, *next;
201 unsigned long flags;
202
203 list_for_each_safe(node, next, bridge_list) {
204 bridge = list_entry(node, struct fpga_bridge, node);
205
206 fpga_bridge_put(bridge);
207
208 spin_lock_irqsave(&bridge_list_lock, flags);
209 list_del(&bridge->node);
210 spin_unlock_irqrestore(&bridge_list_lock, flags);
211 }
212}
213EXPORT_SYMBOL_GPL(fpga_bridges_put);
214
215/**
216 * fpga_bridges_get_to_list - get a bridge, add it to a list
217 *
218 * @np: node pointer of a FPGA bridge
219 * @info: fpga image specific information
220 * @bridge_list: list of FPGA bridges
221 *
222 * Get an exclusive reference to the bridge and and it to the list.
223 *
224 * Return 0 for success, error code from of_fpga_bridge_get() othewise.
225 */
226int fpga_bridge_get_to_list(struct device_node *np,
227 struct fpga_image_info *info,
228 struct list_head *bridge_list)
229{
230 struct fpga_bridge *bridge;
231 unsigned long flags;
232
233 bridge = of_fpga_bridge_get(np, info);
234 if (IS_ERR(bridge))
235 return PTR_ERR(bridge);
236
237 spin_lock_irqsave(&bridge_list_lock, flags);
238 list_add(&bridge->node, bridge_list);
239 spin_unlock_irqrestore(&bridge_list_lock, flags);
240
241 return 0;
242}
243EXPORT_SYMBOL_GPL(fpga_bridge_get_to_list);
244
245static ssize_t name_show(struct device *dev,
246 struct device_attribute *attr, char *buf)
247{
248 struct fpga_bridge *bridge = to_fpga_bridge(dev);
249
250 return sprintf(buf, "%s\n", bridge->name);
251}
252
253static ssize_t state_show(struct device *dev,
254 struct device_attribute *attr, char *buf)
255{
256 struct fpga_bridge *bridge = to_fpga_bridge(dev);
257 int enable = 1;
258
259 if (bridge->br_ops && bridge->br_ops->enable_show)
260 enable = bridge->br_ops->enable_show(bridge);
261
262 return sprintf(buf, "%s\n", enable ? "enabled" : "disabled");
263}
264
265static DEVICE_ATTR_RO(name);
266static DEVICE_ATTR_RO(state);
267
268static struct attribute *fpga_bridge_attrs[] = {
269 &dev_attr_name.attr,
270 &dev_attr_state.attr,
271 NULL,
272};
273ATTRIBUTE_GROUPS(fpga_bridge);
274
275/**
276 * fpga_bridge_register - register a fpga bridge driver
277 * @dev: FPGA bridge device from pdev
278 * @name: FPGA bridge name
279 * @br_ops: pointer to structure of fpga bridge ops
280 * @priv: FPGA bridge private data
281 *
282 * Return: 0 for success, error code otherwise.
283 */
284int fpga_bridge_register(struct device *dev, const char *name,
285 const struct fpga_bridge_ops *br_ops, void *priv)
286{
287 struct fpga_bridge *bridge;
288 int id, ret = 0;
289
290 if (!name || !strlen(name)) {
291 dev_err(dev, "Attempt to register with no name!\n");
292 return -EINVAL;
293 }
294
295 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
296 if (!bridge)
297 return -ENOMEM;
298
299 id = ida_simple_get(&fpga_bridge_ida, 0, 0, GFP_KERNEL);
300 if (id < 0) {
301 ret = id;
302 goto error_kfree;
303 }
304
305 mutex_init(&bridge->mutex);
306 INIT_LIST_HEAD(&bridge->node);
307
308 bridge->name = name;
309 bridge->br_ops = br_ops;
310 bridge->priv = priv;
311
312 device_initialize(&bridge->dev);
313 bridge->dev.class = fpga_bridge_class;
314 bridge->dev.parent = dev;
315 bridge->dev.of_node = dev->of_node;
316 bridge->dev.id = id;
317 dev_set_drvdata(dev, bridge);
318
319 ret = dev_set_name(&bridge->dev, "br%d", id);
320 if (ret)
321 goto error_device;
322
323 ret = device_add(&bridge->dev);
324 if (ret)
325 goto error_device;
326
327 of_platform_populate(dev->of_node, NULL, NULL, dev);
328
329 dev_info(bridge->dev.parent, "fpga bridge [%s] registered\n",
330 bridge->name);
331
332 return 0;
333
334error_device:
335 ida_simple_remove(&fpga_bridge_ida, id);
336error_kfree:
337 kfree(bridge);
338
339 return ret;
340}
341EXPORT_SYMBOL_GPL(fpga_bridge_register);
342
343/**
344 * fpga_bridge_unregister - unregister a fpga bridge driver
345 * @dev: FPGA bridge device from pdev
346 */
347void fpga_bridge_unregister(struct device *dev)
348{
349 struct fpga_bridge *bridge = dev_get_drvdata(dev);
350
351 /*
352 * If the low level driver provides a method for putting bridge into
353 * a desired state upon unregister, do it.
354 */
355 if (bridge->br_ops && bridge->br_ops->fpga_bridge_remove)
356 bridge->br_ops->fpga_bridge_remove(bridge);
357
358 device_unregister(&bridge->dev);
359}
360EXPORT_SYMBOL_GPL(fpga_bridge_unregister);
361
362static void fpga_bridge_dev_release(struct device *dev)
363{
364 struct fpga_bridge *bridge = to_fpga_bridge(dev);
365
366 ida_simple_remove(&fpga_bridge_ida, bridge->dev.id);
367 kfree(bridge);
368}
369
370static int __init fpga_bridge_dev_init(void)
371{
372 spin_lock_init(&bridge_list_lock);
373
374 fpga_bridge_class = class_create(THIS_MODULE, "fpga_bridge");
375 if (IS_ERR(fpga_bridge_class))
376 return PTR_ERR(fpga_bridge_class);
377
378 fpga_bridge_class->dev_groups = fpga_bridge_groups;
379 fpga_bridge_class->dev_release = fpga_bridge_dev_release;
380
381 return 0;
382}
383
384static void __exit fpga_bridge_dev_exit(void)
385{
386 class_destroy(fpga_bridge_class);
387 ida_destroy(&fpga_bridge_ida);
388}
389
390MODULE_DESCRIPTION("FPGA Bridge Driver");
391MODULE_AUTHOR("Alan Tull <atull@opensource.altera.com>");
392MODULE_LICENSE("GPL v2");
393
394subsys_initcall(fpga_bridge_dev_init);
395module_exit(fpga_bridge_dev_exit);