io/tzmon/tzmon.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Solaris x86 ACPI ThermalZone Monitor
 */


#include <sys/errno.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ksynch.h>
#include <sys/uadmin.h>
#include <sys/acpi/acpi.h>
#include <sys/acpica.h>
#include <sys/sdt.h>

#include "tzmon.h"


#define	TZMON_ENUM_TRIP_POINTS	1
#define	TZMON_ENUM_DEV_LISTS	2
#define	TZMON_ENUM_ALL		(TZMON_ENUM_TRIP_POINTS	| TZMON_ENUM_DEV_LISTS)

/*
 * TZ_TASKQ_NAME_LEN is precisely the length of the string "AcpiThermalMonitor"
 * plus a two-digit instance number plus a NULL.  If the taskq name is changed
 * (particularly if it is lengthened), then this value needs to change.
 */
#define	TZ_TASKQ_NAME_LEN	21

/*
 * Kelvin to Celsius conversion
 * The formula for converting degrees Kelvin to degrees Celsius is
 * C = K - 273.15 (we round to 273.2).  The unit for thermal zone
 * temperatures is tenths of a degree Kelvin.  Use tenth of a degree
 * to convert, then make a whole number out of it.
 */
#define	K_TO_C(temp)		(((temp) - 2732) / 10)


/* cb_ops or dev_ops forward declarations */
static	int	tzmon_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd,
    void *arg, void **result);
static	int	tzmon_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static	int	tzmon_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);

/* other forward declarations */
static void tzmon_notify_zone(ACPI_HANDLE obj, UINT32 val, void *ctx);
static void tzmon_eval_int(ACPI_HANDLE obj, char *method, int *rv);
static thermal_zone_t *tzmon_alloc_zone();
static void tzmon_free_zone_list();
static void tzmon_discard_buffers(thermal_zone_t *tzp);
static void tzmon_enumerate_zone(ACPI_HANDLE obj, thermal_zone_t *tzp,
	int enum_flag);
static ACPI_STATUS tzmon_zone_callback(ACPI_HANDLE obj, UINT32 nest,
    void *ctx, void **rv);
static void tzmon_find_zones(void);
static void tzmon_monitor(void *ctx);
static void tzmon_set_power_device(ACPI_HANDLE dev, int on_off, char *tz_name);
static void tzmon_set_power(ACPI_BUFFER devlist, int on_off, char *tz_name);
static void tzmon_eval_zone(thermal_zone_t *tzp);
static void tzmon_do_shutdown(void);

extern void halt(char *);

static struct cb_ops	tzmon_cb_ops = {
	nodev,			/* no open routine	*/
	nodev,			/* no close routine	*/
	nodev,			/* not a block driver	*/
	nodev,			/* no print routine	*/
	nodev,			/* no dump routine	*/
	nodev,			/* no read routine	*/
	nodev,			/* no write routine	*/
	nodev,			/* no ioctl routine	*/
	nodev,			/* no devmap routine	*/
	nodev,			/* no mmap routine	*/
	nodev,			/* no segmap routine	*/
	nochpoll,		/* no chpoll routine	*/
	ddi_prop_op,
	0,			/* not a STREAMS driver	*/
	D_NEW | D_MP,		/* safe for multi-thread/multi-processor */
};

static struct dev_ops tzmon_ops = {
	DEVO_REV,		/* devo_rev */
	0,			/* devo_refcnt */
	tzmon_getinfo,		/* devo_getinfo */
	nulldev,		/* devo_identify */
	nulldev,		/* devo_probe */
	tzmon_attach,		/* devo_attach */
	tzmon_detach,		/* devo_detach */
	nodev,			/* devo_reset */
	&tzmon_cb_ops,		/* devo_cb_ops */
	(struct bus_ops *)0,	/* devo_bus_ops */
	NULL,			/* devo_power */
	ddi_quiesce_not_needed,		/* devo_quiesce */
};

extern	struct	mod_ops mod_driverops;

static	struct modldrv modldrv = {
	&mod_driverops,
	"ACPI Thermal Zone Monitor",
	&tzmon_ops,
};

static	struct modlinkage modlinkage = {
	MODREV_1,		/* MODREV_1 indicated by manual */
	(void *)&modldrv,
	NULL,			/* termination of list of linkage structures */
};

/* globals for this module */
static dev_info_t	*tzmon_dip;
static thermal_zone_t	*zone_list;
static int		zone_count;
static kmutex_t		zone_list_lock;
static kcondvar_t	zone_list_condvar;


/*
 * _init, _info, and _fini support loading and unloading the driver.
 */
int
_init(void)
{
	return (mod_install(&modlinkage));
}


int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}


int
_fini(void)
{
	return (mod_remove(&modlinkage));
}


static int
tzmon_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	if (cmd != DDI_ATTACH)
		return (DDI_FAILURE);

	if (tzmon_dip != NULL)
		return (DDI_FAILURE);

	/*
	 * Check to see if ACPI CA services are available
	 */
	if (AcpiSubsystemStatus() != AE_OK)
		return (DDI_FAILURE);

	mutex_init(&zone_list_lock, NULL, MUTEX_DRIVER, NULL);
	cv_init(&zone_list_condvar, NULL, CV_DRIVER, NULL);

	tzmon_find_zones();
	mutex_enter(&zone_list_lock);
	if (zone_count < 1) {
		mutex_exit(&zone_list_lock);
		mutex_destroy(&zone_list_lock);
		cv_destroy(&zone_list_condvar);
		return (DDI_FAILURE);
	}
	mutex_exit(&zone_list_lock);

	if (ddi_create_minor_node(dip, ddi_get_name(dip), S_IFCHR, 0,
	    DDI_PSEUDO, 0) == DDI_FAILURE) {
		tzmon_free_zone_list();
		mutex_destroy(&zone_list_lock);
		cv_destroy(&zone_list_condvar);
		return (DDI_FAILURE);
	}

	tzmon_dip = dip;

	ddi_report_dev(dip);

	return (DDI_SUCCESS);
}


/*ARGSUSED*/
static int
tzmon_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	int error;

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		*result = tzmon_dip;
		if (tzmon_dip == NULL)
			error = DDI_FAILURE;
		else
			error = DDI_SUCCESS;
		break;
	case DDI_INFO_DEVT2INSTANCE:
		*result = 0;
		error = DDI_SUCCESS;
		break;
	default:
		*result = NULL;
		error = DDI_FAILURE;
	}

	return (error);
}


static int
tzmon_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	thermal_zone_t *tzp = zone_list;

	if (cmd != DDI_DETACH)
		return (DDI_FAILURE);

	/* free allocated thermal zone name(s) */
	while (tzp != NULL) {
		AcpiOsFree(tzp->zone_name);
		tzp = tzp->next;
	}

	/* discard zone list assets */
	tzmon_free_zone_list();

	ddi_remove_minor_node(dip, NULL);
	tzmon_dip = NULL;

	mutex_destroy(&zone_list_lock);
	cv_destroy(&zone_list_condvar);

	return (DDI_SUCCESS);
}


/*
 * tzmon_notify_zone
 * Thermal zone notification handler.
 */
static void
tzmon_notify_zone(ACPI_HANDLE obj, UINT32 val, void *ctx)
{
	thermal_zone_t *tzp = (thermal_zone_t *)ctx;

	switch (val) {
	case 0x80:	/* Thermal Zone status changed */
		tzmon_eval_zone(tzp);
		break;
	case 0x81:	/* Thermal Zone trip points changed */
		tzmon_enumerate_zone(obj, tzp, TZMON_ENUM_TRIP_POINTS);
		break;
	case 0x82:	/* Device Lists changed */
		tzmon_enumerate_zone(obj, tzp, TZMON_ENUM_DEV_LISTS);
		break;
	case 0x83:	/* Thermal Relationship Table changed */
		/* not handling _TRT objects, so not handling this event */
		DTRACE_PROBE1(trt__change, char *, (char *)tzp->zone_name);
		break;
	default:
		break;
	}
}


/*
 * tzmon_eval_int
 * Evaluate the object/method as an integer.
 */
static void
tzmon_eval_int(ACPI_HANDLE obj, char *method, int *rv)
{

	if (acpica_eval_int(obj, method, rv) != AE_OK)
		*rv = -1;
}


/*
 * tzmon_alloc_zone
 * Allocate memory for the zone structure and initialize it lock mutex.
 */
static thermal_zone_t *
tzmon_alloc_zone()
{
	thermal_zone_t *tzp;

	tzp = kmem_zalloc(sizeof (thermal_zone_t), KM_SLEEP);
	mutex_init(&tzp->lock, NULL, MUTEX_DRIVER, NULL);

	return (tzp);
}


/*
 * tzmon_free_zone_list
 * Free the zone list, either because attach failed or detach initiated.
 */
static void
tzmon_free_zone_list()
{
	thermal_zone_t *tzp = zone_list;

	while (tzp != NULL) {
		thermal_zone_t *next;

		mutex_enter(&tzp->lock);

		/*
		 * Remove the notify handler for the zone.  Not much to
		 * do if this fails (since we are on our way out), so
		 * just ignore failure.
		 */
		(void) AcpiRemoveNotifyHandler(tzp->obj, ACPI_DEVICE_NOTIFY,
		    tzmon_notify_zone);

		/* Shut down monitor thread, if running */
		if (tzp->taskq != NULL) {
			tzp->polling_period = 0;
			cv_broadcast(&zone_list_condvar);

			/* Drop mutex to allow the thread to run */
			mutex_exit(&tzp->lock);
			ddi_taskq_destroy(tzp->taskq);
			mutex_enter(&tzp->lock);
		}

		tzmon_discard_buffers(tzp);
		mutex_exit(&tzp->lock);
		mutex_destroy(&tzp->lock);

		next = tzp->next;
		kmem_free(tzp, sizeof (thermal_zone_t));
		tzp = next;
	}
}


static void
tzmon_discard_buffers(thermal_zone_t *tzp)
{
	int level;

	for (level = 0; level < TZ_NUM_LEVELS; level++) {
		if (tzp->al[level].Pointer != NULL)
			AcpiOsFree(tzp->al[level].Pointer);
	}

	if (tzp->psl.Pointer != NULL)
		AcpiOsFree(tzp->psl.Pointer);
}


/*
 * tzmon_enumerate_zone
 * Enumerates the contents of a thermal zone and updates passed-in
 * thermal_zone or creates a new one if tzp is NULL. Newly-created
 * zones are linked into the global zone_list.
 */
static void
tzmon_enumerate_zone(ACPI_HANDLE obj, thermal_zone_t *tzp, int enum_flag)
{
	ACPI_STATUS status;
	ACPI_BUFFER zone_name;
	int	level;
	int	instance;
	char	abuf[5];

	/*
	 * Newly-created zones and existing zones both require
	 * some individual attention.
	 */
	if (tzp == NULL) {
		/* New zone required */
		tzp = tzmon_alloc_zone();
		mutex_enter(&zone_list_lock);
		tzp->next = zone_list;
		zone_list = tzp;

		/*
		 * It is exceedingly unlikely that instance will exceed 99.
		 * However, if it does, this will cause problems when
		 * creating the taskq for this thermal zone.
		 */
		instance = zone_count;
		zone_count++;
		mutex_exit(&zone_list_lock);
		mutex_enter(&tzp->lock);
		tzp->obj = obj;

		/*
		 * Set to a low level.  Will get set to the actual
		 * current power level when the thread monitor polls
		 * the current temperature.
		 */
		tzp->current_level = 0;

		/* Get the zone name in case we need to display it later */
		zone_name.Length = ACPI_ALLOCATE_BUFFER;
		zone_name.Pointer = NULL;

		status = AcpiGetName(obj, ACPI_FULL_PATHNAME, &zone_name);
		ASSERT(status == AE_OK);

		tzp->zone_name = zone_name.Pointer;

		status = AcpiInstallNotifyHandler(obj, ACPI_DEVICE_NOTIFY,
		    tzmon_notify_zone, (void *)tzp);
		ASSERT(status == AE_OK);
	} else {
		/* Existing zone - toss out allocated items */
		mutex_enter(&tzp->lock);
		ASSERT(tzp->obj == obj);

		if (enum_flag & TZMON_ENUM_DEV_LISTS)
			tzmon_discard_buffers(tzp);
	}

	if (enum_flag & TZMON_ENUM_TRIP_POINTS) {
		for (level = 0; level < TZ_NUM_LEVELS; level++) {
			(void) snprintf(abuf, 5, "_AC%d", level);
			tzmon_eval_int(obj, abuf, &tzp->ac[level]);

		}

		tzmon_eval_int(obj, "_CRT", &tzp->crt);
		tzmon_eval_int(obj, "_HOT", &tzp->hot);
		tzmon_eval_int(obj, "_PSV", &tzp->psv);
	}

	if (enum_flag & TZMON_ENUM_DEV_LISTS) {
		for (level = 0; level < TZ_NUM_LEVELS; level++) {
			if (tzp->ac[level] == -1) {
				tzp->al[level].Length = 0;
				tzp->al[level].Pointer = NULL;
			} else {
				(void) snprintf(abuf, 5, "_AL%d", level);
				tzp->al[level].Length = ACPI_ALLOCATE_BUFFER;
				tzp->al[level].Pointer = NULL;
				if (AcpiEvaluateObjectTyped(obj, abuf, NULL,
				    &tzp->al[level], ACPI_TYPE_PACKAGE) !=
				    AE_OK) {
					DTRACE_PROBE2(alx__missing, int, level,
					    char *, (char *)tzp->zone_name);

					tzp->al[level].Length = 0;
					tzp->al[level].Pointer = NULL;
				}
			}
		}

		tzp->psl.Length = ACPI_ALLOCATE_BUFFER;
		tzp->psl.Pointer = NULL;
		(void) AcpiEvaluateObjectTyped(obj, "_PSL", NULL, &tzp->psl,
		    ACPI_TYPE_PACKAGE);
	}

	tzmon_eval_int(obj, "_TC1", &tzp->tc1);
	tzmon_eval_int(obj, "_TC2", &tzp->tc2);
	tzmon_eval_int(obj, "_TSP", &tzp->tsp);
	tzmon_eval_int(obj, "_TZP", &tzp->tzp);

	if (tzp->tzp == 0) {
		tzp->polling_period = 0;
	} else {
		if (tzp->tzp < 0)
			tzp->polling_period = TZ_DEFAULT_PERIOD;
		else
			tzp->polling_period = tzp->tzp/10;

		/* start monitor thread if needed */
		if (tzp->taskq == NULL) {
			char taskq_name[TZ_TASKQ_NAME_LEN];

			(void) snprintf(taskq_name, TZ_TASKQ_NAME_LEN,
			    "AcpiThermalMonitor%02d", instance);
			tzp->taskq = ddi_taskq_create(tzmon_dip,
			    taskq_name, 1, TASKQ_DEFAULTPRI, 0);
			if (tzp->taskq == NULL) {
				tzp->polling_period = 0;
				cmn_err(CE_WARN, "tzmon: could not create "
				    "monitor thread for thermal zone %s - "
				    "monitor by notify only",
				    (char *)tzp->zone_name);
			} else {
				(void) ddi_taskq_dispatch(tzp->taskq,
				    tzmon_monitor, tzp, DDI_SLEEP);
			}
		}
	}

	mutex_exit(&tzp->lock);
}


/*
 * tzmon_zone_callback
 * Enumerate the thermal zone if it has a _TMP (current thermal zone
 * operating temperature) method.
 */
/*ARGSUSED*/
static ACPI_STATUS
tzmon_zone_callback(ACPI_HANDLE obj, UINT32 nest, void *ctx, void **rv)
{
	ACPI_HANDLE tmpobj;

	/*
	 * We get both ThermalZone() and Scope(\_TZ) objects here;
	 * look for _TMP (without which a zone is invalid) to pick
	 * between them (and ignore invalid zones)
	 */
	if (AcpiGetHandle(obj, "_TMP", &tmpobj) == AE_OK) {
		tzmon_enumerate_zone(obj, NULL, TZMON_ENUM_ALL);
	}

	return (AE_OK);
}


/*
 * tzmon_find_zones
 * Find all of the thermal zones by calling a ACPICA function that
 * walks the ACPI namespace and invokes a callback for each thermal
 * object found.
 */
static void
tzmon_find_zones()
{
	ACPI_STATUS status;
	int retval;

	status = AcpiWalkNamespace(ACPI_TYPE_THERMAL, ACPI_ROOT_OBJECT,
	    8, tzmon_zone_callback, NULL, NULL, (void **)&retval);

	ASSERT(status == AE_OK);
}


/*
 * tzmon_monitor
 * Run as a separate thread, this wakes according to polling period and
 * checks particular objects in the thermal zone.  One instance per
 * thermal zone.
 */
static void
tzmon_monitor(void *ctx)
{
	thermal_zone_t *tzp = (thermal_zone_t *)ctx;
	clock_t ticks;

	do {
		/* Check out the zone */
		tzmon_eval_zone(tzp);

		/* Go back to sleep */
		mutex_enter(&tzp->lock);
		ticks = drv_usectohz(tzp->polling_period * 1000000);
		if (ticks > 0)
			(void) cv_reltimedwait(&zone_list_condvar,
			    &tzp->lock, ticks, TR_CLOCK_TICK);
		mutex_exit(&tzp->lock);
	} while (ticks > 0);
}


/*
 * tzmon_set_power_device
 */
static void
tzmon_set_power_device(ACPI_HANDLE dev, int on_off, char *tz_name)
{
	ACPI_BUFFER rb;
	ACPI_OBJECT *pr0;
	ACPI_STATUS status;
	int i;

	rb.Length = ACPI_ALLOCATE_BUFFER;
	rb.Pointer = NULL;
	status = AcpiEvaluateObjectTyped(dev, "_PR0", NULL, &rb,
	    ACPI_TYPE_PACKAGE);
	if (status != AE_OK) {
		DTRACE_PROBE2(alx__error, int, 2, char *, tz_name);
		return;
	}

	pr0 = ((ACPI_OBJECT *)rb.Pointer);
	for (i = 0; i < pr0->Package.Count; i++) {
		status = AcpiEvaluateObject(
		    pr0->Package.Elements[i].Reference.Handle,
		    on_off ? "_ON" : "_OFF", NULL, NULL);
		if (status != AE_OK) {
			DTRACE_PROBE2(alx__error, int, 4, char *, tz_name);
		}
	}

	AcpiOsFree(rb.Pointer);
}


/*
 * tzmon_set_power
 * Turn on or turn off all devices in the supplied list.
 */
static void
tzmon_set_power(ACPI_BUFFER devlist, int on_off, char *tz_name)
{
	ACPI_OBJECT *devs;
	int i;

	devs = ((ACPI_OBJECT *)devlist.Pointer);
	if (devs->Type != ACPI_TYPE_PACKAGE) {
		DTRACE_PROBE2(alx__error, int, 1, char *, tz_name);
		return;
	}

	for (i = 0; i < devs->Package.Count; i++)
		tzmon_set_power_device(
		    devs->Package.Elements[i].Reference.Handle, on_off,
		    tz_name);
}


/*
 * tzmon_eval_zone
 * Evaluate the current conditions within the thermal zone.
 */
static void
tzmon_eval_zone(thermal_zone_t *tzp)
{
	int tmp, new_level, level;

	mutex_enter(&tzp->lock);

	/* get the current temperature from ACPI */
	tzmon_eval_int(tzp->obj, "_TMP", &tmp);
	DTRACE_PROBE4(tz__temp, int, tmp, int, tzp->crt, int, tzp->hot,
	    char *, (char *)tzp->zone_name);

	/* _HOT handling */
	if (tzp->hot > 0 && tmp >= tzp->hot) {
		cmn_err(CE_WARN,
		    "tzmon: Thermal zone (%s) is too hot (%d C); "
		    "initiating shutdown\n",
		    (char *)tzp->zone_name, K_TO_C(tmp));

		tzmon_do_shutdown();
	}

	/* _CRT handling */
	if (tzp->crt > 0 && tmp >= tzp->crt) {
		cmn_err(CE_WARN,
		    "tzmon: Thermal zone (%s) is critically hot (%d C); "
		    "initiating rapid shutdown\n",
		    (char *)tzp->zone_name, K_TO_C(tmp));

		/* shut down (fairly) immediately */
		mdboot(A_REBOOT, AD_HALT, NULL, B_FALSE);
	}

	/*
	 * use the temperature to determine whether the thermal zone
	 * is at a new active cooling threshold level
	 */
	for (level = 0, new_level = -1; level < TZ_NUM_LEVELS; level++) {
		if (tzp->ac[level] >= 0 && (tmp >= tzp->ac[level])) {
			new_level = level;
			break;
		}
	}

	/*
	 * if the active cooling threshold has changed, turn off the
	 * devices associated with the old one and turn on the new one
	 */
	if (tzp->current_level != new_level) {
		if ((tzp->current_level >= 0) &&
		    (tzp->al[tzp->current_level].Length != 0))
			tzmon_set_power(tzp->al[tzp->current_level], 0,
			    (char *)tzp->zone_name);

		if ((new_level >= 0) &&
		    (tzp->al[new_level].Length != 0))
			tzmon_set_power(tzp->al[new_level], 1,
			    (char *)tzp->zone_name);

		tzp->current_level = new_level;
	}

	mutex_exit(&tzp->lock);
}


/*
 * tzmon_do_shutdown
 * Initiates shutdown by sending a SIGPWR signal to init.
 */
static void
tzmon_do_shutdown(void)
{
	proc_t *initpp;

	mutex_enter(&pidlock);
	initpp = prfind(P_INITPID);
	mutex_exit(&pidlock);

	/* if we can't find init, just halt */
	if (initpp == NULL) {
		mdboot(A_REBOOT, AD_HALT, NULL, B_FALSE);
	}

	/* graceful shutdown with inittab and all getting involved */
	psignal(initpp, SIGPWR);
}