[linux.git] / drivers / watchdog / cpwd.c

/* cpwd.c - driver implementation for hardware watchdog
 * timers found on Sun Microsystems CP1400 and CP1500 boards.
 *
 * This device supports both the generic Linux watchdog
 * interface and Solaris-compatible ioctls as best it is
 * able.
 *
 * NOTE: 	CP1400 systems appear to have a defective intr_mask
 * 			register on the PLD, preventing the disabling of
 * 			timer interrupts.  We use a timer to periodically
 * 			reset 'stopped' watchdogs on affected platforms.
 *
 * Copyright (c) 2000 Eric Brower ([email protected])
 * Copyright (C) 2008 David S. Miller <[email protected]>
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/major.h>
#include <linux/init.h>
#include <linux/miscdevice.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/timer.h>
#include <linux/smp_lock.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/uaccess.h>

#include <asm/irq.h>
#include <asm/watchdog.h>

#define DRIVER_NAME	"cpwd"
#define PFX		DRIVER_NAME ": "

#define WD_OBPNAME	"watchdog"
#define WD_BADMODEL	"SUNW,501-5336"
#define WD_BTIMEOUT	(jiffies + (HZ * 1000))
#define WD_BLIMIT	0xFFFF

#define WD0_MINOR	212
#define WD1_MINOR	213
#define WD2_MINOR	214

/* Internal driver definitions.  */
#define WD0_ID			0
#define WD1_ID			1
#define WD2_ID			2
#define WD_NUMDEVS		3

#define WD_INTR_OFF		0
#define WD_INTR_ON		1

#define WD_STAT_INIT	0x01	/* Watchdog timer is initialized	*/
#define WD_STAT_BSTOP	0x02	/* Watchdog timer is brokenstopped	*/
#define WD_STAT_SVCD	0x04	/* Watchdog interrupt occurred		*/

/* Register value definitions
 */
#define WD0_INTR_MASK	0x01	/* Watchdog device interrupt masks	*/
#define WD1_INTR_MASK	0x02
#define WD2_INTR_MASK	0x04

#define WD_S_RUNNING	0x01	/* Watchdog device status running	*/
#define WD_S_EXPIRED	0x02	/* Watchdog device status expired	*/

struct cpwd {
	void __iomem	*regs;
	spinlock_t	lock;

	unsigned int	irq;

	unsigned long	timeout;
	bool		enabled;
	bool		reboot;
	bool		broken;
	bool		initialized;

	struct {
		struct miscdevice	misc;
		void __iomem		*regs;
		u8			intr_mask;
		u8			runstatus;
		u16			timeout;
	} devs[WD_NUMDEVS];
};

static struct cpwd *cpwd_device;

/* Sun uses Altera PLD EPF8820ATC144-4
 * providing three hardware watchdogs:
 *
 * 1) RIC - sends an interrupt when triggered
 * 2) XIR - asserts XIR_B_RESET when triggered, resets CPU
 * 3) POR - asserts POR_B_RESET when triggered, resets CPU, backplane, board
 *
 *** Timer register block definition (struct wd_timer_regblk)
 *
 * dcntr and limit registers (halfword access):
 * -------------------
 * | 15 | ...| 1 | 0 |
 * -------------------
 * |-  counter val  -|
 * -------------------
 * dcntr - 	Current 16-bit downcounter value.
 * 			When downcounter reaches '0' watchdog expires.
 * 			Reading this register resets downcounter with
 * 			'limit' value.
 * limit - 	16-bit countdown value in 1/10th second increments.
 * 			Writing this register begins countdown with input value.
 * 			Reading from this register does not affect counter.
 * NOTES:	After watchdog reset, dcntr and limit contain '1'
 *
 * status register (byte access):
 * ---------------------------
 * | 7 | ... | 2 |  1  |  0  |
 * --------------+------------
 * |-   UNUSED  -| EXP | RUN |
 * ---------------------------
 * status-	Bit 0 - Watchdog is running
 * 			Bit 1 - Watchdog has expired
 *
 *** PLD register block definition (struct wd_pld_regblk)
 *
 * intr_mask register (byte access):
 * ---------------------------------
 * | 7 | ... | 3 |  2  |  1  |  0  |
 * +-------------+------------------
 * |-   UNUSED  -| WD3 | WD2 | WD1 |
 * ---------------------------------
 * WD3 -  1 == Interrupt disabled for watchdog 3
 * WD2 -  1 == Interrupt disabled for watchdog 2
 * WD1 -  1 == Interrupt disabled for watchdog 1
 *
 * pld_status register (byte access):
 * UNKNOWN, MAGICAL MYSTERY REGISTER
 *
 */
#define WD_TIMER_REGSZ	16
#define WD0_OFF		0
#define WD1_OFF		(WD_TIMER_REGSZ * 1)
#define WD2_OFF		(WD_TIMER_REGSZ * 2)
#define PLD_OFF		(WD_TIMER_REGSZ * 3)

#define WD_DCNTR	0x00
#define WD_LIMIT	0x04
#define WD_STATUS	0x08

#define PLD_IMASK	(PLD_OFF + 0x00)
#define PLD_STATUS	(PLD_OFF + 0x04)

static struct timer_list cpwd_timer;

static int wd0_timeout;
static int wd1_timeout;
static int wd2_timeout;

module_param(wd0_timeout, int, 0);
MODULE_PARM_DESC(wd0_timeout, "Default watchdog0 timeout in 1/10secs");
module_param(wd1_timeout, int, 0);
MODULE_PARM_DESC(wd1_timeout, "Default watchdog1 timeout in 1/10secs");
module_param(wd2_timeout, int, 0);
MODULE_PARM_DESC(wd2_timeout, "Default watchdog2 timeout in 1/10secs");

MODULE_AUTHOR("Eric Brower <[email protected]>");
MODULE_DESCRIPTION("Hardware watchdog driver for Sun Microsystems CP1400/1500");
MODULE_LICENSE("GPL");
MODULE_SUPPORTED_DEVICE("watchdog");

static void cpwd_writew(u16 val, void __iomem *addr)
{
	writew(cpu_to_le16(val), addr);
}
static u16 cpwd_readw(void __iomem *addr)
{
	u16 val = readw(addr);

	return le16_to_cpu(val);
}

static void cpwd_writeb(u8 val, void __iomem *addr)
{
	writeb(val, addr);
}

static u8 cpwd_readb(void __iomem *addr)
{
	return readb(addr);
}

/* Enable or disable watchdog interrupts
 * Because of the CP1400 defect this should only be
 * called during initialzation or by wd_[start|stop]timer()
 *
 * index 	- sub-device index, or -1 for 'all'
 * enable	- non-zero to enable interrupts, zero to disable
 */
static void cpwd_toggleintr(struct cpwd *p, int index, int enable)
{
	unsigned char curregs = cpwd_readb(p->regs + PLD_IMASK);
	unsigned char setregs =
		(index == -1) ?
		(WD0_INTR_MASK | WD1_INTR_MASK | WD2_INTR_MASK) :
		(p->devs[index].intr_mask);

	if (enable == WD_INTR_ON)
		curregs &= ~setregs;
	else
		curregs |= setregs;

	cpwd_writeb(curregs, p->regs + PLD_IMASK);
}

/* Restarts timer with maximum limit value and
 * does not unset 'brokenstop' value.
 */
static void cpwd_resetbrokentimer(struct cpwd *p, int index)
{
	cpwd_toggleintr(p, index, WD_INTR_ON);
	cpwd_writew(WD_BLIMIT, p->devs[index].regs + WD_LIMIT);
}

/* Timer method called to reset stopped watchdogs--
 * because of the PLD bug on CP1400, we cannot mask
 * interrupts within the PLD so me must continually
 * reset the timers ad infinitum.
 */
static void cpwd_brokentimer(unsigned long data)
{
	struct cpwd *p = (struct cpwd *) data;
	int id, tripped = 0;

	/* kill a running timer instance, in case we
	 * were called directly instead of by kernel timer
	 */
	if (timer_pending(&cpwd_timer))
		del_timer(&cpwd_timer);

	for (id = 0; id < WD_NUMDEVS; id++) {
		if (p->devs[id].runstatus & WD_STAT_BSTOP) {
			++tripped;
			cpwd_resetbrokentimer(p, id);
		}
	}

	if (tripped) {
		/* there is at least one timer brokenstopped-- reschedule */
		cpwd_timer.expires = WD_BTIMEOUT;
		add_timer(&cpwd_timer);
	}
}

/* Reset countdown timer with 'limit' value and continue countdown.
 * This will not start a stopped timer.
 */
static void cpwd_pingtimer(struct cpwd *p, int index)
{
	if (cpwd_readb(p->devs[index].regs + WD_STATUS) & WD_S_RUNNING)
		cpwd_readw(p->devs[index].regs + WD_DCNTR);
}

/* Stop a running watchdog timer-- the timer actually keeps
 * running, but the interrupt is masked so that no action is
 * taken upon expiration.
 */
static void cpwd_stoptimer(struct cpwd *p, int index)
{
	if (cpwd_readb(p->devs[index].regs + WD_STATUS) & WD_S_RUNNING) {
		cpwd_toggleintr(p, index, WD_INTR_OFF);

		if (p->broken) {
			p->devs[index].runstatus |= WD_STAT_BSTOP;
			cpwd_brokentimer((unsigned long) p);
		}
	}
}

/* Start a watchdog timer with the specified limit value
 * If the watchdog is running, it will be restarted with
 * the provided limit value.
 *
 * This function will enable interrupts on the specified
 * watchdog.
 */
static void cpwd_starttimer(struct cpwd *p, int index)
{
	if (p->broken)
		p->devs[index].runstatus &= ~WD_STAT_BSTOP;

	p->devs[index].runstatus &= ~WD_STAT_SVCD;

	cpwd_writew(p->devs[index].timeout, p->devs[index].regs + WD_LIMIT);
	cpwd_toggleintr(p, index, WD_INTR_ON);
}

static int cpwd_getstatus(struct cpwd *p, int index)
{
	unsigned char stat = cpwd_readb(p->devs[index].regs + WD_STATUS);
	unsigned char intr = cpwd_readb(p->devs[index].regs + PLD_IMASK);
	unsigned char ret  = WD_STOPPED;

	/* determine STOPPED */
	if (!stat)
		return ret;

	/* determine EXPIRED vs FREERUN vs RUNNING */
	else if (WD_S_EXPIRED & stat) {
		ret = WD_EXPIRED;
	} else if (WD_S_RUNNING & stat) {
		if (intr & p->devs[index].intr_mask) {
			ret = WD_FREERUN;
		} else {
			/* Fudge WD_EXPIRED status for defective CP1400--
			 * IF timer is running
			 * 	AND brokenstop is set
			 * 	AND an interrupt has been serviced
			 * we are WD_EXPIRED.
			 *
			 * IF timer is running
			 * 	AND brokenstop is set
			 * 	AND no interrupt has been serviced
			 * we are WD_FREERUN.
			 */
			if (p->broken &&
			    (p->devs[index].runstatus & WD_STAT_BSTOP)) {
				if (p->devs[index].runstatus & WD_STAT_SVCD) {
					ret = WD_EXPIRED;
				} else {
					/* we could as well pretend
					 * we are expired */
					ret = WD_FREERUN;
				}
			} else {
				ret = WD_RUNNING;
			}
		}
	}

	/* determine SERVICED */
	if (p->devs[index].runstatus & WD_STAT_SVCD)
		ret |= WD_SERVICED;

	return ret;
}

static irqreturn_t cpwd_interrupt(int irq, void *dev_id)
{
	struct cpwd *p = dev_id;

	/* Only WD0 will interrupt-- others are NMI and we won't
	 * see them here....
	 */
	spin_lock_irq(&p->lock);

	cpwd_stoptimer(p, WD0_ID);
	p->devs[WD0_ID].runstatus |=  WD_STAT_SVCD;

	spin_unlock_irq(&p->lock);

	return IRQ_HANDLED;
}

static int cpwd_open(struct inode *inode, struct file *f)
{
	struct cpwd *p = cpwd_device;

	lock_kernel();
	switch (iminor(inode)) {
	case WD0_MINOR:
	case WD1_MINOR:
	case WD2_MINOR:
		break;

	default:
		unlock_kernel();
		return -ENODEV;
	}

	/* Register IRQ on first open of device */
	if (!p->initialized) {
		if (request_irq(p->irq, &cpwd_interrupt,
				IRQF_SHARED, DRIVER_NAME, p)) {
			printk(KERN_ERR PFX "Cannot register IRQ %d\n",
				p->irq);
			unlock_kernel();
			return -EBUSY;
		}
		p->initialized = true;
	}

	unlock_kernel();

	return nonseekable_open(inode, f);
}

static int cpwd_release(struct inode *inode, struct file *file)
{
	return 0;
}

static long cpwd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	static struct watchdog_info info = {
		.options		= WDIOF_SETTIMEOUT,
		.firmware_version	= 1,
		.identity		= DRIVER_NAME,
	};
	void __user *argp = (void __user *)arg;
	struct inode *inode = file->f_path.dentry->d_inode;
	int index = iminor(inode) - WD0_MINOR;
	struct cpwd *p = cpwd_device;
	int setopt = 0;

	switch (cmd) {
	/* Generic Linux IOCTLs */
	case WDIOC_GETSUPPORT:
		if (copy_to_user(argp, &info, sizeof(struct watchdog_info)))
			return -EFAULT;
		break;

	case WDIOC_GETSTATUS:
	case WDIOC_GETBOOTSTATUS:
		if (put_user(0, (int __user *)argp))
			return -EFAULT;
		break;

	case WDIOC_KEEPALIVE:
		cpwd_pingtimer(p, index);
		break;

	case WDIOC_SETOPTIONS:
		if (copy_from_user(&setopt, argp, sizeof(unsigned int)))
			return -EFAULT;

		if (setopt & WDIOS_DISABLECARD) {
			if (p->enabled)
				return -EINVAL;
			cpwd_stoptimer(p, index);
		} else if (setopt & WDIOS_ENABLECARD) {
			cpwd_starttimer(p, index);
		} else {
			return -EINVAL;
		}
		break;

	/* Solaris-compatible IOCTLs */
	case WIOCGSTAT:
		setopt = cpwd_getstatus(p, index);
		if (copy_to_user(argp, &setopt, sizeof(unsigned int)))
			return -EFAULT;
		break;

	case WIOCSTART:
		cpwd_starttimer(p, index);
		break;

	case WIOCSTOP:
		if (p->enabled)
			return -EINVAL;

		cpwd_stoptimer(p, index);
		break;

	default:
		return -EINVAL;
	}

	return 0;
}

static long cpwd_compat_ioctl(struct file *file, unsigned int cmd,
			      unsigned long arg)
{
	int rval = -ENOIOCTLCMD;

	switch (cmd) {
	/* solaris ioctls are specific to this driver */
	case WIOCSTART:
	case WIOCSTOP:
	case WIOCGSTAT:
		lock_kernel();
		rval = cpwd_ioctl(file, cmd, arg);
		unlock_kernel();
		break;

	/* everything else is handled by the generic compat layer */
	default:
		break;
	}

	return rval;
}

static ssize_t cpwd_write(struct file *file, const char __user *buf,
			  size_t count, loff_t *ppos)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	struct cpwd *p = cpwd_device;
	int index = iminor(inode);

	if (count) {
		cpwd_pingtimer(p, index);
		return 1;
	}

	return 0;
}

static ssize_t cpwd_read(struct file *file, char __user *buffer,
			 size_t count, loff_t *ppos)
{
	return -EINVAL;
}

static const struct file_operations cpwd_fops = {
	.owner =		THIS_MODULE,
	.unlocked_ioctl =	cpwd_ioctl,
	.compat_ioctl =		cpwd_compat_ioctl,
	.open =			cpwd_open,
	.write =		cpwd_write,
	.read =			cpwd_read,
	.release =		cpwd_release,
};

static int __devinit cpwd_probe(struct of_device *op,
				const struct of_device_id *match)
{
	struct device_node *options;
	const char *str_prop;
	const void *prop_val;
	int i, err = -EINVAL;
	struct cpwd *p;

	if (cpwd_device)
		return -EINVAL;

	p = kzalloc(sizeof(*p), GFP_KERNEL);
	err = -ENOMEM;
	if (!p) {
		printk(KERN_ERR PFX "Unable to allocate struct cpwd.\n");
		goto out;
	}

	p->irq = op->irqs[0];

	spin_lock_init(&p->lock);

	p->regs = of_ioremap(&op->resource[0], 0,
			     4 * WD_TIMER_REGSZ, DRIVER_NAME);
	if (!p->regs) {
		printk(KERN_ERR PFX "Unable to map registers.\n");
		goto out_free;
	}

	options = of_find_node_by_path("/options");
	err = -ENODEV;
	if (!options) {
		printk(KERN_ERR PFX "Unable to find /options node.\n");
		goto out_iounmap;
	}

	prop_val = of_get_property(options, "watchdog-enable?", NULL);
	p->enabled = (prop_val ? true : false);

	prop_val = of_get_property(options, "watchdog-reboot?", NULL);
	p->reboot = (prop_val ? true : false);

	str_prop = of_get_property(options, "watchdog-timeout", NULL);
	if (str_prop)
		p->timeout = simple_strtoul(str_prop, NULL, 10);

	/* CP1400s seem to have broken PLD implementations-- the
	 * interrupt_mask register cannot be written, so no timer
	 * interrupts can be masked within the PLD.
	 */
	str_prop = of_get_property(op->node, "model", NULL);
	p->broken = (str_prop && !strcmp(str_prop, WD_BADMODEL));

	if (!p->enabled)
		cpwd_toggleintr(p, -1, WD_INTR_OFF);

	for (i = 0; i < WD_NUMDEVS; i++) {
		static const char *cpwd_names[] = { "RIC", "XIR", "POR" };
		static int *parms[] = { &wd0_timeout,
					&wd1_timeout,
					&wd2_timeout };
		struct miscdevice *mp = &p->devs[i].misc;

		mp->minor = WD0_MINOR + i;
		mp->name = cpwd_names[i];
		mp->fops = &cpwd_fops;

		p->devs[i].regs = p->regs + (i * WD_TIMER_REGSZ);
		p->devs[i].intr_mask = (WD0_INTR_MASK << i);
		p->devs[i].runstatus &= ~WD_STAT_BSTOP;
		p->devs[i].runstatus |= WD_STAT_INIT;
		p->devs[i].timeout = p->timeout;
		if (*parms[i])
			p->devs[i].timeout = *parms[i];

		err = misc_register(&p->devs[i].misc);
		if (err) {
			printk(KERN_ERR "Could not register misc device for "
			       "dev %d\n", i);
			goto out_unregister;
		}
	}

	if (p->broken) {
		init_timer(&cpwd_timer);
		cpwd_timer.function 	= cpwd_brokentimer;
		cpwd_timer.data		= (unsigned long) p;
		cpwd_timer.expires	= WD_BTIMEOUT;

		printk(KERN_INFO PFX "PLD defect workaround enabled for "
		       "model " WD_BADMODEL ".\n");
	}

	dev_set_drvdata(&op->dev, p);
	cpwd_device = p;
	err = 0;

out:
	return err;

out_unregister:
	for (i--; i >= 0; i--)
		misc_deregister(&p->devs[i].misc);

out_iounmap:
	of_iounmap(&op->resource[0], p->regs, 4 * WD_TIMER_REGSZ);

out_free:
	kfree(p);
	goto out;
}

static int __devexit cpwd_remove(struct of_device *op)
{
	struct cpwd *p = dev_get_drvdata(&op->dev);
	int i;

	for (i = 0; i < 4; i++) {
		misc_deregister(&p->devs[i].misc);

		if (!p->enabled) {
			cpwd_stoptimer(p, i);
			if (p->devs[i].runstatus & WD_STAT_BSTOP)
				cpwd_resetbrokentimer(p, i);
		}
	}

	if (p->broken)
		del_timer_sync(&cpwd_timer);

	if (p->initialized)
		free_irq(p->irq, p);

	of_iounmap(&op->resource[0], p->regs, 4 * WD_TIMER_REGSZ);
	kfree(p);

	cpwd_device = NULL;

	return 0;
}

static const struct of_device_id cpwd_match[] = {
	{
		.name = "watchdog",
	},
	{},
};
MODULE_DEVICE_TABLE(of, cpwd_match);

static struct of_platform_driver cpwd_driver = {
	.name		= DRIVER_NAME,
	.match_table	= cpwd_match,
	.probe		= cpwd_probe,
	.remove		= __devexit_p(cpwd_remove),
};

static int __init cpwd_init(void)
{
	return of_register_driver(&cpwd_driver, &of_bus_type);
}

static void __exit cpwd_exit(void)
{
	of_unregister_driver(&cpwd_driver);
}

module_init(cpwd_init);
module_exit(cpwd_exit);
Commit	Line	Data
8ab0dc33	1	/* cpwd.c - driver implementation for hardware watchdog
1da177e4 LT	2	* timers found on Sun Microsystems CP1400 and CP1500 boards.
1da177e4 LT	3	*
927d6961	4	* This device supports both the generic Linux watchdog
1da177e4 LT	5	* interface and Solaris-compatible ioctls as best it is
	6	* able.
	7	*
	8	* NOTE: CP1400 systems appear to have a defective intr_mask
	9	* register on the PLD, preventing the disabling of
927d6961	10	* timer interrupts. We use a timer to periodically
1da177e4 LT	11	* reset 'stopped' watchdogs on affected platforms.
1da177e4 LT	12	*
1da177e4	13	* Copyright (c) 2000 Eric Brower ([email protected])
c5f8556c	14	* Copyright (C) 2008 David S. Miller <[email protected]>
1da177e4 LT	15	*/
	16
	17	#include <linux/kernel.h>
	18	#include <linux/module.h>
	19	#include <linux/fs.h>
	20	#include <linux/errno.h>
	21	#include <linux/major.h>
	22	#include <linux/init.h>
	23	#include <linux/miscdevice.h>
1da177e4 LT	24	#include <linux/interrupt.h>
	25	#include <linux/ioport.h>
	26	#include <linux/timer.h>
b66621fe	27	#include <linux/smp_lock.h>
347e03df	28	#include <linux/io.h>
c5f8556c DM	29	#include <linux/of.h>
c5f8556c DM	30	#include <linux/of_device.h>
278aefc5	31	#include <linux/uaccess.h>
c5f8556c	32
1da177e4	33	#include <asm/irq.h>
1da177e4 LT	34	#include <asm/watchdog.h>
1da177e4 LT	35
c5f8556c DM	36	#define DRIVER_NAME "cpwd"
	37	#define PFX DRIVER_NAME ": "
	38
1da177e4	39	#define WD_OBPNAME "watchdog"
c5f8556c	40	#define WD_BADMODEL "SUNW,501-5336"
1da177e4 LT	41	#define WD_BTIMEOUT (jiffies + (HZ * 1000))
	42	#define WD_BLIMIT 0xFFFF
	43
1da177e4	44	#define WD0_MINOR 212
927d6961 WVS	45	#define WD1_MINOR 213
927d6961 WVS	46	#define WD2_MINOR 214
1da177e4	47
c5f8556c DM	48	/* Internal driver definitions. */
	49	#define WD0_ID 0
	50	#define WD1_ID 1
	51	#define WD2_ID 2
	52	#define WD_NUMDEVS 3
1da177e4	53
c5f8556c DM	54	#define WD_INTR_OFF 0
c5f8556c DM	55	#define WD_INTR_ON 1
1da177e4 LT	56
	57	#define WD_STAT_INIT 0x01 /* Watchdog timer is initialized */
	58	#define WD_STAT_BSTOP 0x02 /* Watchdog timer is brokenstopped */
	59	#define WD_STAT_SVCD 0x04 /* Watchdog interrupt occurred */
	60
	61	/* Register value definitions
	62	*/
	63	#define WD0_INTR_MASK 0x01 /* Watchdog device interrupt masks */
	64	#define WD1_INTR_MASK 0x02
	65	#define WD2_INTR_MASK 0x04
	66
	67	#define WD_S_RUNNING 0x01 /* Watchdog device status running */
	68	#define WD_S_EXPIRED 0x02 /* Watchdog device status expired */
	69
c5f8556c DM	70	struct cpwd {
	71	void __iomem *regs;
	72	spinlock_t lock;
	73
	74	unsigned int irq;
	75
	76	unsigned long timeout;
	77	bool enabled;
	78	bool reboot;
	79	bool broken;
	80	bool initialized;
	81
	82	struct {
	83	struct miscdevice misc;
	84	void __iomem *regs;
	85	u8 intr_mask;
	86	u8 runstatus;
	87	u16 timeout;
	88	} devs[WD_NUMDEVS];
	89	};
	90
	91	static struct cpwd *cpwd_device;
	92
927d6961	93	/* Sun uses Altera PLD EPF8820ATC144-4
1da177e4 LT	94	* providing three hardware watchdogs:
1da177e4 LT	95	*
927d6961 WVS	96	* 1) RIC - sends an interrupt when triggered
	97	* 2) XIR - asserts XIR_B_RESET when triggered, resets CPU
	98	* 3) POR - asserts POR_B_RESET when triggered, resets CPU, backplane, board
1da177e4 LT	99	*
	100	*** Timer register block definition (struct wd_timer_regblk)
	101	*
927d6961	102	* dcntr and limit registers (halfword access):
1da177e4 LT	103	* -------------------
	104	* \| 15 \| ...\| 1 \| 0 \|
	105	* -------------------
	106	* \|- counter val -\|
	107	* -------------------
	108	* dcntr - Current 16-bit downcounter value.
	109	* When downcounter reaches '0' watchdog expires.
927d6961 WVS	110	* Reading this register resets downcounter with
927d6961 WVS	111	* 'limit' value.
1da177e4 LT	112	* limit - 16-bit countdown value in 1/10th second increments.
	113	* Writing this register begins countdown with input value.
	114	* Reading from this register does not affect counter.
	115	* NOTES: After watchdog reset, dcntr and limit contain '1'
	116	*
	117	* status register (byte access):
	118	* ---------------------------
	119	* \| 7 \| ... \| 2 \| 1 \| 0 \|
	120	* --------------+------------
	121	* \|- UNUSED -\| EXP \| RUN \|
	122	* ---------------------------
	123	* status- Bit 0 - Watchdog is running
	124	* Bit 1 - Watchdog has expired
	125	*
	126	*** PLD register block definition (struct wd_pld_regblk)
	127	*
	128	* intr_mask register (byte access):
	129	* ---------------------------------
	130	* \| 7 \| ... \| 3 \| 2 \| 1 \| 0 \|
	131	* +-------------+------------------
	132	* \|- UNUSED -\| WD3 \| WD2 \| WD1 \|
	133	* ---------------------------------
	134	* WD3 - 1 == Interrupt disabled for watchdog 3
	135	* WD2 - 1 == Interrupt disabled for watchdog 2
	136	* WD1 - 1 == Interrupt disabled for watchdog 1
	137	*
	138	* pld_status register (byte access):
	139	* UNKNOWN, MAGICAL MYSTERY REGISTER
	140	*
	141	*/
	142	#define WD_TIMER_REGSZ 16
	143	#define WD0_OFF 0
	144	#define WD1_OFF (WD_TIMER_REGSZ * 1)
	145	#define WD2_OFF (WD_TIMER_REGSZ * 2)
	146	#define PLD_OFF (WD_TIMER_REGSZ * 3)
	147
	148	#define WD_DCNTR 0x00
	149	#define WD_LIMIT 0x04
	150	#define WD_STATUS 0x08
	151
	152	#define PLD_IMASK (PLD_OFF + 0x00)
	153	#define PLD_STATUS (PLD_OFF + 0x04)
	154
c5f8556c	155	static struct timer_list cpwd_timer;
1da177e4	156
a77dba7e WVS	157	static int wd0_timeout;
	158	static int wd1_timeout;
	159	static int wd2_timeout;
1da177e4	160
927d6961	161	module_param(wd0_timeout, int, 0);
1da177e4	162	MODULE_PARM_DESC(wd0_timeout, "Default watchdog0 timeout in 1/10secs");
927d6961	163	module_param(wd1_timeout, int, 0);
1da177e4	164	MODULE_PARM_DESC(wd1_timeout, "Default watchdog1 timeout in 1/10secs");
927d6961	165	module_param(wd2_timeout, int, 0);
1da177e4 LT	166	MODULE_PARM_DESC(wd2_timeout, "Default watchdog2 timeout in 1/10secs");
1da177e4 LT	167
c5f8556c DM	168	MODULE_AUTHOR("Eric Brower <[email protected]>");
c5f8556c DM	169	MODULE_DESCRIPTION("Hardware watchdog driver for Sun Microsystems CP1400/1500");
1da177e4	170	MODULE_LICENSE("GPL");
c5f8556c DM	171	MODULE_SUPPORTED_DEVICE("watchdog");
	172
	173	static void cpwd_writew(u16 val, void __iomem *addr)
	174	{
	175	writew(cpu_to_le16(val), addr);
	176	}
	177	static u16 cpwd_readw(void __iomem *addr)
	178	{
	179	u16 val = readw(addr);
	180
	181	return le16_to_cpu(val);
	182	}
	183
	184	static void cpwd_writeb(u8 val, void __iomem *addr)
	185	{
	186	writeb(val, addr);
	187	}
	188
	189	static u8 cpwd_readb(void __iomem *addr)
	190	{
	191	return readb(addr);
	192	}
1da177e4	193
c5f8556c DM	194	/* Enable or disable watchdog interrupts
	195	* Because of the CP1400 defect this should only be
	196	* called during initialzation or by wd_[start\|stop]timer()
	197	*
	198	* index - sub-device index, or -1 for 'all'
	199	* enable - non-zero to enable interrupts, zero to disable
1da177e4	200	*/
c5f8556c DM	201	static void cpwd_toggleintr(struct cpwd *p, int index, int enable)
	202	{
	203	unsigned char curregs = cpwd_readb(p->regs + PLD_IMASK);
927d6961 WVS	204	unsigned char setregs =
	205	(index == -1) ?
	206	(WD0_INTR_MASK \| WD1_INTR_MASK \| WD2_INTR_MASK) :
c5f8556c DM	207	(p->devs[index].intr_mask);
	208
	209	if (enable == WD_INTR_ON)
	210	curregs &= ~setregs;
	211	else
	212	curregs \|= setregs;
	213
	214	cpwd_writeb(curregs, p->regs + PLD_IMASK);
	215	}
	216
	217	/* Restarts timer with maximum limit value and
	218	* does not unset 'brokenstop' value.
1da177e4	219	*/
c5f8556c	220	static void cpwd_resetbrokentimer(struct cpwd *p, int index)
1da177e4	221	{
c5f8556c DM	222	cpwd_toggleintr(p, index, WD_INTR_ON);
c5f8556c DM	223	cpwd_writew(WD_BLIMIT, p->devs[index].regs + WD_LIMIT);
1da177e4 LT	224	}
1da177e4 LT	225
c5f8556c DM	226	/* Timer method called to reset stopped watchdogs--
	227	* because of the PLD bug on CP1400, we cannot mask
	228	* interrupts within the PLD so me must continually
	229	* reset the timers ad infinitum.
	230	*/
	231	static void cpwd_brokentimer(unsigned long data)
	232	{
	233	struct cpwd p = (struct cpwd ) data;
	234	int id, tripped = 0;
	235
	236	/* kill a running timer instance, in case we
	237	* were called directly instead of by kernel timer
	238	*/
	239	if (timer_pending(&cpwd_timer))
	240	del_timer(&cpwd_timer);
1da177e4	241
c5f8556c DM	242	for (id = 0; id < WD_NUMDEVS; id++) {
	243	if (p->devs[id].runstatus & WD_STAT_BSTOP) {
	244	++tripped;
	245	cpwd_resetbrokentimer(p, id);
	246	}
	247	}
1da177e4	248
c5f8556c DM	249	if (tripped) {
	250	/* there is at least one timer brokenstopped-- reschedule */
	251	cpwd_timer.expires = WD_BTIMEOUT;
	252	add_timer(&cpwd_timer);
	253	}
	254	}
	255
	256	/* Reset countdown timer with 'limit' value and continue countdown.
	257	* This will not start a stopped timer.
1da177e4	258	*/
c5f8556c	259	static void cpwd_pingtimer(struct cpwd *p, int index)
1da177e4	260	{
c5f8556c DM	261	if (cpwd_readb(p->devs[index].regs + WD_STATUS) & WD_S_RUNNING)
c5f8556c DM	262	cpwd_readw(p->devs[index].regs + WD_DCNTR);
1da177e4	263	}
c5f8556c DM	264
	265	/* Stop a running watchdog timer-- the timer actually keeps
	266	* running, but the interrupt is masked so that no action is
	267	* taken upon expiration.
1da177e4	268	*/
c5f8556c	269	static void cpwd_stoptimer(struct cpwd *p, int index)
1da177e4	270	{
c5f8556c DM	271	if (cpwd_readb(p->devs[index].regs + WD_STATUS) & WD_S_RUNNING) {
c5f8556c DM	272	cpwd_toggleintr(p, index, WD_INTR_OFF);
1da177e4	273
c5f8556c DM	274	if (p->broken) {
	275	p->devs[index].runstatus \|= WD_STAT_BSTOP;
	276	cpwd_brokentimer((unsigned long) p);
	277	}
	278	}
1da177e4 LT	279	}
1da177e4 LT	280
c5f8556c DM	281	/* Start a watchdog timer with the specified limit value
	282	* If the watchdog is running, it will be restarted with
	283	* the provided limit value.
	284	*
	285	* This function will enable interrupts on the specified
	286	* watchdog.
1da177e4	287	*/
c5f8556c	288	static void cpwd_starttimer(struct cpwd *p, int index)
1da177e4	289	{
c5f8556c DM	290	if (p->broken)
	291	p->devs[index].runstatus &= ~WD_STAT_BSTOP;
	292
	293	p->devs[index].runstatus &= ~WD_STAT_SVCD;
1da177e4	294
c5f8556c DM	295	cpwd_writew(p->devs[index].timeout, p->devs[index].regs + WD_LIMIT);
c5f8556c DM	296	cpwd_toggleintr(p, index, WD_INTR_ON);
1da177e4 LT	297	}
1da177e4 LT	298
c5f8556c	299	static int cpwd_getstatus(struct cpwd *p, int index)
1da177e4	300	{
c5f8556c DM	301	unsigned char stat = cpwd_readb(p->devs[index].regs + WD_STATUS);
	302	unsigned char intr = cpwd_readb(p->devs[index].regs + PLD_IMASK);
	303	unsigned char ret = WD_STOPPED;
	304
	305	/* determine STOPPED */
927d6961	306	if (!stat)
c5f8556c DM	307	return ret;
	308
	309	/* determine EXPIRED vs FREERUN vs RUNNING */
	310	else if (WD_S_EXPIRED & stat) {
	311	ret = WD_EXPIRED;
927d6961	312	} else if (WD_S_RUNNING & stat) {
c5f8556c DM	313	if (intr & p->devs[index].intr_mask) {
	314	ret = WD_FREERUN;
	315	} else {
	316	/* Fudge WD_EXPIRED status for defective CP1400--
927d6961 WVS	317	* IF timer is running
927d6961 WVS	318	* AND brokenstop is set
c5f8556c DM	319	* AND an interrupt has been serviced
	320	* we are WD_EXPIRED.
	321	*
927d6961 WVS	322	* IF timer is running
927d6961 WVS	323	* AND brokenstop is set
c5f8556c DM	324	* AND no interrupt has been serviced
	325	* we are WD_FREERUN.
	326	*/
	327	if (p->broken &&
	328	(p->devs[index].runstatus & WD_STAT_BSTOP)) {
	329	if (p->devs[index].runstatus & WD_STAT_SVCD) {
	330	ret = WD_EXPIRED;
	331	} else {
927d6961 WVS	332	/* we could as well pretend
927d6961 WVS	333	* we are expired */
c5f8556c DM	334	ret = WD_FREERUN;
	335	}
	336	} else {
	337	ret = WD_RUNNING;
1da177e4 LT	338	}
	339	}
	340	}
c5f8556c DM	341
	342	/* determine SERVICED */
	343	if (p->devs[index].runstatus & WD_STAT_SVCD)
	344	ret \|= WD_SERVICED;
	345
927d6961	346	return ret;
c5f8556c DM	347	}
	348
	349	static irqreturn_t cpwd_interrupt(int irq, void *dev_id)
	350	{
	351	struct cpwd *p = dev_id;
	352
	353	/* Only WD0 will interrupt-- others are NMI and we won't
	354	* see them here....
	355	*/
	356	spin_lock_irq(&p->lock);
	357
	358	cpwd_stoptimer(p, WD0_ID);
	359	p->devs[WD0_ID].runstatus \|= WD_STAT_SVCD;
	360
	361	spin_unlock_irq(&p->lock);
	362
	363	return IRQ_HANDLED;
1da177e4 LT	364	}
1da177e4 LT	365
c5f8556c	366	static int cpwd_open(struct inode inode, struct file f)
1da177e4	367	{
c5f8556c DM	368	struct cpwd *p = cpwd_device;
c5f8556c DM	369
b05c9e6c	370	lock_kernel();
927d6961 WVS	371	switch (iminor(inode)) {
	372	case WD0_MINOR:
	373	case WD1_MINOR:
	374	case WD2_MINOR:
	375	break;
c5f8556c	376
927d6961 WVS	377	default:
	378	unlock_kernel();
	379	return -ENODEV;
1da177e4 LT	380	}
	381
	382	/* Register IRQ on first open of device */
c5f8556c	383	if (!p->initialized) {
927d6961	384	if (request_irq(p->irq, &cpwd_interrupt,
c5f8556c	385	IRQF_SHARED, DRIVER_NAME, p)) {
927d6961	386	printk(KERN_ERR PFX "Cannot register IRQ %d\n",
c5f8556c	387	p->irq);
b05c9e6c	388	unlock_kernel();
c5f8556c	389	return -EBUSY;
1da177e4	390	}
c5f8556c	391	p->initialized = true;
1da177e4 LT	392	}
1da177e4 LT	393
b05c9e6c	394	unlock_kernel();
c5f8556c DM	395
c5f8556c DM	396	return nonseekable_open(inode, f);
1da177e4 LT	397	}
1da177e4 LT	398
c5f8556c	399	static int cpwd_release(struct inode inode, struct file file)
1da177e4 LT	400	{
	401	return 0;
	402	}
	403
9626dd75	404	static long cpwd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1da177e4	405	{
c5f8556c DM	406	static struct watchdog_info info = {
	407	.options = WDIOF_SETTIMEOUT,
	408	.firmware_version = 1,
	409	.identity = DRIVER_NAME,
1da177e4	410	};
c5f8556c	411	void __user argp = (void __user )arg;
9626dd75	412	struct inode *inode = file->f_path.dentry->d_inode;
c5f8556c DM	413	int index = iminor(inode) - WD0_MINOR;
	414	struct cpwd *p = cpwd_device;
	415	int setopt = 0;
1da177e4	416
c5f8556c DM	417	switch (cmd) {
	418	/* Generic Linux IOCTLs */
	419	case WDIOC_GETSUPPORT:
	420	if (copy_to_user(argp, &info, sizeof(struct watchdog_info)))
	421	return -EFAULT;
	422	break;
1da177e4	423
c5f8556c DM	424	case WDIOC_GETSTATUS:
	425	case WDIOC_GETBOOTSTATUS:
	426	if (put_user(0, (int __user *)argp))
	427	return -EFAULT;
	428	break;
	429
	430	case WDIOC_KEEPALIVE:
	431	cpwd_pingtimer(p, index);
	432	break;
	433
	434	case WDIOC_SETOPTIONS:
	435	if (copy_from_user(&setopt, argp, sizeof(unsigned int)))
	436	return -EFAULT;
	437
	438	if (setopt & WDIOS_DISABLECARD) {
	439	if (p->enabled)
	440	return -EINVAL;
	441	cpwd_stoptimer(p, index);
	442	} else if (setopt & WDIOS_ENABLECARD) {
	443	cpwd_starttimer(p, index);
	444	} else {
	445	return -EINVAL;
927d6961	446	}
c5f8556c DM	447	break;
	448
	449	/* Solaris-compatible IOCTLs */
	450	case WIOCGSTAT:
	451	setopt = cpwd_getstatus(p, index);
	452	if (copy_to_user(argp, &setopt, sizeof(unsigned int)))
	453	return -EFAULT;
	454	break;
	455
	456	case WIOCSTART:
	457	cpwd_starttimer(p, index);
	458	break;
	459
	460	case WIOCSTOP:
	461	if (p->enabled)
927d6961	462	return -EINVAL;
c5f8556c DM	463
	464	cpwd_stoptimer(p, index);
	465	break;
	466
	467	default:
	468	return -EINVAL;
1da177e4	469	}
c5f8556c DM	470
c5f8556c DM	471	return 0;
1da177e4 LT	472	}
1da177e4 LT	473
c5f8556c DM	474	static long cpwd_compat_ioctl(struct file *file, unsigned int cmd,
c5f8556c DM	475	unsigned long arg)
b66621fe CH	476	{
	477	int rval = -ENOIOCTLCMD;
	478
	479	switch (cmd) {
	480	/* solaris ioctls are specific to this driver */
	481	case WIOCSTART:
	482	case WIOCSTOP:
	483	case WIOCGSTAT:
	484	lock_kernel();
9626dd75	485	rval = cpwd_ioctl(file, cmd, arg);
feee207e	486	unlock_kernel();
b66621fe	487	break;
c5f8556c	488
b66621fe CH	489	/* everything else is handled by the generic compat layer */
	490	default:
	491	break;
	492	}
	493
	494	return rval;
	495	}
	496
927d6961	497	static ssize_t cpwd_write(struct file file, const char __user buf,
c5f8556c	498	size_t count, loff_t *ppos)
1da177e4	499	{
c5f8556c DM	500	struct inode *inode = file->f_path.dentry->d_inode;
	501	struct cpwd *p = cpwd_device;
	502	int index = iminor(inode);
1da177e4 LT	503
1da177e4 LT	504	if (count) {
c5f8556c	505	cpwd_pingtimer(p, index);
1da177e4 LT	506	return 1;
1da177e4 LT	507	}
1da177e4	508
c5f8556c	509	return 0;
1da177e4 LT	510	}
1da177e4 LT	511
927d6961	512	static ssize_t cpwd_read(struct file file, char __user buffer,
c5f8556c	513	size_t count, loff_t *ppos)
1da177e4	514	{
c5f8556c	515	return -EINVAL;
1da177e4 LT	516	}
1da177e4 LT	517
c5f8556c	518	static const struct file_operations cpwd_fops = {
9626dd75 WVS	519	.owner = THIS_MODULE,
	520	.unlocked_ioctl = cpwd_ioctl,
	521	.compat_ioctl = cpwd_compat_ioctl,
	522	.open = cpwd_open,
	523	.write = cpwd_write,
	524	.read = cpwd_read,
	525	.release = cpwd_release,
1da177e4 LT	526	};
1da177e4 LT	527
c5f8556c DM	528	static int __devinit cpwd_probe(struct of_device *op,
c5f8556c DM	529	const struct of_device_id *match)
1da177e4	530	{
c5f8556c DM	531	struct device_node *options;
	532	const char *str_prop;
	533	const void *prop_val;
	534	int i, err = -EINVAL;
	535	struct cpwd *p;
1da177e4	536
c5f8556c DM	537	if (cpwd_device)
c5f8556c DM	538	return -EINVAL;
1da177e4	539
c5f8556c DM	540	p = kzalloc(sizeof(*p), GFP_KERNEL);
	541	err = -ENOMEM;
	542	if (!p) {
	543	printk(KERN_ERR PFX "Unable to allocate struct cpwd.\n");
	544	goto out;
1da177e4	545	}
1da177e4	546
c5f8556c	547	p->irq = op->irqs[0];
1da177e4	548
c5f8556c	549	spin_lock_init(&p->lock);
1da177e4	550
c5f8556c DM	551	p->regs = of_ioremap(&op->resource[0], 0,
	552	4 * WD_TIMER_REGSZ, DRIVER_NAME);
	553	if (!p->regs) {
	554	printk(KERN_ERR PFX "Unable to map registers.\n");
	555	goto out_free;
1da177e4	556	}
1da177e4	557
c5f8556c DM	558	options = of_find_node_by_path("/options");
	559	err = -ENODEV;
	560	if (!options) {
	561	printk(KERN_ERR PFX "Unable to find /options node.\n");
	562	goto out_iounmap;
	563	}
1da177e4	564
c5f8556c DM	565	prop_val = of_get_property(options, "watchdog-enable?", NULL);
c5f8556c DM	566	p->enabled = (prop_val ? true : false);
1da177e4	567
c5f8556c DM	568	prop_val = of_get_property(options, "watchdog-reboot?", NULL);
c5f8556c DM	569	p->reboot = (prop_val ? true : false);
1da177e4	570
c5f8556c DM	571	str_prop = of_get_property(options, "watchdog-timeout", NULL);
	572	if (str_prop)
	573	p->timeout = simple_strtoul(str_prop, NULL, 10);
1da177e4	574
c5f8556c DM	575	/* CP1400s seem to have broken PLD implementations-- the
	576	* interrupt_mask register cannot be written, so no timer
	577	* interrupts can be masked within the PLD.
1da177e4	578	*/
c5f8556c DM	579	str_prop = of_get_property(op->node, "model", NULL);
	580	p->broken = (str_prop && !strcmp(str_prop, WD_BADMODEL));
	581
	582	if (!p->enabled)
	583	cpwd_toggleintr(p, -1, WD_INTR_OFF);
	584
	585	for (i = 0; i < WD_NUMDEVS; i++) {
	586	static const char *cpwd_names[] = { "RIC", "XIR", "POR" };
	587	static int *parms[] = { &wd0_timeout,
	588	&wd1_timeout,
	589	&wd2_timeout };
	590	struct miscdevice *mp = &p->devs[i].misc;
	591
	592	mp->minor = WD0_MINOR + i;
	593	mp->name = cpwd_names[i];
	594	mp->fops = &cpwd_fops;
	595
	596	p->devs[i].regs = p->regs + (i * WD_TIMER_REGSZ);
	597	p->devs[i].intr_mask = (WD0_INTR_MASK << i);
	598	p->devs[i].runstatus &= ~WD_STAT_BSTOP;
	599	p->devs[i].runstatus \|= WD_STAT_INIT;
	600	p->devs[i].timeout = p->timeout;
	601	if (*parms[i])
	602	p->devs[i].timeout = *parms[i];
	603
	604	err = misc_register(&p->devs[i].misc);
	605	if (err) {
	606	printk(KERN_ERR "Could not register misc device for "
	607	"dev %d\n", i);
	608	goto out_unregister;
1da177e4 LT	609	}
	610	}
	611
c5f8556c DM	612	if (p->broken) {
	613	init_timer(&cpwd_timer);
	614	cpwd_timer.function = cpwd_brokentimer;
	615	cpwd_timer.data = (unsigned long) p;
	616	cpwd_timer.expires = WD_BTIMEOUT;
	617
	618	printk(KERN_INFO PFX "PLD defect workaround enabled for "
	619	"model " WD_BADMODEL ".\n");
1da177e4	620	}
1da177e4	621
c5f8556c DM	622	dev_set_drvdata(&op->dev, p);
	623	cpwd_device = p;
	624	err = 0;
1da177e4	625
c5f8556c DM	626	out:
c5f8556c DM	627	return err;
1da177e4	628
c5f8556c DM	629	out_unregister:
	630	for (i--; i >= 0; i--)
	631	misc_deregister(&p->devs[i].misc);
1da177e4	632
c5f8556c DM	633	out_iounmap:
	634	of_iounmap(&op->resource[0], p->regs, 4 * WD_TIMER_REGSZ);
	635
	636	out_free:
	637	kfree(p);
	638	goto out;
1da177e4 LT	639	}
1da177e4 LT	640
c5f8556c	641	static int __devexit cpwd_remove(struct of_device *op)
1da177e4	642	{
c5f8556c DM	643	struct cpwd *p = dev_get_drvdata(&op->dev);
	644	int i;
	645
	646	for (i = 0; i < 4; i++) {
	647	misc_deregister(&p->devs[i].misc);
	648
	649	if (!p->enabled) {
	650	cpwd_stoptimer(p, i);
	651	if (p->devs[i].runstatus & WD_STAT_BSTOP)
	652	cpwd_resetbrokentimer(p, i);
1da177e4 LT	653	}
	654	}
	655
c5f8556c DM	656	if (p->broken)
c5f8556c DM	657	del_timer_sync(&cpwd_timer);
1da177e4	658
c5f8556c DM	659	if (p->initialized)
c5f8556c DM	660	free_irq(p->irq, p);
1da177e4	661
c5f8556c DM	662	of_iounmap(&op->resource[0], p->regs, 4 * WD_TIMER_REGSZ);
c5f8556c DM	663	kfree(p);
1da177e4	664
c5f8556c	665	cpwd_device = NULL;
1da177e4	666
c5f8556c DM	667	return 0;
c5f8556c DM	668	}
1da177e4	669
fd098316	670	static const struct of_device_id cpwd_match[] = {
c5f8556c DM	671	{
	672	.name = "watchdog",
	673	},
	674	{},
	675	};
	676	MODULE_DEVICE_TABLE(of, cpwd_match);
1da177e4	677
c5f8556c DM	678	static struct of_platform_driver cpwd_driver = {
	679	.name = DRIVER_NAME,
	680	.match_table = cpwd_match,
	681	.probe = cpwd_probe,
	682	.remove = __devexit_p(cpwd_remove),
	683	};
1da177e4	684
c5f8556c DM	685	static int __init cpwd_init(void)
	686	{
	687	return of_register_driver(&cpwd_driver, &of_bus_type);
1da177e4 LT	688	}
1da177e4 LT	689
c5f8556c	690	static void __exit cpwd_exit(void)
1da177e4	691	{
c5f8556c	692	of_unregister_driver(&cpwd_driver);
1da177e4 LT	693	}
1da177e4 LT	694
c5f8556c DM	695	module_init(cpwd_init);
c5f8556c DM	696	module_exit(cpwd_exit);