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