x86/amd-iommu: Remove redundant device_flush_dte() calls
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / watchdog / stmp3xxx_wdt.c
blobb3421fd2cda80760a0015ee2af75ce3d89bcf985
1 /*
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.
8 */
9 #include <linux/init.h>
10 #include <linux/kernel.h>
11 #include <linux/fs.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>
18 #include <mach/platform.h>
19 #include <mach/regs-rtc.h>
21 #define DEFAULT_HEARTBEAT 19
22 #define MAX_HEARTBEAT (0x10000000 >> 6)
24 /* missing bitmask in headers */
25 #define BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER 0x80000000
27 #define WDT_IN_USE 0
28 #define WDT_OK_TO_CLOSE 1
30 #define WDOG_COUNTER_RATE 1000 /* 1 kHz clock */
32 static DEFINE_SPINLOCK(stmp3xxx_wdt_io_lock);
33 static unsigned long wdt_status;
34 static const int nowayout = WATCHDOG_NOWAYOUT;
35 static int heartbeat = DEFAULT_HEARTBEAT;
36 static unsigned long boot_status;
38 static void wdt_enable(u32 value)
40 spin_lock(&stmp3xxx_wdt_io_lock);
41 __raw_writel(value, REGS_RTC_BASE + HW_RTC_WATCHDOG);
42 stmp3xxx_setl(BM_RTC_CTRL_WATCHDOGEN, REGS_RTC_BASE + HW_RTC_CTRL);
43 stmp3xxx_setl(BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER,
44 REGS_RTC_BASE + HW_RTC_PERSISTENT1);
45 spin_unlock(&stmp3xxx_wdt_io_lock);
48 static void wdt_disable(void)
50 spin_lock(&stmp3xxx_wdt_io_lock);
51 stmp3xxx_clearl(BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER,
52 REGS_RTC_BASE + HW_RTC_PERSISTENT1);
53 stmp3xxx_clearl(BM_RTC_CTRL_WATCHDOGEN, REGS_RTC_BASE + HW_RTC_CTRL);
54 spin_unlock(&stmp3xxx_wdt_io_lock);
57 static void wdt_ping(void)
59 wdt_enable(heartbeat * WDOG_COUNTER_RATE);
62 static int stmp3xxx_wdt_open(struct inode *inode, struct file *file)
64 if (test_and_set_bit(WDT_IN_USE, &wdt_status))
65 return -EBUSY;
67 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
68 wdt_ping();
70 return nonseekable_open(inode, file);
73 static ssize_t stmp3xxx_wdt_write(struct file *file, const char __user *data,
74 size_t len, loff_t *ppos)
76 if (len) {
77 if (!nowayout) {
78 size_t i;
80 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
82 for (i = 0; i != len; i++) {
83 char c;
85 if (get_user(c, data + i))
86 return -EFAULT;
87 if (c == 'V')
88 set_bit(WDT_OK_TO_CLOSE, &wdt_status);
91 wdt_ping();
94 return len;
97 static const struct watchdog_info ident = {
98 .options = WDIOF_CARDRESET |
99 WDIOF_MAGICCLOSE |
100 WDIOF_SETTIMEOUT |
101 WDIOF_KEEPALIVEPING,
102 .identity = "STMP3XXX Watchdog",
105 static long stmp3xxx_wdt_ioctl(struct file *file, unsigned int cmd,
106 unsigned long arg)
108 void __user *argp = (void __user *)arg;
109 int __user *p = argp;
110 int new_heartbeat, opts;
111 int ret = -ENOTTY;
113 switch (cmd) {
114 case WDIOC_GETSUPPORT:
115 ret = copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
116 break;
118 case WDIOC_GETSTATUS:
119 ret = put_user(0, p);
120 break;
122 case WDIOC_GETBOOTSTATUS:
123 ret = put_user(boot_status, p);
124 break;
126 case WDIOC_SETOPTIONS:
127 if (get_user(opts, p)) {
128 ret = -EFAULT;
129 break;
131 if (opts & WDIOS_DISABLECARD)
132 wdt_disable();
133 else if (opts & WDIOS_ENABLECARD)
134 wdt_ping();
135 else {
136 pr_debug("%s: unknown option 0x%x\n", __func__, opts);
137 ret = -EINVAL;
138 break;
140 ret = 0;
141 break;
143 case WDIOC_KEEPALIVE:
144 wdt_ping();
145 ret = 0;
146 break;
148 case WDIOC_SETTIMEOUT:
149 if (get_user(new_heartbeat, p)) {
150 ret = -EFAULT;
151 break;
153 if (new_heartbeat <= 0 || new_heartbeat > MAX_HEARTBEAT) {
154 ret = -EINVAL;
155 break;
158 heartbeat = new_heartbeat;
159 wdt_ping();
160 /* Fall through */
162 case WDIOC_GETTIMEOUT:
163 ret = put_user(heartbeat, p);
164 break;
166 return ret;
169 static int stmp3xxx_wdt_release(struct inode *inode, struct file *file)
171 int ret = 0;
173 if (!nowayout) {
174 if (!test_bit(WDT_OK_TO_CLOSE, &wdt_status)) {
175 wdt_ping();
176 pr_debug("%s: Device closed unexpectdly\n", __func__);
177 ret = -EINVAL;
178 } else {
179 wdt_disable();
180 clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
183 clear_bit(WDT_IN_USE, &wdt_status);
185 return ret;
188 static const struct file_operations stmp3xxx_wdt_fops = {
189 .owner = THIS_MODULE,
190 .llseek = no_llseek,
191 .write = stmp3xxx_wdt_write,
192 .unlocked_ioctl = stmp3xxx_wdt_ioctl,
193 .open = stmp3xxx_wdt_open,
194 .release = stmp3xxx_wdt_release,
197 static struct miscdevice stmp3xxx_wdt_miscdev = {
198 .minor = WATCHDOG_MINOR,
199 .name = "watchdog",
200 .fops = &stmp3xxx_wdt_fops,
203 static int __devinit stmp3xxx_wdt_probe(struct platform_device *pdev)
205 int ret = 0;
207 if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
208 heartbeat = DEFAULT_HEARTBEAT;
210 boot_status = __raw_readl(REGS_RTC_BASE + HW_RTC_PERSISTENT1) &
211 BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER;
212 boot_status = !!boot_status;
213 stmp3xxx_clearl(BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER,
214 REGS_RTC_BASE + HW_RTC_PERSISTENT1);
215 wdt_disable(); /* disable for now */
217 ret = misc_register(&stmp3xxx_wdt_miscdev);
218 if (ret < 0) {
219 dev_err(&pdev->dev, "cannot register misc device\n");
220 return ret;
223 printk(KERN_INFO "stmp3xxx watchdog: initialized, heartbeat %d sec\n",
224 heartbeat);
226 return ret;
229 static int __devexit stmp3xxx_wdt_remove(struct platform_device *pdev)
231 misc_deregister(&stmp3xxx_wdt_miscdev);
232 return 0;
235 #ifdef CONFIG_PM
236 static int wdt_suspended;
237 static u32 wdt_saved_time;
239 static int stmp3xxx_wdt_suspend(struct platform_device *pdev,
240 pm_message_t state)
242 if (__raw_readl(REGS_RTC_BASE + HW_RTC_CTRL) &
243 BM_RTC_CTRL_WATCHDOGEN) {
244 wdt_suspended = 1;
245 wdt_saved_time = __raw_readl(REGS_RTC_BASE + HW_RTC_WATCHDOG);
246 wdt_disable();
248 return 0;
251 static int stmp3xxx_wdt_resume(struct platform_device *pdev)
253 if (wdt_suspended) {
254 wdt_enable(wdt_saved_time);
255 wdt_suspended = 0;
257 return 0;
259 #else
260 #define stmp3xxx_wdt_suspend NULL
261 #define stmp3xxx_wdt_resume NULL
262 #endif
264 static struct platform_driver platform_wdt_driver = {
265 .driver = {
266 .name = "stmp3xxx_wdt",
268 .probe = stmp3xxx_wdt_probe,
269 .remove = __devexit_p(stmp3xxx_wdt_remove),
270 .suspend = stmp3xxx_wdt_suspend,
271 .resume = stmp3xxx_wdt_resume,
274 static int __init stmp3xxx_wdt_init(void)
276 return platform_driver_register(&platform_wdt_driver);
279 static void __exit stmp3xxx_wdt_exit(void)
281 return platform_driver_unregister(&platform_wdt_driver);
284 module_init(stmp3xxx_wdt_init);
285 module_exit(stmp3xxx_wdt_exit);
287 MODULE_DESCRIPTION("STMP3XXX Watchdog Driver");
288 MODULE_LICENSE("GPL");
290 module_param(heartbeat, int, 0);
291 MODULE_PARM_DESC(heartbeat,
292 "Watchdog heartbeat period in seconds from 1 to "
293 __MODULE_STRING(MAX_HEARTBEAT) ", default "
294 __MODULE_STRING(DEFAULT_HEARTBEAT));
296 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);