1 /* 2 * AMD Elan SC520 processor Watchdog Timer driver 3 * 4 * Based on acquirewdt.c by Alan Cox, 5 * and sbc60xxwdt.c by Jakob Oestergaard <jakob@unthought.net> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 * 12 * The authors do NOT admit liability nor provide warranty for 13 * any of this software. This material is provided "AS-IS" in 14 * the hope that it may be useful for others. 15 * 16 * (c) Copyright 2001 Scott Jennings <linuxdrivers@oro.net> 17 * 9/27 - 2001 [Initial release] 18 * 19 * Additional fixes Alan Cox 20 * - Fixed formatting 21 * - Removed debug printks 22 * - Fixed SMP built kernel deadlock 23 * - Switched to private locks not lock_kernel 24 * - Used ioremap/writew/readw 25 * - Added NOWAYOUT support 26 * 4/12 - 2002 Changes by Rob Radez <rob@osinvestor.com> 27 * - Change comments 28 * - Eliminate fop_llseek 29 * - Change CONFIG_WATCHDOG_NOWAYOUT semantics 30 * - Add KERN_* tags to printks 31 * - fix possible wdt_is_open race 32 * - Report proper capabilities in watchdog_info 33 * - Add WDIOC_{GETSTATUS, GETBOOTSTATUS, SETTIMEOUT, 34 * GETTIMEOUT, SETOPTIONS} ioctls 35 * 09/8 - 2003 Changes by Wim Van Sebroeck <wim@iguana.be> 36 * - cleanup of trailing spaces 37 * - added extra printk's for startup problems 38 * - use module_param 39 * - made timeout (the emulated heartbeat) a module_param 40 * - made the keepalive ping an internal subroutine 41 * 3/27 - 2004 Changes by Sean Young <sean@mess.org> 42 * - set MMCR_BASE to 0xfffef000 43 * - CBAR does not need to be read 44 * - removed debugging printks 45 * 46 * This WDT driver is different from most other Linux WDT 47 * drivers in that the driver will ping the watchdog by itself, 48 * because this particular WDT has a very short timeout (1.6 49 * seconds) and it would be insane to count on any userspace 50 * daemon always getting scheduled within that time frame. 51 * 52 * This driver uses memory mapped IO, and spinlock. 53 */ 54 55 #include <linux/module.h> 56 #include <linux/moduleparam.h> 57 #include <linux/types.h> 58 #include <linux/timer.h> 59 #include <linux/miscdevice.h> 60 #include <linux/watchdog.h> 61 #include <linux/fs.h> 62 #include <linux/ioport.h> 63 #include <linux/notifier.h> 64 #include <linux/reboot.h> 65 #include <linux/init.h> 66 #include <linux/jiffies.h> 67 68 #include <asm/io.h> 69 #include <asm/uaccess.h> 70 #include <asm/system.h> 71 72 #define OUR_NAME "sc520_wdt" 73 #define PFX OUR_NAME ": " 74 75 /* 76 * The AMD Elan SC520 timeout value is 492us times a power of 2 (0-7) 77 * 78 * 0: 492us 2: 1.01s 4: 4.03s 6: 16.22s 79 * 1: 503ms 3: 2.01s 5: 8.05s 7: 32.21s 80 * 81 * We will program the SC520 watchdog for a timeout of 2.01s. 82 * If we reset the watchdog every ~250ms we should be safe. 83 */ 84 85 #define WDT_INTERVAL (HZ/4+1) 86 87 /* 88 * We must not require too good response from the userspace daemon. 89 * Here we require the userspace daemon to send us a heartbeat 90 * char to /dev/watchdog every 30 seconds. 91 */ 92 93 #define WATCHDOG_TIMEOUT 30 /* 30 sec default timeout */ 94 static int timeout = WATCHDOG_TIMEOUT; /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */ 95 module_param(timeout, int, 0); 96 MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); 97 98 static int nowayout = WATCHDOG_NOWAYOUT; 99 module_param(nowayout, int, 0); 100 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 101 102 /* 103 * AMD Elan SC520 - Watchdog Timer Registers 104 */ 105 #define MMCR_BASE 0xfffef000 /* The default base address */ 106 #define OFFS_WDTMRCTL 0xCB0 /* Watchdog Timer Control Register */ 107 108 /* WDT Control Register bit definitions */ 109 #define WDT_EXP_SEL_01 0x0001 /* [01] Time-out = 496 us (with 33 Mhz clk). */ 110 #define WDT_EXP_SEL_02 0x0002 /* [02] Time-out = 508 ms (with 33 Mhz clk). */ 111 #define WDT_EXP_SEL_03 0x0004 /* [03] Time-out = 1.02 s (with 33 Mhz clk). */ 112 #define WDT_EXP_SEL_04 0x0008 /* [04] Time-out = 2.03 s (with 33 Mhz clk). */ 113 #define WDT_EXP_SEL_05 0x0010 /* [05] Time-out = 4.07 s (with 33 Mhz clk). */ 114 #define WDT_EXP_SEL_06 0x0020 /* [06] Time-out = 8.13 s (with 33 Mhz clk). */ 115 #define WDT_EXP_SEL_07 0x0040 /* [07] Time-out = 16.27s (with 33 Mhz clk). */ 116 #define WDT_EXP_SEL_08 0x0080 /* [08] Time-out = 32.54s (with 33 Mhz clk). */ 117 #define WDT_IRQ_FLG 0x1000 /* [12] Interrupt Request Flag */ 118 #define WDT_WRST_ENB 0x4000 /* [14] Watchdog Timer Reset Enable */ 119 #define WDT_ENB 0x8000 /* [15] Watchdog Timer Enable */ 120 121 static __u16 __iomem *wdtmrctl; 122 123 static void wdt_timer_ping(unsigned long); 124 static DEFINE_TIMER(timer, wdt_timer_ping, 0, 0); 125 static unsigned long next_heartbeat; 126 static unsigned long wdt_is_open; 127 static char wdt_expect_close; 128 static DEFINE_SPINLOCK(wdt_spinlock); 129 130 /* 131 * Whack the dog 132 */ 133 134 static void wdt_timer_ping(unsigned long data) 135 { 136 /* If we got a heartbeat pulse within the WDT_US_INTERVAL 137 * we agree to ping the WDT 138 */ 139 if(time_before(jiffies, next_heartbeat)) 140 { 141 /* Ping the WDT */ 142 spin_lock(&wdt_spinlock); 143 writew(0xAAAA, wdtmrctl); 144 writew(0x5555, wdtmrctl); 145 spin_unlock(&wdt_spinlock); 146 147 /* Re-set the timer interval */ 148 mod_timer(&timer, jiffies + WDT_INTERVAL); 149 } else { 150 printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n"); 151 } 152 } 153 154 /* 155 * Utility routines 156 */ 157 158 static void wdt_config(int writeval) 159 { 160 __u16 dummy; 161 unsigned long flags; 162 163 /* buy some time (ping) */ 164 spin_lock_irqsave(&wdt_spinlock, flags); 165 dummy=readw(wdtmrctl); /* ensure write synchronization */ 166 writew(0xAAAA, wdtmrctl); 167 writew(0x5555, wdtmrctl); 168 /* unlock WDT = make WDT configuration register writable one time */ 169 writew(0x3333, wdtmrctl); 170 writew(0xCCCC, wdtmrctl); 171 /* write WDT configuration register */ 172 writew(writeval, wdtmrctl); 173 spin_unlock_irqrestore(&wdt_spinlock, flags); 174 } 175 176 static int wdt_startup(void) 177 { 178 next_heartbeat = jiffies + (timeout * HZ); 179 180 /* Start the timer */ 181 mod_timer(&timer, jiffies + WDT_INTERVAL); 182 183 /* Start the watchdog */ 184 wdt_config(WDT_ENB | WDT_WRST_ENB | WDT_EXP_SEL_04); 185 186 printk(KERN_INFO PFX "Watchdog timer is now enabled.\n"); 187 return 0; 188 } 189 190 static int wdt_turnoff(void) 191 { 192 /* Stop the timer */ 193 del_timer(&timer); 194 195 /* Stop the watchdog */ 196 wdt_config(0); 197 198 printk(KERN_INFO PFX "Watchdog timer is now disabled...\n"); 199 return 0; 200 } 201 202 static int wdt_keepalive(void) 203 { 204 /* user land ping */ 205 next_heartbeat = jiffies + (timeout * HZ); 206 return 0; 207 } 208 209 static int wdt_set_heartbeat(int t) 210 { 211 if ((t < 1) || (t > 3600)) /* arbitrary upper limit */ 212 return -EINVAL; 213 214 timeout = t; 215 return 0; 216 } 217 218 /* 219 * /dev/watchdog handling 220 */ 221 222 static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos) 223 { 224 /* See if we got the magic character 'V' and reload the timer */ 225 if(count) { 226 if (!nowayout) { 227 size_t ofs; 228 229 /* note: just in case someone wrote the magic character 230 * five months ago... */ 231 wdt_expect_close = 0; 232 233 /* now scan */ 234 for(ofs = 0; ofs != count; ofs++) { 235 char c; 236 if (get_user(c, buf + ofs)) 237 return -EFAULT; 238 if(c == 'V') 239 wdt_expect_close = 42; 240 } 241 } 242 243 /* Well, anyhow someone wrote to us, we should return that favour */ 244 wdt_keepalive(); 245 } 246 return count; 247 } 248 249 static int fop_open(struct inode * inode, struct file * file) 250 { 251 /* Just in case we're already talking to someone... */ 252 if(test_and_set_bit(0, &wdt_is_open)) 253 return -EBUSY; 254 if (nowayout) 255 __module_get(THIS_MODULE); 256 257 /* Good, fire up the show */ 258 wdt_startup(); 259 return nonseekable_open(inode, file); 260 } 261 262 static int fop_close(struct inode * inode, struct file * file) 263 { 264 if(wdt_expect_close == 42) { 265 wdt_turnoff(); 266 } else { 267 printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n"); 268 wdt_keepalive(); 269 } 270 clear_bit(0, &wdt_is_open); 271 wdt_expect_close = 0; 272 return 0; 273 } 274 275 static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 276 unsigned long arg) 277 { 278 void __user *argp = (void __user *)arg; 279 int __user *p = argp; 280 static struct watchdog_info ident = { 281 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE, 282 .firmware_version = 1, 283 .identity = "SC520", 284 }; 285 286 switch(cmd) 287 { 288 default: 289 return -ENOTTY; 290 case WDIOC_GETSUPPORT: 291 return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0; 292 case WDIOC_GETSTATUS: 293 case WDIOC_GETBOOTSTATUS: 294 return put_user(0, p); 295 case WDIOC_KEEPALIVE: 296 wdt_keepalive(); 297 return 0; 298 case WDIOC_SETOPTIONS: 299 { 300 int new_options, retval = -EINVAL; 301 302 if(get_user(new_options, p)) 303 return -EFAULT; 304 305 if(new_options & WDIOS_DISABLECARD) { 306 wdt_turnoff(); 307 retval = 0; 308 } 309 310 if(new_options & WDIOS_ENABLECARD) { 311 wdt_startup(); 312 retval = 0; 313 } 314 315 return retval; 316 } 317 case WDIOC_SETTIMEOUT: 318 { 319 int new_timeout; 320 321 if(get_user(new_timeout, p)) 322 return -EFAULT; 323 324 if(wdt_set_heartbeat(new_timeout)) 325 return -EINVAL; 326 327 wdt_keepalive(); 328 /* Fall through */ 329 } 330 case WDIOC_GETTIMEOUT: 331 return put_user(timeout, p); 332 } 333 } 334 335 static const struct file_operations wdt_fops = { 336 .owner = THIS_MODULE, 337 .llseek = no_llseek, 338 .write = fop_write, 339 .open = fop_open, 340 .release = fop_close, 341 .ioctl = fop_ioctl, 342 }; 343 344 static struct miscdevice wdt_miscdev = { 345 .minor = WATCHDOG_MINOR, 346 .name = "watchdog", 347 .fops = &wdt_fops, 348 }; 349 350 /* 351 * Notifier for system down 352 */ 353 354 static int wdt_notify_sys(struct notifier_block *this, unsigned long code, 355 void *unused) 356 { 357 if(code==SYS_DOWN || code==SYS_HALT) 358 wdt_turnoff(); 359 return NOTIFY_DONE; 360 } 361 362 /* 363 * The WDT needs to learn about soft shutdowns in order to 364 * turn the timebomb registers off. 365 */ 366 367 static struct notifier_block wdt_notifier = { 368 .notifier_call = wdt_notify_sys, 369 }; 370 371 static void __exit sc520_wdt_unload(void) 372 { 373 if (!nowayout) 374 wdt_turnoff(); 375 376 /* Deregister */ 377 misc_deregister(&wdt_miscdev); 378 unregister_reboot_notifier(&wdt_notifier); 379 iounmap(wdtmrctl); 380 } 381 382 static int __init sc520_wdt_init(void) 383 { 384 int rc = -EBUSY; 385 386 /* Check that the timeout value is within it's range ; if not reset to the default */ 387 if (wdt_set_heartbeat(timeout)) { 388 wdt_set_heartbeat(WATCHDOG_TIMEOUT); 389 printk(KERN_INFO PFX "timeout value must be 1<=timeout<=3600, using %d\n", 390 WATCHDOG_TIMEOUT); 391 } 392 393 wdtmrctl = ioremap((unsigned long)(MMCR_BASE + OFFS_WDTMRCTL), 2); 394 if (!wdtmrctl) { 395 printk(KERN_ERR PFX "Unable to remap memory\n"); 396 rc = -ENOMEM; 397 goto err_out_region2; 398 } 399 400 rc = register_reboot_notifier(&wdt_notifier); 401 if (rc) { 402 printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n", 403 rc); 404 goto err_out_ioremap; 405 } 406 407 rc = misc_register(&wdt_miscdev); 408 if (rc) { 409 printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n", 410 WATCHDOG_MINOR, rc); 411 goto err_out_notifier; 412 } 413 414 printk(KERN_INFO PFX "WDT driver for SC520 initialised. timeout=%d sec (nowayout=%d)\n", 415 timeout,nowayout); 416 417 return 0; 418 419 err_out_notifier: 420 unregister_reboot_notifier(&wdt_notifier); 421 err_out_ioremap: 422 iounmap(wdtmrctl); 423 err_out_region2: 424 return rc; 425 } 426 427 module_init(sc520_wdt_init); 428 module_exit(sc520_wdt_unload); 429 430 MODULE_AUTHOR("Scott and Bill Jennings"); 431 MODULE_DESCRIPTION("Driver for watchdog timer in AMD \"Elan\" SC520 uProcessor"); 432 MODULE_LICENSE("GPL"); 433 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 434