2 * Watchdog driver for the mpcore watchdog timer
4 * (c) Copyright 2004 ARM Limited
6 * Based on the SoftDog driver:
7 * (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
8 * http://www.redhat.com
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
15 * Neither Alan Cox nor CymruNet Ltd. admit liability nor provide
16 * warranty for any of this software. This material is provided
17 * "AS-IS" and at no charge.
19 * (c) Copyright 1995 Alan Cox <alan@lxorguk.ukuu.org.uk>
22 #include <linux/module.h>
23 #include <linux/moduleparam.h>
24 #include <linux/config.h>
25 #include <linux/types.h>
26 #include <linux/miscdevice.h>
27 #include <linux/watchdog.h>
29 #include <linux/reboot.h>
30 #include <linux/init.h>
31 #include <linux/interrupt.h>
32 #include <linux/platform_device.h>
34 #include <asm/hardware/arm_twd.h>
35 #include <asm/uaccess.h>
38 unsigned long timer_alive
;
46 static struct platform_device
*mpcore_wdt_dev
;
48 extern unsigned int mpcore_timer_rate
;
50 #define TIMER_MARGIN 60
51 static int mpcore_margin
= TIMER_MARGIN
;
52 module_param(mpcore_margin
, int, 0);
53 MODULE_PARM_DESC(mpcore_margin
, "MPcore timer margin in seconds. (0<mpcore_margin<65536, default=" __MODULE_STRING(TIMER_MARGIN
) ")");
55 static int nowayout
= WATCHDOG_NOWAYOUT
;
56 module_param(nowayout
, int, 0);
57 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT
) ")");
59 #define ONLY_TESTING 0
60 static int mpcore_noboot
= ONLY_TESTING
;
61 module_param(mpcore_noboot
, int, 0);
62 MODULE_PARM_DESC(mpcore_noboot
, "MPcore watchdog action, set to 1 to ignore reboots, 0 to reboot (default=" __MODULE_STRING(ONLY_TESTING
) ")");
65 * This is the interrupt handler. Note that we only use this
66 * in testing mode, so don't actually do a reboot here.
68 static irqreturn_t
mpcore_wdt_fire(int irq
, void *arg
, struct pt_regs
*regs
)
70 struct mpcore_wdt
*wdt
= arg
;
72 /* Check it really was our interrupt */
73 if (readl(wdt
->base
+ TWD_WDOG_INTSTAT
)) {
74 dev_printk(KERN_CRIT
, wdt
->dev
, "Triggered - Reboot ignored.\n");
76 /* Clear the interrupt on the watchdog */
77 writel(1, wdt
->base
+ TWD_WDOG_INTSTAT
);
86 * mpcore_wdt_keepalive - reload the timer
88 * Note that the spec says a DIFFERENT value must be written to the reload
89 * register each time. The "perturb" variable deals with this by adding 1
90 * to the count every other time the function is called.
92 static void mpcore_wdt_keepalive(struct mpcore_wdt
*wdt
)
96 /* Assume prescale is set to 256 */
97 count
= (mpcore_timer_rate
/ 256) * mpcore_margin
;
99 /* Reload the counter */
100 writel(count
+ wdt
->perturb
, wdt
->base
+ TWD_WDOG_LOAD
);
102 wdt
->perturb
= wdt
->perturb
? 0 : 1;
105 static void mpcore_wdt_stop(struct mpcore_wdt
*wdt
)
107 writel(0x12345678, wdt
->base
+ TWD_WDOG_DISABLE
);
108 writel(0x87654321, wdt
->base
+ TWD_WDOG_DISABLE
);
109 writel(0x0, wdt
->base
+ TWD_WDOG_CONTROL
);
112 static void mpcore_wdt_start(struct mpcore_wdt
*wdt
)
114 dev_printk(KERN_INFO
, wdt
->dev
, "enabling watchdog.\n");
116 /* This loads the count register but does NOT start the count yet */
117 mpcore_wdt_keepalive(wdt
);
120 /* Enable watchdog - prescale=256, watchdog mode=0, enable=1 */
121 writel(0x0000FF01, wdt
->base
+ TWD_WDOG_CONTROL
);
123 /* Enable watchdog - prescale=256, watchdog mode=1, enable=1 */
124 writel(0x0000FF09, wdt
->base
+ TWD_WDOG_CONTROL
);
128 static int mpcore_wdt_set_heartbeat(int t
)
130 if (t
< 0x0001 || t
> 0xFFFF)
138 * /dev/watchdog handling
140 static int mpcore_wdt_open(struct inode
*inode
, struct file
*file
)
142 struct mpcore_wdt
*wdt
= platform_get_drvdata(mpcore_wdt_dev
);
144 if (test_and_set_bit(0, &wdt
->timer_alive
))
148 __module_get(THIS_MODULE
);
150 file
->private_data
= wdt
;
155 mpcore_wdt_start(wdt
);
157 return nonseekable_open(inode
, file
);
160 static int mpcore_wdt_release(struct inode
*inode
, struct file
*file
)
162 struct mpcore_wdt
*wdt
= file
->private_data
;
165 * Shut off the timer.
166 * Lock it in if it's a module and we set nowayout
168 if (wdt
->expect_close
== 42) {
169 mpcore_wdt_stop(wdt
);
171 dev_printk(KERN_CRIT
, wdt
->dev
, "unexpected close, not stopping watchdog!\n");
172 mpcore_wdt_keepalive(wdt
);
174 clear_bit(0, &wdt
->timer_alive
);
175 wdt
->expect_close
= 0;
179 static ssize_t
mpcore_wdt_write(struct file
*file
, const char *data
, size_t len
, loff_t
*ppos
)
181 struct mpcore_wdt
*wdt
= file
->private_data
;
190 /* In case it was set long ago */
191 wdt
->expect_close
= 0;
193 for (i
= 0; i
!= len
; i
++) {
196 if (get_user(c
, data
+ i
))
199 wdt
->expect_close
= 42;
202 mpcore_wdt_keepalive(wdt
);
207 static struct watchdog_info ident
= {
208 .options
= WDIOF_SETTIMEOUT
|
209 WDIOF_KEEPALIVEPING
|
211 .identity
= "MPcore Watchdog",
214 static int mpcore_wdt_ioctl(struct inode
*inode
, struct file
*file
,
215 unsigned int cmd
, unsigned long arg
)
217 struct mpcore_wdt
*wdt
= file
->private_data
;
220 struct watchdog_info ident
;
224 if (_IOC_DIR(cmd
) && _IOC_SIZE(cmd
) > sizeof(uarg
))
227 if (_IOC_DIR(cmd
) & _IOC_WRITE
) {
228 ret
= copy_from_user(&uarg
, (void __user
*)arg
, _IOC_SIZE(cmd
));
234 case WDIOC_GETSUPPORT
:
239 case WDIOC_SETOPTIONS
:
241 if (uarg
.i
& WDIOS_DISABLECARD
) {
242 mpcore_wdt_stop(wdt
);
245 if (uarg
.i
& WDIOS_ENABLECARD
) {
246 mpcore_wdt_start(wdt
);
251 case WDIOC_GETSTATUS
:
252 case WDIOC_GETBOOTSTATUS
:
257 case WDIOC_KEEPALIVE
:
258 mpcore_wdt_keepalive(wdt
);
262 case WDIOC_SETTIMEOUT
:
263 ret
= mpcore_wdt_set_heartbeat(uarg
.i
);
267 mpcore_wdt_keepalive(wdt
);
269 case WDIOC_GETTIMEOUT
:
270 uarg
.i
= mpcore_margin
;
278 if (ret
== 0 && _IOC_DIR(cmd
) & _IOC_READ
) {
279 ret
= copy_to_user((void __user
*)arg
, &uarg
, _IOC_SIZE(cmd
));
287 * System shutdown handler. Turn off the watchdog if we're
288 * restarting or halting the system.
290 static void mpcore_wdt_shutdown(struct platform_device
*dev
)
292 struct mpcore_wdt
*wdt
= platform_get_drvdata(dev
);
294 if (system_state
== SYSTEM_RESTART
|| system_state
== SYSTEM_HALT
)
295 mpcore_wdt_stop(wdt
);
301 static struct file_operations mpcore_wdt_fops
= {
302 .owner
= THIS_MODULE
,
304 .write
= mpcore_wdt_write
,
305 .ioctl
= mpcore_wdt_ioctl
,
306 .open
= mpcore_wdt_open
,
307 .release
= mpcore_wdt_release
,
310 static struct miscdevice mpcore_wdt_miscdev
= {
311 .minor
= WATCHDOG_MINOR
,
313 .fops
= &mpcore_wdt_fops
,
316 static int __devinit
mpcore_wdt_probe(struct platform_device
*dev
)
318 struct mpcore_wdt
*wdt
;
319 struct resource
*res
;
322 /* We only accept one device, and it must have an id of -1 */
326 res
= platform_get_resource(dev
, IORESOURCE_MEM
, 0);
332 wdt
= kmalloc(sizeof(struct mpcore_wdt
), GFP_KERNEL
);
337 memset(wdt
, 0, sizeof(struct mpcore_wdt
));
339 wdt
->dev
= &dev
->dev
;
340 wdt
->irq
= platform_get_irq(dev
, 0);
341 wdt
->base
= ioremap(res
->start
, res
->end
- res
->start
+ 1);
347 mpcore_wdt_miscdev
.dev
= &dev
->dev
;
348 ret
= misc_register(&mpcore_wdt_miscdev
);
350 dev_printk(KERN_ERR
, _dev
, "cannot register miscdev on minor=%d (err=%d)\n",
351 WATCHDOG_MINOR
, ret
);
355 ret
= request_irq(wdt
->irq
, mpcore_wdt_fire
, SA_INTERRUPT
, "mpcore_wdt", wdt
);
357 dev_printk(KERN_ERR
, _dev
, "cannot register IRQ%d for watchdog\n", wdt
->irq
);
361 mpcore_wdt_stop(wdt
);
362 platform_set_drvdata(&dev
->dev
, wdt
);
363 mpcore_wdt_dev
= dev
;
368 misc_deregister(&mpcore_wdt_miscdev
);
377 static int __devexit
mpcore_wdt_remove(struct platform_device
*dev
)
379 struct mpcore_wdt
*wdt
= platform_get_drvdata(dev
);
381 platform_set_drvdata(dev
, NULL
);
383 misc_deregister(&mpcore_wdt_miscdev
);
385 mpcore_wdt_dev
= NULL
;
387 free_irq(wdt
->irq
, wdt
);
393 static struct platform_driver mpcore_wdt_driver
= {
394 .probe
= mpcore_wdt_probe
,
395 .remove
= __devexit_p(mpcore_wdt_remove
),
396 .shutdown
= mpcore_wdt_shutdown
,
398 .owner
= THIS_MODULE
,
399 .name
= "mpcore_wdt",
403 static char banner
[] __initdata
= KERN_INFO
"MPcore Watchdog Timer: 0.1. mpcore_noboot=%d mpcore_margin=%d sec (nowayout= %d)\n";
405 static int __init
mpcore_wdt_init(void)
408 * Check that the margin value is within it's range;
409 * if not reset to the default
411 if (mpcore_wdt_set_heartbeat(mpcore_margin
)) {
412 mpcore_wdt_set_heartbeat(TIMER_MARGIN
);
413 printk(KERN_INFO
"mpcore_margin value must be 0<mpcore_margin<65536, using %d\n",
417 printk(banner
, mpcore_noboot
, mpcore_margin
, nowayout
);
419 return platform_driver_register(&mpcore_wdt_driver
);
422 static void __exit
mpcore_wdt_exit(void)
424 platform_driver_unregister(&mpcore_wdt_driver
);
427 module_init(mpcore_wdt_init
);
428 module_exit(mpcore_wdt_exit
);
430 MODULE_AUTHOR("ARM Limited");
431 MODULE_DESCRIPTION("MPcore Watchdog Device Driver");
432 MODULE_LICENSE("GPL");
433 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);