xref: /openbmc/linux/drivers/char/ipmi/ipmi_si_intf.c (revision e8f6f3b4)
1 /*
2  * ipmi_si.c
3  *
4  * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
5  * BT).
6  *
7  * Author: MontaVista Software, Inc.
8  *         Corey Minyard <minyard@mvista.com>
9  *         source@mvista.com
10  *
11  * Copyright 2002 MontaVista Software Inc.
12  * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
13  *
14  *  This program is free software; you can redistribute it and/or modify it
15  *  under the terms of the GNU General Public License as published by the
16  *  Free Software Foundation; either version 2 of the License, or (at your
17  *  option) any later version.
18  *
19  *
20  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
21  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23  *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
25  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
26  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
28  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
29  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  *
31  *  You should have received a copy of the GNU General Public License along
32  *  with this program; if not, write to the Free Software Foundation, Inc.,
33  *  675 Mass Ave, Cambridge, MA 02139, USA.
34  */
35 
36 /*
37  * This file holds the "policy" for the interface to the SMI state
38  * machine.  It does the configuration, handles timers and interrupts,
39  * and drives the real SMI state machine.
40  */
41 
42 #include <linux/module.h>
43 #include <linux/moduleparam.h>
44 #include <linux/sched.h>
45 #include <linux/seq_file.h>
46 #include <linux/timer.h>
47 #include <linux/errno.h>
48 #include <linux/spinlock.h>
49 #include <linux/slab.h>
50 #include <linux/delay.h>
51 #include <linux/list.h>
52 #include <linux/pci.h>
53 #include <linux/ioport.h>
54 #include <linux/notifier.h>
55 #include <linux/mutex.h>
56 #include <linux/kthread.h>
57 #include <asm/irq.h>
58 #include <linux/interrupt.h>
59 #include <linux/rcupdate.h>
60 #include <linux/ipmi.h>
61 #include <linux/ipmi_smi.h>
62 #include <asm/io.h>
63 #include "ipmi_si_sm.h"
64 #include <linux/dmi.h>
65 #include <linux/string.h>
66 #include <linux/ctype.h>
67 #include <linux/pnp.h>
68 #include <linux/of_device.h>
69 #include <linux/of_platform.h>
70 #include <linux/of_address.h>
71 #include <linux/of_irq.h>
72 
73 #ifdef CONFIG_PARISC
74 #include <asm/hardware.h>	/* for register_parisc_driver() stuff */
75 #include <asm/parisc-device.h>
76 #endif
77 
78 #define PFX "ipmi_si: "
79 
80 /* Measure times between events in the driver. */
81 #undef DEBUG_TIMING
82 
83 /* Call every 10 ms. */
84 #define SI_TIMEOUT_TIME_USEC	10000
85 #define SI_USEC_PER_JIFFY	(1000000/HZ)
86 #define SI_TIMEOUT_JIFFIES	(SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
87 #define SI_SHORT_TIMEOUT_USEC  250 /* .25ms when the SM request a
88 				      short timeout */
89 
90 enum si_intf_state {
91 	SI_NORMAL,
92 	SI_GETTING_FLAGS,
93 	SI_GETTING_EVENTS,
94 	SI_CLEARING_FLAGS,
95 	SI_GETTING_MESSAGES,
96 	SI_CHECKING_ENABLES,
97 	SI_SETTING_ENABLES
98 	/* FIXME - add watchdog stuff. */
99 };
100 
101 /* Some BT-specific defines we need here. */
102 #define IPMI_BT_INTMASK_REG		2
103 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT	2
104 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT	1
105 
106 enum si_type {
107     SI_KCS, SI_SMIC, SI_BT
108 };
109 static char *si_to_str[] = { "kcs", "smic", "bt" };
110 
111 #define DEVICE_NAME "ipmi_si"
112 
113 static struct platform_driver ipmi_driver;
114 
115 /*
116  * Indexes into stats[] in smi_info below.
117  */
118 enum si_stat_indexes {
119 	/*
120 	 * Number of times the driver requested a timer while an operation
121 	 * was in progress.
122 	 */
123 	SI_STAT_short_timeouts = 0,
124 
125 	/*
126 	 * Number of times the driver requested a timer while nothing was in
127 	 * progress.
128 	 */
129 	SI_STAT_long_timeouts,
130 
131 	/* Number of times the interface was idle while being polled. */
132 	SI_STAT_idles,
133 
134 	/* Number of interrupts the driver handled. */
135 	SI_STAT_interrupts,
136 
137 	/* Number of time the driver got an ATTN from the hardware. */
138 	SI_STAT_attentions,
139 
140 	/* Number of times the driver requested flags from the hardware. */
141 	SI_STAT_flag_fetches,
142 
143 	/* Number of times the hardware didn't follow the state machine. */
144 	SI_STAT_hosed_count,
145 
146 	/* Number of completed messages. */
147 	SI_STAT_complete_transactions,
148 
149 	/* Number of IPMI events received from the hardware. */
150 	SI_STAT_events,
151 
152 	/* Number of watchdog pretimeouts. */
153 	SI_STAT_watchdog_pretimeouts,
154 
155 	/* Number of asynchronous messages received. */
156 	SI_STAT_incoming_messages,
157 
158 
159 	/* This *must* remain last, add new values above this. */
160 	SI_NUM_STATS
161 };
162 
163 struct smi_info {
164 	int                    intf_num;
165 	ipmi_smi_t             intf;
166 	struct si_sm_data      *si_sm;
167 	struct si_sm_handlers  *handlers;
168 	enum si_type           si_type;
169 	spinlock_t             si_lock;
170 	struct ipmi_smi_msg    *waiting_msg;
171 	struct ipmi_smi_msg    *curr_msg;
172 	enum si_intf_state     si_state;
173 
174 	/*
175 	 * Used to handle the various types of I/O that can occur with
176 	 * IPMI
177 	 */
178 	struct si_sm_io io;
179 	int (*io_setup)(struct smi_info *info);
180 	void (*io_cleanup)(struct smi_info *info);
181 	int (*irq_setup)(struct smi_info *info);
182 	void (*irq_cleanup)(struct smi_info *info);
183 	unsigned int io_size;
184 	enum ipmi_addr_src addr_source; /* ACPI, PCI, SMBIOS, hardcode, etc. */
185 	void (*addr_source_cleanup)(struct smi_info *info);
186 	void *addr_source_data;
187 
188 	/*
189 	 * Per-OEM handler, called from handle_flags().  Returns 1
190 	 * when handle_flags() needs to be re-run or 0 indicating it
191 	 * set si_state itself.
192 	 */
193 	int (*oem_data_avail_handler)(struct smi_info *smi_info);
194 
195 	/*
196 	 * Flags from the last GET_MSG_FLAGS command, used when an ATTN
197 	 * is set to hold the flags until we are done handling everything
198 	 * from the flags.
199 	 */
200 #define RECEIVE_MSG_AVAIL	0x01
201 #define EVENT_MSG_BUFFER_FULL	0x02
202 #define WDT_PRE_TIMEOUT_INT	0x08
203 #define OEM0_DATA_AVAIL     0x20
204 #define OEM1_DATA_AVAIL     0x40
205 #define OEM2_DATA_AVAIL     0x80
206 #define OEM_DATA_AVAIL      (OEM0_DATA_AVAIL | \
207 			     OEM1_DATA_AVAIL | \
208 			     OEM2_DATA_AVAIL)
209 	unsigned char       msg_flags;
210 
211 	/* Does the BMC have an event buffer? */
212 	bool		    has_event_buffer;
213 
214 	/*
215 	 * If set to true, this will request events the next time the
216 	 * state machine is idle.
217 	 */
218 	atomic_t            req_events;
219 
220 	/*
221 	 * If true, run the state machine to completion on every send
222 	 * call.  Generally used after a panic to make sure stuff goes
223 	 * out.
224 	 */
225 	bool                run_to_completion;
226 
227 	/* The I/O port of an SI interface. */
228 	int                 port;
229 
230 	/*
231 	 * The space between start addresses of the two ports.  For
232 	 * instance, if the first port is 0xca2 and the spacing is 4, then
233 	 * the second port is 0xca6.
234 	 */
235 	unsigned int        spacing;
236 
237 	/* zero if no irq; */
238 	int                 irq;
239 
240 	/* The timer for this si. */
241 	struct timer_list   si_timer;
242 
243 	/* This flag is set, if the timer is running (timer_pending() isn't enough) */
244 	bool		    timer_running;
245 
246 	/* The time (in jiffies) the last timeout occurred at. */
247 	unsigned long       last_timeout_jiffies;
248 
249 	/* Are we waiting for the events, pretimeouts, received msgs? */
250 	atomic_t            need_watch;
251 
252 	/*
253 	 * The driver will disable interrupts when it gets into a
254 	 * situation where it cannot handle messages due to lack of
255 	 * memory.  Once that situation clears up, it will re-enable
256 	 * interrupts.
257 	 */
258 	bool interrupt_disabled;
259 
260 	/*
261 	 * Does the BMC support events?
262 	 */
263 	bool supports_event_msg_buff;
264 
265 	/*
266 	 * Did we get an attention that we did not handle?
267 	 */
268 	bool got_attn;
269 
270 	/* From the get device id response... */
271 	struct ipmi_device_id device_id;
272 
273 	/* Driver model stuff. */
274 	struct device *dev;
275 	struct platform_device *pdev;
276 
277 	/*
278 	 * True if we allocated the device, false if it came from
279 	 * someplace else (like PCI).
280 	 */
281 	bool dev_registered;
282 
283 	/* Slave address, could be reported from DMI. */
284 	unsigned char slave_addr;
285 
286 	/* Counters and things for the proc filesystem. */
287 	atomic_t stats[SI_NUM_STATS];
288 
289 	struct task_struct *thread;
290 
291 	struct list_head link;
292 	union ipmi_smi_info_union addr_info;
293 };
294 
295 #define smi_inc_stat(smi, stat) \
296 	atomic_inc(&(smi)->stats[SI_STAT_ ## stat])
297 #define smi_get_stat(smi, stat) \
298 	((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat]))
299 
300 #define SI_MAX_PARMS 4
301 
302 static int force_kipmid[SI_MAX_PARMS];
303 static int num_force_kipmid;
304 #ifdef CONFIG_PCI
305 static bool pci_registered;
306 #endif
307 #ifdef CONFIG_ACPI
308 static bool pnp_registered;
309 #endif
310 #ifdef CONFIG_PARISC
311 static bool parisc_registered;
312 #endif
313 
314 static unsigned int kipmid_max_busy_us[SI_MAX_PARMS];
315 static int num_max_busy_us;
316 
317 static bool unload_when_empty = true;
318 
319 static int add_smi(struct smi_info *smi);
320 static int try_smi_init(struct smi_info *smi);
321 static void cleanup_one_si(struct smi_info *to_clean);
322 static void cleanup_ipmi_si(void);
323 
324 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
325 static int register_xaction_notifier(struct notifier_block *nb)
326 {
327 	return atomic_notifier_chain_register(&xaction_notifier_list, nb);
328 }
329 
330 static void deliver_recv_msg(struct smi_info *smi_info,
331 			     struct ipmi_smi_msg *msg)
332 {
333 	/* Deliver the message to the upper layer. */
334 	if (smi_info->intf)
335 		ipmi_smi_msg_received(smi_info->intf, msg);
336 	else
337 		ipmi_free_smi_msg(msg);
338 }
339 
340 static void return_hosed_msg(struct smi_info *smi_info, int cCode)
341 {
342 	struct ipmi_smi_msg *msg = smi_info->curr_msg;
343 
344 	if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
345 		cCode = IPMI_ERR_UNSPECIFIED;
346 	/* else use it as is */
347 
348 	/* Make it a response */
349 	msg->rsp[0] = msg->data[0] | 4;
350 	msg->rsp[1] = msg->data[1];
351 	msg->rsp[2] = cCode;
352 	msg->rsp_size = 3;
353 
354 	smi_info->curr_msg = NULL;
355 	deliver_recv_msg(smi_info, msg);
356 }
357 
358 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
359 {
360 	int              rv;
361 #ifdef DEBUG_TIMING
362 	struct timeval t;
363 #endif
364 
365 	if (!smi_info->waiting_msg) {
366 		smi_info->curr_msg = NULL;
367 		rv = SI_SM_IDLE;
368 	} else {
369 		int err;
370 
371 		smi_info->curr_msg = smi_info->waiting_msg;
372 		smi_info->waiting_msg = NULL;
373 #ifdef DEBUG_TIMING
374 		do_gettimeofday(&t);
375 		printk(KERN_DEBUG "**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
376 #endif
377 		err = atomic_notifier_call_chain(&xaction_notifier_list,
378 				0, smi_info);
379 		if (err & NOTIFY_STOP_MASK) {
380 			rv = SI_SM_CALL_WITHOUT_DELAY;
381 			goto out;
382 		}
383 		err = smi_info->handlers->start_transaction(
384 			smi_info->si_sm,
385 			smi_info->curr_msg->data,
386 			smi_info->curr_msg->data_size);
387 		if (err)
388 			return_hosed_msg(smi_info, err);
389 
390 		rv = SI_SM_CALL_WITHOUT_DELAY;
391 	}
392  out:
393 	return rv;
394 }
395 
396 static void start_check_enables(struct smi_info *smi_info)
397 {
398 	unsigned char msg[2];
399 
400 	msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
401 	msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
402 
403 	smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
404 	smi_info->si_state = SI_CHECKING_ENABLES;
405 }
406 
407 static void start_clear_flags(struct smi_info *smi_info)
408 {
409 	unsigned char msg[3];
410 
411 	/* Make sure the watchdog pre-timeout flag is not set at startup. */
412 	msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
413 	msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
414 	msg[2] = WDT_PRE_TIMEOUT_INT;
415 
416 	smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
417 	smi_info->si_state = SI_CLEARING_FLAGS;
418 }
419 
420 static void start_getting_msg_queue(struct smi_info *smi_info)
421 {
422 	smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
423 	smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
424 	smi_info->curr_msg->data_size = 2;
425 
426 	smi_info->handlers->start_transaction(
427 		smi_info->si_sm,
428 		smi_info->curr_msg->data,
429 		smi_info->curr_msg->data_size);
430 	smi_info->si_state = SI_GETTING_MESSAGES;
431 }
432 
433 static void start_getting_events(struct smi_info *smi_info)
434 {
435 	smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
436 	smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
437 	smi_info->curr_msg->data_size = 2;
438 
439 	smi_info->handlers->start_transaction(
440 		smi_info->si_sm,
441 		smi_info->curr_msg->data,
442 		smi_info->curr_msg->data_size);
443 	smi_info->si_state = SI_GETTING_EVENTS;
444 }
445 
446 static void smi_mod_timer(struct smi_info *smi_info, unsigned long new_val)
447 {
448 	smi_info->last_timeout_jiffies = jiffies;
449 	mod_timer(&smi_info->si_timer, new_val);
450 	smi_info->timer_running = true;
451 }
452 
453 /*
454  * When we have a situtaion where we run out of memory and cannot
455  * allocate messages, we just leave them in the BMC and run the system
456  * polled until we can allocate some memory.  Once we have some
457  * memory, we will re-enable the interrupt.
458  */
459 static inline bool disable_si_irq(struct smi_info *smi_info)
460 {
461 	if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
462 		smi_info->interrupt_disabled = true;
463 		start_check_enables(smi_info);
464 		return true;
465 	}
466 	return false;
467 }
468 
469 static inline bool enable_si_irq(struct smi_info *smi_info)
470 {
471 	if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
472 		smi_info->interrupt_disabled = false;
473 		start_check_enables(smi_info);
474 		return true;
475 	}
476 	return false;
477 }
478 
479 /*
480  * Allocate a message.  If unable to allocate, start the interrupt
481  * disable process and return NULL.  If able to allocate but
482  * interrupts are disabled, free the message and return NULL after
483  * starting the interrupt enable process.
484  */
485 static struct ipmi_smi_msg *alloc_msg_handle_irq(struct smi_info *smi_info)
486 {
487 	struct ipmi_smi_msg *msg;
488 
489 	msg = ipmi_alloc_smi_msg();
490 	if (!msg) {
491 		if (!disable_si_irq(smi_info))
492 			smi_info->si_state = SI_NORMAL;
493 	} else if (enable_si_irq(smi_info)) {
494 		ipmi_free_smi_msg(msg);
495 		msg = NULL;
496 	}
497 	return msg;
498 }
499 
500 static void handle_flags(struct smi_info *smi_info)
501 {
502  retry:
503 	if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
504 		/* Watchdog pre-timeout */
505 		smi_inc_stat(smi_info, watchdog_pretimeouts);
506 
507 		start_clear_flags(smi_info);
508 		smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
509 		if (smi_info->intf)
510 			ipmi_smi_watchdog_pretimeout(smi_info->intf);
511 	} else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
512 		/* Messages available. */
513 		smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
514 		if (!smi_info->curr_msg)
515 			return;
516 
517 		start_getting_msg_queue(smi_info);
518 	} else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
519 		/* Events available. */
520 		smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
521 		if (!smi_info->curr_msg)
522 			return;
523 
524 		start_getting_events(smi_info);
525 	} else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
526 		   smi_info->oem_data_avail_handler) {
527 		if (smi_info->oem_data_avail_handler(smi_info))
528 			goto retry;
529 	} else
530 		smi_info->si_state = SI_NORMAL;
531 }
532 
533 /*
534  * Global enables we care about.
535  */
536 #define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \
537 			     IPMI_BMC_EVT_MSG_INTR)
538 
539 static u8 current_global_enables(struct smi_info *smi_info, u8 base,
540 				 bool *irq_on)
541 {
542 	u8 enables = 0;
543 
544 	if (smi_info->supports_event_msg_buff)
545 		enables |= IPMI_BMC_EVT_MSG_BUFF;
546 	else
547 		enables &= ~IPMI_BMC_EVT_MSG_BUFF;
548 
549 	if (smi_info->irq && !smi_info->interrupt_disabled)
550 		enables |= IPMI_BMC_RCV_MSG_INTR;
551 	else
552 		enables &= ~IPMI_BMC_RCV_MSG_INTR;
553 
554 	if (smi_info->supports_event_msg_buff &&
555 	    smi_info->irq && !smi_info->interrupt_disabled)
556 
557 		enables |= IPMI_BMC_EVT_MSG_INTR;
558 	else
559 		enables &= ~IPMI_BMC_EVT_MSG_INTR;
560 
561 	*irq_on = enables & (IPMI_BMC_EVT_MSG_INTR | IPMI_BMC_RCV_MSG_INTR);
562 
563 	return enables;
564 }
565 
566 static void check_bt_irq(struct smi_info *smi_info, bool irq_on)
567 {
568 	u8 irqstate = smi_info->io.inputb(&smi_info->io, IPMI_BT_INTMASK_REG);
569 
570 	irqstate &= IPMI_BT_INTMASK_ENABLE_IRQ_BIT;
571 
572 	if ((bool)irqstate == irq_on)
573 		return;
574 
575 	if (irq_on)
576 		smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
577 				     IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
578 	else
579 		smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 0);
580 }
581 
582 static void handle_transaction_done(struct smi_info *smi_info)
583 {
584 	struct ipmi_smi_msg *msg;
585 #ifdef DEBUG_TIMING
586 	struct timeval t;
587 
588 	do_gettimeofday(&t);
589 	printk(KERN_DEBUG "**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
590 #endif
591 	switch (smi_info->si_state) {
592 	case SI_NORMAL:
593 		if (!smi_info->curr_msg)
594 			break;
595 
596 		smi_info->curr_msg->rsp_size
597 			= smi_info->handlers->get_result(
598 				smi_info->si_sm,
599 				smi_info->curr_msg->rsp,
600 				IPMI_MAX_MSG_LENGTH);
601 
602 		/*
603 		 * Do this here becase deliver_recv_msg() releases the
604 		 * lock, and a new message can be put in during the
605 		 * time the lock is released.
606 		 */
607 		msg = smi_info->curr_msg;
608 		smi_info->curr_msg = NULL;
609 		deliver_recv_msg(smi_info, msg);
610 		break;
611 
612 	case SI_GETTING_FLAGS:
613 	{
614 		unsigned char msg[4];
615 		unsigned int  len;
616 
617 		/* We got the flags from the SMI, now handle them. */
618 		len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
619 		if (msg[2] != 0) {
620 			/* Error fetching flags, just give up for now. */
621 			smi_info->si_state = SI_NORMAL;
622 		} else if (len < 4) {
623 			/*
624 			 * Hmm, no flags.  That's technically illegal, but
625 			 * don't use uninitialized data.
626 			 */
627 			smi_info->si_state = SI_NORMAL;
628 		} else {
629 			smi_info->msg_flags = msg[3];
630 			handle_flags(smi_info);
631 		}
632 		break;
633 	}
634 
635 	case SI_CLEARING_FLAGS:
636 	{
637 		unsigned char msg[3];
638 
639 		/* We cleared the flags. */
640 		smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
641 		if (msg[2] != 0) {
642 			/* Error clearing flags */
643 			dev_warn(smi_info->dev,
644 				 "Error clearing flags: %2.2x\n", msg[2]);
645 		}
646 		smi_info->si_state = SI_NORMAL;
647 		break;
648 	}
649 
650 	case SI_GETTING_EVENTS:
651 	{
652 		smi_info->curr_msg->rsp_size
653 			= smi_info->handlers->get_result(
654 				smi_info->si_sm,
655 				smi_info->curr_msg->rsp,
656 				IPMI_MAX_MSG_LENGTH);
657 
658 		/*
659 		 * Do this here becase deliver_recv_msg() releases the
660 		 * lock, and a new message can be put in during the
661 		 * time the lock is released.
662 		 */
663 		msg = smi_info->curr_msg;
664 		smi_info->curr_msg = NULL;
665 		if (msg->rsp[2] != 0) {
666 			/* Error getting event, probably done. */
667 			msg->done(msg);
668 
669 			/* Take off the event flag. */
670 			smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
671 			handle_flags(smi_info);
672 		} else {
673 			smi_inc_stat(smi_info, events);
674 
675 			/*
676 			 * Do this before we deliver the message
677 			 * because delivering the message releases the
678 			 * lock and something else can mess with the
679 			 * state.
680 			 */
681 			handle_flags(smi_info);
682 
683 			deliver_recv_msg(smi_info, msg);
684 		}
685 		break;
686 	}
687 
688 	case SI_GETTING_MESSAGES:
689 	{
690 		smi_info->curr_msg->rsp_size
691 			= smi_info->handlers->get_result(
692 				smi_info->si_sm,
693 				smi_info->curr_msg->rsp,
694 				IPMI_MAX_MSG_LENGTH);
695 
696 		/*
697 		 * Do this here becase deliver_recv_msg() releases the
698 		 * lock, and a new message can be put in during the
699 		 * time the lock is released.
700 		 */
701 		msg = smi_info->curr_msg;
702 		smi_info->curr_msg = NULL;
703 		if (msg->rsp[2] != 0) {
704 			/* Error getting event, probably done. */
705 			msg->done(msg);
706 
707 			/* Take off the msg flag. */
708 			smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
709 			handle_flags(smi_info);
710 		} else {
711 			smi_inc_stat(smi_info, incoming_messages);
712 
713 			/*
714 			 * Do this before we deliver the message
715 			 * because delivering the message releases the
716 			 * lock and something else can mess with the
717 			 * state.
718 			 */
719 			handle_flags(smi_info);
720 
721 			deliver_recv_msg(smi_info, msg);
722 		}
723 		break;
724 	}
725 
726 	case SI_CHECKING_ENABLES:
727 	{
728 		unsigned char msg[4];
729 		u8 enables;
730 		bool irq_on;
731 
732 		/* We got the flags from the SMI, now handle them. */
733 		smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
734 		if (msg[2] != 0) {
735 			dev_warn(smi_info->dev,
736 				 "Couldn't get irq info: %x.\n", msg[2]);
737 			dev_warn(smi_info->dev,
738 				 "Maybe ok, but ipmi might run very slowly.\n");
739 			smi_info->si_state = SI_NORMAL;
740 			break;
741 		}
742 		enables = current_global_enables(smi_info, 0, &irq_on);
743 		if (smi_info->si_type == SI_BT)
744 			/* BT has its own interrupt enable bit. */
745 			check_bt_irq(smi_info, irq_on);
746 		if (enables != (msg[3] & GLOBAL_ENABLES_MASK)) {
747 			/* Enables are not correct, fix them. */
748 			msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
749 			msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
750 			msg[2] = enables | (msg[3] & ~GLOBAL_ENABLES_MASK);
751 			smi_info->handlers->start_transaction(
752 				smi_info->si_sm, msg, 3);
753 			smi_info->si_state = SI_SETTING_ENABLES;
754 		} else if (smi_info->supports_event_msg_buff) {
755 			smi_info->curr_msg = ipmi_alloc_smi_msg();
756 			if (!smi_info->curr_msg) {
757 				smi_info->si_state = SI_NORMAL;
758 				break;
759 			}
760 			start_getting_msg_queue(smi_info);
761 		} else {
762 			smi_info->si_state = SI_NORMAL;
763 		}
764 		break;
765 	}
766 
767 	case SI_SETTING_ENABLES:
768 	{
769 		unsigned char msg[4];
770 
771 		smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
772 		if (msg[2] != 0)
773 			dev_warn(smi_info->dev,
774 				 "Could not set the global enables: 0x%x.\n",
775 				 msg[2]);
776 
777 		if (smi_info->supports_event_msg_buff) {
778 			smi_info->curr_msg = ipmi_alloc_smi_msg();
779 			if (!smi_info->curr_msg) {
780 				smi_info->si_state = SI_NORMAL;
781 				break;
782 			}
783 			start_getting_msg_queue(smi_info);
784 		} else {
785 			smi_info->si_state = SI_NORMAL;
786 		}
787 		break;
788 	}
789 	}
790 }
791 
792 /*
793  * Called on timeouts and events.  Timeouts should pass the elapsed
794  * time, interrupts should pass in zero.  Must be called with
795  * si_lock held and interrupts disabled.
796  */
797 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
798 					   int time)
799 {
800 	enum si_sm_result si_sm_result;
801 
802  restart:
803 	/*
804 	 * There used to be a loop here that waited a little while
805 	 * (around 25us) before giving up.  That turned out to be
806 	 * pointless, the minimum delays I was seeing were in the 300us
807 	 * range, which is far too long to wait in an interrupt.  So
808 	 * we just run until the state machine tells us something
809 	 * happened or it needs a delay.
810 	 */
811 	si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
812 	time = 0;
813 	while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
814 		si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
815 
816 	if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
817 		smi_inc_stat(smi_info, complete_transactions);
818 
819 		handle_transaction_done(smi_info);
820 		si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
821 	} else if (si_sm_result == SI_SM_HOSED) {
822 		smi_inc_stat(smi_info, hosed_count);
823 
824 		/*
825 		 * Do the before return_hosed_msg, because that
826 		 * releases the lock.
827 		 */
828 		smi_info->si_state = SI_NORMAL;
829 		if (smi_info->curr_msg != NULL) {
830 			/*
831 			 * If we were handling a user message, format
832 			 * a response to send to the upper layer to
833 			 * tell it about the error.
834 			 */
835 			return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
836 		}
837 		si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
838 	}
839 
840 	/*
841 	 * We prefer handling attn over new messages.  But don't do
842 	 * this if there is not yet an upper layer to handle anything.
843 	 */
844 	if (likely(smi_info->intf) &&
845 	    (si_sm_result == SI_SM_ATTN || smi_info->got_attn)) {
846 		unsigned char msg[2];
847 
848 		if (smi_info->si_state != SI_NORMAL) {
849 			/*
850 			 * We got an ATTN, but we are doing something else.
851 			 * Handle the ATTN later.
852 			 */
853 			smi_info->got_attn = true;
854 		} else {
855 			smi_info->got_attn = false;
856 			smi_inc_stat(smi_info, attentions);
857 
858 			/*
859 			 * Got a attn, send down a get message flags to see
860 			 * what's causing it.  It would be better to handle
861 			 * this in the upper layer, but due to the way
862 			 * interrupts work with the SMI, that's not really
863 			 * possible.
864 			 */
865 			msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
866 			msg[1] = IPMI_GET_MSG_FLAGS_CMD;
867 
868 			smi_info->handlers->start_transaction(
869 				smi_info->si_sm, msg, 2);
870 			smi_info->si_state = SI_GETTING_FLAGS;
871 			goto restart;
872 		}
873 	}
874 
875 	/* If we are currently idle, try to start the next message. */
876 	if (si_sm_result == SI_SM_IDLE) {
877 		smi_inc_stat(smi_info, idles);
878 
879 		si_sm_result = start_next_msg(smi_info);
880 		if (si_sm_result != SI_SM_IDLE)
881 			goto restart;
882 	}
883 
884 	if ((si_sm_result == SI_SM_IDLE)
885 	    && (atomic_read(&smi_info->req_events))) {
886 		/*
887 		 * We are idle and the upper layer requested that I fetch
888 		 * events, so do so.
889 		 */
890 		atomic_set(&smi_info->req_events, 0);
891 
892 		/*
893 		 * Take this opportunity to check the interrupt and
894 		 * message enable state for the BMC.  The BMC can be
895 		 * asynchronously reset, and may thus get interrupts
896 		 * disable and messages disabled.
897 		 */
898 		if (smi_info->supports_event_msg_buff || smi_info->irq) {
899 			start_check_enables(smi_info);
900 		} else {
901 			smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
902 			if (!smi_info->curr_msg)
903 				goto out;
904 
905 			start_getting_events(smi_info);
906 		}
907 		goto restart;
908 	}
909  out:
910 	return si_sm_result;
911 }
912 
913 static void check_start_timer_thread(struct smi_info *smi_info)
914 {
915 	if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) {
916 		smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
917 
918 		if (smi_info->thread)
919 			wake_up_process(smi_info->thread);
920 
921 		start_next_msg(smi_info);
922 		smi_event_handler(smi_info, 0);
923 	}
924 }
925 
926 static void sender(void                *send_info,
927 		   struct ipmi_smi_msg *msg)
928 {
929 	struct smi_info   *smi_info = send_info;
930 	enum si_sm_result result;
931 	unsigned long     flags;
932 #ifdef DEBUG_TIMING
933 	struct timeval    t;
934 #endif
935 
936 	BUG_ON(smi_info->waiting_msg);
937 	smi_info->waiting_msg = msg;
938 
939 #ifdef DEBUG_TIMING
940 	do_gettimeofday(&t);
941 	printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
942 #endif
943 
944 	if (smi_info->run_to_completion) {
945 		/*
946 		 * If we are running to completion, start it and run
947 		 * transactions until everything is clear.
948 		 */
949 		smi_info->curr_msg = smi_info->waiting_msg;
950 		smi_info->waiting_msg = NULL;
951 
952 		/*
953 		 * Run to completion means we are single-threaded, no
954 		 * need for locks.
955 		 */
956 
957 		result = smi_event_handler(smi_info, 0);
958 		while (result != SI_SM_IDLE) {
959 			udelay(SI_SHORT_TIMEOUT_USEC);
960 			result = smi_event_handler(smi_info,
961 						   SI_SHORT_TIMEOUT_USEC);
962 		}
963 		return;
964 	}
965 
966 	spin_lock_irqsave(&smi_info->si_lock, flags);
967 	check_start_timer_thread(smi_info);
968 	spin_unlock_irqrestore(&smi_info->si_lock, flags);
969 }
970 
971 static void set_run_to_completion(void *send_info, bool i_run_to_completion)
972 {
973 	struct smi_info   *smi_info = send_info;
974 	enum si_sm_result result;
975 
976 	smi_info->run_to_completion = i_run_to_completion;
977 	if (i_run_to_completion) {
978 		result = smi_event_handler(smi_info, 0);
979 		while (result != SI_SM_IDLE) {
980 			udelay(SI_SHORT_TIMEOUT_USEC);
981 			result = smi_event_handler(smi_info,
982 						   SI_SHORT_TIMEOUT_USEC);
983 		}
984 	}
985 }
986 
987 /*
988  * Use -1 in the nsec value of the busy waiting timespec to tell that
989  * we are spinning in kipmid looking for something and not delaying
990  * between checks
991  */
992 static inline void ipmi_si_set_not_busy(struct timespec *ts)
993 {
994 	ts->tv_nsec = -1;
995 }
996 static inline int ipmi_si_is_busy(struct timespec *ts)
997 {
998 	return ts->tv_nsec != -1;
999 }
1000 
1001 static inline int ipmi_thread_busy_wait(enum si_sm_result smi_result,
1002 					const struct smi_info *smi_info,
1003 					struct timespec *busy_until)
1004 {
1005 	unsigned int max_busy_us = 0;
1006 
1007 	if (smi_info->intf_num < num_max_busy_us)
1008 		max_busy_us = kipmid_max_busy_us[smi_info->intf_num];
1009 	if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
1010 		ipmi_si_set_not_busy(busy_until);
1011 	else if (!ipmi_si_is_busy(busy_until)) {
1012 		getnstimeofday(busy_until);
1013 		timespec_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
1014 	} else {
1015 		struct timespec now;
1016 		getnstimeofday(&now);
1017 		if (unlikely(timespec_compare(&now, busy_until) > 0)) {
1018 			ipmi_si_set_not_busy(busy_until);
1019 			return 0;
1020 		}
1021 	}
1022 	return 1;
1023 }
1024 
1025 
1026 /*
1027  * A busy-waiting loop for speeding up IPMI operation.
1028  *
1029  * Lousy hardware makes this hard.  This is only enabled for systems
1030  * that are not BT and do not have interrupts.  It starts spinning
1031  * when an operation is complete or until max_busy tells it to stop
1032  * (if that is enabled).  See the paragraph on kimid_max_busy_us in
1033  * Documentation/IPMI.txt for details.
1034  */
1035 static int ipmi_thread(void *data)
1036 {
1037 	struct smi_info *smi_info = data;
1038 	unsigned long flags;
1039 	enum si_sm_result smi_result;
1040 	struct timespec busy_until;
1041 
1042 	ipmi_si_set_not_busy(&busy_until);
1043 	set_user_nice(current, MAX_NICE);
1044 	while (!kthread_should_stop()) {
1045 		int busy_wait;
1046 
1047 		spin_lock_irqsave(&(smi_info->si_lock), flags);
1048 		smi_result = smi_event_handler(smi_info, 0);
1049 
1050 		/*
1051 		 * If the driver is doing something, there is a possible
1052 		 * race with the timer.  If the timer handler see idle,
1053 		 * and the thread here sees something else, the timer
1054 		 * handler won't restart the timer even though it is
1055 		 * required.  So start it here if necessary.
1056 		 */
1057 		if (smi_result != SI_SM_IDLE && !smi_info->timer_running)
1058 			smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
1059 
1060 		spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1061 		busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
1062 						  &busy_until);
1063 		if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1064 			; /* do nothing */
1065 		else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait)
1066 			schedule();
1067 		else if (smi_result == SI_SM_IDLE) {
1068 			if (atomic_read(&smi_info->need_watch)) {
1069 				schedule_timeout_interruptible(100);
1070 			} else {
1071 				/* Wait to be woken up when we are needed. */
1072 				__set_current_state(TASK_INTERRUPTIBLE);
1073 				schedule();
1074 			}
1075 		} else
1076 			schedule_timeout_interruptible(1);
1077 	}
1078 	return 0;
1079 }
1080 
1081 
1082 static void poll(void *send_info)
1083 {
1084 	struct smi_info *smi_info = send_info;
1085 	unsigned long flags = 0;
1086 	bool run_to_completion = smi_info->run_to_completion;
1087 
1088 	/*
1089 	 * Make sure there is some delay in the poll loop so we can
1090 	 * drive time forward and timeout things.
1091 	 */
1092 	udelay(10);
1093 	if (!run_to_completion)
1094 		spin_lock_irqsave(&smi_info->si_lock, flags);
1095 	smi_event_handler(smi_info, 10);
1096 	if (!run_to_completion)
1097 		spin_unlock_irqrestore(&smi_info->si_lock, flags);
1098 }
1099 
1100 static void request_events(void *send_info)
1101 {
1102 	struct smi_info *smi_info = send_info;
1103 
1104 	if (!smi_info->has_event_buffer)
1105 		return;
1106 
1107 	atomic_set(&smi_info->req_events, 1);
1108 }
1109 
1110 static void set_need_watch(void *send_info, bool enable)
1111 {
1112 	struct smi_info *smi_info = send_info;
1113 	unsigned long flags;
1114 
1115 	atomic_set(&smi_info->need_watch, enable);
1116 	spin_lock_irqsave(&smi_info->si_lock, flags);
1117 	check_start_timer_thread(smi_info);
1118 	spin_unlock_irqrestore(&smi_info->si_lock, flags);
1119 }
1120 
1121 static int initialized;
1122 
1123 static void smi_timeout(unsigned long data)
1124 {
1125 	struct smi_info   *smi_info = (struct smi_info *) data;
1126 	enum si_sm_result smi_result;
1127 	unsigned long     flags;
1128 	unsigned long     jiffies_now;
1129 	long              time_diff;
1130 	long		  timeout;
1131 #ifdef DEBUG_TIMING
1132 	struct timeval    t;
1133 #endif
1134 
1135 	spin_lock_irqsave(&(smi_info->si_lock), flags);
1136 #ifdef DEBUG_TIMING
1137 	do_gettimeofday(&t);
1138 	printk(KERN_DEBUG "**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1139 #endif
1140 	jiffies_now = jiffies;
1141 	time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
1142 		     * SI_USEC_PER_JIFFY);
1143 	smi_result = smi_event_handler(smi_info, time_diff);
1144 
1145 	if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
1146 		/* Running with interrupts, only do long timeouts. */
1147 		timeout = jiffies + SI_TIMEOUT_JIFFIES;
1148 		smi_inc_stat(smi_info, long_timeouts);
1149 		goto do_mod_timer;
1150 	}
1151 
1152 	/*
1153 	 * If the state machine asks for a short delay, then shorten
1154 	 * the timer timeout.
1155 	 */
1156 	if (smi_result == SI_SM_CALL_WITH_DELAY) {
1157 		smi_inc_stat(smi_info, short_timeouts);
1158 		timeout = jiffies + 1;
1159 	} else {
1160 		smi_inc_stat(smi_info, long_timeouts);
1161 		timeout = jiffies + SI_TIMEOUT_JIFFIES;
1162 	}
1163 
1164  do_mod_timer:
1165 	if (smi_result != SI_SM_IDLE)
1166 		smi_mod_timer(smi_info, timeout);
1167 	else
1168 		smi_info->timer_running = false;
1169 	spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1170 }
1171 
1172 static irqreturn_t si_irq_handler(int irq, void *data)
1173 {
1174 	struct smi_info *smi_info = data;
1175 	unsigned long   flags;
1176 #ifdef DEBUG_TIMING
1177 	struct timeval  t;
1178 #endif
1179 
1180 	spin_lock_irqsave(&(smi_info->si_lock), flags);
1181 
1182 	smi_inc_stat(smi_info, interrupts);
1183 
1184 #ifdef DEBUG_TIMING
1185 	do_gettimeofday(&t);
1186 	printk(KERN_DEBUG "**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1187 #endif
1188 	smi_event_handler(smi_info, 0);
1189 	spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1190 	return IRQ_HANDLED;
1191 }
1192 
1193 static irqreturn_t si_bt_irq_handler(int irq, void *data)
1194 {
1195 	struct smi_info *smi_info = data;
1196 	/* We need to clear the IRQ flag for the BT interface. */
1197 	smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
1198 			     IPMI_BT_INTMASK_CLEAR_IRQ_BIT
1199 			     | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1200 	return si_irq_handler(irq, data);
1201 }
1202 
1203 static int smi_start_processing(void       *send_info,
1204 				ipmi_smi_t intf)
1205 {
1206 	struct smi_info *new_smi = send_info;
1207 	int             enable = 0;
1208 
1209 	new_smi->intf = intf;
1210 
1211 	/* Try to claim any interrupts. */
1212 	if (new_smi->irq_setup)
1213 		new_smi->irq_setup(new_smi);
1214 
1215 	/* Set up the timer that drives the interface. */
1216 	setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
1217 	smi_mod_timer(new_smi, jiffies + SI_TIMEOUT_JIFFIES);
1218 
1219 	/*
1220 	 * Check if the user forcefully enabled the daemon.
1221 	 */
1222 	if (new_smi->intf_num < num_force_kipmid)
1223 		enable = force_kipmid[new_smi->intf_num];
1224 	/*
1225 	 * The BT interface is efficient enough to not need a thread,
1226 	 * and there is no need for a thread if we have interrupts.
1227 	 */
1228 	else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
1229 		enable = 1;
1230 
1231 	if (enable) {
1232 		new_smi->thread = kthread_run(ipmi_thread, new_smi,
1233 					      "kipmi%d", new_smi->intf_num);
1234 		if (IS_ERR(new_smi->thread)) {
1235 			dev_notice(new_smi->dev, "Could not start"
1236 				   " kernel thread due to error %ld, only using"
1237 				   " timers to drive the interface\n",
1238 				   PTR_ERR(new_smi->thread));
1239 			new_smi->thread = NULL;
1240 		}
1241 	}
1242 
1243 	return 0;
1244 }
1245 
1246 static int get_smi_info(void *send_info, struct ipmi_smi_info *data)
1247 {
1248 	struct smi_info *smi = send_info;
1249 
1250 	data->addr_src = smi->addr_source;
1251 	data->dev = smi->dev;
1252 	data->addr_info = smi->addr_info;
1253 	get_device(smi->dev);
1254 
1255 	return 0;
1256 }
1257 
1258 static void set_maintenance_mode(void *send_info, bool enable)
1259 {
1260 	struct smi_info   *smi_info = send_info;
1261 
1262 	if (!enable)
1263 		atomic_set(&smi_info->req_events, 0);
1264 }
1265 
1266 static struct ipmi_smi_handlers handlers = {
1267 	.owner                  = THIS_MODULE,
1268 	.start_processing       = smi_start_processing,
1269 	.get_smi_info		= get_smi_info,
1270 	.sender			= sender,
1271 	.request_events		= request_events,
1272 	.set_need_watch		= set_need_watch,
1273 	.set_maintenance_mode   = set_maintenance_mode,
1274 	.set_run_to_completion  = set_run_to_completion,
1275 	.poll			= poll,
1276 };
1277 
1278 /*
1279  * There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1280  * a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS.
1281  */
1282 
1283 static LIST_HEAD(smi_infos);
1284 static DEFINE_MUTEX(smi_infos_lock);
1285 static int smi_num; /* Used to sequence the SMIs */
1286 
1287 #define DEFAULT_REGSPACING	1
1288 #define DEFAULT_REGSIZE		1
1289 
1290 #ifdef CONFIG_ACPI
1291 static bool          si_tryacpi = 1;
1292 #endif
1293 #ifdef CONFIG_DMI
1294 static bool          si_trydmi = 1;
1295 #endif
1296 static bool          si_tryplatform = 1;
1297 #ifdef CONFIG_PCI
1298 static bool          si_trypci = 1;
1299 #endif
1300 static bool          si_trydefaults = IS_ENABLED(CONFIG_IPMI_SI_PROBE_DEFAULTS);
1301 static char          *si_type[SI_MAX_PARMS];
1302 #define MAX_SI_TYPE_STR 30
1303 static char          si_type_str[MAX_SI_TYPE_STR];
1304 static unsigned long addrs[SI_MAX_PARMS];
1305 static unsigned int num_addrs;
1306 static unsigned int  ports[SI_MAX_PARMS];
1307 static unsigned int num_ports;
1308 static int           irqs[SI_MAX_PARMS];
1309 static unsigned int num_irqs;
1310 static int           regspacings[SI_MAX_PARMS];
1311 static unsigned int num_regspacings;
1312 static int           regsizes[SI_MAX_PARMS];
1313 static unsigned int num_regsizes;
1314 static int           regshifts[SI_MAX_PARMS];
1315 static unsigned int num_regshifts;
1316 static int slave_addrs[SI_MAX_PARMS]; /* Leaving 0 chooses the default value */
1317 static unsigned int num_slave_addrs;
1318 
1319 #define IPMI_IO_ADDR_SPACE  0
1320 #define IPMI_MEM_ADDR_SPACE 1
1321 static char *addr_space_to_str[] = { "i/o", "mem" };
1322 
1323 static int hotmod_handler(const char *val, struct kernel_param *kp);
1324 
1325 module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
1326 MODULE_PARM_DESC(hotmod, "Add and remove interfaces.  See"
1327 		 " Documentation/IPMI.txt in the kernel sources for the"
1328 		 " gory details.");
1329 
1330 #ifdef CONFIG_ACPI
1331 module_param_named(tryacpi, si_tryacpi, bool, 0);
1332 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1333 		 " default scan of the interfaces identified via ACPI");
1334 #endif
1335 #ifdef CONFIG_DMI
1336 module_param_named(trydmi, si_trydmi, bool, 0);
1337 MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the"
1338 		 " default scan of the interfaces identified via DMI");
1339 #endif
1340 module_param_named(tryplatform, si_tryplatform, bool, 0);
1341 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1342 		 " default scan of the interfaces identified via platform"
1343 		 " interfaces like openfirmware");
1344 #ifdef CONFIG_PCI
1345 module_param_named(trypci, si_trypci, bool, 0);
1346 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1347 		 " default scan of the interfaces identified via pci");
1348 #endif
1349 module_param_named(trydefaults, si_trydefaults, bool, 0);
1350 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1351 		 " default scan of the KCS and SMIC interface at the standard"
1352 		 " address");
1353 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1354 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1355 		 " interface separated by commas.  The types are 'kcs',"
1356 		 " 'smic', and 'bt'.  For example si_type=kcs,bt will set"
1357 		 " the first interface to kcs and the second to bt");
1358 module_param_array(addrs, ulong, &num_addrs, 0);
1359 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1360 		 " addresses separated by commas.  Only use if an interface"
1361 		 " is in memory.  Otherwise, set it to zero or leave"
1362 		 " it blank.");
1363 module_param_array(ports, uint, &num_ports, 0);
1364 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1365 		 " addresses separated by commas.  Only use if an interface"
1366 		 " is a port.  Otherwise, set it to zero or leave"
1367 		 " it blank.");
1368 module_param_array(irqs, int, &num_irqs, 0);
1369 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1370 		 " addresses separated by commas.  Only use if an interface"
1371 		 " has an interrupt.  Otherwise, set it to zero or leave"
1372 		 " it blank.");
1373 module_param_array(regspacings, int, &num_regspacings, 0);
1374 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1375 		 " and each successive register used by the interface.  For"
1376 		 " instance, if the start address is 0xca2 and the spacing"
1377 		 " is 2, then the second address is at 0xca4.  Defaults"
1378 		 " to 1.");
1379 module_param_array(regsizes, int, &num_regsizes, 0);
1380 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1381 		 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1382 		 " 16-bit, 32-bit, or 64-bit register.  Use this if you"
1383 		 " the 8-bit IPMI register has to be read from a larger"
1384 		 " register.");
1385 module_param_array(regshifts, int, &num_regshifts, 0);
1386 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1387 		 " IPMI register, in bits.  For instance, if the data"
1388 		 " is read from a 32-bit word and the IPMI data is in"
1389 		 " bit 8-15, then the shift would be 8");
1390 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1391 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1392 		 " the controller.  Normally this is 0x20, but can be"
1393 		 " overridden by this parm.  This is an array indexed"
1394 		 " by interface number.");
1395 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1396 MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1397 		 " disabled(0).  Normally the IPMI driver auto-detects"
1398 		 " this, but the value may be overridden by this parm.");
1399 module_param(unload_when_empty, bool, 0);
1400 MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
1401 		 " specified or found, default is 1.  Setting to 0"
1402 		 " is useful for hot add of devices using hotmod.");
1403 module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
1404 MODULE_PARM_DESC(kipmid_max_busy_us,
1405 		 "Max time (in microseconds) to busy-wait for IPMI data before"
1406 		 " sleeping. 0 (default) means to wait forever. Set to 100-500"
1407 		 " if kipmid is using up a lot of CPU time.");
1408 
1409 
1410 static void std_irq_cleanup(struct smi_info *info)
1411 {
1412 	if (info->si_type == SI_BT)
1413 		/* Disable the interrupt in the BT interface. */
1414 		info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1415 	free_irq(info->irq, info);
1416 }
1417 
1418 static int std_irq_setup(struct smi_info *info)
1419 {
1420 	int rv;
1421 
1422 	if (!info->irq)
1423 		return 0;
1424 
1425 	if (info->si_type == SI_BT) {
1426 		rv = request_irq(info->irq,
1427 				 si_bt_irq_handler,
1428 				 IRQF_SHARED,
1429 				 DEVICE_NAME,
1430 				 info);
1431 		if (!rv)
1432 			/* Enable the interrupt in the BT interface. */
1433 			info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1434 					 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1435 	} else
1436 		rv = request_irq(info->irq,
1437 				 si_irq_handler,
1438 				 IRQF_SHARED,
1439 				 DEVICE_NAME,
1440 				 info);
1441 	if (rv) {
1442 		dev_warn(info->dev, "%s unable to claim interrupt %d,"
1443 			 " running polled\n",
1444 			 DEVICE_NAME, info->irq);
1445 		info->irq = 0;
1446 	} else {
1447 		info->irq_cleanup = std_irq_cleanup;
1448 		dev_info(info->dev, "Using irq %d\n", info->irq);
1449 	}
1450 
1451 	return rv;
1452 }
1453 
1454 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1455 {
1456 	unsigned int addr = io->addr_data;
1457 
1458 	return inb(addr + (offset * io->regspacing));
1459 }
1460 
1461 static void port_outb(struct si_sm_io *io, unsigned int offset,
1462 		      unsigned char b)
1463 {
1464 	unsigned int addr = io->addr_data;
1465 
1466 	outb(b, addr + (offset * io->regspacing));
1467 }
1468 
1469 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1470 {
1471 	unsigned int addr = io->addr_data;
1472 
1473 	return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1474 }
1475 
1476 static void port_outw(struct si_sm_io *io, unsigned int offset,
1477 		      unsigned char b)
1478 {
1479 	unsigned int addr = io->addr_data;
1480 
1481 	outw(b << io->regshift, addr + (offset * io->regspacing));
1482 }
1483 
1484 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1485 {
1486 	unsigned int addr = io->addr_data;
1487 
1488 	return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1489 }
1490 
1491 static void port_outl(struct si_sm_io *io, unsigned int offset,
1492 		      unsigned char b)
1493 {
1494 	unsigned int addr = io->addr_data;
1495 
1496 	outl(b << io->regshift, addr+(offset * io->regspacing));
1497 }
1498 
1499 static void port_cleanup(struct smi_info *info)
1500 {
1501 	unsigned int addr = info->io.addr_data;
1502 	int          idx;
1503 
1504 	if (addr) {
1505 		for (idx = 0; idx < info->io_size; idx++)
1506 			release_region(addr + idx * info->io.regspacing,
1507 				       info->io.regsize);
1508 	}
1509 }
1510 
1511 static int port_setup(struct smi_info *info)
1512 {
1513 	unsigned int addr = info->io.addr_data;
1514 	int          idx;
1515 
1516 	if (!addr)
1517 		return -ENODEV;
1518 
1519 	info->io_cleanup = port_cleanup;
1520 
1521 	/*
1522 	 * Figure out the actual inb/inw/inl/etc routine to use based
1523 	 * upon the register size.
1524 	 */
1525 	switch (info->io.regsize) {
1526 	case 1:
1527 		info->io.inputb = port_inb;
1528 		info->io.outputb = port_outb;
1529 		break;
1530 	case 2:
1531 		info->io.inputb = port_inw;
1532 		info->io.outputb = port_outw;
1533 		break;
1534 	case 4:
1535 		info->io.inputb = port_inl;
1536 		info->io.outputb = port_outl;
1537 		break;
1538 	default:
1539 		dev_warn(info->dev, "Invalid register size: %d\n",
1540 			 info->io.regsize);
1541 		return -EINVAL;
1542 	}
1543 
1544 	/*
1545 	 * Some BIOSes reserve disjoint I/O regions in their ACPI
1546 	 * tables.  This causes problems when trying to register the
1547 	 * entire I/O region.  Therefore we must register each I/O
1548 	 * port separately.
1549 	 */
1550 	for (idx = 0; idx < info->io_size; idx++) {
1551 		if (request_region(addr + idx * info->io.regspacing,
1552 				   info->io.regsize, DEVICE_NAME) == NULL) {
1553 			/* Undo allocations */
1554 			while (idx--) {
1555 				release_region(addr + idx * info->io.regspacing,
1556 					       info->io.regsize);
1557 			}
1558 			return -EIO;
1559 		}
1560 	}
1561 	return 0;
1562 }
1563 
1564 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1565 {
1566 	return readb((io->addr)+(offset * io->regspacing));
1567 }
1568 
1569 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1570 		     unsigned char b)
1571 {
1572 	writeb(b, (io->addr)+(offset * io->regspacing));
1573 }
1574 
1575 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1576 {
1577 	return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1578 		& 0xff;
1579 }
1580 
1581 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1582 		     unsigned char b)
1583 {
1584 	writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1585 }
1586 
1587 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1588 {
1589 	return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1590 		& 0xff;
1591 }
1592 
1593 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1594 		     unsigned char b)
1595 {
1596 	writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1597 }
1598 
1599 #ifdef readq
1600 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1601 {
1602 	return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1603 		& 0xff;
1604 }
1605 
1606 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1607 		     unsigned char b)
1608 {
1609 	writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1610 }
1611 #endif
1612 
1613 static void mem_cleanup(struct smi_info *info)
1614 {
1615 	unsigned long addr = info->io.addr_data;
1616 	int           mapsize;
1617 
1618 	if (info->io.addr) {
1619 		iounmap(info->io.addr);
1620 
1621 		mapsize = ((info->io_size * info->io.regspacing)
1622 			   - (info->io.regspacing - info->io.regsize));
1623 
1624 		release_mem_region(addr, mapsize);
1625 	}
1626 }
1627 
1628 static int mem_setup(struct smi_info *info)
1629 {
1630 	unsigned long addr = info->io.addr_data;
1631 	int           mapsize;
1632 
1633 	if (!addr)
1634 		return -ENODEV;
1635 
1636 	info->io_cleanup = mem_cleanup;
1637 
1638 	/*
1639 	 * Figure out the actual readb/readw/readl/etc routine to use based
1640 	 * upon the register size.
1641 	 */
1642 	switch (info->io.regsize) {
1643 	case 1:
1644 		info->io.inputb = intf_mem_inb;
1645 		info->io.outputb = intf_mem_outb;
1646 		break;
1647 	case 2:
1648 		info->io.inputb = intf_mem_inw;
1649 		info->io.outputb = intf_mem_outw;
1650 		break;
1651 	case 4:
1652 		info->io.inputb = intf_mem_inl;
1653 		info->io.outputb = intf_mem_outl;
1654 		break;
1655 #ifdef readq
1656 	case 8:
1657 		info->io.inputb = mem_inq;
1658 		info->io.outputb = mem_outq;
1659 		break;
1660 #endif
1661 	default:
1662 		dev_warn(info->dev, "Invalid register size: %d\n",
1663 			 info->io.regsize);
1664 		return -EINVAL;
1665 	}
1666 
1667 	/*
1668 	 * Calculate the total amount of memory to claim.  This is an
1669 	 * unusual looking calculation, but it avoids claiming any
1670 	 * more memory than it has to.  It will claim everything
1671 	 * between the first address to the end of the last full
1672 	 * register.
1673 	 */
1674 	mapsize = ((info->io_size * info->io.regspacing)
1675 		   - (info->io.regspacing - info->io.regsize));
1676 
1677 	if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1678 		return -EIO;
1679 
1680 	info->io.addr = ioremap(addr, mapsize);
1681 	if (info->io.addr == NULL) {
1682 		release_mem_region(addr, mapsize);
1683 		return -EIO;
1684 	}
1685 	return 0;
1686 }
1687 
1688 /*
1689  * Parms come in as <op1>[:op2[:op3...]].  ops are:
1690  *   add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
1691  * Options are:
1692  *   rsp=<regspacing>
1693  *   rsi=<regsize>
1694  *   rsh=<regshift>
1695  *   irq=<irq>
1696  *   ipmb=<ipmb addr>
1697  */
1698 enum hotmod_op { HM_ADD, HM_REMOVE };
1699 struct hotmod_vals {
1700 	char *name;
1701 	int  val;
1702 };
1703 static struct hotmod_vals hotmod_ops[] = {
1704 	{ "add",	HM_ADD },
1705 	{ "remove",	HM_REMOVE },
1706 	{ NULL }
1707 };
1708 static struct hotmod_vals hotmod_si[] = {
1709 	{ "kcs",	SI_KCS },
1710 	{ "smic",	SI_SMIC },
1711 	{ "bt",		SI_BT },
1712 	{ NULL }
1713 };
1714 static struct hotmod_vals hotmod_as[] = {
1715 	{ "mem",	IPMI_MEM_ADDR_SPACE },
1716 	{ "i/o",	IPMI_IO_ADDR_SPACE },
1717 	{ NULL }
1718 };
1719 
1720 static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
1721 {
1722 	char *s;
1723 	int  i;
1724 
1725 	s = strchr(*curr, ',');
1726 	if (!s) {
1727 		printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
1728 		return -EINVAL;
1729 	}
1730 	*s = '\0';
1731 	s++;
1732 	for (i = 0; v[i].name; i++) {
1733 		if (strcmp(*curr, v[i].name) == 0) {
1734 			*val = v[i].val;
1735 			*curr = s;
1736 			return 0;
1737 		}
1738 	}
1739 
1740 	printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
1741 	return -EINVAL;
1742 }
1743 
1744 static int check_hotmod_int_op(const char *curr, const char *option,
1745 			       const char *name, int *val)
1746 {
1747 	char *n;
1748 
1749 	if (strcmp(curr, name) == 0) {
1750 		if (!option) {
1751 			printk(KERN_WARNING PFX
1752 			       "No option given for '%s'\n",
1753 			       curr);
1754 			return -EINVAL;
1755 		}
1756 		*val = simple_strtoul(option, &n, 0);
1757 		if ((*n != '\0') || (*option == '\0')) {
1758 			printk(KERN_WARNING PFX
1759 			       "Bad option given for '%s'\n",
1760 			       curr);
1761 			return -EINVAL;
1762 		}
1763 		return 1;
1764 	}
1765 	return 0;
1766 }
1767 
1768 static struct smi_info *smi_info_alloc(void)
1769 {
1770 	struct smi_info *info = kzalloc(sizeof(*info), GFP_KERNEL);
1771 
1772 	if (info)
1773 		spin_lock_init(&info->si_lock);
1774 	return info;
1775 }
1776 
1777 static int hotmod_handler(const char *val, struct kernel_param *kp)
1778 {
1779 	char *str = kstrdup(val, GFP_KERNEL);
1780 	int  rv;
1781 	char *next, *curr, *s, *n, *o;
1782 	enum hotmod_op op;
1783 	enum si_type si_type;
1784 	int  addr_space;
1785 	unsigned long addr;
1786 	int regspacing;
1787 	int regsize;
1788 	int regshift;
1789 	int irq;
1790 	int ipmb;
1791 	int ival;
1792 	int len;
1793 	struct smi_info *info;
1794 
1795 	if (!str)
1796 		return -ENOMEM;
1797 
1798 	/* Kill any trailing spaces, as we can get a "\n" from echo. */
1799 	len = strlen(str);
1800 	ival = len - 1;
1801 	while ((ival >= 0) && isspace(str[ival])) {
1802 		str[ival] = '\0';
1803 		ival--;
1804 	}
1805 
1806 	for (curr = str; curr; curr = next) {
1807 		regspacing = 1;
1808 		regsize = 1;
1809 		regshift = 0;
1810 		irq = 0;
1811 		ipmb = 0; /* Choose the default if not specified */
1812 
1813 		next = strchr(curr, ':');
1814 		if (next) {
1815 			*next = '\0';
1816 			next++;
1817 		}
1818 
1819 		rv = parse_str(hotmod_ops, &ival, "operation", &curr);
1820 		if (rv)
1821 			break;
1822 		op = ival;
1823 
1824 		rv = parse_str(hotmod_si, &ival, "interface type", &curr);
1825 		if (rv)
1826 			break;
1827 		si_type = ival;
1828 
1829 		rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
1830 		if (rv)
1831 			break;
1832 
1833 		s = strchr(curr, ',');
1834 		if (s) {
1835 			*s = '\0';
1836 			s++;
1837 		}
1838 		addr = simple_strtoul(curr, &n, 0);
1839 		if ((*n != '\0') || (*curr == '\0')) {
1840 			printk(KERN_WARNING PFX "Invalid hotmod address"
1841 			       " '%s'\n", curr);
1842 			break;
1843 		}
1844 
1845 		while (s) {
1846 			curr = s;
1847 			s = strchr(curr, ',');
1848 			if (s) {
1849 				*s = '\0';
1850 				s++;
1851 			}
1852 			o = strchr(curr, '=');
1853 			if (o) {
1854 				*o = '\0';
1855 				o++;
1856 			}
1857 			rv = check_hotmod_int_op(curr, o, "rsp", &regspacing);
1858 			if (rv < 0)
1859 				goto out;
1860 			else if (rv)
1861 				continue;
1862 			rv = check_hotmod_int_op(curr, o, "rsi", &regsize);
1863 			if (rv < 0)
1864 				goto out;
1865 			else if (rv)
1866 				continue;
1867 			rv = check_hotmod_int_op(curr, o, "rsh", &regshift);
1868 			if (rv < 0)
1869 				goto out;
1870 			else if (rv)
1871 				continue;
1872 			rv = check_hotmod_int_op(curr, o, "irq", &irq);
1873 			if (rv < 0)
1874 				goto out;
1875 			else if (rv)
1876 				continue;
1877 			rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
1878 			if (rv < 0)
1879 				goto out;
1880 			else if (rv)
1881 				continue;
1882 
1883 			rv = -EINVAL;
1884 			printk(KERN_WARNING PFX
1885 			       "Invalid hotmod option '%s'\n",
1886 			       curr);
1887 			goto out;
1888 		}
1889 
1890 		if (op == HM_ADD) {
1891 			info = smi_info_alloc();
1892 			if (!info) {
1893 				rv = -ENOMEM;
1894 				goto out;
1895 			}
1896 
1897 			info->addr_source = SI_HOTMOD;
1898 			info->si_type = si_type;
1899 			info->io.addr_data = addr;
1900 			info->io.addr_type = addr_space;
1901 			if (addr_space == IPMI_MEM_ADDR_SPACE)
1902 				info->io_setup = mem_setup;
1903 			else
1904 				info->io_setup = port_setup;
1905 
1906 			info->io.addr = NULL;
1907 			info->io.regspacing = regspacing;
1908 			if (!info->io.regspacing)
1909 				info->io.regspacing = DEFAULT_REGSPACING;
1910 			info->io.regsize = regsize;
1911 			if (!info->io.regsize)
1912 				info->io.regsize = DEFAULT_REGSPACING;
1913 			info->io.regshift = regshift;
1914 			info->irq = irq;
1915 			if (info->irq)
1916 				info->irq_setup = std_irq_setup;
1917 			info->slave_addr = ipmb;
1918 
1919 			rv = add_smi(info);
1920 			if (rv) {
1921 				kfree(info);
1922 				goto out;
1923 			}
1924 			rv = try_smi_init(info);
1925 			if (rv) {
1926 				cleanup_one_si(info);
1927 				goto out;
1928 			}
1929 		} else {
1930 			/* remove */
1931 			struct smi_info *e, *tmp_e;
1932 
1933 			mutex_lock(&smi_infos_lock);
1934 			list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
1935 				if (e->io.addr_type != addr_space)
1936 					continue;
1937 				if (e->si_type != si_type)
1938 					continue;
1939 				if (e->io.addr_data == addr)
1940 					cleanup_one_si(e);
1941 			}
1942 			mutex_unlock(&smi_infos_lock);
1943 		}
1944 	}
1945 	rv = len;
1946  out:
1947 	kfree(str);
1948 	return rv;
1949 }
1950 
1951 static int hardcode_find_bmc(void)
1952 {
1953 	int ret = -ENODEV;
1954 	int             i;
1955 	struct smi_info *info;
1956 
1957 	for (i = 0; i < SI_MAX_PARMS; i++) {
1958 		if (!ports[i] && !addrs[i])
1959 			continue;
1960 
1961 		info = smi_info_alloc();
1962 		if (!info)
1963 			return -ENOMEM;
1964 
1965 		info->addr_source = SI_HARDCODED;
1966 		printk(KERN_INFO PFX "probing via hardcoded address\n");
1967 
1968 		if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1969 			info->si_type = SI_KCS;
1970 		} else if (strcmp(si_type[i], "smic") == 0) {
1971 			info->si_type = SI_SMIC;
1972 		} else if (strcmp(si_type[i], "bt") == 0) {
1973 			info->si_type = SI_BT;
1974 		} else {
1975 			printk(KERN_WARNING PFX "Interface type specified "
1976 			       "for interface %d, was invalid: %s\n",
1977 			       i, si_type[i]);
1978 			kfree(info);
1979 			continue;
1980 		}
1981 
1982 		if (ports[i]) {
1983 			/* An I/O port */
1984 			info->io_setup = port_setup;
1985 			info->io.addr_data = ports[i];
1986 			info->io.addr_type = IPMI_IO_ADDR_SPACE;
1987 		} else if (addrs[i]) {
1988 			/* A memory port */
1989 			info->io_setup = mem_setup;
1990 			info->io.addr_data = addrs[i];
1991 			info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1992 		} else {
1993 			printk(KERN_WARNING PFX "Interface type specified "
1994 			       "for interface %d, but port and address were "
1995 			       "not set or set to zero.\n", i);
1996 			kfree(info);
1997 			continue;
1998 		}
1999 
2000 		info->io.addr = NULL;
2001 		info->io.regspacing = regspacings[i];
2002 		if (!info->io.regspacing)
2003 			info->io.regspacing = DEFAULT_REGSPACING;
2004 		info->io.regsize = regsizes[i];
2005 		if (!info->io.regsize)
2006 			info->io.regsize = DEFAULT_REGSPACING;
2007 		info->io.regshift = regshifts[i];
2008 		info->irq = irqs[i];
2009 		if (info->irq)
2010 			info->irq_setup = std_irq_setup;
2011 		info->slave_addr = slave_addrs[i];
2012 
2013 		if (!add_smi(info)) {
2014 			if (try_smi_init(info))
2015 				cleanup_one_si(info);
2016 			ret = 0;
2017 		} else {
2018 			kfree(info);
2019 		}
2020 	}
2021 	return ret;
2022 }
2023 
2024 #ifdef CONFIG_ACPI
2025 
2026 #include <linux/acpi.h>
2027 
2028 /*
2029  * Once we get an ACPI failure, we don't try any more, because we go
2030  * through the tables sequentially.  Once we don't find a table, there
2031  * are no more.
2032  */
2033 static int acpi_failure;
2034 
2035 /* For GPE-type interrupts. */
2036 static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
2037 	u32 gpe_number, void *context)
2038 {
2039 	struct smi_info *smi_info = context;
2040 	unsigned long   flags;
2041 #ifdef DEBUG_TIMING
2042 	struct timeval t;
2043 #endif
2044 
2045 	spin_lock_irqsave(&(smi_info->si_lock), flags);
2046 
2047 	smi_inc_stat(smi_info, interrupts);
2048 
2049 #ifdef DEBUG_TIMING
2050 	do_gettimeofday(&t);
2051 	printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
2052 #endif
2053 	smi_event_handler(smi_info, 0);
2054 	spin_unlock_irqrestore(&(smi_info->si_lock), flags);
2055 
2056 	return ACPI_INTERRUPT_HANDLED;
2057 }
2058 
2059 static void acpi_gpe_irq_cleanup(struct smi_info *info)
2060 {
2061 	if (!info->irq)
2062 		return;
2063 
2064 	acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
2065 }
2066 
2067 static int acpi_gpe_irq_setup(struct smi_info *info)
2068 {
2069 	acpi_status status;
2070 
2071 	if (!info->irq)
2072 		return 0;
2073 
2074 	/* FIXME - is level triggered right? */
2075 	status = acpi_install_gpe_handler(NULL,
2076 					  info->irq,
2077 					  ACPI_GPE_LEVEL_TRIGGERED,
2078 					  &ipmi_acpi_gpe,
2079 					  info);
2080 	if (status != AE_OK) {
2081 		dev_warn(info->dev, "%s unable to claim ACPI GPE %d,"
2082 			 " running polled\n", DEVICE_NAME, info->irq);
2083 		info->irq = 0;
2084 		return -EINVAL;
2085 	} else {
2086 		info->irq_cleanup = acpi_gpe_irq_cleanup;
2087 		dev_info(info->dev, "Using ACPI GPE %d\n", info->irq);
2088 		return 0;
2089 	}
2090 }
2091 
2092 /*
2093  * Defined at
2094  * http://h21007.www2.hp.com/portal/download/files/unprot/hpspmi.pdf
2095  */
2096 struct SPMITable {
2097 	s8	Signature[4];
2098 	u32	Length;
2099 	u8	Revision;
2100 	u8	Checksum;
2101 	s8	OEMID[6];
2102 	s8	OEMTableID[8];
2103 	s8	OEMRevision[4];
2104 	s8	CreatorID[4];
2105 	s8	CreatorRevision[4];
2106 	u8	InterfaceType;
2107 	u8	IPMIlegacy;
2108 	s16	SpecificationRevision;
2109 
2110 	/*
2111 	 * Bit 0 - SCI interrupt supported
2112 	 * Bit 1 - I/O APIC/SAPIC
2113 	 */
2114 	u8	InterruptType;
2115 
2116 	/*
2117 	 * If bit 0 of InterruptType is set, then this is the SCI
2118 	 * interrupt in the GPEx_STS register.
2119 	 */
2120 	u8	GPE;
2121 
2122 	s16	Reserved;
2123 
2124 	/*
2125 	 * If bit 1 of InterruptType is set, then this is the I/O
2126 	 * APIC/SAPIC interrupt.
2127 	 */
2128 	u32	GlobalSystemInterrupt;
2129 
2130 	/* The actual register address. */
2131 	struct acpi_generic_address addr;
2132 
2133 	u8	UID[4];
2134 
2135 	s8      spmi_id[1]; /* A '\0' terminated array starts here. */
2136 };
2137 
2138 static int try_init_spmi(struct SPMITable *spmi)
2139 {
2140 	struct smi_info  *info;
2141 	int rv;
2142 
2143 	if (spmi->IPMIlegacy != 1) {
2144 		printk(KERN_INFO PFX "Bad SPMI legacy %d\n", spmi->IPMIlegacy);
2145 		return -ENODEV;
2146 	}
2147 
2148 	info = smi_info_alloc();
2149 	if (!info) {
2150 		printk(KERN_ERR PFX "Could not allocate SI data (3)\n");
2151 		return -ENOMEM;
2152 	}
2153 
2154 	info->addr_source = SI_SPMI;
2155 	printk(KERN_INFO PFX "probing via SPMI\n");
2156 
2157 	/* Figure out the interface type. */
2158 	switch (spmi->InterfaceType) {
2159 	case 1:	/* KCS */
2160 		info->si_type = SI_KCS;
2161 		break;
2162 	case 2:	/* SMIC */
2163 		info->si_type = SI_SMIC;
2164 		break;
2165 	case 3:	/* BT */
2166 		info->si_type = SI_BT;
2167 		break;
2168 	case 4: /* SSIF, just ignore */
2169 		kfree(info);
2170 		return -EIO;
2171 	default:
2172 		printk(KERN_INFO PFX "Unknown ACPI/SPMI SI type %d\n",
2173 		       spmi->InterfaceType);
2174 		kfree(info);
2175 		return -EIO;
2176 	}
2177 
2178 	if (spmi->InterruptType & 1) {
2179 		/* We've got a GPE interrupt. */
2180 		info->irq = spmi->GPE;
2181 		info->irq_setup = acpi_gpe_irq_setup;
2182 	} else if (spmi->InterruptType & 2) {
2183 		/* We've got an APIC/SAPIC interrupt. */
2184 		info->irq = spmi->GlobalSystemInterrupt;
2185 		info->irq_setup = std_irq_setup;
2186 	} else {
2187 		/* Use the default interrupt setting. */
2188 		info->irq = 0;
2189 		info->irq_setup = NULL;
2190 	}
2191 
2192 	if (spmi->addr.bit_width) {
2193 		/* A (hopefully) properly formed register bit width. */
2194 		info->io.regspacing = spmi->addr.bit_width / 8;
2195 	} else {
2196 		info->io.regspacing = DEFAULT_REGSPACING;
2197 	}
2198 	info->io.regsize = info->io.regspacing;
2199 	info->io.regshift = spmi->addr.bit_offset;
2200 
2201 	if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
2202 		info->io_setup = mem_setup;
2203 		info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2204 	} else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
2205 		info->io_setup = port_setup;
2206 		info->io.addr_type = IPMI_IO_ADDR_SPACE;
2207 	} else {
2208 		kfree(info);
2209 		printk(KERN_WARNING PFX "Unknown ACPI I/O Address type\n");
2210 		return -EIO;
2211 	}
2212 	info->io.addr_data = spmi->addr.address;
2213 
2214 	pr_info("ipmi_si: SPMI: %s %#lx regsize %d spacing %d irq %d\n",
2215 		 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
2216 		 info->io.addr_data, info->io.regsize, info->io.regspacing,
2217 		 info->irq);
2218 
2219 	rv = add_smi(info);
2220 	if (rv)
2221 		kfree(info);
2222 
2223 	return rv;
2224 }
2225 
2226 static void spmi_find_bmc(void)
2227 {
2228 	acpi_status      status;
2229 	struct SPMITable *spmi;
2230 	int              i;
2231 
2232 	if (acpi_disabled)
2233 		return;
2234 
2235 	if (acpi_failure)
2236 		return;
2237 
2238 	for (i = 0; ; i++) {
2239 		status = acpi_get_table(ACPI_SIG_SPMI, i+1,
2240 					(struct acpi_table_header **)&spmi);
2241 		if (status != AE_OK)
2242 			return;
2243 
2244 		try_init_spmi(spmi);
2245 	}
2246 }
2247 
2248 static int ipmi_pnp_probe(struct pnp_dev *dev,
2249 				    const struct pnp_device_id *dev_id)
2250 {
2251 	struct acpi_device *acpi_dev;
2252 	struct smi_info *info;
2253 	struct resource *res, *res_second;
2254 	acpi_handle handle;
2255 	acpi_status status;
2256 	unsigned long long tmp;
2257 	int rv;
2258 
2259 	acpi_dev = pnp_acpi_device(dev);
2260 	if (!acpi_dev)
2261 		return -ENODEV;
2262 
2263 	info = smi_info_alloc();
2264 	if (!info)
2265 		return -ENOMEM;
2266 
2267 	info->addr_source = SI_ACPI;
2268 	printk(KERN_INFO PFX "probing via ACPI\n");
2269 
2270 	handle = acpi_dev->handle;
2271 	info->addr_info.acpi_info.acpi_handle = handle;
2272 
2273 	/* _IFT tells us the interface type: KCS, BT, etc */
2274 	status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp);
2275 	if (ACPI_FAILURE(status))
2276 		goto err_free;
2277 
2278 	switch (tmp) {
2279 	case 1:
2280 		info->si_type = SI_KCS;
2281 		break;
2282 	case 2:
2283 		info->si_type = SI_SMIC;
2284 		break;
2285 	case 3:
2286 		info->si_type = SI_BT;
2287 		break;
2288 	case 4: /* SSIF, just ignore */
2289 		goto err_free;
2290 	default:
2291 		dev_info(&dev->dev, "unknown IPMI type %lld\n", tmp);
2292 		goto err_free;
2293 	}
2294 
2295 	res = pnp_get_resource(dev, IORESOURCE_IO, 0);
2296 	if (res) {
2297 		info->io_setup = port_setup;
2298 		info->io.addr_type = IPMI_IO_ADDR_SPACE;
2299 	} else {
2300 		res = pnp_get_resource(dev, IORESOURCE_MEM, 0);
2301 		if (res) {
2302 			info->io_setup = mem_setup;
2303 			info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2304 		}
2305 	}
2306 	if (!res) {
2307 		dev_err(&dev->dev, "no I/O or memory address\n");
2308 		goto err_free;
2309 	}
2310 	info->io.addr_data = res->start;
2311 
2312 	info->io.regspacing = DEFAULT_REGSPACING;
2313 	res_second = pnp_get_resource(dev,
2314 			       (info->io.addr_type == IPMI_IO_ADDR_SPACE) ?
2315 					IORESOURCE_IO : IORESOURCE_MEM,
2316 			       1);
2317 	if (res_second) {
2318 		if (res_second->start > info->io.addr_data)
2319 			info->io.regspacing = res_second->start - info->io.addr_data;
2320 	}
2321 	info->io.regsize = DEFAULT_REGSPACING;
2322 	info->io.regshift = 0;
2323 
2324 	/* If _GPE exists, use it; otherwise use standard interrupts */
2325 	status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
2326 	if (ACPI_SUCCESS(status)) {
2327 		info->irq = tmp;
2328 		info->irq_setup = acpi_gpe_irq_setup;
2329 	} else if (pnp_irq_valid(dev, 0)) {
2330 		info->irq = pnp_irq(dev, 0);
2331 		info->irq_setup = std_irq_setup;
2332 	}
2333 
2334 	info->dev = &dev->dev;
2335 	pnp_set_drvdata(dev, info);
2336 
2337 	dev_info(info->dev, "%pR regsize %d spacing %d irq %d\n",
2338 		 res, info->io.regsize, info->io.regspacing,
2339 		 info->irq);
2340 
2341 	rv = add_smi(info);
2342 	if (rv)
2343 		kfree(info);
2344 
2345 	return rv;
2346 
2347 err_free:
2348 	kfree(info);
2349 	return -EINVAL;
2350 }
2351 
2352 static void ipmi_pnp_remove(struct pnp_dev *dev)
2353 {
2354 	struct smi_info *info = pnp_get_drvdata(dev);
2355 
2356 	cleanup_one_si(info);
2357 }
2358 
2359 static const struct pnp_device_id pnp_dev_table[] = {
2360 	{"IPI0001", 0},
2361 	{"", 0},
2362 };
2363 
2364 static struct pnp_driver ipmi_pnp_driver = {
2365 	.name		= DEVICE_NAME,
2366 	.probe		= ipmi_pnp_probe,
2367 	.remove		= ipmi_pnp_remove,
2368 	.id_table	= pnp_dev_table,
2369 };
2370 
2371 MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
2372 #endif
2373 
2374 #ifdef CONFIG_DMI
2375 struct dmi_ipmi_data {
2376 	u8   		type;
2377 	u8   		addr_space;
2378 	unsigned long	base_addr;
2379 	u8   		irq;
2380 	u8              offset;
2381 	u8              slave_addr;
2382 };
2383 
2384 static int decode_dmi(const struct dmi_header *dm,
2385 				struct dmi_ipmi_data *dmi)
2386 {
2387 	const u8	*data = (const u8 *)dm;
2388 	unsigned long  	base_addr;
2389 	u8		reg_spacing;
2390 	u8              len = dm->length;
2391 
2392 	dmi->type = data[4];
2393 
2394 	memcpy(&base_addr, data+8, sizeof(unsigned long));
2395 	if (len >= 0x11) {
2396 		if (base_addr & 1) {
2397 			/* I/O */
2398 			base_addr &= 0xFFFE;
2399 			dmi->addr_space = IPMI_IO_ADDR_SPACE;
2400 		} else
2401 			/* Memory */
2402 			dmi->addr_space = IPMI_MEM_ADDR_SPACE;
2403 
2404 		/* If bit 4 of byte 0x10 is set, then the lsb for the address
2405 		   is odd. */
2406 		dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
2407 
2408 		dmi->irq = data[0x11];
2409 
2410 		/* The top two bits of byte 0x10 hold the register spacing. */
2411 		reg_spacing = (data[0x10] & 0xC0) >> 6;
2412 		switch (reg_spacing) {
2413 		case 0x00: /* Byte boundaries */
2414 		    dmi->offset = 1;
2415 		    break;
2416 		case 0x01: /* 32-bit boundaries */
2417 		    dmi->offset = 4;
2418 		    break;
2419 		case 0x02: /* 16-byte boundaries */
2420 		    dmi->offset = 16;
2421 		    break;
2422 		default:
2423 		    /* Some other interface, just ignore it. */
2424 		    return -EIO;
2425 		}
2426 	} else {
2427 		/* Old DMI spec. */
2428 		/*
2429 		 * Note that technically, the lower bit of the base
2430 		 * address should be 1 if the address is I/O and 0 if
2431 		 * the address is in memory.  So many systems get that
2432 		 * wrong (and all that I have seen are I/O) so we just
2433 		 * ignore that bit and assume I/O.  Systems that use
2434 		 * memory should use the newer spec, anyway.
2435 		 */
2436 		dmi->base_addr = base_addr & 0xfffe;
2437 		dmi->addr_space = IPMI_IO_ADDR_SPACE;
2438 		dmi->offset = 1;
2439 	}
2440 
2441 	dmi->slave_addr = data[6];
2442 
2443 	return 0;
2444 }
2445 
2446 static void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
2447 {
2448 	struct smi_info *info;
2449 
2450 	info = smi_info_alloc();
2451 	if (!info) {
2452 		printk(KERN_ERR PFX "Could not allocate SI data\n");
2453 		return;
2454 	}
2455 
2456 	info->addr_source = SI_SMBIOS;
2457 	printk(KERN_INFO PFX "probing via SMBIOS\n");
2458 
2459 	switch (ipmi_data->type) {
2460 	case 0x01: /* KCS */
2461 		info->si_type = SI_KCS;
2462 		break;
2463 	case 0x02: /* SMIC */
2464 		info->si_type = SI_SMIC;
2465 		break;
2466 	case 0x03: /* BT */
2467 		info->si_type = SI_BT;
2468 		break;
2469 	default:
2470 		kfree(info);
2471 		return;
2472 	}
2473 
2474 	switch (ipmi_data->addr_space) {
2475 	case IPMI_MEM_ADDR_SPACE:
2476 		info->io_setup = mem_setup;
2477 		info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2478 		break;
2479 
2480 	case IPMI_IO_ADDR_SPACE:
2481 		info->io_setup = port_setup;
2482 		info->io.addr_type = IPMI_IO_ADDR_SPACE;
2483 		break;
2484 
2485 	default:
2486 		kfree(info);
2487 		printk(KERN_WARNING PFX "Unknown SMBIOS I/O Address type: %d\n",
2488 		       ipmi_data->addr_space);
2489 		return;
2490 	}
2491 	info->io.addr_data = ipmi_data->base_addr;
2492 
2493 	info->io.regspacing = ipmi_data->offset;
2494 	if (!info->io.regspacing)
2495 		info->io.regspacing = DEFAULT_REGSPACING;
2496 	info->io.regsize = DEFAULT_REGSPACING;
2497 	info->io.regshift = 0;
2498 
2499 	info->slave_addr = ipmi_data->slave_addr;
2500 
2501 	info->irq = ipmi_data->irq;
2502 	if (info->irq)
2503 		info->irq_setup = std_irq_setup;
2504 
2505 	pr_info("ipmi_si: SMBIOS: %s %#lx regsize %d spacing %d irq %d\n",
2506 		 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
2507 		 info->io.addr_data, info->io.regsize, info->io.regspacing,
2508 		 info->irq);
2509 
2510 	if (add_smi(info))
2511 		kfree(info);
2512 }
2513 
2514 static void dmi_find_bmc(void)
2515 {
2516 	const struct dmi_device *dev = NULL;
2517 	struct dmi_ipmi_data data;
2518 	int                  rv;
2519 
2520 	while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
2521 		memset(&data, 0, sizeof(data));
2522 		rv = decode_dmi((const struct dmi_header *) dev->device_data,
2523 				&data);
2524 		if (!rv)
2525 			try_init_dmi(&data);
2526 	}
2527 }
2528 #endif /* CONFIG_DMI */
2529 
2530 #ifdef CONFIG_PCI
2531 
2532 #define PCI_ERMC_CLASSCODE		0x0C0700
2533 #define PCI_ERMC_CLASSCODE_MASK		0xffffff00
2534 #define PCI_ERMC_CLASSCODE_TYPE_MASK	0xff
2535 #define PCI_ERMC_CLASSCODE_TYPE_SMIC	0x00
2536 #define PCI_ERMC_CLASSCODE_TYPE_KCS	0x01
2537 #define PCI_ERMC_CLASSCODE_TYPE_BT	0x02
2538 
2539 #define PCI_HP_VENDOR_ID    0x103C
2540 #define PCI_MMC_DEVICE_ID   0x121A
2541 #define PCI_MMC_ADDR_CW     0x10
2542 
2543 static void ipmi_pci_cleanup(struct smi_info *info)
2544 {
2545 	struct pci_dev *pdev = info->addr_source_data;
2546 
2547 	pci_disable_device(pdev);
2548 }
2549 
2550 static int ipmi_pci_probe_regspacing(struct smi_info *info)
2551 {
2552 	if (info->si_type == SI_KCS) {
2553 		unsigned char	status;
2554 		int		regspacing;
2555 
2556 		info->io.regsize = DEFAULT_REGSIZE;
2557 		info->io.regshift = 0;
2558 		info->io_size = 2;
2559 		info->handlers = &kcs_smi_handlers;
2560 
2561 		/* detect 1, 4, 16byte spacing */
2562 		for (regspacing = DEFAULT_REGSPACING; regspacing <= 16;) {
2563 			info->io.regspacing = regspacing;
2564 			if (info->io_setup(info)) {
2565 				dev_err(info->dev,
2566 					"Could not setup I/O space\n");
2567 				return DEFAULT_REGSPACING;
2568 			}
2569 			/* write invalid cmd */
2570 			info->io.outputb(&info->io, 1, 0x10);
2571 			/* read status back */
2572 			status = info->io.inputb(&info->io, 1);
2573 			info->io_cleanup(info);
2574 			if (status)
2575 				return regspacing;
2576 			regspacing *= 4;
2577 		}
2578 	}
2579 	return DEFAULT_REGSPACING;
2580 }
2581 
2582 static int ipmi_pci_probe(struct pci_dev *pdev,
2583 				    const struct pci_device_id *ent)
2584 {
2585 	int rv;
2586 	int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
2587 	struct smi_info *info;
2588 
2589 	info = smi_info_alloc();
2590 	if (!info)
2591 		return -ENOMEM;
2592 
2593 	info->addr_source = SI_PCI;
2594 	dev_info(&pdev->dev, "probing via PCI");
2595 
2596 	switch (class_type) {
2597 	case PCI_ERMC_CLASSCODE_TYPE_SMIC:
2598 		info->si_type = SI_SMIC;
2599 		break;
2600 
2601 	case PCI_ERMC_CLASSCODE_TYPE_KCS:
2602 		info->si_type = SI_KCS;
2603 		break;
2604 
2605 	case PCI_ERMC_CLASSCODE_TYPE_BT:
2606 		info->si_type = SI_BT;
2607 		break;
2608 
2609 	default:
2610 		kfree(info);
2611 		dev_info(&pdev->dev, "Unknown IPMI type: %d\n", class_type);
2612 		return -ENOMEM;
2613 	}
2614 
2615 	rv = pci_enable_device(pdev);
2616 	if (rv) {
2617 		dev_err(&pdev->dev, "couldn't enable PCI device\n");
2618 		kfree(info);
2619 		return rv;
2620 	}
2621 
2622 	info->addr_source_cleanup = ipmi_pci_cleanup;
2623 	info->addr_source_data = pdev;
2624 
2625 	if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2626 		info->io_setup = port_setup;
2627 		info->io.addr_type = IPMI_IO_ADDR_SPACE;
2628 	} else {
2629 		info->io_setup = mem_setup;
2630 		info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2631 	}
2632 	info->io.addr_data = pci_resource_start(pdev, 0);
2633 
2634 	info->io.regspacing = ipmi_pci_probe_regspacing(info);
2635 	info->io.regsize = DEFAULT_REGSIZE;
2636 	info->io.regshift = 0;
2637 
2638 	info->irq = pdev->irq;
2639 	if (info->irq)
2640 		info->irq_setup = std_irq_setup;
2641 
2642 	info->dev = &pdev->dev;
2643 	pci_set_drvdata(pdev, info);
2644 
2645 	dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n",
2646 		&pdev->resource[0], info->io.regsize, info->io.regspacing,
2647 		info->irq);
2648 
2649 	rv = add_smi(info);
2650 	if (rv) {
2651 		kfree(info);
2652 		pci_disable_device(pdev);
2653 	}
2654 
2655 	return rv;
2656 }
2657 
2658 static void ipmi_pci_remove(struct pci_dev *pdev)
2659 {
2660 	struct smi_info *info = pci_get_drvdata(pdev);
2661 	cleanup_one_si(info);
2662 	pci_disable_device(pdev);
2663 }
2664 
2665 static struct pci_device_id ipmi_pci_devices[] = {
2666 	{ PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
2667 	{ PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
2668 	{ 0, }
2669 };
2670 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
2671 
2672 static struct pci_driver ipmi_pci_driver = {
2673 	.name =         DEVICE_NAME,
2674 	.id_table =     ipmi_pci_devices,
2675 	.probe =        ipmi_pci_probe,
2676 	.remove =       ipmi_pci_remove,
2677 };
2678 #endif /* CONFIG_PCI */
2679 
2680 static struct of_device_id ipmi_match[];
2681 static int ipmi_probe(struct platform_device *dev)
2682 {
2683 #ifdef CONFIG_OF
2684 	const struct of_device_id *match;
2685 	struct smi_info *info;
2686 	struct resource resource;
2687 	const __be32 *regsize, *regspacing, *regshift;
2688 	struct device_node *np = dev->dev.of_node;
2689 	int ret;
2690 	int proplen;
2691 
2692 	dev_info(&dev->dev, "probing via device tree\n");
2693 
2694 	match = of_match_device(ipmi_match, &dev->dev);
2695 	if (!match)
2696 		return -EINVAL;
2697 
2698 	if (!of_device_is_available(np))
2699 		return -EINVAL;
2700 
2701 	ret = of_address_to_resource(np, 0, &resource);
2702 	if (ret) {
2703 		dev_warn(&dev->dev, PFX "invalid address from OF\n");
2704 		return ret;
2705 	}
2706 
2707 	regsize = of_get_property(np, "reg-size", &proplen);
2708 	if (regsize && proplen != 4) {
2709 		dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
2710 		return -EINVAL;
2711 	}
2712 
2713 	regspacing = of_get_property(np, "reg-spacing", &proplen);
2714 	if (regspacing && proplen != 4) {
2715 		dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
2716 		return -EINVAL;
2717 	}
2718 
2719 	regshift = of_get_property(np, "reg-shift", &proplen);
2720 	if (regshift && proplen != 4) {
2721 		dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
2722 		return -EINVAL;
2723 	}
2724 
2725 	info = smi_info_alloc();
2726 
2727 	if (!info) {
2728 		dev_err(&dev->dev,
2729 			"could not allocate memory for OF probe\n");
2730 		return -ENOMEM;
2731 	}
2732 
2733 	info->si_type		= (enum si_type) match->data;
2734 	info->addr_source	= SI_DEVICETREE;
2735 	info->irq_setup		= std_irq_setup;
2736 
2737 	if (resource.flags & IORESOURCE_IO) {
2738 		info->io_setup		= port_setup;
2739 		info->io.addr_type	= IPMI_IO_ADDR_SPACE;
2740 	} else {
2741 		info->io_setup		= mem_setup;
2742 		info->io.addr_type	= IPMI_MEM_ADDR_SPACE;
2743 	}
2744 
2745 	info->io.addr_data	= resource.start;
2746 
2747 	info->io.regsize	= regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE;
2748 	info->io.regspacing	= regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING;
2749 	info->io.regshift	= regshift ? be32_to_cpup(regshift) : 0;
2750 
2751 	info->irq		= irq_of_parse_and_map(dev->dev.of_node, 0);
2752 	info->dev		= &dev->dev;
2753 
2754 	dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",
2755 		info->io.addr_data, info->io.regsize, info->io.regspacing,
2756 		info->irq);
2757 
2758 	dev_set_drvdata(&dev->dev, info);
2759 
2760 	ret = add_smi(info);
2761 	if (ret) {
2762 		kfree(info);
2763 		return ret;
2764 	}
2765 #endif
2766 	return 0;
2767 }
2768 
2769 static int ipmi_remove(struct platform_device *dev)
2770 {
2771 #ifdef CONFIG_OF
2772 	cleanup_one_si(dev_get_drvdata(&dev->dev));
2773 #endif
2774 	return 0;
2775 }
2776 
2777 static struct of_device_id ipmi_match[] =
2778 {
2779 	{ .type = "ipmi", .compatible = "ipmi-kcs",
2780 	  .data = (void *)(unsigned long) SI_KCS },
2781 	{ .type = "ipmi", .compatible = "ipmi-smic",
2782 	  .data = (void *)(unsigned long) SI_SMIC },
2783 	{ .type = "ipmi", .compatible = "ipmi-bt",
2784 	  .data = (void *)(unsigned long) SI_BT },
2785 	{},
2786 };
2787 
2788 static struct platform_driver ipmi_driver = {
2789 	.driver = {
2790 		.name = DEVICE_NAME,
2791 		.of_match_table = ipmi_match,
2792 	},
2793 	.probe		= ipmi_probe,
2794 	.remove		= ipmi_remove,
2795 };
2796 
2797 #ifdef CONFIG_PARISC
2798 static int ipmi_parisc_probe(struct parisc_device *dev)
2799 {
2800 	struct smi_info *info;
2801 	int rv;
2802 
2803 	info = smi_info_alloc();
2804 
2805 	if (!info) {
2806 		dev_err(&dev->dev,
2807 			"could not allocate memory for PARISC probe\n");
2808 		return -ENOMEM;
2809 	}
2810 
2811 	info->si_type		= SI_KCS;
2812 	info->addr_source	= SI_DEVICETREE;
2813 	info->io_setup		= mem_setup;
2814 	info->io.addr_type	= IPMI_MEM_ADDR_SPACE;
2815 	info->io.addr_data	= dev->hpa.start;
2816 	info->io.regsize	= 1;
2817 	info->io.regspacing	= 1;
2818 	info->io.regshift	= 0;
2819 	info->irq		= 0; /* no interrupt */
2820 	info->irq_setup		= NULL;
2821 	info->dev		= &dev->dev;
2822 
2823 	dev_dbg(&dev->dev, "addr 0x%lx\n", info->io.addr_data);
2824 
2825 	dev_set_drvdata(&dev->dev, info);
2826 
2827 	rv = add_smi(info);
2828 	if (rv) {
2829 		kfree(info);
2830 		return rv;
2831 	}
2832 
2833 	return 0;
2834 }
2835 
2836 static int ipmi_parisc_remove(struct parisc_device *dev)
2837 {
2838 	cleanup_one_si(dev_get_drvdata(&dev->dev));
2839 	return 0;
2840 }
2841 
2842 static struct parisc_device_id ipmi_parisc_tbl[] = {
2843 	{ HPHW_MC, HVERSION_REV_ANY_ID, 0x004, 0xC0 },
2844 	{ 0, }
2845 };
2846 
2847 static struct parisc_driver ipmi_parisc_driver = {
2848 	.name =		"ipmi",
2849 	.id_table =	ipmi_parisc_tbl,
2850 	.probe =	ipmi_parisc_probe,
2851 	.remove =	ipmi_parisc_remove,
2852 };
2853 #endif /* CONFIG_PARISC */
2854 
2855 static int wait_for_msg_done(struct smi_info *smi_info)
2856 {
2857 	enum si_sm_result     smi_result;
2858 
2859 	smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
2860 	for (;;) {
2861 		if (smi_result == SI_SM_CALL_WITH_DELAY ||
2862 		    smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
2863 			schedule_timeout_uninterruptible(1);
2864 			smi_result = smi_info->handlers->event(
2865 				smi_info->si_sm, jiffies_to_usecs(1));
2866 		} else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
2867 			smi_result = smi_info->handlers->event(
2868 				smi_info->si_sm, 0);
2869 		} else
2870 			break;
2871 	}
2872 	if (smi_result == SI_SM_HOSED)
2873 		/*
2874 		 * We couldn't get the state machine to run, so whatever's at
2875 		 * the port is probably not an IPMI SMI interface.
2876 		 */
2877 		return -ENODEV;
2878 
2879 	return 0;
2880 }
2881 
2882 static int try_get_dev_id(struct smi_info *smi_info)
2883 {
2884 	unsigned char         msg[2];
2885 	unsigned char         *resp;
2886 	unsigned long         resp_len;
2887 	int                   rv = 0;
2888 
2889 	resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2890 	if (!resp)
2891 		return -ENOMEM;
2892 
2893 	/*
2894 	 * Do a Get Device ID command, since it comes back with some
2895 	 * useful info.
2896 	 */
2897 	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2898 	msg[1] = IPMI_GET_DEVICE_ID_CMD;
2899 	smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2900 
2901 	rv = wait_for_msg_done(smi_info);
2902 	if (rv)
2903 		goto out;
2904 
2905 	resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2906 						  resp, IPMI_MAX_MSG_LENGTH);
2907 
2908 	/* Check and record info from the get device id, in case we need it. */
2909 	rv = ipmi_demangle_device_id(resp, resp_len, &smi_info->device_id);
2910 
2911  out:
2912 	kfree(resp);
2913 	return rv;
2914 }
2915 
2916 static int try_enable_event_buffer(struct smi_info *smi_info)
2917 {
2918 	unsigned char         msg[3];
2919 	unsigned char         *resp;
2920 	unsigned long         resp_len;
2921 	int                   rv = 0;
2922 
2923 	resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2924 	if (!resp)
2925 		return -ENOMEM;
2926 
2927 	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2928 	msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
2929 	smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2930 
2931 	rv = wait_for_msg_done(smi_info);
2932 	if (rv) {
2933 		printk(KERN_WARNING PFX "Error getting response from get"
2934 		       " global enables command, the event buffer is not"
2935 		       " enabled.\n");
2936 		goto out;
2937 	}
2938 
2939 	resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2940 						  resp, IPMI_MAX_MSG_LENGTH);
2941 
2942 	if (resp_len < 4 ||
2943 			resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
2944 			resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD   ||
2945 			resp[2] != 0) {
2946 		printk(KERN_WARNING PFX "Invalid return from get global"
2947 		       " enables command, cannot enable the event buffer.\n");
2948 		rv = -EINVAL;
2949 		goto out;
2950 	}
2951 
2952 	if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) {
2953 		/* buffer is already enabled, nothing to do. */
2954 		smi_info->supports_event_msg_buff = true;
2955 		goto out;
2956 	}
2957 
2958 	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2959 	msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
2960 	msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF;
2961 	smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
2962 
2963 	rv = wait_for_msg_done(smi_info);
2964 	if (rv) {
2965 		printk(KERN_WARNING PFX "Error getting response from set"
2966 		       " global, enables command, the event buffer is not"
2967 		       " enabled.\n");
2968 		goto out;
2969 	}
2970 
2971 	resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2972 						  resp, IPMI_MAX_MSG_LENGTH);
2973 
2974 	if (resp_len < 3 ||
2975 			resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
2976 			resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
2977 		printk(KERN_WARNING PFX "Invalid return from get global,"
2978 		       "enables command, not enable the event buffer.\n");
2979 		rv = -EINVAL;
2980 		goto out;
2981 	}
2982 
2983 	if (resp[2] != 0)
2984 		/*
2985 		 * An error when setting the event buffer bit means
2986 		 * that the event buffer is not supported.
2987 		 */
2988 		rv = -ENOENT;
2989 	else
2990 		smi_info->supports_event_msg_buff = true;
2991 
2992  out:
2993 	kfree(resp);
2994 	return rv;
2995 }
2996 
2997 static int smi_type_proc_show(struct seq_file *m, void *v)
2998 {
2999 	struct smi_info *smi = m->private;
3000 
3001 	return seq_printf(m, "%s\n", si_to_str[smi->si_type]);
3002 }
3003 
3004 static int smi_type_proc_open(struct inode *inode, struct file *file)
3005 {
3006 	return single_open(file, smi_type_proc_show, PDE_DATA(inode));
3007 }
3008 
3009 static const struct file_operations smi_type_proc_ops = {
3010 	.open		= smi_type_proc_open,
3011 	.read		= seq_read,
3012 	.llseek		= seq_lseek,
3013 	.release	= single_release,
3014 };
3015 
3016 static int smi_si_stats_proc_show(struct seq_file *m, void *v)
3017 {
3018 	struct smi_info *smi = m->private;
3019 
3020 	seq_printf(m, "interrupts_enabled:    %d\n",
3021 		       smi->irq && !smi->interrupt_disabled);
3022 	seq_printf(m, "short_timeouts:        %u\n",
3023 		       smi_get_stat(smi, short_timeouts));
3024 	seq_printf(m, "long_timeouts:         %u\n",
3025 		       smi_get_stat(smi, long_timeouts));
3026 	seq_printf(m, "idles:                 %u\n",
3027 		       smi_get_stat(smi, idles));
3028 	seq_printf(m, "interrupts:            %u\n",
3029 		       smi_get_stat(smi, interrupts));
3030 	seq_printf(m, "attentions:            %u\n",
3031 		       smi_get_stat(smi, attentions));
3032 	seq_printf(m, "flag_fetches:          %u\n",
3033 		       smi_get_stat(smi, flag_fetches));
3034 	seq_printf(m, "hosed_count:           %u\n",
3035 		       smi_get_stat(smi, hosed_count));
3036 	seq_printf(m, "complete_transactions: %u\n",
3037 		       smi_get_stat(smi, complete_transactions));
3038 	seq_printf(m, "events:                %u\n",
3039 		       smi_get_stat(smi, events));
3040 	seq_printf(m, "watchdog_pretimeouts:  %u\n",
3041 		       smi_get_stat(smi, watchdog_pretimeouts));
3042 	seq_printf(m, "incoming_messages:     %u\n",
3043 		       smi_get_stat(smi, incoming_messages));
3044 	return 0;
3045 }
3046 
3047 static int smi_si_stats_proc_open(struct inode *inode, struct file *file)
3048 {
3049 	return single_open(file, smi_si_stats_proc_show, PDE_DATA(inode));
3050 }
3051 
3052 static const struct file_operations smi_si_stats_proc_ops = {
3053 	.open		= smi_si_stats_proc_open,
3054 	.read		= seq_read,
3055 	.llseek		= seq_lseek,
3056 	.release	= single_release,
3057 };
3058 
3059 static int smi_params_proc_show(struct seq_file *m, void *v)
3060 {
3061 	struct smi_info *smi = m->private;
3062 
3063 	return seq_printf(m,
3064 		       "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
3065 		       si_to_str[smi->si_type],
3066 		       addr_space_to_str[smi->io.addr_type],
3067 		       smi->io.addr_data,
3068 		       smi->io.regspacing,
3069 		       smi->io.regsize,
3070 		       smi->io.regshift,
3071 		       smi->irq,
3072 		       smi->slave_addr);
3073 }
3074 
3075 static int smi_params_proc_open(struct inode *inode, struct file *file)
3076 {
3077 	return single_open(file, smi_params_proc_show, PDE_DATA(inode));
3078 }
3079 
3080 static const struct file_operations smi_params_proc_ops = {
3081 	.open		= smi_params_proc_open,
3082 	.read		= seq_read,
3083 	.llseek		= seq_lseek,
3084 	.release	= single_release,
3085 };
3086 
3087 /*
3088  * oem_data_avail_to_receive_msg_avail
3089  * @info - smi_info structure with msg_flags set
3090  *
3091  * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
3092  * Returns 1 indicating need to re-run handle_flags().
3093  */
3094 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
3095 {
3096 	smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
3097 			       RECEIVE_MSG_AVAIL);
3098 	return 1;
3099 }
3100 
3101 /*
3102  * setup_dell_poweredge_oem_data_handler
3103  * @info - smi_info.device_id must be populated
3104  *
3105  * Systems that match, but have firmware version < 1.40 may assert
3106  * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
3107  * it's safe to do so.  Such systems will de-assert OEM1_DATA_AVAIL
3108  * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
3109  * as RECEIVE_MSG_AVAIL instead.
3110  *
3111  * As Dell has no plans to release IPMI 1.5 firmware that *ever*
3112  * assert the OEM[012] bits, and if it did, the driver would have to
3113  * change to handle that properly, we don't actually check for the
3114  * firmware version.
3115  * Device ID = 0x20                BMC on PowerEdge 8G servers
3116  * Device Revision = 0x80
3117  * Firmware Revision1 = 0x01       BMC version 1.40
3118  * Firmware Revision2 = 0x40       BCD encoded
3119  * IPMI Version = 0x51             IPMI 1.5
3120  * Manufacturer ID = A2 02 00      Dell IANA
3121  *
3122  * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
3123  * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
3124  *
3125  */
3126 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID  0x20
3127 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
3128 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
3129 #define DELL_IANA_MFR_ID 0x0002a2
3130 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
3131 {
3132 	struct ipmi_device_id *id = &smi_info->device_id;
3133 	if (id->manufacturer_id == DELL_IANA_MFR_ID) {
3134 		if (id->device_id       == DELL_POWEREDGE_8G_BMC_DEVICE_ID  &&
3135 		    id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
3136 		    id->ipmi_version   == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
3137 			smi_info->oem_data_avail_handler =
3138 				oem_data_avail_to_receive_msg_avail;
3139 		} else if (ipmi_version_major(id) < 1 ||
3140 			   (ipmi_version_major(id) == 1 &&
3141 			    ipmi_version_minor(id) < 5)) {
3142 			smi_info->oem_data_avail_handler =
3143 				oem_data_avail_to_receive_msg_avail;
3144 		}
3145 	}
3146 }
3147 
3148 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
3149 static void return_hosed_msg_badsize(struct smi_info *smi_info)
3150 {
3151 	struct ipmi_smi_msg *msg = smi_info->curr_msg;
3152 
3153 	/* Make it a response */
3154 	msg->rsp[0] = msg->data[0] | 4;
3155 	msg->rsp[1] = msg->data[1];
3156 	msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
3157 	msg->rsp_size = 3;
3158 	smi_info->curr_msg = NULL;
3159 	deliver_recv_msg(smi_info, msg);
3160 }
3161 
3162 /*
3163  * dell_poweredge_bt_xaction_handler
3164  * @info - smi_info.device_id must be populated
3165  *
3166  * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
3167  * not respond to a Get SDR command if the length of the data
3168  * requested is exactly 0x3A, which leads to command timeouts and no
3169  * data returned.  This intercepts such commands, and causes userspace
3170  * callers to try again with a different-sized buffer, which succeeds.
3171  */
3172 
3173 #define STORAGE_NETFN 0x0A
3174 #define STORAGE_CMD_GET_SDR 0x23
3175 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
3176 					     unsigned long unused,
3177 					     void *in)
3178 {
3179 	struct smi_info *smi_info = in;
3180 	unsigned char *data = smi_info->curr_msg->data;
3181 	unsigned int size   = smi_info->curr_msg->data_size;
3182 	if (size >= 8 &&
3183 	    (data[0]>>2) == STORAGE_NETFN &&
3184 	    data[1] == STORAGE_CMD_GET_SDR &&
3185 	    data[7] == 0x3A) {
3186 		return_hosed_msg_badsize(smi_info);
3187 		return NOTIFY_STOP;
3188 	}
3189 	return NOTIFY_DONE;
3190 }
3191 
3192 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
3193 	.notifier_call	= dell_poweredge_bt_xaction_handler,
3194 };
3195 
3196 /*
3197  * setup_dell_poweredge_bt_xaction_handler
3198  * @info - smi_info.device_id must be filled in already
3199  *
3200  * Fills in smi_info.device_id.start_transaction_pre_hook
3201  * when we know what function to use there.
3202  */
3203 static void
3204 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
3205 {
3206 	struct ipmi_device_id *id = &smi_info->device_id;
3207 	if (id->manufacturer_id == DELL_IANA_MFR_ID &&
3208 	    smi_info->si_type == SI_BT)
3209 		register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
3210 }
3211 
3212 /*
3213  * setup_oem_data_handler
3214  * @info - smi_info.device_id must be filled in already
3215  *
3216  * Fills in smi_info.device_id.oem_data_available_handler
3217  * when we know what function to use there.
3218  */
3219 
3220 static void setup_oem_data_handler(struct smi_info *smi_info)
3221 {
3222 	setup_dell_poweredge_oem_data_handler(smi_info);
3223 }
3224 
3225 static void setup_xaction_handlers(struct smi_info *smi_info)
3226 {
3227 	setup_dell_poweredge_bt_xaction_handler(smi_info);
3228 }
3229 
3230 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
3231 {
3232 	if (smi_info->thread != NULL)
3233 		kthread_stop(smi_info->thread);
3234 	if (smi_info->timer_running)
3235 		del_timer_sync(&smi_info->si_timer);
3236 }
3237 
3238 static struct ipmi_default_vals
3239 {
3240 	int type;
3241 	int port;
3242 } ipmi_defaults[] =
3243 {
3244 	{ .type = SI_KCS, .port = 0xca2 },
3245 	{ .type = SI_SMIC, .port = 0xca9 },
3246 	{ .type = SI_BT, .port = 0xe4 },
3247 	{ .port = 0 }
3248 };
3249 
3250 static void default_find_bmc(void)
3251 {
3252 	struct smi_info *info;
3253 	int             i;
3254 
3255 	for (i = 0; ; i++) {
3256 		if (!ipmi_defaults[i].port)
3257 			break;
3258 #ifdef CONFIG_PPC
3259 		if (check_legacy_ioport(ipmi_defaults[i].port))
3260 			continue;
3261 #endif
3262 		info = smi_info_alloc();
3263 		if (!info)
3264 			return;
3265 
3266 		info->addr_source = SI_DEFAULT;
3267 
3268 		info->si_type = ipmi_defaults[i].type;
3269 		info->io_setup = port_setup;
3270 		info->io.addr_data = ipmi_defaults[i].port;
3271 		info->io.addr_type = IPMI_IO_ADDR_SPACE;
3272 
3273 		info->io.addr = NULL;
3274 		info->io.regspacing = DEFAULT_REGSPACING;
3275 		info->io.regsize = DEFAULT_REGSPACING;
3276 		info->io.regshift = 0;
3277 
3278 		if (add_smi(info) == 0) {
3279 			if ((try_smi_init(info)) == 0) {
3280 				/* Found one... */
3281 				printk(KERN_INFO PFX "Found default %s"
3282 				" state machine at %s address 0x%lx\n",
3283 				si_to_str[info->si_type],
3284 				addr_space_to_str[info->io.addr_type],
3285 				info->io.addr_data);
3286 			} else
3287 				cleanup_one_si(info);
3288 		} else {
3289 			kfree(info);
3290 		}
3291 	}
3292 }
3293 
3294 static int is_new_interface(struct smi_info *info)
3295 {
3296 	struct smi_info *e;
3297 
3298 	list_for_each_entry(e, &smi_infos, link) {
3299 		if (e->io.addr_type != info->io.addr_type)
3300 			continue;
3301 		if (e->io.addr_data == info->io.addr_data)
3302 			return 0;
3303 	}
3304 
3305 	return 1;
3306 }
3307 
3308 static int add_smi(struct smi_info *new_smi)
3309 {
3310 	int rv = 0;
3311 
3312 	printk(KERN_INFO PFX "Adding %s-specified %s state machine",
3313 	       ipmi_addr_src_to_str(new_smi->addr_source),
3314 	       si_to_str[new_smi->si_type]);
3315 	mutex_lock(&smi_infos_lock);
3316 	if (!is_new_interface(new_smi)) {
3317 		printk(KERN_CONT " duplicate interface\n");
3318 		rv = -EBUSY;
3319 		goto out_err;
3320 	}
3321 
3322 	printk(KERN_CONT "\n");
3323 
3324 	/* So we know not to free it unless we have allocated one. */
3325 	new_smi->intf = NULL;
3326 	new_smi->si_sm = NULL;
3327 	new_smi->handlers = NULL;
3328 
3329 	list_add_tail(&new_smi->link, &smi_infos);
3330 
3331 out_err:
3332 	mutex_unlock(&smi_infos_lock);
3333 	return rv;
3334 }
3335 
3336 static int try_smi_init(struct smi_info *new_smi)
3337 {
3338 	int rv = 0;
3339 	int i;
3340 
3341 	printk(KERN_INFO PFX "Trying %s-specified %s state"
3342 	       " machine at %s address 0x%lx, slave address 0x%x,"
3343 	       " irq %d\n",
3344 	       ipmi_addr_src_to_str(new_smi->addr_source),
3345 	       si_to_str[new_smi->si_type],
3346 	       addr_space_to_str[new_smi->io.addr_type],
3347 	       new_smi->io.addr_data,
3348 	       new_smi->slave_addr, new_smi->irq);
3349 
3350 	switch (new_smi->si_type) {
3351 	case SI_KCS:
3352 		new_smi->handlers = &kcs_smi_handlers;
3353 		break;
3354 
3355 	case SI_SMIC:
3356 		new_smi->handlers = &smic_smi_handlers;
3357 		break;
3358 
3359 	case SI_BT:
3360 		new_smi->handlers = &bt_smi_handlers;
3361 		break;
3362 
3363 	default:
3364 		/* No support for anything else yet. */
3365 		rv = -EIO;
3366 		goto out_err;
3367 	}
3368 
3369 	/* Allocate the state machine's data and initialize it. */
3370 	new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
3371 	if (!new_smi->si_sm) {
3372 		printk(KERN_ERR PFX
3373 		       "Could not allocate state machine memory\n");
3374 		rv = -ENOMEM;
3375 		goto out_err;
3376 	}
3377 	new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
3378 							&new_smi->io);
3379 
3380 	/* Now that we know the I/O size, we can set up the I/O. */
3381 	rv = new_smi->io_setup(new_smi);
3382 	if (rv) {
3383 		printk(KERN_ERR PFX "Could not set up I/O space\n");
3384 		goto out_err;
3385 	}
3386 
3387 	/* Do low-level detection first. */
3388 	if (new_smi->handlers->detect(new_smi->si_sm)) {
3389 		if (new_smi->addr_source)
3390 			printk(KERN_INFO PFX "Interface detection failed\n");
3391 		rv = -ENODEV;
3392 		goto out_err;
3393 	}
3394 
3395 	/*
3396 	 * Attempt a get device id command.  If it fails, we probably
3397 	 * don't have a BMC here.
3398 	 */
3399 	rv = try_get_dev_id(new_smi);
3400 	if (rv) {
3401 		if (new_smi->addr_source)
3402 			printk(KERN_INFO PFX "There appears to be no BMC"
3403 			       " at this location\n");
3404 		goto out_err;
3405 	}
3406 
3407 	setup_oem_data_handler(new_smi);
3408 	setup_xaction_handlers(new_smi);
3409 
3410 	new_smi->waiting_msg = NULL;
3411 	new_smi->curr_msg = NULL;
3412 	atomic_set(&new_smi->req_events, 0);
3413 	new_smi->run_to_completion = false;
3414 	for (i = 0; i < SI_NUM_STATS; i++)
3415 		atomic_set(&new_smi->stats[i], 0);
3416 
3417 	new_smi->interrupt_disabled = true;
3418 	atomic_set(&new_smi->need_watch, 0);
3419 	new_smi->intf_num = smi_num;
3420 	smi_num++;
3421 
3422 	rv = try_enable_event_buffer(new_smi);
3423 	if (rv == 0)
3424 		new_smi->has_event_buffer = true;
3425 
3426 	/*
3427 	 * Start clearing the flags before we enable interrupts or the
3428 	 * timer to avoid racing with the timer.
3429 	 */
3430 	start_clear_flags(new_smi);
3431 
3432 	/*
3433 	 * IRQ is defined to be set when non-zero.  req_events will
3434 	 * cause a global flags check that will enable interrupts.
3435 	 */
3436 	if (new_smi->irq) {
3437 		new_smi->interrupt_disabled = false;
3438 		atomic_set(&new_smi->req_events, 1);
3439 	}
3440 
3441 	if (!new_smi->dev) {
3442 		/*
3443 		 * If we don't already have a device from something
3444 		 * else (like PCI), then register a new one.
3445 		 */
3446 		new_smi->pdev = platform_device_alloc("ipmi_si",
3447 						      new_smi->intf_num);
3448 		if (!new_smi->pdev) {
3449 			printk(KERN_ERR PFX
3450 			       "Unable to allocate platform device\n");
3451 			goto out_err;
3452 		}
3453 		new_smi->dev = &new_smi->pdev->dev;
3454 		new_smi->dev->driver = &ipmi_driver.driver;
3455 
3456 		rv = platform_device_add(new_smi->pdev);
3457 		if (rv) {
3458 			printk(KERN_ERR PFX
3459 			       "Unable to register system interface device:"
3460 			       " %d\n",
3461 			       rv);
3462 			goto out_err;
3463 		}
3464 		new_smi->dev_registered = true;
3465 	}
3466 
3467 	rv = ipmi_register_smi(&handlers,
3468 			       new_smi,
3469 			       &new_smi->device_id,
3470 			       new_smi->dev,
3471 			       new_smi->slave_addr);
3472 	if (rv) {
3473 		dev_err(new_smi->dev, "Unable to register device: error %d\n",
3474 			rv);
3475 		goto out_err_stop_timer;
3476 	}
3477 
3478 	rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
3479 				     &smi_type_proc_ops,
3480 				     new_smi);
3481 	if (rv) {
3482 		dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
3483 		goto out_err_stop_timer;
3484 	}
3485 
3486 	rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
3487 				     &smi_si_stats_proc_ops,
3488 				     new_smi);
3489 	if (rv) {
3490 		dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
3491 		goto out_err_stop_timer;
3492 	}
3493 
3494 	rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
3495 				     &smi_params_proc_ops,
3496 				     new_smi);
3497 	if (rv) {
3498 		dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
3499 		goto out_err_stop_timer;
3500 	}
3501 
3502 	dev_info(new_smi->dev, "IPMI %s interface initialized\n",
3503 		 si_to_str[new_smi->si_type]);
3504 
3505 	return 0;
3506 
3507  out_err_stop_timer:
3508 	wait_for_timer_and_thread(new_smi);
3509 
3510  out_err:
3511 	new_smi->interrupt_disabled = true;
3512 
3513 	if (new_smi->intf) {
3514 		ipmi_smi_t intf = new_smi->intf;
3515 		new_smi->intf = NULL;
3516 		ipmi_unregister_smi(intf);
3517 	}
3518 
3519 	if (new_smi->irq_cleanup) {
3520 		new_smi->irq_cleanup(new_smi);
3521 		new_smi->irq_cleanup = NULL;
3522 	}
3523 
3524 	/*
3525 	 * Wait until we know that we are out of any interrupt
3526 	 * handlers might have been running before we freed the
3527 	 * interrupt.
3528 	 */
3529 	synchronize_sched();
3530 
3531 	if (new_smi->si_sm) {
3532 		if (new_smi->handlers)
3533 			new_smi->handlers->cleanup(new_smi->si_sm);
3534 		kfree(new_smi->si_sm);
3535 		new_smi->si_sm = NULL;
3536 	}
3537 	if (new_smi->addr_source_cleanup) {
3538 		new_smi->addr_source_cleanup(new_smi);
3539 		new_smi->addr_source_cleanup = NULL;
3540 	}
3541 	if (new_smi->io_cleanup) {
3542 		new_smi->io_cleanup(new_smi);
3543 		new_smi->io_cleanup = NULL;
3544 	}
3545 
3546 	if (new_smi->dev_registered) {
3547 		platform_device_unregister(new_smi->pdev);
3548 		new_smi->dev_registered = false;
3549 	}
3550 
3551 	return rv;
3552 }
3553 
3554 static int init_ipmi_si(void)
3555 {
3556 	int  i;
3557 	char *str;
3558 	int  rv;
3559 	struct smi_info *e;
3560 	enum ipmi_addr_src type = SI_INVALID;
3561 
3562 	if (initialized)
3563 		return 0;
3564 	initialized = 1;
3565 
3566 	if (si_tryplatform) {
3567 		rv = platform_driver_register(&ipmi_driver);
3568 		if (rv) {
3569 			printk(KERN_ERR PFX "Unable to register "
3570 			       "driver: %d\n", rv);
3571 			return rv;
3572 		}
3573 	}
3574 
3575 	/* Parse out the si_type string into its components. */
3576 	str = si_type_str;
3577 	if (*str != '\0') {
3578 		for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
3579 			si_type[i] = str;
3580 			str = strchr(str, ',');
3581 			if (str) {
3582 				*str = '\0';
3583 				str++;
3584 			} else {
3585 				break;
3586 			}
3587 		}
3588 	}
3589 
3590 	printk(KERN_INFO "IPMI System Interface driver.\n");
3591 
3592 	/* If the user gave us a device, they presumably want us to use it */
3593 	if (!hardcode_find_bmc())
3594 		return 0;
3595 
3596 #ifdef CONFIG_PCI
3597 	if (si_trypci) {
3598 		rv = pci_register_driver(&ipmi_pci_driver);
3599 		if (rv)
3600 			printk(KERN_ERR PFX "Unable to register "
3601 			       "PCI driver: %d\n", rv);
3602 		else
3603 			pci_registered = true;
3604 	}
3605 #endif
3606 
3607 #ifdef CONFIG_ACPI
3608 	if (si_tryacpi) {
3609 		pnp_register_driver(&ipmi_pnp_driver);
3610 		pnp_registered = true;
3611 	}
3612 #endif
3613 
3614 #ifdef CONFIG_DMI
3615 	if (si_trydmi)
3616 		dmi_find_bmc();
3617 #endif
3618 
3619 #ifdef CONFIG_ACPI
3620 	if (si_tryacpi)
3621 		spmi_find_bmc();
3622 #endif
3623 
3624 #ifdef CONFIG_PARISC
3625 	register_parisc_driver(&ipmi_parisc_driver);
3626 	parisc_registered = true;
3627 	/* poking PC IO addresses will crash machine, don't do it */
3628 	si_trydefaults = 0;
3629 #endif
3630 
3631 	/* We prefer devices with interrupts, but in the case of a machine
3632 	   with multiple BMCs we assume that there will be several instances
3633 	   of a given type so if we succeed in registering a type then also
3634 	   try to register everything else of the same type */
3635 
3636 	mutex_lock(&smi_infos_lock);
3637 	list_for_each_entry(e, &smi_infos, link) {
3638 		/* Try to register a device if it has an IRQ and we either
3639 		   haven't successfully registered a device yet or this
3640 		   device has the same type as one we successfully registered */
3641 		if (e->irq && (!type || e->addr_source == type)) {
3642 			if (!try_smi_init(e)) {
3643 				type = e->addr_source;
3644 			}
3645 		}
3646 	}
3647 
3648 	/* type will only have been set if we successfully registered an si */
3649 	if (type) {
3650 		mutex_unlock(&smi_infos_lock);
3651 		return 0;
3652 	}
3653 
3654 	/* Fall back to the preferred device */
3655 
3656 	list_for_each_entry(e, &smi_infos, link) {
3657 		if (!e->irq && (!type || e->addr_source == type)) {
3658 			if (!try_smi_init(e)) {
3659 				type = e->addr_source;
3660 			}
3661 		}
3662 	}
3663 	mutex_unlock(&smi_infos_lock);
3664 
3665 	if (type)
3666 		return 0;
3667 
3668 	if (si_trydefaults) {
3669 		mutex_lock(&smi_infos_lock);
3670 		if (list_empty(&smi_infos)) {
3671 			/* No BMC was found, try defaults. */
3672 			mutex_unlock(&smi_infos_lock);
3673 			default_find_bmc();
3674 		} else
3675 			mutex_unlock(&smi_infos_lock);
3676 	}
3677 
3678 	mutex_lock(&smi_infos_lock);
3679 	if (unload_when_empty && list_empty(&smi_infos)) {
3680 		mutex_unlock(&smi_infos_lock);
3681 		cleanup_ipmi_si();
3682 		printk(KERN_WARNING PFX
3683 		       "Unable to find any System Interface(s)\n");
3684 		return -ENODEV;
3685 	} else {
3686 		mutex_unlock(&smi_infos_lock);
3687 		return 0;
3688 	}
3689 }
3690 module_init(init_ipmi_si);
3691 
3692 static void cleanup_one_si(struct smi_info *to_clean)
3693 {
3694 	int           rv = 0;
3695 
3696 	if (!to_clean)
3697 		return;
3698 
3699 	if (to_clean->intf) {
3700 		ipmi_smi_t intf = to_clean->intf;
3701 
3702 		to_clean->intf = NULL;
3703 		rv = ipmi_unregister_smi(intf);
3704 		if (rv) {
3705 			pr_err(PFX "Unable to unregister device: errno=%d\n",
3706 			       rv);
3707 		}
3708 	}
3709 
3710 	if (to_clean->dev)
3711 		dev_set_drvdata(to_clean->dev, NULL);
3712 
3713 	list_del(&to_clean->link);
3714 
3715 	/*
3716 	 * Make sure that interrupts, the timer and the thread are
3717 	 * stopped and will not run again.
3718 	 */
3719 	if (to_clean->irq_cleanup)
3720 		to_clean->irq_cleanup(to_clean);
3721 	wait_for_timer_and_thread(to_clean);
3722 
3723 	/*
3724 	 * Timeouts are stopped, now make sure the interrupts are off
3725 	 * in the BMC.  Note that timers and CPU interrupts are off,
3726 	 * so no need for locks.
3727 	 */
3728 	while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3729 		poll(to_clean);
3730 		schedule_timeout_uninterruptible(1);
3731 	}
3732 	disable_si_irq(to_clean);
3733 	while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3734 		poll(to_clean);
3735 		schedule_timeout_uninterruptible(1);
3736 	}
3737 
3738 	if (to_clean->handlers)
3739 		to_clean->handlers->cleanup(to_clean->si_sm);
3740 
3741 	kfree(to_clean->si_sm);
3742 
3743 	if (to_clean->addr_source_cleanup)
3744 		to_clean->addr_source_cleanup(to_clean);
3745 	if (to_clean->io_cleanup)
3746 		to_clean->io_cleanup(to_clean);
3747 
3748 	if (to_clean->dev_registered)
3749 		platform_device_unregister(to_clean->pdev);
3750 
3751 	kfree(to_clean);
3752 }
3753 
3754 static void cleanup_ipmi_si(void)
3755 {
3756 	struct smi_info *e, *tmp_e;
3757 
3758 	if (!initialized)
3759 		return;
3760 
3761 #ifdef CONFIG_PCI
3762 	if (pci_registered)
3763 		pci_unregister_driver(&ipmi_pci_driver);
3764 #endif
3765 #ifdef CONFIG_ACPI
3766 	if (pnp_registered)
3767 		pnp_unregister_driver(&ipmi_pnp_driver);
3768 #endif
3769 #ifdef CONFIG_PARISC
3770 	if (parisc_registered)
3771 		unregister_parisc_driver(&ipmi_parisc_driver);
3772 #endif
3773 
3774 	platform_driver_unregister(&ipmi_driver);
3775 
3776 	mutex_lock(&smi_infos_lock);
3777 	list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
3778 		cleanup_one_si(e);
3779 	mutex_unlock(&smi_infos_lock);
3780 }
3781 module_exit(cleanup_ipmi_si);
3782 
3783 MODULE_LICENSE("GPL");
3784 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
3785 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT"
3786 		   " system interfaces.");
3787