Merge branch 'dmapool' of git://git.kernel.org/pub/scm/linux/kernel/git/willy/misc
[linux-2.6] / 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.");