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>
54 #include <linux/irq.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 u32 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);
1162 static int acpi_gpe_irq_setup(struct smi_info *info)
1169 /* FIXME - is level triggered right? */
1170 status = acpi_install_gpe_handler(NULL,
1172 ACPI_GPE_LEVEL_TRIGGERED,
1175 if (status != AE_OK) {
1177 "ipmi_si: %s unable to claim ACPI GPE %d,"
1178 " running polled\n",
1179 DEVICE_NAME, info->irq);
1183 printk(" Using ACPI GPE %d\n", info->irq);
1189 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1194 acpi_remove_gpe_handler(NULL, info->irq, ipmi_acpi_gpe);
1199 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1210 s8 CreatorRevision[4];
1213 s16 SpecificationRevision;
1216 * Bit 0 - SCI interrupt supported
1217 * Bit 1 - I/O APIC/SAPIC
1221 /* If bit 0 of InterruptType is set, then this is the SCI
1222 interrupt in the GPEx_STS register. */
1227 /* If bit 1 of InterruptType is set, then this is the I/O
1228 APIC/SAPIC interrupt. */
1229 u32 GlobalSystemInterrupt;
1231 /* The actual register address. */
1232 struct acpi_generic_address addr;
1236 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1239 static int try_init_acpi(int intf_num, struct smi_info **new_info)
1241 struct smi_info *info;
1243 struct SPMITable *spmi;
1250 status = acpi_get_firmware_table("SPMI", intf_num+1,
1251 ACPI_LOGICAL_ADDRESSING,
1252 (struct acpi_table_header **) &spmi);
1253 if (status != AE_OK) {
1258 if (spmi->IPMIlegacy != 1) {
1259 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1263 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1264 addr_space = IPMI_MEM_ADDR_SPACE;
1266 addr_space = IPMI_IO_ADDR_SPACE;
1267 if (!is_new_interface(-1, addr_space, spmi->addr.address))
1270 /* Figure out the interface type. */
1271 switch (spmi->InterfaceType)
1274 si_type[intf_num] = "kcs";
1278 si_type[intf_num] = "smic";
1282 si_type[intf_num] = "bt";
1286 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1287 spmi->InterfaceType);
1291 info = kmalloc(sizeof(*info), GFP_KERNEL);
1293 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1296 memset(info, 0, sizeof(*info));
1298 if (spmi->InterruptType & 1) {
1299 /* We've got a GPE interrupt. */
1300 info->irq = spmi->GPE;
1301 info->irq_setup = acpi_gpe_irq_setup;
1302 info->irq_cleanup = acpi_gpe_irq_cleanup;
1303 } else if (spmi->InterruptType & 2) {
1304 /* We've got an APIC/SAPIC interrupt. */
1305 info->irq = spmi->GlobalSystemInterrupt;
1306 info->irq_setup = std_irq_setup;
1307 info->irq_cleanup = std_irq_cleanup;
1309 /* Use the default interrupt setting. */
1311 info->irq_setup = NULL;
1314 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1316 info->io_setup = mem_setup;
1317 info->io_cleanup = mem_cleanup;
1318 addrs[intf_num] = spmi->addr.address;
1319 info->io.inputb = mem_inb;
1320 info->io.outputb = mem_outb;
1321 info->io.info = &(addrs[intf_num]);
1322 } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1324 info->io_setup = port_setup;
1325 info->io_cleanup = port_cleanup;
1326 ports[intf_num] = spmi->addr.address;
1327 info->io.inputb = port_inb;
1328 info->io.outputb = port_outb;
1329 info->io.info = &(ports[intf_num]);
1332 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1338 printk("ipmi_si: ACPI/SPMI specifies \"%s\" %s SI @ 0x%lx\n",
1339 si_type[intf_num], io_type, (unsigned long) spmi->addr.address);
1346 typedef struct dmi_ipmi_data
1350 unsigned long base_addr;
1354 typedef struct dmi_header
1361 static int decode_dmi(dmi_header_t *dm, dmi_ipmi_data_t *ipmi_data)
1363 u8 *data = (u8 *)dm;
1364 unsigned long base_addr;
1366 ipmi_data->type = data[0x04];
1368 memcpy(&base_addr,&data[0x08],sizeof(unsigned long));
1369 if (base_addr & 1) {
1371 base_addr &= 0xFFFE;
1372 ipmi_data->addr_space = IPMI_IO_ADDR_SPACE;
1376 ipmi_data->addr_space = IPMI_MEM_ADDR_SPACE;
1379 ipmi_data->base_addr = base_addr;
1380 ipmi_data->irq = data[0x11];
1382 if (is_new_interface(-1, ipmi_data->addr_space,ipmi_data->base_addr))
1385 memset(ipmi_data,0,sizeof(dmi_ipmi_data_t));
1390 static int dmi_table(u32 base, int len, int num,
1391 dmi_ipmi_data_t *ipmi_data)
1394 struct dmi_header *dm;
1399 buf = ioremap(base, len);
1405 while(i<num && (data - buf) < len)
1407 dm=(dmi_header_t *)data;
1409 if((data-buf+dm->length) >= len)
1412 if (dm->type == 38) {
1413 if (decode_dmi(dm, ipmi_data) == 0) {
1420 while((data-buf) < len && (*data || data[1]))
1430 inline static int dmi_checksum(u8 *buf)
1440 static int dmi_iterator(dmi_ipmi_data_t *ipmi_data)
1445 #ifdef CONFIG_SIMNOW
1451 isa_memcpy_fromio(buf, fp, 15);
1452 if(memcmp(buf, "_DMI_", 5)==0 && dmi_checksum(buf))
1454 u16 num=buf[13]<<8|buf[12];
1455 u16 len=buf[7]<<8|buf[6];
1456 u32 base=buf[11]<<24|buf[10]<<16|buf[9]<<8|buf[8];
1458 if(dmi_table(base, len, num, ipmi_data) == 0)
1467 static int try_init_smbios(int intf_num, struct smi_info **new_info)
1469 struct smi_info *info;
1470 dmi_ipmi_data_t ipmi_data;
1474 status = dmi_iterator(&ipmi_data);
1479 switch(ipmi_data.type) {
1480 case 0x01: /* KCS */
1481 si_type[intf_num] = "kcs";
1483 case 0x02: /* SMIC */
1484 si_type[intf_num] = "smic";
1487 si_type[intf_num] = "bt";
1490 printk("ipmi_si: Unknown SMBIOS SI type.\n");
1494 info = kmalloc(sizeof(*info), GFP_KERNEL);
1496 printk(KERN_ERR "ipmi_si: Could not allocate SI data (4)\n");
1499 memset(info, 0, sizeof(*info));
1501 if (ipmi_data.addr_space == 1) {
1503 info->io_setup = mem_setup;
1504 info->io_cleanup = mem_cleanup;
1505 addrs[intf_num] = ipmi_data.base_addr;
1506 info->io.inputb = mem_inb;
1507 info->io.outputb = mem_outb;
1508 info->io.info = &(addrs[intf_num]);
1509 } else if (ipmi_data.addr_space == 2) {
1511 info->io_setup = port_setup;
1512 info->io_cleanup = port_cleanup;
1513 ports[intf_num] = ipmi_data.base_addr;
1514 info->io.inputb = port_inb;
1515 info->io.outputb = port_outb;
1516 info->io.info = &(ports[intf_num]);
1519 printk("ipmi_si: Unknown SMBIOS I/O Address type.\n");
1523 irqs[intf_num] = ipmi_data.irq;
1527 printk("ipmi_si: Found SMBIOS-specified state machine at %s"
1529 io_type, (unsigned long)ipmi_data.base_addr);
1532 #endif /* CONFIG_X86 */
1536 #define PCI_ERMC_CLASSCODE 0x0C0700
1537 #define PCI_HP_VENDOR_ID 0x103C
1538 #define PCI_MMC_DEVICE_ID 0x121A
1539 #define PCI_MMC_ADDR_CW 0x10
1541 /* Avoid more than one attempt to probe pci smic. */
1542 static int pci_smic_checked = 0;
1544 static int find_pci_smic(int intf_num, struct smi_info **new_info)
1546 struct smi_info *info;
1548 struct pci_dev *pci_dev = NULL;
1552 if (pci_smic_checked)
1555 pci_smic_checked = 1;
1557 if ((pci_dev = pci_find_device(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID,
1560 else if ((pci_dev = pci_find_class(PCI_ERMC_CLASSCODE, NULL)) &&
1561 pci_dev->subsystem_vendor == PCI_HP_VENDOR_ID)
1566 error = pci_read_config_word(pci_dev, PCI_MMC_ADDR_CW, &base_addr);
1570 "ipmi_si: pci_read_config_word() failed (%d).\n",
1575 /* Bit 0: 1 specifies programmed I/O, 0 specifies memory mapped I/O */
1576 if (!(base_addr & 0x0001))
1579 "ipmi_si: memory mapped I/O not supported for PCI"
1584 base_addr &= 0xFFFE;
1586 /* Data register starts at base address + 1 in eRMC */
1589 if (!is_new_interface(-1, IPMI_IO_ADDR_SPACE, base_addr))
1592 info = kmalloc(sizeof(*info), GFP_KERNEL);
1594 printk(KERN_ERR "ipmi_si: Could not allocate SI data (5)\n");
1597 memset(info, 0, sizeof(*info));
1599 info->io_setup = port_setup;
1600 info->io_cleanup = port_cleanup;
1601 ports[intf_num] = base_addr;
1602 info->io.inputb = port_inb;
1603 info->io.outputb = port_outb;
1604 info->io.info = &(ports[intf_num]);
1608 irqs[intf_num] = pci_dev->irq;
1609 si_type[intf_num] = "smic";
1611 printk("ipmi_si: Found PCI SMIC at I/O address 0x%lx\n",
1612 (long unsigned int) base_addr);
1616 #endif /* CONFIG_PCI */
1618 static int try_init_plug_and_play(int intf_num, struct smi_info **new_info)
1621 if (find_pci_smic(intf_num, new_info)==0)
1624 /* Include other methods here. */
1630 static int try_get_dev_id(struct smi_info *smi_info)
1632 unsigned char msg[2];
1633 unsigned char *resp;
1634 unsigned long resp_len;
1635 enum si_sm_result smi_result;
1638 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1642 /* Do a Get Device ID command, since it comes back with some
1644 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1645 msg[1] = IPMI_GET_DEVICE_ID_CMD;
1646 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1648 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1651 if (smi_result == SI_SM_CALL_WITH_DELAY) {
1652 set_current_state(TASK_UNINTERRUPTIBLE);
1653 schedule_timeout(1);
1654 smi_result = smi_info->handlers->event(
1655 smi_info->si_sm, 100);
1657 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1659 smi_result = smi_info->handlers->event(
1660 smi_info->si_sm, 0);
1665 if (smi_result == SI_SM_HOSED) {
1666 /* We couldn't get the state machine to run, so whatever's at
1667 the port is probably not an IPMI SMI interface. */
1672 /* Otherwise, we got some data. */
1673 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1674 resp, IPMI_MAX_MSG_LENGTH);
1676 /* That's odd, it should be longer. */
1681 if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
1682 /* That's odd, it shouldn't be able to fail. */
1687 /* Record info from the get device id, in case we need it. */
1688 smi_info->ipmi_si_dev_rev = resp[4] & 0xf;
1689 smi_info->ipmi_si_fw_rev_major = resp[5] & 0x7f;
1690 smi_info->ipmi_si_fw_rev_minor = resp[6];
1691 smi_info->ipmi_version_major = resp[7] & 0xf;
1692 smi_info->ipmi_version_minor = resp[7] >> 4;
1699 static int type_file_read_proc(char *page, char **start, off_t off,
1700 int count, int *eof, void *data)
1702 char *out = (char *) page;
1703 struct smi_info *smi = data;
1705 switch (smi->si_type) {
1707 return sprintf(out, "kcs\n");
1709 return sprintf(out, "smic\n");
1711 return sprintf(out, "bt\n");
1717 static int stat_file_read_proc(char *page, char **start, off_t off,
1718 int count, int *eof, void *data)
1720 char *out = (char *) page;
1721 struct smi_info *smi = data;
1723 out += sprintf(out, "interrupts_enabled: %d\n",
1724 smi->irq && !smi->interrupt_disabled);
1725 out += sprintf(out, "short_timeouts: %ld\n",
1726 smi->short_timeouts);
1727 out += sprintf(out, "long_timeouts: %ld\n",
1728 smi->long_timeouts);
1729 out += sprintf(out, "timeout_restarts: %ld\n",
1730 smi->timeout_restarts);
1731 out += sprintf(out, "idles: %ld\n",
1733 out += sprintf(out, "interrupts: %ld\n",
1735 out += sprintf(out, "attentions: %ld\n",
1737 out += sprintf(out, "flag_fetches: %ld\n",
1739 out += sprintf(out, "hosed_count: %ld\n",
1741 out += sprintf(out, "complete_transactions: %ld\n",
1742 smi->complete_transactions);
1743 out += sprintf(out, "events: %ld\n",
1745 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
1746 smi->watchdog_pretimeouts);
1747 out += sprintf(out, "incoming_messages: %ld\n",
1748 smi->incoming_messages);
1750 return (out - ((char *) page));
1753 /* Returns 0 if initialized, or negative on an error. */
1754 static int init_one_smi(int intf_num, struct smi_info **smi)
1757 struct smi_info *new_smi;
1760 rv = try_init_mem(intf_num, &new_smi);
1762 rv = try_init_port(intf_num, &new_smi);
1763 #ifdef CONFIG_ACPI_INTERPRETER
1764 if ((rv) && (si_trydefaults)) {
1765 rv = try_init_acpi(intf_num, &new_smi);
1769 if ((rv) && (si_trydefaults)) {
1770 rv = try_init_smbios(intf_num, &new_smi);
1773 if ((rv) && (si_trydefaults)) {
1774 rv = try_init_plug_and_play(intf_num, &new_smi);
1781 /* So we know not to free it unless we have allocated one. */
1782 new_smi->intf = NULL;
1783 new_smi->si_sm = NULL;
1784 new_smi->handlers = NULL;
1786 if (!new_smi->irq_setup) {
1787 new_smi->irq = irqs[intf_num];
1788 new_smi->irq_setup = std_irq_setup;
1789 new_smi->irq_cleanup = std_irq_cleanup;
1792 /* Default to KCS if no type is specified. */
1793 if (si_type[intf_num] == NULL) {
1795 si_type[intf_num] = "kcs";
1802 /* Set up the state machine to use. */
1803 if (strcmp(si_type[intf_num], "kcs") == 0) {
1804 new_smi->handlers = &kcs_smi_handlers;
1805 new_smi->si_type = SI_KCS;
1806 } else if (strcmp(si_type[intf_num], "smic") == 0) {
1807 new_smi->handlers = &smic_smi_handlers;
1808 new_smi->si_type = SI_SMIC;
1809 } else if (strcmp(si_type[intf_num], "bt") == 0) {
1810 new_smi->handlers = &bt_smi_handlers;
1811 new_smi->si_type = SI_BT;
1813 /* No support for anything else yet. */
1818 /* Allocate the state machine's data and initialize it. */
1819 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
1820 if (!new_smi->si_sm) {
1821 printk(" Could not allocate state machine memory\n");
1825 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
1828 /* Now that we know the I/O size, we can set up the I/O. */
1829 rv = new_smi->io_setup(new_smi);
1831 printk(" Could not set up I/O space\n");
1835 spin_lock_init(&(new_smi->si_lock));
1836 spin_lock_init(&(new_smi->msg_lock));
1837 spin_lock_init(&(new_smi->count_lock));
1839 /* Do low-level detection first. */
1840 if (new_smi->handlers->detect(new_smi->si_sm)) {
1845 /* Attempt a get device id command. If it fails, we probably
1846 don't have a SMI here. */
1847 rv = try_get_dev_id(new_smi);
1851 /* Try to claim any interrupts. */
1852 new_smi->irq_setup(new_smi);
1854 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
1855 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
1856 new_smi->curr_msg = NULL;
1857 atomic_set(&new_smi->req_events, 0);
1858 new_smi->run_to_completion = 0;
1860 new_smi->interrupt_disabled = 0;
1861 new_smi->timer_stopped = 0;
1862 new_smi->stop_operation = 0;
1864 /* The ipmi_register_smi() code does some operations to
1865 determine the channel information, so we must be ready to
1866 handle operations before it is called. This means we have
1867 to stop the timer if we get an error after this point. */
1868 init_timer(&(new_smi->si_timer));
1869 new_smi->si_timer.data = (long) new_smi;
1870 new_smi->si_timer.function = smi_timeout;
1871 new_smi->last_timeout_jiffies = jiffies;
1872 new_smi->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
1873 add_timer(&(new_smi->si_timer));
1875 rv = ipmi_register_smi(&handlers,
1877 new_smi->ipmi_version_major,
1878 new_smi->ipmi_version_minor,
1882 "ipmi_si: Unable to register device: error %d\n",
1884 goto out_err_stop_timer;
1887 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
1888 type_file_read_proc, NULL,
1889 new_smi, THIS_MODULE);
1892 "ipmi_si: Unable to create proc entry: %d\n",
1894 goto out_err_stop_timer;
1897 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
1898 stat_file_read_proc, NULL,
1899 new_smi, THIS_MODULE);
1902 "ipmi_si: Unable to create proc entry: %d\n",
1904 goto out_err_stop_timer;
1907 start_clear_flags(new_smi);
1909 /* IRQ is defined to be set when non-zero. */
1911 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
1915 printk(" IPMI %s interface initialized\n", si_type[intf_num]);
1920 new_smi->stop_operation = 1;
1922 /* Wait for the timer to stop. This avoids problems with race
1923 conditions removing the timer here. */
1924 while (!new_smi->timer_stopped) {
1925 set_current_state(TASK_UNINTERRUPTIBLE);
1926 schedule_timeout(1);
1931 ipmi_unregister_smi(new_smi->intf);
1933 new_smi->irq_cleanup(new_smi);
1935 /* Wait until we know that we are out of any interrupt
1936 handlers might have been running before we freed the
1938 synchronize_kernel();
1940 if (new_smi->si_sm) {
1941 if (new_smi->handlers)
1942 new_smi->handlers->cleanup(new_smi->si_sm);
1943 kfree(new_smi->si_sm);
1945 new_smi->io_cleanup(new_smi);
1950 static __init int init_ipmi_si(void)
1961 /* Parse out the si_type string into its components. */
1964 for (i=0; (i<SI_MAX_PARMS) && (*str != '\0'); i++) {
1966 str = strchr(str, ',');
1976 printk(KERN_INFO "IPMI System Interface driver version "
1978 if (kcs_smi_handlers.version)
1979 printk(", KCS version %s", kcs_smi_handlers.version);
1980 if (smic_smi_handlers.version)
1981 printk(", SMIC version %s", smic_smi_handlers.version);
1982 if (bt_smi_handlers.version)
1983 printk(", BT version %s", bt_smi_handlers.version);
1986 rv = init_one_smi(0, &(smi_infos[pos]));
1987 if (rv && !ports[0] && si_trydefaults) {
1988 /* If we are trying defaults and the initial port is
1989 not set, then set it. */
1991 ports[0] = DEFAULT_KCS_IO_PORT;
1992 rv = init_one_smi(0, &(smi_infos[pos]));
1994 /* No KCS - try SMIC */
1995 si_type[0] = "smic";
1996 ports[0] = DEFAULT_SMIC_IO_PORT;
1997 rv = init_one_smi(0, &(smi_infos[pos]));
2000 /* No SMIC - try BT */
2002 ports[0] = DEFAULT_BT_IO_PORT;
2003 rv = init_one_smi(0, &(smi_infos[pos]));
2009 for (i=1; i < SI_MAX_PARMS; i++) {
2010 rv = init_one_smi(i, &(smi_infos[pos]));
2015 if (smi_infos[0] == NULL) {
2016 printk("ipmi_si: Unable to find any System Interface(s)\n");
2022 module_init(init_ipmi_si);
2024 void __exit cleanup_one_si(struct smi_info *to_clean)
2027 unsigned long flags;
2032 /* Tell the timer and interrupt handlers that we are shutting
2034 spin_lock_irqsave(&(to_clean->si_lock), flags);
2035 spin_lock(&(to_clean->msg_lock));
2037 to_clean->stop_operation = 1;
2039 to_clean->irq_cleanup(to_clean);
2041 spin_unlock(&(to_clean->msg_lock));
2042 spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2044 /* Wait until we know that we are out of any interrupt
2045 handlers might have been running before we freed the
2047 synchronize_kernel();
2049 /* Wait for the timer to stop. This avoids problems with race
2050 conditions removing the timer here. */
2051 while (!to_clean->timer_stopped) {
2052 set_current_state(TASK_UNINTERRUPTIBLE);
2053 schedule_timeout(1);
2056 rv = ipmi_unregister_smi(to_clean->intf);
2059 "ipmi_si: Unable to unregister device: errno=%d\n",
2063 to_clean->handlers->cleanup(to_clean->si_sm);
2065 kfree(to_clean->si_sm);
2067 to_clean->io_cleanup(to_clean);
2070 static __exit void cleanup_ipmi_si(void)
2077 for (i=0; i<SI_MAX_DRIVERS; i++) {
2078 cleanup_one_si(smi_infos[i]);
2081 module_exit(cleanup_ipmi_si);
2083 MODULE_LICENSE("GPL");