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	if (rv && new_smi->si_sm) {
2086		kfree(new_smi->si_sm);
2087		new_smi->si_sm = NULL;
2088	}
2089
2090	return rv;
2091}
2092
2093static int __init init_ipmi_si(void)
2094{
2095	struct smi_info *e;
2096	enum ipmi_addr_src type = SI_INVALID;
2097
2098	if (initialized)
2099		return 0;
2100
2101	ipmi_hardcode_init();
2102
2103	pr_info("IPMI System Interface driver\n");
2104
2105	ipmi_si_platform_init();
2106
2107	ipmi_si_pci_init();
2108
2109	ipmi_si_parisc_init();
2110
2111	/* We prefer devices with interrupts, but in the case of a machine
2112	   with multiple BMCs we assume that there will be several instances
2113	   of a given type so if we succeed in registering a type then also
2114	   try to register everything else of the same type */
2115	mutex_lock(&smi_infos_lock);
2116	list_for_each_entry(e, &smi_infos, link) {
2117		/* Try to register a device if it has an IRQ and we either
2118		   haven't successfully registered a device yet or this
2119		   device has the same type as one we successfully registered */
2120		if (e->io.irq && (!type || e->io.addr_source == type)) {
2121			if (!try_smi_init(e)) {
2122				type = e->io.addr_source;
2123			}
2124		}
2125	}
2126
2127	/* type will only have been set if we successfully registered an si */
2128	if (type)
2129		goto skip_fallback_noirq;
2130
2131	/* Fall back to the preferred device */
2132
2133	list_for_each_entry(e, &smi_infos, link) {
2134		if (!e->io.irq && (!type || e->io.addr_source == type)) {
2135			if (!try_smi_init(e)) {
2136				type = e->io.addr_source;
2137			}
2138		}
2139	}
2140
2141skip_fallback_noirq:
2142	initialized = true;
2143	mutex_unlock(&smi_infos_lock);
2144
2145	if (type)
2146		return 0;
2147
2148	mutex_lock(&smi_infos_lock);
2149	if (unload_when_empty && list_empty(&smi_infos)) {
2150		mutex_unlock(&smi_infos_lock);
2151		cleanup_ipmi_si();
2152		pr_warn("Unable to find any System Interface(s)\n");
2153		return -ENODEV;
2154	} else {
2155		mutex_unlock(&smi_infos_lock);
2156		return 0;
2157	}
2158}
2159module_init(init_ipmi_si);
2160
2161static void wait_msg_processed(struct smi_info *smi_info)
2162{
2163	unsigned long jiffies_now;
2164	long time_diff;
2165
2166	while (smi_info->curr_msg || (smi_info->si_state != SI_NORMAL)) {
2167		jiffies_now = jiffies;
2168		time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
2169		     * SI_USEC_PER_JIFFY);
2170		smi_event_handler(smi_info, time_diff);
2171		schedule_timeout_uninterruptible(1);
2172	}
2173}
2174
2175static void shutdown_smi(void *send_info)
2176{
2177	struct smi_info *smi_info = send_info;
2178
2179	if (smi_info->dev_group_added) {
2180		device_remove_group(smi_info->io.dev, &ipmi_si_dev_attr_group);
2181		smi_info->dev_group_added = false;
2182	}
2183	if (smi_info->io.dev)
2184		dev_set_drvdata(smi_info->io.dev, NULL);
2185
2186	/*
2187	 * Make sure that interrupts, the timer and the thread are
2188	 * stopped and will not run again.
2189	 */
2190	smi_info->interrupt_disabled = true;
2191	if (smi_info->io.irq_cleanup) {
2192		smi_info->io.irq_cleanup(&smi_info->io);
2193		smi_info->io.irq_cleanup = NULL;
2194	}
2195	stop_timer_and_thread(smi_info);
2196
2197	/*
2198	 * Wait until we know that we are out of any interrupt
2199	 * handlers might have been running before we freed the
2200	 * interrupt.
2201	 */
2202	synchronize_rcu();
2203
2204	/*
2205	 * Timeouts are stopped, now make sure the interrupts are off
2206	 * in the BMC.  Note that timers and CPU interrupts are off,
2207	 * so no need for locks.
2208	 */
2209	wait_msg_processed(smi_info);
2210
 
 
2211	if (smi_info->handlers)
2212		disable_si_irq(smi_info);
2213
2214	wait_msg_processed(smi_info);
2215
 
2216	if (smi_info->handlers)
2217		smi_info->handlers->cleanup(smi_info->si_sm);
2218
 
 
 
 
2219	if (smi_info->io.io_cleanup) {
2220		smi_info->io.io_cleanup(&smi_info->io);
2221		smi_info->io.io_cleanup = NULL;
2222	}
2223
2224	kfree(smi_info->si_sm);
2225	smi_info->si_sm = NULL;
2226
2227	smi_info->intf = NULL;
2228}
2229
2230/*
2231 * Must be called with smi_infos_lock held, to serialize the
2232 * smi_info->intf check.
2233 */
2234static void cleanup_one_si(struct smi_info *smi_info)
2235{
2236	if (!smi_info)
2237		return;
2238
2239	list_del(&smi_info->link);
2240	ipmi_unregister_smi(smi_info->intf);
 
 
 
2241	kfree(smi_info);
2242}
2243
2244void ipmi_si_remove_by_dev(struct device *dev)
2245{
2246	struct smi_info *e;
 
2247
2248	mutex_lock(&smi_infos_lock);
2249	list_for_each_entry(e, &smi_infos, link) {
2250		if (e->io.dev == dev) {
2251			cleanup_one_si(e);
 
2252			break;
2253		}
2254	}
2255	mutex_unlock(&smi_infos_lock);
 
 
2256}
2257
2258struct device *ipmi_si_remove_by_data(int addr_space, enum si_type si_type,
2259				      unsigned long addr)
2260{
2261	/* remove */
2262	struct smi_info *e, *tmp_e;
2263	struct device *dev = NULL;
2264
2265	mutex_lock(&smi_infos_lock);
2266	list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
2267		if (e->io.addr_space != addr_space)
2268			continue;
2269		if (e->io.si_type != si_type)
2270			continue;
2271		if (e->io.addr_data == addr) {
2272			dev = get_device(e->io.dev);
2273			cleanup_one_si(e);
2274		}
2275	}
2276	mutex_unlock(&smi_infos_lock);
2277
2278	return dev;
2279}
2280
2281static void cleanup_ipmi_si(void)
2282{
2283	struct smi_info *e, *tmp_e;
2284
2285	if (!initialized)
2286		return;
2287
2288	ipmi_si_pci_shutdown();
2289
2290	ipmi_si_parisc_shutdown();
2291
2292	ipmi_si_platform_shutdown();
2293
2294	mutex_lock(&smi_infos_lock);
2295	list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2296		cleanup_one_si(e);
2297	mutex_unlock(&smi_infos_lock);
2298
2299	ipmi_si_hardcode_exit();
2300	ipmi_si_hotmod_exit();
2301}
2302module_exit(cleanup_ipmi_si);
2303
2304MODULE_ALIAS("platform:dmi-ipmi-si");
2305MODULE_LICENSE("GPL");
2306MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2307MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");