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@lxorguk.ukuu.org.uk>:
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>
33 #include <linux/workqueue.h>
34 #include <linux/string.h>
35 #include <linux/slab.h>
36 #include <linux/sched.h> /* wait_event_interruptible_timeout() needs this */
37 #include <asm/param.h> /* HZ */
40 #define OSM_NAME "exec-osm"
42 struct i2o_driver i2o_exec_driver
;
44 /* global wait list for POST WAIT */
45 static LIST_HEAD(i2o_exec_wait_list
);
47 /* Wait struct needed for POST WAIT */
48 struct i2o_exec_wait
{
49 wait_queue_head_t
*wq
; /* Pointer to Wait queue */
50 struct i2o_dma dma
; /* DMA buffers to free on failure */
51 u32 tcntxt
; /* transaction context from reply */
52 int complete
; /* 1 if reply received otherwise 0 */
53 u32 m
; /* message id */
54 struct i2o_message
*msg
; /* pointer to the reply message */
55 struct list_head list
; /* node in global wait list */
56 spinlock_t lock
; /* lock before modifying */
59 /* Work struct needed to handle LCT NOTIFY replies */
60 struct i2o_exec_lct_notify_work
{
61 struct work_struct work
; /* work struct */
62 struct i2o_controller
*c
; /* controller on which the LCT NOTIFY
66 /* Exec OSM class handling definition */
67 static struct i2o_class_id i2o_exec_class_id
[] = {
68 {I2O_CLASS_EXECUTIVE
},
73 * i2o_exec_wait_alloc - Allocate a i2o_exec_wait struct an initialize it
75 * Allocate the i2o_exec_wait struct and initialize the wait.
77 * Returns i2o_exec_wait pointer on success or negative error code on
80 static struct i2o_exec_wait
*i2o_exec_wait_alloc(void)
82 struct i2o_exec_wait
*wait
;
84 wait
= kzalloc(sizeof(*wait
), GFP_KERNEL
);
88 INIT_LIST_HEAD(&wait
->list
);
89 spin_lock_init(&wait
->lock
);
95 * i2o_exec_wait_free - Free an i2o_exec_wait struct
96 * @wait: I2O wait data which should be cleaned up
98 static void i2o_exec_wait_free(struct i2o_exec_wait
*wait
)
104 * i2o_msg_post_wait_mem - Post and wait a message with DMA buffers
106 * @msg: message to post
107 * @timeout: time in seconds to wait
108 * @dma: i2o_dma struct of the DMA buffer to free on failure
110 * This API allows an OSM to post a message and then be told whether or
111 * not the system received a successful reply. If the message times out
112 * then the value '-ETIMEDOUT' is returned. This is a special case. In
113 * this situation the message may (should) complete at an indefinite time
114 * in the future. When it completes it will use the memory buffer
115 * attached to the request. If -ETIMEDOUT is returned then the memory
116 * buffer must not be freed. Instead the event completion will free them
117 * for you. In all other cases the buffer are your problem.
119 * Returns 0 on success, negative error code on timeout or positive error
122 int i2o_msg_post_wait_mem(struct i2o_controller
*c
, struct i2o_message
*msg
,
123 unsigned long timeout
, struct i2o_dma
*dma
)
125 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq
);
126 struct i2o_exec_wait
*wait
;
127 static u32 tcntxt
= 0x80000000;
131 wait
= i2o_exec_wait_alloc();
137 if (tcntxt
== 0xffffffff)
144 * Fill in the message initiator context and transaction context.
145 * We will only use transaction contexts >= 0x80000000 for POST WAIT,
146 * so we could find a POST WAIT reply easier in the reply handler.
148 msg
->u
.s
.icntxt
= cpu_to_le32(i2o_exec_driver
.context
);
149 wait
->tcntxt
= tcntxt
++;
150 msg
->u
.s
.tcntxt
= cpu_to_le32(wait
->tcntxt
);
154 * we add elements to the head, because if a entry in the list will
155 * never be removed, we have to iterate over it every time
157 list_add(&wait
->list
, &i2o_exec_wait_list
);
160 * Post the message to the controller. At some point later it will
161 * return. If we time out before it returns then complete will be zero.
163 i2o_msg_post(c
, msg
);
165 wait_event_interruptible_timeout(wq
, wait
->complete
, timeout
* HZ
);
167 spin_lock_irqsave(&wait
->lock
, flags
);
172 rc
= le32_to_cpu(wait
->msg
->body
[0]) >> 24;
180 spin_unlock_irqrestore(&wait
->lock
, flags
);
182 if (rc
!= -ETIMEDOUT
) {
183 i2o_flush_reply(c
, wait
->m
);
184 i2o_exec_wait_free(wait
);
191 * i2o_msg_post_wait_complete - Reply to a i2o_msg_post request from IOP
192 * @c: I2O controller which answers
194 * @msg: pointer to the I2O reply message
195 * @context: transaction context of request
197 * This function is called in interrupt context only. If the reply reached
198 * before the timeout, the i2o_exec_wait struct is filled with the message
199 * and the task will be waked up. The task is now responsible for returning
200 * the message m back to the controller! If the message reaches us after
201 * the timeout clean up the i2o_exec_wait struct (including allocated
204 * Return 0 on success and if the message m should not be given back to the
205 * I2O controller, or >0 on success and if the message should be given back
206 * afterwords. Returns negative error code on failure. In this case the
207 * message must also be given back to the controller.
209 static int i2o_msg_post_wait_complete(struct i2o_controller
*c
, u32 m
,
210 struct i2o_message
*msg
, u32 context
)
212 struct i2o_exec_wait
*wait
, *tmp
;
217 * We need to search through the i2o_exec_wait_list to see if the given
218 * message is still outstanding. If not, it means that the IOP took
219 * longer to respond to the message than we had allowed and timer has
220 * already expired. Not much we can do about that except log it for
221 * debug purposes, increase timeout, and recompile.
223 list_for_each_entry_safe(wait
, tmp
, &i2o_exec_wait_list
, list
) {
224 if (wait
->tcntxt
== context
) {
225 spin_lock_irqsave(&wait
->lock
, flags
);
227 list_del(&wait
->list
);
238 spin_unlock_irqrestore(&wait
->lock
, flags
);
245 pr_debug("%s: timedout reply received!\n",
247 i2o_dma_free(dev
, &wait
->dma
);
248 i2o_exec_wait_free(wait
);
250 wake_up_interruptible(wait
->wq
);
256 osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c
->name
,
263 * i2o_exec_show_vendor_id - Displays Vendor ID of controller
264 * @d: device of which the Vendor ID should be displayed
265 * @attr: device_attribute to display
266 * @buf: buffer into which the Vendor ID should be printed
268 * Returns number of bytes printed into buffer.
270 static ssize_t
i2o_exec_show_vendor_id(struct device
*d
,
271 struct device_attribute
*attr
, char *buf
)
273 struct i2o_device
*dev
= to_i2o_device(d
);
276 if (!i2o_parm_field_get(dev
, 0x0000, 0, &id
, 2)) {
277 sprintf(buf
, "0x%04x", le16_to_cpu(id
));
278 return strlen(buf
) + 1;
285 * i2o_exec_show_product_id - Displays Product ID of controller
286 * @d: device of which the Product ID should be displayed
287 * @attr: device_attribute to display
288 * @buf: buffer into which the Product ID should be printed
290 * Returns number of bytes printed into buffer.
292 static ssize_t
i2o_exec_show_product_id(struct device
*d
,
293 struct device_attribute
*attr
,
296 struct i2o_device
*dev
= to_i2o_device(d
);
299 if (!i2o_parm_field_get(dev
, 0x0000, 1, &id
, 2)) {
300 sprintf(buf
, "0x%04x", le16_to_cpu(id
));
301 return strlen(buf
) + 1;
307 /* Exec-OSM device attributes */
308 static DEVICE_ATTR(vendor_id
, S_IRUGO
, i2o_exec_show_vendor_id
, NULL
);
309 static DEVICE_ATTR(product_id
, S_IRUGO
, i2o_exec_show_product_id
, NULL
);
312 * i2o_exec_probe - Called if a new I2O device (executive class) appears
313 * @dev: I2O device which should be probed
315 * Registers event notification for every event from Executive device. The
316 * return is always 0, because we want all devices of class Executive.
318 * Returns 0 on success.
320 static int i2o_exec_probe(struct device
*dev
)
322 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
325 rc
= i2o_event_register(i2o_dev
, &i2o_exec_driver
, 0, 0xffffffff);
326 if (rc
) goto err_out
;
328 rc
= device_create_file(dev
, &dev_attr_vendor_id
);
329 if (rc
) goto err_evtreg
;
330 rc
= device_create_file(dev
, &dev_attr_product_id
);
331 if (rc
) goto err_vid
;
333 i2o_dev
->iop
->exec
= i2o_dev
;
338 device_remove_file(dev
, &dev_attr_vendor_id
);
340 i2o_event_register(to_i2o_device(dev
), &i2o_exec_driver
, 0, 0);
346 * i2o_exec_remove - Called on I2O device removal
347 * @dev: I2O device which was removed
349 * Unregisters event notification from Executive I2O device.
351 * Returns 0 on success.
353 static int i2o_exec_remove(struct device
*dev
)
355 device_remove_file(dev
, &dev_attr_product_id
);
356 device_remove_file(dev
, &dev_attr_vendor_id
);
358 i2o_event_register(to_i2o_device(dev
), &i2o_exec_driver
, 0, 0);
363 #ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES
365 * i2o_exec_lct_notify - Send a asynchronus LCT NOTIFY request
366 * @c: I2O controller to which the request should be send
367 * @change_ind: change indicator
369 * This function sends a LCT NOTIFY request to the I2O controller with
370 * the change indicator change_ind. If the change_ind == 0 the controller
371 * replies immediately after the request. If change_ind > 0 the reply is
372 * send after change indicator of the LCT is > change_ind.
374 static int i2o_exec_lct_notify(struct i2o_controller
*c
, u32 change_ind
)
376 i2o_status_block
*sb
= c
->status_block
.virt
;
378 struct i2o_message
*msg
;
380 mutex_lock(&c
->lct_lock
);
384 if (i2o_dma_realloc(dev
, &c
->dlct
,
385 le32_to_cpu(sb
->expected_lct_size
))) {
386 mutex_unlock(&c
->lct_lock
);
390 msg
= i2o_msg_get_wait(c
, I2O_TIMEOUT_MESSAGE_GET
);
392 mutex_unlock(&c
->lct_lock
);
396 msg
->u
.head
[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE
| SGL_OFFSET_6
);
397 msg
->u
.head
[1] = cpu_to_le32(I2O_CMD_LCT_NOTIFY
<< 24 | HOST_TID
<< 12 |
399 msg
->u
.s
.icntxt
= cpu_to_le32(i2o_exec_driver
.context
);
400 msg
->u
.s
.tcntxt
= cpu_to_le32(0x00000000);
401 msg
->body
[0] = cpu_to_le32(0xffffffff);
402 msg
->body
[1] = cpu_to_le32(change_ind
);
403 msg
->body
[2] = cpu_to_le32(0xd0000000 | c
->dlct
.len
);
404 msg
->body
[3] = cpu_to_le32(c
->dlct
.phys
);
406 i2o_msg_post(c
, msg
);
408 mutex_unlock(&c
->lct_lock
);
415 * i2o_exec_lct_modified - Called on LCT NOTIFY reply
416 * @_work: work struct for a specific controller
418 * This function handles asynchronus LCT NOTIFY replies. It parses the
419 * new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY
420 * again, otherwise send LCT NOTIFY to get informed on next LCT change.
422 static void i2o_exec_lct_modified(struct work_struct
*_work
)
424 struct i2o_exec_lct_notify_work
*work
=
425 container_of(_work
, struct i2o_exec_lct_notify_work
, work
);
427 struct i2o_controller
*c
= work
->c
;
431 if (i2o_device_parse_lct(c
) != -EAGAIN
)
432 change_ind
= c
->lct
->change_ind
+ 1;
434 #ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES
435 i2o_exec_lct_notify(c
, change_ind
);
440 * i2o_exec_reply - I2O Executive reply handler
441 * @c: I2O controller from which the reply comes
443 * @msg: pointer to the I2O reply message
445 * This function is always called from interrupt context. If a POST WAIT
446 * reply was received, pass it to the complete function. If a LCT NOTIFY
447 * reply was received, a new event is created to handle the update.
449 * Returns 0 on success and if the reply should not be flushed or > 0
450 * on success and if the reply should be flushed. Returns negative error
451 * code on failure and if the reply should be flushed.
453 static int i2o_exec_reply(struct i2o_controller
*c
, u32 m
,
454 struct i2o_message
*msg
)
458 if (le32_to_cpu(msg
->u
.head
[0]) & MSG_FAIL
) {
459 struct i2o_message __iomem
*pmsg
;
463 * If Fail bit is set we must take the transaction context of
464 * the preserved message to find the right request again.
467 pm
= le32_to_cpu(msg
->body
[3]);
468 pmsg
= i2o_msg_in_to_virt(c
, pm
);
469 context
= readl(&pmsg
->u
.s
.tcntxt
);
471 i2o_report_status(KERN_INFO
, "i2o_core", msg
);
473 /* Release the preserved msg */
474 i2o_msg_nop_mfa(c
, pm
);
476 context
= le32_to_cpu(msg
->u
.s
.tcntxt
);
478 if (context
& 0x80000000)
479 return i2o_msg_post_wait_complete(c
, m
, msg
, context
);
481 if ((le32_to_cpu(msg
->u
.head
[1]) >> 24) == I2O_CMD_LCT_NOTIFY
) {
482 struct i2o_exec_lct_notify_work
*work
;
484 pr_debug("%s: LCT notify received\n", c
->name
);
486 work
= kmalloc(sizeof(*work
), GFP_ATOMIC
);
492 INIT_WORK(&work
->work
, i2o_exec_lct_modified
);
493 queue_work(i2o_exec_driver
.event_queue
, &work
->work
);
498 * If this happens, we want to dump the message to the syslog so
499 * it can be sent back to the card manufacturer by the end user
500 * to aid in debugging.
503 printk(KERN_WARNING
"%s: Unsolicited message reply sent to core!"
504 "Message dumped to syslog\n", c
->name
);
505 i2o_dump_message(msg
);
511 * i2o_exec_event - Event handling function
512 * @work: Work item in occurring event
514 * Handles events send by the Executive device. At the moment does not do
517 static void i2o_exec_event(struct work_struct
*work
)
519 struct i2o_event
*evt
= container_of(work
, struct i2o_event
, work
);
521 if (likely(evt
->i2o_dev
))
522 osm_debug("Event received from device: %d\n",
523 evt
->i2o_dev
->lct_data
.tid
);
528 * i2o_exec_lct_get - Get the IOP's Logical Configuration Table
529 * @c: I2O controller from which the LCT should be fetched
531 * Send a LCT NOTIFY request to the controller, and wait
532 * I2O_TIMEOUT_LCT_GET seconds until arrival of response. If the LCT is
533 * to large, retry it.
535 * Returns 0 on success or negative error code on failure.
537 int i2o_exec_lct_get(struct i2o_controller
*c
)
539 struct i2o_message
*msg
;
543 for (i
= 1; i
<= I2O_LCT_GET_TRIES
; i
++) {
544 msg
= i2o_msg_get_wait(c
, I2O_TIMEOUT_MESSAGE_GET
);
549 cpu_to_le32(EIGHT_WORD_MSG_SIZE
| SGL_OFFSET_6
);
551 cpu_to_le32(I2O_CMD_LCT_NOTIFY
<< 24 | HOST_TID
<< 12 |
553 msg
->body
[0] = cpu_to_le32(0xffffffff);
554 msg
->body
[1] = cpu_to_le32(0x00000000);
555 msg
->body
[2] = cpu_to_le32(0xd0000000 | c
->dlct
.len
);
556 msg
->body
[3] = cpu_to_le32(c
->dlct
.phys
);
558 rc
= i2o_msg_post_wait(c
, msg
, I2O_TIMEOUT_LCT_GET
);
562 rc
= i2o_device_parse_lct(c
);
570 /* Exec OSM driver struct */
571 struct i2o_driver i2o_exec_driver
= {
573 .reply
= i2o_exec_reply
,
574 .event
= i2o_exec_event
,
575 .classes
= i2o_exec_class_id
,
577 .probe
= i2o_exec_probe
,
578 .remove
= i2o_exec_remove
,
583 * i2o_exec_init - Registers the Exec OSM
585 * Registers the Exec OSM in the I2O core.
587 * Returns 0 on success or negative error code on failure.
589 int __init
i2o_exec_init(void)
591 return i2o_driver_register(&i2o_exec_driver
);
595 * i2o_exec_exit - Removes the Exec OSM
597 * Unregisters the Exec OSM from the I2O core.
599 void i2o_exec_exit(void)
601 i2o_driver_unregister(&i2o_exec_driver
);
604 EXPORT_SYMBOL(i2o_msg_post_wait_mem
);
605 EXPORT_SYMBOL(i2o_exec_lct_get
);