drivers/char/ipmi/ipmi_si_intf.c

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