4 * Copyright (C) 1999-2002 Red Hat Software
6 * Written by Alan Cox, Building Number Three Ltd
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.
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
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.
30 #include <linux/module.h>
31 #include <linux/i2o.h>
32 #include <linux/delay.h>
34 struct i2o_driver i2o_exec_driver;
36 static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind);
38 /* Module internal functions from other sources */
39 extern int i2o_device_parse_lct(struct i2o_controller *);
41 /* global wait list for POST WAIT */
42 static LIST_HEAD(i2o_exec_wait_list);
44 /* Wait struct needed for POST WAIT */
45 struct i2o_exec_wait {
46 wait_queue_head_t *wq; /* Pointer to Wait queue */
47 struct i2o_dma dma; /* DMA buffers to free on failure */
48 u32 tcntxt; /* transaction context from reply */
49 int complete; /* 1 if reply received otherwise 0 */
50 u32 m; /* message id */
51 struct i2o_message __iomem *msg; /* pointer to the reply message */
52 struct list_head list; /* node in global wait list */
55 /* Exec OSM class handling definition */
56 static struct i2o_class_id i2o_exec_class_id[] = {
57 {I2O_CLASS_EXECUTIVE},
62 * i2o_exec_wait_alloc - Allocate a i2o_exec_wait struct an initialize it
64 * Allocate the i2o_exec_wait struct and initialize the wait.
66 * Returns i2o_exec_wait pointer on success or negative error code on
69 static struct i2o_exec_wait *i2o_exec_wait_alloc(void)
71 struct i2o_exec_wait *wait;
73 wait = kmalloc(sizeof(*wait), GFP_KERNEL);
75 return ERR_PTR(-ENOMEM);
77 memset(wait, 0, sizeof(*wait));
79 INIT_LIST_HEAD(&wait->list);
85 * i2o_exec_wait_free - Free a i2o_exec_wait struct
86 * @i2o_exec_wait: I2O wait data which should be cleaned up
88 static void i2o_exec_wait_free(struct i2o_exec_wait *wait)
94 * i2o_msg_post_wait_mem - Post and wait a message with DMA buffers
97 * @timeout: time in seconds to wait
98 * @dma: i2o_dma struct of the DMA buffer to free on failure
100 * This API allows an OSM to post a message and then be told whether or
101 * not the system received a successful reply. If the message times out
102 * then the value '-ETIMEDOUT' is returned. This is a special case. In
103 * this situation the message may (should) complete at an indefinite time
104 * in the future. When it completes it will use the memory buffer
105 * attached to the request. If -ETIMEDOUT is returned then the memory
106 * buffer must not be freed. Instead the event completion will free them
107 * for you. In all other cases the buffer are your problem.
109 * Returns 0 on success or negative error code on failure.
111 int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
112 timeout, struct i2o_dma *dma)
114 DECLARE_WAIT_QUEUE_HEAD(wq);
115 struct i2o_exec_wait *wait;
116 static u32 tcntxt = 0x80000000;
117 struct i2o_message __iomem *msg = c->in_queue.virt + m;
120 wait = i2o_exec_wait_alloc();
124 if (tcntxt == 0xffffffff)
131 * Fill in the message initiator context and transaction context.
132 * We will only use transaction contexts >= 0x80000000 for POST WAIT,
133 * so we could find a POST WAIT reply easier in the reply handler.
135 writel(i2o_exec_driver.context, &msg->u.s.icntxt);
136 wait->tcntxt = tcntxt++;
137 writel(wait->tcntxt, &msg->u.s.tcntxt);
140 * Post the message to the controller. At some point later it will
141 * return. If we time out before it returns then complete will be zero.
145 if (!wait->complete) {
148 * we add elements add the head, because if a entry in the list
149 * will never be removed, we have to iterate over it every time
151 list_add(&wait->list, &i2o_exec_wait_list);
153 wait_event_interruptible_timeout(wq, wait->complete,
161 if (wait->complete) {
162 if (readl(&wait->msg->body[0]) >> 24)
163 rc = readl(&wait->msg->body[0]) & 0xff;
164 i2o_flush_reply(c, wait->m);
165 i2o_exec_wait_free(wait);
168 * We cannot remove it now. This is important. When it does
169 * terminate (which it must do if the controller has not
170 * died...) then it will otherwise scribble on stuff.
172 * FIXME: try abort message
184 * i2o_msg_post_wait_complete - Reply to a i2o_msg_post request from IOP
185 * @c: I2O controller which answers
187 * @msg: pointer to the I2O reply message
189 * This function is called in interrupt context only. If the reply reached
190 * before the timeout, the i2o_exec_wait struct is filled with the message
191 * and the task will be waked up. The task is now responsible for returning
192 * the message m back to the controller! If the message reaches us after
193 * the timeout clean up the i2o_exec_wait struct (including allocated
196 * Return 0 on success and if the message m should not be given back to the
197 * I2O controller, or >0 on success and if the message should be given back
198 * afterwords. Returns negative error code on failure. In this case the
199 * message must also be given back to the controller.
201 static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
202 struct i2o_message __iomem *msg)
204 struct i2o_exec_wait *wait, *tmp;
205 static spinlock_t lock;
209 spin_lock_init(&lock);
211 context = readl(&msg->u.s.tcntxt);
214 * We need to search through the i2o_exec_wait_list to see if the given
215 * message is still outstanding. If not, it means that the IOP took
216 * longer to respond to the message than we had allowed and timer has
217 * already expired. Not much we can do about that except log it for
218 * debug purposes, increase timeout, and recompile.
221 list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) {
222 if (wait->tcntxt == context) {
223 list_del(&wait->list);
232 wake_up_interruptible(wait->wq);
239 pr_debug("timedout reply received!\n");
240 i2o_dma_free(dev, &wait->dma);
241 i2o_exec_wait_free(wait);
253 pr_debug("i2o: Bogus reply in POST WAIT (tr-context: %08x)!\n",
260 * i2o_exec_probe - Called if a new I2O device (executive class) appears
261 * @dev: I2O device which should be probed
263 * Registers event notification for every event from Executive device. The
264 * return is always 0, because we want all devices of class Executive.
266 * Returns 0 on success.
268 static int i2o_exec_probe(struct device *dev)
270 struct i2o_device *i2o_dev = to_i2o_device(dev);
272 i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff);
274 i2o_dev->iop->exec = i2o_dev;
280 * i2o_exec_remove - Called on I2O device removal
281 * @dev: I2O device which was removed
283 * Unregisters event notification from Executive I2O device.
285 * Returns 0 on success.
287 static int i2o_exec_remove(struct device *dev)
289 i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
295 * i2o_exec_lct_modified - Called on LCT NOTIFY reply
296 * @c: I2O controller on which the LCT has modified
298 * This function handles asynchronus LCT NOTIFY replies. It parses the
299 * new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY
302 static void i2o_exec_lct_modified(struct i2o_controller *c)
304 if (i2o_device_parse_lct(c) == -EAGAIN)
305 i2o_exec_lct_notify(c, 0);
309 * i2o_exec_reply - I2O Executive reply handler
310 * @c: I2O controller from which the reply comes
312 * @msg: pointer to the I2O reply message
314 * This function is always called from interrupt context. If a POST WAIT
315 * reply was received, pass it to the complete function. If a LCT NOTIFY
316 * reply was received, a new event is created to handle the update.
318 * Returns 0 on success and if the reply should not be flushed or > 0
319 * on success and if the reply should be flushed. Returns negative error
320 * code on failure and if the reply should be flushed.
322 static int i2o_exec_reply(struct i2o_controller *c, u32 m,
323 struct i2o_message *msg)
325 if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) { // Fail bit is set
326 struct i2o_message __iomem *pmsg; /* preserved message */
329 pm = le32_to_cpu(msg->body[3]);
331 pmsg = i2o_msg_in_to_virt(c, pm);
333 i2o_report_status(KERN_INFO, "i2o_core", msg);
335 /* Release the preserved msg by resubmitting it as a NOP */
338 /* If reply to i2o_post_wait failed, return causes a timeout */
342 if (le32_to_cpu(msg->u.s.tcntxt) & 0x80000000)
343 return i2o_msg_post_wait_complete(c, m, msg);
345 if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
346 struct work_struct *work;
348 pr_debug("%s: LCT notify received\n", c->name);
350 work = kmalloc(sizeof(*work), GFP_ATOMIC);
354 INIT_WORK(work, (void (*)(void *))i2o_exec_lct_modified, c);
355 queue_work(i2o_exec_driver.event_queue, work);
360 * If this happens, we want to dump the message to the syslog so
361 * it can be sent back to the card manufacturer by the end user
362 * to aid in debugging.
365 printk(KERN_WARNING "%s: Unsolicited message reply sent to core!"
366 "Message dumped to syslog\n", c->name);
367 i2o_dump_message(msg);
373 * i2o_exec_event - Event handling function
374 * @evt: Event which occurs
376 * Handles events send by the Executive device. At the moment does not do
379 static void i2o_exec_event(struct i2o_event *evt)
381 printk(KERN_INFO "Event received from device: %d\n",
382 evt->i2o_dev->lct_data.tid);
387 * i2o_exec_lct_get - Get the IOP's Logical Configuration Table
388 * @c: I2O controller from which the LCT should be fetched
390 * Send a LCT NOTIFY request to the controller, and wait
391 * I2O_TIMEOUT_LCT_GET seconds until arrival of response. If the LCT is
392 * to large, retry it.
394 * Returns 0 on success or negative error code on failure.
396 int i2o_exec_lct_get(struct i2o_controller *c)
398 struct i2o_message __iomem *msg;
403 for (i = 1; i <= I2O_LCT_GET_TRIES; i++) {
404 m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
405 if (m == I2O_QUEUE_EMPTY)
408 writel(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6, &msg->u.head[0]);
409 writel(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 | ADAPTER_TID,
411 writel(0xffffffff, &msg->body[0]);
412 writel(0x00000000, &msg->body[1]);
413 writel(0xd0000000 | c->dlct.len, &msg->body[2]);
414 writel(c->dlct.phys, &msg->body[3]);
416 rc = i2o_msg_post_wait(c, m, I2O_TIMEOUT_LCT_GET);
420 rc = i2o_device_parse_lct(c);
429 * i2o_exec_lct_notify - Send a asynchronus LCT NOTIFY request
430 * @c: I2O controller to which the request should be send
431 * @change_ind: change indicator
433 * This function sends a LCT NOTIFY request to the I2O controller with
434 * the change indicator change_ind. If the change_ind == 0 the controller
435 * replies immediately after the request. If change_ind > 0 the reply is
436 * send after change indicator of the LCT is > change_ind.
438 static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind)
440 i2o_status_block *sb = c->status_block.virt;
442 struct i2o_message __iomem *msg;
447 if (i2o_dma_realloc(dev, &c->dlct, sb->expected_lct_size, GFP_KERNEL))
450 m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
451 if (m == I2O_QUEUE_EMPTY)
454 writel(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6, &msg->u.head[0]);
455 writel(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 | ADAPTER_TID,
457 writel(i2o_exec_driver.context, &msg->u.s.icntxt);
458 writel(0, &msg->u.s.tcntxt); /* FIXME */
459 writel(0xffffffff, &msg->body[0]);
460 writel(change_ind, &msg->body[1]);
461 writel(0xd0000000 | c->dlct.len, &msg->body[2]);
462 writel(c->dlct.phys, &msg->body[3]);
469 /* Exec OSM driver struct */
470 struct i2o_driver i2o_exec_driver = {
472 .reply = i2o_exec_reply,
473 .event = i2o_exec_event,
474 .classes = i2o_exec_class_id,
476 .probe = i2o_exec_probe,
477 .remove = i2o_exec_remove,
482 * i2o_exec_init - Registers the Exec OSM
484 * Registers the Exec OSM in the I2O core.
486 * Returns 0 on success or negative error code on failure.
488 int __init i2o_exec_init(void)
490 return i2o_driver_register(&i2o_exec_driver);
494 * i2o_exec_exit - Removes the Exec OSM
496 * Unregisters the Exec OSM from the I2O core.
498 void __exit i2o_exec_exit(void)
500 i2o_driver_unregister(&i2o_exec_driver);
503 EXPORT_SYMBOL(i2o_msg_post_wait_mem);
504 EXPORT_SYMBOL(i2o_exec_lct_get);