4 * Linux device interface for the IPMI message handler.
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
10 * Copyright 2002 MontaVista Software Inc.
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.
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.
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.
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>
48 #define IPMI_DEVINTF_VERSION "v31"
50 struct ipmi_file_private
53 spinlock_t recv_msg_lock;
54 struct list_head recv_msgs;
56 struct fasync_struct *fasync_queue;
57 wait_queue_head_t wait;
58 struct semaphore recv_sem;
60 unsigned int default_retry_time_ms;
63 static void file_receive_handler(struct ipmi_recv_msg *msg,
66 struct ipmi_file_private *priv = handler_data;
70 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
72 was_empty = list_empty(&(priv->recv_msgs));
73 list_add_tail(&(msg->link), &(priv->recv_msgs));
76 wake_up_interruptible(&priv->wait);
77 kill_fasync(&priv->fasync_queue, SIGIO, POLL_IN);
80 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
83 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
85 struct ipmi_file_private *priv = file->private_data;
86 unsigned int mask = 0;
89 poll_wait(file, &priv->wait, wait);
91 spin_lock_irqsave(&priv->recv_msg_lock, flags);
93 if (! list_empty(&(priv->recv_msgs)))
94 mask |= (POLLIN | POLLRDNORM);
96 spin_unlock_irqrestore(&priv->recv_msg_lock, flags);
101 static int ipmi_fasync(int fd, struct file *file, int on)
103 struct ipmi_file_private *priv = file->private_data;
106 result = fasync_helper(fd, file, on, &priv->fasync_queue);
111 static struct ipmi_user_hndl ipmi_hndlrs =
113 .ipmi_recv_hndl = file_receive_handler,
116 static int ipmi_open(struct inode *inode, struct file *file)
118 int if_num = iminor(inode);
120 struct ipmi_file_private *priv;
123 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
129 rv = ipmi_create_user(if_num,
138 file->private_data = priv;
140 spin_lock_init(&(priv->recv_msg_lock));
141 INIT_LIST_HEAD(&(priv->recv_msgs));
142 init_waitqueue_head(&priv->wait);
143 priv->fasync_queue = NULL;
144 sema_init(&(priv->recv_sem), 1);
146 /* Use the low-level defaults. */
147 priv->default_retries = -1;
148 priv->default_retry_time_ms = 0;
153 static int ipmi_release(struct inode *inode, struct file *file)
155 struct ipmi_file_private *priv = file->private_data;
158 rv = ipmi_destroy_user(priv->user);
162 ipmi_fasync (-1, file, 0);
164 /* FIXME - free the messages in the list. */
170 static int handle_send_req(ipmi_user_t user,
171 struct ipmi_req *req,
173 unsigned int retry_time_ms)
176 struct ipmi_addr addr;
177 unsigned char *msgdata;
179 if (req->addr_len > sizeof(struct ipmi_addr))
182 if (copy_from_user(&addr, req->addr, req->addr_len))
185 msgdata = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
189 /* From here out we cannot return, we must jump to "out" for
190 error exits to free msgdata. */
192 rv = ipmi_validate_addr(&addr, req->addr_len);
196 if (req->msg.data != NULL) {
197 if (req->msg.data_len > IPMI_MAX_MSG_LENGTH) {
202 if (copy_from_user(&msgdata,
210 req->msg.data_len = 0;
212 req->msg.data = msgdata;
214 rv = ipmi_request_settime(user,
227 static int ipmi_ioctl(struct inode *inode,
233 struct ipmi_file_private *priv = file->private_data;
237 case IPMICTL_SEND_COMMAND:
241 if (copy_from_user(&req, (void *) data, sizeof(req))) {
246 rv = handle_send_req(priv->user,
248 priv->default_retries,
249 priv->default_retry_time_ms);
253 case IPMICTL_SEND_COMMAND_SETTIME:
255 struct ipmi_req_settime req;
257 if (copy_from_user(&req, (void *) data, sizeof(req))) {
262 rv = handle_send_req(priv->user,
269 case IPMICTL_RECEIVE_MSG:
270 case IPMICTL_RECEIVE_MSG_TRUNC:
272 struct ipmi_recv rsp;
274 struct list_head *entry;
275 struct ipmi_recv_msg *msg;
280 if (copy_from_user(&rsp, (void *) data, sizeof(rsp))) {
285 /* We claim a semaphore because we don't want two
286 users getting something from the queue at a time.
287 Since we have to release the spinlock before we can
288 copy the data to the user, it's possible another
289 user will grab something from the queue, too. Then
290 the messages might get out of order if something
291 fails and the message gets put back onto the
292 queue. This semaphore prevents that problem. */
293 down(&(priv->recv_sem));
295 /* Grab the message off the list. */
296 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
297 if (list_empty(&(priv->recv_msgs))) {
298 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
302 entry = priv->recv_msgs.next;
303 msg = list_entry(entry, struct ipmi_recv_msg, link);
305 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
307 addr_len = ipmi_addr_length(msg->addr.addr_type);
308 if (rsp.addr_len < addr_len)
311 goto recv_putback_on_err;
314 if (copy_to_user(rsp.addr, &(msg->addr), addr_len)) {
316 goto recv_putback_on_err;
318 rsp.addr_len = addr_len;
320 rsp.recv_type = msg->recv_type;
321 rsp.msgid = msg->msgid;
322 rsp.msg.netfn = msg->msg.netfn;
323 rsp.msg.cmd = msg->msg.cmd;
325 if (msg->msg.data_len > 0) {
326 if (rsp.msg.data_len < msg->msg.data_len) {
328 if (cmd == IPMICTL_RECEIVE_MSG_TRUNC) {
329 msg->msg.data_len = rsp.msg.data_len;
331 goto recv_putback_on_err;
335 if (copy_to_user(rsp.msg.data,
340 goto recv_putback_on_err;
342 rsp.msg.data_len = msg->msg.data_len;
344 rsp.msg.data_len = 0;
347 if (copy_to_user((void *) data, &rsp, sizeof(rsp))) {
349 goto recv_putback_on_err;
352 up(&(priv->recv_sem));
353 ipmi_free_recv_msg(msg);
357 /* If we got an error, put the message back onto
358 the head of the queue. */
359 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
360 list_add(entry, &(priv->recv_msgs));
361 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
362 up(&(priv->recv_sem));
366 up(&(priv->recv_sem));
370 case IPMICTL_REGISTER_FOR_CMD:
372 struct ipmi_cmdspec val;
374 if (copy_from_user(&val, (void *) data, sizeof(val))) {
379 rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd);
383 case IPMICTL_UNREGISTER_FOR_CMD:
385 struct ipmi_cmdspec val;
387 if (copy_from_user(&val, (void *) data, sizeof(val))) {
392 rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd);
396 case IPMICTL_SET_GETS_EVENTS_CMD:
400 if (copy_from_user(&val, (void *) data, sizeof(val))) {
405 rv = ipmi_set_gets_events(priv->user, val);
409 case IPMICTL_SET_MY_ADDRESS_CMD:
413 if (copy_from_user(&val, (void *) data, sizeof(val))) {
418 ipmi_set_my_address(priv->user, val);
423 case IPMICTL_GET_MY_ADDRESS_CMD:
427 val = ipmi_get_my_address(priv->user);
429 if (copy_to_user((void *) data, &val, sizeof(val))) {
437 case IPMICTL_SET_MY_LUN_CMD:
441 if (copy_from_user(&val, (void *) data, sizeof(val))) {
446 ipmi_set_my_LUN(priv->user, val);
451 case IPMICTL_GET_MY_LUN_CMD:
455 val = ipmi_get_my_LUN(priv->user);
457 if (copy_to_user((void *) data, &val, sizeof(val))) {
464 case IPMICTL_SET_TIMING_PARMS_CMD:
466 struct ipmi_timing_parms parms;
468 if (copy_from_user(&parms, (void *) data, sizeof(parms))) {
473 priv->default_retries = parms.retries;
474 priv->default_retry_time_ms = parms.retry_time_ms;
479 case IPMICTL_GET_TIMING_PARMS_CMD:
481 struct ipmi_timing_parms parms;
483 parms.retries = priv->default_retries;
484 parms.retry_time_ms = priv->default_retry_time_ms;
486 if (copy_to_user((void *) data, &parms, sizeof(parms))) {
500 static struct file_operations ipmi_fops = {
501 .owner = THIS_MODULE,
504 .release = ipmi_release,
505 .fasync = ipmi_fasync,
509 #define DEVICE_NAME "ipmidev"
511 static int ipmi_major = 0;
512 module_param(ipmi_major, int, 0);
513 MODULE_PARM_DESC(ipmi_major, "Sets the major number of the IPMI device. By"
514 " default, or if you set it to zero, it will choose the next"
515 " available device. Setting it to -1 will disable the"
516 " interface. Other values will set the major device number"
519 static void ipmi_new_smi(int if_num)
521 devfs_mk_cdev(MKDEV(ipmi_major, if_num),
522 S_IFCHR | S_IRUSR | S_IWUSR,
523 "ipmidev/%d", if_num);
526 static void ipmi_smi_gone(int if_num)
528 devfs_remove("ipmidev/%d", if_num);
531 static struct ipmi_smi_watcher smi_watcher =
533 .owner = THIS_MODULE,
534 .new_smi = ipmi_new_smi,
535 .smi_gone = ipmi_smi_gone,
538 static __init int init_ipmi_devintf(void)
545 printk(KERN_INFO "ipmi device interface version "
546 IPMI_DEVINTF_VERSION "\n");
548 rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
550 printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
554 if (ipmi_major == 0) {
558 devfs_mk_dir(DEVICE_NAME);
560 rv = ipmi_smi_watcher_register(&smi_watcher);
562 unregister_chrdev(ipmi_major, DEVICE_NAME);
563 printk(KERN_WARNING "ipmi: can't register smi watcher\n");
569 module_init(init_ipmi_devintf);
571 static __exit void cleanup_ipmi(void)
573 ipmi_smi_watcher_unregister(&smi_watcher);
574 devfs_remove(DEVICE_NAME);
575 unregister_chrdev(ipmi_major, DEVICE_NAME);
577 module_exit(cleanup_ipmi);
579 MODULE_LICENSE("GPL");