projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add MODULE_ALIAS for autoloading ipmi driver on ACPI systems
[linux-2.6-block.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>
1da177e4 44#include <linux/sched.h>
07412736 45#include <linux/seq_file.h>
1da177e4
LT		 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>
16f4232c 60#include <linux/ipmi.h>
1da177e4
LT		 61#include <linux/ipmi_smi.h>
62#include <asm/io.h>
63#include "ipmi_si_sm.h"
64#include <linux/init.h>
b224cd3a 65#include <linux/dmi.h>
b361e27b
CM		 66#include <linux/string.h>
67#include <linux/ctype.h>
9e368fa0 68#include <linux/pnp.h>
11c675ce
SR		 69#include <linux/of_device.h>
70#include <linux/of_platform.h>
672d8eaf
RH		 71#include <linux/of_address.h>
72#include <linux/of_irq.h>
dba9b4f6 73
b361e27b 74#define PFX "ipmi_si: "
1da177e4
LT		 75
76/* Measure times between events in the driver. */
77#undef DEBUG_TIMING
78
79/* Call every 10 ms. */
80#define SI_TIMEOUT_TIME_USEC 10000
81#define SI_USEC_PER_JIFFY (1000000/HZ)
82#define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
83#define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
c305e3d3 84 short timeout */
1da177e4
LT		 85
86enum si_intf_state {
87 SI_NORMAL,
88 SI_GETTING_FLAGS,
89 SI_GETTING_EVENTS,
90 SI_CLEARING_FLAGS,
91 SI_CLEARING_FLAGS_THEN_SET_IRQ,
92 SI_GETTING_MESSAGES,
93 SI_ENABLE_INTERRUPTS1,
ee6cd5f8
CM		 94 SI_ENABLE_INTERRUPTS2,
95 SI_DISABLE_INTERRUPTS1,
96 SI_DISABLE_INTERRUPTS2
1da177e4
LT		 97 /* FIXME - add watchdog stuff. */
98};
99
9dbf68f9
CM		 100/* Some BT-specific defines we need here. */
101#define IPMI_BT_INTMASK_REG 2
102#define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
103#define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
104
1da177e4
LT		 105enum si_type {
106 SI_KCS, SI_SMIC, SI_BT
107};
b361e27b 108static char *si_to_str[] = { "kcs", "smic", "bt" };
1da177e4 109
5fedc4a2
MG		 110static char *ipmi_addr_src_to_str[] = { NULL, "hotmod", "hardcoded", "SPMI",
111 "ACPI", "SMBIOS", "PCI",
112 "device-tree", "default" };
113
50c812b2
CM		 114#define DEVICE_NAME "ipmi_si"
115
a1e9c9dd 116static struct platform_driver ipmi_driver;
64959e2d
CM		 117
118/*
119 * Indexes into stats[] in smi_info below.
120 */
ba8ff1c6
CM		 121enum si_stat_indexes {
122 /*
123 * Number of times the driver requested a timer while an operation
124 * was in progress.
125 */
126 SI_STAT_short_timeouts = 0,
127
128 /*
129 * Number of times the driver requested a timer while nothing was in
130 * progress.
131 */
132 SI_STAT_long_timeouts,
133
134 /* Number of times the interface was idle while being polled. */
135 SI_STAT_idles,
136
137 /* Number of interrupts the driver handled. */
138 SI_STAT_interrupts,
139
140 /* Number of time the driver got an ATTN from the hardware. */
141 SI_STAT_attentions,
64959e2d 142
ba8ff1c6
CM		 143 /* Number of times the driver requested flags from the hardware. */
144 SI_STAT_flag_fetches,
145
146 /* Number of times the hardware didn't follow the state machine. */
147 SI_STAT_hosed_count,
148
149 /* Number of completed messages. */
150 SI_STAT_complete_transactions,
151
152 /* Number of IPMI events received from the hardware. */
153 SI_STAT_events,
154
155 /* Number of watchdog pretimeouts. */
156 SI_STAT_watchdog_pretimeouts,
157
b3834be5 158 /* Number of asynchronous messages received. */
ba8ff1c6
CM		 159 SI_STAT_incoming_messages,
160
161
162 /* This *must* remain last, add new values above this. */
163 SI_NUM_STATS
164};
64959e2d 165
c305e3d3 166struct smi_info {
a9a2c44f 167 int intf_num;
1da177e4
LT		 168 ipmi_smi_t intf;
169 struct si_sm_data *si_sm;
170 struct si_sm_handlers *handlers;
171 enum si_type si_type;
172 spinlock_t si_lock;
1da177e4
LT		 173 struct list_head xmit_msgs;
174 struct list_head hp_xmit_msgs;
175 struct ipmi_smi_msg *curr_msg;
176 enum si_intf_state si_state;
177
c305e3d3
CM		 178 /*
179 * Used to handle the various types of I/O that can occur with
180 * IPMI
181 */
1da177e4
LT		 182 struct si_sm_io io;
183 int (*io_setup)(struct smi_info *info);
184 void (*io_cleanup)(struct smi_info *info);
185 int (*irq_setup)(struct smi_info *info);
186 void (*irq_cleanup)(struct smi_info *info);
187 unsigned int io_size;
5fedc4a2 188 enum ipmi_addr_src addr_source; /* ACPI, PCI, SMBIOS, hardcode, etc. */
b0defcdb
CM		 189 void (*addr_source_cleanup)(struct smi_info *info);
190 void *addr_source_data;
1da177e4 191
c305e3d3
CM		 192 /*
193 * Per-OEM handler, called from handle_flags(). Returns 1
194 * when handle_flags() needs to be re-run or 0 indicating it
195 * set si_state itself.
196 */
3ae0e0f9
CM		 197 int (*oem_data_avail_handler)(struct smi_info *smi_info);
198
c305e3d3
CM		 199 /*
200 * Flags from the last GET_MSG_FLAGS command, used when an ATTN
201 * is set to hold the flags until we are done handling everything
202 * from the flags.
203 */
1da177e4
LT		 204#define RECEIVE_MSG_AVAIL 0x01
205#define EVENT_MSG_BUFFER_FULL 0x02
206#define WDT_PRE_TIMEOUT_INT 0x08
3ae0e0f9
CM		 207#define OEM0_DATA_AVAIL 0x20
208#define OEM1_DATA_AVAIL 0x40
209#define OEM2_DATA_AVAIL 0x80
210#define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
c305e3d3
CM		 211 OEM1_DATA_AVAIL | \
212 OEM2_DATA_AVAIL)
1da177e4
LT		 213 unsigned char msg_flags;
214
40112ae7
CM		 215 /* Does the BMC have an event buffer? */
216 char has_event_buffer;
217
c305e3d3
CM		 218 /*
219 * If set to true, this will request events the next time the
220 * state machine is idle.
221 */
1da177e4
LT		 222 atomic_t req_events;
223
c305e3d3
CM		 224 /*
225 * If true, run the state machine to completion on every send
226 * call. Generally used after a panic to make sure stuff goes
227 * out.
228 */
1da177e4
LT		 229 int run_to_completion;
230
231 /* The I/O port of an SI interface. */
232 int port;
233
c305e3d3
CM		 234 /*
235 * The space between start addresses of the two ports. For
236 * instance, if the first port is 0xca2 and the spacing is 4, then
237 * the second port is 0xca6.
238 */
1da177e4
LT		 239 unsigned int spacing;
240
241 /* zero if no irq; */
242 int irq;
243
244 /* The timer for this si. */
245 struct timer_list si_timer;
246
247 /* The time (in jiffies) the last timeout occurred at. */
248 unsigned long last_timeout_jiffies;
249
250 /* Used to gracefully stop the timer without race conditions. */
a9a2c44f 251 atomic_t stop_operation;
1da177e4 252
c305e3d3
CM		 253 /*
254 * The driver will disable interrupts when it gets into a
255 * situation where it cannot handle messages due to lack of
256 * memory. Once that situation clears up, it will re-enable
257 * interrupts.
258 */
1da177e4
LT		 259 int interrupt_disabled;
260
50c812b2 261 /* From the get device id response... */
3ae0e0f9 262 struct ipmi_device_id device_id;
1da177e4 263
50c812b2
CM		 264 /* Driver model stuff. */
265 struct device *dev;
266 struct platform_device *pdev;
267
c305e3d3
CM		 268 /*
269 * True if we allocated the device, false if it came from
270 * someplace else (like PCI).
271 */
50c812b2
CM		 272 int dev_registered;
273
1da177e4
LT		 274 /* Slave address, could be reported from DMI. */
275 unsigned char slave_addr;
276
277 /* Counters and things for the proc filesystem. */
64959e2d 278 atomic_t stats[SI_NUM_STATS];
a9a2c44f 279
c305e3d3 280 struct task_struct *thread;
b0defcdb
CM		 281
282 struct list_head link;
16f4232c 283 union ipmi_smi_info_union addr_info;
1da177e4
LT		 284};
285
64959e2d
CM		 286#define smi_inc_stat(smi, stat) \
287 atomic_inc(&(smi)->stats[SI_STAT_ ## stat])
288#define smi_get_stat(smi, stat) \
289 ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat]))
290
a51f4a81
CM		 291#define SI_MAX_PARMS 4
292
293static int force_kipmid[SI_MAX_PARMS];
294static int num_force_kipmid;
56480287
MG		 295#ifdef CONFIG_PCI
296static int pci_registered;
297#endif
561f8182
YL		 298#ifdef CONFIG_ACPI
299static int pnp_registered;
300#endif
a51f4a81 301
ae74e823
MW		 302static unsigned int kipmid_max_busy_us[SI_MAX_PARMS];
303static int num_max_busy_us;
304
b361e27b
CM		 305static int unload_when_empty = 1;
306
2407d77a 307static int add_smi(struct smi_info *smi);
b0defcdb 308static int try_smi_init(struct smi_info *smi);
b361e27b 309static void cleanup_one_si(struct smi_info *to_clean);
d2478521 310static void cleanup_ipmi_si(void);
b0defcdb 311
e041c683 312static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
c305e3d3 313static int register_xaction_notifier(struct notifier_block *nb)
ea94027b 314{
e041c683 315 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
ea94027b
CM		 316}
317
1da177e4
LT		 318static void deliver_recv_msg(struct smi_info *smi_info,
319 struct ipmi_smi_msg *msg)
320{
7adf579c
CM		 321 /* Deliver the message to the upper layer. */
322 ipmi_smi_msg_received(smi_info->intf, msg);
1da177e4
LT		 323}
324
4d7cbac7 325static void return_hosed_msg(struct smi_info *smi_info, int cCode)
1da177e4
LT		 326{
327 struct ipmi_smi_msg *msg = smi_info->curr_msg;
328
4d7cbac7
CM		 329 if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
330 cCode = IPMI_ERR_UNSPECIFIED;
331 /* else use it as is */
332
25985edc 333 /* Make it a response */
1da177e4
LT		 334 msg->rsp[0] = msg->data[0] | 4;
335 msg->rsp[1] = msg->data[1];
4d7cbac7 336 msg->rsp[2] = cCode;
1da177e4
LT		 337 msg->rsp_size = 3;
338
339 smi_info->curr_msg = NULL;
340 deliver_recv_msg(smi_info, msg);
341}
342
343static enum si_sm_result start_next_msg(struct smi_info *smi_info)
344{
345 int rv;
346 struct list_head *entry = NULL;
347#ifdef DEBUG_TIMING
348 struct timeval t;
349#endif
350
1da177e4 351 /* Pick the high priority queue first. */
b0defcdb 352 if (!list_empty(&(smi_info->hp_xmit_msgs))) {
1da177e4 353 entry = smi_info->hp_xmit_msgs.next;
b0defcdb 354 } else if (!list_empty(&(smi_info->xmit_msgs))) {
1da177e4
LT		 355 entry = smi_info->xmit_msgs.next;
356 }
357
b0defcdb 358 if (!entry) {
1da177e4
LT		 359 smi_info->curr_msg = NULL;
360 rv = SI_SM_IDLE;
361 } else {
362 int err;
363
364 list_del(entry);
365 smi_info->curr_msg = list_entry(entry,
366 struct ipmi_smi_msg,
367 link);
368#ifdef DEBUG_TIMING
369 do_gettimeofday(&t);
c305e3d3 370 printk(KERN_DEBUG "**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1da177e4 371#endif
e041c683
AS		 372 err = atomic_notifier_call_chain(&xaction_notifier_list,
373 0, smi_info);
ea94027b
CM		 374 if (err & NOTIFY_STOP_MASK) {
375 rv = SI_SM_CALL_WITHOUT_DELAY;
376 goto out;
377 }
1da177e4
LT		 378 err = smi_info->handlers->start_transaction(
379 smi_info->si_sm,
380 smi_info->curr_msg->data,
381 smi_info->curr_msg->data_size);
c305e3d3 382 if (err)
4d7cbac7 383 return_hosed_msg(smi_info, err);
1da177e4
LT		 384
385 rv = SI_SM_CALL_WITHOUT_DELAY;
386 }
c305e3d3 387 out:
1da177e4
LT		 388 return rv;
389}
390
391static void start_enable_irq(struct smi_info *smi_info)
392{
393 unsigned char msg[2];
394
c305e3d3
CM		 395 /*
396 * If we are enabling interrupts, we have to tell the
397 * BMC to use them.
398 */
1da177e4
LT		 399 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
400 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
401
402 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
403 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
404}
405
ee6cd5f8
CM		 406static void start_disable_irq(struct smi_info *smi_info)
407{
408 unsigned char msg[2];
409
410 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
411 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
412
413 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
414 smi_info->si_state = SI_DISABLE_INTERRUPTS1;
415}
416
1da177e4
LT		 417static void start_clear_flags(struct smi_info *smi_info)
418{
419 unsigned char msg[3];
420
421 /* Make sure the watchdog pre-timeout flag is not set at startup. */
422 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
423 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
424 msg[2] = WDT_PRE_TIMEOUT_INT;
425
426 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
427 smi_info->si_state = SI_CLEARING_FLAGS;
428}
429
c305e3d3
CM		 430/*
431 * When we have a situtaion where we run out of memory and cannot
432 * allocate messages, we just leave them in the BMC and run the system
433 * polled until we can allocate some memory. Once we have some
434 * memory, we will re-enable the interrupt.
435 */
1da177e4
LT		 436static inline void disable_si_irq(struct smi_info *smi_info)
437{
b0defcdb 438 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
ee6cd5f8 439 start_disable_irq(smi_info);
1da177e4 440 smi_info->interrupt_disabled = 1;
ea4078ca
MG		 441 if (!atomic_read(&smi_info->stop_operation))
442 mod_timer(&smi_info->si_timer,
443 jiffies + SI_TIMEOUT_JIFFIES);
1da177e4
LT		 444 }
445}
446
447static inline void enable_si_irq(struct smi_info *smi_info)
448{
449 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
ee6cd5f8 450 start_enable_irq(smi_info);
1da177e4
LT		 451 smi_info->interrupt_disabled = 0;
452 }
453}
454
455static void handle_flags(struct smi_info *smi_info)
456{
3ae0e0f9 457 retry:
1da177e4
LT		 458 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
459 /* Watchdog pre-timeout */
64959e2d 460 smi_inc_stat(smi_info, watchdog_pretimeouts);
1da177e4
LT		 461
462 start_clear_flags(smi_info);
463 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
1da177e4 464 ipmi_smi_watchdog_pretimeout(smi_info->intf);
1da177e4
LT		 465 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
466 /* Messages available. */
467 smi_info->curr_msg = ipmi_alloc_smi_msg();
b0defcdb 468 if (!smi_info->curr_msg) {
1da177e4
LT		 469 disable_si_irq(smi_info);
470 smi_info->si_state = SI_NORMAL;
471 return;
472 }
473 enable_si_irq(smi_info);
474
475 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
476 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
477 smi_info->curr_msg->data_size = 2;
478
479 smi_info->handlers->start_transaction(
480 smi_info->si_sm,
481 smi_info->curr_msg->data,
482 smi_info->curr_msg->data_size);
483 smi_info->si_state = SI_GETTING_MESSAGES;
484 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
485 /* Events available. */
486 smi_info->curr_msg = ipmi_alloc_smi_msg();
b0defcdb 487 if (!smi_info->curr_msg) {
1da177e4
LT		 488 disable_si_irq(smi_info);
489 smi_info->si_state = SI_NORMAL;
490 return;
491 }
492 enable_si_irq(smi_info);
493
494 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
495 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
496 smi_info->curr_msg->data_size = 2;
497
498 smi_info->handlers->start_transaction(
499 smi_info->si_sm,
500 smi_info->curr_msg->data,
501 smi_info->curr_msg->data_size);
502 smi_info->si_state = SI_GETTING_EVENTS;
4064d5ef 503 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
c305e3d3 504 smi_info->oem_data_avail_handler) {
4064d5ef
CM		 505 if (smi_info->oem_data_avail_handler(smi_info))
506 goto retry;
c305e3d3 507 } else
1da177e4 508 smi_info->si_state = SI_NORMAL;
1da177e4
LT		 509}
510
511static void handle_transaction_done(struct smi_info *smi_info)
512{
513 struct ipmi_smi_msg *msg;
514#ifdef DEBUG_TIMING
515 struct timeval t;
516
517 do_gettimeofday(&t);
c305e3d3 518 printk(KERN_DEBUG "**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1da177e4
LT		 519#endif
520 switch (smi_info->si_state) {
521 case SI_NORMAL:
b0defcdb 522 if (!smi_info->curr_msg)
1da177e4
LT		 523 break;
524
525 smi_info->curr_msg->rsp_size
526 = smi_info->handlers->get_result(
527 smi_info->si_sm,
528 smi_info->curr_msg->rsp,
529 IPMI_MAX_MSG_LENGTH);
530
c305e3d3
CM		 531 /*
532 * Do this here becase deliver_recv_msg() releases the
533 * lock, and a new message can be put in during the
534 * time the lock is released.
535 */
1da177e4
LT		 536 msg = smi_info->curr_msg;
537 smi_info->curr_msg = NULL;
538 deliver_recv_msg(smi_info, msg);
539 break;
540
541 case SI_GETTING_FLAGS:
542 {
543 unsigned char msg[4];
544 unsigned int len;
545
546 /* We got the flags from the SMI, now handle them. */
547 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
548 if (msg[2] != 0) {
c305e3d3 549 /* Error fetching flags, just give up for now. */
1da177e4
LT		 550 smi_info->si_state = SI_NORMAL;
551 } else if (len < 4) {
c305e3d3
CM		 552 /*
553 * Hmm, no flags. That's technically illegal, but
554 * don't use uninitialized data.
555 */
1da177e4
LT		 556 smi_info->si_state = SI_NORMAL;
557 } else {
558 smi_info->msg_flags = msg[3];
559 handle_flags(smi_info);
560 }
561 break;
562 }
563
564 case SI_CLEARING_FLAGS:
565 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
566 {
567 unsigned char msg[3];
568
569 /* We cleared the flags. */
570 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
571 if (msg[2] != 0) {
572 /* Error clearing flags */
279fbd0c
MS		 573 dev_warn(smi_info->dev,
574 "Error clearing flags: %2.2x\n", msg[2]);
1da177e4
LT		 575 }
576 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
577 start_enable_irq(smi_info);
578 else
579 smi_info->si_state = SI_NORMAL;
580 break;
581 }
582
583 case SI_GETTING_EVENTS:
584 {
585 smi_info->curr_msg->rsp_size
586 = smi_info->handlers->get_result(
587 smi_info->si_sm,
588 smi_info->curr_msg->rsp,
589 IPMI_MAX_MSG_LENGTH);
590
c305e3d3
CM		 591 /*
592 * Do this here becase deliver_recv_msg() releases the
593 * lock, and a new message can be put in during the
594 * time the lock is released.
595 */
1da177e4
LT		 596 msg = smi_info->curr_msg;
597 smi_info->curr_msg = NULL;
598 if (msg->rsp[2] != 0) {
599 /* Error getting event, probably done. */
600 msg->done(msg);
601
602 /* Take off the event flag. */
603 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
604 handle_flags(smi_info);
605 } else {
64959e2d 606 smi_inc_stat(smi_info, events);
1da177e4 607
c305e3d3
CM		 608 /*
609 * Do this before we deliver the message
610 * because delivering the message releases the
611 * lock and something else can mess with the
612 * state.
613 */
1da177e4
LT		 614 handle_flags(smi_info);
615
616 deliver_recv_msg(smi_info, msg);
617 }
618 break;
619 }
620
621 case SI_GETTING_MESSAGES:
622 {
623 smi_info->curr_msg->rsp_size
624 = smi_info->handlers->get_result(
625 smi_info->si_sm,
626 smi_info->curr_msg->rsp,
627 IPMI_MAX_MSG_LENGTH);
628
c305e3d3
CM		 629 /*
630 * Do this here becase deliver_recv_msg() releases the
631 * lock, and a new message can be put in during the
632 * time the lock is released.
633 */
1da177e4
LT		 634 msg = smi_info->curr_msg;
635 smi_info->curr_msg = NULL;
636 if (msg->rsp[2] != 0) {
637 /* Error getting event, probably done. */
638 msg->done(msg);
639
640 /* Take off the msg flag. */
641 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
642 handle_flags(smi_info);
643 } else {
64959e2d 644 smi_inc_stat(smi_info, incoming_messages);
1da177e4 645
c305e3d3
CM		 646 /*
647 * Do this before we deliver the message
648 * because delivering the message releases the
649 * lock and something else can mess with the
650 * state.
651 */
1da177e4
LT		 652 handle_flags(smi_info);
653
654 deliver_recv_msg(smi_info, msg);
655 }
656 break;
657 }
658
659 case SI_ENABLE_INTERRUPTS1:
660 {
661 unsigned char msg[4];
662
663 /* We got the flags from the SMI, now handle them. */
664 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
665 if (msg[2] != 0) {
0849bfec
CM		 666 dev_warn(smi_info->dev,
667 "Couldn't get irq info: %x.\n", msg[2]);
668 dev_warn(smi_info->dev,
669 "Maybe ok, but ipmi might run very slowly.\n");
1da177e4
LT		 670 smi_info->si_state = SI_NORMAL;
671 } else {
672 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
673 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
ee6cd5f8
CM		 674 msg[2] = (msg[3] |
675 IPMI_BMC_RCV_MSG_INTR |
676 IPMI_BMC_EVT_MSG_INTR);
1da177e4
LT		 677 smi_info->handlers->start_transaction(
678 smi_info->si_sm, msg, 3);
679 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
680 }
681 break;
682 }
683
684 case SI_ENABLE_INTERRUPTS2:
685 {
686 unsigned char msg[4];
687
688 /* We got the flags from the SMI, now handle them. */
689 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
0849bfec
CM		 690 if (msg[2] != 0) {
691 dev_warn(smi_info->dev,
692 "Couldn't set irq info: %x.\n", msg[2]);
693 dev_warn(smi_info->dev,
694 "Maybe ok, but ipmi might run very slowly.\n");
695 } else
ea4078ca 696 smi_info->interrupt_disabled = 0;
1da177e4
LT		 697 smi_info->si_state = SI_NORMAL;
698 break;
699 }
ee6cd5f8
CM		 700
701 case SI_DISABLE_INTERRUPTS1:
702 {
703 unsigned char msg[4];
704
705 /* We got the flags from the SMI, now handle them. */
706 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
707 if (msg[2] != 0) {
279fbd0c
MS		 708 dev_warn(smi_info->dev, "Could not disable interrupts"
709 ", failed get.\n");
ee6cd5f8
CM		 710 smi_info->si_state = SI_NORMAL;
711 } else {
712 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
713 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
714 msg[2] = (msg[3] &
715 ~(IPMI_BMC_RCV_MSG_INTR |
716 IPMI_BMC_EVT_MSG_INTR));
717 smi_info->handlers->start_transaction(
718 smi_info->si_sm, msg, 3);
719 smi_info->si_state = SI_DISABLE_INTERRUPTS2;
720 }
721 break;
722 }
723
724 case SI_DISABLE_INTERRUPTS2:
725 {
726 unsigned char msg[4];
727
728 /* We got the flags from the SMI, now handle them. */
729 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
730 if (msg[2] != 0) {
279fbd0c
MS		 731 dev_warn(smi_info->dev, "Could not disable interrupts"
732 ", failed set.\n");
ee6cd5f8
CM		 733 }
734 smi_info->si_state = SI_NORMAL;
735 break;
736 }
1da177e4
LT		 737 }
738}
739
c305e3d3
CM		 740/*
741 * Called on timeouts and events. Timeouts should pass the elapsed
742 * time, interrupts should pass in zero. Must be called with
743 * si_lock held and interrupts disabled.
744 */
1da177e4
LT		 745static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
746 int time)
747{
748 enum si_sm_result si_sm_result;
749
750 restart:
c305e3d3
CM		 751 /*
752 * There used to be a loop here that waited a little while
753 * (around 25us) before giving up. That turned out to be
754 * pointless, the minimum delays I was seeing were in the 300us
755 * range, which is far too long to wait in an interrupt. So
756 * we just run until the state machine tells us something
757 * happened or it needs a delay.
758 */
1da177e4
LT		 759 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
760 time = 0;
761 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
1da177e4 762 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
1da177e4 763
c305e3d3 764 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
64959e2d 765 smi_inc_stat(smi_info, complete_transactions);
1da177e4
LT		 766
767 handle_transaction_done(smi_info);
768 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
c305e3d3 769 } else if (si_sm_result == SI_SM_HOSED) {
64959e2d 770 smi_inc_stat(smi_info, hosed_count);
1da177e4 771
c305e3d3
CM		 772 /*
773 * Do the before return_hosed_msg, because that
774 * releases the lock.
775 */
1da177e4
LT		 776 smi_info->si_state = SI_NORMAL;
777 if (smi_info->curr_msg != NULL) {
c305e3d3
CM		 778 /*
779 * If we were handling a user message, format
780 * a response to send to the upper layer to
781 * tell it about the error.
782 */
4d7cbac7 783 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
1da177e4
LT		 784 }
785 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
786 }
787
4ea18425
CM		 788 /*
789 * We prefer handling attn over new messages. But don't do
790 * this if there is not yet an upper layer to handle anything.
791 */
c305e3d3 792 if (likely(smi_info->intf) && si_sm_result == SI_SM_ATTN) {
1da177e4
LT		 793 unsigned char msg[2];
794
64959e2d 795 smi_inc_stat(smi_info, attentions);
1da177e4 796
c305e3d3
CM		 797 /*
798 * Got a attn, send down a get message flags to see
799 * what's causing it. It would be better to handle
800 * this in the upper layer, but due to the way
801 * interrupts work with the SMI, that's not really
802 * possible.
803 */
1da177e4
LT		 804 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
805 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
806
807 smi_info->handlers->start_transaction(
808 smi_info->si_sm, msg, 2);
809 smi_info->si_state = SI_GETTING_FLAGS;
810 goto restart;
811 }
812
813 /* If we are currently idle, try to start the next message. */
814 if (si_sm_result == SI_SM_IDLE) {
64959e2d 815 smi_inc_stat(smi_info, idles);
1da177e4
LT		 816
817 si_sm_result = start_next_msg(smi_info);
818 if (si_sm_result != SI_SM_IDLE)
819 goto restart;
c305e3d3 820 }
1da177e4
LT		 821
822 if ((si_sm_result == SI_SM_IDLE)
c305e3d3
CM		 823 && (atomic_read(&smi_info->req_events))) {
824 /*
825 * We are idle and the upper layer requested that I fetch
826 * events, so do so.
827 */
55162fb1 828 atomic_set(&smi_info->req_events, 0);
1da177e4 829
55162fb1
CM		 830 smi_info->curr_msg = ipmi_alloc_smi_msg();
831 if (!smi_info->curr_msg)
832 goto out;
1da177e4 833
55162fb1
CM		 834 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
835 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
836 smi_info->curr_msg->data_size = 2;
1da177e4
LT		 837
838 smi_info->handlers->start_transaction(
55162fb1
CM		 839 smi_info->si_sm,
840 smi_info->curr_msg->data,
841 smi_info->curr_msg->data_size);
842 smi_info->si_state = SI_GETTING_EVENTS;
1da177e4
LT		 843 goto restart;
844 }
55162fb1 845 out:
1da177e4
LT		 846 return si_sm_result;
847}
848
849static void sender(void *send_info,
850 struct ipmi_smi_msg *msg,
851 int priority)
852{
853 struct smi_info *smi_info = send_info;
854 enum si_sm_result result;
855 unsigned long flags;
856#ifdef DEBUG_TIMING
857 struct timeval t;
858#endif
859
b361e27b
CM		 860 if (atomic_read(&smi_info->stop_operation)) {
861 msg->rsp[0] = msg->data[0] | 4;
862 msg->rsp[1] = msg->data[1];
863 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
864 msg->rsp_size = 3;
865 deliver_recv_msg(smi_info, msg);
866 return;
867 }
868
1da177e4
LT		 869#ifdef DEBUG_TIMING
870 do_gettimeofday(&t);
871 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
872#endif
873
874 if (smi_info->run_to_completion) {
bda4c30a
CM		 875 /*
876 * If we are running to completion, then throw it in
877 * the list and run transactions until everything is
878 * clear. Priority doesn't matter here.
879 */
880
881 /*
882 * Run to completion means we are single-threaded, no
883 * need for locks.
884 */
1da177e4
LT		 885 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
886
1da177e4
LT		 887 result = smi_event_handler(smi_info, 0);
888 while (result != SI_SM_IDLE) {
889 udelay(SI_SHORT_TIMEOUT_USEC);
890 result = smi_event_handler(smi_info,
891 SI_SHORT_TIMEOUT_USEC);
892 }
1da177e4 893 return;
1da177e4 894 }
1da177e4 895
f60adf42 896 spin_lock_irqsave(&smi_info->si_lock, flags);
bda4c30a
CM		 897 if (priority > 0)
898 list_add_tail(&msg->link, &smi_info->hp_xmit_msgs);
899 else
900 list_add_tail(&msg->link, &smi_info->xmit_msgs);
bda4c30a 901
b88e7693 902 if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) {
f60adf42
CM		 903 /*
904 * last_timeout_jiffies is updated here to avoid
905 * smi_timeout() handler passing very large time_diff
906 * value to smi_event_handler() that causes
907 * the send command to abort.
908 */
909 smi_info->last_timeout_jiffies = jiffies;
910
911 mod_timer(&smi_info->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
912
913 if (smi_info->thread)
914 wake_up_process(smi_info->thread);
915
1da177e4 916 start_next_msg(smi_info);
b88e7693
S		 917 smi_event_handler(smi_info, 0);
918 }
bda4c30a 919 spin_unlock_irqrestore(&smi_info->si_lock, flags);
1da177e4
LT		 920}
921
922static void set_run_to_completion(void *send_info, int i_run_to_completion)
923{
924 struct smi_info *smi_info = send_info;
925 enum si_sm_result result;
1da177e4
LT		 926
927 smi_info->run_to_completion = i_run_to_completion;
928 if (i_run_to_completion) {
929 result = smi_event_handler(smi_info, 0);
930 while (result != SI_SM_IDLE) {
931 udelay(SI_SHORT_TIMEOUT_USEC);
932 result = smi_event_handler(smi_info,
933 SI_SHORT_TIMEOUT_USEC);
934 }
935 }
1da177e4
LT		 936}
937
ae74e823
MW		 938/*
939 * Use -1 in the nsec value of the busy waiting timespec to tell that
940 * we are spinning in kipmid looking for something and not delaying
941 * between checks
942 */
943static inline void ipmi_si_set_not_busy(struct timespec *ts)
944{
945 ts->tv_nsec = -1;
946}
947static inline int ipmi_si_is_busy(struct timespec *ts)
948{
949 return ts->tv_nsec != -1;
950}
951
952static int ipmi_thread_busy_wait(enum si_sm_result smi_result,
953 const struct smi_info *smi_info,
954 struct timespec *busy_until)
955{
956 unsigned int max_busy_us = 0;
957
958 if (smi_info->intf_num < num_max_busy_us)
959 max_busy_us = kipmid_max_busy_us[smi_info->intf_num];
960 if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
961 ipmi_si_set_not_busy(busy_until);
962 else if (!ipmi_si_is_busy(busy_until)) {
963 getnstimeofday(busy_until);
964 timespec_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
965 } else {
966 struct timespec now;
967 getnstimeofday(&now);
968 if (unlikely(timespec_compare(&now, busy_until) > 0)) {
969 ipmi_si_set_not_busy(busy_until);
970 return 0;
971 }
972 }
973 return 1;
974}
975
976
977/*
978 * A busy-waiting loop for speeding up IPMI operation.
979 *
980 * Lousy hardware makes this hard. This is only enabled for systems
981 * that are not BT and do not have interrupts. It starts spinning
982 * when an operation is complete or until max_busy tells it to stop
983 * (if that is enabled). See the paragraph on kimid_max_busy_us in
984 * Documentation/IPMI.txt for details.
985 */
a9a2c44f
CM		 986static int ipmi_thread(void *data)
987{
988 struct smi_info *smi_info = data;
e9a705a0 989 unsigned long flags;
a9a2c44f 990 enum si_sm_result smi_result;
ae74e823 991 struct timespec busy_until;
a9a2c44f 992
ae74e823 993 ipmi_si_set_not_busy(&busy_until);
a9a2c44f 994 set_user_nice(current, 19);
e9a705a0 995 while (!kthread_should_stop()) {
ae74e823
MW		 996 int busy_wait;
997
a9a2c44f 998 spin_lock_irqsave(&(smi_info->si_lock), flags);
8a3628d5 999 smi_result = smi_event_handler(smi_info, 0);
a9a2c44f 1000 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
ae74e823
MW		 1001 busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
1002 &busy_until);
c305e3d3
CM		 1003 if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
1004 ; /* do nothing */
ae74e823 1005 else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait)
33979734 1006 schedule();
3326f4f2
MG		 1007 else if (smi_result == SI_SM_IDLE)
1008 schedule_timeout_interruptible(100);
e9a705a0 1009 else
8d1f66dc 1010 schedule_timeout_interruptible(1);
a9a2c44f 1011 }
a9a2c44f
CM		 1012 return 0;
1013}
1014
1015
1da177e4
LT		 1016static void poll(void *send_info)
1017{
1018 struct smi_info *smi_info = send_info;
f60adf42
CM		 1019 unsigned long flags = 0;
1020 int run_to_completion = smi_info->run_to_completion;
1da177e4 1021
15c62e10
CM		 1022 /*
1023 * Make sure there is some delay in the poll loop so we can
1024 * drive time forward and timeout things.
1025 */
1026 udelay(10);
f60adf42
CM		 1027 if (!run_to_completion)
1028 spin_lock_irqsave(&smi_info->si_lock, flags);
15c62e10 1029 smi_event_handler(smi_info, 10);
f60adf42
CM		 1030 if (!run_to_completion)
1031 spin_unlock_irqrestore(&smi_info->si_lock, flags);
1da177e4
LT		 1032}
1033
1034static void request_events(void *send_info)
1035{
1036 struct smi_info *smi_info = send_info;
1037
40112ae7
CM		 1038 if (atomic_read(&smi_info->stop_operation) ||
1039 !smi_info->has_event_buffer)
b361e27b
CM		 1040 return;
1041
1da177e4
LT		 1042 atomic_set(&smi_info->req_events, 1);
1043}
1044
0c8204b3 1045static int initialized;
1da177e4 1046
1da177e4
LT		 1047static void smi_timeout(unsigned long data)
1048{
1049 struct smi_info *smi_info = (struct smi_info *) data;
1050 enum si_sm_result smi_result;
1051 unsigned long flags;
1052 unsigned long jiffies_now;
c4edff1c 1053 long time_diff;
3326f4f2 1054 long timeout;
1da177e4
LT		 1055#ifdef DEBUG_TIMING
1056 struct timeval t;
1057#endif
1058
1da177e4
LT		 1059 spin_lock_irqsave(&(smi_info->si_lock), flags);
1060#ifdef DEBUG_TIMING
1061 do_gettimeofday(&t);
c305e3d3 1062 printk(KERN_DEBUG "**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1da177e4
LT		 1063#endif
1064 jiffies_now = jiffies;
c4edff1c 1065 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
1da177e4
LT		 1066 * SI_USEC_PER_JIFFY);
1067 smi_result = smi_event_handler(smi_info, time_diff);
1068
1069 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1070
1071 smi_info->last_timeout_jiffies = jiffies_now;
1072
b0defcdb 1073 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
1da177e4 1074 /* Running with interrupts, only do long timeouts. */
3326f4f2 1075 timeout = jiffies + SI_TIMEOUT_JIFFIES;
64959e2d 1076 smi_inc_stat(smi_info, long_timeouts);
3326f4f2 1077 goto do_mod_timer;
1da177e4
LT		 1078 }
1079
c305e3d3
CM		 1080 /*
1081 * If the state machine asks for a short delay, then shorten
1082 * the timer timeout.
1083 */
1da177e4 1084 if (smi_result == SI_SM_CALL_WITH_DELAY) {
64959e2d 1085 smi_inc_stat(smi_info, short_timeouts);
3326f4f2 1086 timeout = jiffies + 1;
1da177e4 1087 } else {
64959e2d 1088 smi_inc_stat(smi_info, long_timeouts);
3326f4f2 1089 timeout = jiffies + SI_TIMEOUT_JIFFIES;
1da177e4
LT		 1090 }
1091
3326f4f2
MG		 1092 do_mod_timer:
1093 if (smi_result != SI_SM_IDLE)
1094 mod_timer(&(smi_info->si_timer), timeout);
1da177e4
LT		 1095}
1096
7d12e780 1097static irqreturn_t si_irq_handler(int irq, void *data)
1da177e4
LT		 1098{
1099 struct smi_info *smi_info = data;
1100 unsigned long flags;
1101#ifdef DEBUG_TIMING
1102 struct timeval t;
1103#endif
1104
1105 spin_lock_irqsave(&(smi_info->si_lock), flags);
1106
64959e2d 1107 smi_inc_stat(smi_info, interrupts);
1da177e4 1108
1da177e4
LT		 1109#ifdef DEBUG_TIMING
1110 do_gettimeofday(&t);
c305e3d3 1111 printk(KERN_DEBUG "**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1da177e4
LT		 1112#endif
1113 smi_event_handler(smi_info, 0);
1da177e4
LT		 1114 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1115 return IRQ_HANDLED;
1116}
1117
7d12e780 1118static irqreturn_t si_bt_irq_handler(int irq, void *data)
9dbf68f9
CM		 1119{
1120 struct smi_info *smi_info = data;
1121 /* We need to clear the IRQ flag for the BT interface. */
1122 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
1123 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
1124 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
7d12e780 1125 return si_irq_handler(irq, data);
9dbf68f9
CM		 1126}
1127
453823ba
CM		 1128static int smi_start_processing(void *send_info,
1129 ipmi_smi_t intf)
1130{
1131 struct smi_info *new_smi = send_info;
a51f4a81 1132 int enable = 0;
453823ba
CM		 1133
1134 new_smi->intf = intf;
1135
c45adc39
CM		 1136 /* Try to claim any interrupts. */
1137 if (new_smi->irq_setup)
1138 new_smi->irq_setup(new_smi);
1139
453823ba
CM		 1140 /* Set up the timer that drives the interface. */
1141 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
1142 new_smi->last_timeout_jiffies = jiffies;
1143 mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
1144
a51f4a81
CM		 1145 /*
1146 * Check if the user forcefully enabled the daemon.
1147 */
1148 if (new_smi->intf_num < num_force_kipmid)
1149 enable = force_kipmid[new_smi->intf_num];
df3fe8de
CM		 1150 /*
1151 * The BT interface is efficient enough to not need a thread,
1152 * and there is no need for a thread if we have interrupts.
1153 */
c305e3d3 1154 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
a51f4a81
CM		 1155 enable = 1;
1156
1157 if (enable) {
453823ba
CM		 1158 new_smi->thread = kthread_run(ipmi_thread, new_smi,
1159 "kipmi%d", new_smi->intf_num);
1160 if (IS_ERR(new_smi->thread)) {
279fbd0c
MS		 1161 dev_notice(new_smi->dev, "Could not start"
1162 " kernel thread due to error %ld, only using"
1163 " timers to drive the interface\n",
1164 PTR_ERR(new_smi->thread));
453823ba
CM		 1165 new_smi->thread = NULL;
1166 }
1167 }
1168
1169 return 0;
1170}
9dbf68f9 1171
16f4232c
ZY		 1172static int get_smi_info(void *send_info, struct ipmi_smi_info *data)
1173{
1174 struct smi_info *smi = send_info;
1175
1176 data->addr_src = smi->addr_source;
1177 data->dev = smi->dev;
1178 data->addr_info = smi->addr_info;
1179 get_device(smi->dev);
1180
1181 return 0;
1182}
1183
b9675136
CM		 1184static void set_maintenance_mode(void *send_info, int enable)
1185{
1186 struct smi_info *smi_info = send_info;
1187
1188 if (!enable)
1189 atomic_set(&smi_info->req_events, 0);
1190}
1191
c305e3d3 1192static struct ipmi_smi_handlers handlers = {
1da177e4 1193 .owner = THIS_MODULE,
453823ba 1194 .start_processing = smi_start_processing,
16f4232c 1195 .get_smi_info = get_smi_info,
1da177e4
LT		 1196 .sender = sender,
1197 .request_events = request_events,
b9675136 1198 .set_maintenance_mode = set_maintenance_mode,
1da177e4
LT		 1199 .set_run_to_completion = set_run_to_completion,
1200 .poll = poll,
1201};
1202
c305e3d3
CM		 1203/*
1204 * There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1205 * a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS.
1206 */
1da177e4 1207
b0defcdb 1208static LIST_HEAD(smi_infos);
d6dfd131 1209static DEFINE_MUTEX(smi_infos_lock);
b0defcdb 1210static int smi_num; /* Used to sequence the SMIs */
1da177e4 1211
1da177e4 1212#define DEFAULT_REGSPACING 1
dba9b4f6 1213#define DEFAULT_REGSIZE 1
1da177e4 1214
d941aeae
CM		 1215#ifdef CONFIG_ACPI
1216static bool si_tryacpi = 1;
1217#endif
1218#ifdef CONFIG_DMI
1219static bool si_trydmi = 1;
1220#endif
f2afae46
CM		 1221static bool si_tryplatform = 1;
1222#ifdef CONFIG_PCI
1223static bool si_trypci = 1;
1224#endif
90ab5ee9 1225static bool si_trydefaults = 1;
1da177e4
LT		 1226static char *si_type[SI_MAX_PARMS];
1227#define MAX_SI_TYPE_STR 30
1228static char si_type_str[MAX_SI_TYPE_STR];
1229static unsigned long addrs[SI_MAX_PARMS];
64a6f950 1230static unsigned int num_addrs;
1da177e4 1231static unsigned int ports[SI_MAX_PARMS];
64a6f950 1232static unsigned int num_ports;
1da177e4 1233static int irqs[SI_MAX_PARMS];
64a6f950 1234static unsigned int num_irqs;
1da177e4 1235static int regspacings[SI_MAX_PARMS];
64a6f950 1236static unsigned int num_regspacings;
1da177e4 1237static int regsizes[SI_MAX_PARMS];
64a6f950 1238static unsigned int num_regsizes;
1da177e4 1239static int regshifts[SI_MAX_PARMS];
64a6f950 1240static unsigned int num_regshifts;
2f95d513 1241static int slave_addrs[SI_MAX_PARMS]; /* Leaving 0 chooses the default value */
64a6f950 1242static unsigned int num_slave_addrs;
1da177e4 1243
b361e27b
CM		 1244#define IPMI_IO_ADDR_SPACE 0
1245#define IPMI_MEM_ADDR_SPACE 1
1d5636cc 1246static char *addr_space_to_str[] = { "i/o", "mem" };
b361e27b
CM		 1247
1248static int hotmod_handler(const char *val, struct kernel_param *kp);
1249
1250module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
1251MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See"
1252 " Documentation/IPMI.txt in the kernel sources for the"
1253 " gory details.");
1da177e4 1254
d941aeae
CM		 1255#ifdef CONFIG_ACPI
1256module_param_named(tryacpi, si_tryacpi, bool, 0);
1257MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1258 " default scan of the interfaces identified via ACPI");
1259#endif
1260#ifdef CONFIG_DMI
1261module_param_named(trydmi, si_trydmi, bool, 0);
1262MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the"
1263 " default scan of the interfaces identified via DMI");
1264#endif
f2afae46
CM		 1265module_param_named(tryplatform, si_tryplatform, bool, 0);
1266MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1267 " default scan of the interfaces identified via platform"
1268 " interfaces like openfirmware");
1269#ifdef CONFIG_PCI
1270module_param_named(trypci, si_trypci, bool, 0);
1271MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
1272 " default scan of the interfaces identified via pci");
1273#endif
1da177e4
LT		 1274module_param_named(trydefaults, si_trydefaults, bool, 0);
1275MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1276 " default scan of the KCS and SMIC interface at the standard"
1277 " address");
1278module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1279MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1280 " interface separated by commas. The types are 'kcs',"
1281 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1282 " the first interface to kcs and the second to bt");
64a6f950 1283module_param_array(addrs, ulong, &num_addrs, 0);
1da177e4
LT		 1284MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1285 " addresses separated by commas. Only use if an interface"
1286 " is in memory. Otherwise, set it to zero or leave"
1287 " it blank.");
64a6f950 1288module_param_array(ports, uint, &num_ports, 0);
1da177e4
LT		 1289MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1290 " addresses separated by commas. Only use if an interface"
1291 " is a port. Otherwise, set it to zero or leave"
1292 " it blank.");
1293module_param_array(irqs, int, &num_irqs, 0);
1294MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1295 " addresses separated by commas. Only use if an interface"
1296 " has an interrupt. Otherwise, set it to zero or leave"
1297 " it blank.");
1298module_param_array(regspacings, int, &num_regspacings, 0);
1299MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1300 " and each successive register used by the interface. For"
1301 " instance, if the start address is 0xca2 and the spacing"
1302 " is 2, then the second address is at 0xca4. Defaults"
1303 " to 1.");
1304module_param_array(regsizes, int, &num_regsizes, 0);
1305MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1306 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1307 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1308 " the 8-bit IPMI register has to be read from a larger"
1309 " register.");
1310module_param_array(regshifts, int, &num_regshifts, 0);
1311MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1312 " IPMI register, in bits. For instance, if the data"
1313 " is read from a 32-bit word and the IPMI data is in"
1314 " bit 8-15, then the shift would be 8");
1315module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1316MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1317 " the controller. Normally this is 0x20, but can be"
1318 " overridden by this parm. This is an array indexed"
1319 " by interface number.");
a51f4a81
CM		 1320module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1321MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1322 " disabled(0). Normally the IPMI driver auto-detects"
1323 " this, but the value may be overridden by this parm.");
b361e27b
CM		 1324module_param(unload_when_empty, int, 0);
1325MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
1326 " specified or found, default is 1. Setting to 0"
1327 " is useful for hot add of devices using hotmod.");
ae74e823
MW		 1328module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
1329MODULE_PARM_DESC(kipmid_max_busy_us,
1330 "Max time (in microseconds) to busy-wait for IPMI data before"
1331 " sleeping. 0 (default) means to wait forever. Set to 100-500"
1332 " if kipmid is using up a lot of CPU time.");
1da177e4
LT		 1333
1334
b0defcdb 1335static void std_irq_cleanup(struct smi_info *info)
1da177e4 1336{
b0defcdb
CM		 1337 if (info->si_type == SI_BT)
1338 /* Disable the interrupt in the BT interface. */
1339 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1340 free_irq(info->irq, info);
1da177e4 1341}
1da177e4
LT		 1342
1343static int std_irq_setup(struct smi_info *info)
1344{
1345 int rv;
1346
b0defcdb 1347 if (!info->irq)
1da177e4
LT		 1348 return 0;
1349
9dbf68f9
CM		 1350 if (info->si_type == SI_BT) {
1351 rv = request_irq(info->irq,
1352 si_bt_irq_handler,
ee6cd5f8 1353 IRQF_SHARED | IRQF_DISABLED,
9dbf68f9
CM		 1354 DEVICE_NAME,
1355 info);
b0defcdb 1356 if (!rv)
9dbf68f9
CM		 1357 /* Enable the interrupt in the BT interface. */
1358 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1359 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1360 } else
1361 rv = request_irq(info->irq,
1362 si_irq_handler,
ee6cd5f8 1363 IRQF_SHARED | IRQF_DISABLED,
9dbf68f9
CM		 1364 DEVICE_NAME,
1365 info);
1da177e4 1366 if (rv) {
279fbd0c
MS		 1367 dev_warn(info->dev, "%s unable to claim interrupt %d,"
1368 " running polled\n",
1369 DEVICE_NAME, info->irq);
1da177e4
LT		 1370 info->irq = 0;
1371 } else {
b0defcdb 1372 info->irq_cleanup = std_irq_cleanup;
279fbd0c 1373 dev_info(info->dev, "Using irq %d\n", info->irq);
1da177e4
LT		 1374 }
1375
1376 return rv;
1377}
1378
1da177e4
LT		 1379static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1380{
b0defcdb 1381 unsigned int addr = io->addr_data;
1da177e4 1382
b0defcdb 1383 return inb(addr + (offset * io->regspacing));
1da177e4
LT		 1384}
1385
1386static void port_outb(struct si_sm_io *io, unsigned int offset,
1387 unsigned char b)
1388{
b0defcdb 1389 unsigned int addr = io->addr_data;
1da177e4 1390
b0defcdb 1391 outb(b, addr + (offset * io->regspacing));
1da177e4
LT		 1392}
1393
1394static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1395{
b0defcdb 1396 unsigned int addr = io->addr_data;
1da177e4 1397
b0defcdb 1398 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1da177e4
LT		 1399}
1400
1401static void port_outw(struct si_sm_io *io, unsigned int offset,
1402 unsigned char b)
1403{
b0defcdb 1404 unsigned int addr = io->addr_data;
1da177e4 1405
b0defcdb 1406 outw(b << io->regshift, addr + (offset * io->regspacing));
1da177e4
LT		 1407}
1408
1409static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1410{
b0defcdb 1411 unsigned int addr = io->addr_data;
1da177e4 1412
b0defcdb 1413 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
1da177e4
LT		 1414}
1415
1416static void port_outl(struct si_sm_io *io, unsigned int offset,
1417 unsigned char b)
1418{
b0defcdb 1419 unsigned int addr = io->addr_data;
1da177e4 1420
b0defcdb 1421 outl(b << io->regshift, addr+(offset * io->regspacing));
1da177e4
LT		 1422}
1423
1424static void port_cleanup(struct smi_info *info)
1425{
b0defcdb 1426 unsigned int addr = info->io.addr_data;
d61a3ead 1427 int idx;
1da177e4 1428
b0defcdb 1429 if (addr) {
c305e3d3 1430 for (idx = 0; idx < info->io_size; idx++)
d61a3ead
CM		 1431 release_region(addr + idx * info->io.regspacing,
1432 info->io.regsize);
1da177e4 1433 }
1da177e4
LT		 1434}
1435
1436static int port_setup(struct smi_info *info)
1437{
b0defcdb 1438 unsigned int addr = info->io.addr_data;
d61a3ead 1439 int idx;
1da177e4 1440
b0defcdb 1441 if (!addr)
1da177e4
LT		 1442 return -ENODEV;
1443
1444 info->io_cleanup = port_cleanup;
1445
c305e3d3
CM		 1446 /*
1447 * Figure out the actual inb/inw/inl/etc routine to use based
1448 * upon the register size.
1449 */
1da177e4
LT		 1450 switch (info->io.regsize) {
1451 case 1:
1452 info->io.inputb = port_inb;
1453 info->io.outputb = port_outb;
1454 break;
1455 case 2:
1456 info->io.inputb = port_inw;
1457 info->io.outputb = port_outw;
1458 break;
1459 case 4:
1460 info->io.inputb = port_inl;
1461 info->io.outputb = port_outl;
1462 break;
1463 default:
279fbd0c
MS		 1464 dev_warn(info->dev, "Invalid register size: %d\n",
1465 info->io.regsize);
1da177e4
LT		 1466 return -EINVAL;
1467 }
1468
c305e3d3
CM		 1469 /*
1470 * Some BIOSes reserve disjoint I/O regions in their ACPI
d61a3ead
CM		 1471 * tables. This causes problems when trying to register the
1472 * entire I/O region. Therefore we must register each I/O
1473 * port separately.
1474 */
c305e3d3 1475 for (idx = 0; idx < info->io_size; idx++) {
d61a3ead
CM		 1476 if (request_region(addr + idx * info->io.regspacing,
1477 info->io.regsize, DEVICE_NAME) == NULL) {
1478 /* Undo allocations */
1479 while (idx--) {
1480 release_region(addr + idx * info->io.regspacing,
1481 info->io.regsize);
1482 }
1483 return -EIO;
1484 }
1485 }
1da177e4
LT		 1486 return 0;
1487}
1488
546cfdf4 1489static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
1da177e4
LT		 1490{
1491 return readb((io->addr)+(offset * io->regspacing));
1492}
1493
546cfdf4 1494static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
1da177e4
LT		 1495 unsigned char b)
1496{
1497 writeb(b, (io->addr)+(offset * io->regspacing));
1498}
1499
546cfdf4 1500static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
1da177e4
LT		 1501{
1502 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
64d9fe69 1503 & 0xff;
1da177e4
LT		 1504}
1505
546cfdf4 1506static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
1da177e4
LT		 1507 unsigned char b)
1508{
1509 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1510}
1511
546cfdf4 1512static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
1da177e4
LT		 1513{
1514 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
64d9fe69 1515 & 0xff;
1da177e4
LT		 1516}
1517
546cfdf4 1518static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
1da177e4
LT		 1519 unsigned char b)
1520{
1521 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1522}
1523
1524#ifdef readq
1525static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1526{
1527 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
64d9fe69 1528 & 0xff;
1da177e4
LT		 1529}
1530
1531static void mem_outq(struct si_sm_io *io, unsigned int offset,
1532 unsigned char b)
1533{
1534 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1535}
1536#endif
1537
1538static void mem_cleanup(struct smi_info *info)
1539{
b0defcdb 1540 unsigned long addr = info->io.addr_data;
1da177e4
LT		 1541 int mapsize;
1542
1543 if (info->io.addr) {
1544 iounmap(info->io.addr);
1545
1546 mapsize = ((info->io_size * info->io.regspacing)
1547 - (info->io.regspacing - info->io.regsize));
1548
b0defcdb 1549 release_mem_region(addr, mapsize);
1da177e4 1550 }
1da177e4
LT		 1551}
1552
1553static int mem_setup(struct smi_info *info)
1554{
b0defcdb 1555 unsigned long addr = info->io.addr_data;
1da177e4
LT		 1556 int mapsize;
1557
b0defcdb 1558 if (!addr)
1da177e4
LT		 1559 return -ENODEV;
1560
1561 info->io_cleanup = mem_cleanup;
1562
c305e3d3
CM		 1563 /*
1564 * Figure out the actual readb/readw/readl/etc routine to use based
1565 * upon the register size.
1566 */
1da177e4
LT		 1567 switch (info->io.regsize) {
1568 case 1:
546cfdf4
AD		 1569 info->io.inputb = intf_mem_inb;
1570 info->io.outputb = intf_mem_outb;
1da177e4
LT		 1571 break;
1572 case 2:
546cfdf4
AD		 1573 info->io.inputb = intf_mem_inw;
1574 info->io.outputb = intf_mem_outw;
1da177e4
LT		 1575 break;
1576 case 4:
546cfdf4
AD		 1577 info->io.inputb = intf_mem_inl;
1578 info->io.outputb = intf_mem_outl;
1da177e4
LT		 1579 break;
1580#ifdef readq
1581 case 8:
1582 info->io.inputb = mem_inq;
1583 info->io.outputb = mem_outq;
1584 break;
1585#endif
1586 default:
279fbd0c
MS		 1587 dev_warn(info->dev, "Invalid register size: %d\n",
1588 info->io.regsize);
1da177e4
LT		 1589 return -EINVAL;
1590 }
1591
c305e3d3
CM		 1592 /*
1593 * Calculate the total amount of memory to claim. This is an
1da177e4
LT		 1594 * unusual looking calculation, but it avoids claiming any
1595 * more memory than it has to. It will claim everything
1596 * between the first address to the end of the last full
c305e3d3
CM		 1597 * register.
1598 */
1da177e4
LT		 1599 mapsize = ((info->io_size * info->io.regspacing)
1600 - (info->io.regspacing - info->io.regsize));
1601
b0defcdb 1602 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
1da177e4
LT		 1603 return -EIO;
1604
b0defcdb 1605 info->io.addr = ioremap(addr, mapsize);
1da177e4 1606 if (info->io.addr == NULL) {
b0defcdb 1607 release_mem_region(addr, mapsize);
1da177e4
LT		 1608 return -EIO;
1609 }
1610 return 0;
1611}
1612
b361e27b
CM		 1613/*
1614 * Parms come in as <op1>[:op2[:op3...]]. ops are:
1615 * add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
1616 * Options are:
1617 * rsp=<regspacing>
1618 * rsi=<regsize>
1619 * rsh=<regshift>
1620 * irq=<irq>
1621 * ipmb=<ipmb addr>
1622 */
1623enum hotmod_op { HM_ADD, HM_REMOVE };
1624struct hotmod_vals {
1625 char *name;
1626 int val;
1627};
1628static struct hotmod_vals hotmod_ops[] = {
1629 { "add", HM_ADD },
1630 { "remove", HM_REMOVE },
1631 { NULL }
1632};
1633static struct hotmod_vals hotmod_si[] = {
1634 { "kcs", SI_KCS },
1635 { "smic", SI_SMIC },
1636 { "bt", SI_BT },
1637 { NULL }
1638};
1639static struct hotmod_vals hotmod_as[] = {
1640 { "mem", IPMI_MEM_ADDR_SPACE },
1641 { "i/o", IPMI_IO_ADDR_SPACE },
1642 { NULL }
1643};
1d5636cc 1644
b361e27b
CM		 1645static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
1646{
1647 char *s;
1648 int i;
1649
1650 s = strchr(*curr, ',');
1651 if (!s) {
1652 printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
1653 return -EINVAL;
1654 }
1655 *s = '\0';
1656 s++;
1657 for (i = 0; hotmod_ops[i].name; i++) {
1d5636cc 1658 if (strcmp(*curr, v[i].name) == 0) {
b361e27b
CM		 1659 *val = v[i].val;
1660 *curr = s;
1661 return 0;
1662 }
1663 }
1664
1665 printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
1666 return -EINVAL;
1667}
1668
1d5636cc
CM		 1669static int check_hotmod_int_op(const char *curr, const char *option,
1670 const char *name, int *val)
1671{
1672 char *n;
1673
1674 if (strcmp(curr, name) == 0) {
1675 if (!option) {
1676 printk(KERN_WARNING PFX
1677 "No option given for '%s'\n",
1678 curr);
1679 return -EINVAL;
1680 }
1681 *val = simple_strtoul(option, &n, 0);
1682 if ((*n != '\0') || (*option == '\0')) {
1683 printk(KERN_WARNING PFX
1684 "Bad option given for '%s'\n",
1685 curr);
1686 return -EINVAL;
1687 }
1688 return 1;
1689 }
1690 return 0;
1691}
1692
de5e2ddf
ED		 1693static struct smi_info *smi_info_alloc(void)
1694{
1695 struct smi_info *info = kzalloc(sizeof(*info), GFP_KERNEL);
1696
f60adf42 1697 if (info)
de5e2ddf 1698 spin_lock_init(&info->si_lock);
de5e2ddf
ED		 1699 return info;
1700}
1701
b361e27b
CM		 1702static int hotmod_handler(const char *val, struct kernel_param *kp)
1703{
1704 char *str = kstrdup(val, GFP_KERNEL);
1d5636cc 1705 int rv;
b361e27b
CM		 1706 char *next, *curr, *s, *n, *o;
1707 enum hotmod_op op;
1708 enum si_type si_type;
1709 int addr_space;
1710 unsigned long addr;
1711 int regspacing;
1712 int regsize;
1713 int regshift;
1714 int irq;
1715 int ipmb;
1716 int ival;
1d5636cc 1717 int len;
b361e27b
CM		 1718 struct smi_info *info;
1719
1720 if (!str)
1721 return -ENOMEM;
1722
1723 /* Kill any trailing spaces, as we can get a "\n" from echo. */
1d5636cc
CM		 1724 len = strlen(str);
1725 ival = len - 1;
b361e27b
CM		 1726 while ((ival >= 0) && isspace(str[ival])) {
1727 str[ival] = '\0';
1728 ival--;
1729 }
1730
1731 for (curr = str; curr; curr = next) {
1732 regspacing = 1;
1733 regsize = 1;
1734 regshift = 0;
1735 irq = 0;
2f95d513 1736 ipmb = 0; /* Choose the default if not specified */
b361e27b
CM		 1737
1738 next = strchr(curr, ':');
1739 if (next) {
1740 *next = '\0';
1741 next++;
1742 }
1743
1744 rv = parse_str(hotmod_ops, &ival, "operation", &curr);
1745 if (rv)
1746 break;
1747 op = ival;
1748
1749 rv = parse_str(hotmod_si, &ival, "interface type", &curr);
1750 if (rv)
1751 break;
1752 si_type = ival;
1753
1754 rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
1755 if (rv)
1756 break;
1757
1758 s = strchr(curr, ',');
1759 if (s) {
1760 *s = '\0';
1761 s++;
1762 }
1763 addr = simple_strtoul(curr, &n, 0);
1764 if ((*n != '\0') || (*curr == '\0')) {
1765 printk(KERN_WARNING PFX "Invalid hotmod address"
1766 " '%s'\n", curr);
1767 break;
1768 }
1769
1770 while (s) {
1771 curr = s;
1772 s = strchr(curr, ',');
1773 if (s) {
1774 *s = '\0';
1775 s++;
1776 }
1777 o = strchr(curr, '=');
1778 if (o) {
1779 *o = '\0';
1780 o++;
1781 }
1d5636cc
CM		 1782 rv = check_hotmod_int_op(curr, o, "rsp", &regspacing);
1783 if (rv < 0)
b361e27b 1784 goto out;
1d5636cc
CM		 1785 else if (rv)
1786 continue;
1787 rv = check_hotmod_int_op(curr, o, "rsi", &regsize);
1788 if (rv < 0)
1789 goto out;
1790 else if (rv)
1791 continue;
1792 rv = check_hotmod_int_op(curr, o, "rsh", &regshift);
1793 if (rv < 0)
1794 goto out;
1795 else if (rv)
1796 continue;
1797 rv = check_hotmod_int_op(curr, o, "irq", &irq);
1798 if (rv < 0)
1799 goto out;
1800 else if (rv)
1801 continue;
1802 rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
1803 if (rv < 0)
1804 goto out;
1805 else if (rv)
1806 continue;
1807
1808 rv = -EINVAL;
1809 printk(KERN_WARNING PFX
1810 "Invalid hotmod option '%s'\n",
1811 curr);
1812 goto out;
b361e27b
CM		 1813 }
1814
1815 if (op == HM_ADD) {
de5e2ddf 1816 info = smi_info_alloc();
b361e27b
CM		 1817 if (!info) {
1818 rv = -ENOMEM;
1819 goto out;
1820 }
1821
5fedc4a2 1822 info->addr_source = SI_HOTMOD;
b361e27b
CM		 1823 info->si_type = si_type;
1824 info->io.addr_data = addr;
1825 info->io.addr_type = addr_space;
1826 if (addr_space == IPMI_MEM_ADDR_SPACE)
1827 info->io_setup = mem_setup;
1828 else
1829 info->io_setup = port_setup;
1830
1831 info->io.addr = NULL;
1832 info->io.regspacing = regspacing;
1833 if (!info->io.regspacing)
1834 info->io.regspacing = DEFAULT_REGSPACING;
1835 info->io.regsize = regsize;
1836 if (!info->io.regsize)
1837 info->io.regsize = DEFAULT_REGSPACING;
1838 info->io.regshift = regshift;
1839 info->irq = irq;
1840 if (info->irq)
1841 info->irq_setup = std_irq_setup;
1842 info->slave_addr = ipmb;
1843
7faefea6 1844 if (!add_smi(info)) {
2407d77a
MG		 1845 if (try_smi_init(info))
1846 cleanup_one_si(info);
7faefea6
YL		 1847 } else {
1848 kfree(info);
1849 }
b361e27b
CM		 1850 } else {
1851 /* remove */
1852 struct smi_info *e, *tmp_e;
1853
1854 mutex_lock(&smi_infos_lock);
1855 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
1856 if (e->io.addr_type != addr_space)
1857 continue;
1858 if (e->si_type != si_type)
1859 continue;
1860 if (e->io.addr_data == addr)
1861 cleanup_one_si(e);
1862 }
1863 mutex_unlock(&smi_infos_lock);
1864 }
1865 }
1d5636cc 1866 rv = len;
b361e27b
CM		 1867 out:
1868 kfree(str);
1869 return rv;
1870}
b0defcdb 1871
2223cbec 1872static int hardcode_find_bmc(void)
1da177e4 1873{
a1e9c9dd 1874 int ret = -ENODEV;
b0defcdb 1875 int i;
1da177e4
LT		 1876 struct smi_info *info;
1877
b0defcdb
CM		 1878 for (i = 0; i < SI_MAX_PARMS; i++) {
1879 if (!ports[i] && !addrs[i])
1880 continue;
1da177e4 1881
de5e2ddf 1882 info = smi_info_alloc();
b0defcdb 1883 if (!info)
a1e9c9dd 1884 return -ENOMEM;
1da177e4 1885
5fedc4a2 1886 info->addr_source = SI_HARDCODED;
279fbd0c 1887 printk(KERN_INFO PFX "probing via hardcoded address\n");
1da177e4 1888
1d5636cc 1889 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
b0defcdb 1890 info->si_type = SI_KCS;
1d5636cc 1891 } else if (strcmp(si_type[i], "smic") == 0) {
b0defcdb 1892 info->si_type = SI_SMIC;
1d5636cc 1893 } else if (strcmp(si_type[i], "bt") == 0) {
b0defcdb
CM		 1894 info->si_type = SI_BT;
1895 } else {
279fbd0c 1896 printk(KERN_WARNING PFX "Interface type specified "
b0defcdb
CM		 1897 "for interface %d, was invalid: %s\n",
1898 i, si_type[i]);
1899 kfree(info);
1900 continue;
1901 }
1da177e4 1902
b0defcdb
CM		 1903 if (ports[i]) {
1904 /* An I/O port */
1905 info->io_setup = port_setup;
1906 info->io.addr_data = ports[i];
1907 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1908 } else if (addrs[i]) {
1909 /* A memory port */
1910 info->io_setup = mem_setup;
1911 info->io.addr_data = addrs[i];
1912 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1913 } else {
279fbd0c
MS		 1914 printk(KERN_WARNING PFX "Interface type specified "
1915 "for interface %d, but port and address were "
1916 "not set or set to zero.\n", i);
b0defcdb
CM		 1917 kfree(info);
1918 continue;
1919 }
1da177e4 1920
b0defcdb
CM		 1921 info->io.addr = NULL;
1922 info->io.regspacing = regspacings[i];
1923 if (!info->io.regspacing)
1924 info->io.regspacing = DEFAULT_REGSPACING;
1925 info->io.regsize = regsizes[i];
1926 if (!info->io.regsize)
1927 info->io.regsize = DEFAULT_REGSPACING;
1928 info->io.regshift = regshifts[i];
1929 info->irq = irqs[i];
1930 if (info->irq)
1931 info->irq_setup = std_irq_setup;
2f95d513 1932 info->slave_addr = slave_addrs[i];
1da177e4 1933
7faefea6 1934 if (!add_smi(info)) {
2407d77a
MG		 1935 if (try_smi_init(info))
1936 cleanup_one_si(info);
a1e9c9dd 1937 ret = 0;
7faefea6
YL		 1938 } else {
1939 kfree(info);
1940 }
b0defcdb 1941 }
a1e9c9dd 1942 return ret;
b0defcdb 1943}
1da177e4 1944
8466361a 1945#ifdef CONFIG_ACPI
1da177e4
LT		 1946
1947#include <linux/acpi.h>
1948
c305e3d3
CM		 1949/*
1950 * Once we get an ACPI failure, we don't try any more, because we go
1951 * through the tables sequentially. Once we don't find a table, there
1952 * are no more.
1953 */
0c8204b3 1954static int acpi_failure;
1da177e4
LT		 1955
1956/* For GPE-type interrupts. */
8b6cd8ad
LM		 1957static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
1958 u32 gpe_number, void *context)
1da177e4
LT		 1959{
1960 struct smi_info *smi_info = context;
1961 unsigned long flags;
1962#ifdef DEBUG_TIMING
1963 struct timeval t;
1964#endif
1965
1966 spin_lock_irqsave(&(smi_info->si_lock), flags);
1967
64959e2d 1968 smi_inc_stat(smi_info, interrupts);
1da177e4 1969
1da177e4
LT		 1970#ifdef DEBUG_TIMING
1971 do_gettimeofday(&t);
1972 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1973#endif
1974 smi_event_handler(smi_info, 0);
1da177e4
LT		 1975 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1976
1977 return ACPI_INTERRUPT_HANDLED;
1978}
1979
b0defcdb
CM		 1980static void acpi_gpe_irq_cleanup(struct smi_info *info)
1981{
1982 if (!info->irq)
1983 return;
1984
1985 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1986}
1987
1da177e4
LT		 1988static int acpi_gpe_irq_setup(struct smi_info *info)
1989{
1990 acpi_status status;
1991
b0defcdb 1992 if (!info->irq)
1da177e4
LT		 1993 return 0;
1994
1995 /* FIXME - is level triggered right? */
1996 status = acpi_install_gpe_handler(NULL,
1997 info->irq,
1998 ACPI_GPE_LEVEL_TRIGGERED,
1999 &ipmi_acpi_gpe,
2000 info);
2001 if (status != AE_OK) {
279fbd0c
MS		 2002 dev_warn(info->dev, "%s unable to claim ACPI GPE %d,"
2003 " running polled\n", DEVICE_NAME, info->irq);
1da177e4
LT		 2004 info->irq = 0;
2005 return -EINVAL;
2006 } else {
b0defcdb 2007 info->irq_cleanup = acpi_gpe_irq_cleanup;
279fbd0c 2008 dev_info(info->dev, "Using ACPI GPE %d\n", info->irq);
1da177e4
LT		 2009 return 0;
2010 }
2011}
2012
1da177e4
LT		 2013/*
2014 * Defined at
631dd1a8 2015 * http://h21007.www2.hp.com/portal/download/files/unprot/hpspmi.pdf
1da177e4
LT		 2016 */
2017struct SPMITable {
2018 s8 Signature[4];
2019 u32 Length;
2020 u8 Revision;
2021 u8 Checksum;
2022 s8 OEMID[6];
2023 s8 OEMTableID[8];
2024 s8 OEMRevision[4];
2025 s8 CreatorID[4];
2026 s8 CreatorRevision[4];
2027 u8 InterfaceType;
2028 u8 IPMIlegacy;
2029 s16 SpecificationRevision;
2030
2031 /*
2032 * Bit 0 - SCI interrupt supported
2033 * Bit 1 - I/O APIC/SAPIC
2034 */
2035 u8 InterruptType;
2036
c305e3d3
CM		 2037 /*
2038 * If bit 0 of InterruptType is set, then this is the SCI
2039 * interrupt in the GPEx_STS register.
2040 */
1da177e4
LT		 2041 u8 GPE;
2042
2043 s16 Reserved;
2044
c305e3d3
CM		 2045 /*
2046 * If bit 1 of InterruptType is set, then this is the I/O
2047 * APIC/SAPIC interrupt.
2048 */
1da177e4
LT		 2049 u32 GlobalSystemInterrupt;
2050
2051 /* The actual register address. */
2052 struct acpi_generic_address addr;
2053
2054 u8 UID[4];
2055
2056 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
2057};
2058
2223cbec 2059static int try_init_spmi(struct SPMITable *spmi)
1da177e4
LT		 2060{
2061 struct smi_info *info;
1da177e4 2062
1da177e4 2063 if (spmi->IPMIlegacy != 1) {
279fbd0c
MS		 2064 printk(KERN_INFO PFX "Bad SPMI legacy %d\n", spmi->IPMIlegacy);
2065 return -ENODEV;
1da177e4
LT		 2066 }
2067
de5e2ddf 2068 info = smi_info_alloc();
b0defcdb 2069 if (!info) {
279fbd0c 2070 printk(KERN_ERR PFX "Could not allocate SI data (3)\n");
b0defcdb
CM		 2071 return -ENOMEM;
2072 }
2073
5fedc4a2 2074 info->addr_source = SI_SPMI;
279fbd0c 2075 printk(KERN_INFO PFX "probing via SPMI\n");
1da177e4 2076
1da177e4 2077 /* Figure out the interface type. */
c305e3d3 2078 switch (spmi->InterfaceType) {
1da177e4 2079 case 1: /* KCS */
b0defcdb 2080 info->si_type = SI_KCS;
1da177e4 2081 break;
1da177e4 2082 case 2: /* SMIC */
b0defcdb 2083 info->si_type = SI_SMIC;
1da177e4 2084 break;
1da177e4 2085 case 3: /* BT */
b0defcdb 2086 info->si_type = SI_BT;
1da177e4 2087 break;
1da177e4 2088 default:
279fbd0c
MS		 2089 printk(KERN_INFO PFX "Unknown ACPI/SPMI SI type %d\n",
2090 spmi->InterfaceType);
b0defcdb 2091 kfree(info);
1da177e4
LT		 2092 return -EIO;
2093 }
2094
1da177e4
LT		 2095 if (spmi->InterruptType & 1) {
2096 /* We've got a GPE interrupt. */
2097 info->irq = spmi->GPE;
2098 info->irq_setup = acpi_gpe_irq_setup;
1da177e4
LT		 2099 } else if (spmi->InterruptType & 2) {
2100 /* We've got an APIC/SAPIC interrupt. */
2101 info->irq = spmi->GlobalSystemInterrupt;
2102 info->irq_setup = std_irq_setup;
1da177e4
LT		 2103 } else {
2104 /* Use the default interrupt setting. */
2105 info->irq = 0;
2106 info->irq_setup = NULL;
2107 }
2108
15a58ed1 2109 if (spmi->addr.bit_width) {
35bc37a0 2110 /* A (hopefully) properly formed register bit width. */
15a58ed1 2111 info->io.regspacing = spmi->addr.bit_width / 8;
35bc37a0 2112 } else {
35bc37a0
CM		 2113 info->io.regspacing = DEFAULT_REGSPACING;
2114 }
b0defcdb 2115 info->io.regsize = info->io.regspacing;
15a58ed1 2116 info->io.regshift = spmi->addr.bit_offset;
1da177e4 2117
15a58ed1 2118 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
1da177e4 2119 info->io_setup = mem_setup;
8fe1425a 2120 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
15a58ed1 2121 } else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
1da177e4 2122 info->io_setup = port_setup;
8fe1425a 2123 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1da177e4
LT		 2124 } else {
2125 kfree(info);
279fbd0c 2126 printk(KERN_WARNING PFX "Unknown ACPI I/O Address type\n");
1da177e4
LT		 2127 return -EIO;
2128 }
b0defcdb 2129 info->io.addr_data = spmi->addr.address;
1da177e4 2130
7bb671e3
YL		 2131 pr_info("ipmi_si: SPMI: %s %#lx regsize %d spacing %d irq %d\n",
2132 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
2133 info->io.addr_data, info->io.regsize, info->io.regspacing,
2134 info->irq);
2135
7faefea6
YL		 2136 if (add_smi(info))
2137 kfree(info);
1da177e4 2138
1da177e4
LT		 2139 return 0;
2140}
b0defcdb 2141
2223cbec 2142static void spmi_find_bmc(void)
b0defcdb
CM		 2143{
2144 acpi_status status;
2145 struct SPMITable *spmi;
2146 int i;
2147
2148 if (acpi_disabled)
2149 return;
2150
2151 if (acpi_failure)
2152 return;
2153
2154 for (i = 0; ; i++) {
15a58ed1
AS		 2155 status = acpi_get_table(ACPI_SIG_SPMI, i+1,
2156 (struct acpi_table_header **)&spmi);
b0defcdb
CM		 2157 if (status != AE_OK)
2158 return;
2159
18a3e0bf 2160 try_init_spmi(spmi);
b0defcdb
CM		 2161 }
2162}
9e368fa0 2163
2223cbec 2164static int ipmi_pnp_probe(struct pnp_dev *dev,
9e368fa0
BH		 2165 const struct pnp_device_id *dev_id)
2166{
2167 struct acpi_device *acpi_dev;
2168 struct smi_info *info;
a9e31765 2169 struct resource *res, *res_second;
9e368fa0
BH		 2170 acpi_handle handle;
2171 acpi_status status;
2172 unsigned long long tmp;
2173
2174 acpi_dev = pnp_acpi_device(dev);
2175 if (!acpi_dev)
2176 return -ENODEV;
2177
de5e2ddf 2178 info = smi_info_alloc();
9e368fa0
BH		 2179 if (!info)
2180 return -ENOMEM;
2181
5fedc4a2 2182 info->addr_source = SI_ACPI;
279fbd0c 2183 printk(KERN_INFO PFX "probing via ACPI\n");
9e368fa0
BH		 2184
2185 handle = acpi_dev->handle;
16f4232c 2186 info->addr_info.acpi_info.acpi_handle = handle;
9e368fa0
BH		 2187
2188 /* _IFT tells us the interface type: KCS, BT, etc */
2189 status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp);
2190 if (ACPI_FAILURE(status))
2191 goto err_free;
2192
2193 switch (tmp) {
2194 case 1:
2195 info->si_type = SI_KCS;
2196 break;
2197 case 2:
2198 info->si_type = SI_SMIC;
2199 break;
2200 case 3:
2201 info->si_type = SI_BT;
2202 break;
2203 default:
279fbd0c 2204 dev_info(&dev->dev, "unknown IPMI type %lld\n", tmp);
9e368fa0
BH		 2205 goto err_free;
2206 }
2207
279fbd0c
MS		 2208 res = pnp_get_resource(dev, IORESOURCE_IO, 0);
2209 if (res) {
9e368fa0
BH		 2210 info->io_setup = port_setup;
2211 info->io.addr_type = IPMI_IO_ADDR_SPACE;
9e368fa0 2212 } else {
279fbd0c
MS		 2213 res = pnp_get_resource(dev, IORESOURCE_MEM, 0);
2214 if (res) {
2215 info->io_setup = mem_setup;
2216 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2217 }
2218 }
2219 if (!res) {
9e368fa0
BH		 2220 dev_err(&dev->dev, "no I/O or memory address\n");
2221 goto err_free;
2222 }
279fbd0c 2223 info->io.addr_data = res->start;
9e368fa0
BH		 2224
2225 info->io.regspacing = DEFAULT_REGSPACING;
a9e31765 2226 res_second = pnp_get_resource(dev,
d9e1b6c4
YL		 2227 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ?
2228 IORESOURCE_IO : IORESOURCE_MEM,
2229 1);
a9e31765
YL		 2230 if (res_second) {
2231 if (res_second->start > info->io.addr_data)
2232 info->io.regspacing = res_second->start - info->io.addr_data;
d9e1b6c4 2233 }
9e368fa0
BH		 2234 info->io.regsize = DEFAULT_REGSPACING;
2235 info->io.regshift = 0;
2236
2237 /* If _GPE exists, use it; otherwise use standard interrupts */
2238 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
2239 if (ACPI_SUCCESS(status)) {
2240 info->irq = tmp;
2241 info->irq_setup = acpi_gpe_irq_setup;
2242 } else if (pnp_irq_valid(dev, 0)) {
2243 info->irq = pnp_irq(dev, 0);
2244 info->irq_setup = std_irq_setup;
2245 }
2246
8c8eae27 2247 info->dev = &dev->dev;
9e368fa0
BH		 2248 pnp_set_drvdata(dev, info);
2249
279fbd0c
MS		 2250 dev_info(info->dev, "%pR regsize %d spacing %d irq %d\n",
2251 res, info->io.regsize, info->io.regspacing,
2252 info->irq);
2253
7faefea6
YL		 2254 if (add_smi(info))
2255 goto err_free;
2256
2257 return 0;
9e368fa0
BH		 2258
2259err_free:
2260 kfree(info);
2261 return -EINVAL;
2262}
2263
39af33fc 2264static void ipmi_pnp_remove(struct pnp_dev *dev)
9e368fa0
BH		 2265{
2266 struct smi_info *info = pnp_get_drvdata(dev);
2267
2268 cleanup_one_si(info);
2269}
2270
2271static const struct pnp_device_id pnp_dev_table[] = {
2272 {"IPI0001", 0},
2273 {"", 0},
2274};
2275
2276static struct pnp_driver ipmi_pnp_driver = {
2277 .name = DEVICE_NAME,
2278 .probe = ipmi_pnp_probe,
bcd2982a 2279 .remove = ipmi_pnp_remove,
9e368fa0
BH		 2280 .id_table = pnp_dev_table,
2281};
a798e2d2
JD		 2282
2283MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
1da177e4
LT		 2284#endif
2285
a9fad4cc 2286#ifdef CONFIG_DMI
c305e3d3 2287struct dmi_ipmi_data {
1da177e4
LT		 2288 u8 type;
2289 u8 addr_space;
2290 unsigned long base_addr;
2291 u8 irq;
2292 u8 offset;
2293 u8 slave_addr;
b0defcdb 2294};
1da177e4 2295
2223cbec 2296static int decode_dmi(const struct dmi_header *dm,
b0defcdb 2297 struct dmi_ipmi_data *dmi)
1da177e4 2298{
1855256c 2299 const u8 *data = (const u8 *)dm;
1da177e4
LT		 2300 unsigned long base_addr;
2301 u8 reg_spacing;
b224cd3a 2302 u8 len = dm->length;
1da177e4 2303
b0defcdb 2304 dmi->type = data[4];
1da177e4
LT		 2305
2306 memcpy(&base_addr, data+8, sizeof(unsigned long));
2307 if (len >= 0x11) {
2308 if (base_addr & 1) {
2309 /* I/O */
2310 base_addr &= 0xFFFE;
b0defcdb 2311 dmi->addr_space = IPMI_IO_ADDR_SPACE;
c305e3d3 2312 } else
1da177e4 2313 /* Memory */
b0defcdb 2314 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
c305e3d3 2315
1da177e4
LT		 2316 /* If bit 4 of byte 0x10 is set, then the lsb for the address
2317 is odd. */
b0defcdb 2318 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
1da177e4 2319
b0defcdb 2320 dmi->irq = data[0x11];
1da177e4
LT		 2321
2322 /* The top two bits of byte 0x10 hold the register spacing. */
b224cd3a 2323 reg_spacing = (data[0x10] & 0xC0) >> 6;
c305e3d3 2324 switch (reg_spacing) {
1da177e4 2325 case 0x00: /* Byte boundaries */
b0defcdb 2326 dmi->offset = 1;
1da177e4
LT		 2327 break;
2328 case 0x01: /* 32-bit boundaries */
b0defcdb 2329 dmi->offset = 4;
1da177e4
LT		 2330 break;
2331 case 0x02: /* 16-byte boundaries */
b0defcdb 2332 dmi->offset = 16;
1da177e4
LT		 2333 break;
2334 default:
2335 /* Some other interface, just ignore it. */
2336 return -EIO;
2337 }
2338 } else {
2339 /* Old DMI spec. */
c305e3d3
CM		 2340 /*
2341 * Note that technically, the lower bit of the base
92068801
CM		 2342 * address should be 1 if the address is I/O and 0 if
2343 * the address is in memory. So many systems get that
2344 * wrong (and all that I have seen are I/O) so we just
2345 * ignore that bit and assume I/O. Systems that use
c305e3d3
CM		 2346 * memory should use the newer spec, anyway.
2347 */
b0defcdb
CM		 2348 dmi->base_addr = base_addr & 0xfffe;
2349 dmi->addr_space = IPMI_IO_ADDR_SPACE;
2350 dmi->offset = 1;
1da177e4
LT		 2351 }
2352
b0defcdb 2353 dmi->slave_addr = data[6];
1da177e4 2354
b0defcdb 2355 return 0;
1da177e4
LT		 2356}
2357
2223cbec 2358static void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
1da177e4 2359{
b0defcdb 2360 struct smi_info *info;
1da177e4 2361
de5e2ddf 2362 info = smi_info_alloc();
b0defcdb 2363 if (!info) {
279fbd0c 2364 printk(KERN_ERR PFX "Could not allocate SI data\n");
b0defcdb 2365 return;
1da177e4 2366 }
1da177e4 2367
5fedc4a2 2368 info->addr_source = SI_SMBIOS;
279fbd0c 2369 printk(KERN_INFO PFX "probing via SMBIOS\n");
1da177e4 2370
e8b33617 2371 switch (ipmi_data->type) {
b0defcdb
CM		 2372 case 0x01: /* KCS */
2373 info->si_type = SI_KCS;
2374 break;
2375 case 0x02: /* SMIC */
2376 info->si_type = SI_SMIC;
2377 break;
2378 case 0x03: /* BT */
2379 info->si_type = SI_BT;
2380 break;
2381 default:
80cd6920 2382 kfree(info);
b0defcdb 2383 return;
1da177e4 2384 }
1da177e4 2385
b0defcdb
CM		 2386 switch (ipmi_data->addr_space) {
2387 case IPMI_MEM_ADDR_SPACE:
1da177e4 2388 info->io_setup = mem_setup;
b0defcdb
CM		 2389 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2390 break;
2391
2392 case IPMI_IO_ADDR_SPACE:
1da177e4 2393 info->io_setup = port_setup;
b0defcdb
CM		 2394 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2395 break;
2396
2397 default:
1da177e4 2398 kfree(info);
279fbd0c 2399 printk(KERN_WARNING PFX "Unknown SMBIOS I/O Address type: %d\n",
b0defcdb
CM		 2400 ipmi_data->addr_space);
2401 return;
1da177e4 2402 }
b0defcdb 2403 info->io.addr_data = ipmi_data->base_addr;
1da177e4 2404
b0defcdb
CM		 2405 info->io.regspacing = ipmi_data->offset;
2406 if (!info->io.regspacing)
1da177e4
LT		 2407 info->io.regspacing = DEFAULT_REGSPACING;
2408 info->io.regsize = DEFAULT_REGSPACING;
b0defcdb 2409 info->io.regshift = 0;
1da177e4
LT		 2410
2411 info->slave_addr = ipmi_data->slave_addr;
2412
b0defcdb
CM		 2413 info->irq = ipmi_data->irq;
2414 if (info->irq)
2415 info->irq_setup = std_irq_setup;
1da177e4 2416
7bb671e3
YL		 2417 pr_info("ipmi_si: SMBIOS: %s %#lx regsize %d spacing %d irq %d\n",
2418 (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
2419 info->io.addr_data, info->io.regsize, info->io.regspacing,
2420 info->irq);
2421
7faefea6
YL		 2422 if (add_smi(info))
2423 kfree(info);
b0defcdb 2424}
1da177e4 2425
2223cbec 2426static void dmi_find_bmc(void)
b0defcdb 2427{
1855256c 2428 const struct dmi_device *dev = NULL;
b0defcdb
CM		 2429 struct dmi_ipmi_data data;
2430 int rv;
2431
2432 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
397f4ebf 2433 memset(&data, 0, sizeof(data));
1855256c
JG		 2434 rv = decode_dmi((const struct dmi_header *) dev->device_data,
2435 &data);
b0defcdb
CM		 2436 if (!rv)
2437 try_init_dmi(&data);
2438 }
1da177e4 2439}
a9fad4cc 2440#endif /* CONFIG_DMI */
1da177e4
LT		 2441
2442#ifdef CONFIG_PCI
2443
b0defcdb
CM		 2444#define PCI_ERMC_CLASSCODE 0x0C0700
2445#define PCI_ERMC_CLASSCODE_MASK 0xffffff00
2446#define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
2447#define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
2448#define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
2449#define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
2450
1da177e4
LT		 2451#define PCI_HP_VENDOR_ID 0x103C
2452#define PCI_MMC_DEVICE_ID 0x121A
2453#define PCI_MMC_ADDR_CW 0x10
2454
b0defcdb
CM		 2455static void ipmi_pci_cleanup(struct smi_info *info)
2456{
2457 struct pci_dev *pdev = info->addr_source_data;
2458
2459 pci_disable_device(pdev);
2460}
1da177e4 2461
2223cbec 2462static int ipmi_pci_probe_regspacing(struct smi_info *info)
a6c16c28
CM		 2463{
2464 if (info->si_type == SI_KCS) {
2465 unsigned char status;
2466 int regspacing;
2467
2468 info->io.regsize = DEFAULT_REGSIZE;
2469 info->io.regshift = 0;
2470 info->io_size = 2;
2471 info->handlers = &kcs_smi_handlers;
2472
2473 /* detect 1, 4, 16byte spacing */
2474 for (regspacing = DEFAULT_REGSPACING; regspacing <= 16;) {
2475 info->io.regspacing = regspacing;
2476 if (info->io_setup(info)) {
2477 dev_err(info->dev,
2478 "Could not setup I/O space\n");
2479 return DEFAULT_REGSPACING;
2480 }
2481 /* write invalid cmd */
2482 info->io.outputb(&info->io, 1, 0x10);
2483 /* read status back */
2484 status = info->io.inputb(&info->io, 1);
2485 info->io_cleanup(info);
2486 if (status)
2487 return regspacing;
2488 regspacing *= 4;
2489 }
2490 }
2491 return DEFAULT_REGSPACING;
2492}
2493
2223cbec 2494static int ipmi_pci_probe(struct pci_dev *pdev,
b0defcdb 2495 const struct pci_device_id *ent)
1da177e4 2496{
b0defcdb
CM		 2497 int rv;
2498 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
2499 struct smi_info *info;
1da177e4 2500
de5e2ddf 2501 info = smi_info_alloc();
b0defcdb 2502 if (!info)
1cd441f9 2503 return -ENOMEM;
1da177e4 2504
5fedc4a2 2505 info->addr_source = SI_PCI;
279fbd0c 2506 dev_info(&pdev->dev, "probing via PCI");
1da177e4 2507
b0defcdb
CM		 2508 switch (class_type) {
2509 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
2510 info->si_type = SI_SMIC;
2511 break;
1da177e4 2512
b0defcdb
CM		 2513 case PCI_ERMC_CLASSCODE_TYPE_KCS:
2514 info->si_type = SI_KCS;
2515 break;
2516
2517 case PCI_ERMC_CLASSCODE_TYPE_BT:
2518 info->si_type = SI_BT;
2519 break;
2520
2521 default:
2522 kfree(info);
279fbd0c 2523 dev_info(&pdev->dev, "Unknown IPMI type: %d\n", class_type);
1cd441f9 2524 return -ENOMEM;
1da177e4
LT		 2525 }
2526
b0defcdb
CM		 2527 rv = pci_enable_device(pdev);
2528 if (rv) {
279fbd0c 2529 dev_err(&pdev->dev, "couldn't enable PCI device\n");
b0defcdb
CM		 2530 kfree(info);
2531 return rv;
1da177e4
LT		 2532 }
2533
b0defcdb
CM		 2534 info->addr_source_cleanup = ipmi_pci_cleanup;
2535 info->addr_source_data = pdev;
1da177e4 2536
b0defcdb
CM		 2537 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2538 info->io_setup = port_setup;
2539 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2540 } else {
2541 info->io_setup = mem_setup;
2542 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1da177e4 2543 }
b0defcdb 2544 info->io.addr_data = pci_resource_start(pdev, 0);
1da177e4 2545
a6c16c28
CM		 2546 info->io.regspacing = ipmi_pci_probe_regspacing(info);
2547 info->io.regsize = DEFAULT_REGSIZE;
b0defcdb 2548 info->io.regshift = 0;
1da177e4 2549
b0defcdb
CM		 2550 info->irq = pdev->irq;
2551 if (info->irq)
2552 info->irq_setup = std_irq_setup;
1da177e4 2553
50c812b2 2554 info->dev = &pdev->dev;
fca3b747 2555 pci_set_drvdata(pdev, info);
50c812b2 2556
279fbd0c
MS		 2557 dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n",
2558 &pdev->resource[0], info->io.regsize, info->io.regspacing,
2559 info->irq);
2560
7faefea6
YL		 2561 if (add_smi(info))
2562 kfree(info);
2563
2564 return 0;
b0defcdb 2565}
1da177e4 2566
39af33fc 2567static void ipmi_pci_remove(struct pci_dev *pdev)
b0defcdb 2568{
fca3b747
CM		 2569 struct smi_info *info = pci_get_drvdata(pdev);
2570 cleanup_one_si(info);
b0defcdb 2571}
1da177e4 2572
b0defcdb
CM		 2573static struct pci_device_id ipmi_pci_devices[] = {
2574 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
248bdd5e
KC		 2575 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
2576 { 0, }
b0defcdb
CM		 2577};
2578MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
2579
2580static struct pci_driver ipmi_pci_driver = {
c305e3d3
CM		 2581 .name = DEVICE_NAME,
2582 .id_table = ipmi_pci_devices,
2583 .probe = ipmi_pci_probe,
bcd2982a 2584 .remove = ipmi_pci_remove,
b0defcdb
CM		 2585};
2586#endif /* CONFIG_PCI */
1da177e4 2587
b1608d69 2588static struct of_device_id ipmi_match[];
2223cbec 2589static int ipmi_probe(struct platform_device *dev)
dba9b4f6 2590{
a1e9c9dd 2591#ifdef CONFIG_OF
b1608d69 2592 const struct of_device_id *match;
dba9b4f6
CM		 2593 struct smi_info *info;
2594 struct resource resource;
da81c3b9 2595 const __be32 *regsize, *regspacing, *regshift;
61c7a080 2596 struct device_node *np = dev->dev.of_node;
dba9b4f6
CM		 2597 int ret;
2598 int proplen;
2599
279fbd0c 2600 dev_info(&dev->dev, "probing via device tree\n");
dba9b4f6 2601
b1608d69
GL		 2602 match = of_match_device(ipmi_match, &dev->dev);
2603 if (!match)
a1e9c9dd
RH		 2604 return -EINVAL;
2605
dba9b4f6
CM		 2606 ret = of_address_to_resource(np, 0, &resource);
2607 if (ret) {
2608 dev_warn(&dev->dev, PFX "invalid address from OF\n");
2609 return ret;
2610 }
2611
9c25099d 2612 regsize = of_get_property(np, "reg-size", &proplen);
dba9b4f6
CM		 2613 if (regsize && proplen != 4) {
2614 dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
2615 return -EINVAL;
2616 }
2617
9c25099d 2618 regspacing = of_get_property(np, "reg-spacing", &proplen);
dba9b4f6
CM		 2619 if (regspacing && proplen != 4) {
2620 dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
2621 return -EINVAL;
2622 }
2623
9c25099d 2624 regshift = of_get_property(np, "reg-shift", &proplen);
dba9b4f6
CM		 2625 if (regshift && proplen != 4) {
2626 dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
2627 return -EINVAL;
2628 }
2629
de5e2ddf 2630 info = smi_info_alloc();
dba9b4f6
CM		 2631
2632 if (!info) {
2633 dev_err(&dev->dev,
279fbd0c 2634 "could not allocate memory for OF probe\n");
dba9b4f6
CM		 2635 return -ENOMEM;
2636 }
2637
b1608d69 2638 info->si_type = (enum si_type) match->data;
5fedc4a2 2639 info->addr_source = SI_DEVICETREE;
dba9b4f6
CM		 2640 info->irq_setup = std_irq_setup;
2641
3b7ec117
NC		 2642 if (resource.flags & IORESOURCE_IO) {
2643 info->io_setup = port_setup;
2644 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2645 } else {
2646 info->io_setup = mem_setup;
2647 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2648 }
2649
dba9b4f6
CM		 2650 info->io.addr_data = resource.start;
2651
da81c3b9
RH		 2652 info->io.regsize = regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE;
2653 info->io.regspacing = regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING;
2654 info->io.regshift = regshift ? be32_to_cpup(regshift) : 0;
dba9b4f6 2655
61c7a080 2656 info->irq = irq_of_parse_and_map(dev->dev.of_node, 0);
dba9b4f6
CM		 2657 info->dev = &dev->dev;
2658
279fbd0c 2659 dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",
dba9b4f6
CM		 2660 info->io.addr_data, info->io.regsize, info->io.regspacing,
2661 info->irq);
2662
9de33df4 2663 dev_set_drvdata(&dev->dev, info);
dba9b4f6 2664
7faefea6
YL		 2665 if (add_smi(info)) {
2666 kfree(info);
2667 return -EBUSY;
2668 }
a1e9c9dd 2669#endif
7faefea6 2670 return 0;
dba9b4f6
CM		 2671}
2672
39af33fc 2673static int ipmi_remove(struct platform_device *dev)
dba9b4f6 2674{
a1e9c9dd 2675#ifdef CONFIG_OF
9de33df4 2676 cleanup_one_si(dev_get_drvdata(&dev->dev));
a1e9c9dd 2677#endif
dba9b4f6
CM		 2678 return 0;
2679}
2680
2681static struct of_device_id ipmi_match[] =
2682{
c305e3d3
CM		 2683 { .type = "ipmi", .compatible = "ipmi-kcs",
2684 .data = (void *)(unsigned long) SI_KCS },
2685 { .type = "ipmi", .compatible = "ipmi-smic",
2686 .data = (void *)(unsigned long) SI_SMIC },
2687 { .type = "ipmi", .compatible = "ipmi-bt",
2688 .data = (void *)(unsigned long) SI_BT },
dba9b4f6
CM		 2689 {},
2690};
2691
a1e9c9dd 2692static struct platform_driver ipmi_driver = {
4018294b 2693 .driver = {
a1e9c9dd 2694 .name = DEVICE_NAME,
4018294b
GL		 2695 .owner = THIS_MODULE,
2696 .of_match_table = ipmi_match,
2697 },
a1e9c9dd 2698 .probe = ipmi_probe,
bcd2982a 2699 .remove = ipmi_remove,
dba9b4f6 2700};
dba9b4f6 2701
40112ae7 2702static int wait_for_msg_done(struct smi_info *smi_info)
1da177e4 2703{
50c812b2 2704 enum si_sm_result smi_result;
1da177e4
LT		 2705
2706 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
c305e3d3 2707 for (;;) {
c3e7e791
CM		 2708 if (smi_result == SI_SM_CALL_WITH_DELAY ||
2709 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
da4cd8df 2710 schedule_timeout_uninterruptible(1);
1da177e4
LT		 2711 smi_result = smi_info->handlers->event(
2712 smi_info->si_sm, 100);
c305e3d3 2713 } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
1da177e4
LT		 2714 smi_result = smi_info->handlers->event(
2715 smi_info->si_sm, 0);
c305e3d3 2716 } else
1da177e4
LT		 2717 break;
2718 }
40112ae7 2719 if (smi_result == SI_SM_HOSED)
c305e3d3
CM		 2720 /*
2721 * We couldn't get the state machine to run, so whatever's at
2722 * the port is probably not an IPMI SMI interface.
2723 */
40112ae7
CM		 2724 return -ENODEV;
2725
2726 return 0;
2727}
2728
2729static int try_get_dev_id(struct smi_info *smi_info)
2730{
2731 unsigned char msg[2];
2732 unsigned char *resp;
2733 unsigned long resp_len;
2734 int rv = 0;
2735
2736 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2737 if (!resp)
2738 return -ENOMEM;
2739
2740 /*
2741 * Do a Get Device ID command, since it comes back with some
2742 * useful info.
2743 */
2744 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2745 msg[1] = IPMI_GET_DEVICE_ID_CMD;
2746 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2747
2748 rv = wait_for_msg_done(smi_info);
2749 if (rv)
1da177e4 2750 goto out;
1da177e4 2751
1da177e4
LT		 2752 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2753 resp, IPMI_MAX_MSG_LENGTH);
1da177e4 2754
d8c98618
CM		 2755 /* Check and record info from the get device id, in case we need it. */
2756 rv = ipmi_demangle_device_id(resp, resp_len, &smi_info->device_id);
1da177e4
LT		 2757
2758 out:
2759 kfree(resp);
2760 return rv;
2761}
2762
40112ae7
CM		 2763static int try_enable_event_buffer(struct smi_info *smi_info)
2764{
2765 unsigned char msg[3];
2766 unsigned char *resp;
2767 unsigned long resp_len;
2768 int rv = 0;
2769
2770 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2771 if (!resp)
2772 return -ENOMEM;
2773
2774 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2775 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
2776 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2777
2778 rv = wait_for_msg_done(smi_info);
2779 if (rv) {
279fbd0c
MS		 2780 printk(KERN_WARNING PFX "Error getting response from get"
2781 " global enables command, the event buffer is not"
40112ae7
CM		 2782 " enabled.\n");
2783 goto out;
2784 }
2785
2786 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2787 resp, IPMI_MAX_MSG_LENGTH);
2788
2789 if (resp_len < 4 ||
2790 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
2791 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD ||
2792 resp[2] != 0) {
279fbd0c
MS		 2793 printk(KERN_WARNING PFX "Invalid return from get global"
2794 " enables command, cannot enable the event buffer.\n");
40112ae7
CM		 2795 rv = -EINVAL;
2796 goto out;
2797 }
2798
2799 if (resp[3] & IPMI_BMC_EVT_MSG_BUFF)
2800 /* buffer is already enabled, nothing to do. */
2801 goto out;
2802
2803 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2804 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
2805 msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF;
2806 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
2807
2808 rv = wait_for_msg_done(smi_info);
2809 if (rv) {
279fbd0c
MS		 2810 printk(KERN_WARNING PFX "Error getting response from set"
2811 " global, enables command, the event buffer is not"
40112ae7
CM		 2812 " enabled.\n");
2813 goto out;
2814 }
2815
2816 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2817 resp, IPMI_MAX_MSG_LENGTH);
2818
2819 if (resp_len < 3 ||
2820 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
2821 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
279fbd0c
MS		 2822 printk(KERN_WARNING PFX "Invalid return from get global,"
2823 "enables command, not enable the event buffer.\n");
40112ae7
CM		 2824 rv = -EINVAL;
2825 goto out;
2826 }
2827
2828 if (resp[2] != 0)
2829 /*
2830 * An error when setting the event buffer bit means
2831 * that the event buffer is not supported.
2832 */
2833 rv = -ENOENT;
2834 out:
2835 kfree(resp);
2836 return rv;
2837}
2838
07412736 2839static int smi_type_proc_show(struct seq_file *m, void *v)
1da177e4 2840{
07412736 2841 struct smi_info *smi = m->private;
1da177e4 2842
07412736 2843 return seq_printf(m, "%s\n", si_to_str[smi->si_type]);
1da177e4
LT		 2844}
2845
07412736 2846static int smi_type_proc_open(struct inode *inode, struct file *file)
1da177e4 2847{
d9dda78b 2848 return single_open(file, smi_type_proc_show, PDE_DATA(inode));
07412736
AD		 2849}
2850
2851static const struct file_operations smi_type_proc_ops = {
2852 .open = smi_type_proc_open,
2853 .read = seq_read,
2854 .llseek = seq_lseek,
2855 .release = single_release,
2856};
2857
2858static int smi_si_stats_proc_show(struct seq_file *m, void *v)
2859{
2860 struct smi_info *smi = m->private;
1da177e4 2861
07412736 2862 seq_printf(m, "interrupts_enabled: %d\n",
b0defcdb 2863 smi->irq && !smi->interrupt_disabled);
07412736 2864 seq_printf(m, "short_timeouts: %u\n",
64959e2d 2865 smi_get_stat(smi, short_timeouts));
07412736 2866 seq_printf(m, "long_timeouts: %u\n",
64959e2d 2867 smi_get_stat(smi, long_timeouts));
07412736 2868 seq_printf(m, "idles: %u\n",
64959e2d 2869 smi_get_stat(smi, idles));
07412736 2870 seq_printf(m, "interrupts: %u\n",
64959e2d 2871 smi_get_stat(smi, interrupts));
07412736 2872 seq_printf(m, "attentions: %u\n",
64959e2d 2873 smi_get_stat(smi, attentions));
07412736 2874 seq_printf(m, "flag_fetches: %u\n",
64959e2d 2875 smi_get_stat(smi, flag_fetches));
07412736 2876 seq_printf(m, "hosed_count: %u\n",
64959e2d 2877 smi_get_stat(smi, hosed_count));
07412736 2878 seq_printf(m, "complete_transactions: %u\n",
64959e2d 2879 smi_get_stat(smi, complete_transactions));
07412736 2880 seq_printf(m, "events: %u\n",
64959e2d 2881 smi_get_stat(smi, events));
07412736 2882 seq_printf(m, "watchdog_pretimeouts: %u\n",
64959e2d 2883 smi_get_stat(smi, watchdog_pretimeouts));
07412736 2884 seq_printf(m, "incoming_messages: %u\n",
64959e2d 2885 smi_get_stat(smi, incoming_messages));
07412736
AD		 2886 return 0;
2887}
1da177e4 2888
07412736
AD		 2889static int smi_si_stats_proc_open(struct inode *inode, struct file *file)
2890{
d9dda78b 2891 return single_open(file, smi_si_stats_proc_show, PDE_DATA(inode));
b361e27b
CM		 2892}
2893
07412736
AD		 2894static const struct file_operations smi_si_stats_proc_ops = {
2895 .open = smi_si_stats_proc_open,
2896 .read = seq_read,
2897 .llseek = seq_lseek,
2898 .release = single_release,
2899};
2900
2901static int smi_params_proc_show(struct seq_file *m, void *v)
b361e27b 2902{
07412736 2903 struct smi_info *smi = m->private;
b361e27b 2904
07412736 2905 return seq_printf(m,
b361e27b
CM		 2906 "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
2907 si_to_str[smi->si_type],
2908 addr_space_to_str[smi->io.addr_type],
2909 smi->io.addr_data,
2910 smi->io.regspacing,
2911 smi->io.regsize,
2912 smi->io.regshift,
2913 smi->irq,
2914 smi->slave_addr);
1da177e4
LT		 2915}
2916
07412736
AD		 2917static int smi_params_proc_open(struct inode *inode, struct file *file)
2918{
d9dda78b 2919 return single_open(file, smi_params_proc_show, PDE_DATA(inode));
07412736
AD		 2920}
2921
2922static const struct file_operations smi_params_proc_ops = {
2923 .open = smi_params_proc_open,
2924 .read = seq_read,
2925 .llseek = seq_lseek,
2926 .release = single_release,
2927};
2928
3ae0e0f9
CM		 2929/*
2930 * oem_data_avail_to_receive_msg_avail
2931 * @info - smi_info structure with msg_flags set
2932 *
2933 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2934 * Returns 1 indicating need to re-run handle_flags().
2935 */
2936static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2937{
e8b33617 2938 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
c305e3d3 2939 RECEIVE_MSG_AVAIL);
3ae0e0f9
CM		 2940 return 1;
2941}
2942
2943/*
2944 * setup_dell_poweredge_oem_data_handler
2945 * @info - smi_info.device_id must be populated
2946 *
2947 * Systems that match, but have firmware version < 1.40 may assert
2948 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2949 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2950 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2951 * as RECEIVE_MSG_AVAIL instead.
2952 *
2953 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2954 * assert the OEM[012] bits, and if it did, the driver would have to
2955 * change to handle that properly, we don't actually check for the
2956 * firmware version.
2957 * Device ID = 0x20 BMC on PowerEdge 8G servers
2958 * Device Revision = 0x80
2959 * Firmware Revision1 = 0x01 BMC version 1.40
2960 * Firmware Revision2 = 0x40 BCD encoded
2961 * IPMI Version = 0x51 IPMI 1.5
2962 * Manufacturer ID = A2 02 00 Dell IANA
2963 *
d5a2b89a
CM		 2964 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2965 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2966 *
3ae0e0f9
CM		 2967 */
2968#define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2969#define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2970#define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
50c812b2 2971#define DELL_IANA_MFR_ID 0x0002a2
3ae0e0f9
CM		 2972static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2973{
2974 struct ipmi_device_id *id = &smi_info->device_id;
50c812b2 2975 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
d5a2b89a
CM		 2976 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2977 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
50c812b2 2978 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
d5a2b89a
CM		 2979 smi_info->oem_data_avail_handler =
2980 oem_data_avail_to_receive_msg_avail;
c305e3d3
CM		 2981 } else if (ipmi_version_major(id) < 1 ||
2982 (ipmi_version_major(id) == 1 &&
2983 ipmi_version_minor(id) < 5)) {
d5a2b89a
CM		 2984 smi_info->oem_data_avail_handler =
2985 oem_data_avail_to_receive_msg_avail;
2986 }
3ae0e0f9
CM		 2987 }
2988}
2989
ea94027b
CM		 2990#define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2991static void return_hosed_msg_badsize(struct smi_info *smi_info)
2992{
2993 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2994
25985edc 2995 /* Make it a response */
ea94027b
CM		 2996 msg->rsp[0] = msg->data[0] | 4;
2997 msg->rsp[1] = msg->data[1];
2998 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2999 msg->rsp_size = 3;
3000 smi_info->curr_msg = NULL;
3001 deliver_recv_msg(smi_info, msg);
3002}
3003
3004/*
3005 * dell_poweredge_bt_xaction_handler
3006 * @info - smi_info.device_id must be populated
3007 *
3008 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
3009 * not respond to a Get SDR command if the length of the data
3010 * requested is exactly 0x3A, which leads to command timeouts and no
3011 * data returned. This intercepts such commands, and causes userspace
3012 * callers to try again with a different-sized buffer, which succeeds.
3013 */
3014
3015#define STORAGE_NETFN 0x0A
3016#define STORAGE_CMD_GET_SDR 0x23
3017static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
3018 unsigned long unused,
3019 void *in)
3020{
3021 struct smi_info *smi_info = in;
3022 unsigned char *data = smi_info->curr_msg->data;
3023 unsigned int size = smi_info->curr_msg->data_size;
3024 if (size >= 8 &&
3025 (data[0]>>2) == STORAGE_NETFN &&
3026 data[1] == STORAGE_CMD_GET_SDR &&
3027 data[7] == 0x3A) {
3028 return_hosed_msg_badsize(smi_info);
3029 return NOTIFY_STOP;
3030 }
3031 return NOTIFY_DONE;
3032}
3033
3034static struct notifier_block dell_poweredge_bt_xaction_notifier = {
3035 .notifier_call = dell_poweredge_bt_xaction_handler,
3036};
3037
3038/*
3039 * setup_dell_poweredge_bt_xaction_handler
3040 * @info - smi_info.device_id must be filled in already
3041 *
3042 * Fills in smi_info.device_id.start_transaction_pre_hook
3043 * when we know what function to use there.
3044 */
3045static void
3046setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
3047{
3048 struct ipmi_device_id *id = &smi_info->device_id;
50c812b2 3049 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
ea94027b
CM		 3050 smi_info->si_type == SI_BT)
3051 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
3052}
3053
3ae0e0f9
CM		 3054/*
3055 * setup_oem_data_handler
3056 * @info - smi_info.device_id must be filled in already
3057 *
3058 * Fills in smi_info.device_id.oem_data_available_handler
3059 * when we know what function to use there.
3060 */
3061
3062static void setup_oem_data_handler(struct smi_info *smi_info)
3063{
3064 setup_dell_poweredge_oem_data_handler(smi_info);
3065}
3066
ea94027b
CM		 3067static void setup_xaction_handlers(struct smi_info *smi_info)
3068{
3069 setup_dell_poweredge_bt_xaction_handler(smi_info);
3070}
3071
a9a2c44f
CM		 3072static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
3073{
453823ba 3074 if (smi_info->intf) {
c305e3d3
CM		 3075 /*
3076 * The timer and thread are only running if the
3077 * interface has been started up and registered.
3078 */
453823ba
CM		 3079 if (smi_info->thread != NULL)
3080 kthread_stop(smi_info->thread);
3081 del_timer_sync(&smi_info->si_timer);
3082 }
a9a2c44f
CM		 3083}
3084
0bbed20e 3085static struct ipmi_default_vals
b0defcdb
CM		 3086{
3087 int type;
3088 int port;
7420884c 3089} ipmi_defaults[] =
b0defcdb
CM		 3090{
3091 { .type = SI_KCS, .port = 0xca2 },
3092 { .type = SI_SMIC, .port = 0xca9 },
3093 { .type = SI_BT, .port = 0xe4 },
3094 { .port = 0 }
3095};
3096
2223cbec 3097static void default_find_bmc(void)
b0defcdb
CM		 3098{
3099 struct smi_info *info;
3100 int i;
3101
3102 for (i = 0; ; i++) {
3103 if (!ipmi_defaults[i].port)
3104 break;
68e1ee62 3105#ifdef CONFIG_PPC
4ff31d77
CK		 3106 if (check_legacy_ioport(ipmi_defaults[i].port))
3107 continue;
3108#endif
de5e2ddf 3109 info = smi_info_alloc();
a09f4855
AM		 3110 if (!info)
3111 return;
4ff31d77 3112
5fedc4a2 3113 info->addr_source = SI_DEFAULT;
b0defcdb
CM		 3114
3115 info->si_type = ipmi_defaults[i].type;
3116 info->io_setup = port_setup;
3117 info->io.addr_data = ipmi_defaults[i].port;
3118 info->io.addr_type = IPMI_IO_ADDR_SPACE;
3119
3120 info->io.addr = NULL;
3121 info->io.regspacing = DEFAULT_REGSPACING;
3122 info->io.regsize = DEFAULT_REGSPACING;
3123 info->io.regshift = 0;
3124
2407d77a
MG		 3125 if (add_smi(info) == 0) {
3126 if ((try_smi_init(info)) == 0) {
3127 /* Found one... */
279fbd0c 3128 printk(KERN_INFO PFX "Found default %s"
2407d77a
MG		 3129 " state machine at %s address 0x%lx\n",
3130 si_to_str[info->si_type],
3131 addr_space_to_str[info->io.addr_type],
3132 info->io.addr_data);
3133 } else
3134 cleanup_one_si(info);
7faefea6
YL		 3135 } else {
3136 kfree(info);
b0defcdb
CM		 3137 }
3138 }
3139}
3140
3141static int is_new_interface(struct smi_info *info)
1da177e4 3142{
b0defcdb 3143 struct smi_info *e;
1da177e4 3144
b0defcdb
CM		 3145 list_for_each_entry(e, &smi_infos, link) {
3146 if (e->io.addr_type != info->io.addr_type)
3147 continue;
3148 if (e->io.addr_data == info->io.addr_data)
3149 return 0;
3150 }
1da177e4 3151
b0defcdb
CM		 3152 return 1;
3153}
1da177e4 3154
2407d77a 3155static int add_smi(struct smi_info *new_smi)
b0defcdb 3156{
2407d77a 3157 int rv = 0;
b0defcdb 3158
279fbd0c 3159 printk(KERN_INFO PFX "Adding %s-specified %s state machine",
2407d77a
MG		 3160 ipmi_addr_src_to_str[new_smi->addr_source],
3161 si_to_str[new_smi->si_type]);
d6dfd131 3162 mutex_lock(&smi_infos_lock);
b0defcdb 3163 if (!is_new_interface(new_smi)) {
7bb671e3 3164 printk(KERN_CONT " duplicate interface\n");
b0defcdb
CM		 3165 rv = -EBUSY;
3166 goto out_err;
3167 }
1da177e4 3168
2407d77a
MG		 3169 printk(KERN_CONT "\n");
3170
1da177e4
LT		 3171 /* So we know not to free it unless we have allocated one. */
3172 new_smi->intf = NULL;
3173 new_smi->si_sm = NULL;
3174 new_smi->handlers = NULL;
3175
2407d77a
MG		 3176 list_add_tail(&new_smi->link, &smi_infos);
3177
3178out_err:
3179 mutex_unlock(&smi_infos_lock);
3180 return rv;
3181}
3182
3183static int try_smi_init(struct smi_info *new_smi)
3184{
3185 int rv = 0;
3186 int i;
3187
279fbd0c 3188 printk(KERN_INFO PFX "Trying %s-specified %s state"
2407d77a
MG		 3189 " machine at %s address 0x%lx, slave address 0x%x,"
3190 " irq %d\n",
3191 ipmi_addr_src_to_str[new_smi->addr_source],
3192 si_to_str[new_smi->si_type],
3193 addr_space_to_str[new_smi->io.addr_type],
3194 new_smi->io.addr_data,
3195 new_smi->slave_addr, new_smi->irq);
3196
b0defcdb
CM		 3197 switch (new_smi->si_type) {
3198 case SI_KCS:
1da177e4 3199 new_smi->handlers = &kcs_smi_handlers;
b0defcdb
CM		 3200 break;
3201
3202 case SI_SMIC:
1da177e4 3203 new_smi->handlers = &smic_smi_handlers;
b0defcdb
CM		 3204 break;
3205
3206 case SI_BT:
1da177e4 3207 new_smi->handlers = &bt_smi_handlers;
b0defcdb
CM		 3208 break;
3209
3210 default:
1da177e4
LT		 3211 /* No support for anything else yet. */
3212 rv = -EIO;
3213 goto out_err;
3214 }
3215
3216 /* Allocate the state machine's data and initialize it. */
3217 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
b0defcdb 3218 if (!new_smi->si_sm) {
279fbd0c
MS		 3219 printk(KERN_ERR PFX
3220 "Could not allocate state machine memory\n");
1da177e4
LT		 3221 rv = -ENOMEM;
3222 goto out_err;
3223 }
3224 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
3225 &new_smi->io);
3226
3227 /* Now that we know the I/O size, we can set up the I/O. */
3228 rv = new_smi->io_setup(new_smi);
3229 if (rv) {
279fbd0c 3230 printk(KERN_ERR PFX "Could not set up I/O space\n");
1da177e4
LT		 3231 goto out_err;
3232 }
3233
1da177e4
LT		 3234 /* Do low-level detection first. */
3235 if (new_smi->handlers->detect(new_smi->si_sm)) {
b0defcdb 3236 if (new_smi->addr_source)
279fbd0c 3237 printk(KERN_INFO PFX "Interface detection failed\n");
1da177e4
LT		 3238 rv = -ENODEV;
3239 goto out_err;
3240 }
3241
c305e3d3
CM		 3242 /*
3243 * Attempt a get device id command. If it fails, we probably
3244 * don't have a BMC here.
3245 */
1da177e4 3246 rv = try_get_dev_id(new_smi);
b0defcdb
CM		 3247 if (rv) {
3248 if (new_smi->addr_source)
279fbd0c 3249 printk(KERN_INFO PFX "There appears to be no BMC"
b0defcdb 3250 " at this location\n");
1da177e4 3251 goto out_err;
b0defcdb 3252 }
1da177e4 3253
3ae0e0f9 3254 setup_oem_data_handler(new_smi);
ea94027b 3255 setup_xaction_handlers(new_smi);
3ae0e0f9 3256
1da177e4
LT		 3257 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
3258 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
3259 new_smi->curr_msg = NULL;
3260 atomic_set(&new_smi->req_events, 0);
3261 new_smi->run_to_completion = 0;
64959e2d
CM		 3262 for (i = 0; i < SI_NUM_STATS; i++)
3263 atomic_set(&new_smi->stats[i], 0);
1da177e4 3264
ea4078ca 3265 new_smi->interrupt_disabled = 1;
a9a2c44f 3266 atomic_set(&new_smi->stop_operation, 0);
b0defcdb
CM		 3267 new_smi->intf_num = smi_num;
3268 smi_num++;
1da177e4 3269
40112ae7
CM		 3270 rv = try_enable_event_buffer(new_smi);
3271 if (rv == 0)
3272 new_smi->has_event_buffer = 1;
3273
c305e3d3
CM		 3274 /*
3275 * Start clearing the flags before we enable interrupts or the
3276 * timer to avoid racing with the timer.
3277 */
1da177e4
LT		 3278 start_clear_flags(new_smi);
3279 /* IRQ is defined to be set when non-zero. */
3280 if (new_smi->irq)
3281 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
3282
50c812b2 3283 if (!new_smi->dev) {
c305e3d3
CM		 3284 /*
3285 * If we don't already have a device from something
3286 * else (like PCI), then register a new one.
3287 */
50c812b2
CM		 3288 new_smi->pdev = platform_device_alloc("ipmi_si",
3289 new_smi->intf_num);
8b32b5d0 3290 if (!new_smi->pdev) {
279fbd0c
MS		 3291 printk(KERN_ERR PFX
3292 "Unable to allocate platform device\n");
453823ba 3293 goto out_err;
50c812b2
CM		 3294 }
3295 new_smi->dev = &new_smi->pdev->dev;
fe2d5ffc 3296 new_smi->dev->driver = &ipmi_driver.driver;
50c812b2 3297
b48f5457 3298 rv = platform_device_add(new_smi->pdev);
50c812b2 3299 if (rv) {
279fbd0c
MS		 3300 printk(KERN_ERR PFX
3301 "Unable to register system interface device:"
50c812b2
CM		 3302 " %d\n",
3303 rv);
453823ba 3304 goto out_err;
50c812b2
CM		 3305 }
3306 new_smi->dev_registered = 1;
3307 }
3308
1da177e4
LT		 3309 rv = ipmi_register_smi(&handlers,
3310 new_smi,
50c812b2
CM		 3311 &new_smi->device_id,
3312 new_smi->dev,
759643b8 3313 "bmc",
453823ba 3314 new_smi->slave_addr);
1da177e4 3315 if (rv) {
279fbd0c
MS		 3316 dev_err(new_smi->dev, "Unable to register device: error %d\n",
3317 rv);
1da177e4
LT		 3318 goto out_err_stop_timer;
3319 }
3320
3321 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
07412736 3322 &smi_type_proc_ops,
99b76233 3323 new_smi);
1da177e4 3324 if (rv) {
279fbd0c 3325 dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
1da177e4
LT		 3326 goto out_err_stop_timer;
3327 }
3328
3329 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
07412736 3330 &smi_si_stats_proc_ops,
99b76233 3331 new_smi);
1da177e4 3332 if (rv) {
279fbd0c 3333 dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
1da177e4
LT		 3334 goto out_err_stop_timer;
3335 }
3336
b361e27b 3337 rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
07412736 3338 &smi_params_proc_ops,
99b76233 3339 new_smi);
b361e27b 3340 if (rv) {
279fbd0c 3341 dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
b361e27b
CM		 3342 goto out_err_stop_timer;
3343 }
3344
279fbd0c
MS		 3345 dev_info(new_smi->dev, "IPMI %s interface initialized\n",
3346 si_to_str[new_smi->si_type]);
1da177e4
LT		 3347
3348 return 0;
3349
3350 out_err_stop_timer:
a9a2c44f
CM		 3351 atomic_inc(&new_smi->stop_operation);
3352 wait_for_timer_and_thread(new_smi);
1da177e4
LT		 3353
3354 out_err:
2407d77a
MG		 3355 new_smi->interrupt_disabled = 1;
3356
3357 if (new_smi->intf) {
1da177e4 3358 ipmi_unregister_smi(new_smi->intf);
2407d77a
MG		 3359 new_smi->intf = NULL;
3360 }
1da177e4 3361
2407d77a 3362 if (new_smi->irq_cleanup) {
b0defcdb 3363 new_smi->irq_cleanup(new_smi);
2407d77a
MG		 3364 new_smi->irq_cleanup = NULL;
3365 }
1da177e4 3366
c305e3d3
CM		 3367 /*
3368 * Wait until we know that we are out of any interrupt
3369 * handlers might have been running before we freed the
3370 * interrupt.
3371 */
fbd568a3 3372 synchronize_sched();
1da177e4
LT		 3373
3374 if (new_smi->si_sm) {
3375 if (new_smi->handlers)
3376 new_smi->handlers->cleanup(new_smi->si_sm);
3377 kfree(new_smi->si_sm);
2407d77a 3378 new_smi->si_sm = NULL;
1da177e4 3379 }
2407d77a 3380 if (new_smi->addr_source_cleanup) {
b0defcdb 3381 new_smi->addr_source_cleanup(new_smi);
2407d77a
MG		 3382 new_smi->addr_source_cleanup = NULL;
3383 }
3384 if (new_smi->io_cleanup) {
7767e126 3385 new_smi->io_cleanup(new_smi);
2407d77a
MG		 3386 new_smi->io_cleanup = NULL;
3387 }
1da177e4 3388
2407d77a 3389 if (new_smi->dev_registered) {
50c812b2 3390 platform_device_unregister(new_smi->pdev);
2407d77a
MG		 3391 new_smi->dev_registered = 0;
3392 }
b0defcdb 3393
1da177e4
LT		 3394 return rv;
3395}
3396
2223cbec 3397static int init_ipmi_si(void)
1da177e4 3398{
1da177e4
LT		 3399 int i;
3400 char *str;
50c812b2 3401 int rv;
2407d77a 3402 struct smi_info *e;
06ee4594 3403 enum ipmi_addr_src type = SI_INVALID;
1da177e4
LT		 3404
3405 if (initialized)
3406 return 0;
3407 initialized = 1;
3408
f2afae46
CM		 3409 if (si_tryplatform) {
3410 rv = platform_driver_register(&ipmi_driver);
3411 if (rv) {
3412 printk(KERN_ERR PFX "Unable to register "
3413 "driver: %d\n", rv);
3414 return rv;
3415 }
50c812b2
CM		 3416 }
3417
1da177e4
LT		 3418 /* Parse out the si_type string into its components. */
3419 str = si_type_str;
3420 if (*str != '\0') {
e8b33617 3421 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
1da177e4
LT		 3422 si_type[i] = str;
3423 str = strchr(str, ',');
3424 if (str) {
3425 *str = '\0';
3426 str++;
3427 } else {
3428 break;
3429 }
3430 }
3431 }
3432
1fdd75bd 3433 printk(KERN_INFO "IPMI System Interface driver.\n");
1da177e4 3434
d8cc5267 3435 /* If the user gave us a device, they presumably want us to use it */
a1e9c9dd 3436 if (!hardcode_find_bmc())
d8cc5267 3437 return 0;
d8cc5267 3438
b0defcdb 3439#ifdef CONFIG_PCI
f2afae46
CM		 3440 if (si_trypci) {
3441 rv = pci_register_driver(&ipmi_pci_driver);
3442 if (rv)
3443 printk(KERN_ERR PFX "Unable to register "
3444 "PCI driver: %d\n", rv);
3445 else
3446 pci_registered = 1;
3447 }
b0defcdb
CM		 3448#endif
3449
754d4531 3450#ifdef CONFIG_ACPI
d941aeae
CM		 3451 if (si_tryacpi) {
3452 pnp_register_driver(&ipmi_pnp_driver);
3453 pnp_registered = 1;
3454 }
754d4531
MG		 3455#endif
3456
3457#ifdef CONFIG_DMI
d941aeae
CM		 3458 if (si_trydmi)
3459 dmi_find_bmc();
754d4531
MG		 3460#endif
3461
3462#ifdef CONFIG_ACPI
d941aeae
CM		 3463 if (si_tryacpi)
3464 spmi_find_bmc();
754d4531
MG		 3465#endif
3466
06ee4594
MG		 3467 /* We prefer devices with interrupts, but in the case of a machine
3468 with multiple BMCs we assume that there will be several instances
3469 of a given type so if we succeed in registering a type then also
3470 try to register everything else of the same type */
d8cc5267 3471
2407d77a
MG		 3472 mutex_lock(&smi_infos_lock);
3473 list_for_each_entry(e, &smi_infos, link) {
06ee4594
MG		 3474 /* Try to register a device if it has an IRQ and we either
3475 haven't successfully registered a device yet or this
3476 device has the same type as one we successfully registered */
3477 if (e->irq && (!type || e->addr_source == type)) {
d8cc5267 3478 if (!try_smi_init(e)) {
06ee4594 3479 type = e->addr_source;
d8cc5267
MG		 3480 }
3481 }
3482 }
3483
06ee4594
MG		 3484 /* type will only have been set if we successfully registered an si */
3485 if (type) {
3486 mutex_unlock(&smi_infos_lock);
3487 return 0;
3488 }
3489
d8cc5267
MG		 3490 /* Fall back to the preferred device */
3491
3492 list_for_each_entry(e, &smi_infos, link) {
06ee4594 3493 if (!e->irq && (!type || e->addr_source == type)) {
d8cc5267 3494 if (!try_smi_init(e)) {
06ee4594 3495 type = e->addr_source;
d8cc5267
MG		 3496 }
3497 }
2407d77a
MG		 3498 }
3499 mutex_unlock(&smi_infos_lock);
3500
06ee4594
MG		 3501 if (type)
3502 return 0;
3503
b0defcdb 3504 if (si_trydefaults) {
d6dfd131 3505 mutex_lock(&smi_infos_lock);
b0defcdb
CM		 3506 if (list_empty(&smi_infos)) {
3507 /* No BMC was found, try defaults. */
d6dfd131 3508 mutex_unlock(&smi_infos_lock);
b0defcdb 3509 default_find_bmc();
2407d77a 3510 } else
d6dfd131 3511 mutex_unlock(&smi_infos_lock);
1da177e4
LT		 3512 }
3513
d6dfd131 3514 mutex_lock(&smi_infos_lock);
b361e27b 3515 if (unload_when_empty && list_empty(&smi_infos)) {
d6dfd131 3516 mutex_unlock(&smi_infos_lock);
d2478521 3517 cleanup_ipmi_si();
279fbd0c
MS		 3518 printk(KERN_WARNING PFX
3519 "Unable to find any System Interface(s)\n");
1da177e4 3520 return -ENODEV;
b0defcdb 3521 } else {
d6dfd131 3522 mutex_unlock(&smi_infos_lock);
b0defcdb 3523 return 0;
1da177e4 3524 }
1da177e4
LT		 3525}
3526module_init(init_ipmi_si);
3527
b361e27b 3528static void cleanup_one_si(struct smi_info *to_clean)
1da177e4 3529{
2407d77a 3530 int rv = 0;
1da177e4
LT		 3531 unsigned long flags;
3532
b0defcdb 3533 if (!to_clean)
1da177e4
LT		 3534 return;
3535
b0defcdb
CM		 3536 list_del(&to_clean->link);
3537
ee6cd5f8 3538 /* Tell the driver that we are shutting down. */
a9a2c44f 3539 atomic_inc(&to_clean->stop_operation);
b0defcdb 3540
c305e3d3
CM		 3541 /*
3542 * Make sure the timer and thread are stopped and will not run
3543 * again.
3544 */
a9a2c44f 3545 wait_for_timer_and_thread(to_clean);
1da177e4 3546
c305e3d3
CM		 3547 /*
3548 * Timeouts are stopped, now make sure the interrupts are off
3549 * for the device. A little tricky with locks to make sure
3550 * there are no races.
3551 */
ee6cd5f8
CM		 3552 spin_lock_irqsave(&to_clean->si_lock, flags);
3553 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3554 spin_unlock_irqrestore(&to_clean->si_lock, flags);
3555 poll(to_clean);
3556 schedule_timeout_uninterruptible(1);
3557 spin_lock_irqsave(&to_clean->si_lock, flags);
3558 }
3559 disable_si_irq(to_clean);
3560 spin_unlock_irqrestore(&to_clean->si_lock, flags);
3561 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3562 poll(to_clean);
3563 schedule_timeout_uninterruptible(1);
3564 }
3565
3566 /* Clean up interrupts and make sure that everything is done. */
3567 if (to_clean->irq_cleanup)
3568 to_clean->irq_cleanup(to_clean);
e8b33617 3569 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
1da177e4 3570 poll(to_clean);
da4cd8df 3571 schedule_timeout_uninterruptible(1);
1da177e4
LT		 3572 }
3573
2407d77a
MG		 3574 if (to_clean->intf)
3575 rv = ipmi_unregister_smi(to_clean->intf);
3576
1da177e4 3577 if (rv) {
279fbd0c 3578 printk(KERN_ERR PFX "Unable to unregister device: errno=%d\n",
1da177e4
LT		 3579 rv);
3580 }
3581
2407d77a
MG		 3582 if (to_clean->handlers)
3583 to_clean->handlers->cleanup(to_clean->si_sm);
1da177e4
LT		 3584
3585 kfree(to_clean->si_sm);
3586
b0defcdb
CM		 3587 if (to_clean->addr_source_cleanup)
3588 to_clean->addr_source_cleanup(to_clean);
7767e126
PG		 3589 if (to_clean->io_cleanup)
3590 to_clean->io_cleanup(to_clean);
50c812b2
CM		 3591
3592 if (to_clean->dev_registered)
3593 platform_device_unregister(to_clean->pdev);
3594
3595 kfree(to_clean);
1da177e4
LT		 3596}
3597
0dcf334c 3598static void cleanup_ipmi_si(void)
1da177e4 3599{
b0defcdb 3600 struct smi_info *e, *tmp_e;
1da177e4 3601
b0defcdb 3602 if (!initialized)
1da177e4
LT		 3603 return;
3604
b0defcdb 3605#ifdef CONFIG_PCI
56480287
MG		 3606 if (pci_registered)
3607 pci_unregister_driver(&ipmi_pci_driver);
b0defcdb 3608#endif
27d0567a 3609#ifdef CONFIG_ACPI
561f8182
YL		 3610 if (pnp_registered)
3611 pnp_unregister_driver(&ipmi_pnp_driver);
9e368fa0 3612#endif
b0defcdb 3613
a1e9c9dd 3614 platform_driver_unregister(&ipmi_driver);
dba9b4f6 3615
d6dfd131 3616 mutex_lock(&smi_infos_lock);
b0defcdb
CM		 3617 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
3618 cleanup_one_si(e);
d6dfd131 3619 mutex_unlock(&smi_infos_lock);
1da177e4
LT		 3620}
3621module_exit(cleanup_ipmi_si);
3622
3623MODULE_LICENSE("GPL");
1fdd75bd 3624MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
c305e3d3
CM		 3625MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT"
3626 " system interfaces.");
Linux 6.x block layer and io_uring tree(s)