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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 56 57 #include <linux/module.h> 58 #include <linux/moduleparam.h> 59 #include <linux/types.h> 60 #include <linux/timer.h> 61 #include <linux/miscdevice.h> 62 #include <linux/watchdog.h> 63 #include <linux/fs.h> 64 #include <linux/ioport.h> 65 #include <linux/notifier.h> 66 #include <linux/reboot.h> 67 #include <linux/init.h> 68 #include <linux/jiffies.h> 69 #include <linux/io.h> 70 #include <linux/uaccess.h> 71 72 73 /* 74 * The AMD Elan SC520 timeout value is 492us times a power of 2 (0-7) 75 * 76 * 0: 492us 2: 1.01s 4: 4.03s 6: 16.22s 77 * 1: 503ms 3: 2.01s 5: 8.05s 7: 32.21s 78 * 79 * We will program the SC520 watchdog for a timeout of 2.01s. 80 * If we reset the watchdog every ~250ms we should be safe. 81 */ 82 83 #define WDT_INTERVAL (HZ/4+1) 84 85 /* 86 * We must not require too good response from the userspace daemon. 87 * Here we require the userspace daemon to send us a heartbeat 88 * char to /dev/watchdog every 30 seconds. 89 */ 90 91 #define WATCHDOG_TIMEOUT 30 /* 30 sec default timeout */ 92 /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */ 93 static int timeout = WATCHDOG_TIMEOUT; 94 module_param(timeout, int, 0); 95 MODULE_PARM_DESC(timeout, 96 "Watchdog timeout in seconds. (1 <= timeout <= 3600, default=" 97 __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); 98 99 static bool nowayout = WATCHDOG_NOWAYOUT; 100 module_param(nowayout, bool, 0); 101 MODULE_PARM_DESC(nowayout, 102 "Watchdog cannot be stopped once started (default=" 103 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 104 105 /* 106 * AMD Elan SC520 - Watchdog Timer Registers 107 */ 108 #define MMCR_BASE 0xfffef000 /* The default base address */ 109 #define OFFS_WDTMRCTL 0xCB0 /* Watchdog Timer Control Register */ 110 111 /* WDT Control Register bit definitions */ 112 #define WDT_EXP_SEL_01 0x0001 /* [01] Time-out = 496 us (with 33 Mhz clk). */ 113 #define WDT_EXP_SEL_02 0x0002 /* [02] Time-out = 508 ms (with 33 Mhz clk). */ 114 #define WDT_EXP_SEL_03 0x0004 /* [03] Time-out = 1.02 s (with 33 Mhz clk). */ 115 #define WDT_EXP_SEL_04 0x0008 /* [04] Time-out = 2.03 s (with 33 Mhz clk). */ 116 #define WDT_EXP_SEL_05 0x0010 /* [05] Time-out = 4.07 s (with 33 Mhz clk). */ 117 #define WDT_EXP_SEL_06 0x0020 /* [06] Time-out = 8.13 s (with 33 Mhz clk). */ 118 #define WDT_EXP_SEL_07 0x0040 /* [07] Time-out = 16.27s (with 33 Mhz clk). */ 119 #define WDT_EXP_SEL_08 0x0080 /* [08] Time-out = 32.54s (with 33 Mhz clk). */ 120 #define WDT_IRQ_FLG 0x1000 /* [12] Interrupt Request Flag */ 121 #define WDT_WRST_ENB 0x4000 /* [14] Watchdog Timer Reset Enable */ 122 #define WDT_ENB 0x8000 /* [15] Watchdog Timer Enable */ 123 124 static __u16 __iomem *wdtmrctl; 125 126 static void wdt_timer_ping(unsigned long); 127 static DEFINE_TIMER(timer, wdt_timer_ping, 0, 0); 128 static unsigned long next_heartbeat; 129 static unsigned long wdt_is_open; 130 static char wdt_expect_close; 131 static DEFINE_SPINLOCK(wdt_spinlock); 132 133 /* 134 * Whack the dog 135 */ 136 137 static void wdt_timer_ping(unsigned long data) 138 { 139 /* If we got a heartbeat pulse within the WDT_US_INTERVAL 140 * we agree to ping the WDT 141 */ 142 if (time_before(jiffies, next_heartbeat)) { 143 /* Ping the WDT */ 144 spin_lock(&wdt_spinlock); 145 writew(0xAAAA, wdtmrctl); 146 writew(0x5555, wdtmrctl); 147 spin_unlock(&wdt_spinlock); 148 149 /* Re-set the timer interval */ 150 mod_timer(&timer, jiffies + WDT_INTERVAL); 151 } else 152 pr_warn("Heartbeat lost! Will not ping the watchdog\n"); 153 } 154 155 /* 156 * Utility routines 157 */ 158 159 static void wdt_config(int writeval) 160 { 161 __u16 dummy; 162 unsigned long flags; 163 164 /* buy some time (ping) */ 165 spin_lock_irqsave(&wdt_spinlock, flags); 166 dummy = readw(wdtmrctl); /* ensure write synchronization */ 167 writew(0xAAAA, wdtmrctl); 168 writew(0x5555, wdtmrctl); 169 /* unlock WDT = make WDT configuration register writable one time */ 170 writew(0x3333, wdtmrctl); 171 writew(0xCCCC, wdtmrctl); 172 /* write WDT configuration register */ 173 writew(writeval, wdtmrctl); 174 spin_unlock_irqrestore(&wdt_spinlock, flags); 175 } 176 177 static int wdt_startup(void) 178 { 179 next_heartbeat = jiffies + (timeout * HZ); 180 181 /* Start the timer */ 182 mod_timer(&timer, jiffies + WDT_INTERVAL); 183 184 /* Start the watchdog */ 185 wdt_config(WDT_ENB | WDT_WRST_ENB | WDT_EXP_SEL_04); 186 187 pr_info("Watchdog timer is now enabled\n"); 188 return 0; 189 } 190 191 static int wdt_turnoff(void) 192 { 193 /* Stop the timer */ 194 del_timer(&timer); 195 196 /* Stop the watchdog */ 197 wdt_config(0); 198 199 pr_info("Watchdog timer is now disabled...\n"); 200 return 0; 201 } 202 203 static int wdt_keepalive(void) 204 { 205 /* user land ping */ 206 next_heartbeat = jiffies + (timeout * HZ); 207 return 0; 208 } 209 210 static int wdt_set_heartbeat(int t) 211 { 212 if ((t < 1) || (t > 3600)) /* arbitrary upper limit */ 213 return -EINVAL; 214 215 timeout = t; 216 return 0; 217 } 218 219 /* 220 * /dev/watchdog handling 221 */ 222 223 static ssize_t fop_write(struct file *file, const char __user *buf, 224 size_t count, loff_t *ppos) 225 { 226 /* See if we got the magic character 'V' and reload the timer */ 227 if (count) { 228 if (!nowayout) { 229 size_t ofs; 230 231 /* note: just in case someone wrote the magic character 232 * five months ago... */ 233 wdt_expect_close = 0; 234 235 /* now scan */ 236 for (ofs = 0; ofs != count; ofs++) { 237 char c; 238 if (get_user(c, buf + ofs)) 239 return -EFAULT; 240 if (c == 'V') 241 wdt_expect_close = 42; 242 } 243 } 244 245 /* Well, anyhow someone wrote to us, we should 246 return that favour */ 247 wdt_keepalive(); 248 } 249 return count; 250 } 251 252 static int fop_open(struct inode *inode, struct file *file) 253 { 254 /* Just in case we're already talking to someone... */ 255 if (test_and_set_bit(0, &wdt_is_open)) 256 return -EBUSY; 257 if (nowayout) 258 __module_get(THIS_MODULE); 259 260 /* Good, fire up the show */ 261 wdt_startup(); 262 return nonseekable_open(inode, file); 263 } 264 265 static int fop_close(struct inode *inode, struct file *file) 266 { 267 if (wdt_expect_close == 42) 268 wdt_turnoff(); 269 else { 270 pr_crit("Unexpected close, not stopping watchdog!\n"); 271 wdt_keepalive(); 272 } 273 clear_bit(0, &wdt_is_open); 274 wdt_expect_close = 0; 275 return 0; 276 } 277 278 static long fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 279 { 280 void __user *argp = (void __user *)arg; 281 int __user *p = argp; 282 static const struct watchdog_info ident = { 283 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT 284 | WDIOF_MAGICCLOSE, 285 .firmware_version = 1, 286 .identity = "SC520", 287 }; 288 289 switch (cmd) { 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_SETOPTIONS: 296 { 297 int new_options, retval = -EINVAL; 298 299 if (get_user(new_options, p)) 300 return -EFAULT; 301 302 if (new_options & WDIOS_DISABLECARD) { 303 wdt_turnoff(); 304 retval = 0; 305 } 306 307 if (new_options & WDIOS_ENABLECARD) { 308 wdt_startup(); 309 retval = 0; 310 } 311 312 return retval; 313 } 314 case WDIOC_KEEPALIVE: 315 wdt_keepalive(); 316 return 0; 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 default: 333 return -ENOTTY; 334 } 335 } 336 337 static const struct file_operations wdt_fops = { 338 .owner = THIS_MODULE, 339 .llseek = no_llseek, 340 .write = fop_write, 341 .open = fop_open, 342 .release = fop_close, 343 .unlocked_ioctl = fop_ioctl, 344 }; 345 346 static struct miscdevice wdt_miscdev = { 347 .minor = WATCHDOG_MINOR, 348 .name = "watchdog", 349 .fops = &wdt_fops, 350 }; 351 352 /* 353 * Notifier for system down 354 */ 355 356 static int wdt_notify_sys(struct notifier_block *this, unsigned long code, 357 void *unused) 358 { 359 if (code == SYS_DOWN || code == SYS_HALT) 360 wdt_turnoff(); 361 return NOTIFY_DONE; 362 } 363 364 /* 365 * The WDT needs to learn about soft shutdowns in order to 366 * turn the timebomb registers off. 367 */ 368 369 static struct notifier_block wdt_notifier = { 370 .notifier_call = wdt_notify_sys, 371 }; 372 373 static void __exit sc520_wdt_unload(void) 374 { 375 if (!nowayout) 376 wdt_turnoff(); 377 378 /* Deregister */ 379 misc_deregister(&wdt_miscdev); 380 unregister_reboot_notifier(&wdt_notifier); 381 iounmap(wdtmrctl); 382 } 383 384 static int __init sc520_wdt_init(void) 385 { 386 int rc = -EBUSY; 387 388 /* Check that the timeout value is within it's range ; 389 if not reset to the default */ 390 if (wdt_set_heartbeat(timeout)) { 391 wdt_set_heartbeat(WATCHDOG_TIMEOUT); 392 pr_info("timeout value must be 1 <= timeout <= 3600, using %d\n", 393 WATCHDOG_TIMEOUT); 394 } 395 396 wdtmrctl = ioremap(MMCR_BASE + OFFS_WDTMRCTL, 2); 397 if (!wdtmrctl) { 398 pr_err("Unable to remap memory\n"); 399 rc = -ENOMEM; 400 goto err_out_region2; 401 } 402 403 rc = register_reboot_notifier(&wdt_notifier); 404 if (rc) { 405 pr_err("cannot register reboot notifier (err=%d)\n", rc); 406 goto err_out_ioremap; 407 } 408 409 rc = misc_register(&wdt_miscdev); 410 if (rc) { 411 pr_err("cannot register miscdev on minor=%d (err=%d)\n", 412 WATCHDOG_MINOR, rc); 413 goto err_out_notifier; 414 } 415 416 pr_info("WDT driver for SC520 initialised. timeout=%d sec (nowayout=%d)\n", 417 timeout, nowayout); 418 419 return 0; 420 421 err_out_notifier: 422 unregister_reboot_notifier(&wdt_notifier); 423 err_out_ioremap: 424 iounmap(wdtmrctl); 425 err_out_region2: 426 return rc; 427 } 428 429 module_init(sc520_wdt_init); 430 module_exit(sc520_wdt_unload); 431 432 MODULE_AUTHOR("Scott and Bill Jennings"); 433 MODULE_DESCRIPTION( 434 "Driver for watchdog timer in AMD \"Elan\" SC520 uProcessor"); 435 MODULE_LICENSE("GPL"); 436 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 437