/*
- * Industrial Computer Source WDT500/501 driver for Linux 2.1.x
+ * Industrial Computer Source PCI-WDT500/501 driver
*
* (c) Copyright 1996-1997 Alan Cox <alan@redhat.com>, All Rights Reserved.
* http://www.redhat.com
*
* (c) Copyright 1995 Alan Cox <alan@lxorguk.ukuu.org.uk>
*
- * Release 0.09.
+ * Release 0.10.
*
* Fixes
* Dave Gregorich : Modularisation and minor bugs
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/init.h>
+#include <linux/fs.h>
#include <linux/pci.h>
#include <asm/io.h>
#define PCI_DEVICE_ID_WDG_CSM 0x22c0
#endif
+/* We can only use 1 card due to the /dev/watchdog restriction */
+static int dev_count;
+
static struct semaphore open_sem;
static spinlock_t wdtpci_lock;
static char expect_close;
static int irq;
/* Default timeout */
-#define WD_TIMO (100*60) /* 1 minute */
-#define WD_TIMO_MAX (WD_TIMO*60) /* 1 hour(?) */
+#define WD_TIMO 60 /* Default heartbeat = 60 seconds */
-static int wd_margin = WD_TIMO;
+static int heartbeat = WD_TIMO;
+static int wd_heartbeat;
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (0<heartbeat<65536, default=" __MODULE_STRING(WD_TIMO) ")");
#ifdef CONFIG_WATCHDOG_NOWAYOUT
static int nowayout = 1;
module_param(nowayout, int, 0);
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
+#ifdef CONFIG_WDT_501_PCI
+/* Support for the Fan Tachometer on the PCI-WDT501 */
+static int tachometer;
+
+module_param(tachometer, int, 0);
+MODULE_PARM_DESC(tachometer, "PCI-WDT501 Fan Tachometer support (0=disable, default=0)");
+#endif /* CONFIG_WDT_501_PCI */
+
/*
* Programming support
*/
outb_p(val>>8, WDT_COUNT0+ctr);
}
-/*
- * Kernel methods.
+/**
+ * wdtpci_start:
+ *
+ * Start the watchdog driver.
*/
+static int wdtpci_start(void)
+{
+ unsigned long flags;
+
+ spin_lock_irqsave(&wdtpci_lock, flags);
+
+ /*
+ * "pet" the watchdog, as Access says.
+ * This resets the clock outputs.
+ */
+ inb_p(WDT_DC); /* Disable watchdog */
+ wdtpci_ctr_mode(2,0); /* Program CTR2 for Mode 0: Pulse on Terminal Count */
+ outb_p(0, WDT_DC); /* Enable watchdog */
+
+ inb_p(WDT_DC); /* Disable watchdog */
+ outb_p(0, WDT_CLOCK); /* 2.0833MHz clock */
+ inb_p(WDT_BUZZER); /* disable */
+ inb_p(WDT_OPTONOTRST); /* disable */
+ inb_p(WDT_OPTORST); /* disable */
+ inb_p(WDT_PROGOUT); /* disable */
+ wdtpci_ctr_mode(0,3); /* Program CTR0 for Mode 3: Square Wave Generator */
+ wdtpci_ctr_mode(1,2); /* Program CTR1 for Mode 2: Rate Generator */
+ wdtpci_ctr_mode(2,1); /* Program CTR2 for Mode 1: Retriggerable One-Shot */
+ wdtpci_ctr_load(0,20833); /* count at 100Hz */
+ wdtpci_ctr_load(1,wd_heartbeat);/* Heartbeat */
+ /* DO NOT LOAD CTR2 on PCI card! -- JPN */
+ outb_p(0, WDT_DC); /* Enable watchdog */
+
+ spin_unlock_irqrestore(&wdtpci_lock, flags);
+ return 0;
+}
+
+/**
+ * wdtpci_stop:
+ *
+ * Stop the watchdog driver.
+ */
+
+static int wdtpci_stop (void)
+{
+ unsigned long flags;
+
+ /* Turn the card off */
+ spin_lock_irqsave(&wdtpci_lock, flags);
+ inb_p(WDT_DC); /* Disable watchdog */
+ wdtpci_ctr_load(2,0); /* 0 length reset pulses now */
+ spin_unlock_irqrestore(&wdtpci_lock, flags);
+ return 0;
+}
+
+/**
+ * wdtpci_ping:
+ *
+ * Reload counter one with the watchdog heartbeat. We don't bother reloading
+ * the cascade counter.
+ */
+
+static int wdtpci_ping(void)
+{
+ unsigned long flags;
+
+ /* Write a watchdog value */
+ spin_lock_irqsave(&wdtpci_lock, flags);
+ inb_p(WDT_DC); /* Disable watchdog */
+ wdtpci_ctr_mode(1,2); /* Re-Program CTR1 for Mode 2: Rate Generator */
+ wdtpci_ctr_load(1,wd_heartbeat);/* Heartbeat */
+ outb_p(0, WDT_DC); /* Enable watchdog */
+ spin_unlock_irqrestore(&wdtpci_lock, flags);
+ return 0;
+}
+
+/**
+ * wdtpci_set_heartbeat:
+ * @t: the new heartbeat value that needs to be set.
+ *
+ * Set a new heartbeat value for the watchdog device. If the heartbeat value is
+ * incorrect we keep the old value and return -EINVAL. If successfull we
+ * return 0.
+ */
+static int wdtpci_set_heartbeat(int t)
+{
+ /* Arbitrary, can't find the card's limits */
+ if ((t < 1) || (t > 65535))
+ return -EINVAL;
+
+ heartbeat = t;
+ wd_heartbeat = t * 100;
+ return 0;
+}
/**
- * wdtpci_status:
+ * wdtpci_get_status:
+ * @status: the new status.
*
* Extract the status information from a WDT watchdog device. There are
* several board variants so we have to know which bits are valid. Some
* we then map the bits onto the status ioctl flags.
*/
-static int wdtpci_status(void)
+static int wdtpci_get_status(int *status)
{
- /*
- * Status register to bit flags
- */
+ unsigned char new_status=inb_p(WDT_SR);
- int flag=0;
- unsigned char status=inb_p(WDT_SR);
- status|=FEATUREMAP1;
- status&=~FEATUREMAP2;
-
- if(!(status&WDC_SR_TGOOD))
- flag|=WDIOF_OVERHEAT;
- if(!(status&WDC_SR_PSUOVER))
- flag|=WDIOF_POWEROVER;
- if(!(status&WDC_SR_PSUUNDR))
- flag|=WDIOF_POWERUNDER;
- if(!(status&WDC_SR_FANGOOD))
- flag|=WDIOF_FANFAULT;
- if(status&WDC_SR_ISOI0)
- flag|=WDIOF_EXTERN1;
- if(status&WDC_SR_ISII1)
- flag|=WDIOF_EXTERN2;
- return flag;
+ *status=0;
+ if (new_status & WDC_SR_ISOI0)
+ *status |= WDIOF_EXTERN1;
+ if (new_status & WDC_SR_ISII1)
+ *status |= WDIOF_EXTERN2;
+#ifdef CONFIG_WDT_501_PCI
+ if (!(new_status & WDC_SR_TGOOD))
+ *status |= WDIOF_OVERHEAT;
+ if (!(new_status & WDC_SR_PSUOVER))
+ *status |= WDIOF_POWEROVER;
+ if (!(new_status & WDC_SR_PSUUNDR))
+ *status |= WDIOF_POWERUNDER;
+ if (tachometer) {
+ if (!(new_status & WDC_SR_FANGOOD))
+ *status |= WDIOF_FANFAULT;
+ }
+#endif /* CONFIG_WDT_501_PCI */
+ return 0;
}
+#ifdef CONFIG_WDT_501_PCI
+/**
+ * wdtpci_get_temperature:
+ *
+ * Reports the temperature in degrees Fahrenheit. The API is in
+ * farenheit. It was designed by an imperial measurement luddite.
+ */
+
+static int wdtpci_get_temperature(int *temperature)
+{
+ unsigned short c=inb_p(WDT_RT);
+
+ *temperature = (c * 11 / 15) + 7;
+ return 0;
+}
+#endif /* CONFIG_WDT_501_PCI */
+
/**
* wdtpci_interrupt:
* @irq: Interrupt number
* Read the status register see what is up and
* then printk it.
*/
-
unsigned char status=inb_p(WDT_SR);
- status|=FEATUREMAP1;
- status&=~FEATUREMAP2;
+ printk(KERN_CRIT PFX "status %d\n", status);
- printk(KERN_CRIT "WDT status %d\n", status);
-
- if(!(status&WDC_SR_TGOOD))
- printk(KERN_CRIT "Overheat alarm.(%d)\n",inb_p(WDT_RT));
- if(!(status&WDC_SR_PSUOVER))
- printk(KERN_CRIT "PSU over voltage.\n");
- if(!(status&WDC_SR_PSUUNDR))
- printk(KERN_CRIT "PSU under voltage.\n");
- if(!(status&WDC_SR_FANGOOD))
- printk(KERN_CRIT "Possible fan fault.\n");
- if(!(status&WDC_SR_WCCR))
+#ifdef CONFIG_WDT_501_PCI
+ if (!(status & WDC_SR_TGOOD))
+ printk(KERN_CRIT PFX "Overheat alarm.(%d)\n",inb_p(WDT_RT));
+ if (!(status & WDC_SR_PSUOVER))
+ printk(KERN_CRIT PFX "PSU over voltage.\n");
+ if (!(status & WDC_SR_PSUUNDR))
+ printk(KERN_CRIT PFX "PSU under voltage.\n");
+ if (tachometer) {
+ if (!(status & WDC_SR_FANGOOD))
+ printk(KERN_CRIT PFX "Possible fan fault.\n");
+ }
+#endif /* CONFIG_WDT_501_PCI */
+ if (!(status&WDC_SR_WCCR))
#ifdef SOFTWARE_REBOOT
#ifdef ONLY_TESTING
- printk(KERN_CRIT "Would Reboot.\n");
+ printk(KERN_CRIT PFX "Would Reboot.\n");
#else
- printk(KERN_CRIT "Initiating system reboot.\n");
+ printk(KERN_CRIT PFX "Initiating system reboot.\n");
machine_restart(NULL);
#endif
#else
- printk(KERN_CRIT "Reset in 5ms.\n");
+ printk(KERN_CRIT PFX "Reset in 5ms.\n");
#endif
return IRQ_HANDLED;
}
-/**
- * wdtpci_ping:
- *
- * Reload counter one with the watchdog timeout. We don't bother reloading
- * the cascade counter.
- */
-
-static void wdtpci_ping(void)
-{
- unsigned long flags;
-
- /* Write a watchdog value */
- spin_lock_irqsave(&wdtpci_lock, flags);
- inb_p(WDT_DC);
- wdtpci_ctr_mode(1,2);
- wdtpci_ctr_load(1,wd_margin); /* Timeout */
- outb_p(0, WDT_DC);
- spin_unlock_irqrestore(&wdtpci_lock, flags);
-}
-
/**
* wdtpci_write:
* @file: file handle to the watchdog
return count;
}
-/**
- * wdtpci_read:
- * @file: file handle to the watchdog board
- * @buf: buffer to write 1 byte into
- * @count: length of buffer
- * @ptr: offset (no seek allowed)
- *
- * Read reports the temperature in degrees Fahrenheit. The API is in
- * fahrenheit. It was designed by an imperial measurement luddite.
- */
-
-static ssize_t wdtpci_read(struct file *file, char *buf, size_t count, loff_t *ptr)
-{
- unsigned short c=inb_p(WDT_RT);
- unsigned char cp;
-
- /* Can't seek (pread) on this device */
- if (ptr != &file->f_pos)
- return -ESPIPE;
-
- switch(iminor(file->f_dentry->d_inode))
- {
- case TEMP_MINOR:
- c*=11;
- c/=15;
- cp=c+7;
- if(copy_to_user(buf,&cp,1))
- return -EFAULT;
- return 1;
- default:
- return -EINVAL;
- }
-}
-
/**
* wdtpci_ioctl:
* @inode: inode of the device
static int wdtpci_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
- int new_margin;
+ int new_heartbeat;
+ int status;
+
static struct watchdog_info ident = {
- .options = WDIOF_OVERHEAT | WDIOF_POWERUNDER |
- WDIOF_POWEROVER | WDIOF_EXTERN1 |
- WDIOF_EXTERN2 | WDIOF_FANFAULT |
- WDIOF_SETTIMEOUT|WDIOF_MAGICCLOSE,
- .firmware_version = 1,
- .identity = "WDT500/501PCI",
+ .options = WDIOF_SETTIMEOUT|
+ WDIOF_MAGICCLOSE|
+ WDIOF_KEEPALIVEPING,
+ .firmware_version = 1,
+ .identity = "PCI-WDT500/501",
};
- ident.options&=WDT_OPTION_MASK; /* Mask down to the card we have */
+ /* Add options according to the card we have */
+ ident.options |= (WDIOF_EXTERN1|WDIOF_EXTERN2);
+#ifdef CONFIG_WDT_501_PCI
+ ident.options |= (WDIOF_OVERHEAT|WDIOF_POWERUNDER|WDIOF_POWEROVER);
+ if (tachometer)
+ ident.options |= WDIOF_FANFAULT;
+#endif /* CONFIG_WDT_501_PCI */
+
switch(cmd)
{
default:
return copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident))?-EFAULT:0;
case WDIOC_GETSTATUS:
- return put_user(wdtpci_status(),(int *)arg);
+ wdtpci_get_status(&status);
+ return put_user(status,(int *)arg);
case WDIOC_GETBOOTSTATUS:
return put_user(0, (int *)arg);
case WDIOC_KEEPALIVE:
wdtpci_ping();
return 0;
case WDIOC_SETTIMEOUT:
- if (get_user(new_margin, (int *)arg))
+ if (get_user(new_heartbeat, (int *)arg))
return -EFAULT;
- /* Arbitrary, can't find the card's limits */
- new_margin *= 100;
- if ((new_margin < 0) || (new_margin > WD_TIMO_MAX))
+
+ if (wdtpci_set_heartbeat(new_heartbeat))
return -EINVAL;
- wd_margin = new_margin;
+
wdtpci_ping();
/* Fall */
case WDIOC_GETTIMEOUT:
- return put_user(wd_margin / 100, (int *)arg);
+ return put_user(heartbeat, (int *)arg);
}
}
* @inode: inode of device
* @file: file handle to device
*
- * One of our two misc devices has been opened. The watchdog device is
- * single open and on opening we load the counters. Counter zero is a
- * 100Hz cascade, into counter 1 which downcounts to reboot. When the
- * counter triggers counter 2 downcounts the length of the reset pulse
- * which set set to be as long as possible.
+ * The watchdog device has been opened. The watchdog device is single
+ * open and on opening we load the counters. Counter zero is a 100Hz
+ * cascade, into counter 1 which downcounts to reboot. When the counter
+ * triggers counter 2 downcounts the length of the reset pulse which
+ * set set to be as long as possible.
*/
static int wdtpci_open(struct inode *inode, struct file *file)
{
- unsigned long flags;
+ if (down_trylock(&open_sem))
+ return -EBUSY;
- switch(iminor(inode))
- {
- case WATCHDOG_MINOR:
- if (down_trylock(&open_sem))
- return -EBUSY;
-
- if (nowayout) {
- __module_get(THIS_MODULE);
- }
- /*
- * Activate
- */
- spin_lock_irqsave(&wdtpci_lock, flags);
-
- inb_p(WDT_DC); /* Disable */
-
- /*
- * "pet" the watchdog, as Access says.
- * This resets the clock outputs.
- */
-
- wdtpci_ctr_mode(2,0);
- outb_p(0, WDT_DC);
-
- inb_p(WDT_DC);
-
- outb_p(0, WDT_CLOCK); /* 2.0833MHz clock */
- inb_p(WDT_BUZZER); /* disable */
- inb_p(WDT_OPTONOTRST); /* disable */
- inb_p(WDT_OPTORST); /* disable */
- inb_p(WDT_PROGOUT); /* disable */
- wdtpci_ctr_mode(0,3);
- wdtpci_ctr_mode(1,2);
- wdtpci_ctr_mode(2,1);
- wdtpci_ctr_load(0,20833); /* count at 100Hz */
- wdtpci_ctr_load(1,wd_margin);/* Timeout 60 seconds */
- /* DO NOT LOAD CTR2 on PCI card! -- JPN */
- outb_p(0, WDT_DC); /* Enable */
- spin_unlock_irqrestore(&wdtpci_lock, flags);
- return 0;
- case TEMP_MINOR:
- return 0;
- default:
- return -ENODEV;
+ if (nowayout) {
+ __module_get(THIS_MODULE);
}
+ /*
+ * Activate
+ */
+ wdtpci_start();
+ return 0;
}
/**
- * wdtpci_close:
+ * wdtpci_release:
* @inode: inode to board
* @file: file handle to board
*
static int wdtpci_release(struct inode *inode, struct file *file)
{
-
- if (iminor(inode)==WATCHDOG_MINOR) {
- unsigned long flags;
- if (expect_close == 42) {
- spin_lock_irqsave(&wdtpci_lock, flags);
- inb_p(WDT_DC); /* Disable counters */
- wdtpci_ctr_load(2,0); /* 0 length reset pulses now */
- spin_unlock_irqrestore(&wdtpci_lock, flags);
- } else {
- printk(KERN_CRIT PFX "Unexpected close, not stopping timer!");
- wdtpci_ping();
- }
- expect_close = 0;
- up(&open_sem);
+ if (expect_close == 42) {
+ wdtpci_stop();
+ } else {
+ printk(KERN_CRIT PFX "Unexpected close, not stopping timer!");
+ wdtpci_ping();
}
+ expect_close = 0;
+ up(&open_sem);
+ return 0;
+}
+
+#ifdef CONFIG_WDT_501_PCI
+/**
+ * wdtpci_temp_read:
+ * @file: file handle to the watchdog board
+ * @buf: buffer to write 1 byte into
+ * @count: length of buffer
+ * @ptr: offset (no seek allowed)
+ *
+ * Read reports the temperature in degrees Fahrenheit. The API is in
+ * fahrenheit. It was designed by an imperial measurement luddite.
+ */
+
+static ssize_t wdtpci_temp_read(struct file *file, char *buf, size_t count, loff_t *ptr)
+{
+ int temperature;
+
+ /* Can't seek (pread) on this device */
+ if (ptr != &file->f_pos)
+ return -ESPIPE;
+
+ if (wdtpci_get_temperature(&temperature))
+ return -EFAULT;
+
+ if (copy_to_user (buf, &temperature, 1))
+ return -EFAULT;
+
+ return 1;
+}
+
+/**
+ * wdtpci_temp_open:
+ * @inode: inode of device
+ * @file: file handle to device
+ *
+ * The temperature device has been opened.
+ */
+
+static int wdtpci_temp_open(struct inode *inode, struct file *file)
+{
+ return 0;
+}
+
+/**
+ * wdtpci_temp_release:
+ * @inode: inode to board
+ * @file: file handle to board
+ *
+ * The temperature device has been closed.
+ */
+
+static int wdtpci_temp_release(struct inode *inode, struct file *file)
+{
return 0;
}
+#endif /* CONFIG_WDT_501_PCI */
/**
* notify_sys:
static int wdtpci_notify_sys(struct notifier_block *this, unsigned long code,
void *unused)
{
- unsigned long flags;
-
if (code==SYS_DOWN || code==SYS_HALT) {
/* Turn the card off */
- spin_lock_irqsave(&wdtpci_lock, flags);
- inb_p(WDT_DC);
- wdtpci_ctr_load(2,0);
- spin_unlock_irqrestore(&wdtpci_lock, flags);
+ wdtpci_stop();
}
return NOTIFY_DONE;
}
static struct file_operations wdtpci_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
- .read = wdtpci_read,
.write = wdtpci_write,
.ioctl = wdtpci_ioctl,
.open = wdtpci_open,
};
#ifdef CONFIG_WDT_501_PCI
+static struct file_operations wdtpci_temp_fops = {
+ .owner = THIS_MODULE,
+ .llseek = no_llseek,
+ .read = wdtpci_temp_read,
+ .open = wdtpci_temp_open,
+ .release = wdtpci_temp_release,
+};
+
static struct miscdevice temp_miscdev = {
.minor = TEMP_MINOR,
.name = "temperature",
- .fops = &wdtpci_fops,
+ .fops = &wdtpci_temp_fops,
};
-#endif
+#endif /* CONFIG_WDT_501_PCI */
/*
* The WDT card needs to learn about soft shutdowns in order to
static int __devinit wdtpci_init_one (struct pci_dev *dev,
const struct pci_device_id *ent)
{
- static int dev_count = 0;
int ret = -EIO;
dev_count++;
if (dev_count > 1) {
- printk (KERN_ERR PFX
- "this driver only supports 1 device\n");
+ printk (KERN_ERR PFX "this driver only supports 1 device\n");
return -ENODEV;
}
- if (pci_enable_device (dev))
- goto out;
+ if (pci_enable_device (dev)) {
+ printk (KERN_ERR PFX "Not possible to enable PCI Device\n");
+ return -ENODEV;
+ }
+
+ if (pci_resource_start (dev, 2) == 0x0000) {
+ printk (KERN_ERR PFX "No I/O-Address for card detected\n");
+ ret = -ENODEV;
+ goto out_pci;
+ }
sema_init(&open_sem, 1);
spin_lock_init(&wdtpci_lock);
irq = dev->irq;
io = pci_resource_start (dev, 2);
- printk ("WDT501-P(PCI-WDG-CSM) driver 0.07 at %X "
- "(Interrupt %d)\n", io, irq);
- if (request_region (io, 16, "wdt-pci") == NULL) {
- printk (KERN_ERR PFX "I/O %d is not free.\n", io);
- goto out;
+ if (request_region (io, 16, "wdt_pci") == NULL) {
+ printk (KERN_ERR PFX "I/O address 0x%04x already in use\n", io);
+ goto out_pci;
}
if (request_irq (irq, wdtpci_interrupt, SA_INTERRUPT | SA_SHIRQ,
- "wdt-pci", &wdtpci_miscdev)) {
- printk (KERN_ERR PFX "IRQ %d is not free.\n", irq);
+ "wdt_pci", &wdtpci_miscdev)) {
+ printk (KERN_ERR PFX "IRQ %d is not free\n", irq);
goto out_reg;
}
- ret = misc_register (&wdtpci_miscdev);
- if (ret) {
- printk (KERN_ERR PFX "can't misc_register on minor=%d\n", WATCHDOG_MINOR);
- goto out_irq;
+ printk ("PCI-WDT500/501 (PCI-WDG-CSM) driver 0.10 at 0x%04x (Interrupt %d)\n",
+ io, irq);
+
+ /* Check that the heartbeat value is within it's range ; if not reset to the default */
+ if (wdtpci_set_heartbeat(heartbeat)) {
+ wdtpci_set_heartbeat(WD_TIMO);
+ printk(KERN_INFO PFX "heartbeat value must be 0<heartbeat<65536, using %d\n",
+ WD_TIMO);
}
ret = register_reboot_notifier (&wdtpci_notifier);
if (ret) {
- printk (KERN_ERR PFX "can't misc_register on minor=%d\n", WATCHDOG_MINOR);
- goto out_misc;
+ printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n", ret);
+ goto out_irq;
}
+
#ifdef CONFIG_WDT_501_PCI
ret = misc_register (&temp_miscdev);
if (ret) {
- printk (KERN_ERR PFX "can't misc_register (temp) on minor=%d\n", TEMP_MINOR);
+ printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
+ TEMP_MINOR, ret);
goto out_rbt;
}
-#endif
+#endif /* CONFIG_WDT_501_PCI */
+
+ ret = misc_register (&wdtpci_miscdev);
+ if (ret) {
+ printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
+ WATCHDOG_MINOR, ret);
+ goto out_misc;
+ }
+
+ printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
+ heartbeat, nowayout);
+#ifdef CONFIG_WDT_501_PCI
+ printk(KERN_INFO "wdt: Fan Tachometer is %s\n", (tachometer ? "Enabled" : "Disabled"));
+#endif /* CONFIG_WDT_501_PCI */
ret = 0;
out:
return ret;
+out_misc:
#ifdef CONFIG_WDT_501_PCI
+ misc_deregister(&temp_miscdev);
+#endif /* CONFIG_WDT_501_PCI */
out_rbt:
unregister_reboot_notifier(&wdtpci_notifier);
-#endif
-out_misc:
- misc_deregister(&wdtpci_miscdev);
out_irq:
free_irq(irq, &wdtpci_miscdev);
out_reg:
release_region (io, 16);
+out_pci:
+ pci_disable_device(dev);
goto out;
}
{
/* here we assume only one device will ever have
* been picked up and registered by probe function */
- unregister_reboot_notifier(&wdtpci_notifier);
+ misc_deregister(&wdtpci_miscdev);
#ifdef CONFIG_WDT_501_PCI
misc_deregister(&temp_miscdev);
-#endif
- misc_deregister(&wdtpci_miscdev);
+#endif /* CONFIG_WDT_501_PCI */
+ unregister_reboot_notifier(&wdtpci_notifier);
free_irq(irq, &wdtpci_miscdev);
release_region(io, 16);
+ pci_disable_device(pdev);
+ dev_count--;
}
static struct pci_driver wdtpci_driver = {
- .name = "wdt-pci",
+ .name = "wdt_pci",
.id_table = wdtpci_pci_tbl,
.probe = wdtpci_init_one,
.remove = __devexit_p(wdtpci_remove_one),
* If your watchdog is set to continue ticking on close and you unload
* it, well it keeps ticking. We won't get the interrupt but the board
* will not touch PC memory so all is fine. You just have to load a new
- * module in 60 seconds or reboot.
+ * module in xx seconds or reboot.
*/
static void __exit wdtpci_cleanup(void)
static int __init wdtpci_init(void)
{
- int rc = pci_register_driver (&wdtpci_driver);
-
- if (rc < 1)
- return -ENODEV;
-
- return 0;
+ return pci_register_driver (&wdtpci_driver);
}
module_exit(wdtpci_cleanup);
MODULE_AUTHOR("JP Nollmann, Alan Cox");
-MODULE_DESCRIPTION("Driver for the ICS PCI watchdog cards");
+MODULE_DESCRIPTION("Driver for the ICS PCI-WDT500/501 watchdog cards");
MODULE_LICENSE("GPL");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
MODULE_ALIAS_MISCDEV(TEMP_MINOR);
projects / linux / commitdiff