drivers/char/ipmi/ipmi_si_intf.c

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