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