excalibur/envd/piclenvsetup.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 (c) 1999-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*
 * This file contains code for setting up environmental related nodes
 * and properties in the PICL tree.
 *
 * For each temperature-device class node, it does the following:
 *	- Create cpu and cpu-ambient temperautre-sensor class nodes.
 *	- Create "devfs-path" property under each temperature-sensor class node
 *	- Create "Temperature" volatile property under these nodes.
 *	- Create various temperature threshold properties under each node.
 *	- Create "Temperature" and "AmbientTemperature" volatile properties
 *	  under corresponding "cpu" class node.
 *
 * For the "fan-control" node, it does the following:
 *	- Create system-fan node
 *	- Create "devfs-path" property under "fan" class node
 *	- Create "Speed" volatile propery under each node.
 *	- Create "SpeedUnit" property under each node.
 *
 * Access to sensor/fan properties is protected by the envpicl_rwlock
 * readers/writer lock. This lock is held as a reader while trying to
 * access any volatile sensor/fan property, and held as a writer lock
 * while trying to create or destroy sensor/fan nodes and properties.
 */

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <syslog.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/open.h>
#include <ctype.h>
#include <string.h>
#include <alloca.h>
#include <libintl.h>
#include <sys/systeminfo.h>
#include <picl.h>
#include <picltree.h>
#include <picld_pluginutil.h>
#include <pthread.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include "picldefs.h"
#include "envd.h"


/*
 * Volatile property read/write function typedef
 */
typedef int ptree_vol_rdfunc_t(ptree_rarg_t *parg, void *buf);
typedef int ptree_vol_wrfunc_t(ptree_warg_t *parg, const void *buf);

#define	PROP_FAN_SPEED_UNIT_VALUE	"%"

/*
 * PICL class path for CPU nodes
 */
#define	CPU0_PLAT_PATH		"_class:/gptwo/cpu?ID=0"
#define	CPU1_PLAT_PATH		"_class:/gptwo/cpu?ID=1"

/*
 * "UnitAddress" propval for various temperature devices (platform dependent)
 */
#define	CPU0_TEMPDEV_UNITADDR	"0,30"
#define	CPU1_TEMPDEV_UNITADDR	"0,98"

/*
 * Sensor node data structure
 */
typedef struct {
	char		*sensor_name;	/* sensor name */
	env_sensor_t	*sensorp;	/* sensor info */
	char		*unitaddr;	/* parent's UnitAddress propval */
	char		*sdev_node;	/* sensed device node name */
	char		*sdev_pname;	/* sensed device "temp" prop name */
	picl_nodehdl_t	nodeh;		/* sensor node handle */
	picl_prophdl_t	proph;		/* "Temperature" property handle */
	picl_prophdl_t	target_proph;	/* "TargetTemp" property handle */
	picl_prophdl_t	sdev_proph;	/* property handle for sensed dev */
} sensor_node_t;


/*
 * Sensor nodes array
 */
static sensor_node_t sensor_nodes[] = {
	{SENSOR_CPU0_DIE, NULL, CPU0_TEMPDEV_UNITADDR,
	    CPU0_PLAT_PATH, PICL_PROP_CPU_DIE_TEMP},

	{SENSOR_CPU0_AMB, NULL, CPU0_TEMPDEV_UNITADDR,
	    CPU0_PLAT_PATH, PICL_PROP_CPU_AMB_TEMP},

	{SENSOR_CPU1_DIE, NULL, CPU1_TEMPDEV_UNITADDR,
	    CPU1_PLAT_PATH, PICL_PROP_CPU_DIE_TEMP},

	{SENSOR_CPU1_AMB, NULL, CPU1_TEMPDEV_UNITADDR,
	    CPU1_PLAT_PATH, PICL_PROP_CPU_AMB_TEMP},

	{NULL, NULL, NULL, NULL, NULL}
};


/*
 * Fan node data structure
 */
typedef struct {
	char		*fan_name;	/* fan name */
	env_fan_t	*fanp;		/* fan information */
	char		*speed_unit;	/* speed unit string */
	picl_nodehdl_t	nodeh;		/* "fan" node handle */
	picl_prophdl_t	proph;		/* "Speed" property handle */
} fan_node_t;


/*
 * Fan node array
 */
static fan_node_t fan_nodes[] =  {
	{ENV_SYSTEM_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE},
	{ENV_CPU_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE},
	{ENV_PSUPPLY_FAN, NULL, PROP_FAN_SPEED_UNIT_VALUE},
	{NULL, NULL, NULL}
};


/*
 * Miscellaneous declarations
 */
typedef struct node_list {
	picl_nodehdl_t		nodeh;
	struct node_list	*next;
} node_list_t;

static void delete_sensor_nodes_and_props(void);
static void delete_fan_nodes_and_props(void);
static pthread_rwlock_t	envpicl_rwlock = PTHREAD_RWLOCK_INITIALIZER;


/*
 * Read function for volatile "Temperature" property
 */
static int
get_current_target_temp(ptree_rarg_t *parg, void *buf)
{
	picl_prophdl_t	proph;
	sensor_node_t	*snodep;
	env_sensor_t	*sensorp;

	/*
	 * Locate the sensor in our sensor_nodes table by matching the
	 * property handle and get its temperature.
	 */
	proph = parg->proph;
	(void) pthread_rwlock_rdlock(&envpicl_rwlock);
	for (snodep = &sensor_nodes[0]; snodep->sensor_name != NULL;
	    snodep++) {
		if (snodep->target_proph != proph)
			continue;

		if ((sensorp = snodep->sensorp) == NULL)
			break;
		(void) memcpy(buf, (caddr_t)&sensorp->target_temp,
		    sizeof (sensorp->target_temp));
		(void) pthread_rwlock_unlock(&envpicl_rwlock);
		return (PICL_SUCCESS);
	}
	(void) pthread_rwlock_unlock(&envpicl_rwlock);
	return (PICL_FAILURE);
}


/*
 * Read function for volatile "Temperature" property
 */
static int
get_current_temp(ptree_rarg_t *parg, void *buf)
{
	tempr_t		temp;
	picl_prophdl_t	proph;
	sensor_node_t	*snodep;

	/*
	 * Locate the sensor in our sensor_nodes table by matching the
	 * property handle and get its temperature.
	 */
	proph = parg->proph;
	(void) pthread_rwlock_rdlock(&envpicl_rwlock);
	for (snodep = &sensor_nodes[0]; snodep->sensor_name != NULL;
	    snodep++) {
		if (snodep->proph != proph &&
		    snodep->sdev_proph != proph)
			continue;

		if (get_temperature(snodep->sensorp, &temp) < 0)
			break;
		(void) memcpy(buf, (caddr_t)&temp, sizeof (tempr_t));
		(void) pthread_rwlock_unlock(&envpicl_rwlock);
		return (PICL_SUCCESS);
	}
	(void) pthread_rwlock_unlock(&envpicl_rwlock);
	return (PICL_FAILURE);
}


/*
 * Read function for volatile "Speed" property on "fan" class node
 */
static int
get_current_speed(ptree_rarg_t *parg, void *buf)
{
	fanspeed_t	speed;
	picl_prophdl_t	proph;
	fan_node_t	*fnodep;

	/*
	 * Locate the fan in our fan_nodes table by matching the
	 * property handle and get fan speed.
	 */
	proph = parg->proph;
	(void) pthread_rwlock_rdlock(&envpicl_rwlock);
	for (fnodep = &fan_nodes[0]; fnodep->fan_name != NULL; fnodep++) {
		if (fnodep->proph != proph)
			continue;
		if (get_fan_speed(fnodep->fanp, &speed) < 0)
			break;
		speed = (fanspeed_t)(speed * 100/fnodep->fanp->speed_max);

		(void) memcpy(buf, (caddr_t)&speed, sizeof (speed));
		(void) pthread_rwlock_unlock(&envpicl_rwlock);
		return (PICL_SUCCESS);
	}
	(void) pthread_rwlock_unlock(&envpicl_rwlock);
	return (PICL_FAILURE);
}


static node_list_t *
add_node_to_list(picl_nodehdl_t nodeh, node_list_t *listp)
{
	node_list_t	*el;
	node_list_t	*tmp;

	el = malloc(sizeof (node_list_t));
	if (el == NULL)
		return (listp);
	el->nodeh = nodeh;
	el->next = NULL;
	if (listp == NULL) {
		listp = el;
		return (listp);
	}

	/*
	 * append to the end to preserve the order found
	 */
	tmp = listp;
	while (tmp->next != NULL)
		tmp = tmp->next;

	tmp->next = el;
	return (listp);
}


/*
 * Get a list of nodes of the specified classname under nodeh
 * Once a node of the specified class is found, it's children are not
 * searched.
 */
static node_list_t *
get_node_list_by_class(picl_nodehdl_t nodeh, const char *classname,
    node_list_t *listp)
{
	int		err;
	char		clname[PICL_CLASSNAMELEN_MAX+1];
	picl_nodehdl_t	chdh;

	/*
	 * go through the children
	 */
	err = ptree_get_propval_by_name(nodeh, PICL_PROP_CHILD, &chdh,
	    sizeof (picl_nodehdl_t));

	while (err == PICL_SUCCESS) {
		err = ptree_get_propval_by_name(chdh, PICL_PROP_CLASSNAME,
		    clname, strlen(classname) + 1);

		if ((err == PICL_SUCCESS) && (strcmp(clname, classname) == 0))
			listp = add_node_to_list(chdh, listp);
		else
			listp = get_node_list_by_class(chdh, classname, listp);

		err = ptree_get_propval_by_name(chdh, PICL_PROP_PEER, &chdh,
		    sizeof (picl_nodehdl_t));
	}
	return (listp);
}


/*
 * Free memory allocated to build the specified node list.
 */
static void
free_node_list(node_list_t *listp)
{
	node_list_t	*next;

	for (; listp != NULL; listp = next) {
		next = listp->next;
		free(listp);
	}
}

/*
 * Get PICL_PTYPE_CHARSTRING "UnitAddress" property
 */
static int
get_unit_address_prop(picl_nodehdl_t nodeh, void *buf, size_t len)
{
	int			err;
	picl_prophdl_t		proph;
	ptree_propinfo_t	pinfo;

	err = ptree_get_prop_by_name(nodeh, PICL_PROP_UNIT_ADDRESS, &proph);
	if (err == PICL_SUCCESS)
		err = ptree_get_propinfo(proph, &pinfo);

	if (err != PICL_SUCCESS)
		return (err);

	if (pinfo.piclinfo.type != PICL_PTYPE_CHARSTRING ||
	    pinfo.piclinfo.size > len)
		return (PICL_FAILURE);

	err = ptree_get_propval(proph, buf, pinfo.piclinfo.size);
	return (err);
}


/*
 * Create and add the specified regular property
 */

static int
add_regular_prop(picl_nodehdl_t nodeh, char *name, int type, int access,
    int size, void *valbuf, picl_prophdl_t *prophp)
{
	int			err;
	ptree_propinfo_t	propinfo;
	picl_prophdl_t		proph;

	err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
	    type, access, size, name, NULL, NULL);
	if (err != PICL_SUCCESS)
		return (err);

	err = ptree_create_and_add_prop(nodeh, &propinfo, valbuf, &proph);
	if (err == PICL_SUCCESS && prophp)
		*prophp = proph;
	return (err);
}


/*
 * Create and add the specified volatile property
 */
static int
add_volatile_prop(picl_nodehdl_t nodeh, char *name, int type, int access,
    int size, ptree_vol_rdfunc_t *rdfunc, ptree_vol_wrfunc_t *wrfunc,
    picl_prophdl_t *prophp)
{
	int			err;
	ptree_propinfo_t	propinfo;
	picl_prophdl_t		proph;

	err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
	    type, (access|PICL_VOLATILE), size, name, rdfunc, wrfunc);
	if (err != PICL_SUCCESS)
		return (err);

	err = ptree_create_and_add_prop(nodeh, &propinfo, NULL, &proph);
	if (err == PICL_SUCCESS && prophp)
		*prophp = proph;
	return (err);
}

/*
 * Add temperature threshold properties
 */
static void
add_sensor_thresh_props(picl_nodehdl_t nodeh, sensor_thresh_t *threshp)
{
	picl_prophdl_t	proph;

	(void) add_regular_prop(nodeh, PICL_PROP_LOW_POWER_OFF,
	    PICL_PTYPE_INT, PICL_READ,
	    sizeof (threshp->low_power_off),
	    (void *)&(threshp->low_power_off), &proph);

	(void) add_regular_prop(nodeh, PICL_PROP_LOW_SHUTDOWN,
	    PICL_PTYPE_INT, PICL_READ,
	    sizeof (threshp->low_shutdown),
	    (void *)&(threshp->low_shutdown), &proph);

	(void) add_regular_prop(nodeh, PICL_PROP_LOW_WARNING,
	    PICL_PTYPE_INT, PICL_READ,
	    sizeof (threshp->low_warning),
	    (void *)&(threshp->low_warning), &proph);

	(void) add_regular_prop(nodeh, PICL_PROP_HIGH_WARNING,
	    PICL_PTYPE_INT, PICL_READ,
	    sizeof (threshp->high_warning),
	    (void *)&(threshp->high_warning), &proph);

	(void) add_regular_prop(nodeh, PICL_PROP_HIGH_SHUTDOWN,
	    PICL_PTYPE_INT, PICL_READ,
	    sizeof (threshp->high_shutdown),
	    (void *)&(threshp->high_shutdown), &proph);

	(void) add_regular_prop(nodeh, PICL_PROP_HIGH_POWER_OFF,
	    PICL_PTYPE_INT, PICL_READ,
	    sizeof (threshp->high_power_off),
	    (void *)&(threshp->high_power_off), &proph);
}


/*
 * Lookup "temperature-device" class nodes and create "temperature-sensor"
 * class nodes and relevant properties under those nodes.
 *
 * For each entry in sensor_nodes[] array, do the following:
 *	- Create specified (cpu-die or cpu-ambient) "temperautre-sensor" class
 *	  node.
 *	- Create "devfs-path" property under this node.
 *	- Create "Temperature" volatile property under this node.
 *	- Create various temperature threshold properties under this node.
 *	- Create specified ("Temperature" or "AmbientTemperature") volatile
 *	  temperature property under specified sdev_node node.
 */

static int
add_sensor_nodes_and_props(picl_nodehdl_t plath)
{
	int		err;
	char		*pname, *nodename, *refnode, *devfs_path;
	node_list_t	*node_list, *listp;
	sensor_node_t	*snodep;
	sensor_thresh_t *threshp;
	picl_nodehdl_t	nodeh, refnodeh, cnodeh;
	picl_prophdl_t	proph;
	char		unitaddr[PICL_UNITADDR_LEN_MAX];
	env_sensor_t	*sensorp;

	node_list =
	    get_node_list_by_class(plath, PICL_CLASS_TEMPERATURE_DEVICE, NULL);

	if (node_list == NULL)
		return (PICL_FAILURE);

	for (listp = node_list; listp != NULL; listp = listp->next) {
		/*
		 * Get "reg" property. Skip if no "reg" property found.
		 */
		nodeh = listp->nodeh;
		err = get_unit_address_prop(nodeh, (void *)unitaddr,
		    sizeof (unitaddr));
		if (err != PICL_SUCCESS)
			continue;

		for (snodep = sensor_nodes; snodep->sensor_name != NULL;
		    snodep++) {

			/* Match "UnitAddress" property */
			if (strcasecmp(unitaddr, snodep->unitaddr) != 0)
				continue;

			/*
			 * Skip if already initialized or no sensor info
			 */
			sensorp = snodep->sensorp;
			if (snodep->nodeh != 0 || sensorp == NULL)
				continue;

			/*
			 * Create temperature-sensor node
			 */
			nodename = snodep->sensor_name;
			err = ptree_create_and_add_node(nodeh, nodename,
			    PICL_CLASS_TEMPERATURE_SENSOR, &cnodeh);
			if (env_debug)
				envd_log(LOG_INFO,
				    "Creating PICL sensor node '%s' err:%d\n",
				    nodename, err);
			if (err != PICL_SUCCESS)
				break;

			/* save node handle */
			snodep->nodeh = cnodeh;

			/*
			 * Add "devfs_path" property in child node
			 */
			devfs_path = sensorp->devfs_path;
			pname = PICL_PROP_DEVFS_PATH;
			err = add_regular_prop(cnodeh, pname,
			    PICL_PTYPE_CHARSTRING, PICL_READ,
			    strlen(devfs_path)+1, (void *)devfs_path, &proph);
			if (err != PICL_SUCCESS)
				break;

			/*
			 * Now add volatile "temperature" volatile property
			 * in this "temperature-sensor" class node.
			 */
			pname = PICL_PROP_TEMPERATURE;
			err = add_volatile_prop(cnodeh, pname,
			    PICL_PTYPE_INT, PICL_READ, sizeof (tempr_t),
			    get_current_temp, NULL, &proph);
			if (err != PICL_SUCCESS)
				break;

			/* Save prop handle */
			snodep->proph = proph;

			/*
			 * Add threshold related properties
			 */
			threshp = sensorp->temp_thresh;
			if (threshp && threshp->policy_type ==
			    POLICY_TARGET_TEMP) {
				/*
				 * Add volatile "TargetTemperature" property
				 */
				pname = PICL_PROP_TARGET_TEMPERATURE;
				err = add_volatile_prop(cnodeh, pname,
				    PICL_PTYPE_INT, PICL_READ,
				    sizeof (sensorp->target_temp),
				    get_current_target_temp, NULL, &proph);
				if (err != PICL_SUCCESS)
					break;
				snodep->target_proph = proph;
			}

			if (threshp != NULL)
				add_sensor_thresh_props(cnodeh, threshp);

			/*
			 * Finally create property in the sensed device
			 * (if one specified)
			 */
			refnode =  snodep->sdev_node;
			pname =  snodep->sdev_pname;
			if (refnode == NULL || pname == NULL)
				continue;

			err = ptree_get_node_by_path(refnode, &refnodeh);
			if (err == PICL_SUCCESS) {
				err = add_volatile_prop(refnodeh, pname,
				    PICL_PTYPE_INT, PICL_READ,
				    sizeof (tempr_t), get_current_temp,
				    NULL, &proph);
			}

			if (err != PICL_SUCCESS)
				break;

			/* Save prop handle */
			snodep->sdev_proph = proph;
		}
		if (err != PICL_SUCCESS) {
			delete_sensor_nodes_and_props();
			free_node_list(node_list);
			if (env_debug)
				envd_log(LOG_INFO,
				    "Can't create prop/node for sensor '%s'\n",
				    nodename);
			return (err);
		}
	}

	free_node_list(node_list);
	return (PICL_SUCCESS);
}

/*
 * Delete all sensor nodes and related properties created by the
 * add_sensor_prop() for each sensor node in the PICL tree.
 */
static void
delete_sensor_nodes_and_props(void)
{
	sensor_node_t	*snodep;

	/*
	 * Delete/destroy any property created in the sensed device
	 * as well as the sensor node and all properties under it.
	 * Note that deleiing/destroying a node deletes/destroys
	 * all properties within that node.
	 */

	for (snodep = sensor_nodes; snodep->sensor_name != NULL; snodep++) {
		if (snodep->sdev_proph != 0) {
			(void) ptree_delete_prop(snodep->sdev_proph);
			(void) ptree_destroy_prop(snodep->sdev_proph);
			snodep->sdev_proph = 0;
		}

		if (snodep->nodeh != 0) {
			/* delete node and all properties under it */
			(void) ptree_delete_node(snodep->nodeh);
			(void) ptree_destroy_node(snodep->nodeh);
			snodep->nodeh = 0;
			snodep->proph = 0;
		}
	}
}


/*
 * Lookup "fan-control" class node and create "fan" class nodes and
 * relevant properties under those nodes.
 *
 * For each entry in fan_nodes[] array, do the following:
 *	- Create specified "fan" class node.
 *	- Create "devfs-path" property under "fan" class node
 *	- Create "Speed" volatile propery under "fan" class node.
 *	- Create "SpeedUnit" property under "fan" class node.
 */

static int
add_fan_nodes_and_props(picl_nodehdl_t plath)
{
	int		err;
	char		*pname, *nodename, *devfs_path;
	env_fan_t	*fanp;
	fan_node_t	*fnodep;
	picl_nodehdl_t	nodeh, cnodeh;
	picl_prophdl_t	proph;
	node_list_t	*node_list, *listp;

	node_list =
	    get_node_list_by_class(plath, PICL_CLASS_FAN_CONTROL, NULL);

	if (node_list == NULL)
		return (PICL_FAILURE);

	for (listp = node_list; listp != NULL; listp = listp->next) {
		/*
		 * Add various fan nodes and properties
		 */
		nodeh = listp->nodeh;
		err = PICL_SUCCESS;
		for (fnodep = fan_nodes; fnodep->fan_name != NULL; fnodep++) {

			/* Skip if already initialized or no fan info */
			if (fnodep->nodeh != 0 || fnodep->fanp == NULL)
				continue;

			/*
			 * Create "fan" class node and save node handle
			 */
			nodename = fnodep->fan_name;
			err = ptree_create_and_add_node(nodeh, nodename,
			    PICL_CLASS_FAN, &cnodeh);
			if (env_debug)
				envd_log(LOG_INFO,
				    "Creating PICL fan node '%s' err:%d\n",
				    nodename, err);

			if (err != PICL_SUCCESS)
				break;
			fnodep->nodeh = cnodeh;

			/*
			 * Add "devfs_path" property in child node
			 */
			fanp = fnodep->fanp;
			devfs_path  = fanp->devfs_path;
			pname = PICL_PROP_DEVFS_PATH;
			err = add_regular_prop(cnodeh, pname,
			    PICL_PTYPE_CHARSTRING, PICL_READ,
			    strlen(devfs_path)+1, (void *)devfs_path, &proph);

			if (err != PICL_SUCCESS)
				break;

			/*
			 * Add "Speed" volatile property in this "fan"
			 * class node and save prop handle.
			 */
			pname = PICL_PROP_FAN_SPEED;
			err = add_volatile_prop(cnodeh, pname, PICL_PTYPE_INT,
			    PICL_READ, sizeof (fanspeed_t), get_current_speed,
			    NULL, &proph);

			if (err != PICL_SUCCESS)
				break;
			fnodep->proph = proph;

			/*
			 * Add other "fan" class properties
			 */
			pname = PICL_PROP_FAN_SPEED_UNIT;
			err = add_regular_prop(cnodeh, pname,
			    PICL_PTYPE_CHARSTRING, PICL_READ,
			    strlen(fnodep->speed_unit)+1,
			    (void *)fnodep->speed_unit, &proph);

			if (err != PICL_SUCCESS)
				break;
		}
		if (err != PICL_SUCCESS) {
			delete_fan_nodes_and_props();
			free_node_list(node_list);
			if (env_debug)
				envd_log(LOG_WARNING,
				    "Can't create prop/node for fan '%s'\n",
				    nodename);
			return (err);
		}
	}

	free_node_list(node_list);
	return (PICL_SUCCESS);
}


/*
 * Delete all fan nodes and related properties created by the
 * add_fan_props() for each fan node in the PICL tree.
 */
static void
delete_fan_nodes_and_props(void)
{
	fan_node_t	*fnodep;

	/*
	 * Delete/destroy fan node and all properties under it.
	 * Note that deleiing/destroying a node deletes/destroys
	 * all properties within that node.
	 */

	for (fnodep = fan_nodes; fnodep->fan_name != NULL; fnodep++) {
		if (fnodep->nodeh != 0) {
			(void) ptree_delete_node(fnodep->nodeh);
			(void) ptree_destroy_node(fnodep->nodeh);
			fnodep->nodeh = 0;
		}
	}
}

/*
 * Find the ENVMODEL_CONF_FILE file.
 */
static int
get_envmodel_conf_file(char *outfilename)
{
	char	nmbuf[SYS_NMLN];
	char    pname[PATH_MAX];

	if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
		(void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
		(void) strlcat(pname, ENVMODEL_CONF_FILE, PATH_MAX);
		if (access(pname, R_OK) == 0) {
			(void) strlcpy(outfilename, pname, PATH_MAX);
			return (0);
		}
	}

	if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) {
		(void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
		(void) strlcat(pname, ENVMODEL_CONF_FILE, PATH_MAX);
		if (access(pname, R_OK) == 0) {
			(void) strlcpy(outfilename, pname, PATH_MAX);
			return (0);
		}
	}

	(void) snprintf(pname, PATH_MAX, "%s/%s", PICLD_COMMON_PLUGIN_DIR,
	    ENVMODEL_CONF_FILE);

	if (access(pname, R_OK) == 0) {
		(void) strlcpy(outfilename, pname, PATH_MAX);
		return (0);
	}

	return (-1);
}

/* Delete all sensor/fan nodes and any properties created by this plugin */
void
env_picl_destroy(void)
{
	(void) pthread_rwlock_wrlock(&envpicl_rwlock);
	delete_fan_nodes_and_props();
	delete_sensor_nodes_and_props();
	(void) pthread_rwlock_unlock(&envpicl_rwlock);
}

void
env_picl_setup(void)
{
	int		err;
	sensor_node_t	*snodep;
	fan_node_t	*fnodep;
	picl_nodehdl_t	plath;
	char		fullfilename[PATH_MAX];
	picl_nodehdl_t  rooth;


	/*
	 * Initialize sensorp and other fields in the sensor_nodes[] array
	 */
	for (snodep = sensor_nodes; snodep->sensor_name != NULL; snodep++) {
		snodep->sensorp = sensor_lookup(snodep->sensor_name);
		snodep->nodeh = 0;
		snodep->proph = 0;
		snodep->target_proph = 0;
		snodep->sdev_proph = 0;
	}

	/*
	 * Initialize fanp and other fields in the fan_nodes[] array
	 */
	for (fnodep = fan_nodes; fnodep->fan_name != NULL; fnodep++) {
		fnodep->fanp = fan_lookup(fnodep->fan_name);
		fnodep->nodeh = 0;
		fnodep->proph = 0;
	}

	/*
	 * Get platform handle and populate PICL tree with environmental
	 * nodes and properties
	 */
	err = ptree_get_node_by_path("/platform", &plath);

	if (err == PICL_SUCCESS) {
		(void) pthread_rwlock_wrlock(&envpicl_rwlock);
		err = add_sensor_nodes_and_props(plath);
		if (err == PICL_SUCCESS)
			err = add_fan_nodes_and_props(plath);

		if (err != PICL_SUCCESS)
			delete_sensor_nodes_and_props();
		(void) pthread_rwlock_unlock(&envpicl_rwlock);
	}

	if (err != PICL_SUCCESS) {
		envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
		return;
	}

	/*
	 * Parse the envmodel.conf file and populate the PICL tree
	 */
	if (get_envmodel_conf_file(fullfilename) < 0)
		envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
	if (ptree_get_root(&rooth) != PICL_SUCCESS)
		envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
	err = picld_pluginutil_parse_config_file(rooth, fullfilename);

	if (err != PICL_SUCCESS)
		envd_log(LOG_CRIT, ENVD_PICL_SETUP_FAILED);
}