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

Commit b588e2bb authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog 

* git://git.kernel.org/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog: (70 commits)
  [WATCHDOG] more coding style clean-up's
  [WATCHDOG] sbc8360.c - move stop code into a function
  [WATCHDOG] Coding style - Indentation - part 2
  [WATCHDOG] Coding style - Indentation - part 1
  [WATCHDOG] mpc8xxx_wdt: add support for MPC8xx watchdogs
  [WATCHDOG] mpc8xxx_wdt: fix build
  [WATCHDOG] mpc8xxx_wdt: various renames, mostly s/mpc83xx/mpc8xxx/g
  [WATCHDOG] mpc83xx_wdt: rename to mpc8xxx_wdt
  [WATCHDOG] mpc83xx_wdt: add support for MPC86xx CPUs
  [WATCHDOG] mpc83xx_wdt: convert to the OF platform driver
  [WATCHDOG] pcwd: a couple of watchdogs escaped conversion
  [WATCHDOG] Clean-up includes
  [WATCHDOG] hpwdt.c - fix double includes
  [WATCHDOG 57/57] wdt501/pci: Clean up, coding style and switch to unlocked_ioctl
  [WATCHDOG 56/57] wdt977: clean up, coding style and switch to unlocked_ioctl
  [WATCHDOG 55/57] wdt285: switch to unlocked_ioctl and tidy up oddments of coding style
  [WATCHDOG 54/57] wdrtas: clean up, coding style, switch to unlocked_ioctl
  [WATCHDOG 53/57] wafer5823wdt: Clean up, coding style, switch to unlocked_ioctl
  [WATCHDOG 52/57] w83977f_wdt: clean up, coding style and switch to unlocked_ioctl
  [WATCHDOG 51/57] w83877f_wdt: clean up code, coding style, switch to unlocked_ioctl
  ...
parents 3df302ff 7944d3a5

drivers/watchdog/Kconfig

+12 −4
Original line number Diff line number Diff line
@@ -695,9 +695,17 @@ config 8xx_WDT 
	tristate "MPC8xx Watchdog Timer"

	depends on 8xx



config 83xx_WDT

	tristate "MPC83xx Watchdog Timer"

	depends on PPC_83xx

config 8xxx_WDT

	tristate "MPC8xxx Platform Watchdog Timer"

	depends on PPC_8xx || PPC_83xx || PPC_86xx

	help

	  This driver is for a SoC level watchdog that exists on some

	  Freescale PowerPC processors. So far this driver supports:

	  - MPC8xx watchdogs

	  - MPC83xx watchdogs

	  - MPC86xx watchdogs



	  For BookE processors (MPC85xx) use the BOOKE_WDT driver instead.



config MV64X60_WDT

	tristate "MV64X60 (Marvell Discovery) Watchdog Timer"

drivers/watchdog/Makefile

+2 −2
Original line number Diff line number Diff line
@@ -103,7 +103,7 @@ obj-$(CONFIG_TXX9_WDT) += txx9wdt.o 
# POWERPC Architecture

obj-$(CONFIG_8xx_WDT) += mpc8xx_wdt.o

obj-$(CONFIG_MPC5200_WDT) += mpc5200_wdt.o

obj-$(CONFIG_83xx_WDT) += mpc83xx_wdt.o

obj-$(CONFIG_8xxx_WDT) += mpc8xxx_wdt.o

obj-$(CONFIG_MV64X60_WDT) += mv64x60_wdt.o

obj-$(CONFIG_BOOKE_WDT) += booke_wdt.o

drivers/watchdog/acquirewdt.c

+63 −67
Original line number Diff line number Diff line
@@ -58,39 +58,45 @@ 
#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 +118,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... */

			   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 +138,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;
@@ -161,32 +164,26 @@ static int acq_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 
	case WDIOC_GETBOOTSTATUS:

		return put_user(0, p);



	case WDIOC_KEEPALIVE:

	  acq_keepalive();

	  return 0;



	case WDIOC_GETTIMEOUT:

	  return put_user(WATCHDOG_HEARTBEAT, p);



	case WDIOC_SETOPTIONS:

	{

		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;

	}

	case WDIOC_KEEPALIVE:

		acq_keepalive();

		return 0;



	case WDIOC_GETTIMEOUT:

		return put_user(WATCHDOG_HEARTBEAT, p);



	default:

		return -ENOTTY;
@@ -211,7 +208,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 +225,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 +246,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 +259,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 +308,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

+76 −86
Original line number Diff line number Diff line
@@ -37,9 +37,9 @@ 
#include <linux/ioport.h>

#include <linux/platform_device.h>

#include <linux/init.h>

#include <linux/io.h>

#include <linux/uaccess.h>



#include <asm/io.h>

#include <asm/uaccess.h>

#include <asm/system.h>



#define DRV_NAME "advantechwdt"
@@ -47,7 +47,8 @@ 
#define WATCHDOG_NAME "Advantech WDT"

#define WATCHDOG_TIMEOUT 60		/* 60 sec default timeout */



static struct platform_device *advwdt_platform_device;	/* the watchdog platform device */

/* the watchdog platform device */

static struct platform_device *advwdt_platform_device;

static unsigned long advwdt_is_open;

static char adv_expect_close;
@@ -72,35 +73,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 +110,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 +132,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;
@@ -154,49 +153,42 @@ advwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 
	case WDIOC_GETBOOTSTATUS:

		return put_user(0, p);



	case WDIOC_KEEPALIVE:

	  advwdt_ping();

	  break;



	case WDIOC_SETTIMEOUT:

	  if (get_user(new_timeout, p))

		  return -EFAULT;

	  if (advwdt_set_heartbeat(new_timeout))

		  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;

	}

	case WDIOC_KEEPALIVE:

		advwdt_ping();

		break;



	case WDIOC_SETTIMEOUT:

		if (get_user(new_timeout, p))

			return -EFAULT;

		if (advwdt_set_heartbeat(new_timeout))

			return -EINVAL;

		advwdt_ping();

		/* Fall */

	case WDIOC_GETTIMEOUT:

		return put_user(timeout, p);

	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;
@@ -208,13 +200,13 @@ advwdt_open(struct inode *inode, struct file *file) 
	return nonseekable_open(inode, file);

}



static int

advwdt_close(struct inode *inode, struct file *file)

static int 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,18 +311,19 @@ static struct platform_driver advwdt_driver = { 
	},

};



static int __init

advwdt_init(void)

static int __init advwdt_init(void)

{

	int err;



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

	printk(KERN_INFO

	     "WDT driver for Advantech single board computer initialising.\n");



	err = platform_driver_register(&advwdt_driver);

	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 +336,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

+92 −97
Original line number Diff line number Diff line
@@ -18,9 +18,8 @@ 
#include <linux/init.h>

#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 +35,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 +114,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 +145,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 +168,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 +176,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 +190,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_KEEPALIVE:

		ali_keepalive();

		return 0;

	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 +265,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 +284,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 +345,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 +365,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 +392,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 +409,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;

	}