• Home
  • History
  • Annotate
  • Line#
  • Navigate
  • Raw
  • Download
  • only in /netgear-R7000-V1.0.7.12_1.2.5/components/opensource/linux/linux-2.6.36/drivers/watchdog/
1/* riowd.c - driver for hw watchdog inside Super I/O of RIO
2 *
3 * Copyright (C) 2001, 2008 David S. Miller (davem@davemloft.net)
4 */
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>
13#include <linux/watchdog.h>
14#include <linux/of.h>
15#include <linux/of_device.h>
16#include <linux/io.h>
17#include <linux/uaccess.h>
18#include <linux/slab.h>
19
20
21/* RIO uses the NatSemi Super I/O power management logical device
22 * as its' watchdog.
23 *
24 * When the watchdog triggers, it asserts a line to the BBC (Boot Bus
25 * Controller) of the machine.  The BBC can only be configured to
26 * trigger a power-on reset when the signal is asserted.  The BBC
27 * can be configured to ignore the signal entirely as well.
28 *
29 * The only Super I/O device register we care about is at index
30 * 0x05 (WDTO_INDEX) which is the watchdog time-out in minutes (1-255).
31 * If set to zero, this disables the watchdog.  When set, the system
32 * must periodically (before watchdog expires) clear (set to zero) and
33 * re-set the watchdog else it will trigger.
34 *
35 * There are two other indexed watchdog registers inside this Super I/O
36 * logical device, but they are unused.  The first, at index 0x06 is
37 * the watchdog control and can be used to make the watchdog timer re-set
38 * when the PS/2 mouse or serial lines show activity.  The second, at
39 * index 0x07 is merely a sampling of the line from the watchdog to the
40 * BBC.
41 *
42 * The watchdog device generates no interrupts.
43 */
44
45MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
46MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
47MODULE_SUPPORTED_DEVICE("watchdog");
48MODULE_LICENSE("GPL");
49
50#define DRIVER_NAME	"riowd"
51#define PFX		DRIVER_NAME ": "
52
53struct riowd {
54	void __iomem		*regs;
55	spinlock_t		lock;
56};
57
58static struct riowd *riowd_device;
59
60#define WDTO_INDEX	0x05
61
62static int riowd_timeout = 1;		/* in minutes */
63module_param(riowd_timeout, int, 0);
64MODULE_PARM_DESC(riowd_timeout, "Watchdog timeout in minutes");
65
66static void riowd_writereg(struct riowd *p, u8 val, int index)
67{
68	unsigned long flags;
69
70	spin_lock_irqsave(&p->lock, flags);
71	writeb(index, p->regs + 0);
72	writeb(val, p->regs + 1);
73	spin_unlock_irqrestore(&p->lock, flags);
74}
75
76static int riowd_open(struct inode *inode, struct file *filp)
77{
78	nonseekable_open(inode, filp);
79	return 0;
80}
81
82static int riowd_release(struct inode *inode, struct file *filp)
83{
84	return 0;
85}
86
87static long riowd_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
88{
89	static const struct watchdog_info info = {
90		.options		= WDIOF_SETTIMEOUT,
91		.firmware_version	= 1,
92		.identity		= DRIVER_NAME,
93	};
94	void __user *argp = (void __user *)arg;
95	struct riowd *p = riowd_device;
96	unsigned int options;
97	int new_margin;
98
99	switch (cmd) {
100	case WDIOC_GETSUPPORT:
101		if (copy_to_user(argp, &info, sizeof(info)))
102			return -EFAULT;
103		break;
104
105	case WDIOC_GETSTATUS:
106	case WDIOC_GETBOOTSTATUS:
107		if (put_user(0, (int __user *)argp))
108			return -EFAULT;
109		break;
110
111	case WDIOC_KEEPALIVE:
112		riowd_writereg(p, riowd_timeout, WDTO_INDEX);
113		break;
114
115	case WDIOC_SETOPTIONS:
116		if (copy_from_user(&options, argp, sizeof(options)))
117			return -EFAULT;
118
119		if (options & WDIOS_DISABLECARD)
120			riowd_writereg(p, 0, WDTO_INDEX);
121		else if (options & WDIOS_ENABLECARD)
122			riowd_writereg(p, riowd_timeout, WDTO_INDEX);
123		else
124			return -EINVAL;
125
126		break;
127
128	case WDIOC_SETTIMEOUT:
129		if (get_user(new_margin, (int __user *)argp))
130			return -EFAULT;
131		if ((new_margin < 60) || (new_margin > (255 * 60)))
132			return -EINVAL;
133		riowd_timeout = (new_margin + 59) / 60;
134		riowd_writereg(p, riowd_timeout, WDTO_INDEX);
135		/* Fall */
136
137	case WDIOC_GETTIMEOUT:
138		return put_user(riowd_timeout * 60, (int __user *)argp);
139
140	default:
141		return -EINVAL;
142	};
143
144	return 0;
145}
146
147static ssize_t riowd_write(struct file *file, const char __user *buf,
148						size_t count, loff_t *ppos)
149{
150	struct riowd *p = riowd_device;
151
152	if (count) {
153		riowd_writereg(p, riowd_timeout, WDTO_INDEX);
154		return 1;
155	}
156
157	return 0;
158}
159
160static const struct file_operations riowd_fops = {
161	.owner =		THIS_MODULE,
162	.llseek =		no_llseek,
163	.unlocked_ioctl =	riowd_ioctl,
164	.open =			riowd_open,
165	.write =		riowd_write,
166	.release =		riowd_release,
167};
168
169static struct miscdevice riowd_miscdev = {
170	.minor	= WATCHDOG_MINOR,
171	.name	= "watchdog",
172	.fops	= &riowd_fops
173};
174
175static int __devinit riowd_probe(struct platform_device *op,
176				 const struct of_device_id *match)
177{
178	struct riowd *p;
179	int err = -EINVAL;
180
181	if (riowd_device)
182		goto out;
183
184	err = -ENOMEM;
185	p = kzalloc(sizeof(*p), GFP_KERNEL);
186	if (!p)
187		goto out;
188
189	spin_lock_init(&p->lock);
190
191	p->regs = of_ioremap(&op->resource[0], 0, 2, DRIVER_NAME);
192	if (!p->regs) {
193		printk(KERN_ERR PFX "Cannot map registers.\n");
194		goto out_free;
195	}
196	/* Make miscdev useable right away */
197	riowd_device = p;
198
199	err = misc_register(&riowd_miscdev);
200	if (err) {
201		printk(KERN_ERR PFX "Cannot register watchdog misc device.\n");
202		goto out_iounmap;
203	}
204
205	printk(KERN_INFO PFX "Hardware watchdog [%i minutes], "
206	       "regs at %p\n", riowd_timeout, p->regs);
207
208	dev_set_drvdata(&op->dev, p);
209	return 0;
210
211out_iounmap:
212	riowd_device = NULL;
213	of_iounmap(&op->resource[0], p->regs, 2);
214
215out_free:
216	kfree(p);
217
218out:
219	return err;
220}
221
222static int __devexit riowd_remove(struct platform_device *op)
223{
224	struct riowd *p = dev_get_drvdata(&op->dev);
225
226	misc_deregister(&riowd_miscdev);
227	of_iounmap(&op->resource[0], p->regs, 2);
228	kfree(p);
229
230	return 0;
231}
232
233static const struct of_device_id riowd_match[] = {
234	{
235		.name = "pmc",
236	},
237	{},
238};
239MODULE_DEVICE_TABLE(of, riowd_match);
240
241static struct of_platform_driver riowd_driver = {
242	.driver = {
243		.name = DRIVER_NAME,
244		.owner = THIS_MODULE,
245		.of_match_table = riowd_match,
246	},
247	.probe		= riowd_probe,
248	.remove		= __devexit_p(riowd_remove),
249};
250
251static int __init riowd_init(void)
252{
253	return of_register_platform_driver(&riowd_driver);
254}
255
256static void __exit riowd_exit(void)
257{
258	of_unregister_platform_driver(&riowd_driver);
259}
260
261module_init(riowd_init);
262module_exit(riowd_exit);
263