[mirror_ubuntu-artful-kernel.git] / drivers / watchdog / scx200_wdt.c

/* drivers/char/watchdog/scx200_wdt.c

   National Semiconductor SCx200 Watchdog support

   Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>

   Some code taken from:
   National Semiconductor PC87307/PC97307 (ala SC1200) WDT driver
   (c) Copyright 2002 Zwane Mwaikambo <zwane@commfireservices.com>

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The author(s) of this software shall not be held liable for damages
   of any nature resulting due to the use of this software. This
   software is provided AS-IS with no warranties. */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/miscdevice.h>
#include <linux/watchdog.h>
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/fs.h>
#include <linux/ioport.h>
#include <linux/scx200.h>
#include <linux/uaccess.h>
#include <linux/io.h>

#define DEBUG

MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
MODULE_DESCRIPTION("NatSemi SCx200 Watchdog Driver");
MODULE_LICENSE("GPL");

static int margin = 60;		/* in seconds */
module_param(margin, int, 0);
MODULE_PARM_DESC(margin, "Watchdog margin in seconds");

static bool nowayout = WATCHDOG_NOWAYOUT;
module_param(nowayout, bool, 0);
MODULE_PARM_DESC(nowayout, "Disable watchdog shutdown on close");

static u16 wdto_restart;
static char expect_close;
static unsigned long open_lock;
static DEFINE_SPINLOCK(scx_lock);

/* Bits of the WDCNFG register */
#define W_ENABLE 0x00fa		/* Enable watchdog */
#define W_DISABLE 0x0000	/* Disable watchdog */

/* The scaling factor for the timer, this depends on the value of W_ENABLE */
#define W_SCALE (32768/1024)

static void scx200_wdt_ping(void)
{
	spin_lock(&scx_lock);
	outw(wdto_restart, scx200_cb_base + SCx200_WDT_WDTO);
	spin_unlock(&scx_lock);
}

static void scx200_wdt_update_margin(void)
{
	pr_info("timer margin %d seconds\n", margin);
	wdto_restart = margin * W_SCALE;
}

static void scx200_wdt_enable(void)
{
	pr_debug("enabling watchdog timer, wdto_restart = %d\n", wdto_restart);

	spin_lock(&scx_lock);
	outw(0, scx200_cb_base + SCx200_WDT_WDTO);
	outb(SCx200_WDT_WDSTS_WDOVF, scx200_cb_base + SCx200_WDT_WDSTS);
	outw(W_ENABLE, scx200_cb_base + SCx200_WDT_WDCNFG);
	spin_unlock(&scx_lock);

	scx200_wdt_ping();
}

static void scx200_wdt_disable(void)
{
	pr_debug("disabling watchdog timer\n");

	spin_lock(&scx_lock);
	outw(0, scx200_cb_base + SCx200_WDT_WDTO);
	outb(SCx200_WDT_WDSTS_WDOVF, scx200_cb_base + SCx200_WDT_WDSTS);
	outw(W_DISABLE, scx200_cb_base + SCx200_WDT_WDCNFG);
	spin_unlock(&scx_lock);
}

static int scx200_wdt_open(struct inode *inode, struct file *file)
{
	/* only allow one at a time */
	if (test_and_set_bit(0, &open_lock))
		return -EBUSY;
	scx200_wdt_enable();

	return nonseekable_open(inode, file);
}

static int scx200_wdt_release(struct inode *inode, struct file *file)
{
	if (expect_close != 42)
		pr_warn("watchdog device closed unexpectedly, will not disable the watchdog timer\n");
	else if (!nowayout)
		scx200_wdt_disable();
	expect_close = 0;
	clear_bit(0, &open_lock);

	return 0;
}

static int scx200_wdt_notify_sys(struct notifier_block *this,
				      unsigned long code, void *unused)
{
	if (code == SYS_HALT || code == SYS_POWER_OFF)
		if (!nowayout)
			scx200_wdt_disable();

	return NOTIFY_DONE;
}

static struct notifier_block scx200_wdt_notifier = {
	.notifier_call = scx200_wdt_notify_sys,
};

static ssize_t scx200_wdt_write(struct file *file, const char __user *data,
				     size_t len, loff_t *ppos)
{
	/* check for a magic close character */
	if (len) {
		size_t i;

		scx200_wdt_ping();

		expect_close = 0;
		for (i = 0; i < len; ++i) {
			char c;
			if (get_user(c, data + i))
				return -EFAULT;
			if (c == 'V')
				expect_close = 42;
		}

		return len;
	}

	return 0;
}

static long scx200_wdt_ioctl(struct file *file, unsigned int cmd,
							unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	int __user *p = argp;
	static const struct watchdog_info ident = {
		.identity = "NatSemi SCx200 Watchdog",
		.firmware_version = 1,
		.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
						WDIOF_MAGICCLOSE,
	};
	int new_margin;

	switch (cmd) {
	case WDIOC_GETSUPPORT:
		if (copy_to_user(argp, &ident, sizeof(ident)))
			return -EFAULT;
		return 0;
	case WDIOC_GETSTATUS:
	case WDIOC_GETBOOTSTATUS:
		if (put_user(0, p))
			return -EFAULT;
		return 0;
	case WDIOC_KEEPALIVE:
		scx200_wdt_ping();
		return 0;
	case WDIOC_SETTIMEOUT:
		if (get_user(new_margin, p))
			return -EFAULT;
		if (new_margin < 1)
			return -EINVAL;
		margin = new_margin;
		scx200_wdt_update_margin();
		scx200_wdt_ping();
	case WDIOC_GETTIMEOUT:
		if (put_user(margin, p))
			return -EFAULT;
		return 0;
	default:
		return -ENOTTY;
	}
}

static const struct file_operations scx200_wdt_fops = {
	.owner = THIS_MODULE,
	.llseek = no_llseek,
	.write = scx200_wdt_write,
	.unlocked_ioctl = scx200_wdt_ioctl,
	.open = scx200_wdt_open,
	.release = scx200_wdt_release,
};

static struct miscdevice scx200_wdt_miscdev = {
	.minor = WATCHDOG_MINOR,
	.name = "watchdog",
	.fops = &scx200_wdt_fops,
};

static int __init scx200_wdt_init(void)
{
	int r;

	pr_debug("NatSemi SCx200 Watchdog Driver\n");

	/* check that we have found the configuration block */
	if (!scx200_cb_present())
		return -ENODEV;

	if (!request_region(scx200_cb_base + SCx200_WDT_OFFSET,
			    SCx200_WDT_SIZE,
			    "NatSemi SCx200 Watchdog")) {
		pr_warn("watchdog I/O region busy\n");
		return -EBUSY;
	}

	scx200_wdt_update_margin();
	scx200_wdt_disable();

	r = register_reboot_notifier(&scx200_wdt_notifier);
	if (r) {
		pr_err("unable to register reboot notifier\n");
		release_region(scx200_cb_base + SCx200_WDT_OFFSET,
				SCx200_WDT_SIZE);
		return r;
	}

	r = misc_register(&scx200_wdt_miscdev);
	if (r) {
		unregister_reboot_notifier(&scx200_wdt_notifier);
		release_region(scx200_cb_base + SCx200_WDT_OFFSET,
				SCx200_WDT_SIZE);
		return r;
	}

	return 0;
}

static void __exit scx200_wdt_cleanup(void)
{
	misc_deregister(&scx200_wdt_miscdev);
	unregister_reboot_notifier(&scx200_wdt_notifier);
	release_region(scx200_cb_base + SCx200_WDT_OFFSET,
		       SCx200_WDT_SIZE);
}

module_init(scx200_wdt_init);
module_exit(scx200_wdt_cleanup);

/*
    Local variables:
	compile-command: "make -k -C ../.. SUBDIRS=drivers/char modules"
	c-basic-offset: 8
    End:
*/
Commit	Line	Data
1da177e4 LT	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
27c766aa JP	20	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27c766aa JP	21
1da177e4 LT	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>
6473d160	30	#include <linux/ioport.h>
1da177e4	31	#include <linux/scx200.h>
9b748ed0 AC	32	#include <linux/uaccess.h>
9b748ed0 AC	33	#include <linux/io.h>
1da177e4	34
27c766aa	35	#define DEBUG
1da177e4 LT	36
	37	MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
	38	MODULE_DESCRIPTION("NatSemi SCx200 Watchdog Driver");
	39	MODULE_LICENSE("GPL");
1da177e4	40
1da177e4 LT	41	static int margin = 60; /* in seconds */
	42	module_param(margin, int, 0);
	43	MODULE_PARM_DESC(margin, "Watchdog margin in seconds");
	44
86a1e189 WVS	45	static bool nowayout = WATCHDOG_NOWAYOUT;
86a1e189 WVS	46	module_param(nowayout, bool, 0);
1da177e4 LT	47	MODULE_PARM_DESC(nowayout, "Disable watchdog shutdown on close");
	48
	49	static u16 wdto_restart;
1da177e4	50	static char expect_close;
9b748ed0 AC	51	static unsigned long open_lock;
9b748ed0 AC	52	static DEFINE_SPINLOCK(scx_lock);
1da177e4 LT	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
	61	static void scx200_wdt_ping(void)
	62	{
9b748ed0	63	spin_lock(&scx_lock);
1da177e4	64	outw(wdto_restart, scx200_cb_base + SCx200_WDT_WDTO);
9b748ed0	65	spin_unlock(&scx_lock);
1da177e4 LT	66	}
	67
	68	static void scx200_wdt_update_margin(void)
	69	{
27c766aa	70	pr_info("timer margin %d seconds\n", margin);
1da177e4 LT	71	wdto_restart = margin * W_SCALE;
	72	}
	73
	74	static void scx200_wdt_enable(void)
	75	{
27c766aa	76	pr_debug("enabling watchdog timer, wdto_restart = %d\n", wdto_restart);
1da177e4	77
9b748ed0	78	spin_lock(&scx_lock);
1da177e4 LT	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);
9b748ed0	82	spin_unlock(&scx_lock);
1da177e4 LT	83
	84	scx200_wdt_ping();
	85	}
	86
	87	static void scx200_wdt_disable(void)
	88	{
27c766aa	89	pr_debug("disabling watchdog timer\n");
1da177e4	90
9b748ed0	91	spin_lock(&scx_lock);
1da177e4 LT	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);
9b748ed0	95	spin_unlock(&scx_lock);
1da177e4 LT	96	}
	97
	98	static int scx200_wdt_open(struct inode inode, struct file file)
	99	{
	100	/* only allow one at a time */
9b748ed0	101	if (test_and_set_bit(0, &open_lock))
1da177e4 LT	102	return -EBUSY;
	103	scx200_wdt_enable();
	104
	105	return nonseekable_open(inode, file);
	106	}
	107
	108	static int scx200_wdt_release(struct inode inode, struct file file)
	109	{
9b748ed0	110	if (expect_close != 42)
27c766aa	111	pr_warn("watchdog device closed unexpectedly, will not disable the watchdog timer\n");
9b748ed0	112	else if (!nowayout)
1da177e4	113	scx200_wdt_disable();
1da177e4	114	expect_close = 0;
9b748ed0	115	clear_bit(0, &open_lock);
1da177e4 LT	116
	117	return 0;
	118	}
	119
	120	static 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
9b748ed0	130	static struct notifier_block scx200_wdt_notifier = {
1da177e4 LT	131	.notifier_call = scx200_wdt_notify_sys,
	132	};
	133
	134	static 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 */
9b748ed0	138	if (len) {
1da177e4 LT	139	size_t i;
	140
	141	scx200_wdt_ping();
	142
	143	expect_close = 0;
	144	for (i = 0; i < len; ++i) {
	145	char c;
7944d3a5	146	if (get_user(c, data + i))
1da177e4 LT	147	return -EFAULT;
	148	if (c == 'V')
	149	expect_close = 42;
	150	}
	151
	152	return len;
	153	}
	154
	155	return 0;
	156	}
	157
9b748ed0 AC	158	static long scx200_wdt_ioctl(struct file *file, unsigned int cmd,
9b748ed0 AC	159	unsigned long arg)
1da177e4 LT	160	{
	161	void __user argp = (void __user )arg;
	162	int __user *p = argp;
9b748ed0	163	static const struct watchdog_info ident = {
1da177e4 LT	164	.identity = "NatSemi SCx200 Watchdog",
1da177e4 LT	165	.firmware_version = 1,
e73a7802 WVS	166	.options = WDIOF_SETTIMEOUT \| WDIOF_KEEPALIVEPING \|
e73a7802 WVS	167	WDIOF_MAGICCLOSE,
1da177e4 LT	168	};
	169	int new_margin;
	170
	171	switch (cmd) {
1da177e4	172	case WDIOC_GETSUPPORT:
9b748ed0	173	if (copy_to_user(argp, &ident, sizeof(ident)))
1da177e4 LT	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;
0c06090c WVS	196	default:
0c06090c WVS	197	return -ENOTTY;
1da177e4 LT	198	}
	199	}
	200
62322d25	201	static const struct file_operations scx200_wdt_fops = {
9b748ed0 AC	202	.owner = THIS_MODULE,
	203	.llseek = no_llseek,
	204	.write = scx200_wdt_write,
	205	.unlocked_ioctl = scx200_wdt_ioctl,
	206	.open = scx200_wdt_open,
1da177e4 LT	207	.release = scx200_wdt_release,
	208	};
	209
	210	static struct miscdevice scx200_wdt_miscdev = {
	211	.minor = WATCHDOG_MINOR,
9b748ed0 AC	212	.name = "watchdog",
9b748ed0 AC	213	.fops = &scx200_wdt_fops,
1da177e4 LT	214	};
	215
	216	static int __init scx200_wdt_init(void)
	217	{
	218	int r;
	219
27c766aa	220	pr_debug("NatSemi SCx200 Watchdog Driver\n");
1da177e4 LT	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")) {
27c766aa	229	pr_warn("watchdog I/O region busy\n");
1da177e4 LT	230	return -EBUSY;
	231	}
	232
	233	scx200_wdt_update_margin();
	234	scx200_wdt_disable();
	235
c6cb13ae	236	r = register_reboot_notifier(&scx200_wdt_notifier);
1da177e4	237	if (r) {
27c766aa	238	pr_err("unable to register reboot notifier\n");
1da177e4 LT	239	release_region(scx200_cb_base + SCx200_WDT_OFFSET,
	240	SCx200_WDT_SIZE);
	241	return r;
	242	}
	243
c6cb13ae	244	r = misc_register(&scx200_wdt_miscdev);
1da177e4	245	if (r) {
c6cb13ae	246	unregister_reboot_notifier(&scx200_wdt_notifier);
1da177e4 LT	247	release_region(scx200_cb_base + SCx200_WDT_OFFSET,
	248	SCx200_WDT_SIZE);
	249	return r;
	250	}
	251
	252	return 0;
	253	}
	254
	255	static void __exit scx200_wdt_cleanup(void)
	256	{
1da177e4	257	misc_deregister(&scx200_wdt_miscdev);
c6cb13ae	258	unregister_reboot_notifier(&scx200_wdt_notifier);
1da177e4 LT	259	release_region(scx200_cb_base + SCx200_WDT_OFFSET,
	260	SCx200_WDT_SIZE);
	261	}
	262
	263	module_init(scx200_wdt_init);
	264	module_exit(scx200_wdt_cleanup);
	265
	266	/*
	267	Local variables:
9b748ed0 AC	268	compile-command: "make -k -C ../.. SUBDIRS=drivers/char modules"
9b748ed0 AC	269	c-basic-offset: 8
1da177e4 LT	270	End:
1da177e4 LT	271	*/