]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/char/ipmi/ipmi_devintf.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] ipmi: clean up versioning of the IPMI driver
[net-next-2.6.git] / drivers / char / ipmi / ipmi_devintf.c
CommitLineData
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>
6a94f920 48#include <linux/compat.h>
1da177e4 49
1da177e4
LT		 50struct ipmi_file_private
51{
52 ipmi_user_t user;
53 spinlock_t recv_msg_lock;
54 struct list_head recv_msgs;
55 struct file *file;
56 struct fasync_struct *fasync_queue;
57 wait_queue_head_t wait;
58 struct semaphore recv_sem;
59 int default_retries;
60 unsigned int default_retry_time_ms;
61};
62
63static void file_receive_handler(struct ipmi_recv_msg *msg,
64 void *handler_data)
65{
66 struct ipmi_file_private *priv = handler_data;
67 int was_empty;
68 unsigned long flags;
69
70 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
71
72 was_empty = list_empty(&(priv->recv_msgs));
73 list_add_tail(&(msg->link), &(priv->recv_msgs));
74
75 if (was_empty) {
76 wake_up_interruptible(&priv->wait);
77 kill_fasync(&priv->fasync_queue, SIGIO, POLL_IN);
78 }
79
80 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
81}
82
83static unsigned int ipmi_poll(struct file *file, poll_table *wait)
84{
85 struct ipmi_file_private *priv = file->private_data;
86 unsigned int mask = 0;
87 unsigned long flags;
88
89 poll_wait(file, &priv->wait, wait);
90
91 spin_lock_irqsave(&priv->recv_msg_lock, flags);
92
93 if (! list_empty(&(priv->recv_msgs)))
94 mask |= (POLLIN | POLLRDNORM);
95
96 spin_unlock_irqrestore(&priv->recv_msg_lock, flags);
97
98 return mask;
99}
100
101static int ipmi_fasync(int fd, struct file *file, int on)
102{
103 struct ipmi_file_private *priv = file->private_data;
104 int result;
105
106 result = fasync_helper(fd, file, on, &priv->fasync_queue);
107
108 return (result);
109}
110
111static struct ipmi_user_hndl ipmi_hndlrs =
112{
113 .ipmi_recv_hndl = file_receive_handler,
114};
115
116static int ipmi_open(struct inode *inode, struct file *file)
117{
118 int if_num = iminor(inode);
119 int rv;
120 struct ipmi_file_private *priv;
121
122
123 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
124 if (!priv)
125 return -ENOMEM;
126
127 priv->file = file;
128
129 rv = ipmi_create_user(if_num,
130 &ipmi_hndlrs,
131 priv,
132 &(priv->user));
133 if (rv) {
134 kfree(priv);
135 return rv;
136 }
137
138 file->private_data = priv;
139
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);
145
146 /* Use the low-level defaults. */
147 priv->default_retries = -1;
148 priv->default_retry_time_ms = 0;
149
150 return 0;
151}
152
153static int ipmi_release(struct inode *inode, struct file *file)
154{
155 struct ipmi_file_private *priv = file->private_data;
156 int rv;
157
158 rv = ipmi_destroy_user(priv->user);
159 if (rv)
160 return rv;
161
162 ipmi_fasync (-1, file, 0);
163
164 /* FIXME - free the messages in the list. */
165 kfree(priv);
166
167 return 0;
168}
169
170static int handle_send_req(ipmi_user_t user,
171 struct ipmi_req *req,
172 int retries,
173 unsigned int retry_time_ms)
174{
175 int rv;
176 struct ipmi_addr addr;
177 struct kernel_ipmi_msg msg;
178
179 if (req->addr_len > sizeof(struct ipmi_addr))
180 return -EINVAL;
181
182 if (copy_from_user(&addr, req->addr, req->addr_len))
183 return -EFAULT;
184
185 msg.netfn = req->msg.netfn;
186 msg.cmd = req->msg.cmd;
187 msg.data_len = req->msg.data_len;
188 msg.data = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
189 if (!msg.data)
190 return -ENOMEM;
191
192 /* From here out we cannot return, we must jump to "out" for
193 error exits to free msgdata. */
194
195 rv = ipmi_validate_addr(&addr, req->addr_len);
196 if (rv)
197 goto out;
198
199 if (req->msg.data != NULL) {
200 if (req->msg.data_len > IPMI_MAX_MSG_LENGTH) {
201 rv = -EMSGSIZE;
202 goto out;
203 }
204
205 if (copy_from_user(msg.data,
206 req->msg.data,
207 req->msg.data_len))
208 {
209 rv = -EFAULT;
210 goto out;
211 }
212 } else {
213 msg.data_len = 0;
214 }
215
216 rv = ipmi_request_settime(user,
217 &addr,
218 req->msgid,
219 &msg,
220 NULL,
221 0,
222 retries,
223 retry_time_ms);
224 out:
225 kfree(msg.data);
226 return rv;
227}
228
229static int ipmi_ioctl(struct inode *inode,
230 struct file *file,
231 unsigned int cmd,
232 unsigned long data)
233{
234 int rv = -EINVAL;
235 struct ipmi_file_private *priv = file->private_data;
236 void __user *arg = (void __user *)data;
237
238 switch (cmd)
239 {
240 case IPMICTL_SEND_COMMAND:
241 {
242 struct ipmi_req req;
243
244 if (copy_from_user(&req, arg, sizeof(req))) {
245 rv = -EFAULT;
246 break;
247 }
248
249 rv = handle_send_req(priv->user,
250 &req,
251 priv->default_retries,
252 priv->default_retry_time_ms);
253 break;
254 }
255
256 case IPMICTL_SEND_COMMAND_SETTIME:
257 {
258 struct ipmi_req_settime req;
259
260 if (copy_from_user(&req, arg, sizeof(req))) {
261 rv = -EFAULT;
262 break;
263 }
264
265 rv = handle_send_req(priv->user,
266 &req.req,
267 req.retries,
268 req.retry_time_ms);
269 break;
270 }
271
272 case IPMICTL_RECEIVE_MSG:
273 case IPMICTL_RECEIVE_MSG_TRUNC:
274 {
275 struct ipmi_recv rsp;
276 int addr_len;
277 struct list_head *entry;
278 struct ipmi_recv_msg *msg;
279 unsigned long flags;
280
281
282 rv = 0;
283 if (copy_from_user(&rsp, arg, sizeof(rsp))) {
284 rv = -EFAULT;
285 break;
286 }
287
288 /* We claim a semaphore because we don't want two
289 users getting something from the queue at a time.
290 Since we have to release the spinlock before we can
291 copy the data to the user, it's possible another
292 user will grab something from the queue, too. Then
293 the messages might get out of order if something
294 fails and the message gets put back onto the
295 queue. This semaphore prevents that problem. */
296 down(&(priv->recv_sem));
297
298 /* Grab the message off the list. */
299 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
300 if (list_empty(&(priv->recv_msgs))) {
301 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
302 rv = -EAGAIN;
303 goto recv_err;
304 }
305 entry = priv->recv_msgs.next;
306 msg = list_entry(entry, struct ipmi_recv_msg, link);
307 list_del(entry);
308 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
309
310 addr_len = ipmi_addr_length(msg->addr.addr_type);
311 if (rsp.addr_len < addr_len)
312 {
313 rv = -EINVAL;
314 goto recv_putback_on_err;
315 }
316
317 if (copy_to_user(rsp.addr, &(msg->addr), addr_len)) {
318 rv = -EFAULT;
319 goto recv_putback_on_err;
320 }
321 rsp.addr_len = addr_len;
322
323 rsp.recv_type = msg->recv_type;
324 rsp.msgid = msg->msgid;
325 rsp.msg.netfn = msg->msg.netfn;
326 rsp.msg.cmd = msg->msg.cmd;
327
328 if (msg->msg.data_len > 0) {
329 if (rsp.msg.data_len < msg->msg.data_len) {
330 rv = -EMSGSIZE;
331 if (cmd == IPMICTL_RECEIVE_MSG_TRUNC) {
332 msg->msg.data_len = rsp.msg.data_len;
333 } else {
334 goto recv_putback_on_err;
335 }
336 }
337
338 if (copy_to_user(rsp.msg.data,
339 msg->msg.data,
340 msg->msg.data_len))
341 {
342 rv = -EFAULT;
343 goto recv_putback_on_err;
344 }
345 rsp.msg.data_len = msg->msg.data_len;
346 } else {
347 rsp.msg.data_len = 0;
348 }
349
350 if (copy_to_user(arg, &rsp, sizeof(rsp))) {
351 rv = -EFAULT;
352 goto recv_putback_on_err;
353 }
354
355 up(&(priv->recv_sem));
356 ipmi_free_recv_msg(msg);
357 break;
358
359 recv_putback_on_err:
360 /* If we got an error, put the message back onto
361 the head of the queue. */
362 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
363 list_add(entry, &(priv->recv_msgs));
364 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
365 up(&(priv->recv_sem));
366 break;
367
368 recv_err:
369 up(&(priv->recv_sem));
370 break;
371 }
372
373 case IPMICTL_REGISTER_FOR_CMD:
374 {
375 struct ipmi_cmdspec val;
376
377 if (copy_from_user(&val, arg, sizeof(val))) {
378 rv = -EFAULT;
379 break;
380 }
381
382 rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd);
383 break;
384 }
385
386 case IPMICTL_UNREGISTER_FOR_CMD:
387 {
388 struct ipmi_cmdspec val;
389
390 if (copy_from_user(&val, arg, sizeof(val))) {
391 rv = -EFAULT;
392 break;
393 }
394
395 rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd);
396 break;
397 }
398
399 case IPMICTL_SET_GETS_EVENTS_CMD:
400 {
401 int val;
402
403 if (copy_from_user(&val, arg, sizeof(val))) {
404 rv = -EFAULT;
405 break;
406 }
407
408 rv = ipmi_set_gets_events(priv->user, val);
409 break;
410 }
411
c14979b9 412 /* The next four are legacy, not per-channel. */
1da177e4
LT		 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
c14979b9 422 rv = ipmi_set_my_address(priv->user, 0, val);
1da177e4
LT		 423 break;
424 }
425
426 case IPMICTL_GET_MY_ADDRESS_CMD:
427 {
c14979b9
CM		 428 unsigned int val;
429 unsigned char rval;
430
431 rv = ipmi_get_my_address(priv->user, 0, &rval);
432 if (rv)
433 break;
1da177e4 434
c14979b9 435 val = rval;
1da177e4
LT		 436
437 if (copy_to_user(arg, &val, sizeof(val))) {
438 rv = -EFAULT;
439 break;
440 }
1da177e4
LT		 441 break;
442 }
443
444 case IPMICTL_SET_MY_LUN_CMD:
445 {
446 unsigned int val;
447
448 if (copy_from_user(&val, arg, sizeof(val))) {
449 rv = -EFAULT;
450 break;
451 }
452
c14979b9 453 rv = ipmi_set_my_LUN(priv->user, 0, val);
1da177e4
LT		 454 break;
455 }
456
457 case IPMICTL_GET_MY_LUN_CMD:
458 {
c14979b9
CM		 459 unsigned int val;
460 unsigned char rval;
461
462 rv = ipmi_get_my_LUN(priv->user, 0, &rval);
463 if (rv)
464 break;
1da177e4 465
c14979b9 466 val = rval;
1da177e4
LT		 467
468 if (copy_to_user(arg, &val, sizeof(val))) {
469 rv = -EFAULT;
470 break;
471 }
1da177e4
LT		 472 break;
473 }
c14979b9
CM		 474
475 case IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD:
476 {
477 struct ipmi_channel_lun_address_set val;
478
479 if (copy_from_user(&val, arg, sizeof(val))) {
480 rv = -EFAULT;
481 break;
482 }
483
484 return ipmi_set_my_address(priv->user, val.channel, val.value);
485 break;
486 }
487
488 case IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD:
489 {
490 struct ipmi_channel_lun_address_set val;
491
492 if (copy_from_user(&val, arg, sizeof(val))) {
493 rv = -EFAULT;
494 break;
495 }
496
497 rv = ipmi_get_my_address(priv->user, val.channel, &val.value);
498 if (rv)
499 break;
500
501 if (copy_to_user(arg, &val, sizeof(val))) {
502 rv = -EFAULT;
503 break;
504 }
505 break;
506 }
507
508 case IPMICTL_SET_MY_CHANNEL_LUN_CMD:
509 {
510 struct ipmi_channel_lun_address_set val;
511
512 if (copy_from_user(&val, arg, sizeof(val))) {
513 rv = -EFAULT;
514 break;
515 }
516
517 rv = ipmi_set_my_LUN(priv->user, val.channel, val.value);
518 break;
519 }
520
521 case IPMICTL_GET_MY_CHANNEL_LUN_CMD:
522 {
523 struct ipmi_channel_lun_address_set val;
524
525 if (copy_from_user(&val, arg, sizeof(val))) {
526 rv = -EFAULT;
527 break;
528 }
529
530 rv = ipmi_get_my_LUN(priv->user, val.channel, &val.value);
531 if (rv)
532 break;
533
534 if (copy_to_user(arg, &val, sizeof(val))) {
535 rv = -EFAULT;
536 break;
537 }
538 break;
539 }
540
1da177e4
LT		 541 case IPMICTL_SET_TIMING_PARMS_CMD:
542 {
543 struct ipmi_timing_parms parms;
544
545 if (copy_from_user(&parms, arg, sizeof(parms))) {
546 rv = -EFAULT;
547 break;
548 }
549
550 priv->default_retries = parms.retries;
551 priv->default_retry_time_ms = parms.retry_time_ms;
552 rv = 0;
553 break;
554 }
555
556 case IPMICTL_GET_TIMING_PARMS_CMD:
557 {
558 struct ipmi_timing_parms parms;
559
560 parms.retries = priv->default_retries;
561 parms.retry_time_ms = priv->default_retry_time_ms;
562
563 if (copy_to_user(arg, &parms, sizeof(parms))) {
564 rv = -EFAULT;
565 break;
566 }
567
568 rv = 0;
569 break;
570 }
571 }
572
573 return rv;
574}
575
6a94f920
AM		 576#ifdef CONFIG_COMPAT
577
578/*
579 * The following code contains code for supporting 32-bit compatible
580 * ioctls on 64-bit kernels. This allows running 32-bit apps on the
581 * 64-bit kernel
582 */
583#define COMPAT_IPMICTL_SEND_COMMAND \
584 _IOR(IPMI_IOC_MAGIC, 13, struct compat_ipmi_req)
585#define COMPAT_IPMICTL_SEND_COMMAND_SETTIME \
586 _IOR(IPMI_IOC_MAGIC, 21, struct compat_ipmi_req_settime)
587#define COMPAT_IPMICTL_RECEIVE_MSG \
588 _IOWR(IPMI_IOC_MAGIC, 12, struct compat_ipmi_recv)
589#define COMPAT_IPMICTL_RECEIVE_MSG_TRUNC \
590 _IOWR(IPMI_IOC_MAGIC, 11, struct compat_ipmi_recv)
591
592struct compat_ipmi_msg {
593 u8 netfn;
594 u8 cmd;
595 u16 data_len;
596 compat_uptr_t data;
597};
598
599struct compat_ipmi_req {
600 compat_uptr_t addr;
601 compat_uint_t addr_len;
602 compat_long_t msgid;
603 struct compat_ipmi_msg msg;
604};
605
606struct compat_ipmi_recv {
607 compat_int_t recv_type;
608 compat_uptr_t addr;
609 compat_uint_t addr_len;
610 compat_long_t msgid;
611 struct compat_ipmi_msg msg;
612};
613
614struct compat_ipmi_req_settime {
615 struct compat_ipmi_req req;
616 compat_int_t retries;
617 compat_uint_t retry_time_ms;
618};
619
620/*
621 * Define some helper functions for copying IPMI data
622 */
623static long get_compat_ipmi_msg(struct ipmi_msg *p64,
624 struct compat_ipmi_msg __user *p32)
625{
626 compat_uptr_t tmp;
627
628 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
629 __get_user(p64->netfn, &p32->netfn) ||
630 __get_user(p64->cmd, &p32->cmd) ||
631 __get_user(p64->data_len, &p32->data_len) ||
632 __get_user(tmp, &p32->data))
633 return -EFAULT;
634 p64->data = compat_ptr(tmp);
635 return 0;
636}
637
638static long put_compat_ipmi_msg(struct ipmi_msg *p64,
639 struct compat_ipmi_msg __user *p32)
640{
641 if (!access_ok(VERIFY_WRITE, p32, sizeof(*p32)) ||
642 __put_user(p64->netfn, &p32->netfn) ||
643 __put_user(p64->cmd, &p32->cmd) ||
644 __put_user(p64->data_len, &p32->data_len))
645 return -EFAULT;
646 return 0;
647}
648
649static long get_compat_ipmi_req(struct ipmi_req *p64,
650 struct compat_ipmi_req __user *p32)
651{
652
653 compat_uptr_t tmp;
654
655 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
656 __get_user(tmp, &p32->addr) ||
657 __get_user(p64->addr_len, &p32->addr_len) ||
658 __get_user(p64->msgid, &p32->msgid) ||
659 get_compat_ipmi_msg(&p64->msg, &p32->msg))
660 return -EFAULT;
661 p64->addr = compat_ptr(tmp);
662 return 0;
663}
664
665static long get_compat_ipmi_req_settime(struct ipmi_req_settime *p64,
666 struct compat_ipmi_req_settime __user *p32)
667{
668 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
669 get_compat_ipmi_req(&p64->req, &p32->req) ||
670 __get_user(p64->retries, &p32->retries) ||
671 __get_user(p64->retry_time_ms, &p32->retry_time_ms))
672 return -EFAULT;
673 return 0;
674}
675
676static long get_compat_ipmi_recv(struct ipmi_recv *p64,
677 struct compat_ipmi_recv __user *p32)
678{
679 compat_uptr_t tmp;
680
681 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
682 __get_user(p64->recv_type, &p32->recv_type) ||
683 __get_user(tmp, &p32->addr) ||
684 __get_user(p64->addr_len, &p32->addr_len) ||
685 __get_user(p64->msgid, &p32->msgid) ||
686 get_compat_ipmi_msg(&p64->msg, &p32->msg))
687 return -EFAULT;
688 p64->addr = compat_ptr(tmp);
689 return 0;
690}
691
692static long put_compat_ipmi_recv(struct ipmi_recv *p64,
693 struct compat_ipmi_recv __user *p32)
694{
695 if (!access_ok(VERIFY_WRITE, p32, sizeof(*p32)) ||
696 __put_user(p64->recv_type, &p32->recv_type) ||
697 __put_user(p64->addr_len, &p32->addr_len) ||
698 __put_user(p64->msgid, &p32->msgid) ||
699 put_compat_ipmi_msg(&p64->msg, &p32->msg))
700 return -EFAULT;
701 return 0;
702}
703
704/*
705 * Handle compatibility ioctls
706 */
707static long compat_ipmi_ioctl(struct file *filep, unsigned int cmd,
708 unsigned long arg)
709{
710 int rc;
711 struct ipmi_file_private *priv = filep->private_data;
712
713 switch(cmd) {
714 case COMPAT_IPMICTL_SEND_COMMAND:
715 {
716 struct ipmi_req rp;
717
718 if (get_compat_ipmi_req(&rp, compat_ptr(arg)))
719 return -EFAULT;
720
721 return handle_send_req(priv->user, &rp,
722 priv->default_retries,
723 priv->default_retry_time_ms);
724 }
725 case COMPAT_IPMICTL_SEND_COMMAND_SETTIME:
726 {
727 struct ipmi_req_settime sp;
728
729 if (get_compat_ipmi_req_settime(&sp, compat_ptr(arg)))
730 return -EFAULT;
731
732 return handle_send_req(priv->user, &sp.req,
733 sp.retries, sp.retry_time_ms);
734 }
735 case COMPAT_IPMICTL_RECEIVE_MSG:
736 case COMPAT_IPMICTL_RECEIVE_MSG_TRUNC:
737 {
738 struct ipmi_recv *precv64, recv64;
739
740 if (get_compat_ipmi_recv(&recv64, compat_ptr(arg)))
741 return -EFAULT;
742
743 precv64 = compat_alloc_user_space(sizeof(recv64));
744 if (copy_to_user(precv64, &recv64, sizeof(recv64)))
745 return -EFAULT;
746
747 rc = ipmi_ioctl(filep->f_dentry->d_inode, filep,
748 ((cmd == COMPAT_IPMICTL_RECEIVE_MSG)
749 ? IPMICTL_RECEIVE_MSG
750 : IPMICTL_RECEIVE_MSG_TRUNC),
751 (long) precv64);
752 if (rc != 0)
753 return rc;
754
755 if (copy_from_user(&recv64, precv64, sizeof(recv64)))
756 return -EFAULT;
757
758 if (put_compat_ipmi_recv(&recv64, compat_ptr(arg)))
759 return -EFAULT;
760
761 return rc;
762 }
763 default:
764 return ipmi_ioctl(filep->f_dentry->d_inode, filep, cmd, arg);
765 }
766}
767#endif
1da177e4
LT		 768
769static struct file_operations ipmi_fops = {
770 .owner = THIS_MODULE,
771 .ioctl = ipmi_ioctl,
6a94f920
AM		 772#ifdef CONFIG_COMPAT
773 .compat_ioctl = compat_ipmi_ioctl,
774#endif
1da177e4
LT		 775 .open = ipmi_open,
776 .release = ipmi_release,
777 .fasync = ipmi_fasync,
778 .poll = ipmi_poll,
779};
780
781#define DEVICE_NAME "ipmidev"
782
783static int ipmi_major = 0;
784module_param(ipmi_major, int, 0);
785MODULE_PARM_DESC(ipmi_major, "Sets the major number of the IPMI device. By"
786 " default, or if you set it to zero, it will choose the next"
787 " available device. Setting it to -1 will disable the"
788 " interface. Other values will set the major device number"
789 " to that value.");
790
eb51b650 791static struct class *ipmi_class;
37e0915b 792
1da177e4
LT		 793static void ipmi_new_smi(int if_num)
794{
37e0915b
CM		 795 dev_t dev = MKDEV(ipmi_major, if_num);
796
797 devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
1da177e4 798 "ipmidev/%d", if_num);
37e0915b 799
eb51b650 800 class_device_create(ipmi_class, dev, NULL, "ipmi%d", if_num);
1da177e4
LT		 801}
802
803static void ipmi_smi_gone(int if_num)
804{
eb51b650 805 class_device_destroy(ipmi_class, MKDEV(ipmi_major, if_num));
1da177e4
LT		 806 devfs_remove("ipmidev/%d", if_num);
807}
808
809static struct ipmi_smi_watcher smi_watcher =
810{
811 .owner = THIS_MODULE,
812 .new_smi = ipmi_new_smi,
813 .smi_gone = ipmi_smi_gone,
814};
815
816static __init int init_ipmi_devintf(void)
817{
818 int rv;
819
820 if (ipmi_major < 0)
821 return -EINVAL;
822
1fdd75bd 823 printk(KERN_INFO "ipmi device interface\n");
1da177e4 824
eb51b650 825 ipmi_class = class_create(THIS_MODULE, "ipmi");
37e0915b
CM		 826 if (IS_ERR(ipmi_class)) {
827 printk(KERN_ERR "ipmi: can't register device class\n");
828 return PTR_ERR(ipmi_class);
829 }
830
1da177e4
LT		 831 rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
832 if (rv < 0) {
eb51b650 833 class_destroy(ipmi_class);
1da177e4
LT		 834 printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
835 return rv;
836 }
837
838 if (ipmi_major == 0) {
839 ipmi_major = rv;
840 }
841
842 devfs_mk_dir(DEVICE_NAME);
843
844 rv = ipmi_smi_watcher_register(&smi_watcher);
845 if (rv) {
846 unregister_chrdev(ipmi_major, DEVICE_NAME);
eb51b650 847 class_destroy(ipmi_class);
1da177e4
LT		 848 printk(KERN_WARNING "ipmi: can't register smi watcher\n");
849 return rv;
850 }
851
852 return 0;
853}
854module_init(init_ipmi_devintf);
855
856static __exit void cleanup_ipmi(void)
857{
eb51b650 858 class_destroy(ipmi_class);
1da177e4
LT		 859 ipmi_smi_watcher_unregister(&smi_watcher);
860 devfs_remove(DEVICE_NAME);
861 unregister_chrdev(ipmi_major, DEVICE_NAME);
862}
863module_exit(cleanup_ipmi);
864
865MODULE_LICENSE("GPL");
1fdd75bd
CM		 866MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
867MODULE_DESCRIPTION("Linux device interface for the IPMI message handler.");
Clone of davem's net-next-2.6 tree