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