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 #define OSM_NAME "exec-osm"
36 struct i2o_driver i2o_exec_driver
;
38 static int i2o_exec_lct_notify(struct i2o_controller
*c
, u32 change_ind
);
40 /* Module internal functions from other sources */
41 extern int i2o_device_parse_lct(struct i2o_controller
*);
43 /* global wait list for POST WAIT */
44 static LIST_HEAD(i2o_exec_wait_list
);
46 /* Wait struct needed for POST WAIT */
47 struct i2o_exec_wait
{
48 wait_queue_head_t
*wq
; /* Pointer to Wait queue */
49 struct i2o_dma dma
; /* DMA buffers to free on failure */
50 u32 tcntxt
; /* transaction context from reply */
51 int complete
; /* 1 if reply received otherwise 0 */
52 u32 m
; /* message id */
53 struct i2o_message __iomem
*msg
; /* pointer to the reply message */
54 struct list_head list
; /* node in global wait list */
57 /* Exec OSM class handling definition */
58 static struct i2o_class_id i2o_exec_class_id
[] = {
59 {I2O_CLASS_EXECUTIVE
},
64 * i2o_exec_wait_alloc - Allocate a i2o_exec_wait struct an initialize it
66 * Allocate the i2o_exec_wait struct and initialize the wait.
68 * Returns i2o_exec_wait pointer on success or negative error code on
71 static struct i2o_exec_wait
*i2o_exec_wait_alloc(void)
73 struct i2o_exec_wait
*wait
;
75 wait
= kmalloc(sizeof(*wait
), GFP_KERNEL
);
77 return ERR_PTR(-ENOMEM
);
79 memset(wait
, 0, sizeof(*wait
));
81 INIT_LIST_HEAD(&wait
->list
);
87 * i2o_exec_wait_free - Free a i2o_exec_wait struct
88 * @i2o_exec_wait: I2O wait data which should be cleaned up
90 static void i2o_exec_wait_free(struct i2o_exec_wait
*wait
)
96 * i2o_msg_post_wait_mem - Post and wait a message with DMA buffers
99 * @timeout: time in seconds to wait
100 * @dma: i2o_dma struct of the DMA buffer to free on failure
102 * This API allows an OSM to post a message and then be told whether or
103 * not the system received a successful reply. If the message times out
104 * then the value '-ETIMEDOUT' is returned. This is a special case. In
105 * this situation the message may (should) complete at an indefinite time
106 * in the future. When it completes it will use the memory buffer
107 * attached to the request. If -ETIMEDOUT is returned then the memory
108 * buffer must not be freed. Instead the event completion will free them
109 * for you. In all other cases the buffer are your problem.
111 * Returns 0 on success, negative error code on timeout or positive error
114 int i2o_msg_post_wait_mem(struct i2o_controller
*c
, u32 m
, unsigned long
115 timeout
, struct i2o_dma
*dma
)
117 DECLARE_WAIT_QUEUE_HEAD(wq
);
118 struct i2o_exec_wait
*wait
;
119 static u32 tcntxt
= 0x80000000;
120 struct i2o_message __iomem
*msg
= i2o_msg_in_to_virt(c
, m
);
123 wait
= i2o_exec_wait_alloc();
127 if (tcntxt
== 0xffffffff)
134 * Fill in the message initiator context and transaction context.
135 * We will only use transaction contexts >= 0x80000000 for POST WAIT,
136 * so we could find a POST WAIT reply easier in the reply handler.
138 writel(i2o_exec_driver
.context
, &msg
->u
.s
.icntxt
);
139 wait
->tcntxt
= tcntxt
++;
140 writel(wait
->tcntxt
, &msg
->u
.s
.tcntxt
);
143 * Post the message to the controller. At some point later it will
144 * return. If we time out before it returns then complete will be zero.
148 if (!wait
->complete
) {
151 * we add elements add the head, because if a entry in the list
152 * will never be removed, we have to iterate over it every time
154 list_add(&wait
->list
, &i2o_exec_wait_list
);
156 wait_event_interruptible_timeout(wq
, wait
->complete
,
164 if (wait
->complete
) {
165 rc
= readl(&wait
->msg
->body
[0]) >> 24;
166 i2o_flush_reply(c
, wait
->m
);
167 i2o_exec_wait_free(wait
);
170 * We cannot remove it now. This is important. When it does
171 * terminate (which it must do if the controller has not
172 * died...) then it will otherwise scribble on stuff.
174 * FIXME: try abort message
186 * i2o_msg_post_wait_complete - Reply to a i2o_msg_post request from IOP
187 * @c: I2O controller which answers
189 * @msg: pointer to the I2O reply message
190 * @context: transaction context of request
192 * This function is called in interrupt context only. If the reply reached
193 * before the timeout, the i2o_exec_wait struct is filled with the message
194 * and the task will be waked up. The task is now responsible for returning
195 * the message m back to the controller! If the message reaches us after
196 * the timeout clean up the i2o_exec_wait struct (including allocated
199 * Return 0 on success and if the message m should not be given back to the
200 * I2O controller, or >0 on success and if the message should be given back
201 * afterwords. Returns negative error code on failure. In this case the
202 * message must also be given back to the controller.
204 static int i2o_msg_post_wait_complete(struct i2o_controller
*c
, u32 m
,
205 struct i2o_message __iomem
*msg
,
208 struct i2o_exec_wait
*wait
, *tmp
;
209 static spinlock_t lock
= SPIN_LOCK_UNLOCKED
;
213 * We need to search through the i2o_exec_wait_list to see if the given
214 * message is still outstanding. If not, it means that the IOP took
215 * longer to respond to the message than we had allowed and timer has
216 * already expired. Not much we can do about that except log it for
217 * debug purposes, increase timeout, and recompile.
220 list_for_each_entry_safe(wait
, tmp
, &i2o_exec_wait_list
, list
) {
221 if (wait
->tcntxt
== context
) {
222 list_del(&wait
->list
);
231 wake_up_interruptible(wait
->wq
);
238 pr_debug("%s: timedout reply received!\n",
240 i2o_dma_free(dev
, &wait
->dma
);
241 i2o_exec_wait_free(wait
);
253 osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c
->name
,
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 __iomem
*msg
)
327 if (readl(&msg
->u
.head
[0]) & MSG_FAIL
) {
329 * If Fail bit is set we must take the transaction context of
330 * the preserved message to find the right request again.
332 struct i2o_message __iomem
*pmsg
;
335 pm
= readl(&msg
->body
[3]);
337 pmsg
= i2o_msg_in_to_virt(c
, pm
);
339 i2o_report_status(KERN_INFO
, "i2o_core", msg
);
341 context
= readl(&pmsg
->u
.s
.tcntxt
);
343 /* Release the preserved msg */
346 context
= readl(&msg
->u
.s
.tcntxt
);
348 if (context
& 0x80000000)
349 return i2o_msg_post_wait_complete(c
, m
, msg
, context
);
351 if ((readl(&msg
->u
.head
[1]) >> 24) == I2O_CMD_LCT_NOTIFY
) {
352 struct work_struct
*work
;
354 pr_debug("%s: LCT notify received\n", c
->name
);
356 work
= kmalloc(sizeof(*work
), GFP_ATOMIC
);
360 INIT_WORK(work
, (void (*)(void *))i2o_exec_lct_modified
, c
);
361 queue_work(i2o_exec_driver
.event_queue
, work
);
366 * If this happens, we want to dump the message to the syslog so
367 * it can be sent back to the card manufacturer by the end user
368 * to aid in debugging.
371 printk(KERN_WARNING
"%s: Unsolicited message reply sent to core!"
372 "Message dumped to syslog\n", c
->name
);
373 i2o_dump_message(msg
);
379 * i2o_exec_event - Event handling function
380 * @evt: Event which occurs
382 * Handles events send by the Executive device. At the moment does not do
385 static void i2o_exec_event(struct i2o_event
*evt
)
387 if(likely(evt
->i2o_dev
))
388 osm_info("Event received from device: %d\n",
389 evt
->i2o_dev
->lct_data
.tid
);
394 * i2o_exec_lct_get - Get the IOP's Logical Configuration Table
395 * @c: I2O controller from which the LCT should be fetched
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.
401 * Returns 0 on success or negative error code on failure.
403 int i2o_exec_lct_get(struct i2o_controller
*c
)
405 struct i2o_message __iomem
*msg
;
410 for (i
= 1; i
<= I2O_LCT_GET_TRIES
; i
++) {
411 m
= i2o_msg_get_wait(c
, &msg
, I2O_TIMEOUT_MESSAGE_GET
);
412 if (m
== I2O_QUEUE_EMPTY
)
415 writel(EIGHT_WORD_MSG_SIZE
| SGL_OFFSET_6
, &msg
->u
.head
[0]);
416 writel(I2O_CMD_LCT_NOTIFY
<< 24 | HOST_TID
<< 12 | ADAPTER_TID
,
418 writel(0xffffffff, &msg
->body
[0]);
419 writel(0x00000000, &msg
->body
[1]);
420 writel(0xd0000000 | c
->dlct
.len
, &msg
->body
[2]);
421 writel(c
->dlct
.phys
, &msg
->body
[3]);
423 rc
= i2o_msg_post_wait(c
, m
, I2O_TIMEOUT_LCT_GET
);
427 rc
= i2o_device_parse_lct(c
);
436 * i2o_exec_lct_notify - Send a asynchronus LCT NOTIFY request
437 * @c: I2O controller to which the request should be send
438 * @change_ind: change indicator
440 * This function sends a LCT NOTIFY request to the I2O controller with
441 * the change indicator change_ind. If the change_ind == 0 the controller
442 * replies immediately after the request. If change_ind > 0 the reply is
443 * send after change indicator of the LCT is > change_ind.
445 static int i2o_exec_lct_notify(struct i2o_controller
*c
, u32 change_ind
)
447 i2o_status_block
*sb
= c
->status_block
.virt
;
449 struct i2o_message __iomem
*msg
;
454 if (i2o_dma_realloc(dev
, &c
->dlct
, sb
->expected_lct_size
, GFP_KERNEL
))
457 m
= i2o_msg_get_wait(c
, &msg
, I2O_TIMEOUT_MESSAGE_GET
);
458 if (m
== I2O_QUEUE_EMPTY
)
461 writel(EIGHT_WORD_MSG_SIZE
| SGL_OFFSET_6
, &msg
->u
.head
[0]);
462 writel(I2O_CMD_LCT_NOTIFY
<< 24 | HOST_TID
<< 12 | ADAPTER_TID
,
464 writel(i2o_exec_driver
.context
, &msg
->u
.s
.icntxt
);
465 writel(0, &msg
->u
.s
.tcntxt
); /* FIXME */
466 writel(0xffffffff, &msg
->body
[0]);
467 writel(change_ind
, &msg
->body
[1]);
468 writel(0xd0000000 | c
->dlct
.len
, &msg
->body
[2]);
469 writel(c
->dlct
.phys
, &msg
->body
[3]);
476 /* Exec OSM driver struct */
477 struct i2o_driver i2o_exec_driver
= {
479 .reply
= i2o_exec_reply
,
480 .event
= i2o_exec_event
,
481 .classes
= i2o_exec_class_id
,
483 .probe
= i2o_exec_probe
,
484 .remove
= i2o_exec_remove
,
489 * i2o_exec_init - Registers the Exec OSM
491 * Registers the Exec OSM in the I2O core.
493 * Returns 0 on success or negative error code on failure.
495 int __init
i2o_exec_init(void)
497 return i2o_driver_register(&i2o_exec_driver
);
501 * i2o_exec_exit - Removes the Exec OSM
503 * Unregisters the Exec OSM from the I2O core.
505 void __exit
i2o_exec_exit(void)
507 i2o_driver_unregister(&i2o_exec_driver
);
510 EXPORT_SYMBOL(i2o_msg_post_wait_mem
);
511 EXPORT_SYMBOL(i2o_exec_lct_get
);