drivers/char/ipmi/ipmi_watchdog.c

   1 /*
   2  * ipmi_watchdog.c
   3  *
   4  * A watchdog timer based upon the IPMI interface.
   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/module.h>
  35 #include <linux/moduleparam.h>
  36 #include <linux/ipmi.h>
  37 #include <linux/ipmi_smi.h>
  38 #include <linux/watchdog.h>
  39 #include <linux/miscdevice.h>
  40 #include <linux/init.h>
  41 #include <linux/completion.h>
  42 #include <linux/kdebug.h>
  43 #include <linux/rwsem.h>
  44 #include <linux/errno.h>
  45 #include <asm/uaccess.h>
  46 #include <linux/notifier.h>
  47 #include <linux/nmi.h>
  48 #include <linux/reboot.h>
  49 #include <linux/wait.h>
  50 #include <linux/poll.h>
  51 #include <linux/string.h>
  52 #include <linux/ctype.h>
  53 #include <linux/delay.h>
  54 #include <asm/atomic.h>
  55
  56 #ifdef CONFIG_X86
  57 /* This is ugly, but I've determined that x86 is the only architecture
  58    that can reasonably support the IPMI NMI watchdog timeout at this
  59    time.  If another architecture adds this capability somehow, it
  60    will have to be a somewhat different mechanism and I have no idea
  61    how it will work.  So in the unlikely event that another
  62    architecture supports this, we can figure out a good generic
  63    mechanism for it at that time. */
  64 #include <asm/kdebug.h>
  65 #define HAVE_DIE_NMI
  66 #endif
  67
  68 #define PFX "IPMI Watchdog: "
  69
  70 /*
  71  * The IPMI command/response information for the watchdog timer.
  72  */
  73
  74 /* values for byte 1 of the set command, byte 2 of the get response. */
  75 #define WDOG_DONT_LOG           (1 << 7)
  76 #define WDOG_DONT_STOP_ON_SET   (1 << 6)
  77 #define WDOG_SET_TIMER_USE(byte, use) \
  78         byte = ((byte) & 0xf8) | ((use) & 0x7)
  79 #define WDOG_GET_TIMER_USE(byte) ((byte) & 0x7)
  80 #define WDOG_TIMER_USE_BIOS_FRB2        1
  81 #define WDOG_TIMER_USE_BIOS_POST        2
  82 #define WDOG_TIMER_USE_OS_LOAD          3
  83 #define WDOG_TIMER_USE_SMS_OS           4
  84 #define WDOG_TIMER_USE_OEM              5
  85
  86 /* values for byte 2 of the set command, byte 3 of the get response. */
  87 #define WDOG_SET_PRETIMEOUT_ACT(byte, use) \
  88         byte = ((byte) & 0x8f) | (((use) & 0x7) << 4)
  89 #define WDOG_GET_PRETIMEOUT_ACT(byte) (((byte) >> 4) & 0x7)
  90 #define WDOG_PRETIMEOUT_NONE            0
  91 #define WDOG_PRETIMEOUT_SMI             1
  92 #define WDOG_PRETIMEOUT_NMI             2
  93 #define WDOG_PRETIMEOUT_MSG_INT         3
  94
  95 /* Operations that can be performed on a pretimout. */
  96 #define WDOG_PREOP_NONE         0
  97 #define WDOG_PREOP_PANIC        1
  98 #define WDOG_PREOP_GIVE_DATA    2 /* Cause data to be available to
  99                                      read.  Doesn't work in NMI
 100                                      mode. */
 101
 102 /* Actions to perform on a full timeout. */
 103 #define WDOG_SET_TIMEOUT_ACT(byte, use) \
 104         byte = ((byte) & 0xf8) | ((use) & 0x7)
 105 #define WDOG_GET_TIMEOUT_ACT(byte) ((byte) & 0x7)
 106 #define WDOG_TIMEOUT_NONE               0
 107 #define WDOG_TIMEOUT_RESET              1
 108 #define WDOG_TIMEOUT_POWER_DOWN         2
 109 #define WDOG_TIMEOUT_POWER_CYCLE        3
 110
 111 /* Byte 3 of the get command, byte 4 of the get response is the
 112    pre-timeout in seconds. */
 113
 114 /* Bits for setting byte 4 of the set command, byte 5 of the get response. */
 115 #define WDOG_EXPIRE_CLEAR_BIOS_FRB2     (1 << 1)
 116 #define WDOG_EXPIRE_CLEAR_BIOS_POST     (1 << 2)
 117 #define WDOG_EXPIRE_CLEAR_OS_LOAD       (1 << 3)
 118 #define WDOG_EXPIRE_CLEAR_SMS_OS        (1 << 4)
 119 #define WDOG_EXPIRE_CLEAR_OEM           (1 << 5)
 120
 121 /* Setting/getting the watchdog timer value.  This is for bytes 5 and
 122    6 (the timeout time) of the set command, and bytes 6 and 7 (the
 123    timeout time) and 8 and 9 (the current countdown value) of the
 124    response.  The timeout value is given in seconds (in the command it
 125    is 100ms intervals). */
 126 #define WDOG_SET_TIMEOUT(byte1, byte2, val) \
 127         (byte1) = (((val) * 10) & 0xff), (byte2) = (((val) * 10) >> 8)
 128 #define WDOG_GET_TIMEOUT(byte1, byte2) \
 129         (((byte1) | ((byte2) << 8)) / 10)
 130
 131 #define IPMI_WDOG_RESET_TIMER           0x22
 132 #define IPMI_WDOG_SET_TIMER             0x24
 133 #define IPMI_WDOG_GET_TIMER             0x25
 134
 135 /* These are here until the real ones get into the watchdog.h interface. */
 136 #ifndef WDIOC_GETTIMEOUT
 137 #define WDIOC_GETTIMEOUT        _IOW(WATCHDOG_IOCTL_BASE, 20, int)
 138 #endif
 139 #ifndef WDIOC_SET_PRETIMEOUT
 140 #define WDIOC_SET_PRETIMEOUT     _IOW(WATCHDOG_IOCTL_BASE, 21, int)
 141 #endif
 142 #ifndef WDIOC_GET_PRETIMEOUT
 143 #define WDIOC_GET_PRETIMEOUT     _IOW(WATCHDOG_IOCTL_BASE, 22, int)
 144 #endif
 145
 146 static int nowayout = WATCHDOG_NOWAYOUT;
 147
 148 static ipmi_user_t watchdog_user;
 149 static int watchdog_ifnum;
 150
 151 /* Default the timeout to 10 seconds. */
 152 static int timeout = 10;
 153
 154 /* The pre-timeout is disabled by default. */
 155 static int pretimeout;
 156
 157 /* Default action is to reset the board on a timeout. */
 158 static unsigned char action_val = WDOG_TIMEOUT_RESET;
 159
 160 static char action[16] = "reset";
 161
 162 static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
 163
 164 static char preaction[16] = "pre_none";
 165
 166 static unsigned char preop_val = WDOG_PREOP_NONE;
 167
 168 static char preop[16] = "preop_none";
 169 static DEFINE_SPINLOCK(ipmi_read_lock);
 170 static char data_to_read;
 171 static DECLARE_WAIT_QUEUE_HEAD(read_q);
 172 static struct fasync_struct *fasync_q;
 173 static char pretimeout_since_last_heartbeat;
 174 static char expect_close;
 175
 176 static int ifnum_to_use = -1;
 177
 178 /* Parameters to ipmi_set_timeout */
 179 #define IPMI_SET_TIMEOUT_NO_HB                  0
 180 #define IPMI_SET_TIMEOUT_HB_IF_NECESSARY        1
 181 #define IPMI_SET_TIMEOUT_FORCE_HB               2
 182
 183 static int ipmi_set_timeout(int do_heartbeat);
 184 static void ipmi_register_watchdog(int ipmi_intf);
 185 static void ipmi_unregister_watchdog(int ipmi_intf);
 186
 187 /* If true, the driver will start running as soon as it is configured
 188    and ready. */
 189 static int start_now;
 190
 191 static int set_param_int(const char *val, struct kernel_param *kp)
 192 {
 193         char *endp;
 194         int  l;
 195         int  rv = 0;
 196
 197         if (!val)
 198                 return -EINVAL;
 199         l = simple_strtoul(val, &endp, 0);
 200         if (endp == val)
 201                 return -EINVAL;
 202
 203         *((int *)kp->arg) = l;
 204         if (watchdog_user)
 205                 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 206
 207         return rv;
 208 }
 209
 210 static int get_param_int(char *buffer, struct kernel_param *kp)
 211 {
 212         return sprintf(buffer, "%i", *((int *)kp->arg));
 213 }
 214
 215 typedef int (*action_fn)(const char *intval, char *outval);
 216
 217 static int action_op(const char *inval, char *outval);
 218 static int preaction_op(const char *inval, char *outval);
 219 static int preop_op(const char *inval, char *outval);
 220 static void check_parms(void);
 221
 222 static int set_param_str(const char *val, struct kernel_param *kp)
 223 {
 224         action_fn  fn = (action_fn) kp->arg;
 225         int        rv = 0;
 226         char       valcp[16];
 227         char       *s;
 228
 229         strncpy(valcp, val, 16);
 230         valcp[15] = '\0';
 231
 232         s = strstrip(valcp);
 233
 234         rv = fn(s, NULL);
 235         if (rv)
 236                 goto out;
 237
 238         check_parms();
 239         if (watchdog_user)
 240                 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 241
 242  out:
 243         return rv;
 244 }
 245
 246 static int get_param_str(char *buffer, struct kernel_param *kp)
 247 {
 248         action_fn fn = (action_fn) kp->arg;
 249         int       rv;
 250
 251         rv = fn(NULL, buffer);
 252         if (rv)
 253                 return rv;
 254         return strlen(buffer);
 255 }
 256
 257
 258 static int set_param_wdog_ifnum(const char *val, struct kernel_param *kp)
 259 {
 260         int rv = param_set_int(val, kp);
 261         if (rv)
 262                 return rv;
 263         if ((ifnum_to_use < 0) || (ifnum_to_use == watchdog_ifnum))
 264                 return 0;
 265
 266         ipmi_unregister_watchdog(watchdog_ifnum);
 267         ipmi_register_watchdog(ifnum_to_use);
 268         return 0;
 269 }
 270
 271 module_param_call(ifnum_to_use, set_param_wdog_ifnum, get_param_int,
 272                   &ifnum_to_use, 0644);
 273 MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
 274                  "timer.  Setting to -1 defaults to the first registered "
 275                  "interface");
 276
 277 module_param_call(timeout, set_param_int, get_param_int, &timeout, 0644);
 278 MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
 279
 280 module_param_call(pretimeout, set_param_int, get_param_int, &pretimeout, 0644);
 281 MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
 282
 283 module_param_call(action, set_param_str, get_param_str, action_op, 0644);
 284 MODULE_PARM_DESC(action, "Timeout action. One of: "
 285                  "reset, none, power_cycle, power_off.");
 286
 287 module_param_call(preaction, set_param_str, get_param_str, preaction_op, 0644);
 288 MODULE_PARM_DESC(preaction, "Pretimeout action.  One of: "
 289                  "pre_none, pre_smi, pre_nmi, pre_int.");
 290
 291 module_param_call(preop, set_param_str, get_param_str, preop_op, 0644);
 292 MODULE_PARM_DESC(preop, "Pretimeout driver operation.  One of: "
 293                  "preop_none, preop_panic, preop_give_data.");
 294
 295 module_param(start_now, int, 0444);
 296 MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
 297                  "soon as the driver is loaded.");
 298
 299 module_param(nowayout, int, 0644);
 300 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
 301                  "(default=CONFIG_WATCHDOG_NOWAYOUT)");
 302
 303 /* Default state of the timer. */
 304 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 305
 306 /* If shutting down via IPMI, we ignore the heartbeat. */
 307 static int ipmi_ignore_heartbeat;
 308
 309 /* Is someone using the watchdog?  Only one user is allowed. */
 310 static unsigned long ipmi_wdog_open;
 311
 312 /* If set to 1, the heartbeat command will set the state to reset and
 313    start the timer.  The timer doesn't normally run when the driver is
 314    first opened until the heartbeat is set the first time, this
 315    variable is used to accomplish this. */
 316 static int ipmi_start_timer_on_heartbeat;
 317
 318 /* IPMI version of the BMC. */
 319 static unsigned char ipmi_version_major;
 320 static unsigned char ipmi_version_minor;
 321
 322 /* If a pretimeout occurs, this is used to allow only one panic to happen. */
 323 static atomic_t preop_panic_excl = ATOMIC_INIT(-1);
 324
 325 #ifdef HAVE_DIE_NMI
 326 static int testing_nmi;
 327 static int nmi_handler_registered;
 328 #endif
 329
 330 static int ipmi_heartbeat(void);
 331
 332 /* We use a mutex to make sure that only one thing can send a set
 333    timeout at one time, because we only have one copy of the data.
 334    The mutex is claimed when the set_timeout is sent and freed
 335    when both messages are free. */
 336 static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
 337 static DEFINE_MUTEX(set_timeout_lock);
 338 static DECLARE_COMPLETION(set_timeout_wait);
 339 static void set_timeout_free_smi(struct ipmi_smi_msg *msg)
 340 {
 341     if (atomic_dec_and_test(&set_timeout_tofree))
 342             complete(&set_timeout_wait);
 343 }
 344 static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
 345 {
 346     if (atomic_dec_and_test(&set_timeout_tofree))
 347             complete(&set_timeout_wait);
 348 }
 349 static struct ipmi_smi_msg set_timeout_smi_msg =
 350 {
 351         .done = set_timeout_free_smi
 352 };
 353 static struct ipmi_recv_msg set_timeout_recv_msg =
 354 {
 355         .done = set_timeout_free_recv
 356 };
 357
 358 static int i_ipmi_set_timeout(struct ipmi_smi_msg  *smi_msg,
 359                               struct ipmi_recv_msg *recv_msg,
 360                               int                  *send_heartbeat_now)
 361 {
 362         struct kernel_ipmi_msg            msg;
 363         unsigned char                     data[6];
 364         int                               rv;
 365         struct ipmi_system_interface_addr addr;
 366         int                               hbnow = 0;
 367
 368
 369         /* These can be cleared as we are setting the timeout. */
 370         pretimeout_since_last_heartbeat = 0;
 371
 372         data[0] = 0;
 373         WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
 374
 375         if ((ipmi_version_major > 1)
 376             || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5)))
 377         {
 378                 /* This is an IPMI 1.5-only feature. */
 379                 data[0] |= WDOG_DONT_STOP_ON_SET;
 380         } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
 381                 /* In ipmi 1.0, setting the timer stops the watchdog, we
 382                    need to start it back up again. */
 383                 hbnow = 1;
 384         }
 385
 386         data[1] = 0;
 387         WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state);
 388         if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) {
 389             WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val);
 390             data[2] = pretimeout;
 391         } else {
 392             WDOG_SET_PRETIMEOUT_ACT(data[1], WDOG_PRETIMEOUT_NONE);
 393             data[2] = 0; /* No pretimeout. */
 394         }
 395         data[3] = 0;
 396         WDOG_SET_TIMEOUT(data[4], data[5], timeout);
 397
 398         addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
 399         addr.channel = IPMI_BMC_CHANNEL;
 400         addr.lun = 0;
 401
 402         msg.netfn = 0x06;
 403         msg.cmd = IPMI_WDOG_SET_TIMER;
 404         msg.data = data;
 405         msg.data_len = sizeof(data);
 406         rv = ipmi_request_supply_msgs(watchdog_user,
 407                                       (struct ipmi_addr *) &addr,
 408                                       0,
 409                                       &msg,
 410                                       NULL,
 411                                       smi_msg,
 412                                       recv_msg,
 413                                       1);
 414         if (rv) {
 415                 printk(KERN_WARNING PFX "set timeout error: %d\n",
 416                        rv);
 417         }
 418
 419         if (send_heartbeat_now)
 420             *send_heartbeat_now = hbnow;
 421
 422         return rv;
 423 }
 424
 425 static int ipmi_set_timeout(int do_heartbeat)
 426 {
 427         int send_heartbeat_now;
 428         int rv;
 429
 430
 431         /* We can only send one of these at a time. */
 432         mutex_lock(&set_timeout_lock);
 433
 434         atomic_set(&set_timeout_tofree, 2);
 435
 436         rv = i_ipmi_set_timeout(&set_timeout_smi_msg,
 437                                 &set_timeout_recv_msg,
 438                                 &send_heartbeat_now);
 439         if (rv) {
 440                 mutex_unlock(&set_timeout_lock);
 441                 goto out;
 442         }
 443
 444         wait_for_completion(&set_timeout_wait);
 445
 446         mutex_unlock(&set_timeout_lock);
 447
 448         if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
 449             || ((send_heartbeat_now)
 450                 && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
 451                 rv = ipmi_heartbeat();
 452
 453 out:
 454         return rv;
 455 }
 456
 457 static atomic_t panic_done_count = ATOMIC_INIT(0);
 458
 459 static void panic_smi_free(struct ipmi_smi_msg *msg)
 460 {
 461         atomic_dec(&panic_done_count);
 462 }
 463 static void panic_recv_free(struct ipmi_recv_msg *msg)
 464 {
 465         atomic_dec(&panic_done_count);
 466 }
 467
 468 static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg =
 469 {
 470         .done = panic_smi_free
 471 };
 472 static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg =
 473 {
 474         .done = panic_recv_free
 475 };
 476
 477 static void panic_halt_ipmi_heartbeat(void)
 478 {
 479         struct kernel_ipmi_msg             msg;
 480         struct ipmi_system_interface_addr addr;
 481         int rv;
 482
 483         /* Don't reset the timer if we have the timer turned off, that
 484            re-enables the watchdog. */
 485         if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
 486                 return;
 487
 488         addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
 489         addr.channel = IPMI_BMC_CHANNEL;
 490         addr.lun = 0;
 491
 492         msg.netfn = 0x06;
 493         msg.cmd = IPMI_WDOG_RESET_TIMER;
 494         msg.data = NULL;
 495         msg.data_len = 0;
 496         rv = ipmi_request_supply_msgs(watchdog_user,
 497                                       (struct ipmi_addr *) &addr,
 498                                       0,
 499                                       &msg,
 500                                       NULL,
 501                                       &panic_halt_heartbeat_smi_msg,
 502                                       &panic_halt_heartbeat_recv_msg,
 503                                       1);
 504         if (!rv)
 505                 atomic_add(2, &panic_done_count);
 506 }
 507
 508 static struct ipmi_smi_msg panic_halt_smi_msg =
 509 {
 510         .done = panic_smi_free
 511 };
 512 static struct ipmi_recv_msg panic_halt_recv_msg =
 513 {
 514         .done = panic_recv_free
 515 };
 516
 517 /* Special call, doesn't claim any locks.  This is only to be called
 518    at panic or halt time, in run-to-completion mode, when the caller
 519    is the only CPU and the only thing that will be going is these IPMI
 520    calls. */
 521 static void panic_halt_ipmi_set_timeout(void)
 522 {
 523         int send_heartbeat_now;
 524         int rv;
 525
 526         /* Wait for the messages to be free. */
 527         while (atomic_read(&panic_done_count) != 0)
 528                 ipmi_poll_interface(watchdog_user);
 529         rv = i_ipmi_set_timeout(&panic_halt_smi_msg,
 530                                 &panic_halt_recv_msg,
 531                                 &send_heartbeat_now);
 532         if (!rv) {
 533                 atomic_add(2, &panic_done_count);
 534                 if (send_heartbeat_now)
 535                         panic_halt_ipmi_heartbeat();
 536         } else
 537                 printk(KERN_WARNING PFX
 538                        "Unable to extend the watchdog timeout.");
 539         while (atomic_read(&panic_done_count) != 0)
 540                 ipmi_poll_interface(watchdog_user);
 541 }
 542
 543 /* We use a semaphore to make sure that only one thing can send a
 544    heartbeat at one time, because we only have one copy of the data.
 545    The semaphore is claimed when the set_timeout is sent and freed
 546    when both messages are free. */
 547 static atomic_t heartbeat_tofree = ATOMIC_INIT(0);
 548 static DEFINE_MUTEX(heartbeat_lock);
 549 static DECLARE_COMPLETION(heartbeat_wait);
 550 static void heartbeat_free_smi(struct ipmi_smi_msg *msg)
 551 {
 552     if (atomic_dec_and_test(&heartbeat_tofree))
 553             complete(&heartbeat_wait);
 554 }
 555 static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
 556 {
 557     if (atomic_dec_and_test(&heartbeat_tofree))
 558             complete(&heartbeat_wait);
 559 }
 560 static struct ipmi_smi_msg heartbeat_smi_msg =
 561 {
 562         .done = heartbeat_free_smi
 563 };
 564 static struct ipmi_recv_msg heartbeat_recv_msg =
 565 {
 566         .done = heartbeat_free_recv
 567 };
 568
 569 static int ipmi_heartbeat(void)
 570 {
 571         struct kernel_ipmi_msg            msg;
 572         int                               rv;
 573         struct ipmi_system_interface_addr addr;
 574
 575         if (ipmi_ignore_heartbeat)
 576                 return 0;
 577
 578         if (ipmi_start_timer_on_heartbeat) {
 579                 ipmi_start_timer_on_heartbeat = 0;
 580                 ipmi_watchdog_state = action_val;
 581                 return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 582         } else if (pretimeout_since_last_heartbeat) {
 583                 /* A pretimeout occurred, make sure we set the timeout.
 584                    We don't want to set the action, though, we want to
 585                    leave that alone (thus it can't be combined with the
 586                    above operation. */
 587                 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 588         }
 589
 590         mutex_lock(&heartbeat_lock);
 591
 592         atomic_set(&heartbeat_tofree, 2);
 593
 594         /* Don't reset the timer if we have the timer turned off, that
 595            re-enables the watchdog. */
 596         if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) {
 597                 mutex_unlock(&heartbeat_lock);
 598                 return 0;
 599         }
 600
 601         addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
 602         addr.channel = IPMI_BMC_CHANNEL;
 603         addr.lun = 0;
 604
 605         msg.netfn = 0x06;
 606         msg.cmd = IPMI_WDOG_RESET_TIMER;
 607         msg.data = NULL;
 608         msg.data_len = 0;
 609         rv = ipmi_request_supply_msgs(watchdog_user,
 610                                       (struct ipmi_addr *) &addr,
 611                                       0,
 612                                       &msg,
 613                                       NULL,
 614                                       &heartbeat_smi_msg,
 615                                       &heartbeat_recv_msg,
 616                                       1);
 617         if (rv) {
 618                 mutex_unlock(&heartbeat_lock);
 619                 printk(KERN_WARNING PFX "heartbeat failure: %d\n",
 620                        rv);
 621                 return rv;
 622         }
 623
 624         /* Wait for the heartbeat to be sent. */
 625         wait_for_completion(&heartbeat_wait);
 626
 627         if (heartbeat_recv_msg.msg.data[0] != 0) {
 628             /* Got an error in the heartbeat response.  It was already
 629                reported in ipmi_wdog_msg_handler, but we should return
 630                an error here. */
 631             rv = -EINVAL;
 632         }
 633
 634         mutex_unlock(&heartbeat_lock);
 635
 636         return rv;
 637 }
 638
 639 static struct watchdog_info ident =
 640 {
 641         .options        = 0,    /* WDIOF_SETTIMEOUT, */
 642         .firmware_version = 1,
 643         .identity       = "IPMI"
 644 };
 645
 646 static int ipmi_ioctl(struct inode *inode, struct file *file,
 647                       unsigned int cmd, unsigned long arg)
 648 {
 649         void __user *argp = (void __user *)arg;
 650         int i;
 651         int val;
 652
 653         switch(cmd) {
 654         case WDIOC_GETSUPPORT:
 655                 i = copy_to_user(argp, &ident, sizeof(ident));
 656                 return i ? -EFAULT : 0;
 657
 658         case WDIOC_SETTIMEOUT:
 659                 i = copy_from_user(&val, argp, sizeof(int));
 660                 if (i)
 661                         return -EFAULT;
 662                 timeout = val;
 663                 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 664
 665         case WDIOC_GETTIMEOUT:
 666                 i = copy_to_user(argp, &timeout, sizeof(timeout));
 667                 if (i)
 668                         return -EFAULT;
 669                 return 0;
 670
 671         case WDIOC_SET_PRETIMEOUT:
 672                 i = copy_from_user(&val, argp, sizeof(int));
 673                 if (i)
 674                         return -EFAULT;
 675                 pretimeout = val;
 676                 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 677
 678         case WDIOC_GET_PRETIMEOUT:
 679                 i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
 680                 if (i)
 681                         return -EFAULT;
 682                 return 0;
 683
 684         case WDIOC_KEEPALIVE:
 685                 return ipmi_heartbeat();
 686
 687         case WDIOC_SETOPTIONS:
 688                 i = copy_from_user(&val, argp, sizeof(int));
 689                 if (i)
 690                         return -EFAULT;
 691                 if (val & WDIOS_DISABLECARD)
 692                 {
 693                         ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 694                         ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 695                         ipmi_start_timer_on_heartbeat = 0;
 696                 }
 697
 698                 if (val & WDIOS_ENABLECARD)
 699                 {
 700                         ipmi_watchdog_state = action_val;
 701                         ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 702                 }
 703                 return 0;
 704
 705         case WDIOC_GETSTATUS:
 706                 val = 0;
 707                 i = copy_to_user(argp, &val, sizeof(val));
 708                 if (i)
 709                         return -EFAULT;
 710                 return 0;
 711
 712         default:
 713                 return -ENOIOCTLCMD;
 714         }
 715 }
 716
 717 static ssize_t ipmi_write(struct file *file,
 718                           const char  __user *buf,
 719                           size_t      len,
 720                           loff_t      *ppos)
 721 {
 722         int rv;
 723
 724         if (len) {
 725                 if (!nowayout) {
 726                         size_t i;
 727
 728                         /* In case it was set long ago */
 729                         expect_close = 0;
 730
 731                         for (i = 0; i != len; i++) {
 732                                 char c;
 733
 734                                 if (get_user(c, buf + i))
 735                                         return -EFAULT;
 736                                 if (c == 'V')
 737                                         expect_close = 42;
 738                         }
 739                 }
 740                 rv = ipmi_heartbeat();
 741                 if (rv)
 742                         return rv;
 743                 return 1;
 744         }
 745         return 0;
 746 }
 747
 748 static ssize_t ipmi_read(struct file *file,
 749                          char        __user *buf,
 750                          size_t      count,
 751                          loff_t      *ppos)
 752 {
 753         int          rv = 0;
 754         wait_queue_t wait;
 755
 756         if (count <= 0)
 757                 return 0;
 758
 759         /* Reading returns if the pretimeout has gone off, and it only does
 760            it once per pretimeout. */
 761         spin_lock(&ipmi_read_lock);
 762         if (!data_to_read) {
 763                 if (file->f_flags & O_NONBLOCK) {
 764                         rv = -EAGAIN;
 765                         goto out;
 766                 }
 767
 768                 init_waitqueue_entry(&wait, current);
 769                 add_wait_queue(&read_q, &wait);
 770                 while (!data_to_read) {
 771                         set_current_state(TASK_INTERRUPTIBLE);
 772                         spin_unlock(&ipmi_read_lock);
 773                         schedule();
 774                         spin_lock(&ipmi_read_lock);
 775                 }
 776                 remove_wait_queue(&read_q, &wait);
 777
 778                 if (signal_pending(current)) {
 779                         rv = -ERESTARTSYS;
 780                         goto out;
 781                 }
 782         }
 783         data_to_read = 0;
 784
 785  out:
 786         spin_unlock(&ipmi_read_lock);
 787
 788         if (rv == 0) {
 789                 if (copy_to_user(buf, &data_to_read, 1))
 790                         rv = -EFAULT;
 791                 else
 792                         rv = 1;
 793         }
 794
 795         return rv;
 796 }
 797
 798 static int ipmi_open(struct inode *ino, struct file *filep)
 799 {
 800         switch (iminor(ino)) {
 801         case WATCHDOG_MINOR:
 802                 if (test_and_set_bit(0, &ipmi_wdog_open))
 803                         return -EBUSY;
 804
 805                 /* Don't start the timer now, let it start on the
 806                    first heartbeat. */
 807                 ipmi_start_timer_on_heartbeat = 1;
 808                 return nonseekable_open(ino, filep);
 809
 810         default:
 811                 return (-ENODEV);
 812         }
 813 }
 814
 815 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
 816 {
 817         unsigned int mask = 0;
 818
 819         poll_wait(file, &read_q, wait);
 820
 821         spin_lock(&ipmi_read_lock);
 822         if (data_to_read)
 823                 mask |= (POLLIN | POLLRDNORM);
 824         spin_unlock(&ipmi_read_lock);
 825
 826         return mask;
 827 }
 828
 829 static int ipmi_fasync(int fd, struct file *file, int on)
 830 {
 831         int result;
 832
 833         result = fasync_helper(fd, file, on, &fasync_q);
 834
 835         return (result);
 836 }
 837
 838 static int ipmi_close(struct inode *ino, struct file *filep)
 839 {
 840         if (iminor(ino) == WATCHDOG_MINOR) {
 841                 if (expect_close == 42) {
 842                         ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 843                         ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 844                 } else {
 845                         printk(KERN_CRIT PFX
 846                                "Unexpected close, not stopping watchdog!\n");
 847                         ipmi_heartbeat();
 848                 }
 849                 clear_bit(0, &ipmi_wdog_open);
 850         }
 851
 852         ipmi_fasync (-1, filep, 0);
 853         expect_close = 0;
 854
 855         return 0;
 856 }
 857
 858 static const struct file_operations ipmi_wdog_fops = {
 859         .owner   = THIS_MODULE,
 860         .read    = ipmi_read,
 861         .poll    = ipmi_poll,
 862         .write   = ipmi_write,
 863         .ioctl   = ipmi_ioctl,
 864         .open    = ipmi_open,
 865         .release = ipmi_close,
 866         .fasync  = ipmi_fasync,
 867 };
 868
 869 static struct miscdevice ipmi_wdog_miscdev = {
 870         .minor          = WATCHDOG_MINOR,
 871         .name           = "watchdog",
 872         .fops           = &ipmi_wdog_fops
 873 };
 874
 875 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
 876                                   void                 *handler_data)
 877 {
 878         if (msg->msg.data[0] != 0) {
 879                 printk(KERN_ERR PFX "response: Error %x on cmd %x\n",
 880                        msg->msg.data[0],
 881                        msg->msg.cmd);
 882         }
 883
 884         ipmi_free_recv_msg(msg);
 885 }
 886
 887 static void ipmi_wdog_pretimeout_handler(void *handler_data)
 888 {
 889         if (preaction_val != WDOG_PRETIMEOUT_NONE) {
 890                 if (preop_val == WDOG_PREOP_PANIC) {
 891                         if (atomic_inc_and_test(&preop_panic_excl))
 892                                 panic("Watchdog pre-timeout");
 893                 } else if (preop_val == WDOG_PREOP_GIVE_DATA) {
 894                         spin_lock(&ipmi_read_lock);
 895                         data_to_read = 1;
 896                         wake_up_interruptible(&read_q);
 897                         kill_fasync(&fasync_q, SIGIO, POLL_IN);
 898
 899                         spin_unlock(&ipmi_read_lock);
 900                 }
 901         }
 902
 903         /* On some machines, the heartbeat will give
 904            an error and not work unless we re-enable
 905            the timer.   So do so. */
 906         pretimeout_since_last_heartbeat = 1;
 907 }
 908
 909 static struct ipmi_user_hndl ipmi_hndlrs =
 910 {
 911         .ipmi_recv_hndl           = ipmi_wdog_msg_handler,
 912         .ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler
 913 };
 914
 915 static void ipmi_register_watchdog(int ipmi_intf)
 916 {
 917         int rv = -EBUSY;
 918
 919         if (watchdog_user)
 920                 goto out;
 921
 922         if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf))
 923                 goto out;
 924
 925         watchdog_ifnum = ipmi_intf;
 926
 927         rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
 928         if (rv < 0) {
 929                 printk(KERN_CRIT PFX "Unable to register with ipmi\n");
 930                 goto out;
 931         }
 932
 933         ipmi_get_version(watchdog_user,
 934                          &ipmi_version_major,
 935                          &ipmi_version_minor);
 936
 937         rv = misc_register(&ipmi_wdog_miscdev);
 938         if (rv < 0) {
 939                 ipmi_destroy_user(watchdog_user);
 940                 watchdog_user = NULL;
 941                 printk(KERN_CRIT PFX "Unable to register misc device\n");
 942         }
 943
 944 #ifdef HAVE_DIE_NMI
 945         if (nmi_handler_registered) {
 946                 int old_pretimeout = pretimeout;
 947                 int old_timeout = timeout;
 948                 int old_preop_val = preop_val;
 949
 950                 /* Set the pretimeout to go off in a second and give
 951                    ourselves plenty of time to stop the timer. */
 952                 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
 953                 preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */
 954                 pretimeout = 99;
 955                 timeout = 100;
 956
 957                 testing_nmi = 1;
 958
 959                 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 960                 if (rv) {
 961                         printk(KERN_WARNING PFX "Error starting timer to"
 962                                " test NMI: 0x%x.  The NMI pretimeout will"
 963                                " likely not work\n", rv);
 964                         rv = 0;
 965                         goto out_restore;
 966                 }
 967
 968                 msleep(1500);
 969
 970                 if (testing_nmi != 2) {
 971                         printk(KERN_WARNING PFX "IPMI NMI didn't seem to"
 972                                " occur.  The NMI pretimeout will"
 973                                " likely not work\n");
 974                 }
 975         out_restore:
 976                 testing_nmi = 0;
 977                 preop_val = old_preop_val;
 978                 pretimeout = old_pretimeout;
 979                 timeout = old_timeout;
 980         }
 981 #endif
 982
 983  out:
 984         if ((start_now) && (rv == 0)) {
 985                 /* Run from startup, so start the timer now. */
 986                 start_now = 0; /* Disable this function after first startup. */
 987                 ipmi_watchdog_state = action_val;
 988                 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 989                 printk(KERN_INFO PFX "Starting now!\n");
 990         } else {
 991                 /* Stop the timer now. */
 992                 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 993                 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 994         }
 995 }
 996
 997 static void ipmi_unregister_watchdog(int ipmi_intf)
 998 {
 999         int rv;
1000
1001         if (!watchdog_user)
1002                 goto out;
1003
1004         if (watchdog_ifnum != ipmi_intf)
1005                 goto out;
1006
1007         /* Make sure no one can call us any more. */
1008         misc_deregister(&ipmi_wdog_miscdev);
1009
1010         /* Wait to make sure the message makes it out.  The lower layer has
1011            pointers to our buffers, we want to make sure they are done before
1012            we release our memory. */
1013         while (atomic_read(&set_timeout_tofree))
1014                 schedule_timeout_uninterruptible(1);
1015
1016         /* Disconnect from IPMI. */
1017         rv = ipmi_destroy_user(watchdog_user);
1018         if (rv) {
1019                 printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
1020                        rv);
1021         }
1022         watchdog_user = NULL;
1023
1024  out:
1025         return;
1026 }
1027
1028 #ifdef HAVE_DIE_NMI
1029 static int
1030 ipmi_nmi(struct notifier_block *self, unsigned long val, void *data)
1031 {
1032         struct die_args *args = data;
1033
1034         if (val != DIE_NMI)
1035                 return NOTIFY_OK;
1036
1037         /* Hack, if it's a memory or I/O error, ignore it. */
1038         if (args->err & 0xc0)
1039                 return NOTIFY_OK;
1040
1041         /*
1042          * If we get here, it's an NMI that's not a memory or I/O
1043          * error.  We can't truly tell if it's from IPMI or not
1044          * without sending a message, and sending a message is almost
1045          * impossible because of locking.
1046          */
1047
1048         if (testing_nmi) {
1049                 testing_nmi = 2;
1050                 return NOTIFY_STOP;
1051         }
1052
1053         /* If we are not expecting a timeout, ignore it. */
1054         if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
1055                 return NOTIFY_OK;
1056
1057         if (preaction_val != WDOG_PRETIMEOUT_NMI)
1058                 return NOTIFY_OK;
1059
1060         /* If no one else handled the NMI, we assume it was the IPMI
1061            watchdog. */
1062         if (preop_val == WDOG_PREOP_PANIC) {
1063                 /* On some machines, the heartbeat will give
1064                    an error and not work unless we re-enable
1065                    the timer.   So do so. */
1066                 pretimeout_since_last_heartbeat = 1;
1067                 if (atomic_inc_and_test(&preop_panic_excl))
1068                         panic(PFX "pre-timeout");
1069         }
1070
1071         return NOTIFY_STOP;
1072 }
1073
1074 static struct notifier_block ipmi_nmi_handler = {
1075         .notifier_call = ipmi_nmi
1076 };
1077 #endif
1078
1079 static int wdog_reboot_handler(struct notifier_block *this,
1080                                unsigned long         code,
1081                                void                  *unused)
1082 {
1083         static int reboot_event_handled = 0;
1084
1085         if ((watchdog_user) && (!reboot_event_handled)) {
1086                 /* Make sure we only do this once. */
1087                 reboot_event_handled = 1;
1088
1089                 if (code == SYS_POWER_OFF || code == SYS_HALT) {
1090                         /* Disable the WDT if we are shutting down. */
1091                         ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1092                         panic_halt_ipmi_set_timeout();
1093                 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1094                         /* Set a long timer to let the reboot happens, but
1095                            reboot if it hangs, but only if the watchdog
1096                            timer was already running. */
1097                         timeout = 120;
1098                         pretimeout = 0;
1099                         ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
1100                         panic_halt_ipmi_set_timeout();
1101                 }
1102         }
1103         return NOTIFY_OK;
1104 }
1105
1106 static struct notifier_block wdog_reboot_notifier = {
1107         .notifier_call  = wdog_reboot_handler,
1108         .next           = NULL,
1109         .priority       = 0
1110 };
1111
1112 static int wdog_panic_handler(struct notifier_block *this,
1113                               unsigned long         event,
1114                               void                  *unused)
1115 {
1116         static int panic_event_handled = 0;
1117
1118         /* On a panic, if we have a panic timeout, make sure to extend
1119            the watchdog timer to a reasonable value to complete the
1120            panic, if the watchdog timer is running.  Plus the
1121            pretimeout is meaningless at panic time. */
1122         if (watchdog_user && !panic_event_handled &&
1123             ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1124                 /* Make sure we do this only once. */
1125                 panic_event_handled = 1;
1126
1127                 timeout = 255;
1128                 pretimeout = 0;
1129                 panic_halt_ipmi_set_timeout();
1130         }
1131
1132         return NOTIFY_OK;
1133 }
1134
1135 static struct notifier_block wdog_panic_notifier = {
1136         .notifier_call  = wdog_panic_handler,
1137         .next           = NULL,
1138         .priority       = 150   /* priority: INT_MAX >= x >= 0 */
1139 };
1140
1141
1142 static void ipmi_new_smi(int if_num, struct device *device)
1143 {
1144         ipmi_register_watchdog(if_num);
1145 }
1146
1147 static void ipmi_smi_gone(int if_num)
1148 {
1149         ipmi_unregister_watchdog(if_num);
1150 }
1151
1152 static struct ipmi_smi_watcher smi_watcher =
1153 {
1154         .owner    = THIS_MODULE,
1155         .new_smi  = ipmi_new_smi,
1156         .smi_gone = ipmi_smi_gone
1157 };
1158
1159 static int action_op(const char *inval, char *outval)
1160 {
1161         if (outval)
1162                 strcpy(outval, action);
1163
1164         if (!inval)
1165                 return 0;
1166
1167         if (strcmp(inval, "reset") == 0)
1168                 action_val = WDOG_TIMEOUT_RESET;
1169         else if (strcmp(inval, "none") == 0)
1170                 action_val = WDOG_TIMEOUT_NONE;
1171         else if (strcmp(inval, "power_cycle") == 0)
1172                 action_val = WDOG_TIMEOUT_POWER_CYCLE;
1173         else if (strcmp(inval, "power_off") == 0)
1174                 action_val = WDOG_TIMEOUT_POWER_DOWN;
1175         else
1176                 return -EINVAL;
1177         strcpy(action, inval);
1178         return 0;
1179 }
1180
1181 static int preaction_op(const char *inval, char *outval)
1182 {
1183         if (outval)
1184                 strcpy(outval, preaction);
1185
1186         if (!inval)
1187                 return 0;
1188
1189         if (strcmp(inval, "pre_none") == 0)
1190                 preaction_val = WDOG_PRETIMEOUT_NONE;
1191         else if (strcmp(inval, "pre_smi") == 0)
1192                 preaction_val = WDOG_PRETIMEOUT_SMI;
1193 #ifdef HAVE_DIE_NMI
1194         else if (strcmp(inval, "pre_nmi") == 0)
1195                 preaction_val = WDOG_PRETIMEOUT_NMI;
1196 #endif
1197         else if (strcmp(inval, "pre_int") == 0)
1198                 preaction_val = WDOG_PRETIMEOUT_MSG_INT;
1199         else
1200                 return -EINVAL;
1201         strcpy(preaction, inval);
1202         return 0;
1203 }
1204
1205 static int preop_op(const char *inval, char *outval)
1206 {
1207         if (outval)
1208                 strcpy(outval, preop);
1209
1210         if (!inval)
1211                 return 0;
1212
1213         if (strcmp(inval, "preop_none") == 0)
1214                 preop_val = WDOG_PREOP_NONE;
1215         else if (strcmp(inval, "preop_panic") == 0)
1216                 preop_val = WDOG_PREOP_PANIC;
1217         else if (strcmp(inval, "preop_give_data") == 0)
1218                 preop_val = WDOG_PREOP_GIVE_DATA;
1219         else
1220                 return -EINVAL;
1221         strcpy(preop, inval);
1222         return 0;
1223 }
1224
1225 static void check_parms(void)
1226 {
1227 #ifdef HAVE_DIE_NMI
1228         int do_nmi = 0;
1229         int rv;
1230
1231         if (preaction_val == WDOG_PRETIMEOUT_NMI) {
1232                 do_nmi = 1;
1233                 if (preop_val == WDOG_PREOP_GIVE_DATA) {
1234                         printk(KERN_WARNING PFX "Pretimeout op is to give data"
1235                                " but NMI pretimeout is enabled, setting"
1236                                " pretimeout op to none\n");
1237                         preop_op("preop_none", NULL);
1238                         do_nmi = 0;
1239                 }
1240         }
1241         if (do_nmi && !nmi_handler_registered) {
1242                 rv = register_die_notifier(&ipmi_nmi_handler);
1243                 if (rv) {
1244                         printk(KERN_WARNING PFX
1245                                "Can't register nmi handler\n");
1246                         return;
1247                 } else
1248                         nmi_handler_registered = 1;
1249         } else if (!do_nmi && nmi_handler_registered) {
1250                 unregister_die_notifier(&ipmi_nmi_handler);
1251                 nmi_handler_registered = 0;
1252         }
1253 #endif
1254 }
1255
1256 static int __init ipmi_wdog_init(void)
1257 {
1258         int rv;
1259
1260         if (action_op(action, NULL)) {
1261                 action_op("reset", NULL);
1262                 printk(KERN_INFO PFX "Unknown action '%s', defaulting to"
1263                        " reset\n", action);
1264         }
1265
1266         if (preaction_op(preaction, NULL)) {
1267                 preaction_op("pre_none", NULL);
1268                 printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to"
1269                        " none\n", preaction);
1270         }
1271
1272         if (preop_op(preop, NULL)) {
1273                 preop_op("preop_none", NULL);
1274                 printk(KERN_INFO PFX "Unknown preop '%s', defaulting to"
1275                        " none\n", preop);
1276         }
1277
1278         check_parms();
1279
1280         register_reboot_notifier(&wdog_reboot_notifier);
1281         atomic_notifier_chain_register(&panic_notifier_list,
1282                         &wdog_panic_notifier);
1283
1284         rv = ipmi_smi_watcher_register(&smi_watcher);
1285         if (rv) {
1286 #ifdef HAVE_DIE_NMI
1287                 if (nmi_handler_registered)
1288                         unregister_die_notifier(&ipmi_nmi_handler);
1289 #endif
1290                 atomic_notifier_chain_unregister(&panic_notifier_list,
1291                                                  &wdog_panic_notifier);
1292                 unregister_reboot_notifier(&wdog_reboot_notifier);
1293                 printk(KERN_WARNING PFX "can't register smi watcher\n");
1294                 return rv;
1295         }
1296
1297         printk(KERN_INFO PFX "driver initialized\n");
1298
1299         return 0;
1300 }
1301
1302 static void __exit ipmi_wdog_exit(void)
1303 {
1304         ipmi_smi_watcher_unregister(&smi_watcher);
1305         ipmi_unregister_watchdog(watchdog_ifnum);
1306
1307 #ifdef HAVE_DIE_NMI
1308         if (nmi_handler_registered)
1309                 unregister_die_notifier(&ipmi_nmi_handler);
1310 #endif
1311
1312         atomic_notifier_chain_unregister(&panic_notifier_list,
1313                                          &wdog_panic_notifier);
1314         unregister_reboot_notifier(&wdog_reboot_notifier);
1315 }
1316 module_exit(ipmi_wdog_exit);
1317 module_init(ipmi_wdog_init);
1318 MODULE_LICENSE("GPL");
1319 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1320 MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");