1/* 2 * Wdt977 0.04: A Watchdog Device for Netwinder W83977AF chip 3 * 4 * (c) Copyright 1998 Rebel.com (Woody Suwalski <woody@netwinder.org>) 5 * 6 * ----------------------- 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 * 13 * ----------------------- 14 * 14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com> 15 * Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT 16 * 19-Dec-2001 Woody Suwalski: Netwinder fixes, ioctl interface 17 * 06-Jan-2002 Woody Suwalski: For compatibility, convert all timeouts 18 * from minutes to seconds. 19 * 07-Jul-2003 Daniele Bellucci: Audit return code of misc_register in 20 * nwwatchdog_init. 21 * 25-Oct-2005 Woody Suwalski: Convert addresses to #defs, add spinlocks 22 * remove limitiation to be used on 23 * Netwinders only 24 */ 25 26#include <linux/module.h> 27#include <linux/moduleparam.h> 28#include <linux/types.h> 29#include <linux/kernel.h> 30#include <linux/fs.h> 31#include <linux/miscdevice.h> 32#include <linux/init.h> 33#include <linux/ioport.h> 34#include <linux/watchdog.h> 35#include <linux/notifier.h> 36#include <linux/reboot.h> 37#include <linux/io.h> 38#include <linux/uaccess.h> 39 40#include <asm/system.h> 41#include <asm/mach-types.h> 42 43#define WATCHDOG_VERSION "0.04" 44#define WATCHDOG_NAME "Wdt977" 45#define PFX WATCHDOG_NAME ": " 46#define DRIVER_VERSION WATCHDOG_NAME " driver, v" WATCHDOG_VERSION "\n" 47 48#define IO_INDEX_PORT 0x370 /* on some systems it can be 0x3F0 */ 49#define IO_DATA_PORT (IO_INDEX_PORT + 1) 50 51#define UNLOCK_DATA 0x87 52#define LOCK_DATA 0xAA 53#define DEVICE_REGISTER 0x07 54 55 56#define DEFAULT_TIMEOUT 60 /* default timeout in seconds */ 57 58static int timeout = DEFAULT_TIMEOUT; 59static int timeoutM; /* timeout in minutes */ 60static unsigned long timer_alive; 61static int testmode; 62static char expect_close; 63static DEFINE_SPINLOCK(spinlock); 64 65module_param(timeout, int, 0); 66MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (60..15300, default=" 67 __MODULE_STRING(DEFAULT_TIMEOUT) ")"); 68module_param(testmode, int, 0); 69MODULE_PARM_DESC(testmode, "Watchdog testmode (1 = no reboot), default=0"); 70 71static int nowayout = WATCHDOG_NOWAYOUT; 72module_param(nowayout, int, 0); 73MODULE_PARM_DESC(nowayout, 74 "Watchdog cannot be stopped once started (default=" 75 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 76 77/* 78 * Start the watchdog 79 */ 80 81static int wdt977_start(void) 82{ 83 unsigned long flags; 84 85 spin_lock_irqsave(&spinlock, flags); 86 87 /* unlock the SuperIO chip */ 88 outb_p(UNLOCK_DATA, IO_INDEX_PORT); 89 outb_p(UNLOCK_DATA, IO_INDEX_PORT); 90 91 /* select device Aux2 (device=8) and set watchdog regs F2, F3 and F4 92 * F2 has the timeout in minutes 93 * F3 could be set to the POWER LED blink (with GP17 set to PowerLed) 94 * at timeout, and to reset timer on kbd/mouse activity (not impl.) 95 * F4 is used to just clear the TIMEOUT'ed state (bit 0) 96 */ 97 outb_p(DEVICE_REGISTER, IO_INDEX_PORT); 98 outb_p(0x08, IO_DATA_PORT); 99 outb_p(0xF2, IO_INDEX_PORT); 100 outb_p(timeoutM, IO_DATA_PORT); 101 outb_p(0xF3, IO_INDEX_PORT); 102 outb_p(0x00, IO_DATA_PORT); /* another setting is 0E for 103 kbd/mouse/LED */ 104 outb_p(0xF4, IO_INDEX_PORT); 105 outb_p(0x00, IO_DATA_PORT); 106 107 /* At last select device Aux1 (dev=7) and set GP16 as a 108 * watchdog output. In test mode watch the bit 1 on F4 to 109 * indicate "triggered" 110 */ 111 if (!testmode) { 112 outb_p(DEVICE_REGISTER, IO_INDEX_PORT); 113 outb_p(0x07, IO_DATA_PORT); 114 outb_p(0xE6, IO_INDEX_PORT); 115 outb_p(0x08, IO_DATA_PORT); 116 } 117 118 /* lock the SuperIO chip */ 119 outb_p(LOCK_DATA, IO_INDEX_PORT); 120 121 spin_unlock_irqrestore(&spinlock, flags); 122 printk(KERN_INFO PFX "activated.\n"); 123 124 return 0; 125} 126 127/* 128 * Stop the watchdog 129 */ 130 131static int wdt977_stop(void) 132{ 133 unsigned long flags; 134 spin_lock_irqsave(&spinlock, flags); 135 136 /* unlock the SuperIO chip */ 137 outb_p(UNLOCK_DATA, IO_INDEX_PORT); 138 outb_p(UNLOCK_DATA, IO_INDEX_PORT); 139 140 /* select device Aux2 (device=8) and set watchdog regs F2,F3 and F4 141 * F3 is reset to its default state 142 * F4 can clear the TIMEOUT'ed state (bit 0) - back to default 143 * We can not use GP17 as a PowerLed, as we use its usage as a RedLed 144 */ 145 outb_p(DEVICE_REGISTER, IO_INDEX_PORT); 146 outb_p(0x08, IO_DATA_PORT); 147 outb_p(0xF2, IO_INDEX_PORT); 148 outb_p(0xFF, IO_DATA_PORT); 149 outb_p(0xF3, IO_INDEX_PORT); 150 outb_p(0x00, IO_DATA_PORT); 151 outb_p(0xF4, IO_INDEX_PORT); 152 outb_p(0x00, IO_DATA_PORT); 153 outb_p(0xF2, IO_INDEX_PORT); 154 outb_p(0x00, IO_DATA_PORT); 155 156 /* at last select device Aux1 (dev=7) and set 157 GP16 as a watchdog output */ 158 outb_p(DEVICE_REGISTER, IO_INDEX_PORT); 159 outb_p(0x07, IO_DATA_PORT); 160 outb_p(0xE6, IO_INDEX_PORT); 161 outb_p(0x08, IO_DATA_PORT); 162 163 /* lock the SuperIO chip */ 164 outb_p(LOCK_DATA, IO_INDEX_PORT); 165 166 spin_unlock_irqrestore(&spinlock, flags); 167 printk(KERN_INFO PFX "shutdown.\n"); 168 169 return 0; 170} 171 172/* 173 * Send a keepalive ping to the watchdog 174 * This is done by simply re-writing the timeout to reg. 0xF2 175 */ 176 177static int wdt977_keepalive(void) 178{ 179 unsigned long flags; 180 spin_lock_irqsave(&spinlock, flags); 181 182 /* unlock the SuperIO chip */ 183 outb_p(UNLOCK_DATA, IO_INDEX_PORT); 184 outb_p(UNLOCK_DATA, IO_INDEX_PORT); 185 186 /* select device Aux2 (device=8) and kicks watchdog reg F2 */ 187 /* F2 has the timeout in minutes */ 188 outb_p(DEVICE_REGISTER, IO_INDEX_PORT); 189 outb_p(0x08, IO_DATA_PORT); 190 outb_p(0xF2, IO_INDEX_PORT); 191 outb_p(timeoutM, IO_DATA_PORT); 192 193 /* lock the SuperIO chip */ 194 outb_p(LOCK_DATA, IO_INDEX_PORT); 195 spin_unlock_irqrestore(&spinlock, flags); 196 197 return 0; 198} 199 200/* 201 * Set the watchdog timeout value 202 */ 203 204static int wdt977_set_timeout(int t) 205{ 206 int tmrval; 207 208 /* convert seconds to minutes, rounding up */ 209 tmrval = (t + 59) / 60; 210 211 if (machine_is_netwinder()) { 212 /* we have a hw bug somewhere, so each 977 minute is actually 213 * only 30sec. This limits the max timeout to half of device 214 * max of 255 minutes... 215 */ 216 tmrval += tmrval; 217 } 218 219 if (tmrval < 1 || tmrval > 255) 220 return -EINVAL; 221 222 /* timeout is the timeout in seconds, timeoutM is 223 the timeout in minutes) */ 224 timeout = t; 225 timeoutM = tmrval; 226 return 0; 227} 228 229/* 230 * Get the watchdog status 231 */ 232 233static int wdt977_get_status(int *status) 234{ 235 int new_status; 236 unsigned long flags; 237 238 spin_lock_irqsave(&spinlock, flags); 239 240 /* unlock the SuperIO chip */ 241 outb_p(UNLOCK_DATA, IO_INDEX_PORT); 242 outb_p(UNLOCK_DATA, IO_INDEX_PORT); 243 244 /* select device Aux2 (device=8) and read watchdog reg F4 */ 245 outb_p(DEVICE_REGISTER, IO_INDEX_PORT); 246 outb_p(0x08, IO_DATA_PORT); 247 outb_p(0xF4, IO_INDEX_PORT); 248 new_status = inb_p(IO_DATA_PORT); 249 250 /* lock the SuperIO chip */ 251 outb_p(LOCK_DATA, IO_INDEX_PORT); 252 253 spin_unlock_irqrestore(&spinlock, flags); 254 255 *status = 0; 256 if (new_status & 1) 257 *status |= WDIOF_CARDRESET; 258 259 return 0; 260} 261 262 263/* 264 * /dev/watchdog handling 265 */ 266 267static int wdt977_open(struct inode *inode, struct file *file) 268{ 269 /* If the watchdog is alive we don't need to start it again */ 270 if (test_and_set_bit(0, &timer_alive)) 271 return -EBUSY; 272 273 if (nowayout) 274 __module_get(THIS_MODULE); 275 276 wdt977_start(); 277 return nonseekable_open(inode, file); 278} 279 280static int wdt977_release(struct inode *inode, struct file *file) 281{ 282 /* 283 * Shut off the timer. 284 * Lock it in if it's a module and we set nowayout 285 */ 286 if (expect_close == 42) { 287 wdt977_stop(); 288 clear_bit(0, &timer_alive); 289 } else { 290 wdt977_keepalive(); 291 printk(KERN_CRIT PFX 292 "Unexpected close, not stopping watchdog!\n"); 293 } 294 expect_close = 0; 295 return 0; 296} 297 298 299/* 300 * wdt977_write: 301 * @file: file handle to the watchdog 302 * @buf: buffer to write (unused as data does not matter here 303 * @count: count of bytes 304 * @ppos: pointer to the position to write. No seeks allowed 305 * 306 * A write to a watchdog device is defined as a keepalive signal. Any 307 * write of data will do, as we we don't define content meaning. 308 */ 309 310static ssize_t wdt977_write(struct file *file, const char __user *buf, 311 size_t count, loff_t *ppos) 312{ 313 if (count) { 314 if (!nowayout) { 315 size_t i; 316 317 /* In case it was set long ago */ 318 expect_close = 0; 319 320 for (i = 0; i != count; i++) { 321 char c; 322 if (get_user(c, buf + i)) 323 return -EFAULT; 324 if (c == 'V') 325 expect_close = 42; 326 } 327 } 328 329 /* someone wrote to us, we should restart timer */ 330 wdt977_keepalive(); 331 } 332 return count; 333} 334 335static const struct watchdog_info ident = { 336 .options = WDIOF_SETTIMEOUT | 337 WDIOF_MAGICCLOSE | 338 WDIOF_KEEPALIVEPING, 339 .firmware_version = 1, 340 .identity = WATCHDOG_NAME, 341}; 342 343/* 344 * wdt977_ioctl: 345 * @inode: inode of the device 346 * @file: file handle to the device 347 * @cmd: watchdog command 348 * @arg: argument pointer 349 * 350 * The watchdog API defines a common set of functions for all watchdogs 351 * according to their available features. 352 */ 353 354static long wdt977_ioctl(struct file *file, unsigned int cmd, 355 unsigned long arg) 356{ 357 int status; 358 int new_options, retval = -EINVAL; 359 int new_timeout; 360 union { 361 struct watchdog_info __user *ident; 362 int __user *i; 363 } uarg; 364 365 uarg.i = (int __user *)arg; 366 367 switch (cmd) { 368 case WDIOC_GETSUPPORT: 369 return copy_to_user(uarg.ident, &ident, 370 sizeof(ident)) ? -EFAULT : 0; 371 372 case WDIOC_GETSTATUS: 373 wdt977_get_status(&status); 374 return put_user(status, uarg.i); 375 376 case WDIOC_GETBOOTSTATUS: 377 return put_user(0, uarg.i); 378 379 case WDIOC_SETOPTIONS: 380 if (get_user(new_options, uarg.i)) 381 return -EFAULT; 382 383 if (new_options & WDIOS_DISABLECARD) { 384 wdt977_stop(); 385 retval = 0; 386 } 387 388 if (new_options & WDIOS_ENABLECARD) { 389 wdt977_start(); 390 retval = 0; 391 } 392 393 return retval; 394 395 case WDIOC_KEEPALIVE: 396 wdt977_keepalive(); 397 return 0; 398 399 case WDIOC_SETTIMEOUT: 400 if (get_user(new_timeout, uarg.i)) 401 return -EFAULT; 402 403 if (wdt977_set_timeout(new_timeout)) 404 return -EINVAL; 405 406 wdt977_keepalive(); 407 /* Fall */ 408 409 case WDIOC_GETTIMEOUT: 410 return put_user(timeout, uarg.i); 411 412 default: 413 return -ENOTTY; 414 415 } 416} 417 418static int wdt977_notify_sys(struct notifier_block *this, unsigned long code, 419 void *unused) 420{ 421 if (code == SYS_DOWN || code == SYS_HALT) 422 wdt977_stop(); 423 return NOTIFY_DONE; 424} 425 426static const struct file_operations wdt977_fops = { 427 .owner = THIS_MODULE, 428 .llseek = no_llseek, 429 .write = wdt977_write, 430 .unlocked_ioctl = wdt977_ioctl, 431 .open = wdt977_open, 432 .release = wdt977_release, 433}; 434 435static struct miscdevice wdt977_miscdev = { 436 .minor = WATCHDOG_MINOR, 437 .name = "watchdog", 438 .fops = &wdt977_fops, 439}; 440 441static struct notifier_block wdt977_notifier = { 442 .notifier_call = wdt977_notify_sys, 443}; 444 445static int __init wd977_init(void) 446{ 447 int rc; 448 449 printk(KERN_INFO PFX DRIVER_VERSION); 450 451 /* Check that the timeout value is within its range; 452 if not reset to the default */ 453 if (wdt977_set_timeout(timeout)) { 454 wdt977_set_timeout(DEFAULT_TIMEOUT); 455 printk(KERN_INFO PFX 456 "timeout value must be 60 < timeout < 15300, using %d\n", 457 DEFAULT_TIMEOUT); 458 } 459 460 /* on Netwinder the IOports are already reserved by 461 * arch/arm/mach-footbridge/netwinder-hw.c 462 */ 463 if (!machine_is_netwinder()) { 464 if (!request_region(IO_INDEX_PORT, 2, WATCHDOG_NAME)) { 465 printk(KERN_ERR PFX 466 "I/O address 0x%04x already in use\n", 467 IO_INDEX_PORT); 468 rc = -EIO; 469 goto err_out; 470 } 471 } 472 473 rc = register_reboot_notifier(&wdt977_notifier); 474 if (rc) { 475 printk(KERN_ERR PFX 476 "cannot register reboot notifier (err=%d)\n", rc); 477 goto err_out_region; 478 } 479 480 rc = misc_register(&wdt977_miscdev); 481 if (rc) { 482 printk(KERN_ERR PFX 483 "cannot register miscdev on minor=%d (err=%d)\n", 484 wdt977_miscdev.minor, rc); 485 goto err_out_reboot; 486 } 487 488 printk(KERN_INFO PFX 489 "initialized. timeout=%d sec (nowayout=%d, testmode=%i)\n", 490 timeout, nowayout, testmode); 491 492 return 0; 493 494err_out_reboot: 495 unregister_reboot_notifier(&wdt977_notifier); 496err_out_region: 497 if (!machine_is_netwinder()) 498 release_region(IO_INDEX_PORT, 2); 499err_out: 500 return rc; 501} 502 503static void __exit wd977_exit(void) 504{ 505 wdt977_stop(); 506 misc_deregister(&wdt977_miscdev); 507 unregister_reboot_notifier(&wdt977_notifier); 508 release_region(IO_INDEX_PORT, 2); 509} 510 511module_init(wd977_init); 512module_exit(wd977_exit); 513 514MODULE_AUTHOR("Woody Suwalski <woodys@xandros.com>"); 515MODULE_DESCRIPTION("W83977AF Watchdog driver"); 516MODULE_LICENSE("GPL"); 517MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 518