2 * drivers/watchdog/orion_wdt.c
4 * Watchdog driver for Orion/Kirkwood processors
6 * Author: Sylver Bruneau <sylver.bruneau@googlemail.com>
8 * This file is licensed under the terms of the GNU General Public
9 * License version 2. This program is licensed "as is" without any
10 * warranty of any kind, whether express or implied.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
20 #include <linux/miscdevice.h>
21 #include <linux/platform_device.h>
22 #include <linux/watchdog.h>
23 #include <linux/init.h>
24 #include <linux/uaccess.h>
26 #include <linux/spinlock.h>
27 #include <mach/bridge-regs.h>
28 #include <plat/orion_wdt.h>
31 * Watchdog timer block registers.
33 #define TIMER_CTRL 0x0000
35 #define WDT_VAL 0x0024
37 #define WDT_MAX_CYCLE_COUNT 0xffffffff
39 #define WDT_OK_TO_CLOSE 1
41 static bool nowayout = WATCHDOG_NOWAYOUT;
42 static int heartbeat = -1; /* module parameter (seconds) */
43 static unsigned int wdt_max_duration; /* (seconds) */
44 static unsigned int wdt_tclk;
45 static void __iomem *wdt_reg;
46 static unsigned long wdt_status;
47 static DEFINE_SPINLOCK(wdt_lock);
49 static void orion_wdt_ping(void)
53 /* Reload watchdog duration */
54 writel(wdt_tclk * heartbeat, wdt_reg + WDT_VAL);
56 spin_unlock(&wdt_lock);
59 static void orion_wdt_enable(void)
65 /* Set watchdog duration */
66 writel(wdt_tclk * heartbeat, wdt_reg + WDT_VAL);
68 /* Clear watchdog timer interrupt */
69 reg = readl(BRIDGE_CAUSE);
71 writel(reg, BRIDGE_CAUSE);
73 /* Enable watchdog timer */
74 reg = readl(wdt_reg + TIMER_CTRL);
76 writel(reg, wdt_reg + TIMER_CTRL);
78 /* Enable reset on watchdog */
79 reg = readl(RSTOUTn_MASK);
80 reg |= WDT_RESET_OUT_EN;
81 writel(reg, RSTOUTn_MASK);
83 spin_unlock(&wdt_lock);
86 static void orion_wdt_disable(void)
92 /* Disable reset on watchdog */
93 reg = readl(RSTOUTn_MASK);
94 reg &= ~WDT_RESET_OUT_EN;
95 writel(reg, RSTOUTn_MASK);
97 /* Disable watchdog timer */
98 reg = readl(wdt_reg + TIMER_CTRL);
100 writel(reg, wdt_reg + TIMER_CTRL);
102 spin_unlock(&wdt_lock);
105 static int orion_wdt_get_timeleft(int *time_left)
107 spin_lock(&wdt_lock);
108 *time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
109 spin_unlock(&wdt_lock);
113 static int orion_wdt_open(struct inode *inode, struct file *file)
115 if (test_and_set_bit(WDT_IN_USE, &wdt_status))
117 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
119 return nonseekable_open(inode, file);
122 static ssize_t orion_wdt_write(struct file *file, const char *data,
123 size_t len, loff_t *ppos)
129 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
130 for (i = 0; i != len; i++) {
133 if (get_user(c, data + i))
136 set_bit(WDT_OK_TO_CLOSE, &wdt_status);
144 static int orion_wdt_settimeout(int new_time)
146 if ((new_time <= 0) || (new_time > wdt_max_duration))
149 /* Set new watchdog time to be used when
150 * orion_wdt_enable() or orion_wdt_ping() is called. */
151 heartbeat = new_time;
155 static const struct watchdog_info ident = {
156 .options = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT |
158 .identity = "Orion Watchdog",
161 static long orion_wdt_ioctl(struct file *file, unsigned int cmd,
168 case WDIOC_GETSUPPORT:
169 ret = copy_to_user((struct watchdog_info *)arg, &ident,
170 sizeof(ident)) ? -EFAULT : 0;
173 case WDIOC_GETSTATUS:
174 case WDIOC_GETBOOTSTATUS:
175 ret = put_user(0, (int *)arg);
178 case WDIOC_KEEPALIVE:
183 case WDIOC_SETTIMEOUT:
184 ret = get_user(time, (int *)arg);
188 if (orion_wdt_settimeout(time)) {
195 case WDIOC_GETTIMEOUT:
196 ret = put_user(heartbeat, (int *)arg);
199 case WDIOC_GETTIMELEFT:
200 if (orion_wdt_get_timeleft(&time)) {
204 ret = put_user(time, (int *)arg);
210 static int orion_wdt_release(struct inode *inode, struct file *file)
212 if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
215 pr_crit("Device closed unexpectedly - timer will not stop\n");
216 clear_bit(WDT_IN_USE, &wdt_status);
217 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
223 static const struct file_operations orion_wdt_fops = {
224 .owner = THIS_MODULE,
226 .write = orion_wdt_write,
227 .unlocked_ioctl = orion_wdt_ioctl,
228 .open = orion_wdt_open,
229 .release = orion_wdt_release,
232 static struct miscdevice orion_wdt_miscdev = {
233 .minor = WATCHDOG_MINOR,
235 .fops = &orion_wdt_fops,
238 static int __devinit orion_wdt_probe(struct platform_device *pdev)
240 struct orion_wdt_platform_data *pdata = pdev->dev.platform_data;
241 struct resource *res;
245 wdt_tclk = pdata->tclk;
247 pr_err("misses platform data\n");
251 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
253 wdt_reg = ioremap(res->start, resource_size(res));
255 if (orion_wdt_miscdev.parent)
257 orion_wdt_miscdev.parent = &pdev->dev;
259 wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
260 if (orion_wdt_settimeout(heartbeat))
261 heartbeat = wdt_max_duration;
263 ret = misc_register(&orion_wdt_miscdev);
267 pr_info("Initial timeout %d sec%s\n",
268 heartbeat, nowayout ? ", nowayout" : "");
272 static int __devexit orion_wdt_remove(struct platform_device *pdev)
276 if (test_bit(WDT_IN_USE, &wdt_status)) {
278 clear_bit(WDT_IN_USE, &wdt_status);
281 ret = misc_deregister(&orion_wdt_miscdev);
283 orion_wdt_miscdev.parent = NULL;
288 static void orion_wdt_shutdown(struct platform_device *pdev)
290 if (test_bit(WDT_IN_USE, &wdt_status))
294 static struct platform_driver orion_wdt_driver = {
295 .probe = orion_wdt_probe,
296 .remove = __devexit_p(orion_wdt_remove),
297 .shutdown = orion_wdt_shutdown,
299 .owner = THIS_MODULE,
304 module_platform_driver(orion_wdt_driver);
306 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
307 MODULE_DESCRIPTION("Orion Processor Watchdog");
309 module_param(heartbeat, int, 0);
310 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
312 module_param(nowayout, bool, 0);
313 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
314 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
316 MODULE_LICENSE("GPL");
317 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);