drivers/char/ipmi/ipmi_si_intf.c

   1 /*
   2  * ipmi_si.c
   3  *
   4  * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
   5  * BT).
   6  *
   7  * Author: MontaVista Software, Inc.
   8  *         Corey Minyard <minyard@mvista.com>
   9  *         source@mvista.com
  10  *
  11  * Copyright 2002 MontaVista Software Inc.
  12  *
  13  *  This program is free software; you can redistribute it and/or modify it
  14  *  under the terms of the GNU General Public License as published by the
  15  *  Free Software Foundation; either version 2 of the License, or (at your
  16  *  option) any later version.
  17  *
  18  *
  19  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  20  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  24  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  25  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  26  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  27  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  28  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  *  You should have received a copy of the GNU General Public License along
  31  *  with this program; if not, write to the Free Software Foundation, Inc.,
  32  *  675 Mass Ave, Cambridge, MA 02139, USA.
  33  */
  34
  35 /*
  36  * This file holds the "policy" for the interface to the SMI state
  37  * machine.  It does the configuration, handles timers and interrupts,
  38  * and drives the real SMI state machine.
  39  */
  40
  41 #include <linux/config.h>
  42 #include <linux/module.h>
  43 #include <linux/moduleparam.h>
  44 #include <asm/system.h>
  45 #include <linux/sched.h>
  46 #include <linux/timer.h>
  47 #include <linux/errno.h>
  48 #include <linux/spinlock.h>
  49 #include <linux/slab.h>
  50 #include <linux/delay.h>
  51 #include <linux/list.h>
  52 #include <linux/pci.h>
  53 #include <linux/ioport.h>
  54 #include <linux/irq.h>
  55 #ifdef CONFIG_HIGH_RES_TIMERS
  56 #include <linux/hrtime.h>
  57 # if defined(schedule_next_int)
  58 /* Old high-res timer code, do translations. */
  59 #  define get_arch_cycles(a) quick_update_jiffies_sub(a)
  60 #  define arch_cycles_per_jiffy cycles_per_jiffies
  61 # endif
  62 static inline void add_usec_to_timer(struct timer_list *t, long v)
  63 {
  64         t->sub_expires += nsec_to_arch_cycle(v * 1000);
  65         while (t->sub_expires >= arch_cycles_per_jiffy)
  66         {
  67                 t->expires++;
  68                 t->sub_expires -= arch_cycles_per_jiffy;
  69         }
  70 }
  71 #endif
  72 #include <linux/interrupt.h>
  73 #include <linux/rcupdate.h>
  74 #include <linux/ipmi_smi.h>
  75 #include <asm/io.h>
  76 #include "ipmi_si_sm.h"
  77 #include <linux/init.h>
  78
  79 #define IPMI_SI_VERSION "v32"
  80
  81 /* Measure times between events in the driver. */
  82 #undef DEBUG_TIMING
  83
  84 /* Call every 10 ms. */
  85 #define SI_TIMEOUT_TIME_USEC    10000
  86 #define SI_USEC_PER_JIFFY       (1000000/HZ)
  87 #define SI_TIMEOUT_JIFFIES      (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
  88 #define SI_SHORT_TIMEOUT_USEC  250 /* .25ms when the SM request a
  89                                        short timeout */
  90
  91 enum si_intf_state {
  92         SI_NORMAL,
  93         SI_GETTING_FLAGS,
  94         SI_GETTING_EVENTS,
  95         SI_CLEARING_FLAGS,
  96         SI_CLEARING_FLAGS_THEN_SET_IRQ,
  97         SI_GETTING_MESSAGES,
  98         SI_ENABLE_INTERRUPTS1,
  99         SI_ENABLE_INTERRUPTS2
 100         /* FIXME - add watchdog stuff. */
 101 };
 102
 103 enum si_type {
 104     SI_KCS, SI_SMIC, SI_BT
 105 };
 106
 107 struct smi_info
 108 {
 109         ipmi_smi_t             intf;
 110         struct si_sm_data      *si_sm;
 111         struct si_sm_handlers  *handlers;
 112         enum si_type           si_type;
 113         spinlock_t             si_lock;
 114         spinlock_t             msg_lock;
 115         struct list_head       xmit_msgs;
 116         struct list_head       hp_xmit_msgs;
 117         struct ipmi_smi_msg    *curr_msg;
 118         enum si_intf_state     si_state;
 119
 120         /* Used to handle the various types of I/O that can occur with
 121            IPMI */
 122         struct si_sm_io io;
 123         int (*io_setup)(struct smi_info *info);
 124         void (*io_cleanup)(struct smi_info *info);
 125         int (*irq_setup)(struct smi_info *info);
 126         void (*irq_cleanup)(struct smi_info *info);
 127         unsigned int io_size;
 128
 129         /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
 130            is set to hold the flags until we are done handling everything
 131            from the flags. */
 132 #define RECEIVE_MSG_AVAIL       0x01
 133 #define EVENT_MSG_BUFFER_FULL   0x02
 134 #define WDT_PRE_TIMEOUT_INT     0x08
 135         unsigned char       msg_flags;
 136
 137         /* If set to true, this will request events the next time the
 138            state machine is idle. */
 139         atomic_t            req_events;
 140
 141         /* If true, run the state machine to completion on every send
 142            call.  Generally used after a panic to make sure stuff goes
 143            out. */
 144         int                 run_to_completion;
 145
 146         /* The I/O port of an SI interface. */
 147         int                 port;
 148
 149         /* zero if no irq; */
 150         int                 irq;
 151
 152         /* The timer for this si. */
 153         struct timer_list   si_timer;
 154
 155         /* The time (in jiffies) the last timeout occurred at. */
 156         unsigned long       last_timeout_jiffies;
 157
 158         /* Used to gracefully stop the timer without race conditions. */
 159         volatile int        stop_operation;
 160         volatile int        timer_stopped;
 161
 162         /* The driver will disable interrupts when it gets into a
 163            situation where it cannot handle messages due to lack of
 164            memory.  Once that situation clears up, it will re-enable
 165            interrupts. */
 166         int interrupt_disabled;
 167
 168         unsigned char ipmi_si_dev_rev;
 169         unsigned char ipmi_si_fw_rev_major;
 170         unsigned char ipmi_si_fw_rev_minor;
 171         unsigned char ipmi_version_major;
 172         unsigned char ipmi_version_minor;
 173
 174         /* Counters and things for the proc filesystem. */
 175         spinlock_t count_lock;
 176         unsigned long short_timeouts;
 177         unsigned long long_timeouts;
 178         unsigned long timeout_restarts;
 179         unsigned long idles;
 180         unsigned long interrupts;
 181         unsigned long attentions;
 182         unsigned long flag_fetches;
 183         unsigned long hosed_count;
 184         unsigned long complete_transactions;
 185         unsigned long events;
 186         unsigned long watchdog_pretimeouts;
 187         unsigned long incoming_messages;
 188 };
 189
 190 static void si_restart_short_timer(struct smi_info *smi_info);
 191
 192 static void deliver_recv_msg(struct smi_info *smi_info,
 193                              struct ipmi_smi_msg *msg)
 194 {
 195         /* Deliver the message to the upper layer with the lock
 196            released. */
 197         spin_unlock(&(smi_info->si_lock));
 198         ipmi_smi_msg_received(smi_info->intf, msg);
 199         spin_lock(&(smi_info->si_lock));
 200 }
 201
 202 static void return_hosed_msg(struct smi_info *smi_info)
 203 {
 204         struct ipmi_smi_msg *msg = smi_info->curr_msg;
 205
 206         /* Make it a reponse */
 207         msg->rsp[0] = msg->data[0] | 4;
 208         msg->rsp[1] = msg->data[1];
 209         msg->rsp[2] = 0xFF; /* Unknown error. */
 210         msg->rsp_size = 3;
 211
 212         smi_info->curr_msg = NULL;
 213         deliver_recv_msg(smi_info, msg);
 214 }
 215
 216 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
 217 {
 218         int              rv;
 219         struct list_head *entry = NULL;
 220 #ifdef DEBUG_TIMING
 221         struct timeval t;
 222 #endif
 223
 224         /* No need to save flags, we aleady have interrupts off and we
 225            already hold the SMI lock. */
 226         spin_lock(&(smi_info->msg_lock));
 227
 228         /* Pick the high priority queue first. */
 229         if (! list_empty(&(smi_info->hp_xmit_msgs))) {
 230                 entry = smi_info->hp_xmit_msgs.next;
 231         } else if (! list_empty(&(smi_info->xmit_msgs))) {
 232                 entry = smi_info->xmit_msgs.next;
 233         }
 234
 235         if (!entry) {
 236                 smi_info->curr_msg = NULL;
 237                 rv = SI_SM_IDLE;
 238         } else {
 239                 int err;
 240
 241                 list_del(entry);
 242                 smi_info->curr_msg = list_entry(entry,
 243                                                 struct ipmi_smi_msg,
 244                                                 link);
 245 #ifdef DEBUG_TIMING
 246                 do_gettimeofday(&t);
 247                 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 248 #endif
 249                 err = smi_info->handlers->start_transaction(
 250                         smi_info->si_sm,
 251                         smi_info->curr_msg->data,
 252                         smi_info->curr_msg->data_size);
 253                 if (err) {
 254                         return_hosed_msg(smi_info);
 255                 }
 256
 257                 rv = SI_SM_CALL_WITHOUT_DELAY;
 258         }
 259         spin_unlock(&(smi_info->msg_lock));
 260
 261         return rv;
 262 }
 263
 264 static void start_enable_irq(struct smi_info *smi_info)
 265 {
 266         unsigned char msg[2];
 267
 268         /* If we are enabling interrupts, we have to tell the
 269            BMC to use them. */
 270         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 271         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
 272
 273         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
 274         smi_info->si_state = SI_ENABLE_INTERRUPTS1;
 275 }
 276
 277 static void start_clear_flags(struct smi_info *smi_info)
 278 {
 279         unsigned char msg[3];
 280
 281         /* Make sure the watchdog pre-timeout flag is not set at startup. */
 282         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 283         msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
 284         msg[2] = WDT_PRE_TIMEOUT_INT;
 285
 286         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
 287         smi_info->si_state = SI_CLEARING_FLAGS;
 288 }
 289
 290 /* When we have a situtaion where we run out of memory and cannot
 291    allocate messages, we just leave them in the BMC and run the system
 292    polled until we can allocate some memory.  Once we have some
 293    memory, we will re-enable the interrupt. */
 294 static inline void disable_si_irq(struct smi_info *smi_info)
 295 {
 296         if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
 297                 disable_irq_nosync(smi_info->irq);
 298                 smi_info->interrupt_disabled = 1;
 299         }
 300 }
 301
 302 static inline void enable_si_irq(struct smi_info *smi_info)
 303 {
 304         if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
 305                 enable_irq(smi_info->irq);
 306                 smi_info->interrupt_disabled = 0;
 307         }
 308 }
 309
 310 static void handle_flags(struct smi_info *smi_info)
 311 {
 312         if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
 313                 /* Watchdog pre-timeout */
 314                 spin_lock(&smi_info->count_lock);
 315                 smi_info->watchdog_pretimeouts++;
 316                 spin_unlock(&smi_info->count_lock);
 317
 318                 start_clear_flags(smi_info);
 319                 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
 320                 spin_unlock(&(smi_info->si_lock));
 321                 ipmi_smi_watchdog_pretimeout(smi_info->intf);
 322                 spin_lock(&(smi_info->si_lock));
 323         } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
 324                 /* Messages available. */
 325                 smi_info->curr_msg = ipmi_alloc_smi_msg();
 326                 if (!smi_info->curr_msg) {
 327                         disable_si_irq(smi_info);
 328                         smi_info->si_state = SI_NORMAL;
 329                         return;
 330                 }
 331                 enable_si_irq(smi_info);
 332
 333                 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 334                 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
 335                 smi_info->curr_msg->data_size = 2;
 336
 337                 smi_info->handlers->start_transaction(
 338                         smi_info->si_sm,
 339                         smi_info->curr_msg->data,
 340                         smi_info->curr_msg->data_size);
 341                 smi_info->si_state = SI_GETTING_MESSAGES;
 342         } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
 343                 /* Events available. */
 344                 smi_info->curr_msg = ipmi_alloc_smi_msg();
 345                 if (!smi_info->curr_msg) {
 346                         disable_si_irq(smi_info);
 347                         smi_info->si_state = SI_NORMAL;
 348                         return;
 349                 }
 350                 enable_si_irq(smi_info);
 351
 352                 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 353                 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
 354                 smi_info->curr_msg->data_size = 2;
 355
 356                 smi_info->handlers->start_transaction(
 357                         smi_info->si_sm,
 358                         smi_info->curr_msg->data,
 359                         smi_info->curr_msg->data_size);
 360                 smi_info->si_state = SI_GETTING_EVENTS;
 361         } else {
 362                 smi_info->si_state = SI_NORMAL;
 363         }
 364 }
 365
 366 static void handle_transaction_done(struct smi_info *smi_info)
 367 {
 368         struct ipmi_smi_msg *msg;
 369 #ifdef DEBUG_TIMING
 370         struct timeval t;
 371
 372         do_gettimeofday(&t);
 373         printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 374 #endif
 375         switch (smi_info->si_state) {
 376         case SI_NORMAL:
 377                 if (!smi_info->curr_msg)
 378                         break;
 379
 380                 smi_info->curr_msg->rsp_size
 381                         = smi_info->handlers->get_result(
 382                                 smi_info->si_sm,
 383                                 smi_info->curr_msg->rsp,
 384                                 IPMI_MAX_MSG_LENGTH);
 385
 386                 /* Do this here becase deliver_recv_msg() releases the
 387                    lock, and a new message can be put in during the
 388                    time the lock is released. */
 389                 msg = smi_info->curr_msg;
 390                 smi_info->curr_msg = NULL;
 391                 deliver_recv_msg(smi_info, msg);
 392                 break;
 393
 394         case SI_GETTING_FLAGS:
 395         {
 396                 unsigned char msg[4];
 397                 unsigned int  len;
 398
 399                 /* We got the flags from the SMI, now handle them. */
 400                 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 401                 if (msg[2] != 0) {
 402                         /* Error fetching flags, just give up for
 403                            now. */
 404                         smi_info->si_state = SI_NORMAL;
 405                 } else if (len < 3) {
 406                         /* Hmm, no flags.  That's technically illegal, but
 407                            don't use uninitialized data. */
 408                         smi_info->si_state = SI_NORMAL;
 409                 } else {
 410                         smi_info->msg_flags = msg[3];
 411                         handle_flags(smi_info);
 412                 }
 413                 break;
 414         }
 415
 416         case SI_CLEARING_FLAGS:
 417         case SI_CLEARING_FLAGS_THEN_SET_IRQ:
 418         {
 419                 unsigned char msg[3];
 420
 421                 /* We cleared the flags. */
 422                 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
 423                 if (msg[2] != 0) {
 424                         /* Error clearing flags */
 425                         printk(KERN_WARNING
 426                                "ipmi_si: Error clearing flags: %2.2x\n",
 427                                msg[2]);
 428                 }
 429                 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
 430                         start_enable_irq(smi_info);
 431                 else
 432                         smi_info->si_state = SI_NORMAL;
 433                 break;
 434         }
 435
 436         case SI_GETTING_EVENTS:
 437         {
 438                 smi_info->curr_msg->rsp_size
 439                         = smi_info->handlers->get_result(
 440                                 smi_info->si_sm,
 441                                 smi_info->curr_msg->rsp,
 442                                 IPMI_MAX_MSG_LENGTH);
 443
 444                 /* Do this here becase deliver_recv_msg() releases the
 445                    lock, and a new message can be put in during the
 446                    time the lock is released. */
 447                 msg = smi_info->curr_msg;
 448                 smi_info->curr_msg = NULL;
 449                 if (msg->rsp[2] != 0) {
 450                         /* Error getting event, probably done. */
 451                         msg->done(msg);
 452
 453                         /* Take off the event flag. */
 454                         smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
 455                 } else {
 456                         spin_lock(&smi_info->count_lock);
 457                         smi_info->events++;
 458                         spin_unlock(&smi_info->count_lock);
 459
 460                         deliver_recv_msg(smi_info, msg);
 461                 }
 462                 handle_flags(smi_info);
 463                 break;
 464         }
 465
 466         case SI_GETTING_MESSAGES:
 467         {
 468                 smi_info->curr_msg->rsp_size
 469                         = smi_info->handlers->get_result(
 470                                 smi_info->si_sm,
 471                                 smi_info->curr_msg->rsp,
 472                                 IPMI_MAX_MSG_LENGTH);
 473
 474                 /* Do this here becase deliver_recv_msg() releases the
 475                    lock, and a new message can be put in during the
 476                    time the lock is released. */
 477                 msg = smi_info->curr_msg;
 478                 smi_info->curr_msg = NULL;
 479                 if (msg->rsp[2] != 0) {
 480                         /* Error getting event, probably done. */
 481                         msg->done(msg);
 482
 483                         /* Take off the msg flag. */
 484                         smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
 485                 } else {
 486                         spin_lock(&smi_info->count_lock);
 487                         smi_info->incoming_messages++;
 488                         spin_unlock(&smi_info->count_lock);
 489
 490                         deliver_recv_msg(smi_info, msg);
 491                 }
 492                 handle_flags(smi_info);
 493                 break;
 494         }
 495
 496         case SI_ENABLE_INTERRUPTS1:
 497         {
 498                 unsigned char msg[4];
 499
 500                 /* We got the flags from the SMI, now handle them. */
 501                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 502                 if (msg[2] != 0) {
 503                         printk(KERN_WARNING
 504                                "ipmi_si: Could not enable interrupts"
 505                                ", failed get, using polled mode.\n");
 506                         smi_info->si_state = SI_NORMAL;
 507                 } else {
 508                         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 509                         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
 510                         msg[2] = msg[3] | 1; /* enable msg queue int */
 511                         smi_info->handlers->start_transaction(
 512                                 smi_info->si_sm, msg, 3);
 513                         smi_info->si_state = SI_ENABLE_INTERRUPTS2;
 514                 }
 515                 break;
 516         }
 517
 518         case SI_ENABLE_INTERRUPTS2:
 519         {
 520                 unsigned char msg[4];
 521
 522                 /* We got the flags from the SMI, now handle them. */
 523                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 524                 if (msg[2] != 0) {
 525                         printk(KERN_WARNING
 526                                "ipmi_si: Could not enable interrupts"
 527                                ", failed set, using polled mode.\n");
 528                 }
 529                 smi_info->si_state = SI_NORMAL;
 530                 break;
 531         }
 532         }
 533 }
 534
 535 /* Called on timeouts and events.  Timeouts should pass the elapsed
 536    time, interrupts should pass in zero. */
 537 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
 538                                            int time)
 539 {
 540         enum si_sm_result si_sm_result;
 541
 542  restart:
 543         /* There used to be a loop here that waited a little while
 544            (around 25us) before giving up.  That turned out to be
 545            pointless, the minimum delays I was seeing were in the 300us
 546            range, which is far too long to wait in an interrupt.  So
 547            we just run until the state machine tells us something
 548            happened or it needs a delay. */
 549         si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
 550         time = 0;
 551         while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
 552         {
 553                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
 554         }
 555
 556         if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
 557         {
 558                 spin_lock(&smi_info->count_lock);
 559                 smi_info->complete_transactions++;
 560                 spin_unlock(&smi_info->count_lock);
 561
 562                 handle_transaction_done(smi_info);
 563                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
 564         }
 565         else if (si_sm_result == SI_SM_HOSED)
 566         {
 567                 spin_lock(&smi_info->count_lock);
 568                 smi_info->hosed_count++;
 569                 spin_unlock(&smi_info->count_lock);
 570
 571                 if (smi_info->curr_msg != NULL) {
 572                         /* If we were handling a user message, format
 573                            a response to send to the upper layer to
 574                            tell it about the error. */
 575                         return_hosed_msg(smi_info);
 576                 }
 577                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
 578                 smi_info->si_state = SI_NORMAL;
 579         }
 580
 581         /* We prefer handling attn over new messages. */
 582         if (si_sm_result == SI_SM_ATTN)
 583         {
 584                 unsigned char msg[2];
 585
 586                 spin_lock(&smi_info->count_lock);
 587                 smi_info->attentions++;
 588                 spin_unlock(&smi_info->count_lock);
 589
 590                 /* Got a attn, send down a get message flags to see
 591                    what's causing it.  It would be better to handle
 592                    this in the upper layer, but due to the way
 593                    interrupts work with the SMI, that's not really
 594                    possible. */
 595                 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 596                 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
 597
 598                 smi_info->handlers->start_transaction(
 599                         smi_info->si_sm, msg, 2);
 600                 smi_info->si_state = SI_GETTING_FLAGS;
 601                 goto restart;
 602         }
 603
 604         /* If we are currently idle, try to start the next message. */
 605         if (si_sm_result == SI_SM_IDLE) {
 606                 spin_lock(&smi_info->count_lock);
 607                 smi_info->idles++;
 608                 spin_unlock(&smi_info->count_lock);
 609
 610                 si_sm_result = start_next_msg(smi_info);
 611                 if (si_sm_result != SI_SM_IDLE)
 612                         goto restart;
 613         }
 614
 615         if ((si_sm_result == SI_SM_IDLE)
 616             && (atomic_read(&smi_info->req_events)))
 617         {
 618                 /* We are idle and the upper layer requested that I fetch
 619                    events, so do so. */
 620                 unsigned char msg[2];
 621
 622                 spin_lock(&smi_info->count_lock);
 623                 smi_info->flag_fetches++;
 624                 spin_unlock(&smi_info->count_lock);
 625
 626                 atomic_set(&smi_info->req_events, 0);
 627                 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 628                 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
 629
 630                 smi_info->handlers->start_transaction(
 631                         smi_info->si_sm, msg, 2);
 632                 smi_info->si_state = SI_GETTING_FLAGS;
 633                 goto restart;
 634         }
 635
 636         return si_sm_result;
 637 }
 638
 639 static void sender(void                *send_info,
 640                    struct ipmi_smi_msg *msg,
 641                    int                 priority)
 642 {
 643         struct smi_info   *smi_info = send_info;
 644         enum si_sm_result result;
 645         unsigned long     flags;
 646 #ifdef DEBUG_TIMING
 647         struct timeval    t;
 648 #endif
 649
 650         spin_lock_irqsave(&(smi_info->msg_lock), flags);
 651 #ifdef DEBUG_TIMING
 652         do_gettimeofday(&t);
 653         printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 654 #endif
 655
 656         if (smi_info->run_to_completion) {
 657                 /* If we are running to completion, then throw it in
 658                    the list and run transactions until everything is
 659                    clear.  Priority doesn't matter here. */
 660                 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
 661
 662                 /* We have to release the msg lock and claim the smi
 663                    lock in this case, because of race conditions. */
 664                 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
 665
 666                 spin_lock_irqsave(&(smi_info->si_lock), flags);
 667                 result = smi_event_handler(smi_info, 0);
 668                 while (result != SI_SM_IDLE) {
 669                         udelay(SI_SHORT_TIMEOUT_USEC);
 670                         result = smi_event_handler(smi_info,
 671                                                    SI_SHORT_TIMEOUT_USEC);
 672                 }
 673                 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 674                 return;
 675         } else {
 676                 if (priority > 0) {
 677                         list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
 678                 } else {
 679                         list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
 680                 }
 681         }
 682         spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
 683
 684         spin_lock_irqsave(&(smi_info->si_lock), flags);
 685         if ((smi_info->si_state == SI_NORMAL)
 686             && (smi_info->curr_msg == NULL))
 687         {
 688                 start_next_msg(smi_info);
 689                 si_restart_short_timer(smi_info);
 690         }
 691         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 692 }
 693
 694 static void set_run_to_completion(void *send_info, int i_run_to_completion)
 695 {
 696         struct smi_info   *smi_info = send_info;
 697         enum si_sm_result result;
 698         unsigned long     flags;
 699
 700         spin_lock_irqsave(&(smi_info->si_lock), flags);
 701
 702         smi_info->run_to_completion = i_run_to_completion;
 703         if (i_run_to_completion) {
 704                 result = smi_event_handler(smi_info, 0);
 705                 while (result != SI_SM_IDLE) {
 706                         udelay(SI_SHORT_TIMEOUT_USEC);
 707                         result = smi_event_handler(smi_info,
 708                                                    SI_SHORT_TIMEOUT_USEC);
 709                 }
 710         }
 711
 712         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 713 }
 714
 715 static void poll(void *send_info)
 716 {
 717         struct smi_info *smi_info = send_info;
 718
 719         smi_event_handler(smi_info, 0);
 720 }
 721
 722 static void request_events(void *send_info)
 723 {
 724         struct smi_info *smi_info = send_info;
 725
 726         atomic_set(&smi_info->req_events, 1);
 727 }
 728
 729 static int initialized = 0;
 730
 731 /* Must be called with interrupts off and with the si_lock held. */
 732 static void si_restart_short_timer(struct smi_info *smi_info)
 733 {
 734 #if defined(CONFIG_HIGH_RES_TIMERS)
 735         unsigned long flags;
 736         unsigned long jiffies_now;
 737
 738         if (del_timer(&(smi_info->si_timer))) {
 739                 /* If we don't delete the timer, then it will go off
 740                    immediately, anyway.  So we only process if we
 741                    actually delete the timer. */
 742
 743                 /* We already have irqsave on, so no need for it
 744                    here. */
 745                 read_lock(&xtime_lock);
 746                 jiffies_now = jiffies;
 747                 smi_info->si_timer.expires = jiffies_now;
 748                 smi_info->si_timer.sub_expires = get_arch_cycles(jiffies_now);
 749
 750                 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
 751
 752                 add_timer(&(smi_info->si_timer));
 753                 spin_lock_irqsave(&smi_info->count_lock, flags);
 754                 smi_info->timeout_restarts++;
 755                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
 756         }
 757 #endif
 758 }
 759
 760 static void smi_timeout(unsigned long data)
 761 {
 762         struct smi_info   *smi_info = (struct smi_info *) data;
 763         enum si_sm_result smi_result;
 764         unsigned long     flags;
 765         unsigned long     jiffies_now;
 766         unsigned long     time_diff;
 767 #ifdef DEBUG_TIMING
 768         struct timeval    t;
 769 #endif
 770
 771         if (smi_info->stop_operation) {
 772                 smi_info->timer_stopped = 1;
 773                 return;
 774         }
 775
 776         spin_lock_irqsave(&(smi_info->si_lock), flags);
 777 #ifdef DEBUG_TIMING
 778         do_gettimeofday(&t);
 779         printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 780 #endif
 781         jiffies_now = jiffies;
 782         time_diff = ((jiffies_now - smi_info->last_timeout_jiffies)
 783                      * SI_USEC_PER_JIFFY);
 784         smi_result = smi_event_handler(smi_info, time_diff);
 785
 786         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 787
 788         smi_info->last_timeout_jiffies = jiffies_now;
 789
 790         if ((smi_info->irq) && (! smi_info->interrupt_disabled)) {
 791                 /* Running with interrupts, only do long timeouts. */
 792                 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
 793                 spin_lock_irqsave(&smi_info->count_lock, flags);
 794                 smi_info->long_timeouts++;
 795                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
 796                 goto do_add_timer;
 797         }
 798
 799         /* If the state machine asks for a short delay, then shorten
 800            the timer timeout. */
 801         if (smi_result == SI_SM_CALL_WITH_DELAY) {
 802                 spin_lock_irqsave(&smi_info->count_lock, flags);
 803                 smi_info->short_timeouts++;
 804                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
 805 #if defined(CONFIG_HIGH_RES_TIMERS)
 806                 read_lock(&xtime_lock);
 807                 smi_info->si_timer.expires = jiffies;
 808                 smi_info->si_timer.sub_expires
 809                         = get_arch_cycles(smi_info->si_timer.expires);
 810                 read_unlock(&xtime_lock);
 811                 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
 812 #else
 813                 smi_info->si_timer.expires = jiffies + 1;
 814 #endif
 815         } else {
 816                 spin_lock_irqsave(&smi_info->count_lock, flags);
 817                 smi_info->long_timeouts++;
 818                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
 819                 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
 820 #if defined(CONFIG_HIGH_RES_TIMERS)
 821                 smi_info->si_timer.sub_expires = 0;
 822 #endif
 823         }
 824
 825  do_add_timer:
 826         add_timer(&(smi_info->si_timer));
 827 }
 828
 829 static irqreturn_t si_irq_handler(int irq, void *data, struct pt_regs *regs)
 830 {
 831         struct smi_info *smi_info = data;
 832         unsigned long   flags;
 833 #ifdef DEBUG_TIMING
 834         struct timeval  t;
 835 #endif
 836
 837         spin_lock_irqsave(&(smi_info->si_lock), flags);
 838
 839         spin_lock(&smi_info->count_lock);
 840         smi_info->interrupts++;
 841         spin_unlock(&smi_info->count_lock);
 842
 843         if (smi_info->stop_operation)
 844                 goto out;
 845
 846 #ifdef DEBUG_TIMING
 847         do_gettimeofday(&t);
 848         printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 849 #endif
 850         smi_event_handler(smi_info, 0);
 851  out:
 852         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 853         return IRQ_HANDLED;
 854 }
 855
 856 static struct ipmi_smi_handlers handlers =
 857 {
 858         .owner                  = THIS_MODULE,
 859         .sender                 = sender,
 860         .request_events         = request_events,
 861         .set_run_to_completion  = set_run_to_completion,
 862         .poll                   = poll,
 863 };
 864
 865 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
 866    a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS */
 867
 868 #define SI_MAX_PARMS 4
 869 #define SI_MAX_DRIVERS ((SI_MAX_PARMS * 2) + 2)
 870 static struct smi_info *smi_infos[SI_MAX_DRIVERS] =
 871 { NULL, NULL, NULL, NULL };
 872
 873 #define DEVICE_NAME "ipmi_si"
 874
 875 #define DEFAULT_KCS_IO_PORT 0xca2
 876 #define DEFAULT_SMIC_IO_PORT 0xca9
 877 #define DEFAULT_BT_IO_PORT   0xe4
 878
 879 static int           si_trydefaults = 1;
 880 static char          *si_type[SI_MAX_PARMS] = { NULL, NULL, NULL, NULL };
 881 #define MAX_SI_TYPE_STR 30
 882 static char          si_type_str[MAX_SI_TYPE_STR];
 883 static unsigned long addrs[SI_MAX_PARMS] = { 0, 0, 0, 0 };
 884 static int num_addrs = 0;
 885 static unsigned int  ports[SI_MAX_PARMS] = { 0, 0, 0, 0 };
 886 static int num_ports = 0;
 887 static int           irqs[SI_MAX_PARMS] = { 0, 0, 0, 0 };
 888 static int num_irqs = 0;
 889
 890
 891 module_param_named(trydefaults, si_trydefaults, bool, 0);
 892 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
 893                  " default scan of the KCS and SMIC interface at the standard"
 894                  " address");
 895 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
 896 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
 897                  " interface separated by commas.  The types are 'kcs',"
 898                  " 'smic', and 'bt'.  For example si_type=kcs,bt will set"
 899                  " the first interface to kcs and the second to bt");
 900 module_param_array(addrs, long, num_addrs, 0);
 901 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
 902                  " addresses separated by commas.  Only use if an interface"
 903                  " is in memory.  Otherwise, set it to zero or leave"
 904                  " it blank.");
 905 module_param_array(ports, int, num_ports, 0);
 906 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
 907                  " addresses separated by commas.  Only use if an interface"
 908                  " is a port.  Otherwise, set it to zero or leave"
 909                  " it blank.");
 910 module_param_array(irqs, int, num_irqs, 0);
 911 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
 912                  " addresses separated by commas.  Only use if an interface"
 913                  " has an interrupt.  Otherwise, set it to zero or leave"
 914                  " it blank.");
 915
 916 #define IPMI_MEM_ADDR_SPACE 1
 917 #define IPMI_IO_ADDR_SPACE  2
 918
 919 #if defined(CONFIG_ACPI_INTERPETER) || defined(CONFIG_X86) || defined(CONFIG_PCI)
 920 static int is_new_interface(int intf, u8 addr_space, unsigned long base_addr)
 921 {
 922         int i;
 923
 924         for (i = 0; i < SI_MAX_PARMS; ++i) {
 925                 /* Don't check our address. */
 926                 if (i == intf)
 927                         continue;
 928                 if (si_type[i] != NULL) {
 929                         if ((addr_space == IPMI_MEM_ADDR_SPACE &&
 930                              base_addr == addrs[i]) ||
 931                             (addr_space == IPMI_IO_ADDR_SPACE &&
 932                              base_addr == ports[i]))
 933                                 return 0;
 934                 }
 935                 else
 936                         break;
 937         }
 938
 939         return 1;
 940 }
 941 #endif
 942
 943 static int std_irq_setup(struct smi_info *info)
 944 {
 945         int rv;
 946
 947         if (!info->irq)
 948                 return 0;
 949
 950         rv = request_irq(info->irq,
 951                          si_irq_handler,
 952                          SA_INTERRUPT,
 953                          DEVICE_NAME,
 954                          info);
 955         if (rv) {
 956                 printk(KERN_WARNING
 957                        "ipmi_si: %s unable to claim interrupt %d,"
 958                        " running polled\n",
 959                        DEVICE_NAME, info->irq);
 960                 info->irq = 0;
 961         } else {
 962                 printk("  Using irq %d\n", info->irq);
 963         }
 964
 965         return rv;
 966 }
 967
 968 static void std_irq_cleanup(struct smi_info *info)
 969 {
 970         if (!info->irq)
 971                 return;
 972
 973         free_irq(info->irq, info);
 974 }
 975
 976 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
 977 {
 978         unsigned int *addr = io->info;
 979
 980         return inb((*addr)+offset);
 981 }
 982
 983 static void port_outb(struct si_sm_io *io, unsigned int offset,
 984                       unsigned char b)
 985 {
 986         unsigned int *addr = io->info;
 987
 988         outb(b, (*addr)+offset);
 989 }
 990
 991 static int port_setup(struct smi_info *info)
 992 {
 993         unsigned int *addr = info->io.info;
 994
 995         if (!addr || (!*addr))
 996                 return -ENODEV;
 997
 998         if (request_region(*addr, info->io_size, DEVICE_NAME) == NULL)
 999                 return -EIO;
1000         return 0;
1001 }
1002
1003 static void port_cleanup(struct smi_info *info)
1004 {
1005         unsigned int *addr = info->io.info;
1006
1007         if (addr && (*addr))
1008                 release_region (*addr, info->io_size);
1009         kfree(info);
1010 }
1011
1012 static int try_init_port(int intf_num, struct smi_info **new_info)
1013 {
1014         struct smi_info *info;
1015
1016         if (!ports[intf_num])
1017                 return -ENODEV;
1018
1019         if (!is_new_interface(intf_num, IPMI_IO_ADDR_SPACE,
1020                               ports[intf_num]))
1021                 return -ENODEV;
1022
1023         info = kmalloc(sizeof(*info), GFP_KERNEL);
1024         if (!info) {
1025                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (1)\n");
1026                 return -ENOMEM;
1027         }
1028         memset(info, 0, sizeof(*info));
1029
1030         info->io_setup = port_setup;
1031         info->io_cleanup = port_cleanup;
1032         info->io.inputb = port_inb;
1033         info->io.outputb = port_outb;
1034         info->io.info = &(ports[intf_num]);
1035         info->io.addr = NULL;
1036         info->irq = 0;
1037         info->irq_setup = NULL;
1038         *new_info = info;
1039
1040         if (si_type[intf_num] == NULL)
1041                 si_type[intf_num] = "kcs";
1042
1043         printk("ipmi_si: Trying \"%s\" at I/O port 0x%x\n",
1044                si_type[intf_num], ports[intf_num]);
1045         return 0;
1046 }
1047
1048 static unsigned char mem_inb(struct si_sm_io *io, unsigned int offset)
1049 {
1050         return readb((io->addr)+offset);
1051 }
1052
1053 static void mem_outb(struct si_sm_io *io, unsigned int offset,
1054                      unsigned char b)
1055 {
1056         writeb(b, (io->addr)+offset);
1057 }
1058
1059 static int mem_setup(struct smi_info *info)
1060 {
1061         unsigned long *addr = info->io.info;
1062
1063         if (!addr || (!*addr))
1064                 return -ENODEV;
1065
1066         if (request_mem_region(*addr, info->io_size, DEVICE_NAME) == NULL)
1067                 return -EIO;
1068
1069         info->io.addr = ioremap(*addr, info->io_size);
1070         if (info->io.addr == NULL) {
1071                 release_mem_region(*addr, info->io_size);
1072                 return -EIO;
1073         }
1074         return 0;
1075 }
1076
1077 static void mem_cleanup(struct smi_info *info)
1078 {
1079         unsigned long *addr = info->io.info;
1080
1081         if (info->io.addr) {
1082                 iounmap(info->io.addr);
1083                 release_mem_region(*addr, info->io_size);
1084         }
1085         kfree(info);
1086 }
1087
1088 static int try_init_mem(int intf_num, struct smi_info **new_info)
1089 {
1090         struct smi_info *info;
1091
1092         if (!addrs[intf_num])
1093                 return -ENODEV;
1094
1095         if (!is_new_interface(intf_num, IPMI_MEM_ADDR_SPACE,
1096                               addrs[intf_num]))
1097                 return -ENODEV;
1098
1099         info = kmalloc(sizeof(*info), GFP_KERNEL);
1100         if (!info) {
1101                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (2)\n");
1102                 return -ENOMEM;
1103         }
1104         memset(info, 0, sizeof(*info));
1105
1106         info->io_setup = mem_setup;
1107         info->io_cleanup = mem_cleanup;
1108         info->io.inputb = mem_inb;
1109         info->io.outputb = mem_outb;
1110         info->io.info = (void *) addrs[intf_num];
1111         info->io.addr = NULL;
1112         info->irq = 0;
1113         info->irq_setup = NULL;
1114         *new_info = info;
1115
1116         if (si_type[intf_num] == NULL)
1117                 si_type[intf_num] = "kcs";
1118
1119         printk("ipmi_si: Trying \"%s\" at memory address 0x%lx\n",
1120                si_type[intf_num], addrs[intf_num]);
1121         return 0;
1122 }
1123
1124
1125 #ifdef CONFIG_ACPI_INTERPRETER
1126
1127 #include <linux/acpi.h>
1128
1129 /* Once we get an ACPI failure, we don't try any more, because we go
1130    through the tables sequentially.  Once we don't find a table, there
1131    are no more. */
1132 static int acpi_failure = 0;
1133
1134 /* For GPE-type interrupts. */
1135 u32 ipmi_acpi_gpe(void *context)
1136 {
1137         struct smi_info *smi_info = context;
1138         unsigned long   flags;
1139 #ifdef DEBUG_TIMING
1140         struct timeval t;
1141 #endif
1142
1143         spin_lock_irqsave(&(smi_info->si_lock), flags);
1144
1145         spin_lock(&smi_info->count_lock);
1146         smi_info->interrupts++;
1147         spin_unlock(&smi_info->count_lock);
1148
1149         if (smi_info->stop_operation)
1150                 goto out;
1151
1152 #ifdef DEBUG_TIMING
1153         do_gettimeofday(&t);
1154         printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1155 #endif
1156         smi_event_handler(smi_info, 0);
1157  out:
1158         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1159         return 0;
1160 }
1161
1162 static int acpi_gpe_irq_setup(struct smi_info *info)
1163 {
1164         acpi_status status;
1165
1166         if (!info->irq)
1167                 return 0;
1168
1169         /* FIXME - is level triggered right? */
1170         status = acpi_install_gpe_handler(NULL,
1171                                           info->irq,
1172                                           ACPI_GPE_LEVEL_TRIGGERED,
1173                                           ipmi_acpi_gpe,
1174                                           info);
1175         if (status != AE_OK) {
1176                 printk(KERN_WARNING
1177                        "ipmi_si: %s unable to claim ACPI GPE %d,"
1178                        " running polled\n",
1179                        DEVICE_NAME, info->irq);
1180                 info->irq = 0;
1181                 return -EINVAL;
1182         } else {
1183                 printk("  Using ACPI GPE %d\n", info->irq);
1184                 return 0;
1185         }
1186
1187 }
1188
1189 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1190 {
1191         if (!info->irq)
1192                 return;
1193
1194         acpi_remove_gpe_handler(NULL, info->irq, ipmi_acpi_gpe);
1195 }
1196
1197 /*
1198  * Defined at
1199  * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1200  */
1201 struct SPMITable {
1202         s8      Signature[4];
1203         u32     Length;
1204         u8      Revision;
1205         u8      Checksum;
1206         s8      OEMID[6];
1207         s8      OEMTableID[8];
1208         s8      OEMRevision[4];
1209         s8      CreatorID[4];
1210         s8      CreatorRevision[4];
1211         u8      InterfaceType;
1212         u8      IPMIlegacy;
1213         s16     SpecificationRevision;
1214
1215         /*
1216          * Bit 0 - SCI interrupt supported
1217          * Bit 1 - I/O APIC/SAPIC
1218          */
1219         u8      InterruptType;
1220
1221         /* If bit 0 of InterruptType is set, then this is the SCI
1222            interrupt in the GPEx_STS register. */
1223         u8      GPE;
1224
1225         s16     Reserved;
1226
1227         /* If bit 1 of InterruptType is set, then this is the I/O
1228            APIC/SAPIC interrupt. */
1229         u32     GlobalSystemInterrupt;
1230
1231         /* The actual register address. */
1232         struct acpi_generic_address addr;
1233
1234         u8      UID[4];
1235
1236         s8      spmi_id[1]; /* A '\0' terminated array starts here. */
1237 };
1238
1239 static int try_init_acpi(int intf_num, struct smi_info **new_info)
1240 {
1241         struct smi_info  *info;
1242         acpi_status      status;
1243         struct SPMITable *spmi;
1244         char             *io_type;
1245         u8               addr_space;
1246
1247         if (acpi_failure)
1248                 return -ENODEV;
1249
1250         status = acpi_get_firmware_table("SPMI", intf_num+1,
1251                                          ACPI_LOGICAL_ADDRESSING,
1252                                          (struct acpi_table_header **) &spmi);
1253         if (status != AE_OK) {
1254                 acpi_failure = 1;
1255                 return -ENODEV;
1256         }
1257
1258         if (spmi->IPMIlegacy != 1) {
1259             printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1260             return -ENODEV;
1261         }
1262
1263         if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1264                 addr_space = IPMI_MEM_ADDR_SPACE;
1265         else
1266                 addr_space = IPMI_IO_ADDR_SPACE;
1267         if (!is_new_interface(-1, addr_space, spmi->addr.address))
1268                 return -ENODEV;
1269
1270         /* Figure out the interface type. */
1271         switch (spmi->InterfaceType)
1272         {
1273         case 1: /* KCS */
1274                 si_type[intf_num] = "kcs";
1275                 break;
1276
1277         case 2: /* SMIC */
1278                 si_type[intf_num] = "smic";
1279                 break;
1280
1281         case 3: /* BT */
1282                 si_type[intf_num] = "bt";
1283                 break;
1284
1285         default:
1286                 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1287                         spmi->InterfaceType);
1288                 return -EIO;
1289         }
1290
1291         info = kmalloc(sizeof(*info), GFP_KERNEL);
1292         if (!info) {
1293                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1294                 return -ENOMEM;
1295         }
1296         memset(info, 0, sizeof(*info));
1297
1298         if (spmi->InterruptType & 1) {
1299                 /* We've got a GPE interrupt. */
1300                 info->irq = spmi->GPE;
1301                 info->irq_setup = acpi_gpe_irq_setup;
1302                 info->irq_cleanup = acpi_gpe_irq_cleanup;
1303         } else if (spmi->InterruptType & 2) {
1304                 /* We've got an APIC/SAPIC interrupt. */
1305                 info->irq = spmi->GlobalSystemInterrupt;
1306                 info->irq_setup = std_irq_setup;
1307                 info->irq_cleanup = std_irq_cleanup;
1308         } else {
1309                 /* Use the default interrupt setting. */
1310                 info->irq = 0;
1311                 info->irq_setup = NULL;
1312         }
1313
1314         if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1315                 io_type = "memory";
1316                 info->io_setup = mem_setup;
1317                 info->io_cleanup = mem_cleanup;
1318                 addrs[intf_num] = spmi->addr.address;
1319                 info->io.inputb = mem_inb;
1320                 info->io.outputb = mem_outb;
1321                 info->io.info = &(addrs[intf_num]);
1322         } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1323                 io_type = "I/O";
1324                 info->io_setup = port_setup;
1325                 info->io_cleanup = port_cleanup;
1326                 ports[intf_num] = spmi->addr.address;
1327                 info->io.inputb = port_inb;
1328                 info->io.outputb = port_outb;
1329                 info->io.info = &(ports[intf_num]);
1330         } else {
1331                 kfree(info);
1332                 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1333                 return -EIO;
1334         }
1335
1336         *new_info = info;
1337
1338         printk("ipmi_si: ACPI/SPMI specifies \"%s\" %s SI @ 0x%lx\n",
1339                si_type[intf_num], io_type, (unsigned long) spmi->addr.address);
1340         return 0;
1341 }
1342 #endif
1343
1344 #ifdef CONFIG_X86
1345
1346 typedef struct dmi_ipmi_data
1347 {
1348         u8              type;
1349         u8              addr_space;
1350         unsigned long   base_addr;
1351         u8              irq;
1352 }dmi_ipmi_data_t;
1353
1354 typedef struct dmi_header
1355 {
1356         u8      type;
1357         u8      length;
1358         u16     handle;
1359 }dmi_header_t;
1360
1361 static int decode_dmi(dmi_header_t *dm, dmi_ipmi_data_t *ipmi_data)
1362 {
1363         u8              *data = (u8 *)dm;
1364         unsigned long   base_addr;
1365
1366         ipmi_data->type = data[0x04];
1367
1368         memcpy(&base_addr,&data[0x08],sizeof(unsigned long));
1369         if (base_addr & 1) {
1370                 /* I/O */
1371                 base_addr &= 0xFFFE;
1372                 ipmi_data->addr_space = IPMI_IO_ADDR_SPACE;
1373         }
1374         else {
1375                 /* Memory */
1376                 ipmi_data->addr_space = IPMI_MEM_ADDR_SPACE;
1377         }
1378
1379         ipmi_data->base_addr = base_addr;
1380         ipmi_data->irq = data[0x11];
1381
1382         if (is_new_interface(-1, ipmi_data->addr_space,ipmi_data->base_addr))
1383             return 0;
1384
1385         memset(ipmi_data,0,sizeof(dmi_ipmi_data_t));
1386
1387         return -1;
1388 }
1389
1390 static int dmi_table(u32 base, int len, int num,
1391         dmi_ipmi_data_t *ipmi_data)
1392 {
1393         u8                *buf;
1394         struct dmi_header *dm;
1395         u8                *data;
1396         int               i=1;
1397         int               status=-1;
1398
1399         buf = ioremap(base, len);
1400         if(buf==NULL)
1401                 return -1;
1402
1403         data = buf;
1404
1405         while(i<num && (data - buf) < len)
1406         {
1407                 dm=(dmi_header_t *)data;
1408
1409                 if((data-buf+dm->length) >= len)
1410                         break;
1411
1412                 if (dm->type == 38) {
1413                         if (decode_dmi(dm, ipmi_data) == 0) {
1414                                 status = 0;
1415                                 break;
1416                         }
1417                 }
1418
1419                 data+=dm->length;
1420                 while((data-buf) < len && (*data || data[1]))
1421                         data++;
1422                 data+=2;
1423                 i++;
1424         }
1425         iounmap(buf);
1426
1427         return status;
1428 }
1429
1430 inline static int dmi_checksum(u8 *buf)
1431 {
1432         u8   sum=0;
1433         int  a;
1434
1435         for(a=0; a<15; a++)
1436                 sum+=buf[a];
1437         return (sum==0);
1438 }
1439
1440 static int dmi_iterator(dmi_ipmi_data_t *ipmi_data)
1441 {
1442         u8   buf[15];
1443         u32  fp=0xF0000;
1444
1445 #ifdef CONFIG_SIMNOW
1446         return -1;
1447 #endif
1448
1449         while(fp < 0xFFFFF)
1450         {
1451                 isa_memcpy_fromio(buf, fp, 15);
1452                 if(memcmp(buf, "_DMI_", 5)==0 && dmi_checksum(buf))
1453                 {
1454                         u16 num=buf[13]<<8|buf[12];
1455                         u16 len=buf[7]<<8|buf[6];
1456                         u32 base=buf[11]<<24|buf[10]<<16|buf[9]<<8|buf[8];
1457
1458                         if(dmi_table(base, len, num, ipmi_data) == 0)
1459                                 return 0;
1460                 }
1461                 fp+=16;
1462         }
1463
1464         return -1;
1465 }
1466
1467 static int try_init_smbios(int intf_num, struct smi_info **new_info)
1468 {
1469         struct smi_info   *info;
1470         dmi_ipmi_data_t   ipmi_data;
1471         char              *io_type;
1472         int               status;
1473
1474         status = dmi_iterator(&ipmi_data);
1475
1476         if (status < 0)
1477                 return -ENODEV;
1478
1479         switch(ipmi_data.type) {
1480                 case 0x01: /* KCS */
1481                         si_type[intf_num] = "kcs";
1482                         break;
1483                 case 0x02: /* SMIC */
1484                         si_type[intf_num] = "smic";
1485                         break;
1486                 case 0x03: /* BT */
1487                         si_type[intf_num] = "bt";
1488                         break;
1489                 default:
1490                         printk("ipmi_si: Unknown SMBIOS SI type.\n");
1491                         return -EIO;
1492         }
1493
1494         info = kmalloc(sizeof(*info), GFP_KERNEL);
1495         if (!info) {
1496                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (4)\n");
1497                 return -ENOMEM;
1498         }
1499         memset(info, 0, sizeof(*info));
1500
1501         if (ipmi_data.addr_space == 1) {
1502                 io_type = "memory";
1503                 info->io_setup = mem_setup;
1504                 info->io_cleanup = mem_cleanup;
1505                 addrs[intf_num] = ipmi_data.base_addr;
1506                 info->io.inputb = mem_inb;
1507                 info->io.outputb = mem_outb;
1508                 info->io.info = &(addrs[intf_num]);
1509         } else if (ipmi_data.addr_space == 2) {
1510                 io_type = "I/O";
1511                 info->io_setup = port_setup;
1512                 info->io_cleanup = port_cleanup;
1513                 ports[intf_num] = ipmi_data.base_addr;
1514                 info->io.inputb = port_inb;
1515                 info->io.outputb = port_outb;
1516                 info->io.info = &(ports[intf_num]);
1517         } else {
1518                 kfree(info);
1519                 printk("ipmi_si: Unknown SMBIOS I/O Address type.\n");
1520                 return -EIO;
1521         }
1522
1523         irqs[intf_num] = ipmi_data.irq;
1524
1525         *new_info = info;
1526
1527         printk("ipmi_si: Found SMBIOS-specified state machine at %s"
1528                " address 0x%lx\n",
1529                io_type, (unsigned long)ipmi_data.base_addr);
1530         return 0;
1531 }
1532 #endif /* CONFIG_X86 */
1533
1534 #ifdef CONFIG_PCI
1535
1536 #define PCI_ERMC_CLASSCODE  0x0C0700
1537 #define PCI_HP_VENDOR_ID    0x103C
1538 #define PCI_MMC_DEVICE_ID   0x121A
1539 #define PCI_MMC_ADDR_CW     0x10
1540
1541 /* Avoid more than one attempt to probe pci smic. */
1542 static int pci_smic_checked = 0;
1543
1544 static int find_pci_smic(int intf_num, struct smi_info **new_info)
1545 {
1546         struct smi_info  *info;
1547         int              error;
1548         struct pci_dev   *pci_dev = NULL;
1549         u16              base_addr;
1550         int              fe_rmc = 0;
1551
1552         if (pci_smic_checked)
1553                 return -ENODEV;
1554
1555         pci_smic_checked = 1;
1556
1557         if ((pci_dev = pci_find_device(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID,
1558                                        NULL)))
1559                 ;
1560         else if ((pci_dev = pci_find_class(PCI_ERMC_CLASSCODE, NULL)) &&
1561                  pci_dev->subsystem_vendor == PCI_HP_VENDOR_ID)
1562                 fe_rmc = 1;
1563         else
1564                 return -ENODEV;
1565
1566         error = pci_read_config_word(pci_dev, PCI_MMC_ADDR_CW, &base_addr);
1567         if (error)
1568         {
1569                 printk(KERN_ERR
1570                        "ipmi_si: pci_read_config_word() failed (%d).\n",
1571                        error);
1572                 return -ENODEV;
1573         }
1574
1575         /* Bit 0: 1 specifies programmed I/O, 0 specifies memory mapped I/O */
1576         if (!(base_addr & 0x0001))
1577         {
1578                 printk(KERN_ERR
1579                        "ipmi_si: memory mapped I/O not supported for PCI"
1580                        " smic.\n");
1581                 return -ENODEV;
1582         }
1583
1584         base_addr &= 0xFFFE;
1585         if (!fe_rmc)
1586                 /* Data register starts at base address + 1 in eRMC */
1587                 ++base_addr;
1588
1589         if (!is_new_interface(-1, IPMI_IO_ADDR_SPACE, base_addr))
1590             return -ENODEV;
1591
1592         info = kmalloc(sizeof(*info), GFP_KERNEL);
1593         if (!info) {
1594                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (5)\n");
1595                 return -ENOMEM;
1596         }
1597         memset(info, 0, sizeof(*info));
1598
1599         info->io_setup = port_setup;
1600         info->io_cleanup = port_cleanup;
1601         ports[intf_num] = base_addr;
1602         info->io.inputb = port_inb;
1603         info->io.outputb = port_outb;
1604         info->io.info = &(ports[intf_num]);
1605
1606         *new_info = info;
1607
1608         irqs[intf_num] = pci_dev->irq;
1609         si_type[intf_num] = "smic";
1610
1611         printk("ipmi_si: Found PCI SMIC at I/O address 0x%lx\n",
1612                 (long unsigned int) base_addr);
1613
1614         return 0;
1615 }
1616 #endif /* CONFIG_PCI */
1617
1618 static int try_init_plug_and_play(int intf_num, struct smi_info **new_info)
1619 {
1620 #ifdef CONFIG_PCI
1621         if (find_pci_smic(intf_num, new_info)==0)
1622                 return 0;
1623 #endif
1624         /* Include other methods here. */
1625
1626         return -ENODEV;
1627 }
1628
1629
1630 static int try_get_dev_id(struct smi_info *smi_info)
1631 {
1632         unsigned char      msg[2];
1633         unsigned char      *resp;
1634         unsigned long      resp_len;
1635         enum si_sm_result smi_result;
1636         int               rv = 0;
1637
1638         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1639         if (!resp)
1640                 return -ENOMEM;
1641
1642         /* Do a Get Device ID command, since it comes back with some
1643            useful info. */
1644         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1645         msg[1] = IPMI_GET_DEVICE_ID_CMD;
1646         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1647
1648         smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1649         for (;;)
1650         {
1651                 if (smi_result == SI_SM_CALL_WITH_DELAY) {
1652                         set_current_state(TASK_UNINTERRUPTIBLE);
1653                         schedule_timeout(1);
1654                         smi_result = smi_info->handlers->event(
1655                                 smi_info->si_sm, 100);
1656                 }
1657                 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1658                 {
1659                         smi_result = smi_info->handlers->event(
1660                                 smi_info->si_sm, 0);
1661                 }
1662                 else
1663                         break;
1664         }
1665         if (smi_result == SI_SM_HOSED) {
1666                 /* We couldn't get the state machine to run, so whatever's at
1667                    the port is probably not an IPMI SMI interface. */
1668                 rv = -ENODEV;
1669                 goto out;
1670         }
1671
1672         /* Otherwise, we got some data. */
1673         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1674                                                   resp, IPMI_MAX_MSG_LENGTH);
1675         if (resp_len < 6) {
1676                 /* That's odd, it should be longer. */
1677                 rv = -EINVAL;
1678                 goto out;
1679         }
1680
1681         if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
1682                 /* That's odd, it shouldn't be able to fail. */
1683                 rv = -EINVAL;
1684                 goto out;
1685         }
1686
1687         /* Record info from the get device id, in case we need it. */
1688         smi_info->ipmi_si_dev_rev = resp[4] & 0xf;
1689         smi_info->ipmi_si_fw_rev_major = resp[5] & 0x7f;
1690         smi_info->ipmi_si_fw_rev_minor = resp[6];
1691         smi_info->ipmi_version_major = resp[7] & 0xf;
1692         smi_info->ipmi_version_minor = resp[7] >> 4;
1693
1694  out:
1695         kfree(resp);
1696         return rv;
1697 }
1698
1699 static int type_file_read_proc(char *page, char **start, off_t off,
1700                                int count, int *eof, void *data)
1701 {
1702         char            *out = (char *) page;
1703         struct smi_info *smi = data;
1704
1705         switch (smi->si_type) {
1706             case SI_KCS:
1707                 return sprintf(out, "kcs\n");
1708             case SI_SMIC:
1709                 return sprintf(out, "smic\n");
1710             case SI_BT:
1711                 return sprintf(out, "bt\n");
1712             default:
1713                 return 0;
1714         }
1715 }
1716
1717 static int stat_file_read_proc(char *page, char **start, off_t off,
1718                                int count, int *eof, void *data)
1719 {
1720         char            *out = (char *) page;
1721         struct smi_info *smi = data;
1722
1723         out += sprintf(out, "interrupts_enabled:    %d\n",
1724                        smi->irq && !smi->interrupt_disabled);
1725         out += sprintf(out, "short_timeouts:        %ld\n",
1726                        smi->short_timeouts);
1727         out += sprintf(out, "long_timeouts:         %ld\n",
1728                        smi->long_timeouts);
1729         out += sprintf(out, "timeout_restarts:      %ld\n",
1730                        smi->timeout_restarts);
1731         out += sprintf(out, "idles:                 %ld\n",
1732                        smi->idles);
1733         out += sprintf(out, "interrupts:            %ld\n",
1734                        smi->interrupts);
1735         out += sprintf(out, "attentions:            %ld\n",
1736                        smi->attentions);
1737         out += sprintf(out, "flag_fetches:          %ld\n",
1738                        smi->flag_fetches);
1739         out += sprintf(out, "hosed_count:           %ld\n",
1740                        smi->hosed_count);
1741         out += sprintf(out, "complete_transactions: %ld\n",
1742                        smi->complete_transactions);
1743         out += sprintf(out, "events:                %ld\n",
1744                        smi->events);
1745         out += sprintf(out, "watchdog_pretimeouts:  %ld\n",
1746                        smi->watchdog_pretimeouts);
1747         out += sprintf(out, "incoming_messages:     %ld\n",
1748                        smi->incoming_messages);
1749
1750         return (out - ((char *) page));
1751 }
1752
1753 /* Returns 0 if initialized, or negative on an error. */
1754 static int init_one_smi(int intf_num, struct smi_info **smi)
1755 {
1756         int             rv;
1757         struct smi_info *new_smi;
1758
1759
1760         rv = try_init_mem(intf_num, &new_smi);
1761         if (rv)
1762                 rv = try_init_port(intf_num, &new_smi);
1763 #ifdef CONFIG_ACPI_INTERPRETER
1764         if ((rv) && (si_trydefaults)) {
1765                 rv = try_init_acpi(intf_num, &new_smi);
1766         }
1767 #endif
1768 #ifdef CONFIG_X86
1769         if ((rv) && (si_trydefaults)) {
1770                 rv = try_init_smbios(intf_num, &new_smi);
1771         }
1772 #endif
1773         if ((rv) && (si_trydefaults)) {
1774                 rv = try_init_plug_and_play(intf_num, &new_smi);
1775         }
1776
1777
1778         if (rv)
1779                 return rv;
1780
1781         /* So we know not to free it unless we have allocated one. */
1782         new_smi->intf = NULL;
1783         new_smi->si_sm = NULL;
1784         new_smi->handlers = NULL;
1785
1786         if (!new_smi->irq_setup) {
1787                 new_smi->irq = irqs[intf_num];
1788                 new_smi->irq_setup = std_irq_setup;
1789                 new_smi->irq_cleanup = std_irq_cleanup;
1790         }
1791
1792         /* Default to KCS if no type is specified. */
1793         if (si_type[intf_num] == NULL) {
1794                 if (si_trydefaults)
1795                         si_type[intf_num] = "kcs";
1796                 else {
1797                         rv = -EINVAL;
1798                         goto out_err;
1799                 }
1800         }
1801
1802         /* Set up the state machine to use. */
1803         if (strcmp(si_type[intf_num], "kcs") == 0) {
1804                 new_smi->handlers = &kcs_smi_handlers;
1805                 new_smi->si_type = SI_KCS;
1806         } else if (strcmp(si_type[intf_num], "smic") == 0) {
1807                 new_smi->handlers = &smic_smi_handlers;
1808                 new_smi->si_type = SI_SMIC;
1809         } else if (strcmp(si_type[intf_num], "bt") == 0) {
1810                 new_smi->handlers = &bt_smi_handlers;
1811                 new_smi->si_type = SI_BT;
1812         } else {
1813                 /* No support for anything else yet. */
1814                 rv = -EIO;
1815                 goto out_err;
1816         }
1817
1818         /* Allocate the state machine's data and initialize it. */
1819         new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
1820         if (!new_smi->si_sm) {
1821                 printk(" Could not allocate state machine memory\n");
1822                 rv = -ENOMEM;
1823                 goto out_err;
1824         }
1825         new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
1826                                                         &new_smi->io);
1827
1828         /* Now that we know the I/O size, we can set up the I/O. */
1829         rv = new_smi->io_setup(new_smi);
1830         if (rv) {
1831                 printk(" Could not set up I/O space\n");
1832                 goto out_err;
1833         }
1834
1835         spin_lock_init(&(new_smi->si_lock));
1836         spin_lock_init(&(new_smi->msg_lock));
1837         spin_lock_init(&(new_smi->count_lock));
1838
1839         /* Do low-level detection first. */
1840         if (new_smi->handlers->detect(new_smi->si_sm)) {
1841                 rv = -ENODEV;
1842                 goto out_err;
1843         }
1844
1845         /* Attempt a get device id command.  If it fails, we probably
1846            don't have a SMI here. */
1847         rv = try_get_dev_id(new_smi);
1848         if (rv)
1849                 goto out_err;
1850
1851         /* Try to claim any interrupts. */
1852         new_smi->irq_setup(new_smi);
1853
1854         INIT_LIST_HEAD(&(new_smi->xmit_msgs));
1855         INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
1856         new_smi->curr_msg = NULL;
1857         atomic_set(&new_smi->req_events, 0);
1858         new_smi->run_to_completion = 0;
1859
1860         new_smi->interrupt_disabled = 0;
1861         new_smi->timer_stopped = 0;
1862         new_smi->stop_operation = 0;
1863
1864         /* The ipmi_register_smi() code does some operations to
1865            determine the channel information, so we must be ready to
1866            handle operations before it is called.  This means we have
1867            to stop the timer if we get an error after this point. */
1868         init_timer(&(new_smi->si_timer));
1869         new_smi->si_timer.data = (long) new_smi;
1870         new_smi->si_timer.function = smi_timeout;
1871         new_smi->last_timeout_jiffies = jiffies;
1872         new_smi->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
1873         add_timer(&(new_smi->si_timer));
1874
1875         rv = ipmi_register_smi(&handlers,
1876                                new_smi,
1877                                new_smi->ipmi_version_major,
1878                                new_smi->ipmi_version_minor,
1879                                &(new_smi->intf));
1880         if (rv) {
1881                 printk(KERN_ERR
1882                        "ipmi_si: Unable to register device: error %d\n",
1883                        rv);
1884                 goto out_err_stop_timer;
1885         }
1886
1887         rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
1888                                      type_file_read_proc, NULL,
1889                                      new_smi, THIS_MODULE);
1890         if (rv) {
1891                 printk(KERN_ERR
1892                        "ipmi_si: Unable to create proc entry: %d\n",
1893                        rv);
1894                 goto out_err_stop_timer;
1895         }
1896
1897         rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
1898                                      stat_file_read_proc, NULL,
1899                                      new_smi, THIS_MODULE);
1900         if (rv) {
1901                 printk(KERN_ERR
1902                        "ipmi_si: Unable to create proc entry: %d\n",
1903                        rv);
1904                 goto out_err_stop_timer;
1905         }
1906
1907         start_clear_flags(new_smi);
1908
1909         /* IRQ is defined to be set when non-zero. */
1910         if (new_smi->irq)
1911                 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
1912
1913         *smi = new_smi;
1914
1915         printk(" IPMI %s interface initialized\n", si_type[intf_num]);
1916
1917         return 0;
1918
1919  out_err_stop_timer:
1920         new_smi->stop_operation = 1;
1921
1922         /* Wait for the timer to stop.  This avoids problems with race
1923            conditions removing the timer here. */
1924         while (!new_smi->timer_stopped) {
1925                 set_current_state(TASK_UNINTERRUPTIBLE);
1926                 schedule_timeout(1);
1927         }
1928
1929  out_err:
1930         if (new_smi->intf)
1931                 ipmi_unregister_smi(new_smi->intf);
1932
1933         new_smi->irq_cleanup(new_smi);
1934
1935         /* Wait until we know that we are out of any interrupt
1936            handlers might have been running before we freed the
1937            interrupt. */
1938         synchronize_kernel();
1939
1940         if (new_smi->si_sm) {
1941                 if (new_smi->handlers)
1942                         new_smi->handlers->cleanup(new_smi->si_sm);
1943                 kfree(new_smi->si_sm);
1944         }
1945         new_smi->io_cleanup(new_smi);
1946
1947         return rv;
1948 }
1949
1950 static __init int init_ipmi_si(void)
1951 {
1952         int  rv = 0;
1953         int  pos = 0;
1954         int  i;
1955         char *str;
1956
1957         if (initialized)
1958                 return 0;
1959         initialized = 1;
1960
1961         /* Parse out the si_type string into its components. */
1962         str = si_type_str;
1963         if (*str != '\0') {
1964                 for (i=0; (i<SI_MAX_PARMS) && (*str != '\0'); i++) {
1965                         si_type[i] = str;
1966                         str = strchr(str, ',');
1967                         if (str) {
1968                                 *str = '\0';
1969                                 str++;
1970                         } else {
1971                                 break;
1972                         }
1973                 }
1974         }
1975
1976         printk(KERN_INFO "IPMI System Interface driver version "
1977                IPMI_SI_VERSION);
1978         if (kcs_smi_handlers.version)
1979                 printk(", KCS version %s", kcs_smi_handlers.version);
1980         if (smic_smi_handlers.version)
1981                 printk(", SMIC version %s", smic_smi_handlers.version);
1982         if (bt_smi_handlers.version)
1983                 printk(", BT version %s", bt_smi_handlers.version);
1984         printk("\n");
1985
1986         rv = init_one_smi(0, &(smi_infos[pos]));
1987         if (rv && !ports[0] && si_trydefaults) {
1988                 /* If we are trying defaults and the initial port is
1989                    not set, then set it. */
1990                 si_type[0] = "kcs";
1991                 ports[0] = DEFAULT_KCS_IO_PORT;
1992                 rv = init_one_smi(0, &(smi_infos[pos]));
1993                 if (rv) {
1994                         /* No KCS - try SMIC */
1995                         si_type[0] = "smic";
1996                         ports[0] = DEFAULT_SMIC_IO_PORT;
1997                         rv = init_one_smi(0, &(smi_infos[pos]));
1998                 }
1999                 if (rv) {
2000                         /* No SMIC - try BT */
2001                         si_type[0] = "bt";
2002                         ports[0] = DEFAULT_BT_IO_PORT;
2003                         rv = init_one_smi(0, &(smi_infos[pos]));
2004                 }
2005         }
2006         if (rv == 0)
2007                 pos++;
2008
2009         for (i=1; i < SI_MAX_PARMS; i++) {
2010                 rv = init_one_smi(i, &(smi_infos[pos]));
2011                 if (rv == 0)
2012                         pos++;
2013         }
2014
2015         if (smi_infos[0] == NULL) {
2016                 printk("ipmi_si: Unable to find any System Interface(s)\n");
2017                 return -ENODEV;
2018         }
2019
2020         return 0;
2021 }
2022 module_init(init_ipmi_si);
2023
2024 void __exit cleanup_one_si(struct smi_info *to_clean)
2025 {
2026         int           rv;
2027         unsigned long flags;
2028
2029         if (! to_clean)
2030                 return;
2031
2032         /* Tell the timer and interrupt handlers that we are shutting
2033            down. */
2034         spin_lock_irqsave(&(to_clean->si_lock), flags);
2035         spin_lock(&(to_clean->msg_lock));
2036
2037         to_clean->stop_operation = 1;
2038
2039         to_clean->irq_cleanup(to_clean);
2040
2041         spin_unlock(&(to_clean->msg_lock));
2042         spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2043
2044         /* Wait until we know that we are out of any interrupt
2045            handlers might have been running before we freed the
2046            interrupt. */
2047         synchronize_kernel();
2048
2049         /* Wait for the timer to stop.  This avoids problems with race
2050            conditions removing the timer here. */
2051         while (!to_clean->timer_stopped) {
2052                 set_current_state(TASK_UNINTERRUPTIBLE);
2053                 schedule_timeout(1);
2054         }
2055
2056         rv = ipmi_unregister_smi(to_clean->intf);
2057         if (rv) {
2058                 printk(KERN_ERR
2059                        "ipmi_si: Unable to unregister device: errno=%d\n",
2060                        rv);
2061         }
2062
2063         to_clean->handlers->cleanup(to_clean->si_sm);
2064
2065         kfree(to_clean->si_sm);
2066
2067         to_clean->io_cleanup(to_clean);
2068 }
2069
2070 static __exit void cleanup_ipmi_si(void)
2071 {
2072         int i;
2073
2074         if (!initialized)
2075                 return;
2076
2077         for (i=0; i<SI_MAX_DRIVERS; i++) {
2078                 cleanup_one_si(smi_infos[i]);
2079         }
2080 }
2081 module_exit(cleanup_ipmi_si);
2082
2083 MODULE_LICENSE("GPL");