]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
394b701c MP |
2 | /* |
3 | * RapidIO driver support | |
4 | * | |
5 | * Copyright 2005 MontaVista Software, Inc. | |
6 | * Matt Porter <mporter@kernel.crashing.org> | |
394b701c MP |
7 | */ |
8 | ||
9 | #include <linux/init.h> | |
10 | #include <linux/module.h> | |
11 | #include <linux/rio.h> | |
12 | #include <linux/rio_ids.h> | |
13 | ||
14 | #include "rio.h" | |
15 | ||
16 | /** | |
17 | * rio_match_device - Tell if a RIO device has a matching RIO device id structure | |
18 | * @id: the RIO device id structure to match against | |
19 | * @rdev: the RIO device structure to match against | |
20 | * | |
21 | * Used from driver probe and bus matching to check whether a RIO device | |
22 | * matches a device id structure provided by a RIO driver. Returns the | |
23 | * matching &struct rio_device_id or %NULL if there is no match. | |
24 | */ | |
25 | static const struct rio_device_id *rio_match_device(const struct rio_device_id | |
26 | *id, | |
27 | const struct rio_dev *rdev) | |
28 | { | |
29 | while (id->vid || id->asm_vid) { | |
30 | if (((id->vid == RIO_ANY_ID) || (id->vid == rdev->vid)) && | |
31 | ((id->did == RIO_ANY_ID) || (id->did == rdev->did)) && | |
32 | ((id->asm_vid == RIO_ANY_ID) | |
33 | || (id->asm_vid == rdev->asm_vid)) | |
34 | && ((id->asm_did == RIO_ANY_ID) | |
35 | || (id->asm_did == rdev->asm_did))) | |
36 | return id; | |
37 | id++; | |
38 | } | |
39 | return NULL; | |
40 | } | |
41 | ||
42 | /** | |
43 | * rio_dev_get - Increments the reference count of the RIO device structure | |
44 | * | |
45 | * @rdev: RIO device being referenced | |
46 | * | |
47 | * Each live reference to a device should be refcounted. | |
48 | * | |
49 | * Drivers for RIO devices should normally record such references in | |
50 | * their probe() methods, when they bind to a device, and release | |
51 | * them by calling rio_dev_put(), in their disconnect() methods. | |
52 | */ | |
53 | struct rio_dev *rio_dev_get(struct rio_dev *rdev) | |
54 | { | |
55 | if (rdev) | |
56 | get_device(&rdev->dev); | |
57 | ||
58 | return rdev; | |
59 | } | |
60 | ||
61 | /** | |
62 | * rio_dev_put - Release a use of the RIO device structure | |
63 | * | |
64 | * @rdev: RIO device being disconnected | |
65 | * | |
66 | * Must be called when a user of a device is finished with it. | |
67 | * When the last user of the device calls this function, the | |
68 | * memory of the device is freed. | |
69 | */ | |
70 | void rio_dev_put(struct rio_dev *rdev) | |
71 | { | |
72 | if (rdev) | |
73 | put_device(&rdev->dev); | |
74 | } | |
75 | ||
76 | /** | |
7b089c8b | 77 | * rio_device_probe - Tell if a RIO device structure has a matching RIO device id structure |
394b701c MP |
78 | * @dev: the RIO device structure to match against |
79 | * | |
80 | * return 0 and set rio_dev->driver when drv claims rio_dev, else error | |
81 | */ | |
82 | static int rio_device_probe(struct device *dev) | |
83 | { | |
84 | struct rio_driver *rdrv = to_rio_driver(dev->driver); | |
85 | struct rio_dev *rdev = to_rio_dev(dev); | |
86 | int error = -ENODEV; | |
87 | const struct rio_device_id *id; | |
88 | ||
89 | if (!rdev->driver && rdrv->probe) { | |
90 | if (!rdrv->id_table) | |
91 | return error; | |
92 | id = rio_match_device(rdrv->id_table, rdev); | |
93 | rio_dev_get(rdev); | |
94 | if (id) | |
95 | error = rdrv->probe(rdev, id); | |
96 | if (error >= 0) { | |
97 | rdev->driver = rdrv; | |
98 | error = 0; | |
a7de3902 | 99 | } else |
394b701c | 100 | rio_dev_put(rdev); |
394b701c MP |
101 | } |
102 | return error; | |
103 | } | |
104 | ||
105 | /** | |
106 | * rio_device_remove - Remove a RIO device from the system | |
107 | * | |
108 | * @dev: the RIO device structure to match against | |
109 | * | |
110 | * Remove a RIO device from the system. If it has an associated | |
111 | * driver, then run the driver remove() method. Then update | |
112 | * the reference count. | |
113 | */ | |
114 | static int rio_device_remove(struct device *dev) | |
115 | { | |
116 | struct rio_dev *rdev = to_rio_dev(dev); | |
117 | struct rio_driver *rdrv = rdev->driver; | |
118 | ||
119 | if (rdrv) { | |
120 | if (rdrv->remove) | |
121 | rdrv->remove(rdev); | |
122 | rdev->driver = NULL; | |
123 | } | |
124 | ||
125 | rio_dev_put(rdev); | |
126 | ||
127 | return 0; | |
128 | } | |
129 | ||
83dc2cbc AB |
130 | static void rio_device_shutdown(struct device *dev) |
131 | { | |
132 | struct rio_dev *rdev = to_rio_dev(dev); | |
133 | struct rio_driver *rdrv = rdev->driver; | |
134 | ||
135 | dev_dbg(dev, "RIO: %s\n", __func__); | |
136 | ||
137 | if (rdrv && rdrv->shutdown) | |
138 | rdrv->shutdown(rdev); | |
139 | } | |
140 | ||
394b701c MP |
141 | /** |
142 | * rio_register_driver - register a new RIO driver | |
143 | * @rdrv: the RIO driver structure to register | |
144 | * | |
7b089c8b | 145 | * Adds a &struct rio_driver to the list of registered drivers. |
394b701c MP |
146 | * Returns a negative value on error, otherwise 0. If no error |
147 | * occurred, the driver remains registered even if no device | |
148 | * was claimed during registration. | |
149 | */ | |
150 | int rio_register_driver(struct rio_driver *rdrv) | |
151 | { | |
152 | /* initialize common driver fields */ | |
153 | rdrv->driver.name = rdrv->name; | |
154 | rdrv->driver.bus = &rio_bus_type; | |
394b701c MP |
155 | |
156 | /* register with core */ | |
157 | return driver_register(&rdrv->driver); | |
158 | } | |
159 | ||
160 | /** | |
161 | * rio_unregister_driver - unregister a RIO driver | |
162 | * @rdrv: the RIO driver structure to unregister | |
163 | * | |
164 | * Deletes the &struct rio_driver from the list of registered RIO | |
165 | * drivers, gives it a chance to clean up by calling its remove() | |
166 | * function for each device it was responsible for, and marks those | |
167 | * devices as driverless. | |
168 | */ | |
169 | void rio_unregister_driver(struct rio_driver *rdrv) | |
170 | { | |
171 | driver_unregister(&rdrv->driver); | |
172 | } | |
173 | ||
a11650e1 AB |
174 | void rio_attach_device(struct rio_dev *rdev) |
175 | { | |
176 | rdev->dev.bus = &rio_bus_type; | |
a11650e1 AB |
177 | } |
178 | EXPORT_SYMBOL_GPL(rio_attach_device); | |
179 | ||
394b701c | 180 | /** |
7b089c8b | 181 | * rio_match_bus - Tell if a RIO device structure has a matching RIO driver device id structure |
394b701c MP |
182 | * @dev: the standard device structure to match against |
183 | * @drv: the standard driver structure containing the ids to match against | |
184 | * | |
185 | * Used by a driver to check whether a RIO device present in the | |
186 | * system is in its list of supported devices. Returns 1 if | |
187 | * there is a matching &struct rio_device_id or 0 if there is | |
188 | * no match. | |
189 | */ | |
190 | static int rio_match_bus(struct device *dev, struct device_driver *drv) | |
191 | { | |
192 | struct rio_dev *rdev = to_rio_dev(dev); | |
193 | struct rio_driver *rdrv = to_rio_driver(drv); | |
194 | const struct rio_device_id *id = rdrv->id_table; | |
195 | const struct rio_device_id *found_id; | |
196 | ||
197 | if (!id) | |
198 | goto out; | |
199 | ||
200 | found_id = rio_match_device(id, rdev); | |
201 | ||
202 | if (found_id) | |
203 | return 1; | |
204 | ||
205 | out:return 0; | |
206 | } | |
207 | ||
3bdbb62f AB |
208 | static int rio_uevent(struct device *dev, struct kobj_uevent_env *env) |
209 | { | |
210 | struct rio_dev *rdev; | |
211 | ||
212 | if (!dev) | |
213 | return -ENODEV; | |
214 | ||
215 | rdev = to_rio_dev(dev); | |
216 | if (!rdev) | |
217 | return -ENODEV; | |
218 | ||
219 | if (add_uevent_var(env, "MODALIAS=rapidio:v%04Xd%04Xav%04Xad%04X", | |
220 | rdev->vid, rdev->did, rdev->asm_vid, rdev->asm_did)) | |
221 | return -ENOMEM; | |
222 | return 0; | |
223 | } | |
224 | ||
2aaf308b AB |
225 | struct class rio_mport_class = { |
226 | .name = "rapidio_port", | |
227 | .owner = THIS_MODULE, | |
228 | .dev_groups = rio_mport_groups, | |
394b701c | 229 | }; |
2aaf308b | 230 | EXPORT_SYMBOL_GPL(rio_mport_class); |
394b701c MP |
231 | |
232 | struct bus_type rio_bus_type = { | |
233 | .name = "rapidio", | |
234 | .match = rio_match_bus, | |
6d39c80b | 235 | .dev_groups = rio_dev_groups, |
ed1d2da2 | 236 | .bus_groups = rio_bus_groups, |
fc3d3ddd RK |
237 | .probe = rio_device_probe, |
238 | .remove = rio_device_remove, | |
83dc2cbc | 239 | .shutdown = rio_device_shutdown, |
3bdbb62f | 240 | .uevent = rio_uevent, |
394b701c MP |
241 | }; |
242 | ||
243 | /** | |
244 | * rio_bus_init - Register the RapidIO bus with the device model | |
245 | * | |
2aaf308b | 246 | * Registers the RIO mport device class and RIO bus type with the Linux |
394b701c MP |
247 | * device model. |
248 | */ | |
249 | static int __init rio_bus_init(void) | |
250 | { | |
2aaf308b AB |
251 | int ret; |
252 | ||
253 | ret = class_register(&rio_mport_class); | |
254 | if (!ret) { | |
255 | ret = bus_register(&rio_bus_type); | |
256 | if (ret) | |
257 | class_unregister(&rio_mport_class); | |
258 | } | |
259 | return ret; | |
394b701c MP |
260 | } |
261 | ||
262 | postcore_initcall(rio_bus_init); | |
263 | ||
264 | EXPORT_SYMBOL_GPL(rio_register_driver); | |
265 | EXPORT_SYMBOL_GPL(rio_unregister_driver); | |
266 | EXPORT_SYMBOL_GPL(rio_bus_type); | |
267 | EXPORT_SYMBOL_GPL(rio_dev_get); | |
268 | EXPORT_SYMBOL_GPL(rio_dev_put); |