blob: 5ea133c59afb3e7ab2788c2d68c1512723ddf5c6 [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
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
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
44static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind);
45
Linus Torvalds1da177e2005-04-16 15:20:36 -070046/* global wait list for POST WAIT */
47static LIST_HEAD(i2o_exec_wait_list);
48
49/* Wait struct needed for POST WAIT */
50struct i2o_exec_wait {
51 wait_queue_head_t *wq; /* Pointer to Wait queue */
52 struct i2o_dma dma; /* DMA buffers to free on failure */
53 u32 tcntxt; /* transaction context from reply */
54 int complete; /* 1 if reply received otherwise 0 */
55 u32 m; /* message id */
Markus Lidel9e875452005-06-23 22:02:21 -070056 struct i2o_message *msg; /* pointer to the reply message */
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 struct list_head list; /* node in global wait list */
58};
59
Vasily Averin071a6512006-03-05 23:18:14 +010060/* Work struct needed to handle LCT NOTIFY replies */
61struct i2o_exec_lct_notify_work {
62 struct work_struct work; /* work struct */
63 struct i2o_controller *c; /* controller on which the LCT NOTIFY
64 was received */
65};
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067/* Exec OSM class handling definition */
68static struct i2o_class_id i2o_exec_class_id[] = {
69 {I2O_CLASS_EXECUTIVE},
70 {I2O_CLASS_END}
71};
72
73/**
74 * i2o_exec_wait_alloc - Allocate a i2o_exec_wait struct an initialize it
75 *
76 * Allocate the i2o_exec_wait struct and initialize the wait.
77 *
78 * Returns i2o_exec_wait pointer on success or negative error code on
79 * failure.
80 */
81static struct i2o_exec_wait *i2o_exec_wait_alloc(void)
82{
83 struct i2o_exec_wait *wait;
84
Markus Lidelf6ed39a2006-01-06 00:19:33 -080085 wait = kzalloc(sizeof(*wait), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 if (!wait)
Markus Lidel793fd152006-01-06 00:19:30 -080087 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 INIT_LIST_HEAD(&wait->list);
90
91 return wait;
92};
93
94/**
95 * i2o_exec_wait_free - Free a i2o_exec_wait struct
96 * @i2o_exec_wait: I2O wait data which should be cleaned up
97 */
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
106 * @m: message to post
107 * @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{
125 DECLARE_WAIT_QUEUE_HEAD(wq);
126 struct i2o_exec_wait *wait;
127 static u32 tcntxt = 0x80000000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 int rc = 0;
129
130 wait = i2o_exec_wait_alloc();
131 if (!wait)
132 return -ENOMEM;
133
134 if (tcntxt == 0xffffffff)
135 tcntxt = 0x80000000;
136
137 if (dma)
138 wait->dma = *dma;
139
140 /*
141 * Fill in the message initiator context and transaction context.
142 * We will only use transaction contexts >= 0x80000000 for POST WAIT,
143 * so we could find a POST WAIT reply easier in the reply handler.
144 */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800145 msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 wait->tcntxt = tcntxt++;
Markus Lidela1a5ea72006-01-06 00:19:29 -0800147 msg->u.s.tcntxt = cpu_to_le32(wait->tcntxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149 /*
150 * Post the message to the controller. At some point later it will
151 * return. If we time out before it returns then complete will be zero.
152 */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800153 i2o_msg_post(c, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 if (!wait->complete) {
156 wait->wq = &wq;
157 /*
158 * we add elements add the head, because if a entry in the list
159 * will never be removed, we have to iterate over it every time
160 */
161 list_add(&wait->list, &i2o_exec_wait_list);
162
163 wait_event_interruptible_timeout(wq, wait->complete,
Markus Lidelf33213e2005-06-23 22:02:23 -0700164 timeout * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166 wait->wq = NULL;
167 }
168
169 barrier();
170
171 if (wait->complete) {
Markus Lidel9e875452005-06-23 22:02:21 -0700172 rc = le32_to_cpu(wait->msg->body[0]) >> 24;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 i2o_flush_reply(c, wait->m);
174 i2o_exec_wait_free(wait);
175 } else {
176 /*
177 * We cannot remove it now. This is important. When it does
178 * terminate (which it must do if the controller has not
179 * died...) then it will otherwise scribble on stuff.
180 *
181 * FIXME: try abort message
182 */
183 if (dma)
184 dma->virt = NULL;
185
186 rc = -ETIMEDOUT;
187 }
188
189 return rc;
190};
191
192/**
193 * i2o_msg_post_wait_complete - Reply to a i2o_msg_post request from IOP
194 * @c: I2O controller which answers
195 * @m: message id
196 * @msg: pointer to the I2O reply message
Markus Lidelf88e1192005-06-23 22:02:14 -0700197 * @context: transaction context of request
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 *
199 * This function is called in interrupt context only. If the reply reached
200 * before the timeout, the i2o_exec_wait struct is filled with the message
201 * and the task will be waked up. The task is now responsible for returning
202 * the message m back to the controller! If the message reaches us after
203 * the timeout clean up the i2o_exec_wait struct (including allocated
204 * DMA buffer).
205 *
206 * Return 0 on success and if the message m should not be given back to the
207 * I2O controller, or >0 on success and if the message should be given back
208 * afterwords. Returns negative error code on failure. In this case the
209 * message must also be given back to the controller.
210 */
211static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
Markus Lidel9e875452005-06-23 22:02:21 -0700212 struct i2o_message *msg, u32 context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
214 struct i2o_exec_wait *wait, *tmp;
Markus Lidelf10378f2005-06-23 22:02:16 -0700215 unsigned long flags;
Markus Lidel61fbfa82005-06-23 22:02:11 -0700216 static spinlock_t lock = SPIN_LOCK_UNLOCKED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 int rc = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
219 /*
220 * We need to search through the i2o_exec_wait_list to see if the given
221 * message is still outstanding. If not, it means that the IOP took
222 * longer to respond to the message than we had allowed and timer has
223 * already expired. Not much we can do about that except log it for
224 * debug purposes, increase timeout, and recompile.
225 */
Markus Lidelf10378f2005-06-23 22:02:16 -0700226 spin_lock_irqsave(&lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) {
228 if (wait->tcntxt == context) {
229 list_del(&wait->list);
230
Markus Lidelf10378f2005-06-23 22:02:16 -0700231 spin_unlock_irqrestore(&lock, flags);
232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 wait->m = m;
234 wait->msg = msg;
235 wait->complete = 1;
236
237 barrier();
238
239 if (wait->wq) {
240 wake_up_interruptible(wait->wq);
241 rc = 0;
242 } else {
243 struct device *dev;
244
245 dev = &c->pdev->dev;
246
247 pr_debug("%s: timedout reply received!\n",
248 c->name);
249 i2o_dma_free(dev, &wait->dma);
250 i2o_exec_wait_free(wait);
251 rc = -1;
252 }
253
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 return rc;
255 }
256 }
257
Markus Lidelf10378f2005-06-23 22:02:16 -0700258 spin_unlock_irqrestore(&lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Markus Lidelf88e1192005-06-23 22:02:14 -0700260 osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 context);
262
263 return -1;
264};
265
266/**
Markus Lidelf10378f2005-06-23 22:02:16 -0700267 * i2o_exec_show_vendor_id - Displays Vendor ID of controller
268 * @d: device of which the Vendor ID should be displayed
269 * @buf: buffer into which the Vendor ID should be printed
270 *
271 * Returns number of bytes printed into buffer.
272 */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800273static ssize_t i2o_exec_show_vendor_id(struct device *d,
274 struct device_attribute *attr, char *buf)
Markus Lidelf10378f2005-06-23 22:02:16 -0700275{
276 struct i2o_device *dev = to_i2o_device(d);
277 u16 id;
278
Markus Lidel793fd152006-01-06 00:19:30 -0800279 if (!i2o_parm_field_get(dev, 0x0000, 0, &id, 2)) {
280 sprintf(buf, "0x%04x", le16_to_cpu(id));
Markus Lidelf10378f2005-06-23 22:02:16 -0700281 return strlen(buf) + 1;
282 }
283
284 return 0;
285};
286
287/**
288 * i2o_exec_show_product_id - Displays Product ID of controller
289 * @d: device of which the Product ID should be displayed
290 * @buf: buffer into which the Product ID should be printed
291 *
292 * Returns number of bytes printed into buffer.
293 */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800294static ssize_t i2o_exec_show_product_id(struct device *d,
295 struct device_attribute *attr,
296 char *buf)
Markus Lidelf10378f2005-06-23 22:02:16 -0700297{
298 struct i2o_device *dev = to_i2o_device(d);
299 u16 id;
300
Markus Lidel793fd152006-01-06 00:19:30 -0800301 if (!i2o_parm_field_get(dev, 0x0000, 1, &id, 2)) {
302 sprintf(buf, "0x%04x", le16_to_cpu(id));
Markus Lidelf10378f2005-06-23 22:02:16 -0700303 return strlen(buf) + 1;
304 }
305
306 return 0;
307};
308
309/* Exec-OSM device attributes */
310static DEVICE_ATTR(vendor_id, S_IRUGO, i2o_exec_show_vendor_id, NULL);
311static DEVICE_ATTR(product_id, S_IRUGO, i2o_exec_show_product_id, NULL);
312
313/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 * i2o_exec_probe - Called if a new I2O device (executive class) appears
315 * @dev: I2O device which should be probed
316 *
317 * Registers event notification for every event from Executive device. The
318 * return is always 0, because we want all devices of class Executive.
319 *
320 * Returns 0 on success.
321 */
322static int i2o_exec_probe(struct device *dev)
323{
324 struct i2o_device *i2o_dev = to_i2o_device(dev);
Markus Lidelf10378f2005-06-23 22:02:16 -0700325 struct i2o_controller *c = i2o_dev->iop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff);
328
Markus Lidelf10378f2005-06-23 22:02:16 -0700329 c->exec = i2o_dev;
330
331 i2o_exec_lct_notify(c, c->lct->change_ind + 1);
332
333 device_create_file(dev, &dev_attr_vendor_id);
334 device_create_file(dev, &dev_attr_product_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
336 return 0;
337};
338
339/**
340 * i2o_exec_remove - Called on I2O device removal
341 * @dev: I2O device which was removed
342 *
343 * Unregisters event notification from Executive I2O device.
344 *
345 * Returns 0 on success.
346 */
347static int i2o_exec_remove(struct device *dev)
348{
Markus Lidelf10378f2005-06-23 22:02:16 -0700349 device_remove_file(dev, &dev_attr_product_id);
350 device_remove_file(dev, &dev_attr_vendor_id);
351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
353
354 return 0;
355};
356
357/**
358 * i2o_exec_lct_modified - Called on LCT NOTIFY reply
359 * @c: I2O controller on which the LCT has modified
360 *
361 * This function handles asynchronus LCT NOTIFY replies. It parses the
362 * new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY
Markus Lidelf10378f2005-06-23 22:02:16 -0700363 * again, otherwise send LCT NOTIFY to get informed on next LCT change.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 */
Vasily Averin071a6512006-03-05 23:18:14 +0100365static void i2o_exec_lct_modified(struct i2o_exec_lct_notify_work *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366{
Markus Lidelf10378f2005-06-23 22:02:16 -0700367 u32 change_ind = 0;
Vasily Averin071a6512006-03-05 23:18:14 +0100368 struct i2o_controller *c = work->c;
369
370 kfree(work);
Markus Lidelf10378f2005-06-23 22:02:16 -0700371
372 if (i2o_device_parse_lct(c) != -EAGAIN)
373 change_ind = c->lct->change_ind + 1;
374
Markus Lidel793fd152006-01-06 00:19:30 -0800375#ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES
Markus Lidelf10378f2005-06-23 22:02:16 -0700376 i2o_exec_lct_notify(c, change_ind);
Markus Lidel793fd152006-01-06 00:19:30 -0800377#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378};
379
380/**
381 * i2o_exec_reply - I2O Executive reply handler
382 * @c: I2O controller from which the reply comes
383 * @m: message id
384 * @msg: pointer to the I2O reply message
385 *
386 * This function is always called from interrupt context. If a POST WAIT
387 * reply was received, pass it to the complete function. If a LCT NOTIFY
388 * reply was received, a new event is created to handle the update.
389 *
390 * Returns 0 on success and if the reply should not be flushed or > 0
391 * on success and if the reply should be flushed. Returns negative error
392 * code on failure and if the reply should be flushed.
393 */
394static int i2o_exec_reply(struct i2o_controller *c, u32 m,
Markus Lidel9e875452005-06-23 22:02:21 -0700395 struct i2o_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396{
Markus Lidelf88e1192005-06-23 22:02:14 -0700397 u32 context;
398
Markus Lidel9e875452005-06-23 22:02:21 -0700399 if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) {
Markus Lidela1a5ea72006-01-06 00:19:29 -0800400 struct i2o_message __iomem *pmsg;
401 u32 pm;
402
Markus Lidelf88e1192005-06-23 22:02:14 -0700403 /*
404 * If Fail bit is set we must take the transaction context of
405 * the preserved message to find the right request again.
406 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
Markus Lidel9e875452005-06-23 22:02:21 -0700408 pm = le32_to_cpu(msg->body[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 pmsg = i2o_msg_in_to_virt(c, pm);
Markus Lidela1a5ea72006-01-06 00:19:29 -0800410 context = readl(&pmsg->u.s.tcntxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
412 i2o_report_status(KERN_INFO, "i2o_core", msg);
413
Markus Lidelf88e1192005-06-23 22:02:14 -0700414 /* Release the preserved msg */
Markus Lidela1a5ea72006-01-06 00:19:29 -0800415 i2o_msg_nop_mfa(c, pm);
Markus Lidelf88e1192005-06-23 22:02:14 -0700416 } else
Markus Lidel9e875452005-06-23 22:02:21 -0700417 context = le32_to_cpu(msg->u.s.tcntxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
Markus Lidelf88e1192005-06-23 22:02:14 -0700419 if (context & 0x80000000)
420 return i2o_msg_post_wait_complete(c, m, msg, context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
Markus Lidel9e875452005-06-23 22:02:21 -0700422 if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
Vasily Averin071a6512006-03-05 23:18:14 +0100423 struct i2o_exec_lct_notify_work *work;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
425 pr_debug("%s: LCT notify received\n", c->name);
426
427 work = kmalloc(sizeof(*work), GFP_ATOMIC);
428 if (!work)
429 return -ENOMEM;
430
Vasily Averin071a6512006-03-05 23:18:14 +0100431 work->c = c;
432
433 INIT_WORK(&work->work, (void (*)(void *))i2o_exec_lct_modified,
434 work);
435 queue_work(i2o_exec_driver.event_queue, &work->work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 return 1;
437 }
438
439 /*
440 * If this happens, we want to dump the message to the syslog so
441 * it can be sent back to the card manufacturer by the end user
442 * to aid in debugging.
443 *
444 */
445 printk(KERN_WARNING "%s: Unsolicited message reply sent to core!"
446 "Message dumped to syslog\n", c->name);
447 i2o_dump_message(msg);
448
449 return -EFAULT;
450}
451
452/**
453 * i2o_exec_event - Event handling function
454 * @evt: Event which occurs
455 *
456 * Handles events send by the Executive device. At the moment does not do
457 * anything useful.
458 */
459static void i2o_exec_event(struct i2o_event *evt)
460{
Markus Lidel9e875452005-06-23 22:02:21 -0700461 if (likely(evt->i2o_dev))
462 osm_debug("Event received from device: %d\n",
463 evt->i2o_dev->lct_data.tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 kfree(evt);
465};
466
467/**
468 * i2o_exec_lct_get - Get the IOP's Logical Configuration Table
469 * @c: I2O controller from which the LCT should be fetched
470 *
471 * Send a LCT NOTIFY request to the controller, and wait
472 * I2O_TIMEOUT_LCT_GET seconds until arrival of response. If the LCT is
473 * to large, retry it.
474 *
475 * Returns 0 on success or negative error code on failure.
476 */
477int i2o_exec_lct_get(struct i2o_controller *c)
478{
Markus Lidela1a5ea72006-01-06 00:19:29 -0800479 struct i2o_message *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 int i = 0;
481 int rc = -EAGAIN;
482
483 for (i = 1; i <= I2O_LCT_GET_TRIES; i++) {
Markus Lidela1a5ea72006-01-06 00:19:29 -0800484 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
485 if (IS_ERR(msg))
486 return PTR_ERR(msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Markus Lidela1a5ea72006-01-06 00:19:29 -0800488 msg->u.head[0] =
489 cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
490 msg->u.head[1] =
491 cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
492 ADAPTER_TID);
493 msg->body[0] = cpu_to_le32(0xffffffff);
494 msg->body[1] = cpu_to_le32(0x00000000);
495 msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
496 msg->body[3] = cpu_to_le32(c->dlct.phys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Markus Lidela1a5ea72006-01-06 00:19:29 -0800498 rc = i2o_msg_post_wait(c, msg, I2O_TIMEOUT_LCT_GET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 if (rc < 0)
500 break;
501
502 rc = i2o_device_parse_lct(c);
503 if (rc != -EAGAIN)
504 break;
505 }
506
507 return rc;
508}
509
510/**
511 * i2o_exec_lct_notify - Send a asynchronus LCT NOTIFY request
512 * @c: I2O controller to which the request should be send
513 * @change_ind: change indicator
514 *
515 * This function sends a LCT NOTIFY request to the I2O controller with
516 * the change indicator change_ind. If the change_ind == 0 the controller
517 * replies immediately after the request. If change_ind > 0 the reply is
518 * send after change indicator of the LCT is > change_ind.
519 */
520static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind)
521{
522 i2o_status_block *sb = c->status_block.virt;
523 struct device *dev;
Markus Lidela1a5ea72006-01-06 00:19:29 -0800524 struct i2o_message *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
526 dev = &c->pdev->dev;
527
Markus Lidel793fd152006-01-06 00:19:30 -0800528 if (i2o_dma_realloc
529 (dev, &c->dlct, le32_to_cpu(sb->expected_lct_size), GFP_KERNEL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 return -ENOMEM;
531
Markus Lidela1a5ea72006-01-06 00:19:29 -0800532 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
533 if (IS_ERR(msg))
534 return PTR_ERR(msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
Markus Lidela1a5ea72006-01-06 00:19:29 -0800536 msg->u.head[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
537 msg->u.head[1] = cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
538 ADAPTER_TID);
539 msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
540 msg->u.s.tcntxt = cpu_to_le32(0x00000000);
541 msg->body[0] = cpu_to_le32(0xffffffff);
542 msg->body[1] = cpu_to_le32(change_ind);
543 msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
544 msg->body[3] = cpu_to_le32(c->dlct.phys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
Markus Lidela1a5ea72006-01-06 00:19:29 -0800546 i2o_msg_post(c, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
548 return 0;
549};
550
551/* Exec OSM driver struct */
552struct i2o_driver i2o_exec_driver = {
553 .name = OSM_NAME,
554 .reply = i2o_exec_reply,
555 .event = i2o_exec_event,
556 .classes = i2o_exec_class_id,
557 .driver = {
558 .probe = i2o_exec_probe,
559 .remove = i2o_exec_remove,
560 },
561};
562
563/**
564 * i2o_exec_init - Registers the Exec OSM
565 *
566 * Registers the Exec OSM in the I2O core.
567 *
568 * Returns 0 on success or negative error code on failure.
569 */
570int __init i2o_exec_init(void)
571{
572 return i2o_driver_register(&i2o_exec_driver);
573};
574
575/**
576 * i2o_exec_exit - Removes the Exec OSM
577 *
578 * Unregisters the Exec OSM from the I2O core.
579 */
580void __exit i2o_exec_exit(void)
581{
582 i2o_driver_unregister(&i2o_exec_driver);
583};
584
585EXPORT_SYMBOL(i2o_msg_post_wait_mem);
586EXPORT_SYMBOL(i2o_exec_lct_get);