blob: c14ae867690356de79612e308b75512d2432becc [file] [log] [blame]
David S. Miller957183f2008-08-29 15:40:24 -07001/* riowd.c - driver for hw watchdog inside Super I/O of RIO
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
David S. Millere42311d2008-08-29 15:35:59 -07003 * Copyright (C) 2001, 2008 David S. Miller (davem@davemloft.net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 */
5
6#include <linux/kernel.h>
7#include <linux/module.h>
8#include <linux/types.h>
9#include <linux/fs.h>
10#include <linux/errno.h>
11#include <linux/init.h>
12#include <linux/miscdevice.h>
David S. Millere42311d2008-08-29 15:35:59 -070013#include <linux/watchdog.h>
14#include <linux/of.h>
15#include <linux/of_device.h>
Wim Van Sebroeck278aefc2009-03-18 09:09:26 +000016#include <linux/io.h>
17#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
20/* RIO uses the NatSemi Super I/O power management logical device
21 * as its' watchdog.
22 *
23 * When the watchdog triggers, it asserts a line to the BBC (Boot Bus
24 * Controller) of the machine. The BBC can only be configured to
25 * trigger a power-on reset when the signal is asserted. The BBC
26 * can be configured to ignore the signal entirely as well.
27 *
28 * The only Super I/O device register we care about is at index
29 * 0x05 (WDTO_INDEX) which is the watchdog time-out in minutes (1-255).
30 * If set to zero, this disables the watchdog. When set, the system
31 * must periodically (before watchdog expires) clear (set to zero) and
32 * re-set the watchdog else it will trigger.
33 *
34 * There are two other indexed watchdog registers inside this Super I/O
35 * logical device, but they are unused. The first, at index 0x06 is
36 * the watchdog control and can be used to make the watchdog timer re-set
37 * when the PS/2 mouse or serial lines show activity. The second, at
38 * index 0x07 is merely a sampling of the line from the watchdog to the
39 * BBC.
40 *
41 * The watchdog device generates no interrupts.
42 */
43
David S. Millere42311d2008-08-29 15:35:59 -070044MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
Linus Torvalds1da177e2005-04-16 15:20:36 -070045MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
46MODULE_SUPPORTED_DEVICE("watchdog");
47MODULE_LICENSE("GPL");
48
David S. Millere25ecd02008-08-29 15:42:31 -070049#define DRIVER_NAME "riowd"
50#define PFX DRIVER_NAME ": "
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
David S. Millere42311d2008-08-29 15:35:59 -070052struct riowd {
53 void __iomem *regs;
54 spinlock_t lock;
55};
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
David S. Millere42311d2008-08-29 15:35:59 -070057static struct riowd *riowd_device;
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#define WDTO_INDEX 0x05
60
61static int riowd_timeout = 1; /* in minutes */
62module_param(riowd_timeout, int, 0);
63MODULE_PARM_DESC(riowd_timeout, "Watchdog timeout in minutes");
64
David S. Millere42311d2008-08-29 15:35:59 -070065static void riowd_writereg(struct riowd *p, u8 val, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
67 unsigned long flags;
68
David S. Millere42311d2008-08-29 15:35:59 -070069 spin_lock_irqsave(&p->lock, flags);
70 writeb(index, p->regs + 0);
71 writeb(val, p->regs + 1);
72 spin_unlock_irqrestore(&p->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073}
74
75static int riowd_open(struct inode *inode, struct file *filp)
76{
77 nonseekable_open(inode, filp);
78 return 0;
79}
80
81static int riowd_release(struct inode *inode, struct file *filp)
82{
83 return 0;
84}
85
Wim Van Sebroeck9626dd72009-01-21 11:13:11 +000086static long riowd_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
88 static struct watchdog_info info = {
David S. Millere42311d2008-08-29 15:35:59 -070089 .options = WDIOF_SETTIMEOUT,
90 .firmware_version = 1,
David S. Millere25ecd02008-08-29 15:42:31 -070091 .identity = DRIVER_NAME,
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 };
93 void __user *argp = (void __user *)arg;
David S. Millere42311d2008-08-29 15:35:59 -070094 struct riowd *p = riowd_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 unsigned int options;
96 int new_margin;
97
98 switch (cmd) {
99 case WDIOC_GETSUPPORT:
100 if (copy_to_user(argp, &info, sizeof(info)))
101 return -EFAULT;
102 break;
103
104 case WDIOC_GETSTATUS:
105 case WDIOC_GETBOOTSTATUS:
106 if (put_user(0, (int __user *)argp))
107 return -EFAULT;
108 break;
109
110 case WDIOC_KEEPALIVE:
David S. Millere42311d2008-08-29 15:35:59 -0700111 riowd_writereg(p, riowd_timeout, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 break;
113
114 case WDIOC_SETOPTIONS:
115 if (copy_from_user(&options, argp, sizeof(options)))
116 return -EFAULT;
117
118 if (options & WDIOS_DISABLECARD)
David S. Millere42311d2008-08-29 15:35:59 -0700119 riowd_writereg(p, 0, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 else if (options & WDIOS_ENABLECARD)
David S. Millere42311d2008-08-29 15:35:59 -0700121 riowd_writereg(p, riowd_timeout, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 else
123 return -EINVAL;
124
125 break;
126
127 case WDIOC_SETTIMEOUT:
128 if (get_user(new_margin, (int __user *)argp))
129 return -EFAULT;
130 if ((new_margin < 60) || (new_margin > (255 * 60)))
David S. Millere42311d2008-08-29 15:35:59 -0700131 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 riowd_timeout = (new_margin + 59) / 60;
David S. Millere42311d2008-08-29 15:35:59 -0700133 riowd_writereg(p, riowd_timeout, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 /* Fall */
135
136 case WDIOC_GETTIMEOUT:
137 return put_user(riowd_timeout * 60, (int __user *)argp);
138
139 default:
140 return -EINVAL;
141 };
142
143 return 0;
144}
145
Wim Van Sebroeck143a2e52009-03-18 08:35:09 +0000146static ssize_t riowd_write(struct file *file, const char __user *buf,
147 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148{
David S. Millere42311d2008-08-29 15:35:59 -0700149 struct riowd *p = riowd_device;
150
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 if (count) {
David S. Millere42311d2008-08-29 15:35:59 -0700152 riowd_writereg(p, riowd_timeout, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 return 1;
154 }
155
156 return 0;
157}
158
Arjan van de Ven00977a52007-02-12 00:55:34 -0800159static const struct file_operations riowd_fops = {
Wim Van Sebroeck9626dd72009-01-21 11:13:11 +0000160 .owner = THIS_MODULE,
161 .llseek = no_llseek,
162 .unlocked_ioctl = riowd_ioctl,
163 .open = riowd_open,
164 .write = riowd_write,
165 .release = riowd_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166};
167
David S. Millere42311d2008-08-29 15:35:59 -0700168static struct miscdevice riowd_miscdev = {
169 .minor = WATCHDOG_MINOR,
170 .name = "watchdog",
171 .fops = &riowd_fops
172};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
David S. Millere42311d2008-08-29 15:35:59 -0700174static int __devinit riowd_probe(struct of_device *op,
175 const struct of_device_id *match)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176{
David S. Millere42311d2008-08-29 15:35:59 -0700177 struct riowd *p;
178 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
David S. Millere42311d2008-08-29 15:35:59 -0700180 if (riowd_device)
181 goto out;
182
183 err = -ENOMEM;
184 p = kzalloc(sizeof(*p), GFP_KERNEL);
185 if (!p)
186 goto out;
187
188 spin_lock_init(&p->lock);
189
David S. Millere25ecd02008-08-29 15:42:31 -0700190 p->regs = of_ioremap(&op->resource[0], 0, 2, DRIVER_NAME);
David S. Millere42311d2008-08-29 15:35:59 -0700191 if (!p->regs) {
192 printk(KERN_ERR PFX "Cannot map registers.\n");
193 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 }
Thomas Gleixner462265b2009-11-02 21:16:28 -0800195 /* Make miscdev useable right away */
196 riowd_device = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
David S. Millere42311d2008-08-29 15:35:59 -0700198 err = misc_register(&riowd_miscdev);
199 if (err) {
200 printk(KERN_ERR PFX "Cannot register watchdog misc device.\n");
201 goto out_iounmap;
202 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
David S. Millere42311d2008-08-29 15:35:59 -0700204 printk(KERN_INFO PFX "Hardware watchdog [%i minutes], "
205 "regs at %p\n", riowd_timeout, p->regs);
206
207 dev_set_drvdata(&op->dev, p);
Thomas Gleixner03717e32009-10-14 01:18:26 -0700208 return 0;
David S. Millere42311d2008-08-29 15:35:59 -0700209
210out_iounmap:
Thomas Gleixner462265b2009-11-02 21:16:28 -0800211 riowd_device = NULL;
David S. Millere42311d2008-08-29 15:35:59 -0700212 of_iounmap(&op->resource[0], p->regs, 2);
213
214out_free:
215 kfree(p);
216
217out:
218 return err;
219}
220
221static int __devexit riowd_remove(struct of_device *op)
222{
223 struct riowd *p = dev_get_drvdata(&op->dev);
224
225 misc_deregister(&riowd_miscdev);
226 of_iounmap(&op->resource[0], p->regs, 2);
227 kfree(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
229 return 0;
230}
231
David S. Millerfd098312008-08-31 01:23:17 -0700232static const struct of_device_id riowd_match[] = {
David S. Millere42311d2008-08-29 15:35:59 -0700233 {
234 .name = "pmc",
235 },
236 {},
237};
238MODULE_DEVICE_TABLE(of, riowd_match);
239
240static struct of_platform_driver riowd_driver = {
David S. Millere25ecd02008-08-29 15:42:31 -0700241 .name = DRIVER_NAME,
David S. Millere42311d2008-08-29 15:35:59 -0700242 .match_table = riowd_match,
243 .probe = riowd_probe,
244 .remove = __devexit_p(riowd_remove),
245};
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247static int __init riowd_init(void)
248{
David S. Millere42311d2008-08-29 15:35:59 -0700249 return of_register_driver(&riowd_driver, &of_bus_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250}
251
David S. Millere42311d2008-08-29 15:35:59 -0700252static void __exit riowd_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
David S. Millere42311d2008-08-29 15:35:59 -0700254 of_unregister_driver(&riowd_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255}
256
257module_init(riowd_init);
David S. Millere42311d2008-08-29 15:35:59 -0700258module_exit(riowd_exit);