1	// SPDX-License-Identifier: GPL-2.0+
2	/*
3	* ipmi_si.c
4	*
5	* The interface to the IPMI driver for the system interfaces (KCS, SMIC,
6	* BT).
7	*
8	* Author: MontaVista Software, Inc.
9	* Corey Minyard <minyard@mvista.com>
10	* source@mvista.com
11	*
12	* Copyright 2002 MontaVista Software Inc.
13	* Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
14	*/
15
16	/*
17	* This file holds the "policy" for the interface to the SMI state
18	* machine. It does the configuration, handles timers and interrupts,
19	* and drives the real SMI state machine.
20	*/
21
22	#define pr_fmt(fmt) "ipmi_si: " fmt
23
24	#include <linux/module.h>
25	#include <linux/moduleparam.h>
26	#include <linux/sched.h>
27	#include <linux/seq_file.h>
28	#include <linux/timer.h>
29	#include <linux/errno.h>
30	#include <linux/spinlock.h>
31	#include <linux/slab.h>
32	#include <linux/delay.h>
33	#include <linux/list.h>
34	#include <linux/notifier.h>
35	#include <linux/mutex.h>
36	#include <linux/kthread.h>
37	#include <asm/irq.h>
38	#include <linux/interrupt.h>
39	#include <linux/rcupdate.h>
40	#include <linux/ipmi.h>
41	#include <linux/ipmi_smi.h>
42	#include "ipmi_si.h"
43	#include "ipmi_si_sm.h"
44	#include <linux/string.h>
45	#include <linux/ctype.h>
46
47	/* Measure times between events in the driver. */
48	#undef DEBUG_TIMING
49
50	/* Call every 10 ms. */
51	#define SI_TIMEOUT_TIME_USEC 10000
52	#define SI_USEC_PER_JIFFY (1000000/HZ)
53	#define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
54	#define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
55	short timeout */
56
57	enum si_intf_state {
58	SI_NORMAL,
59	SI_GETTING_FLAGS,
60	SI_GETTING_EVENTS,
61	SI_CLEARING_FLAGS,
62	SI_GETTING_MESSAGES,
63	SI_CHECKING_ENABLES,
64	SI_SETTING_ENABLES
65	/* FIXME - add watchdog stuff. */
66	};
67
68	/* Some BT-specific defines we need here. */
69	#define IPMI_BT_INTMASK_REG 2
70	#define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
71	#define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
72
73	/* 'invalid' to allow a firmware-specified interface to be disabled */
74	const char *const si_to_str[] = { "invalid", "kcs", "smic", "bt", NULL };
75
76	static bool initialized;
77
78	/*
79	* Indexes into stats[] in smi_info below.
80	*/
81	enum si_stat_indexes {
82	/*
83	* Number of times the driver requested a timer while an operation
84	* was in progress.
85	*/
86	SI_STAT_short_timeouts = 0,
87
88	/*
89	* Number of times the driver requested a timer while nothing was in
90	* progress.
91	*/
92	SI_STAT_long_timeouts,
93
94	/* Number of times the interface was idle while being polled. */
95	SI_STAT_idles,
96
97	/* Number of interrupts the driver handled. */
98	SI_STAT_interrupts,
99
100	/* Number of time the driver got an ATTN from the hardware. */
101	SI_STAT_attentions,
102
103	/* Number of times the driver requested flags from the hardware. */
104	SI_STAT_flag_fetches,
105
106	/* Number of times the hardware didn't follow the state machine. */
107	SI_STAT_hosed_count,
108
109	/* Number of completed messages. */
110	SI_STAT_complete_transactions,
111
112	/* Number of IPMI events received from the hardware. */
113	SI_STAT_events,
114
115	/* Number of watchdog pretimeouts. */
116	SI_STAT_watchdog_pretimeouts,
117
118	/* Number of asynchronous messages received. */
119	SI_STAT_incoming_messages,
120
121
122	/* This *must* remain last, add new values above this. */
123	SI_NUM_STATS
124	};
125
126	struct smi_info {
127	int si_num;
128	struct ipmi_smi *intf;
129	struct si_sm_data *si_sm;
130	const struct si_sm_handlers *handlers;
131	spinlock_t si_lock;
132	struct ipmi_smi_msg *waiting_msg;
133	struct ipmi_smi_msg *curr_msg;
134	enum si_intf_state si_state;
135
136	/*
137	* Used to handle the various types of I/O that can occur with
138	* IPMI
139	*/
140	struct si_sm_io io;
141
142	/*
143	* Per-OEM handler, called from handle_flags(). Returns 1
144	* when handle_flags() needs to be re-run or 0 indicating it
145	* set si_state itself.
146	*/
147	int (*oem_data_avail_handler)(struct smi_info *smi_info);
148
149	/*
150	* Flags from the last GET_MSG_FLAGS command, used when an ATTN
151	* is set to hold the flags until we are done handling everything
152	* from the flags.
153	*/
154	#define RECEIVE_MSG_AVAIL 0x01
155	#define EVENT_MSG_BUFFER_FULL 0x02
156	#define WDT_PRE_TIMEOUT_INT 0x08
157	#define OEM0_DATA_AVAIL 0x20
158	#define OEM1_DATA_AVAIL 0x40
159	#define OEM2_DATA_AVAIL 0x80
160	#define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
161	OEM1_DATA_AVAIL | \
162	OEM2_DATA_AVAIL)
163	unsigned char msg_flags;
164
165	/* Does the BMC have an event buffer? */
166	bool has_event_buffer;
167
168	/*
169	* If set to true, this will request events the next time the
170	* state machine is idle.
171	*/
172	atomic_t req_events;
173
174	/*
175	* If true, run the state machine to completion on every send
176	* call. Generally used after a panic to make sure stuff goes
177	* out.
178	*/
179	bool run_to_completion;
180
181	/* The timer for this si. */
182	struct timer_list si_timer;
183
184	/* This flag is set, if the timer can be set */
185	bool timer_can_start;
186
187	/* This flag is set, if the timer is running (timer_pending() isn't enough) */
188	bool timer_running;
189
190	/* The time (in jiffies) the last timeout occurred at. */
191	unsigned long last_timeout_jiffies;
192
193	/* Are we waiting for the events, pretimeouts, received msgs? */
194	atomic_t need_watch;
195
196	/*
197	* The driver will disable interrupts when it gets into a
198	* situation where it cannot handle messages due to lack of
199	* memory. Once that situation clears up, it will re-enable
200	* interrupts.
201	*/
202	bool interrupt_disabled;
203
204	/*
205	* Does the BMC support events?
206	*/
207	bool supports_event_msg_buff;
208
209	/*
210	* Can we disable interrupts the global enables receive irq
211	* bit? There are currently two forms of brokenness, some
212	* systems cannot disable the bit (which is technically within
213	* the spec but a bad idea) and some systems have the bit
214	* forced to zero even though interrupts work (which is
215	* clearly outside the spec). The next bool tells which form
216	* of brokenness is present.
217	*/
218	bool cannot_disable_irq;
219
220	/*
221	* Some systems are broken and cannot set the irq enable
222	* bit, even if they support interrupts.
223	*/
224	bool irq_enable_broken;
225
226	/* Is the driver in maintenance mode? */
227	bool in_maintenance_mode;
228
229	/*
230	* Did we get an attention that we did not handle?
231	*/
232	bool got_attn;
233
234	/* From the get device id response... */
235	struct ipmi_device_id device_id;
236
237	/* Have we added the device group to the device? */
238	bool dev_group_added;
239
240	/* Counters and things for the proc filesystem. */
241	atomic_t stats[SI_NUM_STATS];
242
243	struct task_struct *thread;
244
245	struct list_head link;
246	};
247
248	#define smi_inc_stat(smi, stat) \
249	atomic_inc(&(smi)->stats[SI_STAT_ ## stat])
250	#define smi_get_stat(smi, stat) \
251	((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat]))
252
253	#define IPMI_MAX_INTFS 4
254	static int force_kipmid[IPMI_MAX_INTFS];
255	static int num_force_kipmid;
256
257	static unsigned int kipmid_max_busy_us[IPMI_MAX_INTFS];
258	static int num_max_busy_us;
259
260	static bool unload_when_empty = true;
261
262	static int try_smi_init(struct smi_info *smi);
263	static void cleanup_one_si(struct smi_info *smi_info);
264	static void cleanup_ipmi_si(void);
265
266	#ifdef DEBUG_TIMING
267	void debug_timestamp(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
279	static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
280	static int register_xaction_notifier(struct notifier_block *nb)
281	{
282	return atomic_notifier_chain_register(nh: &xaction_notifier_list, nb);
283	}
284
285	static 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(intf: smi_info->intf, msg);
290	}
291
292	static 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
310	static 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(nh: &xaction_notifier_list,
324	val: 0, v: 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, cCode: err);
335
336	rv = SI_SM_CALL_WITHOUT_DELAY;
337	}
338	out:
339	return rv;
340	}
341
342	static 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(timer: &smi_info->si_timer, expires: new_val);
348	smi_info->timer_running = true;
349	}
350
351	/*
352	* Start a new message and (re)start the timer and thread.
353	*/
354	static void start_new_msg(struct smi_info *smi_info, unsigned char *msg,
355	unsigned int size)
356	{
357	smi_mod_timer(smi_info, new_val: jiffies + SI_TIMEOUT_JIFFIES);
358
359	if (smi_info->thread)
360	wake_up_process(tsk: smi_info->thread);
361
362	smi_info->handlers->start_transaction(smi_info->si_sm, msg, size);
363	}
364
365	static 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, size: 2);
373	smi_info->si_state = SI_CHECKING_ENABLES;
374	}
375
376	static 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, size: 3);
386	smi_info->si_state = SI_CLEARING_FLAGS;
387	}
388
389	static 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, msg: smi_info->curr_msg->data,
396	size: smi_info->curr_msg->data_size);
397	smi_info->si_state = SI_GETTING_MESSAGES;
398	}
399
400	static 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, msg: smi_info->curr_msg->data,
407	size: 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	*/
420	static 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
430	static 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	*/
446	static 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
461	static void handle_flags(struct smi_info *smi_info)
462	{
463	retry:
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(intf: 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
499	static 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
522	static 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
538	static 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, base: 0, irq_on: &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	*/
749	static 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
754	restart:
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, size: 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(v: &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(v: &smi_info->req_events, i: 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(timer: &smi_info->si_timer))
863	smi_info->timer_running = false;
864	}
865
866	out:
867	return si_sm_result;
868	}
869
870	static 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, new_val: jiffies + SI_TIMEOUT_JIFFIES);
874
875	if (smi_info->thread)
876	wake_up_process(tsk: smi_info->thread);
877
878	start_next_msg(smi_info);
879	smi_event_handler(smi_info, time: 0);
880	}
881	}
882
883	static 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, time: 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
899	static 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(lock: &smi_info->si_lock, flags);
928	}
929
930	static 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(send_info: 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)
944	static 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	*/
975	static 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, time: 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, new_val: jiffies + SI_TIMEOUT_JIFFIES);
998
999	spin_unlock_irqrestore(lock: &(smi_info->si_lock), flags);
1000	busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
1001	busy_until: &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(min: 100, max: 200);
1015	} else if (smi_result == SI_SM_IDLE) {
1016	if (atomic_read(v: &smi_info->need_watch)) {
1017	schedule_timeout_interruptible(timeout: 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(timeout: 1);
1025	}
1026	}
1027	return 0;
1028	}
1029
1030
1031	static 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, time: 10);
1045	if (!run_to_completion)
1046	spin_unlock_irqrestore(lock: &smi_info->si_lock, flags);
1047	}
1048
1049	static 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(v: &smi_info->req_events, i: 1);
1057	}
1058
1059	static 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(v: &smi_info->need_watch, i: enable);
1068	spin_lock_irqsave(&smi_info->si_lock, flags);
1069	check_start_timer_thread(smi_info);
1070	spin_unlock_irqrestore(lock: &smi_info->si_lock, flags);
1071	}
1072
1073	static 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: 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
1109	do_mod_timer:
1110	if (smi_result != SI_SM_IDLE)
1111	smi_mod_timer(smi_info, new_val: timeout);
1112	else
1113	smi_info->timer_running = false;
1114	spin_unlock_irqrestore(lock: &(smi_info->si_lock), flags);
1115	}
1116
1117	irqreturn_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, time: 0);
1135	spin_unlock_irqrestore(lock: &(smi_info->si_lock), flags);
1136	return IRQ_HANDLED;
1137	}
1138
1139	static 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(smi_info: new_smi, new_val: 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(ptr: 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
1184	static 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(dev: smi->io.dev);
1192
1193	return 0;
1194	}
1195
1196	static 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(v: &smi_info->req_events, i: 0);
1202	smi_info->in_maintenance_mode = enable;
1203	}
1204
1205	static void shutdown_smi(void *send_info);
1206	static 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
1220	static LIST_HEAD(smi_infos);
1221	static DEFINE_MUTEX(smi_infos_lock);
1222	static int smi_num; /* Used to sequence the SMIs */
1223
1224	static const char * const addr_space_to_str[] = { "i/o", "mem" };
1225
1226	module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1227	MODULE_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.");
1229	module_param(unload_when_empty, bool, 0);
1230	MODULE_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.");
1232	module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
1233	MODULE_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
1236	void 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
1244	void 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
1251	static 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
1257	int 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(irq: io->irq,
1265	handler: ipmi_si_irq_handler,
1266	IRQF_SHARED,
1267	SI_DEVICE_NAME,
1268	dev: 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
1282	static 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(timeout: 1);
1291	smi_result = smi_info->handlers->event(
1292	smi_info->si_sm, jiffies_to_usecs(j: 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
1309	static 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
1328	retry:
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(netfn: resp[0] >> 2, cmd: resp[1],
1340	data: resp + 2, data_len: resp_len - 2, id: &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
1354	out:
1355	kfree(objp: resp);
1356	return rv;
1357	}
1358
1359	static 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
1398	out:
1399	kfree(objp: resp);
1400	return rv;
1401	}
1402
1403	/*
1404	* Returns 1 if it gets an error from the command.
1405	*/
1406	static 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
1446	out:
1447	kfree(objp: 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	*/
1456	static 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: &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	*/
1493	static 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: &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
1525	static 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
1595	out:
1596	kfree(objp: resp);
1597	return rv;
1598	}
1599
1600	#define IPMI_SI_ATTR(name) \
1601	static 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	} \
1609	static DEVICE_ATTR_RO(name)
1610
1611	static 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, fmt: "%s\n", si_to_str[smi_info->io.si_type]);
1618	}
1619	static DEVICE_ATTR_RO(type);
1620
1621	static 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, fmt: "%d\n", enabled);
1629	}
1630	static DEVICE_ATTR_RO(interrupts_enabled);
1631
1632	IPMI_SI_ATTR(short_timeouts);
1633	IPMI_SI_ATTR(long_timeouts);
1634	IPMI_SI_ATTR(idles);
1635	IPMI_SI_ATTR(interrupts);
1636	IPMI_SI_ATTR(attentions);
1637	IPMI_SI_ATTR(flag_fetches);
1638	IPMI_SI_ATTR(hosed_count);
1639	IPMI_SI_ATTR(complete_transactions);
1640	IPMI_SI_ATTR(events);
1641	IPMI_SI_ATTR(watchdog_pretimeouts);
1642	IPMI_SI_ATTR(incoming_messages);
1643
1644	static ssize_t params_show(struct device *dev,
1645	struct device_attribute *attr,
1646	char *buf)
1647	{
1648	struct smi_info *smi_info = dev_get_drvdata(dev);
1649
1650	return sysfs_emit(buf,
1651	fmt: "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
1652	si_to_str[smi_info->io.si_type],
1653	addr_space_to_str[smi_info->io.addr_space],
1654	smi_info->io.addr_data,
1655	smi_info->io.regspacing,
1656	smi_info->io.regsize,
1657	smi_info->io.regshift,
1658	smi_info->io.irq,
1659	smi_info->io.slave_addr);
1660	}
1661	static DEVICE_ATTR_RO(params);
1662
1663	static struct attribute *ipmi_si_dev_attrs[] = {
1664	&dev_attr_type.attr,
1665	&dev_attr_interrupts_enabled.attr,
1666	&dev_attr_short_timeouts.attr,
1667	&dev_attr_long_timeouts.attr,
1668	&dev_attr_idles.attr,
1669	&dev_attr_interrupts.attr,
1670	&dev_attr_attentions.attr,
1671	&dev_attr_flag_fetches.attr,
1672	&dev_attr_hosed_count.attr,
1673	&dev_attr_complete_transactions.attr,
1674	&dev_attr_events.attr,
1675	&dev_attr_watchdog_pretimeouts.attr,
1676	&dev_attr_incoming_messages.attr,
1677	&dev_attr_params.attr,
1678	NULL
1679	};
1680
1681	static const struct attribute_group ipmi_si_dev_attr_group = {
1682	.attrs = ipmi_si_dev_attrs,
1683	};
1684
1685	/*
1686	* oem_data_avail_to_receive_msg_avail
1687	* @info - smi_info structure with msg_flags set
1688	*
1689	* Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
1690	* Returns 1 indicating need to re-run handle_flags().
1691	*/
1692	static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
1693	{
1694	smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
1695	RECEIVE_MSG_AVAIL);
1696	return 1;
1697	}
1698
1699	/*
1700	* setup_dell_poweredge_oem_data_handler
1701	* @info - smi_info.device_id must be populated
1702	*
1703	* Systems that match, but have firmware version < 1.40 may assert
1704	* OEM0_DATA_AVAIL on their own, without being told via Set Flags that
1705	* it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
1706	* upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
1707	* as RECEIVE_MSG_AVAIL instead.
1708	*
1709	* As Dell has no plans to release IPMI 1.5 firmware that *ever*
1710	* assert the OEM[012] bits, and if it did, the driver would have to
1711	* change to handle that properly, we don't actually check for the
1712	* firmware version.
1713	* Device ID = 0x20 BMC on PowerEdge 8G servers
1714	* Device Revision = 0x80
1715	* Firmware Revision1 = 0x01 BMC version 1.40
1716	* Firmware Revision2 = 0x40 BCD encoded
1717	* IPMI Version = 0x51 IPMI 1.5
1718	* Manufacturer ID = A2 02 00 Dell IANA
1719	*
1720	* Additionally, PowerEdge systems with IPMI < 1.5 may also assert
1721	* OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
1722	*
1723	*/
1724	#define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
1725	#define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
1726	#define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
1727	#define DELL_IANA_MFR_ID 0x0002a2
1728	static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
1729	{
1730	struct ipmi_device_id *id = &smi_info->device_id;
1731	if (id->manufacturer_id == DELL_IANA_MFR_ID) {
1732	if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
1733	id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
1734	id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
1735	smi_info->oem_data_avail_handler =
1736	oem_data_avail_to_receive_msg_avail;
1737	} else if (ipmi_version_major(id) < 1 ||
1738	(ipmi_version_major(id) == 1 &&
1739	ipmi_version_minor(id) < 5)) {
1740	smi_info->oem_data_avail_handler =
1741	oem_data_avail_to_receive_msg_avail;
1742	}
1743	}
1744	}
1745
1746	#define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
1747	static void return_hosed_msg_badsize(struct smi_info *smi_info)
1748	{
1749	struct ipmi_smi_msg *msg = smi_info->curr_msg;
1750
1751	/* Make it a response */
1752	msg->rsp[0] = msg->data[0] | 4;
1753	msg->rsp[1] = msg->data[1];
1754	msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
1755	msg->rsp_size = 3;
1756	smi_info->curr_msg = NULL;
1757	deliver_recv_msg(smi_info, msg);
1758	}
1759
1760	/*
1761	* dell_poweredge_bt_xaction_handler
1762	* @info - smi_info.device_id must be populated
1763	*
1764	* Dell PowerEdge servers with the BT interface (x6xx and 1750) will
1765	* not respond to a Get SDR command if the length of the data
1766	* requested is exactly 0x3A, which leads to command timeouts and no
1767	* data returned. This intercepts such commands, and causes userspace
1768	* callers to try again with a different-sized buffer, which succeeds.
1769	*/
1770
1771	#define STORAGE_NETFN 0x0A
1772	#define STORAGE_CMD_GET_SDR 0x23
1773	static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
1774	unsigned long unused,
1775	void *in)
1776	{
1777	struct smi_info *smi_info = in;
1778	unsigned char *data = smi_info->curr_msg->data;
1779	unsigned int size = smi_info->curr_msg->data_size;
1780	if (size >= 8 &&
1781	(data[0]>>2) == STORAGE_NETFN &&
1782	data[1] == STORAGE_CMD_GET_SDR &&
1783	data[7] == 0x3A) {
1784	return_hosed_msg_badsize(smi_info);
1785	return NOTIFY_STOP;
1786	}
1787	return NOTIFY_DONE;
1788	}
1789
1790	static struct notifier_block dell_poweredge_bt_xaction_notifier = {
1791	.notifier_call = dell_poweredge_bt_xaction_handler,
1792	};
1793
1794	/*
1795	* setup_dell_poweredge_bt_xaction_handler
1796	* @info - smi_info.device_id must be filled in already
1797	*
1798	* Fills in smi_info.device_id.start_transaction_pre_hook
1799	* when we know what function to use there.
1800	*/
1801	static void
1802	setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
1803	{
1804	struct ipmi_device_id *id = &smi_info->device_id;
1805	if (id->manufacturer_id == DELL_IANA_MFR_ID &&
1806	smi_info->io.si_type == SI_BT)
1807	register_xaction_notifier(nb: &dell_poweredge_bt_xaction_notifier);
1808	}
1809
1810	/*
1811	* setup_oem_data_handler
1812	* @info - smi_info.device_id must be filled in already
1813	*
1814	* Fills in smi_info.device_id.oem_data_available_handler
1815	* when we know what function to use there.
1816	*/
1817
1818	static void setup_oem_data_handler(struct smi_info *smi_info)
1819	{
1820	setup_dell_poweredge_oem_data_handler(smi_info);
1821	}
1822
1823	static void setup_xaction_handlers(struct smi_info *smi_info)
1824	{
1825	setup_dell_poweredge_bt_xaction_handler(smi_info);
1826	}
1827
1828	static void check_for_broken_irqs(struct smi_info *smi_info)
1829	{
1830	check_clr_rcv_irq(smi_info);
1831	check_set_rcv_irq(smi_info);
1832	}
1833
1834	static inline void stop_timer_and_thread(struct smi_info *smi_info)
1835	{
1836	if (smi_info->thread != NULL) {
1837	kthread_stop(k: smi_info->thread);
1838	smi_info->thread = NULL;
1839	}
1840
1841	smi_info->timer_can_start = false;
1842	del_timer_sync(timer: &smi_info->si_timer);
1843	}
1844
1845	static struct smi_info *find_dup_si(struct smi_info *info)
1846	{
1847	struct smi_info *e;
1848
1849	list_for_each_entry(e, &smi_infos, link) {
1850	if (e->io.addr_space != info->io.addr_space)
1851	continue;
1852	if (e->io.addr_data == info->io.addr_data) {
1853	/*
1854	* This is a cheap hack, ACPI doesn't have a defined
1855	* slave address but SMBIOS does. Pick it up from
1856	* any source that has it available.
1857	*/
1858	if (info->io.slave_addr && !e->io.slave_addr)
1859	e->io.slave_addr = info->io.slave_addr;
1860	return e;
1861	}
1862	}
1863
1864	return NULL;
1865	}
1866
1867	int ipmi_si_add_smi(struct si_sm_io *io)
1868	{
1869	int rv = 0;
1870	struct smi_info *new_smi, *dup;
1871
1872	/*
1873	* If the user gave us a hard-coded device at the same
1874	* address, they presumably want us to use it and not what is
1875	* in the firmware.
1876	*/
1877	if (io->addr_source != SI_HARDCODED && io->addr_source != SI_HOTMOD &&
1878	ipmi_si_hardcode_match(addr_space: io->addr_space, addr: 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(size: 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(info: 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(smi_info: 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(objp: 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: &new_smi->link, head: &smi_infos);
1927
1928	if (initialized)
1929	rv = try_smi_init(smi: new_smi);
1930	out_err:
1931	mutex_unlock(lock: &smi_infos_lock);
1932	return rv;
1933	}
1934
1935	/*
1936	* Try to start up an interface. Must be called with smi_infos_lock
1937	* held, primarily to keep smi_num consistent, we only one to do these
1938	* one at a time.
1939	*/
1940	static int try_smi_init(struct smi_info *new_smi)
1941	{
1942	int rv = 0;
1943	int i;
1944
1945	pr_info("Trying %s-specified %s state machine at %s address 0x%lx, slave address 0x%x, irq %d\n",
1946	ipmi_addr_src_to_str(new_smi->io.addr_source),
1947	si_to_str[new_smi->io.si_type],
1948	addr_space_to_str[new_smi->io.addr_space],
1949	new_smi->io.addr_data,
1950	new_smi->io.slave_addr, new_smi->io.irq);
1951
1952	switch (new_smi->io.si_type) {
1953	case SI_KCS:
1954	new_smi->handlers = &kcs_smi_handlers;
1955	break;
1956
1957	case SI_SMIC:
1958	new_smi->handlers = &smic_smi_handlers;
1959	break;
1960
1961	case SI_BT:
1962	new_smi->handlers = &bt_smi_handlers;
1963	break;
1964
1965	default:
1966	/* No support for anything else yet. */
1967	rv = -EIO;
1968	goto out_err;
1969	}
1970
1971	new_smi->si_num = smi_num;
1972
1973	/* Do this early so it's available for logs. */
1974	if (!new_smi->io.dev) {
1975	pr_err("IPMI interface added with no device\n");
1976	rv = -EIO;
1977	goto out_err;
1978	}
1979
1980	/* Allocate the state machine's data and initialize it. */
1981	new_smi->si_sm = kmalloc(size: 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(smi_info: 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(smi_info: new_smi);
2020
2021	new_smi->waiting_msg = NULL;
2022	new_smi->curr_msg = NULL;
2023	atomic_set(v: &new_smi->req_events, i: 0);
2024	new_smi->run_to_completion = false;
2025	for (i = 0; i < SI_NUM_STATS; i++)
2026	atomic_set(v: &new_smi->stats[i], i: 0);
2027
2028	new_smi->interrupt_disabled = true;
2029	atomic_set(v: &new_smi->need_watch, i: 0);
2030
2031	rv = try_enable_event_buffer(smi_info: 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(smi_info: 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(v: &new_smi->req_events, i: 1);
2048	}
2049
2050	dev_set_drvdata(dev: new_smi->io.dev, data: new_smi);
2051	rv = device_add_group(dev: new_smi->io.dev, grp: &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(objp: new_smi->si_sm);
2087	new_smi->si_sm = NULL;
2088	}
2089
2090	return rv;
2091	}
2092
2093	static 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(new_smi: 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(new_smi: e)) {
2136	type = e->io.addr_source;
2137	}
2138	}
2139	}
2140
2141	skip_fallback_noirq:
2142	initialized = true;
2143	mutex_unlock(lock: &smi_infos_lock);
2144
2145	if (type)
2146	return 0;
2147
2148	mutex_lock(&smi_infos_lock);
2149	if (unload_when_empty && list_empty(head: &smi_infos)) {
2150	mutex_unlock(lock: &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(lock: &smi_infos_lock);
2156	return 0;
2157	}
2158	}
2159	module_init(init_ipmi_si);
2160
2161	static 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: time_diff);
2171	schedule_timeout_uninterruptible(timeout: 1);
2172	}
2173	}
2174
2175	static 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(dev: smi_info->io.dev, grp: &ipmi_si_dev_attr_group);
2181	smi_info->dev_group_added = false;
2182	}
2183	if (smi_info->io.dev)
2184	dev_set_drvdata(dev: 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(objp: 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	*/
2234	static void cleanup_one_si(struct smi_info *smi_info)
2235	{
2236	if (!smi_info)
2237	return;
2238
2239	list_del(entry: &smi_info->link);
2240	ipmi_unregister_smi(intf: smi_info->intf);
2241	kfree(objp: smi_info);
2242	}
2243
2244	void 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(smi_info: e);
2252	break;
2253	}
2254	}
2255	mutex_unlock(lock: &smi_infos_lock);
2256	}
2257
2258	struct 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(dev: e->io.dev);
2273	cleanup_one_si(smi_info: e);
2274	}
2275	}
2276	mutex_unlock(lock: &smi_infos_lock);
2277
2278	return dev;
2279	}
2280
2281	static 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(smi_info: e);
2297	mutex_unlock(lock: &smi_infos_lock);
2298
2299	ipmi_si_hardcode_exit();
2300	ipmi_si_hotmod_exit();
2301	}
2302	module_exit(cleanup_ipmi_si);
2303
2304	MODULE_ALIAS("platform:dmi-ipmi-si");
2305	MODULE_LICENSE("GPL");
2306	MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2307	MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");
2308