cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

ipmi_si_intf.c (60151B)


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