git.oblomov.eu Git - linux-2.6/blob - 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         case WDIOC_SETPRETIMEOUT:
 673                 i = copy_from_user(&val, argp, sizeof(int));
 674                 if (i)
 675                         return -EFAULT;
 676                 pretimeout = val;
 677                 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 678
 679         case WDIOC_GET_PRETIMEOUT:
 680         case WDIOC_GETPRETIMEOUT:
 681                 i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
 682                 if (i)
 683                         return -EFAULT;
 684                 return 0;
 685
 686         case WDIOC_KEEPALIVE:
 687                 return ipmi_heartbeat();
 688
 689         case WDIOC_SETOPTIONS:
 690                 i = copy_from_user(&val, argp, sizeof(int));
 691                 if (i)
 692                         return -EFAULT;
 693                 if (val & WDIOS_DISABLECARD)
 694                 {
 695                         ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 696                         ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 697                         ipmi_start_timer_on_heartbeat = 0;
 698                 }
 699
 700                 if (val & WDIOS_ENABLECARD)
 701                 {
 702                         ipmi_watchdog_state = action_val;
 703                         ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 704                 }
 705                 return 0;
 706
 707         case WDIOC_GETSTATUS:
 708                 val = 0;
 709                 i = copy_to_user(argp, &val, sizeof(val));
 710                 if (i)
 711                         return -EFAULT;
 712                 return 0;
 713
 714         default:
 715                 return -ENOIOCTLCMD;
 716         }
 717 }
 718
 719 static ssize_t ipmi_write(struct file *file,
 720                           const char  __user *buf,
 721                           size_t      len,
 722                           loff_t      *ppos)
 723 {
 724         int rv;
 725
 726         if (len) {
 727                 if (!nowayout) {
 728                         size_t i;
 729
 730                         /* In case it was set long ago */
 731                         expect_close = 0;
 732
 733                         for (i = 0; i != len; i++) {
 734                                 char c;
 735
 736                                 if (get_user(c, buf + i))
 737                                         return -EFAULT;
 738                                 if (c == 'V')
 739                                         expect_close = 42;
 740                         }
 741                 }
 742                 rv = ipmi_heartbeat();
 743                 if (rv)
 744                         return rv;
 745                 return 1;
 746         }
 747         return 0;
 748 }
 749
 750 static ssize_t ipmi_read(struct file *file,
 751                          char        __user *buf,
 752                          size_t      count,
 753                          loff_t      *ppos)
 754 {
 755         int          rv = 0;
 756         wait_queue_t wait;
 757
 758         if (count <= 0)
 759                 return 0;
 760
 761         /* Reading returns if the pretimeout has gone off, and it only does
 762            it once per pretimeout. */
 763         spin_lock(&ipmi_read_lock);
 764         if (!data_to_read) {
 765                 if (file->f_flags & O_NONBLOCK) {
 766                         rv = -EAGAIN;
 767                         goto out;
 768                 }
 769
 770                 init_waitqueue_entry(&wait, current);
 771                 add_wait_queue(&read_q, &wait);
 772                 while (!data_to_read) {
 773                         set_current_state(TASK_INTERRUPTIBLE);
 774                         spin_unlock(&ipmi_read_lock);
 775                         schedule();
 776                         spin_lock(&ipmi_read_lock);
 777                 }
 778                 remove_wait_queue(&read_q, &wait);
 779
 780                 if (signal_pending(current)) {
 781                         rv = -ERESTARTSYS;
 782                         goto out;
 783                 }
 784         }
 785         data_to_read = 0;
 786
 787  out:
 788         spin_unlock(&ipmi_read_lock);
 789
 790         if (rv == 0) {
 791                 if (copy_to_user(buf, &data_to_read, 1))
 792                         rv = -EFAULT;
 793                 else
 794                         rv = 1;
 795         }
 796
 797         return rv;
 798 }
 799
 800 static int ipmi_open(struct inode *ino, struct file *filep)
 801 {
 802         switch (iminor(ino)) {
 803         case WATCHDOG_MINOR:
 804                 if (test_and_set_bit(0, &ipmi_wdog_open))
 805                         return -EBUSY;
 806
 807                 /* Don't start the timer now, let it start on the
 808                    first heartbeat. */
 809                 ipmi_start_timer_on_heartbeat = 1;
 810                 return nonseekable_open(ino, filep);
 811
 812         default:
 813                 return (-ENODEV);
 814         }
 815 }
 816
 817 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
 818 {
 819         unsigned int mask = 0;
 820
 821         poll_wait(file, &read_q, wait);
 822
 823         spin_lock(&ipmi_read_lock);
 824         if (data_to_read)
 825                 mask |= (POLLIN | POLLRDNORM);
 826         spin_unlock(&ipmi_read_lock);
 827
 828         return mask;
 829 }
 830
 831 static int ipmi_fasync(int fd, struct file *file, int on)
 832 {
 833         int result;
 834
 835         result = fasync_helper(fd, file, on, &fasync_q);
 836
 837         return (result);
 838 }
 839
 840 static int ipmi_close(struct inode *ino, struct file *filep)
 841 {
 842         if (iminor(ino) == WATCHDOG_MINOR) {
 843                 if (expect_close == 42) {
 844                         ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 845                         ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 846                 } else {
 847                         printk(KERN_CRIT PFX
 848                                "Unexpected close, not stopping watchdog!\n");
 849                         ipmi_heartbeat();
 850                 }
 851                 clear_bit(0, &ipmi_wdog_open);
 852         }
 853
 854         ipmi_fasync (-1, filep, 0);
 855         expect_close = 0;
 856
 857         return 0;
 858 }
 859
 860 static const struct file_operations ipmi_wdog_fops = {
 861         .owner   = THIS_MODULE,
 862         .read    = ipmi_read,
 863         .poll    = ipmi_poll,
 864         .write   = ipmi_write,
 865         .ioctl   = ipmi_ioctl,
 866         .open    = ipmi_open,
 867         .release = ipmi_close,
 868         .fasync  = ipmi_fasync,
 869 };
 870
 871 static struct miscdevice ipmi_wdog_miscdev = {
 872         .minor          = WATCHDOG_MINOR,
 873         .name           = "watchdog",
 874         .fops           = &ipmi_wdog_fops
 875 };
 876
 877 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
 878                                   void                 *handler_data)
 879 {
 880         if (msg->msg.data[0] != 0) {
 881                 printk(KERN_ERR PFX "response: Error %x on cmd %x\n",
 882                        msg->msg.data[0],
 883                        msg->msg.cmd);
 884         }
 885
 886         ipmi_free_recv_msg(msg);
 887 }
 888
 889 static void ipmi_wdog_pretimeout_handler(void *handler_data)
 890 {
 891         if (preaction_val != WDOG_PRETIMEOUT_NONE) {
 892                 if (preop_val == WDOG_PREOP_PANIC) {
 893                         if (atomic_inc_and_test(&preop_panic_excl))
 894                                 panic("Watchdog pre-timeout");
 895                 } else if (preop_val == WDOG_PREOP_GIVE_DATA) {
 896                         spin_lock(&ipmi_read_lock);
 897                         data_to_read = 1;
 898                         wake_up_interruptible(&read_q);
 899                         kill_fasync(&fasync_q, SIGIO, POLL_IN);
 900
 901                         spin_unlock(&ipmi_read_lock);
 902                 }
 903         }
 904
 905         /* On some machines, the heartbeat will give
 906            an error and not work unless we re-enable
 907            the timer.   So do so. */
 908         pretimeout_since_last_heartbeat = 1;
 909 }
 910
 911 static struct ipmi_user_hndl ipmi_hndlrs =
 912 {
 913         .ipmi_recv_hndl           = ipmi_wdog_msg_handler,
 914         .ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler
 915 };
 916
 917 static void ipmi_register_watchdog(int ipmi_intf)
 918 {
 919         int rv = -EBUSY;
 920
 921         if (watchdog_user)
 922                 goto out;
 923
 924         if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf))
 925                 goto out;
 926
 927         watchdog_ifnum = ipmi_intf;
 928
 929         rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
 930         if (rv < 0) {
 931                 printk(KERN_CRIT PFX "Unable to register with ipmi\n");
 932                 goto out;
 933         }
 934
 935         ipmi_get_version(watchdog_user,
 936                          &ipmi_version_major,
 937                          &ipmi_version_minor);
 938
 939         rv = misc_register(&ipmi_wdog_miscdev);
 940         if (rv < 0) {
 941                 ipmi_destroy_user(watchdog_user);
 942                 watchdog_user = NULL;
 943                 printk(KERN_CRIT PFX "Unable to register misc device\n");
 944         }
 945
 946 #ifdef HAVE_DIE_NMI
 947         if (nmi_handler_registered) {
 948                 int old_pretimeout = pretimeout;
 949                 int old_timeout = timeout;
 950                 int old_preop_val = preop_val;
 951
 952                 /* Set the pretimeout to go off in a second and give
 953                    ourselves plenty of time to stop the timer. */
 954                 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
 955                 preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */
 956                 pretimeout = 99;
 957                 timeout = 100;
 958
 959                 testing_nmi = 1;
 960
 961                 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 962                 if (rv) {
 963                         printk(KERN_WARNING PFX "Error starting timer to"
 964                                " test NMI: 0x%x.  The NMI pretimeout will"
 965                                " likely not work\n", rv);
 966                         rv = 0;
 967                         goto out_restore;
 968                 }
 969
 970                 msleep(1500);
 971
 972                 if (testing_nmi != 2) {
 973                         printk(KERN_WARNING PFX "IPMI NMI didn't seem to"
 974                                " occur.  The NMI pretimeout will"
 975                                " likely not work\n");
 976                 }
 977         out_restore:
 978                 testing_nmi = 0;
 979                 preop_val = old_preop_val;
 980                 pretimeout = old_pretimeout;
 981                 timeout = old_timeout;
 982         }
 983 #endif
 984
 985  out:
 986         if ((start_now) && (rv == 0)) {
 987                 /* Run from startup, so start the timer now. */
 988                 start_now = 0; /* Disable this function after first startup. */
 989                 ipmi_watchdog_state = action_val;
 990                 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 991                 printk(KERN_INFO PFX "Starting now!\n");
 992         } else {
 993                 /* Stop the timer now. */
 994                 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 995                 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 996         }
 997 }
 998
 999 static void ipmi_unregister_watchdog(int ipmi_intf)
1000 {
1001         int rv;
1002
1003         if (!watchdog_user)
1004                 goto out;
1005
1006         if (watchdog_ifnum != ipmi_intf)
1007                 goto out;
1008
1009         /* Make sure no one can call us any more. */
1010         misc_deregister(&ipmi_wdog_miscdev);
1011
1012         /* Wait to make sure the message makes it out.  The lower layer has
1013            pointers to our buffers, we want to make sure they are done before
1014            we release our memory. */
1015         while (atomic_read(&set_timeout_tofree))
1016                 schedule_timeout_uninterruptible(1);
1017
1018         /* Disconnect from IPMI. */
1019         rv = ipmi_destroy_user(watchdog_user);
1020         if (rv) {
1021                 printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
1022                        rv);
1023         }
1024         watchdog_user = NULL;
1025
1026  out:
1027         return;
1028 }
1029
1030 #ifdef HAVE_DIE_NMI
1031 static int
1032 ipmi_nmi(struct notifier_block *self, unsigned long val, void *data)
1033 {
1034         struct die_args *args = data;
1035
1036         if (val != DIE_NMI)
1037                 return NOTIFY_OK;
1038
1039         /* Hack, if it's a memory or I/O error, ignore it. */
1040         if (args->err & 0xc0)
1041                 return NOTIFY_OK;
1042
1043         /*
1044          * If we get here, it's an NMI that's not a memory or I/O
1045          * error.  We can't truly tell if it's from IPMI or not
1046          * without sending a message, and sending a message is almost
1047          * impossible because of locking.
1048          */
1049
1050         if (testing_nmi) {
1051                 testing_nmi = 2;
1052                 return NOTIFY_STOP;
1053         }
1054
1055         /* If we are not expecting a timeout, ignore it. */
1056         if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
1057                 return NOTIFY_OK;
1058
1059         if (preaction_val != WDOG_PRETIMEOUT_NMI)
1060                 return NOTIFY_OK;
1061
1062         /* If no one else handled the NMI, we assume it was the IPMI
1063            watchdog. */
1064         if (preop_val == WDOG_PREOP_PANIC) {
1065                 /* On some machines, the heartbeat will give
1066                    an error and not work unless we re-enable
1067                    the timer.   So do so. */
1068                 pretimeout_since_last_heartbeat = 1;
1069                 if (atomic_inc_and_test(&preop_panic_excl))
1070                         panic(PFX "pre-timeout");
1071         }
1072
1073         return NOTIFY_STOP;
1074 }
1075
1076 static struct notifier_block ipmi_nmi_handler = {
1077         .notifier_call = ipmi_nmi
1078 };
1079 #endif
1080
1081 static int wdog_reboot_handler(struct notifier_block *this,
1082                                unsigned long         code,
1083                                void                  *unused)
1084 {
1085         static int reboot_event_handled = 0;
1086
1087         if ((watchdog_user) && (!reboot_event_handled)) {
1088                 /* Make sure we only do this once. */
1089                 reboot_event_handled = 1;
1090
1091                 if (code == SYS_POWER_OFF || code == SYS_HALT) {
1092                         /* Disable the WDT if we are shutting down. */
1093                         ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1094                         panic_halt_ipmi_set_timeout();
1095                 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1096                         /* Set a long timer to let the reboot happens, but
1097                            reboot if it hangs, but only if the watchdog
1098                            timer was already running. */
1099                         timeout = 120;
1100                         pretimeout = 0;
1101                         ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
1102                         panic_halt_ipmi_set_timeout();
1103                 }
1104         }
1105         return NOTIFY_OK;
1106 }
1107
1108 static struct notifier_block wdog_reboot_notifier = {
1109         .notifier_call  = wdog_reboot_handler,
1110         .next           = NULL,
1111         .priority       = 0
1112 };
1113
1114 static int wdog_panic_handler(struct notifier_block *this,
1115                               unsigned long         event,
1116                               void                  *unused)
1117 {
1118         static int panic_event_handled = 0;
1119
1120         /* On a panic, if we have a panic timeout, make sure to extend
1121            the watchdog timer to a reasonable value to complete the
1122            panic, if the watchdog timer is running.  Plus the
1123            pretimeout is meaningless at panic time. */
1124         if (watchdog_user && !panic_event_handled &&
1125             ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1126                 /* Make sure we do this only once. */
1127                 panic_event_handled = 1;
1128
1129                 timeout = 255;
1130                 pretimeout = 0;
1131                 panic_halt_ipmi_set_timeout();
1132         }
1133
1134         return NOTIFY_OK;
1135 }
1136
1137 static struct notifier_block wdog_panic_notifier = {
1138         .notifier_call  = wdog_panic_handler,
1139         .next           = NULL,
1140         .priority       = 150   /* priority: INT_MAX >= x >= 0 */
1141 };
1142
1143
1144 static void ipmi_new_smi(int if_num, struct device *device)
1145 {
1146         ipmi_register_watchdog(if_num);
1147 }
1148
1149 static void ipmi_smi_gone(int if_num)
1150 {
1151         ipmi_unregister_watchdog(if_num);
1152 }
1153
1154 static struct ipmi_smi_watcher smi_watcher =
1155 {
1156         .owner    = THIS_MODULE,
1157         .new_smi  = ipmi_new_smi,
1158         .smi_gone = ipmi_smi_gone
1159 };
1160
1161 static int action_op(const char *inval, char *outval)
1162 {
1163         if (outval)
1164                 strcpy(outval, action);
1165
1166         if (!inval)
1167                 return 0;
1168
1169         if (strcmp(inval, "reset") == 0)
1170                 action_val = WDOG_TIMEOUT_RESET;
1171         else if (strcmp(inval, "none") == 0)
1172                 action_val = WDOG_TIMEOUT_NONE;
1173         else if (strcmp(inval, "power_cycle") == 0)
1174                 action_val = WDOG_TIMEOUT_POWER_CYCLE;
1175         else if (strcmp(inval, "power_off") == 0)
1176                 action_val = WDOG_TIMEOUT_POWER_DOWN;
1177         else
1178                 return -EINVAL;
1179         strcpy(action, inval);
1180         return 0;
1181 }
1182
1183 static int preaction_op(const char *inval, char *outval)
1184 {
1185         if (outval)
1186                 strcpy(outval, preaction);
1187
1188         if (!inval)
1189                 return 0;
1190
1191         if (strcmp(inval, "pre_none") == 0)
1192                 preaction_val = WDOG_PRETIMEOUT_NONE;
1193         else if (strcmp(inval, "pre_smi") == 0)
1194                 preaction_val = WDOG_PRETIMEOUT_SMI;
1195 #ifdef HAVE_DIE_NMI
1196         else if (strcmp(inval, "pre_nmi") == 0)
1197                 preaction_val = WDOG_PRETIMEOUT_NMI;
1198 #endif
1199         else if (strcmp(inval, "pre_int") == 0)
1200                 preaction_val = WDOG_PRETIMEOUT_MSG_INT;
1201         else
1202                 return -EINVAL;
1203         strcpy(preaction, inval);
1204         return 0;
1205 }
1206
1207 static int preop_op(const char *inval, char *outval)
1208 {
1209         if (outval)
1210                 strcpy(outval, preop);
1211
1212         if (!inval)
1213                 return 0;
1214
1215         if (strcmp(inval, "preop_none") == 0)
1216                 preop_val = WDOG_PREOP_NONE;
1217         else if (strcmp(inval, "preop_panic") == 0)
1218                 preop_val = WDOG_PREOP_PANIC;
1219         else if (strcmp(inval, "preop_give_data") == 0)
1220                 preop_val = WDOG_PREOP_GIVE_DATA;
1221         else
1222                 return -EINVAL;
1223         strcpy(preop, inval);
1224         return 0;
1225 }
1226
1227 static void check_parms(void)
1228 {
1229 #ifdef HAVE_DIE_NMI
1230         int do_nmi = 0;
1231         int rv;
1232
1233         if (preaction_val == WDOG_PRETIMEOUT_NMI) {
1234                 do_nmi = 1;
1235                 if (preop_val == WDOG_PREOP_GIVE_DATA) {
1236                         printk(KERN_WARNING PFX "Pretimeout op is to give data"
1237                                " but NMI pretimeout is enabled, setting"
1238                                " pretimeout op to none\n");
1239                         preop_op("preop_none", NULL);
1240                         do_nmi = 0;
1241                 }
1242         }
1243         if (do_nmi && !nmi_handler_registered) {
1244                 rv = register_die_notifier(&ipmi_nmi_handler);
1245                 if (rv) {
1246                         printk(KERN_WARNING PFX
1247                                "Can't register nmi handler\n");
1248                         return;
1249                 } else
1250                         nmi_handler_registered = 1;
1251         } else if (!do_nmi && nmi_handler_registered) {
1252                 unregister_die_notifier(&ipmi_nmi_handler);
1253                 nmi_handler_registered = 0;
1254         }
1255 #endif
1256 }
1257
1258 static int __init ipmi_wdog_init(void)
1259 {
1260         int rv;
1261
1262         if (action_op(action, NULL)) {
1263                 action_op("reset", NULL);
1264                 printk(KERN_INFO PFX "Unknown action '%s', defaulting to"
1265                        " reset\n", action);
1266         }
1267
1268         if (preaction_op(preaction, NULL)) {
1269                 preaction_op("pre_none", NULL);
1270                 printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to"
1271                        " none\n", preaction);
1272         }
1273
1274         if (preop_op(preop, NULL)) {
1275                 preop_op("preop_none", NULL);
1276                 printk(KERN_INFO PFX "Unknown preop '%s', defaulting to"
1277                        " none\n", preop);
1278         }
1279
1280         check_parms();
1281
1282         register_reboot_notifier(&wdog_reboot_notifier);
1283         atomic_notifier_chain_register(&panic_notifier_list,
1284                         &wdog_panic_notifier);
1285
1286         rv = ipmi_smi_watcher_register(&smi_watcher);
1287         if (rv) {
1288 #ifdef HAVE_DIE_NMI
1289                 if (nmi_handler_registered)
1290                         unregister_die_notifier(&ipmi_nmi_handler);
1291 #endif
1292                 atomic_notifier_chain_unregister(&panic_notifier_list,
1293                                                  &wdog_panic_notifier);
1294                 unregister_reboot_notifier(&wdog_reboot_notifier);
1295                 printk(KERN_WARNING PFX "can't register smi watcher\n");
1296                 return rv;
1297         }
1298
1299         printk(KERN_INFO PFX "driver initialized\n");
1300
1301         return 0;
1302 }
1303
1304 static void __exit ipmi_wdog_exit(void)
1305 {
1306         ipmi_smi_watcher_unregister(&smi_watcher);
1307         ipmi_unregister_watchdog(watchdog_ifnum);
1308
1309 #ifdef HAVE_DIE_NMI
1310         if (nmi_handler_registered)
1311                 unregister_die_notifier(&ipmi_nmi_handler);
1312 #endif
1313
1314         atomic_notifier_chain_unregister(&panic_notifier_list,
1315                                          &wdog_panic_notifier);
1316         unregister_reboot_notifier(&wdog_reboot_notifier);
1317 }
1318 module_exit(ipmi_wdog_exit);
1319 module_init(ipmi_wdog_init);
1320 MODULE_LICENSE("GPL");
1321 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1322 MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");