Merge branch 'pmtimer-overflow' into release
[linux-2.6] / drivers / watchdog / rc32434_wdt.c
1 /*
2  *  IDT Interprise 79RC32434 watchdog driver
3  *
4  *  Copyright (C) 2006, Ondrej Zajicek <santiago@crfreenet.org>
5  *  Copyright (C) 2008, Florian Fainelli <florian@openwrt.org>
6  *
7  *  based on
8  *  SoftDog 0.05:       A Software Watchdog Device
9  *
10  *  (c) Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>,
11  *                                      All Rights Reserved.
12  *
13  *  This program is free software; you can redistribute it and/or
14  *  modify it under the terms of the GNU General Public License
15  *  as published by the Free Software Foundation; either version
16  *  2 of the License, or (at your option) any later version.
17  *
18  */
19
20 #include <linux/module.h>
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23 #include <linux/fs.h>
24 #include <linux/mm.h>
25 #include <linux/miscdevice.h>
26 #include <linux/watchdog.h>
27 #include <linux/reboot.h>
28 #include <linux/smp_lock.h>
29 #include <linux/init.h>
30 #include <linux/platform_device.h>
31 #include <linux/uaccess.h>
32
33 #include <asm/bootinfo.h>
34 #include <asm/time.h>
35 #include <asm/mach-rc32434/integ.h>
36
37 #define VERSION "0.4"
38
39 static struct {
40         unsigned long inuse;
41 } rc32434_wdt_device;
42
43 static struct integ __iomem *wdt_reg;
44
45 static int expect_close;
46
47 /* Board internal clock speed in Hz,
48  * the watchdog timer ticks at. */
49 extern unsigned int idt_cpu_freq;
50
51 /* translate wtcompare value to seconds and vice versa */
52 #define WTCOMP2SEC(x)   (x / idt_cpu_freq)
53 #define SEC2WTCOMP(x)   (x * idt_cpu_freq)
54
55 /* Use a default timeout of 20s. This should be
56  * safe for CPU clock speeds up to 400MHz, as
57  * ((2 ^ 32) - 1) / (400MHz / 2) = 21s.  */
58 #define WATCHDOG_TIMEOUT 20
59
60 static int timeout = WATCHDOG_TIMEOUT;
61
62 static int nowayout = WATCHDOG_NOWAYOUT;
63 module_param(nowayout, int, 0);
64 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
65         __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
66
67 /* apply or and nand masks to data read from addr and write back */
68 #define SET_BITS(addr, or, nand) \
69         writel((readl(&addr) | or) & ~nand, &addr)
70
71 static void rc32434_wdt_start(void)
72 {
73         u32 or, nand;
74
75         /* zero the counter before enabling */
76         writel(0, &wdt_reg->wtcount);
77
78         /* don't generate a non-maskable interrupt,
79          * do a warm reset instead */
80         nand = 1 << RC32434_ERR_WNE;
81         or = 1 << RC32434_ERR_WRE;
82
83         /* reset the ERRCS timeout bit in case it's set */
84         nand |= 1 << RC32434_ERR_WTO;
85
86         SET_BITS(wdt_reg->errcs, or, nand);
87
88         /* reset WTC timeout bit and enable WDT */
89         nand = 1 << RC32434_WTC_TO;
90         or = 1 << RC32434_WTC_EN;
91
92         SET_BITS(wdt_reg->wtc, or, nand);
93 }
94
95 static void rc32434_wdt_stop(void)
96 {
97         /* Disable WDT */
98         SET_BITS(wdt_reg->wtc, 0, 1 << RC32434_WTC_EN);
99 }
100
101 static int rc32434_wdt_set(int new_timeout)
102 {
103         int max_to = WTCOMP2SEC((u32)-1);
104
105         if (new_timeout < 0 || new_timeout > max_to) {
106                 printk(KERN_ERR KBUILD_MODNAME
107                         ": timeout value must be between 0 and %d",
108                         max_to);
109                 return -EINVAL;
110         }
111         timeout = new_timeout;
112         writel(SEC2WTCOMP(timeout), &wdt_reg->wtcompare);
113
114         return 0;
115 }
116
117 static void rc32434_wdt_ping(void)
118 {
119         writel(0, &wdt_reg->wtcount);
120 }
121
122 static int rc32434_wdt_open(struct inode *inode, struct file *file)
123 {
124         if (test_and_set_bit(0, &rc32434_wdt_device.inuse))
125                 return -EBUSY;
126
127         if (nowayout)
128                 __module_get(THIS_MODULE);
129
130         rc32434_wdt_start();
131         rc32434_wdt_ping();
132
133         return nonseekable_open(inode, file);
134 }
135
136 static int rc32434_wdt_release(struct inode *inode, struct file *file)
137 {
138         if (expect_close == 42) {
139                 rc32434_wdt_stop();
140                 printk(KERN_INFO KBUILD_MODNAME ": disabling watchdog timer\n");
141                 module_put(THIS_MODULE);
142         } else {
143                 printk(KERN_CRIT KBUILD_MODNAME
144                         ": device closed unexpectedly. WDT will not stop !\n");
145                 rc32434_wdt_ping();
146         }
147         clear_bit(0, &rc32434_wdt_device.inuse);
148         return 0;
149 }
150
151 static ssize_t rc32434_wdt_write(struct file *file, const char *data,
152                                 size_t len, loff_t *ppos)
153 {
154         if (len) {
155                 if (!nowayout) {
156                         size_t i;
157
158                         /* In case it was set long ago */
159                         expect_close = 0;
160
161                         for (i = 0; i != len; i++) {
162                                 char c;
163                                 if (get_user(c, data + i))
164                                         return -EFAULT;
165                                 if (c == 'V')
166                                         expect_close = 42;
167                         }
168                 }
169                 rc32434_wdt_ping();
170                 return len;
171         }
172         return 0;
173 }
174
175 static long rc32434_wdt_ioctl(struct file *file, unsigned int cmd,
176                                 unsigned long arg)
177 {
178         void __user *argp = (void __user *)arg;
179         int new_timeout;
180         unsigned int value;
181         static struct watchdog_info ident = {
182                 .options =              WDIOF_SETTIMEOUT |
183                                         WDIOF_KEEPALIVEPING |
184                                         WDIOF_MAGICCLOSE,
185                 .identity =             "RC32434_WDT Watchdog",
186         };
187         switch (cmd) {
188         case WDIOC_KEEPALIVE:
189                 rc32434_wdt_ping();
190                 break;
191         case WDIOC_GETSTATUS:
192         case WDIOC_GETBOOTSTATUS:
193                 value = 0;
194                 if (copy_to_user(argp, &value, sizeof(int)))
195                         return -EFAULT;
196                 break;
197         case WDIOC_GETSUPPORT:
198                 if (copy_to_user(argp, &ident, sizeof(ident)))
199                         return -EFAULT;
200                 break;
201         case WDIOC_SETOPTIONS:
202                 if (copy_from_user(&value, argp, sizeof(int)))
203                         return -EFAULT;
204                 switch (value) {
205                 case WDIOS_ENABLECARD:
206                         rc32434_wdt_start();
207                         break;
208                 case WDIOS_DISABLECARD:
209                         rc32434_wdt_stop();
210                         break;
211                 default:
212                         return -EINVAL;
213                 }
214                 break;
215         case WDIOC_SETTIMEOUT:
216                 if (copy_from_user(&new_timeout, argp, sizeof(int)))
217                         return -EFAULT;
218                 if (rc32434_wdt_set(new_timeout))
219                         return -EINVAL;
220                 /* Fall through */
221         case WDIOC_GETTIMEOUT:
222                 return copy_to_user(argp, &timeout, sizeof(int));
223         default:
224                 return -ENOTTY;
225         }
226
227         return 0;
228 }
229
230 static struct file_operations rc32434_wdt_fops = {
231         .owner          = THIS_MODULE,
232         .llseek         = no_llseek,
233         .write          = rc32434_wdt_write,
234         .unlocked_ioctl = rc32434_wdt_ioctl,
235         .open           = rc32434_wdt_open,
236         .release        = rc32434_wdt_release,
237 };
238
239 static struct miscdevice rc32434_wdt_miscdev = {
240         .minor  = WATCHDOG_MINOR,
241         .name   = "watchdog",
242         .fops   = &rc32434_wdt_fops,
243 };
244
245 static char banner[] __devinitdata = KERN_INFO KBUILD_MODNAME
246                 ": Watchdog Timer version " VERSION ", timer margin: %d sec\n";
247
248 static int __devinit rc32434_wdt_probe(struct platform_device *pdev)
249 {
250         int ret;
251         struct resource *r;
252
253         r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rb532_wdt_res");
254         if (!r) {
255                 printk(KERN_ERR KBUILD_MODNAME
256                         "failed to retrieve resources\n");
257                 return -ENODEV;
258         }
259
260         wdt_reg = ioremap_nocache(r->start, r->end - r->start);
261         if (!wdt_reg) {
262                 printk(KERN_ERR KBUILD_MODNAME
263                         "failed to remap I/O resources\n");
264                 return -ENXIO;
265         }
266
267         ret = misc_register(&rc32434_wdt_miscdev);
268         if (ret < 0) {
269                 printk(KERN_ERR KBUILD_MODNAME
270                         "failed to register watchdog device\n");
271                 goto unmap;
272         }
273
274         printk(banner, timeout);
275
276         return 0;
277
278 unmap:
279         iounmap(wdt_reg);
280         return ret;
281 }
282
283 static int __devexit rc32434_wdt_remove(struct platform_device *pdev)
284 {
285         misc_deregister(&rc32434_wdt_miscdev);
286         iounmap(wdt_reg);
287         return 0;
288 }
289
290 static struct platform_driver rc32434_wdt = {
291         .probe  = rc32434_wdt_probe,
292         .remove = __devexit_p(rc32434_wdt_remove),
293         .driver = {
294                 .name = "rc32434_wdt",
295         }
296 };
297
298 static int __init rc32434_wdt_init(void)
299 {
300         return platform_driver_register(&rc32434_wdt);
301 }
302
303 static void __exit rc32434_wdt_exit(void)
304 {
305         platform_driver_unregister(&rc32434_wdt);
306 }
307
308 module_init(rc32434_wdt_init);
309 module_exit(rc32434_wdt_exit);
310
311 MODULE_AUTHOR("Ondrej Zajicek <santiago@crfreenet.org>,"
312                 "Florian Fainelli <florian@openwrt.org>");
313 MODULE_DESCRIPTION("Driver for the IDT RC32434 SoC watchdog");
314 MODULE_LICENSE("GPL");
315 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);