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