2 * Berkshire PCI-PC Watchdog Card Driver
4 * (c) Copyright 2003-2005 Wim Van Sebroeck <wim@iguana.be>.
6 * Based on source code of the following authors:
7 * Ken Hollis <kenji@bitgate.com>,
8 * Lindsay Harris <lindsay@bluegum.com>,
9 * Alan Cox <alan@redhat.com>,
10 * Matt Domsch <Matt_Domsch@dell.com>,
11 * Rob Radez <rob@osinvestor.com>
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License
15 * as published by the Free Software Foundation; either version
16 * 2 of the License, or (at your option) any later version.
18 * Neither Wim Van Sebroeck nor Iguana vzw. admit liability nor
19 * provide warranty for any of this software. This material is
20 * provided "AS-IS" and at no charge.
24 * A bells and whistles driver is available from:
25 * http://www.kernel.org/pub/linux/kernel/people/wim/pcwd/pcwd_pci/
27 * More info available at http://www.berkprod.com/ or http://www.pcwatchdog.com/
31 * Includes, defines, variables, module parameters, ...
34 #include <linux/config.h> /* For CONFIG_WATCHDOG_NOWAYOUT/... */
35 #include <linux/module.h> /* For module specific items */
36 #include <linux/moduleparam.h> /* For new moduleparam's */
37 #include <linux/types.h> /* For standard types (like size_t) */
38 #include <linux/errno.h> /* For the -ENODEV/... values */
39 #include <linux/kernel.h> /* For printk/panic/... */
40 #include <linux/delay.h> /* For mdelay function */
41 #include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */
42 #include <linux/watchdog.h> /* For the watchdog specific items */
43 #include <linux/notifier.h> /* For notifier support */
44 #include <linux/reboot.h> /* For reboot_notifier stuff */
45 #include <linux/init.h> /* For __init/__exit/... */
46 #include <linux/fs.h> /* For file operations */
47 #include <linux/pci.h> /* For pci functions */
48 #include <linux/ioport.h> /* For io-port access */
49 #include <linux/spinlock.h> /* For spin_lock/spin_unlock/... */
51 #include <asm/uaccess.h> /* For copy_to_user/put_user/... */
52 #include <asm/io.h> /* For inb/outb/... */
54 /* Module and version information */
55 #define WATCHDOG_VERSION "1.02"
56 #define WATCHDOG_DATE "03 Sep 2005"
57 #define WATCHDOG_DRIVER_NAME "PCI-PC Watchdog"
58 #define WATCHDOG_NAME "pcwd_pci"
59 #define PFX WATCHDOG_NAME ": "
60 #define DRIVER_VERSION WATCHDOG_DRIVER_NAME " driver, v" WATCHDOG_VERSION " (" WATCHDOG_DATE ")\n"
62 /* Stuff for the PCI ID's */
63 #ifndef PCI_VENDOR_ID_QUICKLOGIC
64 #define PCI_VENDOR_ID_QUICKLOGIC 0x11e3
67 #ifndef PCI_DEVICE_ID_WATCHDOG_PCIPCWD
68 #define PCI_DEVICE_ID_WATCHDOG_PCIPCWD 0x5030
72 * These are the defines that describe the control status bits for the
73 * PCI-PC Watchdog card.
75 /* Port 1 : Control Status #1 */
76 #define WD_PCI_WTRP 0x01 /* Watchdog Trip status */
77 #define WD_PCI_HRBT 0x02 /* Watchdog Heartbeat */
78 #define WD_PCI_TTRP 0x04 /* Temperature Trip status */
79 #define WD_PCI_RL2A 0x08 /* Relay 2 Active */
80 #define WD_PCI_RL1A 0x10 /* Relay 1 Active */
81 #define WD_PCI_R2DS 0x40 /* Relay 2 Disable Temperature-trip/reset */
82 #define WD_PCI_RLY2 0x80 /* Activate Relay 2 on the board */
83 /* Port 2 : Control Status #2 */
84 #define WD_PCI_WDIS 0x10 /* Watchdog Disable */
85 #define WD_PCI_ENTP 0x20 /* Enable Temperature Trip Reset */
86 #define WD_PCI_WRSP 0x40 /* Watchdog wrote response */
87 #define WD_PCI_PCMD 0x80 /* PC has sent command */
89 /* according to documentation max. time to process a command for the pci
90 * watchdog card is 100 ms, so we give it 150 ms to do it's job */
91 #define PCI_COMMAND_TIMEOUT 150
93 /* Watchdog's internal commands */
94 #define CMD_GET_STATUS 0x04
95 #define CMD_GET_FIRMWARE_VERSION 0x08
96 #define CMD_READ_WATCHDOG_TIMEOUT 0x18
97 #define CMD_WRITE_WATCHDOG_TIMEOUT 0x19
98 #define CMD_GET_CLEAR_RESET_COUNT 0x84
100 /* We can only use 1 card due to the /dev/watchdog restriction */
101 static int cards_found
;
103 /* internal variables */
104 static int temp_panic
;
105 static unsigned long is_active
;
106 static char expect_release
;
107 static struct { /* this is private data for each PCI-PC watchdog card */
108 int supports_temp
; /* Wether or not the card has a temperature device */
109 int boot_status
; /* The card's boot status */
110 unsigned long io_addr
; /* The cards I/O address */
111 spinlock_t io_lock
; /* the lock for io operations */
112 struct pci_dev
*pdev
; /* the PCI-device */
115 /* module parameters */
116 #define QUIET 0 /* Default */
117 #define VERBOSE 1 /* Verbose */
118 #define DEBUG 2 /* print fancy stuff too */
119 static int debug
= QUIET
;
120 module_param(debug
, int, 0);
121 MODULE_PARM_DESC(debug
, "Debug level: 0=Quiet, 1=Verbose, 2=Debug (default=0)");
123 #define WATCHDOG_HEARTBEAT 2 /* 2 sec default heartbeat */
124 static int heartbeat
= WATCHDOG_HEARTBEAT
;
125 module_param(heartbeat
, int, 0);
126 MODULE_PARM_DESC(heartbeat
, "Watchdog heartbeat in seconds. (0<heartbeat<65536, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT
) ")");
128 static int nowayout
= WATCHDOG_NOWAYOUT
;
129 module_param(nowayout
, int, 0);
130 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
136 static int send_command(int cmd
, int *msb
, int *lsb
)
138 int got_response
, count
;
141 printk(KERN_DEBUG PFX
"sending following data cmd=0x%02x msb=0x%02x lsb=0x%02x\n",
144 spin_lock(&pcipcwd_private
.io_lock
);
145 /* If a command requires data it should be written first.
146 * Data for commands with 8 bits of data should be written to port 4.
147 * Commands with 16 bits of data, should be written as LSB to port 4
149 * After the required data has been written then write the command to
151 outb_p(*lsb
, pcipcwd_private
.io_addr
+ 4);
152 outb_p(*msb
, pcipcwd_private
.io_addr
+ 5);
153 outb_p(cmd
, pcipcwd_private
.io_addr
+ 6);
155 /* wait till the pci card processed the command, signaled by
156 * the WRSP bit in port 2 and give it a max. timeout of
157 * PCI_COMMAND_TIMEOUT to process */
158 got_response
= inb_p(pcipcwd_private
.io_addr
+ 2) & WD_PCI_WRSP
;
159 for (count
= 0; (count
< PCI_COMMAND_TIMEOUT
) && (!got_response
); count
++) {
161 got_response
= inb_p(pcipcwd_private
.io_addr
+ 2) & WD_PCI_WRSP
;
164 if (debug
>= DEBUG
) {
166 printk(KERN_DEBUG PFX
"time to process command was: %d ms\n",
169 printk(KERN_DEBUG PFX
"card did not respond on command!\n");
174 /* read back response */
175 *lsb
= inb_p(pcipcwd_private
.io_addr
+ 4);
176 *msb
= inb_p(pcipcwd_private
.io_addr
+ 5);
179 inb_p(pcipcwd_private
.io_addr
+ 6);
182 printk(KERN_DEBUG PFX
"received following data for cmd=0x%02x: msb=0x%02x lsb=0x%02x\n",
186 spin_unlock(&pcipcwd_private
.io_lock
);
191 static inline void pcipcwd_check_temperature_support(void)
193 if (inb_p(pcipcwd_private
.io_addr
) != 0xF0)
194 pcipcwd_private
.supports_temp
= 1;
197 static int pcipcwd_get_option_switches(void)
201 option_switches
= inb_p(pcipcwd_private
.io_addr
+ 3);
202 return option_switches
;
205 static void pcipcwd_show_card_info(void)
207 int got_fw_rev
, fw_rev_major
, fw_rev_minor
;
208 char fw_ver_str
[20]; /* The cards firmware version */
211 got_fw_rev
= send_command(CMD_GET_FIRMWARE_VERSION
, &fw_rev_major
, &fw_rev_minor
);
213 sprintf(fw_ver_str
, "%u.%02u", fw_rev_major
, fw_rev_minor
);
215 sprintf(fw_ver_str
, "<card no answer>");
218 /* Get switch settings */
219 option_switches
= pcipcwd_get_option_switches();
221 printk(KERN_INFO PFX
"Found card at port 0x%04x (Firmware: %s) %s temp option\n",
222 (int) pcipcwd_private
.io_addr
, fw_ver_str
,
223 (pcipcwd_private
.supports_temp
? "with" : "without"));
225 printk(KERN_INFO PFX
"Option switches (0x%02x): Temperature Reset Enable=%s, Power On Delay=%s\n",
227 ((option_switches
& 0x10) ? "ON" : "OFF"),
228 ((option_switches
& 0x08) ? "ON" : "OFF"));
230 if (pcipcwd_private
.boot_status
& WDIOF_CARDRESET
)
231 printk(KERN_INFO PFX
"Previous reset was caused by the Watchdog card\n");
233 if (pcipcwd_private
.boot_status
& WDIOF_OVERHEAT
)
234 printk(KERN_INFO PFX
"Card sensed a CPU Overheat\n");
236 if (pcipcwd_private
.boot_status
== 0)
237 printk(KERN_INFO PFX
"No previous trip detected - Cold boot or reset\n");
240 static int pcipcwd_start(void)
244 spin_lock(&pcipcwd_private
.io_lock
);
245 outb_p(0x00, pcipcwd_private
.io_addr
+ 3);
248 stat_reg
= inb_p(pcipcwd_private
.io_addr
+ 2);
249 spin_unlock(&pcipcwd_private
.io_lock
);
251 if (stat_reg
& WD_PCI_WDIS
) {
252 printk(KERN_ERR PFX
"Card timer not enabled\n");
256 if (debug
>= VERBOSE
)
257 printk(KERN_DEBUG PFX
"Watchdog started\n");
262 static int pcipcwd_stop(void)
266 spin_lock(&pcipcwd_private
.io_lock
);
267 outb_p(0xA5, pcipcwd_private
.io_addr
+ 3);
270 outb_p(0xA5, pcipcwd_private
.io_addr
+ 3);
273 stat_reg
= inb_p(pcipcwd_private
.io_addr
+ 2);
274 spin_unlock(&pcipcwd_private
.io_lock
);
276 if (!(stat_reg
& WD_PCI_WDIS
)) {
277 printk(KERN_ERR PFX
"Card did not acknowledge disable attempt\n");
281 if (debug
>= VERBOSE
)
282 printk(KERN_DEBUG PFX
"Watchdog stopped\n");
287 static int pcipcwd_keepalive(void)
289 /* Re-trigger watchdog by writing to port 0 */
290 outb_p(0x42, pcipcwd_private
.io_addr
); /* send out any data */
293 printk(KERN_DEBUG PFX
"Watchdog keepalive signal send\n");
298 static int pcipcwd_set_heartbeat(int t
)
303 if ((t
< 0x0001) || (t
> 0xFFFF))
306 /* Write new heartbeat to watchdog */
307 send_command(CMD_WRITE_WATCHDOG_TIMEOUT
, &t_msb
, &t_lsb
);
310 if (debug
>= VERBOSE
)
311 printk(KERN_DEBUG PFX
"New heartbeat: %d\n",
317 static int pcipcwd_get_status(int *status
)
322 control_status
= inb_p(pcipcwd_private
.io_addr
+ 1);
323 if (control_status
& WD_PCI_WTRP
)
324 *status
|= WDIOF_CARDRESET
;
325 if (control_status
& WD_PCI_TTRP
) {
326 *status
|= WDIOF_OVERHEAT
;
328 panic(PFX
"Temperature overheat trip!\n");
332 printk(KERN_DEBUG PFX
"Control Status #1: 0x%02x\n",
338 static int pcipcwd_clear_status(void)
344 if (debug
>= VERBOSE
)
345 printk(KERN_INFO PFX
"clearing watchdog trip status & LED\n");
347 control_status
= inb_p(pcipcwd_private
.io_addr
+ 1);
349 if (debug
>= DEBUG
) {
350 printk(KERN_DEBUG PFX
"status was: 0x%02x\n", control_status
);
351 printk(KERN_DEBUG PFX
"sending: 0x%02x\n",
352 (control_status
& WD_PCI_R2DS
) | WD_PCI_WTRP
);
355 /* clear trip status & LED and keep mode of relay 2 */
356 outb_p((control_status
& WD_PCI_R2DS
) | WD_PCI_WTRP
, pcipcwd_private
.io_addr
+ 1);
358 /* clear reset counter */
361 send_command(CMD_GET_CLEAR_RESET_COUNT
, &msb
, &reset_counter
);
363 if (debug
>= DEBUG
) {
364 printk(KERN_DEBUG PFX
"reset count was: 0x%02x\n",
371 static int pcipcwd_get_temperature(int *temperature
)
374 if (!pcipcwd_private
.supports_temp
)
377 *temperature
= inb_p(pcipcwd_private
.io_addr
);
380 * Convert celsius to fahrenheit, since this was
381 * the decided 'standard' for this return value.
383 *temperature
= (*temperature
* 9 / 5) + 32;
385 if (debug
>= DEBUG
) {
386 printk(KERN_DEBUG PFX
"temperature is: %d F\n",
394 * /dev/watchdog handling
397 static ssize_t
pcipcwd_write(struct file
*file
, const char __user
*data
,
398 size_t len
, loff_t
*ppos
)
400 /* See if we got the magic character 'V' and reload the timer */
405 /* note: just in case someone wrote the magic character
406 * five months ago... */
409 /* scan to see whether or not we got the magic character */
410 for (i
= 0; i
!= len
; i
++) {
412 if(get_user(c
, data
+i
))
419 /* someone wrote to us, we should reload the timer */
425 static int pcipcwd_ioctl(struct inode
*inode
, struct file
*file
,
426 unsigned int cmd
, unsigned long arg
)
428 void __user
*argp
= (void __user
*)arg
;
429 int __user
*p
= argp
;
430 static struct watchdog_info ident
= {
431 .options
= WDIOF_OVERHEAT
|
433 WDIOF_KEEPALIVEPING
|
436 .firmware_version
= 1,
437 .identity
= WATCHDOG_DRIVER_NAME
,
441 case WDIOC_GETSUPPORT
:
442 return copy_to_user(argp
, &ident
,
443 sizeof (ident
)) ? -EFAULT
: 0;
445 case WDIOC_GETSTATUS
:
449 pcipcwd_get_status(&status
);
451 return put_user(status
, p
);
454 case WDIOC_GETBOOTSTATUS
:
455 return put_user(pcipcwd_private
.boot_status
, p
);
461 if (pcipcwd_get_temperature(&temperature
))
464 return put_user(temperature
, p
);
467 case WDIOC_KEEPALIVE
:
471 case WDIOC_SETOPTIONS
:
473 int new_options
, retval
= -EINVAL
;
475 if (get_user (new_options
, p
))
478 if (new_options
& WDIOS_DISABLECARD
) {
484 if (new_options
& WDIOS_ENABLECARD
) {
490 if (new_options
& WDIOS_TEMPPANIC
) {
498 case WDIOC_SETTIMEOUT
:
502 if (get_user(new_heartbeat
, p
))
505 if (pcipcwd_set_heartbeat(new_heartbeat
))
512 case WDIOC_GETTIMEOUT
:
513 return put_user(heartbeat
, p
);
520 static int pcipcwd_open(struct inode
*inode
, struct file
*file
)
522 /* /dev/watchdog can only be opened once */
523 if (test_and_set_bit(0, &is_active
)) {
524 if (debug
>= VERBOSE
)
525 printk(KERN_ERR PFX
"Attempt to open already opened device.\n");
532 return nonseekable_open(inode
, file
);
535 static int pcipcwd_release(struct inode
*inode
, struct file
*file
)
538 * Shut off the timer.
540 if (expect_release
== 42) {
543 printk(KERN_CRIT PFX
"Unexpected close, not stopping watchdog!\n");
547 clear_bit(0, &is_active
);
552 * /dev/temperature handling
555 static ssize_t
pcipcwd_temp_read(struct file
*file
, char __user
*data
,
556 size_t len
, loff_t
*ppos
)
560 if (pcipcwd_get_temperature(&temperature
))
563 if (copy_to_user (data
, &temperature
, 1))
569 static int pcipcwd_temp_open(struct inode
*inode
, struct file
*file
)
571 if (!pcipcwd_private
.supports_temp
)
574 return nonseekable_open(inode
, file
);
577 static int pcipcwd_temp_release(struct inode
*inode
, struct file
*file
)
586 static int pcipcwd_notify_sys(struct notifier_block
*this, unsigned long code
, void *unused
)
588 if (code
==SYS_DOWN
|| code
==SYS_HALT
) {
589 /* Turn the WDT off */
600 static struct file_operations pcipcwd_fops
= {
601 .owner
= THIS_MODULE
,
603 .write
= pcipcwd_write
,
604 .ioctl
= pcipcwd_ioctl
,
605 .open
= pcipcwd_open
,
606 .release
= pcipcwd_release
,
609 static struct miscdevice pcipcwd_miscdev
= {
610 .minor
= WATCHDOG_MINOR
,
612 .fops
= &pcipcwd_fops
,
615 static struct file_operations pcipcwd_temp_fops
= {
616 .owner
= THIS_MODULE
,
618 .read
= pcipcwd_temp_read
,
619 .open
= pcipcwd_temp_open
,
620 .release
= pcipcwd_temp_release
,
623 static struct miscdevice pcipcwd_temp_miscdev
= {
625 .name
= "temperature",
626 .fops
= &pcipcwd_temp_fops
,
629 static struct notifier_block pcipcwd_notifier
= {
630 .notifier_call
= pcipcwd_notify_sys
,
634 * Init & exit routines
637 static int __devinit
pcipcwd_card_init(struct pci_dev
*pdev
,
638 const struct pci_device_id
*ent
)
643 if (cards_found
== 1)
644 printk(KERN_INFO PFX DRIVER_VERSION
);
646 if (cards_found
> 1) {
647 printk(KERN_ERR PFX
"This driver only supports 1 device\n");
651 if (pci_enable_device(pdev
)) {
652 printk(KERN_ERR PFX
"Not possible to enable PCI Device\n");
656 if (pci_resource_start(pdev
, 0) == 0x0000) {
657 printk(KERN_ERR PFX
"No I/O-Address for card detected\n");
659 goto err_out_disable_device
;
662 pcipcwd_private
.pdev
= pdev
;
663 pcipcwd_private
.io_addr
= pci_resource_start(pdev
, 0);
665 if (pci_request_regions(pdev
, WATCHDOG_NAME
)) {
666 printk(KERN_ERR PFX
"I/O address 0x%04x already in use\n",
667 (int) pcipcwd_private
.io_addr
);
669 goto err_out_disable_device
;
672 /* get the boot_status */
673 pcipcwd_get_status(&pcipcwd_private
.boot_status
);
675 /* clear the "card caused reboot" flag */
676 pcipcwd_clear_status();
681 /* Check whether or not the card supports the temperature device */
682 pcipcwd_check_temperature_support();
684 /* Show info about the card itself */
685 pcipcwd_show_card_info();
687 /* Check that the heartbeat value is within it's range ; if not reset to the default */
688 if (pcipcwd_set_heartbeat(heartbeat
)) {
689 pcipcwd_set_heartbeat(WATCHDOG_HEARTBEAT
);
690 printk(KERN_INFO PFX
"heartbeat value must be 0<heartbeat<65536, using %d\n",
694 ret
= register_reboot_notifier(&pcipcwd_notifier
);
696 printk(KERN_ERR PFX
"cannot register reboot notifier (err=%d)\n",
698 goto err_out_release_region
;
701 if (pcipcwd_private
.supports_temp
) {
702 ret
= misc_register(&pcipcwd_temp_miscdev
);
704 printk(KERN_ERR PFX
"cannot register miscdev on minor=%d (err=%d)\n",
706 goto err_out_unregister_reboot
;
710 ret
= misc_register(&pcipcwd_miscdev
);
712 printk(KERN_ERR PFX
"cannot register miscdev on minor=%d (err=%d)\n",
713 WATCHDOG_MINOR
, ret
);
714 goto err_out_misc_deregister
;
717 printk(KERN_INFO PFX
"initialized. heartbeat=%d sec (nowayout=%d)\n",
718 heartbeat
, nowayout
);
722 err_out_misc_deregister
:
723 if (pcipcwd_private
.supports_temp
)
724 misc_deregister(&pcipcwd_temp_miscdev
);
725 err_out_unregister_reboot
:
726 unregister_reboot_notifier(&pcipcwd_notifier
);
727 err_out_release_region
:
728 pci_release_regions(pdev
);
729 err_out_disable_device
:
730 pci_disable_device(pdev
);
734 static void __devexit
pcipcwd_card_exit(struct pci_dev
*pdev
)
736 /* Stop the timer before we leave */
741 misc_deregister(&pcipcwd_miscdev
);
742 if (pcipcwd_private
.supports_temp
)
743 misc_deregister(&pcipcwd_temp_miscdev
);
744 unregister_reboot_notifier(&pcipcwd_notifier
);
745 pci_release_regions(pdev
);
746 pci_disable_device(pdev
);
750 static struct pci_device_id pcipcwd_pci_tbl
[] = {
751 { PCI_VENDOR_ID_QUICKLOGIC
, PCI_DEVICE_ID_WATCHDOG_PCIPCWD
,
752 PCI_ANY_ID
, PCI_ANY_ID
, },
753 { 0 }, /* End of list */
755 MODULE_DEVICE_TABLE(pci
, pcipcwd_pci_tbl
);
757 static struct pci_driver pcipcwd_driver
= {
758 .name
= WATCHDOG_NAME
,
759 .id_table
= pcipcwd_pci_tbl
,
760 .probe
= pcipcwd_card_init
,
761 .remove
= __devexit_p(pcipcwd_card_exit
),
764 static int __init
pcipcwd_init_module(void)
766 spin_lock_init(&pcipcwd_private
.io_lock
);
768 return pci_register_driver(&pcipcwd_driver
);
771 static void __exit
pcipcwd_cleanup_module(void)
773 pci_unregister_driver(&pcipcwd_driver
);
776 module_init(pcipcwd_init_module
);
777 module_exit(pcipcwd_cleanup_module
);
779 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
780 MODULE_DESCRIPTION("Berkshire PCI-PC Watchdog driver");
781 MODULE_LICENSE("GPL");
782 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);
783 MODULE_ALIAS_MISCDEV(TEMP_MINOR
);