1 /* 2 * Berkshire PCI-PC Watchdog Card Driver 3 * 4 * (c) Copyright 2003-2007 Wim Van Sebroeck <wim@iguana.be>. 5 * 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@lxorguk.ukuu.org.uk>, 10 * Matt Domsch <Matt_Domsch@dell.com>, 11 * Rob Radez <rob@osinvestor.com> 12 * 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. 17 * 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. 21 */ 22 23 /* 24 * A bells and whistles driver is available from: 25 * http://www.kernel.org/pub/linux/kernel/people/wim/pcwd/pcwd_pci/ 26 * 27 * More info available at 28 * http://www.berkprod.com/ or http://www.pcwatchdog.com/ 29 */ 30 31 /* 32 * Includes, defines, variables, module parameters, ... 33 */ 34 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/... */ 50 #include <linux/uaccess.h> /* For copy_to_user/put_user/... */ 51 #include <linux/io.h> /* For inb/outb/... */ 52 53 /* Module and version information */ 54 #define WATCHDOG_VERSION "1.03" 55 #define WATCHDOG_DRIVER_NAME "PCI-PC Watchdog" 56 #define WATCHDOG_NAME "pcwd_pci" 57 #define PFX WATCHDOG_NAME ": " 58 #define DRIVER_VERSION WATCHDOG_DRIVER_NAME " driver, v" WATCHDOG_VERSION "\n" 59 60 /* Stuff for the PCI ID's */ 61 #ifndef PCI_VENDOR_ID_QUICKLOGIC 62 #define PCI_VENDOR_ID_QUICKLOGIC 0x11e3 63 #endif 64 65 #ifndef PCI_DEVICE_ID_WATCHDOG_PCIPCWD 66 #define PCI_DEVICE_ID_WATCHDOG_PCIPCWD 0x5030 67 #endif 68 69 /* 70 * These are the defines that describe the control status bits for the 71 * PCI-PC Watchdog card. 72 */ 73 /* Port 1 : Control Status #1 */ 74 #define WD_PCI_WTRP 0x01 /* Watchdog Trip status */ 75 #define WD_PCI_HRBT 0x02 /* Watchdog Heartbeat */ 76 #define WD_PCI_TTRP 0x04 /* Temperature Trip status */ 77 #define WD_PCI_RL2A 0x08 /* Relay 2 Active */ 78 #define WD_PCI_RL1A 0x10 /* Relay 1 Active */ 79 #define WD_PCI_R2DS 0x40 /* Relay 2 Disable Temperature-trip / 80 reset */ 81 #define WD_PCI_RLY2 0x80 /* Activate Relay 2 on the board */ 82 /* Port 2 : Control Status #2 */ 83 #define WD_PCI_WDIS 0x10 /* Watchdog Disable */ 84 #define WD_PCI_ENTP 0x20 /* Enable Temperature Trip Reset */ 85 #define WD_PCI_WRSP 0x40 /* Watchdog wrote response */ 86 #define WD_PCI_PCMD 0x80 /* PC has sent command */ 87 88 /* according to documentation max. time to process a command for the pci 89 * watchdog card is 100 ms, so we give it 150 ms to do it's job */ 90 #define PCI_COMMAND_TIMEOUT 150 91 92 /* Watchdog's internal commands */ 93 #define CMD_GET_STATUS 0x04 94 #define CMD_GET_FIRMWARE_VERSION 0x08 95 #define CMD_READ_WATCHDOG_TIMEOUT 0x18 96 #define CMD_WRITE_WATCHDOG_TIMEOUT 0x19 97 #define CMD_GET_CLEAR_RESET_COUNT 0x84 98 99 /* Watchdog's Dip Switch heartbeat values */ 100 static const int heartbeat_tbl[] = { 101 5, /* OFF-OFF-OFF = 5 Sec */ 102 10, /* OFF-OFF-ON = 10 Sec */ 103 30, /* OFF-ON-OFF = 30 Sec */ 104 60, /* OFF-ON-ON = 1 Min */ 105 300, /* ON-OFF-OFF = 5 Min */ 106 600, /* ON-OFF-ON = 10 Min */ 107 1800, /* ON-ON-OFF = 30 Min */ 108 3600, /* ON-ON-ON = 1 hour */ 109 }; 110 111 /* We can only use 1 card due to the /dev/watchdog restriction */ 112 static int cards_found; 113 114 /* internal variables */ 115 static int temp_panic; 116 static unsigned long is_active; 117 static char expect_release; 118 /* this is private data for each PCI-PC watchdog card */ 119 static struct { 120 /* Wether or not the card has a temperature device */ 121 int supports_temp; 122 /* The card's boot status */ 123 int boot_status; 124 /* The cards I/O address */ 125 unsigned long io_addr; 126 /* the lock for io operations */ 127 spinlock_t io_lock; 128 /* the PCI-device */ 129 struct pci_dev *pdev; 130 } pcipcwd_private; 131 132 /* module parameters */ 133 #define QUIET 0 /* Default */ 134 #define VERBOSE 1 /* Verbose */ 135 #define DEBUG 2 /* print fancy stuff too */ 136 static int debug = QUIET; 137 module_param(debug, int, 0); 138 MODULE_PARM_DESC(debug, "Debug level: 0=Quiet, 1=Verbose, 2=Debug (default=0)"); 139 140 #define WATCHDOG_HEARTBEAT 0 /* default heartbeat = 141 delay-time from dip-switches */ 142 static int heartbeat = WATCHDOG_HEARTBEAT; 143 module_param(heartbeat, int, 0); 144 MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. " 145 "(0<heartbeat<65536 or 0=delay-time from dip-switches, default=" 146 __MODULE_STRING(WATCHDOG_HEARTBEAT) ")"); 147 148 static int nowayout = WATCHDOG_NOWAYOUT; 149 module_param(nowayout, int, 0); 150 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" 151 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 152 153 /* 154 * Internal functions 155 */ 156 157 static int send_command(int cmd, int *msb, int *lsb) 158 { 159 int got_response, count; 160 161 if (debug >= DEBUG) 162 printk(KERN_DEBUG PFX "sending following data " 163 "cmd=0x%02x msb=0x%02x lsb=0x%02x\n", cmd, *msb, *lsb); 164 165 spin_lock(&pcipcwd_private.io_lock); 166 /* If a command requires data it should be written first. 167 * Data for commands with 8 bits of data should be written to port 4. 168 * Commands with 16 bits of data, should be written as LSB to port 4 169 * and MSB to port 5. 170 * After the required data has been written then write the command to 171 * port 6. */ 172 outb_p(*lsb, pcipcwd_private.io_addr + 4); 173 outb_p(*msb, pcipcwd_private.io_addr + 5); 174 outb_p(cmd, pcipcwd_private.io_addr + 6); 175 176 /* wait till the pci card processed the command, signaled by 177 * the WRSP bit in port 2 and give it a max. timeout of 178 * PCI_COMMAND_TIMEOUT to process */ 179 got_response = inb_p(pcipcwd_private.io_addr + 2) & WD_PCI_WRSP; 180 for (count = 0; (count < PCI_COMMAND_TIMEOUT) && (!got_response); 181 count++) { 182 mdelay(1); 183 got_response = inb_p(pcipcwd_private.io_addr + 2) & WD_PCI_WRSP; 184 } 185 186 if (debug >= DEBUG) { 187 if (got_response) { 188 printk(KERN_DEBUG PFX 189 "time to process command was: %d ms\n", 190 count); 191 } else { 192 printk(KERN_DEBUG PFX 193 "card did not respond on command!\n"); 194 } 195 } 196 197 if (got_response) { 198 /* read back response */ 199 *lsb = inb_p(pcipcwd_private.io_addr + 4); 200 *msb = inb_p(pcipcwd_private.io_addr + 5); 201 202 /* clear WRSP bit */ 203 inb_p(pcipcwd_private.io_addr + 6); 204 205 if (debug >= DEBUG) 206 printk(KERN_DEBUG PFX "received following data for " 207 "cmd=0x%02x: msb=0x%02x lsb=0x%02x\n", 208 cmd, *msb, *lsb); 209 } 210 211 spin_unlock(&pcipcwd_private.io_lock); 212 213 return got_response; 214 } 215 216 static inline void pcipcwd_check_temperature_support(void) 217 { 218 if (inb_p(pcipcwd_private.io_addr) != 0xF0) 219 pcipcwd_private.supports_temp = 1; 220 } 221 222 static int pcipcwd_get_option_switches(void) 223 { 224 int option_switches; 225 226 option_switches = inb_p(pcipcwd_private.io_addr + 3); 227 return option_switches; 228 } 229 230 static void pcipcwd_show_card_info(void) 231 { 232 int got_fw_rev, fw_rev_major, fw_rev_minor; 233 char fw_ver_str[20]; /* The cards firmware version */ 234 int option_switches; 235 236 got_fw_rev = send_command(CMD_GET_FIRMWARE_VERSION, &fw_rev_major, 237 &fw_rev_minor); 238 if (got_fw_rev) 239 sprintf(fw_ver_str, "%u.%02u", fw_rev_major, fw_rev_minor); 240 else 241 sprintf(fw_ver_str, "<card no answer>"); 242 243 /* Get switch settings */ 244 option_switches = pcipcwd_get_option_switches(); 245 246 printk(KERN_INFO PFX "Found card at port " 247 "0x%04x (Firmware: %s) %s temp option\n", 248 (int) pcipcwd_private.io_addr, fw_ver_str, 249 (pcipcwd_private.supports_temp ? "with" : "without")); 250 251 printk(KERN_INFO PFX "Option switches (0x%02x): " 252 "Temperature Reset Enable=%s, Power On Delay=%s\n", 253 option_switches, 254 ((option_switches & 0x10) ? "ON" : "OFF"), 255 ((option_switches & 0x08) ? "ON" : "OFF")); 256 257 if (pcipcwd_private.boot_status & WDIOF_CARDRESET) 258 printk(KERN_INFO PFX 259 "Previous reset was caused by the Watchdog card\n"); 260 261 if (pcipcwd_private.boot_status & WDIOF_OVERHEAT) 262 printk(KERN_INFO PFX "Card sensed a CPU Overheat\n"); 263 264 if (pcipcwd_private.boot_status == 0) 265 printk(KERN_INFO PFX 266 "No previous trip detected - Cold boot or reset\n"); 267 } 268 269 static int pcipcwd_start(void) 270 { 271 int stat_reg; 272 273 spin_lock(&pcipcwd_private.io_lock); 274 outb_p(0x00, pcipcwd_private.io_addr + 3); 275 udelay(1000); 276 277 stat_reg = inb_p(pcipcwd_private.io_addr + 2); 278 spin_unlock(&pcipcwd_private.io_lock); 279 280 if (stat_reg & WD_PCI_WDIS) { 281 printk(KERN_ERR PFX "Card timer not enabled\n"); 282 return -1; 283 } 284 285 if (debug >= VERBOSE) 286 printk(KERN_DEBUG PFX "Watchdog started\n"); 287 288 return 0; 289 } 290 291 static int pcipcwd_stop(void) 292 { 293 int stat_reg; 294 295 spin_lock(&pcipcwd_private.io_lock); 296 outb_p(0xA5, pcipcwd_private.io_addr + 3); 297 udelay(1000); 298 299 outb_p(0xA5, pcipcwd_private.io_addr + 3); 300 udelay(1000); 301 302 stat_reg = inb_p(pcipcwd_private.io_addr + 2); 303 spin_unlock(&pcipcwd_private.io_lock); 304 305 if (!(stat_reg & WD_PCI_WDIS)) { 306 printk(KERN_ERR PFX 307 "Card did not acknowledge disable attempt\n"); 308 return -1; 309 } 310 311 if (debug >= VERBOSE) 312 printk(KERN_DEBUG PFX "Watchdog stopped\n"); 313 314 return 0; 315 } 316 317 static int pcipcwd_keepalive(void) 318 { 319 /* Re-trigger watchdog by writing to port 0 */ 320 spin_lock(&pcipcwd_private.io_lock); 321 outb_p(0x42, pcipcwd_private.io_addr); /* send out any data */ 322 spin_unlock(&pcipcwd_private.io_lock); 323 324 if (debug >= DEBUG) 325 printk(KERN_DEBUG PFX "Watchdog keepalive signal send\n"); 326 327 return 0; 328 } 329 330 static int pcipcwd_set_heartbeat(int t) 331 { 332 int t_msb = t / 256; 333 int t_lsb = t % 256; 334 335 if ((t < 0x0001) || (t > 0xFFFF)) 336 return -EINVAL; 337 338 /* Write new heartbeat to watchdog */ 339 send_command(CMD_WRITE_WATCHDOG_TIMEOUT, &t_msb, &t_lsb); 340 341 heartbeat = t; 342 if (debug >= VERBOSE) 343 printk(KERN_DEBUG PFX "New heartbeat: %d\n", 344 heartbeat); 345 346 return 0; 347 } 348 349 static int pcipcwd_get_status(int *status) 350 { 351 int control_status; 352 353 *status = 0; 354 control_status = inb_p(pcipcwd_private.io_addr + 1); 355 if (control_status & WD_PCI_WTRP) 356 *status |= WDIOF_CARDRESET; 357 if (control_status & WD_PCI_TTRP) { 358 *status |= WDIOF_OVERHEAT; 359 if (temp_panic) 360 panic(PFX "Temperature overheat trip!\n"); 361 } 362 363 if (debug >= DEBUG) 364 printk(KERN_DEBUG PFX "Control Status #1: 0x%02x\n", 365 control_status); 366 367 return 0; 368 } 369 370 static int pcipcwd_clear_status(void) 371 { 372 int control_status; 373 int msb; 374 int reset_counter; 375 376 if (debug >= VERBOSE) 377 printk(KERN_INFO PFX "clearing watchdog trip status & LED\n"); 378 379 control_status = inb_p(pcipcwd_private.io_addr + 1); 380 381 if (debug >= DEBUG) { 382 printk(KERN_DEBUG PFX "status was: 0x%02x\n", control_status); 383 printk(KERN_DEBUG PFX "sending: 0x%02x\n", 384 (control_status & WD_PCI_R2DS) | WD_PCI_WTRP); 385 } 386 387 /* clear trip status & LED and keep mode of relay 2 */ 388 outb_p((control_status & WD_PCI_R2DS) | WD_PCI_WTRP, 389 pcipcwd_private.io_addr + 1); 390 391 /* clear reset counter */ 392 msb = 0; 393 reset_counter = 0xff; 394 send_command(CMD_GET_CLEAR_RESET_COUNT, &msb, &reset_counter); 395 396 if (debug >= DEBUG) { 397 printk(KERN_DEBUG PFX "reset count was: 0x%02x\n", 398 reset_counter); 399 } 400 401 return 0; 402 } 403 404 static int pcipcwd_get_temperature(int *temperature) 405 { 406 *temperature = 0; 407 if (!pcipcwd_private.supports_temp) 408 return -ENODEV; 409 410 spin_lock(&pcipcwd_private.io_lock); 411 *temperature = inb_p(pcipcwd_private.io_addr); 412 spin_unlock(&pcipcwd_private.io_lock); 413 414 /* 415 * Convert celsius to fahrenheit, since this was 416 * the decided 'standard' for this return value. 417 */ 418 *temperature = (*temperature * 9 / 5) + 32; 419 420 if (debug >= DEBUG) { 421 printk(KERN_DEBUG PFX "temperature is: %d F\n", 422 *temperature); 423 } 424 425 return 0; 426 } 427 428 static int pcipcwd_get_timeleft(int *time_left) 429 { 430 int msb; 431 int lsb; 432 433 /* Read the time that's left before rebooting */ 434 /* Note: if the board is not yet armed then we will read 0xFFFF */ 435 send_command(CMD_READ_WATCHDOG_TIMEOUT, &msb, &lsb); 436 437 *time_left = (msb << 8) + lsb; 438 439 if (debug >= VERBOSE) 440 printk(KERN_DEBUG PFX "Time left before next reboot: %d\n", 441 *time_left); 442 443 return 0; 444 } 445 446 /* 447 * /dev/watchdog handling 448 */ 449 450 static ssize_t pcipcwd_write(struct file *file, const char __user *data, 451 size_t len, loff_t *ppos) 452 { 453 /* See if we got the magic character 'V' and reload the timer */ 454 if (len) { 455 if (!nowayout) { 456 size_t i; 457 458 /* note: just in case someone wrote the magic character 459 * five months ago... */ 460 expect_release = 0; 461 462 /* scan to see whether or not we got the 463 * magic character */ 464 for (i = 0; i != len; i++) { 465 char c; 466 if (get_user(c, data + i)) 467 return -EFAULT; 468 if (c == 'V') 469 expect_release = 42; 470 } 471 } 472 473 /* someone wrote to us, we should reload the timer */ 474 pcipcwd_keepalive(); 475 } 476 return len; 477 } 478 479 static long pcipcwd_ioctl(struct file *file, unsigned int cmd, 480 unsigned long arg) 481 { 482 void __user *argp = (void __user *)arg; 483 int __user *p = argp; 484 static struct watchdog_info ident = { 485 .options = WDIOF_OVERHEAT | 486 WDIOF_CARDRESET | 487 WDIOF_KEEPALIVEPING | 488 WDIOF_SETTIMEOUT | 489 WDIOF_MAGICCLOSE, 490 .firmware_version = 1, 491 .identity = WATCHDOG_DRIVER_NAME, 492 }; 493 494 switch (cmd) { 495 case WDIOC_GETSUPPORT: 496 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0; 497 498 case WDIOC_GETSTATUS: 499 { 500 int status; 501 pcipcwd_get_status(&status); 502 return put_user(status, p); 503 } 504 505 case WDIOC_GETBOOTSTATUS: 506 return put_user(pcipcwd_private.boot_status, p); 507 508 case WDIOC_GETTEMP: 509 { 510 int temperature; 511 512 if (pcipcwd_get_temperature(&temperature)) 513 return -EFAULT; 514 515 return put_user(temperature, p); 516 } 517 518 case WDIOC_SETOPTIONS: 519 { 520 int new_options, retval = -EINVAL; 521 522 if (get_user(new_options, p)) 523 return -EFAULT; 524 525 if (new_options & WDIOS_DISABLECARD) { 526 if (pcipcwd_stop()) 527 return -EIO; 528 retval = 0; 529 } 530 531 if (new_options & WDIOS_ENABLECARD) { 532 if (pcipcwd_start()) 533 return -EIO; 534 retval = 0; 535 } 536 537 if (new_options & WDIOS_TEMPPANIC) { 538 temp_panic = 1; 539 retval = 0; 540 } 541 542 return retval; 543 } 544 545 case WDIOC_KEEPALIVE: 546 pcipcwd_keepalive(); 547 return 0; 548 549 case WDIOC_SETTIMEOUT: 550 { 551 int new_heartbeat; 552 553 if (get_user(new_heartbeat, p)) 554 return -EFAULT; 555 556 if (pcipcwd_set_heartbeat(new_heartbeat)) 557 return -EINVAL; 558 559 pcipcwd_keepalive(); 560 /* Fall */ 561 } 562 563 case WDIOC_GETTIMEOUT: 564 return put_user(heartbeat, p); 565 566 case WDIOC_GETTIMELEFT: 567 { 568 int time_left; 569 570 if (pcipcwd_get_timeleft(&time_left)) 571 return -EFAULT; 572 573 return put_user(time_left, p); 574 } 575 576 default: 577 return -ENOTTY; 578 } 579 } 580 581 static int pcipcwd_open(struct inode *inode, struct file *file) 582 { 583 /* /dev/watchdog can only be opened once */ 584 if (test_and_set_bit(0, &is_active)) { 585 if (debug >= VERBOSE) 586 printk(KERN_ERR PFX 587 "Attempt to open already opened device.\n"); 588 return -EBUSY; 589 } 590 591 /* Activate */ 592 pcipcwd_start(); 593 pcipcwd_keepalive(); 594 return nonseekable_open(inode, file); 595 } 596 597 static int pcipcwd_release(struct inode *inode, struct file *file) 598 { 599 /* 600 * Shut off the timer. 601 */ 602 if (expect_release == 42) { 603 pcipcwd_stop(); 604 } else { 605 printk(KERN_CRIT PFX 606 "Unexpected close, not stopping watchdog!\n"); 607 pcipcwd_keepalive(); 608 } 609 expect_release = 0; 610 clear_bit(0, &is_active); 611 return 0; 612 } 613 614 /* 615 * /dev/temperature handling 616 */ 617 618 static ssize_t pcipcwd_temp_read(struct file *file, char __user *data, 619 size_t len, loff_t *ppos) 620 { 621 int temperature; 622 623 if (pcipcwd_get_temperature(&temperature)) 624 return -EFAULT; 625 626 if (copy_to_user(data, &temperature, 1)) 627 return -EFAULT; 628 629 return 1; 630 } 631 632 static int pcipcwd_temp_open(struct inode *inode, struct file *file) 633 { 634 if (!pcipcwd_private.supports_temp) 635 return -ENODEV; 636 637 return nonseekable_open(inode, file); 638 } 639 640 static int pcipcwd_temp_release(struct inode *inode, struct file *file) 641 { 642 return 0; 643 } 644 645 /* 646 * Notify system 647 */ 648 649 static int pcipcwd_notify_sys(struct notifier_block *this, unsigned long code, 650 void *unused) 651 { 652 if (code == SYS_DOWN || code == SYS_HALT) 653 pcipcwd_stop(); /* Turn the WDT off */ 654 655 return NOTIFY_DONE; 656 } 657 658 /* 659 * Kernel Interfaces 660 */ 661 662 static const struct file_operations pcipcwd_fops = { 663 .owner = THIS_MODULE, 664 .llseek = no_llseek, 665 .write = pcipcwd_write, 666 .unlocked_ioctl = pcipcwd_ioctl, 667 .open = pcipcwd_open, 668 .release = pcipcwd_release, 669 }; 670 671 static struct miscdevice pcipcwd_miscdev = { 672 .minor = WATCHDOG_MINOR, 673 .name = "watchdog", 674 .fops = &pcipcwd_fops, 675 }; 676 677 static const struct file_operations pcipcwd_temp_fops = { 678 .owner = THIS_MODULE, 679 .llseek = no_llseek, 680 .read = pcipcwd_temp_read, 681 .open = pcipcwd_temp_open, 682 .release = pcipcwd_temp_release, 683 }; 684 685 static struct miscdevice pcipcwd_temp_miscdev = { 686 .minor = TEMP_MINOR, 687 .name = "temperature", 688 .fops = &pcipcwd_temp_fops, 689 }; 690 691 static struct notifier_block pcipcwd_notifier = { 692 .notifier_call = pcipcwd_notify_sys, 693 }; 694 695 /* 696 * Init & exit routines 697 */ 698 699 static int __devinit pcipcwd_card_init(struct pci_dev *pdev, 700 const struct pci_device_id *ent) 701 { 702 int ret = -EIO; 703 704 cards_found++; 705 if (cards_found == 1) 706 printk(KERN_INFO PFX DRIVER_VERSION); 707 708 if (cards_found > 1) { 709 printk(KERN_ERR PFX "This driver only supports 1 device\n"); 710 return -ENODEV; 711 } 712 713 if (pci_enable_device(pdev)) { 714 printk(KERN_ERR PFX "Not possible to enable PCI Device\n"); 715 return -ENODEV; 716 } 717 718 if (pci_resource_start(pdev, 0) == 0x0000) { 719 printk(KERN_ERR PFX "No I/O-Address for card detected\n"); 720 ret = -ENODEV; 721 goto err_out_disable_device; 722 } 723 724 pcipcwd_private.pdev = pdev; 725 pcipcwd_private.io_addr = pci_resource_start(pdev, 0); 726 727 if (pci_request_regions(pdev, WATCHDOG_NAME)) { 728 printk(KERN_ERR PFX "I/O address 0x%04x already in use\n", 729 (int) pcipcwd_private.io_addr); 730 ret = -EIO; 731 goto err_out_disable_device; 732 } 733 734 /* get the boot_status */ 735 pcipcwd_get_status(&pcipcwd_private.boot_status); 736 737 /* clear the "card caused reboot" flag */ 738 pcipcwd_clear_status(); 739 740 /* disable card */ 741 pcipcwd_stop(); 742 743 /* Check whether or not the card supports the temperature device */ 744 pcipcwd_check_temperature_support(); 745 746 /* Show info about the card itself */ 747 pcipcwd_show_card_info(); 748 749 /* If heartbeat = 0 then we use the heartbeat from the dip-switches */ 750 if (heartbeat == 0) 751 heartbeat = 752 heartbeat_tbl[(pcipcwd_get_option_switches() & 0x07)]; 753 754 /* Check that the heartbeat value is within it's range ; 755 * if not reset to the default */ 756 if (pcipcwd_set_heartbeat(heartbeat)) { 757 pcipcwd_set_heartbeat(WATCHDOG_HEARTBEAT); 758 printk(KERN_INFO PFX 759 "heartbeat value must be 0<heartbeat<65536, using %d\n", 760 WATCHDOG_HEARTBEAT); 761 } 762 763 ret = register_reboot_notifier(&pcipcwd_notifier); 764 if (ret != 0) { 765 printk(KERN_ERR PFX 766 "cannot register reboot notifier (err=%d)\n", ret); 767 goto err_out_release_region; 768 } 769 770 if (pcipcwd_private.supports_temp) { 771 ret = misc_register(&pcipcwd_temp_miscdev); 772 if (ret != 0) { 773 printk(KERN_ERR PFX "cannot register miscdev on " 774 "minor=%d (err=%d)\n", TEMP_MINOR, ret); 775 goto err_out_unregister_reboot; 776 } 777 } 778 779 ret = misc_register(&pcipcwd_miscdev); 780 if (ret != 0) { 781 printk(KERN_ERR PFX 782 "cannot register miscdev on minor=%d (err=%d)\n", 783 WATCHDOG_MINOR, ret); 784 goto err_out_misc_deregister; 785 } 786 787 printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n", 788 heartbeat, nowayout); 789 790 return 0; 791 792 err_out_misc_deregister: 793 if (pcipcwd_private.supports_temp) 794 misc_deregister(&pcipcwd_temp_miscdev); 795 err_out_unregister_reboot: 796 unregister_reboot_notifier(&pcipcwd_notifier); 797 err_out_release_region: 798 pci_release_regions(pdev); 799 err_out_disable_device: 800 pci_disable_device(pdev); 801 return ret; 802 } 803 804 static void __devexit pcipcwd_card_exit(struct pci_dev *pdev) 805 { 806 /* Stop the timer before we leave */ 807 if (!nowayout) 808 pcipcwd_stop(); 809 810 /* Deregister */ 811 misc_deregister(&pcipcwd_miscdev); 812 if (pcipcwd_private.supports_temp) 813 misc_deregister(&pcipcwd_temp_miscdev); 814 unregister_reboot_notifier(&pcipcwd_notifier); 815 pci_release_regions(pdev); 816 pci_disable_device(pdev); 817 cards_found--; 818 } 819 820 static struct pci_device_id pcipcwd_pci_tbl[] = { 821 { PCI_VENDOR_ID_QUICKLOGIC, PCI_DEVICE_ID_WATCHDOG_PCIPCWD, 822 PCI_ANY_ID, PCI_ANY_ID, }, 823 { 0 }, /* End of list */ 824 }; 825 MODULE_DEVICE_TABLE(pci, pcipcwd_pci_tbl); 826 827 static struct pci_driver pcipcwd_driver = { 828 .name = WATCHDOG_NAME, 829 .id_table = pcipcwd_pci_tbl, 830 .probe = pcipcwd_card_init, 831 .remove = __devexit_p(pcipcwd_card_exit), 832 }; 833 834 static int __init pcipcwd_init_module(void) 835 { 836 spin_lock_init(&pcipcwd_private.io_lock); 837 838 return pci_register_driver(&pcipcwd_driver); 839 } 840 841 static void __exit pcipcwd_cleanup_module(void) 842 { 843 pci_unregister_driver(&pcipcwd_driver); 844 845 printk(KERN_INFO PFX "Watchdog Module Unloaded.\n"); 846 } 847 848 module_init(pcipcwd_init_module); 849 module_exit(pcipcwd_cleanup_module); 850 851 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>"); 852 MODULE_DESCRIPTION("Berkshire PCI-PC Watchdog driver"); 853 MODULE_LICENSE("GPL"); 854 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 855 MODULE_ALIAS_MISCDEV(TEMP_MINOR); 856