drivers/char/ipmi/ipmi_si_intf.c

   1 /*
   2  * ipmi_si.c
   3  *
   4  * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
   5  * BT).
   6  *
   7  * Author: MontaVista Software, Inc.
   8  *         Corey Minyard <minyard@mvista.com>
   9  *         source@mvista.com
  10  *
  11  * Copyright 2002 MontaVista Software Inc.
  12  *
  13  *  This program is free software; you can redistribute it and/or modify it
  14  *  under the terms of the GNU General Public License as published by the
  15  *  Free Software Foundation; either version 2 of the License, or (at your
  16  *  option) any later version.
  17  *
  18  *
  19  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  20  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  24  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  25  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  26  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  27  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  28  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  *  You should have received a copy of the GNU General Public License along
  31  *  with this program; if not, write to the Free Software Foundation, Inc.,
  32  *  675 Mass Ave, Cambridge, MA 02139, USA.
  33  */
  34
  35 /*
  36  * This file holds the "policy" for the interface to the SMI state
  37  * machine.  It does the configuration, handles timers and interrupts,
  38  * and drives the real SMI state machine.
  39  */
  40
  41 #include <linux/config.h>
  42 #include <linux/module.h>
  43 #include <linux/moduleparam.h>
  44 #include <asm/system.h>
  45 #include <linux/sched.h>
  46 #include <linux/timer.h>
  47 #include <linux/errno.h>
  48 #include <linux/spinlock.h>
  49 #include <linux/slab.h>
  50 #include <linux/delay.h>
  51 #include <linux/list.h>
  52 #include <linux/pci.h>
  53 #include <linux/ioport.h>
  54 #include <linux/notifier.h>
  55 #include <linux/mutex.h>
  56 #include <linux/kthread.h>
  57 #include <asm/irq.h>
  58 #ifdef CONFIG_HIGH_RES_TIMERS
  59 #include <linux/hrtime.h>
  60 # if defined(schedule_next_int)
  61 /* Old high-res timer code, do translations. */
  62 #  define get_arch_cycles(a) quick_update_jiffies_sub(a)
  63 #  define arch_cycles_per_jiffy cycles_per_jiffies
  64 # endif
  65 static inline void add_usec_to_timer(struct timer_list *t, long v)
  66 {
  67         t->arch_cycle_expires += nsec_to_arch_cycle(v * 1000);
  68         while (t->arch_cycle_expires >= arch_cycles_per_jiffy)
  69         {
  70                 t->expires++;
  71                 t->arch_cycle_expires -= arch_cycles_per_jiffy;
  72         }
  73 }
  74 #endif
  75 #include <linux/interrupt.h>
  76 #include <linux/rcupdate.h>
  77 #include <linux/ipmi_smi.h>
  78 #include <asm/io.h>
  79 #include "ipmi_si_sm.h"
  80 #include <linux/init.h>
  81 #include <linux/dmi.h>
  82
  83 /* Measure times between events in the driver. */
  84 #undef DEBUG_TIMING
  85
  86 /* Call every 10 ms. */
  87 #define SI_TIMEOUT_TIME_USEC    10000
  88 #define SI_USEC_PER_JIFFY       (1000000/HZ)
  89 #define SI_TIMEOUT_JIFFIES      (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
  90 #define SI_SHORT_TIMEOUT_USEC  250 /* .25ms when the SM request a
  91                                        short timeout */
  92
  93 enum si_intf_state {
  94         SI_NORMAL,
  95         SI_GETTING_FLAGS,
  96         SI_GETTING_EVENTS,
  97         SI_CLEARING_FLAGS,
  98         SI_CLEARING_FLAGS_THEN_SET_IRQ,
  99         SI_GETTING_MESSAGES,
 100         SI_ENABLE_INTERRUPTS1,
 101         SI_ENABLE_INTERRUPTS2
 102         /* FIXME - add watchdog stuff. */
 103 };
 104
 105 /* Some BT-specific defines we need here. */
 106 #define IPMI_BT_INTMASK_REG             2
 107 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT   2
 108 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT  1
 109
 110 enum si_type {
 111     SI_KCS, SI_SMIC, SI_BT
 112 };
 113 static char *si_to_str[] = { "KCS", "SMIC", "BT" };
 114
 115 #define DEVICE_NAME "ipmi_si"
 116
 117 static struct device_driver ipmi_driver =
 118 {
 119         .name = DEVICE_NAME,
 120         .bus = &platform_bus_type
 121 };
 122
 123 struct smi_info
 124 {
 125         int                    intf_num;
 126         ipmi_smi_t             intf;
 127         struct si_sm_data      *si_sm;
 128         struct si_sm_handlers  *handlers;
 129         enum si_type           si_type;
 130         spinlock_t             si_lock;
 131         spinlock_t             msg_lock;
 132         struct list_head       xmit_msgs;
 133         struct list_head       hp_xmit_msgs;
 134         struct ipmi_smi_msg    *curr_msg;
 135         enum si_intf_state     si_state;
 136
 137         /* Used to handle the various types of I/O that can occur with
 138            IPMI */
 139         struct si_sm_io io;
 140         int (*io_setup)(struct smi_info *info);
 141         void (*io_cleanup)(struct smi_info *info);
 142         int (*irq_setup)(struct smi_info *info);
 143         void (*irq_cleanup)(struct smi_info *info);
 144         unsigned int io_size;
 145         char *addr_source; /* ACPI, PCI, SMBIOS, hardcode, default. */
 146         void (*addr_source_cleanup)(struct smi_info *info);
 147         void *addr_source_data;
 148
 149         /* Per-OEM handler, called from handle_flags().
 150            Returns 1 when handle_flags() needs to be re-run
 151            or 0 indicating it set si_state itself.
 152         */
 153         int (*oem_data_avail_handler)(struct smi_info *smi_info);
 154
 155         /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
 156            is set to hold the flags until we are done handling everything
 157            from the flags. */
 158 #define RECEIVE_MSG_AVAIL       0x01
 159 #define EVENT_MSG_BUFFER_FULL   0x02
 160 #define WDT_PRE_TIMEOUT_INT     0x08
 161 #define OEM0_DATA_AVAIL     0x20
 162 #define OEM1_DATA_AVAIL     0x40
 163 #define OEM2_DATA_AVAIL     0x80
 164 #define OEM_DATA_AVAIL      (OEM0_DATA_AVAIL | \
 165                              OEM1_DATA_AVAIL | \
 166                              OEM2_DATA_AVAIL)
 167         unsigned char       msg_flags;
 168
 169         /* If set to true, this will request events the next time the
 170            state machine is idle. */
 171         atomic_t            req_events;
 172
 173         /* If true, run the state machine to completion on every send
 174            call.  Generally used after a panic to make sure stuff goes
 175            out. */
 176         int                 run_to_completion;
 177
 178         /* The I/O port of an SI interface. */
 179         int                 port;
 180
 181         /* The space between start addresses of the two ports.  For
 182            instance, if the first port is 0xca2 and the spacing is 4, then
 183            the second port is 0xca6. */
 184         unsigned int        spacing;
 185
 186         /* zero if no irq; */
 187         int                 irq;
 188
 189         /* The timer for this si. */
 190         struct timer_list   si_timer;
 191
 192         /* The time (in jiffies) the last timeout occurred at. */
 193         unsigned long       last_timeout_jiffies;
 194
 195         /* Used to gracefully stop the timer without race conditions. */
 196         atomic_t            stop_operation;
 197
 198         /* The driver will disable interrupts when it gets into a
 199            situation where it cannot handle messages due to lack of
 200            memory.  Once that situation clears up, it will re-enable
 201            interrupts. */
 202         int interrupt_disabled;
 203
 204         /* From the get device id response... */
 205         struct ipmi_device_id device_id;
 206
 207         /* Driver model stuff. */
 208         struct device *dev;
 209         struct platform_device *pdev;
 210
 211          /* True if we allocated the device, false if it came from
 212           * someplace else (like PCI). */
 213         int dev_registered;
 214
 215         /* Slave address, could be reported from DMI. */
 216         unsigned char slave_addr;
 217
 218         /* Counters and things for the proc filesystem. */
 219         spinlock_t count_lock;
 220         unsigned long short_timeouts;
 221         unsigned long long_timeouts;
 222         unsigned long timeout_restarts;
 223         unsigned long idles;
 224         unsigned long interrupts;
 225         unsigned long attentions;
 226         unsigned long flag_fetches;
 227         unsigned long hosed_count;
 228         unsigned long complete_transactions;
 229         unsigned long events;
 230         unsigned long watchdog_pretimeouts;
 231         unsigned long incoming_messages;
 232
 233         struct task_struct *thread;
 234
 235         struct list_head link;
 236 };
 237
 238 static int try_smi_init(struct smi_info *smi);
 239
 240 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
 241 static int register_xaction_notifier(struct notifier_block * nb)
 242 {
 243         return atomic_notifier_chain_register(&xaction_notifier_list, nb);
 244 }
 245
 246 static void si_restart_short_timer(struct smi_info *smi_info);
 247
 248 static void deliver_recv_msg(struct smi_info *smi_info,
 249                              struct ipmi_smi_msg *msg)
 250 {
 251         /* Deliver the message to the upper layer with the lock
 252            released. */
 253         spin_unlock(&(smi_info->si_lock));
 254         ipmi_smi_msg_received(smi_info->intf, msg);
 255         spin_lock(&(smi_info->si_lock));
 256 }
 257
 258 static void return_hosed_msg(struct smi_info *smi_info)
 259 {
 260         struct ipmi_smi_msg *msg = smi_info->curr_msg;
 261
 262         /* Make it a reponse */
 263         msg->rsp[0] = msg->data[0] | 4;
 264         msg->rsp[1] = msg->data[1];
 265         msg->rsp[2] = 0xFF; /* Unknown error. */
 266         msg->rsp_size = 3;
 267
 268         smi_info->curr_msg = NULL;
 269         deliver_recv_msg(smi_info, msg);
 270 }
 271
 272 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
 273 {
 274         int              rv;
 275         struct list_head *entry = NULL;
 276 #ifdef DEBUG_TIMING
 277         struct timeval t;
 278 #endif
 279
 280         /* No need to save flags, we aleady have interrupts off and we
 281            already hold the SMI lock. */
 282         spin_lock(&(smi_info->msg_lock));
 283
 284         /* Pick the high priority queue first. */
 285         if (!list_empty(&(smi_info->hp_xmit_msgs))) {
 286                 entry = smi_info->hp_xmit_msgs.next;
 287         } else if (!list_empty(&(smi_info->xmit_msgs))) {
 288                 entry = smi_info->xmit_msgs.next;
 289         }
 290
 291         if (!entry) {
 292                 smi_info->curr_msg = NULL;
 293                 rv = SI_SM_IDLE;
 294         } else {
 295                 int err;
 296
 297                 list_del(entry);
 298                 smi_info->curr_msg = list_entry(entry,
 299                                                 struct ipmi_smi_msg,
 300                                                 link);
 301 #ifdef DEBUG_TIMING
 302                 do_gettimeofday(&t);
 303                 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 304 #endif
 305                 err = atomic_notifier_call_chain(&xaction_notifier_list,
 306                                 0, smi_info);
 307                 if (err & NOTIFY_STOP_MASK) {
 308                         rv = SI_SM_CALL_WITHOUT_DELAY;
 309                         goto out;
 310                 }
 311                 err = smi_info->handlers->start_transaction(
 312                         smi_info->si_sm,
 313                         smi_info->curr_msg->data,
 314                         smi_info->curr_msg->data_size);
 315                 if (err) {
 316                         return_hosed_msg(smi_info);
 317                 }
 318
 319                 rv = SI_SM_CALL_WITHOUT_DELAY;
 320         }
 321         out:
 322         spin_unlock(&(smi_info->msg_lock));
 323
 324         return rv;
 325 }
 326
 327 static void start_enable_irq(struct smi_info *smi_info)
 328 {
 329         unsigned char msg[2];
 330
 331         /* If we are enabling interrupts, we have to tell the
 332            BMC to use them. */
 333         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 334         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
 335
 336         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
 337         smi_info->si_state = SI_ENABLE_INTERRUPTS1;
 338 }
 339
 340 static void start_clear_flags(struct smi_info *smi_info)
 341 {
 342         unsigned char msg[3];
 343
 344         /* Make sure the watchdog pre-timeout flag is not set at startup. */
 345         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 346         msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
 347         msg[2] = WDT_PRE_TIMEOUT_INT;
 348
 349         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
 350         smi_info->si_state = SI_CLEARING_FLAGS;
 351 }
 352
 353 /* When we have a situtaion where we run out of memory and cannot
 354    allocate messages, we just leave them in the BMC and run the system
 355    polled until we can allocate some memory.  Once we have some
 356    memory, we will re-enable the interrupt. */
 357 static inline void disable_si_irq(struct smi_info *smi_info)
 358 {
 359         if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
 360                 disable_irq_nosync(smi_info->irq);
 361                 smi_info->interrupt_disabled = 1;
 362         }
 363 }
 364
 365 static inline void enable_si_irq(struct smi_info *smi_info)
 366 {
 367         if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
 368                 enable_irq(smi_info->irq);
 369                 smi_info->interrupt_disabled = 0;
 370         }
 371 }
 372
 373 static void handle_flags(struct smi_info *smi_info)
 374 {
 375  retry:
 376         if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
 377                 /* Watchdog pre-timeout */
 378                 spin_lock(&smi_info->count_lock);
 379                 smi_info->watchdog_pretimeouts++;
 380                 spin_unlock(&smi_info->count_lock);
 381
 382                 start_clear_flags(smi_info);
 383                 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
 384                 spin_unlock(&(smi_info->si_lock));
 385                 ipmi_smi_watchdog_pretimeout(smi_info->intf);
 386                 spin_lock(&(smi_info->si_lock));
 387         } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
 388                 /* Messages available. */
 389                 smi_info->curr_msg = ipmi_alloc_smi_msg();
 390                 if (!smi_info->curr_msg) {
 391                         disable_si_irq(smi_info);
 392                         smi_info->si_state = SI_NORMAL;
 393                         return;
 394                 }
 395                 enable_si_irq(smi_info);
 396
 397                 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 398                 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
 399                 smi_info->curr_msg->data_size = 2;
 400
 401                 smi_info->handlers->start_transaction(
 402                         smi_info->si_sm,
 403                         smi_info->curr_msg->data,
 404                         smi_info->curr_msg->data_size);
 405                 smi_info->si_state = SI_GETTING_MESSAGES;
 406         } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
 407                 /* Events available. */
 408                 smi_info->curr_msg = ipmi_alloc_smi_msg();
 409                 if (!smi_info->curr_msg) {
 410                         disable_si_irq(smi_info);
 411                         smi_info->si_state = SI_NORMAL;
 412                         return;
 413                 }
 414                 enable_si_irq(smi_info);
 415
 416                 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 417                 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
 418                 smi_info->curr_msg->data_size = 2;
 419
 420                 smi_info->handlers->start_transaction(
 421                         smi_info->si_sm,
 422                         smi_info->curr_msg->data,
 423                         smi_info->curr_msg->data_size);
 424                 smi_info->si_state = SI_GETTING_EVENTS;
 425         } else if (smi_info->msg_flags & OEM_DATA_AVAIL) {
 426                 if (smi_info->oem_data_avail_handler)
 427                         if (smi_info->oem_data_avail_handler(smi_info))
 428                                 goto retry;
 429         } else {
 430                 smi_info->si_state = SI_NORMAL;
 431         }
 432 }
 433
 434 static void handle_transaction_done(struct smi_info *smi_info)
 435 {
 436         struct ipmi_smi_msg *msg;
 437 #ifdef DEBUG_TIMING
 438         struct timeval t;
 439
 440         do_gettimeofday(&t);
 441         printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 442 #endif
 443         switch (smi_info->si_state) {
 444         case SI_NORMAL:
 445                 if (!smi_info->curr_msg)
 446                         break;
 447
 448                 smi_info->curr_msg->rsp_size
 449                         = smi_info->handlers->get_result(
 450                                 smi_info->si_sm,
 451                                 smi_info->curr_msg->rsp,
 452                                 IPMI_MAX_MSG_LENGTH);
 453
 454                 /* Do this here becase deliver_recv_msg() releases the
 455                    lock, and a new message can be put in during the
 456                    time the lock is released. */
 457                 msg = smi_info->curr_msg;
 458                 smi_info->curr_msg = NULL;
 459                 deliver_recv_msg(smi_info, msg);
 460                 break;
 461
 462         case SI_GETTING_FLAGS:
 463         {
 464                 unsigned char msg[4];
 465                 unsigned int  len;
 466
 467                 /* We got the flags from the SMI, now handle them. */
 468                 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 469                 if (msg[2] != 0) {
 470                         /* Error fetching flags, just give up for
 471                            now. */
 472                         smi_info->si_state = SI_NORMAL;
 473                 } else if (len < 4) {
 474                         /* Hmm, no flags.  That's technically illegal, but
 475                            don't use uninitialized data. */
 476                         smi_info->si_state = SI_NORMAL;
 477                 } else {
 478                         smi_info->msg_flags = msg[3];
 479                         handle_flags(smi_info);
 480                 }
 481                 break;
 482         }
 483
 484         case SI_CLEARING_FLAGS:
 485         case SI_CLEARING_FLAGS_THEN_SET_IRQ:
 486         {
 487                 unsigned char msg[3];
 488
 489                 /* We cleared the flags. */
 490                 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
 491                 if (msg[2] != 0) {
 492                         /* Error clearing flags */
 493                         printk(KERN_WARNING
 494                                "ipmi_si: Error clearing flags: %2.2x\n",
 495                                msg[2]);
 496                 }
 497                 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
 498                         start_enable_irq(smi_info);
 499                 else
 500                         smi_info->si_state = SI_NORMAL;
 501                 break;
 502         }
 503
 504         case SI_GETTING_EVENTS:
 505         {
 506                 smi_info->curr_msg->rsp_size
 507                         = smi_info->handlers->get_result(
 508                                 smi_info->si_sm,
 509                                 smi_info->curr_msg->rsp,
 510                                 IPMI_MAX_MSG_LENGTH);
 511
 512                 /* Do this here becase deliver_recv_msg() releases the
 513                    lock, and a new message can be put in during the
 514                    time the lock is released. */
 515                 msg = smi_info->curr_msg;
 516                 smi_info->curr_msg = NULL;
 517                 if (msg->rsp[2] != 0) {
 518                         /* Error getting event, probably done. */
 519                         msg->done(msg);
 520
 521                         /* Take off the event flag. */
 522                         smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
 523                         handle_flags(smi_info);
 524                 } else {
 525                         spin_lock(&smi_info->count_lock);
 526                         smi_info->events++;
 527                         spin_unlock(&smi_info->count_lock);
 528
 529                         /* Do this before we deliver the message
 530                            because delivering the message releases the
 531                            lock and something else can mess with the
 532                            state. */
 533                         handle_flags(smi_info);
 534
 535                         deliver_recv_msg(smi_info, msg);
 536                 }
 537                 break;
 538         }
 539
 540         case SI_GETTING_MESSAGES:
 541         {
 542                 smi_info->curr_msg->rsp_size
 543                         = smi_info->handlers->get_result(
 544                                 smi_info->si_sm,
 545                                 smi_info->curr_msg->rsp,
 546                                 IPMI_MAX_MSG_LENGTH);
 547
 548                 /* Do this here becase deliver_recv_msg() releases the
 549                    lock, and a new message can be put in during the
 550                    time the lock is released. */
 551                 msg = smi_info->curr_msg;
 552                 smi_info->curr_msg = NULL;
 553                 if (msg->rsp[2] != 0) {
 554                         /* Error getting event, probably done. */
 555                         msg->done(msg);
 556
 557                         /* Take off the msg flag. */
 558                         smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
 559                         handle_flags(smi_info);
 560                 } else {
 561                         spin_lock(&smi_info->count_lock);
 562                         smi_info->incoming_messages++;
 563                         spin_unlock(&smi_info->count_lock);
 564
 565                         /* Do this before we deliver the message
 566                            because delivering the message releases the
 567                            lock and something else can mess with the
 568                            state. */
 569                         handle_flags(smi_info);
 570
 571                         deliver_recv_msg(smi_info, msg);
 572                 }
 573                 break;
 574         }
 575
 576         case SI_ENABLE_INTERRUPTS1:
 577         {
 578                 unsigned char msg[4];
 579
 580                 /* We got the flags from the SMI, now handle them. */
 581                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 582                 if (msg[2] != 0) {
 583                         printk(KERN_WARNING
 584                                "ipmi_si: Could not enable interrupts"
 585                                ", failed get, using polled mode.\n");
 586                         smi_info->si_state = SI_NORMAL;
 587                 } else {
 588                         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 589                         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
 590                         msg[2] = msg[3] | 1; /* enable msg queue int */
 591                         smi_info->handlers->start_transaction(
 592                                 smi_info->si_sm, msg, 3);
 593                         smi_info->si_state = SI_ENABLE_INTERRUPTS2;
 594                 }
 595                 break;
 596         }
 597
 598         case SI_ENABLE_INTERRUPTS2:
 599         {
 600                 unsigned char msg[4];
 601
 602                 /* We got the flags from the SMI, now handle them. */
 603                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 604                 if (msg[2] != 0) {
 605                         printk(KERN_WARNING
 606                                "ipmi_si: Could not enable interrupts"
 607                                ", failed set, using polled mode.\n");
 608                 }
 609                 smi_info->si_state = SI_NORMAL;
 610                 break;
 611         }
 612         }
 613 }
 614
 615 /* Called on timeouts and events.  Timeouts should pass the elapsed
 616    time, interrupts should pass in zero. */
 617 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
 618                                            int time)
 619 {
 620         enum si_sm_result si_sm_result;
 621
 622  restart:
 623         /* There used to be a loop here that waited a little while
 624            (around 25us) before giving up.  That turned out to be
 625            pointless, the minimum delays I was seeing were in the 300us
 626            range, which is far too long to wait in an interrupt.  So
 627            we just run until the state machine tells us something
 628            happened or it needs a delay. */
 629         si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
 630         time = 0;
 631         while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
 632         {
 633                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
 634         }
 635
 636         if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
 637         {
 638                 spin_lock(&smi_info->count_lock);
 639                 smi_info->complete_transactions++;
 640                 spin_unlock(&smi_info->count_lock);
 641
 642                 handle_transaction_done(smi_info);
 643                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
 644         }
 645         else if (si_sm_result == SI_SM_HOSED)
 646         {
 647                 spin_lock(&smi_info->count_lock);
 648                 smi_info->hosed_count++;
 649                 spin_unlock(&smi_info->count_lock);
 650
 651                 /* Do the before return_hosed_msg, because that
 652                    releases the lock. */
 653                 smi_info->si_state = SI_NORMAL;
 654                 if (smi_info->curr_msg != NULL) {
 655                         /* If we were handling a user message, format
 656                            a response to send to the upper layer to
 657                            tell it about the error. */
 658                         return_hosed_msg(smi_info);
 659                 }
 660                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
 661         }
 662
 663         /* We prefer handling attn over new messages. */
 664         if (si_sm_result == SI_SM_ATTN)
 665         {
 666                 unsigned char msg[2];
 667
 668                 spin_lock(&smi_info->count_lock);
 669                 smi_info->attentions++;
 670                 spin_unlock(&smi_info->count_lock);
 671
 672                 /* Got a attn, send down a get message flags to see
 673                    what's causing it.  It would be better to handle
 674                    this in the upper layer, but due to the way
 675                    interrupts work with the SMI, that's not really
 676                    possible. */
 677                 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 678                 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
 679
 680                 smi_info->handlers->start_transaction(
 681                         smi_info->si_sm, msg, 2);
 682                 smi_info->si_state = SI_GETTING_FLAGS;
 683                 goto restart;
 684         }
 685
 686         /* If we are currently idle, try to start the next message. */
 687         if (si_sm_result == SI_SM_IDLE) {
 688                 spin_lock(&smi_info->count_lock);
 689                 smi_info->idles++;
 690                 spin_unlock(&smi_info->count_lock);
 691
 692                 si_sm_result = start_next_msg(smi_info);
 693                 if (si_sm_result != SI_SM_IDLE)
 694                         goto restart;
 695         }
 696
 697         if ((si_sm_result == SI_SM_IDLE)
 698             && (atomic_read(&smi_info->req_events)))
 699         {
 700                 /* We are idle and the upper layer requested that I fetch
 701                    events, so do so. */
 702                 unsigned char msg[2];
 703
 704                 spin_lock(&smi_info->count_lock);
 705                 smi_info->flag_fetches++;
 706                 spin_unlock(&smi_info->count_lock);
 707
 708                 atomic_set(&smi_info->req_events, 0);
 709                 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 710                 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
 711
 712                 smi_info->handlers->start_transaction(
 713                         smi_info->si_sm, msg, 2);
 714                 smi_info->si_state = SI_GETTING_FLAGS;
 715                 goto restart;
 716         }
 717
 718         return si_sm_result;
 719 }
 720
 721 static void sender(void                *send_info,
 722                    struct ipmi_smi_msg *msg,
 723                    int                 priority)
 724 {
 725         struct smi_info   *smi_info = send_info;
 726         enum si_sm_result result;
 727         unsigned long     flags;
 728 #ifdef DEBUG_TIMING
 729         struct timeval    t;
 730 #endif
 731
 732         spin_lock_irqsave(&(smi_info->msg_lock), flags);
 733 #ifdef DEBUG_TIMING
 734         do_gettimeofday(&t);
 735         printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 736 #endif
 737
 738         if (smi_info->run_to_completion) {
 739                 /* If we are running to completion, then throw it in
 740                    the list and run transactions until everything is
 741                    clear.  Priority doesn't matter here. */
 742                 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
 743
 744                 /* We have to release the msg lock and claim the smi
 745                    lock in this case, because of race conditions. */
 746                 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
 747
 748                 spin_lock_irqsave(&(smi_info->si_lock), flags);
 749                 result = smi_event_handler(smi_info, 0);
 750                 while (result != SI_SM_IDLE) {
 751                         udelay(SI_SHORT_TIMEOUT_USEC);
 752                         result = smi_event_handler(smi_info,
 753                                                    SI_SHORT_TIMEOUT_USEC);
 754                 }
 755                 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 756                 return;
 757         } else {
 758                 if (priority > 0) {
 759                         list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
 760                 } else {
 761                         list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
 762                 }
 763         }
 764         spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
 765
 766         spin_lock_irqsave(&(smi_info->si_lock), flags);
 767         if ((smi_info->si_state == SI_NORMAL)
 768             && (smi_info->curr_msg == NULL))
 769         {
 770                 start_next_msg(smi_info);
 771                 si_restart_short_timer(smi_info);
 772         }
 773         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 774 }
 775
 776 static void set_run_to_completion(void *send_info, int i_run_to_completion)
 777 {
 778         struct smi_info   *smi_info = send_info;
 779         enum si_sm_result result;
 780         unsigned long     flags;
 781
 782         spin_lock_irqsave(&(smi_info->si_lock), flags);
 783
 784         smi_info->run_to_completion = i_run_to_completion;
 785         if (i_run_to_completion) {
 786                 result = smi_event_handler(smi_info, 0);
 787                 while (result != SI_SM_IDLE) {
 788                         udelay(SI_SHORT_TIMEOUT_USEC);
 789                         result = smi_event_handler(smi_info,
 790                                                    SI_SHORT_TIMEOUT_USEC);
 791                 }
 792         }
 793
 794         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 795 }
 796
 797 static int ipmi_thread(void *data)
 798 {
 799         struct smi_info *smi_info = data;
 800         unsigned long flags;
 801         enum si_sm_result smi_result;
 802
 803         set_user_nice(current, 19);
 804         while (!kthread_should_stop()) {
 805                 spin_lock_irqsave(&(smi_info->si_lock), flags);
 806                 smi_result=smi_event_handler(smi_info, 0);
 807                 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 808                 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
 809                         /* do nothing */
 810                 }
 811                 else if (smi_result == SI_SM_CALL_WITH_DELAY)
 812                         udelay(1);
 813                 else
 814                         schedule_timeout_interruptible(1);
 815         }
 816         return 0;
 817 }
 818
 819
 820 static void poll(void *send_info)
 821 {
 822         struct smi_info *smi_info = send_info;
 823
 824         smi_event_handler(smi_info, 0);
 825 }
 826
 827 static void request_events(void *send_info)
 828 {
 829         struct smi_info *smi_info = send_info;
 830
 831         atomic_set(&smi_info->req_events, 1);
 832 }
 833
 834 static int initialized = 0;
 835
 836 /* Must be called with interrupts off and with the si_lock held. */
 837 static void si_restart_short_timer(struct smi_info *smi_info)
 838 {
 839 #if defined(CONFIG_HIGH_RES_TIMERS)
 840         unsigned long flags;
 841         unsigned long jiffies_now;
 842         unsigned long seq;
 843
 844         if (del_timer(&(smi_info->si_timer))) {
 845                 /* If we don't delete the timer, then it will go off
 846                    immediately, anyway.  So we only process if we
 847                    actually delete the timer. */
 848
 849                 do {
 850                         seq = read_seqbegin_irqsave(&xtime_lock, flags);
 851                         jiffies_now = jiffies;
 852                         smi_info->si_timer.expires = jiffies_now;
 853                         smi_info->si_timer.arch_cycle_expires
 854                                 = get_arch_cycles(jiffies_now);
 855                 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
 856
 857                 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
 858
 859                 add_timer(&(smi_info->si_timer));
 860                 spin_lock_irqsave(&smi_info->count_lock, flags);
 861                 smi_info->timeout_restarts++;
 862                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
 863         }
 864 #endif
 865 }
 866
 867 static void smi_timeout(unsigned long data)
 868 {
 869         struct smi_info   *smi_info = (struct smi_info *) data;
 870         enum si_sm_result smi_result;
 871         unsigned long     flags;
 872         unsigned long     jiffies_now;
 873         long              time_diff;
 874 #ifdef DEBUG_TIMING
 875         struct timeval    t;
 876 #endif
 877
 878         if (atomic_read(&smi_info->stop_operation))
 879                 return;
 880
 881         spin_lock_irqsave(&(smi_info->si_lock), flags);
 882 #ifdef DEBUG_TIMING
 883         do_gettimeofday(&t);
 884         printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 885 #endif
 886         jiffies_now = jiffies;
 887         time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
 888                      * SI_USEC_PER_JIFFY);
 889         smi_result = smi_event_handler(smi_info, time_diff);
 890
 891         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 892
 893         smi_info->last_timeout_jiffies = jiffies_now;
 894
 895         if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
 896                 /* Running with interrupts, only do long timeouts. */
 897                 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
 898                 spin_lock_irqsave(&smi_info->count_lock, flags);
 899                 smi_info->long_timeouts++;
 900                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
 901                 goto do_add_timer;
 902         }
 903
 904         /* If the state machine asks for a short delay, then shorten
 905            the timer timeout. */
 906         if (smi_result == SI_SM_CALL_WITH_DELAY) {
 907 #if defined(CONFIG_HIGH_RES_TIMERS)
 908                 unsigned long seq;
 909 #endif
 910                 spin_lock_irqsave(&smi_info->count_lock, flags);
 911                 smi_info->short_timeouts++;
 912                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
 913 #if defined(CONFIG_HIGH_RES_TIMERS)
 914                 do {
 915                         seq = read_seqbegin_irqsave(&xtime_lock, flags);
 916                         smi_info->si_timer.expires = jiffies;
 917                         smi_info->si_timer.arch_cycle_expires
 918                                 = get_arch_cycles(smi_info->si_timer.expires);
 919                 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
 920                 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
 921 #else
 922                 smi_info->si_timer.expires = jiffies + 1;
 923 #endif
 924         } else {
 925                 spin_lock_irqsave(&smi_info->count_lock, flags);
 926                 smi_info->long_timeouts++;
 927                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
 928                 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
 929 #if defined(CONFIG_HIGH_RES_TIMERS)
 930                 smi_info->si_timer.arch_cycle_expires = 0;
 931 #endif
 932         }
 933
 934  do_add_timer:
 935         add_timer(&(smi_info->si_timer));
 936 }
 937
 938 static irqreturn_t si_irq_handler(int irq, void *data, struct pt_regs *regs)
 939 {
 940         struct smi_info *smi_info = data;
 941         unsigned long   flags;
 942 #ifdef DEBUG_TIMING
 943         struct timeval  t;
 944 #endif
 945
 946         spin_lock_irqsave(&(smi_info->si_lock), flags);
 947
 948         spin_lock(&smi_info->count_lock);
 949         smi_info->interrupts++;
 950         spin_unlock(&smi_info->count_lock);
 951
 952         if (atomic_read(&smi_info->stop_operation))
 953                 goto out;
 954
 955 #ifdef DEBUG_TIMING
 956         do_gettimeofday(&t);
 957         printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 958 #endif
 959         smi_event_handler(smi_info, 0);
 960  out:
 961         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 962         return IRQ_HANDLED;
 963 }
 964
 965 static irqreturn_t si_bt_irq_handler(int irq, void *data, struct pt_regs *regs)
 966 {
 967         struct smi_info *smi_info = data;
 968         /* We need to clear the IRQ flag for the BT interface. */
 969         smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
 970                              IPMI_BT_INTMASK_CLEAR_IRQ_BIT
 971                              | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
 972         return si_irq_handler(irq, data, regs);
 973 }
 974
 975
 976 static struct ipmi_smi_handlers handlers =
 977 {
 978         .owner                  = THIS_MODULE,
 979         .sender                 = sender,
 980         .request_events         = request_events,
 981         .set_run_to_completion  = set_run_to_completion,
 982         .poll                   = poll,
 983 };
 984
 985 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
 986    a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS */
 987
 988 #define SI_MAX_PARMS 4
 989 static LIST_HEAD(smi_infos);
 990 static DECLARE_MUTEX(smi_infos_lock);
 991 static int smi_num; /* Used to sequence the SMIs */
 992
 993 #define DEFAULT_REGSPACING      1
 994
 995 static int           si_trydefaults = 1;
 996 static char          *si_type[SI_MAX_PARMS];
 997 #define MAX_SI_TYPE_STR 30
 998 static char          si_type_str[MAX_SI_TYPE_STR];
 999 static unsigned long addrs[SI_MAX_PARMS];
1000 static int num_addrs;
1001 static unsigned int  ports[SI_MAX_PARMS];
1002 static int num_ports;
1003 static int           irqs[SI_MAX_PARMS];
1004 static int num_irqs;
1005 static int           regspacings[SI_MAX_PARMS];
1006 static int num_regspacings = 0;
1007 static int           regsizes[SI_MAX_PARMS];
1008 static int num_regsizes = 0;
1009 static int           regshifts[SI_MAX_PARMS];
1010 static int num_regshifts = 0;
1011 static int slave_addrs[SI_MAX_PARMS];
1012 static int num_slave_addrs = 0;
1013
1014
1015 module_param_named(trydefaults, si_trydefaults, bool, 0);
1016 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1017                  " default scan of the KCS and SMIC interface at the standard"
1018                  " address");
1019 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1020 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1021                  " interface separated by commas.  The types are 'kcs',"
1022                  " 'smic', and 'bt'.  For example si_type=kcs,bt will set"
1023                  " the first interface to kcs and the second to bt");
1024 module_param_array(addrs, long, &num_addrs, 0);
1025 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1026                  " addresses separated by commas.  Only use if an interface"
1027                  " is in memory.  Otherwise, set it to zero or leave"
1028                  " it blank.");
1029 module_param_array(ports, int, &num_ports, 0);
1030 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1031                  " addresses separated by commas.  Only use if an interface"
1032                  " is a port.  Otherwise, set it to zero or leave"
1033                  " it blank.");
1034 module_param_array(irqs, int, &num_irqs, 0);
1035 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1036                  " addresses separated by commas.  Only use if an interface"
1037                  " has an interrupt.  Otherwise, set it to zero or leave"
1038                  " it blank.");
1039 module_param_array(regspacings, int, &num_regspacings, 0);
1040 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1041                  " and each successive register used by the interface.  For"
1042                  " instance, if the start address is 0xca2 and the spacing"
1043                  " is 2, then the second address is at 0xca4.  Defaults"
1044                  " to 1.");
1045 module_param_array(regsizes, int, &num_regsizes, 0);
1046 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1047                  " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1048                  " 16-bit, 32-bit, or 64-bit register.  Use this if you"
1049                  " the 8-bit IPMI register has to be read from a larger"
1050                  " register.");
1051 module_param_array(regshifts, int, &num_regshifts, 0);
1052 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1053                  " IPMI register, in bits.  For instance, if the data"
1054                  " is read from a 32-bit word and the IPMI data is in"
1055                  " bit 8-15, then the shift would be 8");
1056 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1057 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1058                  " the controller.  Normally this is 0x20, but can be"
1059                  " overridden by this parm.  This is an array indexed"
1060                  " by interface number.");
1061
1062
1063 #define IPMI_IO_ADDR_SPACE  0
1064 #define IPMI_MEM_ADDR_SPACE 1
1065 static char *addr_space_to_str[] = { "I/O", "memory" };
1066
1067 static void std_irq_cleanup(struct smi_info *info)
1068 {
1069         if (info->si_type == SI_BT)
1070                 /* Disable the interrupt in the BT interface. */
1071                 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1072         free_irq(info->irq, info);
1073 }
1074
1075 static int std_irq_setup(struct smi_info *info)
1076 {
1077         int rv;
1078
1079         if (!info->irq)
1080                 return 0;
1081
1082         if (info->si_type == SI_BT) {
1083                 rv = request_irq(info->irq,
1084                                  si_bt_irq_handler,
1085                                  SA_INTERRUPT,
1086                                  DEVICE_NAME,
1087                                  info);
1088                 if (!rv)
1089                         /* Enable the interrupt in the BT interface. */
1090                         info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1091                                          IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1092         } else
1093                 rv = request_irq(info->irq,
1094                                  si_irq_handler,
1095                                  SA_INTERRUPT,
1096                                  DEVICE_NAME,
1097                                  info);
1098         if (rv) {
1099                 printk(KERN_WARNING
1100                        "ipmi_si: %s unable to claim interrupt %d,"
1101                        " running polled\n",
1102                        DEVICE_NAME, info->irq);
1103                 info->irq = 0;
1104         } else {
1105                 info->irq_cleanup = std_irq_cleanup;
1106                 printk("  Using irq %d\n", info->irq);
1107         }
1108
1109         return rv;
1110 }
1111
1112 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1113 {
1114         unsigned int addr = io->addr_data;
1115
1116         return inb(addr + (offset * io->regspacing));
1117 }
1118
1119 static void port_outb(struct si_sm_io *io, unsigned int offset,
1120                       unsigned char b)
1121 {
1122         unsigned int addr = io->addr_data;
1123
1124         outb(b, addr + (offset * io->regspacing));
1125 }
1126
1127 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1128 {
1129         unsigned int addr = io->addr_data;
1130
1131         return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1132 }
1133
1134 static void port_outw(struct si_sm_io *io, unsigned int offset,
1135                       unsigned char b)
1136 {
1137         unsigned int addr = io->addr_data;
1138
1139         outw(b << io->regshift, addr + (offset * io->regspacing));
1140 }
1141
1142 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1143 {
1144         unsigned int addr = io->addr_data;
1145
1146         return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1147 }
1148
1149 static void port_outl(struct si_sm_io *io, unsigned int offset,
1150                       unsigned char b)
1151 {
1152         unsigned int addr = io->addr_data;
1153
1154         outl(b << io->regshift, addr+(offset * io->regspacing));
1155 }
1156
1157 static void port_cleanup(struct smi_info *info)
1158 {
1159         unsigned int addr = info->io.addr_data;
1160         int          mapsize;
1161
1162         if (addr) {
1163                 mapsize = ((info->io_size * info->io.regspacing)
1164                            - (info->io.regspacing - info->io.regsize));
1165
1166                 release_region (addr, mapsize);
1167         }
1168 }
1169
1170 static int port_setup(struct smi_info *info)
1171 {
1172         unsigned int addr = info->io.addr_data;
1173         int          mapsize;
1174
1175         if (!addr)
1176                 return -ENODEV;
1177
1178         info->io_cleanup = port_cleanup;
1179
1180         /* Figure out the actual inb/inw/inl/etc routine to use based
1181            upon the register size. */
1182         switch (info->io.regsize) {
1183         case 1:
1184                 info->io.inputb = port_inb;
1185                 info->io.outputb = port_outb;
1186                 break;
1187         case 2:
1188                 info->io.inputb = port_inw;
1189                 info->io.outputb = port_outw;
1190                 break;
1191         case 4:
1192                 info->io.inputb = port_inl;
1193                 info->io.outputb = port_outl;
1194                 break;
1195         default:
1196                 printk("ipmi_si: Invalid register size: %d\n",
1197                        info->io.regsize);
1198                 return -EINVAL;
1199         }
1200
1201         /* Calculate the total amount of memory to claim.  This is an
1202          * unusual looking calculation, but it avoids claiming any
1203          * more memory than it has to.  It will claim everything
1204          * between the first address to the end of the last full
1205          * register. */
1206         mapsize = ((info->io_size * info->io.regspacing)
1207                    - (info->io.regspacing - info->io.regsize));
1208
1209         if (request_region(addr, mapsize, DEVICE_NAME) == NULL)
1210                 return -EIO;
1211         return 0;
1212 }
1213
1214 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1215 {
1216         return readb((io->addr)+(offset * io->regspacing));
1217 }
1218
1219 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1220                      unsigned char b)
1221 {
1222         writeb(b, (io->addr)+(offset * io->regspacing));
1223 }
1224
1225 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1226 {
1227         return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1228                 && 0xff;
1229 }
1230
1231 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1232                      unsigned char b)
1233 {
1234         writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1235 }
1236
1237 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1238 {
1239         return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1240                 && 0xff;
1241 }
1242
1243 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1244                      unsigned char b)
1245 {
1246         writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1247 }
1248
1249 #ifdef readq
1250 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1251 {
1252         return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1253                 && 0xff;
1254 }
1255
1256 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1257                      unsigned char b)
1258 {
1259         writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1260 }
1261 #endif
1262
1263 static void mem_cleanup(struct smi_info *info)
1264 {
1265         unsigned long addr = info->io.addr_data;
1266         int           mapsize;
1267
1268         if (info->io.addr) {
1269                 iounmap(info->io.addr);
1270
1271                 mapsize = ((info->io_size * info->io.regspacing)
1272                            - (info->io.regspacing - info->io.regsize));
1273
1274                 release_mem_region(addr, mapsize);
1275         }
1276 }
1277
1278 static int mem_setup(struct smi_info *info)
1279 {
1280         unsigned long addr = info->io.addr_data;
1281         int           mapsize;
1282
1283         if (!addr)
1284                 return -ENODEV;
1285
1286         info->io_cleanup = mem_cleanup;
1287
1288         /* Figure out the actual readb/readw/readl/etc routine to use based
1289            upon the register size. */
1290         switch (info->io.regsize) {
1291         case 1:
1292                 info->io.inputb = intf_mem_inb;
1293                 info->io.outputb = intf_mem_outb;
1294                 break;
1295         case 2:
1296                 info->io.inputb = intf_mem_inw;
1297                 info->io.outputb = intf_mem_outw;
1298                 break;
1299         case 4:
1300                 info->io.inputb = intf_mem_inl;
1301                 info->io.outputb = intf_mem_outl;
1302                 break;
1303 #ifdef readq
1304         case 8:
1305                 info->io.inputb = mem_inq;
1306                 info->io.outputb = mem_outq;
1307                 break;
1308 #endif
1309         default:
1310                 printk("ipmi_si: Invalid register size: %d\n",
1311                        info->io.regsize);
1312                 return -EINVAL;
1313         }
1314
1315         /* Calculate the total amount of memory to claim.  This is an
1316          * unusual looking calculation, but it avoids claiming any
1317          * more memory than it has to.  It will claim everything
1318          * between the first address to the end of the last full
1319          * register. */
1320         mapsize = ((info->io_size * info->io.regspacing)
1321                    - (info->io.regspacing - info->io.regsize));
1322
1323         if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1324                 return -EIO;
1325
1326         info->io.addr = ioremap(addr, mapsize);
1327         if (info->io.addr == NULL) {
1328                 release_mem_region(addr, mapsize);
1329                 return -EIO;
1330         }
1331         return 0;
1332 }
1333
1334
1335 static __devinit void hardcode_find_bmc(void)
1336 {
1337         int             i;
1338         struct smi_info *info;
1339
1340         for (i = 0; i < SI_MAX_PARMS; i++) {
1341                 if (!ports[i] && !addrs[i])
1342                         continue;
1343
1344                 info = kzalloc(sizeof(*info), GFP_KERNEL);
1345                 if (!info)
1346                         return;
1347
1348                 info->addr_source = "hardcoded";
1349
1350                 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1351                         info->si_type = SI_KCS;
1352                 } else if (strcmp(si_type[i], "smic") == 0) {
1353                         info->si_type = SI_SMIC;
1354                 } else if (strcmp(si_type[i], "bt") == 0) {
1355                         info->si_type = SI_BT;
1356                 } else {
1357                         printk(KERN_WARNING
1358                                "ipmi_si: Interface type specified "
1359                                "for interface %d, was invalid: %s\n",
1360                                i, si_type[i]);
1361                         kfree(info);
1362                         continue;
1363                 }
1364
1365                 if (ports[i]) {
1366                         /* An I/O port */
1367                         info->io_setup = port_setup;
1368                         info->io.addr_data = ports[i];
1369                         info->io.addr_type = IPMI_IO_ADDR_SPACE;
1370                 } else if (addrs[i]) {
1371                         /* A memory port */
1372                         info->io_setup = mem_setup;
1373                         info->io.addr_data = addrs[i];
1374                         info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1375                 } else {
1376                         printk(KERN_WARNING
1377                                "ipmi_si: Interface type specified "
1378                                "for interface %d, "
1379                                "but port and address were not set or "
1380                                "set to zero.\n", i);
1381                         kfree(info);
1382                         continue;
1383                 }
1384
1385                 info->io.addr = NULL;
1386                 info->io.regspacing = regspacings[i];
1387                 if (!info->io.regspacing)
1388                         info->io.regspacing = DEFAULT_REGSPACING;
1389                 info->io.regsize = regsizes[i];
1390                 if (!info->io.regsize)
1391                         info->io.regsize = DEFAULT_REGSPACING;
1392                 info->io.regshift = regshifts[i];
1393                 info->irq = irqs[i];
1394                 if (info->irq)
1395                         info->irq_setup = std_irq_setup;
1396
1397                 try_smi_init(info);
1398         }
1399 }
1400
1401 #ifdef CONFIG_ACPI
1402
1403 #include <linux/acpi.h>
1404
1405 /* Once we get an ACPI failure, we don't try any more, because we go
1406    through the tables sequentially.  Once we don't find a table, there
1407    are no more. */
1408 static int acpi_failure = 0;
1409
1410 /* For GPE-type interrupts. */
1411 static u32 ipmi_acpi_gpe(void *context)
1412 {
1413         struct smi_info *smi_info = context;
1414         unsigned long   flags;
1415 #ifdef DEBUG_TIMING
1416         struct timeval t;
1417 #endif
1418
1419         spin_lock_irqsave(&(smi_info->si_lock), flags);
1420
1421         spin_lock(&smi_info->count_lock);
1422         smi_info->interrupts++;
1423         spin_unlock(&smi_info->count_lock);
1424
1425         if (atomic_read(&smi_info->stop_operation))
1426                 goto out;
1427
1428 #ifdef DEBUG_TIMING
1429         do_gettimeofday(&t);
1430         printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1431 #endif
1432         smi_event_handler(smi_info, 0);
1433  out:
1434         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1435
1436         return ACPI_INTERRUPT_HANDLED;
1437 }
1438
1439 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1440 {
1441         if (!info->irq)
1442                 return;
1443
1444         acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1445 }
1446
1447 static int acpi_gpe_irq_setup(struct smi_info *info)
1448 {
1449         acpi_status status;
1450
1451         if (!info->irq)
1452                 return 0;
1453
1454         /* FIXME - is level triggered right? */
1455         status = acpi_install_gpe_handler(NULL,
1456                                           info->irq,
1457                                           ACPI_GPE_LEVEL_TRIGGERED,
1458                                           &ipmi_acpi_gpe,
1459                                           info);
1460         if (status != AE_OK) {
1461                 printk(KERN_WARNING
1462                        "ipmi_si: %s unable to claim ACPI GPE %d,"
1463                        " running polled\n",
1464                        DEVICE_NAME, info->irq);
1465                 info->irq = 0;
1466                 return -EINVAL;
1467         } else {
1468                 info->irq_cleanup = acpi_gpe_irq_cleanup;
1469                 printk("  Using ACPI GPE %d\n", info->irq);
1470                 return 0;
1471         }
1472 }
1473
1474 /*
1475  * Defined at
1476  * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1477  */
1478 struct SPMITable {
1479         s8      Signature[4];
1480         u32     Length;
1481         u8      Revision;
1482         u8      Checksum;
1483         s8      OEMID[6];
1484         s8      OEMTableID[8];
1485         s8      OEMRevision[4];
1486         s8      CreatorID[4];
1487         s8      CreatorRevision[4];
1488         u8      InterfaceType;
1489         u8      IPMIlegacy;
1490         s16     SpecificationRevision;
1491
1492         /*
1493          * Bit 0 - SCI interrupt supported
1494          * Bit 1 - I/O APIC/SAPIC
1495          */
1496         u8      InterruptType;
1497
1498         /* If bit 0 of InterruptType is set, then this is the SCI
1499            interrupt in the GPEx_STS register. */
1500         u8      GPE;
1501
1502         s16     Reserved;
1503
1504         /* If bit 1 of InterruptType is set, then this is the I/O
1505            APIC/SAPIC interrupt. */
1506         u32     GlobalSystemInterrupt;
1507
1508         /* The actual register address. */
1509         struct acpi_generic_address addr;
1510
1511         u8      UID[4];
1512
1513         s8      spmi_id[1]; /* A '\0' terminated array starts here. */
1514 };
1515
1516 static __devinit int try_init_acpi(struct SPMITable *spmi)
1517 {
1518         struct smi_info  *info;
1519         char             *io_type;
1520         u8               addr_space;
1521
1522         if (spmi->IPMIlegacy != 1) {
1523             printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1524             return -ENODEV;
1525         }
1526
1527         if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1528                 addr_space = IPMI_MEM_ADDR_SPACE;
1529         else
1530                 addr_space = IPMI_IO_ADDR_SPACE;
1531
1532         info = kzalloc(sizeof(*info), GFP_KERNEL);
1533         if (!info) {
1534                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1535                 return -ENOMEM;
1536         }
1537
1538         info->addr_source = "ACPI";
1539
1540         /* Figure out the interface type. */
1541         switch (spmi->InterfaceType)
1542         {
1543         case 1: /* KCS */
1544                 info->si_type = SI_KCS;
1545                 break;
1546         case 2: /* SMIC */
1547                 info->si_type = SI_SMIC;
1548                 break;
1549         case 3: /* BT */
1550                 info->si_type = SI_BT;
1551                 break;
1552         default:
1553                 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1554                         spmi->InterfaceType);
1555                 kfree(info);
1556                 return -EIO;
1557         }
1558
1559         if (spmi->InterruptType & 1) {
1560                 /* We've got a GPE interrupt. */
1561                 info->irq = spmi->GPE;
1562                 info->irq_setup = acpi_gpe_irq_setup;
1563         } else if (spmi->InterruptType & 2) {
1564                 /* We've got an APIC/SAPIC interrupt. */
1565                 info->irq = spmi->GlobalSystemInterrupt;
1566                 info->irq_setup = std_irq_setup;
1567         } else {
1568                 /* Use the default interrupt setting. */
1569                 info->irq = 0;
1570                 info->irq_setup = NULL;
1571         }
1572
1573         if (spmi->addr.register_bit_width) {
1574                 /* A (hopefully) properly formed register bit width. */
1575                 info->io.regspacing = spmi->addr.register_bit_width / 8;
1576         } else {
1577                 info->io.regspacing = DEFAULT_REGSPACING;
1578         }
1579         info->io.regsize = info->io.regspacing;
1580         info->io.regshift = spmi->addr.register_bit_offset;
1581
1582         if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1583                 io_type = "memory";
1584                 info->io_setup = mem_setup;
1585                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1586         } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1587                 io_type = "I/O";
1588                 info->io_setup = port_setup;
1589                 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1590         } else {
1591                 kfree(info);
1592                 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1593                 return -EIO;
1594         }
1595         info->io.addr_data = spmi->addr.address;
1596
1597         try_smi_init(info);
1598
1599         return 0;
1600 }
1601
1602 static __devinit void acpi_find_bmc(void)
1603 {
1604         acpi_status      status;
1605         struct SPMITable *spmi;
1606         int              i;
1607
1608         if (acpi_disabled)
1609                 return;
1610
1611         if (acpi_failure)
1612                 return;
1613
1614         for (i = 0; ; i++) {
1615                 status = acpi_get_firmware_table("SPMI", i+1,
1616                                                  ACPI_LOGICAL_ADDRESSING,
1617                                                  (struct acpi_table_header **)
1618                                                  &spmi);
1619                 if (status != AE_OK)
1620                         return;
1621
1622                 try_init_acpi(spmi);
1623         }
1624 }
1625 #endif
1626
1627 #ifdef CONFIG_DMI
1628 struct dmi_ipmi_data
1629 {
1630         u8              type;
1631         u8              addr_space;
1632         unsigned long   base_addr;
1633         u8              irq;
1634         u8              offset;
1635         u8              slave_addr;
1636 };
1637
1638 static int __devinit decode_dmi(struct dmi_header *dm,
1639                                 struct dmi_ipmi_data *dmi)
1640 {
1641         u8              *data = (u8 *)dm;
1642         unsigned long   base_addr;
1643         u8              reg_spacing;
1644         u8              len = dm->length;
1645
1646         dmi->type = data[4];
1647
1648         memcpy(&base_addr, data+8, sizeof(unsigned long));
1649         if (len >= 0x11) {
1650                 if (base_addr & 1) {
1651                         /* I/O */
1652                         base_addr &= 0xFFFE;
1653                         dmi->addr_space = IPMI_IO_ADDR_SPACE;
1654                 }
1655                 else {
1656                         /* Memory */
1657                         dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1658                 }
1659                 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1660                    is odd. */
1661                 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1662
1663                 dmi->irq = data[0x11];
1664
1665                 /* The top two bits of byte 0x10 hold the register spacing. */
1666                 reg_spacing = (data[0x10] & 0xC0) >> 6;
1667                 switch(reg_spacing){
1668                 case 0x00: /* Byte boundaries */
1669                     dmi->offset = 1;
1670                     break;
1671                 case 0x01: /* 32-bit boundaries */
1672                     dmi->offset = 4;
1673                     break;
1674                 case 0x02: /* 16-byte boundaries */
1675                     dmi->offset = 16;
1676                     break;
1677                 default:
1678                     /* Some other interface, just ignore it. */
1679                     return -EIO;
1680                 }
1681         } else {
1682                 /* Old DMI spec. */
1683                 /* Note that technically, the lower bit of the base
1684                  * address should be 1 if the address is I/O and 0 if
1685                  * the address is in memory.  So many systems get that
1686                  * wrong (and all that I have seen are I/O) so we just
1687                  * ignore that bit and assume I/O.  Systems that use
1688                  * memory should use the newer spec, anyway. */
1689                 dmi->base_addr = base_addr & 0xfffe;
1690                 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1691                 dmi->offset = 1;
1692         }
1693
1694         dmi->slave_addr = data[6];
1695
1696         return 0;
1697 }
1698
1699 static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
1700 {
1701         struct smi_info *info;
1702
1703         info = kzalloc(sizeof(*info), GFP_KERNEL);
1704         if (!info) {
1705                 printk(KERN_ERR
1706                        "ipmi_si: Could not allocate SI data\n");
1707                 return;
1708         }
1709
1710         info->addr_source = "SMBIOS";
1711
1712         switch (ipmi_data->type) {
1713         case 0x01: /* KCS */
1714                 info->si_type = SI_KCS;
1715                 break;
1716         case 0x02: /* SMIC */
1717                 info->si_type = SI_SMIC;
1718                 break;
1719         case 0x03: /* BT */
1720                 info->si_type = SI_BT;
1721                 break;
1722         default:
1723                 return;
1724         }
1725
1726         switch (ipmi_data->addr_space) {
1727         case IPMI_MEM_ADDR_SPACE:
1728                 info->io_setup = mem_setup;
1729                 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1730                 break;
1731
1732         case IPMI_IO_ADDR_SPACE:
1733                 info->io_setup = port_setup;
1734                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1735                 break;
1736
1737         default:
1738                 kfree(info);
1739                 printk(KERN_WARNING
1740                        "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
1741                        ipmi_data->addr_space);
1742                 return;
1743         }
1744         info->io.addr_data = ipmi_data->base_addr;
1745
1746         info->io.regspacing = ipmi_data->offset;
1747         if (!info->io.regspacing)
1748                 info->io.regspacing = DEFAULT_REGSPACING;
1749         info->io.regsize = DEFAULT_REGSPACING;
1750         info->io.regshift = 0;
1751
1752         info->slave_addr = ipmi_data->slave_addr;
1753
1754         info->irq = ipmi_data->irq;
1755         if (info->irq)
1756                 info->irq_setup = std_irq_setup;
1757
1758         try_smi_init(info);
1759 }
1760
1761 static void __devinit dmi_find_bmc(void)
1762 {
1763         struct dmi_device    *dev = NULL;
1764         struct dmi_ipmi_data data;
1765         int                  rv;
1766
1767         while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
1768                 rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
1769                 if (!rv)
1770                         try_init_dmi(&data);
1771         }
1772 }
1773 #endif /* CONFIG_DMI */
1774
1775 #ifdef CONFIG_PCI
1776
1777 #define PCI_ERMC_CLASSCODE              0x0C0700
1778 #define PCI_ERMC_CLASSCODE_MASK         0xffffff00
1779 #define PCI_ERMC_CLASSCODE_TYPE_MASK    0xff
1780 #define PCI_ERMC_CLASSCODE_TYPE_SMIC    0x00
1781 #define PCI_ERMC_CLASSCODE_TYPE_KCS     0x01
1782 #define PCI_ERMC_CLASSCODE_TYPE_BT      0x02
1783
1784 #define PCI_HP_VENDOR_ID    0x103C
1785 #define PCI_MMC_DEVICE_ID   0x121A
1786 #define PCI_MMC_ADDR_CW     0x10
1787
1788 static void ipmi_pci_cleanup(struct smi_info *info)
1789 {
1790         struct pci_dev *pdev = info->addr_source_data;
1791
1792         pci_disable_device(pdev);
1793 }
1794
1795 static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
1796                                     const struct pci_device_id *ent)
1797 {
1798         int rv;
1799         int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
1800         struct smi_info *info;
1801         int first_reg_offset = 0;
1802
1803         info = kzalloc(sizeof(*info), GFP_KERNEL);
1804         if (!info)
1805                 return ENOMEM;
1806
1807         info->addr_source = "PCI";
1808
1809         switch (class_type) {
1810         case PCI_ERMC_CLASSCODE_TYPE_SMIC:
1811                 info->si_type = SI_SMIC;
1812                 break;
1813
1814         case PCI_ERMC_CLASSCODE_TYPE_KCS:
1815                 info->si_type = SI_KCS;
1816                 break;
1817
1818         case PCI_ERMC_CLASSCODE_TYPE_BT:
1819                 info->si_type = SI_BT;
1820                 break;
1821
1822         default:
1823                 kfree(info);
1824                 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
1825                        pci_name(pdev), class_type);
1826                 return ENOMEM;
1827         }
1828
1829         rv = pci_enable_device(pdev);
1830         if (rv) {
1831                 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
1832                        pci_name(pdev));
1833                 kfree(info);
1834                 return rv;
1835         }
1836
1837         info->addr_source_cleanup = ipmi_pci_cleanup;
1838         info->addr_source_data = pdev;
1839
1840         if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
1841                 first_reg_offset = 1;
1842
1843         if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
1844                 info->io_setup = port_setup;
1845                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1846         } else {
1847                 info->io_setup = mem_setup;
1848                 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1849         }
1850         info->io.addr_data = pci_resource_start(pdev, 0);
1851
1852         info->io.regspacing = DEFAULT_REGSPACING;
1853         info->io.regsize = DEFAULT_REGSPACING;
1854         info->io.regshift = 0;
1855
1856         info->irq = pdev->irq;
1857         if (info->irq)
1858                 info->irq_setup = std_irq_setup;
1859
1860         info->dev = &pdev->dev;
1861
1862         return try_smi_init(info);
1863 }
1864
1865 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
1866 {
1867 }
1868
1869 #ifdef CONFIG_PM
1870 static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
1871 {
1872         return 0;
1873 }
1874
1875 static int ipmi_pci_resume(struct pci_dev *pdev)
1876 {
1877         return 0;
1878 }
1879 #endif
1880
1881 static struct pci_device_id ipmi_pci_devices[] = {
1882         { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
1883         { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE) }
1884 };
1885 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
1886
1887 static struct pci_driver ipmi_pci_driver = {
1888         .name =         DEVICE_NAME,
1889         .id_table =     ipmi_pci_devices,
1890         .probe =        ipmi_pci_probe,
1891         .remove =       __devexit_p(ipmi_pci_remove),
1892 #ifdef CONFIG_PM
1893         .suspend =      ipmi_pci_suspend,
1894         .resume =       ipmi_pci_resume,
1895 #endif
1896 };
1897 #endif /* CONFIG_PCI */
1898
1899
1900 static int try_get_dev_id(struct smi_info *smi_info)
1901 {
1902         unsigned char         msg[2];
1903         unsigned char         *resp;
1904         unsigned long         resp_len;
1905         enum si_sm_result     smi_result;
1906         int                   rv = 0;
1907
1908         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1909         if (!resp)
1910                 return -ENOMEM;
1911
1912         /* Do a Get Device ID command, since it comes back with some
1913            useful info. */
1914         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1915         msg[1] = IPMI_GET_DEVICE_ID_CMD;
1916         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1917
1918         smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1919         for (;;)
1920         {
1921                 if (smi_result == SI_SM_CALL_WITH_DELAY ||
1922                     smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1923                         schedule_timeout_uninterruptible(1);
1924                         smi_result = smi_info->handlers->event(
1925                                 smi_info->si_sm, 100);
1926                 }
1927                 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1928                 {
1929                         smi_result = smi_info->handlers->event(
1930                                 smi_info->si_sm, 0);
1931                 }
1932                 else
1933                         break;
1934         }
1935         if (smi_result == SI_SM_HOSED) {
1936                 /* We couldn't get the state machine to run, so whatever's at
1937                    the port is probably not an IPMI SMI interface. */
1938                 rv = -ENODEV;
1939                 goto out;
1940         }
1941
1942         /* Otherwise, we got some data. */
1943         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1944                                                   resp, IPMI_MAX_MSG_LENGTH);
1945         if (resp_len < 14) {
1946                 /* That's odd, it should be longer. */
1947                 rv = -EINVAL;
1948                 goto out;
1949         }
1950
1951         if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
1952                 /* That's odd, it shouldn't be able to fail. */
1953                 rv = -EINVAL;
1954                 goto out;
1955         }
1956
1957         /* Record info from the get device id, in case we need it. */
1958         ipmi_demangle_device_id(resp+3, resp_len-3, &smi_info->device_id);
1959
1960  out:
1961         kfree(resp);
1962         return rv;
1963 }
1964
1965 static int type_file_read_proc(char *page, char **start, off_t off,
1966                                int count, int *eof, void *data)
1967 {
1968         char            *out = (char *) page;
1969         struct smi_info *smi = data;
1970
1971         switch (smi->si_type) {
1972             case SI_KCS:
1973                 return sprintf(out, "kcs\n");
1974             case SI_SMIC:
1975                 return sprintf(out, "smic\n");
1976             case SI_BT:
1977                 return sprintf(out, "bt\n");
1978             default:
1979                 return 0;
1980         }
1981 }
1982
1983 static int stat_file_read_proc(char *page, char **start, off_t off,
1984                                int count, int *eof, void *data)
1985 {
1986         char            *out = (char *) page;
1987         struct smi_info *smi = data;
1988
1989         out += sprintf(out, "interrupts_enabled:    %d\n",
1990                        smi->irq && !smi->interrupt_disabled);
1991         out += sprintf(out, "short_timeouts:        %ld\n",
1992                        smi->short_timeouts);
1993         out += sprintf(out, "long_timeouts:         %ld\n",
1994                        smi->long_timeouts);
1995         out += sprintf(out, "timeout_restarts:      %ld\n",
1996                        smi->timeout_restarts);
1997         out += sprintf(out, "idles:                 %ld\n",
1998                        smi->idles);
1999         out += sprintf(out, "interrupts:            %ld\n",
2000                        smi->interrupts);
2001         out += sprintf(out, "attentions:            %ld\n",
2002                        smi->attentions);
2003         out += sprintf(out, "flag_fetches:          %ld\n",
2004                        smi->flag_fetches);
2005         out += sprintf(out, "hosed_count:           %ld\n",
2006                        smi->hosed_count);
2007         out += sprintf(out, "complete_transactions: %ld\n",
2008                        smi->complete_transactions);
2009         out += sprintf(out, "events:                %ld\n",
2010                        smi->events);
2011         out += sprintf(out, "watchdog_pretimeouts:  %ld\n",
2012                        smi->watchdog_pretimeouts);
2013         out += sprintf(out, "incoming_messages:     %ld\n",
2014                        smi->incoming_messages);
2015
2016         return (out - ((char *) page));
2017 }
2018
2019 /*
2020  * oem_data_avail_to_receive_msg_avail
2021  * @info - smi_info structure with msg_flags set
2022  *
2023  * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2024  * Returns 1 indicating need to re-run handle_flags().
2025  */
2026 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2027 {
2028         smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2029                                 RECEIVE_MSG_AVAIL);
2030         return 1;
2031 }
2032
2033 /*
2034  * setup_dell_poweredge_oem_data_handler
2035  * @info - smi_info.device_id must be populated
2036  *
2037  * Systems that match, but have firmware version < 1.40 may assert
2038  * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2039  * it's safe to do so.  Such systems will de-assert OEM1_DATA_AVAIL
2040  * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2041  * as RECEIVE_MSG_AVAIL instead.
2042  *
2043  * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2044  * assert the OEM[012] bits, and if it did, the driver would have to
2045  * change to handle that properly, we don't actually check for the
2046  * firmware version.
2047  * Device ID = 0x20                BMC on PowerEdge 8G servers
2048  * Device Revision = 0x80
2049  * Firmware Revision1 = 0x01       BMC version 1.40
2050  * Firmware Revision2 = 0x40       BCD encoded
2051  * IPMI Version = 0x51             IPMI 1.5
2052  * Manufacturer ID = A2 02 00      Dell IANA
2053  *
2054  * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2055  * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2056  *
2057  */
2058 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID  0x20
2059 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2060 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2061 #define DELL_IANA_MFR_ID 0x0002a2
2062 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2063 {
2064         struct ipmi_device_id *id = &smi_info->device_id;
2065         if (id->manufacturer_id == DELL_IANA_MFR_ID) {
2066                 if (id->device_id       == DELL_POWEREDGE_8G_BMC_DEVICE_ID  &&
2067                     id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2068                     id->ipmi_version   == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
2069                         smi_info->oem_data_avail_handler =
2070                                 oem_data_avail_to_receive_msg_avail;
2071                 }
2072                 else if (ipmi_version_major(id) < 1 ||
2073                          (ipmi_version_major(id) == 1 &&
2074                           ipmi_version_minor(id) < 5)) {
2075                         smi_info->oem_data_avail_handler =
2076                                 oem_data_avail_to_receive_msg_avail;
2077                 }
2078         }
2079 }
2080
2081 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2082 static void return_hosed_msg_badsize(struct smi_info *smi_info)
2083 {
2084         struct ipmi_smi_msg *msg = smi_info->curr_msg;
2085
2086         /* Make it a reponse */
2087         msg->rsp[0] = msg->data[0] | 4;
2088         msg->rsp[1] = msg->data[1];
2089         msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2090         msg->rsp_size = 3;
2091         smi_info->curr_msg = NULL;
2092         deliver_recv_msg(smi_info, msg);
2093 }
2094
2095 /*
2096  * dell_poweredge_bt_xaction_handler
2097  * @info - smi_info.device_id must be populated
2098  *
2099  * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2100  * not respond to a Get SDR command if the length of the data
2101  * requested is exactly 0x3A, which leads to command timeouts and no
2102  * data returned.  This intercepts such commands, and causes userspace
2103  * callers to try again with a different-sized buffer, which succeeds.
2104  */
2105
2106 #define STORAGE_NETFN 0x0A
2107 #define STORAGE_CMD_GET_SDR 0x23
2108 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2109                                              unsigned long unused,
2110                                              void *in)
2111 {
2112         struct smi_info *smi_info = in;
2113         unsigned char *data = smi_info->curr_msg->data;
2114         unsigned int size   = smi_info->curr_msg->data_size;
2115         if (size >= 8 &&
2116             (data[0]>>2) == STORAGE_NETFN &&
2117             data[1] == STORAGE_CMD_GET_SDR &&
2118             data[7] == 0x3A) {
2119                 return_hosed_msg_badsize(smi_info);
2120                 return NOTIFY_STOP;
2121         }
2122         return NOTIFY_DONE;
2123 }
2124
2125 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2126         .notifier_call  = dell_poweredge_bt_xaction_handler,
2127 };
2128
2129 /*
2130  * setup_dell_poweredge_bt_xaction_handler
2131  * @info - smi_info.device_id must be filled in already
2132  *
2133  * Fills in smi_info.device_id.start_transaction_pre_hook
2134  * when we know what function to use there.
2135  */
2136 static void
2137 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2138 {
2139         struct ipmi_device_id *id = &smi_info->device_id;
2140         if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2141             smi_info->si_type == SI_BT)
2142                 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2143 }
2144
2145 /*
2146  * setup_oem_data_handler
2147  * @info - smi_info.device_id must be filled in already
2148  *
2149  * Fills in smi_info.device_id.oem_data_available_handler
2150  * when we know what function to use there.
2151  */
2152
2153 static void setup_oem_data_handler(struct smi_info *smi_info)
2154 {
2155         setup_dell_poweredge_oem_data_handler(smi_info);
2156 }
2157
2158 static void setup_xaction_handlers(struct smi_info *smi_info)
2159 {
2160         setup_dell_poweredge_bt_xaction_handler(smi_info);
2161 }
2162
2163 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2164 {
2165         if (smi_info->thread != NULL && smi_info->thread != ERR_PTR(-ENOMEM))
2166                 kthread_stop(smi_info->thread);
2167         del_timer_sync(&smi_info->si_timer);
2168 }
2169
2170 static struct ipmi_default_vals
2171 {
2172         int type;
2173         int port;
2174 } __devinit ipmi_defaults[] =
2175 {
2176         { .type = SI_KCS, .port = 0xca2 },
2177         { .type = SI_SMIC, .port = 0xca9 },
2178         { .type = SI_BT, .port = 0xe4 },
2179         { .port = 0 }
2180 };
2181
2182 static __devinit void default_find_bmc(void)
2183 {
2184         struct smi_info *info;
2185         int             i;
2186
2187         for (i = 0; ; i++) {
2188                 if (!ipmi_defaults[i].port)
2189                         break;
2190
2191                 info = kzalloc(sizeof(*info), GFP_KERNEL);
2192                 if (!info)
2193                         return;
2194
2195                 info->addr_source = NULL;
2196
2197                 info->si_type = ipmi_defaults[i].type;
2198                 info->io_setup = port_setup;
2199                 info->io.addr_data = ipmi_defaults[i].port;
2200                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2201
2202                 info->io.addr = NULL;
2203                 info->io.regspacing = DEFAULT_REGSPACING;
2204                 info->io.regsize = DEFAULT_REGSPACING;
2205                 info->io.regshift = 0;
2206
2207                 if (try_smi_init(info) == 0) {
2208                         /* Found one... */
2209                         printk(KERN_INFO "ipmi_si: Found default %s state"
2210                                " machine at %s address 0x%lx\n",
2211                                si_to_str[info->si_type],
2212                                addr_space_to_str[info->io.addr_type],
2213                                info->io.addr_data);
2214                         return;
2215                 }
2216         }
2217 }
2218
2219 static int is_new_interface(struct smi_info *info)
2220 {
2221         struct smi_info *e;
2222
2223         list_for_each_entry(e, &smi_infos, link) {
2224                 if (e->io.addr_type != info->io.addr_type)
2225                         continue;
2226                 if (e->io.addr_data == info->io.addr_data)
2227                         return 0;
2228         }
2229
2230         return 1;
2231 }
2232
2233 static int try_smi_init(struct smi_info *new_smi)
2234 {
2235         int rv;
2236
2237         if (new_smi->addr_source) {
2238                 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2239                        " machine at %s address 0x%lx, slave address 0x%x,"
2240                        " irq %d\n",
2241                        new_smi->addr_source,
2242                        si_to_str[new_smi->si_type],
2243                        addr_space_to_str[new_smi->io.addr_type],
2244                        new_smi->io.addr_data,
2245                        new_smi->slave_addr, new_smi->irq);
2246         }
2247
2248         down(&smi_infos_lock);
2249         if (!is_new_interface(new_smi)) {
2250                 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2251                 rv = -EBUSY;
2252                 goto out_err;
2253         }
2254
2255         /* So we know not to free it unless we have allocated one. */
2256         new_smi->intf = NULL;
2257         new_smi->si_sm = NULL;
2258         new_smi->handlers = NULL;
2259
2260         switch (new_smi->si_type) {
2261         case SI_KCS:
2262                 new_smi->handlers = &kcs_smi_handlers;
2263                 break;
2264
2265         case SI_SMIC:
2266                 new_smi->handlers = &smic_smi_handlers;
2267                 break;
2268
2269         case SI_BT:
2270                 new_smi->handlers = &bt_smi_handlers;
2271                 break;
2272
2273         default:
2274                 /* No support for anything else yet. */
2275                 rv = -EIO;
2276                 goto out_err;
2277         }
2278
2279         /* Allocate the state machine's data and initialize it. */
2280         new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2281         if (!new_smi->si_sm) {
2282                 printk(" Could not allocate state machine memory\n");
2283                 rv = -ENOMEM;
2284                 goto out_err;
2285         }
2286         new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2287                                                         &new_smi->io);
2288
2289         /* Now that we know the I/O size, we can set up the I/O. */
2290         rv = new_smi->io_setup(new_smi);
2291         if (rv) {
2292                 printk(" Could not set up I/O space\n");
2293                 goto out_err;
2294         }
2295
2296         spin_lock_init(&(new_smi->si_lock));
2297         spin_lock_init(&(new_smi->msg_lock));
2298         spin_lock_init(&(new_smi->count_lock));
2299
2300         /* Do low-level detection first. */
2301         if (new_smi->handlers->detect(new_smi->si_sm)) {
2302                 if (new_smi->addr_source)
2303                         printk(KERN_INFO "ipmi_si: Interface detection"
2304                                " failed\n");
2305                 rv = -ENODEV;
2306                 goto out_err;
2307         }
2308
2309         /* Attempt a get device id command.  If it fails, we probably
2310            don't have a BMC here. */
2311         rv = try_get_dev_id(new_smi);
2312         if (rv) {
2313                 if (new_smi->addr_source)
2314                         printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2315                                " at this location\n");
2316                 goto out_err;
2317         }
2318
2319         setup_oem_data_handler(new_smi);
2320         setup_xaction_handlers(new_smi);
2321
2322         /* Try to claim any interrupts. */
2323         if (new_smi->irq_setup)
2324                 new_smi->irq_setup(new_smi);
2325
2326         INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2327         INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2328         new_smi->curr_msg = NULL;
2329         atomic_set(&new_smi->req_events, 0);
2330         new_smi->run_to_completion = 0;
2331
2332         new_smi->interrupt_disabled = 0;
2333         atomic_set(&new_smi->stop_operation, 0);
2334         new_smi->intf_num = smi_num;
2335         smi_num++;
2336
2337         /* Start clearing the flags before we enable interrupts or the
2338            timer to avoid racing with the timer. */
2339         start_clear_flags(new_smi);
2340         /* IRQ is defined to be set when non-zero. */
2341         if (new_smi->irq)
2342                 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2343
2344         /* The ipmi_register_smi() code does some operations to
2345            determine the channel information, so we must be ready to
2346            handle operations before it is called.  This means we have
2347            to stop the timer if we get an error after this point. */
2348         init_timer(&(new_smi->si_timer));
2349         new_smi->si_timer.data = (long) new_smi;
2350         new_smi->si_timer.function = smi_timeout;
2351         new_smi->last_timeout_jiffies = jiffies;
2352         new_smi->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
2353
2354         add_timer(&(new_smi->si_timer));
2355         if (new_smi->si_type != SI_BT)
2356                 new_smi->thread = kthread_run(ipmi_thread, new_smi,
2357                                               "kipmi%d", new_smi->intf_num);
2358
2359         if (!new_smi->dev) {
2360                 /* If we don't already have a device from something
2361                  * else (like PCI), then register a new one. */
2362                 new_smi->pdev = platform_device_alloc("ipmi_si",
2363                                                       new_smi->intf_num);
2364                 if (rv) {
2365                         printk(KERN_ERR
2366                                "ipmi_si_intf:"
2367                                " Unable to allocate platform device\n");
2368                         goto out_err_stop_timer;
2369                 }
2370                 new_smi->dev = &new_smi->pdev->dev;
2371                 new_smi->dev->driver = &ipmi_driver;
2372
2373                 rv = platform_device_register(new_smi->pdev);
2374                 if (rv) {
2375                         printk(KERN_ERR
2376                                "ipmi_si_intf:"
2377                                " Unable to register system interface device:"
2378                                " %d\n",
2379                                rv);
2380                         goto out_err_stop_timer;
2381                 }
2382                 new_smi->dev_registered = 1;
2383         }
2384
2385         rv = ipmi_register_smi(&handlers,
2386                                new_smi,
2387                                &new_smi->device_id,
2388                                new_smi->dev,
2389                                new_smi->slave_addr,
2390                                &(new_smi->intf));
2391         if (rv) {
2392                 printk(KERN_ERR
2393                        "ipmi_si: Unable to register device: error %d\n",
2394                        rv);
2395                 goto out_err_stop_timer;
2396         }
2397
2398         rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2399                                      type_file_read_proc, NULL,
2400                                      new_smi, THIS_MODULE);
2401         if (rv) {
2402                 printk(KERN_ERR
2403                        "ipmi_si: Unable to create proc entry: %d\n",
2404                        rv);
2405                 goto out_err_stop_timer;
2406         }
2407
2408         rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2409                                      stat_file_read_proc, NULL,
2410                                      new_smi, THIS_MODULE);
2411         if (rv) {
2412                 printk(KERN_ERR
2413                        "ipmi_si: Unable to create proc entry: %d\n",
2414                        rv);
2415                 goto out_err_stop_timer;
2416         }
2417
2418         list_add_tail(&new_smi->link, &smi_infos);
2419
2420         up(&smi_infos_lock);
2421
2422         printk(" IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
2423
2424         return 0;
2425
2426  out_err_stop_timer:
2427         atomic_inc(&new_smi->stop_operation);
2428         wait_for_timer_and_thread(new_smi);
2429
2430  out_err:
2431         if (new_smi->intf)
2432                 ipmi_unregister_smi(new_smi->intf);
2433
2434         if (new_smi->irq_cleanup)
2435                 new_smi->irq_cleanup(new_smi);
2436
2437         /* Wait until we know that we are out of any interrupt
2438            handlers might have been running before we freed the
2439            interrupt. */
2440         synchronize_sched();
2441
2442         if (new_smi->si_sm) {
2443                 if (new_smi->handlers)
2444                         new_smi->handlers->cleanup(new_smi->si_sm);
2445                 kfree(new_smi->si_sm);
2446         }
2447         if (new_smi->addr_source_cleanup)
2448                 new_smi->addr_source_cleanup(new_smi);
2449         if (new_smi->io_cleanup)
2450                 new_smi->io_cleanup(new_smi);
2451
2452         if (new_smi->dev_registered)
2453                 platform_device_unregister(new_smi->pdev);
2454
2455         kfree(new_smi);
2456
2457         up(&smi_infos_lock);
2458
2459         return rv;
2460 }
2461
2462 static __devinit int init_ipmi_si(void)
2463 {
2464         int  i;
2465         char *str;
2466         int  rv;
2467
2468         if (initialized)
2469                 return 0;
2470         initialized = 1;
2471
2472         /* Register the device drivers. */
2473         rv = driver_register(&ipmi_driver);
2474         if (rv) {
2475                 printk(KERN_ERR
2476                        "init_ipmi_si: Unable to register driver: %d\n",
2477                        rv);
2478                 return rv;
2479         }
2480
2481
2482         /* Parse out the si_type string into its components. */
2483         str = si_type_str;
2484         if (*str != '\0') {
2485                 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
2486                         si_type[i] = str;
2487                         str = strchr(str, ',');
2488                         if (str) {
2489                                 *str = '\0';
2490                                 str++;
2491                         } else {
2492                                 break;
2493                         }
2494                 }
2495         }
2496
2497         printk(KERN_INFO "IPMI System Interface driver.\n");
2498
2499         hardcode_find_bmc();
2500
2501 #ifdef CONFIG_DMI
2502         dmi_find_bmc();
2503 #endif
2504
2505 #ifdef CONFIG_ACPI
2506         if (si_trydefaults)
2507                 acpi_find_bmc();
2508 #endif
2509
2510 #ifdef CONFIG_PCI
2511         pci_module_init(&ipmi_pci_driver);
2512 #endif
2513
2514         if (si_trydefaults) {
2515                 down(&smi_infos_lock);
2516                 if (list_empty(&smi_infos)) {
2517                         /* No BMC was found, try defaults. */
2518                         up(&smi_infos_lock);
2519                         default_find_bmc();
2520                 } else {
2521                         up(&smi_infos_lock);
2522                 }
2523         }
2524
2525         down(&smi_infos_lock);
2526         if (list_empty(&smi_infos)) {
2527                 up(&smi_infos_lock);
2528 #ifdef CONFIG_PCI
2529                 pci_unregister_driver(&ipmi_pci_driver);
2530 #endif
2531                 printk("ipmi_si: Unable to find any System Interface(s)\n");
2532                 return -ENODEV;
2533         } else {
2534                 up(&smi_infos_lock);
2535                 return 0;
2536         }
2537 }
2538 module_init(init_ipmi_si);
2539
2540 static void __devexit cleanup_one_si(struct smi_info *to_clean)
2541 {
2542         int           rv;
2543         unsigned long flags;
2544
2545         if (!to_clean)
2546                 return;
2547
2548         list_del(&to_clean->link);
2549
2550         /* Tell the timer and interrupt handlers that we are shutting
2551            down. */
2552         spin_lock_irqsave(&(to_clean->si_lock), flags);
2553         spin_lock(&(to_clean->msg_lock));
2554
2555         atomic_inc(&to_clean->stop_operation);
2556
2557         if (to_clean->irq_cleanup)
2558                 to_clean->irq_cleanup(to_clean);
2559
2560         spin_unlock(&(to_clean->msg_lock));
2561         spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2562
2563         /* Wait until we know that we are out of any interrupt
2564            handlers might have been running before we freed the
2565            interrupt. */
2566         synchronize_sched();
2567
2568         wait_for_timer_and_thread(to_clean);
2569
2570         /* Interrupts and timeouts are stopped, now make sure the
2571            interface is in a clean state. */
2572         while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
2573                 poll(to_clean);
2574                 schedule_timeout_uninterruptible(1);
2575         }
2576
2577         rv = ipmi_unregister_smi(to_clean->intf);
2578         if (rv) {
2579                 printk(KERN_ERR
2580                        "ipmi_si: Unable to unregister device: errno=%d\n",
2581                        rv);
2582         }
2583
2584         to_clean->handlers->cleanup(to_clean->si_sm);
2585
2586         kfree(to_clean->si_sm);
2587
2588         if (to_clean->addr_source_cleanup)
2589                 to_clean->addr_source_cleanup(to_clean);
2590         if (to_clean->io_cleanup)
2591                 to_clean->io_cleanup(to_clean);
2592
2593         if (to_clean->dev_registered)
2594                 platform_device_unregister(to_clean->pdev);
2595
2596         kfree(to_clean);
2597 }
2598
2599 static __exit void cleanup_ipmi_si(void)
2600 {
2601         struct smi_info *e, *tmp_e;
2602
2603         if (!initialized)
2604                 return;
2605
2606 #ifdef CONFIG_PCI
2607         pci_unregister_driver(&ipmi_pci_driver);
2608 #endif
2609
2610         down(&smi_infos_lock);
2611         list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2612                 cleanup_one_si(e);
2613         up(&smi_infos_lock);
2614
2615         driver_unregister(&ipmi_driver);
2616 }
2617 module_exit(cleanup_ipmi_si);
2618
2619 MODULE_LICENSE("GPL");
2620 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2621 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");