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