drivers/char/ipmi/ipmi_si_intf.c

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