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;
811 * Make sure there is some delay in the poll loop so we can
812 * drive time forward and timeout things.
815 smi_event_handler(smi_info, 10);
818 static void request_events(void *send_info)
820 struct smi_info *smi_info = send_info;
822 atomic_set(&smi_info->req_events, 1);
825 static int initialized = 0;
827 static void smi_timeout(unsigned long data)
829 struct smi_info *smi_info = (struct smi_info *) data;
830 enum si_sm_result smi_result;
832 unsigned long jiffies_now;
838 if (atomic_read(&smi_info->stop_operation))
841 spin_lock_irqsave(&(smi_info->si_lock), flags);
844 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
846 jiffies_now = jiffies;
847 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
848 * SI_USEC_PER_JIFFY);
849 smi_result = smi_event_handler(smi_info, time_diff);
851 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
853 smi_info->last_timeout_jiffies = jiffies_now;
855 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
856 /* Running with interrupts, only do long timeouts. */
857 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
858 spin_lock_irqsave(&smi_info->count_lock, flags);
859 smi_info->long_timeouts++;
860 spin_unlock_irqrestore(&smi_info->count_lock, flags);
864 /* If the state machine asks for a short delay, then shorten
865 the timer timeout. */
866 if (smi_result == SI_SM_CALL_WITH_DELAY) {
867 spin_lock_irqsave(&smi_info->count_lock, flags);
868 smi_info->short_timeouts++;
869 spin_unlock_irqrestore(&smi_info->count_lock, flags);
870 smi_info->si_timer.expires = jiffies + 1;
872 spin_lock_irqsave(&smi_info->count_lock, flags);
873 smi_info->long_timeouts++;
874 spin_unlock_irqrestore(&smi_info->count_lock, flags);
875 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
879 add_timer(&(smi_info->si_timer));
882 static irqreturn_t si_irq_handler(int irq, void *data)
884 struct smi_info *smi_info = data;
890 spin_lock_irqsave(&(smi_info->si_lock), flags);
892 spin_lock(&smi_info->count_lock);
893 smi_info->interrupts++;
894 spin_unlock(&smi_info->count_lock);
896 if (atomic_read(&smi_info->stop_operation))
901 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
903 smi_event_handler(smi_info, 0);
905 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
909 static irqreturn_t si_bt_irq_handler(int irq, void *data)
911 struct smi_info *smi_info = data;
912 /* We need to clear the IRQ flag for the BT interface. */
913 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
914 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
915 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
916 return si_irq_handler(irq, data);
919 static int smi_start_processing(void *send_info,
922 struct smi_info *new_smi = send_info;
925 new_smi->intf = intf;
927 /* Set up the timer that drives the interface. */
928 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
929 new_smi->last_timeout_jiffies = jiffies;
930 mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
933 * Check if the user forcefully enabled the daemon.
935 if (new_smi->intf_num < num_force_kipmid)
936 enable = force_kipmid[new_smi->intf_num];
938 * The BT interface is efficient enough to not need a thread,
939 * and there is no need for a thread if we have interrupts.
941 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
945 new_smi->thread = kthread_run(ipmi_thread, new_smi,
946 "kipmi%d", new_smi->intf_num);
947 if (IS_ERR(new_smi->thread)) {
948 printk(KERN_NOTICE "ipmi_si_intf: Could not start"
949 " kernel thread due to error %ld, only using"
950 " timers to drive the interface\n",
951 PTR_ERR(new_smi->thread));
952 new_smi->thread = NULL;
959 static void set_maintenance_mode(void *send_info, int enable)
961 struct smi_info *smi_info = send_info;
964 atomic_set(&smi_info->req_events, 0);
967 static struct ipmi_smi_handlers handlers =
969 .owner = THIS_MODULE,
970 .start_processing = smi_start_processing,
972 .request_events = request_events,
973 .set_maintenance_mode = set_maintenance_mode,
974 .set_run_to_completion = set_run_to_completion,
978 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
979 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
981 static LIST_HEAD(smi_infos);
982 static DEFINE_MUTEX(smi_infos_lock);
983 static int smi_num; /* Used to sequence the SMIs */
985 #define DEFAULT_REGSPACING 1
987 static int si_trydefaults = 1;
988 static char *si_type[SI_MAX_PARMS];
989 #define MAX_SI_TYPE_STR 30
990 static char si_type_str[MAX_SI_TYPE_STR];
991 static unsigned long addrs[SI_MAX_PARMS];
992 static int num_addrs;
993 static unsigned int ports[SI_MAX_PARMS];
994 static int num_ports;
995 static int irqs[SI_MAX_PARMS];
997 static int regspacings[SI_MAX_PARMS];
998 static int num_regspacings = 0;
999 static int regsizes[SI_MAX_PARMS];
1000 static int num_regsizes = 0;
1001 static int regshifts[SI_MAX_PARMS];
1002 static int num_regshifts = 0;
1003 static int slave_addrs[SI_MAX_PARMS];
1004 static int num_slave_addrs = 0;
1007 module_param_named(trydefaults, si_trydefaults, bool, 0);
1008 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1009 " default scan of the KCS and SMIC interface at the standard"
1011 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1012 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1013 " interface separated by commas. The types are 'kcs',"
1014 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1015 " the first interface to kcs and the second to bt");
1016 module_param_array(addrs, long, &num_addrs, 0);
1017 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1018 " addresses separated by commas. Only use if an interface"
1019 " is in memory. Otherwise, set it to zero or leave"
1021 module_param_array(ports, int, &num_ports, 0);
1022 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1023 " addresses separated by commas. Only use if an interface"
1024 " is a port. Otherwise, set it to zero or leave"
1026 module_param_array(irqs, int, &num_irqs, 0);
1027 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1028 " addresses separated by commas. Only use if an interface"
1029 " has an interrupt. Otherwise, set it to zero or leave"
1031 module_param_array(regspacings, int, &num_regspacings, 0);
1032 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1033 " and each successive register used by the interface. For"
1034 " instance, if the start address is 0xca2 and the spacing"
1035 " is 2, then the second address is at 0xca4. Defaults"
1037 module_param_array(regsizes, int, &num_regsizes, 0);
1038 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1039 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1040 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1041 " the 8-bit IPMI register has to be read from a larger"
1043 module_param_array(regshifts, int, &num_regshifts, 0);
1044 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1045 " IPMI register, in bits. For instance, if the data"
1046 " is read from a 32-bit word and the IPMI data is in"
1047 " bit 8-15, then the shift would be 8");
1048 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1049 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1050 " the controller. Normally this is 0x20, but can be"
1051 " overridden by this parm. This is an array indexed"
1052 " by interface number.");
1053 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1054 MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1055 " disabled(0). Normally the IPMI driver auto-detects"
1056 " this, but the value may be overridden by this parm.");
1059 #define IPMI_IO_ADDR_SPACE 0
1060 #define IPMI_MEM_ADDR_SPACE 1
1061 static char *addr_space_to_str[] = { "I/O", "memory" };
1063 static void std_irq_cleanup(struct smi_info *info)
1065 if (info->si_type == SI_BT)
1066 /* Disable the interrupt in the BT interface. */
1067 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1068 free_irq(info->irq, info);
1071 static int std_irq_setup(struct smi_info *info)
1078 if (info->si_type == SI_BT) {
1079 rv = request_irq(info->irq,
1085 /* Enable the interrupt in the BT interface. */
1086 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1087 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1089 rv = request_irq(info->irq,
1096 "ipmi_si: %s unable to claim interrupt %d,"
1097 " running polled\n",
1098 DEVICE_NAME, info->irq);
1101 info->irq_cleanup = std_irq_cleanup;
1102 printk(" Using irq %d\n", info->irq);
1108 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1110 unsigned int addr = io->addr_data;
1112 return inb(addr + (offset * io->regspacing));
1115 static void port_outb(struct si_sm_io *io, unsigned int offset,
1118 unsigned int addr = io->addr_data;
1120 outb(b, addr + (offset * io->regspacing));
1123 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1125 unsigned int addr = io->addr_data;
1127 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1130 static void port_outw(struct si_sm_io *io, unsigned int offset,
1133 unsigned int addr = io->addr_data;
1135 outw(b << io->regshift, addr + (offset * io->regspacing));
1138 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1140 unsigned int addr = io->addr_data;
1142 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1145 static void port_outl(struct si_sm_io *io, unsigned int offset,
1148 unsigned int addr = io->addr_data;
1150 outl(b << io->regshift, addr+(offset * io->regspacing));
1153 static void port_cleanup(struct smi_info *info)
1155 unsigned int addr = info->io.addr_data;
1159 for (idx = 0; idx < info->io_size; idx++) {
1160 release_region(addr + idx * info->io.regspacing,
1166 static int port_setup(struct smi_info *info)
1168 unsigned int addr = info->io.addr_data;
1174 info->io_cleanup = port_cleanup;
1176 /* Figure out the actual inb/inw/inl/etc routine to use based
1177 upon the register size. */
1178 switch (info->io.regsize) {
1180 info->io.inputb = port_inb;
1181 info->io.outputb = port_outb;
1184 info->io.inputb = port_inw;
1185 info->io.outputb = port_outw;
1188 info->io.inputb = port_inl;
1189 info->io.outputb = port_outl;
1192 printk("ipmi_si: Invalid register size: %d\n",
1197 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1198 * tables. This causes problems when trying to register the
1199 * entire I/O region. Therefore we must register each I/O
1202 for (idx = 0; idx < info->io_size; idx++) {
1203 if (request_region(addr + idx * info->io.regspacing,
1204 info->io.regsize, DEVICE_NAME) == NULL) {
1205 /* Undo allocations */
1207 release_region(addr + idx * info->io.regspacing,
1216 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1218 return readb((io->addr)+(offset * io->regspacing));
1221 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1224 writeb(b, (io->addr)+(offset * io->regspacing));
1227 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1229 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1233 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1236 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1239 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1241 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1245 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1248 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1252 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1254 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1258 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1261 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1265 static void mem_cleanup(struct smi_info *info)
1267 unsigned long addr = info->io.addr_data;
1270 if (info->io.addr) {
1271 iounmap(info->io.addr);
1273 mapsize = ((info->io_size * info->io.regspacing)
1274 - (info->io.regspacing - info->io.regsize));
1276 release_mem_region(addr, mapsize);
1280 static int mem_setup(struct smi_info *info)
1282 unsigned long addr = info->io.addr_data;
1288 info->io_cleanup = mem_cleanup;
1290 /* Figure out the actual readb/readw/readl/etc routine to use based
1291 upon the register size. */
1292 switch (info->io.regsize) {
1294 info->io.inputb = intf_mem_inb;
1295 info->io.outputb = intf_mem_outb;
1298 info->io.inputb = intf_mem_inw;
1299 info->io.outputb = intf_mem_outw;
1302 info->io.inputb = intf_mem_inl;
1303 info->io.outputb = intf_mem_outl;
1307 info->io.inputb = mem_inq;
1308 info->io.outputb = mem_outq;
1312 printk("ipmi_si: Invalid register size: %d\n",
1317 /* Calculate the total amount of memory to claim. This is an
1318 * unusual looking calculation, but it avoids claiming any
1319 * more memory than it has to. It will claim everything
1320 * between the first address to the end of the last full
1322 mapsize = ((info->io_size * info->io.regspacing)
1323 - (info->io.regspacing - info->io.regsize));
1325 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1328 info->io.addr = ioremap(addr, mapsize);
1329 if (info->io.addr == NULL) {
1330 release_mem_region(addr, mapsize);
1337 static __devinit void hardcode_find_bmc(void)
1340 struct smi_info *info;
1342 for (i = 0; i < SI_MAX_PARMS; i++) {
1343 if (!ports[i] && !addrs[i])
1346 info = kzalloc(sizeof(*info), GFP_KERNEL);
1350 info->addr_source = "hardcoded";
1352 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1353 info->si_type = SI_KCS;
1354 } else if (strcmp(si_type[i], "smic") == 0) {
1355 info->si_type = SI_SMIC;
1356 } else if (strcmp(si_type[i], "bt") == 0) {
1357 info->si_type = SI_BT;
1360 "ipmi_si: Interface type specified "
1361 "for interface %d, was invalid: %s\n",
1369 info->io_setup = port_setup;
1370 info->io.addr_data = ports[i];
1371 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1372 } else if (addrs[i]) {
1374 info->io_setup = mem_setup;
1375 info->io.addr_data = addrs[i];
1376 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1379 "ipmi_si: Interface type specified "
1380 "for interface %d, "
1381 "but port and address were not set or "
1382 "set to zero.\n", i);
1387 info->io.addr = NULL;
1388 info->io.regspacing = regspacings[i];
1389 if (!info->io.regspacing)
1390 info->io.regspacing = DEFAULT_REGSPACING;
1391 info->io.regsize = regsizes[i];
1392 if (!info->io.regsize)
1393 info->io.regsize = DEFAULT_REGSPACING;
1394 info->io.regshift = regshifts[i];
1395 info->irq = irqs[i];
1397 info->irq_setup = std_irq_setup;
1405 #include <linux/acpi.h>
1407 /* Once we get an ACPI failure, we don't try any more, because we go
1408 through the tables sequentially. Once we don't find a table, there
1410 static int acpi_failure = 0;
1412 /* For GPE-type interrupts. */
1413 static u32 ipmi_acpi_gpe(void *context)
1415 struct smi_info *smi_info = context;
1416 unsigned long flags;
1421 spin_lock_irqsave(&(smi_info->si_lock), flags);
1423 spin_lock(&smi_info->count_lock);
1424 smi_info->interrupts++;
1425 spin_unlock(&smi_info->count_lock);
1427 if (atomic_read(&smi_info->stop_operation))
1431 do_gettimeofday(&t);
1432 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1434 smi_event_handler(smi_info, 0);
1436 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1438 return ACPI_INTERRUPT_HANDLED;
1441 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1446 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1449 static int acpi_gpe_irq_setup(struct smi_info *info)
1456 /* FIXME - is level triggered right? */
1457 status = acpi_install_gpe_handler(NULL,
1459 ACPI_GPE_LEVEL_TRIGGERED,
1462 if (status != AE_OK) {
1464 "ipmi_si: %s unable to claim ACPI GPE %d,"
1465 " running polled\n",
1466 DEVICE_NAME, info->irq);
1470 info->irq_cleanup = acpi_gpe_irq_cleanup;
1471 printk(" Using ACPI GPE %d\n", info->irq);
1478 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1489 s8 CreatorRevision[4];
1492 s16 SpecificationRevision;
1495 * Bit 0 - SCI interrupt supported
1496 * Bit 1 - I/O APIC/SAPIC
1500 /* If bit 0 of InterruptType is set, then this is the SCI
1501 interrupt in the GPEx_STS register. */
1506 /* If bit 1 of InterruptType is set, then this is the I/O
1507 APIC/SAPIC interrupt. */
1508 u32 GlobalSystemInterrupt;
1510 /* The actual register address. */
1511 struct acpi_generic_address addr;
1515 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1518 static __devinit int try_init_acpi(struct SPMITable *spmi)
1520 struct smi_info *info;
1524 if (spmi->IPMIlegacy != 1) {
1525 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1529 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1530 addr_space = IPMI_MEM_ADDR_SPACE;
1532 addr_space = IPMI_IO_ADDR_SPACE;
1534 info = kzalloc(sizeof(*info), GFP_KERNEL);
1536 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1540 info->addr_source = "ACPI";
1542 /* Figure out the interface type. */
1543 switch (spmi->InterfaceType)
1546 info->si_type = SI_KCS;
1549 info->si_type = SI_SMIC;
1552 info->si_type = SI_BT;
1555 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1556 spmi->InterfaceType);
1561 if (spmi->InterruptType & 1) {
1562 /* We've got a GPE interrupt. */
1563 info->irq = spmi->GPE;
1564 info->irq_setup = acpi_gpe_irq_setup;
1565 } else if (spmi->InterruptType & 2) {
1566 /* We've got an APIC/SAPIC interrupt. */
1567 info->irq = spmi->GlobalSystemInterrupt;
1568 info->irq_setup = std_irq_setup;
1570 /* Use the default interrupt setting. */
1572 info->irq_setup = NULL;
1575 if (spmi->addr.register_bit_width) {
1576 /* A (hopefully) properly formed register bit width. */
1577 info->io.regspacing = spmi->addr.register_bit_width / 8;
1579 info->io.regspacing = DEFAULT_REGSPACING;
1581 info->io.regsize = info->io.regspacing;
1582 info->io.regshift = spmi->addr.register_bit_offset;
1584 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1586 info->io_setup = mem_setup;
1587 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1588 } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1590 info->io_setup = port_setup;
1591 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1594 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1597 info->io.addr_data = spmi->addr.address;
1604 static __devinit void acpi_find_bmc(void)
1607 struct SPMITable *spmi;
1616 for (i = 0; ; i++) {
1617 status = acpi_get_firmware_table("SPMI", i+1,
1618 ACPI_LOGICAL_ADDRESSING,
1619 (struct acpi_table_header **)
1621 if (status != AE_OK)
1624 try_init_acpi(spmi);
1630 struct dmi_ipmi_data
1634 unsigned long base_addr;
1640 static int __devinit decode_dmi(struct dmi_header *dm,
1641 struct dmi_ipmi_data *dmi)
1643 u8 *data = (u8 *)dm;
1644 unsigned long base_addr;
1646 u8 len = dm->length;
1648 dmi->type = data[4];
1650 memcpy(&base_addr, data+8, sizeof(unsigned long));
1652 if (base_addr & 1) {
1654 base_addr &= 0xFFFE;
1655 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1659 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1661 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1663 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1665 dmi->irq = data[0x11];
1667 /* The top two bits of byte 0x10 hold the register spacing. */
1668 reg_spacing = (data[0x10] & 0xC0) >> 6;
1669 switch(reg_spacing){
1670 case 0x00: /* Byte boundaries */
1673 case 0x01: /* 32-bit boundaries */
1676 case 0x02: /* 16-byte boundaries */
1680 /* Some other interface, just ignore it. */
1685 /* Note that technically, the lower bit of the base
1686 * address should be 1 if the address is I/O and 0 if
1687 * the address is in memory. So many systems get that
1688 * wrong (and all that I have seen are I/O) so we just
1689 * ignore that bit and assume I/O. Systems that use
1690 * memory should use the newer spec, anyway. */
1691 dmi->base_addr = base_addr & 0xfffe;
1692 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1696 dmi->slave_addr = data[6];
1701 static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
1703 struct smi_info *info;
1705 info = kzalloc(sizeof(*info), GFP_KERNEL);
1708 "ipmi_si: Could not allocate SI data\n");
1712 info->addr_source = "SMBIOS";
1714 switch (ipmi_data->type) {
1715 case 0x01: /* KCS */
1716 info->si_type = SI_KCS;
1718 case 0x02: /* SMIC */
1719 info->si_type = SI_SMIC;
1722 info->si_type = SI_BT;
1728 switch (ipmi_data->addr_space) {
1729 case IPMI_MEM_ADDR_SPACE:
1730 info->io_setup = mem_setup;
1731 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1734 case IPMI_IO_ADDR_SPACE:
1735 info->io_setup = port_setup;
1736 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1742 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
1743 ipmi_data->addr_space);
1746 info->io.addr_data = ipmi_data->base_addr;
1748 info->io.regspacing = ipmi_data->offset;
1749 if (!info->io.regspacing)
1750 info->io.regspacing = DEFAULT_REGSPACING;
1751 info->io.regsize = DEFAULT_REGSPACING;
1752 info->io.regshift = 0;
1754 info->slave_addr = ipmi_data->slave_addr;
1756 info->irq = ipmi_data->irq;
1758 info->irq_setup = std_irq_setup;
1763 static void __devinit dmi_find_bmc(void)
1765 struct dmi_device *dev = NULL;
1766 struct dmi_ipmi_data data;
1769 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
1770 memset(&data, 0, sizeof(data));
1771 rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
1773 try_init_dmi(&data);
1776 #endif /* CONFIG_DMI */
1780 #define PCI_ERMC_CLASSCODE 0x0C0700
1781 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
1782 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
1783 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
1784 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
1785 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
1787 #define PCI_HP_VENDOR_ID 0x103C
1788 #define PCI_MMC_DEVICE_ID 0x121A
1789 #define PCI_MMC_ADDR_CW 0x10
1791 static void ipmi_pci_cleanup(struct smi_info *info)
1793 struct pci_dev *pdev = info->addr_source_data;
1795 pci_disable_device(pdev);
1798 static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
1799 const struct pci_device_id *ent)
1802 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
1803 struct smi_info *info;
1804 int first_reg_offset = 0;
1806 info = kzalloc(sizeof(*info), GFP_KERNEL);
1810 info->addr_source = "PCI";
1812 switch (class_type) {
1813 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
1814 info->si_type = SI_SMIC;
1817 case PCI_ERMC_CLASSCODE_TYPE_KCS:
1818 info->si_type = SI_KCS;
1821 case PCI_ERMC_CLASSCODE_TYPE_BT:
1822 info->si_type = SI_BT;
1827 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
1828 pci_name(pdev), class_type);
1832 rv = pci_enable_device(pdev);
1834 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
1840 info->addr_source_cleanup = ipmi_pci_cleanup;
1841 info->addr_source_data = pdev;
1843 if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
1844 first_reg_offset = 1;
1846 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
1847 info->io_setup = port_setup;
1848 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1850 info->io_setup = mem_setup;
1851 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1853 info->io.addr_data = pci_resource_start(pdev, 0);
1855 info->io.regspacing = DEFAULT_REGSPACING;
1856 info->io.regsize = DEFAULT_REGSPACING;
1857 info->io.regshift = 0;
1859 info->irq = pdev->irq;
1861 info->irq_setup = std_irq_setup;
1863 info->dev = &pdev->dev;
1865 return try_smi_init(info);
1868 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
1873 static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
1878 static int ipmi_pci_resume(struct pci_dev *pdev)
1884 static struct pci_device_id ipmi_pci_devices[] = {
1885 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
1886 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) }
1888 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
1890 static struct pci_driver ipmi_pci_driver = {
1891 .name = DEVICE_NAME,
1892 .id_table = ipmi_pci_devices,
1893 .probe = ipmi_pci_probe,
1894 .remove = __devexit_p(ipmi_pci_remove),
1896 .suspend = ipmi_pci_suspend,
1897 .resume = ipmi_pci_resume,
1900 #endif /* CONFIG_PCI */
1903 static int try_get_dev_id(struct smi_info *smi_info)
1905 unsigned char msg[2];
1906 unsigned char *resp;
1907 unsigned long resp_len;
1908 enum si_sm_result smi_result;
1911 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1915 /* Do a Get Device ID command, since it comes back with some
1917 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1918 msg[1] = IPMI_GET_DEVICE_ID_CMD;
1919 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1921 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1924 if (smi_result == SI_SM_CALL_WITH_DELAY ||
1925 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1926 schedule_timeout_uninterruptible(1);
1927 smi_result = smi_info->handlers->event(
1928 smi_info->si_sm, 100);
1930 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1932 smi_result = smi_info->handlers->event(
1933 smi_info->si_sm, 0);
1938 if (smi_result == SI_SM_HOSED) {
1939 /* We couldn't get the state machine to run, so whatever's at
1940 the port is probably not an IPMI SMI interface. */
1945 /* Otherwise, we got some data. */
1946 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1947 resp, IPMI_MAX_MSG_LENGTH);
1948 if (resp_len < 14) {
1949 /* That's odd, it should be longer. */
1954 if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
1955 /* That's odd, it shouldn't be able to fail. */
1960 /* Record info from the get device id, in case we need it. */
1961 ipmi_demangle_device_id(resp+3, resp_len-3, &smi_info->device_id);
1968 static int type_file_read_proc(char *page, char **start, off_t off,
1969 int count, int *eof, void *data)
1971 char *out = (char *) page;
1972 struct smi_info *smi = data;
1974 switch (smi->si_type) {
1976 return sprintf(out, "kcs\n");
1978 return sprintf(out, "smic\n");
1980 return sprintf(out, "bt\n");
1986 static int stat_file_read_proc(char *page, char **start, off_t off,
1987 int count, int *eof, void *data)
1989 char *out = (char *) page;
1990 struct smi_info *smi = data;
1992 out += sprintf(out, "interrupts_enabled: %d\n",
1993 smi->irq && !smi->interrupt_disabled);
1994 out += sprintf(out, "short_timeouts: %ld\n",
1995 smi->short_timeouts);
1996 out += sprintf(out, "long_timeouts: %ld\n",
1997 smi->long_timeouts);
1998 out += sprintf(out, "timeout_restarts: %ld\n",
1999 smi->timeout_restarts);
2000 out += sprintf(out, "idles: %ld\n",
2002 out += sprintf(out, "interrupts: %ld\n",
2004 out += sprintf(out, "attentions: %ld\n",
2006 out += sprintf(out, "flag_fetches: %ld\n",
2008 out += sprintf(out, "hosed_count: %ld\n",
2010 out += sprintf(out, "complete_transactions: %ld\n",
2011 smi->complete_transactions);
2012 out += sprintf(out, "events: %ld\n",
2014 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
2015 smi->watchdog_pretimeouts);
2016 out += sprintf(out, "incoming_messages: %ld\n",
2017 smi->incoming_messages);
2019 return (out - ((char *) page));
2023 * oem_data_avail_to_receive_msg_avail
2024 * @info - smi_info structure with msg_flags set
2026 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2027 * Returns 1 indicating need to re-run handle_flags().
2029 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2031 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2037 * setup_dell_poweredge_oem_data_handler
2038 * @info - smi_info.device_id must be populated
2040 * Systems that match, but have firmware version < 1.40 may assert
2041 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2042 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2043 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2044 * as RECEIVE_MSG_AVAIL instead.
2046 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2047 * assert the OEM[012] bits, and if it did, the driver would have to
2048 * change to handle that properly, we don't actually check for the
2050 * Device ID = 0x20 BMC on PowerEdge 8G servers
2051 * Device Revision = 0x80
2052 * Firmware Revision1 = 0x01 BMC version 1.40
2053 * Firmware Revision2 = 0x40 BCD encoded
2054 * IPMI Version = 0x51 IPMI 1.5
2055 * Manufacturer ID = A2 02 00 Dell IANA
2057 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2058 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2061 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2062 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2063 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2064 #define DELL_IANA_MFR_ID 0x0002a2
2065 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2067 struct ipmi_device_id *id = &smi_info->device_id;
2068 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
2069 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2070 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2071 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
2072 smi_info->oem_data_avail_handler =
2073 oem_data_avail_to_receive_msg_avail;
2075 else if (ipmi_version_major(id) < 1 ||
2076 (ipmi_version_major(id) == 1 &&
2077 ipmi_version_minor(id) < 5)) {
2078 smi_info->oem_data_avail_handler =
2079 oem_data_avail_to_receive_msg_avail;
2084 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2085 static void return_hosed_msg_badsize(struct smi_info *smi_info)
2087 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2089 /* Make it a reponse */
2090 msg->rsp[0] = msg->data[0] | 4;
2091 msg->rsp[1] = msg->data[1];
2092 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2094 smi_info->curr_msg = NULL;
2095 deliver_recv_msg(smi_info, msg);
2099 * dell_poweredge_bt_xaction_handler
2100 * @info - smi_info.device_id must be populated
2102 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2103 * not respond to a Get SDR command if the length of the data
2104 * requested is exactly 0x3A, which leads to command timeouts and no
2105 * data returned. This intercepts such commands, and causes userspace
2106 * callers to try again with a different-sized buffer, which succeeds.
2109 #define STORAGE_NETFN 0x0A
2110 #define STORAGE_CMD_GET_SDR 0x23
2111 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2112 unsigned long unused,
2115 struct smi_info *smi_info = in;
2116 unsigned char *data = smi_info->curr_msg->data;
2117 unsigned int size = smi_info->curr_msg->data_size;
2119 (data[0]>>2) == STORAGE_NETFN &&
2120 data[1] == STORAGE_CMD_GET_SDR &&
2122 return_hosed_msg_badsize(smi_info);
2128 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2129 .notifier_call = dell_poweredge_bt_xaction_handler,
2133 * setup_dell_poweredge_bt_xaction_handler
2134 * @info - smi_info.device_id must be filled in already
2136 * Fills in smi_info.device_id.start_transaction_pre_hook
2137 * when we know what function to use there.
2140 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2142 struct ipmi_device_id *id = &smi_info->device_id;
2143 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2144 smi_info->si_type == SI_BT)
2145 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2149 * setup_oem_data_handler
2150 * @info - smi_info.device_id must be filled in already
2152 * Fills in smi_info.device_id.oem_data_available_handler
2153 * when we know what function to use there.
2156 static void setup_oem_data_handler(struct smi_info *smi_info)
2158 setup_dell_poweredge_oem_data_handler(smi_info);
2161 static void setup_xaction_handlers(struct smi_info *smi_info)
2163 setup_dell_poweredge_bt_xaction_handler(smi_info);
2166 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2168 if (smi_info->intf) {
2169 /* The timer and thread are only running if the
2170 interface has been started up and registered. */
2171 if (smi_info->thread != NULL)
2172 kthread_stop(smi_info->thread);
2173 del_timer_sync(&smi_info->si_timer);
2177 static __devinitdata struct ipmi_default_vals
2183 { .type = SI_KCS, .port = 0xca2 },
2184 { .type = SI_SMIC, .port = 0xca9 },
2185 { .type = SI_BT, .port = 0xe4 },
2189 static __devinit void default_find_bmc(void)
2191 struct smi_info *info;
2194 for (i = 0; ; i++) {
2195 if (!ipmi_defaults[i].port)
2198 info = kzalloc(sizeof(*info), GFP_KERNEL);
2202 info->addr_source = NULL;
2204 info->si_type = ipmi_defaults[i].type;
2205 info->io_setup = port_setup;
2206 info->io.addr_data = ipmi_defaults[i].port;
2207 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2209 info->io.addr = NULL;
2210 info->io.regspacing = DEFAULT_REGSPACING;
2211 info->io.regsize = DEFAULT_REGSPACING;
2212 info->io.regshift = 0;
2214 if (try_smi_init(info) == 0) {
2216 printk(KERN_INFO "ipmi_si: Found default %s state"
2217 " machine at %s address 0x%lx\n",
2218 si_to_str[info->si_type],
2219 addr_space_to_str[info->io.addr_type],
2220 info->io.addr_data);
2226 static int is_new_interface(struct smi_info *info)
2230 list_for_each_entry(e, &smi_infos, link) {
2231 if (e->io.addr_type != info->io.addr_type)
2233 if (e->io.addr_data == info->io.addr_data)
2240 static int try_smi_init(struct smi_info *new_smi)
2244 if (new_smi->addr_source) {
2245 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2246 " machine at %s address 0x%lx, slave address 0x%x,"
2248 new_smi->addr_source,
2249 si_to_str[new_smi->si_type],
2250 addr_space_to_str[new_smi->io.addr_type],
2251 new_smi->io.addr_data,
2252 new_smi->slave_addr, new_smi->irq);
2255 mutex_lock(&smi_infos_lock);
2256 if (!is_new_interface(new_smi)) {
2257 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2262 /* So we know not to free it unless we have allocated one. */
2263 new_smi->intf = NULL;
2264 new_smi->si_sm = NULL;
2265 new_smi->handlers = NULL;
2267 switch (new_smi->si_type) {
2269 new_smi->handlers = &kcs_smi_handlers;
2273 new_smi->handlers = &smic_smi_handlers;
2277 new_smi->handlers = &bt_smi_handlers;
2281 /* No support for anything else yet. */
2286 /* Allocate the state machine's data and initialize it. */
2287 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2288 if (!new_smi->si_sm) {
2289 printk(" Could not allocate state machine memory\n");
2293 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2296 /* Now that we know the I/O size, we can set up the I/O. */
2297 rv = new_smi->io_setup(new_smi);
2299 printk(" Could not set up I/O space\n");
2303 spin_lock_init(&(new_smi->si_lock));
2304 spin_lock_init(&(new_smi->msg_lock));
2305 spin_lock_init(&(new_smi->count_lock));
2307 /* Do low-level detection first. */
2308 if (new_smi->handlers->detect(new_smi->si_sm)) {
2309 if (new_smi->addr_source)
2310 printk(KERN_INFO "ipmi_si: Interface detection"
2316 /* Attempt a get device id command. If it fails, we probably
2317 don't have a BMC here. */
2318 rv = try_get_dev_id(new_smi);
2320 if (new_smi->addr_source)
2321 printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2322 " at this location\n");
2326 setup_oem_data_handler(new_smi);
2327 setup_xaction_handlers(new_smi);
2329 /* Try to claim any interrupts. */
2330 if (new_smi->irq_setup)
2331 new_smi->irq_setup(new_smi);
2333 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2334 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2335 new_smi->curr_msg = NULL;
2336 atomic_set(&new_smi->req_events, 0);
2337 new_smi->run_to_completion = 0;
2339 new_smi->interrupt_disabled = 0;
2340 atomic_set(&new_smi->stop_operation, 0);
2341 new_smi->intf_num = smi_num;
2344 /* Start clearing the flags before we enable interrupts or the
2345 timer to avoid racing with the timer. */
2346 start_clear_flags(new_smi);
2347 /* IRQ is defined to be set when non-zero. */
2349 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2351 if (!new_smi->dev) {
2352 /* If we don't already have a device from something
2353 * else (like PCI), then register a new one. */
2354 new_smi->pdev = platform_device_alloc("ipmi_si",
2359 " Unable to allocate platform device\n");
2362 new_smi->dev = &new_smi->pdev->dev;
2363 new_smi->dev->driver = &ipmi_driver;
2365 rv = platform_device_add(new_smi->pdev);
2369 " Unable to register system interface device:"
2374 new_smi->dev_registered = 1;
2377 rv = ipmi_register_smi(&handlers,
2379 &new_smi->device_id,
2382 new_smi->slave_addr);
2385 "ipmi_si: Unable to register device: error %d\n",
2387 goto out_err_stop_timer;
2390 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2391 type_file_read_proc, NULL,
2392 new_smi, THIS_MODULE);
2395 "ipmi_si: Unable to create proc entry: %d\n",
2397 goto out_err_stop_timer;
2400 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2401 stat_file_read_proc, NULL,
2402 new_smi, THIS_MODULE);
2405 "ipmi_si: Unable to create proc entry: %d\n",
2407 goto out_err_stop_timer;
2410 list_add_tail(&new_smi->link, &smi_infos);
2412 mutex_unlock(&smi_infos_lock);
2414 printk(" IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
2419 atomic_inc(&new_smi->stop_operation);
2420 wait_for_timer_and_thread(new_smi);
2424 ipmi_unregister_smi(new_smi->intf);
2426 if (new_smi->irq_cleanup)
2427 new_smi->irq_cleanup(new_smi);
2429 /* Wait until we know that we are out of any interrupt
2430 handlers might have been running before we freed the
2432 synchronize_sched();
2434 if (new_smi->si_sm) {
2435 if (new_smi->handlers)
2436 new_smi->handlers->cleanup(new_smi->si_sm);
2437 kfree(new_smi->si_sm);
2439 if (new_smi->addr_source_cleanup)
2440 new_smi->addr_source_cleanup(new_smi);
2441 if (new_smi->io_cleanup)
2442 new_smi->io_cleanup(new_smi);
2444 if (new_smi->dev_registered)
2445 platform_device_unregister(new_smi->pdev);
2449 mutex_unlock(&smi_infos_lock);
2454 static __devinit int init_ipmi_si(void)
2464 /* Register the device drivers. */
2465 rv = driver_register(&ipmi_driver);
2468 "init_ipmi_si: Unable to register driver: %d\n",
2474 /* Parse out the si_type string into its components. */
2477 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
2479 str = strchr(str, ',');
2489 printk(KERN_INFO "IPMI System Interface driver.\n");
2491 hardcode_find_bmc();
2503 pci_module_init(&ipmi_pci_driver);
2506 if (si_trydefaults) {
2507 mutex_lock(&smi_infos_lock);
2508 if (list_empty(&smi_infos)) {
2509 /* No BMC was found, try defaults. */
2510 mutex_unlock(&smi_infos_lock);
2513 mutex_unlock(&smi_infos_lock);
2517 mutex_lock(&smi_infos_lock);
2518 if (list_empty(&smi_infos)) {
2519 mutex_unlock(&smi_infos_lock);
2521 pci_unregister_driver(&ipmi_pci_driver);
2523 driver_unregister(&ipmi_driver);
2524 printk("ipmi_si: Unable to find any System Interface(s)\n");
2527 mutex_unlock(&smi_infos_lock);
2531 module_init(init_ipmi_si);
2533 static void __devexit cleanup_one_si(struct smi_info *to_clean)
2536 unsigned long flags;
2541 list_del(&to_clean->link);
2543 /* Tell the timer and interrupt handlers that we are shutting
2545 spin_lock_irqsave(&(to_clean->si_lock), flags);
2546 spin_lock(&(to_clean->msg_lock));
2548 atomic_inc(&to_clean->stop_operation);
2550 if (to_clean->irq_cleanup)
2551 to_clean->irq_cleanup(to_clean);
2553 spin_unlock(&(to_clean->msg_lock));
2554 spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2556 /* Wait until we know that we are out of any interrupt
2557 handlers might have been running before we freed the
2559 synchronize_sched();
2561 wait_for_timer_and_thread(to_clean);
2563 /* Interrupts and timeouts are stopped, now make sure the
2564 interface is in a clean state. */
2565 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
2567 schedule_timeout_uninterruptible(1);
2570 rv = ipmi_unregister_smi(to_clean->intf);
2573 "ipmi_si: Unable to unregister device: errno=%d\n",
2577 to_clean->handlers->cleanup(to_clean->si_sm);
2579 kfree(to_clean->si_sm);
2581 if (to_clean->addr_source_cleanup)
2582 to_clean->addr_source_cleanup(to_clean);
2583 if (to_clean->io_cleanup)
2584 to_clean->io_cleanup(to_clean);
2586 if (to_clean->dev_registered)
2587 platform_device_unregister(to_clean->pdev);
2592 static __exit void cleanup_ipmi_si(void)
2594 struct smi_info *e, *tmp_e;
2600 pci_unregister_driver(&ipmi_pci_driver);
2603 mutex_lock(&smi_infos_lock);
2604 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2606 mutex_unlock(&smi_infos_lock);
2608 driver_unregister(&ipmi_driver);
2610 module_exit(cleanup_ipmi_si);
2612 MODULE_LICENSE("GPL");
2613 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2614 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");