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