drivers/sbus/char/riowatchdog.c

   1 /* $Id: riowatchdog.c,v 1.3.2.2 2002/01/23 18:48:02 davem Exp $
   2  * riowatchdog.c - driver for hw watchdog inside Super I/O of RIO
   3  *
   4  * Copyright (C) 2001 David S. Miller (davem@redhat.com)
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/types.h>
  10 #include <linux/fs.h>
  11 #include <linux/errno.h>
  12 #include <linux/init.h>
  13 #include <linux/miscdevice.h>
  14
  15 #include <asm/io.h>
  16 #include <asm/ebus.h>
  17 #include <asm/bbc.h>
  18 #include <asm/oplib.h>
  19 #include <asm/uaccess.h>
  20
  21 #include <asm/watchdog.h>
  22
  23 /* RIO uses the NatSemi Super I/O power management logical device
  24  * as its' watchdog.
  25  *
  26  * When the watchdog triggers, it asserts a line to the BBC (Boot Bus
  27  * Controller) of the machine.  The BBC can only be configured to
  28  * trigger a power-on reset when the signal is asserted.  The BBC
  29  * can be configured to ignore the signal entirely as well.
  30  *
  31  * The only Super I/O device register we care about is at index
  32  * 0x05 (WDTO_INDEX) which is the watchdog time-out in minutes (1-255).
  33  * If set to zero, this disables the watchdog.  When set, the system
  34  * must periodically (before watchdog expires) clear (set to zero) and
  35  * re-set the watchdog else it will trigger.
  36  *
  37  * There are two other indexed watchdog registers inside this Super I/O
  38  * logical device, but they are unused.  The first, at index 0x06 is
  39  * the watchdog control and can be used to make the watchdog timer re-set
  40  * when the PS/2 mouse or serial lines show activity.  The second, at
  41  * index 0x07 is merely a sampling of the line from the watchdog to the
  42  * BBC.
  43  *
  44  * The watchdog device generates no interrupts.
  45  */
  46
  47 MODULE_AUTHOR("David S. Miller <davem@redhat.com>");
  48 MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
  49 MODULE_SUPPORTED_DEVICE("watchdog");
  50 MODULE_LICENSE("GPL");
  51
  52 #define RIOWD_NAME      "pmc"
  53 #define RIOWD_MINOR     215
  54
  55 static spinlock_t riowd_lock = SPIN_LOCK_UNLOCKED;
  56
  57 static void *bbc_regs;
  58 static void *riowd_regs;
  59 #define WDTO_INDEX      0x05
  60
  61 static int riowd_timeout = 1;           /* in minutes */
  62 MODULE_PARM(riowd_timeout,"i");
  63 MODULE_PARM_DESC(riowd_timeout, "Watchdog timeout in minutes");
  64
  65 #if 0 /* Currently unused. */
  66 static u8 riowd_readreg(int index)
  67 {
  68         unsigned long flags;
  69         u8 ret;
  70
  71         spin_lock_irqsave(&riowd_lock, flags);
  72         writeb(index, riowd_regs + 0);
  73         ret = readb(riowd_regs + 1);
  74         spin_unlock_irqrestore(&riowd_lock, flags);
  75
  76         return ret;
  77 }
  78 #endif
  79
  80 static void riowd_writereg(u8 val, int index)
  81 {
  82         unsigned long flags;
  83
  84         spin_lock_irqsave(&riowd_lock, flags);
  85         writeb(index, riowd_regs + 0);
  86         writeb(val, riowd_regs + 1);
  87         spin_unlock_irqrestore(&riowd_lock, flags);
  88 }
  89
  90 static void riowd_pingtimer(void)
  91 {
  92         riowd_writereg(riowd_timeout, WDTO_INDEX);
  93 }
  94
  95 static void riowd_stoptimer(void)
  96 {
  97         u8 val;
  98
  99         riowd_writereg(0, WDTO_INDEX);
 100
 101         val = readb(bbc_regs + BBC_WDACTION);
 102         val &= ~BBC_WDACTION_RST;
 103         writeb(val, bbc_regs + BBC_WDACTION);
 104 }
 105
 106 static void riowd_starttimer(void)
 107 {
 108         u8 val;
 109
 110         riowd_writereg(riowd_timeout, WDTO_INDEX);
 111
 112         val = readb(bbc_regs + BBC_WDACTION);
 113         val |= BBC_WDACTION_RST;
 114         writeb(val, bbc_regs + BBC_WDACTION);
 115 }
 116
 117 static int riowd_open(struct inode *inode, struct file *filp)
 118 {
 119         return 0;
 120 }
 121
 122 static int riowd_release(struct inode *inode, struct file *filp)
 123 {
 124         return 0;
 125 }
 126
 127 static int riowd_ioctl(struct inode *inode, struct file *filp,
 128                        unsigned int cmd, unsigned long arg)
 129 {
 130         static struct watchdog_info info = {
 131                 WDIOF_SETTIMEOUT, 0, "Natl. Semiconductor PC97317"
 132         };
 133         void __user *argp = (void __user *)arg;
 134         unsigned int options;
 135         int new_margin;
 136
 137         switch (cmd) {
 138         case WDIOC_GETSUPPORT:
 139                 if (copy_to_user(argp, &info, sizeof(info)))
 140                         return -EFAULT;
 141                 break;
 142
 143         case WDIOC_GETSTATUS:
 144         case WDIOC_GETBOOTSTATUS:
 145                 if (put_user(0, (int __user *)argp))
 146                         return -EFAULT;
 147                 break;
 148
 149         case WDIOC_KEEPALIVE:
 150                 riowd_pingtimer();
 151                 break;
 152
 153         case WDIOC_SETOPTIONS:
 154                 if (copy_from_user(&options, argp, sizeof(options)))
 155                         return -EFAULT;
 156
 157                 if (options & WDIOS_DISABLECARD)
 158                         riowd_stoptimer();
 159                 else if (options & WDIOS_ENABLECARD)
 160                         riowd_starttimer();
 161                 else
 162                         return -EINVAL;
 163
 164                 break;
 165
 166         case WDIOC_SETTIMEOUT:
 167                 if (get_user(new_margin, (int __user *)argp))
 168                         return -EFAULT;
 169                 if ((new_margin < 60) || (new_margin > (255 * 60)))
 170                     return -EINVAL;
 171                 riowd_timeout = (new_margin + 59) / 60;
 172                 riowd_pingtimer();
 173                 /* Fall */
 174
 175         case WDIOC_GETTIMEOUT:
 176                 return put_user(riowd_timeout * 60, (int __user *)argp);
 177
 178         default:
 179                 return -EINVAL;
 180         };
 181
 182         return 0;
 183 }
 184
 185 static ssize_t riowd_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 186 {
 187         if (ppos != &file->f_pos)
 188                 return -ESPIPE;
 189
 190         if (count) {
 191                 riowd_pingtimer();
 192                 return 1;
 193         }
 194
 195         return 0;
 196 }
 197
 198 static struct file_operations riowd_fops = {
 199         .owner =        THIS_MODULE,
 200         .ioctl =        riowd_ioctl,
 201         .open =         riowd_open,
 202         .write =        riowd_write,
 203         .release =      riowd_release,
 204 };
 205
 206 static struct miscdevice riowd_miscdev = { RIOWD_MINOR, RIOWD_NAME, &riowd_fops };
 207
 208 static int __init riowd_bbc_init(void)
 209 {
 210         struct  linux_ebus *ebus = NULL;
 211         struct  linux_ebus_device *edev = NULL;
 212         u8 val;
 213
 214         for_each_ebus(ebus) {
 215                 for_each_ebusdev(edev, ebus) {
 216                         if (!strcmp(edev->prom_name, "bbc"))
 217                                 goto found_bbc;
 218                 }
 219         }
 220
 221 found_bbc:
 222         if (!edev)
 223                 return -ENODEV;
 224         bbc_regs = ioremap(edev->resource[0].start, BBC_REGS_SIZE);
 225         if (!bbc_regs)
 226                 return -ENODEV;
 227
 228         /* Turn it off. */
 229         val = readb(bbc_regs + BBC_WDACTION);
 230         val &= ~BBC_WDACTION_RST;
 231         writeb(val, bbc_regs + BBC_WDACTION);
 232
 233         return 0;
 234 }
 235
 236 static int __init riowd_init(void)
 237 {
 238         struct  linux_ebus *ebus = NULL;
 239         struct  linux_ebus_device *edev = NULL;
 240
 241         for_each_ebus(ebus) {
 242                 for_each_ebusdev(edev, ebus) {
 243                         if (!strcmp(edev->prom_name, RIOWD_NAME))
 244                                 goto ebus_done;
 245                 }
 246         }
 247
 248 ebus_done:
 249         if (!edev)
 250                 goto fail;
 251
 252         riowd_regs = ioremap(edev->resource[0].start, 2);
 253         if (riowd_regs == NULL) {
 254                 printk(KERN_ERR "pmc: Cannot map registers.\n");
 255                 return -ENODEV;
 256         }
 257
 258         if (riowd_bbc_init()) {
 259                 printk(KERN_ERR "pmc: Failure initializing BBC config.\n");
 260                 goto fail;
 261         }
 262
 263         if (misc_register(&riowd_miscdev)) {
 264                 printk(KERN_ERR "pmc: Cannot register watchdog misc device.\n");
 265                 goto fail;
 266         }
 267
 268         printk(KERN_INFO "pmc: Hardware watchdog [%i minutes], "
 269                "regs at %p\n", riowd_timeout, riowd_regs);
 270
 271         return 0;
 272
 273 fail:
 274         if (riowd_regs) {
 275                 iounmap(riowd_regs);
 276                 riowd_regs = NULL;
 277         }
 278         if (bbc_regs) {
 279                 iounmap(bbc_regs);
 280                 bbc_regs = NULL;
 281         }
 282         return -ENODEV;
 283 }
 284
 285 static void __exit riowd_cleanup(void)
 286 {
 287         misc_deregister(&riowd_miscdev);
 288         iounmap(riowd_regs);
 289         riowd_regs = NULL;
 290         iounmap(bbc_regs);
 291         bbc_regs = NULL;
 292 }
 293
 294 module_init(riowd_init);
 295 module_exit(riowd_cleanup);