[mirror_ubuntu-hirsute-kernel.git] / drivers / char / ipmi / ipmi_devintf.c

/*
 * ipmi_devintf.c
 *
 * Linux device interface for the IPMI message handler.
 *
 * 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/moduleparam.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 <asm/semaphore.h>
#include <linux/init.h>
#include <linux/device.h>

#define IPMI_DEVINTF_VERSION "v33"

struct ipmi_file_private
{
	ipmi_user_t          user;
	spinlock_t           recv_msg_lock;
	struct list_head     recv_msgs;
	struct file          *file;
	struct fasync_struct *fasync_queue;
	wait_queue_head_t    wait;
	struct semaphore     recv_sem;
	int                  default_retries;
	unsigned int         default_retry_time_ms;
};

static void file_receive_handler(struct ipmi_recv_msg *msg,
				 void                 *handler_data)
{
	struct ipmi_file_private *priv = handler_data;
	int                      was_empty;
	unsigned long            flags;

	spin_lock_irqsave(&(priv->recv_msg_lock), flags);

	was_empty = list_empty(&(priv->recv_msgs));
	list_add_tail(&(msg->link), &(priv->recv_msgs));

	if (was_empty) {
		wake_up_interruptible(&priv->wait);
		kill_fasync(&priv->fasync_queue, SIGIO, POLL_IN);
	}

	spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
}

static unsigned int ipmi_poll(struct file *file, poll_table *wait)
{
	struct ipmi_file_private *priv = file->private_data;
	unsigned int             mask = 0;
	unsigned long            flags;

	poll_wait(file, &priv->wait, wait);

	spin_lock_irqsave(&priv->recv_msg_lock, flags);

	if (! list_empty(&(priv->recv_msgs)))
		mask |= (POLLIN | POLLRDNORM);

	spin_unlock_irqrestore(&priv->recv_msg_lock, flags);

	return mask;
}

static int ipmi_fasync(int fd, struct file *file, int on)
{
	struct ipmi_file_private *priv = file->private_data;
	int                      result;

	result = fasync_helper(fd, file, on, &priv->fasync_queue);

	return (result);
}

static struct ipmi_user_hndl ipmi_hndlrs =
{
	.ipmi_recv_hndl	= file_receive_handler,
};

static int ipmi_open(struct inode *inode, struct file *file)
{
	int                      if_num = iminor(inode);
	int                      rv;
	struct ipmi_file_private *priv;


	priv = kmalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	priv->file = file;

	rv = ipmi_create_user(if_num,
			      &ipmi_hndlrs,
			      priv,
			      &(priv->user));
	if (rv) {
		kfree(priv);
		return rv;
	}

	file->private_data = priv;

	spin_lock_init(&(priv->recv_msg_lock));
	INIT_LIST_HEAD(&(priv->recv_msgs));
	init_waitqueue_head(&priv->wait);
	priv->fasync_queue = NULL;
	sema_init(&(priv->recv_sem), 1);

	/* Use the low-level defaults. */
	priv->default_retries = -1;
	priv->default_retry_time_ms = 0;

	return 0;
}

static int ipmi_release(struct inode *inode, struct file *file)
{
	struct ipmi_file_private *priv = file->private_data;
	int                      rv;

	rv = ipmi_destroy_user(priv->user);
	if (rv)
		return rv;

	ipmi_fasync (-1, file, 0);

	/* FIXME - free the messages in the list. */
	kfree(priv);

	return 0;
}

static int handle_send_req(ipmi_user_t     user,
			   struct ipmi_req *req,
			   int             retries,
			   unsigned int    retry_time_ms)
{
	int              rv;
	struct ipmi_addr addr;
	struct kernel_ipmi_msg msg;

	if (req->addr_len > sizeof(struct ipmi_addr))
		return -EINVAL;

	if (copy_from_user(&addr, req->addr, req->addr_len))
		return -EFAULT;

	msg.netfn = req->msg.netfn;
	msg.cmd = req->msg.cmd;
	msg.data_len = req->msg.data_len;
	msg.data = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
	if (!msg.data)
		return -ENOMEM;

	/* From here out we cannot return, we must jump to "out" for
	   error exits to free msgdata. */

	rv = ipmi_validate_addr(&addr, req->addr_len);
	if (rv)
		goto out;

	if (req->msg.data != NULL) {
		if (req->msg.data_len > IPMI_MAX_MSG_LENGTH) {
			rv = -EMSGSIZE;
			goto out;
		}

		if (copy_from_user(msg.data,
				   req->msg.data,
				   req->msg.data_len))
		{
			rv = -EFAULT;
			goto out;
		}
	} else {
		msg.data_len = 0;
	}

	rv = ipmi_request_settime(user,
				  &addr,
				  req->msgid,
				  &msg,
				  NULL,
				  0,
				  retries,
				  retry_time_ms);
 out:
	kfree(msg.data);
	return rv;
}

static int ipmi_ioctl(struct inode  *inode,
		      struct file   *file,
		      unsigned int  cmd,
		      unsigned long data)
{
	int                      rv = -EINVAL;
	struct ipmi_file_private *priv = file->private_data;
	void __user *arg = (void __user *)data;

	switch (cmd) 
	{
	case IPMICTL_SEND_COMMAND:
	{
		struct ipmi_req req;

		if (copy_from_user(&req, arg, sizeof(req))) {
			rv = -EFAULT;
			break;
		}

		rv = handle_send_req(priv->user,
				     &req,
				     priv->default_retries,
				     priv->default_retry_time_ms);
		break;
	}

	case IPMICTL_SEND_COMMAND_SETTIME:
	{
		struct ipmi_req_settime req;

		if (copy_from_user(&req, arg, sizeof(req))) {
			rv = -EFAULT;
			break;
		}

		rv = handle_send_req(priv->user,
				     &req.req,
				     req.retries,
				     req.retry_time_ms);
		break;
	}

	case IPMICTL_RECEIVE_MSG:
	case IPMICTL_RECEIVE_MSG_TRUNC:
	{
		struct ipmi_recv      rsp;
		int              addr_len;
		struct list_head *entry;
		struct ipmi_recv_msg  *msg;
		unsigned long    flags;
		

		rv = 0;
		if (copy_from_user(&rsp, arg, sizeof(rsp))) {
			rv = -EFAULT;
			break;
		}

		/* We claim a semaphore because we don't want two
                   users getting something from the queue at a time.
                   Since we have to release the spinlock before we can
                   copy the data to the user, it's possible another
                   user will grab something from the queue, too.  Then
                   the messages might get out of order if something
                   fails and the message gets put back onto the
                   queue.  This semaphore prevents that problem. */
		down(&(priv->recv_sem));

		/* Grab the message off the list. */
		spin_lock_irqsave(&(priv->recv_msg_lock), flags);
		if (list_empty(&(priv->recv_msgs))) {
			spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
			rv = -EAGAIN;
			goto recv_err;
		}
		entry = priv->recv_msgs.next;
		msg = list_entry(entry, struct ipmi_recv_msg, link);
		list_del(entry);
		spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);

		addr_len = ipmi_addr_length(msg->addr.addr_type);
		if (rsp.addr_len < addr_len)
		{
			rv = -EINVAL;
			goto recv_putback_on_err;
		}

		if (copy_to_user(rsp.addr, &(msg->addr), addr_len)) {
			rv = -EFAULT;
			goto recv_putback_on_err;
		}
		rsp.addr_len = addr_len;

		rsp.recv_type = msg->recv_type;
		rsp.msgid = msg->msgid;
		rsp.msg.netfn = msg->msg.netfn;
		rsp.msg.cmd = msg->msg.cmd;

		if (msg->msg.data_len > 0) {
			if (rsp.msg.data_len < msg->msg.data_len) {
				rv = -EMSGSIZE;
				if (cmd == IPMICTL_RECEIVE_MSG_TRUNC) {
					msg->msg.data_len = rsp.msg.data_len;
				} else {
					goto recv_putback_on_err;
				}
			}

			if (copy_to_user(rsp.msg.data,
					 msg->msg.data,
					 msg->msg.data_len))
			{
				rv = -EFAULT;
				goto recv_putback_on_err;
			}
			rsp.msg.data_len = msg->msg.data_len;
		} else {
			rsp.msg.data_len = 0;
		}

		if (copy_to_user(arg, &rsp, sizeof(rsp))) {
			rv = -EFAULT;
			goto recv_putback_on_err;
		}

		up(&(priv->recv_sem));
		ipmi_free_recv_msg(msg);
		break;

	recv_putback_on_err:
		/* If we got an error, put the message back onto
		   the head of the queue. */
		spin_lock_irqsave(&(priv->recv_msg_lock), flags);
		list_add(entry, &(priv->recv_msgs));
		spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
		up(&(priv->recv_sem));
		break;

	recv_err:
		up(&(priv->recv_sem));
		break;
	}

	case IPMICTL_REGISTER_FOR_CMD:
	{
		struct ipmi_cmdspec val;

		if (copy_from_user(&val, arg, sizeof(val))) {
			rv = -EFAULT;
			break;
		}

		rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd);
		break;
	}

	case IPMICTL_UNREGISTER_FOR_CMD:
	{
		struct ipmi_cmdspec   val;

		if (copy_from_user(&val, arg, sizeof(val))) {
			rv = -EFAULT;
			break;
		}

		rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd);
		break;
	}

	case IPMICTL_SET_GETS_EVENTS_CMD:
	{
		int val;

		if (copy_from_user(&val, arg, sizeof(val))) {
			rv = -EFAULT;
			break;
		}

		rv = ipmi_set_gets_events(priv->user, val);
		break;
	}

	case IPMICTL_SET_MY_ADDRESS_CMD:
	{
		unsigned int val;

		if (copy_from_user(&val, arg, sizeof(val))) {
			rv = -EFAULT;
			break;
		}

		ipmi_set_my_address(priv->user, val);
		rv = 0;
		break;
	}

	case IPMICTL_GET_MY_ADDRESS_CMD:
	{
		unsigned int val;

		val = ipmi_get_my_address(priv->user);

		if (copy_to_user(arg, &val, sizeof(val))) {
			rv = -EFAULT;
			break;
		}
		rv = 0;
		break;
	}

	case IPMICTL_SET_MY_LUN_CMD:
	{
		unsigned int val;

		if (copy_from_user(&val, arg, sizeof(val))) {
			rv = -EFAULT;
			break;
		}

		ipmi_set_my_LUN(priv->user, val);
		rv = 0;
		break;
	}

	case IPMICTL_GET_MY_LUN_CMD:
	{
		unsigned int val;

		val = ipmi_get_my_LUN(priv->user);

		if (copy_to_user(arg, &val, sizeof(val))) {
			rv = -EFAULT;
			break;
		}
		rv = 0;
		break;
	}
	case IPMICTL_SET_TIMING_PARMS_CMD:
	{
		struct ipmi_timing_parms parms;

		if (copy_from_user(&parms, arg, sizeof(parms))) {
			rv = -EFAULT;
			break;
		}

		priv->default_retries = parms.retries;
		priv->default_retry_time_ms = parms.retry_time_ms;
		rv = 0;
		break;
	}

	case IPMICTL_GET_TIMING_PARMS_CMD:
	{
		struct ipmi_timing_parms parms;

		parms.retries = priv->default_retries;
		parms.retry_time_ms = priv->default_retry_time_ms;

		if (copy_to_user(arg, &parms, sizeof(parms))) {
			rv = -EFAULT;
			break;
		}

		rv = 0;
		break;
	}
	}
  
	return rv;
}


static struct file_operations ipmi_fops = {
	.owner		= THIS_MODULE,
	.ioctl		= ipmi_ioctl,
	.open		= ipmi_open,
	.release	= ipmi_release,
	.fasync		= ipmi_fasync,
	.poll		= ipmi_poll,
};

#define DEVICE_NAME     "ipmidev"

static int ipmi_major = 0;
module_param(ipmi_major, int, 0);
MODULE_PARM_DESC(ipmi_major, "Sets the major number of the IPMI device.  By"
		 " default, or if you set it to zero, it will choose the next"
		 " available device.  Setting it to -1 will disable the"
		 " interface.  Other values will set the major device number"
		 " to that value.");

static struct class_simple *ipmi_class;

static void ipmi_new_smi(int if_num)
{
	dev_t dev = MKDEV(ipmi_major, if_num);

	devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
		      "ipmidev/%d", if_num);

	class_simple_device_add(ipmi_class, dev, NULL, "ipmi%d", if_num);
}

static void ipmi_smi_gone(int if_num)
{
	class_simple_device_remove(MKDEV(ipmi_major, if_num));
	devfs_remove("ipmidev/%d", if_num);
}

static struct ipmi_smi_watcher smi_watcher =
{
	.owner    = THIS_MODULE,
	.new_smi  = ipmi_new_smi,
	.smi_gone = ipmi_smi_gone,
};

static __init int init_ipmi_devintf(void)
{
	int rv;

	if (ipmi_major < 0)
		return -EINVAL;

	printk(KERN_INFO "ipmi device interface version "
	       IPMI_DEVINTF_VERSION "\n");

	ipmi_class = class_simple_create(THIS_MODULE, "ipmi");
	if (IS_ERR(ipmi_class)) {
		printk(KERN_ERR "ipmi: can't register device class\n");
		return PTR_ERR(ipmi_class);
	}

	rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
	if (rv < 0) {
		class_simple_destroy(ipmi_class);
		printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
		return rv;
	}

	if (ipmi_major == 0) {
		ipmi_major = rv;
	}

	devfs_mk_dir(DEVICE_NAME);

	rv = ipmi_smi_watcher_register(&smi_watcher);
	if (rv) {
		unregister_chrdev(ipmi_major, DEVICE_NAME);
		class_simple_destroy(ipmi_class);
		printk(KERN_WARNING "ipmi: can't register smi watcher\n");
		return rv;
	}

	return 0;
}
module_init(init_ipmi_devintf);

static __exit void cleanup_ipmi(void)
{
	class_simple_destroy(ipmi_class);
	ipmi_smi_watcher_unregister(&smi_watcher);
	devfs_remove(DEVICE_NAME);
	unregister_chrdev(ipmi_major, DEVICE_NAME);
}
module_exit(cleanup_ipmi);

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* ipmi_devintf.c
	3	*
	4	* Linux device interface for the IPMI message handler.
	5	*
	6	* Author: MontaVista Software, Inc.
	7	* Corey Minyard <minyard@mvista.com>
	8	* source@mvista.com
	9	*
	10	* Copyright 2002 MontaVista Software Inc.
	11	*
	12	* This program is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by the
	14	* Free Software Foundation; either version 2 of the License, or (at your
	15	* option) any later version.
	16	*
	17	*
	18	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
	19	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	20	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
	23	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
	24	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	25	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
	26	* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
	27	* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	28	*
	29	* You should have received a copy of the GNU General Public License along
	30	* with this program; if not, write to the Free Software Foundation, Inc.,
	31	* 675 Mass Ave, Cambridge, MA 02139, USA.
	32	*/
	33
	34	#include <linux/config.h>
	35	#include <linux/module.h>
	36	#include <linux/moduleparam.h>
	37	#include <linux/errno.h>
	38	#include <asm/system.h>
	39	#include <linux/sched.h>
	40	#include <linux/poll.h>
	41	#include <linux/spinlock.h>
	42	#include <linux/slab.h>
	43	#include <linux/devfs_fs_kernel.h>
	44	#include <linux/ipmi.h>
	45	#include <asm/semaphore.h>
	46	#include <linux/init.h>
37e0915b	47	#include <linux/device.h>
1da177e4 LT	48
	49	#define IPMI_DEVINTF_VERSION "v33"
	50
	51	struct ipmi_file_private
	52	{
	53	ipmi_user_t user;
	54	spinlock_t recv_msg_lock;
	55	struct list_head recv_msgs;
	56	struct file *file;
	57	struct fasync_struct *fasync_queue;
	58	wait_queue_head_t wait;
	59	struct semaphore recv_sem;
	60	int default_retries;
	61	unsigned int default_retry_time_ms;
	62	};
	63
	64	static void file_receive_handler(struct ipmi_recv_msg *msg,
	65	void *handler_data)
	66	{
	67	struct ipmi_file_private *priv = handler_data;
	68	int was_empty;
	69	unsigned long flags;
	70
	71	spin_lock_irqsave(&(priv->recv_msg_lock), flags);
	72
	73	was_empty = list_empty(&(priv->recv_msgs));
	74	list_add_tail(&(msg->link), &(priv->recv_msgs));
	75
	76	if (was_empty) {
	77	wake_up_interruptible(&priv->wait);
	78	kill_fasync(&priv->fasync_queue, SIGIO, POLL_IN);
	79	}
	80
	81	spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
	82	}
	83
	84	static unsigned int ipmi_poll(struct file file, poll_table wait)
	85	{
	86	struct ipmi_file_private *priv = file->private_data;
	87	unsigned int mask = 0;
	88	unsigned long flags;
	89
	90	poll_wait(file, &priv->wait, wait);
	91
	92	spin_lock_irqsave(&priv->recv_msg_lock, flags);
	93
	94	if (! list_empty(&(priv->recv_msgs)))
	95	mask \|= (POLLIN \| POLLRDNORM);
	96
	97	spin_unlock_irqrestore(&priv->recv_msg_lock, flags);
	98
	99	return mask;
	100	}
	101
	102	static int ipmi_fasync(int fd, struct file *file, int on)
	103	{
	104	struct ipmi_file_private *priv = file->private_data;
	105	int result;
	106
	107	result = fasync_helper(fd, file, on, &priv->fasync_queue);
	108
	109	return (result);
	110	}
	111
112	static struct ipmi_user_hndl ipmi_hndlrs =
113	{
114	.ipmi_recv_hndl = file_receive_handler,
115	};
116
117	static int ipmi_open(struct inode inode, struct file file)
118	{
119	int if_num = iminor(inode);
120	int rv;
121	struct ipmi_file_private *priv;
122
123
124	priv = kmalloc(sizeof(*priv), GFP_KERNEL);
125	if (!priv)
126	return -ENOMEM;
127
128	priv->file = file;
129
130	rv = ipmi_create_user(if_num,
131	&ipmi_hndlrs,
132	priv,
133	&(priv->user));
134	if (rv) {
135	kfree(priv);
136	return rv;
137	}
138
139	file->private_data = priv;
140
141	spin_lock_init(&(priv->recv_msg_lock));
142	INIT_LIST_HEAD(&(priv->recv_msgs));
143	init_waitqueue_head(&priv->wait);
144	priv->fasync_queue = NULL;
145	sema_init(&(priv->recv_sem), 1);
146
147	/* Use the low-level defaults. */
148	priv->default_retries = -1;
149	priv->default_retry_time_ms = 0;
150
151	return 0;
152	}
153
154	static int ipmi_release(struct inode inode, struct file file)
155	{
156	struct ipmi_file_private *priv = file->private_data;
157	int rv;
158
159	rv = ipmi_destroy_user(priv->user);
160	if (rv)
161	return rv;
162
163	ipmi_fasync (-1, file, 0);
164
165	/* FIXME - free the messages in the list. */
166	kfree(priv);
167
168	return 0;
169	}
170
171	static int handle_send_req(ipmi_user_t user,
172	struct ipmi_req *req,
173	int retries,
174	unsigned int retry_time_ms)
175	{
176	int rv;
177	struct ipmi_addr addr;
178	struct kernel_ipmi_msg msg;
179
180	if (req->addr_len > sizeof(struct ipmi_addr))
181	return -EINVAL;
182
183	if (copy_from_user(&addr, req->addr, req->addr_len))
184	return -EFAULT;
185
186	msg.netfn = req->msg.netfn;
187	msg.cmd = req->msg.cmd;
188	msg.data_len = req->msg.data_len;
189	msg.data = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
190	if (!msg.data)
191	return -ENOMEM;
192
193	/* From here out we cannot return, we must jump to "out" for
194	error exits to free msgdata. */
195
196	rv = ipmi_validate_addr(&addr, req->addr_len);
197	if (rv)
198	goto out;
199
200	if (req->msg.data != NULL) {
201	if (req->msg.data_len > IPMI_MAX_MSG_LENGTH) {
202	rv = -EMSGSIZE;
203	goto out;
204	}
205
206	if (copy_from_user(msg.data,
207	req->msg.data,
208	req->msg.data_len))
209	{
210	rv = -EFAULT;
211	goto out;
212	}
213	} else {
214	msg.data_len = 0;
215	}
216
217	rv = ipmi_request_settime(user,
218	&addr,
219	req->msgid,
220	&msg,
221	NULL,
222	0,
223	retries,
224	retry_time_ms);
225	out:
226	kfree(msg.data);
227	return rv;
228	}
229
230	static int ipmi_ioctl(struct inode *inode,
231	struct file *file,
232	unsigned int cmd,
233	unsigned long data)
234	{
235	int rv = -EINVAL;
236	struct ipmi_file_private *priv = file->private_data;
237	void __user arg = (void __user )data;
238
239	switch (cmd)
240	{
241	case IPMICTL_SEND_COMMAND:
242	{
243	struct ipmi_req req;
244
245	if (copy_from_user(&req, arg, sizeof(req))) {
246	rv = -EFAULT;
247	break;
248	}
249
250	rv = handle_send_req(priv->user,
251	&req,
252	priv->default_retries,
253	priv->default_retry_time_ms);
254	break;
255	}
256
257	case IPMICTL_SEND_COMMAND_SETTIME:
258	{
259	struct ipmi_req_settime req;
260
261	if (copy_from_user(&req, arg, sizeof(req))) {
262	rv = -EFAULT;
263	break;
264	}
265
266	rv = handle_send_req(priv->user,
267	&req.req,
268	req.retries,
269	req.retry_time_ms);
270	break;
271	}
272
273	case IPMICTL_RECEIVE_MSG:
274	case IPMICTL_RECEIVE_MSG_TRUNC:
275	{
276	struct ipmi_recv rsp;
277	int addr_len;
278	struct list_head *entry;
279	struct ipmi_recv_msg *msg;
280	unsigned long flags;
281
282
283	rv = 0;
284	if (copy_from_user(&rsp, arg, sizeof(rsp))) {
285	rv = -EFAULT;
286	break;
287	}
288
289	/* We claim a semaphore because we don't want two
290	users getting something from the queue at a time.
291	Since we have to release the spinlock before we can
292	copy the data to the user, it's possible another
293	user will grab something from the queue, too. Then
294	the messages might get out of order if something
295	fails and the message gets put back onto the
296	queue. This semaphore prevents that problem. */
297	down(&(priv->recv_sem));
298
299	/* Grab the message off the list. */
300	spin_lock_irqsave(&(priv->recv_msg_lock), flags);
301	if (list_empty(&(priv->recv_msgs))) {
302	spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
303	rv = -EAGAIN;
304	goto recv_err;
305	}
306	entry = priv->recv_msgs.next;
307	msg = list_entry(entry, struct ipmi_recv_msg, link);
308	list_del(entry);
309	spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
310
311	addr_len = ipmi_addr_length(msg->addr.addr_type);
312	if (rsp.addr_len < addr_len)
313	{
314	rv = -EINVAL;
315	goto recv_putback_on_err;
316	}
317
318	if (copy_to_user(rsp.addr, &(msg->addr), addr_len)) {
319	rv = -EFAULT;
320	goto recv_putback_on_err;
321	}
322	rsp.addr_len = addr_len;
323
324	rsp.recv_type = msg->recv_type;
325	rsp.msgid = msg->msgid;
326	rsp.msg.netfn = msg->msg.netfn;
327	rsp.msg.cmd = msg->msg.cmd;
328
329	if (msg->msg.data_len > 0) {
330	if (rsp.msg.data_len < msg->msg.data_len) {
331	rv = -EMSGSIZE;
332	if (cmd == IPMICTL_RECEIVE_MSG_TRUNC) {
333	msg->msg.data_len = rsp.msg.data_len;
334	} else {
335	goto recv_putback_on_err;
336	}
337	}
338
339	if (copy_to_user(rsp.msg.data,
340	msg->msg.data,
341	msg->msg.data_len))
342	{
343	rv = -EFAULT;
344	goto recv_putback_on_err;
345	}
346	rsp.msg.data_len = msg->msg.data_len;
347	} else {
348	rsp.msg.data_len = 0;
349	}
350
351	if (copy_to_user(arg, &rsp, sizeof(rsp))) {
352	rv = -EFAULT;
353	goto recv_putback_on_err;
354	}
355
356	up(&(priv->recv_sem));
357	ipmi_free_recv_msg(msg);
358	break;
359
360	recv_putback_on_err:
361	/* If we got an error, put the message back onto
362	the head of the queue. */
363	spin_lock_irqsave(&(priv->recv_msg_lock), flags);
364	list_add(entry, &(priv->recv_msgs));
365	spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
366	up(&(priv->recv_sem));
367	break;
368
369	recv_err:
370	up(&(priv->recv_sem));
371	break;
372	}
373
374	case IPMICTL_REGISTER_FOR_CMD:
375	{
376	struct ipmi_cmdspec val;
377
378	if (copy_from_user(&val, arg, sizeof(val))) {
379	rv = -EFAULT;
380	break;
381	}
382
383	rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd);
384	break;
385	}
386
387	case IPMICTL_UNREGISTER_FOR_CMD:
388	{
389	struct ipmi_cmdspec val;
390
391	if (copy_from_user(&val, arg, sizeof(val))) {
392	rv = -EFAULT;
393	break;
394	}
395
396	rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd);
397	break;
398	}
399
400	case IPMICTL_SET_GETS_EVENTS_CMD:
401	{
402	int val;
403
404	if (copy_from_user(&val, arg, sizeof(val))) {
405	rv = -EFAULT;
406	break;
407	}
408
409	rv = ipmi_set_gets_events(priv->user, val);
410	break;
411	}
412
413	case IPMICTL_SET_MY_ADDRESS_CMD:
414	{
415	unsigned int val;
416
417	if (copy_from_user(&val, arg, sizeof(val))) {
418	rv = -EFAULT;
419	break;
420	}
421
422	ipmi_set_my_address(priv->user, val);
423	rv = 0;
424	break;
425	}
426
427	case IPMICTL_GET_MY_ADDRESS_CMD:
428	{
429	unsigned int val;
430
431	val = ipmi_get_my_address(priv->user);
432
433	if (copy_to_user(arg, &val, sizeof(val))) {
434	rv = -EFAULT;
435	break;
436	}
437	rv = 0;
438	break;
439	}
440
441	case IPMICTL_SET_MY_LUN_CMD:
442	{
443	unsigned int val;
444
445	if (copy_from_user(&val, arg, sizeof(val))) {
446	rv = -EFAULT;
447	break;
448	}
449
450	ipmi_set_my_LUN(priv->user, val);
451	rv = 0;
452	break;
453	}
454
455	case IPMICTL_GET_MY_LUN_CMD:
456	{
457	unsigned int val;
458
459	val = ipmi_get_my_LUN(priv->user);
460
461	if (copy_to_user(arg, &val, sizeof(val))) {
462	rv = -EFAULT;
463	break;
464	}
465	rv = 0;
466	break;
467	}
468	case IPMICTL_SET_TIMING_PARMS_CMD:
469	{
470	struct ipmi_timing_parms parms;
471
472	if (copy_from_user(&parms, arg, sizeof(parms))) {
473	rv = -EFAULT;
474	break;
475	}
476
477	priv->default_retries = parms.retries;
478	priv->default_retry_time_ms = parms.retry_time_ms;
479	rv = 0;
480	break;
481	}
482
483	case IPMICTL_GET_TIMING_PARMS_CMD:
484	{
485	struct ipmi_timing_parms parms;
486
487	parms.retries = priv->default_retries;
488	parms.retry_time_ms = priv->default_retry_time_ms;
489
490	if (copy_to_user(arg, &parms, sizeof(parms))) {
491	rv = -EFAULT;
492	break;
493	}
494
495	rv = 0;
496	break;
497	}
498	}
499
500	return rv;
501	}
502
503
504	static struct file_operations ipmi_fops = {
505	.owner = THIS_MODULE,
506	.ioctl = ipmi_ioctl,
507	.open = ipmi_open,
508	.release = ipmi_release,
509	.fasync = ipmi_fasync,
510	.poll = ipmi_poll,
511	};
512
513	#define DEVICE_NAME "ipmidev"
514
515	static int ipmi_major = 0;
516	module_param(ipmi_major, int, 0);
517	MODULE_PARM_DESC(ipmi_major, "Sets the major number of the IPMI device. By"
518	" default, or if you set it to zero, it will choose the next"
519	" available device. Setting it to -1 will disable the"
520	" interface. Other values will set the major device number"
521	" to that value.");
522
dca79a04	523	static struct class_simple *ipmi_class;
37e0915b	524
1da177e4 LT	525	static void ipmi_new_smi(int if_num)
1da177e4 LT	526	{
37e0915b CM	527	dev_t dev = MKDEV(ipmi_major, if_num);
	528
	529	devfs_mk_cdev(dev, S_IFCHR \| S_IRUSR \| S_IWUSR,
1da177e4	530	"ipmidev/%d", if_num);
37e0915b CM	531
37e0915b CM	532	class_simple_device_add(ipmi_class, dev, NULL, "ipmi%d", if_num);
1da177e4 LT	533	}
	534
	535	static void ipmi_smi_gone(int if_num)
	536	{
dca79a04	537	class_simple_device_remove(MKDEV(ipmi_major, if_num));
1da177e4 LT	538	devfs_remove("ipmidev/%d", if_num);
	539	}
	540
	541	static struct ipmi_smi_watcher smi_watcher =
	542	{
	543	.owner = THIS_MODULE,
	544	.new_smi = ipmi_new_smi,
	545	.smi_gone = ipmi_smi_gone,
	546	};
	547
	548	static __init int init_ipmi_devintf(void)
	549	{
	550	int rv;
	551
	552	if (ipmi_major < 0)
	553	return -EINVAL;
	554
	555	printk(KERN_INFO "ipmi device interface version "
	556	IPMI_DEVINTF_VERSION "\n");
	557
37e0915b CM	558	ipmi_class = class_simple_create(THIS_MODULE, "ipmi");
	559	if (IS_ERR(ipmi_class)) {
	560	printk(KERN_ERR "ipmi: can't register device class\n");
	561	return PTR_ERR(ipmi_class);
	562	}
	563
1da177e4 LT	564	rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
1da177e4 LT	565	if (rv < 0) {
37e0915b	566	class_simple_destroy(ipmi_class);
1da177e4 LT	567	printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
	568	return rv;
	569	}
	570
	571	if (ipmi_major == 0) {
	572	ipmi_major = rv;
	573	}
	574
	575	devfs_mk_dir(DEVICE_NAME);
	576
	577	rv = ipmi_smi_watcher_register(&smi_watcher);
	578	if (rv) {
	579	unregister_chrdev(ipmi_major, DEVICE_NAME);
37e0915b	580	class_simple_destroy(ipmi_class);
1da177e4 LT	581	printk(KERN_WARNING "ipmi: can't register smi watcher\n");
	582	return rv;
	583	}
	584
	585	return 0;
	586	}
	587	module_init(init_ipmi_devintf);
	588
	589	static __exit void cleanup_ipmi(void)
	590	{
37e0915b	591	class_simple_destroy(ipmi_class);
1da177e4 LT	592	ipmi_smi_watcher_unregister(&smi_watcher);
	593	devfs_remove(DEVICE_NAME);
	594	unregister_chrdev(ipmi_major, DEVICE_NAME);
	595	}
	596	module_exit(cleanup_ipmi);
	597
	598	MODULE_LICENSE("GPL");