blob: 4f560d0bb8089fa296dadeaee3a21bfb7a91b052 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
Corey Minyarddba9b4f2007-05-08 00:23:51 -070012 * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/module.h>
43#include <linux/moduleparam.h>
44#include <asm/system.h>
45#include <linux/sched.h>
46#include <linux/timer.h>
47#include <linux/errno.h>
48#include <linux/spinlock.h>
49#include <linux/slab.h>
50#include <linux/delay.h>
51#include <linux/list.h>
52#include <linux/pci.h>
53#include <linux/ioport.h>
Corey Minyardea940272005-11-07 00:59:59 -080054#include <linux/notifier.h>
Corey Minyardb0defcd2006-03-26 01:37:20 -080055#include <linux/mutex.h>
Matt Domsche9a705a2005-11-07 01:00:04 -080056#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#include <asm/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <linux/interrupt.h>
59#include <linux/rcupdate.h>
60#include <linux/ipmi_smi.h>
61#include <asm/io.h>
62#include "ipmi_si_sm.h"
63#include <linux/init.h>
Andrey Paninb224cd32005-09-06 15:18:37 -070064#include <linux/dmi.h>
Corey Minyardb361e272006-12-06 20:41:07 -080065#include <linux/string.h>
66#include <linux/ctype.h>
67
Corey Minyarddba9b4f2007-05-08 00:23:51 -070068#ifdef CONFIG_PPC_OF
69#include <asm/of_device.h>
70#include <asm/of_platform.h>
71#endif
72
Corey Minyardb361e272006-12-06 20:41:07 -080073#define PFX "ipmi_si: "
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75/* Measure times between events in the driver. */
76#undef DEBUG_TIMING
77
78/* Call every 10 ms. */
79#define SI_TIMEOUT_TIME_USEC 10000
80#define SI_USEC_PER_JIFFY (1000000/HZ)
81#define SI_TIMEOUT_JIFFIES (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
82#define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
83 short timeout */
84
Corey Minyardee6cd5f2007-05-08 00:23:54 -070085/* Bit for BMC global enables. */
86#define IPMI_BMC_RCV_MSG_INTR 0x01
87#define IPMI_BMC_EVT_MSG_INTR 0x02
88#define IPMI_BMC_EVT_MSG_BUFF 0x04
89#define IPMI_BMC_SYS_LOG 0x08
90
Linus Torvalds1da177e2005-04-16 15:20:36 -070091enum si_intf_state {
92 SI_NORMAL,
93 SI_GETTING_FLAGS,
94 SI_GETTING_EVENTS,
95 SI_CLEARING_FLAGS,
96 SI_CLEARING_FLAGS_THEN_SET_IRQ,
97 SI_GETTING_MESSAGES,
98 SI_ENABLE_INTERRUPTS1,
Corey Minyardee6cd5f2007-05-08 00:23:54 -070099 SI_ENABLE_INTERRUPTS2,
100 SI_DISABLE_INTERRUPTS1,
101 SI_DISABLE_INTERRUPTS2
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 /* FIXME - add watchdog stuff. */
103};
104
Corey Minyard9dbf68f2005-05-01 08:59:11 -0700105/* Some BT-specific defines we need here. */
106#define IPMI_BT_INTMASK_REG 2
107#define IPMI_BT_INTMASK_CLEAR_IRQ_BIT 2
108#define IPMI_BT_INTMASK_ENABLE_IRQ_BIT 1
109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110enum si_type {
111 SI_KCS, SI_SMIC, SI_BT
112};
Corey Minyardb361e272006-12-06 20:41:07 -0800113static char *si_to_str[] = { "kcs", "smic", "bt" };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Corey Minyard50c812b2006-03-26 01:37:21 -0800115#define DEVICE_NAME "ipmi_si"
Corey Minyard3ae0e0f2005-09-06 15:18:41 -0700116
Corey Minyard50c812b2006-03-26 01:37:21 -0800117static struct device_driver ipmi_driver =
118{
119 .name = DEVICE_NAME,
120 .bus = &platform_bus_type
121};
Corey Minyard3ae0e0f2005-09-06 15:18:41 -0700122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123struct smi_info
124{
Corey Minyarda9a2c442005-11-07 01:00:03 -0800125 int intf_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 ipmi_smi_t intf;
127 struct si_sm_data *si_sm;
128 struct si_sm_handlers *handlers;
129 enum si_type si_type;
130 spinlock_t si_lock;
131 spinlock_t msg_lock;
132 struct list_head xmit_msgs;
133 struct list_head hp_xmit_msgs;
134 struct ipmi_smi_msg *curr_msg;
135 enum si_intf_state si_state;
136
137 /* Used to handle the various types of I/O that can occur with
138 IPMI */
139 struct si_sm_io io;
140 int (*io_setup)(struct smi_info *info);
141 void (*io_cleanup)(struct smi_info *info);
142 int (*irq_setup)(struct smi_info *info);
143 void (*irq_cleanup)(struct smi_info *info);
144 unsigned int io_size;
Corey Minyardb0defcd2006-03-26 01:37:20 -0800145 char *addr_source; /* ACPI, PCI, SMBIOS, hardcode, default. */
146 void (*addr_source_cleanup)(struct smi_info *info);
147 void *addr_source_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Corey Minyard3ae0e0f2005-09-06 15:18:41 -0700149 /* Per-OEM handler, called from handle_flags().
150 Returns 1 when handle_flags() needs to be re-run
151 or 0 indicating it set si_state itself.
152 */
153 int (*oem_data_avail_handler)(struct smi_info *smi_info);
154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
156 is set to hold the flags until we are done handling everything
157 from the flags. */
158#define RECEIVE_MSG_AVAIL 0x01
159#define EVENT_MSG_BUFFER_FULL 0x02
160#define WDT_PRE_TIMEOUT_INT 0x08
Corey Minyard3ae0e0f2005-09-06 15:18:41 -0700161#define OEM0_DATA_AVAIL 0x20
162#define OEM1_DATA_AVAIL 0x40
163#define OEM2_DATA_AVAIL 0x80
164#define OEM_DATA_AVAIL (OEM0_DATA_AVAIL | \
165 OEM1_DATA_AVAIL | \
166 OEM2_DATA_AVAIL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 unsigned char msg_flags;
168
169 /* If set to true, this will request events the next time the
170 state machine is idle. */
171 atomic_t req_events;
172
173 /* If true, run the state machine to completion on every send
174 call. Generally used after a panic to make sure stuff goes
175 out. */
176 int run_to_completion;
177
178 /* The I/O port of an SI interface. */
179 int port;
180
181 /* The space between start addresses of the two ports. For
182 instance, if the first port is 0xca2 and the spacing is 4, then
183 the second port is 0xca6. */
184 unsigned int spacing;
185
186 /* zero if no irq; */
187 int irq;
188
189 /* The timer for this si. */
190 struct timer_list si_timer;
191
192 /* The time (in jiffies) the last timeout occurred at. */
193 unsigned long last_timeout_jiffies;
194
195 /* Used to gracefully stop the timer without race conditions. */
Corey Minyarda9a2c442005-11-07 01:00:03 -0800196 atomic_t stop_operation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198 /* The driver will disable interrupts when it gets into a
199 situation where it cannot handle messages due to lack of
200 memory. Once that situation clears up, it will re-enable
201 interrupts. */
202 int interrupt_disabled;
203
Corey Minyard50c812b2006-03-26 01:37:21 -0800204 /* From the get device id response... */
Corey Minyard3ae0e0f2005-09-06 15:18:41 -0700205 struct ipmi_device_id device_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Corey Minyard50c812b2006-03-26 01:37:21 -0800207 /* Driver model stuff. */
208 struct device *dev;
209 struct platform_device *pdev;
210
211 /* True if we allocated the device, false if it came from
212 * someplace else (like PCI). */
213 int dev_registered;
214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 /* Slave address, could be reported from DMI. */
216 unsigned char slave_addr;
217
218 /* Counters and things for the proc filesystem. */
219 spinlock_t count_lock;
220 unsigned long short_timeouts;
221 unsigned long long_timeouts;
222 unsigned long timeout_restarts;
223 unsigned long idles;
224 unsigned long interrupts;
225 unsigned long attentions;
226 unsigned long flag_fetches;
227 unsigned long hosed_count;
228 unsigned long complete_transactions;
229 unsigned long events;
230 unsigned long watchdog_pretimeouts;
231 unsigned long incoming_messages;
Corey Minyarda9a2c442005-11-07 01:00:03 -0800232
Matt Domsche9a705a2005-11-07 01:00:04 -0800233 struct task_struct *thread;
Corey Minyardb0defcd2006-03-26 01:37:20 -0800234
235 struct list_head link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236};
237
Corey Minyarda51f4a82006-10-03 01:13:59 -0700238#define SI_MAX_PARMS 4
239
240static int force_kipmid[SI_MAX_PARMS];
241static int num_force_kipmid;
242
Corey Minyardb361e272006-12-06 20:41:07 -0800243static int unload_when_empty = 1;
244
Corey Minyardb0defcd2006-03-26 01:37:20 -0800245static int try_smi_init(struct smi_info *smi);
Corey Minyardb361e272006-12-06 20:41:07 -0800246static void cleanup_one_si(struct smi_info *to_clean);
Corey Minyardb0defcd2006-03-26 01:37:20 -0800247
Alan Sterne041c682006-03-27 01:16:30 -0800248static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
Corey Minyardea940272005-11-07 00:59:59 -0800249static int register_xaction_notifier(struct notifier_block * nb)
250{
Alan Sterne041c682006-03-27 01:16:30 -0800251 return atomic_notifier_chain_register(&xaction_notifier_list, nb);
Corey Minyardea940272005-11-07 00:59:59 -0800252}
253
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254static void deliver_recv_msg(struct smi_info *smi_info,
255 struct ipmi_smi_msg *msg)
256{
257 /* Deliver the message to the upper layer with the lock
258 released. */
259 spin_unlock(&(smi_info->si_lock));
260 ipmi_smi_msg_received(smi_info->intf, msg);
261 spin_lock(&(smi_info->si_lock));
262}
263
Corey Minyard4d7cbac2006-12-06 20:41:14 -0800264static void return_hosed_msg(struct smi_info *smi_info, int cCode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265{
266 struct ipmi_smi_msg *msg = smi_info->curr_msg;
267
Corey Minyard4d7cbac2006-12-06 20:41:14 -0800268 if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
269 cCode = IPMI_ERR_UNSPECIFIED;
270 /* else use it as is */
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 /* Make it a reponse */
273 msg->rsp[0] = msg->data[0] | 4;
274 msg->rsp[1] = msg->data[1];
Corey Minyard4d7cbac2006-12-06 20:41:14 -0800275 msg->rsp[2] = cCode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 msg->rsp_size = 3;
277
278 smi_info->curr_msg = NULL;
279 deliver_recv_msg(smi_info, msg);
280}
281
282static enum si_sm_result start_next_msg(struct smi_info *smi_info)
283{
284 int rv;
285 struct list_head *entry = NULL;
286#ifdef DEBUG_TIMING
287 struct timeval t;
288#endif
289
290 /* No need to save flags, we aleady have interrupts off and we
291 already hold the SMI lock. */
292 spin_lock(&(smi_info->msg_lock));
293
294 /* Pick the high priority queue first. */
Corey Minyardb0defcd2006-03-26 01:37:20 -0800295 if (!list_empty(&(smi_info->hp_xmit_msgs))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 entry = smi_info->hp_xmit_msgs.next;
Corey Minyardb0defcd2006-03-26 01:37:20 -0800297 } else if (!list_empty(&(smi_info->xmit_msgs))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 entry = smi_info->xmit_msgs.next;
299 }
300
Corey Minyardb0defcd2006-03-26 01:37:20 -0800301 if (!entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 smi_info->curr_msg = NULL;
303 rv = SI_SM_IDLE;
304 } else {
305 int err;
306
307 list_del(entry);
308 smi_info->curr_msg = list_entry(entry,
309 struct ipmi_smi_msg,
310 link);
311#ifdef DEBUG_TIMING
312 do_gettimeofday(&t);
313 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
314#endif
Alan Sterne041c682006-03-27 01:16:30 -0800315 err = atomic_notifier_call_chain(&xaction_notifier_list,
316 0, smi_info);
Corey Minyardea940272005-11-07 00:59:59 -0800317 if (err & NOTIFY_STOP_MASK) {
318 rv = SI_SM_CALL_WITHOUT_DELAY;
319 goto out;
320 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 err = smi_info->handlers->start_transaction(
322 smi_info->si_sm,
323 smi_info->curr_msg->data,
324 smi_info->curr_msg->data_size);
325 if (err) {
Corey Minyard4d7cbac2006-12-06 20:41:14 -0800326 return_hosed_msg(smi_info, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 }
328
329 rv = SI_SM_CALL_WITHOUT_DELAY;
330 }
Corey Minyardea940272005-11-07 00:59:59 -0800331 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 spin_unlock(&(smi_info->msg_lock));
333
334 return rv;
335}
336
337static void start_enable_irq(struct smi_info *smi_info)
338{
339 unsigned char msg[2];
340
341 /* If we are enabling interrupts, we have to tell the
342 BMC to use them. */
343 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
344 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
345
346 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
347 smi_info->si_state = SI_ENABLE_INTERRUPTS1;
348}
349
Corey Minyardee6cd5f2007-05-08 00:23:54 -0700350static void start_disable_irq(struct smi_info *smi_info)
351{
352 unsigned char msg[2];
353
354 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
355 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
356
357 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
358 smi_info->si_state = SI_DISABLE_INTERRUPTS1;
359}
360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361static void start_clear_flags(struct smi_info *smi_info)
362{
363 unsigned char msg[3];
364
365 /* Make sure the watchdog pre-timeout flag is not set at startup. */
366 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
367 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
368 msg[2] = WDT_PRE_TIMEOUT_INT;
369
370 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
371 smi_info->si_state = SI_CLEARING_FLAGS;
372}
373
374/* When we have a situtaion where we run out of memory and cannot
375 allocate messages, we just leave them in the BMC and run the system
376 polled until we can allocate some memory. Once we have some
377 memory, we will re-enable the interrupt. */
378static inline void disable_si_irq(struct smi_info *smi_info)
379{
Corey Minyardb0defcd2006-03-26 01:37:20 -0800380 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
Corey Minyardee6cd5f2007-05-08 00:23:54 -0700381 start_disable_irq(smi_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 smi_info->interrupt_disabled = 1;
383 }
384}
385
386static inline void enable_si_irq(struct smi_info *smi_info)
387{
388 if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
Corey Minyardee6cd5f2007-05-08 00:23:54 -0700389 start_enable_irq(smi_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 smi_info->interrupt_disabled = 0;
391 }
392}
393
394static void handle_flags(struct smi_info *smi_info)
395{
Corey Minyard3ae0e0f2005-09-06 15:18:41 -0700396 retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
398 /* Watchdog pre-timeout */
399 spin_lock(&smi_info->count_lock);
400 smi_info->watchdog_pretimeouts++;
401 spin_unlock(&smi_info->count_lock);
402
403 start_clear_flags(smi_info);
404 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
405 spin_unlock(&(smi_info->si_lock));
406 ipmi_smi_watchdog_pretimeout(smi_info->intf);
407 spin_lock(&(smi_info->si_lock));
408 } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
409 /* Messages available. */
410 smi_info->curr_msg = ipmi_alloc_smi_msg();
Corey Minyardb0defcd2006-03-26 01:37:20 -0800411 if (!smi_info->curr_msg) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 disable_si_irq(smi_info);
413 smi_info->si_state = SI_NORMAL;
414 return;
415 }
416 enable_si_irq(smi_info);
417
418 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
419 smi_info->curr_msg->data[1] = IPMI_GET_MSG_CMD;
420 smi_info->curr_msg->data_size = 2;
421
422 smi_info->handlers->start_transaction(
423 smi_info->si_sm,
424 smi_info->curr_msg->data,
425 smi_info->curr_msg->data_size);
426 smi_info->si_state = SI_GETTING_MESSAGES;
427 } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
428 /* Events available. */
429 smi_info->curr_msg = ipmi_alloc_smi_msg();
Corey Minyardb0defcd2006-03-26 01:37:20 -0800430 if (!smi_info->curr_msg) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 disable_si_irq(smi_info);
432 smi_info->si_state = SI_NORMAL;
433 return;
434 }
435 enable_si_irq(smi_info);
436
437 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
438 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
439 smi_info->curr_msg->data_size = 2;
440
441 smi_info->handlers->start_transaction(
442 smi_info->si_sm,
443 smi_info->curr_msg->data,
444 smi_info->curr_msg->data_size);
445 smi_info->si_state = SI_GETTING_EVENTS;
Corey Minyard4064d5e2006-09-16 12:15:41 -0700446 } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
447 smi_info->oem_data_avail_handler) {
448 if (smi_info->oem_data_avail_handler(smi_info))
449 goto retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 } else {
451 smi_info->si_state = SI_NORMAL;
452 }
453}
454
455static void handle_transaction_done(struct smi_info *smi_info)
456{
457 struct ipmi_smi_msg *msg;
458#ifdef DEBUG_TIMING
459 struct timeval t;
460
461 do_gettimeofday(&t);
462 printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
463#endif
464 switch (smi_info->si_state) {
465 case SI_NORMAL:
Corey Minyardb0defcd2006-03-26 01:37:20 -0800466 if (!smi_info->curr_msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 break;
468
469 smi_info->curr_msg->rsp_size
470 = smi_info->handlers->get_result(
471 smi_info->si_sm,
472 smi_info->curr_msg->rsp,
473 IPMI_MAX_MSG_LENGTH);
474
475 /* Do this here becase deliver_recv_msg() releases the
476 lock, and a new message can be put in during the
477 time the lock is released. */
478 msg = smi_info->curr_msg;
479 smi_info->curr_msg = NULL;
480 deliver_recv_msg(smi_info, msg);
481 break;
482
483 case SI_GETTING_FLAGS:
484 {
485 unsigned char msg[4];
486 unsigned int len;
487
488 /* We got the flags from the SMI, now handle them. */
489 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
490 if (msg[2] != 0) {
491 /* Error fetching flags, just give up for
492 now. */
493 smi_info->si_state = SI_NORMAL;
494 } else if (len < 4) {
495 /* Hmm, no flags. That's technically illegal, but
496 don't use uninitialized data. */
497 smi_info->si_state = SI_NORMAL;
498 } else {
499 smi_info->msg_flags = msg[3];
500 handle_flags(smi_info);
501 }
502 break;
503 }
504
505 case SI_CLEARING_FLAGS:
506 case SI_CLEARING_FLAGS_THEN_SET_IRQ:
507 {
508 unsigned char msg[3];
509
510 /* We cleared the flags. */
511 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
512 if (msg[2] != 0) {
513 /* Error clearing flags */
514 printk(KERN_WARNING
515 "ipmi_si: Error clearing flags: %2.2x\n",
516 msg[2]);
517 }
518 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
519 start_enable_irq(smi_info);
520 else
521 smi_info->si_state = SI_NORMAL;
522 break;
523 }
524
525 case SI_GETTING_EVENTS:
526 {
527 smi_info->curr_msg->rsp_size
528 = smi_info->handlers->get_result(
529 smi_info->si_sm,
530 smi_info->curr_msg->rsp,
531 IPMI_MAX_MSG_LENGTH);
532
533 /* Do this here becase deliver_recv_msg() releases the
534 lock, and a new message can be put in during the
535 time the lock is released. */
536 msg = smi_info->curr_msg;
537 smi_info->curr_msg = NULL;
538 if (msg->rsp[2] != 0) {
539 /* Error getting event, probably done. */
540 msg->done(msg);
541
542 /* Take off the event flag. */
543 smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
544 handle_flags(smi_info);
545 } else {
546 spin_lock(&smi_info->count_lock);
547 smi_info->events++;
548 spin_unlock(&smi_info->count_lock);
549
550 /* Do this before we deliver the message
551 because delivering the message releases the
552 lock and something else can mess with the
553 state. */
554 handle_flags(smi_info);
555
556 deliver_recv_msg(smi_info, msg);
557 }
558 break;
559 }
560
561 case SI_GETTING_MESSAGES:
562 {
563 smi_info->curr_msg->rsp_size
564 = smi_info->handlers->get_result(
565 smi_info->si_sm,
566 smi_info->curr_msg->rsp,
567 IPMI_MAX_MSG_LENGTH);
568
569 /* Do this here becase deliver_recv_msg() releases the
570 lock, and a new message can be put in during the
571 time the lock is released. */
572 msg = smi_info->curr_msg;
573 smi_info->curr_msg = NULL;
574 if (msg->rsp[2] != 0) {
575 /* Error getting event, probably done. */
576 msg->done(msg);
577
578 /* Take off the msg flag. */
579 smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
580 handle_flags(smi_info);
581 } else {
582 spin_lock(&smi_info->count_lock);
583 smi_info->incoming_messages++;
584 spin_unlock(&smi_info->count_lock);
585
586 /* Do this before we deliver the message
587 because delivering the message releases the
588 lock and something else can mess with the
589 state. */
590 handle_flags(smi_info);
591
592 deliver_recv_msg(smi_info, msg);
593 }
594 break;
595 }
596
597 case SI_ENABLE_INTERRUPTS1:
598 {
599 unsigned char msg[4];
600
601 /* We got the flags from the SMI, now handle them. */
602 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
603 if (msg[2] != 0) {
604 printk(KERN_WARNING
605 "ipmi_si: Could not enable interrupts"
606 ", failed get, using polled mode.\n");
607 smi_info->si_state = SI_NORMAL;
608 } else {
609 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
610 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
Corey Minyardee6cd5f2007-05-08 00:23:54 -0700611 msg[2] = (msg[3] |
612 IPMI_BMC_RCV_MSG_INTR |
613 IPMI_BMC_EVT_MSG_INTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 smi_info->handlers->start_transaction(
615 smi_info->si_sm, msg, 3);
616 smi_info->si_state = SI_ENABLE_INTERRUPTS2;
617 }
618 break;
619 }
620
621 case SI_ENABLE_INTERRUPTS2:
622 {
623 unsigned char msg[4];
624
625 /* We got the flags from the SMI, now handle them. */
626 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
627 if (msg[2] != 0) {
628 printk(KERN_WARNING
629 "ipmi_si: Could not enable interrupts"
630 ", failed set, using polled mode.\n");
631 }
632 smi_info->si_state = SI_NORMAL;
633 break;
634 }
Corey Minyardee6cd5f2007-05-08 00:23:54 -0700635
636 case SI_DISABLE_INTERRUPTS1:
637 {
638 unsigned char msg[4];
639
640 /* We got the flags from the SMI, now handle them. */
641 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
642 if (msg[2] != 0) {
643 printk(KERN_WARNING
644 "ipmi_si: Could not disable interrupts"
645 ", failed get.\n");
646 smi_info->si_state = SI_NORMAL;
647 } else {
648 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
649 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
650 msg[2] = (msg[3] &
651 ~(IPMI_BMC_RCV_MSG_INTR |
652 IPMI_BMC_EVT_MSG_INTR));
653 smi_info->handlers->start_transaction(
654 smi_info->si_sm, msg, 3);
655 smi_info->si_state = SI_DISABLE_INTERRUPTS2;
656 }
657 break;
658 }
659
660 case SI_DISABLE_INTERRUPTS2:
661 {
662 unsigned char msg[4];
663
664 /* We got the flags from the SMI, now handle them. */
665 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
666 if (msg[2] != 0) {
667 printk(KERN_WARNING
668 "ipmi_si: Could not disable interrupts"
669 ", failed set.\n");
670 }
671 smi_info->si_state = SI_NORMAL;
672 break;
673 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 }
675}
676
677/* Called on timeouts and events. Timeouts should pass the elapsed
Corey Minyardfcfa4722007-10-18 03:07:09 -0700678 time, interrupts should pass in zero. Must be called with
679 si_lock held and interrupts disabled. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
681 int time)
682{
683 enum si_sm_result si_sm_result;
684
685 restart:
686 /* There used to be a loop here that waited a little while
687 (around 25us) before giving up. That turned out to be
688 pointless, the minimum delays I was seeing were in the 300us
689 range, which is far too long to wait in an interrupt. So
690 we just run until the state machine tells us something
691 happened or it needs a delay. */
692 si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
693 time = 0;
694 while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
695 {
696 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
697 }
698
699 if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
700 {
701 spin_lock(&smi_info->count_lock);
702 smi_info->complete_transactions++;
703 spin_unlock(&smi_info->count_lock);
704
705 handle_transaction_done(smi_info);
706 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
707 }
708 else if (si_sm_result == SI_SM_HOSED)
709 {
710 spin_lock(&smi_info->count_lock);
711 smi_info->hosed_count++;
712 spin_unlock(&smi_info->count_lock);
713
714 /* Do the before return_hosed_msg, because that
715 releases the lock. */
716 smi_info->si_state = SI_NORMAL;
717 if (smi_info->curr_msg != NULL) {
718 /* If we were handling a user message, format
719 a response to send to the upper layer to
720 tell it about the error. */
Corey Minyard4d7cbac2006-12-06 20:41:14 -0800721 return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 }
723 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
724 }
725
726 /* We prefer handling attn over new messages. */
727 if (si_sm_result == SI_SM_ATTN)
728 {
729 unsigned char msg[2];
730
731 spin_lock(&smi_info->count_lock);
732 smi_info->attentions++;
733 spin_unlock(&smi_info->count_lock);
734
735 /* Got a attn, send down a get message flags to see
736 what's causing it. It would be better to handle
737 this in the upper layer, but due to the way
738 interrupts work with the SMI, that's not really
739 possible. */
740 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
741 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
742
743 smi_info->handlers->start_transaction(
744 smi_info->si_sm, msg, 2);
745 smi_info->si_state = SI_GETTING_FLAGS;
746 goto restart;
747 }
748
749 /* If we are currently idle, try to start the next message. */
750 if (si_sm_result == SI_SM_IDLE) {
751 spin_lock(&smi_info->count_lock);
752 smi_info->idles++;
753 spin_unlock(&smi_info->count_lock);
754
755 si_sm_result = start_next_msg(smi_info);
756 if (si_sm_result != SI_SM_IDLE)
757 goto restart;
758 }
759
760 if ((si_sm_result == SI_SM_IDLE)
761 && (atomic_read(&smi_info->req_events)))
762 {
763 /* We are idle and the upper layer requested that I fetch
764 events, so do so. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 atomic_set(&smi_info->req_events, 0);
Corey Minyard55162fb2006-12-06 20:41:04 -0800766
767 smi_info->curr_msg = ipmi_alloc_smi_msg();
768 if (!smi_info->curr_msg)
769 goto out;
770
771 smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
772 smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
773 smi_info->curr_msg->data_size = 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
775 smi_info->handlers->start_transaction(
Corey Minyard55162fb2006-12-06 20:41:04 -0800776 smi_info->si_sm,
777 smi_info->curr_msg->data,
778 smi_info->curr_msg->data_size);
779 smi_info->si_state = SI_GETTING_EVENTS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 goto restart;
781 }
Corey Minyard55162fb2006-12-06 20:41:04 -0800782 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 return si_sm_result;
784}
785
786static void sender(void *send_info,
787 struct ipmi_smi_msg *msg,
788 int priority)
789{
790 struct smi_info *smi_info = send_info;
791 enum si_sm_result result;
792 unsigned long flags;
793#ifdef DEBUG_TIMING
794 struct timeval t;
795#endif
796
Corey Minyardb361e272006-12-06 20:41:07 -0800797 if (atomic_read(&smi_info->stop_operation)) {
798 msg->rsp[0] = msg->data[0] | 4;
799 msg->rsp[1] = msg->data[1];
800 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
801 msg->rsp_size = 3;
802 deliver_recv_msg(smi_info, msg);
803 return;
804 }
805
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 spin_lock_irqsave(&(smi_info->msg_lock), flags);
807#ifdef DEBUG_TIMING
808 do_gettimeofday(&t);
809 printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
810#endif
811
812 if (smi_info->run_to_completion) {
813 /* If we are running to completion, then throw it in
814 the list and run transactions until everything is
815 clear. Priority doesn't matter here. */
816 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
817
818 /* We have to release the msg lock and claim the smi
819 lock in this case, because of race conditions. */
820 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
821
822 spin_lock_irqsave(&(smi_info->si_lock), flags);
823 result = smi_event_handler(smi_info, 0);
824 while (result != SI_SM_IDLE) {
825 udelay(SI_SHORT_TIMEOUT_USEC);
826 result = smi_event_handler(smi_info,
827 SI_SHORT_TIMEOUT_USEC);
828 }
829 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
830 return;
831 } else {
832 if (priority > 0) {
833 list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
834 } else {
835 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
836 }
837 }
838 spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
839
840 spin_lock_irqsave(&(smi_info->si_lock), flags);
841 if ((smi_info->si_state == SI_NORMAL)
842 && (smi_info->curr_msg == NULL))
843 {
844 start_next_msg(smi_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 }
846 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
847}
848
849static void set_run_to_completion(void *send_info, int i_run_to_completion)
850{
851 struct smi_info *smi_info = send_info;
852 enum si_sm_result result;
853 unsigned long flags;
854
855 spin_lock_irqsave(&(smi_info->si_lock), flags);
856
857 smi_info->run_to_completion = i_run_to_completion;
858 if (i_run_to_completion) {
859 result = smi_event_handler(smi_info, 0);
860 while (result != SI_SM_IDLE) {
861 udelay(SI_SHORT_TIMEOUT_USEC);
862 result = smi_event_handler(smi_info,
863 SI_SHORT_TIMEOUT_USEC);
864 }
865 }
866
867 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
868}
869
Corey Minyarda9a2c442005-11-07 01:00:03 -0800870static int ipmi_thread(void *data)
871{
872 struct smi_info *smi_info = data;
Matt Domsche9a705a2005-11-07 01:00:04 -0800873 unsigned long flags;
Corey Minyarda9a2c442005-11-07 01:00:03 -0800874 enum si_sm_result smi_result;
875
Corey Minyarda9a2c442005-11-07 01:00:03 -0800876 set_user_nice(current, 19);
Matt Domsche9a705a2005-11-07 01:00:04 -0800877 while (!kthread_should_stop()) {
Corey Minyarda9a2c442005-11-07 01:00:03 -0800878 spin_lock_irqsave(&(smi_info->si_lock), flags);
Corey Minyard8a3628d2006-03-31 02:30:40 -0800879 smi_result = smi_event_handler(smi_info, 0);
Corey Minyarda9a2c442005-11-07 01:00:03 -0800880 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
Matt Domsche9a705a2005-11-07 01:00:04 -0800881 if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
882 /* do nothing */
883 }
884 else if (smi_result == SI_SM_CALL_WITH_DELAY)
akpm@osdl.org33979732006-06-27 02:54:04 -0700885 schedule();
Matt Domsche9a705a2005-11-07 01:00:04 -0800886 else
887 schedule_timeout_interruptible(1);
Corey Minyarda9a2c442005-11-07 01:00:03 -0800888 }
Corey Minyarda9a2c442005-11-07 01:00:03 -0800889 return 0;
890}
891
892
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893static void poll(void *send_info)
894{
895 struct smi_info *smi_info = send_info;
Corey Minyardfcfa4722007-10-18 03:07:09 -0700896 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
Corey Minyard15c62e12006-12-06 20:41:06 -0800898 /*
899 * Make sure there is some delay in the poll loop so we can
900 * drive time forward and timeout things.
901 */
902 udelay(10);
Corey Minyardfcfa4722007-10-18 03:07:09 -0700903 spin_lock_irqsave(&smi_info->si_lock, flags);
Corey Minyard15c62e12006-12-06 20:41:06 -0800904 smi_event_handler(smi_info, 10);
Corey Minyardfcfa4722007-10-18 03:07:09 -0700905 spin_unlock_irqrestore(&smi_info->si_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906}
907
908static void request_events(void *send_info)
909{
910 struct smi_info *smi_info = send_info;
911
Corey Minyardb361e272006-12-06 20:41:07 -0800912 if (atomic_read(&smi_info->stop_operation))
913 return;
914
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 atomic_set(&smi_info->req_events, 1);
916}
917
Randy Dunlap0c8204b2006-12-10 02:19:06 -0800918static int initialized;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920static void smi_timeout(unsigned long data)
921{
922 struct smi_info *smi_info = (struct smi_info *) data;
923 enum si_sm_result smi_result;
924 unsigned long flags;
925 unsigned long jiffies_now;
Corey Minyardc4edff12005-11-07 00:59:56 -0800926 long time_diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927#ifdef DEBUG_TIMING
928 struct timeval t;
929#endif
930
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 spin_lock_irqsave(&(smi_info->si_lock), flags);
932#ifdef DEBUG_TIMING
933 do_gettimeofday(&t);
934 printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
935#endif
936 jiffies_now = jiffies;
Corey Minyardc4edff12005-11-07 00:59:56 -0800937 time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 * SI_USEC_PER_JIFFY);
939 smi_result = smi_event_handler(smi_info, time_diff);
940
941 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
942
943 smi_info->last_timeout_jiffies = jiffies_now;
944
Corey Minyardb0defcd2006-03-26 01:37:20 -0800945 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 /* Running with interrupts, only do long timeouts. */
947 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
948 spin_lock_irqsave(&smi_info->count_lock, flags);
949 smi_info->long_timeouts++;
950 spin_unlock_irqrestore(&smi_info->count_lock, flags);
951 goto do_add_timer;
952 }
953
954 /* If the state machine asks for a short delay, then shorten
955 the timer timeout. */
956 if (smi_result == SI_SM_CALL_WITH_DELAY) {
957 spin_lock_irqsave(&smi_info->count_lock, flags);
958 smi_info->short_timeouts++;
959 spin_unlock_irqrestore(&smi_info->count_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 smi_info->si_timer.expires = jiffies + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 } else {
962 spin_lock_irqsave(&smi_info->count_lock, flags);
963 smi_info->long_timeouts++;
964 spin_unlock_irqrestore(&smi_info->count_lock, flags);
965 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 }
967
968 do_add_timer:
969 add_timer(&(smi_info->si_timer));
970}
971
David Howells7d12e782006-10-05 14:55:46 +0100972static irqreturn_t si_irq_handler(int irq, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973{
974 struct smi_info *smi_info = data;
975 unsigned long flags;
976#ifdef DEBUG_TIMING
977 struct timeval t;
978#endif
979
980 spin_lock_irqsave(&(smi_info->si_lock), flags);
981
982 spin_lock(&smi_info->count_lock);
983 smi_info->interrupts++;
984 spin_unlock(&smi_info->count_lock);
985
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986#ifdef DEBUG_TIMING
987 do_gettimeofday(&t);
988 printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
989#endif
990 smi_event_handler(smi_info, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
992 return IRQ_HANDLED;
993}
994
David Howells7d12e782006-10-05 14:55:46 +0100995static irqreturn_t si_bt_irq_handler(int irq, void *data)
Corey Minyard9dbf68f2005-05-01 08:59:11 -0700996{
997 struct smi_info *smi_info = data;
998 /* We need to clear the IRQ flag for the BT interface. */
999 smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
1000 IPMI_BT_INTMASK_CLEAR_IRQ_BIT
1001 | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
David Howells7d12e782006-10-05 14:55:46 +01001002 return si_irq_handler(irq, data);
Corey Minyard9dbf68f2005-05-01 08:59:11 -07001003}
1004
Corey Minyard453823b2006-03-31 02:30:39 -08001005static int smi_start_processing(void *send_info,
1006 ipmi_smi_t intf)
1007{
1008 struct smi_info *new_smi = send_info;
Corey Minyarda51f4a82006-10-03 01:13:59 -07001009 int enable = 0;
Corey Minyard453823b2006-03-31 02:30:39 -08001010
1011 new_smi->intf = intf;
1012
Corey Minyardc45adc32007-10-18 03:07:08 -07001013 /* Try to claim any interrupts. */
1014 if (new_smi->irq_setup)
1015 new_smi->irq_setup(new_smi);
1016
Corey Minyard453823b2006-03-31 02:30:39 -08001017 /* Set up the timer that drives the interface. */
1018 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
1019 new_smi->last_timeout_jiffies = jiffies;
1020 mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
1021
Corey Minyarddf3fe8d2006-09-30 23:28:20 -07001022 /*
Corey Minyarda51f4a82006-10-03 01:13:59 -07001023 * Check if the user forcefully enabled the daemon.
1024 */
1025 if (new_smi->intf_num < num_force_kipmid)
1026 enable = force_kipmid[new_smi->intf_num];
1027 /*
Corey Minyarddf3fe8d2006-09-30 23:28:20 -07001028 * The BT interface is efficient enough to not need a thread,
1029 * and there is no need for a thread if we have interrupts.
1030 */
Corey Minyarda51f4a82006-10-03 01:13:59 -07001031 else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
1032 enable = 1;
1033
1034 if (enable) {
Corey Minyard453823b2006-03-31 02:30:39 -08001035 new_smi->thread = kthread_run(ipmi_thread, new_smi,
1036 "kipmi%d", new_smi->intf_num);
1037 if (IS_ERR(new_smi->thread)) {
1038 printk(KERN_NOTICE "ipmi_si_intf: Could not start"
1039 " kernel thread due to error %ld, only using"
1040 " timers to drive the interface\n",
1041 PTR_ERR(new_smi->thread));
1042 new_smi->thread = NULL;
1043 }
1044 }
1045
1046 return 0;
1047}
Corey Minyard9dbf68f2005-05-01 08:59:11 -07001048
Corey Minyardb9675132006-12-06 20:41:02 -08001049static void set_maintenance_mode(void *send_info, int enable)
1050{
1051 struct smi_info *smi_info = send_info;
1052
1053 if (!enable)
1054 atomic_set(&smi_info->req_events, 0);
1055}
1056
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057static struct ipmi_smi_handlers handlers =
1058{
1059 .owner = THIS_MODULE,
Corey Minyard453823b2006-03-31 02:30:39 -08001060 .start_processing = smi_start_processing,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 .sender = sender,
1062 .request_events = request_events,
Corey Minyardb9675132006-12-06 20:41:02 -08001063 .set_maintenance_mode = set_maintenance_mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 .set_run_to_completion = set_run_to_completion,
1065 .poll = poll,
1066};
1067
1068/* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
1069 a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */
1070
Corey Minyardb0defcd2006-03-26 01:37:20 -08001071static LIST_HEAD(smi_infos);
Corey Minyardd6dfd132006-03-31 02:30:41 -08001072static DEFINE_MUTEX(smi_infos_lock);
Corey Minyardb0defcd2006-03-26 01:37:20 -08001073static int smi_num; /* Used to sequence the SMIs */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075#define DEFAULT_REGSPACING 1
Corey Minyarddba9b4f2007-05-08 00:23:51 -07001076#define DEFAULT_REGSIZE 1
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
1078static int si_trydefaults = 1;
1079static char *si_type[SI_MAX_PARMS];
1080#define MAX_SI_TYPE_STR 30
1081static char si_type_str[MAX_SI_TYPE_STR];
1082static unsigned long addrs[SI_MAX_PARMS];
Al Viro64a6f952007-10-14 19:35:30 +01001083static unsigned int num_addrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084static unsigned int ports[SI_MAX_PARMS];
Al Viro64a6f952007-10-14 19:35:30 +01001085static unsigned int num_ports;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086static int irqs[SI_MAX_PARMS];
Al Viro64a6f952007-10-14 19:35:30 +01001087static unsigned int num_irqs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088static int regspacings[SI_MAX_PARMS];
Al Viro64a6f952007-10-14 19:35:30 +01001089static unsigned int num_regspacings;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090static int regsizes[SI_MAX_PARMS];
Al Viro64a6f952007-10-14 19:35:30 +01001091static unsigned int num_regsizes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092static int regshifts[SI_MAX_PARMS];
Al Viro64a6f952007-10-14 19:35:30 +01001093static unsigned int num_regshifts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094static int slave_addrs[SI_MAX_PARMS];
Al Viro64a6f952007-10-14 19:35:30 +01001095static unsigned int num_slave_addrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
Corey Minyardb361e272006-12-06 20:41:07 -08001097#define IPMI_IO_ADDR_SPACE 0
1098#define IPMI_MEM_ADDR_SPACE 1
Corey Minyard1d5636c2006-12-10 02:19:08 -08001099static char *addr_space_to_str[] = { "i/o", "mem" };
Corey Minyardb361e272006-12-06 20:41:07 -08001100
1101static int hotmod_handler(const char *val, struct kernel_param *kp);
1102
1103module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
1104MODULE_PARM_DESC(hotmod, "Add and remove interfaces. See"
1105 " Documentation/IPMI.txt in the kernel sources for the"
1106 " gory details.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107
1108module_param_named(trydefaults, si_trydefaults, bool, 0);
1109MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
1110 " default scan of the KCS and SMIC interface at the standard"
1111 " address");
1112module_param_string(type, si_type_str, MAX_SI_TYPE_STR, 0);
1113MODULE_PARM_DESC(type, "Defines the type of each interface, each"
1114 " interface separated by commas. The types are 'kcs',"
1115 " 'smic', and 'bt'. For example si_type=kcs,bt will set"
1116 " the first interface to kcs and the second to bt");
Al Viro64a6f952007-10-14 19:35:30 +01001117module_param_array(addrs, ulong, &num_addrs, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118MODULE_PARM_DESC(addrs, "Sets the memory address of each interface, the"
1119 " addresses separated by commas. Only use if an interface"
1120 " is in memory. Otherwise, set it to zero or leave"
1121 " it blank.");
Al Viro64a6f952007-10-14 19:35:30 +01001122module_param_array(ports, uint, &num_ports, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123MODULE_PARM_DESC(ports, "Sets the port address of each interface, the"
1124 " addresses separated by commas. Only use if an interface"
1125 " is a port. Otherwise, set it to zero or leave"
1126 " it blank.");
1127module_param_array(irqs, int, &num_irqs, 0);
1128MODULE_PARM_DESC(irqs, "Sets the interrupt of each interface, the"
1129 " addresses separated by commas. Only use if an interface"
1130 " has an interrupt. Otherwise, set it to zero or leave"
1131 " it blank.");
1132module_param_array(regspacings, int, &num_regspacings, 0);
1133MODULE_PARM_DESC(regspacings, "The number of bytes between the start address"
1134 " and each successive register used by the interface. For"
1135 " instance, if the start address is 0xca2 and the spacing"
1136 " is 2, then the second address is at 0xca4. Defaults"
1137 " to 1.");
1138module_param_array(regsizes, int, &num_regsizes, 0);
1139MODULE_PARM_DESC(regsizes, "The size of the specific IPMI register in bytes."
1140 " This should generally be 1, 2, 4, or 8 for an 8-bit,"
1141 " 16-bit, 32-bit, or 64-bit register. Use this if you"
1142 " the 8-bit IPMI register has to be read from a larger"
1143 " register.");
1144module_param_array(regshifts, int, &num_regshifts, 0);
1145MODULE_PARM_DESC(regshifts, "The amount to shift the data read from the."
1146 " IPMI register, in bits. For instance, if the data"
1147 " is read from a 32-bit word and the IPMI data is in"
1148 " bit 8-15, then the shift would be 8");
1149module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1150MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
1151 " the controller. Normally this is 0x20, but can be"
1152 " overridden by this parm. This is an array indexed"
1153 " by interface number.");
Corey Minyarda51f4a82006-10-03 01:13:59 -07001154module_param_array(force_kipmid, int, &num_force_kipmid, 0);
1155MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
1156 " disabled(0). Normally the IPMI driver auto-detects"
1157 " this, but the value may be overridden by this parm.");
Corey Minyardb361e272006-12-06 20:41:07 -08001158module_param(unload_when_empty, int, 0);
1159MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
1160 " specified or found, default is 1. Setting to 0"
1161 " is useful for hot add of devices using hotmod.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
1163
Corey Minyardb0defcd2006-03-26 01:37:20 -08001164static void std_irq_cleanup(struct smi_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001166 if (info->si_type == SI_BT)
1167 /* Disable the interrupt in the BT interface. */
1168 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG, 0);
1169 free_irq(info->irq, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171
1172static int std_irq_setup(struct smi_info *info)
1173{
1174 int rv;
1175
Corey Minyardb0defcd2006-03-26 01:37:20 -08001176 if (!info->irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 return 0;
1178
Corey Minyard9dbf68f2005-05-01 08:59:11 -07001179 if (info->si_type == SI_BT) {
1180 rv = request_irq(info->irq,
1181 si_bt_irq_handler,
Corey Minyardee6cd5f2007-05-08 00:23:54 -07001182 IRQF_SHARED | IRQF_DISABLED,
Corey Minyard9dbf68f2005-05-01 08:59:11 -07001183 DEVICE_NAME,
1184 info);
Corey Minyardb0defcd2006-03-26 01:37:20 -08001185 if (!rv)
Corey Minyard9dbf68f2005-05-01 08:59:11 -07001186 /* Enable the interrupt in the BT interface. */
1187 info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
1188 IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
1189 } else
1190 rv = request_irq(info->irq,
1191 si_irq_handler,
Corey Minyardee6cd5f2007-05-08 00:23:54 -07001192 IRQF_SHARED | IRQF_DISABLED,
Corey Minyard9dbf68f2005-05-01 08:59:11 -07001193 DEVICE_NAME,
1194 info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 if (rv) {
1196 printk(KERN_WARNING
1197 "ipmi_si: %s unable to claim interrupt %d,"
1198 " running polled\n",
1199 DEVICE_NAME, info->irq);
1200 info->irq = 0;
1201 } else {
Corey Minyardb0defcd2006-03-26 01:37:20 -08001202 info->irq_cleanup = std_irq_cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 printk(" Using irq %d\n", info->irq);
1204 }
1205
1206 return rv;
1207}
1208
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209static unsigned char port_inb(struct si_sm_io *io, unsigned int offset)
1210{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001211 unsigned int addr = io->addr_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
Corey Minyardb0defcd2006-03-26 01:37:20 -08001213 return inb(addr + (offset * io->regspacing));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214}
1215
1216static void port_outb(struct si_sm_io *io, unsigned int offset,
1217 unsigned char b)
1218{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001219 unsigned int addr = io->addr_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
Corey Minyardb0defcd2006-03-26 01:37:20 -08001221 outb(b, addr + (offset * io->regspacing));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222}
1223
1224static unsigned char port_inw(struct si_sm_io *io, unsigned int offset)
1225{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001226 unsigned int addr = io->addr_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227
Corey Minyardb0defcd2006-03-26 01:37:20 -08001228 return (inw(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229}
1230
1231static void port_outw(struct si_sm_io *io, unsigned int offset,
1232 unsigned char b)
1233{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001234 unsigned int addr = io->addr_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235
Corey Minyardb0defcd2006-03-26 01:37:20 -08001236 outw(b << io->regshift, addr + (offset * io->regspacing));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237}
1238
1239static unsigned char port_inl(struct si_sm_io *io, unsigned int offset)
1240{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001241 unsigned int addr = io->addr_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
Corey Minyardb0defcd2006-03-26 01:37:20 -08001243 return (inl(addr + (offset * io->regspacing)) >> io->regshift) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244}
1245
1246static void port_outl(struct si_sm_io *io, unsigned int offset,
1247 unsigned char b)
1248{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001249 unsigned int addr = io->addr_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250
Corey Minyardb0defcd2006-03-26 01:37:20 -08001251 outl(b << io->regshift, addr+(offset * io->regspacing));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252}
1253
1254static void port_cleanup(struct smi_info *info)
1255{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001256 unsigned int addr = info->io.addr_data;
Corey Minyardd61a3ea2006-05-30 21:25:57 -07001257 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258
Corey Minyardb0defcd2006-03-26 01:37:20 -08001259 if (addr) {
Corey Minyardd61a3ea2006-05-30 21:25:57 -07001260 for (idx = 0; idx < info->io_size; idx++) {
1261 release_region(addr + idx * info->io.regspacing,
1262 info->io.regsize);
1263 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265}
1266
1267static int port_setup(struct smi_info *info)
1268{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001269 unsigned int addr = info->io.addr_data;
Corey Minyardd61a3ea2006-05-30 21:25:57 -07001270 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Corey Minyardb0defcd2006-03-26 01:37:20 -08001272 if (!addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 return -ENODEV;
1274
1275 info->io_cleanup = port_cleanup;
1276
1277 /* Figure out the actual inb/inw/inl/etc routine to use based
1278 upon the register size. */
1279 switch (info->io.regsize) {
1280 case 1:
1281 info->io.inputb = port_inb;
1282 info->io.outputb = port_outb;
1283 break;
1284 case 2:
1285 info->io.inputb = port_inw;
1286 info->io.outputb = port_outw;
1287 break;
1288 case 4:
1289 info->io.inputb = port_inl;
1290 info->io.outputb = port_outl;
1291 break;
1292 default:
1293 printk("ipmi_si: Invalid register size: %d\n",
1294 info->io.regsize);
1295 return -EINVAL;
1296 }
1297
Corey Minyardd61a3ea2006-05-30 21:25:57 -07001298 /* Some BIOSes reserve disjoint I/O regions in their ACPI
1299 * tables. This causes problems when trying to register the
1300 * entire I/O region. Therefore we must register each I/O
1301 * port separately.
1302 */
1303 for (idx = 0; idx < info->io_size; idx++) {
1304 if (request_region(addr + idx * info->io.regspacing,
1305 info->io.regsize, DEVICE_NAME) == NULL) {
1306 /* Undo allocations */
1307 while (idx--) {
1308 release_region(addr + idx * info->io.regspacing,
1309 info->io.regsize);
1310 }
1311 return -EIO;
1312 }
1313 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 return 0;
1315}
1316
Alexey Dobriyan546cfdf2006-02-03 03:04:40 -08001317static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318{
1319 return readb((io->addr)+(offset * io->regspacing));
1320}
1321
Alexey Dobriyan546cfdf2006-02-03 03:04:40 -08001322static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 unsigned char b)
1324{
1325 writeb(b, (io->addr)+(offset * io->regspacing));
1326}
1327
Alexey Dobriyan546cfdf2006-02-03 03:04:40 -08001328static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329{
1330 return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
Alexey Dobriyan64d9fe62006-11-08 17:44:56 -08001331 & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332}
1333
Alexey Dobriyan546cfdf2006-02-03 03:04:40 -08001334static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 unsigned char b)
1336{
1337 writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
1338}
1339
Alexey Dobriyan546cfdf2006-02-03 03:04:40 -08001340static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341{
1342 return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
Alexey Dobriyan64d9fe62006-11-08 17:44:56 -08001343 & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344}
1345
Alexey Dobriyan546cfdf2006-02-03 03:04:40 -08001346static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 unsigned char b)
1348{
1349 writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
1350}
1351
1352#ifdef readq
1353static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
1354{
1355 return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
Alexey Dobriyan64d9fe62006-11-08 17:44:56 -08001356 & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357}
1358
1359static void mem_outq(struct si_sm_io *io, unsigned int offset,
1360 unsigned char b)
1361{
1362 writeq(b << io->regshift, (io->addr)+(offset * io->regspacing));
1363}
1364#endif
1365
1366static void mem_cleanup(struct smi_info *info)
1367{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001368 unsigned long addr = info->io.addr_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 int mapsize;
1370
1371 if (info->io.addr) {
1372 iounmap(info->io.addr);
1373
1374 mapsize = ((info->io_size * info->io.regspacing)
1375 - (info->io.regspacing - info->io.regsize));
1376
Corey Minyardb0defcd2006-03-26 01:37:20 -08001377 release_mem_region(addr, mapsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379}
1380
1381static int mem_setup(struct smi_info *info)
1382{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001383 unsigned long addr = info->io.addr_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 int mapsize;
1385
Corey Minyardb0defcd2006-03-26 01:37:20 -08001386 if (!addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 return -ENODEV;
1388
1389 info->io_cleanup = mem_cleanup;
1390
1391 /* Figure out the actual readb/readw/readl/etc routine to use based
1392 upon the register size. */
1393 switch (info->io.regsize) {
1394 case 1:
Alexey Dobriyan546cfdf2006-02-03 03:04:40 -08001395 info->io.inputb = intf_mem_inb;
1396 info->io.outputb = intf_mem_outb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 break;
1398 case 2:
Alexey Dobriyan546cfdf2006-02-03 03:04:40 -08001399 info->io.inputb = intf_mem_inw;
1400 info->io.outputb = intf_mem_outw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 break;
1402 case 4:
Alexey Dobriyan546cfdf2006-02-03 03:04:40 -08001403 info->io.inputb = intf_mem_inl;
1404 info->io.outputb = intf_mem_outl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 break;
1406#ifdef readq
1407 case 8:
1408 info->io.inputb = mem_inq;
1409 info->io.outputb = mem_outq;
1410 break;
1411#endif
1412 default:
1413 printk("ipmi_si: Invalid register size: %d\n",
1414 info->io.regsize);
1415 return -EINVAL;
1416 }
1417
1418 /* Calculate the total amount of memory to claim. This is an
1419 * unusual looking calculation, but it avoids claiming any
1420 * more memory than it has to. It will claim everything
1421 * between the first address to the end of the last full
1422 * register. */
1423 mapsize = ((info->io_size * info->io.regspacing)
1424 - (info->io.regspacing - info->io.regsize));
1425
Corey Minyardb0defcd2006-03-26 01:37:20 -08001426 if (request_mem_region(addr, mapsize, DEVICE_NAME) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 return -EIO;
1428
Corey Minyardb0defcd2006-03-26 01:37:20 -08001429 info->io.addr = ioremap(addr, mapsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 if (info->io.addr == NULL) {
Corey Minyardb0defcd2006-03-26 01:37:20 -08001431 release_mem_region(addr, mapsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 return -EIO;
1433 }
1434 return 0;
1435}
1436
Corey Minyardb361e272006-12-06 20:41:07 -08001437/*
1438 * Parms come in as <op1>[:op2[:op3...]]. ops are:
1439 * add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
1440 * Options are:
1441 * rsp=<regspacing>
1442 * rsi=<regsize>
1443 * rsh=<regshift>
1444 * irq=<irq>
1445 * ipmb=<ipmb addr>
1446 */
1447enum hotmod_op { HM_ADD, HM_REMOVE };
1448struct hotmod_vals {
1449 char *name;
1450 int val;
1451};
1452static struct hotmod_vals hotmod_ops[] = {
1453 { "add", HM_ADD },
1454 { "remove", HM_REMOVE },
1455 { NULL }
1456};
1457static struct hotmod_vals hotmod_si[] = {
1458 { "kcs", SI_KCS },
1459 { "smic", SI_SMIC },
1460 { "bt", SI_BT },
1461 { NULL }
1462};
1463static struct hotmod_vals hotmod_as[] = {
1464 { "mem", IPMI_MEM_ADDR_SPACE },
1465 { "i/o", IPMI_IO_ADDR_SPACE },
1466 { NULL }
1467};
Corey Minyard1d5636c2006-12-10 02:19:08 -08001468
Corey Minyardb361e272006-12-06 20:41:07 -08001469static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
1470{
1471 char *s;
1472 int i;
1473
1474 s = strchr(*curr, ',');
1475 if (!s) {
1476 printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
1477 return -EINVAL;
1478 }
1479 *s = '\0';
1480 s++;
1481 for (i = 0; hotmod_ops[i].name; i++) {
Corey Minyard1d5636c2006-12-10 02:19:08 -08001482 if (strcmp(*curr, v[i].name) == 0) {
Corey Minyardb361e272006-12-06 20:41:07 -08001483 *val = v[i].val;
1484 *curr = s;
1485 return 0;
1486 }
1487 }
1488
1489 printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
1490 return -EINVAL;
1491}
1492
Corey Minyard1d5636c2006-12-10 02:19:08 -08001493static int check_hotmod_int_op(const char *curr, const char *option,
1494 const char *name, int *val)
1495{
1496 char *n;
1497
1498 if (strcmp(curr, name) == 0) {
1499 if (!option) {
1500 printk(KERN_WARNING PFX
1501 "No option given for '%s'\n",
1502 curr);
1503 return -EINVAL;
1504 }
1505 *val = simple_strtoul(option, &n, 0);
1506 if ((*n != '\0') || (*option == '\0')) {
1507 printk(KERN_WARNING PFX
1508 "Bad option given for '%s'\n",
1509 curr);
1510 return -EINVAL;
1511 }
1512 return 1;
1513 }
1514 return 0;
1515}
1516
Corey Minyardb361e272006-12-06 20:41:07 -08001517static int hotmod_handler(const char *val, struct kernel_param *kp)
1518{
1519 char *str = kstrdup(val, GFP_KERNEL);
Corey Minyard1d5636c2006-12-10 02:19:08 -08001520 int rv;
Corey Minyardb361e272006-12-06 20:41:07 -08001521 char *next, *curr, *s, *n, *o;
1522 enum hotmod_op op;
1523 enum si_type si_type;
1524 int addr_space;
1525 unsigned long addr;
1526 int regspacing;
1527 int regsize;
1528 int regshift;
1529 int irq;
1530 int ipmb;
1531 int ival;
Corey Minyard1d5636c2006-12-10 02:19:08 -08001532 int len;
Corey Minyardb361e272006-12-06 20:41:07 -08001533 struct smi_info *info;
1534
1535 if (!str)
1536 return -ENOMEM;
1537
1538 /* Kill any trailing spaces, as we can get a "\n" from echo. */
Corey Minyard1d5636c2006-12-10 02:19:08 -08001539 len = strlen(str);
1540 ival = len - 1;
Corey Minyardb361e272006-12-06 20:41:07 -08001541 while ((ival >= 0) && isspace(str[ival])) {
1542 str[ival] = '\0';
1543 ival--;
1544 }
1545
1546 for (curr = str; curr; curr = next) {
1547 regspacing = 1;
1548 regsize = 1;
1549 regshift = 0;
1550 irq = 0;
1551 ipmb = 0x20;
1552
1553 next = strchr(curr, ':');
1554 if (next) {
1555 *next = '\0';
1556 next++;
1557 }
1558
1559 rv = parse_str(hotmod_ops, &ival, "operation", &curr);
1560 if (rv)
1561 break;
1562 op = ival;
1563
1564 rv = parse_str(hotmod_si, &ival, "interface type", &curr);
1565 if (rv)
1566 break;
1567 si_type = ival;
1568
1569 rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
1570 if (rv)
1571 break;
1572
1573 s = strchr(curr, ',');
1574 if (s) {
1575 *s = '\0';
1576 s++;
1577 }
1578 addr = simple_strtoul(curr, &n, 0);
1579 if ((*n != '\0') || (*curr == '\0')) {
1580 printk(KERN_WARNING PFX "Invalid hotmod address"
1581 " '%s'\n", curr);
1582 break;
1583 }
1584
1585 while (s) {
1586 curr = s;
1587 s = strchr(curr, ',');
1588 if (s) {
1589 *s = '\0';
1590 s++;
1591 }
1592 o = strchr(curr, '=');
1593 if (o) {
1594 *o = '\0';
1595 o++;
1596 }
Corey Minyard1d5636c2006-12-10 02:19:08 -08001597 rv = check_hotmod_int_op(curr, o, "rsp", &regspacing);
1598 if (rv < 0)
Corey Minyardb361e272006-12-06 20:41:07 -08001599 goto out;
Corey Minyard1d5636c2006-12-10 02:19:08 -08001600 else if (rv)
1601 continue;
1602 rv = check_hotmod_int_op(curr, o, "rsi", &regsize);
1603 if (rv < 0)
1604 goto out;
1605 else if (rv)
1606 continue;
1607 rv = check_hotmod_int_op(curr, o, "rsh", &regshift);
1608 if (rv < 0)
1609 goto out;
1610 else if (rv)
1611 continue;
1612 rv = check_hotmod_int_op(curr, o, "irq", &irq);
1613 if (rv < 0)
1614 goto out;
1615 else if (rv)
1616 continue;
1617 rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
1618 if (rv < 0)
1619 goto out;
1620 else if (rv)
1621 continue;
1622
1623 rv = -EINVAL;
1624 printk(KERN_WARNING PFX
1625 "Invalid hotmod option '%s'\n",
1626 curr);
1627 goto out;
Corey Minyardb361e272006-12-06 20:41:07 -08001628 }
1629
1630 if (op == HM_ADD) {
1631 info = kzalloc(sizeof(*info), GFP_KERNEL);
1632 if (!info) {
1633 rv = -ENOMEM;
1634 goto out;
1635 }
1636
1637 info->addr_source = "hotmod";
1638 info->si_type = si_type;
1639 info->io.addr_data = addr;
1640 info->io.addr_type = addr_space;
1641 if (addr_space == IPMI_MEM_ADDR_SPACE)
1642 info->io_setup = mem_setup;
1643 else
1644 info->io_setup = port_setup;
1645
1646 info->io.addr = NULL;
1647 info->io.regspacing = regspacing;
1648 if (!info->io.regspacing)
1649 info->io.regspacing = DEFAULT_REGSPACING;
1650 info->io.regsize = regsize;
1651 if (!info->io.regsize)
1652 info->io.regsize = DEFAULT_REGSPACING;
1653 info->io.regshift = regshift;
1654 info->irq = irq;
1655 if (info->irq)
1656 info->irq_setup = std_irq_setup;
1657 info->slave_addr = ipmb;
1658
1659 try_smi_init(info);
1660 } else {
1661 /* remove */
1662 struct smi_info *e, *tmp_e;
1663
1664 mutex_lock(&smi_infos_lock);
1665 list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
1666 if (e->io.addr_type != addr_space)
1667 continue;
1668 if (e->si_type != si_type)
1669 continue;
1670 if (e->io.addr_data == addr)
1671 cleanup_one_si(e);
1672 }
1673 mutex_unlock(&smi_infos_lock);
1674 }
1675 }
Corey Minyard1d5636c2006-12-10 02:19:08 -08001676 rv = len;
Corey Minyardb361e272006-12-06 20:41:07 -08001677 out:
1678 kfree(str);
1679 return rv;
1680}
Corey Minyardb0defcd2006-03-26 01:37:20 -08001681
1682static __devinit void hardcode_find_bmc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683{
Corey Minyardb0defcd2006-03-26 01:37:20 -08001684 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 struct smi_info *info;
1686
Corey Minyardb0defcd2006-03-26 01:37:20 -08001687 for (i = 0; i < SI_MAX_PARMS; i++) {
1688 if (!ports[i] && !addrs[i])
1689 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690
Corey Minyardb0defcd2006-03-26 01:37:20 -08001691 info = kzalloc(sizeof(*info), GFP_KERNEL);
1692 if (!info)
1693 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694
Corey Minyardb0defcd2006-03-26 01:37:20 -08001695 info->addr_source = "hardcoded";
1696
Corey Minyard1d5636c2006-12-10 02:19:08 -08001697 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
Corey Minyardb0defcd2006-03-26 01:37:20 -08001698 info->si_type = SI_KCS;
Corey Minyard1d5636c2006-12-10 02:19:08 -08001699 } else if (strcmp(si_type[i], "smic") == 0) {
Corey Minyardb0defcd2006-03-26 01:37:20 -08001700 info->si_type = SI_SMIC;
Corey Minyard1d5636c2006-12-10 02:19:08 -08001701 } else if (strcmp(si_type[i], "bt") == 0) {
Corey Minyardb0defcd2006-03-26 01:37:20 -08001702 info->si_type = SI_BT;
1703 } else {
1704 printk(KERN_WARNING
1705 "ipmi_si: Interface type specified "
1706 "for interface %d, was invalid: %s\n",
1707 i, si_type[i]);
1708 kfree(info);
1709 continue;
1710 }
1711
1712 if (ports[i]) {
1713 /* An I/O port */
1714 info->io_setup = port_setup;
1715 info->io.addr_data = ports[i];
1716 info->io.addr_type = IPMI_IO_ADDR_SPACE;
1717 } else if (addrs[i]) {
1718 /* A memory port */
1719 info->io_setup = mem_setup;
1720 info->io.addr_data = addrs[i];
1721 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
1722 } else {
1723 printk(KERN_WARNING
1724 "ipmi_si: Interface type specified "
1725 "for interface %d, "
1726 "but port and address were not set or "
1727 "set to zero.\n", i);
1728 kfree(info);
1729 continue;
1730 }
1731
1732 info->io.addr = NULL;
1733 info->io.regspacing = regspacings[i];
1734 if (!info->io.regspacing)
1735 info->io.regspacing = DEFAULT_REGSPACING;
1736 info->io.regsize = regsizes[i];
1737 if (!info->io.regsize)
1738 info->io.regsize = DEFAULT_REGSPACING;
1739 info->io.regshift = regshifts[i];
1740 info->irq = irqs[i];
1741 if (info->irq)
1742 info->irq_setup = std_irq_setup;
1743
1744 try_smi_init(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746}
1747
Len Brown84663612005-08-24 12:09:07 -04001748#ifdef CONFIG_ACPI
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749
1750#include <linux/acpi.h>
1751
1752/* Once we get an ACPI failure, we don't try any more, because we go
1753 through the tables sequentially. Once we don't find a table, there
1754 are no more. */
Randy Dunlap0c8204b2006-12-10 02:19:06 -08001755static int acpi_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756
1757/* For GPE-type interrupts. */
1758static u32 ipmi_acpi_gpe(void *context)
1759{
1760 struct smi_info *smi_info = context;
1761 unsigned long flags;
1762#ifdef DEBUG_TIMING
1763 struct timeval t;
1764#endif
1765
1766 spin_lock_irqsave(&(smi_info->si_lock), flags);
1767
1768 spin_lock(&smi_info->count_lock);
1769 smi_info->interrupts++;
1770 spin_unlock(&smi_info->count_lock);
1771
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772#ifdef DEBUG_TIMING
1773 do_gettimeofday(&t);
1774 printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
1775#endif
1776 smi_event_handler(smi_info, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
1778
1779 return ACPI_INTERRUPT_HANDLED;
1780}
1781
Corey Minyardb0defcd2006-03-26 01:37:20 -08001782static void acpi_gpe_irq_cleanup(struct smi_info *info)
1783{
1784 if (!info->irq)
1785 return;
1786
1787 acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
1788}
1789
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790static int acpi_gpe_irq_setup(struct smi_info *info)
1791{
1792 acpi_status status;
1793
Corey Minyardb0defcd2006-03-26 01:37:20 -08001794 if (!info->irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 return 0;
1796
1797 /* FIXME - is level triggered right? */
1798 status = acpi_install_gpe_handler(NULL,
1799 info->irq,
1800 ACPI_GPE_LEVEL_TRIGGERED,
1801 &ipmi_acpi_gpe,
1802 info);
1803 if (status != AE_OK) {
1804 printk(KERN_WARNING
1805 "ipmi_si: %s unable to claim ACPI GPE %d,"
1806 " running polled\n",
1807 DEVICE_NAME, info->irq);
1808 info->irq = 0;
1809 return -EINVAL;
1810 } else {
Corey Minyardb0defcd2006-03-26 01:37:20 -08001811 info->irq_cleanup = acpi_gpe_irq_cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 printk(" Using ACPI GPE %d\n", info->irq);
1813 return 0;
1814 }
1815}
1816
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817/*
1818 * Defined at
1819 * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
1820 */
1821struct SPMITable {
1822 s8 Signature[4];
1823 u32 Length;
1824 u8 Revision;
1825 u8 Checksum;
1826 s8 OEMID[6];
1827 s8 OEMTableID[8];
1828 s8 OEMRevision[4];
1829 s8 CreatorID[4];
1830 s8 CreatorRevision[4];
1831 u8 InterfaceType;
1832 u8 IPMIlegacy;
1833 s16 SpecificationRevision;
1834
1835 /*
1836 * Bit 0 - SCI interrupt supported
1837 * Bit 1 - I/O APIC/SAPIC
1838 */
1839 u8 InterruptType;
1840
1841 /* If bit 0 of InterruptType is set, then this is the SCI
1842 interrupt in the GPEx_STS register. */
1843 u8 GPE;
1844
1845 s16 Reserved;
1846
1847 /* If bit 1 of InterruptType is set, then this is the I/O
1848 APIC/SAPIC interrupt. */
1849 u32 GlobalSystemInterrupt;
1850
1851 /* The actual register address. */
1852 struct acpi_generic_address addr;
1853
1854 u8 UID[4];
1855
1856 s8 spmi_id[1]; /* A '\0' terminated array starts here. */
1857};
1858
Corey Minyardb0defcd2006-03-26 01:37:20 -08001859static __devinit int try_init_acpi(struct SPMITable *spmi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860{
1861 struct smi_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 u8 addr_space;
1863
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 if (spmi->IPMIlegacy != 1) {
1865 printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
1866 return -ENODEV;
1867 }
1868
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +03001869 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 addr_space = IPMI_MEM_ADDR_SPACE;
1871 else
1872 addr_space = IPMI_IO_ADDR_SPACE;
Corey Minyardb0defcd2006-03-26 01:37:20 -08001873
1874 info = kzalloc(sizeof(*info), GFP_KERNEL);
1875 if (!info) {
1876 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
1877 return -ENOMEM;
1878 }
1879
1880 info->addr_source = "ACPI";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 /* Figure out the interface type. */
1883 switch (spmi->InterfaceType)
1884 {
1885 case 1: /* KCS */
Corey Minyardb0defcd2006-03-26 01:37:20 -08001886 info->si_type = SI_KCS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 case 2: /* SMIC */
Corey Minyardb0defcd2006-03-26 01:37:20 -08001889 info->si_type = SI_SMIC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 case 3: /* BT */
Corey Minyardb0defcd2006-03-26 01:37:20 -08001892 info->si_type = SI_BT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 default:
1895 printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
1896 spmi->InterfaceType);
Corey Minyardb0defcd2006-03-26 01:37:20 -08001897 kfree(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 return -EIO;
1899 }
1900
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 if (spmi->InterruptType & 1) {
1902 /* We've got a GPE interrupt. */
1903 info->irq = spmi->GPE;
1904 info->irq_setup = acpi_gpe_irq_setup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 } else if (spmi->InterruptType & 2) {
1906 /* We've got an APIC/SAPIC interrupt. */
1907 info->irq = spmi->GlobalSystemInterrupt;
1908 info->irq_setup = std_irq_setup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 } else {
1910 /* Use the default interrupt setting. */
1911 info->irq = 0;
1912 info->irq_setup = NULL;
1913 }
1914
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +03001915 if (spmi->addr.bit_width) {
Corey Minyard35bc37a2005-05-01 08:59:10 -07001916 /* A (hopefully) properly formed register bit width. */
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +03001917 info->io.regspacing = spmi->addr.bit_width / 8;
Corey Minyard35bc37a2005-05-01 08:59:10 -07001918 } else {
Corey Minyard35bc37a2005-05-01 08:59:10 -07001919 info->io.regspacing = DEFAULT_REGSPACING;
1920 }
Corey Minyardb0defcd2006-03-26 01:37:20 -08001921 info->io.regsize = info->io.regspacing;
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +03001922 info->io.regshift = spmi->addr.bit_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +03001924 if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 info->io_setup = mem_setup;
Corey Minyard8fe14252007-05-12 10:36:58 -07001926 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +03001927 } else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 info->io_setup = port_setup;
Corey Minyard8fe14252007-05-12 10:36:58 -07001929 info->io.addr_type = IPMI_IO_ADDR_SPACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 } else {
1931 kfree(info);
1932 printk("ipmi_si: Unknown ACPI I/O Address type\n");
1933 return -EIO;
1934 }
Corey Minyardb0defcd2006-03-26 01:37:20 -08001935 info->io.addr_data = spmi->addr.address;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936
Corey Minyardb0defcd2006-03-26 01:37:20 -08001937 try_smi_init(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 return 0;
1940}
Corey Minyardb0defcd2006-03-26 01:37:20 -08001941
1942static __devinit void acpi_find_bmc(void)
1943{
1944 acpi_status status;
1945 struct SPMITable *spmi;
1946 int i;
1947
1948 if (acpi_disabled)
1949 return;
1950
1951 if (acpi_failure)
1952 return;
1953
1954 for (i = 0; ; i++) {
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +03001955 status = acpi_get_table(ACPI_SIG_SPMI, i+1,
1956 (struct acpi_table_header **)&spmi);
Corey Minyardb0defcd2006-03-26 01:37:20 -08001957 if (status != AE_OK)
1958 return;
1959
1960 try_init_acpi(spmi);
1961 }
1962}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963#endif
1964
Matt Domscha9fad4c2006-01-11 12:17:44 -08001965#ifdef CONFIG_DMI
Corey Minyardb0defcd2006-03-26 01:37:20 -08001966struct dmi_ipmi_data
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967{
1968 u8 type;
1969 u8 addr_space;
1970 unsigned long base_addr;
1971 u8 irq;
1972 u8 offset;
1973 u8 slave_addr;
Corey Minyardb0defcd2006-03-26 01:37:20 -08001974};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975
Jeff Garzik18552562007-10-03 15:15:40 -04001976static int __devinit decode_dmi(const struct dmi_header *dm,
Corey Minyardb0defcd2006-03-26 01:37:20 -08001977 struct dmi_ipmi_data *dmi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978{
Jeff Garzik18552562007-10-03 15:15:40 -04001979 const u8 *data = (const u8 *)dm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980 unsigned long base_addr;
1981 u8 reg_spacing;
Andrey Paninb224cd32005-09-06 15:18:37 -07001982 u8 len = dm->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983
Corey Minyardb0defcd2006-03-26 01:37:20 -08001984 dmi->type = data[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985
1986 memcpy(&base_addr, data+8, sizeof(unsigned long));
1987 if (len >= 0x11) {
1988 if (base_addr & 1) {
1989 /* I/O */
1990 base_addr &= 0xFFFE;
Corey Minyardb0defcd2006-03-26 01:37:20 -08001991 dmi->addr_space = IPMI_IO_ADDR_SPACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 }
1993 else {
1994 /* Memory */
Corey Minyardb0defcd2006-03-26 01:37:20 -08001995 dmi->addr_space = IPMI_MEM_ADDR_SPACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 }
1997 /* If bit 4 of byte 0x10 is set, then the lsb for the address
1998 is odd. */
Corey Minyardb0defcd2006-03-26 01:37:20 -08001999 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000
Corey Minyardb0defcd2006-03-26 01:37:20 -08002001 dmi->irq = data[0x11];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
2003 /* The top two bits of byte 0x10 hold the register spacing. */
Andrey Paninb224cd32005-09-06 15:18:37 -07002004 reg_spacing = (data[0x10] & 0xC0) >> 6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 switch(reg_spacing){
2006 case 0x00: /* Byte boundaries */
Corey Minyardb0defcd2006-03-26 01:37:20 -08002007 dmi->offset = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 break;
2009 case 0x01: /* 32-bit boundaries */
Corey Minyardb0defcd2006-03-26 01:37:20 -08002010 dmi->offset = 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 break;
2012 case 0x02: /* 16-byte boundaries */
Corey Minyardb0defcd2006-03-26 01:37:20 -08002013 dmi->offset = 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 break;
2015 default:
2016 /* Some other interface, just ignore it. */
2017 return -EIO;
2018 }
2019 } else {
2020 /* Old DMI spec. */
Corey Minyard92068802005-05-01 08:59:10 -07002021 /* Note that technically, the lower bit of the base
2022 * address should be 1 if the address is I/O and 0 if
2023 * the address is in memory. So many systems get that
2024 * wrong (and all that I have seen are I/O) so we just
2025 * ignore that bit and assume I/O. Systems that use
2026 * memory should use the newer spec, anyway. */
Corey Minyardb0defcd2006-03-26 01:37:20 -08002027 dmi->base_addr = base_addr & 0xfffe;
2028 dmi->addr_space = IPMI_IO_ADDR_SPACE;
2029 dmi->offset = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 }
2031
Corey Minyardb0defcd2006-03-26 01:37:20 -08002032 dmi->slave_addr = data[6];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033
Corey Minyardb0defcd2006-03-26 01:37:20 -08002034 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035}
2036
Corey Minyardb0defcd2006-03-26 01:37:20 -08002037static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038{
Corey Minyarde8b33612005-09-06 15:18:45 -07002039 struct smi_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040
Corey Minyardb0defcd2006-03-26 01:37:20 -08002041 info = kzalloc(sizeof(*info), GFP_KERNEL);
2042 if (!info) {
2043 printk(KERN_ERR
2044 "ipmi_si: Could not allocate SI data\n");
2045 return;
2046 }
2047
2048 info->addr_source = "SMBIOS";
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049
Corey Minyarde8b33612005-09-06 15:18:45 -07002050 switch (ipmi_data->type) {
Corey Minyardb0defcd2006-03-26 01:37:20 -08002051 case 0x01: /* KCS */
2052 info->si_type = SI_KCS;
2053 break;
2054 case 0x02: /* SMIC */
2055 info->si_type = SI_SMIC;
2056 break;
2057 case 0x03: /* BT */
2058 info->si_type = SI_BT;
2059 break;
2060 default:
Jesper Juhl80cd6922007-07-31 00:39:05 -07002061 kfree(info);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002062 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 }
2064
Corey Minyardb0defcd2006-03-26 01:37:20 -08002065 switch (ipmi_data->addr_space) {
2066 case IPMI_MEM_ADDR_SPACE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 info->io_setup = mem_setup;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002068 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2069 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070
Corey Minyardb0defcd2006-03-26 01:37:20 -08002071 case IPMI_IO_ADDR_SPACE:
2072 info->io_setup = port_setup;
2073 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2074 break;
2075
2076 default:
2077 kfree(info);
2078 printk(KERN_WARNING
2079 "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
2080 ipmi_data->addr_space);
2081 return;
2082 }
2083 info->io.addr_data = ipmi_data->base_addr;
2084
2085 info->io.regspacing = ipmi_data->offset;
2086 if (!info->io.regspacing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 info->io.regspacing = DEFAULT_REGSPACING;
2088 info->io.regsize = DEFAULT_REGSPACING;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002089 info->io.regshift = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
2091 info->slave_addr = ipmi_data->slave_addr;
2092
Corey Minyardb0defcd2006-03-26 01:37:20 -08002093 info->irq = ipmi_data->irq;
2094 if (info->irq)
2095 info->irq_setup = std_irq_setup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096
Corey Minyardb0defcd2006-03-26 01:37:20 -08002097 try_smi_init(info);
2098}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099
Corey Minyardb0defcd2006-03-26 01:37:20 -08002100static void __devinit dmi_find_bmc(void)
2101{
Jeff Garzik18552562007-10-03 15:15:40 -04002102 const struct dmi_device *dev = NULL;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002103 struct dmi_ipmi_data data;
2104 int rv;
2105
2106 while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
Jeff Garzik397f4eb2006-10-03 01:13:52 -07002107 memset(&data, 0, sizeof(data));
Jeff Garzik18552562007-10-03 15:15:40 -04002108 rv = decode_dmi((const struct dmi_header *) dev->device_data,
2109 &data);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002110 if (!rv)
2111 try_init_dmi(&data);
2112 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113}
Matt Domscha9fad4c2006-01-11 12:17:44 -08002114#endif /* CONFIG_DMI */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115
2116#ifdef CONFIG_PCI
2117
Corey Minyardb0defcd2006-03-26 01:37:20 -08002118#define PCI_ERMC_CLASSCODE 0x0C0700
2119#define PCI_ERMC_CLASSCODE_MASK 0xffffff00
2120#define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
2121#define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
2122#define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
2123#define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
2124
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125#define PCI_HP_VENDOR_ID 0x103C
2126#define PCI_MMC_DEVICE_ID 0x121A
2127#define PCI_MMC_ADDR_CW 0x10
2128
Corey Minyardb0defcd2006-03-26 01:37:20 -08002129static void ipmi_pci_cleanup(struct smi_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130{
Corey Minyardb0defcd2006-03-26 01:37:20 -08002131 struct pci_dev *pdev = info->addr_source_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132
Corey Minyardb0defcd2006-03-26 01:37:20 -08002133 pci_disable_device(pdev);
2134}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135
Corey Minyardb0defcd2006-03-26 01:37:20 -08002136static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
2137 const struct pci_device_id *ent)
2138{
2139 int rv;
2140 int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
2141 struct smi_info *info;
2142 int first_reg_offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143
Corey Minyardb0defcd2006-03-26 01:37:20 -08002144 info = kzalloc(sizeof(*info), GFP_KERNEL);
2145 if (!info)
Dave Jones1cd441f2006-10-19 23:29:09 -07002146 return -ENOMEM;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002147
2148 info->addr_source = "PCI";
2149
2150 switch (class_type) {
2151 case PCI_ERMC_CLASSCODE_TYPE_SMIC:
2152 info->si_type = SI_SMIC;
2153 break;
2154
2155 case PCI_ERMC_CLASSCODE_TYPE_KCS:
2156 info->si_type = SI_KCS;
2157 break;
2158
2159 case PCI_ERMC_CLASSCODE_TYPE_BT:
2160 info->si_type = SI_BT;
2161 break;
2162
2163 default:
2164 kfree(info);
2165 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
2166 pci_name(pdev), class_type);
Dave Jones1cd441f2006-10-19 23:29:09 -07002167 return -ENOMEM;
Corey Minyarde8b33612005-09-06 15:18:45 -07002168 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169
Corey Minyardb0defcd2006-03-26 01:37:20 -08002170 rv = pci_enable_device(pdev);
2171 if (rv) {
2172 printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
2173 pci_name(pdev));
2174 kfree(info);
2175 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 }
2177
Corey Minyardb0defcd2006-03-26 01:37:20 -08002178 info->addr_source_cleanup = ipmi_pci_cleanup;
2179 info->addr_source_data = pdev;
2180
2181 if (pdev->subsystem_vendor == PCI_HP_VENDOR_ID)
2182 first_reg_offset = 1;
2183
2184 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2185 info->io_setup = port_setup;
2186 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2187 } else {
2188 info->io_setup = mem_setup;
2189 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 }
Corey Minyardb0defcd2006-03-26 01:37:20 -08002191 info->io.addr_data = pci_resource_start(pdev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192
Corey Minyardb0defcd2006-03-26 01:37:20 -08002193 info->io.regspacing = DEFAULT_REGSPACING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 info->io.regsize = DEFAULT_REGSPACING;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002195 info->io.regshift = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196
Corey Minyardb0defcd2006-03-26 01:37:20 -08002197 info->irq = pdev->irq;
2198 if (info->irq)
2199 info->irq_setup = std_irq_setup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200
Corey Minyard50c812b2006-03-26 01:37:21 -08002201 info->dev = &pdev->dev;
Corey Minyardfca3b742007-05-08 00:23:59 -07002202 pci_set_drvdata(pdev, info);
Corey Minyard50c812b2006-03-26 01:37:21 -08002203
Corey Minyardb0defcd2006-03-26 01:37:20 -08002204 return try_smi_init(info);
2205}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206
Corey Minyardb0defcd2006-03-26 01:37:20 -08002207static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
2208{
Corey Minyardfca3b742007-05-08 00:23:59 -07002209 struct smi_info *info = pci_get_drvdata(pdev);
2210 cleanup_one_si(info);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002211}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212
Corey Minyardb0defcd2006-03-26 01:37:20 -08002213#ifdef CONFIG_PM
2214static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
2215{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 return 0;
2217}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218
Corey Minyardb0defcd2006-03-26 01:37:20 -08002219static int ipmi_pci_resume(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220{
Corey Minyardb0defcd2006-03-26 01:37:20 -08002221 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222}
Corey Minyardb0defcd2006-03-26 01:37:20 -08002223#endif
2224
2225static struct pci_device_id ipmi_pci_devices[] = {
2226 { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
Kees Cook248bdd52007-09-18 22:46:32 -07002227 { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
2228 { 0, }
Corey Minyardb0defcd2006-03-26 01:37:20 -08002229};
2230MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
2231
2232static struct pci_driver ipmi_pci_driver = {
2233 .name = DEVICE_NAME,
2234 .id_table = ipmi_pci_devices,
2235 .probe = ipmi_pci_probe,
2236 .remove = __devexit_p(ipmi_pci_remove),
2237#ifdef CONFIG_PM
2238 .suspend = ipmi_pci_suspend,
2239 .resume = ipmi_pci_resume,
2240#endif
2241};
2242#endif /* CONFIG_PCI */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243
2244
Corey Minyarddba9b4f2007-05-08 00:23:51 -07002245#ifdef CONFIG_PPC_OF
2246static int __devinit ipmi_of_probe(struct of_device *dev,
2247 const struct of_device_id *match)
2248{
2249 struct smi_info *info;
2250 struct resource resource;
2251 const int *regsize, *regspacing, *regshift;
2252 struct device_node *np = dev->node;
2253 int ret;
2254 int proplen;
2255
2256 dev_info(&dev->dev, PFX "probing via device tree\n");
2257
2258 ret = of_address_to_resource(np, 0, &resource);
2259 if (ret) {
2260 dev_warn(&dev->dev, PFX "invalid address from OF\n");
2261 return ret;
2262 }
2263
Stephen Rothwell9c250992007-08-15 16:42:12 +10002264 regsize = of_get_property(np, "reg-size", &proplen);
Corey Minyarddba9b4f2007-05-08 00:23:51 -07002265 if (regsize && proplen != 4) {
2266 dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
2267 return -EINVAL;
2268 }
2269
Stephen Rothwell9c250992007-08-15 16:42:12 +10002270 regspacing = of_get_property(np, "reg-spacing", &proplen);
Corey Minyarddba9b4f2007-05-08 00:23:51 -07002271 if (regspacing && proplen != 4) {
2272 dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
2273 return -EINVAL;
2274 }
2275
Stephen Rothwell9c250992007-08-15 16:42:12 +10002276 regshift = of_get_property(np, "reg-shift", &proplen);
Corey Minyarddba9b4f2007-05-08 00:23:51 -07002277 if (regshift && proplen != 4) {
2278 dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
2279 return -EINVAL;
2280 }
2281
2282 info = kzalloc(sizeof(*info), GFP_KERNEL);
2283
2284 if (!info) {
2285 dev_err(&dev->dev,
2286 PFX "could not allocate memory for OF probe\n");
2287 return -ENOMEM;
2288 }
2289
2290 info->si_type = (enum si_type) match->data;
2291 info->addr_source = "device-tree";
2292 info->io_setup = mem_setup;
2293 info->irq_setup = std_irq_setup;
2294
2295 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
2296 info->io.addr_data = resource.start;
2297
2298 info->io.regsize = regsize ? *regsize : DEFAULT_REGSIZE;
2299 info->io.regspacing = regspacing ? *regspacing : DEFAULT_REGSPACING;
2300 info->io.regshift = regshift ? *regshift : 0;
2301
2302 info->irq = irq_of_parse_and_map(dev->node, 0);
2303 info->dev = &dev->dev;
2304
Mijo Safradin32d21982007-08-22 14:01:48 -07002305 dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %x\n",
Corey Minyarddba9b4f2007-05-08 00:23:51 -07002306 info->io.addr_data, info->io.regsize, info->io.regspacing,
2307 info->irq);
2308
2309 dev->dev.driver_data = (void*) info;
2310
2311 return try_smi_init(info);
2312}
2313
2314static int __devexit ipmi_of_remove(struct of_device *dev)
2315{
2316 cleanup_one_si(dev->dev.driver_data);
2317 return 0;
2318}
2319
2320static struct of_device_id ipmi_match[] =
2321{
2322 { .type = "ipmi", .compatible = "ipmi-kcs", .data = (void *)(unsigned long) SI_KCS },
2323 { .type = "ipmi", .compatible = "ipmi-smic", .data = (void *)(unsigned long) SI_SMIC },
2324 { .type = "ipmi", .compatible = "ipmi-bt", .data = (void *)(unsigned long) SI_BT },
2325 {},
2326};
2327
2328static struct of_platform_driver ipmi_of_platform_driver =
2329{
2330 .name = "ipmi",
2331 .match_table = ipmi_match,
2332 .probe = ipmi_of_probe,
2333 .remove = __devexit_p(ipmi_of_remove),
2334};
2335#endif /* CONFIG_PPC_OF */
2336
2337
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338static int try_get_dev_id(struct smi_info *smi_info)
2339{
Corey Minyard50c812b2006-03-26 01:37:21 -08002340 unsigned char msg[2];
2341 unsigned char *resp;
2342 unsigned long resp_len;
2343 enum si_sm_result smi_result;
2344 int rv = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345
2346 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002347 if (!resp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 return -ENOMEM;
2349
2350 /* Do a Get Device ID command, since it comes back with some
2351 useful info. */
2352 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2353 msg[1] = IPMI_GET_DEVICE_ID_CMD;
2354 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2355
2356 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
2357 for (;;)
2358 {
Corey Minyardc3e7e792005-11-07 01:00:02 -08002359 if (smi_result == SI_SM_CALL_WITH_DELAY ||
2360 smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
Nishanth Aravamudanda4cd8d2005-09-10 00:27:30 -07002361 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 smi_result = smi_info->handlers->event(
2363 smi_info->si_sm, 100);
2364 }
2365 else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
2366 {
2367 smi_result = smi_info->handlers->event(
2368 smi_info->si_sm, 0);
2369 }
2370 else
2371 break;
2372 }
2373 if (smi_result == SI_SM_HOSED) {
2374 /* We couldn't get the state machine to run, so whatever's at
2375 the port is probably not an IPMI SMI interface. */
2376 rv = -ENODEV;
2377 goto out;
2378 }
2379
2380 /* Otherwise, we got some data. */
2381 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2382 resp, IPMI_MAX_MSG_LENGTH);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002383
Corey Minyardd8c98612007-10-18 03:07:11 -07002384 /* Check and record info from the get device id, in case we need it. */
2385 rv = ipmi_demangle_device_id(resp, resp_len, &smi_info->device_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386
2387 out:
2388 kfree(resp);
2389 return rv;
2390}
2391
2392static int type_file_read_proc(char *page, char **start, off_t off,
2393 int count, int *eof, void *data)
2394{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 struct smi_info *smi = data;
2396
Corey Minyardb361e272006-12-06 20:41:07 -08002397 return sprintf(page, "%s\n", si_to_str[smi->si_type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398}
2399
2400static int stat_file_read_proc(char *page, char **start, off_t off,
2401 int count, int *eof, void *data)
2402{
2403 char *out = (char *) page;
2404 struct smi_info *smi = data;
2405
2406 out += sprintf(out, "interrupts_enabled: %d\n",
Corey Minyardb0defcd2006-03-26 01:37:20 -08002407 smi->irq && !smi->interrupt_disabled);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 out += sprintf(out, "short_timeouts: %ld\n",
2409 smi->short_timeouts);
2410 out += sprintf(out, "long_timeouts: %ld\n",
2411 smi->long_timeouts);
2412 out += sprintf(out, "timeout_restarts: %ld\n",
2413 smi->timeout_restarts);
2414 out += sprintf(out, "idles: %ld\n",
2415 smi->idles);
2416 out += sprintf(out, "interrupts: %ld\n",
2417 smi->interrupts);
2418 out += sprintf(out, "attentions: %ld\n",
2419 smi->attentions);
2420 out += sprintf(out, "flag_fetches: %ld\n",
2421 smi->flag_fetches);
2422 out += sprintf(out, "hosed_count: %ld\n",
2423 smi->hosed_count);
2424 out += sprintf(out, "complete_transactions: %ld\n",
2425 smi->complete_transactions);
2426 out += sprintf(out, "events: %ld\n",
2427 smi->events);
2428 out += sprintf(out, "watchdog_pretimeouts: %ld\n",
2429 smi->watchdog_pretimeouts);
2430 out += sprintf(out, "incoming_messages: %ld\n",
2431 smi->incoming_messages);
2432
Corey Minyardb361e272006-12-06 20:41:07 -08002433 return out - page;
2434}
2435
2436static int param_read_proc(char *page, char **start, off_t off,
2437 int count, int *eof, void *data)
2438{
2439 struct smi_info *smi = data;
2440
2441 return sprintf(page,
2442 "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
2443 si_to_str[smi->si_type],
2444 addr_space_to_str[smi->io.addr_type],
2445 smi->io.addr_data,
2446 smi->io.regspacing,
2447 smi->io.regsize,
2448 smi->io.regshift,
2449 smi->irq,
2450 smi->slave_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451}
2452
Corey Minyard3ae0e0f2005-09-06 15:18:41 -07002453/*
2454 * oem_data_avail_to_receive_msg_avail
2455 * @info - smi_info structure with msg_flags set
2456 *
2457 * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
2458 * Returns 1 indicating need to re-run handle_flags().
2459 */
2460static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
2461{
Corey Minyarde8b33612005-09-06 15:18:45 -07002462 smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
2463 RECEIVE_MSG_AVAIL);
Corey Minyard3ae0e0f2005-09-06 15:18:41 -07002464 return 1;
2465}
2466
2467/*
2468 * setup_dell_poweredge_oem_data_handler
2469 * @info - smi_info.device_id must be populated
2470 *
2471 * Systems that match, but have firmware version < 1.40 may assert
2472 * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
2473 * it's safe to do so. Such systems will de-assert OEM1_DATA_AVAIL
2474 * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
2475 * as RECEIVE_MSG_AVAIL instead.
2476 *
2477 * As Dell has no plans to release IPMI 1.5 firmware that *ever*
2478 * assert the OEM[012] bits, and if it did, the driver would have to
2479 * change to handle that properly, we don't actually check for the
2480 * firmware version.
2481 * Device ID = 0x20 BMC on PowerEdge 8G servers
2482 * Device Revision = 0x80
2483 * Firmware Revision1 = 0x01 BMC version 1.40
2484 * Firmware Revision2 = 0x40 BCD encoded
2485 * IPMI Version = 0x51 IPMI 1.5
2486 * Manufacturer ID = A2 02 00 Dell IANA
2487 *
Corey Minyardd5a2b892005-11-07 00:59:58 -08002488 * Additionally, PowerEdge systems with IPMI < 1.5 may also assert
2489 * OEM0_DATA_AVAIL and needs to be treated as RECEIVE_MSG_AVAIL.
2490 *
Corey Minyard3ae0e0f2005-09-06 15:18:41 -07002491 */
2492#define DELL_POWEREDGE_8G_BMC_DEVICE_ID 0x20
2493#define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
2494#define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
Corey Minyard50c812b2006-03-26 01:37:21 -08002495#define DELL_IANA_MFR_ID 0x0002a2
Corey Minyard3ae0e0f2005-09-06 15:18:41 -07002496static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
2497{
2498 struct ipmi_device_id *id = &smi_info->device_id;
Corey Minyard50c812b2006-03-26 01:37:21 -08002499 if (id->manufacturer_id == DELL_IANA_MFR_ID) {
Corey Minyardd5a2b892005-11-07 00:59:58 -08002500 if (id->device_id == DELL_POWEREDGE_8G_BMC_DEVICE_ID &&
2501 id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV &&
Corey Minyard50c812b2006-03-26 01:37:21 -08002502 id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
Corey Minyardd5a2b892005-11-07 00:59:58 -08002503 smi_info->oem_data_avail_handler =
2504 oem_data_avail_to_receive_msg_avail;
2505 }
2506 else if (ipmi_version_major(id) < 1 ||
2507 (ipmi_version_major(id) == 1 &&
2508 ipmi_version_minor(id) < 5)) {
2509 smi_info->oem_data_avail_handler =
2510 oem_data_avail_to_receive_msg_avail;
2511 }
Corey Minyard3ae0e0f2005-09-06 15:18:41 -07002512 }
2513}
2514
Corey Minyardea940272005-11-07 00:59:59 -08002515#define CANNOT_RETURN_REQUESTED_LENGTH 0xCA
2516static void return_hosed_msg_badsize(struct smi_info *smi_info)
2517{
2518 struct ipmi_smi_msg *msg = smi_info->curr_msg;
2519
2520 /* Make it a reponse */
2521 msg->rsp[0] = msg->data[0] | 4;
2522 msg->rsp[1] = msg->data[1];
2523 msg->rsp[2] = CANNOT_RETURN_REQUESTED_LENGTH;
2524 msg->rsp_size = 3;
2525 smi_info->curr_msg = NULL;
2526 deliver_recv_msg(smi_info, msg);
2527}
2528
2529/*
2530 * dell_poweredge_bt_xaction_handler
2531 * @info - smi_info.device_id must be populated
2532 *
2533 * Dell PowerEdge servers with the BT interface (x6xx and 1750) will
2534 * not respond to a Get SDR command if the length of the data
2535 * requested is exactly 0x3A, which leads to command timeouts and no
2536 * data returned. This intercepts such commands, and causes userspace
2537 * callers to try again with a different-sized buffer, which succeeds.
2538 */
2539
2540#define STORAGE_NETFN 0x0A
2541#define STORAGE_CMD_GET_SDR 0x23
2542static int dell_poweredge_bt_xaction_handler(struct notifier_block *self,
2543 unsigned long unused,
2544 void *in)
2545{
2546 struct smi_info *smi_info = in;
2547 unsigned char *data = smi_info->curr_msg->data;
2548 unsigned int size = smi_info->curr_msg->data_size;
2549 if (size >= 8 &&
2550 (data[0]>>2) == STORAGE_NETFN &&
2551 data[1] == STORAGE_CMD_GET_SDR &&
2552 data[7] == 0x3A) {
2553 return_hosed_msg_badsize(smi_info);
2554 return NOTIFY_STOP;
2555 }
2556 return NOTIFY_DONE;
2557}
2558
2559static struct notifier_block dell_poweredge_bt_xaction_notifier = {
2560 .notifier_call = dell_poweredge_bt_xaction_handler,
2561};
2562
2563/*
2564 * setup_dell_poweredge_bt_xaction_handler
2565 * @info - smi_info.device_id must be filled in already
2566 *
2567 * Fills in smi_info.device_id.start_transaction_pre_hook
2568 * when we know what function to use there.
2569 */
2570static void
2571setup_dell_poweredge_bt_xaction_handler(struct smi_info *smi_info)
2572{
2573 struct ipmi_device_id *id = &smi_info->device_id;
Corey Minyard50c812b2006-03-26 01:37:21 -08002574 if (id->manufacturer_id == DELL_IANA_MFR_ID &&
Corey Minyardea940272005-11-07 00:59:59 -08002575 smi_info->si_type == SI_BT)
2576 register_xaction_notifier(&dell_poweredge_bt_xaction_notifier);
2577}
2578
Corey Minyard3ae0e0f2005-09-06 15:18:41 -07002579/*
2580 * setup_oem_data_handler
2581 * @info - smi_info.device_id must be filled in already
2582 *
2583 * Fills in smi_info.device_id.oem_data_available_handler
2584 * when we know what function to use there.
2585 */
2586
2587static void setup_oem_data_handler(struct smi_info *smi_info)
2588{
2589 setup_dell_poweredge_oem_data_handler(smi_info);
2590}
2591
Corey Minyardea940272005-11-07 00:59:59 -08002592static void setup_xaction_handlers(struct smi_info *smi_info)
2593{
2594 setup_dell_poweredge_bt_xaction_handler(smi_info);
2595}
2596
Corey Minyarda9a2c442005-11-07 01:00:03 -08002597static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
2598{
Corey Minyard453823b2006-03-31 02:30:39 -08002599 if (smi_info->intf) {
2600 /* The timer and thread are only running if the
2601 interface has been started up and registered. */
2602 if (smi_info->thread != NULL)
2603 kthread_stop(smi_info->thread);
2604 del_timer_sync(&smi_info->si_timer);
2605 }
Corey Minyarda9a2c442005-11-07 01:00:03 -08002606}
2607
Randy Dunlap74208842006-04-18 22:21:52 -07002608static __devinitdata struct ipmi_default_vals
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609{
Corey Minyardb0defcd2006-03-26 01:37:20 -08002610 int type;
2611 int port;
Randy Dunlap74208842006-04-18 22:21:52 -07002612} ipmi_defaults[] =
Corey Minyardb0defcd2006-03-26 01:37:20 -08002613{
2614 { .type = SI_KCS, .port = 0xca2 },
2615 { .type = SI_SMIC, .port = 0xca9 },
2616 { .type = SI_BT, .port = 0xe4 },
2617 { .port = 0 }
2618};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619
Corey Minyardb0defcd2006-03-26 01:37:20 -08002620static __devinit void default_find_bmc(void)
2621{
2622 struct smi_info *info;
2623 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624
Corey Minyardb0defcd2006-03-26 01:37:20 -08002625 for (i = 0; ; i++) {
2626 if (!ipmi_defaults[i].port)
2627 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628
Corey Minyardb0defcd2006-03-26 01:37:20 -08002629 info = kzalloc(sizeof(*info), GFP_KERNEL);
2630 if (!info)
2631 return;
2632
Christian Krafft4ff31d72007-03-05 00:30:48 -08002633#ifdef CONFIG_PPC_MERGE
2634 if (check_legacy_ioport(ipmi_defaults[i].port))
2635 continue;
2636#endif
2637
Corey Minyardb0defcd2006-03-26 01:37:20 -08002638 info->addr_source = NULL;
2639
2640 info->si_type = ipmi_defaults[i].type;
2641 info->io_setup = port_setup;
2642 info->io.addr_data = ipmi_defaults[i].port;
2643 info->io.addr_type = IPMI_IO_ADDR_SPACE;
2644
2645 info->io.addr = NULL;
2646 info->io.regspacing = DEFAULT_REGSPACING;
2647 info->io.regsize = DEFAULT_REGSPACING;
2648 info->io.regshift = 0;
2649
2650 if (try_smi_init(info) == 0) {
2651 /* Found one... */
2652 printk(KERN_INFO "ipmi_si: Found default %s state"
2653 " machine at %s address 0x%lx\n",
2654 si_to_str[info->si_type],
2655 addr_space_to_str[info->io.addr_type],
2656 info->io.addr_data);
2657 return;
2658 }
2659 }
2660}
2661
2662static int is_new_interface(struct smi_info *info)
2663{
2664 struct smi_info *e;
2665
2666 list_for_each_entry(e, &smi_infos, link) {
2667 if (e->io.addr_type != info->io.addr_type)
2668 continue;
2669 if (e->io.addr_data == info->io.addr_data)
2670 return 0;
2671 }
2672
2673 return 1;
2674}
2675
2676static int try_smi_init(struct smi_info *new_smi)
2677{
2678 int rv;
2679
2680 if (new_smi->addr_source) {
2681 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
2682 " machine at %s address 0x%lx, slave address 0x%x,"
2683 " irq %d\n",
2684 new_smi->addr_source,
2685 si_to_str[new_smi->si_type],
2686 addr_space_to_str[new_smi->io.addr_type],
2687 new_smi->io.addr_data,
2688 new_smi->slave_addr, new_smi->irq);
2689 }
2690
Corey Minyardd6dfd132006-03-31 02:30:41 -08002691 mutex_lock(&smi_infos_lock);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002692 if (!is_new_interface(new_smi)) {
2693 printk(KERN_WARNING "ipmi_si: duplicate interface\n");
2694 rv = -EBUSY;
2695 goto out_err;
2696 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697
2698 /* So we know not to free it unless we have allocated one. */
2699 new_smi->intf = NULL;
2700 new_smi->si_sm = NULL;
2701 new_smi->handlers = NULL;
2702
Corey Minyardb0defcd2006-03-26 01:37:20 -08002703 switch (new_smi->si_type) {
2704 case SI_KCS:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 new_smi->handlers = &kcs_smi_handlers;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002706 break;
2707
2708 case SI_SMIC:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709 new_smi->handlers = &smic_smi_handlers;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002710 break;
2711
2712 case SI_BT:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713 new_smi->handlers = &bt_smi_handlers;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002714 break;
2715
2716 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717 /* No support for anything else yet. */
2718 rv = -EIO;
2719 goto out_err;
2720 }
2721
2722 /* Allocate the state machine's data and initialize it. */
2723 new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002724 if (!new_smi->si_sm) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725 printk(" Could not allocate state machine memory\n");
2726 rv = -ENOMEM;
2727 goto out_err;
2728 }
2729 new_smi->io_size = new_smi->handlers->init_data(new_smi->si_sm,
2730 &new_smi->io);
2731
2732 /* Now that we know the I/O size, we can set up the I/O. */
2733 rv = new_smi->io_setup(new_smi);
2734 if (rv) {
2735 printk(" Could not set up I/O space\n");
2736 goto out_err;
2737 }
2738
2739 spin_lock_init(&(new_smi->si_lock));
2740 spin_lock_init(&(new_smi->msg_lock));
2741 spin_lock_init(&(new_smi->count_lock));
2742
2743 /* Do low-level detection first. */
2744 if (new_smi->handlers->detect(new_smi->si_sm)) {
Corey Minyardb0defcd2006-03-26 01:37:20 -08002745 if (new_smi->addr_source)
2746 printk(KERN_INFO "ipmi_si: Interface detection"
2747 " failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748 rv = -ENODEV;
2749 goto out_err;
2750 }
2751
2752 /* Attempt a get device id command. If it fails, we probably
Corey Minyardb0defcd2006-03-26 01:37:20 -08002753 don't have a BMC here. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754 rv = try_get_dev_id(new_smi);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002755 if (rv) {
2756 if (new_smi->addr_source)
2757 printk(KERN_INFO "ipmi_si: There appears to be no BMC"
2758 " at this location\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759 goto out_err;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002760 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761
Corey Minyard3ae0e0f2005-09-06 15:18:41 -07002762 setup_oem_data_handler(new_smi);
Corey Minyardea940272005-11-07 00:59:59 -08002763 setup_xaction_handlers(new_smi);
Corey Minyard3ae0e0f2005-09-06 15:18:41 -07002764
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765 INIT_LIST_HEAD(&(new_smi->xmit_msgs));
2766 INIT_LIST_HEAD(&(new_smi->hp_xmit_msgs));
2767 new_smi->curr_msg = NULL;
2768 atomic_set(&new_smi->req_events, 0);
2769 new_smi->run_to_completion = 0;
2770
2771 new_smi->interrupt_disabled = 0;
Corey Minyarda9a2c442005-11-07 01:00:03 -08002772 atomic_set(&new_smi->stop_operation, 0);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002773 new_smi->intf_num = smi_num;
2774 smi_num++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775
2776 /* Start clearing the flags before we enable interrupts or the
2777 timer to avoid racing with the timer. */
2778 start_clear_flags(new_smi);
2779 /* IRQ is defined to be set when non-zero. */
2780 if (new_smi->irq)
2781 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
2782
Corey Minyard50c812b2006-03-26 01:37:21 -08002783 if (!new_smi->dev) {
2784 /* If we don't already have a device from something
2785 * else (like PCI), then register a new one. */
2786 new_smi->pdev = platform_device_alloc("ipmi_si",
2787 new_smi->intf_num);
2788 if (rv) {
2789 printk(KERN_ERR
2790 "ipmi_si_intf:"
2791 " Unable to allocate platform device\n");
Corey Minyard453823b2006-03-31 02:30:39 -08002792 goto out_err;
Corey Minyard50c812b2006-03-26 01:37:21 -08002793 }
2794 new_smi->dev = &new_smi->pdev->dev;
2795 new_smi->dev->driver = &ipmi_driver;
2796
Zhang, Yanminb48f5452006-11-16 01:19:08 -08002797 rv = platform_device_add(new_smi->pdev);
Corey Minyard50c812b2006-03-26 01:37:21 -08002798 if (rv) {
2799 printk(KERN_ERR
2800 "ipmi_si_intf:"
2801 " Unable to register system interface device:"
2802 " %d\n",
2803 rv);
Corey Minyard453823b2006-03-31 02:30:39 -08002804 goto out_err;
Corey Minyard50c812b2006-03-26 01:37:21 -08002805 }
2806 new_smi->dev_registered = 1;
2807 }
2808
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809 rv = ipmi_register_smi(&handlers,
2810 new_smi,
Corey Minyard50c812b2006-03-26 01:37:21 -08002811 &new_smi->device_id,
2812 new_smi->dev,
Corey Minyard759643b2006-12-06 20:40:59 -08002813 "bmc",
Corey Minyard453823b2006-03-31 02:30:39 -08002814 new_smi->slave_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815 if (rv) {
2816 printk(KERN_ERR
2817 "ipmi_si: Unable to register device: error %d\n",
2818 rv);
2819 goto out_err_stop_timer;
2820 }
2821
2822 rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
2823 type_file_read_proc, NULL,
2824 new_smi, THIS_MODULE);
2825 if (rv) {
2826 printk(KERN_ERR
2827 "ipmi_si: Unable to create proc entry: %d\n",
2828 rv);
2829 goto out_err_stop_timer;
2830 }
2831
2832 rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
2833 stat_file_read_proc, NULL,
2834 new_smi, THIS_MODULE);
2835 if (rv) {
2836 printk(KERN_ERR
2837 "ipmi_si: Unable to create proc entry: %d\n",
2838 rv);
2839 goto out_err_stop_timer;
2840 }
2841
Corey Minyardb361e272006-12-06 20:41:07 -08002842 rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
2843 param_read_proc, NULL,
2844 new_smi, THIS_MODULE);
2845 if (rv) {
2846 printk(KERN_ERR
2847 "ipmi_si: Unable to create proc entry: %d\n",
2848 rv);
2849 goto out_err_stop_timer;
2850 }
2851
Corey Minyardb0defcd2006-03-26 01:37:20 -08002852 list_add_tail(&new_smi->link, &smi_infos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853
Corey Minyardd6dfd132006-03-31 02:30:41 -08002854 mutex_unlock(&smi_infos_lock);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002855
Dan Aloni8f141372007-07-15 23:41:57 -07002856 printk(KERN_INFO "IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857
2858 return 0;
2859
2860 out_err_stop_timer:
Corey Minyarda9a2c442005-11-07 01:00:03 -08002861 atomic_inc(&new_smi->stop_operation);
2862 wait_for_timer_and_thread(new_smi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863
2864 out_err:
2865 if (new_smi->intf)
2866 ipmi_unregister_smi(new_smi->intf);
2867
Corey Minyardb0defcd2006-03-26 01:37:20 -08002868 if (new_smi->irq_cleanup)
2869 new_smi->irq_cleanup(new_smi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870
2871 /* Wait until we know that we are out of any interrupt
2872 handlers might have been running before we freed the
2873 interrupt. */
Paul E. McKenneyfbd568a3e2005-05-01 08:59:04 -07002874 synchronize_sched();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875
2876 if (new_smi->si_sm) {
2877 if (new_smi->handlers)
2878 new_smi->handlers->cleanup(new_smi->si_sm);
2879 kfree(new_smi->si_sm);
2880 }
Corey Minyardb0defcd2006-03-26 01:37:20 -08002881 if (new_smi->addr_source_cleanup)
2882 new_smi->addr_source_cleanup(new_smi);
Paolo Galtieri7767e122005-12-15 12:34:28 -08002883 if (new_smi->io_cleanup)
2884 new_smi->io_cleanup(new_smi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885
Corey Minyard50c812b2006-03-26 01:37:21 -08002886 if (new_smi->dev_registered)
2887 platform_device_unregister(new_smi->pdev);
2888
2889 kfree(new_smi);
2890
Corey Minyardd6dfd132006-03-31 02:30:41 -08002891 mutex_unlock(&smi_infos_lock);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002892
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893 return rv;
2894}
2895
Corey Minyardb0defcd2006-03-26 01:37:20 -08002896static __devinit int init_ipmi_si(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898 int i;
2899 char *str;
Corey Minyard50c812b2006-03-26 01:37:21 -08002900 int rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901
2902 if (initialized)
2903 return 0;
2904 initialized = 1;
2905
Corey Minyard50c812b2006-03-26 01:37:21 -08002906 /* Register the device drivers. */
2907 rv = driver_register(&ipmi_driver);
2908 if (rv) {
2909 printk(KERN_ERR
2910 "init_ipmi_si: Unable to register driver: %d\n",
2911 rv);
2912 return rv;
2913 }
2914
2915
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916 /* Parse out the si_type string into its components. */
2917 str = si_type_str;
2918 if (*str != '\0') {
Corey Minyarde8b33612005-09-06 15:18:45 -07002919 for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 si_type[i] = str;
2921 str = strchr(str, ',');
2922 if (str) {
2923 *str = '\0';
2924 str++;
2925 } else {
2926 break;
2927 }
2928 }
2929 }
2930
Corey Minyard1fdd75b2005-09-06 15:18:42 -07002931 printk(KERN_INFO "IPMI System Interface driver.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932
Corey Minyardb0defcd2006-03-26 01:37:20 -08002933 hardcode_find_bmc();
2934
Matt Domscha9fad4c2006-01-11 12:17:44 -08002935#ifdef CONFIG_DMI
Andrey Paninb224cd32005-09-06 15:18:37 -07002936 dmi_find_bmc();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937#endif
2938
Corey Minyardb0defcd2006-03-26 01:37:20 -08002939#ifdef CONFIG_ACPI
Corey Minyard1d5636c2006-12-10 02:19:08 -08002940 acpi_find_bmc();
Corey Minyardb0defcd2006-03-26 01:37:20 -08002941#endif
2942
2943#ifdef CONFIG_PCI
Corey Minyard168b35a2006-12-06 20:41:11 -08002944 rv = pci_register_driver(&ipmi_pci_driver);
2945 if (rv){
2946 printk(KERN_ERR
2947 "init_ipmi_si: Unable to register PCI driver: %d\n",
2948 rv);
2949 }
Corey Minyardb0defcd2006-03-26 01:37:20 -08002950#endif
2951
Corey Minyarddba9b4f2007-05-08 00:23:51 -07002952#ifdef CONFIG_PPC_OF
2953 of_register_platform_driver(&ipmi_of_platform_driver);
2954#endif
2955
Corey Minyardb0defcd2006-03-26 01:37:20 -08002956 if (si_trydefaults) {
Corey Minyardd6dfd132006-03-31 02:30:41 -08002957 mutex_lock(&smi_infos_lock);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002958 if (list_empty(&smi_infos)) {
2959 /* No BMC was found, try defaults. */
Corey Minyardd6dfd132006-03-31 02:30:41 -08002960 mutex_unlock(&smi_infos_lock);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002961 default_find_bmc();
2962 } else {
Corey Minyardd6dfd132006-03-31 02:30:41 -08002963 mutex_unlock(&smi_infos_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964 }
2965 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966
Corey Minyardd6dfd132006-03-31 02:30:41 -08002967 mutex_lock(&smi_infos_lock);
Corey Minyardb361e272006-12-06 20:41:07 -08002968 if (unload_when_empty && list_empty(&smi_infos)) {
Corey Minyardd6dfd132006-03-31 02:30:41 -08002969 mutex_unlock(&smi_infos_lock);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002970#ifdef CONFIG_PCI
2971 pci_unregister_driver(&ipmi_pci_driver);
2972#endif
Christian Krafft10fb62e2007-05-12 10:37:01 -07002973
2974#ifdef CONFIG_PPC_OF
2975 of_unregister_platform_driver(&ipmi_of_platform_driver);
2976#endif
Arnaud Patard55ebcc32006-09-16 12:15:36 -07002977 driver_unregister(&ipmi_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002978 printk("ipmi_si: Unable to find any System Interface(s)\n");
2979 return -ENODEV;
Corey Minyardb0defcd2006-03-26 01:37:20 -08002980 } else {
Corey Minyardd6dfd132006-03-31 02:30:41 -08002981 mutex_unlock(&smi_infos_lock);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002982 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984}
2985module_init(init_ipmi_si);
2986
Corey Minyardb361e272006-12-06 20:41:07 -08002987static void cleanup_one_si(struct smi_info *to_clean)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988{
2989 int rv;
2990 unsigned long flags;
2991
Corey Minyardb0defcd2006-03-26 01:37:20 -08002992 if (!to_clean)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993 return;
2994
Corey Minyardb0defcd2006-03-26 01:37:20 -08002995 list_del(&to_clean->link);
2996
Corey Minyardee6cd5f2007-05-08 00:23:54 -07002997 /* Tell the driver that we are shutting down. */
Corey Minyarda9a2c442005-11-07 01:00:03 -08002998 atomic_inc(&to_clean->stop_operation);
Corey Minyardb0defcd2006-03-26 01:37:20 -08002999
Corey Minyardee6cd5f2007-05-08 00:23:54 -07003000 /* Make sure the timer and thread are stopped and will not run
3001 again. */
Corey Minyarda9a2c442005-11-07 01:00:03 -08003002 wait_for_timer_and_thread(to_clean);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003
Corey Minyardee6cd5f2007-05-08 00:23:54 -07003004 /* Timeouts are stopped, now make sure the interrupts are off
3005 for the device. A little tricky with locks to make sure
3006 there are no races. */
3007 spin_lock_irqsave(&to_clean->si_lock, flags);
3008 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3009 spin_unlock_irqrestore(&to_clean->si_lock, flags);
3010 poll(to_clean);
3011 schedule_timeout_uninterruptible(1);
3012 spin_lock_irqsave(&to_clean->si_lock, flags);
3013 }
3014 disable_si_irq(to_clean);
3015 spin_unlock_irqrestore(&to_clean->si_lock, flags);
3016 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
3017 poll(to_clean);
3018 schedule_timeout_uninterruptible(1);
3019 }
3020
3021 /* Clean up interrupts and make sure that everything is done. */
3022 if (to_clean->irq_cleanup)
3023 to_clean->irq_cleanup(to_clean);
Corey Minyarde8b33612005-09-06 15:18:45 -07003024 while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025 poll(to_clean);
Nishanth Aravamudanda4cd8d2005-09-10 00:27:30 -07003026 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027 }
3028
3029 rv = ipmi_unregister_smi(to_clean->intf);
3030 if (rv) {
3031 printk(KERN_ERR
3032 "ipmi_si: Unable to unregister device: errno=%d\n",
3033 rv);
3034 }
3035
3036 to_clean->handlers->cleanup(to_clean->si_sm);
3037
3038 kfree(to_clean->si_sm);
3039
Corey Minyardb0defcd2006-03-26 01:37:20 -08003040 if (to_clean->addr_source_cleanup)
3041 to_clean->addr_source_cleanup(to_clean);
Paolo Galtieri7767e122005-12-15 12:34:28 -08003042 if (to_clean->io_cleanup)
3043 to_clean->io_cleanup(to_clean);
Corey Minyard50c812b2006-03-26 01:37:21 -08003044
3045 if (to_clean->dev_registered)
3046 platform_device_unregister(to_clean->pdev);
3047
3048 kfree(to_clean);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049}
3050
3051static __exit void cleanup_ipmi_si(void)
3052{
Corey Minyardb0defcd2006-03-26 01:37:20 -08003053 struct smi_info *e, *tmp_e;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054
Corey Minyardb0defcd2006-03-26 01:37:20 -08003055 if (!initialized)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 return;
3057
Corey Minyardb0defcd2006-03-26 01:37:20 -08003058#ifdef CONFIG_PCI
3059 pci_unregister_driver(&ipmi_pci_driver);
3060#endif
3061
Corey Minyarddba9b4f2007-05-08 00:23:51 -07003062#ifdef CONFIG_PPC_OF
3063 of_unregister_platform_driver(&ipmi_of_platform_driver);
3064#endif
3065
Corey Minyardd6dfd132006-03-31 02:30:41 -08003066 mutex_lock(&smi_infos_lock);
Corey Minyardb0defcd2006-03-26 01:37:20 -08003067 list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
3068 cleanup_one_si(e);
Corey Minyardd6dfd132006-03-31 02:30:41 -08003069 mutex_unlock(&smi_infos_lock);
Corey Minyard50c812b2006-03-26 01:37:21 -08003070
3071 driver_unregister(&ipmi_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072}
3073module_exit(cleanup_ipmi_si);
3074
3075MODULE_LICENSE("GPL");
Corey Minyard1fdd75b2005-09-06 15:18:42 -07003076MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
3077MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");