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