]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/char/ipmi/ipmi_si_intf.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ipc: sysvsem: refuse clone(CLONE_SYSVSEM|CLONE_NEWIPC)
[net-next-2.6.git] / drivers / char / ipmi / ipmi_si_intf.c
CommitLineData
1da177e4
LT		 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.
dba9b4f6 12 * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
1da177e4
LT		 13 *
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.
18 *
19 *
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.
30 *
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.
34 */
35
36/*
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.
40 */
41
1da177e4
LT		 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>
ea94027b 54#include <linux/notifier.h>
b0defcdb 55#include <linux/mutex.h>
e9a705a0 56#include <linux/kthread.h>
1da177e4 57#include <asm/irq.h>
1da177e4
LT		 58#include <linux/interrupt.h>
59#include <linux/rcupdate.h>
60#include <linux/ipmi_smi.h>
61#include <asm/io.h>
62#include "ipmi_si_sm.h"
63#include <linux/init.h>
b224cd3a 64#include <linux/dmi.h>
b361e27b
CM		 65#include <linux/string.h>
66#include <linux/ctype.h>
67
dba9b4f6
CM		 68#ifdef CONFIG_PPC_OF
69#include <asm/of_device.h>
70#include <asm/of_platform.h>
71#endif
72
b361e27b 73#define PFX "ipmi_si: "
1da177e4
LT		 74
75/* Measure times between events in the driver. */
76#undef DEBUG_TIMING
77
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
83 short timeout */
84
ee6cd5f8
CM		 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
90
1da177e4
LT		 91enum si_intf_state {
92 SI_NORMAL,
93 SI_GETTING_FLAGS,
94 SI_GETTING_EVENTS,
95 SI_CLEARING_FLAGS,
96 SI_CLEARING_FLAGS_THEN_SET_IRQ,
97 SI_GETTING_MESSAGES,
98 SI_ENABLE_INTERRUPTS1,
ee6cd5f8
CM		 99 SI_ENABLE_INTERRUPTS2,
100 SI_DISABLE_INTERRUPTS1,
101 SI_DISABLE_INTERRUPTS2
1da177e4
LT		 102 /* FIXME - add watchdog stuff. */
103};
104
9dbf68f9
CM		 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
109
1da177e4
LT		 110enum si_type {
111 SI_KCS, SI_SMIC, SI_BT
112};
b361e27b 113static char *si_to_str[] = { "kcs", "smic", "bt" };
1da177e4 114
50c812b2
CM		 115#define DEVICE_NAME "ipmi_si"
116
117static struct device_driver ipmi_driver =
118{
119 .name = DEVICE_NAME,
120 .bus = &platform_bus_type
121};
3ae0e0f9 122
1da177e4
LT		 123struct smi_info
124{
a9a2c44f 125 int intf_num;
1da177e4
LT		 126 ipmi_smi_t intf;
127 struct si_sm_data *si_sm;
128 struct si_sm_handlers *handlers;
129 enum si_type si_type;
130 spinlock_t si_lock;
131 spinlock_t msg_lock;
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;
136
137 /* Used to handle the various types of I/O that can occur with
138 IPMI */
139 struct si_sm_io io;
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;
b0defcdb
CM		 145 char *addr_source; /* ACPI, PCI, SMBIOS, hardcode, default. */
146 void (*addr_source_cleanup)(struct smi_info *info);
147 void *addr_source_data;
1da177e4 148
3ae0e0f9
CM		 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.
152 */
153 int (*oem_data_avail_handler)(struct smi_info *smi_info);
154
1da177e4
LT		 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
157 from the flags. */
158#define RECEIVE_MSG_AVAIL 0x01
159#define EVENT_MSG_BUFFER_FULL 0x02
160#define WDT_PRE_TIMEOUT_INT 0x08
3ae0e0f9
CM		 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 | \
165 OEM1_DATA_AVAIL | \
166 OEM2_DATA_AVAIL)
1da177e4
LT		 167 unsigned char msg_flags;
168
169 /* If set to true, this will request events the next time the
170 state machine is idle. */
171 atomic_t req_events;
172
173 /* If true, run the state machine to completion on every send
174 call. Generally used after a panic to make sure stuff goes
175 out. */
176 int run_to_completion;
177
178 /* The I/O port of an SI interface. */
179 int port;
180
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;
185
186 /* zero if no irq; */
187 int irq;
188
189 /* The timer for this si. */
190 struct timer_list si_timer;
191
192 /* The time (in jiffies) the last timeout occurred at. */
193 unsigned long last_timeout_jiffies;
194
195 /* Used to gracefully stop the timer without race conditions. */
a9a2c44f 196 atomic_t stop_operation;
1da177e4
LT		 197
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
201 interrupts. */
202 int interrupt_disabled;
203
50c812b2 204 /* From the get device id response... */
3ae0e0f9 205 struct ipmi_device_id device_id;
1da177e4 206
50c812b2
CM		 207 /* Driver model stuff. */
208 struct device *dev;
209 struct platform_device *pdev;
210
211 /* True if we allocated the device, false if it came from
212 * someplace else (like PCI). */
213 int dev_registered;
214
1da177e4
LT		 215 /* Slave address, could be reported from DMI. */
216 unsigned char slave_addr;
217
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;
223 unsigned long idles;
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;
a9a2c44f 232
e9a705a0 233 struct task_struct *thread;
b0defcdb
CM		 234
235 struct list_head link;
1da177e4
LT		 236};
237
a51f4a81
CM		 238#define SI_MAX_PARMS 4
239
240static int force_kipmid[SI_MAX_PARMS];
241static int num_force_kipmid;
242
b361e27b
CM		 243static int unload_when_empty = 1;
244
b0defcdb 245static int try_smi_init(struct smi_info *smi);
b361e27b 246static void cleanup_one_si(struct smi_info *to_clean);
b0defcdb 247
e041c683 248static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
ea94027b
CM		 249static int register_xaction_notifier(struct notifier_block * nb)
250{
e041c683 251 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
ea94027b
CM		 252}
253
1da177e4
LT		 254static void deliver_recv_msg(struct smi_info *smi_info,
255 struct ipmi_smi_msg *msg)
256{
257 /* Deliver the message to the upper layer with the lock
258 released. */
259 spin_unlock(&(smi_info->si_lock));
260 ipmi_smi_msg_received(smi_info->intf, msg);
261 spin_lock(&(smi_info->si_lock));
262}
263
4d7cbac7 264static void return_hosed_msg(struct smi_info *smi_info, int cCode)
1da177e4
LT		 265{
266 struct ipmi_smi_msg *msg = smi_info->curr_msg;
267
4d7cbac7
CM		 268 if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
269 cCode = IPMI_ERR_UNSPECIFIED;
270 /* else use it as is */
271
1da177e4
LT		 272 /* Make it a reponse */
273 msg->rsp[0] = msg->data[0] | 4;
274 msg->rsp[1] = msg->data[1];
4d7cbac7 275 msg->rsp[2] = cCode;
1da177e4
LT		 276 msg->rsp_size = 3;
277
278 smi_info->curr_msg = NULL;
279 deliver_recv_msg(smi_info, msg);
280}
281
282static enum si_sm_result start_next_msg(struct smi_info *smi_info)
283{
284 int rv;
285 struct list_head *entry = NULL;
286#ifdef DEBUG_TIMING
287 struct timeval t;
288#endif
289
290 /* No need to save flags, we aleady have interrupts off and we
291 already hold the SMI lock. */
292 spin_lock(&(smi_info->msg_lock));
293
294 /* Pick the high priority queue first. */
b0defcdb 295 if (!list_empty(&(smi_info->hp_xmit_msgs))) {
1da177e4 296 entry = smi_info->hp_xmit_msgs.next;
b0defcdb 297 } else if (!list_empty(&(smi_info->xmit_msgs))) {
1da177e4
LT		 298 entry = smi_info->xmit_msgs.next;
299 }
300
b0defcdb 301 if (!entry) {
1da177e4
LT		 302 smi_info->curr_msg = NULL;
303 rv = SI_SM_IDLE;
304 } else {
305 int err;
306
307 list_del(entry);
308 smi_info->curr_msg = list_entry(entry,
309 struct ipmi_smi_msg,
310 link);
311#ifdef DEBUG_TIMING
312 do_gettimeofday(&t);
313 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
314#endif
e041c683
AS		 315 err = atomic_notifier_call_chain(&xaction_notifier_list,
316 0, smi_info);
ea94027b
CM		 317 if (err & NOTIFY_STOP_MASK) {
318 rv = SI_SM_CALL_WITHOUT_DELAY;
319 goto out;
320 }
1da177e4
LT		 321 err = smi_info->handlers->start_transaction(
322 smi_info->si_sm,
323 smi_info->curr_msg->data,
324 smi_info->curr_msg->data_size);
325 if (err) {
4d7cbac7 326 return_hosed_msg(smi_info, err);
1da177e4
LT		 327 }
328
329 rv = SI_SM_CALL_WITHOUT_DELAY;
330 }
ea94027b 331 out:
1da177e4
LT		 332 spin_unlock(&(smi_info->msg_lock));
333
334 return rv;
335}
336
337static void start_enable_irq(struct smi_info *smi_info)
338{
339 unsigned char msg[2];
340
341 /* If we are enabling interrupts, we have to tell the
342 BMC to use them. */
343 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
344 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
345
346 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
347 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
348}
349
ee6cd5f8
CM		 350static void start_disable_irq(struct smi_info *smi_info)
351{
352 unsigned char msg[2];
353
354 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
355 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
356
357 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
358 smi_info->si_state = SI_DISABLE_INTERRUPTS1;
359}
360
1da177e4
LT		 361static void start_clear_flags(struct smi_info *smi_info)
362{
363 unsigned char msg[3];
364
365 /* Make sure the watchdog pre-timeout flag is not set at startup. */
366 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
367 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
368 msg[2] = WDT_PRE_TIMEOUT_INT;
369
370 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
371 smi_info->si_state = SI_CLEARING_FLAGS;
372}
373
374/* When we have a situtaion where we run out of memory and cannot
375 allocate messages, we just leave them in the BMC and run the system
376 polled until we can allocate some memory. Once we have some
377 memory, we will re-enable the interrupt. */
378static inline void disable_si_irq(struct smi_info *smi_info)
379{
b0defcdb 380 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
ee6cd5f8 381 start_disable_irq(smi_info);
1da177e4
LT		 382 smi_info->interrupt_disabled = 1;
383 }
384}
385
386static inline void enable_si_irq(struct smi_info *smi_info)
387{
388 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
ee6cd5f8 389 start_enable_irq(smi_info);
1da177e4
LT		 390 smi_info->interrupt_disabled = 0;
391 }
392}
393
394static void handle_flags(struct smi_info *smi_info)
395{
3ae0e0f9 396 retry:
1da177e4
LT		 397 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
398 /* Watchdog pre-timeout */
399 spin_lock(&smi_info->count_lock);
400 smi_info->watchdog_pretimeouts++;
401 spin_unlock(&smi_info->count_lock);
402
403 start_clear_flags(smi_info);
404 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
405 spin_unlock(&(smi_info->si_lock));
406 ipmi_smi_watchdog_pretimeout(smi_info->intf);
407 spin_lock(&(smi_info->si_lock));
408 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
409 /* Messages available. */
410 smi_info->curr_msg = ipmi_alloc_smi_msg();
b0defcdb 411 if (!smi_info->curr_msg) {
1da177e4
LT		 412 disable_si_irq(smi_info);
413 smi_info->si_state = SI_NORMAL;
414 return;
415 }
416 enable_si_irq(smi_info);
417
418 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
419 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
420 smi_info->curr_msg->data_size = 2;
421
422 smi_info->handlers->start_transaction(
423 smi_info->si_sm,
424 smi_info->curr_msg->data,
425 smi_info->curr_msg->data_size);
426 smi_info->si_state = SI_GETTING_MESSAGES;
427 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
428 /* Events available. */
429 smi_info->curr_msg = ipmi_alloc_smi_msg();
b0defcdb 430 if (!smi_info->curr_msg) {
1da177e4
LT		 431 disable_si_irq(smi_info);
432 smi_info->si_state = SI_NORMAL;
433 return;
434 }
435 enable_si_irq(smi_info);
436
437 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
438 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
439 smi_info->curr_msg->data_size = 2;
440
441 smi_info->handlers->start_transaction(
442 smi_info->si_sm,
443 smi_info->curr_msg->data,
444 smi_info->curr_msg->data_size);
445 smi_info->si_state = SI_GETTING_EVENTS;
4064d5ef
CM		 446 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
447 smi_info->oem_data_avail_handler) {
448 if (smi_info->oem_data_avail_handler(smi_info))
449 goto retry;
1da177e4
LT		 450 } else {
451 smi_info->si_state = SI_NORMAL;
452 }
453}
454
455static void handle_transaction_done(struct smi_info *smi_info)
456{
457 struct ipmi_smi_msg *msg;
458#ifdef DEBUG_TIMING
459 struct timeval t;
460
461 do_gettimeofday(&t);
462 printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
463#endif
464 switch (smi_info->si_state) {
465 case SI_NORMAL:
b0defcdb 466 if (!smi_info->curr_msg)
1da177e4
LT		 467 break;
468
469 smi_info->curr_msg->rsp_size
470 = smi_info->handlers->get_result(
471 smi_info->si_sm,
472 smi_info->curr_msg->rsp,
473 IPMI_MAX_MSG_LENGTH);
474
475 /* Do this here becase deliver_recv_msg() releases the
476 lock, and a new message can be put in during the
477 time the lock is released. */
478 msg = smi_info->curr_msg;
479 smi_info->curr_msg = NULL;
480 deliver_recv_msg(smi_info, msg);
481 break;
482
483 case SI_GETTING_FLAGS:
484 {
485 unsigned char msg[4];
486 unsigned int len;
487
488 /* We got the flags from the SMI, now handle them. */
489 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
490 if (msg[2] != 0) {
491 /* Error fetching flags, just give up for
492 now. */
493 smi_info->si_state = SI_NORMAL;
494 } else if (len < 4) {
495 /* Hmm, no flags. That's technically illegal, but
496 don't use uninitialized data. */
497 smi_info->si_state = SI_NORMAL;
498 } else {
499 smi_info->msg_flags = msg[3];
500 handle_flags(smi_info);
501 }
502 break;
503 }
504
505 case SI_CLEARING_FLAGS:
506 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
507 {
508 unsigned char msg[3];
509
510 /* We cleared the flags. */
511 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
512 if (msg[2] != 0) {
513 /* Error clearing flags */
514 printk(KERN_WARNING
515 "ipmi_si: Error clearing flags: %2.2x\n",
516 msg[2]);
517 }
518 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
519 start_enable_irq(smi_info);
520 else
521 smi_info->si_state = SI_NORMAL;
522 break;
523 }
524
525 case SI_GETTING_EVENTS:
526 {
527 smi_info->curr_msg->rsp_size
528 = smi_info->handlers->get_result(
529 smi_info->si_sm,
530 smi_info->curr_msg->rsp,
531 IPMI_MAX_MSG_LENGTH);
532
533 /* Do this here becase deliver_recv_msg() releases the
534 lock, and a new message can be put in during the
535 time the lock is released. */
536 msg = smi_info->curr_msg;
537 smi_info->curr_msg = NULL;
538 if (msg->rsp[2] != 0) {
539 /* Error getting event, probably done. */
540 msg->done(msg);
541
542 /* Take off the event flag. */
543 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
544 handle_flags(smi_info);
545 } else {
546 spin_lock(&smi_info->count_lock);
547 smi_info->events++;
548 spin_unlock(&smi_info->count_lock);
549
550 /* Do this before we deliver the message
551 because delivering the message releases the
552 lock and something else can mess with the
553 state. */
554 handle_flags(smi_info);
555
556 deliver_recv_msg(smi_info, msg);
557 }
558 break;
559 }
560
561 case SI_GETTING_MESSAGES:
562 {
563 smi_info->curr_msg->rsp_size
564 = smi_info->handlers->get_result(
565 smi_info->si_sm,
566 smi_info->curr_msg->rsp,
567 IPMI_MAX_MSG_LENGTH);
568
569 /* Do this here becase deliver_recv_msg() releases the
570 lock, and a new message can be put in during the
571 time the lock is released. */
572 msg = smi_info->curr_msg;
573 smi_info->curr_msg = NULL;
574 if (msg->rsp[2] != 0) {
575 /* Error getting event, probably done. */
576 msg->done(msg);
577
578 /* Take off the msg flag. */
579 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
580 handle_flags(smi_info);
581 } else {
582 spin_lock(&smi_info->count_lock);
583 smi_info->incoming_messages++;
584 spin_unlock(&smi_info->count_lock);
585
586 /* Do this before we deliver the message
587 because delivering the message releases the
588 lock and something else can mess with the
589 state. */
590 handle_flags(smi_info);
591
592 deliver_recv_msg(smi_info, msg);
593 }
594 break;
595 }
596
597 case SI_ENABLE_INTERRUPTS1:
598 {
599 unsigned char msg[4];
600
601 /* We got the flags from the SMI, now handle them. */
602 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
603 if (msg[2] != 0) {
604 printk(KERN_WARNING
605 "ipmi_si: Could not enable interrupts"
606 ", failed get, using polled mode.\n");
607 smi_info->si_state = SI_NORMAL;
608 } else {
609 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
610 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
ee6cd5f8
CM		 611 msg[2] = (msg[3] |
612 IPMI_BMC_RCV_MSG_INTR |
613 IPMI_BMC_EVT_MSG_INTR);
1da177e4
LT		 614 smi_info->handlers->start_transaction(
615 smi_info->si_sm, msg, 3);
616 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
617 }
618 break;
619 }
620
621 case SI_ENABLE_INTERRUPTS2:
622 {
623 unsigned char msg[4];
624
625 /* We got the flags from the SMI, now handle them. */
626 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
627 if (msg[2] != 0) {
628 printk(KERN_WARNING
629 "ipmi_si: Could not enable interrupts"
630 ", failed set, using polled mode.\n");
631 }
632 smi_info->si_state = SI_NORMAL;
633 break;
634 }
ee6cd5f8
CM		 635
636 case SI_DISABLE_INTERRUPTS1:
637 {
638 unsigned char msg[4];
639
640 /* We got the flags from the SMI, now handle them. */
641 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
642 if (msg[2] != 0) {
643 printk(KERN_WARNING
644 "ipmi_si: Could not disable interrupts"
645 ", failed get.\n");
646 smi_info->si_state = SI_NORMAL;
647 } else {
648 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
649 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
650 msg[2] = (msg[3] &
651 ~(IPMI_BMC_RCV_MSG_INTR |
652 IPMI_BMC_EVT_MSG_INTR));
653 smi_info->handlers->start_transaction(
654 smi_info->si_sm, msg, 3);
655 smi_info->si_state = SI_DISABLE_INTERRUPTS2;
656 }
657 break;
658 }
659
660 case SI_DISABLE_INTERRUPTS2:
661 {
662 unsigned char msg[4];
663
664 /* We got the flags from the SMI, now handle them. */
665 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
666 if (msg[2] != 0) {
667 printk(KERN_WARNING
668 "ipmi_si: Could not disable interrupts"
669 ", failed set.\n");
670 }
671 smi_info->si_state = SI_NORMAL;
672 break;
673 }
1da177e4
LT		 674 }
675}
676
677/* Called on timeouts and events. Timeouts should pass the elapsed
fcfa4724
CM		 678 time, interrupts should pass in zero. Must be called with
679 si_lock held and interrupts disabled. */
1da177e4
LT		 680static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
681 int time)
682{
683 enum si_sm_result si_sm_result;
684
685 restart:
686 /* There used to be a loop here that waited a little while
687 (around 25us) before giving up. That turned out to be
688 pointless, the minimum delays I was seeing were in the 300us
689 range, which is far too long to wait in an interrupt. So
690 we just run until the state machine tells us something
691 happened or it needs a delay. */
692 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
693 time = 0;
694 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
695 {
696 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
697 }
698
699 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
700 {
701 spin_lock(&smi_info->count_lock);
702 smi_info->complete_transactions++;
703 spin_unlock(&smi_info->count_lock);
704
705 handle_transaction_done(smi_info);
706 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
707 }
708 else if (si_sm_result == SI_SM_HOSED)
709 {
710 spin_lock(&smi_info->count_lock);
711 smi_info->hosed_count++;
712 spin_unlock(&smi_info->count_lock);
713
714 /* Do the before return_hosed_msg, because that
715 releases the lock. */
716 smi_info->si_state = SI_NORMAL;
717 if (smi_info->curr_msg != NULL) {
718 /* If we were handling a user message, format
719 a response to send to the upper layer to
720 tell it about the error. */
4d7cbac7 721 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
1da177e4
LT		 722 }
723 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
724 }
725
726 /* We prefer handling attn over new messages. */
727 if (si_sm_result == SI_SM_ATTN)
728 {
729 unsigned char msg[2];
730
731 spin_lock(&smi_info->count_lock);
732 smi_info->attentions++;
733 spin_unlock(&smi_info->count_lock);
734
735 /* Got a attn, send down a get message flags to see
736 what's causing it. It would be better to handle
737 this in the upper layer, but due to the way
738 interrupts work with the SMI, that's not really
739 possible. */
740 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
741 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
742
743 smi_info->handlers->start_transaction(
744 smi_info->si_sm, msg, 2);
745 smi_info->si_state = SI_GETTING_FLAGS;
746 goto restart;
747 }
748
749 /* If we are currently idle, try to start the next message. */
750 if (si_sm_result == SI_SM_IDLE) {
751 spin_lock(&smi_info->count_lock);
752 smi_info->idles++;
753 spin_unlock(&smi_info->count_lock);
754
755 si_sm_result = start_next_msg(smi_info);
756 if (si_sm_result != SI_SM_IDLE)
757 goto restart;
758 }
759
760 if ((si_sm_result == SI_SM_IDLE)
761 && (atomic_read(&smi_info->req_events)))
762 {
763 /* We are idle and the upper layer requested that I fetch
764 events, so do so. */
55162fb1 765 atomic_set(&smi_info->req_events, 0);
1da177e4 766
55162fb1
CM		 767 smi_info->curr_msg = ipmi_alloc_smi_msg();
768 if (!smi_info->curr_msg)
769 goto out;
1da177e4 770
55162fb1
CM		 771 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
772 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
773 smi_info->curr_msg->data_size = 2;
1da177e4
LT		 774
775 smi_info->handlers->start_transaction(
55162fb1
CM		 776 smi_info->si_sm,
777 smi_info->curr_msg->data,
778 smi_info->curr_msg->data_size);
779 smi_info->si_state = SI_GETTING_EVENTS;
1da177e4
LT		 780 goto restart;
781 }
55162fb1 782 out:
1da177e4
LT		 783 return si_sm_result;
784}
785
786static void sender(void *send_info,
787 struct ipmi_smi_msg *msg,
788 int priority)
789{
790 struct smi_info *smi_info = send_info;
791 enum si_sm_result result;
792 unsigned long flags;
793#ifdef DEBUG_TIMING
794 struct timeval t;
795#endif
796
b361e27b
CM		 797 if (atomic_read(&smi_info->stop_operation)) {
798 msg->rsp[0] = msg->data[0] | 4;
799 msg->rsp[1] = msg->data[1];
800 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
801 msg->rsp_size = 3;
802 deliver_recv_msg(smi_info, msg);
803 return;
804 }
805
1da177e4
LT		 806 spin_lock_irqsave(&(smi_info->msg_lock), flags);
807#ifdef DEBUG_TIMING
808 do_gettimeofday(&t);
809 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
810#endif
811
812 if (smi_info->run_to_completion) {
813 /* If we are running to completion, then throw it in
814 the list and run transactions until everything is
815 clear. Priority doesn't matter here. */
816 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
817
818 /* We have to release the msg lock and claim the smi
819 lock in this case, because of race conditions. */
820 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
821
822 spin_lock_irqsave(&(smi_info->si_lock), flags);
823 result = smi_event_handler(smi_info, 0);
824 while (result != SI_SM_IDLE) {
825 udelay(SI_SHORT_TIMEOUT_USEC);
826 result = smi_event_handler(smi_info,
827 SI_SHORT_TIMEOUT_USEC);
828 }
829 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
830 return;
831 } else {
832 if (priority > 0) {
833 list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
834 } else {
835 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
836 }
837 }
838 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
839
840 spin_lock_irqsave(&(smi_info->si_lock), flags);
841 if ((smi_info->si_state == SI_NORMAL)
842 && (smi_info->curr_msg == NULL))
843 {
844 start_next_msg(smi_info);
1da177e4
LT		 845 }
846 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
847}
848
849static void set_run_to_completion(void *send_info, int i_run_to_completion)
850{
851 struct smi_info *smi_info = send_info;
852 enum si_sm_result result;
853 unsigned long flags;
854
855 spin_lock_irqsave(&(smi_info->si_lock), flags);
856
857 smi_info->run_to_completion = i_run_to_completion;
858 if (i_run_to_completion) {
859 result = smi_event_handler(smi_info, 0);
860 while (result != SI_SM_IDLE) {
861 udelay(SI_SHORT_TIMEOUT_USEC);
862 result = smi_event_handler(smi_info,
863 SI_SHORT_TIMEOUT_USEC);
864 }
865 }
866
867 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
868}
869
a9a2c44f
CM		 870static int ipmi_thread(void *data)
871{
872 struct smi_info *smi_info = data;
e9a705a0 873 unsigned long flags;
a9a2c44f
CM		 874 enum si_sm_result smi_result;
875
a9a2c44f 876 set_user_nice(current, 19);
e9a705a0 877 while (!kthread_should_stop()) {
a9a2c44f 878 spin_lock_irqsave(&(smi_info->si_lock), flags);
8a3628d5 879 smi_result = smi_event_handler(smi_info, 0);
a9a2c44f 880 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
e9a705a0
MD		 881 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
882 /* do nothing */
a9a2c44f 883 }
e9a705a0 884 else if (smi_result == SI_SM_CALL_WITH_DELAY)
33979734 885 schedule();
e9a705a0
MD		 886 else
887 schedule_timeout_interruptible(1);
a9a2c44f 888 }
a9a2c44f
CM		 889 return 0;
890}
891
892
1da177e4
LT		 893static void poll(void *send_info)
894{
895 struct smi_info *smi_info = send_info;
fcfa4724 896 unsigned long flags;
1da177e4 897
15c62e10
CM		 898 /*
899 * Make sure there is some delay in the poll loop so we can
900 * drive time forward and timeout things.
901 */
902 udelay(10);
fcfa4724 903 spin_lock_irqsave(&smi_info->si_lock, flags);
15c62e10 904 smi_event_handler(smi_info, 10);
fcfa4724 905 spin_unlock_irqrestore(&smi_info->si_lock, flags);
1da177e4
LT		 906}
907
908static void request_events(void *send_info)
909{
910 struct smi_info *smi_info = send_info;
911
b361e27b
CM		 912 if (atomic_read(&smi_info->stop_operation))
913 return;
914
1da177e4
LT		 915 atomic_set(&smi_info->req_events, 1);
916}
917
0c8204b3 918static int initialized;
1da177e4 919
1da177e4
LT		 920static void smi_timeout(unsigned long data)
921{
922 struct smi_info *smi_info = (struct smi_info *) data;
923 enum si_sm_result smi_result;
924 unsigned long flags;
925 unsigned long jiffies_now;
c4edff1c 926 long time_diff;
1da177e4
LT		 927#ifdef DEBUG_TIMING
928 struct timeval t;
929#endif
930
1da177e4
LT		 931 spin_lock_irqsave(&(smi_info->si_lock), flags);
932#ifdef DEBUG_TIMING
933 do_gettimeofday(&t);
934 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
935#endif
936 jiffies_now = jiffies;
c4edff1c 937 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
1da177e4
LT		 938 * SI_USEC_PER_JIFFY);
939 smi_result = smi_event_handler(smi_info, time_diff);
940
941 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
942
943 smi_info->last_timeout_jiffies = jiffies_now;
944
b0defcdb 945 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
1da177e4
LT		 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);
951 goto do_add_timer;
952 }
953
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);
1da177e4 960 smi_info->si_timer.expires = jiffies + 1;
1da177e4
LT		 961 } else {
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;
1da177e4
LT		 966 }
967
968 do_add_timer:
969 add_timer(&(smi_info->si_timer));
970}
971
7d12e780 972static irqreturn_t si_irq_handler(int irq, void *data)
1da177e4
LT		 973{
974 struct smi_info *smi_info = data;
975 unsigned long flags;
976#ifdef DEBUG_TIMING
977 struct timeval t;
978#endif
979
980 spin_lock_irqsave(&(smi_info->si_lock), flags);
981
982 spin_lock(&smi_info->count_lock);
983 smi_info->interrupts++;
984 spin_unlock(&smi_info->count_lock);
985
1da177e4
LT		 986#ifdef DEBUG_TIMING
987 do_gettimeofday(&t);
988 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
989#endif
990 smi_event_handler(smi_info, 0);
1da177e4
LT		 991 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
992 return IRQ_HANDLED;
993}
994
7d12e780 995static irqreturn_t si_bt_irq_handler(int irq, void *data)
9dbf68f9
CM		 996{
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);
7d12e780 1002 return si_irq_handler(irq, data);
9dbf68f9
CM		 1003}
1004
453823ba
CM		 1005static int smi_start_processing(void *send_info,
1006 ipmi_smi_t intf)
1007{
1008 struct smi_info *new_smi = send_info;
a51f4a81 1009 int enable = 0;
453823ba
CM		 1010
1011 new_smi->intf = intf;
1012
c45adc39
CM		 1013 /* Try to claim any interrupts. */
1014 if (new_smi->irq_setup)
1015 new_smi->irq_setup(new_smi);
1016
453823ba
CM		 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);
1021
a51f4a81
CM		 1022 /*
1023 * Check if the user forcefully enabled the daemon.
1024 */
1025 if (new_smi->intf_num < num_force_kipmid)
1026 enable = force_kipmid[new_smi->intf_num];
df3fe8de
CM		 1027 /*
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.
1030 */
a51f4a81
CM		 1031 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
1032 enable = 1;
1033
1034 if (enable) {
453823ba
CM		 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;
1043 }
1044 }
1045
1046 return 0;
1047}
9dbf68f9 1048
b9675136
CM		 1049static void set_maintenance_mode(void *send_info, int enable)
1050{
1051 struct smi_info *smi_info = send_info;
1052
1053 if (!enable)
1054 atomic_set(&smi_info->req_events, 0);
1055}
1056
1da177e4
LT		 1057static struct ipmi_smi_handlers handlers =
1058{
1059 .owner = THIS_MODULE,
453823ba 1060 .start_processing = smi_start_processing,
1da177e4
LT		 1061 .sender = sender,
1062 .request_events = request_events,
b9675136 1063 .set_maintenance_mode = set_maintenance_mode,
1da177e4
LT		 1064 .set_run_to_completion = set_run_to_completion,
1065 .poll = poll,
1066};
1067
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 */
1070
b0defcdb 1071static LIST_HEAD(smi_infos);
d6dfd131 1072static DEFINE_MUTEX(smi_infos_lock);
b0defcdb 1073static int smi_num; /* Used to sequence the SMIs */
1da177e4 1074
1da177e4 1075#define DEFAULT_REGSPACING 1
dba9b4f6 1076#define DEFAULT_REGSIZE 1
1da177e4
LT		 1077
1078static int si_trydefaults = 1;
1079static char *si_type[SI_MAX_PARMS];
1080#define MAX_SI_TYPE_STR 30
1081static char si_type_str[MAX_SI_TYPE_STR];
1082static unsigned long addrs[SI_MAX_PARMS];
64a6f950 1083static unsigned int num_addrs;
1da177e4 1084static unsigned int ports[SI_MAX_PARMS];
64a6f950 1085static unsigned int num_ports;
1da177e4 1086static int irqs[SI_MAX_PARMS];
64a6f950 1087static unsigned int num_irqs;
1da177e4 1088static int regspacings[SI_MAX_PARMS];
64a6f950 1089static unsigned int num_regspacings;
1da177e4 1090static int regsizes[SI_MAX_PARMS];
64a6f950 1091static unsigned int num_regsizes;
1da177e4 1092static int regshifts[SI_MAX_PARMS];
64a6f950 1093static unsigned int num_regshifts;
1da177e4 1094static int slave_addrs[SI_MAX_PARMS];
64a6f950 1095static unsigned int num_slave_addrs;
1da177e4 1096
b361e27b
CM		 1097#define IPMI_IO_ADDR_SPACE 0
1098#define IPMI_MEM_ADDR_SPACE 1
1d5636cc 1099static char *addr_space_to_str[] = { "i/o", "mem" };
b361e27b
CM		 1100
1101static int hotmod_handler(const char *val, struct kernel_param *kp);
1102
1103module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
1104MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See"
1105 " Documentation/IPMI.txt in the kernel sources for the"
1106 " gory details.");
1da177e4
LT		 1107
1108module_param_named(trydefaults, si_trydefaults, bool, 0);
1109MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1110 " default scan of the KCS and SMIC interface at the standard"
1111 " address");
1112module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1113MODULE_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");
64a6f950 1117module_param_array(addrs, ulong, &num_addrs, 0);
1da177e4
LT		 1118MODULE_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"
1121 " it blank.");
64a6f950 1122module_param_array(ports, uint, &num_ports, 0);
1da177e4
LT		 1123MODULE_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"
1126 " it blank.");
1127module_param_array(irqs, int, &num_irqs, 0);
1128MODULE_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"
1131 " it blank.");
1132module_param_array(regspacings, int, &num_regspacings, 0);
1133MODULE_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"
1137 " to 1.");
1138module_param_array(regsizes, int, &num_regsizes, 0);
1139MODULE_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"
1143 " register.");
1144module_param_array(regshifts, int, &num_regshifts, 0);
1145MODULE_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");
1149module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1150MODULE_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.");
a51f4a81
CM		 1154module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1155MODULE_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.");
b361e27b
CM		 1158module_param(unload_when_empty, int, 0);
1159MODULE_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.");
1da177e4
LT		 1162
1163
b0defcdb 1164static void std_irq_cleanup(struct smi_info *info)
1da177e4 1165{
b0defcdb
CM		 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);
1da177e4 1170}
1da177e4
LT		 1171
1172static int std_irq_setup(struct smi_info *info)
1173{
1174 int rv;
1175
b0defcdb 1176 if (!info->irq)
1da177e4
LT		 1177 return 0;
1178
9dbf68f9
CM		 1179 if (info->si_type == SI_BT) {
1180 rv = request_irq(info->irq,
1181 si_bt_irq_handler,
ee6cd5f8 1182 IRQF_SHARED | IRQF_DISABLED,
9dbf68f9
CM		 1183 DEVICE_NAME,
1184 info);
b0defcdb 1185 if (!rv)
9dbf68f9
CM		 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);
1189 } else
1190 rv = request_irq(info->irq,
1191 si_irq_handler,
ee6cd5f8 1192 IRQF_SHARED | IRQF_DISABLED,
9dbf68f9
CM		 1193 DEVICE_NAME,
1194 info);
1da177e4
LT		 1195 if (rv) {
1196 printk(KERN_WARNING
1197 "ipmi_si: %s unable to claim interrupt %d,"
1198 " running polled\n",
1199 DEVICE_NAME, info->irq);
1200 info->irq = 0;
1201 } else {
b0defcdb 1202 info->irq_cleanup = std_irq_cleanup;
1da177e4
LT		 1203 printk(" Using irq %d\n", info->irq);
1204 }
1205
1206 return rv;
1207}
1208
1da177e4
LT		 1209static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1210{
b0defcdb 1211 unsigned int addr = io->addr_data;
1da177e4 1212
b0defcdb 1213 return inb(addr + (offset * io->regspacing));
1da177e4
LT		 1214}
1215
1216static void port_outb(struct si_sm_io *io, unsigned int offset,
1217 unsigned char b)
1218{
b0defcdb 1219 unsigned int addr = io->addr_data;
1da177e4 1220
b0defcdb 1221 outb(b, addr + (offset * io->regspacing));
1da177e4
LT		 1222}
1223
1224static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1225{
b0defcdb 1226 unsigned int addr = io->addr_data;
1da177e4 1227
b0defcdb 1228 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1da177e4
LT		 1229}
1230
1231static void port_outw(struct si_sm_io *io, unsigned int offset,
1232 unsigned char b)
1233{
b0defcdb 1234 unsigned int addr = io->addr_data;
1da177e4 1235
b0defcdb 1236 outw(b << io->regshift, addr + (offset * io->regspacing));
1da177e4
LT		 1237}
1238
1239static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1240{
b0defcdb 1241 unsigned int addr = io->addr_data;
1da177e4 1242
b0defcdb 1243 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1da177e4
LT		 1244}
1245
1246static void port_outl(struct si_sm_io *io, unsigned int offset,
1247 unsigned char b)
1248{
b0defcdb 1249 unsigned int addr = io->addr_data;
1da177e4 1250
b0defcdb 1251 outl(b << io->regshift, addr+(offset * io->regspacing));
1da177e4
LT		 1252}
1253
1254static void port_cleanup(struct smi_info *info)
1255{
b0defcdb 1256 unsigned int addr = info->io.addr_data;
d61a3ead 1257 int idx;
1da177e4 1258
b0defcdb 1259 if (addr) {
d61a3ead
CM		 1260 for (idx = 0; idx < info->io_size; idx++) {
1261 release_region(addr + idx * info->io.regspacing,
1262 info->io.regsize);
1263 }
1da177e4 1264 }
1da177e4
LT		 1265}
1266
1267static int port_setup(struct smi_info *info)
1268{
b0defcdb 1269 unsigned int addr = info->io.addr_data;
d61a3ead 1270 int idx;
1da177e4 1271
b0defcdb 1272 if (!addr)
1da177e4
LT		 1273 return -ENODEV;
1274
1275 info->io_cleanup = port_cleanup;
1276
1277 /* Figure out the actual inb/inw/inl/etc routine to use based
1278 upon the register size. */
1279 switch (info->io.regsize) {
1280 case 1:
1281 info->io.inputb = port_inb;
1282 info->io.outputb = port_outb;
1283 break;
1284 case 2:
1285 info->io.inputb = port_inw;
1286 info->io.outputb = port_outw;
1287 break;
1288 case 4:
1289 info->io.inputb = port_inl;
1290 info->io.outputb = port_outl;
1291 break;
1292 default:
1293 printk("ipmi_si: Invalid register size: %d\n",
1294 info->io.regsize);
1295 return -EINVAL;
1296 }
1297
d61a3ead
CM		 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
1301 * port separately.
1302 */
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 */
1307 while (idx--) {
1308 release_region(addr + idx * info->io.regspacing,
1309 info->io.regsize);
1310 }
1311 return -EIO;
1312 }
1313 }
1da177e4
LT		 1314 return 0;
1315}
1316
546cfdf4 1317static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1da177e4
LT		 1318{
1319 return readb((io->addr)+(offset * io->regspacing));
1320}
1321
546cfdf4 1322static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1da177e4
LT		 1323 unsigned char b)
1324{
1325 writeb(b, (io->addr)+(offset * io->regspacing));
1326}
1327
546cfdf4 1328static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1da177e4
LT		 1329{
1330 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
64d9fe69 1331 & 0xff;
1da177e4
LT		 1332}
1333
546cfdf4 1334static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1da177e4
LT		 1335 unsigned char b)
1336{
1337 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1338}
1339
546cfdf4 1340static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1da177e4
LT		 1341{
1342 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
64d9fe69 1343 & 0xff;
1da177e4
LT		 1344}
1345
546cfdf4 1346static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1da177e4
LT		 1347 unsigned char b)
1348{
1349 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1350}
1351
1352#ifdef readq
1353static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1354{
1355 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
64d9fe69 1356 & 0xff;
1da177e4
LT		 1357}
1358
1359static void mem_outq(struct si_sm_io *io, unsigned int offset,
1360 unsigned char b)
1361{
1362 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1363}
1364#endif
1365
1366static void mem_cleanup(struct smi_info *info)
1367{
b0defcdb 1368 unsigned long addr = info->io.addr_data;
1da177e4
LT		 1369 int mapsize;
1370
1371 if (info->io.addr) {
1372 iounmap(info->io.addr);
1373
1374 mapsize = ((info->io_size * info->io.regspacing)
1375 - (info->io.regspacing - info->io.regsize));
1376
b0defcdb 1377 release_mem_region(addr, mapsize);
1da177e4 1378 }
1da177e4
LT		 1379}
1380
1381static int mem_setup(struct smi_info *info)
1382{
b0defcdb 1383 unsigned long addr = info->io.addr_data;
1da177e4
LT		 1384 int mapsize;
1385
b0defcdb 1386 if (!addr)
1da177e4
LT		 1387 return -ENODEV;
1388
1389 info->io_cleanup = mem_cleanup;
1390
1391 /* Figure out the actual readb/readw/readl/etc routine to use based
1392 upon the register size. */
1393 switch (info->io.regsize) {
1394 case 1:
546cfdf4
AD		 1395 info->io.inputb = intf_mem_inb;
1396 info->io.outputb = intf_mem_outb;
1da177e4
LT		 1397 break;
1398 case 2:
546cfdf4
AD		 1399 info->io.inputb = intf_mem_inw;
1400 info->io.outputb = intf_mem_outw;
1da177e4
LT		 1401 break;
1402 case 4:
546cfdf4
AD		 1403 info->io.inputb = intf_mem_inl;
1404 info->io.outputb = intf_mem_outl;
1da177e4
LT		 1405 break;
1406#ifdef readq
1407 case 8:
1408 info->io.inputb = mem_inq;
1409 info->io.outputb = mem_outq;
1410 break;
1411#endif
1412 default:
1413 printk("ipmi_si: Invalid register size: %d\n",
1414 info->io.regsize);
1415 return -EINVAL;
1416 }
1417
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
1422 * register. */
1423 mapsize = ((info->io_size * info->io.regspacing)
1424 - (info->io.regspacing - info->io.regsize));
1425
b0defcdb 1426 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1da177e4
LT		 1427 return -EIO;
1428
b0defcdb 1429 info->io.addr = ioremap(addr, mapsize);
1da177e4 1430 if (info->io.addr == NULL) {
b0defcdb 1431 release_mem_region(addr, mapsize);
1da177e4
LT		 1432 return -EIO;
1433 }
1434 return 0;
1435}
1436
b361e27b
CM		 1437/*
1438 * Parms come in as <op1>[:op2[:op3...]]. ops are:
1439 * add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
1440 * Options are:
1441 * rsp=<regspacing>
1442 * rsi=<regsize>
1443 * rsh=<regshift>
1444 * irq=<irq>
1445 * ipmb=<ipmb addr>
1446 */
1447enum hotmod_op { HM_ADD, HM_REMOVE };
1448struct hotmod_vals {
1449 char *name;
1450 int val;
1451};
1452static struct hotmod_vals hotmod_ops[] = {
1453 { "add", HM_ADD },
1454 { "remove", HM_REMOVE },
1455 { NULL }
1456};
1457static struct hotmod_vals hotmod_si[] = {
1458 { "kcs", SI_KCS },
1459 { "smic", SI_SMIC },
1460 { "bt", SI_BT },
1461 { NULL }
1462};
1463static struct hotmod_vals hotmod_as[] = {
1464 { "mem", IPMI_MEM_ADDR_SPACE },
1465 { "i/o", IPMI_IO_ADDR_SPACE },
1466 { NULL }
1467};
1d5636cc 1468
b361e27b
CM		 1469static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
1470{
1471 char *s;
1472 int i;
1473
1474 s = strchr(*curr, ',');
1475 if (!s) {
1476 printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
1477 return -EINVAL;
1478 }
1479 *s = '\0';
1480 s++;
1481 for (i = 0; hotmod_ops[i].name; i++) {
1d5636cc 1482 if (strcmp(*curr, v[i].name) == 0) {
b361e27b
CM		 1483 *val = v[i].val;
1484 *curr = s;
1485 return 0;
1486 }
1487 }
1488
1489 printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
1490 return -EINVAL;
1491}
1492
1d5636cc
CM		 1493static int check_hotmod_int_op(const char *curr, const char *option,
1494 const char *name, int *val)
1495{
1496 char *n;
1497
1498 if (strcmp(curr, name) == 0) {
1499 if (!option) {
1500 printk(KERN_WARNING PFX
1501 "No option given for '%s'\n",
1502 curr);
1503 return -EINVAL;
1504 }
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",
1509 curr);
1510 return -EINVAL;
1511 }
1512 return 1;
1513 }
1514 return 0;
1515}
1516
b361e27b
CM		 1517static int hotmod_handler(const char *val, struct kernel_param *kp)
1518{
1519 char *str = kstrdup(val, GFP_KERNEL);
1d5636cc 1520 int rv;
b361e27b
CM		 1521 char *next, *curr, *s, *n, *o;
1522 enum hotmod_op op;
1523 enum si_type si_type;
1524 int addr_space;
1525 unsigned long addr;
1526 int regspacing;
1527 int regsize;
1528 int regshift;
1529 int irq;
1530 int ipmb;
1531 int ival;
1d5636cc 1532 int len;
b361e27b
CM		 1533 struct smi_info *info;
1534
1535 if (!str)
1536 return -ENOMEM;
1537
1538 /* Kill any trailing spaces, as we can get a "\n" from echo. */
1d5636cc
CM		 1539 len = strlen(str);
1540 ival = len - 1;
b361e27b
CM		 1541 while ((ival >= 0) && isspace(str[ival])) {
1542 str[ival] = '\0';
1543 ival--;
1544 }
1545
1546 for (curr = str; curr; curr = next) {
1547 regspacing = 1;
1548 regsize = 1;
1549 regshift = 0;
1550 irq = 0;
1551 ipmb = 0x20;
1552
1553 next = strchr(curr, ':');
1554 if (next) {
1555 *next = '\0';
1556 next++;
1557 }
1558
1559 rv = parse_str(hotmod_ops, &ival, "operation", &curr);
1560 if (rv)
1561 break;
1562 op = ival;
1563
1564 rv = parse_str(hotmod_si, &ival, "interface type", &curr);
1565 if (rv)
1566 break;
1567 si_type = ival;
1568
1569 rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
1570 if (rv)
1571 break;
1572
1573 s = strchr(curr, ',');
1574 if (s) {
1575 *s = '\0';
1576 s++;
1577 }
1578 addr = simple_strtoul(curr, &n, 0);
1579 if ((*n != '\0') || (*curr == '\0')) {
1580 printk(KERN_WARNING PFX "Invalid hotmod address"
1581 " '%s'\n", curr);
1582 break;
1583 }
1584
1585 while (s) {
1586 curr = s;
1587 s = strchr(curr, ',');
1588 if (s) {
1589 *s = '\0';
1590 s++;
1591 }
1592 o = strchr(curr, '=');
1593 if (o) {
1594 *o = '\0';
1595 o++;
1596 }
1d5636cc
CM		 1597 rv = check_hotmod_int_op(curr, o, "rsp", &regspacing);
1598 if (rv < 0)
b361e27b 1599 goto out;
1d5636cc
CM		 1600 else if (rv)
1601 continue;
1602 rv = check_hotmod_int_op(curr, o, "rsi", &regsize);
1603 if (rv < 0)
1604 goto out;
1605 else if (rv)
1606 continue;
1607 rv = check_hotmod_int_op(curr, o, "rsh", &regshift);
1608 if (rv < 0)
1609 goto out;
1610 else if (rv)
1611 continue;
1612 rv = check_hotmod_int_op(curr, o, "irq", &irq);
1613 if (rv < 0)
1614 goto out;
1615 else if (rv)
1616 continue;
1617 rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
1618 if (rv < 0)
1619 goto out;
1620 else if (rv)
1621 continue;
1622
1623 rv = -EINVAL;
1624 printk(KERN_WARNING PFX
1625 "Invalid hotmod option '%s'\n",
1626 curr);
1627 goto out;
b361e27b
CM		 1628 }
1629
1630 if (op == HM_ADD) {
1631 info = kzalloc(sizeof(*info), GFP_KERNEL);
1632 if (!info) {
1633 rv = -ENOMEM;
1634 goto out;
1635 }
1636
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;
1643 else
1644 info->io_setup = port_setup;
1645
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;
1654 info->irq = irq;
1655 if (info->irq)
1656 info->irq_setup = std_irq_setup;
1657 info->slave_addr = ipmb;
1658
1659 try_smi_init(info);
1660 } else {
1661 /* remove */
1662 struct smi_info *e, *tmp_e;
1663
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)
1667 continue;
1668 if (e->si_type != si_type)
1669 continue;
1670 if (e->io.addr_data == addr)
1671 cleanup_one_si(e);
1672 }
1673 mutex_unlock(&smi_infos_lock);
1674 }
1675 }
1d5636cc 1676 rv = len;
b361e27b
CM		 1677 out:
1678 kfree(str);
1679 return rv;
1680}
b0defcdb
CM		 1681
1682static __devinit void hardcode_find_bmc(void)
1da177e4 1683{
b0defcdb 1684 int i;
1da177e4
LT		 1685 struct smi_info *info;
1686
b0defcdb
CM		 1687 for (i = 0; i < SI_MAX_PARMS; i++) {
1688 if (!ports[i] && !addrs[i])
1689 continue;
1da177e4 1690
b0defcdb
CM		 1691 info = kzalloc(sizeof(*info), GFP_KERNEL);
1692 if (!info)
1693 return;
1da177e4 1694
b0defcdb 1695 info->addr_source = "hardcoded";
1da177e4 1696
1d5636cc 1697 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
b0defcdb 1698 info->si_type = SI_KCS;
1d5636cc 1699 } else if (strcmp(si_type[i], "smic") == 0) {
b0defcdb 1700 info->si_type = SI_SMIC;
1d5636cc 1701 } else if (strcmp(si_type[i], "bt") == 0) {
b0defcdb
CM		 1702 info->si_type = SI_BT;
1703 } else {
1704 printk(KERN_WARNING
1705 "ipmi_si: Interface type specified "
1706 "for interface %d, was invalid: %s\n",
1707 i, si_type[i]);
1708 kfree(info);
1709 continue;
1710 }
1da177e4 1711
b0defcdb
CM		 1712 if (ports[i]) {
1713 /* An I/O port */
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]) {
1718 /* A memory port */
1719 info->io_setup = mem_setup;
1720 info->io.addr_data = addrs[i];
1721 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1722 } else {
1723 printk(KERN_WARNING
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);
1728 kfree(info);
1729 continue;
1730 }
1da177e4 1731
b0defcdb
CM		 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];
1741 if (info->irq)
1742 info->irq_setup = std_irq_setup;
1da177e4 1743
b0defcdb
CM		 1744 try_smi_init(info);
1745 }
1746}
1da177e4 1747
8466361a 1748#ifdef CONFIG_ACPI
1da177e4
LT		 1749
1750#include <linux/acpi.h>
1751
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
1754 are no more. */
0c8204b3 1755static int acpi_failure;
1da177e4
LT		 1756
1757/* For GPE-type interrupts. */
1758static u32 ipmi_acpi_gpe(void *context)
1759{
1760 struct smi_info *smi_info = context;
1761 unsigned long flags;
1762#ifdef DEBUG_TIMING
1763 struct timeval t;
1764#endif
1765
1766 spin_lock_irqsave(&(smi_info->si_lock), flags);
1767
1768 spin_lock(&smi_info->count_lock);
1769 smi_info->interrupts++;
1770 spin_unlock(&smi_info->count_lock);
1771
1da177e4
LT		 1772#ifdef DEBUG_TIMING
1773 do_gettimeofday(&t);
1774 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1775#endif
1776 smi_event_handler(smi_info, 0);
1da177e4
LT		 1777 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1778
1779 return ACPI_INTERRUPT_HANDLED;
1780}
1781
b0defcdb
CM		 1782static void acpi_gpe_irq_cleanup(struct smi_info *info)
1783{
1784 if (!info->irq)
1785 return;
1786
1787 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1788}
1789
1da177e4
LT		 1790static int acpi_gpe_irq_setup(struct smi_info *info)
1791{
1792 acpi_status status;
1793
b0defcdb 1794 if (!info->irq)
1da177e4
LT		 1795 return 0;
1796
1797 /* FIXME - is level triggered right? */
1798 status = acpi_install_gpe_handler(NULL,
1799 info->irq,
1800 ACPI_GPE_LEVEL_TRIGGERED,
1801 &ipmi_acpi_gpe,
1802 info);
1803 if (status != AE_OK) {
1804 printk(KERN_WARNING
1805 "ipmi_si: %s unable to claim ACPI GPE %d,"
1806 " running polled\n",
1807 DEVICE_NAME, info->irq);
1808 info->irq = 0;
1809 return -EINVAL;
1810 } else {
b0defcdb 1811 info->irq_cleanup = acpi_gpe_irq_cleanup;
1da177e4
LT		 1812 printk(" Using ACPI GPE %d\n", info->irq);
1813 return 0;
1814 }
1815}
1816
1da177e4
LT		 1817/*
1818 * Defined at
1819 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1820 */
1821struct SPMITable {
1822 s8 Signature[4];
1823 u32 Length;
1824 u8 Revision;
1825 u8 Checksum;
1826 s8 OEMID[6];
1827 s8 OEMTableID[8];
1828 s8 OEMRevision[4];
1829 s8 CreatorID[4];
1830 s8 CreatorRevision[4];
1831 u8 InterfaceType;
1832 u8 IPMIlegacy;
1833 s16 SpecificationRevision;
1834
1835 /*
1836 * Bit 0 - SCI interrupt supported
1837 * Bit 1 - I/O APIC/SAPIC
1838 */
1839 u8 InterruptType;
1840
1841 /* If bit 0 of InterruptType is set, then this is the SCI
1842 interrupt in the GPEx_STS register. */
1843 u8 GPE;
1844
1845 s16 Reserved;
1846
1847 /* If bit 1 of InterruptType is set, then this is the I/O
1848 APIC/SAPIC interrupt. */
1849 u32 GlobalSystemInterrupt;
1850
1851 /* The actual register address. */
1852 struct acpi_generic_address addr;
1853
1854 u8 UID[4];
1855
1856 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1857};
1858
b0defcdb 1859static __devinit int try_init_acpi(struct SPMITable *spmi)
1da177e4
LT		 1860{
1861 struct smi_info *info;
1da177e4
LT		 1862 u8 addr_space;
1863
1da177e4
LT		 1864 if (spmi->IPMIlegacy != 1) {
1865 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1866 return -ENODEV;
1867 }
1868
15a58ed1 1869 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
1da177e4
LT		 1870 addr_space = IPMI_MEM_ADDR_SPACE;
1871 else
1872 addr_space = IPMI_IO_ADDR_SPACE;
b0defcdb
CM		 1873
1874 info = kzalloc(sizeof(*info), GFP_KERNEL);
1875 if (!info) {
1876 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1877 return -ENOMEM;
1878 }
1879
1880 info->addr_source = "ACPI";
1da177e4 1881
1da177e4
LT		 1882 /* Figure out the interface type. */
1883 switch (spmi->InterfaceType)
1884 {
1885 case 1: /* KCS */
b0defcdb 1886 info->si_type = SI_KCS;
1da177e4 1887 break;
1da177e4 1888 case 2: /* SMIC */
b0defcdb 1889 info->si_type = SI_SMIC;
1da177e4 1890 break;
1da177e4 1891 case 3: /* BT */
b0defcdb 1892 info->si_type = SI_BT;
1da177e4 1893 break;
1da177e4
LT		 1894 default:
1895 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1896 spmi->InterfaceType);
b0defcdb 1897 kfree(info);
1da177e4
LT		 1898 return -EIO;
1899 }
1900
1da177e4
LT		 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;
1da177e4
LT		 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;
1da177e4
LT		 1909 } else {
1910 /* Use the default interrupt setting. */
1911 info->irq = 0;
1912 info->irq_setup = NULL;
1913 }
1914
15a58ed1 1915 if (spmi->addr.bit_width) {
35bc37a0 1916 /* A (hopefully) properly formed register bit width. */
15a58ed1 1917 info->io.regspacing = spmi->addr.bit_width / 8;
35bc37a0 1918 } else {
35bc37a0
CM		 1919 info->io.regspacing = DEFAULT_REGSPACING;
1920 }
b0defcdb 1921 info->io.regsize = info->io.regspacing;
15a58ed1 1922 info->io.regshift = spmi->addr.bit_offset;
1da177e4 1923
15a58ed1 1924 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1da177e4 1925 info->io_setup = mem_setup;
8fe1425a 1926 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
15a58ed1 1927 } else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1da177e4 1928 info->io_setup = port_setup;
8fe1425a 1929 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1da177e4
LT		 1930 } else {
1931 kfree(info);
1932 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1933 return -EIO;
1934 }
b0defcdb 1935 info->io.addr_data = spmi->addr.address;
1da177e4 1936
b0defcdb 1937 try_smi_init(info);
1da177e4 1938
1da177e4
LT		 1939 return 0;
1940}
b0defcdb
CM		 1941
1942static __devinit void acpi_find_bmc(void)
1943{
1944 acpi_status status;
1945 struct SPMITable *spmi;
1946 int i;
1947
1948 if (acpi_disabled)
1949 return;
1950
1951 if (acpi_failure)
1952 return;
1953
1954 for (i = 0; ; i++) {
15a58ed1
AS		 1955 status = acpi_get_table(ACPI_SIG_SPMI, i+1,
1956 (struct acpi_table_header **)&spmi);
b0defcdb
CM		 1957 if (status != AE_OK)
1958 return;
1959
1960 try_init_acpi(spmi);
1961 }
1962}
1da177e4
LT		 1963#endif
1964
a9fad4cc 1965#ifdef CONFIG_DMI
b0defcdb 1966struct dmi_ipmi_data
1da177e4
LT		 1967{
1968 u8 type;
1969 u8 addr_space;
1970 unsigned long base_addr;
1971 u8 irq;
1972 u8 offset;
1973 u8 slave_addr;
b0defcdb 1974};
1da177e4 1975
1855256c 1976static int __devinit decode_dmi(const struct dmi_header *dm,
b0defcdb 1977 struct dmi_ipmi_data *dmi)
1da177e4 1978{
1855256c 1979 const u8 *data = (const u8 *)dm;
1da177e4
LT		 1980 unsigned long base_addr;
1981 u8 reg_spacing;
b224cd3a 1982 u8 len = dm->length;
1da177e4 1983
b0defcdb 1984 dmi->type = data[4];
1da177e4
LT		 1985
1986 memcpy(&base_addr, data+8, sizeof(unsigned long));
1987 if (len >= 0x11) {
1988 if (base_addr & 1) {
1989 /* I/O */
1990 base_addr &= 0xFFFE;
b0defcdb 1991 dmi->addr_space = IPMI_IO_ADDR_SPACE;
1da177e4
LT		 1992 }
1993 else {
1994 /* Memory */
b0defcdb 1995 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
1da177e4
LT		 1996 }
1997 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1998 is odd. */
b0defcdb 1999 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1da177e4 2000
b0defcdb 2001 dmi->irq = data[0x11];
1da177e4
LT		 2002
2003 /* The top two bits of byte 0x10 hold the register spacing. */
b224cd3a 2004 reg_spacing = (data[0x10] & 0xC0) >> 6;
1da177e4
LT		 2005 switch(reg_spacing){
2006 case 0x00: /* Byte boundaries */
b0defcdb 2007 dmi->offset = 1;
1da177e4
LT		 2008 break;
2009 case 0x01: /* 32-bit boundaries */
b0defcdb 2010 dmi->offset = 4;
1da177e4
LT		 2011 break;
2012 case 0x02: /* 16-byte boundaries */
b0defcdb 2013 dmi->offset = 16;
1da177e4
LT		 2014 break;
2015 default:
2016 /* Some other interface, just ignore it. */
2017 return -EIO;
2018 }
2019 } else {
2020 /* Old DMI spec. */
92068801
CM		 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. */
b0defcdb
CM		 2027 dmi->base_addr = base_addr & 0xfffe;
2028 dmi->addr_space = IPMI_IO_ADDR_SPACE;
2029 dmi->offset = 1;
1da177e4
LT		 2030 }
2031
b0defcdb 2032 dmi->slave_addr = data[6];
1da177e4 2033
b0defcdb 2034 return 0;
1da177e4
LT		 2035}
2036
b0defcdb 2037static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
1da177e4 2038{
b0defcdb 2039 struct smi_info *info;
1da177e4 2040
b0defcdb
CM		 2041 info = kzalloc(sizeof(*info), GFP_KERNEL);
2042 if (!info) {
2043 printk(KERN_ERR
2044 "ipmi_si: Could not allocate SI data\n");
2045 return;
1da177e4 2046 }
1da177e4 2047
b0defcdb 2048 info->addr_source = "SMBIOS";
1da177e4 2049
e8b33617 2050 switch (ipmi_data->type) {
b0defcdb
CM		 2051 case 0x01: /* KCS */
2052 info->si_type = SI_KCS;
2053 break;
2054 case 0x02: /* SMIC */
2055 info->si_type = SI_SMIC;
2056 break;
2057 case 0x03: /* BT */
2058 info->si_type = SI_BT;
2059 break;
2060 default:
80cd6920 2061 kfree(info);
b0defcdb 2062 return;
1da177e4 2063 }
1da177e4 2064
b0defcdb
CM		 2065 switch (ipmi_data->addr_space) {
2066 case IPMI_MEM_ADDR_SPACE:
1da177e4 2067 info->io_setup = mem_setup;
b0defcdb
CM		 2068 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2069 break;
2070
2071 case IPMI_IO_ADDR_SPACE:
1da177e4 2072 info->io_setup = port_setup;
b0defcdb
CM		 2073 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2074 break;
2075
2076 default:
1da177e4 2077 kfree(info);
b0defcdb
CM		 2078 printk(KERN_WARNING
2079 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
2080 ipmi_data->addr_space);
2081 return;
1da177e4 2082 }
b0defcdb 2083 info->io.addr_data = ipmi_data->base_addr;
1da177e4 2084
b0defcdb
CM		 2085 info->io.regspacing = ipmi_data->offset;
2086 if (!info->io.regspacing)
1da177e4
LT		 2087 info->io.regspacing = DEFAULT_REGSPACING;
2088 info->io.regsize = DEFAULT_REGSPACING;
b0defcdb 2089 info->io.regshift = 0;
1da177e4
LT		 2090
2091 info->slave_addr = ipmi_data->slave_addr;
2092
b0defcdb
CM		 2093 info->irq = ipmi_data->irq;
2094 if (info->irq)
2095 info->irq_setup = std_irq_setup;
1da177e4 2096
b0defcdb
CM		 2097 try_smi_init(info);
2098}
1da177e4 2099
b0defcdb
CM		 2100static void __devinit dmi_find_bmc(void)
2101{
1855256c 2102 const struct dmi_device *dev = NULL;
b0defcdb
CM		 2103 struct dmi_ipmi_data data;
2104 int rv;
2105
2106 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
397f4ebf 2107 memset(&data, 0, sizeof(data));
1855256c
JG		 2108 rv = decode_dmi((const struct dmi_header *) dev->device_data,
2109 &data);
b0defcdb
CM		 2110 if (!rv)
2111 try_init_dmi(&data);
2112 }
1da177e4 2113}
a9fad4cc 2114#endif /* CONFIG_DMI */
1da177e4
LT		 2115
2116#ifdef CONFIG_PCI
2117
b0defcdb
CM		 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
2124
1da177e4
LT		 2125#define PCI_HP_VENDOR_ID 0x103C
2126#define PCI_MMC_DEVICE_ID 0x121A
2127#define PCI_MMC_ADDR_CW 0x10
2128
b0defcdb
CM		 2129static void ipmi_pci_cleanup(struct smi_info *info)
2130{
2131 struct pci_dev *pdev = info->addr_source_data;
2132
2133 pci_disable_device(pdev);
2134}
1da177e4 2135
b0defcdb
CM		 2136static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
2137 const struct pci_device_id *ent)
1da177e4 2138{
b0defcdb
CM		 2139 int rv;
2140 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
2141 struct smi_info *info;
2142 int first_reg_offset = 0;
1da177e4 2143
b0defcdb
CM		 2144 info = kzalloc(sizeof(*info), GFP_KERNEL);
2145 if (!info)
1cd441f9 2146 return -ENOMEM;
1da177e4 2147
b0defcdb 2148 info->addr_source = "PCI";
1da177e4 2149
b0defcdb
CM		 2150 switch (class_type) {
2151 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
2152 info->si_type = SI_SMIC;
2153 break;
1da177e4 2154
b0defcdb
CM		 2155 case PCI_ERMC_CLASSCODE_TYPE_KCS:
2156 info->si_type = SI_KCS;
2157 break;
2158
2159 case PCI_ERMC_CLASSCODE_TYPE_BT:
2160 info->si_type = SI_BT;
2161 break;
2162
2163 default:
2164 kfree(info);
2165 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
2166 pci_name(pdev), class_type);
1cd441f9 2167 return -ENOMEM;
1da177e4
LT		 2168 }
2169
b0defcdb
CM		 2170 rv = pci_enable_device(pdev);
2171 if (rv) {
2172 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
2173 pci_name(pdev));
2174 kfree(info);
2175 return rv;
1da177e4
LT		 2176 }
2177
b0defcdb
CM		 2178 info->addr_source_cleanup = ipmi_pci_cleanup;
2179 info->addr_source_data = pdev;
1da177e4 2180
b0defcdb
CM		 2181 if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
2182 first_reg_offset = 1;
1da177e4 2183
b0defcdb
CM		 2184 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2185 info->io_setup = port_setup;
2186 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2187 } else {
2188 info->io_setup = mem_setup;
2189 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1da177e4 2190 }
b0defcdb 2191 info->io.addr_data = pci_resource_start(pdev, 0);
1da177e4 2192
b0defcdb 2193 info->io.regspacing = DEFAULT_REGSPACING;
1da177e4 2194 info->io.regsize = DEFAULT_REGSPACING;
b0defcdb 2195 info->io.regshift = 0;
1da177e4 2196
b0defcdb
CM		 2197 info->irq = pdev->irq;
2198 if (info->irq)
2199 info->irq_setup = std_irq_setup;
1da177e4 2200
50c812b2 2201 info->dev = &pdev->dev;
fca3b747 2202 pci_set_drvdata(pdev, info);
50c812b2 2203
b0defcdb
CM		 2204 return try_smi_init(info);
2205}
1da177e4 2206
b0defcdb
CM		 2207static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
2208{
fca3b747
CM		 2209 struct smi_info *info = pci_get_drvdata(pdev);
2210 cleanup_one_si(info);
b0defcdb 2211}
1da177e4 2212
b0defcdb
CM		 2213#ifdef CONFIG_PM
2214static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
2215{
1da177e4
LT		 2216 return 0;
2217}
1da177e4 2218
b0defcdb 2219static int ipmi_pci_resume(struct pci_dev *pdev)
1da177e4 2220{
b0defcdb
CM		 2221 return 0;
2222}
1da177e4 2223#endif
1da177e4 2224
b0defcdb
CM		 2225static struct pci_device_id ipmi_pci_devices[] = {
2226 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
248bdd5e
KC		 2227 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
2228 { 0, }
b0defcdb
CM		 2229};
2230MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
2231
2232static 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),
2237#ifdef CONFIG_PM
2238 .suspend = ipmi_pci_suspend,
2239 .resume = ipmi_pci_resume,
2240#endif
2241};
2242#endif /* CONFIG_PCI */
1da177e4
LT		 2243
2244
dba9b4f6
CM		 2245#ifdef CONFIG_PPC_OF
2246static int __devinit ipmi_of_probe(struct of_device *dev,
2247 const struct of_device_id *match)
2248{
2249 struct smi_info *info;
2250 struct resource resource;
2251 const int *regsize, *regspacing, *regshift;
2252 struct device_node *np = dev->node;
2253 int ret;
2254 int proplen;
2255
2256 dev_info(&dev->dev, PFX "probing via device tree\n");
2257
2258 ret = of_address_to_resource(np, 0, &resource);
2259 if (ret) {
2260 dev_warn(&dev->dev, PFX "invalid address from OF\n");
2261 return ret;
2262 }
2263
9c25099d 2264 regsize = of_get_property(np, "reg-size", &proplen);
dba9b4f6
CM		 2265 if (regsize && proplen != 4) {
2266 dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
2267 return -EINVAL;
2268 }
2269
9c25099d 2270 regspacing = of_get_property(np, "reg-spacing", &proplen);
dba9b4f6
CM		 2271 if (regspacing && proplen != 4) {
2272 dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
2273 return -EINVAL;
2274 }
2275
9c25099d 2276 regshift = of_get_property(np, "reg-shift", &proplen);
dba9b4f6
CM		 2277 if (regshift && proplen != 4) {
2278 dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
2279 return -EINVAL;
2280 }
2281
2282 info = kzalloc(sizeof(*info), GFP_KERNEL);
2283
2284 if (!info) {
2285 dev_err(&dev->dev,
2286 PFX "could not allocate memory for OF probe\n");
2287 return -ENOMEM;
2288 }
2289
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;
2294
2295 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2296 info->io.addr_data = resource.start;
2297
2298 info->io.regsize = regsize ? *regsize : DEFAULT_REGSIZE;
2299 info->io.regspacing = regspacing ? *regspacing : DEFAULT_REGSPACING;
2300 info->io.regshift = regshift ? *regshift : 0;
2301
2302 info->irq = irq_of_parse_and_map(dev->node, 0);
2303 info->dev = &dev->dev;
2304
32d21985 2305 dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %x\n",
dba9b4f6
CM		 2306 info->io.addr_data, info->io.regsize, info->io.regspacing,
2307 info->irq);
2308
2309 dev->dev.driver_data = (void*) info;
2310
2311 return try_smi_init(info);
2312}
2313
2314static int __devexit ipmi_of_remove(struct of_device *dev)
2315{
2316 cleanup_one_si(dev->dev.driver_data);
2317 return 0;
2318}
2319
2320static struct of_device_id ipmi_match[] =
2321{
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 },
2325 {},
2326};
2327
2328static struct of_platform_driver ipmi_of_platform_driver =
2329{
2330 .name = "ipmi",
2331 .match_table = ipmi_match,
2332 .probe = ipmi_of_probe,
2333 .remove = __devexit_p(ipmi_of_remove),
2334};
2335#endif /* CONFIG_PPC_OF */
2336
2337
1da177e4
LT		 2338static int try_get_dev_id(struct smi_info *smi_info)
2339{
50c812b2
CM		 2340 unsigned char msg[2];
2341 unsigned char *resp;
2342 unsigned long resp_len;
2343 enum si_sm_result smi_result;
2344 int rv = 0;
1da177e4
LT		 2345
2346 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
b0defcdb 2347 if (!resp)
1da177e4
LT		 2348 return -ENOMEM;
2349
2350 /* Do a Get Device ID command, since it comes back with some
2351 useful info. */
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);
2355
2356 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
2357 for (;;)
2358 {
c3e7e791
CM		 2359 if (smi_result == SI_SM_CALL_WITH_DELAY ||
2360 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
da4cd8df 2361 schedule_timeout_uninterruptible(1);
1da177e4
LT		 2362 smi_result = smi_info->handlers->event(
2363 smi_info->si_sm, 100);
2364 }
2365 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
2366 {
2367 smi_result = smi_info->handlers->event(
2368 smi_info->si_sm, 0);
2369 }
2370 else
2371 break;
2372 }
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. */
2376 rv = -ENODEV;
2377 goto out;
2378 }
2379
2380 /* Otherwise, we got some data. */
2381 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2382 resp, IPMI_MAX_MSG_LENGTH);
1da177e4 2383
d8c98618
CM		 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);
1da177e4
LT		 2386
2387 out:
2388 kfree(resp);
2389 return rv;
2390}
2391
2392static int type_file_read_proc(char *page, char **start, off_t off,
2393 int count, int *eof, void *data)
2394{
1da177e4
LT		 2395 struct smi_info *smi = data;
2396
b361e27b 2397 return sprintf(page, "%s\n", si_to_str[smi->si_type]);
1da177e4
LT		 2398}
2399
2400static int stat_file_read_proc(char *page, char **start, off_t off,
2401 int count, int *eof, void *data)
2402{
2403 char *out = (char *) page;
2404 struct smi_info *smi = data;
2405
2406 out += sprintf(out, "interrupts_enabled: %d\n",
b0defcdb 2407 smi->irq && !smi->interrupt_disabled);
1da177e4
LT		 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",
2415 smi->idles);
2416 out += sprintf(out, "interrupts: %ld\n",
2417 smi->interrupts);
2418 out += sprintf(out, "attentions: %ld\n",
2419 smi->attentions);
2420 out += sprintf(out, "flag_fetches: %ld\n",
2421 smi->flag_fetches);
2422 out += sprintf(out, "hosed_count: %ld\n",
2423 smi->hosed_count);
2424 out += sprintf(out, "complete_transactions: %ld\n",
2425 smi->complete_transactions);
2426 out += sprintf(out, "events: %ld\n",
2427 smi->events);
2428 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
2429 smi->watchdog_pretimeouts);
2430 out += sprintf(out, "incoming_messages: %ld\n",
2431 smi->incoming_messages);
2432
b361e27b
CM		 2433 return out - page;
2434}
2435
2436static int param_read_proc(char *page, char **start, off_t off,
2437 int count, int *eof, void *data)
2438{
2439 struct smi_info *smi = data;
2440
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],
2445 smi->io.addr_data,
2446 smi->io.regspacing,
2447 smi->io.regsize,
2448 smi->io.regshift,
2449 smi->irq,
2450 smi->slave_addr);
1da177e4
LT		 2451}
2452
3ae0e0f9
CM		 2453/*
2454 * oem_data_avail_to_receive_msg_avail
2455 * @info - smi_info structure with msg_flags set
2456 *
2457 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2458 * Returns 1 indicating need to re-run handle_flags().
2459 */
2460static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2461{
e8b33617
CM		 2462 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2463 RECEIVE_MSG_AVAIL);
3ae0e0f9
CM		 2464 return 1;
2465}
2466
2467/*
2468 * setup_dell_poweredge_oem_data_handler
2469 * @info - smi_info.device_id must be populated
2470 *
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.
2476 *
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
2480 * firmware version.
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
2487 *
d5a2b89a
CM		 2488 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2489 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2490 *
3ae0e0f9
CM		 2491 */
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
50c812b2 2495#define DELL_IANA_MFR_ID 0x0002a2
3ae0e0f9
CM		 2496static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2497{
2498 struct ipmi_device_id *id = &smi_info->device_id;
50c812b2 2499 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
d5a2b89a
CM		 2500 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2501 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
50c812b2 2502 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
d5a2b89a
CM		 2503 smi_info->oem_data_avail_handler =
2504 oem_data_avail_to_receive_msg_avail;
2505 }
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;
2511 }
3ae0e0f9
CM		 2512 }
2513}
2514
ea94027b
CM		 2515#define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2516static void return_hosed_msg_badsize(struct smi_info *smi_info)
2517{
2518 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2519
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;
2524 msg->rsp_size = 3;
2525 smi_info->curr_msg = NULL;
2526 deliver_recv_msg(smi_info, msg);
2527}
2528
2529/*
2530 * dell_poweredge_bt_xaction_handler
2531 * @info - smi_info.device_id must be populated
2532 *
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.
2538 */
2539
2540#define STORAGE_NETFN 0x0A
2541#define STORAGE_CMD_GET_SDR 0x23
2542static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2543 unsigned long unused,
2544 void *in)
2545{
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;
2549 if (size >= 8 &&
2550 (data[0]>>2) == STORAGE_NETFN &&
2551 data[1] == STORAGE_CMD_GET_SDR &&
2552 data[7] == 0x3A) {
2553 return_hosed_msg_badsize(smi_info);
2554 return NOTIFY_STOP;
2555 }
2556 return NOTIFY_DONE;
2557}
2558
2559static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2560 .notifier_call = dell_poweredge_bt_xaction_handler,
2561};
2562
2563/*
2564 * setup_dell_poweredge_bt_xaction_handler
2565 * @info - smi_info.device_id must be filled in already
2566 *
2567 * Fills in smi_info.device_id.start_transaction_pre_hook
2568 * when we know what function to use there.
2569 */
2570static void
2571setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2572{
2573 struct ipmi_device_id *id = &smi_info->device_id;
50c812b2 2574 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
ea94027b
CM		 2575 smi_info->si_type == SI_BT)
2576 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2577}
2578
3ae0e0f9
CM		 2579/*
2580 * setup_oem_data_handler
2581 * @info - smi_info.device_id must be filled in already
2582 *
2583 * Fills in smi_info.device_id.oem_data_available_handler
2584 * when we know what function to use there.
2585 */
2586
2587static void setup_oem_data_handler(struct smi_info *smi_info)
2588{
2589 setup_dell_poweredge_oem_data_handler(smi_info);
2590}
2591
ea94027b
CM		 2592static void setup_xaction_handlers(struct smi_info *smi_info)
2593{
2594 setup_dell_poweredge_bt_xaction_handler(smi_info);
2595}
2596
a9a2c44f
CM		 2597static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2598{
453823ba
CM		 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);
2605 }
a9a2c44f
CM		 2606}
2607
7420884c 2608static __devinitdata struct ipmi_default_vals
b0defcdb
CM		 2609{
2610 int type;
2611 int port;
7420884c 2612} ipmi_defaults[] =
b0defcdb
CM		 2613{
2614 { .type = SI_KCS, .port = 0xca2 },
2615 { .type = SI_SMIC, .port = 0xca9 },
2616 { .type = SI_BT, .port = 0xe4 },
2617 { .port = 0 }
2618};
2619
2620static __devinit void default_find_bmc(void)
2621{
2622 struct smi_info *info;
2623 int i;
2624
2625 for (i = 0; ; i++) {
2626 if (!ipmi_defaults[i].port)
2627 break;
2628
2629 info = kzalloc(sizeof(*info), GFP_KERNEL);
2630 if (!info)
2631 return;
2632
4ff31d77
CK		 2633#ifdef CONFIG_PPC_MERGE
2634 if (check_legacy_ioport(ipmi_defaults[i].port))
2635 continue;
2636#endif
2637
b0defcdb
CM		 2638 info->addr_source = NULL;
2639
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;
2644
2645 info->io.addr = NULL;
2646 info->io.regspacing = DEFAULT_REGSPACING;
2647 info->io.regsize = DEFAULT_REGSPACING;
2648 info->io.regshift = 0;
2649
2650 if (try_smi_init(info) == 0) {
2651 /* Found one... */
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);
2657 return;
2658 }
2659 }
2660}
2661
2662static int is_new_interface(struct smi_info *info)
1da177e4 2663{
b0defcdb 2664 struct smi_info *e;
1da177e4 2665
b0defcdb
CM		 2666 list_for_each_entry(e, &smi_infos, link) {
2667 if (e->io.addr_type != info->io.addr_type)
2668 continue;
2669 if (e->io.addr_data == info->io.addr_data)
2670 return 0;
2671 }
1da177e4 2672
b0defcdb
CM		 2673 return 1;
2674}
1da177e4 2675
b0defcdb
CM		 2676static int try_smi_init(struct smi_info *new_smi)
2677{
2678 int rv;
2679
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,"
2683 " irq %d\n",
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);
2689 }
2690
d6dfd131 2691 mutex_lock(&smi_infos_lock);
b0defcdb
CM		 2692 if (!is_new_interface(new_smi)) {
2693 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2694 rv = -EBUSY;
2695 goto out_err;
2696 }
1da177e4
LT		 2697
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;
2702
b0defcdb
CM		 2703 switch (new_smi->si_type) {
2704 case SI_KCS:
1da177e4 2705 new_smi->handlers = &kcs_smi_handlers;
b0defcdb
CM		 2706 break;
2707
2708 case SI_SMIC:
1da177e4 2709 new_smi->handlers = &smic_smi_handlers;
b0defcdb
CM		 2710 break;
2711
2712 case SI_BT:
1da177e4 2713 new_smi->handlers = &bt_smi_handlers;
b0defcdb
CM		 2714 break;
2715
2716 default:
1da177e4
LT		 2717 /* No support for anything else yet. */
2718 rv = -EIO;
2719 goto out_err;
2720 }
2721
2722 /* Allocate the state machine's data and initialize it. */
2723 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
b0defcdb 2724 if (!new_smi->si_sm) {
1da177e4
LT		 2725 printk(" Could not allocate state machine memory\n");
2726 rv = -ENOMEM;
2727 goto out_err;
2728 }
2729 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2730 &new_smi->io);
2731
2732 /* Now that we know the I/O size, we can set up the I/O. */
2733 rv = new_smi->io_setup(new_smi);
2734 if (rv) {
2735 printk(" Could not set up I/O space\n");
2736 goto out_err;
2737 }
2738
2739 spin_lock_init(&(new_smi->si_lock));
2740 spin_lock_init(&(new_smi->msg_lock));
2741 spin_lock_init(&(new_smi->count_lock));
2742
2743 /* Do low-level detection first. */
2744 if (new_smi->handlers->detect(new_smi->si_sm)) {
b0defcdb
CM		 2745 if (new_smi->addr_source)
2746 printk(KERN_INFO "ipmi_si: Interface detection"
2747 " failed\n");
1da177e4
LT		 2748 rv = -ENODEV;
2749 goto out_err;
2750 }
2751
2752 /* Attempt a get device id command. If it fails, we probably
b0defcdb 2753 don't have a BMC here. */
1da177e4 2754 rv = try_get_dev_id(new_smi);
b0defcdb
CM		 2755 if (rv) {
2756 if (new_smi->addr_source)
2757 printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2758 " at this location\n");
1da177e4 2759 goto out_err;
b0defcdb 2760 }
1da177e4 2761
3ae0e0f9 2762 setup_oem_data_handler(new_smi);
ea94027b 2763 setup_xaction_handlers(new_smi);
3ae0e0f9 2764
1da177e4
LT		 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;
2770
2771 new_smi->interrupt_disabled = 0;
a9a2c44f 2772 atomic_set(&new_smi->stop_operation, 0);
b0defcdb
CM		 2773 new_smi->intf_num = smi_num;
2774 smi_num++;
1da177e4
LT		 2775
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. */
2780 if (new_smi->irq)
2781 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2782
50c812b2
CM		 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",
2787 new_smi->intf_num);
2788 if (rv) {
2789 printk(KERN_ERR
2790 "ipmi_si_intf:"
2791 " Unable to allocate platform device\n");
453823ba 2792 goto out_err;
50c812b2
CM		 2793 }
2794 new_smi->dev = &new_smi->pdev->dev;
2795 new_smi->dev->driver = &ipmi_driver;
2796
b48f5457 2797 rv = platform_device_add(new_smi->pdev);
50c812b2
CM		 2798 if (rv) {
2799 printk(KERN_ERR
2800 "ipmi_si_intf:"
2801 " Unable to register system interface device:"
2802 " %d\n",
2803 rv);
453823ba 2804 goto out_err;
50c812b2
CM		 2805 }
2806 new_smi->dev_registered = 1;
2807 }
2808
1da177e4
LT		 2809 rv = ipmi_register_smi(&handlers,
2810 new_smi,
50c812b2
CM		 2811 &new_smi->device_id,
2812 new_smi->dev,
759643b8 2813 "bmc",
453823ba 2814 new_smi->slave_addr);
1da177e4
LT		 2815 if (rv) {
2816 printk(KERN_ERR
2817 "ipmi_si: Unable to register device: error %d\n",
2818 rv);
2819 goto out_err_stop_timer;
2820 }
2821
2822 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2823 type_file_read_proc, NULL,
2824 new_smi, THIS_MODULE);
2825 if (rv) {
2826 printk(KERN_ERR
2827 "ipmi_si: Unable to create proc entry: %d\n",
2828 rv);
2829 goto out_err_stop_timer;
2830 }
2831
2832 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2833 stat_file_read_proc, NULL,
2834 new_smi, THIS_MODULE);
2835 if (rv) {
2836 printk(KERN_ERR
2837 "ipmi_si: Unable to create proc entry: %d\n",
2838 rv);
2839 goto out_err_stop_timer;
2840 }
2841
b361e27b
CM		 2842 rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
2843 param_read_proc, NULL,
2844 new_smi, THIS_MODULE);
2845 if (rv) {
2846 printk(KERN_ERR
2847 "ipmi_si: Unable to create proc entry: %d\n",
2848 rv);
2849 goto out_err_stop_timer;
2850 }
2851
b0defcdb
CM		 2852 list_add_tail(&new_smi->link, &smi_infos);
2853
d6dfd131 2854 mutex_unlock(&smi_infos_lock);
1da177e4 2855
8f14137e 2856 printk(KERN_INFO "IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
1da177e4
LT		 2857
2858 return 0;
2859
2860 out_err_stop_timer:
a9a2c44f
CM		 2861 atomic_inc(&new_smi->stop_operation);
2862 wait_for_timer_and_thread(new_smi);
1da177e4
LT		 2863
2864 out_err:
2865 if (new_smi->intf)
2866 ipmi_unregister_smi(new_smi->intf);
2867
b0defcdb
CM		 2868 if (new_smi->irq_cleanup)
2869 new_smi->irq_cleanup(new_smi);
1da177e4
LT		 2870
2871 /* Wait until we know that we are out of any interrupt
2872 handlers might have been running before we freed the
2873 interrupt. */
fbd568a3 2874 synchronize_sched();
1da177e4
LT		 2875
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);
2880 }
b0defcdb
CM		 2881 if (new_smi->addr_source_cleanup)
2882 new_smi->addr_source_cleanup(new_smi);
7767e126
PG		 2883 if (new_smi->io_cleanup)
2884 new_smi->io_cleanup(new_smi);
1da177e4 2885
50c812b2
CM		 2886 if (new_smi->dev_registered)
2887 platform_device_unregister(new_smi->pdev);
2888
2889 kfree(new_smi);
2890
d6dfd131 2891 mutex_unlock(&smi_infos_lock);
b0defcdb 2892
1da177e4
LT		 2893 return rv;
2894}
2895
b0defcdb 2896static __devinit int init_ipmi_si(void)
1da177e4 2897{
1da177e4
LT		 2898 int i;
2899 char *str;
50c812b2 2900 int rv;
1da177e4
LT		 2901
2902 if (initialized)
2903 return 0;
2904 initialized = 1;
2905
50c812b2
CM		 2906 /* Register the device drivers. */
2907 rv = driver_register(&ipmi_driver);
2908 if (rv) {
2909 printk(KERN_ERR
2910 "init_ipmi_si: Unable to register driver: %d\n",
2911 rv);
2912 return rv;
2913 }
2914
2915
1da177e4
LT		 2916 /* Parse out the si_type string into its components. */
2917 str = si_type_str;
2918 if (*str != '\0') {
e8b33617 2919 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
1da177e4
LT		 2920 si_type[i] = str;
2921 str = strchr(str, ',');
2922 if (str) {
2923 *str = '\0';
2924 str++;
2925 } else {
2926 break;
2927 }
2928 }
2929 }
2930
1fdd75bd 2931 printk(KERN_INFO "IPMI System Interface driver.\n");
1da177e4 2932
b0defcdb
CM		 2933 hardcode_find_bmc();
2934
a9fad4cc 2935#ifdef CONFIG_DMI
b224cd3a 2936 dmi_find_bmc();
1da177e4
LT		 2937#endif
2938
b0defcdb 2939#ifdef CONFIG_ACPI
1d5636cc 2940 acpi_find_bmc();
b0defcdb 2941#endif
1da177e4 2942
b0defcdb 2943#ifdef CONFIG_PCI
168b35a7
CM		 2944 rv = pci_register_driver(&ipmi_pci_driver);
2945 if (rv){
2946 printk(KERN_ERR
2947 "init_ipmi_si: Unable to register PCI driver: %d\n",
2948 rv);
2949 }
b0defcdb
CM		 2950#endif
2951
dba9b4f6
CM		 2952#ifdef CONFIG_PPC_OF
2953 of_register_platform_driver(&ipmi_of_platform_driver);
2954#endif
2955
b0defcdb 2956 if (si_trydefaults) {
d6dfd131 2957 mutex_lock(&smi_infos_lock);
b0defcdb
CM		 2958 if (list_empty(&smi_infos)) {
2959 /* No BMC was found, try defaults. */
d6dfd131 2960 mutex_unlock(&smi_infos_lock);
b0defcdb
CM		 2961 default_find_bmc();
2962 } else {
d6dfd131 2963 mutex_unlock(&smi_infos_lock);
b0defcdb 2964 }
1da177e4
LT		 2965 }
2966
d6dfd131 2967 mutex_lock(&smi_infos_lock);
b361e27b 2968 if (unload_when_empty && list_empty(&smi_infos)) {
d6dfd131 2969 mutex_unlock(&smi_infos_lock);
b0defcdb
CM		 2970#ifdef CONFIG_PCI
2971 pci_unregister_driver(&ipmi_pci_driver);
2972#endif
10fb62e5
CK		 2973
2974#ifdef CONFIG_PPC_OF
2975 of_unregister_platform_driver(&ipmi_of_platform_driver);
2976#endif
55ebcc38 2977 driver_unregister(&ipmi_driver);
1da177e4
LT		 2978 printk("ipmi_si: Unable to find any System Interface(s)\n");
2979 return -ENODEV;
b0defcdb 2980 } else {
d6dfd131 2981 mutex_unlock(&smi_infos_lock);
b0defcdb 2982 return 0;
1da177e4 2983 }
1da177e4
LT		 2984}
2985module_init(init_ipmi_si);
2986
b361e27b 2987static void cleanup_one_si(struct smi_info *to_clean)
1da177e4
LT		 2988{
2989 int rv;
2990 unsigned long flags;
2991
b0defcdb 2992 if (!to_clean)
1da177e4
LT		 2993 return;
2994
b0defcdb
CM		 2995 list_del(&to_clean->link);
2996
ee6cd5f8 2997 /* Tell the driver that we are shutting down. */
a9a2c44f 2998 atomic_inc(&to_clean->stop_operation);
b0defcdb 2999
ee6cd5f8
CM		 3000 /* Make sure the timer and thread are stopped and will not run
3001 again. */
a9a2c44f 3002 wait_for_timer_and_thread(to_clean);
1da177e4 3003
ee6cd5f8
CM		 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);
3010 poll(to_clean);
3011 schedule_timeout_uninterruptible(1);
3012 spin_lock_irqsave(&to_clean->si_lock, flags);
3013 }
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)) {
3017 poll(to_clean);
3018 schedule_timeout_uninterruptible(1);
3019 }
3020
3021 /* Clean up interrupts and make sure that everything is done. */
3022 if (to_clean->irq_cleanup)
3023 to_clean->irq_cleanup(to_clean);
e8b33617 3024 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
1da177e4 3025 poll(to_clean);
da4cd8df 3026 schedule_timeout_uninterruptible(1);
1da177e4
LT		 3027 }
3028
3029 rv = ipmi_unregister_smi(to_clean->intf);
3030 if (rv) {
3031 printk(KERN_ERR
3032 "ipmi_si: Unable to unregister device: errno=%d\n",
3033 rv);
3034 }
3035
3036 to_clean->handlers->cleanup(to_clean->si_sm);
3037
3038 kfree(to_clean->si_sm);
3039
b0defcdb
CM		 3040 if (to_clean->addr_source_cleanup)
3041 to_clean->addr_source_cleanup(to_clean);
7767e126
PG		 3042 if (to_clean->io_cleanup)
3043 to_clean->io_cleanup(to_clean);
50c812b2
CM		 3044
3045 if (to_clean->dev_registered)
3046 platform_device_unregister(to_clean->pdev);
3047
3048 kfree(to_clean);
1da177e4
LT		 3049}
3050
3051static __exit void cleanup_ipmi_si(void)
3052{
b0defcdb 3053 struct smi_info *e, *tmp_e;
1da177e4 3054
b0defcdb 3055 if (!initialized)
1da177e4
LT		 3056 return;
3057
b0defcdb
CM		 3058#ifdef CONFIG_PCI
3059 pci_unregister_driver(&ipmi_pci_driver);
3060#endif
3061
dba9b4f6
CM		 3062#ifdef CONFIG_PPC_OF
3063 of_unregister_platform_driver(&ipmi_of_platform_driver);
3064#endif
3065
d6dfd131 3066 mutex_lock(&smi_infos_lock);
b0defcdb
CM		 3067 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
3068 cleanup_one_si(e);
d6dfd131 3069 mutex_unlock(&smi_infos_lock);
50c812b2
CM		 3070
3071 driver_unregister(&ipmi_driver);
1da177e4
LT		 3072}
3073module_exit(cleanup_ipmi_si);
3074
3075MODULE_LICENSE("GPL");
1fdd75bd
CM		 3076MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
3077MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");
Clone of davem's net-next-2.6 tree