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