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 static int try_smi_init(struct smi_info
*smi
);
222 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list
);
223 static int register_xaction_notifier(struct notifier_block
* nb
)
225 return atomic_notifier_chain_register(&xaction_notifier_list
, nb
);
228 static void deliver_recv_msg(struct smi_info
*smi_info
,
229 struct ipmi_smi_msg
*msg
)
231 /* Deliver the message to the upper layer with the lock
233 spin_unlock(&(smi_info
->si_lock
));
234 ipmi_smi_msg_received(smi_info
->intf
, msg
);
235 spin_lock(&(smi_info
->si_lock
));
238 static void return_hosed_msg(struct smi_info
*smi_info
)
240 struct ipmi_smi_msg
*msg
= smi_info
->curr_msg
;
242 /* Make it a reponse */
243 msg
->rsp
[0] = msg
->data
[0] | 4;
244 msg
->rsp
[1] = msg
->data
[1];
245 msg
->rsp
[2] = 0xFF; /* Unknown error. */
248 smi_info
->curr_msg
= NULL
;
249 deliver_recv_msg(smi_info
, msg
);
252 static enum si_sm_result
start_next_msg(struct smi_info
*smi_info
)
255 struct list_head
*entry
= NULL
;
260 /* No need to save flags, we aleady have interrupts off and we
261 already hold the SMI lock. */
262 spin_lock(&(smi_info
->msg_lock
));
264 /* Pick the high priority queue first. */
265 if (!list_empty(&(smi_info
->hp_xmit_msgs
))) {
266 entry
= smi_info
->hp_xmit_msgs
.next
;
267 } else if (!list_empty(&(smi_info
->xmit_msgs
))) {
268 entry
= smi_info
->xmit_msgs
.next
;
272 smi_info
->curr_msg
= NULL
;
278 smi_info
->curr_msg
= list_entry(entry
,
283 printk("**Start2: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
285 err
= atomic_notifier_call_chain(&xaction_notifier_list
,
287 if (err
& NOTIFY_STOP_MASK
) {
288 rv
= SI_SM_CALL_WITHOUT_DELAY
;
291 err
= smi_info
->handlers
->start_transaction(
293 smi_info
->curr_msg
->data
,
294 smi_info
->curr_msg
->data_size
);
296 return_hosed_msg(smi_info
);
299 rv
= SI_SM_CALL_WITHOUT_DELAY
;
302 spin_unlock(&(smi_info
->msg_lock
));
307 static void start_enable_irq(struct smi_info
*smi_info
)
309 unsigned char msg
[2];
311 /* If we are enabling interrupts, we have to tell the
313 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
314 msg
[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD
;
316 smi_info
->handlers
->start_transaction(smi_info
->si_sm
, msg
, 2);
317 smi_info
->si_state
= SI_ENABLE_INTERRUPTS1
;
320 static void start_clear_flags(struct smi_info
*smi_info
)
322 unsigned char msg
[3];
324 /* Make sure the watchdog pre-timeout flag is not set at startup. */
325 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
326 msg
[1] = IPMI_CLEAR_MSG_FLAGS_CMD
;
327 msg
[2] = WDT_PRE_TIMEOUT_INT
;
329 smi_info
->handlers
->start_transaction(smi_info
->si_sm
, msg
, 3);
330 smi_info
->si_state
= SI_CLEARING_FLAGS
;
333 /* When we have a situtaion where we run out of memory and cannot
334 allocate messages, we just leave them in the BMC and run the system
335 polled until we can allocate some memory. Once we have some
336 memory, we will re-enable the interrupt. */
337 static inline void disable_si_irq(struct smi_info
*smi_info
)
339 if ((smi_info
->irq
) && (!smi_info
->interrupt_disabled
)) {
340 disable_irq_nosync(smi_info
->irq
);
341 smi_info
->interrupt_disabled
= 1;
345 static inline void enable_si_irq(struct smi_info
*smi_info
)
347 if ((smi_info
->irq
) && (smi_info
->interrupt_disabled
)) {
348 enable_irq(smi_info
->irq
);
349 smi_info
->interrupt_disabled
= 0;
353 static void handle_flags(struct smi_info
*smi_info
)
356 if (smi_info
->msg_flags
& WDT_PRE_TIMEOUT_INT
) {
357 /* Watchdog pre-timeout */
358 spin_lock(&smi_info
->count_lock
);
359 smi_info
->watchdog_pretimeouts
++;
360 spin_unlock(&smi_info
->count_lock
);
362 start_clear_flags(smi_info
);
363 smi_info
->msg_flags
&= ~WDT_PRE_TIMEOUT_INT
;
364 spin_unlock(&(smi_info
->si_lock
));
365 ipmi_smi_watchdog_pretimeout(smi_info
->intf
);
366 spin_lock(&(smi_info
->si_lock
));
367 } else if (smi_info
->msg_flags
& RECEIVE_MSG_AVAIL
) {
368 /* Messages available. */
369 smi_info
->curr_msg
= ipmi_alloc_smi_msg();
370 if (!smi_info
->curr_msg
) {
371 disable_si_irq(smi_info
);
372 smi_info
->si_state
= SI_NORMAL
;
375 enable_si_irq(smi_info
);
377 smi_info
->curr_msg
->data
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
378 smi_info
->curr_msg
->data
[1] = IPMI_GET_MSG_CMD
;
379 smi_info
->curr_msg
->data_size
= 2;
381 smi_info
->handlers
->start_transaction(
383 smi_info
->curr_msg
->data
,
384 smi_info
->curr_msg
->data_size
);
385 smi_info
->si_state
= SI_GETTING_MESSAGES
;
386 } else if (smi_info
->msg_flags
& EVENT_MSG_BUFFER_FULL
) {
387 /* Events available. */
388 smi_info
->curr_msg
= ipmi_alloc_smi_msg();
389 if (!smi_info
->curr_msg
) {
390 disable_si_irq(smi_info
);
391 smi_info
->si_state
= SI_NORMAL
;
394 enable_si_irq(smi_info
);
396 smi_info
->curr_msg
->data
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
397 smi_info
->curr_msg
->data
[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD
;
398 smi_info
->curr_msg
->data_size
= 2;
400 smi_info
->handlers
->start_transaction(
402 smi_info
->curr_msg
->data
,
403 smi_info
->curr_msg
->data_size
);
404 smi_info
->si_state
= SI_GETTING_EVENTS
;
405 } else if (smi_info
->msg_flags
& OEM_DATA_AVAIL
&&
406 smi_info
->oem_data_avail_handler
) {
407 if (smi_info
->oem_data_avail_handler(smi_info
))
410 smi_info
->si_state
= SI_NORMAL
;
414 static void handle_transaction_done(struct smi_info
*smi_info
)
416 struct ipmi_smi_msg
*msg
;
421 printk("**Done: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
423 switch (smi_info
->si_state
) {
425 if (!smi_info
->curr_msg
)
428 smi_info
->curr_msg
->rsp_size
429 = smi_info
->handlers
->get_result(
431 smi_info
->curr_msg
->rsp
,
432 IPMI_MAX_MSG_LENGTH
);
434 /* Do this here becase deliver_recv_msg() releases the
435 lock, and a new message can be put in during the
436 time the lock is released. */
437 msg
= smi_info
->curr_msg
;
438 smi_info
->curr_msg
= NULL
;
439 deliver_recv_msg(smi_info
, msg
);
442 case SI_GETTING_FLAGS
:
444 unsigned char msg
[4];
447 /* We got the flags from the SMI, now handle them. */
448 len
= smi_info
->handlers
->get_result(smi_info
->si_sm
, msg
, 4);
450 /* Error fetching flags, just give up for
452 smi_info
->si_state
= SI_NORMAL
;
453 } else if (len
< 4) {
454 /* Hmm, no flags. That's technically illegal, but
455 don't use uninitialized data. */
456 smi_info
->si_state
= SI_NORMAL
;
458 smi_info
->msg_flags
= msg
[3];
459 handle_flags(smi_info
);
464 case SI_CLEARING_FLAGS
:
465 case SI_CLEARING_FLAGS_THEN_SET_IRQ
:
467 unsigned char msg
[3];
469 /* We cleared the flags. */
470 smi_info
->handlers
->get_result(smi_info
->si_sm
, msg
, 3);
472 /* Error clearing flags */
474 "ipmi_si: Error clearing flags: %2.2x\n",
477 if (smi_info
->si_state
== SI_CLEARING_FLAGS_THEN_SET_IRQ
)
478 start_enable_irq(smi_info
);
480 smi_info
->si_state
= SI_NORMAL
;
484 case SI_GETTING_EVENTS
:
486 smi_info
->curr_msg
->rsp_size
487 = smi_info
->handlers
->get_result(
489 smi_info
->curr_msg
->rsp
,
490 IPMI_MAX_MSG_LENGTH
);
492 /* Do this here becase deliver_recv_msg() releases the
493 lock, and a new message can be put in during the
494 time the lock is released. */
495 msg
= smi_info
->curr_msg
;
496 smi_info
->curr_msg
= NULL
;
497 if (msg
->rsp
[2] != 0) {
498 /* Error getting event, probably done. */
501 /* Take off the event flag. */
502 smi_info
->msg_flags
&= ~EVENT_MSG_BUFFER_FULL
;
503 handle_flags(smi_info
);
505 spin_lock(&smi_info
->count_lock
);
507 spin_unlock(&smi_info
->count_lock
);
509 /* Do this before we deliver the message
510 because delivering the message releases the
511 lock and something else can mess with the
513 handle_flags(smi_info
);
515 deliver_recv_msg(smi_info
, msg
);
520 case SI_GETTING_MESSAGES
:
522 smi_info
->curr_msg
->rsp_size
523 = smi_info
->handlers
->get_result(
525 smi_info
->curr_msg
->rsp
,
526 IPMI_MAX_MSG_LENGTH
);
528 /* Do this here becase deliver_recv_msg() releases the
529 lock, and a new message can be put in during the
530 time the lock is released. */
531 msg
= smi_info
->curr_msg
;
532 smi_info
->curr_msg
= NULL
;
533 if (msg
->rsp
[2] != 0) {
534 /* Error getting event, probably done. */
537 /* Take off the msg flag. */
538 smi_info
->msg_flags
&= ~RECEIVE_MSG_AVAIL
;
539 handle_flags(smi_info
);
541 spin_lock(&smi_info
->count_lock
);
542 smi_info
->incoming_messages
++;
543 spin_unlock(&smi_info
->count_lock
);
545 /* Do this before we deliver the message
546 because delivering the message releases the
547 lock and something else can mess with the
549 handle_flags(smi_info
);
551 deliver_recv_msg(smi_info
, msg
);
556 case SI_ENABLE_INTERRUPTS1
:
558 unsigned char msg
[4];
560 /* We got the flags from the SMI, now handle them. */
561 smi_info
->handlers
->get_result(smi_info
->si_sm
, msg
, 4);
564 "ipmi_si: Could not enable interrupts"
565 ", failed get, using polled mode.\n");
566 smi_info
->si_state
= SI_NORMAL
;
568 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
569 msg
[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD
;
570 msg
[2] = msg
[3] | 1; /* enable msg queue int */
571 smi_info
->handlers
->start_transaction(
572 smi_info
->si_sm
, msg
, 3);
573 smi_info
->si_state
= SI_ENABLE_INTERRUPTS2
;
578 case SI_ENABLE_INTERRUPTS2
:
580 unsigned char msg
[4];
582 /* We got the flags from the SMI, now handle them. */
583 smi_info
->handlers
->get_result(smi_info
->si_sm
, msg
, 4);
586 "ipmi_si: Could not enable interrupts"
587 ", failed set, using polled mode.\n");
589 smi_info
->si_state
= SI_NORMAL
;
595 /* Called on timeouts and events. Timeouts should pass the elapsed
596 time, interrupts should pass in zero. */
597 static enum si_sm_result
smi_event_handler(struct smi_info
*smi_info
,
600 enum si_sm_result si_sm_result
;
603 /* There used to be a loop here that waited a little while
604 (around 25us) before giving up. That turned out to be
605 pointless, the minimum delays I was seeing were in the 300us
606 range, which is far too long to wait in an interrupt. So
607 we just run until the state machine tells us something
608 happened or it needs a delay. */
609 si_sm_result
= smi_info
->handlers
->event(smi_info
->si_sm
, time
);
611 while (si_sm_result
== SI_SM_CALL_WITHOUT_DELAY
)
613 si_sm_result
= smi_info
->handlers
->event(smi_info
->si_sm
, 0);
616 if (si_sm_result
== SI_SM_TRANSACTION_COMPLETE
)
618 spin_lock(&smi_info
->count_lock
);
619 smi_info
->complete_transactions
++;
620 spin_unlock(&smi_info
->count_lock
);
622 handle_transaction_done(smi_info
);
623 si_sm_result
= smi_info
->handlers
->event(smi_info
->si_sm
, 0);
625 else if (si_sm_result
== SI_SM_HOSED
)
627 spin_lock(&smi_info
->count_lock
);
628 smi_info
->hosed_count
++;
629 spin_unlock(&smi_info
->count_lock
);
631 /* Do the before return_hosed_msg, because that
632 releases the lock. */
633 smi_info
->si_state
= SI_NORMAL
;
634 if (smi_info
->curr_msg
!= NULL
) {
635 /* If we were handling a user message, format
636 a response to send to the upper layer to
637 tell it about the error. */
638 return_hosed_msg(smi_info
);
640 si_sm_result
= smi_info
->handlers
->event(smi_info
->si_sm
, 0);
643 /* We prefer handling attn over new messages. */
644 if (si_sm_result
== SI_SM_ATTN
)
646 unsigned char msg
[2];
648 spin_lock(&smi_info
->count_lock
);
649 smi_info
->attentions
++;
650 spin_unlock(&smi_info
->count_lock
);
652 /* Got a attn, send down a get message flags to see
653 what's causing it. It would be better to handle
654 this in the upper layer, but due to the way
655 interrupts work with the SMI, that's not really
657 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
658 msg
[1] = IPMI_GET_MSG_FLAGS_CMD
;
660 smi_info
->handlers
->start_transaction(
661 smi_info
->si_sm
, msg
, 2);
662 smi_info
->si_state
= SI_GETTING_FLAGS
;
666 /* If we are currently idle, try to start the next message. */
667 if (si_sm_result
== SI_SM_IDLE
) {
668 spin_lock(&smi_info
->count_lock
);
670 spin_unlock(&smi_info
->count_lock
);
672 si_sm_result
= start_next_msg(smi_info
);
673 if (si_sm_result
!= SI_SM_IDLE
)
677 if ((si_sm_result
== SI_SM_IDLE
)
678 && (atomic_read(&smi_info
->req_events
)))
680 /* We are idle and the upper layer requested that I fetch
682 unsigned char msg
[2];
684 spin_lock(&smi_info
->count_lock
);
685 smi_info
->flag_fetches
++;
686 spin_unlock(&smi_info
->count_lock
);
688 atomic_set(&smi_info
->req_events
, 0);
689 msg
[0] = (IPMI_NETFN_APP_REQUEST
<< 2);
690 msg
[1] = IPMI_GET_MSG_FLAGS_CMD
;
692 smi_info
->handlers
->start_transaction(
693 smi_info
->si_sm
, msg
, 2);
694 smi_info
->si_state
= SI_GETTING_FLAGS
;
701 static void sender(void *send_info
,
702 struct ipmi_smi_msg
*msg
,
705 struct smi_info
*smi_info
= send_info
;
706 enum si_sm_result result
;
712 spin_lock_irqsave(&(smi_info
->msg_lock
), flags
);
715 printk("**Enqueue: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
718 if (smi_info
->run_to_completion
) {
719 /* If we are running to completion, then throw it in
720 the list and run transactions until everything is
721 clear. Priority doesn't matter here. */
722 list_add_tail(&(msg
->link
), &(smi_info
->xmit_msgs
));
724 /* We have to release the msg lock and claim the smi
725 lock in this case, because of race conditions. */
726 spin_unlock_irqrestore(&(smi_info
->msg_lock
), flags
);
728 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
729 result
= smi_event_handler(smi_info
, 0);
730 while (result
!= SI_SM_IDLE
) {
731 udelay(SI_SHORT_TIMEOUT_USEC
);
732 result
= smi_event_handler(smi_info
,
733 SI_SHORT_TIMEOUT_USEC
);
735 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
739 list_add_tail(&(msg
->link
), &(smi_info
->hp_xmit_msgs
));
741 list_add_tail(&(msg
->link
), &(smi_info
->xmit_msgs
));
744 spin_unlock_irqrestore(&(smi_info
->msg_lock
), flags
);
746 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
747 if ((smi_info
->si_state
== SI_NORMAL
)
748 && (smi_info
->curr_msg
== NULL
))
750 start_next_msg(smi_info
);
752 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
755 static void set_run_to_completion(void *send_info
, int i_run_to_completion
)
757 struct smi_info
*smi_info
= send_info
;
758 enum si_sm_result result
;
761 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
763 smi_info
->run_to_completion
= i_run_to_completion
;
764 if (i_run_to_completion
) {
765 result
= smi_event_handler(smi_info
, 0);
766 while (result
!= SI_SM_IDLE
) {
767 udelay(SI_SHORT_TIMEOUT_USEC
);
768 result
= smi_event_handler(smi_info
,
769 SI_SHORT_TIMEOUT_USEC
);
773 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
776 static int ipmi_thread(void *data
)
778 struct smi_info
*smi_info
= data
;
780 enum si_sm_result smi_result
;
782 set_user_nice(current
, 19);
783 while (!kthread_should_stop()) {
784 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
785 smi_result
= smi_event_handler(smi_info
, 0);
786 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
787 if (smi_result
== SI_SM_CALL_WITHOUT_DELAY
) {
790 else if (smi_result
== SI_SM_CALL_WITH_DELAY
)
793 schedule_timeout_interruptible(1);
799 static void poll(void *send_info
)
801 struct smi_info
*smi_info
= send_info
;
803 smi_event_handler(smi_info
, 0);
806 static void request_events(void *send_info
)
808 struct smi_info
*smi_info
= send_info
;
810 atomic_set(&smi_info
->req_events
, 1);
813 static int initialized
= 0;
815 static void smi_timeout(unsigned long data
)
817 struct smi_info
*smi_info
= (struct smi_info
*) data
;
818 enum si_sm_result smi_result
;
820 unsigned long jiffies_now
;
826 if (atomic_read(&smi_info
->stop_operation
))
829 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
832 printk("**Timer: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
834 jiffies_now
= jiffies
;
835 time_diff
= (((long)jiffies_now
- (long)smi_info
->last_timeout_jiffies
)
836 * SI_USEC_PER_JIFFY
);
837 smi_result
= smi_event_handler(smi_info
, time_diff
);
839 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
841 smi_info
->last_timeout_jiffies
= jiffies_now
;
843 if ((smi_info
->irq
) && (!smi_info
->interrupt_disabled
)) {
844 /* Running with interrupts, only do long timeouts. */
845 smi_info
->si_timer
.expires
= jiffies
+ SI_TIMEOUT_JIFFIES
;
846 spin_lock_irqsave(&smi_info
->count_lock
, flags
);
847 smi_info
->long_timeouts
++;
848 spin_unlock_irqrestore(&smi_info
->count_lock
, flags
);
852 /* If the state machine asks for a short delay, then shorten
853 the timer timeout. */
854 if (smi_result
== SI_SM_CALL_WITH_DELAY
) {
855 spin_lock_irqsave(&smi_info
->count_lock
, flags
);
856 smi_info
->short_timeouts
++;
857 spin_unlock_irqrestore(&smi_info
->count_lock
, flags
);
858 smi_info
->si_timer
.expires
= jiffies
+ 1;
860 spin_lock_irqsave(&smi_info
->count_lock
, flags
);
861 smi_info
->long_timeouts
++;
862 spin_unlock_irqrestore(&smi_info
->count_lock
, flags
);
863 smi_info
->si_timer
.expires
= jiffies
+ SI_TIMEOUT_JIFFIES
;
867 add_timer(&(smi_info
->si_timer
));
870 static irqreturn_t
si_irq_handler(int irq
, void *data
, struct pt_regs
*regs
)
872 struct smi_info
*smi_info
= data
;
878 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
880 spin_lock(&smi_info
->count_lock
);
881 smi_info
->interrupts
++;
882 spin_unlock(&smi_info
->count_lock
);
884 if (atomic_read(&smi_info
->stop_operation
))
889 printk("**Interrupt: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
891 smi_event_handler(smi_info
, 0);
893 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
897 static irqreturn_t
si_bt_irq_handler(int irq
, void *data
, struct pt_regs
*regs
)
899 struct smi_info
*smi_info
= data
;
900 /* We need to clear the IRQ flag for the BT interface. */
901 smi_info
->io
.outputb(&smi_info
->io
, IPMI_BT_INTMASK_REG
,
902 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
903 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT
);
904 return si_irq_handler(irq
, data
, regs
);
907 static int smi_start_processing(void *send_info
,
910 struct smi_info
*new_smi
= send_info
;
912 new_smi
->intf
= intf
;
914 /* Set up the timer that drives the interface. */
915 setup_timer(&new_smi
->si_timer
, smi_timeout
, (long)new_smi
);
916 new_smi
->last_timeout_jiffies
= jiffies
;
917 mod_timer(&new_smi
->si_timer
, jiffies
+ SI_TIMEOUT_JIFFIES
);
920 * The BT interface is efficient enough to not need a thread,
921 * and there is no need for a thread if we have interrupts.
923 if ((new_smi
->si_type
!= SI_BT
) && (!new_smi
->irq
)) {
924 new_smi
->thread
= kthread_run(ipmi_thread
, new_smi
,
925 "kipmi%d", new_smi
->intf_num
);
926 if (IS_ERR(new_smi
->thread
)) {
927 printk(KERN_NOTICE
"ipmi_si_intf: Could not start"
928 " kernel thread due to error %ld, only using"
929 " timers to drive the interface\n",
930 PTR_ERR(new_smi
->thread
));
931 new_smi
->thread
= NULL
;
938 static struct ipmi_smi_handlers handlers
=
940 .owner
= THIS_MODULE
,
941 .start_processing
= smi_start_processing
,
943 .request_events
= request_events
,
944 .set_run_to_completion
= set_run_to_completion
,
948 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
949 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
951 #define SI_MAX_PARMS 4
952 static LIST_HEAD(smi_infos
);
953 static DEFINE_MUTEX(smi_infos_lock
);
954 static int smi_num
; /* Used to sequence the SMIs */
956 #define DEFAULT_REGSPACING 1
958 static int si_trydefaults
= 1;
959 static char *si_type
[SI_MAX_PARMS
];
960 #define MAX_SI_TYPE_STR 30
961 static char si_type_str
[MAX_SI_TYPE_STR
];
962 static unsigned long addrs
[SI_MAX_PARMS
];
963 static int num_addrs
;
964 static unsigned int ports
[SI_MAX_PARMS
];
965 static int num_ports
;
966 static int irqs
[SI_MAX_PARMS
];
968 static int regspacings
[SI_MAX_PARMS
];
969 static int num_regspacings
= 0;
970 static int regsizes
[SI_MAX_PARMS
];
971 static int num_regsizes
= 0;
972 static int regshifts
[SI_MAX_PARMS
];
973 static int num_regshifts
= 0;
974 static int slave_addrs
[SI_MAX_PARMS
];
975 static int num_slave_addrs
= 0;
978 module_param_named(trydefaults
, si_trydefaults
, bool, 0);
979 MODULE_PARM_DESC(trydefaults
, "Setting this to 'false' will disable the"
980 " default scan of the KCS and SMIC interface at the standard"
982 module_param_string(type
, si_type_str
, MAX_SI_TYPE_STR
, 0);
983 MODULE_PARM_DESC(type
, "Defines the type of each interface, each"
984 " interface separated by commas. The types are 'kcs',"
985 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
986 " the first interface to kcs and the second to bt");
987 module_param_array(addrs
, long, &num_addrs
, 0);
988 MODULE_PARM_DESC(addrs
, "Sets the memory address of each interface, the"
989 " addresses separated by commas. Only use if an interface"
990 " is in memory. Otherwise, set it to zero or leave"
992 module_param_array(ports
, int, &num_ports
, 0);
993 MODULE_PARM_DESC(ports
, "Sets the port address of each interface, the"
994 " addresses separated by commas. Only use if an interface"
995 " is a port. Otherwise, set it to zero or leave"
997 module_param_array(irqs
, int, &num_irqs
, 0);
998 MODULE_PARM_DESC(irqs
, "Sets the interrupt of each interface, the"
999 " addresses separated by commas. Only use if an interface"
1000 " has an interrupt. Otherwise, set it to zero or leave"
1002 module_param_array(regspacings
, int, &num_regspacings
, 0);
1003 MODULE_PARM_DESC(regspacings
, "The number of bytes between the start address"
1004 " and each successive register used by the interface. For"
1005 " instance, if the start address is 0xca2 and the spacing"
1006 " is 2, then the second address is at 0xca4. Defaults"
1008 module_param_array(regsizes
, int, &num_regsizes
, 0);
1009 MODULE_PARM_DESC(regsizes
, "The size of the specific IPMI register in bytes."
1010 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1011 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1012 " the 8-bit IPMI register has to be read from a larger"
1014 module_param_array(regshifts
, int, &num_regshifts
, 0);
1015 MODULE_PARM_DESC(regshifts
, "The amount to shift the data read from the."
1016 " IPMI register, in bits. For instance, if the data"
1017 " is read from a 32-bit word and the IPMI data is in"
1018 " bit 8-15, then the shift would be 8");
1019 module_param_array(slave_addrs
, int, &num_slave_addrs
, 0);
1020 MODULE_PARM_DESC(slave_addrs
, "Set the default IPMB slave address for"
1021 " the controller. Normally this is 0x20, but can be"
1022 " overridden by this parm. This is an array indexed"
1023 " by interface number.");
1026 #define IPMI_IO_ADDR_SPACE 0
1027 #define IPMI_MEM_ADDR_SPACE 1
1028 static char *addr_space_to_str
[] = { "I/O", "memory" };
1030 static void std_irq_cleanup(struct smi_info
*info
)
1032 if (info
->si_type
== SI_BT
)
1033 /* Disable the interrupt in the BT interface. */
1034 info
->io
.outputb(&info
->io
, IPMI_BT_INTMASK_REG
, 0);
1035 free_irq(info
->irq
, info
);
1038 static int std_irq_setup(struct smi_info
*info
)
1045 if (info
->si_type
== SI_BT
) {
1046 rv
= request_irq(info
->irq
,
1052 /* Enable the interrupt in the BT interface. */
1053 info
->io
.outputb(&info
->io
, IPMI_BT_INTMASK_REG
,
1054 IPMI_BT_INTMASK_ENABLE_IRQ_BIT
);
1056 rv
= request_irq(info
->irq
,
1063 "ipmi_si: %s unable to claim interrupt %d,"
1064 " running polled\n",
1065 DEVICE_NAME
, info
->irq
);
1068 info
->irq_cleanup
= std_irq_cleanup
;
1069 printk(" Using irq %d\n", info
->irq
);
1075 static unsigned char port_inb(struct si_sm_io
*io
, unsigned int offset
)
1077 unsigned int addr
= io
->addr_data
;
1079 return inb(addr
+ (offset
* io
->regspacing
));
1082 static void port_outb(struct si_sm_io
*io
, unsigned int offset
,
1085 unsigned int addr
= io
->addr_data
;
1087 outb(b
, addr
+ (offset
* io
->regspacing
));
1090 static unsigned char port_inw(struct si_sm_io
*io
, unsigned int offset
)
1092 unsigned int addr
= io
->addr_data
;
1094 return (inw(addr
+ (offset
* io
->regspacing
)) >> io
->regshift
) & 0xff;
1097 static void port_outw(struct si_sm_io
*io
, unsigned int offset
,
1100 unsigned int addr
= io
->addr_data
;
1102 outw(b
<< io
->regshift
, addr
+ (offset
* io
->regspacing
));
1105 static unsigned char port_inl(struct si_sm_io
*io
, unsigned int offset
)
1107 unsigned int addr
= io
->addr_data
;
1109 return (inl(addr
+ (offset
* io
->regspacing
)) >> io
->regshift
) & 0xff;
1112 static void port_outl(struct si_sm_io
*io
, unsigned int offset
,
1115 unsigned int addr
= io
->addr_data
;
1117 outl(b
<< io
->regshift
, addr
+(offset
* io
->regspacing
));
1120 static void port_cleanup(struct smi_info
*info
)
1122 unsigned int addr
= info
->io
.addr_data
;
1126 for (idx
= 0; idx
< info
->io_size
; idx
++) {
1127 release_region(addr
+ idx
* info
->io
.regspacing
,
1133 static int port_setup(struct smi_info
*info
)
1135 unsigned int addr
= info
->io
.addr_data
;
1141 info
->io_cleanup
= port_cleanup
;
1143 /* Figure out the actual inb/inw/inl/etc routine to use based
1144 upon the register size. */
1145 switch (info
->io
.regsize
) {
1147 info
->io
.inputb
= port_inb
;
1148 info
->io
.outputb
= port_outb
;
1151 info
->io
.inputb
= port_inw
;
1152 info
->io
.outputb
= port_outw
;
1155 info
->io
.inputb
= port_inl
;
1156 info
->io
.outputb
= port_outl
;
1159 printk("ipmi_si: Invalid register size: %d\n",
1164 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1165 * tables. This causes problems when trying to register the
1166 * entire I/O region. Therefore we must register each I/O
1169 for (idx
= 0; idx
< info
->io_size
; idx
++) {
1170 if (request_region(addr
+ idx
* info
->io
.regspacing
,
1171 info
->io
.regsize
, DEVICE_NAME
) == NULL
) {
1172 /* Undo allocations */
1174 release_region(addr
+ idx
* info
->io
.regspacing
,
1183 static unsigned char intf_mem_inb(struct si_sm_io
*io
, unsigned int offset
)
1185 return readb((io
->addr
)+(offset
* io
->regspacing
));
1188 static void intf_mem_outb(struct si_sm_io
*io
, unsigned int offset
,
1191 writeb(b
, (io
->addr
)+(offset
* io
->regspacing
));
1194 static unsigned char intf_mem_inw(struct si_sm_io
*io
, unsigned int offset
)
1196 return (readw((io
->addr
)+(offset
* io
->regspacing
)) >> io
->regshift
)
1200 static void intf_mem_outw(struct si_sm_io
*io
, unsigned int offset
,
1203 writeb(b
<< io
->regshift
, (io
->addr
)+(offset
* io
->regspacing
));
1206 static unsigned char intf_mem_inl(struct si_sm_io
*io
, unsigned int offset
)
1208 return (readl((io
->addr
)+(offset
* io
->regspacing
)) >> io
->regshift
)
1212 static void intf_mem_outl(struct si_sm_io
*io
, unsigned int offset
,
1215 writel(b
<< io
->regshift
, (io
->addr
)+(offset
* io
->regspacing
));
1219 static unsigned char mem_inq(struct si_sm_io
*io
, unsigned int offset
)
1221 return (readq((io
->addr
)+(offset
* io
->regspacing
)) >> io
->regshift
)
1225 static void mem_outq(struct si_sm_io
*io
, unsigned int offset
,
1228 writeq(b
<< io
->regshift
, (io
->addr
)+(offset
* io
->regspacing
));
1232 static void mem_cleanup(struct smi_info
*info
)
1234 unsigned long addr
= info
->io
.addr_data
;
1237 if (info
->io
.addr
) {
1238 iounmap(info
->io
.addr
);
1240 mapsize
= ((info
->io_size
* info
->io
.regspacing
)
1241 - (info
->io
.regspacing
- info
->io
.regsize
));
1243 release_mem_region(addr
, mapsize
);
1247 static int mem_setup(struct smi_info
*info
)
1249 unsigned long addr
= info
->io
.addr_data
;
1255 info
->io_cleanup
= mem_cleanup
;
1257 /* Figure out the actual readb/readw/readl/etc routine to use based
1258 upon the register size. */
1259 switch (info
->io
.regsize
) {
1261 info
->io
.inputb
= intf_mem_inb
;
1262 info
->io
.outputb
= intf_mem_outb
;
1265 info
->io
.inputb
= intf_mem_inw
;
1266 info
->io
.outputb
= intf_mem_outw
;
1269 info
->io
.inputb
= intf_mem_inl
;
1270 info
->io
.outputb
= intf_mem_outl
;
1274 info
->io
.inputb
= mem_inq
;
1275 info
->io
.outputb
= mem_outq
;
1279 printk("ipmi_si: Invalid register size: %d\n",
1284 /* Calculate the total amount of memory to claim. This is an
1285 * unusual looking calculation, but it avoids claiming any
1286 * more memory than it has to. It will claim everything
1287 * between the first address to the end of the last full
1289 mapsize
= ((info
->io_size
* info
->io
.regspacing
)
1290 - (info
->io
.regspacing
- info
->io
.regsize
));
1292 if (request_mem_region(addr
, mapsize
, DEVICE_NAME
) == NULL
)
1295 info
->io
.addr
= ioremap(addr
, mapsize
);
1296 if (info
->io
.addr
== NULL
) {
1297 release_mem_region(addr
, mapsize
);
1304 static __devinit
void hardcode_find_bmc(void)
1307 struct smi_info
*info
;
1309 for (i
= 0; i
< SI_MAX_PARMS
; i
++) {
1310 if (!ports
[i
] && !addrs
[i
])
1313 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1317 info
->addr_source
= "hardcoded";
1319 if (!si_type
[i
] || strcmp(si_type
[i
], "kcs") == 0) {
1320 info
->si_type
= SI_KCS
;
1321 } else if (strcmp(si_type
[i
], "smic") == 0) {
1322 info
->si_type
= SI_SMIC
;
1323 } else if (strcmp(si_type
[i
], "bt") == 0) {
1324 info
->si_type
= SI_BT
;
1327 "ipmi_si: Interface type specified "
1328 "for interface %d, was invalid: %s\n",
1336 info
->io_setup
= port_setup
;
1337 info
->io
.addr_data
= ports
[i
];
1338 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
1339 } else if (addrs
[i
]) {
1341 info
->io_setup
= mem_setup
;
1342 info
->io
.addr_data
= addrs
[i
];
1343 info
->io
.addr_type
= IPMI_MEM_ADDR_SPACE
;
1346 "ipmi_si: Interface type specified "
1347 "for interface %d, "
1348 "but port and address were not set or "
1349 "set to zero.\n", i
);
1354 info
->io
.addr
= NULL
;
1355 info
->io
.regspacing
= regspacings
[i
];
1356 if (!info
->io
.regspacing
)
1357 info
->io
.regspacing
= DEFAULT_REGSPACING
;
1358 info
->io
.regsize
= regsizes
[i
];
1359 if (!info
->io
.regsize
)
1360 info
->io
.regsize
= DEFAULT_REGSPACING
;
1361 info
->io
.regshift
= regshifts
[i
];
1362 info
->irq
= irqs
[i
];
1364 info
->irq_setup
= std_irq_setup
;
1372 #include <linux/acpi.h>
1374 /* Once we get an ACPI failure, we don't try any more, because we go
1375 through the tables sequentially. Once we don't find a table, there
1377 static int acpi_failure
= 0;
1379 /* For GPE-type interrupts. */
1380 static u32
ipmi_acpi_gpe(void *context
)
1382 struct smi_info
*smi_info
= context
;
1383 unsigned long flags
;
1388 spin_lock_irqsave(&(smi_info
->si_lock
), flags
);
1390 spin_lock(&smi_info
->count_lock
);
1391 smi_info
->interrupts
++;
1392 spin_unlock(&smi_info
->count_lock
);
1394 if (atomic_read(&smi_info
->stop_operation
))
1398 do_gettimeofday(&t
);
1399 printk("**ACPI_GPE: %d.%9.9d\n", t
.tv_sec
, t
.tv_usec
);
1401 smi_event_handler(smi_info
, 0);
1403 spin_unlock_irqrestore(&(smi_info
->si_lock
), flags
);
1405 return ACPI_INTERRUPT_HANDLED
;
1408 static void acpi_gpe_irq_cleanup(struct smi_info
*info
)
1413 acpi_remove_gpe_handler(NULL
, info
->irq
, &ipmi_acpi_gpe
);
1416 static int acpi_gpe_irq_setup(struct smi_info
*info
)
1423 /* FIXME - is level triggered right? */
1424 status
= acpi_install_gpe_handler(NULL
,
1426 ACPI_GPE_LEVEL_TRIGGERED
,
1429 if (status
!= AE_OK
) {
1431 "ipmi_si: %s unable to claim ACPI GPE %d,"
1432 " running polled\n",
1433 DEVICE_NAME
, info
->irq
);
1437 info
->irq_cleanup
= acpi_gpe_irq_cleanup
;
1438 printk(" Using ACPI GPE %d\n", info
->irq
);
1445 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1456 s8 CreatorRevision
[4];
1459 s16 SpecificationRevision
;
1462 * Bit 0 - SCI interrupt supported
1463 * Bit 1 - I/O APIC/SAPIC
1467 /* If bit 0 of InterruptType is set, then this is the SCI
1468 interrupt in the GPEx_STS register. */
1473 /* If bit 1 of InterruptType is set, then this is the I/O
1474 APIC/SAPIC interrupt. */
1475 u32 GlobalSystemInterrupt
;
1477 /* The actual register address. */
1478 struct acpi_generic_address addr
;
1482 s8 spmi_id
[1]; /* A '\0' terminated array starts here. */
1485 static __devinit
int try_init_acpi(struct SPMITable
*spmi
)
1487 struct smi_info
*info
;
1491 if (spmi
->IPMIlegacy
!= 1) {
1492 printk(KERN_INFO
"IPMI: Bad SPMI legacy %d\n", spmi
->IPMIlegacy
);
1496 if (spmi
->addr
.address_space_id
== ACPI_ADR_SPACE_SYSTEM_MEMORY
)
1497 addr_space
= IPMI_MEM_ADDR_SPACE
;
1499 addr_space
= IPMI_IO_ADDR_SPACE
;
1501 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1503 printk(KERN_ERR
"ipmi_si: Could not allocate SI data (3)\n");
1507 info
->addr_source
= "ACPI";
1509 /* Figure out the interface type. */
1510 switch (spmi
->InterfaceType
)
1513 info
->si_type
= SI_KCS
;
1516 info
->si_type
= SI_SMIC
;
1519 info
->si_type
= SI_BT
;
1522 printk(KERN_INFO
"ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1523 spmi
->InterfaceType
);
1528 if (spmi
->InterruptType
& 1) {
1529 /* We've got a GPE interrupt. */
1530 info
->irq
= spmi
->GPE
;
1531 info
->irq_setup
= acpi_gpe_irq_setup
;
1532 } else if (spmi
->InterruptType
& 2) {
1533 /* We've got an APIC/SAPIC interrupt. */
1534 info
->irq
= spmi
->GlobalSystemInterrupt
;
1535 info
->irq_setup
= std_irq_setup
;
1537 /* Use the default interrupt setting. */
1539 info
->irq_setup
= NULL
;
1542 if (spmi
->addr
.register_bit_width
) {
1543 /* A (hopefully) properly formed register bit width. */
1544 info
->io
.regspacing
= spmi
->addr
.register_bit_width
/ 8;
1546 info
->io
.regspacing
= DEFAULT_REGSPACING
;
1548 info
->io
.regsize
= info
->io
.regspacing
;
1549 info
->io
.regshift
= spmi
->addr
.register_bit_offset
;
1551 if (spmi
->addr
.address_space_id
== ACPI_ADR_SPACE_SYSTEM_MEMORY
) {
1553 info
->io_setup
= mem_setup
;
1554 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
1555 } else if (spmi
->addr
.address_space_id
== ACPI_ADR_SPACE_SYSTEM_IO
) {
1557 info
->io_setup
= port_setup
;
1558 info
->io
.addr_type
= IPMI_MEM_ADDR_SPACE
;
1561 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1564 info
->io
.addr_data
= spmi
->addr
.address
;
1571 static __devinit
void acpi_find_bmc(void)
1574 struct SPMITable
*spmi
;
1583 for (i
= 0; ; i
++) {
1584 status
= acpi_get_firmware_table("SPMI", i
+1,
1585 ACPI_LOGICAL_ADDRESSING
,
1586 (struct acpi_table_header
**)
1588 if (status
!= AE_OK
)
1591 try_init_acpi(spmi
);
1597 struct dmi_ipmi_data
1601 unsigned long base_addr
;
1607 static int __devinit
decode_dmi(struct dmi_header
*dm
,
1608 struct dmi_ipmi_data
*dmi
)
1610 u8
*data
= (u8
*)dm
;
1611 unsigned long base_addr
;
1613 u8 len
= dm
->length
;
1615 dmi
->type
= data
[4];
1617 memcpy(&base_addr
, data
+8, sizeof(unsigned long));
1619 if (base_addr
& 1) {
1621 base_addr
&= 0xFFFE;
1622 dmi
->addr_space
= IPMI_IO_ADDR_SPACE
;
1626 dmi
->addr_space
= IPMI_MEM_ADDR_SPACE
;
1628 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1630 dmi
->base_addr
= base_addr
| ((data
[0x10] & 0x10) >> 4);
1632 dmi
->irq
= data
[0x11];
1634 /* The top two bits of byte 0x10 hold the register spacing. */
1635 reg_spacing
= (data
[0x10] & 0xC0) >> 6;
1636 switch(reg_spacing
){
1637 case 0x00: /* Byte boundaries */
1640 case 0x01: /* 32-bit boundaries */
1643 case 0x02: /* 16-byte boundaries */
1647 /* Some other interface, just ignore it. */
1652 /* Note that technically, the lower bit of the base
1653 * address should be 1 if the address is I/O and 0 if
1654 * the address is in memory. So many systems get that
1655 * wrong (and all that I have seen are I/O) so we just
1656 * ignore that bit and assume I/O. Systems that use
1657 * memory should use the newer spec, anyway. */
1658 dmi
->base_addr
= base_addr
& 0xfffe;
1659 dmi
->addr_space
= IPMI_IO_ADDR_SPACE
;
1663 dmi
->slave_addr
= data
[6];
1668 static __devinit
void try_init_dmi(struct dmi_ipmi_data
*ipmi_data
)
1670 struct smi_info
*info
;
1672 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1675 "ipmi_si: Could not allocate SI data\n");
1679 info
->addr_source
= "SMBIOS";
1681 switch (ipmi_data
->type
) {
1682 case 0x01: /* KCS */
1683 info
->si_type
= SI_KCS
;
1685 case 0x02: /* SMIC */
1686 info
->si_type
= SI_SMIC
;
1689 info
->si_type
= SI_BT
;
1695 switch (ipmi_data
->addr_space
) {
1696 case IPMI_MEM_ADDR_SPACE
:
1697 info
->io_setup
= mem_setup
;
1698 info
->io
.addr_type
= IPMI_MEM_ADDR_SPACE
;
1701 case IPMI_IO_ADDR_SPACE
:
1702 info
->io_setup
= port_setup
;
1703 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
1709 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
1710 ipmi_data
->addr_space
);
1713 info
->io
.addr_data
= ipmi_data
->base_addr
;
1715 info
->io
.regspacing
= ipmi_data
->offset
;
1716 if (!info
->io
.regspacing
)
1717 info
->io
.regspacing
= DEFAULT_REGSPACING
;
1718 info
->io
.regsize
= DEFAULT_REGSPACING
;
1719 info
->io
.regshift
= 0;
1721 info
->slave_addr
= ipmi_data
->slave_addr
;
1723 info
->irq
= ipmi_data
->irq
;
1725 info
->irq_setup
= std_irq_setup
;
1730 static void __devinit
dmi_find_bmc(void)
1732 struct dmi_device
*dev
= NULL
;
1733 struct dmi_ipmi_data data
;
1736 while ((dev
= dmi_find_device(DMI_DEV_TYPE_IPMI
, NULL
, dev
))) {
1737 rv
= decode_dmi((struct dmi_header
*) dev
->device_data
, &data
);
1739 try_init_dmi(&data
);
1742 #endif /* CONFIG_DMI */
1746 #define PCI_ERMC_CLASSCODE 0x0C0700
1747 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
1748 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
1749 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
1750 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
1751 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
1753 #define PCI_HP_VENDOR_ID 0x103C
1754 #define PCI_MMC_DEVICE_ID 0x121A
1755 #define PCI_MMC_ADDR_CW 0x10
1757 static void ipmi_pci_cleanup(struct smi_info
*info
)
1759 struct pci_dev
*pdev
= info
->addr_source_data
;
1761 pci_disable_device(pdev
);
1764 static int __devinit
ipmi_pci_probe(struct pci_dev
*pdev
,
1765 const struct pci_device_id
*ent
)
1768 int class_type
= pdev
->class & PCI_ERMC_CLASSCODE_TYPE_MASK
;
1769 struct smi_info
*info
;
1770 int first_reg_offset
= 0;
1772 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1776 info
->addr_source
= "PCI";
1778 switch (class_type
) {
1779 case PCI_ERMC_CLASSCODE_TYPE_SMIC
:
1780 info
->si_type
= SI_SMIC
;
1783 case PCI_ERMC_CLASSCODE_TYPE_KCS
:
1784 info
->si_type
= SI_KCS
;
1787 case PCI_ERMC_CLASSCODE_TYPE_BT
:
1788 info
->si_type
= SI_BT
;
1793 printk(KERN_INFO
"ipmi_si: %s: Unknown IPMI type: %d\n",
1794 pci_name(pdev
), class_type
);
1798 rv
= pci_enable_device(pdev
);
1800 printk(KERN_ERR
"ipmi_si: %s: couldn't enable PCI device\n",
1806 info
->addr_source_cleanup
= ipmi_pci_cleanup
;
1807 info
->addr_source_data
= pdev
;
1809 if (pdev
->subsystem_vendor
== PCI_HP_VENDOR_ID
)
1810 first_reg_offset
= 1;
1812 if (pci_resource_flags(pdev
, 0) & IORESOURCE_IO
) {
1813 info
->io_setup
= port_setup
;
1814 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
1816 info
->io_setup
= mem_setup
;
1817 info
->io
.addr_type
= IPMI_MEM_ADDR_SPACE
;
1819 info
->io
.addr_data
= pci_resource_start(pdev
, 0);
1821 info
->io
.regspacing
= DEFAULT_REGSPACING
;
1822 info
->io
.regsize
= DEFAULT_REGSPACING
;
1823 info
->io
.regshift
= 0;
1825 info
->irq
= pdev
->irq
;
1827 info
->irq_setup
= std_irq_setup
;
1829 info
->dev
= &pdev
->dev
;
1831 return try_smi_init(info
);
1834 static void __devexit
ipmi_pci_remove(struct pci_dev
*pdev
)
1839 static int ipmi_pci_suspend(struct pci_dev
*pdev
, pm_message_t state
)
1844 static int ipmi_pci_resume(struct pci_dev
*pdev
)
1850 static struct pci_device_id ipmi_pci_devices
[] = {
1851 { PCI_DEVICE(PCI_HP_VENDOR_ID
, PCI_MMC_DEVICE_ID
) },
1852 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE
, PCI_ERMC_CLASSCODE
) }
1854 MODULE_DEVICE_TABLE(pci
, ipmi_pci_devices
);
1856 static struct pci_driver ipmi_pci_driver
= {
1857 .name
= DEVICE_NAME
,
1858 .id_table
= ipmi_pci_devices
,
1859 .probe
= ipmi_pci_probe
,
1860 .remove
= __devexit_p(ipmi_pci_remove
),
1862 .suspend
= ipmi_pci_suspend
,
1863 .resume
= ipmi_pci_resume
,
1866 #endif /* CONFIG_PCI */
1869 static int try_get_dev_id(struct smi_info
*smi_info
)
1871 unsigned char msg
[2];
1872 unsigned char *resp
;
1873 unsigned long resp_len
;
1874 enum si_sm_result smi_result
;
1877 resp
= kmalloc(IPMI_MAX_MSG_LENGTH
, GFP_KERNEL
);
1881 /* Do a Get Device ID command, since it comes back with some
1883 msg
[0] = IPMI_NETFN_APP_REQUEST
<< 2;
1884 msg
[1] = IPMI_GET_DEVICE_ID_CMD
;
1885 smi_info
->handlers
->start_transaction(smi_info
->si_sm
, msg
, 2);
1887 smi_result
= smi_info
->handlers
->event(smi_info
->si_sm
, 0);
1890 if (smi_result
== SI_SM_CALL_WITH_DELAY
||
1891 smi_result
== SI_SM_CALL_WITH_TICK_DELAY
) {
1892 schedule_timeout_uninterruptible(1);
1893 smi_result
= smi_info
->handlers
->event(
1894 smi_info
->si_sm
, 100);
1896 else if (smi_result
== SI_SM_CALL_WITHOUT_DELAY
)
1898 smi_result
= smi_info
->handlers
->event(
1899 smi_info
->si_sm
, 0);
1904 if (smi_result
== SI_SM_HOSED
) {
1905 /* We couldn't get the state machine to run, so whatever's at
1906 the port is probably not an IPMI SMI interface. */
1911 /* Otherwise, we got some data. */
1912 resp_len
= smi_info
->handlers
->get_result(smi_info
->si_sm
,
1913 resp
, IPMI_MAX_MSG_LENGTH
);
1914 if (resp_len
< 14) {
1915 /* That's odd, it should be longer. */
1920 if ((resp
[1] != IPMI_GET_DEVICE_ID_CMD
) || (resp
[2] != 0)) {
1921 /* That's odd, it shouldn't be able to fail. */
1926 /* Record info from the get device id, in case we need it. */
1927 ipmi_demangle_device_id(resp
+3, resp_len
-3, &smi_info
->device_id
);
1934 static int type_file_read_proc(char *page
, char **start
, off_t off
,
1935 int count
, int *eof
, void *data
)
1937 char *out
= (char *) page
;
1938 struct smi_info
*smi
= data
;
1940 switch (smi
->si_type
) {
1942 return sprintf(out
, "kcs\n");
1944 return sprintf(out
, "smic\n");
1946 return sprintf(out
, "bt\n");
1952 static int stat_file_read_proc(char *page
, char **start
, off_t off
,
1953 int count
, int *eof
, void *data
)
1955 char *out
= (char *) page
;
1956 struct smi_info
*smi
= data
;
1958 out
+= sprintf(out
, "interrupts_enabled: %d\n",
1959 smi
->irq
&& !smi
->interrupt_disabled
);
1960 out
+= sprintf(out
, "short_timeouts: %ld\n",
1961 smi
->short_timeouts
);
1962 out
+= sprintf(out
, "long_timeouts: %ld\n",
1963 smi
->long_timeouts
);
1964 out
+= sprintf(out
, "timeout_restarts: %ld\n",
1965 smi
->timeout_restarts
);
1966 out
+= sprintf(out
, "idles: %ld\n",
1968 out
+= sprintf(out
, "interrupts: %ld\n",
1970 out
+= sprintf(out
, "attentions: %ld\n",
1972 out
+= sprintf(out
, "flag_fetches: %ld\n",
1974 out
+= sprintf(out
, "hosed_count: %ld\n",
1976 out
+= sprintf(out
, "complete_transactions: %ld\n",
1977 smi
->complete_transactions
);
1978 out
+= sprintf(out
, "events: %ld\n",
1980 out
+= sprintf(out
, "watchdog_pretimeouts: %ld\n",
1981 smi
->watchdog_pretimeouts
);
1982 out
+= sprintf(out
, "incoming_messages: %ld\n",
1983 smi
->incoming_messages
);
1985 return (out
- ((char *) page
));
1989 * oem_data_avail_to_receive_msg_avail
1990 * @info - smi_info structure with msg_flags set
1992 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
1993 * Returns 1 indicating need to re-run handle_flags().
1995 static int oem_data_avail_to_receive_msg_avail(struct smi_info
*smi_info
)
1997 smi_info
->msg_flags
= ((smi_info
->msg_flags
& ~OEM_DATA_AVAIL
) |
2003 * setup_dell_poweredge_oem_data_handler
2004 * @info - smi_info.device_id must be populated
2006 * Systems that match, but have firmware version < 1.40 may assert
2007 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2008 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2009 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2010 * as RECEIVE_MSG_AVAIL instead.
2012 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2013 * assert the OEM[012] bits, and if it did, the driver would have to
2014 * change to handle that properly, we don't actually check for the
2016 * Device ID = 0x20 BMC on PowerEdge 8G servers
2017 * Device Revision = 0x80
2018 * Firmware Revision1 = 0x01 BMC version 1.40
2019 * Firmware Revision2 = 0x40 BCD encoded
2020 * IPMI Version = 0x51 IPMI 1.5
2021 * Manufacturer ID = A2 02 00 Dell IANA
2023 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2024 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2027 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2028 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2029 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2030 #define DELL_IANA_MFR_ID 0x0002a2
2031 static void setup_dell_poweredge_oem_data_handler(struct smi_info
*smi_info
)
2033 struct ipmi_device_id
*id
= &smi_info
->device_id
;
2034 if (id
->manufacturer_id
== DELL_IANA_MFR_ID
) {
2035 if (id
->device_id
== DELL_POWEREDGE_8G_BMC_DEVICE_ID
&&
2036 id
->device_revision
== DELL_POWEREDGE_8G_BMC_DEVICE_REV
&&
2037 id
->ipmi_version
== DELL_POWEREDGE_8G_BMC_IPMI_VERSION
) {
2038 smi_info
->oem_data_avail_handler
=
2039 oem_data_avail_to_receive_msg_avail
;
2041 else if (ipmi_version_major(id
) < 1 ||
2042 (ipmi_version_major(id
) == 1 &&
2043 ipmi_version_minor(id
) < 5)) {
2044 smi_info
->oem_data_avail_handler
=
2045 oem_data_avail_to_receive_msg_avail
;
2050 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2051 static void return_hosed_msg_badsize(struct smi_info
*smi_info
)
2053 struct ipmi_smi_msg
*msg
= smi_info
->curr_msg
;
2055 /* Make it a reponse */
2056 msg
->rsp
[0] = msg
->data
[0] | 4;
2057 msg
->rsp
[1] = msg
->data
[1];
2058 msg
->rsp
[2] = CANNOT_RETURN_REQUESTED_LENGTH
;
2060 smi_info
->curr_msg
= NULL
;
2061 deliver_recv_msg(smi_info
, msg
);
2065 * dell_poweredge_bt_xaction_handler
2066 * @info - smi_info.device_id must be populated
2068 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2069 * not respond to a Get SDR command if the length of the data
2070 * requested is exactly 0x3A, which leads to command timeouts and no
2071 * data returned. This intercepts such commands, and causes userspace
2072 * callers to try again with a different-sized buffer, which succeeds.
2075 #define STORAGE_NETFN 0x0A
2076 #define STORAGE_CMD_GET_SDR 0x23
2077 static int dell_poweredge_bt_xaction_handler(struct notifier_block
*self
,
2078 unsigned long unused
,
2081 struct smi_info
*smi_info
= in
;
2082 unsigned char *data
= smi_info
->curr_msg
->data
;
2083 unsigned int size
= smi_info
->curr_msg
->data_size
;
2085 (data
[0]>>2) == STORAGE_NETFN
&&
2086 data
[1] == STORAGE_CMD_GET_SDR
&&
2088 return_hosed_msg_badsize(smi_info
);
2094 static struct notifier_block dell_poweredge_bt_xaction_notifier
= {
2095 .notifier_call
= dell_poweredge_bt_xaction_handler
,
2099 * setup_dell_poweredge_bt_xaction_handler
2100 * @info - smi_info.device_id must be filled in already
2102 * Fills in smi_info.device_id.start_transaction_pre_hook
2103 * when we know what function to use there.
2106 setup_dell_poweredge_bt_xaction_handler(struct smi_info
*smi_info
)
2108 struct ipmi_device_id
*id
= &smi_info
->device_id
;
2109 if (id
->manufacturer_id
== DELL_IANA_MFR_ID
&&
2110 smi_info
->si_type
== SI_BT
)
2111 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier
);
2115 * setup_oem_data_handler
2116 * @info - smi_info.device_id must be filled in already
2118 * Fills in smi_info.device_id.oem_data_available_handler
2119 * when we know what function to use there.
2122 static void setup_oem_data_handler(struct smi_info
*smi_info
)
2124 setup_dell_poweredge_oem_data_handler(smi_info
);
2127 static void setup_xaction_handlers(struct smi_info
*smi_info
)
2129 setup_dell_poweredge_bt_xaction_handler(smi_info
);
2132 static inline void wait_for_timer_and_thread(struct smi_info
*smi_info
)
2134 if (smi_info
->intf
) {
2135 /* The timer and thread are only running if the
2136 interface has been started up and registered. */
2137 if (smi_info
->thread
!= NULL
)
2138 kthread_stop(smi_info
->thread
);
2139 del_timer_sync(&smi_info
->si_timer
);
2143 static __devinitdata
struct ipmi_default_vals
2149 { .type
= SI_KCS
, .port
= 0xca2 },
2150 { .type
= SI_SMIC
, .port
= 0xca9 },
2151 { .type
= SI_BT
, .port
= 0xe4 },
2155 static __devinit
void default_find_bmc(void)
2157 struct smi_info
*info
;
2160 for (i
= 0; ; i
++) {
2161 if (!ipmi_defaults
[i
].port
)
2164 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
2168 info
->addr_source
= NULL
;
2170 info
->si_type
= ipmi_defaults
[i
].type
;
2171 info
->io_setup
= port_setup
;
2172 info
->io
.addr_data
= ipmi_defaults
[i
].port
;
2173 info
->io
.addr_type
= IPMI_IO_ADDR_SPACE
;
2175 info
->io
.addr
= NULL
;
2176 info
->io
.regspacing
= DEFAULT_REGSPACING
;
2177 info
->io
.regsize
= DEFAULT_REGSPACING
;
2178 info
->io
.regshift
= 0;
2180 if (try_smi_init(info
) == 0) {
2182 printk(KERN_INFO
"ipmi_si: Found default %s state"
2183 " machine at %s address 0x%lx\n",
2184 si_to_str
[info
->si_type
],
2185 addr_space_to_str
[info
->io
.addr_type
],
2186 info
->io
.addr_data
);
2192 static int is_new_interface(struct smi_info
*info
)
2196 list_for_each_entry(e
, &smi_infos
, link
) {
2197 if (e
->io
.addr_type
!= info
->io
.addr_type
)
2199 if (e
->io
.addr_data
== info
->io
.addr_data
)
2206 static int try_smi_init(struct smi_info
*new_smi
)
2210 if (new_smi
->addr_source
) {
2211 printk(KERN_INFO
"ipmi_si: Trying %s-specified %s state"
2212 " machine at %s address 0x%lx, slave address 0x%x,"
2214 new_smi
->addr_source
,
2215 si_to_str
[new_smi
->si_type
],
2216 addr_space_to_str
[new_smi
->io
.addr_type
],
2217 new_smi
->io
.addr_data
,
2218 new_smi
->slave_addr
, new_smi
->irq
);
2221 mutex_lock(&smi_infos_lock
);
2222 if (!is_new_interface(new_smi
)) {
2223 printk(KERN_WARNING
"ipmi_si: duplicate interface\n");
2228 /* So we know not to free it unless we have allocated one. */
2229 new_smi
->intf
= NULL
;
2230 new_smi
->si_sm
= NULL
;
2231 new_smi
->handlers
= NULL
;
2233 switch (new_smi
->si_type
) {
2235 new_smi
->handlers
= &kcs_smi_handlers
;
2239 new_smi
->handlers
= &smic_smi_handlers
;
2243 new_smi
->handlers
= &bt_smi_handlers
;
2247 /* No support for anything else yet. */
2252 /* Allocate the state machine's data and initialize it. */
2253 new_smi
->si_sm
= kmalloc(new_smi
->handlers
->size(), GFP_KERNEL
);
2254 if (!new_smi
->si_sm
) {
2255 printk(" Could not allocate state machine memory\n");
2259 new_smi
->io_size
= new_smi
->handlers
->init_data(new_smi
->si_sm
,
2262 /* Now that we know the I/O size, we can set up the I/O. */
2263 rv
= new_smi
->io_setup(new_smi
);
2265 printk(" Could not set up I/O space\n");
2269 spin_lock_init(&(new_smi
->si_lock
));
2270 spin_lock_init(&(new_smi
->msg_lock
));
2271 spin_lock_init(&(new_smi
->count_lock
));
2273 /* Do low-level detection first. */
2274 if (new_smi
->handlers
->detect(new_smi
->si_sm
)) {
2275 if (new_smi
->addr_source
)
2276 printk(KERN_INFO
"ipmi_si: Interface detection"
2282 /* Attempt a get device id command. If it fails, we probably
2283 don't have a BMC here. */
2284 rv
= try_get_dev_id(new_smi
);
2286 if (new_smi
->addr_source
)
2287 printk(KERN_INFO
"ipmi_si: There appears to be no BMC"
2288 " at this location\n");
2292 setup_oem_data_handler(new_smi
);
2293 setup_xaction_handlers(new_smi
);
2295 /* Try to claim any interrupts. */
2296 if (new_smi
->irq_setup
)
2297 new_smi
->irq_setup(new_smi
);
2299 INIT_LIST_HEAD(&(new_smi
->xmit_msgs
));
2300 INIT_LIST_HEAD(&(new_smi
->hp_xmit_msgs
));
2301 new_smi
->curr_msg
= NULL
;
2302 atomic_set(&new_smi
->req_events
, 0);
2303 new_smi
->run_to_completion
= 0;
2305 new_smi
->interrupt_disabled
= 0;
2306 atomic_set(&new_smi
->stop_operation
, 0);
2307 new_smi
->intf_num
= smi_num
;
2310 /* Start clearing the flags before we enable interrupts or the
2311 timer to avoid racing with the timer. */
2312 start_clear_flags(new_smi
);
2313 /* IRQ is defined to be set when non-zero. */
2315 new_smi
->si_state
= SI_CLEARING_FLAGS_THEN_SET_IRQ
;
2317 if (!new_smi
->dev
) {
2318 /* If we don't already have a device from something
2319 * else (like PCI), then register a new one. */
2320 new_smi
->pdev
= platform_device_alloc("ipmi_si",
2325 " Unable to allocate platform device\n");
2328 new_smi
->dev
= &new_smi
->pdev
->dev
;
2329 new_smi
->dev
->driver
= &ipmi_driver
;
2331 rv
= platform_device_register(new_smi
->pdev
);
2335 " Unable to register system interface device:"
2340 new_smi
->dev_registered
= 1;
2343 rv
= ipmi_register_smi(&handlers
,
2345 &new_smi
->device_id
,
2347 new_smi
->slave_addr
);
2350 "ipmi_si: Unable to register device: error %d\n",
2352 goto out_err_stop_timer
;
2355 rv
= ipmi_smi_add_proc_entry(new_smi
->intf
, "type",
2356 type_file_read_proc
, NULL
,
2357 new_smi
, THIS_MODULE
);
2360 "ipmi_si: Unable to create proc entry: %d\n",
2362 goto out_err_stop_timer
;
2365 rv
= ipmi_smi_add_proc_entry(new_smi
->intf
, "si_stats",
2366 stat_file_read_proc
, NULL
,
2367 new_smi
, THIS_MODULE
);
2370 "ipmi_si: Unable to create proc entry: %d\n",
2372 goto out_err_stop_timer
;
2375 list_add_tail(&new_smi
->link
, &smi_infos
);
2377 mutex_unlock(&smi_infos_lock
);
2379 printk(" IPMI %s interface initialized\n",si_to_str
[new_smi
->si_type
]);
2384 atomic_inc(&new_smi
->stop_operation
);
2385 wait_for_timer_and_thread(new_smi
);
2389 ipmi_unregister_smi(new_smi
->intf
);
2391 if (new_smi
->irq_cleanup
)
2392 new_smi
->irq_cleanup(new_smi
);
2394 /* Wait until we know that we are out of any interrupt
2395 handlers might have been running before we freed the
2397 synchronize_sched();
2399 if (new_smi
->si_sm
) {
2400 if (new_smi
->handlers
)
2401 new_smi
->handlers
->cleanup(new_smi
->si_sm
);
2402 kfree(new_smi
->si_sm
);
2404 if (new_smi
->addr_source_cleanup
)
2405 new_smi
->addr_source_cleanup(new_smi
);
2406 if (new_smi
->io_cleanup
)
2407 new_smi
->io_cleanup(new_smi
);
2409 if (new_smi
->dev_registered
)
2410 platform_device_unregister(new_smi
->pdev
);
2414 mutex_unlock(&smi_infos_lock
);
2419 static __devinit
int init_ipmi_si(void)
2429 /* Register the device drivers. */
2430 rv
= driver_register(&ipmi_driver
);
2433 "init_ipmi_si: Unable to register driver: %d\n",
2439 /* Parse out the si_type string into its components. */
2442 for (i
= 0; (i
< SI_MAX_PARMS
) && (*str
!= '\0'); i
++) {
2444 str
= strchr(str
, ',');
2454 printk(KERN_INFO
"IPMI System Interface driver.\n");
2456 hardcode_find_bmc();
2468 pci_module_init(&ipmi_pci_driver
);
2471 if (si_trydefaults
) {
2472 mutex_lock(&smi_infos_lock
);
2473 if (list_empty(&smi_infos
)) {
2474 /* No BMC was found, try defaults. */
2475 mutex_unlock(&smi_infos_lock
);
2478 mutex_unlock(&smi_infos_lock
);
2482 mutex_lock(&smi_infos_lock
);
2483 if (list_empty(&smi_infos
)) {
2484 mutex_unlock(&smi_infos_lock
);
2486 pci_unregister_driver(&ipmi_pci_driver
);
2488 driver_unregister(&ipmi_driver
);
2489 printk("ipmi_si: Unable to find any System Interface(s)\n");
2492 mutex_unlock(&smi_infos_lock
);
2496 module_init(init_ipmi_si
);
2498 static void __devexit
cleanup_one_si(struct smi_info
*to_clean
)
2501 unsigned long flags
;
2506 list_del(&to_clean
->link
);
2508 /* Tell the timer and interrupt handlers that we are shutting
2510 spin_lock_irqsave(&(to_clean
->si_lock
), flags
);
2511 spin_lock(&(to_clean
->msg_lock
));
2513 atomic_inc(&to_clean
->stop_operation
);
2515 if (to_clean
->irq_cleanup
)
2516 to_clean
->irq_cleanup(to_clean
);
2518 spin_unlock(&(to_clean
->msg_lock
));
2519 spin_unlock_irqrestore(&(to_clean
->si_lock
), flags
);
2521 /* Wait until we know that we are out of any interrupt
2522 handlers might have been running before we freed the
2524 synchronize_sched();
2526 wait_for_timer_and_thread(to_clean
);
2528 /* Interrupts and timeouts are stopped, now make sure the
2529 interface is in a clean state. */
2530 while (to_clean
->curr_msg
|| (to_clean
->si_state
!= SI_NORMAL
)) {
2532 schedule_timeout_uninterruptible(1);
2535 rv
= ipmi_unregister_smi(to_clean
->intf
);
2538 "ipmi_si: Unable to unregister device: errno=%d\n",
2542 to_clean
->handlers
->cleanup(to_clean
->si_sm
);
2544 kfree(to_clean
->si_sm
);
2546 if (to_clean
->addr_source_cleanup
)
2547 to_clean
->addr_source_cleanup(to_clean
);
2548 if (to_clean
->io_cleanup
)
2549 to_clean
->io_cleanup(to_clean
);
2551 if (to_clean
->dev_registered
)
2552 platform_device_unregister(to_clean
->pdev
);
2557 static __exit
void cleanup_ipmi_si(void)
2559 struct smi_info
*e
, *tmp_e
;
2565 pci_unregister_driver(&ipmi_pci_driver
);
2568 mutex_lock(&smi_infos_lock
);
2569 list_for_each_entry_safe(e
, tmp_e
, &smi_infos
, link
)
2571 mutex_unlock(&smi_infos_lock
);
2573 driver_unregister(&ipmi_driver
);
2575 module_exit(cleanup_ipmi_si
);
2577 MODULE_LICENSE("GPL");
2578 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2579 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");