[WATCHDOG] w83697hf WDT driver (f9a8c891) · Commits · e / devices / android_kernel_sony_msm8994

drivers/char/watchdog/Kconfig

+13 −0

Original line number	Diff line number	Diff line
		@@ -430,6 +430,19 @@ config W83627HF_WDT

		Most people will say N.

		config W83697HF_WDT
		tristate "W83697HF Watchdog Timer"
		depends on WATCHDOG && X86
		---help---
		This is the driver for the hardware watchdog on the W83697HF chipset
		This watchdog simply watches your kernel to make sure it doesn't freeze,
		and if it does, it reboots your computer after a certain amount of time.

		To compile this driver as a module, choose M here: the
		module will be called w83697hf_wdt.

		Most people will say N.

		config W83877F_WDT
		tristate "W83877F (EMACS) Watchdog Timer"
		depends on WATCHDOG && X86

drivers/char/watchdog/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -55,6 +55,7 @@ obj-$(CONFIG_SBC8360_WDT) += sbc8360.o
		obj-$(CONFIG_CPU5_WDT) += cpu5wdt.o
		obj-$(CONFIG_SMSC37B787_WDT) += smsc37b787_wdt.o
		obj-$(CONFIG_W83627HF_WDT) += w83627hf_wdt.o
		obj-$(CONFIG_W83697HF_WDT) += w83697hf_wdt.o
		obj-$(CONFIG_W83877F_WDT) += w83877f_wdt.o
		obj-$(CONFIG_W83977F_WDT) += w83977f_wdt.o
		obj-$(CONFIG_MACHZ_WDT) += machzwd.o

drivers/char/watchdog/w83697hf_wdt.c

0 → 100644

+367 −0

Original line number	Diff line number	Diff line
		/*
		* w83697hf WDT driver
		*
		* (c) Copyright 2006 Marcus Junker <junker@anduras.de>
		*
		* Based on w83627hf_wdt.c advantechwdt.c which is based on wdt.c.
		* Original copyright messages:
		*
		* (c) Copyright 2003 Pdraig Brady <P@draigBrady.com>
		*
		* (c) Copyright 2000-2001 Marek Michalkiewicz <marekm@linux.org.pl>
		*
		* (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
		* http://www.redhat.com
		*
		* 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.
		*
		* Neither Marcus Junker nor ANDURAS AG admit liability nor provide
		* warranty for any of this software. This material is provided
		* "AS-IS" and at no charge.
		*/

		#include <linux/module.h>
		#include <linux/moduleparam.h>
		#include <linux/types.h>
		#include <linux/miscdevice.h>
		#include <linux/watchdog.h>
		#include <linux/fs.h>
		#include <linux/ioport.h>
		#include <linux/notifier.h>
		#include <linux/reboot.h>
		#include <linux/init.h>

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

		#define WATCHDOG_NAME "w83697hf WDT"
		#define PFX WATCHDOG_NAME ": "
		#define WATCHDOG_TIMEOUT 60 /* 60 sec default timeout */

		static unsigned long wdt_is_open;
		static char expect_close;

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

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

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

		/*
		* Kernel methods.
		*/

		#define WDT_EFER (wdt_io+0) /* Extended Function Enable Registers */
		#define WDT_EFIR (wdt_io+0) /* Extended Function Index Register (same as EFER) */
		#define WDT_EFDR (WDT_EFIR+1) /* Extended Function Data Register */

		static void
		w83697hf_select_wd_register(void)
		{
		outb_p(0x87, WDT_EFER); /* Enter extended function mode */
		outb_p(0x87, WDT_EFER); /* Again according to manual */

		outb_p(0x29, WDT_EFER); /* select CR29 */
		outb_p(0x20, WDT_EFDR); /* select WDTO */

		outb_p(0x07, WDT_EFER); /* point to logical device number reg */
		outb_p(0x08, WDT_EFDR); /* select logical device 8 (GPIO2) */
		outb_p(0x30, WDT_EFER); /* select CR30 */
		outb_p(0x01, WDT_EFDR); /* set bit 0 to activate GPIO2 */
		}

		static void
		w83697hf_unselect_wd_register(void)
		{
		outb_p(0xAA, WDT_EFER); /* Leave extended function mode */
		}

		/* tyan motherboards seem to set F5 to 0x4C ?
		* So explicitly init to appropriate value. */
		static void
		w83697hf_init(void)
		{
		unsigned char t;

		w83697hf_select_wd_register();

		outb_p(0xF3, WDT_EFER); /* Select CRF3 */

		t=inb_p(WDT_EFDR); /* read CRF6 */
		if (t != 0) {
		printk (KERN_INFO PFX "Watchdog already running. Resetting timeout to %d sec\n", timeout);
		outb_p(timeout, WDT_EFDR); /* Write back to CRF6 */
		}
		outb_p(0xF4, WDT_EFER); /* Select CRF4 */
		t=inb_p(WDT_EFDR); /* read CRF4 */
		t&=~0x0C; /* set second mode & disable keyboard turning off watchdog */
		outb_p(t, WDT_EFDR); /* Write back to CRF5 */

		w83697hf_unselect_wd_register();
		}

		static void
		wdt_ctrl(int timeout)
		{
		w83697hf_select_wd_register();

		outb_p(0xF4, WDT_EFER); /* Select CRF4 */
		outb_p(timeout, WDT_EFDR); /* Write Timeout counter to CRF4 */

		w83697hf_unselect_wd_register();
		}

		static int
		wdt_ping(void)
		{
		wdt_ctrl(timeout);
		return 0;
		}

		static int
		wdt_disable(void)
		{
		wdt_ctrl(0);
		return 0;
		}

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

		timeout = t;
		return 0;
		}

		static ssize_t
		wdt_write(struct file file, const char __user buf, size_t count, loff_t *ppos)
		{
		if (count) {
		if (!nowayout) {
		size_t i;

		expect_close = 0;

		for (i = 0; i != count; i++) {
		char c;
		if (get_user(c, buf+i))
		return -EFAULT;
		if (c == 'V')
		expect_close = 42;
		}
		}
		wdt_ping();
		}
		return count;
		}

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

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

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

		case WDIOC_KEEPALIVE:
		wdt_ping();
		break;

		case WDIOC_SETTIMEOUT:
		if (get_user(new_timeout, p))
		return -EFAULT;
		if (wdt_set_heartbeat(new_timeout))
		return -EINVAL;
		wdt_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) {
		wdt_disable();
		retval = 0;
		}

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

		return retval;
		}

		default:
		return -ENOIOCTLCMD;
		}
		return 0;
		}

		static int
		wdt_open(struct inode inode, struct file file)
		{
		if (test_and_set_bit(0, &wdt_is_open))
		return -EBUSY;
		/*
		* Activate
		*/

		wdt_ping();
		return nonseekable_open(inode, file);
		}

		static int
		wdt_close(struct inode inode, struct file file)
		{
		if (expect_close == 42) {
		wdt_disable();
		} else {
		printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
		wdt_ping();
		}
		expect_close = 0;
		clear_bit(0, &wdt_is_open);
		return 0;
		}

		/*
		* Notifier for system down
		*/

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

		/*
		* Kernel Interfaces
		*/

		static struct file_operations wdt_fops = {
		.owner = THIS_MODULE,
		.llseek = no_llseek,
		.write = wdt_write,
		.ioctl = wdt_ioctl,
		.open = wdt_open,
		.release = wdt_close,
		};

		static struct miscdevice wdt_miscdev = {
		.minor = WATCHDOG_MINOR,
		.name = "watchdog",
		.fops = &wdt_fops,
		};

		/*
		* The WDT needs to learn about soft shutdowns in order to
		* turn the timebomb registers off.
		*/

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

		static int __init
		wdt_init(void)
		{
		int ret;

		printk(KERN_INFO "WDT driver for the Winbond(TM) W83697HF Super I/O chip initialising.\n");

		if (wdt_set_heartbeat(timeout)) {
		wdt_set_heartbeat(WATCHDOG_TIMEOUT);
		printk (KERN_INFO PFX "timeout value must be 1<=timeout<=63, using %d\n",
		WATCHDOG_TIMEOUT);
		}

		if (!request_region(wdt_io, 1, WATCHDOG_NAME)) {
		printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
		wdt_io);
		ret = -EIO;
		goto out;
		}

		w83697hf_init();

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

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

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

		out:
		return ret;
		unreg_reboot:
		unregister_reboot_notifier(&wdt_notifier);
		unreg_regions:
		release_region(wdt_io, 1);
		goto out;
		}

		static void __exit
		wdt_exit(void)
		{
		misc_deregister(&wdt_miscdev);
		unregister_reboot_notifier(&wdt_notifier);
		release_region(wdt_io,1);
		}

		module_init(wdt_init);
		module_exit(wdt_exit);

		MODULE_LICENSE("GPL");
		MODULE_AUTHOR("Marcus Junker <junker@anduras.de>");
		MODULE_DESCRIPTION("w83697hf WDT driver");
		MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);