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

Commit 38ff6fd2 authored by Jorge Boncompte [DTI2]'s avatar Jorge Boncompte [DTI2] Committed by Wim Van Sebroeck
Browse files

[WATCHDOG] IT8212F watchdog driver 



This patch adds support for the ITE Tech Inc. IT8712F EC-LPC Super I/O 
chipset found on many Pentium III and AMD motherboards. Developed using code 
from other watchdog drivers and the datasheet on ITE Tech homepage.

Signed-off-by: default avatarJorge Boncompte <jorge@dti2.net>
Signed-off-by: default avatarWim Van Sebroeck <wim@iguana.be>
parent 6027f661

drivers/watchdog/Kconfig

+10 −0
Original line number Diff line number Diff line
@@ -392,6 +392,16 @@ config ITCO_VENDOR_SUPPORT 
	  devices. At this moment we only have additional support for some

	  SuperMicro Inc. motherboards.



config IT8712F_WDT

	tristate "IT8712F (Smart Guardian) Watchdog Timer"

	depends on X86

	---help---

	  This is the driver for the built-in watchdog timer on the IT8712F

	  Super I/0 chipset used on many motherboards.



	  To compile this driver as a module, choose M here: the

	  module will be called it8712f_wdt.



config SC1200_WDT

	tristate "National Semiconductor PC87307/PC97307 (ala SC1200) Watchdog"

	depends on X86

drivers/watchdog/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -66,6 +66,7 @@ obj-$(CONFIG_IBMASR) += ibmasr.o 
obj-$(CONFIG_WAFER_WDT) += wafer5823wdt.o

obj-$(CONFIG_I6300ESB_WDT) += i6300esb.o

obj-$(CONFIG_ITCO_WDT) += iTCO_wdt.o iTCO_vendor_support.o

obj-$(CONFIG_IT8712F_WDT) += it8712f_wdt.o

obj-$(CONFIG_SC1200_WDT) += sc1200wdt.o

obj-$(CONFIG_SCx200_WDT) += scx200_wdt.o

obj-$(CONFIG_PC87413_WDT) += pc87413_wdt.o

drivers/watchdog/it8712f_wdt.c

0 → 100644
+400 −0
Original line number Diff line number Diff line 
/*

 *	IT8712F "Smart Guardian" Watchdog support

 *

 *	Copyright (c) 2006-2007 Jorge Boncompte - DTI2 <jorge@dti2.net>

 *

 *	Based on info and code taken from:

 *

 *	drivers/char/watchdog/scx200_wdt.c

 *	drivers/hwmon/it87.c

 *	IT8712F EC-LPC I/O Preliminary Specification 0.9.2.pdf

 *

 *	This program is free software; you can redistribute it and/or

 *	modify it under the terms of the GNU General Public License as

 *	published by the Free Software Foundation; either version 2 of the

 *	License, or (at your option) any later version.

 *

 *	The author(s) of this software shall not be held liable for damages

 *	of any nature resulting due to the use of this software. This

 *	software is provided AS-IS with no warranties.

 */



#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/init.h>

#include <linux/miscdevice.h>

#include <linux/watchdog.h>

#include <linux/notifier.h>

#include <linux/reboot.h>

#include <linux/fs.h>

#include <linux/pci.h>

#include <linux/spinlock.h>



#include <asm/uaccess.h>

#include <asm/io.h>



#define NAME "it8712f_wdt"



MODULE_AUTHOR("Jorge Boncompte - DTI2 <jorge@dti2.net>");

MODULE_DESCRIPTION("IT8712F Watchdog Driver");

MODULE_LICENSE("GPL");

MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);



static int margin = 60;		/* in seconds */

module_param(margin, int, 0);

MODULE_PARM_DESC(margin, "Watchdog margin in seconds");



static int nowayout = WATCHDOG_NOWAYOUT;

module_param(nowayout, int, 0);

MODULE_PARM_DESC(nowayout, "Disable watchdog shutdown on close");



static struct semaphore it8712f_wdt_sem;

static unsigned expect_close;

static spinlock_t io_lock;



/* Dog Food address - We use the game port address */

static unsigned short address;



#define	REG		0x2e	/* The register to read/write */

#define	VAL		0x2f	/* The value to read/write */



#define	LDN		0x07	/* Register: Logical device select */

#define	DEVID		0x20	/* Register: Device ID */

#define	DEVREV		0x22	/* Register: Device Revision */

#define ACT_REG		0x30	/* LDN Register: Activation */

#define BASE_REG	0x60	/* LDN Register: Base address */



#define IT8712F_DEVID	0x8712



#define LDN_GPIO	0x07	/* GPIO and Watch Dog Timer */

#define LDN_GAME 	0x09	/* Game Port */



#define WDT_CONTROL	0x71	/* WDT Register: Control */

#define WDT_CONFIG	0x72	/* WDT Register: Configuration */

#define WDT_TIMEOUT	0x73	/* WDT Register: Timeout Value */



#define WDT_RESET_GAME	0x10

#define WDT_RESET_KBD	0x20

#define WDT_RESET_MOUSE	0x40

#define WDT_RESET_CIR	0x80



#define WDT_UNIT_SEC	0x80	/* If 0 in MINUTES */



#define WDT_OUT_PWROK	0x10

#define WDT_OUT_KRST	0x40



static int

superio_inb(int reg)

{

	outb(reg, REG);

	return inb(VAL);

}



static void

superio_outb(int val, int reg)

{

	outb(reg, REG);

	outb(val, VAL);

}



static int

superio_inw(int reg)

{

	int val;

	outb(reg++, REG);

	val = inb(VAL) << 8;

	outb(reg, REG);

	val |= inb(VAL);

	return val;

}



static inline void

superio_select(int ldn)

{

	outb(LDN, REG);

	outb(ldn, VAL);

}



static inline void

superio_enter(void)

{

	spin_lock(&io_lock);

	outb(0x87, REG);

	outb(0x01, REG);

	outb(0x55, REG);

	outb(0x55, REG);

}



static inline void

superio_exit(void)

{

	outb(0x02, REG);

	outb(0x02, VAL);

	spin_unlock(&io_lock);

}



static inline void

it8712f_wdt_ping(void)

{

	inb(address);

}



static void

it8712f_wdt_update_margin(void)

{

	int config = WDT_OUT_KRST | WDT_OUT_PWROK;



	printk(KERN_INFO NAME ": timer margin %d seconds\n", margin);



	/* The timeout register only has 8bits wide */

	if (margin < 256)

		config |= WDT_UNIT_SEC;	/* else UNIT are MINUTES */

	superio_outb(config, WDT_CONFIG);



	superio_outb((margin > 255) ? (margin / 60) : margin, WDT_TIMEOUT);

}



static void

it8712f_wdt_enable(void)

{

	printk(KERN_DEBUG NAME ": enabling watchdog timer\n");

	superio_enter();

	superio_select(LDN_GPIO);



	superio_outb(WDT_RESET_GAME, WDT_CONTROL);



	it8712f_wdt_update_margin();



	superio_exit();



	it8712f_wdt_ping();

}



static void

it8712f_wdt_disable(void)

{

	printk(KERN_DEBUG NAME ": disabling watchdog timer\n");



	superio_enter();

	superio_select(LDN_GPIO);



	superio_outb(0, WDT_CONFIG);

	superio_outb(0, WDT_CONTROL);

	superio_outb(0, WDT_TIMEOUT);



	superio_exit();

}



static int

it8712f_wdt_notify(struct notifier_block *this,

		    unsigned long code, void *unused)

{

	if (code == SYS_HALT || code == SYS_POWER_OFF)

		if (!nowayout)

			it8712f_wdt_disable();



	return NOTIFY_DONE;

}



static struct notifier_block it8712f_wdt_notifier = {

	.notifier_call = it8712f_wdt_notify,

};



static ssize_t

it8712f_wdt_write(struct file *file, const char __user *data,

	size_t len, loff_t *ppos)

{

	/* check for a magic close character */

	if (len) {

		size_t i;



		it8712f_wdt_ping();



		expect_close = 0;

		for (i = 0; i < len; ++i) {

			char c;

			if (get_user(c, data+i))

				return -EFAULT;

			if (c == 'V')

				expect_close = 42;

		}

	}



	return len;

}



static int

it8712f_wdt_ioctl(struct inode *inode, struct file *file,

	unsigned int cmd, unsigned long arg)

{

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

	int __user *p = argp;

	static struct watchdog_info ident = {

		.identity = "IT8712F Watchdog",

		.firmware_version = 1,

		.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,

	};

	int new_margin;



	switch (cmd) {

	default:

		return -ENOTTY;

	case WDIOC_GETSUPPORT:

		if (copy_to_user(argp, &ident, sizeof(ident)))

			return -EFAULT;

		return 0;

	case WDIOC_GETSTATUS:

	case WDIOC_GETBOOTSTATUS:

		return put_user(0, p);

	case WDIOC_KEEPALIVE:

		it8712f_wdt_ping();

		return 0;

	case WDIOC_SETTIMEOUT:

		if (get_user(new_margin, p))

			return -EFAULT;

		if (new_margin < 1)

			return -EINVAL;

		margin = new_margin;

		superio_enter();

		superio_select(LDN_GPIO);



		it8712f_wdt_update_margin();



		superio_exit();

		it8712f_wdt_ping();

	case WDIOC_GETTIMEOUT:

		if (put_user(margin, p))

			return -EFAULT;

		return 0;

	}

}



static int

it8712f_wdt_open(struct inode *inode, struct file *file)

{

	/* only allow one at a time */

	if (down_trylock(&it8712f_wdt_sem))

		return -EBUSY;

	it8712f_wdt_enable();



	return nonseekable_open(inode, file);

}



static int

it8712f_wdt_release(struct inode *inode, struct file *file)

{

	if (expect_close != 42) {

		printk(KERN_WARNING NAME

			": watchdog device closed unexpectedly, will not"

			" disable the watchdog timer\n");

	} else if (!nowayout) {

		it8712f_wdt_disable();

	}

	expect_close = 0;

	up(&it8712f_wdt_sem);



	return 0;

}



static struct file_operations it8712f_wdt_fops = {

	.owner = THIS_MODULE,

	.llseek = no_llseek,

	.write = it8712f_wdt_write,

	.ioctl = it8712f_wdt_ioctl,

	.open = it8712f_wdt_open,

	.release = it8712f_wdt_release,

};



static struct miscdevice it8712f_wdt_miscdev = {

	.minor = WATCHDOG_MINOR,

	.name = "watchdog",

	.fops = &it8712f_wdt_fops,

};



static int __init

it8712f_wdt_find(unsigned short *address)

{

	int err = -ENODEV;

	int chip_type;



	superio_enter();

	chip_type = superio_inw(DEVID);

	if (chip_type != IT8712F_DEVID)

		goto exit;



	superio_select(LDN_GAME);

	superio_outb(1, ACT_REG);

	if (!(superio_inb(ACT_REG) & 0x01)) {

		printk(KERN_ERR NAME ": Device not activated, skipping\n");

		goto exit;

	}



	*address = superio_inw(BASE_REG);

	if (*address == 0) {

		printk(KERN_ERR NAME ": Base address not set, skipping\n");

		goto exit;

	}



	err = 0;

	printk(KERN_DEBUG NAME ": Found IT%04xF chip revision %d - "

		"using DogFood address 0x%x\n",

		chip_type, superio_inb(DEVREV) & 0x0f, *address);



exit:

	superio_exit();

	return err;

}



static int __init

it8712f_wdt_init(void)

{

	int err = 0;



	spin_lock_init(&io_lock);



	if (it8712f_wdt_find(&address))

		return -ENODEV;



	if (!request_region(address, 1, "IT8712F Watchdog")) {

		printk(KERN_WARNING NAME ": watchdog I/O region busy\n");

		return -EBUSY;

	}



	it8712f_wdt_disable();



	sema_init(&it8712f_wdt_sem, 1);



	err = register_reboot_notifier(&it8712f_wdt_notifier);

	if (err) {

		printk(KERN_ERR NAME ": unable to register reboot notifier\n");

		goto out;

	}



	err = misc_register(&it8712f_wdt_miscdev);

	if (err) {

		printk(KERN_ERR NAME

			": cannot register miscdev on minor=%d (err=%d)\n",

			WATCHDOG_MINOR, err);

		goto reboot_out;

	}



	return 0;





reboot_out:

	unregister_reboot_notifier(&it8712f_wdt_notifier);

out:

	release_region(address, 1);

	return err;

}



static void __exit

it8712f_wdt_exit(void)

{

	misc_deregister(&it8712f_wdt_miscdev);

	unregister_reboot_notifier(&it8712f_wdt_notifier);

	release_region(address, 1);

}



module_init(it8712f_wdt_init);

module_exit(it8712f_wdt_exit);