1 // SPDX-License-Identifier: GPL-2.0+
5 * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
8 * Author: MontaVista Software, Inc.
9 * Corey Minyard <minyard@mvista.com>
12 * Copyright 2002 MontaVista Software Inc.
13 * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
17 * This file holds the "policy" for the interface to the SMI state
18 * machine. It does the configuration, handles timers and interrupts,
19 * and drives the real SMI state machine.
22 #define pr_fmt(fmt) "ipmi_si: " fmt
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/sched.h>
27 #include <linux/seq_file.h>
28 #include <linux/timer.h>
29 #include <linux/errno.h>
30 #include <linux/spinlock.h>
31 #include <linux/slab.h>
32 #include <linux/delay.h>
33 #include <linux/list.h>
34 #include <linux/notifier.h>
35 #include <linux/mutex.h>
36 #include <linux/kthread.h>
38 #include <linux/interrupt.h>
39 #include <linux/rcupdate.h>
40 #include <linux/ipmi.h>
41 #include <linux/ipmi_smi.h>
43 #include <linux/string.h>
44 #include <linux/ctype.h>
46 /* Measure times between events in the driver. */
49 /* Call every 10 ms. */
50 #define SI_TIMEOUT_TIME_USEC 10000
51 #define SI_USEC_PER_JIFFY (1000000/HZ)
52 #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
53 #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
64 /* FIXME - add watchdog stuff. */
67 /* Some BT-specific defines we need here. */
68 #define IPMI_BT_INTMASK_REG 2
69 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
70 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
72 static const char * const si_to_str[] = { "invalid", "kcs", "smic", "bt" };
74 static int initialized;
77 * Indexes into stats[] in smi_info below.
79 enum si_stat_indexes {
81 * Number of times the driver requested a timer while an operation
84 SI_STAT_short_timeouts = 0,
87 * Number of times the driver requested a timer while nothing was in
90 SI_STAT_long_timeouts,
92 /* Number of times the interface was idle while being polled. */
95 /* Number of interrupts the driver handled. */
98 /* Number of time the driver got an ATTN from the hardware. */
101 /* Number of times the driver requested flags from the hardware. */
102 SI_STAT_flag_fetches,
104 /* Number of times the hardware didn't follow the state machine. */
107 /* Number of completed messages. */
108 SI_STAT_complete_transactions,
110 /* Number of IPMI events received from the hardware. */
113 /* Number of watchdog pretimeouts. */
114 SI_STAT_watchdog_pretimeouts,
116 /* Number of asynchronous messages received. */
117 SI_STAT_incoming_messages,
120 /* This *must* remain last, add new values above this. */
126 struct ipmi_smi *intf;
127 struct si_sm_data *si_sm;
128 const struct si_sm_handlers *handlers;
130 struct ipmi_smi_msg *waiting_msg;
131 struct ipmi_smi_msg *curr_msg;
132 enum si_intf_state si_state;
135 * Used to handle the various types of I/O that can occur with
141 * Per-OEM handler, called from handle_flags(). Returns 1
142 * when handle_flags() needs to be re-run or 0 indicating it
143 * set si_state itself.
145 int (*oem_data_avail_handler)(struct smi_info *smi_info);
148 * Flags from the last GET_MSG_FLAGS command, used when an ATTN
149 * is set to hold the flags until we are done handling everything
152 #define RECEIVE_MSG_AVAIL 0x01
153 #define EVENT_MSG_BUFFER_FULL 0x02
154 #define WDT_PRE_TIMEOUT_INT 0x08
155 #define OEM0_DATA_AVAIL 0x20
156 #define OEM1_DATA_AVAIL 0x40
157 #define OEM2_DATA_AVAIL 0x80
158 #define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
161 unsigned char msg_flags;
163 /* Does the BMC have an event buffer? */
164 bool has_event_buffer;
167 * If set to true, this will request events the next time the
168 * state machine is idle.
173 * If true, run the state machine to completion on every send
174 * call. Generally used after a panic to make sure stuff goes
177 bool run_to_completion;
179 /* The timer for this si. */
180 struct timer_list si_timer;
182 /* This flag is set, if the timer can be set */
183 bool timer_can_start;
185 /* This flag is set, if the timer is running (timer_pending() isn't enough) */
188 /* The time (in jiffies) the last timeout occurred at. */
189 unsigned long last_timeout_jiffies;
191 /* Are we waiting for the events, pretimeouts, received msgs? */
195 * The driver will disable interrupts when it gets into a
196 * situation where it cannot handle messages due to lack of
197 * memory. Once that situation clears up, it will re-enable
200 bool interrupt_disabled;
203 * Does the BMC support events?
205 bool supports_event_msg_buff;
208 * Can we disable interrupts the global enables receive irq
209 * bit? There are currently two forms of brokenness, some
210 * systems cannot disable the bit (which is technically within
211 * the spec but a bad idea) and some systems have the bit
212 * forced to zero even though interrupts work (which is
213 * clearly outside the spec). The next bool tells which form
214 * of brokenness is present.
216 bool cannot_disable_irq;
219 * Some systems are broken and cannot set the irq enable
220 * bit, even if they support interrupts.
222 bool irq_enable_broken;
225 * Did we get an attention that we did not handle?
229 /* From the get device id response... */
230 struct ipmi_device_id device_id;
232 /* Default driver model device. */
233 struct platform_device *pdev;
235 /* Have we added the device group to the device? */
236 bool dev_group_added;
238 /* Have we added the platform device? */
239 bool pdev_registered;
241 /* Counters and things for the proc filesystem. */
242 atomic_t stats[SI_NUM_STATS];
244 struct task_struct *thread;
246 struct list_head link;
249 #define smi_inc_stat(smi, stat) \
250 atomic_inc(&(smi)->stats[SI_STAT_ ## stat])
251 #define smi_get_stat(smi, stat) \
252 ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat]))
254 #define IPMI_MAX_INTFS 4
255 static int force_kipmid[IPMI_MAX_INTFS];
256 static int num_force_kipmid;
258 static unsigned int kipmid_max_busy_us[IPMI_MAX_INTFS];
259 static int num_max_busy_us;
261 static bool unload_when_empty = true;
263 static int try_smi_init(struct smi_info *smi);
264 static void cleanup_one_si(struct smi_info *smi_info);
265 static void cleanup_ipmi_si(void);
268 void debug_timestamp(char *msg)
273 pr_debug("**%s: %lld.%9.9ld\n", msg, (long long) t.tv_sec, t.tv_nsec);
276 #define debug_timestamp(x)
279 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
280 static int register_xaction_notifier(struct notifier_block *nb)
282 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
285 static void deliver_recv_msg(struct smi_info *smi_info,
286 struct ipmi_smi_msg *msg)
288 /* Deliver the message to the upper layer. */
289 ipmi_smi_msg_received(smi_info->intf, msg);
292 static void return_hosed_msg(struct smi_info *smi_info, int cCode)
294 struct ipmi_smi_msg *msg = smi_info->curr_msg;
296 if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
297 cCode = IPMI_ERR_UNSPECIFIED;
298 /* else use it as is */
300 /* Make it a response */
301 msg->rsp[0] = msg->data[0] | 4;
302 msg->rsp[1] = msg->data[1];
306 smi_info->curr_msg = NULL;
307 deliver_recv_msg(smi_info, msg);
310 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
314 if (!smi_info->waiting_msg) {
315 smi_info->curr_msg = NULL;
320 smi_info->curr_msg = smi_info->waiting_msg;
321 smi_info->waiting_msg = NULL;
322 debug_timestamp("Start2");
323 err = atomic_notifier_call_chain(&xaction_notifier_list,
325 if (err & NOTIFY_STOP_MASK) {
326 rv = SI_SM_CALL_WITHOUT_DELAY;
329 err = smi_info->handlers->start_transaction(
331 smi_info->curr_msg->data,
332 smi_info->curr_msg->data_size);
334 return_hosed_msg(smi_info, err);
336 rv = SI_SM_CALL_WITHOUT_DELAY;
342 static void smi_mod_timer(struct smi_info *smi_info, unsigned long new_val)
344 if (!smi_info->timer_can_start)
346 smi_info->last_timeout_jiffies = jiffies;
347 mod_timer(&smi_info->si_timer, new_val);
348 smi_info->timer_running = true;
352 * Start a new message and (re)start the timer and thread.
354 static void start_new_msg(struct smi_info *smi_info, unsigned char *msg,
357 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
359 if (smi_info->thread)
360 wake_up_process(smi_info->thread);
362 smi_info->handlers->start_transaction(smi_info->si_sm, msg, size);
365 static void start_check_enables(struct smi_info *smi_info)
367 unsigned char msg[2];
369 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
370 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
372 start_new_msg(smi_info, msg, 2);
373 smi_info->si_state = SI_CHECKING_ENABLES;
376 static void start_clear_flags(struct smi_info *smi_info)
378 unsigned char msg[3];
380 /* Make sure the watchdog pre-timeout flag is not set at startup. */
381 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
382 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
383 msg[2] = WDT_PRE_TIMEOUT_INT;
385 start_new_msg(smi_info, msg, 3);
386 smi_info->si_state = SI_CLEARING_FLAGS;
389 static void start_getting_msg_queue(struct smi_info *smi_info)
391 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
392 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
393 smi_info->curr_msg->data_size = 2;
395 start_new_msg(smi_info, smi_info->curr_msg->data,
396 smi_info->curr_msg->data_size);
397 smi_info->si_state = SI_GETTING_MESSAGES;
400 static void start_getting_events(struct smi_info *smi_info)
402 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
403 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
404 smi_info->curr_msg->data_size = 2;
406 start_new_msg(smi_info, smi_info->curr_msg->data,
407 smi_info->curr_msg->data_size);
408 smi_info->si_state = SI_GETTING_EVENTS;
412 * When we have a situtaion where we run out of memory and cannot
413 * allocate messages, we just leave them in the BMC and run the system
414 * polled until we can allocate some memory. Once we have some
415 * memory, we will re-enable the interrupt.
417 * Note that we cannot just use disable_irq(), since the interrupt may
420 static inline bool disable_si_irq(struct smi_info *smi_info)
422 if ((smi_info->io.irq) && (!smi_info->interrupt_disabled)) {
423 smi_info->interrupt_disabled = true;
424 start_check_enables(smi_info);
430 static inline bool enable_si_irq(struct smi_info *smi_info)
432 if ((smi_info->io.irq) && (smi_info->interrupt_disabled)) {
433 smi_info->interrupt_disabled = false;
434 start_check_enables(smi_info);
441 * Allocate a message. If unable to allocate, start the interrupt
442 * disable process and return NULL. If able to allocate but
443 * interrupts are disabled, free the message and return NULL after
444 * starting the interrupt enable process.
446 static struct ipmi_smi_msg *alloc_msg_handle_irq(struct smi_info *smi_info)
448 struct ipmi_smi_msg *msg;
450 msg = ipmi_alloc_smi_msg();
452 if (!disable_si_irq(smi_info))
453 smi_info->si_state = SI_NORMAL;
454 } else if (enable_si_irq(smi_info)) {
455 ipmi_free_smi_msg(msg);
461 static void handle_flags(struct smi_info *smi_info)
464 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
465 /* Watchdog pre-timeout */
466 smi_inc_stat(smi_info, watchdog_pretimeouts);
468 start_clear_flags(smi_info);
469 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
470 ipmi_smi_watchdog_pretimeout(smi_info->intf);
471 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
472 /* Messages available. */
473 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
474 if (!smi_info->curr_msg)
477 start_getting_msg_queue(smi_info);
478 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
479 /* Events available. */
480 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
481 if (!smi_info->curr_msg)
484 start_getting_events(smi_info);
485 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
486 smi_info->oem_data_avail_handler) {
487 if (smi_info->oem_data_avail_handler(smi_info))
490 smi_info->si_state = SI_NORMAL;
494 * Global enables we care about.
496 #define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \
497 IPMI_BMC_EVT_MSG_INTR)
499 static u8 current_global_enables(struct smi_info *smi_info, u8 base,
504 if (smi_info->supports_event_msg_buff)
505 enables |= IPMI_BMC_EVT_MSG_BUFF;
507 if (((smi_info->io.irq && !smi_info->interrupt_disabled) ||
508 smi_info->cannot_disable_irq) &&
509 !smi_info->irq_enable_broken)
510 enables |= IPMI_BMC_RCV_MSG_INTR;
512 if (smi_info->supports_event_msg_buff &&
513 smi_info->io.irq && !smi_info->interrupt_disabled &&
514 !smi_info->irq_enable_broken)
515 enables |= IPMI_BMC_EVT_MSG_INTR;
517 *irq_on = enables & (IPMI_BMC_EVT_MSG_INTR | IPMI_BMC_RCV_MSG_INTR);
522 static void check_bt_irq(struct smi_info *smi_info, bool irq_on)
524 u8 irqstate = smi_info->io.inputb(&smi_info->io, IPMI_BT_INTMASK_REG);
526 irqstate &= IPMI_BT_INTMASK_ENABLE_IRQ_BIT;
528 if ((bool)irqstate == irq_on)
532 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
533 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
535 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG, 0);
538 static void handle_transaction_done(struct smi_info *smi_info)
540 struct ipmi_smi_msg *msg;
542 debug_timestamp("Done");
543 switch (smi_info->si_state) {
545 if (!smi_info->curr_msg)
548 smi_info->curr_msg->rsp_size
549 = smi_info->handlers->get_result(
551 smi_info->curr_msg->rsp,
552 IPMI_MAX_MSG_LENGTH);
555 * Do this here becase deliver_recv_msg() releases the
556 * lock, and a new message can be put in during the
557 * time the lock is released.
559 msg = smi_info->curr_msg;
560 smi_info->curr_msg = NULL;
561 deliver_recv_msg(smi_info, msg);
564 case SI_GETTING_FLAGS:
566 unsigned char msg[4];
569 /* We got the flags from the SMI, now handle them. */
570 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
572 /* Error fetching flags, just give up for now. */
573 smi_info->si_state = SI_NORMAL;
574 } else if (len < 4) {
576 * Hmm, no flags. That's technically illegal, but
577 * don't use uninitialized data.
579 smi_info->si_state = SI_NORMAL;
581 smi_info->msg_flags = msg[3];
582 handle_flags(smi_info);
587 case SI_CLEARING_FLAGS:
589 unsigned char msg[3];
591 /* We cleared the flags. */
592 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
594 /* Error clearing flags */
595 dev_warn(smi_info->io.dev,
596 "Error clearing flags: %2.2x\n", msg[2]);
598 smi_info->si_state = SI_NORMAL;
602 case SI_GETTING_EVENTS:
604 smi_info->curr_msg->rsp_size
605 = smi_info->handlers->get_result(
607 smi_info->curr_msg->rsp,
608 IPMI_MAX_MSG_LENGTH);
611 * Do this here becase deliver_recv_msg() releases the
612 * lock, and a new message can be put in during the
613 * time the lock is released.
615 msg = smi_info->curr_msg;
616 smi_info->curr_msg = NULL;
617 if (msg->rsp[2] != 0) {
618 /* Error getting event, probably done. */
621 /* Take off the event flag. */
622 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
623 handle_flags(smi_info);
625 smi_inc_stat(smi_info, events);
628 * Do this before we deliver the message
629 * because delivering the message releases the
630 * lock and something else can mess with the
633 handle_flags(smi_info);
635 deliver_recv_msg(smi_info, msg);
640 case SI_GETTING_MESSAGES:
642 smi_info->curr_msg->rsp_size
643 = smi_info->handlers->get_result(
645 smi_info->curr_msg->rsp,
646 IPMI_MAX_MSG_LENGTH);
649 * Do this here becase deliver_recv_msg() releases the
650 * lock, and a new message can be put in during the
651 * time the lock is released.
653 msg = smi_info->curr_msg;
654 smi_info->curr_msg = NULL;
655 if (msg->rsp[2] != 0) {
656 /* Error getting event, probably done. */
659 /* Take off the msg flag. */
660 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
661 handle_flags(smi_info);
663 smi_inc_stat(smi_info, incoming_messages);
666 * Do this before we deliver the message
667 * because delivering the message releases the
668 * lock and something else can mess with the
671 handle_flags(smi_info);
673 deliver_recv_msg(smi_info, msg);
678 case SI_CHECKING_ENABLES:
680 unsigned char msg[4];
684 /* We got the flags from the SMI, now handle them. */
685 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
687 dev_warn(smi_info->io.dev,
688 "Couldn't get irq info: %x.\n", msg[2]);
689 dev_warn(smi_info->io.dev,
690 "Maybe ok, but ipmi might run very slowly.\n");
691 smi_info->si_state = SI_NORMAL;
694 enables = current_global_enables(smi_info, 0, &irq_on);
695 if (smi_info->io.si_type == SI_BT)
696 /* BT has its own interrupt enable bit. */
697 check_bt_irq(smi_info, irq_on);
698 if (enables != (msg[3] & GLOBAL_ENABLES_MASK)) {
699 /* Enables are not correct, fix them. */
700 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
701 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
702 msg[2] = enables | (msg[3] & ~GLOBAL_ENABLES_MASK);
703 smi_info->handlers->start_transaction(
704 smi_info->si_sm, msg, 3);
705 smi_info->si_state = SI_SETTING_ENABLES;
706 } else if (smi_info->supports_event_msg_buff) {
707 smi_info->curr_msg = ipmi_alloc_smi_msg();
708 if (!smi_info->curr_msg) {
709 smi_info->si_state = SI_NORMAL;
712 start_getting_events(smi_info);
714 smi_info->si_state = SI_NORMAL;
719 case SI_SETTING_ENABLES:
721 unsigned char msg[4];
723 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
725 dev_warn(smi_info->io.dev,
726 "Could not set the global enables: 0x%x.\n",
729 if (smi_info->supports_event_msg_buff) {
730 smi_info->curr_msg = ipmi_alloc_smi_msg();
731 if (!smi_info->curr_msg) {
732 smi_info->si_state = SI_NORMAL;
735 start_getting_events(smi_info);
737 smi_info->si_state = SI_NORMAL;
745 * Called on timeouts and events. Timeouts should pass the elapsed
746 * time, interrupts should pass in zero. Must be called with
747 * si_lock held and interrupts disabled.
749 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
752 enum si_sm_result si_sm_result;
756 * There used to be a loop here that waited a little while
757 * (around 25us) before giving up. That turned out to be
758 * pointless, the minimum delays I was seeing were in the 300us
759 * range, which is far too long to wait in an interrupt. So
760 * we just run until the state machine tells us something
761 * happened or it needs a delay.
763 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
765 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
766 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
768 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
769 smi_inc_stat(smi_info, complete_transactions);
771 handle_transaction_done(smi_info);
773 } else if (si_sm_result == SI_SM_HOSED) {
774 smi_inc_stat(smi_info, hosed_count);
777 * Do the before return_hosed_msg, because that
780 smi_info->si_state = SI_NORMAL;
781 if (smi_info->curr_msg != NULL) {
783 * If we were handling a user message, format
784 * a response to send to the upper layer to
785 * tell it about the error.
787 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
793 * We prefer handling attn over new messages. But don't do
794 * this if there is not yet an upper layer to handle anything.
796 if (si_sm_result == SI_SM_ATTN || smi_info->got_attn) {
797 unsigned char msg[2];
799 if (smi_info->si_state != SI_NORMAL) {
801 * We got an ATTN, but we are doing something else.
802 * Handle the ATTN later.
804 smi_info->got_attn = true;
806 smi_info->got_attn = false;
807 smi_inc_stat(smi_info, attentions);
810 * Got a attn, send down a get message flags to see
811 * what's causing it. It would be better to handle
812 * this in the upper layer, but due to the way
813 * interrupts work with the SMI, that's not really
816 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
817 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
819 start_new_msg(smi_info, msg, 2);
820 smi_info->si_state = SI_GETTING_FLAGS;
825 /* If we are currently idle, try to start the next message. */
826 if (si_sm_result == SI_SM_IDLE) {
827 smi_inc_stat(smi_info, idles);
829 si_sm_result = start_next_msg(smi_info);
830 if (si_sm_result != SI_SM_IDLE)
834 if ((si_sm_result == SI_SM_IDLE)
835 && (atomic_read(&smi_info->req_events))) {
837 * We are idle and the upper layer requested that I fetch
840 atomic_set(&smi_info->req_events, 0);
843 * Take this opportunity to check the interrupt and
844 * message enable state for the BMC. The BMC can be
845 * asynchronously reset, and may thus get interrupts
846 * disable and messages disabled.
848 if (smi_info->supports_event_msg_buff || smi_info->io.irq) {
849 start_check_enables(smi_info);
851 smi_info->curr_msg = alloc_msg_handle_irq(smi_info);
852 if (!smi_info->curr_msg)
855 start_getting_events(smi_info);
860 if (si_sm_result == SI_SM_IDLE && smi_info->timer_running) {
861 /* Ok it if fails, the timer will just go off. */
862 if (del_timer(&smi_info->si_timer))
863 smi_info->timer_running = false;
870 static void check_start_timer_thread(struct smi_info *smi_info)
872 if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) {
873 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
875 if (smi_info->thread)
876 wake_up_process(smi_info->thread);
878 start_next_msg(smi_info);
879 smi_event_handler(smi_info, 0);
883 static void flush_messages(void *send_info)
885 struct smi_info *smi_info = send_info;
886 enum si_sm_result result;
889 * Currently, this function is called only in run-to-completion
890 * mode. This means we are single-threaded, no need for locks.
892 result = smi_event_handler(smi_info, 0);
893 while (result != SI_SM_IDLE) {
894 udelay(SI_SHORT_TIMEOUT_USEC);
895 result = smi_event_handler(smi_info, SI_SHORT_TIMEOUT_USEC);
899 static void sender(void *send_info,
900 struct ipmi_smi_msg *msg)
902 struct smi_info *smi_info = send_info;
905 debug_timestamp("Enqueue");
907 if (smi_info->run_to_completion) {
909 * If we are running to completion, start it. Upper
910 * layer will call flush_messages to clear it out.
912 smi_info->waiting_msg = msg;
916 spin_lock_irqsave(&smi_info->si_lock, flags);
918 * The following two lines don't need to be under the lock for
919 * the lock's sake, but they do need SMP memory barriers to
920 * avoid getting things out of order. We are already claiming
921 * the lock, anyway, so just do it under the lock to avoid the
924 BUG_ON(smi_info->waiting_msg);
925 smi_info->waiting_msg = msg;
926 check_start_timer_thread(smi_info);
927 spin_unlock_irqrestore(&smi_info->si_lock, flags);
930 static void set_run_to_completion(void *send_info, bool i_run_to_completion)
932 struct smi_info *smi_info = send_info;
934 smi_info->run_to_completion = i_run_to_completion;
935 if (i_run_to_completion)
936 flush_messages(smi_info);
940 * Use -1 in the nsec value of the busy waiting timespec to tell that
941 * we are spinning in kipmid looking for something and not delaying
944 static inline void ipmi_si_set_not_busy(struct timespec64 *ts)
948 static inline int ipmi_si_is_busy(struct timespec64 *ts)
950 return ts->tv_nsec != -1;
953 static inline int ipmi_thread_busy_wait(enum si_sm_result smi_result,
954 const struct smi_info *smi_info,
955 struct timespec64 *busy_until)
957 unsigned int max_busy_us = 0;
959 if (smi_info->si_num < num_max_busy_us)
960 max_busy_us = kipmid_max_busy_us[smi_info->si_num];
961 if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
962 ipmi_si_set_not_busy(busy_until);
963 else if (!ipmi_si_is_busy(busy_until)) {
964 ktime_get_ts64(busy_until);
965 timespec64_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
967 struct timespec64 now;
969 ktime_get_ts64(&now);
970 if (unlikely(timespec64_compare(&now, busy_until) > 0)) {
971 ipmi_si_set_not_busy(busy_until);
980 * A busy-waiting loop for speeding up IPMI operation.
982 * Lousy hardware makes this hard. This is only enabled for systems
983 * that are not BT and do not have interrupts. It starts spinning
984 * when an operation is complete or until max_busy tells it to stop
985 * (if that is enabled). See the paragraph on kimid_max_busy_us in
986 * Documentation/IPMI.txt for details.
988 static int ipmi_thread(void *data)
990 struct smi_info *smi_info = data;
992 enum si_sm_result smi_result;
993 struct timespec64 busy_until;
995 ipmi_si_set_not_busy(&busy_until);
996 set_user_nice(current, MAX_NICE);
997 while (!kthread_should_stop()) {
1000 spin_lock_irqsave(&(smi_info->si_lock), flags);
1001 smi_result = smi_event_handler(smi_info, 0);
1004 * If the driver is doing something, there is a possible
1005 * race with the timer. If the timer handler see idle,
1006 * and the thread here sees something else, the timer
1007 * handler won't restart the timer even though it is
1008 * required. So start it here if necessary.
1010 if (smi_result != SI_SM_IDLE && !smi_info->timer_running)
1011 smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
1013 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1014 busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
1016 if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1018 else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait)
1020 else if (smi_result == SI_SM_IDLE) {
1021 if (atomic_read(&smi_info->need_watch)) {
1022 schedule_timeout_interruptible(100);
1024 /* Wait to be woken up when we are needed. */
1025 __set_current_state(TASK_INTERRUPTIBLE);
1029 schedule_timeout_interruptible(1);
1035 static void poll(void *send_info)
1037 struct smi_info *smi_info = send_info;
1038 unsigned long flags = 0;
1039 bool run_to_completion = smi_info->run_to_completion;
1042 * Make sure there is some delay in the poll loop so we can
1043 * drive time forward and timeout things.
1046 if (!run_to_completion)
1047 spin_lock_irqsave(&smi_info->si_lock, flags);
1048 smi_event_handler(smi_info, 10);
1049 if (!run_to_completion)
1050 spin_unlock_irqrestore(&smi_info->si_lock, flags);
1053 static void request_events(void *send_info)
1055 struct smi_info *smi_info = send_info;
1057 if (!smi_info->has_event_buffer)
1060 atomic_set(&smi_info->req_events, 1);
1063 static void set_need_watch(void *send_info, unsigned int watch_mask)
1065 struct smi_info *smi_info = send_info;
1066 unsigned long flags;
1069 enable = !!watch_mask;
1071 atomic_set(&smi_info->need_watch, enable);
1072 spin_lock_irqsave(&smi_info->si_lock, flags);
1073 check_start_timer_thread(smi_info);
1074 spin_unlock_irqrestore(&smi_info->si_lock, flags);
1077 static void smi_timeout(struct timer_list *t)
1079 struct smi_info *smi_info = from_timer(smi_info, t, si_timer);
1080 enum si_sm_result smi_result;
1081 unsigned long flags;
1082 unsigned long jiffies_now;
1086 spin_lock_irqsave(&(smi_info->si_lock), flags);
1087 debug_timestamp("Timer");
1089 jiffies_now = jiffies;
1090 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
1091 * SI_USEC_PER_JIFFY);
1092 smi_result = smi_event_handler(smi_info, time_diff);
1094 if ((smi_info->io.irq) && (!smi_info->interrupt_disabled)) {
1095 /* Running with interrupts, only do long timeouts. */
1096 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1097 smi_inc_stat(smi_info, long_timeouts);
1102 * If the state machine asks for a short delay, then shorten
1103 * the timer timeout.
1105 if (smi_result == SI_SM_CALL_WITH_DELAY) {
1106 smi_inc_stat(smi_info, short_timeouts);
1107 timeout = jiffies + 1;
1109 smi_inc_stat(smi_info, long_timeouts);
1110 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1114 if (smi_result != SI_SM_IDLE)
1115 smi_mod_timer(smi_info, timeout);
1117 smi_info->timer_running = false;
1118 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1121 irqreturn_t ipmi_si_irq_handler(int irq, void *data)
1123 struct smi_info *smi_info = data;
1124 unsigned long flags;
1126 if (smi_info->io.si_type == SI_BT)
1127 /* We need to clear the IRQ flag for the BT interface. */
1128 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
1129 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
1130 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1132 spin_lock_irqsave(&(smi_info->si_lock), flags);
1134 smi_inc_stat(smi_info, interrupts);
1136 debug_timestamp("Interrupt");
1138 smi_event_handler(smi_info, 0);
1139 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1143 static int smi_start_processing(void *send_info,
1144 struct ipmi_smi *intf)
1146 struct smi_info *new_smi = send_info;
1149 new_smi->intf = intf;
1151 /* Set up the timer that drives the interface. */
1152 timer_setup(&new_smi->si_timer, smi_timeout, 0);
1153 new_smi->timer_can_start = true;
1154 smi_mod_timer(new_smi, jiffies + SI_TIMEOUT_JIFFIES);
1156 /* Try to claim any interrupts. */
1157 if (new_smi->io.irq_setup) {
1158 new_smi->io.irq_handler_data = new_smi;
1159 new_smi->io.irq_setup(&new_smi->io);
1163 * Check if the user forcefully enabled the daemon.
1165 if (new_smi->si_num < num_force_kipmid)
1166 enable = force_kipmid[new_smi->si_num];
1168 * The BT interface is efficient enough to not need a thread,
1169 * and there is no need for a thread if we have interrupts.
1171 else if ((new_smi->io.si_type != SI_BT) && (!new_smi->io.irq))
1175 new_smi->thread = kthread_run(ipmi_thread, new_smi,
1176 "kipmi%d", new_smi->si_num);
1177 if (IS_ERR(new_smi->thread)) {
1178 dev_notice(new_smi->io.dev, "Could not start"
1179 " kernel thread due to error %ld, only using"
1180 " timers to drive the interface\n",
1181 PTR_ERR(new_smi->thread));
1182 new_smi->thread = NULL;
1189 static int get_smi_info(void *send_info, struct ipmi_smi_info *data)
1191 struct smi_info *smi = send_info;
1193 data->addr_src = smi->io.addr_source;
1194 data->dev = smi->io.dev;
1195 data->addr_info = smi->io.addr_info;
1196 get_device(smi->io.dev);
1201 static void set_maintenance_mode(void *send_info, bool enable)
1203 struct smi_info *smi_info = send_info;
1206 atomic_set(&smi_info->req_events, 0);
1209 static void shutdown_smi(void *send_info);
1210 static const struct ipmi_smi_handlers handlers = {
1211 .owner = THIS_MODULE,
1212 .start_processing = smi_start_processing,
1213 .shutdown = shutdown_smi,
1214 .get_smi_info = get_smi_info,
1216 .request_events = request_events,
1217 .set_need_watch = set_need_watch,
1218 .set_maintenance_mode = set_maintenance_mode,
1219 .set_run_to_completion = set_run_to_completion,
1220 .flush_messages = flush_messages,
1224 static LIST_HEAD(smi_infos);
1225 static DEFINE_MUTEX(smi_infos_lock);
1226 static int smi_num; /* Used to sequence the SMIs */
1228 static const char * const addr_space_to_str[] = { "i/o", "mem" };
1230 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1231 MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1232 " disabled(0). Normally the IPMI driver auto-detects"
1233 " this, but the value may be overridden by this parm.");
1234 module_param(unload_when_empty, bool, 0);
1235 MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
1236 " specified or found, default is 1. Setting to 0"
1237 " is useful for hot add of devices using hotmod.");
1238 module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
1239 MODULE_PARM_DESC(kipmid_max_busy_us,
1240 "Max time (in microseconds) to busy-wait for IPMI data before"
1241 " sleeping. 0 (default) means to wait forever. Set to 100-500"
1242 " if kipmid is using up a lot of CPU time.");
1244 void ipmi_irq_finish_setup(struct si_sm_io *io)
1246 if (io->si_type == SI_BT)
1247 /* Enable the interrupt in the BT interface. */
1248 io->outputb(io, IPMI_BT_INTMASK_REG,
1249 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1252 void ipmi_irq_start_cleanup(struct si_sm_io *io)
1254 if (io->si_type == SI_BT)
1255 /* Disable the interrupt in the BT interface. */
1256 io->outputb(io, IPMI_BT_INTMASK_REG, 0);
1259 static void std_irq_cleanup(struct si_sm_io *io)
1261 ipmi_irq_start_cleanup(io);
1262 free_irq(io->irq, io->irq_handler_data);
1265 int ipmi_std_irq_setup(struct si_sm_io *io)
1272 rv = request_irq(io->irq,
1273 ipmi_si_irq_handler,
1276 io->irq_handler_data);
1278 dev_warn(io->dev, "%s unable to claim interrupt %d,"
1279 " running polled\n",
1280 DEVICE_NAME, io->irq);
1283 io->irq_cleanup = std_irq_cleanup;
1284 ipmi_irq_finish_setup(io);
1285 dev_info(io->dev, "Using irq %d\n", io->irq);
1291 static int wait_for_msg_done(struct smi_info *smi_info)
1293 enum si_sm_result smi_result;
1295 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1297 if (smi_result == SI_SM_CALL_WITH_DELAY ||
1298 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1299 schedule_timeout_uninterruptible(1);
1300 smi_result = smi_info->handlers->event(
1301 smi_info->si_sm, jiffies_to_usecs(1));
1302 } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
1303 smi_result = smi_info->handlers->event(
1304 smi_info->si_sm, 0);
1308 if (smi_result == SI_SM_HOSED)
1310 * We couldn't get the state machine to run, so whatever's at
1311 * the port is probably not an IPMI SMI interface.
1318 static int try_get_dev_id(struct smi_info *smi_info)
1320 unsigned char msg[2];
1321 unsigned char *resp;
1322 unsigned long resp_len;
1325 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1330 * Do a Get Device ID command, since it comes back with some
1333 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1334 msg[1] = IPMI_GET_DEVICE_ID_CMD;
1335 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1337 rv = wait_for_msg_done(smi_info);
1341 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1342 resp, IPMI_MAX_MSG_LENGTH);
1344 /* Check and record info from the get device id, in case we need it. */
1345 rv = ipmi_demangle_device_id(resp[0] >> 2, resp[1],
1346 resp + 2, resp_len - 2, &smi_info->device_id);
1353 static int get_global_enables(struct smi_info *smi_info, u8 *enables)
1355 unsigned char msg[3];
1356 unsigned char *resp;
1357 unsigned long resp_len;
1360 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1364 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1365 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
1366 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1368 rv = wait_for_msg_done(smi_info);
1370 dev_warn(smi_info->io.dev,
1371 "Error getting response from get global enables command: %d\n",
1376 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1377 resp, IPMI_MAX_MSG_LENGTH);
1380 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1381 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD ||
1383 dev_warn(smi_info->io.dev,
1384 "Invalid return from get global enables command: %ld %x %x %x\n",
1385 resp_len, resp[0], resp[1], resp[2]);
1398 * Returns 1 if it gets an error from the command.
1400 static int set_global_enables(struct smi_info *smi_info, u8 enables)
1402 unsigned char msg[3];
1403 unsigned char *resp;
1404 unsigned long resp_len;
1407 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1411 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1412 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
1414 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
1416 rv = wait_for_msg_done(smi_info);
1418 dev_warn(smi_info->io.dev,
1419 "Error getting response from set global enables command: %d\n",
1424 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1425 resp, IPMI_MAX_MSG_LENGTH);
1428 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1429 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
1430 dev_warn(smi_info->io.dev,
1431 "Invalid return from set global enables command: %ld %x %x\n",
1432 resp_len, resp[0], resp[1]);
1446 * Some BMCs do not support clearing the receive irq bit in the global
1447 * enables (even if they don't support interrupts on the BMC). Check
1448 * for this and handle it properly.
1450 static void check_clr_rcv_irq(struct smi_info *smi_info)
1455 rv = get_global_enables(smi_info, &enables);
1457 if ((enables & IPMI_BMC_RCV_MSG_INTR) == 0)
1458 /* Already clear, should work ok. */
1461 enables &= ~IPMI_BMC_RCV_MSG_INTR;
1462 rv = set_global_enables(smi_info, enables);
1466 dev_err(smi_info->io.dev,
1467 "Cannot check clearing the rcv irq: %d\n", rv);
1473 * An error when setting the event buffer bit means
1474 * clearing the bit is not supported.
1476 dev_warn(smi_info->io.dev,
1477 "The BMC does not support clearing the recv irq bit, compensating, but the BMC needs to be fixed.\n");
1478 smi_info->cannot_disable_irq = true;
1483 * Some BMCs do not support setting the interrupt bits in the global
1484 * enables even if they support interrupts. Clearly bad, but we can
1487 static void check_set_rcv_irq(struct smi_info *smi_info)
1492 if (!smi_info->io.irq)
1495 rv = get_global_enables(smi_info, &enables);
1497 enables |= IPMI_BMC_RCV_MSG_INTR;
1498 rv = set_global_enables(smi_info, enables);
1502 dev_err(smi_info->io.dev,
1503 "Cannot check setting the rcv irq: %d\n", rv);
1509 * An error when setting the event buffer bit means
1510 * setting the bit is not supported.
1512 dev_warn(smi_info->io.dev,
1513 "The BMC does not support setting the recv irq bit, compensating, but the BMC needs to be fixed.\n");
1514 smi_info->cannot_disable_irq = true;
1515 smi_info->irq_enable_broken = true;
1519 static int try_enable_event_buffer(struct smi_info *smi_info)
1521 unsigned char msg[3];
1522 unsigned char *resp;
1523 unsigned long resp_len;
1526 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1530 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1531 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
1532 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1534 rv = wait_for_msg_done(smi_info);
1536 pr_warn("Error getting response from get global enables command, the event buffer is not enabled\n");
1540 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1541 resp, IPMI_MAX_MSG_LENGTH);
1544 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1545 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD ||
1547 pr_warn("Invalid return from get global enables command, cannot enable the event buffer\n");
1552 if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) {
1553 /* buffer is already enabled, nothing to do. */
1554 smi_info->supports_event_msg_buff = true;
1558 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1559 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
1560 msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF;
1561 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
1563 rv = wait_for_msg_done(smi_info);
1565 pr_warn("Error getting response from set global, enables command, the event buffer is not enabled\n");
1569 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1570 resp, IPMI_MAX_MSG_LENGTH);
1573 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
1574 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
1575 pr_warn("Invalid return from get global, enables command, not enable the event buffer\n");
1582 * An error when setting the event buffer bit means
1583 * that the event buffer is not supported.
1587 smi_info->supports_event_msg_buff = true;
1594 #define IPMI_SI_ATTR(name) \
1595 static ssize_t ipmi_##name##_show(struct device *dev, \
1596 struct device_attribute *attr, \
1599 struct smi_info *smi_info = dev_get_drvdata(dev); \
1601 return snprintf(buf, 10, "%u\n", smi_get_stat(smi_info, name)); \
1603 static DEVICE_ATTR(name, S_IRUGO, ipmi_##name##_show, NULL)
1605 static ssize_t ipmi_type_show(struct device *dev,
1606 struct device_attribute *attr,
1609 struct smi_info *smi_info = dev_get_drvdata(dev);
1611 return snprintf(buf, 10, "%s\n", si_to_str[smi_info->io.si_type]);
1613 static DEVICE_ATTR(type, S_IRUGO, ipmi_type_show, NULL);
1615 static ssize_t ipmi_interrupts_enabled_show(struct device *dev,
1616 struct device_attribute *attr,
1619 struct smi_info *smi_info = dev_get_drvdata(dev);
1620 int enabled = smi_info->io.irq && !smi_info->interrupt_disabled;
1622 return snprintf(buf, 10, "%d\n", enabled);
1624 static DEVICE_ATTR(interrupts_enabled, S_IRUGO,
1625 ipmi_interrupts_enabled_show, NULL);
1627 IPMI_SI_ATTR(short_timeouts);
1628 IPMI_SI_ATTR(long_timeouts);
1629 IPMI_SI_ATTR(idles);
1630 IPMI_SI_ATTR(interrupts);
1631 IPMI_SI_ATTR(attentions);
1632 IPMI_SI_ATTR(flag_fetches);
1633 IPMI_SI_ATTR(hosed_count);
1634 IPMI_SI_ATTR(complete_transactions);
1635 IPMI_SI_ATTR(events);
1636 IPMI_SI_ATTR(watchdog_pretimeouts);
1637 IPMI_SI_ATTR(incoming_messages);
1639 static ssize_t ipmi_params_show(struct device *dev,
1640 struct device_attribute *attr,
1643 struct smi_info *smi_info = dev_get_drvdata(dev);
1645 return snprintf(buf, 200,
1646 "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
1647 si_to_str[smi_info->io.si_type],
1648 addr_space_to_str[smi_info->io.addr_space],
1649 smi_info->io.addr_data,
1650 smi_info->io.regspacing,
1651 smi_info->io.regsize,
1652 smi_info->io.regshift,
1654 smi_info->io.slave_addr);
1656 static DEVICE_ATTR(params, S_IRUGO, ipmi_params_show, NULL);
1658 static struct attribute *ipmi_si_dev_attrs[] = {
1659 &dev_attr_type.attr,
1660 &dev_attr_interrupts_enabled.attr,
1661 &dev_attr_short_timeouts.attr,
1662 &dev_attr_long_timeouts.attr,
1663 &dev_attr_idles.attr,
1664 &dev_attr_interrupts.attr,
1665 &dev_attr_attentions.attr,
1666 &dev_attr_flag_fetches.attr,
1667 &dev_attr_hosed_count.attr,
1668 &dev_attr_complete_transactions.attr,
1669 &dev_attr_events.attr,
1670 &dev_attr_watchdog_pretimeouts.attr,
1671 &dev_attr_incoming_messages.attr,
1672 &dev_attr_params.attr,
1676 static const struct attribute_group ipmi_si_dev_attr_group = {
1677 .attrs = ipmi_si_dev_attrs,
1681 * oem_data_avail_to_receive_msg_avail
1682 * @info - smi_info structure with msg_flags set
1684 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
1685 * Returns 1 indicating need to re-run handle_flags().
1687 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
1689 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
1695 * setup_dell_poweredge_oem_data_handler
1696 * @info - smi_info.device_id must be populated
1698 * Systems that match, but have firmware version < 1.40 may assert
1699 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
1700 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
1701 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
1702 * as RECEIVE_MSG_AVAIL instead.
1704 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
1705 * assert the OEM[012] bits, and if it did, the driver would have to
1706 * change to handle that properly, we don't actually check for the
1708 * Device ID = 0x20 BMC on PowerEdge 8G servers
1709 * Device Revision = 0x80
1710 * Firmware Revision1 = 0x01 BMC version 1.40
1711 * Firmware Revision2 = 0x40 BCD encoded
1712 * IPMI Version = 0x51 IPMI 1.5
1713 * Manufacturer ID = A2 02 00 Dell IANA
1715 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
1716 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
1719 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
1720 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
1721 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
1722 #define DELL_IANA_MFR_ID 0x0002a2
1723 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
1725 struct ipmi_device_id *id = &smi_info->device_id;
1726 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
1727 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
1728 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
1729 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
1730 smi_info->oem_data_avail_handler =
1731 oem_data_avail_to_receive_msg_avail;
1732 } else if (ipmi_version_major(id) < 1 ||
1733 (ipmi_version_major(id) == 1 &&
1734 ipmi_version_minor(id) < 5)) {
1735 smi_info->oem_data_avail_handler =
1736 oem_data_avail_to_receive_msg_avail;
1741 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
1742 static void return_hosed_msg_badsize(struct smi_info *smi_info)
1744 struct ipmi_smi_msg *msg = smi_info->curr_msg;
1746 /* Make it a response */
1747 msg->rsp[0] = msg->data[0] | 4;
1748 msg->rsp[1] = msg->data[1];
1749 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
1751 smi_info->curr_msg = NULL;
1752 deliver_recv_msg(smi_info, msg);
1756 * dell_poweredge_bt_xaction_handler
1757 * @info - smi_info.device_id must be populated
1759 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
1760 * not respond to a Get SDR command if the length of the data
1761 * requested is exactly 0x3A, which leads to command timeouts and no
1762 * data returned. This intercepts such commands, and causes userspace
1763 * callers to try again with a different-sized buffer, which succeeds.
1766 #define STORAGE_NETFN 0x0A
1767 #define STORAGE_CMD_GET_SDR 0x23
1768 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
1769 unsigned long unused,
1772 struct smi_info *smi_info = in;
1773 unsigned char *data = smi_info->curr_msg->data;
1774 unsigned int size = smi_info->curr_msg->data_size;
1776 (data[0]>>2) == STORAGE_NETFN &&
1777 data[1] == STORAGE_CMD_GET_SDR &&
1779 return_hosed_msg_badsize(smi_info);
1785 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
1786 .notifier_call = dell_poweredge_bt_xaction_handler,
1790 * setup_dell_poweredge_bt_xaction_handler
1791 * @info - smi_info.device_id must be filled in already
1793 * Fills in smi_info.device_id.start_transaction_pre_hook
1794 * when we know what function to use there.
1797 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
1799 struct ipmi_device_id *id = &smi_info->device_id;
1800 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
1801 smi_info->io.si_type == SI_BT)
1802 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
1806 * setup_oem_data_handler
1807 * @info - smi_info.device_id must be filled in already
1809 * Fills in smi_info.device_id.oem_data_available_handler
1810 * when we know what function to use there.
1813 static void setup_oem_data_handler(struct smi_info *smi_info)
1815 setup_dell_poweredge_oem_data_handler(smi_info);
1818 static void setup_xaction_handlers(struct smi_info *smi_info)
1820 setup_dell_poweredge_bt_xaction_handler(smi_info);
1823 static void check_for_broken_irqs(struct smi_info *smi_info)
1825 check_clr_rcv_irq(smi_info);
1826 check_set_rcv_irq(smi_info);
1829 static inline void stop_timer_and_thread(struct smi_info *smi_info)
1831 if (smi_info->thread != NULL) {
1832 kthread_stop(smi_info->thread);
1833 smi_info->thread = NULL;
1836 smi_info->timer_can_start = false;
1837 if (smi_info->timer_running)
1838 del_timer_sync(&smi_info->si_timer);
1841 static struct smi_info *find_dup_si(struct smi_info *info)
1845 list_for_each_entry(e, &smi_infos, link) {
1846 if (e->io.addr_space != info->io.addr_space)
1848 if (e->io.addr_data == info->io.addr_data) {
1850 * This is a cheap hack, ACPI doesn't have a defined
1851 * slave address but SMBIOS does. Pick it up from
1852 * any source that has it available.
1854 if (info->io.slave_addr && !e->io.slave_addr)
1855 e->io.slave_addr = info->io.slave_addr;
1863 int ipmi_si_add_smi(struct si_sm_io *io)
1866 struct smi_info *new_smi, *dup;
1869 * If the user gave us a hard-coded device at the same
1870 * address, they presumably want us to use it and not what is
1873 if (io->addr_source != SI_HARDCODED &&
1874 ipmi_si_hardcode_match(io->addr_space, io->addr_data)) {
1876 "Hard-coded device at this address already exists");
1880 if (!io->io_setup) {
1881 if (io->addr_space == IPMI_IO_ADDR_SPACE) {
1882 io->io_setup = ipmi_si_port_setup;
1883 } else if (io->addr_space == IPMI_MEM_ADDR_SPACE) {
1884 io->io_setup = ipmi_si_mem_setup;
1890 new_smi = kzalloc(sizeof(*new_smi), GFP_KERNEL);
1893 spin_lock_init(&new_smi->si_lock);
1897 mutex_lock(&smi_infos_lock);
1898 dup = find_dup_si(new_smi);
1900 if (new_smi->io.addr_source == SI_ACPI &&
1901 dup->io.addr_source == SI_SMBIOS) {
1902 /* We prefer ACPI over SMBIOS. */
1903 dev_info(dup->io.dev,
1904 "Removing SMBIOS-specified %s state machine in favor of ACPI\n",
1905 si_to_str[new_smi->io.si_type]);
1906 cleanup_one_si(dup);
1908 dev_info(new_smi->io.dev,
1909 "%s-specified %s state machine: duplicate\n",
1910 ipmi_addr_src_to_str(new_smi->io.addr_source),
1911 si_to_str[new_smi->io.si_type]);
1918 pr_info("Adding %s-specified %s state machine\n",
1919 ipmi_addr_src_to_str(new_smi->io.addr_source),
1920 si_to_str[new_smi->io.si_type]);
1922 list_add_tail(&new_smi->link, &smi_infos);
1925 rv = try_smi_init(new_smi);
1927 mutex_unlock(&smi_infos_lock);
1932 * Try to start up an interface. Must be called with smi_infos_lock
1933 * held, primarily to keep smi_num consistent, we only one to do these
1936 static int try_smi_init(struct smi_info *new_smi)
1940 char *init_name = NULL;
1942 pr_info("Trying %s-specified %s state machine at %s address 0x%lx, slave address 0x%x, irq %d\n",
1943 ipmi_addr_src_to_str(new_smi->io.addr_source),
1944 si_to_str[new_smi->io.si_type],
1945 addr_space_to_str[new_smi->io.addr_space],
1946 new_smi->io.addr_data,
1947 new_smi->io.slave_addr, new_smi->io.irq);
1949 switch (new_smi->io.si_type) {
1951 new_smi->handlers = &kcs_smi_handlers;
1955 new_smi->handlers = &smic_smi_handlers;
1959 new_smi->handlers = &bt_smi_handlers;
1963 /* No support for anything else yet. */
1968 new_smi->si_num = smi_num;
1970 /* Do this early so it's available for logs. */
1971 if (!new_smi->io.dev) {
1972 init_name = kasprintf(GFP_KERNEL, "ipmi_si.%d",
1976 * If we don't already have a device from something
1977 * else (like PCI), then register a new one.
1979 new_smi->pdev = platform_device_alloc("ipmi_si",
1981 if (!new_smi->pdev) {
1982 pr_err("Unable to allocate platform device\n");
1986 new_smi->io.dev = &new_smi->pdev->dev;
1987 new_smi->io.dev->driver = &ipmi_platform_driver.driver;
1988 /* Nulled by device_add() */
1989 new_smi->io.dev->init_name = init_name;
1992 /* Allocate the state machine's data and initialize it. */
1993 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
1994 if (!new_smi->si_sm) {
1998 new_smi->io.io_size = new_smi->handlers->init_data(new_smi->si_sm,
2001 /* Now that we know the I/O size, we can set up the I/O. */
2002 rv = new_smi->io.io_setup(&new_smi->io);
2004 dev_err(new_smi->io.dev, "Could not set up I/O space\n");
2008 /* Do low-level detection first. */
2009 if (new_smi->handlers->detect(new_smi->si_sm)) {
2010 if (new_smi->io.addr_source)
2011 dev_err(new_smi->io.dev,
2012 "Interface detection failed\n");
2018 * Attempt a get device id command. If it fails, we probably
2019 * don't have a BMC here.
2021 rv = try_get_dev_id(new_smi);
2023 if (new_smi->io.addr_source)
2024 dev_err(new_smi->io.dev,
2025 "There appears to be no BMC at this location\n");
2029 setup_oem_data_handler(new_smi);
2030 setup_xaction_handlers(new_smi);
2031 check_for_broken_irqs(new_smi);
2033 new_smi->waiting_msg = NULL;
2034 new_smi->curr_msg = NULL;
2035 atomic_set(&new_smi->req_events, 0);
2036 new_smi->run_to_completion = false;
2037 for (i = 0; i < SI_NUM_STATS; i++)
2038 atomic_set(&new_smi->stats[i], 0);
2040 new_smi->interrupt_disabled = true;
2041 atomic_set(&new_smi->need_watch, 0);
2043 rv = try_enable_event_buffer(new_smi);
2045 new_smi->has_event_buffer = true;
2048 * Start clearing the flags before we enable interrupts or the
2049 * timer to avoid racing with the timer.
2051 start_clear_flags(new_smi);
2054 * IRQ is defined to be set when non-zero. req_events will
2055 * cause a global flags check that will enable interrupts.
2057 if (new_smi->io.irq) {
2058 new_smi->interrupt_disabled = false;
2059 atomic_set(&new_smi->req_events, 1);
2062 if (new_smi->pdev && !new_smi->pdev_registered) {
2063 rv = platform_device_add(new_smi->pdev);
2065 dev_err(new_smi->io.dev,
2066 "Unable to register system interface device: %d\n",
2070 new_smi->pdev_registered = true;
2073 dev_set_drvdata(new_smi->io.dev, new_smi);
2074 rv = device_add_group(new_smi->io.dev, &ipmi_si_dev_attr_group);
2076 dev_err(new_smi->io.dev,
2077 "Unable to add device attributes: error %d\n",
2081 new_smi->dev_group_added = true;
2083 rv = ipmi_register_smi(&handlers,
2086 new_smi->io.slave_addr);
2088 dev_err(new_smi->io.dev,
2089 "Unable to register device: error %d\n",
2094 /* Don't increment till we know we have succeeded. */
2097 dev_info(new_smi->io.dev, "IPMI %s interface initialized\n",
2098 si_to_str[new_smi->io.si_type]);
2100 WARN_ON(new_smi->io.dev->init_name != NULL);
2103 if (rv && new_smi->io.io_cleanup) {
2104 new_smi->io.io_cleanup(&new_smi->io);
2105 new_smi->io.io_cleanup = NULL;
2112 static int __init init_ipmi_si(void)
2115 enum ipmi_addr_src type = SI_INVALID;
2120 ipmi_hardcode_init();
2122 pr_info("IPMI System Interface driver\n");
2124 ipmi_si_platform_init();
2128 ipmi_si_parisc_init();
2130 /* We prefer devices with interrupts, but in the case of a machine
2131 with multiple BMCs we assume that there will be several instances
2132 of a given type so if we succeed in registering a type then also
2133 try to register everything else of the same type */
2134 mutex_lock(&smi_infos_lock);
2135 list_for_each_entry(e, &smi_infos, link) {
2136 /* Try to register a device if it has an IRQ and we either
2137 haven't successfully registered a device yet or this
2138 device has the same type as one we successfully registered */
2139 if (e->io.irq && (!type || e->io.addr_source == type)) {
2140 if (!try_smi_init(e)) {
2141 type = e->io.addr_source;
2146 /* type will only have been set if we successfully registered an si */
2148 goto skip_fallback_noirq;
2150 /* Fall back to the preferred device */
2152 list_for_each_entry(e, &smi_infos, link) {
2153 if (!e->io.irq && (!type || e->io.addr_source == type)) {
2154 if (!try_smi_init(e)) {
2155 type = e->io.addr_source;
2160 skip_fallback_noirq:
2162 mutex_unlock(&smi_infos_lock);
2167 mutex_lock(&smi_infos_lock);
2168 if (unload_when_empty && list_empty(&smi_infos)) {
2169 mutex_unlock(&smi_infos_lock);
2171 pr_warn("Unable to find any System Interface(s)\n");
2174 mutex_unlock(&smi_infos_lock);
2178 module_init(init_ipmi_si);
2180 static void shutdown_smi(void *send_info)
2182 struct smi_info *smi_info = send_info;
2184 if (smi_info->dev_group_added) {
2185 device_remove_group(smi_info->io.dev, &ipmi_si_dev_attr_group);
2186 smi_info->dev_group_added = false;
2188 if (smi_info->io.dev)
2189 dev_set_drvdata(smi_info->io.dev, NULL);
2192 * Make sure that interrupts, the timer and the thread are
2193 * stopped and will not run again.
2195 smi_info->interrupt_disabled = true;
2196 if (smi_info->io.irq_cleanup) {
2197 smi_info->io.irq_cleanup(&smi_info->io);
2198 smi_info->io.irq_cleanup = NULL;
2200 stop_timer_and_thread(smi_info);
2203 * Wait until we know that we are out of any interrupt
2204 * handlers might have been running before we freed the
2210 * Timeouts are stopped, now make sure the interrupts are off
2211 * in the BMC. Note that timers and CPU interrupts are off,
2212 * so no need for locks.
2214 while (smi_info->curr_msg || (smi_info->si_state != SI_NORMAL)) {
2216 schedule_timeout_uninterruptible(1);
2218 if (smi_info->handlers)
2219 disable_si_irq(smi_info);
2220 while (smi_info->curr_msg || (smi_info->si_state != SI_NORMAL)) {
2222 schedule_timeout_uninterruptible(1);
2224 if (smi_info->handlers)
2225 smi_info->handlers->cleanup(smi_info->si_sm);
2227 if (smi_info->io.addr_source_cleanup) {
2228 smi_info->io.addr_source_cleanup(&smi_info->io);
2229 smi_info->io.addr_source_cleanup = NULL;
2231 if (smi_info->io.io_cleanup) {
2232 smi_info->io.io_cleanup(&smi_info->io);
2233 smi_info->io.io_cleanup = NULL;
2236 kfree(smi_info->si_sm);
2237 smi_info->si_sm = NULL;
2239 smi_info->intf = NULL;
2243 * Must be called with smi_infos_lock held, to serialize the
2244 * smi_info->intf check.
2246 static void cleanup_one_si(struct smi_info *smi_info)
2251 list_del(&smi_info->link);
2254 ipmi_unregister_smi(smi_info->intf);
2256 if (smi_info->pdev) {
2257 if (smi_info->pdev_registered)
2258 platform_device_unregister(smi_info->pdev);
2260 platform_device_put(smi_info->pdev);
2266 int ipmi_si_remove_by_dev(struct device *dev)
2271 mutex_lock(&smi_infos_lock);
2272 list_for_each_entry(e, &smi_infos, link) {
2273 if (e->io.dev == dev) {
2279 mutex_unlock(&smi_infos_lock);
2284 void ipmi_si_remove_by_data(int addr_space, enum si_type si_type,
2288 struct smi_info *e, *tmp_e;
2290 mutex_lock(&smi_infos_lock);
2291 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
2292 if (e->io.addr_space != addr_space)
2294 if (e->io.si_type != si_type)
2296 if (e->io.addr_data == addr)
2299 mutex_unlock(&smi_infos_lock);
2302 static void cleanup_ipmi_si(void)
2304 struct smi_info *e, *tmp_e;
2309 ipmi_si_pci_shutdown();
2311 ipmi_si_parisc_shutdown();
2313 ipmi_si_platform_shutdown();
2315 mutex_lock(&smi_infos_lock);
2316 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2318 mutex_unlock(&smi_infos_lock);
2320 ipmi_si_hardcode_exit();
2322 module_exit(cleanup_ipmi_si);
2324 MODULE_ALIAS("platform:dmi-ipmi-si");
2325 MODULE_LICENSE("GPL");
2326 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2327 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT"
2328 " system interfaces.");