2 * 60xx Single Board Computer Watchdog Timer driver for Linux 2.2.x
4 * Based on acquirewdt.c by Alan Cox.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
11 * The author does NOT admit liability nor provide warranty for
12 * any of this software. This material is provided "AS-IS" in
13 * the hope that it may be useful for others.
15 * (c) Copyright 2000 Jakob Oestergaard <jakob@unthought.net>
17 * 12/4 - 2000 [Initial revision]
18 * 25/4 - 2000 Added /dev/watchdog support
19 * 09/5 - 2001 [smj@oro.net] fixed fop_write to "return 1" on success
20 * 12/4 - 2002 [rob@osinvestor.com] eliminate fop_read
21 * fix possible wdt_is_open race
22 * add CONFIG_WATCHDOG_NOWAYOUT support
23 * remove lock_kernel/unlock_kernel pairs
24 * added KERN_* to printk's
25 * got rid of extraneous comments
26 * changed watchdog_info to correctly reflect what the driver offers
27 * added WDIOC_GETSTATUS, WDIOC_GETBOOTSTATUS, WDIOC_SETTIMEOUT,
28 * WDIOC_GETTIMEOUT, and WDIOC_SETOPTIONS ioctls
29 * 09/8 - 2003 [wim@iguana.be] cleanup of trailing spaces
31 * made timeout (the emulated heartbeat) a module_param
32 * made the keepalive ping an internal subroutine
33 * made wdt_stop and wdt_start module params
34 * added extra printk's for startup problems
35 * added MODULE_AUTHOR and MODULE_DESCRIPTION info
38 * This WDT driver is different from the other Linux WDT
39 * drivers in the following ways:
40 * *) The driver will ping the watchdog by itself, because this
41 * particular WDT has a very short timeout (one second) and it
42 * would be insane to count on any userspace daemon always
43 * getting scheduled within that time frame.
47 #include <linux/module.h>
48 #include <linux/moduleparam.h>
49 #include <linux/types.h>
50 #include <linux/timer.h>
51 #include <linux/jiffies.h>
52 #include <linux/miscdevice.h>
53 #include <linux/watchdog.h>
55 #include <linux/ioport.h>
56 #include <linux/notifier.h>
57 #include <linux/reboot.h>
58 #include <linux/init.h>
61 #include <asm/uaccess.h>
62 #include <asm/system.h>
64 #define OUR_NAME "sbc60xxwdt"
65 #define PFX OUR_NAME ": "
68 * You must set these - The driver cannot probe for the settings
71 static int wdt_stop
= 0x45;
72 module_param(wdt_stop
, int, 0);
73 MODULE_PARM_DESC(wdt_stop
, "SBC60xx WDT 'stop' io port (default 0x45)");
75 static int wdt_start
= 0x443;
76 module_param(wdt_start
, int, 0);
77 MODULE_PARM_DESC(wdt_start
, "SBC60xx WDT 'start' io port (default 0x443)");
80 * The 60xx board can use watchdog timeout values from one second
81 * to several minutes. The default is one second, so if we reset
82 * the watchdog every ~250ms we should be safe.
85 #define WDT_INTERVAL (HZ/4+1)
88 * We must not require too good response from the userspace daemon.
89 * Here we require the userspace daemon to send us a heartbeat
90 * char to /dev/watchdog every 30 seconds.
91 * If the daemon pulses us every 25 seconds, we can still afford
92 * a 5 second scheduling delay on the (high priority) daemon. That
93 * should be sufficient for a box under any load.
96 #define WATCHDOG_TIMEOUT 30 /* 30 sec default timeout */
97 static int timeout
= WATCHDOG_TIMEOUT
; /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
98 module_param(timeout
, int, 0);
99 MODULE_PARM_DESC(timeout
, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT
) ")");
101 static int nowayout
= WATCHDOG_NOWAYOUT
;
102 module_param(nowayout
, int, 0);
103 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
105 static void wdt_timer_ping(unsigned long);
106 static struct timer_list timer
;
107 static unsigned long next_heartbeat
;
108 static unsigned long wdt_is_open
;
109 static char wdt_expect_close
;
115 static void wdt_timer_ping(unsigned long data
)
117 /* If we got a heartbeat pulse within the WDT_US_INTERVAL
118 * we agree to ping the WDT
120 if(time_before(jiffies
, next_heartbeat
))
122 /* Ping the WDT by reading from wdt_start */
124 /* Re-set the timer interval */
125 timer
.expires
= jiffies
+ WDT_INTERVAL
;
128 printk(KERN_WARNING PFX
"Heartbeat lost! Will not ping the watchdog\n");
136 static void wdt_startup(void)
138 next_heartbeat
= jiffies
+ (timeout
* HZ
);
140 /* Start the timer */
141 timer
.expires
= jiffies
+ WDT_INTERVAL
;
143 printk(KERN_INFO PFX
"Watchdog timer is now enabled.\n");
146 static void wdt_turnoff(void)
151 printk(KERN_INFO PFX
"Watchdog timer is now disabled...\n");
154 static void wdt_keepalive(void)
157 next_heartbeat
= jiffies
+ (timeout
* HZ
);
161 * /dev/watchdog handling
164 static ssize_t
fop_write(struct file
* file
, const char __user
* buf
, size_t count
, loff_t
* ppos
)
166 /* See if we got the magic character 'V' and reload the timer */
173 /* note: just in case someone wrote the magic character
174 * five months ago... */
175 wdt_expect_close
= 0;
177 /* scan to see whether or not we got the magic character */
178 for(ofs
= 0; ofs
!= count
; ofs
++)
181 if(get_user(c
, buf
+ofs
))
184 wdt_expect_close
= 42;
188 /* Well, anyhow someone wrote to us, we should return that favour */
194 static int fop_open(struct inode
* inode
, struct file
* file
)
196 nonseekable_open(inode
, file
);
198 /* Just in case we're already talking to someone... */
199 if(test_and_set_bit(0, &wdt_is_open
))
203 __module_get(THIS_MODULE
);
205 /* Good, fire up the show */
210 static int fop_close(struct inode
* inode
, struct file
* file
)
212 if(wdt_expect_close
== 42)
216 printk(KERN_CRIT PFX
"device file closed unexpectedly. Will not stop the WDT!\n");
218 clear_bit(0, &wdt_is_open
);
219 wdt_expect_close
= 0;
223 static int fop_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
,
226 void __user
*argp
= (void __user
*)arg
;
227 int __user
*p
= argp
;
228 static struct watchdog_info ident
=
230 .options
= WDIOF_KEEPALIVEPING
| WDIOF_SETTIMEOUT
| WDIOF_MAGICCLOSE
,
231 .firmware_version
= 1,
232 .identity
= "SBC60xx",
239 case WDIOC_GETSUPPORT
:
240 return copy_to_user(argp
, &ident
, sizeof(ident
))?-EFAULT
:0;
241 case WDIOC_GETSTATUS
:
242 case WDIOC_GETBOOTSTATUS
:
243 return put_user(0, p
);
244 case WDIOC_KEEPALIVE
:
247 case WDIOC_SETOPTIONS
:
249 int new_options
, retval
= -EINVAL
;
251 if(get_user(new_options
, p
))
254 if(new_options
& WDIOS_DISABLECARD
) {
259 if(new_options
& WDIOS_ENABLECARD
) {
266 case WDIOC_SETTIMEOUT
:
270 if(get_user(new_timeout
, p
))
273 if(new_timeout
< 1 || new_timeout
> 3600) /* arbitrary upper limit */
276 timeout
= new_timeout
;
280 case WDIOC_GETTIMEOUT
:
281 return put_user(timeout
, p
);
285 static const struct file_operations wdt_fops
= {
286 .owner
= THIS_MODULE
,
290 .release
= fop_close
,
294 static struct miscdevice wdt_miscdev
= {
295 .minor
= WATCHDOG_MINOR
,
301 * Notifier for system down
304 static int wdt_notify_sys(struct notifier_block
*this, unsigned long code
,
307 if(code
==SYS_DOWN
|| code
==SYS_HALT
)
313 * The WDT needs to learn about soft shutdowns in order to
314 * turn the timebomb registers off.
317 static struct notifier_block wdt_notifier
=
319 .notifier_call
= wdt_notify_sys
,
322 static void __exit
sbc60xxwdt_unload(void)
327 misc_deregister(&wdt_miscdev
);
329 unregister_reboot_notifier(&wdt_notifier
);
330 if ((wdt_stop
!= 0x45) && (wdt_stop
!= wdt_start
))
331 release_region(wdt_stop
,1);
332 release_region(wdt_start
,1);
335 static int __init
sbc60xxwdt_init(void)
339 if(timeout
< 1 || timeout
> 3600) /* arbitrary upper limit */
341 timeout
= WATCHDOG_TIMEOUT
;
342 printk(KERN_INFO PFX
"timeout value must be 1<=x<=3600, using %d\n",
346 if (!request_region(wdt_start
, 1, "SBC 60XX WDT"))
348 printk(KERN_ERR PFX
"I/O address 0x%04x already in use\n",
354 /* We cannot reserve 0x45 - the kernel already has! */
355 if ((wdt_stop
!= 0x45) && (wdt_stop
!= wdt_start
))
357 if (!request_region(wdt_stop
, 1, "SBC 60XX WDT"))
359 printk(KERN_ERR PFX
"I/O address 0x%04x already in use\n",
362 goto err_out_region1
;
367 timer
.function
= wdt_timer_ping
;
370 rc
= misc_register(&wdt_miscdev
);
373 printk(KERN_ERR PFX
"cannot register miscdev on minor=%d (err=%d)\n",
374 wdt_miscdev
.minor
, rc
);
375 goto err_out_region2
;
378 rc
= register_reboot_notifier(&wdt_notifier
);
381 printk(KERN_ERR PFX
"cannot register reboot notifier (err=%d)\n",
383 goto err_out_miscdev
;
386 printk(KERN_INFO PFX
"WDT driver for 60XX single board computer initialised. timeout=%d sec (nowayout=%d)\n",
392 misc_deregister(&wdt_miscdev
);
394 if ((wdt_stop
!= 0x45) && (wdt_stop
!= wdt_start
))
395 release_region(wdt_stop
,1);
397 release_region(wdt_start
,1);
402 module_init(sbc60xxwdt_init
);
403 module_exit(sbc60xxwdt_unload
);
405 MODULE_AUTHOR("Jakob Oestergaard <jakob@unthought.net>");
406 MODULE_DESCRIPTION("60xx Single Board Computer Watchdog Timer driver");
407 MODULE_LICENSE("GPL");
408 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);