2 * Watchdog driver for Freescale STMP37XX/STMP378X
4 * Author: Vitaly Wool <vital@embeddedalley.com>
6 * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
7 * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
9 #include <linux/init.h>
10 #include <linux/kernel.h>
12 #include <linux/miscdevice.h>
13 #include <linux/watchdog.h>
14 #include <linux/platform_device.h>
15 #include <linux/spinlock.h>
16 #include <linux/uaccess.h>
17 #include <linux/module.h>
19 #include <mach/platform.h>
20 #include <mach/regs-rtc.h>
22 #define DEFAULT_HEARTBEAT 19
23 #define MAX_HEARTBEAT (0x10000000 >> 6)
25 /* missing bitmask in headers */
26 #define BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER 0x80000000
29 #define WDT_OK_TO_CLOSE 1
31 #define WDOG_COUNTER_RATE 1000 /* 1 kHz clock */
33 static DEFINE_SPINLOCK(stmp3xxx_wdt_io_lock);
34 static unsigned long wdt_status;
35 static const int nowayout = WATCHDOG_NOWAYOUT;
36 static int heartbeat = DEFAULT_HEARTBEAT;
37 static unsigned long boot_status;
39 static void wdt_enable(u32 value)
41 spin_lock(&stmp3xxx_wdt_io_lock);
42 __raw_writel(value, REGS_RTC_BASE + HW_RTC_WATCHDOG);
43 stmp3xxx_setl(BM_RTC_CTRL_WATCHDOGEN, REGS_RTC_BASE + HW_RTC_CTRL);
44 stmp3xxx_setl(BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER,
45 REGS_RTC_BASE + HW_RTC_PERSISTENT1);
46 spin_unlock(&stmp3xxx_wdt_io_lock);
49 static void wdt_disable(void)
51 spin_lock(&stmp3xxx_wdt_io_lock);
52 stmp3xxx_clearl(BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER,
53 REGS_RTC_BASE + HW_RTC_PERSISTENT1);
54 stmp3xxx_clearl(BM_RTC_CTRL_WATCHDOGEN, REGS_RTC_BASE + HW_RTC_CTRL);
55 spin_unlock(&stmp3xxx_wdt_io_lock);
58 static void wdt_ping(void)
60 wdt_enable(heartbeat * WDOG_COUNTER_RATE);
63 static int stmp3xxx_wdt_open(struct inode *inode, struct file *file)
65 if (test_and_set_bit(WDT_IN_USE, &wdt_status))
68 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
71 return nonseekable_open(inode, file);
74 static ssize_t stmp3xxx_wdt_write(struct file *file, const char __user *data,
75 size_t len, loff_t *ppos)
81 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
83 for (i = 0; i != len; i++) {
86 if (get_user(c, data + i))
89 set_bit(WDT_OK_TO_CLOSE, &wdt_status);
98 static const struct watchdog_info ident = {
99 .options = WDIOF_CARDRESET |
103 .identity = "STMP3XXX Watchdog",
106 static long stmp3xxx_wdt_ioctl(struct file *file, unsigned int cmd,
109 void __user *argp = (void __user *)arg;
110 int __user *p = argp;
111 int new_heartbeat, opts;
115 case WDIOC_GETSUPPORT:
116 ret = copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
119 case WDIOC_GETSTATUS:
120 ret = put_user(0, p);
123 case WDIOC_GETBOOTSTATUS:
124 ret = put_user(boot_status, p);
127 case WDIOC_SETOPTIONS:
128 if (get_user(opts, p)) {
132 if (opts & WDIOS_DISABLECARD)
134 else if (opts & WDIOS_ENABLECARD)
137 pr_debug("%s: unknown option 0x%x\n", __func__, opts);
144 case WDIOC_KEEPALIVE:
149 case WDIOC_SETTIMEOUT:
150 if (get_user(new_heartbeat, p)) {
154 if (new_heartbeat <= 0 || new_heartbeat > MAX_HEARTBEAT) {
159 heartbeat = new_heartbeat;
163 case WDIOC_GETTIMEOUT:
164 ret = put_user(heartbeat, p);
170 static int stmp3xxx_wdt_release(struct inode *inode, struct file *file)
175 if (!test_bit(WDT_OK_TO_CLOSE, &wdt_status)) {
177 pr_debug("%s: Device closed unexpectedly\n", __func__);
181 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
184 clear_bit(WDT_IN_USE, &wdt_status);
189 static const struct file_operations stmp3xxx_wdt_fops = {
190 .owner = THIS_MODULE,
192 .write = stmp3xxx_wdt_write,
193 .unlocked_ioctl = stmp3xxx_wdt_ioctl,
194 .open = stmp3xxx_wdt_open,
195 .release = stmp3xxx_wdt_release,
198 static struct miscdevice stmp3xxx_wdt_miscdev = {
199 .minor = WATCHDOG_MINOR,
201 .fops = &stmp3xxx_wdt_fops,
204 static int __devinit stmp3xxx_wdt_probe(struct platform_device *pdev)
208 if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
209 heartbeat = DEFAULT_HEARTBEAT;
211 boot_status = __raw_readl(REGS_RTC_BASE + HW_RTC_PERSISTENT1) &
212 BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER;
213 boot_status = !!boot_status;
214 stmp3xxx_clearl(BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER,
215 REGS_RTC_BASE + HW_RTC_PERSISTENT1);
216 wdt_disable(); /* disable for now */
218 ret = misc_register(&stmp3xxx_wdt_miscdev);
220 dev_err(&pdev->dev, "cannot register misc device\n");
224 printk(KERN_INFO "stmp3xxx watchdog: initialized, heartbeat %d sec\n",
230 static int __devexit stmp3xxx_wdt_remove(struct platform_device *pdev)
232 misc_deregister(&stmp3xxx_wdt_miscdev);
237 static int wdt_suspended;
238 static u32 wdt_saved_time;
240 static int stmp3xxx_wdt_suspend(struct platform_device *pdev,
243 if (__raw_readl(REGS_RTC_BASE + HW_RTC_CTRL) &
244 BM_RTC_CTRL_WATCHDOGEN) {
246 wdt_saved_time = __raw_readl(REGS_RTC_BASE + HW_RTC_WATCHDOG);
252 static int stmp3xxx_wdt_resume(struct platform_device *pdev)
255 wdt_enable(wdt_saved_time);
261 #define stmp3xxx_wdt_suspend NULL
262 #define stmp3xxx_wdt_resume NULL
265 static struct platform_driver platform_wdt_driver = {
267 .name = "stmp3xxx_wdt",
269 .probe = stmp3xxx_wdt_probe,
270 .remove = __devexit_p(stmp3xxx_wdt_remove),
271 .suspend = stmp3xxx_wdt_suspend,
272 .resume = stmp3xxx_wdt_resume,
275 module_platform_driver(platform_wdt_driver);
277 MODULE_DESCRIPTION("STMP3XXX Watchdog Driver");
278 MODULE_LICENSE("GPL");
280 module_param(heartbeat, int, 0);
281 MODULE_PARM_DESC(heartbeat,
282 "Watchdog heartbeat period in seconds from 1 to "
283 __MODULE_STRING(MAX_HEARTBEAT) ", default "
284 __MODULE_STRING(DEFAULT_HEARTBEAT));
286 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);