drivers/char/watchdog/w83697hf_wdt.c

   1 /*
   2  *      w83697hf/hg WDT driver
   3  *
   4  *      (c) Copyright 2006 Marcus Junker <junker@anduras.de>
   5  *
   6  *      Based on w83627hf_wdt.c which is based on advantechwdt.c
   7  *      which is based on wdt.c.
   8  *      Original copyright messages:
   9  *
  10  *      (c) Copyright 2003 Pádraig Brady <P@draigBrady.com>
  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 Marcus Junker nor ANDURAS AG admit liability nor provide
  23  *      warranty for any of this software. This material is provided
  24  *      "AS-IS" and at no charge.
  25  */
  26
  27 #include <linux/module.h>
  28 #include <linux/moduleparam.h>
  29 #include <linux/types.h>
  30 #include <linux/miscdevice.h>
  31 #include <linux/watchdog.h>
  32 #include <linux/fs.h>
  33 #include <linux/ioport.h>
  34 #include <linux/notifier.h>
  35 #include <linux/reboot.h>
  36 #include <linux/init.h>
  37 #include <linux/spinlock.h>
  38
  39 #include <asm/io.h>
  40 #include <asm/uaccess.h>
  41 #include <asm/system.h>
  42
  43 #define WATCHDOG_NAME "w83697hf/hg WDT"
  44 #define PFX WATCHDOG_NAME ": "
  45 #define WATCHDOG_TIMEOUT 60             /* 60 sec default timeout */
  46
  47 static unsigned long wdt_is_open;
  48 static char expect_close;
  49 static spinlock_t io_lock;
  50
  51 /* You must set this - there is no sane way to probe for this board. */
  52 static int wdt_io = 0x2e;
  53 module_param(wdt_io, int, 0);
  54 MODULE_PARM_DESC(wdt_io, "w83697hf/hg WDT io port (default 0x2e, 0 = autodetect)");
  55
  56 static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
  57 module_param(timeout, int, 0);
  58 MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. 1<= timeout <=255, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
  59
  60 static int nowayout = WATCHDOG_NOWAYOUT;
  61 module_param(nowayout, int, 0);
  62 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
  63
  64 /*
  65  *      Kernel methods.
  66  */
  67
  68 #define W83697HF_EFER (wdt_io+0)        /* Extended Function Enable Register */
  69 #define W83697HF_EFIR (wdt_io+0)        /* Extended Function Index Register (same as EFER) */
  70 #define W83697HF_EFDR (wdt_io+1)        /* Extended Function Data Register */
  71
  72 static inline void
  73 w83697hf_unlock(void)
  74 {
  75         outb_p(0x87, W83697HF_EFER);    /* Enter extended function mode */
  76         outb_p(0x87, W83697HF_EFER);    /* Again according to manual */
  77 }
  78
  79 static inline void
  80 w83697hf_lock(void)
  81 {
  82         outb_p(0xAA, W83697HF_EFER);    /* Leave extended function mode */
  83 }
  84
  85 /*
  86  *      The three functions w83697hf_get_reg(), w83697hf_set_reg() and
  87  *      w83697hf_write_timeout() must be called with the device unlocked.
  88  */
  89
  90 static unsigned char
  91 w83697hf_get_reg(unsigned char reg)
  92 {
  93         outb_p(reg, W83697HF_EFIR);
  94         return inb_p(W83697HF_EFDR);
  95 }
  96
  97 static void
  98 w83697hf_set_reg(unsigned char reg, unsigned char data)
  99 {
 100         outb_p(reg, W83697HF_EFIR);
 101         outb_p(data, W83697HF_EFDR);
 102 }
 103
 104 static void
 105 w83697hf_write_timeout(int timeout)
 106 {
 107         w83697hf_set_reg(0xF4, timeout);        /* Write Timeout counter to CRF4 */
 108 }
 109
 110 static void
 111 w83697hf_select_wdt(void)
 112 {
 113         w83697hf_unlock();
 114         w83697hf_set_reg(0x07, 0x08);   /* Switch to logic device 8 (GPIO2) */
 115 }
 116
 117 static inline void
 118 w83697hf_deselect_wdt(void)
 119 {
 120         w83697hf_lock();
 121 }
 122
 123 static void
 124 w83697hf_select_wd_register(void)
 125 {
 126         w83697hf_unlock();
 127
 128         w83697hf_set_reg(0x29, 0x20);   /* Set pin 119 to WDTO# mode (= CR29, WDT0) */
 129
 130         w83697hf_set_reg(0x07, 0x08);   /* Switch to logic device 8 (GPIO2) */
 131         w83697hf_set_reg(0x30, 0x01);   /* Enable timer/activate GPIO2 via bit 0 */
 132 }
 133
 134 static void
 135 w83697hf_unselect_wd_register(void)
 136 {
 137         w83697hf_lock();
 138 }
 139
 140 static void
 141 w83697hf_init(void)
 142 {
 143         unsigned char t;
 144
 145         w83697hf_select_wd_register();
 146
 147         t = w83697hf_get_reg(0xF3);     /* Read CRF3 */
 148         if (t != 0) {
 149                 printk (KERN_INFO PFX "Watchdog already running. Resetting timeout to %d sec\n", timeout);
 150                 w83697hf_set_reg(0xF3, timeout);        /* Write new timeout */
 151         }
 152         t = w83697hf_get_reg(0xF4);     /* Read CRF4 */
 153         t&=~0x0C;                       /* set second mode & disable keyboard turning off watchdog */
 154         w83697hf_set_reg(0xF4, t);      /* Write back to CRF4 */
 155
 156         w83697hf_unselect_wd_register();
 157 }
 158
 159 static int
 160 wdt_ping(void)
 161 {
 162         spin_lock(&io_lock);
 163         w83697hf_select_wdt();
 164
 165         w83697hf_write_timeout(timeout);
 166
 167         w83697hf_deselect_wdt();
 168         spin_unlock(&io_lock);
 169         return 0;
 170 }
 171
 172 static int
 173 wdt_enable(void)
 174 {
 175         spin_lock(&io_lock);
 176         w83697hf_select_wdt();
 177
 178         w83697hf_write_timeout(timeout);
 179         w83697hf_set_reg(0x30, 1);      /* Enable timer */
 180
 181         w83697hf_deselect_wdt();
 182         spin_unlock(&io_lock);
 183         return 0;
 184 }
 185
 186 static int
 187 wdt_disable(void)
 188 {
 189         spin_lock(&io_lock);
 190         w83697hf_select_wdt();
 191
 192         w83697hf_set_reg(0x30, 0);      /* Disable timer */
 193         w83697hf_write_timeout(0);
 194
 195         w83697hf_deselect_wdt();
 196         spin_unlock(&io_lock);
 197         return 0;
 198 }
 199
 200 static int
 201 wdt_set_heartbeat(int t)
 202 {
 203         if ((t < 1) || (t > 255))
 204                 return -EINVAL;
 205
 206         timeout = t;
 207         return 0;
 208 }
 209
 210 static ssize_t
 211 wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 212 {
 213         if (count) {
 214                 if (!nowayout) {
 215                         size_t i;
 216
 217                         expect_close = 0;
 218
 219                         for (i = 0; i != count; i++) {
 220                                 char c;
 221                                 if (get_user(c, buf+i))
 222                                         return -EFAULT;
 223                                 if (c == 'V')
 224                                         expect_close = 42;
 225                         }
 226                 }
 227                 wdt_ping();
 228         }
 229         return count;
 230 }
 231
 232 static int
 233 wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 234           unsigned long arg)
 235 {
 236         void __user *argp = (void __user *)arg;
 237         int __user *p = argp;
 238         int new_timeout;
 239         static struct watchdog_info ident = {
 240                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
 241                 .firmware_version = 1,
 242                 .identity = "W83697HF WDT",
 243         };
 244
 245         switch (cmd) {
 246         case WDIOC_GETSUPPORT:
 247                 if (copy_to_user(argp, &ident, sizeof(ident)))
 248                         return -EFAULT;
 249                 break;
 250
 251         case WDIOC_GETSTATUS:
 252         case WDIOC_GETBOOTSTATUS:
 253                 return put_user(0, p);
 254
 255         case WDIOC_KEEPALIVE:
 256                 wdt_ping();
 257                 break;
 258
 259         case WDIOC_SETTIMEOUT:
 260                 if (get_user(new_timeout, p))
 261                         return -EFAULT;
 262                 if (wdt_set_heartbeat(new_timeout))
 263                         return -EINVAL;
 264                 wdt_ping();
 265                 /* Fall */
 266
 267         case WDIOC_GETTIMEOUT:
 268                 return put_user(timeout, p);
 269
 270         case WDIOC_SETOPTIONS:
 271         {
 272                 int options, retval = -EINVAL;
 273
 274                 if (get_user(options, p))
 275                         return -EFAULT;
 276
 277                 if (options & WDIOS_DISABLECARD) {
 278                         wdt_disable();
 279                         retval = 0;
 280                 }
 281
 282                 if (options & WDIOS_ENABLECARD) {
 283                         wdt_enable();
 284                         retval = 0;
 285                 }
 286
 287                 return retval;
 288         }
 289
 290         default:
 291                 return -ENOTTY;
 292         }
 293         return 0;
 294 }
 295
 296 static int
 297 wdt_open(struct inode *inode, struct file *file)
 298 {
 299         if (test_and_set_bit(0, &wdt_is_open))
 300                 return -EBUSY;
 301         /*
 302          *      Activate
 303          */
 304
 305         wdt_enable();
 306         return nonseekable_open(inode, file);
 307 }
 308
 309 static int
 310 wdt_close(struct inode *inode, struct file *file)
 311 {
 312         if (expect_close == 42) {
 313                 wdt_disable();
 314         } else {
 315                 printk (KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
 316                 wdt_ping();
 317         }
 318         expect_close = 0;
 319         clear_bit(0, &wdt_is_open);
 320         return 0;
 321 }
 322
 323 /*
 324  *      Notifier for system down
 325  */
 326
 327 static int
 328 wdt_notify_sys(struct notifier_block *this, unsigned long code,
 329         void *unused)
 330 {
 331         if (code == SYS_DOWN || code == SYS_HALT) {
 332                 /* Turn the WDT off */
 333                 wdt_disable();
 334         }
 335         return NOTIFY_DONE;
 336 }
 337
 338 /*
 339  *      Kernel Interfaces
 340  */
 341
 342 static struct file_operations wdt_fops = {
 343         .owner          = THIS_MODULE,
 344         .llseek         = no_llseek,
 345         .write          = wdt_write,
 346         .ioctl          = wdt_ioctl,
 347         .open           = wdt_open,
 348         .release        = wdt_close,
 349 };
 350
 351 static struct miscdevice wdt_miscdev = {
 352         .minor = WATCHDOG_MINOR,
 353         .name = "watchdog",
 354         .fops = &wdt_fops,
 355 };
 356
 357 /*
 358  *      The WDT needs to learn about soft shutdowns in order to
 359  *      turn the timebomb registers off.
 360  */
 361
 362 static struct notifier_block wdt_notifier = {
 363         .notifier_call = wdt_notify_sys,
 364 };
 365
 366 static int
 367 w83697hf_check_wdt(void)
 368 {
 369         if (!request_region(wdt_io, 2, WATCHDOG_NAME)) {
 370                 printk (KERN_ERR PFX "I/O address 0x%x already in use\n", wdt_io);
 371                 return -EIO;
 372         }
 373
 374         printk (KERN_DEBUG PFX "Looking for watchdog at address 0x%x\n", wdt_io);
 375         w83697hf_unlock();
 376         if (w83697hf_get_reg(0x20) == 0x60) {
 377                 printk (KERN_INFO PFX "watchdog found at address 0x%x\n", wdt_io);
 378                 w83697hf_lock();
 379                 return 0;
 380         }
 381         w83697hf_lock();        /* Reprotect in case it was a compatible device */
 382
 383         printk (KERN_INFO PFX "watchdog not found at address 0x%x\n", wdt_io);
 384         release_region(wdt_io, 2);
 385         return -EIO;
 386 }
 387
 388 static int __init
 389 wdt_init(void)
 390 {
 391         int ret, autodetect;
 392
 393         spin_lock_init(&io_lock);
 394
 395         printk (KERN_INFO PFX "WDT driver for W83697HF/HG initializing\n");
 396
 397         autodetect = wdt_io == 0;
 398         if (autodetect)
 399                 wdt_io = 0x2e;
 400
 401         if (!w83697hf_check_wdt())
 402                 goto found;
 403
 404         if (autodetect) {
 405                 wdt_io = 0x4e;
 406                 if (!w83697hf_check_wdt())
 407                         goto found;
 408         }
 409
 410         printk (KERN_ERR PFX "No W83697HF/HG could be found\n");
 411         ret = -EIO;
 412         goto out;
 413
 414 found:
 415
 416         if (wdt_set_heartbeat(timeout)) {
 417                 wdt_set_heartbeat(WATCHDOG_TIMEOUT);
 418                 printk (KERN_INFO PFX "timeout value must be 1<=timeout<=255, using %d\n",
 419                         WATCHDOG_TIMEOUT);
 420         }
 421
 422         w83697hf_init();
 423
 424         ret = register_reboot_notifier(&wdt_notifier);
 425         if (ret != 0) {
 426                 printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
 427                         ret);
 428                 goto unreg_regions;
 429         }
 430
 431         ret = misc_register(&wdt_miscdev);
 432         if (ret != 0) {
 433                 printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
 434                         WATCHDOG_MINOR, ret);
 435                 goto unreg_reboot;
 436         }
 437
 438         printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
 439                 timeout, nowayout);
 440
 441 out:
 442         return ret;
 443 unreg_reboot:
 444         unregister_reboot_notifier(&wdt_notifier);
 445 unreg_regions:
 446         release_region(wdt_io, 2);
 447         goto out;
 448 }
 449
 450 static void __exit
 451 wdt_exit(void)
 452 {
 453         misc_deregister(&wdt_miscdev);
 454         unregister_reboot_notifier(&wdt_notifier);
 455         release_region(wdt_io, 2);
 456 }
 457
 458 module_init(wdt_init);
 459 module_exit(wdt_exit);
 460
 461 MODULE_LICENSE("GPL");
 462 MODULE_AUTHOR("Marcus Junker <junker@anduras.de>");
 463 MODULE_DESCRIPTION("w83697hf/hg WDT driver");
 464 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);