61b837de4b6a134756e5af4eb0892b9a8c318685
[linux-2.6.git] / drivers / message / i2o / iop.c
1 /*
2  *      Functions to handle I2O controllers and I2O message handling
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
14  *      Red 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  */
27
28 #include <linux/module.h>
29 #include <linux/i2o.h>
30 #include <linux/delay.h>
31 #include <linux/sched.h>
32 #include "core.h"
33
34 #define OSM_NAME        "i2o"
35 #define OSM_VERSION     "1.288"
36 #define OSM_DESCRIPTION "I2O subsystem"
37
38 /* global I2O controller list */
39 LIST_HEAD(i2o_controllers);
40
41 /*
42  * global I2O System Table. Contains information about all the IOPs in the
43  * system. Used to inform IOPs about each others existence.
44  */
45 static struct i2o_dma i2o_systab;
46
47 static int i2o_hrt_get(struct i2o_controller *c);
48
49 /**
50  *      i2o_msg_nop - Returns a message which is not used
51  *      @c: I2O controller from which the message was created
52  *      @m: message which should be returned
53  *
54  *      If you fetch a message via i2o_msg_get, and can't use it, you must
55  *      return the message with this function. Otherwise the message frame
56  *      is lost.
57  */
58 void i2o_msg_nop(struct i2o_controller *c, u32 m)
59 {
60         struct i2o_message __iomem *msg = i2o_msg_in_to_virt(c, m);
61
62         writel(THREE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
63         writel(I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | ADAPTER_TID,
64                &msg->u.head[1]);
65         writel(0, &msg->u.head[2]);
66         writel(0, &msg->u.head[3]);
67         i2o_msg_post(c, m);
68 };
69
70 /**
71  *      i2o_msg_get_wait - obtain an I2O message from the IOP
72  *      @c: I2O controller
73  *      @msg: pointer to a I2O message pointer
74  *      @wait: how long to wait until timeout
75  *
76  *      This function waits up to wait seconds for a message slot to be
77  *      available.
78  *
79  *      On a success the message is returned and the pointer to the message is
80  *      set in msg. The returned message is the physical page frame offset
81  *      address from the read port (see the i2o spec). If no message is
82  *      available returns I2O_QUEUE_EMPTY and msg is leaved untouched.
83  */
84 u32 i2o_msg_get_wait(struct i2o_controller *c,
85                      struct i2o_message __iomem ** msg, int wait)
86 {
87         unsigned long timeout = jiffies + wait * HZ;
88         u32 m;
89
90         while ((m = i2o_msg_get(c, msg)) == I2O_QUEUE_EMPTY) {
91                 if (time_after(jiffies, timeout)) {
92                         osm_debug("%s: Timeout waiting for message frame.\n",
93                                   c->name);
94                         return I2O_QUEUE_EMPTY;
95                 }
96                 set_current_state(TASK_UNINTERRUPTIBLE);
97                 schedule_timeout(1);
98         }
99
100         return m;
101 };
102
103 #if BITS_PER_LONG == 64
104 /**
105  *      i2o_cntxt_list_add - Append a pointer to context list and return a id
106  *      @c: controller to which the context list belong
107  *      @ptr: pointer to add to the context list
108  *
109  *      Because the context field in I2O is only 32-bit large, on 64-bit the
110  *      pointer is to large to fit in the context field. The i2o_cntxt_list
111  *      functions therefore map pointers to context fields.
112  *
113  *      Returns context id > 0 on success or 0 on failure.
114  */
115 u32 i2o_cntxt_list_add(struct i2o_controller * c, void *ptr)
116 {
117         struct i2o_context_list_element *entry;
118         unsigned long flags;
119
120         if (!ptr)
121                 osm_err("%s: couldn't add NULL pointer to context list!\n",
122                         c->name);
123
124         entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
125         if (!entry) {
126                 osm_err("%s: Could not allocate memory for context list element"
127                         "\n", c->name);
128                 return 0;
129         }
130
131         entry->ptr = ptr;
132         entry->timestamp = jiffies;
133         INIT_LIST_HEAD(&entry->list);
134
135         spin_lock_irqsave(&c->context_list_lock, flags);
136
137         if (unlikely(atomic_inc_and_test(&c->context_list_counter)))
138                 atomic_inc(&c->context_list_counter);
139
140         entry->context = atomic_read(&c->context_list_counter);
141
142         list_add(&entry->list, &c->context_list);
143
144         spin_unlock_irqrestore(&c->context_list_lock, flags);
145
146         osm_debug("%s: Add context to list %p -> %d\n", c->name, ptr, context);
147
148         return entry->context;
149 };
150
151 /**
152  *      i2o_cntxt_list_remove - Remove a pointer from the context list
153  *      @c: controller to which the context list belong
154  *      @ptr: pointer which should be removed from the context list
155  *
156  *      Removes a previously added pointer from the context list and returns
157  *      the matching context id.
158  *
159  *      Returns context id on succes or 0 on failure.
160  */
161 u32 i2o_cntxt_list_remove(struct i2o_controller * c, void *ptr)
162 {
163         struct i2o_context_list_element *entry;
164         u32 context = 0;
165         unsigned long flags;
166
167         spin_lock_irqsave(&c->context_list_lock, flags);
168         list_for_each_entry(entry, &c->context_list, list)
169             if (entry->ptr == ptr) {
170                 list_del(&entry->list);
171                 context = entry->context;
172                 kfree(entry);
173                 break;
174         }
175         spin_unlock_irqrestore(&c->context_list_lock, flags);
176
177         if (!context)
178                 osm_warn("%s: Could not remove nonexistent ptr %p\n", c->name,
179                          ptr);
180
181         osm_debug("%s: remove ptr from context list %d -> %p\n", c->name,
182                   context, ptr);
183
184         return context;
185 };
186
187 /**
188  *      i2o_cntxt_list_get - Get a pointer from the context list and remove it
189  *      @c: controller to which the context list belong
190  *      @context: context id to which the pointer belong
191  *
192  *      Returns pointer to the matching context id on success or NULL on
193  *      failure.
194  */
195 void *i2o_cntxt_list_get(struct i2o_controller *c, u32 context)
196 {
197         struct i2o_context_list_element *entry;
198         unsigned long flags;
199         void *ptr = NULL;
200
201         spin_lock_irqsave(&c->context_list_lock, flags);
202         list_for_each_entry(entry, &c->context_list, list)
203             if (entry->context == context) {
204                 list_del(&entry->list);
205                 ptr = entry->ptr;
206                 kfree(entry);
207                 break;
208         }
209         spin_unlock_irqrestore(&c->context_list_lock, flags);
210
211         if (!ptr)
212                 osm_warn("%s: context id %d not found\n", c->name, context);
213
214         osm_debug("%s: get ptr from context list %d -> %p\n", c->name, context,
215                   ptr);
216
217         return ptr;
218 };
219
220 /**
221  *      i2o_cntxt_list_get_ptr - Get a context id from the context list
222  *      @c: controller to which the context list belong
223  *      @ptr: pointer to which the context id should be fetched
224  *
225  *      Returns context id which matches to the pointer on succes or 0 on
226  *      failure.
227  */
228 u32 i2o_cntxt_list_get_ptr(struct i2o_controller * c, void *ptr)
229 {
230         struct i2o_context_list_element *entry;
231         u32 context = 0;
232         unsigned long flags;
233
234         spin_lock_irqsave(&c->context_list_lock, flags);
235         list_for_each_entry(entry, &c->context_list, list)
236             if (entry->ptr == ptr) {
237                 context = entry->context;
238                 break;
239         }
240         spin_unlock_irqrestore(&c->context_list_lock, flags);
241
242         if (!context)
243                 osm_warn("%s: Could not find nonexistent ptr %p\n", c->name,
244                          ptr);
245
246         osm_debug("%s: get context id from context list %p -> %d\n", c->name,
247                   ptr, context);
248
249         return context;
250 };
251 #endif
252
253 /**
254  *      i2o_iop_find - Find an I2O controller by id
255  *      @unit: unit number of the I2O controller to search for
256  *
257  *      Lookup the I2O controller on the controller list.
258  *
259  *      Returns pointer to the I2O controller on success or NULL if not found.
260  */
261 struct i2o_controller *i2o_find_iop(int unit)
262 {
263         struct i2o_controller *c;
264
265         list_for_each_entry(c, &i2o_controllers, list) {
266                 if (c->unit == unit)
267                         return c;
268         }
269
270         return NULL;
271 };
272
273 /**
274  *      i2o_iop_find_device - Find a I2O device on an I2O controller
275  *      @c: I2O controller where the I2O device hangs on
276  *      @tid: TID of the I2O device to search for
277  *
278  *      Searches the devices of the I2O controller for a device with TID tid and
279  *      returns it.
280  *
281  *      Returns a pointer to the I2O device if found, otherwise NULL.
282  */
283 struct i2o_device *i2o_iop_find_device(struct i2o_controller *c, u16 tid)
284 {
285         struct i2o_device *dev;
286
287         list_for_each_entry(dev, &c->devices, list)
288             if (dev->lct_data.tid == tid)
289                 return dev;
290
291         return NULL;
292 };
293
294 /**
295  *      i2o_quiesce_controller - quiesce controller
296  *      @c: controller
297  *
298  *      Quiesce an IOP. Causes IOP to make external operation quiescent
299  *      (i2o 'READY' state). Internal operation of the IOP continues normally.
300  *
301  *      Returns 0 on success or negative error code on failure.
302  */
303 static int i2o_iop_quiesce(struct i2o_controller *c)
304 {
305         struct i2o_message __iomem *msg;
306         u32 m;
307         i2o_status_block *sb = c->status_block.virt;
308         int rc;
309
310         i2o_status_get(c);
311
312         /* SysQuiesce discarded if IOP not in READY or OPERATIONAL state */
313         if ((sb->iop_state != ADAPTER_STATE_READY) &&
314             (sb->iop_state != ADAPTER_STATE_OPERATIONAL))
315                 return 0;
316
317         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
318         if (m == I2O_QUEUE_EMPTY)
319                 return -ETIMEDOUT;
320
321         writel(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
322         writel(I2O_CMD_SYS_QUIESCE << 24 | HOST_TID << 12 | ADAPTER_TID,
323                &msg->u.head[1]);
324
325         /* Long timeout needed for quiesce if lots of devices */
326         if ((rc = i2o_msg_post_wait(c, m, 240)))
327                 osm_info("%s: Unable to quiesce (status=%#x).\n", c->name, -rc);
328         else
329                 osm_debug("%s: Quiesced.\n", c->name);
330
331         i2o_status_get(c);      // Entered READY state
332
333         return rc;
334 };
335
336 /**
337  *      i2o_iop_enable - move controller from ready to OPERATIONAL
338  *      @c: I2O controller
339  *
340  *      Enable IOP. This allows the IOP to resume external operations and
341  *      reverses the effect of a quiesce. Returns zero or an error code if
342  *      an error occurs.
343  */
344 static int i2o_iop_enable(struct i2o_controller *c)
345 {
346         struct i2o_message __iomem *msg;
347         u32 m;
348         i2o_status_block *sb = c->status_block.virt;
349         int rc;
350
351         i2o_status_get(c);
352
353         /* Enable only allowed on READY state */
354         if (sb->iop_state != ADAPTER_STATE_READY)
355                 return -EINVAL;
356
357         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
358         if (m == I2O_QUEUE_EMPTY)
359                 return -ETIMEDOUT;
360
361         writel(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
362         writel(I2O_CMD_SYS_ENABLE << 24 | HOST_TID << 12 | ADAPTER_TID,
363                &msg->u.head[1]);
364
365         /* How long of a timeout do we need? */
366         if ((rc = i2o_msg_post_wait(c, m, 240)))
367                 osm_err("%s: Could not enable (status=%#x).\n", c->name, -rc);
368         else
369                 osm_debug("%s: Enabled.\n", c->name);
370
371         i2o_status_get(c);      // entered OPERATIONAL state
372
373         return rc;
374 };
375
376 /**
377  *      i2o_iop_quiesce_all - Quiesce all I2O controllers on the system
378  *
379  *      Quiesce all I2O controllers which are connected to the system.
380  */
381 static inline void i2o_iop_quiesce_all(void)
382 {
383         struct i2o_controller *c, *tmp;
384
385         list_for_each_entry_safe(c, tmp, &i2o_controllers, list) {
386                 if (!c->no_quiesce)
387                         i2o_iop_quiesce(c);
388         }
389 };
390
391 /**
392  *      i2o_iop_enable_all - Enables all controllers on the system
393  *
394  *      Enables all I2O controllers which are connected to the system.
395  */
396 static inline void i2o_iop_enable_all(void)
397 {
398         struct i2o_controller *c, *tmp;
399
400         list_for_each_entry_safe(c, tmp, &i2o_controllers, list)
401             i2o_iop_enable(c);
402 };
403
404 /**
405  *      i2o_clear_controller - Bring I2O controller into HOLD state
406  *      @c: controller
407  *
408  *      Clear an IOP to HOLD state, ie. terminate external operations, clear all
409  *      input queues and prepare for a system restart. IOP's internal operation
410  *      continues normally and the outbound queue is alive. The IOP is not
411  *      expected to rebuild its LCT.
412  *
413  *      Returns 0 on success or negative error code on failure.
414  */
415 static int i2o_iop_clear(struct i2o_controller *c)
416 {
417         struct i2o_message __iomem *msg;
418         u32 m;
419         int rc;
420
421         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
422         if (m == I2O_QUEUE_EMPTY)
423                 return -ETIMEDOUT;
424
425         /* Quiesce all IOPs first */
426         i2o_iop_quiesce_all();
427
428         writel(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
429         writel(I2O_CMD_ADAPTER_CLEAR << 24 | HOST_TID << 12 | ADAPTER_TID,
430                &msg->u.head[1]);
431
432         if ((rc = i2o_msg_post_wait(c, m, 30)))
433                 osm_info("%s: Unable to clear (status=%#x).\n", c->name, -rc);
434         else
435                 osm_debug("%s: Cleared.\n", c->name);
436
437         /* Enable all IOPs */
438         i2o_iop_enable_all();
439
440         return rc;
441 }
442
443 /**
444  *      i2o_iop_init_outbound_queue - setup the outbound message queue
445  *      @c: I2O controller
446  *
447  *      Clear and (re)initialize IOP's outbound queue and post the message
448  *      frames to the IOP.
449  *
450  *      Returns 0 on success or a negative errno code on failure.
451  */
452 static int i2o_iop_init_outbound_queue(struct i2o_controller *c)
453 {
454         volatile u8 *status = c->status.virt;
455         u32 m;
456         struct i2o_message __iomem *msg;
457         ulong timeout;
458         int i;
459
460         osm_debug("%s: Initializing Outbound Queue...\n", c->name);
461
462         memset(c->status.virt, 0, 4);
463
464         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
465         if (m == I2O_QUEUE_EMPTY)
466                 return -ETIMEDOUT;
467
468         writel(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6, &msg->u.head[0]);
469         writel(I2O_CMD_OUTBOUND_INIT << 24 | HOST_TID << 12 | ADAPTER_TID,
470                &msg->u.head[1]);
471         writel(i2o_exec_driver.context, &msg->u.s.icntxt);
472         writel(0x00000000, &msg->u.s.tcntxt);
473         writel(PAGE_SIZE, &msg->body[0]);
474         /* Outbound msg frame size in words and Initcode */
475         writel(I2O_OUTBOUND_MSG_FRAME_SIZE << 16 | 0x80, &msg->body[1]);
476         writel(0xd0000004, &msg->body[2]);
477         writel(i2o_dma_low(c->status.phys), &msg->body[3]);
478         writel(i2o_dma_high(c->status.phys), &msg->body[4]);
479
480         i2o_msg_post(c, m);
481
482         timeout = jiffies + I2O_TIMEOUT_INIT_OUTBOUND_QUEUE * HZ;
483         while (*status <= I2O_CMD_IN_PROGRESS) {
484                 if (time_after(jiffies, timeout)) {
485                         osm_warn("%s: Timeout Initializing\n", c->name);
486                         return -ETIMEDOUT;
487                 }
488                 set_current_state(TASK_UNINTERRUPTIBLE);
489                 schedule_timeout(1);
490         }
491
492         m = c->out_queue.phys;
493
494         /* Post frames */
495         for (i = 0; i < I2O_MAX_OUTBOUND_MSG_FRAMES; i++) {
496                 i2o_flush_reply(c, m);
497                 udelay(1);      /* Promise */
498                 m += I2O_OUTBOUND_MSG_FRAME_SIZE * sizeof(u32);
499         }
500
501         return 0;
502 }
503
504 /**
505  *      i2o_iop_reset - reset an I2O controller
506  *      @c: controller to reset
507  *
508  *      Reset the IOP into INIT state and wait until IOP gets into RESET state.
509  *      Terminate all external operations, clear IOP's inbound and outbound
510  *      queues, terminate all DDMs, and reload the IOP's operating environment
511  *      and all local DDMs. The IOP rebuilds its LCT.
512  */
513 static int i2o_iop_reset(struct i2o_controller *c)
514 {
515         volatile u8 *status = c->status.virt;
516         struct i2o_message __iomem *msg;
517         u32 m;
518         unsigned long timeout;
519         i2o_status_block *sb = c->status_block.virt;
520         int rc = 0;
521
522         osm_debug("%s: Resetting controller\n", c->name);
523
524         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
525         if (m == I2O_QUEUE_EMPTY)
526                 return -ETIMEDOUT;
527
528         memset(c->status_block.virt, 0, 8);
529
530         /* Quiesce all IOPs first */
531         i2o_iop_quiesce_all();
532
533         writel(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
534         writel(I2O_CMD_ADAPTER_RESET << 24 | HOST_TID << 12 | ADAPTER_TID,
535                &msg->u.head[1]);
536         writel(i2o_exec_driver.context, &msg->u.s.icntxt);
537         writel(0, &msg->u.s.tcntxt);    //FIXME: use reasonable transaction context
538         writel(0, &msg->body[0]);
539         writel(0, &msg->body[1]);
540         writel(i2o_dma_low(c->status.phys), &msg->body[2]);
541         writel(i2o_dma_high(c->status.phys), &msg->body[3]);
542
543         i2o_msg_post(c, m);
544
545         /* Wait for a reply */
546         timeout = jiffies + I2O_TIMEOUT_RESET * HZ;
547         while (!*status) {
548                 if (time_after(jiffies, timeout))
549                         break;
550
551                 set_current_state(TASK_UNINTERRUPTIBLE);
552                 schedule_timeout(1);
553         }
554
555         switch (*status) {
556         case I2O_CMD_REJECTED:
557                 osm_warn("%s: IOP reset rejected\n", c->name);
558                 rc = -EPERM;
559                 break;
560
561         case I2O_CMD_IN_PROGRESS:
562                 /*
563                  * Once the reset is sent, the IOP goes into the INIT state
564                  * which is indeterminate. We need to wait until the IOP has
565                  * rebooted before we can let the system talk to it. We read
566                  * the inbound Free_List until a message is available. If we
567                  * can't read one in the given ammount of time, we assume the
568                  * IOP could not reboot properly.
569                  */
570                 osm_debug("%s: Reset in progress, waiting for reboot...\n",
571                           c->name);
572
573                 m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_RESET);
574                 while (m == I2O_QUEUE_EMPTY) {
575                         if (time_after(jiffies, timeout)) {
576                                 osm_err("%s: IOP reset timeout.\n", c->name);
577                                 rc = -ETIMEDOUT;
578                                 goto exit;
579                         }
580                         set_current_state(TASK_UNINTERRUPTIBLE);
581                         schedule_timeout(1);
582
583                         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_RESET);
584                 }
585                 i2o_msg_nop(c, m);
586
587                 /* from here all quiesce commands are safe */
588                 c->no_quiesce = 0;
589
590                 /* verify if controller is in state RESET */
591                 i2o_status_get(c);
592
593                 if (!c->promise && (sb->iop_state != ADAPTER_STATE_RESET))
594                         osm_warn("%s: reset completed, but adapter not in RESET"
595                                  " state.\n", c->name);
596                 else
597                         osm_debug("%s: reset completed.\n", c->name);
598
599                 break;
600
601         default:
602                 osm_err("%s: IOP reset timeout.\n", c->name);
603                 rc = -ETIMEDOUT;
604                 break;
605         }
606
607       exit:
608         /* Enable all IOPs */
609         i2o_iop_enable_all();
610
611         return rc;
612 };
613
614 /**
615  *      i2o_iop_activate - Bring controller up to HOLD
616  *      @c: controller
617  *
618  *      This function brings an I2O controller into HOLD state. The adapter
619  *      is reset if necessary and then the queues and resource table are read.
620  *
621  *      Returns 0 on success or negative error code on failure.
622  */
623 static int i2o_iop_activate(struct i2o_controller *c)
624 {
625         i2o_status_block *sb = c->status_block.virt;
626         int rc;
627         int state;
628
629         /* In INIT state, Wait Inbound Q to initialize (in i2o_status_get) */
630         /* In READY state, Get status */
631
632         rc = i2o_status_get(c);
633         if (rc) {
634                 osm_info("%s: Unable to obtain status, attempting a reset.\n",
635                          c->name);
636                 rc = i2o_iop_reset(c);
637                 if (rc)
638                         return rc;
639         }
640
641         if (sb->i2o_version > I2OVER15) {
642                 osm_err("%s: Not running version 1.5 of the I2O Specification."
643                         "\n", c->name);
644                 return -ENODEV;
645         }
646
647         switch (sb->iop_state) {
648         case ADAPTER_STATE_FAULTED:
649                 osm_err("%s: hardware fault\n", c->name);
650                 return -EFAULT;
651
652         case ADAPTER_STATE_READY:
653         case ADAPTER_STATE_OPERATIONAL:
654         case ADAPTER_STATE_HOLD:
655         case ADAPTER_STATE_FAILED:
656                 osm_debug("%s: already running, trying to reset...\n", c->name);
657                 rc = i2o_iop_reset(c);
658                 if (rc)
659                         return rc;
660         }
661
662         /* preserve state */
663         state = sb->iop_state;
664
665         rc = i2o_iop_init_outbound_queue(c);
666         if (rc)
667                 return rc;
668
669         /* if adapter was not in RESET state clear now */
670         if (state != ADAPTER_STATE_RESET)
671                 i2o_iop_clear(c);
672
673         i2o_status_get(c);
674
675         if (sb->iop_state != ADAPTER_STATE_HOLD) {
676                 osm_err("%s: failed to bring IOP into HOLD state\n", c->name);
677                 return -EIO;
678         }
679
680         return i2o_hrt_get(c);
681 };
682
683 /**
684  *      i2o_iop_systab_set - Set the I2O System Table of the specified IOP
685  *      @c: I2O controller to which the system table should be send
686  *
687  *      Before the systab could be set i2o_systab_build() must be called.
688  *
689  *      Returns 0 on success or negative error code on failure.
690  */
691 static int i2o_iop_systab_set(struct i2o_controller *c)
692 {
693         struct i2o_message __iomem *msg;
694         u32 m;
695         i2o_status_block *sb = c->status_block.virt;
696         struct device *dev = &c->pdev->dev;
697         struct resource *root;
698         int rc;
699
700         if (sb->current_mem_size < sb->desired_mem_size) {
701                 struct resource *res = &c->mem_resource;
702                 res->name = c->pdev->bus->name;
703                 res->flags = IORESOURCE_MEM;
704                 res->start = 0;
705                 res->end = 0;
706                 osm_info("%s: requires private memory resources.\n", c->name);
707                 root = pci_find_parent_resource(c->pdev, res);
708                 if (root == NULL)
709                         osm_warn("%s: Can't find parent resource!\n", c->name);
710                 if (root && allocate_resource(root, res, sb->desired_mem_size, sb->desired_mem_size, sb->desired_mem_size, 1 << 20,     /* Unspecified, so use 1Mb and play safe */
711                                               NULL, NULL) >= 0) {
712                         c->mem_alloc = 1;
713                         sb->current_mem_size = 1 + res->end - res->start;
714                         sb->current_mem_base = res->start;
715                         osm_info("%s: allocated %ld bytes of PCI memory at "
716                                  "0x%08lX.\n", c->name,
717                                  1 + res->end - res->start, res->start);
718                 }
719         }
720
721         if (sb->current_io_size < sb->desired_io_size) {
722                 struct resource *res = &c->io_resource;
723                 res->name = c->pdev->bus->name;
724                 res->flags = IORESOURCE_IO;
725                 res->start = 0;
726                 res->end = 0;
727                 osm_info("%s: requires private memory resources.\n", c->name);
728                 root = pci_find_parent_resource(c->pdev, res);
729                 if (root == NULL)
730                         osm_warn("%s: Can't find parent resource!\n", c->name);
731                 if (root && allocate_resource(root, res, sb->desired_io_size, sb->desired_io_size, sb->desired_io_size, 1 << 20,        /* Unspecified, so use 1Mb and play safe */
732                                               NULL, NULL) >= 0) {
733                         c->io_alloc = 1;
734                         sb->current_io_size = 1 + res->end - res->start;
735                         sb->current_mem_base = res->start;
736                         osm_info("%s: allocated %ld bytes of PCI I/O at 0x%08lX"
737                                  ".\n", c->name, 1 + res->end - res->start,
738                                  res->start);
739                 }
740         }
741
742         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
743         if (m == I2O_QUEUE_EMPTY)
744                 return -ETIMEDOUT;
745
746         i2o_systab.phys = dma_map_single(dev, i2o_systab.virt, i2o_systab.len,
747                                          PCI_DMA_TODEVICE);
748         if (!i2o_systab.phys) {
749                 i2o_msg_nop(c, m);
750                 return -ENOMEM;
751         }
752
753         writel(I2O_MESSAGE_SIZE(12) | SGL_OFFSET_6, &msg->u.head[0]);
754         writel(I2O_CMD_SYS_TAB_SET << 24 | HOST_TID << 12 | ADAPTER_TID,
755                &msg->u.head[1]);
756
757         /*
758          * Provide three SGL-elements:
759          * System table (SysTab), Private memory space declaration and
760          * Private i/o space declaration
761          *
762          * FIXME: is this still true?
763          * Nasty one here. We can't use dma_alloc_coherent to send the
764          * same table to everyone. We have to go remap it for them all
765          */
766
767         writel(c->unit + 2, &msg->body[0]);
768         writel(0, &msg->body[1]);
769         writel(0x54000000 | i2o_systab.len, &msg->body[2]);
770         writel(i2o_systab.phys, &msg->body[3]);
771         writel(0x54000000 | sb->current_mem_size, &msg->body[4]);
772         writel(sb->current_mem_base, &msg->body[5]);
773         writel(0xd4000000 | sb->current_io_size, &msg->body[6]);
774         writel(sb->current_io_base, &msg->body[6]);
775
776         rc = i2o_msg_post_wait(c, m, 120);
777
778         dma_unmap_single(dev, i2o_systab.phys, i2o_systab.len,
779                          PCI_DMA_TODEVICE);
780
781         if (rc < 0)
782                 osm_err("%s: Unable to set SysTab (status=%#x).\n", c->name,
783                         -rc);
784         else
785                 osm_debug("%s: SysTab set.\n", c->name);
786
787         i2o_status_get(c);      // Entered READY state
788
789         return rc;
790 }
791
792 /**
793  *      i2o_iop_online - Bring a controller online into OPERATIONAL state.
794  *      @c: I2O controller
795  *
796  *      Send the system table and enable the I2O controller.
797  *
798  *      Returns 0 on success or negativer error code on failure.
799  */
800 static int i2o_iop_online(struct i2o_controller *c)
801 {
802         int rc;
803
804         rc = i2o_iop_systab_set(c);
805         if (rc)
806                 return rc;
807
808         /* In READY state */
809         osm_debug("%s: Attempting to enable...\n", c->name);
810         rc = i2o_iop_enable(c);
811         if (rc)
812                 return rc;
813
814         return 0;
815 };
816
817 /**
818  *      i2o_iop_remove - Remove the I2O controller from the I2O core
819  *      @c: I2O controller
820  *
821  *      Remove the I2O controller from the I2O core. If devices are attached to
822  *      the controller remove these also and finally reset the controller.
823  */
824 void i2o_iop_remove(struct i2o_controller *c)
825 {
826         struct i2o_device *dev, *tmp;
827
828         osm_debug("%s: deleting controller\n", c->name);
829
830         i2o_driver_notify_controller_remove_all(c);
831
832         list_del(&c->list);
833
834         list_for_each_entry_safe(dev, tmp, &c->devices, list)
835             i2o_device_remove(dev);
836
837         class_device_unregister(c->classdev);
838         device_del(&c->device);
839
840         /* Ask the IOP to switch to RESET state */
841         i2o_iop_reset(c);
842
843         put_device(&c->device);
844 }
845
846 /**
847  *      i2o_systab_build - Build system table
848  *
849  *      The system table contains information about all the IOPs in the system
850  *      (duh) and is used by the Executives on the IOPs to establish peer2peer
851  *      connections. We're not supporting peer2peer at the moment, but this
852  *      will be needed down the road for things like lan2lan forwarding.
853  *
854  *      Returns 0 on success or negative error code on failure.
855  */
856 static int i2o_systab_build(void)
857 {
858         struct i2o_controller *c, *tmp;
859         int num_controllers = 0;
860         u32 change_ind = 0;
861         int count = 0;
862         struct i2o_sys_tbl *systab = i2o_systab.virt;
863
864         list_for_each_entry_safe(c, tmp, &i2o_controllers, list)
865             num_controllers++;
866
867         if (systab) {
868                 change_ind = systab->change_ind;
869                 kfree(i2o_systab.virt);
870         }
871
872         /* Header + IOPs */
873         i2o_systab.len = sizeof(struct i2o_sys_tbl) + num_controllers *
874             sizeof(struct i2o_sys_tbl_entry);
875
876         systab = i2o_systab.virt = kmalloc(i2o_systab.len, GFP_KERNEL);
877         if (!systab) {
878                 osm_err("unable to allocate memory for System Table\n");
879                 return -ENOMEM;
880         }
881         memset(systab, 0, i2o_systab.len);
882
883         systab->version = I2OVERSION;
884         systab->change_ind = change_ind + 1;
885
886         list_for_each_entry_safe(c, tmp, &i2o_controllers, list) {
887                 i2o_status_block *sb;
888
889                 if (count >= num_controllers) {
890                         osm_err("controller added while building system table"
891                                 "\n");
892                         break;
893                 }
894
895                 sb = c->status_block.virt;
896
897                 /*
898                  * Get updated IOP state so we have the latest information
899                  *
900                  * We should delete the controller at this point if it
901                  * doesn't respond since if it's not on the system table
902                  * it is techninically not part of the I2O subsystem...
903                  */
904                 if (unlikely(i2o_status_get(c))) {
905                         osm_err("%s: Deleting b/c could not get status while "
906                                 "attempting to build system table\n", c->name);
907                         i2o_iop_remove(c);
908                         continue;       // try the next one
909                 }
910
911                 systab->iops[count].org_id = sb->org_id;
912                 systab->iops[count].iop_id = c->unit + 2;
913                 systab->iops[count].seg_num = 0;
914                 systab->iops[count].i2o_version = sb->i2o_version;
915                 systab->iops[count].iop_state = sb->iop_state;
916                 systab->iops[count].msg_type = sb->msg_type;
917                 systab->iops[count].frame_size = sb->inbound_frame_size;
918                 systab->iops[count].last_changed = change_ind;
919                 systab->iops[count].iop_capabilities = sb->iop_capabilities;
920                 systab->iops[count].inbound_low =
921                     i2o_dma_low(c->base.phys + I2O_IN_PORT);
922                 systab->iops[count].inbound_high =
923                     i2o_dma_high(c->base.phys + I2O_IN_PORT);
924
925                 count++;
926         }
927
928         systab->num_entries = count;
929
930         return 0;
931 };
932
933 /**
934  *      i2o_parse_hrt - Parse the hardware resource table.
935  *      @c: I2O controller
936  *
937  *      We don't do anything with it except dumping it (in debug mode).
938  *
939  *      Returns 0.
940  */
941 static int i2o_parse_hrt(struct i2o_controller *c)
942 {
943         i2o_dump_hrt(c);
944         return 0;
945 };
946
947 /**
948  *      i2o_status_get - Get the status block from the I2O controller
949  *      @c: I2O controller
950  *
951  *      Issue a status query on the controller. This updates the attached
952  *      status block. The status block could then be accessed through
953  *      c->status_block.
954  *
955  *      Returns 0 on sucess or negative error code on failure.
956  */
957 int i2o_status_get(struct i2o_controller *c)
958 {
959         struct i2o_message __iomem *msg;
960         u32 m;
961         volatile u8 *status_block;
962         unsigned long timeout;
963
964         status_block = (u8 *) c->status_block.virt;
965         memset(c->status_block.virt, 0, sizeof(i2o_status_block));
966
967         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
968         if (m == I2O_QUEUE_EMPTY)
969                 return -ETIMEDOUT;
970
971         writel(NINE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
972         writel(I2O_CMD_STATUS_GET << 24 | HOST_TID << 12 | ADAPTER_TID,
973                &msg->u.head[1]);
974         writel(i2o_exec_driver.context, &msg->u.s.icntxt);
975         writel(0, &msg->u.s.tcntxt);    // FIXME: use resonable transaction context
976         writel(0, &msg->body[0]);
977         writel(0, &msg->body[1]);
978         writel(i2o_dma_low(c->status_block.phys), &msg->body[2]);
979         writel(i2o_dma_high(c->status_block.phys), &msg->body[3]);
980         writel(sizeof(i2o_status_block), &msg->body[4]);        /* always 88 bytes */
981
982         i2o_msg_post(c, m);
983
984         /* Wait for a reply */
985         timeout = jiffies + I2O_TIMEOUT_STATUS_GET * HZ;
986         while (status_block[87] != 0xFF) {
987                 if (time_after(jiffies, timeout)) {
988                         osm_err("%s: Get status timeout.\n", c->name);
989                         return -ETIMEDOUT;
990                 }
991
992                 set_current_state(TASK_UNINTERRUPTIBLE);
993                 schedule_timeout(1);
994         }
995
996 #ifdef DEBUG
997         i2o_debug_state(c);
998 #endif
999
1000         return 0;
1001 }
1002
1003 /*
1004  *      i2o_hrt_get - Get the Hardware Resource Table from the I2O controller
1005  *      @c: I2O controller from which the HRT should be fetched
1006  *
1007  *      The HRT contains information about possible hidden devices but is
1008  *      mostly useless to us.
1009  *
1010  *      Returns 0 on success or negativer error code on failure.
1011  */
1012 static int i2o_hrt_get(struct i2o_controller *c)
1013 {
1014         int rc;
1015         int i;
1016         i2o_hrt *hrt = c->hrt.virt;
1017         u32 size = sizeof(i2o_hrt);
1018         struct device *dev = &c->pdev->dev;
1019
1020         for (i = 0; i < I2O_HRT_GET_TRIES; i++) {
1021                 struct i2o_message __iomem *msg;
1022                 u32 m;
1023
1024                 m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
1025                 if (m == I2O_QUEUE_EMPTY)
1026                         return -ETIMEDOUT;
1027
1028                 writel(SIX_WORD_MSG_SIZE | SGL_OFFSET_4, &msg->u.head[0]);
1029                 writel(I2O_CMD_HRT_GET << 24 | HOST_TID << 12 | ADAPTER_TID,
1030                        &msg->u.head[1]);
1031                 writel(0xd0000000 | c->hrt.len, &msg->body[0]);
1032                 writel(c->hrt.phys, &msg->body[1]);
1033
1034                 rc = i2o_msg_post_wait_mem(c, m, 20, &c->hrt);
1035
1036                 if (rc < 0) {
1037                         osm_err("%s: Unable to get HRT (status=%#x)\n", c->name,
1038                                 -rc);
1039                         return rc;
1040                 }
1041
1042                 size = hrt->num_entries * hrt->entry_len << 2;
1043                 if (size > c->hrt.len) {
1044                         if (i2o_dma_realloc(dev, &c->hrt, size, GFP_KERNEL))
1045                                 return -ENOMEM;
1046                         else
1047                                 hrt = c->hrt.virt;
1048                 } else
1049                         return i2o_parse_hrt(c);
1050         }
1051
1052         osm_err("%s: Unable to get HRT after %d tries, giving up\n", c->name,
1053                 I2O_HRT_GET_TRIES);
1054
1055         return -EBUSY;
1056 }
1057
1058 /**
1059  *      i2o_iop_free - Free the i2o_controller struct
1060  *      @c: I2O controller to free
1061  */
1062 void i2o_iop_free(struct i2o_controller *c)
1063 {
1064         kfree(c);
1065 };
1066
1067 /**
1068  *      i2o_iop_release - release the memory for a I2O controller
1069  *      @dev: I2O controller which should be released
1070  *
1071  *      Release the allocated memory. This function is called if refcount of
1072  *      device reaches 0 automatically.
1073  */
1074 static void i2o_iop_release(struct device *dev)
1075 {
1076         struct i2o_controller *c = to_i2o_controller(dev);
1077
1078         i2o_iop_free(c);
1079 };
1080
1081 /* I2O controller class */
1082 static struct class *i2o_controller_class;
1083
1084 /**
1085  *      i2o_iop_alloc - Allocate and initialize a i2o_controller struct
1086  *
1087  *      Allocate the necessary memory for a i2o_controller struct and
1088  *      initialize the lists.
1089  *
1090  *      Returns a pointer to the I2O controller or a negative error code on
1091  *      failure.
1092  */
1093 struct i2o_controller *i2o_iop_alloc(void)
1094 {
1095         static int unit = 0;    /* 0 and 1 are NULL IOP and Local Host */
1096         struct i2o_controller *c;
1097
1098         c = kmalloc(sizeof(*c), GFP_KERNEL);
1099         if (!c) {
1100                 osm_err("i2o: Insufficient memory to allocate a I2O controller."
1101                         "\n");
1102                 return ERR_PTR(-ENOMEM);
1103         }
1104         memset(c, 0, sizeof(*c));
1105
1106         INIT_LIST_HEAD(&c->devices);
1107         spin_lock_init(&c->lock);
1108         init_MUTEX(&c->lct_lock);
1109         c->unit = unit++;
1110         sprintf(c->name, "iop%d", c->unit);
1111
1112         device_initialize(&c->device);
1113
1114         c->device.release = &i2o_iop_release;
1115
1116         snprintf(c->device.bus_id, BUS_ID_SIZE, "iop%d", c->unit);
1117
1118 #if BITS_PER_LONG == 64
1119         spin_lock_init(&c->context_list_lock);
1120         atomic_set(&c->context_list_counter, 0);
1121         INIT_LIST_HEAD(&c->context_list);
1122 #endif
1123
1124         return c;
1125 };
1126
1127 /**
1128  *      i2o_iop_add - Initialize the I2O controller and add him to the I2O core
1129  *      @c: controller
1130  *
1131  *      Initialize the I2O controller and if no error occurs add him to the I2O
1132  *      core.
1133  *
1134  *      Returns 0 on success or negative error code on failure.
1135  */
1136 int i2o_iop_add(struct i2o_controller *c)
1137 {
1138         int rc;
1139
1140         if ((rc = device_add(&c->device))) {
1141                 osm_err("%s: could not add controller\n", c->name);
1142                 goto iop_reset;
1143         }
1144
1145         c->classdev = class_device_create(i2o_controller_class, NULL, MKDEV(0,0),
1146                         &c->device, "iop%d", c->unit);
1147         if (IS_ERR(c->classdev)) {
1148                 osm_err("%s: could not add controller class\n", c->name);
1149                 goto device_del;
1150         }
1151
1152         osm_info("%s: Activating I2O controller...\n", c->name);
1153         osm_info("%s: This may take a few minutes if there are many devices\n",
1154                  c->name);
1155
1156         if ((rc = i2o_iop_activate(c))) {
1157                 osm_err("%s: could not activate controller\n", c->name);
1158                 goto class_del;
1159         }
1160
1161         osm_debug("%s: building sys table...\n", c->name);
1162
1163         if ((rc = i2o_systab_build()))
1164                 goto class_del;
1165
1166         osm_debug("%s: online controller...\n", c->name);
1167
1168         if ((rc = i2o_iop_online(c)))
1169                 goto class_del;
1170
1171         osm_debug("%s: getting LCT...\n", c->name);
1172
1173         if ((rc = i2o_exec_lct_get(c)))
1174                 goto class_del;
1175
1176         list_add(&c->list, &i2o_controllers);
1177
1178         i2o_driver_notify_controller_add_all(c);
1179
1180         osm_info("%s: Controller added\n", c->name);
1181
1182         return 0;
1183
1184       class_del:
1185         class_device_unregister(c->classdev);
1186
1187       device_del:
1188         device_del(&c->device);
1189
1190       iop_reset:
1191         i2o_iop_reset(c);
1192
1193         return rc;
1194 };
1195
1196 /**
1197  *      i2o_event_register - Turn on/off event notification for a I2O device
1198  *      @dev: I2O device which should receive the event registration request
1199  *      @drv: driver which want to get notified
1200  *      @tcntxt: transaction context to use with this notifier
1201  *      @evt_mask: mask of events
1202  *
1203  *      Create and posts an event registration message to the task. No reply
1204  *      is waited for, or expected. If you do not want further notifications,
1205  *      call the i2o_event_register again with a evt_mask of 0.
1206  *
1207  *      Returns 0 on success or -ETIMEDOUT if no message could be fetched for
1208  *      sending the request.
1209  */
1210 int i2o_event_register(struct i2o_device *dev, struct i2o_driver *drv,
1211                        int tcntxt, u32 evt_mask)
1212 {
1213         struct i2o_controller *c = dev->iop;
1214         struct i2o_message __iomem *msg;
1215         u32 m;
1216
1217         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
1218         if (m == I2O_QUEUE_EMPTY)
1219                 return -ETIMEDOUT;
1220
1221         writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
1222         writel(I2O_CMD_UTIL_EVT_REGISTER << 24 | HOST_TID << 12 | dev->lct_data.
1223                tid, &msg->u.head[1]);
1224         writel(drv->context, &msg->u.s.icntxt);
1225         writel(tcntxt, &msg->u.s.tcntxt);
1226         writel(evt_mask, &msg->body[0]);
1227
1228         i2o_msg_post(c, m);
1229
1230         return 0;
1231 };
1232
1233 /**
1234  *      i2o_iop_init - I2O main initialization function
1235  *
1236  *      Initialize the I2O drivers (OSM) functions, register the Executive OSM,
1237  *      initialize the I2O PCI part and finally initialize I2O device stuff.
1238  *
1239  *      Returns 0 on success or negative error code on failure.
1240  */
1241 static int __init i2o_iop_init(void)
1242 {
1243         int rc = 0;
1244
1245         printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n");
1246
1247         i2o_controller_class = class_create(THIS_MODULE, "i2o_controller");
1248         if (IS_ERR(i2o_controller_class)) {
1249                 osm_err("can't register class i2o_controller\n");
1250                 goto exit;
1251         }
1252
1253         if ((rc = i2o_driver_init()))
1254                 goto class_exit;
1255
1256         if ((rc = i2o_exec_init()))
1257                 goto driver_exit;
1258
1259         if ((rc = i2o_pci_init()))
1260                 goto exec_exit;
1261
1262         return 0;
1263
1264       exec_exit:
1265         i2o_exec_exit();
1266
1267       driver_exit:
1268         i2o_driver_exit();
1269
1270       class_exit:
1271         class_destroy(i2o_controller_class);
1272
1273       exit:
1274         return rc;
1275 }
1276
1277 /**
1278  *      i2o_iop_exit - I2O main exit function
1279  *
1280  *      Removes I2O controllers from PCI subsystem and shut down OSMs.
1281  */
1282 static void __exit i2o_iop_exit(void)
1283 {
1284         i2o_pci_exit();
1285         i2o_exec_exit();
1286         i2o_driver_exit();
1287         class_destroy(i2o_controller_class);
1288 };
1289
1290 module_init(i2o_iop_init);
1291 module_exit(i2o_iop_exit);
1292
1293 MODULE_AUTHOR("Red Hat Software");
1294 MODULE_LICENSE("GPL");
1295 MODULE_DESCRIPTION(OSM_DESCRIPTION);
1296 MODULE_VERSION(OSM_VERSION);
1297
1298 #if BITS_PER_LONG == 64
1299 EXPORT_SYMBOL(i2o_cntxt_list_add);
1300 EXPORT_SYMBOL(i2o_cntxt_list_get);
1301 EXPORT_SYMBOL(i2o_cntxt_list_remove);
1302 EXPORT_SYMBOL(i2o_cntxt_list_get_ptr);
1303 #endif
1304 EXPORT_SYMBOL(i2o_msg_get_wait);
1305 EXPORT_SYMBOL(i2o_msg_nop);
1306 EXPORT_SYMBOL(i2o_find_iop);
1307 EXPORT_SYMBOL(i2o_iop_find_device);
1308 EXPORT_SYMBOL(i2o_event_register);
1309 EXPORT_SYMBOL(i2o_status_get);
1310 EXPORT_SYMBOL(i2o_controllers);