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

/*
 * Daktari platform platform specific environment monitoring policies
 */
#include        <poll.h>
#include        <syslog.h>
#include        <unistd.h>
#include        <stdio.h>
#include        <stdlib.h>
#include        <errno.h>
#include        <fcntl.h>
#include        <strings.h>
#include        <libintl.h>
#include        <sys/types.h>
#include        <sys/param.h>
#include        <config_admin.h>
#include        <libdevice.h>
#include        <picl.h>
#include        <picltree.h>
#include        <psvc_objects.h>
#include        <sys/i2c/clients/i2c_client.h>
#include        <sys/daktari.h>
#include        <sys/hpc3130_events.h>
#include        <assert.h>
#include        <limits.h>
#include        <sys/systeminfo.h>

/*LINTLIBRARY*/

/* resides in libcfgadm */
extern cfga_err_t config_change_state(cfga_cmd_t, int, char *const *,
        const char *, struct cfga_confirm *, struct cfga_msg *, char **,
        cfga_flags_t);
/* Local Routine */
static int32_t update_gen_fault_led(psvc_opaque_t, char *);
static void shutdown_routine(void);
static int32_t update_thresholds(psvc_opaque_t hdlp, char *id, int offset);


#ifdef DEBUG

static int dak_policy_debug = 0;

#define D1SYS_ERR(ARGS) if (dak_policy_debug & 0x1) syslog ARGS;
#define D2SYS_ERR(ARGS) if (dak_policy_debug & 0x2) syslog ARGS;

#else

#define D1SYS_ERR(ARGS)
#define D2SYS_ERR(ARGS)

#endif

#define I2C_PATH        "/devices/pci@9,700000/ebus@1/i2c@1,30"
#define I2C_NODE        I2C_PATH ":devctl"
#define PCF8574         I2C_PATH "/ioexp@0,%x:pcf8574"
#define PCF8591         I2C_PATH "/adio@0,%x:port_0"
#define FRU             I2C_PATH "/fru@0,%x:fru"
#define HPC3130_DEV     I2C_PATH "/hotplug-controller@0,%2x:port_%1x"
#define GEN_FAULT_LED   "FSP_GEN_FAULT_LED"
#define EMPTY_STRING    "EMPTY"
#define DEVICE_FAILURE_MSG      gettext("WARNING: Device %s failure detected")
#define DEVICE_INSERTED_MSG     gettext("Device %s inserted")
#define DEVICE_REMOVED_MSG      gettext("Device %s removed")
#define PS_UNPLUGGED_MSG        gettext("Device %s unplugged")
#define PS_PLUGGED_MSG          gettext("Device %s Plugged in")
#define DEVICE_OK_MSG           gettext("Device %s OK")
#define SET_LED_FAILED_MSG              \
        gettext("Failed to set LED state, id = %s, errno = %d\n")
#define GET_PRESENCE_FAILED_MSG         \
        gettext("Failed to get presence attribute, id = %s, errno = %d\n")
#define GET_SENSOR_FAILED_MSG           \
        gettext("Failed to get sensor value, id = %s, errno = %d\n")
#define ADD_PS_MSG                      \
    gettext("WARNING: Only 1 Power Supply in system. ADD a 2nd Power Supply.\n")
#define REMOVE_LOAD_MSG                 \
        gettext("WARNING: Power Supply at 95%% current. Remove some load.\n")
#define PS_OVER_CURRENT_MSG             \
        gettext("WARNING: Power Supply overcurrent detected\n")
#define PS_UNDER_CURRENT_MSG            \
        gettext("WARNING: PS%d Undercurrent on one or more DC lines\n")
#define DEVICE_UNKNOWN_MSG      gettext("Unknown device %s instance %d\n")
#define DEVICE_HANDLE_FAIL_MSG          \
        gettext("Failed to get device handle for %s, errno = %d\n")
#define DEVTREE_NODE_CREATE_FAILED      \
        gettext("psvc PICL plugin: Failed to create node for %s, errno = %d")
#define DEVTREE_NODE_DELETE_FAILED      \
        gettext("psvc PICL plugin: Failed to delete node for %s, errno = %d")
#define DISK_FAULT_MSG          gettext("%s: Error Reported\n")
#define DISK_OK_MSG             gettext("%s: Error Cleared\n")
#define SET_FANSPEED_FAILED_MSG         \
        gettext("Failed to set fan speed, id = %s, errno = %d\n")
#define GET_ATTR_FRU_FAILED_MSG gettext("Failed psvc_get_attr for FRU info\n")
#define NO_FRU_INFO_MSG                 \
        gettext("No FRU Information for %s using default module card\n")

#define DAKTARI_MAX_PS  3
#define DAK_MAX_PS_I_SENSORS 4
#define DAK_MAX_DISKS   12
#define DAK_MAX_CPU_MOD 4
#define DAK_MAX_FAULT_SENSORS 3
#define DAK_MAX_FANS 10

static int co_ps = 0;
static char *shutdown_string = "shutdown -y -g 60 -i 5 \"OVERTEMP condition\"";

typedef struct i2c_hp {
        int32_t         addr[2];
        char            name[256];
        char            compatible[256];
} i2c_hp_t;

typedef struct seg_desc {
        int32_t segdesc;
        int16_t segoffset;
        int16_t seglength;
} seg_desc_t;

static int32_t threshold_names[] = {
        PSVC_HW_LO_SHUT_ATTR,
        PSVC_LO_SHUT_ATTR,
        PSVC_LO_WARN_ATTR,
        PSVC_NOT_USED,                  /* LOW MODE which is not used */
        PSVC_OPTIMAL_TEMP_ATTR,
        PSVC_HI_WARN_ATTR,
        PSVC_HI_SHUT_ATTR,
        PSVC_HW_HI_SHUT_ATTR
};

/*
 * 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_pshp_status = PSVC_NUM_OF_RETRIES;
static int retry_sleep_pshp_status = 1;
static int n_read_overcurrent = PSVC_THRESHOLD_COUNTER;
static int n_read_undercurrent = PSVC_THRESHOLD_COUNTER;
static int n_retry_devicefail = PSVC_NUM_OF_RETRIES;
static int retry_sleep_devicefail = 1;
static int n_read_fanfault = PSVC_THRESHOLD_COUNTER;
static int n_retry_pshp = PSVC_NUM_OF_RETRIES;
static int retry_sleep_pshp = 1;
static int n_retry_diskfault = PSVC_NUM_OF_RETRIES;
static int retry_sleep_diskfault = 1;
static int n_retry_temp_shutdown = PSVC_NUM_OF_RETRIES;
static int retry_sleep_temp_shutdown = 1;

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

static i2c_noise_param_t i2cparams[] = {
        &n_retry_pshp_status, "n_retry_pshp_status",
        &retry_sleep_pshp_status, "retry_sleep_pshp_status",
        &n_read_overcurrent, "n_read_overcurrent",
        &n_read_undercurrent, "n_read_undercurrent",
        &n_retry_devicefail, "n_retry_devicefail",
        &retry_sleep_devicefail, "retry_sleep_devicefail",
        &n_read_fanfault, "n_read_fanfault",
        &n_retry_pshp, "n_retry_pshp",
        &retry_sleep_pshp, "retry_sleep_pshp",
        &n_retry_diskfault, "n_retry_diskfault",
        &retry_sleep_diskfault, "retry_sleep_diskfault",
        &n_retry_temp_shutdown, "n_retry_temp_shutdown",
        &retry_sleep_temp_shutdown, "retry_sleep_temp_shutdown",
        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));
}

int32_t
psvc_MB_update_thresholds_0(psvc_opaque_t hdlp, char *id, int offset)
{
        int IO_offset = 0xd;
        int32_t err;

        err = update_thresholds(hdlp, id, IO_offset);

        return (err);
}

int32_t
psvc_IO_update_thresholds_0(psvc_opaque_t hdlp, char *id, int offset)
{
        int IO_offset = 0x8;
        int32_t err;

        err = update_thresholds(hdlp, id, IO_offset);

        return (err);
}

int32_t
psvc_DBP_update_thresholds_0(psvc_opaque_t hdlp, char *id, int offset)
{
        int IO_offset = 0x7;
        int32_t err;

        err = update_thresholds(hdlp, id, IO_offset);

        return (err);
}

/*
 * used to determine if a change of state occured. valid when states
 * are strings.
 */
static int8_t
change_of_state_str(char *state1, char *check1, char *state2, char *check2)
{
        int change = 0;

        if ((strcmp(state1, check1) == 0) && (strcmp(state2, check2) != 0))
                change = 1;
        if ((strcmp(state1, check1) != 0) && (strcmp(state2, check2) == 0))
                change = 1;

        return (change);
}

/*
 * Update thresholds tries to read the temperature thresholds from the FRU
 * SEEproms and then updates the thresholds in the object by overriding the
 * hardcoded thresholds.  For Daktari it is an Error if the FRU does not
 * contain the segment that had the temperature thresholds.
 */
static int32_t
update_thresholds(psvc_opaque_t hdlp, char *id, int offset)
{
        int32_t status = PSVC_SUCCESS;
        fru_info_t fru_data;
        char *fru, seg_name[2];
        int8_t seg_count, temp_array[8];
        int32_t match_count, i, j, seg_desc_start = 0x1806, temp_address;
        int32_t seg_found, temp;
        boolean_t present;
        seg_desc_t segment;

        status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
        if ((status != PSVC_SUCCESS) || (present != PSVC_PRESENT))
                return (status);

        status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &match_count,
            PSVC_FRU);
        if (status == PSVC_FAILURE)
                return (status);

        for (i = 0; i < match_count; i++) {
                seg_found = 0;
                status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                    &fru, PSVC_FRU, i);
                if (status != PSVC_SUCCESS)
                        return (status);

                fru_data.buf_start = 0x1805;
                fru_data.buf = (char *)&seg_count;
                fru_data.read_size = 1;

                status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
                    &fru_data);
                if (status != PSVC_SUCCESS) {
                        return (status);
                }
                for (j = 0; (j < seg_count) && (!seg_found); j++) {
                        fru_data.buf_start = seg_desc_start;
                        fru_data.buf = seg_name;
                        fru_data.read_size = 2;

                        status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
                            &fru_data);

                        seg_desc_start = seg_desc_start + 2;
                        fru_data.buf_start = seg_desc_start;
                        fru_data.buf = (char *)&segment;
                        fru_data.read_size = sizeof (seg_desc_t);

                        status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
                            &fru_data);
                        if (status != PSVC_SUCCESS) {
                                syslog(LOG_ERR,
                                    "Failed psvc_get_attr for FRU info\n");
                                return (status);
                        }
                        seg_desc_start = seg_desc_start + sizeof (seg_desc_t);
                        if (memcmp(seg_name, "SC", 2) == 0)
                                seg_found = 1;
                }
                if (seg_found) {
                        temp_address = segment.segoffset + offset;
                        fru_data.buf_start = temp_address;
                        fru_data.buf = (char *)&temp_array;
                        fru_data.read_size = sizeof (temp_array);
                        status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
                            &fru_data);
                        if (status != PSVC_SUCCESS) {
                                syslog(LOG_ERR,
                                    "Failed psvc_get_attr for FRU info\n");
                                return (status);
                        } else {
                                for (j = 0; j < sizeof (temp_array); j++) {
                                        if (threshold_names[j] ==
                                            PSVC_NOT_USED)
                                                continue;
                                        temp = temp_array[j];
                                        status = psvc_set_attr(hdlp, id,
                                            threshold_names[j], &temp);
                                        if (status != PSVC_SUCCESS) {
                                                return (status);
                                        }
                                }
                        }
                } else {
                        syslog(LOG_ERR, "No FRU Information for %s"
                            " using default temperatures\n", id);
                }
        }
        return (status);
}

int32_t
psvc_fan_init_speed_0(psvc_opaque_t hdlp, char *id)
{
        int32_t status = PSVC_SUCCESS;
        boolean_t present;
        char *control_id;
        int32_t init_speed = 0;

        status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
        if ((status != PSVC_SUCCESS) || (present != PSVC_PRESENT))
                return (status);

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

        status = psvc_set_attr(hdlp, control_id, PSVC_CONTROL_VALUE_ATTR,
            &init_speed);
        if (status == PSVC_FAILURE) {
                syslog(LOG_ERR, SET_FANSPEED_FAILED_MSG, control_id, errno);
                return (status);
        }

        return (status);
}

int32_t
psvc_update_setpoint_0(psvc_opaque_t hdlp, char *id)
{
        int32_t status = PSVC_SUCCESS;
        char *temp_sensor;
        int32_t match_count, i, temp;
        int16_t lowest_temp = 500;
        boolean_t present;

        status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
        if ((status != PSVC_SUCCESS) || (present != PSVC_PRESENT))
                return (status);

        status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &match_count,
            PSVC_DEV_TEMP_SENSOR);
        if (status == PSVC_FAILURE)
                return (status);

        for (i = 0; i < match_count; i++) {
                status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                    &temp_sensor, PSVC_DEV_TEMP_SENSOR, i);
                if (status != PSVC_SUCCESS)
                        return (status);
                status = psvc_get_attr(hdlp, temp_sensor,
                    PSVC_OPTIMAL_TEMP_ATTR, &temp);
                if (status != PSVC_SUCCESS) {
                        syslog(LOG_ERR, "Failed to get Optimal temp for %s\n",
                            temp_sensor);
                        return (status);
                }
                if (temp < lowest_temp)
                        lowest_temp = temp;
        }
        status = psvc_set_attr(hdlp, id, PSVC_SETPOINT_ATTR, &lowest_temp);
        if (status == PSVC_FAILURE) {
                syslog(LOG_ERR, "Failed to change setpoint for %s\n", id);
                return (status);
        }
        return (status);
}

int32_t
psvc_remove_missing_nodes_0(psvc_opaque_t hdlp, char *id)
{
        int32_t status = PSVC_SUCCESS;
        char state[32];
        char *physical_dev;
        int32_t i, device_count;
        char parent_path[256];
        picl_nodehdl_t child_node;
        boolean_t present;

        status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR,
            &device_count, PSVC_PHYSICAL_DEVICE);
        if (status == PSVC_FAILURE)
                return (status);

        for (i = 0; i < device_count; i++) {
                status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                    &physical_dev, PSVC_PHYSICAL_DEVICE, i);
                if (status != PSVC_SUCCESS)
                        return (status);
                if (strncmp(physical_dev, "LTC1427", 7) == 0)
                        continue;
                status = psvc_get_attr(hdlp, physical_dev,
                    PSVC_PROBE_RESULT_ATTR, state);
                if (status != PSVC_SUCCESS)
                        continue;
                status = psvc_get_attr(hdlp, physical_dev, PSVC_PRESENCE_ATTR,
                    &present);
                if (status == PSVC_FAILURE) {
                        syslog(LOG_ERR, GET_PRESENCE_FAILED_MSG, physical_dev,
                            errno);
                        return (status);
                }

                if ((strcmp(state, PSVC_ERROR) == 0) &&
                    (present == PSVC_PRESENT)) {
                        /* convert name to node, and parent path */
                        psvcplugin_lookup(physical_dev, parent_path,
                            &child_node);
                        /* Device removed */
                        ptree_delete_node(child_node);
                }
        }
        return (status);
}

int32_t
psvc_check_ps_hotplug_status_0(psvc_opaque_t hdlp, char *id)
{
        char            fail_valid_switch_id[PICL_PROPNAMELEN_MAX];
        int32_t         status = PSVC_SUCCESS;
        char            valid_switch_state[32];
        char            state[32], fault[32];
        int32_t         led_count, j;
        char            *led_id;
        char            led_state[32];
        boolean_t       present;
        static int8_t   hotplug_failed_count = 0;
        static int      unplugged_ps = 0;
        int     retry;
        char            *unplugged_id;

        status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
        if (status == PSVC_FAILURE) {
                syslog(LOG_ERR, GET_PRESENCE_FAILED_MSG, id, errno);
                return (status);
        }

        if (present == PSVC_ABSENT) {
                errno = ENODEV;
                return (PSVC_FAILURE);
        }

        snprintf(fail_valid_switch_id, sizeof (fail_valid_switch_id), "%s%s",
            id, "_SENSOR_VALID_SWITCH");

        retry = 0;
        do {
                if (retry)
                        (void) sleep(retry_sleep_pshp_status);
                status = psvc_get_attr(hdlp, fail_valid_switch_id,
                    PSVC_STATE_ATTR, valid_switch_state);
                if (status == PSVC_FAILURE) {
                        if (hotplug_failed_count == 0) {
                                /*
                                 * First time the get_attr call failed
                                 * set count so that if we fail again
                                 * we will know
                                 */
                                hotplug_failed_count = 1;
                                /*
                                 * We probably failed because the power
                                 * supply was just insterted or removed
                                 * before the get_attr call. We then
                                 * return from this policy successfully
                                 * knowing it will be run again shortly
                                 * with the right PS state.
                                 */
                                return (PSVC_SUCCESS);
                        } else {
                                /*
                                 * We have failed before and so this
                                 * we will consider a hardware problem
                                 * and it should be reported
                                 */
                                syslog(LOG_ERR,
                                    "Failed getting %s State: ",
                                    "ps_hotplug_status_0\n",
                                    fail_valid_switch_id);
                                return (status);
                        }
                }
                /*
                 * Because we have successfully gotten a value from
                 * the i2c device on the PS we will set the
                 * failed_count to 0
                 */
                hotplug_failed_count = 0;

                status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
                if (status == PSVC_FAILURE)
                        return (status);
                retry++;
                /*
                 * check to see if we need to retry. the conditions are:
                 *
                 * valid_switch_state   state                   retry
                 * --------------------------------------------------
                 *      PSVC_OFF        !PSVC_HOTPLUGGED        yes
                 *      PSVC_ON         PSVC_HOTPLUGGED         yes
                 *      PSVC_OFF        PSVC_HOTPLUGGED         no
                 *      PSVC_ON         !PSVC_HOTPLUGGED        no
                 */
        } while ((retry < n_retry_pshp_status) &&
            change_of_state_str(valid_switch_state, PSVC_OFF,
            state, PSVC_HOTPLUGGED));

        if ((strcmp(valid_switch_state, PSVC_OFF) == 0) &&
            (strcmp(state, PSVC_HOTPLUGGED) != 0)) {
                strcpy(state, PSVC_HOTPLUGGED);
                strcpy(fault, PSVC_NO_FAULT);
                strcpy(led_state, PSVC_LED_OFF);
                status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
                    state);
                if (status == PSVC_FAILURE)
                        return (status);
                status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR,
                    &led_count, PSVC_DEV_FAULT_LED);
                if (status == PSVC_FAILURE)
                        return (status);

                for (j = 0; j < led_count; j++) {

                        status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                            &led_id, PSVC_DEV_FAULT_LED, j);
                        if (status != PSVC_SUCCESS)
                                return (status);

                        status = psvc_set_attr(hdlp, led_id,
                            PSVC_LED_STATE_ATTR, led_state);
                        if (status != PSVC_SUCCESS) {
                                syslog(LOG_ERR, SET_LED_FAILED_MSG, led_id,
                                    errno);
                                return (status);
                        }

                }
                strcpy(led_state, PSVC_LED_ON);
                status = psvc_set_attr(hdlp, "FSP_POWER_FAULT_LED",
                    PSVC_LED_STATE_ATTR, led_state);
                if (status != PSVC_SUCCESS) {
                        syslog(LOG_ERR, SET_LED_FAILED_MSG, led_id, errno);
                        return (status);
                }
                unplugged_id = id + 2;
                unplugged_ps = unplugged_ps | (1 << (int)strtol(unplugged_id,
                    (char **)NULL, 10));
                status = update_gen_fault_led(hdlp, GEN_FAULT_LED);
                syslog(LOG_ERR, PS_UNPLUGGED_MSG, id);
                return (status);
        }

        if ((strcmp(valid_switch_state, PSVC_ON) == 0) &&
            (strcmp(state, PSVC_HOTPLUGGED) == 0)) {
                strcpy(state, PSVC_OK);
                strcpy(fault, PSVC_NO_FAULT);
                status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state);
                if (status == PSVC_FAILURE)
                        return (status);
                unplugged_id = id + 2;
                unplugged_ps = unplugged_ps ^ (1 << (int)strtol(unplugged_id,
                    (char **)NULL, 10));
                if (unplugged_ps == 0) {
                        strcpy(led_state, PSVC_LED_OFF);
                        status = psvc_set_attr(hdlp, "FSP_POWER_FAULT_LED",
                            PSVC_LED_STATE_ATTR, led_state);
                        if (status != PSVC_SUCCESS) {
                                syslog(LOG_ERR, SET_LED_FAILED_MSG, led_id,
                                    errno);
                                return (status);
                        }
                        status = update_gen_fault_led(hdlp, GEN_FAULT_LED);
                }
                syslog(LOG_ERR, PS_PLUGGED_MSG, id);
        }

        return (status);
}

int32_t
psvc_ps_overcurrent_check_policy_0(psvc_opaque_t hdlp, char *system)
{
        int32_t status = PSVC_SUCCESS;
        boolean_t present;
        static char *sensor_id[DAKTARI_MAX_PS][DAK_MAX_PS_I_SENSORS];
        static char *power_supply_id[DAKTARI_MAX_PS] = {NULL};
        int32_t i, j;
        int32_t amps, oc_flag = 0, ps_present = 0;
        static int32_t hi_warn[DAKTARI_MAX_PS][DAK_MAX_PS_I_SENSORS];
        char state[32];
        static int8_t overcurrent_failed_check = 0;
        static int threshold_counter = 0;

        if (power_supply_id[0] == NULL) {
                for (i = 0; i < DAKTARI_MAX_PS; i++) {
                        status = psvc_get_attr(hdlp, system,
                            PSVC_ASSOC_ID_ATTR, &(power_supply_id[i]),
                            PSVC_PS, i);
                        if (status != PSVC_SUCCESS)
                                return (status);
                        for (j = 0; j < DAK_MAX_PS_I_SENSORS; ++j) {
                                status = psvc_get_attr(hdlp,
                                    power_supply_id[i], PSVC_ASSOC_ID_ATTR,
                                    &(sensor_id[i][j]), PSVC_PS_I_SENSOR, j);
                                if (status != PSVC_SUCCESS)
                                        return (status);
                                status = psvc_get_attr(hdlp, sensor_id[i][j],
                                    PSVC_HI_WARN_ATTR, &(hi_warn[i][j]));
                                if (status != PSVC_SUCCESS)
                                        return (status);
                        }
                }
        }

        for (i = 0; i < DAKTARI_MAX_PS; i++) {
                status = psvc_get_attr(hdlp, power_supply_id[i],
                    PSVC_PRESENCE_ATTR, &present);
                if (status == PSVC_FAILURE) {
                        syslog(LOG_ERR, GET_PRESENCE_FAILED_MSG,
                            power_supply_id[i], errno);
                        return (status);
                }

                if (present == PSVC_ABSENT) {
                        continue;
                }

                status = psvc_check_ps_hotplug_status_0(hdlp,
                    power_supply_id[i]);
                if (status == PSVC_FAILURE)
                        return (status);

                status = psvc_get_attr(hdlp, power_supply_id[i],
                    PSVC_STATE_ATTR, state);
                if (status == PSVC_FAILURE)
                        return (status);

                if (strcmp(state, PSVC_HOTPLUGGED) == 0) {
                        continue;
                } else {
                        ps_present++;
                }

                for (j = 0; j < DAK_MAX_PS_I_SENSORS; ++j) {
                        status = psvc_get_attr(hdlp, sensor_id[i][j],
                            PSVC_SENSOR_VALUE_ATTR, &amps);
                        if (status != PSVC_SUCCESS) {
                                if (overcurrent_failed_check == 0) {
                                        /*
                                         * First time the get_attr call
                                         * failed  set count so that if we
                                         * fail again we will know
                                         */
                                        overcurrent_failed_check = 1;
                                        /*
                                         * We probably failed because the power
                                         * supply was just insterted or removed
                                         * before the get_attr call. We then
                                         * return from this policy successfully
                                         * knowing it will be run again shortly
                                         * with the right PS state.
                                         */
                                        return (PSVC_SUCCESS);
                                } else {
                                        /*
                                         * We have failed before and so this we
                                         * will consider a hardware problem and
                                         * it should be reported.
                                         */
                                        syslog(LOG_ERR,
                                            "Failed getting %s sensor value",
                                            sensor_id[i][j]);
                                        return (status);
                                }
                        }
                        /*
                         * Because we have successfully gotten a value from the
                         * i2c device on the PS we will set the failed_count
                         * to 0.
                         */
                        overcurrent_failed_check = 0;

                        if (amps >= hi_warn[i][j]) {
                                oc_flag = 1;
                        }
                }
        }

        if (oc_flag) {
                /*
                 * Because we observed an overcurrent
                 * condition, we increment threshold_counter.
                 * Once threshold_counter reaches the value
                 * of n_read_overcurrent we log the event.
                 */
                threshold_counter++;
                if (threshold_counter == n_read_overcurrent) {
                        threshold_counter = 0;
                        if (ps_present == 1) {
                                syslog(LOG_ERR, PS_OVER_CURRENT_MSG);
                                syslog(LOG_ERR, ADD_PS_MSG);
                        } else {
                                syslog(LOG_ERR, PS_OVER_CURRENT_MSG);
                                syslog(LOG_ERR, REMOVE_LOAD_MSG);
                        }
                }
        } else {
                threshold_counter = 0;
        }

        return (PSVC_SUCCESS);
}

int32_t
psvc_ps_undercurrent_check(psvc_opaque_t hdlp, char *id, int32_t *uc_flag)
{
        int32_t status = PSVC_SUCCESS;
        boolean_t present;
        static char *sensor_id[DAK_MAX_PS_I_SENSORS];
        int32_t j;
        int32_t amps;
        static int32_t lo_warn[DAK_MAX_PS_I_SENSORS];
        static int8_t undercurrent_failed_check = 0;

        status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
        if (status == PSVC_FAILURE) {
                syslog(LOG_ERR, GET_PRESENCE_FAILED_MSG, id, errno);
                return (status);
        }

        if (present == PSVC_ABSENT) {
                errno = ENODEV;
                return (PSVC_FAILURE);
        }

        for (j = 0; j < DAK_MAX_PS_I_SENSORS; ++j) {
                status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                    &(sensor_id[j]), PSVC_PS_I_SENSOR, j);
                if (status != PSVC_SUCCESS)
                        return (status);
                status = psvc_get_attr(hdlp, sensor_id[j],
                    PSVC_LO_WARN_ATTR, &(lo_warn[j]));
                if (status != PSVC_SUCCESS)
                        return (status);
        }

        *uc_flag = 0;
        for (j = 0; j < DAK_MAX_PS_I_SENSORS; ++j) {
                status = psvc_get_attr(hdlp, sensor_id[j],
                    PSVC_SENSOR_VALUE_ATTR, &amps);
                if (status != PSVC_SUCCESS) {
                        if (undercurrent_failed_check == 0) {
                                /*
                                 * First time the get_attr call
                                 * failed  set count so that if we
                                 * fail again we will know.
                                 */
                                undercurrent_failed_check = 1;
                                /*
                                 * We probably failed because the power
                                 * supply was just inserted or removed
                                 * before the get_attr call. We then
                                 * return from this policy successfully
                                 * knowing it will be run again shortly
                                 * with the right PS state.
                                 */
                                return (PSVC_SUCCESS);
                        } else {
                                /*
                                 * Repeated failures are logged.
                                 */
                                syslog(LOG_ERR,
                                    "Failed getting %s sensor value",
                                    sensor_id[j]);
                                return (status);
                        }
                }
                /*
                 * Because we have successfully gotten a value from the
                 * i2c device on the PS we will set the failed_count
                 * to 0.
                 */
                undercurrent_failed_check = 0;

                if (amps <= lo_warn[j]) {
                        *uc_flag = 1;
                        return (PSVC_SUCCESS);
                }
        }

        return (PSVC_SUCCESS);
}

int32_t
psvc_ps_device_fail_notifier_policy_0(psvc_opaque_t hdlp, char *system)
{
        static char *ps_id[DAKTARI_MAX_PS] = {NULL};
        static char *sensor_id[DAKTARI_MAX_PS][DAK_MAX_FAULT_SENSORS];
        char *led_id = "FSP_POWER_FAULT_LED";
        int i, j, uc_flag;
        char state[32], fault[32], previous_state[32], past_state[32];
        char led_state[32];
        char bad_sensors[DAK_MAX_FAULT_SENSORS][256];
        static int threshold_counter[DAKTARI_MAX_PS];
        int32_t status = PSVC_SUCCESS;
        boolean_t present;
        int fail_state;
        static int8_t device_fail_failed_check = 0;
        int retry, should_retry;

        if (ps_id[0] == NULL) {
                for (i = 0; i < DAKTARI_MAX_PS; i++) {
                        status = psvc_get_attr(hdlp, system,
                            PSVC_ASSOC_ID_ATTR, &(ps_id[i]), PSVC_PS, i);
                        if (status != PSVC_SUCCESS)
                                return (status);
                        for (j = 0; j < DAK_MAX_FAULT_SENSORS; j++) {
                                status = psvc_get_attr(hdlp, ps_id[i],
                                    PSVC_ASSOC_ID_ATTR, &(sensor_id[i][j]),
                                    PSVC_DEV_FAULT_SENSOR, j);
                                if (status != PSVC_SUCCESS)
                                        return (status);
                        }
                }
        }

        for (i = 0; i < DAKTARI_MAX_PS; i++) {
                fail_state = 0;
                status = psvc_get_attr(hdlp, ps_id[i], PSVC_PRESENCE_ATTR,
                    &present);
                if (status == PSVC_FAILURE)
                        return (status);

                if (present == PSVC_ABSENT) {
                        errno = ENODEV;
                        return (PSVC_FAILURE);
                }

                status = psvc_check_ps_hotplug_status_0(hdlp, ps_id[i]);
                if (status == PSVC_FAILURE)
                        return (status);

                status = psvc_get_attr(hdlp, ps_id[i], PSVC_STATE_ATTR,
                    past_state);
                if (status == PSVC_FAILURE)
                        return (status);

                if (strcmp(past_state, PSVC_HOTPLUGGED) == 0) {
                        return (PICL_SUCCESS);
                }

                retry = 0;
                do {
                        if (retry)
                                (void) sleep(retry_sleep_devicefail);
                        fail_state = 0;
                        should_retry = 0;
                        for (j = 0; j < DAK_MAX_FAULT_SENSORS; ++j) {
                                status = psvc_get_attr(hdlp, sensor_id[i][j],
                                    PSVC_SWITCH_STATE_ATTR, state);
                                if (status != PSVC_SUCCESS) {
                                        if (device_fail_failed_check == 0) {
                                                /*
                                                 * First time the get_attr call
                                                 * failed  set count so that
                                                 * if we fail again we will know
                                                 */
                                                device_fail_failed_check = 1;
                                                /*
                                                 * We probably failed because
                                                 * the power supply was just
                                                 * insterted or removed before
                                                 * the get_attr call. We then
                                                 * return from this policy
                                                 * successfully knowing it will
                                                 * be run again shortly
                                                 * with the right PS state.
                                                 */
                                                return (PSVC_SUCCESS);
                                        } else {
                                                /*
                                                 * We have failed before and
                                                 * so this we will consider a
                                                 * hardware problem and
                                                 * it should be reported.
                                                 */
                                                syslog(LOG_ERR, "Failed in "
                                                    "getting sensor state for "
                                                    "%s\n", sensor_id[i][j]);

                                                return (status);
                                        }
                                }

                                /*
                                 * Because we have successfully gotten
                                 * a value from the i2c device on the
                                 * PS we will set the failed_count to 0.
                                 */
                                device_fail_failed_check = 0;

                                /*
                                 * If we find that the sensor is on we
                                 * fill in the name of the sensor in
                                 * the bad_sensor array. If the sensor
                                 * is off we use EMPTY_STRING as a check
                                 * later on as to when NOT to print out
                                 * what is in bad_sensor[].
                                 */
                                if (strcmp(state, PSVC_SWITCH_ON) == 0) {
                                        fail_state++;
                                        strlcpy(bad_sensors[j], sensor_id[i][j],
                                            sizeof (bad_sensors[j]));
                                } else {
                                        strcpy(bad_sensors[j], EMPTY_STRING);
                                }
                        }
                        retry++;
                        /*
                         * check to see if we need to retry. the conditions are:
                         *
                         * fail_state           past_state              retry
                         * --------------------------------------------------
                         *      +               PSVC_OK                 yes
                         *      0               PSVC_ERROR              yes
                         *      +               PSVC_ERROR              no
                         *      0               PSVC_OK                 no
                         */
                        if ((fail_state > 0) &&
                            (strcmp(past_state, PSVC_OK) == 0)) {
                                should_retry = 1;
                        } else if ((fail_state == 0) &&
                            (strcmp(past_state, PSVC_ERROR) == 0)) {
                                should_retry = 1;
                        }
                } while ((retry < n_retry_devicefail) && should_retry);

                /* Under current check */
                status = psvc_ps_undercurrent_check(hdlp, ps_id[i], &uc_flag);

                if (status != PSVC_FAILURE) {
                        if (uc_flag) {
                                /*
                                 * Because we observed an undercurrent
                                 * condition, we increment threshold counter.
                                 * Once threshold counter reaches the value
                                 * of n_read_undercurrent we log the event.
                                 */
                                threshold_counter[i]++;
                                if (threshold_counter[i] >=
                                    n_read_undercurrent) {
                                        fail_state++;
                                        syslog(LOG_ERR, PS_UNDER_CURRENT_MSG,
                                            i);
                                }
                        } else {
                                threshold_counter[i] = 0;
                        }
                }

                if (fail_state != 0) {
                        strcpy(state, PSVC_ERROR);
                        strcpy(fault, PSVC_GEN_FAULT);
                } else {
                        strcpy(state, PSVC_OK);
                        strcpy(fault, PSVC_NO_FAULT);
                }

                status = psvc_set_attr(hdlp, ps_id[i], PSVC_STATE_ATTR, state);
                if (status != PSVC_SUCCESS)
                        return (status);

                status = psvc_set_attr(hdlp, ps_id[i], PSVC_FAULTID_ATTR,
                    fault);
                if (status != PSVC_SUCCESS)
                        return (status);

                status = psvc_get_attr(hdlp, ps_id[i], PSVC_PREV_STATE_ATTR,
                    previous_state);
                if (status != PSVC_SUCCESS)
                        return (status);

                if (strcmp(state, previous_state) != 0) {
                        char dev_label[32];

                        psvc_get_attr(hdlp, ps_id[i], PSVC_LABEL_ATTR,
                            dev_label);

                        if (strcmp(state, PSVC_ERROR) == 0) {
                                syslog(LOG_ERR, DEVICE_FAILURE_MSG, dev_label);
                                for (j = 0; j < DAK_MAX_FAULT_SENSORS; ++j) {
                                        if (strcmp(bad_sensors[j],
                                            EMPTY_STRING) != 0)
                                                syslog(LOG_ERR, "%s\n",
                                                    bad_sensors[j]);
                                }
                                strcpy(led_state, PSVC_LED_ON);
                        } else {
                                syslog(LOG_ERR, DEVICE_OK_MSG, dev_label);
                                strcpy(led_state, PSVC_LED_OFF);
                        }

                        status = psvc_set_attr(hdlp, led_id,
                            PSVC_LED_STATE_ATTR, led_state);
                        if (status != PSVC_SUCCESS) {
                                syslog(LOG_ERR, SET_LED_FAILED_MSG, led_id,
                                    errno);
                                return (status);
                        }
                }
        }

        return (PSVC_SUCCESS);
}

int32_t
psvc_ps_check_and_disable_dr_policy_0(psvc_opaque_t hdlp, char *id)
{
        char            state[32];
        static char     *name[DAKTARI_MAX_PS] = {NULL};
        int             ps_cnt = 0;
        int             i, j;
        int             dr_conf;
        int             fd, rv;
        boolean_t       present;
        char            dev_path[sizeof (HPC3130_DEV)+8];
        unsigned char   controller_names[HPC3130_CONTROLLERS] =
                { 0xe2, 0xe6, 0xe8, 0xec };

        if (name[0] == NULL) {
                for (i = 0; i < DAKTARI_MAX_PS; i++) {
                        rv = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                            &(name[i]), PSVC_PS, i);
                        if (rv != PSVC_SUCCESS)
                                return (rv);
                }
        }

        /*
         * Go through the power supplies to make sure they're present
         * and OK.
         */
        ps_cnt = DAKTARI_MAX_PS;
        for (i = 0; i < DAKTARI_MAX_PS; i++) {
                rv = psvc_get_attr(hdlp, name[i], PSVC_PRESENCE_ATTR,
                    &present);
                if (rv != PSVC_SUCCESS)
                        return (rv);

                if (present != PSVC_PRESENT) {
                        ps_cnt--;
                        continue;
                } else {
                        rv = psvc_get_attr(hdlp, name[i], PSVC_STATE_ATTR,
                            state);
                        if (rv != PSVC_SUCCESS)
                                return (rv);

                        if (strcmp(state, PSVC_OK))
                                ps_cnt--;
                }
        }

        /*
         * No change in DR configuration is needed if the new power supply
         * count equals the current count.
         */
        if (ps_cnt == co_ps)
                return (PSVC_SUCCESS);

        /*
         * Disable DR when hotplugged down to 1 power supply; enable DR when
         * hotplugged up from 1 supply.
         */
        assert(ps_cnt);
        if ((co_ps == 0 || co_ps > 1) && ps_cnt != 1) {
                co_ps = ps_cnt;
                return (PSVC_SUCCESS);
        }
        dr_conf = (ps_cnt == 1 ? HPC3130_DR_DISABLE : HPC3130_DR_ENABLE);
        co_ps = ps_cnt;

        for (i = 0; i < HPC3130_CONTROLLERS; i++) {
                for (j = 0; j < HPC3130_SLOTS; j++) {
                        (void) snprintf(dev_path, sizeof (dev_path),
                            HPC3130_DEV, controller_names[i], j);
                        fd = open(dev_path, O_RDWR);
                        if (fd == -1)
                                return (PSVC_FAILURE);

                        rv = ioctl(fd, HPC3130_CONF_DR, &dr_conf);
                        close(fd);
                        if (rv == -1)
                                return (PSVC_FAILURE);
                }
        }

        return (PSVC_SUCCESS);
}

int32_t
psvc_fan_blast_shutoff_policy_0(psvc_opaque_t hdlp, char *id)
{
        char            switch_status[32];
        int32_t         status = PSVC_SUCCESS;

        status = psvc_get_attr(hdlp, id, PSVC_SWITCH_STATE_ATTR, switch_status);
        if (status != PSVC_SUCCESS)
                return (status);
        status = psvc_set_attr(hdlp, id, PSVC_SWITCH_STATE_ATTR,
            PSVC_SWITCH_OFF);
        if (status != PSVC_SUCCESS)
                return (status);
        status = psvc_set_attr(hdlp, id, PSVC_SWITCH_STATE_ATTR,
            PSVC_SWITCH_ON);
        if (status != PSVC_SUCCESS)
                return (status);
        status = psvc_set_attr(hdlp, id, PSVC_SWITCH_STATE_ATTR,
            PSVC_SWITCH_OFF);

        return (status);
}

int32_t
psvc_fan_fault_check_policy_0(psvc_opaque_t hdlp, char *system)
{
        static char *fan_id[DAK_MAX_FANS] = {NULL};
        boolean_t enabled;
        int32_t speed;
        int32_t status = PSVC_SUCCESS;
        int r;
        static int threshold_counter = 0;

        if (fan_id[0] == NULL) {
                for (r = 0; r < DAK_MAX_FANS; r++) {
                        status = psvc_get_attr(hdlp, system,
                            PSVC_ASSOC_ID_ATTR, &(fan_id[r]), PSVC_FAN, r);
                        if (status != PSVC_SUCCESS)
                                return (status);
                }
        }

        for (r = 0; r < DAK_MAX_FANS; r++) {
                status = psvc_get_attr(hdlp, fan_id[r], PSVC_ENABLE_ATTR,
                    &enabled);
                if (status != PSVC_SUCCESS)
                        return (status);

                if (enabled == PSVC_ENABLED) {
                        uint64_t features;
                        char *switch_id;
                        char switch_state[32], fan_state[32];
                        int fan_count, fans;
                        char *other_fan_id;
                        char fstate[32], ffault[32];

                        /*
                         * If any other fan on the fan tray has an ERROR state,
                         * mark this fan bad and return
                         */
                        psvc_get_attr(hdlp, fan_id[r], PSVC_ASSOC_MATCHES_ATTR,
                            &fan_count, PSVC_FAN_TRAY_FANS);
                        for (fans = 0; fans < fan_count; ++fans) {
                                status = psvc_get_attr(hdlp, fan_id[r],
                                    PSVC_ASSOC_ID_ATTR, &other_fan_id,
                                    PSVC_FAN_TRAY_FANS, fans);
                                if (status == PSVC_FAILURE)
                                        return (status);
                                status = psvc_get_attr(hdlp, other_fan_id,
                                    PSVC_STATE_ATTR, fan_state);
                                if (status != PSVC_SUCCESS)
                                        return (status);

                                if (strcmp(fan_state, PSVC_ERROR) == 0) {
                                        strlcpy(ffault, PSVC_GEN_FAULT,
                                            sizeof (ffault));
                                        status = psvc_set_attr(hdlp, fan_id[r],
                                            PSVC_FAULTID_ATTR, ffault);
                                        if (status != PSVC_SUCCESS)
                                                return (status);

                                        strlcpy(fstate, PSVC_ERROR,
                                            sizeof (fstate));
                                        status = psvc_set_attr(hdlp, fan_id[r],
                                            PSVC_STATE_ATTR, fstate);

                                        return (status);
                                }
                        }

                        /*
                         * Select tachometer for IO or CPU primary/secondary
                         * fans.
                         */
                        pthread_mutex_lock(&fan_mutex);

                        status = psvc_get_attr(hdlp, fan_id[r],
                            PSVC_ASSOC_ID_ATTR, &switch_id,
                            PSVC_FAN_PRIM_SEC_SELECTOR, 0);

                        if (status != PSVC_FAILURE) {
                                status = psvc_get_attr(hdlp, fan_id[r],
                                    PSVC_FEATURES_ATTR, &features);
                                if (status == PSVC_FAILURE) {
                                        pthread_mutex_unlock(&fan_mutex);
                                        return (status);
                                }

                                if (features & PSVC_DEV_PRIMARY)
                                        strlcpy(switch_state, PSVC_SWITCH_ON,
                                            sizeof (switch_state));
                                else
                                        strlcpy(switch_state, PSVC_SWITCH_OFF,
                                            sizeof (switch_state));
                                status = psvc_set_attr(hdlp, switch_id,
                                    PSVC_SWITCH_STATE_ATTR, switch_state);
                                if (status == PSVC_FAILURE) {
                                        pthread_mutex_unlock(&fan_mutex);
                                        return (status);
                                }

                                /* allow time for speed to be determined */
                                (void) poll(NULL, 0, 250);
                        }

                        status = psvc_get_attr(hdlp, fan_id[r],
                            PSVC_SENSOR_VALUE_ATTR, &speed);
                        if (status != PSVC_SUCCESS) {
                                pthread_mutex_unlock(&fan_mutex);
                                return (status);
                        }

                        pthread_mutex_unlock(&fan_mutex);

                        if (speed == 0) {
                                threshold_counter++;
                                if (threshold_counter ==
                                    n_read_fanfault) {
                                        int32_t i;
                                        int32_t led_count;
                                        char led_state[32];
                                        char *led_id;
                                        char *slot_id;
                                        char label[32];
                                        char state[32], fault[32];

                                        threshold_counter = 0;
                                        strlcpy(fault, PSVC_GEN_FAULT,
                                            sizeof (fault));
                                        status = psvc_set_attr(hdlp, fan_id[r],
                                            PSVC_FAULTID_ATTR, fault);
                                        if (status != PSVC_SUCCESS)
                                                return (status);

                                        strlcpy(state, PSVC_ERROR,
                                            sizeof (state));
                                        status = psvc_set_attr(hdlp, fan_id[r],
                                            PSVC_STATE_ATTR, state);
                                        if (status != PSVC_SUCCESS)
                                                return (status);

                                        status = psvc_get_attr(hdlp, fan_id[r],
                                            PSVC_LABEL_ATTR, label);
                                        if (status != PSVC_SUCCESS)
                                                return (status);

                                        syslog(LOG_ERR, DEVICE_FAILURE_MSG,
                                            label);

                                        /* turn on fault LEDs */
                                        psvc_get_attr(hdlp, fan_id[r],
                                            PSVC_ASSOC_MATCHES_ATTR, &led_count,
                                            PSVC_DEV_FAULT_LED);
                                        strlcpy(led_state, PSVC_LED_ON,
                                            sizeof (led_state));
                                        for (i = 0; i < led_count; ++i) {
                                                status = psvc_get_attr(hdlp,
                                                    fan_id[r],
                                                    PSVC_ASSOC_ID_ATTR, &led_id,
                                                    PSVC_DEV_FAULT_LED, i);
                                                if (status == PSVC_FAILURE)
                                                        return (status);

                                                status = psvc_set_attr(hdlp,
                                                    led_id, PSVC_LED_STATE_ATTR,
                                                    led_state);
                                                if (status == PSVC_FAILURE)
                                                        return (status);
                                        }

                                        /* turn on OK to remove LEDs */

                                        status = psvc_get_attr(hdlp, fan_id[r],
                                            PSVC_ASSOC_ID_ATTR, &slot_id,
                                            PSVC_PARENT, 0);
                                        if (status != PSVC_SUCCESS)
                                                return (status);

                                        psvc_get_attr(hdlp, slot_id,
                                            PSVC_ASSOC_MATCHES_ATTR, &led_count,
                                            PSVC_SLOT_REMOVE_LED);
                                        strlcpy(led_state, PSVC_LED_ON,
                                            sizeof (led_state));
                                        for (i = 0; i < led_count; ++i) {
                                                status = psvc_get_attr(hdlp,
                                                    slot_id,
                                                    PSVC_ASSOC_ID_ATTR, &led_id,
                                                    PSVC_SLOT_REMOVE_LED, i);
                                                if (status == PSVC_FAILURE)
                                                        return (status);

                                                status = psvc_set_attr(hdlp,
                                                    led_id, PSVC_LED_STATE_ATTR,
                                                    led_state);
                                                if (status == PSVC_FAILURE)
                                                        return (status);
                                        }
                                }
                        }
                }
        }

        return (PSVC_SUCCESS);
}

/*
 * This routine takes in the PSVC handle pointer, the PS name, and the
 * instance number (0, 1, or 2). 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 *sensor_id;
        char fail_valid_switch_id[PICL_PROPNAMELEN_MAX];
        int32_t status = PSVC_SUCCESS;
        boolean_t presence;
        int j;

        /* Get the Sensor Valid Switch presence */
        snprintf(fail_valid_switch_id, sizeof (fail_valid_switch_id), "%s%s",
            id, "_SENSOR_VALID_SWITCH");

        status = psvc_get_attr(hdlp, fail_valid_switch_id, PSVC_PRESENCE_ATTR,
            &presence);
        if (status != PSVC_SUCCESS)
                return (status);

        /* Go through each PS's fault sensors */
        for (j = 0; j < DAK_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 current sensors */
        for (j = 0; j < DAK_MAX_PS_I_SENSORS; ++j) {
                status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                    &(sensor_id), PSVC_PS_I_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 < 3; 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 i2c_hp_t devices[3][3] = {
{{{0, 0x90}, "adio", "i2c-pcf8591"}, {{0, 0x70}, "ioexp", "i2c-pcf8574"},
        {{0, 0xa0}, "fru", "i2c-at24c64"}},
{{{0, 0x92}, "adio", "i2c-pcf8591"}, {{0, 0x72}, "ioexp", "i2c-pcf8574"},
        {{0, 0xa2}, "fru", "i2c-at24c64"}},
{{{0, 0x94}, "adio", "i2c-pcf8591"}, {{0, 0x74}, "ioexp", "i2c-pcf8574"},
        {{0, 0xa4}, "fru", "i2c-at24c64"}},
};

int32_t
psvc_ps_hotplug_policy_0(psvc_opaque_t hdlp, char *id)
{
        boolean_t presence, previous_presence;
        int32_t status = PSVC_SUCCESS;
        char label[32], state[32], fault[32];
        int32_t ps_instance, led_count;
        char *switch_id, *led_id;
        int i;
        picl_nodehdl_t parent_node;
        char parent_path[256], ps_path[256];
        picl_nodehdl_t child_node;
        devctl_hdl_t bus_handle, dev_handle;
        devctl_ddef_t ddef_hdl;
        char pcf8574_devpath[256], pcf8591_devpath[256], fru_devpath[256];
        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_pshp);

                status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
                if (status != PSVC_SUCCESS)
                        return (status);
                retry++;
        } while ((retry < n_retry_pshp) &&
            (presence != previous_presence));

        if (presence == previous_presence) {
                /* No change */
                return (status);
        }

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

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

        if (presence == PSVC_PRESENT) {
                /*
                 * Run this code if Power Supply was just added into the
                 * System.  This code toggles hotplug switch and adds the
                 * PS and it's children to the picl tree. We then goto adding
                 * device drivers at bottom of the routine.
                 */
                int32_t switch_count;
                char state[32], fault[32];
                char switch_state[32];

                /* may detect presence before all connections are made */
                (void) poll(NULL, 0, 500);

                /* Device added */
                syslog(LOG_ERR, DEVICE_INSERTED_MSG, label);

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

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

                /* Enable i2c bus */
                psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR,
                    &switch_count, PSVC_HOTPLUG_ENABLE_SWITCH);
                for (i = 0; i < switch_count; ++i) {
                        status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                            &switch_id, PSVC_HOTPLUG_ENABLE_SWITCH, i);
                        if (status == PSVC_FAILURE)
                                return (status);

                        strcpy(switch_state, PSVC_SWITCH_OFF);
                        status = psvc_set_attr(hdlp, switch_id,
                            PSVC_SWITCH_STATE_ATTR, switch_state);
                        if (status == PSVC_FAILURE)
                                return (status);

                        strcpy(switch_state, PSVC_SWITCH_ON);
                        status = psvc_set_attr(hdlp, switch_id,
                            PSVC_SWITCH_STATE_ATTR, switch_state);
                        if (status == PSVC_FAILURE)
                                return (status);
                }
                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);
        } else {
                /*
                 * Run this code if PS was just removed from the system. We
                 * delete the device from the picl tree and then shut off
                 * all fault lights associated with the PS.  We also set the
                 * device state to PSVC_REMOVED so that if we hit overcurrent
                 * or fault checking code we can do a psvc call to see that
                 * the device has not offically been added into the system.
                 * We then will drop to code lower in the routine to remove
                 * the device drivers for this PS.
                 */

                /* Device removed */
                syslog(LOG_ERR, DEVICE_REMOVED_MSG, label);
                ptree_delete_node(child_node);
                psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &led_count,
                    PSVC_DEV_FAULT_LED);

                for (i = 0; i < led_count; i++) {
                        status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                            &led_id, PSVC_DEV_FAULT_LED, i);
                        if (status != PSVC_SUCCESS) {
                                return (status);
                        }

                        status = psvc_set_attr(hdlp, led_id,
                            PSVC_LED_STATE_ATTR, PSVC_OFF);
                        if (status != PSVC_SUCCESS) {
                                syslog(LOG_ERR, SET_LED_FAILED_MSG, led_id,
                                    errno);
                                return (status);
                        }

                }

                strcpy(state, PSVC_OK);
                strcpy(fault, PSVC_NO_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_set_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR, &presence);
        if (status != PSVC_SUCCESS)
                return (status);

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

        if (presence != PSVC_PRESENT) {
                /*
                 * This is the additional code needed to remove the PS from
                 * the system.  It removes the device drivers from the
                 * device tree.
                 */
                snprintf(pcf8574_devpath, sizeof (pcf8574_devpath), PCF8574,
                    devices[ps_instance][1].addr[1]);
                snprintf(pcf8591_devpath, sizeof (pcf8591_devpath), PCF8591,
                    devices[ps_instance][0].addr[1]);
                snprintf(fru_devpath, sizeof (fru_devpath), FRU,
                    devices[ps_instance][2].addr[1]);

                dev_handle = devctl_device_acquire(pcf8591_devpath, 0);
                if (dev_handle == NULL) {
                        syslog(LOG_ERR, DEVICE_HANDLE_FAIL_MSG,
                            pcf8591_devpath, errno);
                        devctl_release(dev_handle);
                        return (PSVC_FAILURE);
                } else if ((devctl_device_remove(dev_handle)) &&
                    (errno != ENXIO)) {
                                syslog(LOG_ERR, DEVTREE_NODE_DELETE_FAILED,
                                    pcf8591_devpath, errno);
                                devctl_release(dev_handle);
                                return (PSVC_FAILURE);
                        } else {
                                devctl_release(dev_handle);
                                status = PSVC_SUCCESS;
                        }

                dev_handle = devctl_device_acquire(pcf8574_devpath, 0);
                if (dev_handle == NULL) {
                        syslog(LOG_ERR, DEVICE_HANDLE_FAIL_MSG,
                            pcf8574_devpath, errno);
                        devctl_release(dev_handle);
                        return (PSVC_FAILURE);
                } else if ((devctl_device_remove(dev_handle)) &&
                    (errno != ENXIO)) {
                                syslog(LOG_ERR, DEVTREE_NODE_DELETE_FAILED,
                                    pcf8574_devpath, errno);
                                devctl_release(dev_handle);
                                return (PSVC_FAILURE);
                        } else {
                                devctl_release(dev_handle);
                                status = PSVC_SUCCESS;
                        }

                dev_handle = devctl_device_acquire(fru_devpath, 0);
                if (dev_handle == NULL) {
                        syslog(LOG_ERR, DEVICE_HANDLE_FAIL_MSG,
                            fru_devpath, errno);
                        devctl_release(dev_handle);
                        return (PSVC_FAILURE);
                } else if ((devctl_device_remove(dev_handle)) &&
                    (errno != ENXIO)) {
                                syslog(LOG_ERR, DEVTREE_NODE_DELETE_FAILED,
                                    fru_devpath, errno);
                                devctl_release(dev_handle);
                                return (PSVC_FAILURE);
                        } else {
                                devctl_release(dev_handle);
                                status = PSVC_SUCCESS;
                        }

                return (status);
        }

        /*
         * This code is 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);
        if (status == PSVC_FAILURE) {
                return (status);
        }

        /*
         * We fall through to here if the device has been inserted.
         * Add the devinfo tree node entry for the seeprom and attach
         * the i2c seeprom driver
         */

        bus_handle = devctl_bus_acquire(I2C_NODE, 0);
        if (bus_handle == NULL) {
                syslog(LOG_ERR, DEVICE_HANDLE_FAIL_MSG, I2C_NODE, errno);
                return (PSVC_FAILURE);
        }
        /* Create the deivce nodes for all 3 i2c parts on the PS */
        for (i = 0; i < 3; i++) {
                ddef_hdl = devctl_ddef_alloc(devices[ps_instance][i].name, 0);
                if (ddef_hdl == NULL) {
                        syslog(LOG_ERR, DEVICE_HANDLE_FAIL_MSG,
                            devices[ps_instance][i].name, errno);
                        return (PSVC_FAILURE);
                }
                status = devctl_ddef_string(ddef_hdl, "compatible",
                    devices[ps_instance][i].compatible);
                if (status == -1) {
                        syslog(LOG_ERR, DEVICE_HANDLE_FAIL_MSG,
                            devices[ps_instance][i].name, errno);
                        return (PSVC_FAILURE);
                }
                status = devctl_ddef_int_array(ddef_hdl, "reg", 2,
                    devices[ps_instance][i].addr);
                if (status == -1) {
                        syslog(LOG_ERR, DEVICE_HANDLE_FAIL_MSG,
                            devices[ps_instance][i].name, errno);
                        return (PSVC_FAILURE);
                }
                if (devctl_bus_dev_create(bus_handle, ddef_hdl, 0,
                    &dev_handle)) {
                        syslog(LOG_ERR, DEVTREE_NODE_CREATE_FAILED,
                            devices[ps_instance][i].name, errno);
                        return (PSVC_FAILURE);
                } else
                        devctl_release(dev_handle);
                devctl_ddef_free(ddef_hdl);
        }
        devctl_release(bus_handle);

        return (status);
}

static void
shutdown_routine()
{
        static boolean_t shutdown_flag = 0;

        if (!(shutdown_flag)) {
                system(shutdown_string);
                shutdown_flag = 1;
        }
}

/*
 * This policy checks temperature sensors to see if the fault attribute
 * is set to either High or Low Shutdown. If so then it shuts the system
 * down with a 1 minute warning period
 */
int32_t
psvc_shutdown_policy(psvc_opaque_t hdlp, char *id)
{
        int32_t status;
        char    fault[32] = {0};
        boolean_t       pr;
        int     retry;

        status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &pr);
        if ((status != PSVC_SUCCESS) || (pr != PSVC_PRESENT)) {
                return (status);
        }

        retry = 0;
        do {
                if (retry)
                        (void) sleep(retry_sleep_temp_shutdown);
                status = psvc_get_attr(hdlp, id, PSVC_FAULTID_ATTR, fault);
                if (status != PSVC_SUCCESS)
                        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_LO_SHUT) == 0) ||
            (strcmp(fault, PSVC_TEMP_HI_SHUT) == 0)) {
                shutdown_routine();
        }

        return (PSVC_SUCCESS);
}

int32_t
psvc_check_disk_fault_policy_0(psvc_opaque_t hdlp, char *id)
{
        int32_t         status = PSVC_SUCCESS;
        int32_t         i;
        char            prev_state[32], led_state[32];
        char            disk_fault[32], disk_state[32];
        static char     *disk_id[DAK_MAX_DISKS] = {NULL};
        static char     *led_id[DAK_MAX_DISKS] = {NULL};
        static char     *parent_id[DAK_MAX_DISKS] = {NULL};
        boolean_t       present;
        int             retry;

        /*
         * Check which disk faulted, now get the disks.
         * We are now going to get disk, disk parent,
         * parent's leds, and check to see if parent's leds are on
         */

        if (disk_id[0] == NULL) {
                for (i = 0; i < DAK_MAX_DISKS; i++) {
                        status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                            &(disk_id[i]), PSVC_DISK, i);
                        if (status != PSVC_SUCCESS)
                                return (status);
                        status = psvc_get_attr(hdlp, disk_id[i],
                            PSVC_ASSOC_ID_ATTR, &(parent_id[i]),
                            PSVC_PARENT, 0);
                        if (status != PSVC_SUCCESS)
                                return (status);
                        status = psvc_get_attr(hdlp, parent_id[i],
                            PSVC_ASSOC_ID_ATTR, &(led_id[i]),
                            PSVC_SLOT_FAULT_LED, 0);
                        if (status != PSVC_SUCCESS)
                                return (status);

                }
        }

        for (i = 0; i < DAK_MAX_DISKS; i++) {
                prev_state[0] = 0;

                status = psvc_get_attr(hdlp, disk_id[i], PSVC_PRESENCE_ATTR,
                    &present);
                if (status != PSVC_SUCCESS)
                        return (status);

                if (present == PSVC_ABSENT)
                        continue;

                /*
                 * Check if whether or not the led is on.
                 * If so, then this disk has a problem and
                 * set its fault and error states to bad.
                 * If not, then set fault and error states to good.
                 * If the disk underwent a change in state, then
                 * print out what state it's now in.
                 */

                status = psvc_get_attr(hdlp, disk_id[i], PSVC_STATE_ATTR,
                    prev_state);
                if (status != PSVC_SUCCESS)
                        return (status);

                retry = 0;
                do {
                        if (retry)
                                (void) sleep(retry_sleep_diskfault);
                        status = psvc_get_attr(hdlp, led_id[i], PSVC_STATE_ATTR,
                            led_state);
                        if (status != PSVC_SUCCESS)
                                return (status);
                        retry++;
                        /*
                         * check to see if we need to retry. the conditions are:
                         *
                         * prev_state           led_state               retry
                         * --------------------------------------------------
                         * PSVC_ERROR           PSVC_LED_ON             yes
                         * PSVC_OK              PSVC_LED_OFF            yes
                         * PSVC_ERROR           PSVC_LED_OFF            no
                         * PSVC_OK              PSVC_LED_ON             no
                         */
                } while ((retry < n_retry_diskfault) &&
                    change_of_state_str(prev_state, PSVC_OK,
                    led_state, PSVC_LED_ON));

                /*
                 * Set the disk's state and fault id according to
                 * what we found the disk fault sensor (disk_slot_fault_led)
                 * to be.
                 */
                if (strcmp(led_state, PSVC_LED_ON) == 0) {
                        strcpy(disk_fault, PSVC_GEN_FAULT);
                        strcpy(disk_state, PSVC_ERROR);
                } else {
                        strcpy(disk_fault, PSVC_NO_FAULT);
                        strcpy(disk_state, PSVC_OK);
                }
                status = psvc_set_attr(hdlp, disk_id[i], PSVC_STATE_ATTR,
                    disk_state);
                if (status != PSVC_SUCCESS)
                        return (status);
                status = psvc_set_attr(hdlp, disk_id[i], PSVC_FAULTID_ATTR,
                    disk_fault);
                if (status != PSVC_SUCCESS)
                        return (status);
                /*
                 * Check disk states.  If they differ, then print out
                 * the current state of the disk
                 */
                status = psvc_get_attr(hdlp, disk_id[i], PSVC_PREV_STATE_ATTR,
                    prev_state);
                if (status != PSVC_SUCCESS)
                        return (status);

                if (strcmp(disk_state, prev_state) != 0) {
                        if (strcmp(disk_state, PSVC_ERROR) == 0) {
                                syslog(LOG_ERR, DISK_FAULT_MSG, disk_id[i]);
                        } else {
                                syslog(LOG_ERR, DISK_OK_MSG, disk_id[i]);
                        }
                }
        }
        return (PSVC_SUCCESS);
}

int32_t
psvc_update_FSP_fault_led_policy_0(psvc_opaque_t hdlp, char *id)
{
        int32_t status = PSVC_SUCCESS;
        int32_t i;
        int32_t dev_count, fault_state = 0;
        char    *dev_id;
        char    dev_state[32], led_state[32];
        boolean_t       present;

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

        fault_state = 0;

        for (i = 0; i < dev_count; i++) {
                status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                    &dev_id, PSVC_DEV_FAULT_SENSOR, i);
                if (status != PSVC_SUCCESS)
                        return (status);
                status = psvc_get_attr(hdlp, dev_id, PSVC_PRESENCE_ATTR,
                    &present);
                if (status != PSVC_SUCCESS)
                        return (status);

                if (present == PSVC_ABSENT)
                        continue;

                status = psvc_get_attr(hdlp, dev_id, PSVC_STATE_ATTR,
                    dev_state);
                if (status != PSVC_SUCCESS)
                        return (status);

                if (strcmp(dev_state, PSVC_ERROR) == 0) {
                        fault_state = 1;
                }
        }
        if (fault_state == 1) {
                status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, led_state);
                if (status != PSVC_SUCCESS)
                        return (status);
                if (strcmp(led_state, PSVC_OFF) == 0) {
                        status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
                            PSVC_ON);
                        if (status != PSVC_SUCCESS)
                                return (status);
                }
        } else {
                status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, led_state);
                if (status != PSVC_SUCCESS)
                        return (status);
                if (strcmp(led_state, PSVC_ON) == 0) {
                        status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
                            PSVC_OFF);
                        if (status != PSVC_SUCCESS)
                                return (status);
                }
        }
        status = update_gen_fault_led(hdlp, GEN_FAULT_LED);

        return (status);
}

int32_t
update_gen_fault_led(psvc_opaque_t hdlp, char *id)
{
        int32_t status = PSVC_SUCCESS;
        int32_t i;
        int32_t led_count, fault_state;
        char    *led_id;
        char    led_state[32];

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

        fault_state = 0;

        for (i = 0; i < led_count; i++) {
                status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
                    &led_id, PSVC_DEV_FAULT_SENSOR, i);
                if (status != PSVC_SUCCESS)
                        return (status);
                status = psvc_get_attr(hdlp, led_id, PSVC_STATE_ATTR,
                    led_state);
                if (status != PSVC_SUCCESS)
                        return (status);

                if (strcmp(led_state, PSVC_ON) == 0) {
                        fault_state = 1;
                }
        }

        if (fault_state == 1) {
                status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, led_state);
                if (status != PSVC_SUCCESS)
                        return (status);
                if (strcmp(led_state, PSVC_OFF) == 0) {
                        status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
                            PSVC_ON);
                        if (status != PSVC_SUCCESS)
                                return (status);
                }
        } else {
                status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, led_state);
                if (status != PSVC_SUCCESS)
                        return (status);
                if (strcmp(led_state, PSVC_ON) == 0) {
                        status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
                            PSVC_OFF);
                        if (status != PSVC_SUCCESS)
                                return (status);
                }
        }

        return (status);
}


/*
 * This function detects whether the module present in the dakatari's
 * CPU slot is a CPU module or a Zulu (XVR-4000).
 * Based on this detection it also sets the appropriate temperature sensors
 * to HOTPLUGGED, so that it works properly with check_temp() function
 */
#define MAX_MODULE_SIZE         20
#define MAX_TEMP_SENSOR_SIZE    30

int32_t
psvc_update_cpu_module_card_node_0(psvc_opaque_t hdlp, char *id)
{
        int32_t set_temp_sensor_properties(psvc_opaque_t, char *);
        int32_t remove_module_node(psvc_opaque_t, char *);
        int32_t status = PSVC_SUCCESS;
        fru_info_t fru_data;
        char *fru, seg_name[2];
        int8_t seg_count, module_card;
        int32_t match_count, i, j, seg_desc_start = 0x1806, module_address;
        int32_t seg_found;
        boolean_t present;
        seg_desc_t segment;
        char other_module_id[MAX_MODULE_SIZE];
        char cpu_temp_sensor1[MAX_TEMP_SENSOR_SIZE];
        char cpu_temp_sensor2[MAX_TEMP_SENSOR_SIZE];
        char zulu_temp_sensor1[MAX_TEMP_SENSOR_SIZE];
        char zulu_temp_sensor2[MAX_TEMP_SENSOR_SIZE];
        int offset = 0x7;

        status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
        if ((status != PSVC_SUCCESS) || (present != PSVC_PRESENT)) {
                return (status);
        }

        status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &match_count,
            PSVC_FRU);
        if (status == PSVC_FAILURE) {
                return (status);
        }

        for (i = 0; i < match_count; i++) {
                seg_found = 0;
                status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, &fru,
                    PSVC_FRU, i);
                if (status != PSVC_SUCCESS)
                        return (status);

                fru_data.buf_start = 0x1805;
                fru_data.buf = (char *)&seg_count;
                fru_data.read_size = 1;

                status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
                    &fru_data);
                if (status != PSVC_SUCCESS) {
                        return (status);
                }

                for (j = 0; (j < seg_count) && (!seg_found); j++) {
                        fru_data.buf_start = seg_desc_start;
                        fru_data.buf = seg_name;
                        fru_data.read_size = 2;

                        status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
                            &fru_data);
                        if (status != PSVC_SUCCESS) {
                                syslog(LOG_ERR, GET_ATTR_FRU_FAILED_MSG);
                                return (status);
                        }

                        seg_desc_start = seg_desc_start + 2;
                        fru_data.buf_start = seg_desc_start;
                        fru_data.buf = (char *)&segment;
                        fru_data.read_size = sizeof (seg_desc_t);

                        status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
                            &fru_data);
                        if (status != PSVC_SUCCESS) {
                                syslog(LOG_ERR, GET_ATTR_FRU_FAILED_MSG);
                                return (status);
                        }
                        seg_desc_start = seg_desc_start + sizeof (seg_desc_t);
                        if (memcmp(seg_name, "SC", 2) == 0)
                                seg_found = 1;
                }

                if (seg_found) {
                        module_address = segment.segoffset + offset;
                        fru_data.buf_start = module_address;
                        fru_data.buf = (char *)&module_card;
                        fru_data.read_size = 1;
                        status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
                            &fru_data);
                        if (status != PSVC_SUCCESS) {
                                syslog(LOG_ERR, GET_ATTR_FRU_FAILED_MSG);
                                return (status);
                        }
                } else {
                        syslog(LOG_ERR, NO_FRU_INFO_MSG, id);
                }
        }

        if (strcmp(id, "ZULU_1_3_MOD_CARD") == 0) {
                strlcpy(other_module_id, "CPU_1_3_MOD_CARD", MAX_MODULE_SIZE);

                strlcpy(cpu_temp_sensor1, "CPU1_DIE_TEMPERATURE_SENSOR",
                    MAX_TEMP_SENSOR_SIZE);
                strlcpy(cpu_temp_sensor2, "CPU3_DIE_TEMPERATURE_SENSOR",
                    MAX_TEMP_SENSOR_SIZE);

                strlcpy(zulu_temp_sensor1, "ZULU1_DIE_TEMPERATURE_SENSOR",
                    MAX_TEMP_SENSOR_SIZE);
                strlcpy(zulu_temp_sensor2, "ZULU3_DIE_TEMPERATURE_SENSOR",
                    MAX_TEMP_SENSOR_SIZE);
        }

        if (strcmp(id, "ZULU_4_6_MOD_CARD") == 0) {
                strlcpy(other_module_id, "CPU_4_6_MOD_CARD", MAX_MODULE_SIZE);

                strlcpy(cpu_temp_sensor1, "CPU4_DIE_TEMPERATURE_SENSOR",
                    MAX_TEMP_SENSOR_SIZE);
                strlcpy(cpu_temp_sensor2, "CPU6_DIE_TEMPERATURE_SENSOR",
                    MAX_TEMP_SENSOR_SIZE);

                strlcpy(zulu_temp_sensor1, "ZULU4_DIE_TEMPERATURE_SENSOR",
                    MAX_TEMP_SENSOR_SIZE);
                strlcpy(zulu_temp_sensor2, "ZULU6_DIE_TEMPERATURE_SENSOR",
                    MAX_TEMP_SENSOR_SIZE);
        }


        /*
         * If the module in the CPU slot is a Zulu (XVR-4000), then
         * location 0x1EB0 in its FRUid prom has a value 0xFB.
         * If Zulu (XVR-4000) is detected, delete the CPU node, otherwise
         * delete the Zulu node. Also set the temperature sensor value to
         * HOTPLUGGED for absent temperature sensors.
         */
        if ((module_card & 0xff) == 0xfb) {
                status = set_temp_sensor_properties(hdlp, cpu_temp_sensor1);
                if (status == PSVC_FAILURE) {
                        return (status);
                }

                status = set_temp_sensor_properties(hdlp, cpu_temp_sensor2);
                if (status == PSVC_FAILURE) {
                        return (status);
                }

                /*
                 * Remove CPU node
                 */
                status = remove_module_node(hdlp, other_module_id);
                if (status == PSVC_FAILURE) {
                        return (status);
                }
        } else {
                status = set_temp_sensor_properties(hdlp, zulu_temp_sensor1);
                if (status == PSVC_FAILURE) {
                        return (status);
                }
                status = set_temp_sensor_properties(hdlp, zulu_temp_sensor2);
                if (status == PSVC_FAILURE) {
                        return (status);
                }

                /*
                 * Remove Zulu (XVR-4000) node
                 */
                status = remove_module_node(hdlp, id);
                if (status == PSVC_FAILURE) {
                        return (status);
                }
        }

        return (PSVC_SUCCESS);
}


/*
 * Remove the CPU slot's module node
 */
int32_t
remove_module_node(psvc_opaque_t hdlp, char *id)
{
        char parent_path[256];
        picl_nodehdl_t child_node;

        /* convert name to node, and parent path */
        psvcplugin_lookup(id, parent_path, &child_node);
        /* Device removed */
        ptree_delete_node(child_node);

        return (PSVC_SUCCESS);
}


/*
 * Set absent temperature sensor values to HOTPLUGGED
 */
int32_t
set_temp_sensor_properties(psvc_opaque_t hdlp, char *id)
{
        char state[32];
        int32_t status = PSVC_SUCCESS;

        status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
        if (status == PSVC_FAILURE) {
                return (status);
        }

        if (strcmp(state, PSVC_HOTPLUGGED) != 0) {
                strcpy(state, PSVC_HOTPLUGGED);

                status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state);
                if (status == PSVC_FAILURE) {
                        return (status);
                }
        }

        return (PSVC_SUCCESS);
}