blob: 49e1b1c2135cdde2c00bfd37978c02d8ce62cfd1 [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
Joe Perches27c766a2012-02-15 15:06:19 -08006#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/kernel.h>
9#include <linux/module.h>
10#include <linux/types.h>
11#include <linux/fs.h>
12#include <linux/errno.h>
13#include <linux/init.h>
14#include <linux/miscdevice.h>
David S. Millere42311d2008-08-29 15:35:59 -070015#include <linux/watchdog.h>
16#include <linux/of.h>
17#include <linux/of_device.h>
Wim Van Sebroeck278aefc2009-03-18 09:09:26 +000018#include <linux/io.h>
19#include <linux/uaccess.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23/* RIO uses the NatSemi Super I/O power management logical device
24 * as its' watchdog.
25 *
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.
30 *
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.
36 *
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
42 * BBC.
43 *
44 * The watchdog device generates no interrupts.
45 */
46
David S. Millere42311d2008-08-29 15:35:59 -070047MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
Linus Torvalds1da177e2005-04-16 15:20:36 -070048MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
49MODULE_SUPPORTED_DEVICE("watchdog");
50MODULE_LICENSE("GPL");
51
David S. Millere25ecd02008-08-29 15:42:31 -070052#define DRIVER_NAME "riowd"
53#define PFX DRIVER_NAME ": "
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
David S. Millere42311d2008-08-29 15:35:59 -070055struct riowd {
56 void __iomem *regs;
57 spinlock_t lock;
58};
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
David S. Millere42311d2008-08-29 15:35:59 -070060static struct riowd *riowd_device;
61
Linus Torvalds1da177e2005-04-16 15:20:36 -070062#define WDTO_INDEX 0x05
63
64static int riowd_timeout = 1; /* in minutes */
65module_param(riowd_timeout, int, 0);
66MODULE_PARM_DESC(riowd_timeout, "Watchdog timeout in minutes");
67
David S. Millere42311d2008-08-29 15:35:59 -070068static void riowd_writereg(struct riowd *p, u8 val, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069{
70 unsigned long flags;
71
David S. Millere42311d2008-08-29 15:35:59 -070072 spin_lock_irqsave(&p->lock, flags);
73 writeb(index, p->regs + 0);
74 writeb(val, p->regs + 1);
75 spin_unlock_irqrestore(&p->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076}
77
78static int riowd_open(struct inode *inode, struct file *filp)
79{
80 nonseekable_open(inode, filp);
81 return 0;
82}
83
84static int riowd_release(struct inode *inode, struct file *filp)
85{
86 return 0;
87}
88
Wim Van Sebroeck9626dd72009-01-21 11:13:11 +000089static long riowd_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090{
Wim Van Sebroeck42747d72009-12-26 18:55:22 +000091 static const struct watchdog_info info = {
David S. Millere42311d2008-08-29 15:35:59 -070092 .options = WDIOF_SETTIMEOUT,
93 .firmware_version = 1,
David S. Millere25ecd02008-08-29 15:42:31 -070094 .identity = DRIVER_NAME,
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 };
96 void __user *argp = (void __user *)arg;
David S. Millere42311d2008-08-29 15:35:59 -070097 struct riowd *p = riowd_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 unsigned int options;
99 int new_margin;
100
101 switch (cmd) {
102 case WDIOC_GETSUPPORT:
103 if (copy_to_user(argp, &info, sizeof(info)))
104 return -EFAULT;
105 break;
106
107 case WDIOC_GETSTATUS:
108 case WDIOC_GETBOOTSTATUS:
109 if (put_user(0, (int __user *)argp))
110 return -EFAULT;
111 break;
112
113 case WDIOC_KEEPALIVE:
David S. Millere42311d2008-08-29 15:35:59 -0700114 riowd_writereg(p, riowd_timeout, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 break;
116
117 case WDIOC_SETOPTIONS:
118 if (copy_from_user(&options, argp, sizeof(options)))
119 return -EFAULT;
120
121 if (options & WDIOS_DISABLECARD)
David S. Millere42311d2008-08-29 15:35:59 -0700122 riowd_writereg(p, 0, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 else if (options & WDIOS_ENABLECARD)
David S. Millere42311d2008-08-29 15:35:59 -0700124 riowd_writereg(p, riowd_timeout, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 else
126 return -EINVAL;
127
128 break;
129
130 case WDIOC_SETTIMEOUT:
131 if (get_user(new_margin, (int __user *)argp))
132 return -EFAULT;
133 if ((new_margin < 60) || (new_margin > (255 * 60)))
David S. Millere42311d2008-08-29 15:35:59 -0700134 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 riowd_timeout = (new_margin + 59) / 60;
David S. Millere42311d2008-08-29 15:35:59 -0700136 riowd_writereg(p, riowd_timeout, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 /* Fall */
138
139 case WDIOC_GETTIMEOUT:
140 return put_user(riowd_timeout * 60, (int __user *)argp);
141
142 default:
143 return -EINVAL;
144 };
145
146 return 0;
147}
148
Wim Van Sebroeck143a2e52009-03-18 08:35:09 +0000149static ssize_t riowd_write(struct file *file, const char __user *buf,
150 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
David S. Millere42311d2008-08-29 15:35:59 -0700152 struct riowd *p = riowd_device;
153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 if (count) {
David S. Millere42311d2008-08-29 15:35:59 -0700155 riowd_writereg(p, riowd_timeout, WDTO_INDEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 return 1;
157 }
158
159 return 0;
160}
161
Arjan van de Ven00977a52007-02-12 00:55:34 -0800162static const struct file_operations riowd_fops = {
Wim Van Sebroeck9626dd72009-01-21 11:13:11 +0000163 .owner = THIS_MODULE,
164 .llseek = no_llseek,
165 .unlocked_ioctl = riowd_ioctl,
166 .open = riowd_open,
167 .write = riowd_write,
168 .release = riowd_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169};
170
David S. Millere42311d2008-08-29 15:35:59 -0700171static struct miscdevice riowd_miscdev = {
172 .minor = WATCHDOG_MINOR,
173 .name = "watchdog",
174 .fops = &riowd_fops
175};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
Grant Likely1c48a5c2011-02-17 02:43:24 -0700177static int __devinit riowd_probe(struct platform_device *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
David S. Millere42311d2008-08-29 15:35:59 -0700179 struct riowd *p;
180 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
David S. Millere42311d2008-08-29 15:35:59 -0700182 if (riowd_device)
183 goto out;
184
185 err = -ENOMEM;
186 p = kzalloc(sizeof(*p), GFP_KERNEL);
187 if (!p)
188 goto out;
189
190 spin_lock_init(&p->lock);
191
David S. Millere25ecd02008-08-29 15:42:31 -0700192 p->regs = of_ioremap(&op->resource[0], 0, 2, DRIVER_NAME);
David S. Millere42311d2008-08-29 15:35:59 -0700193 if (!p->regs) {
Joe Perches27c766a2012-02-15 15:06:19 -0800194 pr_err("Cannot map registers\n");
David S. Millere42311d2008-08-29 15:35:59 -0700195 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 }
Thomas Gleixner462265b2009-11-02 21:16:28 -0800197 /* Make miscdev useable right away */
198 riowd_device = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
David S. Millere42311d2008-08-29 15:35:59 -0700200 err = misc_register(&riowd_miscdev);
201 if (err) {
Joe Perches27c766a2012-02-15 15:06:19 -0800202 pr_err("Cannot register watchdog misc device\n");
David S. Millere42311d2008-08-29 15:35:59 -0700203 goto out_iounmap;
204 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Joe Perches27c766a2012-02-15 15:06:19 -0800206 pr_info("Hardware watchdog [%i minutes], regs at %p\n",
207 riowd_timeout, p->regs);
David S. Millere42311d2008-08-29 15:35:59 -0700208
209 dev_set_drvdata(&op->dev, p);
Thomas Gleixner03717e32009-10-14 01:18:26 -0700210 return 0;
David S. Millere42311d2008-08-29 15:35:59 -0700211
212out_iounmap:
Thomas Gleixner462265b2009-11-02 21:16:28 -0800213 riowd_device = NULL;
David S. Millere42311d2008-08-29 15:35:59 -0700214 of_iounmap(&op->resource[0], p->regs, 2);
215
216out_free:
217 kfree(p);
218
219out:
220 return err;
221}
222
Grant Likely2dc11582010-08-06 09:25:50 -0600223static int __devexit riowd_remove(struct platform_device *op)
David S. Millere42311d2008-08-29 15:35:59 -0700224{
225 struct riowd *p = dev_get_drvdata(&op->dev);
226
227 misc_deregister(&riowd_miscdev);
228 of_iounmap(&op->resource[0], p->regs, 2);
229 kfree(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
231 return 0;
232}
233
David S. Millerfd098312008-08-31 01:23:17 -0700234static const struct of_device_id riowd_match[] = {
David S. Millere42311d2008-08-29 15:35:59 -0700235 {
236 .name = "pmc",
237 },
238 {},
239};
240MODULE_DEVICE_TABLE(of, riowd_match);
241
Grant Likely1c48a5c2011-02-17 02:43:24 -0700242static struct platform_driver riowd_driver = {
Grant Likely40182942010-04-13 16:13:02 -0700243 .driver = {
244 .name = DRIVER_NAME,
245 .owner = THIS_MODULE,
246 .of_match_table = riowd_match,
247 },
David S. Millere42311d2008-08-29 15:35:59 -0700248 .probe = riowd_probe,
249 .remove = __devexit_p(riowd_remove),
250};
251
Axel Linb8ec6112011-11-29 13:56:27 +0800252module_platform_driver(riowd_driver);