/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 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 Enchilada 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/i2c/clients/i2c_client.h>
#include <sys/i2c/clients/adm1031.h>
#include <sys/i2c/clients/pic16f819_reg.h>
#include "envd.h"
#include <sys/scsi/scsi.h>
#include <sys/scsi/generic/commands.h>


/*
 * 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);

/*
 * Sleep routine used for polling
 */
static int get_dimm_fan_speed(int, fanspeed_t *);
static int is_dimm_fan_failed(void);

#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 dimm_fan_rpm_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};
static char dimm_fan_status_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};
static char dimm_fan_command_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};
static char dimm_fan_debug_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};

static int      scsi_log_sense(int fd, uchar_t page_code, uchar_t *pagebuf,
                        uint16_t pagelen);
static int      get_disk_temp(env_disk_t *);
/*
 * ES Segment data structures
 */
static sensor_ctrl_blk_t        sensor_ctrl[MAX_SENSORS];
static fan_ctrl_blk_t           fan_ctrl[MAX_FANS];
static fruenvseg_t              *envfru = NULL;

/*
 * Env thread variables
 */
static boolean_t  system_shutdown_started = B_FALSE;
static boolean_t  ovtemp_thr1_created = B_FALSE;
static pthread_t  ovtemp_thr1_id;
static pthread_attr_t thr_attr;
static boolean_t  ovtemp_thr2_created = B_FALSE;
static pthread_t  ovtemp_thr2_id;
static boolean_t  dimm_fan_thr_created = B_FALSE;
static pthread_t  dimm_fan_thr_id;
static boolean_t  disk_temp_thr_created = B_FALSE;
static pthread_t  disk_temp_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;

/*
 * Fan devices
 */
static env_fan_t envd_sys_out_fan = {
        ENV_SYSTEM_OUT_FAN, ENV_SYSTEM_OUT_FAN_DEVFS, NULL,
        SYSTEM_OUT_FAN_ID, SYSTEM_OUT_FAN_SPEED_MIN, SYSTEM_OUT_FAN_SPEED_MAX,
        -1, -1,
};

static env_fan_t envd_sys_in_fan = {
        ENV_SYSTEM_INTAKE_FAN, ENV_SYSTEM_INTAKE_FAN_DEVFS, NULL,
        SYSTEM_INTAKE_FAN_ID, SYSTEM_INTAKE_FAN_SPEED_MIN,
        SYSTEM_INTAKE_FAN_SPEED_MAX, -1, -1,
};

static env_fan_t envd_cpu0_fan = {
        ENV_CPU0_FAN, ENV_CPU0_FAN_DEVFS, NULL,
        CPU0_FAN_ID, CPU_FAN_SPEED_MIN, CPU_FAN_SPEED_MAX, -1, -1,
};

static env_fan_t envd_cpu1_fan = {
        ENV_CPU1_FAN, ENV_CPU1_FAN_DEVFS, NULL,
        CPU1_FAN_ID, CPU_FAN_SPEED_MIN, CPU_FAN_SPEED_MAX, -1, -1,
};

static env_fan_t envd_dimm_fan = {
        ENV_DIMM_FAN, ENV_DIMM_FAN_DEVFS, NULL,
        DIMM_FAN_ID, 100, 100, -1, -1,
};

static env_disk_t envd_disk0 = {
        ENV_DISK0, ENV_DISK0_DEVFS, DISK0_PHYSPATH, DISK0_NODE_PATH,
        DISK0_ID, -1, -1,
};

static env_disk_t envd_disk1 = {
        ENV_DISK1, ENV_DISK1_DEVFS, DISK1_PHYSPATH, DISK1_NODE_PATH,
        DISK1_ID, -1, -1,
};

/*
 * The vendor-id and device-id are the properties associated with
 * the SCSI controller. This is used to identify a particular controller
 * like LSI1030.
 */
#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_cpu0_fan,
        &envd_cpu1_fan,
        &envd_sys_out_fan,
        &envd_sys_in_fan,
        &envd_dimm_fan,
        NULL
};

static  env_disk_t      *envd_disks[] = {
        &envd_disk0,
        &envd_disk1,
        NULL
};

/*
 * ADM1031 speedrange map is indexed by a 2-bit value
 */
static int      adm_speedrange_map[] = {1, 2, 4, 8};

/*
 * ADM1031 devices
 */
static char     *hwm_devs[] = {
        CPU_HWM_DEVFS,  /* CPU_HWM_ID */
        SYS_HWM_DEVFS   /* SYS_HWM_ID */
};

/*
 * Fan names associated with each ADM1031 hwms - used to
 * print fault messages.
 */
static char     *hwm_fans[MAX_HWMS][2] = {
        {ENV_CPU0_FAN, ENV_CPU1_FAN},
        {ENV_SYSTEM_INTAKE_FAN, ENV_SYSTEM_OUT_FAN}
};

/*
 * Temperature sensors
 */
static env_sensor_t envd_sensors[] = {
        { SENSOR_CPU0_DIE, SENSOR_CPU0_DIE_DEVFS, NULL,
            CPU0_SENSOR_ID, CPU_HWM_ID, (void *)&envd_cpu0_fan, -1},
        { SENSOR_CPU1_DIE, SENSOR_CPU1_DIE_DEVFS, NULL,
            CPU1_SENSOR_ID, CPU_HWM_ID, (void *)&envd_cpu1_fan, -1},
        { SENSOR_INT_AMB_0, SENSOR_INT_AMB_0_DEVFS, NULL,
            INT_AMB0_SENSOR_ID, CPU_HWM_ID, NULL, -1},
        { SENSOR_SYS_OUT, SENSOR_SYS_OUT_DEVFS, NULL,
            SYS_OUT_SENSOR_ID, SYS_HWM_ID, (void *)&envd_sys_out_fan, -1},
        { SENSOR_INT_AMB_1, SENSOR_INT_AMB_1_DEVFS, NULL,
            INT_AMB1_SENSOR_ID, SYS_HWM_ID, NULL, -1},
        { SENSOR_SYS_IN, SENSOR_SYS_IN_DEVFS, NULL,
            SYS_IN_SENSOR_ID, SYS_HWM_ID, (void *)&envd_sys_in_fan, -1},
};
#define N_ENVD_SENSORS  (sizeof (envd_sensors)/sizeof (envd_sensors[0]))

#define NOT_AVAILABLE   "NA"

/*
 * ADM1031 macros
 */
#define TACH_UNKNOWN    255
#define FAN_OUT_OF_RANGE        (TACH_UNKNOWN)
#define ADM_HYSTERISIS  5
#define N_SEQ_TACH      15

#define TMIN_MASK       (0xF8)
#define TMIN_SHIFT      (3)
#define TMIN_UNITS      (4)     /* increments of 4 degrees celsius */
#define TRANGE_MASK     (0x7)

#define TMIN(regval)    (((regval & TMIN_MASK) >> TMIN_SHIFT) * TMIN_UNITS)
#define TRANGE(regval)  (regval & TRANGE_MASK)

#define GET_TMIN_RANGE(tmin, trange) \
        ((((tmin / TMIN_UNITS) & TMIN_MASK) << TMIN_SHIFT) | \
        (trange & TRANGE_MASK))

#define TACH_ENABLE_MASK                (0x0C)
#define ADM_SETFANSPEED_CONV(speed)     (15 * speed / 100)

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

int     monitor_disk_temp       = 1;    /* enabled */
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 get_monitor_cpu_mode(ptree_rarg_t *parg, void *buf);
static int set_monitor_cpu_mode(ptree_warg_t *parg, const void *buf);
static int get_monitor_sys_mode(ptree_rarg_t *parg, void *buf);
static int set_monitor_sys_mode(ptree_warg_t *parg, const void *buf);
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 get_cpu_tach(ptree_rarg_t *parg, void *buf);
static int set_cpu_tach(ptree_warg_t *parg, const void *buf);
static int get_sys_tach(ptree_rarg_t *parg, void *buf);
static int set_sys_tach(ptree_warg_t *parg, const void *buf);

static int      shutdown_override       = 0;
static int      sensor_poll_interval    = SENSORPOLL_INTERVAL;
static int      warning_interval        = WARNING_INTERVAL;
static int      disk_warning_interval   = DISK_WARNING_INTERVAL;
static int      disk_warning_duration   = DISK_WARNING_DURATION;
static int      shutdown_interval       = SHUTDOWN_INTERVAL;
static int      disk_shutdown_interval  = DISK_SHUTDOWN_INTERVAL;
static int      ovtemp_monitor          = 1;    /* enabled */
static int      pm_monitor              = 1;    /* enabled */
static int      mon_fanstat             = 1;    /* enabled */

static int      cpu_mode;
static int      sys_mode;
static int      cpu_tach;
static int      sys_tach;
static char     shutdown_cmd[] = SHUTDOWN_CMD;

env_tuneable_t tuneables[] = {
        {"ovtemp-monitor", PICL_PTYPE_INT, &ovtemp_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)},

        {"cpu-hm-automode-enable", PICL_PTYPE_INT, &cpu_mode,
            &get_monitor_cpu_mode, &set_monitor_cpu_mode,
            sizeof (int)},

        {"sys-hm-automode-enable", PICL_PTYPE_INT, &sys_mode,
            &get_monitor_sys_mode, &set_monitor_sys_mode,
            sizeof (int)},

        {"sensor-poll-interval", PICL_PTYPE_INT,
            &sensor_poll_interval,
            &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)},

        {"warning-interval", PICL_PTYPE_INT, &warning_interval,
            &get_int_val, &set_int_val,
            sizeof (int)},

        {"shutdown-interval", PICL_PTYPE_INT, &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)},

        {"cpu-tach-enable", PICL_PTYPE_INT, &cpu_tach,
            &get_cpu_tach, &set_cpu_tach,
            sizeof (int)},

        {"sys-tach-enable", PICL_PTYPE_INT, &sys_tach,
            &get_sys_tach, &set_sys_tach,
            sizeof (int)},

        {"monitor-fanstat", PICL_PTYPE_INT, &mon_fanstat,
            &get_int_val, &set_int_val, sizeof (int)},

        {"monitor-disk-temp", PICL_PTYPE_INT, &monitor_disk_temp,
            &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]));

/*
 * Table Handling Code
 */
static void
fini_table(table_t *tblp)
{
        if (tblp == NULL)
                return;
        free(tblp->xymap);
        free(tblp);
}

static table_t *
init_table(int npoints)
{
        table_t         *tblp;
        point_t         *xy;

        if (npoints == 0)
                return (NULL);

        if ((tblp = malloc(sizeof (*tblp))) == NULL)
                return (NULL);

        if ((xy = malloc(sizeof (*xy) * npoints)) == NULL) {
                free(tblp);
                return (NULL);
        }

        tblp->nentries = npoints;
        tblp->xymap = xy;

        return (tblp);
}

/*
 * function: calculates y for a given x based on a table of points
 * for monotonically increasing x values.
 * 'tbl' specifies the table to use, 'val' specifies the 'x', returns 'y'
 */
static int
y_of_x(table_t *tbl, int xval)
{
        int             i;
        int             entries;
        point_t         *xymap;
        float           newval;
        float           dy, dx, slope;

        entries = tbl->nentries;
        xymap = tbl->xymap;
        /*
         * If the temperature is outside the correction table
         * then simply return the original value.
         */
        if ((xval < xymap[0].x) || (xval > xymap[entries - 1].x))
                return (xval);
        if (xval == xymap[0].x)
                return (xymap[0].y);
        if (xval == xymap[entries - 1].x)
                return (xymap[entries - 1].y);

        for (i = 1; i < entries - 1; i++) {
                if (xval == xymap[i].x)
                        return (xymap[i].y);
                if (xval < xymap[i].x)
                        break;
        }

        /*
         * Use linear interpolation
         */
        dy = (float)(xymap[i].y - xymap[i-1].y);
        dx = (float)(xymap[i].x - xymap[i-1].x);
        slope = dy/dx;
        newval = xymap[i - 1].y + slope * (xval - xymap[i - 1].x);
        return ((int)(newval + (newval >= 0 ? 0.5 : -0.5)));
}

/*
 * Get environmental segment from the specified FRU SEEPROM
 */
static int
get_envseg(int fd, void **envsegp, int *envseglenp)
{
        int                     i, segcnt, envseglen;
        section_layout_t        section;
        segment_layout_t        segment;
        uint8_t                 *envseg;

        if (lseek(fd, (long)SECTION_HDR_OFFSET, 0) == -1L ||
            read(fd, &section, sizeof (section)) != sizeof (section)) {
                return (EINVAL);
        }

        /*
         * Verify we have the correct section and contents are valid
         * For now, we don't verify the CRC.
         */
        if (section.header_tag != SECTION_HDR_TAG ||
            GET_UNALIGN16(&section.header_version[0]) != SECTION_HDR_VER) {
                if (env_debug)
                        envd_log(LOG_INFO,
                            "Invalid section header tag:%x  version:%x\n",
                            section.header_tag,
                            GET_UNALIGN16(&section.header_version));
                return (EINVAL);
        }

        /*
         * Locate our environmental segment
         */
        segcnt = section.segment_count;
        for (i = 0; i < segcnt; i++) {
                if (read(fd, &segment, sizeof (segment)) != sizeof (segment)) {
                        return (EINVAL);
                }
                if (env_debug)
                        envd_log(LOG_INFO,
                            "Seg name: %x  desc:%x off:%x  len:%x\n",
                            GET_UNALIGN16(&segment.name),
                            GET_UNALIGN32(&segment.descriptor[0]),
                            GET_UNALIGN16(&segment.offset),
                            GET_UNALIGN16(&segment.length));
                if (GET_UNALIGN16(&segment.name) == ENVSEG_NAME)
                        break;
        }

        if (i >= segcnt) {
                return (ENOENT);
        }

        /*
         * Allocate memory to hold the environmental segment data.
         */
        envseglen = GET_UNALIGN16(&segment.length);
        if ((envseg = malloc(envseglen)) == NULL) {
                return (ENOMEM);
        }

        if (lseek(fd, (long)GET_UNALIGN16(&segment.offset), 0) == -1L ||
            read(fd, envseg, envseglen) != envseglen) {
                (void) free(envseg);
                return (EIO);
        }
        *envsegp = envseg;
        *envseglenp = envseglen;
        return (0);
}

/*
 * Get all environmental segments
 * Return NULL on error
 */
static fruenvseg_t *
get_fru_envsegs(void)
{
        fruenvseg_t             *fruenvsegs;
        envseg_layout_t         *envsegp;
        void                    *envsegbufp;
        int                     fd, envseglen, hdrlen;
        char                    path[PATH_MAX];

        fruenvsegs = NULL;
        fruenvsegs = malloc(sizeof (*fruenvsegs));
        if (fruenvsegs == NULL) {
                return (NULL);
        }

        /*
         * Now get the environmental segment from this FRU
         */
        (void) snprintf(path, sizeof (path), "%s%s", I2C_DEVFS, MBFRU_DEV);
        fd = open(path, O_RDONLY);
        if (fd == -1) {
                envd_log(LOG_ERR, ENV_FRU_OPEN_FAIL, errno, path);
                free(fruenvsegs);
                return (NULL);
        }

        /*
         * Read environmental segment from this FRU SEEPROM
         */
        if (get_envseg(fd, &envsegbufp, &envseglen) != 0) {
                envd_log(LOG_ERR, ENV_FRU_BAD_ENVSEG, path);
                free(fruenvsegs);
                (void) close(fd);
                return (NULL);
        }

        /*
         * Validate envseg version number and header length
         */
        envsegp = (envseg_layout_t *)envsegbufp;
        hdrlen = sizeof (envseg_layout_t) -
            sizeof (envseg_sensor_t) +
            (envsegp->sensor_count) * sizeof (envseg_sensor_t);

        if (envsegp->version != ENVSEG_VERSION ||
            envseglen < hdrlen) {
                /*
                 * version mismatch or header not big enough
                 */
                envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG, FRU_SEEPROM_NAME);
                if (envsegbufp != NULL)
                        (void) free(envsegbufp);
                free(fruenvsegs);
                (void) close(fd);
                return (NULL);
        }

        fruenvsegs->envseglen = envseglen;
        fruenvsegs->envsegbufp = envsegbufp;
        (void) close(fd);
        return (fruenvsegs);
}

static int
process_fru_seeprom(unsigned char *buff)
{
        id_off_t id;
        int  i;
        int  id_offset = 0;
        int  nsensors;
        int  nfans;
        env_fan_t *fnodep;
        env_sensor_t *snodep;

#define NSENSOR_OFFSET  1
#define ID_OFF_SIZE     6
#define NFANS_OFFSET(x) ((x * ID_OFF_SIZE) + 2)

        nsensors = (int)buff[NSENSOR_OFFSET];
        if (nsensors != MAX_SENSORS) {
                envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG, FRU_SEEPROM_NAME);
                return (-1);
        }

        nfans = (int)buff[NFANS_OFFSET(nsensors)];
        if (nfans != MAX_FANS) {
                envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG, FRU_SEEPROM_NAME);
                return (-1);
        }

        while (nsensors > 0) {
                (void) memcpy((char *)&id,
                    (char *)&buff[id_offset + 2],
                    ID_OFF_SIZE);

                if (env_debug)
                        envd_log(LOG_ERR, "\n Sensor Id %x offset %x",
                            id.id, id.offset);

                if (id.id > MAX_SENSOR_ID) {
                        envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG,
                            FRU_SEEPROM_NAME);
                        return (-1);
                }

                /*
                 * Copy into the sensor control block array according to the
                 * sensor ID
                 */
                (void) memcpy((char *)&sensor_ctrl[id.id],
                    (char *)&buff[id.offset],
                    sizeof (sensor_ctrl_blk_t));
                nsensors--;
                id_offset += ID_OFF_SIZE;
        }

        /*
         * Skip past no of Fan entry(single byte)
         */
        id_offset++;
        while (nfans > 0) {
                (void) memcpy((char *)&id, (char *)&buff[id_offset + 2],
                    ID_OFF_SIZE);

                if (env_debug)
                        envd_log(LOG_ERR, "\n Fan Id %x offset %x", id.id,
                            id.offset);

                if (id.id > 3) {
                        envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG,
                            FRU_SEEPROM_NAME);
                        return (-1);
                }

                (void) memcpy((char *)&fan_ctrl[id.id],
                    (char *)&buff[id.offset], sizeof (fan_ctrl_blk_t));

                nfans--;
                id_offset += ID_OFF_SIZE;
        }

        /*
         * Match Sensor/ES ID and point correct data
         * based on IDs
         */
        for (i = 0; i < N_ENVD_SENSORS; i++) {
                snodep = &envd_sensors[i];
                snodep->es_ptr = &sensor_ctrl[snodep->id];
        }

        /*
         * Match Fan/ES ID and point to correct ES Data
         * based on IDs
         */
        for (i = 0; (fnodep = envd_fans[i]) != NULL; i++)
                fnodep->es_ptr = &fan_ctrl[fnodep->id];

        return (0);
}

static int
envd_es_setup(void)
{
        envfru = get_fru_envsegs();
        if (envfru == NULL) {
                envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG, FRU_SEEPROM_NAME);
                return (-1);
        }
        return (process_fru_seeprom((uchar_t *)envfru->envsegbufp));
}

static void
envd_es_destroy(void)
{
        if (envfru != NULL)
                free(envfru->envsegbufp);
}

/*
 * 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, I2C_GET_TEMPERATURE, temp) == -1) {

                retval = -1;

                if (sensorp->error == 0) {
                        sensorp->error = 1;
                        envd_log(LOG_WARNING, ENV_SENSOR_ACCESS_FAIL,
                            sensorp->name, errno, strerror(errno));
                }
        } else if (sensorp->error != 0) {
                sensorp->error = 0;
                envd_log(LOG_WARNING, ENV_SENSOR_ACCESS_OK, sensorp->name);
        }
        if (sensorp->crtbl != NULL) {
                *temp = (tempr_t)y_of_x(sensorp->crtbl, *temp);
        }

        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 uncorrected current temperature
 * Returns -1 on error, 0 if successful
 */
static int
get_raw_temperature(env_sensor_t *sensorp, tempr_t *temp)
{
        int     fd = sensorp->fd;
        int     retval = 0;

        if (fd == -1)
                retval = -1;
        else if (ioctl(fd, I2C_GET_TEMPERATURE, temp) == -1) {
                retval = -1;
        }

        return (retval);
}

/*
 * Return Fan RPM given N & tach
 * count and N are retrived from the
 * ADM1031 chip.
 */
static int
tach_to_rpm(int n, uint8_t tach)
{
        if (n * tach == 0)
                return (0);
        return ((ADCSAMPLE * 60) / (n * tach));
}

static int
get_raw_fan_speed(env_fan_t *fanp, uint8_t *fanspeedp)
{
        int     fan_fd;
        int     retval = 0;

        fan_fd = fanp->fd;

        if (fan_fd == -1)
                retval = -1;
        else if (ioctl(fan_fd, I2C_GET_FAN_SPEED, fanspeedp) == -1) {
                retval = -1;
        }


        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)
{
        int     fan_fd;
        uint8_t tach;

        fan_fd = fanp->fd;

        if (fan_fd == -1)
                return (-1);
        if (fanp->id == DIMM_FAN_ID) {
                return (get_dimm_fan_speed(fan_fd, fanspeedp));
        }
        if (ioctl(fan_fd, I2C_GET_FAN_SPEED, &tach) == -1) {
                return (-1);
        }

        /*
         * Fanspeeds are reported as 0
         * if the tach is out of range or fan status is off
         * and if monitoring fan status is enabled.
         */
        if (mon_fanstat && (!fanp->fanstat || tach == FAN_OUT_OF_RANGE)) {
                *fanspeedp = 0;
        } else {
                *fanspeedp =
                    tach_to_rpm(fanp->speedrange, 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)
{
        int     fan_fd;
        int     retval = 0;
        uint8_t speed;

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

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

        speed = (uint8_t)ADM_SETFANSPEED_CONV(fanspeed);

        if (ioctl(fan_fd, I2C_SET_FAN_SPEED, &speed) == -1) {
                retval = -1;
        }
        return (retval);
}

/*
 * 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;
                }
                if (sensorp->crtbl != NULL)
                        fini_table(sensorp->crtbl);
        }
}

/*
 * Open fan devices and initialize per fan data structure.
 * Returns #fans found.
 */
static int
envd_setup_fans(void)
{
        int             i, fd;
        env_fan_t       *fanp;
        char            path[PATH_MAX];
        int             fancnt = 0;
        uint8_t         n = 0;
        picl_nodehdl_t tnodeh;
        i2c_reg_t       i2c_reg;

        for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
                /* 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) {
                                fanp->present = B_FALSE;
                                continue;
                        }
                }
                if (fanp->id == CPU1_FAN_ID) {
                        if (ptree_get_node_by_path(CPU1_PATH, &tnodeh) !=
                            PICL_SUCCESS) {
                                fanp->present = B_FALSE;
                                continue;
                        }
                }
                if (fanp->id == DIMM_FAN_ID) {
                        if (ptree_get_node_by_path(DIMM_FAN_CONTROLLER_PATH,
                            &tnodeh) != PICL_SUCCESS) {
                                if (env_debug)
                                        envd_log(LOG_ERR,
                                            "dimm Fan not found in the "
                                            "system.\n");
                                fanp->present = B_FALSE;
                                continue;
                        }
                }
                (void) strcpy(path, "/devices");
                (void) strlcat(path, fanp->devfs_path, sizeof (path));
                fd = open(path, O_RDWR);
                if (fd == -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;
                if (fanp->id == DIMM_FAN_ID) {
                        /*
                         * set the SW aware bit in command register.
                         * Clear the Fan fault latch bit.
                         */
                        i2c_reg.reg_num = PIC16F819_COMMAND_REGISTER;
                        i2c_reg.reg_value = (PIC16F819_SW_AWARE_MODE |
                            PIC16F819_FAN_FAULT_CLEAR);
                        if (ioctl(fd, I2C_SET_REG, &i2c_reg) == -1) {
                                if (env_debug)
                                        envd_log(LOG_ERR,
                                            "Error in writing to COMMAND reg. "
                                            "of DIMM FAN controller\n");
                        }
                } else {
                        /* Get speed range value */
                        if (ioctl(fd, ADM1031_GET_FAN_FEATURE, &n) != -1) {
                                fanp->speedrange =
                                    adm_speedrange_map[(n >> 6) & 0x03];
                        } else {
                                fanp->speedrange = FAN_RANGE_DEFAULT;
                        }
                }
                fanp->present = B_TRUE;
                fanp->fanstat = 0;
                fanp->cspeed = TACH_UNKNOWN;
                fanp->lspeed = TACH_UNKNOWN;
                fanp->conccnt = 0;
                fancnt++;
        }
        return (fancnt);
}

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];

        /*
         * Check if the SCSi controller on the system is 1010 or 1030
         */

        if (ptree_get_node_by_path(SCSI_CONTROLLER_NODE_PATH,
            &tnodeh) != PICL_SUCCESS) {
                if (env_debug)
                        envd_log(LOG_ERR,
                            "On-Board SCSI controller not found "
                            "in the system.\n");
                monitor_disk_temp = 0;
                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);
                monitor_disk_temp = 0;
                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);
                monitor_disk_temp = 0;
                return (-1);
        }
        if (env_debug)
                envd_log(LOG_ERR, "vendor-id=0x%x device-id=0x%x\n",
                    vendor_id, device_id);
        if ((vendor_id != LSI1030_VENDOR_ID) ||
            (device_id != LSI1030_DEVICE_ID)) {
                monitor_disk_temp = 0;
                return (-1);
        }
        /*
         * We have found LSI1030 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 not found in the system.\n",
                                    diskp->id);
                        continue;
                }
                diskp->fd = open(diskp->devfs_path, O_RDONLY);
                if (diskp->fd == -1) {
                        diskp->present = B_FALSE;
                        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;
                /*
                 * Find out if the Temperature page is supported by the disk.
                 */
                ret = scsi_log_sense(diskp->fd, SUPPORTED_LPAGES,
                    log_page, sizeof (log_page));
                if (ret != 0) {
                        continue;
                }
                page_len = ((log_page[2] << 8) & 0xFF00) | log_page[3];

                for (page_index = LOGPAGEHDRSIZE;
                    page_index < page_len + LOGPAGEHDRSIZE; page_index++) {
                        switch (log_page[page_index]) {
                        case TEMPERATURE_PAGE:
                                diskp->tpage_supported = B_TRUE;
                                if (env_debug)
                                        envd_log(LOG_ERR,
                                            "tpage supported for %s\n",
                                            diskp->nodepath);
                        default:
                                break;
                        }
                }
                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;
                ret = get_disk_temp(diskp);
        }
        return (0);
}

/*
 * Open temperature sensor devices and initialize per sensor data structure.
 * Returns #sensors found.
 */
static int
envd_setup_sensors(void)
{
        env_sensor_t    *sensorp;
        sensor_ctrl_blk_t *es_ptr;
        table_t         *tblp;
        char            path[PATH_MAX];
        int             sensorcnt = 0;
        int             i, j, nentries;
        int16_t         tmin = 0;
        picl_nodehdl_t tnodeh;

        for (i = 0; i < N_ENVD_SENSORS; ++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;
                sensorp->crtbl = NULL;
                /* make sure cpu0/1 sensors are present */
                if (sensorp->id == CPU0_SENSOR_ID) {
                        if (ptree_get_node_by_path(CPU0_PATH, &tnodeh) !=
                            PICL_SUCCESS) {
                                sensorp->present = B_FALSE;
                                continue;
                        }
                }
                if (sensorp->id == CPU1_SENSOR_ID) {
                        if (ptree_get_node_by_path(CPU1_PATH, &tnodeh) !=
                            PICL_SUCCESS) {
                                sensorp->present = B_FALSE;
                                continue;
                        }
                }
                (void) strcpy(path, "/devices");
                (void) strlcat(path, sensorp->devfs_path,
                    sizeof (path));
                sensorp->fd = open(path, O_RDWR);
                if (sensorp->fd == -1) {
                        envd_log(LOG_ERR, ENV_SENSOR_OPEN_FAIL,
                            sensorp->name, sensorp->devfs_path,
                            errno, strerror(errno));
                        sensorp->present = B_FALSE;
                        continue;
                }
                sensorp->present = B_TRUE;
                sensorcnt++;

                /*
                 * Get Tmin
                 */

                if (ioctl(sensorp->fd, ADM1031_GET_TEMP_MIN_RANGE,
                    &tmin) != -1) {
                        sensorp->tmin = TMIN(tmin);
                } else {
                        sensorp->tmin = -1;
                }
                if (env_debug)
                        envd_log(LOG_ERR, "Sensor %s tmin %d",
                            sensorp->name, sensorp->tmin);

                /*
                 * Create a correction table
                 * if correction pairs are present in es
                 * segment.
                 */
                es_ptr = sensorp->es_ptr;

                if (es_ptr == NULL) {
                        continue;
                }
                nentries = es_ptr->correctionEntries;

                if (nentries <= 2) {
                        if (env_debug)
                                envd_log(LOG_CRIT, "sensor correction <2");
                        continue;
                }

                sensorp->crtbl = init_table(nentries);
                if (sensorp->crtbl == NULL)
                        continue;
                tblp = sensorp->crtbl;
                tblp->xymap[0].x =
                    (char)es_ptr->correctionPair[0].measured;
                tblp->xymap[0].y =
                    (char)es_ptr->correctionPair[0].corrected;

                for (j = 1; j < nentries; ++j) {
                        tblp->xymap[j].x =
                            (char)es_ptr->correctionPair[j].measured;
                        tblp->xymap[j].y =
                            (char)es_ptr->correctionPair[j].corrected;

                        if (tblp->xymap[j].x <= tblp->xymap[j - 1].x) {
                                fini_table(tblp);
                                sensorp->crtbl = NULL;
                                envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG,
                                    FRU_SEEPROM_NAME);
                                break;
                        }
                }

                if (env_debug) {
                        envd_log(LOG_CRIT, "Sensor correction  %s",
                            sensorp->name);
                        for (j = 0; j < nentries; j++)
                                envd_log(LOG_CRIT, " %d %d",
                                    tblp->xymap[j].x, tblp->xymap[j].y);
                }
        }
        return (sensorcnt);
}

/*
 * Modify ADM Tmin/ranges depending what power level
 * we are from.
 */
static void
updateadm_ranges(char *name, uchar_t cur_lpstate)
{
        env_sensor_t *sensorp;
        fan_ctrl_blk_t *fanctl;
        uchar_t tmin;
        uchar_t trange;
        uint16_t tdata;
        int sysfd;
        uchar_t sys_id = SYS_HWM_ID;
        uint8_t mode;
        static uint16_t tsave[2] = {0, 0};
        /* Index of saved Tmin/Trange for two sensors */
        uint16_t tindex = 0;

        sensorp = sensor_lookup(name);
        if (sensorp == NULL)
                return;

        /*
         * If there is only one Control pairs then return
         */
        fanctl = ((env_fan_t *)sensorp->fanp)->es_ptr;

        if (fanctl != NULL && fanctl->no_ctl_pairs <= 1)
                return;

        /*
         * if fan control specifies that ranges are same then
         * we skip re-programming adm chip.
         */

        tmin = fanctl->fan_ctl_pairs[0].tMin;
        trange = fanctl->fan_ctl_pairs[0].tRange;
        if ((tmin == fanctl->fan_ctl_pairs[1].tMin) &&
            (trange == fanctl->fan_ctl_pairs[1].tRange))
                        return;

        sysfd = open(hwm_devs[sys_id], O_RDWR);
        if (sysfd == -1) {
                if (env_debug)
                        envd_log(LOG_ERR, ENV_ADM_OPEN_FAIL, hwm_devs[sys_id],
                            errno, strerror(errno));
                return;
        }
        tindex = ((strcmp(name, SENSOR_SYS_IN) == 0) ? 0 : 1);

        /* Read ADM default value only for the first time */
        if (tsave[tindex] == 0) {
                if (ioctl(sensorp->fd, ADM1031_GET_TEMP_MIN_RANGE,
                    &tsave[tindex]) == -1) {
                        if (env_debug)
                                envd_log(LOG_ERR,
                                    "read tminrange ioctl failed");
                        (void) close(sysfd);
                        return;
                }
        }
        /*
         * Need to reinit ADM to manual mode for Tmin range to be
         * effective.
         */
        mode = ADM1031_MANUAL_MODE;
        if (ioctl(sysfd, ADM1031_SET_MONITOR_MODE, &mode) == -1) {
                if (env_debug)
                        envd_log(LOG_ERR, ENV_ADM_MANUAL_MODE);
                (void) close(sysfd);
                return;
        }

        if (cur_lpstate == 1) {
                /*
                 * ADM 1031 Tmin/Trange register need to be reprogrammed.
                 */
                tdata = ((fanctl->fan_ctl_pairs[cur_lpstate].tMin / TMIN_UNITS)
                    << TMIN_SHIFT);
                /* Need to pack tRange in ADM bits 2:0 */
                switch (fanctl->fan_ctl_pairs[cur_lpstate].tRange) {
                case 5:
                        break;

                case 10:
                        tdata |= 1;
                        break;

                case 20:
                        tdata |= 2;
                        break;

                case 40:
                        tdata |= 3;
                        break;

                case 80:
                        tdata |= 4;
                        break;
                }
        } else
                tdata = tsave[tindex];

        if (ioctl(sensorp->fd, ADM1031_SET_TEMP_MIN_RANGE,
            &tdata) != -1)
                sensorp->tmin = TMIN(tdata);

        mode = ADM1031_AUTO_MODE;
        if (ioctl(sysfd, ADM1031_SET_MONITOR_MODE, &mode) == -1) {
                if (env_debug)
                        envd_log(LOG_ERR, ENV_ADM_AUTO_MODE);
        }
        (void) close(sysfd);
}

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

        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 adjust ADM hardware
                 * monitor's fan speed settings.
                 *
                 * 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);
                /*
                 * Change ADM ranges as per E* Requirements. Update
                 * happens only for valid state changes.
                 */
                if (pre_lpstate != cur_lpstate) {
                        pre_lpstate = cur_lpstate;
                        updateadm_ranges(SENSOR_SYS_OUT, cur_lpstate);
                        updateadm_ranges(SENSOR_SYS_IN, cur_lpstate);
                }
        }
        /* Not reached */
        return (NULL);
}

/*
 * This function is used to reasonably predict the
 * state of the fan (ON/OFF) using tmin and current temperature.
 *
 * We know the fan is on  if temp >= tmin and fan is off if
 * temp < (Tmin - Hysterisis).
 *
 * When the temperature is in between we don't know if the fan is on/off
 * because the temperature could be decreasing and not have crossed
 * Tmin - hysterisis and vice a versa.
 *
 *                      FAN ON
 * Tmin
 *      -------------------------------------------
 *
 *                      FAN ON/OFF
 *
 *      --------------------------------------------
 * Tmin - Hysterisis
 *                      FAN OFF
 *
 * To solve the problem of finding out if the fan is on/off in our gray region
 * we keep track of the last read tach and the current read tach. From
 * experimentation and from discussions with analog devices it is unlikely that
 * if the fans are on we will get a constant tach reading  more than 5 times in
 * a row. This is not but the most fool proof approach but the  best we can do.
 *
 * This routine implements the above logic for a sensor with an
 * associated fan. The caller garauntees sensorp and fanp are not null.
 */

static void
check_fanstat(env_sensor_t *sensorp)
{
        env_fan_t *fanp = sensorp->fanp;
        tempr_t temp;
        uint8_t fanspeed;

        if (get_raw_temperature(sensorp, &temp) == -1)
                return;

        if (temp < (sensorp->tmin - ADM_HYSTERISIS)) {

                fanp->fanstat = 0;              /* Fan off */
                fanp->lspeed = TACH_UNKNOWN;    /* Reset Last read tach */
                fanp->conccnt = 0;

        } else if (temp >= sensorp->tmin) {

                fanp->fanstat = 1;              /* Fan on */
                fanp->lspeed = TACH_UNKNOWN;
                fanp->conccnt = 0;

        } else {
                if (get_raw_fan_speed(fanp, &fanspeed) == -1)
                        return;

                fanp->cspeed = fanspeed;
                /*
                 * First time in the gray area
                 * set last read speed to current speed
                 */
                if (fanp->lspeed == TACH_UNKNOWN) {
                        fanp->lspeed = fanspeed;
                } else {
                        if (fanp->lspeed != fanp->cspeed) {
                                fanp->conccnt = 0;
                                fanp->fanstat = 1;
                        } else {
                                fanp->conccnt++;

                                if (fanp->conccnt >= N_SEQ_TACH)
                                        fanp->fanstat = 0;
                        }
                        fanp->lspeed = fanp->cspeed;
                }
        }
}
/*
 * There is an issue with the ADM1031 chip that causes the chip
 * to not update the tach register in case the fan stops. The
 * fans stop when the temperature measured (temp) drops below
 * Tmin - Hysterisis  and turn on when the temp >= Tmin.
 *
 * Since the tach registers don't update and remain stuck at the
 * last read tach value our get_fan_speed function always returns
 * a non-zero RPM reading.
 *
 * To fix this we need to figure out when the fans will be on/off
 * depending on the current temperature. Currently we poll for
 * interrupts, we can use that loop to determine what the current
 * temperature is and if the fans should be on/off.
 *
 * We get current temperature and check the fans.
 */
static void
monitor_fanstat(void)
{
        env_sensor_t *sensorp;
        env_fan_t *fanp;
        int i;

        for (i = 0; i < N_ENVD_SENSORS; i++) {
                sensorp = &envd_sensors[i];

                if (!sensorp)
                        continue;

                fanp = sensorp->fanp;

                if (!(fanp && fanp->present))
                        continue;

                if (sensorp->tmin != -1) {
                        check_fanstat(sensorp);
                } else {
                        fanp->fanstat = 1;
                }

        }
}

static int
handle_overtemp_interrupt(int hwm_id)
{
        env_sensor_t *sensorp;
        tempr_t  temp;
        uchar_t smap[MAX_SENSORS];
        time_t  ct;
        uchar_t i;
        char msgbuf[BUFSIZ];
        char syscmd[BUFSIZ];
        boolean_t return_flag;
        int     ret;
        timespec_t      to;
        pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
        pthread_cond_t  env_monitor_cv = PTHREAD_COND_INITIALIZER;

        /* Clear Map of Sensor Entries */
        (void) memset(smap, SENSOR_OK, sizeof (smap));

        for (;;) {
                for (i = 0; i < N_ENVD_SENSORS; i++) {
                        sensorp = &envd_sensors[i];

                        /*
                         * Check whether the sensor belongs to the
                         * interrupting ADM hardware monitor
                         */
                        if (sensorp->hwm_id != hwm_id)
                                continue;

                        if (sensorp->present == B_FALSE)
                                continue;
                        /*
                         * if shutdown is initiated then we simply loop
                         * through the sensors until shutdown
                         */
                        if (sensorp->shutdown_initiated == B_TRUE)
                                continue;

                        /* get current temp for this sensor */
                        if (get_temperature(sensorp, &temp) == -1)
                                continue;

                        sensorp->cur_temp = temp;

                        if (env_debug)
                                envd_log(LOG_ERR,
                                    "sensor name %s, cur temp %d, "
                                    "HW %d LW %d SD %d LS %d\n",
                                    sensorp->name, temp,
                                    sensorp->es_ptr->high_warning,
                                    (int)sensorp->es_ptr->low_warning,
                                    sensorp->es_ptr->high_shutdown,
                                    (int)sensorp->es_ptr->low_shutdown);

                        if (TEMP_IN_WARNING_RANGE(sensorp->cur_temp, sensorp)) {
                                /*
                                 * Log on warning atmost one second
                                 */
                                ct = (time_t)(gethrtime() / NANOSEC);
                                if ((ct - sensorp->warning_tstamp) >=
                                    warning_interval) {
                                        envd_log(LOG_CRIT,
                                            ENV_WARNING_MSG, sensorp->name,
                                            temp,
                                            sensorp->es_ptr->low_warning,
                                            sensorp->es_ptr->high_warning);
                                        sensorp->warning_tstamp = ct;
                                }
                                smap[i] = SENSOR_WARN;
                        } else {
                                /*
                                 * We will fall in this caterory only if
                                 * Temperature drops/increases from warning
                                 * threshold. If so we set sensor map to
                                 * OK so that we can exit the loop if
                                 * shutdown not initiated.
                                 */
                                smap[i] = SENSOR_OK;
                        }

                        if (TEMP_IN_SHUTDOWN_RANGE(temp, sensorp) &&
                            !shutdown_override) {
                                ct = (time_t)(gethrtime() / NANOSEC);
                                if (sensorp->shutdown_tstamp == 0)
                                        sensorp->shutdown_tstamp = ct;
                                if ((ct - sensorp->shutdown_tstamp) >=
                                    shutdown_interval) {
                                        sensorp->shutdown_initiated = B_TRUE;
                                        (void) snprintf(msgbuf, sizeof (msgbuf),
                                            ENV_SHUTDOWN_MSG, sensorp->name,
                                            temp,
                                            sensorp->es_ptr->low_shutdown,
                                            sensorp->es_ptr->high_shutdown);
                                        envd_log(LOG_ALERT, msgbuf);
                                }
                                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;
                }

                /*
                 * Sweep thorugh Sensor Map and if warnings OR shutdown
                 * are not logged then return to caller.
                 */
                return_flag = B_TRUE;
                for (i = 0; i < N_ENVD_SENSORS; i++)
                        if (smap[i] == SENSOR_WARN)
                                return_flag = B_FALSE;

                if ((return_flag == B_TRUE) &&
                    (system_shutdown_started == B_FALSE)) {
                        return (1);
                }

wait_till_timeout:
                /*
                 * We use pthread_cond_reltimedwait_np to sleep for
                 * fixed interval of time.
                 * earlier implementation used alarm() call which
                 * fails in Multi threaded environment. If multiple
                 * threads call alarm() only one of the threads is
                 * sent the SIGALRM signal.
                 */
                (void) pthread_mutex_lock(&env_monitor_mutex);
                ret = pthread_cond_reltimedwait_np(&env_monitor_cv,
                    &env_monitor_mutex, &to);
                to.tv_sec = SENSORPOLL_INTERVAL;
                to.tv_nsec = 0;
                if (ret != ETIMEDOUT) {
                        (void) pthread_mutex_unlock(&env_monitor_mutex);
                        goto wait_till_timeout;
                }
                (void) pthread_mutex_unlock(&env_monitor_mutex);
        }
}

/*
 * 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.
 * For Enchilada there will be two threads, one for each ADM chip.
 */
static void *
ovtemp_thr(void *args)
{
        int     fd;
        uint8_t stat[2];
        int     hwm_id = (int)args;
        int    err;
        env_fan_t *fanp;
        timespec_t      to;
        int     ret;
        pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
        pthread_cond_t  env_monitor_cv = PTHREAD_COND_INITIALIZER;

        fd = open(hwm_devs[hwm_id], O_RDWR);
        if (fd == -1) {
                envd_log(LOG_ERR, ENV_ADM_OPEN_FAIL, hwm_devs[hwm_id],
                    errno, strerror(errno));
                return (NULL);
        }
        if (env_debug)
                envd_log(LOG_ERR, "ovtemp thread for %s running...\n",
                    hwm_devs[hwm_id]);

        for (;;) {
                /*
                 * Sleep for specified seconds before issuing IOCTL
                 * again.
                 */

                /*
                 * We use pthread_cond_reltimedwait_np to sleep for
                 * fixed interval of time.
                 * earlier implementation used alarm() call which
                 * fails in Multi threaded environment. If multiple
                 * threads call alarm() only one of the threads is
                 * sent the SIGALRM signal.
                 */
                (void) pthread_mutex_lock(&env_monitor_mutex);
                ret = pthread_cond_reltimedwait_np(&env_monitor_cv,
                    &env_monitor_mutex, &to);
                to.tv_sec = INTERRUPTPOLL_INTERVAL;
                to.tv_nsec = 0;
                if (ret != ETIMEDOUT) {
                        (void) pthread_mutex_unlock(&env_monitor_mutex);
                        continue;
                }
                (void) pthread_mutex_unlock(&env_monitor_mutex);
                /*
                 * Monitor the sensors to update fan status
                 */
                if (mon_fanstat)
                        monitor_fanstat();

                /*
                 * Read ADM1031 two Status Registers to determine source
                 * of Interrupts.
                 */

                if ((err = ioctl(fd, ADM1031_GET_STATUS_1, &stat[0])) != -1)
                        err = ioctl(fd, ADM1031_GET_STATUS_2, &stat[1]);

                if (err == -1) {
                        if (env_debug)
                                envd_log(LOG_ERR,
                                    "OverTemp: Status Error");
                        continue;
                }

                if (env_debug)
                        envd_log(LOG_ERR, "INTR %s, Stat1 %x, Stat2 %x",
                            hwm_devs[hwm_id], stat[0], stat[1]);

                if (stat[0] & FANFAULT) {
                        fanp = fan_lookup(hwm_fans[hwm_id][HWM_FAN1]);
                        if (fanp && fanp->present)
                                envd_log(LOG_ERR, ENV_FAN_FAULT,
                                    hwm_devs[hwm_id],
                                    hwm_fans[hwm_id][HWM_FAN1]);
                }
                if (stat[1] & FANFAULT) {
                        fanp = fan_lookup(hwm_fans[hwm_id][HWM_FAN2]);
                        if (fanp && fanp->present)
                                envd_log(LOG_ERR, ENV_FAN_FAULT,
                                    hwm_devs[hwm_id],
                                    hwm_fans[hwm_id][HWM_FAN2]);
                }
                /*
                 * Check respective Remote/Local High, Low before start
                 * manual monitoring
                 */
                if ((stat[0] & STAT1MASK) || (stat[1] & STAT2MASK))
                        (void) handle_overtemp_interrupt(hwm_id);

        }       /* end of for ever loop */
        /*NOTREACHED*/
        return (NULL);
}

static void *
dimm_fan_thr(void *args)
{
        char syscmd[BUFSIZ];
        char msgbuf[BUFSIZ];
        i2c_reg_t       i2c_reg;
        timespec_t      to;
        int     ret;
        pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
        pthread_cond_t  env_monitor_cv = PTHREAD_COND_INITIALIZER;

        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 = INTERRUPTPOLL_INTERVAL;
                to.tv_nsec = 0;
                if (ret != ETIMEDOUT) {
                        (void) pthread_mutex_unlock(&env_monitor_mutex);
                        continue;
                }
                (void) pthread_mutex_unlock(&env_monitor_mutex);
                /*
                 * We write to the comand register periodically
                 * to inform the PIC firmware that Solaris is
                 * Monitoring the dimm fan periodically.
                 */
                i2c_reg.reg_num = PIC16F819_COMMAND_REGISTER;
                i2c_reg.reg_value = PIC16F819_SW_AWARE_MODE;
                if (ioctl(envd_dimm_fan.fd,
                    I2C_SET_REG, &i2c_reg) == -1) {
                        if (env_debug)
                                envd_log(LOG_ERR,
                                    "Error in writing to COMMAND reg. "
                                    "of DIMM FAN controller\n");
                }
                /*
                 * We initiate shutdown if fan status indicates
                 * failure.
                 */
                if (is_dimm_fan_failed() != 0) {
                        /*
                         * Mark Dimm fan present as False so that we
                         * do not WARN the user of the Fan failure
                         * repeatedly.
                         */
                        envd_dimm_fan.present = B_FALSE;
                        (void) snprintf(msgbuf, sizeof (msgbuf),
                            ENV_DIMM_FAN_FAILURE_SHUTDOWN_MSG,
                            ENV_DIMM_FAN,
                            dimm_fan_rpm_string, dimm_fan_status_string,
                            dimm_fan_command_string,
                            dimm_fan_debug_string);
                        envd_log(LOG_ALERT, msgbuf);

                        if (system_shutdown_started == B_FALSE) {
                                system_shutdown_started = B_TRUE;
                                (void) snprintf(syscmd, sizeof (syscmd),
                                    "%s \"%s\"",
                                    SHUTDOWN_CMD,
                                    msgbuf);
                                envd_log(LOG_ALERT, syscmd);
                                (void) system(syscmd);
                        }
                }
        }
        /*NOTREACHED*/
        return (NULL);
}
static int
scsi_log_sense(int fd, 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((void *)&cdb_buf, sizeof (cdb_buf));
        bzero((void *)&ucmd_buf, sizeof (ucmd_buf));
        bzero((void *)&sense_buf, sizeof (sense_buf));

        cdb_buf[0] = SCMD_LOG_SENSE_G1;
        cdb_buf[2] = (0x01 << 6) | 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 = 60;

        ret_val = ioctl(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 failed.ret_val = 0x%x status = 0x%x "
                    "errno = 0x%x\n",
                    ret_val, ucmd_buf.uscsi_status, errno);
        return (1);
}

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

        ret = scsi_log_sense(diskp->fd,
            TEMPERATURE_PAGE,
            tpage, sizeof (tpage));
        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;

        disk_pm_fd = open(PM_DEVICE, O_RDWR);
        if (disk_pm_fd == -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 */
}

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

        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);
        }

        ret = envd_es_setup();
        if (ret < 0) {
                ovtemp_monitor = 0;
                pm_monitor = 0;
        }

        /*
         * Setup temperature sensors and fail if we can't open
         * at least one sensor.
         */
        if (envd_setup_sensors() <= 0) {
                return (0);
        }

        /*
         * Setup fan device (don't fail even if we can't access
         * the fan as we can still monitor temeperature.
         */
        (void) envd_setup_fans();

        (void) envd_setup_disks();

        /* If ES Segment setup failed,don't create  thread */

        if (ovtemp_monitor && ovtemp_thr1_created == B_FALSE) {
                if (pthread_create(&ovtemp_thr1_id, &thr_attr, ovtemp_thr,
                    (void *)CPU_HWM_ID) != 0)
                        envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
                else
                        ovtemp_thr1_created = B_TRUE;
        }

        if (ovtemp_monitor && ovtemp_thr2_created == B_FALSE) {
                if (pthread_create(&ovtemp_thr2_id, &thr_attr, ovtemp_thr,
                    (void *)SYS_HWM_ID) != 0)
                        envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
                else
                        ovtemp_thr2_created = B_TRUE;
        }

        if (envd_dimm_fan.present) {
                if (dimm_fan_thr_created == B_FALSE) {
                        if (pthread_create(&dimm_fan_thr_id, &thr_attr,
                            dimm_fan_thr, NULL) != 0)
                                envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
                        else
                                dimm_fan_thr_created = B_TRUE;
                }
        }

        /*
         * 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 (monitor_disk_temp) {
                if (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;
                }
        }
        return (0);
}

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

static void
piclenvd_init(void)
{

        (void) env_picl_setup_tuneables();

        /*
         * 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();
        envd_es_destroy();
}

/*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_cpu_tach(ptree_rarg_t *parg, void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;
        int             fd;
        int8_t          cfg;

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        fd = open(CPU_HWM_DEVFS, O_RDWR);

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

        if (ioctl(fd, ADM1031_GET_CONFIG_2, &cfg) == -1) {
                return (PICL_FAILURE);
        }

        if ((cfg & TACH_ENABLE_MASK) == TACH_ENABLE_MASK) {
                *((int *)tuneablep->value) = ENABLE;
        } else {
                *((int *)tuneablep->value) = DISABLE;
        }

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

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

static int
set_cpu_tach(ptree_warg_t *parg, const void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;
        int              fd, val;
        int8_t           cfg;

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

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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


        fd = open(CPU_HWM_DEVFS, O_RDWR);

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

        if (ioctl(fd, ADM1031_GET_CONFIG_2, &cfg) == -1) {
                return (PICL_FAILURE);
        }

        (void) memcpy(&val, (caddr_t)buf, sizeof (val));

        if (val == ENABLE) {
                cfg |= TACH_ENABLE_MASK;
        } else if (val == DISABLE) {
                cfg &= ~TACH_ENABLE_MASK;
        }


        if (ioctl(fd, ADM1031_SET_CONFIG_2, &cfg) == -1) {
                return (PICL_FAILURE);
        }

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

static int
get_sys_tach(ptree_rarg_t *parg, void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;
        int             fd;
        int8_t          cfg;

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        fd = open(SYS_HWM_DEVFS, O_RDWR);

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

        if (ioctl(fd, ADM1031_GET_CONFIG_2, &cfg) == -1) {
                return (PICL_FAILURE);
        }

        if ((cfg & TACH_ENABLE_MASK) == TACH_ENABLE_MASK) {
                *((int *)tuneablep->value) = ENABLE;
        } else {
                *((int *)tuneablep->value) = DISABLE;
        }

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

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

static int
set_sys_tach(ptree_warg_t *parg, const void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;
        int             fd, val;
        int8_t          cfg;

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

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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


        fd = open(SYS_HWM_DEVFS, O_RDWR);

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

        if (ioctl(fd, ADM1031_GET_CONFIG_2, &cfg) == -1) {
                return (PICL_FAILURE);
        }

        (void) memcpy(&val, buf, sizeof (val));

        if (val == ENABLE) {
                cfg |= TACH_ENABLE_MASK;
        } else if (val == DISABLE) {
                cfg &= ~TACH_ENABLE_MASK;
        }


        if (ioctl(fd, ADM1031_SET_CONFIG_2, &cfg) == -1) {
                return (PICL_FAILURE);
        }

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

static int
get_monitor_cpu_mode(ptree_rarg_t *parg, void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;
        int             fd;
        int8_t          mmode;

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        fd = open(CPU_HWM_DEVFS, O_RDWR);

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

        if (ioctl(fd, ADM1031_GET_MONITOR_MODE, &mmode) == -1) {
                return (PICL_FAILURE);
        }

        if (mmode == ADM1031_AUTO_MODE) {
                *((int *)tuneablep->value) = ENABLE;
        } else {
                *((int *)tuneablep->value) = DISABLE;
        }

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

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

static int
set_monitor_cpu_mode(ptree_warg_t *parg, const void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;
        int             fd, val;
        int8_t          mmode;

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

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        fd = open(CPU_HWM_DEVFS, O_RDWR);

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

        (void) memcpy(&val, buf, sizeof (val));

        if (val == ENABLE) {
                mmode = ADM1031_AUTO_MODE;
        } else if (val == DISABLE) {
                mmode = ADM1031_MANUAL_MODE;
        }

        if (ioctl(fd, ADM1031_SET_MONITOR_MODE, &mmode) == -1) {
                return (PICL_FAILURE);
        }

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

static int
get_monitor_sys_mode(ptree_rarg_t *parg, void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;
        int             fd;
        int8_t          mmode;

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        fd = open(SYS_HWM_DEVFS, O_RDWR);

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

        if (ioctl(fd, ADM1031_GET_MONITOR_MODE, &mmode) == -1) {
                return (PICL_FAILURE);
        }

        if (mmode == ADM1031_AUTO_MODE) {
                *((int *)tuneablep->value) = ENABLE;
        } else {
                *((int *)tuneablep->value) = DISABLE;
        }

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

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

static int
set_monitor_sys_mode(ptree_warg_t *parg, const void *buf)
{
        picl_prophdl_t  proph;
        env_tuneable_t  *tuneablep;
        int             fd, val;
        int8_t          mmode;

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

        proph = parg->proph;

        tuneablep = tuneable_lookup(proph);

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

        fd = open(SYS_HWM_DEVFS, O_RDWR);

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

        (void) memcpy(&val, buf, sizeof (val));

        if (val == ENABLE) {
                mmode = ADM1031_AUTO_MODE;
        } else if (val == DISABLE) {
                mmode = ADM1031_MANUAL_MODE;
        }

        if (ioctl(fd, ADM1031_SET_MONITOR_MODE, &mmode) == -1) {
                return (PICL_FAILURE);
        }

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

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, (caddr_t)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((caddr_t)tuneables->value, (caddr_t)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((int *)buf, (int *)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((int *)tuneablep->value, (int *)buf,
            tuneablep->nbytes);

        return (PICL_SUCCESS);
}

int
get_dimm_fan_speed(int fan_fd, fanspeed_t *fanspeedp)
{
        int16_t dimm_fan_period;
        i2c_reg_t       i2c_reg;

        /*
         * The dimm fan period is 16 bit value and we need to read
         * registers 2 and 3 to get the LSB and MSB values.
         */
        i2c_reg.reg_num = PIC16F819_FAN_PERIOD_MSB_REGISTER;
        if (ioctl(fan_fd, I2C_GET_REG, &i2c_reg) == -1) {
                if (env_debug)
                        envd_log(LOG_ERR,
                        "Error in reading FAN_PERIOD MSB REGISTER\n");
                return (-1);
        }
        dimm_fan_period = (i2c_reg.reg_value << 8);
        i2c_reg.reg_num = PIC16F819_FAN_PERIOD_LSB_REGISTER;
        if (ioctl(fan_fd, I2C_GET_REG, &i2c_reg) == -1) {
                if (env_debug)
                        envd_log(LOG_ERR,
                        "Error in reading FAN_PERIOD LSB REGISTER\n");
                return (-1);
        }
        dimm_fan_period |= i2c_reg.reg_value;
        if (env_debug)
                envd_log(LOG_ERR,
                " dimm fan tach period is 0x%x\n", dimm_fan_period);
        if (dimm_fan_period == 0) {
                if (env_debug)
                        envd_log(LOG_ERR,
                        "dimm fan tach period read as zero. Illegal value.\n");
                return (-1);
        }
        *fanspeedp = PIC16F819_FAN_TACH_TO_RPM(dimm_fan_period);
        return (0);
}

int
is_dimm_fan_failed(void)
{
        i2c_reg_t       i2c_reg;
        fanspeed_t      fan_speed;
        int             retry_count;

        if (envd_dimm_fan.fd == -1)
                return (-1);
        /*
         * read register 1 to look at Fan fault bit.
         */
        i2c_reg.reg_num = PIC16F819_STATUS_REGISTER;
        retry_count = MAX_RETRIES_FOR_PIC16F819_REG_READ;
        while (retry_count > 0) {
                if (ioctl(envd_dimm_fan.fd, I2C_GET_REG, &i2c_reg) == -1) {
                        retry_count--;
                        continue;
                } else break;
        }
        if (retry_count != MAX_RETRIES_FOR_PIC16F819_REG_READ) {
                if (env_debug)
                        envd_log(LOG_ERR,
                            "%d retries attempted in reading STATUS "
                            "register.\n",
                            (MAX_RETRIES_FOR_PIC16F819_REG_READ - retry_count));
        }
        if (retry_count == 0) {
                (void) strncpy(dimm_fan_status_string, NOT_AVAILABLE,
                    sizeof (dimm_fan_status_string));
                (void) strncpy(dimm_fan_command_string, NOT_AVAILABLE,
                    sizeof (dimm_fan_command_string));
                (void) strncpy(dimm_fan_debug_string, NOT_AVAILABLE,
                    sizeof (dimm_fan_debug_string));
                (void) strncpy(dimm_fan_rpm_string, NOT_AVAILABLE,
                    sizeof (dimm_fan_rpm_string));
                return (-1);
        }
        if (env_debug)
                envd_log(LOG_ERR,
                "DIMM FAN STATUS reg = 0x%x\n", i2c_reg.reg_value);
        if (i2c_reg.reg_value & PIC16F819_FAN_FAILED) {
                (void) snprintf(dimm_fan_status_string,
                    sizeof (dimm_fan_status_string), "0x%x",
                    i2c_reg.reg_value);
                i2c_reg.reg_num = PIC16F819_DEBUG_REGISTER;
                if (ioctl(envd_dimm_fan.fd, I2C_GET_REG, &i2c_reg) == -1) {
                        (void) strncpy(dimm_fan_debug_string, NOT_AVAILABLE,
                            sizeof (dimm_fan_debug_string));
                } else {
                        (void) snprintf(dimm_fan_debug_string,
                            sizeof (dimm_fan_debug_string),
                            "0x%x", i2c_reg.reg_value);
                }
                i2c_reg.reg_num = PIC16F819_COMMAND_REGISTER;
                if (ioctl(envd_dimm_fan.fd, I2C_GET_REG, &i2c_reg) == -1) {
                        (void) strncpy(dimm_fan_command_string, NOT_AVAILABLE,
                            sizeof (dimm_fan_command_string));
                } else {
                        (void) snprintf(dimm_fan_command_string,
                            sizeof (dimm_fan_command_string),
                            "0x%x", i2c_reg.reg_value);
                }
                if (get_dimm_fan_speed(envd_dimm_fan.fd, &fan_speed) == -1) {
                        (void) strncpy(dimm_fan_rpm_string, NOT_AVAILABLE,
                            sizeof (dimm_fan_rpm_string));
                } else {
                        (void) snprintf(dimm_fan_rpm_string,
                            sizeof (dimm_fan_rpm_string),
                            "%d", fan_speed);
                }
                return (1);
        } else return (0);
}