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 if (!smi_info->run_to_completion)
293 spin_lock(&(smi_info->msg_lock));
295 /* Pick the high priority queue first. */
296 if (!list_empty(&(smi_info->hp_xmit_msgs))) {
297 entry = smi_info->hp_xmit_msgs.next;
298 } else if (!list_empty(&(smi_info->xmit_msgs))) {
299 entry = smi_info->xmit_msgs.next;
303 smi_info->curr_msg = NULL;
309 smi_info->curr_msg = list_entry(entry,
314 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
316 err = atomic_notifier_call_chain(&xaction_notifier_list,
318 if (err & NOTIFY_STOP_MASK) {
319 rv = SI_SM_CALL_WITHOUT_DELAY;
322 err = smi_info->handlers->start_transaction(
324 smi_info->curr_msg->data,
325 smi_info->curr_msg->data_size);
327 return_hosed_msg(smi_info, err);
330 rv = SI_SM_CALL_WITHOUT_DELAY;
333 if (!smi_info->run_to_completion)
334 spin_unlock(&(smi_info->msg_lock));
339 static void start_enable_irq(struct smi_info *smi_info)
341 unsigned char msg[2];
343 /* If we are enabling interrupts, we have to tell the
345 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
346 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
348 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
349 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
352 static void start_disable_irq(struct smi_info *smi_info)
354 unsigned char msg[2];
356 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
357 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
359 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
360 smi_info->si_state = SI_DISABLE_INTERRUPTS1;
363 static void start_clear_flags(struct smi_info *smi_info)
365 unsigned char msg[3];
367 /* Make sure the watchdog pre-timeout flag is not set at startup. */
368 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
369 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
370 msg[2] = WDT_PRE_TIMEOUT_INT;
372 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
373 smi_info->si_state = SI_CLEARING_FLAGS;
376 /* When we have a situtaion where we run out of memory and cannot
377 allocate messages, we just leave them in the BMC and run the system
378 polled until we can allocate some memory. Once we have some
379 memory, we will re-enable the interrupt. */
380 static inline void disable_si_irq(struct smi_info *smi_info)
382 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
383 start_disable_irq(smi_info);
384 smi_info->interrupt_disabled = 1;
388 static inline void enable_si_irq(struct smi_info *smi_info)
390 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
391 start_enable_irq(smi_info);
392 smi_info->interrupt_disabled = 0;
396 static void handle_flags(struct smi_info *smi_info)
399 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
400 /* Watchdog pre-timeout */
401 spin_lock(&smi_info->count_lock);
402 smi_info->watchdog_pretimeouts++;
403 spin_unlock(&smi_info->count_lock);
405 start_clear_flags(smi_info);
406 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
407 spin_unlock(&(smi_info->si_lock));
408 ipmi_smi_watchdog_pretimeout(smi_info->intf);
409 spin_lock(&(smi_info->si_lock));
410 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
411 /* Messages available. */
412 smi_info->curr_msg = ipmi_alloc_smi_msg();
413 if (!smi_info->curr_msg) {
414 disable_si_irq(smi_info);
415 smi_info->si_state = SI_NORMAL;
418 enable_si_irq(smi_info);
420 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
421 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
422 smi_info->curr_msg->data_size = 2;
424 smi_info->handlers->start_transaction(
426 smi_info->curr_msg->data,
427 smi_info->curr_msg->data_size);
428 smi_info->si_state = SI_GETTING_MESSAGES;
429 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
430 /* Events available. */
431 smi_info->curr_msg = ipmi_alloc_smi_msg();
432 if (!smi_info->curr_msg) {
433 disable_si_irq(smi_info);
434 smi_info->si_state = SI_NORMAL;
437 enable_si_irq(smi_info);
439 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
440 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
441 smi_info->curr_msg->data_size = 2;
443 smi_info->handlers->start_transaction(
445 smi_info->curr_msg->data,
446 smi_info->curr_msg->data_size);
447 smi_info->si_state = SI_GETTING_EVENTS;
448 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
449 smi_info->oem_data_avail_handler) {
450 if (smi_info->oem_data_avail_handler(smi_info))
453 smi_info->si_state = SI_NORMAL;
457 static void handle_transaction_done(struct smi_info *smi_info)
459 struct ipmi_smi_msg *msg;
464 printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
466 switch (smi_info->si_state) {
468 if (!smi_info->curr_msg)
471 smi_info->curr_msg->rsp_size
472 = smi_info->handlers->get_result(
474 smi_info->curr_msg->rsp,
475 IPMI_MAX_MSG_LENGTH);
477 /* Do this here becase deliver_recv_msg() releases the
478 lock, and a new message can be put in during the
479 time the lock is released. */
480 msg = smi_info->curr_msg;
481 smi_info->curr_msg = NULL;
482 deliver_recv_msg(smi_info, msg);
485 case SI_GETTING_FLAGS:
487 unsigned char msg[4];
490 /* We got the flags from the SMI, now handle them. */
491 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
493 /* Error fetching flags, just give up for
495 smi_info->si_state = SI_NORMAL;
496 } else if (len < 4) {
497 /* Hmm, no flags. That's technically illegal, but
498 don't use uninitialized data. */
499 smi_info->si_state = SI_NORMAL;
501 smi_info->msg_flags = msg[3];
502 handle_flags(smi_info);
507 case SI_CLEARING_FLAGS:
508 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
510 unsigned char msg[3];
512 /* We cleared the flags. */
513 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
515 /* Error clearing flags */
517 "ipmi_si: Error clearing flags: %2.2x\n",
520 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
521 start_enable_irq(smi_info);
523 smi_info->si_state = SI_NORMAL;
527 case SI_GETTING_EVENTS:
529 smi_info->curr_msg->rsp_size
530 = smi_info->handlers->get_result(
532 smi_info->curr_msg->rsp,
533 IPMI_MAX_MSG_LENGTH);
535 /* Do this here becase deliver_recv_msg() releases the
536 lock, and a new message can be put in during the
537 time the lock is released. */
538 msg = smi_info->curr_msg;
539 smi_info->curr_msg = NULL;
540 if (msg->rsp[2] != 0) {
541 /* Error getting event, probably done. */
544 /* Take off the event flag. */
545 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
546 handle_flags(smi_info);
548 spin_lock(&smi_info->count_lock);
550 spin_unlock(&smi_info->count_lock);
552 /* Do this before we deliver the message
553 because delivering the message releases the
554 lock and something else can mess with the
556 handle_flags(smi_info);
558 deliver_recv_msg(smi_info, msg);
563 case SI_GETTING_MESSAGES:
565 smi_info->curr_msg->rsp_size
566 = smi_info->handlers->get_result(
568 smi_info->curr_msg->rsp,
569 IPMI_MAX_MSG_LENGTH);
571 /* Do this here becase deliver_recv_msg() releases the
572 lock, and a new message can be put in during the
573 time the lock is released. */
574 msg = smi_info->curr_msg;
575 smi_info->curr_msg = NULL;
576 if (msg->rsp[2] != 0) {
577 /* Error getting event, probably done. */
580 /* Take off the msg flag. */
581 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
582 handle_flags(smi_info);
584 spin_lock(&smi_info->count_lock);
585 smi_info->incoming_messages++;
586 spin_unlock(&smi_info->count_lock);
588 /* Do this before we deliver the message
589 because delivering the message releases the
590 lock and something else can mess with the
592 handle_flags(smi_info);
594 deliver_recv_msg(smi_info, msg);
599 case SI_ENABLE_INTERRUPTS1:
601 unsigned char msg[4];
603 /* We got the flags from the SMI, now handle them. */
604 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
607 "ipmi_si: Could not enable interrupts"
608 ", failed get, using polled mode.\n");
609 smi_info->si_state = SI_NORMAL;
611 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
612 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
614 IPMI_BMC_RCV_MSG_INTR |
615 IPMI_BMC_EVT_MSG_INTR);
616 smi_info->handlers->start_transaction(
617 smi_info->si_sm, msg, 3);
618 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
623 case SI_ENABLE_INTERRUPTS2:
625 unsigned char msg[4];
627 /* We got the flags from the SMI, now handle them. */
628 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
631 "ipmi_si: Could not enable interrupts"
632 ", failed set, using polled mode.\n");
634 smi_info->si_state = SI_NORMAL;
638 case SI_DISABLE_INTERRUPTS1:
640 unsigned char msg[4];
642 /* We got the flags from the SMI, now handle them. */
643 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
646 "ipmi_si: Could not disable interrupts"
648 smi_info->si_state = SI_NORMAL;
650 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
651 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
653 ~(IPMI_BMC_RCV_MSG_INTR |
654 IPMI_BMC_EVT_MSG_INTR));
655 smi_info->handlers->start_transaction(
656 smi_info->si_sm, msg, 3);
657 smi_info->si_state = SI_DISABLE_INTERRUPTS2;
662 case SI_DISABLE_INTERRUPTS2:
664 unsigned char msg[4];
666 /* We got the flags from the SMI, now handle them. */
667 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
670 "ipmi_si: Could not disable interrupts"
673 smi_info->si_state = SI_NORMAL;
679 /* Called on timeouts and events. Timeouts should pass the elapsed
680 time, interrupts should pass in zero. Must be called with
681 si_lock held and interrupts disabled. */
682 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
685 enum si_sm_result si_sm_result;
688 /* There used to be a loop here that waited a little while
689 (around 25us) before giving up. That turned out to be
690 pointless, the minimum delays I was seeing were in the 300us
691 range, which is far too long to wait in an interrupt. So
692 we just run until the state machine tells us something
693 happened or it needs a delay. */
694 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
696 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
698 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
701 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
703 spin_lock(&smi_info->count_lock);
704 smi_info->complete_transactions++;
705 spin_unlock(&smi_info->count_lock);
707 handle_transaction_done(smi_info);
708 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
710 else if (si_sm_result == SI_SM_HOSED)
712 spin_lock(&smi_info->count_lock);
713 smi_info->hosed_count++;
714 spin_unlock(&smi_info->count_lock);
716 /* Do the before return_hosed_msg, because that
717 releases the lock. */
718 smi_info->si_state = SI_NORMAL;
719 if (smi_info->curr_msg != NULL) {
720 /* If we were handling a user message, format
721 a response to send to the upper layer to
722 tell it about the error. */
723 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
725 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
729 * We prefer handling attn over new messages. But don't do
730 * this if there is not yet an upper layer to handle anything.
732 if (likely(smi_info->intf) && si_sm_result == SI_SM_ATTN)
734 unsigned char msg[2];
736 spin_lock(&smi_info->count_lock);
737 smi_info->attentions++;
738 spin_unlock(&smi_info->count_lock);
740 /* Got a attn, send down a get message flags to see
741 what's causing it. It would be better to handle
742 this in the upper layer, but due to the way
743 interrupts work with the SMI, that's not really
745 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
746 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
748 smi_info->handlers->start_transaction(
749 smi_info->si_sm, msg, 2);
750 smi_info->si_state = SI_GETTING_FLAGS;
754 /* If we are currently idle, try to start the next message. */
755 if (si_sm_result == SI_SM_IDLE) {
756 spin_lock(&smi_info->count_lock);
758 spin_unlock(&smi_info->count_lock);
760 si_sm_result = start_next_msg(smi_info);
761 if (si_sm_result != SI_SM_IDLE)
765 if ((si_sm_result == SI_SM_IDLE)
766 && (atomic_read(&smi_info->req_events)))
768 /* We are idle and the upper layer requested that I fetch
770 atomic_set(&smi_info->req_events, 0);
772 smi_info->curr_msg = ipmi_alloc_smi_msg();
773 if (!smi_info->curr_msg)
776 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
777 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
778 smi_info->curr_msg->data_size = 2;
780 smi_info->handlers->start_transaction(
782 smi_info->curr_msg->data,
783 smi_info->curr_msg->data_size);
784 smi_info->si_state = SI_GETTING_EVENTS;
791 static void sender(void *send_info,
792 struct ipmi_smi_msg *msg,
795 struct smi_info *smi_info = send_info;
796 enum si_sm_result result;
802 if (atomic_read(&smi_info->stop_operation)) {
803 msg->rsp[0] = msg->data[0] | 4;
804 msg->rsp[1] = msg->data[1];
805 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
807 deliver_recv_msg(smi_info, msg);
813 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
816 if (smi_info->run_to_completion) {
818 * If we are running to completion, then throw it in
819 * the list and run transactions until everything is
820 * clear. Priority doesn't matter here.
824 * Run to completion means we are single-threaded, no
827 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
829 result = smi_event_handler(smi_info, 0);
830 while (result != SI_SM_IDLE) {
831 udelay(SI_SHORT_TIMEOUT_USEC);
832 result = smi_event_handler(smi_info,
833 SI_SHORT_TIMEOUT_USEC);
838 spin_lock_irqsave(&smi_info->msg_lock, flags);
840 list_add_tail(&msg->link, &smi_info->hp_xmit_msgs);
842 list_add_tail(&msg->link, &smi_info->xmit_msgs);
843 spin_unlock_irqrestore(&smi_info->msg_lock, flags);
845 spin_lock_irqsave(&smi_info->si_lock, flags);
846 if ((smi_info->si_state == SI_NORMAL)
847 && (smi_info->curr_msg == NULL))
849 start_next_msg(smi_info);
851 spin_unlock_irqrestore(&smi_info->si_lock, flags);
854 static void set_run_to_completion(void *send_info, int i_run_to_completion)
856 struct smi_info *smi_info = send_info;
857 enum si_sm_result result;
859 smi_info->run_to_completion = i_run_to_completion;
860 if (i_run_to_completion) {
861 result = smi_event_handler(smi_info, 0);
862 while (result != SI_SM_IDLE) {
863 udelay(SI_SHORT_TIMEOUT_USEC);
864 result = smi_event_handler(smi_info,
865 SI_SHORT_TIMEOUT_USEC);
870 static int ipmi_thread(void *data)
872 struct smi_info *smi_info = data;
874 enum si_sm_result smi_result;
876 set_user_nice(current, 19);
877 while (!kthread_should_stop()) {
878 spin_lock_irqsave(&(smi_info->si_lock), flags);
879 smi_result = smi_event_handler(smi_info, 0);
880 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
881 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
884 else if (smi_result == SI_SM_CALL_WITH_DELAY)
887 schedule_timeout_interruptible(1);
893 static void poll(void *send_info)
895 struct smi_info *smi_info = send_info;
899 * Make sure there is some delay in the poll loop so we can
900 * drive time forward and timeout things.
903 spin_lock_irqsave(&smi_info->si_lock, flags);
904 smi_event_handler(smi_info, 10);
905 spin_unlock_irqrestore(&smi_info->si_lock, flags);
908 static void request_events(void *send_info)
910 struct smi_info *smi_info = send_info;
912 if (atomic_read(&smi_info->stop_operation))
915 atomic_set(&smi_info->req_events, 1);
918 static int initialized;
920 static void smi_timeout(unsigned long data)
922 struct smi_info *smi_info = (struct smi_info *) data;
923 enum si_sm_result smi_result;
925 unsigned long jiffies_now;
931 spin_lock_irqsave(&(smi_info->si_lock), flags);
934 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
936 jiffies_now = jiffies;
937 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
938 * SI_USEC_PER_JIFFY);
939 smi_result = smi_event_handler(smi_info, time_diff);
941 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
943 smi_info->last_timeout_jiffies = jiffies_now;
945 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
946 /* Running with interrupts, only do long timeouts. */
947 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
948 spin_lock_irqsave(&smi_info->count_lock, flags);
949 smi_info->long_timeouts++;
950 spin_unlock_irqrestore(&smi_info->count_lock, flags);
954 /* If the state machine asks for a short delay, then shorten
955 the timer timeout. */
956 if (smi_result == SI_SM_CALL_WITH_DELAY) {
957 spin_lock_irqsave(&smi_info->count_lock, flags);
958 smi_info->short_timeouts++;
959 spin_unlock_irqrestore(&smi_info->count_lock, flags);
960 smi_info->si_timer.expires = jiffies + 1;
962 spin_lock_irqsave(&smi_info->count_lock, flags);
963 smi_info->long_timeouts++;
964 spin_unlock_irqrestore(&smi_info->count_lock, flags);
965 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
969 add_timer(&(smi_info->si_timer));
972 static irqreturn_t si_irq_handler(int irq, void *data)
974 struct smi_info *smi_info = data;
980 spin_lock_irqsave(&(smi_info->si_lock), flags);
982 spin_lock(&smi_info->count_lock);
983 smi_info->interrupts++;
984 spin_unlock(&smi_info->count_lock);
988 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
990 smi_event_handler(smi_info, 0);
991 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
995 static irqreturn_t si_bt_irq_handler(int irq, void *data)
997 struct smi_info *smi_info = data;
998 /* We need to clear the IRQ flag for the BT interface. */
999 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
1000 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
1001 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1002 return si_irq_handler(irq, data);
1005 static int smi_start_processing(void *send_info,
1008 struct smi_info *new_smi = send_info;
1011 new_smi->intf = intf;
1013 /* Try to claim any interrupts. */
1014 if (new_smi->irq_setup)
1015 new_smi->irq_setup(new_smi);
1017 /* Set up the timer that drives the interface. */
1018 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
1019 new_smi->last_timeout_jiffies = jiffies;
1020 mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
1023 * Check if the user forcefully enabled the daemon.
1025 if (new_smi->intf_num < num_force_kipmid)
1026 enable = force_kipmid[new_smi->intf_num];
1028 * The BT interface is efficient enough to not need a thread,
1029 * and there is no need for a thread if we have interrupts.
1031 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
1035 new_smi->thread = kthread_run(ipmi_thread, new_smi,
1036 "kipmi%d", new_smi->intf_num);
1037 if (IS_ERR(new_smi->thread)) {
1038 printk(KERN_NOTICE "ipmi_si_intf: Could not start"
1039 " kernel thread due to error %ld, only using"
1040 " timers to drive the interface\n",
1041 PTR_ERR(new_smi->thread));
1042 new_smi->thread = NULL;
1049 static void set_maintenance_mode(void *send_info, int enable)
1051 struct smi_info *smi_info = send_info;
1054 atomic_set(&smi_info->req_events, 0);
1057 static struct ipmi_smi_handlers handlers =
1059 .owner = THIS_MODULE,
1060 .start_processing = smi_start_processing,
1062 .request_events = request_events,
1063 .set_maintenance_mode = set_maintenance_mode,
1064 .set_run_to_completion = set_run_to_completion,
1068 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1069 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
1071 static LIST_HEAD(smi_infos);
1072 static DEFINE_MUTEX(smi_infos_lock);
1073 static int smi_num; /* Used to sequence the SMIs */
1075 #define DEFAULT_REGSPACING 1
1076 #define DEFAULT_REGSIZE 1
1078 static int si_trydefaults = 1;
1079 static char *si_type[SI_MAX_PARMS];
1080 #define MAX_SI_TYPE_STR 30
1081 static char si_type_str[MAX_SI_TYPE_STR];
1082 static unsigned long addrs[SI_MAX_PARMS];
1083 static unsigned int num_addrs;
1084 static unsigned int ports[SI_MAX_PARMS];
1085 static unsigned int num_ports;
1086 static int irqs[SI_MAX_PARMS];
1087 static unsigned int num_irqs;
1088 static int regspacings[SI_MAX_PARMS];
1089 static unsigned int num_regspacings;
1090 static int regsizes[SI_MAX_PARMS];
1091 static unsigned int num_regsizes;
1092 static int regshifts[SI_MAX_PARMS];
1093 static unsigned int num_regshifts;
1094 static int slave_addrs[SI_MAX_PARMS];
1095 static unsigned int num_slave_addrs;
1097 #define IPMI_IO_ADDR_SPACE 0
1098 #define IPMI_MEM_ADDR_SPACE 1
1099 static char *addr_space_to_str[] = { "i/o", "mem" };
1101 static int hotmod_handler(const char *val, struct kernel_param *kp);
1103 module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
1104 MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See"
1105 " Documentation/IPMI.txt in the kernel sources for the"
1108 module_param_named(trydefaults, si_trydefaults, bool, 0);
1109 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1110 " default scan of the KCS and SMIC interface at the standard"
1112 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1113 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1114 " interface separated by commas. The types are 'kcs',"
1115 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1116 " the first interface to kcs and the second to bt");
1117 module_param_array(addrs, ulong, &num_addrs, 0);
1118 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1119 " addresses separated by commas. Only use if an interface"
1120 " is in memory. Otherwise, set it to zero or leave"
1122 module_param_array(ports, uint, &num_ports, 0);
1123 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1124 " addresses separated by commas. Only use if an interface"
1125 " is a port. Otherwise, set it to zero or leave"
1127 module_param_array(irqs, int, &num_irqs, 0);
1128 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1129 " addresses separated by commas. Only use if an interface"
1130 " has an interrupt. Otherwise, set it to zero or leave"
1132 module_param_array(regspacings, int, &num_regspacings, 0);
1133 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1134 " and each successive register used by the interface. For"
1135 " instance, if the start address is 0xca2 and the spacing"
1136 " is 2, then the second address is at 0xca4. Defaults"
1138 module_param_array(regsizes, int, &num_regsizes, 0);
1139 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1140 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1141 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1142 " the 8-bit IPMI register has to be read from a larger"
1144 module_param_array(regshifts, int, &num_regshifts, 0);
1145 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1146 " IPMI register, in bits. For instance, if the data"
1147 " is read from a 32-bit word and the IPMI data is in"
1148 " bit 8-15, then the shift would be 8");
1149 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1150 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1151 " the controller. Normally this is 0x20, but can be"
1152 " overridden by this parm. This is an array indexed"
1153 " by interface number.");
1154 module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1155 MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1156 " disabled(0). Normally the IPMI driver auto-detects"
1157 " this, but the value may be overridden by this parm.");
1158 module_param(unload_when_empty, int, 0);
1159 MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
1160 " specified or found, default is 1. Setting to 0"
1161 " is useful for hot add of devices using hotmod.");
1164 static void std_irq_cleanup(struct smi_info *info)
1166 if (info->si_type == SI_BT)
1167 /* Disable the interrupt in the BT interface. */
1168 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1169 free_irq(info->irq, info);
1172 static int std_irq_setup(struct smi_info *info)
1179 if (info->si_type == SI_BT) {
1180 rv = request_irq(info->irq,
1182 IRQF_SHARED | IRQF_DISABLED,
1186 /* Enable the interrupt in the BT interface. */
1187 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1188 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1190 rv = request_irq(info->irq,
1192 IRQF_SHARED | IRQF_DISABLED,
1197 "ipmi_si: %s unable to claim interrupt %d,"
1198 " running polled\n",
1199 DEVICE_NAME, info->irq);
1202 info->irq_cleanup = std_irq_cleanup;
1203 printk(" Using irq %d\n", info->irq);
1209 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1211 unsigned int addr = io->addr_data;
1213 return inb(addr + (offset * io->regspacing));
1216 static void port_outb(struct si_sm_io *io, unsigned int offset,
1219 unsigned int addr = io->addr_data;
1221 outb(b, addr + (offset * io->regspacing));
1224 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1226 unsigned int addr = io->addr_data;
1228 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1231 static void port_outw(struct si_sm_io *io, unsigned int offset,
1234 unsigned int addr = io->addr_data;
1236 outw(b << io->regshift, addr + (offset * io->regspacing));
1239 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1241 unsigned int addr = io->addr_data;
1243 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1246 static void port_outl(struct si_sm_io *io, unsigned int offset,
1249 unsigned int addr = io->addr_data;
1251 outl(b << io->regshift, addr+(offset * io->regspacing));
1254 static void port_cleanup(struct smi_info *info)
1256 unsigned int addr = info->io.addr_data;
1260 for (idx = 0; idx < info->io_size; idx++) {
1261 release_region(addr + idx * info->io.regspacing,
1267 static int port_setup(struct smi_info *info)
1269 unsigned int addr = info->io.addr_data;
1275 info->io_cleanup = port_cleanup;
1277 /* Figure out the actual inb/inw/inl/etc routine to use based
1278 upon the register size. */
1279 switch (info->io.regsize) {
1281 info->io.inputb = port_inb;
1282 info->io.outputb = port_outb;
1285 info->io.inputb = port_inw;
1286 info->io.outputb = port_outw;
1289 info->io.inputb = port_inl;
1290 info->io.outputb = port_outl;
1293 printk("ipmi_si: Invalid register size: %d\n",
1298 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1299 * tables. This causes problems when trying to register the
1300 * entire I/O region. Therefore we must register each I/O
1303 for (idx = 0; idx < info->io_size; idx++) {
1304 if (request_region(addr + idx * info->io.regspacing,
1305 info->io.regsize, DEVICE_NAME) == NULL) {
1306 /* Undo allocations */
1308 release_region(addr + idx * info->io.regspacing,
1317 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1319 return readb((io->addr)+(offset * io->regspacing));
1322 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1325 writeb(b, (io->addr)+(offset * io->regspacing));
1328 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1330 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1334 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1337 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1340 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1342 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1346 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1349 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1353 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1355 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1359 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1362 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1366 static void mem_cleanup(struct smi_info *info)
1368 unsigned long addr = info->io.addr_data;
1371 if (info->io.addr) {
1372 iounmap(info->io.addr);
1374 mapsize = ((info->io_size * info->io.regspacing)
1375 - (info->io.regspacing - info->io.regsize));
1377 release_mem_region(addr, mapsize);
1381 static int mem_setup(struct smi_info *info)
1383 unsigned long addr = info->io.addr_data;
1389 info->io_cleanup = mem_cleanup;
1391 /* Figure out the actual readb/readw/readl/etc routine to use based
1392 upon the register size. */
1393 switch (info->io.regsize) {
1395 info->io.inputb = intf_mem_inb;
1396 info->io.outputb = intf_mem_outb;
1399 info->io.inputb = intf_mem_inw;
1400 info->io.outputb = intf_mem_outw;
1403 info->io.inputb = intf_mem_inl;
1404 info->io.outputb = intf_mem_outl;
1408 info->io.inputb = mem_inq;
1409 info->io.outputb = mem_outq;
1413 printk("ipmi_si: Invalid register size: %d\n",
1418 /* Calculate the total amount of memory to claim. This is an
1419 * unusual looking calculation, but it avoids claiming any
1420 * more memory than it has to. It will claim everything
1421 * between the first address to the end of the last full
1423 mapsize = ((info->io_size * info->io.regspacing)
1424 - (info->io.regspacing - info->io.regsize));
1426 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1429 info->io.addr = ioremap(addr, mapsize);
1430 if (info->io.addr == NULL) {
1431 release_mem_region(addr, mapsize);
1438 * Parms come in as <op1>[:op2[:op3...]]. ops are:
1439 * add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
1447 enum hotmod_op { HM_ADD, HM_REMOVE };
1448 struct hotmod_vals {
1452 static struct hotmod_vals hotmod_ops[] = {
1454 { "remove", HM_REMOVE },
1457 static struct hotmod_vals hotmod_si[] = {
1459 { "smic", SI_SMIC },
1463 static struct hotmod_vals hotmod_as[] = {
1464 { "mem", IPMI_MEM_ADDR_SPACE },
1465 { "i/o", IPMI_IO_ADDR_SPACE },
1469 static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
1474 s = strchr(*curr, ',');
1476 printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
1481 for (i = 0; hotmod_ops[i].name; i++) {
1482 if (strcmp(*curr, v[i].name) == 0) {
1489 printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
1493 static int check_hotmod_int_op(const char *curr, const char *option,
1494 const char *name, int *val)
1498 if (strcmp(curr, name) == 0) {
1500 printk(KERN_WARNING PFX
1501 "No option given for '%s'\n",
1505 *val = simple_strtoul(option, &n, 0);
1506 if ((*n != '\0') || (*option == '\0')) {
1507 printk(KERN_WARNING PFX
1508 "Bad option given for '%s'\n",
1517 static int hotmod_handler(const char *val, struct kernel_param *kp)
1519 char *str = kstrdup(val, GFP_KERNEL);
1521 char *next, *curr, *s, *n, *o;
1523 enum si_type si_type;
1533 struct smi_info *info;
1538 /* Kill any trailing spaces, as we can get a "\n" from echo. */
1541 while ((ival >= 0) && isspace(str[ival])) {
1546 for (curr = str; curr; curr = next) {
1553 next = strchr(curr, ':');
1559 rv = parse_str(hotmod_ops, &ival, "operation", &curr);
1564 rv = parse_str(hotmod_si, &ival, "interface type", &curr);
1569 rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
1573 s = strchr(curr, ',');
1578 addr = simple_strtoul(curr, &n, 0);
1579 if ((*n != '\0') || (*curr == '\0')) {
1580 printk(KERN_WARNING PFX "Invalid hotmod address"
1587 s = strchr(curr, ',');
1592 o = strchr(curr, '=');
1597 rv = check_hotmod_int_op(curr, o, "rsp", ®spacing);
1602 rv = check_hotmod_int_op(curr, o, "rsi", ®size);
1607 rv = check_hotmod_int_op(curr, o, "rsh", ®shift);
1612 rv = check_hotmod_int_op(curr, o, "irq", &irq);
1617 rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
1624 printk(KERN_WARNING PFX
1625 "Invalid hotmod option '%s'\n",
1631 info = kzalloc(sizeof(*info), GFP_KERNEL);
1637 info->addr_source = "hotmod";
1638 info->si_type = si_type;
1639 info->io.addr_data = addr;
1640 info->io.addr_type = addr_space;
1641 if (addr_space == IPMI_MEM_ADDR_SPACE)
1642 info->io_setup = mem_setup;
1644 info->io_setup = port_setup;
1646 info->io.addr = NULL;
1647 info->io.regspacing = regspacing;
1648 if (!info->io.regspacing)
1649 info->io.regspacing = DEFAULT_REGSPACING;
1650 info->io.regsize = regsize;
1651 if (!info->io.regsize)
1652 info->io.regsize = DEFAULT_REGSPACING;
1653 info->io.regshift = regshift;
1656 info->irq_setup = std_irq_setup;
1657 info->slave_addr = ipmb;
1662 struct smi_info *e, *tmp_e;
1664 mutex_lock(&smi_infos_lock);
1665 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
1666 if (e->io.addr_type != addr_space)
1668 if (e->si_type != si_type)
1670 if (e->io.addr_data == addr)
1673 mutex_unlock(&smi_infos_lock);
1682 static __devinit void hardcode_find_bmc(void)
1685 struct smi_info *info;
1687 for (i = 0; i < SI_MAX_PARMS; i++) {
1688 if (!ports[i] && !addrs[i])
1691 info = kzalloc(sizeof(*info), GFP_KERNEL);
1695 info->addr_source = "hardcoded";
1697 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1698 info->si_type = SI_KCS;
1699 } else if (strcmp(si_type[i], "smic") == 0) {
1700 info->si_type = SI_SMIC;
1701 } else if (strcmp(si_type[i], "bt") == 0) {
1702 info->si_type = SI_BT;
1705 "ipmi_si: Interface type specified "
1706 "for interface %d, was invalid: %s\n",
1714 info->io_setup = port_setup;
1715 info->io.addr_data = ports[i];
1716 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1717 } else if (addrs[i]) {
1719 info->io_setup = mem_setup;
1720 info->io.addr_data = addrs[i];
1721 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1724 "ipmi_si: Interface type specified "
1725 "for interface %d, "
1726 "but port and address were not set or "
1727 "set to zero.\n", i);
1732 info->io.addr = NULL;
1733 info->io.regspacing = regspacings[i];
1734 if (!info->io.regspacing)
1735 info->io.regspacing = DEFAULT_REGSPACING;
1736 info->io.regsize = regsizes[i];
1737 if (!info->io.regsize)
1738 info->io.regsize = DEFAULT_REGSPACING;
1739 info->io.regshift = regshifts[i];
1740 info->irq = irqs[i];
1742 info->irq_setup = std_irq_setup;
1750 #include <linux/acpi.h>
1752 /* Once we get an ACPI failure, we don't try any more, because we go
1753 through the tables sequentially. Once we don't find a table, there
1755 static int acpi_failure;
1757 /* For GPE-type interrupts. */
1758 static u32 ipmi_acpi_gpe(void *context)
1760 struct smi_info *smi_info = context;
1761 unsigned long flags;
1766 spin_lock_irqsave(&(smi_info->si_lock), flags);
1768 spin_lock(&smi_info->count_lock);
1769 smi_info->interrupts++;
1770 spin_unlock(&smi_info->count_lock);
1773 do_gettimeofday(&t);
1774 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1776 smi_event_handler(smi_info, 0);
1777 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1779 return ACPI_INTERRUPT_HANDLED;
1782 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1787 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1790 static int acpi_gpe_irq_setup(struct smi_info *info)
1797 /* FIXME - is level triggered right? */
1798 status = acpi_install_gpe_handler(NULL,
1800 ACPI_GPE_LEVEL_TRIGGERED,
1803 if (status != AE_OK) {
1805 "ipmi_si: %s unable to claim ACPI GPE %d,"
1806 " running polled\n",
1807 DEVICE_NAME, info->irq);
1811 info->irq_cleanup = acpi_gpe_irq_cleanup;
1812 printk(" Using ACPI GPE %d\n", info->irq);
1819 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1830 s8 CreatorRevision[4];
1833 s16 SpecificationRevision;
1836 * Bit 0 - SCI interrupt supported
1837 * Bit 1 - I/O APIC/SAPIC
1841 /* If bit 0 of InterruptType is set, then this is the SCI
1842 interrupt in the GPEx_STS register. */
1847 /* If bit 1 of InterruptType is set, then this is the I/O
1848 APIC/SAPIC interrupt. */
1849 u32 GlobalSystemInterrupt;
1851 /* The actual register address. */
1852 struct acpi_generic_address addr;
1856 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1859 static __devinit int try_init_acpi(struct SPMITable *spmi)
1861 struct smi_info *info;
1864 if (spmi->IPMIlegacy != 1) {
1865 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1869 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1870 addr_space = IPMI_MEM_ADDR_SPACE;
1872 addr_space = IPMI_IO_ADDR_SPACE;
1874 info = kzalloc(sizeof(*info), GFP_KERNEL);
1876 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1880 info->addr_source = "ACPI";
1882 /* Figure out the interface type. */
1883 switch (spmi->InterfaceType)
1886 info->si_type = SI_KCS;
1889 info->si_type = SI_SMIC;
1892 info->si_type = SI_BT;
1895 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1896 spmi->InterfaceType);
1901 if (spmi->InterruptType & 1) {
1902 /* We've got a GPE interrupt. */
1903 info->irq = spmi->GPE;
1904 info->irq_setup = acpi_gpe_irq_setup;
1905 } else if (spmi->InterruptType & 2) {
1906 /* We've got an APIC/SAPIC interrupt. */
1907 info->irq = spmi->GlobalSystemInterrupt;
1908 info->irq_setup = std_irq_setup;
1910 /* Use the default interrupt setting. */
1912 info->irq_setup = NULL;
1915 if (spmi->addr.bit_width) {
1916 /* A (hopefully) properly formed register bit width. */
1917 info->io.regspacing = spmi->addr.bit_width / 8;
1919 info->io.regspacing = DEFAULT_REGSPACING;
1921 info->io.regsize = info->io.regspacing;
1922 info->io.regshift = spmi->addr.bit_offset;
1924 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1925 info->io_setup = mem_setup;
1926 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1927 } else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1928 info->io_setup = port_setup;
1929 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1932 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1935 info->io.addr_data = spmi->addr.address;
1942 static __devinit void acpi_find_bmc(void)
1945 struct SPMITable *spmi;
1954 for (i = 0; ; i++) {
1955 status = acpi_get_table(ACPI_SIG_SPMI, i+1,
1956 (struct acpi_table_header **)&spmi);
1957 if (status != AE_OK)
1960 try_init_acpi(spmi);
1966 struct dmi_ipmi_data
1970 unsigned long base_addr;
1976 static int __devinit decode_dmi(const struct dmi_header *dm,
1977 struct dmi_ipmi_data *dmi)
1979 const u8 *data = (const u8 *)dm;
1980 unsigned long base_addr;
1982 u8 len = dm->length;
1984 dmi->type = data[4];
1986 memcpy(&base_addr, data+8, sizeof(unsigned long));
1988 if (base_addr & 1) {
1990 base_addr &= 0xFFFE;
1991 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1995 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1997 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1999 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
2001 dmi->irq = data[0x11];
2003 /* The top two bits of byte 0x10 hold the register spacing. */
2004 reg_spacing = (data[0x10] & 0xC0) >> 6;
2005 switch(reg_spacing){
2006 case 0x00: /* Byte boundaries */
2009 case 0x01: /* 32-bit boundaries */
2012 case 0x02: /* 16-byte boundaries */
2016 /* Some other interface, just ignore it. */
2021 /* Note that technically, the lower bit of the base
2022 * address should be 1 if the address is I/O and 0 if
2023 * the address is in memory. So many systems get that
2024 * wrong (and all that I have seen are I/O) so we just
2025 * ignore that bit and assume I/O. Systems that use
2026 * memory should use the newer spec, anyway. */
2027 dmi->base_addr = base_addr & 0xfffe;
2028 dmi->addr_space = IPMI_IO_ADDR_SPACE;
2032 dmi->slave_addr = data[6];
2037 static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
2039 struct smi_info *info;
2041 info = kzalloc(sizeof(*info), GFP_KERNEL);
2044 "ipmi_si: Could not allocate SI data\n");
2048 info->addr_source = "SMBIOS";
2050 switch (ipmi_data->type) {
2051 case 0x01: /* KCS */
2052 info->si_type = SI_KCS;
2054 case 0x02: /* SMIC */
2055 info->si_type = SI_SMIC;
2058 info->si_type = SI_BT;
2065 switch (ipmi_data->addr_space) {
2066 case IPMI_MEM_ADDR_SPACE:
2067 info->io_setup = mem_setup;
2068 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2071 case IPMI_IO_ADDR_SPACE:
2072 info->io_setup = port_setup;
2073 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2079 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
2080 ipmi_data->addr_space);
2083 info->io.addr_data = ipmi_data->base_addr;
2085 info->io.regspacing = ipmi_data->offset;
2086 if (!info->io.regspacing)
2087 info->io.regspacing = DEFAULT_REGSPACING;
2088 info->io.regsize = DEFAULT_REGSPACING;
2089 info->io.regshift = 0;
2091 info->slave_addr = ipmi_data->slave_addr;
2093 info->irq = ipmi_data->irq;
2095 info->irq_setup = std_irq_setup;
2100 static void __devinit dmi_find_bmc(void)
2102 const struct dmi_device *dev = NULL;
2103 struct dmi_ipmi_data data;
2106 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
2107 memset(&data, 0, sizeof(data));
2108 rv = decode_dmi((const struct dmi_header *) dev->device_data,
2111 try_init_dmi(&data);
2114 #endif /* CONFIG_DMI */
2118 #define PCI_ERMC_CLASSCODE 0x0C0700
2119 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
2120 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
2121 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
2122 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
2123 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
2125 #define PCI_HP_VENDOR_ID 0x103C
2126 #define PCI_MMC_DEVICE_ID 0x121A
2127 #define PCI_MMC_ADDR_CW 0x10
2129 static void ipmi_pci_cleanup(struct smi_info *info)
2131 struct pci_dev *pdev = info->addr_source_data;
2133 pci_disable_device(pdev);
2136 static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
2137 const struct pci_device_id *ent)
2140 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
2141 struct smi_info *info;
2142 int first_reg_offset = 0;
2144 info = kzalloc(sizeof(*info), GFP_KERNEL);
2148 info->addr_source = "PCI";
2150 switch (class_type) {
2151 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
2152 info->si_type = SI_SMIC;
2155 case PCI_ERMC_CLASSCODE_TYPE_KCS:
2156 info->si_type = SI_KCS;
2159 case PCI_ERMC_CLASSCODE_TYPE_BT:
2160 info->si_type = SI_BT;
2165 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
2166 pci_name(pdev), class_type);
2170 rv = pci_enable_device(pdev);
2172 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
2178 info->addr_source_cleanup = ipmi_pci_cleanup;
2179 info->addr_source_data = pdev;
2181 if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
2182 first_reg_offset = 1;
2184 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2185 info->io_setup = port_setup;
2186 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2188 info->io_setup = mem_setup;
2189 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2191 info->io.addr_data = pci_resource_start(pdev, 0);
2193 info->io.regspacing = DEFAULT_REGSPACING;
2194 info->io.regsize = DEFAULT_REGSPACING;
2195 info->io.regshift = 0;
2197 info->irq = pdev->irq;
2199 info->irq_setup = std_irq_setup;
2201 info->dev = &pdev->dev;
2202 pci_set_drvdata(pdev, info);
2204 return try_smi_init(info);
2207 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
2209 struct smi_info *info = pci_get_drvdata(pdev);
2210 cleanup_one_si(info);
2214 static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
2219 static int ipmi_pci_resume(struct pci_dev *pdev)
2225 static struct pci_device_id ipmi_pci_devices[] = {
2226 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
2227 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
2230 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
2232 static struct pci_driver ipmi_pci_driver = {
2233 .name = DEVICE_NAME,
2234 .id_table = ipmi_pci_devices,
2235 .probe = ipmi_pci_probe,
2236 .remove = __devexit_p(ipmi_pci_remove),
2238 .suspend = ipmi_pci_suspend,
2239 .resume = ipmi_pci_resume,
2242 #endif /* CONFIG_PCI */
2245 #ifdef CONFIG_PPC_OF
2246 static int __devinit ipmi_of_probe(struct of_device *dev,
2247 const struct of_device_id *match)
2249 struct smi_info *info;
2250 struct resource resource;
2251 const int *regsize, *regspacing, *regshift;
2252 struct device_node *np = dev->node;
2256 dev_info(&dev->dev, PFX "probing via device tree\n");
2258 ret = of_address_to_resource(np, 0, &resource);
2260 dev_warn(&dev->dev, PFX "invalid address from OF\n");
2264 regsize = of_get_property(np, "reg-size", &proplen);
2265 if (regsize && proplen != 4) {
2266 dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
2270 regspacing = of_get_property(np, "reg-spacing", &proplen);
2271 if (regspacing && proplen != 4) {
2272 dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
2276 regshift = of_get_property(np, "reg-shift", &proplen);
2277 if (regshift && proplen != 4) {
2278 dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
2282 info = kzalloc(sizeof(*info), GFP_KERNEL);
2286 PFX "could not allocate memory for OF probe\n");
2290 info->si_type = (enum si_type) match->data;
2291 info->addr_source = "device-tree";
2292 info->io_setup = mem_setup;
2293 info->irq_setup = std_irq_setup;
2295 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2296 info->io.addr_data = resource.start;
2298 info->io.regsize = regsize ? *regsize : DEFAULT_REGSIZE;
2299 info->io.regspacing = regspacing ? *regspacing : DEFAULT_REGSPACING;
2300 info->io.regshift = regshift ? *regshift : 0;
2302 info->irq = irq_of_parse_and_map(dev->node, 0);
2303 info->dev = &dev->dev;
2305 dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %x\n",
2306 info->io.addr_data, info->io.regsize, info->io.regspacing,
2309 dev->dev.driver_data = (void*) info;
2311 return try_smi_init(info);
2314 static int __devexit ipmi_of_remove(struct of_device *dev)
2316 cleanup_one_si(dev->dev.driver_data);
2320 static struct of_device_id ipmi_match[] =
2322 { .type = "ipmi", .compatible = "ipmi-kcs", .data = (void *)(unsigned long) SI_KCS },
2323 { .type = "ipmi", .compatible = "ipmi-smic", .data = (void *)(unsigned long) SI_SMIC },
2324 { .type = "ipmi", .compatible = "ipmi-bt", .data = (void *)(unsigned long) SI_BT },
2328 static struct of_platform_driver ipmi_of_platform_driver =
2331 .match_table = ipmi_match,
2332 .probe = ipmi_of_probe,
2333 .remove = __devexit_p(ipmi_of_remove),
2335 #endif /* CONFIG_PPC_OF */
2338 static int try_get_dev_id(struct smi_info *smi_info)
2340 unsigned char msg[2];
2341 unsigned char *resp;
2342 unsigned long resp_len;
2343 enum si_sm_result smi_result;
2346 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2350 /* Do a Get Device ID command, since it comes back with some
2352 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2353 msg[1] = IPMI_GET_DEVICE_ID_CMD;
2354 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2356 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
2359 if (smi_result == SI_SM_CALL_WITH_DELAY ||
2360 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
2361 schedule_timeout_uninterruptible(1);
2362 smi_result = smi_info->handlers->event(
2363 smi_info->si_sm, 100);
2365 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
2367 smi_result = smi_info->handlers->event(
2368 smi_info->si_sm, 0);
2373 if (smi_result == SI_SM_HOSED) {
2374 /* We couldn't get the state machine to run, so whatever's at
2375 the port is probably not an IPMI SMI interface. */
2380 /* Otherwise, we got some data. */
2381 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2382 resp, IPMI_MAX_MSG_LENGTH);
2384 /* Check and record info from the get device id, in case we need it. */
2385 rv = ipmi_demangle_device_id(resp, resp_len, &smi_info->device_id);
2392 static int type_file_read_proc(char *page, char **start, off_t off,
2393 int count, int *eof, void *data)
2395 struct smi_info *smi = data;
2397 return sprintf(page, "%s\n", si_to_str[smi->si_type]);
2400 static int stat_file_read_proc(char *page, char **start, off_t off,
2401 int count, int *eof, void *data)
2403 char *out = (char *) page;
2404 struct smi_info *smi = data;
2406 out += sprintf(out, "interrupts_enabled: %d\n",
2407 smi->irq && !smi->interrupt_disabled);
2408 out += sprintf(out, "short_timeouts: %ld\n",
2409 smi->short_timeouts);
2410 out += sprintf(out, "long_timeouts: %ld\n",
2411 smi->long_timeouts);
2412 out += sprintf(out, "timeout_restarts: %ld\n",
2413 smi->timeout_restarts);
2414 out += sprintf(out, "idles: %ld\n",
2416 out += sprintf(out, "interrupts: %ld\n",
2418 out += sprintf(out, "attentions: %ld\n",
2420 out += sprintf(out, "flag_fetches: %ld\n",
2422 out += sprintf(out, "hosed_count: %ld\n",
2424 out += sprintf(out, "complete_transactions: %ld\n",
2425 smi->complete_transactions);
2426 out += sprintf(out, "events: %ld\n",
2428 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
2429 smi->watchdog_pretimeouts);
2430 out += sprintf(out, "incoming_messages: %ld\n",
2431 smi->incoming_messages);
2436 static int param_read_proc(char *page, char **start, off_t off,
2437 int count, int *eof, void *data)
2439 struct smi_info *smi = data;
2441 return sprintf(page,
2442 "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
2443 si_to_str[smi->si_type],
2444 addr_space_to_str[smi->io.addr_type],
2454 * oem_data_avail_to_receive_msg_avail
2455 * @info - smi_info structure with msg_flags set
2457 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2458 * Returns 1 indicating need to re-run handle_flags().
2460 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2462 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2468 * setup_dell_poweredge_oem_data_handler
2469 * @info - smi_info.device_id must be populated
2471 * Systems that match, but have firmware version < 1.40 may assert
2472 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2473 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2474 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2475 * as RECEIVE_MSG_AVAIL instead.
2477 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2478 * assert the OEM[012] bits, and if it did, the driver would have to
2479 * change to handle that properly, we don't actually check for the
2481 * Device ID = 0x20 BMC on PowerEdge 8G servers
2482 * Device Revision = 0x80
2483 * Firmware Revision1 = 0x01 BMC version 1.40
2484 * Firmware Revision2 = 0x40 BCD encoded
2485 * IPMI Version = 0x51 IPMI 1.5
2486 * Manufacturer ID = A2 02 00 Dell IANA
2488 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2489 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2492 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2493 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2494 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2495 #define DELL_IANA_MFR_ID 0x0002a2
2496 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2498 struct ipmi_device_id *id = &smi_info->device_id;
2499 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
2500 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2501 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2502 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
2503 smi_info->oem_data_avail_handler =
2504 oem_data_avail_to_receive_msg_avail;
2506 else if (ipmi_version_major(id) < 1 ||
2507 (ipmi_version_major(id) == 1 &&
2508 ipmi_version_minor(id) < 5)) {
2509 smi_info->oem_data_avail_handler =
2510 oem_data_avail_to_receive_msg_avail;
2515 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2516 static void return_hosed_msg_badsize(struct smi_info *smi_info)
2518 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2520 /* Make it a reponse */
2521 msg->rsp[0] = msg->data[0] | 4;
2522 msg->rsp[1] = msg->data[1];
2523 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2525 smi_info->curr_msg = NULL;
2526 deliver_recv_msg(smi_info, msg);
2530 * dell_poweredge_bt_xaction_handler
2531 * @info - smi_info.device_id must be populated
2533 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2534 * not respond to a Get SDR command if the length of the data
2535 * requested is exactly 0x3A, which leads to command timeouts and no
2536 * data returned. This intercepts such commands, and causes userspace
2537 * callers to try again with a different-sized buffer, which succeeds.
2540 #define STORAGE_NETFN 0x0A
2541 #define STORAGE_CMD_GET_SDR 0x23
2542 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2543 unsigned long unused,
2546 struct smi_info *smi_info = in;
2547 unsigned char *data = smi_info->curr_msg->data;
2548 unsigned int size = smi_info->curr_msg->data_size;
2550 (data[0]>>2) == STORAGE_NETFN &&
2551 data[1] == STORAGE_CMD_GET_SDR &&
2553 return_hosed_msg_badsize(smi_info);
2559 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2560 .notifier_call = dell_poweredge_bt_xaction_handler,
2564 * setup_dell_poweredge_bt_xaction_handler
2565 * @info - smi_info.device_id must be filled in already
2567 * Fills in smi_info.device_id.start_transaction_pre_hook
2568 * when we know what function to use there.
2571 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2573 struct ipmi_device_id *id = &smi_info->device_id;
2574 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2575 smi_info->si_type == SI_BT)
2576 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2580 * setup_oem_data_handler
2581 * @info - smi_info.device_id must be filled in already
2583 * Fills in smi_info.device_id.oem_data_available_handler
2584 * when we know what function to use there.
2587 static void setup_oem_data_handler(struct smi_info *smi_info)
2589 setup_dell_poweredge_oem_data_handler(smi_info);
2592 static void setup_xaction_handlers(struct smi_info *smi_info)
2594 setup_dell_poweredge_bt_xaction_handler(smi_info);
2597 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2599 if (smi_info->intf) {
2600 /* The timer and thread are only running if the
2601 interface has been started up and registered. */
2602 if (smi_info->thread != NULL)
2603 kthread_stop(smi_info->thread);
2604 del_timer_sync(&smi_info->si_timer);
2608 static __devinitdata struct ipmi_default_vals
2614 { .type = SI_KCS, .port = 0xca2 },
2615 { .type = SI_SMIC, .port = 0xca9 },
2616 { .type = SI_BT, .port = 0xe4 },
2620 static __devinit void default_find_bmc(void)
2622 struct smi_info *info;
2625 for (i = 0; ; i++) {
2626 if (!ipmi_defaults[i].port)
2629 info = kzalloc(sizeof(*info), GFP_KERNEL);
2633 #ifdef CONFIG_PPC_MERGE
2634 if (check_legacy_ioport(ipmi_defaults[i].port))
2638 info->addr_source = NULL;
2640 info->si_type = ipmi_defaults[i].type;
2641 info->io_setup = port_setup;
2642 info->io.addr_data = ipmi_defaults[i].port;
2643 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2645 info->io.addr = NULL;
2646 info->io.regspacing = DEFAULT_REGSPACING;
2647 info->io.regsize = DEFAULT_REGSPACING;
2648 info->io.regshift = 0;
2650 if (try_smi_init(info) == 0) {
2652 printk(KERN_INFO "ipmi_si: Found default %s state"
2653 " machine at %s address 0x%lx\n",
2654 si_to_str[info->si_type],
2655 addr_space_to_str[info->io.addr_type],
2656 info->io.addr_data);
2662 static int is_new_interface(struct smi_info *info)
2666 list_for_each_entry(e, &smi_infos, link) {
2667 if (e->io.addr_type != info->io.addr_type)
2669 if (e->io.addr_data == info->io.addr_data)
2676 static int try_smi_init(struct smi_info *new_smi)
2680 if (new_smi->addr_source) {
2681 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2682 " machine at %s address 0x%lx, slave address 0x%x,"
2684 new_smi->addr_source,
2685 si_to_str[new_smi->si_type],
2686 addr_space_to_str[new_smi->io.addr_type],
2687 new_smi->io.addr_data,
2688 new_smi->slave_addr, new_smi->irq);
2691 mutex_lock(&smi_infos_lock);
2692 if (!is_new_interface(new_smi)) {
2693 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2698 /* So we know not to free it unless we have allocated one. */
2699 new_smi->intf = NULL;
2700 new_smi->si_sm = NULL;
2701 new_smi->handlers = NULL;
2703 switch (new_smi->si_type) {
2705 new_smi->handlers = &kcs_smi_handlers;
2709 new_smi->handlers = &smic_smi_handlers;
2713 new_smi->handlers = &bt_smi_handlers;
2717 /* No support for anything else yet. */
2722 /* Allocate the state machine's data and initialize it. */
2723 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2724 if (!new_smi->si_sm) {
2725 printk(" Could not allocate state machine memory\n");
2729 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2732 /* Now that we know the I/O size, we can set up the I/O. */
2733 rv = new_smi->io_setup(new_smi);
2735 printk(" Could not set up I/O space\n");
2739 spin_lock_init(&(new_smi->si_lock));
2740 spin_lock_init(&(new_smi->msg_lock));
2741 spin_lock_init(&(new_smi->count_lock));
2743 /* Do low-level detection first. */
2744 if (new_smi->handlers->detect(new_smi->si_sm)) {
2745 if (new_smi->addr_source)
2746 printk(KERN_INFO "ipmi_si: Interface detection"
2752 /* Attempt a get device id command. If it fails, we probably
2753 don't have a BMC here. */
2754 rv = try_get_dev_id(new_smi);
2756 if (new_smi->addr_source)
2757 printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2758 " at this location\n");
2762 setup_oem_data_handler(new_smi);
2763 setup_xaction_handlers(new_smi);
2765 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2766 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2767 new_smi->curr_msg = NULL;
2768 atomic_set(&new_smi->req_events, 0);
2769 new_smi->run_to_completion = 0;
2771 new_smi->interrupt_disabled = 0;
2772 atomic_set(&new_smi->stop_operation, 0);
2773 new_smi->intf_num = smi_num;
2776 /* Start clearing the flags before we enable interrupts or the
2777 timer to avoid racing with the timer. */
2778 start_clear_flags(new_smi);
2779 /* IRQ is defined to be set when non-zero. */
2781 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2783 if (!new_smi->dev) {
2784 /* If we don't already have a device from something
2785 * else (like PCI), then register a new one. */
2786 new_smi->pdev = platform_device_alloc("ipmi_si",
2791 " Unable to allocate platform device\n");
2794 new_smi->dev = &new_smi->pdev->dev;
2795 new_smi->dev->driver = &ipmi_driver;
2797 rv = platform_device_add(new_smi->pdev);
2801 " Unable to register system interface device:"
2806 new_smi->dev_registered = 1;
2809 rv = ipmi_register_smi(&handlers,
2811 &new_smi->device_id,
2814 new_smi->slave_addr);
2817 "ipmi_si: Unable to register device: error %d\n",
2819 goto out_err_stop_timer;
2822 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2823 type_file_read_proc, NULL,
2824 new_smi, THIS_MODULE);
2827 "ipmi_si: Unable to create proc entry: %d\n",
2829 goto out_err_stop_timer;
2832 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2833 stat_file_read_proc, NULL,
2834 new_smi, THIS_MODULE);
2837 "ipmi_si: Unable to create proc entry: %d\n",
2839 goto out_err_stop_timer;
2842 rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
2843 param_read_proc, NULL,
2844 new_smi, THIS_MODULE);
2847 "ipmi_si: Unable to create proc entry: %d\n",
2849 goto out_err_stop_timer;
2852 list_add_tail(&new_smi->link, &smi_infos);
2854 mutex_unlock(&smi_infos_lock);
2856 printk(KERN_INFO "IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
2861 atomic_inc(&new_smi->stop_operation);
2862 wait_for_timer_and_thread(new_smi);
2866 ipmi_unregister_smi(new_smi->intf);
2868 if (new_smi->irq_cleanup)
2869 new_smi->irq_cleanup(new_smi);
2871 /* Wait until we know that we are out of any interrupt
2872 handlers might have been running before we freed the
2874 synchronize_sched();
2876 if (new_smi->si_sm) {
2877 if (new_smi->handlers)
2878 new_smi->handlers->cleanup(new_smi->si_sm);
2879 kfree(new_smi->si_sm);
2881 if (new_smi->addr_source_cleanup)
2882 new_smi->addr_source_cleanup(new_smi);
2883 if (new_smi->io_cleanup)
2884 new_smi->io_cleanup(new_smi);
2886 if (new_smi->dev_registered)
2887 platform_device_unregister(new_smi->pdev);
2891 mutex_unlock(&smi_infos_lock);
2896 static __devinit int init_ipmi_si(void)
2906 /* Register the device drivers. */
2907 rv = driver_register(&ipmi_driver);
2910 "init_ipmi_si: Unable to register driver: %d\n",
2916 /* Parse out the si_type string into its components. */
2919 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
2921 str = strchr(str, ',');
2931 printk(KERN_INFO "IPMI System Interface driver.\n");
2933 hardcode_find_bmc();
2944 rv = pci_register_driver(&ipmi_pci_driver);
2947 "init_ipmi_si: Unable to register PCI driver: %d\n",
2952 #ifdef CONFIG_PPC_OF
2953 of_register_platform_driver(&ipmi_of_platform_driver);
2956 if (si_trydefaults) {
2957 mutex_lock(&smi_infos_lock);
2958 if (list_empty(&smi_infos)) {
2959 /* No BMC was found, try defaults. */
2960 mutex_unlock(&smi_infos_lock);
2963 mutex_unlock(&smi_infos_lock);
2967 mutex_lock(&smi_infos_lock);
2968 if (unload_when_empty && list_empty(&smi_infos)) {
2969 mutex_unlock(&smi_infos_lock);
2971 pci_unregister_driver(&ipmi_pci_driver);
2974 #ifdef CONFIG_PPC_OF
2975 of_unregister_platform_driver(&ipmi_of_platform_driver);
2977 driver_unregister(&ipmi_driver);
2978 printk("ipmi_si: Unable to find any System Interface(s)\n");
2981 mutex_unlock(&smi_infos_lock);
2985 module_init(init_ipmi_si);
2987 static void cleanup_one_si(struct smi_info *to_clean)
2990 unsigned long flags;
2995 list_del(&to_clean->link);
2997 /* Tell the driver that we are shutting down. */
2998 atomic_inc(&to_clean->stop_operation);
3000 /* Make sure the timer and thread are stopped and will not run
3002 wait_for_timer_and_thread(to_clean);
3004 /* Timeouts are stopped, now make sure the interrupts are off
3005 for the device. A little tricky with locks to make sure
3006 there are no races. */
3007 spin_lock_irqsave(&to_clean->si_lock, flags);
3008 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3009 spin_unlock_irqrestore(&to_clean->si_lock, flags);
3011 schedule_timeout_uninterruptible(1);
3012 spin_lock_irqsave(&to_clean->si_lock, flags);
3014 disable_si_irq(to_clean);
3015 spin_unlock_irqrestore(&to_clean->si_lock, flags);
3016 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3018 schedule_timeout_uninterruptible(1);
3021 /* Clean up interrupts and make sure that everything is done. */
3022 if (to_clean->irq_cleanup)
3023 to_clean->irq_cleanup(to_clean);
3024 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3026 schedule_timeout_uninterruptible(1);
3029 rv = ipmi_unregister_smi(to_clean->intf);
3032 "ipmi_si: Unable to unregister device: errno=%d\n",
3036 to_clean->handlers->cleanup(to_clean->si_sm);
3038 kfree(to_clean->si_sm);
3040 if (to_clean->addr_source_cleanup)
3041 to_clean->addr_source_cleanup(to_clean);
3042 if (to_clean->io_cleanup)
3043 to_clean->io_cleanup(to_clean);
3045 if (to_clean->dev_registered)
3046 platform_device_unregister(to_clean->pdev);
3051 static __exit void cleanup_ipmi_si(void)
3053 struct smi_info *e, *tmp_e;
3059 pci_unregister_driver(&ipmi_pci_driver);
3062 #ifdef CONFIG_PPC_OF
3063 of_unregister_platform_driver(&ipmi_of_platform_driver);
3066 mutex_lock(&smi_infos_lock);
3067 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
3069 mutex_unlock(&smi_infos_lock);
3071 driver_unregister(&ipmi_driver);
3073 module_exit(cleanup_ipmi_si);
3075 MODULE_LICENSE("GPL");
3076 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
3077 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");