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(char *msg)
 268 {
 269         struct timespec64 t;
 270
 271         ktime_get_ts64(&t);
 272         pr_debug("**%s: %lld.%9.9ld\n", msg, t.tv_sec, t.tv_nsec);
 273 }
 274 #else
 275 #define debug_timestamp(x)
 276 #endif
 277
 278 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
 279 static int register_xaction_notifier(struct notifier_block *nb)
 280 {
 281         return atomic_notifier_chain_register(&xaction_notifier_list, nb);
 282 }
 283
 284 static void deliver_recv_msg(struct smi_info *smi_info,
 285                              struct ipmi_smi_msg *msg)
 286 {
 287         /* Deliver the message to the upper layer. */
 288         ipmi_smi_msg_received(smi_info->intf, msg);
 289 }
 290
 291 static void return_hosed_msg(struct smi_info *smi_info, int cCode)
 292 {
 293         struct ipmi_smi_msg *msg = smi_info->curr_msg;
 294
 295         if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
 296                 cCode = IPMI_ERR_UNSPECIFIED;
 297         /* else use it as is */
 298
 299         /* Make it a response */
 300         msg->rsp[0] = msg->data[0] | 4;
 301         msg->rsp[1] = msg->data[1];
 302         msg->rsp[2] = cCode;
 303         msg->rsp_size = 3;
 304
 305         smi_info->curr_msg = NULL;
 306         deliver_recv_msg(smi_info, msg);
 307 }
 308
 309 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
 310 {
 311         int              rv;
 312
 313         if (!smi_info->waiting_msg) {
 314                 smi_info->curr_msg = NULL;
 315                 rv = SI_SM_IDLE;
 316         } else {
 317                 int err;
 318
 319                 smi_info->curr_msg = smi_info->waiting_msg;
 320                 smi_info->waiting_msg = NULL;
 321                 debug_timestamp("Start2");
 322                 err = atomic_notifier_call_chain(&xaction_notifier_list,
 323                                 0, smi_info);
 324                 if (err & NOTIFY_STOP_MASK) {
 325                         rv = SI_SM_CALL_WITHOUT_DELAY;
 326                         goto out;
 327                 }
 328                 err = smi_info->handlers->start_transaction(
 329                         smi_info->si_sm,
 330                         smi_info->curr_msg->data,
 331                         smi_info->curr_msg->data_size);
 332                 if (err)
 333                         return_hosed_msg(smi_info, err);
 334
 335                 rv = SI_SM_CALL_WITHOUT_DELAY;
 336         }
 337 out:
 338         return rv;
 339 }
 340
 341 static void smi_mod_timer(struct smi_info *smi_info, unsigned long new_val)
 342 {
 343         if (!smi_info->timer_can_start)
 344                 return;
 345         smi_info->last_timeout_jiffies = jiffies;
 346         mod_timer(&smi_info->si_timer, new_val);
 347         smi_info->timer_running = true;
 348 }
 349
 350 /*
 351  * Start a new message and (re)start the timer and thread.
 352  */
 353 static void start_new_msg(struct smi_info *smi_info, unsigned char *msg,
 354                           unsigned int size)
 355 {
 356         smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
 357
 358         if (smi_info->thread)
 359                 wake_up_process(smi_info->thread);
 360
 361         smi_info->handlers->start_transaction(smi_info->si_sm, msg, size);
 362 }
 363
 364 static void start_check_enables(struct smi_info *smi_info)
 365 {
 366         unsigned char msg[2];
 367
 368         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 369         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
 370
 371         start_new_msg(smi_info, msg, 2);
 372         smi_info->si_state = SI_CHECKING_ENABLES;
 373 }
 374
 375 static void start_clear_flags(struct smi_info *smi_info)
 376 {
 377         unsigned char msg[3];
 378
 379         /* Make sure the watchdog pre-timeout flag is not set at startup. */
 380         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 381         msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
 382         msg[2] = WDT_PRE_TIMEOUT_INT;
 383
 384         start_new_msg(smi_info, msg, 3);
 385         smi_info->si_state = SI_CLEARING_FLAGS;
 386 }
 387
 388 static void start_getting_msg_queue(struct smi_info *smi_info)
 389 {
 390         smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 391         smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
 392         smi_info->curr_msg->data_size = 2;
 393
 394         start_new_msg(smi_info, smi_info->curr_msg->data,
 395                       smi_info->curr_msg->data_size);
 396         smi_info->si_state = SI_GETTING_MESSAGES;
 397 }
 398
 399 static void start_getting_events(struct smi_info *smi_info)
 400 {
 401         smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 402         smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
 403         smi_info->curr_msg->data_size = 2;
 404
 405         start_new_msg(smi_info, smi_info->curr_msg->data,
 406                       smi_info->curr_msg->data_size);
 407         smi_info->si_state = SI_GETTING_EVENTS;
 408 }
 409
 410 /*
 411  * When we have a situtaion where we run out of memory and cannot
 412  * allocate messages, we just leave them in the BMC and run the system
 413  * polled until we can allocate some memory.  Once we have some
 414  * memory, we will re-enable the interrupt.
 415  *
 416  * Note that we cannot just use disable_irq(), since the interrupt may
 417  * be shared.
 418  */
 419 static inline bool disable_si_irq(struct smi_info *smi_info)
 420 {
 421         if ((smi_info->io.irq) && (!smi_info->interrupt_disabled)) {
 422                 smi_info->interrupt_disabled = true;
 423                 start_check_enables(smi_info);
 424                 return true;
 425         }
 426         return false;
 427 }
 428
 429 static inline bool enable_si_irq(struct smi_info *smi_info)
 430 {
 431         if ((smi_info->io.irq) && (smi_info->interrupt_disabled)) {
 432                 smi_info->interrupt_disabled = false;
 433                 start_check_enables(smi_info);
 434                 return true;
 435         }
 436         return false;
 437 }
 438
 439 /*
 440  * Allocate a message.  If unable to allocate, start the interrupt
 441  * disable process and return NULL.  If able to allocate but
 442  * interrupts are disabled, free the message and return NULL after
 443  * starting the interrupt enable process.
 444  */
 445 static struct ipmi_smi_msg *alloc_msg_handle_irq(struct smi_info *smi_info)
 446 {
 447         struct ipmi_smi_msg *msg;
 448
 449         msg = ipmi_alloc_smi_msg();
 450         if (!msg) {
 451                 if (!disable_si_irq(smi_info))
 452                         smi_info->si_state = SI_NORMAL;
 453         } else if (enable_si_irq(smi_info)) {
 454                 ipmi_free_smi_msg(msg);
 455                 msg = NULL;
 456         }
 457         return msg;
 458 }
 459
 460 static void handle_flags(struct smi_info *smi_info)
 461 {
 462 retry:
 463         if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
 464                 /* Watchdog pre-timeout */
 465                 smi_inc_stat(smi_info, watchdog_pretimeouts);
 466
 467                 start_clear_flags(smi_info);
 468                 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
 469                 ipmi_smi_watchdog_pretimeout(smi_info->intf);
 470         } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
 471                 /* Messages available. */
 472                 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
 473                 if (!smi_info->curr_msg)
 474                         return;
 475
 476                 start_getting_msg_queue(smi_info);
 477         } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
 478                 /* Events available. */
 479                 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
 480                 if (!smi_info->curr_msg)
 481                         return;
 482
 483                 start_getting_events(smi_info);
 484         } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
 485                    smi_info->oem_data_avail_handler) {
 486                 if (smi_info->oem_data_avail_handler(smi_info))
 487                         goto retry;
 488         } else
 489                 smi_info->si_state = SI_NORMAL;
 490 }
 491
 492 /*
 493  * Global enables we care about.
 494  */
 495 #define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \
 496                              IPMI_BMC_EVT_MSG_INTR)
 497
 498 static u8 current_global_enables(struct smi_info *smi_info, u8 base,
 499                                  bool *irq_on)
 500 {
 501         u8 enables = 0;
 502
 503         if (smi_info->supports_event_msg_buff)
 504                 enables |= IPMI_BMC_EVT_MSG_BUFF;
 505
 506         if (((smi_info->io.irq && !smi_info->interrupt_disabled) ||
 507              smi_info->cannot_disable_irq) &&
 508             !smi_info->irq_enable_broken)
 509                 enables |= IPMI_BMC_RCV_MSG_INTR;
 510
 511         if (smi_info->supports_event_msg_buff &&
 512             smi_info->io.irq && !smi_info->interrupt_disabled &&
 513             !smi_info->irq_enable_broken)
 514                 enables |= IPMI_BMC_EVT_MSG_INTR;
 515
 516         *irq_on = enables & (IPMI_BMC_EVT_MSG_INTR | IPMI_BMC_RCV_MSG_INTR);
 517
 518         return enables;
 519 }
 520
 521 static void check_bt_irq(struct smi_info *smi_info, bool irq_on)
 522 {
 523         u8 irqstate = smi_info->io.inputb(&smi_info->io, IPMI_BT_INTMASK_REG);
 524
 525         irqstate &= IPMI_BT_INTMASK_ENABLE_IRQ_BIT;
 526
 527         if ((bool)irqstate == irq_on)
 528                 return;
 529
 530         if (irq_on)
 531                 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
 532                                      IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
 533         else
 534                 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 0);
 535 }
 536
 537 static void handle_transaction_done(struct smi_info *smi_info)
 538 {
 539         struct ipmi_smi_msg *msg;
 540
 541         debug_timestamp("Done");
 542         switch (smi_info->si_state) {
 543         case SI_NORMAL:
 544                 if (!smi_info->curr_msg)
 545                         break;
 546
 547                 smi_info->curr_msg->rsp_size
 548                         = smi_info->handlers->get_result(
 549                                 smi_info->si_sm,
 550                                 smi_info->curr_msg->rsp,
 551                                 IPMI_MAX_MSG_LENGTH);
 552
 553                 /*
 554                  * Do this here becase deliver_recv_msg() releases the
 555                  * lock, and a new message can be put in during the
 556                  * time the lock is released.
 557                  */
 558                 msg = smi_info->curr_msg;
 559                 smi_info->curr_msg = NULL;
 560                 deliver_recv_msg(smi_info, msg);
 561                 break;
 562
 563         case SI_GETTING_FLAGS:
 564         {
 565                 unsigned char msg[4];
 566                 unsigned int  len;
 567
 568                 /* We got the flags from the SMI, now handle them. */
 569                 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 570                 if (msg[2] != 0) {
 571                         /* Error fetching flags, just give up for now. */
 572                         smi_info->si_state = SI_NORMAL;
 573                 } else if (len < 4) {
 574                         /*
 575                          * Hmm, no flags.  That's technically illegal, but
 576                          * don't use uninitialized data.
 577                          */
 578                         smi_info->si_state = SI_NORMAL;
 579                 } else {
 580                         smi_info->msg_flags = msg[3];
 581                         handle_flags(smi_info);
 582                 }
 583                 break;
 584         }
 585
 586         case SI_CLEARING_FLAGS:
 587         {
 588                 unsigned char msg[3];
 589
 590                 /* We cleared the flags. */
 591                 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
 592                 if (msg[2] != 0) {
 593                         /* Error clearing flags */
 594                         dev_warn(smi_info->io.dev,
 595                                  "Error clearing flags: %2.2x\n", msg[2]);
 596                 }
 597                 smi_info->si_state = SI_NORMAL;
 598                 break;
 599         }
 600
 601         case SI_GETTING_EVENTS:
 602         {
 603                 smi_info->curr_msg->rsp_size
 604                         = smi_info->handlers->get_result(
 605                                 smi_info->si_sm,
 606                                 smi_info->curr_msg->rsp,
 607                                 IPMI_MAX_MSG_LENGTH);
 608
 609                 /*
 610                  * Do this here becase deliver_recv_msg() releases the
 611                  * lock, and a new message can be put in during the
 612                  * time the lock is released.
 613                  */
 614                 msg = smi_info->curr_msg;
 615                 smi_info->curr_msg = NULL;
 616                 if (msg->rsp[2] != 0) {
 617                         /* Error getting event, probably done. */
 618                         msg->done(msg);
 619
 620                         /* Take off the event flag. */
 621                         smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
 622                         handle_flags(smi_info);
 623                 } else {
 624                         smi_inc_stat(smi_info, events);
 625
 626                         /*
 627                          * Do this before we deliver the message
 628                          * because delivering the message releases the
 629                          * lock and something else can mess with the
 630                          * state.
 631                          */
 632                         handle_flags(smi_info);
 633
 634                         deliver_recv_msg(smi_info, msg);
 635                 }
 636                 break;
 637         }
 638
 639         case SI_GETTING_MESSAGES:
 640         {
 641                 smi_info->curr_msg->rsp_size
 642                         = smi_info->handlers->get_result(
 643                                 smi_info->si_sm,
 644                                 smi_info->curr_msg->rsp,
 645                                 IPMI_MAX_MSG_LENGTH);
 646
 647                 /*
 648                  * Do this here becase deliver_recv_msg() releases the
 649                  * lock, and a new message can be put in during the
 650                  * time the lock is released.
 651                  */
 652                 msg = smi_info->curr_msg;
 653                 smi_info->curr_msg = NULL;
 654                 if (msg->rsp[2] != 0) {
 655                         /* Error getting event, probably done. */
 656                         msg->done(msg);
 657
 658                         /* Take off the msg flag. */
 659                         smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
 660                         handle_flags(smi_info);
 661                 } else {
 662                         smi_inc_stat(smi_info, incoming_messages);
 663
 664                         /*
 665                          * Do this before we deliver the message
 666                          * because delivering the message releases the
 667                          * lock and something else can mess with the
 668                          * state.
 669                          */
 670                         handle_flags(smi_info);
 671
 672                         deliver_recv_msg(smi_info, msg);
 673                 }
 674                 break;
 675         }
 676
 677         case SI_CHECKING_ENABLES:
 678         {
 679                 unsigned char msg[4];
 680                 u8 enables;
 681                 bool irq_on;
 682
 683                 /* We got the flags from the SMI, now handle them. */
 684                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 685                 if (msg[2] != 0) {
 686                         dev_warn(smi_info->io.dev,
 687                                  "Couldn't get irq info: %x.\n", msg[2]);
 688                         dev_warn(smi_info->io.dev,
 689                                  "Maybe ok, but ipmi might run very slowly.\n");
 690                         smi_info->si_state = SI_NORMAL;
 691                         break;
 692                 }
 693                 enables = current_global_enables(smi_info, 0, &irq_on);
 694                 if (smi_info->io.si_type == SI_BT)
 695                         /* BT has its own interrupt enable bit. */
 696                         check_bt_irq(smi_info, irq_on);
 697                 if (enables != (msg[3] & GLOBAL_ENABLES_MASK)) {
 698                         /* Enables are not correct, fix them. */
 699                         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 700                         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
 701                         msg[2] = enables | (msg[3] & ~GLOBAL_ENABLES_MASK);
 702                         smi_info->handlers->start_transaction(
 703                                 smi_info->si_sm, msg, 3);
 704                         smi_info->si_state = SI_SETTING_ENABLES;
 705                 } else if (smi_info->supports_event_msg_buff) {
 706                         smi_info->curr_msg = ipmi_alloc_smi_msg();
 707                         if (!smi_info->curr_msg) {
 708                                 smi_info->si_state = SI_NORMAL;
 709                                 break;
 710                         }
 711                         start_getting_events(smi_info);
 712                 } else {
 713                         smi_info->si_state = SI_NORMAL;
 714                 }
 715                 break;
 716         }
 717
 718         case SI_SETTING_ENABLES:
 719         {
 720                 unsigned char msg[4];
 721
 722                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
 723                 if (msg[2] != 0)
 724                         dev_warn(smi_info->io.dev,
 725                                  "Could not set the global enables: 0x%x.\n",
 726                                  msg[2]);
 727
 728                 if (smi_info->supports_event_msg_buff) {
 729                         smi_info->curr_msg = ipmi_alloc_smi_msg();
 730                         if (!smi_info->curr_msg) {
 731                                 smi_info->si_state = SI_NORMAL;
 732                                 break;
 733                         }
 734                         start_getting_events(smi_info);
 735                 } else {
 736                         smi_info->si_state = SI_NORMAL;
 737                 }
 738                 break;
 739         }
 740         }
 741 }
 742
 743 /*
 744  * Called on timeouts and events.  Timeouts should pass the elapsed
 745  * time, interrupts should pass in zero.  Must be called with
 746  * si_lock held and interrupts disabled.
 747  */
 748 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
 749                                            int time)
 750 {
 751         enum si_sm_result si_sm_result;
 752
 753 restart:
 754         /*
 755          * There used to be a loop here that waited a little while
 756          * (around 25us) before giving up.  That turned out to be
 757          * pointless, the minimum delays I was seeing were in the 300us
 758          * range, which is far too long to wait in an interrupt.  So
 759          * we just run until the state machine tells us something
 760          * happened or it needs a delay.
 761          */
 762         si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
 763         time = 0;
 764         while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
 765                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
 766
 767         if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
 768                 smi_inc_stat(smi_info, complete_transactions);
 769
 770                 handle_transaction_done(smi_info);
 771                 goto restart;
 772         } else if (si_sm_result == SI_SM_HOSED) {
 773                 smi_inc_stat(smi_info, hosed_count);
 774
 775                 /*
 776                  * Do the before return_hosed_msg, because that
 777                  * releases the lock.
 778                  */
 779                 smi_info->si_state = SI_NORMAL;
 780                 if (smi_info->curr_msg != NULL) {
 781                         /*
 782                          * If we were handling a user message, format
 783                          * a response to send to the upper layer to
 784                          * tell it about the error.
 785                          */
 786                         return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
 787                 }
 788                 goto restart;
 789         }
 790
 791         /*
 792          * We prefer handling attn over new messages.  But don't do
 793          * this if there is not yet an upper layer to handle anything.
 794          */
 795         if (si_sm_result == SI_SM_ATTN || smi_info->got_attn) {
 796                 unsigned char msg[2];
 797
 798                 if (smi_info->si_state != SI_NORMAL) {
 799                         /*
 800                          * We got an ATTN, but we are doing something else.
 801                          * Handle the ATTN later.
 802                          */
 803                         smi_info->got_attn = true;
 804                 } else {
 805                         smi_info->got_attn = false;
 806                         smi_inc_stat(smi_info, attentions);
 807
 808                         /*
 809                          * Got a attn, send down a get message flags to see
 810                          * what's causing it.  It would be better to handle
 811                          * this in the upper layer, but due to the way
 812                          * interrupts work with the SMI, that's not really
 813                          * possible.
 814                          */
 815                         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 816                         msg[1] = IPMI_GET_MSG_FLAGS_CMD;
 817
 818                         start_new_msg(smi_info, msg, 2);
 819                         smi_info->si_state = SI_GETTING_FLAGS;
 820                         goto restart;
 821                 }
 822         }
 823
 824         /* If we are currently idle, try to start the next message. */
 825         if (si_sm_result == SI_SM_IDLE) {
 826                 smi_inc_stat(smi_info, idles);
 827
 828                 si_sm_result = start_next_msg(smi_info);
 829                 if (si_sm_result != SI_SM_IDLE)
 830                         goto restart;
 831         }
 832
 833         if ((si_sm_result == SI_SM_IDLE)
 834             && (atomic_read(&smi_info->req_events))) {
 835                 /*
 836                  * We are idle and the upper layer requested that I fetch
 837                  * events, so do so.
 838                  */
 839                 atomic_set(&smi_info->req_events, 0);
 840
 841                 /*
 842                  * Take this opportunity to check the interrupt and
 843                  * message enable state for the BMC.  The BMC can be
 844                  * asynchronously reset, and may thus get interrupts
 845                  * disable and messages disabled.
 846                  */
 847                 if (smi_info->supports_event_msg_buff || smi_info->io.irq) {
 848                         start_check_enables(smi_info);
 849                 } else {
 850                         smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
 851                         if (!smi_info->curr_msg)
 852                                 goto out;
 853
 854                         start_getting_events(smi_info);
 855                 }
 856                 goto restart;
 857         }
 858
 859         if (si_sm_result == SI_SM_IDLE && smi_info->timer_running) {
 860                 /* Ok it if fails, the timer will just go off. */
 861                 if (del_timer(&smi_info->si_timer))
 862                         smi_info->timer_running = false;
 863         }
 864
 865 out:
 866         return si_sm_result;
 867 }
 868
 869 static void check_start_timer_thread(struct smi_info *smi_info)
 870 {
 871         if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) {
 872                 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
 873
 874                 if (smi_info->thread)
 875                         wake_up_process(smi_info->thread);
 876
 877                 start_next_msg(smi_info);
 878                 smi_event_handler(smi_info, 0);
 879         }
 880 }
 881
 882 static void flush_messages(void *send_info)
 883 {
 884         struct smi_info *smi_info = send_info;
 885         enum si_sm_result result;
 886
 887         /*
 888          * Currently, this function is called only in run-to-completion
 889          * mode.  This means we are single-threaded, no need for locks.
 890          */
 891         result = smi_event_handler(smi_info, 0);
 892         while (result != SI_SM_IDLE) {
 893                 udelay(SI_SHORT_TIMEOUT_USEC);
 894                 result = smi_event_handler(smi_info, SI_SHORT_TIMEOUT_USEC);
 895         }
 896 }
 897
 898 static void sender(void                *send_info,
 899                    struct ipmi_smi_msg *msg)
 900 {
 901         struct smi_info   *smi_info = send_info;
 902         unsigned long     flags;
 903
 904         debug_timestamp("Enqueue");
 905
 906         if (smi_info->run_to_completion) {
 907                 /*
 908                  * If we are running to completion, start it.  Upper
 909                  * layer will call flush_messages to clear it out.
 910                  */
 911                 smi_info->waiting_msg = msg;
 912                 return;
 913         }
 914
 915         spin_lock_irqsave(&smi_info->si_lock, flags);
 916         /*
 917          * The following two lines don't need to be under the lock for
 918          * the lock's sake, but they do need SMP memory barriers to
 919          * avoid getting things out of order.  We are already claiming
 920          * the lock, anyway, so just do it under the lock to avoid the
 921          * ordering problem.
 922          */
 923         BUG_ON(smi_info->waiting_msg);
 924         smi_info->waiting_msg = msg;
 925         check_start_timer_thread(smi_info);
 926         spin_unlock_irqrestore(&smi_info->si_lock, flags);
 927 }
 928
 929 static void set_run_to_completion(void *send_info, bool i_run_to_completion)
 930 {
 931         struct smi_info   *smi_info = send_info;
 932
 933         smi_info->run_to_completion = i_run_to_completion;
 934         if (i_run_to_completion)
 935                 flush_messages(smi_info);
 936 }
 937
 938 /*
 939  * Use -1 as a special constant to tell that we are spinning in kipmid
 940  * looking for something and not delaying between checks
 941  */
 942 #define IPMI_TIME_NOT_BUSY ns_to_ktime(-1ull)
 943 static inline bool ipmi_thread_busy_wait(enum si_sm_result smi_result,
 944                                          const struct smi_info *smi_info,
 945                                          ktime_t *busy_until)
 946 {
 947         unsigned int max_busy_us = 0;
 948
 949         if (smi_info->si_num < num_max_busy_us)
 950                 max_busy_us = kipmid_max_busy_us[smi_info->si_num];
 951         if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
 952                 *busy_until = IPMI_TIME_NOT_BUSY;
 953         else if (*busy_until == IPMI_TIME_NOT_BUSY) {
 954                 *busy_until = ktime_get() + max_busy_us * NSEC_PER_USEC;
 955         } else {
 956                 if (unlikely(ktime_get() > *busy_until)) {
 957                         *busy_until = IPMI_TIME_NOT_BUSY;
 958                         return false;
 959                 }
 960         }
 961         return true;
 962 }
 963
 964
 965 /*
 966  * A busy-waiting loop for speeding up IPMI operation.
 967  *
 968  * Lousy hardware makes this hard.  This is only enabled for systems
 969  * that are not BT and do not have interrupts.  It starts spinning
 970  * when an operation is complete or until max_busy tells it to stop
 971  * (if that is enabled).  See the paragraph on kimid_max_busy_us in
 972  * Documentation/driver-api/ipmi.rst for details.
 973  */
 974 static int ipmi_thread(void *data)
 975 {
 976         struct smi_info *smi_info = data;
 977         unsigned long flags;
 978         enum si_sm_result smi_result;
 979         ktime_t busy_until = IPMI_TIME_NOT_BUSY;
 980
 981         set_user_nice(current, MAX_NICE);
 982         while (!kthread_should_stop()) {
 983                 int busy_wait;
 984
 985                 spin_lock_irqsave(&(smi_info->si_lock), flags);
 986                 smi_result = smi_event_handler(smi_info, 0);
 987
 988                 /*
 989                  * If the driver is doing something, there is a possible
 990                  * race with the timer.  If the timer handler see idle,
 991                  * and the thread here sees something else, the timer
 992                  * handler won't restart the timer even though it is
 993                  * required.  So start it here if necessary.
 994                  */
 995                 if (smi_result != SI_SM_IDLE && !smi_info->timer_running)
 996                         smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
 997
 998                 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 999                 busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
1000                                                   &busy_until);
1001                 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
1002                         ; /* do nothing */
1003                 } else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait) {
1004                         /*
1005                          * In maintenance mode we run as fast as
1006                          * possible to allow firmware updates to
1007                          * complete as fast as possible, but normally
1008                          * don't bang on the scheduler.
1009                          */
1010                         if (smi_info->in_maintenance_mode)
1011                                 schedule();
1012                         else
1013                                 usleep_range(100, 200);
1014                 } else if (smi_result == SI_SM_IDLE) {
1015                         if (atomic_read(&smi_info->need_watch)) {
1016                                 schedule_timeout_interruptible(100);
1017                         } else {
1018                                 /* Wait to be woken up when we are needed. */
1019                                 __set_current_state(TASK_INTERRUPTIBLE);
1020                                 schedule();
1021                         }
1022                 } else {
1023                         schedule_timeout_interruptible(1);
1024                 }
1025         }
1026         return 0;
1027 }
1028
1029
1030 static void poll(void *send_info)
1031 {
1032         struct smi_info *smi_info = send_info;
1033         unsigned long flags = 0;
1034         bool run_to_completion = smi_info->run_to_completion;
1035
1036         /*
1037          * Make sure there is some delay in the poll loop so we can
1038          * drive time forward and timeout things.
1039          */
1040         udelay(10);
1041         if (!run_to_completion)
1042                 spin_lock_irqsave(&smi_info->si_lock, flags);
1043         smi_event_handler(smi_info, 10);
1044         if (!run_to_completion)
1045                 spin_unlock_irqrestore(&smi_info->si_lock, flags);
1046 }
1047
1048 static void request_events(void *send_info)
1049 {
1050         struct smi_info *smi_info = send_info;
1051
1052         if (!smi_info->has_event_buffer)
1053                 return;
1054
1055         atomic_set(&smi_info->req_events, 1);
1056 }
1057
1058 static void set_need_watch(void *send_info, unsigned int watch_mask)
1059 {
1060         struct smi_info *smi_info = send_info;
1061         unsigned long flags;
1062         int enable;
1063
1064         enable = !!watch_mask;
1065
1066         atomic_set(&smi_info->need_watch, enable);
1067         spin_lock_irqsave(&smi_info->si_lock, flags);
1068         check_start_timer_thread(smi_info);
1069         spin_unlock_irqrestore(&smi_info->si_lock, flags);
1070 }
1071
1072 static void smi_timeout(struct timer_list *t)
1073 {
1074         struct smi_info   *smi_info = from_timer(smi_info, t, si_timer);
1075         enum si_sm_result smi_result;
1076         unsigned long     flags;
1077         unsigned long     jiffies_now;
1078         long              time_diff;
1079         long              timeout;
1080
1081         spin_lock_irqsave(&(smi_info->si_lock), flags);
1082         debug_timestamp("Timer");
1083
1084         jiffies_now = jiffies;
1085         time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
1086                      * SI_USEC_PER_JIFFY);
1087         smi_result = smi_event_handler(smi_info, time_diff);
1088
1089         if ((smi_info->io.irq) && (!smi_info->interrupt_disabled)) {
1090                 /* Running with interrupts, only do long timeouts. */
1091                 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1092                 smi_inc_stat(smi_info, long_timeouts);
1093                 goto do_mod_timer;
1094         }
1095
1096         /*
1097          * If the state machine asks for a short delay, then shorten
1098          * the timer timeout.
1099          */
1100         if (smi_result == SI_SM_CALL_WITH_DELAY) {
1101                 smi_inc_stat(smi_info, short_timeouts);
1102                 timeout = jiffies + 1;
1103         } else {
1104                 smi_inc_stat(smi_info, long_timeouts);
1105                 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1106         }
1107
1108 do_mod_timer:
1109         if (smi_result != SI_SM_IDLE)
1110                 smi_mod_timer(smi_info, timeout);
1111         else
1112                 smi_info->timer_running = false;
1113         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1114 }
1115
1116 irqreturn_t ipmi_si_irq_handler(int irq, void *data)
1117 {
1118         struct smi_info *smi_info = data;
1119         unsigned long   flags;
1120
1121         if (smi_info->io.si_type == SI_BT)
1122                 /* We need to clear the IRQ flag for the BT interface. */
1123                 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
1124                                      IPMI_BT_INTMASK_CLEAR_IRQ_BIT
1125                                      | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1126
1127         spin_lock_irqsave(&(smi_info->si_lock), flags);
1128
1129         smi_inc_stat(smi_info, interrupts);
1130
1131         debug_timestamp("Interrupt");
1132
1133         smi_event_handler(smi_info, 0);
1134         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1135         return IRQ_HANDLED;
1136 }
1137
1138 static int smi_start_processing(void            *send_info,
1139                                 struct ipmi_smi *intf)
1140 {
1141         struct smi_info *new_smi = send_info;
1142         int             enable = 0;
1143
1144         new_smi->intf = intf;
1145
1146         /* Set up the timer that drives the interface. */
1147         timer_setup(&new_smi->si_timer, smi_timeout, 0);
1148         new_smi->timer_can_start = true;
1149         smi_mod_timer(new_smi, jiffies + SI_TIMEOUT_JIFFIES);
1150
1151         /* Try to claim any interrupts. */
1152         if (new_smi->io.irq_setup) {
1153                 new_smi->io.irq_handler_data = new_smi;
1154                 new_smi->io.irq_setup(&new_smi->io);
1155         }
1156
1157         /*
1158          * Check if the user forcefully enabled the daemon.
1159          */
1160         if (new_smi->si_num < num_force_kipmid)
1161                 enable = force_kipmid[new_smi->si_num];
1162         /*
1163          * The BT interface is efficient enough to not need a thread,
1164          * and there is no need for a thread if we have interrupts.
1165          */
1166         else if ((new_smi->io.si_type != SI_BT) && (!new_smi->io.irq))
1167                 enable = 1;
1168
1169         if (enable) {
1170                 new_smi->thread = kthread_run(ipmi_thread, new_smi,
1171                                               "kipmi%d", new_smi->si_num);
1172                 if (IS_ERR(new_smi->thread)) {
1173                         dev_notice(new_smi->io.dev,
1174                                    "Could not start kernel thread due to error %ld, only using timers to drive the interface\n",
1175                                    PTR_ERR(new_smi->thread));
1176                         new_smi->thread = NULL;
1177                 }
1178         }
1179
1180         return 0;
1181 }
1182
1183 static int get_smi_info(void *send_info, struct ipmi_smi_info *data)
1184 {
1185         struct smi_info *smi = send_info;
1186
1187         data->addr_src = smi->io.addr_source;
1188         data->dev = smi->io.dev;
1189         data->addr_info = smi->io.addr_info;
1190         get_device(smi->io.dev);
1191
1192         return 0;
1193 }
1194
1195 static void set_maintenance_mode(void *send_info, bool enable)
1196 {
1197         struct smi_info   *smi_info = send_info;
1198
1199         if (!enable)
1200                 atomic_set(&smi_info->req_events, 0);
1201         smi_info->in_maintenance_mode = enable;
1202 }
1203
1204 static void shutdown_smi(void *send_info);
1205 static const struct ipmi_smi_handlers handlers = {
1206         .owner                  = THIS_MODULE,
1207         .start_processing       = smi_start_processing,
1208         .shutdown               = shutdown_smi,
1209         .get_smi_info           = get_smi_info,
1210         .sender                 = sender,
1211         .request_events         = request_events,
1212         .set_need_watch         = set_need_watch,
1213         .set_maintenance_mode   = set_maintenance_mode,
1214         .set_run_to_completion  = set_run_to_completion,
1215         .flush_messages         = flush_messages,
1216         .poll                   = poll,
1217 };
1218
1219 static LIST_HEAD(smi_infos);
1220 static DEFINE_MUTEX(smi_infos_lock);
1221 static int smi_num; /* Used to sequence the SMIs */
1222
1223 static const char * const addr_space_to_str[] = { "i/o", "mem" };
1224
1225 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1226 MODULE_PARM_DESC(force_kipmid,
1227                  "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.");
1228 module_param(unload_when_empty, bool, 0);
1229 MODULE_PARM_DESC(unload_when_empty,
1230                  "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.");
1231 module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
1232 MODULE_PARM_DESC(kipmid_max_busy_us,
1233                  "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.");
1234
1235 void ipmi_irq_finish_setup(struct si_sm_io *io)
1236 {
1237         if (io->si_type == SI_BT)
1238                 /* Enable the interrupt in the BT interface. */
1239                 io->outputb(io, IPMI_BT_INTMASK_REG,
1240                             IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1241 }
1242
1243 void ipmi_irq_start_cleanup(struct si_sm_io *io)
1244 {
1245         if (io->si_type == SI_BT)
1246                 /* Disable the interrupt in the BT interface. */
1247                 io->outputb(io, IPMI_BT_INTMASK_REG, 0);
1248 }
1249
1250 static void std_irq_cleanup(struct si_sm_io *io)
1251 {
1252         ipmi_irq_start_cleanup(io);
1253         free_irq(io->irq, io->irq_handler_data);
1254 }
1255
1256 int ipmi_std_irq_setup(struct si_sm_io *io)
1257 {
1258         int rv;
1259
1260         if (!io->irq)
1261                 return 0;
1262
1263         rv = request_irq(io->irq,
1264                          ipmi_si_irq_handler,
1265                          IRQF_SHARED,
1266                          SI_DEVICE_NAME,
1267                          io->irq_handler_data);
1268         if (rv) {
1269                 dev_warn(io->dev, "%s unable to claim interrupt %d, running polled\n",
1270                          SI_DEVICE_NAME, io->irq);
1271                 io->irq = 0;
1272         } else {
1273                 io->irq_cleanup = std_irq_cleanup;
1274                 ipmi_irq_finish_setup(io);
1275                 dev_info(io->dev, "Using irq %d\n", io->irq);
1276         }
1277
1278         return rv;
1279 }
1280
1281 static int wait_for_msg_done(struct smi_info *smi_info)
1282 {
1283         enum si_sm_result     smi_result;
1284
1285         smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1286         for (;;) {
1287                 if (smi_result == SI_SM_CALL_WITH_DELAY ||
1288                     smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1289                         schedule_timeout_uninterruptible(1);
1290                         smi_result = smi_info->handlers->event(
1291                                 smi_info->si_sm, jiffies_to_usecs(1));
1292                 } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
1293                         smi_result = smi_info->handlers->event(
1294                                 smi_info->si_sm, 0);
1295                 } else
1296                         break;
1297         }
1298         if (smi_result == SI_SM_HOSED)
1299                 /*
1300                  * We couldn't get the state machine to run, so whatever's at
1301                  * the port is probably not an IPMI SMI interface.
1302                  */
1303                 return -ENODEV;
1304
1305         return 0;
1306 }
1307
1308 static int try_get_dev_id(struct smi_info *smi_info)
1309 {
1310         unsigned char         msg[2];
1311         unsigned char         *resp;
1312         unsigned long         resp_len;
1313         int                   rv = 0;
1314         unsigned int          retry_count = 0;
1315
1316         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1317         if (!resp)
1318                 return -ENOMEM;
1319
1320         /*
1321          * Do a Get Device ID command, since it comes back with some
1322          * useful info.
1323          */
1324         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1325         msg[1] = IPMI_GET_DEVICE_ID_CMD;
1326
1327 retry:
1328         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1329
1330         rv = wait_for_msg_done(smi_info);
1331         if (rv)
1332                 goto out;
1333
1334         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1335                                                   resp, IPMI_MAX_MSG_LENGTH);
1336
1337         /* Check and record info from the get device id, in case we need it. */
1338         rv = ipmi_demangle_device_id(resp[0] >> 2, resp[1],
1339                         resp + 2, resp_len - 2, &smi_info->device_id);
1340         if (rv) {
1341                 /* record completion code */
1342                 unsigned char cc = *(resp + 2);
1343
1344                 if (cc != IPMI_CC_NO_ERROR &&
1345                     ++retry_count <= GET_DEVICE_ID_MAX_RETRY) {
1346                         dev_warn(smi_info->io.dev,
1347                             "BMC returned 0x%2.2x, retry get bmc device id\n",
1348                             cc);
1349                         goto retry;
1350                 }
1351         }
1352
1353 out:
1354         kfree(resp);
1355         return rv;
1356 }
1357
1358 static int get_global_enables(struct smi_info *smi_info, u8 *enables)
1359 {
1360         unsigned char         msg[3];
1361         unsigned char         *resp;
1362         unsigned long         resp_len;
1363         int                   rv;
1364
1365         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1366         if (!resp)
1367                 return -ENOMEM;
1368
1369         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1370         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
1371         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1372
1373         rv = wait_for_msg_done(smi_info);
1374         if (rv) {
1375                 dev_warn(smi_info->io.dev,
1376                          "Error getting response from get global enables command: %d\n",
1377                          rv);
1378                 goto out;
1379         }
1380
1381         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1382                                                   resp, IPMI_MAX_MSG_LENGTH);
1383
1384         if (resp_len < 4 ||
1385                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1386                         resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD   ||
1387                         resp[2] != 0) {
1388                 dev_warn(smi_info->io.dev,
1389                          "Invalid return from get global enables command: %ld %x %x %x\n",
1390                          resp_len, resp[0], resp[1], resp[2]);
1391                 rv = -EINVAL;
1392                 goto out;
1393         } else {
1394                 *enables = resp[3];
1395         }
1396
1397 out:
1398         kfree(resp);
1399         return rv;
1400 }
1401
1402 /*
1403  * Returns 1 if it gets an error from the command.
1404  */
1405 static int set_global_enables(struct smi_info *smi_info, u8 enables)
1406 {
1407         unsigned char         msg[3];
1408         unsigned char         *resp;
1409         unsigned long         resp_len;
1410         int                   rv;
1411
1412         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1413         if (!resp)
1414                 return -ENOMEM;
1415
1416         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1417         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
1418         msg[2] = enables;
1419         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
1420
1421         rv = wait_for_msg_done(smi_info);
1422         if (rv) {
1423                 dev_warn(smi_info->io.dev,
1424                          "Error getting response from set global enables command: %d\n",
1425                          rv);
1426                 goto out;
1427         }
1428
1429         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1430                                                   resp, IPMI_MAX_MSG_LENGTH);
1431
1432         if (resp_len < 3 ||
1433                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1434                         resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
1435                 dev_warn(smi_info->io.dev,
1436                          "Invalid return from set global enables command: %ld %x %x\n",
1437                          resp_len, resp[0], resp[1]);
1438                 rv = -EINVAL;
1439                 goto out;
1440         }
1441
1442         if (resp[2] != 0)
1443                 rv = 1;
1444
1445 out:
1446         kfree(resp);
1447         return rv;
1448 }
1449
1450 /*
1451  * Some BMCs do not support clearing the receive irq bit in the global
1452  * enables (even if they don't support interrupts on the BMC).  Check
1453  * for this and handle it properly.
1454  */
1455 static void check_clr_rcv_irq(struct smi_info *smi_info)
1456 {
1457         u8 enables = 0;
1458         int rv;
1459
1460         rv = get_global_enables(smi_info, &enables);
1461         if (!rv) {
1462                 if ((enables & IPMI_BMC_RCV_MSG_INTR) == 0)
1463                         /* Already clear, should work ok. */
1464                         return;
1465
1466                 enables &= ~IPMI_BMC_RCV_MSG_INTR;
1467                 rv = set_global_enables(smi_info, enables);
1468         }
1469
1470         if (rv < 0) {
1471                 dev_err(smi_info->io.dev,
1472                         "Cannot check clearing the rcv irq: %d\n", rv);
1473                 return;
1474         }
1475
1476         if (rv) {
1477                 /*
1478                  * An error when setting the event buffer bit means
1479                  * clearing the bit is not supported.
1480                  */
1481                 dev_warn(smi_info->io.dev,
1482                          "The BMC does not support clearing the recv irq bit, compensating, but the BMC needs to be fixed.\n");
1483                 smi_info->cannot_disable_irq = true;
1484         }
1485 }
1486
1487 /*
1488  * Some BMCs do not support setting the interrupt bits in the global
1489  * enables even if they support interrupts.  Clearly bad, but we can
1490  * compensate.
1491  */
1492 static void check_set_rcv_irq(struct smi_info *smi_info)
1493 {
1494         u8 enables = 0;
1495         int rv;
1496
1497         if (!smi_info->io.irq)
1498                 return;
1499
1500         rv = get_global_enables(smi_info, &enables);
1501         if (!rv) {
1502                 enables |= IPMI_BMC_RCV_MSG_INTR;
1503                 rv = set_global_enables(smi_info, enables);
1504         }
1505
1506         if (rv < 0) {
1507                 dev_err(smi_info->io.dev,
1508                         "Cannot check setting the rcv irq: %d\n", rv);
1509                 return;
1510         }
1511
1512         if (rv) {
1513                 /*
1514                  * An error when setting the event buffer bit means
1515                  * setting the bit is not supported.
1516                  */
1517                 dev_warn(smi_info->io.dev,
1518                          "The BMC does not support setting the recv irq bit, compensating, but the BMC needs to be fixed.\n");
1519                 smi_info->cannot_disable_irq = true;
1520                 smi_info->irq_enable_broken = true;
1521         }
1522 }
1523
1524 static int try_enable_event_buffer(struct smi_info *smi_info)
1525 {
1526         unsigned char         msg[3];
1527         unsigned char         *resp;
1528         unsigned long         resp_len;
1529         int                   rv = 0;
1530
1531         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1532         if (!resp)
1533                 return -ENOMEM;
1534
1535         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1536         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
1537         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1538
1539         rv = wait_for_msg_done(smi_info);
1540         if (rv) {
1541                 pr_warn("Error getting response from get global enables command, the event buffer is not enabled\n");
1542                 goto out;
1543         }
1544
1545         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1546                                                   resp, IPMI_MAX_MSG_LENGTH);
1547
1548         if (resp_len < 4 ||
1549                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1550                         resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD   ||
1551                         resp[2] != 0) {
1552                 pr_warn("Invalid return from get global enables command, cannot enable the event buffer\n");
1553                 rv = -EINVAL;
1554                 goto out;
1555         }
1556
1557         if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) {
1558                 /* buffer is already enabled, nothing to do. */
1559                 smi_info->supports_event_msg_buff = true;
1560                 goto out;
1561         }
1562
1563         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1564         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
1565         msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF;
1566         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
1567
1568         rv = wait_for_msg_done(smi_info);
1569         if (rv) {
1570                 pr_warn("Error getting response from set global, enables command, the event buffer is not enabled\n");
1571                 goto out;
1572         }
1573
1574         resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1575                                                   resp, IPMI_MAX_MSG_LENGTH);
1576
1577         if (resp_len < 3 ||
1578                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1579                         resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
1580                 pr_warn("Invalid return from get global, enables command, not enable the event buffer\n");
1581                 rv = -EINVAL;
1582                 goto out;
1583         }
1584
1585         if (resp[2] != 0)
1586                 /*
1587                  * An error when setting the event buffer bit means
1588                  * that the event buffer is not supported.
1589                  */
1590                 rv = -ENOENT;
1591         else
1592                 smi_info->supports_event_msg_buff = true;
1593
1594 out:
1595         kfree(resp);
1596         return rv;
1597 }
1598
1599 #define IPMI_SI_ATTR(name) \
1600 static ssize_t name##_show(struct device *dev,                  \
1601                            struct device_attribute *attr,               \
1602                            char *buf)                                   \
1603 {                                                                       \
1604         struct smi_info *smi_info = dev_get_drvdata(dev);               \
1605                                                                         \
1606         return snprintf(buf, 10, "%u\n", smi_get_stat(smi_info, name)); \
1607 }                                                                       \
1608 static DEVICE_ATTR(name, 0444, name##_show, NULL)
1609
1610 static ssize_t type_show(struct device *dev,
1611                          struct device_attribute *attr,
1612                          char *buf)
1613 {
1614         struct smi_info *smi_info = dev_get_drvdata(dev);
1615
1616         return snprintf(buf, 10, "%s\n", si_to_str[smi_info->io.si_type]);
1617 }
1618 static DEVICE_ATTR(type, 0444, type_show, NULL);
1619
1620 static ssize_t interrupts_enabled_show(struct device *dev,
1621                                        struct device_attribute *attr,
1622                                        char *buf)
1623 {
1624         struct smi_info *smi_info = dev_get_drvdata(dev);
1625         int enabled = smi_info->io.irq && !smi_info->interrupt_disabled;
1626
1627         return snprintf(buf, 10, "%d\n", enabled);
1628 }
1629 static DEVICE_ATTR(interrupts_enabled, 0444,
1630                    interrupts_enabled_show, NULL);
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 snprintf(buf, 200,
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(params, 0444, params_show, NULL);
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
2225         if (smi_info->intf)
2226                 ipmi_unregister_smi(smi_info->intf);
2227
2228         kfree(smi_info);
2229 }
2230
2231 void ipmi_si_remove_by_dev(struct device *dev)
2232 {
2233         struct smi_info *e;
2234
2235         mutex_lock(&smi_infos_lock);
2236         list_for_each_entry(e, &smi_infos, link) {
2237                 if (e->io.dev == dev) {
2238                         cleanup_one_si(e);
2239                         break;
2240                 }
2241         }
2242         mutex_unlock(&smi_infos_lock);
2243 }
2244
2245 struct device *ipmi_si_remove_by_data(int addr_space, enum si_type si_type,
2246                                       unsigned long addr)
2247 {
2248         /* remove */
2249         struct smi_info *e, *tmp_e;
2250         struct device *dev = NULL;
2251
2252         mutex_lock(&smi_infos_lock);
2253         list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
2254                 if (e->io.addr_space != addr_space)
2255                         continue;
2256                 if (e->io.si_type != si_type)
2257                         continue;
2258                 if (e->io.addr_data == addr) {
2259                         dev = get_device(e->io.dev);
2260                         cleanup_one_si(e);
2261                 }
2262         }
2263         mutex_unlock(&smi_infos_lock);
2264
2265         return dev;
2266 }
2267
2268 static void cleanup_ipmi_si(void)
2269 {
2270         struct smi_info *e, *tmp_e;
2271
2272         if (!initialized)
2273                 return;
2274
2275         ipmi_si_pci_shutdown();
2276
2277         ipmi_si_parisc_shutdown();
2278
2279         ipmi_si_platform_shutdown();
2280
2281         mutex_lock(&smi_infos_lock);
2282         list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2283                 cleanup_one_si(e);
2284         mutex_unlock(&smi_infos_lock);
2285
2286         ipmi_si_hardcode_exit();
2287         ipmi_si_hotmod_exit();
2288 }
2289 module_exit(cleanup_ipmi_si);
2290
2291 MODULE_ALIAS("platform:dmi-ipmi-si");
2292 MODULE_LICENSE("GPL");
2293 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2294 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");