1/* 2 * w83627hf/thf WDT driver 3 * 4 * (c) Copyright 2007 Vlad Drukker <vlad@storewiz.com> 5 * added support for W83627THF. 6 * 7 * (c) Copyright 2003 P�draig Brady <P@draigBrady.com> 8 * 9 * Based on advantechwdt.c which is based on wdt.c. 10 * Original copyright messages: 11 * 12 * (c) Copyright 2000-2001 Marek Michalkiewicz <marekm@linux.org.pl> 13 * 14 * (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved. 15 * http://www.redhat.com 16 * 17 * This program is free software; you can redistribute it and/or 18 * modify it under the terms of the GNU General Public License 19 * as published by the Free Software Foundation; either version 20 * 2 of the License, or (at your option) any later version. 21 * 22 * Neither Alan Cox nor CymruNet Ltd. admit liability nor provide 23 * warranty for any of this software. This material is provided 24 * "AS-IS" and at no charge. 25 * 26 * (c) Copyright 1995 Alan Cox <alan@redhat.com> 27 */ 28 29#include <linux/module.h> 30#include <linux/moduleparam.h> 31#include <linux/types.h> 32#include <linux/miscdevice.h> 33#include <linux/watchdog.h> 34#include <linux/fs.h> 35#include <linux/ioport.h> 36#include <linux/notifier.h> 37#include <linux/reboot.h> 38#include <linux/init.h> 39#include <linux/spinlock.h> 40 41#include <asm/io.h> 42#include <asm/uaccess.h> 43#include <asm/system.h> 44 45#define WATCHDOG_NAME "w83627hf/thf WDT" 46#define PFX WATCHDOG_NAME ": " 47#define WATCHDOG_TIMEOUT 60 /* 60 sec default timeout */ 48 49static unsigned long wdt_is_open; 50static char expect_close; 51static spinlock_t io_lock; 52 53/* You must set this - there is no sane way to probe for this board. */ 54static int wdt_io = 0x2E; 55module_param(wdt_io, int, 0); 56MODULE_PARM_DESC(wdt_io, "w83627hf/thf WDT io port (default 0x2E)"); 57 58static int timeout = WATCHDOG_TIMEOUT; /* in seconds */ 59module_param(timeout, int, 0); 60MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. 1<= timeout <=63, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) "."); 61 62static int nowayout = WATCHDOG_NOWAYOUT; 63module_param(nowayout, int, 0); 64MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 65 66/* 67 * Kernel methods. 68 */ 69 70#define WDT_EFER (wdt_io+0) /* Extended Function Enable Registers */ 71#define WDT_EFIR (wdt_io+0) /* Extended Function Index Register (same as EFER) */ 72#define WDT_EFDR (WDT_EFIR+1) /* Extended Function Data Register */ 73 74static void 75w83627hf_select_wd_register(void) 76{ 77 unsigned char c; 78 outb_p(0x87, WDT_EFER); /* Enter extended function mode */ 79 outb_p(0x87, WDT_EFER); /* Again according to manual */ 80 81 outb(0x20, WDT_EFER); /* check chip version */ 82 c = inb(WDT_EFDR); 83 if (c == 0x82) { /* W83627THF */ 84 outb_p(0x2b, WDT_EFER); /* select GPIO3 */ 85 c = ((inb_p(WDT_EFDR) & 0xf7) | 0x04); /* select WDT0 */ 86 outb_p(0x2b, WDT_EFER); 87 outb_p(c, WDT_EFDR); /* set GPIO3 to WDT0 */ 88 } 89 90 outb_p(0x07, WDT_EFER); /* point to logical device number reg */ 91 outb_p(0x08, WDT_EFDR); /* select logical device 8 (GPIO2) */ 92 outb_p(0x30, WDT_EFER); /* select CR30 */ 93 outb_p(0x01, WDT_EFDR); /* set bit 0 to activate GPIO2 */ 94} 95 96static void 97w83627hf_unselect_wd_register(void) 98{ 99 outb_p(0xAA, WDT_EFER); /* Leave extended function mode */ 100} 101 102/* tyan motherboards seem to set F5 to 0x4C ? 103 * So explicitly init to appropriate value. */ 104static void 105w83627hf_init(void) 106{ 107 unsigned char t; 108 109 w83627hf_select_wd_register(); 110 111 outb_p(0xF6, WDT_EFER); /* Select CRF6 */ 112 t=inb_p(WDT_EFDR); /* read CRF6 */ 113 if (t != 0) { 114 printk (KERN_INFO PFX "Watchdog already running. Resetting timeout to %d sec\n", timeout); 115 outb_p(timeout, WDT_EFDR); /* Write back to CRF6 */ 116 } 117 outb_p(0xF5, WDT_EFER); /* Select CRF5 */ 118 t=inb_p(WDT_EFDR); /* read CRF5 */ 119 t&=~0x0C; /* set second mode & disable keyboard turning off watchdog */ 120 outb_p(t, WDT_EFDR); /* Write back to CRF5 */ 121 122 w83627hf_unselect_wd_register(); 123} 124 125static void 126wdt_ctrl(int timeout) 127{ 128 spin_lock(&io_lock); 129 130 w83627hf_select_wd_register(); 131 132 outb_p(0xF6, WDT_EFER); /* Select CRF6 */ 133 outb_p(timeout, WDT_EFDR); /* Write Timeout counter to CRF6 */ 134 135 w83627hf_unselect_wd_register(); 136 137 spin_unlock(&io_lock); 138} 139 140static int 141wdt_ping(void) 142{ 143 wdt_ctrl(timeout); 144 return 0; 145} 146 147static int 148wdt_disable(void) 149{ 150 wdt_ctrl(0); 151 return 0; 152} 153 154static int 155wdt_set_heartbeat(int t) 156{ 157 if ((t < 1) || (t > 63)) 158 return -EINVAL; 159 160 timeout = t; 161 return 0; 162} 163 164static ssize_t 165wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 166{ 167 if (count) { 168 if (!nowayout) { 169 size_t i; 170 171 expect_close = 0; 172 173 for (i = 0; i != count; i++) { 174 char c; 175 if (get_user(c, buf+i)) 176 return -EFAULT; 177 if (c == 'V') 178 expect_close = 42; 179 } 180 } 181 wdt_ping(); 182 } 183 return count; 184} 185 186static int 187wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 188 unsigned long arg) 189{ 190 void __user *argp = (void __user *)arg; 191 int __user *p = argp; 192 int new_timeout; 193 static struct watchdog_info ident = { 194 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE, 195 .firmware_version = 1, 196 .identity = "W83627HF WDT", 197 }; 198 199 switch (cmd) { 200 case WDIOC_GETSUPPORT: 201 if (copy_to_user(argp, &ident, sizeof(ident))) 202 return -EFAULT; 203 break; 204 205 case WDIOC_GETSTATUS: 206 case WDIOC_GETBOOTSTATUS: 207 return put_user(0, p); 208 209 case WDIOC_KEEPALIVE: 210 wdt_ping(); 211 break; 212 213 case WDIOC_SETTIMEOUT: 214 if (get_user(new_timeout, p)) 215 return -EFAULT; 216 if (wdt_set_heartbeat(new_timeout)) 217 return -EINVAL; 218 wdt_ping(); 219 /* Fall */ 220 221 case WDIOC_GETTIMEOUT: 222 return put_user(timeout, p); 223 224 case WDIOC_SETOPTIONS: 225 { 226 int options, retval = -EINVAL; 227 228 if (get_user(options, p)) 229 return -EFAULT; 230 231 if (options & WDIOS_DISABLECARD) { 232 wdt_disable(); 233 retval = 0; 234 } 235 236 if (options & WDIOS_ENABLECARD) { 237 wdt_ping(); 238 retval = 0; 239 } 240 241 return retval; 242 } 243 244 default: 245 return -ENOTTY; 246 } 247 return 0; 248} 249 250static int 251wdt_open(struct inode *inode, struct file *file) 252{ 253 if (test_and_set_bit(0, &wdt_is_open)) 254 return -EBUSY; 255 /* 256 * Activate 257 */ 258 259 wdt_ping(); 260 return nonseekable_open(inode, file); 261} 262 263static int 264wdt_close(struct inode *inode, struct file *file) 265{ 266 if (expect_close == 42) { 267 wdt_disable(); 268 } else { 269 printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n"); 270 wdt_ping(); 271 } 272 expect_close = 0; 273 clear_bit(0, &wdt_is_open); 274 return 0; 275} 276 277/* 278 * Notifier for system down 279 */ 280 281static int 282wdt_notify_sys(struct notifier_block *this, unsigned long code, 283 void *unused) 284{ 285 if (code == SYS_DOWN || code == SYS_HALT) { 286 /* Turn the WDT off */ 287 wdt_disable(); 288 } 289 return NOTIFY_DONE; 290} 291 292/* 293 * Kernel Interfaces 294 */ 295 296static const struct file_operations wdt_fops = { 297 .owner = THIS_MODULE, 298 .llseek = no_llseek, 299 .write = wdt_write, 300 .ioctl = wdt_ioctl, 301 .open = wdt_open, 302 .release = wdt_close, 303}; 304 305static struct miscdevice wdt_miscdev = { 306 .minor = WATCHDOG_MINOR, 307 .name = "watchdog", 308 .fops = &wdt_fops, 309}; 310 311/* 312 * The WDT needs to learn about soft shutdowns in order to 313 * turn the timebomb registers off. 314 */ 315 316static struct notifier_block wdt_notifier = { 317 .notifier_call = wdt_notify_sys, 318}; 319 320static int __init 321wdt_init(void) 322{ 323 int ret; 324 325 spin_lock_init(&io_lock); 326 327 printk(KERN_INFO "WDT driver for the Winbond(TM) W83627HF/THF Super I/O chip initialising.\n"); 328 329 if (wdt_set_heartbeat(timeout)) { 330 wdt_set_heartbeat(WATCHDOG_TIMEOUT); 331 printk (KERN_INFO PFX "timeout value must be 1<=timeout<=63, using %d\n", 332 WATCHDOG_TIMEOUT); 333 } 334 335 if (!request_region(wdt_io, 1, WATCHDOG_NAME)) { 336 printk (KERN_ERR PFX "I/O address 0x%04x already in use\n", 337 wdt_io); 338 ret = -EIO; 339 goto out; 340 } 341 342 w83627hf_init(); 343 344 ret = register_reboot_notifier(&wdt_notifier); 345 if (ret != 0) { 346 printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n", 347 ret); 348 goto unreg_regions; 349 } 350 351 ret = misc_register(&wdt_miscdev); 352 if (ret != 0) { 353 printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n", 354 WATCHDOG_MINOR, ret); 355 goto unreg_reboot; 356 } 357 358 printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n", 359 timeout, nowayout); 360 361out: 362 return ret; 363unreg_reboot: 364 unregister_reboot_notifier(&wdt_notifier); 365unreg_regions: 366 release_region(wdt_io, 1); 367 goto out; 368} 369 370static void __exit 371wdt_exit(void) 372{ 373 misc_deregister(&wdt_miscdev); 374 unregister_reboot_notifier(&wdt_notifier); 375 release_region(wdt_io,1); 376} 377 378module_init(wdt_init); 379module_exit(wdt_exit); 380 381MODULE_LICENSE("GPL"); 382MODULE_AUTHOR("P�draig Brady <P@draigBrady.com>"); 383MODULE_DESCRIPTION("w83627hf/thf WDT driver"); 384MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 385