forked from Minki/linux
00977a59b9
Many struct file_operations in the kernel can be "const". Marking them const moves these to the .rodata section, which avoids false sharing with potential dirty data. In addition it'll catch accidental writes at compile time to these shared resources. Signed-off-by: Arjan van de Ven <arjan@linux.intel.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
294 lines
6.4 KiB
C
294 lines
6.4 KiB
C
/* $Id: riowatchdog.c,v 1.3.2.2 2002/01/23 18:48:02 davem Exp $
|
|
* riowatchdog.c - driver for hw watchdog inside Super I/O of RIO
|
|
*
|
|
* Copyright (C) 2001 David S. Miller (davem@redhat.com)
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/init.h>
|
|
#include <linux/miscdevice.h>
|
|
|
|
#include <asm/io.h>
|
|
#include <asm/ebus.h>
|
|
#include <asm/bbc.h>
|
|
#include <asm/oplib.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/watchdog.h>
|
|
|
|
/* RIO uses the NatSemi Super I/O power management logical device
|
|
* as its' watchdog.
|
|
*
|
|
* When the watchdog triggers, it asserts a line to the BBC (Boot Bus
|
|
* Controller) of the machine. The BBC can only be configured to
|
|
* trigger a power-on reset when the signal is asserted. The BBC
|
|
* can be configured to ignore the signal entirely as well.
|
|
*
|
|
* The only Super I/O device register we care about is at index
|
|
* 0x05 (WDTO_INDEX) which is the watchdog time-out in minutes (1-255).
|
|
* If set to zero, this disables the watchdog. When set, the system
|
|
* must periodically (before watchdog expires) clear (set to zero) and
|
|
* re-set the watchdog else it will trigger.
|
|
*
|
|
* There are two other indexed watchdog registers inside this Super I/O
|
|
* logical device, but they are unused. The first, at index 0x06 is
|
|
* the watchdog control and can be used to make the watchdog timer re-set
|
|
* when the PS/2 mouse or serial lines show activity. The second, at
|
|
* index 0x07 is merely a sampling of the line from the watchdog to the
|
|
* BBC.
|
|
*
|
|
* The watchdog device generates no interrupts.
|
|
*/
|
|
|
|
MODULE_AUTHOR("David S. Miller <davem@redhat.com>");
|
|
MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
|
|
MODULE_SUPPORTED_DEVICE("watchdog");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
#define RIOWD_NAME "pmc"
|
|
#define RIOWD_MINOR 215
|
|
|
|
static DEFINE_SPINLOCK(riowd_lock);
|
|
|
|
static void __iomem *bbc_regs;
|
|
static void __iomem *riowd_regs;
|
|
#define WDTO_INDEX 0x05
|
|
|
|
static int riowd_timeout = 1; /* in minutes */
|
|
module_param(riowd_timeout, int, 0);
|
|
MODULE_PARM_DESC(riowd_timeout, "Watchdog timeout in minutes");
|
|
|
|
#if 0 /* Currently unused. */
|
|
static u8 riowd_readreg(int index)
|
|
{
|
|
unsigned long flags;
|
|
u8 ret;
|
|
|
|
spin_lock_irqsave(&riowd_lock, flags);
|
|
writeb(index, riowd_regs + 0);
|
|
ret = readb(riowd_regs + 1);
|
|
spin_unlock_irqrestore(&riowd_lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static void riowd_writereg(u8 val, int index)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&riowd_lock, flags);
|
|
writeb(index, riowd_regs + 0);
|
|
writeb(val, riowd_regs + 1);
|
|
spin_unlock_irqrestore(&riowd_lock, flags);
|
|
}
|
|
|
|
static void riowd_pingtimer(void)
|
|
{
|
|
riowd_writereg(riowd_timeout, WDTO_INDEX);
|
|
}
|
|
|
|
static void riowd_stoptimer(void)
|
|
{
|
|
u8 val;
|
|
|
|
riowd_writereg(0, WDTO_INDEX);
|
|
|
|
val = readb(bbc_regs + BBC_WDACTION);
|
|
val &= ~BBC_WDACTION_RST;
|
|
writeb(val, bbc_regs + BBC_WDACTION);
|
|
}
|
|
|
|
static void riowd_starttimer(void)
|
|
{
|
|
u8 val;
|
|
|
|
riowd_writereg(riowd_timeout, WDTO_INDEX);
|
|
|
|
val = readb(bbc_regs + BBC_WDACTION);
|
|
val |= BBC_WDACTION_RST;
|
|
writeb(val, bbc_regs + BBC_WDACTION);
|
|
}
|
|
|
|
static int riowd_open(struct inode *inode, struct file *filp)
|
|
{
|
|
nonseekable_open(inode, filp);
|
|
return 0;
|
|
}
|
|
|
|
static int riowd_release(struct inode *inode, struct file *filp)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int riowd_ioctl(struct inode *inode, struct file *filp,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
static struct watchdog_info info = {
|
|
WDIOF_SETTIMEOUT, 0, "Natl. Semiconductor PC97317"
|
|
};
|
|
void __user *argp = (void __user *)arg;
|
|
unsigned int options;
|
|
int new_margin;
|
|
|
|
switch (cmd) {
|
|
case WDIOC_GETSUPPORT:
|
|
if (copy_to_user(argp, &info, sizeof(info)))
|
|
return -EFAULT;
|
|
break;
|
|
|
|
case WDIOC_GETSTATUS:
|
|
case WDIOC_GETBOOTSTATUS:
|
|
if (put_user(0, (int __user *)argp))
|
|
return -EFAULT;
|
|
break;
|
|
|
|
case WDIOC_KEEPALIVE:
|
|
riowd_pingtimer();
|
|
break;
|
|
|
|
case WDIOC_SETOPTIONS:
|
|
if (copy_from_user(&options, argp, sizeof(options)))
|
|
return -EFAULT;
|
|
|
|
if (options & WDIOS_DISABLECARD)
|
|
riowd_stoptimer();
|
|
else if (options & WDIOS_ENABLECARD)
|
|
riowd_starttimer();
|
|
else
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
case WDIOC_SETTIMEOUT:
|
|
if (get_user(new_margin, (int __user *)argp))
|
|
return -EFAULT;
|
|
if ((new_margin < 60) || (new_margin > (255 * 60)))
|
|
return -EINVAL;
|
|
riowd_timeout = (new_margin + 59) / 60;
|
|
riowd_pingtimer();
|
|
/* Fall */
|
|
|
|
case WDIOC_GETTIMEOUT:
|
|
return put_user(riowd_timeout * 60, (int __user *)argp);
|
|
|
|
default:
|
|
return -EINVAL;
|
|
};
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t riowd_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
|
|
{
|
|
if (count) {
|
|
riowd_pingtimer();
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct file_operations riowd_fops = {
|
|
.owner = THIS_MODULE,
|
|
.ioctl = riowd_ioctl,
|
|
.open = riowd_open,
|
|
.write = riowd_write,
|
|
.release = riowd_release,
|
|
};
|
|
|
|
static struct miscdevice riowd_miscdev = { RIOWD_MINOR, RIOWD_NAME, &riowd_fops };
|
|
|
|
static int __init riowd_bbc_init(void)
|
|
{
|
|
struct linux_ebus *ebus = NULL;
|
|
struct linux_ebus_device *edev = NULL;
|
|
u8 val;
|
|
|
|
for_each_ebus(ebus) {
|
|
for_each_ebusdev(edev, ebus) {
|
|
if (!strcmp(edev->ofdev.node->name, "bbc"))
|
|
goto found_bbc;
|
|
}
|
|
}
|
|
|
|
found_bbc:
|
|
if (!edev)
|
|
return -ENODEV;
|
|
bbc_regs = ioremap(edev->resource[0].start, BBC_REGS_SIZE);
|
|
if (!bbc_regs)
|
|
return -ENODEV;
|
|
|
|
/* Turn it off. */
|
|
val = readb(bbc_regs + BBC_WDACTION);
|
|
val &= ~BBC_WDACTION_RST;
|
|
writeb(val, bbc_regs + BBC_WDACTION);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __init riowd_init(void)
|
|
{
|
|
struct linux_ebus *ebus = NULL;
|
|
struct linux_ebus_device *edev = NULL;
|
|
|
|
for_each_ebus(ebus) {
|
|
for_each_ebusdev(edev, ebus) {
|
|
if (!strcmp(edev->ofdev.node->name, RIOWD_NAME))
|
|
goto ebus_done;
|
|
}
|
|
}
|
|
|
|
ebus_done:
|
|
if (!edev)
|
|
goto fail;
|
|
|
|
riowd_regs = ioremap(edev->resource[0].start, 2);
|
|
if (riowd_regs == NULL) {
|
|
printk(KERN_ERR "pmc: Cannot map registers.\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (riowd_bbc_init()) {
|
|
printk(KERN_ERR "pmc: Failure initializing BBC config.\n");
|
|
goto fail;
|
|
}
|
|
|
|
if (misc_register(&riowd_miscdev)) {
|
|
printk(KERN_ERR "pmc: Cannot register watchdog misc device.\n");
|
|
goto fail;
|
|
}
|
|
|
|
printk(KERN_INFO "pmc: Hardware watchdog [%i minutes], "
|
|
"regs at %p\n", riowd_timeout, riowd_regs);
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
if (riowd_regs) {
|
|
iounmap(riowd_regs);
|
|
riowd_regs = NULL;
|
|
}
|
|
if (bbc_regs) {
|
|
iounmap(bbc_regs);
|
|
bbc_regs = NULL;
|
|
}
|
|
return -ENODEV;
|
|
}
|
|
|
|
static void __exit riowd_cleanup(void)
|
|
{
|
|
misc_deregister(&riowd_miscdev);
|
|
iounmap(riowd_regs);
|
|
riowd_regs = NULL;
|
|
iounmap(bbc_regs);
|
|
bbc_regs = NULL;
|
|
}
|
|
|
|
module_init(riowd_init);
|
|
module_exit(riowd_cleanup);
|