From 8e7ff45124547d1e02dbd590d05989348abc4d69 Mon Sep 17 00:00:00 2001 From: Wim Van Sebroeck Date: Sun, 21 Mar 2004 13:22:23 +0100 Subject: [PATCH] [WATCHDOG] v2.6.5-rc2 wdt_pci.c-patch Version 0.10 of wdt_pci.c - Changes that were made are: * Extract the start code in a seperate function (wdtpci_start) * Extract the stop code in a seperate function (wdtpci_stop) * Convert wdtpci_ping so that it return an int value (0=succes). * Extract the get_temperature code in a seperate function (wdtpci_get_temperature) * Make /dev/watchdog and /dev/temperature to different misc devices with their own fops. * Reorganize init and exit functions * Make heartbeat (the emulated heartbeat) a module parameter * Rewrite status flag code so that we could add a new tachometer module parameter + make clear distinction between PCI-WDT500 and PCI-WDT501. * Small clean-up's --- drivers/char/watchdog/wdt_pci.c | 562 +++++++++++++++++++------------- 1 file changed, 337 insertions(+), 225 deletions(-) diff --git a/drivers/char/watchdog/wdt_pci.c b/drivers/char/watchdog/wdt_pci.c index fde30429c5f81..395df48c82f52 100644 --- a/drivers/char/watchdog/wdt_pci.c +++ b/drivers/char/watchdog/wdt_pci.c @@ -1,5 +1,5 @@ /* - * Industrial Computer Source WDT500/501 driver for Linux 2.1.x + * Industrial Computer Source PCI-WDT500/501 driver * * (c) Copyright 1996-1997 Alan Cox , All Rights Reserved. * http://www.redhat.com @@ -15,7 +15,7 @@ * * (c) Copyright 1995 Alan Cox * - * Release 0.09. + * Release 0.10. * * Fixes * Dave Gregorich : Modularisation and minor bugs @@ -46,6 +46,7 @@ #include #include #include +#include #include #include @@ -70,6 +71,9 @@ #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; @@ -78,10 +82,12 @@ static int io; 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>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 @@ -125,32 +231,47 @@ static void wdtpci_ctr_load(int ctr, int val) * 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 @@ -168,57 +289,37 @@ static irqreturn_t wdtpci_interrupt(int irq, void *dev_id, struct pt_regs *regs) * 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 @@ -256,40 +357,6 @@ static ssize_t wdtpci_write(struct file *file, const char *buf, size_t count, lo 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 @@ -305,17 +372,25 @@ static ssize_t wdtpci_read(struct file *file, char *buf, size_t count, loff_t *p 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: @@ -324,24 +399,24 @@ static int wdtpci_ioctl(struct inode *inode, struct file *file, unsigned int cmd 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); } } @@ -350,66 +425,30 @@ static int wdtpci_ioctl(struct inode *inode, struct file *file, unsigned int cmd * @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 * @@ -422,23 +461,72 @@ static int wdtpci_open(struct inode *inode, struct file *file) 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: @@ -455,14 +543,9 @@ static int wdtpci_release(struct inode *inode, struct file *file) 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; } @@ -475,7 +558,6 @@ static int wdtpci_notify_sys(struct notifier_block *this, unsigned long code, static struct file_operations wdtpci_fops = { .owner = THIS_MODULE, .llseek = no_llseek, - .read = wdtpci_read, .write = wdtpci_write, .ioctl = wdtpci_ioctl, .open = wdtpci_open, @@ -489,12 +571,20 @@ static struct miscdevice wdtpci_miscdev = { }; #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 @@ -509,71 +599,96 @@ static struct notifier_block wdtpci_notifier = { 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