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
4 * Copyright (C) 2001 David S. Miller (davem@redhat.com)
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/types.h>
11 #include <linux/errno.h>
12 #include <linux/init.h>
13 #include <linux/miscdevice.h>
18 #include <asm/oplib.h>
19 #include <asm/uaccess.h>
21 #include <asm/watchdog.h>
23 /* RIO uses the NatSemi Super I/O power management logical device
26 * When the watchdog triggers, it asserts a line to the BBC (Boot Bus
27 * Controller) of the machine. The BBC can only be configured to
28 * trigger a power-on reset when the signal is asserted. The BBC
29 * can be configured to ignore the signal entirely as well.
31 * The only Super I/O device register we care about is at index
32 * 0x05 (WDTO_INDEX) which is the watchdog time-out in minutes (1-255).
33 * If set to zero, this disables the watchdog. When set, the system
34 * must periodically (before watchdog expires) clear (set to zero) and
35 * re-set the watchdog else it will trigger.
37 * There are two other indexed watchdog registers inside this Super I/O
38 * logical device, but they are unused. The first, at index 0x06 is
39 * the watchdog control and can be used to make the watchdog timer re-set
40 * when the PS/2 mouse or serial lines show activity. The second, at
41 * index 0x07 is merely a sampling of the line from the watchdog to the
44 * The watchdog device generates no interrupts.
47 MODULE_AUTHOR("David S. Miller <davem@redhat.com>");
48 MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
49 MODULE_SUPPORTED_DEVICE("watchdog");
50 MODULE_LICENSE("GPL");
52 #define RIOWD_NAME "pmc"
53 #define RIOWD_MINOR 215
55 static spinlock_t riowd_lock = SPIN_LOCK_UNLOCKED;
57 static void *bbc_regs;
58 static void *riowd_regs;
59 #define WDTO_INDEX 0x05
61 static int riowd_timeout = 1; /* in minutes */
62 MODULE_PARM(riowd_timeout,"i");
63 MODULE_PARM_DESC(riowd_timeout, "Watchdog timeout in minutes");
65 #if 0 /* Currently unused. */
66 static u8 riowd_readreg(int index)
71 spin_lock_irqsave(&riowd_lock, flags);
72 writeb(index, riowd_regs + 0);
73 ret = readb(riowd_regs + 1);
74 spin_unlock_irqrestore(&riowd_lock, flags);
80 static void riowd_writereg(u8 val, int index)
84 spin_lock_irqsave(&riowd_lock, flags);
85 writeb(index, riowd_regs + 0);
86 writeb(val, riowd_regs + 1);
87 spin_unlock_irqrestore(&riowd_lock, flags);
90 static void riowd_pingtimer(void)
92 riowd_writereg(riowd_timeout, WDTO_INDEX);
95 static void riowd_stoptimer(void)
99 riowd_writereg(0, WDTO_INDEX);
101 val = readb(bbc_regs + BBC_WDACTION);
102 val &= ~BBC_WDACTION_RST;
103 writeb(val, bbc_regs + BBC_WDACTION);
106 static void riowd_starttimer(void)
110 riowd_writereg(riowd_timeout, WDTO_INDEX);
112 val = readb(bbc_regs + BBC_WDACTION);
113 val |= BBC_WDACTION_RST;
114 writeb(val, bbc_regs + BBC_WDACTION);
117 static int riowd_open(struct inode *inode, struct file *filp)
122 static int riowd_release(struct inode *inode, struct file *filp)
127 static int riowd_ioctl(struct inode *inode, struct file *filp,
128 unsigned int cmd, unsigned long arg)
130 static struct watchdog_info info = {
131 WDIOF_SETTIMEOUT, 0, "Natl. Semiconductor PC97317"
133 void __user *argp = (void __user *)arg;
134 unsigned int options;
138 case WDIOC_GETSUPPORT:
139 if (copy_to_user(argp, &info, sizeof(info)))
143 case WDIOC_GETSTATUS:
144 case WDIOC_GETBOOTSTATUS:
145 if (put_user(0, (int __user *)argp))
149 case WDIOC_KEEPALIVE:
153 case WDIOC_SETOPTIONS:
154 if (copy_from_user(&options, argp, sizeof(options)))
157 if (options & WDIOS_DISABLECARD)
159 else if (options & WDIOS_ENABLECARD)
166 case WDIOC_SETTIMEOUT:
167 if (get_user(new_margin, (int __user *)argp))
169 if ((new_margin < 60) || (new_margin > (255 * 60)))
171 riowd_timeout = (new_margin + 59) / 60;
175 case WDIOC_GETTIMEOUT:
176 return put_user(riowd_timeout * 60, (int __user *)argp);
185 static ssize_t riowd_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
187 if (ppos != &file->f_pos)
198 static struct file_operations riowd_fops = {
199 .owner = THIS_MODULE,
200 .ioctl = riowd_ioctl,
202 .write = riowd_write,
203 .release = riowd_release,
206 static struct miscdevice riowd_miscdev = { RIOWD_MINOR, RIOWD_NAME, &riowd_fops };
208 static int __init riowd_bbc_init(void)
210 struct linux_ebus *ebus = NULL;
211 struct linux_ebus_device *edev = NULL;
214 for_each_ebus(ebus) {
215 for_each_ebusdev(edev, ebus) {
216 if (!strcmp(edev->prom_name, "bbc"))
224 bbc_regs = ioremap(edev->resource[0].start, BBC_REGS_SIZE);
229 val = readb(bbc_regs + BBC_WDACTION);
230 val &= ~BBC_WDACTION_RST;
231 writeb(val, bbc_regs + BBC_WDACTION);
236 static int __init riowd_init(void)
238 struct linux_ebus *ebus = NULL;
239 struct linux_ebus_device *edev = NULL;
241 for_each_ebus(ebus) {
242 for_each_ebusdev(edev, ebus) {
243 if (!strcmp(edev->prom_name, RIOWD_NAME))
252 riowd_regs = ioremap(edev->resource[0].start, 2);
253 if (riowd_regs == NULL) {
254 printk(KERN_ERR "pmc: Cannot map registers.\n");
258 if (riowd_bbc_init()) {
259 printk(KERN_ERR "pmc: Failure initializing BBC config.\n");
263 if (misc_register(&riowd_miscdev)) {
264 printk(KERN_ERR "pmc: Cannot register watchdog misc device.\n");
268 printk(KERN_INFO "pmc: Hardware watchdog [%i minutes], "
269 "regs at %p\n", riowd_timeout, riowd_regs);
285 static void __exit riowd_cleanup(void)
287 misc_deregister(&riowd_miscdev);
294 module_init(riowd_init);
295 module_exit(riowd_cleanup);