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