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         unsigned int options;
 134         int new_margin;
 135
 136         switch (cmd) {
 137         case WDIOC_GETSUPPORT:
 138                 if (copy_to_user((struct watchdog_info *) arg, &info, sizeof(info)))
 139                         return -EFAULT;
 140                 break;
 141
 142         case WDIOC_GETSTATUS:
 143         case WDIOC_GETBOOTSTATUS:
 144                 if (put_user(0, (int *) arg))
 145                         return -EFAULT;
 146                 break;
 147
 148         case WDIOC_KEEPALIVE:
 149                 riowd_pingtimer();
 150                 break;
 151
 152         case WDIOC_SETOPTIONS:
 153                 if (copy_from_user(&options, (void *) arg, sizeof(options)))
 154                         return -EFAULT;
 155
 156                 if (options & WDIOS_DISABLECARD)
 157                         riowd_stoptimer();
 158                 else if (options & WDIOS_ENABLECARD)
 159                         riowd_starttimer();
 160                 else
 161                         return -EINVAL;
 162
 163                 break;
 164
 165         case WDIOC_SETTIMEOUT:
 166                 if (get_user(new_margin, (int *)arg))
 167                         return -EFAULT;
 168                 if ((new_margin < 60) || (new_margin > (255 * 60)))
 169                     return -EINVAL;
 170                 riowd_timeout = (new_margin + 59) / 60;
 171                 riowd_pingtimer();
 172                 /* Fall */
 173
 174         case WDIOC_GETTIMEOUT:
 175                 return put_user(riowd_timeout * 60, (int *)arg);
 176
 177         default:
 178                 return -EINVAL;
 179         };
 180
 181         return 0;
 182 }
 183
 184 static ssize_t riowd_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
 185 {
 186         if (ppos != &file->f_pos)
 187                 return -ESPIPE;
 188
 189         if (count) {
 190                 riowd_pingtimer();
 191                 return 1;
 192         }
 193
 194         return 0;
 195 }
 196
 197 static struct file_operations riowd_fops = {
 198         .owner =        THIS_MODULE,
 199         .ioctl =        riowd_ioctl,
 200         .open =         riowd_open,
 201         .write =        riowd_write,
 202         .release =      riowd_release,
 203 };
 204
 205 static struct miscdevice riowd_miscdev = { RIOWD_MINOR, RIOWD_NAME, &riowd_fops };
 206
 207 static int __init riowd_bbc_init(void)
 208 {
 209         struct  linux_ebus *ebus = NULL;
 210         struct  linux_ebus_device *edev = NULL;
 211         u8 val;
 212
 213         for_each_ebus(ebus) {
 214                 for_each_ebusdev(edev, ebus) {
 215                         if (!strcmp(edev->prom_name, "bbc"))
 216                                 goto found_bbc;
 217                 }
 218         }
 219
 220 found_bbc:
 221         if (!edev)
 222                 return -ENODEV;
 223         bbc_regs = ioremap(edev->resource[0].start, BBC_REGS_SIZE);
 224         if (!bbc_regs)
 225                 return -ENODEV;
 226
 227         /* Turn it off. */
 228         val = readb(bbc_regs + BBC_WDACTION);
 229         val &= ~BBC_WDACTION_RST;
 230         writeb(val, bbc_regs + BBC_WDACTION);
 231
 232         return 0;
 233 }
 234
 235 static int __init riowd_init(void)
 236 {
 237         struct  linux_ebus *ebus = NULL;
 238         struct  linux_ebus_device *edev = NULL;
 239
 240         for_each_ebus(ebus) {
 241                 for_each_ebusdev(edev, ebus) {
 242                         if (!strcmp(edev->prom_name, RIOWD_NAME))
 243                                 goto ebus_done;
 244                 }
 245         }
 246
 247 ebus_done:
 248         if (!edev)
 249                 goto fail;
 250
 251         riowd_regs = ioremap(edev->resource[0].start, 2);
 252         if (riowd_regs == NULL) {
 253                 printk(KERN_ERR "pmc: Cannot map registers.\n");
 254                 return -ENODEV;
 255         }
 256
 257         if (riowd_bbc_init()) {
 258                 printk(KERN_ERR "pmc: Failure initializing BBC config.\n");
 259                 goto fail;
 260         }
 261
 262         if (misc_register(&riowd_miscdev)) {
 263                 printk(KERN_ERR "pmc: Cannot register watchdog misc device.\n");
 264                 goto fail;
 265         }
 266
 267         printk(KERN_INFO "pmc: Hardware watchdog [%i minutes], "
 268                "regs at %p\n", riowd_timeout, riowd_regs);
 269
 270         return 0;
 271
 272 fail:
 273         if (riowd_regs) {
 274                 iounmap(riowd_regs);
 275                 riowd_regs = NULL;
 276         }
 277         if (bbc_regs) {
 278                 iounmap(bbc_regs);
 279                 bbc_regs = NULL;
 280         }
 281         return -ENODEV;
 282 }
 283
 284 static void __exit riowd_cleanup(void)
 285 {
 286         misc_deregister(&riowd_miscdev);
 287         iounmap(riowd_regs);
 288         riowd_regs = NULL;
 289         iounmap(bbc_regs);
 290         bbc_regs = NULL;
 291 }
 292
 293 module_init(riowd_init);
 294 module_exit(riowd_cleanup);