Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 96e2e6fa authored by Wim Van Sebroeck's avatar Wim Van Sebroeck
Browse files

[WATCHDOG] Merge code clean-up's from Alan Cox. 



Merge branch 'alan' of ../linux-2.6-watchdog-mm
Fixed Conflicts in the following files:
	drivers/watchdog/booke_wdt.c
	drivers/watchdog/mpc5200_wdt.c
	drivers/watchdog/sc1200wdt.c

Signed-off-by: default avatarAlan Cox <alan@redhat.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarWim Van Sebroeck <wim@iguana.be>
parents 0967d61e 7c4be5aa

drivers/watchdog/acquirewdt.c

+58 −61
Original line number Diff line number Diff line
@@ -58,39 +58,46 @@ 
#include <linux/types.h>		/* For standard types (like size_t) */

#include <linux/errno.h>		/* For the -ENODEV/... values */

#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/fs.h>			/* For file operations */

#include <linux/ioport.h>		/* For io-port access */

#include <linux/platform_device.h>	/* For platform_driver framework */

#include <linux/init.h>			/* For __init/__exit/... */



#include <asm/uaccess.h>		/* For copy_to_user/put_user/... */

#include <asm/io.h>			/* For inb/outb/... */

#include <linux/uaccess.h>		/* For copy_to_user/put_user/... */

#include <linux/io.h>			/* For inb/outb/... */



/* Module information */

#define DRV_NAME "acquirewdt"

#define PFX DRV_NAME ": "

#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 */

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 char expect_close;



/* 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_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_PARM_DESC(wdt_start, "Acquire WDT 'start' io port (default 0x443)");



static int nowayout = WATCHDOG_NOWAYOUT;

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
@@ -112,18 +119,18 @@ static void acq_stop(void) 
 *	/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 */

	if (count) {

		if (!nowayout) {

			size_t i;



			/* note: just in case someone wrote the magic character

			 * five months ago... */

			expect_close = 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 != count; i++) {

				char c;

				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;

			}

		}



		/* Well, anyhow someone wrote to us, we should return that favour */

		/* Well, anyhow someone wrote to us, we should

				return that favour */

		acq_keepalive();

	}

	return count;

}



static int acq_ioctl(struct inode *inode, struct file *file, unsigned int cmd,

	unsigned long arg)

static long acq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

{

	int options, retval = -EINVAL;

	void __user *argp = (void __user *)arg;

	int __user *p = argp;

	static struct watchdog_info ident =

	{

	static struct watchdog_info ident = {

		.options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,

		.firmware_version = 1,

		.identity = WATCHDOG_NAME,

	};



	switch(cmd)

	{

	switch (cmd) {

	case WDIOC_GETSUPPORT:

		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))

			return -EFAULT;



	    if (options & WDIOS_DISABLECARD)

	    {

		if (options & WDIOS_DISABLECARD) {

			acq_stop();

			retval = 0;

		}



	    if (options & WDIOS_ENABLECARD)

	    {

		if (options & WDIOS_ENABLECARD) {

			acq_keepalive();

			retval = 0;

		}



		return retval;

	}



	default:

		return -ENOTTY;

	}
@@ -211,7 +209,8 @@ static int acq_close(struct inode *inode, struct file *file) 
	if (expect_close == 42) {

		acq_stop();

	} else {

		printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");

		printk(KERN_CRIT PFX

			"Unexpected close, not stopping watchdog!\n");

		acq_keepalive();

	}

	clear_bit(0, &acq_is_open);
@@ -227,7 +226,7 @@ static const struct file_operations acq_fops = { 
	.owner		= THIS_MODULE,

	.llseek		= no_llseek,

	.write		= acq_write,

	.ioctl		= acq_ioctl,

	.unlocked_ioctl	= acq_ioctl,

	.open		= acq_open,

	.release	= acq_close,

};
@@ -248,8 +247,8 @@ static int __devinit acq_probe(struct platform_device *dev) 


	if (wdt_stop != wdt_start) {

		if (!request_region(wdt_stop, 1, WATCHDOG_NAME)) {

			printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",

				wdt_stop);

			printk(KERN_ERR PFX

			    "I/O address 0x%04x already in use\n", wdt_stop);

			ret = -EIO;

			goto out;

		}
@@ -261,19 +260,16 @@ static int __devinit acq_probe(struct platform_device *dev) 
		ret = -EIO;

		goto unreg_stop;

	}



	ret = misc_register(&acq_miscdev);

	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);

		goto unreg_regions;

	}



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

		nowayout);

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



	return 0;



unreg_regions:

	release_region(wdt_start, 1);

unreg_stop:
@@ -313,18 +309,19 @@ static int __init acq_init(void) 
{

	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);

	if (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)) {

		err = PTR_ERR(acq_platform_device);

		goto unreg_platform_driver;

	}



	return 0;



unreg_platform_driver:

drivers/watchdog/advantechwdt.c

+62 −73
Original line number 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 */

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;

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

 */



static void

advwdt_ping(void)

static void advwdt_ping(void)

{

	/* Write a watchdog value */

	outb_p(timeout, wdt_start);

}



static void

advwdt_disable(void)

static void advwdt_disable(void)

{

	inb_p(wdt_stop);

}



static int

advwdt_set_heartbeat(int t)

static int advwdt_set_heartbeat(int t)

{

	if ((t < 1) || (t > 63))

	if (t < 1 || t > 63)

		return -EINVAL;



	timeout = t;

	return 0;

}
@@ -109,8 +109,8 @@ advwdt_set_heartbeat(int t) 
 *	/dev/watchdog handling

 */



static ssize_t

advwdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)

static ssize_t advwdt_write(struct file *file, const char __user *buf,

						size_t count, loff_t *ppos)

{

	if (count) {

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

}



static int

advwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,

	  unsigned long arg)

static long advwdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

{

	int new_timeout;

	void __user *argp = (void __user *)arg;
@@ -165,38 +163,31 @@ advwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 
			return -EINVAL;

		advwdt_ping();

		/* Fall */



	case WDIOC_GETTIMEOUT:

		return put_user(timeout, p);



	case WDIOC_SETOPTIONS:

	{

		int options, retval = -EINVAL;



		if (get_user(options, p))

			return -EFAULT;



		if (options & WDIOS_DISABLECARD) {

			advwdt_disable();

			retval = 0;

		}



		if (options & WDIOS_ENABLECARD) {

			advwdt_ping();

			retval = 0;

		}



		return retval;

	}



	default:

		return -ENOTTY;

	}

	return 0;

}



static int

advwdt_open(struct inode *inode, struct file *file)

static int advwdt_open(struct inode *inode, struct file *file)

{

	if (test_and_set_bit(0, &advwdt_is_open))

		return -EBUSY;
@@ -214,7 +205,8 @@ advwdt_close(struct inode *inode, struct file *file) 
	if (adv_expect_close == 42) {

		advwdt_disable();

	} else {

		printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");

		printk(KERN_CRIT PFX

				"Unexpected close, not stopping watchdog!\n");

		advwdt_ping();

	}

	clear_bit(0, &advwdt_is_open);
@@ -230,7 +222,7 @@ static const struct file_operations advwdt_fops = { 
	.owner		= THIS_MODULE,

	.llseek		= no_llseek,

	.write		= advwdt_write,

	.ioctl		= advwdt_ioctl,

	.unlocked_ioctl	= advwdt_ioctl,

	.open		= advwdt_open,

	.release	= advwdt_close,

};
@@ -245,14 +237,14 @@ static struct miscdevice advwdt_miscdev = { 
 *	Init & exit routines

 */



static int __devinit

advwdt_probe(struct platform_device *dev)

static int __devinit advwdt_probe(struct platform_device *dev)

{

	int ret;



	if (wdt_stop != wdt_start) {

		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);

			ret = -EIO;

			goto out;
@@ -260,7 +252,8 @@ advwdt_probe(struct platform_device *dev) 
	}



	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);

		ret = -EIO;

		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 */

	if (advwdt_set_heartbeat(timeout)) {

		advwdt_set_heartbeat(WATCHDOG_TIMEOUT);

		printk (KERN_INFO PFX "timeout value must be 1<=x<=63, using %d\n",

			timeout);

		printk(KERN_INFO PFX

			"timeout value must be 1<=x<=63, using %d\n", timeout);

	}



	ret = misc_register(&advwdt_miscdev);

	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);

		goto unreg_regions;

	}



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

		timeout, nowayout);



out:

	return ret;

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

}



static int __devexit

advwdt_remove(struct platform_device *dev)

static int __devexit advwdt_remove(struct platform_device *dev)

{

	misc_deregister(&advwdt_miscdev);

	release_region(wdt_start,1);
@@ -304,8 +295,7 @@ advwdt_remove(struct platform_device *dev) 
	return 0;

}



static void

advwdt_shutdown(struct platform_device *dev)

static void advwdt_shutdown(struct platform_device *dev)

{

	/* Turn the WDT off if we have a soft shutdown */

	advwdt_disable();
@@ -321,8 +311,7 @@ static struct platform_driver advwdt_driver = { 
	},

};



static int __init

advwdt_init(void)

static int __init advwdt_init(void)

{

	int err;
@@ -332,7 +321,8 @@ advwdt_init(void) 
	if (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)) {

		err = PTR_ERR(advwdt_platform_device);

		goto unreg_platform_driver;
@@ -345,8 +335,7 @@ advwdt_init(void) 
	return err;

}



static void __exit

advwdt_exit(void)

static void __exit advwdt_exit(void)

{

	platform_device_unregister(advwdt_platform_device);

	platform_driver_unregister(&advwdt_driver);

drivers/watchdog/alim1535_wdt.c

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

#include <linux/pci.h>



#include <asm/uaccess.h>

#include <asm/io.h>

#include <linux/uaccess.h>

#include <linux/io.h>



#define WATCHDOG_NAME "ALi_M1535"

#define PFX WATCHDOG_NAME ": "
@@ -36,11 +36,15 @@ static DEFINE_SPINLOCK(ali_lock); /* Guards the hardware */ 
/* module parameters */

static int timeout = WATCHDOG_TIMEOUT;

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;

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
@@ -111,7 +115,8 @@ static int ali_settimer(int t) 
		ali_timeout_bits = (t/60)|(1<<7);

	else if (t < 18000)

		ali_timeout_bits = (t/300)|(1<<6)|(1<<7);

	else return -EINVAL;

	else

		return -EINVAL;



	timeout = t;

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

			size_t i;



			/* note: just in case someone wrote the magic character

			 * five months ago... */

			/* note: just in case someone wrote the

			   magic character five months ago... */

			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++) {

				char c;

				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

 *	@inode: VFS inode

 *	@file: VFS file pointer

 *	@cmd: ioctl number

 *	@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

 */



static int ali_ioctl(struct inode *inode, struct file *file,

			  unsigned int cmd, unsigned long arg)

static long ali_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

{

	void __user *argp = (void __user *)arg;

	int __user *p = argp;
@@ -187,54 +191,42 @@ static int ali_ioctl(struct inode *inode, struct file *file, 


	switch (cmd) {

	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_GETBOOTSTATUS:

		return put_user(0, p);



	case WDIOC_KEEPALIVE:

		ali_keepalive();

		return 0;



	case WDIOC_SETOPTIONS:

	{

		int new_options, retval = -EINVAL;



		if (get_user(new_options, p))

			return -EFAULT;



		if (new_options & WDIOS_DISABLECARD) {

			ali_stop();

			retval = 0;

		}



		if (new_options & WDIOS_ENABLECARD) {

			ali_start();

			retval = 0;

		}



		return retval;

	}



	case WDIOC_SETTIMEOUT:

	{

		int new_timeout;



		if (get_user(new_timeout, p))

			return -EFAULT;



		if (ali_settimer(new_timeout))

			return -EINVAL;



		ali_keepalive();

		/* Fall */

	}



	case WDIOC_GETTIMEOUT:

		return put_user(timeout, p);



	default:

		return -ENOTTY;

	}
@@ -274,10 +266,11 @@ static int ali_release(struct inode *inode, struct file *file) 
	/*

	 *      Shut off the timer.

	 */

	if (ali_expect_release == 42) {

	if (ali_expect_release == 42)

		ali_stop();

	} else {

		printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");

	else {

		printk(KERN_CRIT PFX

				"Unexpected close, not stopping watchdog!\n");

		ali_keepalive();

	}

	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) {

		/* Turn the WDT off */

		ali_stop();

	}



	if (code == SYS_DOWN || code == SYS_HALT)

		ali_stop();		/* Turn the WDT off */

	return NOTIFY_DONE;

}
@@ -355,9 +346,12 @@ static int __init ali_find_watchdog(void) 
	 */

	pci_read_config_dword(pdev, 0xCC, &wdog);



	wdog &= ~0x3F;		/* Timer bits */

	wdog &= ~((1<<27)|(1<<26)|(1<<25)|(1<<24));	/* Issued events */

	wdog &= ~((1<<16)|(1<<13)|(1<<12)|(1<<11)|(1<<10)|(1<<9));	/* No monitor bits */

	/* Timer bits */

	wdog &= ~0x3F;

	/* 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);
@@ -372,7 +366,7 @@ static const struct file_operations ali_fops = { 
	.owner 		=	THIS_MODULE,

	.llseek 	=	no_llseek,

	.write		=	ali_write,

	.ioctl =	ali_ioctl,

	.unlocked_ioctl =	ali_ioctl,

	.open 		=	ali_open,

	.release 	=	ali_release,

};
@@ -399,14 +393,15 @@ static int __init watchdog_init(void) 
	int ret;



	/* Check whether or not the hardware watchdog is there */

	if (ali_find_watchdog() != 0) {

	if (ali_find_watchdog() != 0)

		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) {

		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);

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


	ret = register_reboot_notifier(&ali_notifier);

	if (ret != 0) {

		printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",

			ret);

		printk(KERN_ERR PFX

			"cannot register reboot notifier (err=%d)\n", ret);

		goto out;

	}



	ret = misc_register(&ali_miscdev);

	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);

		goto unreg_reboot;

	}

drivers/watchdog/alim7101_wdt.c

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

#include <linux/pci.h>



#include <asm/io.h>

#include <asm/uaccess.h>

#include <linux/io.h>

#include <linux/uaccess.h>

#include <asm/system.h>



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



#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_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_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 DEFINE_TIMER(timer, wdt_timer_ping, 0, 1);
@@ -77,7 +81,8 @@ static struct pci_dev *alim7101_pmu; 


static int nowayout = WATCHDOG_NOWAYOUT;

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) ")");



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

	char tmp;



	if(time_before(jiffies, next_heartbeat))

	{

	if (time_before(jiffies, next_heartbeat)) {

		/* Ping the WDT (this is actually a disarm/arm sequence) */

		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, ALI_7101_WDT, (tmp | ALI_WDT_ARM));

		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) {

			pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);

			pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp

					| 0x20);

			pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp

					& ~0x20);

			pci_read_config_byte(alim7101_pmu,

					ALI_7101_GPIO_O, &tmp);

			pci_write_config_byte(alim7101_pmu,

					ALI_7101_GPIO_O, tmp | 0x20);

			pci_write_config_byte(alim7101_pmu,

					ALI_7101_GPIO_O, tmp & ~0x20);

		}

	} 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 */

	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);

	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) {

			pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);

			pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp & ~0x20);

			pci_read_config_byte(alim7101_pmu,

					ALI_7101_GPIO_O, &tmp);

			pci_write_config_byte(alim7101_pmu,

					ALI_7101_GPIO_O, tmp & ~0x20);

		}



	} 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) {

			pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);

			pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp | 0x20);

			pci_read_config_byte(alim7101_pmu,

					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

 */



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 */

	if (count) {
@@ -211,26 +226,26 @@ static int fop_close(struct inode * inode, struct file * file) 
		wdt_turnoff();

	else {

		/* 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);

	wdt_expect_close = 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;

	int __user *p = argp;

	static struct watchdog_info ident =

	{

		.options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,

	static struct watchdog_info ident = {

		.options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT

							| WDIOF_MAGICCLOSE,

		.firmware_version = 1,

		.identity = "ALiM7101",

	};



	switch(cmd)

	{

	switch (cmd) {

	case WDIOC_GETSUPPORT:

		return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;

	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))

			return -EFAULT;



		if (new_options & WDIOS_DISABLECARD) {

			wdt_turnoff();

			retval = 0;

		}



		if (new_options & WDIOS_ENABLECARD) {

			wdt_startup();

			retval = 0;

		}



		return retval;

	}

	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))

			return -EFAULT;



			if(new_timeout < 1 || new_timeout > 3600) /* arbitrary upper limit */

		/* arbitrary upper limit */

		if (new_timeout < 1 || new_timeout > 3600)

			return -EINVAL;



		timeout = new_timeout;

		wdt_keepalive();

		/* Fall through */
@@ -285,7 +296,7 @@ static const struct file_operations wdt_fops = { 
	.write		=	fop_write,

	.open		=	fop_open,

	.release	=	fop_close,

	.ioctl=		fop_ioctl,

	.unlocked_ioctl	=	fop_ioctl,

};



static struct miscdevice wdt_miscdev = {
@@ -298,16 +309,17 @@ static struct miscdevice wdt_miscdev = { 
 *	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)

		wdt_turnoff();



	if (code == SYS_RESTART) {

		/*

		 * Cobalt devices have no way of rebooting themselves other than

		 * getting the watchdog to pull reset, so we restart the watchdog on

		 * reboot with no heartbeat

		 * Cobalt devices have no way of rebooting themselves other

		 * than getting the watchdog to pull reset, so we restart the

		 * watchdog on reboot with no heartbeat

		 */

		wdt_change(WDT_ENABLE);

		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.

 */



static struct notifier_block wdt_notifier=

{

static struct notifier_block wdt_notifier = {

	.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,

		NULL);

	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;

	}

	pci_read_config_byte(ali1543_south, 0x5e, &tmp);
@@ -370,17 +382,18 @@ static int __init alim7101_wdt_init(void) 
		goto err_out;

	}



	if(timeout < 1 || timeout > 3600) /* arbitrary upper limit */

	{

	if (timeout < 1 || timeout > 3600) {

		/* arbitrary upper limit */

		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);

	}



	rc = register_reboot_notifier(&wdt_notifier);

	if (rc) {

		printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",

			rc);

		printk(KERN_ERR PFX

			"cannot register reboot notifier (err=%d)\n", rc);

		goto err_out;

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

	}



	if (nowayout) {

	if (nowayout)

		__module_get(THIS_MODULE);

	}



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

		timeout, nowayout);

drivers/watchdog/at32ap700x_wdt.c

+3 −4
Original line number Diff line number Diff line
@@ -212,7 +212,7 @@ static struct watchdog_info at32_wdt_info = { 
/*

 * 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)

{

	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 = {

	.owner		= THIS_MODULE,

	.llseek		= no_llseek,

	.ioctl		= at32_wdt_ioctl,

	.unlocked_ioctl	= at32_wdt_ioctl,

	.open		= at32_wdt_open,

	.release	= at32_wdt_close,

	.write		= at32_wdt_write,
@@ -391,7 +391,6 @@ static int __exit at32_wdt_remove(struct platform_device *pdev) 
		wdt = NULL;

		platform_set_drvdata(pdev, NULL);

	}



	return 0;

}