Commit | Line | Data |
---|---|---|
03ec5856 FF |
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 | * | |
29fa0586 AC |
10 | * (c) Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>, |
11 | * All Rights Reserved. | |
03ec5856 FF |
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 | ||
d9a8798c | 37 | #define VERSION "0.4" |
03ec5856 FF |
38 | |
39 | static struct { | |
03ec5856 FF |
40 | unsigned long inuse; |
41 | } rc32434_wdt_device; | |
42 | ||
43 | static struct integ __iomem *wdt_reg; | |
03ec5856 FF |
44 | |
45 | static int expect_close; | |
0af98d37 PS |
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; | |
03ec5856 FF |
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 | ||
0af98d37 PS |
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) | |
03ec5856 FF |
70 | |
71 | static void rc32434_wdt_start(void) | |
72 | { | |
0af98d37 | 73 | u32 or, nand; |
03ec5856 | 74 | |
0af98d37 PS |
75 | /* zero the counter before enabling */ |
76 | writel(0, &wdt_reg->wtcount); | |
03ec5856 | 77 | |
0af98d37 PS |
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; | |
03ec5856 | 82 | |
0af98d37 PS |
83 | /* reset the ERRCS timeout bit in case it's set */ |
84 | nand |= 1 << RC32434_ERR_WTO; | |
03ec5856 | 85 | |
0af98d37 | 86 | SET_BITS(wdt_reg->errcs, or, nand); |
03ec5856 | 87 | |
0af98d37 PS |
88 | /* reset WTC timeout bit and enable WDT */ |
89 | nand = 1 << RC32434_WTC_TO; | |
90 | or = 1 << RC32434_WTC_EN; | |
03ec5856 | 91 | |
0af98d37 PS |
92 | SET_BITS(wdt_reg->wtc, or, nand); |
93 | } | |
03ec5856 | 94 | |
0af98d37 PS |
95 | static void rc32434_wdt_stop(void) |
96 | { | |
97 | /* Disable WDT */ | |
98 | SET_BITS(wdt_reg->wtc, 0, 1 << RC32434_WTC_EN); | |
03ec5856 FF |
99 | } |
100 | ||
0af98d37 | 101 | static int rc32434_wdt_set(int new_timeout) |
03ec5856 | 102 | { |
0af98d37 | 103 | int max_to = WTCOMP2SEC((u32)-1); |
03ec5856 | 104 | |
0af98d37 PS |
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 | } | |
03ec5856 | 111 | timeout = new_timeout; |
0af98d37 | 112 | writel(SEC2WTCOMP(timeout), &wdt_reg->wtcompare); |
03ec5856 | 113 | |
0af98d37 | 114 | return 0; |
03ec5856 FF |
115 | } |
116 | ||
0af98d37 | 117 | static void rc32434_wdt_ping(void) |
03ec5856 | 118 | { |
03ec5856 | 119 | writel(0, &wdt_reg->wtcount); |
03ec5856 FF |
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 | ||
0af98d37 PS |
130 | rc32434_wdt_start(); |
131 | rc32434_wdt_ping(); | |
132 | ||
03ec5856 FF |
133 | return nonseekable_open(inode, file); |
134 | } | |
135 | ||
136 | static int rc32434_wdt_release(struct inode *inode, struct file *file) | |
137 | { | |
0af98d37 | 138 | if (expect_close == 42) { |
03ec5856 FF |
139 | rc32434_wdt_stop(); |
140 | printk(KERN_INFO KBUILD_MODNAME ": disabling watchdog timer\n"); | |
141 | module_put(THIS_MODULE); | |
0af98d37 | 142 | } else { |
03ec5856 FF |
143 | printk(KERN_CRIT KBUILD_MODNAME |
144 | ": device closed unexpectedly. WDT will not stop !\n"); | |
0af98d37 PS |
145 | rc32434_wdt_ping(); |
146 | } | |
03ec5856 FF |
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') | |
0af98d37 | 166 | expect_close = 42; |
03ec5856 FF |
167 | } |
168 | } | |
0af98d37 | 169 | rc32434_wdt_ping(); |
03ec5856 FF |
170 | return len; |
171 | } | |
172 | return 0; | |
173 | } | |
174 | ||
7275fc8c WVS |
175 | static long rc32434_wdt_ioctl(struct file *file, unsigned int cmd, |
176 | unsigned long arg) | |
03ec5856 FF |
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: | |
0af98d37 | 189 | rc32434_wdt_ping(); |
03ec5856 FF |
190 | break; |
191 | case WDIOC_GETSTATUS: | |
192 | case WDIOC_GETBOOTSTATUS: | |
0af98d37 | 193 | value = 0; |
03ec5856 FF |
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(); | |
0af98d37 | 210 | break; |
03ec5856 FF |
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; | |
0af98d37 | 218 | if (rc32434_wdt_set(new_timeout)) |
03ec5856 | 219 | return -EINVAL; |
0af98d37 | 220 | /* Fall through */ |
03ec5856 FF |
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, | |
7275fc8c | 234 | .unlocked_ioctl = rc32434_wdt_ioctl, |
03ec5856 FF |
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 | ||
d9a8798c | 245 | static char banner[] __devinitdata = KERN_INFO KBUILD_MODNAME |
03ec5856 FF |
246 | ": Watchdog Timer version " VERSION ", timer margin: %d sec\n"; |
247 | ||
d9a8798c | 248 | static int __devinit rc32434_wdt_probe(struct platform_device *pdev) |
03ec5856 FF |
249 | { |
250 | int ret; | |
251 | struct resource *r; | |
252 | ||
0af98d37 | 253 | r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rb532_wdt_res"); |
03ec5856 FF |
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); | |
03ec5856 FF |
268 | if (ret < 0) { |
269 | printk(KERN_ERR KBUILD_MODNAME | |
270 | "failed to register watchdog device\n"); | |
271 | goto unmap; | |
272 | } | |
273 | ||
03ec5856 FF |
274 | printk(banner, timeout); |
275 | ||
276 | return 0; | |
277 | ||
278 | unmap: | |
279 | iounmap(wdt_reg); | |
280 | return ret; | |
281 | } | |
282 | ||
d9a8798c | 283 | static int __devexit rc32434_wdt_remove(struct platform_device *pdev) |
03ec5856 | 284 | { |
03ec5856 | 285 | misc_deregister(&rc32434_wdt_miscdev); |
03ec5856 | 286 | iounmap(wdt_reg); |
03ec5856 FF |
287 | return 0; |
288 | } | |
289 | ||
290 | static struct platform_driver rc32434_wdt = { | |
291 | .probe = rc32434_wdt_probe, | |
d9a8798c PS |
292 | .remove = __devexit_p(rc32434_wdt_remove), |
293 | .driver = { | |
03ec5856 FF |
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); |