[PATCH] kernel-doc: fix fusion and i2o docs
[linux-2.6.git] / 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         spinlock_t lock;        /* lock before modifying */
59 };
60
61 /* Work struct needed to handle LCT NOTIFY replies */
62 struct i2o_exec_lct_notify_work {
63         struct work_struct work;        /* work struct */
64         struct i2o_controller *c;       /* controller on which the LCT NOTIFY
65                                            was received */
66 };
67
68 /* Exec OSM class handling definition */
69 static struct i2o_class_id i2o_exec_class_id[] = {
70         {I2O_CLASS_EXECUTIVE},
71         {I2O_CLASS_END}
72 };
73
74 /**
75  *      i2o_exec_wait_alloc - Allocate a i2o_exec_wait struct an initialize it
76  *
77  *      Allocate the i2o_exec_wait struct and initialize the wait.
78  *
79  *      Returns i2o_exec_wait pointer on success or negative error code on
80  *      failure.
81  */
82 static struct i2o_exec_wait *i2o_exec_wait_alloc(void)
83 {
84         struct i2o_exec_wait *wait;
85
86         wait = kzalloc(sizeof(*wait), GFP_KERNEL);
87         if (!wait)
88                 return NULL;
89
90         INIT_LIST_HEAD(&wait->list);
91         spin_lock_init(&wait->lock);
92
93         return wait;
94 };
95
96 /**
97  *      i2o_exec_wait_free - Free an i2o_exec_wait struct
98  *      @wait: I2O wait data which should be cleaned up
99  */
100 static void i2o_exec_wait_free(struct i2o_exec_wait *wait)
101 {
102         kfree(wait);
103 };
104
105 /**
106  *      i2o_msg_post_wait_mem - Post and wait a message with DMA buffers
107  *      @c: controller
108  *      @msg: message to post
109  *      @timeout: time in seconds to wait
110  *      @dma: i2o_dma struct of the DMA buffer to free on failure
111  *
112  *      This API allows an OSM to post a message and then be told whether or
113  *      not the system received a successful reply. If the message times out
114  *      then the value '-ETIMEDOUT' is returned. This is a special case. In
115  *      this situation the message may (should) complete at an indefinite time
116  *      in the future. When it completes it will use the memory buffer
117  *      attached to the request. If -ETIMEDOUT is returned then the memory
118  *      buffer must not be freed. Instead the event completion will free them
119  *      for you. In all other cases the buffer are your problem.
120  *
121  *      Returns 0 on success, negative error code on timeout or positive error
122  *      code from reply.
123  */
124 int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg,
125                           unsigned long timeout, struct i2o_dma *dma)
126 {
127         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
128         struct i2o_exec_wait *wait;
129         static u32 tcntxt = 0x80000000;
130         unsigned long flags;
131         int rc = 0;
132
133         wait = i2o_exec_wait_alloc();
134         if (!wait)
135                 return -ENOMEM;
136
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          */
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);
151
152         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
159         /*
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          */
163         i2o_msg_post(c, msg);
164
165         wait_event_interruptible_timeout(wq, wait->complete, timeout * HZ);
166
167         spin_lock_irqsave(&wait->lock, flags);
168
169         wait->wq = NULL;
170
171         if (wait->complete)
172                 rc = le32_to_cpu(wait->msg->body[0]) >> 24;
173         else {
174                 /*
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
187         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
194         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
202  *      @context: transaction context of request
203  *
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  */
216 static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
217                                       struct i2o_message *msg, u32 context)
218 {
219         struct i2o_exec_wait *wait, *tmp;
220         unsigned long flags;
221         int rc = 1;
222
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          */
230         list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) {
231                 if (wait->tcntxt == context) {
232                         spin_lock_irqsave(&wait->lock, flags);
233
234                         list_del(&wait->list);
235
236                         wait->m = m;
237                         wait->msg = msg;
238                         wait->complete = 1;
239
240                         if (wait->wq)
241                                 rc = 0;
242                         else
243                                 rc = -1;
244
245                         spin_unlock_irqrestore(&wait->lock, flags);
246
247                         if (rc) {
248                                 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);
256                         } else
257                                 wake_up_interruptible(wait->wq);
258
259                         return rc;
260                 }
261         }
262
263         osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
264                  context);
265
266         return -1;
267 };
268
269 /**
270  *      i2o_exec_show_vendor_id - Displays Vendor ID of controller
271  *      @d: device of which the Vendor ID should be displayed
272  *      @attr: device_attribute to display
273  *      @buf: buffer into which the Vendor ID should be printed
274  *
275  *      Returns number of bytes printed into buffer.
276  */
277 static ssize_t i2o_exec_show_vendor_id(struct device *d,
278                                        struct device_attribute *attr, char *buf)
279 {
280         struct i2o_device *dev = to_i2o_device(d);
281         u16 id;
282
283         if (!i2o_parm_field_get(dev, 0x0000, 0, &id, 2)) {
284                 sprintf(buf, "0x%04x", le16_to_cpu(id));
285                 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
294  *      @attr: device_attribute to display
295  *      @buf: buffer into which the Product ID should be printed
296  *
297  *      Returns number of bytes printed into buffer.
298  */
299 static ssize_t i2o_exec_show_product_id(struct device *d,
300                                         struct device_attribute *attr,
301                                         char *buf)
302 {
303         struct i2o_device *dev = to_i2o_device(d);
304         u16 id;
305
306         if (!i2o_parm_field_get(dev, 0x0000, 1, &id, 2)) {
307                 sprintf(buf, "0x%04x", le16_to_cpu(id));
308                 return strlen(buf) + 1;
309         }
310
311         return 0;
312 };
313
314 /* Exec-OSM device attributes */
315 static DEVICE_ATTR(vendor_id, S_IRUGO, i2o_exec_show_vendor_id, NULL);
316 static DEVICE_ATTR(product_id, S_IRUGO, i2o_exec_show_product_id, NULL);
317
318 /**
319  *      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  */
327 static int i2o_exec_probe(struct device *dev)
328 {
329         struct i2o_device *i2o_dev = to_i2o_device(dev);
330         int rc;
331
332         rc = i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff);
333         if (rc) goto err_out;
334
335         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;
339
340         return 0;
341
342 err_vid:
343         device_remove_file(dev, &dev_attr_vendor_id);
344 err_evtreg:
345         i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
346 err_out:
347         return rc;
348 };
349
350 /**
351  *      i2o_exec_remove - Called on I2O device removal
352  *      @dev: I2O device which was removed
353  *
354  *      Unregisters event notification from Executive I2O device.
355  *
356  *      Returns 0 on success.
357  */
358 static int i2o_exec_remove(struct device *dev)
359 {
360         device_remove_file(dev, &dev_attr_product_id);
361         device_remove_file(dev, &dev_attr_vendor_id);
362
363         i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
364
365         return 0;
366 };
367
368 /**
369  *      i2o_exec_lct_modified - Called on LCT NOTIFY reply
370  *      @work: work struct for a specific controller
371  *
372  *      This function handles asynchronus LCT NOTIFY replies. It parses the
373  *      new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY
374  *      again, otherwise send LCT NOTIFY to get informed on next LCT change.
375  */
376 static void i2o_exec_lct_modified(struct work_struct *_work)
377 {
378         struct i2o_exec_lct_notify_work *work =
379                 container_of(_work, struct i2o_exec_lct_notify_work, work);
380         u32 change_ind = 0;
381         struct i2o_controller *c = work->c;
382
383         kfree(work);
384
385         if (i2o_device_parse_lct(c) != -EAGAIN)
386                 change_ind = c->lct->change_ind + 1;
387
388 #ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES
389         i2o_exec_lct_notify(c, change_ind);
390 #endif
391 };
392
393 /**
394  *      i2o_exec_reply -  I2O Executive reply handler
395  *      @c: I2O controller from which the reply comes
396  *      @m: message id
397  *      @msg: pointer to the I2O reply message
398  *
399  *      This function is always called from interrupt context. If a POST WAIT
400  *      reply was received, pass it to the complete function. If a LCT NOTIFY
401  *      reply was received, a new event is created to handle the update.
402  *
403  *      Returns 0 on success and if the reply should not be flushed or > 0
404  *      on success and if the reply should be flushed. Returns negative error
405  *      code on failure and if the reply should be flushed.
406  */
407 static int i2o_exec_reply(struct i2o_controller *c, u32 m,
408                           struct i2o_message *msg)
409 {
410         u32 context;
411
412         if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) {
413                 struct i2o_message __iomem *pmsg;
414                 u32 pm;
415
416                 /*
417                  * If Fail bit is set we must take the transaction context of
418                  * the preserved message to find the right request again.
419                  */
420
421                 pm = le32_to_cpu(msg->body[3]);
422                 pmsg = i2o_msg_in_to_virt(c, pm);
423                 context = readl(&pmsg->u.s.tcntxt);
424
425                 i2o_report_status(KERN_INFO, "i2o_core", msg);
426
427                 /* Release the preserved msg */
428                 i2o_msg_nop_mfa(c, pm);
429         } else
430                 context = le32_to_cpu(msg->u.s.tcntxt);
431
432         if (context & 0x80000000)
433                 return i2o_msg_post_wait_complete(c, m, msg, context);
434
435         if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
436                 struct i2o_exec_lct_notify_work *work;
437
438                 pr_debug("%s: LCT notify received\n", c->name);
439
440                 work = kmalloc(sizeof(*work), GFP_ATOMIC);
441                 if (!work)
442                         return -ENOMEM;
443
444                 work->c = c;
445
446                 INIT_WORK(&work->work, i2o_exec_lct_modified);
447                 queue_work(i2o_exec_driver.event_queue, &work->work);
448                 return 1;
449         }
450
451         /*
452          * If this happens, we want to dump the message to the syslog so
453          * it can be sent back to the card manufacturer by the end user
454          * to aid in debugging.
455          *
456          */
457         printk(KERN_WARNING "%s: Unsolicited message reply sent to core!"
458                "Message dumped to syslog\n", c->name);
459         i2o_dump_message(msg);
460
461         return -EFAULT;
462 }
463
464 /**
465  *      i2o_exec_event - Event handling function
466  *      @work: Work item in occurring event
467  *
468  *      Handles events send by the Executive device. At the moment does not do
469  *      anything useful.
470  */
471 static void i2o_exec_event(struct work_struct *work)
472 {
473         struct i2o_event *evt = container_of(work, struct i2o_event, work);
474
475         if (likely(evt->i2o_dev))
476                 osm_debug("Event received from device: %d\n",
477                           evt->i2o_dev->lct_data.tid);
478         kfree(evt);
479 };
480
481 /**
482  *      i2o_exec_lct_get - Get the IOP's Logical Configuration Table
483  *      @c: I2O controller from which the LCT should be fetched
484  *
485  *      Send a LCT NOTIFY request to the controller, and wait
486  *      I2O_TIMEOUT_LCT_GET seconds until arrival of response. If the LCT is
487  *      to large, retry it.
488  *
489  *      Returns 0 on success or negative error code on failure.
490  */
491 int i2o_exec_lct_get(struct i2o_controller *c)
492 {
493         struct i2o_message *msg;
494         int i = 0;
495         int rc = -EAGAIN;
496
497         for (i = 1; i <= I2O_LCT_GET_TRIES; i++) {
498                 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
499                 if (IS_ERR(msg))
500                         return PTR_ERR(msg);
501
502                 msg->u.head[0] =
503                     cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
504                 msg->u.head[1] =
505                     cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
506                                 ADAPTER_TID);
507                 msg->body[0] = cpu_to_le32(0xffffffff);
508                 msg->body[1] = cpu_to_le32(0x00000000);
509                 msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
510                 msg->body[3] = cpu_to_le32(c->dlct.phys);
511
512                 rc = i2o_msg_post_wait(c, msg, I2O_TIMEOUT_LCT_GET);
513                 if (rc < 0)
514                         break;
515
516                 rc = i2o_device_parse_lct(c);
517                 if (rc != -EAGAIN)
518                         break;
519         }
520
521         return rc;
522 }
523
524 /**
525  *      i2o_exec_lct_notify - Send a asynchronus LCT NOTIFY request
526  *      @c: I2O controller to which the request should be send
527  *      @change_ind: change indicator
528  *
529  *      This function sends a LCT NOTIFY request to the I2O controller with
530  *      the change indicator change_ind. If the change_ind == 0 the controller
531  *      replies immediately after the request. If change_ind > 0 the reply is
532  *      send after change indicator of the LCT is > change_ind.
533  */
534 static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind)
535 {
536         i2o_status_block *sb = c->status_block.virt;
537         struct device *dev;
538         struct i2o_message *msg;
539
540         down(&c->lct_lock);
541
542         dev = &c->pdev->dev;
543
544         if (i2o_dma_realloc
545             (dev, &c->dlct, le32_to_cpu(sb->expected_lct_size), GFP_KERNEL))
546                 return -ENOMEM;
547
548         msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
549         if (IS_ERR(msg))
550                 return PTR_ERR(msg);
551
552         msg->u.head[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
553         msg->u.head[1] = cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
554                                      ADAPTER_TID);
555         msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
556         msg->u.s.tcntxt = cpu_to_le32(0x00000000);
557         msg->body[0] = cpu_to_le32(0xffffffff);
558         msg->body[1] = cpu_to_le32(change_ind);
559         msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
560         msg->body[3] = cpu_to_le32(c->dlct.phys);
561
562         i2o_msg_post(c, msg);
563
564         up(&c->lct_lock);
565
566         return 0;
567 };
568
569 /* Exec OSM driver struct */
570 struct i2o_driver i2o_exec_driver = {
571         .name = OSM_NAME,
572         .reply = i2o_exec_reply,
573         .event = i2o_exec_event,
574         .classes = i2o_exec_class_id,
575         .driver = {
576                    .probe = i2o_exec_probe,
577                    .remove = i2o_exec_remove,
578                    },
579 };
580
581 /**
582  *      i2o_exec_init - Registers the Exec OSM
583  *
584  *      Registers the Exec OSM in the I2O core.
585  *
586  *      Returns 0 on success or negative error code on failure.
587  */
588 int __init i2o_exec_init(void)
589 {
590         return i2o_driver_register(&i2o_exec_driver);
591 };
592
593 /**
594  *      i2o_exec_exit - Removes the Exec OSM
595  *
596  *      Unregisters the Exec OSM from the I2O core.
597  */
598 void __exit i2o_exec_exit(void)
599 {
600         i2o_driver_unregister(&i2o_exec_driver);
601 };
602
603 EXPORT_SYMBOL(i2o_msg_post_wait_mem);
604 EXPORT_SYMBOL(i2o_exec_lct_get);