2 * Berkshire PCI-PC Watchdog Card Driver
4 * (c) Copyright 2003 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 http://www.pcwd.de/
25 * More info available at http://www.berkprod.com/ or http://www.pcwatchdog.com/
29 * Includes, defines, variables, module parameters, ...
32 #include <linux/config.h>
33 #include <linux/module.h>
34 #include <linux/moduleparam.h>
35 #include <linux/types.h>
36 #include <linux/delay.h>
37 #include <linux/miscdevice.h>
38 #include <linux/watchdog.h>
39 #include <linux/notifier.h>
40 #include <linux/reboot.h>
41 #include <linux/init.h>
43 #include <linux/pci.h>
44 #include <linux/ioport.h>
45 #include <linux/spinlock.h>
47 #include <asm/uaccess.h>
50 /* Module and version information */
51 #define WATCHDOG_VERSION "1.01"
52 #define WATCHDOG_DATE "15 Mar 2005"
53 #define WATCHDOG_DRIVER_NAME "PCI-PC Watchdog"
54 #define WATCHDOG_NAME "pcwd_pci"
55 #define PFX WATCHDOG_NAME ": "
56 #define DRIVER_VERSION WATCHDOG_DRIVER_NAME " driver, v" WATCHDOG_VERSION " (" WATCHDOG_DATE ")\n"
58 /* Stuff for the PCI ID's */
59 #ifndef PCI_VENDOR_ID_QUICKLOGIC
60 #define PCI_VENDOR_ID_QUICKLOGIC 0x11e3
63 #ifndef PCI_DEVICE_ID_WATCHDOG_PCIPCWD
64 #define PCI_DEVICE_ID_WATCHDOG_PCIPCWD 0x5030
68 * These are the defines that describe the control status bits for the
69 * PCI-PC Watchdog card.
71 #define WD_PCI_WTRP 0x01 /* Watchdog Trip status */
72 #define WD_PCI_HRBT 0x02 /* Watchdog Heartbeat */
73 #define WD_PCI_TTRP 0x04 /* Temperature Trip status */
75 /* according to documentation max. time to process a command for the pci
76 * watchdog card is 100 ms, so we give it 150 ms to do it's job */
77 #define PCI_COMMAND_TIMEOUT 150
79 /* Watchdog's internal commands */
80 #define CMD_GET_STATUS 0x04
81 #define CMD_GET_FIRMWARE_VERSION 0x08
82 #define CMD_READ_WATCHDOG_TIMEOUT 0x18
83 #define CMD_WRITE_WATCHDOG_TIMEOUT 0x19
85 /* We can only use 1 card due to the /dev/watchdog restriction */
86 static int cards_found
;
88 /* internal variables */
89 static int temp_panic
;
90 static unsigned long is_active
;
91 static char expect_release
;
93 int supports_temp
; /* Wether or not the card has a temperature device */
94 int boot_status
; /* The card's boot status */
95 unsigned long io_addr
; /* The cards I/O address */
100 /* module parameters */
101 #define WATCHDOG_HEARTBEAT 2 /* 2 sec default heartbeat */
102 static int heartbeat
= WATCHDOG_HEARTBEAT
;
103 module_param(heartbeat
, int, 0);
104 MODULE_PARM_DESC(heartbeat
, "Watchdog heartbeat in seconds. (0<heartbeat<65536, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT
) ")");
106 static int nowayout
= WATCHDOG_NOWAYOUT
;
107 module_param(nowayout
, int, 0);
108 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
114 static int send_command(int cmd
, int *msb
, int *lsb
)
116 int got_response
, count
;
118 spin_lock(&pcipcwd_private
.io_lock
);
119 /* If a command requires data it should be written first.
120 * Data for commands with 8 bits of data should be written to port 4.
121 * Commands with 16 bits of data, should be written as LSB to port 4
123 * After the required data has been written then write the command to
125 outb_p(*lsb
, pcipcwd_private
.io_addr
+ 4);
126 outb_p(*msb
, pcipcwd_private
.io_addr
+ 5);
127 outb_p(cmd
, pcipcwd_private
.io_addr
+ 6);
129 /* wait till the pci card processed the command, signaled by
130 * the WRSP bit in port 2 and give it a max. timeout of
131 * PCI_COMMAND_TIMEOUT to process */
132 got_response
= inb_p(pcipcwd_private
.io_addr
+ 2) & 0x40;
133 for (count
= 0; (count
< PCI_COMMAND_TIMEOUT
) && (!got_response
); count
++) {
135 got_response
= inb_p(pcipcwd_private
.io_addr
+ 2) & 0x40;
139 /* read back response */
140 *lsb
= inb_p(pcipcwd_private
.io_addr
+ 4);
141 *msb
= inb_p(pcipcwd_private
.io_addr
+ 5);
144 inb_p(pcipcwd_private
.io_addr
+ 6);
146 spin_unlock(&pcipcwd_private
.io_lock
);
151 static int pcipcwd_start(void)
155 spin_lock(&pcipcwd_private
.io_lock
);
156 outb_p(0x00, pcipcwd_private
.io_addr
+ 3);
159 stat_reg
= inb_p(pcipcwd_private
.io_addr
+ 2);
160 spin_unlock(&pcipcwd_private
.io_lock
);
162 if (stat_reg
& 0x10) {
163 printk(KERN_ERR PFX
"Card timer not enabled\n");
170 static int pcipcwd_stop(void)
174 spin_lock(&pcipcwd_private
.io_lock
);
175 outb_p(0xA5, pcipcwd_private
.io_addr
+ 3);
178 outb_p(0xA5, pcipcwd_private
.io_addr
+ 3);
181 stat_reg
= inb_p(pcipcwd_private
.io_addr
+ 2);
182 spin_unlock(&pcipcwd_private
.io_lock
);
184 if (!(stat_reg
& 0x10)) {
185 printk(KERN_ERR PFX
"Card did not acknowledge disable attempt\n");
192 static int pcipcwd_keepalive(void)
194 /* Re-trigger watchdog by writing to port 0 */
195 outb_p(0x42, pcipcwd_private
.io_addr
);
199 static int pcipcwd_set_heartbeat(int t
)
204 if ((t
< 0x0001) || (t
> 0xFFFF))
207 /* Write new heartbeat to watchdog */
208 send_command(CMD_WRITE_WATCHDOG_TIMEOUT
, &t_msb
, &t_lsb
);
214 static int pcipcwd_get_status(int *status
)
219 new_status
= inb_p(pcipcwd_private
.io_addr
+ 1);
220 if (new_status
& WD_PCI_WTRP
)
221 *status
|= WDIOF_CARDRESET
;
222 if (new_status
& WD_PCI_TTRP
) {
223 *status
|= WDIOF_OVERHEAT
;
225 panic(PFX
"Temperature overheat trip!\n");
231 static int pcipcwd_clear_status(void)
233 outb_p(0x01, pcipcwd_private
.io_addr
+ 1);
237 static int pcipcwd_get_temperature(int *temperature
)
240 if (!pcipcwd_private
.supports_temp
)
244 * Convert celsius to fahrenheit, since this was
245 * the decided 'standard' for this return value.
247 *temperature
= ((inb_p(pcipcwd_private
.io_addr
)) * 9 / 5) + 32;
253 * /dev/watchdog handling
256 static ssize_t
pcipcwd_write(struct file
*file
, const char __user
*data
,
257 size_t len
, loff_t
*ppos
)
259 /* See if we got the magic character 'V' and reload the timer */
264 /* note: just in case someone wrote the magic character
265 * five months ago... */
268 /* scan to see whether or not we got the magic character */
269 for (i
= 0; i
!= len
; i
++) {
271 if(get_user(c
, data
+i
))
278 /* someone wrote to us, we should reload the timer */
284 static int pcipcwd_ioctl(struct inode
*inode
, struct file
*file
,
285 unsigned int cmd
, unsigned long arg
)
287 void __user
*argp
= (void __user
*)arg
;
288 int __user
*p
= argp
;
289 static struct watchdog_info ident
= {
290 .options
= WDIOF_OVERHEAT
|
292 WDIOF_KEEPALIVEPING
|
295 .firmware_version
= 1,
296 .identity
= WATCHDOG_DRIVER_NAME
,
300 case WDIOC_GETSUPPORT
:
301 return copy_to_user(argp
, &ident
,
302 sizeof (ident
)) ? -EFAULT
: 0;
304 case WDIOC_GETSTATUS
:
308 pcipcwd_get_status(&status
);
310 return put_user(status
, p
);
313 case WDIOC_GETBOOTSTATUS
:
314 return put_user(pcipcwd_private
.boot_status
, p
);
320 if (pcipcwd_get_temperature(&temperature
))
323 return put_user(temperature
, p
);
326 case WDIOC_KEEPALIVE
:
330 case WDIOC_SETOPTIONS
:
332 int new_options
, retval
= -EINVAL
;
334 if (get_user (new_options
, p
))
337 if (new_options
& WDIOS_DISABLECARD
) {
342 if (new_options
& WDIOS_ENABLECARD
) {
347 if (new_options
& WDIOS_TEMPPANIC
) {
355 case WDIOC_SETTIMEOUT
:
359 if (get_user(new_heartbeat
, p
))
362 if (pcipcwd_set_heartbeat(new_heartbeat
))
369 case WDIOC_GETTIMEOUT
:
370 return put_user(heartbeat
, p
);
377 static int pcipcwd_open(struct inode
*inode
, struct file
*file
)
379 /* /dev/watchdog can only be opened once */
380 if (test_and_set_bit(0, &is_active
))
386 return nonseekable_open(inode
, file
);
389 static int pcipcwd_release(struct inode
*inode
, struct file
*file
)
392 * Shut off the timer.
394 if (expect_release
== 42) {
397 printk(KERN_CRIT PFX
"Unexpected close, not stopping watchdog!\n");
401 clear_bit(0, &is_active
);
406 * /dev/temperature handling
409 static ssize_t
pcipcwd_temp_read(struct file
*file
, char __user
*data
,
410 size_t len
, loff_t
*ppos
)
414 if (pcipcwd_get_temperature(&temperature
))
417 if (copy_to_user (data
, &temperature
, 1))
423 static int pcipcwd_temp_open(struct inode
*inode
, struct file
*file
)
425 if (!pcipcwd_private
.supports_temp
)
428 return nonseekable_open(inode
, file
);
431 static int pcipcwd_temp_release(struct inode
*inode
, struct file
*file
)
440 static int pcipcwd_notify_sys(struct notifier_block
*this, unsigned long code
, void *unused
)
442 if (code
==SYS_DOWN
|| code
==SYS_HALT
) {
443 /* Turn the WDT off */
454 static struct file_operations pcipcwd_fops
= {
455 .owner
= THIS_MODULE
,
457 .write
= pcipcwd_write
,
458 .ioctl
= pcipcwd_ioctl
,
459 .open
= pcipcwd_open
,
460 .release
= pcipcwd_release
,
463 static struct miscdevice pcipcwd_miscdev
= {
464 .minor
= WATCHDOG_MINOR
,
466 .fops
= &pcipcwd_fops
,
469 static struct file_operations pcipcwd_temp_fops
= {
470 .owner
= THIS_MODULE
,
472 .read
= pcipcwd_temp_read
,
473 .open
= pcipcwd_temp_open
,
474 .release
= pcipcwd_temp_release
,
477 static struct miscdevice pcipcwd_temp_miscdev
= {
479 .name
= "temperature",
480 .fops
= &pcipcwd_temp_fops
,
483 static struct notifier_block pcipcwd_notifier
= {
484 .notifier_call
= pcipcwd_notify_sys
,
488 * Init & exit routines
491 static inline void check_temperature_support(void)
493 if (inb_p(pcipcwd_private
.io_addr
) != 0xF0)
494 pcipcwd_private
.supports_temp
= 1;
497 static int __devinit
pcipcwd_card_init(struct pci_dev
*pdev
,
498 const struct pci_device_id
*ent
)
501 int got_fw_rev
, fw_rev_major
, fw_rev_minor
;
503 char option_switches
;
506 if (cards_found
== 1)
507 printk(KERN_INFO PFX DRIVER_VERSION
);
509 if (cards_found
> 1) {
510 printk(KERN_ERR PFX
"This driver only supports 1 device\n");
514 if (pci_enable_device(pdev
)) {
515 printk(KERN_ERR PFX
"Not possible to enable PCI Device\n");
519 if (pci_resource_start(pdev
, 0) == 0x0000) {
520 printk(KERN_ERR PFX
"No I/O-Address for card detected\n");
522 goto err_out_disable_device
;
525 pcipcwd_private
.pdev
= pdev
;
526 pcipcwd_private
.io_addr
= pci_resource_start(pdev
, 0);
528 if (pci_request_regions(pdev
, WATCHDOG_NAME
)) {
529 printk(KERN_ERR PFX
"I/O address 0x%04x already in use\n",
530 (int) pcipcwd_private
.io_addr
);
532 goto err_out_disable_device
;
535 /* get the boot_status */
536 pcipcwd_get_status(&pcipcwd_private
.boot_status
);
538 /* clear the "card caused reboot" flag */
539 pcipcwd_clear_status();
544 /* Check whether or not the card supports the temperature device */
545 check_temperature_support();
547 /* Get the Firmware Version */
548 got_fw_rev
= send_command(CMD_GET_FIRMWARE_VERSION
, &fw_rev_major
, &fw_rev_minor
);
550 sprintf(fw_ver_str
, "%u.%02u", fw_rev_major
, fw_rev_minor
);
552 sprintf(fw_ver_str
, "<card no answer>");
555 /* Get switch settings */
556 option_switches
= inb_p(pcipcwd_private
.io_addr
+ 3);
558 printk(KERN_INFO PFX
"Found card at port 0x%04x (Firmware: %s) %s temp option\n",
559 (int) pcipcwd_private
.io_addr
, fw_ver_str
,
560 (pcipcwd_private
.supports_temp
? "with" : "without"));
562 printk(KERN_INFO PFX
"Option switches (0x%02x): Temperature Reset Enable=%s, Power On Delay=%s\n",
564 ((option_switches
& 0x10) ? "ON" : "OFF"),
565 ((option_switches
& 0x08) ? "ON" : "OFF"));
567 if (pcipcwd_private
.boot_status
& WDIOF_CARDRESET
)
568 printk(KERN_INFO PFX
"Previous reset was caused by the Watchdog card\n");
570 if (pcipcwd_private
.boot_status
& WDIOF_OVERHEAT
)
571 printk(KERN_INFO PFX
"Card sensed a CPU Overheat\n");
573 if (pcipcwd_private
.boot_status
== 0)
574 printk(KERN_INFO PFX
"No previous trip detected - Cold boot or reset\n");
576 /* Check that the heartbeat value is within it's range ; if not reset to the default */
577 if (pcipcwd_set_heartbeat(heartbeat
)) {
578 pcipcwd_set_heartbeat(WATCHDOG_HEARTBEAT
);
579 printk(KERN_INFO PFX
"heartbeat value must be 0<heartbeat<65536, using %d\n",
583 ret
= register_reboot_notifier(&pcipcwd_notifier
);
585 printk(KERN_ERR PFX
"cannot register reboot notifier (err=%d)\n",
587 goto err_out_release_region
;
590 if (pcipcwd_private
.supports_temp
) {
591 ret
= misc_register(&pcipcwd_temp_miscdev
);
593 printk(KERN_ERR PFX
"cannot register miscdev on minor=%d (err=%d)\n",
595 goto err_out_unregister_reboot
;
599 ret
= misc_register(&pcipcwd_miscdev
);
601 printk(KERN_ERR PFX
"cannot register miscdev on minor=%d (err=%d)\n",
602 WATCHDOG_MINOR
, ret
);
603 goto err_out_misc_deregister
;
606 printk(KERN_INFO PFX
"initialized. heartbeat=%d sec (nowayout=%d)\n",
607 heartbeat
, nowayout
);
611 err_out_misc_deregister
:
612 if (pcipcwd_private
.supports_temp
)
613 misc_deregister(&pcipcwd_temp_miscdev
);
614 err_out_unregister_reboot
:
615 unregister_reboot_notifier(&pcipcwd_notifier
);
616 err_out_release_region
:
617 pci_release_regions(pdev
);
618 err_out_disable_device
:
619 pci_disable_device(pdev
);
623 static void __devexit
pcipcwd_card_exit(struct pci_dev
*pdev
)
625 /* Stop the timer before we leave */
630 misc_deregister(&pcipcwd_miscdev
);
631 if (pcipcwd_private
.supports_temp
)
632 misc_deregister(&pcipcwd_temp_miscdev
);
633 unregister_reboot_notifier(&pcipcwd_notifier
);
634 pci_release_regions(pdev
);
635 pci_disable_device(pdev
);
639 static struct pci_device_id pcipcwd_pci_tbl
[] = {
640 { PCI_VENDOR_ID_QUICKLOGIC
, PCI_DEVICE_ID_WATCHDOG_PCIPCWD
,
641 PCI_ANY_ID
, PCI_ANY_ID
, },
642 { 0 }, /* End of list */
644 MODULE_DEVICE_TABLE(pci
, pcipcwd_pci_tbl
);
646 static struct pci_driver pcipcwd_driver
= {
647 .name
= WATCHDOG_NAME
,
648 .id_table
= pcipcwd_pci_tbl
,
649 .probe
= pcipcwd_card_init
,
650 .remove
= __devexit_p(pcipcwd_card_exit
),
653 static int __init
pcipcwd_init_module(void)
655 spin_lock_init (&pcipcwd_private
.io_lock
);
657 return pci_register_driver(&pcipcwd_driver
);
660 static void __exit
pcipcwd_cleanup_module(void)
662 pci_unregister_driver(&pcipcwd_driver
);
665 module_init(pcipcwd_init_module
);
666 module_exit(pcipcwd_cleanup_module
);
668 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
669 MODULE_DESCRIPTION("Berkshire PCI-PC Watchdog driver");
670 MODULE_LICENSE("GPL");
671 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);
672 MODULE_ALIAS_MISCDEV(TEMP_MINOR
);