drivers/char/ipmi/ipmi_si_intf.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * ipmi_si.c
   4  *
   5  * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
   6  * BT).
   7  *
   8  * Author: MontaVista Software, Inc.
   9  *         Corey Minyard <minyard@mvista.com>
  10  *         source@mvista.com
  11  *
  12  * Copyright 2002 MontaVista Software Inc.
  13  * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
  14  */
  15
  16 /*
  17  * This file holds the "policy" for the interface to the SMI state
  18  * machine.  It does the configuration, handles timers and interrupts,
  19  * and drives the real SMI state machine.
  20  */
  21
  22 #define pr_fmt(fmt) "ipmi_si: " fmt
  23
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/sched.h>
  27 #include <linux/seq_file.h>
  28 #include <linux/timer.h>
  29 #include <linux/errno.h>
  30 #include <linux/spinlock.h>
  31 #include <linux/slab.h>
  32 #include <linux/delay.h>
  33 #include <linux/list.h>
  34 #include <linux/notifier.h>
  35 #include <linux/mutex.h>
  36 #include <linux/kthread.h>
  37 #include <asm/irq.h>
  38 #include <linux/interrupt.h>
  39 #include <linux/rcupdate.h>
  40 #include <linux/ipmi.h>
  41 #include <linux/ipmi_smi.h>
  42 #include "ipmi_si.h"
  43 #include "ipmi_si_sm.h"
  44 #include <linux/string.h>
  45 #include <linux/ctype.h>
  46
  47 /* Measure times between events in the driver. */
  48 #undef DEBUG_TIMING
  49
  50 /* Call every 10 ms. */
  51 #define SI_TIMEOUT_TIME_USEC    10000
  52 #define SI_USEC_PER_JIFFY       (1000000/HZ)
  53 #define SI_TIMEOUT_JIFFIES      (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
  54 #define SI_SHORT_TIMEOUT_USEC  250 /* .25ms when the SM request a
  55                                       short timeout */
  56
  57 enum si_intf_state {
  58         SI_NORMAL,
  59         SI_GETTING_FLAGS,
  60         SI_GETTING_EVENTS,
  61         SI_CLEARING_FLAGS,
  62         SI_GETTING_MESSAGES,
  63         SI_CHECKING_ENABLES,
  64         SI_SETTING_ENABLES
  65         /* FIXME - add watchdog stuff. */
  66 };
  67
  68 /* Some BT-specific defines we need here. */
  69 #define IPMI_BT_INTMASK_REG             2
  70 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT   2
  71 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT  1
  72
  73 /* 'invalid' to allow a firmware-specified interface to be disabled */
  74 const char *const si_to_str[] = { "invalid", "kcs", "smic", "bt", NULL };
  75
  76 static bool initialized;
  77
  78 /*
  79  * Indexes into stats[] in smi_info below.
  80  */
  81 enum si_stat_indexes {
  82         /*
  83          * Number of times the driver requested a timer while an operation
  84          * was in progress.
  85          */
  86         SI_STAT_short_timeouts = 0,
  87
  88         /*
  89          * Number of times the driver requested a timer while nothing was in
  90          * progress.
  91          */
  92         SI_STAT_long_timeouts,
  93
  94         /* Number of times the interface was idle while being polled. */
  95         SI_STAT_idles,
  96
  97         /* Number of interrupts the driver handled. */
  98         SI_STAT_interrupts,
  99
 100         /* Number of time the driver got an ATTN from the hardware. */
 101         SI_STAT_attentions,
 102
 103         /* Number of times the driver requested flags from the hardware. */
 104         SI_STAT_flag_fetches,
 105
 106         /* Number of times the hardware didn't follow the state machine. */
 107         SI_STAT_hosed_count,
 108
 109         /* Number of completed messages. */
 110         SI_STAT_complete_transactions,
 111
 112         /* Number of IPMI events received from the hardware. */
 113         SI_STAT_events,
 114
 115         /* Number of watchdog pretimeouts. */
 116         SI_STAT_watchdog_pretimeouts,
 117
 118         /* Number of asynchronous messages received. */
 119         SI_STAT_incoming_messages,
 120
 121
 122         /* This *must* remain last, add new values above this. */
 123         SI_NUM_STATS
 124 };
 125
 126 struct smi_info {
 127         int                    si_num;
 128         struct ipmi_smi        *intf;
 129         struct si_sm_data      *si_sm;
 130         const struct si_sm_handlers *handlers;
 131         spinlock_t             si_lock;
 132         struct ipmi_smi_msg    *waiting_msg;
 133         struct ipmi_smi_msg    *curr_msg;
 134         enum si_intf_state     si_state;
 135
 136         /*
 137          * Used to handle the various types of I/O that can occur with
 138          * IPMI
 139          */
 140         struct si_sm_io io;
 141
 142         /*
 143          * Per-OEM handler, called from handle_flags().  Returns 1
 144          * when handle_flags() needs to be re-run or 0 indicating it
 145          * set si_state itself.
 146          */
 147         int (*oem_data_avail_handler)(struct smi_info *smi_info);
 148
 149         /*
 150          * Flags from the last GET_MSG_FLAGS command, used when an ATTN
 151          * is set to hold the flags until we are done handling everything
 152          * from the flags.
 153          */
 154 #define RECEIVE_MSG_AVAIL       0x01
 155 #define EVENT_MSG_BUFFER_FULL   0x02
 156 #define WDT_PRE_TIMEOUT_INT     0x08
 157 #define OEM0_DATA_AVAIL     0x20
 158 #define OEM1_DATA_AVAIL     0x40
 159 #define OEM2_DATA_AVAIL     0x80
 160 #define OEM_DATA_AVAIL      (OEM0_DATA_AVAIL | \
 161                              OEM1_DATA_AVAIL | \
 162                              OEM2_DATA_AVAIL)
 163         unsigned char       msg_flags;
 164
 165         /* Does the BMC have an event buffer? */
 166         bool                has_event_buffer;
 167
 168         /*
 169          * If set to true, this will request events the next time the
 170          * state machine is idle.
 171          */
 172         atomic_t            req_events;
 173
 174         /*
 175          * If true, run the state machine to completion on every send
 176          * call.  Generally used after a panic to make sure stuff goes
 177          * out.
 178          */
 179         bool                run_to_completion;
 180
 181         /* The timer for this si. */
 182         struct timer_list   si_timer;
 183
 184         /* This flag is set, if the timer can be set */
 185         bool                timer_can_start;
 186
 187         /* This flag is set, if the timer is running (timer_pending() isn't enough) */
 188         bool                timer_running;
 189
 190         /* The time (in jiffies) the last timeout occurred at. */
 191         unsigned long       last_timeout_jiffies;
 192
 193         /* Are we waiting for the events, pretimeouts, received msgs? */
 194         atomic_t            need_watch;
 195
 196         /*
 197          * The driver will disable interrupts when it gets into a
 198          * situation where it cannot handle messages due to lack of
 199          * memory.  Once that situation clears up, it will re-enable
 200          * interrupts.
 201          */
 202         bool interrupt_disabled;
 203
 204         /*
 205          * Does the BMC support events?
 206          */
 207         bool supports_event_msg_buff;
 208
 209         /*
 210          * Can we disable interrupts the global enables receive irq
 211          * bit?  There are currently two forms of brokenness, some
 212          * systems cannot disable the bit (which is technically within
 213          * the spec but a bad idea) and some systems have the bit
 214          * forced to zero even though interrupts work (which is
 215          * clearly outside the spec).  The next bool tells which form
 216          * of brokenness is present.
 217          */
 218         bool cannot_disable_irq;
 219
 220         /*
 221          * Some systems are broken and cannot set the irq enable
 222          * bit, even if they support interrupts.
 223          */
 224         bool irq_enable_broken;
 225
 226         /* Is the driver in maintenance mode? */
 227         bool in_maintenance_mode;
 228
 229         /*
 230          * Did we get an attention that we did not handle?
 231          */
 232         bool got_attn;
 233
 234         /* From the get device id response... */
 235         struct ipmi_device_id device_id;
 236
 237         /* Have we added the device group to the device? */
 238         bool dev_group_added;
 239
 240         /* Counters and things for the proc filesystem. */
 241         atomic_t stats[SI_NUM_STATS];
 242
 243         struct task_struct *thread;
 244
 245         struct list_head link;
 246 };
 247
 248 #define smi_inc_stat(smi, stat) \
 249         atomic_inc(&(smi)->stats[SI_STAT_ ## stat])
 250 #define smi_get_stat(smi, stat) \
 251         ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat]))
 252
 253 #define IPMI_MAX_INTFS 4
 254 static int force_kipmid[IPMI_MAX_INTFS];
 255 static int num_force_kipmid;
 256
 257 static unsigned int kipmid_max_busy_us[IPMI_MAX_INTFS];
 258 static int num_max_busy_us;
 259
 260 static bool unload_when_empty = true;
 261
 262 static int try_smi_init(struct smi_info *smi);
 263 static void cleanup_one_si(struct smi_info *smi_info);
 264 static void cleanup_ipmi_si(void);
 265
 266 #ifdef DEBUG_TIMING
 267 void debug_timestamp(struct smi_info *smi_info, char *msg)
 268 {
 269         struct timespec64 t;
 270
 271         ktime_get_ts64(&t);
 272         dev_dbg(smi_info->io.dev, "**%s: %lld.%9.9ld\n",
 273                 msg, t.tv_sec, t.tv_nsec);
 274 }
 275 #else
 276 #define debug_timestamp(smi_info, x)
 277 #endif
 278
 279 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
 280 static int register_xaction_notifier(struct notifier_block *nb)
 281 {
 282         return atomic_notifier_chain_register(&xaction_notifier_list, nb);
 283 }
 284
 285 static void deliver_recv_msg(struct smi_info *smi_info,
 286                              struct ipmi_smi_msg *msg)
 287 {
 288         /* Deliver the message to the upper layer. */
 289         ipmi_smi_msg_received(smi_info->intf, msg);
 290 }
 291
 292 static void return_hosed_msg(struct smi_info *smi_info, int cCode)
 293 {
 294         struct ipmi_smi_msg *msg = smi_info->curr_msg;
 295
 296         if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
 297                 cCode = IPMI_ERR_UNSPECIFIED;
 298         /* else use it as is */
 299
 300         /* Make it a response */
 301         msg->rsp[0] = msg->data[0] | 4;
 302         msg->rsp[1] = msg->data[1];
 303         msg->rsp[2] = cCode;
 304         msg->rsp_size = 3;
 305
 306         smi_info->curr_msg = NULL;
 307         deliver_recv_msg(smi_info, msg);
 308 }
 309
 310 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
 311 {
 312         int              rv;
 313
 314         if (!smi_info->waiting_msg) {
 315                 smi_info->curr_msg = NULL;
 316                 rv = SI_SM_IDLE;
 317         } else {
 318                 int err;
 319
 320                 smi_info->curr_msg = smi_info->waiting_msg;
 321                 smi_info->waiting_msg = NULL;
 322                 debug_timestamp(smi_info, "Start2");
 323                 err = atomic_notifier_call_chain(&xaction_notifier_list,
 324                                 0, smi_info);
 325                 if (err & NOTIFY_STOP_MASK) {
 326                         rv = SI_SM_CALL_WITHOUT_DELAY;
 327                         goto out;
 328                 }
 329                 err = smi_info->handlers->start_transaction(
 330                         smi_info->si_sm,
 331                         smi_info->curr_msg->data,
 332                         smi_info->curr_msg->data_size);
 333                 if (err)
 334                         return_hosed_msg(smi_info, err);
 335
 336                 rv = SI_SM_CALL_WITHOUT_DELAY;
 337         }
 338 out:
 339         return rv;
 340 }
 341
 342 static void smi_mod_timer(struct smi_info *smi_info, unsigned long new_val)
 343 {
 344         if (!smi_info->timer_can_start)
 345                 return;
 346         smi_info->last_timeout_jiffies = jiffies;
 347         mod_timer(&smi_info->si_timer, new_val);
 348         smi_info->timer_running = true;
 349 }
 350
 351 /*
 352  * Start a new message and (re)start the timer and thread.
 353  */
 354 static void start_new_msg(struct smi_info *smi_info, unsigned char *msg,
 355                           unsigned int size)
 356 {
 357         smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
 358
 359         if (smi_info->thread)
 360                 wake_up_process(smi_info->thread);
 361
 362         smi_info->handlers->start_transaction(smi_info->si_sm, msg, size);
 363 }
 364
 365 static void start_check_enables(struct smi_info *smi_info)
 366 {
 367         unsigned char msg[2];
 368
 369         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 370         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
 371
 372         start_new_msg(smi_info, msg, 2);
 373         smi_info->si_state = SI_CHECKING_ENABLES;
 374 }
 375
 376 static void start_clear_flags(struct smi_info *smi_info)
 377 {
 378         unsigned char msg[3];
 379
 380         /* Make sure the watchdog pre-timeout flag is not set at startup. */
 381         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 382         msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
 383         msg[2] = WDT_PRE_TIMEOUT_INT;
 384
 385         start_new_msg(smi_info, msg, 3);
 386         smi_info->si_state = SI_CLEARING_FLAGS;
 387 }
 388
 389 static void start_getting_msg_queue(struct smi_info *smi_info)
 390 {
 391         smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 392         smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
 393         smi_info->curr_msg->data_size = 2;
 394
 395         start_new_msg(smi_info, smi_info->curr_msg->data,
 396                       smi_info->curr_msg->data_size);
 397         smi_info->si_state = SI_GETTING_MESSAGES;
 398 }
 399
 400 static void start_getting_events(struct smi_info *smi_info)
 401 {
 402         smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 403         smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
 404         smi_info->curr_msg->data_size = 2;
 405
 406         start_new_msg(smi_info, smi_info->curr_msg->data,
 407                       smi_info->curr_msg->data_size);
 408         smi_info->si_state = SI_GETTING_EVENTS;
 409 }
 410
 411 /*
 412  * When we have a situtaion where we run out of memory and cannot
 413  * allocate messages, we just leave them in the BMC and run the system
 414  * polled until we can allocate some memory.  Once we have some
 415  * memory, we will re-enable the interrupt.
 416  *
 417  * Note that we cannot just use disable_irq(), since the interrupt may
 418  * be shared.
 419  */
 420 static inline bool disable_si_irq(struct smi_info *smi_info)
 421 {
 422         if ((smi_info->io.irq) && (!smi_info->interrupt_disabled)) {
 423                 smi_info->interrupt_disabled = true;
 424                 start_check_enables(smi_info);
 425                 return true;
 426         }
 427         return false;
 428 }
 429
 430 static inline bool enable_si_irq(struct smi_info *smi_info)
 431 {
 432         if ((smi_info->io.irq) && (smi_info->interrupt_disabled)) {
 433                 smi_info->interrupt_disabled = false;
 434                 start_check_enables(smi_info);
 435                 return true;
 436         }
 437         return false;
 438 }
 439
 440 /*
 441  * Allocate a message.  If unable to allocate, start the interrupt
 442  * disable process and return NULL.  If able to allocate but
 443  * interrupts are disabled, free the message and return NULL after
 444  * starting the interrupt enable process.
 445  */
 446 static struct ipmi_smi_msg *alloc_msg_handle_irq(struct smi_info *smi_info)
 447 {
 448         struct ipmi_smi_msg *msg;
 449
 450         msg = ipmi_alloc_smi_msg();
 451         if (!msg) {
 452                 if (!disable_si_irq(smi_info))
 453                         smi_info->si_state = SI_NORMAL;
 454         } else if (enable_si_irq(smi_info)) {
 455                 ipmi_free_smi_msg(msg);
 456                 msg = NULL;
 457         }
 458         return msg;
 459 }
 460
 461 static void handle_flags(struct smi_info *smi_info)
 462 {
 463 retry:
 464         if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
 465                 /* Watchdog pre-timeout */
 466                 smi_inc_stat(smi_info, watchdog_pretimeouts);
 467
 468                 start_clear_flags(smi_info);
 469                 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
 470                 ipmi_smi_watchdog_pretimeout(smi_info->intf);
 471         } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
 472                 /* Messages available. */
 473                 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
 474                 if (!smi_info->curr_msg)
 475                         return;
 476
 477                 start_getting_msg_queue(smi_info);
 478         } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
 479                 /* Events available. */
 480                 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
 481                 if (!smi_info->curr_msg)
 482                         return;
 483
 484                 start_getting_events(smi_info);
 485         } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
 486                    smi_info->oem_data_avail_handler) {
 487                 if (smi_info->oem_data_avail_handler(smi_info))
 488                         goto retry;
 489         } else
 490                 smi_info->si_state = SI_NORMAL;
 491 }
 492
 493 /*
 494  * Global enables we care about.
 495  */
 496 #define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \
 497                              IPMI_BMC_EVT_MSG_INTR)
 498
 499 static u8 current_global_enables(struct smi_info *smi_info, u8 base,
 500                                  bool *irq_on)
 501 {
 502         u8 enables = 0;
 503
 504         if (smi_info->supports_event_msg_buff)
 505                 enables |= IPMI_BMC_EVT_MSG_BUFF;
 506
 507         if (((smi_info->io.irq && !smi_info->interrupt_disabled) ||
 508              smi_info->cannot_disable_irq) &&
 509             !smi_info->irq_enable_broken)
 510                 enables |= IPMI_BMC_RCV_MSG_INTR;
 511
 512         if (smi_info->supports_event_msg_buff &&
 513             smi_info->io.irq && !smi_info->interrupt_disabled &&
 514             !smi_info->irq_enable_broken)
 515                 enables |= IPMI_BMC_EVT_MSG_INTR;
 516
 517         *irq_on = enables & (IPMI_BMC_EVT_MSG_INTR | IPMI_BMC_RCV_MSG_INTR);
 518
 519         return enables;
 520 }
 521
 522 static void check_bt_irq(struct smi_info *smi_info, bool irq_on)
 523 {
 524         u8 irqstate = smi_info->io.inputb(&smi_info->io, IPMI_BT_INTMASK_REG);
 525
 526         irqstate &= IPMI_BT_INTMASK_ENABLE_IRQ_BIT;
 527
 528         if ((bool)irqstate == irq_on)
 529                 return;
 530
 531         if (irq_on)
 532                 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
 533                                      IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
 534         else
 535                 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 0);
 536 }
 537
 538 static void handle_transaction_done(struct smi_info *smi_info)
 539 {
 540         struct ipmi_smi_msg *msg;
 541
 542         debug_timestamp(smi_info, "Done");
 543         switch (smi_info->si_state) {
 544         case SI_NORMAL:
 545                 if (!smi_info->curr_msg)
 546                         break;
 547
 548                 smi_info->curr_msg->rsp_size
 549                         = smi_info->handlers->get_result(
 550                                 smi_info->si_sm,
 551                                 smi_info->curr_msg->rsp,
 552                                 IPMI_MAX_MSG_LENGTH);
 553
 554                 /*
 555                  * Do this here becase deliver_recv_msg() releases the
 556                  * lock, and a new message can be put in during the
 557                  * time the lock is released.
 558                  */
 559                 msg = smi_info->curr_msg;
 560                 smi_info->curr_msg = NULL;
 561                 deliver_recv_msg(smi_info, msg);
 562                 break;
 563
 564         case SI_GETTING_FLAGS:
 565         {
 566                 unsigned char msg[4];
 567                 unsigned int  len;
 568
 569                 /* We got the flags from the SMI, now handle them. */
 570                 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 571                 if (msg[2] != 0) {
 572                         /* Error fetching flags, just give up for now. */
 573                         smi_info->si_state = SI_NORMAL;
 574                 } else if (len < 4) {
 575                         /*
 576                          * Hmm, no flags.  That's technically illegal, but
 577                          * don't use uninitialized data.
 578                          */
 579                         smi_info->si_state = SI_NORMAL;
 580                 } else {
 581                         smi_info->msg_flags = msg[3];
 582                         handle_flags(smi_info);
 583                 }
 584                 break;
 585         }
 586
 587         case SI_CLEARING_FLAGS:
 588         {
 589                 unsigned char msg[3];
 590
 591                 /* We cleared the flags. */
 592                 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
 593                 if (msg[2] != 0) {
 594                         /* Error clearing flags */
 595                         dev_warn_ratelimited(smi_info->io.dev,
 596                                  "Error clearing flags: %2.2x\n", msg[2]);
 597                 }
 598                 smi_info->si_state = SI_NORMAL;
 599                 break;
 600         }
 601
 602         case SI_GETTING_EVENTS:
 603         {
 604                 smi_info->curr_msg->rsp_size
 605                         = smi_info->handlers->get_result(
 606                                 smi_info->si_sm,
 607                                 smi_info->curr_msg->rsp,
 608                                 IPMI_MAX_MSG_LENGTH);
 609
 610                 /*
 611                  * Do this here becase deliver_recv_msg() releases the
 612                  * lock, and a new message can be put in during the
 613                  * time the lock is released.
 614                  */
 615                 msg = smi_info->curr_msg;
 616                 smi_info->curr_msg = NULL;
 617                 if (msg->rsp[2] != 0) {
 618                         /* Error getting event, probably done. */
 619                         msg->done(msg);
 620
 621                         /* Take off the event flag. */
 622                         smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
 623                         handle_flags(smi_info);
 624                 } else {
 625                         smi_inc_stat(smi_info, events);
 626
 627                         /*
 628                          * Do this before we deliver the message
 629                          * because delivering the message releases the
 630                          * lock and something else can mess with the
 631                          * state.
 632                          */
 633                         handle_flags(smi_info);
 634
 635                         deliver_recv_msg(smi_info, msg);
 636                 }
 637                 break;
 638         }
 639
 640         case SI_GETTING_MESSAGES:
 641         {
 642                 smi_info->curr_msg->rsp_size
 643                         = smi_info->handlers->get_result(
 644                                 smi_info->si_sm,
 645                                 smi_info->curr_msg->rsp,
 646                                 IPMI_MAX_MSG_LENGTH);
 647
 648                 /*
 649                  * Do this here becase deliver_recv_msg() releases the
 650                  * lock, and a new message can be put in during the
 651                  * time the lock is released.
 652                  */
 653                 msg = smi_info->curr_msg;
 654                 smi_info->curr_msg = NULL;
 655                 if (msg->rsp[2] != 0) {
 656                         /* Error getting event, probably done. */
 657                         msg->done(msg);
 658
 659                         /* Take off the msg flag. */
 660                         smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
 661                         handle_flags(smi_info);
 662                 } else {
 663                         smi_inc_stat(smi_info, incoming_messages);
 664
 665                         /*
 666                          * Do this before we deliver the message
 667                          * because delivering the message releases the
 668                          * lock and something else can mess with the
 669                          * state.
 670                          */
 671                         handle_flags(smi_info);
 672
 673                         deliver_recv_msg(smi_info, msg);
 674                 }
 675                 break;
 676         }
 677
 678         case SI_CHECKING_ENABLES:
 679         {
 680                 unsigned char msg[4];
 681                 u8 enables;
 682                 bool irq_on;
 683
 684                 /* We got the flags from the SMI, now handle them. */
 685                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 686                 if (msg[2] != 0) {
 687                         dev_warn_ratelimited(smi_info->io.dev,
 688                                 "Couldn't get irq info: %x,\n"
 689                                 "Maybe ok, but ipmi might run very slowly.\n",
 690                                 msg[2]);
 691                         smi_info->si_state = SI_NORMAL;
 692                         break;
 693                 }
 694                 enables = current_global_enables(smi_info, 0, &irq_on);
 695                 if (smi_info->io.si_type == SI_BT)
 696                         /* BT has its own interrupt enable bit. */
 697                         check_bt_irq(smi_info, irq_on);
 698                 if (enables != (msg[3] & GLOBAL_ENABLES_MASK)) {
 699                         /* Enables are not correct, fix them. */
 700                         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 701                         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
 702                         msg[2] = enables | (msg[3] & ~GLOBAL_ENABLES_MASK);
 703                         smi_info->handlers->start_transaction(
 704                                 smi_info->si_sm, msg, 3);
 705                         smi_info->si_state = SI_SETTING_ENABLES;
 706                 } else if (smi_info->supports_event_msg_buff) {
 707                         smi_info->curr_msg = ipmi_alloc_smi_msg();
 708                         if (!smi_info->curr_msg) {
 709                                 smi_info->si_state = SI_NORMAL;
 710                                 break;
 711                         }
 712                         start_getting_events(smi_info);
 713                 } else {
 714                         smi_info->si_state = SI_NORMAL;
 715                 }
 716                 break;
 717         }
 718
 719         case SI_SETTING_ENABLES:
 720         {
 721                 unsigned char msg[4];
 722
 723                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 724                 if (msg[2] != 0)
 725                         dev_warn_ratelimited(smi_info->io.dev,
 726                                  "Could not set the global enables: 0x%x.\n",
 727                                  msg[2]);
 728
 729                 if (smi_info->supports_event_msg_buff) {
 730                         smi_info->curr_msg = ipmi_alloc_smi_msg();
 731                         if (!smi_info->curr_msg) {
 732                                 smi_info->si_state = SI_NORMAL;
 733                                 break;
 734                         }
 735                         start_getting_events(smi_info);
 736                 } else {
 737                         smi_info->si_state = SI_NORMAL;
 738                 }
 739                 break;
 740         }
 741         }
 742 }
 743
 744 /*
 745  * Called on timeouts and events.  Timeouts should pass the elapsed
 746  * time, interrupts should pass in zero.  Must be called with
 747  * si_lock held and interrupts disabled.
 748  */
 749 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
 750                                            int time)
 751 {
 752         enum si_sm_result si_sm_result;
 753
 754 restart:
 755         /*
 756          * There used to be a loop here that waited a little while
 757          * (around 25us) before giving up.  That turned out to be
 758          * pointless, the minimum delays I was seeing were in the 300us
 759          * range, which is far too long to wait in an interrupt.  So
 760          * we just run until the state machine tells us something
 761          * happened or it needs a delay.
 762          */
 763         si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
 764         time = 0;
 765         while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
 766                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
 767
 768         if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
 769                 smi_inc_stat(smi_info, complete_transactions);
 770
 771                 handle_transaction_done(smi_info);
 772                 goto restart;
 773         } else if (si_sm_result == SI_SM_HOSED) {
 774                 smi_inc_stat(smi_info, hosed_count);
 775
 776                 /*
 777                  * Do the before return_hosed_msg, because that
 778                  * releases the lock.
 779                  */
 780                 smi_info->si_state = SI_NORMAL;
 781                 if (smi_info->curr_msg != NULL) {
 782                         /*
 783                          * If we were handling a user message, format
 784                          * a response to send to the upper layer to
 785                          * tell it about the error.
 786                          */
 787                         return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
 788                 }
 789                 goto restart;
 790         }
 791
 792         /*
 793          * We prefer handling attn over new messages.  But don't do
 794          * this if there is not yet an upper layer to handle anything.
 795          */
 796         if (si_sm_result == SI_SM_ATTN || smi_info->got_attn) {
 797                 unsigned char msg[2];
 798
 799                 if (smi_info->si_state != SI_NORMAL) {
 800                         /*
 801                          * We got an ATTN, but we are doing something else.
 802                          * Handle the ATTN later.
 803                          */
 804                         smi_info->got_attn = true;
 805                 } else {
 806                         smi_info->got_attn = false;
 807                         smi_inc_stat(smi_info, attentions);
 808
 809                         /*
 810                          * Got a attn, send down a get message flags to see
 811                          * what's causing it.  It would be better to handle
 812                          * this in the upper layer, but due to the way
 813                          * interrupts work with the SMI, that's not really
 814                          * possible.
 815                          */
 816                         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 817                         msg[1] = IPMI_GET_MSG_FLAGS_CMD;
 818
 819                         start_new_msg(smi_info, msg, 2);
 820                         smi_info->si_state = SI_GETTING_FLAGS;
 821                         goto restart;
 822                 }
 823         }
 824
 825         /* If we are currently idle, try to start the next message. */
 826         if (si_sm_result == SI_SM_IDLE) {
 827                 smi_inc_stat(smi_info, idles);
 828
 829                 si_sm_result = start_next_msg(smi_info);
 830                 if (si_sm_result != SI_SM_IDLE)
 831                         goto restart;
 832         }
 833
 834         if ((si_sm_result == SI_SM_IDLE)
 835             && (atomic_read(&smi_info->req_events))) {
 836                 /*
 837                  * We are idle and the upper layer requested that I fetch
 838                  * events, so do so.
 839                  */
 840                 atomic_set(&smi_info->req_events, 0);
 841
 842                 /*
 843                  * Take this opportunity to check the interrupt and
 844                  * message enable state for the BMC.  The BMC can be
 845                  * asynchronously reset, and may thus get interrupts
 846                  * disable and messages disabled.
 847                  */
 848                 if (smi_info->supports_event_msg_buff || smi_info->io.irq) {
 849                         start_check_enables(smi_info);
 850                 } else {
 851                         smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
 852                         if (!smi_info->curr_msg)
 853                                 goto out;
 854
 855                         start_getting_events(smi_info);
 856                 }
 857                 goto restart;
 858         }
 859
 860         if (si_sm_result == SI_SM_IDLE && smi_info->timer_running) {
 861                 /* Ok it if fails, the timer will just go off. */
 862                 if (del_timer(&smi_info->si_timer))
 863                         smi_info->timer_running = false;
 864         }
 865
 866 out:
 867         return si_sm_result;
 868 }
 869
 870 static void check_start_timer_thread(struct smi_info *smi_info)
 871 {
 872         if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) {
 873                 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
 874
 875                 if (smi_info->thread)
 876                         wake_up_process(smi_info->thread);
 877
 878                 start_next_msg(smi_info);
 879                 smi_event_handler(smi_info, 0);
 880         }
 881 }
 882
 883 static void flush_messages(void *send_info)
 884 {
 885         struct smi_info *smi_info = send_info;
 886         enum si_sm_result result;
 887
 888         /*
 889          * Currently, this function is called only in run-to-completion
 890          * mode.  This means we are single-threaded, no need for locks.
 891          */
 892         result = smi_event_handler(smi_info, 0);
 893         while (result != SI_SM_IDLE) {
 894                 udelay(SI_SHORT_TIMEOUT_USEC);
 895                 result = smi_event_handler(smi_info, SI_SHORT_TIMEOUT_USEC);
 896         }
 897 }
 898
 899 static void sender(void                *send_info,
 900                    struct ipmi_smi_msg *msg)
 901 {
 902         struct smi_info   *smi_info = send_info;
 903         unsigned long     flags;
 904
 905         debug_timestamp(smi_info, "Enqueue");
 906
 907         if (smi_info->run_to_completion) {
 908                 /*
 909                  * If we are running to completion, start it.  Upper
 910                  * layer will call flush_messages to clear it out.
 911                  */
 912                 smi_info->waiting_msg = msg;
 913                 return;
 914         }
 915
 916         spin_lock_irqsave(&smi_info->si_lock, flags);
 917         /*
 918          * The following two lines don't need to be under the lock for
 919          * the lock's sake, but they do need SMP memory barriers to
 920          * avoid getting things out of order.  We are already claiming
 921          * the lock, anyway, so just do it under the lock to avoid the
 922          * ordering problem.
 923          */
 924         BUG_ON(smi_info->waiting_msg);
 925         smi_info->waiting_msg = msg;
 926         check_start_timer_thread(smi_info);
 927         spin_unlock_irqrestore(&smi_info->si_lock, flags);
 928 }
 929
 930 static void set_run_to_completion(void *send_info, bool i_run_to_completion)
 931 {
 932         struct smi_info   *smi_info = send_info;
 933
 934         smi_info->run_to_completion = i_run_to_completion;
 935         if (i_run_to_completion)
 936                 flush_messages(smi_info);
 937 }
 938
 939 /*
 940  * Use -1 as a special constant to tell that we are spinning in kipmid
 941  * looking for something and not delaying between checks
 942  */
 943 #define IPMI_TIME_NOT_BUSY ns_to_ktime(-1ull)
 944 static inline bool ipmi_thread_busy_wait(enum si_sm_result smi_result,
 945                                          const struct smi_info *smi_info,
 946                                          ktime_t *busy_until)
 947 {
 948         unsigned int max_busy_us = 0;
 949
 950         if (smi_info->si_num < num_max_busy_us)
 951                 max_busy_us = kipmid_max_busy_us[smi_info->si_num];
 952         if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
 953                 *busy_until = IPMI_TIME_NOT_BUSY;
 954         else if (*busy_until == IPMI_TIME_NOT_BUSY) {
 955                 *busy_until = ktime_get() + max_busy_us * NSEC_PER_USEC;
 956         } else {
 957                 if (unlikely(ktime_get() > *busy_until)) {
 958                         *busy_until = IPMI_TIME_NOT_BUSY;
 959                         return false;
 960                 }
 961         }
 962         return true;
 963 }
 964
 965
 966 /*
 967  * A busy-waiting loop for speeding up IPMI operation.
 968  *
 969  * Lousy hardware makes this hard.  This is only enabled for systems
 970  * that are not BT and do not have interrupts.  It starts spinning
 971  * when an operation is complete or until max_busy tells it to stop
 972  * (if that is enabled).  See the paragraph on kimid_max_busy_us in
 973  * Documentation/driver-api/ipmi.rst for details.
 974  */
 975 static int ipmi_thread(void *data)
 976 {
 977         struct smi_info *smi_info = data;
 978         unsigned long flags;
 979         enum si_sm_result smi_result;
 980         ktime_t busy_until = IPMI_TIME_NOT_BUSY;
 981
 982         set_user_nice(current, MAX_NICE);
 983         while (!kthread_should_stop()) {
 984                 int busy_wait;
 985
 986                 spin_lock_irqsave(&(smi_info->si_lock), flags);
 987                 smi_result = smi_event_handler(smi_info, 0);
 988
 989                 /*
 990                  * If the driver is doing something, there is a possible
 991                  * race with the timer.  If the timer handler see idle,
 992                  * and the thread here sees something else, the timer
 993                  * handler won't restart the timer even though it is
 994                  * required.  So start it here if necessary.
 995                  */
 996                 if (smi_result != SI_SM_IDLE && !smi_info->timer_running)
 997                         smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
 998
 999                 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1000                 busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
1001                                                   &busy_until);
1002                 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
1003                         ; /* do nothing */
1004                 } else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait) {
1005                         /*
1006                          * In maintenance mode we run as fast as
1007                          * possible to allow firmware updates to
1008                          * complete as fast as possible, but normally
1009                          * don't bang on the scheduler.
1010                          */
1011                         if (smi_info->in_maintenance_mode)
1012                                 schedule();
1013                         else
1014                                 usleep_range(100, 200);
1015                 } else if (smi_result == SI_SM_IDLE) {
1016                         if (atomic_read(&smi_info->need_watch)) {
1017                                 schedule_timeout_interruptible(100);
1018                         } else {
1019                                 /* Wait to be woken up when we are needed. */
1020                                 __set_current_state(TASK_INTERRUPTIBLE);
1021                                 schedule();
1022                         }
1023                 } else {
1024                         schedule_timeout_interruptible(1);
1025                 }
1026         }
1027         return 0;
1028 }
1029
1030
1031 static void poll(void *send_info)
1032 {
1033         struct smi_info *smi_info = send_info;
1034         unsigned long flags = 0;
1035         bool run_to_completion = smi_info->run_to_completion;
1036
1037         /*
1038          * Make sure there is some delay in the poll loop so we can
1039          * drive time forward and timeout things.
1040          */
1041         udelay(10);
1042         if (!run_to_completion)
1043                 spin_lock_irqsave(&smi_info->si_lock, flags);
1044         smi_event_handler(smi_info, 10);
1045         if (!run_to_completion)
1046                 spin_unlock_irqrestore(&smi_info->si_lock, flags);
1047 }
1048
1049 static void request_events(void *send_info)
1050 {
1051         struct smi_info *smi_info = send_info;
1052
1053         if (!smi_info->has_event_buffer)
1054                 return;
1055
1056         atomic_set(&smi_info->req_events, 1);
1057 }
1058
1059 static void set_need_watch(void *send_info, unsigned int watch_mask)
1060 {
1061         struct smi_info *smi_info = send_info;
1062         unsigned long flags;
1063         int enable;
1064
1065         enable = !!watch_mask;
1066
1067         atomic_set(&smi_info->need_watch, enable);
1068         spin_lock_irqsave(&smi_info->si_lock, flags);
1069         check_start_timer_thread(smi_info);
1070         spin_unlock_irqrestore(&smi_info->si_lock, flags);
1071 }
1072
1073 static void smi_timeout(struct timer_list *t)
1074 {
1075         struct smi_info   *smi_info = from_timer(smi_info, t, si_timer);
1076         enum si_sm_result smi_result;
1077         unsigned long     flags;
1078         unsigned long     jiffies_now;
1079         long              time_diff;
1080         long              timeout;
1081
1082         spin_lock_irqsave(&(smi_info->si_lock), flags);
1083         debug_timestamp(smi_info, "Timer");
1084
1085         jiffies_now = jiffies;
1086         time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
1087                      * SI_USEC_PER_JIFFY);
1088         smi_result = smi_event_handler(smi_info, time_diff);
1089
1090         if ((smi_info->io.irq) && (!smi_info->interrupt_disabled)) {
1091                 /* Running with interrupts, only do long timeouts. */
1092                 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1093                 smi_inc_stat(smi_info, long_timeouts);
1094                 goto do_mod_timer;
1095         }
1096
1097         /*
1098          * If the state machine asks for a short delay, then shorten
1099          * the timer timeout.
1100          */
1101         if (smi_result == SI_SM_CALL_WITH_DELAY) {
1102                 smi_inc_stat(smi_info, short_timeouts);
1103                 timeout = jiffies + 1;
1104         } else {
1105                 smi_inc_stat(smi_info, long_timeouts);
1106                 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1107         }
1108
1109 do_mod_timer:
1110         if (smi_result != SI_SM_IDLE)
1111                 smi_mod_timer(smi_info, timeout);
1112         else
1113                 smi_info->timer_running = false;
1114         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1115 }
1116
1117 irqreturn_t ipmi_si_irq_handler(int irq, void *data)
1118 {
1119         struct smi_info *smi_info = data;
1120         unsigned long   flags;
1121
1122         if (smi_info->io.si_type == SI_BT)
1123                 /* We need to clear the IRQ flag for the BT interface. */
1124                 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
1125                                      IPMI_BT_INTMASK_CLEAR_IRQ_BIT
1126                                      | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1127
1128         spin_lock_irqsave(&(smi_info->si_lock), flags);
1129
1130         smi_inc_stat(smi_info, interrupts);
1131
1132         debug_timestamp(smi_info, "Interrupt");
1133
1134         smi_event_handler(smi_info, 0);
1135         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1136         return IRQ_HANDLED;
1137 }
1138
1139 static int smi_start_processing(void            *send_info,
1140                                 struct ipmi_smi *intf)
1141 {
1142         struct smi_info *new_smi = send_info;
1143         int             enable = 0;
1144
1145         new_smi->intf = intf;
1146
1147         /* Set up the timer that drives the interface. */
1148         timer_setup(&new_smi->si_timer, smi_timeout, 0);
1149         new_smi->timer_can_start = true;
1150         smi_mod_timer(new_smi, jiffies + SI_TIMEOUT_JIFFIES);
1151
1152         /* Try to claim any interrupts. */
1153         if (new_smi->io.irq_setup) {
1154                 new_smi->io.irq_handler_data = new_smi;
1155                 new_smi->io.irq_setup(&new_smi->io);
1156         }
1157
1158         /*
1159          * Check if the user forcefully enabled the daemon.
1160          */
1161         if (new_smi->si_num < num_force_kipmid)
1162                 enable = force_kipmid[new_smi->si_num];
1163         /*
1164          * The BT interface is efficient enough to not need a thread,
1165          * and there is no need for a thread if we have interrupts.
1166          */
1167         else if ((new_smi->io.si_type != SI_BT) && (!new_smi->io.irq))
1168                 enable = 1;
1169
1170         if (enable) {
1171                 new_smi->thread = kthread_run(ipmi_thread, new_smi,
1172                                               "kipmi%d", new_smi->si_num);
1173                 if (IS_ERR(new_smi->thread)) {
1174                         dev_notice(new_smi->io.dev,
1175                                    "Could not start kernel thread due to error %ld, only using timers to drive the interface\n",
1176                                    PTR_ERR(new_smi->thread));
1177                         new_smi->thread = NULL;
1178                 }
1179         }
1180
1181         return 0;
1182 }
1183
1184 static int get_smi_info(void *send_info, struct ipmi_smi_info *data)
1185 {
1186         struct smi_info *smi = send_info;
1187
1188         data->addr_src = smi->io.addr_source;
1189         data->dev = smi->io.dev;
1190         data->addr_info = smi->io.addr_info;
1191         get_device(smi->io.dev);
1192
1193         return 0;
1194 }
1195
1196 static void set_maintenance_mode(void *send_info, bool enable)
1197 {
1198         struct smi_info   *smi_info = send_info;
1199
1200         if (!enable)
1201                 atomic_set(&smi_info->req_events, 0);
1202         smi_info->in_maintenance_mode = enable;
1203 }
1204
1205 static void shutdown_smi(void *send_info);
1206 static const struct ipmi_smi_handlers handlers = {
1207         .owner                  = THIS_MODULE,
1208         .start_processing       = smi_start_processing,
1209         .shutdown               = shutdown_smi,
1210         .get_smi_info           = get_smi_info,
1211         .sender                 = sender,
1212         .request_events         = request_events,
1213         .set_need_watch         = set_need_watch,
1214         .set_maintenance_mode   = set_maintenance_mode,
1215         .set_run_to_completion  = set_run_to_completion,
1216         .flush_messages         = flush_messages,
1217         .poll                   = poll,
1218 };
1219
1220 static LIST_HEAD(smi_infos);
1221 static DEFINE_MUTEX(smi_infos_lock);
1222 static int smi_num; /* Used to sequence the SMIs */
1223
1224 static const char * const addr_space_to_str[] = { "i/o", "mem" };
1225
1226 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1227 MODULE_PARM_DESC(force_kipmid,
1228                  "Force the kipmi daemon to be enabled (1) or disabled(0).  Normally the IPMI driver auto-detects this, but the value may be overridden by this parm.");
1229 module_param(unload_when_empty, bool, 0);
1230 MODULE_PARM_DESC(unload_when_empty,
1231                  "Unload the module if no interfaces are specified or found, default is 1.  Setting to 0 is useful for hot add of devices using hotmod.");
1232 module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
1233 MODULE_PARM_DESC(kipmid_max_busy_us,
1234                  "Max time (in microseconds) to busy-wait for IPMI data before sleeping. 0 (default) means to wait forever. Set to 100-500 if kipmid is using up a lot of CPU time.");
1235
1236 void ipmi_irq_finish_setup(struct si_sm_io *io)
1237 {
1238         if (io->si_type == SI_BT)
1239                 /* Enable the interrupt in the BT interface. */
1240                 io->outputb(io, IPMI_BT_INTMASK_REG,
1241                             IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1242 }
1243
1244 void ipmi_irq_start_cleanup(struct si_sm_io *io)
1245 {
1246         if (io->si_type == SI_BT)
1247                 /* Disable the interrupt in the BT interface. */
1248                 io->outputb(io, IPMI_BT_INTMASK_REG, 0);
1249 }
1250
1251 static void std_irq_cleanup(struct si_sm_io *io)
1252 {
1253         ipmi_irq_start_cleanup(io);
1254         free_irq(io->irq, io->irq_handler_data);
1255 }
1256
1257 int ipmi_std_irq_setup(struct si_sm_io *io)
1258 {
1259         int rv;
1260
1261         if (!io->irq)
1262                 return 0;
1263
1264         rv = request_irq(io->irq,
1265                          ipmi_si_irq_handler,
1266                          IRQF_SHARED,
1267                          SI_DEVICE_NAME,
1268                          io->irq_handler_data);
1269         if (rv) {
1270                 dev_warn(io->dev, "%s unable to claim interrupt %d, running polled\n",
1271                          SI_DEVICE_NAME, io->irq);
1272                 io->irq = 0;
1273         } else {
1274                 io->irq_cleanup = std_irq_cleanup;
1275                 ipmi_irq_finish_setup(io);
1276                 dev_info(io->dev, "Using irq %d\n", io->irq);
1277         }
1278
1279         return rv;
1280 }
1281
1282 static int wait_for_msg_done(struct smi_info *smi_info)
1283 {
1284         enum si_sm_result     smi_result;
1285
1286         smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1287         for (;;) {
1288                 if (smi_result == SI_SM_CALL_WITH_DELAY ||
1289                     smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1290                         schedule_timeout_uninterruptible(1);
1291                         smi_result = smi_info->handlers->event(
1292                                 smi_info->si_sm, jiffies_to_usecs(1));
1293                 } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
1294                         smi_result = smi_info->handlers->event(
1295                                 smi_info->si_sm, 0);
1296                 } else
1297                         break;
1298         }
1299         if (smi_result == SI_SM_HOSED)
1300                 /*
1301                  * We couldn't get the state machine to run, so whatever's at
1302                  * the port is probably not an IPMI SMI interface.
1303                  */
1304                 return -ENODEV;
1305
1306         return 0;
1307 }
1308
1309 static int try_get_dev_id(struct smi_info *smi_info)
1310 {
1311         unsigned char         msg[2];
1312         unsigned char         *resp;
1313         unsigned long         resp_len;
1314         int                   rv = 0;
1315         unsigned int          retry_count = 0;
1316
1317         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1318         if (!resp)
1319                 return -ENOMEM;
1320
1321         /*
1322          * Do a Get Device ID command, since it comes back with some
1323          * useful info.
1324          */
1325         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1326         msg[1] = IPMI_GET_DEVICE_ID_CMD;
1327
1328 retry:
1329         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1330
1331         rv = wait_for_msg_done(smi_info);
1332         if (rv)
1333                 goto out;
1334
1335         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1336                                                   resp, IPMI_MAX_MSG_LENGTH);
1337
1338         /* Check and record info from the get device id, in case we need it. */
1339         rv = ipmi_demangle_device_id(resp[0] >> 2, resp[1],
1340                         resp + 2, resp_len - 2, &smi_info->device_id);
1341         if (rv) {
1342                 /* record completion code */
1343                 unsigned char cc = *(resp + 2);
1344
1345                 if (cc != IPMI_CC_NO_ERROR &&
1346                     ++retry_count <= GET_DEVICE_ID_MAX_RETRY) {
1347                         dev_warn_ratelimited(smi_info->io.dev,
1348                             "BMC returned 0x%2.2x, retry get bmc device id\n",
1349                             cc);
1350                         goto retry;
1351                 }
1352         }
1353
1354 out:
1355         kfree(resp);
1356         return rv;
1357 }
1358
1359 static int get_global_enables(struct smi_info *smi_info, u8 *enables)
1360 {
1361         unsigned char         msg[3];
1362         unsigned char         *resp;
1363         unsigned long         resp_len;
1364         int                   rv;
1365
1366         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1367         if (!resp)
1368                 return -ENOMEM;
1369
1370         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1371         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
1372         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1373
1374         rv = wait_for_msg_done(smi_info);
1375         if (rv) {
1376                 dev_warn(smi_info->io.dev,
1377                          "Error getting response from get global enables command: %d\n",
1378                          rv);
1379                 goto out;
1380         }
1381
1382         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1383                                                   resp, IPMI_MAX_MSG_LENGTH);
1384
1385         if (resp_len < 4 ||
1386                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1387                         resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD   ||
1388                         resp[2] != 0) {
1389                 dev_warn(smi_info->io.dev,
1390                          "Invalid return from get global enables command: %ld %x %x %x\n",
1391                          resp_len, resp[0], resp[1], resp[2]);
1392                 rv = -EINVAL;
1393                 goto out;
1394         } else {
1395                 *enables = resp[3];
1396         }
1397
1398 out:
1399         kfree(resp);
1400         return rv;
1401 }
1402
1403 /*
1404  * Returns 1 if it gets an error from the command.
1405  */
1406 static int set_global_enables(struct smi_info *smi_info, u8 enables)
1407 {
1408         unsigned char         msg[3];
1409         unsigned char         *resp;
1410         unsigned long         resp_len;
1411         int                   rv;
1412
1413         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1414         if (!resp)
1415                 return -ENOMEM;
1416
1417         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1418         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
1419         msg[2] = enables;
1420         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
1421
1422         rv = wait_for_msg_done(smi_info);
1423         if (rv) {
1424                 dev_warn(smi_info->io.dev,
1425                          "Error getting response from set global enables command: %d\n",
1426                          rv);
1427                 goto out;
1428         }
1429
1430         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1431                                                   resp, IPMI_MAX_MSG_LENGTH);
1432
1433         if (resp_len < 3 ||
1434                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1435                         resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
1436                 dev_warn(smi_info->io.dev,
1437                          "Invalid return from set global enables command: %ld %x %x\n",
1438                          resp_len, resp[0], resp[1]);
1439                 rv = -EINVAL;
1440                 goto out;
1441         }
1442
1443         if (resp[2] != 0)
1444                 rv = 1;
1445
1446 out:
1447         kfree(resp);
1448         return rv;
1449 }
1450
1451 /*
1452  * Some BMCs do not support clearing the receive irq bit in the global
1453  * enables (even if they don't support interrupts on the BMC).  Check
1454  * for this and handle it properly.
1455  */
1456 static void check_clr_rcv_irq(struct smi_info *smi_info)
1457 {
1458         u8 enables = 0;
1459         int rv;
1460
1461         rv = get_global_enables(smi_info, &enables);
1462         if (!rv) {
1463                 if ((enables & IPMI_BMC_RCV_MSG_INTR) == 0)
1464                         /* Already clear, should work ok. */
1465                         return;
1466
1467                 enables &= ~IPMI_BMC_RCV_MSG_INTR;
1468                 rv = set_global_enables(smi_info, enables);
1469         }
1470
1471         if (rv < 0) {
1472                 dev_err(smi_info->io.dev,
1473                         "Cannot check clearing the rcv irq: %d\n", rv);
1474                 return;
1475         }
1476
1477         if (rv) {
1478                 /*
1479                  * An error when setting the event buffer bit means
1480                  * clearing the bit is not supported.
1481                  */
1482                 dev_warn(smi_info->io.dev,
1483                          "The BMC does not support clearing the recv irq bit, compensating, but the BMC needs to be fixed.\n");
1484                 smi_info->cannot_disable_irq = true;
1485         }
1486 }
1487
1488 /*
1489  * Some BMCs do not support setting the interrupt bits in the global
1490  * enables even if they support interrupts.  Clearly bad, but we can
1491  * compensate.
1492  */
1493 static void check_set_rcv_irq(struct smi_info *smi_info)
1494 {
1495         u8 enables = 0;
1496         int rv;
1497
1498         if (!smi_info->io.irq)
1499                 return;
1500
1501         rv = get_global_enables(smi_info, &enables);
1502         if (!rv) {
1503                 enables |= IPMI_BMC_RCV_MSG_INTR;
1504                 rv = set_global_enables(smi_info, enables);
1505         }
1506
1507         if (rv < 0) {
1508                 dev_err(smi_info->io.dev,
1509                         "Cannot check setting the rcv irq: %d\n", rv);
1510                 return;
1511         }
1512
1513         if (rv) {
1514                 /*
1515                  * An error when setting the event buffer bit means
1516                  * setting the bit is not supported.
1517                  */
1518                 dev_warn(smi_info->io.dev,
1519                          "The BMC does not support setting the recv irq bit, compensating, but the BMC needs to be fixed.\n");
1520                 smi_info->cannot_disable_irq = true;
1521                 smi_info->irq_enable_broken = true;
1522         }
1523 }
1524
1525 static int try_enable_event_buffer(struct smi_info *smi_info)
1526 {
1527         unsigned char         msg[3];
1528         unsigned char         *resp;
1529         unsigned long         resp_len;
1530         int                   rv = 0;
1531
1532         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1533         if (!resp)
1534                 return -ENOMEM;
1535
1536         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1537         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
1538         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1539
1540         rv = wait_for_msg_done(smi_info);
1541         if (rv) {
1542                 pr_warn("Error getting response from get global enables command, the event buffer is not enabled\n");
1543                 goto out;
1544         }
1545
1546         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1547                                                   resp, IPMI_MAX_MSG_LENGTH);
1548
1549         if (resp_len < 4 ||
1550                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1551                         resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD   ||
1552                         resp[2] != 0) {
1553                 pr_warn("Invalid return from get global enables command, cannot enable the event buffer\n");
1554                 rv = -EINVAL;
1555                 goto out;
1556         }
1557
1558         if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) {
1559                 /* buffer is already enabled, nothing to do. */
1560                 smi_info->supports_event_msg_buff = true;
1561                 goto out;
1562         }
1563
1564         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1565         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
1566         msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF;
1567         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
1568
1569         rv = wait_for_msg_done(smi_info);
1570         if (rv) {
1571                 pr_warn("Error getting response from set global, enables command, the event buffer is not enabled\n");
1572                 goto out;
1573         }
1574
1575         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1576                                                   resp, IPMI_MAX_MSG_LENGTH);
1577
1578         if (resp_len < 3 ||
1579                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1580                         resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
1581                 pr_warn("Invalid return from get global, enables command, not enable the event buffer\n");
1582                 rv = -EINVAL;
1583                 goto out;
1584         }
1585
1586         if (resp[2] != 0)
1587                 /*
1588                  * An error when setting the event buffer bit means
1589                  * that the event buffer is not supported.
1590                  */
1591                 rv = -ENOENT;
1592         else
1593                 smi_info->supports_event_msg_buff = true;
1594
1595 out:
1596         kfree(resp);
1597         return rv;
1598 }
1599
1600 #define IPMI_SI_ATTR(name) \
1601 static ssize_t name##_show(struct device *dev,                  \
1602                            struct device_attribute *attr,               \
1603                            char *buf)                                   \
1604 {                                                                       \
1605         struct smi_info *smi_info = dev_get_drvdata(dev);               \
1606                                                                         \
1607         return sysfs_emit(buf, "%u\n", smi_get_stat(smi_info, name));   \
1608 }                                                                       \
1609 static DEVICE_ATTR_RO(name)
1610
1611 static ssize_t type_show(struct device *dev,
1612                          struct device_attribute *attr,
1613                          char *buf)
1614 {
1615         struct smi_info *smi_info = dev_get_drvdata(dev);
1616
1617         return sysfs_emit(buf, "%s\n", si_to_str[smi_info->io.si_type]);
1618 }
1619 static DEVICE_ATTR_RO(type);
1620
1621 static ssize_t interrupts_enabled_show(struct device *dev,
1622                                        struct device_attribute *attr,
1623                                        char *buf)
1624 {
1625         struct smi_info *smi_info = dev_get_drvdata(dev);
1626         int enabled = smi_info->io.irq && !smi_info->interrupt_disabled;
1627
1628         return sysfs_emit(buf, "%d\n", enabled);
1629 }
1630 static DEVICE_ATTR_RO(interrupts_enabled);
1631
1632 IPMI_SI_ATTR(short_timeouts);
1633 IPMI_SI_ATTR(long_timeouts);
1634 IPMI_SI_ATTR(idles);
1635 IPMI_SI_ATTR(interrupts);
1636 IPMI_SI_ATTR(attentions);
1637 IPMI_SI_ATTR(flag_fetches);
1638 IPMI_SI_ATTR(hosed_count);
1639 IPMI_SI_ATTR(complete_transactions);
1640 IPMI_SI_ATTR(events);
1641 IPMI_SI_ATTR(watchdog_pretimeouts);
1642 IPMI_SI_ATTR(incoming_messages);
1643
1644 static ssize_t params_show(struct device *dev,
1645                            struct device_attribute *attr,
1646                            char *buf)
1647 {
1648         struct smi_info *smi_info = dev_get_drvdata(dev);
1649
1650         return sysfs_emit(buf,
1651                         "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
1652                         si_to_str[smi_info->io.si_type],
1653                         addr_space_to_str[smi_info->io.addr_space],
1654                         smi_info->io.addr_data,
1655                         smi_info->io.regspacing,
1656                         smi_info->io.regsize,
1657                         smi_info->io.regshift,
1658                         smi_info->io.irq,
1659                         smi_info->io.slave_addr);
1660 }
1661 static DEVICE_ATTR_RO(params);
1662
1663 static struct attribute *ipmi_si_dev_attrs[] = {
1664         &dev_attr_type.attr,
1665         &dev_attr_interrupts_enabled.attr,
1666         &dev_attr_short_timeouts.attr,
1667         &dev_attr_long_timeouts.attr,
1668         &dev_attr_idles.attr,
1669         &dev_attr_interrupts.attr,
1670         &dev_attr_attentions.attr,
1671         &dev_attr_flag_fetches.attr,
1672         &dev_attr_hosed_count.attr,
1673         &dev_attr_complete_transactions.attr,
1674         &dev_attr_events.attr,
1675         &dev_attr_watchdog_pretimeouts.attr,
1676         &dev_attr_incoming_messages.attr,
1677         &dev_attr_params.attr,
1678         NULL
1679 };
1680
1681 static const struct attribute_group ipmi_si_dev_attr_group = {
1682         .attrs          = ipmi_si_dev_attrs,
1683 };
1684
1685 /*
1686  * oem_data_avail_to_receive_msg_avail
1687  * @info - smi_info structure with msg_flags set
1688  *
1689  * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
1690  * Returns 1 indicating need to re-run handle_flags().
1691  */
1692 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
1693 {
1694         smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
1695                                RECEIVE_MSG_AVAIL);
1696         return 1;
1697 }
1698
1699 /*
1700  * setup_dell_poweredge_oem_data_handler
1701  * @info - smi_info.device_id must be populated
1702  *
1703  * Systems that match, but have firmware version < 1.40 may assert
1704  * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
1705  * it's safe to do so.  Such systems will de-assert OEM1_DATA_AVAIL
1706  * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
1707  * as RECEIVE_MSG_AVAIL instead.
1708  *
1709  * As Dell has no plans to release IPMI 1.5 firmware that *ever*
1710  * assert the OEM[012] bits, and if it did, the driver would have to
1711  * change to handle that properly, we don't actually check for the
1712  * firmware version.
1713  * Device ID = 0x20                BMC on PowerEdge 8G servers
1714  * Device Revision = 0x80
1715  * Firmware Revision1 = 0x01       BMC version 1.40
1716  * Firmware Revision2 = 0x40       BCD encoded
1717  * IPMI Version = 0x51             IPMI 1.5
1718  * Manufacturer ID = A2 02 00      Dell IANA
1719  *
1720  * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
1721  * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
1722  *
1723  */
1724 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID  0x20
1725 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
1726 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
1727 #define DELL_IANA_MFR_ID 0x0002a2
1728 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
1729 {
1730         struct ipmi_device_id *id = &smi_info->device_id;
1731         if (id->manufacturer_id == DELL_IANA_MFR_ID) {
1732                 if (id->device_id       == DELL_POWEREDGE_8G_BMC_DEVICE_ID  &&
1733                     id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
1734                     id->ipmi_version   == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
1735                         smi_info->oem_data_avail_handler =
1736                                 oem_data_avail_to_receive_msg_avail;
1737                 } else if (ipmi_version_major(id) < 1 ||
1738                            (ipmi_version_major(id) == 1 &&
1739                             ipmi_version_minor(id) < 5)) {
1740                         smi_info->oem_data_avail_handler =
1741                                 oem_data_avail_to_receive_msg_avail;
1742                 }
1743         }
1744 }
1745
1746 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
1747 static void return_hosed_msg_badsize(struct smi_info *smi_info)
1748 {
1749         struct ipmi_smi_msg *msg = smi_info->curr_msg;
1750
1751         /* Make it a response */
1752         msg->rsp[0] = msg->data[0] | 4;
1753         msg->rsp[1] = msg->data[1];
1754         msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
1755         msg->rsp_size = 3;
1756         smi_info->curr_msg = NULL;
1757         deliver_recv_msg(smi_info, msg);
1758 }
1759
1760 /*
1761  * dell_poweredge_bt_xaction_handler
1762  * @info - smi_info.device_id must be populated
1763  *
1764  * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
1765  * not respond to a Get SDR command if the length of the data
1766  * requested is exactly 0x3A, which leads to command timeouts and no
1767  * data returned.  This intercepts such commands, and causes userspace
1768  * callers to try again with a different-sized buffer, which succeeds.
1769  */
1770
1771 #define STORAGE_NETFN 0x0A
1772 #define STORAGE_CMD_GET_SDR 0x23
1773 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
1774                                              unsigned long unused,
1775                                              void *in)
1776 {
1777         struct smi_info *smi_info = in;
1778         unsigned char *data = smi_info->curr_msg->data;
1779         unsigned int size   = smi_info->curr_msg->data_size;
1780         if (size >= 8 &&
1781             (data[0]>>2) == STORAGE_NETFN &&
1782             data[1] == STORAGE_CMD_GET_SDR &&
1783             data[7] == 0x3A) {
1784                 return_hosed_msg_badsize(smi_info);
1785                 return NOTIFY_STOP;
1786         }
1787         return NOTIFY_DONE;
1788 }
1789
1790 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
1791         .notifier_call  = dell_poweredge_bt_xaction_handler,
1792 };
1793
1794 /*
1795  * setup_dell_poweredge_bt_xaction_handler
1796  * @info - smi_info.device_id must be filled in already
1797  *
1798  * Fills in smi_info.device_id.start_transaction_pre_hook
1799  * when we know what function to use there.
1800  */
1801 static void
1802 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
1803 {
1804         struct ipmi_device_id *id = &smi_info->device_id;
1805         if (id->manufacturer_id == DELL_IANA_MFR_ID &&
1806             smi_info->io.si_type == SI_BT)
1807                 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
1808 }
1809
1810 /*
1811  * setup_oem_data_handler
1812  * @info - smi_info.device_id must be filled in already
1813  *
1814  * Fills in smi_info.device_id.oem_data_available_handler
1815  * when we know what function to use there.
1816  */
1817
1818 static void setup_oem_data_handler(struct smi_info *smi_info)
1819 {
1820         setup_dell_poweredge_oem_data_handler(smi_info);
1821 }
1822
1823 static void setup_xaction_handlers(struct smi_info *smi_info)
1824 {
1825         setup_dell_poweredge_bt_xaction_handler(smi_info);
1826 }
1827
1828 static void check_for_broken_irqs(struct smi_info *smi_info)
1829 {
1830         check_clr_rcv_irq(smi_info);
1831         check_set_rcv_irq(smi_info);
1832 }
1833
1834 static inline void stop_timer_and_thread(struct smi_info *smi_info)
1835 {
1836         if (smi_info->thread != NULL) {
1837                 kthread_stop(smi_info->thread);
1838                 smi_info->thread = NULL;
1839         }
1840
1841         smi_info->timer_can_start = false;
1842         del_timer_sync(&smi_info->si_timer);
1843 }
1844
1845 static struct smi_info *find_dup_si(struct smi_info *info)
1846 {
1847         struct smi_info *e;
1848
1849         list_for_each_entry(e, &smi_infos, link) {
1850                 if (e->io.addr_space != info->io.addr_space)
1851                         continue;
1852                 if (e->io.addr_data == info->io.addr_data) {
1853                         /*
1854                          * This is a cheap hack, ACPI doesn't have a defined
1855                          * slave address but SMBIOS does.  Pick it up from
1856                          * any source that has it available.
1857                          */
1858                         if (info->io.slave_addr && !e->io.slave_addr)
1859                                 e->io.slave_addr = info->io.slave_addr;
1860                         return e;
1861                 }
1862         }
1863
1864         return NULL;
1865 }
1866
1867 int ipmi_si_add_smi(struct si_sm_io *io)
1868 {
1869         int rv = 0;
1870         struct smi_info *new_smi, *dup;
1871
1872         /*
1873          * If the user gave us a hard-coded device at the same
1874          * address, they presumably want us to use it and not what is
1875          * in the firmware.
1876          */
1877         if (io->addr_source != SI_HARDCODED && io->addr_source != SI_HOTMOD &&
1878             ipmi_si_hardcode_match(io->addr_space, io->addr_data)) {
1879                 dev_info(io->dev,
1880                          "Hard-coded device at this address already exists");
1881                 return -ENODEV;
1882         }
1883
1884         if (!io->io_setup) {
1885                 if (io->addr_space == IPMI_IO_ADDR_SPACE) {
1886                         io->io_setup = ipmi_si_port_setup;
1887                 } else if (io->addr_space == IPMI_MEM_ADDR_SPACE) {
1888                         io->io_setup = ipmi_si_mem_setup;
1889                 } else {
1890                         return -EINVAL;
1891                 }
1892         }
1893
1894         new_smi = kzalloc(sizeof(*new_smi), GFP_KERNEL);
1895         if (!new_smi)
1896                 return -ENOMEM;
1897         spin_lock_init(&new_smi->si_lock);
1898
1899         new_smi->io = *io;
1900
1901         mutex_lock(&smi_infos_lock);
1902         dup = find_dup_si(new_smi);
1903         if (dup) {
1904                 if (new_smi->io.addr_source == SI_ACPI &&
1905                     dup->io.addr_source == SI_SMBIOS) {
1906                         /* We prefer ACPI over SMBIOS. */
1907                         dev_info(dup->io.dev,
1908                                  "Removing SMBIOS-specified %s state machine in favor of ACPI\n",
1909                                  si_to_str[new_smi->io.si_type]);
1910                         cleanup_one_si(dup);
1911                 } else {
1912                         dev_info(new_smi->io.dev,
1913                                  "%s-specified %s state machine: duplicate\n",
1914                                  ipmi_addr_src_to_str(new_smi->io.addr_source),
1915                                  si_to_str[new_smi->io.si_type]);
1916                         rv = -EBUSY;
1917                         kfree(new_smi);
1918                         goto out_err;
1919                 }
1920         }
1921
1922         pr_info("Adding %s-specified %s state machine\n",
1923                 ipmi_addr_src_to_str(new_smi->io.addr_source),
1924                 si_to_str[new_smi->io.si_type]);
1925
1926         list_add_tail(&new_smi->link, &smi_infos);
1927
1928         if (initialized)
1929                 rv = try_smi_init(new_smi);
1930 out_err:
1931         mutex_unlock(&smi_infos_lock);
1932         return rv;
1933 }
1934
1935 /*
1936  * Try to start up an interface.  Must be called with smi_infos_lock
1937  * held, primarily to keep smi_num consistent, we only one to do these
1938  * one at a time.
1939  */
1940 static int try_smi_init(struct smi_info *new_smi)
1941 {
1942         int rv = 0;
1943         int i;
1944
1945         pr_info("Trying %s-specified %s state machine at %s address 0x%lx, slave address 0x%x, irq %d\n",
1946                 ipmi_addr_src_to_str(new_smi->io.addr_source),
1947                 si_to_str[new_smi->io.si_type],
1948                 addr_space_to_str[new_smi->io.addr_space],
1949                 new_smi->io.addr_data,
1950                 new_smi->io.slave_addr, new_smi->io.irq);
1951
1952         switch (new_smi->io.si_type) {
1953         case SI_KCS:
1954                 new_smi->handlers = &kcs_smi_handlers;
1955                 break;
1956
1957         case SI_SMIC:
1958                 new_smi->handlers = &smic_smi_handlers;
1959                 break;
1960
1961         case SI_BT:
1962                 new_smi->handlers = &bt_smi_handlers;
1963                 break;
1964
1965         default:
1966                 /* No support for anything else yet. */
1967                 rv = -EIO;
1968                 goto out_err;
1969         }
1970
1971         new_smi->si_num = smi_num;
1972
1973         /* Do this early so it's available for logs. */
1974         if (!new_smi->io.dev) {
1975                 pr_err("IPMI interface added with no device\n");
1976                 rv = -EIO;
1977                 goto out_err;
1978         }
1979
1980         /* Allocate the state machine's data and initialize it. */
1981         new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
1982         if (!new_smi->si_sm) {
1983                 rv = -ENOMEM;
1984                 goto out_err;
1985         }
1986         new_smi->io.io_size = new_smi->handlers->init_data(new_smi->si_sm,
1987                                                            &new_smi->io);
1988
1989         /* Now that we know the I/O size, we can set up the I/O. */
1990         rv = new_smi->io.io_setup(&new_smi->io);
1991         if (rv) {
1992                 dev_err(new_smi->io.dev, "Could not set up I/O space\n");
1993                 goto out_err;
1994         }
1995
1996         /* Do low-level detection first. */
1997         if (new_smi->handlers->detect(new_smi->si_sm)) {
1998                 if (new_smi->io.addr_source)
1999                         dev_err(new_smi->io.dev,
2000                                 "Interface detection failed\n");
2001                 rv = -ENODEV;
2002                 goto out_err;
2003         }
2004
2005         /*
2006          * Attempt a get device id command.  If it fails, we probably
2007          * don't have a BMC here.
2008          */
2009         rv = try_get_dev_id(new_smi);
2010         if (rv) {
2011                 if (new_smi->io.addr_source)
2012                         dev_err(new_smi->io.dev,
2013                                "There appears to be no BMC at this location\n");
2014                 goto out_err;
2015         }
2016
2017         setup_oem_data_handler(new_smi);
2018         setup_xaction_handlers(new_smi);
2019         check_for_broken_irqs(new_smi);
2020
2021         new_smi->waiting_msg = NULL;
2022         new_smi->curr_msg = NULL;
2023         atomic_set(&new_smi->req_events, 0);
2024         new_smi->run_to_completion = false;
2025         for (i = 0; i < SI_NUM_STATS; i++)
2026                 atomic_set(&new_smi->stats[i], 0);
2027
2028         new_smi->interrupt_disabled = true;
2029         atomic_set(&new_smi->need_watch, 0);
2030
2031         rv = try_enable_event_buffer(new_smi);
2032         if (rv == 0)
2033                 new_smi->has_event_buffer = true;
2034
2035         /*
2036          * Start clearing the flags before we enable interrupts or the
2037          * timer to avoid racing with the timer.
2038          */
2039         start_clear_flags(new_smi);
2040
2041         /*
2042          * IRQ is defined to be set when non-zero.  req_events will
2043          * cause a global flags check that will enable interrupts.
2044          */
2045         if (new_smi->io.irq) {
2046                 new_smi->interrupt_disabled = false;
2047                 atomic_set(&new_smi->req_events, 1);
2048         }
2049
2050         dev_set_drvdata(new_smi->io.dev, new_smi);
2051         rv = device_add_group(new_smi->io.dev, &ipmi_si_dev_attr_group);
2052         if (rv) {
2053                 dev_err(new_smi->io.dev,
2054                         "Unable to add device attributes: error %d\n",
2055                         rv);
2056                 goto out_err;
2057         }
2058         new_smi->dev_group_added = true;
2059
2060         rv = ipmi_register_smi(&handlers,
2061                                new_smi,
2062                                new_smi->io.dev,
2063                                new_smi->io.slave_addr);
2064         if (rv) {
2065                 dev_err(new_smi->io.dev,
2066                         "Unable to register device: error %d\n",
2067                         rv);
2068                 goto out_err;
2069         }
2070
2071         /* Don't increment till we know we have succeeded. */
2072         smi_num++;
2073
2074         dev_info(new_smi->io.dev, "IPMI %s interface initialized\n",
2075                  si_to_str[new_smi->io.si_type]);
2076
2077         WARN_ON(new_smi->io.dev->init_name != NULL);
2078
2079  out_err:
2080         if (rv && new_smi->io.io_cleanup) {
2081                 new_smi->io.io_cleanup(&new_smi->io);
2082                 new_smi->io.io_cleanup = NULL;
2083         }
2084
2085         return rv;
2086 }
2087
2088 static int __init init_ipmi_si(void)
2089 {
2090         struct smi_info *e;
2091         enum ipmi_addr_src type = SI_INVALID;
2092
2093         if (initialized)
2094                 return 0;
2095
2096         ipmi_hardcode_init();
2097
2098         pr_info("IPMI System Interface driver\n");
2099
2100         ipmi_si_platform_init();
2101
2102         ipmi_si_pci_init();
2103
2104         ipmi_si_parisc_init();
2105
2106         /* We prefer devices with interrupts, but in the case of a machine
2107            with multiple BMCs we assume that there will be several instances
2108            of a given type so if we succeed in registering a type then also
2109            try to register everything else of the same type */
2110         mutex_lock(&smi_infos_lock);
2111         list_for_each_entry(e, &smi_infos, link) {
2112                 /* Try to register a device if it has an IRQ and we either
2113                    haven't successfully registered a device yet or this
2114                    device has the same type as one we successfully registered */
2115                 if (e->io.irq && (!type || e->io.addr_source == type)) {
2116                         if (!try_smi_init(e)) {
2117                                 type = e->io.addr_source;
2118                         }
2119                 }
2120         }
2121
2122         /* type will only have been set if we successfully registered an si */
2123         if (type)
2124                 goto skip_fallback_noirq;
2125
2126         /* Fall back to the preferred device */
2127
2128         list_for_each_entry(e, &smi_infos, link) {
2129                 if (!e->io.irq && (!type || e->io.addr_source == type)) {
2130                         if (!try_smi_init(e)) {
2131                                 type = e->io.addr_source;
2132                         }
2133                 }
2134         }
2135
2136 skip_fallback_noirq:
2137         initialized = true;
2138         mutex_unlock(&smi_infos_lock);
2139
2140         if (type)
2141                 return 0;
2142
2143         mutex_lock(&smi_infos_lock);
2144         if (unload_when_empty && list_empty(&smi_infos)) {
2145                 mutex_unlock(&smi_infos_lock);
2146                 cleanup_ipmi_si();
2147                 pr_warn("Unable to find any System Interface(s)\n");
2148                 return -ENODEV;
2149         } else {
2150                 mutex_unlock(&smi_infos_lock);
2151                 return 0;
2152         }
2153 }
2154 module_init(init_ipmi_si);
2155
2156 static void shutdown_smi(void *send_info)
2157 {
2158         struct smi_info *smi_info = send_info;
2159
2160         if (smi_info->dev_group_added) {
2161                 device_remove_group(smi_info->io.dev, &ipmi_si_dev_attr_group);
2162                 smi_info->dev_group_added = false;
2163         }
2164         if (smi_info->io.dev)
2165                 dev_set_drvdata(smi_info->io.dev, NULL);
2166
2167         /*
2168          * Make sure that interrupts, the timer and the thread are
2169          * stopped and will not run again.
2170          */
2171         smi_info->interrupt_disabled = true;
2172         if (smi_info->io.irq_cleanup) {
2173                 smi_info->io.irq_cleanup(&smi_info->io);
2174                 smi_info->io.irq_cleanup = NULL;
2175         }
2176         stop_timer_and_thread(smi_info);
2177
2178         /*
2179          * Wait until we know that we are out of any interrupt
2180          * handlers might have been running before we freed the
2181          * interrupt.
2182          */
2183         synchronize_rcu();
2184
2185         /*
2186          * Timeouts are stopped, now make sure the interrupts are off
2187          * in the BMC.  Note that timers and CPU interrupts are off,
2188          * so no need for locks.
2189          */
2190         while (smi_info->curr_msg || (smi_info->si_state != SI_NORMAL)) {
2191                 poll(smi_info);
2192                 schedule_timeout_uninterruptible(1);
2193         }
2194         if (smi_info->handlers)
2195                 disable_si_irq(smi_info);
2196         while (smi_info->curr_msg || (smi_info->si_state != SI_NORMAL)) {
2197                 poll(smi_info);
2198                 schedule_timeout_uninterruptible(1);
2199         }
2200         if (smi_info->handlers)
2201                 smi_info->handlers->cleanup(smi_info->si_sm);
2202
2203         if (smi_info->io.io_cleanup) {
2204                 smi_info->io.io_cleanup(&smi_info->io);
2205                 smi_info->io.io_cleanup = NULL;
2206         }
2207
2208         kfree(smi_info->si_sm);
2209         smi_info->si_sm = NULL;
2210
2211         smi_info->intf = NULL;
2212 }
2213
2214 /*
2215  * Must be called with smi_infos_lock held, to serialize the
2216  * smi_info->intf check.
2217  */
2218 static void cleanup_one_si(struct smi_info *smi_info)
2219 {
2220         if (!smi_info)
2221                 return;
2222
2223         list_del(&smi_info->link);
2224         ipmi_unregister_smi(smi_info->intf);
2225         kfree(smi_info);
2226 }
2227
2228 void ipmi_si_remove_by_dev(struct device *dev)
2229 {
2230         struct smi_info *e;
2231
2232         mutex_lock(&smi_infos_lock);
2233         list_for_each_entry(e, &smi_infos, link) {
2234                 if (e->io.dev == dev) {
2235                         cleanup_one_si(e);
2236                         break;
2237                 }
2238         }
2239         mutex_unlock(&smi_infos_lock);
2240 }
2241
2242 struct device *ipmi_si_remove_by_data(int addr_space, enum si_type si_type,
2243                                       unsigned long addr)
2244 {
2245         /* remove */
2246         struct smi_info *e, *tmp_e;
2247         struct device *dev = NULL;
2248
2249         mutex_lock(&smi_infos_lock);
2250         list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
2251                 if (e->io.addr_space != addr_space)
2252                         continue;
2253                 if (e->io.si_type != si_type)
2254                         continue;
2255                 if (e->io.addr_data == addr) {
2256                         dev = get_device(e->io.dev);
2257                         cleanup_one_si(e);
2258                 }
2259         }
2260         mutex_unlock(&smi_infos_lock);
2261
2262         return dev;
2263 }
2264
2265 static void cleanup_ipmi_si(void)
2266 {
2267         struct smi_info *e, *tmp_e;
2268
2269         if (!initialized)
2270                 return;
2271
2272         ipmi_si_pci_shutdown();
2273
2274         ipmi_si_parisc_shutdown();
2275
2276         ipmi_si_platform_shutdown();
2277
2278         mutex_lock(&smi_infos_lock);
2279         list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2280                 cleanup_one_si(e);
2281         mutex_unlock(&smi_infos_lock);
2282
2283         ipmi_si_hardcode_exit();
2284         ipmi_si_hotmod_exit();
2285 }
2286 module_exit(cleanup_ipmi_si);
2287
2288 MODULE_ALIAS("platform:dmi-ipmi-si");
2289 MODULE_LICENSE("GPL");
2290 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2291 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");