Imported Upstream version 2.9.3upstream/2.9.3

1 files changed, 1904 insertions, 0 deletions

diff --git a/kern/openipmi-emu-rh80.patch b/kern/openipmi-emu-rh80.patch
new file mode 100644
index 0000000..a7e46a0
--- /dev/null
+++ b/kern/openipmi-emu-rh80.patch
@@ -0,0 +1,1904 @@
+--- linux-2.4.18-14orig/Documentation/Configure.help	2003-03-27 15:37:28.000000000 -0500
++++ linux-2.4.18-14/Documentation/Configure.help	2003-03-27 15:32:58.000000000 -0500
+@@ -25590,6 +25590,17 @@
+ CONFIG_IPMI_WATCHDOG
+   This enables the IPMI watchdog timer.
+ 
++Emulate Radisys IPMI driver
++CONFIG_IPMI_EMULATE_RADISYS
++  This enables emulation of the Radisys IPMI device driver.
++
++Emulate Intel IBM driver
++CONFIG_IPMI_EMULATE_IMB
++  This enables emulation of the Intel IMB device driver.  Note that you
++  MUST have the IPMI watchdog timer enabled to use this.  This code
++  uses some of the watchdog code, but the dependency is not enforced
++  by config.
++
+ #
+ # A couple of things I keep forgetting:
+ #   capitalize: AppleTalk, Ethernet, DOS, DMA, FAT, FTP, Internet,
+--- linux-2.4.18-14orig/drivers/char/Config.in	2003-03-27 15:37:28.000000000 -0500
++++ linux-2.4.18-14/drivers/char/Config.in	2003-03-27 15:32:58.000000000 -0500
+@@ -180,6 +180,8 @@
+ dep_tristate '  Device interface for IPMI' CONFIG_IPMI_DEVICE_INTERFACE $CONFIG_IPMI_HANDLER
+ dep_tristate '  IPMI KCS handler' CONFIG_IPMI_KCS $CONFIG_IPMI_HANDLER
+ dep_tristate '  IPMI Watchdog Timer' CONFIG_IPMI_WATCHDOG $CONFIG_IPMI_HANDLER
++dep_tristate '  Emulate Radisys IPMI driver' CONFIG_IPMI_EMULATE_RADISYS $CONFIG_IPMI_HANDLER
++dep_tristate '  Emulate Intel IMB driver' CONFIG_IPMI_EMULATE_IMB $CONFIG_IPMI_WATCHDOG
+ 
+ mainmenu_option next_comment
+ comment 'Watchdog Cards'
+--- linux-2.4.18-14orig/drivers/char/ipmi/Makefile	2003-03-27 15:37:28.000000000 -0500
++++ linux-2.4.18-14/drivers/char/ipmi/Makefile	2003-03-27 15:32:58.000000000 -0500
+@@ -13,6 +13,8 @@
+ obj-$(CONFIG_IPMI_DEVICE_INTERFACE) += ipmi_devintf.o
+ obj-$(CONFIG_IPMI_KCS) += ipmi_kcs_drv.o
+ obj-$(CONFIG_IPMI_WATCHDOG) += ipmi_watchdog.o
++obj-$(CONFIG_IPMI_EMULATE_RADISYS) += ipmi_radisys.o
++obj-$(CONFIG_IPMI_EMULATE_IMB) += ipmi_imb.o
+ 
+ include $(TOPDIR)/Rules.make
+ 
+--- /dev/null	2002-08-30 19:31:37.000000000 -0400
++++ linux-2.4.18-14/include/linux/ipmi_imb.h	2003-03-27 15:33:11.000000000 -0500
+@@ -0,0 +1,144 @@
++/*
++ * ipmi_imb.h
++ *
++ * Intels IMB emulation on the MontaVista IPMI interface
++ *
++ * Author: MontaVista Software, Inc.
++ *         Corey Minyard <minyard@mvista.com>
++ *         source@mvista.com
++ *
++ * Copyright 2002 MontaVista Software Inc.
++ *
++ *  This program is free software; you can redistribute it and/or modify it
++ *  under the terms of the GNU General Public License as published by the
++ *  Free Software Foundation; either version 2 of the License, or (at your
++ *  option) any later version.
++ *
++ *
++ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
++ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
++ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
++ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
++ *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
++ *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
++ *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
++ *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ *
++ *  You should have received a copy of the GNU General Public License along
++ *  with this program; if not, write to the Free Software Foundation, Inc.,
++ *  675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#ifndef __LINUX_IPMI_IMB_H
++#define __LINUX_IPMI_IMB_H
++
++typedef struct overlapped_s {
++    unsigned long Internal;
++    unsigned long InternalHigh;
++    unsigned long Offset;
++    unsigned long OffsetHigh;
++} overlapped_t;
++
++struct smi {
++    unsigned long smi_VersionNo;
++    unsigned long smi_Reserved1;
++    unsigned long smi_Reserved2;
++    void          *ntstatus;	      /* address of NT status block*/
++    void          *lpvInBuffer;       /* address of buffer for input data*/
++    unsigned long cbInBuffer;         /* size of input buffer*/
++    void          *lpvOutBuffer;      /* address of output buffer*/
++    unsigned long cbOutBuffer;        /* size of output buffer*/
++    unsigned long *lpcbBytesReturned; /* address of actual bytes of output*/
++    overlapped_t  *lpoOverlapped;     /* address of overlapped structure*/
++};
++
++
++#define MAX_IMB_PACKET_SIZE	33
++
++typedef struct {
++	unsigned char rsSa;
++	unsigned char cmd;
++	unsigned char netFn;
++	unsigned char rsLun;
++	unsigned char dataLength;
++	unsigned char data[1];
++} ImbRequest;
++
++typedef struct {
++	unsigned long flags;
++#define	      		NO_RESPONSE_EXPECTED	0x01
++
++	unsigned long timeOut;
++	ImbRequest    req;
++} ImbRequestBuffer;
++
++#define MIN_IMB_REQ_BUF_SIZE	13
++
++
++typedef struct {
++	unsigned char cCode;
++	unsigned char data[1];
++} ImbResponseBuffer;
++
++#define MIN_IMB_RESP_BUF_SIZE	1	// a buffer without any request data
++#define MAX_IMB_RESP_SIZE		(MIN_IMB_RESP_BUF_SIZE + MAX_IMB_RESPONSE_SIZE)
++
++#define MIN_IMB_RESPONSE_SIZE	7
++#define MAX_IMB_RESPONSE_SIZE	MAX_IMB_PACKET_SIZE
++
++typedef struct {
++	unsigned long timeOut;
++	unsigned long lastSeq;
++} ImbAsyncRequest;
++
++typedef struct {
++	unsigned long thisSeq;
++	unsigned char data[1];
++} ImbAsyncResponse;
++
++#define MIN_ASYNC_RESP_SIZE		sizeof(unsigned long)
++#define MAX_ASYNC_RESP_SIZE		(MIN_ASYNC_RESP_SIZE + MAX_IMB_PACKET_SIZE)
++
++#define STATUS_SUCCESS                  (0x00000000U)
++#define IMB_NO_ASYNC_MSG		((unsigned long)0xE0070012L)
++#define IMB_SEND_REQUEST_FAILED		((unsigned long)0xE0070013L)
++#define INVALID_ARGUMENTS		((unsigned long)0xE0070002L)
++
++
++#define FILE_DEVICE_IMB			0x00008010
++#define IOCTL_IMB_BASE			0x00000880
++
++#define CTL_CODE(DeviceType, Function, Method, Access)\
++		_IO(DeviceType & 0x00FF, Function & 0x00FF)
++
++#define FILE_DEVICE_IMB			0x00008010
++#define IOCTL_IMB_BASE			0x00000880
++#define METHOD_BUFFERED                 0
++#define FILE_ANY_ACCESS                 0
++
++
++typedef struct {
++	int	code;
++#define		SD_NO_ACTION				0
++#define		SD_RESET				1
++#define		SD_POWER_OFF				2
++
++	int	delayTime;  /* in units of 100 millisecond */
++} ShutdownCmdBuffer;
++
++
++/* BMC added parentheses around IOCTL_IMB_BASE + 2 */
++#define IOCTL_IMB_SEND_MESSAGE		CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 2), METHOD_BUFFERED, FILE_ANY_ACCESS)
++#define IOCTL_IMB_GET_ASYNC_MSG		CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 8), METHOD_BUFFERED, FILE_ANY_ACCESS)
++#define IOCTL_IMB_MAP_MEMORY		CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 14),METHOD_BUFFERED, FILE_ANY_ACCESS)
++#define IOCTL_IMB_UNMAP_MEMORY		CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 16),METHOD_BUFFERED, FILE_ANY_ACCESS)
++#define IOCTL_IMB_SHUTDOWN_CODE		CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 18),METHOD_BUFFERED, FILE_ANY_ACCESS)
++#define IOCTL_IMB_REGISTER_ASYNC_OBJ	CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 24),METHOD_BUFFERED, FILE_ANY_ACCESS)
++#define IOCTL_IMB_DEREGISTER_ASYNC_OBJ	CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 26),METHOD_BUFFERED, FILE_ANY_ACCESS)
++#define IOCTL_IMB_CHECK_EVENT		CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 28),METHOD_BUFFERED, FILE_ANY_ACCESS)
++#define IOCTL_IMB_POLL_ASYNC		CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 20),METHOD_BUFFERED, FILE_ANY_ACCESS)
++
++
++#endif /* __LINUX_IPMI_IMB_H */
+--- /dev/null	2002-08-30 19:31:37.000000000 -0400
++++ linux-2.4.18-14/include/linux/ipmi_radisys.h	2003-03-27 15:33:11.000000000 -0500
+@@ -0,0 +1,128 @@
++/*
++ * ipmi_radisys.h
++ *
++ * An emulation of the Radisys IPMI interface on top of the MontaVista
++ * interface.
++ *
++ * Author: MontaVista Software, Inc.
++ *         Corey Minyard <minyard@mvista.com>
++ *         source@mvista.com
++ *
++ * Copyright 2002 MontaVista Software Inc.
++ *
++ *  This program is free software; you can redistribute it and/or modify it
++ *  under the terms of the GNU General Public License as published by the
++ *  Free Software Foundation; either version 2 of the License, or (at your
++ *  option) any later version.
++ *
++ *
++ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
++ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
++ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
++ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
++ *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
++ *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
++ *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
++ *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ *
++ *  You should have received a copy of the GNU General Public License along
++ *  with this program; if not, write to the Free Software Foundation, Inc.,
++ *  675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#ifndef __LINUX_IPMI_RADISYS_H
++#define __LINUX_IPMI_RADISYS_H
++
++/******************************************************************************
++ * This is the old IPMI interface defined by Radisys.  We are
++ * compliant with that.  Don't use it for new designs, though.
++ */
++#define IOCTL_IPMI_RCV          ( IPMI_IOC_MAGIC<<8 | 1 )
++#define IOCTL_IPMI_SEND         ( IPMI_IOC_MAGIC<<8 | 2 )
++#define IOCTL_IPMI_EVENT        ( IPMI_IOC_MAGIC<<8 | 3 )
++#define IOCTL_IPMI_REGISTER     ( IPMI_IOC_MAGIC<<8 | 4 )
++#define IOCTL_IPMI_UNREGISTER   ( IPMI_IOC_MAGIC<<8 | 5 )
++#define IOCTL_IPMI_CLEAR        ( IPMI_IOC_MAGIC<<8 | 9 )
++
++/* These don't seem to be implemented in the Radisys driver.
++#define IOCTL_IPMI_RESET_BMC    ( IPMI_IOC_MAGIC<<8 | 6 )
++#define IOCTL_IPMI_GET_BMC_ADDR ( IPMI_IOC_MAGIC<<8 | 7 )
++#define IOCTL_IPMI_SET_BMC_ADDR ( IPMI_IOC_MAGIC<<8 | 8 )
++*/
++
++/* 
++ * Network Function Codes 
++ */
++#define IPMI_NETFN_CHASSIS          0x00    /* Chassis - 0x00 << 2 */
++#define IPMI_NETFN_CHASSIS_RESP     0x04    /* Chassis - 0x01 << 2 */
++
++#define IPMI_NETFN_BRIDGE           0x08    /* Bridge - 0x02 << 2 */
++#define IPMI_NETFN_BRIDGE_RESP      0x0c    /* Bridge - 0x03 << 2 */
++
++#define IPMI_NETFN_SENSOR_EVT       0x10    /* Sensor/Event - 0x04 << 2 */
++#define IPMI_NETFN_SENSOR_EVT_RESP  0x14    /* Sensor/Event - 0x05 << 2 */
++
++#define IPMI_NETFN_APP              0x18    /* Application - 0x06 << 2 */
++#define IPMI_NETFN_APP_RESP         0x1c    /* Application - 0x07 << 2 */
++
++#define IPMI_NETFN_FIRMWARE         0x20    /* Firmware - 0x08 << 2 */
++#define IPMI_NETFN_FIRMWARE_RESP    0x24    /* Firmware - 0x09 << 2 */
++
++#define IPMI_NETFN_STORAGE          0x28    /* Storage - 0x0a << 2 */
++#define IPMI_NETFN_STORAGE_RESP     0x2c    /* Storage - 0x0b << 2 */
++
++#define IPMI_NETFN_OEM_1            0xC0    /* Storage - 0x30 << 2 */
++#define IPMI_NETFN_OEM_1_RESP       0xC4    /* Storage - 0x31 << 2 */
++
++/* there are 15 other OEM netfn pairs (OEM - 0x30-0x3f) */
++
++typedef struct _IPMI_LIST_ENTRY {
++   struct _IPMI_LIST_ENTRY * volatile Flink;
++   struct _IPMI_LIST_ENTRY * volatile Blink;
++} IPMI_LIST_ENTRY, *PIPMI_LIST_ENTRY;
++
++typedef struct IPMI_semaphore   IPMI_KSEMAPHORE;
++typedef struct IPMI_semaphore * IPMI_PKSEMAPHORE;
++
++/* IPMI Address structure */
++typedef struct _IPMI_ADDR {
++    unsigned char uchSlave;                /* Slave Address */
++    unsigned char uchLun;                  /* Logical Unit Number */
++} IPMI_ADDR, *PIPMI_ADDR;
++
++#define IPMI_MAX_MSG_SIZE	36
++
++/* IPMI Message Descriptor structure */
++typedef struct _IPMI_MSGDESC {
++                                         /************************************/
++                                         /* Device Driver Specific Elements  */
++                                         /************************************/
++    IPMI_LIST_ENTRY  Entry;                  /* Linked list element */
++    void             *pIRPacket;             /* Pointer to IRP object */
++    IPMI_PKSEMAPHORE pSema;                  /* Semaphore Object */
++    long             lTimeout;               /* Timeout value */
++                                         /************************************/
++                                         /* Shared elements                  */
++                                         /************************************/
++    unsigned char   auchBuffer[IPMI_MAX_MSG_SIZE]; /* Message buffer */
++    unsigned long   ulLength;               /* Length of message in bytes */
++    int             fDefer;                 /* TRUE - Defer I/O
++					       operation, doesn't seem
++					       to be used in the
++					       Radisys driver. */
++    IPMI_ADDR       Dest;                   /* Destination IPM Address */
++    unsigned char   uchNetFn;               /* Network Function */
++    unsigned char   uchCmd;                 /* Command */
++    unsigned char   uchSeq;                 /* Sequence Number */
++    unsigned char   uchComplete;            /* Completion Code */
++} IPMI_MSGDESC, *PIPMI_MSGDESC;
++
++/* Byte return codes for some things. */
++#define LOWLRC_SUCCESS              0x00 /* routine completed successfully */
++#define LOWLRC_ERROR                0xff /* routine did not complete */
++#define LOWLRC_INVALID_PARAMETERS   0xfe /* invalid parameters */
++#define LOWLRC_INVALID_REQUEST_DATA 0xfd /* invalid request data */
++
++#endif /* __LINUX_IPMI_RADISYS_H */
+--- /dev/null	2002-08-30 19:31:37.000000000 -0400
++++ linux-2.4.18-14/drivers/char/ipmi/ipmi_imb.c	2003-03-27 15:32:59.000000000 -0500
+@@ -0,0 +1,744 @@
++/*
++ * ipmi_imb.c
++ *
++ * Intel IMB emulation for the IPMI interface.
++ *
++ * Author: MontaVista Software, Inc.
++ *         Corey Minyard <minyard@mvista.com>
++ *         source@mvista.com
++ *
++ * Copyright 2002 MontaVista Software Inc.
++ *
++ *  This program is free software; you can redistribute it and/or modify it
++ *  under the terms of the GNU General Public License as published by the
++ *  Free Software Foundation; either version 2 of the License, or (at your
++ *  option) any later version.
++ *
++ *
++ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
++ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
++ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
++ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
++ *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
++ *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
++ *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
++ *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ *
++ *  You should have received a copy of the GNU General Public License along
++ *  with this program; if not, write to the Free Software Foundation, Inc.,
++ *  675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/errno.h>
++#include <asm/system.h>
++#include <linux/sched.h>
++#include <linux/poll.h>
++#include <linux/spinlock.h>
++#include <linux/slab.h>
++#include <linux/devfs_fs_kernel.h>
++#include <linux/ipmi.h>
++#include <linux/ipmi_imb.h>
++
++
++
++#define MAX_BUFFER_SIZE                 64
++#define BMC_SA				0x20
++
++struct priv_data
++{
++	/* This is for supporting the old Imb interface. */
++	ipmi_user_t       imb_user;
++	spinlock_t        imb_lock;
++
++	unsigned long     curr_msgid;
++
++	/* A list of responses in the queue. */
++	struct list_head  imb_waiting_rsps;
++
++	/* A list of things waiting for responses.  We wake them all up
++	   when a response comes in. */
++	wait_queue_head_t imb_waiting_rsp_rcvrs;
++
++	/* A list of commands that have come in. */
++	struct list_head  imb_waiting_cmds;
++
++	/* A list of thing waiting for commands.  We wake them all up
++	   when a command comes in. */
++	wait_queue_head_t imb_waiting_cmd_rcvrs;
++
++	/* The registered command receiver value.  This only allows someone
++	   with the "magic number" to issue commands. */
++	unsigned long     imb_cmd_receiver;
++
++	/* Is someone already waiting for a command?  The Imb driver
++	   only allows one waiter, this enforces that. */
++	int               imb_cmd_waiting;
++
++	/* A list of IPMI events waiting to be delivered.  (not that
++           the Imb driver calls incoming commands "events", this
++           variable is actual IPMI events, not incoming commands). */
++	struct list_head  imb_waiting_events;
++
++#define IMB_EVENT_QUEUE_LIMIT	16 /* Allow up to 16 events. */
++	/* The number of events in the event queue. */
++	unsigned int      imb_waiting_event_count;
++};
++
++static devfs_handle_t devfs_handle;
++
++
++/* We cheat and use a piece of the address as the timeout. */
++static long *imb_timeout(struct ipmi_recv_msg *msg)
++{
++	char *base = (char *) &(msg->addr);
++	base += sizeof(struct ipmi_ipmb_addr);
++	return (long *) base;
++}
++
++static void imb_msg_recv(struct ipmi_recv_msg *msg,
++			 void                 *data)
++{
++	struct priv_data *priv = data;
++	unsigned long    flags;
++
++	spin_lock_irqsave(&(priv->imb_lock), flags);
++	if (msg->recv_type == IPMI_RESPONSE_RECV_TYPE) {
++		*imb_timeout(msg) = 5000;
++		list_add_tail(&(msg->link), &(priv->imb_waiting_rsps));
++		wake_up_all(&(priv->imb_waiting_rsp_rcvrs));
++	} else if (msg->recv_type == IPMI_CMD_RECV_TYPE) {
++		*imb_timeout(msg) = 5000;
++		list_add_tail(&(msg->link), &(priv->imb_waiting_cmds));
++		wake_up_all(&(priv->imb_waiting_cmd_rcvrs));
++	} else if (msg->recv_type == IPMI_ASYNC_EVENT_RECV_TYPE) {
++		if (priv->imb_waiting_event_count > IMB_EVENT_QUEUE_LIMIT) {
++			ipmi_free_recv_msg(msg);
++		} else {
++			list_add_tail(&(msg->link),&(priv->imb_waiting_events));
++			(priv->imb_waiting_event_count)++;
++		}
++	} else {
++		ipmi_free_recv_msg(msg);
++	}
++	spin_unlock_irqrestore(&(priv->imb_lock), flags);
++}
++
++/* We emulate the event queue in the driver for the imb emulation. */
++static int imb_handle_event_request(struct priv_data     *priv,
++				    struct ipmi_recv_msg **rsp)
++{
++	struct list_head     *entry;
++	unsigned long        flags;
++	struct ipmi_recv_msg *msg = NULL;
++	int                  rv = 0;
++
++	spin_lock_irqsave(&(priv->imb_lock), flags);
++	if (list_empty(&(priv->imb_waiting_events))) {
++		/* Nothing in the event queue, just return an error. */
++		msg = ipmi_alloc_recv_msg();
++		if (msg == NULL) {
++			rv = -EAGAIN;
++			goto out_err;
++		}
++		msg->addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
++		msg->addr.channel = IPMI_BMC_CHANNEL;
++		msg->msg.cmd = IPMI_READ_EVENT_MSG_BUFFER_CMD;
++		msg->msgid = 0;
++		msg->recv_type = IPMI_ASYNC_EVENT_RECV_TYPE;
++		msg->msg.netfn = IPMI_NETFN_APP_RESPONSE;
++		msg->msg.data = msg->msg_data;
++		msg->msg.data[0] = 0x80; /* Data not available. */
++		msg->msg.data_len = 1;
++	} else {
++		/* Pull an item from the event queue . */
++		entry = priv->imb_waiting_events.next;
++		list_del(entry);
++		msg = list_entry(entry, struct ipmi_recv_msg, link);
++		(priv->imb_waiting_event_count)--;
++	}
++
++	*rsp = msg;
++
++ out_err:
++	spin_unlock_irqrestore(&(priv->imb_lock), flags);
++	return rv;
++}
++
++static struct priv_data *ipmi_user;
++static unsigned int user_count = 0; /* How many users have this open. */
++static spinlock_t dev_lock = SPIN_LOCK_UNLOCKED;
++
++static int ipmi_imb_open(struct inode *inode, struct file *file)
++{
++	int rv;
++
++	if (user_count == 0) {
++		rv = ipmi_register_all_cmd_rcvr(ipmi_user->imb_user);
++		if (rv)	{
++			return rv;
++		}
++	}
++
++	file->private_data = ipmi_user;
++	spin_lock(&dev_lock);
++	if (user_count == 0)
++		ipmi_set_gets_events(ipmi_user->imb_user, 1);
++	user_count++;
++	spin_unlock(&dev_lock);
++
++	return 0;
++}
++
++static int ipmi_imb_release(struct inode *inode, struct file *file)
++{
++	spin_lock(&dev_lock);
++	user_count--;
++	if (user_count == 0) {
++		ipmi_set_gets_events(ipmi_user->imb_user, 0);
++		ipmi_unregister_all_cmd_rcvr(ipmi_user->imb_user);
++	}
++	spin_unlock(&dev_lock);
++	return 0;
++}
++
++static unsigned char
++ipmb_checksum(unsigned char *data, int size)
++{
++	unsigned char csum = 0;
++	
++	for (; size > 0; size--, data++)
++		csum += *data;
++
++	return -csum;
++}
++
++extern void ipmi_delayed_shutdown(long delay, int power_off);
++
++static int ipmi_imb_ioctl(struct inode  *inode,
++			  struct file   *file,
++			  unsigned int  cmd,
++			  unsigned long data)
++{
++	struct priv_data *priv = file->private_data;
++	int              rv = -EINVAL;
++	struct smi       smi;
++	unsigned long    flags;
++
++	if (copy_from_user((caddr_t)&smi, (caddr_t)data, sizeof(smi))) {
++		return -EFAULT;
++	}
++	
++	switch(cmd) {
++	case IOCTL_IMB_POLL_ASYNC:
++		/*
++		 * No-op for this, the low-level driver polls.
++		 */
++		break;
++
++	case IOCTL_IMB_GET_ASYNC_MSG:
++	{
++		unsigned char        resp[MAX_ASYNC_RESP_SIZE];
++		struct ipmi_recv_msg *msg = NULL;
++		ImbAsyncResponse     *pAsyncResp = (ImbAsyncResponse *) resp;
++		unsigned long        length = 0;
++			
++		if (smi.cbInBuffer < sizeof(ImbAsyncRequest))
++			return -EINVAL;
++		if (smi.cbOutBuffer < MIN_ASYNC_RESP_SIZE)
++			return -EINVAL;
++
++		spin_lock_irqsave(&(priv->imb_lock), flags);
++
++		if (list_empty(&(priv->imb_waiting_cmds))) {
++			/* No command waiting, just return an error. */
++			rv = IMB_NO_ASYNC_MSG;
++		} else {
++			struct list_head *entry;
++
++			/* Got a command, pull it out and handle it. */
++			entry = priv->imb_waiting_cmds.next;
++			list_del(entry);
++			msg = list_entry(entry, struct ipmi_recv_msg, link);
++			rv = STATUS_SUCCESS;
++		}
++		spin_unlock_irqrestore(&(priv->imb_lock), flags);
++
++		if (msg != NULL) {
++			struct ipmi_ipmb_addr *ipmb_addr;
++
++			ipmb_addr = (struct ipmi_ipmb_addr *) &(msg->addr);
++			pAsyncResp->thisSeq = msg->msgid;
++			pAsyncResp->data[0] = IPMI_NETFN_APP_REQUEST << 2;
++			pAsyncResp->data[1] = IPMI_SEND_MSG_CMD;
++			pAsyncResp->data[2] = 0;
++			pAsyncResp->data[3] = msg->addr.channel;
++			pAsyncResp->data[4] = ((msg->msg.netfn << 2)
++					     | 2);
++			pAsyncResp->data[5]
++				= ipmb_checksum(&(pAsyncResp->data[3]),
++						2);
++			pAsyncResp->data[6] = ipmb_addr->slave_addr;
++			pAsyncResp->data[7] = ((msg->msgid << 2)
++					     | ipmb_addr->lun);
++			pAsyncResp->data[8] = msg->msg.cmd;
++
++			memcpy(&(pAsyncResp->data[9]),
++			       &(msg->msg.data[0]),
++			       msg->msg.data_len);
++			
++			length = msg->msg.data_len + MIN_ASYNC_RESP_SIZE;
++
++			ipmi_free_recv_msg(msg);
++
++			if (copy_to_user(smi.lpvOutBuffer, pAsyncResp, length))
++			{
++				return -EFAULT;
++			}
++		}
++
++		if (copy_to_user(smi.lpcbBytesReturned,
++				 &length,
++				 sizeof(length)))
++		{
++			return -EFAULT;
++		}
++		rv = 0;
++		break;
++	}
++		
++	case IOCTL_IMB_SEND_MESSAGE:
++	{
++		unsigned char        imbReqBuffer[MAX_IMB_RESPONSE_SIZE + 8];
++		unsigned char        imbRespBuffer[MAX_IMB_RESPONSE_SIZE + 8];
++		ImbRequestBuffer     *pImbReq=(ImbRequestBuffer *)imbReqBuffer;
++		ImbResponseBuffer    *pImbResp=(ImbResponseBuffer*)imbRespBuffer;
++		struct ipmi_addr     addr;
++		struct ipmi_msg      msg;
++		unsigned long        msgid;
++		struct ipmi_recv_msg *rsp;
++		unsigned long        length;
++		wait_queue_t         wait;
++		struct list_head     *entry;
++
++
++		if ((smi.cbInBuffer < MIN_IMB_REQ_BUF_SIZE)
++		    || (smi.cbOutBuffer < MIN_IMB_RESP_BUF_SIZE))
++		{
++			return -EINVAL;
++		}
++
++		if (smi.cbInBuffer > (MAX_IMB_RESPONSE_SIZE + 8)) {
++			/* Input buffer is too large */
++			return -EINVAL;
++		}
++
++		if (copy_from_user(pImbReq, smi.lpvInBuffer, smi.cbInBuffer)) {
++			return -EFAULT;
++		}
++		if ((pImbReq->req.dataLength + MIN_IMB_REQ_BUF_SIZE)
++		    > smi.cbInBuffer)
++		{
++			return -EINVAL;
++		}
++		if (pImbReq->req.dataLength > MAX_BUFFER_SIZE) {
++			return -EINVAL;
++		}
++
++		if (pImbReq->req.rsSa == BMC_SA) {
++			struct ipmi_system_interface_addr *smi_addr
++				= (struct ipmi_system_interface_addr *) &addr;
++
++			if ((pImbReq->req.netFn
++			     == (IPMI_NETFN_APP_REQUEST << 2))
++			    && (pImbReq->req.cmd
++				== IPMI_READ_EVENT_MSG_BUFFER_CMD))
++			{
++				/* The driver gets event messages
++                                   automatically, so we emulate
++                                   this. */
++				rv = imb_handle_event_request(priv, &rsp);
++				goto copy_resp;
++			} else {
++				smi_addr->addr_type
++				    = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
++				smi_addr->channel = IPMI_BMC_CHANNEL;
++				smi_addr->lun = 0;
++			}
++		} else {
++			struct ipmi_ipmb_addr *ipmb_addr =
++				(struct ipmi_ipmb_addr *) &addr;
++			
++			ipmb_addr->addr_type = IPMI_IPMB_ADDR_TYPE;
++			ipmb_addr->slave_addr = pImbReq->req.rsSa;
++			ipmb_addr->lun = pImbReq->req.rsLun;
++			ipmb_addr->channel = 0;
++		}
++
++		if (pImbReq->flags & NO_RESPONSE_EXPECTED) {
++			spin_lock(&priv->imb_lock);
++			msgid = priv->curr_msgid;
++			(priv->curr_msgid)++;
++			spin_unlock(&priv->imb_lock);
++		} else {
++			msgid = 0;
++		}
++
++		msg.netfn = pImbReq->req.netFn;
++		msg.cmd = pImbReq->req.cmd;
++		msg.data = pImbReq->req.data;
++		msg.data_len = pImbReq->req.dataLength;
++		rv = ipmi_request(priv->imb_user,
++				  &addr,
++				  msgid,
++				  &msg,
++				  0);
++		if (rv) {
++			rv = IMB_SEND_REQUEST_FAILED;
++			goto copy_resp;
++		}
++
++		if (pImbReq->flags & NO_RESPONSE_EXPECTED)
++			goto no_response;
++
++		/* Now wait for the response to come back. */
++		spin_lock_irqsave(&(priv->imb_lock), flags);
++		init_waitqueue_entry(&wait, current);
++		add_wait_queue(&(priv->imb_waiting_rsp_rcvrs),
++			       &wait);
++		for (;;) {
++			/* Check to see if it's there. */
++			if (!list_empty(&(priv->imb_waiting_rsps))) {
++				entry = priv->imb_waiting_rsps.next;
++				list_del(entry);
++				rsp = list_entry(entry,
++						 struct ipmi_recv_msg,
++						 link);
++				if (rsp->msgid != msgid) {
++					ipmi_free_recv_msg(rsp);
++					rsp = NULL;
++				} else {
++					break;
++				}
++			}
++
++			set_current_state(TASK_INTERRUPTIBLE);
++			if (!signal_pending(current)) {
++				spin_unlock_irqrestore
++					(&(priv->imb_lock), flags);
++				schedule();
++				spin_lock_irqsave
++					(&(priv->imb_lock), flags);
++			} else {
++				rv = -ERESTARTSYS;
++				break;
++			}
++		}
++		remove_wait_queue(&(priv->imb_waiting_rsp_rcvrs),
++				  &wait);
++		spin_unlock_irqrestore(&(priv->imb_lock), flags);
++
++	copy_resp:
++		if (rsp != NULL) {
++			pImbResp->cCode = rsp->msg.data[0];
++			memcpy(pImbResp->data,
++			       rsp->msg.data+1,
++			       rsp->msg.data_len-1);
++			length = (rsp->msg.data_len - 1
++				  + MIN_IMB_RESP_BUF_SIZE);
++
++			if (copy_to_user(smi.lpvOutBuffer, pImbResp, length)) {
++				return -EFAULT;
++			}
++
++			if (copy_to_user(smi.lpcbBytesReturned,
++					 &length,
++					 sizeof(length)))
++			{
++				return -EFAULT;
++			}
++		}
++	no_response:
++		break;
++	}
++
++	case IOCTL_IMB_SHUTDOWN_CODE:
++	{
++		ShutdownCmdBuffer shutdownCmd;
++
++		if (copy_from_user(&shutdownCmd,
++				   smi.lpvInBuffer, 
++				   sizeof(ShutdownCmdBuffer)))
++		{
++			return -EFAULT;
++		}
++
++		if (smi.cbInBuffer < sizeof(ShutdownCmdBuffer))
++		{
++			return -EINVAL;
++		}
++
++		rv = 0;
++		switch (shutdownCmd.code) {
++		case SD_POWER_OFF:
++			ipmi_delayed_shutdown(shutdownCmd.delayTime / 10, 1);
++			break;
++
++		case SD_RESET:
++			ipmi_delayed_shutdown(shutdownCmd.delayTime / 10, 0);
++			break;
++
++		case SD_NO_ACTION:
++			break;
++
++		default:
++			rv = INVALID_ARGUMENTS;
++		}
++
++        }
++
++	case IOCTL_IMB_REGISTER_ASYNC_OBJ:
++		rv = STATUS_SUCCESS;
++		break;
++
++
++	case IOCTL_IMB_CHECK_EVENT:
++	{
++		wait_queue_t wait;
++
++		spin_lock_irqsave(&(priv->imb_lock), flags);
++		init_waitqueue_entry(&wait, current);
++		add_wait_queue(&(priv->imb_waiting_cmd_rcvrs),
++			       &wait);
++		while (!list_empty(&(priv->imb_waiting_cmds))) {
++			set_current_state(TASK_INTERRUPTIBLE);
++			if (!signal_pending(current)) {
++				spin_unlock_irqrestore
++					(&(priv->imb_lock), flags);
++				schedule();
++				spin_lock_irqsave
++					(&(priv->imb_lock), flags);
++			} else {
++				rv = -ERESTARTSYS;
++				break;
++			}
++		}
++		remove_wait_queue(&(priv->imb_waiting_cmd_rcvrs),
++				  &wait);
++		spin_unlock_irqrestore(&(priv->imb_lock), flags);
++		rv = 0;
++		break;
++	}
++	}
++
++	return rv;
++}
++
++static int ipmi_imb_mmap(struct file *file, struct vm_area_struct *vma)
++{
++    off_t offset = vma->vm_pgoff << PAGE_SHIFT;
++
++    if (offset < 0)
++	    return -EINVAL;
++
++    if (remap_page_range(vma->vm_start, offset, 
++			 vma->vm_end - vma->vm_start,
++			 vma->vm_page_prot))
++    {
++	    return -EAGAIN;
++    }
++
++    /*vma->vm_inode = what_goes_here; */
++
++    return 0;
++
++}
++
++
++static struct file_operations ipmi_fops = {
++	owner:   THIS_MODULE,
++	ioctl:   ipmi_imb_ioctl,
++	open:    ipmi_imb_open,
++	release: ipmi_imb_release,
++	mmap:    ipmi_imb_mmap
++};
++
++static struct timer_list ipmi_imb_timer;
++
++/* Call every 100 ms. */
++#define IPMI_TIMEOUT_TIME	100
++#define IPMI_TIMEOUT_JIFFIES	(IPMI_TIMEOUT_TIME/(1000/HZ))
++
++static volatile int stop_operation = 0;
++static volatile int timer_stopped = 0;
++
++static void ipmi_imb_timeout(unsigned long data)
++{
++	struct list_head     *entry, *entry2;
++	struct priv_data     *priv = (struct priv_data *) data;
++	int                  timeout_period = IPMI_TIMEOUT_TIME;
++	struct ipmi_recv_msg *msg;
++
++	if (stop_operation) {
++		timer_stopped = 1;
++		return;
++	}
++
++	/* Now time out any messages in the Imb message queue. */
++	spin_lock(&(priv->imb_lock));
++	list_for_each_safe(entry, entry2, &(priv->imb_waiting_rsps)) {
++		long *timeout;
++		msg = list_entry(entry, struct ipmi_recv_msg, link);
++		timeout = imb_timeout(msg);
++		*timeout -= timeout_period;
++		if ((*timeout) <= 0) {
++			list_del(entry);
++			ipmi_free_recv_msg(msg);
++		}
++	}
++	list_for_each_safe(entry, entry2, &(priv->imb_waiting_cmds)) {
++		long *timeout;
++		msg = list_entry(entry, struct ipmi_recv_msg, link);
++		timeout = imb_timeout(msg);
++		*timeout -= timeout_period;
++		if ((*timeout) <= 0) {
++			list_del(entry);
++			ipmi_free_recv_msg(msg);
++		}
++	}
++	spin_unlock(&priv->imb_lock);
++
++	ipmi_imb_timer.expires += IPMI_TIMEOUT_JIFFIES;
++	add_timer(&ipmi_imb_timer);
++}
++
++#define DEVICE_NAME     "imb"
++
++static int ipmi_imb_major = 0;
++MODULE_PARM(ipmi_imb_major, "i");
++
++static struct ipmi_user_hndl ipmi_hndlrs =
++{
++	ipmi_recv_hndl : imb_msg_recv
++};
++
++static int init_ipmi_imb(void)
++{
++	int rv;
++
++	if (ipmi_imb_major < 0)
++		return -EINVAL;
++
++	ipmi_user = kmalloc(sizeof(*ipmi_user), GFP_KERNEL);
++	if (!ipmi_user) {
++		return -ENOMEM;
++	}
++
++	/* Create the Imb interface user. */
++	spin_lock_init(&(ipmi_user->imb_lock));
++	INIT_LIST_HEAD(&(ipmi_user->imb_waiting_rsps));
++	init_waitqueue_head(&(ipmi_user->imb_waiting_rsp_rcvrs));
++	INIT_LIST_HEAD(&(ipmi_user->imb_waiting_cmds));
++	init_waitqueue_head(&(ipmi_user->imb_waiting_cmd_rcvrs));
++	ipmi_user->imb_cmd_waiting = 0;
++	INIT_LIST_HEAD(&(ipmi_user->imb_waiting_events));
++
++	rv = ipmi_create_user(0,
++			      &ipmi_hndlrs,
++			      ipmi_user,
++			      &(ipmi_user->imb_user));
++	if (rv) {
++		kfree(ipmi_user);
++		ipmi_user = NULL;
++		return rv;
++	}
++
++	rv = register_chrdev(ipmi_imb_major, DEVICE_NAME, &ipmi_fops);
++	if (rv < 0) 
++	{
++		kfree(ipmi_user);
++		ipmi_user = NULL;
++		printk(KERN_ERR "ipmi: can't get major %d\n",
++		       ipmi_imb_major);
++		return rv;
++	}
++
++	if (ipmi_imb_major == 0) 
++	{
++		ipmi_imb_major = rv;
++	}
++
++	devfs_handle = devfs_register(NULL, DEVICE_NAME, DEVFS_FL_NONE,
++				      ipmi_imb_major, 0,
++				      S_IFCHR | S_IRUSR | S_IWUSR,
++				      &ipmi_fops, NULL);
++
++	ipmi_imb_timer.data = (long) ipmi_user;
++	ipmi_imb_timer.function = ipmi_imb_timeout;
++	ipmi_imb_timer.expires = jiffies + IPMI_TIMEOUT_JIFFIES;
++	add_timer(&ipmi_imb_timer);
++
++	printk(KERN_INFO "ipmi_imb: driver initialized at char major %d\n",
++	       ipmi_imb_major);
++
++	return 0;
++}
++
++#ifdef MODULE
++static void free_recv_msg_list(struct list_head *q)
++{
++	struct list_head     *entry, *entry2;
++	struct ipmi_recv_msg *msg;
++
++	list_for_each_safe(entry, entry2, q) {
++		msg = list_entry(entry, struct ipmi_recv_msg, link);
++		list_del(entry);
++		ipmi_free_recv_msg(msg);
++	}
++}
++
++static void cleanup_ipmi_imb(void)
++{
++	devfs_unregister(devfs_handle);
++
++	/* Tell the timer to stop, then wait for it to stop.  This avoids
++	   problems with race conditions removing the timer here. */
++	stop_operation = 1;
++	while (!timer_stopped) {
++		schedule_timeout(1);
++	}
++
++	ipmi_destroy_user(ipmi_user->imb_user);
++
++	free_recv_msg_list(&(ipmi_user->imb_waiting_rsps));
++	free_recv_msg_list(&(ipmi_user->imb_waiting_cmds));
++	free_recv_msg_list(&(ipmi_user->imb_waiting_events));
++
++	kfree(ipmi_user);
++	ipmi_user = NULL;
++
++	unregister_chrdev(ipmi_imb_major, DEVICE_NAME);
++}
++module_exit(cleanup_ipmi_imb);
++#else
++static int __init ipmi_imb_setup (char *str)
++{
++	int x;
++
++	if (get_option (&str, &x)) {
++		/* ipmi=x sets the major number to x. */
++		ipmi_imb_major = x;
++	} else if (!strcmp(str, "off")) {
++		ipmi_imb_major = -1;
++	}
++
++	return 1;
++}
++__setup("ipmi_imb=", ipmi_imb_setup);
++#endif
++
++module_init(init_ipmi_imb);
++MODULE_LICENSE("GPL");
+--- /dev/null	2002-08-30 19:31:37.000000000 -0400
++++ linux-2.4.18-14/drivers/char/ipmi/ipmi_radisys.c	2003-03-27 15:32:59.000000000 -0500
+@@ -0,0 +1,834 @@
++/*
++ * ipmi_radisys.c
++ *
++ * Radisys emulation for the IPMI interface.
++ *
++ * Author: MontaVista Software, Inc.
++ *         Corey Minyard <minyard@mvista.com>
++ *         source@mvista.com
++ *
++ * Copyright 2002 MontaVista Software Inc.
++ *
++ *  This program is free software; you can redistribute it and/or modify it
++ *  under the terms of the GNU General Public License as published by the
++ *  Free Software Foundation; either version 2 of the License, or (at your
++ *  option) any later version.
++ *
++ *
++ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
++ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
++ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
++ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
++ *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
++ *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
++ *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
++ *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ *
++ *  You should have received a copy of the GNU General Public License along
++ *  with this program; if not, write to the Free Software Foundation, Inc.,
++ *  675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/errno.h>
++#include <asm/system.h>
++#include <linux/sched.h>
++#include <linux/poll.h>
++#include <linux/spinlock.h>
++#include <linux/slab.h>
++#include <linux/devfs_fs_kernel.h>
++#include <linux/ipmi.h>
++#include <linux/ipmi_radisys.h>
++
++
++struct priv_data
++{
++	/* This is for supporting the old Radisys interface. */
++	ipmi_user_t       rs_user;
++	spinlock_t        rs_lock;
++
++	/* A list of responses in the queue. */
++	struct list_head  rs_waiting_rsps;
++
++	/* A list of things waiting for responses.  We wake them all up
++	   when a response comes in. */
++	wait_queue_head_t rs_waiting_rsp_rcvrs;
++
++	/* A list of commands that have come in. */
++	struct list_head  rs_waiting_cmds;
++
++	/* A list of thing waiting for commands.  We wake them all up
++	   when a command comes in. */
++	wait_queue_head_t rs_waiting_cmd_rcvrs;
++
++	/* The registered command receiver value.  This only allows someone
++	   with the "magic number" to issue commands. */
++	unsigned long     rs_cmd_receiver;
++
++	/* Is someone already waiting for a command?  The Radisys driver
++	   only allows one waiter, this enforces that. */
++	int               rs_cmd_waiting;
++
++	/* A list of IPMI events waiting to be delivered.  (not that
++           the Radisys driver calls incoming commands "events", this
++           variable is actual IPMI events, not incoming commands). */
++	struct list_head  rs_waiting_events;
++
++#define RS_EVENT_QUEUE_LIMIT	16 /* Allow up to 16 events. */
++	/* The number of events in the event queue. */
++	unsigned int      rs_waiting_event_count;
++};
++
++
++static devfs_handle_t devfs_handle;
++
++/* We cheat and use a piece of the address as the timeout. */
++static long *rs_timeout(struct ipmi_recv_msg *msg)
++{
++	char *base = (char *) &(msg->addr);
++	base += sizeof(struct ipmi_ipmb_addr);
++	return (long *) base;
++}
++
++static void rs_msg_recv(struct ipmi_recv_msg *msg,
++			void                 *data)
++{
++	struct priv_data *priv = data;
++	unsigned long    flags;
++
++	spin_lock_irqsave(&(priv->rs_lock), flags);
++	if (msg->recv_type == IPMI_RESPONSE_RECV_TYPE) {
++		*rs_timeout(msg) = 5000;
++		list_add_tail(&(msg->link), &(priv->rs_waiting_rsps));
++		wake_up_all(&(priv->rs_waiting_rsp_rcvrs));
++	} else if (msg->recv_type == IPMI_CMD_RECV_TYPE) {
++		*rs_timeout(msg) = 5000;
++		list_add_tail(&(msg->link), &(priv->rs_waiting_cmds));
++		wake_up_all(&(priv->rs_waiting_cmd_rcvrs));
++	} else if (msg->recv_type == IPMI_ASYNC_EVENT_RECV_TYPE) {
++		if (priv->rs_waiting_event_count > RS_EVENT_QUEUE_LIMIT) {
++			ipmi_free_recv_msg(msg);
++		} else {
++			list_add_tail(&(msg->link),&(priv->rs_waiting_events));
++			(priv->rs_waiting_event_count)++;
++		}
++	} else {
++		ipmi_free_recv_msg(msg);
++	}
++	spin_unlock_irqrestore(&(priv->rs_lock), flags);
++}
++
++/* We emulate the event queue in the driver for the Radisys emulation. */
++static int rs_handle_event_request(struct priv_data *priv)
++{
++	struct list_head     *entry;
++	unsigned long        flags;
++	struct ipmi_recv_msg *msg = NULL;
++	int                  rv = 0;
++
++	spin_lock_irqsave(&(priv->rs_lock), flags);
++	if (list_empty(&(priv->rs_waiting_events))) {
++		/* Nothing in the event queue, just return an error. */
++		msg = ipmi_alloc_recv_msg();
++		if (msg == NULL) {
++			rv = -EAGAIN;
++			goto out_err;
++		}
++		msg->addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
++		msg->addr.channel = IPMI_BMC_CHANNEL;
++		msg->msg.cmd = IPMI_READ_EVENT_MSG_BUFFER_CMD;
++		msg->msgid = 0;
++		msg->recv_type = IPMI_ASYNC_EVENT_RECV_TYPE;
++		msg->msg.netfn = IPMI_NETFN_APP_RESPONSE;
++		msg->msg.data = msg->msg_data;
++		msg->msg.data[0] = 0x80; /* Data not available. */
++		msg->msg.data_len = 1;
++	} else {
++		/* Pull an item from the event queue . */
++		entry = priv->rs_waiting_events.next;
++		list_del(entry);
++		msg = list_entry(entry, struct ipmi_recv_msg, link);
++		(priv->rs_waiting_event_count)--;
++	}
++
++	/* Put the response into the list of waiting responses and
++           wake all the response waiters up. */
++	*rs_timeout(msg) = 5000;
++	list_add_tail(&(msg->link), &(priv->rs_waiting_rsps));
++	wake_up_all(&(priv->rs_waiting_rsp_rcvrs));
++
++ out_err:
++	spin_unlock_irqrestore(&(priv->rs_lock), flags);
++	return rv;
++}
++
++static struct ipmi_recv_msg *rs_find_in_list(struct list_head *q,
++					     unsigned char    slave_addr,
++					     unsigned char    lun,
++					     unsigned char    netfn,
++					     unsigned char    cmd,
++					     unsigned char    seq)
++{
++	struct list_head      *entry;
++	struct ipmi_recv_msg  *msg;
++	struct ipmi_addr      addr;
++	unsigned char         msg_seq;
++
++	if (slave_addr == 1) {
++		struct ipmi_system_interface_addr *smi_addr;
++		smi_addr = (struct ipmi_system_interface_addr *) &addr;
++		smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
++		smi_addr->lun = lun;
++		/* Slave address 1 means no matching sequence in the
++                   Radisys driver. */
++	} else {
++		struct ipmi_ipmb_addr *ipmb_addr;
++		ipmb_addr = (struct ipmi_ipmb_addr *) &addr;
++		ipmb_addr->addr_type = IPMI_IPMB_ADDR_TYPE;
++		ipmb_addr->slave_addr = slave_addr;
++		ipmb_addr->lun = lun;
++	}
++
++	list_for_each(entry, q) {
++		msg = list_entry(entry, struct ipmi_recv_msg, link);
++		if (msg->addr.channel == IPMI_BMC_CHANNEL)
++			msg_seq = 0;
++		else
++			msg_seq = msg->msgid;
++
++		/* We ignore the channel for these comparisons, since the
++		   Radisys driver seems to ignore it. */
++		addr.channel = msg->addr.channel;
++
++		if ((msg_seq == seq)
++		    && (msg->msg.cmd == cmd)
++		    && (msg->msg.netfn == (netfn >> 2))
++		    && ipmi_addr_equal(&addr, &(msg->addr)))
++		{
++			list_del(entry);
++			return msg;
++		}
++	}
++
++	return NULL;
++}
++
++static struct priv_data *ipmi_user;
++static unsigned int user_count = 0; /* How many users have this open. */
++static spinlock_t dev_lock = SPIN_LOCK_UNLOCKED;
++
++static int ipmi_open(struct inode *inode, struct file *file)
++{
++	file->private_data = ipmi_user;
++	spin_lock(&dev_lock);
++	if (user_count == 0)
++		ipmi_set_gets_events(ipmi_user->rs_user, 1);
++	user_count++;
++	spin_unlock(&dev_lock);
++
++	return 0;
++}
++
++static int ipmi_release(struct inode *inode, struct file *file)
++{
++	spin_lock(&dev_lock);
++	user_count--;
++	if (user_count == 0)
++		ipmi_set_gets_events(ipmi_user->rs_user, 0);
++	spin_unlock(&dev_lock);
++	return 0;
++}
++
++static unsigned char
++ipmb_checksum(unsigned char *data, int size)
++{
++	unsigned char csum = 0;
++	
++	for (; size > 0; size--, data++)
++		csum += *data;
++
++	return -csum;
++}
++
++static int ipmi_ioctl(struct inode  *inode,
++		      struct file   *file,
++		      unsigned int  cmd,
++		      unsigned long data)
++{
++	struct priv_data *priv = file->private_data;
++	int              rv = -EINVAL;
++
++	switch(cmd) {
++	case IOCTL_IPMI_RCV:   /* get ipmi message */
++	{
++		IPMI_MSGDESC         rsp;
++		struct ipmi_recv_msg *msg;
++		unsigned long        flags;
++		long                 timeout;
++		wait_queue_t         wait;
++
++		if (copy_from_user(&rsp, (void *) data, sizeof(rsp))) {
++			rv = -EFAULT;
++			break;
++		}
++
++		rv = 0;
++
++		spin_lock_irqsave(&(priv->rs_lock), flags);
++
++		msg = rs_find_in_list(&(priv->rs_waiting_rsps),
++				      rsp.Dest.uchSlave,
++				      rsp.Dest.uchLun,
++				      rsp.uchNetFn,
++				      rsp.uchCmd,
++				      rsp.uchSeq);
++		init_waitqueue_entry(&wait, current);
++		add_wait_queue(&(priv->rs_waiting_rsp_rcvrs),
++			       &wait);
++		timeout = 5000 / (1000 / HZ);
++		while (msg == NULL) {
++			set_current_state(TASK_INTERRUPTIBLE);
++			if (!signal_pending(current)) {
++				spin_unlock_irqrestore
++					(&(priv->rs_lock), flags);
++				timeout = schedule_timeout(timeout);
++				spin_lock_irqsave
++					(&(priv->rs_lock), flags);
++			} else {
++				rv = -ERESTARTSYS;
++				break;
++			}
++			if (timeout <= 0) {
++				rsp.uchComplete = IPMI_TIMEOUT_COMPLETION_CODE;
++				break;
++			} else {
++				msg = rs_find_in_list
++					(&(priv->rs_waiting_rsps),
++					 rsp.Dest.uchSlave,
++					 rsp.Dest.uchLun,
++					 rsp.uchNetFn,
++					 rsp.uchCmd,
++					 rsp.uchSeq);
++			}
++		}
++		remove_wait_queue(&(priv->rs_waiting_rsp_rcvrs),
++				  &wait);
++		spin_unlock_irqrestore(&(priv->rs_lock), flags);
++
++		if (msg != NULL) {
++			rsp.uchComplete = msg->msg.data[0];
++			/* The Radisys driver expects all the data to
++			   be there in the data, even the stuff we
++			   already have processed for it.  So make is
++			   so. */
++			if (msg->addr.channel == IPMI_BMC_CHANNEL) {
++				struct ipmi_system_interface_addr *smi_addr;
++
++				smi_addr = ((struct ipmi_system_interface_addr *)
++					    &(msg->addr));
++				memcpy(&(rsp.auchBuffer[2]),
++				       &(msg->msg.data[0]),
++				       msg->msg.data_len);
++				rsp.ulLength = msg->msg.data_len+2;
++				rsp.auchBuffer[0] = ((msg->msg.netfn << 2)
++						     | (smi_addr->lun));
++				rsp.auchBuffer[1] = msg->msg.cmd;
++			} else {
++				struct ipmi_ipmb_addr *ipmb_addr;
++
++				ipmb_addr = (struct ipmi_ipmb_addr *) &msg->addr;
++				memcpy(&(rsp.auchBuffer[9]),
++				       &(msg->msg.data[0]),
++				       msg->msg.data_len);
++				rsp.ulLength = msg->msg.data_len+10;
++				rsp.auchBuffer[0] = IPMI_NETFN_APP_REQUEST << 2;
++				rsp.auchBuffer[1] = IPMI_GET_MSG_CMD;
++				rsp.auchBuffer[2] = 0;
++				rsp.auchBuffer[3] = msg->addr.channel;
++				rsp.auchBuffer[4] = ((msg->msg.netfn << 2)
++						     | 2);
++				rsp.auchBuffer[5]
++					= ipmb_checksum(&(rsp.auchBuffer[3]),
++							2);
++				rsp.auchBuffer[6] = ipmb_addr->slave_addr;
++				rsp.auchBuffer[7] = ((msg->msgid << 2)
++						     | ipmb_addr->lun);
++				rsp.auchBuffer[8] = msg->msg.cmd;
++				rsp.auchBuffer[msg->msg.data_len+9]
++					= ipmb_checksum(&(rsp.auchBuffer[6]),
++							msg->msg.data_len+3);
++			}
++			ipmi_free_recv_msg(msg);
++		}
++
++		if (copy_to_user((void *) data, &rsp, sizeof(rsp))) {
++			rv = -EFAULT;
++			break;
++		}
++
++		break;
++	}
++     
++	case IOCTL_IPMI_SEND: /* send ipmi message */
++	{
++		IPMI_MSGDESC     req;
++		struct ipmi_addr addr;
++		struct ipmi_msg  msg;
++		unsigned char    source_address;
++		unsigned char    source_lun;
++		unsigned int     start_offset;
++
++		if (copy_from_user(&req, (void *) data, sizeof(req))) {
++			rv = -EFAULT;
++			break;
++		}
++
++		if (req.Dest.uchSlave == 1) {
++			struct ipmi_system_interface_addr *smi_addr
++				= (struct ipmi_system_interface_addr *) &addr;
++			if ((req.uchNetFn == (IPMI_NETFN_APP_REQUEST << 2))
++			    && (req.uchCmd == IPMI_READ_EVENT_MSG_BUFFER_CMD))
++			{
++				/* The driver gets event messages
++                                   automatically, so we emulate
++                                   this. */
++				rv = rs_handle_event_request(priv);
++				break;
++			}
++
++			smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
++			smi_addr->channel = IPMI_BMC_CHANNEL;
++			smi_addr->lun = req.uchNetFn & 0x3;
++			source_address = 0;
++			source_lun = 0;
++			start_offset = 2;
++		} else {
++			struct ipmi_ipmb_addr *ipmb_addr =
++				(struct ipmi_ipmb_addr *) &addr;
++			
++			ipmb_addr->addr_type = IPMI_IPMB_ADDR_TYPE;
++			ipmb_addr->channel = 0;
++			ipmb_addr->slave_addr = req.Dest.uchSlave;
++			ipmb_addr->lun = req.Dest.uchLun;
++			source_address = req.auchBuffer[6];
++			source_lun = req.auchBuffer[7] & 0x3;
++			start_offset = 9;
++			req.ulLength--; /* Remove the checksum the userland
++					   process adds. */
++		}
++
++		msg.netfn = req.uchNetFn >> 2;
++		msg.cmd = req.uchCmd;
++		msg.data = req.auchBuffer + start_offset;
++		msg.data_len = req.ulLength - start_offset;
++
++		rv = ipmi_request_with_source(priv->rs_user,
++					      &addr,
++					      req.uchSeq,
++					      &msg,
++					      0,
++					      source_address,
++					      source_lun);
++		if (rv)
++			req.uchComplete = IPMI_UNKNOWN_ERR_COMPLETION_CODE;
++		else
++			req.uchComplete = 0;
++		/* The Radisys driver does no error checking here. */
++		copy_to_user((void *) data, &req, sizeof(req));
++		rv = 0;
++		break;
++	}
++
++	case IOCTL_IPMI_EVENT:  /* get an incoming command.  Don't be
++                                   fooled by the name, these are
++                                   commands, not IPMI events. */
++	{
++		IPMI_MSGDESC         rsp;
++		struct ipmi_recv_msg *msg = NULL;
++		struct list_head     *entry;
++		unsigned long        flags;
++		long                 timeout;
++		unsigned long        receiver;
++		wait_queue_t         wait;
++
++		if (copy_from_user(&receiver, (void *) data, sizeof(receiver)))
++		{
++			rv = -EFAULT;
++			break;
++		}
++
++		if (copy_from_user(&timeout,
++				   (void *) (data + sizeof(receiver)),
++				   sizeof(timeout)))
++		{
++			rv = -EFAULT;
++			break;
++		}
++
++		rv = 0;
++
++		spin_lock_irqsave(&(priv->rs_lock), flags);
++
++		/* If someone else is already waiting, the Radisys driver
++		   returns EFAULT, so we do to. */
++		if (priv->rs_cmd_waiting) {
++			spin_unlock_irqrestore(&(priv->rs_lock), flags);
++			rv = -EFAULT;
++			break;
++		}
++
++		/* If the user thread doesn't match up, abort. */
++		if (receiver != priv->rs_cmd_receiver) {
++			spin_unlock_irqrestore(&(priv->rs_lock), flags);
++			rsp.uchComplete = IPMI_INVALID_CMD_COMPLETION_CODE;
++			break;
++		}
++
++		init_waitqueue_entry(&wait, current);
++		add_wait_queue(&(priv->rs_waiting_cmd_rcvrs),
++			       &wait);
++		priv->rs_cmd_waiting = 1;
++		timeout = timeout / (1000 / HZ); /* from ms to jiffies */
++		while ((timeout > 0) &&
++		       list_empty(&(priv->rs_waiting_cmds)))
++		{
++			set_current_state(TASK_INTERRUPTIBLE);
++			if (!signal_pending(current)) {
++				spin_unlock_irqrestore
++					(&(priv->rs_lock), flags);
++				timeout = schedule_timeout(timeout);
++				spin_lock_irqsave
++					(&(priv->rs_lock), flags);
++			} else {
++				rv = -ERESTARTSYS;
++				break;
++			}
++		}
++		if (!list_empty(&(priv->rs_waiting_cmds))) {
++			entry = priv->rs_waiting_cmds.next;
++			list_del(entry);
++			msg = list_entry(entry, struct ipmi_recv_msg, link);
++		}
++		priv->rs_cmd_waiting = 0;
++		remove_wait_queue(&(priv->rs_waiting_cmd_rcvrs),
++				  &wait);
++		spin_unlock_irqrestore(&(priv->rs_lock), flags);
++
++		if (msg != NULL) {
++			/* The Radisys driver expects all the data to
++			   be there in the data, even the stuff we
++			   already have processed for it.  So make is
++			   so. */
++			struct ipmi_ipmb_addr *ipmb_addr;
++
++			ipmb_addr = (struct ipmi_ipmb_addr *) &msg->addr;
++			memcpy(&(rsp.auchBuffer[9]),
++			       &(msg->msg.data[0]),
++			       msg->msg.data_len);
++			rsp.ulLength = msg->msg.data_len+9;
++			rsp.auchBuffer[0] = IPMI_NETFN_APP_REQUEST << 2;
++			rsp.auchBuffer[1] = IPMI_SEND_MSG_CMD;
++			rsp.auchBuffer[2] = 0;
++			rsp.auchBuffer[3] = msg->addr.channel;
++			rsp.auchBuffer[4] = ((msg->msg.netfn << 2)
++					     | 2);
++			rsp.auchBuffer[5]
++				= ipmb_checksum(&(rsp.auchBuffer[3]),
++						2);
++			rsp.auchBuffer[6] = ipmb_addr->slave_addr;
++			rsp.auchBuffer[7] = ((msg->msgid << 2)
++					     | ipmb_addr->lun);
++			rsp.auchBuffer[8] = msg->msg.cmd;
++
++			rsp.uchNetFn = (msg->msg.netfn << 2);
++			rsp.uchCmd = msg->msg.cmd;
++			rsp.uchSeq = msg->msgid;
++			rsp.ulLength = msg->msg.data_len + 9;
++			ipmi_free_recv_msg(msg);
++		} else if (!rv) {
++			/* On a time out, the Radisys driver returns
++			   IPMIRC_ERROR in the completion code, for
++			   some wierd reason. */
++			rsp.uchComplete = IPMI_UNKNOWN_ERR_COMPLETION_CODE;
++		}
++
++		/* The Radisys driver does no error checking here. */
++		copy_to_user((void *) data, &rsp, sizeof(rsp));
++		rv = 0;
++		break;
++	}
++    
++	case IOCTL_IPMI_REGISTER: /* register as event receiver */
++	{
++		unsigned long receiver;
++		unsigned char rc = LOWLRC_SUCCESS;
++		unsigned long flags;
++
++		if (copy_from_user(&receiver, (void *) data, sizeof(receiver)))
++		{
++			rv = -EFAULT;
++			break;
++		}
++
++		spin_lock_irqsave(&(priv->rs_lock), flags);
++		if (priv->rs_cmd_receiver == 0) {
++			rv = ipmi_register_all_cmd_rcvr(priv->rs_user);
++			if (rv)	{
++				priv->rs_cmd_receiver = receiver;
++			} else {
++				rc = LOWLRC_ERROR;
++			}
++		} else if (priv->rs_cmd_receiver != receiver) {
++			rc = LOWLRC_ERROR;
++		}
++		spin_unlock_irqrestore(&(priv->rs_lock), flags);
++
++		/* The Radisys driver does no error checking here. */
++		copy_to_user((void *) data, &rc, sizeof(rc));
++		rv = 0;
++		break;
++	}
++    
++	case IOCTL_IPMI_UNREGISTER:   /* unregister as event receiver */
++	{
++		unsigned long receiver;
++		unsigned char rc = LOWLRC_SUCCESS;
++		unsigned long flags;
++
++		if (copy_from_user(&receiver, (void *) data, sizeof(receiver)))
++		{
++			rv = -EFAULT;
++			break;
++		}
++
++		spin_lock_irqsave(&(priv->rs_lock), flags);
++		if (priv->rs_cmd_receiver == receiver) {
++			ipmi_unregister_all_cmd_rcvr(priv->rs_user);
++			priv->rs_cmd_receiver = 0;
++		} else {
++			rc = LOWLRC_ERROR;
++		}
++		spin_unlock_irqrestore(&(priv->rs_lock), flags);
++
++		/* The Radisys driver does no error checking here. */
++		copy_to_user((void *) data, &rc, sizeof(rc));
++		rv = 0;
++		break;
++	}
++
++	case IOCTL_IPMI_CLEAR: /* clear registered event receiver */
++	{
++		unsigned char rc = LOWLRC_SUCCESS;
++		unsigned long flags;
++
++		spin_lock_irqsave(&(priv->rs_lock), flags);
++		ipmi_unregister_all_cmd_rcvr(priv->rs_user);
++		priv->rs_cmd_receiver = 0;
++		spin_unlock_irqrestore(&(priv->rs_lock), flags);
++
++		/* The Radisys driver does no error checking here. */
++		copy_to_user((void *) data, &rc, sizeof(rc));
++		rv = 0;
++		break;
++	}
++	}
++
++	return rv;
++}
++
++static struct file_operations ipmi_fops = {
++	owner:   THIS_MODULE,
++	ioctl:   ipmi_ioctl,
++	open:    ipmi_open,
++	release: ipmi_release
++};
++
++static struct timer_list ipmi_radisys_timer;
++
++/* Call every 100 ms. */
++#define IPMI_TIMEOUT_TIME	100
++#define IPMI_TIMEOUT_JIFFIES	(IPMI_TIMEOUT_TIME/(1000/HZ))
++
++/* Request events from the queue every second.  Hopefully, in the
++   future, IPMI will add a way to know immediately if an event is
++   in the queue. */
++#define IPMI_REQUEST_EV_TIME	(1000 / (IPMI_TIMEOUT_TIME))
++
++static volatile int stop_operation = 0;
++static volatile int timer_stopped = 0;
++
++static void ipmi_radisys_timeout(unsigned long data)
++{
++	struct list_head     *entry, *entry2;
++	struct priv_data     *priv = (struct priv_data *) data;
++	int                  timeout_period = IPMI_TIMEOUT_TIME;
++	struct ipmi_recv_msg *msg;
++
++	if (stop_operation) {
++		timer_stopped = 1;
++		return;
++	}
++
++	/* Now time out any messages in the Radisys message queue. */
++	spin_lock(&(priv->rs_lock));
++	list_for_each_safe(entry, entry2, &(priv->rs_waiting_rsps)) {
++		long *timeout;
++		msg = list_entry(entry, struct ipmi_recv_msg, link);
++		timeout = rs_timeout(msg);
++		*timeout -= timeout_period;
++		if ((*timeout) <= 0) {
++			list_del(entry);
++			ipmi_free_recv_msg(msg);
++		}
++	}
++	list_for_each_safe(entry, entry2, &(priv->rs_waiting_cmds)) {
++		long *timeout;
++		msg = list_entry(entry, struct ipmi_recv_msg, link);
++		timeout = rs_timeout(msg);
++		*timeout -= timeout_period;
++		if ((*timeout) <= 0) {
++			list_del(entry);
++			ipmi_free_recv_msg(msg);
++		}
++	}
++	spin_unlock(&priv->rs_lock);
++
++	ipmi_radisys_timer.expires += IPMI_TIMEOUT_JIFFIES;
++	add_timer(&ipmi_radisys_timer);
++}
++
++#define DEVICE_NAME     "ipmi_radisys"
++
++static int ipmi_radisys_major = 0;
++MODULE_PARM(ipmi_radisys_major, "i");
++
++static struct ipmi_user_hndl ipmi_hndlrs =
++{
++	ipmi_recv_hndl : rs_msg_recv
++};
++
++
++static int init_ipmi_radisys(void)
++{
++	int rv;
++
++	if (ipmi_radisys_major < 0)
++		return -EINVAL;
++
++	ipmi_user = kmalloc(sizeof(*ipmi_user), GFP_KERNEL);
++	if (!ipmi_user) {
++		printk("ipmi_radisys: Unable to allocate memory\n");
++		return -ENOMEM;
++	}
++
++	/* Create the Radisys interface user. */
++	spin_lock_init(&(ipmi_user->rs_lock));
++	INIT_LIST_HEAD(&(ipmi_user->rs_waiting_rsps));
++	init_waitqueue_head(&(ipmi_user->rs_waiting_rsp_rcvrs));
++	INIT_LIST_HEAD(&(ipmi_user->rs_waiting_cmds));
++	init_waitqueue_head(&(ipmi_user->rs_waiting_cmd_rcvrs));
++	ipmi_user->rs_cmd_waiting = 0;
++	INIT_LIST_HEAD(&(ipmi_user->rs_waiting_events));
++
++	rv = ipmi_create_user(0,
++			      &ipmi_hndlrs,
++			      ipmi_user,
++			      &(ipmi_user->rs_user));
++	if (rv) {
++		printk("ipmi_radisys: Unable to create an IPMI user, probably"
++		       " no physical devices present.\n");
++		kfree(ipmi_user);
++		ipmi_user = NULL;
++		return rv;
++	}
++
++	rv = register_chrdev(ipmi_radisys_major, DEVICE_NAME, &ipmi_fops);
++	if (rv < 0) 
++	{
++		printk("ipmi_radisys: Unable to create the character device\n");
++		kfree(ipmi_user);
++		ipmi_user = NULL;
++		printk(KERN_ERR "ipmi: can't get major %d\n",
++		       ipmi_radisys_major);
++		return rv;
++	}
++
++	if (ipmi_radisys_major == 0) 
++	{
++		ipmi_radisys_major = rv;
++	}
++
++	devfs_handle = devfs_register(NULL, DEVICE_NAME, DEVFS_FL_NONE,
++				      ipmi_radisys_major, 0,
++				      S_IFCHR | S_IRUSR | S_IWUSR,
++				      &ipmi_fops, NULL);
++
++	ipmi_radisys_timer.data = (long) ipmi_user;
++	ipmi_radisys_timer.function = ipmi_radisys_timeout;
++	ipmi_radisys_timer.expires = jiffies + IPMI_TIMEOUT_JIFFIES;
++	add_timer(&ipmi_radisys_timer);
++
++	printk(KERN_INFO "ipmi_radisys: driver initialized at char major %d\n",
++	       ipmi_radisys_major);
++
++	return 0;
++}
++
++#ifdef MODULE
++static void free_recv_msg_list(struct list_head *q)
++{
++	struct list_head     *entry, *entry2;
++	struct ipmi_recv_msg *msg;
++
++	list_for_each_safe(entry, entry2, q) {
++		msg = list_entry(entry, struct ipmi_recv_msg, link);
++		list_del(entry);
++		ipmi_free_recv_msg(msg);
++	}
++}
++
++static void cleanup_ipmi_radisys(void)
++{
++	devfs_unregister(devfs_handle);
++
++	/* Tell the timer to stop, then wait for it to stop.  This avoids
++	   problems with race conditions removing the timer here. */
++	stop_operation = 1;
++	while (!timer_stopped) {
++		schedule_timeout(1);
++	}
++
++	ipmi_destroy_user(ipmi_user->rs_user);
++
++	free_recv_msg_list(&(ipmi_user->rs_waiting_rsps));
++	free_recv_msg_list(&(ipmi_user->rs_waiting_cmds));
++	free_recv_msg_list(&(ipmi_user->rs_waiting_events));
++
++	kfree(ipmi_user);
++	ipmi_user = NULL;
++
++	unregister_chrdev(ipmi_radisys_major, DEVICE_NAME);
++}
++module_exit(cleanup_ipmi_radisys);
++#else
++static int __init ipmi_radisys_setup (char *str)
++{
++	int x;
++
++	if (get_option (&str, &x)) {
++		/* ipmi=x sets the major number to x. */
++		ipmi_radisys_major = x;
++	} else if (!strcmp(str, "off")) {
++		ipmi_radisys_major = -1;
++	}
++
++	return 1;
++}
++__setup("ipmi_radisys=", ipmi_radisys_setup);
++#endif
++
++module_init(init_ipmi_radisys);
++MODULE_LICENSE("GPL");