1/* drivers/char/watchdog/scx200_wdt.c
2
3   National Semiconductor SCx200 Watchdog support
4
5   Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
6
7   Some code taken from:
8   National Semiconductor PC87307/PC97307 (ala SC1200) WDT driver
9   (c) Copyright 2002 Zwane Mwaikambo <zwane@commfireservices.com>
10
11   This program is free software; you can redistribute it and/or
12   modify it under the terms of the GNU General Public License as
13   published by the Free Software Foundation; either version 2 of the
14   License, or (at your option) any later version.
15
16   The author(s) of this software shall not be held liable for damages
17   of any nature resulting due to the use of this software. This
18   software is provided AS-IS with no warranties. */
19
20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
22#include <linux/module.h>
23#include <linux/moduleparam.h>
24#include <linux/init.h>
25#include <linux/miscdevice.h>
26#include <linux/watchdog.h>
27#include <linux/notifier.h>
28#include <linux/reboot.h>
29#include <linux/fs.h>
30#include <linux/ioport.h>
31#include <linux/scx200.h>
32#include <linux/uaccess.h>
33#include <linux/io.h>
34
35#define DEBUG
36
37MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
38MODULE_DESCRIPTION("NatSemi SCx200 Watchdog Driver");
39MODULE_LICENSE("GPL");
40
41static int margin = 60;		/* in seconds */
42module_param(margin, int, 0);
43MODULE_PARM_DESC(margin, "Watchdog margin in seconds");
44
45static bool nowayout = WATCHDOG_NOWAYOUT;
46module_param(nowayout, bool, 0);
47MODULE_PARM_DESC(nowayout, "Disable watchdog shutdown on close");
48
49static u16 wdto_restart;
50static char expect_close;
51static unsigned long open_lock;
52static DEFINE_SPINLOCK(scx_lock);
53
54/* Bits of the WDCNFG register */
55#define W_ENABLE 0x00fa		/* Enable watchdog */
56#define W_DISABLE 0x0000	/* Disable watchdog */
57
58/* The scaling factor for the timer, this depends on the value of W_ENABLE */
59#define W_SCALE (32768/1024)
60
61static void scx200_wdt_ping(void)
62{
63	spin_lock(&scx_lock);
64	outw(wdto_restart, scx200_cb_base + SCx200_WDT_WDTO);
65	spin_unlock(&scx_lock);
66}
67
68static void scx200_wdt_update_margin(void)
69{
70	pr_info("timer margin %d seconds\n", margin);
71	wdto_restart = margin * W_SCALE;
72}
73
74static void scx200_wdt_enable(void)
75{
76	pr_debug("enabling watchdog timer, wdto_restart = %d\n", wdto_restart);
77
78	spin_lock(&scx_lock);
79	outw(0, scx200_cb_base + SCx200_WDT_WDTO);
80	outb(SCx200_WDT_WDSTS_WDOVF, scx200_cb_base + SCx200_WDT_WDSTS);
81	outw(W_ENABLE, scx200_cb_base + SCx200_WDT_WDCNFG);
82	spin_unlock(&scx_lock);
83
84	scx200_wdt_ping();
85}
86
87static void scx200_wdt_disable(void)
88{
89	pr_debug("disabling watchdog timer\n");
90
91	spin_lock(&scx_lock);
92	outw(0, scx200_cb_base + SCx200_WDT_WDTO);
93	outb(SCx200_WDT_WDSTS_WDOVF, scx200_cb_base + SCx200_WDT_WDSTS);
94	outw(W_DISABLE, scx200_cb_base + SCx200_WDT_WDCNFG);
95	spin_unlock(&scx_lock);
96}
97
98static int scx200_wdt_open(struct inode *inode, struct file *file)
99{
100	/* only allow one at a time */
101	if (test_and_set_bit(0, &open_lock))
102		return -EBUSY;
103	scx200_wdt_enable();
104
105	return nonseekable_open(inode, file);
106}
107
108static int scx200_wdt_release(struct inode *inode, struct file *file)
109{
110	if (expect_close != 42)
111		pr_warn("watchdog device closed unexpectedly, will not disable the watchdog timer\n");
112	else if (!nowayout)
113		scx200_wdt_disable();
114	expect_close = 0;
115	clear_bit(0, &open_lock);
116
117	return 0;
118}
119
120static int scx200_wdt_notify_sys(struct notifier_block *this,
121				      unsigned long code, void *unused)
122{
123	if (code == SYS_HALT || code == SYS_POWER_OFF)
124		if (!nowayout)
125			scx200_wdt_disable();
126
127	return NOTIFY_DONE;
128}
129
130static struct notifier_block scx200_wdt_notifier = {
131	.notifier_call = scx200_wdt_notify_sys,
132};
133
134static ssize_t scx200_wdt_write(struct file *file, const char __user *data,
135				     size_t len, loff_t *ppos)
136{
137	/* check for a magic close character */
138	if (len) {
139		size_t i;
140
141		scx200_wdt_ping();
142
143		expect_close = 0;
144		for (i = 0; i < len; ++i) {
145			char c;
146			if (get_user(c, data + i))
147				return -EFAULT;
148			if (c == 'V')
149				expect_close = 42;
150		}
151
152		return len;
153	}
154
155	return 0;
156}
157
158static long scx200_wdt_ioctl(struct file *file, unsigned int cmd,
159							unsigned long arg)
160{
161	void __user *argp = (void __user *)arg;
162	int __user *p = argp;
163	static const struct watchdog_info ident = {
164		.identity = "NatSemi SCx200 Watchdog",
165		.firmware_version = 1,
166		.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
167						WDIOF_MAGICCLOSE,
168	};
169	int new_margin;
170
171	switch (cmd) {
172	case WDIOC_GETSUPPORT:
173		if (copy_to_user(argp, &ident, sizeof(ident)))
174			return -EFAULT;
175		return 0;
176	case WDIOC_GETSTATUS:
177	case WDIOC_GETBOOTSTATUS:
178		if (put_user(0, p))
179			return -EFAULT;
180		return 0;
181	case WDIOC_KEEPALIVE:
182		scx200_wdt_ping();
183		return 0;
184	case WDIOC_SETTIMEOUT:
185		if (get_user(new_margin, p))
186			return -EFAULT;
187		if (new_margin < 1)
188			return -EINVAL;
189		margin = new_margin;
190		scx200_wdt_update_margin();
191		scx200_wdt_ping();
192	case WDIOC_GETTIMEOUT:
193		if (put_user(margin, p))
194			return -EFAULT;
195		return 0;
196	default:
197		return -ENOTTY;
198	}
199}
200
201static const struct file_operations scx200_wdt_fops = {
202	.owner = THIS_MODULE,
203	.llseek = no_llseek,
204	.write = scx200_wdt_write,
205	.unlocked_ioctl = scx200_wdt_ioctl,
206	.open = scx200_wdt_open,
207	.release = scx200_wdt_release,
208};
209
210static struct miscdevice scx200_wdt_miscdev = {
211	.minor = WATCHDOG_MINOR,
212	.name = "watchdog",
213	.fops = &scx200_wdt_fops,
214};
215
216static int __init scx200_wdt_init(void)
217{
218	int r;
219
220	pr_debug("NatSemi SCx200 Watchdog Driver\n");
221
222	/* check that we have found the configuration block */
223	if (!scx200_cb_present())
224		return -ENODEV;
225
226	if (!request_region(scx200_cb_base + SCx200_WDT_OFFSET,
227			    SCx200_WDT_SIZE,
228			    "NatSemi SCx200 Watchdog")) {
229		pr_warn("watchdog I/O region busy\n");
230		return -EBUSY;
231	}
232
233	scx200_wdt_update_margin();
234	scx200_wdt_disable();
235
236	r = register_reboot_notifier(&scx200_wdt_notifier);
237	if (r) {
238		pr_err("unable to register reboot notifier\n");
239		release_region(scx200_cb_base + SCx200_WDT_OFFSET,
240				SCx200_WDT_SIZE);
241		return r;
242	}
243
244	r = misc_register(&scx200_wdt_miscdev);
245	if (r) {
246		unregister_reboot_notifier(&scx200_wdt_notifier);
247		release_region(scx200_cb_base + SCx200_WDT_OFFSET,
248				SCx200_WDT_SIZE);
249		return r;
250	}
251
252	return 0;
253}
254
255static void __exit scx200_wdt_cleanup(void)
256{
257	misc_deregister(&scx200_wdt_miscdev);
258	unregister_reboot_notifier(&scx200_wdt_notifier);
259	release_region(scx200_cb_base + SCx200_WDT_OFFSET,
260		       SCx200_WDT_SIZE);
261}
262
263module_init(scx200_wdt_init);
264module_exit(scx200_wdt_cleanup);
265
266/*
267    Local variables:
268	compile-command: "make -k -C ../.. SUBDIRS=drivers/char modules"
269	c-basic-offset: 8
270    End:
271*/
272