/* $NetBSD: tco.c,v 1.9.4.1 2023/08/01 14:06:36 martin Exp $ */ /*- * Copyright (c) 2015 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Minoura Makoto and Matthew R. Green. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * Intel I/O Controller Hub (ICHn) watchdog timer */ #include __KERNEL_RCSID(0, "$NetBSD: tco.c,v 1.9.4.1 2023/08/01 14:06:36 martin Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include "pcibvar.h" struct tco_softc { struct sysmon_wdog sc_smw; bus_space_tag_t sc_pmt; bus_space_handle_t sc_pmh; bus_space_tag_t sc_rcbat; bus_space_handle_t sc_rcbah; struct pcib_softc * sc_pcib; pci_chipset_tag_t sc_pc; bus_space_tag_t sc_tcot; bus_space_handle_t sc_tcoh; int (*sc_set_noreboot)(device_t, bool); int sc_armed; unsigned int sc_min_t; unsigned int sc_max_t; int sc_version; bool sc_attached; }; static int tco_match(device_t, cfdata_t, void *); static void tco_attach(device_t, device_t, void *); static int tco_detach(device_t, int); static bool tco_suspend(device_t, const pmf_qual_t *); static int tcotimer_setmode(struct sysmon_wdog *); static int tcotimer_tickle(struct sysmon_wdog *); static void tcotimer_stop(struct tco_softc *); static void tcotimer_start(struct tco_softc *); static void tcotimer_status_reset(struct tco_softc *); static int tcotimer_disable_noreboot(device_t); CFATTACH_DECL3_NEW(tco, sizeof(struct tco_softc), tco_match, tco_attach, tco_detach, NULL, NULL, NULL, 0); /* * Autoconf callbacks. */ static int tco_match(device_t parent, cfdata_t match, void *aux) { struct tco_attach_args *ta = aux; switch (ta->ta_version) { case TCO_VERSION_SMBUS: break; case TCO_VERSION_RCBA: case TCO_VERSION_PCIB: if (ta->ta_pmt == 0) return 0; break; default: return 0; } return 1; } static void tco_attach(device_t parent, device_t self, void *aux) { struct tco_softc *sc = device_private(self); struct tco_attach_args *ta = aux; uint32_t ioreg; /* Retrieve bus info shared with parent/siblings */ sc->sc_version = ta->ta_version; sc->sc_pmt = ta->ta_pmt; sc->sc_pmh = ta->ta_pmh; sc->sc_rcbat = ta->ta_rcbat; sc->sc_rcbah = ta->ta_rcbah; sc->sc_pcib = ta->ta_pcib; aprint_normal(": TCO (watchdog) timer configured.\n"); aprint_naive("\n"); switch (sc->sc_version) { case TCO_VERSION_SMBUS: sc->sc_tcot = ta->ta_tcot; sc->sc_tcoh = ta->ta_tcoh; sc->sc_set_noreboot = ta->ta_set_noreboot; break; case TCO_VERSION_RCBA: case TCO_VERSION_PCIB: sc->sc_tcot = sc->sc_pmt; if (bus_space_subregion(sc->sc_pmt, sc->sc_pmh, PMC_TCO_BASE, TCO_REGSIZE, &sc->sc_tcoh)) { aprint_error_dev(self, "failed to map TCO\n"); return; } break; } /* Explicitly stop the TCO timer. */ tcotimer_stop(sc); /* * Enable TCO timeout SMI only if the hardware reset does not * work. We don't know what the SMBIOS does. */ ioreg = bus_space_read_4(sc->sc_pmt, sc->sc_pmh, PMC_SMI_EN); aprint_debug_dev(self, "SMI_EN=0x%08x\n", ioreg); ioreg &= ~PMC_SMI_EN_TCO_EN; /* * Clear the No Reboot (NR) bit. If this fails, enabling the TCO_EN bit * in the SMI_EN register is the last chance. */ if (tcotimer_disable_noreboot(self)) { ioreg |= PMC_SMI_EN_TCO_EN; } if ((ioreg & PMC_SMI_EN_GBL_SMI_EN) != 0) { aprint_debug_dev(self, "SMI_EN:=0x%08x\n", ioreg); bus_space_write_4(sc->sc_pmt, sc->sc_pmh, PMC_SMI_EN, ioreg); aprint_debug_dev(self, "SMI_EN=0x%08x\n", bus_space_read_4(sc->sc_pmt, sc->sc_pmh, PMC_SMI_EN)); } /* Reset the watchdog status registers. */ tcotimer_status_reset(sc); /* * Register the driver with the sysmon watchdog framework. */ sc->sc_smw.smw_name = device_xname(self); sc->sc_smw.smw_cookie = sc; sc->sc_smw.smw_setmode = tcotimer_setmode; sc->sc_smw.smw_tickle = tcotimer_tickle; /* * ICH6 or newer are limited to 2ticks min and 613ticks max. * 1sec 367secs * * ICH5 or older are limited to 4ticks min and 39ticks max. * 2secs 23secs */ switch (sc->sc_version) { case TCO_VERSION_SMBUS: case TCO_VERSION_RCBA: sc->sc_max_t = TCOTIMER2_MAX_TICK; sc->sc_min_t = TCOTIMER2_MIN_TICK; break; case TCO_VERSION_PCIB: sc->sc_max_t = TCOTIMER_MAX_TICK; sc->sc_min_t = TCOTIMER_MIN_TICK; break; } sc->sc_smw.smw_period = tcotimer_tick_to_second(sc->sc_max_t); aprint_verbose_dev(self, "Min/Max interval %u/%u seconds\n", tcotimer_tick_to_second(sc->sc_min_t), tcotimer_tick_to_second(sc->sc_max_t)); if (sysmon_wdog_register(&sc->sc_smw)) aprint_error_dev(self, "unable to register TCO timer" "as a sysmon watchdog device.\n"); if (!pmf_device_register(self, tco_suspend, NULL)) aprint_error_dev(self, "unable to register with pmf\n"); sc->sc_attached = true; } static int tco_detach(device_t self, int flags) { struct tco_softc *sc = device_private(self); int rc; if (!sc->sc_attached) return 0; if ((rc = sysmon_wdog_unregister(&sc->sc_smw)) != 0) { if (rc == ERESTART) rc = EINTR; return rc; } /* Explicitly stop the TCO timer. */ tcotimer_stop(sc); /* XXX Set No Reboot? */ pmf_device_deregister(self); return 0; } static bool tco_suspend(device_t self, const pmf_qual_t *quals) { struct tco_softc *sc = device_private(self); /* Allow suspend only if watchdog is not armed */ return ((sc->sc_smw.smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED); } /* * Sysmon watchdog callbacks. */ static int tcotimer_setmode(struct sysmon_wdog *smw) { struct tco_softc *sc = smw->smw_cookie; unsigned int period; uint16_t ich6period = 0; uint8_t ich5period = 0; if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) { /* Stop the TCO timer. */ tcotimer_stop(sc); } else { period = tcotimer_second_to_tick(smw->smw_period); if (period < sc->sc_min_t || period > sc->sc_max_t) return EINVAL; /* Stop the TCO timer, */ tcotimer_stop(sc); /* set the timeout, */ switch (sc->sc_version) { case TCO_VERSION_SMBUS: case TCO_VERSION_RCBA: /* ICH6 or newer */ ich6period = bus_space_read_2(sc->sc_tcot, sc->sc_tcoh, TCO_TMR2); ich6period &= 0xfc00; bus_space_write_2(sc->sc_tcot, sc->sc_tcoh, TCO_TMR2, ich6period | period); break; case TCO_VERSION_PCIB: /* ICH5 or older */ ich5period = bus_space_read_1(sc->sc_tcot, sc->sc_tcoh, TCO_TMR); ich5period &= 0xc0; bus_space_write_1(sc->sc_tcot, sc->sc_tcoh, TCO_TMR, ich5period | period); break; } /* and start/reload the timer. */ tcotimer_start(sc); tcotimer_tickle(smw); } return 0; } static int tcotimer_tickle(struct sysmon_wdog *smw) { struct tco_softc *sc = smw->smw_cookie; /* any value is allowed */ switch (sc->sc_version) { case TCO_VERSION_SMBUS: case TCO_VERSION_RCBA: bus_space_write_2(sc->sc_tcot, sc->sc_tcoh, TCO_RLD, 1); break; case TCO_VERSION_PCIB: bus_space_write_1(sc->sc_tcot, sc->sc_tcoh, TCO_RLD, 1); break; } return 0; } static void tcotimer_stop(struct tco_softc *sc) { uint16_t ioreg; ioreg = bus_space_read_2(sc->sc_tcot, sc->sc_tcoh, TCO1_CNT); ioreg |= TCO1_CNT_TCO_TMR_HLT; bus_space_write_2(sc->sc_tcot, sc->sc_tcoh, TCO1_CNT, ioreg); } static void tcotimer_start(struct tco_softc *sc) { uint16_t ioreg; ioreg = bus_space_read_2(sc->sc_tcot, sc->sc_tcoh, TCO1_CNT); ioreg &= ~TCO1_CNT_TCO_TMR_HLT; bus_space_write_2(sc->sc_tcot, sc->sc_tcoh, TCO1_CNT, ioreg); } static void tcotimer_status_reset(struct tco_softc *sc) { bus_space_write_2(sc->sc_tcot, sc->sc_tcoh, TCO1_STS, TCO1_STS_TIMEOUT); bus_space_write_2(sc->sc_tcot, sc->sc_tcoh, TCO2_STS, TCO2_STS_BOOT_STS); bus_space_write_2(sc->sc_tcot, sc->sc_tcoh, TCO2_STS, TCO2_STS_SECONDS_TO_STS); } /* * Clear the No Reboot (NR) bit, this enables reboots when the timer * reaches the timeout for the second time. */ static int tcotimer_disable_noreboot(device_t self) { struct tco_softc *sc = device_private(self); int error = EINVAL; switch (sc->sc_version) { case TCO_VERSION_SMBUS: error = (*sc->sc_set_noreboot)(self, false); if (error) goto error; break; case TCO_VERSION_RCBA: { uint32_t status; status = bus_space_read_4(sc->sc_rcbat, sc->sc_rcbah, LPCIB_GCS_OFFSET); status &= ~LPCIB_GCS_NO_REBOOT; bus_space_write_4(sc->sc_rcbat, sc->sc_rcbah, LPCIB_GCS_OFFSET, status); status = bus_space_read_4(sc->sc_rcbat, sc->sc_rcbah, LPCIB_GCS_OFFSET); if (status & LPCIB_GCS_NO_REBOOT) goto error; break; } case TCO_VERSION_PCIB: { pcireg_t pcireg; pcireg = pci_conf_read(sc->sc_pcib->sc_pc, sc->sc_pcib->sc_tag, LPCIB_PCI_GEN_STA); if (pcireg & LPCIB_PCI_GEN_STA_NO_REBOOT) { /* TCO timeout reset is disabled; try to enable it */ pcireg &= ~LPCIB_PCI_GEN_STA_NO_REBOOT; pci_conf_write(sc->sc_pcib->sc_pc, sc->sc_pcib->sc_tag, LPCIB_PCI_GEN_STA, pcireg); if (pcireg & LPCIB_PCI_GEN_STA_NO_REBOOT) goto error; } break; } } return 0; error: aprint_error_dev(self, "TCO timer reboot disabled by hardware; " "hope SMBIOS properly handles it.\n"); return error; } MODULE(MODULE_CLASS_DRIVER, tco, "sysmon_wdog"); #ifdef _MODULE #include "ioconf.c" #endif static int tco_modcmd(modcmd_t cmd, void *arg) { int ret = 0; switch (cmd) { case MODULE_CMD_INIT: #ifdef _MODULE ret = config_init_component(cfdriver_ioconf_tco, cfattach_ioconf_tco, cfdata_ioconf_tco); #endif break; case MODULE_CMD_FINI: #ifdef _MODULE ret = config_fini_component(cfdriver_ioconf_tco, cfattach_ioconf_tco, cfdata_ioconf_tco); #endif break; default: ret = ENOTTY; } return ret; }