cherrystone/psvcpolicy/psvcpolicy.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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * Cherrystone platform specific environment monitoring policies
 */

#include	<syslog.h>
#include	<unistd.h>
#include	<stdio.h>
#include 	<libintl.h>
#include	<string.h>
#include	<stdlib.h>
#include	<errno.h>
#include	<fcntl.h>
#include	<sys/types.h>
#include	<sys/time.h>
#include	<sys/time_impl.h>
#include	<sys/signal.h>
#include	<sys/devctl.h>
#include	<libdevinfo.h>
#include	<libdevice.h>
#include	<picl.h>
#include	<picltree.h>
#include	<sys/i2c/clients/i2c_client.h>
#include	<hbaapi.h>
#include	<limits.h>
#include	<sys/systeminfo.h>

#include	<psvc_objects.h>

/* Device paths for power supply hotplug handling */
#define	SEG5_ADDR		0x30
#define	EBUS_DEV_NAME		"/devices/pci@9,700000/ebus@1/"
#define	SEG5_DEV_NAME		EBUS_DEV_NAME "i2c@1,30/"
#define	SEG5_ADDR_DEV_FMT	EBUS_DEV_NAME "i2c@1,%x:devctl"

#define	QLC_NODE		 "/pci@9,600000/SUNW,qlc@2"

#define	DISK_DRV  "ssd"
#define	MAX_DISKS 2
#define	WWN_SIZE 8
#define	ONBOARD_CONTR	"../../devices/pci@9,600000/SUNW,qlc@2/fp@0,0:fc"

/* Bit masks so we don't "wedge" the inputs */
#define	PCF8574_BIT_WRITE_VALUE(byte, bit, value)\
				((value << bit) | (byte & (~(0x01 << bit))))

#define	PDB_MUST_BE_1		0xBF
#define	PSU_MUST_BE_1		0x7F
#define	DISKBP_MUST_BE_1	0x0F

/*LINTLIBRARY*/

#define	PSVC_MAX_STR_LEN	32

#define	PS_MAX_FAULT_SENSORS 3

/*
 * Keep track of the power supply's fail status for reporting if/when
 * they go good.
 * ID's:
 * O	PSx_FAULT_SENSOR
 * 1	Doesn't matter	-- only need 0 to be PSx_FAULT_SENSOR
 * 2	Doesn't matter
 */
static char	*ps_prev_id[2][3] =
		{{NULL, NULL, NULL}, {NULL, NULL, NULL}};
static int	ps_prev_failed[2][3] = {{0, 0, 0}, {0, 0, 0}};

/*
 * Keep track of the power supply's previous presence
 * because PSVC doesn't do that for us.
 */
static boolean_t ps_prev_present[2];
static boolean_t ps_present[2];

/* Local Routines for the environmental policies */
static int ac_unplugged(psvc_opaque_t, char *);
static int ac_power_check(psvc_opaque_t, char *, char *);

/*
 * The I2C bus is noisy, and the state may be incorrectly reported as
 * having changed.  When the state changes, we attempt to confirm by
 * retrying.  If any retries indicate that the state has not changed, we
 * assume the state change(s) were incorrect and the state has not changed.
 * The following variables are used to store the tuneable values read in
 * from the optional i2cparam.conf file for this shared object library.
 */
static int n_retry_fan = PSVC_NUM_OF_RETRIES;
static int retry_sleep_fan = 1;
static int n_retry_ps_status = PSVC_NUM_OF_RETRIES;
static int retry_sleep_ps_status = 1;
static int n_retry_pshp = PSVC_NUM_OF_RETRIES;
static int retry_sleep_pshp = 1;
static int n_retry_diskhp = PSVC_NUM_OF_RETRIES;
static int retry_sleep_diskhp = 1;
static int n_retry_temp_shutdown = PSVC_NUM_OF_RETRIES;
static int retry_sleep_temp_shutdown = 1;
static int n_retry_fsp_fault = PSVC_NUM_OF_RETRIES;
static int retry_sleep_fsp_fault = 1;

typedef struct {
	int *pvar;
	char *texttag;
} i2c_noise_param_t;

static i2c_noise_param_t i2cparams[] = {
	&n_retry_fan, "n_retry_fan",
	&retry_sleep_fan, "retry_sleep_fan",
	&n_retry_ps_status, "n_retry_ps_status",
	&retry_sleep_ps_status, "retry_sleep_ps_status",
	&n_retry_pshp, "n_retry_pshp",
	&retry_sleep_pshp, "retry_sleep_pshp",
	&n_retry_diskhp, "n_retry_diskhp",
	&retry_sleep_diskhp, "retry_sleep_diskhp",
	&n_retry_temp_shutdown, "n_retry_temp_shutdown",
	&retry_sleep_temp_shutdown, "retry_sleep_temp_shutdown",
	&n_retry_fsp_fault, "n_retry_fsp_fault",
	&retry_sleep_fsp_fault, "retry_sleep_fsp_fault",
	NULL, NULL
};

#pragma init(i2cparams_load)

static void
i2cparams_debug(i2c_noise_param_t *pi2cparams, char *platform,
	int usingDefaults)
{
	char s[128];
	i2c_noise_param_t *p;

	if (!usingDefaults) {
		(void) snprintf(s, sizeof (s),
		    "# Values from /usr/platform/%s/lib/i2cparam.conf\n",
		    platform);
		syslog(LOG_WARNING, "%s", s);
	} else {
		/* no file - we're using the defaults */
		(void) snprintf(s, sizeof (s),
"# No /usr/platform/%s/lib/i2cparam.conf file, using defaults\n",
		    platform);
	}
	(void) fputs(s, stdout);
	p = pi2cparams;
	while (p->pvar != NULL) {
		(void) snprintf(s, sizeof (s), "%s %d\n", p->texttag,
		    *(p->pvar));
		if (!usingDefaults)
			syslog(LOG_WARNING, "%s", s);
		(void) fputs(s, stdout);
		p++;
	}
}

static void
i2cparams_load(void)
{
	FILE *fp;
	char filename[PATH_MAX];
	char platform[64];
	char s[128];
	char var[128];
	int val;
	i2c_noise_param_t *p;

	if (sysinfo(SI_PLATFORM, platform, sizeof (platform)) == -1) {
		syslog(LOG_ERR, "sysinfo error %s\n", strerror(errno));
		return;
	}
	(void) snprintf(filename, sizeof (filename),
	    "/usr/platform/%s/lib/i2cparam.conf", platform);
	/* read thru the i2cparam.conf file and set variables */
	if ((fp = fopen(filename, "r")) != NULL) {
		while (fgets(s, sizeof (s), fp) != NULL) {
			if (s[0] == '#') /* skip comment lines */
				continue;
			/* try to find a string match and get the value */
			if (sscanf(s, "%127s %d", var, &val) != 2)
				continue;
			if (val < 1)
				val = 1;  /* clamp min value */
			p = &(i2cparams[0]);
			while (p->pvar != NULL) {
				if (strncmp(p->texttag, var, sizeof (var)) ==
				    0) {
					*(p->pvar) = val;
					break;
				}
				p++;
			}
		}
		(void) fclose(fp);
	}
	/* output the values of the parameters */
	i2cparams_debug(&(i2cparams[0]), platform, ((fp == NULL)? 1 : 0));
}

/*
 * Create an I2C device node.
 */
static int
create_i2c_node(char *nd_name, char *nd_compat, int nd_nexi, int *nd_reg)
{
	devctl_ddef_t	ddef_hdl = NULL;
	devctl_hdl_t	bus_hdl = NULL;
	devctl_hdl_t	dev_hdl = NULL;
	char		buf[MAXPATHLEN];
	char		dev_path[MAXPATHLEN];
	int		rv = PSVC_FAILURE;

	(void) snprintf(buf, sizeof (buf), SEG5_ADDR_DEV_FMT, nd_nexi);
	bus_hdl = devctl_bus_acquire(buf, 0);
	if (bus_hdl == NULL)
		goto bad;

	/* device definition properties */
	ddef_hdl = devctl_ddef_alloc(nd_name, 0);
	(void) devctl_ddef_string(ddef_hdl, "compatible", nd_compat);
	(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))
		goto bad;

	if (devctl_get_pathname(dev_hdl, dev_path, MAXPATHLEN) == NULL)
		goto bad;

#ifdef DEBUG
	syslog(LOG_ERR, "PSVC: create_i2c_node: Device node created: (%s)",
		dev_path);
#endif
	rv = PSVC_SUCCESS;
bad:
	if (dev_hdl)  devctl_release(dev_hdl);
	if (ddef_hdl) devctl_ddef_free(ddef_hdl);
	if (bus_hdl)  devctl_release(bus_hdl);
	return (rv);
}

/*
 * Delete an I2C device node given the device path.
 */
static void
delete_i2c_node(char *nd)
{
	int		rv;
	devctl_hdl_t	dev_hdl;

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

	rv = devctl_device_remove(dev_hdl);
	if (rv != DDI_SUCCESS)
		perror(nd);
#ifdef DEBUG
	else
		syslog(LOG_ERR, "Device node deleted: (%s)", nd);
#endif
	devctl_release(dev_hdl);
}


/* PCF8574 Reset Function */
static int
send_pcf8574_reset(psvc_opaque_t hdlp, char *reset_dev)
{
	int	err;
	uint8_t reset_bits[2] = {0x7F, 0xFF};
	int	i;
	for (i = 0; i < 2; i++) {
		err = psvc_set_attr(hdlp, reset_dev, PSVC_GPIO_VALUE_ATTR,
			&reset_bits[i]);
		if (err != PSVC_SUCCESS) {
#ifdef DEBUG
			syslog(LOG_ERR,
				gettext("Reset to %s with 0x%x failed"),
				reset_dev, reset_bits[i]);
#endif
			return (err);
		}
	}
	/* Need to give u-code a chance to update */
	sleep(3);
	return (err);
}

static int
pcf8574_write_bit(psvc_opaque_t hdlp, char *id, uint8_t bit_num,
	uint8_t bit_val, uint8_t write_must_be_1)
{
	int	rv = PSVC_FAILURE;
	uint8_t	byte;

	rv = psvc_get_attr(hdlp, id, PSVC_GPIO_VALUE_ATTR, &byte);
	if (rv != PSVC_SUCCESS)
		return (rv);

	byte = PCF8574_BIT_WRITE_VALUE(byte, bit_num, bit_val);
	byte |= write_must_be_1;
	rv = psvc_set_attr(hdlp, id, PSVC_GPIO_VALUE_ATTR, &byte);
	return (rv);
}

/*
 * To enable the i2c bus, we must toggle bit 6 on the PDB's
 * PCF8574 (0x4C) high->low->high
 */
static int
pdb_enable_i2c(psvc_opaque_t hdlp)
{
	int		rv = PSVC_SUCCESS, i;
	int		bit_vals[3] = {1, 0, 1};
	int		bit_num = 6;

	for (i = 0; i < 3; i++) {
		rv = pcf8574_write_bit(hdlp, "PDB_PORT", bit_num, bit_vals[i],
			PDB_MUST_BE_1);
		if (rv != PSVC_SUCCESS) {
			goto bad;
		}
	}
	return (rv);
bad:
#ifdef DEBUG
	syslog(LOG_ERR, gettext("PDB I2C Bus Enabling Failed"));
#endif
	return (rv);
}

int32_t
psvc_init_disk_bp_policy_0(psvc_opaque_t hdlp, char *id)
{
	uint8_t	reset = 0xFF;
	return (psvc_set_attr(hdlp, id, PSVC_GPIO_VALUE_ATTR,
		&reset));
}

int32_t
pcf8574_init_policy_0(psvc_opaque_t hdlp, char *id)
{
	return (send_pcf8574_reset(hdlp, id));
}

static int32_t
check_fan(psvc_opaque_t hdlp, char *tray_id, char *fan_id, boolean_t *fault_on)
{
	int		status;
	int		speed;
	int		low_thresh;
	boolean_t	have_fault = 0;
	char		*tach_id;
	char		state[PSVC_MAX_STR_LEN];
	char		prev_state[PSVC_MAX_STR_LEN];
	char		fault_state[PSVC_MAX_STR_LEN];
	int		retry;

	/* Get this fan object's corresponding fan tach */
	status = psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_ID_ATTR,
		&tach_id, PSVC_FAN_SPEED_TACHOMETER, 0);
	if (status != PSVC_SUCCESS)
		return (status);

	/* Get the low fan speed threshold */
	status = psvc_get_attr(hdlp, tach_id, PSVC_LO_WARN_ATTR, &low_thresh);
	if (status != PSVC_SUCCESS)
		return (status);

	retry = 0;
	do {
		if (retry)
			(void) sleep(retry_sleep_fan);
		/* Get the fan speed */
		status = psvc_get_attr(hdlp, tach_id, PSVC_SENSOR_VALUE_ATTR,
		    &speed);
		if (status != PSVC_SUCCESS)
		return (status);

		if (speed <= low_thresh) { /* We see a fault */
			strlcpy(fault_state, "DEVICE_FAIL",
			    sizeof (fault_state));
			strlcpy(state, PSVC_ERROR, sizeof (state));
			have_fault = 1;
		} else { /* Fault gone? */
			strlcpy(fault_state, PSVC_NO_FAULT,
			    sizeof (fault_state));
			strlcpy(state, PSVC_OK, sizeof (state));
			have_fault = 0;
		}
		retry++;
	} while ((retry < n_retry_fan) && (speed <= low_thresh));

	/* Assign new states to the fan object */
	status = psvc_set_attr(hdlp, fan_id, PSVC_FAULTID_ATTR, fault_state);
	if (status != PSVC_SUCCESS)
		return (status);
	status = psvc_set_attr(hdlp, fan_id, PSVC_STATE_ATTR, state);
	if (status != PSVC_SUCCESS)
		return (status);

	/* Get state and previous state */
	status = psvc_get_attr(hdlp, fan_id, PSVC_STATE_ATTR, state);
	if (status != PSVC_SUCCESS)
		return (status);
	status = psvc_get_attr(hdlp, fan_id, PSVC_PREV_STATE_ATTR, prev_state);
	if (status != PSVC_SUCCESS)
		return (status);

	/* Display notices */
	if (strcmp(state, PSVC_OK) != 0) {
		syslog(LOG_ERR,	gettext("WARNING: %s (%s) failure detected"),
			tray_id, fan_id);
	} else {
		if (strcmp(state, prev_state) != 0) {
		syslog(LOG_ERR,	gettext("NOTICE: Device %s (%s) OK"),
			tray_id, fan_id);
		}
	}

	*fault_on |= have_fault;
	return (PSVC_SUCCESS);
}

/*
 * This policy acts on fan trays.  It looks at each of its fans
 * and checks the speeds.  If the fan speed is less than the threshold,
 * then indicate:  console, log, LED.
 */
int32_t
psvc_fan_fault_check_policy_0(psvc_opaque_t hdlp, char *id)
{
	int		fan_count;
	int		led_count;
	int		err, i;
	char		*led_id;
	char		*fan_id;
	char		led_state[PSVC_MAX_STR_LEN];
	char		state[PSVC_MAX_STR_LEN];
	char		prev_state[PSVC_MAX_STR_LEN];
	boolean_t	fault_on = 0;

	/* Get the number of fans associated with this fan tray. */
	err = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &fan_count,
		PSVC_FAN_TRAY_FANS);
	if (err != PSVC_SUCCESS)
		return (err);

	for (i = 0; i < fan_count; i++) {
		err = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
			&fan_id, PSVC_FAN_TRAY_FANS, i);
		if (err != PSVC_SUCCESS)
			return (err);

		err = check_fan(hdlp, id, fan_id, &fault_on);
		if (err != PSVC_SUCCESS)
			return (err);
	}

	if (fault_on) {
		strlcpy(led_state, PSVC_LED_ON, sizeof (led_state));
		err = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, PSVC_ERROR);
		if (err != PSVC_SUCCESS)
			return (err);

	} else {
		strlcpy(led_state, PSVC_LED_OFF, sizeof (led_state));
		err = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, PSVC_OK);
		if (err != PSVC_SUCCESS)
			return (err);
	}

	err = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
	if (err != PSVC_SUCCESS)
		return (err);
	err = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR, prev_state);
	if (err != PSVC_SUCCESS)
		return (err);

	/*
	 * Set leds according to the fan tray's states.
	 * (we only do this if there is a change of state in order
	 *  to reduce i2c traffic)
	 */
	if (strcmp(state, prev_state) != 0) {
		err = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR,
			&led_count, PSVC_DEV_FAULT_LED);
		if (err != PSVC_SUCCESS)
			return (err);
		for (i = 0; i < led_count; i++) {
			err = psvc_get_attr(hdlp, id,
				PSVC_ASSOC_ID_ATTR, &led_id,
				PSVC_DEV_FAULT_LED, i);
			if (err != PSVC_SUCCESS)
				return (err);
			err = psvc_set_attr(hdlp, led_id,
				PSVC_LED_STATE_ATTR, led_state);
			if (err != PSVC_SUCCESS)
				return (err);
			err = psvc_get_attr(hdlp, led_id,
				PSVC_LED_STATE_ATTR, led_state);
			if (err != PSVC_SUCCESS)
				return (err);
		}
	}
	return (err);
}

static int32_t
check_cpu_temp_fault(psvc_opaque_t hdlp, char *cpu, int32_t cpu_count)
{
	char *sensorid;
	int32_t sensor_count;
	int32_t status = PSVC_SUCCESS;
	int32_t i;
	char fault[PSVC_MAX_STR_LEN];
	int		retry;

	psvc_get_attr(hdlp, cpu, PSVC_ASSOC_MATCHES_ATTR, &sensor_count,
		PSVC_DEV_TEMP_SENSOR);
	for (i = 0; i < sensor_count; ++i) {
		status = psvc_get_attr(hdlp, cpu, PSVC_ASSOC_ID_ATTR,
			&sensorid, PSVC_DEV_TEMP_SENSOR, i);
		if (status == PSVC_FAILURE)
			return (status);

		retry = 0;
		do {
			if (retry)
				(void) sleep(retry_sleep_temp_shutdown);
			status = psvc_get_attr(hdlp, sensorid,
			    PSVC_FAULTID_ATTR, fault);
			if (status == PSVC_FAILURE)
				return (status);
			retry++;
		} while (((strcmp(fault, PSVC_TEMP_LO_SHUT) == 0) ||
		    (strcmp(fault, PSVC_TEMP_HI_SHUT) == 0)) &&
		    (retry < n_retry_temp_shutdown));

		if ((strcmp(fault, PSVC_TEMP_HI_SHUT) == 0) ||
			(strcmp(fault, PSVC_TEMP_LO_SHUT) == 0)) {
			system("shutdown -y -g 60 -i 5 \"OVERTEMP condition\"");
		}
	}

	return (status);
}

int32_t
psvc_shutdown_policy_0(psvc_opaque_t hdlp, char *id)
{
	int32_t cpu_count;
	char *cpuid;
	int32_t i;
	boolean_t present;
	int32_t status = PSVC_SUCCESS;

	psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &cpu_count,
		PSVC_CPU);
	for (i = 0; i < cpu_count; ++i) {

		status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, &cpuid,
			PSVC_CPU, i);
		if (status == PSVC_FAILURE)
			return (status);

		status = psvc_get_attr(hdlp, cpuid,
			PSVC_PRESENCE_ATTR, &present);
		if (status == PSVC_FAILURE && present == PSVC_PRESENT)
			return (status);
		if (present == PSVC_PRESENT) {
			status = check_cpu_temp_fault(hdlp, cpuid, cpu_count);
			if (status == PSVC_FAILURE && errno != ENODEV)
				return (status);
		}
	}

	return (PSVC_SUCCESS);
}

/*
 * Checks device specified by the PSVC_DEV_FAULT_SENSOR association
 * for errors, and if there is, then report and turn on the FSP Fault
 * Led.
 */
int32_t
psvc_fsp_device_fault_check_policy_0(psvc_opaque_t hdlp, char *id)
{
	int32_t	status;
	int32_t	i;
	int32_t	device_count = 0;
	char	device_state[PSVC_MAX_STR_LEN];
	char	*device_id;
	int32_t	failed_count = 0;
	static int32_t led_on = 0;
	int		retry;

	status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR,
		&device_count, PSVC_DEV_FAULT_SENSOR);
	if (status != PSVC_SUCCESS)
		return (status);

	for (i = 0; i < device_count; i++) {
		status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
			&device_id, PSVC_DEV_FAULT_SENSOR, i);
		if (status != PSVC_SUCCESS)
			return (status);

		retry = 0;
		do {
			if (retry)
				(void) sleep(retry_sleep_fsp_fault);
			status = psvc_get_attr(hdlp, device_id, PSVC_STATE_ATTR,
			    device_state);
			if (status != PSVC_SUCCESS)
				return (status);

			if (strcmp(device_state, PSVC_OK) != 0 &&
			    strcmp(device_state, PSVC_HOTPLUGGED) != 0 &&
			    strcmp(device_state, "NO AC POWER") != 0 &&
			    strlen(device_state) != 0) {
			    failed_count++;
			}
			retry++;
		} while ((retry < n_retry_fsp_fault) && (failed_count));
	}
	if (failed_count == 0 && led_on) {
		syslog(LOG_ERR, gettext("%s has turned OFF"), id);
		status = psvc_set_attr(hdlp, id, PSVC_LED_STATE_ATTR,
			PSVC_LED_OFF);
		led_on = 0;
	}

	if (failed_count > 0 && ! led_on) {
		syslog(LOG_ERR,
			gettext("%s has turned ON"), id);
		status = psvc_set_attr(hdlp, id, PSVC_LED_STATE_ATTR,
			PSVC_LED_ON);
		led_on = 1;
	}

	return (PSVC_SUCCESS);
}

/* Power Supply Policy Helper and Worker Functions */
static void
ps_reset_prev_failed(int index)
{
	int	i;
	/* Reset the power supply's failure information */
	for (i = 0; i < 3; i++) {
		ps_prev_id[index][i] = NULL;
		ps_prev_failed[index][i] = 0;
	}

}
static int
check_i2c_access(psvc_opaque_t hdlp, char *id)
{
	int		rv;
	char		state[PSVC_MAX_STR_LEN];
	char		ps_fault_sensor[PSVC_MAX_STR_LEN];

	snprintf(ps_fault_sensor, sizeof (ps_fault_sensor),
		"%s_FAULT_SENSOR", id);

	rv = psvc_get_attr(hdlp, ps_fault_sensor, PSVC_SWITCH_STATE_ATTR,
		&state);
	return (rv);
}

/*
 * This routine takes in the PSVC handle pointer, the PS name, and the
 * instance number (0 or 1). It simply make a psvc_get call to get the
 * presence of each of the children under the PS. This call will set the
 * presence state of the child device if it was not there when the system
 * was booted.
 */
static int
handle_ps_hotplug_children_presence(psvc_opaque_t hdlp, char *id)
{
	char *child_add_on[4] = {"_RESET", "_LOGICAL_STATE", "_AC_IN_SENSOR",
				"_FAULT_SENSOR"};
	int add_ons = 4;
	char addon_id[PICL_PROPNAMELEN_MAX];
	char *sensor_id;
	int32_t	status = PSVC_SUCCESS;
	boolean_t presence;
	int j;

	/* Go through the add on list and set presence */
	for (j = 0; j < add_ons; j++) {
		snprintf(addon_id, sizeof (addon_id), "%s%s", id,
		    child_add_on[j]);
		status = psvc_get_attr(hdlp, addon_id, PSVC_PRESENCE_ATTR,
		    &presence);
		if (status != PSVC_SUCCESS)
			return (status);
	}

	/* Go through each PS's fault sensors */
	for (j = 0; j < PS_MAX_FAULT_SENSORS; j++) {
		status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
		    &(sensor_id), PSVC_DEV_FAULT_SENSOR, j);
		if (status != PSVC_SUCCESS)
			return (status);
		status = psvc_get_attr(hdlp, sensor_id, PSVC_PRESENCE_ATTR,
		    &presence);
		if (status != PSVC_SUCCESS)
			return (status);
	}

	/* Go through each PS's onboard i2c hardware */
	for (j = 0; j < 2; j++) {
		status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
		    &(sensor_id), PSVC_PHYSICAL_DEVICE, j);
		if (status != PSVC_SUCCESS)
			return (status);
		status = psvc_get_attr(hdlp, sensor_id, PSVC_PRESENCE_ATTR,
		    &presence);
		if (status != PSVC_SUCCESS)
			return (status);
	}

	return (status);
}

static int
handle_ps_hotplug(psvc_opaque_t hdlp, char *id, boolean_t present)
{
	int32_t		status = PSVC_SUCCESS;
	int32_t		instance;
	picl_nodehdl_t	parent_node;
	picl_nodehdl_t	child_node;
	char		info[PSVC_MAX_STR_LEN];
	char		ps_logical_state[PICL_PROPNAMELEN_MAX];
	char		parent_path[PICL_PROPNAMELEN_MAX];
	char		ps_path[PICL_PROPNAMELEN_MAX];
	static int	fruprom_addr[2][2] = { {0, 0xa2}, {0, 0xa0} };
	static int	pcf8574_addr[2][2] = { {0, 0x72}, {0, 0x70} };
	char		dev_path[MAXPATHLEN];

	/* Convert name to node and parent path */
	psvcplugin_lookup(id, parent_path, &child_node);

	/*
	 * Get the power supply's instance.
	 * Used to index the xxx_addr arrays
	 */
	status = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance);
	if (status != PSVC_SUCCESS)
		return (status);

	if (present == PSVC_PRESENT && !ps_prev_present[instance]) {
		/* Service Power Supply Insertion */
		syslog(LOG_ERR, gettext("Device %s inserted"), id);

		/* PICL Tree Maintenance */
		ptree_get_node_by_path(parent_path, &parent_node);
		ptree_add_node(parent_node, child_node);
		snprintf(ps_path, sizeof (ps_path), "%s/%s", parent_path, id);
		psvcplugin_add_children(ps_path);

		/*
		 * This code to update the presences of power supply
		 * child devices in the event that picld was started
		 * without a power supply present.  This call makes
		 * the devices available after that initial insertion.
		 */
		status = handle_ps_hotplug_children_presence(hdlp, id);

		/*
		 * Device Tree Maintenance
		 * Add the devinfo tree node entry for the pcf8574 and seeprom
		 * and attach their drivers.
		 */
		status |= create_i2c_node("ioexp", "i2c-pcf8574", SEG5_ADDR,
			pcf8574_addr[instance]);
		status |= create_i2c_node("fru", "i2c-at24c64", SEG5_ADDR,
			fruprom_addr[instance]);
	} else {
		/* Service Power Supply Removal */
		syslog(LOG_ERR, gettext("Device %s removed"), id);

		/* Reset the power supply's failure information */
		ps_reset_prev_failed(instance);

		/* PICL Tree Maintenance */
		if (ptree_delete_node(child_node) != PICL_SUCCESS)
			syslog(LOG_ERR, "ptree_delete_node failed!");

		/*
		 * The hardcoded subscript in pcf8574_add[instance][1]
		 * refers to the address.  We are appending the address to
		 * device path.  Both elements are used when creating
		 * the i2c node (above).
		 */
		snprintf(dev_path, sizeof (dev_path),
			SEG5_DEV_NAME"ioexp@0,%x:pcf8574",
			pcf8574_addr[instance][1]);
		delete_i2c_node(dev_path);

		snprintf(dev_path, sizeof (dev_path),
			SEG5_DEV_NAME"fru@0,%x:fru", fruprom_addr[instance][1]);
			delete_i2c_node(dev_path);
	}

	snprintf(ps_logical_state, sizeof (ps_logical_state),
		"%s_LOGICAL_STATE", id);

	strlcpy(info, PSVC_OK, sizeof (info));
	status |= psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, info);
	status |= psvc_set_attr(hdlp, ps_logical_state,	PSVC_STATE_ATTR, info);

	strlcpy(info, PSVC_NO_FAULT, sizeof (info));
	status |= psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, info);

	/* Enable the i2c connection to the power supply */
	status |= pdb_enable_i2c(hdlp);
	return (status);
}

/*
 * check_ps_state() Checks for:
 *
 * - Failure bits:
 *	Power Supply Fan Failure
 *	Power Supply Temperature Failure
 *	Power Supply Generic Fault
 *	Power Supply AC Cord Plugged In
 *
 * - If we see a "bad" state we will report an error.
 *
 * - "Bad" states:
 *	Fault bit shows fault.
 *	Temperature fault shows fault.
 *	Fan fault shows fault.
 *	AC power NOT okay to supply.
 *
 * - If we see that the AC Cord is not plugged in, then the the other
 *   failure bits are invalid.
 *
 * - Send pcf8574_reset at the end of the policy if we see
 *   any "bad" states.
 */
static int32_t
check_ps_state(psvc_opaque_t hdlp, char *id)
{
	int32_t		sensor_count;
	int32_t		status = PSVC_SUCCESS;
	int32_t		i;
	int32_t		fault_on = 0;
	char		*sensor_id;
	char		ps_ok_sensor[PICL_PROPNAMELEN_MAX];
	char		ps_logical_state[PICL_PROPNAMELEN_MAX];
	char		ps_reset[PICL_PROPNAMELEN_MAX];
	char		previous_state[PSVC_MAX_STR_LEN];
	char		state[PSVC_MAX_STR_LEN];
	char		fault[PSVC_MAX_STR_LEN];
	int		ps_okay = 1;	/* Keep track of the PDB PS OK Bit */
	int		instance;
	int		retry;

	/* Logical state id */
	snprintf(ps_logical_state, sizeof (ps_logical_state),
		"%s_LOGICAL_STATE", id);

	/*
	 * ac_power_check updates the Power Supply state with "NO AC POWER" if
	 * the power cord is out OR PSVC_OK if the power cord is in.
	 */
	status = ac_power_check(hdlp, id, ps_logical_state);
	if (status == PSVC_FAILURE)
		return (status);

	/*
	 * After running ac_power_check we now need to get the current state
	 * of the PS.  If the power supply state is "NO AC POWER" then we do
	 * not need to check for failures and we return.
	 */
	status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
	if (status != PSVC_SUCCESS)
		return (status);

	if (strcmp(state, "NO AC POWER") == 0)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR, previous_state);
	if (status != PSVC_SUCCESS)
		return (status);

	snprintf(ps_ok_sensor, sizeof (ps_ok_sensor), "%s_OK_SENSOR", id);
	retry = 0;
	do {
		if (retry)
			(void) sleep(retry_sleep_ps_status);
		/* Handle the PDB P/S OK Bit */
		status = psvc_get_attr(hdlp, ps_ok_sensor,
		    PSVC_SWITCH_STATE_ATTR, state);
		if (status != PSVC_SUCCESS)
			return (status);
		retry++;
	} while ((retry < n_retry_ps_status) &&
	    (strcmp(previous_state, state)));


	/*
	 * If there is a change of state (current state differs from
	 * previous state, then assign the error values.
	 */
	if (strcmp(previous_state, state) != 0) {
		if (strcmp(state, PSVC_SWITCH_OFF) == 0) {
			strlcpy(state, PSVC_ERROR, sizeof (state));
			strlcpy(fault, "DEVICE_FAIL", sizeof (fault));
			fault_on = 1;
			syslog(LOG_ERR,	gettext(
				"Device %s: Failure Detected -- %s "
				"shutdown!"), id, id);
			ps_okay = 0;
		} else {
			strlcpy(state, PSVC_OK, sizeof (state));
			strlcpy(fault, PSVC_NO_FAULT, sizeof (fault));
		}

		status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state);
		if (status != PSVC_SUCCESS)
			return (status);

		status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, fault);
		if (status != PSVC_SUCCESS)
			return (status);
	}

	status = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &sensor_count,
		PSVC_DEV_FAULT_SENSOR);
	if (status != PSVC_SUCCESS) {
		return (status);
	}

	/* Handle the power supply fail bits. */
	for (i = 0; i < sensor_count; i++) {
		status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
			&sensor_id, PSVC_DEV_FAULT_SENSOR, i);
		if (status != PSVC_SUCCESS)
			return (status);

		retry = 0;
		do {
			if (retry)
				(void) sleep(retry_sleep_ps_status);
			status = psvc_get_attr(hdlp, sensor_id,
			    PSVC_SWITCH_STATE_ATTR, state);
			if (status != PSVC_SUCCESS)
				return (status);
			retry++;
		} while ((retry < n_retry_ps_status) &&
		    (strcmp(state, PSVC_SWITCH_ON) == 0));

		if (strcmp(state, PSVC_SWITCH_ON) == 0) {
			if (ps_prev_id[instance][i] == NULL)
				ps_prev_id[instance][i] = sensor_id;

			if (ps_prev_failed[instance][i] != 1)
				ps_prev_failed[instance][i] = 1;
			fault_on = 1;
			/*
			 * The first sensor in the list is:
			 * PSx_DEV_FAULT_SENSOR.  If this is on, we do not
			 * want to merely report that it's on, but rather
			 * report that there was a fault detected, thus
			 * improving diagnosability.
			 */
			if (i == 0) {
				/*
				 * Don't notify if the PDB PS OKAY Bit is
				 * "0"
				 */
				if (ps_okay)
					syslog(LOG_ERR, gettext(
						"Device %s: Fault Detected"),
							id);
			} else {
				syslog(LOG_ERR, gettext("Warning %s: %s is ON"),
					id, sensor_id);
			}
		}
	}

	status = psvc_get_attr(hdlp, ps_logical_state,
		PSVC_STATE_ATTR, state);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, ps_logical_state,
		PSVC_PREV_STATE_ATTR, previous_state);
	if (status != PSVC_SUCCESS)
		return (status);

	/*
	 * If we encountered a fault of any kind (something before
	 * has set 'fault_on' to '1') then we want to send the reset
	 * signal to the power supply's PCF8574 and also set
	 * 'ps_logical_state' to "ERROR" so that the FSP General Fault
	 * LED will light.
	 */
	if (fault_on) {
		if (ps_okay) {
			status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR,
				PSVC_GEN_FAULT);
			if (status != PSVC_SUCCESS)
				return (status);
		}
		status = psvc_set_attr(hdlp, ps_logical_state,
			PSVC_STATE_ATTR, PSVC_ERROR);
		if (status != PSVC_SUCCESS)
			return (status);
		/*
		 * "id" is in the form of "PSx", We need to make it
		 * PSx_RESET.
		 */
		snprintf(ps_reset, sizeof (ps_reset), "%s_RESET", id);
		status = send_pcf8574_reset(hdlp, ps_reset);
		return (status);
	}

	/*
	 * There was no fault encountered so we want to
	 * set 'ps_logical_state' to "OK"
	 */
	if (strcmp(state, PSVC_OK) != 0) {
		for (i = 0; i < 3; i++) {
			char	*sensor = ps_prev_id[instance][i];
			int	*prev_failed = &ps_prev_failed[instance][i];
			if (sensor == NULL)
				continue;
			if (*prev_failed == 0)
				continue;
			*prev_failed = 0;
			if (i == 0) {
				/*
				 * Don't notifiy if we have a power supply
				 * failure (PDB PS OKAY == 0
				 */
				if (ps_okay)
					syslog(LOG_ERR, gettext(
						"Notice %s: Fault Cleared"),
							id);
			} else {
				syslog(LOG_ERR, gettext("Notice %s: %s is OFF"),
					id, sensor);
			}
		}

		status = psvc_set_attr(hdlp, ps_logical_state,
			PSVC_STATE_ATTR, PSVC_OK);
		if (status != PSVC_SUCCESS)
			return (status);
		syslog(LOG_ERR, gettext("Device %s Okay"), id);
	}

	return (PSVC_SUCCESS);
}

/*
 * This routine takes in a handle pointer and a Power Supply id. It then gets
 * the switch state for the PSx_AC_IN_SENSOR. If the switch is OFF the cord is
 * unplugged and we return a true (1). If the switch is ON then the cord is
 * plugged in and we return a false (0). If the get_attr call fails we return
 * PSVC_FAILURE (-1).
 */
static int
ac_unplugged(psvc_opaque_t hdlp, char *id)
{
	int32_t		status = PSVC_SUCCESS;
	char		ac_sensor_id[PICL_PROPNAMELEN_MAX];
	char		ac_switch_state[PSVC_MAX_STR_LEN];

	snprintf(ac_sensor_id, sizeof (ac_sensor_id), "%s_AC_IN_SENSOR", id);

	status = psvc_get_attr(hdlp, ac_sensor_id, PSVC_SWITCH_STATE_ATTR,
		ac_switch_state);
	if (status == PSVC_FAILURE) {
		return (status);
	}

	if (strcmp(ac_switch_state, PSVC_SWITCH_OFF) == 0) {
		return (1);
	} else {
		return (0);
	}
}

/*
 * This routine expects a handle pointer, a Power Supply ID, and a PS logical
 * state switch ID.  It check to see if the power cord has been removed from or
 * inserted to the power supply. It then updates the PS state accordingly.
 */
static int
ac_power_check(psvc_opaque_t hdlp, char *id, char *ps_logical_state)
{
	int32_t		status = PSVC_SUCCESS;
	int32_t		sensor_count;
	char		*sensor_id;
	char		state[PSVC_MAX_STR_LEN];
	int		unplugged, i;

	status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
	if (status != PSVC_SUCCESS)
		return (status);

	/*
	 * Check for AC Power Cord. ac_unplugged will return true if the PS is
	 * unplugged, a false is the PS is plugged in, and PSVC_FAILURE if the
	 * call to get the state fails.
	 */
	unplugged = ac_unplugged(hdlp, id);
	if (status == PSVC_FAILURE) {
		return (status);
	}

	/*
	 * If power cord is not in, then we set the fault and error
	 * states to "".
	 * If power cord is in, then we check the devices.
	 */
	status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &sensor_count,
		PSVC_DEV_FAULT_SENSOR);
	if (status != PSVC_SUCCESS) {
		return (status);
	}

	if ((unplugged) && (strcmp(state, "NO AC POWER") != 0)) {
		/* set id's state to "NO AC POWER" */
		status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
		    "NO AC POWER");
		if (status != PSVC_SUCCESS)
			return (status);
		/*
		 * Set this state so that the FSP Fault LED lights
		 * when there is no AC Power to the power supply.
		 */
		status = psvc_set_attr(hdlp, ps_logical_state, PSVC_STATE_ATTR,
		    PSVC_ERROR);
		if (status != PSVC_SUCCESS)
			return (status);

		status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR,
		    "NO AC POWER");
		if (status != PSVC_SUCCESS)
			return (status);

		syslog(LOG_ERR, gettext("Device %s AC UNAVAILABLE"), id);

		/* Set fault sensor states to "" */
		for (i = 0; i < sensor_count; ++i) {
			status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
				&sensor_id, PSVC_DEV_FAULT_SENSOR, i);
			if (status != PSVC_SUCCESS)
				return (status);

			status = psvc_set_attr(hdlp, sensor_id,
				PSVC_FAULTID_ATTR, "");
			if (status != PSVC_SUCCESS)
				return (status);
		}
	}

	/* Power cord is plugged in */
	if ((!unplugged) && (strcmp(state, "NO AC POWER") == 0)) {
		/* Default the state to "OK" */
		status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
			PSVC_OK);
		if (status != PSVC_SUCCESS)
			return (status);
		/* Default the PS_LOGICAL_STATE to "OK" */
		status = psvc_set_attr(hdlp, ps_logical_state, PSVC_STATE_ATTR,
			PSVC_OK);
		if (status != PSVC_SUCCESS)
			return (status);
		/* Display message */
		syslog(LOG_ERR, gettext("Device %s AC AVAILABLE"), id);
	}

	return (status);
}

int32_t
psvc_init_ps_presence(psvc_opaque_t hdlp, char *id)
{
	int		err;
	int		instance;
	boolean_t	presence;

	err = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance);
	err |= psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
	ps_prev_present[instance] = ps_present[instance] = presence;
	return (err);
}

int32_t
psvc_ps_monitor_policy_0(psvc_opaque_t hdlp, char *id)
{
	int		err;
	int		instance;
	static	int	failed_last_time[2] = {0, 0};
	int	retry;

	err = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance);
	if (err != PSVC_SUCCESS)
		return (err);

	/* copy current presence to previous presence */
	ps_prev_present[instance] = ps_present[instance];

	retry = 0;
	do {
		if (retry)
			(void) sleep(retry_sleep_pshp);
		/* Get new presence */
		err = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR,
		    &ps_present[instance]);
		if (err != PSVC_SUCCESS)
			goto out;
		retry++;
	} while ((retry < n_retry_pshp) &&
	    (ps_present[instance] != ps_prev_present[instance]));

	/* Sustained Hotplug detected */
	if (ps_present[instance] != ps_prev_present[instance]) {
		err = handle_ps_hotplug(hdlp, id, ps_present[instance]);
		return (err);
	}

	/* If our power supply is not present, we're done */
	if (!ps_present[instance])
		return (PSVC_SUCCESS);

	err = check_i2c_access(hdlp, id);
	if (err != PSVC_SUCCESS) {
		/* Quickie hotplug */
		if (ps_present[instance] == PSVC_PRESENT &&
		    ps_prev_present[instance] == PSVC_PRESENT) {
			syslog(LOG_ERR, "Device %s removed", id);
			/* Reset prev_failed information */
			ps_reset_prev_failed(instance);
			ps_prev_present[instance] = 0;
			handle_ps_hotplug(hdlp, id, ps_present[instance]);
			/* We ignore the error on a quickie hotplug */
			return (PSVC_SUCCESS);
		}
		/* There was an actual i2c access error */
		goto out;
	}

	err = check_ps_state(hdlp, id);
	if (err != PSVC_SUCCESS)
		goto out;

	failed_last_time[instance] = 0;
	return (err);

out:
	if (! failed_last_time[instance]) {
		/*
		 * We ignore the error condition the first time thru
		 * because the PS could have been removed after (or
		 * during) our call to check_ps_hotplug().
		 *
		 * If the problem is still there the next time, then
		 * we'll raise a flag.
		 *
		 * The instance determines which power supply the policy
		 * errored on.  For instance PS0 might have failed and then
		 * PS1 might have failed, but we'll display a warning
		 * even though there might not be anything actually wrong.
		 * The instance keeps track of which failure occurred so
		 * we warn on the corresponding occurrence of errors.
		 */
		failed_last_time[instance] = 1;
		return (PSVC_SUCCESS);
	}
	return (err);
}

static int
light_disk_fault_leds(psvc_opaque_t hdlp, char *id, boolean_t disk_presence)
{
	int		err;
	int		bit_nums[MAX_DISKS] = {6, 7};
	uint8_t		led_masks[MAX_DISKS] = {0x40, 0x80};
	int		instance;
	int		bit_value;
	char		state[PSVC_MAX_STR_LEN];
	uint8_t		byte;

	if (disk_presence != PSVC_PRESENT)
		return (PSVC_SUCCESS);

	err = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance);
	if (err != PSVC_SUCCESS)
		return (err);

	err = psvc_get_attr(hdlp, "DISK_PORT", PSVC_GPIO_VALUE_ATTR,
		&byte);
	if (err != PSVC_SUCCESS)
		return (err);

	err = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
	if (err != PSVC_SUCCESS)
		return (err);
	if (strcmp(state, PSVC_OK) == 0 || strcmp(state, "") == 0) { /* OK */
		if (byte & led_masks[instance]) { /* Led is OFF */
			return (err); /* Done. */
		} else { /* Led is ON, Turn if OFF */
			bit_value = 1;	/* Active Low */
			err = pcf8574_write_bit(hdlp, "DISK_PORT",
				bit_nums[instance], bit_value,
				DISKBP_MUST_BE_1);
			if (err != PSVC_SUCCESS)
				return (err);
		}
	} else { /* Disk is NOT OK */
		if (byte & led_masks[instance]) { /* Led is OFF, Turn it ON */
			bit_value = 0;	/* Active Low */
			err = pcf8574_write_bit(hdlp, "DISK_PORT",
				bit_nums[instance], bit_value,
				DISKBP_MUST_BE_1);
			if (err != PSVC_SUCCESS)
				return (err);
		} else {
			return (err); /* Done. */
		}
	}
	return (err);
}

int
verify_disk_wwn(char *wwn)
{
	HBA_PORTATTRIBUTES	hbaPortAttrs, discPortAttrs;
	HBA_HANDLE	handle;
	HBA_STATUS	status;
	HBA_ADAPTERATTRIBUTES	hbaAttrs;
	HBA_UINT32	numberOfAdapters, hbaCount, hbaPort, discPort;
	char	adaptername[256];
	char	vwwn[WWN_SIZE * 2];
	char	OSDeviceName[PATH_MAX + 1];
	int	count, linksize;

	/* Load common lib */
	status = HBA_LoadLibrary();
	if (status != HBA_STATUS_OK) {
		(void) HBA_FreeLibrary();
		return (HBA_STATUS_ERROR);
	}

	/*
	 * Since devfs can store multiple instances
	 * of a target the validity of the WWN of a disk is
	 * verified with an actual probe of internal disks
	 */

	/* Cycle through FC-AL Adapters and search for WWN */
	numberOfAdapters = HBA_GetNumberOfAdapters();
	for (hbaCount = 0; hbaCount < numberOfAdapters; hbaCount++) {
		if ((status = HBA_GetAdapterName(hbaCount, adaptername)) !=
		    HBA_STATUS_OK)
			continue;

		handle = HBA_OpenAdapter(adaptername);
		if (handle == 0)
			continue;

		/* Get Adapter Attributes */
		if ((status = HBA_GetAdapterAttributes(handle,
		    &hbaAttrs)) != HBA_STATUS_OK) {
			HBA_CloseAdapter(handle);
			continue;
		}

		/* Get Adapter's Port Attributes */
		for (hbaPort = 0;
		    hbaPort < hbaAttrs.NumberOfPorts; hbaPort++) {
			if ((status = HBA_GetAdapterPortAttributes(handle,
			    hbaPort, &hbaPortAttrs)) != HBA_STATUS_OK)
				continue;

			/*
			 * Verify whether this is onboard controller.
			 * HBAAPI provides path of symbol link to
			 * to the qlc node therefore readlink() is
			 * needed to obtain hard link
			 */
			linksize = readlink(hbaPortAttrs.OSDeviceName,
			    OSDeviceName, PATH_MAX);

			/*
			 * If readlink does not return size of onboard
			 * controller than don't bother checking device
			 */
			if ((linksize + 1) != sizeof (ONBOARD_CONTR))
				continue;

			OSDeviceName[linksize] = '\0';
			if (strcmp(OSDeviceName, ONBOARD_CONTR) != 0)
				continue;

			/* Get Discovered Port Attributes */
			for (discPort = 0;
			    discPort < hbaPortAttrs.NumberofDiscoveredPorts;
			    discPort++) {
				status = HBA_GetDiscoveredPortAttributes(
					handle, hbaPort, discPort,
						&discPortAttrs);
				if (status != HBA_STATUS_OK)
					continue;

				/* Get target info */
				for (count = 0; count < WWN_SIZE; count++)
					(void) sprintf(&vwwn[count * 2],
					    "%2.2x",
					    discPortAttrs.NodeWWN.wwn[count]);

				if (strcmp(wwn, vwwn) == 0) {
					HBA_CloseAdapter(handle);
					(void) HBA_FreeLibrary();
					return (HBA_STATUS_OK);
				}

			}
		}
		HBA_CloseAdapter(handle);
	}
	(void) HBA_FreeLibrary();
	return (HBA_STATUS_ERROR_ILLEGAL_WWN);
}

static int
light_disk_ok2remove_leds(psvc_opaque_t hdlp, boolean_t *disk_present)
{
	di_node_t	node;
	di_node_t	root_node;
	di_minor_t	min_node;
	int		*prop;
	int		n;
	int		target;
	int		rv;
	int		disk_online = 0;
	static int	prev_online[MAX_DISKS] = {-1, -1};
	int		bit_nums[MAX_DISKS] = {4, 5};
	int		bit_val;
	int		count;
	char		*dev_path;
	char		wwn[WWN_SIZE * 2];
	uchar_t		*prop_wwn;

	root_node = di_init("/", DINFOCPYALL);
	if (root_node == DI_NODE_NIL)
		return (PSVC_FAILURE);

	for (node = di_drv_first_node(DISK_DRV, root_node);
		node != DI_NODE_NIL;
		node = di_drv_next_node(node)) {
		n = di_prop_lookup_ints(DDI_DEV_T_ANY, node, "target", &prop);
		if (n == -1)
			continue;
		target = *prop;
		if (target < 0 || target > 1)
			continue;

		if (! disk_present[target])
			continue;

		dev_path = di_devfs_path(node);
		if (memcmp(dev_path, QLC_NODE, (sizeof (QLC_NODE) - 1)) != 0) {
			/*
			 * This isn't our FC-AL controller, so this
			 * must be an external disk on Loop B.  Skip it.
			 */
			di_devfs_path_free(dev_path);
			continue;
		}
		di_devfs_path_free(dev_path);

		/*
		 * Verify if disk is valid by checking WWN
		 * because devfs retains stale data.
		 */
		n = di_prop_lookup_bytes(DDI_DEV_T_ANY, node,
		    "node-wwn", &prop_wwn);
		if (n == -1)
			continue;

		for (count = 0; count < WWN_SIZE; count++)
			(void) sprintf(&wwn[count * 2], "%2.2x",
			    prop_wwn[count]);

		n = verify_disk_wwn(wwn);
		if (n == HBA_STATUS_ERROR_ILLEGAL_WWN)
			continue;

		min_node = di_minor_next(node, DI_MINOR_NIL);
		disk_online = (min_node != DI_MINOR_NIL);
		if (! disk_online && prev_online[target]) {
			/* Light Led */
			bit_val = 0;
			rv = pcf8574_write_bit(hdlp, "DISK_PORT",
				bit_nums[target], bit_val, DISKBP_MUST_BE_1);
			if (rv != PSVC_SUCCESS)
				goto done;
		} else if (!prev_online[target] && disk_online) {
			/* Unlight Led */
			bit_val = 1;
			rv = pcf8574_write_bit(hdlp, "DISK_PORT",
				bit_nums[target], bit_val, DISKBP_MUST_BE_1);
			if (rv != PSVC_SUCCESS)
				goto done;
		}
		if (disk_online != prev_online[target])
			prev_online[target] = disk_online;
	}
done:
	di_fini(root_node);
	return (rv);
}

static int
check_disk_fault(psvc_opaque_t hdlp, char *id, boolean_t disk_presence)
{
	int32_t		status = PSVC_SUCCESS;
	int32_t		fault_on = 0;
	char		*sensor_id;
	char		disk_state[PSVC_MAX_STR_LEN];
	char		state[PSVC_MAX_STR_LEN];
	char		fault[PSVC_MAX_STR_LEN];
	boolean_t	change_of_state = 0;

	if (disk_presence != PSVC_PRESENT)
		return (PSVC_SUCCESS);

	status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, disk_state);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
		&sensor_id, PSVC_DEV_FAULT_SENSOR, 0);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, sensor_id, PSVC_SWITCH_STATE_ATTR, state);
	if (status != PSVC_SUCCESS)
		return (status);

	/* Fault detected */
	if (strcmp(state, PSVC_SWITCH_ON) == 0) {
		strlcpy(state, PSVC_ERROR, sizeof (state));
		strlcpy(fault, PSVC_GEN_FAULT, sizeof (fault));
		fault_on = 1;
	} else { /* No fault detected */
		if (strcmp(disk_state, PSVC_OK) != 0)
			change_of_state = 1;
		strlcpy(state, PSVC_OK, sizeof (state));
		strlcpy(fault, PSVC_NO_FAULT, sizeof (fault));
	}

	status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, fault);
	if (status != PSVC_SUCCESS)
		return (status);

	if (fault_on) {
		syslog(LOG_ERR, gettext("Fault detected: %s"), id);

	} else {
		if (change_of_state)
			syslog(LOG_ERR, gettext("Notice: %s okay"), id);
	}
	return (PSVC_SUCCESS);
}

static int
check_disk_hotplug(psvc_opaque_t hdlp, char *id, boolean_t *disk_presence,
	int disk_instance)
{
	boolean_t	presence;
	boolean_t	previous_presence;
	int32_t		status = PSVC_SUCCESS;
	char		label[PSVC_MAX_STR_LEN];
	uint8_t		disk_leds[MAX_DISKS][2] = {{4, 6}, {5, 7}};
	int	retry;

	status = psvc_get_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR,
		&previous_presence);
	if (status != PSVC_SUCCESS)
		return (status);

	retry = 0;
	do {
		if (retry)
			(void) sleep(retry_sleep_diskhp);
		status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR,
		    &presence);
		if (status != PSVC_SUCCESS)
			return (status);
		retry++;
	} while ((retry < n_retry_diskhp) &&
	    (presence != previous_presence));

	*disk_presence = presence;

	if (presence != previous_presence) {
		char		parent_path[PICL_PROPNAMELEN_MAX];
		picl_nodehdl_t	child_node;

		status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label);
		if (status != PSVC_SUCCESS)
			return (status);

		/* return parent path and node for an object */
		psvcplugin_lookup(id, parent_path, &child_node);

		if (presence == PSVC_PRESENT) {
			picl_nodehdl_t	parent_node;
			char		state[PSVC_MAX_STR_LEN];
			char		fault[PSVC_MAX_STR_LEN];

			syslog(LOG_ERR, gettext("Device %s inserted"), label);
			strlcpy(state, PSVC_OK, sizeof (state));
			status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
				state);
			if (status != PSVC_SUCCESS)
				return (status);

			strlcpy(fault, PSVC_NO_FAULT, sizeof (fault));
			status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR,
				fault);
			if (status != PSVC_SUCCESS) {
				return (status);
			}

			status = ptree_get_node_by_path(parent_path,
				&parent_node);
			if (status != PICL_SUCCESS)
				return (PSVC_FAILURE);
			status = ptree_add_node(parent_node, child_node);
			if (status != PICL_SUCCESS)
				return (PSVC_FAILURE);
		} else {
			/*
			 * Disk Removed so we need to turn off these LEDs:
			 * DISKx_FLT_LED
			 * DISKx_REMOVE_LED
			 */
			int i;
			int bit_val = 1;  /* Active Low */
			for (i = 0; i < 2; i++) {
				status = pcf8574_write_bit(hdlp, "DISK_PORT",
					disk_leds[disk_instance][i], bit_val,
					DISKBP_MUST_BE_1);
				if (status != PSVC_SUCCESS)
					syslog(LOG_ERR, "Failed in turning off"
						" %d's LEDs", id);
			}
			syslog(LOG_ERR, gettext("Device %s removed"), label);
			ptree_delete_node(child_node);
		}
	}

	status = psvc_set_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR, &presence);
	if (status != PSVC_SUCCESS)
		return (status);

	return (status);
}

int32_t
psvc_disk_monitor_policy_0(psvc_opaque_t hdlp, char *id)
{
	int		rv, err, i;
	char		*disks[MAX_DISKS] = {"DISK0", "DISK1"};
	int		saved_errno = 0;
	boolean_t	disk_present[MAX_DISKS] = {0, 0};

	for (i = 0; i < MAX_DISKS; i++) {
		err = check_disk_hotplug(hdlp, disks[i], &disk_present[i], i);
		if (err) saved_errno = errno;
		rv = err;

		err = check_disk_fault(hdlp, disks[i], disk_present[i]);
		if (err) saved_errno = errno;
		rv |= err;

		err |= light_disk_fault_leds(hdlp, disks[i], disk_present[i]);
		if (err) saved_errno = errno;
		rv |= err;
	}

	err = light_disk_ok2remove_leds(hdlp, disk_present);
	if (err) saved_errno = errno;
	rv |= err;

	errno = saved_errno;
	return (rv);
}

/*
 * Read in temperature thresholds from FRU Prom and update the
 * default values.
 */

#define	START_OFFSET		0x1800	/* Last 2K of SEEPROM */
#define	NUM_SEG_OFFSET		0x1805	/* Number of segments */
#define	SEG_TABLE_OFFSET	0x1806	/* Segment description tables */

static int32_t
read_sc_segment(psvc_opaque_t hdlp, char *id, char *fru_id, int offset)
{
	static int thresh_names[] = {
		PSVC_HW_LO_SHUT_ATTR,
		PSVC_LO_SHUT_ATTR,
		PSVC_LO_WARN_ATTR,
		PSVC_NOT_USED,			/* LOW MODE  */
		PSVC_OPTIMAL_TEMP_ATTR,
		PSVC_HI_WARN_ATTR,
		PSVC_HI_SHUT_ATTR,
		PSVC_HW_HI_SHUT_ATTR
	};
	int8_t		amb_temp_array[8];
	int		i;
	fru_info_t	fru_info;
	int		err;

	fru_info.buf_start = offset + 8;
	fru_info.buf = amb_temp_array;
	fru_info.read_size = 8;

	err = psvc_get_attr(hdlp, fru_id, PSVC_FRU_INFO_ATTR, &fru_info);
	if (err != PSVC_SUCCESS)
		return (err);

	for (i = 0; i < 8; i++) {
		int32_t temp = amb_temp_array[i];
		if (thresh_names[i] == PSVC_NOT_USED)
			continue;
		err = psvc_set_attr(hdlp, id, thresh_names[i], &temp);
		if (err != PSVC_SUCCESS)
			return (err);
	}
	return (PSVC_SUCCESS);
}

int32_t
update_disk_bp_temp_thresholds(psvc_opaque_t hdlp, char *id)
{

	char		*fru;
	fru_info_t	fru_info;
	int16_t		seg_offset;
	int8_t		byte;
	int8_t		seg_count;
	char		seg_name[2];
	int		current_offset, i, err;

	err = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, &fru, PSVC_FRU, 0);
	if (err != PSVC_SUCCESS)
		return (err);

	/* Sanity Check */
	fru_info.buf_start = START_OFFSET;
	fru_info.buf = &byte;
	fru_info.read_size = 1;

	err = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR, &fru_info);
	if (err != PSVC_SUCCESS)
		return (err);
	if (*fru_info.buf != 8) {
		syslog(LOG_ERR, "Notice: FRU Prom %s not programmed", fru);
	}
	/* Should do CRC Check on fru */

	/* Get Segment Count */
	fru_info.buf_start = NUM_SEG_OFFSET;
	fru_info.buf = &seg_count;
	fru_info.read_size = 1;

	err = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR, &fru_info);
	if (err != PSVC_SUCCESS)
		return (err);

	current_offset = SEG_TABLE_OFFSET;
	for (i = 0; i < seg_count; i++) {
		fru_info.buf_start = current_offset;
		fru_info.buf = seg_name;
		fru_info.read_size = 2;
		err = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR, &fru_info);
		if (err != PSVC_SUCCESS)
			return (err);

		if (memcmp(seg_name, "SC", 2) == 0) {
			current_offset += 6;	/* Skip over description */
			fru_info.buf_start = current_offset;
			fru_info.buf = (char *)&seg_offset;
			fru_info.read_size = 2;
			psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
				&fru_info);
			return (read_sc_segment(hdlp, id, fru, seg_offset));
		}
		current_offset += 10;
	}

	return (PSVC_SUCCESS);
}