2 * Functions to handle I2O drivers (OSMs) and I2O bus type for sysfs
4 * Copyright (C) 2004 Markus Lidel <Markus.Lidel@shadowconnect.com>
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.
12 * Markus Lidel <Markus.Lidel@shadowconnect.com>
16 #include <linux/device.h>
17 #include <linux/module.h>
18 #include <linux/rwsem.h>
19 #include <linux/i2o.h>
21 #define OSM_NAME "i2o"
23 /* max_drivers - Maximum I2O drivers (OSMs) which could be registered */
24 unsigned int i2o_max_drivers
= I2O_MAX_DRIVERS
;
25 module_param_named(max_drivers
, i2o_max_drivers
, uint
, 0);
26 MODULE_PARM_DESC(max_drivers
, "maximum number of OSM's to support");
28 /* I2O drivers lock and array */
29 static spinlock_t i2o_drivers_lock
;
30 static struct i2o_driver
**i2o_drivers
;
33 * i2o_bus_match - Tell if a I2O device class id match the class ids of
34 * the I2O driver (OSM)
36 * @dev: device which should be verified
37 * @drv: the driver to match against
39 * Used by the bus to check if the driver wants to handle the device.
41 * Returns 1 if the class ids of the driver match the class id of the
42 * device, otherwise 0.
44 static int i2o_bus_match(struct device
*dev
, struct device_driver
*drv
)
46 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
47 struct i2o_driver
*i2o_drv
= to_i2o_driver(drv
);
48 struct i2o_class_id
*ids
= i2o_drv
->classes
;
51 while (ids
->class_id
!= I2O_CLASS_END
) {
52 if (ids
->class_id
== i2o_dev
->lct_data
.class_id
)
60 struct bus_type i2o_bus_type
= {
62 .match
= i2o_bus_match
,
66 * i2o_driver_register - Register a I2O driver (OSM) in the I2O core
67 * @drv: I2O driver which should be registered
69 * Registers the OSM drv in the I2O core and creates an event queues if
72 * Returns 0 on success or negative error code on failure.
74 int i2o_driver_register(struct i2o_driver
*drv
)
76 struct i2o_controller
*c
;
81 osm_debug("Register driver %s\n", drv
->name
);
84 drv
->event_queue
= create_workqueue(drv
->name
);
85 if (!drv
->event_queue
) {
86 osm_err("Could not initialize event queue for driver "
90 osm_debug("Event queue initialized for driver %s\n", drv
->name
);
92 drv
->event_queue
= NULL
;
94 drv
->driver
.name
= drv
->name
;
95 drv
->driver
.bus
= &i2o_bus_type
;
97 spin_lock_irqsave(&i2o_drivers_lock
, flags
);
99 for (i
= 0; i2o_drivers
[i
]; i
++)
100 if (i
>= i2o_max_drivers
) {
101 osm_err("too many drivers registered, increase "
103 spin_unlock_irqrestore(&i2o_drivers_lock
, flags
);
108 i2o_drivers
[i
] = drv
;
110 spin_unlock_irqrestore(&i2o_drivers_lock
, flags
);
112 osm_debug("driver %s gets context id %d\n", drv
->name
, drv
->context
);
114 list_for_each_entry(c
, &i2o_controllers
, list
) {
115 struct i2o_device
*i2o_dev
;
117 i2o_driver_notify_controller_add(drv
, c
);
118 list_for_each_entry(i2o_dev
, &c
->devices
, list
)
119 i2o_driver_notify_device_add(drv
, i2o_dev
);
123 rc
= driver_register(&drv
->driver
);
125 destroy_workqueue(drv
->event_queue
);
131 * i2o_driver_unregister - Unregister a I2O driver (OSM) from the I2O core
132 * @drv: I2O driver which should be unregistered
134 * Unregisters the OSM drv from the I2O core and cleanup event queues if
137 void i2o_driver_unregister(struct i2o_driver
*drv
)
139 struct i2o_controller
*c
;
142 osm_debug("unregister driver %s\n", drv
->name
);
144 driver_unregister(&drv
->driver
);
146 list_for_each_entry(c
, &i2o_controllers
, list
) {
147 struct i2o_device
*i2o_dev
;
149 list_for_each_entry(i2o_dev
, &c
->devices
, list
)
150 i2o_driver_notify_device_remove(drv
, i2o_dev
);
152 i2o_driver_notify_controller_remove(drv
, c
);
155 spin_lock_irqsave(&i2o_drivers_lock
, flags
);
156 i2o_drivers
[drv
->context
] = NULL
;
157 spin_unlock_irqrestore(&i2o_drivers_lock
, flags
);
159 if (drv
->event_queue
) {
160 destroy_workqueue(drv
->event_queue
);
161 drv
->event_queue
= NULL
;
162 osm_debug("event queue removed for %s\n", drv
->name
);
167 * i2o_driver_dispatch - dispatch an I2O reply message
168 * @c: I2O controller of the message
169 * @m: I2O message number
170 * @msg: I2O message to be delivered
172 * The reply is delivered to the driver from which the original message
173 * was. This function is only called from interrupt context.
175 * Returns 0 on success and the message should not be flushed. Returns > 0
176 * on success and if the message should be flushed afterwords. Returns
177 * negative error code on failure (the message will be flushed too).
179 int i2o_driver_dispatch(struct i2o_controller
*c
, u32 m
)
181 struct i2o_driver
*drv
;
182 struct i2o_message __iomem
*msg
= i2o_msg_out_to_virt(c
, m
);
183 u32 context
= readl(&msg
->u
.s
.icntxt
);
185 if (unlikely(context
>= i2o_max_drivers
)) {
186 osm_warn("%s: Spurious reply to unknown driver %d\n", c
->name
,
191 spin_lock(&i2o_drivers_lock
);
192 drv
= i2o_drivers
[context
];
193 spin_unlock(&i2o_drivers_lock
);
195 if (unlikely(!drv
)) {
196 osm_warn("%s: Spurious reply to unknown driver %d\n", c
->name
,
201 if ((readl(&msg
->u
.head
[1]) >> 24) == I2O_CMD_UTIL_EVT_REGISTER
) {
202 struct i2o_device
*dev
, *tmp
;
203 struct i2o_event
*evt
;
205 u16 tid
= readl(&msg
->u
.head
[1]) & 0xfff;
207 osm_debug("event received from device %d\n", tid
);
212 /* cut of header from message size (in 32-bit words) */
213 size
= (readl(&msg
->u
.head
[0]) >> 16) - 5;
215 evt
= kmalloc(size
* 4 + sizeof(*evt
), GFP_ATOMIC
| __GFP_ZERO
);
220 evt
->tcntxt
= readl(&msg
->u
.s
.tcntxt
);
221 evt
->event_indicator
= readl(&msg
->body
[0]);
222 memcpy_fromio(&evt
->tcntxt
, &msg
->u
.s
.tcntxt
, size
* 4);
224 list_for_each_entry_safe(dev
, tmp
, &c
->devices
, list
)
225 if (dev
->lct_data
.tid
== tid
) {
230 INIT_WORK(&evt
->work
, (void (*)(void *))drv
->event
, evt
);
231 queue_work(drv
->event_queue
, &evt
->work
);
235 if (unlikely(!drv
->reply
)) {
236 osm_debug("%s: Reply to driver %s, but no reply function"
237 " defined!\n", c
->name
, drv
->name
);
241 return drv
->reply(c
, m
, msg
);
245 * i2o_driver_notify_controller_add_all - Send notify of added controller
248 * Send notifications to all registered drivers that a new controller was
251 void i2o_driver_notify_controller_add_all(struct i2o_controller
*c
)
254 struct i2o_driver
*drv
;
256 for (i
= 0; i
< I2O_MAX_DRIVERS
; i
++) {
257 drv
= i2o_drivers
[i
];
260 i2o_driver_notify_controller_add(drv
, c
);
265 * i2o_driver_notify_controller_remove_all - Send notify of removed
266 * controller to all I2O drivers
268 * Send notifications to all registered drivers that a controller was
271 void i2o_driver_notify_controller_remove_all(struct i2o_controller
*c
)
274 struct i2o_driver
*drv
;
276 for (i
= 0; i
< I2O_MAX_DRIVERS
; i
++) {
277 drv
= i2o_drivers
[i
];
280 i2o_driver_notify_controller_remove(drv
, c
);
285 * i2o_driver_notify_device_add_all - Send notify of added device to all
288 * Send notifications to all registered drivers that a device was added.
290 void i2o_driver_notify_device_add_all(struct i2o_device
*i2o_dev
)
293 struct i2o_driver
*drv
;
295 for (i
= 0; i
< I2O_MAX_DRIVERS
; i
++) {
296 drv
= i2o_drivers
[i
];
299 i2o_driver_notify_device_add(drv
, i2o_dev
);
304 * i2o_driver_notify_device_remove_all - Send notify of removed device to
307 * Send notifications to all registered drivers that a device was removed.
309 void i2o_driver_notify_device_remove_all(struct i2o_device
*i2o_dev
)
312 struct i2o_driver
*drv
;
314 for (i
= 0; i
< I2O_MAX_DRIVERS
; i
++) {
315 drv
= i2o_drivers
[i
];
318 i2o_driver_notify_device_remove(drv
, i2o_dev
);
323 * i2o_driver_init - initialize I2O drivers (OSMs)
325 * Registers the I2O bus and allocate memory for the array of OSMs.
327 * Returns 0 on success or negative error code on failure.
329 int __init
i2o_driver_init(void)
333 spin_lock_init(&i2o_drivers_lock
);
335 if ((i2o_max_drivers
< 2) || (i2o_max_drivers
> 64) ||
336 ((i2o_max_drivers
^ (i2o_max_drivers
- 1)) !=
337 (2 * i2o_max_drivers
- 1))) {
338 osm_warn("max_drivers set to %d, but must be >=2 and <= 64 and "
339 "a power of 2\n", i2o_max_drivers
);
340 i2o_max_drivers
= I2O_MAX_DRIVERS
;
342 osm_info("max drivers = %d\n", i2o_max_drivers
);
345 kmalloc(i2o_max_drivers
* sizeof(*i2o_drivers
), GFP_KERNEL
);
349 memset(i2o_drivers
, 0, i2o_max_drivers
* sizeof(*i2o_drivers
));
351 rc
= bus_register(&i2o_bus_type
);
360 * i2o_driver_exit - clean up I2O drivers (OSMs)
362 * Unregisters the I2O bus and free driver array.
364 void __exit
i2o_driver_exit(void)
366 bus_unregister(&i2o_bus_type
);
370 EXPORT_SYMBOL(i2o_driver_register
);
371 EXPORT_SYMBOL(i2o_driver_unregister
);
372 EXPORT_SYMBOL(i2o_driver_notify_controller_add_all
);
373 EXPORT_SYMBOL(i2o_driver_notify_controller_remove_all
);
374 EXPORT_SYMBOL(i2o_driver_notify_device_add_all
);
375 EXPORT_SYMBOL(i2o_driver_notify_device_remove_all
);