taco/envd/piclenvd.c

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

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

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

/*
 * This plugin sets up the PICLTREE for Taco.
 * It provides functionality to get/set temperatures
 * and fan speeds
 *
 * The environmental monitoring policy is the default
 * 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 <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 "envd.h"

/*
 * PICL plguin 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 uint_t envd_sleep(uint_t);

#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,
};

/*
 * 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_thr_created = B_FALSE;
static pthread_t  ovtemp_thr_id;
static pthread_attr_t thr_attr;


/*
 * PM thread related variabled
 */
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_FAN_DEVFS, NULL,
    SYSTEM_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_FAN_DEVFS, NULL,
    SYSTEM_FAN_ID, SYSTEM_INTAKE_FAN_SPEED_MIN,
    SYSTEM_INTAKE_FAN_SPEED_MAX, -1, -1,
};

static env_fan_t envd_cpu_fan = {
    ENV_CPU_FAN, ENV_CPU_FAN_DEVFS, NULL,
    CPU_FAN_ID, CPU_FAN_SPEED_MIN, CPU_FAN_SPEED_MAX, -1, -1,
};

/*
 * NULL terminated array of fans
 */
static env_fan_t *envd_fans[] = {
    &envd_cpu_fan,
    &envd_sys_in_fan,
    &envd_sys_out_fan,
    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 */
};

/*
 * Fan names associated with each ADM1031 hwms - used to
 * print fault messages
 */
static char *hwm_fans[MAX_HWMS][2] = {
    {ENV_CPU_FAN, ENV_SYSTEM_IN_OUT_FANS}
};

/*
 * Temperature sensors
 */
static env_sensor_t envd_sensors[] = {
    { SENSOR_CPU_DIE, SENSOR_CPU_DIE_DEVFS, NULL,
        CPU_SENSOR_ID, CPU_HWM_ID, (void *)&envd_cpu_fan, -1},
    { SENSOR_INT_AMB, SENSOR_INT_AMB_DEVFS, NULL,
        INT_AMB_SENSOR_ID, CPU_HWM_ID, NULL, -1},
    { SENSOR_SYS_IN, SENSOR_SYS_IN_DEVFS, NULL,
        SYS_IN_SENSOR_ID, CPU_HWM_ID, (void *)&envd_sys_in_fan, -1},
};
#define N_ENVD_SENSORS  (sizeof (envd_sensors)/sizeof (envd_sensors[0]))

/*
 * 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 MONITOR_ENABLE_MASK     (0x01)
#define ADM_SETFANSPEED_CONV(speed) (15 * speed / 100)

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

static int get_monitor_mode(ptree_rarg_t *parg, void *buf);
static int set_monitor_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_tach(ptree_rarg_t *parg, void *buf);
static int set_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  shutdown_interval   = SHUTDOWN_INTERVAL;
static int  ovtemp_monitor      = 1;    /* enabled */
static int  pm_monitor      = 1;    /* enabled */
static int  mon_fanstat     = 1;    /* enabled */

static int  hwm_mode;
static int  hwm_tach_enable;
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)},

    {"hwm-automode-enable", PICL_PTYPE_INT, &hwm_mode,
        &get_monitor_mode, &set_monitor_mode, sizeof (int)},

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

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

    {"tach-enable", PICL_PTYPE_INT, &hwm_tach_enable,
        &get_tach, &set_tach,
        sizeof (int)},

    {"monitor-fanstat", PICL_PTYPE_INT, &mon_fanstat,
        &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 (xval <= xymap[0].x)
        return (xymap[0].y);
    else 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
 */
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, path);
        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);

        (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 (snodep = envd_sensors; snodep->name != NULL; snodep++)
        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()
{
    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()
{
    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);
}

/*
 * 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 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
 * 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);
    else 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
 * Returns -1 on error, 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;

    for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
        (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 (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);
}

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

    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;

        (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 = CPU_HWM_ID;
    uint8_t mode;
    static uint16_t tsave = 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;
    }
    /* Read ADM default value only for the first time */
    if (tsave == 0) {
        if (ioctl(sensorp->fd, ADM1031_GET_TEMP_MIN_RANGE,
            &tsave) == -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;

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

    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_IN, cur_lpstate);
        }
    }
    /*NOTREACHED*/
    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 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 turns the fan 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)
            continue;

        if (sensorp->tmin != -1) {
            check_fanstat(sensorp);
        } else {
            fanp->fanstat = 1;
        }
    }
    /*
     * On Taco both the system fans are driven by one
     * sensor (sys-in) and connected to the sys-in tach.
     */
    envd_sys_out_fan.fanstat = envd_sys_in_fan.fanstat;

}

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;

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

        (void) envd_sleep(SENSORPOLL_INTERVAL);
    }
}

/*
 * 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 Taco there will be one thread for the ADM chip.
 */
static void *
ovtemp_thr(void *args)
{
    int fd;
    uint8_t stat[2];
    int hwm_id = (int)args;
    int  err;

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

    for (;;) {

        /*
         * Monitor the sensors to update status
         */
        if (mon_fanstat)
            monitor_fanstat();

        /*
         * Sleep for specified seconds before issuing IOCTL
         * again.
         */
        (void) envd_sleep(INTERRUPTPOLL_INTERVAL);

        /*
         * Read ADM1031 two Status Register 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)
            envd_log(LOG_ERR, ENV_FAN_FAULT,
                hwm_devs[hwm_id], hwm_fans[hwm_id][HWM_FAN1]);

        if (stat[1] & FANFAULT)
            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);
    }
    /*NOTREACHED*/
    return (NULL);
}

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

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

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

    if (ovtemp_monitor && ovtemp_thr_created == B_FALSE) {
        if (pthread_create(&ovtemp_thr_id, &thr_attr, ovtemp_thr,
            (void *)CPU_HWM_ID) != 0)
            envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
        else
            ovtemp_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;
    }
    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);
}

#ifdef __lint
/*
 * Redefine sigwait to posix style external declaration so that LINT
 * does not check against libc version of sigwait() and complain as
 * it uses different number of arguments.
 */
#define sigwait my_posix_sigwait
extern int my_posix_sigwait(const sigset_t *set, int *sig);
#endif

static uint_t
envd_sleep(uint_t sleep_tm)
{
    int sig;
    uint_t unslept;
    sigset_t alrm_mask;

    if (sleep_tm == 0)
        return (0);

    (void) sigemptyset(&alrm_mask);
    (void) sigaddset(&alrm_mask, SIGALRM);

    (void) alarm(sleep_tm);
    (void) sigwait(&alrm_mask, &sig);

    unslept = alarm(0);
    return (unslept);
}

/*
 * 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_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_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_monitor_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_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_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;

    proph = parg->proph;

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

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