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