drm/radeon/rv740: fix backend setup
[linux-2.6.git] / drivers / watchdog / rdc321x_wdt.c
1 /*
2  * RDC321x watchdog driver
3  *
4  * Copyright (C) 2007 Florian Fainelli <florian@openwrt.org>
5  *
6  * This driver is highly inspired from the cpu5_wdt driver
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  *
22  */
23
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/types.h>
27 #include <linux/errno.h>
28 #include <linux/miscdevice.h>
29 #include <linux/fs.h>
30 #include <linux/init.h>
31 #include <linux/ioport.h>
32 #include <linux/timer.h>
33 #include <linux/completion.h>
34 #include <linux/jiffies.h>
35 #include <linux/platform_device.h>
36 #include <linux/watchdog.h>
37 #include <linux/io.h>
38 #include <linux/uaccess.h>
39
40 #include <asm/rdc321x_defs.h>
41
42 #define RDC_WDT_MASK    0x80000000 /* Mask */
43 #define RDC_WDT_EN      0x00800000 /* Enable bit */
44 #define RDC_WDT_WTI     0x00200000 /* Generate CPU reset/NMI/WDT on timeout */
45 #define RDC_WDT_RST     0x00100000 /* Reset bit */
46 #define RDC_WDT_WIF     0x00040000 /* WDT IRQ Flag */
47 #define RDC_WDT_IRT     0x00000100 /* IRQ Routing table */
48 #define RDC_WDT_CNT     0x00000001 /* WDT count */
49
50 #define RDC_CLS_TMR     0x80003844 /* Clear timer */
51
52 #define RDC_WDT_INTERVAL        (HZ/10+1)
53
54 static int ticks = 1000;
55
56 /* some device data */
57
58 static struct {
59         struct completion stop;
60         int running;
61         struct timer_list timer;
62         int queue;
63         int default_ticks;
64         unsigned long inuse;
65         spinlock_t lock;
66 } rdc321x_wdt_device;
67
68 /* generic helper functions */
69
70 static void rdc321x_wdt_trigger(unsigned long unused)
71 {
72         unsigned long flags;
73
74         if (rdc321x_wdt_device.running)
75                 ticks--;
76
77         /* keep watchdog alive */
78         spin_lock_irqsave(&rdc321x_wdt_device.lock, flags);
79         outl(RDC_WDT_EN | inl(RDC3210_CFGREG_DATA),
80                 RDC3210_CFGREG_DATA);
81         spin_unlock_irqrestore(&rdc321x_wdt_device.lock, flags);
82
83         /* requeue?? */
84         if (rdc321x_wdt_device.queue && ticks)
85                 mod_timer(&rdc321x_wdt_device.timer,
86                                 jiffies + RDC_WDT_INTERVAL);
87         else {
88                 /* ticks doesn't matter anyway */
89                 complete(&rdc321x_wdt_device.stop);
90         }
91
92 }
93
94 static void rdc321x_wdt_reset(void)
95 {
96         ticks = rdc321x_wdt_device.default_ticks;
97 }
98
99 static void rdc321x_wdt_start(void)
100 {
101         unsigned long flags;
102
103         if (!rdc321x_wdt_device.queue) {
104                 rdc321x_wdt_device.queue = 1;
105
106                 /* Clear the timer */
107                 spin_lock_irqsave(&rdc321x_wdt_device.lock, flags);
108                 outl(RDC_CLS_TMR, RDC3210_CFGREG_ADDR);
109
110                 /* Enable watchdog and set the timeout to 81.92 us */
111                 outl(RDC_WDT_EN | RDC_WDT_CNT, RDC3210_CFGREG_DATA);
112                 spin_unlock_irqrestore(&rdc321x_wdt_device.lock, flags);
113
114                 mod_timer(&rdc321x_wdt_device.timer,
115                                 jiffies + RDC_WDT_INTERVAL);
116         }
117
118         /* if process dies, counter is not decremented */
119         rdc321x_wdt_device.running++;
120 }
121
122 static int rdc321x_wdt_stop(void)
123 {
124         if (rdc321x_wdt_device.running)
125                 rdc321x_wdt_device.running = 0;
126
127         ticks = rdc321x_wdt_device.default_ticks;
128
129         return -EIO;
130 }
131
132 /* filesystem operations */
133 static int rdc321x_wdt_open(struct inode *inode, struct file *file)
134 {
135         if (test_and_set_bit(0, &rdc321x_wdt_device.inuse))
136                 return -EBUSY;
137
138         return nonseekable_open(inode, file);
139 }
140
141 static int rdc321x_wdt_release(struct inode *inode, struct file *file)
142 {
143         clear_bit(0, &rdc321x_wdt_device.inuse);
144         return 0;
145 }
146
147 static long rdc321x_wdt_ioctl(struct file *file, unsigned int cmd,
148                                 unsigned long arg)
149 {
150         void __user *argp = (void __user *)arg;
151         unsigned int value;
152         static struct watchdog_info ident = {
153                 .options = WDIOF_CARDRESET,
154                 .identity = "RDC321x WDT",
155         };
156         unsigned long flags;
157
158         switch (cmd) {
159         case WDIOC_KEEPALIVE:
160                 rdc321x_wdt_reset();
161                 break;
162         case WDIOC_GETSTATUS:
163                 /* Read the value from the DATA register */
164                 spin_lock_irqsave(&rdc321x_wdt_device.lock, flags);
165                 value = inl(RDC3210_CFGREG_DATA);
166                 spin_unlock_irqrestore(&rdc321x_wdt_device.lock, flags);
167                 if (copy_to_user(argp, &value, sizeof(int)))
168                         return -EFAULT;
169                 break;
170         case WDIOC_GETSUPPORT:
171                 if (copy_to_user(argp, &ident, sizeof(ident)))
172                         return -EFAULT;
173                 break;
174         case WDIOC_SETOPTIONS:
175                 if (copy_from_user(&value, argp, sizeof(int)))
176                         return -EFAULT;
177                 switch (value) {
178                 case WDIOS_ENABLECARD:
179                         rdc321x_wdt_start();
180                         break;
181                 case WDIOS_DISABLECARD:
182                         return rdc321x_wdt_stop();
183                 default:
184                         return -EINVAL;
185                 }
186                 break;
187         default:
188                 return -ENOTTY;
189         }
190         return 0;
191 }
192
193 static ssize_t rdc321x_wdt_write(struct file *file, const char __user *buf,
194                                 size_t count, loff_t *ppos)
195 {
196         if (!count)
197                 return -EIO;
198
199         rdc321x_wdt_reset();
200
201         return count;
202 }
203
204 static const struct file_operations rdc321x_wdt_fops = {
205         .owner          = THIS_MODULE,
206         .llseek         = no_llseek,
207         .unlocked_ioctl = rdc321x_wdt_ioctl,
208         .open           = rdc321x_wdt_open,
209         .write          = rdc321x_wdt_write,
210         .release        = rdc321x_wdt_release,
211 };
212
213 static struct miscdevice rdc321x_wdt_misc = {
214         .minor  = WATCHDOG_MINOR,
215         .name   = "watchdog",
216         .fops   = &rdc321x_wdt_fops,
217 };
218
219 static int __devinit rdc321x_wdt_probe(struct platform_device *pdev)
220 {
221         int err;
222
223         err = misc_register(&rdc321x_wdt_misc);
224         if (err < 0) {
225                 printk(KERN_ERR PFX "watchdog misc_register failed\n");
226                 return err;
227         }
228
229         spin_lock_init(&rdc321x_wdt_device.lock);
230
231         /* Reset the watchdog */
232         outl(RDC_WDT_RST, RDC3210_CFGREG_DATA);
233
234         init_completion(&rdc321x_wdt_device.stop);
235         rdc321x_wdt_device.queue = 0;
236
237         clear_bit(0, &rdc321x_wdt_device.inuse);
238
239         setup_timer(&rdc321x_wdt_device.timer, rdc321x_wdt_trigger, 0);
240
241         rdc321x_wdt_device.default_ticks = ticks;
242
243         printk(KERN_INFO PFX "watchdog init success\n");
244
245         return 0;
246 }
247
248 static int __devexit rdc321x_wdt_remove(struct platform_device *pdev)
249 {
250         if (rdc321x_wdt_device.queue) {
251                 rdc321x_wdt_device.queue = 0;
252                 wait_for_completion(&rdc321x_wdt_device.stop);
253         }
254
255         misc_deregister(&rdc321x_wdt_misc);
256
257         return 0;
258 }
259
260 static struct platform_driver rdc321x_wdt_driver = {
261         .probe = rdc321x_wdt_probe,
262         .remove = __devexit_p(rdc321x_wdt_remove),
263         .driver = {
264                 .owner = THIS_MODULE,
265                 .name = "rdc321x-wdt",
266         },
267 };
268
269 static int __init rdc321x_wdt_init(void)
270 {
271         return platform_driver_register(&rdc321x_wdt_driver);
272 }
273
274 static void __exit rdc321x_wdt_exit(void)
275 {
276         platform_driver_unregister(&rdc321x_wdt_driver);
277 }
278
279 module_init(rdc321x_wdt_init);
280 module_exit(rdc321x_wdt_exit);
281
282 MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>");
283 MODULE_DESCRIPTION("RDC321x watchdog driver");
284 MODULE_LICENSE("GPL");
285 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);