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