drivers/char/acquirewdt.c

   1 /*
   2  *      Acquire Single Board Computer Watchdog Timer driver for Linux 2.1.x
   3  *
   4  *      Based on wdt.c. Original copyright messages:
   5  *
   6  *      (c) Copyright 1996 Alan Cox <alan@cymru.net>, All Rights Reserved.
   7  *                              http://www.cymru.net
   8  *
   9  *      This program is free software; you can redistribute it and/or
  10  *      modify it under the terms of the GNU General Public License
  11  *      as published by the Free Software Foundation; either version
  12  *      2 of the License, or (at your option) any later version.
  13  *
  14  *      Neither Alan Cox nor CymruNet Ltd. admit liability nor provide
  15  *      warranty for any of this software. This material is provided
  16  *      "AS-IS" and at no charge.
  17  *
  18  *      (c) Copyright 1995    Alan Cox <alan@lxorguk.ukuu.org.uk>
  19  *
  20  */
  21
  22 #include <linux/config.h>
  23 #include <linux/module.h>
  24 #include <linux/version.h>
  25 #include <linux/types.h>
  26 #include <linux/errno.h>
  27 #include <linux/kernel.h>
  28 #include <linux/sched.h>
  29 #include <linux/miscdevice.h>
  30 #include <linux/watchdog.h>
  31 #include <linux/malloc.h>
  32 #include <linux/ioport.h>
  33 #include <linux/fcntl.h>
  34 #include <asm/io.h>
  35 #include <asm/uaccess.h>
  36 #include <asm/system.h>
  37 #include <linux/notifier.h>
  38 #include <linux/reboot.h>
  39 #include <linux/init.h>
  40
  41 static int acq_is_open=0;
  42
  43 /*
  44  *      You must set these - there is no sane way to probe for this board.
  45  */
  46
  47 #define WDT_STOP 0x43
  48 #define WDT_START 0x443
  49
  50 #define WD_TIMO (100*60)                /* 1 minute */
  51
  52
  53 /*
  54  *      Kernel methods.
  55  */
  56
  57
  58 static void acq_ping(void)
  59 {
  60         /* Write a watchdog value */
  61         inb_p(WDT_START);
  62 }
  63
  64 static ssize_t acq_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
  65 {
  66         /*  Can't seek (pwrite) on this device  */
  67         if (ppos != &file->f_pos)
  68                 return -ESPIPE;
  69
  70         if(count)
  71         {
  72                 acq_ping();
  73                 return 1;
  74         }
  75         return 0;
  76 }
  77
  78 static ssize_t acq_read(struct file *file, char *buf, size_t count, loff_t *ppos)
  79 {
  80         return -EINVAL;
  81 }
  82
  83
  84
  85 static int acq_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
  86         unsigned long arg)
  87 {
  88         static struct watchdog_info ident=
  89         {
  90                 WDIOF_KEEPALIVEPING, 1, "Acquire WDT"
  91         };
  92
  93         switch(cmd)
  94         {
  95         case WDIOC_GETSUPPORT:
  96           if (copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident)))
  97             return -EFAULT;
  98           break;
  99
 100         case WDIOC_GETSTATUS:
 101           if (copy_to_user((int *)arg, &acq_is_open,  sizeof(int)))
 102             return -EFAULT;
 103           break;
 104
 105         case WDIOC_KEEPALIVE:
 106           acq_ping();
 107           break;
 108
 109         default:
 110           return -ENOIOCTLCMD;
 111         }
 112         return 0;
 113 }
 114
 115 static int acq_open(struct inode *inode, struct file *file)
 116 {
 117         switch(MINOR(inode->i_rdev))
 118         {
 119                 case WATCHDOG_MINOR:
 120                         if(acq_is_open)
 121                                 return -EBUSY;
 122                         MOD_INC_USE_COUNT;
 123                         /*
 124                          *      Activate
 125                          */
 126
 127                         acq_is_open=1;
 128                         inb_p(WDT_START);
 129                         return 0;
 130                 default:
 131                         return -ENODEV;
 132         }
 133 }
 134
 135 static int acq_close(struct inode *inode, struct file *file)
 136 {
 137         if(MINOR(inode->i_rdev)==WATCHDOG_MINOR)
 138         {
 139 #ifndef CONFIG_WATCHDOG_NOWAYOUT
 140                 inb_p(WDT_STOP);
 141 #endif
 142                 acq_is_open=0;
 143         }
 144         MOD_DEC_USE_COUNT;
 145         return 0;
 146 }
 147
 148 /*
 149  *      Notifier for system down
 150  */
 151
 152 static int acq_notify_sys(struct notifier_block *this, unsigned long code,
 153         void *unused)
 154 {
 155         if(code==SYS_DOWN || code==SYS_HALT)
 156         {
 157                 /* Turn the card off */
 158                 inb_p(WDT_STOP);
 159         }
 160         return NOTIFY_DONE;
 161 }
 162
 163 /*
 164  *      Kernel Interfaces
 165  */
 166
 167
 168 static struct file_operations acq_fops = {
 169         NULL,
 170         acq_read,
 171         acq_write,
 172         NULL,           /* No Readdir */
 173         NULL,           /* No Select */
 174         acq_ioctl,
 175         NULL,           /* No mmap */
 176         acq_open,
 177         NULL,           /* flush */
 178         acq_close
 179 };
 180
 181 static struct miscdevice acq_miscdev=
 182 {
 183         WATCHDOG_MINOR,
 184         "watchdog",
 185         &acq_fops
 186 };
 187
 188
 189 /*
 190  *      The WDT card needs to learn about soft shutdowns in order to
 191  *      turn the timebomb registers off.
 192  */
 193
 194 static struct notifier_block acq_notifier=
 195 {
 196         acq_notify_sys,
 197         NULL,
 198         0
 199 };
 200
 201 #ifdef MODULE
 202
 203 #define acq_init init_module
 204
 205 void cleanup_module(void)
 206 {
 207         misc_deregister(&acq_miscdev);
 208         unregister_reboot_notifier(&acq_notifier);
 209         release_region(WDT_STOP,1);
 210         release_region(WDT_START,1);
 211 }
 212
 213 #endif
 214
 215 __initfunc(int acq_init(void))
 216 {
 217         printk("WDT driver for Acquire single board computer initialising.\n");
 218
 219         misc_register(&acq_miscdev);
 220         request_region(WDT_STOP, 1, "Acquire WDT");
 221         request_region(WDT_START, 1, "Acquire WDT");
 222         unregister_reboot_notifier(&acq_notifier);
 223         return 0;
 224 }
 225