blob: 9f210299de2491cd9c9ed654268e0bda991a6c5e [file] [log] [blame]
Jamie Ilesc9353ae2011-01-24 12:19:12 +00001/*
2 * Copyright 2010-2011 Picochip Ltd., Jamie Iles
3 * http://www.picochip.com
4 *
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.
9 *
10 * This file implements a driver for the Synopsys DesignWare watchdog device
Baruch Siach58a251f2013-12-30 14:25:54 +020011 * in the many subsystems. The watchdog has 16 different timeout periods
Jamie Ilesc9353ae2011-01-24 12:19:12 +000012 * and these are a function of the input clock frequency.
13 *
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.
18 */
Joe Perches27c766a2012-02-15 15:06:19 -080019
20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
Jamie Ilesc9353ae2011-01-24 12:19:12 +000021
22#include <linux/bitops.h>
23#include <linux/clk.h>
24#include <linux/device.h>
25#include <linux/err.h>
26#include <linux/fs.h>
27#include <linux/io.h>
28#include <linux/kernel.h>
29#include <linux/miscdevice.h>
30#include <linux/module.h>
31#include <linux/moduleparam.h>
Dinh Nguyen58e56372013-10-22 11:59:12 -050032#include <linux/of.h>
Jamie Ilesc9353ae2011-01-24 12:19:12 +000033#include <linux/pm.h>
34#include <linux/platform_device.h>
35#include <linux/spinlock.h>
36#include <linux/timer.h>
37#include <linux/uaccess.h>
38#include <linux/watchdog.h>
39
40#define WDOG_CONTROL_REG_OFFSET 0x00
41#define WDOG_CONTROL_REG_WDT_EN_MASK 0x01
42#define WDOG_TIMEOUT_RANGE_REG_OFFSET 0x04
43#define WDOG_CURRENT_COUNT_REG_OFFSET 0x08
44#define WDOG_COUNTER_RESTART_REG_OFFSET 0x0c
45#define WDOG_COUNTER_RESTART_KICK_VALUE 0x76
46
47/* The maximum TOP (timeout period) value that can be set in the watchdog. */
48#define DW_WDT_MAX_TOP 15
49
Wim Van Sebroeck86a1e182012-03-05 16:51:11 +010050static bool nowayout = WATCHDOG_NOWAYOUT;
51module_param(nowayout, bool, 0);
Jamie Ilesc9353ae2011-01-24 12:19:12 +000052MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
53 "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
54
55#define WDT_TIMEOUT (HZ / 2)
56
57static struct {
58 spinlock_t lock;
59 void __iomem *regs;
60 struct clk *clk;
61 unsigned long in_use;
62 unsigned long next_heartbeat;
63 struct timer_list timer;
64 int expect_close;
65} dw_wdt;
66
67static inline int dw_wdt_is_enabled(void)
68{
69 return readl(dw_wdt.regs + WDOG_CONTROL_REG_OFFSET) &
70 WDOG_CONTROL_REG_WDT_EN_MASK;
71}
72
73static inline int dw_wdt_top_in_seconds(unsigned top)
74{
75 /*
76 * There are 16 possible timeout values in 0..15 where the number of
77 * cycles is 2 ^ (16 + i) and the watchdog counts down.
78 */
79 return (1 << (16 + top)) / clk_get_rate(dw_wdt.clk);
80}
81
82static int dw_wdt_get_top(void)
83{
84 int top = readl(dw_wdt.regs + WDOG_TIMEOUT_RANGE_REG_OFFSET) & 0xF;
85
86 return dw_wdt_top_in_seconds(top);
87}
88
89static inline void dw_wdt_set_next_heartbeat(void)
90{
91 dw_wdt.next_heartbeat = jiffies + dw_wdt_get_top() * HZ;
92}
93
94static int dw_wdt_set_top(unsigned top_s)
95{
96 int i, top_val = DW_WDT_MAX_TOP;
97
98 /*
99 * Iterate over the timeout values until we find the closest match. We
100 * always look for >=.
101 */
102 for (i = 0; i <= DW_WDT_MAX_TOP; ++i)
103 if (dw_wdt_top_in_seconds(i) >= top_s) {
104 top_val = i;
105 break;
106 }
107
108 /* Set the new value in the watchdog. */
109 writel(top_val, dw_wdt.regs + WDOG_TIMEOUT_RANGE_REG_OFFSET);
110
111 dw_wdt_set_next_heartbeat();
112
113 return dw_wdt_top_in_seconds(top_val);
114}
115
116static void dw_wdt_keepalive(void)
117{
118 writel(WDOG_COUNTER_RESTART_KICK_VALUE, dw_wdt.regs +
119 WDOG_COUNTER_RESTART_REG_OFFSET);
120}
121
122static void dw_wdt_ping(unsigned long data)
123{
124 if (time_before(jiffies, dw_wdt.next_heartbeat) ||
125 (!nowayout && !dw_wdt.in_use)) {
126 dw_wdt_keepalive();
127 mod_timer(&dw_wdt.timer, jiffies + WDT_TIMEOUT);
128 } else
129 pr_crit("keepalive missed, machine will reset\n");
130}
131
132static int dw_wdt_open(struct inode *inode, struct file *filp)
133{
134 if (test_and_set_bit(0, &dw_wdt.in_use))
135 return -EBUSY;
136
137 /* Make sure we don't get unloaded. */
138 __module_get(THIS_MODULE);
139
140 spin_lock(&dw_wdt.lock);
141 if (!dw_wdt_is_enabled()) {
142 /*
143 * The watchdog is not currently enabled. Set the timeout to
144 * the maximum and then start it.
145 */
146 dw_wdt_set_top(DW_WDT_MAX_TOP);
147 writel(WDOG_CONTROL_REG_WDT_EN_MASK,
148 dw_wdt.regs + WDOG_CONTROL_REG_OFFSET);
149 }
150
151 dw_wdt_set_next_heartbeat();
152
153 spin_unlock(&dw_wdt.lock);
154
155 return nonseekable_open(inode, filp);
156}
157
Sachin Kamat0b930262013-05-14 12:11:03 +0530158static ssize_t dw_wdt_write(struct file *filp, const char __user *buf,
159 size_t len, loff_t *offset)
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000160{
161 if (!len)
162 return 0;
163
164 if (!nowayout) {
165 size_t i;
166
167 dw_wdt.expect_close = 0;
168
169 for (i = 0; i < len; ++i) {
170 char c;
171
172 if (get_user(c, buf + i))
173 return -EFAULT;
174
175 if (c == 'V') {
176 dw_wdt.expect_close = 1;
177 break;
178 }
179 }
180 }
181
182 dw_wdt_set_next_heartbeat();
183 mod_timer(&dw_wdt.timer, jiffies + WDT_TIMEOUT);
184
185 return len;
186}
187
188static u32 dw_wdt_time_left(void)
189{
190 return readl(dw_wdt.regs + WDOG_CURRENT_COUNT_REG_OFFSET) /
191 clk_get_rate(dw_wdt.clk);
192}
193
194static const struct watchdog_info dw_wdt_ident = {
195 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
196 WDIOF_MAGICCLOSE,
197 .identity = "Synopsys DesignWare Watchdog",
198};
199
200static long dw_wdt_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
201{
202 unsigned long val;
203 int timeout;
204
205 switch (cmd) {
206 case WDIOC_GETSUPPORT:
Jingoo Han60295502013-08-01 14:38:36 +0900207 return copy_to_user((void __user *)arg, &dw_wdt_ident,
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000208 sizeof(dw_wdt_ident)) ? -EFAULT : 0;
209
210 case WDIOC_GETSTATUS:
211 case WDIOC_GETBOOTSTATUS:
Jingoo Han60295502013-08-01 14:38:36 +0900212 return put_user(0, (int __user *)arg);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000213
214 case WDIOC_KEEPALIVE:
215 dw_wdt_set_next_heartbeat();
216 return 0;
217
218 case WDIOC_SETTIMEOUT:
219 if (get_user(val, (int __user *)arg))
220 return -EFAULT;
221 timeout = dw_wdt_set_top(val);
222 return put_user(timeout , (int __user *)arg);
223
224 case WDIOC_GETTIMEOUT:
225 return put_user(dw_wdt_get_top(), (int __user *)arg);
226
227 case WDIOC_GETTIMELEFT:
228 /* Get the time left until expiry. */
229 if (get_user(val, (int __user *)arg))
230 return -EFAULT;
231 return put_user(dw_wdt_time_left(), (int __user *)arg);
232
233 default:
234 return -ENOTTY;
235 }
236}
237
238static int dw_wdt_release(struct inode *inode, struct file *filp)
239{
240 clear_bit(0, &dw_wdt.in_use);
241
242 if (!dw_wdt.expect_close) {
243 del_timer(&dw_wdt.timer);
244
245 if (!nowayout)
246 pr_crit("unexpected close, system will reboot soon\n");
247 else
248 pr_crit("watchdog cannot be disabled, system will reboot soon\n");
249 }
250
251 dw_wdt.expect_close = 0;
252
253 return 0;
254}
255
Heiko Stübnerad83c6c2013-06-26 20:03:52 +0200256#ifdef CONFIG_PM_SLEEP
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000257static int dw_wdt_suspend(struct device *dev)
258{
Heiko Stübner280103e2013-06-26 20:04:31 +0200259 clk_disable_unprepare(dw_wdt.clk);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000260
261 return 0;
262}
263
264static int dw_wdt_resume(struct device *dev)
265{
Heiko Stübner280103e2013-06-26 20:04:31 +0200266 int err = clk_prepare_enable(dw_wdt.clk);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000267
268 if (err)
269 return err;
270
271 dw_wdt_keepalive();
272
273 return 0;
274}
Heiko Stübnerad83c6c2013-06-26 20:03:52 +0200275#endif /* CONFIG_PM_SLEEP */
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000276
Heiko Stübnerad83c6c2013-06-26 20:03:52 +0200277static SIMPLE_DEV_PM_OPS(dw_wdt_pm_ops, dw_wdt_suspend, dw_wdt_resume);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000278
279static const struct file_operations wdt_fops = {
280 .owner = THIS_MODULE,
281 .llseek = no_llseek,
282 .open = dw_wdt_open,
283 .write = dw_wdt_write,
284 .unlocked_ioctl = dw_wdt_ioctl,
285 .release = dw_wdt_release
286};
287
288static struct miscdevice dw_wdt_miscdev = {
289 .fops = &wdt_fops,
290 .name = "watchdog",
291 .minor = WATCHDOG_MINOR,
292};
293
Bill Pemberton2d991a12012-11-19 13:21:41 -0500294static int dw_wdt_drv_probe(struct platform_device *pdev)
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000295{
296 int ret;
297 struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
298
Thierry Reding4c271bb2013-01-21 11:09:25 +0100299 dw_wdt.regs = devm_ioremap_resource(&pdev->dev, mem);
300 if (IS_ERR(dw_wdt.regs))
301 return PTR_ERR(dw_wdt.regs);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000302
Jingoo Hancf3cc8c2013-04-29 18:15:26 +0900303 dw_wdt.clk = devm_clk_get(&pdev->dev, NULL);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000304 if (IS_ERR(dw_wdt.clk))
305 return PTR_ERR(dw_wdt.clk);
306
Heiko Stübner280103e2013-06-26 20:04:31 +0200307 ret = clk_prepare_enable(dw_wdt.clk);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000308 if (ret)
Jingoo Hancf3cc8c2013-04-29 18:15:26 +0900309 return ret;
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000310
311 spin_lock_init(&dw_wdt.lock);
312
313 ret = misc_register(&dw_wdt_miscdev);
314 if (ret)
315 goto out_disable_clk;
316
317 dw_wdt_set_next_heartbeat();
318 setup_timer(&dw_wdt.timer, dw_wdt_ping, 0);
319 mod_timer(&dw_wdt.timer, jiffies + WDT_TIMEOUT);
320
321 return 0;
322
323out_disable_clk:
Heiko Stübner280103e2013-06-26 20:04:31 +0200324 clk_disable_unprepare(dw_wdt.clk);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000325
326 return ret;
327}
328
Bill Pemberton4b12b892012-11-19 13:26:24 -0500329static int dw_wdt_drv_remove(struct platform_device *pdev)
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000330{
331 misc_deregister(&dw_wdt_miscdev);
332
Heiko Stübner280103e2013-06-26 20:04:31 +0200333 clk_disable_unprepare(dw_wdt.clk);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000334
335 return 0;
336}
337
Dinh Nguyen58e56372013-10-22 11:59:12 -0500338#ifdef CONFIG_OF
339static const struct of_device_id dw_wdt_of_match[] = {
340 { .compatible = "snps,dw-wdt", },
341 { /* sentinel */ }
342};
343MODULE_DEVICE_TABLE(of, dw_wdt_of_match);
344#endif
345
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000346static struct platform_driver dw_wdt_driver = {
347 .probe = dw_wdt_drv_probe,
Bill Pemberton82268712012-11-19 13:21:12 -0500348 .remove = dw_wdt_drv_remove,
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000349 .driver = {
350 .name = "dw_wdt",
351 .owner = THIS_MODULE,
Dinh Nguyen58e56372013-10-22 11:59:12 -0500352 .of_match_table = of_match_ptr(dw_wdt_of_match),
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000353 .pm = &dw_wdt_pm_ops,
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000354 },
355};
356
Axel Linb8ec6112011-11-29 13:56:27 +0800357module_platform_driver(dw_wdt_driver);
Jamie Ilesc9353ae2011-01-24 12:19:12 +0000358
359MODULE_AUTHOR("Jamie Iles");
360MODULE_DESCRIPTION("Synopsys DesignWare Watchdog Driver");
361MODULE_LICENSE("GPL");