linux/drivers/watchdog/riowd.c
<<
>>
Prefs
   1/* riowd.c - driver for hw watchdog inside Super I/O of RIO
   2 *
   3 * Copyright (C) 2001, 2008 David S. Miller (davem@davemloft.net)
   4 */
   5
   6#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   7
   8#include <linux/kernel.h>
   9#include <linux/module.h>
  10#include <linux/types.h>
  11#include <linux/fs.h>
  12#include <linux/errno.h>
  13#include <linux/init.h>
  14#include <linux/miscdevice.h>
  15#include <linux/watchdog.h>
  16#include <linux/of.h>
  17#include <linux/of_device.h>
  18#include <linux/io.h>
  19#include <linux/uaccess.h>
  20#include <linux/slab.h>
  21
  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
  47MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
  48MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
  49MODULE_SUPPORTED_DEVICE("watchdog");
  50MODULE_LICENSE("GPL");
  51
  52#define DRIVER_NAME     "riowd"
  53#define PFX             DRIVER_NAME ": "
  54
  55struct riowd {
  56        void __iomem            *regs;
  57        spinlock_t              lock;
  58};
  59
  60static struct riowd *riowd_device;
  61
  62#define WDTO_INDEX      0x05
  63
  64static int riowd_timeout = 1;           /* in minutes */
  65module_param(riowd_timeout, int, 0);
  66MODULE_PARM_DESC(riowd_timeout, "Watchdog timeout in minutes");
  67
  68static void riowd_writereg(struct riowd *p, u8 val, int index)
  69{
  70        unsigned long flags;
  71
  72        spin_lock_irqsave(&p->lock, flags);
  73        writeb(index, p->regs + 0);
  74        writeb(val, p->regs + 1);
  75        spin_unlock_irqrestore(&p->lock, flags);
  76}
  77
  78static int riowd_open(struct inode *inode, struct file *filp)
  79{
  80        nonseekable_open(inode, filp);
  81        return 0;
  82}
  83
  84static int riowd_release(struct inode *inode, struct file *filp)
  85{
  86        return 0;
  87}
  88
  89static long riowd_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  90{
  91        static const struct watchdog_info info = {
  92                .options                = WDIOF_SETTIMEOUT,
  93                .firmware_version       = 1,
  94                .identity               = DRIVER_NAME,
  95        };
  96        void __user *argp = (void __user *)arg;
  97        struct riowd *p = riowd_device;
  98        unsigned int options;
  99        int new_margin;
 100
 101        switch (cmd) {
 102        case WDIOC_GETSUPPORT:
 103                if (copy_to_user(argp, &info, sizeof(info)))
 104                        return -EFAULT;
 105                break;
 106
 107        case WDIOC_GETSTATUS:
 108        case WDIOC_GETBOOTSTATUS:
 109                if (put_user(0, (int __user *)argp))
 110                        return -EFAULT;
 111                break;
 112
 113        case WDIOC_KEEPALIVE:
 114                riowd_writereg(p, riowd_timeout, WDTO_INDEX);
 115                break;
 116
 117        case WDIOC_SETOPTIONS:
 118                if (copy_from_user(&options, argp, sizeof(options)))
 119                        return -EFAULT;
 120
 121                if (options & WDIOS_DISABLECARD)
 122                        riowd_writereg(p, 0, WDTO_INDEX);
 123                else if (options & WDIOS_ENABLECARD)
 124                        riowd_writereg(p, riowd_timeout, WDTO_INDEX);
 125                else
 126                        return -EINVAL;
 127
 128                break;
 129
 130        case WDIOC_SETTIMEOUT:
 131                if (get_user(new_margin, (int __user *)argp))
 132                        return -EFAULT;
 133                if ((new_margin < 60) || (new_margin > (255 * 60)))
 134                        return -EINVAL;
 135                riowd_timeout = (new_margin + 59) / 60;
 136                riowd_writereg(p, riowd_timeout, WDTO_INDEX);
 137                /* Fall */
 138
 139        case WDIOC_GETTIMEOUT:
 140                return put_user(riowd_timeout * 60, (int __user *)argp);
 141
 142        default:
 143                return -EINVAL;
 144        };
 145
 146        return 0;
 147}
 148
 149static ssize_t riowd_write(struct file *file, const char __user *buf,
 150                                                size_t count, loff_t *ppos)
 151{
 152        struct riowd *p = riowd_device;
 153
 154        if (count) {
 155                riowd_writereg(p, riowd_timeout, WDTO_INDEX);
 156                return 1;
 157        }
 158
 159        return 0;
 160}
 161
 162static const struct file_operations riowd_fops = {
 163        .owner =                THIS_MODULE,
 164        .llseek =               no_llseek,
 165        .unlocked_ioctl =       riowd_ioctl,
 166        .open =                 riowd_open,
 167        .write =                riowd_write,
 168        .release =              riowd_release,
 169};
 170
 171static struct miscdevice riowd_miscdev = {
 172        .minor  = WATCHDOG_MINOR,
 173        .name   = "watchdog",
 174        .fops   = &riowd_fops
 175};
 176
 177static int __devinit riowd_probe(struct platform_device *op)
 178{
 179        struct riowd *p;
 180        int err = -EINVAL;
 181
 182        if (riowd_device)
 183                goto out;
 184
 185        err = -ENOMEM;
 186        p = kzalloc(sizeof(*p), GFP_KERNEL);
 187        if (!p)
 188                goto out;
 189
 190        spin_lock_init(&p->lock);
 191
 192        p->regs = of_ioremap(&op->resource[0], 0, 2, DRIVER_NAME);
 193        if (!p->regs) {
 194                pr_err("Cannot map registers\n");
 195                goto out_free;
 196        }
 197        /* Make miscdev useable right away */
 198        riowd_device = p;
 199
 200        err = misc_register(&riowd_miscdev);
 201        if (err) {
 202                pr_err("Cannot register watchdog misc device\n");
 203                goto out_iounmap;
 204        }
 205
 206        pr_info("Hardware watchdog [%i minutes], regs at %p\n",
 207                riowd_timeout, p->regs);
 208
 209        dev_set_drvdata(&op->dev, p);
 210        return 0;
 211
 212out_iounmap:
 213        riowd_device = NULL;
 214        of_iounmap(&op->resource[0], p->regs, 2);
 215
 216out_free:
 217        kfree(p);
 218
 219out:
 220        return err;
 221}
 222
 223static int __devexit riowd_remove(struct platform_device *op)
 224{
 225        struct riowd *p = dev_get_drvdata(&op->dev);
 226
 227        misc_deregister(&riowd_miscdev);
 228        of_iounmap(&op->resource[0], p->regs, 2);
 229        kfree(p);
 230
 231        return 0;
 232}
 233
 234static const struct of_device_id riowd_match[] = {
 235        {
 236                .name = "pmc",
 237        },
 238        {},
 239};
 240MODULE_DEVICE_TABLE(of, riowd_match);
 241
 242static struct platform_driver riowd_driver = {
 243        .driver = {
 244                .name = DRIVER_NAME,
 245                .owner = THIS_MODULE,
 246                .of_match_table = riowd_match,
 247        },
 248        .probe          = riowd_probe,
 249        .remove         = __devexit_p(riowd_remove),
 250};
 251
 252module_platform_driver(riowd_driver);
 253
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.