diff -Naur linux-2.6.9.orrig/drivers/char/watchdog/Kconfig linux-2.6.9/drivers/char/watchdog/Kconfig --- linux-2.6.9.orrig/drivers/char/watchdog/Kconfig 2004-10-18 21:54:38.000000000 +0000 +++ linux-2.6.9/drivers/char/watchdog/Kconfig 2004-12-01 02:47:09.000000000 +0000 @@ -254,6 +254,15 @@ If compiled as a module, it will be called scx200_watchdog. + +config SC1100_WDT + tristate "Geode SC1100 Watchdog Timer" + depends on WATCHDOG && X86 && MGEODE + help + If you have a National Semi Conductor Geode SC1100 say 'Y' + to this feature to enable support of it's internal watchdog. + + config 60XX_WDT tristate "SBC-60XX Watchdog Timer" depends on WATCHDOG && X86 diff -Naur linux-2.6.9.orrig/drivers/char/watchdog/Makefile linux-2.6.9/drivers/char/watchdog/Makefile --- linux-2.6.9.orrig/drivers/char/watchdog/Makefile 2004-10-18 21:54:40.000000000 +0000 +++ linux-2.6.9/drivers/char/watchdog/Makefile 2004-12-01 02:47:09.000000000 +0000 @@ -30,6 +30,7 @@ obj-$(CONFIG_ALIM7101_WDT) += alim7101_wdt.o obj-$(CONFIG_ALIM1535_WDT) += alim1535_wdt.o obj-$(CONFIG_SC1200_WDT) += sc1200wdt.o +obj-$(CONFIG_SC1100_WDT) += sc1100wdt.o obj-$(CONFIG_WAFER_WDT) += wafer5823wdt.o obj-$(CONFIG_CPU5_WDT) += cpu5wdt.o obj-$(CONFIG_INDYDOG) += indydog.o diff -Naur linux-2.6.9.orrig/drivers/char/watchdog/sc1100wdt.c linux-2.6.9/drivers/char/watchdog/sc1100wdt.c --- linux-2.6.9.orrig/drivers/char/watchdog/sc1100wdt.c 1970-01-01 00:00:00.000000000 +0000 +++ linux-2.6.9/drivers/char/watchdog/sc1100wdt.c 2004-12-01 02:47:09.000000000 +0000 @@ -0,0 +1,388 @@ +/* + * National Semiconductor SC1x00 CPU watchdog driver + * Copyright (c) Inprimis Technologies 2002 + * + * by Mark Grosberg + * and Rolando Goldman + * + * Minor changes by Kianusch Sayah Karadji + * ( Soekris net4801 Support, module-parameter ) + * + * Porting from 2.4.27 to 2.6.8.1 by Cedric Bail + * + * 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. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * Since the SC1100 is an x86 clone, we don't even bother with + * allowing other architectures to compile us. + */ +#ifndef CONFIG_X86 +# error Sorry this driver is only for x86. +#endif + +#include +#include +#include +#include +#include + +#define SC1100_MODULE_VER "build 20041009" +#define SC1100_MODULE_NAME "sc1100wdt" +#define PFX SC1100_MODULE_NAME ": " + +/* Register definitions */ + +#define SC1100_F5_VENDOR_ID 0x100B +#define SC1100_F5_DEVICE_ID 0x0515 + +#define CPU_WDTO_REG 0x00 /* watchdog time out, 16 bit register */ +#define CPU_WDCNFG_REG 0x02 /* watchdog config , 16 bit register */ +#define CPU_WDSTS_REG 0x04 /* watchdog status , 8 bit register */ + +/* Default timeout: 60 seconds (changeable via sysctl) */ +static int timeout = 60; +#ifdef CONFIG_WATCHDOG_NOWAYOUT +static int graceful = 0; +#else +static int graceful = 1; +#endif + +module_param (timeout, int, 0); +MODULE_PARM_DESC (timeout, "range is 0-65534, default is 60s"); +module_param (graceful, int, 0); +MODULE_PARM_DESC (graceful, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)"); + +static unsigned short cpu_base; +static char expect_close; + +static spinlock_t sc1100wdt_lock; +static struct semaphore sc1100wdt_open_sem; + +/*******************************************************/ + +/* Read byte from Register */ +static inline unsigned char sc1100wdt_read_datab (int port) +{ + unsigned char result; + + spin_lock (&sc1100wdt_lock); + result = inb (port); + spin_unlock (&sc1100wdt_lock); + + return result; +} + +/* Read word from Register */ +static inline unsigned short sc1100wdt_read_dataw (int port) +{ + unsigned char result; + + spin_lock (&sc1100wdt_lock); + result = inw (port); + spin_unlock (&sc1100wdt_lock); + + return result; +} + +/* Write byte to Register */ +static inline void sc1100wdt_write_datab (unsigned char value, + int port) +{ + spin_lock (&sc1100wdt_lock); + outb (value, port); + spin_unlock (&sc1100wdt_lock); +} + +/* Write word to Register */ +static inline void sc1100wdt_write_dataw (unsigned short value, + int port) +{ + spin_lock (&sc1100wdt_lock); + outw (value, port); + spin_unlock (&sc1100wdt_lock); +} + +/* Resest Watchdog */ +static inline void sc1100wdt_reset (void) +{ + /* timeout << 3 == timeout * 8 */ + sc1100wdt_write_dataw (timeout << 3, cpu_base + CPU_WDTO_REG); +} + +/* Stop watchdog */ +static inline void sc1100wdt_stop (void) +{ + sc1100wdt_write_dataw (0, cpu_base + CPU_WDCNFG_REG); +} + +/* Start watchdog */ +static int sc1100wdt_start (void) +{ + /* + * Configure the chip to do a reset if the timer goes to 0. + * Set the clock divisor to 4096. + */ + sc1100wdt_write_dataw (0xfc, cpu_base + CPU_WDCNFG_REG); + + /* Start the watchdog: It won't run until we write the TO reg. */ + sc1100wdt_reset (); + + return 0; +} + +static int sc1100wdt_status (void) +{ + /* >> 3 == / 8 */ + return sc1100wdt_read_dataw (cpu_base + CPU_WDTO_REG) >> 3; +} + +static int sc1100wdt_reboot_reason (void) +{ + static int result; + static int fetched = 0; + + if (!fetched) + { + unsigned char sr; + + sr = sc1100wdt_read_datab (cpu_base + CPU_WDSTS_REG); + sc1100wdt_write_datab (sr | 1, cpu_base + CPU_WDSTS_REG); + + fetched = 1; + result = sr; + } + + return result; +} + +static int sc1100wdt_ioctl (struct inode *inode, + struct file *file, + unsigned int cmd, + unsigned long arg) +{ + void __user *argp = (void __user *)arg; + int __user *intp = argp; + int tmp = 0; + + static struct watchdog_info ident = { + .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE, + .firmware_version = 0, + .identity = "NSC SC1x00 WD" + }; + + switch (cmd) + { + default: + return -ENOIOCTLCMD; + + case WDIOC_GETSUPPORT: + if (copy_to_user (argp, &ident, sizeof ident)) + return -EFAULT; + return 0; + + case WDIOC_GETSTATUS: + return put_user (sc1100wdt_status (), intp); + + case WDIOC_GETBOOTSTATUS: + return put_user (sc1100wdt_reboot_reason (), intp); + + case WDIOC_SETTIMEOUT: + if (get_user (tmp, intp)) + return -EFAULT; + + timeout = tmp; + + case WDIOC_KEEPALIVE: + sc1100wdt_reset (); + return 0; + + case WDIOC_GETTIMEOUT: + return put_user (timeout, intp); + } + +} + +static int sc1100wdt_open (struct inode *inode, + struct file *file) +{ + nonseekable_open (inode, file); + + /* allow one at a time */ + if (down_trylock (&sc1100wdt_open_sem)) + return -EBUSY; + + timeout = (timeout < 1) ? 1 : ((timeout > 65535) ? 65535 : timeout); + expect_close = 0; + + sc1100wdt_start (); + printk (KERN_INFO PFX "Watchdog enabled, timeout = %d sec, graceful %s\n", + timeout, graceful ? "yes": "no"); + + return 0; +} + +static int sc1100wdt_release (struct inode *inode, + struct file *file) +{ + sc1100wdt_reset (); + + if (expect_close == 42) + sc1100wdt_stop (); + + up (&sc1100wdt_open_sem); + + if (expect_close == 42) + printk ("Watchdog disabled\n"); + else + printk ("Watchdog still running !\n"); + + return 0; +} + +static ssize_t sc1100wdt_write (struct file *file, + const char *data, + size_t len, + loff_t *ppos) +{ + if (len) { + if (graceful) { + size_t i; + + 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; + } + } + + sc1100wdt_reset (); + + return len; + } + + return 0; +} + +static int sc1100wdt_notify_sys (struct notifier_block *this, + unsigned long code, + void *unused) +{ + if (code == SYS_DOWN || code == SYS_HALT) + sc1100wdt_stop(); + + return NOTIFY_DONE; +} + +static struct notifier_block sc1100wdt_notifier = + { + .notifier_call = sc1100wdt_notify_sys + }; + +static struct file_operations sc1100wdt_fops = + { + .owner = THIS_MODULE, + .write = sc1100wdt_write, + .ioctl = sc1100wdt_ioctl, + .open = sc1100wdt_open, + .release = sc1100wdt_release + }; + +static struct miscdevice sc1100wdt_miscdev = + { + .minor = WATCHDOG_MINOR, + .name = "watchdog", + .fops = &sc1100wdt_fops + }; + +static int __init sc1100wdt_init (void) +{ + int ret; + struct pci_dev *dev; + unsigned int cw; + + if ((strcmp (boot_cpu_data.x86_vendor_id, "Geode by NSC") != 0) + || (boot_cpu_data.x86_model != 4 && boot_cpu_data.x86_model != 9)) + { + printk (KERN_WARNING "sc1100wdt.c: This is not an SC1100 processor !\n"); + return -EINVAL; + } + + + /* get the CONFIG BLOCK ADDRESS from scratch pad register */ + dev = pci_find_device(SC1100_F5_VENDOR_ID,SC1100_F5_DEVICE_ID,0); + if (dev == NULL) + { + printk(KERN_ERR "sc1100wdt.c: Can not find bridge device.\n"); + return 0; + } + + pci_read_config_dword(dev, 0x64, &cw); + cpu_base = (unsigned short) cw; + + printk(KERN_INFO "SC1x00 Watchdog driver by Inprimis Technolgies.\n"); + + /* + * We must call reboot_reason() to reset the flag in the WD. + * + * Even though it is available as an ioctl(), we call it during + * module initialization to perform the clear. You can take out + * the printk(), but don't take out the call to reboot_reason(). + */ + if (sc1100wdt_reboot_reason ()) + printk(KERN_INFO "Last reboot was by watchdog!\n"); + + spin_lock_init(&sc1100wdt_lock); + sema_init(&sc1100wdt_open_sem, 1); + + if ((ret = misc_register (&sc1100wdt_miscdev))) + { + printk (KERN_ERR "sc1100wdt.c: Can't register device.\n"); + return ret; + } + + if ((ret = register_reboot_notifier (&sc1100wdt_notifier))) + { + printk(KERN_ERR PFX "Unable to register reboot notifier.\n"); + return ret; + } + + return 0; +} + +static void __exit sc1100wdt_exit (void) +{ + misc_deregister (&sc1100wdt_miscdev); + unregister_reboot_notifier (&sc1100wdt_notifier); +} + +module_init (sc1100wdt_init); +module_exit (sc1100wdt_exit); + +MODULE_AUTHOR ("Bail Cedric "); +MODULE_DESCRIPTION ("Driver for National Semiconductor SC1100 watchdog component"); +MODULE_LICENSE ("GPL"); +MODULE_ALIAS_MISCDEV (WATCHDOG_MINOR);