/*
 * 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.
 */

/*
 * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
 */

/*
 * Copyright (c) 2018, Joyent, Inc.
 */

/*
 * Facility node support for SES enclosures.  We support the following facility
 * nodes, based on the node type:
 *
 *      bay
 *              indicator=ident
 *              indicator=fail
 *              indicator=ok2rm
 *              sensor=fault
 *
 *      controller
 *              indicator=ident
 *              indicator=fail
 *
 *      fan
 *              indicator=ident
 *              indicator=fail
 *              sensor=speed
 *              sensor=fault
 *
 *      psu
 *              indicator=ident
 *              indicator=fail
 *              sensor=status
 *
 *      ses-enclosure
 *              indicator=ident
 *              indicator=fail
 *              sensor=fault
 *              sensor=<name>   (temperature)
 *              sensor=<name>   (voltage)
 *              sensor=<name>   (current)
 *
 * Most of these are handled by a single method that supports getting and
 * setting boolean properties on the node.  The fan speed sensor requires a
 * special handler, while the analog enclosure sensors all have similar
 * behavior and can be grouped together using a common method.
 */

#include "ses.h"
#include "disk.h"

#include <string.h>

static int ses_indicator_mode(topo_mod_t *, tnode_t *, topo_version_t,
    nvlist_t *, nvlist_t **);
static int ses_sensor_reading(topo_mod_t *, tnode_t *, topo_version_t,
    nvlist_t *, nvlist_t **);
static int ses_sensor_state(topo_mod_t *, tnode_t *, topo_version_t,
    nvlist_t *, nvlist_t **);
static int ses_psu_state(topo_mod_t *, tnode_t *, topo_version_t,
    nvlist_t *, nvlist_t **);

#define	SES_SUPP_WARN_UNDER	0x01
#define	SES_SUPP_WARN_OVER	0x02
#define	SES_SUPP_CRIT_UNDER	0x04
#define	SES_SUPP_CRIT_OVER	0x08

typedef struct ses_sensor_desc {
	int		sd_type;
	int		sd_units;
	const char	*sd_propname;
	double		sd_multiplier;
} ses_sensor_desc_t;

#define	TOPO_METH_SES_MODE_VERSION	0
#define	TOPO_METH_SES_READING_VERSION	0
#define	TOPO_METH_SES_STATE_VERSION	0
#define	TOPO_METH_SES_PSU_VERSION	0

#define	TOPO_METH_SES_READING_PROP	"propname"
#define	TOPO_METH_SES_READING_MULT	"multiplier"

#define	TOPO_METH_SES_STATE_PROP	"propname"

#define	TOPO_METH_SES_MODE_PROP		"property-name"
#define	TOPO_METH_SES_MODE_ALTPROP	"alternate-property"

static const topo_method_t ses_indicator_methods[] = {
	{ "ses_indicator_mode", TOPO_PROP_METH_DESC,
	    TOPO_METH_SES_MODE_VERSION, TOPO_STABILITY_INTERNAL,
	    ses_indicator_mode },
	{ NULL }
};

static const topo_method_t ses_sensor_methods[] = {
	{ "ses_sensor_reading", TOPO_PROP_METH_DESC,
	    TOPO_METH_SES_READING_VERSION, TOPO_STABILITY_INTERNAL,
	    ses_sensor_reading },
	{ "ses_sensor_state", TOPO_PROP_METH_DESC,
	    TOPO_METH_SES_STATE_VERSION, TOPO_STABILITY_INTERNAL,
	    ses_sensor_state },
	{ "ses_psu_state", TOPO_PROP_METH_DESC,
	    TOPO_METH_SES_PSU_VERSION, TOPO_STABILITY_INTERNAL,
	    ses_psu_state },
	{ NULL }
};

/*
 * Get or set an indicator.  This method is invoked with arguments indicating
 * the property to query to retrieve the value.  Some elements (enclosures and
 * devices) support a request property that is distinct from an array-detected
 * property.  Either of these conditions will result in the indicator being
 * lit, so we have to check both properties.
 */
static int
ses_indicator_mode(topo_mod_t *mod, tnode_t *tn, topo_version_t vers,
    nvlist_t *in, nvlist_t **out)
{
	ses_node_t *np;
	nvlist_t *args, *pargs, *props;
	char *propname, *altprop;
	uint32_t mode;
	boolean_t current, altcurrent;
	nvlist_t *nvl;
	ses_enum_target_t *tp = topo_node_getspecific(tn);

	if (vers > TOPO_METH_SES_MODE_VERSION)
		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));

	if (nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args) != 0 ||
	    nvlist_lookup_string(args, TOPO_METH_SES_MODE_PROP,
	    &propname) != 0) {
		topo_mod_dprintf(mod, "invalid arguments to 'mode' method\n");
		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
	}

	if (nvlist_lookup_string(args, TOPO_METH_SES_MODE_ALTPROP,
	    &altprop) != 0)
		altprop = NULL;

	if ((np = ses_node_lock(mod, tn)) == NULL) {
		topo_mod_dprintf(mod, "failed to lookup ses node in 'mode' "
		    "method\n");
		return (-1);
	}
	verify((props = ses_node_props(np)) != NULL);

	if (nvlist_lookup_nvlist(in, TOPO_PROP_PARGS, &pargs) == 0 &&
	    nvlist_exists(pargs, TOPO_PROP_VAL_VAL)) {
		/* set operation */
		if (nvlist_lookup_uint32(pargs, TOPO_PROP_VAL_VAL,
		    &mode) != 0) {
			topo_mod_dprintf(mod, "invalid type for indicator "
			    "mode property");
			(void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
			goto error;
		}

		if (mode != TOPO_LED_STATE_OFF && mode != TOPO_LED_STATE_ON) {
			topo_mod_dprintf(mod, "invalid indicator mode %d\n",
			    mode);
			(void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
			goto error;
		}

		nvl = NULL;
		if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
		    nvlist_add_boolean_value(nvl, propname,
		    mode == TOPO_LED_STATE_ON ? B_TRUE : B_FALSE) != 0) {
			nvlist_free(nvl);
			(void) topo_mod_seterrno(mod, EMOD_NOMEM);
			goto error;
		}

		if (ses_node_ctl(np, SES_CTL_OP_SETPROP, nvl) != 0) {
			topo_mod_dprintf(mod, "failed to set indicator: %s\n",
			    ses_errmsg());
			nvlist_free(nvl);
			goto error;
		}

		tp->set_snaptime = 0;
		nvlist_free(nvl);
	} else {
		/* get operation */
		if (nvlist_lookup_boolean_value(props,
		    propname, &current) != 0) {
			topo_mod_dprintf(mod, "failed to lookup %s in node "
			    "properties\n", propname);
			(void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
			goto error;
		}

		if (altprop != NULL && nvlist_lookup_boolean_value(props,
		    altprop, &altcurrent) == 0)
			current |= altcurrent;

		mode = current ? TOPO_LED_STATE_ON : TOPO_LED_STATE_OFF;
	}

	nvl = NULL;
	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
	    nvlist_add_string(nvl, TOPO_PROP_VAL_NAME,
	    TOPO_LED_MODE) != 0 ||
	    nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_UINT32) != 0 ||
	    nvlist_add_uint32(nvl, TOPO_PROP_VAL_VAL, mode) != 0) {
		nvlist_free(nvl);
		(void) topo_mod_seterrno(mod, EMOD_NOMEM);
		goto error;
	}

	ses_node_unlock(mod, tn);
	*out = nvl;
	return (0);

error:
	ses_node_unlock(mod, tn);
	return (-1);
}

/*
 * Read the given sensor value.  This just looks up the value in the node
 * properties, and multiplies by a fixed value (determined when the method is
 * instantiated).
 */
static int
ses_sensor_reading(topo_mod_t *mod, tnode_t *tn, topo_version_t vers,
    nvlist_t *in, nvlist_t **out)
{
	ses_node_t *np;
	nvlist_t *args, *props;
	char *prop;
	double raw, multiplier;
	uint64_t current;
	int64_t scurrent;
	nvlist_t *nvl;

	if (vers > TOPO_METH_SES_MODE_VERSION)
		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));

	if (nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args) != 0 ||
	    nvlist_lookup_string(args, TOPO_METH_SES_READING_PROP,
	    &prop) != 0) {
		topo_mod_dprintf(mod,
		    "invalid arguments to 'reading' method\n");
		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
	}

	if (nvlist_lookup_double(args, TOPO_METH_SES_READING_MULT,
	    &multiplier) != 0)
		multiplier = 1;

	if ((np = ses_node_lock(mod, tn)) == NULL) {
		topo_mod_dprintf(mod, "failed to lookup ses node in 'mode' "
		    "method\n");
		return (-1);
	}
	verify((props = ses_node_props(np)) != NULL);

	if (nvlist_lookup_uint64(props, prop, &current) == 0) {
		raw = (double)current;
	} else if (nvlist_lookup_int64(props, prop, &scurrent) == 0) {
		raw = (double)scurrent;
	} else {
		topo_mod_dprintf(mod, "failed to lookup %s in node "
		    "properties\n", prop);
		ses_node_unlock(mod, tn);
		return (topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP));
	}

	ses_node_unlock(mod, tn);

	nvl = NULL;
	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
	    nvlist_add_string(nvl, TOPO_PROP_VAL_NAME,
	    TOPO_SENSOR_READING) != 0 ||
	    nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_DOUBLE) != 0 ||
	    nvlist_add_double(nvl, TOPO_PROP_VAL_VAL, raw * multiplier) != 0) {
		nvlist_free(nvl);
		return (topo_mod_seterrno(mod, EMOD_NOMEM));
	}

	*out = nvl;
	return (0);
}

/*
 * Returns the current sensor state.  This can be invoked for one of two
 * different types of sensors: threshold or discrete sensors.  For discrete
 * sensors, we expect a name of a boolean property and indicate
 * asserted/deasserted based on that.  For threshold sensors, we check for the
 * standard warning/critical properties and translate that into the appropriate
 * topo state.
 */
/*ARGSUSED*/
static int
ses_sensor_state(topo_mod_t *mod, tnode_t *tn, topo_version_t vers,
    nvlist_t *in, nvlist_t **out)
{
	nvlist_t *nvl, *args, *props;
	boolean_t value;
	uint64_t status;
	uint32_t state;
	ses_node_t *np;
	char *prop;

	if (nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args) != 0) {
		topo_mod_dprintf(mod,
		    "invalid arguments to 'state' method\n");
		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
	}

	if ((np = ses_node_lock(mod, tn)) == NULL) {
		topo_mod_dprintf(mod, "failed to lookup ses node in 'mode' "
		    "method\n");
		return (-1);
	}
	verify((props = ses_node_props(np)) != NULL);

	if (nvlist_lookup_uint64(props, SES_PROP_STATUS_CODE, &status) != 0)
		status = SES_ESC_UNSUPPORTED;

	state = 0;
	if (nvlist_lookup_string(args, TOPO_METH_SES_STATE_PROP,
	    &prop) == 0) {
		/* discrete (fault) sensor */

		if (status == SES_ESC_UNRECOVERABLE)
			state |= TOPO_SENSOR_STATE_GENERIC_FAIL_NONRECOV;
		else if (status == SES_ESC_CRITICAL)
			state |= TOPO_SENSOR_STATE_GENERIC_FAIL_CRITICAL;
		else if (nvlist_lookup_boolean_value(props, prop,
		    &value) == 0 && value)
			state |= TOPO_SENSOR_STATE_GENERIC_FAIL_NONRECOV;
		else
			state |= TOPO_SENSOR_STATE_GENERIC_FAIL_DEASSERTED;
	} else {
		/* threshold sensor */
		if (nvlist_lookup_boolean_value(props,
		    SES_PROP_WARN_UNDER, &value) == 0 && value)
			state |= TOPO_SENSOR_STATE_THRESH_LOWER_NONCRIT;
		if (nvlist_lookup_boolean_value(props,
		    SES_PROP_WARN_OVER, &value) == 0 && value)
			state |= TOPO_SENSOR_STATE_THRESH_UPPER_NONCRIT;
		if (nvlist_lookup_boolean_value(props,
		    SES_PROP_CRIT_UNDER, &value) == 0 && value)
			state |= TOPO_SENSOR_STATE_THRESH_LOWER_CRIT;
		if (nvlist_lookup_boolean_value(props,
		    SES_PROP_CRIT_OVER, &value) == 0 && value)
			state |= TOPO_SENSOR_STATE_THRESH_UPPER_CRIT;
	}

	ses_node_unlock(mod, tn);

	nvl = NULL;
	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
	    nvlist_add_string(nvl, TOPO_PROP_VAL_NAME,
	    TOPO_SENSOR_STATE) != 0 ||
	    nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_UINT32) != 0 ||
	    nvlist_add_uint32(nvl, TOPO_PROP_VAL_VAL, state) != 0) {
		nvlist_free(nvl);
		return (topo_mod_seterrno(mod, EMOD_NOMEM));
	}

	*out = nvl;
	return (0);
}

/*
 * Read the status of a PSU.  This is such a specialized operation that it has
 * its own method instead of trying to piggyback on ses_sensor_state().  We
 * use the following mapping to get to the standard topo power supply states:
 *
 *	acfail		-> INPUT_LOST
 *	dcfail		-> INPUT_LOST
 *	undervoltage	-> INPUT_RANGE
 *	overvoltage	-> INPUT_RANGE_PRES
 *	overcurrent	-> INPUT_RANGE_PRES
 *	overtemp	-> (none)
 *
 * If we ever have a need for reading overtemp, we can expand the topo
 * representation for power supplies, but at the moment this seems unnecessary.
 */
/*ARGSUSED*/
static int
ses_psu_state(topo_mod_t *mod, tnode_t *tn, topo_version_t vers,
    nvlist_t *in, nvlist_t **out)
{
	nvlist_t *nvl, *props;
	boolean_t value;
	uint32_t state;
	ses_node_t *np;

	if ((np = ses_node_lock(mod, tn)) == NULL) {
		topo_mod_dprintf(mod, "failed to lookup ses node in 'mode' "
		    "method\n");
		return (-1);
	}
	verify((props = ses_node_props(np)) != NULL);

	state = 0;
	if ((nvlist_lookup_boolean_value(props, SES_PSU_PROP_DC_FAIL,
	    &value) == 0 && value) ||
	    (nvlist_lookup_boolean_value(props, SES_PSU_PROP_AC_FAIL,
	    &value) == 0 && value))
		state |= TOPO_SENSOR_STATE_POWER_SUPPLY_INPUT_LOST;

	if (nvlist_lookup_boolean_value(props, SES_PSU_PROP_DC_UNDER_VOLTAGE,
	    &value) == 0 && value)
		state |= TOPO_SENSOR_STATE_POWER_SUPPLY_INPUT_RANGE;

	if ((nvlist_lookup_boolean_value(props, SES_PSU_PROP_DC_OVER_VOLTAGE,
	    &value) == 0 && value) ||
	    (nvlist_lookup_boolean_value(props, SES_PSU_PROP_DC_OVER_CURRENT,
	    &value) == 0 && value))
		state |= TOPO_SENSOR_STATE_POWER_SUPPLY_INPUT_RANGE_PRES;

	ses_node_unlock(mod, tn);

	nvl = NULL;
	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
	    nvlist_add_string(nvl, TOPO_PROP_VAL_NAME,
	    TOPO_SENSOR_STATE) != 0 ||
	    nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_UINT32) != 0 ||
	    nvlist_add_uint32(nvl, TOPO_PROP_VAL_VAL, state) != 0) {
		nvlist_free(nvl);
		return (topo_mod_seterrno(mod, EMOD_NOMEM));
	}

	*out = nvl;
	return (0);
}

/*
 * Create a facility node, either a sensor or an indicator.
 */
static tnode_t *
ses_add_fac_common(topo_mod_t *mod, tnode_t *pnode, const char *name,
    const char *type, uint64_t nodeid)
{
	tnode_t *tn;
	topo_pgroup_info_t pgi;
	int err;
	ses_enum_target_t *stp = topo_node_getspecific(pnode);

	if ((tn = topo_node_facbind(mod, pnode, name, type)) == NULL) {
		topo_mod_dprintf(mod, "failed to bind facility node %s\n",
		    name);
		return (NULL);
	}

	stp->set_refcount++;
	topo_node_setspecific(tn, stp);

	pgi.tpi_name = TOPO_PGROUP_FACILITY;
	pgi.tpi_namestab = TOPO_STABILITY_PRIVATE;
	pgi.tpi_datastab = TOPO_STABILITY_PRIVATE;
	pgi.tpi_version = 1;

	if (topo_pgroup_create(tn, &pgi, &err) != 0) {
		topo_mod_dprintf(mod, "failed to create facility property "
		    "group: %s\n", topo_strerror(err));
		topo_node_unbind(tn);
		return (NULL);
	}

	/*
	 * We need the node-id property for each facility node.
	 */
	pgi.tpi_name = TOPO_PGROUP_SES;
	pgi.tpi_namestab = TOPO_STABILITY_PRIVATE;
	pgi.tpi_datastab = TOPO_STABILITY_PRIVATE;
	pgi.tpi_version = TOPO_VERSION;

	if (topo_pgroup_create(tn, &pgi, &err) != 0) {
		topo_mod_dprintf(mod, "failed to create ses property "
		    "group: %s\n", topo_strerror(err));
		topo_node_unbind(tn);
		return (NULL);
	}

	if (topo_prop_set_uint64(tn, TOPO_PGROUP_SES,
	    TOPO_PROP_NODE_ID, TOPO_PROP_IMMUTABLE,
	    nodeid, &err) != 0) {
		topo_mod_dprintf(mod,
		    "failed to create property %s: %s\n",
		    TOPO_PROP_NODE_ID, topo_strerror(err));
		topo_node_unbind(tn);
		return (NULL);
	}

	return (tn);
}

/*
 * Add an indicator.  This can be represented by a single property, or by the
 * union of two elements when SES is capable of distinguishing between
 * requested failure and detected failure.
 */
static int
ses_add_indicator(topo_mod_t *mod, tnode_t *pnode, uint64_t nodeid,
    int type, const char *name, const char *propname, const char *altprop)
{
	tnode_t *tn;
	int err;
	nvlist_t *nvl;

	/* create facility node and add methods */
	if ((tn = ses_add_fac_common(mod, pnode, name,
	    TOPO_FAC_TYPE_INDICATOR, nodeid)) == NULL)
		return (-1);

	if (topo_method_register(mod, tn, ses_indicator_methods) < 0) {
		topo_mod_dprintf(mod, "failed to register facility methods\n");
		topo_node_unbind(tn);
		return (-1);
	}

	/* set standard properties */
	if (topo_prop_set_uint32(tn, TOPO_PGROUP_FACILITY,
	    TOPO_FACILITY_TYPE, TOPO_PROP_IMMUTABLE, type, &err) != 0) {
		topo_mod_dprintf(mod,
		    "failed to set facility node properties: %s\n",
		    topo_strerror(err));
		topo_node_unbind(tn);
		return (-1);
	}

	/* 'mode' property */
	nvl = NULL;
	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
	    nvlist_add_string(nvl, TOPO_METH_SES_MODE_PROP,
	    propname) != 0 ||
	    (altprop != NULL && nvlist_add_string(nvl,
	    TOPO_METH_SES_MODE_ALTPROP, altprop) != 0)) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to setup method arguments\n");
		topo_node_unbind(tn);
		return (topo_mod_seterrno(mod, EMOD_NOMEM));
	}

	if (topo_prop_method_register(tn, TOPO_PGROUP_FACILITY,
	    TOPO_LED_MODE, TOPO_TYPE_UINT32, "ses_indicator_mode",
	    nvl, &err) != 0) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to register reading method: %s\n",
		    topo_strerror(err));
		return (-1);
	}

	if (topo_prop_setmutable(tn, TOPO_PGROUP_FACILITY,
	    TOPO_LED_MODE, &err) != 0) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to set property as mutable: %s\n",
		    topo_strerror(err));
		return (-1);
	}

	nvlist_free(nvl);
	return (0);
}

static tnode_t *
ses_add_sensor_common(topo_mod_t *mod, tnode_t *pnode, uint64_t nodeid,
    const char *name, const char *class, int type)
{
	tnode_t *tn;
	int err;

	/* create facility node and add methods */
	if ((tn = ses_add_fac_common(mod, pnode, name,
	    TOPO_FAC_TYPE_SENSOR, nodeid)) == NULL)
		return (NULL);

	if (topo_method_register(mod, tn, ses_sensor_methods) < 0) {
		topo_mod_dprintf(mod, "failed to register facility methods\n");
		topo_node_unbind(tn);
		return (NULL);
	}

	/* set standard properties */
	if (topo_prop_set_string(tn, TOPO_PGROUP_FACILITY,
	    TOPO_SENSOR_CLASS, TOPO_PROP_IMMUTABLE,
	    class, &err) != 0 ||
	    topo_prop_set_uint32(tn, TOPO_PGROUP_FACILITY,
	    TOPO_FACILITY_TYPE, TOPO_PROP_IMMUTABLE,
	    type, &err) != 0) {
		topo_mod_dprintf(mod,
		    "failed to set facility node properties: %s\n",
		    topo_strerror(err));
		topo_node_unbind(tn);
		return (NULL);
	}

	return (tn);
}

/*
 * Add an analog (threshold) sensor to the enclosure.  This is used for fan
 * speed, voltage, current, and temperature sensors.
 */
static int
ses_add_sensor(topo_mod_t *mod, tnode_t *pnode, uint64_t nodeid,
    const char *name, const ses_sensor_desc_t *sdp)
{
	tnode_t *tn;
	int err;
	nvlist_t *nvl;

	if ((tn = ses_add_sensor_common(mod, pnode, nodeid, name,
	    TOPO_SENSOR_CLASS_THRESHOLD, sdp->sd_type)) == NULL)
		return (-1);

	if (topo_prop_set_uint32(tn, TOPO_PGROUP_FACILITY,
	    TOPO_SENSOR_UNITS, TOPO_PROP_IMMUTABLE, sdp->sd_units, &err) != 0) {
		topo_mod_dprintf(mod,
		    "failed to set facility node properties: %s\n",
		    topo_strerror(err));
		topo_node_unbind(tn);
		return (-1);
	}

	/* 'reading' property */
	nvl = NULL;
	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
	    nvlist_add_string(nvl, TOPO_METH_SES_READING_PROP,
	    sdp->sd_propname) != 0 ||
	    (sdp->sd_multiplier != 0 &&
	    nvlist_add_double(nvl, TOPO_METH_SES_READING_MULT,
	    sdp->sd_multiplier) != 0)) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to setup method arguments\n");
		topo_node_unbind(tn);
		return (-1);
	}

	if (topo_prop_method_register(tn, TOPO_PGROUP_FACILITY,
	    TOPO_SENSOR_READING, TOPO_TYPE_DOUBLE, "ses_sensor_reading",
	    nvl, &err) != 0) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to register reading method: %s\n",
		    topo_strerror(err));
		return (-1);
	}

	nvlist_free(nvl);
	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0) {
		topo_mod_dprintf(mod, "failed to setup method arguments\n");
		topo_node_unbind(tn);
		return (-1);
	}

	/* 'state' property */
	if (topo_prop_method_register(tn, TOPO_PGROUP_FACILITY,
	    TOPO_SENSOR_STATE, TOPO_TYPE_UINT32, "ses_sensor_state",
	    nvl, &err) != 0) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to register state method: %s\n",
		    topo_strerror(err));
		return (-1);
	}

	nvlist_free(nvl);
	return (0);
}

/*
 * Add a discrete sensor for simple boolean values.  This is used to indicate
 * externally-detected failures for fans, bays, and enclosures.
 */
static int
ses_add_discrete(topo_mod_t *mod, tnode_t *pnode, uint64_t nodeid,
    const char *name, const char *prop)
{
	tnode_t *tn;
	int err;
	nvlist_t *nvl;

	if ((tn = ses_add_sensor_common(mod, pnode, nodeid, name,
	    TOPO_SENSOR_CLASS_DISCRETE,
	    TOPO_SENSOR_TYPE_GENERIC_FAILURE)) == NULL)
		return (-1);

	nvl = NULL;
	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
	    nvlist_add_string(nvl, TOPO_METH_SES_STATE_PROP, prop) != 0) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to setup method arguments\n");
		topo_node_unbind(tn);
		return (-1);
	}

	/* 'state' property */
	if (topo_prop_method_register(tn, TOPO_PGROUP_FACILITY,
	    TOPO_SENSOR_STATE, TOPO_TYPE_UINT32, "ses_sensor_state",
	    nvl, &err) != 0) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to register state method: %s\n",
		    topo_strerror(err));
		return (-1);
	}

	nvlist_free(nvl);
	return (0);
}

/*ARGSUSED*/
static int
ses_add_psu_status(topo_mod_t *mod, tnode_t *pnode, uint64_t nodeid)
{
	tnode_t *tn;
	int err;
	nvlist_t *nvl;

	/* create facility node and add methods */
	if ((tn = ses_add_sensor_common(mod, pnode, nodeid, "status",
	    TOPO_SENSOR_CLASS_DISCRETE,
	    TOPO_SENSOR_TYPE_POWER_SUPPLY)) == NULL)
		return (-1);

	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to setup method arguments\n");
		topo_node_unbind(tn);
		return (-1);
	}

	/* 'state' property */
	if (topo_prop_method_register(tn, TOPO_PGROUP_FACILITY,
	    TOPO_SENSOR_STATE, TOPO_TYPE_UINT32, "ses_psu_state",
	    nvl, &err) != 0) {
		nvlist_free(nvl);
		topo_mod_dprintf(mod, "failed to register state method: %s\n",
		    topo_strerror(err));
		return (-1);
	}

	nvlist_free(nvl);
	return (0);
}

/*ARGSUSED*/
int
ses_node_enum_facility(topo_mod_t *mod, tnode_t *tn, topo_version_t vers,
    nvlist_t *in, nvlist_t **out)
{
	ses_node_t *np;
	nvlist_t *props;
	uint64_t type, nodeid;
	ses_sensor_desc_t sd = { 0 };

	if ((np = ses_node_lock(mod, tn)) == NULL)
		return (-1);

	assert(ses_node_type(np) == SES_NODE_ELEMENT);
	nodeid = ses_node_id(np);
	verify((props = ses_node_props(np)) != NULL);
	verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_TYPE, &type) == 0);

	if (type != SES_ET_DEVICE && type != SES_ET_ARRAY_DEVICE &&
	    type != SES_ET_COOLING && type != SES_ET_POWER_SUPPLY) {
		ses_node_unlock(mod, tn);
		return (0);
	}

	/*
	 * Every element supports an 'ident' indicator.  All elements also
	 * support a 'fail' indicator, but the properties used to represent
	 * this condition differs between elements.
	 */
	if (ses_add_indicator(mod, tn, nodeid, TOPO_LED_TYPE_LOCATE, "ident",
	    SES_PROP_IDENT, NULL) != 0)
		goto error;

	switch (type) {
	case SES_ET_DEVICE:
	case SES_ET_ARRAY_DEVICE:
		/*
		 * Disks support an additional 'ok2rm' indicator, as well as
		 * externally detected 'fail' sensor.
		 */
		if (ses_add_indicator(mod, tn, nodeid, TOPO_LED_TYPE_SERVICE,
		    "fail", SES_DEV_PROP_FAULT_RQSTD,
		    SES_DEV_PROP_FAULT_SENSED) != 0 ||
		    ses_add_indicator(mod, tn, nodeid, TOPO_LED_TYPE_OK2RM,
		    "ok2rm", SES_PROP_RMV, SES_PROP_RMV) != 0 ||
		    ses_add_discrete(mod, tn, nodeid, "fault",
		    SES_DEV_PROP_FAULT_SENSED) != 0)
			goto error;
		break;

	case SES_ET_COOLING:
		/*
		 * Add the fan speed sensor, and a discrete sensor for
		 * detecting failure.
		 */
		sd.sd_type = TOPO_SENSOR_TYPE_THRESHOLD_STATE;
		sd.sd_units = TOPO_SENSOR_UNITS_RPM;
		sd.sd_propname = SES_COOLING_PROP_FAN_SPEED;
		if (ses_add_indicator(mod, tn, nodeid, TOPO_LED_TYPE_SERVICE,
		    "fail", SES_PROP_FAIL, NULL) != 0 ||
		    ses_add_sensor(mod, tn, nodeid, "speed", &sd) != 0 ||
		    ses_add_discrete(mod, tn, nodeid, "fault",
		    SES_PROP_FAIL) != 0)
			goto error;
		break;

	case SES_ET_POWER_SUPPLY:
		/*
		 * For power supplies, we have a number of different sensors:
		 * acfail, dcfail, overtemp, undervoltate, overvoltage,
		 * and overcurrent.  Rather than expose these all as individual
		 * sensors, we lump them together into a 'status' sensor of
		 * type TOPO_SENSOR_TYPE_POWER_SUPPLY and export the
		 * appropriate status flags as defined by the libtopo standard.
		 */
		if (ses_add_indicator(mod, tn, nodeid, TOPO_LED_TYPE_SERVICE,
		    "fail", SES_PROP_FAIL, NULL) != 0)
			goto error;

		if (ses_add_psu_status(mod, tn, nodeid) != 0)
			goto error;
		break;

	default:
		return (0);
	}

	ses_node_unlock(mod, tn);
	return (0);

error:
	ses_node_unlock(mod, tn);
	return (-1);
}

/*
 * Add enclosure-wide sensors (temperature, voltage, and current) beneath the
 * given aggregate.
 */
static int
ses_add_enclosure_sensors(topo_mod_t *mod, tnode_t *tn, ses_node_t *agg,
    uint64_t type)
{
	ses_node_t *child;
	const char *defaultname;
	char *desc, *name;
	char rawname[64];
	nvlist_t *props, *aprops;
	uint64_t index, nodeid;
	ses_sensor_desc_t sd = { 0 };
	size_t len;

	switch (type) {
	case SES_ET_TEMPERATURE_SENSOR:
		sd.sd_type = TOPO_SENSOR_TYPE_TEMP;
		sd.sd_units = TOPO_SENSOR_UNITS_DEGREES_C;
		sd.sd_propname = SES_TEMP_PROP_TEMP;
		defaultname = "temperature";
		break;

	case SES_ET_VOLTAGE_SENSOR:
		sd.sd_type = TOPO_SENSOR_TYPE_VOLTAGE;
		sd.sd_units = TOPO_SENSOR_UNITS_VOLTS;
		sd.sd_propname = SES_VS_PROP_VOLTAGE_MV;
		sd.sd_multiplier = 0.001;
		defaultname = "voltage";
		break;

	case SES_ET_CURRENT_SENSOR:
		sd.sd_type = TOPO_SENSOR_TYPE_CURRENT;
		sd.sd_units = TOPO_SENSOR_UNITS_AMPS;
		sd.sd_propname = SES_CS_PROP_CURRENT_MA;
		sd.sd_multiplier = 0.001;
		defaultname = "current";
		break;

	default:
		return (0);
	}

	aprops = ses_node_props(agg);

	for (child = ses_node_child(agg); child != NULL;
	    child = ses_node_sibling(child)) {
		/*
		 * The only tricky part here is getting the name for the
		 * sensor, where we follow the algorithm of the standard
		 * elements.
		 */
		props = ses_node_props(child);
		nodeid = ses_node_id(child);
		if (nvlist_lookup_uint64(props, SES_PROP_ELEMENT_CLASS_INDEX,
		    &index) != 0)
			continue;

		if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION,
		    &desc) == 0 && desc[0] != '\0') {
			(void) strlcpy(rawname, desc, sizeof (rawname));
		} else {
			if (nvlist_lookup_string(aprops,
			    SES_PROP_CLASS_DESCRIPTION, &desc) != 0 ||
			    desc[0] == '\0')
				desc = (char *)defaultname;

			len = strlen(desc);
			while (len > 0 && desc[len - 1] == ' ')
				len--;

			(void) snprintf(rawname, sizeof (rawname),
			    "%.*s %llu", len, desc, index);
		}

		if ((name = topo_mod_clean_str(mod, rawname)) == NULL)
			return (-1);

		if (ses_add_sensor(mod, tn, nodeid, name, &sd) != 0) {
			topo_mod_strfree(mod, name);
			return (-1);
		}

		topo_mod_strfree(mod, name);
	}

	return (0);
}

/*ARGSUSED*/
int
ses_enc_enum_facility(topo_mod_t *mod, tnode_t *tn, topo_version_t vers,
    nvlist_t *in, nvlist_t **out)
{
	ses_node_t *np, *agg;
	nvlist_t *aprops;
	uint64_t type, nodeid;

	if ((np = ses_node_lock(mod, tn)) == NULL)
		return (-1);

	assert(ses_node_type(np) == SES_NODE_ENCLOSURE);
	nodeid = ses_node_id(np);

	/*
	 * 'ident' and 'fail' LEDs, and 'fault' sensor.
	 */
	if (ses_add_indicator(mod, tn, nodeid, TOPO_LED_TYPE_LOCATE, "ident",
	    SES_PROP_IDENT, NULL) != 0 ||
	    ses_add_indicator(mod, tn, nodeid, TOPO_LED_TYPE_SERVICE, "fail",
	    SES_PROP_FAIL_REQ, SES_PROP_FAIL) != 0 ||
	    ses_add_discrete(mod, tn, nodeid, "fault", SES_PROP_FAIL) != 0)
		goto error;

	/*
	 * Environmental sensors (temperature, voltage, current).  We have no
	 * way of knowing if any of these sensors correspond to a particular
	 * element, so we just attach them to the enclosure as a whole.  In the
	 * future, some vendor-specific libses plugin knowledge could let us
	 * make this correlation clearer.
	 */
	for (agg = ses_node_child(np); agg != NULL;
	    agg = ses_node_sibling(agg)) {
		if (ses_node_type(agg) != SES_NODE_AGGREGATE)
			continue;

		verify((aprops = ses_node_props(agg)) != NULL);
		if (nvlist_lookup_uint64(aprops, SES_PROP_ELEMENT_TYPE,
		    &type) != 0)
			continue;

		if (ses_add_enclosure_sensors(mod, tn, agg, type) != 0)
			goto error;
	}

	ses_node_unlock(mod, tn);
	return (0);

error:
	ses_node_unlock(mod, tn);
	return (-1);
}