1/* 2 * Eurotech CPU-1220/1410/1420 on board WDT driver 3 * 4 * (c) Copyright 2001 Ascensit <support@ascensit.com> 5 * (c) Copyright 2001 Rodolfo Giometti <giometti@ascensit.com> 6 * (c) Copyright 2002 Rob Radez <rob@osinvestor.com> 7 * 8 * Based on wdt.c. 9 * Original copyright messages: 10 * 11 * (c) Copyright 1996-1997 Alan Cox <alan@lxorguk.ukuu.org.uk>, 12 * All Rights Reserved. 13 * 14 * This program is free software; you can redistribute it and/or 15 * modify it under the terms of the GNU General Public License 16 * as published by the Free Software Foundation; either version 17 * 2 of the License, or (at your option) any later version. 18 * 19 * Neither Alan Cox nor CymruNet Ltd. admit liability nor provide 20 * warranty for any of this software. This material is provided 21 * "AS-IS" and at no charge. 22 * 23 * (c) Copyright 1995 Alan Cox <alan@lxorguk.ukuu.org.uk>* 24 */ 25 26/* Changelog: 27 * 28 * 2001 - Rodolfo Giometti 29 * Initial release 30 * 31 * 2002/04/25 - Rob Radez 32 * clean up #includes 33 * clean up locking 34 * make __setup param unique 35 * proper options in watchdog_info 36 * add WDIOC_GETSTATUS and WDIOC_SETOPTIONS ioctls 37 * add expect_close support 38 * 39 * 2002.05.30 - Joel Becker <joel.becker@oracle.com> 40 * Added Matt Domsch's nowayout module option. 41 */ 42 43/* 44 * The eurotech CPU-1220/1410/1420's watchdog is a part 45 * of the on-board SUPER I/O device SMSC FDC 37B782. 46 */ 47 48#include <linux/interrupt.h> 49#include <linux/module.h> 50#include <linux/moduleparam.h> 51#include <linux/types.h> 52#include <linux/miscdevice.h> 53#include <linux/watchdog.h> 54#include <linux/fs.h> 55#include <linux/ioport.h> 56#include <linux/notifier.h> 57#include <linux/reboot.h> 58#include <linux/init.h> 59#include <linux/io.h> 60#include <linux/uaccess.h> 61 62#include <asm/system.h> 63 64static unsigned long eurwdt_is_open; 65static int eurwdt_timeout; 66static char eur_expect_close; 67static spinlock_t eurwdt_lock; 68 69/* 70 * You must set these - there is no sane way to probe for this board. 71 */ 72 73static int io = 0x3f0; 74static int irq = 10; 75static char *ev = "int"; 76 77#define WDT_TIMEOUT 60 /* 1 minute */ 78 79static int nowayout = WATCHDOG_NOWAYOUT; 80module_param(nowayout, int, 0); 81MODULE_PARM_DESC(nowayout, 82 "Watchdog cannot be stopped once started (default=" 83 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 84 85/* 86 * Some symbolic names 87 */ 88 89#define WDT_CTRL_REG 0x30 90#define WDT_OUTPIN_CFG 0xe2 91#define WDT_EVENT_INT 0x00 92#define WDT_EVENT_REBOOT 0x08 93#define WDT_UNIT_SEL 0xf1 94#define WDT_UNIT_SECS 0x80 95#define WDT_TIMEOUT_VAL 0xf2 96#define WDT_TIMER_CFG 0xf3 97 98 99module_param(io, int, 0); 100MODULE_PARM_DESC(io, "Eurotech WDT io port (default=0x3f0)"); 101module_param(irq, int, 0); 102MODULE_PARM_DESC(irq, "Eurotech WDT irq (default=10)"); 103module_param(ev, charp, 0); 104MODULE_PARM_DESC(ev, "Eurotech WDT event type (default is `int')"); 105 106 107/* 108 * Programming support 109 */ 110 111static inline void eurwdt_write_reg(u8 index, u8 data) 112{ 113 outb(index, io); 114 outb(data, io+1); 115} 116 117static inline void eurwdt_lock_chip(void) 118{ 119 outb(0xaa, io); 120} 121 122static inline void eurwdt_unlock_chip(void) 123{ 124 outb(0x55, io); 125 eurwdt_write_reg(0x07, 0x08); /* set the logical device */ 126} 127 128static inline void eurwdt_set_timeout(int timeout) 129{ 130 eurwdt_write_reg(WDT_TIMEOUT_VAL, (u8) timeout); 131} 132 133static inline void eurwdt_disable_timer(void) 134{ 135 eurwdt_set_timeout(0); 136} 137 138static void eurwdt_activate_timer(void) 139{ 140 eurwdt_disable_timer(); 141 eurwdt_write_reg(WDT_CTRL_REG, 0x01); /* activate the WDT */ 142 eurwdt_write_reg(WDT_OUTPIN_CFG, 143 !strcmp("int", ev) ? WDT_EVENT_INT : WDT_EVENT_REBOOT); 144 145 /* Setting interrupt line */ 146 if (irq == 2 || irq > 15 || irq < 0) { 147 printk(KERN_ERR ": invalid irq number\n"); 148 irq = 0; /* if invalid we disable interrupt */ 149 } 150 if (irq == 0) 151 printk(KERN_INFO ": interrupt disabled\n"); 152 153 eurwdt_write_reg(WDT_TIMER_CFG, irq << 4); 154 155 eurwdt_write_reg(WDT_UNIT_SEL, WDT_UNIT_SECS); /* we use seconds */ 156 eurwdt_set_timeout(0); /* the default timeout */ 157} 158 159 160/* 161 * Kernel methods. 162 */ 163 164static irqreturn_t eurwdt_interrupt(int irq, void *dev_id) 165{ 166 printk(KERN_CRIT "timeout WDT timeout\n"); 167 168#ifdef ONLY_TESTING 169 printk(KERN_CRIT "Would Reboot.\n"); 170#else 171 printk(KERN_CRIT "Initiating system reboot.\n"); 172 emergency_restart(); 173#endif 174 return IRQ_HANDLED; 175} 176 177 178/** 179 * eurwdt_ping: 180 * 181 * Reload counter one with the watchdog timeout. 182 */ 183 184static void eurwdt_ping(void) 185{ 186 /* Write the watchdog default value */ 187 eurwdt_set_timeout(eurwdt_timeout); 188} 189 190/** 191 * eurwdt_write: 192 * @file: file handle to the watchdog 193 * @buf: buffer to write (unused as data does not matter here 194 * @count: count of bytes 195 * @ppos: pointer to the position to write. No seeks allowed 196 * 197 * A write to a watchdog device is defined as a keepalive signal. Any 198 * write of data will do, as we we don't define content meaning. 199 */ 200 201static ssize_t eurwdt_write(struct file *file, const char __user *buf, 202size_t count, loff_t *ppos) 203{ 204 if (count) { 205 if (!nowayout) { 206 size_t i; 207 208 eur_expect_close = 0; 209 210 for (i = 0; i != count; i++) { 211 char c; 212 if (get_user(c, buf + i)) 213 return -EFAULT; 214 if (c == 'V') 215 eur_expect_close = 42; 216 } 217 } 218 spin_lock(&eurwdt_lock); 219 eurwdt_ping(); /* the default timeout */ 220 spin_unlock(&eurwdt_lock); 221 } 222 return count; 223} 224 225/** 226 * eurwdt_ioctl: 227 * @file: file handle to the device 228 * @cmd: watchdog command 229 * @arg: argument pointer 230 * 231 * The watchdog API defines a common set of functions for all watchdogs 232 * according to their available features. 233 */ 234 235static long eurwdt_ioctl(struct file *file, 236 unsigned int cmd, unsigned long arg) 237{ 238 void __user *argp = (void __user *)arg; 239 int __user *p = argp; 240 static const struct watchdog_info ident = { 241 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT 242 | WDIOF_MAGICCLOSE, 243 .firmware_version = 1, 244 .identity = "WDT Eurotech CPU-1220/1410", 245 }; 246 247 int time; 248 int options, retval = -EINVAL; 249 250 switch (cmd) { 251 case WDIOC_GETSUPPORT: 252 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0; 253 254 case WDIOC_GETSTATUS: 255 case WDIOC_GETBOOTSTATUS: 256 return put_user(0, p); 257 258 case WDIOC_SETOPTIONS: 259 if (get_user(options, p)) 260 return -EFAULT; 261 spin_lock(&eurwdt_lock); 262 if (options & WDIOS_DISABLECARD) { 263 eurwdt_disable_timer(); 264 retval = 0; 265 } 266 if (options & WDIOS_ENABLECARD) { 267 eurwdt_activate_timer(); 268 eurwdt_ping(); 269 retval = 0; 270 } 271 spin_unlock(&eurwdt_lock); 272 return retval; 273 274 case WDIOC_KEEPALIVE: 275 spin_lock(&eurwdt_lock); 276 eurwdt_ping(); 277 spin_unlock(&eurwdt_lock); 278 return 0; 279 280 case WDIOC_SETTIMEOUT: 281 if (copy_from_user(&time, p, sizeof(int))) 282 return -EFAULT; 283 284 /* Sanity check */ 285 if (time < 0 || time > 255) 286 return -EINVAL; 287 288 spin_lock(&eurwdt_lock); 289 eurwdt_timeout = time; 290 eurwdt_set_timeout(time); 291 spin_unlock(&eurwdt_lock); 292 /* Fall */ 293 294 case WDIOC_GETTIMEOUT: 295 return put_user(eurwdt_timeout, p); 296 297 default: 298 return -ENOTTY; 299 } 300} 301 302/** 303 * eurwdt_open: 304 * @inode: inode of device 305 * @file: file handle to device 306 * 307 * The misc device has been opened. The watchdog device is single 308 * open and on opening we load the counter. 309 */ 310 311static int eurwdt_open(struct inode *inode, struct file *file) 312{ 313 if (test_and_set_bit(0, &eurwdt_is_open)) 314 return -EBUSY; 315 eurwdt_timeout = WDT_TIMEOUT; /* initial timeout */ 316 /* Activate the WDT */ 317 eurwdt_activate_timer(); 318 return nonseekable_open(inode, file); 319} 320 321/** 322 * eurwdt_release: 323 * @inode: inode to board 324 * @file: file handle to board 325 * 326 * The watchdog has a configurable API. There is a religious dispute 327 * between people who want their watchdog to be able to shut down and 328 * those who want to be sure if the watchdog manager dies the machine 329 * reboots. In the former case we disable the counters, in the latter 330 * case you have to open it again very soon. 331 */ 332 333static int eurwdt_release(struct inode *inode, struct file *file) 334{ 335 if (eur_expect_close == 42) 336 eurwdt_disable_timer(); 337 else { 338 printk(KERN_CRIT 339 "eurwdt: Unexpected close, not stopping watchdog!\n"); 340 eurwdt_ping(); 341 } 342 clear_bit(0, &eurwdt_is_open); 343 eur_expect_close = 0; 344 return 0; 345} 346 347/** 348 * eurwdt_notify_sys: 349 * @this: our notifier block 350 * @code: the event being reported 351 * @unused: unused 352 * 353 * Our notifier is called on system shutdowns. We want to turn the card 354 * off at reboot otherwise the machine will reboot again during memory 355 * test or worse yet during the following fsck. This would suck, in fact 356 * trust me - if it happens it does suck. 357 */ 358 359static int eurwdt_notify_sys(struct notifier_block *this, unsigned long code, 360 void *unused) 361{ 362 if (code == SYS_DOWN || code == SYS_HALT) 363 eurwdt_disable_timer(); /* Turn the card off */ 364 365 return NOTIFY_DONE; 366} 367 368/* 369 * Kernel Interfaces 370 */ 371 372 373static const struct file_operations eurwdt_fops = { 374 .owner = THIS_MODULE, 375 .llseek = no_llseek, 376 .write = eurwdt_write, 377 .unlocked_ioctl = eurwdt_ioctl, 378 .open = eurwdt_open, 379 .release = eurwdt_release, 380}; 381 382static struct miscdevice eurwdt_miscdev = { 383 .minor = WATCHDOG_MINOR, 384 .name = "watchdog", 385 .fops = &eurwdt_fops, 386}; 387 388/* 389 * The WDT card needs to learn about soft shutdowns in order to 390 * turn the timebomb registers off. 391 */ 392 393static struct notifier_block eurwdt_notifier = { 394 .notifier_call = eurwdt_notify_sys, 395}; 396 397/** 398 * cleanup_module: 399 * 400 * Unload the watchdog. You cannot do this with any file handles open. 401 * If your watchdog is set to continue ticking on close and you unload 402 * it, well it keeps ticking. We won't get the interrupt but the board 403 * will not touch PC memory so all is fine. You just have to load a new 404 * module in 60 seconds or reboot. 405 */ 406 407static void __exit eurwdt_exit(void) 408{ 409 eurwdt_lock_chip(); 410 411 misc_deregister(&eurwdt_miscdev); 412 413 unregister_reboot_notifier(&eurwdt_notifier); 414 release_region(io, 2); 415 free_irq(irq, NULL); 416} 417 418/** 419 * eurwdt_init: 420 * 421 * Set up the WDT watchdog board. After grabbing the resources 422 * we require we need also to unlock the device. 423 * The open() function will actually kick the board off. 424 */ 425 426static int __init eurwdt_init(void) 427{ 428 int ret; 429 430 ret = request_irq(irq, eurwdt_interrupt, IRQF_DISABLED, "eurwdt", NULL); 431 if (ret) { 432 printk(KERN_ERR "eurwdt: IRQ %d is not free.\n", irq); 433 goto out; 434 } 435 436 if (!request_region(io, 2, "eurwdt")) { 437 printk(KERN_ERR "eurwdt: IO %X is not free.\n", io); 438 ret = -EBUSY; 439 goto outirq; 440 } 441 442 ret = register_reboot_notifier(&eurwdt_notifier); 443 if (ret) { 444 printk(KERN_ERR 445 "eurwdt: can't register reboot notifier (err=%d)\n", ret); 446 goto outreg; 447 } 448 449 spin_lock_init(&eurwdt_lock); 450 451 ret = misc_register(&eurwdt_miscdev); 452 if (ret) { 453 printk(KERN_ERR "eurwdt: can't misc_register on minor=%d\n", 454 WATCHDOG_MINOR); 455 goto outreboot; 456 } 457 458 eurwdt_unlock_chip(); 459 460 ret = 0; 461 printk(KERN_INFO "Eurotech WDT driver 0.01 at %X (Interrupt %d)" 462 " - timeout event: %s\n", 463 io, irq, (!strcmp("int", ev) ? "int" : "reboot")); 464 465out: 466 return ret; 467 468outreboot: 469 unregister_reboot_notifier(&eurwdt_notifier); 470 471outreg: 472 release_region(io, 2); 473 474outirq: 475 free_irq(irq, NULL); 476 goto out; 477} 478 479module_init(eurwdt_init); 480module_exit(eurwdt_exit); 481 482MODULE_AUTHOR("Rodolfo Giometti"); 483MODULE_DESCRIPTION("Driver for Eurotech CPU-1220/1410 on board watchdog"); 484MODULE_LICENSE("GPL"); 485MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 486