/* $NetBSD: acpi_tz.c,v 1.91 2022/05/22 11:27:35 andvar Exp $ */

/*
 * Copyright (c) 2003 Jared D. McNeill <jmcneill@invisible.ca>
 * All rights reserved.
 *
 * 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. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */

/*
 * ACPI Thermal Zone driver
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: acpi_tz.c,v 1.91 2022/05/22 11:27:35 andvar Exp $");

#include <sys/param.h>
#include <sys/device.h>
#include <sys/callout.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/systm.h>
#include <sys/kmem.h>
#include <sys/cpu.h>

#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>
#include <dev/acpi/acpi_power.h>

#define _COMPONENT              ACPI_TZ_COMPONENT
ACPI_MODULE_NAME                ("acpi_tz")

#define ACPI_NOTIFY_TZ_ZONE     0x80
#define ACPI_NOTIFY_TZ_TRIP     0x81
#define ACPI_NOTIFY_TZ_DEVLIST  0x82

#define ATZ_F_CRITICAL          0x01    /* zone critical */
#define ATZ_F_HOT               0x02    /* zone hot */
#define ATZ_F_PASSIVE           0x04    /* zone passive cooling */
#define ATZ_F_PASSIVEONLY       0x08    /* zone is passive cooling only */

#define ATZ_ACTIVE_NONE           -1

/*
 * The constants are as follows:
 *
 *   ATZ_TZP_RATE       default polling interval (30 seconds) if no _TZP
 *   ATZ_NLEVELS        number of cooling levels for _ACx and _ALx
 *   ATZ_ZEROC          0 C, measured in 0.1 Kelvin
 *   ATZ_TMP_INVALID    temporarily invalid temperature
 *   ATZ_ZONE_EXPIRE    zone info refetch interval (15 minutes)
 */
#define ATZ_TZP_RATE            300
#define ATZ_NLEVELS             10
#define ATZ_ZEROC               2732
#define ATZ_TMP_INVALID         0xffffffff
#define ATZ_ZONE_EXPIRE         9000

/*
 * All temperatures are reported in 0.1 Kelvin.
 * The ACPI specification assumes that K = C + 273.2
 * rather than the nominal 273.15 used by envsys(4).
 */
#define ATZ2UKELVIN(t) ((t) * 100000 - 50000)

struct acpitz_zone {
        ACPI_BUFFER              al[ATZ_NLEVELS];
        uint32_t                 ac[ATZ_NLEVELS];
        uint32_t                 crt;
        uint32_t                 hot;
        uint32_t                 rtv;
        uint32_t                 psv;
        uint32_t                 tc1;
        uint32_t                 tc2;
        uint32_t                 tmp;
        uint32_t                 prevtmp;
        uint32_t                 tzp;
        uint32_t                 fanmin;
        uint32_t                 fanmax;
        uint32_t                 fancurrent;
};

struct acpitz_softc {
        struct acpi_devnode     *sc_node;
        struct sysmon_envsys    *sc_sme;
        struct acpitz_zone       sc_zone;
        struct callout           sc_callout;
        envsys_data_t            sc_temp_sensor;
        envsys_data_t            sc_fan_sensor;
        int                      sc_active;
        int                      sc_flags;
        int                      sc_zone_expire;
        bool                     sc_first;
        bool                     sc_have_fan;
        struct cpu_info        **sc_psl;
        size_t                   sc_psl_size;
};

static int              acpitz_match(device_t, cfdata_t, void *);
static void             acpitz_attach(device_t, device_t, void *);
static int              acpitz_detach(device_t, int);
static void             acpitz_get_status(void *);
static void             acpitz_get_zone(void *, int);
static void             acpitz_get_zone_quiet(void *);
static char            *acpitz_celcius_string(int);
static void             acpitz_power_off(struct acpitz_softc *);
static void             acpitz_power_zone(struct acpitz_softc *, int, int);
static void             acpitz_sane_temp(uint32_t *tmp);
static ACPI_STATUS      acpitz_switch_cooler(ACPI_OBJECT *, void *);
static void             acpitz_notify_handler(ACPI_HANDLE, uint32_t, void *);
static int              acpitz_get_integer(device_t, const char *, uint32_t *);
static void             acpitz_tick(void *);
static void             acpitz_init_envsys(device_t);
static void             acpitz_get_limits(struct sysmon_envsys *,
                                          envsys_data_t *,
                                          sysmon_envsys_lim_t *, uint32_t *);
static int              acpitz_get_fanspeed(device_t, uint32_t *,
                                            uint32_t *, uint32_t *);
#ifdef notyet
static ACPI_STATUS      acpitz_set_fanspeed(device_t, uint32_t);
#endif
static void             acpitz_print_processor_list(device_t);

CFATTACH_DECL_NEW(acpitz, sizeof(struct acpitz_softc),
    acpitz_match, acpitz_attach, acpitz_detach, NULL);

/*
 * acpitz_match: autoconf(9) match routine
 */
static int
acpitz_match(device_t parent, cfdata_t match, void *aux)
{
        struct acpi_attach_args *aa = aux;

        if (aa->aa_node->ad_type != ACPI_TYPE_THERMAL)
                return 0;

        return 1;
}

/*
 * acpitz_attach: autoconf(9) attach routine
 */
static void
acpitz_attach(device_t parent, device_t self, void *aux)
{
        struct acpitz_softc *sc = device_private(self);
        struct acpi_attach_args *aa = aux;
        ACPI_INTEGER val;
        ACPI_STATUS rv;

        sc->sc_first = true;
        sc->sc_have_fan = false;
        sc->sc_node = aa->aa_node;
        sc->sc_zone.tzp = ATZ_TZP_RATE;

        aprint_naive("\n");
        acpitz_print_processor_list(self);
        aprint_normal("\n");

        /*
         * The _TZP (ACPI 4.0, p. 430) defines the recommended
         * polling interval (in tenths of seconds). A value zero
         * means that polling "should not be necessary".
         */
        rv = acpi_eval_integer(sc->sc_node->ad_handle, "_TZP", &val);

        if (ACPI_SUCCESS(rv) && val != 0)
                sc->sc_zone.tzp = val;

        aprint_debug_dev(self, "polling interval %d.%d seconds\n",
            sc->sc_zone.tzp / 10, sc->sc_zone.tzp % 10);

        sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp;

        /*
         * XXX: The fan controls seen here are available on
         *      some HP laptops. Arguably these should not
         *      appear in a generic device driver like this.
         */
        if (acpitz_get_fanspeed(self, &sc->sc_zone.fanmin,
                &sc->sc_zone.fanmax, &sc->sc_zone.fancurrent) == 0)
                sc->sc_have_fan = true;

        acpitz_get_zone(self, 1);
        acpitz_get_status(self);

        (void)pmf_device_register(self, NULL, NULL);
        (void)acpi_power_register(sc->sc_node->ad_handle);
        (void)acpi_register_notify(sc->sc_node, acpitz_notify_handler);

        callout_init(&sc->sc_callout, CALLOUT_MPSAFE);
        callout_setfunc(&sc->sc_callout, acpitz_tick, self);

        acpitz_init_envsys(self);

        callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10);
}

static int
acpitz_detach(device_t self, int flags)
{
        struct acpitz_softc *sc = device_private(self);
        ACPI_HANDLE hdl;
        ACPI_BUFFER al;
        ACPI_STATUS rv;
        int i;

        callout_halt(&sc->sc_callout, NULL);
        callout_destroy(&sc->sc_callout);

        pmf_device_deregister(self);
        acpi_deregister_notify(sc->sc_node);

        /*
         * Although the device itself should not contain any power
         * resources, we have possibly used the resources of active
         * cooling devices. To unregister these, first fetch a fresh
         * active cooling zone, and then detach the resources from
         * the reference handles contained in the cooling zone.
         */
        acpitz_get_zone(self, 0);

        for (i = 0; i < ATZ_NLEVELS; i++) {

                if (sc->sc_zone.al[i].Pointer == NULL)
                        continue;

                al = sc->sc_zone.al[i];
                rv = acpi_eval_reference_handle(al.Pointer, &hdl);

                if (ACPI_SUCCESS(rv))
                        acpi_power_deregister(hdl);

                ACPI_FREE(sc->sc_zone.al[i].Pointer);
        }

        if (sc->sc_psl)
                kmem_free(sc->sc_psl, sc->sc_psl_size);

        if (sc->sc_sme != NULL)
                sysmon_envsys_unregister(sc->sc_sme);

        return 0;
}

static void
acpitz_get_zone_quiet(void *opaque)
{
        acpitz_get_zone(opaque, 0);
}

static void
acpitz_get_status(void *opaque)
{
        device_t dv = opaque;
        struct acpitz_softc *sc = device_private(dv);
        uint32_t tmp, fmin, fmax, fcurrent;
        int active, changed, flags, i;

        sc->sc_zone_expire--;

        if (sc->sc_zone_expire <= 0) {
                sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp;

                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                        "%s: zone refetch forced\n", device_xname(dv)));

                acpitz_get_zone(dv, 0);
        }

        if (acpitz_get_integer(dv, "_TMP", &tmp) != 0)
                return;

        sc->sc_zone.prevtmp = sc->sc_zone.tmp;
        sc->sc_zone.tmp = tmp;

        if (sc->sc_first != false)
                sc->sc_zone.prevtmp = tmp; /* XXX: Sanity check? */

        if (acpitz_get_fanspeed(dv, &fmin, &fmax, &fcurrent) == 0) {

                if (fcurrent != ATZ_TMP_INVALID)
                        sc->sc_zone.fancurrent = fcurrent;
        }

        sc->sc_temp_sensor.state = ENVSYS_SVALID;
        sc->sc_temp_sensor.value_cur = ATZ2UKELVIN(sc->sc_zone.tmp);

        sc->sc_fan_sensor.state = ENVSYS_SVALID;
        sc->sc_fan_sensor.value_cur = sc->sc_zone.fancurrent;

        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: zone temperature is %s C\n",
                device_xname(dv), acpitz_celcius_string(sc->sc_zone.tmp)));

        /*
         * XXX: Passive cooling is not yet supported.
         */
        if ((sc->sc_flags & ATZ_F_PASSIVEONLY) != 0)
                return;

        /*
         * As noted in ACPI 4.0 (p. 420), the temperature
         * thresholds are conveyed in the optional _ACx
         * object (x = 0 ... 9). The smaller the x, the
         * greater the cooling level. We prefer to keep
         * the highest cooling mode when in "active".
         */
        active = ATZ_ACTIVE_NONE;

        for (i = ATZ_NLEVELS - 1; i >= 0; i--) {

                if (sc->sc_zone.ac[i] == ATZ_TMP_INVALID)
                        continue;

                if (sc->sc_zone.ac[i] <= tmp)
                        active = i;
        }

        flags = sc->sc_flags & ~(ATZ_F_CRITICAL | ATZ_F_HOT | ATZ_F_PASSIVE);

        if (sc->sc_zone.psv != ATZ_TMP_INVALID && tmp >= sc->sc_zone.psv)
                flags |= ATZ_F_PASSIVE;

        if (sc->sc_zone.hot != ATZ_TMP_INVALID && tmp >= sc->sc_zone.hot)
                flags |= ATZ_F_HOT;

        if (sc->sc_zone.crt != ATZ_TMP_INVALID && tmp >= sc->sc_zone.crt)
                flags |= ATZ_F_CRITICAL;

        if (flags != sc->sc_flags) {

                changed = (sc->sc_flags ^ flags) & flags;
                sc->sc_flags = flags;

                if ((changed & ATZ_F_CRITICAL) != 0) {
                        sc->sc_temp_sensor.state = ENVSYS_SCRITOVER;

                        aprint_debug_dev(dv, "zone went critical, %s C\n",
                            acpitz_celcius_string(tmp));

                } else if ((changed & ATZ_F_HOT) != 0) {
                        sc->sc_temp_sensor.state = ENVSYS_SCRITOVER;

                        aprint_debug_dev(dv, "zone went hot, %s C\n",
                            acpitz_celcius_string(tmp));
                }
        }

        /* Power on the fans. */
        if (sc->sc_active != active) {

                if (sc->sc_active != ATZ_ACTIVE_NONE)
                        acpitz_power_zone(sc, sc->sc_active, 0);

                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: active cooling "
                        "level %d\n", device_xname(dv), active));

                if (active != ATZ_ACTIVE_NONE)
                        acpitz_power_zone(sc, active, 1);

                sc->sc_active = active;
        }
}

static char *
acpitz_celcius_string(int dk)
{
        static char buf[10];
        int dc;

        dc = abs(dk - ATZ_ZEROC);

        (void)snprintf(buf, sizeof(buf), "%s%d.%d",
            (dk >= ATZ_ZEROC) ? "" : "-", dc / 10, dc % 10);

        return buf;
}

static ACPI_STATUS
acpitz_switch_cooler(ACPI_OBJECT *obj, void *arg)
{
        int flag, pwr_state;
        ACPI_HANDLE cooler;
        ACPI_STATUS rv;

        /*
         * The _ALx object is a package in which the elements
         * are reference handles to an active cooling device
         * (typically PNP0C0B, ACPI fan device). Try to turn
         * on (or off) the power resources behind these handles
         * to start (or terminate) the active cooling.
         */
        flag = *(int *)arg;
        pwr_state = (flag != 0) ? ACPI_STATE_D0 : ACPI_STATE_D3;

        rv = acpi_eval_reference_handle(obj, &cooler);

        if (ACPI_FAILURE(rv))
                return rv;

        (void)acpi_power_set(cooler, pwr_state);

        return AE_OK;
}

/*
 * acpitz_power_zone:
 *
 *      Power on or off the i:th part of the zone zone.
 */
static void
acpitz_power_zone(struct acpitz_softc *sc, int i, int on)
{

        KASSERT(i >= 0 && i < ATZ_NLEVELS);

        (void)acpi_foreach_package_object(sc->sc_zone.al[i].Pointer,
            acpitz_switch_cooler, &on);
}


/*
 * acpitz_power_off:
 *
 *      Power off parts of the zone.
 */
static void
acpitz_power_off(struct acpitz_softc *sc)
{
        int i;

        for (i = 0 ; i < ATZ_NLEVELS; i++) {

                if (sc->sc_zone.al[i].Pointer == NULL)
                        continue;

                acpitz_power_zone(sc, i, 0);
        }

        sc->sc_active = ATZ_ACTIVE_NONE;
        sc->sc_flags &= ~(ATZ_F_CRITICAL | ATZ_F_HOT | ATZ_F_PASSIVE);
}

static void
acpitz_get_zone(void *opaque, int verbose)
{
        device_t dv = opaque;
        struct acpitz_softc *sc = device_private(dv);
        int comma, i, valid_levels;
        ACPI_OBJECT *obj;
        ACPI_STATUS rv;
        char buf[5];

        if (sc->sc_first != true) {
                acpitz_power_off(sc);

                for (i = 0; i < ATZ_NLEVELS; i++) {

                        if (sc->sc_zone.al[i].Pointer != NULL)
                                ACPI_FREE(sc->sc_zone.al[i].Pointer);

                        sc->sc_zone.al[i].Pointer = NULL;
                }
        }

        valid_levels = 0;

        for (i = 0; i < ATZ_NLEVELS; i++) {

                (void)snprintf(buf, sizeof(buf), "_AC%d", i);

                if (acpitz_get_integer(dv, buf, &sc->sc_zone.ac[i]))
                        continue;

                (void)snprintf(buf, sizeof(buf), "_AL%d", i);

                rv = acpi_eval_struct(sc->sc_node->ad_handle, buf,
                    &sc->sc_zone.al[i]);

                if (ACPI_FAILURE(rv)) {
                        sc->sc_zone.al[i].Pointer = NULL;
                        continue;
                }

                obj = sc->sc_zone.al[i].Pointer;

                if (obj->Type != ACPI_TYPE_PACKAGE || obj->Package.Count == 0) {
                        sc->sc_zone.al[i].Pointer = NULL;
                        ACPI_FREE(obj);
                        continue;
                }

                if (sc->sc_first != false)
                        aprint_normal_dev(dv, "active cooling level %d: %sC\n",
                            i, acpitz_celcius_string(sc->sc_zone.ac[i]));

                valid_levels++;
        }

        /*
         * A brief summary (ACPI 4.0, section 11.4):
         *
         *    _TMP : current temperature (in tenths of degrees)
         *    _CRT : critical trip-point at which to shutdown
         *    _HOT : critical trip-point at which to go to S4
         *    _PSV : passive cooling policy threshold
         *    _TC1 : thermal constant for passive cooling
         *    _TC2 : thermal constant for passive cooling
         */
        (void)acpitz_get_integer(dv, "_TMP", &sc->sc_zone.tmp);
        (void)acpitz_get_integer(dv, "_CRT", &sc->sc_zone.crt);
        (void)acpitz_get_integer(dv, "_HOT", &sc->sc_zone.hot);
        (void)acpitz_get_integer(dv, "_PSV", &sc->sc_zone.psv);
        (void)acpitz_get_integer(dv, "_TC1", &sc->sc_zone.tc1);
        (void)acpitz_get_integer(dv, "_TC2", &sc->sc_zone.tc2);

        /*
         * If _RTV is not present or present and zero,
         * values are absolute (see ACPI 4.0, 425).
         */
        acpitz_get_integer(dv, "_RTV", &sc->sc_zone.rtv);

        if (sc->sc_zone.rtv == ATZ_TMP_INVALID)
                sc->sc_zone.rtv = 0;

        acpitz_sane_temp(&sc->sc_zone.tmp);
        acpitz_sane_temp(&sc->sc_zone.crt);
        acpitz_sane_temp(&sc->sc_zone.hot);
        acpitz_sane_temp(&sc->sc_zone.psv);

        if (verbose != 0) {
                comma = 0;

                aprint_verbose_dev(dv, "levels: ");

                if (sc->sc_zone.crt != ATZ_TMP_INVALID) {
                        aprint_verbose("critical %s C",
                            acpitz_celcius_string(sc->sc_zone.crt));
                        comma = 1;
                }

                if (sc->sc_zone.hot != ATZ_TMP_INVALID) {
                        aprint_verbose("%shot %s C", comma ? ", " : "",
                            acpitz_celcius_string(sc->sc_zone.hot));
                        comma = 1;
                }

                if (sc->sc_zone.psv != ATZ_TMP_INVALID) {
                        aprint_verbose("%spassive %s C", comma ? ", " : "",
                            acpitz_celcius_string(sc->sc_zone.psv));
                        comma = 1;
                }

                if (valid_levels == 0) {
                        sc->sc_flags |= ATZ_F_PASSIVEONLY;

                        if (sc->sc_first != false)
                                aprint_verbose("%spassive cooling", comma ?
                                    ", " : "");
                }

                aprint_verbose("\n");
        }

        for (i = 0; i < ATZ_NLEVELS; i++)
                acpitz_sane_temp(&sc->sc_zone.ac[i]);

        acpitz_power_off(sc);
        sc->sc_first = false;
}

static void
acpitz_notify_handler(ACPI_HANDLE hdl, uint32_t notify, void *opaque)
{
        ACPI_OSD_EXEC_CALLBACK func = NULL;
        device_t dv = opaque;

        switch (notify) {

        case ACPI_NOTIFY_TZ_ZONE:
                func = acpitz_get_status;
                break;

        case ACPI_NOTIFY_TZ_TRIP:
        case ACPI_NOTIFY_TZ_DEVLIST:
                func = acpitz_get_zone_quiet;
                break;

        default:
                aprint_debug_dev(dv, "unknown notify 0x%02X\n", notify);
                return;
        }

        (void)AcpiOsExecute(OSL_NOTIFY_HANDLER, func, dv);
}

static void
acpitz_sane_temp(uint32_t *tmp)
{
        /* Sane temperatures are between 0 and 150 C. */
        if (*tmp < ATZ_ZEROC || *tmp > ATZ_ZEROC + 1500)
                *tmp = ATZ_TMP_INVALID;
}

static int
acpitz_get_integer(device_t dv, const char *cm, uint32_t *val)
{
        struct acpitz_softc *sc = device_private(dv);
        ACPI_INTEGER tmp;
        ACPI_STATUS rv;

        rv = acpi_eval_integer(sc->sc_node->ad_handle, cm, &tmp);

        if (ACPI_FAILURE(rv)) {
                *val = ATZ_TMP_INVALID;

                ACPI_DEBUG_PRINT((ACPI_DB_DEBUG_OBJECT,
                        "%s: failed to evaluate %s: %s\n",
                        device_xname(dv), cm, AcpiFormatException(rv)));

                return 1;
        }

        *val = tmp;

        return 0;
}

static int
acpitz_get_fanspeed(device_t dv,
    uint32_t *fanmin, uint32_t *fanmax, uint32_t *fancurrent)
{
        struct acpitz_softc *sc = device_private(dv);
        ACPI_INTEGER fmin, fmax, fcurr;
        ACPI_HANDLE handle;
        ACPI_STATUS rv;
        int rc = 0;

        handle = sc->sc_node->ad_handle;

        rv = acpi_eval_integer(handle, "FMIN", &fmin);

        if (ACPI_FAILURE(rv)) {
                fmin = ATZ_TMP_INVALID;
                rc = 1;
        }

        rv = acpi_eval_integer(handle, "FMAX", &fmax);

        if (ACPI_FAILURE(rv)) {
                fmax = ATZ_TMP_INVALID;
                rc = 1;
        }
        rv = acpi_eval_integer(handle, "FRSP", &fcurr);

        if (ACPI_FAILURE(rv)) {
                fcurr = ATZ_TMP_INVALID;
                rc = 1;
        }

        if (fanmin != NULL)
                *fanmin = fmin;

        if (fanmax != NULL)
                *fanmax = fmax;

        if (fancurrent != NULL)
                *fancurrent = fcurr;

        return rc;
}

#ifdef notyet
static ACPI_STATUS
acpitz_set_fanspeed(device_t dv, uint32_t fanspeed)
{
        struct acpitz_softc *sc = device_private(dv);
        ACPI_HANDLE handle;
        ACPI_STATUS rv;

        handle = sc->sc_node->ad_handle;

        rv = acpi_eval_set_integer(handle, "FSSP", fanspeed);

        if (ACPI_FAILURE(rv))
                aprint_debug_dev(dv, "failed to set fan speed to %u RPM: %s\n",
                    fanspeed, AcpiFormatException(rv));

        return rv;
}
#endif

static void
acpitz_print_processor_list(device_t dv)
{
        struct acpitz_softc *sc = device_private(dv);
        ACPI_HANDLE handle = sc->sc_node->ad_handle;
        ACPI_OBJECT *obj, *pref;
        ACPI_HANDLE prhandle;
        ACPI_BUFFER buf;
        ACPI_STATUS rv;
        struct cpu_info *ci;
        unsigned int i, cnt;

        rv = acpi_eval_struct(handle, "_PSL", &buf);

        if (ACPI_FAILURE(rv) || buf.Pointer == NULL)
                return;

        obj = buf.Pointer;

        if (obj->Type != ACPI_TYPE_PACKAGE || obj->Package.Count == 0)
                goto done;

        sc->sc_psl_size = sizeof(ci) * (obj->Package.Count + 1);
        sc->sc_psl = kmem_zalloc(sc->sc_psl_size, KM_SLEEP);
        for (cnt = i = 0; i < obj->Package.Count; i++) {

                pref = &obj->Package.Elements[i];
                rv = acpi_eval_reference_handle(pref, &prhandle);

                if (ACPI_FAILURE(rv))
                        continue;

                ci = acpi_match_cpu_handle(prhandle);

                if (ci == NULL)
                        continue;

                if (cnt == 0)
                        aprint_normal(":");

                aprint_normal(" %s", cpu_name(ci));

                sc->sc_psl[cnt] = ci;
                ++cnt;
        }

done:
        ACPI_FREE(buf.Pointer);
}

static void
acpitz_tick(void *opaque)
{
        device_t dv = opaque;
        struct acpitz_softc *sc = device_private(dv);

        (void)AcpiOsExecute(OSL_NOTIFY_HANDLER, acpitz_get_status, dv);

        callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10);
}

static void
acpitz_init_envsys(device_t dv)
{
        const int flags = ENVSYS_FMONLIMITS | ENVSYS_FMONNOTSUPP |
                          ENVSYS_FHAS_ENTROPY;
        struct acpitz_softc *sc = device_private(dv);
        unsigned int i;

        sc->sc_sme = sysmon_envsys_create();

        sc->sc_sme->sme_cookie = sc;
        sc->sc_sme->sme_name = device_xname(dv);
        sc->sc_sme->sme_flags = SME_DISABLE_REFRESH;
        sc->sc_sme->sme_get_limits = acpitz_get_limits;

        sc->sc_temp_sensor.flags = flags;
        sc->sc_temp_sensor.units = ENVSYS_STEMP;
        sc->sc_temp_sensor.state = ENVSYS_SINVALID;

        memset(sc->sc_temp_sensor.desc, 0, sizeof(sc->sc_temp_sensor.desc));
        if (sc->sc_psl) {
                for (i = 0; sc->sc_psl[i] != NULL; i++) {
                        if (i > 0)
                                strlcat(sc->sc_temp_sensor.desc, "/",
                                    sizeof(sc->sc_temp_sensor.desc));
                        strlcat(sc->sc_temp_sensor.desc,
                            device_xname(sc->sc_psl[i]->ci_dev),
                            sizeof(sc->sc_temp_sensor.desc));
                }
                strlcat(sc->sc_temp_sensor.desc, " ",
                    sizeof(sc->sc_temp_sensor.desc));
        }
        strlcat(sc->sc_temp_sensor.desc, "temperature",
            sizeof(sc->sc_temp_sensor.desc));

        if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_temp_sensor))
                goto out;

        if (sc->sc_have_fan != false) {

                sc->sc_fan_sensor.flags = flags;
                sc->sc_fan_sensor.units = ENVSYS_SFANRPM;
                sc->sc_fan_sensor.state = ENVSYS_SINVALID;

                (void)strlcpy(sc->sc_fan_sensor.desc,
                    "FAN", sizeof(sc->sc_fan_sensor.desc));

                /* Ignore error because fan sensor is optional. */
                (void)sysmon_envsys_sensor_attach(sc->sc_sme,
                    &sc->sc_fan_sensor);
        }

        if (sysmon_envsys_register(sc->sc_sme) == 0)
                return;

out:
        aprint_error_dev(dv, "unable to register with sysmon\n");

        sysmon_envsys_destroy(sc->sc_sme);
        sc->sc_sme = NULL;
}

static void
acpitz_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata,
                  sysmon_envsys_lim_t *limits, uint32_t *props)
{
        struct acpitz_softc *sc = sme->sme_cookie;

        switch (edata->units) {
        case ENVSYS_STEMP:
                *props = 0;
                if (sc->sc_zone.hot != ATZ_TMP_INVALID) {
                        *props |= PROP_CRITMAX;
                        limits->sel_critmax = ATZ2UKELVIN(sc->sc_zone.hot);
                } else if (sc->sc_zone.crt != ATZ_TMP_INVALID) {
                        *props |= PROP_CRITMAX;
                        limits->sel_critmax = ATZ2UKELVIN(sc->sc_zone.crt);
                }
                break;

        case ENVSYS_SFANRPM:
                *props = 0;
                if (sc->sc_zone.fanmin != ATZ_TMP_INVALID) {
                        *props |= PROP_WARNMIN;
                        limits->sel_warnmin = sc->sc_zone.fanmin;
                }
                if (sc->sc_zone.fanmax != ATZ_TMP_INVALID) {
                        *props |= PROP_WARNMAX;
                        limits->sel_warnmax = sc->sc_zone.fanmax;
                }
                break;
        }
}

MODULE(MODULE_CLASS_DRIVER, acpitz, "sysmon_envsys");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
acpitz_modcmd(modcmd_t cmd, void *aux)
{
        int rv = 0;

        switch (cmd) {

        case MODULE_CMD_INIT:

#ifdef _MODULE
                rv = config_init_component(cfdriver_ioconf_acpitz,
                    cfattach_ioconf_acpitz, cfdata_ioconf_acpitz);
#endif
                break;

        case MODULE_CMD_FINI:

#ifdef _MODULE
                rv = config_fini_component(cfdriver_ioconf_acpitz,
                    cfattach_ioconf_acpitz, cfdata_ioconf_acpitz);
#endif
                break;

        default:
                rv = ENOTTY;
        }

        return rv;
}