4 * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
7 * Author: MontaVista Software, Inc.
8 * Corey Minyard <minyard@mvista.com>
11 * Copyright 2002 MontaVista Software Inc.
12 * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
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.
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.
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.
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.
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>
58 #include <linux/interrupt.h>
59 #include <linux/rcupdate.h>
60 #include <linux/ipmi.h>
61 #include <linux/ipmi_smi.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>
74 #include <asm/hardware.h> /* for register_parisc_driver() stuff */
75 #include <asm/parisc-device.h>
78 #define PFX "ipmi_si: "
80 /* Measure times between events in the driver. */
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
98 /* FIXME - add watchdog stuff. */
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
107 SI_KCS, SI_SMIC, SI_BT
109 static char *si_to_str[] = { "kcs", "smic", "bt" };
111 #define DEVICE_NAME "ipmi_si"
113 static struct platform_driver ipmi_driver;
116 * Indexes into stats[] in smi_info below.
118 enum si_stat_indexes {
120 * Number of times the driver requested a timer while an operation
123 SI_STAT_short_timeouts = 0,
126 * Number of times the driver requested a timer while nothing was in
129 SI_STAT_long_timeouts,
131 /* Number of times the interface was idle while being polled. */
134 /* Number of interrupts the driver handled. */
137 /* Number of time the driver got an ATTN from the hardware. */
140 /* Number of times the driver requested flags from the hardware. */
141 SI_STAT_flag_fetches,
143 /* Number of times the hardware didn't follow the state machine. */
146 /* Number of completed messages. */
147 SI_STAT_complete_transactions,
149 /* Number of IPMI events received from the hardware. */
152 /* Number of watchdog pretimeouts. */
153 SI_STAT_watchdog_pretimeouts,
155 /* Number of asynchronous messages received. */
156 SI_STAT_incoming_messages,
159 /* This *must* remain last, add new values above this. */
166 struct si_sm_data *si_sm;
167 struct si_sm_handlers *handlers;
168 enum si_type si_type;
170 struct ipmi_smi_msg *waiting_msg;
171 struct ipmi_smi_msg *curr_msg;
172 enum si_intf_state si_state;
175 * Used to handle the various types of I/O that can occur with
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;
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.
193 int (*oem_data_avail_handler)(struct smi_info *smi_info);
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
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 | \
209 unsigned char msg_flags;
211 /* Does the BMC have an event buffer? */
212 bool has_event_buffer;
215 * If set to true, this will request events the next time the
216 * state machine is idle.
221 * If true, run the state machine to completion on every send
222 * call. Generally used after a panic to make sure stuff goes
225 bool run_to_completion;
227 /* The I/O port of an SI interface. */
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.
235 unsigned int spacing;
237 /* zero if no irq; */
240 /* The timer for this si. */
241 struct timer_list si_timer;
243 /* This flag is set, if the timer is running (timer_pending() isn't enough) */
246 /* The time (in jiffies) the last timeout occurred at. */
247 unsigned long last_timeout_jiffies;
249 /* Are we waiting for the events, pretimeouts, received msgs? */
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
258 bool interrupt_disabled;
261 * Does the BMC support events?
263 bool supports_event_msg_buff;
266 * Can we clear the global enables receive irq bit?
268 bool cannot_clear_recv_irq_bit;
271 * Did we get an attention that we did not handle?
275 /* From the get device id response... */
276 struct ipmi_device_id device_id;
278 /* Driver model stuff. */
280 struct platform_device *pdev;
283 * True if we allocated the device, false if it came from
284 * someplace else (like PCI).
288 /* Slave address, could be reported from DMI. */
289 unsigned char slave_addr;
291 /* Counters and things for the proc filesystem. */
292 atomic_t stats[SI_NUM_STATS];
294 struct task_struct *thread;
296 struct list_head link;
297 union ipmi_smi_info_union addr_info;
300 #define smi_inc_stat(smi, stat) \
301 atomic_inc(&(smi)->stats[SI_STAT_ ## stat])
302 #define smi_get_stat(smi, stat) \
303 ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat]))
305 #define SI_MAX_PARMS 4
307 static int force_kipmid[SI_MAX_PARMS];
308 static int num_force_kipmid;
310 static bool pci_registered;
313 static bool pnp_registered;
316 static bool parisc_registered;
319 static unsigned int kipmid_max_busy_us[SI_MAX_PARMS];
320 static int num_max_busy_us;
322 static bool unload_when_empty = true;
324 static int add_smi(struct smi_info *smi);
325 static int try_smi_init(struct smi_info *smi);
326 static void cleanup_one_si(struct smi_info *to_clean);
327 static void cleanup_ipmi_si(void);
330 void debug_timestamp(char *msg)
334 getnstimeofday64(&t);
335 pr_debug("**%s: %lld.%9.9ld\n", msg, (long long) t.tv_sec, t.tv_nsec);
338 #define debug_timestamp(x)
341 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
342 static int register_xaction_notifier(struct notifier_block *nb)
344 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
347 static void deliver_recv_msg(struct smi_info *smi_info,
348 struct ipmi_smi_msg *msg)
350 /* Deliver the message to the upper layer. */
352 ipmi_smi_msg_received(smi_info->intf, msg);
354 ipmi_free_smi_msg(msg);
357 static void return_hosed_msg(struct smi_info *smi_info, int cCode)
359 struct ipmi_smi_msg *msg = smi_info->curr_msg;
361 if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
362 cCode = IPMI_ERR_UNSPECIFIED;
363 /* else use it as is */
365 /* Make it a response */
366 msg->rsp[0] = msg->data[0] | 4;
367 msg->rsp[1] = msg->data[1];
371 smi_info->curr_msg = NULL;
372 deliver_recv_msg(smi_info, msg);
375 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
379 if (!smi_info->waiting_msg) {
380 smi_info->curr_msg = NULL;
385 smi_info->curr_msg = smi_info->waiting_msg;
386 smi_info->waiting_msg = NULL;
387 debug_timestamp("Start2");
388 err = atomic_notifier_call_chain(&xaction_notifier_list,
390 if (err & NOTIFY_STOP_MASK) {
391 rv = SI_SM_CALL_WITHOUT_DELAY;
394 err = smi_info->handlers->start_transaction(
396 smi_info->curr_msg->data,
397 smi_info->curr_msg->data_size);
399 return_hosed_msg(smi_info, err);
401 rv = SI_SM_CALL_WITHOUT_DELAY;
407 static void start_check_enables(struct smi_info *smi_info)
409 unsigned char msg[2];
411 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
412 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
414 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
415 smi_info->si_state = SI_CHECKING_ENABLES;
418 static void start_clear_flags(struct smi_info *smi_info)
420 unsigned char msg[3];
422 /* Make sure the watchdog pre-timeout flag is not set at startup. */
423 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
424 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
425 msg[2] = WDT_PRE_TIMEOUT_INT;
427 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
428 smi_info->si_state = SI_CLEARING_FLAGS;
431 static void start_getting_msg_queue(struct smi_info *smi_info)
433 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
434 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
435 smi_info->curr_msg->data_size = 2;
437 smi_info->handlers->start_transaction(
439 smi_info->curr_msg->data,
440 smi_info->curr_msg->data_size);
441 smi_info->si_state = SI_GETTING_MESSAGES;
444 static void start_getting_events(struct smi_info *smi_info)
446 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
447 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
448 smi_info->curr_msg->data_size = 2;
450 smi_info->handlers->start_transaction(
452 smi_info->curr_msg->data,
453 smi_info->curr_msg->data_size);
454 smi_info->si_state = SI_GETTING_EVENTS;
457 static void smi_mod_timer(struct smi_info *smi_info, unsigned long new_val)
459 smi_info->last_timeout_jiffies = jiffies;
460 mod_timer(&smi_info->si_timer, new_val);
461 smi_info->timer_running = true;
465 * When we have a situtaion where we run out of memory and cannot
466 * allocate messages, we just leave them in the BMC and run the system
467 * polled until we can allocate some memory. Once we have some
468 * memory, we will re-enable the interrupt.
470 * Note that we cannot just use disable_irq(), since the interrupt may
473 static inline bool disable_si_irq(struct smi_info *smi_info)
475 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
476 smi_info->interrupt_disabled = true;
477 start_check_enables(smi_info);
483 static inline bool enable_si_irq(struct smi_info *smi_info)
485 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
486 smi_info->interrupt_disabled = false;
487 start_check_enables(smi_info);
494 * Allocate a message. If unable to allocate, start the interrupt
495 * disable process and return NULL. If able to allocate but
496 * interrupts are disabled, free the message and return NULL after
497 * starting the interrupt enable process.
499 static struct ipmi_smi_msg *alloc_msg_handle_irq(struct smi_info *smi_info)
501 struct ipmi_smi_msg *msg;
503 msg = ipmi_alloc_smi_msg();
505 if (!disable_si_irq(smi_info))
506 smi_info->si_state = SI_NORMAL;
507 } else if (enable_si_irq(smi_info)) {
508 ipmi_free_smi_msg(msg);
514 static void handle_flags(struct smi_info *smi_info)
517 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
518 /* Watchdog pre-timeout */
519 smi_inc_stat(smi_info, watchdog_pretimeouts);
521 start_clear_flags(smi_info);
522 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
524 ipmi_smi_watchdog_pretimeout(smi_info->intf);
525 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
526 /* Messages available. */
527 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
528 if (!smi_info->curr_msg)
531 start_getting_msg_queue(smi_info);
532 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
533 /* Events available. */
534 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
535 if (!smi_info->curr_msg)
538 start_getting_events(smi_info);
539 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
540 smi_info->oem_data_avail_handler) {
541 if (smi_info->oem_data_avail_handler(smi_info))
544 smi_info->si_state = SI_NORMAL;
548 * Global enables we care about.
550 #define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \
551 IPMI_BMC_EVT_MSG_INTR)
553 static u8 current_global_enables(struct smi_info *smi_info, u8 base,
558 if (smi_info->supports_event_msg_buff)
559 enables |= IPMI_BMC_EVT_MSG_BUFF;
561 if ((smi_info->irq && !smi_info->interrupt_disabled) ||
562 smi_info->cannot_clear_recv_irq_bit)
563 enables |= IPMI_BMC_RCV_MSG_INTR;
565 if (smi_info->supports_event_msg_buff &&
566 smi_info->irq && !smi_info->interrupt_disabled)
568 enables |= IPMI_BMC_EVT_MSG_INTR;
570 *irq_on = enables & (IPMI_BMC_EVT_MSG_INTR | IPMI_BMC_RCV_MSG_INTR);
575 static void check_bt_irq(struct smi_info *smi_info, bool irq_on)
577 u8 irqstate = smi_info->io.inputb(&smi_info->io, IPMI_BT_INTMASK_REG);
579 irqstate &= IPMI_BT_INTMASK_ENABLE_IRQ_BIT;
581 if ((bool)irqstate == irq_on)
585 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
586 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
588 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 0);
591 static void handle_transaction_done(struct smi_info *smi_info)
593 struct ipmi_smi_msg *msg;
595 debug_timestamp("Done");
596 switch (smi_info->si_state) {
598 if (!smi_info->curr_msg)
601 smi_info->curr_msg->rsp_size
602 = smi_info->handlers->get_result(
604 smi_info->curr_msg->rsp,
605 IPMI_MAX_MSG_LENGTH);
608 * Do this here becase deliver_recv_msg() releases the
609 * lock, and a new message can be put in during the
610 * time the lock is released.
612 msg = smi_info->curr_msg;
613 smi_info->curr_msg = NULL;
614 deliver_recv_msg(smi_info, msg);
617 case SI_GETTING_FLAGS:
619 unsigned char msg[4];
622 /* We got the flags from the SMI, now handle them. */
623 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
625 /* Error fetching flags, just give up for now. */
626 smi_info->si_state = SI_NORMAL;
627 } else if (len < 4) {
629 * Hmm, no flags. That's technically illegal, but
630 * don't use uninitialized data.
632 smi_info->si_state = SI_NORMAL;
634 smi_info->msg_flags = msg[3];
635 handle_flags(smi_info);
640 case SI_CLEARING_FLAGS:
642 unsigned char msg[3];
644 /* We cleared the flags. */
645 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
647 /* Error clearing flags */
648 dev_warn(smi_info->dev,
649 "Error clearing flags: %2.2x\n", msg[2]);
651 smi_info->si_state = SI_NORMAL;
655 case SI_GETTING_EVENTS:
657 smi_info->curr_msg->rsp_size
658 = smi_info->handlers->get_result(
660 smi_info->curr_msg->rsp,
661 IPMI_MAX_MSG_LENGTH);
664 * Do this here becase deliver_recv_msg() releases the
665 * lock, and a new message can be put in during the
666 * time the lock is released.
668 msg = smi_info->curr_msg;
669 smi_info->curr_msg = NULL;
670 if (msg->rsp[2] != 0) {
671 /* Error getting event, probably done. */
674 /* Take off the event flag. */
675 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
676 handle_flags(smi_info);
678 smi_inc_stat(smi_info, events);
681 * Do this before we deliver the message
682 * because delivering the message releases the
683 * lock and something else can mess with the
686 handle_flags(smi_info);
688 deliver_recv_msg(smi_info, msg);
693 case SI_GETTING_MESSAGES:
695 smi_info->curr_msg->rsp_size
696 = smi_info->handlers->get_result(
698 smi_info->curr_msg->rsp,
699 IPMI_MAX_MSG_LENGTH);
702 * Do this here becase deliver_recv_msg() releases the
703 * lock, and a new message can be put in during the
704 * time the lock is released.
706 msg = smi_info->curr_msg;
707 smi_info->curr_msg = NULL;
708 if (msg->rsp[2] != 0) {
709 /* Error getting event, probably done. */
712 /* Take off the msg flag. */
713 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
714 handle_flags(smi_info);
716 smi_inc_stat(smi_info, incoming_messages);
719 * Do this before we deliver the message
720 * because delivering the message releases the
721 * lock and something else can mess with the
724 handle_flags(smi_info);
726 deliver_recv_msg(smi_info, msg);
731 case SI_CHECKING_ENABLES:
733 unsigned char msg[4];
737 /* We got the flags from the SMI, now handle them. */
738 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
740 dev_warn(smi_info->dev,
741 "Couldn't get irq info: %x.\n", msg[2]);
742 dev_warn(smi_info->dev,
743 "Maybe ok, but ipmi might run very slowly.\n");
744 smi_info->si_state = SI_NORMAL;
747 enables = current_global_enables(smi_info, 0, &irq_on);
748 if (smi_info->si_type == SI_BT)
749 /* BT has its own interrupt enable bit. */
750 check_bt_irq(smi_info, irq_on);
751 if (enables != (msg[3] & GLOBAL_ENABLES_MASK)) {
752 /* Enables are not correct, fix them. */
753 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
754 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
755 msg[2] = enables | (msg[3] & ~GLOBAL_ENABLES_MASK);
756 smi_info->handlers->start_transaction(
757 smi_info->si_sm, msg, 3);
758 smi_info->si_state = SI_SETTING_ENABLES;
759 } else if (smi_info->supports_event_msg_buff) {
760 smi_info->curr_msg = ipmi_alloc_smi_msg();
761 if (!smi_info->curr_msg) {
762 smi_info->si_state = SI_NORMAL;
765 start_getting_msg_queue(smi_info);
767 smi_info->si_state = SI_NORMAL;
772 case SI_SETTING_ENABLES:
774 unsigned char msg[4];
776 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
778 dev_warn(smi_info->dev,
779 "Could not set the global enables: 0x%x.\n",
782 if (smi_info->supports_event_msg_buff) {
783 smi_info->curr_msg = ipmi_alloc_smi_msg();
784 if (!smi_info->curr_msg) {
785 smi_info->si_state = SI_NORMAL;
788 start_getting_msg_queue(smi_info);
790 smi_info->si_state = SI_NORMAL;
798 * Called on timeouts and events. Timeouts should pass the elapsed
799 * time, interrupts should pass in zero. Must be called with
800 * si_lock held and interrupts disabled.
802 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
805 enum si_sm_result si_sm_result;
809 * There used to be a loop here that waited a little while
810 * (around 25us) before giving up. That turned out to be
811 * pointless, the minimum delays I was seeing were in the 300us
812 * range, which is far too long to wait in an interrupt. So
813 * we just run until the state machine tells us something
814 * happened or it needs a delay.
816 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
818 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
819 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
821 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
822 smi_inc_stat(smi_info, complete_transactions);
824 handle_transaction_done(smi_info);
825 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
826 } else if (si_sm_result == SI_SM_HOSED) {
827 smi_inc_stat(smi_info, hosed_count);
830 * Do the before return_hosed_msg, because that
833 smi_info->si_state = SI_NORMAL;
834 if (smi_info->curr_msg != NULL) {
836 * If we were handling a user message, format
837 * a response to send to the upper layer to
838 * tell it about the error.
840 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
842 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
846 * We prefer handling attn over new messages. But don't do
847 * this if there is not yet an upper layer to handle anything.
849 if (likely(smi_info->intf) &&
850 (si_sm_result == SI_SM_ATTN || smi_info->got_attn)) {
851 unsigned char msg[2];
853 if (smi_info->si_state != SI_NORMAL) {
855 * We got an ATTN, but we are doing something else.
856 * Handle the ATTN later.
858 smi_info->got_attn = true;
860 smi_info->got_attn = false;
861 smi_inc_stat(smi_info, attentions);
864 * Got a attn, send down a get message flags to see
865 * what's causing it. It would be better to handle
866 * this in the upper layer, but due to the way
867 * interrupts work with the SMI, that's not really
870 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
871 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
873 smi_info->handlers->start_transaction(
874 smi_info->si_sm, msg, 2);
875 smi_info->si_state = SI_GETTING_FLAGS;
880 /* If we are currently idle, try to start the next message. */
881 if (si_sm_result == SI_SM_IDLE) {
882 smi_inc_stat(smi_info, idles);
884 si_sm_result = start_next_msg(smi_info);
885 if (si_sm_result != SI_SM_IDLE)
889 if ((si_sm_result == SI_SM_IDLE)
890 && (atomic_read(&smi_info->req_events))) {
892 * We are idle and the upper layer requested that I fetch
895 atomic_set(&smi_info->req_events, 0);
898 * Take this opportunity to check the interrupt and
899 * message enable state for the BMC. The BMC can be
900 * asynchronously reset, and may thus get interrupts
901 * disable and messages disabled.
903 if (smi_info->supports_event_msg_buff || smi_info->irq) {
904 start_check_enables(smi_info);
906 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
907 if (!smi_info->curr_msg)
910 start_getting_events(smi_info);
918 static void check_start_timer_thread(struct smi_info *smi_info)
920 if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) {
921 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
923 if (smi_info->thread)
924 wake_up_process(smi_info->thread);
926 start_next_msg(smi_info);
927 smi_event_handler(smi_info, 0);
931 static void sender(void *send_info,
932 struct ipmi_smi_msg *msg)
934 struct smi_info *smi_info = send_info;
935 enum si_sm_result result;
938 debug_timestamp("Enqueue");
940 if (smi_info->run_to_completion) {
942 * If we are running to completion, start it and run
943 * transactions until everything is clear.
945 smi_info->curr_msg = msg;
946 smi_info->waiting_msg = NULL;
949 * Run to completion means we are single-threaded, no
953 result = smi_event_handler(smi_info, 0);
954 while (result != SI_SM_IDLE) {
955 udelay(SI_SHORT_TIMEOUT_USEC);
956 result = smi_event_handler(smi_info,
957 SI_SHORT_TIMEOUT_USEC);
962 spin_lock_irqsave(&smi_info->si_lock, flags);
964 * The following two lines don't need to be under the lock for
965 * the lock's sake, but they do need SMP memory barriers to
966 * avoid getting things out of order. We are already claiming
967 * the lock, anyway, so just do it under the lock to avoid the
970 BUG_ON(smi_info->waiting_msg);
971 smi_info->waiting_msg = msg;
972 check_start_timer_thread(smi_info);
973 spin_unlock_irqrestore(&smi_info->si_lock, flags);
976 static void set_run_to_completion(void *send_info, bool i_run_to_completion)
978 struct smi_info *smi_info = send_info;
979 enum si_sm_result result;
981 smi_info->run_to_completion = i_run_to_completion;
982 if (i_run_to_completion) {
983 result = smi_event_handler(smi_info, 0);
984 while (result != SI_SM_IDLE) {
985 udelay(SI_SHORT_TIMEOUT_USEC);
986 result = smi_event_handler(smi_info,
987 SI_SHORT_TIMEOUT_USEC);
993 * Use -1 in the nsec value of the busy waiting timespec to tell that
994 * we are spinning in kipmid looking for something and not delaying
997 static inline void ipmi_si_set_not_busy(struct timespec64 *ts)
1001 static inline int ipmi_si_is_busy(struct timespec64 *ts)
1003 return ts->tv_nsec != -1;
1006 static inline int ipmi_thread_busy_wait(enum si_sm_result smi_result,
1007 const struct smi_info *smi_info,
1008 struct timespec64 *busy_until)
1010 unsigned int max_busy_us = 0;
1012 if (smi_info->intf_num < num_max_busy_us)
1013 max_busy_us = kipmid_max_busy_us[smi_info->intf_num];
1014 if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
1015 ipmi_si_set_not_busy(busy_until);
1016 else if (!ipmi_si_is_busy(busy_until)) {
1017 getnstimeofday64(busy_until);
1018 timespec64_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
1020 struct timespec64 now;
1022 getnstimeofday64(&now);
1023 if (unlikely(timespec64_compare(&now, busy_until) > 0)) {
1024 ipmi_si_set_not_busy(busy_until);
1033 * A busy-waiting loop for speeding up IPMI operation.
1035 * Lousy hardware makes this hard. This is only enabled for systems
1036 * that are not BT and do not have interrupts. It starts spinning
1037 * when an operation is complete or until max_busy tells it to stop
1038 * (if that is enabled). See the paragraph on kimid_max_busy_us in
1039 * Documentation/IPMI.txt for details.
1041 static int ipmi_thread(void *data)
1043 struct smi_info *smi_info = data;
1044 unsigned long flags;
1045 enum si_sm_result smi_result;
1046 struct timespec64 busy_until;
1048 ipmi_si_set_not_busy(&busy_until);
1049 set_user_nice(current, MAX_NICE);
1050 while (!kthread_should_stop()) {
1053 spin_lock_irqsave(&(smi_info->si_lock), flags);
1054 smi_result = smi_event_handler(smi_info, 0);
1057 * If the driver is doing something, there is a possible
1058 * race with the timer. If the timer handler see idle,
1059 * and the thread here sees something else, the timer
1060 * handler won't restart the timer even though it is
1061 * required. So start it here if necessary.
1063 if (smi_result != SI_SM_IDLE && !smi_info->timer_running)
1064 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
1066 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1067 busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
1069 if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1071 else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait)
1073 else if (smi_result == SI_SM_IDLE) {
1074 if (atomic_read(&smi_info->need_watch)) {
1075 schedule_timeout_interruptible(100);
1077 /* Wait to be woken up when we are needed. */
1078 __set_current_state(TASK_INTERRUPTIBLE);
1082 schedule_timeout_interruptible(1);
1088 static void poll(void *send_info)
1090 struct smi_info *smi_info = send_info;
1091 unsigned long flags = 0;
1092 bool run_to_completion = smi_info->run_to_completion;
1095 * Make sure there is some delay in the poll loop so we can
1096 * drive time forward and timeout things.
1099 if (!run_to_completion)
1100 spin_lock_irqsave(&smi_info->si_lock, flags);
1101 smi_event_handler(smi_info, 10);
1102 if (!run_to_completion)
1103 spin_unlock_irqrestore(&smi_info->si_lock, flags);
1106 static void request_events(void *send_info)
1108 struct smi_info *smi_info = send_info;
1110 if (!smi_info->has_event_buffer)
1113 atomic_set(&smi_info->req_events, 1);
1116 static void set_need_watch(void *send_info, bool enable)
1118 struct smi_info *smi_info = send_info;
1119 unsigned long flags;
1121 atomic_set(&smi_info->need_watch, enable);
1122 spin_lock_irqsave(&smi_info->si_lock, flags);
1123 check_start_timer_thread(smi_info);
1124 spin_unlock_irqrestore(&smi_info->si_lock, flags);
1127 static int initialized;
1129 static void smi_timeout(unsigned long data)
1131 struct smi_info *smi_info = (struct smi_info *) data;
1132 enum si_sm_result smi_result;
1133 unsigned long flags;
1134 unsigned long jiffies_now;
1138 spin_lock_irqsave(&(smi_info->si_lock), flags);
1139 debug_timestamp("Timer");
1141 jiffies_now = jiffies;
1142 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
1143 * SI_USEC_PER_JIFFY);
1144 smi_result = smi_event_handler(smi_info, time_diff);
1146 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
1147 /* Running with interrupts, only do long timeouts. */
1148 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1149 smi_inc_stat(smi_info, long_timeouts);
1154 * If the state machine asks for a short delay, then shorten
1155 * the timer timeout.
1157 if (smi_result == SI_SM_CALL_WITH_DELAY) {
1158 smi_inc_stat(smi_info, short_timeouts);
1159 timeout = jiffies + 1;
1161 smi_inc_stat(smi_info, long_timeouts);
1162 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1166 if (smi_result != SI_SM_IDLE)
1167 smi_mod_timer(smi_info, timeout);
1169 smi_info->timer_running = false;
1170 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1173 static irqreturn_t si_irq_handler(int irq, void *data)
1175 struct smi_info *smi_info = data;
1176 unsigned long flags;
1178 spin_lock_irqsave(&(smi_info->si_lock), flags);
1180 smi_inc_stat(smi_info, interrupts);
1182 debug_timestamp("Interrupt");
1184 smi_event_handler(smi_info, 0);
1185 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1189 static irqreturn_t si_bt_irq_handler(int irq, void *data)
1191 struct smi_info *smi_info = data;
1192 /* We need to clear the IRQ flag for the BT interface. */
1193 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
1194 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
1195 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1196 return si_irq_handler(irq, data);
1199 static int smi_start_processing(void *send_info,
1202 struct smi_info *new_smi = send_info;
1205 new_smi->intf = intf;
1207 /* Try to claim any interrupts. */
1208 if (new_smi->irq_setup)
1209 new_smi->irq_setup(new_smi);
1211 /* Set up the timer that drives the interface. */
1212 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
1213 smi_mod_timer(new_smi, jiffies + SI_TIMEOUT_JIFFIES);
1216 * Check if the user forcefully enabled the daemon.
1218 if (new_smi->intf_num < num_force_kipmid)
1219 enable = force_kipmid[new_smi->intf_num];
1221 * The BT interface is efficient enough to not need a thread,
1222 * and there is no need for a thread if we have interrupts.
1224 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
1228 new_smi->thread = kthread_run(ipmi_thread, new_smi,
1229 "kipmi%d", new_smi->intf_num);
1230 if (IS_ERR(new_smi->thread)) {
1231 dev_notice(new_smi->dev, "Could not start"
1232 " kernel thread due to error %ld, only using"
1233 " timers to drive the interface\n",
1234 PTR_ERR(new_smi->thread));
1235 new_smi->thread = NULL;
1242 static int get_smi_info(void *send_info, struct ipmi_smi_info *data)
1244 struct smi_info *smi = send_info;
1246 data->addr_src = smi->addr_source;
1247 data->dev = smi->dev;
1248 data->addr_info = smi->addr_info;
1249 get_device(smi->dev);
1254 static void set_maintenance_mode(void *send_info, bool enable)
1256 struct smi_info *smi_info = send_info;
1259 atomic_set(&smi_info->req_events, 0);
1262 static struct ipmi_smi_handlers handlers = {
1263 .owner = THIS_MODULE,
1264 .start_processing = smi_start_processing,
1265 .get_smi_info = get_smi_info,
1267 .request_events = request_events,
1268 .set_need_watch = set_need_watch,
1269 .set_maintenance_mode = set_maintenance_mode,
1270 .set_run_to_completion = set_run_to_completion,
1275 * There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1276 * a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS.
1279 static LIST_HEAD(smi_infos);
1280 static DEFINE_MUTEX(smi_infos_lock);
1281 static int smi_num; /* Used to sequence the SMIs */
1283 #define DEFAULT_REGSPACING 1
1284 #define DEFAULT_REGSIZE 1
1287 static bool si_tryacpi = 1;
1290 static bool si_trydmi = 1;
1292 static bool si_tryplatform = 1;
1294 static bool si_trypci = 1;
1296 static bool si_trydefaults = IS_ENABLED(CONFIG_IPMI_SI_PROBE_DEFAULTS);
1297 static char *si_type[SI_MAX_PARMS];
1298 #define MAX_SI_TYPE_STR 30
1299 static char si_type_str[MAX_SI_TYPE_STR];
1300 static unsigned long addrs[SI_MAX_PARMS];
1301 static unsigned int num_addrs;
1302 static unsigned int ports[SI_MAX_PARMS];
1303 static unsigned int num_ports;
1304 static int irqs[SI_MAX_PARMS];
1305 static unsigned int num_irqs;
1306 static int regspacings[SI_MAX_PARMS];
1307 static unsigned int num_regspacings;
1308 static int regsizes[SI_MAX_PARMS];
1309 static unsigned int num_regsizes;
1310 static int regshifts[SI_MAX_PARMS];
1311 static unsigned int num_regshifts;
1312 static int slave_addrs[SI_MAX_PARMS]; /* Leaving 0 chooses the default value */
1313 static unsigned int num_slave_addrs;
1315 #define IPMI_IO_ADDR_SPACE 0
1316 #define IPMI_MEM_ADDR_SPACE 1
1317 static char *addr_space_to_str[] = { "i/o", "mem" };
1319 static int hotmod_handler(const char *val, struct kernel_param *kp);
1321 module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
1322 MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See"
1323 " Documentation/IPMI.txt in the kernel sources for the"
1327 module_param_named(tryacpi, si_tryacpi, bool, 0);
1328 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1329 " default scan of the interfaces identified via ACPI");
1332 module_param_named(trydmi, si_trydmi, bool, 0);
1333 MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the"
1334 " default scan of the interfaces identified via DMI");
1336 module_param_named(tryplatform, si_tryplatform, bool, 0);
1337 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1338 " default scan of the interfaces identified via platform"
1339 " interfaces like openfirmware");
1341 module_param_named(trypci, si_trypci, bool, 0);
1342 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1343 " default scan of the interfaces identified via pci");
1345 module_param_named(trydefaults, si_trydefaults, bool, 0);
1346 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1347 " default scan of the KCS and SMIC interface at the standard"
1349 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1350 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1351 " interface separated by commas. The types are 'kcs',"
1352 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1353 " the first interface to kcs and the second to bt");
1354 module_param_array(addrs, ulong, &num_addrs, 0);
1355 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1356 " addresses separated by commas. Only use if an interface"
1357 " is in memory. Otherwise, set it to zero or leave"
1359 module_param_array(ports, uint, &num_ports, 0);
1360 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1361 " addresses separated by commas. Only use if an interface"
1362 " is a port. Otherwise, set it to zero or leave"
1364 module_param_array(irqs, int, &num_irqs, 0);
1365 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1366 " addresses separated by commas. Only use if an interface"
1367 " has an interrupt. Otherwise, set it to zero or leave"
1369 module_param_array(regspacings, int, &num_regspacings, 0);
1370 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1371 " and each successive register used by the interface. For"
1372 " instance, if the start address is 0xca2 and the spacing"
1373 " is 2, then the second address is at 0xca4. Defaults"
1375 module_param_array(regsizes, int, &num_regsizes, 0);
1376 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1377 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1378 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1379 " the 8-bit IPMI register has to be read from a larger"
1381 module_param_array(regshifts, int, &num_regshifts, 0);
1382 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1383 " IPMI register, in bits. For instance, if the data"
1384 " is read from a 32-bit word and the IPMI data is in"
1385 " bit 8-15, then the shift would be 8");
1386 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1387 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1388 " the controller. Normally this is 0x20, but can be"
1389 " overridden by this parm. This is an array indexed"
1390 " by interface number.");
1391 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1392 MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1393 " disabled(0). Normally the IPMI driver auto-detects"
1394 " this, but the value may be overridden by this parm.");
1395 module_param(unload_when_empty, bool, 0);
1396 MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
1397 " specified or found, default is 1. Setting to 0"
1398 " is useful for hot add of devices using hotmod.");
1399 module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
1400 MODULE_PARM_DESC(kipmid_max_busy_us,
1401 "Max time (in microseconds) to busy-wait for IPMI data before"
1402 " sleeping. 0 (default) means to wait forever. Set to 100-500"
1403 " if kipmid is using up a lot of CPU time.");
1406 static void std_irq_cleanup(struct smi_info *info)
1408 if (info->si_type == SI_BT)
1409 /* Disable the interrupt in the BT interface. */
1410 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1411 free_irq(info->irq, info);
1414 static int std_irq_setup(struct smi_info *info)
1421 if (info->si_type == SI_BT) {
1422 rv = request_irq(info->irq,
1428 /* Enable the interrupt in the BT interface. */
1429 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1430 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1432 rv = request_irq(info->irq,
1438 dev_warn(info->dev, "%s unable to claim interrupt %d,"
1439 " running polled\n",
1440 DEVICE_NAME, info->irq);
1443 info->irq_cleanup = std_irq_cleanup;
1444 dev_info(info->dev, "Using irq %d\n", info->irq);
1450 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1452 unsigned int addr = io->addr_data;
1454 return inb(addr + (offset * io->regspacing));
1457 static void port_outb(struct si_sm_io *io, unsigned int offset,
1460 unsigned int addr = io->addr_data;
1462 outb(b, addr + (offset * io->regspacing));
1465 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1467 unsigned int addr = io->addr_data;
1469 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1472 static void port_outw(struct si_sm_io *io, unsigned int offset,
1475 unsigned int addr = io->addr_data;
1477 outw(b << io->regshift, addr + (offset * io->regspacing));
1480 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1482 unsigned int addr = io->addr_data;
1484 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1487 static void port_outl(struct si_sm_io *io, unsigned int offset,
1490 unsigned int addr = io->addr_data;
1492 outl(b << io->regshift, addr+(offset * io->regspacing));
1495 static void port_cleanup(struct smi_info *info)
1497 unsigned int addr = info->io.addr_data;
1501 for (idx = 0; idx < info->io_size; idx++)
1502 release_region(addr + idx * info->io.regspacing,
1507 static int port_setup(struct smi_info *info)
1509 unsigned int addr = info->io.addr_data;
1515 info->io_cleanup = port_cleanup;
1518 * Figure out the actual inb/inw/inl/etc routine to use based
1519 * upon the register size.
1521 switch (info->io.regsize) {
1523 info->io.inputb = port_inb;
1524 info->io.outputb = port_outb;
1527 info->io.inputb = port_inw;
1528 info->io.outputb = port_outw;
1531 info->io.inputb = port_inl;
1532 info->io.outputb = port_outl;
1535 dev_warn(info->dev, "Invalid register size: %d\n",
1541 * Some BIOSes reserve disjoint I/O regions in their ACPI
1542 * tables. This causes problems when trying to register the
1543 * entire I/O region. Therefore we must register each I/O
1546 for (idx = 0; idx < info->io_size; idx++) {
1547 if (request_region(addr + idx * info->io.regspacing,
1548 info->io.regsize, DEVICE_NAME) == NULL) {
1549 /* Undo allocations */
1551 release_region(addr + idx * info->io.regspacing,
1560 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1562 return readb((io->addr)+(offset * io->regspacing));
1565 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1568 writeb(b, (io->addr)+(offset * io->regspacing));
1571 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1573 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1577 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1580 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1583 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1585 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1589 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1592 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1596 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1598 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1602 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1605 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1609 static void mem_cleanup(struct smi_info *info)
1611 unsigned long addr = info->io.addr_data;
1614 if (info->io.addr) {
1615 iounmap(info->io.addr);
1617 mapsize = ((info->io_size * info->io.regspacing)
1618 - (info->io.regspacing - info->io.regsize));
1620 release_mem_region(addr, mapsize);
1624 static int mem_setup(struct smi_info *info)
1626 unsigned long addr = info->io.addr_data;
1632 info->io_cleanup = mem_cleanup;
1635 * Figure out the actual readb/readw/readl/etc routine to use based
1636 * upon the register size.
1638 switch (info->io.regsize) {
1640 info->io.inputb = intf_mem_inb;
1641 info->io.outputb = intf_mem_outb;
1644 info->io.inputb = intf_mem_inw;
1645 info->io.outputb = intf_mem_outw;
1648 info->io.inputb = intf_mem_inl;
1649 info->io.outputb = intf_mem_outl;
1653 info->io.inputb = mem_inq;
1654 info->io.outputb = mem_outq;
1658 dev_warn(info->dev, "Invalid register size: %d\n",
1664 * Calculate the total amount of memory to claim. This is an
1665 * unusual looking calculation, but it avoids claiming any
1666 * more memory than it has to. It will claim everything
1667 * between the first address to the end of the last full
1670 mapsize = ((info->io_size * info->io.regspacing)
1671 - (info->io.regspacing - info->io.regsize));
1673 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1676 info->io.addr = ioremap(addr, mapsize);
1677 if (info->io.addr == NULL) {
1678 release_mem_region(addr, mapsize);
1685 * Parms come in as <op1>[:op2[:op3...]]. ops are:
1686 * add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
1694 enum hotmod_op { HM_ADD, HM_REMOVE };
1695 struct hotmod_vals {
1699 static struct hotmod_vals hotmod_ops[] = {
1701 { "remove", HM_REMOVE },
1704 static struct hotmod_vals hotmod_si[] = {
1706 { "smic", SI_SMIC },
1710 static struct hotmod_vals hotmod_as[] = {
1711 { "mem", IPMI_MEM_ADDR_SPACE },
1712 { "i/o", IPMI_IO_ADDR_SPACE },
1716 static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
1721 s = strchr(*curr, ',');
1723 printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
1728 for (i = 0; v[i].name; i++) {
1729 if (strcmp(*curr, v[i].name) == 0) {
1736 printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
1740 static int check_hotmod_int_op(const char *curr, const char *option,
1741 const char *name, int *val)
1745 if (strcmp(curr, name) == 0) {
1747 printk(KERN_WARNING PFX
1748 "No option given for '%s'\n",
1752 *val = simple_strtoul(option, &n, 0);
1753 if ((*n != '\0') || (*option == '\0')) {
1754 printk(KERN_WARNING PFX
1755 "Bad option given for '%s'\n",
1764 static struct smi_info *smi_info_alloc(void)
1766 struct smi_info *info = kzalloc(sizeof(*info), GFP_KERNEL);
1769 spin_lock_init(&info->si_lock);
1773 static int hotmod_handler(const char *val, struct kernel_param *kp)
1775 char *str = kstrdup(val, GFP_KERNEL);
1777 char *next, *curr, *s, *n, *o;
1779 enum si_type si_type;
1789 struct smi_info *info;
1794 /* Kill any trailing spaces, as we can get a "\n" from echo. */
1797 while ((ival >= 0) && isspace(str[ival])) {
1802 for (curr = str; curr; curr = next) {
1807 ipmb = 0; /* Choose the default if not specified */
1809 next = strchr(curr, ':');
1815 rv = parse_str(hotmod_ops, &ival, "operation", &curr);
1820 rv = parse_str(hotmod_si, &ival, "interface type", &curr);
1825 rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
1829 s = strchr(curr, ',');
1834 addr = simple_strtoul(curr, &n, 0);
1835 if ((*n != '\0') || (*curr == '\0')) {
1836 printk(KERN_WARNING PFX "Invalid hotmod address"
1843 s = strchr(curr, ',');
1848 o = strchr(curr, '=');
1853 rv = check_hotmod_int_op(curr, o, "rsp", ®spacing);
1858 rv = check_hotmod_int_op(curr, o, "rsi", ®size);
1863 rv = check_hotmod_int_op(curr, o, "rsh", ®shift);
1868 rv = check_hotmod_int_op(curr, o, "irq", &irq);
1873 rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
1880 printk(KERN_WARNING PFX
1881 "Invalid hotmod option '%s'\n",
1887 info = smi_info_alloc();
1893 info->addr_source = SI_HOTMOD;
1894 info->si_type = si_type;
1895 info->io.addr_data = addr;
1896 info->io.addr_type = addr_space;
1897 if (addr_space == IPMI_MEM_ADDR_SPACE)
1898 info->io_setup = mem_setup;
1900 info->io_setup = port_setup;
1902 info->io.addr = NULL;
1903 info->io.regspacing = regspacing;
1904 if (!info->io.regspacing)
1905 info->io.regspacing = DEFAULT_REGSPACING;
1906 info->io.regsize = regsize;
1907 if (!info->io.regsize)
1908 info->io.regsize = DEFAULT_REGSPACING;
1909 info->io.regshift = regshift;
1912 info->irq_setup = std_irq_setup;
1913 info->slave_addr = ipmb;
1920 rv = try_smi_init(info);
1922 cleanup_one_si(info);
1927 struct smi_info *e, *tmp_e;
1929 mutex_lock(&smi_infos_lock);
1930 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
1931 if (e->io.addr_type != addr_space)
1933 if (e->si_type != si_type)
1935 if (e->io.addr_data == addr)
1938 mutex_unlock(&smi_infos_lock);
1947 static int hardcode_find_bmc(void)
1951 struct smi_info *info;
1953 for (i = 0; i < SI_MAX_PARMS; i++) {
1954 if (!ports[i] && !addrs[i])
1957 info = smi_info_alloc();
1961 info->addr_source = SI_HARDCODED;
1962 printk(KERN_INFO PFX "probing via hardcoded address\n");
1964 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1965 info->si_type = SI_KCS;
1966 } else if (strcmp(si_type[i], "smic") == 0) {
1967 info->si_type = SI_SMIC;
1968 } else if (strcmp(si_type[i], "bt") == 0) {
1969 info->si_type = SI_BT;
1971 printk(KERN_WARNING PFX "Interface type specified "
1972 "for interface %d, was invalid: %s\n",
1980 info->io_setup = port_setup;
1981 info->io.addr_data = ports[i];
1982 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1983 } else if (addrs[i]) {
1985 info->io_setup = mem_setup;
1986 info->io.addr_data = addrs[i];
1987 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1989 printk(KERN_WARNING PFX "Interface type specified "
1990 "for interface %d, but port and address were "
1991 "not set or set to zero.\n", i);
1996 info->io.addr = NULL;
1997 info->io.regspacing = regspacings[i];
1998 if (!info->io.regspacing)
1999 info->io.regspacing = DEFAULT_REGSPACING;
2000 info->io.regsize = regsizes[i];
2001 if (!info->io.regsize)
2002 info->io.regsize = DEFAULT_REGSPACING;
2003 info->io.regshift = regshifts[i];
2004 info->irq = irqs[i];
2006 info->irq_setup = std_irq_setup;
2007 info->slave_addr = slave_addrs[i];
2009 if (!add_smi(info)) {
2010 if (try_smi_init(info))
2011 cleanup_one_si(info);
2022 #include <linux/acpi.h>
2025 * Once we get an ACPI failure, we don't try any more, because we go
2026 * through the tables sequentially. Once we don't find a table, there
2029 static int acpi_failure;
2031 /* For GPE-type interrupts. */
2032 static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
2033 u32 gpe_number, void *context)
2035 struct smi_info *smi_info = context;
2036 unsigned long flags;
2038 spin_lock_irqsave(&(smi_info->si_lock), flags);
2040 smi_inc_stat(smi_info, interrupts);
2042 debug_timestamp("ACPI_GPE");
2044 smi_event_handler(smi_info, 0);
2045 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
2047 return ACPI_INTERRUPT_HANDLED;
2050 static void acpi_gpe_irq_cleanup(struct smi_info *info)
2055 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
2058 static int acpi_gpe_irq_setup(struct smi_info *info)
2065 status = acpi_install_gpe_handler(NULL,
2067 ACPI_GPE_LEVEL_TRIGGERED,
2070 if (status != AE_OK) {
2071 dev_warn(info->dev, "%s unable to claim ACPI GPE %d,"
2072 " running polled\n", DEVICE_NAME, info->irq);
2076 info->irq_cleanup = acpi_gpe_irq_cleanup;
2077 dev_info(info->dev, "Using ACPI GPE %d\n", info->irq);
2084 * http://h21007.www2.hp.com/portal/download/files/unprot/hpspmi.pdf
2095 s8 CreatorRevision[4];
2098 s16 SpecificationRevision;
2101 * Bit 0 - SCI interrupt supported
2102 * Bit 1 - I/O APIC/SAPIC
2107 * If bit 0 of InterruptType is set, then this is the SCI
2108 * interrupt in the GPEx_STS register.
2115 * If bit 1 of InterruptType is set, then this is the I/O
2116 * APIC/SAPIC interrupt.
2118 u32 GlobalSystemInterrupt;
2120 /* The actual register address. */
2121 struct acpi_generic_address addr;
2125 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
2128 static int try_init_spmi(struct SPMITable *spmi)
2130 struct smi_info *info;
2133 if (spmi->IPMIlegacy != 1) {
2134 printk(KERN_INFO PFX "Bad SPMI legacy %d\n", spmi->IPMIlegacy);
2138 info = smi_info_alloc();
2140 printk(KERN_ERR PFX "Could not allocate SI data (3)\n");
2144 info->addr_source = SI_SPMI;
2145 printk(KERN_INFO PFX "probing via SPMI\n");
2147 /* Figure out the interface type. */
2148 switch (spmi->InterfaceType) {
2150 info->si_type = SI_KCS;
2153 info->si_type = SI_SMIC;
2156 info->si_type = SI_BT;
2158 case 4: /* SSIF, just ignore */
2162 printk(KERN_INFO PFX "Unknown ACPI/SPMI SI type %d\n",
2163 spmi->InterfaceType);
2168 if (spmi->InterruptType & 1) {
2169 /* We've got a GPE interrupt. */
2170 info->irq = spmi->GPE;
2171 info->irq_setup = acpi_gpe_irq_setup;
2172 } else if (spmi->InterruptType & 2) {
2173 /* We've got an APIC/SAPIC interrupt. */
2174 info->irq = spmi->GlobalSystemInterrupt;
2175 info->irq_setup = std_irq_setup;
2177 /* Use the default interrupt setting. */
2179 info->irq_setup = NULL;
2182 if (spmi->addr.bit_width) {
2183 /* A (hopefully) properly formed register bit width. */
2184 info->io.regspacing = spmi->addr.bit_width / 8;
2186 info->io.regspacing = DEFAULT_REGSPACING;
2188 info->io.regsize = info->io.regspacing;
2189 info->io.regshift = spmi->addr.bit_offset;
2191 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
2192 info->io_setup = mem_setup;
2193 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2194 } else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
2195 info->io_setup = port_setup;
2196 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2199 printk(KERN_WARNING PFX "Unknown ACPI I/O Address type\n");
2202 info->io.addr_data = spmi->addr.address;
2204 pr_info("ipmi_si: SPMI: %s %#lx regsize %d spacing %d irq %d\n",
2205 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
2206 info->io.addr_data, info->io.regsize, info->io.regspacing,
2216 static void spmi_find_bmc(void)
2219 struct SPMITable *spmi;
2228 for (i = 0; ; i++) {
2229 status = acpi_get_table(ACPI_SIG_SPMI, i+1,
2230 (struct acpi_table_header **)&spmi);
2231 if (status != AE_OK)
2234 try_init_spmi(spmi);
2238 static int ipmi_pnp_probe(struct pnp_dev *dev,
2239 const struct pnp_device_id *dev_id)
2241 struct acpi_device *acpi_dev;
2242 struct smi_info *info;
2243 struct resource *res, *res_second;
2246 unsigned long long tmp;
2249 acpi_dev = pnp_acpi_device(dev);
2253 info = smi_info_alloc();
2257 info->addr_source = SI_ACPI;
2258 printk(KERN_INFO PFX "probing via ACPI\n");
2260 handle = acpi_dev->handle;
2261 info->addr_info.acpi_info.acpi_handle = handle;
2263 /* _IFT tells us the interface type: KCS, BT, etc */
2264 status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp);
2265 if (ACPI_FAILURE(status))
2270 info->si_type = SI_KCS;
2273 info->si_type = SI_SMIC;
2276 info->si_type = SI_BT;
2278 case 4: /* SSIF, just ignore */
2281 dev_info(&dev->dev, "unknown IPMI type %lld\n", tmp);
2285 res = pnp_get_resource(dev, IORESOURCE_IO, 0);
2287 info->io_setup = port_setup;
2288 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2290 res = pnp_get_resource(dev, IORESOURCE_MEM, 0);
2292 info->io_setup = mem_setup;
2293 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2297 dev_err(&dev->dev, "no I/O or memory address\n");
2300 info->io.addr_data = res->start;
2302 info->io.regspacing = DEFAULT_REGSPACING;
2303 res_second = pnp_get_resource(dev,
2304 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ?
2305 IORESOURCE_IO : IORESOURCE_MEM,
2308 if (res_second->start > info->io.addr_data)
2309 info->io.regspacing = res_second->start - info->io.addr_data;
2311 info->io.regsize = DEFAULT_REGSPACING;
2312 info->io.regshift = 0;
2314 /* If _GPE exists, use it; otherwise use standard interrupts */
2315 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
2316 if (ACPI_SUCCESS(status)) {
2318 info->irq_setup = acpi_gpe_irq_setup;
2319 } else if (pnp_irq_valid(dev, 0)) {
2320 info->irq = pnp_irq(dev, 0);
2321 info->irq_setup = std_irq_setup;
2324 info->dev = &dev->dev;
2325 pnp_set_drvdata(dev, info);
2327 dev_info(info->dev, "%pR regsize %d spacing %d irq %d\n",
2328 res, info->io.regsize, info->io.regspacing,
2342 static void ipmi_pnp_remove(struct pnp_dev *dev)
2344 struct smi_info *info = pnp_get_drvdata(dev);
2346 cleanup_one_si(info);
2349 static const struct pnp_device_id pnp_dev_table[] = {
2354 static struct pnp_driver ipmi_pnp_driver = {
2355 .name = DEVICE_NAME,
2356 .probe = ipmi_pnp_probe,
2357 .remove = ipmi_pnp_remove,
2358 .id_table = pnp_dev_table,
2361 MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
2365 struct dmi_ipmi_data {
2368 unsigned long base_addr;
2374 static int decode_dmi(const struct dmi_header *dm,
2375 struct dmi_ipmi_data *dmi)
2377 const u8 *data = (const u8 *)dm;
2378 unsigned long base_addr;
2380 u8 len = dm->length;
2382 dmi->type = data[4];
2384 memcpy(&base_addr, data+8, sizeof(unsigned long));
2386 if (base_addr & 1) {
2388 base_addr &= 0xFFFE;
2389 dmi->addr_space = IPMI_IO_ADDR_SPACE;
2392 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
2394 /* If bit 4 of byte 0x10 is set, then the lsb for the address
2396 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
2398 dmi->irq = data[0x11];
2400 /* The top two bits of byte 0x10 hold the register spacing. */
2401 reg_spacing = (data[0x10] & 0xC0) >> 6;
2402 switch (reg_spacing) {
2403 case 0x00: /* Byte boundaries */
2406 case 0x01: /* 32-bit boundaries */
2409 case 0x02: /* 16-byte boundaries */
2413 /* Some other interface, just ignore it. */
2419 * Note that technically, the lower bit of the base
2420 * address should be 1 if the address is I/O and 0 if
2421 * the address is in memory. So many systems get that
2422 * wrong (and all that I have seen are I/O) so we just
2423 * ignore that bit and assume I/O. Systems that use
2424 * memory should use the newer spec, anyway.
2426 dmi->base_addr = base_addr & 0xfffe;
2427 dmi->addr_space = IPMI_IO_ADDR_SPACE;
2431 dmi->slave_addr = data[6];
2436 static void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
2438 struct smi_info *info;
2440 info = smi_info_alloc();
2442 printk(KERN_ERR PFX "Could not allocate SI data\n");
2446 info->addr_source = SI_SMBIOS;
2447 printk(KERN_INFO PFX "probing via SMBIOS\n");
2449 switch (ipmi_data->type) {
2450 case 0x01: /* KCS */
2451 info->si_type = SI_KCS;
2453 case 0x02: /* SMIC */
2454 info->si_type = SI_SMIC;
2457 info->si_type = SI_BT;
2464 switch (ipmi_data->addr_space) {
2465 case IPMI_MEM_ADDR_SPACE:
2466 info->io_setup = mem_setup;
2467 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2470 case IPMI_IO_ADDR_SPACE:
2471 info->io_setup = port_setup;
2472 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2477 printk(KERN_WARNING PFX "Unknown SMBIOS I/O Address type: %d\n",
2478 ipmi_data->addr_space);
2481 info->io.addr_data = ipmi_data->base_addr;
2483 info->io.regspacing = ipmi_data->offset;
2484 if (!info->io.regspacing)
2485 info->io.regspacing = DEFAULT_REGSPACING;
2486 info->io.regsize = DEFAULT_REGSPACING;
2487 info->io.regshift = 0;
2489 info->slave_addr = ipmi_data->slave_addr;
2491 info->irq = ipmi_data->irq;
2493 info->irq_setup = std_irq_setup;
2495 pr_info("ipmi_si: SMBIOS: %s %#lx regsize %d spacing %d irq %d\n",
2496 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
2497 info->io.addr_data, info->io.regsize, info->io.regspacing,
2504 static void dmi_find_bmc(void)
2506 const struct dmi_device *dev = NULL;
2507 struct dmi_ipmi_data data;
2510 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
2511 memset(&data, 0, sizeof(data));
2512 rv = decode_dmi((const struct dmi_header *) dev->device_data,
2515 try_init_dmi(&data);
2518 #endif /* CONFIG_DMI */
2522 #define PCI_ERMC_CLASSCODE 0x0C0700
2523 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
2524 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
2525 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
2526 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
2527 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
2529 #define PCI_HP_VENDOR_ID 0x103C
2530 #define PCI_MMC_DEVICE_ID 0x121A
2531 #define PCI_MMC_ADDR_CW 0x10
2533 static void ipmi_pci_cleanup(struct smi_info *info)
2535 struct pci_dev *pdev = info->addr_source_data;
2537 pci_disable_device(pdev);
2540 static int ipmi_pci_probe_regspacing(struct smi_info *info)
2542 if (info->si_type == SI_KCS) {
2543 unsigned char status;
2546 info->io.regsize = DEFAULT_REGSIZE;
2547 info->io.regshift = 0;
2549 info->handlers = &kcs_smi_handlers;
2551 /* detect 1, 4, 16byte spacing */
2552 for (regspacing = DEFAULT_REGSPACING; regspacing <= 16;) {
2553 info->io.regspacing = regspacing;
2554 if (info->io_setup(info)) {
2556 "Could not setup I/O space\n");
2557 return DEFAULT_REGSPACING;
2559 /* write invalid cmd */
2560 info->io.outputb(&info->io, 1, 0x10);
2561 /* read status back */
2562 status = info->io.inputb(&info->io, 1);
2563 info->io_cleanup(info);
2569 return DEFAULT_REGSPACING;
2572 static int ipmi_pci_probe(struct pci_dev *pdev,
2573 const struct pci_device_id *ent)
2576 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
2577 struct smi_info *info;
2579 info = smi_info_alloc();
2583 info->addr_source = SI_PCI;
2584 dev_info(&pdev->dev, "probing via PCI");
2586 switch (class_type) {
2587 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
2588 info->si_type = SI_SMIC;
2591 case PCI_ERMC_CLASSCODE_TYPE_KCS:
2592 info->si_type = SI_KCS;
2595 case PCI_ERMC_CLASSCODE_TYPE_BT:
2596 info->si_type = SI_BT;
2601 dev_info(&pdev->dev, "Unknown IPMI type: %d\n", class_type);
2605 rv = pci_enable_device(pdev);
2607 dev_err(&pdev->dev, "couldn't enable PCI device\n");
2612 info->addr_source_cleanup = ipmi_pci_cleanup;
2613 info->addr_source_data = pdev;
2615 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2616 info->io_setup = port_setup;
2617 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2619 info->io_setup = mem_setup;
2620 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2622 info->io.addr_data = pci_resource_start(pdev, 0);
2624 info->io.regspacing = ipmi_pci_probe_regspacing(info);
2625 info->io.regsize = DEFAULT_REGSIZE;
2626 info->io.regshift = 0;
2628 info->irq = pdev->irq;
2630 info->irq_setup = std_irq_setup;
2632 info->dev = &pdev->dev;
2633 pci_set_drvdata(pdev, info);
2635 dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n",
2636 &pdev->resource[0], info->io.regsize, info->io.regspacing,
2642 pci_disable_device(pdev);
2648 static void ipmi_pci_remove(struct pci_dev *pdev)
2650 struct smi_info *info = pci_get_drvdata(pdev);
2651 cleanup_one_si(info);
2652 pci_disable_device(pdev);
2655 static struct pci_device_id ipmi_pci_devices[] = {
2656 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
2657 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
2660 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
2662 static struct pci_driver ipmi_pci_driver = {
2663 .name = DEVICE_NAME,
2664 .id_table = ipmi_pci_devices,
2665 .probe = ipmi_pci_probe,
2666 .remove = ipmi_pci_remove,
2668 #endif /* CONFIG_PCI */
2670 static const struct of_device_id ipmi_match[];
2671 static int ipmi_probe(struct platform_device *dev)
2674 const struct of_device_id *match;
2675 struct smi_info *info;
2676 struct resource resource;
2677 const __be32 *regsize, *regspacing, *regshift;
2678 struct device_node *np = dev->dev.of_node;
2682 dev_info(&dev->dev, "probing via device tree\n");
2684 match = of_match_device(ipmi_match, &dev->dev);
2688 if (!of_device_is_available(np))
2691 ret = of_address_to_resource(np, 0, &resource);
2693 dev_warn(&dev->dev, PFX "invalid address from OF\n");
2697 regsize = of_get_property(np, "reg-size", &proplen);
2698 if (regsize && proplen != 4) {
2699 dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
2703 regspacing = of_get_property(np, "reg-spacing", &proplen);
2704 if (regspacing && proplen != 4) {
2705 dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
2709 regshift = of_get_property(np, "reg-shift", &proplen);
2710 if (regshift && proplen != 4) {
2711 dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
2715 info = smi_info_alloc();
2719 "could not allocate memory for OF probe\n");
2723 info->si_type = (enum si_type) match->data;
2724 info->addr_source = SI_DEVICETREE;
2725 info->irq_setup = std_irq_setup;
2727 if (resource.flags & IORESOURCE_IO) {
2728 info->io_setup = port_setup;
2729 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2731 info->io_setup = mem_setup;
2732 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2735 info->io.addr_data = resource.start;
2737 info->io.regsize = regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE;
2738 info->io.regspacing = regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING;
2739 info->io.regshift = regshift ? be32_to_cpup(regshift) : 0;
2741 info->irq = irq_of_parse_and_map(dev->dev.of_node, 0);
2742 info->dev = &dev->dev;
2744 dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",
2745 info->io.addr_data, info->io.regsize, info->io.regspacing,
2748 dev_set_drvdata(&dev->dev, info);
2750 ret = add_smi(info);
2759 static int ipmi_remove(struct platform_device *dev)
2762 cleanup_one_si(dev_get_drvdata(&dev->dev));
2767 static const struct of_device_id ipmi_match[] =
2769 { .type = "ipmi", .compatible = "ipmi-kcs",
2770 .data = (void *)(unsigned long) SI_KCS },
2771 { .type = "ipmi", .compatible = "ipmi-smic",
2772 .data = (void *)(unsigned long) SI_SMIC },
2773 { .type = "ipmi", .compatible = "ipmi-bt",
2774 .data = (void *)(unsigned long) SI_BT },
2778 static struct platform_driver ipmi_driver = {
2780 .name = DEVICE_NAME,
2781 .of_match_table = ipmi_match,
2783 .probe = ipmi_probe,
2784 .remove = ipmi_remove,
2787 #ifdef CONFIG_PARISC
2788 static int ipmi_parisc_probe(struct parisc_device *dev)
2790 struct smi_info *info;
2793 info = smi_info_alloc();
2797 "could not allocate memory for PARISC probe\n");
2801 info->si_type = SI_KCS;
2802 info->addr_source = SI_DEVICETREE;
2803 info->io_setup = mem_setup;
2804 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2805 info->io.addr_data = dev->hpa.start;
2806 info->io.regsize = 1;
2807 info->io.regspacing = 1;
2808 info->io.regshift = 0;
2809 info->irq = 0; /* no interrupt */
2810 info->irq_setup = NULL;
2811 info->dev = &dev->dev;
2813 dev_dbg(&dev->dev, "addr 0x%lx\n", info->io.addr_data);
2815 dev_set_drvdata(&dev->dev, info);
2826 static int ipmi_parisc_remove(struct parisc_device *dev)
2828 cleanup_one_si(dev_get_drvdata(&dev->dev));
2832 static struct parisc_device_id ipmi_parisc_tbl[] = {
2833 { HPHW_MC, HVERSION_REV_ANY_ID, 0x004, 0xC0 },
2837 static struct parisc_driver ipmi_parisc_driver = {
2839 .id_table = ipmi_parisc_tbl,
2840 .probe = ipmi_parisc_probe,
2841 .remove = ipmi_parisc_remove,
2843 #endif /* CONFIG_PARISC */
2845 static int wait_for_msg_done(struct smi_info *smi_info)
2847 enum si_sm_result smi_result;
2849 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
2851 if (smi_result == SI_SM_CALL_WITH_DELAY ||
2852 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
2853 schedule_timeout_uninterruptible(1);
2854 smi_result = smi_info->handlers->event(
2855 smi_info->si_sm, jiffies_to_usecs(1));
2856 } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
2857 smi_result = smi_info->handlers->event(
2858 smi_info->si_sm, 0);
2862 if (smi_result == SI_SM_HOSED)
2864 * We couldn't get the state machine to run, so whatever's at
2865 * the port is probably not an IPMI SMI interface.
2872 static int try_get_dev_id(struct smi_info *smi_info)
2874 unsigned char msg[2];
2875 unsigned char *resp;
2876 unsigned long resp_len;
2879 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2884 * Do a Get Device ID command, since it comes back with some
2887 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2888 msg[1] = IPMI_GET_DEVICE_ID_CMD;
2889 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2891 rv = wait_for_msg_done(smi_info);
2895 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2896 resp, IPMI_MAX_MSG_LENGTH);
2898 /* Check and record info from the get device id, in case we need it. */
2899 rv = ipmi_demangle_device_id(resp, resp_len, &smi_info->device_id);
2907 * Some BMCs do not support clearing the receive irq bit in the global
2908 * enables (even if they don't support interrupts on the BMC). Check
2909 * for this and handle it properly.
2911 static void check_clr_rcv_irq(struct smi_info *smi_info)
2913 unsigned char msg[3];
2914 unsigned char *resp;
2915 unsigned long resp_len;
2918 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2920 printk(KERN_WARNING PFX "Out of memory allocating response for"
2921 " global enables command, cannot check recv irq bit"
2926 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2927 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
2928 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2930 rv = wait_for_msg_done(smi_info);
2932 printk(KERN_WARNING PFX "Error getting response from get"
2933 " global enables command, cannot check recv irq bit"
2938 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2939 resp, IPMI_MAX_MSG_LENGTH);
2942 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
2943 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD ||
2945 printk(KERN_WARNING PFX "Invalid return from get global"
2946 " enables command, cannot check recv irq bit"
2952 if ((resp[3] & IPMI_BMC_RCV_MSG_INTR) == 0)
2953 /* Already clear, should work ok. */
2956 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2957 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
2958 msg[2] = resp[3] & ~IPMI_BMC_RCV_MSG_INTR;
2959 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
2961 rv = wait_for_msg_done(smi_info);
2963 printk(KERN_WARNING PFX "Error getting response from set"
2964 " global enables command, cannot check recv irq bit"
2969 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2970 resp, IPMI_MAX_MSG_LENGTH);
2973 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
2974 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
2975 printk(KERN_WARNING PFX "Invalid return from get global"
2976 " enables command, cannot check recv irq bit"
2984 * An error when setting the event buffer bit means
2985 * clearing the bit is not supported.
2987 printk(KERN_WARNING PFX "The BMC does not support clearing"
2988 " the recv irq bit, compensating, but the BMC needs to"
2990 smi_info->cannot_clear_recv_irq_bit = true;
2996 static int try_enable_event_buffer(struct smi_info *smi_info)
2998 unsigned char msg[3];
2999 unsigned char *resp;
3000 unsigned long resp_len;
3003 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
3007 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
3008 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
3009 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
3011 rv = wait_for_msg_done(smi_info);
3013 printk(KERN_WARNING PFX "Error getting response from get"
3014 " global enables command, the event buffer is not"
3019 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
3020 resp, IPMI_MAX_MSG_LENGTH);
3023 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
3024 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD ||
3026 printk(KERN_WARNING PFX "Invalid return from get global"
3027 " enables command, cannot enable the event buffer.\n");
3032 if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) {
3033 /* buffer is already enabled, nothing to do. */
3034 smi_info->supports_event_msg_buff = true;
3038 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
3039 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
3040 msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF;
3041 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
3043 rv = wait_for_msg_done(smi_info);
3045 printk(KERN_WARNING PFX "Error getting response from set"
3046 " global, enables command, the event buffer is not"
3051 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
3052 resp, IPMI_MAX_MSG_LENGTH);
3055 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
3056 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
3057 printk(KERN_WARNING PFX "Invalid return from get global,"
3058 "enables command, not enable the event buffer.\n");
3065 * An error when setting the event buffer bit means
3066 * that the event buffer is not supported.
3070 smi_info->supports_event_msg_buff = true;
3077 static int smi_type_proc_show(struct seq_file *m, void *v)
3079 struct smi_info *smi = m->private;
3081 seq_printf(m, "%s\n", si_to_str[smi->si_type]);
3083 return seq_has_overflowed(m);
3086 static int smi_type_proc_open(struct inode *inode, struct file *file)
3088 return single_open(file, smi_type_proc_show, PDE_DATA(inode));
3091 static const struct file_operations smi_type_proc_ops = {
3092 .open = smi_type_proc_open,
3094 .llseek = seq_lseek,
3095 .release = single_release,
3098 static int smi_si_stats_proc_show(struct seq_file *m, void *v)
3100 struct smi_info *smi = m->private;
3102 seq_printf(m, "interrupts_enabled: %d\n",
3103 smi->irq && !smi->interrupt_disabled);
3104 seq_printf(m, "short_timeouts: %u\n",
3105 smi_get_stat(smi, short_timeouts));
3106 seq_printf(m, "long_timeouts: %u\n",
3107 smi_get_stat(smi, long_timeouts));
3108 seq_printf(m, "idles: %u\n",
3109 smi_get_stat(smi, idles));
3110 seq_printf(m, "interrupts: %u\n",
3111 smi_get_stat(smi, interrupts));
3112 seq_printf(m, "attentions: %u\n",
3113 smi_get_stat(smi, attentions));
3114 seq_printf(m, "flag_fetches: %u\n",
3115 smi_get_stat(smi, flag_fetches));
3116 seq_printf(m, "hosed_count: %u\n",
3117 smi_get_stat(smi, hosed_count));
3118 seq_printf(m, "complete_transactions: %u\n",
3119 smi_get_stat(smi, complete_transactions));
3120 seq_printf(m, "events: %u\n",
3121 smi_get_stat(smi, events));
3122 seq_printf(m, "watchdog_pretimeouts: %u\n",
3123 smi_get_stat(smi, watchdog_pretimeouts));
3124 seq_printf(m, "incoming_messages: %u\n",
3125 smi_get_stat(smi, incoming_messages));
3129 static int smi_si_stats_proc_open(struct inode *inode, struct file *file)
3131 return single_open(file, smi_si_stats_proc_show, PDE_DATA(inode));
3134 static const struct file_operations smi_si_stats_proc_ops = {
3135 .open = smi_si_stats_proc_open,
3137 .llseek = seq_lseek,
3138 .release = single_release,
3141 static int smi_params_proc_show(struct seq_file *m, void *v)
3143 struct smi_info *smi = m->private;
3146 "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
3147 si_to_str[smi->si_type],
3148 addr_space_to_str[smi->io.addr_type],
3156 return seq_has_overflowed(m);
3159 static int smi_params_proc_open(struct inode *inode, struct file *file)
3161 return single_open(file, smi_params_proc_show, PDE_DATA(inode));
3164 static const struct file_operations smi_params_proc_ops = {
3165 .open = smi_params_proc_open,
3167 .llseek = seq_lseek,
3168 .release = single_release,
3172 * oem_data_avail_to_receive_msg_avail
3173 * @info - smi_info structure with msg_flags set
3175 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
3176 * Returns 1 indicating need to re-run handle_flags().
3178 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
3180 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
3186 * setup_dell_poweredge_oem_data_handler
3187 * @info - smi_info.device_id must be populated
3189 * Systems that match, but have firmware version < 1.40 may assert
3190 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
3191 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
3192 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
3193 * as RECEIVE_MSG_AVAIL instead.
3195 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
3196 * assert the OEM[012] bits, and if it did, the driver would have to
3197 * change to handle that properly, we don't actually check for the
3199 * Device ID = 0x20 BMC on PowerEdge 8G servers
3200 * Device Revision = 0x80
3201 * Firmware Revision1 = 0x01 BMC version 1.40
3202 * Firmware Revision2 = 0x40 BCD encoded
3203 * IPMI Version = 0x51 IPMI 1.5
3204 * Manufacturer ID = A2 02 00 Dell IANA
3206 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
3207 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
3210 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
3211 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
3212 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
3213 #define DELL_IANA_MFR_ID 0x0002a2
3214 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
3216 struct ipmi_device_id *id = &smi_info->device_id;
3217 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
3218 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
3219 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
3220 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
3221 smi_info->oem_data_avail_handler =
3222 oem_data_avail_to_receive_msg_avail;
3223 } else if (ipmi_version_major(id) < 1 ||
3224 (ipmi_version_major(id) == 1 &&
3225 ipmi_version_minor(id) < 5)) {
3226 smi_info->oem_data_avail_handler =
3227 oem_data_avail_to_receive_msg_avail;
3232 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
3233 static void return_hosed_msg_badsize(struct smi_info *smi_info)
3235 struct ipmi_smi_msg *msg = smi_info->curr_msg;
3237 /* Make it a response */
3238 msg->rsp[0] = msg->data[0] | 4;
3239 msg->rsp[1] = msg->data[1];
3240 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
3242 smi_info->curr_msg = NULL;
3243 deliver_recv_msg(smi_info, msg);
3247 * dell_poweredge_bt_xaction_handler
3248 * @info - smi_info.device_id must be populated
3250 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
3251 * not respond to a Get SDR command if the length of the data
3252 * requested is exactly 0x3A, which leads to command timeouts and no
3253 * data returned. This intercepts such commands, and causes userspace
3254 * callers to try again with a different-sized buffer, which succeeds.
3257 #define STORAGE_NETFN 0x0A
3258 #define STORAGE_CMD_GET_SDR 0x23
3259 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
3260 unsigned long unused,
3263 struct smi_info *smi_info = in;
3264 unsigned char *data = smi_info->curr_msg->data;
3265 unsigned int size = smi_info->curr_msg->data_size;
3267 (data[0]>>2) == STORAGE_NETFN &&
3268 data[1] == STORAGE_CMD_GET_SDR &&
3270 return_hosed_msg_badsize(smi_info);
3276 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
3277 .notifier_call = dell_poweredge_bt_xaction_handler,
3281 * setup_dell_poweredge_bt_xaction_handler
3282 * @info - smi_info.device_id must be filled in already
3284 * Fills in smi_info.device_id.start_transaction_pre_hook
3285 * when we know what function to use there.
3288 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
3290 struct ipmi_device_id *id = &smi_info->device_id;
3291 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
3292 smi_info->si_type == SI_BT)
3293 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
3297 * setup_oem_data_handler
3298 * @info - smi_info.device_id must be filled in already
3300 * Fills in smi_info.device_id.oem_data_available_handler
3301 * when we know what function to use there.
3304 static void setup_oem_data_handler(struct smi_info *smi_info)
3306 setup_dell_poweredge_oem_data_handler(smi_info);
3309 static void setup_xaction_handlers(struct smi_info *smi_info)
3311 setup_dell_poweredge_bt_xaction_handler(smi_info);
3314 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
3316 if (smi_info->thread != NULL)
3317 kthread_stop(smi_info->thread);
3318 if (smi_info->timer_running)
3319 del_timer_sync(&smi_info->si_timer);
3322 static struct ipmi_default_vals
3328 { .type = SI_KCS, .port = 0xca2 },
3329 { .type = SI_SMIC, .port = 0xca9 },
3330 { .type = SI_BT, .port = 0xe4 },
3334 static void default_find_bmc(void)
3336 struct smi_info *info;
3339 for (i = 0; ; i++) {
3340 if (!ipmi_defaults[i].port)
3343 if (check_legacy_ioport(ipmi_defaults[i].port))
3346 info = smi_info_alloc();
3350 info->addr_source = SI_DEFAULT;
3352 info->si_type = ipmi_defaults[i].type;
3353 info->io_setup = port_setup;
3354 info->io.addr_data = ipmi_defaults[i].port;
3355 info->io.addr_type = IPMI_IO_ADDR_SPACE;
3357 info->io.addr = NULL;
3358 info->io.regspacing = DEFAULT_REGSPACING;
3359 info->io.regsize = DEFAULT_REGSPACING;
3360 info->io.regshift = 0;
3362 if (add_smi(info) == 0) {
3363 if ((try_smi_init(info)) == 0) {
3365 printk(KERN_INFO PFX "Found default %s"
3366 " state machine at %s address 0x%lx\n",
3367 si_to_str[info->si_type],
3368 addr_space_to_str[info->io.addr_type],
3369 info->io.addr_data);
3371 cleanup_one_si(info);
3378 static int is_new_interface(struct smi_info *info)
3382 list_for_each_entry(e, &smi_infos, link) {
3383 if (e->io.addr_type != info->io.addr_type)
3385 if (e->io.addr_data == info->io.addr_data)
3392 static int add_smi(struct smi_info *new_smi)
3396 printk(KERN_INFO PFX "Adding %s-specified %s state machine",
3397 ipmi_addr_src_to_str(new_smi->addr_source),
3398 si_to_str[new_smi->si_type]);
3399 mutex_lock(&smi_infos_lock);
3400 if (!is_new_interface(new_smi)) {
3401 printk(KERN_CONT " duplicate interface\n");
3406 printk(KERN_CONT "\n");
3408 /* So we know not to free it unless we have allocated one. */
3409 new_smi->intf = NULL;
3410 new_smi->si_sm = NULL;
3411 new_smi->handlers = NULL;
3413 list_add_tail(&new_smi->link, &smi_infos);
3416 mutex_unlock(&smi_infos_lock);
3420 static int try_smi_init(struct smi_info *new_smi)
3425 printk(KERN_INFO PFX "Trying %s-specified %s state"
3426 " machine at %s address 0x%lx, slave address 0x%x,"
3428 ipmi_addr_src_to_str(new_smi->addr_source),
3429 si_to_str[new_smi->si_type],
3430 addr_space_to_str[new_smi->io.addr_type],
3431 new_smi->io.addr_data,
3432 new_smi->slave_addr, new_smi->irq);
3434 switch (new_smi->si_type) {
3436 new_smi->handlers = &kcs_smi_handlers;
3440 new_smi->handlers = &smic_smi_handlers;
3444 new_smi->handlers = &bt_smi_handlers;
3448 /* No support for anything else yet. */
3453 /* Allocate the state machine's data and initialize it. */
3454 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
3455 if (!new_smi->si_sm) {
3457 "Could not allocate state machine memory\n");
3461 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
3464 /* Now that we know the I/O size, we can set up the I/O. */
3465 rv = new_smi->io_setup(new_smi);
3467 printk(KERN_ERR PFX "Could not set up I/O space\n");
3471 /* Do low-level detection first. */
3472 if (new_smi->handlers->detect(new_smi->si_sm)) {
3473 if (new_smi->addr_source)
3474 printk(KERN_INFO PFX "Interface detection failed\n");
3480 * Attempt a get device id command. If it fails, we probably
3481 * don't have a BMC here.
3483 rv = try_get_dev_id(new_smi);
3485 if (new_smi->addr_source)
3486 printk(KERN_INFO PFX "There appears to be no BMC"
3487 " at this location\n");
3491 check_clr_rcv_irq(new_smi);
3493 setup_oem_data_handler(new_smi);
3494 setup_xaction_handlers(new_smi);
3496 new_smi->waiting_msg = NULL;
3497 new_smi->curr_msg = NULL;
3498 atomic_set(&new_smi->req_events, 0);
3499 new_smi->run_to_completion = false;
3500 for (i = 0; i < SI_NUM_STATS; i++)
3501 atomic_set(&new_smi->stats[i], 0);
3503 new_smi->interrupt_disabled = true;
3504 atomic_set(&new_smi->need_watch, 0);
3505 new_smi->intf_num = smi_num;
3508 rv = try_enable_event_buffer(new_smi);
3510 new_smi->has_event_buffer = true;
3513 * Start clearing the flags before we enable interrupts or the
3514 * timer to avoid racing with the timer.
3516 start_clear_flags(new_smi);
3519 * IRQ is defined to be set when non-zero. req_events will
3520 * cause a global flags check that will enable interrupts.
3523 new_smi->interrupt_disabled = false;
3524 atomic_set(&new_smi->req_events, 1);
3527 if (!new_smi->dev) {
3529 * If we don't already have a device from something
3530 * else (like PCI), then register a new one.
3532 new_smi->pdev = platform_device_alloc("ipmi_si",
3534 if (!new_smi->pdev) {
3536 "Unable to allocate platform device\n");
3539 new_smi->dev = &new_smi->pdev->dev;
3540 new_smi->dev->driver = &ipmi_driver.driver;
3542 rv = platform_device_add(new_smi->pdev);
3545 "Unable to register system interface device:"
3550 new_smi->dev_registered = true;
3553 rv = ipmi_register_smi(&handlers,
3555 &new_smi->device_id,
3557 new_smi->slave_addr);
3559 dev_err(new_smi->dev, "Unable to register device: error %d\n",
3561 goto out_err_stop_timer;
3564 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
3568 dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
3569 goto out_err_stop_timer;
3572 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
3573 &smi_si_stats_proc_ops,
3576 dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
3577 goto out_err_stop_timer;
3580 rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
3581 &smi_params_proc_ops,
3584 dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
3585 goto out_err_stop_timer;
3588 dev_info(new_smi->dev, "IPMI %s interface initialized\n",
3589 si_to_str[new_smi->si_type]);
3594 wait_for_timer_and_thread(new_smi);
3597 new_smi->interrupt_disabled = true;
3599 if (new_smi->intf) {
3600 ipmi_smi_t intf = new_smi->intf;
3601 new_smi->intf = NULL;
3602 ipmi_unregister_smi(intf);
3605 if (new_smi->irq_cleanup) {
3606 new_smi->irq_cleanup(new_smi);
3607 new_smi->irq_cleanup = NULL;
3611 * Wait until we know that we are out of any interrupt
3612 * handlers might have been running before we freed the
3615 synchronize_sched();
3617 if (new_smi->si_sm) {
3618 if (new_smi->handlers)
3619 new_smi->handlers->cleanup(new_smi->si_sm);
3620 kfree(new_smi->si_sm);
3621 new_smi->si_sm = NULL;
3623 if (new_smi->addr_source_cleanup) {
3624 new_smi->addr_source_cleanup(new_smi);
3625 new_smi->addr_source_cleanup = NULL;
3627 if (new_smi->io_cleanup) {
3628 new_smi->io_cleanup(new_smi);
3629 new_smi->io_cleanup = NULL;
3632 if (new_smi->dev_registered) {
3633 platform_device_unregister(new_smi->pdev);
3634 new_smi->dev_registered = false;
3640 static int init_ipmi_si(void)
3646 enum ipmi_addr_src type = SI_INVALID;
3652 if (si_tryplatform) {
3653 rv = platform_driver_register(&ipmi_driver);
3655 printk(KERN_ERR PFX "Unable to register "
3656 "driver: %d\n", rv);
3661 /* Parse out the si_type string into its components. */
3664 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
3666 str = strchr(str, ',');
3676 printk(KERN_INFO "IPMI System Interface driver.\n");
3678 /* If the user gave us a device, they presumably want us to use it */
3679 if (!hardcode_find_bmc())
3684 rv = pci_register_driver(&ipmi_pci_driver);
3686 printk(KERN_ERR PFX "Unable to register "
3687 "PCI driver: %d\n", rv);
3689 pci_registered = true;
3695 pnp_register_driver(&ipmi_pnp_driver);
3696 pnp_registered = true;
3710 #ifdef CONFIG_PARISC
3711 register_parisc_driver(&ipmi_parisc_driver);
3712 parisc_registered = true;
3713 /* poking PC IO addresses will crash machine, don't do it */
3717 /* We prefer devices with interrupts, but in the case of a machine
3718 with multiple BMCs we assume that there will be several instances
3719 of a given type so if we succeed in registering a type then also
3720 try to register everything else of the same type */
3722 mutex_lock(&smi_infos_lock);
3723 list_for_each_entry(e, &smi_infos, link) {
3724 /* Try to register a device if it has an IRQ and we either
3725 haven't successfully registered a device yet or this
3726 device has the same type as one we successfully registered */
3727 if (e->irq && (!type || e->addr_source == type)) {
3728 if (!try_smi_init(e)) {
3729 type = e->addr_source;
3734 /* type will only have been set if we successfully registered an si */
3736 mutex_unlock(&smi_infos_lock);
3740 /* Fall back to the preferred device */
3742 list_for_each_entry(e, &smi_infos, link) {
3743 if (!e->irq && (!type || e->addr_source == type)) {
3744 if (!try_smi_init(e)) {
3745 type = e->addr_source;
3749 mutex_unlock(&smi_infos_lock);
3754 if (si_trydefaults) {
3755 mutex_lock(&smi_infos_lock);
3756 if (list_empty(&smi_infos)) {
3757 /* No BMC was found, try defaults. */
3758 mutex_unlock(&smi_infos_lock);
3761 mutex_unlock(&smi_infos_lock);
3764 mutex_lock(&smi_infos_lock);
3765 if (unload_when_empty && list_empty(&smi_infos)) {
3766 mutex_unlock(&smi_infos_lock);
3768 printk(KERN_WARNING PFX
3769 "Unable to find any System Interface(s)\n");
3772 mutex_unlock(&smi_infos_lock);
3776 module_init(init_ipmi_si);
3778 static void cleanup_one_si(struct smi_info *to_clean)
3785 if (to_clean->intf) {
3786 ipmi_smi_t intf = to_clean->intf;
3788 to_clean->intf = NULL;
3789 rv = ipmi_unregister_smi(intf);
3791 pr_err(PFX "Unable to unregister device: errno=%d\n",
3797 dev_set_drvdata(to_clean->dev, NULL);
3799 list_del(&to_clean->link);
3802 * Make sure that interrupts, the timer and the thread are
3803 * stopped and will not run again.
3805 if (to_clean->irq_cleanup)
3806 to_clean->irq_cleanup(to_clean);
3807 wait_for_timer_and_thread(to_clean);
3810 * Timeouts are stopped, now make sure the interrupts are off
3811 * in the BMC. Note that timers and CPU interrupts are off,
3812 * so no need for locks.
3814 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3816 schedule_timeout_uninterruptible(1);
3818 disable_si_irq(to_clean);
3819 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3821 schedule_timeout_uninterruptible(1);
3824 if (to_clean->handlers)
3825 to_clean->handlers->cleanup(to_clean->si_sm);
3827 kfree(to_clean->si_sm);
3829 if (to_clean->addr_source_cleanup)
3830 to_clean->addr_source_cleanup(to_clean);
3831 if (to_clean->io_cleanup)
3832 to_clean->io_cleanup(to_clean);
3834 if (to_clean->dev_registered)
3835 platform_device_unregister(to_clean->pdev);
3840 static void cleanup_ipmi_si(void)
3842 struct smi_info *e, *tmp_e;
3849 pci_unregister_driver(&ipmi_pci_driver);
3853 pnp_unregister_driver(&ipmi_pnp_driver);
3855 #ifdef CONFIG_PARISC
3856 if (parisc_registered)
3857 unregister_parisc_driver(&ipmi_parisc_driver);
3860 platform_driver_unregister(&ipmi_driver);
3862 mutex_lock(&smi_infos_lock);
3863 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
3865 mutex_unlock(&smi_infos_lock);
3867 module_exit(cleanup_ipmi_si);
3869 MODULE_LICENSE("GPL");
3870 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
3871 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT"
3872 " system interfaces.");