drivers/watchdog/w83697hf_wdt.c

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