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.
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
19 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
20 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
25 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
27 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
28 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 * You should have received a copy of the GNU General Public License along
31 * with this program; if not, write to the Free Software Foundation, Inc.,
32 * 675 Mass Ave, Cambridge, MA 02139, USA.
36 * This file holds the "policy" for the interface to the SMI state
37 * machine. It does the configuration, handles timers and interrupts,
38 * and drives the real SMI state machine.
41 #include <linux/module.h>
42 #include <linux/moduleparam.h>
43 #include <asm/system.h>
44 #include <linux/sched.h>
45 #include <linux/timer.h>
46 #include <linux/errno.h>
47 #include <linux/spinlock.h>
48 #include <linux/slab.h>
49 #include <linux/delay.h>
50 #include <linux/list.h>
51 #include <linux/pci.h>
52 #include <linux/ioport.h>
53 #include <linux/notifier.h>
54 #include <linux/mutex.h>
55 #include <linux/kthread.h>
57 #include <linux/interrupt.h>
58 #include <linux/rcupdate.h>
59 #include <linux/ipmi_smi.h>
61 #include "ipmi_si_sm.h"
62 #include <linux/init.h>
63 #include <linux/dmi.h>
65 /* Measure times between events in the driver. */
68 /* Call every 10 ms. */
69 #define SI_TIMEOUT_TIME_USEC 10000
70 #define SI_USEC_PER_JIFFY (1000000/HZ)
71 #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
72 #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
80 SI_CLEARING_FLAGS_THEN_SET_IRQ,
82 SI_ENABLE_INTERRUPTS1,
84 /* FIXME - add watchdog stuff. */
87 /* Some BT-specific defines we need here. */
88 #define IPMI_BT_INTMASK_REG 2
89 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
90 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
93 SI_KCS, SI_SMIC, SI_BT
95 static char *si_to_str[] = { "KCS", "SMIC", "BT" };
97 #define DEVICE_NAME "ipmi_si"
99 static struct device_driver ipmi_driver =
102 .bus = &platform_bus_type
109 struct si_sm_data *si_sm;
110 struct si_sm_handlers *handlers;
111 enum si_type si_type;
114 struct list_head xmit_msgs;
115 struct list_head hp_xmit_msgs;
116 struct ipmi_smi_msg *curr_msg;
117 enum si_intf_state si_state;
119 /* Used to handle the various types of I/O that can occur with
122 int (*io_setup)(struct smi_info *info);
123 void (*io_cleanup)(struct smi_info *info);
124 int (*irq_setup)(struct smi_info *info);
125 void (*irq_cleanup)(struct smi_info *info);
126 unsigned int io_size;
127 char *addr_source; /* ACPI, PCI, SMBIOS, hardcode, default. */
128 void (*addr_source_cleanup)(struct smi_info *info);
129 void *addr_source_data;
131 /* Per-OEM handler, called from handle_flags().
132 Returns 1 when handle_flags() needs to be re-run
133 or 0 indicating it set si_state itself.
135 int (*oem_data_avail_handler)(struct smi_info *smi_info);
137 /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
138 is set to hold the flags until we are done handling everything
140 #define RECEIVE_MSG_AVAIL 0x01
141 #define EVENT_MSG_BUFFER_FULL 0x02
142 #define WDT_PRE_TIMEOUT_INT 0x08
143 #define OEM0_DATA_AVAIL 0x20
144 #define OEM1_DATA_AVAIL 0x40
145 #define OEM2_DATA_AVAIL 0x80
146 #define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
149 unsigned char msg_flags;
151 /* If set to true, this will request events the next time the
152 state machine is idle. */
155 /* If true, run the state machine to completion on every send
156 call. Generally used after a panic to make sure stuff goes
158 int run_to_completion;
160 /* The I/O port of an SI interface. */
163 /* The space between start addresses of the two ports. For
164 instance, if the first port is 0xca2 and the spacing is 4, then
165 the second port is 0xca6. */
166 unsigned int spacing;
168 /* zero if no irq; */
171 /* The timer for this si. */
172 struct timer_list si_timer;
174 /* The time (in jiffies) the last timeout occurred at. */
175 unsigned long last_timeout_jiffies;
177 /* Used to gracefully stop the timer without race conditions. */
178 atomic_t stop_operation;
180 /* The driver will disable interrupts when it gets into a
181 situation where it cannot handle messages due to lack of
182 memory. Once that situation clears up, it will re-enable
184 int interrupt_disabled;
186 /* From the get device id response... */
187 struct ipmi_device_id device_id;
189 /* Driver model stuff. */
191 struct platform_device *pdev;
193 /* True if we allocated the device, false if it came from
194 * someplace else (like PCI). */
197 /* Slave address, could be reported from DMI. */
198 unsigned char slave_addr;
200 /* Counters and things for the proc filesystem. */
201 spinlock_t count_lock;
202 unsigned long short_timeouts;
203 unsigned long long_timeouts;
204 unsigned long timeout_restarts;
206 unsigned long interrupts;
207 unsigned long attentions;
208 unsigned long flag_fetches;
209 unsigned long hosed_count;
210 unsigned long complete_transactions;
211 unsigned long events;
212 unsigned long watchdog_pretimeouts;
213 unsigned long incoming_messages;
215 struct task_struct *thread;
217 struct list_head link;
220 #define SI_MAX_PARMS 4
222 static int force_kipmid[SI_MAX_PARMS];
223 static int num_force_kipmid;
225 static int try_smi_init(struct smi_info *smi);
227 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
228 static int register_xaction_notifier(struct notifier_block * nb)
230 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
233 static void deliver_recv_msg(struct smi_info *smi_info,
234 struct ipmi_smi_msg *msg)
236 /* Deliver the message to the upper layer with the lock
238 spin_unlock(&(smi_info->si_lock));
239 ipmi_smi_msg_received(smi_info->intf, msg);
240 spin_lock(&(smi_info->si_lock));
243 static void return_hosed_msg(struct smi_info *smi_info)
245 struct ipmi_smi_msg *msg = smi_info->curr_msg;
247 /* Make it a reponse */
248 msg->rsp[0] = msg->data[0] | 4;
249 msg->rsp[1] = msg->data[1];
250 msg->rsp[2] = 0xFF; /* Unknown error. */
253 smi_info->curr_msg = NULL;
254 deliver_recv_msg(smi_info, msg);
257 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
260 struct list_head *entry = NULL;
265 /* No need to save flags, we aleady have interrupts off and we
266 already hold the SMI lock. */
267 spin_lock(&(smi_info->msg_lock));
269 /* Pick the high priority queue first. */
270 if (!list_empty(&(smi_info->hp_xmit_msgs))) {
271 entry = smi_info->hp_xmit_msgs.next;
272 } else if (!list_empty(&(smi_info->xmit_msgs))) {
273 entry = smi_info->xmit_msgs.next;
277 smi_info->curr_msg = NULL;
283 smi_info->curr_msg = list_entry(entry,
288 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
290 err = atomic_notifier_call_chain(&xaction_notifier_list,
292 if (err & NOTIFY_STOP_MASK) {
293 rv = SI_SM_CALL_WITHOUT_DELAY;
296 err = smi_info->handlers->start_transaction(
298 smi_info->curr_msg->data,
299 smi_info->curr_msg->data_size);
301 return_hosed_msg(smi_info);
304 rv = SI_SM_CALL_WITHOUT_DELAY;
307 spin_unlock(&(smi_info->msg_lock));
312 static void start_enable_irq(struct smi_info *smi_info)
314 unsigned char msg[2];
316 /* If we are enabling interrupts, we have to tell the
318 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
319 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
321 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
322 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
325 static void start_clear_flags(struct smi_info *smi_info)
327 unsigned char msg[3];
329 /* Make sure the watchdog pre-timeout flag is not set at startup. */
330 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
331 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
332 msg[2] = WDT_PRE_TIMEOUT_INT;
334 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
335 smi_info->si_state = SI_CLEARING_FLAGS;
338 /* When we have a situtaion where we run out of memory and cannot
339 allocate messages, we just leave them in the BMC and run the system
340 polled until we can allocate some memory. Once we have some
341 memory, we will re-enable the interrupt. */
342 static inline void disable_si_irq(struct smi_info *smi_info)
344 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
345 disable_irq_nosync(smi_info->irq);
346 smi_info->interrupt_disabled = 1;
350 static inline void enable_si_irq(struct smi_info *smi_info)
352 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
353 enable_irq(smi_info->irq);
354 smi_info->interrupt_disabled = 0;
358 static void handle_flags(struct smi_info *smi_info)
361 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
362 /* Watchdog pre-timeout */
363 spin_lock(&smi_info->count_lock);
364 smi_info->watchdog_pretimeouts++;
365 spin_unlock(&smi_info->count_lock);
367 start_clear_flags(smi_info);
368 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
369 spin_unlock(&(smi_info->si_lock));
370 ipmi_smi_watchdog_pretimeout(smi_info->intf);
371 spin_lock(&(smi_info->si_lock));
372 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
373 /* Messages available. */
374 smi_info->curr_msg = ipmi_alloc_smi_msg();
375 if (!smi_info->curr_msg) {
376 disable_si_irq(smi_info);
377 smi_info->si_state = SI_NORMAL;
380 enable_si_irq(smi_info);
382 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
383 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
384 smi_info->curr_msg->data_size = 2;
386 smi_info->handlers->start_transaction(
388 smi_info->curr_msg->data,
389 smi_info->curr_msg->data_size);
390 smi_info->si_state = SI_GETTING_MESSAGES;
391 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
392 /* Events available. */
393 smi_info->curr_msg = ipmi_alloc_smi_msg();
394 if (!smi_info->curr_msg) {
395 disable_si_irq(smi_info);
396 smi_info->si_state = SI_NORMAL;
399 enable_si_irq(smi_info);
401 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
402 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
403 smi_info->curr_msg->data_size = 2;
405 smi_info->handlers->start_transaction(
407 smi_info->curr_msg->data,
408 smi_info->curr_msg->data_size);
409 smi_info->si_state = SI_GETTING_EVENTS;
410 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
411 smi_info->oem_data_avail_handler) {
412 if (smi_info->oem_data_avail_handler(smi_info))
415 smi_info->si_state = SI_NORMAL;
419 static void handle_transaction_done(struct smi_info *smi_info)
421 struct ipmi_smi_msg *msg;
426 printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
428 switch (smi_info->si_state) {
430 if (!smi_info->curr_msg)
433 smi_info->curr_msg->rsp_size
434 = smi_info->handlers->get_result(
436 smi_info->curr_msg->rsp,
437 IPMI_MAX_MSG_LENGTH);
439 /* Do this here becase deliver_recv_msg() releases the
440 lock, and a new message can be put in during the
441 time the lock is released. */
442 msg = smi_info->curr_msg;
443 smi_info->curr_msg = NULL;
444 deliver_recv_msg(smi_info, msg);
447 case SI_GETTING_FLAGS:
449 unsigned char msg[4];
452 /* We got the flags from the SMI, now handle them. */
453 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
455 /* Error fetching flags, just give up for
457 smi_info->si_state = SI_NORMAL;
458 } else if (len < 4) {
459 /* Hmm, no flags. That's technically illegal, but
460 don't use uninitialized data. */
461 smi_info->si_state = SI_NORMAL;
463 smi_info->msg_flags = msg[3];
464 handle_flags(smi_info);
469 case SI_CLEARING_FLAGS:
470 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
472 unsigned char msg[3];
474 /* We cleared the flags. */
475 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
477 /* Error clearing flags */
479 "ipmi_si: Error clearing flags: %2.2x\n",
482 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
483 start_enable_irq(smi_info);
485 smi_info->si_state = SI_NORMAL;
489 case SI_GETTING_EVENTS:
491 smi_info->curr_msg->rsp_size
492 = smi_info->handlers->get_result(
494 smi_info->curr_msg->rsp,
495 IPMI_MAX_MSG_LENGTH);
497 /* Do this here becase deliver_recv_msg() releases the
498 lock, and a new message can be put in during the
499 time the lock is released. */
500 msg = smi_info->curr_msg;
501 smi_info->curr_msg = NULL;
502 if (msg->rsp[2] != 0) {
503 /* Error getting event, probably done. */
506 /* Take off the event flag. */
507 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
508 handle_flags(smi_info);
510 spin_lock(&smi_info->count_lock);
512 spin_unlock(&smi_info->count_lock);
514 /* Do this before we deliver the message
515 because delivering the message releases the
516 lock and something else can mess with the
518 handle_flags(smi_info);
520 deliver_recv_msg(smi_info, msg);
525 case SI_GETTING_MESSAGES:
527 smi_info->curr_msg->rsp_size
528 = smi_info->handlers->get_result(
530 smi_info->curr_msg->rsp,
531 IPMI_MAX_MSG_LENGTH);
533 /* Do this here becase deliver_recv_msg() releases the
534 lock, and a new message can be put in during the
535 time the lock is released. */
536 msg = smi_info->curr_msg;
537 smi_info->curr_msg = NULL;
538 if (msg->rsp[2] != 0) {
539 /* Error getting event, probably done. */
542 /* Take off the msg flag. */
543 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
544 handle_flags(smi_info);
546 spin_lock(&smi_info->count_lock);
547 smi_info->incoming_messages++;
548 spin_unlock(&smi_info->count_lock);
550 /* Do this before we deliver the message
551 because delivering the message releases the
552 lock and something else can mess with the
554 handle_flags(smi_info);
556 deliver_recv_msg(smi_info, msg);
561 case SI_ENABLE_INTERRUPTS1:
563 unsigned char msg[4];
565 /* We got the flags from the SMI, now handle them. */
566 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
569 "ipmi_si: Could not enable interrupts"
570 ", failed get, using polled mode.\n");
571 smi_info->si_state = SI_NORMAL;
573 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
574 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
575 msg[2] = msg[3] | 1; /* enable msg queue int */
576 smi_info->handlers->start_transaction(
577 smi_info->si_sm, msg, 3);
578 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
583 case SI_ENABLE_INTERRUPTS2:
585 unsigned char msg[4];
587 /* We got the flags from the SMI, now handle them. */
588 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
591 "ipmi_si: Could not enable interrupts"
592 ", failed set, using polled mode.\n");
594 smi_info->si_state = SI_NORMAL;
600 /* Called on timeouts and events. Timeouts should pass the elapsed
601 time, interrupts should pass in zero. */
602 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
605 enum si_sm_result si_sm_result;
608 /* There used to be a loop here that waited a little while
609 (around 25us) before giving up. That turned out to be
610 pointless, the minimum delays I was seeing were in the 300us
611 range, which is far too long to wait in an interrupt. So
612 we just run until the state machine tells us something
613 happened or it needs a delay. */
614 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
616 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
618 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
621 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
623 spin_lock(&smi_info->count_lock);
624 smi_info->complete_transactions++;
625 spin_unlock(&smi_info->count_lock);
627 handle_transaction_done(smi_info);
628 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
630 else if (si_sm_result == SI_SM_HOSED)
632 spin_lock(&smi_info->count_lock);
633 smi_info->hosed_count++;
634 spin_unlock(&smi_info->count_lock);
636 /* Do the before return_hosed_msg, because that
637 releases the lock. */
638 smi_info->si_state = SI_NORMAL;
639 if (smi_info->curr_msg != NULL) {
640 /* If we were handling a user message, format
641 a response to send to the upper layer to
642 tell it about the error. */
643 return_hosed_msg(smi_info);
645 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
648 /* We prefer handling attn over new messages. */
649 if (si_sm_result == SI_SM_ATTN)
651 unsigned char msg[2];
653 spin_lock(&smi_info->count_lock);
654 smi_info->attentions++;
655 spin_unlock(&smi_info->count_lock);
657 /* Got a attn, send down a get message flags to see
658 what's causing it. It would be better to handle
659 this in the upper layer, but due to the way
660 interrupts work with the SMI, that's not really
662 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
663 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
665 smi_info->handlers->start_transaction(
666 smi_info->si_sm, msg, 2);
667 smi_info->si_state = SI_GETTING_FLAGS;
671 /* If we are currently idle, try to start the next message. */
672 if (si_sm_result == SI_SM_IDLE) {
673 spin_lock(&smi_info->count_lock);
675 spin_unlock(&smi_info->count_lock);
677 si_sm_result = start_next_msg(smi_info);
678 if (si_sm_result != SI_SM_IDLE)
682 if ((si_sm_result == SI_SM_IDLE)
683 && (atomic_read(&smi_info->req_events)))
685 /* We are idle and the upper layer requested that I fetch
687 atomic_set(&smi_info->req_events, 0);
689 smi_info->curr_msg = ipmi_alloc_smi_msg();
690 if (!smi_info->curr_msg)
693 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
694 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
695 smi_info->curr_msg->data_size = 2;
697 smi_info->handlers->start_transaction(
699 smi_info->curr_msg->data,
700 smi_info->curr_msg->data_size);
701 smi_info->si_state = SI_GETTING_EVENTS;
708 static void sender(void *send_info,
709 struct ipmi_smi_msg *msg,
712 struct smi_info *smi_info = send_info;
713 enum si_sm_result result;
719 spin_lock_irqsave(&(smi_info->msg_lock), flags);
722 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
725 if (smi_info->run_to_completion) {
726 /* If we are running to completion, then throw it in
727 the list and run transactions until everything is
728 clear. Priority doesn't matter here. */
729 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
731 /* We have to release the msg lock and claim the smi
732 lock in this case, because of race conditions. */
733 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
735 spin_lock_irqsave(&(smi_info->si_lock), flags);
736 result = smi_event_handler(smi_info, 0);
737 while (result != SI_SM_IDLE) {
738 udelay(SI_SHORT_TIMEOUT_USEC);
739 result = smi_event_handler(smi_info,
740 SI_SHORT_TIMEOUT_USEC);
742 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
746 list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
748 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
751 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
753 spin_lock_irqsave(&(smi_info->si_lock), flags);
754 if ((smi_info->si_state == SI_NORMAL)
755 && (smi_info->curr_msg == NULL))
757 start_next_msg(smi_info);
759 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
762 static void set_run_to_completion(void *send_info, int i_run_to_completion)
764 struct smi_info *smi_info = send_info;
765 enum si_sm_result result;
768 spin_lock_irqsave(&(smi_info->si_lock), flags);
770 smi_info->run_to_completion = i_run_to_completion;
771 if (i_run_to_completion) {
772 result = smi_event_handler(smi_info, 0);
773 while (result != SI_SM_IDLE) {
774 udelay(SI_SHORT_TIMEOUT_USEC);
775 result = smi_event_handler(smi_info,
776 SI_SHORT_TIMEOUT_USEC);
780 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
783 static int ipmi_thread(void *data)
785 struct smi_info *smi_info = data;
787 enum si_sm_result smi_result;
789 set_user_nice(current, 19);
790 while (!kthread_should_stop()) {
791 spin_lock_irqsave(&(smi_info->si_lock), flags);
792 smi_result = smi_event_handler(smi_info, 0);
793 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
794 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
797 else if (smi_result == SI_SM_CALL_WITH_DELAY)
800 schedule_timeout_interruptible(1);
806 static void poll(void *send_info)
808 struct smi_info *smi_info = send_info;
810 smi_event_handler(smi_info, 0);
813 static void request_events(void *send_info)
815 struct smi_info *smi_info = send_info;
817 atomic_set(&smi_info->req_events, 1);
820 static int initialized = 0;
822 static void smi_timeout(unsigned long data)
824 struct smi_info *smi_info = (struct smi_info *) data;
825 enum si_sm_result smi_result;
827 unsigned long jiffies_now;
833 if (atomic_read(&smi_info->stop_operation))
836 spin_lock_irqsave(&(smi_info->si_lock), flags);
839 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
841 jiffies_now = jiffies;
842 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
843 * SI_USEC_PER_JIFFY);
844 smi_result = smi_event_handler(smi_info, time_diff);
846 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
848 smi_info->last_timeout_jiffies = jiffies_now;
850 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
851 /* Running with interrupts, only do long timeouts. */
852 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
853 spin_lock_irqsave(&smi_info->count_lock, flags);
854 smi_info->long_timeouts++;
855 spin_unlock_irqrestore(&smi_info->count_lock, flags);
859 /* If the state machine asks for a short delay, then shorten
860 the timer timeout. */
861 if (smi_result == SI_SM_CALL_WITH_DELAY) {
862 spin_lock_irqsave(&smi_info->count_lock, flags);
863 smi_info->short_timeouts++;
864 spin_unlock_irqrestore(&smi_info->count_lock, flags);
865 smi_info->si_timer.expires = jiffies + 1;
867 spin_lock_irqsave(&smi_info->count_lock, flags);
868 smi_info->long_timeouts++;
869 spin_unlock_irqrestore(&smi_info->count_lock, flags);
870 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
874 add_timer(&(smi_info->si_timer));
877 static irqreturn_t si_irq_handler(int irq, void *data)
879 struct smi_info *smi_info = data;
885 spin_lock_irqsave(&(smi_info->si_lock), flags);
887 spin_lock(&smi_info->count_lock);
888 smi_info->interrupts++;
889 spin_unlock(&smi_info->count_lock);
891 if (atomic_read(&smi_info->stop_operation))
896 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
898 smi_event_handler(smi_info, 0);
900 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
904 static irqreturn_t si_bt_irq_handler(int irq, void *data)
906 struct smi_info *smi_info = data;
907 /* We need to clear the IRQ flag for the BT interface. */
908 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
909 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
910 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
911 return si_irq_handler(irq, data);
914 static int smi_start_processing(void *send_info,
917 struct smi_info *new_smi = send_info;
920 new_smi->intf = intf;
922 /* Set up the timer that drives the interface. */
923 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
924 new_smi->last_timeout_jiffies = jiffies;
925 mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
928 * Check if the user forcefully enabled the daemon.
930 if (new_smi->intf_num < num_force_kipmid)
931 enable = force_kipmid[new_smi->intf_num];
933 * The BT interface is efficient enough to not need a thread,
934 * and there is no need for a thread if we have interrupts.
936 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
940 new_smi->thread = kthread_run(ipmi_thread, new_smi,
941 "kipmi%d", new_smi->intf_num);
942 if (IS_ERR(new_smi->thread)) {
943 printk(KERN_NOTICE "ipmi_si_intf: Could not start"
944 " kernel thread due to error %ld, only using"
945 " timers to drive the interface\n",
946 PTR_ERR(new_smi->thread));
947 new_smi->thread = NULL;
954 static void set_maintenance_mode(void *send_info, int enable)
956 struct smi_info *smi_info = send_info;
959 atomic_set(&smi_info->req_events, 0);
962 static struct ipmi_smi_handlers handlers =
964 .owner = THIS_MODULE,
965 .start_processing = smi_start_processing,
967 .request_events = request_events,
968 .set_maintenance_mode = set_maintenance_mode,
969 .set_run_to_completion = set_run_to_completion,
973 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
974 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
976 static LIST_HEAD(smi_infos);
977 static DEFINE_MUTEX(smi_infos_lock);
978 static int smi_num; /* Used to sequence the SMIs */
980 #define DEFAULT_REGSPACING 1
982 static int si_trydefaults = 1;
983 static char *si_type[SI_MAX_PARMS];
984 #define MAX_SI_TYPE_STR 30
985 static char si_type_str[MAX_SI_TYPE_STR];
986 static unsigned long addrs[SI_MAX_PARMS];
987 static int num_addrs;
988 static unsigned int ports[SI_MAX_PARMS];
989 static int num_ports;
990 static int irqs[SI_MAX_PARMS];
992 static int regspacings[SI_MAX_PARMS];
993 static int num_regspacings = 0;
994 static int regsizes[SI_MAX_PARMS];
995 static int num_regsizes = 0;
996 static int regshifts[SI_MAX_PARMS];
997 static int num_regshifts = 0;
998 static int slave_addrs[SI_MAX_PARMS];
999 static int num_slave_addrs = 0;
1002 module_param_named(trydefaults, si_trydefaults, bool, 0);
1003 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1004 " default scan of the KCS and SMIC interface at the standard"
1006 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1007 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1008 " interface separated by commas. The types are 'kcs',"
1009 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1010 " the first interface to kcs and the second to bt");
1011 module_param_array(addrs, long, &num_addrs, 0);
1012 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1013 " addresses separated by commas. Only use if an interface"
1014 " is in memory. Otherwise, set it to zero or leave"
1016 module_param_array(ports, int, &num_ports, 0);
1017 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1018 " addresses separated by commas. Only use if an interface"
1019 " is a port. Otherwise, set it to zero or leave"
1021 module_param_array(irqs, int, &num_irqs, 0);
1022 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1023 " addresses separated by commas. Only use if an interface"
1024 " has an interrupt. Otherwise, set it to zero or leave"
1026 module_param_array(regspacings, int, &num_regspacings, 0);
1027 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1028 " and each successive register used by the interface. For"
1029 " instance, if the start address is 0xca2 and the spacing"
1030 " is 2, then the second address is at 0xca4. Defaults"
1032 module_param_array(regsizes, int, &num_regsizes, 0);
1033 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1034 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1035 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1036 " the 8-bit IPMI register has to be read from a larger"
1038 module_param_array(regshifts, int, &num_regshifts, 0);
1039 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1040 " IPMI register, in bits. For instance, if the data"
1041 " is read from a 32-bit word and the IPMI data is in"
1042 " bit 8-15, then the shift would be 8");
1043 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1044 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1045 " the controller. Normally this is 0x20, but can be"
1046 " overridden by this parm. This is an array indexed"
1047 " by interface number.");
1048 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1049 MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1050 " disabled(0). Normally the IPMI driver auto-detects"
1051 " this, but the value may be overridden by this parm.");
1054 #define IPMI_IO_ADDR_SPACE 0
1055 #define IPMI_MEM_ADDR_SPACE 1
1056 static char *addr_space_to_str[] = { "I/O", "memory" };
1058 static void std_irq_cleanup(struct smi_info *info)
1060 if (info->si_type == SI_BT)
1061 /* Disable the interrupt in the BT interface. */
1062 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1063 free_irq(info->irq, info);
1066 static int std_irq_setup(struct smi_info *info)
1073 if (info->si_type == SI_BT) {
1074 rv = request_irq(info->irq,
1080 /* Enable the interrupt in the BT interface. */
1081 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1082 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1084 rv = request_irq(info->irq,
1091 "ipmi_si: %s unable to claim interrupt %d,"
1092 " running polled\n",
1093 DEVICE_NAME, info->irq);
1096 info->irq_cleanup = std_irq_cleanup;
1097 printk(" Using irq %d\n", info->irq);
1103 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1105 unsigned int addr = io->addr_data;
1107 return inb(addr + (offset * io->regspacing));
1110 static void port_outb(struct si_sm_io *io, unsigned int offset,
1113 unsigned int addr = io->addr_data;
1115 outb(b, addr + (offset * io->regspacing));
1118 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1120 unsigned int addr = io->addr_data;
1122 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1125 static void port_outw(struct si_sm_io *io, unsigned int offset,
1128 unsigned int addr = io->addr_data;
1130 outw(b << io->regshift, addr + (offset * io->regspacing));
1133 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1135 unsigned int addr = io->addr_data;
1137 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1140 static void port_outl(struct si_sm_io *io, unsigned int offset,
1143 unsigned int addr = io->addr_data;
1145 outl(b << io->regshift, addr+(offset * io->regspacing));
1148 static void port_cleanup(struct smi_info *info)
1150 unsigned int addr = info->io.addr_data;
1154 for (idx = 0; idx < info->io_size; idx++) {
1155 release_region(addr + idx * info->io.regspacing,
1161 static int port_setup(struct smi_info *info)
1163 unsigned int addr = info->io.addr_data;
1169 info->io_cleanup = port_cleanup;
1171 /* Figure out the actual inb/inw/inl/etc routine to use based
1172 upon the register size. */
1173 switch (info->io.regsize) {
1175 info->io.inputb = port_inb;
1176 info->io.outputb = port_outb;
1179 info->io.inputb = port_inw;
1180 info->io.outputb = port_outw;
1183 info->io.inputb = port_inl;
1184 info->io.outputb = port_outl;
1187 printk("ipmi_si: Invalid register size: %d\n",
1192 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1193 * tables. This causes problems when trying to register the
1194 * entire I/O region. Therefore we must register each I/O
1197 for (idx = 0; idx < info->io_size; idx++) {
1198 if (request_region(addr + idx * info->io.regspacing,
1199 info->io.regsize, DEVICE_NAME) == NULL) {
1200 /* Undo allocations */
1202 release_region(addr + idx * info->io.regspacing,
1211 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1213 return readb((io->addr)+(offset * io->regspacing));
1216 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1219 writeb(b, (io->addr)+(offset * io->regspacing));
1222 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1224 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1228 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1231 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1234 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1236 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1240 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1243 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1247 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1249 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1253 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1256 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1260 static void mem_cleanup(struct smi_info *info)
1262 unsigned long addr = info->io.addr_data;
1265 if (info->io.addr) {
1266 iounmap(info->io.addr);
1268 mapsize = ((info->io_size * info->io.regspacing)
1269 - (info->io.regspacing - info->io.regsize));
1271 release_mem_region(addr, mapsize);
1275 static int mem_setup(struct smi_info *info)
1277 unsigned long addr = info->io.addr_data;
1283 info->io_cleanup = mem_cleanup;
1285 /* Figure out the actual readb/readw/readl/etc routine to use based
1286 upon the register size. */
1287 switch (info->io.regsize) {
1289 info->io.inputb = intf_mem_inb;
1290 info->io.outputb = intf_mem_outb;
1293 info->io.inputb = intf_mem_inw;
1294 info->io.outputb = intf_mem_outw;
1297 info->io.inputb = intf_mem_inl;
1298 info->io.outputb = intf_mem_outl;
1302 info->io.inputb = mem_inq;
1303 info->io.outputb = mem_outq;
1307 printk("ipmi_si: Invalid register size: %d\n",
1312 /* Calculate the total amount of memory to claim. This is an
1313 * unusual looking calculation, but it avoids claiming any
1314 * more memory than it has to. It will claim everything
1315 * between the first address to the end of the last full
1317 mapsize = ((info->io_size * info->io.regspacing)
1318 - (info->io.regspacing - info->io.regsize));
1320 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1323 info->io.addr = ioremap(addr, mapsize);
1324 if (info->io.addr == NULL) {
1325 release_mem_region(addr, mapsize);
1332 static __devinit void hardcode_find_bmc(void)
1335 struct smi_info *info;
1337 for (i = 0; i < SI_MAX_PARMS; i++) {
1338 if (!ports[i] && !addrs[i])
1341 info = kzalloc(sizeof(*info), GFP_KERNEL);
1345 info->addr_source = "hardcoded";
1347 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1348 info->si_type = SI_KCS;
1349 } else if (strcmp(si_type[i], "smic") == 0) {
1350 info->si_type = SI_SMIC;
1351 } else if (strcmp(si_type[i], "bt") == 0) {
1352 info->si_type = SI_BT;
1355 "ipmi_si: Interface type specified "
1356 "for interface %d, was invalid: %s\n",
1364 info->io_setup = port_setup;
1365 info->io.addr_data = ports[i];
1366 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1367 } else if (addrs[i]) {
1369 info->io_setup = mem_setup;
1370 info->io.addr_data = addrs[i];
1371 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1374 "ipmi_si: Interface type specified "
1375 "for interface %d, "
1376 "but port and address were not set or "
1377 "set to zero.\n", i);
1382 info->io.addr = NULL;
1383 info->io.regspacing = regspacings[i];
1384 if (!info->io.regspacing)
1385 info->io.regspacing = DEFAULT_REGSPACING;
1386 info->io.regsize = regsizes[i];
1387 if (!info->io.regsize)
1388 info->io.regsize = DEFAULT_REGSPACING;
1389 info->io.regshift = regshifts[i];
1390 info->irq = irqs[i];
1392 info->irq_setup = std_irq_setup;
1400 #include <linux/acpi.h>
1402 /* Once we get an ACPI failure, we don't try any more, because we go
1403 through the tables sequentially. Once we don't find a table, there
1405 static int acpi_failure = 0;
1407 /* For GPE-type interrupts. */
1408 static u32 ipmi_acpi_gpe(void *context)
1410 struct smi_info *smi_info = context;
1411 unsigned long flags;
1416 spin_lock_irqsave(&(smi_info->si_lock), flags);
1418 spin_lock(&smi_info->count_lock);
1419 smi_info->interrupts++;
1420 spin_unlock(&smi_info->count_lock);
1422 if (atomic_read(&smi_info->stop_operation))
1426 do_gettimeofday(&t);
1427 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1429 smi_event_handler(smi_info, 0);
1431 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1433 return ACPI_INTERRUPT_HANDLED;
1436 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1441 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1444 static int acpi_gpe_irq_setup(struct smi_info *info)
1451 /* FIXME - is level triggered right? */
1452 status = acpi_install_gpe_handler(NULL,
1454 ACPI_GPE_LEVEL_TRIGGERED,
1457 if (status != AE_OK) {
1459 "ipmi_si: %s unable to claim ACPI GPE %d,"
1460 " running polled\n",
1461 DEVICE_NAME, info->irq);
1465 info->irq_cleanup = acpi_gpe_irq_cleanup;
1466 printk(" Using ACPI GPE %d\n", info->irq);
1473 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1484 s8 CreatorRevision[4];
1487 s16 SpecificationRevision;
1490 * Bit 0 - SCI interrupt supported
1491 * Bit 1 - I/O APIC/SAPIC
1495 /* If bit 0 of InterruptType is set, then this is the SCI
1496 interrupt in the GPEx_STS register. */
1501 /* If bit 1 of InterruptType is set, then this is the I/O
1502 APIC/SAPIC interrupt. */
1503 u32 GlobalSystemInterrupt;
1505 /* The actual register address. */
1506 struct acpi_generic_address addr;
1510 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1513 static __devinit int try_init_acpi(struct SPMITable *spmi)
1515 struct smi_info *info;
1519 if (spmi->IPMIlegacy != 1) {
1520 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1524 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1525 addr_space = IPMI_MEM_ADDR_SPACE;
1527 addr_space = IPMI_IO_ADDR_SPACE;
1529 info = kzalloc(sizeof(*info), GFP_KERNEL);
1531 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1535 info->addr_source = "ACPI";
1537 /* Figure out the interface type. */
1538 switch (spmi->InterfaceType)
1541 info->si_type = SI_KCS;
1544 info->si_type = SI_SMIC;
1547 info->si_type = SI_BT;
1550 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1551 spmi->InterfaceType);
1556 if (spmi->InterruptType & 1) {
1557 /* We've got a GPE interrupt. */
1558 info->irq = spmi->GPE;
1559 info->irq_setup = acpi_gpe_irq_setup;
1560 } else if (spmi->InterruptType & 2) {
1561 /* We've got an APIC/SAPIC interrupt. */
1562 info->irq = spmi->GlobalSystemInterrupt;
1563 info->irq_setup = std_irq_setup;
1565 /* Use the default interrupt setting. */
1567 info->irq_setup = NULL;
1570 if (spmi->addr.register_bit_width) {
1571 /* A (hopefully) properly formed register bit width. */
1572 info->io.regspacing = spmi->addr.register_bit_width / 8;
1574 info->io.regspacing = DEFAULT_REGSPACING;
1576 info->io.regsize = info->io.regspacing;
1577 info->io.regshift = spmi->addr.register_bit_offset;
1579 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1581 info->io_setup = mem_setup;
1582 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1583 } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1585 info->io_setup = port_setup;
1586 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1589 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1592 info->io.addr_data = spmi->addr.address;
1599 static __devinit void acpi_find_bmc(void)
1602 struct SPMITable *spmi;
1611 for (i = 0; ; i++) {
1612 status = acpi_get_firmware_table("SPMI", i+1,
1613 ACPI_LOGICAL_ADDRESSING,
1614 (struct acpi_table_header **)
1616 if (status != AE_OK)
1619 try_init_acpi(spmi);
1625 struct dmi_ipmi_data
1629 unsigned long base_addr;
1635 static int __devinit decode_dmi(struct dmi_header *dm,
1636 struct dmi_ipmi_data *dmi)
1638 u8 *data = (u8 *)dm;
1639 unsigned long base_addr;
1641 u8 len = dm->length;
1643 dmi->type = data[4];
1645 memcpy(&base_addr, data+8, sizeof(unsigned long));
1647 if (base_addr & 1) {
1649 base_addr &= 0xFFFE;
1650 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1654 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1656 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1658 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1660 dmi->irq = data[0x11];
1662 /* The top two bits of byte 0x10 hold the register spacing. */
1663 reg_spacing = (data[0x10] & 0xC0) >> 6;
1664 switch(reg_spacing){
1665 case 0x00: /* Byte boundaries */
1668 case 0x01: /* 32-bit boundaries */
1671 case 0x02: /* 16-byte boundaries */
1675 /* Some other interface, just ignore it. */
1680 /* Note that technically, the lower bit of the base
1681 * address should be 1 if the address is I/O and 0 if
1682 * the address is in memory. So many systems get that
1683 * wrong (and all that I have seen are I/O) so we just
1684 * ignore that bit and assume I/O. Systems that use
1685 * memory should use the newer spec, anyway. */
1686 dmi->base_addr = base_addr & 0xfffe;
1687 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1691 dmi->slave_addr = data[6];
1696 static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
1698 struct smi_info *info;
1700 info = kzalloc(sizeof(*info), GFP_KERNEL);
1703 "ipmi_si: Could not allocate SI data\n");
1707 info->addr_source = "SMBIOS";
1709 switch (ipmi_data->type) {
1710 case 0x01: /* KCS */
1711 info->si_type = SI_KCS;
1713 case 0x02: /* SMIC */
1714 info->si_type = SI_SMIC;
1717 info->si_type = SI_BT;
1723 switch (ipmi_data->addr_space) {
1724 case IPMI_MEM_ADDR_SPACE:
1725 info->io_setup = mem_setup;
1726 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1729 case IPMI_IO_ADDR_SPACE:
1730 info->io_setup = port_setup;
1731 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1737 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
1738 ipmi_data->addr_space);
1741 info->io.addr_data = ipmi_data->base_addr;
1743 info->io.regspacing = ipmi_data->offset;
1744 if (!info->io.regspacing)
1745 info->io.regspacing = DEFAULT_REGSPACING;
1746 info->io.regsize = DEFAULT_REGSPACING;
1747 info->io.regshift = 0;
1749 info->slave_addr = ipmi_data->slave_addr;
1751 info->irq = ipmi_data->irq;
1753 info->irq_setup = std_irq_setup;
1758 static void __devinit dmi_find_bmc(void)
1760 struct dmi_device *dev = NULL;
1761 struct dmi_ipmi_data data;
1764 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
1765 memset(&data, 0, sizeof(data));
1766 rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
1768 try_init_dmi(&data);
1771 #endif /* CONFIG_DMI */
1775 #define PCI_ERMC_CLASSCODE 0x0C0700
1776 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
1777 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
1778 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
1779 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
1780 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
1782 #define PCI_HP_VENDOR_ID 0x103C
1783 #define PCI_MMC_DEVICE_ID 0x121A
1784 #define PCI_MMC_ADDR_CW 0x10
1786 static void ipmi_pci_cleanup(struct smi_info *info)
1788 struct pci_dev *pdev = info->addr_source_data;
1790 pci_disable_device(pdev);
1793 static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
1794 const struct pci_device_id *ent)
1797 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
1798 struct smi_info *info;
1799 int first_reg_offset = 0;
1801 info = kzalloc(sizeof(*info), GFP_KERNEL);
1805 info->addr_source = "PCI";
1807 switch (class_type) {
1808 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
1809 info->si_type = SI_SMIC;
1812 case PCI_ERMC_CLASSCODE_TYPE_KCS:
1813 info->si_type = SI_KCS;
1816 case PCI_ERMC_CLASSCODE_TYPE_BT:
1817 info->si_type = SI_BT;
1822 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
1823 pci_name(pdev), class_type);
1827 rv = pci_enable_device(pdev);
1829 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
1835 info->addr_source_cleanup = ipmi_pci_cleanup;
1836 info->addr_source_data = pdev;
1838 if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
1839 first_reg_offset = 1;
1841 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
1842 info->io_setup = port_setup;
1843 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1845 info->io_setup = mem_setup;
1846 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1848 info->io.addr_data = pci_resource_start(pdev, 0);
1850 info->io.regspacing = DEFAULT_REGSPACING;
1851 info->io.regsize = DEFAULT_REGSPACING;
1852 info->io.regshift = 0;
1854 info->irq = pdev->irq;
1856 info->irq_setup = std_irq_setup;
1858 info->dev = &pdev->dev;
1860 return try_smi_init(info);
1863 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
1868 static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
1873 static int ipmi_pci_resume(struct pci_dev *pdev)
1879 static struct pci_device_id ipmi_pci_devices[] = {
1880 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
1881 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) }
1883 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
1885 static struct pci_driver ipmi_pci_driver = {
1886 .name = DEVICE_NAME,
1887 .id_table = ipmi_pci_devices,
1888 .probe = ipmi_pci_probe,
1889 .remove = __devexit_p(ipmi_pci_remove),
1891 .suspend = ipmi_pci_suspend,
1892 .resume = ipmi_pci_resume,
1895 #endif /* CONFIG_PCI */
1898 static int try_get_dev_id(struct smi_info *smi_info)
1900 unsigned char msg[2];
1901 unsigned char *resp;
1902 unsigned long resp_len;
1903 enum si_sm_result smi_result;
1906 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1910 /* Do a Get Device ID command, since it comes back with some
1912 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1913 msg[1] = IPMI_GET_DEVICE_ID_CMD;
1914 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1916 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1919 if (smi_result == SI_SM_CALL_WITH_DELAY ||
1920 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1921 schedule_timeout_uninterruptible(1);
1922 smi_result = smi_info->handlers->event(
1923 smi_info->si_sm, 100);
1925 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1927 smi_result = smi_info->handlers->event(
1928 smi_info->si_sm, 0);
1933 if (smi_result == SI_SM_HOSED) {
1934 /* We couldn't get the state machine to run, so whatever's at
1935 the port is probably not an IPMI SMI interface. */
1940 /* Otherwise, we got some data. */
1941 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1942 resp, IPMI_MAX_MSG_LENGTH);
1943 if (resp_len < 14) {
1944 /* That's odd, it should be longer. */
1949 if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
1950 /* That's odd, it shouldn't be able to fail. */
1955 /* Record info from the get device id, in case we need it. */
1956 ipmi_demangle_device_id(resp+3, resp_len-3, &smi_info->device_id);
1963 static int type_file_read_proc(char *page, char **start, off_t off,
1964 int count, int *eof, void *data)
1966 char *out = (char *) page;
1967 struct smi_info *smi = data;
1969 switch (smi->si_type) {
1971 return sprintf(out, "kcs\n");
1973 return sprintf(out, "smic\n");
1975 return sprintf(out, "bt\n");
1981 static int stat_file_read_proc(char *page, char **start, off_t off,
1982 int count, int *eof, void *data)
1984 char *out = (char *) page;
1985 struct smi_info *smi = data;
1987 out += sprintf(out, "interrupts_enabled: %d\n",
1988 smi->irq && !smi->interrupt_disabled);
1989 out += sprintf(out, "short_timeouts: %ld\n",
1990 smi->short_timeouts);
1991 out += sprintf(out, "long_timeouts: %ld\n",
1992 smi->long_timeouts);
1993 out += sprintf(out, "timeout_restarts: %ld\n",
1994 smi->timeout_restarts);
1995 out += sprintf(out, "idles: %ld\n",
1997 out += sprintf(out, "interrupts: %ld\n",
1999 out += sprintf(out, "attentions: %ld\n",
2001 out += sprintf(out, "flag_fetches: %ld\n",
2003 out += sprintf(out, "hosed_count: %ld\n",
2005 out += sprintf(out, "complete_transactions: %ld\n",
2006 smi->complete_transactions);
2007 out += sprintf(out, "events: %ld\n",
2009 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
2010 smi->watchdog_pretimeouts);
2011 out += sprintf(out, "incoming_messages: %ld\n",
2012 smi->incoming_messages);
2014 return (out - ((char *) page));
2018 * oem_data_avail_to_receive_msg_avail
2019 * @info - smi_info structure with msg_flags set
2021 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2022 * Returns 1 indicating need to re-run handle_flags().
2024 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2026 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2032 * setup_dell_poweredge_oem_data_handler
2033 * @info - smi_info.device_id must be populated
2035 * Systems that match, but have firmware version < 1.40 may assert
2036 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2037 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2038 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2039 * as RECEIVE_MSG_AVAIL instead.
2041 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2042 * assert the OEM[012] bits, and if it did, the driver would have to
2043 * change to handle that properly, we don't actually check for the
2045 * Device ID = 0x20 BMC on PowerEdge 8G servers
2046 * Device Revision = 0x80
2047 * Firmware Revision1 = 0x01 BMC version 1.40
2048 * Firmware Revision2 = 0x40 BCD encoded
2049 * IPMI Version = 0x51 IPMI 1.5
2050 * Manufacturer ID = A2 02 00 Dell IANA
2052 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2053 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2056 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2057 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2058 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2059 #define DELL_IANA_MFR_ID 0x0002a2
2060 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2062 struct ipmi_device_id *id = &smi_info->device_id;
2063 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
2064 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2065 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2066 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
2067 smi_info->oem_data_avail_handler =
2068 oem_data_avail_to_receive_msg_avail;
2070 else if (ipmi_version_major(id) < 1 ||
2071 (ipmi_version_major(id) == 1 &&
2072 ipmi_version_minor(id) < 5)) {
2073 smi_info->oem_data_avail_handler =
2074 oem_data_avail_to_receive_msg_avail;
2079 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2080 static void return_hosed_msg_badsize(struct smi_info *smi_info)
2082 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2084 /* Make it a reponse */
2085 msg->rsp[0] = msg->data[0] | 4;
2086 msg->rsp[1] = msg->data[1];
2087 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2089 smi_info->curr_msg = NULL;
2090 deliver_recv_msg(smi_info, msg);
2094 * dell_poweredge_bt_xaction_handler
2095 * @info - smi_info.device_id must be populated
2097 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2098 * not respond to a Get SDR command if the length of the data
2099 * requested is exactly 0x3A, which leads to command timeouts and no
2100 * data returned. This intercepts such commands, and causes userspace
2101 * callers to try again with a different-sized buffer, which succeeds.
2104 #define STORAGE_NETFN 0x0A
2105 #define STORAGE_CMD_GET_SDR 0x23
2106 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2107 unsigned long unused,
2110 struct smi_info *smi_info = in;
2111 unsigned char *data = smi_info->curr_msg->data;
2112 unsigned int size = smi_info->curr_msg->data_size;
2114 (data[0]>>2) == STORAGE_NETFN &&
2115 data[1] == STORAGE_CMD_GET_SDR &&
2117 return_hosed_msg_badsize(smi_info);
2123 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2124 .notifier_call = dell_poweredge_bt_xaction_handler,
2128 * setup_dell_poweredge_bt_xaction_handler
2129 * @info - smi_info.device_id must be filled in already
2131 * Fills in smi_info.device_id.start_transaction_pre_hook
2132 * when we know what function to use there.
2135 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2137 struct ipmi_device_id *id = &smi_info->device_id;
2138 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2139 smi_info->si_type == SI_BT)
2140 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2144 * setup_oem_data_handler
2145 * @info - smi_info.device_id must be filled in already
2147 * Fills in smi_info.device_id.oem_data_available_handler
2148 * when we know what function to use there.
2151 static void setup_oem_data_handler(struct smi_info *smi_info)
2153 setup_dell_poweredge_oem_data_handler(smi_info);
2156 static void setup_xaction_handlers(struct smi_info *smi_info)
2158 setup_dell_poweredge_bt_xaction_handler(smi_info);
2161 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2163 if (smi_info->intf) {
2164 /* The timer and thread are only running if the
2165 interface has been started up and registered. */
2166 if (smi_info->thread != NULL)
2167 kthread_stop(smi_info->thread);
2168 del_timer_sync(&smi_info->si_timer);
2172 static __devinitdata struct ipmi_default_vals
2178 { .type = SI_KCS, .port = 0xca2 },
2179 { .type = SI_SMIC, .port = 0xca9 },
2180 { .type = SI_BT, .port = 0xe4 },
2184 static __devinit void default_find_bmc(void)
2186 struct smi_info *info;
2189 for (i = 0; ; i++) {
2190 if (!ipmi_defaults[i].port)
2193 info = kzalloc(sizeof(*info), GFP_KERNEL);
2197 info->addr_source = NULL;
2199 info->si_type = ipmi_defaults[i].type;
2200 info->io_setup = port_setup;
2201 info->io.addr_data = ipmi_defaults[i].port;
2202 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2204 info->io.addr = NULL;
2205 info->io.regspacing = DEFAULT_REGSPACING;
2206 info->io.regsize = DEFAULT_REGSPACING;
2207 info->io.regshift = 0;
2209 if (try_smi_init(info) == 0) {
2211 printk(KERN_INFO "ipmi_si: Found default %s state"
2212 " machine at %s address 0x%lx\n",
2213 si_to_str[info->si_type],
2214 addr_space_to_str[info->io.addr_type],
2215 info->io.addr_data);
2221 static int is_new_interface(struct smi_info *info)
2225 list_for_each_entry(e, &smi_infos, link) {
2226 if (e->io.addr_type != info->io.addr_type)
2228 if (e->io.addr_data == info->io.addr_data)
2235 static int try_smi_init(struct smi_info *new_smi)
2239 if (new_smi->addr_source) {
2240 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2241 " machine at %s address 0x%lx, slave address 0x%x,"
2243 new_smi->addr_source,
2244 si_to_str[new_smi->si_type],
2245 addr_space_to_str[new_smi->io.addr_type],
2246 new_smi->io.addr_data,
2247 new_smi->slave_addr, new_smi->irq);
2250 mutex_lock(&smi_infos_lock);
2251 if (!is_new_interface(new_smi)) {
2252 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2257 /* So we know not to free it unless we have allocated one. */
2258 new_smi->intf = NULL;
2259 new_smi->si_sm = NULL;
2260 new_smi->handlers = NULL;
2262 switch (new_smi->si_type) {
2264 new_smi->handlers = &kcs_smi_handlers;
2268 new_smi->handlers = &smic_smi_handlers;
2272 new_smi->handlers = &bt_smi_handlers;
2276 /* No support for anything else yet. */
2281 /* Allocate the state machine's data and initialize it. */
2282 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2283 if (!new_smi->si_sm) {
2284 printk(" Could not allocate state machine memory\n");
2288 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2291 /* Now that we know the I/O size, we can set up the I/O. */
2292 rv = new_smi->io_setup(new_smi);
2294 printk(" Could not set up I/O space\n");
2298 spin_lock_init(&(new_smi->si_lock));
2299 spin_lock_init(&(new_smi->msg_lock));
2300 spin_lock_init(&(new_smi->count_lock));
2302 /* Do low-level detection first. */
2303 if (new_smi->handlers->detect(new_smi->si_sm)) {
2304 if (new_smi->addr_source)
2305 printk(KERN_INFO "ipmi_si: Interface detection"
2311 /* Attempt a get device id command. If it fails, we probably
2312 don't have a BMC here. */
2313 rv = try_get_dev_id(new_smi);
2315 if (new_smi->addr_source)
2316 printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2317 " at this location\n");
2321 setup_oem_data_handler(new_smi);
2322 setup_xaction_handlers(new_smi);
2324 /* Try to claim any interrupts. */
2325 if (new_smi->irq_setup)
2326 new_smi->irq_setup(new_smi);
2328 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2329 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2330 new_smi->curr_msg = NULL;
2331 atomic_set(&new_smi->req_events, 0);
2332 new_smi->run_to_completion = 0;
2334 new_smi->interrupt_disabled = 0;
2335 atomic_set(&new_smi->stop_operation, 0);
2336 new_smi->intf_num = smi_num;
2339 /* Start clearing the flags before we enable interrupts or the
2340 timer to avoid racing with the timer. */
2341 start_clear_flags(new_smi);
2342 /* IRQ is defined to be set when non-zero. */
2344 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2346 if (!new_smi->dev) {
2347 /* If we don't already have a device from something
2348 * else (like PCI), then register a new one. */
2349 new_smi->pdev = platform_device_alloc("ipmi_si",
2354 " Unable to allocate platform device\n");
2357 new_smi->dev = &new_smi->pdev->dev;
2358 new_smi->dev->driver = &ipmi_driver;
2360 rv = platform_device_add(new_smi->pdev);
2364 " Unable to register system interface device:"
2369 new_smi->dev_registered = 1;
2372 rv = ipmi_register_smi(&handlers,
2374 &new_smi->device_id,
2377 new_smi->slave_addr);
2380 "ipmi_si: Unable to register device: error %d\n",
2382 goto out_err_stop_timer;
2385 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2386 type_file_read_proc, NULL,
2387 new_smi, THIS_MODULE);
2390 "ipmi_si: Unable to create proc entry: %d\n",
2392 goto out_err_stop_timer;
2395 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2396 stat_file_read_proc, NULL,
2397 new_smi, THIS_MODULE);
2400 "ipmi_si: Unable to create proc entry: %d\n",
2402 goto out_err_stop_timer;
2405 list_add_tail(&new_smi->link, &smi_infos);
2407 mutex_unlock(&smi_infos_lock);
2409 printk(" IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
2414 atomic_inc(&new_smi->stop_operation);
2415 wait_for_timer_and_thread(new_smi);
2419 ipmi_unregister_smi(new_smi->intf);
2421 if (new_smi->irq_cleanup)
2422 new_smi->irq_cleanup(new_smi);
2424 /* Wait until we know that we are out of any interrupt
2425 handlers might have been running before we freed the
2427 synchronize_sched();
2429 if (new_smi->si_sm) {
2430 if (new_smi->handlers)
2431 new_smi->handlers->cleanup(new_smi->si_sm);
2432 kfree(new_smi->si_sm);
2434 if (new_smi->addr_source_cleanup)
2435 new_smi->addr_source_cleanup(new_smi);
2436 if (new_smi->io_cleanup)
2437 new_smi->io_cleanup(new_smi);
2439 if (new_smi->dev_registered)
2440 platform_device_unregister(new_smi->pdev);
2444 mutex_unlock(&smi_infos_lock);
2449 static __devinit int init_ipmi_si(void)
2459 /* Register the device drivers. */
2460 rv = driver_register(&ipmi_driver);
2463 "init_ipmi_si: Unable to register driver: %d\n",
2469 /* Parse out the si_type string into its components. */
2472 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
2474 str = strchr(str, ',');
2484 printk(KERN_INFO "IPMI System Interface driver.\n");
2486 hardcode_find_bmc();
2498 pci_module_init(&ipmi_pci_driver);
2501 if (si_trydefaults) {
2502 mutex_lock(&smi_infos_lock);
2503 if (list_empty(&smi_infos)) {
2504 /* No BMC was found, try defaults. */
2505 mutex_unlock(&smi_infos_lock);
2508 mutex_unlock(&smi_infos_lock);
2512 mutex_lock(&smi_infos_lock);
2513 if (list_empty(&smi_infos)) {
2514 mutex_unlock(&smi_infos_lock);
2516 pci_unregister_driver(&ipmi_pci_driver);
2518 driver_unregister(&ipmi_driver);
2519 printk("ipmi_si: Unable to find any System Interface(s)\n");
2522 mutex_unlock(&smi_infos_lock);
2526 module_init(init_ipmi_si);
2528 static void __devexit cleanup_one_si(struct smi_info *to_clean)
2531 unsigned long flags;
2536 list_del(&to_clean->link);
2538 /* Tell the timer and interrupt handlers that we are shutting
2540 spin_lock_irqsave(&(to_clean->si_lock), flags);
2541 spin_lock(&(to_clean->msg_lock));
2543 atomic_inc(&to_clean->stop_operation);
2545 if (to_clean->irq_cleanup)
2546 to_clean->irq_cleanup(to_clean);
2548 spin_unlock(&(to_clean->msg_lock));
2549 spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2551 /* Wait until we know that we are out of any interrupt
2552 handlers might have been running before we freed the
2554 synchronize_sched();
2556 wait_for_timer_and_thread(to_clean);
2558 /* Interrupts and timeouts are stopped, now make sure the
2559 interface is in a clean state. */
2560 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
2562 schedule_timeout_uninterruptible(1);
2565 rv = ipmi_unregister_smi(to_clean->intf);
2568 "ipmi_si: Unable to unregister device: errno=%d\n",
2572 to_clean->handlers->cleanup(to_clean->si_sm);
2574 kfree(to_clean->si_sm);
2576 if (to_clean->addr_source_cleanup)
2577 to_clean->addr_source_cleanup(to_clean);
2578 if (to_clean->io_cleanup)
2579 to_clean->io_cleanup(to_clean);
2581 if (to_clean->dev_registered)
2582 platform_device_unregister(to_clean->pdev);
2587 static __exit void cleanup_ipmi_si(void)
2589 struct smi_info *e, *tmp_e;
2595 pci_unregister_driver(&ipmi_pci_driver);
2598 mutex_lock(&smi_infos_lock);
2599 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2601 mutex_unlock(&smi_infos_lock);
2603 driver_unregister(&ipmi_driver);
2605 module_exit(cleanup_ipmi_si);
2607 MODULE_LICENSE("GPL");
2608 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2609 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");