git.oblomov.eu Git - linux-2.6/blob - drivers/message/i2o/driver.c

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