xref: /onnv-gate/usr/src/cmd/picl/plugins/sun4u/mpxu/frudr/piclfrudr.c (revision 12601:3fd4339427c7)

/*
 * 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 (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdio.h>
#include <stddef.h>
#include <syslog.h>
#include <strings.h>
#include <unistd.h>
#include <libintl.h>
#include <stdlib.h>
#include <ctype.h>
#include <picl.h>
#include <picltree.h>
#include <picld_pluginutil.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <sys/sysevent/dr.h>
#include <pthread.h>
#include <libdevinfo.h>
#include <limits.h>
#include <sys/systeminfo.h>
#include <sys/envmon.h>
#include <i2c_gpio.h>
#include "libdevice.h"
#include "picldefs.h"
#include <sys/raidioctl.h>
#include <sys/param.h>
#include <sys/epic.h>

/*
 * Plugin registration entry points
 */
static void	piclfrudr_register(void);
static void	piclfrudr_init(void);
static void	piclfrudr_fini(void);
static void	rmc_state_event(void);
static void	seattle_setleds(void);
static void	boston_set_frontleds(const char *, int);
static void	boston_set_rearleds(const char *, int);

#pragma	init(piclfrudr_register)

static picld_plugin_reg_t  my_reg_info = {
	PICLD_PLUGIN_VERSION_1,
	PICLD_PLUGIN_CRITICAL,
	"SUNW_MPXU_frudr",
	piclfrudr_init,
	piclfrudr_fini,
};

/*
 * Log message texts
 */
#define	EM_THREAD_CREATE_FAILED gettext("piclfrudr: pthread_create failed: %s")
#define	DELETE_PROP_FAIL gettext("ptree_delete_prop failed: %d")
#define	EM_DI_INIT_FAIL	gettext("piclfrudr: di_init failed: %s")
#define	PROPINFO_FAIL gettext("ptree_init_propinfo %s failed: %d")
#define	ADD_NODE_FAIL gettext("ptree_create_and_add_node %s failed: %d")
#define	ADD_TBL_ENTRY_FAIL gettext("piclfrudr: cannot add entry to table")
#define	EM_POLL_FAIL gettext("piclfrudr: poll() failed: %s")
#define	ADD_PROP_FAIL gettext("ptree_create_and_add_prop %s failed: %d")
#define	EM_MUTEX_FAIL gettext("piclfrudr: pthread_mutex_lock returned: %s")
#define	EM_UNK_FRU gettext("piclfrudr: Fru removed event for unknown node")
#define	PARSE_CONF_FAIL gettext("parse config file %s failed")
#define	EM_NO_SC_DEV gettext("piclfrudr: failed to locate SC device node")
#define	EM_NO_SYSINFO gettext("piclfrudr: failed to get SC sysinfo: %s")

/*
 * PICL property values
 */
#define	PICL_PROPVAL_ON		"ON"
#define	PICL_PROPVAL_OFF	"OFF"

/*
 * Local defines
 */
#define	SEEPROM_DRIVER_NAME	"seeprom"
#define	FRUTREE_PATH		"/frutree"
#define	CHASSIS_LOC_PATH	"/frutree/chassis/%s"
#define	SYS_BOARD_PATH		"/frutree/chassis/MB/system-board/%s"
#define	SEATTLE1U_HDDBP_PATH	\
	"/frutree/chassis/MB/system-board/HDDBP/disk-backplane-1/%s"
#define	SEATTLE2U_HDDBP_PATH	\
	"/frutree/chassis/MB/system-board/HDDBP/disk-backplane-3/%s"
#define	BOSTON_HDDBP_PATH	\
	"/frutree/chassis/MB/system-board/HDDCNTRL/disk-controller/HDDBP" \
	"/disk-backplane-8/%s"

#define	CONFFILE_PREFIX		"fru_"
#define	CONFFILE_SUFFIX		".conf"
#define	CONFFILE_FRUTREE	"piclfrutree.conf"
#define	PS_NAME			"PS"
#define	PS_NAME_LEN		2
#define	PS_FRU_NAME		"power-supply"
#define	PS_PLATFORM_NAME	"power-supply-fru-prom"
#define	DISK_NAME		"HDD"
#define	DISK_NAME_LEN		3
#define	DISK_FRU_NAME		"disk"
#define	SCC_NAME		"SCC"
#define	SCC_NAME_LEN		3
#define	SCC_FRU_NAME		"scc"
#define	RMC_NAME		"SC"
#define	RMC_NAME_LEN		2
#define	RMC_FRU_NAME		"sc"
#define	FT_NAME			"FT"
#define	FT_NAME_LEN		2
#define	F0_NAME			"F0"
#define	F0_NAME_LEN		2
#define	F1_NAME			"F1"
#define	F1_NAME_LEN		2
#define	FT_FRU_NAME		"fan-tray"
#define	FT_FRU_NAME_LEN	8
#define	FT_ID_BUFSZ		(FT_NAME_LEN + 2)
#define	DEV_PREFIX		"/devices"
#define	ENXS_FRONT_SRVC_LED	0x20
#define	ENXS_FRONT_ACT_LED	0x10
#define	ENXS_REAR_SRVC_LED	0x20
#define	ENXS_REAR_ACT_LED	0x10
#define	ENTS_SRVC_LED		0x20
#define	ENTS_ACT_LED		0x10
#define	V440_SRVC_LED		0x2
#define	V440_ACT_LED		0x1
#define	BOSTON_FRONT_SRVC_LED	0x2
#define	BOSTON_FRONT_ACT_LED	0x4
#define	BOSTON_FRONT_CLEAR_DIR	0x0
#define	BOSTON_FRONT_CLEAR_POL	0x0
#define	BOSTON_FRONT_LED_MASK	0xffffffff
#define	BOSTON_REAR_SRVC_LED	0x8000
#define	BOSTON_REAR_ACT_LED	0x2000
#define	BOSTON_REAR_CLEAR_POL	0x0000
#define	BOSTON_REAR_LED_MASK	0xe000

/*
 * PSU defines
 */
#define	PSU_I2C_BUS_DEV "/devices/pci@1e,600000/isa@7/i2c@0,320:devctl"
#define	PSU_DEV	\
	"/devices/pci@1e,600000/isa@7/i2c@0,320/power-supply-fru-prom@0,%x"
#define	PSU_PLATFORM	"/platform/pci@1e,600000/isa@7/i2c@0,320"
#define	PS0_ADDR ((sys_platform == PLAT_CHALUPA19) ? 0xc0 : 0xb0)
#define	PS1_ADDR ((sys_platform == PLAT_CHALUPA19) ? 0xc2 : 0xa4)
#define	PS2_ADDR 0x70
#define	PS3_ADDR 0x72
#define	PS0_UNITADDR	((sys_platform == PLAT_CHALUPA19) ? "0,c0" : "0,b0")
#define	PS1_UNITADDR	((sys_platform == PLAT_CHALUPA19) ? "0,c2" : "0,a4")
#define	PS2_UNITADDR	"0,70"
#define	PS3_UNITADDR	"0,72"
#define	PS0_NAME "PS0"
#define	PS1_NAME "PS1"
#define	PS2_NAME "PS2"
#define	PS3_NAME "PS3"
#define	PSU0_NAME "PSU0"
#define	PSU1_NAME "PSU1"
#define	PSU2_NAME "PSU2"
#define	PSU3_NAME "PSU3"
#define	PS_DEVICE_NAME "power-supply-fru-prom"
#define	PSU_COMPATIBLE	"i2c-at24c64"

/*
 * Seattle/Boston PSU defines
 */
#define	SEATTLE_PSU_I2C_BUS_DEV "/devices/i2c@1f,530000:devctl"
#define	SEATTLE_PSU_DEV	\
	"/devices/i2c@1f,530000/power-supply-fru-prom@0,%x"
#define	SEATTLE_PSU_PLATFORM	"/platform/i2c@1f,530000"
#define	SEATTLE_PS0_ADDR	0x6c
#define	SEATTLE_PS1_ADDR	0x6e
#define	SEATTLE_PS0_UNITADDR	"0,6c"
#define	SEATTLE_PS1_UNITADDR	"0,6e"
#define	SEATTLE_PSU_COMPATIBLE	"i2c-at34c02"
#define	BOSTON_PSU_I2C_BUS_DEV	"/devices/i2c@1f,520000:devctl"
#define	BOSTON_PSU_DEV	\
	"/devices/i2c@1f,520000/power-supply-fru-prom@0,%x"
#define	BOSTON_PSU_PLATFORM	"/platform/i2c@1f,520000"
#define	BOSTON_PS0_ADDR		0x24
#define	BOSTON_PS1_ADDR		0x32
#define	BOSTON_PS2_ADDR		0x52
#define	BOSTON_PS3_ADDR		0x72
#define	BOSTON_PS0_UNITADDR	"0,24"
#define	BOSTON_PS1_UNITADDR	"0,32"
#define	BOSTON_PS2_UNITADDR	"0,52"
#define	BOSTON_PS3_UNITADDR	"0,72"
#define	BOSTON_PSU_COMPATIBLE	"i2c-at34c02"

/*
 * Seattle fan-tray paths
 */
#define	SEATTLE_FCB0_1U \
	"/frutree/chassis/MB/system-board/FIOB/front-io-board-1" \
	"/FCB0/fan-connector-board/%s"
#define	SEATTLE_FCB1_1U \
	"/frutree/chassis/MB/system-board/FIOB/front-io-board-1" \
	"/FCB1/fan-connector-board/%s"
#define	SEATTLE_PDB_1U \
	"/frutree/chassis/PDB/power-distribution-board/%s"
#define	SEATTLE_FCB0_2U	\
	"/frutree/chassis/MB/system-board/FIOB/front-io-board-2" \
	"/FCB0/fan-connector-board/%s"
#define	SEATTLE_FCB1_2U \
	"/frutree/chassis/MB/system-board/FIOB/front-io-board-2" \
	"/FCB1/fan-connector-board/%s"
#define	SEATTLE_PDB_2U \
	"/frutree/chassis/PDB/power-distribution-board" \
	"/HDDFB/fan-connector-board/%s"

/*
 * disk defines
 */
#define	REMOK_LED "OK2RM"
#define	FAULT_LED "SERVICE"
#define	PLATFORMLEN 9
#define	N_DISKS 8
#define	N_CHALUPA_DISKS 4
#define	N_ENTS_DISKS 8
#define	N_MPXU_DISKS 4
#define	N_EN19_DISKS 2
#define	DISK_POLL_TIME	5000
/* For V440 RAID policy */
#define	V440_DISK_DEVCTL "/devices/pci@1f,700000/scsi@2:devctl"

/*
 * Seattle/Boston disk defines
 */
#define	N_SEATTLE1U_DISKS	2
#define	N_SEATTLE2U_DISKS	4
#define	N_BOSTON_DISKS		8
#define	SEATTLE_DISK_DEVCTL \
	"/devices/pci@1e,600000/pci@0/pci@a/pci@0/pci@8/scsi@1:devctl"
#define	BOSTON_DISK_DEVCTL_1068X \
	"/devices/pci@1f,700000/pci@0/pci@2/pci@0/pci@8/LSILogic,sas@1:devctl"
#define	BOSTON_DISK_DEVCTL_1068E \
	"/devices/pci@1e,600000/pci@0/pci@2/scsi@0:devctl"

/*
 * led defines
 */
#define	ENXS_LED_DIR	"/devices/pci@1e,600000/isa@7/i2c@0,320/"
#define	ENXS_FRONT_LEDS	"gpio@0,70:"
#define	ENXS_REAR_LEDS	ENXS_LED_DIR "gpio@0,44:port_1"

#define	ENTS_LED_DIR	"/devices/pci@1e,600000/isa@7/i2c@0,320/"
#define	ENTS_LEDS	"gpio@0,70:"

#define	V440_LED_DIR	"/devices/pci@1e,600000/isa@7/i2c@0,320/"
#define	V440_LED_PATH	V440_LED_DIR "gpio@0,48:port_0"

/*
 * Seattle/Boston led defines
 */
#define	SEATTLE_LED_DEV	"/devices/ebus@1f,464000/env-monitor@3,0:env-monitor0"
#define	BOSTON_LED_DIR	"/devices/i2c@1f,520000/"
#define	BOSTON_FRONT_LED_PATH	BOSTON_LED_DIR "gpio@0,3a:port_0"
#define	BOSTON_REAR_LED_PATH	BOSTON_LED_DIR "hardware-monitor@0,5c:adm1026"

/*
 * Seattle/Boston USB defines
 */
#define	MAX_USB_PORTS		4
#define	USB_CONF_FILE_NAME	"usb-a-"

typedef struct id_props {
	envmon_handle_t	envhandle;
	picl_prophdl_t	volprop;
} id_props_t;

typedef struct idp_lkup {
	int		maxnum;		/* entries in array */
	int		num;		/* entries in use */
	id_props_t	idp[1];
} idp_lkup_t;

/*
 * table for mapping RMC handles to volatile property handles
 */
static idp_lkup_t	*idprop = NULL;

/*
 * path names to system-controller device and fault led gpio
 */
static char		*sc_device_name = NULL;
static char		*bezel_leds = NULL;

/*
 * disk data
 */
static int disk_ready[N_DISKS];
static char *disk_name[N_DISKS] = { "HDD0", "HDD1", "HDD2", "HDD3",
					"HDD4", "HDD5", "HDD6", "HDD7" };
static volatile boolean_t	disk_leds_thread_ack = B_FALSE;
static volatile	boolean_t	disk_leds_thread_running = B_FALSE;
static pthread_t		ledsthr_tid;
static pthread_attr_t		ledsthr_attr;
static boolean_t		ledsthr_created = B_FALSE;
static boolean_t		g_mutex_init = B_FALSE;
static pthread_cond_t		g_cv;
static pthread_cond_t		g_cv_ack;
static pthread_mutex_t		g_mutex;
static volatile boolean_t	g_finish_now = B_FALSE;

/*
 * Boston platform-specific flag which tells us if we are using
 * a LSI 1068X disk controller (0) or a LSI 1068E (1).
 */
static int boston_1068e_flag = 0;

/*
 * static strings
 */
static const char		str_devfs_path[] = "devfs-path";

/*
 * OperationalStatus property values
 */
static const char		str_opst_present[] = "present";
static const char		str_opst_ok[] = "okay";
static const char		str_opst_faulty[] = "faulty";
static const char		str_opst_download[] = "download";
static const char		str_opst_unknown[] = "unknown";
static size_t			max_opst_len = sizeof (str_opst_download);

/*
 * forward reference
 */
static void opst_init(void);
static void add_op_status_by_name(const char *name, const char *child_name,
    picl_prophdl_t *prophdl_p);
static void add_op_status_to_node(picl_nodehdl_t nodeh,
    picl_prophdl_t *prophdl_p);
static int read_vol_data(ptree_rarg_t *r_arg, void *buf);
static int find_picl_handle(picl_prophdl_t proph);
static void disk_leds_init(void);
static void disk_leds_fini(void);
static void *disk_leds_thread(void *args);
static picl_nodehdl_t find_child_by_name(picl_nodehdl_t parh, char *name);
static void post_frudr_event(char *ename, picl_nodehdl_t parenth,
    picl_nodehdl_t fruh);
static int add_prop_ref(picl_nodehdl_t nodeh, picl_nodehdl_t value, char *name);
static void remove_fru_parents(picl_nodehdl_t fruh);
static int get_node_by_class(picl_nodehdl_t nodeh, const char *classname,
    picl_nodehdl_t *foundnodeh);
static int get_sys_controller_node(picl_nodehdl_t *nodeh);
static char *create_sys_controller_pathname(picl_nodehdl_t sysconh);
static char *create_bezel_leds_pathname(const char *dirpath,
    const char *devname);
static void frudr_evhandler(const char *ename, const void *earg,
    size_t size, void *cookie);
static void fru_add_handler(const char *ename, const void *earg,
    size_t size, void *cookie);
static void frutree_evhandler(const char *ename, const void *earg,
	size_t size, void *cookie);
static int create_table(picl_nodehdl_t fruhdl, picl_prophdl_t *tblhdlp,
    char *tbl_name);
static int create_table_entry(picl_prophdl_t tblhdl,
    picl_nodehdl_t refhdl, char *class);
static int create_i2c_node(char *ap_id);
static void delete_i2c_node(char *ap_id);
static int set_led(char *name, char *ptr, char *value);
static int ps_name_to_addr(char *name);
static char *ps_name_to_unitaddr(char *name);
static char *ps_apid_to_nodename(char *apid);
static void add_op_status(envmon_hpu_t *hpu, int *index);
static void get_fantray_path(char *ap_id, char *path, int bufsz);

#define	sprintf_buf2(buf, a1, a2) (void) snprintf(buf, sizeof (buf), a1, a2)

/*
 * Because this plugin is shared across different platforms, we need to
 * distinguish for certain functionality
 */
#define	PLAT_UNKNOWN	(-1)
#define	PLAT_ENXS	0
#define	PLAT_ENTS	1
#define	PLAT_CHALUPA	2
#define	PLAT_EN19	3
#define	PLAT_CHALUPA19	4
#define	PLAT_SALSA19	5
#define	PLAT_SEATTLE1U	6
#define	PLAT_SEATTLE2U	7
#define	PLAT_BOSTON	8

static int sys_platform;

static void
get_platform()
{
	char	platform[64];
	(void) sysinfo(SI_PLATFORM, platform, sizeof (platform));
	if (strcmp(platform, "SUNW,Sun-Fire-V250") == 0)
		sys_platform = PLAT_ENTS;
	else if (strcmp(platform, "SUNW,Sun-Fire-V440") == 0)
		sys_platform = PLAT_CHALUPA;
	else if (strcmp(platform, "SUNW,Sun-Fire-V210") == 0)
		sys_platform = PLAT_ENXS;
	else if (strcmp(platform, "SUNW,Sun-Fire-V240") == 0)
		sys_platform = PLAT_ENXS;
	else if (strcmp(platform, "SUNW,Netra-240") == 0)
		sys_platform = PLAT_EN19;
	else if (strcmp(platform, "SUNW,Netra-210") == 0)
		sys_platform = PLAT_SALSA19;
	else if (strcmp(platform, "SUNW,Netra-440") == 0)
		sys_platform = PLAT_CHALUPA19;
	else if (strcmp(platform, "SUNW,Sun-Fire-V215") == 0)
		sys_platform = PLAT_SEATTLE1U;
	else if (strcmp(platform, "SUNW,Sun-Fire-V245") == 0)
		sys_platform = PLAT_SEATTLE2U;
	else if (strcmp(platform, "SUNW,Sun-Fire-V445") == 0)
		sys_platform = PLAT_BOSTON;
	else
		sys_platform = PLAT_UNKNOWN;
}

/*
 * This function is executed as part of .init when the plugin is
 * dlopen()ed
 */
static void
piclfrudr_register(void)
{
	(void) picld_plugin_register(&my_reg_info);
}

/*
 * This function is the init entry point of the plugin.
 * It initializes the /frutree tree
 */
static void
piclfrudr_init(void)
{
	picl_nodehdl_t	sc_nodeh;
	picl_nodehdl_t	locationh;
	picl_nodehdl_t	childh;
	char namebuf[PATH_MAX];

	get_platform();

	if (sc_device_name != NULL) {
		free(sc_device_name);	/* must have reen restarted */
		sc_device_name = NULL;
	}

	if ((get_sys_controller_node(&sc_nodeh) != PICL_SUCCESS) ||
	    ((sc_device_name = create_sys_controller_pathname(sc_nodeh)) ==
	    NULL))
		syslog(LOG_ERR, EM_NO_SC_DEV);

	opst_init();
	disk_leds_init();

	(void) ptree_register_handler(PICLEVENT_DR_AP_STATE_CHANGE,
	    frudr_evhandler, NULL);
	(void) ptree_register_handler(PICL_FRU_ADDED, fru_add_handler, NULL);
	(void) ptree_register_handler(PICLEVENT_SYSEVENT_DEVICE_ADDED,
	    frutree_evhandler, NULL);

	/*
	 * There is a window of opportunity for the RMC to deliver an event
	 * indicating a newly operable state just before we are listening for
	 * it. In this case, envmon will have missed setting up /platform
	 * and won't get a signal from frudr. So send it a PICL_FRU_ADDED just
	 * in case.
	 */

	if ((sys_platform == PLAT_CHALUPA) ||
	    (sys_platform == PLAT_CHALUPA19)) {
		sprintf_buf2(namebuf, CHASSIS_LOC_PATH, RMC_NAME);
	} else {
		sprintf_buf2(namebuf, SYS_BOARD_PATH, RMC_NAME);
	}

	if (ptree_get_node_by_path(namebuf, &locationh) != PICL_SUCCESS)
		return;
	if (ptree_get_propval_by_name(locationh, PICL_PROP_CHILD,
	    &childh, sizeof (picl_nodehdl_t)) != PICL_SUCCESS)
		return;
	post_frudr_event(PICL_FRU_ADDED, locationh, childh);
}

static void
add_op_status_by_name(const char *name, const char *child_name,
    picl_prophdl_t *prophdl_p)
{
	picl_nodehdl_t		nodeh;

	if (ptree_get_node_by_path(name, &nodeh) != PICL_SUCCESS) {
		return;
	}

	if (ptree_get_propval_by_name(nodeh, PICL_PROP_CHILD,
	    &nodeh, sizeof (picl_nodehdl_t)) != PICL_SUCCESS) {

		if (child_name == NULL)
			return;
		/*
		 * create fru node of supplied name
		 */
		if (ptree_create_and_add_node(nodeh, child_name,
		    PICL_CLASS_FRU, &nodeh) != PICL_SUCCESS)
			return;
	}

	add_op_status_to_node(nodeh, prophdl_p);
}

/*
 * function to add a volatile property to a specified node
 */
static void
add_op_status_to_node(picl_nodehdl_t nodeh, picl_prophdl_t *prophdl_p)
{
	int			err;
	ptree_propinfo_t	info;
	picl_prophdl_t		proph;

	err = ptree_init_propinfo(&info, PTREE_PROPINFO_VERSION,
	    PICL_PTYPE_CHARSTRING, PICL_VOLATILE | PICL_READ, max_opst_len,
	    PICL_PROP_OPERATIONAL_STATUS, read_vol_data, NULL);

	if (err == PICL_SUCCESS) {
		if (ptree_get_prop_by_name(nodeh, PICL_PROP_OPERATIONAL_STATUS,
		    &proph) == PICL_SUCCESS) {
			if (ptree_delete_prop(proph) == PICL_SUCCESS)
				err = ptree_destroy_prop(proph);
		}
	}

	if ((err != PICL_SUCCESS) || ((err = ptree_create_and_add_prop(nodeh,
	    &info, NULL, prophdl_p)) != PICL_SUCCESS)) {
		syslog(LOG_ERR, ADD_PROP_FAIL, PICL_PROP_OPERATIONAL_STATUS,
		    err);
		return;
	}
}

/*
 * Deliver volatile property value.
 * prtpicl gets very upset if we fail this command, so if the property
 * cannot be retrieved, return a status of unknown.
 */
static int
read_vol_data(ptree_rarg_t *r_arg, void *buf)
{
	picl_prophdl_t	proph;
	int		index;
	int		envmon_fd;
	int		err;
	envmon_hpu_t	data;

	proph = r_arg->proph;
	index = find_picl_handle(proph);

	if (index < 0) {
		/*
		 * We drop memory of PSU op status handles in opst_init()
		 * when we get an RMC faulty event. We cannot access the
		 * status info in this circumstance, so returning "unknown"
		 * is appropriate.
		 */
		(void) strlcpy(buf, str_opst_unknown, max_opst_len);
		return (PICL_SUCCESS);
	}

	envmon_fd = open(sc_device_name, O_RDONLY);

	if (envmon_fd < 0) {
		/*
		 * To get this far we must have succeeded with an earlier
		 * open, so this is an unlikely failure. It would be more
		 * helpful to indicate the nature of the failure, but we
		 * don't have the space to say much. Just return "unknown".
		 */
		(void) strlcpy(buf, str_opst_unknown, max_opst_len);
		return (PICL_SUCCESS);
	}

	data.id = idprop->idp[index].envhandle;
	err = ioctl(envmon_fd, ENVMONIOCHPU, &data);

	if (err < 0) {
		/*
		 * If we can't read the stats, "unknown" is a reasonable
		 * status to return. This one really shouldn't happen.
		 */
		(void) strlcpy(buf, str_opst_unknown, max_opst_len);
		(void) close(envmon_fd);
		return (PICL_SUCCESS);
	}

	(void) close(envmon_fd);

	if (strncmp(data.id.name, DISK_NAME, DISK_NAME_LEN) == 0 &&
	    data.fru_status == ENVMON_FRU_PRESENT) {
		(void) strlcpy(buf, str_opst_present, max_opst_len);
		return (PICL_SUCCESS);
	}

	if (data.sensor_status != ENVMON_SENSOR_OK) {
		(void) strlcpy(buf, str_opst_unknown, max_opst_len);
		return (PICL_SUCCESS);
	}

	(void) strlcpy(buf,
	    data.fru_status == ENVMON_FRU_PRESENT ? str_opst_ok :
	    data.fru_status == ENVMON_FRU_DOWNLOAD ? str_opst_download :
	    data.fru_status == ENVMON_FRU_FAULT ? str_opst_faulty :
	    str_opst_unknown, max_opst_len);

	return (PICL_SUCCESS);
}

/*
 * Function for explicitly turning on system leds
 * for a failed/degraded RMC (SC).
 */
static void
solaris_setleds(const char *led_path, int leds)
{
	i2c_gpio_t	gpio;
	int		fd = open(led_path, O_RDWR);

	if (fd < 0)
		return;

	gpio.reg_val = (leds ^ 0xff);
	gpio.reg_mask = 0xffffffff;
	if (ioctl(fd, GPIO_SET_CONFIG, &gpio) == 0) {
		gpio.reg_val = (leds ^ 0xff);
		gpio.reg_mask = 0xffffffff;
		(void) ioctl(fd, GPIO_SET_OUTPUT, &gpio);
	}
	(void) close(fd);
}

/*
 * Function for explicitly turning on system leds
 * for a failed/degraded RMC (SC) on Seattle
 */
static void
seattle_setleds(void)
{
	int fd;

	fd = open(SEATTLE_LED_DEV, O_RDWR);

	if (fd < 0)
		return;

	ioctl(fd, EPIC_SET_POWER_LED, (char *)0);
	ioctl(fd, EPIC_SET_ALERT_LED, (char *)0);
	(void) close(fd);
}

/*
 * Function for explicitly turning on the front system leds
 * for a failed/degraded RMC (SC) on Boston
 */
static void
boston_set_frontleds(const char *led_path, int leds)
{
	i2c_gpio_t	gpio;
	int		fd = open(led_path, O_RDWR);

	if (fd < 0) {
		return;
	}

	/* first clear the polarity */
	gpio.reg_val  = BOSTON_FRONT_CLEAR_POL;
	gpio.reg_mask = BOSTON_FRONT_LED_MASK;
	if (ioctl(fd, GPIO_SET_POLARITY, &gpio) < 0)	{
		(void) close(fd);
		return;
	}

	/* now clear the direction */
	gpio.reg_val  = BOSTON_FRONT_CLEAR_DIR;
	gpio.reg_mask = BOSTON_FRONT_LED_MASK;
	if (ioctl(fd, GPIO_SET_CONFIG, &gpio) < 0)	{
		(void) close(fd);
		return;
	}

	/* and light the leds */
	gpio.reg_val = leds;
	gpio.reg_mask = BOSTON_FRONT_LED_MASK;
	ioctl(fd, GPIO_SET_OUTPUT, &gpio);
	(void) close(fd);
}

/*
 * Function for explicitly turning on the rear system leds
 * for a failed/degraded RMC (SC) on Boston
 */
static void
boston_set_rearleds(const char *led_path, int leds)
{
	i2c_gpio_t	gpio;
	int		fd = open(led_path, O_RDWR);

	if (fd < 0) {
		return;
	}

	/* first clear the polarity */
	gpio.reg_val  = BOSTON_REAR_CLEAR_POL;
	gpio.reg_mask = BOSTON_REAR_LED_MASK;
	if (ioctl(fd, GPIO_SET_POLARITY, &gpio) < 0)	{
		(void) close(fd);
		return;
	}

	/* now set the direction */
	gpio.reg_val  = BOSTON_REAR_LED_MASK;
	gpio.reg_mask = BOSTON_REAR_LED_MASK;
	if (ioctl(fd, GPIO_SET_CONFIG, &gpio) < 0)	{
		(void) close(fd);
		return;
	}

	/* and light the leds */
	gpio.reg_val = leds;
	gpio.reg_mask = BOSTON_REAR_LED_MASK;
	ioctl(fd, GPIO_SET_OUTPUT, &gpio);
	(void) close(fd);
}

static void
rmc_state_event(void)
{
	envmon_hpu_t	hpu;
	int		res;
	int		fd = open(sc_device_name, O_RDONLY);

	if (fd < 0)
		return;

	(void) strlcpy(hpu.id.name, RMC_NAME, sizeof (hpu.id.name));
	res = ioctl(fd, ENVMONIOCHPU, &hpu);
	(void) close(fd);

	if ((res == 0) && (hpu.sensor_status == ENVMON_SENSOR_OK) &&
	    ((hpu.fru_status & ENVMON_FRU_FAULT) != 0)) {
		/*
		 * SC failed event - light the service led
		 * note that as Solaris is still running,
		 * the Solaris active led should be lit too.
		 */
		switch (sys_platform) {
		case PLAT_ENXS:
		case PLAT_SALSA19:
		case PLAT_EN19:
			solaris_setleds(ENXS_REAR_LEDS,
			    ENXS_REAR_SRVC_LED | ENXS_REAR_ACT_LED);
			/*
			 * the device name for the bezel leds GPIO device
			 * tends to vary from Unix to Unix. Search for it.
			 */
			if (bezel_leds  == NULL) {
				bezel_leds =
				    create_bezel_leds_pathname(ENXS_LED_DIR,
				    ENXS_FRONT_LEDS);
			}
			if (bezel_leds == NULL)
				return;
			solaris_setleds(bezel_leds,
			    ENXS_FRONT_SRVC_LED | ENXS_FRONT_ACT_LED);
			break;
		case PLAT_ENTS:
			/*
			 * the device name for the system leds gpio can vary
			 * as there are several similar gpio devices. Search
			 * for one with the desired address.
			 */
			if (bezel_leds  == NULL) {
				bezel_leds =
				    create_bezel_leds_pathname(ENTS_LED_DIR,
				    ENTS_LEDS);
			}
			if (bezel_leds == NULL)
				return;
			solaris_setleds(bezel_leds,
			    ENTS_SRVC_LED | ENTS_ACT_LED);
			break;
		case PLAT_CHALUPA:
		case PLAT_CHALUPA19:
			solaris_setleds(V440_LED_PATH,
			    V440_SRVC_LED | V440_ACT_LED);
			break;
		case PLAT_BOSTON:
			/* set front leds */
			boston_set_frontleds(BOSTON_FRONT_LED_PATH,
			    BOSTON_FRONT_SRVC_LED | BOSTON_FRONT_ACT_LED);
			/* and then the rear leds */
			boston_set_rearleds(BOSTON_REAR_LED_PATH,
			    BOSTON_REAR_SRVC_LED | BOSTON_REAR_ACT_LED);
			break;
		case PLAT_SEATTLE1U:
		case PLAT_SEATTLE2U:
			seattle_setleds();
			break;
		default:
			break;
		}
	}
}

static int
find_picl_handle(picl_prophdl_t proph)
{
	int index;

	if (idprop == NULL)
		return (-1);

	for (index = 0; index < idprop->num; index++) {
		if (idprop->idp[index].volprop == proph)
			return (index);
	}

	return (-1);
}

static int
find_vol_prop_by_name(const char *name)
{
	int index;

	if (idprop == NULL)
		return (-1);

	for (index = 0; index < idprop->num; index++) {
		if (strcmp(idprop->idp[index].envhandle.name, name) == 0)
			return (index);
	}

	return (-1);
}

/*
 * This function is the fini entry point of the plugin.
 */
static void
piclfrudr_fini(void)
{
	(void) ptree_unregister_handler(PICLEVENT_DR_AP_STATE_CHANGE,
	    frudr_evhandler, NULL);
	(void) ptree_unregister_handler(PICL_FRU_ADDED, fru_add_handler,
	    NULL);
	disk_leds_fini();
	if (idprop != NULL) {
		free(idprop);
		idprop = NULL;
	}
	if (sc_device_name != NULL) {
		free(sc_device_name);
		sc_device_name = NULL;
	}
}

/*
 * subroutine for various functions. Finds immediate child of parh with
 * requested name if present. Otherwise returns NULL.
 */
static picl_nodehdl_t
find_child_by_name(picl_nodehdl_t parh, char *name)
{
	picl_nodehdl_t nodeh;
	int err;
	char	nodename[PICL_PROPNAMELEN_MAX];

	err = ptree_get_propval_by_name(parh, PICL_PROP_CHILD,
	    &nodeh, sizeof (picl_nodehdl_t));
	if (err != PICL_SUCCESS)
		return (NULL);
	for (;;) {
		err = ptree_get_propval_by_name(nodeh, PICL_PROP_NAME, nodename,
		    sizeof (nodename));
		if (err != PICL_SUCCESS)
			return (NULL);
		if (strcmp(name, nodename) == 0) {
			return (nodeh);
		}
		err = ptree_get_propval_by_name(nodeh, PICL_PROP_PEER,
		    &nodeh, sizeof (picl_nodehdl_t));
		if (err != PICL_SUCCESS)
			return (NULL);
	}
}

/* Creates a reference property for a given PICL node */
static int
add_prop_ref(picl_nodehdl_t nodeh, picl_nodehdl_t value, char *name)
{
	picl_prophdl_t proph;
	ptree_propinfo_t propinfo;
	int err;

	err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
	    PICL_PTYPE_REFERENCE, PICL_READ, sizeof (picl_nodehdl_t), name,
	    NULL, NULL);
	if (err != PICL_SUCCESS) {
		syslog(LOG_ERR, PROPINFO_FAIL, name, err);
		return (err);
	}
	err = ptree_create_and_add_prop(nodeh, &propinfo, &value, &proph);
	if (err != PICL_SUCCESS) {
		syslog(LOG_ERR, ADD_PROP_FAIL, name, err);
		return (err);
	}
	return (PICL_SUCCESS);
}

/* create an entry in the specified table */
static int
create_table_entry(picl_prophdl_t tblhdl, picl_nodehdl_t refhdl, char *class)
{
	int			err;
	ptree_propinfo_t	prop;
	picl_prophdl_t		prophdl[2];

	/* first column is class */
	prop.version = PTREE_PROPINFO_VERSION;
	prop.piclinfo.type =  PICL_PTYPE_CHARSTRING;
	prop.piclinfo.accessmode = PICL_READ;
	prop.piclinfo.size = PICL_CLASSNAMELEN_MAX;
	prop.read = NULL;
	prop.write = NULL;
	(void) strlcpy(prop.piclinfo.name, PICL_PROP_CLASS,
	    sizeof (prop.piclinfo.name));
	err = ptree_create_prop(&prop, class, &prophdl[0]);
	if (err != PICL_SUCCESS) {
		syslog(LOG_ERR, ADD_TBL_ENTRY_FAIL, err);
		return (err);
	}

	/* second column is reference property */
	prop.version = PTREE_PROPINFO_VERSION;
	prop.piclinfo.type =  PICL_PTYPE_REFERENCE;
	prop.piclinfo.accessmode = PICL_READ;
	prop.piclinfo.size = sizeof (picl_nodehdl_t);
	prop.read = NULL;
	prop.write = NULL;
	sprintf_buf2(prop.piclinfo.name, "_%s_", class);
	err = ptree_create_prop(&prop, &refhdl, &prophdl[1]);
	if (err != PICL_SUCCESS) {
		syslog(LOG_ERR, ADD_TBL_ENTRY_FAIL, err);
		return (err);
	}

	/* add row to table */
	err = ptree_add_row_to_table(tblhdl, 2, prophdl);
	if (err != PICL_SUCCESS)
		syslog(LOG_ERR, ADD_TBL_ENTRY_FAIL, err);
	return (err);
}

/* create an empty table property */
static int
create_table(picl_nodehdl_t fruhdl, picl_prophdl_t *tblhdlp, char *tbl_name)
{
	int			err;
	ptree_propinfo_t	prop;
	picl_prophdl_t		tblprophdl;

	err = ptree_create_table(tblhdlp);
	if (err != PICL_SUCCESS) {
		syslog(LOG_ERR, ADD_PROP_FAIL, tbl_name, err);
		return (err);
	}
	prop.version = PTREE_PROPINFO_VERSION;
	prop.piclinfo.type =  PICL_PTYPE_TABLE;
	prop.piclinfo.accessmode = PICL_READ;
	prop.piclinfo.size = sizeof (picl_prophdl_t);
	prop.read = NULL;
	prop.write = NULL;
	(void) strlcpy(prop.piclinfo.name, tbl_name,
	    sizeof (prop.piclinfo.name));
	err = ptree_create_and_add_prop(fruhdl, &prop, tblhdlp, &tblprophdl);
	if (err != PICL_SUCCESS)
		syslog(LOG_ERR, ADD_PROP_FAIL, tbl_name, err);
	return (err);
}

/*
 * The size of outfilename must be PATH_MAX
 */
static int
get_config_file(char *outfilename, char *fru)
{
	char		nmbuf[SYS_NMLN];
	char		pname[PATH_MAX];
	int		dir;

	for (dir = 0; dir < 2; dir++) {
		if (sysinfo(dir == 0 ? SI_PLATFORM : SI_MACHINE,
		    nmbuf, sizeof (nmbuf)) == -1) {
			continue;
		}

		(void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
		(void) strlcat(pname, CONFFILE_PREFIX, PATH_MAX);
		(void) strlcat(pname, fru, PATH_MAX);
		(void) strlcat(pname, CONFFILE_SUFFIX, PATH_MAX);

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

	(void) snprintf(pname, PATH_MAX, "%s/%s%s%s",
	    PICLD_COMMON_PLUGIN_DIR, CONFFILE_PREFIX, fru,
	    CONFFILE_SUFFIX);

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

	return (-1);
}

/*
 * This helper function for Netra-440 fan tray removal removes
 * the rmclomv-rooted nodes and their properties.
 */
static void
delete_node_and_props(picl_nodehdl_t hdl)
{
	picl_prophdl_t prop;
	int err;

	do {
		err = ptree_get_first_prop(hdl, &prop);
		if (err == PICL_SUCCESS) {
			if (ptree_delete_prop(prop) == PICL_SUCCESS)
				(void) ptree_destroy_prop(prop);
		}
	} while (err == PICL_SUCCESS);
	if (ptree_delete_node(hdl) == PICL_SUCCESS)
		(void) ptree_destroy_node(hdl);
}

static void
remove_fru_parents(picl_nodehdl_t fruh)
{
	char			name[MAXPATHLEN];
	int			retval;
	picl_nodehdl_t		nodeh;
	picl_prophdl_t		tableh;
	picl_prophdl_t		tblh;
	picl_prophdl_t		fruph;
	picl_nodehdl_t		childh;
	int			fanfru = 0;

	retval = ptree_get_propval_by_name(fruh, PICL_PROP_NAME, name,
	    sizeof (name));
	if (retval != PICL_SUCCESS) {
		syslog(LOG_ERR, EM_UNK_FRU);
		return;
	}

	retval = ptree_get_prop_by_name(fruh, PICL_PROP_DEVICES, &tableh);
	if (retval != PICL_SUCCESS) {
		/*
		 * No Devices table. However on Seattle, Boston and
		 * Netra-440 (Chalupa19) (which support fan fru hotplug),
		 * the Devices table will be found under the child node (Fn)
		 * of the fru (fan-tray).
		 * Therefore, check the first child of the fru for the
		 * Devices table on these platforms before returning.
		 */
		switch (sys_platform) {
		case PLAT_SEATTLE1U:
		case PLAT_SEATTLE2U:
		case PLAT_BOSTON:
			if (strcmp(name, FT_FRU_NAME) != 0)
				return;
			fanfru = 1;
			break;
		case PLAT_CHALUPA19:
			if (strncmp(name, F0_NAME, F0_NAME_LEN) &&
			    strncmp(name, F1_NAME, F1_NAME_LEN))
				return;
			fanfru = 1;
			break;
		default:
			/* nothing to do */
			return;
		}
		retval = ptree_get_propval_by_name(fruh,
		    PICL_PROP_CHILD, &childh, sizeof (picl_nodehdl_t));
		if (retval != PICL_SUCCESS)
			return;
		retval = ptree_get_prop_by_name(childh,
		    PICL_PROP_DEVICES, &tableh);
		if (retval != PICL_SUCCESS)
			return;
	}

	/*
	 * follow all reference properties in the second
	 * column of the table and delete any _fru_parent node
	 * at the referenced node.
	 */
	retval = ptree_get_propval(tableh, &tblh, sizeof (tblh));
	if (retval != PICL_SUCCESS) {
		/* can't get value of table property */
		goto afterloop;
	}

	/* get first col, first row */
	retval = ptree_get_next_by_col(tblh, &tblh);
	if (retval != PICL_SUCCESS) {
		/* no rows? */
		goto afterloop;
	}

	/*
	 * starting at next col, get every entry in the column
	 */
	for (retval = ptree_get_next_by_row(tblh, &tblh);
	    retval == PICL_SUCCESS;
	    retval = ptree_get_next_by_col(tblh, &tblh)) {
		/*
		 * should be a ref prop in our hands,
		 * get the target node handle
		 */
		retval = ptree_get_propval(tblh, &nodeh,
		    sizeof (nodeh));
		if (retval != PICL_SUCCESS) {
			continue;
		}
		/*
		 * got the referenced node, has it got a
		 * _fru_parent property?
		 */
		retval = ptree_get_prop_by_name(nodeh,
		    PICL_REFPROP_FRU_PARENT, &fruph);
		if (retval != PICL_SUCCESS) {
			/*
			 * on Boston, Seattle and Netra-440 we should
			 * actually be looking for the _location_parent
			 * property for fan frus
			 */
			if (fanfru) {
				retval = ptree_get_prop_by_name(nodeh,
				    PICL_REFPROP_LOC_PARENT, &fruph);
			}
			if (retval != PICL_SUCCESS)
				continue;
		}
		/*
		 * got a _fru_parent node reference delete it
		 */
		if (ptree_delete_prop(fruph) == PICL_SUCCESS)
			(void) ptree_destroy_prop(fruph);

		/* On Netra-440, extra clean-up is required for fan trays */
		if ((sys_platform == PLAT_CHALUPA19) && (fanfru)) {
			/* remove the rmclomv node and its properties */
			delete_node_and_props(nodeh);
		}
	}
afterloop:
	/* More Netra-440 fan tray clean-up  */
	if ((sys_platform == PLAT_CHALUPA19) && (fanfru)) {
		/* remove the fru's child's table */
		if (ptree_delete_prop(tableh) == PICL_SUCCESS)
			(void) ptree_destroy_prop(tableh);
		/* remove the child */
		if (ptree_delete_node(childh) == PICL_SUCCESS)
			(void) ptree_destroy_node(childh);
	}
}

static void
remove_tables(picl_nodehdl_t rootnd)
{
	picl_nodehdl_t	tableh;
	int		retval;

	retval = ptree_get_prop_by_name(rootnd, PICL_PROP_DEVICES, &tableh);

	if (retval == PICL_SUCCESS) {
		/*
		 * found a Devices property, delete it
		 */
		if ((retval = ptree_delete_prop(tableh)) == PICL_SUCCESS) {
			(void) ptree_destroy_prop(tableh);
		}
	}

	/*
	 * is there a child node?
	 */
	retval = ptree_get_propval_by_name(rootnd, PICL_PROP_CHILD, &rootnd,
	    sizeof (rootnd));

	while (retval == PICL_SUCCESS) {

		remove_tables(rootnd);

		/*
		 * any siblings?
		 */
		retval = ptree_get_propval_by_name(rootnd, PICL_PROP_PEER,
		    &rootnd, sizeof (rootnd));
	}
}

/*
 * Event completion handler for PICL_FRU_ADDED/PICL_FRU_REMOVED events
 */
/* ARGSUSED */
static void
frudr_completion_handler(char *ename, void *earg, size_t size)
{
	picl_nodehdl_t	fruh;
	picl_nodehdl_t	parh;
	picl_nodehdl_t	peerh = NULL;
	char	nodename[PICL_PROPNAMELEN_MAX] = { '\0' };
	int err;

	if (strcmp(ename, PICL_FRU_REMOVED) == 0) {
		/*
		 * now frudata has been notified that the node is to be
		 * removed, we can actually remove it
		 */
		fruh = NULL;
		(void) nvlist_lookup_uint64(earg,
		    PICLEVENTARG_FRUHANDLE, &fruh);
		if (fruh != NULL) {
			(void) ptree_get_propval_by_name(fruh, PICL_PROP_PEER,
			    &peerh, sizeof (peerh));

			/*
			 * first find name of the fru
			 */
			err = ptree_get_propval_by_name(fruh, PICL_PROP_PARENT,
			    &parh, sizeof (parh));
			if (err == PICL_SUCCESS) {
				err = ptree_get_propval_by_name(parh,
				    PICL_PROP_NAME, nodename,
				    sizeof (nodename));
			}
			if (err == PICL_SUCCESS) {
				/*
				 * if it was a power supply, delete i2c node
				 */
				if (strncmp(nodename, PS_NAME,
				    PS_NAME_LEN) == 0) {
					(void) delete_i2c_node(nodename);
				}

				/*
				 * is disk node, make thread re-evaluate led
				 * state
				 */
				if (strncmp(nodename, DISK_NAME,
				    DISK_NAME_LEN) == 0) {
					disk_ready[nodename[DISK_NAME_LEN] -
					    '0'] = -1;
				}
			}

			remove_fru_parents(fruh);

			/*
			 * now we can delete the node
			 */
			err = ptree_delete_node(fruh);
			if (err == PICL_SUCCESS) {
				(void) ptree_destroy_node(fruh);
			} else {
				syslog(LOG_ERR, DELETE_PROP_FAIL, err);
			}

			if ((sys_platform == PLAT_CHALUPA19) &&
			    (strncmp(nodename, FT_NAME, FT_NAME_LEN) == 0) &&
			    (peerh != NULL)) {
				/*
				 * On Netra-440 platforms, a fan tray
				 * may contain 2 fans (F0 and F1) but
				 * we only receive a single notification
				 * for removal of F0.  If F1 is present,
				 * peerh will be valid and we need to
				 * process it as well.
				 */
				remove_fru_parents(peerh);
				err = ptree_delete_node(peerh);
				if (err == PICL_SUCCESS) {
					(void) ptree_destroy_node(peerh);
				} else {
					syslog(LOG_ERR, DELETE_PROP_FAIL, err);
				}
			}
		}
	}

	free(ename);
	nvlist_free(earg);
}

/*
 * Post the PICL_FRU_ADDED/PICL_FRU_REMOVED event
 */
static void
post_frudr_event(char *ename, picl_nodehdl_t parenth, picl_nodehdl_t fruh)
{
	nvlist_t	*nvl;
	char		*ev_name;

	ev_name = strdup(ename);
	if (ev_name == NULL)
		return;
	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, NULL)) {
		free(ev_name);
		return;
	}
	if (parenth != 0L &&
	    nvlist_add_uint64(nvl, PICLEVENTARG_PARENTHANDLE, parenth)) {
		free(ev_name);
		nvlist_free(nvl);
		return;
	}
	if (fruh != 0L &&
	    nvlist_add_uint64(nvl, PICLEVENTARG_FRUHANDLE, fruh)) {
		free(ev_name);
		nvlist_free(nvl);
		return;
	}
	if (ptree_post_event(ev_name, nvl, sizeof (nvl),
	    frudr_completion_handler) != 0) {
		free(ev_name);
		nvlist_free(nvl);
	}
}

static void
add_ps_to_platform(char *unit)
{
	picl_nodehdl_t		parent_hdl;
	picl_nodehdl_t		child_hdl;
	ptree_propinfo_t	info;
	int			unit_size = 1 + strlen(unit);
	int			res;
	char			unit_addr[PICL_UNITADDR_LEN_MAX];

	switch (sys_platform) {
	case PLAT_SEATTLE1U:
	case PLAT_SEATTLE2U:
		res = ptree_get_node_by_path(SEATTLE_PSU_PLATFORM, &parent_hdl);
		break;
	case PLAT_BOSTON:
		res = ptree_get_node_by_path(BOSTON_PSU_PLATFORM, &parent_hdl);
		break;
	default:
		res = ptree_get_node_by_path(PSU_PLATFORM, &parent_hdl);
		break;
	}

	if (res != PICL_SUCCESS)
		return;
	/*
	 * seeprom nodes sit below this node,
	 * is there one with the supplied unit address?
	 */
	res = ptree_get_propval_by_name(parent_hdl, PICL_PROP_CHILD,
	    &child_hdl, sizeof (picl_nodehdl_t));

	while (res == PICL_SUCCESS) {
		res = ptree_get_propval_by_name(child_hdl, PICL_PROP_PEER,
		    &child_hdl, sizeof (picl_nodehdl_t));
		if ((res == PICL_SUCCESS) &&
		    ptree_get_propval_by_name(child_hdl,
		    PICL_PROP_UNIT_ADDRESS, unit_addr,
		    sizeof (unit_addr)) == PICL_SUCCESS) {
			unit_addr[sizeof (unit_addr) - 1] = '\0';
			if (strcmp(unit_addr, unit) == 0)
				return;	/* unit address exists already */
		}
	}

	/*
	 * found platform location for PS seeprom node, create it
	 */
	if (ptree_create_and_add_node(parent_hdl, PS_PLATFORM_NAME,
	    PICL_CLASS_SEEPROM, &child_hdl) != PICL_SUCCESS)
		return;
	if (ptree_init_propinfo(&info, PTREE_PROPINFO_VERSION,
	    PICL_PTYPE_CHARSTRING, PICL_READ, unit_size,
	    PICL_PROP_UNIT_ADDRESS, NULL, NULL) != PICL_SUCCESS)
		return;
	(void) ptree_create_and_add_prop(child_hdl, &info, unit, NULL);
}

static void
get_fantray_path(char *ap_id, char *path, int bufsz)
{
	char	ft_id[FT_ID_BUFSZ];

	(void) strlcpy(ft_id, ap_id, FT_ID_BUFSZ);

	switch (sys_platform) {
	case PLAT_SEATTLE1U:
		if ((strncmp(ap_id, "FT0", 3) == 0) ||
		    (strncmp(ap_id, "FT1", 3) == 0) ||
		    (strncmp(ap_id, "FT2", 3) == 0)) {
			(void) snprintf(path, bufsz, SEATTLE_FCB0_1U, ft_id);
		} else if ((strncmp(ap_id, "FT3", 3) == 0) ||
		    (strncmp(ap_id, "FT4", 3) == 0) ||
		    (strncmp(ap_id, "FT5", 3) == 0)) {
			(void) snprintf(path, bufsz, SEATTLE_FCB1_1U, ft_id);
		} else {
			(void) snprintf(path, bufsz, SEATTLE_PDB_1U, ft_id);
		}
		break;

	case PLAT_SEATTLE2U:
		if ((strncmp(ap_id, "FT0", 3) == 0) ||
		    (strncmp(ap_id, "FT1", 3) == 0) ||
		    (strncmp(ap_id, "FT2", 3) == 0)) {
			(void) snprintf(path, bufsz, SEATTLE_FCB0_2U, ft_id);
		} else if ((strncmp(ap_id, "FT3", 3) == 0) ||
		    (strncmp(ap_id, "FT4", 3) == 0) ||
		    (strncmp(ap_id, "FT5", 3) == 0)) {
			(void) snprintf(path, bufsz, SEATTLE_FCB1_2U, ft_id);
		} else {
			(void) snprintf(path, bufsz, SEATTLE_PDB_2U, ft_id);
		}
		break;

	case PLAT_BOSTON:
		(void) snprintf(path, bufsz, SYS_BOARD_PATH, ft_id);
		break;

	default:
		(void) snprintf(path, bufsz, CHASSIS_LOC_PATH, ft_id);
		break;
	}
}

/*
 * handle EC_DR picl events
 */
/*ARGSUSED*/
static void
frudr_evhandler(const char *ename, const void *earg, size_t size, void *cookie)
{
	nvlist_t		*nvlp;
	char			*dtype;
	char			*ap_id;
	char			*hint;
	char			path[MAXPATHLEN];
	picl_nodehdl_t		fruh;
	picl_nodehdl_t		locnodeh;
	int			err;
	int			index;
	picl_nodehdl_t		childh;
	char			*fru_name;
	boolean_t		rmc_flag = B_FALSE;

	if (strcmp(ename, PICLEVENT_DR_AP_STATE_CHANGE) != 0) {
		return;
	}

	if (nvlist_unpack((char *)earg, size, &nvlp, NULL)) {
		return;
	}

	if (nvlist_lookup_string(nvlp, PICLEVENTARG_DATA_TYPE, &dtype)) {
		nvlist_free(nvlp);
		return;
	}

	if (strcmp(dtype, PICLEVENTARG_PICLEVENT_DATA) != 0) {
		nvlist_free(nvlp);
		return;
	}

	if (nvlist_lookup_string(nvlp, PICLEVENTARG_AP_ID, &ap_id)) {
		nvlist_free(nvlp);
		return;
	}

	/*
	 * check ap_id really is a hot-plug device
	 */
	if (strncmp(ap_id, PS_NAME, PS_NAME_LEN) == 0) {
		fru_name = PS_FRU_NAME;
	} else if (strncmp(ap_id, DISK_NAME, DISK_NAME_LEN) == 0) {
		fru_name = DISK_FRU_NAME;
	} else if (strncmp(ap_id, SCC_NAME, SCC_NAME_LEN) == 0) {
		fru_name = SCC_FRU_NAME;
	} else if (strncmp(ap_id, RMC_NAME, RMC_NAME_LEN) == 0) {
		fru_name = RMC_FRU_NAME;
		rmc_flag = B_TRUE;
	} else if (strncmp(ap_id, FT_NAME, FT_NAME_LEN) == 0) {
		fru_name = FT_FRU_NAME;
	} else {
		nvlist_free(nvlp);
		return;
	}

	if (nvlist_lookup_string(nvlp, PICLEVENTARG_HINT, &hint)) {
		nvlist_free(nvlp);
		return;
	}

	/*
	 * OK - so this is an EC_DR event - let's handle it.
	 */
	if (rmc_flag && (sys_platform != PLAT_CHALUPA) &&
	    (sys_platform != PLAT_CHALUPA19))
		sprintf_buf2(path, SYS_BOARD_PATH, ap_id);
	else {
		if ((sys_platform == PLAT_CHALUPA19) &&
		    (strncmp(ap_id, PS_NAME, PS_NAME_LEN) == 0)) {
			sprintf_buf2(path, CHASSIS_LOC_PATH,
			    ps_apid_to_nodename(ap_id));
		} else	if (strncmp(ap_id, DISK_NAME, DISK_NAME_LEN) == 0) {
			switch (sys_platform)	{
			case PLAT_SEATTLE1U:
				sprintf_buf2(path, SEATTLE1U_HDDBP_PATH, ap_id);
				break;
			case PLAT_SEATTLE2U:
				sprintf_buf2(path, SEATTLE2U_HDDBP_PATH, ap_id);
				break;
			case PLAT_BOSTON:
				sprintf_buf2(path, BOSTON_HDDBP_PATH, ap_id);
				break;
			default:
				sprintf_buf2(path, CHASSIS_LOC_PATH, ap_id);
				break;
			}
		} else if (strncmp(ap_id, FT_NAME, FT_NAME_LEN) == 0) {
			get_fantray_path(ap_id, path, MAXPATHLEN);
		} else	{
			sprintf_buf2(path, CHASSIS_LOC_PATH, ap_id);
		}
	}

	if (ptree_get_node_by_path(path, &locnodeh) != PICL_SUCCESS) {
		nvlist_free(nvlp);
		return;
	}

	/*
	 * now either add or delete the fru node as appropriate. If no
	 * hint, treat as insert and update the tree if necessary.
	 */
	if (strcmp(hint, DR_HINT_REMOVE) == 0) {
		if (ptree_get_propval_by_name(locnodeh, PICL_PROP_CHILD,
		    &fruh, sizeof (picl_nodehdl_t)) == PICL_SUCCESS) {
			/*
			 * fru was there - but has gone away
			 */
			post_frudr_event(PICL_FRU_REMOVED, NULL, fruh);
		}
	} else if (rmc_flag) {
		/*
		 * An event on the RMC location, just pass it on
		 * it's not really a PICL_FRU_ADDED event, so offer
		 * the child handle as well (if it exists).
		 */
		if (ptree_get_propval_by_name(locnodeh, PICL_PROP_CHILD,
		    &fruh, sizeof (picl_nodehdl_t)) != PICL_SUCCESS) {
			fruh = NULL;
		}
		post_frudr_event(PICL_FRU_ADDED, locnodeh, fruh);
	} else {
		/*
		 * fru has been inserted (or may need to update)
		 * if node already there, then just return
		 */
		childh = find_child_by_name(locnodeh, fru_name);
		if (childh != NULL) {
			nvlist_free(nvlp);
			return;
		}

		/*
		 * On Netra-440, the fan-tray location nodes are
		 * not deleted when fan-trays are physically
		 * removed, so we do not need to create another
		 * fru node.
		 */
		if ((sys_platform != PLAT_CHALUPA19) ||
		    (strncmp(fru_name, FT_FRU_NAME, FT_FRU_NAME_LEN) != 0)) {
			/*
			 * create requested fru node
			 */
			err = ptree_create_and_add_node(locnodeh, fru_name,
			    PICL_CLASS_FRU, &childh);
			if (err != PICL_SUCCESS) {
				syslog(LOG_ERR, ADD_NODE_FAIL, ap_id, err);
				nvlist_free(nvlp);
				return;
			}
		}

		/*
		 * power supplies have operational status and fruid -
		 * add OperationalStatus property and create i2c device node
		 * before posting fru_added event
		 */
		if (strncmp(ap_id, PS_NAME, PS_NAME_LEN) == 0) {
			index = find_vol_prop_by_name(
			    ps_apid_to_nodename(ap_id));
			if (index >= 0)
				add_op_status_to_node(childh,
				    &idprop->idp[index].volprop);
			(void) create_i2c_node(ap_id);
			add_ps_to_platform(ps_name_to_unitaddr(ap_id));
		}

		/*
		 * now post event
		 */
		post_frudr_event(PICL_FRU_ADDED, locnodeh, NULL);
	}
	nvlist_free(nvlp);
}

/*
 * Handle PICL_FRU_ADDED events.
 * These events are posted by the frudr_evhandler of this plugin in response to
 * PICLEVENT_DR_AP_STATE_CHANGE events. The sequence is as follows:
 *	1) frudr_evhandler catches PICLEVENT_DR_AP_STATE_CHANGE and creates a
 *	child node below the relevant location.
 *	2) frudr_evhandler posts a PICL_FRU_ADDED event.
 *	3) envmon catches PICL_FRU_ADDED event, gropes the RMC configuration
 *	and creates platform tree nodes (primarily for PSUs). (If the event
 *	is for the RMC itself, envmon deletes existing platform nodes and
 *	rebuilds from scratch.)
 *	4) this plugin catches PICL_FRU_ADDED event, looks for a related
 *	configuration file and parses it. This adds Fru data properties (etc.).
 *	5) frudata catches the event and updates its FRUID data cache.
 */
/*ARGSUSED*/
static void
fru_add_handler(const char *ename, const void *earg, size_t size, void *cookie)
{
	int			retval;
	picl_nodehdl_t		locnodeh;
	picl_nodehdl_t		rooth;
	char			path[MAXPATHLEN];
	char			*fru_name;

	if (strcmp(ename, PICL_FRU_ADDED) != 0)
		return;

	retval = nvlist_lookup_uint64((nvlist_t *)earg,
	    PICLEVENTARG_PARENTHANDLE, &locnodeh);
	if (retval != PICL_SUCCESS)
		return;

	retval = ptree_get_propval_by_name(locnodeh, PICL_PROP_NAME,
	    path, sizeof (path));
	if (retval != PICL_SUCCESS)
		return;

	fru_name = strdup(path);
	if (fru_name == NULL)
		return;

	/*
	 * We're about to parse a fru-specific .conf file to populate
	 * picl nodes relating to the dynamically added component. In the
	 * case of the RMC, there is a problem: all of its /platform tree
	 * nodes have just been replaced by envmon. It is now necessary to
	 * repopulate Devices tables in /frutree.
	 * picld_pluginutil_parse_config_file doesn't handle repopulating
	 * existing tables, so as a work round, delete all tables found
	 * under /frutree. This works on Enchilada Server as the tables
	 * are all created from parsing a .conf file, and we're about to
	 * redo that action.
	 */
	if (strcmp(fru_name, RMC_NAME) == 0) {
		rmc_state_event();
		retval = ptree_get_node_by_path(FRUTREE_PATH, &rooth);
		if (retval == PICL_SUCCESS) {
			remove_tables(rooth);
		}
	}

	/*
	 * Re-establish the HPU(FRU) volatile properties.
	 * This needs to be done before the .conf file is parsed because
	 * it has a side effect of re-creating any missing power-supply
	 * fru node. The .conf file can then hang properties beneath.
	 */
	opst_init();

	/*
	 * see if there's a .conf file for this fru
	 */
	if (get_config_file(path, fru_name) == 0) {
		if ((ptree_get_root(&rooth) != PICL_SUCCESS) ||
		    (picld_pluginutil_parse_config_file(rooth, path) !=
		    PICL_SUCCESS)) {
			syslog(LOG_ERR, PARSE_CONF_FAIL, path);
		}
	}

	free(fru_name);
}

/*
 * Handle PICLEVENT_SYSEVENT_DEVICE_ADDED events.
 */
/*ARGSUSED*/
static void
frutree_evhandler(const char *ename, const void *earg, size_t size,
    void *cookie)
{
	nvlist_t		*nvlp;
	picl_nodehdl_t		rooth;
	char			path[MAXPATHLEN];
	char			*fru_name;
	char			*dtype;
	char			*dpath;
	char			*ptr;
	char			*ptr2;
	int			done = B_FALSE;
	int			i;

	if (strcmp(ename, PICLEVENT_SYSEVENT_DEVICE_ADDED) != 0)
		return;

	if (nvlist_unpack((char *)earg, size, &nvlp, NULL))
		return;

	if (nvlist_lookup_string(nvlp, PICLEVENTARG_DATA_TYPE, &dtype)) {
		nvlist_free(nvlp);
		return;
	}

	if (strcmp(dtype, PICLEVENTARG_PICLEVENT_DATA) != 0) {
		nvlist_free(nvlp);
		return;
	}

	if (nvlist_lookup_string(nvlp, PICLEVENTARG_DEVFS_PATH, &dpath)) {
		nvlist_free(nvlp);
		return;
	}

	fru_name = strdup(dpath);
	if (fru_name == NULL) {
		nvlist_free(nvlp);
		return;
	}

	nvlist_free(nvlp);

	/*
	 * fru_name is of the form
	 *	"/pci@1e,600000/usb@a/mouse@2"
	 * or
	 *	"/pci@1e,600000/usb@a/device@2/mouse@0"
	 * reduce it to "usb-a-2"
	 */
	if ((sys_platform == PLAT_SEATTLE1U) ||
	    (sys_platform == PLAT_SEATTLE2U) ||
	    (sys_platform == PLAT_BOSTON)) {
		for (i = 0; i < MAX_USB_PORTS; i++) {
			sprintf(fru_name, "%s%d", USB_CONF_FILE_NAME, i+1);
			if (get_config_file(path, fru_name) == 0) {
				if ((ptree_get_root(&rooth) != PICL_SUCCESS) ||
				    (picld_pluginutil_parse_config_file(rooth,
				    path) != PICL_SUCCESS)) {
					syslog(LOG_ERR, PARSE_CONF_FAIL, path);
				}
			}
		}
	} else {
		ptr = fru_name;
		if (*ptr == '/') {
			ptr++;
			ptr = strchr(ptr, '/');
			if (ptr != NULL) {
				ptr++;
				(void) memmove(fru_name, ptr, strlen(ptr) + 1);
				ptr = strchr(fru_name, '@');
				if (ptr != NULL) {
					*ptr = '-';
					ptr++;
					ptr = strchr(ptr, '/');
					if (ptr != NULL) {
						*ptr = '-';
						ptr++;
						ptr2 = ptr;
						ptr = strchr(ptr, '@');
						if (ptr != NULL) {
							ptr++;
							(void) memmove(ptr2,
							    ptr, strlen(ptr)+1);
							ptr2 = strchr(ptr2,
							    '/');
							if (ptr2 != NULL) {
								*ptr2 = '\0';
							}
							done = B_TRUE;
						}
					}
				}
			}
		}
		if (done == B_FALSE) {
			free(fru_name);
			return;
		}

		/*
		 * see if there's a .conf file for this fru
		 */

		if (get_config_file(path, fru_name) == 0) {
			if ((ptree_get_root(&rooth) != PICL_SUCCESS) ||
			    (picld_pluginutil_parse_config_file(rooth, path) !=
			    PICL_SUCCESS)) {
				syslog(LOG_ERR, PARSE_CONF_FAIL, path);
			}
		}
	}

	free(fru_name);
}

static int
set_led(char *name, char *ptr, char *value)
{
	char			path[MAXPATHLEN];
	picl_prophdl_t		proph;
	ptree_propinfo_t	propinfo;
	picl_prophdl_t		tableh;
	picl_nodehdl_t		locnodeh;
	picl_nodehdl_t		nodeh;
	picl_prophdl_t		tblh;
	int			retval;
	char			*value_ptr;
	char			label[PICL_PROPNAMELEN_MAX];
	char			class[PICL_PROPNAMELEN_MAX];

	/* find the location node */
	switch (sys_platform)	{
	case PLAT_CHALUPA:
	case PLAT_CHALUPA19:
		sprintf_buf2(path, CHASSIS_LOC_PATH, name);
		break;
	case PLAT_SEATTLE1U:
		sprintf_buf2(path, SEATTLE1U_HDDBP_PATH, name);
		break;
	case PLAT_SEATTLE2U:
		sprintf_buf2(path, SEATTLE2U_HDDBP_PATH, name);
		break;
	case PLAT_BOSTON:
		sprintf_buf2(path, BOSTON_HDDBP_PATH, name);
		break;
	default:
		sprintf_buf2(path, CHASSIS_LOC_PATH, name);
		break;
	}

	if (ptree_get_node_by_path(path, &locnodeh) != PICL_SUCCESS)	{
		return (PICL_FAILURE);
	}

	/*
	 * if no fru node, then turn led off
	 */
	if (find_child_by_name(locnodeh, DISK_FRU_NAME) != NULL)
		value_ptr = value;
	else
		value_ptr = PICL_PROPVAL_OFF;

	/* get its Devices table */
	if (ptree_get_prop_by_name(locnodeh, PICL_PROP_DEVICES, &tableh) !=
	    PICL_SUCCESS)
		return (PICL_FAILURE);
	if (ptree_get_propval(tableh, &tblh, sizeof (tblh)) != PICL_SUCCESS)
		return (PICL_FAILURE);

	/* get first col, first row */
	if (ptree_get_next_by_col(tblh, &tblh) != PICL_SUCCESS)
		return (PICL_FAILURE);

	/*
	 * starting at next col, get every entry in the column
	 */
	for (retval = ptree_get_next_by_row(tblh, &tblh);
	    retval == PICL_SUCCESS;
	    retval = ptree_get_next_by_col(tblh, &tblh)) {
		/*
		 * get the target node handle
		 */
		if (ptree_get_propval(tblh, &nodeh, sizeof (nodeh))
		    != PICL_SUCCESS)
			continue;

		/*
		 * check it's a led
		 */
		if (ptree_get_propval_by_name(nodeh, PICL_PROP_CLASSNAME,
		    class, sizeof (class)) != PICL_SUCCESS)
			continue;
		if (strcmp(class, "led") != 0)
			continue;

		/*
		 * check its the right led
		 */
		if (ptree_get_propval_by_name(nodeh, PICL_PROP_LABEL,
		    label, sizeof (label)) != PICL_SUCCESS)
			continue;
		if (strcmp(label, ptr) == 0) {
			/*
			 * set it
			 */
			if (ptree_get_prop_by_name(nodeh, PICL_PROP_STATE,
			    &proph) != PICL_SUCCESS)
				continue;
			if (ptree_get_propinfo(proph, &propinfo) !=
			    PICL_SUCCESS)
				continue;
			retval =  ptree_update_propval_by_name(nodeh,
			    PICL_PROP_STATE, value_ptr, propinfo.piclinfo.size);
			return (retval);
		}
	}
	return (PICL_FAILURE);
}

/*
 * function to find first node of specified class beneath supplied node
 */
static int
get_node_by_class(picl_nodehdl_t nodeh, const char *classname,
    picl_nodehdl_t *foundnodeh)
{
	int		err;
	char		clname[PICL_CLASSNAMELEN_MAX+1];
	picl_nodehdl_t	childh;

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

	while (err == PICL_SUCCESS) {
		err = ptree_get_propval_by_name(childh, PICL_PROP_CLASSNAME,
		    clname, sizeof (clname));

		if ((err == PICL_SUCCESS) && (strcmp(clname, classname) == 0)) {
			*foundnodeh = childh;
			return (PICL_SUCCESS);
		}

		err = get_node_by_class(childh, classname, foundnodeh);
		if (err == PICL_SUCCESS)
			return (PICL_SUCCESS);

		err = ptree_get_propval_by_name(childh, PICL_PROP_PEER,
		    &childh, sizeof (picl_nodehdl_t));
	}

	return (PICL_NODENOTFOUND);
}

/*
 * get system-controller node
 */
static int
get_sys_controller_node(picl_nodehdl_t *nodeh)
{
	int		err;

	/* get platform node */
	err = ptree_get_node_by_path(PICL_NODE_ROOT PICL_NODE_PLATFORM, nodeh);
	if (err != PICL_SUCCESS)
		return (err);
	err = get_node_by_class(*nodeh, PICL_CLASS_SERVICE_PROCESSOR, nodeh);
	return (err);
}

/*
 * create pathname string for system-controller device
 */
static char *
create_sys_controller_pathname(picl_nodehdl_t sysconh)
{
	char		*ptr;
	char		namebuf[PATH_MAX];
	size_t		len;
	DIR		*dirp;
	struct dirent	*dp;
	struct stat	statbuf;

	/*
	 * prefix devfs-path name with /devices
	 */
	(void) strlcpy(namebuf, DEV_PREFIX, PATH_MAX);

	/*
	 * append devfs-path property
	 */
	len = strlen(namebuf);
	if (ptree_get_propval_by_name(sysconh, str_devfs_path, namebuf + len,
	    sizeof (namebuf) - len) != PICL_SUCCESS) {
		return (NULL);
	}

	/*
	 * locate final component of name
	 */
	ptr = strrchr(namebuf, '/');
	if (ptr == NULL)
		return (NULL);
	*ptr = '\0';		/* terminate at end of directory path */
	len = strlen(ptr + 1);	/* length of terminal name */
	dirp = opendir(namebuf);
	if (dirp == NULL) {
		return (NULL);
	}
	*ptr++ = '/';		/* restore '/' and advance to final name */

	while ((dp = readdir(dirp)) != NULL) {
		/*
		 * look for a name which starts with the string at *ptr
		 */
		if (strlen(dp->d_name) < len)
			continue;	/* skip short names */
		if (strncmp(dp->d_name, ptr, len) == 0) {
			/*
			 * Got a match, restore full pathname and stat the
			 * entry. Reject if not a char device
			 */
			(void) strlcpy(ptr, dp->d_name,
			    sizeof (namebuf) - (ptr - namebuf));
			if (stat(namebuf, &statbuf) < 0)
				continue;	/* reject if can't stat it */
			if (!S_ISCHR(statbuf.st_mode))
				continue;	/* not a character device */
			/*
			 * go with this entry
			 */
			(void) closedir(dirp);
			return (strdup(namebuf));
		}
	}
	(void) closedir(dirp);
	return (NULL);
}

/*
 * create pathname string for bezel leds device
 */
static char *
create_bezel_leds_pathname(const char *dirpath, const char *devname)
{
	char		namebuf[PATH_MAX];
	size_t		lendirpath;
	size_t		len;
	DIR		*dirp;
	struct dirent	*dp;
	struct stat	statbuf;

	/*
	 * start with directory name
	 */
	(void) strlcpy(namebuf, dirpath, PATH_MAX);

	/*
	 * append devfs-path property
	 */
	lendirpath = strlen(namebuf);
	dirp = opendir(namebuf);
	if (dirp == NULL) {
		return (NULL);
	}

	len = strlen(devname);

	while ((dp = readdir(dirp)) != NULL) {
		/*
		 * look for a name which starts with the gpio string
		 */
		if (strlen(dp->d_name) < len)
			continue;	/* skip short names */
		if (strncmp(dp->d_name, devname, len) == 0) {
			/*
			 * Got a match, restore full pathname and stat the
			 * entry. Reject if not a char device
			 */
			(void) strlcpy(namebuf + lendirpath, dp->d_name,
			    sizeof (namebuf) - lendirpath);
			if (stat(namebuf, &statbuf) < 0)
				continue;	/* reject if can't stat it */
			if (!S_ISCHR(statbuf.st_mode))
				continue;	/* not a character device */
			/*
			 * go with this entry
			 */
			(void) closedir(dirp);
			return (strdup(namebuf));
		}
	}
	(void) closedir(dirp);
	return (NULL);
}

/*
 * initialise structure associated with nodes requiring OperationalStatus
 */
static void
opst_init(void)
{
	int			res;
	int			index = 0;
	int			fd;
	int			entries = 0;
	int			err = 0;
	boolean_t		rmc_flag;
	boolean_t		ps_flag;
	boolean_t		disk_flag;
	size_t			len;
	envmon_sysinfo_t	sysinfo;
	envmon_hpu_t		hpu;

	if (idprop != NULL) {
		/*
		 * This must be a restart, clean up earlier allocation
		 */
		free(idprop);
		idprop = NULL;
	}

	if (sc_device_name == NULL)
		err = 1;
	else {
		fd = open(sc_device_name, O_RDONLY);

		if (fd < 0) {
			syslog(LOG_ERR, EM_NO_SC_DEV);
			err = 1;
		}
	}

	if (err == 0) {
		res = ioctl(fd, ENVMONIOCSYSINFO, &sysinfo);

		if (res < 0) {
			syslog(LOG_ERR, EM_NO_SYSINFO, strerror(errno));
			(void) close(fd);
			err = 1;
		}
	}

	if (err == 0) {
		entries = sysinfo.maxHPU;
		len = offsetof(idp_lkup_t, idp) + entries * sizeof (id_props_t);
		idprop = calloc(len, 1);
		if (idprop == NULL) {
			(void) close(fd);
			err = 1;
		}
	}

	if (err == 0) {
		idprop->maxnum = entries;
		hpu.id.name[0] = '\0';	/* request for first name */
		res = ioctl(fd, ENVMONIOCHPU, &hpu);

		/*
		 * The HPU node for the RMC is a special case. Its handle is
		 * generated by the rmclomv driver. Rather than building
		 * knowledge of its frutree hierarchic name into the driver, we
		 * put that knowledge here.
		 */
		while ((res == 0) && (index < entries) &&
		    (hpu.next_id.name[0] != '\0')) {
			hpu.id = hpu.next_id;
			res = ioctl(fd, ENVMONIOCHPU, &hpu);
			if ((res == 0) &&
			    ((hpu.sensor_status & ENVMON_NOT_PRESENT) == 0)) {
				add_op_status(&hpu, &index);
			}
		}

		idprop->num = index;
		(void) close(fd);
	}
}

static void
disk_leds_init(void)
{
	int err = 0, i;

	if (!g_mutex_init) {
		if ((pthread_cond_init(&g_cv, NULL) == 0) &&
		    (pthread_cond_init(&g_cv_ack, NULL) == 0) &&
		    (pthread_mutex_init(&g_mutex, NULL) == 0)) {
			g_mutex_init = B_TRUE;
		} else {
			return;
		}
	}

	/*
	 * Initialise to -1 so the led thread will set correctly.
	 * Do this before creating the disk_leds thread,
	 * so there's no race.
	 */
	for (i = 0; i < N_DISKS; i++)
		disk_ready[i] = -1;

	if (ledsthr_created) {
		/*
		 * this is a restart, wake up sleeping threads
		 */
		err = pthread_mutex_lock(&g_mutex);
		if (err != 0) {
			syslog(LOG_ERR, EM_MUTEX_FAIL, strerror(errno));
			return;
		}
		g_finish_now = B_FALSE;
		(void) pthread_cond_broadcast(&g_cv);
		(void) pthread_mutex_unlock(&g_mutex);
	} else {
		if ((pthread_attr_init(&ledsthr_attr) != 0) ||
		    (pthread_attr_setscope(&ledsthr_attr,
		    PTHREAD_SCOPE_SYSTEM) != 0))
			return;
		if ((err = pthread_create(&ledsthr_tid, &ledsthr_attr,
		    disk_leds_thread, NULL)) != 0) {
			syslog(LOG_ERR, EM_THREAD_CREATE_FAILED,
			    strerror(errno));
			return;
		}
		ledsthr_created = B_TRUE;
	}
}

static void
disk_leds_fini(void)
{
	int	err, i;

	/*
	 * turn the leds off as we'll no longer be monitoring them
	 */
	for (i = 0; i < N_DISKS; i++)
		(void) set_led(disk_name[i], REMOK_LED, PICL_PROPVAL_OFF);

	/*
	 * disk_leds_thread() never started or an error occured so
	 * that it's not running
	 */
	if (!disk_leds_thread_running)
		return;

	/*
	 * tell led thread to pause
	 */
	if (!ledsthr_created)
		return;
	err = pthread_mutex_lock(&g_mutex);
	if (err != 0) {
		syslog(LOG_ERR, EM_MUTEX_FAIL, strerror(errno));
		return;
	}
	g_finish_now = B_TRUE;
	disk_leds_thread_ack = B_FALSE;
	(void) pthread_cond_broadcast(&g_cv);

	/*
	 * and wait for them to acknowledge
	 */
	while (!disk_leds_thread_ack) {
		(void) pthread_cond_wait(&g_cv_ack, &g_mutex);
	}
	(void) pthread_mutex_unlock(&g_mutex);
}

static void
update_disk_node(char *fruname, char *devpath)
{
	picl_nodehdl_t slotndh;
	picl_nodehdl_t diskndh;
	picl_nodehdl_t devhdl;
	picl_prophdl_t tblhdl;
	picl_prophdl_t tblhdl2;
	picl_prophdl_t tblproph;
	int err;
	char path[MAXPATHLEN];

	switch (sys_platform)	{
	case PLAT_CHALUPA:
	case PLAT_CHALUPA19:
		sprintf_buf2(path, CHASSIS_LOC_PATH, fruname);
		break;
	case PLAT_SEATTLE1U:
		sprintf_buf2(path, SEATTLE1U_HDDBP_PATH, fruname);
		break;
	case PLAT_SEATTLE2U:
		sprintf_buf2(path, SEATTLE2U_HDDBP_PATH, fruname);
		break;
	case PLAT_BOSTON:
		sprintf_buf2(path, BOSTON_HDDBP_PATH, fruname);
		break;
	default:
		sprintf_buf2(path, CHASSIS_LOC_PATH, fruname);
		break;
	}

	if (ptree_get_node_by_path(path, &slotndh) != PICL_SUCCESS) {
		return;
	}
	diskndh = find_child_by_name(slotndh, DISK_FRU_NAME);
	if (diskndh == NULL) {
		return;
	}
	err = ptree_get_node_by_path(devpath, &devhdl);
	if (err == PICL_SUCCESS) {
		err = ptree_get_propval_by_name(diskndh,
		    PICL_PROP_DEVICES, &tblhdl, sizeof (tblhdl));
		if (err != PICL_SUCCESS)
			return;
		err = ptree_get_next_by_col(tblhdl, &tblhdl2);
		if (err != PICL_SUCCESS) {
			err = create_table_entry(tblhdl, devhdl,
			    PICL_CLASS_BLOCK);
			if (err != PICL_SUCCESS)
				return;
			err = add_prop_ref(devhdl, diskndh,
			    PICL_REFPROP_FRU_PARENT);
			if (err != PICL_SUCCESS)
				return;
		}
	} else {
		/*
		 * no mechanism for deleting row - so delete
		 * whole table and start again
		 */
		err = ptree_get_prop_by_name(diskndh, PICL_PROP_DEVICES,
		    &tblproph);
		if (err != PICL_SUCCESS)
			return;
		err = ptree_delete_prop(tblproph);
		if (err != PICL_SUCCESS)
			return;
		(void) ptree_destroy_prop(tblproph);
		err = create_table(diskndh, &tblhdl, PICL_PROP_DEVICES);
		if (err != PICL_SUCCESS)
			return;
	}
}

/*
 * We will light the OK2REMOVE LED for disks configured
 * into a raid if (and only if) the driver reports
 * that the disk has failed.
 */
static int
raid_ok2rem_policy(raid_config_t config, int target)
{
	int i;

	for (i = 0; i < config.ndisks; i++) {
		int d = config.disk[i];
		int dstatus = config.diskstatus[i];

		if (d  == target)	{
			switch (dstatus) {
			case RAID_DISKSTATUS_MISSING:
				/* If LED is on, turn it off */
				if (disk_ready[d] == B_FALSE) {
					if (set_led(disk_name[d], REMOK_LED,
					    PICL_PROPVAL_OFF) == PICL_SUCCESS) {
						disk_ready[d] = B_TRUE;
					}
				}
			break;
			case RAID_DISKSTATUS_GOOD:
				if (disk_ready[d] != B_TRUE) {
					if (set_led(disk_name[d], REMOK_LED,
					    PICL_PROPVAL_OFF) == PICL_SUCCESS) {
						disk_ready[d] = B_TRUE;
					}
				}
			break;
			case RAID_DISKSTATUS_FAILED:
				if (disk_ready[d] != B_FALSE) {
					if (set_led(disk_name[d], REMOK_LED,
					    PICL_PROPVAL_ON) == PICL_SUCCESS) {
						disk_ready[d] = B_FALSE;
					}
				}
			break;
			default:
			break;
			}
			return (1);
		}
	}
	return (0);
}

static int
check_raid(int target)
{
	raid_config_t	config;
	int	fd;
	int	numvols;
	int	i, j;

	switch (sys_platform) {
	case PLAT_CHALUPA:
	case PLAT_CHALUPA19:
		fd = open(V440_DISK_DEVCTL, O_RDONLY);
		break;
	case PLAT_SEATTLE1U:
	case PLAT_SEATTLE2U:
		fd = open(SEATTLE_DISK_DEVCTL, O_RDONLY);
		break;
	case PLAT_BOSTON:
		if (boston_1068e_flag) {
			fd = open(BOSTON_DISK_DEVCTL_1068E, O_RDONLY);
		} else {
			fd = open(BOSTON_DISK_DEVCTL_1068X, O_RDONLY);
		}
		break;
	default:
		fd = -1;
		break;
	}

	if (fd == -1) {
		return (0);
	}

	if (ioctl(fd, RAID_NUMVOLUMES, &numvols)) {
		(void) close(fd);
		return (0);
	}

	for (i = 0; i < numvols; i++)	{
		config.unitid = i;
		if (ioctl(fd, RAID_GETCONFIG, &config)) {
			(void) close(fd);
			return (0);
		}
		if (raid_ok2rem_policy(config, target))	{
			(void) close(fd);
			return (1);
		}
	}

	(void) close(fd);
	return (0);
}

/*ARGSUSED*/
static void *
disk_leds_thread(void *args)
{
	int 	c;
	int 	i;
	char	**disk_dev;
	int fd;

	devctl_hdl_t dhdl;

	int 	n_disks = 0,
	    do_raid = 0,
	    err 	= 0;
	uint_t	statep	= 0;

	static char *mpxu_devs[] = {
		"/pci@1c,600000/scsi@2/sd@0,0",
		"/pci@1c,600000/scsi@2/sd@1,0",
		"/pci@1c,600000/scsi@2/sd@2,0",
		"/pci@1c,600000/scsi@2/sd@3,0"
	};

	static char *ents_devs[] = {
		"/pci@1d,700000/scsi@4/sd@0,0",
		"/pci@1d,700000/scsi@4/sd@1,0",
		"/pci@1d,700000/scsi@4/sd@2,0",
		"/pci@1d,700000/scsi@4/sd@3,0",
		"/pci@1d,700000/scsi@4/sd@8,0",
		"/pci@1d,700000/scsi@4/sd@9,0",
		"/pci@1d,700000/scsi@4/sd@a,0",
		"/pci@1d,700000/scsi@4/sd@b,0"
	};

	static char *v440_devs[] = {
		"/pci@1f,700000/scsi@2/sd@0,0",
		"/pci@1f,700000/scsi@2/sd@1,0",
		"/pci@1f,700000/scsi@2/sd@2,0",
		"/pci@1f,700000/scsi@2/sd@3,0"
	};

	static char *n210_devs[] = {
		"/pci@1c,600000/LSILogic,sas@1/sd@0,0",
		"/pci@1c,600000/LSILogic,sas@1/sd@1,0"
	};

	static char *seattle_devs[] = {
		"/pci@1e,600000/pci@0/pci@a/pci@0/pci@8/scsi@1/sd@0,0",
		"/pci@1e,600000/pci@0/pci@a/pci@0/pci@8/scsi@1/sd@1,0",
		"/pci@1e,600000/pci@0/pci@a/pci@0/pci@8/scsi@1/sd@2,0",
		"/pci@1e,600000/pci@0/pci@a/pci@0/pci@8/scsi@1/sd@3,0"
	};

	static char *boston_devs_1068e[] = {
		"/pci@1e,600000/pci@0/pci@2/scsi@0/sd@0,0",
		"/pci@1e,600000/pci@0/pci@2/scsi@0/sd@1,0",
		"/pci@1e,600000/pci@0/pci@2/scsi@0/sd@2,0",
		"/pci@1e,600000/pci@0/pci@2/scsi@0/sd@3,0",
		"/pci@1e,600000/pci@0/pci@2/scsi@0/sd@4,0",
		"/pci@1e,600000/pci@0/pci@2/scsi@0/sd@5,0",
		"/pci@1e,600000/pci@0/pci@2/scsi@0/sd@6,0",
		"/pci@1e,600000/pci@0/pci@2/scsi@0/sd@7,0"
	};
	static char *boston_devs_1068x[] = {
		"/pci@1f,700000/pci@0/pci@2/pci@0/pci@8/LSILogic,sas@1/sd@0,0",
		"/pci@1f,700000/pci@0/pci@2/pci@0/pci@8/LSILogic,sas@1/sd@1,0",
		"/pci@1f,700000/pci@0/pci@2/pci@0/pci@8/LSILogic,sas@1/sd@2,0",
		"/pci@1f,700000/pci@0/pci@2/pci@0/pci@8/LSILogic,sas@1/sd@3,0",
		"/pci@1f,700000/pci@0/pci@2/pci@0/pci@8/LSILogic,sas@1/sd@4,0",
		"/pci@1f,700000/pci@0/pci@2/pci@0/pci@8/LSILogic,sas@1/sd@5,0",
		"/pci@1f,700000/pci@0/pci@2/pci@0/pci@8/LSILogic,sas@1/sd@6,0",
		"/pci@1f,700000/pci@0/pci@2/pci@0/pci@8/LSILogic,sas@1/sd@7,0"
	};

	char	*ddev[N_DISKS];		/* "/devices"  */
	char	*pdev[N_DISKS];		/* "/platform" */

	switch (sys_platform) {

	case PLAT_ENTS:
		disk_dev = ents_devs;
		n_disks = N_ENTS_DISKS;
		break;

	case PLAT_CHALUPA:
	case PLAT_CHALUPA19:
		do_raid = 1;
		disk_dev = v440_devs;
		n_disks = N_CHALUPA_DISKS;
		break;

	case PLAT_SALSA19:
		disk_dev = n210_devs;
		n_disks = N_EN19_DISKS;
		break;

	case PLAT_SEATTLE1U:
	case PLAT_SEATTLE2U:
		do_raid = 1;
		disk_dev = seattle_devs;
		n_disks = (sys_platform == PLAT_SEATTLE1U) ?
		    N_SEATTLE1U_DISKS : N_SEATTLE2U_DISKS;
		break;

	case PLAT_BOSTON:
		/*
		 * If we can open the devctl path for the built-in 1068E
		 * controller then assume we're a 1068E-equipped Boston
		 * and make all the paths appropriate for that hardware.
		 * Otherwise assume we are a 1068X-equipped Boston and
		 * make all of the paths appropriate for a 1068X PCI-X
		 * controller in PCI slot 4.
		 *
		 * The flag is also used in the check_raid() function.
		 */
		if ((fd = open(BOSTON_DISK_DEVCTL_1068E, O_RDONLY)) != -1) {
			boston_1068e_flag = 1;
			disk_dev = boston_devs_1068e;
		} else {
			boston_1068e_flag = 0;
			disk_dev = boston_devs_1068x;
		}
		(void) close(fd);
		do_raid = 1;
		n_disks = N_BOSTON_DISKS;
		break;

	default: /* PLAT_ENXS/PLAT_EN19 */
		disk_dev = mpxu_devs;
		n_disks = (sys_platform == PLAT_EN19) ?
		    N_EN19_DISKS : N_MPXU_DISKS;
	}

	/*
	 * make up disk names
	 */

	for (i = 0; i < n_disks; i++) {
		char buffer[MAXPATHLEN];
		sprintf(buffer, "/devices%s", disk_dev[i]);
		ddev[i] = strdup(buffer);
		sprintf(buffer, "/platform%s", disk_dev[i]);
		pdev[i] = strdup(buffer);
	}

	disk_leds_thread_running = B_TRUE;

	for (;;) {
		for (i = 0; i < n_disks; i++) {
			/*
			 * If it's one of the RAID disks, we have already
			 * applied the ok2remove policy.
			 */
			if (do_raid && check_raid(i))	{
				continue;
			}

			dhdl = devctl_device_acquire(ddev[i], 0);
			devctl_device_getstate(dhdl, &statep);
			devctl_release(dhdl);

			if (statep & DEVICE_OFFLINE) {
				if (disk_ready[i] != B_FALSE) {
					update_disk_node(disk_name[i], pdev[i]);
					if (set_led(disk_name[i], REMOK_LED,
					    PICL_PROPVAL_ON) == PICL_SUCCESS)
						disk_ready[i] = B_FALSE;
				}
			} else if (statep & DEVICE_ONLINE) {
				if (disk_ready[i] != B_TRUE) {
					update_disk_node(disk_name[i], pdev[i]);
					if (set_led(disk_name[i], REMOK_LED,
					    PICL_PROPVAL_OFF) == PICL_SUCCESS)
						disk_ready[i] = B_TRUE;
				}
			}
		}

		/*
		 * wait a bit until we check again
		 */

		(void) poll(NULL, 0, DISK_POLL_TIME);

		/*
		 * are we to stop?
		 */

		(void) pthread_mutex_lock(&g_mutex);

		while (g_finish_now) {
			/*
			 * notify _fini routine that we've paused
			 */
			disk_leds_thread_ack = B_TRUE;
			(void) pthread_cond_signal(&g_cv_ack);

			/*
			 * and go to sleep in case we get restarted
			 */
			(void) pthread_cond_wait(&g_cv, &g_mutex);
		}
		(void) pthread_mutex_unlock(&g_mutex);
	}

	return ((void *)err);
}

/*
 * Given the powersupply name, convert to addr
 */
static int
ps_name_to_addr(char *name)
{
	int ps_addr = 0;
	if ((strcmp(name, PS0_NAME) == 0) ||
	    (strcmp(name, PSU0_NAME) == 0))	{
		switch (sys_platform) {
		case PLAT_SEATTLE1U:
		case PLAT_SEATTLE2U:
			ps_addr = SEATTLE_PS0_ADDR;
			break;
		case PLAT_BOSTON:
			ps_addr = BOSTON_PS0_ADDR;
			break;
		default:
			ps_addr = PS0_ADDR;
			break;
		}
	} else if ((strcmp(name, PS1_NAME) == 0) ||
	    (strcmp(name, PSU1_NAME) == 0))	{
		switch (sys_platform) {
		case PLAT_SEATTLE1U:
		case PLAT_SEATTLE2U:
			ps_addr = SEATTLE_PS1_ADDR;
			break;
		case PLAT_BOSTON:
			ps_addr = BOSTON_PS1_ADDR;
			break;
		default:
			ps_addr = PS1_ADDR;
			break;
		}
	} else if ((strcmp(name, PS2_NAME) == 0) ||
	    (strcmp(name, PSU2_NAME) == 0))	{
		switch (sys_platform) {
		case PLAT_BOSTON:
			ps_addr = BOSTON_PS2_ADDR;
			break;
		default:
			ps_addr = PS2_ADDR;
			break;
		}
	} else if ((strcmp(name, PS3_NAME) == 0) ||
	    (strcmp(name, PSU3_NAME) == 0))	{
		switch (sys_platform) {
		case PLAT_BOSTON:
			ps_addr = BOSTON_PS3_ADDR;
			break;
		default:
			ps_addr = PS3_ADDR;
			break;
		}
	}

	return (ps_addr);
}

/*
 * Given powersupply name, convert to unit addr
 */
static char *
ps_name_to_unitaddr(char *name)
{
	char *unitaddr;

	if (strcmp(name, PS0_NAME) == 0)	{
		switch (sys_platform) {
		case PLAT_SEATTLE1U:
		case PLAT_SEATTLE2U:
			unitaddr = SEATTLE_PS0_UNITADDR;
			break;
		case PLAT_BOSTON:
			unitaddr = BOSTON_PS0_UNITADDR;
			break;
		default:
			unitaddr = PS0_UNITADDR;
			break;
		}
	} else if (strcmp(name, PS1_NAME) == 0)	{
		switch (sys_platform) {
		case PLAT_SEATTLE1U:
		case PLAT_SEATTLE2U:
			unitaddr = SEATTLE_PS1_UNITADDR;
			break;
		case PLAT_BOSTON:
			unitaddr = BOSTON_PS1_UNITADDR;
			break;
		default:
			unitaddr = PS1_UNITADDR;
			break;
		}
	} else if (strcmp(name, PS2_NAME) == 0)	{
		switch (sys_platform) {
		case PLAT_BOSTON:
			unitaddr = BOSTON_PS2_UNITADDR;
			break;
		default:
			unitaddr = PS2_UNITADDR;
			break;
		}
	} else if (strcmp(name, PS3_NAME) == 0)	{
		switch (sys_platform) {
		case PLAT_BOSTON:
			unitaddr = BOSTON_PS3_UNITADDR;
			break;
		default:
			unitaddr = PS3_UNITADDR;
			break;
		}
	}
	else
		unitaddr = NULL;

	return (unitaddr);
}

/*
 * converts apid to real FRU name in PICL tree. The
 * name of powersupply devices on chalupa19 are
 * PSU instead of PS
 */
static char *
ps_apid_to_nodename(char *apid)
{
	char *nodename;

	if (sys_platform != PLAT_CHALUPA19)
		return (apid);

	if (strcmp(apid, PS0_NAME) == 0)
		nodename = PSU0_NAME;
	else if (strcmp(apid, PS1_NAME) == 0)
		nodename = PSU1_NAME;
	else if (strcmp(apid, PS2_NAME) == 0)
		nodename = PSU2_NAME;
	else if (strcmp(apid, PS3_NAME) == 0)
		nodename = PSU3_NAME;
	else
		nodename = apid;

	return (nodename);
}

/*
 * Create SEEPROM node at insertion time.
 */
static int
create_i2c_node(char *ap_id)
{
	int	nd_reg[2];
	devctl_ddef_t	ddef_hdl;
	devctl_hdl_t	bus_hdl;
	devctl_hdl_t	dev_hdl;
	char		dev_path[MAXPATHLEN];
	char		*compatible;

	/* create seeprom node */
	nd_reg[0] = 0;
	nd_reg[1] = ps_name_to_addr(ap_id);

	switch (sys_platform) {
	case PLAT_SEATTLE1U:
	case PLAT_SEATTLE2U:
		bus_hdl = devctl_bus_acquire(SEATTLE_PSU_I2C_BUS_DEV, 0);
		compatible = SEATTLE_PSU_COMPATIBLE;
		break;
	case PLAT_BOSTON:
		bus_hdl = devctl_bus_acquire(BOSTON_PSU_I2C_BUS_DEV, 0);
		compatible = BOSTON_PSU_COMPATIBLE;
		break;
	default:
		bus_hdl = devctl_bus_acquire(PSU_I2C_BUS_DEV, 0);
		compatible = PSU_COMPATIBLE;
		break;
	}

	if (bus_hdl == NULL)
		return (DDI_FAILURE);

	/* device definition properties */
	ddef_hdl = devctl_ddef_alloc(PS_DEVICE_NAME, 0);
	(void) devctl_ddef_string(ddef_hdl, "compatible", compatible);
	(void) devctl_ddef_string(ddef_hdl, "device_type", "seeprom");
	(void) devctl_ddef_int_array(ddef_hdl, "reg", 2, nd_reg);

	/* create the device node */
	if (devctl_bus_dev_create(bus_hdl, ddef_hdl, 0, &dev_hdl))
		return (DDI_FAILURE);

	if (devctl_get_pathname(dev_hdl, dev_path, MAXPATHLEN) == NULL)
		return (DDI_FAILURE);

	devctl_release(dev_hdl);
	devctl_ddef_free(ddef_hdl);
	devctl_release(bus_hdl);
	return (DDI_SUCCESS);
}

/*
 * Delete SEEPROM node at insertion time.
 */
static void
delete_i2c_node(char *ap_id)
{
	devctl_hdl_t	dev_hdl;
	char	buf[MAXPATHLEN];

	switch (sys_platform) {
	case PLAT_SEATTLE1U:
	case PLAT_SEATTLE2U:
		sprintf_buf2(buf, SEATTLE_PSU_DEV, ps_name_to_addr(ap_id));
		break;
	case PLAT_BOSTON:
		sprintf_buf2(buf, BOSTON_PSU_DEV, ps_name_to_addr(ap_id));
		break;
	default:
		sprintf_buf2(buf, PSU_DEV, ps_name_to_addr(ap_id));
		break;
	}

	dev_hdl = devctl_device_acquire(buf, 0);
	if (dev_hdl == NULL) {
		return;
	}

	/*
	 * If the seeprom driver is not loaded, calls to
	 * devctl_device_remove fails for seeprom devices
	 */
	if (devctl_device_remove(dev_hdl)) {
		di_init_driver(SEEPROM_DRIVER_NAME, 0);
		devctl_device_remove(dev_hdl);
	}
	devctl_release(dev_hdl);
}

static void
add_op_status(envmon_hpu_t *hpu, int *index)
{
	boolean_t		rmc_flag;
	boolean_t		ps_flag;
	boolean_t		disk_flag;
	char			node_name[MAXPATHLEN];
	boolean_t		flag;

	rmc_flag = (strcmp(hpu->id.name, RMC_NAME) == 0);
	ps_flag = (strncmp(hpu->id.name, PS_NAME,
	    PS_NAME_LEN) == 0);
	disk_flag = (strncmp(hpu->id.name, DISK_NAME,
	    DISK_NAME_LEN) == 0);
	if (rmc_flag || ps_flag) {
		idprop->idp[*index].envhandle = hpu->id;
		flag = rmc_flag && ((sys_platform != PLAT_CHALUPA) &&
		    (sys_platform != PLAT_CHALUPA19));
		sprintf_buf2(node_name,
		    flag ? SYS_BOARD_PATH : CHASSIS_LOC_PATH, ps_flag ?
		    ps_apid_to_nodename(hpu->id.name) : hpu->id.name);

		add_op_status_by_name(node_name, ps_flag ? PS_FRU_NAME : NULL,
		    &idprop->idp[(*index)++].volprop);
	} else if (disk_flag)	{
		idprop->idp[*index].envhandle = hpu->id;
		switch (sys_platform)	{
		case PLAT_CHALUPA:
		case PLAT_CHALUPA19:
			sprintf_buf2(node_name, CHASSIS_LOC_PATH, hpu->id.name);
			break;
		case PLAT_SEATTLE1U:
			sprintf_buf2(node_name, SEATTLE1U_HDDBP_PATH, \
			    hpu->id.name);
			break;
		case PLAT_SEATTLE2U:
			sprintf_buf2(node_name, SEATTLE2U_HDDBP_PATH, \
			    hpu->id.name);
			break;
		case PLAT_BOSTON:
			sprintf_buf2(node_name, BOSTON_HDDBP_PATH, \
			    hpu->id.name);
			break;
		default:
			sprintf_buf2(node_name, SYS_BOARD_PATH, hpu->id.name);
			break;
		}
		add_op_status_by_name(node_name, DISK_FRU_NAME,
		    &idprop->idp[(*index)++].volprop);
	}
}