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 WDT io port (default 0x2E)");
  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 void
  73 w83697hf_select_wd_register(void)
  74 {
  75         outb_p(0x87, W83697HF_EFER);    /* Enter extended function mode */
  76         outb_p(0x87, W83697HF_EFER);    /* Again according to manual */
  77
  78         outb_p(0x29, W83697HF_EFER);    /* select CR29 */
  79         outb_p(0x20, W83697HF_EFDR);    /* select WDTO */
  80
  81         outb_p(0x07, W83697HF_EFER);    /* point to logical device number reg */
  82         outb_p(0x08, W83697HF_EFDR);    /* select logical device 8 (GPIO2) */
  83         outb_p(0x30, W83697HF_EFER);    /* select CR30 */
  84         outb_p(0x01, W83697HF_EFDR);    /* set bit 0 to activate GPIO2 */
  85 }
  86
  87 static void
  88 w83697hf_unselect_wd_register(void)
  89 {
  90         outb_p(0xAA, W83697HF_EFER);    /* Leave extended function mode */
  91 }
  92
  93 static void
  94 w83697hf_init(void)
  95 {
  96         unsigned char t;
  97
  98         w83697hf_select_wd_register();
  99
 100         outb_p(0xF3, W83697HF_EFER);    /* Select CRF3 */
 101
 102         t=inb_p(W83697HF_EFDR);         /* read CRF3 */
 103         if (t != 0) {
 104                 printk (KERN_INFO PFX "Watchdog already running. Resetting timeout to %d sec\n", timeout);
 105                 outb_p(timeout, W83697HF_EFDR); /* Write back to CRF3 */
 106         }
 107         outb_p(0xF4, W83697HF_EFER);    /* Select CRF4 */
 108         t=inb_p(W83697HF_EFDR);         /* read CRF4 */
 109         t&=~0x0C;                       /* set second mode & disable keyboard turning off watchdog */
 110         outb_p(t, W83697HF_EFDR);       /* Write back to CRF4 */
 111
 112         w83697hf_unselect_wd_register();
 113 }
 114
 115 static void
 116 wdt_ctrl(int timeout)
 117 {
 118         spin_lock(&io_lock);
 119
 120         w83697hf_select_wd_register();
 121
 122         outb_p(0xF4, W83697HF_EFER);    /* Select CRF4 */
 123         outb_p(timeout, W83697HF_EFDR); /* Write Timeout counter to CRF4 */
 124
 125         w83697hf_unselect_wd_register();
 126
 127         spin_unlock(&io_lock);
 128 }
 129
 130 static int
 131 wdt_ping(void)
 132 {
 133         wdt_ctrl(timeout);
 134         return 0;
 135 }
 136
 137 static int
 138 wdt_disable(void)
 139 {
 140         wdt_ctrl(0);
 141         return 0;
 142 }
 143
 144 static int
 145 wdt_set_heartbeat(int t)
 146 {
 147         if ((t < 1) || (t > 255))
 148                 return -EINVAL;
 149
 150         timeout = t;
 151         return 0;
 152 }
 153
 154 static ssize_t
 155 wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 156 {
 157         if (count) {
 158                 if (!nowayout) {
 159                         size_t i;
 160
 161                         expect_close = 0;
 162
 163                         for (i = 0; i != count; i++) {
 164                                 char c;
 165                                 if (get_user(c, buf+i))
 166                                         return -EFAULT;
 167                                 if (c == 'V')
 168                                         expect_close = 42;
 169                         }
 170                 }
 171                 wdt_ping();
 172         }
 173         return count;
 174 }
 175
 176 static int
 177 wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 178           unsigned long arg)
 179 {
 180         void __user *argp = (void __user *)arg;
 181         int __user *p = argp;
 182         int new_timeout;
 183         static struct watchdog_info ident = {
 184                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
 185                 .firmware_version = 1,
 186                 .identity = "W83697HF WDT",
 187         };
 188
 189         switch (cmd) {
 190         case WDIOC_GETSUPPORT:
 191                 if (copy_to_user(argp, &ident, sizeof(ident)))
 192                         return -EFAULT;
 193                 break;
 194
 195         case WDIOC_GETSTATUS:
 196         case WDIOC_GETBOOTSTATUS:
 197                 return put_user(0, p);
 198
 199         case WDIOC_KEEPALIVE:
 200                 wdt_ping();
 201                 break;
 202
 203         case WDIOC_SETTIMEOUT:
 204                 if (get_user(new_timeout, p))
 205                         return -EFAULT;
 206                 if (wdt_set_heartbeat(new_timeout))
 207                         return -EINVAL;
 208                 wdt_ping();
 209                 /* Fall */
 210
 211         case WDIOC_GETTIMEOUT:
 212                 return put_user(timeout, p);
 213
 214         case WDIOC_SETOPTIONS:
 215         {
 216                 int options, retval = -EINVAL;
 217
 218                 if (get_user(options, p))
 219                         return -EFAULT;
 220
 221                 if (options & WDIOS_DISABLECARD) {
 222                         wdt_disable();
 223                         retval = 0;
 224                 }
 225
 226                 if (options & WDIOS_ENABLECARD) {
 227                         wdt_ping();
 228                         retval = 0;
 229                 }
 230
 231                 return retval;
 232         }
 233
 234         default:
 235                 return -ENOTTY;
 236         }
 237         return 0;
 238 }
 239
 240 static int
 241 wdt_open(struct inode *inode, struct file *file)
 242 {
 243         if (test_and_set_bit(0, &wdt_is_open))
 244                 return -EBUSY;
 245         /*
 246          *      Activate
 247          */
 248
 249         wdt_ping();
 250         return nonseekable_open(inode, file);
 251 }
 252
 253 static int
 254 wdt_close(struct inode *inode, struct file *file)
 255 {
 256         if (expect_close == 42) {
 257                 wdt_disable();
 258         } else {
 259                 printk (KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
 260                 wdt_ping();
 261         }
 262         expect_close = 0;
 263         clear_bit(0, &wdt_is_open);
 264         return 0;
 265 }
 266
 267 /*
 268  *      Notifier for system down
 269  */
 270
 271 static int
 272 wdt_notify_sys(struct notifier_block *this, unsigned long code,
 273         void *unused)
 274 {
 275         if (code == SYS_DOWN || code == SYS_HALT) {
 276                 /* Turn the WDT off */
 277                 wdt_disable();
 278         }
 279         return NOTIFY_DONE;
 280 }
 281
 282 /*
 283  *      Kernel Interfaces
 284  */
 285
 286 static struct file_operations wdt_fops = {
 287         .owner          = THIS_MODULE,
 288         .llseek         = no_llseek,
 289         .write          = wdt_write,
 290         .ioctl          = wdt_ioctl,
 291         .open           = wdt_open,
 292         .release        = wdt_close,
 293 };
 294
 295 static struct miscdevice wdt_miscdev = {
 296         .minor = WATCHDOG_MINOR,
 297         .name = "watchdog",
 298         .fops = &wdt_fops,
 299 };
 300
 301 /*
 302  *      The WDT needs to learn about soft shutdowns in order to
 303  *      turn the timebomb registers off.
 304  */
 305
 306 static struct notifier_block wdt_notifier = {
 307         .notifier_call = wdt_notify_sys,
 308 };
 309
 310 static int __init
 311 wdt_init(void)
 312 {
 313         int ret;
 314
 315         spin_lock_init(&io_lock);
 316
 317         printk (KERN_INFO PFX "WDT driver for W83697HF/HG initializing\n");
 318
 319         if (wdt_set_heartbeat(timeout)) {
 320                 wdt_set_heartbeat(WATCHDOG_TIMEOUT);
 321                 printk (KERN_INFO PFX "timeout value must be 1<=timeout<=255, using %d\n",
 322                         WATCHDOG_TIMEOUT);
 323         }
 324
 325         if (!request_region(wdt_io, 2, WATCHDOG_NAME)) {
 326                 printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
 327                         wdt_io);
 328                 ret = -EIO;
 329                 goto out;
 330         }
 331
 332         w83697hf_init();
 333
 334         ret = register_reboot_notifier(&wdt_notifier);
 335         if (ret != 0) {
 336                 printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
 337                         ret);
 338                 goto unreg_regions;
 339         }
 340
 341         ret = misc_register(&wdt_miscdev);
 342         if (ret != 0) {
 343                 printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
 344                         WATCHDOG_MINOR, ret);
 345                 goto unreg_reboot;
 346         }
 347
 348         printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
 349                 timeout, nowayout);
 350
 351 out:
 352         return ret;
 353 unreg_reboot:
 354         unregister_reboot_notifier(&wdt_notifier);
 355 unreg_regions:
 356         release_region(wdt_io, 2);
 357         goto out;
 358 }
 359
 360 static void __exit
 361 wdt_exit(void)
 362 {
 363         misc_deregister(&wdt_miscdev);
 364         unregister_reboot_notifier(&wdt_notifier);
 365         release_region(wdt_io, 2);
 366 }
 367
 368 module_init(wdt_init);
 369 module_exit(wdt_exit);
 370
 371 MODULE_LICENSE("GPL");
 372 MODULE_AUTHOR("Marcus Junker <junker@anduras.de>");
 373 MODULE_DESCRIPTION("w83697hf/hg WDT driver");
 374 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);