/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * This file contains the environmental PICL plug-in module.
 */

/*
 * This plugin sets up the PICLTREE for Chicago WS.
 * It provides functionality to get/set temperatures and
 * fan speeds.
 *
 * The environmental policy defaults to the auto mode
 * as programmed by OBP at boot time.
 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/sysmacros.h>
#include <limits.h>
#include <string.h>
#include <strings.h>
#include <stdarg.h>
#include <alloca.h>
#include <unistd.h>
#include <sys/processor.h>
#include <syslog.h>
#include <errno.h>
#include <fcntl.h>
#include <picl.h>
#include <picltree.h>
#include <picldefs.h>
#include <pthread.h>
#include <signal.h>
#include <libdevinfo.h>
#include <sys/pm.h>
#include <sys/open.h>
#include <sys/time.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include <note.h>
#include <sys/pic16f747.h>
#include "envd.h"
#include <sys/scsi/scsi.h>
#include <sys/scsi/generic/commands.h>

int     debug_fd;
/*
 * PICL plugin entry points
 */
static void piclenvd_register(void);
static void piclenvd_init(void);
static void piclenvd_fini(void);

/*
 * Env setup routines
 */
extern void env_picl_setup(void);
extern void env_picl_destroy(void);
extern int env_picl_setup_tuneables(void);

static boolean_t has_fan_failed(env_fan_t *fanp);

/*
 * PSU fan fault handling
 */
static boolean_t has_psufan_failed(void);
static int psufan_last_status = FAN_OK;

#pragma init(piclenvd_register)

/*
 * Plugin registration information
 */
static picld_plugin_reg_t my_reg_info = {
        PICLD_PLUGIN_VERSION,
        PICLD_PLUGIN_CRITICAL,
        "SUNW_piclenvd",
        piclenvd_init,
        piclenvd_fini,
};

#define REGISTER_INFORMATION_STRING_LENGTH      16
static char fan_rpm_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};
static char fan_status_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};

static int      scsi_log_sense(env_disk_t *diskp, uchar_t page_code,
                        void *pagebuf, uint16_t pagelen, int page_control);
static int scsi_mode_select(env_disk_t *diskp, uchar_t page_code,
                        uchar_t *pagebuf, uint16_t pagelen);

static int      get_disk_temp(env_disk_t *);

/*
 * ES Segment stuff
 */
static es_sensor_blk_t sensor_ctl[MAX_SENSORS];

/*
 * Default limits for sensors, in case ES segment is not present, or has
 * inconsistent information
 */
static es_sensor_blk_t sensor_default_ctl[MAX_SENSORS] = {
        {
            CPU0_HIGH_POWER_OFF, CPU0_HIGH_SHUTDOWN, CPU0_HIGH_WARNING,
            CPU0_LOW_WARNING, CPU0_LOW_SHUTDOWN, CPU0_LOW_POWER_OFF
        },
        {
            CPU1_HIGH_POWER_OFF, CPU1_HIGH_SHUTDOWN, CPU1_HIGH_WARNING,
            CPU1_LOW_WARNING, CPU1_LOW_SHUTDOWN, CPU1_LOW_POWER_OFF
        },
        {
            ADT7462_HIGH_POWER_OFF, ADT7462_HIGH_SHUTDOWN, ADT7462_HIGH_WARNING,
            ADT7462_LOW_WARNING, ADT7462_LOW_SHUTDOWN, ADT7462_LOW_POWER_OFF
        },
        {
            MB_HIGH_POWER_OFF, MB_HIGH_SHUTDOWN, MB_HIGH_WARNING,
            MB_LOW_WARNING, MB_LOW_SHUTDOWN, MB_LOW_POWER_OFF
        },
        {
            LM95221_HIGH_POWER_OFF, LM95221_HIGH_SHUTDOWN, LM95221_HIGH_WARNING,
            LM95221_LOW_WARNING, LM95221_LOW_SHUTDOWN, LM95221_LOW_POWER_OFF
        },
        {
            FIRE_HIGH_POWER_OFF, FIRE_HIGH_SHUTDOWN, FIRE_HIGH_WARNING,
            FIRE_LOW_WARNING, FIRE_LOW_SHUTDOWN, FIRE_LOW_POWER_OFF
        },
        {
            LSI1064_HIGH_POWER_OFF, LSI1064_HIGH_SHUTDOWN, LSI1064_HIGH_WARNING,
            LSI1064_LOW_WARNING, LSI1064_LOW_SHUTDOWN, LSI1064_LOW_POWER_OFF
        },
        {
            FRONT_PANEL_HIGH_POWER_OFF, FRONT_PANEL_HIGH_SHUTDOWN,
            FRONT_PANEL_HIGH_WARNING, FRONT_PANEL_LOW_WARNING,
            FRONT_PANEL_LOW_SHUTDOWN, FRONT_PANEL_LOW_POWER_OFF
        },
        {
            PSU_HIGH_POWER_OFF, PSU_HIGH_SHUTDOWN, PSU_HIGH_WARNING,
            PSU_LOW_WARNING, PSU_LOW_SHUTDOWN, PSU_LOW_POWER_OFF
        }
};

/*
 * Env thread variables
 */
static boolean_t  system_shutdown_started = B_FALSE;
static boolean_t  system_temp_thr_created = B_FALSE;
static pthread_t  system_temp_thr_id;
static pthread_attr_t thr_attr;
static boolean_t  disk_temp_thr_created = B_FALSE;
static pthread_t  disk_temp_thr_id;
static boolean_t  fan_thr_created = B_FALSE;
static pthread_t  fan_thr_id;

/*
 * PM thread related variables
 */
static pthread_t        pmthr_tid;      /* pmthr thread ID */
static int              pm_fd = -1;     /* PM device file descriptor */
static boolean_t        pmthr_created = B_FALSE;
static int              cur_lpstate;    /* cur low power state */

/*
 * Envd plug-in verbose flag set by SUNW_PICLENVD_DEBUG environment var
 * Setting the verbose tuneable also enables debugging for better
 * control
 */
int     env_debug = 0;

/*
 * These are debug variables for keeping track of the total number
 * of Fan and Temp sensor retries over the lifetime of the plugin.
 */
static int total_fan_retries = 0;
static int total_temp_retries = 0;

/*
 * Fan devices
 */
static env_fan_t envd_system_fan0 = {
        ENV_SYSTEM_FAN0, ENV_SYSTEM_FAN0_DEVFS, SYSTEM_FAN0_ID,
        SYSTEM_FAN_SPEED_MIN, SYSTEM_FAN_SPEED_MAX, -1, -1,
};
static env_fan_t envd_system_fan1 = {
        ENV_SYSTEM_FAN1, ENV_SYSTEM_FAN1_DEVFS, SYSTEM_FAN1_ID,
        SYSTEM_FAN_SPEED_MIN, SYSTEM_FAN_SPEED_MAX, -1, -1,
};
static env_fan_t envd_system_fan2 = {
        ENV_SYSTEM_FAN2, ENV_SYSTEM_FAN2_DEVFS, SYSTEM_FAN2_ID,
        SYSTEM_FAN_SPEED_MIN, SYSTEM_FAN_SPEED_MAX, -1, -1,
};
static env_fan_t envd_system_fan3 = {
        ENV_SYSTEM_FAN3, ENV_SYSTEM_FAN3_DEVFS, SYSTEM_FAN3_ID,
        SYSTEM_FAN_SPEED_MIN, SYSTEM_FAN_SPEED_MAX, -1, -1,
};
static env_fan_t envd_system_fan4 = {
        ENV_SYSTEM_FAN4, ENV_SYSTEM_FAN4_DEVFS, SYSTEM_FAN4_ID,
        SYSTEM_FAN_SPEED_MIN, SYSTEM_FAN_SPEED_MAX, -1, -1,
};

/*
 * Disk devices
 */
static env_disk_t envd_disk0 = {
        ENV_DISK0, ENV_DISK0_DEVFS, DISK0_PHYSPATH, DISK0_NODE_PATH,
        DISK0_ID, -1,
};
static env_disk_t envd_disk1 = {
        ENV_DISK1, ENV_DISK1_DEVFS, DISK1_PHYSPATH, DISK1_NODE_PATH,
        DISK1_ID, -1,
};
static env_disk_t envd_disk2 = {
        ENV_DISK2, ENV_DISK2_DEVFS, DISK2_PHYSPATH, DISK2_NODE_PATH,
        DISK2_ID, -1,
};
static env_disk_t envd_disk3 = {
        ENV_DISK3, ENV_DISK3_DEVFS, DISK3_PHYSPATH, DISK3_NODE_PATH,
        DISK3_ID, -1,
};

/*
 * Sensors
 */
static env_sensor_t envd_sensor_cpu0 = {
        SENSOR_CPU0, SENSOR_CPU0_DEVFS, CPU0_SENSOR_ID, -1, NULL,
};
static env_sensor_t envd_sensor_cpu1 = {
        SENSOR_CPU1, SENSOR_CPU1_DEVFS, CPU1_SENSOR_ID, -1, NULL,
};
static env_sensor_t envd_sensor_adt7462 = {
        SENSOR_ADT7462, SENSOR_ADT7462_DEVFS, ADT7462_SENSOR_ID, -1, NULL,
};
static env_sensor_t envd_sensor_mb = {
        SENSOR_MB, SENSOR_MB_DEVFS, MB_SENSOR_ID, -1, NULL,
};
static env_sensor_t envd_sensor_lm95221 = {
        SENSOR_LM95221, SENSOR_LM95221_DEVFS, LM95221_SENSOR_ID, -1, NULL,
};
static env_sensor_t envd_sensor_fire = {
        SENSOR_FIRE, SENSOR_FIRE_DEVFS, FIRE_SENSOR_ID, -1, NULL,
};
static env_sensor_t envd_sensor_lsi1064 = {
        SENSOR_LSI1064, SENSOR_LSI1064_DEVFS, LSI1064_SENSOR_ID, -1, NULL,
};
static env_sensor_t envd_sensor_front_panel = {
        SENSOR_FRONT_PANEL, SENSOR_FRONT_PANEL_DEVFS, FRONT_PANEL_SENSOR_ID,
        -1, NULL,
};
static env_sensor_t envd_sensor_psu = {
        SENSOR_PSU, SENSOR_PSU_DEVFS, PSU_SENSOR_ID, -1, NULL,
};

/*
 * The vendor-id and device-id are the properties associated with
 * the SCSI controller. This is used to identify a particular controller
 * like LSI1064.
 */
#define VENDOR_ID       "vendor-id"
#define DEVICE_ID       "device-id"

/*
 * The implementation for SCSI disk drives to supply info. about
 * temperature is not mandatory. Hence we first determine if the
 * temperature page is supported. To do this we need to scan the list
 * of pages supported.
 */
#define SUPPORTED_LPAGES        0
#define TEMPERATURE_PAGE        0x0D
#define LOGPAGEHDRSIZE  4

/*
 * NULL terminated array of fans
 */
static env_fan_t *envd_fans[] = {
        &envd_system_fan0,
        &envd_system_fan1,
        &envd_system_fan2,
        &envd_system_fan3,
        &envd_system_fan4,
        NULL
};

/*
 * NULL terminated array of disks
 */
static env_disk_t *envd_disks[] = {
        &envd_disk0,
        &envd_disk1,
        &envd_disk2,
        &envd_disk3,
        NULL
};

/*
 * NULL terminated array of temperature sensors
 */
#define N_ENVD_SENSORS  9
static env_sensor_t *envd_sensors[] = {
        &envd_sensor_cpu0,
        &envd_sensor_cpu1,
        &envd_sensor_adt7462,
        &envd_sensor_mb,
        &envd_sensor_lm95221,
        &envd_sensor_fire,
        &envd_sensor_lsi1064,
        &envd_sensor_front_panel,
        &envd_sensor_psu,
        NULL
};

#define NOT_AVAILABLE   "NA"

/*
 * Tuneables
 */
#define ENABLE  1
#define DISABLE 0

static  int     disk_high_warn_temperature      = DISK_HIGH_WARN_TEMPERATURE;
static  int     disk_low_warn_temperature       = DISK_LOW_WARN_TEMPERATURE;
static  int     disk_high_shutdown_temperature  =
                                                DISK_HIGH_SHUTDOWN_TEMPERATURE;
static  int     disk_low_shutdown_temperature   = DISK_LOW_SHUTDOWN_TEMPERATURE;

static  int     disk_scan_interval              = DISK_SCAN_INTERVAL;
static  int     sensor_scan_interval            = SENSOR_SCAN_INTERVAL;
static  int     fan_scan_interval               = FAN_SCAN_INTERVAL;

static int get_int_val(ptree_rarg_t *parg, void *buf);
static int set_int_val(ptree_warg_t *parg, const void *buf);
static int get_string_val(ptree_rarg_t *parg, void *buf);
static int set_string_val(ptree_warg_t *parg, const void *buf);

static int      shutdown_override       = 0;
static int      sensor_warning_interval = SENSOR_WARNING_INTERVAL;
static int      sensor_warning_duration = SENSOR_WARNING_DURATION;
static int      sensor_shutdown_interval = SENSOR_SHUTDOWN_INTERVAL;
static int      disk_warning_interval   = DISK_WARNING_INTERVAL;
static int      disk_warning_duration   = DISK_WARNING_DURATION;
static int      disk_shutdown_interval  = DISK_SHUTDOWN_INTERVAL;

static int      system_temp_monitor     = 1;    /* enabled */
static int      fan_monitor             = 1;    /* enabled */
static int      pm_monitor              = 1;    /* enabled */

/* Disable disk temperature monitoring until we have LSI fw support */
int             disk_temp_monitor       = 0;

static char     shutdown_cmd[] = SHUTDOWN_CMD;
const char      *iofru_devname = I2C_DEVFS "/" IOFRU_DEV;

env_tuneable_t tuneables[] = {
        {"system_temp-monitor", PICL_PTYPE_INT, &system_temp_monitor,
            &get_int_val, &set_int_val, sizeof (int)},

        {"fan-monitor", PICL_PTYPE_INT, &fan_monitor,
            &get_int_val, &set_int_val, sizeof (int)},

        {"pm-monitor", PICL_PTYPE_INT, &pm_monitor,
            &get_int_val, &set_int_val, sizeof (int)},

        {"shutdown-override", PICL_PTYPE_INT, &shutdown_override,
            &get_int_val, &set_int_val, sizeof (int)},

        {"sensor-warning-duration", PICL_PTYPE_INT,
            &sensor_warning_duration,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"disk-scan-interval", PICL_PTYPE_INT,
            &disk_scan_interval,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"fan-scan-interval", PICL_PTYPE_INT,
            &fan_scan_interval,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"sensor-scan-interval", PICL_PTYPE_INT,
            &sensor_scan_interval,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"sensor_warning-interval", PICL_PTYPE_INT, &sensor_warning_interval,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"sensor_shutdown-interval", PICL_PTYPE_INT, &sensor_shutdown_interval,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"disk_warning-interval", PICL_PTYPE_INT, &disk_warning_interval,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"disk_warning-duration", PICL_PTYPE_INT, &disk_warning_duration,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"disk_shutdown-interval", PICL_PTYPE_INT, &disk_shutdown_interval,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"shutdown-command", PICL_PTYPE_CHARSTRING, shutdown_cmd,
            &get_string_val, &set_string_val,
            sizeof (shutdown_cmd)},

        {"monitor-disk-temp", PICL_PTYPE_INT, &disk_temp_monitor,
            &get_int_val, &set_int_val, sizeof (int)},

        {"disk-high-warn-temperature", PICL_PTYPE_INT,
            &disk_high_warn_temperature, &get_int_val,
            &set_int_val, sizeof (int)},

        {"disk-low-warn-temperature", PICL_PTYPE_INT,
            &disk_low_warn_temperature, &get_int_val,
            &set_int_val, sizeof (int)},

        {"disk-high-shutdown-temperature", PICL_PTYPE_INT,
            &disk_high_shutdown_temperature, &get_int_val,
            &set_int_val, sizeof (int)},

        {"disk-low-shutdown-temperature", PICL_PTYPE_INT,
            &disk_low_shutdown_temperature, &get_int_val,
            &set_int_val, sizeof (int)},

        {"verbose", PICL_PTYPE_INT, &env_debug,
            &get_int_val, &set_int_val, sizeof (int)}
};

/*
 * We use this to figure out how many tuneables there are
 * This is variable because the publishing routine needs this info
 * in piclenvsetup.c
 */
int     ntuneables = (sizeof (tuneables)/sizeof (tuneables[0]));

/*
 * Lookup fan and return a pointer to env_fan_t data structure.
 */
env_fan_t *
fan_lookup(char *name)
{
        int             i;
        env_fan_t       *fanp;

        for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
                if (strcmp(fanp->name, name) == 0)
                        return (fanp);
        }
        return (NULL);
}

/*
 * Lookup sensor and return a pointer to env_sensor_t data structure.
 */
env_sensor_t *
sensor_lookup(char *name)
{
        env_sensor_t    *sensorp;
        int             i;

        for (i = 0; i < N_ENVD_SENSORS; ++i) {
                sensorp = envd_sensors[i];
                if (strcmp(sensorp->name, name) == 0)
                        return (sensorp);
        }
        return (NULL);
}

/*
 * Lookup disk and return a pointer to env_disk_t data structure.
 */
env_disk_t *
disk_lookup(char *name)
{
        int             i;
        env_disk_t      *diskp;

        for (i = 0; (diskp = envd_disks[i]) != NULL; i++) {
                if (strncmp(diskp->name, name, strlen(name)) == 0)
                        return (diskp);
        }
        return (NULL);
}

/*
 * Get current temperature
 * Returns -1 on error, 0 if successful
 */
int
get_temperature(env_sensor_t *sensorp, tempr_t *temp)
{
        int     fd = sensorp->fd;
        int     retval = 0;

        if (fd == -1)
                retval = -1;
        else if (ioctl(fd, PIC_GET_TEMPERATURE, temp) != 0) {

                retval = -1;

                sensorp->error++;

                if (sensorp->error == MAX_SENSOR_RETRIES) {
                        envd_log(LOG_WARNING, ENV_SENSOR_ACCESS_FAIL,
                            sensorp->name, errno, strerror(errno));
                }

                total_temp_retries++;
                (void) sleep(1);

        } else if (sensorp->error != 0) {
                if (sensorp->error >= MAX_SENSOR_RETRIES) {
                        envd_log(LOG_WARNING, ENV_SENSOR_ACCESS_OK,
                            sensorp->name);
                }

                sensorp->error = 0;

                if (total_temp_retries && env_debug) {
                        envd_log(LOG_WARNING,
                            "Total retries for sensors = %d",
                            total_temp_retries);
                }
        }

        return (retval);
}

/*
 * Get current disk temperature
 * Returns -1 on error, 0 if successful
 */
int
disk_temperature(env_disk_t *diskp, tempr_t *temp)
{
        int     retval = 0;

        if (diskp == NULL)
                retval = -1;
        else
                *temp = diskp->current_temp;

        return (retval);
}

/*
 * Get current fan speed
 * This function returns a RPM value for fanspeed
 * in fanspeedp.
 * Returns -1 on error, 0 if successful
 */
int
get_fan_speed(env_fan_t *fanp, fanspeed_t *fanspeedp)
{
        uint8_t tach;
        int     real_tach;
        int     retries;

        if (fanp->fd == -1)
                return (-1);

        if (has_fan_failed(fanp)) {
                *fanspeedp = 0;
                return (0);
        }

        /* try to read the fan information */
        for (retries = 0; retries < MAX_FAN_RETRIES; retries++) {
                if (ioctl(fanp->fd, PIC_GET_FAN_SPEED, &tach) == 0)
                        break;
                (void) sleep(1);
        }

        total_fan_retries += retries;
        if (retries >= MAX_FAN_RETRIES)
                return (-1);

        if (total_fan_retries && env_debug) {
                envd_log(LOG_WARNING, "total retries for fan = %d",
                    total_fan_retries);
        }

        real_tach = tach << 8;
        *fanspeedp = TACH_TO_RPM(real_tach);
        return (0);
}

/*
 * Set fan speed
 * This function accepts a percentage of fan speed
 * from 0-100 and programs the HW monitor fans to the corresponding
 * fanspeed value.
 * Returns -1 on error, -2 on invalid args passed, 0 if successful
 */
int
set_fan_speed(env_fan_t *fanp, fanspeed_t fanspeed)
{
        uint8_t speed;

        if (fanp->fd == -1)
                return (-1);

        if (fanspeed < 0 || fanspeed > 100)
                return (-2);

        speed = fanspeed;
        if (ioctl(fanp->fd, PIC_SET_FAN_SPEED, &speed) != 0)
                return (-1);

        return (0);
}

/*
 * close all fan devices
 */
static void
envd_close_fans(void)
{
        int             i;
        env_fan_t       *fanp;

        for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
                if (fanp->fd != -1) {
                        (void) close(fanp->fd);
                        fanp->fd = -1;
                }
        }
}

/*
 * Close sensor devices and freeup resources
 */
static void
envd_close_sensors(void)
{
        env_sensor_t    *sensorp;
        int             i;

        for (i = 0; i < N_ENVD_SENSORS; ++i) {
                sensorp = envd_sensors[i];
                if (sensorp->fd != -1) {
                        (void) close(sensorp->fd);
                        sensorp->fd = -1;
                }
        }
}

/*
 * Open fan devices and initialize per fan data structure.
 */
static int
envd_setup_fans(void)
{
        int             i, fd;
        env_fan_t       *fanp;
        int             fancnt = 0;
        picl_nodehdl_t tnodeh;

        for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
                fanp->last_status = FAN_OK;

                /* Make sure cpu0/1 present for validating cpu fans */
                if (fanp->id == CPU0_FAN_ID) {
                        if (ptree_get_node_by_path(CPU0_PATH, &tnodeh) !=
                            PICL_SUCCESS) {
                                        if (env_debug) {
                                                envd_log(LOG_ERR,
                                        "get node by path failed for %s\n",
                                                    CPU0_PATH);
                                        }
                                        fanp->present = B_FALSE;
                                        continue;
                        }
                }
                if (fanp->id == CPU1_FAN_ID) {
                        if (ptree_get_node_by_path(CPU1_PATH, &tnodeh) !=
                            PICL_SUCCESS) {
                                        if (env_debug) {
                                                envd_log(LOG_ERR,
                                "get node by path failed for %s\n", CPU0_PATH);
                                        }
                                        fanp->present = B_FALSE;
                                        continue;
                        }
                }
                if ((fd = open(fanp->devfs_path, O_RDWR)) == -1) {
                        envd_log(LOG_CRIT,
                            ENV_FAN_OPEN_FAIL, fanp->name,
                            fanp->devfs_path, errno, strerror(errno));
                        fanp->present = B_FALSE;
                        continue;
                }
                fanp->fd = fd;
                fanp->present = B_TRUE;
                fancnt++;
        }

        if (fancnt == 0)
                return (-1);

        return (0);
}

static int
envd_setup_disks(void)
{
        int     ret, i, page_index, page_len;
        picl_nodehdl_t tnodeh;
        env_disk_t      *diskp;
        uint_t  vendor_id;
        uint_t  device_id;
        uchar_t log_page[256];

        if (ptree_get_node_by_path(SCSI_CONTROLLER_NODE_PATH,
            &tnodeh) != PICL_SUCCESS) {
                if (env_debug) {
                        envd_log(LOG_ERR, "On-Board SCSI controller %s "
                            "not found in the system.\n",
                            SCSI_CONTROLLER_NODE_PATH);
                }
                return (-1);
        }

        if ((ret = ptree_get_propval_by_name(tnodeh, VENDOR_ID,
            &vendor_id, sizeof (vendor_id))) != 0) {
                if (env_debug) {
                        envd_log(LOG_ERR, "Error in getting vendor-id "
                            "for SCSI controller. ret = %d errno = 0x%d\n",
                            ret, errno);
                }
                return (-1);
        }
        if ((ret = ptree_get_propval_by_name(tnodeh, DEVICE_ID,
            &device_id, sizeof (device_id))) != 0) {
                if (env_debug) {
                        envd_log(LOG_ERR, "Error in getting device-id "
                            "for SCSI controller. ret = %d errno = 0x%d\n",
                            ret, errno);
                }
                return (-1);
        }

        /*
         * We have found LSI1064 SCSi controller onboard.
         */
        for (i = 0; (diskp = envd_disks[i]) != NULL; i++) {
                if (ptree_get_node_by_path(diskp->nodepath,
                    &tnodeh) != PICL_SUCCESS) {
                        diskp->present = B_FALSE;
                        if (env_debug) {
                                envd_log(LOG_ERR,
                                    "DISK %d: %s not found in the system.\n",
                                    diskp->id, diskp->nodepath);
                        }
                        continue;
                }
                if ((diskp->fd = open(diskp->devfs_path, O_RDONLY)) == -1) {
                        diskp->present = B_FALSE;
                        if (env_debug) {
                                envd_log(LOG_ERR,
                                    "Error in opening %s errno = 0x%x\n",
                                    diskp->devfs_path, errno);
                        }
                        continue;
                }
                diskp->present = B_TRUE;
                diskp->tpage_supported = B_FALSE;
                diskp->smart_supported = B_FALSE;
                diskp->warning_tstamp = 0;
                diskp->shutdown_tstamp = 0;
                diskp->high_warning = disk_high_warn_temperature;
                diskp->low_warning = disk_low_warn_temperature;
                diskp->high_shutdown = disk_high_shutdown_temperature;
                diskp->low_shutdown = disk_low_shutdown_temperature;
                /*
                 * Find out if the Temperature page is supported by the disk.
                 */
                if (scsi_log_sense(diskp, SUPPORTED_LPAGES, log_page,
                    sizeof (log_page), 1) == 0) {

                        page_len = ((log_page[2] << 8) & 0xFF00) | log_page[3];

                        for (page_index = LOGPAGEHDRSIZE;
                            page_index < page_len + LOGPAGEHDRSIZE;
                            page_index++) {
                                if (log_page[page_index] != TEMPERATURE_PAGE)
                                        continue;

                                diskp->tpage_supported = B_TRUE;
                                if (env_debug) {
                                        envd_log(LOG_ERR,
                                            "tpage supported for %s\n",
                                            diskp->nodepath);
                                }
                        }
                }
                /*
                 * If the temp log page failed, we can check if this is
                 * a SATA drive and attempt to read the temperature
                 * using the SMART interface.
                 */
                if (diskp->tpage_supported != B_TRUE) {
                        uchar_t iec_page[IEC_PAGE_SIZE];

                        if (env_debug)
                                envd_log(LOG_ERR, "Turning on SMART\n");

                        (void) memset(iec_page, 0, sizeof (iec_page));
                        iec_page[0] = IEC_PAGE; /* SMART PAGE */
                        iec_page[1] = 0xa;      /* length */
                        /* Notification, only when requested */
                        iec_page[3] = REPORT_ON_REQUEST;

                        ret = scsi_mode_select(diskp, IEC_PAGE,
                            iec_page, sizeof (iec_page));

                        /*
                         * Since we know this is a SMART capable
                         * drive, we will try to set the page and
                         * determine if the drive is not capable
                         * of reading the TEMP page when we
                         * try to read the temperature and disable
                         * it then. We do not fail when reading
                         * or writing this page because we will
                         * determine the SMART capabilities
                         * when reading the temperature.
                         */
                        if ((ret != 0) && (env_debug)) {
                                envd_log(LOG_ERR,
                                    "Failed to set mode page");
                        }

                        diskp->smart_supported = B_TRUE;
                        diskp->tpage_supported = B_TRUE;
                }

                if (get_disk_temp(diskp) < 0) {
                        envd_log(LOG_ERR, " error reading temperature of:%s\n",
                            diskp->name);
                } else if (env_debug) {
                        envd_log(LOG_ERR, "%s: temperature = %d\n",
                            diskp->name, diskp->current_temp);
                }

        }

        return (0);
}

static int
envd_es_setup(void)
{
        seeprom_scn_t   scn_hdr;
        seeprom_seg_t   seg_hdr;
        es_data_t       *envseg;
        es_sensor_t     *sensorp;
        int             i, fd, id;
        int             envseg_len, esd_len;
        char            *envsegp;

        /*
         * Open the front io fru
         */
        if ((fd = open(iofru_devname, O_RDONLY)) == -1) {
                envd_log(LOG_ERR, ENV_FRU_OPEN_FAIL, iofru_devname, errno);
                return (-1);
        }

        /*
         * Read section header from the fru SEEPROM
         */
        if (lseek(fd, SSCN_OFFSET, SEEK_SET) == (off_t)-1 ||
            read(fd, &scn_hdr, sizeof (scn_hdr)) != sizeof (scn_hdr)) {
                envd_log(LOG_ERR, ENV_FRU_BAD_ENVSEG, iofru_devname);
                (void) close(fd);
                return (-1);
        }
        if ((scn_hdr.sscn_tag != SSCN_TAG) ||
            (GET_UNALIGN16(&scn_hdr.sscn_ver) != SSCN_VER)) {
                envd_log(LOG_ERR, ENV_FRU_BAD_SCNHDR, scn_hdr.sscn_tag,
                    GET_UNALIGN16(&scn_hdr.sscn_ver));
                (void) close(fd);
                return (-1);
        }

        /*
         * Locate environmental segment
         */
        for (i = 0; i < scn_hdr.sscn_nsegs; i++) {
                if (read(fd, &seg_hdr, sizeof (seg_hdr)) != sizeof (seg_hdr)) {
                        envd_log(LOG_ERR, ENV_FRU_BAD_ENVSEG, iofru_devname);
                        (void) close(fd);
                        return (-1);
                }

                if (env_debug) {
                        envd_log(LOG_INFO,
                            "Seg name: %x off:%x len:%x\n",
                            GET_UNALIGN16(&seg_hdr.sseg_name),
                            GET_UNALIGN16(&seg_hdr.sseg_off),
                            GET_UNALIGN16(&seg_hdr.sseg_len));
                }

                if (GET_UNALIGN16(&seg_hdr.sseg_name) == ENVSEG_NAME)
                        break;
        }
        if (i == scn_hdr.sscn_nsegs) {
                envd_log(LOG_ERR, ENV_FRU_BAD_ENVSEG, iofru_devname);
                (void) close(fd);
                return (-1);
        }

        /*
         * Read environmental segment
         */
        envseg_len = GET_UNALIGN16(&seg_hdr.sseg_len);
        if ((envseg = malloc(envseg_len)) == NULL) {
                envd_log(LOG_ERR, ENV_FRU_NOMEM_FOR_SEG, envseg_len);
                (void) close(fd);
                return (-1);
        }

        if (lseek(fd, (off_t)GET_UNALIGN16(&seg_hdr.sseg_off),
            SEEK_SET) == (off_t)-1 ||
            read(fd, envseg, envseg_len) != envseg_len) {
                envd_log(LOG_ERR, ENV_FRU_BAD_ENVSEG, iofru_devname);
                free(envseg);
                (void) close(fd);
                return (-1);
        }

        /*
         * Check environmental segment data for consistency
         */
        esd_len = sizeof (*envseg) +
            (envseg->esd_nsensors - 1) * sizeof (envseg->esd_sensors[0]);
        if (envseg->esd_ver != ENVSEG_VERSION || envseg_len < esd_len) {
                envd_log(LOG_ERR, ENV_FRU_BAD_ENVSEG, iofru_devname);
                free(envseg);
                (void) close(fd);
                return (-1);
        }

        /*
         * Process environmental segment data
         */
        if (envseg->esd_nsensors > MAX_SENSORS) {
                envd_log(LOG_ERR, ENV_FRU_BAD_ENVSEG, iofru_devname);
                free(envseg);
                (void) close(fd);
                return (-1);
        }

        sensorp = &(envseg->esd_sensors[0]);
        envsegp = (char *)envseg;
        for (i = 0; i < envseg->esd_nsensors; i++) {
                uint32_t ess_id;

                (void) memcpy(&ess_id,
                    sensorp->ess_id, sizeof (sensorp->ess_id));

                if (env_debug) {
                        envd_log(LOG_INFO, "\n Sensor Id %x offset %x",
                            ess_id, sensorp->ess_off);
                }
                if (ess_id >= MAX_SENSORS) {
                        envd_log(LOG_ERR, ENV_FRU_BAD_ENVSEG, iofru_devname);
                        free(envseg);
                        (void) close(fd);
                        return (-1);
                }
                (void) memcpy(&sensor_ctl[ess_id], &envsegp[sensorp->ess_off],
                    sizeof (es_sensor_blk_t));

                sensorp++;
        }

        /*
         * Match sensor/ES id and point to correct data based on IDs
         */
        for (i = 0; i < N_ENVD_SENSORS; i++) {
                id = envd_sensors[i]->id;
                envd_sensors[i]->es = &sensor_ctl[id];
        }

        /*
         * Cleanup and return
         */
        free(envseg);
        (void) close(fd);

        return (0);
}

static void
envd_es_default_setup(void)
{
        int     i, id;

        for (i = 0; i < N_ENVD_SENSORS; i++) {
                id = envd_sensors[i]->id;
                envd_sensors[i]->es = &sensor_default_ctl[id];
        }
}

/*
 * Open temperature sensor devices and initialize per sensor data structure.
 */
static int
envd_setup_sensors(void)
{
        env_sensor_t    *sensorp;
        int             sensorcnt = 0;
        int             i;
        picl_nodehdl_t  tnodeh;

        for (i = 0; i < N_ENVD_SENSORS; i++) {
                if (env_debug)
                        envd_log(LOG_ERR, "scanning sensor %d\n", i);

                sensorp = envd_sensors[i];

                /* Initialize sensor's initial state */
                sensorp->shutdown_initiated = B_FALSE;
                sensorp->warning_tstamp = 0;
                sensorp->shutdown_tstamp = 0;
                sensorp->error = 0;

                /* Make sure cpu0/1 sensors are present */
                if (sensorp->id == CPU0_SENSOR_ID) {
                        if (ptree_get_node_by_path(CPU0_PATH, &tnodeh) !=
                            PICL_SUCCESS) {
                                if (env_debug) {
                                        envd_log(LOG_ERR,
                                            "get node by path failed for %s\n",
                                            CPU0_PATH);
                                }
                                sensorp->present = B_FALSE;
                                continue;
                        }
                }
                if (sensorp->id == CPU1_SENSOR_ID) {
                        if (ptree_get_node_by_path(CPU1_PATH, &tnodeh) !=
                            PICL_SUCCESS) {
                                if (env_debug) {
                                        envd_log(LOG_ERR,
                                            "get node by path failed for %s\n",
                                            CPU1_PATH);
                                }
                                sensorp->present = B_FALSE;
                                continue;
                        }
                }

                sensorp->fd = open(sensorp->devfs_path, O_RDWR);
                if (sensorp->fd == -1) {
                        if (env_debug) {
                                envd_log(LOG_ERR, ENV_SENSOR_OPEN_FAIL,
                                    sensorp->name, sensorp->devfs_path,
                                    errno, strerror(errno));
                        }
                        sensorp->present = B_FALSE;
                        continue;
                }

                /*
                 * Determine if the front panel is attached, we want the
                 * information if it exists, but should not shut down
                 * the system if it is removed.
                 */
                if (sensorp->id == FRONT_PANEL_SENSOR_ID) {
                        tempr_t temp;
                        int     tries;

                        for (tries = 0; tries < MAX_SENSOR_RETRIES; tries++) {
                                if (ioctl(sensorp->fd, PIC_GET_TEMPERATURE,
                                    &temp) == 0) {
                                        break;
                                }
                                (void) sleep(1);
                        }
                        if (tries == MAX_SENSOR_RETRIES)
                                sensorp->present = B_FALSE;
                }

                sensorp->present = B_TRUE;
                sensorcnt++;
        }

        if (sensorcnt == 0)
                return (-1);

        return (0);
}

/* ARGSUSED */
static void *
pmthr(void *args)
{
        pm_state_change_t       pmstate;
        char                    physpath[PATH_MAX];
        int                     pre_lpstate;
        uint8_t                 estar_state;
        int                     env_monitor_fd;

        pmstate.physpath = physpath;
        pmstate.size = sizeof (physpath);
        cur_lpstate = 0;
        pre_lpstate = 1;

        pm_fd = open(PM_DEVICE, O_RDWR);
        if (pm_fd == -1) {
                envd_log(LOG_ERR, PM_THREAD_EXITING, errno, strerror(errno));
                return (NULL);
        }
        for (;;) {
                /*
                 * Get PM state change events to check if the system
                 * is in lowest power state and inform PIC which controls
                 * fan speeds.
                 *
                 * To minimize polling, we use the blocking interface
                 * to get the power state change event here.
                 */
                if (ioctl(pm_fd, PM_GET_STATE_CHANGE_WAIT, &pmstate) != 0) {
                        if (errno != EINTR)
                                break;
                        continue;
                }

                do {
                        if (env_debug)  {
                                envd_log(LOG_INFO,
                                "pmstate event:0x%x flags:%x"
                                "comp:%d oldval:%d newval:%d path:%s\n",
                                    pmstate.event, pmstate.flags,
                                    pmstate.component,
                                    pmstate.old_level,
                                    pmstate.new_level,
                                    pmstate.physpath);
                        }
                        cur_lpstate =
                            (pmstate.flags & PSC_ALL_LOWEST) ? 1 : 0;
                } while (ioctl(pm_fd, PM_GET_STATE_CHANGE, &pmstate) == 0);

                if (pre_lpstate != cur_lpstate) {
                        pre_lpstate = cur_lpstate;
                        estar_state = (cur_lpstate & 0x1);
                        if (env_debug)
                                envd_log(LOG_ERR,
                                    "setting PIC ESTAR SATE to %x\n",
                                    estar_state);

                        env_monitor_fd = open(ENV_MONITOR_DEVFS, O_RDWR);
                        if (env_monitor_fd != -1) {
                                if (ioctl(env_monitor_fd, PIC_SET_ESTAR_MODE,
                                    &estar_state) < 0) {
                                        if (env_debug)
                                                envd_log(LOG_ERR,
                                        "unable to set ESTAR_MODE in PIC\n");
                                }
                                (void) close(env_monitor_fd);
                        } else {
                                if (env_debug)
                                        envd_log(LOG_ERR,
                                "Failed to open %s\n",
                                            ENV_MONITOR_DEVFS);
                        }
                }
        }

        /*NOTREACHED*/
        return (NULL);
}

/*
 * This is env thread which monitors the current temperature when
 * warning threshold is exceeded. The job is to make sure it does
 * not execced/decrease shutdown threshold. If it does it will start
 * forced shutdown to avoid reaching hardware poweroff via THERM interrupt.
 */
/*ARGSUSED*/
static void *
system_temp_thr(void *args)
{
        char syscmd[BUFSIZ];
        char msgbuf[BUFSIZ];
        timespec_t      to;
        int     ret, i;
        env_sensor_t    *sensorp;
        pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
        pthread_cond_t  env_monitor_cv = PTHREAD_COND_INITIALIZER;
        time_t  ct;
        tempr_t  temp;

        for (;;) {
                /*
                 * Sleep for specified seconds before issuing IOCTL
                 * again.
                 */
                (void) pthread_mutex_lock(&env_monitor_mutex);
                ret = pthread_cond_reltimedwait_np(&env_monitor_cv,
                    &env_monitor_mutex, &to);
                to.tv_sec = sensor_scan_interval;
                to.tv_nsec = 0;
                if (ret != ETIMEDOUT) {
                        (void) pthread_mutex_unlock(&env_monitor_mutex);
                        continue;
                }

                (void) pthread_mutex_unlock(&env_monitor_mutex);
                for (i = 0; i < N_ENVD_SENSORS; i++) {
                        sensorp = envd_sensors[i];
                        if (sensorp->present == B_FALSE)
                                continue;
                        if (get_temperature(sensorp, &temp) == -1)
                                continue;

                        sensorp->cur_temp = temp;
                        if (env_debug) {
                                envd_log(LOG_ERR,
                                "%s temp = %d",
                                    sensorp->name, sensorp->cur_temp);
                        }

                        /*
                         * If this sensor already triggered system shutdown,
                         * don't log any more shutdown/warning messages for it.
                         */
                        if (sensorp->shutdown_initiated)
                                continue;

                        /*
                         * Check for the temperature in warning and shutdown
                         * range and take appropriate action.
                         */
                        if (SENSOR_TEMP_IN_WARNING_RANGE(sensorp->cur_temp,
                            sensorp)) {
                                /*
                                 * Check if the temperature has been in
                                 * warning range during last
                                 * sensor_warning_duration interval. If so,
                                 * the temperature is truly in warning range
                                 * and we need to log a warning message, but
                                 * no more than once every
                                 * sensor_warning_interval seconds.
                                 */
                                time_t  wtstamp = sensorp->warning_tstamp;

                                ct = (time_t)(gethrtime() / NANOSEC);
                                if (sensorp->warning_start == 0)
                                        sensorp->warning_start = ct;
                                if (((ct - sensorp->warning_start) >=
                                    sensor_warning_duration) &&
                                    (wtstamp == 0 || (ct - wtstamp) >=
                                    sensor_warning_interval)) {
                                        envd_log(LOG_CRIT, ENV_WARNING_MSG,
                                            sensorp->name, sensorp->cur_temp,
                                            (int8_t)
                                            sensorp->es->esb_low_warning,
                                            (int8_t)
                                            sensorp->es->esb_high_warning);

                                        sensorp->warning_tstamp = ct;
                                }
                        } else if (sensorp->warning_start != 0)
                                sensorp->warning_start = 0;

                        if (!shutdown_override &&
                            SENSOR_TEMP_IN_SHUTDOWN_RANGE(sensorp->cur_temp,
                            sensorp)) {
                                ct = (time_t)(gethrtime() / NANOSEC);
                                if (sensorp->shutdown_tstamp == 0)
                                        sensorp->shutdown_tstamp = ct;

                                /*
                                 * Shutdown the system if the temperature
                                 * remains in the shutdown range for over
                                 * sensor_shutdown_interval seconds.
                                 */
                                if ((ct - sensorp->shutdown_tstamp) >=
                                    sensor_shutdown_interval) {
                                        /*
                                         * Log error
                                         */
                                        sensorp->shutdown_initiated = B_TRUE;

                                        (void) snprintf(msgbuf, sizeof (msgbuf),
                                            ENV_SHUTDOWN_MSG, sensorp->name,
                                            sensorp->cur_temp,
                                            (int8_t)
                                            sensorp->es->esb_low_shutdown,
                                            (int8_t)
                                            sensorp->es->esb_high_shutdown);

                                        envd_log(LOG_ALERT, msgbuf);

                                        /*
                                         * Shutdown the system (only once)
                                         */
                                        if (system_shutdown_started ==
                                            B_FALSE) {
                                                (void) snprintf(syscmd,
                                                    sizeof (syscmd),
                                                    "%s \"%s\"", shutdown_cmd,
                                                    msgbuf);

                                                envd_log(LOG_ALERT, syscmd);
                                                system_shutdown_started =
                                                    B_TRUE;

                                                (void) system(syscmd);
                                        }
                                }
                        } else if (sensorp->shutdown_tstamp != 0)
                                sensorp->shutdown_tstamp = 0;
                }
        }       /* end of forever loop */

        /*NOTREACHED*/
        return (NULL);
}

static int
scsi_log_sense(env_disk_t *diskp, uchar_t page_code, void *pagebuf,
                uint16_t pagelen, int page_control)
{
        struct uscsi_cmd        ucmd_buf;
        uchar_t         cdb_buf[CDB_GROUP1];
        struct  scsi_extended_sense     sense_buf;
        int     ret_val;

        bzero(&cdb_buf, sizeof (cdb_buf));
        bzero(&ucmd_buf, sizeof (ucmd_buf));
        bzero(&sense_buf, sizeof (sense_buf));

        cdb_buf[0] = SCMD_LOG_SENSE_G1;

        /*
         * For SATA we need to have the current threshold value set.
         * For SAS drives we can use the current cumulative value.
         * This is set for non-SMART drives, by passing a non-zero
         * page_control.
         */
        if (page_control)
                cdb_buf[2] = (0x01 << 6) | page_code;
        else
                cdb_buf[2] = page_code;

        cdb_buf[7] = (uchar_t)((pagelen & 0xFF00) >> 8);
        cdb_buf[8] = (uchar_t)(pagelen  & 0x00FF);

        ucmd_buf.uscsi_cdb = (char *)cdb_buf;
        ucmd_buf.uscsi_cdblen = sizeof (cdb_buf);
        ucmd_buf.uscsi_bufaddr = (caddr_t)pagebuf;
        ucmd_buf.uscsi_buflen = pagelen;
        ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
        ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
        ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
        ucmd_buf.uscsi_timeout = DEFAULT_SCSI_TIMEOUT;

        ret_val = ioctl(diskp->fd, USCSICMD, ucmd_buf);
        if ((ret_val == 0) && (ucmd_buf.uscsi_status == 0)) {
                if (env_debug)
                        envd_log(LOG_ERR,
                "log sense command for page_code 0x%x succeeded\n", page_code);
                return (ret_val);
        }
        if (env_debug)
                envd_log(LOG_ERR, "log sense command for %s failed. "
                    "page_code 0x%x ret_val = 0x%x "
                    "status = 0x%x errno = 0x%x\n", diskp->name, page_code,
                    ret_val, ucmd_buf.uscsi_status, errno);

        return (1);
}


static int
get_disk_temp(env_disk_t *diskp)
{
        int     ret;
        uchar_t tpage[256];

        if (diskp->smart_supported == B_TRUE) {
                smart_structure smartpage;
                smart_attribute *temp_attrib = NULL;
                uint8_t         checksum;
                uint8_t         *index;
                int             i;

                bzero(&smartpage, sizeof (smartpage));

                ret = scsi_log_sense(diskp, GET_SMART_INFO,
                    &smartpage, sizeof (smartpage), 0);

                if (ret != 0) {
                        diskp->current_temp = DISK_INVALID_TEMP;
                        diskp->ref_temp = DISK_INVALID_TEMP;
                        return (-1);
                }

                /*
                 * verify the checksum of the data. A 2's compliment
                 * of the result addition of the is stored in the
                 * last byte. The sum of all the checksum should be
                 * 0. If the checksum is bad, return an error for
                 * this iteration.
                 */
                index = (uint8_t *)&smartpage;

                for (i = checksum = 0; i < 512; i++)
                        checksum += index[i];

                if ((checksum != 0) && env_debug) {
                        envd_log(LOG_ERR,
                            "SMART checksum error! 0x%x\n", checksum);

                        /*
                         * We got bad data back from the drive, fail this
                         * time around and picl will retry again. If this
                         * continues to fail picl will give this drive a
                         * failed status.
                         */
                        diskp->current_temp = DISK_INVALID_TEMP;
                        diskp->ref_temp = DISK_INVALID_TEMP;

                        return (-1);
                }

                /*
                 * Scan through the various SMART data and look for
                 * the complete drive temp.
                 */

                for (i = 0; (i < SMART_FIELDS) &&
                    (smartpage.attribute[i].id != 0) &&
                    (temp_attrib == NULL); i++) {

                        if (smartpage.attribute[i].id == HDA_TEMP) {
                                temp_attrib = &smartpage.attribute[i];
                        }
                }

                /*
                 * If we dont find any temp SMART attributes, this drive
                 * does not support this page, disable temp checking
                 * for this drive.
                 */
                if (temp_attrib == NULL) {

                        /*
                         * If the checksum is valid, the temp. attributes are
                         * not supported, disable this drive from temp.
                         * checking.
                         */
                        if (env_debug)
                                envd_log(LOG_ERR,
                                    "Temp ATTRIBUTE not supported\n");
                        diskp->smart_supported = B_FALSE;
                        diskp->tpage_supported = B_FALSE;
                        diskp->current_temp = DISK_INVALID_TEMP;
                        diskp->ref_temp = DISK_INVALID_TEMP;

                        return (-1);
                }

                if (env_debug) {
                        envd_log(LOG_ERR, "flags = 0x%x%x,curr = 0x%x,"
                            "data = 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
                            temp_attrib->flags[0], temp_attrib->flags[1],
                            temp_attrib->raw_data[0], temp_attrib->raw_data[1],
                            temp_attrib->raw_data[2], temp_attrib->raw_data[3],
                            temp_attrib->raw_data[4], temp_attrib->raw_data[5],
                            temp_attrib->raw_data[6], temp_attrib->raw_data[7]);
                }
                if (temp_attrib->raw_data[1] != 0xFF) {
                        diskp->current_temp = temp_attrib->raw_data[2];
                        diskp->ref_temp = temp_attrib->raw_data[2];
                } else {
                        diskp->ref_temp = DISK_INVALID_TEMP;
                        diskp->current_temp = DISK_INVALID_TEMP;

                        return (-1);
                }

        } else {
                ret = scsi_log_sense(diskp, TEMPERATURE_PAGE, tpage,
                    sizeof (tpage), 1);

                if (ret != 0) {
                        diskp->current_temp = DISK_INVALID_TEMP;
                        diskp->ref_temp = DISK_INVALID_TEMP;
                        return (-1);
                }
                /*
                 * For the current temperature verify that the parameter
                 * length is 0x02 and the parameter code is 0x00
                 * Temperature value of 255(0xFF) is considered INVALID.
                 */
                if ((tpage[7] == 0x02) && (tpage[4] == 0x00) &&
                    (tpage[5] == 0x00)) {
                        if (tpage[9] == 0xFF) {
                                diskp->current_temp = DISK_INVALID_TEMP;
                                return (-1);
                        } else {
                                diskp->current_temp = tpage[9];
                        }
                }

                /*
                 * For the reference temperature verify that the parameter
                 * length is 0x02 and the parameter code is 0x01
                 * Temperature value of 255(0xFF) is considered INVALID.
                 */
                if ((tpage[13] == 0x02) && (tpage[10] == 0x00) &&
                    (tpage[11] == 0x01)) {
                        if (tpage[15] == 0xFF) {
                                diskp->ref_temp = DISK_INVALID_TEMP;
                        } else {
                                diskp->ref_temp = tpage[15];
                        }
                }
        }
        return (0);
}

/* ARGSUSED */
static void *
disk_temp_thr(void *args)
{
        char syscmd[BUFSIZ];
        char msgbuf[BUFSIZ];
        timespec_t      to;
        int     ret, i;
        env_disk_t      *diskp;
        pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
        pthread_cond_t  env_monitor_cv = PTHREAD_COND_INITIALIZER;
        pm_state_change_t       pmstate;
        int     idle_time;
        int     disk_pm_fd;
        time_t  ct;

        if ((disk_pm_fd = open(PM_DEVICE, O_RDWR)) == -1) {
                envd_log(LOG_ERR, DISK_TEMP_THREAD_EXITING,
                    errno, strerror(errno));
                return (NULL);
        }

        for (;;) {
                /*
                 * Sleep for specified seconds before issuing IOCTL
                 * again.
                 */
                (void) pthread_mutex_lock(&env_monitor_mutex);
                ret = pthread_cond_reltimedwait_np(&env_monitor_cv,
                    &env_monitor_mutex, &to);

                to.tv_sec = disk_scan_interval;
                to.tv_nsec = 0;

                if (ret != ETIMEDOUT) {
                        (void) pthread_mutex_unlock(
                            &env_monitor_mutex);
                        continue;
                }
                (void) pthread_mutex_unlock(&env_monitor_mutex);

                for (i = 0; (diskp = envd_disks[i]) != NULL; i++) {
                        if (diskp->present == B_FALSE)
                                continue;
                        if (diskp->tpage_supported == B_FALSE)
                                continue;
                /*
                 * If the disk temperature is above the warning threshold
                 * continue monitoring until the temperature drops below
                 * warning threshold.
                 * if the temperature is in the NORMAL range monitor only
                 * when the disk is BUSY.
                 * We do not want to read the disk temperature if the disk is
                 * is idling. The reason for this is disk will never get into
                 * lowest power mode if we scan the disk temperature
                 * peridoically. To avoid this situation we first determine
                 * the idle_time of the disk. If the disk has been IDLE since
                 * we scanned the temperature last time we will not read the
                 * temperature.
                 */
                if (!DISK_TEMP_IN_WARNING_RANGE(diskp->current_temp, diskp)) {
                        pmstate.physpath = diskp->physpath;
                        pmstate.size = strlen(diskp->physpath);
                        pmstate.component = 0;
                        if ((idle_time =
                            ioctl(disk_pm_fd, PM_GET_TIME_IDLE,
                            &pmstate)) == -1) {

                                if (errno != EINTR) {
                                        if (env_debug)
                                                envd_log(LOG_ERR,
                        "ioctl PM_GET_TIME_IDLE failed for DISK0. errno=0x%x\n",
                                                    errno);
                                        continue;
                                }
                                continue;
                        }
                        if (idle_time >= (disk_scan_interval/2)) {
                                if (env_debug) {
                                        envd_log(LOG_ERR, "%s idle time = %d\n",
                                            diskp->name, idle_time);
                                }
                                continue;
                        }
                }
                ret = get_disk_temp(diskp);
                if (ret != 0)
                        continue;
                if (env_debug) {
                        envd_log(LOG_ERR, "%s temp = %d ref. temp = %d\n",
                            diskp->name, diskp->current_temp, diskp->ref_temp);
                }
                /*
                 * If this disk already triggered system shutdown, don't
                 * log any more shutdown/warning messages for it.
                 */
                if (diskp->shutdown_initiated)
                        continue;

                /*
                 * Check for the temperature in warning and shutdown range
                 * and take appropriate action.
                 */
                if (DISK_TEMP_IN_WARNING_RANGE(diskp->current_temp, diskp)) {
                        /*
                         * Check if the temperature has been in warning
                         * range during last disk_warning_duration interval.
                         * If so, the temperature is truly in warning
                         * range and we need to log a warning message,
                         * but no more than once every disk_warning_interval
                         * seconds.
                         */
                        time_t  wtstamp = diskp->warning_tstamp;

                        ct = (time_t)(gethrtime() / NANOSEC);
                        if (diskp->warning_start == 0)
                                diskp->warning_start = ct;
                        if (((ct - diskp->warning_start) >=
                            disk_warning_duration) && (wtstamp == 0 ||
                            (ct - wtstamp) >= disk_warning_interval)) {
                                envd_log(LOG_CRIT, ENV_WARNING_MSG,
                                    diskp->name, diskp->current_temp,
                                    diskp->low_warning,
                                    diskp->high_warning);
                                diskp->warning_tstamp = ct;
                        }
                } else if (diskp->warning_start != 0)
                        diskp->warning_start = 0;

                if (!shutdown_override &&
                    DISK_TEMP_IN_SHUTDOWN_RANGE(diskp->current_temp, diskp)) {
                        ct = (time_t)(gethrtime() / NANOSEC);
                        if (diskp->shutdown_tstamp == 0)
                                diskp->shutdown_tstamp = ct;

                        /*
                         * Shutdown the system if the temperature remains
                         * in the shutdown range for over disk_shutdown_interval
                         * seconds.
                         */
                        if ((ct - diskp->shutdown_tstamp) >=
                            disk_shutdown_interval) {
                                /* log error */
                                diskp->shutdown_initiated = B_TRUE;
                                (void) snprintf(msgbuf, sizeof (msgbuf),
                                    ENV_SHUTDOWN_MSG, diskp->name,
                                    diskp->current_temp, diskp->low_shutdown,
                                    diskp->high_shutdown);
                                envd_log(LOG_ALERT, msgbuf);

                                /* shutdown the system (only once) */
                                if (system_shutdown_started == B_FALSE) {
                                        (void) snprintf(syscmd, sizeof (syscmd),
                                            "%s \"%s\"", shutdown_cmd, msgbuf);
                                        envd_log(LOG_ALERT, syscmd);
                                        system_shutdown_started = B_TRUE;
                                        (void) system(syscmd);
                                }
                        }
                } else if (diskp->shutdown_tstamp != 0)
                        diskp->shutdown_tstamp = 0;
                }
        } /* end of forever loop */
}

static void *
fan_thr(void *args)
{
        char msgbuf[BUFSIZ];
        timespec_t      to;
        int     ret, i;
        pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
        pthread_cond_t  env_monitor_cv = PTHREAD_COND_INITIALIZER;
        env_fan_t       *fanp;

#ifdef  __lint
        args = args;
#endif

        for (;;) {
                /*
                 * Sleep for specified seconds before issuing IOCTL
                 * again.
                 */
                (void) pthread_mutex_lock(&env_monitor_mutex);
                ret = pthread_cond_reltimedwait_np(&env_monitor_cv,
                    &env_monitor_mutex, &to);
                to.tv_sec = fan_scan_interval;
                to.tv_nsec = 0;
                if (ret != ETIMEDOUT) {
                        (void) pthread_mutex_unlock(&env_monitor_mutex);
                        continue;
                }
                (void) pthread_mutex_unlock(&env_monitor_mutex);

                for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
                        if (fanp->present == B_FALSE)
                                continue;

                        if (has_fan_failed(fanp) == B_TRUE) {
                                if (fanp->last_status == FAN_FAILED)
                                        continue;
                                fanp->last_status = FAN_FAILED;
                                (void) snprintf(msgbuf, sizeof (msgbuf),
                                    ENV_FAN_FAILURE_WARNING_MSG, fanp->name,
                                    fan_rpm_string, fan_status_string);
                                envd_log(LOG_ALERT, msgbuf);
                        } else {
                                if (fanp->last_status == FAN_OK)
                                        continue;
                                fanp->last_status = FAN_OK;
                                (void) snprintf(msgbuf, sizeof (msgbuf),
                                    ENV_FAN_OK_MSG, fanp->name);
                                envd_log(LOG_ALERT, msgbuf);
                        }
                }

                if (has_psufan_failed() == B_TRUE) {
                        if (psufan_last_status == FAN_FAILED)
                                continue;
                        psufan_last_status = FAN_FAILED;
                        (void) snprintf(msgbuf, sizeof (msgbuf),
                            ENV_FAN_FAILURE_WARNING_MSG, SENSOR_PSU,
                            fan_rpm_string, fan_status_string);
                        envd_log(LOG_ALERT, msgbuf);
                } else {
                        if (psufan_last_status == FAN_OK)
                                continue;
                        psufan_last_status = FAN_OK;
                        (void) snprintf(msgbuf, sizeof (msgbuf),
                            ENV_FAN_OK_MSG, SENSOR_PSU);
                        envd_log(LOG_ALERT, msgbuf);
                }
        }

        /*NOTREACHED*/
        return (NULL);
}

/*
 * Setup envrionmental monitor state and start threads to monitor
 * temperature, fan, disk and power management state.
 * Returns -1 on error, 0 if successful.
 */
static int
envd_setup(void)
{

        if (getenv("SUNW_piclenvd_debug") != NULL)
                env_debug = 1;

        if (pthread_attr_init(&thr_attr) != 0 ||
            pthread_attr_setscope(&thr_attr, PTHREAD_SCOPE_SYSTEM) != 0) {
                return (-1);
        }

        /*
         * If ES segment is not present or has inconsistent information, we
         * use default values for sensor limits. For the sake of simplicity,
         * we still store these limits internally in the 'es' member in the
         * structure.
         */
        if (envd_es_setup() < 0) {
                envd_log(LOG_WARNING, ENV_DEFAULT_LIMITS);
                envd_es_default_setup();
        }

        if (envd_setup_sensors() < 0) {
                if (env_debug)
                        envd_log(LOG_ERR, "Failed to setup sensors\n");
                system_temp_monitor = 0;
        }

        if (envd_setup_fans() < 0) {
                if (env_debug)
                        envd_log(LOG_ERR, "Failed to setup fans\n");
                fan_monitor = 0;
                pm_monitor = 0;
        }

        /*
         * Disable disk temperature monitoring until we have
         * LSI fw support to read SATA disk temperature
         */
        if (disk_temp_monitor) {
                if (envd_setup_disks() < 0) {
                        if (env_debug)
                                envd_log(LOG_ERR, "Failed to setup disks\n");
                        disk_temp_monitor = 0;
                }
        }

        /*
         * Create a thread to monitor system temperatures
         */
        if ((system_temp_monitor) && (system_temp_thr_created == B_FALSE)) {
                if (pthread_create(&system_temp_thr_id, &thr_attr,
                    system_temp_thr, NULL) != 0) {
                        envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
                } else {
                        system_temp_thr_created = B_TRUE;
                        if (env_debug)
                                envd_log(LOG_ERR,
                        "Created thread to monitor system temperatures\n");
                }
        }

        /*
         * Create a thread to monitor fans
         */
        if ((fan_monitor) && (fan_thr_created == B_FALSE)) {
                if (pthread_create(&fan_thr_id, &thr_attr, fan_thr, NULL) != 0)
                        envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
                else {
                        fan_thr_created = B_TRUE;
                        if (env_debug) {
                                envd_log(LOG_ERR,
                                    "Created thread to monitor system fans\n");
                        }
                }
        }

        /*
         * Create a thread to monitor PM state
         */
        if ((pm_monitor) && (pmthr_created == B_FALSE)) {
                if (pthread_create(&pmthr_tid, &thr_attr, pmthr, NULL) != 0)
                        envd_log(LOG_CRIT, PM_THREAD_CREATE_FAILED);
                else {
                        pmthr_created = B_TRUE;
                        if (env_debug)
                                envd_log(LOG_ERR,
                        "Created thread to monitor system power state\n");
                }
        }

        /*
         * Create a thread to monitor disk temperature
         */
        if ((disk_temp_monitor) && (disk_temp_thr_created == B_FALSE)) {
                if (pthread_create(&disk_temp_thr_id, &thr_attr,
                    disk_temp_thr, NULL) != 0) {
                        envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
                } else {
                        disk_temp_thr_created = B_TRUE;
                        if (env_debug)
                                envd_log(LOG_ERR,
                        "Created thread for disk temperatures\n");
                }
        }

        return (0);
}

static void
piclenvd_register(void)
{
        picld_plugin_register(&my_reg_info);
}

static void
piclenvd_init(void)
{

        (void) env_picl_setup_tuneables();

        /*
         * Do not allow disk temperature monitoring to be enabled
         * via tuneables. Disk temperature monitoring is disabled
         * until we have LSI fw support to read the temperature of
         * SATA disks
         */
        disk_temp_monitor = 0;

        /*
         * Setup the environmental data structures
         */
        if (envd_setup() != 0) {
                envd_log(LOG_CRIT, ENVD_PLUGIN_INIT_FAILED);
                return;
        }

        /*
         * Now setup/populate PICL tree
         */
        env_picl_setup();
}

static void
piclenvd_fini(void)
{

        /*
         * Invoke env_picl_destroy() to remove any PICL nodes/properties
         * (including volatile properties) we created. Once this call
         * returns, there can't be any more calls from the PICL framework
         * to get current temperature or fan speed.
         */
        env_picl_destroy();
        envd_close_sensors();
        envd_close_fans();
}

/*VARARGS2*/
void
envd_log(int pri, const char *fmt, ...)
{
        va_list ap;

        va_start(ap, fmt);
        vsyslog(pri, fmt, ap);
        va_end(ap);
}

/*
 * Tunables support functions
 */
static env_tuneable_t *
tuneable_lookup(picl_prophdl_t proph)
{
        int i;
        env_tuneable_t  *tuneablep = NULL;

        for (i = 0; i < ntuneables; i++) {
                tuneablep = &tuneables[i];
                if (tuneablep->proph == proph)
                        return (tuneablep);
        }

        return (NULL);
}

static int
get_string_val(ptree_rarg_t *parg, void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        (void) memcpy(buf, tuneablep->value, tuneablep->nbytes);

        return (PICL_SUCCESS);
}

static int
set_string_val(ptree_warg_t *parg, const void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;

        if (parg->cred.dc_euid != 0)
                return (PICL_PERMDENIED);

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        (void) memcpy(tuneables->value, buf, tuneables->nbytes);


        return (PICL_SUCCESS);
}

static int
get_int_val(ptree_rarg_t *parg, void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        (void) memcpy(buf, tuneablep->value, tuneablep->nbytes);

        return (PICL_SUCCESS);
}

static int
set_int_val(ptree_warg_t *parg, const void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;

        if (parg->cred.dc_euid != 0)
                return (PICL_PERMDENIED);

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        (void) memcpy(tuneablep->value, buf, tuneablep->nbytes);

        return (PICL_SUCCESS);
}

boolean_t
has_fan_failed(env_fan_t *fanp)
{
        fanspeed_t      fan_speed;
        uchar_t         status;
        uint8_t         tach;
        int             real_tach;
        int             ret, ntries;

        if (fanp->fd == -1)
                return (B_TRUE);

        /*
         * Read RF_FAN_STATUS bit of the fan fault register, retry if
         * the PIC is busy, with a 1 second delay to allow it to update.
         */
        for (ntries = 0; ntries < MAX_RETRIES_FOR_FAN_FAULT; ntries++) {
                ret = ioctl(fanp->fd, PIC_GET_FAN_STATUS, &status);
                if ((ret == 0) && ((status & 0x1) == 0))
                        break;
                (void) sleep(1);
        }

        if (ntries > 0) {
                if (env_debug) {
                        envd_log(LOG_ERR,
                            "%d retries attempted in reading fan status.\n",
                            ntries);
                }
        }

        if (ntries == MAX_RETRIES_FOR_FAN_FAULT) {
                (void) strncpy(fan_status_string, NOT_AVAILABLE,
                    sizeof (fan_status_string));
                (void) strncpy(fan_rpm_string, NOT_AVAILABLE,
                    sizeof (fan_rpm_string));
                return (B_TRUE);
        }

        if (env_debug)
                envd_log(LOG_ERR, "fan status = 0x%x\n", status);

        /*
         * ST_FFAULT bit isn't implemented yet and we're reading only
         * individual fan status
         */
        if (status & 0x1) {
                (void) snprintf(fan_status_string, sizeof (fan_status_string),
                    "0x%x", status);
                if (ioctl(fanp->fd, PIC_GET_FAN_SPEED, &tach) != 0) {
                        (void) strncpy(fan_rpm_string, NOT_AVAILABLE,
                            sizeof (fan_rpm_string));
                } else {
                        real_tach = tach << 8;
                        fan_speed = TACH_TO_RPM(real_tach);
                        (void) snprintf(fan_rpm_string, sizeof (fan_rpm_string),
                            "%d", fan_speed);
                }
                return (B_TRUE);
        }

        return (B_FALSE);
}

boolean_t
has_psufan_failed(void)
{
        uchar_t         status;
        int             ret, ntries;

        if (envd_sensor_psu.fd == -1)
                return (B_FALSE);

        /*
         * For psu, only fan fault is visible, no fan speed
         */
        (void) strncpy(fan_rpm_string, NOT_AVAILABLE, sizeof (fan_rpm_string));

        /*
         * Read RF_FAN_STATUS bit of the fan fault register, retry if
         * the PIC is busy, with a 1 second delay to allow it to update.
         */
        for (ntries = 0; ntries < MAX_RETRIES_FOR_FAN_FAULT; ntries++) {
                ret = ioctl(envd_sensor_psu.fd, PIC_GET_FAN_STATUS, &status);
                if ((ret == 0) && ((status & 0x1) == 0))
                        break;
                (void) sleep(1);
        }

        if (ntries > 0) {
                if (env_debug) {
                        envd_log(LOG_ERR,
                            "%d retries attempted in reading fan status.\n",
                            ntries);
                }
        }

        if (ntries == MAX_RETRIES_FOR_FAN_FAULT) {
                (void) strncpy(fan_status_string, NOT_AVAILABLE,
                    sizeof (fan_status_string));
                return (B_TRUE);
        }

        if (env_debug)
                envd_log(LOG_ERR, "fan status = 0x%x\n", status);

        if (status & 0x1) {
                (void) snprintf(fan_status_string, sizeof (fan_status_string),
                    "0x%x", status);
                return (B_TRUE);
        }

        return (B_FALSE);
}

static int
scsi_mode_select(env_disk_t *diskp, uchar_t page_code, uchar_t *pagebuf,
    uint16_t pagelen)
{
        struct uscsi_cmd                ucmd_buf;
        uchar_t                         cdb_buf[CDB_GROUP1];
        struct scsi_extended_sense      sense_buf;
        int                             ret_val;

        bzero(&cdb_buf, sizeof (cdb_buf));
        bzero(&ucmd_buf, sizeof (ucmd_buf));
        bzero(&sense_buf, sizeof (sense_buf));

        cdb_buf[0] = SCMD_MODE_SELECT_G1;
        cdb_buf[1] = 1<<PAGE_FMT;

        cdb_buf[7] = (uchar_t)((pagelen & 0xFF00) >> 8);
        cdb_buf[8] = (uchar_t)(pagelen  & 0x00FF);

        ucmd_buf.uscsi_cdb = (char *)cdb_buf;
        ucmd_buf.uscsi_cdblen = sizeof (cdb_buf);
        ucmd_buf.uscsi_bufaddr = (caddr_t)pagebuf;
        ucmd_buf.uscsi_buflen = pagelen;
        ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
        ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
        ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_WRITE | USCSI_SILENT;
        ucmd_buf.uscsi_timeout = DEFAULT_SCSI_TIMEOUT;

        ret_val = ioctl(diskp->fd, USCSICMD, ucmd_buf);

        if (ret_val == 0 && ucmd_buf.uscsi_status == 0) {
                return (ret_val);
        }
        if (env_debug)
                envd_log(LOG_ERR, "mode select command for %s failed. "
                    "page_code 0x%x ret_val = 0x%x "
                    "status = 0x%x errno = 0x%x\n", diskp->name, page_code,
                    ret_val, ucmd_buf.uscsi_status, errno);

        return (1);

}