ia64/linux-2.6.18-xen.hg

view drivers/char/ipmi/ipmi_si_intf.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 3e8752eb6d9c
children
line source
1 /*
2 * ipmi_si.c
3 *
4 * The interface to the IPMI driver for the system interfaces (KCS, SMIC,
5 * BT).
6 *
7 * Author: MontaVista Software, Inc.
8 * Corey Minyard <minyard@mvista.com>
9 * source@mvista.com
10 *
11 * Copyright 2002 MontaVista Software Inc.
12 *
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
17 *
18 *
19 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
20 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
25 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
27 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
28 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 *
30 * You should have received a copy of the GNU General Public License along
31 * with this program; if not, write to the Free Software Foundation, Inc.,
32 * 675 Mass Ave, Cambridge, MA 02139, USA.
33 */
35 /*
36 * This file holds the "policy" for the interface to the SMI state
37 * machine. It does the configuration, handles timers and interrupts,
38 * and drives the real SMI state machine.
39 */
41 #include <linux/module.h>
42 #include <linux/moduleparam.h>
43 #include <asm/system.h>
44 #include <linux/sched.h>
45 #include <linux/timer.h>
46 #include <linux/errno.h>
47 #include <linux/spinlock.h>
48 #include <linux/slab.h>
49 #include <linux/delay.h>
50 #include <linux/list.h>
51 #include <linux/pci.h>
52 #include <linux/ioport.h>
53 #include <linux/notifier.h>
54 #include <linux/mutex.h>
55 #include <linux/kthread.h>
56 #include <asm/irq.h>
57 #include <linux/interrupt.h>
58 #include <linux/rcupdate.h>
59 #include <linux/ipmi_smi.h>
60 #include <asm/io.h>
61 #include "ipmi_si_sm.h"
62 #include <linux/init.h>
63 #include <linux/dmi.h>
65 /* Measure times between events in the driver. */
66 #undef DEBUG_TIMING
68 /* Call every 10 ms. */
69 #define SI_TIMEOUT_TIME_USEC 10000
70 #define SI_USEC_PER_JIFFY (1000000/HZ)
71 #define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
72 #define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
73 short timeout */
75 enum si_intf_state {
76 SI_NORMAL,
77 SI_GETTING_FLAGS,
78 SI_GETTING_EVENTS,
79 SI_CLEARING_FLAGS,
80 SI_CLEARING_FLAGS_THEN_SET_IRQ,
81 SI_GETTING_MESSAGES,
82 SI_ENABLE_INTERRUPTS1,
83 SI_ENABLE_INTERRUPTS2
84 /* FIXME - add watchdog stuff. */
85 };
87 /* Some BT-specific defines we need here. */
88 #define IPMI_BT_INTMASK_REG 2
89 #define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
90 #define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
92 enum si_type {
93 SI_KCS, SI_SMIC, SI_BT
94 };
95 static char *si_to_str[] = { "KCS", "SMIC", "BT" };
97 #define DEVICE_NAME "ipmi_si"
99 static struct device_driver ipmi_driver =
100 {
101 .name = DEVICE_NAME,
102 .bus = &platform_bus_type
103 };
105 struct smi_info
106 {
107 int intf_num;
108 ipmi_smi_t intf;
109 struct si_sm_data *si_sm;
110 struct si_sm_handlers *handlers;
111 enum si_type si_type;
112 spinlock_t si_lock;
113 spinlock_t msg_lock;
114 struct list_head xmit_msgs;
115 struct list_head hp_xmit_msgs;
116 struct ipmi_smi_msg *curr_msg;
117 enum si_intf_state si_state;
119 /* Used to handle the various types of I/O that can occur with
120 IPMI */
121 struct si_sm_io io;
122 int (*io_setup)(struct smi_info *info);
123 void (*io_cleanup)(struct smi_info *info);
124 int (*irq_setup)(struct smi_info *info);
125 void (*irq_cleanup)(struct smi_info *info);
126 unsigned int io_size;
127 char *addr_source; /* ACPI, PCI, SMBIOS, hardcode, default. */
128 void (*addr_source_cleanup)(struct smi_info *info);
129 void *addr_source_data;
131 /* Per-OEM handler, called from handle_flags().
132 Returns 1 when handle_flags() needs to be re-run
133 or 0 indicating it set si_state itself.
134 */
135 int (*oem_data_avail_handler)(struct smi_info *smi_info);
137 /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
138 is set to hold the flags until we are done handling everything
139 from the flags. */
140 #define RECEIVE_MSG_AVAIL 0x01
141 #define EVENT_MSG_BUFFER_FULL 0x02
142 #define WDT_PRE_TIMEOUT_INT 0x08
143 #define OEM0_DATA_AVAIL 0x20
144 #define OEM1_DATA_AVAIL 0x40
145 #define OEM2_DATA_AVAIL 0x80
146 #define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
147 OEM1_DATA_AVAIL | \
148 OEM2_DATA_AVAIL)
149 unsigned char msg_flags;
151 /* If set to true, this will request events the next time the
152 state machine is idle. */
153 atomic_t req_events;
155 /* If true, run the state machine to completion on every send
156 call. Generally used after a panic to make sure stuff goes
157 out. */
158 int run_to_completion;
160 /* The I/O port of an SI interface. */
161 int port;
163 /* The space between start addresses of the two ports. For
164 instance, if the first port is 0xca2 and the spacing is 4, then
165 the second port is 0xca6. */
166 unsigned int spacing;
168 /* zero if no irq; */
169 int irq;
171 /* The timer for this si. */
172 struct timer_list si_timer;
174 /* The time (in jiffies) the last timeout occurred at. */
175 unsigned long last_timeout_jiffies;
177 /* Used to gracefully stop the timer without race conditions. */
178 atomic_t stop_operation;
180 /* The driver will disable interrupts when it gets into a
181 situation where it cannot handle messages due to lack of
182 memory. Once that situation clears up, it will re-enable
183 interrupts. */
184 int interrupt_disabled;
186 /* From the get device id response... */
187 struct ipmi_device_id device_id;
189 /* Driver model stuff. */
190 struct device *dev;
191 struct platform_device *pdev;
193 /* True if we allocated the device, false if it came from
194 * someplace else (like PCI). */
195 int dev_registered;
197 /* Slave address, could be reported from DMI. */
198 unsigned char slave_addr;
200 /* Counters and things for the proc filesystem. */
201 spinlock_t count_lock;
202 unsigned long short_timeouts;
203 unsigned long long_timeouts;
204 unsigned long timeout_restarts;
205 unsigned long idles;
206 unsigned long interrupts;
207 unsigned long attentions;
208 unsigned long flag_fetches;
209 unsigned long hosed_count;
210 unsigned long complete_transactions;
211 unsigned long events;
212 unsigned long watchdog_pretimeouts;
213 unsigned long incoming_messages;
215 struct task_struct *thread;
217 struct list_head link;
218 };
220 static int try_smi_init(struct smi_info *smi);
222 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
223 static int register_xaction_notifier(struct notifier_block * nb)
224 {
225 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
226 }
228 static void deliver_recv_msg(struct smi_info *smi_info,
229 struct ipmi_smi_msg *msg)
230 {
231 /* Deliver the message to the upper layer with the lock
232 released. */
233 spin_unlock(&(smi_info->si_lock));
234 ipmi_smi_msg_received(smi_info->intf, msg);
235 spin_lock(&(smi_info->si_lock));
236 }
238 static void return_hosed_msg(struct smi_info *smi_info)
239 {
240 struct ipmi_smi_msg *msg = smi_info->curr_msg;
242 /* Make it a reponse */
243 msg->rsp[0] = msg->data[0] | 4;
244 msg->rsp[1] = msg->data[1];
245 msg->rsp[2] = 0xFF; /* Unknown error. */
246 msg->rsp_size = 3;
248 smi_info->curr_msg = NULL;
249 deliver_recv_msg(smi_info, msg);
250 }
252 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
253 {
254 int rv;
255 struct list_head *entry = NULL;
256 #ifdef DEBUG_TIMING
257 struct timeval t;
258 #endif
260 /* No need to save flags, we aleady have interrupts off and we
261 already hold the SMI lock. */
262 spin_lock(&(smi_info->msg_lock));
264 /* Pick the high priority queue first. */
265 if (!list_empty(&(smi_info->hp_xmit_msgs))) {
266 entry = smi_info->hp_xmit_msgs.next;
267 } else if (!list_empty(&(smi_info->xmit_msgs))) {
268 entry = smi_info->xmit_msgs.next;
269 }
271 if (!entry) {
272 smi_info->curr_msg = NULL;
273 rv = SI_SM_IDLE;
274 } else {
275 int err;
277 list_del(entry);
278 smi_info->curr_msg = list_entry(entry,
279 struct ipmi_smi_msg,
280 link);
281 #ifdef DEBUG_TIMING
282 do_gettimeofday(&t);
283 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
284 #endif
285 err = atomic_notifier_call_chain(&xaction_notifier_list,
286 0, smi_info);
287 if (err & NOTIFY_STOP_MASK) {
288 rv = SI_SM_CALL_WITHOUT_DELAY;
289 goto out;
290 }
291 err = smi_info->handlers->start_transaction(
292 smi_info->si_sm,
293 smi_info->curr_msg->data,
294 smi_info->curr_msg->data_size);
295 if (err) {
296 return_hosed_msg(smi_info);
297 }
299 rv = SI_SM_CALL_WITHOUT_DELAY;
300 }
301 out:
302 spin_unlock(&(smi_info->msg_lock));
304 return rv;
305 }
307 static void start_enable_irq(struct smi_info *smi_info)
308 {
309 unsigned char msg[2];
311 /* If we are enabling interrupts, we have to tell the
312 BMC to use them. */
313 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
314 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
316 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
317 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
318 }
320 static void start_clear_flags(struct smi_info *smi_info)
321 {
322 unsigned char msg[3];
324 /* Make sure the watchdog pre-timeout flag is not set at startup. */
325 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
326 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
327 msg[2] = WDT_PRE_TIMEOUT_INT;
329 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
330 smi_info->si_state = SI_CLEARING_FLAGS;
331 }
333 /* When we have a situtaion where we run out of memory and cannot
334 allocate messages, we just leave them in the BMC and run the system
335 polled until we can allocate some memory. Once we have some
336 memory, we will re-enable the interrupt. */
337 static inline void disable_si_irq(struct smi_info *smi_info)
338 {
339 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
340 disable_irq_nosync(smi_info->irq);
341 smi_info->interrupt_disabled = 1;
342 }
343 }
345 static inline void enable_si_irq(struct smi_info *smi_info)
346 {
347 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
348 enable_irq(smi_info->irq);
349 smi_info->interrupt_disabled = 0;
350 }
351 }
353 static void handle_flags(struct smi_info *smi_info)
354 {
355 retry:
356 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
357 /* Watchdog pre-timeout */
358 spin_lock(&smi_info->count_lock);
359 smi_info->watchdog_pretimeouts++;
360 spin_unlock(&smi_info->count_lock);
362 start_clear_flags(smi_info);
363 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
364 spin_unlock(&(smi_info->si_lock));
365 ipmi_smi_watchdog_pretimeout(smi_info->intf);
366 spin_lock(&(smi_info->si_lock));
367 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
368 /* Messages available. */
369 smi_info->curr_msg = ipmi_alloc_smi_msg();
370 if (!smi_info->curr_msg) {
371 disable_si_irq(smi_info);
372 smi_info->si_state = SI_NORMAL;
373 return;
374 }
375 enable_si_irq(smi_info);
377 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
378 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
379 smi_info->curr_msg->data_size = 2;
381 smi_info->handlers->start_transaction(
382 smi_info->si_sm,
383 smi_info->curr_msg->data,
384 smi_info->curr_msg->data_size);
385 smi_info->si_state = SI_GETTING_MESSAGES;
386 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
387 /* Events available. */
388 smi_info->curr_msg = ipmi_alloc_smi_msg();
389 if (!smi_info->curr_msg) {
390 disable_si_irq(smi_info);
391 smi_info->si_state = SI_NORMAL;
392 return;
393 }
394 enable_si_irq(smi_info);
396 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
397 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
398 smi_info->curr_msg->data_size = 2;
400 smi_info->handlers->start_transaction(
401 smi_info->si_sm,
402 smi_info->curr_msg->data,
403 smi_info->curr_msg->data_size);
404 smi_info->si_state = SI_GETTING_EVENTS;
405 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
406 smi_info->oem_data_avail_handler) {
407 if (smi_info->oem_data_avail_handler(smi_info))
408 goto retry;
409 } else {
410 smi_info->si_state = SI_NORMAL;
411 }
412 }
414 static void handle_transaction_done(struct smi_info *smi_info)
415 {
416 struct ipmi_smi_msg *msg;
417 #ifdef DEBUG_TIMING
418 struct timeval t;
420 do_gettimeofday(&t);
421 printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
422 #endif
423 switch (smi_info->si_state) {
424 case SI_NORMAL:
425 if (!smi_info->curr_msg)
426 break;
428 smi_info->curr_msg->rsp_size
429 = smi_info->handlers->get_result(
430 smi_info->si_sm,
431 smi_info->curr_msg->rsp,
432 IPMI_MAX_MSG_LENGTH);
434 /* Do this here becase deliver_recv_msg() releases the
435 lock, and a new message can be put in during the
436 time the lock is released. */
437 msg = smi_info->curr_msg;
438 smi_info->curr_msg = NULL;
439 deliver_recv_msg(smi_info, msg);
440 break;
442 case SI_GETTING_FLAGS:
443 {
444 unsigned char msg[4];
445 unsigned int len;
447 /* We got the flags from the SMI, now handle them. */
448 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
449 if (msg[2] != 0) {
450 /* Error fetching flags, just give up for
451 now. */
452 smi_info->si_state = SI_NORMAL;
453 } else if (len < 4) {
454 /* Hmm, no flags. That's technically illegal, but
455 don't use uninitialized data. */
456 smi_info->si_state = SI_NORMAL;
457 } else {
458 smi_info->msg_flags = msg[3];
459 handle_flags(smi_info);
460 }
461 break;
462 }
464 case SI_CLEARING_FLAGS:
465 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
466 {
467 unsigned char msg[3];
469 /* We cleared the flags. */
470 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
471 if (msg[2] != 0) {
472 /* Error clearing flags */
473 printk(KERN_WARNING
474 "ipmi_si: Error clearing flags: %2.2x\n",
475 msg[2]);
476 }
477 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
478 start_enable_irq(smi_info);
479 else
480 smi_info->si_state = SI_NORMAL;
481 break;
482 }
484 case SI_GETTING_EVENTS:
485 {
486 smi_info->curr_msg->rsp_size
487 = smi_info->handlers->get_result(
488 smi_info->si_sm,
489 smi_info->curr_msg->rsp,
490 IPMI_MAX_MSG_LENGTH);
492 /* Do this here becase deliver_recv_msg() releases the
493 lock, and a new message can be put in during the
494 time the lock is released. */
495 msg = smi_info->curr_msg;
496 smi_info->curr_msg = NULL;
497 if (msg->rsp[2] != 0) {
498 /* Error getting event, probably done. */
499 msg->done(msg);
501 /* Take off the event flag. */
502 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
503 handle_flags(smi_info);
504 } else {
505 spin_lock(&smi_info->count_lock);
506 smi_info->events++;
507 spin_unlock(&smi_info->count_lock);
509 /* Do this before we deliver the message
510 because delivering the message releases the
511 lock and something else can mess with the
512 state. */
513 handle_flags(smi_info);
515 deliver_recv_msg(smi_info, msg);
516 }
517 break;
518 }
520 case SI_GETTING_MESSAGES:
521 {
522 smi_info->curr_msg->rsp_size
523 = smi_info->handlers->get_result(
524 smi_info->si_sm,
525 smi_info->curr_msg->rsp,
526 IPMI_MAX_MSG_LENGTH);
528 /* Do this here becase deliver_recv_msg() releases the
529 lock, and a new message can be put in during the
530 time the lock is released. */
531 msg = smi_info->curr_msg;
532 smi_info->curr_msg = NULL;
533 if (msg->rsp[2] != 0) {
534 /* Error getting event, probably done. */
535 msg->done(msg);
537 /* Take off the msg flag. */
538 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
539 handle_flags(smi_info);
540 } else {
541 spin_lock(&smi_info->count_lock);
542 smi_info->incoming_messages++;
543 spin_unlock(&smi_info->count_lock);
545 /* Do this before we deliver the message
546 because delivering the message releases the
547 lock and something else can mess with the
548 state. */
549 handle_flags(smi_info);
551 deliver_recv_msg(smi_info, msg);
552 }
553 break;
554 }
556 case SI_ENABLE_INTERRUPTS1:
557 {
558 unsigned char msg[4];
560 /* We got the flags from the SMI, now handle them. */
561 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
562 if (msg[2] != 0) {
563 printk(KERN_WARNING
564 "ipmi_si: Could not enable interrupts"
565 ", failed get, using polled mode.\n");
566 smi_info->si_state = SI_NORMAL;
567 } else {
568 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
569 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
570 msg[2] = msg[3] | 1; /* enable msg queue int */
571 smi_info->handlers->start_transaction(
572 smi_info->si_sm, msg, 3);
573 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
574 }
575 break;
576 }
578 case SI_ENABLE_INTERRUPTS2:
579 {
580 unsigned char msg[4];
582 /* We got the flags from the SMI, now handle them. */
583 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
584 if (msg[2] != 0) {
585 printk(KERN_WARNING
586 "ipmi_si: Could not enable interrupts"
587 ", failed set, using polled mode.\n");
588 }
589 smi_info->si_state = SI_NORMAL;
590 break;
591 }
592 }
593 }
595 /* Called on timeouts and events. Timeouts should pass the elapsed
596 time, interrupts should pass in zero. */
597 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
598 int time)
599 {
600 enum si_sm_result si_sm_result;
602 restart:
603 /* There used to be a loop here that waited a little while
604 (around 25us) before giving up. That turned out to be
605 pointless, the minimum delays I was seeing were in the 300us
606 range, which is far too long to wait in an interrupt. So
607 we just run until the state machine tells us something
608 happened or it needs a delay. */
609 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
610 time = 0;
611 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
612 {
613 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
614 }
616 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
617 {
618 spin_lock(&smi_info->count_lock);
619 smi_info->complete_transactions++;
620 spin_unlock(&smi_info->count_lock);
622 handle_transaction_done(smi_info);
623 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
624 }
625 else if (si_sm_result == SI_SM_HOSED)
626 {
627 spin_lock(&smi_info->count_lock);
628 smi_info->hosed_count++;
629 spin_unlock(&smi_info->count_lock);
631 /* Do the before return_hosed_msg, because that
632 releases the lock. */
633 smi_info->si_state = SI_NORMAL;
634 if (smi_info->curr_msg != NULL) {
635 /* If we were handling a user message, format
636 a response to send to the upper layer to
637 tell it about the error. */
638 return_hosed_msg(smi_info);
639 }
640 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
641 }
643 /* We prefer handling attn over new messages. */
644 if (si_sm_result == SI_SM_ATTN)
645 {
646 unsigned char msg[2];
648 spin_lock(&smi_info->count_lock);
649 smi_info->attentions++;
650 spin_unlock(&smi_info->count_lock);
652 /* Got a attn, send down a get message flags to see
653 what's causing it. It would be better to handle
654 this in the upper layer, but due to the way
655 interrupts work with the SMI, that's not really
656 possible. */
657 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
658 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
660 smi_info->handlers->start_transaction(
661 smi_info->si_sm, msg, 2);
662 smi_info->si_state = SI_GETTING_FLAGS;
663 goto restart;
664 }
666 /* If we are currently idle, try to start the next message. */
667 if (si_sm_result == SI_SM_IDLE) {
668 spin_lock(&smi_info->count_lock);
669 smi_info->idles++;
670 spin_unlock(&smi_info->count_lock);
672 si_sm_result = start_next_msg(smi_info);
673 if (si_sm_result != SI_SM_IDLE)
674 goto restart;
675 }
677 if ((si_sm_result == SI_SM_IDLE)
678 && (atomic_read(&smi_info->req_events)))
679 {
680 /* We are idle and the upper layer requested that I fetch
681 events, so do so. */
682 unsigned char msg[2];
684 spin_lock(&smi_info->count_lock);
685 smi_info->flag_fetches++;
686 spin_unlock(&smi_info->count_lock);
688 atomic_set(&smi_info->req_events, 0);
689 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
690 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
692 smi_info->handlers->start_transaction(
693 smi_info->si_sm, msg, 2);
694 smi_info->si_state = SI_GETTING_FLAGS;
695 goto restart;
696 }
698 return si_sm_result;
699 }
701 static void sender(void *send_info,
702 struct ipmi_smi_msg *msg,
703 int priority)
704 {
705 struct smi_info *smi_info = send_info;
706 enum si_sm_result result;
707 unsigned long flags;
708 #ifdef DEBUG_TIMING
709 struct timeval t;
710 #endif
712 spin_lock_irqsave(&(smi_info->msg_lock), flags);
713 #ifdef DEBUG_TIMING
714 do_gettimeofday(&t);
715 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
716 #endif
718 if (smi_info->run_to_completion) {
719 /* If we are running to completion, then throw it in
720 the list and run transactions until everything is
721 clear. Priority doesn't matter here. */
722 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
724 /* We have to release the msg lock and claim the smi
725 lock in this case, because of race conditions. */
726 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
728 spin_lock_irqsave(&(smi_info->si_lock), flags);
729 result = smi_event_handler(smi_info, 0);
730 while (result != SI_SM_IDLE) {
731 udelay(SI_SHORT_TIMEOUT_USEC);
732 result = smi_event_handler(smi_info,
733 SI_SHORT_TIMEOUT_USEC);
734 }
735 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
736 return;
737 } else {
738 if (priority > 0) {
739 list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
740 } else {
741 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
742 }
743 }
744 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
746 spin_lock_irqsave(&(smi_info->si_lock), flags);
747 if ((smi_info->si_state == SI_NORMAL)
748 && (smi_info->curr_msg == NULL))
749 {
750 start_next_msg(smi_info);
751 }
752 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
753 }
755 static void set_run_to_completion(void *send_info, int i_run_to_completion)
756 {
757 struct smi_info *smi_info = send_info;
758 enum si_sm_result result;
759 unsigned long flags;
761 spin_lock_irqsave(&(smi_info->si_lock), flags);
763 smi_info->run_to_completion = i_run_to_completion;
764 if (i_run_to_completion) {
765 result = smi_event_handler(smi_info, 0);
766 while (result != SI_SM_IDLE) {
767 udelay(SI_SHORT_TIMEOUT_USEC);
768 result = smi_event_handler(smi_info,
769 SI_SHORT_TIMEOUT_USEC);
770 }
771 }
773 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
774 }
776 static int ipmi_thread(void *data)
777 {
778 struct smi_info *smi_info = data;
779 unsigned long flags;
780 enum si_sm_result smi_result;
782 set_user_nice(current, 19);
783 while (!kthread_should_stop()) {
784 spin_lock_irqsave(&(smi_info->si_lock), flags);
785 smi_result = smi_event_handler(smi_info, 0);
786 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
787 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
788 /* do nothing */
789 }
790 else if (smi_result == SI_SM_CALL_WITH_DELAY)
791 schedule();
792 else
793 schedule_timeout_interruptible(1);
794 }
795 return 0;
796 }
799 static void poll(void *send_info)
800 {
801 struct smi_info *smi_info = send_info;
803 smi_event_handler(smi_info, 0);
804 }
806 static void request_events(void *send_info)
807 {
808 struct smi_info *smi_info = send_info;
810 atomic_set(&smi_info->req_events, 1);
811 }
813 static int initialized = 0;
815 static void smi_timeout(unsigned long data)
816 {
817 struct smi_info *smi_info = (struct smi_info *) data;
818 enum si_sm_result smi_result;
819 unsigned long flags;
820 unsigned long jiffies_now;
821 long time_diff;
822 #ifdef DEBUG_TIMING
823 struct timeval t;
824 #endif
826 if (atomic_read(&smi_info->stop_operation))
827 return;
829 spin_lock_irqsave(&(smi_info->si_lock), flags);
830 #ifdef DEBUG_TIMING
831 do_gettimeofday(&t);
832 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
833 #endif
834 jiffies_now = jiffies;
835 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
836 * SI_USEC_PER_JIFFY);
837 smi_result = smi_event_handler(smi_info, time_diff);
839 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
841 smi_info->last_timeout_jiffies = jiffies_now;
843 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
844 /* Running with interrupts, only do long timeouts. */
845 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
846 spin_lock_irqsave(&smi_info->count_lock, flags);
847 smi_info->long_timeouts++;
848 spin_unlock_irqrestore(&smi_info->count_lock, flags);
849 goto do_add_timer;
850 }
852 /* If the state machine asks for a short delay, then shorten
853 the timer timeout. */
854 if (smi_result == SI_SM_CALL_WITH_DELAY) {
855 spin_lock_irqsave(&smi_info->count_lock, flags);
856 smi_info->short_timeouts++;
857 spin_unlock_irqrestore(&smi_info->count_lock, flags);
858 smi_info->si_timer.expires = jiffies + 1;
859 } else {
860 spin_lock_irqsave(&smi_info->count_lock, flags);
861 smi_info->long_timeouts++;
862 spin_unlock_irqrestore(&smi_info->count_lock, flags);
863 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
864 }
866 do_add_timer:
867 add_timer(&(smi_info->si_timer));
868 }
870 static irqreturn_t si_irq_handler(int irq, void *data, struct pt_regs *regs)
871 {
872 struct smi_info *smi_info = data;
873 unsigned long flags;
874 #ifdef DEBUG_TIMING
875 struct timeval t;
876 #endif
878 spin_lock_irqsave(&(smi_info->si_lock), flags);
880 spin_lock(&smi_info->count_lock);
881 smi_info->interrupts++;
882 spin_unlock(&smi_info->count_lock);
884 if (atomic_read(&smi_info->stop_operation))
885 goto out;
887 #ifdef DEBUG_TIMING
888 do_gettimeofday(&t);
889 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
890 #endif
891 smi_event_handler(smi_info, 0);
892 out:
893 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
894 return IRQ_HANDLED;
895 }
897 static irqreturn_t si_bt_irq_handler(int irq, void *data, struct pt_regs *regs)
898 {
899 struct smi_info *smi_info = data;
900 /* We need to clear the IRQ flag for the BT interface. */
901 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
902 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
903 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
904 return si_irq_handler(irq, data, regs);
905 }
907 static int smi_start_processing(void *send_info,
908 ipmi_smi_t intf)
909 {
910 struct smi_info *new_smi = send_info;
912 new_smi->intf = intf;
914 /* Set up the timer that drives the interface. */
915 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
916 new_smi->last_timeout_jiffies = jiffies;
917 mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
919 if (new_smi->si_type != SI_BT) {
920 new_smi->thread = kthread_run(ipmi_thread, new_smi,
921 "kipmi%d", new_smi->intf_num);
922 if (IS_ERR(new_smi->thread)) {
923 printk(KERN_NOTICE "ipmi_si_intf: Could not start"
924 " kernel thread due to error %ld, only using"
925 " timers to drive the interface\n",
926 PTR_ERR(new_smi->thread));
927 new_smi->thread = NULL;
928 }
929 }
931 return 0;
932 }
934 static struct ipmi_smi_handlers handlers =
935 {
936 .owner = THIS_MODULE,
937 .start_processing = smi_start_processing,
938 .sender = sender,
939 .request_events = request_events,
940 .set_run_to_completion = set_run_to_completion,
941 .poll = poll,
942 };
944 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
945 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
947 #define SI_MAX_PARMS 4
948 static LIST_HEAD(smi_infos);
949 static DEFINE_MUTEX(smi_infos_lock);
950 static int smi_num; /* Used to sequence the SMIs */
952 #define DEFAULT_REGSPACING 1
954 static int si_trydefaults = 1;
955 static char *si_type[SI_MAX_PARMS];
956 #define MAX_SI_TYPE_STR 30
957 static char si_type_str[MAX_SI_TYPE_STR];
958 static unsigned long addrs[SI_MAX_PARMS];
959 static int num_addrs;
960 static unsigned int ports[SI_MAX_PARMS];
961 static int num_ports;
962 static int irqs[SI_MAX_PARMS];
963 static int num_irqs;
964 static int regspacings[SI_MAX_PARMS];
965 static int num_regspacings = 0;
966 static int regsizes[SI_MAX_PARMS];
967 static int num_regsizes = 0;
968 static int regshifts[SI_MAX_PARMS];
969 static int num_regshifts = 0;
970 static int slave_addrs[SI_MAX_PARMS];
971 static int num_slave_addrs = 0;
974 module_param_named(trydefaults, si_trydefaults, bool, 0);
975 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
976 " default scan of the KCS and SMIC interface at the standard"
977 " address");
978 module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
979 MODULE_PARM_DESC(type, "Defines the type of each interface, each"
980 " interface separated by commas. The types are 'kcs',"
981 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
982 " the first interface to kcs and the second to bt");
983 module_param_array(addrs, long, &num_addrs, 0);
984 MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
985 " addresses separated by commas. Only use if an interface"
986 " is in memory. Otherwise, set it to zero or leave"
987 " it blank.");
988 module_param_array(ports, int, &num_ports, 0);
989 MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
990 " addresses separated by commas. Only use if an interface"
991 " is a port. Otherwise, set it to zero or leave"
992 " it blank.");
993 module_param_array(irqs, int, &num_irqs, 0);
994 MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
995 " addresses separated by commas. Only use if an interface"
996 " has an interrupt. Otherwise, set it to zero or leave"
997 " it blank.");
998 module_param_array(regspacings, int, &num_regspacings, 0);
999 MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1000 " and each successive register used by the interface. For"
1001 " instance, if the start address is 0xca2 and the spacing"
1002 " is 2, then the second address is at 0xca4. Defaults"
1003 " to 1.");
1004 module_param_array(regsizes, int, &num_regsizes, 0);
1005 MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1006 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1007 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1008 " the 8-bit IPMI register has to be read from a larger"
1009 " register.");
1010 module_param_array(regshifts, int, &num_regshifts, 0);
1011 MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1012 " IPMI register, in bits. For instance, if the data"
1013 " is read from a 32-bit word and the IPMI data is in"
1014 " bit 8-15, then the shift would be 8");
1015 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1016 MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1017 " the controller. Normally this is 0x20, but can be"
1018 " overridden by this parm. This is an array indexed"
1019 " by interface number.");
1022 #define IPMI_IO_ADDR_SPACE 0
1023 #define IPMI_MEM_ADDR_SPACE 1
1024 static char *addr_space_to_str[] = { "I/O", "memory" };
1026 static void std_irq_cleanup(struct smi_info *info)
1028 if (info->si_type == SI_BT)
1029 /* Disable the interrupt in the BT interface. */
1030 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1031 free_irq(info->irq, info);
1034 static int std_irq_setup(struct smi_info *info)
1036 int rv;
1038 if (!info->irq)
1039 return 0;
1041 if (info->si_type == SI_BT) {
1042 rv = request_irq(info->irq,
1043 si_bt_irq_handler,
1044 IRQF_DISABLED,
1045 DEVICE_NAME,
1046 info);
1047 if (!rv)
1048 /* Enable the interrupt in the BT interface. */
1049 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1050 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1051 } else
1052 rv = request_irq(info->irq,
1053 si_irq_handler,
1054 IRQF_DISABLED,
1055 DEVICE_NAME,
1056 info);
1057 if (rv) {
1058 printk(KERN_WARNING
1059 "ipmi_si: %s unable to claim interrupt %d,"
1060 " running polled\n",
1061 DEVICE_NAME, info->irq);
1062 info->irq = 0;
1063 } else {
1064 info->irq_cleanup = std_irq_cleanup;
1065 printk(" Using irq %d\n", info->irq);
1068 return rv;
1071 static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1073 unsigned int addr = io->addr_data;
1075 return inb(addr + (offset * io->regspacing));
1078 static void port_outb(struct si_sm_io *io, unsigned int offset,
1079 unsigned char b)
1081 unsigned int addr = io->addr_data;
1083 outb(b, addr + (offset * io->regspacing));
1086 static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1088 unsigned int addr = io->addr_data;
1090 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1093 static void port_outw(struct si_sm_io *io, unsigned int offset,
1094 unsigned char b)
1096 unsigned int addr = io->addr_data;
1098 outw(b << io->regshift, addr + (offset * io->regspacing));
1101 static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1103 unsigned int addr = io->addr_data;
1105 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1108 static void port_outl(struct si_sm_io *io, unsigned int offset,
1109 unsigned char b)
1111 unsigned int addr = io->addr_data;
1113 outl(b << io->regshift, addr+(offset * io->regspacing));
1116 static void port_cleanup(struct smi_info *info)
1118 unsigned int addr = info->io.addr_data;
1119 int idx;
1121 if (addr) {
1122 for (idx = 0; idx < info->io_size; idx++) {
1123 release_region(addr + idx * info->io.regspacing,
1124 info->io.regsize);
1129 static int port_setup(struct smi_info *info)
1131 unsigned int addr = info->io.addr_data;
1132 int idx;
1134 if (!addr)
1135 return -ENODEV;
1137 info->io_cleanup = port_cleanup;
1139 /* Figure out the actual inb/inw/inl/etc routine to use based
1140 upon the register size. */
1141 switch (info->io.regsize) {
1142 case 1:
1143 info->io.inputb = port_inb;
1144 info->io.outputb = port_outb;
1145 break;
1146 case 2:
1147 info->io.inputb = port_inw;
1148 info->io.outputb = port_outw;
1149 break;
1150 case 4:
1151 info->io.inputb = port_inl;
1152 info->io.outputb = port_outl;
1153 break;
1154 default:
1155 printk("ipmi_si: Invalid register size: %d\n",
1156 info->io.regsize);
1157 return -EINVAL;
1160 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1161 * tables. This causes problems when trying to register the
1162 * entire I/O region. Therefore we must register each I/O
1163 * port separately.
1164 */
1165 for (idx = 0; idx < info->io_size; idx++) {
1166 if (request_region(addr + idx * info->io.regspacing,
1167 info->io.regsize, DEVICE_NAME) == NULL) {
1168 /* Undo allocations */
1169 while (idx--) {
1170 release_region(addr + idx * info->io.regspacing,
1171 info->io.regsize);
1173 return -EIO;
1176 return 0;
1179 static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1181 return readb((io->addr)+(offset * io->regspacing));
1184 static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1185 unsigned char b)
1187 writeb(b, (io->addr)+(offset * io->regspacing));
1190 static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1192 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
1193 && 0xff;
1196 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1197 unsigned char b)
1199 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1202 static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1204 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
1205 && 0xff;
1208 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1209 unsigned char b)
1211 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1214 #ifdef readq
1215 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1217 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
1218 && 0xff;
1221 static void mem_outq(struct si_sm_io *io, unsigned int offset,
1222 unsigned char b)
1224 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1226 #endif
1228 static void mem_cleanup(struct smi_info *info)
1230 unsigned long addr = info->io.addr_data;
1231 int mapsize;
1233 if (info->io.addr) {
1234 iounmap(info->io.addr);
1236 mapsize = ((info->io_size * info->io.regspacing)
1237 - (info->io.regspacing - info->io.regsize));
1239 release_mem_region(addr, mapsize);
1243 static int mem_setup(struct smi_info *info)
1245 unsigned long addr = info->io.addr_data;
1246 int mapsize;
1248 if (!addr)
1249 return -ENODEV;
1251 info->io_cleanup = mem_cleanup;
1253 /* Figure out the actual readb/readw/readl/etc routine to use based
1254 upon the register size. */
1255 switch (info->io.regsize) {
1256 case 1:
1257 info->io.inputb = intf_mem_inb;
1258 info->io.outputb = intf_mem_outb;
1259 break;
1260 case 2:
1261 info->io.inputb = intf_mem_inw;
1262 info->io.outputb = intf_mem_outw;
1263 break;
1264 case 4:
1265 info->io.inputb = intf_mem_inl;
1266 info->io.outputb = intf_mem_outl;
1267 break;
1268 #ifdef readq
1269 case 8:
1270 info->io.inputb = mem_inq;
1271 info->io.outputb = mem_outq;
1272 break;
1273 #endif
1274 default:
1275 printk("ipmi_si: Invalid register size: %d\n",
1276 info->io.regsize);
1277 return -EINVAL;
1280 /* Calculate the total amount of memory to claim. This is an
1281 * unusual looking calculation, but it avoids claiming any
1282 * more memory than it has to. It will claim everything
1283 * between the first address to the end of the last full
1284 * register. */
1285 mapsize = ((info->io_size * info->io.regspacing)
1286 - (info->io.regspacing - info->io.regsize));
1288 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1289 return -EIO;
1291 info->io.addr = ioremap(addr, mapsize);
1292 if (info->io.addr == NULL) {
1293 release_mem_region(addr, mapsize);
1294 return -EIO;
1296 return 0;
1300 static __devinit void hardcode_find_bmc(void)
1302 int i;
1303 struct smi_info *info;
1305 for (i = 0; i < SI_MAX_PARMS; i++) {
1306 if (!ports[i] && !addrs[i])
1307 continue;
1309 info = kzalloc(sizeof(*info), GFP_KERNEL);
1310 if (!info)
1311 return;
1313 info->addr_source = "hardcoded";
1315 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
1316 info->si_type = SI_KCS;
1317 } else if (strcmp(si_type[i], "smic") == 0) {
1318 info->si_type = SI_SMIC;
1319 } else if (strcmp(si_type[i], "bt") == 0) {
1320 info->si_type = SI_BT;
1321 } else {
1322 printk(KERN_WARNING
1323 "ipmi_si: Interface type specified "
1324 "for interface %d, was invalid: %s\n",
1325 i, si_type[i]);
1326 kfree(info);
1327 continue;
1330 if (ports[i]) {
1331 /* An I/O port */
1332 info->io_setup = port_setup;
1333 info->io.addr_data = ports[i];
1334 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1335 } else if (addrs[i]) {
1336 /* A memory port */
1337 info->io_setup = mem_setup;
1338 info->io.addr_data = addrs[i];
1339 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1340 } else {
1341 printk(KERN_WARNING
1342 "ipmi_si: Interface type specified "
1343 "for interface %d, "
1344 "but port and address were not set or "
1345 "set to zero.\n", i);
1346 kfree(info);
1347 continue;
1350 info->io.addr = NULL;
1351 info->io.regspacing = regspacings[i];
1352 if (!info->io.regspacing)
1353 info->io.regspacing = DEFAULT_REGSPACING;
1354 info->io.regsize = regsizes[i];
1355 if (!info->io.regsize)
1356 info->io.regsize = DEFAULT_REGSPACING;
1357 info->io.regshift = regshifts[i];
1358 info->irq = irqs[i];
1359 if (info->irq)
1360 info->irq_setup = std_irq_setup;
1362 try_smi_init(info);
1366 #ifdef CONFIG_ACPI
1368 #include <linux/acpi.h>
1370 /* Once we get an ACPI failure, we don't try any more, because we go
1371 through the tables sequentially. Once we don't find a table, there
1372 are no more. */
1373 static int acpi_failure = 0;
1375 /* For GPE-type interrupts. */
1376 static u32 ipmi_acpi_gpe(void *context)
1378 struct smi_info *smi_info = context;
1379 unsigned long flags;
1380 #ifdef DEBUG_TIMING
1381 struct timeval t;
1382 #endif
1384 spin_lock_irqsave(&(smi_info->si_lock), flags);
1386 spin_lock(&smi_info->count_lock);
1387 smi_info->interrupts++;
1388 spin_unlock(&smi_info->count_lock);
1390 if (atomic_read(&smi_info->stop_operation))
1391 goto out;
1393 #ifdef DEBUG_TIMING
1394 do_gettimeofday(&t);
1395 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1396 #endif
1397 smi_event_handler(smi_info, 0);
1398 out:
1399 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1401 return ACPI_INTERRUPT_HANDLED;
1404 static void acpi_gpe_irq_cleanup(struct smi_info *info)
1406 if (!info->irq)
1407 return;
1409 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1412 static int acpi_gpe_irq_setup(struct smi_info *info)
1414 acpi_status status;
1416 if (!info->irq)
1417 return 0;
1419 /* FIXME - is level triggered right? */
1420 status = acpi_install_gpe_handler(NULL,
1421 info->irq,
1422 ACPI_GPE_LEVEL_TRIGGERED,
1423 &ipmi_acpi_gpe,
1424 info);
1425 if (status != AE_OK) {
1426 printk(KERN_WARNING
1427 "ipmi_si: %s unable to claim ACPI GPE %d,"
1428 " running polled\n",
1429 DEVICE_NAME, info->irq);
1430 info->irq = 0;
1431 return -EINVAL;
1432 } else {
1433 info->irq_cleanup = acpi_gpe_irq_cleanup;
1434 printk(" Using ACPI GPE %d\n", info->irq);
1435 return 0;
1439 /*
1440 * Defined at
1441 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1442 */
1443 struct SPMITable {
1444 s8 Signature[4];
1445 u32 Length;
1446 u8 Revision;
1447 u8 Checksum;
1448 s8 OEMID[6];
1449 s8 OEMTableID[8];
1450 s8 OEMRevision[4];
1451 s8 CreatorID[4];
1452 s8 CreatorRevision[4];
1453 u8 InterfaceType;
1454 u8 IPMIlegacy;
1455 s16 SpecificationRevision;
1457 /*
1458 * Bit 0 - SCI interrupt supported
1459 * Bit 1 - I/O APIC/SAPIC
1460 */
1461 u8 InterruptType;
1463 /* If bit 0 of InterruptType is set, then this is the SCI
1464 interrupt in the GPEx_STS register. */
1465 u8 GPE;
1467 s16 Reserved;
1469 /* If bit 1 of InterruptType is set, then this is the I/O
1470 APIC/SAPIC interrupt. */
1471 u32 GlobalSystemInterrupt;
1473 /* The actual register address. */
1474 struct acpi_generic_address addr;
1476 u8 UID[4];
1478 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1479 };
1481 static __devinit int try_init_acpi(struct SPMITable *spmi)
1483 struct smi_info *info;
1484 char *io_type;
1485 u8 addr_space;
1487 if (spmi->IPMIlegacy != 1) {
1488 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1489 return -ENODEV;
1492 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1493 addr_space = IPMI_MEM_ADDR_SPACE;
1494 else
1495 addr_space = IPMI_IO_ADDR_SPACE;
1497 info = kzalloc(sizeof(*info), GFP_KERNEL);
1498 if (!info) {
1499 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1500 return -ENOMEM;
1503 info->addr_source = "ACPI";
1505 /* Figure out the interface type. */
1506 switch (spmi->InterfaceType)
1508 case 1: /* KCS */
1509 info->si_type = SI_KCS;
1510 break;
1511 case 2: /* SMIC */
1512 info->si_type = SI_SMIC;
1513 break;
1514 case 3: /* BT */
1515 info->si_type = SI_BT;
1516 break;
1517 default:
1518 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1519 spmi->InterfaceType);
1520 kfree(info);
1521 return -EIO;
1524 if (spmi->InterruptType & 1) {
1525 /* We've got a GPE interrupt. */
1526 info->irq = spmi->GPE;
1527 info->irq_setup = acpi_gpe_irq_setup;
1528 } else if (spmi->InterruptType & 2) {
1529 /* We've got an APIC/SAPIC interrupt. */
1530 info->irq = spmi->GlobalSystemInterrupt;
1531 info->irq_setup = std_irq_setup;
1532 } else {
1533 /* Use the default interrupt setting. */
1534 info->irq = 0;
1535 info->irq_setup = NULL;
1538 if (spmi->addr.register_bit_width) {
1539 /* A (hopefully) properly formed register bit width. */
1540 info->io.regspacing = spmi->addr.register_bit_width / 8;
1541 } else {
1542 info->io.regspacing = DEFAULT_REGSPACING;
1544 info->io.regsize = info->io.regspacing;
1545 info->io.regshift = spmi->addr.register_bit_offset;
1547 if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1548 io_type = "memory";
1549 info->io_setup = mem_setup;
1550 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1551 } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1552 io_type = "I/O";
1553 info->io_setup = port_setup;
1554 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1555 } else {
1556 kfree(info);
1557 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1558 return -EIO;
1560 info->io.addr_data = spmi->addr.address;
1562 try_smi_init(info);
1564 return 0;
1567 static __devinit void acpi_find_bmc(void)
1569 acpi_status status;
1570 struct SPMITable *spmi;
1571 int i;
1573 if (acpi_disabled)
1574 return;
1576 if (acpi_failure)
1577 return;
1579 for (i = 0; ; i++) {
1580 status = acpi_get_firmware_table("SPMI", i+1,
1581 ACPI_LOGICAL_ADDRESSING,
1582 (struct acpi_table_header **)
1583 &spmi);
1584 if (status != AE_OK)
1585 return;
1587 try_init_acpi(spmi);
1590 #endif
1592 #ifdef CONFIG_DMI
1593 struct dmi_ipmi_data
1595 u8 type;
1596 u8 addr_space;
1597 unsigned long base_addr;
1598 u8 irq;
1599 u8 offset;
1600 u8 slave_addr;
1601 };
1603 static int __devinit decode_dmi(struct dmi_header *dm,
1604 struct dmi_ipmi_data *dmi)
1606 u8 *data = (u8 *)dm;
1607 unsigned long base_addr;
1608 u8 reg_spacing;
1609 u8 len = dm->length;
1611 dmi->type = data[4];
1613 memcpy(&base_addr, data+8, sizeof(unsigned long));
1614 if (len >= 0x11) {
1615 if (base_addr & 1) {
1616 /* I/O */
1617 base_addr &= 0xFFFE;
1618 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1620 else {
1621 /* Memory */
1622 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1624 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1625 is odd. */
1626 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1628 dmi->irq = data[0x11];
1630 /* The top two bits of byte 0x10 hold the register spacing. */
1631 reg_spacing = (data[0x10] & 0xC0) >> 6;
1632 switch(reg_spacing){
1633 case 0x00: /* Byte boundaries */
1634 dmi->offset = 1;
1635 break;
1636 case 0x01: /* 32-bit boundaries */
1637 dmi->offset = 4;
1638 break;
1639 case 0x02: /* 16-byte boundaries */
1640 dmi->offset = 16;
1641 break;
1642 default:
1643 /* Some other interface, just ignore it. */
1644 return -EIO;
1646 } else {
1647 /* Old DMI spec. */
1648 /* Note that technically, the lower bit of the base
1649 * address should be 1 if the address is I/O and 0 if
1650 * the address is in memory. So many systems get that
1651 * wrong (and all that I have seen are I/O) so we just
1652 * ignore that bit and assume I/O. Systems that use
1653 * memory should use the newer spec, anyway. */
1654 dmi->base_addr = base_addr & 0xfffe;
1655 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1656 dmi->offset = 1;
1659 dmi->slave_addr = data[6];
1661 return 0;
1664 static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
1666 struct smi_info *info;
1668 info = kzalloc(sizeof(*info), GFP_KERNEL);
1669 if (!info) {
1670 printk(KERN_ERR
1671 "ipmi_si: Could not allocate SI data\n");
1672 return;
1675 info->addr_source = "SMBIOS";
1677 switch (ipmi_data->type) {
1678 case 0x01: /* KCS */
1679 info->si_type = SI_KCS;
1680 break;
1681 case 0x02: /* SMIC */
1682 info->si_type = SI_SMIC;
1683 break;
1684 case 0x03: /* BT */
1685 info->si_type = SI_BT;
1686 break;
1687 default:
1688 return;
1691 switch (ipmi_data->addr_space) {
1692 case IPMI_MEM_ADDR_SPACE:
1693 info->io_setup = mem_setup;
1694 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1695 break;
1697 case IPMI_IO_ADDR_SPACE:
1698 info->io_setup = port_setup;
1699 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1700 break;
1702 default:
1703 kfree(info);
1704 printk(KERN_WARNING
1705 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
1706 ipmi_data->addr_space);
1707 return;
1709 info->io.addr_data = ipmi_data->base_addr;
1711 info->io.regspacing = ipmi_data->offset;
1712 if (!info->io.regspacing)
1713 info->io.regspacing = DEFAULT_REGSPACING;
1714 info->io.regsize = DEFAULT_REGSPACING;
1715 info->io.regshift = 0;
1717 info->slave_addr = ipmi_data->slave_addr;
1719 info->irq = ipmi_data->irq;
1720 if (info->irq)
1721 info->irq_setup = std_irq_setup;
1723 try_smi_init(info);
1726 static void __devinit dmi_find_bmc(void)
1728 struct dmi_device *dev = NULL;
1729 struct dmi_ipmi_data data;
1730 int rv;
1732 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
1733 rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
1734 if (!rv)
1735 try_init_dmi(&data);
1738 #endif /* CONFIG_DMI */
1740 #ifdef CONFIG_PCI
1742 #define PCI_ERMC_CLASSCODE 0x0C0700
1743 #define PCI_ERMC_CLASSCODE_MASK 0xffffff00
1744 #define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
1745 #define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
1746 #define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
1747 #define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
1749 #define PCI_HP_VENDOR_ID 0x103C
1750 #define PCI_MMC_DEVICE_ID 0x121A
1751 #define PCI_MMC_ADDR_CW 0x10
1753 static void ipmi_pci_cleanup(struct smi_info *info)
1755 struct pci_dev *pdev = info->addr_source_data;
1757 pci_disable_device(pdev);
1760 static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
1761 const struct pci_device_id *ent)
1763 int rv;
1764 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
1765 struct smi_info *info;
1766 int first_reg_offset = 0;
1768 info = kzalloc(sizeof(*info), GFP_KERNEL);
1769 if (!info)
1770 return ENOMEM;
1772 info->addr_source = "PCI";
1774 switch (class_type) {
1775 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
1776 info->si_type = SI_SMIC;
1777 break;
1779 case PCI_ERMC_CLASSCODE_TYPE_KCS:
1780 info->si_type = SI_KCS;
1781 break;
1783 case PCI_ERMC_CLASSCODE_TYPE_BT:
1784 info->si_type = SI_BT;
1785 break;
1787 default:
1788 kfree(info);
1789 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
1790 pci_name(pdev), class_type);
1791 return ENOMEM;
1794 rv = pci_enable_device(pdev);
1795 if (rv) {
1796 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
1797 pci_name(pdev));
1798 kfree(info);
1799 return rv;
1802 info->addr_source_cleanup = ipmi_pci_cleanup;
1803 info->addr_source_data = pdev;
1805 if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
1806 first_reg_offset = 1;
1808 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
1809 info->io_setup = port_setup;
1810 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1811 } else {
1812 info->io_setup = mem_setup;
1813 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1815 info->io.addr_data = pci_resource_start(pdev, 0);
1817 info->io.regspacing = DEFAULT_REGSPACING;
1818 info->io.regsize = DEFAULT_REGSPACING;
1819 info->io.regshift = 0;
1821 info->irq = pdev->irq;
1822 if (info->irq)
1823 info->irq_setup = std_irq_setup;
1825 info->dev = &pdev->dev;
1827 return try_smi_init(info);
1830 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
1834 #ifdef CONFIG_PM
1835 static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
1837 return 0;
1840 static int ipmi_pci_resume(struct pci_dev *pdev)
1842 return 0;
1844 #endif
1846 static struct pci_device_id ipmi_pci_devices[] = {
1847 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
1848 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) }
1849 };
1850 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
1852 static struct pci_driver ipmi_pci_driver = {
1853 .name = DEVICE_NAME,
1854 .id_table = ipmi_pci_devices,
1855 .probe = ipmi_pci_probe,
1856 .remove = __devexit_p(ipmi_pci_remove),
1857 #ifdef CONFIG_PM
1858 .suspend = ipmi_pci_suspend,
1859 .resume = ipmi_pci_resume,
1860 #endif
1861 };
1862 #endif /* CONFIG_PCI */
1865 static int try_get_dev_id(struct smi_info *smi_info)
1867 unsigned char msg[2];
1868 unsigned char *resp;
1869 unsigned long resp_len;
1870 enum si_sm_result smi_result;
1871 int rv = 0;
1873 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1874 if (!resp)
1875 return -ENOMEM;
1877 /* Do a Get Device ID command, since it comes back with some
1878 useful info. */
1879 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1880 msg[1] = IPMI_GET_DEVICE_ID_CMD;
1881 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
1883 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
1884 for (;;)
1886 if (smi_result == SI_SM_CALL_WITH_DELAY ||
1887 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
1888 schedule_timeout_uninterruptible(1);
1889 smi_result = smi_info->handlers->event(
1890 smi_info->si_sm, 100);
1892 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1894 smi_result = smi_info->handlers->event(
1895 smi_info->si_sm, 0);
1897 else
1898 break;
1900 if (smi_result == SI_SM_HOSED) {
1901 /* We couldn't get the state machine to run, so whatever's at
1902 the port is probably not an IPMI SMI interface. */
1903 rv = -ENODEV;
1904 goto out;
1907 /* Otherwise, we got some data. */
1908 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
1909 resp, IPMI_MAX_MSG_LENGTH);
1910 if (resp_len < 14) {
1911 /* That's odd, it should be longer. */
1912 rv = -EINVAL;
1913 goto out;
1916 if ((resp[1] != IPMI_GET_DEVICE_ID_CMD) || (resp[2] != 0)) {
1917 /* That's odd, it shouldn't be able to fail. */
1918 rv = -EINVAL;
1919 goto out;
1922 /* Record info from the get device id, in case we need it. */
1923 ipmi_demangle_device_id(resp+3, resp_len-3, &smi_info->device_id);
1925 out:
1926 kfree(resp);
1927 return rv;
1930 static int type_file_read_proc(char *page, char **start, off_t off,
1931 int count, int *eof, void *data)
1933 char *out = (char *) page;
1934 struct smi_info *smi = data;
1936 switch (smi->si_type) {
1937 case SI_KCS:
1938 return sprintf(out, "kcs\n");
1939 case SI_SMIC:
1940 return sprintf(out, "smic\n");
1941 case SI_BT:
1942 return sprintf(out, "bt\n");
1943 default:
1944 return 0;
1948 static int stat_file_read_proc(char *page, char **start, off_t off,
1949 int count, int *eof, void *data)
1951 char *out = (char *) page;
1952 struct smi_info *smi = data;
1954 out += sprintf(out, "interrupts_enabled: %d\n",
1955 smi->irq && !smi->interrupt_disabled);
1956 out += sprintf(out, "short_timeouts: %ld\n",
1957 smi->short_timeouts);
1958 out += sprintf(out, "long_timeouts: %ld\n",
1959 smi->long_timeouts);
1960 out += sprintf(out, "timeout_restarts: %ld\n",
1961 smi->timeout_restarts);
1962 out += sprintf(out, "idles: %ld\n",
1963 smi->idles);
1964 out += sprintf(out, "interrupts: %ld\n",
1965 smi->interrupts);
1966 out += sprintf(out, "attentions: %ld\n",
1967 smi->attentions);
1968 out += sprintf(out, "flag_fetches: %ld\n",
1969 smi->flag_fetches);
1970 out += sprintf(out, "hosed_count: %ld\n",
1971 smi->hosed_count);
1972 out += sprintf(out, "complete_transactions: %ld\n",
1973 smi->complete_transactions);
1974 out += sprintf(out, "events: %ld\n",
1975 smi->events);
1976 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
1977 smi->watchdog_pretimeouts);
1978 out += sprintf(out, "incoming_messages: %ld\n",
1979 smi->incoming_messages);
1981 return (out - ((char *) page));
1984 /*
1985 * oem_data_avail_to_receive_msg_avail
1986 * @info - smi_info structure with msg_flags set
1988 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
1989 * Returns 1 indicating need to re-run handle_flags().
1990 */
1991 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
1993 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
1994 RECEIVE_MSG_AVAIL);
1995 return 1;
1998 /*
1999 * setup_dell_poweredge_oem_data_handler
2000 * @info - smi_info.device_id must be populated
2002 * Systems that match, but have firmware version < 1.40 may assert
2003 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2004 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2005 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2006 * as RECEIVE_MSG_AVAIL instead.
2008 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2009 * assert the OEM[012] bits, and if it did, the driver would have to
2010 * change to handle that properly, we don't actually check for the
2011 * firmware version.
2012 * Device ID = 0x20 BMC on PowerEdge 8G servers
2013 * Device Revision = 0x80
2014 * Firmware Revision1 = 0x01 BMC version 1.40
2015 * Firmware Revision2 = 0x40 BCD encoded
2016 * IPMI Version = 0x51 IPMI 1.5
2017 * Manufacturer ID = A2 02 00 Dell IANA
2019 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2020 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2022 */
2023 #define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2024 #define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2025 #define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
2026 #define DELL_IANA_MFR_ID 0x0002a2
2027 static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2029 struct ipmi_device_id *id = &smi_info->device_id;
2030 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
2031 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2032 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
2033 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
2034 smi_info->oem_data_avail_handler =
2035 oem_data_avail_to_receive_msg_avail;
2037 else if (ipmi_version_major(id) < 1 ||
2038 (ipmi_version_major(id) == 1 &&
2039 ipmi_version_minor(id) < 5)) {
2040 smi_info->oem_data_avail_handler =
2041 oem_data_avail_to_receive_msg_avail;
2046 #define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2047 static void return_hosed_msg_badsize(struct smi_info *smi_info)
2049 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2051 /* Make it a reponse */
2052 msg->rsp[0] = msg->data[0] | 4;
2053 msg->rsp[1] = msg->data[1];
2054 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2055 msg->rsp_size = 3;
2056 smi_info->curr_msg = NULL;
2057 deliver_recv_msg(smi_info, msg);
2060 /*
2061 * dell_poweredge_bt_xaction_handler
2062 * @info - smi_info.device_id must be populated
2064 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2065 * not respond to a Get SDR command if the length of the data
2066 * requested is exactly 0x3A, which leads to command timeouts and no
2067 * data returned. This intercepts such commands, and causes userspace
2068 * callers to try again with a different-sized buffer, which succeeds.
2069 */
2071 #define STORAGE_NETFN 0x0A
2072 #define STORAGE_CMD_GET_SDR 0x23
2073 static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2074 unsigned long unused,
2075 void *in)
2077 struct smi_info *smi_info = in;
2078 unsigned char *data = smi_info->curr_msg->data;
2079 unsigned int size = smi_info->curr_msg->data_size;
2080 if (size >= 8 &&
2081 (data[0]>>2) == STORAGE_NETFN &&
2082 data[1] == STORAGE_CMD_GET_SDR &&
2083 data[7] == 0x3A) {
2084 return_hosed_msg_badsize(smi_info);
2085 return NOTIFY_STOP;
2087 return NOTIFY_DONE;
2090 static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2091 .notifier_call = dell_poweredge_bt_xaction_handler,
2092 };
2094 /*
2095 * setup_dell_poweredge_bt_xaction_handler
2096 * @info - smi_info.device_id must be filled in already
2098 * Fills in smi_info.device_id.start_transaction_pre_hook
2099 * when we know what function to use there.
2100 */
2101 static void
2102 setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2104 struct ipmi_device_id *id = &smi_info->device_id;
2105 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
2106 smi_info->si_type == SI_BT)
2107 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2110 /*
2111 * setup_oem_data_handler
2112 * @info - smi_info.device_id must be filled in already
2114 * Fills in smi_info.device_id.oem_data_available_handler
2115 * when we know what function to use there.
2116 */
2118 static void setup_oem_data_handler(struct smi_info *smi_info)
2120 setup_dell_poweredge_oem_data_handler(smi_info);
2123 static void setup_xaction_handlers(struct smi_info *smi_info)
2125 setup_dell_poweredge_bt_xaction_handler(smi_info);
2128 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2130 if (smi_info->intf) {
2131 /* The timer and thread are only running if the
2132 interface has been started up and registered. */
2133 if (smi_info->thread != NULL)
2134 kthread_stop(smi_info->thread);
2135 del_timer_sync(&smi_info->si_timer);
2139 static __devinitdata struct ipmi_default_vals
2141 int type;
2142 int port;
2143 } ipmi_defaults[] =
2145 { .type = SI_KCS, .port = 0xca2 },
2146 { .type = SI_SMIC, .port = 0xca9 },
2147 { .type = SI_BT, .port = 0xe4 },
2148 { .port = 0 }
2149 };
2151 static __devinit void default_find_bmc(void)
2153 struct smi_info *info;
2154 int i;
2156 for (i = 0; ; i++) {
2157 if (!ipmi_defaults[i].port)
2158 break;
2160 info = kzalloc(sizeof(*info), GFP_KERNEL);
2161 if (!info)
2162 return;
2164 info->addr_source = NULL;
2166 info->si_type = ipmi_defaults[i].type;
2167 info->io_setup = port_setup;
2168 info->io.addr_data = ipmi_defaults[i].port;
2169 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2171 info->io.addr = NULL;
2172 info->io.regspacing = DEFAULT_REGSPACING;
2173 info->io.regsize = DEFAULT_REGSPACING;
2174 info->io.regshift = 0;
2176 if (try_smi_init(info) == 0) {
2177 /* Found one... */
2178 printk(KERN_INFO "ipmi_si: Found default %s state"
2179 " machine at %s address 0x%lx\n",
2180 si_to_str[info->si_type],
2181 addr_space_to_str[info->io.addr_type],
2182 info->io.addr_data);
2183 return;
2188 static int is_new_interface(struct smi_info *info)
2190 struct smi_info *e;
2192 list_for_each_entry(e, &smi_infos, link) {
2193 if (e->io.addr_type != info->io.addr_type)
2194 continue;
2195 if (e->io.addr_data == info->io.addr_data)
2196 return 0;
2199 return 1;
2202 static int try_smi_init(struct smi_info *new_smi)
2204 int rv;
2206 if (new_smi->addr_source) {
2207 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2208 " machine at %s address 0x%lx, slave address 0x%x,"
2209 " irq %d\n",
2210 new_smi->addr_source,
2211 si_to_str[new_smi->si_type],
2212 addr_space_to_str[new_smi->io.addr_type],
2213 new_smi->io.addr_data,
2214 new_smi->slave_addr, new_smi->irq);
2217 mutex_lock(&smi_infos_lock);
2218 if (!is_new_interface(new_smi)) {
2219 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2220 rv = -EBUSY;
2221 goto out_err;
2224 /* So we know not to free it unless we have allocated one. */
2225 new_smi->intf = NULL;
2226 new_smi->si_sm = NULL;
2227 new_smi->handlers = NULL;
2229 switch (new_smi->si_type) {
2230 case SI_KCS:
2231 new_smi->handlers = &kcs_smi_handlers;
2232 break;
2234 case SI_SMIC:
2235 new_smi->handlers = &smic_smi_handlers;
2236 break;
2238 case SI_BT:
2239 new_smi->handlers = &bt_smi_handlers;
2240 break;
2242 default:
2243 /* No support for anything else yet. */
2244 rv = -EIO;
2245 goto out_err;
2248 /* Allocate the state machine's data and initialize it. */
2249 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
2250 if (!new_smi->si_sm) {
2251 printk(" Could not allocate state machine memory\n");
2252 rv = -ENOMEM;
2253 goto out_err;
2255 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2256 &new_smi->io);
2258 /* Now that we know the I/O size, we can set up the I/O. */
2259 rv = new_smi->io_setup(new_smi);
2260 if (rv) {
2261 printk(" Could not set up I/O space\n");
2262 goto out_err;
2265 spin_lock_init(&(new_smi->si_lock));
2266 spin_lock_init(&(new_smi->msg_lock));
2267 spin_lock_init(&(new_smi->count_lock));
2269 /* Do low-level detection first. */
2270 if (new_smi->handlers->detect(new_smi->si_sm)) {
2271 if (new_smi->addr_source)
2272 printk(KERN_INFO "ipmi_si: Interface detection"
2273 " failed\n");
2274 rv = -ENODEV;
2275 goto out_err;
2278 /* Attempt a get device id command. If it fails, we probably
2279 don't have a BMC here. */
2280 rv = try_get_dev_id(new_smi);
2281 if (rv) {
2282 if (new_smi->addr_source)
2283 printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2284 " at this location\n");
2285 goto out_err;
2288 setup_oem_data_handler(new_smi);
2289 setup_xaction_handlers(new_smi);
2291 /* Try to claim any interrupts. */
2292 if (new_smi->irq_setup)
2293 new_smi->irq_setup(new_smi);
2295 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2296 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2297 new_smi->curr_msg = NULL;
2298 atomic_set(&new_smi->req_events, 0);
2299 new_smi->run_to_completion = 0;
2301 new_smi->interrupt_disabled = 0;
2302 atomic_set(&new_smi->stop_operation, 0);
2303 new_smi->intf_num = smi_num;
2304 smi_num++;
2306 /* Start clearing the flags before we enable interrupts or the
2307 timer to avoid racing with the timer. */
2308 start_clear_flags(new_smi);
2309 /* IRQ is defined to be set when non-zero. */
2310 if (new_smi->irq)
2311 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2313 if (!new_smi->dev) {
2314 /* If we don't already have a device from something
2315 * else (like PCI), then register a new one. */
2316 new_smi->pdev = platform_device_alloc("ipmi_si",
2317 new_smi->intf_num);
2318 if (rv) {
2319 printk(KERN_ERR
2320 "ipmi_si_intf:"
2321 " Unable to allocate platform device\n");
2322 goto out_err;
2324 new_smi->dev = &new_smi->pdev->dev;
2325 new_smi->dev->driver = &ipmi_driver;
2327 rv = platform_device_register(new_smi->pdev);
2328 if (rv) {
2329 printk(KERN_ERR
2330 "ipmi_si_intf:"
2331 " Unable to register system interface device:"
2332 " %d\n",
2333 rv);
2334 goto out_err;
2336 new_smi->dev_registered = 1;
2339 rv = ipmi_register_smi(&handlers,
2340 new_smi,
2341 &new_smi->device_id,
2342 new_smi->dev,
2343 new_smi->slave_addr);
2344 if (rv) {
2345 printk(KERN_ERR
2346 "ipmi_si: Unable to register device: error %d\n",
2347 rv);
2348 goto out_err_stop_timer;
2351 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2352 type_file_read_proc, NULL,
2353 new_smi, THIS_MODULE);
2354 if (rv) {
2355 printk(KERN_ERR
2356 "ipmi_si: Unable to create proc entry: %d\n",
2357 rv);
2358 goto out_err_stop_timer;
2361 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2362 stat_file_read_proc, NULL,
2363 new_smi, THIS_MODULE);
2364 if (rv) {
2365 printk(KERN_ERR
2366 "ipmi_si: Unable to create proc entry: %d\n",
2367 rv);
2368 goto out_err_stop_timer;
2371 list_add_tail(&new_smi->link, &smi_infos);
2373 mutex_unlock(&smi_infos_lock);
2375 printk(" IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
2377 return 0;
2379 out_err_stop_timer:
2380 atomic_inc(&new_smi->stop_operation);
2381 wait_for_timer_and_thread(new_smi);
2383 out_err:
2384 if (new_smi->intf)
2385 ipmi_unregister_smi(new_smi->intf);
2387 if (new_smi->irq_cleanup)
2388 new_smi->irq_cleanup(new_smi);
2390 /* Wait until we know that we are out of any interrupt
2391 handlers might have been running before we freed the
2392 interrupt. */
2393 synchronize_sched();
2395 if (new_smi->si_sm) {
2396 if (new_smi->handlers)
2397 new_smi->handlers->cleanup(new_smi->si_sm);
2398 kfree(new_smi->si_sm);
2400 if (new_smi->addr_source_cleanup)
2401 new_smi->addr_source_cleanup(new_smi);
2402 if (new_smi->io_cleanup)
2403 new_smi->io_cleanup(new_smi);
2405 if (new_smi->dev_registered)
2406 platform_device_unregister(new_smi->pdev);
2408 kfree(new_smi);
2410 mutex_unlock(&smi_infos_lock);
2412 return rv;
2415 static __devinit int init_ipmi_si(void)
2417 int i;
2418 char *str;
2419 int rv;
2421 if (initialized)
2422 return 0;
2423 initialized = 1;
2425 /* Register the device drivers. */
2426 rv = driver_register(&ipmi_driver);
2427 if (rv) {
2428 printk(KERN_ERR
2429 "init_ipmi_si: Unable to register driver: %d\n",
2430 rv);
2431 return rv;
2435 /* Parse out the si_type string into its components. */
2436 str = si_type_str;
2437 if (*str != '\0') {
2438 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
2439 si_type[i] = str;
2440 str = strchr(str, ',');
2441 if (str) {
2442 *str = '\0';
2443 str++;
2444 } else {
2445 break;
2450 printk(KERN_INFO "IPMI System Interface driver.\n");
2452 hardcode_find_bmc();
2454 #ifdef CONFIG_DMI
2455 dmi_find_bmc();
2456 #endif
2458 #ifdef CONFIG_ACPI
2459 if (si_trydefaults)
2460 acpi_find_bmc();
2461 #endif
2463 #ifdef CONFIG_PCI
2464 pci_module_init(&ipmi_pci_driver);
2465 #endif
2467 if (si_trydefaults) {
2468 mutex_lock(&smi_infos_lock);
2469 if (list_empty(&smi_infos)) {
2470 /* No BMC was found, try defaults. */
2471 mutex_unlock(&smi_infos_lock);
2472 default_find_bmc();
2473 } else {
2474 mutex_unlock(&smi_infos_lock);
2478 mutex_lock(&smi_infos_lock);
2479 if (list_empty(&smi_infos)) {
2480 mutex_unlock(&smi_infos_lock);
2481 #ifdef CONFIG_PCI
2482 pci_unregister_driver(&ipmi_pci_driver);
2483 #endif
2484 driver_unregister(&ipmi_driver);
2485 printk("ipmi_si: Unable to find any System Interface(s)\n");
2486 return -ENODEV;
2487 } else {
2488 mutex_unlock(&smi_infos_lock);
2489 return 0;
2492 module_init(init_ipmi_si);
2494 static void __devexit cleanup_one_si(struct smi_info *to_clean)
2496 int rv;
2497 unsigned long flags;
2499 if (!to_clean)
2500 return;
2502 list_del(&to_clean->link);
2504 /* Tell the timer and interrupt handlers that we are shutting
2505 down. */
2506 spin_lock_irqsave(&(to_clean->si_lock), flags);
2507 spin_lock(&(to_clean->msg_lock));
2509 atomic_inc(&to_clean->stop_operation);
2511 if (to_clean->irq_cleanup)
2512 to_clean->irq_cleanup(to_clean);
2514 spin_unlock(&(to_clean->msg_lock));
2515 spin_unlock_irqrestore(&(to_clean->si_lock), flags);
2517 /* Wait until we know that we are out of any interrupt
2518 handlers might have been running before we freed the
2519 interrupt. */
2520 synchronize_sched();
2522 wait_for_timer_and_thread(to_clean);
2524 /* Interrupts and timeouts are stopped, now make sure the
2525 interface is in a clean state. */
2526 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
2527 poll(to_clean);
2528 schedule_timeout_uninterruptible(1);
2531 rv = ipmi_unregister_smi(to_clean->intf);
2532 if (rv) {
2533 printk(KERN_ERR
2534 "ipmi_si: Unable to unregister device: errno=%d\n",
2535 rv);
2538 to_clean->handlers->cleanup(to_clean->si_sm);
2540 kfree(to_clean->si_sm);
2542 if (to_clean->addr_source_cleanup)
2543 to_clean->addr_source_cleanup(to_clean);
2544 if (to_clean->io_cleanup)
2545 to_clean->io_cleanup(to_clean);
2547 if (to_clean->dev_registered)
2548 platform_device_unregister(to_clean->pdev);
2550 kfree(to_clean);
2553 static __exit void cleanup_ipmi_si(void)
2555 struct smi_info *e, *tmp_e;
2557 if (!initialized)
2558 return;
2560 #ifdef CONFIG_PCI
2561 pci_unregister_driver(&ipmi_pci_driver);
2562 #endif
2564 mutex_lock(&smi_infos_lock);
2565 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
2566 cleanup_one_si(e);
2567 mutex_unlock(&smi_infos_lock);
2569 driver_unregister(&ipmi_driver);
2571 module_exit(cleanup_ipmi_si);
2573 MODULE_LICENSE("GPL");
2574 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
2575 MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");