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