Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzi...
[linux-2.6] / drivers / sbus / char / riowatchdog.c
1 /* $Id: riowatchdog.c,v 1.3.2.2 2002/01/23 18:48:02 davem Exp $
2  * riowatchdog.c - driver for hw watchdog inside Super I/O of RIO
3  *
4  * Copyright (C) 2001 David S. Miller (davem@redhat.com)
5  */
6
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/types.h>
10 #include <linux/fs.h>
11 #include <linux/errno.h>
12 #include <linux/init.h>
13 #include <linux/miscdevice.h>
14 #include <linux/smp_lock.h>
15
16 #include <asm/io.h>
17 #include <asm/ebus.h>
18 #include <asm/bbc.h>
19 #include <asm/oplib.h>
20 #include <asm/uaccess.h>
21
22 #include <asm/watchdog.h>
23
24 /* RIO uses the NatSemi Super I/O power management logical device
25  * as its' watchdog.
26  *
27  * When the watchdog triggers, it asserts a line to the BBC (Boot Bus
28  * Controller) of the machine.  The BBC can only be configured to
29  * trigger a power-on reset when the signal is asserted.  The BBC
30  * can be configured to ignore the signal entirely as well.
31  *
32  * The only Super I/O device register we care about is at index
33  * 0x05 (WDTO_INDEX) which is the watchdog time-out in minutes (1-255).
34  * If set to zero, this disables the watchdog.  When set, the system
35  * must periodically (before watchdog expires) clear (set to zero) and
36  * re-set the watchdog else it will trigger.
37  *
38  * There are two other indexed watchdog registers inside this Super I/O
39  * logical device, but they are unused.  The first, at index 0x06 is
40  * the watchdog control and can be used to make the watchdog timer re-set
41  * when the PS/2 mouse or serial lines show activity.  The second, at
42  * index 0x07 is merely a sampling of the line from the watchdog to the
43  * BBC.
44  *
45  * The watchdog device generates no interrupts.
46  */
47
48 MODULE_AUTHOR("David S. Miller <davem@redhat.com>");
49 MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
50 MODULE_SUPPORTED_DEVICE("watchdog");
51 MODULE_LICENSE("GPL");
52
53 #define RIOWD_NAME      "pmc"
54 #define RIOWD_MINOR     215
55
56 static DEFINE_SPINLOCK(riowd_lock);
57
58 static void __iomem *bbc_regs;
59 static void __iomem *riowd_regs;
60 #define WDTO_INDEX      0x05
61
62 static int riowd_timeout = 1;           /* in minutes */
63 module_param(riowd_timeout, int, 0);
64 MODULE_PARM_DESC(riowd_timeout, "Watchdog timeout in minutes");
65
66 #if 0 /* Currently unused. */
67 static u8 riowd_readreg(int index)
68 {
69         unsigned long flags;
70         u8 ret;
71
72         spin_lock_irqsave(&riowd_lock, flags);
73         writeb(index, riowd_regs + 0);
74         ret = readb(riowd_regs + 1);
75         spin_unlock_irqrestore(&riowd_lock, flags);
76
77         return ret;
78 }
79 #endif
80
81 static void riowd_writereg(u8 val, int index)
82 {
83         unsigned long flags;
84
85         spin_lock_irqsave(&riowd_lock, flags);
86         writeb(index, riowd_regs + 0);
87         writeb(val, riowd_regs + 1);
88         spin_unlock_irqrestore(&riowd_lock, flags);
89 }
90
91 static void riowd_pingtimer(void)
92 {
93         riowd_writereg(riowd_timeout, WDTO_INDEX);
94 }
95
96 static void riowd_stoptimer(void)
97 {
98         u8 val;
99
100         riowd_writereg(0, WDTO_INDEX);
101
102         val = readb(bbc_regs + BBC_WDACTION);
103         val &= ~BBC_WDACTION_RST;
104         writeb(val, bbc_regs + BBC_WDACTION);
105 }
106
107 static void riowd_starttimer(void)
108 {
109         u8 val;
110
111         riowd_writereg(riowd_timeout, WDTO_INDEX);
112
113         val = readb(bbc_regs + BBC_WDACTION);
114         val |= BBC_WDACTION_RST;
115         writeb(val, bbc_regs + BBC_WDACTION);
116 }
117
118 static int riowd_open(struct inode *inode, struct file *filp)
119 {
120         cycle_kernel_lock();
121         nonseekable_open(inode, filp);
122         return 0;
123 }
124
125 static int riowd_release(struct inode *inode, struct file *filp)
126 {
127         return 0;
128 }
129
130 static int riowd_ioctl(struct inode *inode, struct file *filp,
131                        unsigned int cmd, unsigned long arg)
132 {
133         static struct watchdog_info info = {
134                 WDIOF_SETTIMEOUT, 0, "Natl. Semiconductor PC97317"
135         };
136         void __user *argp = (void __user *)arg;
137         unsigned int options;
138         int new_margin;
139
140         switch (cmd) {
141         case WDIOC_GETSUPPORT:
142                 if (copy_to_user(argp, &info, sizeof(info)))
143                         return -EFAULT;
144                 break;
145
146         case WDIOC_GETSTATUS:
147         case WDIOC_GETBOOTSTATUS:
148                 if (put_user(0, (int __user *)argp))
149                         return -EFAULT;
150                 break;
151
152         case WDIOC_KEEPALIVE:
153                 riowd_pingtimer();
154                 break;
155
156         case WDIOC_SETOPTIONS:
157                 if (copy_from_user(&options, argp, sizeof(options)))
158                         return -EFAULT;
159
160                 if (options & WDIOS_DISABLECARD)
161                         riowd_stoptimer();
162                 else if (options & WDIOS_ENABLECARD)
163                         riowd_starttimer();
164                 else
165                         return -EINVAL;
166
167                 break;
168
169         case WDIOC_SETTIMEOUT:
170                 if (get_user(new_margin, (int __user *)argp))
171                         return -EFAULT;
172                 if ((new_margin < 60) || (new_margin > (255 * 60)))
173                     return -EINVAL;
174                 riowd_timeout = (new_margin + 59) / 60;
175                 riowd_pingtimer();
176                 /* Fall */
177
178         case WDIOC_GETTIMEOUT:
179                 return put_user(riowd_timeout * 60, (int __user *)argp);
180
181         default:
182                 return -EINVAL;
183         };
184
185         return 0;
186 }
187
188 static ssize_t riowd_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
189 {
190         if (count) {
191                 riowd_pingtimer();
192                 return 1;
193         }
194
195         return 0;
196 }
197
198 static const struct file_operations riowd_fops = {
199         .owner =        THIS_MODULE,
200         .ioctl =        riowd_ioctl,
201         .open =         riowd_open,
202         .write =        riowd_write,
203         .release =      riowd_release,
204 };
205
206 static struct miscdevice riowd_miscdev = { RIOWD_MINOR, RIOWD_NAME, &riowd_fops };
207
208 static int __init riowd_bbc_init(void)
209 {
210         struct  linux_ebus *ebus = NULL;
211         struct  linux_ebus_device *edev = NULL;
212         u8 val;
213
214         for_each_ebus(ebus) {
215                 for_each_ebusdev(edev, ebus) {
216                         if (!strcmp(edev->ofdev.node->name, "bbc"))
217                                 goto found_bbc;
218                 }
219         }
220
221 found_bbc:
222         if (!edev)
223                 return -ENODEV;
224         bbc_regs = ioremap(edev->resource[0].start, BBC_REGS_SIZE);
225         if (!bbc_regs)
226                 return -ENODEV;
227
228         /* Turn it off. */
229         val = readb(bbc_regs + BBC_WDACTION);
230         val &= ~BBC_WDACTION_RST;
231         writeb(val, bbc_regs + BBC_WDACTION);
232
233         return 0;
234 }
235
236 static int __init riowd_init(void)
237 {
238         struct  linux_ebus *ebus = NULL;
239         struct  linux_ebus_device *edev = NULL;
240
241         for_each_ebus(ebus) {
242                 for_each_ebusdev(edev, ebus) {
243                         if (!strcmp(edev->ofdev.node->name, RIOWD_NAME))
244                                 goto ebus_done;
245                 }
246         }
247
248 ebus_done:
249         if (!edev)
250                 goto fail;
251
252         riowd_regs = ioremap(edev->resource[0].start, 2);
253         if (riowd_regs == NULL) {
254                 printk(KERN_ERR "pmc: Cannot map registers.\n");
255                 return -ENODEV;
256         }
257
258         if (riowd_bbc_init()) {
259                 printk(KERN_ERR "pmc: Failure initializing BBC config.\n");
260                 goto fail;
261         }
262
263         if (misc_register(&riowd_miscdev)) {
264                 printk(KERN_ERR "pmc: Cannot register watchdog misc device.\n");
265                 goto fail;
266         }
267
268         printk(KERN_INFO "pmc: Hardware watchdog [%i minutes], "
269                "regs at %p\n", riowd_timeout, riowd_regs);
270
271         return 0;
272
273 fail:
274         if (riowd_regs) {
275                 iounmap(riowd_regs);
276                 riowd_regs = NULL;
277         }
278         if (bbc_regs) {
279                 iounmap(bbc_regs);
280                 bbc_regs = NULL;
281         }
282         return -ENODEV;
283 }
284
285 static void __exit riowd_cleanup(void)
286 {
287         misc_deregister(&riowd_miscdev);
288         iounmap(riowd_regs);
289         riowd_regs = NULL;
290         iounmap(bbc_regs);
291         bbc_regs = NULL;
292 }
293
294 module_init(riowd_init);
295 module_exit(riowd_cleanup);