drivers/char/watchdog/w83877f_wdt.c

   1 /*
   2  *      W83877F Computer Watchdog Timer driver
   3  *
   4  *      Based on acquirewdt.c by Alan Cox,
   5  *           and sbc60xxwdt.c by Jakob Oestergaard <jakob@unthought.net>
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License
   9  *      as published by the Free Software Foundation; either version
  10  *      2 of the License, or (at your option) any later version.
  11  *
  12  *      The authors do NOT admit liability nor provide warranty for
  13  *      any of this software. This material is provided "AS-IS" in
  14  *      the hope that it may be useful for others.
  15  *
  16  *      (c) Copyright 2001    Scott Jennings <linuxdrivers@oro.net>
  17  *
  18  *           4/19 - 2001      [Initial revision]
  19  *           9/27 - 2001      Added spinlocking
  20  *           4/12 - 2002      [rob@osinvestor.com] Eliminate extra comments
  21  *                            Eliminate fop_read
  22  *                            Eliminate extra spin_unlock
  23  *                            Added KERN_* tags to printks
  24  *                            add CONFIG_WATCHDOG_NOWAYOUT support
  25  *                            fix possible wdt_is_open race
  26  *                            changed watchdog_info to correctly reflect what the driver offers
  27  *                            added WDIOC_GETSTATUS, WDIOC_GETBOOTSTATUS, WDIOC_SETTIMEOUT,
  28  *                            WDIOC_GETTIMEOUT, and WDIOC_SETOPTIONS ioctls
  29  *           09/8 - 2003      [wim@iguana.be] cleanup of trailing spaces
  30  *                            added extra printk's for startup problems
  31  *                            use module_param
  32  *                            made timeout (the emulated heartbeat) a module_param
  33  *                            made the keepalive ping an internal subroutine
  34  *
  35  *  This WDT driver is different from most other Linux WDT
  36  *  drivers in that the driver will ping the watchdog by itself,
  37  *  because this particular WDT has a very short timeout (1.6
  38  *  seconds) and it would be insane to count on any userspace
  39  *  daemon always getting scheduled within that time frame.
  40  */
  41
  42 #include <linux/module.h>
  43 #include <linux/moduleparam.h>
  44 #include <linux/types.h>
  45 #include <linux/timer.h>
  46 #include <linux/jiffies.h>
  47 #include <linux/miscdevice.h>
  48 #include <linux/watchdog.h>
  49 #include <linux/fs.h>
  50 #include <linux/ioport.h>
  51 #include <linux/notifier.h>
  52 #include <linux/reboot.h>
  53 #include <linux/init.h>
  54 #include <asm/io.h>
  55 #include <asm/uaccess.h>
  56 #include <asm/system.h>
  57
  58 #define OUR_NAME "w83877f_wdt"
  59 #define PFX OUR_NAME ": "
  60
  61 #define ENABLE_W83877F_PORT 0x3F0
  62 #define ENABLE_W83877F 0x87
  63 #define DISABLE_W83877F 0xAA
  64 #define WDT_PING 0x443
  65 #define WDT_REGISTER 0x14
  66 #define WDT_ENABLE 0x9C
  67 #define WDT_DISABLE 0x8C
  68
  69 /*
  70  * The W83877F seems to be fixed at 1.6s timeout (at least on the
  71  * EMACS PC-104 board I'm using). If we reset the watchdog every
  72  * ~250ms we should be safe.  */
  73
  74 #define WDT_INTERVAL (HZ/4+1)
  75
  76 /*
  77  * We must not require too good response from the userspace daemon.
  78  * Here we require the userspace daemon to send us a heartbeat
  79  * char to /dev/watchdog every 30 seconds.
  80  */
  81
  82 #define WATCHDOG_TIMEOUT 30            /* 30 sec default timeout */
  83 static int timeout = WATCHDOG_TIMEOUT; /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
  84 module_param(timeout, int, 0);
  85 MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
  86
  87
  88 #ifdef CONFIG_WATCHDOG_NOWAYOUT
  89 static int nowayout = 1;
  90 #else
  91 static int nowayout = 0;
  92 #endif
  93
  94 module_param(nowayout, int, 0);
  95 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
  96
  97 static void wdt_timer_ping(unsigned long);
  98 static struct timer_list timer;
  99 static unsigned long next_heartbeat;
 100 static unsigned long wdt_is_open;
 101 static char wdt_expect_close;
 102 static spinlock_t wdt_spinlock;
 103
 104 /*
 105  *      Whack the dog
 106  */
 107
 108 static void wdt_timer_ping(unsigned long data)
 109 {
 110         /* If we got a heartbeat pulse within the WDT_US_INTERVAL
 111          * we agree to ping the WDT
 112          */
 113         if(time_before(jiffies, next_heartbeat))
 114         {
 115                 /* Ping the WDT */
 116                 spin_lock(&wdt_spinlock);
 117
 118                 /* Ping the WDT by reading from WDT_PING */
 119                 inb_p(WDT_PING);
 120
 121                 /* Re-set the timer interval */
 122                 timer.expires = jiffies + WDT_INTERVAL;
 123                 add_timer(&timer);
 124
 125                 spin_unlock(&wdt_spinlock);
 126
 127         } else {
 128                 printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
 129         }
 130 }
 131
 132 /*
 133  * Utility routines
 134  */
 135
 136 static void wdt_change(int writeval)
 137 {
 138         unsigned long flags;
 139         spin_lock_irqsave(&wdt_spinlock, flags);
 140
 141         /* buy some time */
 142         inb_p(WDT_PING);
 143
 144         /* make W83877F available */
 145         outb_p(ENABLE_W83877F,  ENABLE_W83877F_PORT);
 146         outb_p(ENABLE_W83877F,  ENABLE_W83877F_PORT);
 147
 148         /* enable watchdog */
 149         outb_p(WDT_REGISTER,    ENABLE_W83877F_PORT);
 150         outb_p(writeval,        ENABLE_W83877F_PORT+1);
 151
 152         /* lock the W8387FF away */
 153         outb_p(DISABLE_W83877F, ENABLE_W83877F_PORT);
 154
 155         spin_unlock_irqrestore(&wdt_spinlock, flags);
 156 }
 157
 158 static void wdt_startup(void)
 159 {
 160         next_heartbeat = jiffies + (timeout * HZ);
 161
 162         /* Start the timer */
 163         timer.expires = jiffies + WDT_INTERVAL;
 164         add_timer(&timer);
 165
 166         wdt_change(WDT_ENABLE);
 167
 168         printk(KERN_INFO PFX "Watchdog timer is now enabled.\n");
 169 }
 170
 171 static void wdt_turnoff(void)
 172 {
 173         /* Stop the timer */
 174         del_timer(&timer);
 175
 176         wdt_change(WDT_DISABLE);
 177
 178         printk(KERN_INFO PFX "Watchdog timer is now disabled...\n");
 179 }
 180
 181 static void wdt_keepalive(void)
 182 {
 183         /* user land ping */
 184         next_heartbeat = jiffies + (timeout * HZ);
 185 }
 186
 187 /*
 188  * /dev/watchdog handling
 189  */
 190
 191 static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos)
 192 {
 193         /* See if we got the magic character 'V' and reload the timer */
 194         if(count)
 195         {
 196                 if (!nowayout)
 197                 {
 198                         size_t ofs;
 199
 200                         /* note: just in case someone wrote the magic character
 201                          * five months ago... */
 202                         wdt_expect_close = 0;
 203
 204                         /* scan to see whether or not we got the magic character */
 205                         for(ofs = 0; ofs != count; ofs++)
 206                         {
 207                                 char c;
 208                                 if (get_user(c, buf + ofs))
 209                                         return -EFAULT;
 210                                 if (c == 'V')
 211                                         wdt_expect_close = 42;
 212                         }
 213                 }
 214
 215                 /* someone wrote to us, we should restart timer */
 216                 wdt_keepalive();
 217         }
 218         return count;
 219 }
 220
 221 static int fop_open(struct inode * inode, struct file * file)
 222 {
 223         /* Just in case we're already talking to someone... */
 224         if(test_and_set_bit(0, &wdt_is_open))
 225                 return -EBUSY;
 226
 227         /* Good, fire up the show */
 228         wdt_startup();
 229         return nonseekable_open(inode, file);
 230 }
 231
 232 static int fop_close(struct inode * inode, struct file * file)
 233 {
 234         if(wdt_expect_close == 42)
 235                 wdt_turnoff();
 236         else {
 237                 del_timer(&timer);
 238                 printk(KERN_CRIT PFX "device file closed unexpectedly. Will not stop the WDT!\n");
 239         }
 240         clear_bit(0, &wdt_is_open);
 241         wdt_expect_close = 0;
 242         return 0;
 243 }
 244
 245 static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 246         unsigned long arg)
 247 {
 248         void __user *argp = (void __user *)arg;
 249         int __user *p = argp;
 250         static struct watchdog_info ident=
 251         {
 252                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
 253                 .firmware_version = 1,
 254                 .identity = "W83877F",
 255         };
 256
 257         switch(cmd)
 258         {
 259                 default:
 260                         return -ENOIOCTLCMD;
 261                 case WDIOC_GETSUPPORT:
 262                         return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
 263                 case WDIOC_GETSTATUS:
 264                 case WDIOC_GETBOOTSTATUS:
 265                         return put_user(0, p);
 266                 case WDIOC_KEEPALIVE:
 267                         wdt_keepalive();
 268                         return 0;
 269                 case WDIOC_SETOPTIONS:
 270                 {
 271                         int new_options, retval = -EINVAL;
 272
 273                         if(get_user(new_options, p))
 274                                 return -EFAULT;
 275
 276                         if(new_options & WDIOS_DISABLECARD) {
 277                                 wdt_turnoff();
 278                                 retval = 0;
 279                         }
 280
 281                         if(new_options & WDIOS_ENABLECARD) {
 282                                 wdt_startup();
 283                                 retval = 0;
 284                         }
 285
 286                         return retval;
 287                 }
 288                 case WDIOC_SETTIMEOUT:
 289                 {
 290                         int new_timeout;
 291
 292                         if(get_user(new_timeout, p))
 293                                 return -EFAULT;
 294
 295                         if(new_timeout < 1 || new_timeout > 3600) /* arbitrary upper limit */
 296                                 return -EINVAL;
 297
 298                         timeout = new_timeout;
 299                         wdt_keepalive();
 300                         /* Fall through */
 301                 }
 302                 case WDIOC_GETTIMEOUT:
 303                         return put_user(timeout, p);
 304         }
 305 }
 306
 307 static struct file_operations wdt_fops = {
 308         .owner          = THIS_MODULE,
 309         .llseek         = no_llseek,
 310         .write          = fop_write,
 311         .open           = fop_open,
 312         .release        = fop_close,
 313         .ioctl          = fop_ioctl,
 314 };
 315
 316 static struct miscdevice wdt_miscdev = {
 317         .minor  = WATCHDOG_MINOR,
 318         .name   = "watchdog",
 319         .fops   = &wdt_fops,
 320 };
 321
 322 /*
 323  *      Notifier for system down
 324  */
 325
 326 static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
 327         void *unused)
 328 {
 329         if(code==SYS_DOWN || code==SYS_HALT)
 330                 wdt_turnoff();
 331         return NOTIFY_DONE;
 332 }
 333
 334 /*
 335  *      The WDT needs to learn about soft shutdowns in order to
 336  *      turn the timebomb registers off.
 337  */
 338
 339 static struct notifier_block wdt_notifier=
 340 {
 341         .notifier_call = wdt_notify_sys,
 342 };
 343
 344 static void __exit w83877f_wdt_unload(void)
 345 {
 346         wdt_turnoff();
 347
 348         /* Deregister */
 349         misc_deregister(&wdt_miscdev);
 350
 351         unregister_reboot_notifier(&wdt_notifier);
 352         release_region(WDT_PING,1);
 353         release_region(ENABLE_W83877F_PORT,2);
 354 }
 355
 356 static int __init w83877f_wdt_init(void)
 357 {
 358         int rc = -EBUSY;
 359
 360         spin_lock_init(&wdt_spinlock);
 361
 362         if(timeout < 1 || timeout > 3600) /* arbitrary upper limit */
 363         {
 364                 timeout = WATCHDOG_TIMEOUT;
 365                 printk(KERN_INFO PFX "timeout value must be 1<=x<=3600, using %d\n",
 366                         timeout);
 367         }
 368
 369         if (!request_region(ENABLE_W83877F_PORT, 2, "W83877F WDT"))
 370         {
 371                 printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
 372                         ENABLE_W83877F_PORT);
 373                 rc = -EIO;
 374                 goto err_out;
 375         }
 376
 377         if (!request_region(WDT_PING, 1, "W8387FF WDT"))
 378         {
 379                 printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
 380                         WDT_PING);
 381                 rc = -EIO;
 382                 goto err_out_region1;
 383         }
 384
 385         init_timer(&timer);
 386         timer.function = wdt_timer_ping;
 387         timer.data = 0;
 388
 389         rc = misc_register(&wdt_miscdev);
 390         if (rc)
 391         {
 392                 printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
 393                         wdt_miscdev.minor, rc);
 394                 goto err_out_region2;
 395         }
 396
 397         rc = register_reboot_notifier(&wdt_notifier);
 398         if (rc)
 399         {
 400                 printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
 401                         rc);
 402                 goto err_out_miscdev;
 403         }
 404
 405         printk(KERN_INFO PFX "WDT driver for W83877F initialised. timeout=%d sec (nowayout=%d)\n",
 406                 timeout, nowayout);
 407
 408         return 0;
 409
 410 err_out_miscdev:
 411         misc_deregister(&wdt_miscdev);
 412 err_out_region2:
 413         release_region(WDT_PING,1);
 414 err_out_region1:
 415         release_region(ENABLE_W83877F_PORT,2);
 416 err_out:
 417         return rc;
 418 }
 419
 420 module_init(w83877f_wdt_init);
 421 module_exit(w83877f_wdt_unload);
 422
 423 MODULE_AUTHOR("Scott and Bill Jennings");
 424 MODULE_DESCRIPTION("Driver for watchdog timer in w83877f chip");
 425 MODULE_LICENSE("GPL");
 426 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);