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 static int smi_start_processing(void       *send_info,
 976                                 ipmi_smi_t intf)
 977 {
 978         struct smi_info *new_smi = send_info;
 979
 980         new_smi->intf = intf;
 981
 982         /* Set up the timer that drives the interface. */
 983         setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
 984         new_smi->last_timeout_jiffies = jiffies;
 985         mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
 986
 987         if (new_smi->si_type != SI_BT) {
 988                 new_smi->thread = kthread_run(ipmi_thread, new_smi,
 989                                               "kipmi%d", new_smi->intf_num);
 990                 if (IS_ERR(new_smi->thread)) {
 991                         printk(KERN_NOTICE "ipmi_si_intf: Could not start"
 992                                " kernel thread due to error %ld, only using"
 993                                " timers to drive the interface\n",
 994                                PTR_ERR(new_smi->thread));
 995                         new_smi->thread = NULL;
 996                 }
 997         }
 998
 999         return 0;
1000 }
1001
1002 static struct ipmi_smi_handlers handlers =
1003 {
1004         .owner                  = THIS_MODULE,
1005         .start_processing       = smi_start_processing,
1006         .sender                 = sender,
1007         .request_events         = request_events,
1008         .set_run_to_completion  = set_run_to_completion,
1009         .poll                   = poll,
1010 };
1011
1012 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1013    a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS */
1014
1015 #define SI_MAX_PARMS 4
1016 static LIST_HEAD(smi_infos);
1017 static DEFINE_MUTEX(smi_infos_lock);
1018 static int smi_num; /* Used to sequence the SMIs */
1019
1020 #define DEFAULT_REGSPACING      1
1021
1022 static int           si_trydefaults = 1;
1023 static char          *si_type[SI_MAX_PARMS];
1024 #define MAX_SI_TYPE_STR 30
1025 static char          si_type_str[MAX_SI_TYPE_STR];
1026 static unsigned long addrs[SI_MAX_PARMS];
1027 static int num_addrs;
1028 static unsigned int  ports[SI_MAX_PARMS];
1029 static int num_ports;
1030 static int           irqs[SI_MAX_PARMS];
1031 static int num_irqs;
1032 static int           regspacings[SI_MAX_PARMS];
1033 static int num_regspacings = 0;
1034 static int           regsizes[SI_MAX_PARMS];
1035 static int num_regsizes = 0;
1036 static int           regshifts[SI_MAX_PARMS];
1037 static int num_regshifts = 0;
1038 static int slave_addrs[SI_MAX_PARMS];
1039 static int num_slave_addrs = 0;
1040
1041
1042 module_param_named(trydefaults, si_trydefaults, bool, 0);
1043 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1044                  " default scan of the KCS and SMIC interface at the standard"
1045                  " address");
1046 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1047 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1048                  " interface separated by commas.  The types are 'kcs',"
1049                  " 'smic', and 'bt'.  For example si_type=kcs,bt will set"
1050                  " the first interface to kcs and the second to bt");
1051 module_param_array(addrs, long, &num_addrs, 0);
1052 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1053                  " addresses separated by commas.  Only use if an interface"
1054                  " is in memory.  Otherwise, set it to zero or leave"
1055                  " it blank.");
1056 module_param_array(ports, int, &num_ports, 0);
1057 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1058                  " addresses separated by commas.  Only use if an interface"
1059                  " is a port.  Otherwise, set it to zero or leave"
1060                  " it blank.");
1061 module_param_array(irqs, int, &num_irqs, 0);
1062 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1063                  " addresses separated by commas.  Only use if an interface"
1064                  " has an interrupt.  Otherwise, set it to zero or leave"
1065                  " it blank.");
1066 module_param_array(regspacings, int, &num_regspacings, 0);
1067 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1068                  " and each successive register used by the interface.  For"
1069                  " instance, if the start address is 0xca2 and the spacing"
1070                  " is 2, then the second address is at 0xca4.  Defaults"
1071                  " to 1.");
1072 module_param_array(regsizes, int, &num_regsizes, 0);
1073 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1074                  " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1075                  " 16-bit, 32-bit, or 64-bit register.  Use this if you"
1076                  " the 8-bit IPMI register has to be read from a larger"
1077                  " register.");
1078 module_param_array(regshifts, int, &num_regshifts, 0);
1079 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1080                  " IPMI register, in bits.  For instance, if the data"
1081                  " is read from a 32-bit word and the IPMI data is in"
1082                  " bit 8-15, then the shift would be 8");
1083 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1084 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1085                  " the controller.  Normally this is 0x20, but can be"
1086                  " overridden by this parm.  This is an array indexed"
1087                  " by interface number.");
1088
1089
1090 #define IPMI_IO_ADDR_SPACE  0
1091 #define IPMI_MEM_ADDR_SPACE 1
1092 static char *addr_space_to_str[] = { "I/O", "memory" };
1093
1094 static void std_irq_cleanup(struct smi_info *info)
1095 {
1096         if (info->si_type == SI_BT)
1097                 /* Disable the interrupt in the BT interface. */
1098                 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1099         free_irq(info->irq, info);
1100 }
1101
1102 static int std_irq_setup(struct smi_info *info)
1103 {
1104         int rv;
1105
1106         if (!info->irq)
1107                 return 0;
1108
1109         if (info->si_type == SI_BT) {
1110                 rv = request_irq(info->irq,
1111                                  si_bt_irq_handler,
1112                                  SA_INTERRUPT,
1113                                  DEVICE_NAME,
1114                                  info);
1115                 if (!rv)
1116                         /* Enable the interrupt in the BT interface. */
1117                         info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1118                                          IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1119         } else
1120                 rv = request_irq(info->irq,
1121                                  si_irq_handler,
1122                                  SA_INTERRUPT,
1123                                  DEVICE_NAME,
1124                                  info);
1125         if (rv) {
1126                 printk(KERN_WARNING
1127                        "ipmi_si: %s unable to claim interrupt %d,"
1128                        " running polled\n",
1129                        DEVICE_NAME, info->irq);
1130                 info->irq = 0;
1131         } else {
1132                 info->irq_cleanup = std_irq_cleanup;
1133                 printk("  Using irq %d\n", info->irq);
1134         }
1135
1136         return rv;
1137 }
1138
1139 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1140 {
1141         unsigned int addr = io->addr_data;
1142
1143         return inb(addr + (offset * io->regspacing));
1144 }
1145
1146 static void port_outb(struct si_sm_io *io, unsigned int offset,
1147                       unsigned char b)
1148 {
1149         unsigned int addr = io->addr_data;
1150
1151         outb(b, addr + (offset * io->regspacing));
1152 }
1153
1154 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1155 {
1156         unsigned int addr = io->addr_data;
1157
1158         return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1159 }
1160
1161 static void port_outw(struct si_sm_io *io, unsigned int offset,
1162                       unsigned char b)
1163 {
1164         unsigned int addr = io->addr_data;
1165
1166         outw(b << io->regshift, addr + (offset * io->regspacing));
1167 }
1168
1169 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1170 {
1171         unsigned int addr = io->addr_data;
1172
1173         return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1174 }
1175
1176 static void port_outl(struct si_sm_io *io, unsigned int offset,
1177                       unsigned char b)
1178 {
1179         unsigned int addr = io->addr_data;
1180
1181         outl(b << io->regshift, addr+(offset * io->regspacing));
1182 }
1183
1184 static void port_cleanup(struct smi_info *info)
1185 {
1186         unsigned int addr = info->io.addr_data;
1187         int          idx;
1188
1189         if (addr) {
1190                 for (idx = 0; idx < info->io_size; idx++) {
1191                         release_region(addr + idx * info->io.regspacing,
1192                                        info->io.regsize);
1193                 }
1194         }
1195 }
1196
1197 static int port_setup(struct smi_info *info)
1198 {
1199         unsigned int addr = info->io.addr_data;
1200         int          idx;
1201
1202         if (!addr)
1203                 return -ENODEV;
1204
1205         info->io_cleanup = port_cleanup;
1206
1207         /* Figure out the actual inb/inw/inl/etc routine to use based
1208            upon the register size. */
1209         switch (info->io.regsize) {
1210         case 1:
1211                 info->io.inputb = port_inb;
1212                 info->io.outputb = port_outb;
1213                 break;
1214         case 2:
1215                 info->io.inputb = port_inw;
1216                 info->io.outputb = port_outw;
1217                 break;
1218         case 4:
1219                 info->io.inputb = port_inl;
1220                 info->io.outputb = port_outl;
1221                 break;
1222         default:
1223                 printk("ipmi_si: Invalid register size: %d\n",
1224                        info->io.regsize);
1225                 return -EINVAL;
1226         }
1227
1228         /* Some BIOSes reserve disjoint I/O regions in their ACPI
1229          * tables.  This causes problems when trying to register the
1230          * entire I/O region.  Therefore we must register each I/O
1231          * port separately.
1232          */
1233         for (idx = 0; idx < info->io_size; idx++) {
1234                 if (request_region(addr + idx * info->io.regspacing,
1235                                    info->io.regsize, DEVICE_NAME) == NULL) {
1236                         /* Undo allocations */
1237                         while (idx--) {
1238                                 release_region(addr + idx * info->io.regspacing,
1239                                                info->io.regsize);
1240                         }
1241                         return -EIO;
1242                 }
1243         }
1244         return 0;
1245 }
1246
1247 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1248 {
1249         return readb((io->addr)+(offset * io->regspacing));
1250 }
1251
1252 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1253                      unsigned char b)
1254 {
1255         writeb(b, (io->addr)+(offset * io->regspacing));
1256 }
1257
1258 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1259 {
1260         return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1261                 && 0xff;
1262 }
1263
1264 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1265                      unsigned char b)
1266 {
1267         writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1268 }
1269
1270 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1271 {
1272         return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1273                 && 0xff;
1274 }
1275
1276 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1277                      unsigned char b)
1278 {
1279         writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1280 }
1281
1282 #ifdef readq
1283 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1284 {
1285         return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1286                 && 0xff;
1287 }
1288
1289 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1290                      unsigned char b)
1291 {
1292         writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1293 }
1294 #endif
1295
1296 static void mem_cleanup(struct smi_info *info)
1297 {
1298         unsigned long addr = info->io.addr_data;
1299         int           mapsize;
1300
1301         if (info->io.addr) {
1302                 iounmap(info->io.addr);
1303
1304                 mapsize = ((info->io_size * info->io.regspacing)
1305                            - (info->io.regspacing - info->io.regsize));
1306
1307                 release_mem_region(addr, mapsize);
1308         }
1309 }
1310
1311 static int mem_setup(struct smi_info *info)
1312 {
1313         unsigned long addr = info->io.addr_data;
1314         int           mapsize;
1315
1316         if (!addr)
1317                 return -ENODEV;
1318
1319         info->io_cleanup = mem_cleanup;
1320
1321         /* Figure out the actual readb/readw/readl/etc routine to use based
1322            upon the register size. */
1323         switch (info->io.regsize) {
1324         case 1:
1325                 info->io.inputb = intf_mem_inb;
1326                 info->io.outputb = intf_mem_outb;
1327                 break;
1328         case 2:
1329                 info->io.inputb = intf_mem_inw;
1330                 info->io.outputb = intf_mem_outw;
1331                 break;
1332         case 4:
1333                 info->io.inputb = intf_mem_inl;
1334                 info->io.outputb = intf_mem_outl;
1335                 break;
1336 #ifdef readq
1337         case 8:
1338                 info->io.inputb = mem_inq;
1339                 info->io.outputb = mem_outq;
1340                 break;
1341 #endif
1342         default:
1343                 printk("ipmi_si: Invalid register size: %d\n",
1344                        info->io.regsize);
1345                 return -EINVAL;
1346         }
1347
1348         /* Calculate the total amount of memory to claim.  This is an
1349          * unusual looking calculation, but it avoids claiming any
1350          * more memory than it has to.  It will claim everything
1351          * between the first address to the end of the last full
1352          * register. */
1353         mapsize = ((info->io_size * info->io.regspacing)
1354                    - (info->io.regspacing - info->io.regsize));
1355
1356         if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1357                 return -EIO;
1358
1359         info->io.addr = ioremap(addr, mapsize);
1360         if (info->io.addr == NULL) {
1361                 release_mem_region(addr, mapsize);
1362                 return -EIO;
1363         }
1364         return 0;
1365 }
1366
1367
1368 static __devinit void hardcode_find_bmc(void)
1369 {
1370         int             i;
1371         struct smi_info *info;
1372
1373         for (i = 0; i < SI_MAX_PARMS; i++) {
1374                 if (!ports[i] && !addrs[i])
1375                         continue;
1376
1377                 info = kzalloc(sizeof(*info), GFP_KERNEL);
1378                 if (!info)
1379                         return;
1380
1381                 info->addr_source = "hardcoded";
1382
1383                 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1384                         info->si_type = SI_KCS;
1385                 } else if (strcmp(si_type[i], "smic") == 0) {
1386                         info->si_type = SI_SMIC;
1387                 } else if (strcmp(si_type[i], "bt") == 0) {
1388                         info->si_type = SI_BT;
1389                 } else {
1390                         printk(KERN_WARNING
1391                                "ipmi_si: Interface type specified "
1392                                "for interface %d, was invalid: %s\n",
1393                                i, si_type[i]);
1394                         kfree(info);
1395                         continue;
1396                 }
1397
1398                 if (ports[i]) {
1399                         /* An I/O port */
1400                         info->io_setup = port_setup;
1401                         info->io.addr_data = ports[i];
1402                         info->io.addr_type = IPMI_IO_ADDR_SPACE;
1403                 } else if (addrs[i]) {
1404                         /* A memory port */
1405                         info->io_setup = mem_setup;
1406                         info->io.addr_data = addrs[i];
1407                         info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1408                 } else {
1409                         printk(KERN_WARNING
1410                                "ipmi_si: Interface type specified "
1411                                "for interface %d, "
1412                                "but port and address were not set or "
1413                                "set to zero.\n", i);
1414                         kfree(info);
1415                         continue;
1416                 }
1417
1418                 info->io.addr = NULL;
1419                 info->io.regspacing = regspacings[i];
1420                 if (!info->io.regspacing)
1421                         info->io.regspacing = DEFAULT_REGSPACING;
1422                 info->io.regsize = regsizes[i];
1423                 if (!info->io.regsize)
1424                         info->io.regsize = DEFAULT_REGSPACING;
1425                 info->io.regshift = regshifts[i];
1426                 info->irq = irqs[i];
1427                 if (info->irq)
1428                         info->irq_setup = std_irq_setup;
1429
1430                 try_smi_init(info);
1431         }
1432 }
1433
1434 #ifdef CONFIG_ACPI
1435
1436 #include <linux/acpi.h>
1437
1438 /* Once we get an ACPI failure, we don't try any more, because we go
1439    through the tables sequentially.  Once we don't find a table, there
1440    are no more. */
1441 static int acpi_failure = 0;
1442
1443 /* For GPE-type interrupts. */
1444 static u32 ipmi_acpi_gpe(void *context)
1445 {
1446         struct smi_info *smi_info = context;
1447         unsigned long   flags;
1448 #ifdef DEBUG_TIMING
1449         struct timeval t;
1450 #endif
1451
1452         spin_lock_irqsave(&(smi_info->si_lock), flags);
1453
1454         spin_lock(&smi_info->count_lock);
1455         smi_info->interrupts++;
1456         spin_unlock(&smi_info->count_lock);
1457
1458         if (atomic_read(&smi_info->stop_operation))
1459                 goto out;
1460
1461 #ifdef DEBUG_TIMING
1462         do_gettimeofday(&t);
1463         printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1464 #endif
1465         smi_event_handler(smi_info, 0);
1466  out:
1467         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1468
1469         return ACPI_INTERRUPT_HANDLED;
1470 }
1471
1472 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1473 {
1474         if (!info->irq)
1475                 return;
1476
1477         acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1478 }
1479
1480 static int acpi_gpe_irq_setup(struct smi_info *info)
1481 {
1482         acpi_status status;
1483
1484         if (!info->irq)
1485                 return 0;
1486
1487         /* FIXME - is level triggered right? */
1488         status = acpi_install_gpe_handler(NULL,
1489                                           info->irq,
1490                                           ACPI_GPE_LEVEL_TRIGGERED,
1491                                           &ipmi_acpi_gpe,
1492                                           info);
1493         if (status != AE_OK) {
1494                 printk(KERN_WARNING
1495                        "ipmi_si: %s unable to claim ACPI GPE %d,"
1496                        " running polled\n",
1497                        DEVICE_NAME, info->irq);
1498                 info->irq = 0;
1499                 return -EINVAL;
1500         } else {
1501                 info->irq_cleanup = acpi_gpe_irq_cleanup;
1502                 printk("  Using ACPI GPE %d\n", info->irq);
1503                 return 0;
1504         }
1505 }
1506
1507 /*
1508  * Defined at
1509  * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1510  */
1511 struct SPMITable {
1512         s8      Signature[4];
1513         u32     Length;
1514         u8      Revision;
1515         u8      Checksum;
1516         s8      OEMID[6];
1517         s8      OEMTableID[8];
1518         s8      OEMRevision[4];
1519         s8      CreatorID[4];
1520         s8      CreatorRevision[4];
1521         u8      InterfaceType;
1522         u8      IPMIlegacy;
1523         s16     SpecificationRevision;
1524
1525         /*
1526          * Bit 0 - SCI interrupt supported
1527          * Bit 1 - I/O APIC/SAPIC
1528          */
1529         u8      InterruptType;
1530
1531         /* If bit 0 of InterruptType is set, then this is the SCI
1532            interrupt in the GPEx_STS register. */
1533         u8      GPE;
1534
1535         s16     Reserved;
1536
1537         /* If bit 1 of InterruptType is set, then this is the I/O
1538            APIC/SAPIC interrupt. */
1539         u32     GlobalSystemInterrupt;
1540
1541         /* The actual register address. */
1542         struct acpi_generic_address addr;
1543
1544         u8      UID[4];
1545
1546         s8      spmi_id[1]; /* A '\0' terminated array starts here. */
1547 };
1548
1549 static __devinit int try_init_acpi(struct SPMITable *spmi)
1550 {
1551         struct smi_info  *info;
1552         char             *io_type;
1553         u8               addr_space;
1554
1555         if (spmi->IPMIlegacy != 1) {
1556             printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1557             return -ENODEV;
1558         }
1559
1560         if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1561                 addr_space = IPMI_MEM_ADDR_SPACE;
1562         else
1563                 addr_space = IPMI_IO_ADDR_SPACE;
1564
1565         info = kzalloc(sizeof(*info), GFP_KERNEL);
1566         if (!info) {
1567                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1568                 return -ENOMEM;
1569         }
1570
1571         info->addr_source = "ACPI";
1572
1573         /* Figure out the interface type. */
1574         switch (spmi->InterfaceType)
1575         {
1576         case 1: /* KCS */
1577                 info->si_type = SI_KCS;
1578                 break;
1579         case 2: /* SMIC */
1580                 info->si_type = SI_SMIC;
1581                 break;
1582         case 3: /* BT */
1583                 info->si_type = SI_BT;
1584                 break;
1585         default:
1586                 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1587                         spmi->InterfaceType);
1588                 kfree(info);
1589                 return -EIO;
1590         }
1591
1592         if (spmi->InterruptType & 1) {
1593                 /* We've got a GPE interrupt. */
1594                 info->irq = spmi->GPE;
1595                 info->irq_setup = acpi_gpe_irq_setup;
1596         } else if (spmi->InterruptType & 2) {
1597                 /* We've got an APIC/SAPIC interrupt. */
1598                 info->irq = spmi->GlobalSystemInterrupt;
1599                 info->irq_setup = std_irq_setup;
1600         } else {
1601                 /* Use the default interrupt setting. */
1602                 info->irq = 0;
1603                 info->irq_setup = NULL;
1604         }
1605
1606         if (spmi->addr.register_bit_width) {
1607                 /* A (hopefully) properly formed register bit width. */
1608                 info->io.regspacing = spmi->addr.register_bit_width / 8;
1609         } else {
1610                 info->io.regspacing = DEFAULT_REGSPACING;
1611         }
1612         info->io.regsize = info->io.regspacing;
1613         info->io.regshift = spmi->addr.register_bit_offset;
1614
1615         if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1616                 io_type = "memory";
1617                 info->io_setup = mem_setup;
1618                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1619         } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1620                 io_type = "I/O";
1621                 info->io_setup = port_setup;
1622                 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1623         } else {
1624                 kfree(info);
1625                 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1626                 return -EIO;
1627         }
1628         info->io.addr_data = spmi->addr.address;
1629
1630         try_smi_init(info);
1631
1632         return 0;
1633 }
1634
1635 static __devinit void acpi_find_bmc(void)
1636 {
1637         acpi_status      status;
1638         struct SPMITable *spmi;
1639         int              i;
1640
1641         if (acpi_disabled)
1642                 return;
1643
1644         if (acpi_failure)
1645                 return;
1646
1647         for (i = 0; ; i++) {
1648                 status = acpi_get_firmware_table("SPMI", i+1,
1649                                                  ACPI_LOGICAL_ADDRESSING,
1650                                                  (struct acpi_table_header **)
1651                                                  &spmi);
1652                 if (status != AE_OK)
1653                         return;
1654
1655                 try_init_acpi(spmi);
1656         }
1657 }
1658 #endif
1659
1660 #ifdef CONFIG_DMI
1661 struct dmi_ipmi_data
1662 {
1663         u8              type;
1664         u8              addr_space;
1665         unsigned long   base_addr;
1666         u8              irq;
1667         u8              offset;
1668         u8              slave_addr;
1669 };
1670
1671 static int __devinit decode_dmi(struct dmi_header *dm,
1672                                 struct dmi_ipmi_data *dmi)
1673 {
1674         u8              *data = (u8 *)dm;
1675         unsigned long   base_addr;
1676         u8              reg_spacing;
1677         u8              len = dm->length;
1678
1679         dmi->type = data[4];
1680
1681         memcpy(&base_addr, data+8, sizeof(unsigned long));
1682         if (len >= 0x11) {
1683                 if (base_addr & 1) {
1684                         /* I/O */
1685                         base_addr &= 0xFFFE;
1686                         dmi->addr_space = IPMI_IO_ADDR_SPACE;
1687                 }
1688                 else {
1689                         /* Memory */
1690                         dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1691                 }
1692                 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1693                    is odd. */
1694                 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1695
1696                 dmi->irq = data[0x11];
1697
1698                 /* The top two bits of byte 0x10 hold the register spacing. */
1699                 reg_spacing = (data[0x10] & 0xC0) >> 6;
1700                 switch(reg_spacing){
1701                 case 0x00: /* Byte boundaries */
1702                     dmi->offset = 1;
1703                     break;
1704                 case 0x01: /* 32-bit boundaries */
1705                     dmi->offset = 4;
1706                     break;
1707                 case 0x02: /* 16-byte boundaries */
1708                     dmi->offset = 16;
1709                     break;
1710                 default:
1711                     /* Some other interface, just ignore it. */
1712                     return -EIO;
1713                 }
1714         } else {
1715                 /* Old DMI spec. */
1716                 /* Note that technically, the lower bit of the base
1717                  * address should be 1 if the address is I/O and 0 if
1718                  * the address is in memory.  So many systems get that
1719                  * wrong (and all that I have seen are I/O) so we just
1720                  * ignore that bit and assume I/O.  Systems that use
1721                  * memory should use the newer spec, anyway. */
1722                 dmi->base_addr = base_addr & 0xfffe;
1723                 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1724                 dmi->offset = 1;
1725         }
1726
1727         dmi->slave_addr = data[6];
1728
1729         return 0;
1730 }
1731
1732 static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
1733 {
1734         struct smi_info *info;
1735
1736         info = kzalloc(sizeof(*info), GFP_KERNEL);
1737         if (!info) {
1738                 printk(KERN_ERR
1739                        "ipmi_si: Could not allocate SI data\n");
1740                 return;
1741         }
1742
1743         info->addr_source = "SMBIOS";
1744
1745         switch (ipmi_data->type) {
1746         case 0x01: /* KCS */
1747                 info->si_type = SI_KCS;
1748                 break;
1749         case 0x02: /* SMIC */
1750                 info->si_type = SI_SMIC;
1751                 break;
1752         case 0x03: /* BT */
1753                 info->si_type = SI_BT;
1754                 break;
1755         default:
1756                 return;
1757         }
1758
1759         switch (ipmi_data->addr_space) {
1760         case IPMI_MEM_ADDR_SPACE:
1761                 info->io_setup = mem_setup;
1762                 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1763                 break;
1764
1765         case IPMI_IO_ADDR_SPACE:
1766                 info->io_setup = port_setup;
1767                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1768                 break;
1769
1770         default:
1771                 kfree(info);
1772                 printk(KERN_WARNING
1773                        "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
1774                        ipmi_data->addr_space);
1775                 return;
1776         }
1777         info->io.addr_data = ipmi_data->base_addr;
1778
1779         info->io.regspacing = ipmi_data->offset;
1780         if (!info->io.regspacing)
1781                 info->io.regspacing = DEFAULT_REGSPACING;
1782         info->io.regsize = DEFAULT_REGSPACING;
1783         info->io.regshift = 0;
1784
1785         info->slave_addr = ipmi_data->slave_addr;
1786
1787         info->irq = ipmi_data->irq;
1788         if (info->irq)
1789                 info->irq_setup = std_irq_setup;
1790
1791         try_smi_init(info);
1792 }
1793
1794 static void __devinit dmi_find_bmc(void)
1795 {
1796         struct dmi_device    *dev = NULL;
1797         struct dmi_ipmi_data data;
1798         int                  rv;
1799
1800         while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
1801                 rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
1802                 if (!rv)
1803                         try_init_dmi(&data);
1804         }
1805 }
1806 #endif /* CONFIG_DMI */
1807
1808 #ifdef CONFIG_PCI
1809
1810 #define PCI_ERMC_CLASSCODE              0x0C0700
1811 #define PCI_ERMC_CLASSCODE_MASK         0xffffff00
1812 #define PCI_ERMC_CLASSCODE_TYPE_MASK    0xff
1813 #define PCI_ERMC_CLASSCODE_TYPE_SMIC    0x00
1814 #define PCI_ERMC_CLASSCODE_TYPE_KCS     0x01
1815 #define PCI_ERMC_CLASSCODE_TYPE_BT      0x02
1816
1817 #define PCI_HP_VENDOR_ID    0x103C
1818 #define PCI_MMC_DEVICE_ID   0x121A
1819 #define PCI_MMC_ADDR_CW     0x10
1820
1821 static void ipmi_pci_cleanup(struct smi_info *info)
1822 {
1823         struct pci_dev *pdev = info->addr_source_data;
1824
1825         pci_disable_device(pdev);
1826 }
1827
1828 static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
1829                                     const struct pci_device_id *ent)
1830 {
1831         int rv;
1832         int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
1833         struct smi_info *info;
1834         int first_reg_offset = 0;
1835
1836         info = kzalloc(sizeof(*info), GFP_KERNEL);
1837         if (!info)
1838                 return ENOMEM;
1839
1840         info->addr_source = "PCI";
1841
1842         switch (class_type) {
1843         case PCI_ERMC_CLASSCODE_TYPE_SMIC:
1844                 info->si_type = SI_SMIC;
1845                 break;
1846
1847         case PCI_ERMC_CLASSCODE_TYPE_KCS:
1848                 info->si_type = SI_KCS;
1849                 break;
1850
1851         case PCI_ERMC_CLASSCODE_TYPE_BT:
1852                 info->si_type = SI_BT;
1853                 break;
1854
1855         default:
1856                 kfree(info);
1857                 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
1858                        pci_name(pdev), class_type);
1859                 return ENOMEM;
1860         }
1861
1862         rv = pci_enable_device(pdev);
1863         if (rv) {
1864                 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
1865                        pci_name(pdev));
1866                 kfree(info);
1867                 return rv;
1868         }
1869
1870         info->addr_source_cleanup = ipmi_pci_cleanup;
1871         info->addr_source_data = pdev;
1872
1873         if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
1874                 first_reg_offset = 1;
1875
1876         if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
1877                 info->io_setup = port_setup;
1878                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1879         } else {
1880                 info->io_setup = mem_setup;
1881                 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1882         }
1883         info->io.addr_data = pci_resource_start(pdev, 0);
1884
1885         info->io.regspacing = DEFAULT_REGSPACING;
1886         info->io.regsize = DEFAULT_REGSPACING;
1887         info->io.regshift = 0;
1888
1889         info->irq = pdev->irq;
1890         if (info->irq)
1891                 info->irq_setup = std_irq_setup;
1892
1893         info->dev = &pdev->dev;
1894
1895         return try_smi_init(info);
1896 }
1897
1898 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
1899 {
1900 }
1901
1902 #ifdef CONFIG_PM
1903 static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
1904 {
1905         return 0;
1906 }
1907
1908 static int ipmi_pci_resume(struct pci_dev *pdev)
1909 {
1910         return 0;
1911 }
1912 #endif
1913
1914 static struct pci_device_id ipmi_pci_devices[] = {
1915         { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
1916         { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE) }
1917 };
1918 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
1919
1920 static struct pci_driver ipmi_pci_driver = {
1921         .name =         DEVICE_NAME,
1922         .id_table =     ipmi_pci_devices,
1923         .probe =        ipmi_pci_probe,
1924         .remove =       __devexit_p(ipmi_pci_remove),
1925 #ifdef CONFIG_PM
1926         .suspend =      ipmi_pci_suspend,
1927         .resume =       ipmi_pci_resume,
1928 #endif
1929 };
1930 #endif /* CONFIG_PCI */
1931
1932
1933 static int try_get_dev_id(struct smi_info *smi_info)
1934 {
1935         unsigned char         msg[2];
1936         unsigned char         *resp;
1937         unsigned long         resp_len;
1938         enum si_sm_result     smi_result;
1939         int                   rv = 0;
1940
1941         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1942         if (!resp)
1943                 return -ENOMEM;
1944
1945         /* Do a Get Device ID command, since it comes back with some
1946            useful info. */
1947         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1948         msg[1] = IPMI_GET_DEVICE_ID_CMD;
1949         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1950
1951         smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1952         for (;;)
1953         {
1954                 if (smi_result == SI_SM_CALL_WITH_DELAY ||
1955                     smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1956                         schedule_timeout_uninterruptible(1);
1957                         smi_result = smi_info->handlers->event(
1958                                 smi_info->si_sm, 100);
1959                 }
1960                 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1961                 {
1962                         smi_result = smi_info->handlers->event(
1963                                 smi_info->si_sm, 0);
1964                 }
1965                 else
1966                         break;
1967         }
1968         if (smi_result == SI_SM_HOSED) {
1969                 /* We couldn't get the state machine to run, so whatever's at
1970                    the port is probably not an IPMI SMI interface. */
1971                 rv = -ENODEV;
1972                 goto out;
1973         }
1974
1975         /* Otherwise, we got some data. */
1976         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1977                                                   resp, IPMI_MAX_MSG_LENGTH);
1978         if (resp_len < 14) {
1979                 /* That's odd, it should be longer. */
1980                 rv = -EINVAL;
1981                 goto out;
1982         }
1983
1984         if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
1985                 /* That's odd, it shouldn't be able to fail. */
1986                 rv = -EINVAL;
1987                 goto out;
1988         }
1989
1990         /* Record info from the get device id, in case we need it. */
1991         ipmi_demangle_device_id(resp+3, resp_len-3, &smi_info->device_id);
1992
1993  out:
1994         kfree(resp);
1995         return rv;
1996 }
1997
1998 static int type_file_read_proc(char *page, char **start, off_t off,
1999                                int count, int *eof, void *data)
2000 {
2001         char            *out = (char *) page;
2002         struct smi_info *smi = data;
2003
2004         switch (smi->si_type) {
2005             case SI_KCS:
2006                 return sprintf(out, "kcs\n");
2007             case SI_SMIC:
2008                 return sprintf(out, "smic\n");
2009             case SI_BT:
2010                 return sprintf(out, "bt\n");
2011             default:
2012                 return 0;
2013         }
2014 }
2015
2016 static int stat_file_read_proc(char *page, char **start, off_t off,
2017                                int count, int *eof, void *data)
2018 {
2019         char            *out = (char *) page;
2020         struct smi_info *smi = data;
2021
2022         out += sprintf(out, "interrupts_enabled:    %d\n",
2023                        smi->irq && !smi->interrupt_disabled);
2024         out += sprintf(out, "short_timeouts:        %ld\n",
2025                        smi->short_timeouts);
2026         out += sprintf(out, "long_timeouts:         %ld\n",
2027                        smi->long_timeouts);
2028         out += sprintf(out, "timeout_restarts:      %ld\n",
2029                        smi->timeout_restarts);
2030         out += sprintf(out, "idles:                 %ld\n",
2031                        smi->idles);
2032         out += sprintf(out, "interrupts:            %ld\n",
2033                        smi->interrupts);
2034         out += sprintf(out, "attentions:            %ld\n",
2035                        smi->attentions);
2036         out += sprintf(out, "flag_fetches:          %ld\n",
2037                        smi->flag_fetches);
2038         out += sprintf(out, "hosed_count:           %ld\n",
2039                        smi->hosed_count);
2040         out += sprintf(out, "complete_transactions: %ld\n",
2041                        smi->complete_transactions);
2042         out += sprintf(out, "events:                %ld\n",
2043                        smi->events);
2044         out += sprintf(out, "watchdog_pretimeouts:  %ld\n",
2045                        smi->watchdog_pretimeouts);
2046         out += sprintf(out, "incoming_messages:     %ld\n",
2047                        smi->incoming_messages);
2048
2049         return (out - ((char *) page));
2050 }
2051
2052 /*
2053  * oem_data_avail_to_receive_msg_avail
2054  * @info - smi_info structure with msg_flags set
2055  *
2056  * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2057  * Returns 1 indicating need to re-run handle_flags().
2058  */
2059 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2060 {
2061         smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2062                                 RECEIVE_MSG_AVAIL);
2063         return 1;
2064 }
2065
2066 /*
2067  * setup_dell_poweredge_oem_data_handler
2068  * @info - smi_info.device_id must be populated
2069  *
2070  * Systems that match, but have firmware version < 1.40 may assert
2071  * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2072  * it's safe to do so.  Such systems will de-assert OEM1_DATA_AVAIL
2073  * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2074  * as RECEIVE_MSG_AVAIL instead.
2075  *
2076  * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2077  * assert the OEM[012] bits, and if it did, the driver would have to
2078  * change to handle that properly, we don't actually check for the
2079  * firmware version.
2080  * Device ID = 0x20                BMC on PowerEdge 8G servers
2081  * Device Revision = 0x80
2082  * Firmware Revision1 = 0x01       BMC version 1.40
2083  * Firmware Revision2 = 0x40       BCD encoded
2084  * IPMI Version = 0x51             IPMI 1.5
2085  * Manufacturer ID = A2 02 00      Dell IANA
2086  *
2087  * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2088  * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2089  *
2090  */
2091 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID  0x20
2092 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2093 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2094 #define DELL_IANA_MFR_ID 0x0002a2
2095 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2096 {
2097         struct ipmi_device_id *id = &smi_info->device_id;
2098         if (id->manufacturer_id == DELL_IANA_MFR_ID) {
2099                 if (id->device_id       == DELL_POWEREDGE_8G_BMC_DEVICE_ID  &&
2100                     id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2101                     id->ipmi_version   == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
2102                         smi_info->oem_data_avail_handler =
2103                                 oem_data_avail_to_receive_msg_avail;
2104                 }
2105                 else if (ipmi_version_major(id) < 1 ||
2106                          (ipmi_version_major(id) == 1 &&
2107                           ipmi_version_minor(id) < 5)) {
2108                         smi_info->oem_data_avail_handler =
2109                                 oem_data_avail_to_receive_msg_avail;
2110                 }
2111         }
2112 }
2113
2114 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2115 static void return_hosed_msg_badsize(struct smi_info *smi_info)
2116 {
2117         struct ipmi_smi_msg *msg = smi_info->curr_msg;
2118
2119         /* Make it a reponse */
2120         msg->rsp[0] = msg->data[0] | 4;
2121         msg->rsp[1] = msg->data[1];
2122         msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2123         msg->rsp_size = 3;
2124         smi_info->curr_msg = NULL;
2125         deliver_recv_msg(smi_info, msg);
2126 }
2127
2128 /*
2129  * dell_poweredge_bt_xaction_handler
2130  * @info - smi_info.device_id must be populated
2131  *
2132  * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2133  * not respond to a Get SDR command if the length of the data
2134  * requested is exactly 0x3A, which leads to command timeouts and no
2135  * data returned.  This intercepts such commands, and causes userspace
2136  * callers to try again with a different-sized buffer, which succeeds.
2137  */
2138
2139 #define STORAGE_NETFN 0x0A
2140 #define STORAGE_CMD_GET_SDR 0x23
2141 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2142                                              unsigned long unused,
2143                                              void *in)
2144 {
2145         struct smi_info *smi_info = in;
2146         unsigned char *data = smi_info->curr_msg->data;
2147         unsigned int size   = smi_info->curr_msg->data_size;
2148         if (size >= 8 &&
2149             (data[0]>>2) == STORAGE_NETFN &&
2150             data[1] == STORAGE_CMD_GET_SDR &&
2151             data[7] == 0x3A) {
2152                 return_hosed_msg_badsize(smi_info);
2153                 return NOTIFY_STOP;
2154         }
2155         return NOTIFY_DONE;
2156 }
2157
2158 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2159         .notifier_call  = dell_poweredge_bt_xaction_handler,
2160 };
2161
2162 /*
2163  * setup_dell_poweredge_bt_xaction_handler
2164  * @info - smi_info.device_id must be filled in already
2165  *
2166  * Fills in smi_info.device_id.start_transaction_pre_hook
2167  * when we know what function to use there.
2168  */
2169 static void
2170 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2171 {
2172         struct ipmi_device_id *id = &smi_info->device_id;
2173         if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2174             smi_info->si_type == SI_BT)
2175                 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2176 }
2177
2178 /*
2179  * setup_oem_data_handler
2180  * @info - smi_info.device_id must be filled in already
2181  *
2182  * Fills in smi_info.device_id.oem_data_available_handler
2183  * when we know what function to use there.
2184  */
2185
2186 static void setup_oem_data_handler(struct smi_info *smi_info)
2187 {
2188         setup_dell_poweredge_oem_data_handler(smi_info);
2189 }
2190
2191 static void setup_xaction_handlers(struct smi_info *smi_info)
2192 {
2193         setup_dell_poweredge_bt_xaction_handler(smi_info);
2194 }
2195
2196 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2197 {
2198         if (smi_info->intf) {
2199                 /* The timer and thread are only running if the
2200                    interface has been started up and registered. */
2201                 if (smi_info->thread != NULL)
2202                         kthread_stop(smi_info->thread);
2203                 del_timer_sync(&smi_info->si_timer);
2204         }
2205 }
2206
2207 static __devinitdata struct ipmi_default_vals
2208 {
2209         int type;
2210         int port;
2211 } ipmi_defaults[] =
2212 {
2213         { .type = SI_KCS, .port = 0xca2 },
2214         { .type = SI_SMIC, .port = 0xca9 },
2215         { .type = SI_BT, .port = 0xe4 },
2216         { .port = 0 }
2217 };
2218
2219 static __devinit void default_find_bmc(void)
2220 {
2221         struct smi_info *info;
2222         int             i;
2223
2224         for (i = 0; ; i++) {
2225                 if (!ipmi_defaults[i].port)
2226                         break;
2227
2228                 info = kzalloc(sizeof(*info), GFP_KERNEL);
2229                 if (!info)
2230                         return;
2231
2232                 info->addr_source = NULL;
2233
2234                 info->si_type = ipmi_defaults[i].type;
2235                 info->io_setup = port_setup;
2236                 info->io.addr_data = ipmi_defaults[i].port;
2237                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2238
2239                 info->io.addr = NULL;
2240                 info->io.regspacing = DEFAULT_REGSPACING;
2241                 info->io.regsize = DEFAULT_REGSPACING;
2242                 info->io.regshift = 0;
2243
2244                 if (try_smi_init(info) == 0) {
2245                         /* Found one... */
2246                         printk(KERN_INFO "ipmi_si: Found default %s state"
2247                                " machine at %s address 0x%lx\n",
2248                                si_to_str[info->si_type],
2249                                addr_space_to_str[info->io.addr_type],
2250                                info->io.addr_data);
2251                         return;
2252                 }
2253         }
2254 }
2255
2256 static int is_new_interface(struct smi_info *info)
2257 {
2258         struct smi_info *e;
2259
2260         list_for_each_entry(e, &smi_infos, link) {
2261                 if (e->io.addr_type != info->io.addr_type)
2262                         continue;
2263                 if (e->io.addr_data == info->io.addr_data)
2264                         return 0;
2265         }
2266
2267         return 1;
2268 }
2269
2270 static int try_smi_init(struct smi_info *new_smi)
2271 {
2272         int rv;
2273
2274         if (new_smi->addr_source) {
2275                 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2276                        " machine at %s address 0x%lx, slave address 0x%x,"
2277                        " irq %d\n",
2278                        new_smi->addr_source,
2279                        si_to_str[new_smi->si_type],
2280                        addr_space_to_str[new_smi->io.addr_type],
2281                        new_smi->io.addr_data,
2282                        new_smi->slave_addr, new_smi->irq);
2283         }
2284
2285         mutex_lock(&smi_infos_lock);
2286         if (!is_new_interface(new_smi)) {
2287                 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2288                 rv = -EBUSY;
2289                 goto out_err;
2290         }
2291
2292         /* So we know not to free it unless we have allocated one. */
2293         new_smi->intf = NULL;
2294         new_smi->si_sm = NULL;
2295         new_smi->handlers = NULL;
2296
2297         switch (new_smi->si_type) {
2298         case SI_KCS:
2299                 new_smi->handlers = &kcs_smi_handlers;
2300                 break;
2301
2302         case SI_SMIC:
2303                 new_smi->handlers = &smic_smi_handlers;
2304                 break;
2305
2306         case SI_BT:
2307                 new_smi->handlers = &bt_smi_handlers;
2308                 break;
2309
2310         default:
2311                 /* No support for anything else yet. */
2312                 rv = -EIO;
2313                 goto out_err;
2314         }
2315
2316         /* Allocate the state machine's data and initialize it. */
2317         new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2318         if (!new_smi->si_sm) {
2319                 printk(" Could not allocate state machine memory\n");
2320                 rv = -ENOMEM;
2321                 goto out_err;
2322         }
2323         new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2324                                                         &new_smi->io);
2325
2326         /* Now that we know the I/O size, we can set up the I/O. */
2327         rv = new_smi->io_setup(new_smi);
2328         if (rv) {
2329                 printk(" Could not set up I/O space\n");
2330                 goto out_err;
2331         }
2332
2333         spin_lock_init(&(new_smi->si_lock));
2334         spin_lock_init(&(new_smi->msg_lock));
2335         spin_lock_init(&(new_smi->count_lock));
2336
2337         /* Do low-level detection first. */
2338         if (new_smi->handlers->detect(new_smi->si_sm)) {
2339                 if (new_smi->addr_source)
2340                         printk(KERN_INFO "ipmi_si: Interface detection"
2341                                " failed\n");
2342                 rv = -ENODEV;
2343                 goto out_err;
2344         }
2345
2346         /* Attempt a get device id command.  If it fails, we probably
2347            don't have a BMC here. */
2348         rv = try_get_dev_id(new_smi);
2349         if (rv) {
2350                 if (new_smi->addr_source)
2351                         printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2352                                " at this location\n");
2353                 goto out_err;
2354         }
2355
2356         setup_oem_data_handler(new_smi);
2357         setup_xaction_handlers(new_smi);
2358
2359         /* Try to claim any interrupts. */
2360         if (new_smi->irq_setup)
2361                 new_smi->irq_setup(new_smi);
2362
2363         INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2364         INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2365         new_smi->curr_msg = NULL;
2366         atomic_set(&new_smi->req_events, 0);
2367         new_smi->run_to_completion = 0;
2368
2369         new_smi->interrupt_disabled = 0;
2370         atomic_set(&new_smi->stop_operation, 0);
2371         new_smi->intf_num = smi_num;
2372         smi_num++;
2373
2374         /* Start clearing the flags before we enable interrupts or the
2375            timer to avoid racing with the timer. */
2376         start_clear_flags(new_smi);
2377         /* IRQ is defined to be set when non-zero. */
2378         if (new_smi->irq)
2379                 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2380
2381         if (!new_smi->dev) {
2382                 /* If we don't already have a device from something
2383                  * else (like PCI), then register a new one. */
2384                 new_smi->pdev = platform_device_alloc("ipmi_si",
2385                                                       new_smi->intf_num);
2386                 if (rv) {
2387                         printk(KERN_ERR
2388                                "ipmi_si_intf:"
2389                                " Unable to allocate platform device\n");
2390                         goto out_err;
2391                 }
2392                 new_smi->dev = &new_smi->pdev->dev;
2393                 new_smi->dev->driver = &ipmi_driver;
2394
2395                 rv = platform_device_register(new_smi->pdev);
2396                 if (rv) {
2397                         printk(KERN_ERR
2398                                "ipmi_si_intf:"
2399                                " Unable to register system interface device:"
2400                                " %d\n",
2401                                rv);
2402                         goto out_err;
2403                 }
2404                 new_smi->dev_registered = 1;
2405         }
2406
2407         rv = ipmi_register_smi(&handlers,
2408                                new_smi,
2409                                &new_smi->device_id,
2410                                new_smi->dev,
2411                                new_smi->slave_addr);
2412         if (rv) {
2413                 printk(KERN_ERR
2414                        "ipmi_si: Unable to register device: error %d\n",
2415                        rv);
2416                 goto out_err_stop_timer;
2417         }
2418
2419         rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2420                                      type_file_read_proc, NULL,
2421                                      new_smi, THIS_MODULE);
2422         if (rv) {
2423                 printk(KERN_ERR
2424                        "ipmi_si: Unable to create proc entry: %d\n",
2425                        rv);
2426                 goto out_err_stop_timer;
2427         }
2428
2429         rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2430                                      stat_file_read_proc, NULL,
2431                                      new_smi, THIS_MODULE);
2432         if (rv) {
2433                 printk(KERN_ERR
2434                        "ipmi_si: Unable to create proc entry: %d\n",
2435                        rv);
2436                 goto out_err_stop_timer;
2437         }
2438
2439         list_add_tail(&new_smi->link, &smi_infos);
2440
2441         mutex_unlock(&smi_infos_lock);
2442
2443         printk(" IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
2444
2445         return 0;
2446
2447  out_err_stop_timer:
2448         atomic_inc(&new_smi->stop_operation);
2449         wait_for_timer_and_thread(new_smi);
2450
2451  out_err:
2452         if (new_smi->intf)
2453                 ipmi_unregister_smi(new_smi->intf);
2454
2455         if (new_smi->irq_cleanup)
2456                 new_smi->irq_cleanup(new_smi);
2457
2458         /* Wait until we know that we are out of any interrupt
2459            handlers might have been running before we freed the
2460            interrupt. */
2461         synchronize_sched();
2462
2463         if (new_smi->si_sm) {
2464                 if (new_smi->handlers)
2465                         new_smi->handlers->cleanup(new_smi->si_sm);
2466                 kfree(new_smi->si_sm);
2467         }
2468         if (new_smi->addr_source_cleanup)
2469                 new_smi->addr_source_cleanup(new_smi);
2470         if (new_smi->io_cleanup)
2471                 new_smi->io_cleanup(new_smi);
2472
2473         if (new_smi->dev_registered)
2474                 platform_device_unregister(new_smi->pdev);
2475
2476         kfree(new_smi);
2477
2478         mutex_unlock(&smi_infos_lock);
2479
2480         return rv;
2481 }
2482
2483 static __devinit int init_ipmi_si(void)
2484 {
2485         int  i;
2486         char *str;
2487         int  rv;
2488
2489         if (initialized)
2490                 return 0;
2491         initialized = 1;
2492
2493         /* Register the device drivers. */
2494         rv = driver_register(&ipmi_driver);
2495         if (rv) {
2496                 printk(KERN_ERR
2497                        "init_ipmi_si: Unable to register driver: %d\n",
2498                        rv);
2499                 return rv;
2500         }
2501
2502
2503         /* Parse out the si_type string into its components. */
2504         str = si_type_str;
2505         if (*str != '\0') {
2506                 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
2507                         si_type[i] = str;
2508                         str = strchr(str, ',');
2509                         if (str) {
2510                                 *str = '\0';
2511                                 str++;
2512                         } else {
2513                                 break;
2514                         }
2515                 }
2516         }
2517
2518         printk(KERN_INFO "IPMI System Interface driver.\n");
2519
2520         hardcode_find_bmc();
2521
2522 #ifdef CONFIG_DMI
2523         dmi_find_bmc();
2524 #endif
2525
2526 #ifdef CONFIG_ACPI
2527         if (si_trydefaults)
2528                 acpi_find_bmc();
2529 #endif
2530
2531 #ifdef CONFIG_PCI
2532         pci_module_init(&ipmi_pci_driver);
2533 #endif
2534
2535         if (si_trydefaults) {
2536                 mutex_lock(&smi_infos_lock);
2537                 if (list_empty(&smi_infos)) {
2538                         /* No BMC was found, try defaults. */
2539                         mutex_unlock(&smi_infos_lock);
2540                         default_find_bmc();
2541                 } else {
2542                         mutex_unlock(&smi_infos_lock);
2543                 }
2544         }
2545
2546         mutex_lock(&smi_infos_lock);
2547         if (list_empty(&smi_infos)) {
2548                 mutex_unlock(&smi_infos_lock);
2549 #ifdef CONFIG_PCI
2550                 pci_unregister_driver(&ipmi_pci_driver);
2551 #endif
2552                 printk("ipmi_si: Unable to find any System Interface(s)\n");
2553                 return -ENODEV;
2554         } else {
2555                 mutex_unlock(&smi_infos_lock);
2556                 return 0;
2557         }
2558 }
2559 module_init(init_ipmi_si);
2560
2561 static void __devexit cleanup_one_si(struct smi_info *to_clean)
2562 {
2563         int           rv;
2564         unsigned long flags;
2565
2566         if (!to_clean)
2567                 return;
2568
2569         list_del(&to_clean->link);
2570
2571         /* Tell the timer and interrupt handlers that we are shutting
2572            down. */
2573         spin_lock_irqsave(&(to_clean->si_lock), flags);
2574         spin_lock(&(to_clean->msg_lock));
2575
2576         atomic_inc(&to_clean->stop_operation);
2577
2578         if (to_clean->irq_cleanup)
2579                 to_clean->irq_cleanup(to_clean);
2580
2581         spin_unlock(&(to_clean->msg_lock));
2582         spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2583
2584         /* Wait until we know that we are out of any interrupt
2585            handlers might have been running before we freed the
2586            interrupt. */
2587         synchronize_sched();
2588
2589         wait_for_timer_and_thread(to_clean);
2590
2591         /* Interrupts and timeouts are stopped, now make sure the
2592            interface is in a clean state. */
2593         while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
2594                 poll(to_clean);
2595                 schedule_timeout_uninterruptible(1);
2596         }
2597
2598         rv = ipmi_unregister_smi(to_clean->intf);
2599         if (rv) {
2600                 printk(KERN_ERR
2601                        "ipmi_si: Unable to unregister device: errno=%d\n",
2602                        rv);
2603         }
2604
2605         to_clean->handlers->cleanup(to_clean->si_sm);
2606
2607         kfree(to_clean->si_sm);
2608
2609         if (to_clean->addr_source_cleanup)
2610                 to_clean->addr_source_cleanup(to_clean);
2611         if (to_clean->io_cleanup)
2612                 to_clean->io_cleanup(to_clean);
2613
2614         if (to_clean->dev_registered)
2615                 platform_device_unregister(to_clean->pdev);
2616
2617         kfree(to_clean);
2618 }
2619
2620 static __exit void cleanup_ipmi_si(void)
2621 {
2622         struct smi_info *e, *tmp_e;
2623
2624         if (!initialized)
2625                 return;
2626
2627 #ifdef CONFIG_PCI
2628         pci_unregister_driver(&ipmi_pci_driver);
2629 #endif
2630
2631         mutex_lock(&smi_infos_lock);
2632         list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2633                 cleanup_one_si(e);
2634         mutex_unlock(&smi_infos_lock);
2635
2636         driver_unregister(&ipmi_driver);
2637 }
2638 module_exit(cleanup_ipmi_si);
2639
2640 MODULE_LICENSE("GPL");
2641 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2642 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");