Merge to Fedora Core 2 kernel-2.6.8-1.521
[linux-2.6.git] / drivers / char / watchdog / sc1200wdt.c
1 /*
2  *      National Semiconductor PC87307/PC97307 (ala SC1200) WDT driver
3  *      (c) Copyright 2002 Zwane Mwaikambo <zwane@commfireservices.com>,
4  *                      All Rights Reserved.
5  *      Based on wdt.c and wdt977.c by Alan Cox and Woody Suwalski respectively.
6  *
7  *      This program is free software; you can redistribute it and/or
8  *      modify it under the terms of the GNU General Public License
9  *      as published by the Free Software Foundation; either version
10  *      2 of the License, or (at your option) any later version.
11  *
12  *      The author(s) of this software shall not be held liable for damages
13  *      of any nature resulting due to the use of this software. This
14  *      software is provided AS-IS with no warranties.
15  *
16  *      Changelog:
17  *      20020220 Zwane Mwaikambo        Code based on datasheet, no hardware.
18  *      20020221 Zwane Mwaikambo        Cleanups as suggested by Jeff Garzik and Alan Cox.
19  *      20020222 Zwane Mwaikambo        Added probing.
20  *      20020225 Zwane Mwaikambo        Added ISAPNP support.
21  *      20020412 Rob Radez              Broke out start/stop functions
22  *               <rob@osinvestor.com>   Return proper status instead of temperature warning
23  *                                      Add WDIOC_GETBOOTSTATUS and WDIOC_SETOPTIONS ioctls
24  *                                      Fix CONFIG_WATCHDOG_NOWAYOUT
25  *      20020530 Joel Becker            Add Matt Domsch's nowayout module option
26  *      20030116 Adam Belay             Updated to the latest pnp code
27  *
28  */
29
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <linux/moduleparam.h>
33 #include <linux/miscdevice.h>
34 #include <linux/watchdog.h>
35 #include <linux/ioport.h>
36 #include <linux/spinlock.h>
37 #include <linux/notifier.h>
38 #include <linux/reboot.h>
39 #include <linux/init.h>
40 #include <linux/pnp.h>
41 #include <linux/fs.h>
42 #include <linux/pci.h>
43
44 #include <asm/semaphore.h>
45 #include <asm/io.h>
46 #include <asm/uaccess.h>
47
48 #define SC1200_MODULE_VER       "build 20020303"
49 #define SC1200_MODULE_NAME      "sc1200wdt"
50 #define PFX                     SC1200_MODULE_NAME ": "
51
52 #define MAX_TIMEOUT     255     /* 255 minutes */
53 #define PMIR            (io)    /* Power Management Index Register */
54 #define PMDR            (io+1)  /* Power Management Data Register */
55
56 /* Data Register indexes */
57 #define FER1            0x00    /* Function enable register 1 */
58 #define FER2            0x01    /* Function enable register 2 */
59 #define PMC1            0x02    /* Power Management Ctrl 1 */
60 #define PMC2            0x03    /* Power Management Ctrl 2 */
61 #define PMC3            0x04    /* Power Management Ctrl 3 */
62 #define WDTO            0x05    /* Watchdog timeout register */
63 #define WDCF            0x06    /* Watchdog config register */
64 #define WDST            0x07    /* Watchdog status register */
65
66 /* WDCF bitfields - which devices assert WDO */
67 #define KBC_IRQ         0x01    /* Keyboard Controller */
68 #define MSE_IRQ         0x02    /* Mouse */
69 #define UART1_IRQ       0x03    /* Serial0 */
70 #define UART2_IRQ       0x04    /* Serial1 */
71 /* 5 -7 are reserved */
72
73 static char banner[] __initdata = KERN_INFO PFX SC1200_MODULE_VER;
74 static int timeout = 1;
75 static int io = -1;
76 static int io_len = 2;          /* for non plug and play */
77 struct semaphore open_sem;
78 static char expect_close;
79 spinlock_t sc1200wdt_lock;      /* io port access serialisation */
80
81 #if defined CONFIG_PNP
82 static int isapnp = 1;
83 static struct pnp_dev *wdt_dev;
84
85 module_param(isapnp, int, 0);
86 MODULE_PARM_DESC(isapnp, "When set to 0 driver ISA PnP support will be disabled");
87 #endif
88
89 module_param(io, int, 0);
90 MODULE_PARM_DESC(io, "io port");
91 module_param(timeout, int, 0);
92 MODULE_PARM_DESC(timeout, "range is 0-255 minutes, default is 1");
93
94 #ifdef CONFIG_WATCHDOG_NOWAYOUT
95 static int nowayout = 1;
96 #else
97 static int nowayout = 0;
98 #endif
99
100 module_param(nowayout, int, 0);
101 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
102
103
104
105 /* Read from Data Register */
106 static inline void sc1200wdt_read_data(unsigned char index, unsigned char *data)
107 {
108         spin_lock(&sc1200wdt_lock);
109         outb_p(index, PMIR);
110         *data = inb(PMDR);
111         spin_unlock(&sc1200wdt_lock);
112 }
113
114
115 /* Write to Data Register */
116 static inline void sc1200wdt_write_data(unsigned char index, unsigned char data)
117 {
118         spin_lock(&sc1200wdt_lock);
119         outb_p(index, PMIR);
120         outb(data, PMDR);
121         spin_unlock(&sc1200wdt_lock);
122 }
123
124
125 static void sc1200wdt_start(void)
126 {
127         unsigned char reg;
128
129         sc1200wdt_read_data(WDCF, &reg);
130         /* assert WDO when any of the following interrupts are triggered too */
131         reg |= (KBC_IRQ | MSE_IRQ | UART1_IRQ | UART2_IRQ);
132         sc1200wdt_write_data(WDCF, reg);
133         /* set the timeout and get the ball rolling */
134         sc1200wdt_write_data(WDTO, timeout);
135 }
136
137
138 static void sc1200wdt_stop(void)
139 {
140         sc1200wdt_write_data(WDTO, 0);
141 }
142
143
144 /* This returns the status of the WDO signal, inactive high. */
145 static inline int sc1200wdt_status(void)
146 {
147         unsigned char ret;
148
149         sc1200wdt_read_data(WDST, &ret);
150         /* If the bit is inactive, the watchdog is enabled, so return
151          * KEEPALIVEPING which is a bit of a kludge because there's nothing
152          * else for enabled/disabled status
153          */
154         return (ret & 0x01) ? 0 : WDIOF_KEEPALIVEPING;  /* bits 1 - 7 are undefined */
155 }
156
157
158 static int sc1200wdt_open(struct inode *inode, struct file *file)
159 {
160         nonseekable_open(inode, file);
161
162         /* allow one at a time */
163         if (down_trylock(&open_sem))
164                 return -EBUSY;
165
166         if (timeout > MAX_TIMEOUT)
167                 timeout = MAX_TIMEOUT;
168
169         sc1200wdt_start();
170         printk(KERN_INFO PFX "Watchdog enabled, timeout = %d min(s)", timeout);
171
172         return 0;
173 }
174
175
176 static int sc1200wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
177 {
178         int new_timeout;
179         void __user *argp = (void __user *)arg;
180         int __user *p = argp;
181         static struct watchdog_info ident = {
182                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
183                 .firmware_version = 0,
184                 .identity = "PC87307/PC97307",
185         };
186
187         switch (cmd) {
188                 default:
189                         return -ENOIOCTLCMD;    /* Keep Pavel Machek amused ;) */
190
191                 case WDIOC_GETSUPPORT:
192                         if (copy_to_user(argp, &ident, sizeof ident))
193                                 return -EFAULT;
194                         return 0;
195
196                 case WDIOC_GETSTATUS:
197                         return put_user(sc1200wdt_status(), p);
198
199                 case WDIOC_GETBOOTSTATUS:
200                         return put_user(0, p);
201
202                 case WDIOC_KEEPALIVE:
203                         sc1200wdt_write_data(WDTO, timeout);
204                         return 0;
205
206                 case WDIOC_SETTIMEOUT:
207                         if (get_user(new_timeout, p))
208                                 return -EFAULT;
209
210                         /* the API states this is given in secs */
211                         new_timeout /= 60;
212                         if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
213                                 return -EINVAL;
214
215                         timeout = new_timeout;
216                         sc1200wdt_write_data(WDTO, timeout);
217                         /* fall through and return the new timeout */
218
219                 case WDIOC_GETTIMEOUT:
220                         return put_user(timeout * 60, p);
221
222                 case WDIOC_SETOPTIONS:
223                 {
224                         int options, retval = -EINVAL;
225
226                         if (get_user(options, p))
227                                 return -EFAULT;
228
229                         if (options & WDIOS_DISABLECARD) {
230                                 sc1200wdt_stop();
231                                 retval = 0;
232                         }
233
234                         if (options & WDIOS_ENABLECARD) {
235                                 sc1200wdt_start();
236                                 retval = 0;
237                         }
238
239                         return retval;
240                 }
241         }
242 }
243
244
245 static int sc1200wdt_release(struct inode *inode, struct file *file)
246 {
247         if (expect_close == 42) {
248                 sc1200wdt_stop();
249                 printk(KERN_INFO PFX "Watchdog disabled\n");
250         } else {
251                 sc1200wdt_write_data(WDTO, timeout);
252                 printk(KERN_CRIT PFX "Unexpected close!, timeout = %d min(s)\n", timeout);
253         }
254         up(&open_sem);
255         expect_close = 0;
256
257         return 0;
258 }
259
260
261 static ssize_t sc1200wdt_write(struct file *file, const char __user *data, size_t len, loff_t *ppos)
262 {
263         if (len) {
264                 if (!nowayout) {
265                         size_t i;
266
267                         expect_close = 0;
268
269                         for (i = 0; i != len; i++) {
270                                 char c;
271
272                                 if (get_user(c, data+i))
273                                         return -EFAULT;
274                                 if (c == 'V')
275                                         expect_close = 42;
276                         }
277                 }
278
279                 sc1200wdt_write_data(WDTO, timeout);
280                 return len;
281         }
282
283         return 0;
284 }
285
286
287 static int sc1200wdt_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
288 {
289         if (code == SYS_DOWN || code == SYS_HALT)
290                 sc1200wdt_stop();
291
292         return NOTIFY_DONE;
293 }
294
295
296 static struct notifier_block sc1200wdt_notifier =
297 {
298         .notifier_call =        sc1200wdt_notify_sys,
299 };
300
301 static struct file_operations sc1200wdt_fops =
302 {
303         .owner          = THIS_MODULE,
304         .write          = sc1200wdt_write,
305         .ioctl          = sc1200wdt_ioctl,
306         .open           = sc1200wdt_open,
307         .release        = sc1200wdt_release,
308 };
309
310 static struct miscdevice sc1200wdt_miscdev =
311 {
312         .minor          = WATCHDOG_MINOR,
313         .name           = "watchdog",
314         .fops           = &sc1200wdt_fops,
315 };
316
317
318 static int __init sc1200wdt_probe(void)
319 {
320         /* The probe works by reading the PMC3 register's default value of 0x0e
321          * there is one caveat, if the device disables the parallel port or any
322          * of the UARTs we won't be able to detect it.
323          * Nb. This could be done with accuracy by reading the SID registers, but
324          * we don't have access to those io regions.
325          */
326
327         unsigned char reg;
328
329         sc1200wdt_read_data(PMC3, &reg);
330         reg &= 0x0f;                            /* we don't want the UART busy bits */
331         return (reg == 0x0e) ? 0 : -ENODEV;
332 }
333
334
335 #if defined CONFIG_PNP
336
337 struct pnp_device_id scl200wdt_pnp_devices[] = {
338         /* National Semiconductor PC87307/PC97307 watchdog component */
339         {.id = "NSC0800", .driver_data = 0},
340         {.id = ""},
341 };
342
343 static int scl200wdt_pnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id)
344 {
345         /* this driver only supports one card at a time */
346         if (wdt_dev || !isapnp)
347                 return -EBUSY;
348
349         wdt_dev = dev;
350         io = pnp_port_start(wdt_dev, 0);
351         io_len = pnp_port_len(wdt_dev, 0);
352
353         if (!request_region(io, io_len, SC1200_MODULE_NAME)) {
354                 printk(KERN_ERR PFX "Unable to register IO port %#x\n", io);
355                 return -EBUSY;
356         }
357
358         printk(KERN_INFO "scl200wdt: PnP device found at io port %#x/%d\n", io, io_len);
359         return 0;
360 }
361
362 static void scl200wdt_pnp_remove(struct pnp_dev * dev)
363 {
364         if (wdt_dev){
365                 release_region(io, io_len);
366                 wdt_dev = NULL;
367         }
368 }
369
370 static struct pnp_driver scl200wdt_pnp_driver = {
371         .name           = "scl200wdt",
372         .id_table       = scl200wdt_pnp_devices,
373         .probe          = scl200wdt_pnp_probe,
374         .remove         = scl200wdt_pnp_remove,
375 };
376
377 #endif /* CONFIG_PNP */
378
379
380 static int __init sc1200wdt_init(void)
381 {
382         int ret;
383
384         printk(banner);
385
386         spin_lock_init(&sc1200wdt_lock);
387         sema_init(&open_sem, 1);
388
389 #if defined CONFIG_PNP
390         if (isapnp) {
391                 ret = pnp_register_driver(&scl200wdt_pnp_driver);
392                 if (ret)
393                         goto out_clean;
394         }
395 #endif
396
397         if (io == -1) {
398                 printk(KERN_ERR PFX "io parameter must be specified\n");
399                 ret = -EINVAL;
400                 goto out_clean;
401         }
402
403 #if defined CONFIG_PNP
404         /* now that the user has specified an IO port and we haven't detected
405          * any devices, disable pnp support */
406         isapnp = 0;
407         pnp_unregister_driver(&scl200wdt_pnp_driver);
408 #endif
409
410         if (!request_region(io, io_len, SC1200_MODULE_NAME)) {
411                 printk(KERN_ERR PFX "Unable to register IO port %#x\n", io);
412                 ret = -EBUSY;
413                 goto out_clean;
414         }
415
416         ret = sc1200wdt_probe();
417         if (ret)
418                 goto out_io;
419
420         ret = register_reboot_notifier(&sc1200wdt_notifier);
421         if (ret) {
422                 printk(KERN_ERR PFX "Unable to register reboot notifier err = %d\n", ret);
423                 goto out_io;
424         }
425
426         ret = misc_register(&sc1200wdt_miscdev);
427         if (ret) {
428                 printk(KERN_ERR PFX "Unable to register miscdev on minor %d\n", WATCHDOG_MINOR);
429                 goto out_rbt;
430         }
431
432         /* ret = 0 */
433
434 out_clean:
435         return ret;
436
437 out_rbt:
438         unregister_reboot_notifier(&sc1200wdt_notifier);
439
440 out_io:
441         release_region(io, io_len);
442
443         goto out_clean;
444 }
445
446
447 static void __exit sc1200wdt_exit(void)
448 {
449         misc_deregister(&sc1200wdt_miscdev);
450         unregister_reboot_notifier(&sc1200wdt_notifier);
451
452 #if defined CONFIG_PNP
453         if(isapnp)
454                 pnp_unregister_driver(&scl200wdt_pnp_driver);
455         else
456 #endif
457         release_region(io, io_len);
458 }
459
460 module_init(sc1200wdt_init);
461 module_exit(sc1200wdt_exit);
462
463 MODULE_AUTHOR("Zwane Mwaikambo <zwane@commfireservices.com>");
464 MODULE_DESCRIPTION("Driver for National Semiconductor PC87307/PC97307 watchdog component");
465 MODULE_LICENSE("GPL");
466 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);