[WATCHDOG] Merge code clean-up's from Alan Cox. (96e2e6fa) · Commits · jan.koester / Linux

drivers/watchdog/acquirewdt.c

+58 −61

Original line number	Original line	Diff line number	Diff line
	@@ -58,39 +58,46 @@
	#include <linux/types.h> /* For standard types (like size_t) */		#include <linux/types.h> /* For standard types (like size_t) */
	#include <linux/errno.h> /* For the -ENODEV/... values */		#include <linux/errno.h> /* For the -ENODEV/... values */
	#include <linux/kernel.h> /* For printk/panic/... */		#include <linux/kernel.h> /* For printk/panic/... */
	#include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */		#include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV
			(WATCHDOG_MINOR) */
	#include <linux/watchdog.h> /* For the watchdog specific items */		#include <linux/watchdog.h> /* For the watchdog specific items */
	#include <linux/fs.h> /* For file operations */		#include <linux/fs.h> /* For file operations */
	#include <linux/ioport.h> /* For io-port access */		#include <linux/ioport.h> /* For io-port access */
	#include <linux/platform_device.h> /* For platform_driver framework */		#include <linux/platform_device.h> /* For platform_driver framework */
	#include <linux/init.h> /* For __init/__exit/... */		#include <linux/init.h> /* For __init/__exit/... */

	#include <asm/uaccess.h> /* For copy_to_user/put_user/... */		#include <linux/uaccess.h> /* For copy_to_user/put_user/... */
	#include <asm/io.h> /* For inb/outb/... */		#include <linux/io.h> /* For inb/outb/... */

	/* Module information */		/* Module information */
	#define DRV_NAME "acquirewdt"		#define DRV_NAME "acquirewdt"
	#define PFX DRV_NAME ": "		#define PFX DRV_NAME ": "
	#define WATCHDOG_NAME "Acquire WDT"		#define WATCHDOG_NAME "Acquire WDT"
	#define WATCHDOG_HEARTBEAT 0 /* There is no way to see what the correct time-out period is */		/* There is no way to see what the correct time-out period is */
			#define WATCHDOG_HEARTBEAT 0

	/* internal variables */		/* internal variables */
	static struct platform_device acq_platform_device; / the watchdog platform device */		/* the watchdog platform device */
			static struct platform_device *acq_platform_device;
	static unsigned long acq_is_open;		static unsigned long acq_is_open;
	static char expect_close;		static char expect_close;

	/* module parameters */		/* module parameters */
	static int wdt_stop = 0x43; /* You must set this - there is no sane way to probe for this board. */		/* You must set this - there is no sane way to probe for this board. */
			static int wdt_stop = 0x43;
	module_param(wdt_stop, int, 0);		module_param(wdt_stop, int, 0);
	MODULE_PARM_DESC(wdt_stop, "Acquire WDT 'stop' io port (default 0x43)");		MODULE_PARM_DESC(wdt_stop, "Acquire WDT 'stop' io port (default 0x43)");

	static int wdt_start = 0x443; /* You must set this - there is no sane way to probe for this board. */		/* You must set this - there is no sane way to probe for this board. */
			static int wdt_start = 0x443;
	module_param(wdt_start, int, 0);		module_param(wdt_start, int, 0);
	MODULE_PARM_DESC(wdt_start, "Acquire WDT 'start' io port (default 0x443)");		MODULE_PARM_DESC(wdt_start, "Acquire WDT 'start' io port (default 0x443)");

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

	/*		/*
	* Watchdog Operations		* Watchdog Operations
	@@ -112,18 +119,18 @@ static void acq_stop(void)
	* /dev/watchdog handling		* /dev/watchdog handling
	*/		*/

	static ssize_t acq_write(struct file file, const char __user buf, size_t count, loff_t *ppos)		static ssize_t acq_write(struct file file, const char __user buf,
			size_t count, loff_t *ppos)
	{		{
	/* See if we got the magic character 'V' and reload the timer */		/* See if we got the magic character 'V' and reload the timer */
	if (count) {		if (count) {
	if (!nowayout) {		if (!nowayout) {
	size_t i;		size_t i;

	/* note: just in case someone wrote the magic character		/* note: just in case someone wrote the magic character
	* five months ago... */		* five months ago... */
	expect_close = 0;		expect_close = 0;
			/* scan to see whether or not we got the
	/* scan to see whether or not we got the magic character */		magic character */
	for (i = 0; i != count; i++) {		for (i = 0; i != count; i++) {
	char c;		char c;
	if (get_user(c, buf + i))		if (get_user(c, buf + i))
	@@ -132,28 +139,25 @@ static ssize_t acq_write(struct file file, const char __user buf, size_t count
	expect_close = 42;		expect_close = 42;
	}		}
	}		}
			/* Well, anyhow someone wrote to us, we should
	/* Well, anyhow someone wrote to us, we should return that favour */		return that favour */
	acq_keepalive();		acq_keepalive();
	}		}
	return count;		return count;
	}		}

	static int acq_ioctl(struct inode inode, struct file file, unsigned int cmd,		static long acq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	unsigned long arg)
	{		{
	int options, retval = -EINVAL;		int options, retval = -EINVAL;
	void __user argp = (void __user )arg;		void __user argp = (void __user )arg;
	int __user *p = argp;		int __user *p = argp;
	static struct watchdog_info ident =		static struct watchdog_info ident = {
	{
	.options = WDIOF_KEEPALIVEPING \| WDIOF_MAGICCLOSE,		.options = WDIOF_KEEPALIVEPING \| WDIOF_MAGICCLOSE,
	.firmware_version = 1,		.firmware_version = 1,
	.identity = WATCHDOG_NAME,		.identity = WATCHDOG_NAME,
	};		};

	switch(cmd)		switch (cmd) {
	{
	case WDIOC_GETSUPPORT:		case WDIOC_GETSUPPORT:
	return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;		return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;

	@@ -172,22 +176,16 @@ static int acq_ioctl(struct inode inode, struct file file, unsigned int cmd,
	{		{
	if (get_user(options, p))		if (get_user(options, p))
	return -EFAULT;		return -EFAULT;
			if (options & WDIOS_DISABLECARD) {
	if (options & WDIOS_DISABLECARD)
	{
	acq_stop();		acq_stop();
	retval = 0;		retval = 0;
	}		}
			if (options & WDIOS_ENABLECARD) {
	if (options & WDIOS_ENABLECARD)
	{
	acq_keepalive();		acq_keepalive();
	retval = 0;		retval = 0;
	}		}

	return retval;		return retval;
	}		}

	default:		default:
	return -ENOTTY;		return -ENOTTY;
	}		}
	@@ -211,7 +209,8 @@ static int acq_close(struct inode inode, struct file file)
	if (expect_close == 42) {		if (expect_close == 42) {
	acq_stop();		acq_stop();
	} else {		} else {
	printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");		printk(KERN_CRIT PFX
			"Unexpected close, not stopping watchdog!\n");
	acq_keepalive();		acq_keepalive();
	}		}
	clear_bit(0, &acq_is_open);		clear_bit(0, &acq_is_open);
	@@ -227,7 +226,7 @@ static const struct file_operations acq_fops = {
	.owner = THIS_MODULE,		.owner = THIS_MODULE,
	.llseek = no_llseek,		.llseek = no_llseek,
	.write = acq_write,		.write = acq_write,
	.ioctl = acq_ioctl,		.unlocked_ioctl = acq_ioctl,
	.open = acq_open,		.open = acq_open,
	.release = acq_close,		.release = acq_close,
	};		};
	@@ -248,8 +247,8 @@ static int __devinit acq_probe(struct platform_device *dev)

	if (wdt_stop != wdt_start) {		if (wdt_stop != wdt_start) {
	if (!request_region(wdt_stop, 1, WATCHDOG_NAME)) {		if (!request_region(wdt_stop, 1, WATCHDOG_NAME)) {
	printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",		printk(KERN_ERR PFX
	wdt_stop);		"I/O address 0x%04x already in use\n", wdt_stop);
	ret = -EIO;		ret = -EIO;
	goto out;		goto out;
	}		}
	@@ -261,19 +260,16 @@ static int __devinit acq_probe(struct platform_device *dev)
	ret = -EIO;		ret = -EIO;
	goto unreg_stop;		goto unreg_stop;
	}		}

	ret = misc_register(&acq_miscdev);		ret = misc_register(&acq_miscdev);
	if (ret != 0) {		if (ret != 0) {
	printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",		printk(KERN_ERR PFX
			"cannot register miscdev on minor=%d (err=%d)\n",
	WATCHDOG_MINOR, ret);		WATCHDOG_MINOR, ret);
	goto unreg_regions;		goto unreg_regions;
	}		}
			printk(KERN_INFO PFX "initialized. (nowayout=%d)\n", nowayout);
	printk (KERN_INFO PFX "initialized. (nowayout=%d)\n",
	nowayout);

	return 0;		return 0;

	unreg_regions:		unreg_regions:
	release_region(wdt_start, 1);		release_region(wdt_start, 1);
	unreg_stop:		unreg_stop:
	@@ -313,18 +309,19 @@ static int __init acq_init(void)
	{		{
	int err;		int err;

	printk(KERN_INFO "WDT driver for Acquire single board computer initialising.\n");		printk(KERN_INFO
			"WDT driver for Acquire single board computer initialising.\n");

	err = platform_driver_register(&acquirewdt_driver);		err = platform_driver_register(&acquirewdt_driver);
	if (err)		if (err)
	return err;		return err;

	acq_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0);		acq_platform_device = platform_device_register_simple(DRV_NAME,
			-1, NULL, 0);
	if (IS_ERR(acq_platform_device)) {		if (IS_ERR(acq_platform_device)) {
	err = PTR_ERR(acq_platform_device);		err = PTR_ERR(acq_platform_device);
	goto unreg_platform_driver;		goto unreg_platform_driver;
	}		}

	return 0;		return 0;

	unreg_platform_driver:		unreg_platform_driver:

drivers/watchdog/advantechwdt.c

+62 −73

Original line number	Original line	Diff line number	Diff line
	@@ -72,35 +72,35 @@ MODULE_PARM_DESC(wdt_start, "Advantech WDT 'start' io port (default 0x443)");

	static int timeout = WATCHDOG_TIMEOUT; /* in seconds */		static int timeout = WATCHDOG_TIMEOUT; /* in seconds */
	module_param(timeout, int, 0);		module_param(timeout, int, 0);
	MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. 1<= timeout <=63, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ".");		MODULE_PARM_DESC(timeout,
			"Watchdog timeout in seconds. 1<= timeout <=63, default="
			__MODULE_STRING(WATCHDOG_TIMEOUT) ".");

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

	/*		/*
	* Watchdog Operations		* Watchdog Operations
	*/		*/

	static void		static void advwdt_ping(void)
	advwdt_ping(void)
	{		{
	/* Write a watchdog value */		/* Write a watchdog value */
	outb_p(timeout, wdt_start);		outb_p(timeout, wdt_start);
	}		}

	static void		static void advwdt_disable(void)
	advwdt_disable(void)
	{		{
	inb_p(wdt_stop);		inb_p(wdt_stop);
	}		}

	static int		static int advwdt_set_heartbeat(int t)
	advwdt_set_heartbeat(int t)
	{		{
	if ((t < 1) \|\| (t > 63))		if (t < 1 \|\| t > 63)
	return -EINVAL;		return -EINVAL;

	timeout = t;		timeout = t;
	return 0;		return 0;
	}		}
	@@ -109,8 +109,8 @@ advwdt_set_heartbeat(int t)
	* /dev/watchdog handling		* /dev/watchdog handling
	*/		*/

	static ssize_t		static ssize_t advwdt_write(struct file file, const char __user buf,
	advwdt_write(struct file file, const char __user buf, size_t count, loff_t *ppos)		size_t count, loff_t *ppos)
	{		{
	if (count) {		if (count) {
	if (!nowayout) {		if (!nowayout) {
	@@ -131,9 +131,7 @@ advwdt_write(struct file file, const char __user buf, size_t count, loff_t *pp
	return count;		return count;
	}		}

	static int		static long advwdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	advwdt_ioctl(struct inode inode, struct file file, unsigned int cmd,
	unsigned long arg)
	{		{
	int new_timeout;		int new_timeout;
	void __user argp = (void __user )arg;		void __user argp = (void __user )arg;
	@@ -165,38 +163,31 @@ advwdt_ioctl(struct inode inode, struct file file, unsigned int cmd,
	return -EINVAL;		return -EINVAL;
	advwdt_ping();		advwdt_ping();
	/* Fall */		/* Fall */

	case WDIOC_GETTIMEOUT:		case WDIOC_GETTIMEOUT:
	return put_user(timeout, p);		return put_user(timeout, p);

	case WDIOC_SETOPTIONS:		case WDIOC_SETOPTIONS:
	{		{
	int options, retval = -EINVAL;		int options, retval = -EINVAL;

	if (get_user(options, p))		if (get_user(options, p))
	return -EFAULT;		return -EFAULT;

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

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

	return retval;		return retval;
	}		}

	default:		default:
	return -ENOTTY;		return -ENOTTY;
	}		}
	return 0;		return 0;
	}		}

	static int		static int advwdt_open(struct inode inode, struct file file)
	advwdt_open(struct inode inode, struct file file)
	{		{
	if (test_and_set_bit(0, &advwdt_is_open))		if (test_and_set_bit(0, &advwdt_is_open))
	return -EBUSY;		return -EBUSY;
	@@ -214,7 +205,8 @@ advwdt_close(struct inode inode, struct file file)
	if (adv_expect_close == 42) {		if (adv_expect_close == 42) {
	advwdt_disable();		advwdt_disable();
	} else {		} else {
	printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");		printk(KERN_CRIT PFX
			"Unexpected close, not stopping watchdog!\n");
	advwdt_ping();		advwdt_ping();
	}		}
	clear_bit(0, &advwdt_is_open);		clear_bit(0, &advwdt_is_open);
	@@ -230,7 +222,7 @@ static const struct file_operations advwdt_fops = {
	.owner = THIS_MODULE,		.owner = THIS_MODULE,
	.llseek = no_llseek,		.llseek = no_llseek,
	.write = advwdt_write,		.write = advwdt_write,
	.ioctl = advwdt_ioctl,		.unlocked_ioctl = advwdt_ioctl,
	.open = advwdt_open,		.open = advwdt_open,
	.release = advwdt_close,		.release = advwdt_close,
	};		};
	@@ -245,14 +237,14 @@ static struct miscdevice advwdt_miscdev = {
	* Init & exit routines		* Init & exit routines
	*/		*/

	static int __devinit		static int __devinit advwdt_probe(struct platform_device *dev)
	advwdt_probe(struct platform_device *dev)
	{		{
	int ret;		int ret;

	if (wdt_stop != wdt_start) {		if (wdt_stop != wdt_start) {
	if (!request_region(wdt_stop, 1, WATCHDOG_NAME)) {		if (!request_region(wdt_stop, 1, WATCHDOG_NAME)) {
	printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",		printk(KERN_ERR PFX
			"I/O address 0x%04x already in use\n",
	wdt_stop);		wdt_stop);
	ret = -EIO;		ret = -EIO;
	goto out;		goto out;
	@@ -260,7 +252,8 @@ advwdt_probe(struct platform_device *dev)
	}		}

	if (!request_region(wdt_start, 1, WATCHDOG_NAME)) {		if (!request_region(wdt_start, 1, WATCHDOG_NAME)) {
	printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",		printk(KERN_ERR PFX
			"I/O address 0x%04x already in use\n",
	wdt_start);		wdt_start);
	ret = -EIO;		ret = -EIO;
	goto unreg_stop;		goto unreg_stop;
	@@ -269,20 +262,19 @@ advwdt_probe(struct platform_device *dev)
	/* Check that the heartbeat value is within it's range ; if not reset to the default */		/* Check that the heartbeat value is within it's range ; if not reset to the default */
	if (advwdt_set_heartbeat(timeout)) {		if (advwdt_set_heartbeat(timeout)) {
	advwdt_set_heartbeat(WATCHDOG_TIMEOUT);		advwdt_set_heartbeat(WATCHDOG_TIMEOUT);
	printk (KERN_INFO PFX "timeout value must be 1<=x<=63, using %d\n",		printk(KERN_INFO PFX
	timeout);		"timeout value must be 1<=x<=63, using %d\n", timeout);
	}		}

	ret = misc_register(&advwdt_miscdev);		ret = misc_register(&advwdt_miscdev);
	if (ret != 0) {		if (ret != 0) {
	printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",		printk(KERN_ERR PFX
			"cannot register miscdev on minor=%d (err=%d)\n",
	WATCHDOG_MINOR, ret);		WATCHDOG_MINOR, ret);
	goto unreg_regions;		goto unreg_regions;
	}		}

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

	out:		out:
	return ret;		return ret;
	unreg_regions:		unreg_regions:
	@@ -293,8 +285,7 @@ advwdt_probe(struct platform_device *dev)
	goto out;		goto out;
	}		}

	static int __devexit		static int __devexit advwdt_remove(struct platform_device *dev)
	advwdt_remove(struct platform_device *dev)
	{		{
	misc_deregister(&advwdt_miscdev);		misc_deregister(&advwdt_miscdev);
	release_region(wdt_start,1);		release_region(wdt_start,1);
	@@ -304,8 +295,7 @@ advwdt_remove(struct platform_device *dev)
	return 0;		return 0;
	}		}

	static void		static void advwdt_shutdown(struct platform_device *dev)
	advwdt_shutdown(struct platform_device *dev)
	{		{
	/* Turn the WDT off if we have a soft shutdown */		/* Turn the WDT off if we have a soft shutdown */
	advwdt_disable();		advwdt_disable();
	@@ -321,8 +311,7 @@ static struct platform_driver advwdt_driver = {
	},		},
	};		};

	static int __init		static int __init advwdt_init(void)
	advwdt_init(void)
	{		{
	int err;		int err;

	@@ -332,7 +321,8 @@ advwdt_init(void)
	if (err)		if (err)
	return err;		return err;

	advwdt_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0);		advwdt_platform_device = platform_device_register_simple(DRV_NAME,
			-1, NULL, 0);
	if (IS_ERR(advwdt_platform_device)) {		if (IS_ERR(advwdt_platform_device)) {
	err = PTR_ERR(advwdt_platform_device);		err = PTR_ERR(advwdt_platform_device);
	goto unreg_platform_driver;		goto unreg_platform_driver;
	@@ -345,8 +335,7 @@ advwdt_init(void)
	return err;		return err;
	}		}

	static void __exit		static void __exit advwdt_exit(void)
	advwdt_exit(void)
	{		{
	platform_device_unregister(advwdt_platform_device);		platform_device_unregister(advwdt_platform_device);
	platform_driver_unregister(&advwdt_driver);		platform_driver_unregister(&advwdt_driver);

drivers/watchdog/alim1535_wdt.c

+91 −95

Original line number	Original line	Diff line number	Diff line
	@@ -19,8 +19,8 @@
	#include <linux/fs.h>		#include <linux/fs.h>
	#include <linux/pci.h>		#include <linux/pci.h>

	#include <asm/uaccess.h>		#include <linux/uaccess.h>
	#include <asm/io.h>		#include <linux/io.h>

	#define WATCHDOG_NAME "ALi_M1535"		#define WATCHDOG_NAME "ALi_M1535"
	#define PFX WATCHDOG_NAME ": "		#define PFX WATCHDOG_NAME ": "
	@@ -36,11 +36,15 @@ static DEFINE_SPINLOCK(ali_lock); /* Guards the hardware */
	/* module parameters */		/* module parameters */
	static int timeout = WATCHDOG_TIMEOUT;		static int timeout = WATCHDOG_TIMEOUT;
	module_param(timeout, int, 0);		module_param(timeout, int, 0);
	MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (0<timeout<18000, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");		MODULE_PARM_DESC(timeout,
			"Watchdog timeout in seconds. (0 < timeout < 18000, default="
			__MODULE_STRING(WATCHDOG_TIMEOUT) ")");

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

	/*		/*
	* ali_start - start watchdog countdown		* ali_start - start watchdog countdown
	@@ -111,7 +115,8 @@ static int ali_settimer(int t)
	ali_timeout_bits = (t/60)\|(1<<7);		ali_timeout_bits = (t/60)\|(1<<7);
	else if (t < 18000)		else if (t < 18000)
	ali_timeout_bits = (t/300)\|(1<<6)\|(1<<7);		ali_timeout_bits = (t/300)\|(1<<6)\|(1<<7);
	else return -EINVAL;		else
			return -EINVAL;

	timeout = t;		timeout = t;
	return 0;		return 0;
	@@ -141,11 +146,12 @@ static ssize_t ali_write(struct file file, const char __user data,
	if (!nowayout) {		if (!nowayout) {
	size_t i;		size_t i;

	/* note: just in case someone wrote the magic character		/* note: just in case someone wrote the
	* five months ago... */		magic character five months ago... */
	ali_expect_release = 0;		ali_expect_release = 0;

	/* scan to see whether or not we got the magic character */		/* scan to see whether or not we got
			the magic character */
	for (i = 0; i != len; i++) {		for (i = 0; i != len; i++) {
	char c;		char c;
	if (get_user(c, data+i))		if (get_user(c, data+i))
	@@ -163,7 +169,6 @@ static ssize_t ali_write(struct file file, const char __user data,

	/*		/*
	* ali_ioctl - handle watchdog ioctls		* ali_ioctl - handle watchdog ioctls
	* @inode: VFS inode
	* @file: VFS file pointer		* @file: VFS file pointer
	* @cmd: ioctl number		* @cmd: ioctl number
	* @arg: arguments to the ioctl		* @arg: arguments to the ioctl
	@@ -172,8 +177,7 @@ static ssize_t ali_write(struct file file, const char __user data,
	* we want an extension to enable irq ack monitoring and the like		* we want an extension to enable irq ack monitoring and the like
	*/		*/

	static int ali_ioctl(struct inode inode, struct file file,		static long ali_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	unsigned int cmd, unsigned long arg)
	{		{
	void __user argp = (void __user )arg;		void __user argp = (void __user )arg;
	int __user *p = argp;		int __user *p = argp;
	@@ -187,54 +191,42 @@ static int ali_ioctl(struct inode inode, struct file file,

	switch (cmd) {		switch (cmd) {
	case WDIOC_GETSUPPORT:		case WDIOC_GETSUPPORT:
	return copy_to_user(argp, &ident,		return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
	sizeof (ident)) ? -EFAULT : 0;

	case WDIOC_GETSTATUS:		case WDIOC_GETSTATUS:
	case WDIOC_GETBOOTSTATUS:		case WDIOC_GETBOOTSTATUS:
	return put_user(0, p);		return put_user(0, p);

	case WDIOC_KEEPALIVE:		case WDIOC_KEEPALIVE:
	ali_keepalive();		ali_keepalive();
	return 0;		return 0;

	case WDIOC_SETOPTIONS:		case WDIOC_SETOPTIONS:
	{		{
	int new_options, retval = -EINVAL;		int new_options, retval = -EINVAL;

	if (get_user(new_options, p))		if (get_user(new_options, p))
	return -EFAULT;		return -EFAULT;

	if (new_options & WDIOS_DISABLECARD) {		if (new_options & WDIOS_DISABLECARD) {
	ali_stop();		ali_stop();
	retval = 0;		retval = 0;
	}		}

	if (new_options & WDIOS_ENABLECARD) {		if (new_options & WDIOS_ENABLECARD) {
	ali_start();		ali_start();
	retval = 0;		retval = 0;
	}		}

	return retval;		return retval;
	}		}

	case WDIOC_SETTIMEOUT:		case WDIOC_SETTIMEOUT:
	{		{
	int new_timeout;		int new_timeout;

	if (get_user(new_timeout, p))		if (get_user(new_timeout, p))
	return -EFAULT;		return -EFAULT;

	if (ali_settimer(new_timeout))		if (ali_settimer(new_timeout))
	return -EINVAL;		return -EINVAL;

	ali_keepalive();		ali_keepalive();
	/* Fall */		/* Fall */
	}		}

	case WDIOC_GETTIMEOUT:		case WDIOC_GETTIMEOUT:
	return put_user(timeout, p);		return put_user(timeout, p);

	default:		default:
	return -ENOTTY;		return -ENOTTY;
	}		}
	@@ -274,10 +266,11 @@ static int ali_release(struct inode inode, struct file file)
	/*		/*
	* Shut off the timer.		* Shut off the timer.
	*/		*/
	if (ali_expect_release == 42) {		if (ali_expect_release == 42)
	ali_stop();		ali_stop();
	} else {		else {
	printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");		printk(KERN_CRIT PFX
			"Unexpected close, not stopping watchdog!\n");
	ali_keepalive();		ali_keepalive();
	}		}
	clear_bit(0, &ali_is_open);		clear_bit(0, &ali_is_open);
	@@ -292,13 +285,11 @@ static int ali_release(struct inode inode, struct file file)
	*/		*/


	static int ali_notify_sys(struct notifier_block this, unsigned long code, void unused)		static int ali_notify_sys(struct notifier_block *this,
			unsigned long code, void *unused)
	{		{
	if (code==SYS_DOWN \|\| code==SYS_HALT) {		if (code == SYS_DOWN \|\| code == SYS_HALT)
	/* Turn the WDT off */		ali_stop(); /* Turn the WDT off */
	ali_stop();
	}

	return NOTIFY_DONE;		return NOTIFY_DONE;
	}		}

	@@ -355,9 +346,12 @@ static int __init ali_find_watchdog(void)
	*/		*/
	pci_read_config_dword(pdev, 0xCC, &wdog);		pci_read_config_dword(pdev, 0xCC, &wdog);

	wdog &= ~0x3F; /* Timer bits */		/* Timer bits */
	wdog &= ~((1<<27)\|(1<<26)\|(1<<25)\|(1<<24)); /* Issued events */		wdog &= ~0x3F;
	wdog &= ~((1<<16)\|(1<<13)\|(1<<12)\|(1<<11)\|(1<<10)\|(1<<9)); /* No monitor bits */		/* Issued events */
			wdog &= ~((1<<27)\|(1<<26)\|(1<<25)\|(1<<24));
			/* No monitor bits */
			wdog &= ~((1<<16)\|(1<<13)\|(1<<12)\|(1<<11)\|(1<<10)\|(1<<9));

	pci_write_config_dword(pdev, 0xCC, wdog);		pci_write_config_dword(pdev, 0xCC, wdog);

	@@ -372,7 +366,7 @@ static const struct file_operations ali_fops = {
	.owner = THIS_MODULE,		.owner = THIS_MODULE,
	.llseek = no_llseek,		.llseek = no_llseek,
	.write = ali_write,		.write = ali_write,
	.ioctl = ali_ioctl,		.unlocked_ioctl = ali_ioctl,
	.open = ali_open,		.open = ali_open,
	.release = ali_release,		.release = ali_release,
	};		};
	@@ -399,14 +393,15 @@ static int __init watchdog_init(void)
	int ret;		int ret;

	/* Check whether or not the hardware watchdog is there */		/* Check whether or not the hardware watchdog is there */
	if (ali_find_watchdog() != 0) {		if (ali_find_watchdog() != 0)
	return -ENODEV;		return -ENODEV;
	}

	/* Check that the timeout value is within it's range ; if not reset to the default */		/* Check that the timeout value is within it's range;
			if not reset to the default */
	if (timeout < 1 \|\| timeout >= 18000) {		if (timeout < 1 \|\| timeout >= 18000) {
	timeout = WATCHDOG_TIMEOUT;		timeout = WATCHDOG_TIMEOUT;
	printk(KERN_INFO PFX "timeout value must be 0<timeout<18000, using %d\n",		printk(KERN_INFO PFX
			"timeout value must be 0 < timeout < 18000, using %d\n",
	timeout);		timeout);
	}		}

	@@ -415,14 +410,15 @@ static int __init watchdog_init(void)

	ret = register_reboot_notifier(&ali_notifier);		ret = register_reboot_notifier(&ali_notifier);
	if (ret != 0) {		if (ret != 0) {
	printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",		printk(KERN_ERR PFX
	ret);		"cannot register reboot notifier (err=%d)\n", ret);
	goto out;		goto out;
	}		}

	ret = misc_register(&ali_miscdev);		ret = misc_register(&ali_miscdev);
	if (ret != 0) {		if (ret != 0) {
	printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",		printk(KERN_ERR PFX
			"cannot register miscdev on minor=%d (err=%d)\n",
	WATCHDOG_MINOR, ret);		WATCHDOG_MINOR, ret);
	goto unreg_reboot;		goto unreg_reboot;
	}		}

drivers/watchdog/alim7101_wdt.c

+118 −106

Original line number	Original line	Diff line number	Diff line
	@@ -32,8 +32,8 @@
	#include <linux/fs.h>		#include <linux/fs.h>
	#include <linux/pci.h>		#include <linux/pci.h>

	#include <asm/io.h>		#include <linux/io.h>
	#include <asm/uaccess.h>		#include <linux/uaccess.h>
	#include <asm/system.h>		#include <asm/system.h>

	#define OUR_NAME "alim7101_wdt"		#define OUR_NAME "alim7101_wdt"
	@@ -60,13 +60,17 @@
	*/		*/

	#define WATCHDOG_TIMEOUT 30 /* 30 sec default timeout */		#define WATCHDOG_TIMEOUT 30 /* 30 sec default timeout */
	static int timeout = WATCHDOG_TIMEOUT; /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */		/* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
			static int timeout = WATCHDOG_TIMEOUT;
	module_param(timeout, int, 0);		module_param(timeout, int, 0);
	MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");		MODULE_PARM_DESC(timeout,
			"Watchdog timeout in seconds. (1<=timeout<=3600, default="
			__MODULE_STRING(WATCHDOG_TIMEOUT) ")");

	static int use_gpio = 0; /* Use the pic (for a1d revision alim7101) */		static int use_gpio; /* Use the pic (for a1d revision alim7101) */
	module_param(use_gpio, int, 0);		module_param(use_gpio, int, 0);
	MODULE_PARM_DESC(use_gpio, "Use the gpio watchdog. (required by old cobalt boards)");		MODULE_PARM_DESC(use_gpio,
			"Use the gpio watchdog (required by old cobalt boards).");

	static void wdt_timer_ping(unsigned long);		static void wdt_timer_ping(unsigned long);
	static DEFINE_TIMER(timer, wdt_timer_ping, 0, 1);		static DEFINE_TIMER(timer, wdt_timer_ping, 0, 1);
	@@ -77,7 +81,8 @@ static struct pci_dev *alim7101_pmu;

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

	/*		/*
	@@ -91,21 +96,24 @@ static void wdt_timer_ping(unsigned long data)
	*/		*/
	char tmp;		char tmp;

	if(time_before(jiffies, next_heartbeat))		if (time_before(jiffies, next_heartbeat)) {
	{
	/* Ping the WDT (this is actually a disarm/arm sequence) */		/* Ping the WDT (this is actually a disarm/arm sequence) */
	pci_read_config_byte(alim7101_pmu, 0x92, &tmp);		pci_read_config_byte(alim7101_pmu, 0x92, &tmp);
	pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));		pci_write_config_byte(alim7101_pmu,
	pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp \| ALI_WDT_ARM));		ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));
			pci_write_config_byte(alim7101_pmu,
			ALI_7101_WDT, (tmp \| ALI_WDT_ARM));
	if (use_gpio) {		if (use_gpio) {
	pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);		pci_read_config_byte(alim7101_pmu,
	pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp		ALI_7101_GPIO_O, &tmp);
	\| 0x20);		pci_write_config_byte(alim7101_pmu,
	pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp		ALI_7101_GPIO_O, tmp \| 0x20);
	& ~0x20);		pci_write_config_byte(alim7101_pmu,
			ALI_7101_GPIO_O, tmp & ~0x20);
	}		}
	} else {		} else {
	printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");		printk(KERN_WARNING PFX
			"Heartbeat lost! Will not ping the watchdog\n");
	}		}
	/* Re-set the timer interval */		/* Re-set the timer interval */
	mod_timer(&timer, jiffies + WDT_INTERVAL);		mod_timer(&timer, jiffies + WDT_INTERVAL);
	@@ -121,17 +129,23 @@ static void wdt_change(int writeval)

	pci_read_config_byte(alim7101_pmu, ALI_7101_WDT, &tmp);		pci_read_config_byte(alim7101_pmu, ALI_7101_WDT, &tmp);
	if (writeval == WDT_ENABLE) {		if (writeval == WDT_ENABLE) {
	pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp \| ALI_WDT_ARM));		pci_write_config_byte(alim7101_pmu,
			ALI_7101_WDT, (tmp \| ALI_WDT_ARM));
	if (use_gpio) {		if (use_gpio) {
	pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);		pci_read_config_byte(alim7101_pmu,
	pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp & ~0x20);		ALI_7101_GPIO_O, &tmp);
			pci_write_config_byte(alim7101_pmu,
			ALI_7101_GPIO_O, tmp & ~0x20);
	}		}

	} else {		} else {
	pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));		pci_write_config_byte(alim7101_pmu,
			ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));
	if (use_gpio) {		if (use_gpio) {
	pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);		pci_read_config_byte(alim7101_pmu,
	pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp \| 0x20);		ALI_7101_GPIO_O, &tmp);
			pci_write_config_byte(alim7101_pmu,
			ALI_7101_GPIO_O, tmp \| 0x20);
	}		}
	}		}
	}		}
	@@ -169,7 +183,8 @@ static void wdt_keepalive(void)
	* /dev/watchdog handling		* /dev/watchdog handling
	*/		*/

	static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos)		static ssize_t fop_write(struct file file, const char __user buf,
			size_t count, loff_t *ppos)
	{		{
	/* See if we got the magic character 'V' and reload the timer */		/* See if we got the magic character 'V' and reload the timer */
	if (count) {		if (count) {
	@@ -211,26 +226,26 @@ static int fop_close(struct inode * inode, struct file * file)
	wdt_turnoff();		wdt_turnoff();
	else {		else {
	/* wim: shouldn't there be a: del_timer(&timer); */		/* wim: shouldn't there be a: del_timer(&timer); */
	printk(KERN_CRIT PFX "device file closed unexpectedly. Will not stop the WDT!\n");		printk(KERN_CRIT PFX
			"device file closed unexpectedly. Will not stop the WDT!\n");
	}		}
	clear_bit(0, &wdt_is_open);		clear_bit(0, &wdt_is_open);
	wdt_expect_close = 0;		wdt_expect_close = 0;
	return 0;		return 0;
	}		}

	static int fop_ioctl(struct inode inode, struct file file, unsigned int cmd, unsigned long arg)		static long fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	{		{
	void __user argp = (void __user )arg;		void __user argp = (void __user )arg;
	int __user *p = argp;		int __user *p = argp;
	static struct watchdog_info ident =		static struct watchdog_info ident = {
	{		.options = WDIOF_KEEPALIVEPING \| WDIOF_SETTIMEOUT
	.options = WDIOF_KEEPALIVEPING \| WDIOF_SETTIMEOUT \| WDIOF_MAGICCLOSE,		\| WDIOF_MAGICCLOSE,
	.firmware_version = 1,		.firmware_version = 1,
	.identity = "ALiM7101",		.identity = "ALiM7101",
	};		};

	switch(cmd)		switch (cmd) {
	{
	case WDIOC_GETSUPPORT:		case WDIOC_GETSUPPORT:
	return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;		return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
	case WDIOC_GETSTATUS:		case WDIOC_GETSTATUS:
	@@ -245,17 +260,14 @@ static int fop_ioctl(struct inode inode, struct file file, unsigned int cmd, u

	if (get_user(new_options, p))		if (get_user(new_options, p))
	return -EFAULT;		return -EFAULT;

	if (new_options & WDIOS_DISABLECARD) {		if (new_options & WDIOS_DISABLECARD) {
	wdt_turnoff();		wdt_turnoff();
	retval = 0;		retval = 0;
	}		}

	if (new_options & WDIOS_ENABLECARD) {		if (new_options & WDIOS_ENABLECARD) {
	wdt_startup();		wdt_startup();
	retval = 0;		retval = 0;
	}		}

	return retval;		return retval;
	}		}
	case WDIOC_SETTIMEOUT:		case WDIOC_SETTIMEOUT:
	@@ -264,10 +276,9 @@ static int fop_ioctl(struct inode inode, struct file file, unsigned int cmd, u

	if (get_user(new_timeout, p))		if (get_user(new_timeout, p))
	return -EFAULT;		return -EFAULT;
			/* arbitrary upper limit */
	if(new_timeout < 1 \|\| new_timeout > 3600) /* arbitrary upper limit */		if (new_timeout < 1 \|\| new_timeout > 3600)
	return -EINVAL;		return -EINVAL;

	timeout = new_timeout;		timeout = new_timeout;
	wdt_keepalive();		wdt_keepalive();
	/* Fall through */		/* Fall through */
	@@ -285,7 +296,7 @@ static const struct file_operations wdt_fops = {
	.write = fop_write,		.write = fop_write,
	.open = fop_open,		.open = fop_open,
	.release = fop_close,		.release = fop_close,
	.ioctl= fop_ioctl,		.unlocked_ioctl = fop_ioctl,
	};		};

	static struct miscdevice wdt_miscdev = {		static struct miscdevice wdt_miscdev = {
	@@ -298,16 +309,17 @@ static struct miscdevice wdt_miscdev = {
	* Notifier for system down		* Notifier for system down
	*/		*/

	static int wdt_notify_sys(struct notifier_block this, unsigned long code, void unused)		static int wdt_notify_sys(struct notifier_block *this,
			unsigned long code, void *unused)
	{		{
	if (code == SYS_DOWN \|\| code == SYS_HALT)		if (code == SYS_DOWN \|\| code == SYS_HALT)
	wdt_turnoff();		wdt_turnoff();

	if (code == SYS_RESTART) {		if (code == SYS_RESTART) {
	/*		/*
	* Cobalt devices have no way of rebooting themselves other than		* Cobalt devices have no way of rebooting themselves other
	* getting the watchdog to pull reset, so we restart the watchdog on		* than getting the watchdog to pull reset, so we restart the
	* reboot with no heartbeat		* watchdog on reboot with no heartbeat
	*/		*/
	wdt_change(WDT_ENABLE);		wdt_change(WDT_ENABLE);
	printk(KERN_INFO PFX "Watchdog timer is now enabled with no heartbeat - should reboot in ~1 second.\n");		printk(KERN_INFO PFX "Watchdog timer is now enabled with no heartbeat - should reboot in ~1 second.\n");
	@@ -320,8 +332,7 @@ static int wdt_notify_sys(struct notifier_block *this, unsigned long code, void
	* turn the timebomb registers off.		* turn the timebomb registers off.
	*/		*/

	static struct notifier_block wdt_notifier=		static struct notifier_block wdt_notifier = {
	{
	.notifier_call = wdt_notify_sys,		.notifier_call = wdt_notify_sys,
	};		};

	@@ -354,7 +365,8 @@ static int __init alim7101_wdt_init(void)
	ali1543_south = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,		ali1543_south = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
	NULL);		NULL);
	if (!ali1543_south) {		if (!ali1543_south) {
	printk(KERN_INFO PFX "ALi 1543 South-Bridge not present - WDT not set\n");		printk(KERN_INFO PFX
			"ALi 1543 South-Bridge not present - WDT not set\n");
	goto err_out;		goto err_out;
	}		}
	pci_read_config_byte(ali1543_south, 0x5e, &tmp);		pci_read_config_byte(ali1543_south, 0x5e, &tmp);
	@@ -370,17 +382,18 @@ static int __init alim7101_wdt_init(void)
	goto err_out;		goto err_out;
	}		}

	if(timeout < 1 \|\| timeout > 3600) /* arbitrary upper limit */		if (timeout < 1 \|\| timeout > 3600) {
	{		/* arbitrary upper limit */
	timeout = WATCHDOG_TIMEOUT;		timeout = WATCHDOG_TIMEOUT;
	printk(KERN_INFO PFX "timeout value must be 1<=x<=3600, using %d\n",		printk(KERN_INFO PFX
			"timeout value must be 1 <= x <= 3600, using %d\n",
	timeout);		timeout);
	}		}

	rc = register_reboot_notifier(&wdt_notifier);		rc = register_reboot_notifier(&wdt_notifier);
	if (rc) {		if (rc) {
	printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",		printk(KERN_ERR PFX
	rc);		"cannot register reboot notifier (err=%d)\n", rc);
	goto err_out;		goto err_out;
	}		}

	@@ -391,9 +404,8 @@ static int __init alim7101_wdt_init(void)
	goto err_out_reboot;		goto err_out_reboot;
	}		}

	if (nowayout) {		if (nowayout)
	__module_get(THIS_MODULE);		__module_get(THIS_MODULE);
	}

	printk(KERN_INFO PFX "WDT driver for ALi M7101 initialised. timeout=%d sec (nowayout=%d)\n",		printk(KERN_INFO PFX "WDT driver for ALi M7101 initialised. timeout=%d sec (nowayout=%d)\n",
	timeout, nowayout);		timeout, nowayout);

drivers/watchdog/at32ap700x_wdt.c

+3 −4

Original line number	Original line	Diff line number	Diff line
	@@ -212,7 +212,7 @@ static struct watchdog_info at32_wdt_info = {
	/*		/*
	* Handle commands from user-space.		* Handle commands from user-space.
	*/		*/
	static int at32_wdt_ioctl(struct inode inode, struct file file,		static long at32_wdt_ioctl(struct file *file,
	unsigned int cmd, unsigned long arg)		unsigned int cmd, unsigned long arg)
	{		{
	int ret = -ENOTTY;		int ret = -ENOTTY;
	@@ -298,7 +298,7 @@ static ssize_t at32_wdt_write(struct file file, const char __user data,
	static const struct file_operations at32_wdt_fops = {		static const struct file_operations at32_wdt_fops = {
	.owner = THIS_MODULE,		.owner = THIS_MODULE,
	.llseek = no_llseek,		.llseek = no_llseek,
	.ioctl = at32_wdt_ioctl,		.unlocked_ioctl = at32_wdt_ioctl,
	.open = at32_wdt_open,		.open = at32_wdt_open,
	.release = at32_wdt_close,		.release = at32_wdt_close,
	.write = at32_wdt_write,		.write = at32_wdt_write,
	@@ -391,7 +391,6 @@ static int __exit at32_wdt_remove(struct platform_device *pdev)
	wdt = NULL;		wdt = NULL;
	platform_set_drvdata(pdev, NULL);		platform_set_drvdata(pdev, NULL);
	}		}

	return 0;		return 0;
	}		}