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