Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Functions to handle I2O drivers (OSMs) and I2O bus type for sysfs | |
3 | * | |
4 | * Copyright (C) 2004 Markus Lidel <Markus.Lidel@shadowconnect.com> | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify it | |
7 | * under the terms of the GNU General Public License as published by the | |
8 | * Free Software Foundation; either version 2 of the License, or (at your | |
9 | * option) any later version. | |
10 | * | |
11 | * Fixes/additions: | |
12 | * Markus Lidel <Markus.Lidel@shadowconnect.com> | |
13 | * initial version. | |
14 | */ | |
15 | ||
16 | #include <linux/device.h> | |
17 | #include <linux/module.h> | |
18 | #include <linux/rwsem.h> | |
19 | #include <linux/i2o.h> | |
4e57b681 TS |
20 | #include <linux/workqueue.h> |
21 | #include <linux/string.h> | |
22 | #include <linux/slab.h> | |
9e87545f | 23 | #include "core.h" |
1da177e4 | 24 | |
f88e119c | 25 | #define OSM_NAME "i2o" |
61fbfa81 | 26 | |
1da177e4 | 27 | /* max_drivers - Maximum I2O drivers (OSMs) which could be registered */ |
9e87545f | 28 | static unsigned int i2o_max_drivers = I2O_MAX_DRIVERS; |
1da177e4 LT |
29 | module_param_named(max_drivers, i2o_max_drivers, uint, 0); |
30 | MODULE_PARM_DESC(max_drivers, "maximum number of OSM's to support"); | |
31 | ||
32 | /* I2O drivers lock and array */ | |
33 | static spinlock_t i2o_drivers_lock; | |
34 | static struct i2o_driver **i2o_drivers; | |
35 | ||
36 | /** | |
37 | * i2o_bus_match - Tell if a I2O device class id match the class ids of | |
38 | * the I2O driver (OSM) | |
39 | * | |
40 | * @dev: device which should be verified | |
41 | * @drv: the driver to match against | |
42 | * | |
43 | * Used by the bus to check if the driver wants to handle the device. | |
44 | * | |
45 | * Returns 1 if the class ids of the driver match the class id of the | |
46 | * device, otherwise 0. | |
47 | */ | |
48 | static int i2o_bus_match(struct device *dev, struct device_driver *drv) | |
49 | { | |
50 | struct i2o_device *i2o_dev = to_i2o_device(dev); | |
51 | struct i2o_driver *i2o_drv = to_i2o_driver(drv); | |
52 | struct i2o_class_id *ids = i2o_drv->classes; | |
53 | ||
54 | if (ids) | |
55 | while (ids->class_id != I2O_CLASS_END) { | |
56 | if (ids->class_id == i2o_dev->lct_data.class_id) | |
57 | return 1; | |
58 | ids++; | |
59 | } | |
60 | return 0; | |
61 | }; | |
62 | ||
63 | /* I2O bus type */ | |
7bd7b091 DT |
64 | extern struct device_attribute i2o_device_attrs[]; |
65 | ||
1da177e4 LT |
66 | struct bus_type i2o_bus_type = { |
67 | .name = "i2o", | |
68 | .match = i2o_bus_match, | |
7bd7b091 | 69 | .dev_attrs = i2o_device_attrs, |
1da177e4 LT |
70 | }; |
71 | ||
72 | /** | |
73 | * i2o_driver_register - Register a I2O driver (OSM) in the I2O core | |
74 | * @drv: I2O driver which should be registered | |
75 | * | |
76 | * Registers the OSM drv in the I2O core and creates an event queues if | |
77 | * necessary. | |
78 | * | |
79 | * Returns 0 on success or negative error code on failure. | |
80 | */ | |
81 | int i2o_driver_register(struct i2o_driver *drv) | |
82 | { | |
83 | struct i2o_controller *c; | |
84 | int i; | |
85 | int rc = 0; | |
86 | unsigned long flags; | |
87 | ||
f88e119c | 88 | osm_debug("Register driver %s\n", drv->name); |
1da177e4 LT |
89 | |
90 | if (drv->event) { | |
91 | drv->event_queue = create_workqueue(drv->name); | |
92 | if (!drv->event_queue) { | |
f88e119c ML |
93 | osm_err("Could not initialize event queue for driver " |
94 | "%s\n", drv->name); | |
1da177e4 LT |
95 | return -EFAULT; |
96 | } | |
f88e119c | 97 | osm_debug("Event queue initialized for driver %s\n", drv->name); |
1da177e4 LT |
98 | } else |
99 | drv->event_queue = NULL; | |
100 | ||
101 | drv->driver.name = drv->name; | |
102 | drv->driver.bus = &i2o_bus_type; | |
103 | ||
104 | spin_lock_irqsave(&i2o_drivers_lock, flags); | |
105 | ||
106 | for (i = 0; i2o_drivers[i]; i++) | |
107 | if (i >= i2o_max_drivers) { | |
f88e119c ML |
108 | osm_err("too many drivers registered, increase " |
109 | "max_drivers\n"); | |
1da177e4 LT |
110 | spin_unlock_irqrestore(&i2o_drivers_lock, flags); |
111 | return -EFAULT; | |
112 | } | |
113 | ||
114 | drv->context = i; | |
115 | i2o_drivers[i] = drv; | |
116 | ||
117 | spin_unlock_irqrestore(&i2o_drivers_lock, flags); | |
118 | ||
f88e119c | 119 | osm_debug("driver %s gets context id %d\n", drv->name, drv->context); |
1da177e4 LT |
120 | |
121 | list_for_each_entry(c, &i2o_controllers, list) { | |
122 | struct i2o_device *i2o_dev; | |
123 | ||
124 | i2o_driver_notify_controller_add(drv, c); | |
125 | list_for_each_entry(i2o_dev, &c->devices, list) | |
f33213ec | 126 | i2o_driver_notify_device_add(drv, i2o_dev); |
1da177e4 LT |
127 | } |
128 | ||
1da177e4 LT |
129 | rc = driver_register(&drv->driver); |
130 | if (rc) | |
131 | destroy_workqueue(drv->event_queue); | |
132 | ||
133 | return rc; | |
134 | }; | |
135 | ||
136 | /** | |
137 | * i2o_driver_unregister - Unregister a I2O driver (OSM) from the I2O core | |
138 | * @drv: I2O driver which should be unregistered | |
139 | * | |
140 | * Unregisters the OSM drv from the I2O core and cleanup event queues if | |
141 | * necessary. | |
142 | */ | |
143 | void i2o_driver_unregister(struct i2o_driver *drv) | |
144 | { | |
145 | struct i2o_controller *c; | |
146 | unsigned long flags; | |
147 | ||
f88e119c | 148 | osm_debug("unregister driver %s\n", drv->name); |
1da177e4 LT |
149 | |
150 | driver_unregister(&drv->driver); | |
151 | ||
152 | list_for_each_entry(c, &i2o_controllers, list) { | |
153 | struct i2o_device *i2o_dev; | |
154 | ||
155 | list_for_each_entry(i2o_dev, &c->devices, list) | |
156 | i2o_driver_notify_device_remove(drv, i2o_dev); | |
157 | ||
158 | i2o_driver_notify_controller_remove(drv, c); | |
159 | } | |
160 | ||
161 | spin_lock_irqsave(&i2o_drivers_lock, flags); | |
162 | i2o_drivers[drv->context] = NULL; | |
163 | spin_unlock_irqrestore(&i2o_drivers_lock, flags); | |
164 | ||
165 | if (drv->event_queue) { | |
166 | destroy_workqueue(drv->event_queue); | |
167 | drv->event_queue = NULL; | |
f88e119c | 168 | osm_debug("event queue removed for %s\n", drv->name); |
1da177e4 LT |
169 | } |
170 | }; | |
171 | ||
172 | /** | |
173 | * i2o_driver_dispatch - dispatch an I2O reply message | |
174 | * @c: I2O controller of the message | |
175 | * @m: I2O message number | |
176 | * @msg: I2O message to be delivered | |
177 | * | |
178 | * The reply is delivered to the driver from which the original message | |
179 | * was. This function is only called from interrupt context. | |
180 | * | |
181 | * Returns 0 on success and the message should not be flushed. Returns > 0 | |
182 | * on success and if the message should be flushed afterwords. Returns | |
183 | * negative error code on failure (the message will be flushed too). | |
184 | */ | |
f88e119c | 185 | int i2o_driver_dispatch(struct i2o_controller *c, u32 m) |
1da177e4 LT |
186 | { |
187 | struct i2o_driver *drv; | |
9e87545f ML |
188 | struct i2o_message *msg = i2o_msg_out_to_virt(c, m); |
189 | u32 context = le32_to_cpu(msg->u.s.icntxt); | |
f10378ff ML |
190 | unsigned long flags; |
191 | ||
61fbfa81 | 192 | if (unlikely(context >= i2o_max_drivers)) { |
f88e119c ML |
193 | osm_warn("%s: Spurious reply to unknown driver %d\n", c->name, |
194 | context); | |
61fbfa81 ML |
195 | return -EIO; |
196 | } | |
1da177e4 | 197 | |
f10378ff | 198 | spin_lock_irqsave(&i2o_drivers_lock, flags); |
61fbfa81 | 199 | drv = i2o_drivers[context]; |
f10378ff | 200 | spin_unlock_irqrestore(&i2o_drivers_lock, flags); |
1da177e4 | 201 | |
61fbfa81 | 202 | if (unlikely(!drv)) { |
f88e119c ML |
203 | osm_warn("%s: Spurious reply to unknown driver %d\n", c->name, |
204 | context); | |
61fbfa81 ML |
205 | return -EIO; |
206 | } | |
1da177e4 | 207 | |
9e87545f | 208 | if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_UTIL_EVT_REGISTER) { |
61fbfa81 ML |
209 | struct i2o_device *dev, *tmp; |
210 | struct i2o_event *evt; | |
211 | u16 size; | |
9e87545f | 212 | u16 tid = le32_to_cpu(msg->u.head[1]) & 0xfff; |
1da177e4 | 213 | |
61fbfa81 | 214 | osm_debug("event received from device %d\n", tid); |
1da177e4 | 215 | |
f88e119c ML |
216 | if (!drv->event) |
217 | return -EIO; | |
218 | ||
61fbfa81 | 219 | /* cut of header from message size (in 32-bit words) */ |
9e87545f | 220 | size = (le32_to_cpu(msg->u.head[0]) >> 16) - 5; |
1da177e4 | 221 | |
61fbfa81 ML |
222 | evt = kmalloc(size * 4 + sizeof(*evt), GFP_ATOMIC | __GFP_ZERO); |
223 | if (!evt) | |
224 | return -ENOMEM; | |
1da177e4 | 225 | |
61fbfa81 | 226 | evt->size = size; |
9e87545f ML |
227 | evt->tcntxt = le32_to_cpu(msg->u.s.tcntxt); |
228 | evt->event_indicator = le32_to_cpu(msg->body[0]); | |
229 | memcpy(&evt->tcntxt, &msg->u.s.tcntxt, size * 4); | |
1da177e4 | 230 | |
61fbfa81 ML |
231 | list_for_each_entry_safe(dev, tmp, &c->devices, list) |
232 | if (dev->lct_data.tid == tid) { | |
233 | evt->i2o_dev = dev; | |
234 | break; | |
1da177e4 LT |
235 | } |
236 | ||
61fbfa81 ML |
237 | INIT_WORK(&evt->work, (void (*)(void *))drv->event, evt); |
238 | queue_work(drv->event_queue, &evt->work); | |
239 | return 1; | |
240 | } | |
241 | ||
242 | if (unlikely(!drv->reply)) { | |
f88e119c ML |
243 | osm_debug("%s: Reply to driver %s, but no reply function" |
244 | " defined!\n", c->name, drv->name); | |
1da177e4 | 245 | return -EIO; |
61fbfa81 ML |
246 | } |
247 | ||
248 | return drv->reply(c, m, msg); | |
1da177e4 LT |
249 | } |
250 | ||
251 | /** | |
252 | * i2o_driver_notify_controller_add_all - Send notify of added controller | |
253 | * to all I2O drivers | |
254 | * | |
255 | * Send notifications to all registered drivers that a new controller was | |
256 | * added. | |
257 | */ | |
258 | void i2o_driver_notify_controller_add_all(struct i2o_controller *c) | |
259 | { | |
260 | int i; | |
261 | struct i2o_driver *drv; | |
262 | ||
263 | for (i = 0; i < I2O_MAX_DRIVERS; i++) { | |
264 | drv = i2o_drivers[i]; | |
265 | ||
266 | if (drv) | |
267 | i2o_driver_notify_controller_add(drv, c); | |
268 | } | |
269 | } | |
270 | ||
271 | /** | |
272 | * i2o_driver_notify_controller_remove_all - Send notify of removed | |
273 | * controller to all I2O drivers | |
274 | * | |
275 | * Send notifications to all registered drivers that a controller was | |
276 | * removed. | |
277 | */ | |
278 | void i2o_driver_notify_controller_remove_all(struct i2o_controller *c) | |
279 | { | |
280 | int i; | |
281 | struct i2o_driver *drv; | |
282 | ||
283 | for (i = 0; i < I2O_MAX_DRIVERS; i++) { | |
284 | drv = i2o_drivers[i]; | |
285 | ||
286 | if (drv) | |
287 | i2o_driver_notify_controller_remove(drv, c); | |
288 | } | |
289 | } | |
290 | ||
291 | /** | |
292 | * i2o_driver_notify_device_add_all - Send notify of added device to all | |
293 | * I2O drivers | |
294 | * | |
295 | * Send notifications to all registered drivers that a device was added. | |
296 | */ | |
297 | void i2o_driver_notify_device_add_all(struct i2o_device *i2o_dev) | |
298 | { | |
299 | int i; | |
300 | struct i2o_driver *drv; | |
301 | ||
302 | for (i = 0; i < I2O_MAX_DRIVERS; i++) { | |
303 | drv = i2o_drivers[i]; | |
304 | ||
305 | if (drv) | |
306 | i2o_driver_notify_device_add(drv, i2o_dev); | |
307 | } | |
308 | } | |
309 | ||
310 | /** | |
311 | * i2o_driver_notify_device_remove_all - Send notify of removed device to | |
312 | * all I2O drivers | |
313 | * | |
314 | * Send notifications to all registered drivers that a device was removed. | |
315 | */ | |
316 | void i2o_driver_notify_device_remove_all(struct i2o_device *i2o_dev) | |
317 | { | |
318 | int i; | |
319 | struct i2o_driver *drv; | |
320 | ||
321 | for (i = 0; i < I2O_MAX_DRIVERS; i++) { | |
322 | drv = i2o_drivers[i]; | |
323 | ||
324 | if (drv) | |
325 | i2o_driver_notify_device_remove(drv, i2o_dev); | |
326 | } | |
327 | } | |
328 | ||
329 | /** | |
330 | * i2o_driver_init - initialize I2O drivers (OSMs) | |
331 | * | |
332 | * Registers the I2O bus and allocate memory for the array of OSMs. | |
333 | * | |
334 | * Returns 0 on success or negative error code on failure. | |
335 | */ | |
336 | int __init i2o_driver_init(void) | |
337 | { | |
338 | int rc = 0; | |
339 | ||
340 | spin_lock_init(&i2o_drivers_lock); | |
341 | ||
342 | if ((i2o_max_drivers < 2) || (i2o_max_drivers > 64) || | |
343 | ((i2o_max_drivers ^ (i2o_max_drivers - 1)) != | |
344 | (2 * i2o_max_drivers - 1))) { | |
f88e119c ML |
345 | osm_warn("max_drivers set to %d, but must be >=2 and <= 64 and " |
346 | "a power of 2\n", i2o_max_drivers); | |
1da177e4 LT |
347 | i2o_max_drivers = I2O_MAX_DRIVERS; |
348 | } | |
f88e119c | 349 | osm_info("max drivers = %d\n", i2o_max_drivers); |
1da177e4 LT |
350 | |
351 | i2o_drivers = | |
352 | kmalloc(i2o_max_drivers * sizeof(*i2o_drivers), GFP_KERNEL); | |
353 | if (!i2o_drivers) | |
354 | return -ENOMEM; | |
355 | ||
356 | memset(i2o_drivers, 0, i2o_max_drivers * sizeof(*i2o_drivers)); | |
357 | ||
358 | rc = bus_register(&i2o_bus_type); | |
359 | ||
360 | if (rc < 0) | |
361 | kfree(i2o_drivers); | |
362 | ||
363 | return rc; | |
364 | }; | |
365 | ||
366 | /** | |
367 | * i2o_driver_exit - clean up I2O drivers (OSMs) | |
368 | * | |
369 | * Unregisters the I2O bus and free driver array. | |
370 | */ | |
371 | void __exit i2o_driver_exit(void) | |
372 | { | |
373 | bus_unregister(&i2o_bus_type); | |
374 | kfree(i2o_drivers); | |
375 | }; | |
376 | ||
377 | EXPORT_SYMBOL(i2o_driver_register); | |
378 | EXPORT_SYMBOL(i2o_driver_unregister); | |
379 | EXPORT_SYMBOL(i2o_driver_notify_controller_add_all); | |
380 | EXPORT_SYMBOL(i2o_driver_notify_controller_remove_all); | |
381 | EXPORT_SYMBOL(i2o_driver_notify_device_add_all); | |
382 | EXPORT_SYMBOL(i2o_driver_notify_device_remove_all); |