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 unsigned int options;
137 case WDIOC_GETSUPPORT:
138 if (copy_to_user((struct watchdog_info *) arg, &info, sizeof(info)))
142 case WDIOC_GETSTATUS:
143 case WDIOC_GETBOOTSTATUS:
144 if (put_user(0, (int *) arg))
148 case WDIOC_KEEPALIVE:
152 case WDIOC_SETOPTIONS:
153 if (copy_from_user(&options, (void *) arg, sizeof(options)))
156 if (options & WDIOS_DISABLECARD)
158 else if (options & WDIOS_ENABLECARD)
165 case WDIOC_SETTIMEOUT:
166 if (get_user(new_margin, (int *)arg))
168 if ((new_margin < 60) || (new_margin > (255 * 60)))
170 riowd_timeout = (new_margin + 59) / 60;
174 case WDIOC_GETTIMEOUT:
175 return put_user(riowd_timeout * 60, (int *)arg);
184 static ssize_t riowd_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
186 if (ppos != &file->f_pos)
197 static ssize_t riowd_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
202 static struct file_operations riowd_fops = {
208 release: riowd_release,
211 static struct miscdevice riowd_miscdev = { RIOWD_MINOR, RIOWD_NAME, &riowd_fops };
213 static int __init riowd_bbc_init(void)
215 struct linux_ebus *ebus = NULL;
216 struct linux_ebus_device *edev = NULL;
219 for_each_ebus(ebus) {
220 for_each_ebusdev(edev, ebus) {
221 if (!strcmp(edev->prom_name, "bbc"))
229 bbc_regs = ioremap(edev->resource[0].start, BBC_REGS_SIZE);
234 val = readb(bbc_regs + BBC_WDACTION);
235 val &= ~BBC_WDACTION_RST;
236 writeb(val, bbc_regs + BBC_WDACTION);
241 static int __init riowd_init(void)
243 struct linux_ebus *ebus = NULL;
244 struct linux_ebus_device *edev = NULL;
246 for_each_ebus(ebus) {
247 for_each_ebusdev(edev, ebus) {
248 if (!strcmp(edev->prom_name, RIOWD_NAME))
257 riowd_regs = ioremap(edev->resource[0].start, 2);
258 if (riowd_regs == NULL) {
259 printk(KERN_ERR "pmc: Cannot map registers.\n");
263 if (riowd_bbc_init()) {
264 printk(KERN_ERR "pmc: Failure initializing BBC config.\n");
268 if (misc_register(&riowd_miscdev)) {
269 printk(KERN_ERR "pmc: Cannot register watchdog misc device.\n");
273 printk(KERN_INFO "pmc: Hardware watchdog [%i minutes], "
274 "regs at %p\n", riowd_timeout, riowd_regs);
290 static void __exit riowd_cleanup(void)
292 misc_deregister(&riowd_miscdev);
299 module_init(riowd_init);
300 module_exit(riowd_cleanup);