4 * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
7 * Author: MontaVista Software, Inc.
8 * Corey Minyard <minyard@mvista.com>
11 * Copyright 2002 MontaVista Software Inc.
12 * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
14 * This program is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2 of the License, or (at your
17 * option) any later version.
20 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
21 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
25 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
26 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
28 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
29 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 * You should have received a copy of the GNU General Public License along
32 * with this program; if not, write to the Free Software Foundation, Inc.,
33 * 675 Mass Ave, Cambridge, MA 02139, USA.
37 * This file holds the "policy" for the interface to the SMI state
38 * machine. It does the configuration, handles timers and interrupts,
39 * and drives the real SMI state machine.
42 #include <linux/module.h>
43 #include <linux/moduleparam.h>
44 #include <asm/system.h>
45 #include <linux/sched.h>
46 #include <linux/timer.h>
47 #include <linux/errno.h>
48 #include <linux/spinlock.h>
49 #include <linux/slab.h>
50 #include <linux/delay.h>
51 #include <linux/list.h>
52 #include <linux/pci.h>
53 #include <linux/ioport.h>
54 #include <linux/notifier.h>
55 #include <linux/mutex.h>
56 #include <linux/kthread.h>
58 #include <linux/interrupt.h>
59 #include <linux/rcupdate.h>
60 #include <linux/ipmi_smi.h>
62 #include "ipmi_si_sm.h"
63 #include <linux/init.h>
64 #include <linux/dmi.h>
65 #include <linux/string.h>
66 #include <linux/ctype.h>
69 #include <asm/of_device.h>
70 #include <asm/of_platform.h>
73 #define PFX "ipmi_si: "
75 /* Measure times between events in the driver. */
78 /* Call every 10 ms. */
79 #define SI_TIMEOUT_TIME_USEC 10000
80 #define SI_USEC_PER_JIFFY (1000000/HZ)
81 #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
82 #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
90 SI_CLEARING_FLAGS_THEN_SET_IRQ,
92 SI_ENABLE_INTERRUPTS1,
94 /* FIXME - add watchdog stuff. */
97 /* Some BT-specific defines we need here. */
98 #define IPMI_BT_INTMASK_REG 2
99 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
100 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
103 SI_KCS, SI_SMIC, SI_BT
105 static char *si_to_str[] = { "kcs", "smic", "bt" };
107 #define DEVICE_NAME "ipmi_si"
109 static struct device_driver ipmi_driver =
112 .bus = &platform_bus_type
119 struct si_sm_data *si_sm;
120 struct si_sm_handlers *handlers;
121 enum si_type si_type;
124 struct list_head xmit_msgs;
125 struct list_head hp_xmit_msgs;
126 struct ipmi_smi_msg *curr_msg;
127 enum si_intf_state si_state;
129 /* Used to handle the various types of I/O that can occur with
132 int (*io_setup)(struct smi_info *info);
133 void (*io_cleanup)(struct smi_info *info);
134 int (*irq_setup)(struct smi_info *info);
135 void (*irq_cleanup)(struct smi_info *info);
136 unsigned int io_size;
137 char *addr_source; /* ACPI, PCI, SMBIOS, hardcode, default. */
138 void (*addr_source_cleanup)(struct smi_info *info);
139 void *addr_source_data;
141 /* Per-OEM handler, called from handle_flags().
142 Returns 1 when handle_flags() needs to be re-run
143 or 0 indicating it set si_state itself.
145 int (*oem_data_avail_handler)(struct smi_info *smi_info);
147 /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
148 is set to hold the flags until we are done handling everything
150 #define RECEIVE_MSG_AVAIL 0x01
151 #define EVENT_MSG_BUFFER_FULL 0x02
152 #define WDT_PRE_TIMEOUT_INT 0x08
153 #define OEM0_DATA_AVAIL 0x20
154 #define OEM1_DATA_AVAIL 0x40
155 #define OEM2_DATA_AVAIL 0x80
156 #define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
159 unsigned char msg_flags;
161 /* If set to true, this will request events the next time the
162 state machine is idle. */
165 /* If true, run the state machine to completion on every send
166 call. Generally used after a panic to make sure stuff goes
168 int run_to_completion;
170 /* The I/O port of an SI interface. */
173 /* The space between start addresses of the two ports. For
174 instance, if the first port is 0xca2 and the spacing is 4, then
175 the second port is 0xca6. */
176 unsigned int spacing;
178 /* zero if no irq; */
181 /* The timer for this si. */
182 struct timer_list si_timer;
184 /* The time (in jiffies) the last timeout occurred at. */
185 unsigned long last_timeout_jiffies;
187 /* Used to gracefully stop the timer without race conditions. */
188 atomic_t stop_operation;
190 /* The driver will disable interrupts when it gets into a
191 situation where it cannot handle messages due to lack of
192 memory. Once that situation clears up, it will re-enable
194 int interrupt_disabled;
196 /* From the get device id response... */
197 struct ipmi_device_id device_id;
199 /* Driver model stuff. */
201 struct platform_device *pdev;
203 /* True if we allocated the device, false if it came from
204 * someplace else (like PCI). */
207 /* Slave address, could be reported from DMI. */
208 unsigned char slave_addr;
210 /* Counters and things for the proc filesystem. */
211 spinlock_t count_lock;
212 unsigned long short_timeouts;
213 unsigned long long_timeouts;
214 unsigned long timeout_restarts;
216 unsigned long interrupts;
217 unsigned long attentions;
218 unsigned long flag_fetches;
219 unsigned long hosed_count;
220 unsigned long complete_transactions;
221 unsigned long events;
222 unsigned long watchdog_pretimeouts;
223 unsigned long incoming_messages;
225 struct task_struct *thread;
227 struct list_head link;
230 #define SI_MAX_PARMS 4
232 static int force_kipmid[SI_MAX_PARMS];
233 static int num_force_kipmid;
235 static int unload_when_empty = 1;
237 static int try_smi_init(struct smi_info *smi);
238 static void cleanup_one_si(struct smi_info *to_clean);
240 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
241 static int register_xaction_notifier(struct notifier_block * nb)
243 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
246 static void deliver_recv_msg(struct smi_info *smi_info,
247 struct ipmi_smi_msg *msg)
249 /* Deliver the message to the upper layer with the lock
251 spin_unlock(&(smi_info->si_lock));
252 ipmi_smi_msg_received(smi_info->intf, msg);
253 spin_lock(&(smi_info->si_lock));
256 static void return_hosed_msg(struct smi_info *smi_info, int cCode)
258 struct ipmi_smi_msg *msg = smi_info->curr_msg;
260 if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
261 cCode = IPMI_ERR_UNSPECIFIED;
262 /* else use it as is */
264 /* Make it a reponse */
265 msg->rsp[0] = msg->data[0] | 4;
266 msg->rsp[1] = msg->data[1];
270 smi_info->curr_msg = NULL;
271 deliver_recv_msg(smi_info, msg);
274 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
277 struct list_head *entry = NULL;
282 /* No need to save flags, we aleady have interrupts off and we
283 already hold the SMI lock. */
284 spin_lock(&(smi_info->msg_lock));
286 /* Pick the high priority queue first. */
287 if (!list_empty(&(smi_info->hp_xmit_msgs))) {
288 entry = smi_info->hp_xmit_msgs.next;
289 } else if (!list_empty(&(smi_info->xmit_msgs))) {
290 entry = smi_info->xmit_msgs.next;
294 smi_info->curr_msg = NULL;
300 smi_info->curr_msg = list_entry(entry,
305 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
307 err = atomic_notifier_call_chain(&xaction_notifier_list,
309 if (err & NOTIFY_STOP_MASK) {
310 rv = SI_SM_CALL_WITHOUT_DELAY;
313 err = smi_info->handlers->start_transaction(
315 smi_info->curr_msg->data,
316 smi_info->curr_msg->data_size);
318 return_hosed_msg(smi_info, err);
321 rv = SI_SM_CALL_WITHOUT_DELAY;
324 spin_unlock(&(smi_info->msg_lock));
329 static void start_enable_irq(struct smi_info *smi_info)
331 unsigned char msg[2];
333 /* If we are enabling interrupts, we have to tell the
335 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
336 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
338 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
339 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
342 static void start_clear_flags(struct smi_info *smi_info)
344 unsigned char msg[3];
346 /* Make sure the watchdog pre-timeout flag is not set at startup. */
347 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
348 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
349 msg[2] = WDT_PRE_TIMEOUT_INT;
351 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
352 smi_info->si_state = SI_CLEARING_FLAGS;
355 /* When we have a situtaion where we run out of memory and cannot
356 allocate messages, we just leave them in the BMC and run the system
357 polled until we can allocate some memory. Once we have some
358 memory, we will re-enable the interrupt. */
359 static inline void disable_si_irq(struct smi_info *smi_info)
361 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
362 disable_irq_nosync(smi_info->irq);
363 smi_info->interrupt_disabled = 1;
367 static inline void enable_si_irq(struct smi_info *smi_info)
369 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
370 enable_irq(smi_info->irq);
371 smi_info->interrupt_disabled = 0;
375 static void handle_flags(struct smi_info *smi_info)
378 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
379 /* Watchdog pre-timeout */
380 spin_lock(&smi_info->count_lock);
381 smi_info->watchdog_pretimeouts++;
382 spin_unlock(&smi_info->count_lock);
384 start_clear_flags(smi_info);
385 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
386 spin_unlock(&(smi_info->si_lock));
387 ipmi_smi_watchdog_pretimeout(smi_info->intf);
388 spin_lock(&(smi_info->si_lock));
389 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
390 /* Messages available. */
391 smi_info->curr_msg = ipmi_alloc_smi_msg();
392 if (!smi_info->curr_msg) {
393 disable_si_irq(smi_info);
394 smi_info->si_state = SI_NORMAL;
397 enable_si_irq(smi_info);
399 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
400 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
401 smi_info->curr_msg->data_size = 2;
403 smi_info->handlers->start_transaction(
405 smi_info->curr_msg->data,
406 smi_info->curr_msg->data_size);
407 smi_info->si_state = SI_GETTING_MESSAGES;
408 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
409 /* Events available. */
410 smi_info->curr_msg = ipmi_alloc_smi_msg();
411 if (!smi_info->curr_msg) {
412 disable_si_irq(smi_info);
413 smi_info->si_state = SI_NORMAL;
416 enable_si_irq(smi_info);
418 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
419 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
420 smi_info->curr_msg->data_size = 2;
422 smi_info->handlers->start_transaction(
424 smi_info->curr_msg->data,
425 smi_info->curr_msg->data_size);
426 smi_info->si_state = SI_GETTING_EVENTS;
427 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
428 smi_info->oem_data_avail_handler) {
429 if (smi_info->oem_data_avail_handler(smi_info))
432 smi_info->si_state = SI_NORMAL;
436 static void handle_transaction_done(struct smi_info *smi_info)
438 struct ipmi_smi_msg *msg;
443 printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
445 switch (smi_info->si_state) {
447 if (!smi_info->curr_msg)
450 smi_info->curr_msg->rsp_size
451 = smi_info->handlers->get_result(
453 smi_info->curr_msg->rsp,
454 IPMI_MAX_MSG_LENGTH);
456 /* Do this here becase deliver_recv_msg() releases the
457 lock, and a new message can be put in during the
458 time the lock is released. */
459 msg = smi_info->curr_msg;
460 smi_info->curr_msg = NULL;
461 deliver_recv_msg(smi_info, msg);
464 case SI_GETTING_FLAGS:
466 unsigned char msg[4];
469 /* We got the flags from the SMI, now handle them. */
470 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
472 /* Error fetching flags, just give up for
474 smi_info->si_state = SI_NORMAL;
475 } else if (len < 4) {
476 /* Hmm, no flags. That's technically illegal, but
477 don't use uninitialized data. */
478 smi_info->si_state = SI_NORMAL;
480 smi_info->msg_flags = msg[3];
481 handle_flags(smi_info);
486 case SI_CLEARING_FLAGS:
487 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
489 unsigned char msg[3];
491 /* We cleared the flags. */
492 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
494 /* Error clearing flags */
496 "ipmi_si: Error clearing flags: %2.2x\n",
499 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
500 start_enable_irq(smi_info);
502 smi_info->si_state = SI_NORMAL;
506 case SI_GETTING_EVENTS:
508 smi_info->curr_msg->rsp_size
509 = smi_info->handlers->get_result(
511 smi_info->curr_msg->rsp,
512 IPMI_MAX_MSG_LENGTH);
514 /* Do this here becase deliver_recv_msg() releases the
515 lock, and a new message can be put in during the
516 time the lock is released. */
517 msg = smi_info->curr_msg;
518 smi_info->curr_msg = NULL;
519 if (msg->rsp[2] != 0) {
520 /* Error getting event, probably done. */
523 /* Take off the event flag. */
524 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
525 handle_flags(smi_info);
527 spin_lock(&smi_info->count_lock);
529 spin_unlock(&smi_info->count_lock);
531 /* Do this before we deliver the message
532 because delivering the message releases the
533 lock and something else can mess with the
535 handle_flags(smi_info);
537 deliver_recv_msg(smi_info, msg);
542 case SI_GETTING_MESSAGES:
544 smi_info->curr_msg->rsp_size
545 = smi_info->handlers->get_result(
547 smi_info->curr_msg->rsp,
548 IPMI_MAX_MSG_LENGTH);
550 /* Do this here becase deliver_recv_msg() releases the
551 lock, and a new message can be put in during the
552 time the lock is released. */
553 msg = smi_info->curr_msg;
554 smi_info->curr_msg = NULL;
555 if (msg->rsp[2] != 0) {
556 /* Error getting event, probably done. */
559 /* Take off the msg flag. */
560 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
561 handle_flags(smi_info);
563 spin_lock(&smi_info->count_lock);
564 smi_info->incoming_messages++;
565 spin_unlock(&smi_info->count_lock);
567 /* Do this before we deliver the message
568 because delivering the message releases the
569 lock and something else can mess with the
571 handle_flags(smi_info);
573 deliver_recv_msg(smi_info, msg);
578 case SI_ENABLE_INTERRUPTS1:
580 unsigned char msg[4];
582 /* We got the flags from the SMI, now handle them. */
583 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
586 "ipmi_si: Could not enable interrupts"
587 ", failed get, using polled mode.\n");
588 smi_info->si_state = SI_NORMAL;
590 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
591 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
592 msg[2] = msg[3] | 1; /* enable msg queue int */
593 smi_info->handlers->start_transaction(
594 smi_info->si_sm, msg, 3);
595 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
600 case SI_ENABLE_INTERRUPTS2:
602 unsigned char msg[4];
604 /* We got the flags from the SMI, now handle them. */
605 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
608 "ipmi_si: Could not enable interrupts"
609 ", failed set, using polled mode.\n");
611 smi_info->si_state = SI_NORMAL;
617 /* Called on timeouts and events. Timeouts should pass the elapsed
618 time, interrupts should pass in zero. */
619 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
622 enum si_sm_result si_sm_result;
625 /* There used to be a loop here that waited a little while
626 (around 25us) before giving up. That turned out to be
627 pointless, the minimum delays I was seeing were in the 300us
628 range, which is far too long to wait in an interrupt. So
629 we just run until the state machine tells us something
630 happened or it needs a delay. */
631 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
633 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
635 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
638 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
640 spin_lock(&smi_info->count_lock);
641 smi_info->complete_transactions++;
642 spin_unlock(&smi_info->count_lock);
644 handle_transaction_done(smi_info);
645 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
647 else if (si_sm_result == SI_SM_HOSED)
649 spin_lock(&smi_info->count_lock);
650 smi_info->hosed_count++;
651 spin_unlock(&smi_info->count_lock);
653 /* Do the before return_hosed_msg, because that
654 releases the lock. */
655 smi_info->si_state = SI_NORMAL;
656 if (smi_info->curr_msg != NULL) {
657 /* If we were handling a user message, format
658 a response to send to the upper layer to
659 tell it about the error. */
660 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
662 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
665 /* We prefer handling attn over new messages. */
666 if (si_sm_result == SI_SM_ATTN)
668 unsigned char msg[2];
670 spin_lock(&smi_info->count_lock);
671 smi_info->attentions++;
672 spin_unlock(&smi_info->count_lock);
674 /* Got a attn, send down a get message flags to see
675 what's causing it. It would be better to handle
676 this in the upper layer, but due to the way
677 interrupts work with the SMI, that's not really
679 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
680 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
682 smi_info->handlers->start_transaction(
683 smi_info->si_sm, msg, 2);
684 smi_info->si_state = SI_GETTING_FLAGS;
688 /* If we are currently idle, try to start the next message. */
689 if (si_sm_result == SI_SM_IDLE) {
690 spin_lock(&smi_info->count_lock);
692 spin_unlock(&smi_info->count_lock);
694 si_sm_result = start_next_msg(smi_info);
695 if (si_sm_result != SI_SM_IDLE)
699 if ((si_sm_result == SI_SM_IDLE)
700 && (atomic_read(&smi_info->req_events)))
702 /* We are idle and the upper layer requested that I fetch
704 atomic_set(&smi_info->req_events, 0);
706 smi_info->curr_msg = ipmi_alloc_smi_msg();
707 if (!smi_info->curr_msg)
710 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
711 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
712 smi_info->curr_msg->data_size = 2;
714 smi_info->handlers->start_transaction(
716 smi_info->curr_msg->data,
717 smi_info->curr_msg->data_size);
718 smi_info->si_state = SI_GETTING_EVENTS;
725 static void sender(void *send_info,
726 struct ipmi_smi_msg *msg,
729 struct smi_info *smi_info = send_info;
730 enum si_sm_result result;
736 if (atomic_read(&smi_info->stop_operation)) {
737 msg->rsp[0] = msg->data[0] | 4;
738 msg->rsp[1] = msg->data[1];
739 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
741 deliver_recv_msg(smi_info, msg);
745 spin_lock_irqsave(&(smi_info->msg_lock), flags);
748 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
751 if (smi_info->run_to_completion) {
752 /* If we are running to completion, then throw it in
753 the list and run transactions until everything is
754 clear. Priority doesn't matter here. */
755 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
757 /* We have to release the msg lock and claim the smi
758 lock in this case, because of race conditions. */
759 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
761 spin_lock_irqsave(&(smi_info->si_lock), flags);
762 result = smi_event_handler(smi_info, 0);
763 while (result != SI_SM_IDLE) {
764 udelay(SI_SHORT_TIMEOUT_USEC);
765 result = smi_event_handler(smi_info,
766 SI_SHORT_TIMEOUT_USEC);
768 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
772 list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
774 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
777 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
779 spin_lock_irqsave(&(smi_info->si_lock), flags);
780 if ((smi_info->si_state == SI_NORMAL)
781 && (smi_info->curr_msg == NULL))
783 start_next_msg(smi_info);
785 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
788 static void set_run_to_completion(void *send_info, int i_run_to_completion)
790 struct smi_info *smi_info = send_info;
791 enum si_sm_result result;
794 spin_lock_irqsave(&(smi_info->si_lock), flags);
796 smi_info->run_to_completion = i_run_to_completion;
797 if (i_run_to_completion) {
798 result = smi_event_handler(smi_info, 0);
799 while (result != SI_SM_IDLE) {
800 udelay(SI_SHORT_TIMEOUT_USEC);
801 result = smi_event_handler(smi_info,
802 SI_SHORT_TIMEOUT_USEC);
806 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
809 static int ipmi_thread(void *data)
811 struct smi_info *smi_info = data;
813 enum si_sm_result smi_result;
815 set_user_nice(current, 19);
816 while (!kthread_should_stop()) {
817 spin_lock_irqsave(&(smi_info->si_lock), flags);
818 smi_result = smi_event_handler(smi_info, 0);
819 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
820 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
823 else if (smi_result == SI_SM_CALL_WITH_DELAY)
826 schedule_timeout_interruptible(1);
832 static void poll(void *send_info)
834 struct smi_info *smi_info = send_info;
837 * Make sure there is some delay in the poll loop so we can
838 * drive time forward and timeout things.
841 smi_event_handler(smi_info, 10);
844 static void request_events(void *send_info)
846 struct smi_info *smi_info = send_info;
848 if (atomic_read(&smi_info->stop_operation))
851 atomic_set(&smi_info->req_events, 1);
854 static int initialized;
856 static void smi_timeout(unsigned long data)
858 struct smi_info *smi_info = (struct smi_info *) data;
859 enum si_sm_result smi_result;
861 unsigned long jiffies_now;
867 if (atomic_read(&smi_info->stop_operation))
870 spin_lock_irqsave(&(smi_info->si_lock), flags);
873 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
875 jiffies_now = jiffies;
876 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
877 * SI_USEC_PER_JIFFY);
878 smi_result = smi_event_handler(smi_info, time_diff);
880 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
882 smi_info->last_timeout_jiffies = jiffies_now;
884 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
885 /* Running with interrupts, only do long timeouts. */
886 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
887 spin_lock_irqsave(&smi_info->count_lock, flags);
888 smi_info->long_timeouts++;
889 spin_unlock_irqrestore(&smi_info->count_lock, flags);
893 /* If the state machine asks for a short delay, then shorten
894 the timer timeout. */
895 if (smi_result == SI_SM_CALL_WITH_DELAY) {
896 spin_lock_irqsave(&smi_info->count_lock, flags);
897 smi_info->short_timeouts++;
898 spin_unlock_irqrestore(&smi_info->count_lock, flags);
899 smi_info->si_timer.expires = jiffies + 1;
901 spin_lock_irqsave(&smi_info->count_lock, flags);
902 smi_info->long_timeouts++;
903 spin_unlock_irqrestore(&smi_info->count_lock, flags);
904 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
908 add_timer(&(smi_info->si_timer));
911 static irqreturn_t si_irq_handler(int irq, void *data)
913 struct smi_info *smi_info = data;
919 spin_lock_irqsave(&(smi_info->si_lock), flags);
921 spin_lock(&smi_info->count_lock);
922 smi_info->interrupts++;
923 spin_unlock(&smi_info->count_lock);
925 if (atomic_read(&smi_info->stop_operation))
930 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
932 smi_event_handler(smi_info, 0);
934 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
938 static irqreturn_t si_bt_irq_handler(int irq, void *data)
940 struct smi_info *smi_info = data;
941 /* We need to clear the IRQ flag for the BT interface. */
942 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
943 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
944 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
945 return si_irq_handler(irq, data);
948 static int smi_start_processing(void *send_info,
951 struct smi_info *new_smi = send_info;
954 new_smi->intf = intf;
956 /* Set up the timer that drives the interface. */
957 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
958 new_smi->last_timeout_jiffies = jiffies;
959 mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
962 * Check if the user forcefully enabled the daemon.
964 if (new_smi->intf_num < num_force_kipmid)
965 enable = force_kipmid[new_smi->intf_num];
967 * The BT interface is efficient enough to not need a thread,
968 * and there is no need for a thread if we have interrupts.
970 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
974 new_smi->thread = kthread_run(ipmi_thread, new_smi,
975 "kipmi%d", new_smi->intf_num);
976 if (IS_ERR(new_smi->thread)) {
977 printk(KERN_NOTICE "ipmi_si_intf: Could not start"
978 " kernel thread due to error %ld, only using"
979 " timers to drive the interface\n",
980 PTR_ERR(new_smi->thread));
981 new_smi->thread = NULL;
988 static void set_maintenance_mode(void *send_info, int enable)
990 struct smi_info *smi_info = send_info;
993 atomic_set(&smi_info->req_events, 0);
996 static struct ipmi_smi_handlers handlers =
998 .owner = THIS_MODULE,
999 .start_processing = smi_start_processing,
1001 .request_events = request_events,
1002 .set_maintenance_mode = set_maintenance_mode,
1003 .set_run_to_completion = set_run_to_completion,
1007 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1008 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
1010 static LIST_HEAD(smi_infos);
1011 static DEFINE_MUTEX(smi_infos_lock);
1012 static int smi_num; /* Used to sequence the SMIs */
1014 #define DEFAULT_REGSPACING 1
1015 #define DEFAULT_REGSIZE 1
1017 static int si_trydefaults = 1;
1018 static char *si_type[SI_MAX_PARMS];
1019 #define MAX_SI_TYPE_STR 30
1020 static char si_type_str[MAX_SI_TYPE_STR];
1021 static unsigned long addrs[SI_MAX_PARMS];
1022 static int num_addrs;
1023 static unsigned int ports[SI_MAX_PARMS];
1024 static int num_ports;
1025 static int irqs[SI_MAX_PARMS];
1026 static int num_irqs;
1027 static int regspacings[SI_MAX_PARMS];
1028 static int num_regspacings;
1029 static int regsizes[SI_MAX_PARMS];
1030 static int num_regsizes;
1031 static int regshifts[SI_MAX_PARMS];
1032 static int num_regshifts;
1033 static int slave_addrs[SI_MAX_PARMS];
1034 static int num_slave_addrs;
1036 #define IPMI_IO_ADDR_SPACE 0
1037 #define IPMI_MEM_ADDR_SPACE 1
1038 static char *addr_space_to_str[] = { "i/o", "mem" };
1040 static int hotmod_handler(const char *val, struct kernel_param *kp);
1042 module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
1043 MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See"
1044 " Documentation/IPMI.txt in the kernel sources for the"
1047 module_param_named(trydefaults, si_trydefaults, bool, 0);
1048 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1049 " default scan of the KCS and SMIC interface at the standard"
1051 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1052 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1053 " interface separated by commas. The types are 'kcs',"
1054 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1055 " the first interface to kcs and the second to bt");
1056 module_param_array(addrs, long, &num_addrs, 0);
1057 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1058 " addresses separated by commas. Only use if an interface"
1059 " is in memory. Otherwise, set it to zero or leave"
1061 module_param_array(ports, int, &num_ports, 0);
1062 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1063 " addresses separated by commas. Only use if an interface"
1064 " is a port. Otherwise, set it to zero or leave"
1066 module_param_array(irqs, int, &num_irqs, 0);
1067 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1068 " addresses separated by commas. Only use if an interface"
1069 " has an interrupt. Otherwise, set it to zero or leave"
1071 module_param_array(regspacings, int, &num_regspacings, 0);
1072 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1073 " and each successive register used by the interface. For"
1074 " instance, if the start address is 0xca2 and the spacing"
1075 " is 2, then the second address is at 0xca4. Defaults"
1077 module_param_array(regsizes, int, &num_regsizes, 0);
1078 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1079 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1080 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1081 " the 8-bit IPMI register has to be read from a larger"
1083 module_param_array(regshifts, int, &num_regshifts, 0);
1084 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1085 " IPMI register, in bits. For instance, if the data"
1086 " is read from a 32-bit word and the IPMI data is in"
1087 " bit 8-15, then the shift would be 8");
1088 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1089 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1090 " the controller. Normally this is 0x20, but can be"
1091 " overridden by this parm. This is an array indexed"
1092 " by interface number.");
1093 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1094 MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1095 " disabled(0). Normally the IPMI driver auto-detects"
1096 " this, but the value may be overridden by this parm.");
1097 module_param(unload_when_empty, int, 0);
1098 MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
1099 " specified or found, default is 1. Setting to 0"
1100 " is useful for hot add of devices using hotmod.");
1103 static void std_irq_cleanup(struct smi_info *info)
1105 if (info->si_type == SI_BT)
1106 /* Disable the interrupt in the BT interface. */
1107 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1108 free_irq(info->irq, info);
1111 static int std_irq_setup(struct smi_info *info)
1118 if (info->si_type == SI_BT) {
1119 rv = request_irq(info->irq,
1125 /* Enable the interrupt in the BT interface. */
1126 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1127 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1129 rv = request_irq(info->irq,
1136 "ipmi_si: %s unable to claim interrupt %d,"
1137 " running polled\n",
1138 DEVICE_NAME, info->irq);
1141 info->irq_cleanup = std_irq_cleanup;
1142 printk(" Using irq %d\n", info->irq);
1148 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1150 unsigned int addr = io->addr_data;
1152 return inb(addr + (offset * io->regspacing));
1155 static void port_outb(struct si_sm_io *io, unsigned int offset,
1158 unsigned int addr = io->addr_data;
1160 outb(b, addr + (offset * io->regspacing));
1163 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1165 unsigned int addr = io->addr_data;
1167 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1170 static void port_outw(struct si_sm_io *io, unsigned int offset,
1173 unsigned int addr = io->addr_data;
1175 outw(b << io->regshift, addr + (offset * io->regspacing));
1178 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1180 unsigned int addr = io->addr_data;
1182 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1185 static void port_outl(struct si_sm_io *io, unsigned int offset,
1188 unsigned int addr = io->addr_data;
1190 outl(b << io->regshift, addr+(offset * io->regspacing));
1193 static void port_cleanup(struct smi_info *info)
1195 unsigned int addr = info->io.addr_data;
1199 for (idx = 0; idx < info->io_size; idx++) {
1200 release_region(addr + idx * info->io.regspacing,
1206 static int port_setup(struct smi_info *info)
1208 unsigned int addr = info->io.addr_data;
1214 info->io_cleanup = port_cleanup;
1216 /* Figure out the actual inb/inw/inl/etc routine to use based
1217 upon the register size. */
1218 switch (info->io.regsize) {
1220 info->io.inputb = port_inb;
1221 info->io.outputb = port_outb;
1224 info->io.inputb = port_inw;
1225 info->io.outputb = port_outw;
1228 info->io.inputb = port_inl;
1229 info->io.outputb = port_outl;
1232 printk("ipmi_si: Invalid register size: %d\n",
1237 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1238 * tables. This causes problems when trying to register the
1239 * entire I/O region. Therefore we must register each I/O
1242 for (idx = 0; idx < info->io_size; idx++) {
1243 if (request_region(addr + idx * info->io.regspacing,
1244 info->io.regsize, DEVICE_NAME) == NULL) {
1245 /* Undo allocations */
1247 release_region(addr + idx * info->io.regspacing,
1256 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1258 return readb((io->addr)+(offset * io->regspacing));
1261 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1264 writeb(b, (io->addr)+(offset * io->regspacing));
1267 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1269 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1273 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1276 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1279 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1281 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1285 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1288 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1292 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1294 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1298 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1301 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1305 static void mem_cleanup(struct smi_info *info)
1307 unsigned long addr = info->io.addr_data;
1310 if (info->io.addr) {
1311 iounmap(info->io.addr);
1313 mapsize = ((info->io_size * info->io.regspacing)
1314 - (info->io.regspacing - info->io.regsize));
1316 release_mem_region(addr, mapsize);
1320 static int mem_setup(struct smi_info *info)
1322 unsigned long addr = info->io.addr_data;
1328 info->io_cleanup = mem_cleanup;
1330 /* Figure out the actual readb/readw/readl/etc routine to use based
1331 upon the register size. */
1332 switch (info->io.regsize) {
1334 info->io.inputb = intf_mem_inb;
1335 info->io.outputb = intf_mem_outb;
1338 info->io.inputb = intf_mem_inw;
1339 info->io.outputb = intf_mem_outw;
1342 info->io.inputb = intf_mem_inl;
1343 info->io.outputb = intf_mem_outl;
1347 info->io.inputb = mem_inq;
1348 info->io.outputb = mem_outq;
1352 printk("ipmi_si: Invalid register size: %d\n",
1357 /* Calculate the total amount of memory to claim. This is an
1358 * unusual looking calculation, but it avoids claiming any
1359 * more memory than it has to. It will claim everything
1360 * between the first address to the end of the last full
1362 mapsize = ((info->io_size * info->io.regspacing)
1363 - (info->io.regspacing - info->io.regsize));
1365 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1368 info->io.addr = ioremap(addr, mapsize);
1369 if (info->io.addr == NULL) {
1370 release_mem_region(addr, mapsize);
1377 * Parms come in as <op1>[:op2[:op3...]]. ops are:
1378 * add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
1386 enum hotmod_op { HM_ADD, HM_REMOVE };
1387 struct hotmod_vals {
1391 static struct hotmod_vals hotmod_ops[] = {
1393 { "remove", HM_REMOVE },
1396 static struct hotmod_vals hotmod_si[] = {
1398 { "smic", SI_SMIC },
1402 static struct hotmod_vals hotmod_as[] = {
1403 { "mem", IPMI_MEM_ADDR_SPACE },
1404 { "i/o", IPMI_IO_ADDR_SPACE },
1408 static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
1413 s = strchr(*curr, ',');
1415 printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
1420 for (i = 0; hotmod_ops[i].name; i++) {
1421 if (strcmp(*curr, v[i].name) == 0) {
1428 printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
1432 static int check_hotmod_int_op(const char *curr, const char *option,
1433 const char *name, int *val)
1437 if (strcmp(curr, name) == 0) {
1439 printk(KERN_WARNING PFX
1440 "No option given for '%s'\n",
1444 *val = simple_strtoul(option, &n, 0);
1445 if ((*n != '\0') || (*option == '\0')) {
1446 printk(KERN_WARNING PFX
1447 "Bad option given for '%s'\n",
1456 static int hotmod_handler(const char *val, struct kernel_param *kp)
1458 char *str = kstrdup(val, GFP_KERNEL);
1460 char *next, *curr, *s, *n, *o;
1462 enum si_type si_type;
1472 struct smi_info *info;
1477 /* Kill any trailing spaces, as we can get a "\n" from echo. */
1480 while ((ival >= 0) && isspace(str[ival])) {
1485 for (curr = str; curr; curr = next) {
1492 next = strchr(curr, ':');
1498 rv = parse_str(hotmod_ops, &ival, "operation", &curr);
1503 rv = parse_str(hotmod_si, &ival, "interface type", &curr);
1508 rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
1512 s = strchr(curr, ',');
1517 addr = simple_strtoul(curr, &n, 0);
1518 if ((*n != '\0') || (*curr == '\0')) {
1519 printk(KERN_WARNING PFX "Invalid hotmod address"
1526 s = strchr(curr, ',');
1531 o = strchr(curr, '=');
1536 rv = check_hotmod_int_op(curr, o, "rsp", ®spacing);
1541 rv = check_hotmod_int_op(curr, o, "rsi", ®size);
1546 rv = check_hotmod_int_op(curr, o, "rsh", ®shift);
1551 rv = check_hotmod_int_op(curr, o, "irq", &irq);
1556 rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
1563 printk(KERN_WARNING PFX
1564 "Invalid hotmod option '%s'\n",
1570 info = kzalloc(sizeof(*info), GFP_KERNEL);
1576 info->addr_source = "hotmod";
1577 info->si_type = si_type;
1578 info->io.addr_data = addr;
1579 info->io.addr_type = addr_space;
1580 if (addr_space == IPMI_MEM_ADDR_SPACE)
1581 info->io_setup = mem_setup;
1583 info->io_setup = port_setup;
1585 info->io.addr = NULL;
1586 info->io.regspacing = regspacing;
1587 if (!info->io.regspacing)
1588 info->io.regspacing = DEFAULT_REGSPACING;
1589 info->io.regsize = regsize;
1590 if (!info->io.regsize)
1591 info->io.regsize = DEFAULT_REGSPACING;
1592 info->io.regshift = regshift;
1595 info->irq_setup = std_irq_setup;
1596 info->slave_addr = ipmb;
1601 struct smi_info *e, *tmp_e;
1603 mutex_lock(&smi_infos_lock);
1604 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
1605 if (e->io.addr_type != addr_space)
1607 if (e->si_type != si_type)
1609 if (e->io.addr_data == addr)
1612 mutex_unlock(&smi_infos_lock);
1621 static __devinit void hardcode_find_bmc(void)
1624 struct smi_info *info;
1626 for (i = 0; i < SI_MAX_PARMS; i++) {
1627 if (!ports[i] && !addrs[i])
1630 info = kzalloc(sizeof(*info), GFP_KERNEL);
1634 info->addr_source = "hardcoded";
1636 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1637 info->si_type = SI_KCS;
1638 } else if (strcmp(si_type[i], "smic") == 0) {
1639 info->si_type = SI_SMIC;
1640 } else if (strcmp(si_type[i], "bt") == 0) {
1641 info->si_type = SI_BT;
1644 "ipmi_si: Interface type specified "
1645 "for interface %d, was invalid: %s\n",
1653 info->io_setup = port_setup;
1654 info->io.addr_data = ports[i];
1655 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1656 } else if (addrs[i]) {
1658 info->io_setup = mem_setup;
1659 info->io.addr_data = addrs[i];
1660 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1663 "ipmi_si: Interface type specified "
1664 "for interface %d, "
1665 "but port and address were not set or "
1666 "set to zero.\n", i);
1671 info->io.addr = NULL;
1672 info->io.regspacing = regspacings[i];
1673 if (!info->io.regspacing)
1674 info->io.regspacing = DEFAULT_REGSPACING;
1675 info->io.regsize = regsizes[i];
1676 if (!info->io.regsize)
1677 info->io.regsize = DEFAULT_REGSPACING;
1678 info->io.regshift = regshifts[i];
1679 info->irq = irqs[i];
1681 info->irq_setup = std_irq_setup;
1689 #include <linux/acpi.h>
1691 /* Once we get an ACPI failure, we don't try any more, because we go
1692 through the tables sequentially. Once we don't find a table, there
1694 static int acpi_failure;
1696 /* For GPE-type interrupts. */
1697 static u32 ipmi_acpi_gpe(void *context)
1699 struct smi_info *smi_info = context;
1700 unsigned long flags;
1705 spin_lock_irqsave(&(smi_info->si_lock), flags);
1707 spin_lock(&smi_info->count_lock);
1708 smi_info->interrupts++;
1709 spin_unlock(&smi_info->count_lock);
1711 if (atomic_read(&smi_info->stop_operation))
1715 do_gettimeofday(&t);
1716 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1718 smi_event_handler(smi_info, 0);
1720 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1722 return ACPI_INTERRUPT_HANDLED;
1725 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1730 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1733 static int acpi_gpe_irq_setup(struct smi_info *info)
1740 /* FIXME - is level triggered right? */
1741 status = acpi_install_gpe_handler(NULL,
1743 ACPI_GPE_LEVEL_TRIGGERED,
1746 if (status != AE_OK) {
1748 "ipmi_si: %s unable to claim ACPI GPE %d,"
1749 " running polled\n",
1750 DEVICE_NAME, info->irq);
1754 info->irq_cleanup = acpi_gpe_irq_cleanup;
1755 printk(" Using ACPI GPE %d\n", info->irq);
1762 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1773 s8 CreatorRevision[4];
1776 s16 SpecificationRevision;
1779 * Bit 0 - SCI interrupt supported
1780 * Bit 1 - I/O APIC/SAPIC
1784 /* If bit 0 of InterruptType is set, then this is the SCI
1785 interrupt in the GPEx_STS register. */
1790 /* If bit 1 of InterruptType is set, then this is the I/O
1791 APIC/SAPIC interrupt. */
1792 u32 GlobalSystemInterrupt;
1794 /* The actual register address. */
1795 struct acpi_generic_address addr;
1799 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1802 static __devinit int try_init_acpi(struct SPMITable *spmi)
1804 struct smi_info *info;
1807 if (spmi->IPMIlegacy != 1) {
1808 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1812 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1813 addr_space = IPMI_MEM_ADDR_SPACE;
1815 addr_space = IPMI_IO_ADDR_SPACE;
1817 info = kzalloc(sizeof(*info), GFP_KERNEL);
1819 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1823 info->addr_source = "ACPI";
1825 /* Figure out the interface type. */
1826 switch (spmi->InterfaceType)
1829 info->si_type = SI_KCS;
1832 info->si_type = SI_SMIC;
1835 info->si_type = SI_BT;
1838 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1839 spmi->InterfaceType);
1844 if (spmi->InterruptType & 1) {
1845 /* We've got a GPE interrupt. */
1846 info->irq = spmi->GPE;
1847 info->irq_setup = acpi_gpe_irq_setup;
1848 } else if (spmi->InterruptType & 2) {
1849 /* We've got an APIC/SAPIC interrupt. */
1850 info->irq = spmi->GlobalSystemInterrupt;
1851 info->irq_setup = std_irq_setup;
1853 /* Use the default interrupt setting. */
1855 info->irq_setup = NULL;
1858 if (spmi->addr.bit_width) {
1859 /* A (hopefully) properly formed register bit width. */
1860 info->io.regspacing = spmi->addr.bit_width / 8;
1862 info->io.regspacing = DEFAULT_REGSPACING;
1864 info->io.regsize = info->io.regspacing;
1865 info->io.regshift = spmi->addr.bit_offset;
1867 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1868 info->io_setup = mem_setup;
1869 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1870 } else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1871 info->io_setup = port_setup;
1872 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1875 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1878 info->io.addr_data = spmi->addr.address;
1885 static __devinit void acpi_find_bmc(void)
1888 struct SPMITable *spmi;
1897 for (i = 0; ; i++) {
1898 status = acpi_get_table(ACPI_SIG_SPMI, i+1,
1899 (struct acpi_table_header **)&spmi);
1900 if (status != AE_OK)
1903 try_init_acpi(spmi);
1909 struct dmi_ipmi_data
1913 unsigned long base_addr;
1919 static int __devinit decode_dmi(struct dmi_header *dm,
1920 struct dmi_ipmi_data *dmi)
1922 u8 *data = (u8 *)dm;
1923 unsigned long base_addr;
1925 u8 len = dm->length;
1927 dmi->type = data[4];
1929 memcpy(&base_addr, data+8, sizeof(unsigned long));
1931 if (base_addr & 1) {
1933 base_addr &= 0xFFFE;
1934 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1938 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1940 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1942 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1944 dmi->irq = data[0x11];
1946 /* The top two bits of byte 0x10 hold the register spacing. */
1947 reg_spacing = (data[0x10] & 0xC0) >> 6;
1948 switch(reg_spacing){
1949 case 0x00: /* Byte boundaries */
1952 case 0x01: /* 32-bit boundaries */
1955 case 0x02: /* 16-byte boundaries */
1959 /* Some other interface, just ignore it. */
1964 /* Note that technically, the lower bit of the base
1965 * address should be 1 if the address is I/O and 0 if
1966 * the address is in memory. So many systems get that
1967 * wrong (and all that I have seen are I/O) so we just
1968 * ignore that bit and assume I/O. Systems that use
1969 * memory should use the newer spec, anyway. */
1970 dmi->base_addr = base_addr & 0xfffe;
1971 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1975 dmi->slave_addr = data[6];
1980 static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
1982 struct smi_info *info;
1984 info = kzalloc(sizeof(*info), GFP_KERNEL);
1987 "ipmi_si: Could not allocate SI data\n");
1991 info->addr_source = "SMBIOS";
1993 switch (ipmi_data->type) {
1994 case 0x01: /* KCS */
1995 info->si_type = SI_KCS;
1997 case 0x02: /* SMIC */
1998 info->si_type = SI_SMIC;
2001 info->si_type = SI_BT;
2007 switch (ipmi_data->addr_space) {
2008 case IPMI_MEM_ADDR_SPACE:
2009 info->io_setup = mem_setup;
2010 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2013 case IPMI_IO_ADDR_SPACE:
2014 info->io_setup = port_setup;
2015 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2021 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
2022 ipmi_data->addr_space);
2025 info->io.addr_data = ipmi_data->base_addr;
2027 info->io.regspacing = ipmi_data->offset;
2028 if (!info->io.regspacing)
2029 info->io.regspacing = DEFAULT_REGSPACING;
2030 info->io.regsize = DEFAULT_REGSPACING;
2031 info->io.regshift = 0;
2033 info->slave_addr = ipmi_data->slave_addr;
2035 info->irq = ipmi_data->irq;
2037 info->irq_setup = std_irq_setup;
2042 static void __devinit dmi_find_bmc(void)
2044 struct dmi_device *dev = NULL;
2045 struct dmi_ipmi_data data;
2048 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
2049 memset(&data, 0, sizeof(data));
2050 rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
2052 try_init_dmi(&data);
2055 #endif /* CONFIG_DMI */
2059 #define PCI_ERMC_CLASSCODE 0x0C0700
2060 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
2061 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
2062 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
2063 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
2064 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
2066 #define PCI_HP_VENDOR_ID 0x103C
2067 #define PCI_MMC_DEVICE_ID 0x121A
2068 #define PCI_MMC_ADDR_CW 0x10
2070 static void ipmi_pci_cleanup(struct smi_info *info)
2072 struct pci_dev *pdev = info->addr_source_data;
2074 pci_disable_device(pdev);
2077 static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
2078 const struct pci_device_id *ent)
2081 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
2082 struct smi_info *info;
2083 int first_reg_offset = 0;
2085 info = kzalloc(sizeof(*info), GFP_KERNEL);
2089 info->addr_source = "PCI";
2091 switch (class_type) {
2092 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
2093 info->si_type = SI_SMIC;
2096 case PCI_ERMC_CLASSCODE_TYPE_KCS:
2097 info->si_type = SI_KCS;
2100 case PCI_ERMC_CLASSCODE_TYPE_BT:
2101 info->si_type = SI_BT;
2106 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
2107 pci_name(pdev), class_type);
2111 rv = pci_enable_device(pdev);
2113 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
2119 info->addr_source_cleanup = ipmi_pci_cleanup;
2120 info->addr_source_data = pdev;
2122 if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
2123 first_reg_offset = 1;
2125 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2126 info->io_setup = port_setup;
2127 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2129 info->io_setup = mem_setup;
2130 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2132 info->io.addr_data = pci_resource_start(pdev, 0);
2134 info->io.regspacing = DEFAULT_REGSPACING;
2135 info->io.regsize = DEFAULT_REGSPACING;
2136 info->io.regshift = 0;
2138 info->irq = pdev->irq;
2140 info->irq_setup = std_irq_setup;
2142 info->dev = &pdev->dev;
2144 return try_smi_init(info);
2147 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
2152 static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
2157 static int ipmi_pci_resume(struct pci_dev *pdev)
2163 static struct pci_device_id ipmi_pci_devices[] = {
2164 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
2165 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) }
2167 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
2169 static struct pci_driver ipmi_pci_driver = {
2170 .name = DEVICE_NAME,
2171 .id_table = ipmi_pci_devices,
2172 .probe = ipmi_pci_probe,
2173 .remove = __devexit_p(ipmi_pci_remove),
2175 .suspend = ipmi_pci_suspend,
2176 .resume = ipmi_pci_resume,
2179 #endif /* CONFIG_PCI */
2182 #ifdef CONFIG_PPC_OF
2183 static int __devinit ipmi_of_probe(struct of_device *dev,
2184 const struct of_device_id *match)
2186 struct smi_info *info;
2187 struct resource resource;
2188 const int *regsize, *regspacing, *regshift;
2189 struct device_node *np = dev->node;
2193 dev_info(&dev->dev, PFX "probing via device tree\n");
2195 ret = of_address_to_resource(np, 0, &resource);
2197 dev_warn(&dev->dev, PFX "invalid address from OF\n");
2201 regsize = get_property(np, "reg-size", &proplen);
2202 if (regsize && proplen != 4) {
2203 dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
2207 regspacing = get_property(np, "reg-spacing", &proplen);
2208 if (regspacing && proplen != 4) {
2209 dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
2213 regshift = get_property(np, "reg-shift", &proplen);
2214 if (regshift && proplen != 4) {
2215 dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
2219 info = kzalloc(sizeof(*info), GFP_KERNEL);
2223 PFX "could not allocate memory for OF probe\n");
2227 info->si_type = (enum si_type) match->data;
2228 info->addr_source = "device-tree";
2229 info->io_setup = mem_setup;
2230 info->irq_setup = std_irq_setup;
2232 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2233 info->io.addr_data = resource.start;
2235 info->io.regsize = regsize ? *regsize : DEFAULT_REGSIZE;
2236 info->io.regspacing = regspacing ? *regspacing : DEFAULT_REGSPACING;
2237 info->io.regshift = regshift ? *regshift : 0;
2239 info->irq = irq_of_parse_and_map(dev->node, 0);
2240 info->dev = &dev->dev;
2242 dev_dbg(&dev->dev, "addr 0x%lx regsize %ld spacing %ld irq %x\n",
2243 info->io.addr_data, info->io.regsize, info->io.regspacing,
2246 dev->dev.driver_data = (void*) info;
2248 return try_smi_init(info);
2251 static int __devexit ipmi_of_remove(struct of_device *dev)
2253 cleanup_one_si(dev->dev.driver_data);
2257 static struct of_device_id ipmi_match[] =
2259 { .type = "ipmi", .compatible = "ipmi-kcs", .data = (void *)(unsigned long) SI_KCS },
2260 { .type = "ipmi", .compatible = "ipmi-smic", .data = (void *)(unsigned long) SI_SMIC },
2261 { .type = "ipmi", .compatible = "ipmi-bt", .data = (void *)(unsigned long) SI_BT },
2265 static struct of_platform_driver ipmi_of_platform_driver =
2268 .match_table = ipmi_match,
2269 .probe = ipmi_of_probe,
2270 .remove = __devexit_p(ipmi_of_remove),
2272 #endif /* CONFIG_PPC_OF */
2275 static int try_get_dev_id(struct smi_info *smi_info)
2277 unsigned char msg[2];
2278 unsigned char *resp;
2279 unsigned long resp_len;
2280 enum si_sm_result smi_result;
2283 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2287 /* Do a Get Device ID command, since it comes back with some
2289 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2290 msg[1] = IPMI_GET_DEVICE_ID_CMD;
2291 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2293 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
2296 if (smi_result == SI_SM_CALL_WITH_DELAY ||
2297 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
2298 schedule_timeout_uninterruptible(1);
2299 smi_result = smi_info->handlers->event(
2300 smi_info->si_sm, 100);
2302 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
2304 smi_result = smi_info->handlers->event(
2305 smi_info->si_sm, 0);
2310 if (smi_result == SI_SM_HOSED) {
2311 /* We couldn't get the state machine to run, so whatever's at
2312 the port is probably not an IPMI SMI interface. */
2317 /* Otherwise, we got some data. */
2318 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2319 resp, IPMI_MAX_MSG_LENGTH);
2320 if (resp_len < 14) {
2321 /* That's odd, it should be longer. */
2326 if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
2327 /* That's odd, it shouldn't be able to fail. */
2332 /* Record info from the get device id, in case we need it. */
2333 ipmi_demangle_device_id(resp+3, resp_len-3, &smi_info->device_id);
2340 static int type_file_read_proc(char *page, char **start, off_t off,
2341 int count, int *eof, void *data)
2343 struct smi_info *smi = data;
2345 return sprintf(page, "%s\n", si_to_str[smi->si_type]);
2348 static int stat_file_read_proc(char *page, char **start, off_t off,
2349 int count, int *eof, void *data)
2351 char *out = (char *) page;
2352 struct smi_info *smi = data;
2354 out += sprintf(out, "interrupts_enabled: %d\n",
2355 smi->irq && !smi->interrupt_disabled);
2356 out += sprintf(out, "short_timeouts: %ld\n",
2357 smi->short_timeouts);
2358 out += sprintf(out, "long_timeouts: %ld\n",
2359 smi->long_timeouts);
2360 out += sprintf(out, "timeout_restarts: %ld\n",
2361 smi->timeout_restarts);
2362 out += sprintf(out, "idles: %ld\n",
2364 out += sprintf(out, "interrupts: %ld\n",
2366 out += sprintf(out, "attentions: %ld\n",
2368 out += sprintf(out, "flag_fetches: %ld\n",
2370 out += sprintf(out, "hosed_count: %ld\n",
2372 out += sprintf(out, "complete_transactions: %ld\n",
2373 smi->complete_transactions);
2374 out += sprintf(out, "events: %ld\n",
2376 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
2377 smi->watchdog_pretimeouts);
2378 out += sprintf(out, "incoming_messages: %ld\n",
2379 smi->incoming_messages);
2384 static int param_read_proc(char *page, char **start, off_t off,
2385 int count, int *eof, void *data)
2387 struct smi_info *smi = data;
2389 return sprintf(page,
2390 "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
2391 si_to_str[smi->si_type],
2392 addr_space_to_str[smi->io.addr_type],
2402 * oem_data_avail_to_receive_msg_avail
2403 * @info - smi_info structure with msg_flags set
2405 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2406 * Returns 1 indicating need to re-run handle_flags().
2408 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2410 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2416 * setup_dell_poweredge_oem_data_handler
2417 * @info - smi_info.device_id must be populated
2419 * Systems that match, but have firmware version < 1.40 may assert
2420 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2421 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2422 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2423 * as RECEIVE_MSG_AVAIL instead.
2425 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2426 * assert the OEM[012] bits, and if it did, the driver would have to
2427 * change to handle that properly, we don't actually check for the
2429 * Device ID = 0x20 BMC on PowerEdge 8G servers
2430 * Device Revision = 0x80
2431 * Firmware Revision1 = 0x01 BMC version 1.40
2432 * Firmware Revision2 = 0x40 BCD encoded
2433 * IPMI Version = 0x51 IPMI 1.5
2434 * Manufacturer ID = A2 02 00 Dell IANA
2436 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2437 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2440 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2441 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2442 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2443 #define DELL_IANA_MFR_ID 0x0002a2
2444 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2446 struct ipmi_device_id *id = &smi_info->device_id;
2447 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
2448 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2449 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2450 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
2451 smi_info->oem_data_avail_handler =
2452 oem_data_avail_to_receive_msg_avail;
2454 else if (ipmi_version_major(id) < 1 ||
2455 (ipmi_version_major(id) == 1 &&
2456 ipmi_version_minor(id) < 5)) {
2457 smi_info->oem_data_avail_handler =
2458 oem_data_avail_to_receive_msg_avail;
2463 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2464 static void return_hosed_msg_badsize(struct smi_info *smi_info)
2466 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2468 /* Make it a reponse */
2469 msg->rsp[0] = msg->data[0] | 4;
2470 msg->rsp[1] = msg->data[1];
2471 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2473 smi_info->curr_msg = NULL;
2474 deliver_recv_msg(smi_info, msg);
2478 * dell_poweredge_bt_xaction_handler
2479 * @info - smi_info.device_id must be populated
2481 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2482 * not respond to a Get SDR command if the length of the data
2483 * requested is exactly 0x3A, which leads to command timeouts and no
2484 * data returned. This intercepts such commands, and causes userspace
2485 * callers to try again with a different-sized buffer, which succeeds.
2488 #define STORAGE_NETFN 0x0A
2489 #define STORAGE_CMD_GET_SDR 0x23
2490 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2491 unsigned long unused,
2494 struct smi_info *smi_info = in;
2495 unsigned char *data = smi_info->curr_msg->data;
2496 unsigned int size = smi_info->curr_msg->data_size;
2498 (data[0]>>2) == STORAGE_NETFN &&
2499 data[1] == STORAGE_CMD_GET_SDR &&
2501 return_hosed_msg_badsize(smi_info);
2507 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2508 .notifier_call = dell_poweredge_bt_xaction_handler,
2512 * setup_dell_poweredge_bt_xaction_handler
2513 * @info - smi_info.device_id must be filled in already
2515 * Fills in smi_info.device_id.start_transaction_pre_hook
2516 * when we know what function to use there.
2519 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2521 struct ipmi_device_id *id = &smi_info->device_id;
2522 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2523 smi_info->si_type == SI_BT)
2524 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2528 * setup_oem_data_handler
2529 * @info - smi_info.device_id must be filled in already
2531 * Fills in smi_info.device_id.oem_data_available_handler
2532 * when we know what function to use there.
2535 static void setup_oem_data_handler(struct smi_info *smi_info)
2537 setup_dell_poweredge_oem_data_handler(smi_info);
2540 static void setup_xaction_handlers(struct smi_info *smi_info)
2542 setup_dell_poweredge_bt_xaction_handler(smi_info);
2545 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2547 if (smi_info->intf) {
2548 /* The timer and thread are only running if the
2549 interface has been started up and registered. */
2550 if (smi_info->thread != NULL)
2551 kthread_stop(smi_info->thread);
2552 del_timer_sync(&smi_info->si_timer);
2556 static __devinitdata struct ipmi_default_vals
2562 { .type = SI_KCS, .port = 0xca2 },
2563 { .type = SI_SMIC, .port = 0xca9 },
2564 { .type = SI_BT, .port = 0xe4 },
2568 static __devinit void default_find_bmc(void)
2570 struct smi_info *info;
2573 for (i = 0; ; i++) {
2574 if (!ipmi_defaults[i].port)
2577 info = kzalloc(sizeof(*info), GFP_KERNEL);
2581 #ifdef CONFIG_PPC_MERGE
2582 if (check_legacy_ioport(ipmi_defaults[i].port))
2586 info->addr_source = NULL;
2588 info->si_type = ipmi_defaults[i].type;
2589 info->io_setup = port_setup;
2590 info->io.addr_data = ipmi_defaults[i].port;
2591 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2593 info->io.addr = NULL;
2594 info->io.regspacing = DEFAULT_REGSPACING;
2595 info->io.regsize = DEFAULT_REGSPACING;
2596 info->io.regshift = 0;
2598 if (try_smi_init(info) == 0) {
2600 printk(KERN_INFO "ipmi_si: Found default %s state"
2601 " machine at %s address 0x%lx\n",
2602 si_to_str[info->si_type],
2603 addr_space_to_str[info->io.addr_type],
2604 info->io.addr_data);
2610 static int is_new_interface(struct smi_info *info)
2614 list_for_each_entry(e, &smi_infos, link) {
2615 if (e->io.addr_type != info->io.addr_type)
2617 if (e->io.addr_data == info->io.addr_data)
2624 static int try_smi_init(struct smi_info *new_smi)
2628 if (new_smi->addr_source) {
2629 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2630 " machine at %s address 0x%lx, slave address 0x%x,"
2632 new_smi->addr_source,
2633 si_to_str[new_smi->si_type],
2634 addr_space_to_str[new_smi->io.addr_type],
2635 new_smi->io.addr_data,
2636 new_smi->slave_addr, new_smi->irq);
2639 mutex_lock(&smi_infos_lock);
2640 if (!is_new_interface(new_smi)) {
2641 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2646 /* So we know not to free it unless we have allocated one. */
2647 new_smi->intf = NULL;
2648 new_smi->si_sm = NULL;
2649 new_smi->handlers = NULL;
2651 switch (new_smi->si_type) {
2653 new_smi->handlers = &kcs_smi_handlers;
2657 new_smi->handlers = &smic_smi_handlers;
2661 new_smi->handlers = &bt_smi_handlers;
2665 /* No support for anything else yet. */
2670 /* Allocate the state machine's data and initialize it. */
2671 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2672 if (!new_smi->si_sm) {
2673 printk(" Could not allocate state machine memory\n");
2677 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2680 /* Now that we know the I/O size, we can set up the I/O. */
2681 rv = new_smi->io_setup(new_smi);
2683 printk(" Could not set up I/O space\n");
2687 spin_lock_init(&(new_smi->si_lock));
2688 spin_lock_init(&(new_smi->msg_lock));
2689 spin_lock_init(&(new_smi->count_lock));
2691 /* Do low-level detection first. */
2692 if (new_smi->handlers->detect(new_smi->si_sm)) {
2693 if (new_smi->addr_source)
2694 printk(KERN_INFO "ipmi_si: Interface detection"
2700 /* Attempt a get device id command. If it fails, we probably
2701 don't have a BMC here. */
2702 rv = try_get_dev_id(new_smi);
2704 if (new_smi->addr_source)
2705 printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2706 " at this location\n");
2710 setup_oem_data_handler(new_smi);
2711 setup_xaction_handlers(new_smi);
2713 /* Try to claim any interrupts. */
2714 if (new_smi->irq_setup)
2715 new_smi->irq_setup(new_smi);
2717 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2718 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2719 new_smi->curr_msg = NULL;
2720 atomic_set(&new_smi->req_events, 0);
2721 new_smi->run_to_completion = 0;
2723 new_smi->interrupt_disabled = 0;
2724 atomic_set(&new_smi->stop_operation, 0);
2725 new_smi->intf_num = smi_num;
2728 /* Start clearing the flags before we enable interrupts or the
2729 timer to avoid racing with the timer. */
2730 start_clear_flags(new_smi);
2731 /* IRQ is defined to be set when non-zero. */
2733 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2735 if (!new_smi->dev) {
2736 /* If we don't already have a device from something
2737 * else (like PCI), then register a new one. */
2738 new_smi->pdev = platform_device_alloc("ipmi_si",
2743 " Unable to allocate platform device\n");
2746 new_smi->dev = &new_smi->pdev->dev;
2747 new_smi->dev->driver = &ipmi_driver;
2749 rv = platform_device_add(new_smi->pdev);
2753 " Unable to register system interface device:"
2758 new_smi->dev_registered = 1;
2761 rv = ipmi_register_smi(&handlers,
2763 &new_smi->device_id,
2766 new_smi->slave_addr);
2769 "ipmi_si: Unable to register device: error %d\n",
2771 goto out_err_stop_timer;
2774 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2775 type_file_read_proc, NULL,
2776 new_smi, THIS_MODULE);
2779 "ipmi_si: Unable to create proc entry: %d\n",
2781 goto out_err_stop_timer;
2784 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2785 stat_file_read_proc, NULL,
2786 new_smi, THIS_MODULE);
2789 "ipmi_si: Unable to create proc entry: %d\n",
2791 goto out_err_stop_timer;
2794 rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
2795 param_read_proc, NULL,
2796 new_smi, THIS_MODULE);
2799 "ipmi_si: Unable to create proc entry: %d\n",
2801 goto out_err_stop_timer;
2804 list_add_tail(&new_smi->link, &smi_infos);
2806 mutex_unlock(&smi_infos_lock);
2808 printk(" IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
2813 atomic_inc(&new_smi->stop_operation);
2814 wait_for_timer_and_thread(new_smi);
2818 ipmi_unregister_smi(new_smi->intf);
2820 if (new_smi->irq_cleanup)
2821 new_smi->irq_cleanup(new_smi);
2823 /* Wait until we know that we are out of any interrupt
2824 handlers might have been running before we freed the
2826 synchronize_sched();
2828 if (new_smi->si_sm) {
2829 if (new_smi->handlers)
2830 new_smi->handlers->cleanup(new_smi->si_sm);
2831 kfree(new_smi->si_sm);
2833 if (new_smi->addr_source_cleanup)
2834 new_smi->addr_source_cleanup(new_smi);
2835 if (new_smi->io_cleanup)
2836 new_smi->io_cleanup(new_smi);
2838 if (new_smi->dev_registered)
2839 platform_device_unregister(new_smi->pdev);
2843 mutex_unlock(&smi_infos_lock);
2848 static __devinit int init_ipmi_si(void)
2858 /* Register the device drivers. */
2859 rv = driver_register(&ipmi_driver);
2862 "init_ipmi_si: Unable to register driver: %d\n",
2868 /* Parse out the si_type string into its components. */
2871 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
2873 str = strchr(str, ',');
2883 printk(KERN_INFO "IPMI System Interface driver.\n");
2885 hardcode_find_bmc();
2896 rv = pci_register_driver(&ipmi_pci_driver);
2899 "init_ipmi_si: Unable to register PCI driver: %d\n",
2904 #ifdef CONFIG_PPC_OF
2905 of_register_platform_driver(&ipmi_of_platform_driver);
2908 if (si_trydefaults) {
2909 mutex_lock(&smi_infos_lock);
2910 if (list_empty(&smi_infos)) {
2911 /* No BMC was found, try defaults. */
2912 mutex_unlock(&smi_infos_lock);
2915 mutex_unlock(&smi_infos_lock);
2919 mutex_lock(&smi_infos_lock);
2920 if (unload_when_empty && list_empty(&smi_infos)) {
2921 mutex_unlock(&smi_infos_lock);
2923 pci_unregister_driver(&ipmi_pci_driver);
2925 driver_unregister(&ipmi_driver);
2926 printk("ipmi_si: Unable to find any System Interface(s)\n");
2929 mutex_unlock(&smi_infos_lock);
2933 module_init(init_ipmi_si);
2935 static void cleanup_one_si(struct smi_info *to_clean)
2938 unsigned long flags;
2943 list_del(&to_clean->link);
2945 /* Tell the timer and interrupt handlers that we are shutting
2947 spin_lock_irqsave(&(to_clean->si_lock), flags);
2948 spin_lock(&(to_clean->msg_lock));
2950 atomic_inc(&to_clean->stop_operation);
2952 if (to_clean->irq_cleanup)
2953 to_clean->irq_cleanup(to_clean);
2955 spin_unlock(&(to_clean->msg_lock));
2956 spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2958 /* Wait until we know that we are out of any interrupt
2959 handlers might have been running before we freed the
2961 synchronize_sched();
2963 wait_for_timer_and_thread(to_clean);
2965 /* Interrupts and timeouts are stopped, now make sure the
2966 interface is in a clean state. */
2967 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
2969 schedule_timeout_uninterruptible(1);
2972 rv = ipmi_unregister_smi(to_clean->intf);
2975 "ipmi_si: Unable to unregister device: errno=%d\n",
2979 to_clean->handlers->cleanup(to_clean->si_sm);
2981 kfree(to_clean->si_sm);
2983 if (to_clean->addr_source_cleanup)
2984 to_clean->addr_source_cleanup(to_clean);
2985 if (to_clean->io_cleanup)
2986 to_clean->io_cleanup(to_clean);
2988 if (to_clean->dev_registered)
2989 platform_device_unregister(to_clean->pdev);
2994 static __exit void cleanup_ipmi_si(void)
2996 struct smi_info *e, *tmp_e;
3002 pci_unregister_driver(&ipmi_pci_driver);
3005 #ifdef CONFIG_PPC_OF
3006 of_unregister_platform_driver(&ipmi_of_platform_driver);
3009 mutex_lock(&smi_infos_lock);
3010 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
3012 mutex_unlock(&smi_infos_lock);
3014 driver_unregister(&ipmi_driver);
3016 module_exit(cleanup_ipmi_si);
3018 MODULE_LICENSE("GPL");
3019 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
3020 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");