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