/*      $NetBSD: tco.c,v 1.10 2023/04/12 06:39:15 riastradh 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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: tco.c,v 1.10 2023/04/12 06:39:15 riastradh Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/timetc.h>
#include <sys/module.h>

#include <dev/pci/pcivar.h>
#include <dev/pci/pcireg.h>
#include <dev/ic/i82801lpcreg.h>

#include <dev/sysmon/sysmonvar.h>

#include <arch/x86/pci/tco.h>

#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;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.