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