4 * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
7 * Author: MontaVista Software, Inc.
8 * Corey Minyard <minyard@mvista.com>
11 * Copyright 2002 MontaVista Software Inc.
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
19 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
20 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
25 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
27 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
28 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 * You should have received a copy of the GNU General Public License along
31 * with this program; if not, write to the Free Software Foundation, Inc.,
32 * 675 Mass Ave, Cambridge, MA 02139, USA.
36 * This file holds the "policy" for the interface to the SMI state
37 * machine. It does the configuration, handles timers and interrupts,
38 * and drives the real SMI state machine.
41 #include <linux/module.h>
42 #include <linux/moduleparam.h>
43 #include <asm/system.h>
44 #include <linux/sched.h>
45 #include <linux/timer.h>
46 #include <linux/errno.h>
47 #include <linux/spinlock.h>
48 #include <linux/slab.h>
49 #include <linux/delay.h>
50 #include <linux/list.h>
51 #include <linux/pci.h>
52 #include <linux/ioport.h>
53 #include <linux/notifier.h>
54 #include <linux/mutex.h>
55 #include <linux/kthread.h>
57 #include <linux/interrupt.h>
58 #include <linux/rcupdate.h>
59 #include <linux/ipmi_smi.h>
61 #include "ipmi_si_sm.h"
62 #include <linux/init.h>
63 #include <linux/dmi.h>
65 /* Measure times between events in the driver. */
68 /* Call every 10 ms. */
69 #define SI_TIMEOUT_TIME_USEC 10000
70 #define SI_USEC_PER_JIFFY (1000000/HZ)
71 #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
72 #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
80 SI_CLEARING_FLAGS_THEN_SET_IRQ
,
82 SI_ENABLE_INTERRUPTS1
,
84 /* FIXME - add watchdog stuff. */
87 /* Some BT-specific defines we need here. */
88 #define IPMI_BT_INTMASK_REG 2
89 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
90 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
93 SI_KCS
, SI_SMIC
, SI_BT
95 static char *si_to_str
[] = { "KCS", "SMIC", "BT" };
97 #define DEVICE_NAME "ipmi_si"
99 static struct device_driver ipmi_driver
=
102 .bus
= &platform_bus_type
109 struct si_sm_data
*si_sm
;
110 struct si_sm_handlers
*handlers
;
111 enum si_type si_type
;
114 struct list_head xmit_msgs
;
115 struct list_head hp_xmit_msgs
;
116 struct ipmi_smi_msg
*curr_msg
;
117 enum si_intf_state si_state
;
119 /* Used to handle the various types of I/O that can occur with
122 int (*io_setup
)(struct smi_info
*info
);
123 void (*io_cleanup
)(struct smi_info
*info
);
124 int (*irq_setup
)(struct smi_info
*info
);
125 void (*irq_cleanup
)(struct smi_info
*info
);
126 unsigned int io_size
;
127 char *addr_source
; /* ACPI, PCI, SMBIOS, hardcode, default. */
128 void (*addr_source_cleanup
)(struct smi_info
*info
);
129 void *addr_source_data
;
131 /* Per-OEM handler, called from handle_flags().
132 Returns 1 when handle_flags() needs to be re-run
133 or 0 indicating it set si_state itself.
135 int (*oem_data_avail_handler
)(struct smi_info
*smi_info
);
137 /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
138 is set to hold the flags until we are done handling everything
140 #define RECEIVE_MSG_AVAIL 0x01
141 #define EVENT_MSG_BUFFER_FULL 0x02
142 #define WDT_PRE_TIMEOUT_INT 0x08
143 #define OEM0_DATA_AVAIL 0x20
144 #define OEM1_DATA_AVAIL 0x40
145 #define OEM2_DATA_AVAIL 0x80
146 #define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
149 unsigned char msg_flags
;
151 /* If set to true, this will request events the next time the
152 state machine is idle. */
155 /* If true, run the state machine to completion on every send
156 call. Generally used after a panic to make sure stuff goes
158 int run_to_completion
;
160 /* The I/O port of an SI interface. */
163 /* The space between start addresses of the two ports. For
164 instance, if the first port is 0xca2 and the spacing is 4, then
165 the second port is 0xca6. */
166 unsigned int spacing
;
168 /* zero if no irq; */
171 /* The timer for this si. */
172 struct timer_list si_timer
;
174 /* The time (in jiffies) the last timeout occurred at. */
175 unsigned long last_timeout_jiffies
;
177 /* Used to gracefully stop the timer without race conditions. */
178 atomic_t stop_operation
;
180 /* The driver will disable interrupts when it gets into a
181 situation where it cannot handle messages due to lack of
182 memory. Once that situation clears up, it will re-enable
184 int interrupt_disabled
;
186 /* From the get device id response... */
187 struct ipmi_device_id device_id
;
189 /* Driver model stuff. */
191 struct platform_device
*pdev
;
193 /* True if we allocated the device, false if it came from
194 * someplace else (like PCI). */
197 /* Slave address, could be reported from DMI. */
198 unsigned char slave_addr
;
200 /* Counters and things for the proc filesystem. */
201 spinlock_t count_lock
;
202 unsigned long short_timeouts
;
203 unsigned long long_timeouts
;
204 unsigned long timeout_restarts
;
206 unsigned long interrupts
;
207 unsigned long attentions
;
208 unsigned long flag_fetches
;
209 unsigned long hosed_count
;
210 unsigned long complete_transactions
;
211 unsigned long events
;
212 unsigned long watchdog_pretimeouts
;
213 unsigned long incoming_messages
;
215 struct task_struct
*thread
;
217 struct list_head link
;
220 #define SI_MAX_PARMS 4
222 static int force_kipmid
[SI_MAX_PARMS
];
223 static int num_force_kipmid
;
225 static int try_smi_init(struct smi_info
*smi
);
227 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list
);
228 static int register_xaction_notifier(struct notifier_block
* nb
)
230 return atomic_notifier_chain_register(&xaction_notifier_list
, nb
);
233 static void deliver_recv_msg(struct smi_info
*smi_info
,
234 struct ipmi_smi_msg
*msg
)
236 /* Deliver the message to the upper layer with the lock
238 spin_unlock(&(smi_info
->si_lock
));
239 ipmi_smi_msg_received(smi_info
->intf
, msg
);
240 spin_lock(&(smi_info
->si_lock
));
243 static void return_hosed_msg(struct smi_info
*smi_info
)
245 struct ipmi_smi_msg
*msg
= smi_info
->curr_msg
;
247 /* Make it a reponse */
248 msg
->rsp
[0] = msg
->data
[0] | 4;
249 msg
->rsp
[1] = msg
->data
[1];
250 msg
->rsp
[2] = 0xFF; /* Unknown error. */
253 smi_info
->curr_msg
= NULL
;
254 deliver_recv_msg(smi_info
, msg
);
257 static enum si_sm_result
start_next_msg(struct smi_info
*smi_info
)
260 struct list_head
*entry
= NULL
;
265 /* No need to save flags, we aleady have interrupts off and we
266 already hold the SMI lock. */
267 spin_lock(&(smi_info
->msg_lock
));
269 /* Pick the high priority queue first. */
270 if (!list_empty(&(smi_info
->hp_xmit_msgs
))) {
271 entry
= smi_info
->hp_xmit_msgs
.next
;
272 } else if (!list_empty(&(smi_info
->xmit_msgs
))) {
273 entry
= smi_info
->xmit_msgs
.next
;
277 smi_info
->curr_msg
= NULL
;
283 smi_info
->curr_msg
= list_entry(entry
,
288 printk("**Start2: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
290 err
= atomic_notifier_call_chain(&xaction_notifier_list
,
292 if (err
& NOTIFY_STOP_MASK
) {
293 rv
= SI_SM_CALL_WITHOUT_DELAY
;
296 err
= smi_info
->handlers
->start_transaction(
298 smi_info
->curr_msg
->data
,
299 smi_info
->curr_msg
->data_size
);
301 return_hosed_msg(smi_info
);
304 rv
= SI_SM_CALL_WITHOUT_DELAY
;
307 spin_unlock(&(smi_info
->msg_lock
));
312 static void start_enable_irq(struct smi_info
*smi_info
)
314 unsigned char msg
[2];
316 /* If we are enabling interrupts, we have to tell the
318 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
319 msg
[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD
;
321 smi_info
->handlers
->start_transaction(smi_info
->si_sm
, msg
, 2);
322 smi_info
->si_state
= SI_ENABLE_INTERRUPTS1
;
325 static void start_clear_flags(struct smi_info
*smi_info
)
327 unsigned char msg
[3];
329 /* Make sure the watchdog pre-timeout flag is not set at startup. */
330 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
331 msg
[1] = IPMI_CLEAR_MSG_FLAGS_CMD
;
332 msg
[2] = WDT_PRE_TIMEOUT_INT
;
334 smi_info
->handlers
->start_transaction(smi_info
->si_sm
, msg
, 3);
335 smi_info
->si_state
= SI_CLEARING_FLAGS
;
338 /* When we have a situtaion where we run out of memory and cannot
339 allocate messages, we just leave them in the BMC and run the system
340 polled until we can allocate some memory. Once we have some
341 memory, we will re-enable the interrupt. */
342 static inline void disable_si_irq(struct smi_info
*smi_info
)
344 if ((smi_info
->irq
) && (!smi_info
->interrupt_disabled
)) {
345 disable_irq_nosync(smi_info
->irq
);
346 smi_info
->interrupt_disabled
= 1;
350 static inline void enable_si_irq(struct smi_info
*smi_info
)
352 if ((smi_info
->irq
) && (smi_info
->interrupt_disabled
)) {
353 enable_irq(smi_info
->irq
);
354 smi_info
->interrupt_disabled
= 0;
358 static void handle_flags(struct smi_info
*smi_info
)
361 if (smi_info
->msg_flags
& WDT_PRE_TIMEOUT_INT
) {
362 /* Watchdog pre-timeout */
363 spin_lock(&smi_info
->count_lock
);
364 smi_info
->watchdog_pretimeouts
++;
365 spin_unlock(&smi_info
->count_lock
);
367 start_clear_flags(smi_info
);
368 smi_info
->msg_flags
&= ~WDT_PRE_TIMEOUT_INT
;
369 spin_unlock(&(smi_info
->si_lock
));
370 ipmi_smi_watchdog_pretimeout(smi_info
->intf
);
371 spin_lock(&(smi_info
->si_lock
));
372 } else if (smi_info
->msg_flags
& RECEIVE_MSG_AVAIL
) {
373 /* Messages available. */
374 smi_info
->curr_msg
= ipmi_alloc_smi_msg();
375 if (!smi_info
->curr_msg
) {
376 disable_si_irq(smi_info
);
377 smi_info
->si_state
= SI_NORMAL
;
380 enable_si_irq(smi_info
);
382 smi_info
->curr_msg
->data
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
383 smi_info
->curr_msg
->data
[1] = IPMI_GET_MSG_CMD
;
384 smi_info
->curr_msg
->data_size
= 2;
386 smi_info
->handlers
->start_transaction(
388 smi_info
->curr_msg
->data
,
389 smi_info
->curr_msg
->data_size
);
390 smi_info
->si_state
= SI_GETTING_MESSAGES
;
391 } else if (smi_info
->msg_flags
& EVENT_MSG_BUFFER_FULL
) {
392 /* Events available. */
393 smi_info
->curr_msg
= ipmi_alloc_smi_msg();
394 if (!smi_info
->curr_msg
) {
395 disable_si_irq(smi_info
);
396 smi_info
->si_state
= SI_NORMAL
;
399 enable_si_irq(smi_info
);
401 smi_info
->curr_msg
->data
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
402 smi_info
->curr_msg
->data
[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD
;
403 smi_info
->curr_msg
->data_size
= 2;
405 smi_info
->handlers
->start_transaction(
407 smi_info
->curr_msg
->data
,
408 smi_info
->curr_msg
->data_size
);
409 smi_info
->si_state
= SI_GETTING_EVENTS
;
410 } else if (smi_info
->msg_flags
& OEM_DATA_AVAIL
&&
411 smi_info
->oem_data_avail_handler
) {
412 if (smi_info
->oem_data_avail_handler(smi_info
))
415 smi_info
->si_state
= SI_NORMAL
;
419 static void handle_transaction_done(struct smi_info
*smi_info
)
421 struct ipmi_smi_msg
*msg
;
426 printk("**Done: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
428 switch (smi_info
->si_state
) {
430 if (!smi_info
->curr_msg
)
433 smi_info
->curr_msg
->rsp_size
434 = smi_info
->handlers
->get_result(
436 smi_info
->curr_msg
->rsp
,
437 IPMI_MAX_MSG_LENGTH
);
439 /* Do this here becase deliver_recv_msg() releases the
440 lock, and a new message can be put in during the
441 time the lock is released. */
442 msg
= smi_info
->curr_msg
;
443 smi_info
->curr_msg
= NULL
;
444 deliver_recv_msg(smi_info
, msg
);
447 case SI_GETTING_FLAGS
:
449 unsigned char msg
[4];
452 /* We got the flags from the SMI, now handle them. */
453 len
= smi_info
->handlers
->get_result(smi_info
->si_sm
, msg
, 4);
455 /* Error fetching flags, just give up for
457 smi_info
->si_state
= SI_NORMAL
;
458 } else if (len
< 4) {
459 /* Hmm, no flags. That's technically illegal, but
460 don't use uninitialized data. */
461 smi_info
->si_state
= SI_NORMAL
;
463 smi_info
->msg_flags
= msg
[3];
464 handle_flags(smi_info
);
469 case SI_CLEARING_FLAGS
:
470 case SI_CLEARING_FLAGS_THEN_SET_IRQ
:
472 unsigned char msg
[3];
474 /* We cleared the flags. */
475 smi_info
->handlers
->get_result(smi_info
->si_sm
, msg
, 3);
477 /* Error clearing flags */
479 "ipmi_si: Error clearing flags: %2.2x\n",
482 if (smi_info
->si_state
== SI_CLEARING_FLAGS_THEN_SET_IRQ
)
483 start_enable_irq(smi_info
);
485 smi_info
->si_state
= SI_NORMAL
;
489 case SI_GETTING_EVENTS
:
491 smi_info
->curr_msg
->rsp_size
492 = smi_info
->handlers
->get_result(
494 smi_info
->curr_msg
->rsp
,
495 IPMI_MAX_MSG_LENGTH
);
497 /* Do this here becase deliver_recv_msg() releases the
498 lock, and a new message can be put in during the
499 time the lock is released. */
500 msg
= smi_info
->curr_msg
;
501 smi_info
->curr_msg
= NULL
;
502 if (msg
->rsp
[2] != 0) {
503 /* Error getting event, probably done. */
506 /* Take off the event flag. */
507 smi_info
->msg_flags
&= ~EVENT_MSG_BUFFER_FULL
;
508 handle_flags(smi_info
);
510 spin_lock(&smi_info
->count_lock
);
512 spin_unlock(&smi_info
->count_lock
);
514 /* Do this before we deliver the message
515 because delivering the message releases the
516 lock and something else can mess with the
518 handle_flags(smi_info
);
520 deliver_recv_msg(smi_info
, msg
);
525 case SI_GETTING_MESSAGES
:
527 smi_info
->curr_msg
->rsp_size
528 = smi_info
->handlers
->get_result(
530 smi_info
->curr_msg
->rsp
,
531 IPMI_MAX_MSG_LENGTH
);
533 /* Do this here becase deliver_recv_msg() releases the
534 lock, and a new message can be put in during the
535 time the lock is released. */
536 msg
= smi_info
->curr_msg
;
537 smi_info
->curr_msg
= NULL
;
538 if (msg
->rsp
[2] != 0) {
539 /* Error getting event, probably done. */
542 /* Take off the msg flag. */
543 smi_info
->msg_flags
&= ~RECEIVE_MSG_AVAIL
;
544 handle_flags(smi_info
);
546 spin_lock(&smi_info
->count_lock
);
547 smi_info
->incoming_messages
++;
548 spin_unlock(&smi_info
->count_lock
);
550 /* Do this before we deliver the message
551 because delivering the message releases the
552 lock and something else can mess with the
554 handle_flags(smi_info
);
556 deliver_recv_msg(smi_info
, msg
);
561 case SI_ENABLE_INTERRUPTS1
:
563 unsigned char msg
[4];
565 /* We got the flags from the SMI, now handle them. */
566 smi_info
->handlers
->get_result(smi_info
->si_sm
, msg
, 4);
569 "ipmi_si: Could not enable interrupts"
570 ", failed get, using polled mode.\n");
571 smi_info
->si_state
= SI_NORMAL
;
573 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
574 msg
[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD
;
575 msg
[2] = msg
[3] | 1; /* enable msg queue int */
576 smi_info
->handlers
->start_transaction(
577 smi_info
->si_sm
, msg
, 3);
578 smi_info
->si_state
= SI_ENABLE_INTERRUPTS2
;
583 case SI_ENABLE_INTERRUPTS2
:
585 unsigned char msg
[4];
587 /* We got the flags from the SMI, now handle them. */
588 smi_info
->handlers
->get_result(smi_info
->si_sm
, msg
, 4);
591 "ipmi_si: Could not enable interrupts"
592 ", failed set, using polled mode.\n");
594 smi_info
->si_state
= SI_NORMAL
;
600 /* Called on timeouts and events. Timeouts should pass the elapsed
601 time, interrupts should pass in zero. */
602 static enum si_sm_result
smi_event_handler(struct smi_info
*smi_info
,
605 enum si_sm_result si_sm_result
;
608 /* There used to be a loop here that waited a little while
609 (around 25us) before giving up. That turned out to be
610 pointless, the minimum delays I was seeing were in the 300us
611 range, which is far too long to wait in an interrupt. So
612 we just run until the state machine tells us something
613 happened or it needs a delay. */
614 si_sm_result
= smi_info
->handlers
->event(smi_info
->si_sm
, time
);
616 while (si_sm_result
== SI_SM_CALL_WITHOUT_DELAY
)
618 si_sm_result
= smi_info
->handlers
->event(smi_info
->si_sm
, 0);
621 if (si_sm_result
== SI_SM_TRANSACTION_COMPLETE
)
623 spin_lock(&smi_info
->count_lock
);
624 smi_info
->complete_transactions
++;
625 spin_unlock(&smi_info
->count_lock
);
627 handle_transaction_done(smi_info
);
628 si_sm_result
= smi_info
->handlers
->event(smi_info
->si_sm
, 0);
630 else if (si_sm_result
== SI_SM_HOSED
)
632 spin_lock(&smi_info
->count_lock
);
633 smi_info
->hosed_count
++;
634 spin_unlock(&smi_info
->count_lock
);
636 /* Do the before return_hosed_msg, because that
637 releases the lock. */
638 smi_info
->si_state
= SI_NORMAL
;
639 if (smi_info
->curr_msg
!= NULL
) {
640 /* If we were handling a user message, format
641 a response to send to the upper layer to
642 tell it about the error. */
643 return_hosed_msg(smi_info
);
645 si_sm_result
= smi_info
->handlers
->event(smi_info
->si_sm
, 0);
648 /* We prefer handling attn over new messages. */
649 if (si_sm_result
== SI_SM_ATTN
)
651 unsigned char msg
[2];
653 spin_lock(&smi_info
->count_lock
);
654 smi_info
->attentions
++;
655 spin_unlock(&smi_info
->count_lock
);
657 /* Got a attn, send down a get message flags to see
658 what's causing it. It would be better to handle
659 this in the upper layer, but due to the way
660 interrupts work with the SMI, that's not really
662 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
663 msg
[1] = IPMI_GET_MSG_FLAGS_CMD
;
665 smi_info
->handlers
->start_transaction(
666 smi_info
->si_sm
, msg
, 2);
667 smi_info
->si_state
= SI_GETTING_FLAGS
;
671 /* If we are currently idle, try to start the next message. */
672 if (si_sm_result
== SI_SM_IDLE
) {
673 spin_lock(&smi_info
->count_lock
);
675 spin_unlock(&smi_info
->count_lock
);
677 si_sm_result
= start_next_msg(smi_info
);
678 if (si_sm_result
!= SI_SM_IDLE
)
682 if ((si_sm_result
== SI_SM_IDLE
)
683 && (atomic_read(&smi_info
->req_events
)))
685 /* We are idle and the upper layer requested that I fetch
687 unsigned char msg
[2];
689 spin_lock(&smi_info
->count_lock
);
690 smi_info
->flag_fetches
++;
691 spin_unlock(&smi_info
->count_lock
);
693 atomic_set(&smi_info
->req_events
, 0);
694 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
695 msg
[1] = IPMI_GET_MSG_FLAGS_CMD
;
697 smi_info
->handlers
->start_transaction(
698 smi_info
->si_sm
, msg
, 2);
699 smi_info
->si_state
= SI_GETTING_FLAGS
;
706 static void sender(void *send_info
,
707 struct ipmi_smi_msg
*msg
,
710 struct smi_info
*smi_info
= send_info
;
711 enum si_sm_result result
;
717 spin_lock_irqsave(&(smi_info
->msg_lock
), flags
);
720 printk("**Enqueue: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
723 if (smi_info
->run_to_completion
) {
724 /* If we are running to completion, then throw it in
725 the list and run transactions until everything is
726 clear. Priority doesn't matter here. */
727 list_add_tail(&(msg
->link
), &(smi_info
->xmit_msgs
));
729 /* We have to release the msg lock and claim the smi
730 lock in this case, because of race conditions. */
731 spin_unlock_irqrestore(&(smi_info
->msg_lock
), flags
);
733 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
734 result
= smi_event_handler(smi_info
, 0);
735 while (result
!= SI_SM_IDLE
) {
736 udelay(SI_SHORT_TIMEOUT_USEC
);
737 result
= smi_event_handler(smi_info
,
738 SI_SHORT_TIMEOUT_USEC
);
740 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
744 list_add_tail(&(msg
->link
), &(smi_info
->hp_xmit_msgs
));
746 list_add_tail(&(msg
->link
), &(smi_info
->xmit_msgs
));
749 spin_unlock_irqrestore(&(smi_info
->msg_lock
), flags
);
751 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
752 if ((smi_info
->si_state
== SI_NORMAL
)
753 && (smi_info
->curr_msg
== NULL
))
755 start_next_msg(smi_info
);
757 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
760 static void set_run_to_completion(void *send_info
, int i_run_to_completion
)
762 struct smi_info
*smi_info
= send_info
;
763 enum si_sm_result result
;
766 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
768 smi_info
->run_to_completion
= i_run_to_completion
;
769 if (i_run_to_completion
) {
770 result
= smi_event_handler(smi_info
, 0);
771 while (result
!= SI_SM_IDLE
) {
772 udelay(SI_SHORT_TIMEOUT_USEC
);
773 result
= smi_event_handler(smi_info
,
774 SI_SHORT_TIMEOUT_USEC
);
778 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
781 static int ipmi_thread(void *data
)
783 struct smi_info
*smi_info
= data
;
785 enum si_sm_result smi_result
;
787 set_user_nice(current
, 19);
788 while (!kthread_should_stop()) {
789 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
790 smi_result
= smi_event_handler(smi_info
, 0);
791 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
792 if (smi_result
== SI_SM_CALL_WITHOUT_DELAY
) {
795 else if (smi_result
== SI_SM_CALL_WITH_DELAY
)
798 schedule_timeout_interruptible(1);
804 static void poll(void *send_info
)
806 struct smi_info
*smi_info
= send_info
;
808 smi_event_handler(smi_info
, 0);
811 static void request_events(void *send_info
)
813 struct smi_info
*smi_info
= send_info
;
815 atomic_set(&smi_info
->req_events
, 1);
818 static int initialized
= 0;
820 static void smi_timeout(unsigned long data
)
822 struct smi_info
*smi_info
= (struct smi_info
*) data
;
823 enum si_sm_result smi_result
;
825 unsigned long jiffies_now
;
831 if (atomic_read(&smi_info
->stop_operation
))
834 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
837 printk("**Timer: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
839 jiffies_now
= jiffies
;
840 time_diff
= (((long)jiffies_now
- (long)smi_info
->last_timeout_jiffies
)
841 * SI_USEC_PER_JIFFY
);
842 smi_result
= smi_event_handler(smi_info
, time_diff
);
844 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
846 smi_info
->last_timeout_jiffies
= jiffies_now
;
848 if ((smi_info
->irq
) && (!smi_info
->interrupt_disabled
)) {
849 /* Running with interrupts, only do long timeouts. */
850 smi_info
->si_timer
.expires
= jiffies
+ SI_TIMEOUT_JIFFIES
;
851 spin_lock_irqsave(&smi_info
->count_lock
, flags
);
852 smi_info
->long_timeouts
++;
853 spin_unlock_irqrestore(&smi_info
->count_lock
, flags
);
857 /* If the state machine asks for a short delay, then shorten
858 the timer timeout. */
859 if (smi_result
== SI_SM_CALL_WITH_DELAY
) {
860 spin_lock_irqsave(&smi_info
->count_lock
, flags
);
861 smi_info
->short_timeouts
++;
862 spin_unlock_irqrestore(&smi_info
->count_lock
, flags
);
863 smi_info
->si_timer
.expires
= jiffies
+ 1;
865 spin_lock_irqsave(&smi_info
->count_lock
, flags
);
866 smi_info
->long_timeouts
++;
867 spin_unlock_irqrestore(&smi_info
->count_lock
, flags
);
868 smi_info
->si_timer
.expires
= jiffies
+ SI_TIMEOUT_JIFFIES
;
872 add_timer(&(smi_info
->si_timer
));
875 static irqreturn_t
si_irq_handler(int irq
, void *data
)
877 struct smi_info
*smi_info
= data
;
883 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
885 spin_lock(&smi_info
->count_lock
);
886 smi_info
->interrupts
++;
887 spin_unlock(&smi_info
->count_lock
);
889 if (atomic_read(&smi_info
->stop_operation
))
894 printk("**Interrupt: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
896 smi_event_handler(smi_info
, 0);
898 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
902 static irqreturn_t
si_bt_irq_handler(int irq
, void *data
)
904 struct smi_info
*smi_info
= data
;
905 /* We need to clear the IRQ flag for the BT interface. */
906 smi_info
->io
.outputb(&smi_info
->io
, IPMI_BT_INTMASK_REG
,
907 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
908 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT
);
909 return si_irq_handler(irq
, data
);
912 static int smi_start_processing(void *send_info
,
915 struct smi_info
*new_smi
= send_info
;
918 new_smi
->intf
= intf
;
920 /* Set up the timer that drives the interface. */
921 setup_timer(&new_smi
->si_timer
, smi_timeout
, (long)new_smi
);
922 new_smi
->last_timeout_jiffies
= jiffies
;
923 mod_timer(&new_smi
->si_timer
, jiffies
+ SI_TIMEOUT_JIFFIES
);
926 * Check if the user forcefully enabled the daemon.
928 if (new_smi
->intf_num
< num_force_kipmid
)
929 enable
= force_kipmid
[new_smi
->intf_num
];
931 * The BT interface is efficient enough to not need a thread,
932 * and there is no need for a thread if we have interrupts.
934 else if ((new_smi
->si_type
!= SI_BT
) && (!new_smi
->irq
))
938 new_smi
->thread
= kthread_run(ipmi_thread
, new_smi
,
939 "kipmi%d", new_smi
->intf_num
);
940 if (IS_ERR(new_smi
->thread
)) {
941 printk(KERN_NOTICE
"ipmi_si_intf: Could not start"
942 " kernel thread due to error %ld, only using"
943 " timers to drive the interface\n",
944 PTR_ERR(new_smi
->thread
));
945 new_smi
->thread
= NULL
;
952 static void set_maintenance_mode(void *send_info
, int enable
)
954 struct smi_info
*smi_info
= send_info
;
957 atomic_set(&smi_info
->req_events
, 0);
960 static struct ipmi_smi_handlers handlers
=
962 .owner
= THIS_MODULE
,
963 .start_processing
= smi_start_processing
,
965 .request_events
= request_events
,
966 .set_maintenance_mode
= set_maintenance_mode
,
967 .set_run_to_completion
= set_run_to_completion
,
971 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
972 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
974 static LIST_HEAD(smi_infos
);
975 static DEFINE_MUTEX(smi_infos_lock
);
976 static int smi_num
; /* Used to sequence the SMIs */
978 #define DEFAULT_REGSPACING 1
980 static int si_trydefaults
= 1;
981 static char *si_type
[SI_MAX_PARMS
];
982 #define MAX_SI_TYPE_STR 30
983 static char si_type_str
[MAX_SI_TYPE_STR
];
984 static unsigned long addrs
[SI_MAX_PARMS
];
985 static int num_addrs
;
986 static unsigned int ports
[SI_MAX_PARMS
];
987 static int num_ports
;
988 static int irqs
[SI_MAX_PARMS
];
990 static int regspacings
[SI_MAX_PARMS
];
991 static int num_regspacings
= 0;
992 static int regsizes
[SI_MAX_PARMS
];
993 static int num_regsizes
= 0;
994 static int regshifts
[SI_MAX_PARMS
];
995 static int num_regshifts
= 0;
996 static int slave_addrs
[SI_MAX_PARMS
];
997 static int num_slave_addrs
= 0;
1000 module_param_named(trydefaults
, si_trydefaults
, bool, 0);
1001 MODULE_PARM_DESC(trydefaults
, "Setting this to 'false' will disable the"
1002 " default scan of the KCS and SMIC interface at the standard"
1004 module_param_string(type
, si_type_str
, MAX_SI_TYPE_STR
, 0);
1005 MODULE_PARM_DESC(type
, "Defines the type of each interface, each"
1006 " interface separated by commas. The types are 'kcs',"
1007 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1008 " the first interface to kcs and the second to bt");
1009 module_param_array(addrs
, long, &num_addrs
, 0);
1010 MODULE_PARM_DESC(addrs
, "Sets the memory address of each interface, the"
1011 " addresses separated by commas. Only use if an interface"
1012 " is in memory. Otherwise, set it to zero or leave"
1014 module_param_array(ports
, int, &num_ports
, 0);
1015 MODULE_PARM_DESC(ports
, "Sets the port address of each interface, the"
1016 " addresses separated by commas. Only use if an interface"
1017 " is a port. Otherwise, set it to zero or leave"
1019 module_param_array(irqs
, int, &num_irqs
, 0);
1020 MODULE_PARM_DESC(irqs
, "Sets the interrupt of each interface, the"
1021 " addresses separated by commas. Only use if an interface"
1022 " has an interrupt. Otherwise, set it to zero or leave"
1024 module_param_array(regspacings
, int, &num_regspacings
, 0);
1025 MODULE_PARM_DESC(regspacings
, "The number of bytes between the start address"
1026 " and each successive register used by the interface. For"
1027 " instance, if the start address is 0xca2 and the spacing"
1028 " is 2, then the second address is at 0xca4. Defaults"
1030 module_param_array(regsizes
, int, &num_regsizes
, 0);
1031 MODULE_PARM_DESC(regsizes
, "The size of the specific IPMI register in bytes."
1032 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1033 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1034 " the 8-bit IPMI register has to be read from a larger"
1036 module_param_array(regshifts
, int, &num_regshifts
, 0);
1037 MODULE_PARM_DESC(regshifts
, "The amount to shift the data read from the."
1038 " IPMI register, in bits. For instance, if the data"
1039 " is read from a 32-bit word and the IPMI data is in"
1040 " bit 8-15, then the shift would be 8");
1041 module_param_array(slave_addrs
, int, &num_slave_addrs
, 0);
1042 MODULE_PARM_DESC(slave_addrs
, "Set the default IPMB slave address for"
1043 " the controller. Normally this is 0x20, but can be"
1044 " overridden by this parm. This is an array indexed"
1045 " by interface number.");
1046 module_param_array(force_kipmid
, int, &num_force_kipmid
, 0);
1047 MODULE_PARM_DESC(force_kipmid
, "Force the kipmi daemon to be enabled (1) or"
1048 " disabled(0). Normally the IPMI driver auto-detects"
1049 " this, but the value may be overridden by this parm.");
1052 #define IPMI_IO_ADDR_SPACE 0
1053 #define IPMI_MEM_ADDR_SPACE 1
1054 static char *addr_space_to_str
[] = { "I/O", "memory" };
1056 static void std_irq_cleanup(struct smi_info
*info
)
1058 if (info
->si_type
== SI_BT
)
1059 /* Disable the interrupt in the BT interface. */
1060 info
->io
.outputb(&info
->io
, IPMI_BT_INTMASK_REG
, 0);
1061 free_irq(info
->irq
, info
);
1064 static int std_irq_setup(struct smi_info
*info
)
1071 if (info
->si_type
== SI_BT
) {
1072 rv
= request_irq(info
->irq
,
1078 /* Enable the interrupt in the BT interface. */
1079 info
->io
.outputb(&info
->io
, IPMI_BT_INTMASK_REG
,
1080 IPMI_BT_INTMASK_ENABLE_IRQ_BIT
);
1082 rv
= request_irq(info
->irq
,
1089 "ipmi_si: %s unable to claim interrupt %d,"
1090 " running polled\n",
1091 DEVICE_NAME
, info
->irq
);
1094 info
->irq_cleanup
= std_irq_cleanup
;
1095 printk(" Using irq %d\n", info
->irq
);
1101 static unsigned char port_inb(struct si_sm_io
*io
, unsigned int offset
)
1103 unsigned int addr
= io
->addr_data
;
1105 return inb(addr
+ (offset
* io
->regspacing
));
1108 static void port_outb(struct si_sm_io
*io
, unsigned int offset
,
1111 unsigned int addr
= io
->addr_data
;
1113 outb(b
, addr
+ (offset
* io
->regspacing
));
1116 static unsigned char port_inw(struct si_sm_io
*io
, unsigned int offset
)
1118 unsigned int addr
= io
->addr_data
;
1120 return (inw(addr
+ (offset
* io
->regspacing
)) >> io
->regshift
) & 0xff;
1123 static void port_outw(struct si_sm_io
*io
, unsigned int offset
,
1126 unsigned int addr
= io
->addr_data
;
1128 outw(b
<< io
->regshift
, addr
+ (offset
* io
->regspacing
));
1131 static unsigned char port_inl(struct si_sm_io
*io
, unsigned int offset
)
1133 unsigned int addr
= io
->addr_data
;
1135 return (inl(addr
+ (offset
* io
->regspacing
)) >> io
->regshift
) & 0xff;
1138 static void port_outl(struct si_sm_io
*io
, unsigned int offset
,
1141 unsigned int addr
= io
->addr_data
;
1143 outl(b
<< io
->regshift
, addr
+(offset
* io
->regspacing
));
1146 static void port_cleanup(struct smi_info
*info
)
1148 unsigned int addr
= info
->io
.addr_data
;
1152 for (idx
= 0; idx
< info
->io_size
; idx
++) {
1153 release_region(addr
+ idx
* info
->io
.regspacing
,
1159 static int port_setup(struct smi_info
*info
)
1161 unsigned int addr
= info
->io
.addr_data
;
1167 info
->io_cleanup
= port_cleanup
;
1169 /* Figure out the actual inb/inw/inl/etc routine to use based
1170 upon the register size. */
1171 switch (info
->io
.regsize
) {
1173 info
->io
.inputb
= port_inb
;
1174 info
->io
.outputb
= port_outb
;
1177 info
->io
.inputb
= port_inw
;
1178 info
->io
.outputb
= port_outw
;
1181 info
->io
.inputb
= port_inl
;
1182 info
->io
.outputb
= port_outl
;
1185 printk("ipmi_si: Invalid register size: %d\n",
1190 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1191 * tables. This causes problems when trying to register the
1192 * entire I/O region. Therefore we must register each I/O
1195 for (idx
= 0; idx
< info
->io_size
; idx
++) {
1196 if (request_region(addr
+ idx
* info
->io
.regspacing
,
1197 info
->io
.regsize
, DEVICE_NAME
) == NULL
) {
1198 /* Undo allocations */
1200 release_region(addr
+ idx
* info
->io
.regspacing
,
1209 static unsigned char intf_mem_inb(struct si_sm_io
*io
, unsigned int offset
)
1211 return readb((io
->addr
)+(offset
* io
->regspacing
));
1214 static void intf_mem_outb(struct si_sm_io
*io
, unsigned int offset
,
1217 writeb(b
, (io
->addr
)+(offset
* io
->regspacing
));
1220 static unsigned char intf_mem_inw(struct si_sm_io
*io
, unsigned int offset
)
1222 return (readw((io
->addr
)+(offset
* io
->regspacing
)) >> io
->regshift
)
1226 static void intf_mem_outw(struct si_sm_io
*io
, unsigned int offset
,
1229 writeb(b
<< io
->regshift
, (io
->addr
)+(offset
* io
->regspacing
));
1232 static unsigned char intf_mem_inl(struct si_sm_io
*io
, unsigned int offset
)
1234 return (readl((io
->addr
)+(offset
* io
->regspacing
)) >> io
->regshift
)
1238 static void intf_mem_outl(struct si_sm_io
*io
, unsigned int offset
,
1241 writel(b
<< io
->regshift
, (io
->addr
)+(offset
* io
->regspacing
));
1245 static unsigned char mem_inq(struct si_sm_io
*io
, unsigned int offset
)
1247 return (readq((io
->addr
)+(offset
* io
->regspacing
)) >> io
->regshift
)
1251 static void mem_outq(struct si_sm_io
*io
, unsigned int offset
,
1254 writeq(b
<< io
->regshift
, (io
->addr
)+(offset
* io
->regspacing
));
1258 static void mem_cleanup(struct smi_info
*info
)
1260 unsigned long addr
= info
->io
.addr_data
;
1263 if (info
->io
.addr
) {
1264 iounmap(info
->io
.addr
);
1266 mapsize
= ((info
->io_size
* info
->io
.regspacing
)
1267 - (info
->io
.regspacing
- info
->io
.regsize
));
1269 release_mem_region(addr
, mapsize
);
1273 static int mem_setup(struct smi_info
*info
)
1275 unsigned long addr
= info
->io
.addr_data
;
1281 info
->io_cleanup
= mem_cleanup
;
1283 /* Figure out the actual readb/readw/readl/etc routine to use based
1284 upon the register size. */
1285 switch (info
->io
.regsize
) {
1287 info
->io
.inputb
= intf_mem_inb
;
1288 info
->io
.outputb
= intf_mem_outb
;
1291 info
->io
.inputb
= intf_mem_inw
;
1292 info
->io
.outputb
= intf_mem_outw
;
1295 info
->io
.inputb
= intf_mem_inl
;
1296 info
->io
.outputb
= intf_mem_outl
;
1300 info
->io
.inputb
= mem_inq
;
1301 info
->io
.outputb
= mem_outq
;
1305 printk("ipmi_si: Invalid register size: %d\n",
1310 /* Calculate the total amount of memory to claim. This is an
1311 * unusual looking calculation, but it avoids claiming any
1312 * more memory than it has to. It will claim everything
1313 * between the first address to the end of the last full
1315 mapsize
= ((info
->io_size
* info
->io
.regspacing
)
1316 - (info
->io
.regspacing
- info
->io
.regsize
));
1318 if (request_mem_region(addr
, mapsize
, DEVICE_NAME
) == NULL
)
1321 info
->io
.addr
= ioremap(addr
, mapsize
);
1322 if (info
->io
.addr
== NULL
) {
1323 release_mem_region(addr
, mapsize
);
1330 static __devinit
void hardcode_find_bmc(void)
1333 struct smi_info
*info
;
1335 for (i
= 0; i
< SI_MAX_PARMS
; i
++) {
1336 if (!ports
[i
] && !addrs
[i
])
1339 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1343 info
->addr_source
= "hardcoded";
1345 if (!si_type
[i
] || strcmp(si_type
[i
], "kcs") == 0) {
1346 info
->si_type
= SI_KCS
;
1347 } else if (strcmp(si_type
[i
], "smic") == 0) {
1348 info
->si_type
= SI_SMIC
;
1349 } else if (strcmp(si_type
[i
], "bt") == 0) {
1350 info
->si_type
= SI_BT
;
1353 "ipmi_si: Interface type specified "
1354 "for interface %d, was invalid: %s\n",
1362 info
->io_setup
= port_setup
;
1363 info
->io
.addr_data
= ports
[i
];
1364 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
1365 } else if (addrs
[i
]) {
1367 info
->io_setup
= mem_setup
;
1368 info
->io
.addr_data
= addrs
[i
];
1369 info
->io
.addr_type
= IPMI_MEM_ADDR_SPACE
;
1372 "ipmi_si: Interface type specified "
1373 "for interface %d, "
1374 "but port and address were not set or "
1375 "set to zero.\n", i
);
1380 info
->io
.addr
= NULL
;
1381 info
->io
.regspacing
= regspacings
[i
];
1382 if (!info
->io
.regspacing
)
1383 info
->io
.regspacing
= DEFAULT_REGSPACING
;
1384 info
->io
.regsize
= regsizes
[i
];
1385 if (!info
->io
.regsize
)
1386 info
->io
.regsize
= DEFAULT_REGSPACING
;
1387 info
->io
.regshift
= regshifts
[i
];
1388 info
->irq
= irqs
[i
];
1390 info
->irq_setup
= std_irq_setup
;
1398 #include <linux/acpi.h>
1400 /* Once we get an ACPI failure, we don't try any more, because we go
1401 through the tables sequentially. Once we don't find a table, there
1403 static int acpi_failure
= 0;
1405 /* For GPE-type interrupts. */
1406 static u32
ipmi_acpi_gpe(void *context
)
1408 struct smi_info
*smi_info
= context
;
1409 unsigned long flags
;
1414 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
1416 spin_lock(&smi_info
->count_lock
);
1417 smi_info
->interrupts
++;
1418 spin_unlock(&smi_info
->count_lock
);
1420 if (atomic_read(&smi_info
->stop_operation
))
1424 do_gettimeofday(&t
);
1425 printk("**ACPI_GPE: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
1427 smi_event_handler(smi_info
, 0);
1429 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
1431 return ACPI_INTERRUPT_HANDLED
;
1434 static void acpi_gpe_irq_cleanup(struct smi_info
*info
)
1439 acpi_remove_gpe_handler(NULL
, info
->irq
, &ipmi_acpi_gpe
);
1442 static int acpi_gpe_irq_setup(struct smi_info
*info
)
1449 /* FIXME - is level triggered right? */
1450 status
= acpi_install_gpe_handler(NULL
,
1452 ACPI_GPE_LEVEL_TRIGGERED
,
1455 if (status
!= AE_OK
) {
1457 "ipmi_si: %s unable to claim ACPI GPE %d,"
1458 " running polled\n",
1459 DEVICE_NAME
, info
->irq
);
1463 info
->irq_cleanup
= acpi_gpe_irq_cleanup
;
1464 printk(" Using ACPI GPE %d\n", info
->irq
);
1471 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1482 s8 CreatorRevision
[4];
1485 s16 SpecificationRevision
;
1488 * Bit 0 - SCI interrupt supported
1489 * Bit 1 - I/O APIC/SAPIC
1493 /* If bit 0 of InterruptType is set, then this is the SCI
1494 interrupt in the GPEx_STS register. */
1499 /* If bit 1 of InterruptType is set, then this is the I/O
1500 APIC/SAPIC interrupt. */
1501 u32 GlobalSystemInterrupt
;
1503 /* The actual register address. */
1504 struct acpi_generic_address addr
;
1508 s8 spmi_id
[1]; /* A '\0' terminated array starts here. */
1511 static __devinit
int try_init_acpi(struct SPMITable
*spmi
)
1513 struct smi_info
*info
;
1517 if (spmi
->IPMIlegacy
!= 1) {
1518 printk(KERN_INFO
"IPMI: Bad SPMI legacy %d\n", spmi
->IPMIlegacy
);
1522 if (spmi
->addr
.address_space_id
== ACPI_ADR_SPACE_SYSTEM_MEMORY
)
1523 addr_space
= IPMI_MEM_ADDR_SPACE
;
1525 addr_space
= IPMI_IO_ADDR_SPACE
;
1527 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1529 printk(KERN_ERR
"ipmi_si: Could not allocate SI data (3)\n");
1533 info
->addr_source
= "ACPI";
1535 /* Figure out the interface type. */
1536 switch (spmi
->InterfaceType
)
1539 info
->si_type
= SI_KCS
;
1542 info
->si_type
= SI_SMIC
;
1545 info
->si_type
= SI_BT
;
1548 printk(KERN_INFO
"ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1549 spmi
->InterfaceType
);
1554 if (spmi
->InterruptType
& 1) {
1555 /* We've got a GPE interrupt. */
1556 info
->irq
= spmi
->GPE
;
1557 info
->irq_setup
= acpi_gpe_irq_setup
;
1558 } else if (spmi
->InterruptType
& 2) {
1559 /* We've got an APIC/SAPIC interrupt. */
1560 info
->irq
= spmi
->GlobalSystemInterrupt
;
1561 info
->irq_setup
= std_irq_setup
;
1563 /* Use the default interrupt setting. */
1565 info
->irq_setup
= NULL
;
1568 if (spmi
->addr
.register_bit_width
) {
1569 /* A (hopefully) properly formed register bit width. */
1570 info
->io
.regspacing
= spmi
->addr
.register_bit_width
/ 8;
1572 info
->io
.regspacing
= DEFAULT_REGSPACING
;
1574 info
->io
.regsize
= info
->io
.regspacing
;
1575 info
->io
.regshift
= spmi
->addr
.register_bit_offset
;
1577 if (spmi
->addr
.address_space_id
== ACPI_ADR_SPACE_SYSTEM_MEMORY
) {
1579 info
->io_setup
= mem_setup
;
1580 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
1581 } else if (spmi
->addr
.address_space_id
== ACPI_ADR_SPACE_SYSTEM_IO
) {
1583 info
->io_setup
= port_setup
;
1584 info
->io
.addr_type
= IPMI_MEM_ADDR_SPACE
;
1587 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1590 info
->io
.addr_data
= spmi
->addr
.address
;
1597 static __devinit
void acpi_find_bmc(void)
1600 struct SPMITable
*spmi
;
1609 for (i
= 0; ; i
++) {
1610 status
= acpi_get_firmware_table("SPMI", i
+1,
1611 ACPI_LOGICAL_ADDRESSING
,
1612 (struct acpi_table_header
**)
1614 if (status
!= AE_OK
)
1617 try_init_acpi(spmi
);
1623 struct dmi_ipmi_data
1627 unsigned long base_addr
;
1633 static int __devinit
decode_dmi(struct dmi_header
*dm
,
1634 struct dmi_ipmi_data
*dmi
)
1636 u8
*data
= (u8
*)dm
;
1637 unsigned long base_addr
;
1639 u8 len
= dm
->length
;
1641 dmi
->type
= data
[4];
1643 memcpy(&base_addr
, data
+8, sizeof(unsigned long));
1645 if (base_addr
& 1) {
1647 base_addr
&= 0xFFFE;
1648 dmi
->addr_space
= IPMI_IO_ADDR_SPACE
;
1652 dmi
->addr_space
= IPMI_MEM_ADDR_SPACE
;
1654 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1656 dmi
->base_addr
= base_addr
| ((data
[0x10] & 0x10) >> 4);
1658 dmi
->irq
= data
[0x11];
1660 /* The top two bits of byte 0x10 hold the register spacing. */
1661 reg_spacing
= (data
[0x10] & 0xC0) >> 6;
1662 switch(reg_spacing
){
1663 case 0x00: /* Byte boundaries */
1666 case 0x01: /* 32-bit boundaries */
1669 case 0x02: /* 16-byte boundaries */
1673 /* Some other interface, just ignore it. */
1678 /* Note that technically, the lower bit of the base
1679 * address should be 1 if the address is I/O and 0 if
1680 * the address is in memory. So many systems get that
1681 * wrong (and all that I have seen are I/O) so we just
1682 * ignore that bit and assume I/O. Systems that use
1683 * memory should use the newer spec, anyway. */
1684 dmi
->base_addr
= base_addr
& 0xfffe;
1685 dmi
->addr_space
= IPMI_IO_ADDR_SPACE
;
1689 dmi
->slave_addr
= data
[6];
1694 static __devinit
void try_init_dmi(struct dmi_ipmi_data
*ipmi_data
)
1696 struct smi_info
*info
;
1698 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1701 "ipmi_si: Could not allocate SI data\n");
1705 info
->addr_source
= "SMBIOS";
1707 switch (ipmi_data
->type
) {
1708 case 0x01: /* KCS */
1709 info
->si_type
= SI_KCS
;
1711 case 0x02: /* SMIC */
1712 info
->si_type
= SI_SMIC
;
1715 info
->si_type
= SI_BT
;
1721 switch (ipmi_data
->addr_space
) {
1722 case IPMI_MEM_ADDR_SPACE
:
1723 info
->io_setup
= mem_setup
;
1724 info
->io
.addr_type
= IPMI_MEM_ADDR_SPACE
;
1727 case IPMI_IO_ADDR_SPACE
:
1728 info
->io_setup
= port_setup
;
1729 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
1735 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
1736 ipmi_data
->addr_space
);
1739 info
->io
.addr_data
= ipmi_data
->base_addr
;
1741 info
->io
.regspacing
= ipmi_data
->offset
;
1742 if (!info
->io
.regspacing
)
1743 info
->io
.regspacing
= DEFAULT_REGSPACING
;
1744 info
->io
.regsize
= DEFAULT_REGSPACING
;
1745 info
->io
.regshift
= 0;
1747 info
->slave_addr
= ipmi_data
->slave_addr
;
1749 info
->irq
= ipmi_data
->irq
;
1751 info
->irq_setup
= std_irq_setup
;
1756 static void __devinit
dmi_find_bmc(void)
1758 struct dmi_device
*dev
= NULL
;
1759 struct dmi_ipmi_data data
;
1762 while ((dev
= dmi_find_device(DMI_DEV_TYPE_IPMI
, NULL
, dev
))) {
1763 memset(&data
, 0, sizeof(data
));
1764 rv
= decode_dmi((struct dmi_header
*) dev
->device_data
, &data
);
1766 try_init_dmi(&data
);
1769 #endif /* CONFIG_DMI */
1773 #define PCI_ERMC_CLASSCODE 0x0C0700
1774 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
1775 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
1776 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
1777 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
1778 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
1780 #define PCI_HP_VENDOR_ID 0x103C
1781 #define PCI_MMC_DEVICE_ID 0x121A
1782 #define PCI_MMC_ADDR_CW 0x10
1784 static void ipmi_pci_cleanup(struct smi_info
*info
)
1786 struct pci_dev
*pdev
= info
->addr_source_data
;
1788 pci_disable_device(pdev
);
1791 static int __devinit
ipmi_pci_probe(struct pci_dev
*pdev
,
1792 const struct pci_device_id
*ent
)
1795 int class_type
= pdev
->class & PCI_ERMC_CLASSCODE_TYPE_MASK
;
1796 struct smi_info
*info
;
1797 int first_reg_offset
= 0;
1799 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1803 info
->addr_source
= "PCI";
1805 switch (class_type
) {
1806 case PCI_ERMC_CLASSCODE_TYPE_SMIC
:
1807 info
->si_type
= SI_SMIC
;
1810 case PCI_ERMC_CLASSCODE_TYPE_KCS
:
1811 info
->si_type
= SI_KCS
;
1814 case PCI_ERMC_CLASSCODE_TYPE_BT
:
1815 info
->si_type
= SI_BT
;
1820 printk(KERN_INFO
"ipmi_si: %s: Unknown IPMI type: %d\n",
1821 pci_name(pdev
), class_type
);
1825 rv
= pci_enable_device(pdev
);
1827 printk(KERN_ERR
"ipmi_si: %s: couldn't enable PCI device\n",
1833 info
->addr_source_cleanup
= ipmi_pci_cleanup
;
1834 info
->addr_source_data
= pdev
;
1836 if (pdev
->subsystem_vendor
== PCI_HP_VENDOR_ID
)
1837 first_reg_offset
= 1;
1839 if (pci_resource_flags(pdev
, 0) & IORESOURCE_IO
) {
1840 info
->io_setup
= port_setup
;
1841 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
1843 info
->io_setup
= mem_setup
;
1844 info
->io
.addr_type
= IPMI_MEM_ADDR_SPACE
;
1846 info
->io
.addr_data
= pci_resource_start(pdev
, 0);
1848 info
->io
.regspacing
= DEFAULT_REGSPACING
;
1849 info
->io
.regsize
= DEFAULT_REGSPACING
;
1850 info
->io
.regshift
= 0;
1852 info
->irq
= pdev
->irq
;
1854 info
->irq_setup
= std_irq_setup
;
1856 info
->dev
= &pdev
->dev
;
1858 return try_smi_init(info
);
1861 static void __devexit
ipmi_pci_remove(struct pci_dev
*pdev
)
1866 static int ipmi_pci_suspend(struct pci_dev
*pdev
, pm_message_t state
)
1871 static int ipmi_pci_resume(struct pci_dev
*pdev
)
1877 static struct pci_device_id ipmi_pci_devices
[] = {
1878 { PCI_DEVICE(PCI_HP_VENDOR_ID
, PCI_MMC_DEVICE_ID
) },
1879 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE
, PCI_ERMC_CLASSCODE_MASK
) }
1881 MODULE_DEVICE_TABLE(pci
, ipmi_pci_devices
);
1883 static struct pci_driver ipmi_pci_driver
= {
1884 .name
= DEVICE_NAME
,
1885 .id_table
= ipmi_pci_devices
,
1886 .probe
= ipmi_pci_probe
,
1887 .remove
= __devexit_p(ipmi_pci_remove
),
1889 .suspend
= ipmi_pci_suspend
,
1890 .resume
= ipmi_pci_resume
,
1893 #endif /* CONFIG_PCI */
1896 static int try_get_dev_id(struct smi_info
*smi_info
)
1898 unsigned char msg
[2];
1899 unsigned char *resp
;
1900 unsigned long resp_len
;
1901 enum si_sm_result smi_result
;
1904 resp
= kmalloc(IPMI_MAX_MSG_LENGTH
, GFP_KERNEL
);
1908 /* Do a Get Device ID command, since it comes back with some
1910 msg
[0] = IPMI_NETFN_APP_REQUEST
<< 2;
1911 msg
[1] = IPMI_GET_DEVICE_ID_CMD
;
1912 smi_info
->handlers
->start_transaction(smi_info
->si_sm
, msg
, 2);
1914 smi_result
= smi_info
->handlers
->event(smi_info
->si_sm
, 0);
1917 if (smi_result
== SI_SM_CALL_WITH_DELAY
||
1918 smi_result
== SI_SM_CALL_WITH_TICK_DELAY
) {
1919 schedule_timeout_uninterruptible(1);
1920 smi_result
= smi_info
->handlers
->event(
1921 smi_info
->si_sm
, 100);
1923 else if (smi_result
== SI_SM_CALL_WITHOUT_DELAY
)
1925 smi_result
= smi_info
->handlers
->event(
1926 smi_info
->si_sm
, 0);
1931 if (smi_result
== SI_SM_HOSED
) {
1932 /* We couldn't get the state machine to run, so whatever's at
1933 the port is probably not an IPMI SMI interface. */
1938 /* Otherwise, we got some data. */
1939 resp_len
= smi_info
->handlers
->get_result(smi_info
->si_sm
,
1940 resp
, IPMI_MAX_MSG_LENGTH
);
1941 if (resp_len
< 14) {
1942 /* That's odd, it should be longer. */
1947 if ((resp
[1] != IPMI_GET_DEVICE_ID_CMD
) || (resp
[2] != 0)) {
1948 /* That's odd, it shouldn't be able to fail. */
1953 /* Record info from the get device id, in case we need it. */
1954 ipmi_demangle_device_id(resp
+3, resp_len
-3, &smi_info
->device_id
);
1961 static int type_file_read_proc(char *page
, char **start
, off_t off
,
1962 int count
, int *eof
, void *data
)
1964 char *out
= (char *) page
;
1965 struct smi_info
*smi
= data
;
1967 switch (smi
->si_type
) {
1969 return sprintf(out
, "kcs\n");
1971 return sprintf(out
, "smic\n");
1973 return sprintf(out
, "bt\n");
1979 static int stat_file_read_proc(char *page
, char **start
, off_t off
,
1980 int count
, int *eof
, void *data
)
1982 char *out
= (char *) page
;
1983 struct smi_info
*smi
= data
;
1985 out
+= sprintf(out
, "interrupts_enabled: %d\n",
1986 smi
->irq
&& !smi
->interrupt_disabled
);
1987 out
+= sprintf(out
, "short_timeouts: %ld\n",
1988 smi
->short_timeouts
);
1989 out
+= sprintf(out
, "long_timeouts: %ld\n",
1990 smi
->long_timeouts
);
1991 out
+= sprintf(out
, "timeout_restarts: %ld\n",
1992 smi
->timeout_restarts
);
1993 out
+= sprintf(out
, "idles: %ld\n",
1995 out
+= sprintf(out
, "interrupts: %ld\n",
1997 out
+= sprintf(out
, "attentions: %ld\n",
1999 out
+= sprintf(out
, "flag_fetches: %ld\n",
2001 out
+= sprintf(out
, "hosed_count: %ld\n",
2003 out
+= sprintf(out
, "complete_transactions: %ld\n",
2004 smi
->complete_transactions
);
2005 out
+= sprintf(out
, "events: %ld\n",
2007 out
+= sprintf(out
, "watchdog_pretimeouts: %ld\n",
2008 smi
->watchdog_pretimeouts
);
2009 out
+= sprintf(out
, "incoming_messages: %ld\n",
2010 smi
->incoming_messages
);
2012 return (out
- ((char *) page
));
2016 * oem_data_avail_to_receive_msg_avail
2017 * @info - smi_info structure with msg_flags set
2019 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2020 * Returns 1 indicating need to re-run handle_flags().
2022 static int oem_data_avail_to_receive_msg_avail(struct smi_info
*smi_info
)
2024 smi_info
->msg_flags
= ((smi_info
->msg_flags
& ~OEM_DATA_AVAIL
) |
2030 * setup_dell_poweredge_oem_data_handler
2031 * @info - smi_info.device_id must be populated
2033 * Systems that match, but have firmware version < 1.40 may assert
2034 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2035 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2036 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2037 * as RECEIVE_MSG_AVAIL instead.
2039 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2040 * assert the OEM[012] bits, and if it did, the driver would have to
2041 * change to handle that properly, we don't actually check for the
2043 * Device ID = 0x20 BMC on PowerEdge 8G servers
2044 * Device Revision = 0x80
2045 * Firmware Revision1 = 0x01 BMC version 1.40
2046 * Firmware Revision2 = 0x40 BCD encoded
2047 * IPMI Version = 0x51 IPMI 1.5
2048 * Manufacturer ID = A2 02 00 Dell IANA
2050 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2051 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2054 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2055 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2056 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2057 #define DELL_IANA_MFR_ID 0x0002a2
2058 static void setup_dell_poweredge_oem_data_handler(struct smi_info
*smi_info
)
2060 struct ipmi_device_id
*id
= &smi_info
->device_id
;
2061 if (id
->manufacturer_id
== DELL_IANA_MFR_ID
) {
2062 if (id
->device_id
== DELL_POWEREDGE_8G_BMC_DEVICE_ID
&&
2063 id
->device_revision
== DELL_POWEREDGE_8G_BMC_DEVICE_REV
&&
2064 id
->ipmi_version
== DELL_POWEREDGE_8G_BMC_IPMI_VERSION
) {
2065 smi_info
->oem_data_avail_handler
=
2066 oem_data_avail_to_receive_msg_avail
;
2068 else if (ipmi_version_major(id
) < 1 ||
2069 (ipmi_version_major(id
) == 1 &&
2070 ipmi_version_minor(id
) < 5)) {
2071 smi_info
->oem_data_avail_handler
=
2072 oem_data_avail_to_receive_msg_avail
;
2077 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2078 static void return_hosed_msg_badsize(struct smi_info
*smi_info
)
2080 struct ipmi_smi_msg
*msg
= smi_info
->curr_msg
;
2082 /* Make it a reponse */
2083 msg
->rsp
[0] = msg
->data
[0] | 4;
2084 msg
->rsp
[1] = msg
->data
[1];
2085 msg
->rsp
[2] = CANNOT_RETURN_REQUESTED_LENGTH
;
2087 smi_info
->curr_msg
= NULL
;
2088 deliver_recv_msg(smi_info
, msg
);
2092 * dell_poweredge_bt_xaction_handler
2093 * @info - smi_info.device_id must be populated
2095 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2096 * not respond to a Get SDR command if the length of the data
2097 * requested is exactly 0x3A, which leads to command timeouts and no
2098 * data returned. This intercepts such commands, and causes userspace
2099 * callers to try again with a different-sized buffer, which succeeds.
2102 #define STORAGE_NETFN 0x0A
2103 #define STORAGE_CMD_GET_SDR 0x23
2104 static int dell_poweredge_bt_xaction_handler(struct notifier_block
*self
,
2105 unsigned long unused
,
2108 struct smi_info
*smi_info
= in
;
2109 unsigned char *data
= smi_info
->curr_msg
->data
;
2110 unsigned int size
= smi_info
->curr_msg
->data_size
;
2112 (data
[0]>>2) == STORAGE_NETFN
&&
2113 data
[1] == STORAGE_CMD_GET_SDR
&&
2115 return_hosed_msg_badsize(smi_info
);
2121 static struct notifier_block dell_poweredge_bt_xaction_notifier
= {
2122 .notifier_call
= dell_poweredge_bt_xaction_handler
,
2126 * setup_dell_poweredge_bt_xaction_handler
2127 * @info - smi_info.device_id must be filled in already
2129 * Fills in smi_info.device_id.start_transaction_pre_hook
2130 * when we know what function to use there.
2133 setup_dell_poweredge_bt_xaction_handler(struct smi_info
*smi_info
)
2135 struct ipmi_device_id
*id
= &smi_info
->device_id
;
2136 if (id
->manufacturer_id
== DELL_IANA_MFR_ID
&&
2137 smi_info
->si_type
== SI_BT
)
2138 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier
);
2142 * setup_oem_data_handler
2143 * @info - smi_info.device_id must be filled in already
2145 * Fills in smi_info.device_id.oem_data_available_handler
2146 * when we know what function to use there.
2149 static void setup_oem_data_handler(struct smi_info
*smi_info
)
2151 setup_dell_poweredge_oem_data_handler(smi_info
);
2154 static void setup_xaction_handlers(struct smi_info
*smi_info
)
2156 setup_dell_poweredge_bt_xaction_handler(smi_info
);
2159 static inline void wait_for_timer_and_thread(struct smi_info
*smi_info
)
2161 if (smi_info
->intf
) {
2162 /* The timer and thread are only running if the
2163 interface has been started up and registered. */
2164 if (smi_info
->thread
!= NULL
)
2165 kthread_stop(smi_info
->thread
);
2166 del_timer_sync(&smi_info
->si_timer
);
2170 static __devinitdata
struct ipmi_default_vals
2176 { .type
= SI_KCS
, .port
= 0xca2 },
2177 { .type
= SI_SMIC
, .port
= 0xca9 },
2178 { .type
= SI_BT
, .port
= 0xe4 },
2182 static __devinit
void default_find_bmc(void)
2184 struct smi_info
*info
;
2187 for (i
= 0; ; i
++) {
2188 if (!ipmi_defaults
[i
].port
)
2191 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
2195 info
->addr_source
= NULL
;
2197 info
->si_type
= ipmi_defaults
[i
].type
;
2198 info
->io_setup
= port_setup
;
2199 info
->io
.addr_data
= ipmi_defaults
[i
].port
;
2200 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
2202 info
->io
.addr
= NULL
;
2203 info
->io
.regspacing
= DEFAULT_REGSPACING
;
2204 info
->io
.regsize
= DEFAULT_REGSPACING
;
2205 info
->io
.regshift
= 0;
2207 if (try_smi_init(info
) == 0) {
2209 printk(KERN_INFO
"ipmi_si: Found default %s state"
2210 " machine at %s address 0x%lx\n",
2211 si_to_str
[info
->si_type
],
2212 addr_space_to_str
[info
->io
.addr_type
],
2213 info
->io
.addr_data
);
2219 static int is_new_interface(struct smi_info
*info
)
2223 list_for_each_entry(e
, &smi_infos
, link
) {
2224 if (e
->io
.addr_type
!= info
->io
.addr_type
)
2226 if (e
->io
.addr_data
== info
->io
.addr_data
)
2233 static int try_smi_init(struct smi_info
*new_smi
)
2237 if (new_smi
->addr_source
) {
2238 printk(KERN_INFO
"ipmi_si: Trying %s-specified %s state"
2239 " machine at %s address 0x%lx, slave address 0x%x,"
2241 new_smi
->addr_source
,
2242 si_to_str
[new_smi
->si_type
],
2243 addr_space_to_str
[new_smi
->io
.addr_type
],
2244 new_smi
->io
.addr_data
,
2245 new_smi
->slave_addr
, new_smi
->irq
);
2248 mutex_lock(&smi_infos_lock
);
2249 if (!is_new_interface(new_smi
)) {
2250 printk(KERN_WARNING
"ipmi_si: duplicate interface\n");
2255 /* So we know not to free it unless we have allocated one. */
2256 new_smi
->intf
= NULL
;
2257 new_smi
->si_sm
= NULL
;
2258 new_smi
->handlers
= NULL
;
2260 switch (new_smi
->si_type
) {
2262 new_smi
->handlers
= &kcs_smi_handlers
;
2266 new_smi
->handlers
= &smic_smi_handlers
;
2270 new_smi
->handlers
= &bt_smi_handlers
;
2274 /* No support for anything else yet. */
2279 /* Allocate the state machine's data and initialize it. */
2280 new_smi
->si_sm
= kmalloc(new_smi
->handlers
->size(), GFP_KERNEL
);
2281 if (!new_smi
->si_sm
) {
2282 printk(" Could not allocate state machine memory\n");
2286 new_smi
->io_size
= new_smi
->handlers
->init_data(new_smi
->si_sm
,
2289 /* Now that we know the I/O size, we can set up the I/O. */
2290 rv
= new_smi
->io_setup(new_smi
);
2292 printk(" Could not set up I/O space\n");
2296 spin_lock_init(&(new_smi
->si_lock
));
2297 spin_lock_init(&(new_smi
->msg_lock
));
2298 spin_lock_init(&(new_smi
->count_lock
));
2300 /* Do low-level detection first. */
2301 if (new_smi
->handlers
->detect(new_smi
->si_sm
)) {
2302 if (new_smi
->addr_source
)
2303 printk(KERN_INFO
"ipmi_si: Interface detection"
2309 /* Attempt a get device id command. If it fails, we probably
2310 don't have a BMC here. */
2311 rv
= try_get_dev_id(new_smi
);
2313 if (new_smi
->addr_source
)
2314 printk(KERN_INFO
"ipmi_si: There appears to be no BMC"
2315 " at this location\n");
2319 setup_oem_data_handler(new_smi
);
2320 setup_xaction_handlers(new_smi
);
2322 /* Try to claim any interrupts. */
2323 if (new_smi
->irq_setup
)
2324 new_smi
->irq_setup(new_smi
);
2326 INIT_LIST_HEAD(&(new_smi
->xmit_msgs
));
2327 INIT_LIST_HEAD(&(new_smi
->hp_xmit_msgs
));
2328 new_smi
->curr_msg
= NULL
;
2329 atomic_set(&new_smi
->req_events
, 0);
2330 new_smi
->run_to_completion
= 0;
2332 new_smi
->interrupt_disabled
= 0;
2333 atomic_set(&new_smi
->stop_operation
, 0);
2334 new_smi
->intf_num
= smi_num
;
2337 /* Start clearing the flags before we enable interrupts or the
2338 timer to avoid racing with the timer. */
2339 start_clear_flags(new_smi
);
2340 /* IRQ is defined to be set when non-zero. */
2342 new_smi
->si_state
= SI_CLEARING_FLAGS_THEN_SET_IRQ
;
2344 if (!new_smi
->dev
) {
2345 /* If we don't already have a device from something
2346 * else (like PCI), then register a new one. */
2347 new_smi
->pdev
= platform_device_alloc("ipmi_si",
2352 " Unable to allocate platform device\n");
2355 new_smi
->dev
= &new_smi
->pdev
->dev
;
2356 new_smi
->dev
->driver
= &ipmi_driver
;
2358 rv
= platform_device_add(new_smi
->pdev
);
2362 " Unable to register system interface device:"
2367 new_smi
->dev_registered
= 1;
2370 rv
= ipmi_register_smi(&handlers
,
2372 &new_smi
->device_id
,
2375 new_smi
->slave_addr
);
2378 "ipmi_si: Unable to register device: error %d\n",
2380 goto out_err_stop_timer
;
2383 rv
= ipmi_smi_add_proc_entry(new_smi
->intf
, "type",
2384 type_file_read_proc
, NULL
,
2385 new_smi
, THIS_MODULE
);
2388 "ipmi_si: Unable to create proc entry: %d\n",
2390 goto out_err_stop_timer
;
2393 rv
= ipmi_smi_add_proc_entry(new_smi
->intf
, "si_stats",
2394 stat_file_read_proc
, NULL
,
2395 new_smi
, THIS_MODULE
);
2398 "ipmi_si: Unable to create proc entry: %d\n",
2400 goto out_err_stop_timer
;
2403 list_add_tail(&new_smi
->link
, &smi_infos
);
2405 mutex_unlock(&smi_infos_lock
);
2407 printk(" IPMI %s interface initialized\n",si_to_str
[new_smi
->si_type
]);
2412 atomic_inc(&new_smi
->stop_operation
);
2413 wait_for_timer_and_thread(new_smi
);
2417 ipmi_unregister_smi(new_smi
->intf
);
2419 if (new_smi
->irq_cleanup
)
2420 new_smi
->irq_cleanup(new_smi
);
2422 /* Wait until we know that we are out of any interrupt
2423 handlers might have been running before we freed the
2425 synchronize_sched();
2427 if (new_smi
->si_sm
) {
2428 if (new_smi
->handlers
)
2429 new_smi
->handlers
->cleanup(new_smi
->si_sm
);
2430 kfree(new_smi
->si_sm
);
2432 if (new_smi
->addr_source_cleanup
)
2433 new_smi
->addr_source_cleanup(new_smi
);
2434 if (new_smi
->io_cleanup
)
2435 new_smi
->io_cleanup(new_smi
);
2437 if (new_smi
->dev_registered
)
2438 platform_device_unregister(new_smi
->pdev
);
2442 mutex_unlock(&smi_infos_lock
);
2447 static __devinit
int init_ipmi_si(void)
2457 /* Register the device drivers. */
2458 rv
= driver_register(&ipmi_driver
);
2461 "init_ipmi_si: Unable to register driver: %d\n",
2467 /* Parse out the si_type string into its components. */
2470 for (i
= 0; (i
< SI_MAX_PARMS
) && (*str
!= '\0'); i
++) {
2472 str
= strchr(str
, ',');
2482 printk(KERN_INFO
"IPMI System Interface driver.\n");
2484 hardcode_find_bmc();
2496 pci_module_init(&ipmi_pci_driver
);
2499 if (si_trydefaults
) {
2500 mutex_lock(&smi_infos_lock
);
2501 if (list_empty(&smi_infos
)) {
2502 /* No BMC was found, try defaults. */
2503 mutex_unlock(&smi_infos_lock
);
2506 mutex_unlock(&smi_infos_lock
);
2510 mutex_lock(&smi_infos_lock
);
2511 if (list_empty(&smi_infos
)) {
2512 mutex_unlock(&smi_infos_lock
);
2514 pci_unregister_driver(&ipmi_pci_driver
);
2516 driver_unregister(&ipmi_driver
);
2517 printk("ipmi_si: Unable to find any System Interface(s)\n");
2520 mutex_unlock(&smi_infos_lock
);
2524 module_init(init_ipmi_si
);
2526 static void __devexit
cleanup_one_si(struct smi_info
*to_clean
)
2529 unsigned long flags
;
2534 list_del(&to_clean
->link
);
2536 /* Tell the timer and interrupt handlers that we are shutting
2538 spin_lock_irqsave(&(to_clean
->si_lock
), flags
);
2539 spin_lock(&(to_clean
->msg_lock
));
2541 atomic_inc(&to_clean
->stop_operation
);
2543 if (to_clean
->irq_cleanup
)
2544 to_clean
->irq_cleanup(to_clean
);
2546 spin_unlock(&(to_clean
->msg_lock
));
2547 spin_unlock_irqrestore(&(to_clean
->si_lock
), flags
);
2549 /* Wait until we know that we are out of any interrupt
2550 handlers might have been running before we freed the
2552 synchronize_sched();
2554 wait_for_timer_and_thread(to_clean
);
2556 /* Interrupts and timeouts are stopped, now make sure the
2557 interface is in a clean state. */
2558 while (to_clean
->curr_msg
|| (to_clean
->si_state
!= SI_NORMAL
)) {
2560 schedule_timeout_uninterruptible(1);
2563 rv
= ipmi_unregister_smi(to_clean
->intf
);
2566 "ipmi_si: Unable to unregister device: errno=%d\n",
2570 to_clean
->handlers
->cleanup(to_clean
->si_sm
);
2572 kfree(to_clean
->si_sm
);
2574 if (to_clean
->addr_source_cleanup
)
2575 to_clean
->addr_source_cleanup(to_clean
);
2576 if (to_clean
->io_cleanup
)
2577 to_clean
->io_cleanup(to_clean
);
2579 if (to_clean
->dev_registered
)
2580 platform_device_unregister(to_clean
->pdev
);
2585 static __exit
void cleanup_ipmi_si(void)
2587 struct smi_info
*e
, *tmp_e
;
2593 pci_unregister_driver(&ipmi_pci_driver
);
2596 mutex_lock(&smi_infos_lock
);
2597 list_for_each_entry_safe(e
, tmp_e
, &smi_infos
, link
)
2599 mutex_unlock(&smi_infos_lock
);
2601 driver_unregister(&ipmi_driver
);
2603 module_exit(cleanup_ipmi_si
);
2605 MODULE_LICENSE("GPL");
2606 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2607 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");