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@lxorguk.ukuu.org.uk>,
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>
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/types.h>
28 #include <linux/miscdevice.h>
29 #include <linux/watchdog.h>
31 #include <linux/reboot.h>
32 #include <linux/init.h>
33 #include <linux/interrupt.h>
34 #include <linux/platform_device.h>
35 #include <linux/uaccess.h>
36 #include <linux/slab.h>
39 #include <asm/smp_twd.h>
42 unsigned long timer_alive
;
50 static struct platform_device
*mpcore_wdt_pdev
;
51 static DEFINE_SPINLOCK(wdt_lock
);
53 #define TIMER_MARGIN 60
54 static int mpcore_margin
= TIMER_MARGIN
;
55 module_param(mpcore_margin
, int, 0);
56 MODULE_PARM_DESC(mpcore_margin
,
57 "MPcore timer margin in seconds. (0 < mpcore_margin < 65536, default="
58 __MODULE_STRING(TIMER_MARGIN
) ")");
60 static bool nowayout
= WATCHDOG_NOWAYOUT
;
61 module_param(nowayout
, bool, 0);
62 MODULE_PARM_DESC(nowayout
,
63 "Watchdog cannot be stopped once started (default="
64 __MODULE_STRING(WATCHDOG_NOWAYOUT
) ")");
66 #define ONLY_TESTING 0
67 static int mpcore_noboot
= ONLY_TESTING
;
68 module_param(mpcore_noboot
, int, 0);
69 MODULE_PARM_DESC(mpcore_noboot
, "MPcore watchdog action, "
70 "set to 1 to ignore reboots, 0 to reboot (default="
71 __MODULE_STRING(ONLY_TESTING
) ")");
74 * This is the interrupt handler. Note that we only use this
75 * in testing mode, so don't actually do a reboot here.
77 static irqreturn_t
mpcore_wdt_fire(int irq
, void *arg
)
79 struct mpcore_wdt
*wdt
= arg
;
81 /* Check it really was our interrupt */
82 if (readl(wdt
->base
+ TWD_WDOG_INTSTAT
)) {
83 dev_crit(wdt
->dev
, "Triggered - Reboot ignored\n");
84 /* Clear the interrupt on the watchdog */
85 writel(1, wdt
->base
+ TWD_WDOG_INTSTAT
);
92 * mpcore_wdt_keepalive - reload the timer
94 * Note that the spec says a DIFFERENT value must be written to the reload
95 * register each time. The "perturb" variable deals with this by adding 1
96 * to the count every other time the function is called.
98 static void mpcore_wdt_keepalive(struct mpcore_wdt
*wdt
)
102 spin_lock(&wdt_lock
);
103 /* Assume prescale is set to 256 */
104 count
= __raw_readl(wdt
->base
+ TWD_WDOG_COUNTER
);
105 count
= (0xFFFFFFFFU
- count
) * (HZ
/ 5);
106 count
= (count
/ 256) * mpcore_margin
;
108 /* Reload the counter */
109 writel(count
+ wdt
->perturb
, wdt
->base
+ TWD_WDOG_LOAD
);
110 wdt
->perturb
= wdt
->perturb
? 0 : 1;
111 spin_unlock(&wdt_lock
);
114 static void mpcore_wdt_stop(struct mpcore_wdt
*wdt
)
116 spin_lock(&wdt_lock
);
117 writel(0x12345678, wdt
->base
+ TWD_WDOG_DISABLE
);
118 writel(0x87654321, wdt
->base
+ TWD_WDOG_DISABLE
);
119 writel(0x0, wdt
->base
+ TWD_WDOG_CONTROL
);
120 spin_unlock(&wdt_lock
);
123 static void mpcore_wdt_start(struct mpcore_wdt
*wdt
)
125 dev_info(wdt
->dev
, "enabling watchdog\n");
127 /* This loads the count register but does NOT start the count yet */
128 mpcore_wdt_keepalive(wdt
);
131 /* Enable watchdog - prescale=256, watchdog mode=0, enable=1 */
132 writel(0x0000FF01, wdt
->base
+ TWD_WDOG_CONTROL
);
134 /* Enable watchdog - prescale=256, watchdog mode=1, enable=1 */
135 writel(0x0000FF09, wdt
->base
+ TWD_WDOG_CONTROL
);
139 static int mpcore_wdt_set_heartbeat(int t
)
141 if (t
< 0x0001 || t
> 0xFFFF)
149 * /dev/watchdog handling
151 static int mpcore_wdt_open(struct inode
*inode
, struct file
*file
)
153 struct mpcore_wdt
*wdt
= platform_get_drvdata(mpcore_wdt_pdev
);
155 if (test_and_set_bit(0, &wdt
->timer_alive
))
159 __module_get(THIS_MODULE
);
161 file
->private_data
= wdt
;
166 mpcore_wdt_start(wdt
);
168 return nonseekable_open(inode
, file
);
171 static int mpcore_wdt_release(struct inode
*inode
, struct file
*file
)
173 struct mpcore_wdt
*wdt
= file
->private_data
;
176 * Shut off the timer.
177 * Lock it in if it's a module and we set nowayout
179 if (wdt
->expect_close
== 42)
180 mpcore_wdt_stop(wdt
);
183 "unexpected close, not stopping watchdog!\n");
184 mpcore_wdt_keepalive(wdt
);
186 clear_bit(0, &wdt
->timer_alive
);
187 wdt
->expect_close
= 0;
191 static ssize_t
mpcore_wdt_write(struct file
*file
, const char *data
,
192 size_t len
, loff_t
*ppos
)
194 struct mpcore_wdt
*wdt
= file
->private_data
;
203 /* In case it was set long ago */
204 wdt
->expect_close
= 0;
206 for (i
= 0; i
!= len
; i
++) {
209 if (get_user(c
, data
+ i
))
212 wdt
->expect_close
= 42;
215 mpcore_wdt_keepalive(wdt
);
220 static const struct watchdog_info ident
= {
221 .options
= WDIOF_SETTIMEOUT
|
222 WDIOF_KEEPALIVEPING
|
224 .identity
= "MPcore Watchdog",
227 static long mpcore_wdt_ioctl(struct file
*file
, unsigned int cmd
,
230 struct mpcore_wdt
*wdt
= file
->private_data
;
233 struct watchdog_info ident
;
237 if (_IOC_DIR(cmd
) && _IOC_SIZE(cmd
) > sizeof(uarg
))
240 if (_IOC_DIR(cmd
) & _IOC_WRITE
) {
241 ret
= copy_from_user(&uarg
, (void __user
*)arg
, _IOC_SIZE(cmd
));
247 case WDIOC_GETSUPPORT
:
252 case WDIOC_GETSTATUS
:
253 case WDIOC_GETBOOTSTATUS
:
258 case WDIOC_SETOPTIONS
:
260 if (uarg
.i
& WDIOS_DISABLECARD
) {
261 mpcore_wdt_stop(wdt
);
264 if (uarg
.i
& WDIOS_ENABLECARD
) {
265 mpcore_wdt_start(wdt
);
270 case WDIOC_KEEPALIVE
:
271 mpcore_wdt_keepalive(wdt
);
275 case WDIOC_SETTIMEOUT
:
276 ret
= mpcore_wdt_set_heartbeat(uarg
.i
);
280 mpcore_wdt_keepalive(wdt
);
282 case WDIOC_GETTIMEOUT
:
283 uarg
.i
= mpcore_margin
;
291 if (ret
== 0 && _IOC_DIR(cmd
) & _IOC_READ
) {
292 ret
= copy_to_user((void __user
*)arg
, &uarg
, _IOC_SIZE(cmd
));
300 * System shutdown handler. Turn off the watchdog if we're
301 * restarting or halting the system.
303 static void mpcore_wdt_shutdown(struct platform_device
*pdev
)
305 struct mpcore_wdt
*wdt
= platform_get_drvdata(pdev
);
307 if (system_state
== SYSTEM_RESTART
|| system_state
== SYSTEM_HALT
)
308 mpcore_wdt_stop(wdt
);
314 static const struct file_operations mpcore_wdt_fops
= {
315 .owner
= THIS_MODULE
,
317 .write
= mpcore_wdt_write
,
318 .unlocked_ioctl
= mpcore_wdt_ioctl
,
319 .open
= mpcore_wdt_open
,
320 .release
= mpcore_wdt_release
,
323 static struct miscdevice mpcore_wdt_miscdev
= {
324 .minor
= WATCHDOG_MINOR
,
326 .fops
= &mpcore_wdt_fops
,
329 static int mpcore_wdt_probe(struct platform_device
*pdev
)
331 struct mpcore_wdt
*wdt
;
332 struct resource
*res
;
335 /* We only accept one device, and it must have an id of -1 */
339 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
343 wdt
= devm_kzalloc(&pdev
->dev
, sizeof(struct mpcore_wdt
), GFP_KERNEL
);
347 wdt
->dev
= &pdev
->dev
;
348 wdt
->irq
= platform_get_irq(pdev
, 0);
350 ret
= devm_request_irq(wdt
->dev
, wdt
->irq
, mpcore_wdt_fire
, 0,
354 "cannot register IRQ%d for watchdog\n",
360 wdt
->base
= devm_ioremap(wdt
->dev
, res
->start
, resource_size(res
));
364 mpcore_wdt_miscdev
.parent
= &pdev
->dev
;
365 ret
= misc_register(&mpcore_wdt_miscdev
);
368 "cannot register miscdev on minor=%d (err=%d)\n",
369 WATCHDOG_MINOR
, ret
);
373 mpcore_wdt_stop(wdt
);
374 platform_set_drvdata(pdev
, wdt
);
375 mpcore_wdt_pdev
= pdev
;
380 static int mpcore_wdt_remove(struct platform_device
*pdev
)
382 platform_set_drvdata(pdev
, NULL
);
384 misc_deregister(&mpcore_wdt_miscdev
);
386 mpcore_wdt_pdev
= NULL
;
392 static int mpcore_wdt_suspend(struct platform_device
*pdev
, pm_message_t msg
)
394 struct mpcore_wdt
*wdt
= platform_get_drvdata(pdev
);
395 mpcore_wdt_stop(wdt
); /* Turn the WDT off */
399 static int mpcore_wdt_resume(struct platform_device
*pdev
)
401 struct mpcore_wdt
*wdt
= platform_get_drvdata(pdev
);
402 /* re-activate timer */
403 if (test_bit(0, &wdt
->timer_alive
))
404 mpcore_wdt_start(wdt
);
408 #define mpcore_wdt_suspend NULL
409 #define mpcore_wdt_resume NULL
412 /* work with hotplug and coldplug */
413 MODULE_ALIAS("platform:mpcore_wdt");
415 static struct platform_driver mpcore_wdt_driver
= {
416 .probe
= mpcore_wdt_probe
,
417 .remove
= mpcore_wdt_remove
,
418 .suspend
= mpcore_wdt_suspend
,
419 .resume
= mpcore_wdt_resume
,
420 .shutdown
= mpcore_wdt_shutdown
,
422 .owner
= THIS_MODULE
,
423 .name
= "mpcore_wdt",
427 static int __init
mpcore_wdt_init(void)
430 * Check that the margin value is within it's range;
431 * if not reset to the default
433 if (mpcore_wdt_set_heartbeat(mpcore_margin
)) {
434 mpcore_wdt_set_heartbeat(TIMER_MARGIN
);
435 pr_info("mpcore_margin value must be 0 < mpcore_margin < 65536, using %d\n",
439 pr_info("MPcore Watchdog Timer: 0.1. mpcore_noboot=%d mpcore_margin=%d sec (nowayout= %d)\n",
440 mpcore_noboot
, mpcore_margin
, nowayout
);
442 return platform_driver_register(&mpcore_wdt_driver
);
445 static void __exit
mpcore_wdt_exit(void)
447 platform_driver_unregister(&mpcore_wdt_driver
);
450 module_init(mpcore_wdt_init
);
451 module_exit(mpcore_wdt_exit
);
453 MODULE_AUTHOR("ARM Limited");
454 MODULE_DESCRIPTION("MPcore Watchdog Device Driver");
455 MODULE_LICENSE("GPL");
456 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);