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_dev
;
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 int nowayout
= WATCHDOG_NOWAYOUT
;
61 module_param(nowayout
, int, 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_printk(KERN_CRIT
, wdt
->dev
,
84 "Triggered - Reboot ignored.\n");
85 /* Clear the interrupt on the watchdog */
86 writel(1, wdt
->base
+ TWD_WDOG_INTSTAT
);
93 * mpcore_wdt_keepalive - reload the timer
95 * Note that the spec says a DIFFERENT value must be written to the reload
96 * register each time. The "perturb" variable deals with this by adding 1
97 * to the count every other time the function is called.
99 static void mpcore_wdt_keepalive(struct mpcore_wdt
*wdt
)
103 spin_lock(&wdt_lock
);
104 /* Assume prescale is set to 256 */
105 count
= __raw_readl(wdt
->base
+ TWD_WDOG_COUNTER
);
106 count
= (0xFFFFFFFFU
- count
) * (HZ
/ 5);
107 count
= (count
/ 256) * mpcore_margin
;
109 /* Reload the counter */
110 writel(count
+ wdt
->perturb
, wdt
->base
+ TWD_WDOG_LOAD
);
111 wdt
->perturb
= wdt
->perturb
? 0 : 1;
112 spin_unlock(&wdt_lock
);
115 static void mpcore_wdt_stop(struct mpcore_wdt
*wdt
)
117 spin_lock(&wdt_lock
);
118 writel(0x12345678, wdt
->base
+ TWD_WDOG_DISABLE
);
119 writel(0x87654321, wdt
->base
+ TWD_WDOG_DISABLE
);
120 writel(0x0, wdt
->base
+ TWD_WDOG_CONTROL
);
121 spin_unlock(&wdt_lock
);
124 static void mpcore_wdt_start(struct mpcore_wdt
*wdt
)
126 dev_printk(KERN_INFO
, wdt
->dev
, "enabling watchdog.\n");
128 /* This loads the count register but does NOT start the count yet */
129 mpcore_wdt_keepalive(wdt
);
132 /* Enable watchdog - prescale=256, watchdog mode=0, enable=1 */
133 writel(0x0000FF01, wdt
->base
+ TWD_WDOG_CONTROL
);
135 /* Enable watchdog - prescale=256, watchdog mode=1, enable=1 */
136 writel(0x0000FF09, wdt
->base
+ TWD_WDOG_CONTROL
);
140 static int mpcore_wdt_set_heartbeat(int t
)
142 if (t
< 0x0001 || t
> 0xFFFF)
150 * /dev/watchdog handling
152 static int mpcore_wdt_open(struct inode
*inode
, struct file
*file
)
154 struct mpcore_wdt
*wdt
= platform_get_drvdata(mpcore_wdt_dev
);
156 if (test_and_set_bit(0, &wdt
->timer_alive
))
160 __module_get(THIS_MODULE
);
162 file
->private_data
= wdt
;
167 mpcore_wdt_start(wdt
);
169 return nonseekable_open(inode
, file
);
172 static int mpcore_wdt_release(struct inode
*inode
, struct file
*file
)
174 struct mpcore_wdt
*wdt
= file
->private_data
;
177 * Shut off the timer.
178 * Lock it in if it's a module and we set nowayout
180 if (wdt
->expect_close
== 42)
181 mpcore_wdt_stop(wdt
);
183 dev_printk(KERN_CRIT
, wdt
->dev
,
184 "unexpected close, not stopping watchdog!\n");
185 mpcore_wdt_keepalive(wdt
);
187 clear_bit(0, &wdt
->timer_alive
);
188 wdt
->expect_close
= 0;
192 static ssize_t
mpcore_wdt_write(struct file
*file
, const char *data
,
193 size_t len
, loff_t
*ppos
)
195 struct mpcore_wdt
*wdt
= file
->private_data
;
204 /* In case it was set long ago */
205 wdt
->expect_close
= 0;
207 for (i
= 0; i
!= len
; i
++) {
210 if (get_user(c
, data
+ i
))
213 wdt
->expect_close
= 42;
216 mpcore_wdt_keepalive(wdt
);
221 static const struct watchdog_info ident
= {
222 .options
= WDIOF_SETTIMEOUT
|
223 WDIOF_KEEPALIVEPING
|
225 .identity
= "MPcore Watchdog",
228 static long mpcore_wdt_ioctl(struct file
*file
, unsigned int cmd
,
231 struct mpcore_wdt
*wdt
= file
->private_data
;
234 struct watchdog_info ident
;
238 if (_IOC_DIR(cmd
) && _IOC_SIZE(cmd
) > sizeof(uarg
))
241 if (_IOC_DIR(cmd
) & _IOC_WRITE
) {
242 ret
= copy_from_user(&uarg
, (void __user
*)arg
, _IOC_SIZE(cmd
));
248 case WDIOC_GETSUPPORT
:
253 case WDIOC_GETSTATUS
:
254 case WDIOC_GETBOOTSTATUS
:
259 case WDIOC_SETOPTIONS
:
261 if (uarg
.i
& WDIOS_DISABLECARD
) {
262 mpcore_wdt_stop(wdt
);
265 if (uarg
.i
& WDIOS_ENABLECARD
) {
266 mpcore_wdt_start(wdt
);
271 case WDIOC_KEEPALIVE
:
272 mpcore_wdt_keepalive(wdt
);
276 case WDIOC_SETTIMEOUT
:
277 ret
= mpcore_wdt_set_heartbeat(uarg
.i
);
281 mpcore_wdt_keepalive(wdt
);
283 case WDIOC_GETTIMEOUT
:
284 uarg
.i
= mpcore_margin
;
292 if (ret
== 0 && _IOC_DIR(cmd
) & _IOC_READ
) {
293 ret
= copy_to_user((void __user
*)arg
, &uarg
, _IOC_SIZE(cmd
));
301 * System shutdown handler. Turn off the watchdog if we're
302 * restarting or halting the system.
304 static void mpcore_wdt_shutdown(struct platform_device
*dev
)
306 struct mpcore_wdt
*wdt
= platform_get_drvdata(dev
);
308 if (system_state
== SYSTEM_RESTART
|| system_state
== SYSTEM_HALT
)
309 mpcore_wdt_stop(wdt
);
315 static const struct file_operations mpcore_wdt_fops
= {
316 .owner
= THIS_MODULE
,
318 .write
= mpcore_wdt_write
,
319 .unlocked_ioctl
= mpcore_wdt_ioctl
,
320 .open
= mpcore_wdt_open
,
321 .release
= mpcore_wdt_release
,
324 static struct miscdevice mpcore_wdt_miscdev
= {
325 .minor
= WATCHDOG_MINOR
,
327 .fops
= &mpcore_wdt_fops
,
330 static int __devinit
mpcore_wdt_probe(struct platform_device
*dev
)
332 struct mpcore_wdt
*wdt
;
333 struct resource
*res
;
336 /* We only accept one device, and it must have an id of -1 */
340 res
= platform_get_resource(dev
, IORESOURCE_MEM
, 0);
346 wdt
= kzalloc(sizeof(struct mpcore_wdt
), GFP_KERNEL
);
352 wdt
->dev
= &dev
->dev
;
353 wdt
->irq
= platform_get_irq(dev
, 0);
358 wdt
->base
= ioremap(res
->start
, resource_size(res
));
364 mpcore_wdt_miscdev
.parent
= &dev
->dev
;
365 ret
= misc_register(&mpcore_wdt_miscdev
);
367 dev_printk(KERN_ERR
, wdt
->dev
,
368 "cannot register miscdev on minor=%d (err=%d)\n",
369 WATCHDOG_MINOR
, ret
);
373 ret
= request_irq(wdt
->irq
, mpcore_wdt_fire
, 0, "mpcore_wdt", wdt
);
375 dev_printk(KERN_ERR
, wdt
->dev
,
376 "cannot register IRQ%d for watchdog\n", wdt
->irq
);
380 mpcore_wdt_stop(wdt
);
381 platform_set_drvdata(dev
, wdt
);
382 mpcore_wdt_dev
= dev
;
387 misc_deregister(&mpcore_wdt_miscdev
);
396 static int __devexit
mpcore_wdt_remove(struct platform_device
*dev
)
398 struct mpcore_wdt
*wdt
= platform_get_drvdata(dev
);
400 platform_set_drvdata(dev
, NULL
);
402 misc_deregister(&mpcore_wdt_miscdev
);
404 mpcore_wdt_dev
= NULL
;
406 free_irq(wdt
->irq
, wdt
);
413 static int mpcore_wdt_suspend(struct platform_device
*dev
, pm_message_t msg
)
415 struct mpcore_wdt
*wdt
= platform_get_drvdata(dev
);
416 mpcore_wdt_stop(wdt
); /* Turn the WDT off */
420 static int mpcore_wdt_resume(struct platform_device
*dev
)
422 struct mpcore_wdt
*wdt
= platform_get_drvdata(dev
);
423 /* re-activate timer */
424 if (test_bit(0, &wdt
->timer_alive
))
425 mpcore_wdt_start(wdt
);
429 #define mpcore_wdt_suspend NULL
430 #define mpcore_wdt_resume NULL
433 /* work with hotplug and coldplug */
434 MODULE_ALIAS("platform:mpcore_wdt");
436 static struct platform_driver mpcore_wdt_driver
= {
437 .probe
= mpcore_wdt_probe
,
438 .remove
= __devexit_p(mpcore_wdt_remove
),
439 .suspend
= mpcore_wdt_suspend
,
440 .resume
= mpcore_wdt_resume
,
441 .shutdown
= mpcore_wdt_shutdown
,
443 .owner
= THIS_MODULE
,
444 .name
= "mpcore_wdt",
448 static int __init
mpcore_wdt_init(void)
451 * Check that the margin value is within it's range;
452 * if not reset to the default
454 if (mpcore_wdt_set_heartbeat(mpcore_margin
)) {
455 mpcore_wdt_set_heartbeat(TIMER_MARGIN
);
456 pr_info("mpcore_margin value must be 0 < mpcore_margin < 65536, using %d\n",
460 pr_info("MPcore Watchdog Timer: 0.1. mpcore_noboot=%d mpcore_margin=%d sec (nowayout= %d)\n",
461 mpcore_noboot
, mpcore_margin
, nowayout
);
463 return platform_driver_register(&mpcore_wdt_driver
);
466 static void __exit
mpcore_wdt_exit(void)
468 platform_driver_unregister(&mpcore_wdt_driver
);
471 module_init(mpcore_wdt_init
);
472 module_exit(mpcore_wdt_exit
);
474 MODULE_AUTHOR("ARM Limited");
475 MODULE_DESCRIPTION("MPcore Watchdog Device Driver");
476 MODULE_LICENSE("GPL");
477 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);