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