2 * Copyright 2010-2011 Picochip Ltd., Jamie Iles
3 * http://www.picochip.com
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version
8 * 2 of the License, or (at your option) any later version.
10 * This file implements a driver for the Synopsys DesignWare watchdog device
11 * in the many subsystems. The watchdog has 16 different timeout periods
12 * and these are a function of the input clock frequency.
14 * The DesignWare watchdog cannot be stopped once it has been started so we
15 * use a software timer to implement a ping that will keep the watchdog alive.
16 * If we receive an expected close for the watchdog then we keep the timer
17 * running, otherwise the timer is stopped and the watchdog will expire.
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22 #include <linux/bitops.h>
23 #include <linux/clk.h>
24 #include <linux/delay.h>
25 #include <linux/device.h>
26 #include <linux/err.h>
29 #include <linux/kernel.h>
30 #include <linux/miscdevice.h>
31 #include <linux/module.h>
32 #include <linux/moduleparam.h>
33 #include <linux/notifier.h>
36 #include <linux/platform_device.h>
37 #include <linux/reboot.h>
38 #include <linux/spinlock.h>
39 #include <linux/timer.h>
40 #include <linux/uaccess.h>
41 #include <linux/watchdog.h>
43 #define WDOG_CONTROL_REG_OFFSET 0x00
44 #define WDOG_CONTROL_REG_WDT_EN_MASK 0x01
45 #define WDOG_TIMEOUT_RANGE_REG_OFFSET 0x04
46 #define WDOG_TIMEOUT_RANGE_TOPINIT_SHIFT 4
47 #define WDOG_CURRENT_COUNT_REG_OFFSET 0x08
48 #define WDOG_COUNTER_RESTART_REG_OFFSET 0x0c
49 #define WDOG_COUNTER_RESTART_KICK_VALUE 0x76
51 /* The maximum TOP (timeout period) value that can be set in the watchdog. */
52 #define DW_WDT_MAX_TOP 15
54 #define DW_WDT_DEFAULT_SECONDS 30
56 static bool nowayout
= WATCHDOG_NOWAYOUT
;
57 module_param(nowayout
, bool, 0);
58 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started "
59 "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT
) ")");
61 #define WDT_TIMEOUT (HZ / 2)
68 unsigned long next_heartbeat
;
69 struct timer_list timer
;
71 struct notifier_block restart_handler
;
74 static inline int dw_wdt_is_enabled(void)
76 return readl(dw_wdt
.regs
+ WDOG_CONTROL_REG_OFFSET
) &
77 WDOG_CONTROL_REG_WDT_EN_MASK
;
80 static inline int dw_wdt_top_in_seconds(unsigned top
)
83 * There are 16 possible timeout values in 0..15 where the number of
84 * cycles is 2 ^ (16 + i) and the watchdog counts down.
86 return (1 << (16 + top
)) / clk_get_rate(dw_wdt
.clk
);
89 static int dw_wdt_get_top(void)
91 int top
= readl(dw_wdt
.regs
+ WDOG_TIMEOUT_RANGE_REG_OFFSET
) & 0xF;
93 return dw_wdt_top_in_seconds(top
);
96 static inline void dw_wdt_set_next_heartbeat(void)
98 dw_wdt
.next_heartbeat
= jiffies
+ dw_wdt_get_top() * HZ
;
101 static void dw_wdt_keepalive(void)
103 writel(WDOG_COUNTER_RESTART_KICK_VALUE
, dw_wdt
.regs
+
104 WDOG_COUNTER_RESTART_REG_OFFSET
);
107 static int dw_wdt_set_top(unsigned top_s
)
109 int i
, top_val
= DW_WDT_MAX_TOP
;
112 * Iterate over the timeout values until we find the closest match. We
113 * always look for >=.
115 for (i
= 0; i
<= DW_WDT_MAX_TOP
; ++i
)
116 if (dw_wdt_top_in_seconds(i
) >= top_s
) {
122 * Set the new value in the watchdog. Some versions of dw_wdt
123 * have have TOPINIT in the TIMEOUT_RANGE register (as per
124 * CP_WDT_DUAL_TOP in WDT_COMP_PARAMS_1). On those we
125 * effectively get a pat of the watchdog right here.
127 writel(top_val
| top_val
<< WDOG_TIMEOUT_RANGE_TOPINIT_SHIFT
,
128 dw_wdt
.regs
+ WDOG_TIMEOUT_RANGE_REG_OFFSET
);
131 * Add an explicit pat to handle versions of the watchdog that
132 * don't have TOPINIT. This won't hurt on versions that have
137 dw_wdt_set_next_heartbeat();
139 return dw_wdt_top_in_seconds(top_val
);
142 static int dw_wdt_restart_handle(struct notifier_block
*this,
143 unsigned long mode
, void *cmd
)
147 writel(0, dw_wdt
.regs
+ WDOG_TIMEOUT_RANGE_REG_OFFSET
);
148 val
= readl(dw_wdt
.regs
+ WDOG_CONTROL_REG_OFFSET
);
149 if (val
& WDOG_CONTROL_REG_WDT_EN_MASK
)
150 writel(WDOG_COUNTER_RESTART_KICK_VALUE
, dw_wdt
.regs
+
151 WDOG_COUNTER_RESTART_REG_OFFSET
);
153 writel(WDOG_CONTROL_REG_WDT_EN_MASK
,
154 dw_wdt
.regs
+ WDOG_CONTROL_REG_OFFSET
);
156 /* wait for reset to assert... */
162 static void dw_wdt_ping(unsigned long data
)
164 if (time_before(jiffies
, dw_wdt
.next_heartbeat
) ||
165 (!nowayout
&& !dw_wdt
.in_use
)) {
167 mod_timer(&dw_wdt
.timer
, jiffies
+ WDT_TIMEOUT
);
169 pr_crit("keepalive missed, machine will reset\n");
172 static int dw_wdt_open(struct inode
*inode
, struct file
*filp
)
174 if (test_and_set_bit(0, &dw_wdt
.in_use
))
177 /* Make sure we don't get unloaded. */
178 __module_get(THIS_MODULE
);
180 spin_lock(&dw_wdt
.lock
);
181 if (!dw_wdt_is_enabled()) {
183 * The watchdog is not currently enabled. Set the timeout to
184 * something reasonable and then start it.
186 dw_wdt_set_top(DW_WDT_DEFAULT_SECONDS
);
187 writel(WDOG_CONTROL_REG_WDT_EN_MASK
,
188 dw_wdt
.regs
+ WDOG_CONTROL_REG_OFFSET
);
191 dw_wdt_set_next_heartbeat();
193 spin_unlock(&dw_wdt
.lock
);
195 return nonseekable_open(inode
, filp
);
198 static ssize_t
dw_wdt_write(struct file
*filp
, const char __user
*buf
,
199 size_t len
, loff_t
*offset
)
207 dw_wdt
.expect_close
= 0;
209 for (i
= 0; i
< len
; ++i
) {
212 if (get_user(c
, buf
+ i
))
216 dw_wdt
.expect_close
= 1;
222 dw_wdt_set_next_heartbeat();
223 mod_timer(&dw_wdt
.timer
, jiffies
+ WDT_TIMEOUT
);
228 static u32
dw_wdt_time_left(void)
230 return readl(dw_wdt
.regs
+ WDOG_CURRENT_COUNT_REG_OFFSET
) /
231 clk_get_rate(dw_wdt
.clk
);
234 static const struct watchdog_info dw_wdt_ident
= {
235 .options
= WDIOF_KEEPALIVEPING
| WDIOF_SETTIMEOUT
|
237 .identity
= "Synopsys DesignWare Watchdog",
240 static long dw_wdt_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
246 case WDIOC_GETSUPPORT
:
247 return copy_to_user((void __user
*)arg
, &dw_wdt_ident
,
248 sizeof(dw_wdt_ident
)) ? -EFAULT
: 0;
250 case WDIOC_GETSTATUS
:
251 case WDIOC_GETBOOTSTATUS
:
252 return put_user(0, (int __user
*)arg
);
254 case WDIOC_KEEPALIVE
:
255 dw_wdt_set_next_heartbeat();
258 case WDIOC_SETTIMEOUT
:
259 if (get_user(val
, (int __user
*)arg
))
261 timeout
= dw_wdt_set_top(val
);
262 return put_user(timeout
, (int __user
*)arg
);
264 case WDIOC_GETTIMEOUT
:
265 return put_user(dw_wdt_get_top(), (int __user
*)arg
);
267 case WDIOC_GETTIMELEFT
:
268 /* Get the time left until expiry. */
269 if (get_user(val
, (int __user
*)arg
))
271 return put_user(dw_wdt_time_left(), (int __user
*)arg
);
278 static int dw_wdt_release(struct inode
*inode
, struct file
*filp
)
280 clear_bit(0, &dw_wdt
.in_use
);
282 if (!dw_wdt
.expect_close
) {
283 del_timer(&dw_wdt
.timer
);
286 pr_crit("unexpected close, system will reboot soon\n");
288 pr_crit("watchdog cannot be disabled, system will reboot soon\n");
291 dw_wdt
.expect_close
= 0;
296 #ifdef CONFIG_PM_SLEEP
297 static int dw_wdt_suspend(struct device
*dev
)
299 clk_disable_unprepare(dw_wdt
.clk
);
304 static int dw_wdt_resume(struct device
*dev
)
306 int err
= clk_prepare_enable(dw_wdt
.clk
);
315 #endif /* CONFIG_PM_SLEEP */
317 static SIMPLE_DEV_PM_OPS(dw_wdt_pm_ops
, dw_wdt_suspend
, dw_wdt_resume
);
319 static const struct file_operations wdt_fops
= {
320 .owner
= THIS_MODULE
,
323 .write
= dw_wdt_write
,
324 .unlocked_ioctl
= dw_wdt_ioctl
,
325 .release
= dw_wdt_release
328 static struct miscdevice dw_wdt_miscdev
= {
331 .minor
= WATCHDOG_MINOR
,
334 static int dw_wdt_drv_probe(struct platform_device
*pdev
)
337 struct resource
*mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
339 dw_wdt
.regs
= devm_ioremap_resource(&pdev
->dev
, mem
);
340 if (IS_ERR(dw_wdt
.regs
))
341 return PTR_ERR(dw_wdt
.regs
);
343 dw_wdt
.clk
= devm_clk_get(&pdev
->dev
, NULL
);
344 if (IS_ERR(dw_wdt
.clk
))
345 return PTR_ERR(dw_wdt
.clk
);
347 ret
= clk_prepare_enable(dw_wdt
.clk
);
351 spin_lock_init(&dw_wdt
.lock
);
353 ret
= misc_register(&dw_wdt_miscdev
);
355 goto out_disable_clk
;
357 dw_wdt
.restart_handler
.notifier_call
= dw_wdt_restart_handle
;
358 dw_wdt
.restart_handler
.priority
= 128;
359 ret
= register_restart_handler(&dw_wdt
.restart_handler
);
361 pr_warn("cannot register restart handler\n");
363 dw_wdt_set_next_heartbeat();
364 setup_timer(&dw_wdt
.timer
, dw_wdt_ping
, 0);
365 mod_timer(&dw_wdt
.timer
, jiffies
+ WDT_TIMEOUT
);
370 clk_disable_unprepare(dw_wdt
.clk
);
375 static int dw_wdt_drv_remove(struct platform_device
*pdev
)
377 unregister_restart_handler(&dw_wdt
.restart_handler
);
379 misc_deregister(&dw_wdt_miscdev
);
381 clk_disable_unprepare(dw_wdt
.clk
);
387 static const struct of_device_id dw_wdt_of_match
[] = {
388 { .compatible
= "snps,dw-wdt", },
391 MODULE_DEVICE_TABLE(of
, dw_wdt_of_match
);
394 static struct platform_driver dw_wdt_driver
= {
395 .probe
= dw_wdt_drv_probe
,
396 .remove
= dw_wdt_drv_remove
,
399 .of_match_table
= of_match_ptr(dw_wdt_of_match
),
400 .pm
= &dw_wdt_pm_ops
,
404 module_platform_driver(dw_wdt_driver
);
406 MODULE_AUTHOR("Jamie Iles");
407 MODULE_DESCRIPTION("Synopsys DesignWare Watchdog Driver");
408 MODULE_LICENSE("GPL");