Root/
1 | /* |
2 | * MachZ ZF-Logic Watchdog Timer driver for Linux |
3 | * |
4 | * |
5 | * This program is free software; you can redistribute it and/or |
6 | * modify it under the terms of the GNU General Public License |
7 | * as published by the Free Software Foundation; either version |
8 | * 2 of the License, or (at your option) any later version. |
9 | * |
10 | * The author does NOT admit liability nor provide warranty for |
11 | * any of this software. This material is provided "AS-IS" in |
12 | * the hope that it may be useful for others. |
13 | * |
14 | * Author: Fernando Fuganti <fuganti@conectiva.com.br> |
15 | * |
16 | * Based on sbc60xxwdt.c by Jakob Oestergaard |
17 | * |
18 | * |
19 | * We have two timers (wd#1, wd#2) driven by a 32 KHz clock with the |
20 | * following periods: |
21 | * wd#1 - 2 seconds; |
22 | * wd#2 - 7.2 ms; |
23 | * After the expiration of wd#1, it can generate a NMI, SCI, SMI, or |
24 | * a system RESET and it starts wd#2 that unconditionally will RESET |
25 | * the system when the counter reaches zero. |
26 | * |
27 | * 14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com> |
28 | * Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT |
29 | */ |
30 | |
31 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
32 | |
33 | #include <linux/module.h> |
34 | #include <linux/moduleparam.h> |
35 | #include <linux/types.h> |
36 | #include <linux/timer.h> |
37 | #include <linux/jiffies.h> |
38 | #include <linux/miscdevice.h> |
39 | #include <linux/watchdog.h> |
40 | #include <linux/fs.h> |
41 | #include <linux/ioport.h> |
42 | #include <linux/notifier.h> |
43 | #include <linux/reboot.h> |
44 | #include <linux/init.h> |
45 | #include <linux/io.h> |
46 | #include <linux/uaccess.h> |
47 | |
48 | |
49 | /* ports */ |
50 | #define ZF_IOBASE 0x218 |
51 | #define INDEX 0x218 |
52 | #define DATA_B 0x219 |
53 | #define DATA_W 0x21A |
54 | #define DATA_D 0x21A |
55 | |
56 | /* indexes */ /* size */ |
57 | #define ZFL_VERSION 0x02 /* 16 */ |
58 | #define CONTROL 0x10 /* 16 */ |
59 | #define STATUS 0x12 /* 8 */ |
60 | #define COUNTER_1 0x0C /* 16 */ |
61 | #define COUNTER_2 0x0E /* 8 */ |
62 | #define PULSE_LEN 0x0F /* 8 */ |
63 | |
64 | /* controls */ |
65 | #define ENABLE_WD1 0x0001 |
66 | #define ENABLE_WD2 0x0002 |
67 | #define RESET_WD1 0x0010 |
68 | #define RESET_WD2 0x0020 |
69 | #define GEN_SCI 0x0100 |
70 | #define GEN_NMI 0x0200 |
71 | #define GEN_SMI 0x0400 |
72 | #define GEN_RESET 0x0800 |
73 | |
74 | |
75 | /* utilities */ |
76 | |
77 | #define WD1 0 |
78 | #define WD2 1 |
79 | |
80 | #define zf_writew(port, data) { outb(port, INDEX); outw(data, DATA_W); } |
81 | #define zf_writeb(port, data) { outb(port, INDEX); outb(data, DATA_B); } |
82 | #define zf_get_ZFL_version() zf_readw(ZFL_VERSION) |
83 | |
84 | |
85 | static unsigned short zf_readw(unsigned char port) |
86 | { |
87 | outb(port, INDEX); |
88 | return inw(DATA_W); |
89 | } |
90 | |
91 | |
92 | MODULE_AUTHOR("Fernando Fuganti <fuganti@conectiva.com.br>"); |
93 | MODULE_DESCRIPTION("MachZ ZF-Logic Watchdog driver"); |
94 | MODULE_LICENSE("GPL"); |
95 | MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); |
96 | |
97 | static bool nowayout = WATCHDOG_NOWAYOUT; |
98 | module_param(nowayout, bool, 0); |
99 | MODULE_PARM_DESC(nowayout, |
100 | "Watchdog cannot be stopped once started (default=" |
101 | __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); |
102 | |
103 | #define PFX "machzwd" |
104 | |
105 | static const struct watchdog_info zf_info = { |
106 | .options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, |
107 | .firmware_version = 1, |
108 | .identity = "ZF-Logic watchdog", |
109 | }; |
110 | |
111 | |
112 | /* |
113 | * action refers to action taken when watchdog resets |
114 | * 0 = GEN_RESET |
115 | * 1 = GEN_SMI |
116 | * 2 = GEN_NMI |
117 | * 3 = GEN_SCI |
118 | * defaults to GEN_RESET (0) |
119 | */ |
120 | static int action; |
121 | module_param(action, int, 0); |
122 | MODULE_PARM_DESC(action, "after watchdog resets, generate: " |
123 | "0 = RESET(*) 1 = SMI 2 = NMI 3 = SCI"); |
124 | |
125 | static void zf_ping(unsigned long data); |
126 | |
127 | static int zf_action = GEN_RESET; |
128 | static unsigned long zf_is_open; |
129 | static char zf_expect_close; |
130 | static DEFINE_SPINLOCK(zf_port_lock); |
131 | static DEFINE_TIMER(zf_timer, zf_ping, 0, 0); |
132 | static unsigned long next_heartbeat; |
133 | |
134 | |
135 | /* timeout for user land heart beat (10 seconds) */ |
136 | #define ZF_USER_TIMEO (HZ*10) |
137 | |
138 | /* timeout for hardware watchdog (~500ms) */ |
139 | #define ZF_HW_TIMEO (HZ/2) |
140 | |
141 | /* number of ticks on WD#1 (driven by a 32KHz clock, 2s) */ |
142 | #define ZF_CTIMEOUT 0xffff |
143 | |
144 | #ifndef ZF_DEBUG |
145 | #define dprintk(format, args...) |
146 | #else |
147 | #define dprintk(format, args...) \ |
148 | pr_debug(":%s:%d: " format, __func__, __LINE__ , ## args) |
149 | #endif |
150 | |
151 | |
152 | static inline void zf_set_status(unsigned char new) |
153 | { |
154 | zf_writeb(STATUS, new); |
155 | } |
156 | |
157 | |
158 | /* CONTROL register functions */ |
159 | |
160 | static inline unsigned short zf_get_control(void) |
161 | { |
162 | return zf_readw(CONTROL); |
163 | } |
164 | |
165 | static inline void zf_set_control(unsigned short new) |
166 | { |
167 | zf_writew(CONTROL, new); |
168 | } |
169 | |
170 | |
171 | /* WD#? counter functions */ |
172 | /* |
173 | * Just set counter value |
174 | */ |
175 | |
176 | static inline void zf_set_timer(unsigned short new, unsigned char n) |
177 | { |
178 | switch (n) { |
179 | case WD1: |
180 | zf_writew(COUNTER_1, new); |
181 | case WD2: |
182 | zf_writeb(COUNTER_2, new > 0xff ? 0xff : new); |
183 | default: |
184 | return; |
185 | } |
186 | } |
187 | |
188 | /* |
189 | * stop hardware timer |
190 | */ |
191 | static void zf_timer_off(void) |
192 | { |
193 | unsigned int ctrl_reg = 0; |
194 | unsigned long flags; |
195 | |
196 | /* stop internal ping */ |
197 | del_timer_sync(&zf_timer); |
198 | |
199 | spin_lock_irqsave(&zf_port_lock, flags); |
200 | /* stop watchdog timer */ |
201 | ctrl_reg = zf_get_control(); |
202 | ctrl_reg |= (ENABLE_WD1|ENABLE_WD2); /* disable wd1 and wd2 */ |
203 | ctrl_reg &= ~(ENABLE_WD1|ENABLE_WD2); |
204 | zf_set_control(ctrl_reg); |
205 | spin_unlock_irqrestore(&zf_port_lock, flags); |
206 | |
207 | pr_info("Watchdog timer is now disabled\n"); |
208 | } |
209 | |
210 | |
211 | /* |
212 | * start hardware timer |
213 | */ |
214 | static void zf_timer_on(void) |
215 | { |
216 | unsigned int ctrl_reg = 0; |
217 | unsigned long flags; |
218 | |
219 | spin_lock_irqsave(&zf_port_lock, flags); |
220 | |
221 | zf_writeb(PULSE_LEN, 0xff); |
222 | |
223 | zf_set_timer(ZF_CTIMEOUT, WD1); |
224 | |
225 | /* user land ping */ |
226 | next_heartbeat = jiffies + ZF_USER_TIMEO; |
227 | |
228 | /* start the timer for internal ping */ |
229 | mod_timer(&zf_timer, jiffies + ZF_HW_TIMEO); |
230 | |
231 | /* start watchdog timer */ |
232 | ctrl_reg = zf_get_control(); |
233 | ctrl_reg |= (ENABLE_WD1|zf_action); |
234 | zf_set_control(ctrl_reg); |
235 | spin_unlock_irqrestore(&zf_port_lock, flags); |
236 | |
237 | pr_info("Watchdog timer is now enabled\n"); |
238 | } |
239 | |
240 | |
241 | static void zf_ping(unsigned long data) |
242 | { |
243 | unsigned int ctrl_reg = 0; |
244 | unsigned long flags; |
245 | |
246 | zf_writeb(COUNTER_2, 0xff); |
247 | |
248 | if (time_before(jiffies, next_heartbeat)) { |
249 | dprintk("time_before: %ld\n", next_heartbeat - jiffies); |
250 | /* |
251 | * reset event is activated by transition from 0 to 1 on |
252 | * RESET_WD1 bit and we assume that it is already zero... |
253 | */ |
254 | |
255 | spin_lock_irqsave(&zf_port_lock, flags); |
256 | ctrl_reg = zf_get_control(); |
257 | ctrl_reg |= RESET_WD1; |
258 | zf_set_control(ctrl_reg); |
259 | |
260 | /* ...and nothing changes until here */ |
261 | ctrl_reg &= ~(RESET_WD1); |
262 | zf_set_control(ctrl_reg); |
263 | spin_unlock_irqrestore(&zf_port_lock, flags); |
264 | |
265 | mod_timer(&zf_timer, jiffies + ZF_HW_TIMEO); |
266 | } else |
267 | pr_crit("I will reset your machine\n"); |
268 | } |
269 | |
270 | static ssize_t zf_write(struct file *file, const char __user *buf, size_t count, |
271 | loff_t *ppos) |
272 | { |
273 | /* See if we got the magic character */ |
274 | if (count) { |
275 | /* |
276 | * no need to check for close confirmation |
277 | * no way to disable watchdog ;) |
278 | */ |
279 | if (!nowayout) { |
280 | size_t ofs; |
281 | /* |
282 | * note: just in case someone wrote the magic character |
283 | * five months ago... |
284 | */ |
285 | zf_expect_close = 0; |
286 | |
287 | /* now scan */ |
288 | for (ofs = 0; ofs != count; ofs++) { |
289 | char c; |
290 | if (get_user(c, buf + ofs)) |
291 | return -EFAULT; |
292 | if (c == 'V') { |
293 | zf_expect_close = 42; |
294 | dprintk("zf_expect_close = 42\n"); |
295 | } |
296 | } |
297 | } |
298 | |
299 | /* |
300 | * Well, anyhow someone wrote to us, |
301 | * we should return that favour |
302 | */ |
303 | next_heartbeat = jiffies + ZF_USER_TIMEO; |
304 | dprintk("user ping at %ld\n", jiffies); |
305 | } |
306 | return count; |
307 | } |
308 | |
309 | static long zf_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
310 | { |
311 | void __user *argp = (void __user *)arg; |
312 | int __user *p = argp; |
313 | switch (cmd) { |
314 | case WDIOC_GETSUPPORT: |
315 | if (copy_to_user(argp, &zf_info, sizeof(zf_info))) |
316 | return -EFAULT; |
317 | break; |
318 | case WDIOC_GETSTATUS: |
319 | case WDIOC_GETBOOTSTATUS: |
320 | return put_user(0, p); |
321 | case WDIOC_KEEPALIVE: |
322 | zf_ping(0); |
323 | break; |
324 | default: |
325 | return -ENOTTY; |
326 | } |
327 | return 0; |
328 | } |
329 | |
330 | static int zf_open(struct inode *inode, struct file *file) |
331 | { |
332 | if (test_and_set_bit(0, &zf_is_open)) |
333 | return -EBUSY; |
334 | if (nowayout) |
335 | __module_get(THIS_MODULE); |
336 | zf_timer_on(); |
337 | return nonseekable_open(inode, file); |
338 | } |
339 | |
340 | static int zf_close(struct inode *inode, struct file *file) |
341 | { |
342 | if (zf_expect_close == 42) |
343 | zf_timer_off(); |
344 | else { |
345 | del_timer(&zf_timer); |
346 | pr_err("device file closed unexpectedly. Will not stop the WDT!\n"); |
347 | } |
348 | clear_bit(0, &zf_is_open); |
349 | zf_expect_close = 0; |
350 | return 0; |
351 | } |
352 | |
353 | /* |
354 | * Notifier for system down |
355 | */ |
356 | |
357 | static int zf_notify_sys(struct notifier_block *this, unsigned long code, |
358 | void *unused) |
359 | { |
360 | if (code == SYS_DOWN || code == SYS_HALT) |
361 | zf_timer_off(); |
362 | return NOTIFY_DONE; |
363 | } |
364 | |
365 | static const struct file_operations zf_fops = { |
366 | .owner = THIS_MODULE, |
367 | .llseek = no_llseek, |
368 | .write = zf_write, |
369 | .unlocked_ioctl = zf_ioctl, |
370 | .open = zf_open, |
371 | .release = zf_close, |
372 | }; |
373 | |
374 | static struct miscdevice zf_miscdev = { |
375 | .minor = WATCHDOG_MINOR, |
376 | .name = "watchdog", |
377 | .fops = &zf_fops, |
378 | }; |
379 | |
380 | |
381 | /* |
382 | * The device needs to learn about soft shutdowns in order to |
383 | * turn the timebomb registers off. |
384 | */ |
385 | static struct notifier_block zf_notifier = { |
386 | .notifier_call = zf_notify_sys, |
387 | }; |
388 | |
389 | static void __init zf_show_action(int act) |
390 | { |
391 | static const char * const str[] = { "RESET", "SMI", "NMI", "SCI" }; |
392 | |
393 | pr_info("Watchdog using action = %s\n", str[act]); |
394 | } |
395 | |
396 | static int __init zf_init(void) |
397 | { |
398 | int ret; |
399 | |
400 | pr_info("MachZ ZF-Logic Watchdog driver initializing\n"); |
401 | |
402 | ret = zf_get_ZFL_version(); |
403 | if (!ret || ret == 0xffff) { |
404 | pr_warn("no ZF-Logic found\n"); |
405 | return -ENODEV; |
406 | } |
407 | |
408 | if (action <= 3 && action >= 0) |
409 | zf_action = zf_action >> action; |
410 | else |
411 | action = 0; |
412 | |
413 | zf_show_action(action); |
414 | |
415 | if (!request_region(ZF_IOBASE, 3, "MachZ ZFL WDT")) { |
416 | pr_err("cannot reserve I/O ports at %d\n", ZF_IOBASE); |
417 | ret = -EBUSY; |
418 | goto no_region; |
419 | } |
420 | |
421 | ret = register_reboot_notifier(&zf_notifier); |
422 | if (ret) { |
423 | pr_err("can't register reboot notifier (err=%d)\n", ret); |
424 | goto no_reboot; |
425 | } |
426 | |
427 | ret = misc_register(&zf_miscdev); |
428 | if (ret) { |
429 | pr_err("can't misc_register on minor=%d\n", WATCHDOG_MINOR); |
430 | goto no_misc; |
431 | } |
432 | |
433 | zf_set_status(0); |
434 | zf_set_control(0); |
435 | |
436 | return 0; |
437 | |
438 | no_misc: |
439 | unregister_reboot_notifier(&zf_notifier); |
440 | no_reboot: |
441 | release_region(ZF_IOBASE, 3); |
442 | no_region: |
443 | return ret; |
444 | } |
445 | |
446 | |
447 | static void __exit zf_exit(void) |
448 | { |
449 | zf_timer_off(); |
450 | |
451 | misc_deregister(&zf_miscdev); |
452 | unregister_reboot_notifier(&zf_notifier); |
453 | release_region(ZF_IOBASE, 3); |
454 | } |
455 | |
456 | module_init(zf_init); |
457 | module_exit(zf_exit); |
458 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9