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/config.h>
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>
55 #ifdef CONFIG_HIGH_RES_TIMERS
56 #include <linux/hrtime.h>
57 # if defined(schedule_next_int)
58 /* Old high-res timer code, do translations. */
59 # define get_arch_cycles(a) quick_update_jiffies_sub(a)
60 # define arch_cycles_per_jiffy cycles_per_jiffies
62 static inline void add_usec_to_timer(struct timer_list *t, long v)
64 t->sub_expires += nsec_to_arch_cycle(v * 1000);
65 while (t->sub_expires >= arch_cycles_per_jiffy)
68 t->sub_expires -= arch_cycles_per_jiffy;
72 #include <linux/interrupt.h>
73 #include <linux/rcupdate.h>
74 #include <linux/ipmi_smi.h>
76 #include "ipmi_si_sm.h"
77 #include <linux/init.h>
79 #define IPMI_SI_VERSION "v32"
81 /* Measure times between events in the driver. */
84 /* Call every 10 ms. */
85 #define SI_TIMEOUT_TIME_USEC 10000
86 #define SI_USEC_PER_JIFFY (1000000/HZ)
87 #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
88 #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
96 SI_CLEARING_FLAGS_THEN_SET_IRQ,
98 SI_ENABLE_INTERRUPTS1,
100 /* FIXME - add watchdog stuff. */
104 SI_KCS, SI_SMIC, SI_BT
110 struct si_sm_data *si_sm;
111 struct si_sm_handlers *handlers;
112 enum si_type si_type;
115 struct list_head xmit_msgs;
116 struct list_head hp_xmit_msgs;
117 struct ipmi_smi_msg *curr_msg;
118 enum si_intf_state si_state;
120 /* Used to handle the various types of I/O that can occur with
123 int (*io_setup)(struct smi_info *info);
124 void (*io_cleanup)(struct smi_info *info);
125 int (*irq_setup)(struct smi_info *info);
126 void (*irq_cleanup)(struct smi_info *info);
127 unsigned int io_size;
129 /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
130 is set to hold the flags until we are done handling everything
132 #define RECEIVE_MSG_AVAIL 0x01
133 #define EVENT_MSG_BUFFER_FULL 0x02
134 #define WDT_PRE_TIMEOUT_INT 0x08
135 unsigned char msg_flags;
137 /* If set to true, this will request events the next time the
138 state machine is idle. */
141 /* If true, run the state machine to completion on every send
142 call. Generally used after a panic to make sure stuff goes
144 int run_to_completion;
146 /* The I/O port of an SI interface. */
149 /* zero if no irq; */
152 /* The timer for this si. */
153 struct timer_list si_timer;
155 /* The time (in jiffies) the last timeout occurred at. */
156 unsigned long last_timeout_jiffies;
158 /* Used to gracefully stop the timer without race conditions. */
159 volatile int stop_operation;
160 volatile int timer_stopped;
162 /* The driver will disable interrupts when it gets into a
163 situation where it cannot handle messages due to lack of
164 memory. Once that situation clears up, it will re-enable
166 int interrupt_disabled;
168 unsigned char ipmi_si_dev_rev;
169 unsigned char ipmi_si_fw_rev_major;
170 unsigned char ipmi_si_fw_rev_minor;
171 unsigned char ipmi_version_major;
172 unsigned char ipmi_version_minor;
174 /* Counters and things for the proc filesystem. */
175 spinlock_t count_lock;
176 unsigned long short_timeouts;
177 unsigned long long_timeouts;
178 unsigned long timeout_restarts;
180 unsigned long interrupts;
181 unsigned long attentions;
182 unsigned long flag_fetches;
183 unsigned long hosed_count;
184 unsigned long complete_transactions;
185 unsigned long events;
186 unsigned long watchdog_pretimeouts;
187 unsigned long incoming_messages;
190 static void si_restart_short_timer(struct smi_info *smi_info);
192 static void deliver_recv_msg(struct smi_info *smi_info,
193 struct ipmi_smi_msg *msg)
195 /* Deliver the message to the upper layer with the lock
197 spin_unlock(&(smi_info->si_lock));
198 ipmi_smi_msg_received(smi_info->intf, msg);
199 spin_lock(&(smi_info->si_lock));
202 static void return_hosed_msg(struct smi_info *smi_info)
204 struct ipmi_smi_msg *msg = smi_info->curr_msg;
206 /* Make it a reponse */
207 msg->rsp[0] = msg->data[0] | 4;
208 msg->rsp[1] = msg->data[1];
209 msg->rsp[2] = 0xFF; /* Unknown error. */
212 smi_info->curr_msg = NULL;
213 deliver_recv_msg(smi_info, msg);
216 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
219 struct list_head *entry = NULL;
224 /* No need to save flags, we aleady have interrupts off and we
225 already hold the SMI lock. */
226 spin_lock(&(smi_info->msg_lock));
228 /* Pick the high priority queue first. */
229 if (! list_empty(&(smi_info->hp_xmit_msgs))) {
230 entry = smi_info->hp_xmit_msgs.next;
231 } else if (! list_empty(&(smi_info->xmit_msgs))) {
232 entry = smi_info->xmit_msgs.next;
236 smi_info->curr_msg = NULL;
242 smi_info->curr_msg = list_entry(entry,
247 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
249 err = smi_info->handlers->start_transaction(
251 smi_info->curr_msg->data,
252 smi_info->curr_msg->data_size);
254 return_hosed_msg(smi_info);
257 rv = SI_SM_CALL_WITHOUT_DELAY;
259 spin_unlock(&(smi_info->msg_lock));
264 static void start_enable_irq(struct smi_info *smi_info)
266 unsigned char msg[2];
268 /* If we are enabling interrupts, we have to tell the
270 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
271 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
273 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
274 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
277 static void start_clear_flags(struct smi_info *smi_info)
279 unsigned char msg[3];
281 /* Make sure the watchdog pre-timeout flag is not set at startup. */
282 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
283 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
284 msg[2] = WDT_PRE_TIMEOUT_INT;
286 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
287 smi_info->si_state = SI_CLEARING_FLAGS;
290 /* When we have a situtaion where we run out of memory and cannot
291 allocate messages, we just leave them in the BMC and run the system
292 polled until we can allocate some memory. Once we have some
293 memory, we will re-enable the interrupt. */
294 static inline void disable_si_irq(struct smi_info *smi_info)
296 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
297 disable_irq_nosync(smi_info->irq);
298 smi_info->interrupt_disabled = 1;
302 static inline void enable_si_irq(struct smi_info *smi_info)
304 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
305 enable_irq(smi_info->irq);
306 smi_info->interrupt_disabled = 0;
310 static void handle_flags(struct smi_info *smi_info)
312 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
313 /* Watchdog pre-timeout */
314 spin_lock(&smi_info->count_lock);
315 smi_info->watchdog_pretimeouts++;
316 spin_unlock(&smi_info->count_lock);
318 start_clear_flags(smi_info);
319 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
320 spin_unlock(&(smi_info->si_lock));
321 ipmi_smi_watchdog_pretimeout(smi_info->intf);
322 spin_lock(&(smi_info->si_lock));
323 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
324 /* Messages available. */
325 smi_info->curr_msg = ipmi_alloc_smi_msg();
326 if (!smi_info->curr_msg) {
327 disable_si_irq(smi_info);
328 smi_info->si_state = SI_NORMAL;
331 enable_si_irq(smi_info);
333 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
334 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
335 smi_info->curr_msg->data_size = 2;
337 smi_info->handlers->start_transaction(
339 smi_info->curr_msg->data,
340 smi_info->curr_msg->data_size);
341 smi_info->si_state = SI_GETTING_MESSAGES;
342 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
343 /* Events available. */
344 smi_info->curr_msg = ipmi_alloc_smi_msg();
345 if (!smi_info->curr_msg) {
346 disable_si_irq(smi_info);
347 smi_info->si_state = SI_NORMAL;
350 enable_si_irq(smi_info);
352 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
353 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
354 smi_info->curr_msg->data_size = 2;
356 smi_info->handlers->start_transaction(
358 smi_info->curr_msg->data,
359 smi_info->curr_msg->data_size);
360 smi_info->si_state = SI_GETTING_EVENTS;
362 smi_info->si_state = SI_NORMAL;
366 static void handle_transaction_done(struct smi_info *smi_info)
368 struct ipmi_smi_msg *msg;
373 printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
375 switch (smi_info->si_state) {
377 if (!smi_info->curr_msg)
380 smi_info->curr_msg->rsp_size
381 = smi_info->handlers->get_result(
383 smi_info->curr_msg->rsp,
384 IPMI_MAX_MSG_LENGTH);
386 /* Do this here becase deliver_recv_msg() releases the
387 lock, and a new message can be put in during the
388 time the lock is released. */
389 msg = smi_info->curr_msg;
390 smi_info->curr_msg = NULL;
391 deliver_recv_msg(smi_info, msg);
394 case SI_GETTING_FLAGS:
396 unsigned char msg[4];
399 /* We got the flags from the SMI, now handle them. */
400 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
402 /* Error fetching flags, just give up for
404 smi_info->si_state = SI_NORMAL;
405 } else if (len < 3) {
406 /* Hmm, no flags. That's technically illegal, but
407 don't use uninitialized data. */
408 smi_info->si_state = SI_NORMAL;
410 smi_info->msg_flags = msg[3];
411 handle_flags(smi_info);
416 case SI_CLEARING_FLAGS:
417 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
419 unsigned char msg[3];
421 /* We cleared the flags. */
422 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
424 /* Error clearing flags */
426 "ipmi_si: Error clearing flags: %2.2x\n",
429 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
430 start_enable_irq(smi_info);
432 smi_info->si_state = SI_NORMAL;
436 case SI_GETTING_EVENTS:
438 smi_info->curr_msg->rsp_size
439 = smi_info->handlers->get_result(
441 smi_info->curr_msg->rsp,
442 IPMI_MAX_MSG_LENGTH);
444 /* Do this here becase deliver_recv_msg() releases the
445 lock, and a new message can be put in during the
446 time the lock is released. */
447 msg = smi_info->curr_msg;
448 smi_info->curr_msg = NULL;
449 if (msg->rsp[2] != 0) {
450 /* Error getting event, probably done. */
453 /* Take off the event flag. */
454 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
456 spin_lock(&smi_info->count_lock);
458 spin_unlock(&smi_info->count_lock);
460 deliver_recv_msg(smi_info, msg);
462 handle_flags(smi_info);
466 case SI_GETTING_MESSAGES:
468 smi_info->curr_msg->rsp_size
469 = smi_info->handlers->get_result(
471 smi_info->curr_msg->rsp,
472 IPMI_MAX_MSG_LENGTH);
474 /* Do this here becase deliver_recv_msg() releases the
475 lock, and a new message can be put in during the
476 time the lock is released. */
477 msg = smi_info->curr_msg;
478 smi_info->curr_msg = NULL;
479 if (msg->rsp[2] != 0) {
480 /* Error getting event, probably done. */
483 /* Take off the msg flag. */
484 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
486 spin_lock(&smi_info->count_lock);
487 smi_info->incoming_messages++;
488 spin_unlock(&smi_info->count_lock);
490 deliver_recv_msg(smi_info, msg);
492 handle_flags(smi_info);
496 case SI_ENABLE_INTERRUPTS1:
498 unsigned char msg[4];
500 /* We got the flags from the SMI, now handle them. */
501 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
504 "ipmi_si: Could not enable interrupts"
505 ", failed get, using polled mode.\n");
506 smi_info->si_state = SI_NORMAL;
508 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
509 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
510 msg[2] = msg[3] | 1; /* enable msg queue int */
511 smi_info->handlers->start_transaction(
512 smi_info->si_sm, msg, 3);
513 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
518 case SI_ENABLE_INTERRUPTS2:
520 unsigned char msg[4];
522 /* We got the flags from the SMI, now handle them. */
523 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
526 "ipmi_si: Could not enable interrupts"
527 ", failed set, using polled mode.\n");
529 smi_info->si_state = SI_NORMAL;
535 /* Called on timeouts and events. Timeouts should pass the elapsed
536 time, interrupts should pass in zero. */
537 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
540 enum si_sm_result si_sm_result;
543 /* There used to be a loop here that waited a little while
544 (around 25us) before giving up. That turned out to be
545 pointless, the minimum delays I was seeing were in the 300us
546 range, which is far too long to wait in an interrupt. So
547 we just run until the state machine tells us something
548 happened or it needs a delay. */
549 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
551 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
553 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
556 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
558 spin_lock(&smi_info->count_lock);
559 smi_info->complete_transactions++;
560 spin_unlock(&smi_info->count_lock);
562 handle_transaction_done(smi_info);
563 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
565 else if (si_sm_result == SI_SM_HOSED)
567 spin_lock(&smi_info->count_lock);
568 smi_info->hosed_count++;
569 spin_unlock(&smi_info->count_lock);
571 if (smi_info->curr_msg != NULL) {
572 /* If we were handling a user message, format
573 a response to send to the upper layer to
574 tell it about the error. */
575 return_hosed_msg(smi_info);
577 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
578 smi_info->si_state = SI_NORMAL;
581 /* We prefer handling attn over new messages. */
582 if (si_sm_result == SI_SM_ATTN)
584 unsigned char msg[2];
586 spin_lock(&smi_info->count_lock);
587 smi_info->attentions++;
588 spin_unlock(&smi_info->count_lock);
590 /* Got a attn, send down a get message flags to see
591 what's causing it. It would be better to handle
592 this in the upper layer, but due to the way
593 interrupts work with the SMI, that's not really
595 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
596 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
598 smi_info->handlers->start_transaction(
599 smi_info->si_sm, msg, 2);
600 smi_info->si_state = SI_GETTING_FLAGS;
604 /* If we are currently idle, try to start the next message. */
605 if (si_sm_result == SI_SM_IDLE) {
606 spin_lock(&smi_info->count_lock);
608 spin_unlock(&smi_info->count_lock);
610 si_sm_result = start_next_msg(smi_info);
611 if (si_sm_result != SI_SM_IDLE)
615 if ((si_sm_result == SI_SM_IDLE)
616 && (atomic_read(&smi_info->req_events)))
618 /* We are idle and the upper layer requested that I fetch
620 unsigned char msg[2];
622 spin_lock(&smi_info->count_lock);
623 smi_info->flag_fetches++;
624 spin_unlock(&smi_info->count_lock);
626 atomic_set(&smi_info->req_events, 0);
627 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
628 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
630 smi_info->handlers->start_transaction(
631 smi_info->si_sm, msg, 2);
632 smi_info->si_state = SI_GETTING_FLAGS;
639 static void sender(void *send_info,
640 struct ipmi_smi_msg *msg,
643 struct smi_info *smi_info = send_info;
644 enum si_sm_result result;
650 spin_lock_irqsave(&(smi_info->msg_lock), flags);
653 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
656 if (smi_info->run_to_completion) {
657 /* If we are running to completion, then throw it in
658 the list and run transactions until everything is
659 clear. Priority doesn't matter here. */
660 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
662 /* We have to release the msg lock and claim the smi
663 lock in this case, because of race conditions. */
664 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
666 spin_lock_irqsave(&(smi_info->si_lock), flags);
667 result = smi_event_handler(smi_info, 0);
668 while (result != SI_SM_IDLE) {
669 udelay(SI_SHORT_TIMEOUT_USEC);
670 result = smi_event_handler(smi_info,
671 SI_SHORT_TIMEOUT_USEC);
673 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
677 list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
679 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
682 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
684 spin_lock_irqsave(&(smi_info->si_lock), flags);
685 if ((smi_info->si_state == SI_NORMAL)
686 && (smi_info->curr_msg == NULL))
688 start_next_msg(smi_info);
689 si_restart_short_timer(smi_info);
691 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
694 static void set_run_to_completion(void *send_info, int i_run_to_completion)
696 struct smi_info *smi_info = send_info;
697 enum si_sm_result result;
700 spin_lock_irqsave(&(smi_info->si_lock), flags);
702 smi_info->run_to_completion = i_run_to_completion;
703 if (i_run_to_completion) {
704 result = smi_event_handler(smi_info, 0);
705 while (result != SI_SM_IDLE) {
706 udelay(SI_SHORT_TIMEOUT_USEC);
707 result = smi_event_handler(smi_info,
708 SI_SHORT_TIMEOUT_USEC);
712 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
715 static void poll(void *send_info)
717 struct smi_info *smi_info = send_info;
719 smi_event_handler(smi_info, 0);
722 static void request_events(void *send_info)
724 struct smi_info *smi_info = send_info;
726 atomic_set(&smi_info->req_events, 1);
729 static int initialized = 0;
731 /* Must be called with interrupts off and with the si_lock held. */
732 static void si_restart_short_timer(struct smi_info *smi_info)
734 #if defined(CONFIG_HIGH_RES_TIMERS)
736 unsigned long jiffies_now;
738 if (del_timer(&(smi_info->si_timer))) {
739 /* If we don't delete the timer, then it will go off
740 immediately, anyway. So we only process if we
741 actually delete the timer. */
743 /* We already have irqsave on, so no need for it
745 read_lock(&xtime_lock);
746 jiffies_now = jiffies;
747 smi_info->si_timer.expires = jiffies_now;
748 smi_info->si_timer.sub_expires = get_arch_cycles(jiffies_now);
750 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
752 add_timer(&(smi_info->si_timer));
753 spin_lock_irqsave(&smi_info->count_lock, flags);
754 smi_info->timeout_restarts++;
755 spin_unlock_irqrestore(&smi_info->count_lock, flags);
760 static void smi_timeout(unsigned long data)
762 struct smi_info *smi_info = (struct smi_info *) data;
763 enum si_sm_result smi_result;
765 unsigned long jiffies_now;
766 unsigned long time_diff;
771 if (smi_info->stop_operation) {
772 smi_info->timer_stopped = 1;
776 spin_lock_irqsave(&(smi_info->si_lock), flags);
779 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
781 jiffies_now = jiffies;
782 time_diff = ((jiffies_now - smi_info->last_timeout_jiffies)
783 * SI_USEC_PER_JIFFY);
784 smi_result = smi_event_handler(smi_info, time_diff);
786 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
788 smi_info->last_timeout_jiffies = jiffies_now;
790 if ((smi_info->irq) && (! smi_info->interrupt_disabled)) {
791 /* Running with interrupts, only do long timeouts. */
792 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
793 spin_lock_irqsave(&smi_info->count_lock, flags);
794 smi_info->long_timeouts++;
795 spin_unlock_irqrestore(&smi_info->count_lock, flags);
799 /* If the state machine asks for a short delay, then shorten
800 the timer timeout. */
801 if (smi_result == SI_SM_CALL_WITH_DELAY) {
802 spin_lock_irqsave(&smi_info->count_lock, flags);
803 smi_info->short_timeouts++;
804 spin_unlock_irqrestore(&smi_info->count_lock, flags);
805 #if defined(CONFIG_HIGH_RES_TIMERS)
806 read_lock(&xtime_lock);
807 smi_info->si_timer.expires = jiffies;
808 smi_info->si_timer.sub_expires
809 = get_arch_cycles(smi_info->si_timer.expires);
810 read_unlock(&xtime_lock);
811 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
813 smi_info->si_timer.expires = jiffies + 1;
816 spin_lock_irqsave(&smi_info->count_lock, flags);
817 smi_info->long_timeouts++;
818 spin_unlock_irqrestore(&smi_info->count_lock, flags);
819 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
820 #if defined(CONFIG_HIGH_RES_TIMERS)
821 smi_info->si_timer.sub_expires = 0;
826 add_timer(&(smi_info->si_timer));
829 static irqreturn_t si_irq_handler(int irq, void *data, struct pt_regs *regs)
831 struct smi_info *smi_info = data;
837 spin_lock_irqsave(&(smi_info->si_lock), flags);
839 spin_lock(&smi_info->count_lock);
840 smi_info->interrupts++;
841 spin_unlock(&smi_info->count_lock);
843 if (smi_info->stop_operation)
848 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
850 smi_event_handler(smi_info, 0);
852 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
856 static struct ipmi_smi_handlers handlers =
858 .owner = THIS_MODULE,
860 .request_events = request_events,
861 .set_run_to_completion = set_run_to_completion,
865 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
866 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
868 #define SI_MAX_PARMS 4
869 #define SI_MAX_DRIVERS ((SI_MAX_PARMS * 2) + 2)
870 static struct smi_info *smi_infos[SI_MAX_DRIVERS] =
871 { NULL, NULL, NULL, NULL };
873 #define DEVICE_NAME "ipmi_si"
875 #define DEFAULT_KCS_IO_PORT 0xca2
876 #define DEFAULT_SMIC_IO_PORT 0xca9
877 #define DEFAULT_BT_IO_PORT 0xe4
879 static int si_trydefaults = 1;
880 static char *si_type[SI_MAX_PARMS] = { NULL, NULL, NULL, NULL };
881 #define MAX_SI_TYPE_STR 30
882 static char si_type_str[MAX_SI_TYPE_STR];
883 static unsigned long addrs[SI_MAX_PARMS] = { 0, 0, 0, 0 };
884 static int num_addrs = 0;
885 static unsigned int ports[SI_MAX_PARMS] = { 0, 0, 0, 0 };
886 static int num_ports = 0;
887 static int irqs[SI_MAX_PARMS] = { 0, 0, 0, 0 };
888 static int num_irqs = 0;
891 module_param_named(trydefaults, si_trydefaults, bool, 0);
892 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
893 " default scan of the KCS and SMIC interface at the standard"
895 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
896 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
897 " interface separated by commas. The types are 'kcs',"
898 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
899 " the first interface to kcs and the second to bt");
900 module_param_array(addrs, long, num_addrs, 0);
901 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
902 " addresses separated by commas. Only use if an interface"
903 " is in memory. Otherwise, set it to zero or leave"
905 module_param_array(ports, int, num_ports, 0);
906 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
907 " addresses separated by commas. Only use if an interface"
908 " is a port. Otherwise, set it to zero or leave"
910 module_param_array(irqs, int, num_irqs, 0);
911 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
912 " addresses separated by commas. Only use if an interface"
913 " has an interrupt. Otherwise, set it to zero or leave"
916 #define IPMI_MEM_ADDR_SPACE 1
917 #define IPMI_IO_ADDR_SPACE 2
919 #if defined(CONFIG_ACPI_INTERPETER) || defined(CONFIG_X86) || defined(CONFIG_PCI)
920 static int is_new_interface(int intf, u8 addr_space, unsigned long base_addr)
924 for (i = 0; i < SI_MAX_PARMS; ++i) {
925 /* Don't check our address. */
928 if (si_type[i] != NULL) {
929 if ((addr_space == IPMI_MEM_ADDR_SPACE &&
930 base_addr == addrs[i]) ||
931 (addr_space == IPMI_IO_ADDR_SPACE &&
932 base_addr == ports[i]))
943 static int std_irq_setup(struct smi_info *info)
950 rv = request_irq(info->irq,
957 "ipmi_si: %s unable to claim interrupt %d,"
959 DEVICE_NAME, info->irq);
962 printk(" Using irq %d\n", info->irq);
968 static void std_irq_cleanup(struct smi_info *info)
973 free_irq(info->irq, info);
976 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
978 unsigned int *addr = io->info;
980 return inb((*addr)+offset);
983 static void port_outb(struct si_sm_io *io, unsigned int offset,
986 unsigned int *addr = io->info;
988 outb(b, (*addr)+offset);
991 static int port_setup(struct smi_info *info)
993 unsigned int *addr = info->io.info;
995 if (!addr || (!*addr))
998 if (request_region(*addr, info->io_size, DEVICE_NAME) == NULL)
1003 static void port_cleanup(struct smi_info *info)
1005 unsigned int *addr = info->io.info;
1007 if (addr && (*addr))
1008 release_region (*addr, info->io_size);
1012 static int try_init_port(int intf_num, struct smi_info **new_info)
1014 struct smi_info *info;
1016 if (!ports[intf_num])
1019 if (!is_new_interface(intf_num, IPMI_IO_ADDR_SPACE,
1023 info = kmalloc(sizeof(*info), GFP_KERNEL);
1025 printk(KERN_ERR "ipmi_si: Could not allocate SI data (1)\n");
1028 memset(info, 0, sizeof(*info));
1030 info->io_setup = port_setup;
1031 info->io_cleanup = port_cleanup;
1032 info->io.inputb = port_inb;
1033 info->io.outputb = port_outb;
1034 info->io.info = &(ports[intf_num]);
1035 info->io.addr = NULL;
1037 info->irq_setup = NULL;
1040 if (si_type[intf_num] == NULL)
1041 si_type[intf_num] = "kcs";
1043 printk("ipmi_si: Trying \"%s\" at I/O port 0x%x\n",
1044 si_type[intf_num], ports[intf_num]);
1048 static unsigned char mem_inb(struct si_sm_io *io, unsigned int offset)
1050 return readb((io->addr)+offset);
1053 static void mem_outb(struct si_sm_io *io, unsigned int offset,
1056 writeb(b, (io->addr)+offset);
1059 static int mem_setup(struct smi_info *info)
1061 unsigned long *addr = info->io.info;
1063 if (!addr || (!*addr))
1066 if (request_mem_region(*addr, info->io_size, DEVICE_NAME) == NULL)
1069 info->io.addr = ioremap(*addr, info->io_size);
1070 if (info->io.addr == NULL) {
1071 release_mem_region(*addr, info->io_size);
1077 static void mem_cleanup(struct smi_info *info)
1079 unsigned long *addr = info->io.info;
1081 if (info->io.addr) {
1082 iounmap(info->io.addr);
1083 release_mem_region(*addr, info->io_size);
1088 static int try_init_mem(int intf_num, struct smi_info **new_info)
1090 struct smi_info *info;
1092 if (!addrs[intf_num])
1095 if (!is_new_interface(intf_num, IPMI_MEM_ADDR_SPACE,
1099 info = kmalloc(sizeof(*info), GFP_KERNEL);
1101 printk(KERN_ERR "ipmi_si: Could not allocate SI data (2)\n");
1104 memset(info, 0, sizeof(*info));
1106 info->io_setup = mem_setup;
1107 info->io_cleanup = mem_cleanup;
1108 info->io.inputb = mem_inb;
1109 info->io.outputb = mem_outb;
1110 info->io.info = (void *) addrs[intf_num];
1111 info->io.addr = NULL;
1113 info->irq_setup = NULL;
1116 if (si_type[intf_num] == NULL)
1117 si_type[intf_num] = "kcs";
1119 printk("ipmi_si: Trying \"%s\" at memory address 0x%lx\n",
1120 si_type[intf_num], addrs[intf_num]);
1125 #ifdef CONFIG_ACPI_INTERPRETER
1127 #include <linux/acpi.h>
1129 /* Once we get an ACPI failure, we don't try any more, because we go
1130 through the tables sequentially. Once we don't find a table, there
1132 static int acpi_failure = 0;
1134 /* For GPE-type interrupts. */
1135 void ipmi_acpi_gpe(void *context)
1137 struct smi_info *smi_info = context;
1138 unsigned long flags;
1143 spin_lock_irqsave(&(smi_info->si_lock), flags);
1145 spin_lock(&smi_info->count_lock);
1146 smi_info->interrupts++;
1147 spin_unlock(&smi_info->count_lock);
1149 if (smi_info->stop_operation)
1153 do_gettimeofday(&t);
1154 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1156 smi_event_handler(smi_info, 0);
1158 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1161 static int acpi_gpe_irq_setup(struct smi_info *info)
1168 /* FIXME - is level triggered right? */
1169 status = acpi_install_gpe_handler(NULL,
1171 ACPI_GPE_LEVEL_TRIGGERED,
1174 if (status != AE_OK) {
1176 "ipmi_si: %s unable to claim ACPI GPE %d,"
1177 " running polled\n",
1178 DEVICE_NAME, info->irq);
1182 printk(" Using ACPI GPE %d\n", info->irq);
1188 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1193 acpi_remove_gpe_handler(NULL, info->irq, ipmi_acpi_gpe);
1198 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1209 s8 CreatorRevision[4];
1212 s16 SpecificationRevision;
1215 * Bit 0 - SCI interrupt supported
1216 * Bit 1 - I/O APIC/SAPIC
1220 /* If bit 0 of InterruptType is set, then this is the SCI
1221 interrupt in the GPEx_STS register. */
1226 /* If bit 1 of InterruptType is set, then this is the I/O
1227 APIC/SAPIC interrupt. */
1228 u32 GlobalSystemInterrupt;
1230 /* The actual register address. */
1231 struct acpi_generic_address addr;
1235 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1238 static int try_init_acpi(int intf_num, struct smi_info **new_info)
1240 struct smi_info *info;
1242 struct SPMITable *spmi;
1249 status = acpi_get_firmware_table("SPMI", intf_num+1,
1250 ACPI_LOGICAL_ADDRESSING,
1251 (struct acpi_table_header **) &spmi);
1252 if (status != AE_OK) {
1257 if (spmi->IPMIlegacy != 1) {
1258 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1262 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1263 addr_space = IPMI_MEM_ADDR_SPACE;
1265 addr_space = IPMI_IO_ADDR_SPACE;
1266 if (!is_new_interface(-1, addr_space, spmi->addr.address))
1269 /* Figure out the interface type. */
1270 switch (spmi->InterfaceType)
1273 si_type[intf_num] = "kcs";
1277 si_type[intf_num] = "smic";
1281 si_type[intf_num] = "bt";
1285 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1286 spmi->InterfaceType);
1290 info = kmalloc(sizeof(*info), GFP_KERNEL);
1292 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1295 memset(info, 0, sizeof(*info));
1297 if (spmi->InterruptType & 1) {
1298 /* We've got a GPE interrupt. */
1299 info->irq = spmi->GPE;
1300 info->irq_setup = acpi_gpe_irq_setup;
1301 info->irq_cleanup = acpi_gpe_irq_cleanup;
1302 } else if (spmi->InterruptType & 2) {
1303 /* We've got an APIC/SAPIC interrupt. */
1304 info->irq = spmi->GlobalSystemInterrupt;
1305 info->irq_setup = std_irq_setup;
1306 info->irq_cleanup = std_irq_cleanup;
1308 /* Use the default interrupt setting. */
1310 info->irq_setup = NULL;
1313 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1315 info->io_setup = mem_setup;
1316 info->io_cleanup = mem_cleanup;
1317 addrs[intf_num] = spmi->addr.address;
1318 info->io.inputb = mem_inb;
1319 info->io.outputb = mem_outb;
1320 info->io.info = &(addrs[intf_num]);
1321 } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1323 info->io_setup = port_setup;
1324 info->io_cleanup = port_cleanup;
1325 ports[intf_num] = spmi->addr.address;
1326 info->io.inputb = port_inb;
1327 info->io.outputb = port_outb;
1328 info->io.info = &(ports[intf_num]);
1331 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1337 printk("ipmi_si: ACPI/SPMI specifies \"%s\" %s SI @ 0x%lx\n",
1338 si_type[intf_num], io_type, (unsigned long) spmi->addr.address);
1345 typedef struct dmi_ipmi_data
1349 unsigned long base_addr;
1353 typedef struct dmi_header
1360 static int decode_dmi(dmi_header_t *dm, dmi_ipmi_data_t *ipmi_data)
1362 u8 *data = (u8 *)dm;
1363 unsigned long base_addr;
1365 ipmi_data->type = data[0x04];
1367 memcpy(&base_addr,&data[0x08],sizeof(unsigned long));
1368 if (base_addr & 1) {
1370 base_addr &= 0xFFFE;
1371 ipmi_data->addr_space = IPMI_IO_ADDR_SPACE;
1375 ipmi_data->addr_space = IPMI_MEM_ADDR_SPACE;
1378 ipmi_data->base_addr = base_addr;
1379 ipmi_data->irq = data[0x11];
1381 if (is_new_interface(-1, ipmi_data->addr_space,ipmi_data->base_addr))
1384 memset(ipmi_data,0,sizeof(dmi_ipmi_data_t));
1389 static int dmi_table(u32 base, int len, int num,
1390 dmi_ipmi_data_t *ipmi_data)
1393 struct dmi_header *dm;
1398 buf = ioremap(base, len);
1404 while(i<num && (data - buf) < len)
1406 dm=(dmi_header_t *)data;
1408 if((data-buf+dm->length) >= len)
1411 if (dm->type == 38) {
1412 if (decode_dmi(dm, ipmi_data) == 0) {
1419 while((data-buf) < len && (*data || data[1]))
1429 inline static int dmi_checksum(u8 *buf)
1439 static int dmi_iterator(dmi_ipmi_data_t *ipmi_data)
1444 #ifdef CONFIG_SIMNOW
1450 isa_memcpy_fromio(buf, fp, 15);
1451 if(memcmp(buf, "_DMI_", 5)==0 && dmi_checksum(buf))
1453 u16 num=buf[13]<<8|buf[12];
1454 u16 len=buf[7]<<8|buf[6];
1455 u32 base=buf[11]<<24|buf[10]<<16|buf[9]<<8|buf[8];
1457 if(dmi_table(base, len, num, ipmi_data) == 0)
1466 static int try_init_smbios(int intf_num, struct smi_info **new_info)
1468 struct smi_info *info;
1469 dmi_ipmi_data_t ipmi_data;
1473 status = dmi_iterator(&ipmi_data);
1478 switch(ipmi_data.type) {
1479 case 0x01: /* KCS */
1480 si_type[intf_num] = "kcs";
1482 case 0x02: /* SMIC */
1483 si_type[intf_num] = "smic";
1486 si_type[intf_num] = "bt";
1489 printk("ipmi_si: Unknown SMBIOS SI type.\n");
1493 info = kmalloc(sizeof(*info), GFP_KERNEL);
1495 printk(KERN_ERR "ipmi_si: Could not allocate SI data (4)\n");
1498 memset(info, 0, sizeof(*info));
1500 if (ipmi_data.addr_space == 1) {
1502 info->io_setup = mem_setup;
1503 info->io_cleanup = mem_cleanup;
1504 addrs[intf_num] = ipmi_data.base_addr;
1505 info->io.inputb = mem_inb;
1506 info->io.outputb = mem_outb;
1507 info->io.info = &(addrs[intf_num]);
1508 } else if (ipmi_data.addr_space == 2) {
1510 info->io_setup = port_setup;
1511 info->io_cleanup = port_cleanup;
1512 ports[intf_num] = ipmi_data.base_addr;
1513 info->io.inputb = port_inb;
1514 info->io.outputb = port_outb;
1515 info->io.info = &(ports[intf_num]);
1518 printk("ipmi_si: Unknown SMBIOS I/O Address type.\n");
1522 irqs[intf_num] = ipmi_data.irq;
1526 printk("ipmi_si: Found SMBIOS-specified state machine at %s"
1528 io_type, (unsigned long)ipmi_data.base_addr);
1531 #endif /* CONFIG_X86 */
1535 #define PCI_ERMC_CLASSCODE 0x0C0700
1536 #define PCI_HP_VENDOR_ID 0x103C
1537 #define PCI_MMC_DEVICE_ID 0x121A
1538 #define PCI_MMC_ADDR_CW 0x10
1540 /* Avoid more than one attempt to probe pci smic. */
1541 static int pci_smic_checked = 0;
1543 static int find_pci_smic(int intf_num, struct smi_info **new_info)
1545 struct smi_info *info;
1547 struct pci_dev *pci_dev = NULL;
1551 if (pci_smic_checked)
1554 pci_smic_checked = 1;
1556 if ((pci_dev = pci_find_device(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID,
1559 else if ((pci_dev = pci_find_class(PCI_ERMC_CLASSCODE, NULL)) &&
1560 pci_dev->subsystem_vendor == PCI_HP_VENDOR_ID)
1565 error = pci_read_config_word(pci_dev, PCI_MMC_ADDR_CW, &base_addr);
1569 "ipmi_si: pci_read_config_word() failed (%d).\n",
1574 /* Bit 0: 1 specifies programmed I/O, 0 specifies memory mapped I/O */
1575 if (!(base_addr & 0x0001))
1578 "ipmi_si: memory mapped I/O not supported for PCI"
1583 base_addr &= 0xFFFE;
1585 /* Data register starts at base address + 1 in eRMC */
1588 if (!is_new_interface(-1, IPMI_IO_ADDR_SPACE, base_addr))
1591 info = kmalloc(sizeof(*info), GFP_KERNEL);
1593 printk(KERN_ERR "ipmi_si: Could not allocate SI data (5)\n");
1596 memset(info, 0, sizeof(*info));
1598 info->io_setup = port_setup;
1599 info->io_cleanup = port_cleanup;
1600 ports[intf_num] = base_addr;
1601 info->io.inputb = port_inb;
1602 info->io.outputb = port_outb;
1603 info->io.info = &(ports[intf_num]);
1607 irqs[intf_num] = pci_dev->irq;
1608 si_type[intf_num] = "smic";
1610 printk("ipmi_si: Found PCI SMIC at I/O address 0x%lx\n",
1611 (long unsigned int) base_addr);
1615 #endif /* CONFIG_PCI */
1617 static int try_init_plug_and_play(int intf_num, struct smi_info **new_info)
1620 if (find_pci_smic(intf_num, new_info)==0)
1623 /* Include other methods here. */
1629 static int try_get_dev_id(struct smi_info *smi_info)
1631 unsigned char msg[2];
1632 unsigned char *resp;
1633 unsigned long resp_len;
1634 enum si_sm_result smi_result;
1637 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1641 /* Do a Get Device ID command, since it comes back with some
1643 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1644 msg[1] = IPMI_GET_DEVICE_ID_CMD;
1645 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1647 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1650 if (smi_result == SI_SM_CALL_WITH_DELAY) {
1651 set_current_state(TASK_UNINTERRUPTIBLE);
1652 schedule_timeout(1);
1653 smi_result = smi_info->handlers->event(
1654 smi_info->si_sm, 100);
1656 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1658 smi_result = smi_info->handlers->event(
1659 smi_info->si_sm, 0);
1664 if (smi_result == SI_SM_HOSED) {
1665 /* We couldn't get the state machine to run, so whatever's at
1666 the port is probably not an IPMI SMI interface. */
1671 /* Otherwise, we got some data. */
1672 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1673 resp, IPMI_MAX_MSG_LENGTH);
1675 /* That's odd, it should be longer. */
1680 if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
1681 /* That's odd, it shouldn't be able to fail. */
1686 /* Record info from the get device id, in case we need it. */
1687 smi_info->ipmi_si_dev_rev = resp[4] & 0xf;
1688 smi_info->ipmi_si_fw_rev_major = resp[5] & 0x7f;
1689 smi_info->ipmi_si_fw_rev_minor = resp[6];
1690 smi_info->ipmi_version_major = resp[7] & 0xf;
1691 smi_info->ipmi_version_minor = resp[7] >> 4;
1698 static int type_file_read_proc(char *page, char **start, off_t off,
1699 int count, int *eof, void *data)
1701 char *out = (char *) page;
1702 struct smi_info *smi = data;
1704 switch (smi->si_type) {
1706 return sprintf(out, "kcs\n");
1708 return sprintf(out, "smic\n");
1710 return sprintf(out, "bt\n");
1716 static int stat_file_read_proc(char *page, char **start, off_t off,
1717 int count, int *eof, void *data)
1719 char *out = (char *) page;
1720 struct smi_info *smi = data;
1722 out += sprintf(out, "interrupts_enabled: %d\n",
1723 smi->irq && !smi->interrupt_disabled);
1724 out += sprintf(out, "short_timeouts: %ld\n",
1725 smi->short_timeouts);
1726 out += sprintf(out, "long_timeouts: %ld\n",
1727 smi->long_timeouts);
1728 out += sprintf(out, "timeout_restarts: %ld\n",
1729 smi->timeout_restarts);
1730 out += sprintf(out, "idles: %ld\n",
1732 out += sprintf(out, "interrupts: %ld\n",
1734 out += sprintf(out, "attentions: %ld\n",
1736 out += sprintf(out, "flag_fetches: %ld\n",
1738 out += sprintf(out, "hosed_count: %ld\n",
1740 out += sprintf(out, "complete_transactions: %ld\n",
1741 smi->complete_transactions);
1742 out += sprintf(out, "events: %ld\n",
1744 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
1745 smi->watchdog_pretimeouts);
1746 out += sprintf(out, "incoming_messages: %ld\n",
1747 smi->incoming_messages);
1749 return (out - ((char *) page));
1752 /* Returns 0 if initialized, or negative on an error. */
1753 static int init_one_smi(int intf_num, struct smi_info **smi)
1756 struct smi_info *new_smi;
1759 rv = try_init_mem(intf_num, &new_smi);
1761 rv = try_init_port(intf_num, &new_smi);
1762 #ifdef CONFIG_ACPI_INTERPRETER
1763 if ((rv) && (si_trydefaults)) {
1764 rv = try_init_acpi(intf_num, &new_smi);
1768 if ((rv) && (si_trydefaults)) {
1769 rv = try_init_smbios(intf_num, &new_smi);
1772 if ((rv) && (si_trydefaults)) {
1773 rv = try_init_plug_and_play(intf_num, &new_smi);
1780 /* So we know not to free it unless we have allocated one. */
1781 new_smi->intf = NULL;
1782 new_smi->si_sm = NULL;
1783 new_smi->handlers = NULL;
1785 if (!new_smi->irq_setup) {
1786 new_smi->irq = irqs[intf_num];
1787 new_smi->irq_setup = std_irq_setup;
1788 new_smi->irq_cleanup = std_irq_cleanup;
1791 /* Default to KCS if no type is specified. */
1792 if (si_type[intf_num] == NULL) {
1794 si_type[intf_num] = "kcs";
1801 /* Set up the state machine to use. */
1802 if (strcmp(si_type[intf_num], "kcs") == 0) {
1803 new_smi->handlers = &kcs_smi_handlers;
1804 new_smi->si_type = SI_KCS;
1805 } else if (strcmp(si_type[intf_num], "smic") == 0) {
1806 new_smi->handlers = &smic_smi_handlers;
1807 new_smi->si_type = SI_SMIC;
1808 } else if (strcmp(si_type[intf_num], "bt") == 0) {
1809 new_smi->handlers = &bt_smi_handlers;
1810 new_smi->si_type = SI_BT;
1812 /* No support for anything else yet. */
1817 /* Allocate the state machine's data and initialize it. */
1818 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
1819 if (!new_smi->si_sm) {
1820 printk(" Could not allocate state machine memory\n");
1824 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
1827 /* Now that we know the I/O size, we can set up the I/O. */
1828 rv = new_smi->io_setup(new_smi);
1830 printk(" Could not set up I/O space\n");
1834 spin_lock_init(&(new_smi->si_lock));
1835 spin_lock_init(&(new_smi->msg_lock));
1836 spin_lock_init(&(new_smi->count_lock));
1838 /* Do low-level detection first. */
1839 if (new_smi->handlers->detect(new_smi->si_sm)) {
1844 /* Attempt a get device id command. If it fails, we probably
1845 don't have a SMI here. */
1846 rv = try_get_dev_id(new_smi);
1850 /* Try to claim any interrupts. */
1851 new_smi->irq_setup(new_smi);
1853 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
1854 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
1855 new_smi->curr_msg = NULL;
1856 atomic_set(&new_smi->req_events, 0);
1857 new_smi->run_to_completion = 0;
1859 new_smi->interrupt_disabled = 0;
1860 new_smi->timer_stopped = 0;
1861 new_smi->stop_operation = 0;
1863 /* The ipmi_register_smi() code does some operations to
1864 determine the channel information, so we must be ready to
1865 handle operations before it is called. This means we have
1866 to stop the timer if we get an error after this point. */
1867 init_timer(&(new_smi->si_timer));
1868 new_smi->si_timer.data = (long) new_smi;
1869 new_smi->si_timer.function = smi_timeout;
1870 new_smi->last_timeout_jiffies = jiffies;
1871 new_smi->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
1872 add_timer(&(new_smi->si_timer));
1874 rv = ipmi_register_smi(&handlers,
1876 new_smi->ipmi_version_major,
1877 new_smi->ipmi_version_minor,
1881 "ipmi_si: Unable to register device: error %d\n",
1883 goto out_err_stop_timer;
1886 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
1887 type_file_read_proc, NULL,
1888 new_smi, THIS_MODULE);
1891 "ipmi_si: Unable to create proc entry: %d\n",
1893 goto out_err_stop_timer;
1896 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
1897 stat_file_read_proc, NULL,
1898 new_smi, THIS_MODULE);
1901 "ipmi_si: Unable to create proc entry: %d\n",
1903 goto out_err_stop_timer;
1906 start_clear_flags(new_smi);
1908 /* IRQ is defined to be set when non-zero. */
1910 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
1914 printk(" IPMI %s interface initialized\n", si_type[intf_num]);
1919 new_smi->stop_operation = 1;
1921 /* Wait for the timer to stop. This avoids problems with race
1922 conditions removing the timer here. */
1923 while (!new_smi->timer_stopped) {
1924 set_current_state(TASK_UNINTERRUPTIBLE);
1925 schedule_timeout(1);
1930 ipmi_unregister_smi(new_smi->intf);
1932 new_smi->irq_cleanup(new_smi);
1934 /* Wait until we know that we are out of any interrupt
1935 handlers might have been running before we freed the
1937 synchronize_kernel();
1939 if (new_smi->si_sm) {
1940 if (new_smi->handlers)
1941 new_smi->handlers->cleanup(new_smi->si_sm);
1942 kfree(new_smi->si_sm);
1944 new_smi->io_cleanup(new_smi);
1949 static __init int init_ipmi_si(void)
1960 /* Parse out the si_type string into its components. */
1963 for (i=0; (i<SI_MAX_PARMS) && (*str != '\0'); i++) {
1965 str = strchr(str, ',');
1975 printk(KERN_INFO "IPMI System Interface driver version "
1977 if (kcs_smi_handlers.version)
1978 printk(", KCS version %s", kcs_smi_handlers.version);
1979 if (smic_smi_handlers.version)
1980 printk(", SMIC version %s", smic_smi_handlers.version);
1981 if (bt_smi_handlers.version)
1982 printk(", BT version %s", bt_smi_handlers.version);
1985 rv = init_one_smi(0, &(smi_infos[pos]));
1986 if (rv && !ports[0] && si_trydefaults) {
1987 /* If we are trying defaults and the initial port is
1988 not set, then set it. */
1990 ports[0] = DEFAULT_KCS_IO_PORT;
1991 rv = init_one_smi(0, &(smi_infos[pos]));
1993 /* No KCS - try SMIC */
1994 si_type[0] = "smic";
1995 ports[0] = DEFAULT_SMIC_IO_PORT;
1996 rv = init_one_smi(0, &(smi_infos[pos]));
1999 /* No SMIC - try BT */
2001 ports[0] = DEFAULT_BT_IO_PORT;
2002 rv = init_one_smi(0, &(smi_infos[pos]));
2008 for (i=1; i < SI_MAX_PARMS; i++) {
2009 rv = init_one_smi(i, &(smi_infos[pos]));
2014 if (smi_infos[0] == NULL) {
2015 printk("ipmi_si: Unable to find any System Interface(s)\n");
2021 module_init(init_ipmi_si);
2023 void __exit cleanup_one_si(struct smi_info *to_clean)
2026 unsigned long flags;
2031 /* Tell the timer and interrupt handlers that we are shutting
2033 spin_lock_irqsave(&(to_clean->si_lock), flags);
2034 spin_lock(&(to_clean->msg_lock));
2036 to_clean->stop_operation = 1;
2038 to_clean->irq_cleanup(to_clean);
2040 spin_unlock(&(to_clean->msg_lock));
2041 spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2043 /* Wait until we know that we are out of any interrupt
2044 handlers might have been running before we freed the
2046 synchronize_kernel();
2048 /* Wait for the timer to stop. This avoids problems with race
2049 conditions removing the timer here. */
2050 while (!to_clean->timer_stopped) {
2051 set_current_state(TASK_UNINTERRUPTIBLE);
2052 schedule_timeout(1);
2055 rv = ipmi_unregister_smi(to_clean->intf);
2058 "ipmi_si: Unable to unregister device: errno=%d\n",
2062 to_clean->handlers->cleanup(to_clean->si_sm);
2064 kfree(to_clean->si_sm);
2066 to_clean->io_cleanup(to_clean);
2069 static __exit void cleanup_ipmi_si(void)
2076 for (i=0; i<SI_MAX_DRIVERS; i++) {
2077 cleanup_one_si(smi_infos[i]);
2080 module_exit(cleanup_ipmi_si);
2082 MODULE_LICENSE("GPL");