xref: /src/sys/dev/acpi/acpi_tz.c

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

/*
 * Copyright (c) 2003 Jared D. McNeill <jmcneill (at) 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;
}