/* * i810-tco 0.02: TCO timer driver for i810 chipsets * * (c) Copyright 2000 kernel concepts , All Rights Reserved. * http://www.kernelconcepts.de * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * * Neither kernel concepts nor Nils Faerber admit liability nor provide * warranty for any of this software. This material is provided * "AS-IS" and at no charge. * * (c) Copyright 2000 kernel concepts * developed for * Jentro AG, Haar/Munich (Germany) * * TCO timer driver for i810/i815 chipsets * based on softdog.c by Alan Cox * * The TCO timer is implemented in the 82801AA (82801AB) chip, * see intel documentation from http://developer.intel.com, * order number 290655-003 * * 20000710 Nils Faerber * Initial Version 0.01 * 20000728 Nils Faerber * 0.02 Fix for SMI_EN->TCO_EN bit, some cleanups */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "i810-tco.h" /* Just in case that the PCI vendor and device IDs are not yet defined */ #ifndef PCI_DEVICE_ID_INTEL_82801AA_0 #define PCI_DEVICE_ID_INTEL_82801AA_0 0x2410 #endif /* Default expire timeout */ #define TIMER_MARGIN 50 /* steps of 0.6sec, 2 0x3f || tmrval < 0x03) return -1; spin_lock(&tco_lock); val = inb (TCO1_TMR); val &= 0xc0; val |= tmrval; outb (val, TCO1_TMR); val = inb (TCO1_TMR); spin_unlock(&tco_lock); if ((val & 0x3f) != tmrval) return -1; return 0; } /* * Reload (trigger) the timer. Lock is needed so we dont reload it during * a reprogramming event */ static void tco_timer_reload (void) { spin_lock(&tco_lock); outb (0x01, TCO1_RLD); spin_unlock(&tco_lock); } /* * Read the current timer value */ static unsigned char tco_timer_read (void) { return (inb (TCO1_RLD)); } /* * Allow only one person to hold it open */ static int i810tco_open (struct inode *inode, struct file *file) { if (timer_alive) return -EBUSY; /* * Reload and activate timer */ tco_timer_reload (); tco_timer_start (); timer_alive = 1; return 0; } static int i810tco_release (struct inode *inode, struct file *file) { /* * Shut off the timer. */ #ifndef CONFIG_WATCHDOG_NOWAYOUT tco_timer_stop (); timer_alive = 0; #endif return 0; } static ssize_t i810tco_write (struct file *file, const char *data, size_t len, loff_t * ppos) { /* Can't seek (pwrite) on this device */ if (ppos != &file->f_pos) return -ESPIPE; /* * Refresh the timer. */ if (len) { tco_timer_reload (); return 1; } return 0; } static int i810tco_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int new_margin, u_margin; static struct watchdog_info ident = { WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING, 0, "i810 TCO timer" }; switch (cmd) { default: return -ENOTTY; case WDIOC_GETSUPPORT: if (copy_to_user ((struct watchdog_info *) arg, &ident, sizeof (ident))) return -EFAULT; return 0; case WDIOC_GETSTATUS: return put_user (tco_timer_read (), (unsigned int *) (int) arg); case WDIOC_GETBOOTSTATUS: return put_user (boot_status, (int *) arg); case WDIOC_KEEPALIVE: tco_timer_reload (); return 0; case WDIOC_SETTIMEOUT: if (get_user(u_margin, (int *) arg)) return -EFAULT; new_margin = (u_margin * 10 + 5) / 6; if ((new_margin < 3) || (new_margin > 63)) return -EINVAL; if (tco_timer_settimer((unsigned char)new_margin)) return -EINVAL; i810_margin = new_margin; tco_timer_reload(); /* Fall */ case WDIOC_GETTIMEOUT: return put_user((int)(i810_margin * 6 / 10), (int *) arg); } } /* * Data for PCI driver interface * * This data only exists for exporting the supported * PCI ids via MODULE_DEVICE_TABLE. We do not actually * register a pci_driver, because someone else might one day * want to register another driver on the same PCI id. */ static struct pci_device_id i810tco_pci_tbl[] __initdata = { { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_0, PCI_ANY_ID, PCI_ANY_ID, }, { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_0, PCI_ANY_ID, PCI_ANY_ID, }, { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0, PCI_ANY_ID, PCI_ANY_ID, }, { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_10, PCI_ANY_ID, PCI_ANY_ID, }, { 0, }, }; MODULE_DEVICE_TABLE (pci, i810tco_pci_tbl); static struct pci_dev *i810tco_pci; static unsigned char i810tco_getdevice (void) { struct pci_dev *dev; u8 val1, val2; u16 badr; /* * Find the PCI device */ pci_for_each_dev(dev) { if (pci_match_device(i810tco_pci_tbl, dev)) { i810tco_pci = dev; break; } } if (i810tco_pci) { /* * Find the ACPI base I/O address which is the base * for the TCO registers (TCOBASE=ACPIBASE + 0x60) * ACPIBASE is bits [15:7] from 0x40-0x43 */ pci_read_config_byte (i810tco_pci, 0x40, &val1); pci_read_config_byte (i810tco_pci, 0x41, &val2); badr = ((val2 << 1) | (val1 >> 7)) << 7; ACPIBASE = badr; /* Something's wrong here, ACPIBASE has to be set */ if (badr == 0x0001 || badr == 0x0000) { printk (KERN_ERR "i810tco init: failed to get TCOBASE address\n"); return 0; } /* * Check chipset's NO_REBOOT bit */ pci_read_config_byte (i810tco_pci, 0xd4, &val1); if (val1 & 0x02) { val1 &= 0xfd; pci_write_config_byte (i810tco_pci, 0xd4, val1); pci_read_config_byte (i810tco_pci, 0xd4, &val1); if (val1 & 0x02) { printk (KERN_ERR "i810tco init: failed to reset NO_REBOOT flag, reboot disabled by hardware\n"); return 0; /* Cannot reset NO_REBOOT bit */ } } /* Set the TCO_EN bit in SMI_EN register */ val1 = inb (SMI_EN + 1); val1 &= 0xdf; outb (val1, SMI_EN + 1); /* Clear out the (probably old) status */ outb (0, TCO1_STS); boot_status = (int) inb (TCO2_STS); outb (3, TCO2_STS); return 1; } return 0; } static struct file_operations i810tco_fops = { owner: THIS_MODULE, write: i810tco_write, ioctl: i810tco_ioctl, open: i810tco_open, release: i810tco_release, }; static struct miscdevice i810tco_miscdev = { WATCHDOG_MINOR, "watchdog", &i810tco_fops }; static int __init watchdog_init (void) { spin_lock_init(&tco_lock); if (!i810tco_getdevice () || i810tco_pci == NULL) return -ENODEV; if (!request_region (TCOBASE, 0x10, "i810 TCO")) { printk (KERN_ERR "i810 TCO timer: I/O address 0x%04x already in use\n", TCOBASE); return -EIO; } if (misc_register (&i810tco_miscdev) != 0) { release_region (TCOBASE, 0x10); printk (KERN_ERR "i810 TCO timer: cannot register miscdev\n"); return -EIO; } tco_timer_settimer ((unsigned char) i810_margin); tco_timer_reload (); printk (KERN_INFO "i810 TCO timer: V0.02, timer margin: %d sec (0x%04x)\n", (int) (i810_margin * 6 / 10), TCOBASE); return 0; } static void __exit watchdog_cleanup (void) { u8 val; /* Reset the timer before we leave */ tco_timer_reload (); /* Set the NO_REBOOT bit to prevent later reboots, just for sure */ pci_read_config_byte (i810tco_pci, 0xd4, &val); val |= 0x02; pci_write_config_byte (i810tco_pci, 0xd4, val); release_region (TCOBASE, 0x10); misc_deregister (&i810tco_miscdev); } module_init(watchdog_init); module_exit(watchdog_cleanup); MODULE_LICENSE("GPL");