exec-osm.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586
  1. /*
  2. * Executive OSM
  3. *
  4. * Copyright (C) 1999-2002 Red Hat Software
  5. *
  6. * Written by Alan Cox, Building Number Three Ltd
  7. *
  8. * This program is free software; you can redistribute it and/or modify it
  9. * under the terms of the GNU General Public License as published by the
  10. * Free Software Foundation; either version 2 of the License, or (at your
  11. * option) any later version.
  12. *
  13. * A lot of the I2O message side code from this is taken from the Red
  14. * Creek RCPCI45 adapter driver by Red Creek Communications
  15. *
  16. * Fixes/additions:
  17. * Philipp Rumpf
  18. * Juha Sievänen <Juha.Sievanen@cs.Helsinki.FI>
  19. * Auvo Häkkinen <Auvo.Hakkinen@cs.Helsinki.FI>
  20. * Deepak Saxena <deepak@plexity.net>
  21. * Boji T Kannanthanam <boji.t.kannanthanam@intel.com>
  22. * Alan Cox <alan@redhat.com>:
  23. * Ported to Linux 2.5.
  24. * Markus Lidel <Markus.Lidel@shadowconnect.com>:
  25. * Minor fixes for 2.6.
  26. * Markus Lidel <Markus.Lidel@shadowconnect.com>:
  27. * Support for sysfs included.
  28. */
  29. #include <linux/module.h>
  30. #include <linux/i2o.h>
  31. #include <linux/delay.h>
  32. #include <linux/workqueue.h>
  33. #include <linux/string.h>
  34. #include <linux/slab.h>
  35. #include <linux/sched.h> /* wait_event_interruptible_timeout() needs this */
  36. #include <asm/param.h> /* HZ */
  37. #include "core.h"
  38. #define OSM_NAME "exec-osm"
  39. struct i2o_driver i2o_exec_driver;
  40. static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind);
  41. /* global wait list for POST WAIT */
  42. static LIST_HEAD(i2o_exec_wait_list);
  43. /* Wait struct needed for POST WAIT */
  44. struct i2o_exec_wait {
  45. wait_queue_head_t *wq; /* Pointer to Wait queue */
  46. struct i2o_dma dma; /* DMA buffers to free on failure */
  47. u32 tcntxt; /* transaction context from reply */
  48. int complete; /* 1 if reply received otherwise 0 */
  49. u32 m; /* message id */
  50. struct i2o_message *msg; /* pointer to the reply message */
  51. struct list_head list; /* node in global wait list */
  52. };
  53. /* Work struct needed to handle LCT NOTIFY replies */
  54. struct i2o_exec_lct_notify_work {
  55. struct work_struct work; /* work struct */
  56. struct i2o_controller *c; /* controller on which the LCT NOTIFY
  57. was received */
  58. };
  59. /* Exec OSM class handling definition */
  60. static struct i2o_class_id i2o_exec_class_id[] = {
  61. {I2O_CLASS_EXECUTIVE},
  62. {I2O_CLASS_END}
  63. };
  64. /**
  65. * i2o_exec_wait_alloc - Allocate a i2o_exec_wait struct an initialize it
  66. *
  67. * Allocate the i2o_exec_wait struct and initialize the wait.
  68. *
  69. * Returns i2o_exec_wait pointer on success or negative error code on
  70. * failure.
  71. */
  72. static struct i2o_exec_wait *i2o_exec_wait_alloc(void)
  73. {
  74. struct i2o_exec_wait *wait;
  75. wait = kzalloc(sizeof(*wait), GFP_KERNEL);
  76. if (!wait)
  77. return NULL;
  78. INIT_LIST_HEAD(&wait->list);
  79. return wait;
  80. };
  81. /**
  82. * i2o_exec_wait_free - Free a i2o_exec_wait struct
  83. * @i2o_exec_wait: I2O wait data which should be cleaned up
  84. */
  85. static void i2o_exec_wait_free(struct i2o_exec_wait *wait)
  86. {
  87. kfree(wait);
  88. };
  89. /**
  90. * i2o_msg_post_wait_mem - Post and wait a message with DMA buffers
  91. * @c: controller
  92. * @m: message to post
  93. * @timeout: time in seconds to wait
  94. * @dma: i2o_dma struct of the DMA buffer to free on failure
  95. *
  96. * This API allows an OSM to post a message and then be told whether or
  97. * not the system received a successful reply. If the message times out
  98. * then the value '-ETIMEDOUT' is returned. This is a special case. In
  99. * this situation the message may (should) complete at an indefinite time
  100. * in the future. When it completes it will use the memory buffer
  101. * attached to the request. If -ETIMEDOUT is returned then the memory
  102. * buffer must not be freed. Instead the event completion will free them
  103. * for you. In all other cases the buffer are your problem.
  104. *
  105. * Returns 0 on success, negative error code on timeout or positive error
  106. * code from reply.
  107. */
  108. int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg,
  109. unsigned long timeout, struct i2o_dma *dma)
  110. {
  111. DECLARE_WAIT_QUEUE_HEAD(wq);
  112. struct i2o_exec_wait *wait;
  113. static u32 tcntxt = 0x80000000;
  114. int rc = 0;
  115. wait = i2o_exec_wait_alloc();
  116. if (!wait)
  117. return -ENOMEM;
  118. if (tcntxt == 0xffffffff)
  119. tcntxt = 0x80000000;
  120. if (dma)
  121. wait->dma = *dma;
  122. /*
  123. * Fill in the message initiator context and transaction context.
  124. * We will only use transaction contexts >= 0x80000000 for POST WAIT,
  125. * so we could find a POST WAIT reply easier in the reply handler.
  126. */
  127. msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
  128. wait->tcntxt = tcntxt++;
  129. msg->u.s.tcntxt = cpu_to_le32(wait->tcntxt);
  130. /*
  131. * Post the message to the controller. At some point later it will
  132. * return. If we time out before it returns then complete will be zero.
  133. */
  134. i2o_msg_post(c, msg);
  135. if (!wait->complete) {
  136. wait->wq = &wq;
  137. /*
  138. * we add elements add the head, because if a entry in the list
  139. * will never be removed, we have to iterate over it every time
  140. */
  141. list_add(&wait->list, &i2o_exec_wait_list);
  142. wait_event_interruptible_timeout(wq, wait->complete,
  143. timeout * HZ);
  144. wait->wq = NULL;
  145. }
  146. barrier();
  147. if (wait->complete) {
  148. rc = le32_to_cpu(wait->msg->body[0]) >> 24;
  149. i2o_flush_reply(c, wait->m);
  150. i2o_exec_wait_free(wait);
  151. } else {
  152. /*
  153. * We cannot remove it now. This is important. When it does
  154. * terminate (which it must do if the controller has not
  155. * died...) then it will otherwise scribble on stuff.
  156. *
  157. * FIXME: try abort message
  158. */
  159. if (dma)
  160. dma->virt = NULL;
  161. rc = -ETIMEDOUT;
  162. }
  163. return rc;
  164. };
  165. /**
  166. * i2o_msg_post_wait_complete - Reply to a i2o_msg_post request from IOP
  167. * @c: I2O controller which answers
  168. * @m: message id
  169. * @msg: pointer to the I2O reply message
  170. * @context: transaction context of request
  171. *
  172. * This function is called in interrupt context only. If the reply reached
  173. * before the timeout, the i2o_exec_wait struct is filled with the message
  174. * and the task will be waked up. The task is now responsible for returning
  175. * the message m back to the controller! If the message reaches us after
  176. * the timeout clean up the i2o_exec_wait struct (including allocated
  177. * DMA buffer).
  178. *
  179. * Return 0 on success and if the message m should not be given back to the
  180. * I2O controller, or >0 on success and if the message should be given back
  181. * afterwords. Returns negative error code on failure. In this case the
  182. * message must also be given back to the controller.
  183. */
  184. static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
  185. struct i2o_message *msg, u32 context)
  186. {
  187. struct i2o_exec_wait *wait, *tmp;
  188. unsigned long flags;
  189. static spinlock_t lock = SPIN_LOCK_UNLOCKED;
  190. int rc = 1;
  191. /*
  192. * We need to search through the i2o_exec_wait_list to see if the given
  193. * message is still outstanding. If not, it means that the IOP took
  194. * longer to respond to the message than we had allowed and timer has
  195. * already expired. Not much we can do about that except log it for
  196. * debug purposes, increase timeout, and recompile.
  197. */
  198. spin_lock_irqsave(&lock, flags);
  199. list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) {
  200. if (wait->tcntxt == context) {
  201. list_del(&wait->list);
  202. spin_unlock_irqrestore(&lock, flags);
  203. wait->m = m;
  204. wait->msg = msg;
  205. wait->complete = 1;
  206. barrier();
  207. if (wait->wq) {
  208. wake_up_interruptible(wait->wq);
  209. rc = 0;
  210. } else {
  211. struct device *dev;
  212. dev = &c->pdev->dev;
  213. pr_debug("%s: timedout reply received!\n",
  214. c->name);
  215. i2o_dma_free(dev, &wait->dma);
  216. i2o_exec_wait_free(wait);
  217. rc = -1;
  218. }
  219. return rc;
  220. }
  221. }
  222. spin_unlock_irqrestore(&lock, flags);
  223. osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
  224. context);
  225. return -1;
  226. };
  227. /**
  228. * i2o_exec_show_vendor_id - Displays Vendor ID of controller
  229. * @d: device of which the Vendor ID should be displayed
  230. * @buf: buffer into which the Vendor ID should be printed
  231. *
  232. * Returns number of bytes printed into buffer.
  233. */
  234. static ssize_t i2o_exec_show_vendor_id(struct device *d,
  235. struct device_attribute *attr, char *buf)
  236. {
  237. struct i2o_device *dev = to_i2o_device(d);
  238. u16 id;
  239. if (!i2o_parm_field_get(dev, 0x0000, 0, &id, 2)) {
  240. sprintf(buf, "0x%04x", le16_to_cpu(id));
  241. return strlen(buf) + 1;
  242. }
  243. return 0;
  244. };
  245. /**
  246. * i2o_exec_show_product_id - Displays Product ID of controller
  247. * @d: device of which the Product ID should be displayed
  248. * @buf: buffer into which the Product ID should be printed
  249. *
  250. * Returns number of bytes printed into buffer.
  251. */
  252. static ssize_t i2o_exec_show_product_id(struct device *d,
  253. struct device_attribute *attr,
  254. char *buf)
  255. {
  256. struct i2o_device *dev = to_i2o_device(d);
  257. u16 id;
  258. if (!i2o_parm_field_get(dev, 0x0000, 1, &id, 2)) {
  259. sprintf(buf, "0x%04x", le16_to_cpu(id));
  260. return strlen(buf) + 1;
  261. }
  262. return 0;
  263. };
  264. /* Exec-OSM device attributes */
  265. static DEVICE_ATTR(vendor_id, S_IRUGO, i2o_exec_show_vendor_id, NULL);
  266. static DEVICE_ATTR(product_id, S_IRUGO, i2o_exec_show_product_id, NULL);
  267. /**
  268. * i2o_exec_probe - Called if a new I2O device (executive class) appears
  269. * @dev: I2O device which should be probed
  270. *
  271. * Registers event notification for every event from Executive device. The
  272. * return is always 0, because we want all devices of class Executive.
  273. *
  274. * Returns 0 on success.
  275. */
  276. static int i2o_exec_probe(struct device *dev)
  277. {
  278. struct i2o_device *i2o_dev = to_i2o_device(dev);
  279. struct i2o_controller *c = i2o_dev->iop;
  280. i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff);
  281. c->exec = i2o_dev;
  282. i2o_exec_lct_notify(c, c->lct->change_ind + 1);
  283. device_create_file(dev, &dev_attr_vendor_id);
  284. device_create_file(dev, &dev_attr_product_id);
  285. return 0;
  286. };
  287. /**
  288. * i2o_exec_remove - Called on I2O device removal
  289. * @dev: I2O device which was removed
  290. *
  291. * Unregisters event notification from Executive I2O device.
  292. *
  293. * Returns 0 on success.
  294. */
  295. static int i2o_exec_remove(struct device *dev)
  296. {
  297. device_remove_file(dev, &dev_attr_product_id);
  298. device_remove_file(dev, &dev_attr_vendor_id);
  299. i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
  300. return 0;
  301. };
  302. /**
  303. * i2o_exec_lct_modified - Called on LCT NOTIFY reply
  304. * @c: I2O controller on which the LCT has modified
  305. *
  306. * This function handles asynchronus LCT NOTIFY replies. It parses the
  307. * new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY
  308. * again, otherwise send LCT NOTIFY to get informed on next LCT change.
  309. */
  310. static void i2o_exec_lct_modified(struct i2o_exec_lct_notify_work *work)
  311. {
  312. u32 change_ind = 0;
  313. struct i2o_controller *c = work->c;
  314. kfree(work);
  315. if (i2o_device_parse_lct(c) != -EAGAIN)
  316. change_ind = c->lct->change_ind + 1;
  317. #ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES
  318. i2o_exec_lct_notify(c, change_ind);
  319. #endif
  320. };
  321. /**
  322. * i2o_exec_reply - I2O Executive reply handler
  323. * @c: I2O controller from which the reply comes
  324. * @m: message id
  325. * @msg: pointer to the I2O reply message
  326. *
  327. * This function is always called from interrupt context. If a POST WAIT
  328. * reply was received, pass it to the complete function. If a LCT NOTIFY
  329. * reply was received, a new event is created to handle the update.
  330. *
  331. * Returns 0 on success and if the reply should not be flushed or > 0
  332. * on success and if the reply should be flushed. Returns negative error
  333. * code on failure and if the reply should be flushed.
  334. */
  335. static int i2o_exec_reply(struct i2o_controller *c, u32 m,
  336. struct i2o_message *msg)
  337. {
  338. u32 context;
  339. if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) {
  340. struct i2o_message __iomem *pmsg;
  341. u32 pm;
  342. /*
  343. * If Fail bit is set we must take the transaction context of
  344. * the preserved message to find the right request again.
  345. */
  346. pm = le32_to_cpu(msg->body[3]);
  347. pmsg = i2o_msg_in_to_virt(c, pm);
  348. context = readl(&pmsg->u.s.tcntxt);
  349. i2o_report_status(KERN_INFO, "i2o_core", msg);
  350. /* Release the preserved msg */
  351. i2o_msg_nop_mfa(c, pm);
  352. } else
  353. context = le32_to_cpu(msg->u.s.tcntxt);
  354. if (context & 0x80000000)
  355. return i2o_msg_post_wait_complete(c, m, msg, context);
  356. if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
  357. struct i2o_exec_lct_notify_work *work;
  358. pr_debug("%s: LCT notify received\n", c->name);
  359. work = kmalloc(sizeof(*work), GFP_ATOMIC);
  360. if (!work)
  361. return -ENOMEM;
  362. work->c = c;
  363. INIT_WORK(&work->work, (void (*)(void *))i2o_exec_lct_modified,
  364. work);
  365. queue_work(i2o_exec_driver.event_queue, &work->work);
  366. return 1;
  367. }
  368. /*
  369. * If this happens, we want to dump the message to the syslog so
  370. * it can be sent back to the card manufacturer by the end user
  371. * to aid in debugging.
  372. *
  373. */
  374. printk(KERN_WARNING "%s: Unsolicited message reply sent to core!"
  375. "Message dumped to syslog\n", c->name);
  376. i2o_dump_message(msg);
  377. return -EFAULT;
  378. }
  379. /**
  380. * i2o_exec_event - Event handling function
  381. * @evt: Event which occurs
  382. *
  383. * Handles events send by the Executive device. At the moment does not do
  384. * anything useful.
  385. */
  386. static void i2o_exec_event(struct i2o_event *evt)
  387. {
  388. if (likely(evt->i2o_dev))
  389. osm_debug("Event received from device: %d\n",
  390. evt->i2o_dev->lct_data.tid);
  391. kfree(evt);
  392. };
  393. /**
  394. * i2o_exec_lct_get - Get the IOP's Logical Configuration Table
  395. * @c: I2O controller from which the LCT should be fetched
  396. *
  397. * Send a LCT NOTIFY request to the controller, and wait
  398. * I2O_TIMEOUT_LCT_GET seconds until arrival of response. If the LCT is
  399. * to large, retry it.
  400. *
  401. * Returns 0 on success or negative error code on failure.
  402. */
  403. int i2o_exec_lct_get(struct i2o_controller *c)
  404. {
  405. struct i2o_message *msg;
  406. int i = 0;
  407. int rc = -EAGAIN;
  408. for (i = 1; i <= I2O_LCT_GET_TRIES; i++) {
  409. msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
  410. if (IS_ERR(msg))
  411. return PTR_ERR(msg);
  412. msg->u.head[0] =
  413. cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
  414. msg->u.head[1] =
  415. cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
  416. ADAPTER_TID);
  417. msg->body[0] = cpu_to_le32(0xffffffff);
  418. msg->body[1] = cpu_to_le32(0x00000000);
  419. msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
  420. msg->body[3] = cpu_to_le32(c->dlct.phys);
  421. rc = i2o_msg_post_wait(c, msg, I2O_TIMEOUT_LCT_GET);
  422. if (rc < 0)
  423. break;
  424. rc = i2o_device_parse_lct(c);
  425. if (rc != -EAGAIN)
  426. break;
  427. }
  428. return rc;
  429. }
  430. /**
  431. * i2o_exec_lct_notify - Send a asynchronus LCT NOTIFY request
  432. * @c: I2O controller to which the request should be send
  433. * @change_ind: change indicator
  434. *
  435. * This function sends a LCT NOTIFY request to the I2O controller with
  436. * the change indicator change_ind. If the change_ind == 0 the controller
  437. * replies immediately after the request. If change_ind > 0 the reply is
  438. * send after change indicator of the LCT is > change_ind.
  439. */
  440. static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind)
  441. {
  442. i2o_status_block *sb = c->status_block.virt;
  443. struct device *dev;
  444. struct i2o_message *msg;
  445. dev = &c->pdev->dev;
  446. if (i2o_dma_realloc
  447. (dev, &c->dlct, le32_to_cpu(sb->expected_lct_size), GFP_KERNEL))
  448. return -ENOMEM;
  449. msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
  450. if (IS_ERR(msg))
  451. return PTR_ERR(msg);
  452. msg->u.head[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
  453. msg->u.head[1] = cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
  454. ADAPTER_TID);
  455. msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
  456. msg->u.s.tcntxt = cpu_to_le32(0x00000000);
  457. msg->body[0] = cpu_to_le32(0xffffffff);
  458. msg->body[1] = cpu_to_le32(change_ind);
  459. msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
  460. msg->body[3] = cpu_to_le32(c->dlct.phys);
  461. i2o_msg_post(c, msg);
  462. return 0;
  463. };
  464. /* Exec OSM driver struct */
  465. struct i2o_driver i2o_exec_driver = {
  466. .name = OSM_NAME,
  467. .reply = i2o_exec_reply,
  468. .event = i2o_exec_event,
  469. .classes = i2o_exec_class_id,
  470. .driver = {
  471. .probe = i2o_exec_probe,
  472. .remove = i2o_exec_remove,
  473. },
  474. };
  475. /**
  476. * i2o_exec_init - Registers the Exec OSM
  477. *
  478. * Registers the Exec OSM in the I2O core.
  479. *
  480. * Returns 0 on success or negative error code on failure.
  481. */
  482. int __init i2o_exec_init(void)
  483. {
  484. return i2o_driver_register(&i2o_exec_driver);
  485. };
  486. /**
  487. * i2o_exec_exit - Removes the Exec OSM
  488. *
  489. * Unregisters the Exec OSM from the I2O core.
  490. */
  491. void __exit i2o_exec_exit(void)
  492. {
  493. i2o_driver_unregister(&i2o_exec_driver);
  494. };
  495. EXPORT_SYMBOL(i2o_msg_post_wait_mem);
  496. EXPORT_SYMBOL(i2o_exec_lct_get);