mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
-----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIVAwUAT3NKzROxKuMESys7AQKElw/+JyDxJSlj+g+nymkx8IVVuU8CsEwNLgRk 8KEnRfLhGtkXFLSJYWO6jzGo16F8Uqli1PdMFte/wagSv0285/HZaKlkkBVHdJ/m u40oSjgT013bBh6MQ0Oaf8pFezFUiQB5zPOA9QGaLVGDLXCmgqUgd7exaD5wRIwB ZmyItjZeAVnDfk1R+ZiNYytHAi8A5wSB+eFDCIQYgyulA1Igd1UnRtx+dRKbvc/m rWQ6KWbZHIdvP1ksd8wHHkrlUD2pEeJ8glJLsZUhMm/5oMf/8RmOCvmo8rvE/qwl eDQ1h4cGYlfjobxXZMHqAN9m7Jg2bI946HZjdb7/7oCeO6VW3FwPZ/Ic75p+wp45 HXJTItufERYk6QxShiOKvA+QexnYwY0IT5oRP4DrhdVB/X9cl2MoaZHC+RbYLQy+ /5VNZKi38iK4F9AbFamS7kd0i5QszA/ZzEzKZ6VMuOp3W/fagpn4ZJT1LIA3m4A9 Q0cj24mqeyCfjysu0TMbPtaN+Yjeu1o1OFRvM8XffbZsp5bNzuTDEvviJ2NXw4vK 4qUHulhYSEWcu9YgAZXvEWDEM78FXCkg2v/CrZXH5tyc95kUkMPcgG+QZBB5wElR FaOKpiC/BuNIGEf02IZQ4nfDxE90QwnDeoYeV+FvNj9UEOopJ5z5bMPoTHxm4cCD NypQthI85pc= =G9mT -----END PGP SIGNATURE----- Merge tag 'split-asm_system_h-for-linus-20120328' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-asm_system Pull "Disintegrate and delete asm/system.h" from David Howells: "Here are a bunch of patches to disintegrate asm/system.h into a set of separate bits to relieve the problem of circular inclusion dependencies. I've built all the working defconfigs from all the arches that I can and made sure that they don't break. The reason for these patches is that I recently encountered a circular dependency problem that came about when I produced some patches to optimise get_order() by rewriting it to use ilog2(). This uses bitops - and on the SH arch asm/bitops.h drags in asm-generic/get_order.h by a circuituous route involving asm/system.h. The main difficulty seems to be asm/system.h. It holds a number of low level bits with no/few dependencies that are commonly used (eg. memory barriers) and a number of bits with more dependencies that aren't used in many places (eg. switch_to()). These patches break asm/system.h up into the following core pieces: (1) asm/barrier.h Move memory barriers here. This already done for MIPS and Alpha. (2) asm/switch_to.h Move switch_to() and related stuff here. (3) asm/exec.h Move arch_align_stack() here. Other process execution related bits could perhaps go here from asm/processor.h. (4) asm/cmpxchg.h Move xchg() and cmpxchg() here as they're full word atomic ops and frequently used by atomic_xchg() and atomic_cmpxchg(). (5) asm/bug.h Move die() and related bits. (6) asm/auxvec.h Move AT_VECTOR_SIZE_ARCH here. Other arch headers are created as needed on a per-arch basis." Fixed up some conflicts from other header file cleanups and moving code around that has happened in the meantime, so David's testing is somewhat weakened by that. We'll find out anything that got broken and fix it.. * tag 'split-asm_system_h-for-linus-20120328' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-asm_system: (38 commits) Delete all instances of asm/system.h Remove all #inclusions of asm/system.h Add #includes needed to permit the removal of asm/system.h Move all declarations of free_initmem() to linux/mm.h Disintegrate asm/system.h for OpenRISC Split arch_align_stack() out from asm-generic/system.h Split the switch_to() wrapper out of asm-generic/system.h Move the asm-generic/system.h xchg() implementation to asm-generic/cmpxchg.h Create asm-generic/barrier.h Make asm-generic/cmpxchg.h #include asm-generic/cmpxchg-local.h Disintegrate asm/system.h for Xtensa Disintegrate asm/system.h for Unicore32 [based on ver #3, changed by gxt] Disintegrate asm/system.h for Tile Disintegrate asm/system.h for Sparc Disintegrate asm/system.h for SH Disintegrate asm/system.h for Score Disintegrate asm/system.h for S390 Disintegrate asm/system.h for PowerPC Disintegrate asm/system.h for PA-RISC Disintegrate asm/system.h for MN10300 ...
457 lines
9.9 KiB
C
457 lines
9.9 KiB
C
/*
|
|
* MachZ ZF-Logic Watchdog Timer driver for Linux
|
|
*
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*
|
|
* The author does NOT admit liability nor provide warranty for
|
|
* any of this software. This material is provided "AS-IS" in
|
|
* the hope that it may be useful for others.
|
|
*
|
|
* Author: Fernando Fuganti <fuganti@conectiva.com.br>
|
|
*
|
|
* Based on sbc60xxwdt.c by Jakob Oestergaard
|
|
*
|
|
*
|
|
* We have two timers (wd#1, wd#2) driven by a 32 KHz clock with the
|
|
* following periods:
|
|
* wd#1 - 2 seconds;
|
|
* wd#2 - 7.2 ms;
|
|
* After the expiration of wd#1, it can generate a NMI, SCI, SMI, or
|
|
* a system RESET and it starts wd#2 that unconditionally will RESET
|
|
* the system when the counter reaches zero.
|
|
*
|
|
* 14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com>
|
|
* Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT
|
|
*/
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/types.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/miscdevice.h>
|
|
#include <linux/watchdog.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/notifier.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/init.h>
|
|
#include <linux/io.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
|
|
/* ports */
|
|
#define ZF_IOBASE 0x218
|
|
#define INDEX 0x218
|
|
#define DATA_B 0x219
|
|
#define DATA_W 0x21A
|
|
#define DATA_D 0x21A
|
|
|
|
/* indexes */ /* size */
|
|
#define ZFL_VERSION 0x02 /* 16 */
|
|
#define CONTROL 0x10 /* 16 */
|
|
#define STATUS 0x12 /* 8 */
|
|
#define COUNTER_1 0x0C /* 16 */
|
|
#define COUNTER_2 0x0E /* 8 */
|
|
#define PULSE_LEN 0x0F /* 8 */
|
|
|
|
/* controls */
|
|
#define ENABLE_WD1 0x0001
|
|
#define ENABLE_WD2 0x0002
|
|
#define RESET_WD1 0x0010
|
|
#define RESET_WD2 0x0020
|
|
#define GEN_SCI 0x0100
|
|
#define GEN_NMI 0x0200
|
|
#define GEN_SMI 0x0400
|
|
#define GEN_RESET 0x0800
|
|
|
|
|
|
/* utilities */
|
|
|
|
#define WD1 0
|
|
#define WD2 1
|
|
|
|
#define zf_writew(port, data) { outb(port, INDEX); outw(data, DATA_W); }
|
|
#define zf_writeb(port, data) { outb(port, INDEX); outb(data, DATA_B); }
|
|
#define zf_get_ZFL_version() zf_readw(ZFL_VERSION)
|
|
|
|
|
|
static unsigned short zf_readw(unsigned char port)
|
|
{
|
|
outb(port, INDEX);
|
|
return inw(DATA_W);
|
|
}
|
|
|
|
|
|
MODULE_AUTHOR("Fernando Fuganti <fuganti@conectiva.com.br>");
|
|
MODULE_DESCRIPTION("MachZ ZF-Logic Watchdog driver");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
|
|
|
|
static bool nowayout = WATCHDOG_NOWAYOUT;
|
|
module_param(nowayout, bool, 0);
|
|
MODULE_PARM_DESC(nowayout,
|
|
"Watchdog cannot be stopped once started (default="
|
|
__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
|
|
|
|
#define PFX "machzwd"
|
|
|
|
static const struct watchdog_info zf_info = {
|
|
.options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
|
|
.firmware_version = 1,
|
|
.identity = "ZF-Logic watchdog",
|
|
};
|
|
|
|
|
|
/*
|
|
* action refers to action taken when watchdog resets
|
|
* 0 = GEN_RESET
|
|
* 1 = GEN_SMI
|
|
* 2 = GEN_NMI
|
|
* 3 = GEN_SCI
|
|
* defaults to GEN_RESET (0)
|
|
*/
|
|
static int action;
|
|
module_param(action, int, 0);
|
|
MODULE_PARM_DESC(action, "after watchdog resets, generate: "
|
|
"0 = RESET(*) 1 = SMI 2 = NMI 3 = SCI");
|
|
|
|
static void zf_ping(unsigned long data);
|
|
|
|
static int zf_action = GEN_RESET;
|
|
static unsigned long zf_is_open;
|
|
static char zf_expect_close;
|
|
static DEFINE_SPINLOCK(zf_port_lock);
|
|
static DEFINE_TIMER(zf_timer, zf_ping, 0, 0);
|
|
static unsigned long next_heartbeat;
|
|
|
|
|
|
/* timeout for user land heart beat (10 seconds) */
|
|
#define ZF_USER_TIMEO (HZ*10)
|
|
|
|
/* timeout for hardware watchdog (~500ms) */
|
|
#define ZF_HW_TIMEO (HZ/2)
|
|
|
|
/* number of ticks on WD#1 (driven by a 32KHz clock, 2s) */
|
|
#define ZF_CTIMEOUT 0xffff
|
|
|
|
#ifndef ZF_DEBUG
|
|
#define dprintk(format, args...)
|
|
#else
|
|
#define dprintk(format, args...) \
|
|
pr_debug(":%s:%d: " format, __func__, __LINE__ , ## args)
|
|
#endif
|
|
|
|
|
|
static inline void zf_set_status(unsigned char new)
|
|
{
|
|
zf_writeb(STATUS, new);
|
|
}
|
|
|
|
|
|
/* CONTROL register functions */
|
|
|
|
static inline unsigned short zf_get_control(void)
|
|
{
|
|
return zf_readw(CONTROL);
|
|
}
|
|
|
|
static inline void zf_set_control(unsigned short new)
|
|
{
|
|
zf_writew(CONTROL, new);
|
|
}
|
|
|
|
|
|
/* WD#? counter functions */
|
|
/*
|
|
* Just set counter value
|
|
*/
|
|
|
|
static inline void zf_set_timer(unsigned short new, unsigned char n)
|
|
{
|
|
switch (n) {
|
|
case WD1:
|
|
zf_writew(COUNTER_1, new);
|
|
case WD2:
|
|
zf_writeb(COUNTER_2, new > 0xff ? 0xff : new);
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* stop hardware timer
|
|
*/
|
|
static void zf_timer_off(void)
|
|
{
|
|
unsigned int ctrl_reg = 0;
|
|
unsigned long flags;
|
|
|
|
/* stop internal ping */
|
|
del_timer_sync(&zf_timer);
|
|
|
|
spin_lock_irqsave(&zf_port_lock, flags);
|
|
/* stop watchdog timer */
|
|
ctrl_reg = zf_get_control();
|
|
ctrl_reg |= (ENABLE_WD1|ENABLE_WD2); /* disable wd1 and wd2 */
|
|
ctrl_reg &= ~(ENABLE_WD1|ENABLE_WD2);
|
|
zf_set_control(ctrl_reg);
|
|
spin_unlock_irqrestore(&zf_port_lock, flags);
|
|
|
|
pr_info("Watchdog timer is now disabled\n");
|
|
}
|
|
|
|
|
|
/*
|
|
* start hardware timer
|
|
*/
|
|
static void zf_timer_on(void)
|
|
{
|
|
unsigned int ctrl_reg = 0;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&zf_port_lock, flags);
|
|
|
|
zf_writeb(PULSE_LEN, 0xff);
|
|
|
|
zf_set_timer(ZF_CTIMEOUT, WD1);
|
|
|
|
/* user land ping */
|
|
next_heartbeat = jiffies + ZF_USER_TIMEO;
|
|
|
|
/* start the timer for internal ping */
|
|
mod_timer(&zf_timer, jiffies + ZF_HW_TIMEO);
|
|
|
|
/* start watchdog timer */
|
|
ctrl_reg = zf_get_control();
|
|
ctrl_reg |= (ENABLE_WD1|zf_action);
|
|
zf_set_control(ctrl_reg);
|
|
spin_unlock_irqrestore(&zf_port_lock, flags);
|
|
|
|
pr_info("Watchdog timer is now enabled\n");
|
|
}
|
|
|
|
|
|
static void zf_ping(unsigned long data)
|
|
{
|
|
unsigned int ctrl_reg = 0;
|
|
unsigned long flags;
|
|
|
|
zf_writeb(COUNTER_2, 0xff);
|
|
|
|
if (time_before(jiffies, next_heartbeat)) {
|
|
dprintk("time_before: %ld\n", next_heartbeat - jiffies);
|
|
/*
|
|
* reset event is activated by transition from 0 to 1 on
|
|
* RESET_WD1 bit and we assume that it is already zero...
|
|
*/
|
|
|
|
spin_lock_irqsave(&zf_port_lock, flags);
|
|
ctrl_reg = zf_get_control();
|
|
ctrl_reg |= RESET_WD1;
|
|
zf_set_control(ctrl_reg);
|
|
|
|
/* ...and nothing changes until here */
|
|
ctrl_reg &= ~(RESET_WD1);
|
|
zf_set_control(ctrl_reg);
|
|
spin_unlock_irqrestore(&zf_port_lock, flags);
|
|
|
|
mod_timer(&zf_timer, jiffies + ZF_HW_TIMEO);
|
|
} else
|
|
pr_crit("I will reset your machine\n");
|
|
}
|
|
|
|
static ssize_t zf_write(struct file *file, const char __user *buf, size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
/* See if we got the magic character */
|
|
if (count) {
|
|
/*
|
|
* no need to check for close confirmation
|
|
* no way to disable watchdog ;)
|
|
*/
|
|
if (!nowayout) {
|
|
size_t ofs;
|
|
/*
|
|
* note: just in case someone wrote the magic character
|
|
* five months ago...
|
|
*/
|
|
zf_expect_close = 0;
|
|
|
|
/* now scan */
|
|
for (ofs = 0; ofs != count; ofs++) {
|
|
char c;
|
|
if (get_user(c, buf + ofs))
|
|
return -EFAULT;
|
|
if (c == 'V') {
|
|
zf_expect_close = 42;
|
|
dprintk("zf_expect_close = 42\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Well, anyhow someone wrote to us,
|
|
* we should return that favour
|
|
*/
|
|
next_heartbeat = jiffies + ZF_USER_TIMEO;
|
|
dprintk("user ping at %ld\n", jiffies);
|
|
}
|
|
return count;
|
|
}
|
|
|
|
static long zf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
void __user *argp = (void __user *)arg;
|
|
int __user *p = argp;
|
|
switch (cmd) {
|
|
case WDIOC_GETSUPPORT:
|
|
if (copy_to_user(argp, &zf_info, sizeof(zf_info)))
|
|
return -EFAULT;
|
|
break;
|
|
case WDIOC_GETSTATUS:
|
|
case WDIOC_GETBOOTSTATUS:
|
|
return put_user(0, p);
|
|
case WDIOC_KEEPALIVE:
|
|
zf_ping(0);
|
|
break;
|
|
default:
|
|
return -ENOTTY;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int zf_open(struct inode *inode, struct file *file)
|
|
{
|
|
if (test_and_set_bit(0, &zf_is_open))
|
|
return -EBUSY;
|
|
if (nowayout)
|
|
__module_get(THIS_MODULE);
|
|
zf_timer_on();
|
|
return nonseekable_open(inode, file);
|
|
}
|
|
|
|
static int zf_close(struct inode *inode, struct file *file)
|
|
{
|
|
if (zf_expect_close == 42)
|
|
zf_timer_off();
|
|
else {
|
|
del_timer(&zf_timer);
|
|
pr_err("device file closed unexpectedly. Will not stop the WDT!\n");
|
|
}
|
|
clear_bit(0, &zf_is_open);
|
|
zf_expect_close = 0;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Notifier for system down
|
|
*/
|
|
|
|
static int zf_notify_sys(struct notifier_block *this, unsigned long code,
|
|
void *unused)
|
|
{
|
|
if (code == SYS_DOWN || code == SYS_HALT)
|
|
zf_timer_off();
|
|
return NOTIFY_DONE;
|
|
}
|
|
|
|
static const struct file_operations zf_fops = {
|
|
.owner = THIS_MODULE,
|
|
.llseek = no_llseek,
|
|
.write = zf_write,
|
|
.unlocked_ioctl = zf_ioctl,
|
|
.open = zf_open,
|
|
.release = zf_close,
|
|
};
|
|
|
|
static struct miscdevice zf_miscdev = {
|
|
.minor = WATCHDOG_MINOR,
|
|
.name = "watchdog",
|
|
.fops = &zf_fops,
|
|
};
|
|
|
|
|
|
/*
|
|
* The device needs to learn about soft shutdowns in order to
|
|
* turn the timebomb registers off.
|
|
*/
|
|
static struct notifier_block zf_notifier = {
|
|
.notifier_call = zf_notify_sys,
|
|
};
|
|
|
|
static void __init zf_show_action(int act)
|
|
{
|
|
static const char * const str[] = { "RESET", "SMI", "NMI", "SCI" };
|
|
|
|
pr_info("Watchdog using action = %s\n", str[act]);
|
|
}
|
|
|
|
static int __init zf_init(void)
|
|
{
|
|
int ret;
|
|
|
|
pr_info("MachZ ZF-Logic Watchdog driver initializing\n");
|
|
|
|
ret = zf_get_ZFL_version();
|
|
if (!ret || ret == 0xffff) {
|
|
pr_warn("no ZF-Logic found\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (action <= 3 && action >= 0)
|
|
zf_action = zf_action >> action;
|
|
else
|
|
action = 0;
|
|
|
|
zf_show_action(action);
|
|
|
|
if (!request_region(ZF_IOBASE, 3, "MachZ ZFL WDT")) {
|
|
pr_err("cannot reserve I/O ports at %d\n", ZF_IOBASE);
|
|
ret = -EBUSY;
|
|
goto no_region;
|
|
}
|
|
|
|
ret = register_reboot_notifier(&zf_notifier);
|
|
if (ret) {
|
|
pr_err("can't register reboot notifier (err=%d)\n", ret);
|
|
goto no_reboot;
|
|
}
|
|
|
|
ret = misc_register(&zf_miscdev);
|
|
if (ret) {
|
|
pr_err("can't misc_register on minor=%d\n", WATCHDOG_MINOR);
|
|
goto no_misc;
|
|
}
|
|
|
|
zf_set_status(0);
|
|
zf_set_control(0);
|
|
|
|
return 0;
|
|
|
|
no_misc:
|
|
unregister_reboot_notifier(&zf_notifier);
|
|
no_reboot:
|
|
release_region(ZF_IOBASE, 3);
|
|
no_region:
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void __exit zf_exit(void)
|
|
{
|
|
zf_timer_off();
|
|
|
|
misc_deregister(&zf_miscdev);
|
|
unregister_reboot_notifier(&zf_notifier);
|
|
release_region(ZF_IOBASE, 3);
|
|
}
|
|
|
|
module_init(zf_init);
|
|
module_exit(zf_exit);
|