drivers/char/ipmi/ipmi_devintf.c

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