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 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/types.h>
16 #include <linux/kernel.h>
18 #include <linux/miscdevice.h>
19 #include <linux/platform_device.h>
20 #include <linux/watchdog.h>
21 #include <linux/init.h>
22 #include <linux/uaccess.h>
24 #include <linux/spinlock.h>
25 #include <mach/bridge-regs.h>
26 #include <plat/orion_wdt.h>
29 * Watchdog timer block registers.
31 #define TIMER_CTRL 0x0000
33 #define WDT_VAL 0x0024
35 #define WDT_MAX_CYCLE_COUNT 0xffffffff
37 #define WDT_OK_TO_CLOSE 1
39 static int nowayout = WATCHDOG_NOWAYOUT;
40 static int heartbeat = -1; /* module parameter (seconds) */
41 static unsigned int wdt_max_duration; /* (seconds) */
42 static unsigned int wdt_tclk;
43 static void __iomem *wdt_reg;
44 static unsigned long wdt_status;
45 static DEFINE_SPINLOCK(wdt_lock);
47 static void orion_wdt_ping(void)
51 /* Reload watchdog duration */
52 writel(wdt_tclk * heartbeat, wdt_reg + WDT_VAL);
54 spin_unlock(&wdt_lock);
57 static void orion_wdt_enable(void)
63 /* Set watchdog duration */
64 writel(wdt_tclk * heartbeat, wdt_reg + WDT_VAL);
66 /* Clear watchdog timer interrupt */
67 reg = readl(BRIDGE_CAUSE);
69 writel(reg, BRIDGE_CAUSE);
71 /* Enable watchdog timer */
72 reg = readl(wdt_reg + TIMER_CTRL);
74 writel(reg, wdt_reg + TIMER_CTRL);
76 /* Enable reset on watchdog */
77 reg = readl(RSTOUTn_MASK);
78 reg |= WDT_RESET_OUT_EN;
79 writel(reg, RSTOUTn_MASK);
81 spin_unlock(&wdt_lock);
84 static void orion_wdt_disable(void)
90 /* Disable reset on watchdog */
91 reg = readl(RSTOUTn_MASK);
92 reg &= ~WDT_RESET_OUT_EN;
93 writel(reg, RSTOUTn_MASK);
95 /* Disable watchdog timer */
96 reg = readl(wdt_reg + TIMER_CTRL);
98 writel(reg, wdt_reg + TIMER_CTRL);
100 spin_unlock(&wdt_lock);
103 static int orion_wdt_get_timeleft(int *time_left)
105 spin_lock(&wdt_lock);
106 *time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
107 spin_unlock(&wdt_lock);
111 static int orion_wdt_open(struct inode *inode, struct file *file)
113 if (test_and_set_bit(WDT_IN_USE, &wdt_status))
115 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
117 return nonseekable_open(inode, file);
120 static ssize_t orion_wdt_write(struct file *file, const char *data,
121 size_t len, loff_t *ppos)
127 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
128 for (i = 0; i != len; i++) {
131 if (get_user(c, data + i))
134 set_bit(WDT_OK_TO_CLOSE, &wdt_status);
142 static int orion_wdt_settimeout(int new_time)
144 if ((new_time <= 0) || (new_time > wdt_max_duration))
147 /* Set new watchdog time to be used when
148 * orion_wdt_enable() or orion_wdt_ping() is called. */
149 heartbeat = new_time;
153 static const struct watchdog_info ident = {
154 .options = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT |
156 .identity = "Orion Watchdog",
159 static long orion_wdt_ioctl(struct file *file, unsigned int cmd,
166 case WDIOC_GETSUPPORT:
167 ret = copy_to_user((struct watchdog_info *)arg, &ident,
168 sizeof(ident)) ? -EFAULT : 0;
171 case WDIOC_GETSTATUS:
172 case WDIOC_GETBOOTSTATUS:
173 ret = put_user(0, (int *)arg);
176 case WDIOC_KEEPALIVE:
181 case WDIOC_SETTIMEOUT:
182 ret = get_user(time, (int *)arg);
186 if (orion_wdt_settimeout(time)) {
193 case WDIOC_GETTIMEOUT:
194 ret = put_user(heartbeat, (int *)arg);
197 case WDIOC_GETTIMELEFT:
198 if (orion_wdt_get_timeleft(&time)) {
202 ret = put_user(time, (int *)arg);
208 static int orion_wdt_release(struct inode *inode, struct file *file)
210 if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
213 printk(KERN_CRIT "WATCHDOG: Device closed unexpectedly - "
214 "timer will not stop\n");
215 clear_bit(WDT_IN_USE, &wdt_status);
216 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
222 static const struct file_operations orion_wdt_fops = {
223 .owner = THIS_MODULE,
225 .write = orion_wdt_write,
226 .unlocked_ioctl = orion_wdt_ioctl,
227 .open = orion_wdt_open,
228 .release = orion_wdt_release,
231 static struct miscdevice orion_wdt_miscdev = {
232 .minor = WATCHDOG_MINOR,
234 .fops = &orion_wdt_fops,
237 static int __devinit orion_wdt_probe(struct platform_device *pdev)
239 struct orion_wdt_platform_data *pdata = pdev->dev.platform_data;
240 struct resource *res;
244 wdt_tclk = pdata->tclk;
246 printk(KERN_ERR "Orion Watchdog misses platform data\n");
250 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
252 wdt_reg = ioremap(res->start, resource_size(res));
254 if (orion_wdt_miscdev.parent)
256 orion_wdt_miscdev.parent = &pdev->dev;
258 wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
259 if (orion_wdt_settimeout(heartbeat))
260 heartbeat = wdt_max_duration;
262 ret = misc_register(&orion_wdt_miscdev);
266 printk(KERN_INFO "Orion Watchdog Timer: Initial timeout %d sec%s\n",
267 heartbeat, nowayout ? ", nowayout" : "");
271 static int __devexit orion_wdt_remove(struct platform_device *pdev)
275 if (test_bit(WDT_IN_USE, &wdt_status)) {
277 clear_bit(WDT_IN_USE, &wdt_status);
280 ret = misc_deregister(&orion_wdt_miscdev);
282 orion_wdt_miscdev.parent = NULL;
287 static void orion_wdt_shutdown(struct platform_device *pdev)
289 if (test_bit(WDT_IN_USE, &wdt_status))
293 static struct platform_driver orion_wdt_driver = {
294 .probe = orion_wdt_probe,
295 .remove = __devexit_p(orion_wdt_remove),
296 .shutdown = orion_wdt_shutdown,
298 .owner = THIS_MODULE,
303 module_platform_driver(orion_wdt_driver);
305 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
306 MODULE_DESCRIPTION("Orion Processor Watchdog");
308 module_param(heartbeat, int, 0);
309 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
311 module_param(nowayout, int, 0);
312 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
313 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
315 MODULE_LICENSE("GPL");
316 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);