driver.c 9.4 KB

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