4 * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
7 * Author: MontaVista Software, Inc.
8 * Corey Minyard <minyard@mvista.com>
11 * Copyright 2002 MontaVista Software Inc.
12 * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
14 * This program is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2 of the License, or (at your
17 * option) any later version.
20 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
21 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
25 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
26 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
28 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
29 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 * You should have received a copy of the GNU General Public License along
32 * with this program; if not, write to the Free Software Foundation, Inc.,
33 * 675 Mass Ave, Cambridge, MA 02139, USA.
37 * This file holds the "policy" for the interface to the SMI state
38 * machine. It does the configuration, handles timers and interrupts,
39 * and drives the real SMI state machine.
42 #include <linux/module.h>
43 #include <linux/moduleparam.h>
44 #include <asm/system.h>
45 #include <linux/sched.h>
46 #include <linux/timer.h>
47 #include <linux/errno.h>
48 #include <linux/spinlock.h>
49 #include <linux/slab.h>
50 #include <linux/delay.h>
51 #include <linux/list.h>
52 #include <linux/pci.h>
53 #include <linux/ioport.h>
54 #include <linux/notifier.h>
55 #include <linux/mutex.h>
56 #include <linux/kthread.h>
58 #include <linux/interrupt.h>
59 #include <linux/rcupdate.h>
60 #include <linux/ipmi_smi.h>
62 #include "ipmi_si_sm.h"
63 #include <linux/init.h>
64 #include <linux/dmi.h>
65 #include <linux/string.h>
66 #include <linux/ctype.h>
69 #include <asm/of_device.h>
70 #include <asm/of_platform.h>
73 #define PFX "ipmi_si: "
75 /* Measure times between events in the driver. */
78 /* Call every 10 ms. */
79 #define SI_TIMEOUT_TIME_USEC 10000
80 #define SI_USEC_PER_JIFFY (1000000/HZ)
81 #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
82 #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
85 /* Bit for BMC global enables. */
86 #define IPMI_BMC_RCV_MSG_INTR 0x01
87 #define IPMI_BMC_EVT_MSG_INTR 0x02
88 #define IPMI_BMC_EVT_MSG_BUFF 0x04
89 #define IPMI_BMC_SYS_LOG 0x08
96 SI_CLEARING_FLAGS_THEN_SET_IRQ,
98 SI_ENABLE_INTERRUPTS1,
99 SI_ENABLE_INTERRUPTS2,
100 SI_DISABLE_INTERRUPTS1,
101 SI_DISABLE_INTERRUPTS2
102 /* FIXME - add watchdog stuff. */
105 /* Some BT-specific defines we need here. */
106 #define IPMI_BT_INTMASK_REG 2
107 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
108 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
111 SI_KCS, SI_SMIC, SI_BT
113 static char *si_to_str[] = { "kcs", "smic", "bt" };
115 #define DEVICE_NAME "ipmi_si"
117 static struct device_driver ipmi_driver =
120 .bus = &platform_bus_type
127 struct si_sm_data *si_sm;
128 struct si_sm_handlers *handlers;
129 enum si_type si_type;
132 struct list_head xmit_msgs;
133 struct list_head hp_xmit_msgs;
134 struct ipmi_smi_msg *curr_msg;
135 enum si_intf_state si_state;
137 /* Used to handle the various types of I/O that can occur with
140 int (*io_setup)(struct smi_info *info);
141 void (*io_cleanup)(struct smi_info *info);
142 int (*irq_setup)(struct smi_info *info);
143 void (*irq_cleanup)(struct smi_info *info);
144 unsigned int io_size;
145 char *addr_source; /* ACPI, PCI, SMBIOS, hardcode, default. */
146 void (*addr_source_cleanup)(struct smi_info *info);
147 void *addr_source_data;
149 /* Per-OEM handler, called from handle_flags().
150 Returns 1 when handle_flags() needs to be re-run
151 or 0 indicating it set si_state itself.
153 int (*oem_data_avail_handler)(struct smi_info *smi_info);
155 /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
156 is set to hold the flags until we are done handling everything
158 #define RECEIVE_MSG_AVAIL 0x01
159 #define EVENT_MSG_BUFFER_FULL 0x02
160 #define WDT_PRE_TIMEOUT_INT 0x08
161 #define OEM0_DATA_AVAIL 0x20
162 #define OEM1_DATA_AVAIL 0x40
163 #define OEM2_DATA_AVAIL 0x80
164 #define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
167 unsigned char msg_flags;
169 /* If set to true, this will request events the next time the
170 state machine is idle. */
173 /* If true, run the state machine to completion on every send
174 call. Generally used after a panic to make sure stuff goes
176 int run_to_completion;
178 /* The I/O port of an SI interface. */
181 /* The space between start addresses of the two ports. For
182 instance, if the first port is 0xca2 and the spacing is 4, then
183 the second port is 0xca6. */
184 unsigned int spacing;
186 /* zero if no irq; */
189 /* The timer for this si. */
190 struct timer_list si_timer;
192 /* The time (in jiffies) the last timeout occurred at. */
193 unsigned long last_timeout_jiffies;
195 /* Used to gracefully stop the timer without race conditions. */
196 atomic_t stop_operation;
198 /* The driver will disable interrupts when it gets into a
199 situation where it cannot handle messages due to lack of
200 memory. Once that situation clears up, it will re-enable
202 int interrupt_disabled;
204 /* From the get device id response... */
205 struct ipmi_device_id device_id;
207 /* Driver model stuff. */
209 struct platform_device *pdev;
211 /* True if we allocated the device, false if it came from
212 * someplace else (like PCI). */
215 /* Slave address, could be reported from DMI. */
216 unsigned char slave_addr;
218 /* Counters and things for the proc filesystem. */
219 spinlock_t count_lock;
220 unsigned long short_timeouts;
221 unsigned long long_timeouts;
222 unsigned long timeout_restarts;
224 unsigned long interrupts;
225 unsigned long attentions;
226 unsigned long flag_fetches;
227 unsigned long hosed_count;
228 unsigned long complete_transactions;
229 unsigned long events;
230 unsigned long watchdog_pretimeouts;
231 unsigned long incoming_messages;
233 struct task_struct *thread;
235 struct list_head link;
238 #define SI_MAX_PARMS 4
240 static int force_kipmid[SI_MAX_PARMS];
241 static int num_force_kipmid;
243 static int unload_when_empty = 1;
245 static int try_smi_init(struct smi_info *smi);
246 static void cleanup_one_si(struct smi_info *to_clean);
248 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
249 static int register_xaction_notifier(struct notifier_block * nb)
251 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
254 static void deliver_recv_msg(struct smi_info *smi_info,
255 struct ipmi_smi_msg *msg)
257 /* Deliver the message to the upper layer with the lock
259 spin_unlock(&(smi_info->si_lock));
260 ipmi_smi_msg_received(smi_info->intf, msg);
261 spin_lock(&(smi_info->si_lock));
264 static void return_hosed_msg(struct smi_info *smi_info, int cCode)
266 struct ipmi_smi_msg *msg = smi_info->curr_msg;
268 if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
269 cCode = IPMI_ERR_UNSPECIFIED;
270 /* else use it as is */
272 /* Make it a reponse */
273 msg->rsp[0] = msg->data[0] | 4;
274 msg->rsp[1] = msg->data[1];
278 smi_info->curr_msg = NULL;
279 deliver_recv_msg(smi_info, msg);
282 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
285 struct list_head *entry = NULL;
290 /* No need to save flags, we aleady have interrupts off and we
291 already hold the SMI lock. */
292 spin_lock(&(smi_info->msg_lock));
294 /* Pick the high priority queue first. */
295 if (!list_empty(&(smi_info->hp_xmit_msgs))) {
296 entry = smi_info->hp_xmit_msgs.next;
297 } else if (!list_empty(&(smi_info->xmit_msgs))) {
298 entry = smi_info->xmit_msgs.next;
302 smi_info->curr_msg = NULL;
308 smi_info->curr_msg = list_entry(entry,
313 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
315 err = atomic_notifier_call_chain(&xaction_notifier_list,
317 if (err & NOTIFY_STOP_MASK) {
318 rv = SI_SM_CALL_WITHOUT_DELAY;
321 err = smi_info->handlers->start_transaction(
323 smi_info->curr_msg->data,
324 smi_info->curr_msg->data_size);
326 return_hosed_msg(smi_info, err);
329 rv = SI_SM_CALL_WITHOUT_DELAY;
332 spin_unlock(&(smi_info->msg_lock));
337 static void start_enable_irq(struct smi_info *smi_info)
339 unsigned char msg[2];
341 /* If we are enabling interrupts, we have to tell the
343 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
344 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
346 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
347 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
350 static void start_disable_irq(struct smi_info *smi_info)
352 unsigned char msg[2];
354 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
355 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
357 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
358 smi_info->si_state = SI_DISABLE_INTERRUPTS1;
361 static void start_clear_flags(struct smi_info *smi_info)
363 unsigned char msg[3];
365 /* Make sure the watchdog pre-timeout flag is not set at startup. */
366 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
367 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
368 msg[2] = WDT_PRE_TIMEOUT_INT;
370 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
371 smi_info->si_state = SI_CLEARING_FLAGS;
374 /* When we have a situtaion where we run out of memory and cannot
375 allocate messages, we just leave them in the BMC and run the system
376 polled until we can allocate some memory. Once we have some
377 memory, we will re-enable the interrupt. */
378 static inline void disable_si_irq(struct smi_info *smi_info)
380 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
381 start_disable_irq(smi_info);
382 smi_info->interrupt_disabled = 1;
386 static inline void enable_si_irq(struct smi_info *smi_info)
388 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
389 start_enable_irq(smi_info);
390 smi_info->interrupt_disabled = 0;
394 static void handle_flags(struct smi_info *smi_info)
397 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
398 /* Watchdog pre-timeout */
399 spin_lock(&smi_info->count_lock);
400 smi_info->watchdog_pretimeouts++;
401 spin_unlock(&smi_info->count_lock);
403 start_clear_flags(smi_info);
404 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
405 spin_unlock(&(smi_info->si_lock));
406 ipmi_smi_watchdog_pretimeout(smi_info->intf);
407 spin_lock(&(smi_info->si_lock));
408 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
409 /* Messages available. */
410 smi_info->curr_msg = ipmi_alloc_smi_msg();
411 if (!smi_info->curr_msg) {
412 disable_si_irq(smi_info);
413 smi_info->si_state = SI_NORMAL;
416 enable_si_irq(smi_info);
418 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
419 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
420 smi_info->curr_msg->data_size = 2;
422 smi_info->handlers->start_transaction(
424 smi_info->curr_msg->data,
425 smi_info->curr_msg->data_size);
426 smi_info->si_state = SI_GETTING_MESSAGES;
427 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
428 /* Events available. */
429 smi_info->curr_msg = ipmi_alloc_smi_msg();
430 if (!smi_info->curr_msg) {
431 disable_si_irq(smi_info);
432 smi_info->si_state = SI_NORMAL;
435 enable_si_irq(smi_info);
437 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
438 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
439 smi_info->curr_msg->data_size = 2;
441 smi_info->handlers->start_transaction(
443 smi_info->curr_msg->data,
444 smi_info->curr_msg->data_size);
445 smi_info->si_state = SI_GETTING_EVENTS;
446 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
447 smi_info->oem_data_avail_handler) {
448 if (smi_info->oem_data_avail_handler(smi_info))
451 smi_info->si_state = SI_NORMAL;
455 static void handle_transaction_done(struct smi_info *smi_info)
457 struct ipmi_smi_msg *msg;
462 printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
464 switch (smi_info->si_state) {
466 if (!smi_info->curr_msg)
469 smi_info->curr_msg->rsp_size
470 = smi_info->handlers->get_result(
472 smi_info->curr_msg->rsp,
473 IPMI_MAX_MSG_LENGTH);
475 /* Do this here becase deliver_recv_msg() releases the
476 lock, and a new message can be put in during the
477 time the lock is released. */
478 msg = smi_info->curr_msg;
479 smi_info->curr_msg = NULL;
480 deliver_recv_msg(smi_info, msg);
483 case SI_GETTING_FLAGS:
485 unsigned char msg[4];
488 /* We got the flags from the SMI, now handle them. */
489 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
491 /* Error fetching flags, just give up for
493 smi_info->si_state = SI_NORMAL;
494 } else if (len < 4) {
495 /* Hmm, no flags. That's technically illegal, but
496 don't use uninitialized data. */
497 smi_info->si_state = SI_NORMAL;
499 smi_info->msg_flags = msg[3];
500 handle_flags(smi_info);
505 case SI_CLEARING_FLAGS:
506 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
508 unsigned char msg[3];
510 /* We cleared the flags. */
511 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
513 /* Error clearing flags */
515 "ipmi_si: Error clearing flags: %2.2x\n",
518 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
519 start_enable_irq(smi_info);
521 smi_info->si_state = SI_NORMAL;
525 case SI_GETTING_EVENTS:
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 event flag. */
543 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
544 handle_flags(smi_info);
546 spin_lock(&smi_info->count_lock);
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_GETTING_MESSAGES:
563 smi_info->curr_msg->rsp_size
564 = smi_info->handlers->get_result(
566 smi_info->curr_msg->rsp,
567 IPMI_MAX_MSG_LENGTH);
569 /* Do this here becase deliver_recv_msg() releases the
570 lock, and a new message can be put in during the
571 time the lock is released. */
572 msg = smi_info->curr_msg;
573 smi_info->curr_msg = NULL;
574 if (msg->rsp[2] != 0) {
575 /* Error getting event, probably done. */
578 /* Take off the msg flag. */
579 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
580 handle_flags(smi_info);
582 spin_lock(&smi_info->count_lock);
583 smi_info->incoming_messages++;
584 spin_unlock(&smi_info->count_lock);
586 /* Do this before we deliver the message
587 because delivering the message releases the
588 lock and something else can mess with the
590 handle_flags(smi_info);
592 deliver_recv_msg(smi_info, msg);
597 case SI_ENABLE_INTERRUPTS1:
599 unsigned char msg[4];
601 /* We got the flags from the SMI, now handle them. */
602 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
605 "ipmi_si: Could not enable interrupts"
606 ", failed get, using polled mode.\n");
607 smi_info->si_state = SI_NORMAL;
609 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
610 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
612 IPMI_BMC_RCV_MSG_INTR |
613 IPMI_BMC_EVT_MSG_INTR);
614 smi_info->handlers->start_transaction(
615 smi_info->si_sm, msg, 3);
616 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
621 case SI_ENABLE_INTERRUPTS2:
623 unsigned char msg[4];
625 /* We got the flags from the SMI, now handle them. */
626 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
629 "ipmi_si: Could not enable interrupts"
630 ", failed set, using polled mode.\n");
632 smi_info->si_state = SI_NORMAL;
636 case SI_DISABLE_INTERRUPTS1:
638 unsigned char msg[4];
640 /* We got the flags from the SMI, now handle them. */
641 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
644 "ipmi_si: Could not disable interrupts"
646 smi_info->si_state = SI_NORMAL;
648 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
649 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
651 ~(IPMI_BMC_RCV_MSG_INTR |
652 IPMI_BMC_EVT_MSG_INTR));
653 smi_info->handlers->start_transaction(
654 smi_info->si_sm, msg, 3);
655 smi_info->si_state = SI_DISABLE_INTERRUPTS2;
660 case SI_DISABLE_INTERRUPTS2:
662 unsigned char msg[4];
664 /* We got the flags from the SMI, now handle them. */
665 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
668 "ipmi_si: Could not disable interrupts"
671 smi_info->si_state = SI_NORMAL;
677 /* Called on timeouts and events. Timeouts should pass the elapsed
678 time, interrupts should pass in zero. Must be called with
679 si_lock held and interrupts disabled. */
680 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
683 enum si_sm_result si_sm_result;
686 /* There used to be a loop here that waited a little while
687 (around 25us) before giving up. That turned out to be
688 pointless, the minimum delays I was seeing were in the 300us
689 range, which is far too long to wait in an interrupt. So
690 we just run until the state machine tells us something
691 happened or it needs a delay. */
692 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
694 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
696 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
699 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
701 spin_lock(&smi_info->count_lock);
702 smi_info->complete_transactions++;
703 spin_unlock(&smi_info->count_lock);
705 handle_transaction_done(smi_info);
706 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
708 else if (si_sm_result == SI_SM_HOSED)
710 spin_lock(&smi_info->count_lock);
711 smi_info->hosed_count++;
712 spin_unlock(&smi_info->count_lock);
714 /* Do the before return_hosed_msg, because that
715 releases the lock. */
716 smi_info->si_state = SI_NORMAL;
717 if (smi_info->curr_msg != NULL) {
718 /* If we were handling a user message, format
719 a response to send to the upper layer to
720 tell it about the error. */
721 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
723 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
727 * We prefer handling attn over new messages. But don't do
728 * this if there is not yet an upper layer to handle anything.
730 if (likely(smi_info->intf) && si_sm_result == SI_SM_ATTN)
732 unsigned char msg[2];
734 spin_lock(&smi_info->count_lock);
735 smi_info->attentions++;
736 spin_unlock(&smi_info->count_lock);
738 /* Got a attn, send down a get message flags to see
739 what's causing it. It would be better to handle
740 this in the upper layer, but due to the way
741 interrupts work with the SMI, that's not really
743 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
744 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
746 smi_info->handlers->start_transaction(
747 smi_info->si_sm, msg, 2);
748 smi_info->si_state = SI_GETTING_FLAGS;
752 /* If we are currently idle, try to start the next message. */
753 if (si_sm_result == SI_SM_IDLE) {
754 spin_lock(&smi_info->count_lock);
756 spin_unlock(&smi_info->count_lock);
758 si_sm_result = start_next_msg(smi_info);
759 if (si_sm_result != SI_SM_IDLE)
763 if ((si_sm_result == SI_SM_IDLE)
764 && (atomic_read(&smi_info->req_events)))
766 /* We are idle and the upper layer requested that I fetch
768 atomic_set(&smi_info->req_events, 0);
770 smi_info->curr_msg = ipmi_alloc_smi_msg();
771 if (!smi_info->curr_msg)
774 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
775 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
776 smi_info->curr_msg->data_size = 2;
778 smi_info->handlers->start_transaction(
780 smi_info->curr_msg->data,
781 smi_info->curr_msg->data_size);
782 smi_info->si_state = SI_GETTING_EVENTS;
789 static void sender(void *send_info,
790 struct ipmi_smi_msg *msg,
793 struct smi_info *smi_info = send_info;
794 enum si_sm_result result;
800 if (atomic_read(&smi_info->stop_operation)) {
801 msg->rsp[0] = msg->data[0] | 4;
802 msg->rsp[1] = msg->data[1];
803 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
805 deliver_recv_msg(smi_info, msg);
811 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
814 if (smi_info->run_to_completion) {
816 * If we are running to completion, then throw it in
817 * the list and run transactions until everything is
818 * clear. Priority doesn't matter here.
822 * Run to completion means we are single-threaded, no
825 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
827 result = smi_event_handler(smi_info, 0);
828 while (result != SI_SM_IDLE) {
829 udelay(SI_SHORT_TIMEOUT_USEC);
830 result = smi_event_handler(smi_info,
831 SI_SHORT_TIMEOUT_USEC);
836 spin_lock_irqsave(&smi_info->msg_lock, flags);
838 list_add_tail(&msg->link, &smi_info->hp_xmit_msgs);
840 list_add_tail(&msg->link, &smi_info->xmit_msgs);
841 spin_unlock_irqrestore(&smi_info->msg_lock, flags);
843 spin_lock_irqsave(&smi_info->si_lock, flags);
844 if ((smi_info->si_state == SI_NORMAL)
845 && (smi_info->curr_msg == NULL))
847 start_next_msg(smi_info);
849 spin_unlock_irqrestore(&smi_info->si_lock, flags);
852 static void set_run_to_completion(void *send_info, int i_run_to_completion)
854 struct smi_info *smi_info = send_info;
855 enum si_sm_result result;
857 smi_info->run_to_completion = i_run_to_completion;
858 if (i_run_to_completion) {
859 result = smi_event_handler(smi_info, 0);
860 while (result != SI_SM_IDLE) {
861 udelay(SI_SHORT_TIMEOUT_USEC);
862 result = smi_event_handler(smi_info,
863 SI_SHORT_TIMEOUT_USEC);
868 static int ipmi_thread(void *data)
870 struct smi_info *smi_info = data;
872 enum si_sm_result smi_result;
874 set_user_nice(current, 19);
875 while (!kthread_should_stop()) {
876 spin_lock_irqsave(&(smi_info->si_lock), flags);
877 smi_result = smi_event_handler(smi_info, 0);
878 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
879 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
882 else if (smi_result == SI_SM_CALL_WITH_DELAY)
885 schedule_timeout_interruptible(1);
891 static void poll(void *send_info)
893 struct smi_info *smi_info = send_info;
897 * Make sure there is some delay in the poll loop so we can
898 * drive time forward and timeout things.
901 spin_lock_irqsave(&smi_info->si_lock, flags);
902 smi_event_handler(smi_info, 10);
903 spin_unlock_irqrestore(&smi_info->si_lock, flags);
906 static void request_events(void *send_info)
908 struct smi_info *smi_info = send_info;
910 if (atomic_read(&smi_info->stop_operation))
913 atomic_set(&smi_info->req_events, 1);
916 static int initialized;
918 static void smi_timeout(unsigned long data)
920 struct smi_info *smi_info = (struct smi_info *) data;
921 enum si_sm_result smi_result;
923 unsigned long jiffies_now;
929 spin_lock_irqsave(&(smi_info->si_lock), flags);
932 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
934 jiffies_now = jiffies;
935 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
936 * SI_USEC_PER_JIFFY);
937 smi_result = smi_event_handler(smi_info, time_diff);
939 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
941 smi_info->last_timeout_jiffies = jiffies_now;
943 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
944 /* Running with interrupts, only do long timeouts. */
945 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
946 spin_lock_irqsave(&smi_info->count_lock, flags);
947 smi_info->long_timeouts++;
948 spin_unlock_irqrestore(&smi_info->count_lock, flags);
952 /* If the state machine asks for a short delay, then shorten
953 the timer timeout. */
954 if (smi_result == SI_SM_CALL_WITH_DELAY) {
955 spin_lock_irqsave(&smi_info->count_lock, flags);
956 smi_info->short_timeouts++;
957 spin_unlock_irqrestore(&smi_info->count_lock, flags);
958 smi_info->si_timer.expires = jiffies + 1;
960 spin_lock_irqsave(&smi_info->count_lock, flags);
961 smi_info->long_timeouts++;
962 spin_unlock_irqrestore(&smi_info->count_lock, flags);
963 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
967 add_timer(&(smi_info->si_timer));
970 static irqreturn_t si_irq_handler(int irq, void *data)
972 struct smi_info *smi_info = data;
978 spin_lock_irqsave(&(smi_info->si_lock), flags);
980 spin_lock(&smi_info->count_lock);
981 smi_info->interrupts++;
982 spin_unlock(&smi_info->count_lock);
986 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
988 smi_event_handler(smi_info, 0);
989 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
993 static irqreturn_t si_bt_irq_handler(int irq, void *data)
995 struct smi_info *smi_info = data;
996 /* We need to clear the IRQ flag for the BT interface. */
997 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
998 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
999 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1000 return si_irq_handler(irq, data);
1003 static int smi_start_processing(void *send_info,
1006 struct smi_info *new_smi = send_info;
1009 new_smi->intf = intf;
1011 /* Try to claim any interrupts. */
1012 if (new_smi->irq_setup)
1013 new_smi->irq_setup(new_smi);
1015 /* Set up the timer that drives the interface. */
1016 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
1017 new_smi->last_timeout_jiffies = jiffies;
1018 mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
1021 * Check if the user forcefully enabled the daemon.
1023 if (new_smi->intf_num < num_force_kipmid)
1024 enable = force_kipmid[new_smi->intf_num];
1026 * The BT interface is efficient enough to not need a thread,
1027 * and there is no need for a thread if we have interrupts.
1029 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
1033 new_smi->thread = kthread_run(ipmi_thread, new_smi,
1034 "kipmi%d", new_smi->intf_num);
1035 if (IS_ERR(new_smi->thread)) {
1036 printk(KERN_NOTICE "ipmi_si_intf: Could not start"
1037 " kernel thread due to error %ld, only using"
1038 " timers to drive the interface\n",
1039 PTR_ERR(new_smi->thread));
1040 new_smi->thread = NULL;
1047 static void set_maintenance_mode(void *send_info, int enable)
1049 struct smi_info *smi_info = send_info;
1052 atomic_set(&smi_info->req_events, 0);
1055 static struct ipmi_smi_handlers handlers =
1057 .owner = THIS_MODULE,
1058 .start_processing = smi_start_processing,
1060 .request_events = request_events,
1061 .set_maintenance_mode = set_maintenance_mode,
1062 .set_run_to_completion = set_run_to_completion,
1066 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1067 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
1069 static LIST_HEAD(smi_infos);
1070 static DEFINE_MUTEX(smi_infos_lock);
1071 static int smi_num; /* Used to sequence the SMIs */
1073 #define DEFAULT_REGSPACING 1
1074 #define DEFAULT_REGSIZE 1
1076 static int si_trydefaults = 1;
1077 static char *si_type[SI_MAX_PARMS];
1078 #define MAX_SI_TYPE_STR 30
1079 static char si_type_str[MAX_SI_TYPE_STR];
1080 static unsigned long addrs[SI_MAX_PARMS];
1081 static unsigned int num_addrs;
1082 static unsigned int ports[SI_MAX_PARMS];
1083 static unsigned int num_ports;
1084 static int irqs[SI_MAX_PARMS];
1085 static unsigned int num_irqs;
1086 static int regspacings[SI_MAX_PARMS];
1087 static unsigned int num_regspacings;
1088 static int regsizes[SI_MAX_PARMS];
1089 static unsigned int num_regsizes;
1090 static int regshifts[SI_MAX_PARMS];
1091 static unsigned int num_regshifts;
1092 static int slave_addrs[SI_MAX_PARMS];
1093 static unsigned int num_slave_addrs;
1095 #define IPMI_IO_ADDR_SPACE 0
1096 #define IPMI_MEM_ADDR_SPACE 1
1097 static char *addr_space_to_str[] = { "i/o", "mem" };
1099 static int hotmod_handler(const char *val, struct kernel_param *kp);
1101 module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
1102 MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See"
1103 " Documentation/IPMI.txt in the kernel sources for the"
1106 module_param_named(trydefaults, si_trydefaults, bool, 0);
1107 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1108 " default scan of the KCS and SMIC interface at the standard"
1110 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1111 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1112 " interface separated by commas. The types are 'kcs',"
1113 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1114 " the first interface to kcs and the second to bt");
1115 module_param_array(addrs, ulong, &num_addrs, 0);
1116 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1117 " addresses separated by commas. Only use if an interface"
1118 " is in memory. Otherwise, set it to zero or leave"
1120 module_param_array(ports, uint, &num_ports, 0);
1121 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1122 " addresses separated by commas. Only use if an interface"
1123 " is a port. Otherwise, set it to zero or leave"
1125 module_param_array(irqs, int, &num_irqs, 0);
1126 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1127 " addresses separated by commas. Only use if an interface"
1128 " has an interrupt. Otherwise, set it to zero or leave"
1130 module_param_array(regspacings, int, &num_regspacings, 0);
1131 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1132 " and each successive register used by the interface. For"
1133 " instance, if the start address is 0xca2 and the spacing"
1134 " is 2, then the second address is at 0xca4. Defaults"
1136 module_param_array(regsizes, int, &num_regsizes, 0);
1137 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1138 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1139 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1140 " the 8-bit IPMI register has to be read from a larger"
1142 module_param_array(regshifts, int, &num_regshifts, 0);
1143 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1144 " IPMI register, in bits. For instance, if the data"
1145 " is read from a 32-bit word and the IPMI data is in"
1146 " bit 8-15, then the shift would be 8");
1147 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1148 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1149 " the controller. Normally this is 0x20, but can be"
1150 " overridden by this parm. This is an array indexed"
1151 " by interface number.");
1152 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1153 MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1154 " disabled(0). Normally the IPMI driver auto-detects"
1155 " this, but the value may be overridden by this parm.");
1156 module_param(unload_when_empty, int, 0);
1157 MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
1158 " specified or found, default is 1. Setting to 0"
1159 " is useful for hot add of devices using hotmod.");
1162 static void std_irq_cleanup(struct smi_info *info)
1164 if (info->si_type == SI_BT)
1165 /* Disable the interrupt in the BT interface. */
1166 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1167 free_irq(info->irq, info);
1170 static int std_irq_setup(struct smi_info *info)
1177 if (info->si_type == SI_BT) {
1178 rv = request_irq(info->irq,
1180 IRQF_SHARED | IRQF_DISABLED,
1184 /* Enable the interrupt in the BT interface. */
1185 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1186 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1188 rv = request_irq(info->irq,
1190 IRQF_SHARED | IRQF_DISABLED,
1195 "ipmi_si: %s unable to claim interrupt %d,"
1196 " running polled\n",
1197 DEVICE_NAME, info->irq);
1200 info->irq_cleanup = std_irq_cleanup;
1201 printk(" Using irq %d\n", info->irq);
1207 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1209 unsigned int addr = io->addr_data;
1211 return inb(addr + (offset * io->regspacing));
1214 static void port_outb(struct si_sm_io *io, unsigned int offset,
1217 unsigned int addr = io->addr_data;
1219 outb(b, addr + (offset * io->regspacing));
1222 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1224 unsigned int addr = io->addr_data;
1226 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1229 static void port_outw(struct si_sm_io *io, unsigned int offset,
1232 unsigned int addr = io->addr_data;
1234 outw(b << io->regshift, addr + (offset * io->regspacing));
1237 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1239 unsigned int addr = io->addr_data;
1241 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1244 static void port_outl(struct si_sm_io *io, unsigned int offset,
1247 unsigned int addr = io->addr_data;
1249 outl(b << io->regshift, addr+(offset * io->regspacing));
1252 static void port_cleanup(struct smi_info *info)
1254 unsigned int addr = info->io.addr_data;
1258 for (idx = 0; idx < info->io_size; idx++) {
1259 release_region(addr + idx * info->io.regspacing,
1265 static int port_setup(struct smi_info *info)
1267 unsigned int addr = info->io.addr_data;
1273 info->io_cleanup = port_cleanup;
1275 /* Figure out the actual inb/inw/inl/etc routine to use based
1276 upon the register size. */
1277 switch (info->io.regsize) {
1279 info->io.inputb = port_inb;
1280 info->io.outputb = port_outb;
1283 info->io.inputb = port_inw;
1284 info->io.outputb = port_outw;
1287 info->io.inputb = port_inl;
1288 info->io.outputb = port_outl;
1291 printk("ipmi_si: Invalid register size: %d\n",
1296 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1297 * tables. This causes problems when trying to register the
1298 * entire I/O region. Therefore we must register each I/O
1301 for (idx = 0; idx < info->io_size; idx++) {
1302 if (request_region(addr + idx * info->io.regspacing,
1303 info->io.regsize, DEVICE_NAME) == NULL) {
1304 /* Undo allocations */
1306 release_region(addr + idx * info->io.regspacing,
1315 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1317 return readb((io->addr)+(offset * io->regspacing));
1320 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1323 writeb(b, (io->addr)+(offset * io->regspacing));
1326 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1328 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1332 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1335 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1338 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1340 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1344 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1347 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1351 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1353 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1357 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1360 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1364 static void mem_cleanup(struct smi_info *info)
1366 unsigned long addr = info->io.addr_data;
1369 if (info->io.addr) {
1370 iounmap(info->io.addr);
1372 mapsize = ((info->io_size * info->io.regspacing)
1373 - (info->io.regspacing - info->io.regsize));
1375 release_mem_region(addr, mapsize);
1379 static int mem_setup(struct smi_info *info)
1381 unsigned long addr = info->io.addr_data;
1387 info->io_cleanup = mem_cleanup;
1389 /* Figure out the actual readb/readw/readl/etc routine to use based
1390 upon the register size. */
1391 switch (info->io.regsize) {
1393 info->io.inputb = intf_mem_inb;
1394 info->io.outputb = intf_mem_outb;
1397 info->io.inputb = intf_mem_inw;
1398 info->io.outputb = intf_mem_outw;
1401 info->io.inputb = intf_mem_inl;
1402 info->io.outputb = intf_mem_outl;
1406 info->io.inputb = mem_inq;
1407 info->io.outputb = mem_outq;
1411 printk("ipmi_si: Invalid register size: %d\n",
1416 /* Calculate the total amount of memory to claim. This is an
1417 * unusual looking calculation, but it avoids claiming any
1418 * more memory than it has to. It will claim everything
1419 * between the first address to the end of the last full
1421 mapsize = ((info->io_size * info->io.regspacing)
1422 - (info->io.regspacing - info->io.regsize));
1424 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1427 info->io.addr = ioremap(addr, mapsize);
1428 if (info->io.addr == NULL) {
1429 release_mem_region(addr, mapsize);
1436 * Parms come in as <op1>[:op2[:op3...]]. ops are:
1437 * add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
1445 enum hotmod_op { HM_ADD, HM_REMOVE };
1446 struct hotmod_vals {
1450 static struct hotmod_vals hotmod_ops[] = {
1452 { "remove", HM_REMOVE },
1455 static struct hotmod_vals hotmod_si[] = {
1457 { "smic", SI_SMIC },
1461 static struct hotmod_vals hotmod_as[] = {
1462 { "mem", IPMI_MEM_ADDR_SPACE },
1463 { "i/o", IPMI_IO_ADDR_SPACE },
1467 static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
1472 s = strchr(*curr, ',');
1474 printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
1479 for (i = 0; hotmod_ops[i].name; i++) {
1480 if (strcmp(*curr, v[i].name) == 0) {
1487 printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
1491 static int check_hotmod_int_op(const char *curr, const char *option,
1492 const char *name, int *val)
1496 if (strcmp(curr, name) == 0) {
1498 printk(KERN_WARNING PFX
1499 "No option given for '%s'\n",
1503 *val = simple_strtoul(option, &n, 0);
1504 if ((*n != '\0') || (*option == '\0')) {
1505 printk(KERN_WARNING PFX
1506 "Bad option given for '%s'\n",
1515 static int hotmod_handler(const char *val, struct kernel_param *kp)
1517 char *str = kstrdup(val, GFP_KERNEL);
1519 char *next, *curr, *s, *n, *o;
1521 enum si_type si_type;
1531 struct smi_info *info;
1536 /* Kill any trailing spaces, as we can get a "\n" from echo. */
1539 while ((ival >= 0) && isspace(str[ival])) {
1544 for (curr = str; curr; curr = next) {
1551 next = strchr(curr, ':');
1557 rv = parse_str(hotmod_ops, &ival, "operation", &curr);
1562 rv = parse_str(hotmod_si, &ival, "interface type", &curr);
1567 rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
1571 s = strchr(curr, ',');
1576 addr = simple_strtoul(curr, &n, 0);
1577 if ((*n != '\0') || (*curr == '\0')) {
1578 printk(KERN_WARNING PFX "Invalid hotmod address"
1585 s = strchr(curr, ',');
1590 o = strchr(curr, '=');
1595 rv = check_hotmod_int_op(curr, o, "rsp", ®spacing);
1600 rv = check_hotmod_int_op(curr, o, "rsi", ®size);
1605 rv = check_hotmod_int_op(curr, o, "rsh", ®shift);
1610 rv = check_hotmod_int_op(curr, o, "irq", &irq);
1615 rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
1622 printk(KERN_WARNING PFX
1623 "Invalid hotmod option '%s'\n",
1629 info = kzalloc(sizeof(*info), GFP_KERNEL);
1635 info->addr_source = "hotmod";
1636 info->si_type = si_type;
1637 info->io.addr_data = addr;
1638 info->io.addr_type = addr_space;
1639 if (addr_space == IPMI_MEM_ADDR_SPACE)
1640 info->io_setup = mem_setup;
1642 info->io_setup = port_setup;
1644 info->io.addr = NULL;
1645 info->io.regspacing = regspacing;
1646 if (!info->io.regspacing)
1647 info->io.regspacing = DEFAULT_REGSPACING;
1648 info->io.regsize = regsize;
1649 if (!info->io.regsize)
1650 info->io.regsize = DEFAULT_REGSPACING;
1651 info->io.regshift = regshift;
1654 info->irq_setup = std_irq_setup;
1655 info->slave_addr = ipmb;
1660 struct smi_info *e, *tmp_e;
1662 mutex_lock(&smi_infos_lock);
1663 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
1664 if (e->io.addr_type != addr_space)
1666 if (e->si_type != si_type)
1668 if (e->io.addr_data == addr)
1671 mutex_unlock(&smi_infos_lock);
1680 static __devinit void hardcode_find_bmc(void)
1683 struct smi_info *info;
1685 for (i = 0; i < SI_MAX_PARMS; i++) {
1686 if (!ports[i] && !addrs[i])
1689 info = kzalloc(sizeof(*info), GFP_KERNEL);
1693 info->addr_source = "hardcoded";
1695 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1696 info->si_type = SI_KCS;
1697 } else if (strcmp(si_type[i], "smic") == 0) {
1698 info->si_type = SI_SMIC;
1699 } else if (strcmp(si_type[i], "bt") == 0) {
1700 info->si_type = SI_BT;
1703 "ipmi_si: Interface type specified "
1704 "for interface %d, was invalid: %s\n",
1712 info->io_setup = port_setup;
1713 info->io.addr_data = ports[i];
1714 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1715 } else if (addrs[i]) {
1717 info->io_setup = mem_setup;
1718 info->io.addr_data = addrs[i];
1719 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1722 "ipmi_si: Interface type specified "
1723 "for interface %d, "
1724 "but port and address were not set or "
1725 "set to zero.\n", i);
1730 info->io.addr = NULL;
1731 info->io.regspacing = regspacings[i];
1732 if (!info->io.regspacing)
1733 info->io.regspacing = DEFAULT_REGSPACING;
1734 info->io.regsize = regsizes[i];
1735 if (!info->io.regsize)
1736 info->io.regsize = DEFAULT_REGSPACING;
1737 info->io.regshift = regshifts[i];
1738 info->irq = irqs[i];
1740 info->irq_setup = std_irq_setup;
1748 #include <linux/acpi.h>
1750 /* Once we get an ACPI failure, we don't try any more, because we go
1751 through the tables sequentially. Once we don't find a table, there
1753 static int acpi_failure;
1755 /* For GPE-type interrupts. */
1756 static u32 ipmi_acpi_gpe(void *context)
1758 struct smi_info *smi_info = context;
1759 unsigned long flags;
1764 spin_lock_irqsave(&(smi_info->si_lock), flags);
1766 spin_lock(&smi_info->count_lock);
1767 smi_info->interrupts++;
1768 spin_unlock(&smi_info->count_lock);
1771 do_gettimeofday(&t);
1772 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1774 smi_event_handler(smi_info, 0);
1775 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1777 return ACPI_INTERRUPT_HANDLED;
1780 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1785 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1788 static int acpi_gpe_irq_setup(struct smi_info *info)
1795 /* FIXME - is level triggered right? */
1796 status = acpi_install_gpe_handler(NULL,
1798 ACPI_GPE_LEVEL_TRIGGERED,
1801 if (status != AE_OK) {
1803 "ipmi_si: %s unable to claim ACPI GPE %d,"
1804 " running polled\n",
1805 DEVICE_NAME, info->irq);
1809 info->irq_cleanup = acpi_gpe_irq_cleanup;
1810 printk(" Using ACPI GPE %d\n", info->irq);
1817 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1828 s8 CreatorRevision[4];
1831 s16 SpecificationRevision;
1834 * Bit 0 - SCI interrupt supported
1835 * Bit 1 - I/O APIC/SAPIC
1839 /* If bit 0 of InterruptType is set, then this is the SCI
1840 interrupt in the GPEx_STS register. */
1845 /* If bit 1 of InterruptType is set, then this is the I/O
1846 APIC/SAPIC interrupt. */
1847 u32 GlobalSystemInterrupt;
1849 /* The actual register address. */
1850 struct acpi_generic_address addr;
1854 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1857 static __devinit int try_init_acpi(struct SPMITable *spmi)
1859 struct smi_info *info;
1862 if (spmi->IPMIlegacy != 1) {
1863 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1867 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1868 addr_space = IPMI_MEM_ADDR_SPACE;
1870 addr_space = IPMI_IO_ADDR_SPACE;
1872 info = kzalloc(sizeof(*info), GFP_KERNEL);
1874 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1878 info->addr_source = "ACPI";
1880 /* Figure out the interface type. */
1881 switch (spmi->InterfaceType)
1884 info->si_type = SI_KCS;
1887 info->si_type = SI_SMIC;
1890 info->si_type = SI_BT;
1893 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1894 spmi->InterfaceType);
1899 if (spmi->InterruptType & 1) {
1900 /* We've got a GPE interrupt. */
1901 info->irq = spmi->GPE;
1902 info->irq_setup = acpi_gpe_irq_setup;
1903 } else if (spmi->InterruptType & 2) {
1904 /* We've got an APIC/SAPIC interrupt. */
1905 info->irq = spmi->GlobalSystemInterrupt;
1906 info->irq_setup = std_irq_setup;
1908 /* Use the default interrupt setting. */
1910 info->irq_setup = NULL;
1913 if (spmi->addr.bit_width) {
1914 /* A (hopefully) properly formed register bit width. */
1915 info->io.regspacing = spmi->addr.bit_width / 8;
1917 info->io.regspacing = DEFAULT_REGSPACING;
1919 info->io.regsize = info->io.regspacing;
1920 info->io.regshift = spmi->addr.bit_offset;
1922 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1923 info->io_setup = mem_setup;
1924 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1925 } else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1926 info->io_setup = port_setup;
1927 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1930 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1933 info->io.addr_data = spmi->addr.address;
1940 static __devinit void acpi_find_bmc(void)
1943 struct SPMITable *spmi;
1952 for (i = 0; ; i++) {
1953 status = acpi_get_table(ACPI_SIG_SPMI, i+1,
1954 (struct acpi_table_header **)&spmi);
1955 if (status != AE_OK)
1958 try_init_acpi(spmi);
1964 struct dmi_ipmi_data
1968 unsigned long base_addr;
1974 static int __devinit decode_dmi(const struct dmi_header *dm,
1975 struct dmi_ipmi_data *dmi)
1977 const u8 *data = (const u8 *)dm;
1978 unsigned long base_addr;
1980 u8 len = dm->length;
1982 dmi->type = data[4];
1984 memcpy(&base_addr, data+8, sizeof(unsigned long));
1986 if (base_addr & 1) {
1988 base_addr &= 0xFFFE;
1989 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1993 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1995 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1997 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1999 dmi->irq = data[0x11];
2001 /* The top two bits of byte 0x10 hold the register spacing. */
2002 reg_spacing = (data[0x10] & 0xC0) >> 6;
2003 switch(reg_spacing){
2004 case 0x00: /* Byte boundaries */
2007 case 0x01: /* 32-bit boundaries */
2010 case 0x02: /* 16-byte boundaries */
2014 /* Some other interface, just ignore it. */
2019 /* Note that technically, the lower bit of the base
2020 * address should be 1 if the address is I/O and 0 if
2021 * the address is in memory. So many systems get that
2022 * wrong (and all that I have seen are I/O) so we just
2023 * ignore that bit and assume I/O. Systems that use
2024 * memory should use the newer spec, anyway. */
2025 dmi->base_addr = base_addr & 0xfffe;
2026 dmi->addr_space = IPMI_IO_ADDR_SPACE;
2030 dmi->slave_addr = data[6];
2035 static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
2037 struct smi_info *info;
2039 info = kzalloc(sizeof(*info), GFP_KERNEL);
2042 "ipmi_si: Could not allocate SI data\n");
2046 info->addr_source = "SMBIOS";
2048 switch (ipmi_data->type) {
2049 case 0x01: /* KCS */
2050 info->si_type = SI_KCS;
2052 case 0x02: /* SMIC */
2053 info->si_type = SI_SMIC;
2056 info->si_type = SI_BT;
2063 switch (ipmi_data->addr_space) {
2064 case IPMI_MEM_ADDR_SPACE:
2065 info->io_setup = mem_setup;
2066 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2069 case IPMI_IO_ADDR_SPACE:
2070 info->io_setup = port_setup;
2071 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2077 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
2078 ipmi_data->addr_space);
2081 info->io.addr_data = ipmi_data->base_addr;
2083 info->io.regspacing = ipmi_data->offset;
2084 if (!info->io.regspacing)
2085 info->io.regspacing = DEFAULT_REGSPACING;
2086 info->io.regsize = DEFAULT_REGSPACING;
2087 info->io.regshift = 0;
2089 info->slave_addr = ipmi_data->slave_addr;
2091 info->irq = ipmi_data->irq;
2093 info->irq_setup = std_irq_setup;
2098 static void __devinit dmi_find_bmc(void)
2100 const struct dmi_device *dev = NULL;
2101 struct dmi_ipmi_data data;
2104 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
2105 memset(&data, 0, sizeof(data));
2106 rv = decode_dmi((const struct dmi_header *) dev->device_data,
2109 try_init_dmi(&data);
2112 #endif /* CONFIG_DMI */
2116 #define PCI_ERMC_CLASSCODE 0x0C0700
2117 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
2118 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
2119 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
2120 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
2121 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
2123 #define PCI_HP_VENDOR_ID 0x103C
2124 #define PCI_MMC_DEVICE_ID 0x121A
2125 #define PCI_MMC_ADDR_CW 0x10
2127 static void ipmi_pci_cleanup(struct smi_info *info)
2129 struct pci_dev *pdev = info->addr_source_data;
2131 pci_disable_device(pdev);
2134 static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
2135 const struct pci_device_id *ent)
2138 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
2139 struct smi_info *info;
2140 int first_reg_offset = 0;
2142 info = kzalloc(sizeof(*info), GFP_KERNEL);
2146 info->addr_source = "PCI";
2148 switch (class_type) {
2149 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
2150 info->si_type = SI_SMIC;
2153 case PCI_ERMC_CLASSCODE_TYPE_KCS:
2154 info->si_type = SI_KCS;
2157 case PCI_ERMC_CLASSCODE_TYPE_BT:
2158 info->si_type = SI_BT;
2163 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
2164 pci_name(pdev), class_type);
2168 rv = pci_enable_device(pdev);
2170 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
2176 info->addr_source_cleanup = ipmi_pci_cleanup;
2177 info->addr_source_data = pdev;
2179 if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
2180 first_reg_offset = 1;
2182 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2183 info->io_setup = port_setup;
2184 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2186 info->io_setup = mem_setup;
2187 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2189 info->io.addr_data = pci_resource_start(pdev, 0);
2191 info->io.regspacing = DEFAULT_REGSPACING;
2192 info->io.regsize = DEFAULT_REGSPACING;
2193 info->io.regshift = 0;
2195 info->irq = pdev->irq;
2197 info->irq_setup = std_irq_setup;
2199 info->dev = &pdev->dev;
2200 pci_set_drvdata(pdev, info);
2202 return try_smi_init(info);
2205 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
2207 struct smi_info *info = pci_get_drvdata(pdev);
2208 cleanup_one_si(info);
2212 static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
2217 static int ipmi_pci_resume(struct pci_dev *pdev)
2223 static struct pci_device_id ipmi_pci_devices[] = {
2224 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
2225 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
2228 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
2230 static struct pci_driver ipmi_pci_driver = {
2231 .name = DEVICE_NAME,
2232 .id_table = ipmi_pci_devices,
2233 .probe = ipmi_pci_probe,
2234 .remove = __devexit_p(ipmi_pci_remove),
2236 .suspend = ipmi_pci_suspend,
2237 .resume = ipmi_pci_resume,
2240 #endif /* CONFIG_PCI */
2243 #ifdef CONFIG_PPC_OF
2244 static int __devinit ipmi_of_probe(struct of_device *dev,
2245 const struct of_device_id *match)
2247 struct smi_info *info;
2248 struct resource resource;
2249 const int *regsize, *regspacing, *regshift;
2250 struct device_node *np = dev->node;
2254 dev_info(&dev->dev, PFX "probing via device tree\n");
2256 ret = of_address_to_resource(np, 0, &resource);
2258 dev_warn(&dev->dev, PFX "invalid address from OF\n");
2262 regsize = of_get_property(np, "reg-size", &proplen);
2263 if (regsize && proplen != 4) {
2264 dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
2268 regspacing = of_get_property(np, "reg-spacing", &proplen);
2269 if (regspacing && proplen != 4) {
2270 dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
2274 regshift = of_get_property(np, "reg-shift", &proplen);
2275 if (regshift && proplen != 4) {
2276 dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
2280 info = kzalloc(sizeof(*info), GFP_KERNEL);
2284 PFX "could not allocate memory for OF probe\n");
2288 info->si_type = (enum si_type) match->data;
2289 info->addr_source = "device-tree";
2290 info->io_setup = mem_setup;
2291 info->irq_setup = std_irq_setup;
2293 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2294 info->io.addr_data = resource.start;
2296 info->io.regsize = regsize ? *regsize : DEFAULT_REGSIZE;
2297 info->io.regspacing = regspacing ? *regspacing : DEFAULT_REGSPACING;
2298 info->io.regshift = regshift ? *regshift : 0;
2300 info->irq = irq_of_parse_and_map(dev->node, 0);
2301 info->dev = &dev->dev;
2303 dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %x\n",
2304 info->io.addr_data, info->io.regsize, info->io.regspacing,
2307 dev->dev.driver_data = (void*) info;
2309 return try_smi_init(info);
2312 static int __devexit ipmi_of_remove(struct of_device *dev)
2314 cleanup_one_si(dev->dev.driver_data);
2318 static struct of_device_id ipmi_match[] =
2320 { .type = "ipmi", .compatible = "ipmi-kcs", .data = (void *)(unsigned long) SI_KCS },
2321 { .type = "ipmi", .compatible = "ipmi-smic", .data = (void *)(unsigned long) SI_SMIC },
2322 { .type = "ipmi", .compatible = "ipmi-bt", .data = (void *)(unsigned long) SI_BT },
2326 static struct of_platform_driver ipmi_of_platform_driver =
2329 .match_table = ipmi_match,
2330 .probe = ipmi_of_probe,
2331 .remove = __devexit_p(ipmi_of_remove),
2333 #endif /* CONFIG_PPC_OF */
2336 static int try_get_dev_id(struct smi_info *smi_info)
2338 unsigned char msg[2];
2339 unsigned char *resp;
2340 unsigned long resp_len;
2341 enum si_sm_result smi_result;
2344 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2348 /* Do a Get Device ID command, since it comes back with some
2350 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2351 msg[1] = IPMI_GET_DEVICE_ID_CMD;
2352 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2354 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
2357 if (smi_result == SI_SM_CALL_WITH_DELAY ||
2358 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
2359 schedule_timeout_uninterruptible(1);
2360 smi_result = smi_info->handlers->event(
2361 smi_info->si_sm, 100);
2363 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
2365 smi_result = smi_info->handlers->event(
2366 smi_info->si_sm, 0);
2371 if (smi_result == SI_SM_HOSED) {
2372 /* We couldn't get the state machine to run, so whatever's at
2373 the port is probably not an IPMI SMI interface. */
2378 /* Otherwise, we got some data. */
2379 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2380 resp, IPMI_MAX_MSG_LENGTH);
2382 /* Check and record info from the get device id, in case we need it. */
2383 rv = ipmi_demangle_device_id(resp, resp_len, &smi_info->device_id);
2390 static int type_file_read_proc(char *page, char **start, off_t off,
2391 int count, int *eof, void *data)
2393 struct smi_info *smi = data;
2395 return sprintf(page, "%s\n", si_to_str[smi->si_type]);
2398 static int stat_file_read_proc(char *page, char **start, off_t off,
2399 int count, int *eof, void *data)
2401 char *out = (char *) page;
2402 struct smi_info *smi = data;
2404 out += sprintf(out, "interrupts_enabled: %d\n",
2405 smi->irq && !smi->interrupt_disabled);
2406 out += sprintf(out, "short_timeouts: %ld\n",
2407 smi->short_timeouts);
2408 out += sprintf(out, "long_timeouts: %ld\n",
2409 smi->long_timeouts);
2410 out += sprintf(out, "timeout_restarts: %ld\n",
2411 smi->timeout_restarts);
2412 out += sprintf(out, "idles: %ld\n",
2414 out += sprintf(out, "interrupts: %ld\n",
2416 out += sprintf(out, "attentions: %ld\n",
2418 out += sprintf(out, "flag_fetches: %ld\n",
2420 out += sprintf(out, "hosed_count: %ld\n",
2422 out += sprintf(out, "complete_transactions: %ld\n",
2423 smi->complete_transactions);
2424 out += sprintf(out, "events: %ld\n",
2426 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
2427 smi->watchdog_pretimeouts);
2428 out += sprintf(out, "incoming_messages: %ld\n",
2429 smi->incoming_messages);
2434 static int param_read_proc(char *page, char **start, off_t off,
2435 int count, int *eof, void *data)
2437 struct smi_info *smi = data;
2439 return sprintf(page,
2440 "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
2441 si_to_str[smi->si_type],
2442 addr_space_to_str[smi->io.addr_type],
2452 * oem_data_avail_to_receive_msg_avail
2453 * @info - smi_info structure with msg_flags set
2455 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2456 * Returns 1 indicating need to re-run handle_flags().
2458 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2460 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2466 * setup_dell_poweredge_oem_data_handler
2467 * @info - smi_info.device_id must be populated
2469 * Systems that match, but have firmware version < 1.40 may assert
2470 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2471 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2472 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2473 * as RECEIVE_MSG_AVAIL instead.
2475 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2476 * assert the OEM[012] bits, and if it did, the driver would have to
2477 * change to handle that properly, we don't actually check for the
2479 * Device ID = 0x20 BMC on PowerEdge 8G servers
2480 * Device Revision = 0x80
2481 * Firmware Revision1 = 0x01 BMC version 1.40
2482 * Firmware Revision2 = 0x40 BCD encoded
2483 * IPMI Version = 0x51 IPMI 1.5
2484 * Manufacturer ID = A2 02 00 Dell IANA
2486 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2487 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2490 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2491 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2492 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2493 #define DELL_IANA_MFR_ID 0x0002a2
2494 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2496 struct ipmi_device_id *id = &smi_info->device_id;
2497 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
2498 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2499 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2500 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
2501 smi_info->oem_data_avail_handler =
2502 oem_data_avail_to_receive_msg_avail;
2504 else if (ipmi_version_major(id) < 1 ||
2505 (ipmi_version_major(id) == 1 &&
2506 ipmi_version_minor(id) < 5)) {
2507 smi_info->oem_data_avail_handler =
2508 oem_data_avail_to_receive_msg_avail;
2513 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2514 static void return_hosed_msg_badsize(struct smi_info *smi_info)
2516 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2518 /* Make it a reponse */
2519 msg->rsp[0] = msg->data[0] | 4;
2520 msg->rsp[1] = msg->data[1];
2521 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2523 smi_info->curr_msg = NULL;
2524 deliver_recv_msg(smi_info, msg);
2528 * dell_poweredge_bt_xaction_handler
2529 * @info - smi_info.device_id must be populated
2531 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2532 * not respond to a Get SDR command if the length of the data
2533 * requested is exactly 0x3A, which leads to command timeouts and no
2534 * data returned. This intercepts such commands, and causes userspace
2535 * callers to try again with a different-sized buffer, which succeeds.
2538 #define STORAGE_NETFN 0x0A
2539 #define STORAGE_CMD_GET_SDR 0x23
2540 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2541 unsigned long unused,
2544 struct smi_info *smi_info = in;
2545 unsigned char *data = smi_info->curr_msg->data;
2546 unsigned int size = smi_info->curr_msg->data_size;
2548 (data[0]>>2) == STORAGE_NETFN &&
2549 data[1] == STORAGE_CMD_GET_SDR &&
2551 return_hosed_msg_badsize(smi_info);
2557 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2558 .notifier_call = dell_poweredge_bt_xaction_handler,
2562 * setup_dell_poweredge_bt_xaction_handler
2563 * @info - smi_info.device_id must be filled in already
2565 * Fills in smi_info.device_id.start_transaction_pre_hook
2566 * when we know what function to use there.
2569 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2571 struct ipmi_device_id *id = &smi_info->device_id;
2572 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2573 smi_info->si_type == SI_BT)
2574 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2578 * setup_oem_data_handler
2579 * @info - smi_info.device_id must be filled in already
2581 * Fills in smi_info.device_id.oem_data_available_handler
2582 * when we know what function to use there.
2585 static void setup_oem_data_handler(struct smi_info *smi_info)
2587 setup_dell_poweredge_oem_data_handler(smi_info);
2590 static void setup_xaction_handlers(struct smi_info *smi_info)
2592 setup_dell_poweredge_bt_xaction_handler(smi_info);
2595 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2597 if (smi_info->intf) {
2598 /* The timer and thread are only running if the
2599 interface has been started up and registered. */
2600 if (smi_info->thread != NULL)
2601 kthread_stop(smi_info->thread);
2602 del_timer_sync(&smi_info->si_timer);
2606 static __devinitdata struct ipmi_default_vals
2612 { .type = SI_KCS, .port = 0xca2 },
2613 { .type = SI_SMIC, .port = 0xca9 },
2614 { .type = SI_BT, .port = 0xe4 },
2618 static __devinit void default_find_bmc(void)
2620 struct smi_info *info;
2623 for (i = 0; ; i++) {
2624 if (!ipmi_defaults[i].port)
2627 info = kzalloc(sizeof(*info), GFP_KERNEL);
2631 #ifdef CONFIG_PPC_MERGE
2632 if (check_legacy_ioport(ipmi_defaults[i].port))
2636 info->addr_source = NULL;
2638 info->si_type = ipmi_defaults[i].type;
2639 info->io_setup = port_setup;
2640 info->io.addr_data = ipmi_defaults[i].port;
2641 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2643 info->io.addr = NULL;
2644 info->io.regspacing = DEFAULT_REGSPACING;
2645 info->io.regsize = DEFAULT_REGSPACING;
2646 info->io.regshift = 0;
2648 if (try_smi_init(info) == 0) {
2650 printk(KERN_INFO "ipmi_si: Found default %s state"
2651 " machine at %s address 0x%lx\n",
2652 si_to_str[info->si_type],
2653 addr_space_to_str[info->io.addr_type],
2654 info->io.addr_data);
2660 static int is_new_interface(struct smi_info *info)
2664 list_for_each_entry(e, &smi_infos, link) {
2665 if (e->io.addr_type != info->io.addr_type)
2667 if (e->io.addr_data == info->io.addr_data)
2674 static int try_smi_init(struct smi_info *new_smi)
2678 if (new_smi->addr_source) {
2679 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2680 " machine at %s address 0x%lx, slave address 0x%x,"
2682 new_smi->addr_source,
2683 si_to_str[new_smi->si_type],
2684 addr_space_to_str[new_smi->io.addr_type],
2685 new_smi->io.addr_data,
2686 new_smi->slave_addr, new_smi->irq);
2689 mutex_lock(&smi_infos_lock);
2690 if (!is_new_interface(new_smi)) {
2691 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2696 /* So we know not to free it unless we have allocated one. */
2697 new_smi->intf = NULL;
2698 new_smi->si_sm = NULL;
2699 new_smi->handlers = NULL;
2701 switch (new_smi->si_type) {
2703 new_smi->handlers = &kcs_smi_handlers;
2707 new_smi->handlers = &smic_smi_handlers;
2711 new_smi->handlers = &bt_smi_handlers;
2715 /* No support for anything else yet. */
2720 /* Allocate the state machine's data and initialize it. */
2721 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2722 if (!new_smi->si_sm) {
2723 printk(" Could not allocate state machine memory\n");
2727 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2730 /* Now that we know the I/O size, we can set up the I/O. */
2731 rv = new_smi->io_setup(new_smi);
2733 printk(" Could not set up I/O space\n");
2737 spin_lock_init(&(new_smi->si_lock));
2738 spin_lock_init(&(new_smi->msg_lock));
2739 spin_lock_init(&(new_smi->count_lock));
2741 /* Do low-level detection first. */
2742 if (new_smi->handlers->detect(new_smi->si_sm)) {
2743 if (new_smi->addr_source)
2744 printk(KERN_INFO "ipmi_si: Interface detection"
2750 /* Attempt a get device id command. If it fails, we probably
2751 don't have a BMC here. */
2752 rv = try_get_dev_id(new_smi);
2754 if (new_smi->addr_source)
2755 printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2756 " at this location\n");
2760 setup_oem_data_handler(new_smi);
2761 setup_xaction_handlers(new_smi);
2763 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2764 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2765 new_smi->curr_msg = NULL;
2766 atomic_set(&new_smi->req_events, 0);
2767 new_smi->run_to_completion = 0;
2769 new_smi->interrupt_disabled = 0;
2770 atomic_set(&new_smi->stop_operation, 0);
2771 new_smi->intf_num = smi_num;
2774 /* Start clearing the flags before we enable interrupts or the
2775 timer to avoid racing with the timer. */
2776 start_clear_flags(new_smi);
2777 /* IRQ is defined to be set when non-zero. */
2779 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2781 if (!new_smi->dev) {
2782 /* If we don't already have a device from something
2783 * else (like PCI), then register a new one. */
2784 new_smi->pdev = platform_device_alloc("ipmi_si",
2789 " Unable to allocate platform device\n");
2792 new_smi->dev = &new_smi->pdev->dev;
2793 new_smi->dev->driver = &ipmi_driver;
2795 rv = platform_device_add(new_smi->pdev);
2799 " Unable to register system interface device:"
2804 new_smi->dev_registered = 1;
2807 rv = ipmi_register_smi(&handlers,
2809 &new_smi->device_id,
2812 new_smi->slave_addr);
2815 "ipmi_si: Unable to register device: error %d\n",
2817 goto out_err_stop_timer;
2820 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2821 type_file_read_proc, NULL,
2822 new_smi, THIS_MODULE);
2825 "ipmi_si: Unable to create proc entry: %d\n",
2827 goto out_err_stop_timer;
2830 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2831 stat_file_read_proc, NULL,
2832 new_smi, THIS_MODULE);
2835 "ipmi_si: Unable to create proc entry: %d\n",
2837 goto out_err_stop_timer;
2840 rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
2841 param_read_proc, NULL,
2842 new_smi, THIS_MODULE);
2845 "ipmi_si: Unable to create proc entry: %d\n",
2847 goto out_err_stop_timer;
2850 list_add_tail(&new_smi->link, &smi_infos);
2852 mutex_unlock(&smi_infos_lock);
2854 printk(KERN_INFO "IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
2859 atomic_inc(&new_smi->stop_operation);
2860 wait_for_timer_and_thread(new_smi);
2864 ipmi_unregister_smi(new_smi->intf);
2866 if (new_smi->irq_cleanup)
2867 new_smi->irq_cleanup(new_smi);
2869 /* Wait until we know that we are out of any interrupt
2870 handlers might have been running before we freed the
2872 synchronize_sched();
2874 if (new_smi->si_sm) {
2875 if (new_smi->handlers)
2876 new_smi->handlers->cleanup(new_smi->si_sm);
2877 kfree(new_smi->si_sm);
2879 if (new_smi->addr_source_cleanup)
2880 new_smi->addr_source_cleanup(new_smi);
2881 if (new_smi->io_cleanup)
2882 new_smi->io_cleanup(new_smi);
2884 if (new_smi->dev_registered)
2885 platform_device_unregister(new_smi->pdev);
2889 mutex_unlock(&smi_infos_lock);
2894 static __devinit int init_ipmi_si(void)
2904 /* Register the device drivers. */
2905 rv = driver_register(&ipmi_driver);
2908 "init_ipmi_si: Unable to register driver: %d\n",
2914 /* Parse out the si_type string into its components. */
2917 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
2919 str = strchr(str, ',');
2929 printk(KERN_INFO "IPMI System Interface driver.\n");
2931 hardcode_find_bmc();
2942 rv = pci_register_driver(&ipmi_pci_driver);
2945 "init_ipmi_si: Unable to register PCI driver: %d\n",
2950 #ifdef CONFIG_PPC_OF
2951 of_register_platform_driver(&ipmi_of_platform_driver);
2954 if (si_trydefaults) {
2955 mutex_lock(&smi_infos_lock);
2956 if (list_empty(&smi_infos)) {
2957 /* No BMC was found, try defaults. */
2958 mutex_unlock(&smi_infos_lock);
2961 mutex_unlock(&smi_infos_lock);
2965 mutex_lock(&smi_infos_lock);
2966 if (unload_when_empty && list_empty(&smi_infos)) {
2967 mutex_unlock(&smi_infos_lock);
2969 pci_unregister_driver(&ipmi_pci_driver);
2972 #ifdef CONFIG_PPC_OF
2973 of_unregister_platform_driver(&ipmi_of_platform_driver);
2975 driver_unregister(&ipmi_driver);
2976 printk("ipmi_si: Unable to find any System Interface(s)\n");
2979 mutex_unlock(&smi_infos_lock);
2983 module_init(init_ipmi_si);
2985 static void cleanup_one_si(struct smi_info *to_clean)
2988 unsigned long flags;
2993 list_del(&to_clean->link);
2995 /* Tell the driver that we are shutting down. */
2996 atomic_inc(&to_clean->stop_operation);
2998 /* Make sure the timer and thread are stopped and will not run
3000 wait_for_timer_and_thread(to_clean);
3002 /* Timeouts are stopped, now make sure the interrupts are off
3003 for the device. A little tricky with locks to make sure
3004 there are no races. */
3005 spin_lock_irqsave(&to_clean->si_lock, flags);
3006 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3007 spin_unlock_irqrestore(&to_clean->si_lock, flags);
3009 schedule_timeout_uninterruptible(1);
3010 spin_lock_irqsave(&to_clean->si_lock, flags);
3012 disable_si_irq(to_clean);
3013 spin_unlock_irqrestore(&to_clean->si_lock, flags);
3014 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3016 schedule_timeout_uninterruptible(1);
3019 /* Clean up interrupts and make sure that everything is done. */
3020 if (to_clean->irq_cleanup)
3021 to_clean->irq_cleanup(to_clean);
3022 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3024 schedule_timeout_uninterruptible(1);
3027 rv = ipmi_unregister_smi(to_clean->intf);
3030 "ipmi_si: Unable to unregister device: errno=%d\n",
3034 to_clean->handlers->cleanup(to_clean->si_sm);
3036 kfree(to_clean->si_sm);
3038 if (to_clean->addr_source_cleanup)
3039 to_clean->addr_source_cleanup(to_clean);
3040 if (to_clean->io_cleanup)
3041 to_clean->io_cleanup(to_clean);
3043 if (to_clean->dev_registered)
3044 platform_device_unregister(to_clean->pdev);
3049 static __exit void cleanup_ipmi_si(void)
3051 struct smi_info *e, *tmp_e;
3057 pci_unregister_driver(&ipmi_pci_driver);
3060 #ifdef CONFIG_PPC_OF
3061 of_unregister_platform_driver(&ipmi_of_platform_driver);
3064 mutex_lock(&smi_infos_lock);
3065 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
3067 mutex_unlock(&smi_infos_lock);
3069 driver_unregister(&ipmi_driver);
3071 module_exit(cleanup_ipmi_si);
3073 MODULE_LICENSE("GPL");
3074 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
3075 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");