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