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
= dev_get_drvdata(&mpcore_wdt_dev
->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
;
183 /* Can't seek (pwrite) on this device */
184 if (ppos
!= &file
->f_pos
)
194 /* In case it was set long ago */
195 wdt
->expect_close
= 0;
197 for (i
= 0; i
!= len
; i
++) {
200 if (get_user(c
, data
+ i
))
203 wdt
->expect_close
= 42;
206 mpcore_wdt_keepalive(wdt
);
211 static struct watchdog_info ident
= {
212 .options
= WDIOF_SETTIMEOUT
|
213 WDIOF_KEEPALIVEPING
|
215 .identity
= "MPcore Watchdog",
218 static int mpcore_wdt_ioctl(struct inode
*inode
, struct file
*file
,
219 unsigned int cmd
, unsigned long arg
)
221 struct mpcore_wdt
*wdt
= file
->private_data
;
224 struct watchdog_info ident
;
228 if (_IOC_DIR(cmd
) && _IOC_SIZE(cmd
) > sizeof(uarg
))
231 if (_IOC_DIR(cmd
) & _IOC_WRITE
) {
232 ret
= copy_from_user(&uarg
, (void __user
*)arg
, _IOC_SIZE(cmd
));
238 case WDIOC_GETSUPPORT
:
243 case WDIOC_SETOPTIONS
:
245 if (uarg
.i
& WDIOS_DISABLECARD
) {
246 mpcore_wdt_stop(wdt
);
249 if (uarg
.i
& WDIOS_ENABLECARD
) {
250 mpcore_wdt_start(wdt
);
255 case WDIOC_GETSTATUS
:
256 case WDIOC_GETBOOTSTATUS
:
261 case WDIOC_KEEPALIVE
:
262 mpcore_wdt_keepalive(wdt
);
266 case WDIOC_SETTIMEOUT
:
267 ret
= mpcore_wdt_set_heartbeat(uarg
.i
);
271 mpcore_wdt_keepalive(wdt
);
273 case WDIOC_GETTIMEOUT
:
274 uarg
.i
= mpcore_margin
;
282 if (ret
== 0 && _IOC_DIR(cmd
) & _IOC_READ
) {
283 ret
= copy_to_user((void __user
*)arg
, &uarg
, _IOC_SIZE(cmd
));
291 * System shutdown handler. Turn off the watchdog if we're
292 * restarting or halting the system.
294 static void mpcore_wdt_shutdown(struct device
*_dev
)
296 struct mpcore_wdt
*wdt
= dev_get_drvdata(_dev
);
298 if (system_state
== SYSTEM_RESTART
|| system_state
== SYSTEM_HALT
)
299 mpcore_wdt_stop(wdt
);
305 static struct file_operations mpcore_wdt_fops
= {
306 .owner
= THIS_MODULE
,
308 .write
= mpcore_wdt_write
,
309 .ioctl
= mpcore_wdt_ioctl
,
310 .open
= mpcore_wdt_open
,
311 .release
= mpcore_wdt_release
,
314 static struct miscdevice mpcore_wdt_miscdev
= {
315 .minor
= WATCHDOG_MINOR
,
317 .fops
= &mpcore_wdt_fops
,
320 static int __devinit
mpcore_wdt_probe(struct device
*_dev
)
322 struct platform_device
*dev
= to_platform_device(_dev
);
323 struct mpcore_wdt
*wdt
;
324 struct resource
*res
;
327 /* We only accept one device, and it must have an id of -1 */
331 res
= platform_get_resource(dev
, IORESOURCE_MEM
, 0);
337 wdt
= kmalloc(sizeof(struct mpcore_wdt
), GFP_KERNEL
);
342 memset(wdt
, 0, sizeof(struct mpcore_wdt
));
344 wdt
->dev
= &dev
->dev
;
345 wdt
->irq
= platform_get_irq(dev
, 0);
346 wdt
->base
= ioremap(res
->start
, res
->end
- res
->start
+ 1);
352 mpcore_wdt_miscdev
.dev
= &dev
->dev
;
353 ret
= misc_register(&mpcore_wdt_miscdev
);
355 dev_printk(KERN_ERR
, _dev
, "cannot register miscdev on minor=%d (err=%d)\n",
356 WATCHDOG_MINOR
, ret
);
360 ret
= request_irq(wdt
->irq
, mpcore_wdt_fire
, SA_INTERRUPT
, "mpcore_wdt", wdt
);
362 dev_printk(KERN_ERR
, _dev
, "cannot register IRQ%d for watchdog\n", wdt
->irq
);
366 mpcore_wdt_stop(wdt
);
367 dev_set_drvdata(&dev
->dev
, wdt
);
368 mpcore_wdt_dev
= dev
;
373 misc_deregister(&mpcore_wdt_miscdev
);
382 static int __devexit
mpcore_wdt_remove(struct device
*dev
)
384 struct mpcore_wdt
*wdt
= dev_get_drvdata(dev
);
386 dev_set_drvdata(dev
, NULL
);
388 misc_deregister(&mpcore_wdt_miscdev
);
390 mpcore_wdt_dev
= NULL
;
392 free_irq(wdt
->irq
, wdt
);
398 static struct device_driver mpcore_wdt_driver
= {
399 .name
= "mpcore_wdt",
400 .bus
= &platform_bus_type
,
401 .probe
= mpcore_wdt_probe
,
402 .remove
= __devexit_p(mpcore_wdt_remove
),
403 .shutdown
= mpcore_wdt_shutdown
,
406 static char banner
[] __initdata
= KERN_INFO
"MPcore Watchdog Timer: 0.1. mpcore_noboot=%d mpcore_margin=%d sec (nowayout= %d)\n";
408 static int __init
mpcore_wdt_init(void)
411 * Check that the margin value is within it's range;
412 * if not reset to the default
414 if (mpcore_wdt_set_heartbeat(mpcore_margin
)) {
415 mpcore_wdt_set_heartbeat(TIMER_MARGIN
);
416 printk(KERN_INFO
"mpcore_margin value must be 0<mpcore_margin<65536, using %d\n",
420 printk(banner
, mpcore_noboot
, mpcore_margin
, nowayout
);
422 return driver_register(&mpcore_wdt_driver
);
425 static void __exit
mpcore_wdt_exit(void)
427 driver_unregister(&mpcore_wdt_driver
);
430 module_init(mpcore_wdt_init
);
431 module_exit(mpcore_wdt_exit
);
433 MODULE_AUTHOR("ARM Limited");
434 MODULE_DESCRIPTION("MPcore Watchdog Device Driver");
435 MODULE_LICENSE("GPL");
436 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);