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