blob: bda2c62648bac566529ccdbdd32f82bc33f1d7ca [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>
Markus Lidel9e875452005-06-23 22:02:21 -070033#include "core.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35#define OSM_NAME "exec-osm"
36
37struct i2o_driver i2o_exec_driver;
38
39static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind);
40
Linus Torvalds1da177e2005-04-16 15:20:36 -070041/* global wait list for POST WAIT */
42static LIST_HEAD(i2o_exec_wait_list);
43
44/* Wait struct needed for POST WAIT */
45struct 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 */
Markus Lidel9e875452005-06-23 22:02:21 -070051 struct i2o_message *msg; /* pointer to the reply message */
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 struct list_head list; /* node in global wait list */
53};
54
55/* Exec OSM class handling definition */
56static struct i2o_class_id i2o_exec_class_id[] = {
57 {I2O_CLASS_EXECUTIVE},
58 {I2O_CLASS_END}
59};
60
61/**
62 * i2o_exec_wait_alloc - Allocate a i2o_exec_wait struct an initialize it
63 *
64 * Allocate the i2o_exec_wait struct and initialize the wait.
65 *
66 * Returns i2o_exec_wait pointer on success or negative error code on
67 * failure.
68 */
69static struct i2o_exec_wait *i2o_exec_wait_alloc(void)
70{
71 struct i2o_exec_wait *wait;
72
73 wait = kmalloc(sizeof(*wait), GFP_KERNEL);
74 if (!wait)
75 return ERR_PTR(-ENOMEM);
76
77 memset(wait, 0, sizeof(*wait));
78
79 INIT_LIST_HEAD(&wait->list);
80
81 return wait;
82};
83
84/**
85 * i2o_exec_wait_free - Free a i2o_exec_wait struct
86 * @i2o_exec_wait: I2O wait data which should be cleaned up
87 */
88static void i2o_exec_wait_free(struct i2o_exec_wait *wait)
89{
90 kfree(wait);
91};
92
93/**
94 * i2o_msg_post_wait_mem - Post and wait a message with DMA buffers
95 * @c: controller
96 * @m: message to post
97 * @timeout: time in seconds to wait
98 * @dma: i2o_dma struct of the DMA buffer to free on failure
99 *
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.
108 *
Markus Lidelf88e1192005-06-23 22:02:14 -0700109 * Returns 0 on success, negative error code on timeout or positive error
110 * code from reply.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 */
112int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
113 timeout, struct i2o_dma *dma)
114{
115 DECLARE_WAIT_QUEUE_HEAD(wq);
116 struct i2o_exec_wait *wait;
117 static u32 tcntxt = 0x80000000;
Markus Lidelf88e1192005-06-23 22:02:14 -0700118 struct i2o_message __iomem *msg = i2o_msg_in_to_virt(c, m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 int rc = 0;
120
121 wait = i2o_exec_wait_alloc();
122 if (!wait)
123 return -ENOMEM;
124
125 if (tcntxt == 0xffffffff)
126 tcntxt = 0x80000000;
127
128 if (dma)
129 wait->dma = *dma;
130
131 /*
132 * Fill in the message initiator context and transaction context.
133 * We will only use transaction contexts >= 0x80000000 for POST WAIT,
134 * so we could find a POST WAIT reply easier in the reply handler.
135 */
136 writel(i2o_exec_driver.context, &msg->u.s.icntxt);
137 wait->tcntxt = tcntxt++;
138 writel(wait->tcntxt, &msg->u.s.tcntxt);
139
140 /*
141 * Post the message to the controller. At some point later it will
142 * return. If we time out before it returns then complete will be zero.
143 */
144 i2o_msg_post(c, m);
145
146 if (!wait->complete) {
147 wait->wq = &wq;
148 /*
149 * we add elements add the head, because if a entry in the list
150 * will never be removed, we have to iterate over it every time
151 */
152 list_add(&wait->list, &i2o_exec_wait_list);
153
154 wait_event_interruptible_timeout(wq, wait->complete,
Markus Lidelf33213e2005-06-23 22:02:23 -0700155 timeout * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 wait->wq = NULL;
158 }
159
160 barrier();
161
162 if (wait->complete) {
Markus Lidel9e875452005-06-23 22:02:21 -0700163 rc = le32_to_cpu(wait->msg->body[0]) >> 24;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 i2o_flush_reply(c, wait->m);
165 i2o_exec_wait_free(wait);
166 } else {
167 /*
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.
171 *
172 * FIXME: try abort message
173 */
174 if (dma)
175 dma->virt = NULL;
176
177 rc = -ETIMEDOUT;
178 }
179
180 return rc;
181};
182
183/**
184 * i2o_msg_post_wait_complete - Reply to a i2o_msg_post request from IOP
185 * @c: I2O controller which answers
186 * @m: message id
187 * @msg: pointer to the I2O reply message
Markus Lidelf88e1192005-06-23 22:02:14 -0700188 * @context: transaction context of request
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 *
190 * This function is called in interrupt context only. If the reply reached
191 * before the timeout, the i2o_exec_wait struct is filled with the message
192 * and the task will be waked up. The task is now responsible for returning
193 * the message m back to the controller! If the message reaches us after
194 * the timeout clean up the i2o_exec_wait struct (including allocated
195 * DMA buffer).
196 *
197 * Return 0 on success and if the message m should not be given back to the
198 * I2O controller, or >0 on success and if the message should be given back
199 * afterwords. Returns negative error code on failure. In this case the
200 * message must also be given back to the controller.
201 */
202static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
Markus Lidel9e875452005-06-23 22:02:21 -0700203 struct i2o_message *msg, u32 context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204{
205 struct i2o_exec_wait *wait, *tmp;
Markus Lidelf10378f2005-06-23 22:02:16 -0700206 unsigned long flags;
Markus Lidel61fbfa82005-06-23 22:02:11 -0700207 static spinlock_t lock = SPIN_LOCK_UNLOCKED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 int rc = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
210 /*
211 * We need to search through the i2o_exec_wait_list to see if the given
212 * message is still outstanding. If not, it means that the IOP took
213 * longer to respond to the message than we had allowed and timer has
214 * already expired. Not much we can do about that except log it for
215 * debug purposes, increase timeout, and recompile.
216 */
Markus Lidelf10378f2005-06-23 22:02:16 -0700217 spin_lock_irqsave(&lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) {
219 if (wait->tcntxt == context) {
220 list_del(&wait->list);
221
Markus Lidelf10378f2005-06-23 22:02:16 -0700222 spin_unlock_irqrestore(&lock, flags);
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 wait->m = m;
225 wait->msg = msg;
226 wait->complete = 1;
227
228 barrier();
229
230 if (wait->wq) {
231 wake_up_interruptible(wait->wq);
232 rc = 0;
233 } else {
234 struct device *dev;
235
236 dev = &c->pdev->dev;
237
238 pr_debug("%s: timedout reply received!\n",
239 c->name);
240 i2o_dma_free(dev, &wait->dma);
241 i2o_exec_wait_free(wait);
242 rc = -1;
243 }
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 return rc;
246 }
247 }
248
Markus Lidelf10378f2005-06-23 22:02:16 -0700249 spin_unlock_irqrestore(&lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
Markus Lidelf88e1192005-06-23 22:02:14 -0700251 osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 context);
253
254 return -1;
255};
256
257/**
Markus Lidelf10378f2005-06-23 22:02:16 -0700258 * i2o_exec_show_vendor_id - Displays Vendor ID of controller
259 * @d: device of which the Vendor ID should be displayed
260 * @buf: buffer into which the Vendor ID should be printed
261 *
262 * Returns number of bytes printed into buffer.
263 */
Yani Ioannou3e05d2b2005-06-23 22:02:28 -0700264static ssize_t i2o_exec_show_vendor_id(struct device *d, struct device_attribute *attr, char *buf)
Markus Lidelf10378f2005-06-23 22:02:16 -0700265{
266 struct i2o_device *dev = to_i2o_device(d);
267 u16 id;
268
269 if (i2o_parm_field_get(dev, 0x0000, 0, &id, 2)) {
270 sprintf(buf, "0x%04x", id);
271 return strlen(buf) + 1;
272 }
273
274 return 0;
275};
276
277/**
278 * i2o_exec_show_product_id - Displays Product ID of controller
279 * @d: device of which the Product ID should be displayed
280 * @buf: buffer into which the Product ID should be printed
281 *
282 * Returns number of bytes printed into buffer.
283 */
Yani Ioannou3e05d2b2005-06-23 22:02:28 -0700284static ssize_t i2o_exec_show_product_id(struct device *d, struct device_attribute *attr, char *buf)
Markus Lidelf10378f2005-06-23 22:02:16 -0700285{
286 struct i2o_device *dev = to_i2o_device(d);
287 u16 id;
288
289 if (i2o_parm_field_get(dev, 0x0000, 1, &id, 2)) {
290 sprintf(buf, "0x%04x", id);
291 return strlen(buf) + 1;
292 }
293
294 return 0;
295};
296
297/* Exec-OSM device attributes */
298static DEVICE_ATTR(vendor_id, S_IRUGO, i2o_exec_show_vendor_id, NULL);
299static DEVICE_ATTR(product_id, S_IRUGO, i2o_exec_show_product_id, NULL);
300
301/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 * i2o_exec_probe - Called if a new I2O device (executive class) appears
303 * @dev: I2O device which should be probed
304 *
305 * Registers event notification for every event from Executive device. The
306 * return is always 0, because we want all devices of class Executive.
307 *
308 * Returns 0 on success.
309 */
310static int i2o_exec_probe(struct device *dev)
311{
312 struct i2o_device *i2o_dev = to_i2o_device(dev);
Markus Lidelf10378f2005-06-23 22:02:16 -0700313 struct i2o_controller *c = i2o_dev->iop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
315 i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff);
316
Markus Lidelf10378f2005-06-23 22:02:16 -0700317 c->exec = i2o_dev;
318
319 i2o_exec_lct_notify(c, c->lct->change_ind + 1);
320
321 device_create_file(dev, &dev_attr_vendor_id);
322 device_create_file(dev, &dev_attr_product_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
324 return 0;
325};
326
327/**
328 * i2o_exec_remove - Called on I2O device removal
329 * @dev: I2O device which was removed
330 *
331 * Unregisters event notification from Executive I2O device.
332 *
333 * Returns 0 on success.
334 */
335static int i2o_exec_remove(struct device *dev)
336{
Markus Lidelf10378f2005-06-23 22:02:16 -0700337 device_remove_file(dev, &dev_attr_product_id);
338 device_remove_file(dev, &dev_attr_vendor_id);
339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
341
342 return 0;
343};
344
345/**
346 * i2o_exec_lct_modified - Called on LCT NOTIFY reply
347 * @c: I2O controller on which the LCT has modified
348 *
349 * This function handles asynchronus LCT NOTIFY replies. It parses the
350 * new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY
Markus Lidelf10378f2005-06-23 22:02:16 -0700351 * again, otherwise send LCT NOTIFY to get informed on next LCT change.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 */
353static void i2o_exec_lct_modified(struct i2o_controller *c)
354{
Markus Lidelf10378f2005-06-23 22:02:16 -0700355 u32 change_ind = 0;
356
357 if (i2o_device_parse_lct(c) != -EAGAIN)
358 change_ind = c->lct->change_ind + 1;
359
360 i2o_exec_lct_notify(c, change_ind);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361};
362
363/**
364 * i2o_exec_reply - I2O Executive reply handler
365 * @c: I2O controller from which the reply comes
366 * @m: message id
367 * @msg: pointer to the I2O reply message
368 *
369 * This function is always called from interrupt context. If a POST WAIT
370 * reply was received, pass it to the complete function. If a LCT NOTIFY
371 * reply was received, a new event is created to handle the update.
372 *
373 * Returns 0 on success and if the reply should not be flushed or > 0
374 * on success and if the reply should be flushed. Returns negative error
375 * code on failure and if the reply should be flushed.
376 */
377static int i2o_exec_reply(struct i2o_controller *c, u32 m,
Markus Lidel9e875452005-06-23 22:02:21 -0700378 struct i2o_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
Markus Lidelf88e1192005-06-23 22:02:14 -0700380 u32 context;
381
Markus Lidel9e875452005-06-23 22:02:21 -0700382 if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) {
Markus Lidelf88e1192005-06-23 22:02:14 -0700383 /*
384 * If Fail bit is set we must take the transaction context of
385 * the preserved message to find the right request again.
386 */
387 struct i2o_message __iomem *pmsg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 u32 pm;
389
Markus Lidel9e875452005-06-23 22:02:21 -0700390 pm = le32_to_cpu(msg->body[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
392 pmsg = i2o_msg_in_to_virt(c, pm);
393
394 i2o_report_status(KERN_INFO, "i2o_core", msg);
395
Markus Lidelf88e1192005-06-23 22:02:14 -0700396 context = readl(&pmsg->u.s.tcntxt);
397
398 /* Release the preserved msg */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 i2o_msg_nop(c, pm);
Markus Lidelf88e1192005-06-23 22:02:14 -0700400 } else
Markus Lidel9e875452005-06-23 22:02:21 -0700401 context = le32_to_cpu(msg->u.s.tcntxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Markus Lidelf88e1192005-06-23 22:02:14 -0700403 if (context & 0x80000000)
404 return i2o_msg_post_wait_complete(c, m, msg, context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
Markus Lidel9e875452005-06-23 22:02:21 -0700406 if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 struct work_struct *work;
408
409 pr_debug("%s: LCT notify received\n", c->name);
410
411 work = kmalloc(sizeof(*work), GFP_ATOMIC);
412 if (!work)
413 return -ENOMEM;
414
415 INIT_WORK(work, (void (*)(void *))i2o_exec_lct_modified, c);
416 queue_work(i2o_exec_driver.event_queue, work);
417 return 1;
418 }
419
420 /*
421 * If this happens, we want to dump the message to the syslog so
422 * it can be sent back to the card manufacturer by the end user
423 * to aid in debugging.
424 *
425 */
426 printk(KERN_WARNING "%s: Unsolicited message reply sent to core!"
427 "Message dumped to syslog\n", c->name);
428 i2o_dump_message(msg);
429
430 return -EFAULT;
431}
432
433/**
434 * i2o_exec_event - Event handling function
435 * @evt: Event which occurs
436 *
437 * Handles events send by the Executive device. At the moment does not do
438 * anything useful.
439 */
440static void i2o_exec_event(struct i2o_event *evt)
441{
Markus Lidel9e875452005-06-23 22:02:21 -0700442 if (likely(evt->i2o_dev))
443 osm_debug("Event received from device: %d\n",
444 evt->i2o_dev->lct_data.tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 kfree(evt);
446};
447
448/**
449 * i2o_exec_lct_get - Get the IOP's Logical Configuration Table
450 * @c: I2O controller from which the LCT should be fetched
451 *
452 * Send a LCT NOTIFY request to the controller, and wait
453 * I2O_TIMEOUT_LCT_GET seconds until arrival of response. If the LCT is
454 * to large, retry it.
455 *
456 * Returns 0 on success or negative error code on failure.
457 */
458int i2o_exec_lct_get(struct i2o_controller *c)
459{
460 struct i2o_message __iomem *msg;
461 u32 m;
462 int i = 0;
463 int rc = -EAGAIN;
464
465 for (i = 1; i <= I2O_LCT_GET_TRIES; i++) {
466 m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
467 if (m == I2O_QUEUE_EMPTY)
468 return -ETIMEDOUT;
469
470 writel(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6, &msg->u.head[0]);
471 writel(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 | ADAPTER_TID,
472 &msg->u.head[1]);
473 writel(0xffffffff, &msg->body[0]);
474 writel(0x00000000, &msg->body[1]);
475 writel(0xd0000000 | c->dlct.len, &msg->body[2]);
476 writel(c->dlct.phys, &msg->body[3]);
477
478 rc = i2o_msg_post_wait(c, m, I2O_TIMEOUT_LCT_GET);
479 if (rc < 0)
480 break;
481
482 rc = i2o_device_parse_lct(c);
483 if (rc != -EAGAIN)
484 break;
485 }
486
487 return rc;
488}
489
490/**
491 * i2o_exec_lct_notify - Send a asynchronus LCT NOTIFY request
492 * @c: I2O controller to which the request should be send
493 * @change_ind: change indicator
494 *
495 * This function sends a LCT NOTIFY request to the I2O controller with
496 * the change indicator change_ind. If the change_ind == 0 the controller
497 * replies immediately after the request. If change_ind > 0 the reply is
498 * send after change indicator of the LCT is > change_ind.
499 */
500static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind)
501{
502 i2o_status_block *sb = c->status_block.virt;
503 struct device *dev;
504 struct i2o_message __iomem *msg;
505 u32 m;
506
507 dev = &c->pdev->dev;
508
509 if (i2o_dma_realloc(dev, &c->dlct, sb->expected_lct_size, GFP_KERNEL))
510 return -ENOMEM;
511
512 m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
513 if (m == I2O_QUEUE_EMPTY)
514 return -ETIMEDOUT;
515
516 writel(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6, &msg->u.head[0]);
517 writel(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 | ADAPTER_TID,
518 &msg->u.head[1]);
519 writel(i2o_exec_driver.context, &msg->u.s.icntxt);
520 writel(0, &msg->u.s.tcntxt); /* FIXME */
521 writel(0xffffffff, &msg->body[0]);
522 writel(change_ind, &msg->body[1]);
523 writel(0xd0000000 | c->dlct.len, &msg->body[2]);
524 writel(c->dlct.phys, &msg->body[3]);
525
526 i2o_msg_post(c, m);
527
528 return 0;
529};
530
531/* Exec OSM driver struct */
532struct i2o_driver i2o_exec_driver = {
533 .name = OSM_NAME,
534 .reply = i2o_exec_reply,
535 .event = i2o_exec_event,
536 .classes = i2o_exec_class_id,
537 .driver = {
538 .probe = i2o_exec_probe,
539 .remove = i2o_exec_remove,
540 },
541};
542
543/**
544 * i2o_exec_init - Registers the Exec OSM
545 *
546 * Registers the Exec OSM in the I2O core.
547 *
548 * Returns 0 on success or negative error code on failure.
549 */
550int __init i2o_exec_init(void)
551{
552 return i2o_driver_register(&i2o_exec_driver);
553};
554
555/**
556 * i2o_exec_exit - Removes the Exec OSM
557 *
558 * Unregisters the Exec OSM from the I2O core.
559 */
560void __exit i2o_exec_exit(void)
561{
562 i2o_driver_unregister(&i2o_exec_driver);
563};
564
565EXPORT_SYMBOL(i2o_msg_post_wait_mem);
566EXPORT_SYMBOL(i2o_exec_lct_get);