[deliverable/linux.git] / drivers / watchdog / shwdt.c

/*
 * drivers/char/watchdog/shwdt.c
 *
 * Watchdog driver for integrated watchdog in the SuperH processors.
 *
 * Copyright (C) 2001, 2002, 2003 Paul Mundt <lethal@linux-sh.org>
 *
 * 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.
 *
 * 14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com>
 *     Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT
 *
 * 19-Apr-2002 Rob Radez <rob@osinvestor.com>
 *     Added expect close support, made emulated timeout runtime changeable
 *     general cleanups, add some ioctls
 */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/miscdevice.h>
#include <linux/watchdog.h>
#include <linux/reboot.h>
#include <linux/notifier.h>
#include <linux/ioport.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/watchdog.h>

#define PFX "shwdt: "

/*
 * Default clock division ratio is 5.25 msecs. For an additional table of
 * values, consult the asm-sh/watchdog.h. Overload this at module load
 * time.
 *
 * In order for this to work reliably we need to have HZ set to 1000 or
 * something quite higher than 100 (or we need a proper high-res timer
 * implementation that will deal with this properly), otherwise the 10ms
 * resolution of a jiffy is enough to trigger the overflow. For things like
 * the SH-4 and SH-5, this isn't necessarily that big of a problem, though
 * for the SH-2 and SH-3, this isn't recommended unless the WDT is absolutely
 * necssary.
 *
 * As a result of this timing problem, the only modes that are particularly
 * feasible are the 4096 and the 2048 divisors, which yeild 5.25 and 2.62ms
 * overflow periods respectively.
 *
 * Also, since we can't really expect userspace to be responsive enough
 * before the overflow happens, we maintain two separate timers .. One in
 * the kernel for clearing out WOVF every 2ms or so (again, this depends on
 * HZ == 1000), and another for monitoring userspace writes to the WDT device.
 *
 * As such, we currently use a configurable heartbeat interval which defaults
 * to 30s. In this case, the userspace daemon is only responsible for periodic
 * writes to the device before the next heartbeat is scheduled. If the daemon
 * misses its deadline, the kernel timer will allow the WDT to overflow.
 */
static int clock_division_ratio = WTCSR_CKS_4096;

#define next_ping_period(cks)	msecs_to_jiffies(cks - 4)

static void sh_wdt_ping(unsigned long data);

static unsigned long shwdt_is_open;
static struct watchdog_info sh_wdt_info;
static char shwdt_expect_close;
static DEFINE_TIMER(timer, sh_wdt_ping, 0, 0);
static unsigned long next_heartbeat;

#define WATCHDOG_HEARTBEAT 30			/* 30 sec default heartbeat */
static int heartbeat = WATCHDOG_HEARTBEAT;	/* in seconds */

static int nowayout = WATCHDOG_NOWAYOUT;

/**
 * 	sh_wdt_start - Start the Watchdog
 *
 * 	Starts the watchdog.
 */
static void sh_wdt_start(void)
{
	__u8 csr;

	next_heartbeat = jiffies + (heartbeat * HZ);
	mod_timer(&timer, next_ping_period(clock_division_ratio));

	csr = sh_wdt_read_csr();
	csr |= WTCSR_WT | clock_division_ratio;
	sh_wdt_write_csr(csr);

	sh_wdt_write_cnt(0);

	/*
	 * These processors have a bit of an inconsistent initialization
	 * process.. starting with SH-3, RSTS was moved to WTCSR, and the
	 * RSTCSR register was removed.
	 *
	 * On the SH-2 however, in addition with bits being in different
	 * locations, we must deal with RSTCSR outright..
	 */
	csr = sh_wdt_read_csr();
	csr |= WTCSR_TME;
	csr &= ~WTCSR_RSTS;
	sh_wdt_write_csr(csr);

#ifdef CONFIG_CPU_SH2
	/*
	 * Whoever came up with the RSTCSR semantics must've been smoking
	 * some of the good stuff, since in addition to the WTCSR/WTCNT write
	 * brain-damage, it's managed to fuck things up one step further..
	 *
	 * If we need to clear the WOVF bit, the upper byte has to be 0xa5..
	 * but if we want to touch RSTE or RSTS, the upper byte has to be
	 * 0x5a..
	 */
	csr = sh_wdt_read_rstcsr();
	csr &= ~RSTCSR_RSTS;
	sh_wdt_write_rstcsr(csr);
#endif
}

/**
 * 	sh_wdt_stop - Stop the Watchdog
 * 	Stops the watchdog.
 */
static void sh_wdt_stop(void)
{
	__u8 csr;

	del_timer(&timer);

	csr = sh_wdt_read_csr();
	csr &= ~WTCSR_TME;
	sh_wdt_write_csr(csr);
}

/**
 * 	sh_wdt_keepalive - Keep the Userspace Watchdog Alive
 * 	The Userspace watchdog got a KeepAlive: schedule the next heartbeat.
 */
static inline void sh_wdt_keepalive(void)
{
	next_heartbeat = jiffies + (heartbeat * HZ);
}

/**
 * 	sh_wdt_set_heartbeat - Set the Userspace Watchdog heartbeat
 * 	Set the Userspace Watchdog heartbeat
 */
static int sh_wdt_set_heartbeat(int t)
{
	if (unlikely((t < 1) || (t > 3600))) /* arbitrary upper limit */
		return -EINVAL;

	heartbeat = t;
	return 0;
}

/**
 * 	sh_wdt_ping - Ping the Watchdog
 *	@data: Unused
 *
 * 	Clears overflow bit, resets timer counter.
 */
static void sh_wdt_ping(unsigned long data)
{
	if (time_before(jiffies, next_heartbeat)) {
		__u8 csr;

		csr = sh_wdt_read_csr();
		csr &= ~WTCSR_IOVF;
		sh_wdt_write_csr(csr);

		sh_wdt_write_cnt(0);

		mod_timer(&timer, next_ping_period(clock_division_ratio));
	} else
		printk(KERN_WARNING PFX "Heartbeat lost! Will not ping "
		       "the watchdog\n");
}

/**
 * 	sh_wdt_open - Open the Device
 * 	@inode: inode of device
 * 	@file: file handle of device
 *
 * 	Watchdog device is opened and started.
 */
static int sh_wdt_open(struct inode *inode, struct file *file)
{
	if (test_and_set_bit(0, &shwdt_is_open))
		return -EBUSY;
	if (nowayout)
		__module_get(THIS_MODULE);

	sh_wdt_start();

	return nonseekable_open(inode, file);
}

/**
 * 	sh_wdt_close - Close the Device
 * 	@inode: inode of device
 * 	@file: file handle of device
 *
 * 	Watchdog device is closed and stopped.
 */
static int sh_wdt_close(struct inode *inode, struct file *file)
{
	if (shwdt_expect_close == 42) {
		sh_wdt_stop();
	} else {
		printk(KERN_CRIT PFX "Unexpected close, not "
		       "stopping watchdog!\n");
		sh_wdt_keepalive();
	}

	clear_bit(0, &shwdt_is_open);
	shwdt_expect_close = 0;

	return 0;
}

/**
 * 	sh_wdt_write - Write to Device
 * 	@file: file handle of device
 * 	@buf: buffer to write
 * 	@count: length of buffer
 * 	@ppos: offset
 *
 * 	Pings the watchdog on write.
 */
static ssize_t sh_wdt_write(struct file *file, const char *buf,
			    size_t count, loff_t *ppos)
{
	if (count) {
		if (!nowayout) {
			size_t i;

			shwdt_expect_close = 0;

			for (i = 0; i != count; i++) {
				char c;
				if (get_user(c, buf + i))
					return -EFAULT;
				if (c == 'V')
					shwdt_expect_close = 42;
			}
		}
		sh_wdt_keepalive();
	}

	return count;
}

/**
 * 	sh_wdt_mmap - map WDT/CPG registers into userspace
 * 	@file: file structure for the device
 * 	@vma: VMA to map the registers into
 *
 * 	A simple mmap() implementation for the corner cases where the counter
 * 	needs to be mapped in userspace directly. Due to the relatively small
 * 	size of the area, neighbouring registers not necessarily tied to the
 * 	CPG will also be accessible through the register page, so this remains
 * 	configurable for users that really know what they're doing.
 *
 *	Additionaly, the register page maps in the CPG register base relative
 *	to the nearest page-aligned boundary, which requires that userspace do
 *	the appropriate CPU subtype math for calculating the page offset for
 *	the counter value.
 */
static int sh_wdt_mmap(struct file *file, struct vm_area_struct *vma)
{
	int ret = -ENOSYS;

#ifdef CONFIG_SH_WDT_MMAP
	unsigned long addr;

	/* Only support the simple cases where we map in a register page. */
	if (((vma->vm_end - vma->vm_start) != PAGE_SIZE) || vma->vm_pgoff)
		return -EINVAL;

	/*
	 * Pick WTCNT as the start, it's usually the first register after the
	 * FRQCR, and neither one are generally page-aligned out of the box.
	 */
	addr = WTCNT & ~(PAGE_SIZE - 1);

	vma->vm_flags |= VM_IO;
	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT,
			       PAGE_SIZE, vma->vm_page_prot)) {
		printk(KERN_ERR PFX "%s: io_remap_pfn_range failed\n",
		       __func__);
		return -EAGAIN;
	}

	ret = 0;
#endif

	return ret;
}

/**
 * 	sh_wdt_ioctl - Query Device
 * 	@inode: inode of device
 * 	@file: file handle of device
 * 	@cmd: watchdog command
 * 	@arg: argument
 *
 * 	Query basic information from the device or ping it, as outlined by the
 * 	watchdog API.
 */
static int sh_wdt_ioctl(struct inode *inode, struct file *file,
			unsigned int cmd, unsigned long arg)
{
	int new_heartbeat;
	int options, retval = -EINVAL;

	switch (cmd) {
		case WDIOC_GETSUPPORT:
			return copy_to_user((struct watchdog_info *)arg,
					  &sh_wdt_info,
					  sizeof(sh_wdt_info)) ? -EFAULT : 0;
		case WDIOC_GETSTATUS:
		case WDIOC_GETBOOTSTATUS:
			return put_user(0, (int *)arg);
		case WDIOC_KEEPALIVE:
			sh_wdt_keepalive();
			return 0;
		case WDIOC_SETTIMEOUT:
			if (get_user(new_heartbeat, (int *)arg))
				return -EFAULT;

			if (sh_wdt_set_heartbeat(new_heartbeat))
				return -EINVAL;

			sh_wdt_keepalive();
			/* Fall */
		case WDIOC_GETTIMEOUT:
			return put_user(heartbeat, (int *)arg);
		case WDIOC_SETOPTIONS:
			if (get_user(options, (int *)arg))
				return -EFAULT;

			if (options & WDIOS_DISABLECARD) {
				sh_wdt_stop();
				retval = 0;
			}

			if (options & WDIOS_ENABLECARD) {
				sh_wdt_start();
				retval = 0;
			}

			return retval;
		default:
			return -ENOTTY;
	}

	return 0;
}

/**
 * 	sh_wdt_notify_sys - Notifier Handler
 * 	@this: notifier block
 * 	@code: notifier event
 * 	@unused: unused
 *
 * 	Handles specific events, such as turning off the watchdog during a
 * 	shutdown event.
 */
static int sh_wdt_notify_sys(struct notifier_block *this,
			     unsigned long code, void *unused)
{
	if (code == SYS_DOWN || code == SYS_HALT)
		sh_wdt_stop();

	return NOTIFY_DONE;
}

static const struct file_operations sh_wdt_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.write		= sh_wdt_write,
	.ioctl		= sh_wdt_ioctl,
	.open		= sh_wdt_open,
	.release	= sh_wdt_close,
	.mmap		= sh_wdt_mmap,
};

static struct watchdog_info sh_wdt_info = {
	.options		= WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
				  WDIOF_MAGICCLOSE,
	.firmware_version	= 1,
	.identity		= "SH WDT",
};

static struct notifier_block sh_wdt_notifier = {
	.notifier_call		= sh_wdt_notify_sys,
};

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

/**
 * 	sh_wdt_init - Initialize module
 * 	Registers the device and notifier handler. Actual device
 * 	initialization is handled by sh_wdt_open().
 */
static int __init sh_wdt_init(void)
{
	int rc;

	if ((clock_division_ratio < 0x5) || (clock_division_ratio > 0x7)) {
		clock_division_ratio = WTCSR_CKS_4096;
		printk(KERN_INFO PFX "clock_division_ratio value must "
		       "be 0x5<=x<=0x7, using %d\n", clock_division_ratio);
	}

	rc = sh_wdt_set_heartbeat(heartbeat);
	if (unlikely(rc)) {
		heartbeat = WATCHDOG_HEARTBEAT;
		printk(KERN_INFO PFX "heartbeat value must "
		       "be 1<=x<=3600, using %d\n", heartbeat);
	}

	rc = register_reboot_notifier(&sh_wdt_notifier);
	if (unlikely(rc)) {
		printk(KERN_ERR PFX "Can't register reboot notifier (err=%d)\n",
		       rc);
		return rc;
	}

	rc = misc_register(&sh_wdt_miscdev);
	if (unlikely(rc)) {
		printk(KERN_ERR PFX "Can't register miscdev on "
		       "minor=%d (err=%d)\n", sh_wdt_miscdev.minor, rc);
		unregister_reboot_notifier(&sh_wdt_notifier);
		return rc;
	}

	printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
		heartbeat, nowayout);

	return 0;
}

/**
 * 	sh_wdt_exit - Deinitialize module
 * 	Unregisters the device and notifier handler. Actual device
 * 	deinitialization is handled by sh_wdt_close().
 */
static void __exit sh_wdt_exit(void)
{
	misc_deregister(&sh_wdt_miscdev);
	unregister_reboot_notifier(&sh_wdt_notifier);
}

MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
MODULE_DESCRIPTION("SuperH watchdog driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

module_param(clock_division_ratio, int, 0);
MODULE_PARM_DESC(clock_division_ratio, "Clock division ratio. Valid ranges are from 0x5 (1.31ms) to 0x7 (5.25ms). (default=" __MODULE_STRING(clock_division_ratio) ")");

module_param(heartbeat, int, 0);
MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (1<=heartbeat<=3600, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");

module_param(nowayout, int, 0);
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");

module_init(sh_wdt_init);
module_exit(sh_wdt_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* drivers/char/watchdog/shwdt.c
	3	*
	4	* Watchdog driver for integrated watchdog in the SuperH processors.
	5	*
	6	* Copyright (C) 2001, 2002, 2003 Paul Mundt <lethal@linux-sh.org>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2 of the License, or (at your
	11	* option) any later version.
	12	*
	13	* 14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com>
	14	* Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT
	15	*
	16	* 19-Apr-2002 Rob Radez <rob@osinvestor.com>
	17	* Added expect close support, made emulated timeout runtime changeable
	18	* general cleanups, add some ioctls
	19	*/
1da177e4 LT	20	#include <linux/module.h>
	21	#include <linux/moduleparam.h>
	22	#include <linux/init.h>
	23	#include <linux/types.h>
	24	#include <linux/miscdevice.h>
	25	#include <linux/watchdog.h>
	26	#include <linux/reboot.h>
	27	#include <linux/notifier.h>
	28	#include <linux/ioport.h>
	29	#include <linux/fs.h>
f118420b	30	#include <linux/mm.h>
1da177e4 LT	31	#include <asm/io.h>
	32	#include <asm/uaccess.h>
	33	#include <asm/watchdog.h>
	34
	35	#define PFX "shwdt: "
	36
	37	/*
	38	* Default clock division ratio is 5.25 msecs. For an additional table of
	39	* values, consult the asm-sh/watchdog.h. Overload this at module load
	40	* time.
	41	*
	42	* In order for this to work reliably we need to have HZ set to 1000 or
	43	* something quite higher than 100 (or we need a proper high-res timer
	44	* implementation that will deal with this properly), otherwise the 10ms
	45	* resolution of a jiffy is enough to trigger the overflow. For things like
	46	* the SH-4 and SH-5, this isn't necessarily that big of a problem, though
	47	* for the SH-2 and SH-3, this isn't recommended unless the WDT is absolutely
	48	* necssary.
	49	*
	50	* As a result of this timing problem, the only modes that are particularly
	51	* feasible are the 4096 and the 2048 divisors, which yeild 5.25 and 2.62ms
	52	* overflow periods respectively.
	53	*
	54	* Also, since we can't really expect userspace to be responsive enough
ee0fc097	55	* before the overflow happens, we maintain two separate timers .. One in
1da177e4 LT	56	* the kernel for clearing out WOVF every 2ms or so (again, this depends on
	57	* HZ == 1000), and another for monitoring userspace writes to the WDT device.
	58	*
	59	* As such, we currently use a configurable heartbeat interval which defaults
	60	* to 30s. In this case, the userspace daemon is only responsible for periodic
	61	* writes to the device before the next heartbeat is scheduled. If the daemon
	62	* misses its deadline, the kernel timer will allow the WDT to overflow.
	63	*/
	64	static int clock_division_ratio = WTCSR_CKS_4096;
	65
	66	#define next_ping_period(cks) msecs_to_jiffies(cks - 4)
	67
82eb7c50 JS	68	static void sh_wdt_ping(unsigned long data);
82eb7c50 JS	69
1da177e4 LT	70	static unsigned long shwdt_is_open;
	71	static struct watchdog_info sh_wdt_info;
	72	static char shwdt_expect_close;
82eb7c50	73	static DEFINE_TIMER(timer, sh_wdt_ping, 0, 0);
1da177e4 LT	74	static unsigned long next_heartbeat;
	75
	76	#define WATCHDOG_HEARTBEAT 30 /* 30 sec default heartbeat */
	77	static int heartbeat = WATCHDOG_HEARTBEAT; /* in seconds */
	78
4bfdf378	79	static int nowayout = WATCHDOG_NOWAYOUT;
1da177e4 LT	80
	81	/**
	82	* sh_wdt_start - Start the Watchdog
	83	*
	84	* Starts the watchdog.
	85	*/
	86	static void sh_wdt_start(void)
	87	{
	88	__u8 csr;
	89
	90	next_heartbeat = jiffies + (heartbeat * HZ);
	91	mod_timer(&timer, next_ping_period(clock_division_ratio));
	92
	93	csr = sh_wdt_read_csr();
	94	csr \|= WTCSR_WT \| clock_division_ratio;
	95	sh_wdt_write_csr(csr);
	96
	97	sh_wdt_write_cnt(0);
	98
	99	/*
	100	* These processors have a bit of an inconsistent initialization
	101	* process.. starting with SH-3, RSTS was moved to WTCSR, and the
	102	* RSTCSR register was removed.
	103	*
	104	* On the SH-2 however, in addition with bits being in different
	105	* locations, we must deal with RSTCSR outright..
	106	*/
	107	csr = sh_wdt_read_csr();
	108	csr \|= WTCSR_TME;
	109	csr &= ~WTCSR_RSTS;
	110	sh_wdt_write_csr(csr);
	111
	112	#ifdef CONFIG_CPU_SH2
	113	/*
	114	* Whoever came up with the RSTCSR semantics must've been smoking
	115	* some of the good stuff, since in addition to the WTCSR/WTCNT write
	116	* brain-damage, it's managed to fuck things up one step further..
	117	*
	118	* If we need to clear the WOVF bit, the upper byte has to be 0xa5..
	119	* but if we want to touch RSTE or RSTS, the upper byte has to be
	120	* 0x5a..
	121	*/
	122	csr = sh_wdt_read_rstcsr();
	123	csr &= ~RSTCSR_RSTS;
	124	sh_wdt_write_rstcsr(csr);
	125	#endif
	126	}
	127
	128	/**
	129	* sh_wdt_stop - Stop the Watchdog
1da177e4 LT	130	* Stops the watchdog.
	131	*/
	132	static void sh_wdt_stop(void)
	133	{
	134	__u8 csr;
	135
	136	del_timer(&timer);
	137
	138	csr = sh_wdt_read_csr();
	139	csr &= ~WTCSR_TME;
	140	sh_wdt_write_csr(csr);
	141	}
	142
	143	/**
	144	* sh_wdt_keepalive - Keep the Userspace Watchdog Alive
1da177e4 LT	145	* The Userspace watchdog got a KeepAlive: schedule the next heartbeat.
1da177e4 LT	146	*/
e4c2cfee	147	static inline void sh_wdt_keepalive(void)
1da177e4 LT	148	{
	149	next_heartbeat = jiffies + (heartbeat * HZ);
	150	}
	151
	152	/**
	153	* sh_wdt_set_heartbeat - Set the Userspace Watchdog heartbeat
1da177e4 LT	154	* Set the Userspace Watchdog heartbeat
	155	*/
	156	static int sh_wdt_set_heartbeat(int t)
	157	{
e4c2cfee	158	if (unlikely((t < 1) \|\| (t > 3600))) /* arbitrary upper limit */
1da177e4 LT	159	return -EINVAL;
	160
	161	heartbeat = t;
	162	return 0;
	163	}
	164
	165	/**
	166	* sh_wdt_ping - Ping the Watchdog
1da177e4 LT	167	* @data: Unused
	168	*
	169	* Clears overflow bit, resets timer counter.
	170	*/
	171	static void sh_wdt_ping(unsigned long data)
	172	{
	173	if (time_before(jiffies, next_heartbeat)) {
	174	__u8 csr;
	175
	176	csr = sh_wdt_read_csr();
	177	csr &= ~WTCSR_IOVF;
	178	sh_wdt_write_csr(csr);
	179
	180	sh_wdt_write_cnt(0);
	181
	182	mod_timer(&timer, next_ping_period(clock_division_ratio));
e4c2cfee PM	183	} else
	184	printk(KERN_WARNING PFX "Heartbeat lost! Will not ping "
	185	"the watchdog\n");
1da177e4 LT	186	}
	187
	188	/**
	189	* sh_wdt_open - Open the Device
1da177e4 LT	190	* @inode: inode of device
	191	* @file: file handle of device
	192	*
	193	* Watchdog device is opened and started.
	194	*/
	195	static int sh_wdt_open(struct inode inode, struct file file)
	196	{
	197	if (test_and_set_bit(0, &shwdt_is_open))
	198	return -EBUSY;
	199	if (nowayout)
	200	__module_get(THIS_MODULE);
	201
	202	sh_wdt_start();
	203
	204	return nonseekable_open(inode, file);
	205	}
	206
	207	/**
	208	* sh_wdt_close - Close the Device
1da177e4 LT	209	* @inode: inode of device
	210	* @file: file handle of device
	211	*
	212	* Watchdog device is closed and stopped.
	213	*/
	214	static int sh_wdt_close(struct inode inode, struct file file)
	215	{
	216	if (shwdt_expect_close == 42) {
	217	sh_wdt_stop();
	218	} else {
e4c2cfee PM	219	printk(KERN_CRIT PFX "Unexpected close, not "
e4c2cfee PM	220	"stopping watchdog!\n");
1da177e4 LT	221	sh_wdt_keepalive();
	222	}
	223
	224	clear_bit(0, &shwdt_is_open);
	225	shwdt_expect_close = 0;
	226
	227	return 0;
	228	}
	229
	230	/**
	231	* sh_wdt_write - Write to Device
1da177e4 LT	232	* @file: file handle of device
	233	* @buf: buffer to write
	234	* @count: length of buffer
	235	* @ppos: offset
	236	*
	237	* Pings the watchdog on write.
	238	*/
	239	static ssize_t sh_wdt_write(struct file file, const char buf,
	240	size_t count, loff_t *ppos)
	241	{
	242	if (count) {
	243	if (!nowayout) {
	244	size_t i;
	245
	246	shwdt_expect_close = 0;
	247
	248	for (i = 0; i != count; i++) {
	249	char c;
	250	if (get_user(c, buf + i))
	251	return -EFAULT;
	252	if (c == 'V')
	253	shwdt_expect_close = 42;
	254	}
	255	}
	256	sh_wdt_keepalive();
	257	}
	258
	259	return count;
	260	}
	261
f118420b PM	262	/**
	263	* sh_wdt_mmap - map WDT/CPG registers into userspace
	264	* @file: file structure for the device
	265	* @vma: VMA to map the registers into
	266	*
	267	* A simple mmap() implementation for the corner cases where the counter
	268	* needs to be mapped in userspace directly. Due to the relatively small
	269	* size of the area, neighbouring registers not necessarily tied to the
	270	* CPG will also be accessible through the register page, so this remains
	271	* configurable for users that really know what they're doing.
	272	*
	273	* Additionaly, the register page maps in the CPG register base relative
	274	* to the nearest page-aligned boundary, which requires that userspace do
	275	* the appropriate CPU subtype math for calculating the page offset for
	276	* the counter value.
	277	*/
	278	static int sh_wdt_mmap(struct file file, struct vm_area_struct vma)
	279	{
	280	int ret = -ENOSYS;
	281
	282	#ifdef CONFIG_SH_WDT_MMAP
	283	unsigned long addr;
	284
	285	/* Only support the simple cases where we map in a register page. */
	286	if (((vma->vm_end - vma->vm_start) != PAGE_SIZE) \|\| vma->vm_pgoff)
	287	return -EINVAL;
	288
	289	/*
	290	* Pick WTCNT as the start, it's usually the first register after the
	291	* FRQCR, and neither one are generally page-aligned out of the box.
	292	*/
	293	addr = WTCNT & ~(PAGE_SIZE - 1);
	294
	295	vma->vm_flags \|= VM_IO;
	296	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
	297
	298	if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT,
	299	PAGE_SIZE, vma->vm_page_prot)) {
	300	printk(KERN_ERR PFX "%s: io_remap_pfn_range failed\n",
fa9363c5	301	__func__);
f118420b PM	302	return -EAGAIN;
	303	}
	304
	305	ret = 0;
	306	#endif
	307
	308	return ret;
	309	}
	310
1da177e4 LT	311	/**
1da177e4 LT	312	* sh_wdt_ioctl - Query Device
1da177e4 LT	313	* @inode: inode of device
	314	* @file: file handle of device
	315	* @cmd: watchdog command
	316	* @arg: argument
	317	*
	318	* Query basic information from the device or ping it, as outlined by the
	319	* watchdog API.
	320	*/
	321	static int sh_wdt_ioctl(struct inode inode, struct file file,
	322	unsigned int cmd, unsigned long arg)
	323	{
	324	int new_heartbeat;
	325	int options, retval = -EINVAL;
	326
	327	switch (cmd) {
	328	case WDIOC_GETSUPPORT:
	329	return copy_to_user((struct watchdog_info *)arg,
	330	&sh_wdt_info,
	331	sizeof(sh_wdt_info)) ? -EFAULT : 0;
	332	case WDIOC_GETSTATUS:
	333	case WDIOC_GETBOOTSTATUS:
	334	return put_user(0, (int *)arg);
	335	case WDIOC_KEEPALIVE:
	336	sh_wdt_keepalive();
	337	return 0;
	338	case WDIOC_SETTIMEOUT:
	339	if (get_user(new_heartbeat, (int *)arg))
	340	return -EFAULT;
	341
	342	if (sh_wdt_set_heartbeat(new_heartbeat))
	343	return -EINVAL;
	344
	345	sh_wdt_keepalive();
	346	/* Fall */
	347	case WDIOC_GETTIMEOUT:
	348	return put_user(heartbeat, (int *)arg);
	349	case WDIOC_SETOPTIONS:
	350	if (get_user(options, (int *)arg))
	351	return -EFAULT;
	352
	353	if (options & WDIOS_DISABLECARD) {
	354	sh_wdt_stop();
	355	retval = 0;
	356	}
	357
	358	if (options & WDIOS_ENABLECARD) {
	359	sh_wdt_start();
	360	retval = 0;
	361	}
	362
	363	return retval;
	364	default:
795b89d2	365	return -ENOTTY;
1da177e4 LT	366	}
	367
	368	return 0;
	369	}
	370
	371	/**
	372	* sh_wdt_notify_sys - Notifier Handler
1da177e4 LT	373	* @this: notifier block
	374	* @code: notifier event
	375	* @unused: unused
	376	*
	377	* Handles specific events, such as turning off the watchdog during a
	378	* shutdown event.
	379	*/
	380	static int sh_wdt_notify_sys(struct notifier_block *this,
	381	unsigned long code, void *unused)
	382	{
e4c2cfee	383	if (code == SYS_DOWN \|\| code == SYS_HALT)
1da177e4	384	sh_wdt_stop();
1da177e4 LT	385
	386	return NOTIFY_DONE;
	387	}
	388
62322d25	389	static const struct file_operations sh_wdt_fops = {
1da177e4 LT	390	.owner = THIS_MODULE,
	391	.llseek = no_llseek,
	392	.write = sh_wdt_write,
	393	.ioctl = sh_wdt_ioctl,
	394	.open = sh_wdt_open,
	395	.release = sh_wdt_close,
f118420b	396	.mmap = sh_wdt_mmap,
1da177e4 LT	397	};
	398
	399	static struct watchdog_info sh_wdt_info = {
e4c2cfee PM	400	.options = WDIOF_KEEPALIVEPING \| WDIOF_SETTIMEOUT \|
e4c2cfee PM	401	WDIOF_MAGICCLOSE,
1da177e4 LT	402	.firmware_version = 1,
	403	.identity = "SH WDT",
	404	};
	405
	406	static struct notifier_block sh_wdt_notifier = {
	407	.notifier_call = sh_wdt_notify_sys,
	408	};
	409
	410	static struct miscdevice sh_wdt_miscdev = {
	411	.minor = WATCHDOG_MINOR,
	412	.name = "watchdog",
	413	.fops = &sh_wdt_fops,
	414	};
	415
	416	/**
	417	* sh_wdt_init - Initialize module
1da177e4 LT	418	* Registers the device and notifier handler. Actual device
	419	* initialization is handled by sh_wdt_open().
	420	*/
	421	static int __init sh_wdt_init(void)
	422	{
	423	int rc;
	424
	425	if ((clock_division_ratio < 0x5) \|\| (clock_division_ratio > 0x7)) {
	426	clock_division_ratio = WTCSR_CKS_4096;
e4c2cfee PM	427	printk(KERN_INFO PFX "clock_division_ratio value must "
e4c2cfee PM	428	"be 0x5<=x<=0x7, using %d\n", clock_division_ratio);
1da177e4 LT	429	}
1da177e4 LT	430
e4c2cfee PM	431	rc = sh_wdt_set_heartbeat(heartbeat);
e4c2cfee PM	432	if (unlikely(rc)) {
1da177e4	433	heartbeat = WATCHDOG_HEARTBEAT;
e4c2cfee PM	434	printk(KERN_INFO PFX "heartbeat value must "
e4c2cfee PM	435	"be 1<=x<=3600, using %d\n", heartbeat);
1da177e4 LT	436	}
1da177e4 LT	437
1da177e4	438	rc = register_reboot_notifier(&sh_wdt_notifier);
e4c2cfee PM	439	if (unlikely(rc)) {
	440	printk(KERN_ERR PFX "Can't register reboot notifier (err=%d)\n",
	441	rc);
1da177e4 LT	442	return rc;
	443	}
	444
	445	rc = misc_register(&sh_wdt_miscdev);
e4c2cfee PM	446	if (unlikely(rc)) {
	447	printk(KERN_ERR PFX "Can't register miscdev on "
	448	"minor=%d (err=%d)\n", sh_wdt_miscdev.minor, rc);
1da177e4 LT	449	unregister_reboot_notifier(&sh_wdt_notifier);
	450	return rc;
	451	}
	452
	453	printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
	454	heartbeat, nowayout);
	455
	456	return 0;
	457	}
	458
	459	/**
	460	* sh_wdt_exit - Deinitialize module
1da177e4 LT	461	* Unregisters the device and notifier handler. Actual device
	462	* deinitialization is handled by sh_wdt_close().
	463	*/
	464	static void __exit sh_wdt_exit(void)
	465	{
	466	misc_deregister(&sh_wdt_miscdev);
	467	unregister_reboot_notifier(&sh_wdt_notifier);
	468	}
	469
	470	MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
	471	MODULE_DESCRIPTION("SuperH watchdog driver");
	472	MODULE_LICENSE("GPL");
	473	MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
	474
	475	module_param(clock_division_ratio, int, 0);
e4c2cfee	476	MODULE_PARM_DESC(clock_division_ratio, "Clock division ratio. Valid ranges are from 0x5 (1.31ms) to 0x7 (5.25ms). (default=" __MODULE_STRING(clock_division_ratio) ")");
1da177e4 LT	477
	478	module_param(heartbeat, int, 0);
	479	MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (1<=heartbeat<=3600, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
	480
	481	module_param(nowayout, int, 0);
e4c2cfee	482	MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
1da177e4 LT	483
	484	module_init(sh_wdt_init);
	485	module_exit(sh_wdt_exit);