2 * drivers/watchdog/orion5x_wdt.c
4 * Watchdog driver for Orion5x 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/orion5x_wdt.h>
29 * Watchdog timer block registers.
31 #define TIMER_CTRL (TIMER_VIRT_BASE + 0x0000)
33 #define WDT_VAL (TIMER_VIRT_BASE + 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 unsigned long wdt_status;
44 static spinlock_t wdt_lock;
46 static void orion5x_wdt_ping(void)
50 /* Reload watchdog duration */
51 writel(wdt_tclk * heartbeat, WDT_VAL);
53 spin_unlock(&wdt_lock);
56 static void orion5x_wdt_enable(void)
62 /* Set watchdog duration */
63 writel(wdt_tclk * heartbeat, WDT_VAL);
65 /* Clear watchdog timer interrupt */
66 reg = readl(BRIDGE_CAUSE);
68 writel(reg, BRIDGE_CAUSE);
70 /* Enable watchdog timer */
71 reg = readl(TIMER_CTRL);
73 writel(reg, TIMER_CTRL);
75 /* Enable reset on watchdog */
76 reg = readl(CPU_RESET_MASK);
78 writel(reg, CPU_RESET_MASK);
80 spin_unlock(&wdt_lock);
83 static void orion5x_wdt_disable(void)
89 /* Disable reset on watchdog */
90 reg = readl(CPU_RESET_MASK);
92 writel(reg, CPU_RESET_MASK);
94 /* Disable watchdog timer */
95 reg = readl(TIMER_CTRL);
97 writel(reg, TIMER_CTRL);
99 spin_unlock(&wdt_lock);
102 static int orion5x_wdt_get_timeleft(int *time_left)
104 spin_lock(&wdt_lock);
105 *time_left = readl(WDT_VAL) / wdt_tclk;
106 spin_unlock(&wdt_lock);
110 static int orion5x_wdt_open(struct inode *inode, struct file *file)
112 if (test_and_set_bit(WDT_IN_USE, &wdt_status))
114 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
115 orion5x_wdt_enable();
116 return nonseekable_open(inode, file);
119 static ssize_t orion5x_wdt_write(struct file *file, const char *data,
120 size_t len, loff_t *ppos)
126 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
127 for (i = 0; i != len; i++) {
130 if (get_user(c, data + i))
133 set_bit(WDT_OK_TO_CLOSE, &wdt_status);
141 static int orion5x_wdt_settimeout(int new_time)
143 if ((new_time <= 0) || (new_time > wdt_max_duration))
146 /* Set new watchdog time to be used when
147 * orion5x_wdt_enable() or orion5x_wdt_ping() is called. */
148 heartbeat = new_time;
152 static const struct watchdog_info ident = {
153 .options = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT |
155 .identity = "Orion5x Watchdog",
158 static long orion5x_wdt_ioctl(struct file *file, unsigned int cmd,
165 case WDIOC_GETSUPPORT:
166 ret = copy_to_user((struct watchdog_info *)arg, &ident,
167 sizeof(ident)) ? -EFAULT : 0;
170 case WDIOC_GETSTATUS:
171 case WDIOC_GETBOOTSTATUS:
172 ret = put_user(0, (int *)arg);
175 case WDIOC_KEEPALIVE:
180 case WDIOC_SETTIMEOUT:
181 ret = get_user(time, (int *)arg);
185 if (orion5x_wdt_settimeout(time)) {
192 case WDIOC_GETTIMEOUT:
193 ret = put_user(heartbeat, (int *)arg);
196 case WDIOC_GETTIMELEFT:
197 if (orion5x_wdt_get_timeleft(&time)) {
201 ret = put_user(time, (int *)arg);
207 static int orion5x_wdt_release(struct inode *inode, struct file *file)
209 if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
210 orion5x_wdt_disable();
212 printk(KERN_CRIT "WATCHDOG: Device closed unexpectedly - "
213 "timer will not stop\n");
214 clear_bit(WDT_IN_USE, &wdt_status);
215 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
221 static const struct file_operations orion5x_wdt_fops = {
222 .owner = THIS_MODULE,
224 .write = orion5x_wdt_write,
225 .unlocked_ioctl = orion5x_wdt_ioctl,
226 .open = orion5x_wdt_open,
227 .release = orion5x_wdt_release,
230 static struct miscdevice orion5x_wdt_miscdev = {
231 .minor = WATCHDOG_MINOR,
233 .fops = &orion5x_wdt_fops,
236 static int __devinit orion5x_wdt_probe(struct platform_device *pdev)
238 struct orion5x_wdt_platform_data *pdata = pdev->dev.platform_data;
242 wdt_tclk = pdata->tclk;
244 printk(KERN_ERR "Orion5x Watchdog misses platform data\n");
248 if (orion5x_wdt_miscdev.parent)
250 orion5x_wdt_miscdev.parent = &pdev->dev;
252 wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
253 if (orion5x_wdt_settimeout(heartbeat))
254 heartbeat = wdt_max_duration;
256 ret = misc_register(&orion5x_wdt_miscdev);
260 printk(KERN_INFO "Orion5x Watchdog Timer: Initial timeout %d sec%s\n",
261 heartbeat, nowayout ? ", nowayout" : "");
265 static int __devexit orion5x_wdt_remove(struct platform_device *pdev)
269 if (test_bit(WDT_IN_USE, &wdt_status)) {
270 orion5x_wdt_disable();
271 clear_bit(WDT_IN_USE, &wdt_status);
274 ret = misc_deregister(&orion5x_wdt_miscdev);
276 orion5x_wdt_miscdev.parent = NULL;
281 static void orion5x_wdt_shutdown(struct platform_device *pdev)
283 if (test_bit(WDT_IN_USE, &wdt_status))
284 orion5x_wdt_disable();
287 static struct platform_driver orion5x_wdt_driver = {
288 .probe = orion5x_wdt_probe,
289 .remove = __devexit_p(orion5x_wdt_remove),
290 .shutdown = orion5x_wdt_shutdown,
292 .owner = THIS_MODULE,
293 .name = "orion5x_wdt",
297 static int __init orion5x_wdt_init(void)
299 spin_lock_init(&wdt_lock);
300 return platform_driver_register(&orion5x_wdt_driver);
303 static void __exit orion5x_wdt_exit(void)
305 platform_driver_unregister(&orion5x_wdt_driver);
308 module_init(orion5x_wdt_init);
309 module_exit(orion5x_wdt_exit);
311 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
312 MODULE_DESCRIPTION("Orion5x Processor Watchdog");
314 module_param(heartbeat, int, 0);
315 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
317 module_param(nowayout, int, 0);
318 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
319 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
321 MODULE_LICENSE("GPL");
322 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);