xref: /openbmc/linux/drivers/char/ipmi/ipmi_si_intf.c (revision 6cf1a126)
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
debug_timestamp(struct smi_info * smi_info,char * msg)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);
register_xaction_notifier(struct notifier_block * nb)280 static int register_xaction_notifier(struct notifier_block *nb)
281 {
282 	return atomic_notifier_chain_register(&xaction_notifier_list, nb);
283 }
284 
deliver_recv_msg(struct smi_info * smi_info,struct ipmi_smi_msg * msg)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(smi_info->intf, msg);
290 }
291 
return_hosed_msg(struct smi_info * smi_info,int cCode)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 
start_next_msg(struct smi_info * smi_info)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(&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 	}
338 out:
339 	return rv;
340 }
341 
smi_mod_timer(struct smi_info * smi_info,unsigned long new_val)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(&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  */
start_new_msg(struct smi_info * smi_info,unsigned char * msg,unsigned int size)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, 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 
start_check_enables(struct smi_info * smi_info)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, 2);
373 	smi_info->si_state = SI_CHECKING_ENABLES;
374 }
375 
start_clear_flags(struct smi_info * smi_info)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, 3);
386 	smi_info->si_state = SI_CLEARING_FLAGS;
387 }
388 
start_getting_msg_queue(struct smi_info * smi_info)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, smi_info->curr_msg->data,
396 		      smi_info->curr_msg->data_size);
397 	smi_info->si_state = SI_GETTING_MESSAGES;
398 }
399 
start_getting_events(struct smi_info * smi_info)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, 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  */
disable_si_irq(struct smi_info * smi_info)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 
enable_si_irq(struct smi_info * smi_info)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  */
alloc_msg_handle_irq(struct smi_info * smi_info)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 
handle_flags(struct smi_info * smi_info)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(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 
current_global_enables(struct smi_info * smi_info,u8 base,bool * irq_on)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 
check_bt_irq(struct smi_info * smi_info,bool irq_on)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 
handle_transaction_done(struct smi_info * smi_info)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, 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  */
smi_event_handler(struct smi_info * smi_info,int time)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, 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 
866 out:
867 	return si_sm_result;
868 }
869 
check_start_timer_thread(struct smi_info * smi_info)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, 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 
flush_messages(void * send_info)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, 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 
sender(void * send_info,struct ipmi_smi_msg * msg)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(&smi_info->si_lock, flags);
928 }
929 
set_run_to_completion(void * send_info,bool i_run_to_completion)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(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)
ipmi_thread_busy_wait(enum si_sm_result smi_result,const struct smi_info * smi_info,ktime_t * busy_until)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  */
ipmi_thread(void * data)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, 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 
poll(void * send_info)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, 10);
1045 	if (!run_to_completion)
1046 		spin_unlock_irqrestore(&smi_info->si_lock, flags);
1047 }
1048 
request_events(void * send_info)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(&smi_info->req_events, 1);
1057 }
1058 
set_need_watch(void * send_info,unsigned int watch_mask)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(&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 
smi_timeout(struct timer_list * t)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_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, timeout);
1112 	else
1113 		smi_info->timer_running = false;
1114 	spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1115 }
1116 
ipmi_si_irq_handler(int irq,void * data)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, 0);
1135 	spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1136 	return IRQ_HANDLED;
1137 }
1138 
smi_start_processing(void * send_info,struct ipmi_smi * intf)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(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 
get_smi_info(void * send_info,struct ipmi_smi_info * data)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(smi->io.dev);
1192 
1193 	return 0;
1194 }
1195 
set_maintenance_mode(void * send_info,bool enable)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(&smi_info->req_events, 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 
ipmi_irq_finish_setup(struct si_sm_io * io)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 
ipmi_irq_start_cleanup(struct si_sm_io * io)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 
std_irq_cleanup(struct si_sm_io * io)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 
ipmi_std_irq_setup(struct si_sm_io * io)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(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 
wait_for_msg_done(struct smi_info * smi_info)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(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 
try_get_dev_id(struct smi_info * smi_info)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(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 
1354 out:
1355 	kfree(resp);
1356 	return rv;
1357 }
1358 
get_global_enables(struct smi_info * smi_info,u8 * enables)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(resp);
1400 	return rv;
1401 }
1402 
1403 /*
1404  * Returns 1 if it gets an error from the command.
1405  */
set_global_enables(struct smi_info * smi_info,u8 enables)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(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  */
check_clr_rcv_irq(struct smi_info * smi_info)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);
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  */
check_set_rcv_irq(struct smi_info * smi_info)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);
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 
try_enable_event_buffer(struct smi_info * smi_info)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(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 
type_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%s\n", si_to_str[smi_info->io.si_type]);
1618 }
1619 static DEVICE_ATTR_RO(type);
1620 
interrupts_enabled_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%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 
params_show(struct device * dev,struct device_attribute * attr,char * buf)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 			"%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  */
oem_data_avail_to_receive_msg_avail(struct smi_info * smi_info)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
setup_dell_poweredge_oem_data_handler(struct smi_info * smi_info)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
return_hosed_msg_badsize(struct smi_info * smi_info)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
dell_poweredge_bt_xaction_handler(struct notifier_block * self,unsigned long unused,void * in)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
setup_dell_poweredge_bt_xaction_handler(struct smi_info * smi_info)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(&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 
setup_oem_data_handler(struct smi_info * smi_info)1818 static void setup_oem_data_handler(struct smi_info *smi_info)
1819 {
1820 	setup_dell_poweredge_oem_data_handler(smi_info);
1821 }
1822 
setup_xaction_handlers(struct smi_info * smi_info)1823 static void setup_xaction_handlers(struct smi_info *smi_info)
1824 {
1825 	setup_dell_poweredge_bt_xaction_handler(smi_info);
1826 }
1827 
check_for_broken_irqs(struct smi_info * smi_info)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 
stop_timer_and_thread(struct smi_info * smi_info)1834 static 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 
find_dup_si(struct smi_info * info)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 
ipmi_si_add_smi(struct si_sm_io * io)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(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);
1930 out_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  */
try_smi_init(struct smi_info * new_smi)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(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 
init_ipmi_si(void)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(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 
2141 skip_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 }
2159 module_init(init_ipmi_si);
2160 
wait_msg_processed(struct smi_info * smi_info)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_diff);
2171 		schedule_timeout_uninterruptible(1);
2172 	}
2173 }
2174 
shutdown_smi(void * send_info)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(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  */
cleanup_one_si(struct smi_info * smi_info)2234 static 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 
ipmi_si_remove_by_dev(struct device * dev)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(e);
2252 			break;
2253 		}
2254 	}
2255 	mutex_unlock(&smi_infos_lock);
2256 }
2257 
ipmi_si_remove_by_data(int addr_space,enum si_type si_type,unsigned long addr)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(e->io.dev);
2273 			cleanup_one_si(e);
2274 		}
2275 	}
2276 	mutex_unlock(&smi_infos_lock);
2277 
2278 	return dev;
2279 }
2280 
cleanup_ipmi_si(void)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(e);
2297 	mutex_unlock(&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