blob: a3970e56ae539f693cf9c92217976058e5696661 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Jan Engelhardt96de0e22007-10-19 23:21:04 +020018 * Juha Sievänen <Juha.Sievanen@cs.Helsinki.FI>
19 * Auvo Häkkinen <Auvo.Hakkinen@cs.Helsinki.FI>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 * Deepak Saxena <deepak@plexity.net>
21 * Boji T Kannanthanam <boji.t.kannanthanam@intel.com>
Alan Coxf1b11e52009-01-05 14:04:40 +000022 * Alan Cox <alan@lxorguk.ukuu.org.uk>:
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 * 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
30#include <linux/module.h>
31#include <linux/i2o.h>
32#include <linux/delay.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080033#include <linux/workqueue.h>
34#include <linux/string.h>
35#include <linux/slab.h>
Markus Lidel524e3b62006-01-06 00:19:34 -080036#include <linux/sched.h> /* wait_event_interruptible_timeout() needs this */
Tim Schmielau4e57b682005-10-30 15:03:48 -080037#include <asm/param.h> /* HZ */
Markus Lidel9e875452005-06-23 22:02:21 -070038#include "core.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40#define OSM_NAME "exec-osm"
41
42struct i2o_driver i2o_exec_driver;
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044/* global wait list for POST WAIT */
45static LIST_HEAD(i2o_exec_wait_list);
46
47/* Wait struct needed for POST WAIT */
48struct 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 */
Markus Lidel9e875452005-06-23 22:02:21 -070054 struct i2o_message *msg; /* pointer to the reply message */
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 struct list_head list; /* node in global wait list */
Markus Lidel57a62fe2006-06-10 09:54:14 -070056 spinlock_t lock; /* lock before modifying */
Linus Torvalds1da177e2005-04-16 15:20:36 -070057};
58
Vasily Averin071a6512006-03-05 23:18:14 +010059/* Work struct needed to handle LCT NOTIFY replies */
60struct i2o_exec_lct_notify_work {
61 struct work_struct work; /* work struct */
62 struct i2o_controller *c; /* controller on which the LCT NOTIFY
63 was received */
64};
65
Linus Torvalds1da177e2005-04-16 15:20:36 -070066/* Exec OSM class handling definition */
67static struct i2o_class_id i2o_exec_class_id[] = {
68 {I2O_CLASS_EXECUTIVE},
69 {I2O_CLASS_END}
70};
71
72/**
73 * i2o_exec_wait_alloc - Allocate a i2o_exec_wait struct an initialize it
74 *
75 * Allocate the i2o_exec_wait struct and initialize the wait.
76 *
77 * Returns i2o_exec_wait pointer on success or negative error code on
78 * failure.
79 */
80static struct i2o_exec_wait *i2o_exec_wait_alloc(void)
81{
82 struct i2o_exec_wait *wait;
83
Markus Lidelf6ed39a2006-01-06 00:19:33 -080084 wait = kzalloc(sizeof(*wait), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 if (!wait)
Markus Lidel793fd152006-01-06 00:19:30 -080086 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 INIT_LIST_HEAD(&wait->list);
Markus Lidel57a62fe2006-06-10 09:54:14 -070089 spin_lock_init(&wait->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
91 return wait;
92};
93
94/**
Randy Dunlapd9489fb2006-12-06 20:38:43 -080095 * i2o_exec_wait_free - Free an i2o_exec_wait struct
96 * @wait: I2O wait data which should be cleaned up
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 */
98static void i2o_exec_wait_free(struct i2o_exec_wait *wait)
99{
100 kfree(wait);
101};
102
103/**
104 * i2o_msg_post_wait_mem - Post and wait a message with DMA buffers
105 * @c: controller
Randy Dunlapd9489fb2006-12-06 20:38:43 -0800106 * @msg: message to post
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 * @timeout: time in seconds to wait
108 * @dma: i2o_dma struct of the DMA buffer to free on failure
109 *
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.
118 *
Markus Lidelf88e1192005-06-23 22:02:14 -0700119 * Returns 0 on success, negative error code on timeout or positive error
120 * code from reply.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800122int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg,
123 unsigned long timeout, struct i2o_dma *dma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124{
Peter Zijlstra7259f0d2006-10-29 22:46:36 -0800125 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 struct i2o_exec_wait *wait;
127 static u32 tcntxt = 0x80000000;
Alexey Dobriyan8a7822a2006-10-21 10:24:17 -0700128 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 int rc = 0;
130
131 wait = i2o_exec_wait_alloc();
Vasily Averin3d0fd332007-07-17 04:04:26 -0700132 if (!wait) {
133 i2o_msg_nop(c, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 return -ENOMEM;
Vasily Averin3d0fd332007-07-17 04:04:26 -0700135 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
137 if (tcntxt == 0xffffffff)
138 tcntxt = 0x80000000;
139
140 if (dma)
141 wait->dma = *dma;
142
143 /*
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.
147 */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800148 msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 wait->tcntxt = tcntxt++;
Markus Lidela1a5ea72006-01-06 00:19:29 -0800150 msg->u.s.tcntxt = cpu_to_le32(wait->tcntxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
Markus Lidel57a62fe2006-06-10 09:54:14 -0700152 wait->wq = &wq;
153 /*
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
156 */
157 list_add(&wait->list, &i2o_exec_wait_list);
158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 /*
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.
162 */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800163 i2o_msg_post(c, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Markus Lidel57a62fe2006-06-10 09:54:14 -0700165 wait_event_interruptible_timeout(wq, wait->complete, timeout * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Markus Lidel57a62fe2006-06-10 09:54:14 -0700167 spin_lock_irqsave(&wait->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Markus Lidel57a62fe2006-06-10 09:54:14 -0700169 wait->wq = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Markus Lidel57a62fe2006-06-10 09:54:14 -0700171 if (wait->complete)
Markus Lidel9e875452005-06-23 22:02:21 -0700172 rc = le32_to_cpu(wait->msg->body[0]) >> 24;
Markus Lidel57a62fe2006-06-10 09:54:14 -0700173 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 /*
175 * We cannot remove it now. This is important. When it does
176 * terminate (which it must do if the controller has not
177 * died...) then it will otherwise scribble on stuff.
178 *
179 * FIXME: try abort message
180 */
181 if (dma)
182 dma->virt = NULL;
183
184 rc = -ETIMEDOUT;
185 }
186
Markus Lidel57a62fe2006-06-10 09:54:14 -0700187 spin_unlock_irqrestore(&wait->lock, flags);
188
189 if (rc != -ETIMEDOUT) {
190 i2o_flush_reply(c, wait->m);
191 i2o_exec_wait_free(wait);
192 }
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 return rc;
195};
196
197/**
198 * i2o_msg_post_wait_complete - Reply to a i2o_msg_post request from IOP
199 * @c: I2O controller which answers
200 * @m: message id
201 * @msg: pointer to the I2O reply message
Markus Lidelf88e1192005-06-23 22:02:14 -0700202 * @context: transaction context of request
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 *
204 * This function is called in interrupt context only. If the reply reached
205 * before the timeout, the i2o_exec_wait struct is filled with the message
206 * and the task will be waked up. The task is now responsible for returning
207 * the message m back to the controller! If the message reaches us after
208 * the timeout clean up the i2o_exec_wait struct (including allocated
209 * DMA buffer).
210 *
211 * Return 0 on success and if the message m should not be given back to the
212 * I2O controller, or >0 on success and if the message should be given back
213 * afterwords. Returns negative error code on failure. In this case the
214 * message must also be given back to the controller.
215 */
216static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
Markus Lidel9e875452005-06-23 22:02:21 -0700217 struct i2o_message *msg, u32 context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 struct i2o_exec_wait *wait, *tmp;
Markus Lidelf10378f2005-06-23 22:02:16 -0700220 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 int rc = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
223 /*
224 * We need to search through the i2o_exec_wait_list to see if the given
225 * message is still outstanding. If not, it means that the IOP took
226 * longer to respond to the message than we had allowed and timer has
227 * already expired. Not much we can do about that except log it for
228 * debug purposes, increase timeout, and recompile.
229 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) {
231 if (wait->tcntxt == context) {
Markus Lidel57a62fe2006-06-10 09:54:14 -0700232 spin_lock_irqsave(&wait->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Markus Lidel57a62fe2006-06-10 09:54:14 -0700234 list_del(&wait->list);
Markus Lidelf10378f2005-06-23 22:02:16 -0700235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 wait->m = m;
237 wait->msg = msg;
238 wait->complete = 1;
239
Markus Lidel57a62fe2006-06-10 09:54:14 -0700240 if (wait->wq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 rc = 0;
Markus Lidel57a62fe2006-06-10 09:54:14 -0700242 else
243 rc = -1;
244
245 spin_unlock_irqrestore(&wait->lock, flags);
246
247 if (rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 struct device *dev;
249
250 dev = &c->pdev->dev;
251
252 pr_debug("%s: timedout reply received!\n",
253 c->name);
254 i2o_dma_free(dev, &wait->dma);
255 i2o_exec_wait_free(wait);
Markus Lidel57a62fe2006-06-10 09:54:14 -0700256 } else
257 wake_up_interruptible(wait->wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 return rc;
260 }
261 }
262
Markus Lidelf88e1192005-06-23 22:02:14 -0700263 osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 context);
265
266 return -1;
267};
268
269/**
Markus Lidelf10378f2005-06-23 22:02:16 -0700270 * i2o_exec_show_vendor_id - Displays Vendor ID of controller
271 * @d: device of which the Vendor ID should be displayed
Randy Dunlapd9489fb2006-12-06 20:38:43 -0800272 * @attr: device_attribute to display
Markus Lidelf10378f2005-06-23 22:02:16 -0700273 * @buf: buffer into which the Vendor ID should be printed
274 *
275 * Returns number of bytes printed into buffer.
276 */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800277static ssize_t i2o_exec_show_vendor_id(struct device *d,
278 struct device_attribute *attr, char *buf)
Markus Lidelf10378f2005-06-23 22:02:16 -0700279{
280 struct i2o_device *dev = to_i2o_device(d);
281 u16 id;
282
Markus Lidel793fd152006-01-06 00:19:30 -0800283 if (!i2o_parm_field_get(dev, 0x0000, 0, &id, 2)) {
284 sprintf(buf, "0x%04x", le16_to_cpu(id));
Markus Lidelf10378f2005-06-23 22:02:16 -0700285 return strlen(buf) + 1;
286 }
287
288 return 0;
289};
290
291/**
292 * i2o_exec_show_product_id - Displays Product ID of controller
293 * @d: device of which the Product ID should be displayed
Randy Dunlapd9489fb2006-12-06 20:38:43 -0800294 * @attr: device_attribute to display
Markus Lidelf10378f2005-06-23 22:02:16 -0700295 * @buf: buffer into which the Product ID should be printed
296 *
297 * Returns number of bytes printed into buffer.
298 */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800299static ssize_t i2o_exec_show_product_id(struct device *d,
300 struct device_attribute *attr,
301 char *buf)
Markus Lidelf10378f2005-06-23 22:02:16 -0700302{
303 struct i2o_device *dev = to_i2o_device(d);
304 u16 id;
305
Markus Lidel793fd152006-01-06 00:19:30 -0800306 if (!i2o_parm_field_get(dev, 0x0000, 1, &id, 2)) {
307 sprintf(buf, "0x%04x", le16_to_cpu(id));
Markus Lidelf10378f2005-06-23 22:02:16 -0700308 return strlen(buf) + 1;
309 }
310
311 return 0;
312};
313
314/* Exec-OSM device attributes */
315static DEVICE_ATTR(vendor_id, S_IRUGO, i2o_exec_show_vendor_id, NULL);
316static DEVICE_ATTR(product_id, S_IRUGO, i2o_exec_show_product_id, NULL);
317
318/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 * i2o_exec_probe - Called if a new I2O device (executive class) appears
320 * @dev: I2O device which should be probed
321 *
322 * Registers event notification for every event from Executive device. The
323 * return is always 0, because we want all devices of class Executive.
324 *
325 * Returns 0 on success.
326 */
327static int i2o_exec_probe(struct device *dev)
328{
329 struct i2o_device *i2o_dev = to_i2o_device(dev);
Jeff Garzik6b5f2962006-10-17 00:10:22 -0700330 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Jeff Garzik6b5f2962006-10-17 00:10:22 -0700332 rc = i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff);
333 if (rc) goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
Jeff Garzik6b5f2962006-10-17 00:10:22 -0700335 rc = device_create_file(dev, &dev_attr_vendor_id);
336 if (rc) goto err_evtreg;
337 rc = device_create_file(dev, &dev_attr_product_id);
338 if (rc) goto err_vid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
Vasily Averin44aaa932007-07-17 04:04:27 -0700340 i2o_dev->iop->exec = i2o_dev;
341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 return 0;
Jeff Garzik6b5f2962006-10-17 00:10:22 -0700343
344err_vid:
345 device_remove_file(dev, &dev_attr_vendor_id);
346err_evtreg:
347 i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
348err_out:
349 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350};
351
352/**
353 * i2o_exec_remove - Called on I2O device removal
354 * @dev: I2O device which was removed
355 *
356 * Unregisters event notification from Executive I2O device.
357 *
358 * Returns 0 on success.
359 */
360static int i2o_exec_remove(struct device *dev)
361{
Markus Lidelf10378f2005-06-23 22:02:16 -0700362 device_remove_file(dev, &dev_attr_product_id);
363 device_remove_file(dev, &dev_attr_vendor_id);
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
366
367 return 0;
368};
369
Satyam Sharmac98673f2007-10-16 23:29:39 -0700370#ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES
371/**
372 * i2o_exec_lct_notify - Send a asynchronus LCT NOTIFY request
373 * @c: I2O controller to which the request should be send
374 * @change_ind: change indicator
375 *
376 * This function sends a LCT NOTIFY request to the I2O controller with
377 * the change indicator change_ind. If the change_ind == 0 the controller
378 * replies immediately after the request. If change_ind > 0 the reply is
379 * send after change indicator of the LCT is > change_ind.
380 */
381static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind)
382{
383 i2o_status_block *sb = c->status_block.virt;
384 struct device *dev;
385 struct i2o_message *msg;
386
387 mutex_lock(&c->lct_lock);
388
389 dev = &c->pdev->dev;
390
Alan Cox9d793b02008-10-15 22:02:47 -0700391 if (i2o_dma_realloc(dev, &c->dlct,
Julia Lawall32fa4542010-08-10 18:02:03 -0700392 le32_to_cpu(sb->expected_lct_size))) {
393 mutex_unlock(&c->lct_lock);
Satyam Sharmac98673f2007-10-16 23:29:39 -0700394 return -ENOMEM;
Julia Lawall32fa4542010-08-10 18:02:03 -0700395 }
Satyam Sharmac98673f2007-10-16 23:29:39 -0700396
397 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
Julia Lawall32fa4542010-08-10 18:02:03 -0700398 if (IS_ERR(msg)) {
399 mutex_unlock(&c->lct_lock);
Satyam Sharmac98673f2007-10-16 23:29:39 -0700400 return PTR_ERR(msg);
Julia Lawall32fa4542010-08-10 18:02:03 -0700401 }
Satyam Sharmac98673f2007-10-16 23:29:39 -0700402
403 msg->u.head[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
404 msg->u.head[1] = cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
405 ADAPTER_TID);
406 msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
407 msg->u.s.tcntxt = cpu_to_le32(0x00000000);
408 msg->body[0] = cpu_to_le32(0xffffffff);
409 msg->body[1] = cpu_to_le32(change_ind);
410 msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
411 msg->body[3] = cpu_to_le32(c->dlct.phys);
412
413 i2o_msg_post(c, msg);
414
415 mutex_unlock(&c->lct_lock);
416
417 return 0;
418}
419#endif
420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421/**
422 * i2o_exec_lct_modified - Called on LCT NOTIFY reply
Randy Dunlapaf9997e2006-12-22 01:06:52 -0800423 * @_work: work struct for a specific controller
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 *
425 * This function handles asynchronus LCT NOTIFY replies. It parses the
426 * new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY
Markus Lidelf10378f2005-06-23 22:02:16 -0700427 * again, otherwise send LCT NOTIFY to get informed on next LCT change.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 */
David Howellsc4028952006-11-22 14:57:56 +0000429static void i2o_exec_lct_modified(struct work_struct *_work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430{
David Howellsc4028952006-11-22 14:57:56 +0000431 struct i2o_exec_lct_notify_work *work =
432 container_of(_work, struct i2o_exec_lct_notify_work, work);
Markus Lidelf10378f2005-06-23 22:02:16 -0700433 u32 change_ind = 0;
Vasily Averin071a6512006-03-05 23:18:14 +0100434 struct i2o_controller *c = work->c;
435
436 kfree(work);
Markus Lidelf10378f2005-06-23 22:02:16 -0700437
438 if (i2o_device_parse_lct(c) != -EAGAIN)
439 change_ind = c->lct->change_ind + 1;
440
Markus Lidel793fd152006-01-06 00:19:30 -0800441#ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES
Markus Lidelf10378f2005-06-23 22:02:16 -0700442 i2o_exec_lct_notify(c, change_ind);
Markus Lidel793fd152006-01-06 00:19:30 -0800443#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444};
445
446/**
447 * i2o_exec_reply - I2O Executive reply handler
448 * @c: I2O controller from which the reply comes
449 * @m: message id
450 * @msg: pointer to the I2O reply message
451 *
452 * This function is always called from interrupt context. If a POST WAIT
453 * reply was received, pass it to the complete function. If a LCT NOTIFY
454 * reply was received, a new event is created to handle the update.
455 *
456 * Returns 0 on success and if the reply should not be flushed or > 0
457 * on success and if the reply should be flushed. Returns negative error
458 * code on failure and if the reply should be flushed.
459 */
460static int i2o_exec_reply(struct i2o_controller *c, u32 m,
Markus Lidel9e875452005-06-23 22:02:21 -0700461 struct i2o_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462{
Markus Lidelf88e1192005-06-23 22:02:14 -0700463 u32 context;
464
Markus Lidel9e875452005-06-23 22:02:21 -0700465 if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) {
Markus Lidela1a5ea72006-01-06 00:19:29 -0800466 struct i2o_message __iomem *pmsg;
467 u32 pm;
468
Markus Lidelf88e1192005-06-23 22:02:14 -0700469 /*
470 * If Fail bit is set we must take the transaction context of
471 * the preserved message to find the right request again.
472 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Markus Lidel9e875452005-06-23 22:02:21 -0700474 pm = le32_to_cpu(msg->body[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 pmsg = i2o_msg_in_to_virt(c, pm);
Markus Lidela1a5ea72006-01-06 00:19:29 -0800476 context = readl(&pmsg->u.s.tcntxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478 i2o_report_status(KERN_INFO, "i2o_core", msg);
479
Markus Lidelf88e1192005-06-23 22:02:14 -0700480 /* Release the preserved msg */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800481 i2o_msg_nop_mfa(c, pm);
Markus Lidelf88e1192005-06-23 22:02:14 -0700482 } else
Markus Lidel9e875452005-06-23 22:02:21 -0700483 context = le32_to_cpu(msg->u.s.tcntxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
Markus Lidelf88e1192005-06-23 22:02:14 -0700485 if (context & 0x80000000)
486 return i2o_msg_post_wait_complete(c, m, msg, context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Markus Lidel9e875452005-06-23 22:02:21 -0700488 if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
Vasily Averin071a6512006-03-05 23:18:14 +0100489 struct i2o_exec_lct_notify_work *work;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
491 pr_debug("%s: LCT notify received\n", c->name);
492
493 work = kmalloc(sizeof(*work), GFP_ATOMIC);
494 if (!work)
495 return -ENOMEM;
496
Vasily Averin071a6512006-03-05 23:18:14 +0100497 work->c = c;
498
David Howellsc4028952006-11-22 14:57:56 +0000499 INIT_WORK(&work->work, i2o_exec_lct_modified);
Vasily Averin071a6512006-03-05 23:18:14 +0100500 queue_work(i2o_exec_driver.event_queue, &work->work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 return 1;
502 }
503
504 /*
505 * If this happens, we want to dump the message to the syslog so
506 * it can be sent back to the card manufacturer by the end user
507 * to aid in debugging.
508 *
509 */
510 printk(KERN_WARNING "%s: Unsolicited message reply sent to core!"
511 "Message dumped to syslog\n", c->name);
512 i2o_dump_message(msg);
513
514 return -EFAULT;
515}
516
517/**
518 * i2o_exec_event - Event handling function
David Howellsc4028952006-11-22 14:57:56 +0000519 * @work: Work item in occurring event
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 *
521 * Handles events send by the Executive device. At the moment does not do
522 * anything useful.
523 */
David Howellsc4028952006-11-22 14:57:56 +0000524static void i2o_exec_event(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525{
David Howellsc4028952006-11-22 14:57:56 +0000526 struct i2o_event *evt = container_of(work, struct i2o_event, work);
527
Markus Lidel9e875452005-06-23 22:02:21 -0700528 if (likely(evt->i2o_dev))
529 osm_debug("Event received from device: %d\n",
530 evt->i2o_dev->lct_data.tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 kfree(evt);
532};
533
534/**
535 * i2o_exec_lct_get - Get the IOP's Logical Configuration Table
536 * @c: I2O controller from which the LCT should be fetched
537 *
538 * Send a LCT NOTIFY request to the controller, and wait
539 * I2O_TIMEOUT_LCT_GET seconds until arrival of response. If the LCT is
540 * to large, retry it.
541 *
542 * Returns 0 on success or negative error code on failure.
543 */
544int i2o_exec_lct_get(struct i2o_controller *c)
545{
Markus Lidela1a5ea72006-01-06 00:19:29 -0800546 struct i2o_message *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 int i = 0;
548 int rc = -EAGAIN;
549
550 for (i = 1; i <= I2O_LCT_GET_TRIES; i++) {
Markus Lidela1a5ea72006-01-06 00:19:29 -0800551 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
552 if (IS_ERR(msg))
553 return PTR_ERR(msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
Markus Lidela1a5ea72006-01-06 00:19:29 -0800555 msg->u.head[0] =
556 cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
557 msg->u.head[1] =
558 cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
559 ADAPTER_TID);
560 msg->body[0] = cpu_to_le32(0xffffffff);
561 msg->body[1] = cpu_to_le32(0x00000000);
562 msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
563 msg->body[3] = cpu_to_le32(c->dlct.phys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
Markus Lidela1a5ea72006-01-06 00:19:29 -0800565 rc = i2o_msg_post_wait(c, msg, I2O_TIMEOUT_LCT_GET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 if (rc < 0)
567 break;
568
569 rc = i2o_device_parse_lct(c);
570 if (rc != -EAGAIN)
571 break;
572 }
573
574 return rc;
575}
576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577/* Exec OSM driver struct */
578struct i2o_driver i2o_exec_driver = {
579 .name = OSM_NAME,
580 .reply = i2o_exec_reply,
581 .event = i2o_exec_event,
582 .classes = i2o_exec_class_id,
583 .driver = {
584 .probe = i2o_exec_probe,
585 .remove = i2o_exec_remove,
586 },
587};
588
589/**
590 * i2o_exec_init - Registers the Exec OSM
591 *
592 * Registers the Exec OSM in the I2O core.
593 *
594 * Returns 0 on success or negative error code on failure.
595 */
596int __init i2o_exec_init(void)
597{
598 return i2o_driver_register(&i2o_exec_driver);
599};
600
601/**
602 * i2o_exec_exit - Removes the Exec OSM
603 *
604 * Unregisters the Exec OSM from the I2O core.
605 */
Ralf Baechled7843722006-12-13 00:33:53 -0800606void i2o_exec_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{
608 i2o_driver_unregister(&i2o_exec_driver);
609};
610
611EXPORT_SYMBOL(i2o_msg_post_wait_mem);
612EXPORT_SYMBOL(i2o_exec_lct_get);