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

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <sys/types.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/callb.h>
#include <sys/strlog.h>
#include <sys/cyclic.h>
#include <sys/rmc_comm_dp.h>
#include <sys/rmc_comm_dp_boot.h>
#include <sys/rmc_comm_drvintf.h>
#include <sys/rmc_comm.h>
#include <sys/machsystm.h>
#include <sys/sysevent.h>
#include <sys/sysevent/dr.h>
#include <sys/sysevent/env.h>
#include <sys/sysevent/eventdefs.h>
#include <sys/file.h>
#include <sys/disp.h>
#include <sys/reboot.h>
#include <sys/envmon.h>
#include <sys/rmclomv_impl.h>
#include <sys/cpu_sgnblk_defs.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include <sys/ddi.h>
#include <sys/time.h>
#include <sys/promif.h>
#include <sys/sysmacros.h>

#define RMCRESBUFLEN    1024
#define DATE_TIME_MSG_SIZE      78
#define RMCLOMV_WATCHDOG_MODE   "rmclomv-watchdog-mode"
#define DELAY_TIME      5000000  /* 5 seconds, in microseconds */
#define CPU_SIGNATURE_DELAY_TIME        5000000  /* 5 secs, in microsecs */

extern void     pmugpio_watchdog_pat();

extern int      watchdog_activated;
static int      last_watchdog_msg = 1;
extern int      watchdog_enable;
extern int      boothowto;

int             rmclomv_watchdog_mode;

/*
 * functions local to this driver.
 */
static int      rmclomv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
    void **resultp);
static int      rmclomv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int      rmclomv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static uint_t   rmclomv_break_intr(caddr_t arg);
static int      rmclomv_add_intr_handlers(void);
static int      rmclomv_remove_intr_handlers(void);
static uint_t   rmclomv_event_data_handler(char *);
static void     rmclomv_dr_data_handler(const char *, int);
static int      rmclomv_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p);
static int      rmclomv_close(dev_t dev, int flag, int otyp, cred_t *cred_p);
static int      rmclomv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
    cred_t *cred_p, int *rval_p);
static void     rmclomv_checkrmc_start(void);
static void     rmclomv_checkrmc_destroy(void);
static void     rmclomv_checkrmc_wakeup(void *);
static void     rmclomv_refresh_start(void);
static void     rmclomv_refresh_destroy(void);
static void     rmclomv_refresh_wakeup(void);
static void     rmclomv_reset_cache(rmclomv_cache_section_t *new_chain,
    rmclomv_cache_section_t *new_subchain, dp_get_sysinfo_r_t *sysinfo);
static rmclomv_cache_section_t *rmclomv_find_section(
    rmclomv_cache_section_t *start, uint16_t sensor);
static rmclomv_cache_section_t *create_cache_section(int sensor_type, int num);
static int      get_sensor_by_name(const rmclomv_cache_section_t *section,
    const char *name, int *index);
static int      validate_section_entry(rmclomv_cache_section_t *section,
    int index);
static int      add_names_to_section(rmclomv_cache_section_t *section);
static void     free_section(rmclomv_cache_section_t *section);
static void     add_section(rmclomv_cache_section_t **head,
    rmclomv_cache_section_t *section);
static int      rmclomv_do_cmd(int req_cmd, int resp_cmd, int resp_len,
    intptr_t arg_req, intptr_t arg_res);
static void     refresh_name_cache(int force_fail);
static void     set_val_unav(envmon_sensor_t *sensor);
static void     set_fan_unav(envmon_fan_t *fan);
static int      do_psu_cmd(intptr_t arg, int mode, envmon_indicator_t *env_ind,
    dp_get_psu_status_t *rmc_psu, dp_get_psu_status_r_t *rmc_psu_r,
    int detector_type);
static uint_t rmc_set_watchdog_timer(uint_t timeoutval);
static uint_t rmc_clear_watchdog_timer(void);
static void send_watchdog_msg(int msg);
static void plat_timesync(void *arg);

static kmutex_t         timesync_lock;
static clock_t          timesync_interval = 0;
static timeout_id_t     timesync_tid = 0;

/*
 * Driver entry points
 */
static struct cb_ops rmclomv_cb_ops = {
        rmclomv_open,   /* open */
        rmclomv_close,  /* close */
        nodev,          /* strategy() */
        nodev,          /* print() */
        nodev,          /* dump() */
        nodev,          /* read() */
        nodev,          /* write() */
        rmclomv_ioctl,  /* ioctl() */
        nodev,          /* devmap() */
        nodev,          /* mmap() */
        ddi_segmap,     /* segmap() */
        nochpoll,       /* poll() */
        ddi_prop_op,    /* prop_op() */
        NULL,           /* cb_str */
        D_NEW | D_MP    /* cb_flag */
};


static struct dev_ops rmclomv_ops = {
        DEVO_REV,
        0,                      /* ref count */
        rmclomv_getinfo,        /* getinfo() */
        nulldev,                /* identify() */
        nulldev,                /* probe() */
        rmclomv_attach,         /* attach() */
        rmclomv_detach,         /* detach */
        nodev,                  /* reset */
        &rmclomv_cb_ops,                /* pointer to cb_ops structure */
        (struct bus_ops *)NULL,
        nulldev,                /* power() */
        ddi_quiesce_not_supported,      /* devo_quiesce */
};

/*
 * Loadable module support.
 */
extern struct mod_ops mod_driverops;

static struct modldrv modldrv = {
        &mod_driverops,                 /* Type of module. This is a driver */
        "rmclomv control driver",       /* Name of the module */
        &rmclomv_ops                    /* pointer to the dev_ops structure */
};

static struct modlinkage modlinkage = {
        MODREV_1,
        &modldrv,
        NULL
};

/*
 * Device info
 */
static dev_info_t               *rmclomv_dip = NULL;
static int                      rmclomv_break_requested = B_FALSE;
static ddi_softintr_t           rmclomv_softintr_id;
static ddi_iblock_cookie_t      rmclomv_soft_iblock_cookie;

extern void (*abort_seq_handler)();
/* key_position is effective key-position. Set to locked if unknown */
static rsci8 key_position = RMC_KEYSWITCH_POS_LOCKED;
/* real_key_position starts off as unknown and records value actually seen */
static rsci8 real_key_position = RMC_KEYSWITCH_POS_UNKNOWN;
static void rmclomv_abort_seq_handler(char *msg);

/*
 * mutexes which protect the interrupt handlers.
 */
static kmutex_t         rmclomv_event_hdlr_lock;
static kmutex_t         rmclomv_refresh_lock;
static kcondvar_t       rmclomv_refresh_sig_cv;
static kmutex_t         rmclomv_checkrmc_lock;
static kcondvar_t       rmclomv_checkrmc_sig_cv;

/*
 * mutex to protect the handle_name cache
 */
static kmutex_t         rmclomv_cache_lock;

/*
 * mutex to protect the RMC state
 */
static kmutex_t         rmclomv_state_lock;

/*
 * Payloads of the event handlers.
 */
static dp_event_notification_t  rmclomv_event_payload;
static rmc_comm_msg_t   rmclomv_event_payload_msg;

/*
 * Checkrmc commands..
 */
#define RMCLOMV_CHECKRMC_EXITNOW        (-1)
#define RMCLOMV_CHECKRMC_WAIT           0
#define RMCLOMV_CHECKRMC_PROCESSNOW     1

/*
 * Checkrmc thread state
 */
static int rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_WAIT;
static kt_did_t rmclomv_checkrmc_tid = 0;

/*
 * RMC state data
 */
#define RMCLOMV_RMCSTATE_UNKNOWN        0
#define RMCLOMV_RMCSTATE_OK             1
#define RMCLOMV_RMCSTATE_FAILED         2
#define RMCLOMV_RMCSTATE_DOWNLOAD       3

/*
 * RMC error indicator values (status from last RMC command)
 */
#define RMCLOMV_RMCERROR_NONE           0

/* fail RMC after 5 minutes without a good response */
#define RMCLOMV_RMCFAILTHRESHOLD        5

/*
 * rmclomv_rmc_state is the state reported in OperationalStatus.
 * rmclomv_rmc_error reflects the result of the last RMC interaction.
 * rmclomv_rmcfailcount is used by the rmclomv_checkrmc thread to count
 * failures in its regular status polls. Once RMCLOMV_RMCFAILTHRESHOLD
 * is reached, rmclomv_rmc_state is marked as RMCLOMV_RMCSTATE_FAILED.
 */
static int      rmclomv_rmc_state = RMCLOMV_RMCSTATE_UNKNOWN;
static int      rmclomv_rmc_error = RMCLOMV_RMCERROR_NONE;
static int      rmclomv_rmcfailcount;

/*
 * Refresh commands..
 */
#define RMCLOMV_REFRESH_EXITNOW         (-1)
#define RMCLOMV_REFRESH_WAIT            0
#define RMCLOMV_REFRESH_PROCESSNOW      1

/*
 * Refresh thread state
 */
static int rmclomv_refresh_sig = RMCLOMV_REFRESH_WAIT;
static kt_did_t rmclomv_refresh_tid = 0;

/*
 * timeout id
 */
static timeout_id_t     timer_id;

/*
 * Handle-name cache
 */
#define LOCK_CACHE              mutex_enter(&rmclomv_cache_lock);
#define RELEASE_CACHE           mutex_exit(&rmclomv_cache_lock);
static rmclomv_cache_section_t  *rmclomv_cache;         /* main handle-names */
static rmclomv_cache_section_t  *rmclomv_subcache;      /* derived names */
static dp_get_sysinfo_r_t       rmclomv_sysinfo_data;
static boolean_t                rmclomv_sysinfo_valid;
static int                      rmclomv_cache_valid;

extern pri_t maxclsyspri;

/*
 * static strings
 */
static const char       str_percent[]           = "%";
static const char       str_rpm[]               = " rpm";
static const char       str_ip_volts_ind[]      = "P_PWR";
static const char       str_ip2_volts_ind[]     = "P_PWR2";
static const char       str_ff_pok_ind[]        = "FF_POK";
static const char       str_vlo_volts_ind[]     = "FF_UV";
static const char       str_vhi_volts_ind[]     = "FF_OV";
static const char       str_chi_amps_ind[]      = "FF_OC";
static const char       str_chi_nr_ind[]        = "FF_NR";
static const char       str_ot_tmpr_ind[]       = "FF_OT";
static const char       str_fan_ind[]           = "FF_FAN";
static const char       str_pdct_fan_ind[]      = "FF_PDCT_FAN";
static const char       str_sc[]                = "SC";

int
_init(void)
{
        int     error = 0;

        mutex_init(&rmclomv_event_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);
        mutex_init(&rmclomv_checkrmc_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&rmclomv_refresh_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&rmclomv_cache_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&rmclomv_state_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&timesync_lock, NULL, MUTEX_DEFAULT, NULL);
        cv_init(&rmclomv_checkrmc_sig_cv, NULL, CV_DRIVER, NULL);
        cv_init(&rmclomv_refresh_sig_cv, NULL, CV_DRIVER, NULL);

        error = mod_install(&modlinkage);
        if (error) {
                cv_destroy(&rmclomv_refresh_sig_cv);
                cv_destroy(&rmclomv_checkrmc_sig_cv);
                mutex_destroy(&rmclomv_state_lock);
                mutex_destroy(&rmclomv_cache_lock);
                mutex_destroy(&rmclomv_refresh_lock);
                mutex_destroy(&rmclomv_checkrmc_lock);
                mutex_destroy(&rmclomv_event_hdlr_lock);
        }
        return (error);
}


int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}


int
_fini(void)
{
        int     error = 0;

        error = mod_remove(&modlinkage);
        if (error)
                return (error);
        cv_destroy(&rmclomv_refresh_sig_cv);
        cv_destroy(&rmclomv_checkrmc_sig_cv);
        mutex_destroy(&timesync_lock);
        mutex_destroy(&rmclomv_state_lock);
        mutex_destroy(&rmclomv_cache_lock);
        mutex_destroy(&rmclomv_refresh_lock);
        mutex_destroy(&rmclomv_checkrmc_lock);
        mutex_destroy(&rmclomv_event_hdlr_lock);
        return (error);
}


/* ARGSUSED */
static int
rmclomv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
        minor_t m = getminor((dev_t)arg);

        switch (cmd) {
        case DDI_INFO_DEVT2DEVINFO:
                if ((m != 0) || (rmclomv_dip == NULL)) {
                        *resultp = NULL;
                        return (DDI_FAILURE);
                }
                *resultp = rmclomv_dip;
                return (DDI_SUCCESS);
        case DDI_INFO_DEVT2INSTANCE:
                *resultp = (void *)(uintptr_t)m;
                return (DDI_SUCCESS);
        default:
                return (DDI_FAILURE);
        }
}


static int
rmclomv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int                     instance;
        int                     err;
        char                    *wdog_state;
        int                     attaching = 1;

        switch (cmd) {
        case DDI_ATTACH:
                /*
                 * only allow one instance
                 */
                instance = ddi_get_instance(dip);
                if (instance != 0)
                        return (DDI_FAILURE);

                err = ddi_create_minor_node(dip, "rmclomv", S_IFCHR,
                    instance, DDI_PSEUDO, 0);
                if (err != DDI_SUCCESS)
                        return (DDI_FAILURE);

                /*
                 * Register with rmc_comm to prevent it being detached
                 * (in the unlikely event that its attach succeeded on a
                 * platform whose platmod doesn't lock it down).
                 */
                err = rmc_comm_register();
                if (err != DDI_SUCCESS) {
                        ddi_remove_minor_node(dip, NULL);
                        return (DDI_FAILURE);
                }

                /* Remember the dev info */
                rmclomv_dip = dip;

                /*
                 * Add the handlers which watch for unsolicited messages
                 * and post event to Sysevent Framework.
                 */
                err = rmclomv_add_intr_handlers();
                if (err != DDI_SUCCESS) {
                        rmc_comm_unregister();
                        ddi_remove_minor_node(dip, NULL);
                        rmclomv_dip = NULL;
                        return (DDI_FAILURE);
                }

                rmclomv_checkrmc_start();
                rmclomv_refresh_start();

                abort_seq_handler = rmclomv_abort_seq_handler;
                ddi_report_dev(dip);

                /*
                 * Check whether we have an application watchdog
                 */
                if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip,
                    DDI_PROP_DONTPASS, RMCLOMV_WATCHDOG_MODE,
                    &wdog_state) == DDI_PROP_SUCCESS) {
                        if (strcmp(wdog_state, "app") == 0) {
                                rmclomv_watchdog_mode = 1;
                                watchdog_enable = 0;
                        }
                        else
                                rmclomv_watchdog_mode = 0;
                        ddi_prop_free(wdog_state);
                }

                tod_ops.tod_set_watchdog_timer = rmc_set_watchdog_timer;
                tod_ops.tod_clear_watchdog_timer = rmc_clear_watchdog_timer;

                /*
                 * Now is a good time to activate hardware watchdog
                 * (if one exists).
                 */
                mutex_enter(&tod_lock);
                if (watchdog_enable && tod_ops.tod_set_watchdog_timer != NULL)
                        err = tod_ops.tod_set_watchdog_timer(0);
                mutex_exit(&tod_lock);
                if (err != 0)
                        printf("Hardware watchdog enabled\n");

                /*
                 * Set time interval and start timesync routine.
                 * Also just this once set the Solaris clock
                 * to the RMC clock.
                 */
                timesync_interval = drv_usectohz(5*60 * MICROSEC);
                plat_timesync((void *) &attaching);

                return (DDI_SUCCESS);
        case DDI_RESUME:
                return (DDI_SUCCESS);
        default:
                return (DDI_FAILURE);
        }
}


static int
rmclomv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        timeout_id_t    tid;
        int             instance;
        int             err;

        switch (cmd) {
        case DDI_DETACH:
                instance = ddi_get_instance(dip);
                if (instance != 0)
                        return (DDI_FAILURE);

                /*
                 * Remove the handlers which watch for unsolicited messages
                 * and post event to Sysevent Framework.
                 */
                err = rmclomv_remove_intr_handlers();
                if (err != DDI_SUCCESS) {
                        cmn_err(CE_WARN, "Failed to remove event handlers");
                        return (DDI_FAILURE);
                }
                rmclomv_checkrmc_destroy();
                rmclomv_refresh_destroy();
                rmclomv_reset_cache(NULL, NULL, NULL);
                ddi_remove_minor_node(dip, NULL);

                mutex_enter(&timesync_lock);
                tid = timesync_tid;
                timesync_tid = 0;
                timesync_interval = 0;
                mutex_exit(&timesync_lock);
                (void) untimeout(tid);

                /* Forget the dev info */
                rmclomv_dip = NULL;
                rmc_comm_unregister();
                return (DDI_SUCCESS);
        case DDI_SUSPEND:
                return (DDI_SUCCESS);
        default:
                return (DDI_FAILURE);
        }
}

static int
rmclomv_add_intr_handlers()
{
        int     err;

        if (ddi_get_soft_iblock_cookie(rmclomv_dip, DDI_SOFTINT_HIGH,
            &rmclomv_soft_iblock_cookie) != DDI_SUCCESS) {
                return (DDI_FAILURE);
        }
        err = ddi_add_softintr(rmclomv_dip, DDI_SOFTINT_HIGH,
            &rmclomv_softintr_id, &rmclomv_soft_iblock_cookie, NULL,
            rmclomv_break_intr, NULL);
        if (err != DDI_SUCCESS)
                return (DDI_FAILURE);
        rmclomv_event_payload_msg.msg_buf = (caddr_t)&rmclomv_event_payload;
        rmclomv_event_payload_msg.msg_len = sizeof (rmclomv_event_payload);
        err = rmc_comm_reg_intr(DP_RMC_EVENTS, rmclomv_event_data_handler,
            &rmclomv_event_payload_msg, NULL, &rmclomv_event_hdlr_lock);
        if (err != 0) {
                ddi_remove_softintr(rmclomv_softintr_id);
                return (DDI_FAILURE);
        }
        return (DDI_SUCCESS);
}

static int
rmclomv_remove_intr_handlers(void)
{
        int err = rmc_comm_unreg_intr(DP_RMC_EVENTS,
            rmclomv_event_data_handler);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to unregister DP_RMC_EVENTS "
                    "handler. Err=%d", err);
                return (DDI_FAILURE);
        }
        ddi_remove_softintr(rmclomv_softintr_id);
        return (DDI_SUCCESS);
}

static void
rmclomv_abort_seq_handler(char *msg)
{
        if (key_position == RMC_KEYSWITCH_POS_LOCKED)
                cmn_err(CE_CONT, "KEY in LOCKED position, "
                    "ignoring debug enter sequence");
        else  {
                rmclomv_break_requested = B_TRUE;
                if (msg != NULL)
                        prom_printf("%s\n", msg);

                ddi_trigger_softintr(rmclomv_softintr_id);
        }
}

/* ARGSUSED */
static uint_t
rmclomv_break_intr(caddr_t arg)
{
        if (rmclomv_break_requested) {
                rmclomv_break_requested = B_FALSE;
                debug_enter(NULL);
                return (DDI_INTR_CLAIMED);
        }

        return (DDI_INTR_UNCLAIMED);
}

/*
 * Create a cache section structure
 */
static rmclomv_cache_section_t *
create_cache_section(int sensor_type, int num)
{
        size_t len = offsetof(rmclomv_cache_section_t, entry[0]) +
            num * sizeof (rmclomv_cache_entry_t);
        rmclomv_cache_section_t *ptr = kmem_zalloc(len, KM_SLEEP);
        ptr->next_section = NULL;
        ptr->sensor_type = sensor_type;
        ptr->num_entries = num;
        ptr->section_len = len;
        return (ptr);
}

/*
 * Free a cache_section.
 */
static void
free_section(rmclomv_cache_section_t *section)
{
        size_t len = section->section_len;
        kmem_free(section, len);
}

/*
 * adds supplied section to end of cache chain
 * must be called with cache locked
 */
static void
add_section(rmclomv_cache_section_t **head, rmclomv_cache_section_t *section)
{
        section->next_section = *head;
        *head = section;
}

/*
 * This function releases all cache sections and exchanges the two
 * chain heads for new values.
 */
static void
rmclomv_reset_cache(rmclomv_cache_section_t *new_chain,
    rmclomv_cache_section_t *new_subchain, dp_get_sysinfo_r_t *sysinfo)
{
        rmclomv_cache_section_t *first;
        rmclomv_cache_section_t *sub_first;
        rmclomv_cache_section_t *next;

        LOCK_CACHE

        rmclomv_cache_valid = (new_chain != NULL);
        first = rmclomv_cache;
        rmclomv_cache = new_chain;
        sub_first = rmclomv_subcache;
        rmclomv_subcache = new_subchain;

        if (sysinfo == NULL)
                bzero(&rmclomv_sysinfo_data, sizeof (rmclomv_sysinfo_data));
        else
                bcopy(sysinfo, &rmclomv_sysinfo_data,
                    sizeof (rmclomv_sysinfo_data));

        rmclomv_sysinfo_valid = (sysinfo != NULL);

        RELEASE_CACHE

        while (first != NULL) {
                next = first->next_section;
                free_section(first);
                first = next;
        }

        while (sub_first != NULL) {
                next = sub_first->next_section;
                free_section(sub_first);
                sub_first = next;
        }
}

/*
 * cache must be locked before calling rmclomv_find_section
 */
static rmclomv_cache_section_t *
rmclomv_find_section(rmclomv_cache_section_t *start, uint16_t sensor)
{
        rmclomv_cache_section_t *next = start;

        while ((next != NULL) && (next->sensor_type != sensor))
                next = next->next_section;

        return (next);
}

/*
 * Return a string presenting the keyswitch position
 * For unknown values returns "Unknown"
 */
static char *
rmclomv_key_position(enum rmc_keyswitch_pos pos)
{
        switch (pos) {

        case RMC_KEYSWITCH_POS_NORMAL:
                return ("NORMAL");
        case RMC_KEYSWITCH_POS_DIAG:
                return ("DIAG");
        case RMC_KEYSWITCH_POS_LOCKED:
                return ("LOCKED");
        case RMC_KEYSWITCH_POS_OFF:
                return ("STBY");
        default:
                return ("UNKNOWN");
        }
}

/*
 * The sensor id name is sought in the supplied section and if found
 * its index within the section is written to *index.
 * Return value is zero for success, otherwise -1.
 * The cache must be locked before calling get_sensor_by_name
 */
static int
get_sensor_by_name(const rmclomv_cache_section_t *section,
    const char *name, int *index)
{
        int i;

        for (i = 0; i < section->num_entries; i++) {
                if (strcmp(name, section->entry[i].handle_name.name) == 0) {
                        *index = i;
                        return (0);
                }
        }

        *index = 0;
        return (-1);
}

/*
 * fills in the envmon_handle name
 * if it is unknown (not cached), the dp_handle_t is returned as a hex-digit
 * string
 */
static void
rmclomv_hdl_to_envhdl(dp_handle_t hdl, envmon_handle_t *envhdl)
{
        rmclomv_cache_section_t *next;
        int                     i;

        LOCK_CACHE

        for (next = rmclomv_cache; next != NULL; next = next->next_section) {
                for (i = 0; i < next->num_entries; i++) {
                        if (next->entry[i].handle == hdl) {
                                *envhdl = next->entry[i].handle_name;
                                        RELEASE_CACHE
                                        return;
                        }
                }
        }

        /*
         * Sought handle not currently cached.
         */
        RELEASE_CACHE

        (void) snprintf(envhdl->name, sizeof (envhdl->name),
            "Unknown SC node 0x%x", hdl);
}

static void
rmclomv_dr_data_handler(const char *fru_name, int hint)
{
        int                             err = 0;
        nvlist_t                        *attr_list;
        char                            attach_pnt[MAXPATHLEN];

        (void) snprintf(attach_pnt, sizeof (attach_pnt), "%s", fru_name);

        err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP);
        if (err != 0) {
                cmn_err(CE_WARN,
                    "Failed to allocate name-value list for %s event", EC_DR);
                return;
        }

        err = nvlist_add_string(attr_list, DR_AP_ID, attach_pnt);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s event",
                    DR_AP_ID, EC_DR);
                nvlist_free(attr_list);
                return;
        }

        /*
         * Add the hint
         */
        err = nvlist_add_string(attr_list, DR_HINT, SE_HINT2STR(hint));
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s event",
                    DR_HINT, EC_DR);
                nvlist_free(attr_list);
                return;
        }

        err = ddi_log_sysevent(rmclomv_dip, DDI_VENDOR_SUNW, EC_DR,
            ESC_DR_AP_STATE_CHANGE, attr_list, NULL, DDI_NOSLEEP);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to log %s/%s event",
                    DR_AP_ID, EC_DR);
        }

        nvlist_free(attr_list);
}

static void
fan_sysevent(char *fru_name, char *sensor_name, int sub_event)
{
        nvlist_t                *attr_list;
        char                    fan_str[MAXNAMELEN];
        int                     err;

        err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP);
        if (err != 0) {
                cmn_err(CE_WARN,
                    "Failed to allocate name-value list for %s/%s event",
                    EC_ENV, ESC_ENV_FAN);
                return;
        }

        err = nvlist_add_string(attr_list, ENV_FRU_ID, fru_name);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_FRU_ID, EC_ENV, ESC_ENV_FAN);
                nvlist_free(attr_list);
                return;
        }

        err = nvlist_add_string(attr_list, ENV_FRU_RESOURCE_ID, sensor_name);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_FRU_RESOURCE_ID, EC_ENV, ESC_ENV_FAN);
                nvlist_free(attr_list);
                return;
        }

        err = nvlist_add_string(attr_list, ENV_FRU_DEVICE, ENV_RESERVED_ATTR);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_FRU_DEVICE, EC_ENV, ESC_ENV_FAN);
                nvlist_free(attr_list);
                return;
        }

        err = nvlist_add_int32(attr_list, ENV_FRU_STATE,
            (sub_event == RMC_ENV_FAULT_EVENT) ? ENV_FAILED : ENV_OK);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_FRU_STATE, EC_ENV, ESC_ENV_FAN);
                nvlist_free(attr_list);
                return;
        }

        if (sub_event == RMC_ENV_FAULT_EVENT) {
                (void) snprintf(fan_str, sizeof (fan_str),
                    "fan %s/%s is now failed", fru_name, sensor_name);
        } else {
                (void) snprintf(fan_str, sizeof (fan_str),
                    "fan %s/%s is now ok", fru_name, sensor_name);
        }
        err = nvlist_add_string(attr_list, ENV_MSG, fan_str);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_MSG, EC_ENV, ESC_ENV_FAN);
                nvlist_free(attr_list);
                return;
        }

        err = ddi_log_sysevent(rmclomv_dip, DDI_VENDOR_SUNW, EC_ENV,
            ESC_ENV_FAN, attr_list, NULL, DDI_NOSLEEP);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to log %s/%s event",
                    EC_ENV, ESC_ENV_FAN);
        }

        cmn_err(CE_NOTE, "%s", fan_str);
        nvlist_free(attr_list);
}

static void
threshold_sysevent(char *fru_name, char *sensor_name, int sub_event,
        char event_type)
{
        nvlist_t                *attr_list;
        int                     err;
        char                    *subclass;
        char                    sensor_str[MAXNAMELEN];

        subclass = (event_type == 'T') ? ESC_ENV_TEMP : ESC_ENV_POWER;

        err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP);
        if (err != 0) {
                cmn_err(CE_WARN,
                    "Failed to allocate name-value list for %s/%s event",
                    EC_ENV, subclass);
                return;
        }

        err = nvlist_add_string(attr_list, ENV_FRU_ID, fru_name);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_FRU_ID, EC_ENV, subclass);
                nvlist_free(attr_list);
                return;
        }

        err = nvlist_add_string(attr_list, ENV_FRU_RESOURCE_ID, sensor_name);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_FRU_RESOURCE_ID, EC_ENV, subclass);
                nvlist_free(attr_list);
                return;
        }

        err = nvlist_add_string(attr_list, ENV_FRU_DEVICE, ENV_RESERVED_ATTR);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_FRU_DEVICE, EC_ENV, subclass);
                nvlist_free(attr_list);
                return;
        }

        switch (sub_event) {
        case RMC_ENV_OK_EVENT:
                err = nvlist_add_int32(attr_list, ENV_FRU_STATE, ENV_OK);
                break;
        case RMC_ENV_WARNING_THRESHOLD_EVENT:
                err = nvlist_add_int32(attr_list, ENV_FRU_STATE, ENV_WARNING);
                break;
        case RMC_ENV_SHUTDOWN_THRESHOLD_EVENT:
                err = nvlist_add_int32(attr_list, ENV_FRU_STATE, ENV_FAILED);
                break;
        }
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_FRU_STATE, EC_ENV, subclass);
                nvlist_free(attr_list);
                return;
        }

        switch (sub_event) {
        case RMC_ENV_OK_EVENT:
                (void) snprintf(sensor_str, sizeof (sensor_str),
                    "sensor %s/%s is now ok", fru_name,
                    sensor_name);
                break;
        case RMC_ENV_WARNING_THRESHOLD_EVENT:
                (void) snprintf(sensor_str, sizeof (sensor_str),
                    "sensor %s/%s is now outside warning thresholds", fru_name,
                    sensor_name);
                break;
        case RMC_ENV_SHUTDOWN_THRESHOLD_EVENT:
                (void) snprintf(sensor_str, sizeof (sensor_str),
                    "sensor %s/%s is now outside shutdown thresholds", fru_name,
                    sensor_name);
                break;
        }
        err = nvlist_add_string(attr_list, ENV_MSG, sensor_str);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
                    ENV_MSG, EC_ENV, subclass);
                nvlist_free(attr_list);
                return;
        }

        err = ddi_log_sysevent(rmclomv_dip, DDI_VENDOR_SUNW, EC_ENV,
            subclass, attr_list, NULL, DDI_NOSLEEP);
        if (err != 0) {
                cmn_err(CE_WARN, "Failed to log %s/%s event",
                    EC_ENV, subclass);
        }

        cmn_err(CE_NOTE, "%s", sensor_str);
        nvlist_free(attr_list);
}

static uint_t
rmclomv_event_data_handler(char *arg)
{
        dp_event_notification_t *payload;
        rmc_comm_msg_t  *msg;
        envmon_handle_t envhdl;
        int hint;
        char *ptr, *save_ptr;

        if (arg == NULL) {
                return (DDI_INTR_CLAIMED);
        }

        msg = (rmc_comm_msg_t *)arg;
        if (msg->msg_buf == NULL) {
                return (DDI_INTR_CLAIMED);
        }

        payload = (dp_event_notification_t *)msg->msg_buf;
        switch (payload->event) {

        case RMC_KEYSWITCH_EVENT:
                real_key_position = payload->event_info.ev_keysw.key_position;
                cmn_err(CE_NOTE, "keyswitch change event - state = %s",
                    rmclomv_key_position(real_key_position));
                if ((real_key_position != RMC_KEYSWITCH_POS_UNKNOWN) &&
                    (real_key_position <= RMC_KEYSWITCH_POS_OFF)) {
                        key_position = real_key_position;
                } else {
                        /* treat unknown key position as locked */
                        key_position = RMC_KEYSWITCH_POS_LOCKED;
                }
                break;

        case RMC_HPU_EVENT:
                /*
                 * send appropriate sysevent
                 */
                switch (payload->event_info.ev_hpunot.sub_event) {
                case RMC_HPU_REMOVE_EVENT:
                        hint = SE_HINT_REMOVE;
                        break;
                case RMC_HPU_INSERT_EVENT:
                        hint = SE_HINT_INSERT;
                        break;
                default:
                        hint = SE_NO_HINT;
                        break;
                }
                rmclomv_hdl_to_envhdl(payload->event_info.ev_hpunot.hpu_hdl,
                    &envhdl);
                rmclomv_dr_data_handler(envhdl.name, hint);
                break;

        case RMC_INIT_EVENT:
                /*
                 * Wake up the refresh thread.
                 */
                rmclomv_refresh_wakeup();

                /*
                 * Wake up the checkrmc thread for an early indication to PICL
                 */
                rmclomv_checkrmc_wakeup(NULL);
                break;

        case RMC_ENV_EVENT:
                rmclomv_hdl_to_envhdl(payload->event_info.ev_envnot.env_hdl,
                    &envhdl);

                /* split name into fru name and sensor name */
                ptr = strchr(envhdl.name, '.');

                /* must have at least one '.' */
                if (ptr == NULL)
                        break;

                /* find last '.' - convert the others to '/' */
                for (;;) {
                        save_ptr = ptr;
                        ptr = strchr(ptr, '.');
                        if (ptr == NULL) {
                                ptr = save_ptr;
                                break;
                        }
                        *save_ptr = '/';
                }
                *ptr = '\0';
                ptr++;
                /* is it a voltage or temperature sensor? */
                if ((*ptr == 'V' || *ptr == 'T') && *(ptr + 1) == '_') {
                        switch (payload->event_info.ev_envnot.sub_event) {
                        case RMC_ENV_WARNING_THRESHOLD_EVENT:
                        case RMC_ENV_SHUTDOWN_THRESHOLD_EVENT:
                        case RMC_ENV_OK_EVENT:
                                threshold_sysevent(envhdl.name, ptr,
                                    payload->event_info.ev_envnot.sub_event,
                                    *ptr);
                                break;
                        default:
                                break;
                        }
                }

                /*
                 * is it a fan sensor?
                 * Fan sensor names end either in RS, F0 or F1
                 */
                if ((*ptr == 'R' && *(ptr + 1) == 'S' && *(ptr + 2) == '\0') ||
                    (*ptr == 'F' && *(ptr + 1) == '0' && *(ptr + 2) == '\0') ||
                    (*ptr == 'F' && *(ptr + 1) == '1' && *(ptr + 2) == '\0')) {
                        switch (payload->event_info.ev_envnot.sub_event) {
                        case RMC_ENV_FAULT_EVENT:
                        case RMC_ENV_OK_EVENT:
                                fan_sysevent(envhdl.name, ptr,
                                    payload->event_info.ev_envnot.sub_event);
                                break;
                        default:
                                break;
                        }
                }
                break;

        case RMC_LOG_EVENT:
        {
                int level = 10;
                int flags = SL_NOTE | SL_CONSOLE;
                char *message =
                    (char *)payload->event_info.ev_rmclog.log_record;

                message[ payload->event_info.ev_rmclog.log_record_size] = '\0';

                /*
                 * Logs have a 10 character prefix - specifying the severity of
                 * the event being logged. Thus all the magic number 10s down
                 * here
                 */
                if (0 == strncmp("CRITICAL: ", message, 10)) {
                        message += 10;
                        level = 0;
                        flags = SL_FATAL | SL_ERROR | SL_CONSOLE;
                } else if (0 == strncmp("MAJOR:    ", message, 10)) {
                        message += 10;
                        level = 5;
                        flags = SL_WARN | SL_ERROR | SL_CONSOLE;
                } else if (0 == strncmp("MINOR:    ", message, 10)) {
                        message += 10;
                        level = 10;
                        flags = SL_NOTE | SL_CONSOLE;
                }

                (void) strlog(0, 0, level, flags, message);
                break;
        }

        default:
                return (DDI_INTR_CLAIMED);
        }

        return (DDI_INTR_CLAIMED);
}

/*ARGSUSED*/
static int
rmclomv_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
{
        int error = 0;
        int instance = getminor(*dev_p);

        if (instance != 0)
                return (ENXIO);

        if ((flag & FWRITE) != 0 && (error = drv_priv(cred_p)) != 0)
                return (error);

        return (0);
}

/*ARGSUSED*/
static int
rmclomv_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
{
        return (DDI_SUCCESS);
}

static int
rmclomv_do_cmd(int req_cmd, int resp_cmd, int resp_len, intptr_t arg_req,
    intptr_t arg_res)
{
        rmc_comm_msg_t request, *reqp = &request;
        rmc_comm_msg_t response, *resp = &response;
        int rv = 0;

        bzero((caddr_t)&request, sizeof (request));
        reqp->msg_type = req_cmd;
        reqp->msg_buf = (caddr_t)arg_req;
        bzero((caddr_t)&response, sizeof (response));
        resp->msg_type = resp_cmd;
        resp->msg_buf = (caddr_t)arg_res;
        resp->msg_len = resp_len;

        switch (req_cmd) {
        case DP_GET_SYSINFO:
                resp->msg_len = sizeof (dp_get_sysinfo_r_t);
                break;
        case DP_GET_EVENT_LOG:
                resp->msg_len = sizeof (dp_get_event_log_r_t);
                break;
        case DP_GET_VOLTS:
                reqp->msg_len = sizeof (dp_get_volts_t);
                break;
        case DP_GET_TEMPERATURES:
                reqp->msg_len = sizeof (dp_get_temperatures_t);
                break;
        case DP_GET_CIRCUIT_BRKS:
                reqp->msg_len = sizeof (dp_get_circuit_brks_t);
                break;
        case DP_GET_FAN_STATUS:
                reqp->msg_len = sizeof (dp_get_fan_status_t);
                break;
        case DP_GET_PSU_STATUS:
                reqp->msg_len = sizeof (dp_get_psu_status_t);
                break;
        case DP_GET_LED_STATE:
                reqp->msg_len = sizeof (dp_get_led_state_t);
                break;
        case DP_SET_LED_STATE:
                reqp->msg_len = sizeof (dp_set_led_state_t);
                break;
        case DP_GET_FRU_STATUS:
                reqp->msg_len = sizeof (dp_get_fru_status_t);
                break;
        case DP_GET_HANDLE_NAME:
                reqp->msg_len = sizeof (dp_get_handle_name_t);
                break;
        case DP_GET_ALARM_STATE:
                reqp->msg_len = sizeof (dp_get_alarm_state_t);
                break;
        case DP_SET_ALARM_STATE:
                reqp->msg_len = sizeof (dp_set_alarm_state_t);
                break;
        case DP_GET_SDP_VERSION:
                resp->msg_len = sizeof (dp_get_sdp_version_r_t);
                break;
        case DP_GET_CHASSIS_SERIALNUM:
                reqp->msg_len = 0;
                break;
        case DP_GET_DATE_TIME:
                reqp->msg_len = 0;
                break;
        default:
                return (EINVAL);
        }

        rv = rmc_comm_request_response(reqp, resp,
            RMCLOMV_DEFAULT_MAX_MBOX_WAIT_TIME);

        if (rv != RCNOERR) {
                /*
                 * RMC returned an error or failed to respond.
                 * Where the RMC itself is implicated, rmclomv_rmc_error
                 * is set non-zero. It is cleared after an error free exchange.
                 * Two failure cases are distinguished:
                 * RMCLOMV_RMCSTATE_FAILED and RMCLOMV_RMCSTATE_DOWNLOAD.
                 */
                switch (rv) {
                case RCENOSOFTSTATE:
                        /* invalid/NULL soft state structure */
                        return (EIO);
                case RCENODATALINK:
                        /*
                         * firmware download in progress,
                         * can you come back later?
                         */
                        rmclomv_rmc_error = RMCLOMV_RMCSTATE_DOWNLOAD;
                        rmclomv_rmc_state = RMCLOMV_RMCSTATE_DOWNLOAD;
                        return (EAGAIN);
                case RCENOMEM:
                        /* memory problems */
                        return (ENOMEM);
                case RCECANTRESEND:
                        /* resend failed */
                        rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
                        return (EIO);
                case RCEMAXRETRIES:
                        /* reply not received - retries exceeded */
                        rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
                        return (EINTR);
                case RCETIMEOUT:
                        /* reply not received - command has timed out */
                        rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
                        return (EINTR);
                case RCEINVCMD:
                        /* data protocol cmd not supported */
                        return (ENOTSUP);
                case RCEINVARG:
                        /* invalid argument(s) */
                        return (ENOTSUP);
                case RCEGENERIC:
                        /* generic error */
                        rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
                        return (EIO);
                default:
                        rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
                        return (EIO);
                }
        }

        rmclomv_rmc_error = RMCLOMV_RMCERROR_NONE;
        return (0);
}

/*
 * validate_section_entry checks that the entry at the specified index
 * is valid and not duplicated by an entry above. If these tests fail
 * the entry is removed and B_FALSE returned. Otherwise returns B_TRUE.
 */
static int
validate_section_entry(rmclomv_cache_section_t *section, int index)
{
        int                     i;
        rmclomv_cache_entry_t   *entry;

        for (i = index; i < section->num_entries; i++) {
                entry = &section->entry[i];
                if (entry->handle_name.name[0] == '\0') {
                        cmn_err(CE_WARN,
                            "rmclomv: empty handle_name, handle 0x%x type %x",
                            entry->handle, section->sensor_type);
                } else if (entry->ind_mask != 0) {
                        continue;       /* skip special entries */
                } else if (entry->handle == DP_NULL_HANDLE) {
                        cmn_err(CE_WARN,
                            "rmclomv: null handle id for \"%s\" type %x",
                            entry->handle_name.name, section->sensor_type);
                } else if (i == index) {
                        continue;
                } else if (section->entry[index].handle == entry->handle) {
                        cmn_err(CE_WARN,
                            "rmclomv: duplicate handle 0x%x type %x",
                            entry->handle, section->sensor_type);
                } else if (strcmp(entry->handle_name.name,
                    section->entry[index].handle_name.name) == 0) {
                        cmn_err(CE_WARN,
                            "rmclomv: duplicate handle_name \"%s\", "
                            "handle 0x%x type %x", entry->handle_name.name,
                            entry->handle, section->sensor_type);
                } else
                        continue;

                /*
                 * need to remove the entry at index
                 */
                section->num_entries--;

                for (i = index; i < section->num_entries; i++) {
                        section->entry[i] = section->entry[i + 1];
                }

                return (B_FALSE);
        }

        return (B_TRUE);
}

/*
 * Populate a section containing handles with corresponding names
 * The supplied section structure must not be publically visible and the
 * name cache must not be locked either (because RMC i/o is required).
 *
 * This is the place where a sanity check is applied. Entries containing
 * duplicate handles, duplicate names or empty names are removed and the
 * structure is compacted. As a result num_entries may be reduced.
 */
static int
add_names_to_section(rmclomv_cache_section_t *section)
{
        int                     retval = 0;
        int                     ditched = B_FALSE;
        int                     index;
        dp_get_handle_name_r_t  handle_name_r;
        rmclomv_cache_entry_t   *entry;

        for (index = 0; index < section->num_entries; index++) {
                entry = &section->entry[index];
                if (entry->ind_mask != 0)
                        continue;       /* skip special entries */
                handle_name_r.handle = entry->handle;
                retval = rmclomv_do_cmd(DP_GET_HANDLE_NAME,
                    DP_GET_HANDLE_NAME_R, sizeof (handle_name_r),
                    (intptr_t)&handle_name_r, (intptr_t)&handle_name_r);
                if (retval == 0)
                        bcopy(handle_name_r.name,
                            entry->handle_name.name, DP_MAX_HANDLE_NAME);
        }

        /*
         * now ditch invalid and duplicate entries
         */
        for (index = 0; index < section->num_entries; index++) {
                while (validate_section_entry(section, index) == B_FALSE)
                        ditched = B_TRUE;
        }

        if (ditched)
                cmn_err(CE_WARN, "Retaining %d nodes of type %d",
                    section->num_entries, section->sensor_type);

        return (retval);
}

/*
 * The supplied (PSU) cache section is traversed and entries are created
 * for the individual indicators belonging to a PSU. These entries are
 * placed in a private chain. The caller, subsequently acquires the
 * cache lock and copies the chain head to make it public.
 * The handle-names for PSU indicators are derived from the parent PSU
 * handle-name.
 * NOTE: add_names_to_section() may have reduced psu_section->num_entries
 *       so DON'T USE psu_resp->num_psus
 */
static void
make_psu_subsections(rmclomv_cache_section_t *psu_section,
    rmclomv_cache_section_t **chain_head, dp_get_psu_status_r_t *psu_resp)
{
        int                     index;
        int                     subindex = 0;
        rmclomv_cache_section_t *subsection;
        rmclomv_cache_entry_t   *src_entry;
        rmclomv_cache_entry_t   *dst_entry;

        subsection = create_cache_section(RMCLOMV_VOLT_IND,
            RMCLOMV_MAX_VI_PER_PSU * psu_section->num_entries);
        for (index = 0; index < psu_section->num_entries; index++) {
                src_entry = &psu_section->entry[index];
                if ((psu_resp->psu_status[index].mask &
                    DP_PSU_INPUT_STATUS) != 0) {
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_INPUT_STATUS;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name,
                            str_ip_volts_ind);
                }

                if ((psu_resp->psu_status[index].mask &
                    DP_PSU_SEC_INPUT_STATUS) != 0) {
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_SEC_INPUT_STATUS;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name,
                            str_ip2_volts_ind);
                }

                if ((psu_resp->psu_status[index].mask &
                    DP_PSU_OUTPUT_STATUS) != 0) {
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_OUTPUT_STATUS;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name,
                            str_ff_pok_ind);
                }

                if ((psu_resp->psu_status[index].mask &
                    DP_PSU_OUTPUT_VLO_STATUS) != 0) {
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_OUTPUT_VLO_STATUS;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name,
                            str_vlo_volts_ind);
                }

                if ((psu_resp->psu_status[index].mask &
                    DP_PSU_OUTPUT_VHI_STATUS) != 0) {
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_OUTPUT_VHI_STATUS;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name,
                            str_vhi_volts_ind);
                }
        }
        /*
         * Adjust number of entries value in cache section
         * to match the facts.
         */
        subsection->num_entries = subindex;
        add_section(chain_head, subsection);

        subsection = create_cache_section(RMCLOMV_AMP_IND,
            RMCLOMV_MAX_CI_PER_PSU * psu_section->num_entries);
        subindex = 0;
        for (index = 0; index < psu_section->num_entries; index++) {
                int mask = psu_resp->psu_status[index].mask;
                src_entry = &psu_section->entry[index];
                if ((mask & DP_PSU_OUTPUT_AHI_STATUS) != 0) {
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_OUTPUT_AHI_STATUS;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name,
                            str_chi_amps_ind);
                }
                if ((mask & DP_PSU_NR_WARNING) != 0) {
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_NR_WARNING;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name,
                            str_chi_nr_ind);
                }
        }
        subsection->num_entries = subindex;
        add_section(chain_head, subsection);

        subsection = create_cache_section(RMCLOMV_TEMP_IND,
            psu_section->num_entries);
        subindex = 0;
        for (index = 0; index < psu_section->num_entries; index++) {
                if ((psu_resp->psu_status[index].mask &
                    DP_PSU_OVERTEMP_FAULT) != 0) {
                        src_entry = &psu_section->entry[index];
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_OVERTEMP_FAULT;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name,
                            str_ot_tmpr_ind);
                }
        }
        subsection->num_entries = subindex;
        add_section(chain_head, subsection);

        subsection = create_cache_section(RMCLOMV_FAN_IND,
            RMCLOMV_MAX_FI_PER_PSU * psu_section->num_entries);
        subindex = 0;
        for (index = 0; index < psu_section->num_entries; index++) {
                int mask = psu_resp->psu_status[index].mask;
                src_entry = &psu_section->entry[index];
                if ((mask & DP_PSU_FAN_FAULT) != 0) {
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_FAN_FAULT;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name, str_fan_ind);
                }
                if ((mask & DP_PSU_PDCT_FAN) != 0) {
                        dst_entry = &subsection->entry[subindex++];
                        dst_entry->handle = src_entry->handle;
                        dst_entry->ind_mask = DP_PSU_PDCT_FAN;
                        (void) snprintf(dst_entry->handle_name.name,
                            ENVMON_MAXNAMELEN, "%s.%s",
                            src_entry->handle_name.name, str_pdct_fan_ind);
                }
        }
        subsection->num_entries = subindex;
        add_section(chain_head, subsection);
}

static void
refresh_name_cache(int force_fail)
{
        union {
                dp_get_volts_t          u_volts_cmd;
                dp_get_temperatures_t   u_temp_cmd;
                dp_get_circuit_brks_t   u_ampi_cmd;
                dp_get_fan_status_t     u_fan_cmd;
                dp_get_psu_status_t     u_psu_cmd;
                dp_get_fru_status_t     u_fru_cmd;
                dp_get_led_state_t      u_led_cmd;
                dp_set_led_state_t      u_setled_cmd;
                dp_get_alarm_state_t    u_alarm_cmd;
                dp_set_alarm_state_t    u_setalarm_cmd;
        } rmc_cmdbuf;

/* defines for accessing union fields */
#define volts_cmd       rmc_cmdbuf.u_volts_cmd
#define temp_cmd        rmc_cmdbuf.u_temp_cmd
#define ampi_cmd        rmc_cmdbuf.u_ampi_cmd
#define fan_cmd         rmc_cmdbuf.u_fan_cmd
#define psu_cmd         rmc_cmdbuf.u_psu_cmd
#define fru_cmd         rmc_cmdbuf.u_fru_cmd
#define led_cmd         rmc_cmdbuf.u_led_cmd
#define setled_cmd      rmc_cmdbuf.u_setled_cmd
#define alarm_cmd       rmc_cmdbuf.u_alarm_cmd
#define setalarm_cmd    rmc_cmdbuf.u_setalarm_cmd

        /*
         * Data area to read sensor data into
         */
        static union {
                char                    reservation[RMCRESBUFLEN];
                dp_get_volts_r_t        u_volts_r;
                dp_get_temperatures_r_t u_temp_r;
                dp_get_circuit_brks_r_t u_ampi_r;
                dp_get_fan_status_r_t   u_fan_r;
                dp_get_psu_status_r_t   u_psu_r;
                dp_get_fru_status_r_t   u_fru_r;
                dp_get_led_state_r_t    u_led_r;
                dp_set_led_state_r_t    u_setled_r;
                dp_get_alarm_state_r_t  u_alarm_r;
                dp_set_alarm_state_r_t  u_setalarm_r;
        } rmc_sensbuf;

/* defines for accessing union fields */
#define volts_r         rmc_sensbuf.u_volts_r
#define temp_r          rmc_sensbuf.u_temp_r
#define ampi_r          rmc_sensbuf.u_ampi_r
#define fan_r           rmc_sensbuf.u_fan_r
#define psu_r           rmc_sensbuf.u_psu_r
#define fru_r           rmc_sensbuf.u_fru_r
#define led_r           rmc_sensbuf.u_led_r
#define setled_r        rmc_sensbuf.u_setled_r
#define alarm_r         rmc_sensbuf.u_alarm_r
#define setalarm_r      rmc_sensbuf.u_setalarm_r

        int                     retval = force_fail;
        int                     retval1 = retval;
        int                     index;
        rmclomv_cache_section_t *my_chain = NULL;
        rmclomv_cache_section_t *derived_chain = NULL;
        rmclomv_cache_section_t *section;
        rmclomv_cache_section_t *psu_section;
        rmclomv_cache_section_t *fru_section;
        dp_get_sysinfo_r_t      sysinfo;
        rmclomv_cache_entry_t   *entry;

        if (retval == 0) {
                retval = rmclomv_do_cmd(DP_GET_SYSINFO, DP_GET_SYSINFO_R,
                    sizeof (sysinfo), (intptr_t)NULL, (intptr_t)&sysinfo);
        }
        if (retval == 0) {
                fru_cmd.handle = DP_NULL_HANDLE;
                retval = rmclomv_do_cmd(DP_GET_FRU_STATUS, DP_GET_FRU_STATUS_R,
                    RMCRESBUFLEN, (intptr_t)&fru_cmd, (intptr_t)&fru_r);
        }
        if (retval != 0)
                fru_r.num_frus = 0;

        /*
         * Reserve space for special additional entries in the FRU section
         */
        fru_section = create_cache_section(RMCLOMV_HPU_IND,
            RMCLOMV_NUM_SPECIAL_FRUS + fru_r.num_frus);

        /*
         * add special entry for RMC itself
         */
        entry = &fru_section->entry[0];
        (void) snprintf(entry->handle_name.name, sizeof (envmon_handle_t),
            "SC");
        entry->handle = 0;
        entry->ind_mask = 1;    /* flag as a special entry */

        /*
         * populate any other FRU entries
         */
        for (index = 0; index < fru_r.num_frus; index++) {
                fru_section->entry[RMCLOMV_NUM_SPECIAL_FRUS + index].handle =
                    fru_r.fru_status[index].handle;
                fru_section->entry[RMCLOMV_NUM_SPECIAL_FRUS + index].ind_mask =
                    0;
        }

        my_chain = fru_section;

        if (retval == 0) {
                volts_cmd.handle = DP_NULL_HANDLE;
                retval = rmclomv_do_cmd(DP_GET_VOLTS, DP_GET_VOLTS_R,
                    RMCRESBUFLEN, (intptr_t)&volts_cmd, (intptr_t)&volts_r);
        }
        if (retval == 0) {
                section = create_cache_section(RMCLOMV_VOLT_SENS,
                    volts_r.num_volts);
                for (index = 0; index < volts_r.num_volts; index++) {
                        section->entry[index].handle =
                            volts_r.volt_status[index].handle;
                }
                add_section(&my_chain, section);
        }
        if (retval == 0) {
                temp_cmd.handle = DP_NULL_HANDLE;
                retval = rmclomv_do_cmd(DP_GET_TEMPERATURES,
                    DP_GET_TEMPERATURES_R, RMCRESBUFLEN,
                    (intptr_t)&temp_cmd, (intptr_t)&temp_r);
        }
        if (retval == 0) {
                section = create_cache_section(RMCLOMV_TEMP_SENS,
                    temp_r.num_temps);
                for (index = 0; index < temp_r.num_temps; index++) {
                        section->entry[index].handle =
                            temp_r.temp_status[index].handle;
                }
                add_section(&my_chain, section);
        }
        if (retval == 0) {
                fan_cmd.handle = DP_NULL_HANDLE;
                retval = rmclomv_do_cmd(DP_GET_FAN_STATUS, DP_GET_FAN_STATUS_R,
                    RMCRESBUFLEN, (intptr_t)&fan_cmd, (intptr_t)&fan_r);
        }
        if (retval == 0) {
                section = create_cache_section(RMCLOMV_FAN_SENS,
                    fan_r.num_fans);
                for (index = 0; index < fan_r.num_fans; index++) {
                        section->entry[index].handle =
                            fan_r.fan_status[index].handle;
                }
                add_section(&my_chain, section);
        }
        if (retval == 0) {
                ampi_cmd.handle = DP_NULL_HANDLE;
                retval = rmclomv_do_cmd(DP_GET_CIRCUIT_BRKS,
                    DP_GET_CIRCUIT_BRKS_R, RMCRESBUFLEN,
                    (intptr_t)&ampi_cmd, (intptr_t)&ampi_r);
        }
        if (retval == 0) {
                section = create_cache_section(RMCLOMV_AMP_IND,
                    ampi_r.num_circuit_brks);
                for (index = 0; index < ampi_r.num_circuit_brks; index++) {
                        section->entry[index].handle =
                            ampi_r.circuit_brk_status[index].handle;
                }
                add_section(&my_chain, section);
        }
        if (retval == 0) {
                led_cmd.handle = DP_NULL_HANDLE;
                retval = rmclomv_do_cmd(DP_GET_LED_STATE, DP_GET_LED_STATE_R,
                    RMCRESBUFLEN, (intptr_t)&led_cmd, (intptr_t)&led_r);
        }
        if (retval == 0) {
                section = create_cache_section(RMCLOMV_LED_IND,
                    led_r.num_leds);
                for (index = 0; index < led_r.num_leds; index++) {
                        section->entry[index].handle =
                            led_r.led_state[index].handle;
                }
                add_section(&my_chain, section);
        }
        /*
         * The command DP_GET_ALARM_STATE may not be valid on
         * some RMC versions, so we ignore the return value
         * and proceed
         */
        if (retval == 0) {
                alarm_cmd.handle = DP_NULL_HANDLE;
                retval1 = rmclomv_do_cmd(DP_GET_ALARM_STATE,
                    DP_GET_ALARM_STATE_R, RMCRESBUFLEN,
                    (intptr_t)&alarm_cmd, (intptr_t)&alarm_r);
                if ((retval1 == 0) && alarm_r.num_alarms) {
                        section = create_cache_section(RMCLOMV_ALARM_IND,
                            alarm_r.num_alarms);
                        for (index = 0; index < alarm_r.num_alarms; index++) {
                                section->entry[index].handle =
                                    alarm_r.alarm_state[index].handle;
                        }
                        add_section(&my_chain, section);
                }
        }
        if (retval == 0) {
                psu_cmd.handle = DP_NULL_HANDLE;
                retval = rmclomv_do_cmd(DP_GET_PSU_STATUS, DP_GET_PSU_STATUS_R,
                    RMCRESBUFLEN, (intptr_t)&psu_cmd, (intptr_t)&psu_r);
        }
        if (retval == 0) {
                /*
                 * WARNING:
                 * =======
                 * The PSUs must be probed last so that the response data
                 * (psu_r) is available for make_psu_subsections() below.
                 * Note that all the responses share the same data area
                 * which is declared as a union.
                 */
                psu_section = create_cache_section(RMCLOMV_PSU_IND,
                    psu_r.num_psus);
                for (index = 0; index < psu_r.num_psus; index++) {
                        psu_section->entry[index].handle =
                            psu_r.psu_status[index].handle;
                }
                add_section(&my_chain, psu_section);
        }
        if (retval == 0) {
                for (section = my_chain;
                    section != NULL;
                    section = section->next_section) {
                        retval = add_names_to_section(section);
                        if (retval != 0) {
                                break;
                        }
                }
        }

        /*
         * now add nodes derived from PSUs
         */
        if (retval == 0) {
                make_psu_subsections(psu_section, &derived_chain, &psu_r);
                /*
                 * name cache sections all set, exchange new for old
                 */
                rmclomv_reset_cache(my_chain, derived_chain, &sysinfo);
        } else {
                /*
                 * RMC is not responding, ditch any existing cache
                 * and just leave the special SC FRU node
                 */
                rmclomv_reset_cache(my_chain, NULL, NULL);
        }
}

static void
set_val_unav(envmon_sensor_t *sensor)
{
        sensor->value = ENVMON_VAL_UNAVAILABLE;
        sensor->lowthresholds.warning = ENVMON_VAL_UNAVAILABLE;
        sensor->lowthresholds.shutdown = ENVMON_VAL_UNAVAILABLE;
        sensor->lowthresholds.poweroff = ENVMON_VAL_UNAVAILABLE;
        sensor->highthresholds.warning = ENVMON_VAL_UNAVAILABLE;
        sensor->highthresholds.shutdown = ENVMON_VAL_UNAVAILABLE;
        sensor->highthresholds.poweroff = ENVMON_VAL_UNAVAILABLE;
}

static void
set_fan_unav(envmon_fan_t *fan)
{
        fan->speed = ENVMON_VAL_UNAVAILABLE;
        fan->units[0] = '\0';
        fan->lowthresholds.warning = ENVMON_VAL_UNAVAILABLE;
        fan->lowthresholds.shutdown = ENVMON_VAL_UNAVAILABLE;
        fan->lowthresholds.poweroff = ENVMON_VAL_UNAVAILABLE;
}

static int
do_psu_cmd(intptr_t arg, int mode, envmon_indicator_t *env_ind,
    dp_get_psu_status_t *rmc_psu, dp_get_psu_status_r_t *rmc_psu_r,
    int detector_type)
{
        int                     index;
        uint16_t                sensor_status;
        rmclomv_cache_section_t *section;
        uint16_t                indicator_mask;

        if (ddi_copyin((caddr_t)arg, (caddr_t)env_ind,
            sizeof (envmon_indicator_t), mode) != 0)
                return (EFAULT);

        /* ensure we've got PSU handles cached */
        LOCK_CACHE

        sensor_status = ENVMON_SENSOR_OK;
        section = rmclomv_find_section(rmclomv_subcache, detector_type);
        if (env_ind->id.name[0] == '\0') {
                /* request for first handle */
                if ((section == NULL) || (section->num_entries == 0))
                        env_ind->next_id.name[0] = '\0';
                else
                        env_ind->next_id = section->entry[0].handle_name;
                sensor_status = ENVMON_NOT_PRESENT;
        } else {
                /* ensure name is properly terminated */
                env_ind->id.name[ENVMON_MAXNAMELEN - 1] = '\0';
                if ((section == NULL) || (get_sensor_by_name(section,
                    env_ind->id.name, &index)) != 0) {
                        env_ind->next_id.name[0] = '\0';
                        sensor_status = ENVMON_NOT_PRESENT;
                } else if (index + 1 < section->num_entries)
                        env_ind->next_id =
                            section->entry[index + 1].handle_name;
                else
                        env_ind->next_id.name[0] = '\0';
        }
        if (sensor_status == ENVMON_SENSOR_OK) {
                /*
                 * user correctly identified a sensor, note its
                 * handle value and request the indicator status
                 */
                rmc_psu->handle = section->entry[index].handle;
                indicator_mask = section->entry[index].ind_mask;
        }

        RELEASE_CACHE

        if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
            rmclomv_do_cmd(DP_GET_PSU_STATUS, DP_GET_PSU_STATUS_R,
            sizeof (dp_get_psu_status_r_t), (intptr_t)rmc_psu,
            (intptr_t)rmc_psu_r) != 0)) {
                sensor_status = ENVMON_INACCESSIBLE;
        }
        if ((env_ind->sensor_status = sensor_status) == ENVMON_SENSOR_OK) {
                /*
                 * copy results into buffer for user
                 */
                if ((rmc_psu_r->psu_status[0].flag & DP_PSU_PRESENCE) == 0)
                        env_ind->sensor_status |= ENVMON_NOT_PRESENT;
                if (rmc_psu_r->psu_status[0].sensor_status !=
                    DP_SENSOR_DATA_AVAILABLE)
                        env_ind->sensor_status |= ENVMON_INACCESSIBLE;
                env_ind->condition =
                    (rmc_psu_r->psu_status[0].flag & indicator_mask) == 0 ?
                    0 : 1;
        }

        if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE)
                env_ind->sensor_status = ENVMON_INACCESSIBLE;

        if (ddi_copyout((caddr_t)env_ind, (caddr_t)arg,
            sizeof (envmon_indicator_t), mode) != 0)
                return (EFAULT);

        return (0);
}

/*ARGSUSED*/
static int
rmclomv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred_p,
    int *rval_p)
{
        int instance = getminor(dev);
        envmon_sysinfo_t lomv_sysinfo;
        union {
                envmon_sensor_t         u_env_sensor;
                envmon_indicator_t      u_env_ind;
                envmon_fan_t            u_env_fan;
                envmon_led_info_t       u_env_ledinfo;
                envmon_led_ctl_t        u_env_ledctl;
                envmon_hpu_t            u_env_hpu;
                envmon_alarm_info_t     u_env_alarminfo;
                envmon_alarm_ctl_t      u_env_alarmctl;
        } env_buf;
#define env_sensor      env_buf.u_env_sensor
#define env_ind         env_buf.u_env_ind
#define env_fan         env_buf.u_env_fan
#define env_ledinfo     env_buf.u_env_ledinfo
#define env_ledctl      env_buf.u_env_ledctl
#define env_hpu         env_buf.u_env_hpu
#define env_alarminfo   env_buf.u_env_alarminfo
#define env_alarmctl    env_buf.u_env_alarmctl

        union {
                dp_get_volts_t          u_rmc_volts;
                dp_get_temperatures_t   u_rmc_temp;
                dp_get_circuit_brks_t   u_rmc_ampi;
                dp_get_fan_status_t     u_rmc_fan;
                dp_get_psu_status_t     u_rmc_psu;
                dp_get_fru_status_t     u_rmc_fru;
                dp_get_led_state_t      u_rmc_led;
                dp_set_led_state_t      u_rmc_setled;
                dp_get_alarm_state_t    u_rmc_alarm;
                dp_set_alarm_state_t    u_rmc_setalarm;
        } rmc_reqbuf;
#define rmc_volts       rmc_reqbuf.u_rmc_volts
#define rmc_temp        rmc_reqbuf.u_rmc_temp
#define rmc_ampi        rmc_reqbuf.u_rmc_ampi
#define rmc_fan         rmc_reqbuf.u_rmc_fan
#define rmc_psu         rmc_reqbuf.u_rmc_psu
#define rmc_fru         rmc_reqbuf.u_rmc_fru
#define rmc_led         rmc_reqbuf.u_rmc_led
#define rmc_setled      rmc_reqbuf.u_rmc_setled
#define rmc_alarm       rmc_reqbuf.u_rmc_alarm
#define rmc_setalarm    rmc_reqbuf.u_rmc_setalarm

        union {
                dp_get_volts_r_t        u_rmc_volts_r;
                dp_get_temperatures_r_t u_rmc_temp_r;
                dp_get_circuit_brks_r_t u_rmc_ampi_r;
                dp_get_fan_status_r_t   u_rmc_fan_r;
                dp_get_psu_status_r_t   u_rmc_psu_r;
                dp_get_fru_status_r_t   u_rmc_fru_r;
                dp_get_led_state_r_t    u_rmc_led_r;
                dp_set_led_state_r_t    u_rmc_setled_r;
                dp_get_alarm_state_r_t  u_rmc_alarm_r;
                dp_set_alarm_state_r_t  u_rmc_setalarm_r;
                dp_get_sdp_version_r_t  u_rmc_sdpversion_r;
                dp_get_serialnum_r_t    u_rmc_serialnum_r;
        } rmc_resbuf;
#define rmc_volts_r     rmc_resbuf.u_rmc_volts_r
#define rmc_temp_r      rmc_resbuf.u_rmc_temp_r
#define rmc_ampi_r      rmc_resbuf.u_rmc_ampi_r
#define rmc_fan_r       rmc_resbuf.u_rmc_fan_r
#define rmc_psu_r       rmc_resbuf.u_rmc_psu_r
#define rmc_fru_r       rmc_resbuf.u_rmc_fru_r
#define rmc_led_r       rmc_resbuf.u_rmc_led_r
#define rmc_setled_r    rmc_resbuf.u_rmc_setled_r
#define rmc_alarm_r     rmc_resbuf.u_rmc_alarm_r
#define rmc_setalarm_r  rmc_resbuf.u_rmc_setalarm_r
#define rmc_sdpver_r    rmc_resbuf.u_rmc_sdpversion_r
#define rmc_serialnum_r rmc_resbuf.u_rmc_serialnum_r

        int                     retval = 0;
        int                     special = 0;
        int                     index;
        uint16_t                sensor_status;
        rmclomv_cache_section_t *section;
        envmon_chassis_t chassis;

        if (instance != 0)
                return (ENXIO);

        switch (cmd) {
        case ENVMONIOCSYSINFO:

                LOCK_CACHE

                /*
                 * A number of OK/not_OK indicators are supported by PSUs
                 * (voltage, current, fan, temperature). So the maximum
                 * number of such indicators relates to the maximum number
                 * of power-supplies.
                 */
                if (rmclomv_sysinfo_valid) {
                        lomv_sysinfo.maxVoltSens = rmclomv_sysinfo_data.maxVolt;
                        lomv_sysinfo.maxVoltInd =
                            RMCLOMV_MAX_VI_PER_PSU *
                            rmclomv_sysinfo_data.maxPSU;
                        /*
                         * the ALOM-Solaris interface does not include
                         * amp sensors, so we can hard code this value
                         */
                        lomv_sysinfo.maxAmpSens = 0;
                        lomv_sysinfo.maxAmpInd =
                            rmclomv_sysinfo_data.maxCircuitBrks +
                            (RMCLOMV_MAX_CI_PER_PSU *
                            rmclomv_sysinfo_data.maxPSU);
                        lomv_sysinfo.maxTempSens = rmclomv_sysinfo_data.maxTemp;
                        lomv_sysinfo.maxTempInd =
                            (RMCLOMV_MAX_TI_PER_PSU *
                            rmclomv_sysinfo_data.maxPSU);
                        lomv_sysinfo.maxFanSens = rmclomv_sysinfo_data.maxFan;
                        lomv_sysinfo.maxFanInd =
                            RMCLOMV_MAX_FI_PER_PSU *
                            rmclomv_sysinfo_data.maxPSU;
                        lomv_sysinfo.maxLED = rmclomv_sysinfo_data.maxLED;
                        lomv_sysinfo.maxHPU = RMCLOMV_NUM_SPECIAL_FRUS +
                            rmclomv_sysinfo_data.maxFRU;
                } else {
                        bzero(&lomv_sysinfo, sizeof (lomv_sysinfo));
                        lomv_sysinfo.maxHPU = 1;        /* just the SC node */
                }

                RELEASE_CACHE

                if (ddi_copyout((caddr_t)&lomv_sysinfo, (caddr_t)arg,
                    sizeof (lomv_sysinfo), mode) != 0)
                        return (EFAULT);
                break;

        case ENVMONIOCVOLTSENSOR:
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_sensor,
                    sizeof (envmon_sensor_t), mode) != 0)
                        return (EFAULT);

                /* see if we've got volts handles cached */
                LOCK_CACHE
                sensor_status = ENVMON_SENSOR_OK;

                if ((rmclomv_cache_valid == B_FALSE) ||
                    ((section = rmclomv_find_section(rmclomv_cache,
                    RMCLOMV_VOLT_SENS)) == NULL)) {
                        env_sensor.next_id.name[0] = '\0';
                        sensor_status = ENVMON_NOT_PRESENT;
                } else if (env_sensor.id.name[0] == '\0') {
                        /* request for first handle */
                        if (section->num_entries == 0)
                                env_sensor.next_id.name[0] = '\0';
                        else
                                env_sensor.next_id =
                                    section->entry[0].handle_name;
                        sensor_status = ENVMON_NOT_PRESENT;
                } else {
                        /* ensure name is properly terminated */
                        env_sensor.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
                        if (get_sensor_by_name(section, env_sensor.id.name,
                            &index) != 0) {
                                env_sensor.next_id.name[0] = '\0';
                                sensor_status = ENVMON_NOT_PRESENT;
                        } else if (index + 1 < section->num_entries)
                                env_sensor.next_id =
                                    section->entry[index + 1].handle_name;
                        else
                                env_sensor.next_id.name[0] = '\0';
                }
                if (sensor_status == ENVMON_SENSOR_OK) {
                        /*
                         * user correctly identified a sensor, note its
                         * handle value and request the sensor value
                         */
                        rmc_volts.handle = section->entry[index].handle;
                }
                RELEASE_CACHE
                if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
                    rmclomv_do_cmd(DP_GET_VOLTS, DP_GET_VOLTS_R,
                    sizeof (rmc_volts_r), (intptr_t)&rmc_volts,
                    (intptr_t)&rmc_volts_r) != 0)) {
                        sensor_status = ENVMON_INACCESSIBLE;
                }
                if ((sensor_status == ENVMON_SENSOR_OK) &&
                    (rmc_volts_r.volt_status[0].sensor_status ==
                    DP_SENSOR_NOT_PRESENT)) {
                        sensor_status = ENVMON_NOT_PRESENT;
                }
                if ((env_sensor.sensor_status = sensor_status) ==
                    ENVMON_SENSOR_OK) {
                        /*
                         * copy results into buffer for user
                         */
                        if (rmc_volts_r.volt_status[0].sensor_status !=
                            DP_SENSOR_DATA_AVAILABLE)
                                env_sensor.sensor_status = ENVMON_INACCESSIBLE;
                        env_sensor.value =
                            rmc_volts_r.volt_status[0].reading;
                        env_sensor.lowthresholds.warning =
                            rmc_volts_r.volt_status[0].low_warning;
                        env_sensor.lowthresholds.shutdown =
                            rmc_volts_r.volt_status[0].low_soft_shutdown;
                        env_sensor.lowthresholds.poweroff =
                            rmc_volts_r.volt_status[0].low_hard_shutdown;
                        env_sensor.highthresholds.warning =
                            rmc_volts_r.volt_status[0].high_warning;
                        env_sensor.highthresholds.shutdown =
                            rmc_volts_r.volt_status[0].high_soft_shutdown;
                        env_sensor.highthresholds.poweroff =
                            rmc_volts_r.volt_status[0].high_hard_shutdown;
                }
                if (env_sensor.sensor_status != ENVMON_SENSOR_OK ||
                    rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE)
                        set_val_unav(&env_sensor);

                if (ddi_copyout((caddr_t)&env_sensor, (caddr_t)arg,
                    sizeof (envmon_sensor_t), mode) != 0)
                        return (EFAULT);
                break;

        case ENVMONIOCVOLTIND:
                return (do_psu_cmd(arg, mode, &env_ind, &rmc_psu, &rmc_psu_r,
                    RMCLOMV_VOLT_IND));

        case ENVMONIOCTEMPIND:
                return (do_psu_cmd(arg, mode, &env_ind, &rmc_psu, &rmc_psu_r,
                    RMCLOMV_TEMP_IND));

        case ENVMONIOCFANIND:
                return (do_psu_cmd(arg, mode, &env_ind, &rmc_psu, &rmc_psu_r,
                    RMCLOMV_FAN_IND));

        case ENVMONIOCAMPSENSOR:
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_sensor,
                    sizeof (envmon_sensor_t), mode) != 0)
                        return (EFAULT);

                env_sensor.sensor_status = ENVMON_NOT_PRESENT;
                env_sensor.next_id.name[0] = '\0';

                if (ddi_copyout((caddr_t)&env_sensor, (caddr_t)arg,
                    sizeof (envmon_sensor_t), mode) != 0)
                        return (EFAULT);
                break;

        case ENVMONIOCTEMPSENSOR:
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_sensor,
                    sizeof (envmon_sensor_t), mode) != 0)
                        return (EFAULT);

                /* see if we've got temperature handles cached */
                LOCK_CACHE
                sensor_status = ENVMON_SENSOR_OK;

                if ((rmclomv_cache_valid == B_FALSE) ||
                    ((section = rmclomv_find_section(rmclomv_cache,
                    RMCLOMV_TEMP_SENS)) == NULL)) {
                        env_sensor.next_id.name[0] = '\0';
                        sensor_status = ENVMON_NOT_PRESENT;
                } else if (env_sensor.id.name[0] == '\0') {
                        /* request for first handle */
                        if (section->num_entries == 0)
                                env_sensor.next_id.name[0] = '\0';
                        else
                                env_sensor.next_id =
                                    section->entry[0].handle_name;
                        sensor_status = ENVMON_NOT_PRESENT;
                } else {
                        /* ensure name is properly terminated */
                        env_sensor.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
                        if (get_sensor_by_name(section, env_sensor.id.name,
                            &index) != 0) {
                                env_sensor.next_id.name[0] = '\0';
                                sensor_status = ENVMON_NOT_PRESENT;
                        } else if (index + 1 < section->num_entries)
                                env_sensor.next_id =
                                    section->entry[index + 1].handle_name;
                        else
                                env_sensor.next_id.name[0] = '\0';
                }
                if (sensor_status == ENVMON_SENSOR_OK) {
                        /*
                         * user correctly identified a sensor, note its
                         * handle value and request the sensor value
                         */
                        rmc_temp.handle = section->entry[index].handle;
                }
                RELEASE_CACHE
                if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
                    rmclomv_do_cmd(DP_GET_TEMPERATURES, DP_GET_TEMPERATURES_R,
                    sizeof (rmc_temp_r), (intptr_t)&rmc_temp,
                    (intptr_t)&rmc_temp_r) != 0)) {
                        sensor_status = ENVMON_INACCESSIBLE;
                }
                if ((sensor_status == ENVMON_SENSOR_OK) &&
                    (rmc_temp_r.temp_status[0].sensor_status ==
                    DP_SENSOR_NOT_PRESENT)) {
                        sensor_status = ENVMON_NOT_PRESENT;
                }
                if ((env_sensor.sensor_status = sensor_status) ==
                    ENVMON_SENSOR_OK) {
                        /*
                         * copy results into buffer for user
                         */
                        if (rmc_temp_r.temp_status[0].sensor_status !=
                            DP_SENSOR_DATA_AVAILABLE)
                                env_sensor.sensor_status = ENVMON_INACCESSIBLE;
                        env_sensor.value =
                            rmc_temp_r.temp_status[0].value;
                        env_sensor.lowthresholds.warning =
                            rmc_temp_r.temp_status[0].low_warning;
                        env_sensor.lowthresholds.shutdown =
                            rmc_temp_r.temp_status[0].low_soft_shutdown;
                        env_sensor.lowthresholds.poweroff =
                            rmc_temp_r.temp_status[0].low_hard_shutdown;
                        env_sensor.highthresholds.warning =
                            rmc_temp_r.temp_status[0].high_warning;
                        env_sensor.highthresholds.shutdown =
                            rmc_temp_r.temp_status[0].high_soft_shutdown;
                        env_sensor.highthresholds.poweroff =
                            rmc_temp_r.temp_status[0].high_hard_shutdown;
                }
                if (env_sensor.sensor_status != ENVMON_SENSOR_OK ||
                    rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE)
                        set_val_unav(&env_sensor);

                if (ddi_copyout((caddr_t)&env_sensor, (caddr_t)arg,
                    sizeof (envmon_sensor_t), mode) != 0)
                        return (EFAULT);
                break;


        case ENVMONIOCFAN:
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_fan,
                    sizeof (envmon_fan_t), mode) != 0)
                        return (EFAULT);

                /* see if we've got fan handles cached */
                LOCK_CACHE
                sensor_status = ENVMON_SENSOR_OK;

                if ((rmclomv_cache_valid == B_FALSE) ||
                    ((section = rmclomv_find_section(rmclomv_cache,
                    RMCLOMV_FAN_SENS)) == NULL)) {
                        env_fan.next_id.name[0] = '\0';
                        sensor_status = ENVMON_NOT_PRESENT;
                } else if (env_fan.id.name[0] == '\0') {
                        /* request for first handle */
                        if (section->num_entries == 0)
                                env_fan.next_id.name[0] = '\0';
                        else
                                env_fan.next_id =
                                    section->entry[0].handle_name;
                        sensor_status = ENVMON_NOT_PRESENT;
                } else {
                        /* ensure name is properly terminated */
                        env_fan.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
                        if (get_sensor_by_name(section, env_fan.id.name,
                            &index) != 0) {
                                env_fan.next_id.name[0] = '\0';
                                sensor_status = ENVMON_NOT_PRESENT;
                        } else if (index + 1 < section->num_entries)
                                env_fan.next_id =
                                    section->entry[index + 1].handle_name;
                        else
                                env_fan.next_id.name[0] = '\0';
                }
                if (sensor_status == ENVMON_SENSOR_OK) {
                        /*
                         * user correctly identified a sensor, note its
                         * handle value and request the sensor value
                         */
                        rmc_fan.handle = section->entry[index].handle;
                }
                RELEASE_CACHE
                if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
                    rmclomv_do_cmd(DP_GET_FAN_STATUS, DP_GET_FAN_STATUS_R,
                    sizeof (rmc_fan_r), (intptr_t)&rmc_fan,
                    (intptr_t)&rmc_fan_r) != 0)) {
                        sensor_status = ENVMON_INACCESSIBLE;
                }
                if ((sensor_status == ENVMON_SENSOR_OK) &&
                    (rmc_fan_r.fan_status[0].sensor_status ==
                    DP_SENSOR_NOT_PRESENT)) {
                        sensor_status = ENVMON_NOT_PRESENT;
                }
                if ((env_fan.sensor_status = sensor_status) ==
                    ENVMON_SENSOR_OK) {
                        if ((rmc_fan_r.fan_status[0].flag &
                            DP_FAN_PRESENCE) == 0)
                                env_fan.sensor_status = ENVMON_NOT_PRESENT;
                        if (rmc_fan_r.fan_status[0].sensor_status !=
                            DP_SENSOR_DATA_AVAILABLE)
                                env_fan.sensor_status |= ENVMON_INACCESSIBLE;
                        if (env_fan.sensor_status == ENVMON_SENSOR_OK) {
                                /*
                                 * copy results into buffer for user
                                 */
                                env_fan.speed =
                                    rmc_fan_r.fan_status[0].speed;
                                env_fan.lowthresholds.warning =
                                    rmc_fan_r.fan_status[0].minspeed;
                                env_fan.lowthresholds.shutdown =
                                    ENVMON_VAL_UNAVAILABLE;
                                env_fan.lowthresholds.poweroff =
                                    ENVMON_VAL_UNAVAILABLE;
                                if ((rmc_fan_r.fan_status[0].flag &
                                    DP_FAN_SPEED_VAL_UNIT) == 0)
                                        bcopy(str_rpm, env_fan.units,
                                            sizeof (str_rpm));
                                else
                                        bcopy(str_percent, env_fan.units,
                                            sizeof (str_percent));
                        }
                }
                if (env_fan.sensor_status != ENVMON_SENSOR_OK ||
                    rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE)
                        set_fan_unav(&env_fan);

                if (ddi_copyout((caddr_t)&env_fan, (caddr_t)arg,
                    sizeof (envmon_fan_t), mode) != 0)
                        return (EFAULT);
                break;

        case ENVMONIOCAMPIND:
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_ind,
                    sizeof (envmon_indicator_t), mode) != 0)
                        return (EFAULT);

                /* see if we've got amp indicator handles cached */
                LOCK_CACHE
                sensor_status = ENVMON_SENSOR_OK;

                if ((rmclomv_cache_valid == B_FALSE) ||
                    ((section = rmclomv_find_section(rmclomv_cache,
                    RMCLOMV_AMP_IND)) == NULL)) {
                        RELEASE_CACHE
                        return (do_psu_cmd(arg, mode, &env_ind, &rmc_psu,
                            &rmc_psu_r, RMCLOMV_AMP_IND));
                } else if (env_ind.id.name[0] == '\0') {
                        /* request for first handle */
                        if (section->num_entries == 0) {
                                RELEASE_CACHE
                                return (do_psu_cmd(arg, mode, &env_ind,
                                    &rmc_psu, &rmc_psu_r, RMCLOMV_AMP_IND));
                        }
                        env_ind.next_id = section->entry[0].handle_name;
                        sensor_status = ENVMON_NOT_PRESENT;
                } else {
                        /* ensure name is properly terminated */
                        env_ind.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
                        if (get_sensor_by_name(section, env_ind.id.name,
                            &index) != 0) {
                                RELEASE_CACHE
                                return (do_psu_cmd(arg, mode, &env_ind,
                                    &rmc_psu, &rmc_psu_r, RMCLOMV_AMP_IND));
                        }
                        if (index + 1 < section->num_entries) {
                                env_ind.next_id =
                                    section->entry[index + 1].handle_name;
                        } else {
                                rmclomv_cache_section_t *sub_section =
                                    rmclomv_find_section(rmclomv_subcache,
                                    RMCLOMV_AMP_IND);
                                if ((sub_section == NULL) ||
                                    (sub_section->num_entries == 0))
                                        env_ind.next_id.name[0] = '\0';
                                else
                                        env_ind.next_id =
                                            sub_section->entry[0].handle_name;
                        }
                }
                if (sensor_status == ENVMON_SENSOR_OK) {
                        /*
                         * user correctly identified an indicator, note its
                         * handle value and request the indicator status
                         */
                        rmc_ampi.handle = section->entry[index].handle;
                }
                RELEASE_CACHE
                if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
                    rmclomv_do_cmd(DP_GET_CIRCUIT_BRKS, DP_GET_CIRCUIT_BRKS_R,
                    sizeof (rmc_ampi_r), (intptr_t)&rmc_ampi,
                    (intptr_t)&rmc_ampi_r) != 0)) {
                        sensor_status = ENVMON_INACCESSIBLE;
                }
                if ((sensor_status == ENVMON_SENSOR_OK) &&
                    (rmc_ampi_r.circuit_brk_status[0].sensor_status ==
                    DP_SENSOR_NOT_PRESENT)) {
                        sensor_status = ENVMON_NOT_PRESENT;
                }
                if ((env_ind.sensor_status = sensor_status) ==
                    ENVMON_SENSOR_OK) {
                        /*
                         * copy results into buffer for user
                         */
                        if (rmc_ampi_r.circuit_brk_status[0].sensor_status !=
                            DP_SENSOR_DATA_AVAILABLE)
                                env_ind.sensor_status = ENVMON_INACCESSIBLE;
                        env_ind.condition =
                            rmc_ampi_r.circuit_brk_status[0].status;
                }

                /*
                 * If rmclomv_rmc_error is set there is no way
                 * that we read information from RSC. Just copy
                 * out an inaccessible evironmental.
                 */
                if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE) {
                        env_ind.sensor_status = ENVMON_INACCESSIBLE;
                        env_ind.condition = ENVMON_INACCESSIBLE;
                }

                if (ddi_copyout((caddr_t)&env_ind, (caddr_t)arg,
                    sizeof (envmon_indicator_t), mode) != 0)
                        return (EFAULT);
                break;

        case ENVMONIOCHPU:
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_hpu,
                    sizeof (envmon_hpu_t), mode) != 0)
                        return (EFAULT);

                /* see if we've got hpu handles cached */
                LOCK_CACHE

                if ((rmclomv_cache_valid == B_FALSE) ||
                    ((section = rmclomv_find_section(rmclomv_cache,
                    RMCLOMV_HPU_IND)) == NULL)) {
                        RELEASE_CACHE
                        return (EAGAIN);
                }

                /*
                 * At this point the cache is locked and section points to
                 * the section relating to hpus.
                 */
                sensor_status = ENVMON_SENSOR_OK;
                if (env_hpu.id.name[0] == '\0') {
                        /* request for first handle */
                        if (section->num_entries == 0)
                                env_hpu.next_id.name[0] = '\0';
                        else
                                env_hpu.next_id =
                                    section->entry[0].handle_name;
                        sensor_status = ENVMON_NOT_PRESENT;
                } else {
                        /* ensure name is properly terminated */
                        env_hpu.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
                        if (get_sensor_by_name(section, env_hpu.id.name,
                            &index) != 0) {
                                env_hpu.next_id.name[0] = '\0';
                                sensor_status = ENVMON_NOT_PRESENT;
                        } else if (index + 1 < section->num_entries)
                                env_hpu.next_id =
                                    section->entry[index + 1].handle_name;
                        else
                                env_hpu.next_id.name[0] = '\0';
                }
                if (sensor_status == ENVMON_SENSOR_OK) {
                        /*
                         * user correctly identified an hpu, note its
                         * handle value and request the hpu status
                         */
                        rmc_fru.handle = section->entry[index].handle;
                        special = section->entry[index].ind_mask;
                }
                RELEASE_CACHE
                if ((env_hpu.sensor_status = sensor_status) ==
                    ENVMON_SENSOR_OK) {
                        env_hpu.fru_status = ENVMON_FRU_PRESENT;

                        if (special != 0) {
                                /* this is the pseudo SC node */
                                mutex_enter(&rmclomv_state_lock);
                                switch (rmclomv_rmc_state) {
                                case RMCLOMV_RMCSTATE_OK:
                                        break;
                                case RMCLOMV_RMCSTATE_FAILED:
                                        env_hpu.fru_status = ENVMON_FRU_FAULT;
                                        break;
                                case RMCLOMV_RMCSTATE_DOWNLOAD:
                                        env_hpu.fru_status =
                                            ENVMON_FRU_DOWNLOAD;
                                        break;
                                default:
                                        env_hpu.sensor_status =
                                            ENVMON_INACCESSIBLE;
                                        break;
                                }
                                mutex_exit(&rmclomv_state_lock);
                        } else if (rmclomv_rmc_error ||
                            rmclomv_do_cmd(DP_GET_FRU_STATUS,
                            DP_GET_FRU_STATUS_R, sizeof (rmc_fru_r),
                            (intptr_t)&rmc_fru, (intptr_t)&rmc_fru_r) != 0) {
                                env_hpu.sensor_status = ENVMON_INACCESSIBLE;
                        } else {
                                /*
                                 * copy results into buffer for user
                                 */
                                if (rmc_fru_r.fru_status[0].presence == 0) {
                                        env_hpu.sensor_status =
                                            ENVMON_NOT_PRESENT;
                                        env_hpu.fru_status =
                                            ENVMON_FRU_NOT_PRESENT;
                                } else if (rmc_fru_r.fru_status[0].sensor_status
                                    != DP_SENSOR_DATA_AVAILABLE) {
                                        env_hpu.sensor_status =
                                            ENVMON_INACCESSIBLE;
                                } else {
                                        uint8_t status =
                                            rmc_fru_r.fru_status[0].status;
                                        if (status == DP_FRU_STATUS_UNKNOWN) {
                                                env_hpu.sensor_status =
                                                    ENVMON_INACCESSIBLE;
                                        } else if (status != DP_FRU_STATUS_OK) {
                                                env_hpu.fru_status =
                                                    ENVMON_FRU_FAULT;
                                        }
                                }
                        }
                }

                /*
                 * If rmclomv_rmc_error is set there is no way
                 * that we read information from RSC. Just copy
                 * out an inaccessible environmental.
                 */
                if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE) {
                        env_hpu.sensor_status = ENVMON_INACCESSIBLE;
                        env_hpu.fru_status = ENVMON_INACCESSIBLE;
                }

                if (ddi_copyout((caddr_t)&env_hpu, (caddr_t)arg,
                    sizeof (envmon_hpu_t), mode) != 0)
                        return (EFAULT);
                break;

        case ENVMONIOCGETLED:
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_ledinfo,
                    sizeof (envmon_led_info_t), mode) != 0)
                        return (EFAULT);

                /* see if we've got LED handles cached */
                LOCK_CACHE
                sensor_status = ENVMON_SENSOR_OK;

                if ((rmclomv_cache_valid == B_FALSE) ||
                    ((section = rmclomv_find_section(rmclomv_cache,
                    RMCLOMV_LED_IND)) == NULL)) {
                        env_ledinfo.next_id.name[0] = '\0';
                        sensor_status = ENVMON_NOT_PRESENT;
                } else if (env_ledinfo.id.name[0] == '\0') {
                        /* request for first handle */
                        if (section->num_entries == 0)
                                env_ledinfo.next_id.name[0] = '\0';
                        else
                                env_ledinfo.next_id =
                                    section->entry[0].handle_name;
                        sensor_status = ENVMON_NOT_PRESENT;
                } else {
                        /* ensure name is properly terminated */
                        env_ledinfo.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
                        if (get_sensor_by_name(section, env_ledinfo.id.name,
                            &index) != 0) {
                                env_ledinfo.next_id.name[0] = '\0';
                                sensor_status = ENVMON_NOT_PRESENT;
                        } else if (index + 1 < section->num_entries)
                                env_ledinfo.next_id =
                                    section->entry[index + 1].handle_name;
                        else
                                env_ledinfo.next_id.name[0] = '\0';
                }
                if (sensor_status == ENVMON_SENSOR_OK) {
                        /*
                         * user correctly identified a LED, note its
                         * handle value and request the LED status
                         */
                        rmc_led.handle = section->entry[index].handle;
                }
                RELEASE_CACHE
                if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
                    rmclomv_do_cmd(DP_GET_LED_STATE, DP_GET_LED_STATE_R,
                    sizeof (rmc_led_r), (intptr_t)&rmc_led,
                    (intptr_t)&rmc_led_r) != 0)) {
                        sensor_status = ENVMON_INACCESSIBLE;
                }
                if ((sensor_status == ENVMON_SENSOR_OK) &&
                    (rmc_led_r.led_state[0].sensor_status ==
                    DP_SENSOR_NOT_PRESENT)) {
                        sensor_status = ENVMON_NOT_PRESENT;
                }
                if ((env_ledinfo.sensor_status = sensor_status) ==
                    ENVMON_SENSOR_OK) {
                        /*
                         * copy results into buffer for user
                         * start with some defaults then override
                         */
                        env_ledinfo.sensor_status = ENVMON_SENSOR_OK;
                        env_ledinfo.led_state = ENVMON_LED_OFF;
                        env_ledinfo.led_color = ENVMON_LED_CLR_NONE;

                        if (rmc_led_r.led_state[0].sensor_status !=
                            DP_SENSOR_DATA_AVAILABLE)
                                env_ledinfo.sensor_status = ENVMON_INACCESSIBLE;
                        else {
                                dp_led_state_t ledState;
                                ledState = rmc_led_r.led_state[0];
                                env_ledinfo.led_color = (int8_t)ledState.colour;

                                switch (ledState.state) {
                                case (rsci8)DP_LED_OFF:
                                        break;
                                case (rsci8)DP_LED_ON:
                                        env_ledinfo.led_state = ENVMON_LED_ON;
                                        break;
                                case (rsci8)DP_LED_BLINKING:
                                        env_ledinfo.led_state =
                                            ENVMON_LED_BLINKING;
                                        break;
                                case (rsci8)DP_LED_FLASHING:
                                        env_ledinfo.led_state =
                                            ENVMON_LED_FLASHING;
                                        break;
                                default:
                                        break;
                                }
                        }
                }

                /*
                 * If rmclomv_rmc_error is set there is no way
                 * that we read information from RSC. Just copy
                 * out an inaccessible environmental.
                 */
                if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE) {
                        env_ledinfo.sensor_status = ENVMON_INACCESSIBLE;
                        env_ledinfo.led_state = ENVMON_INACCESSIBLE;
                }

                if (ddi_copyout((caddr_t)&env_ledinfo, (caddr_t)arg,
                    sizeof (envmon_led_info_t), mode) != 0)
                        return (EFAULT);
                break;

        case ENVMONIOCSETLED:
                if ((mode & FWRITE) == 0)
                        return (EACCES);
                if (drv_priv(cred_p) != 0)
                        return (EPERM);
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_ledctl,
                    sizeof (envmon_led_ctl_t), mode) != 0)
                        return (EFAULT);
                if (env_ledctl.led_state < RMCLOMV_MIN_LED_STATE ||
                    env_ledctl.led_state > RMCLOMV_MAX_LED_STATE)
                        return (EINVAL);
                /*
                 * Ensure name is properly terminated.
                 */
                env_ledctl.id.name[ENVMON_MAXNAMELEN - 1] = '\0';

                /* see if we've got LED handles cached */
                LOCK_CACHE

                if ((rmclomv_cache_valid == B_FALSE) ||
                    ((section = rmclomv_find_section(rmclomv_cache,
                    RMCLOMV_LED_IND)) == NULL) ||
                    (get_sensor_by_name(section, env_ledctl.id.name,
                    &index) != 0)) {
                        RELEASE_CACHE
                        return (EINVAL);        /* no such LED */
                }
                /*
                 * user correctly identified a LED, note its handle value
                 */
                rmc_setled.handle = section->entry[index].handle;
                RELEASE_CACHE
                switch (env_ledctl.led_state) {
                case ENVMON_LED_ON:
                        rmc_setled.state = DP_LED_ON;
                        break;
                case ENVMON_LED_BLINKING:
                        rmc_setled.state = DP_LED_BLINKING;
                        break;
                case ENVMON_LED_FLASHING:
                        rmc_setled.state = DP_LED_FLASHING;
                        break;
                default:
                        rmc_setled.state = DP_LED_OFF;
                        break;
                }
                retval = rmclomv_do_cmd(DP_SET_LED_STATE, DP_SET_LED_STATE_R,
                    sizeof (rmc_setled_r), (intptr_t)&rmc_setled,
                    (intptr_t)&rmc_setled_r);

                if (retval != 0) {
                        break;
                }

                if (rmc_setled_r.status != 0) {
                        cmn_err(CE_WARN, "ENVMONIOCSETLED: \"%s\" status: 0x%x",
                            env_ledctl.id.name, rmc_setled_r.status);
                        return (EIO);
                }
                break;

        case ENVMONIOCGETKEYSW:
        {
                enum rmc_keyswitch_pos  rmc_pos = real_key_position;
                envmon_keysw_pos_t      envmon_pos;

                /*
                 * Yes, I know this is ugly, but the V210 has no keyswitch,
                 * even though the ALOM returns a value for it
                 */
                if (strcmp(platform, "SUNW,Sun-Fire-V210") == 0) {
                        return (ENOTSUP);
                }

                switch (rmc_pos) {

                case RMC_KEYSWITCH_POS_NORMAL:
                        envmon_pos = ENVMON_KEYSW_POS_NORMAL;
                        break;
                case RMC_KEYSWITCH_POS_DIAG:
                        envmon_pos = ENVMON_KEYSW_POS_DIAG;
                        break;
                case RMC_KEYSWITCH_POS_LOCKED:
                        envmon_pos = ENVMON_KEYSW_POS_LOCKED;
                        break;
                case RMC_KEYSWITCH_POS_OFF:
                        envmon_pos = ENVMON_KEYSW_POS_OFF;
                        break;
                default:
                        envmon_pos = ENVMON_KEYSW_POS_UNKNOWN;
                        break;
                }

                if (ddi_copyout((caddr_t)&envmon_pos, (caddr_t)arg,
                    sizeof (envmon_pos), mode) != 0)
                        return (EFAULT);
                break;
        }

        case ENVMONIOCGETALARM:
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_alarminfo,
                    sizeof (envmon_alarm_info_t), mode) != 0)
                        return (EFAULT);

                /* see if we've got ALARM handles cached */
                LOCK_CACHE
                sensor_status = ENVMON_SENSOR_OK;

                if ((rmclomv_cache_valid == B_FALSE) ||
                    ((section = rmclomv_find_section(rmclomv_cache,
                    RMCLOMV_ALARM_IND)) == NULL)) {
                        env_alarminfo.next_id.name[0] = '\0';
                        sensor_status = ENVMON_NOT_PRESENT;
                } else if (env_alarminfo.id.name[0] == '\0') {
                        /* request for first handle */
                        if (section->num_entries == 0)
                                env_alarminfo.next_id.name[0] = '\0';
                        else
                                env_alarminfo.next_id =
                                    section->entry[0].handle_name;
                        sensor_status = ENVMON_NOT_PRESENT;
                } else {
                        /* ensure name is properly terminated */
                        env_alarminfo.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
                        if (get_sensor_by_name(section, env_alarminfo.id.name,
                            &index) != 0) {
                                env_alarminfo.next_id.name[0] = '\0';
                                sensor_status = ENVMON_NOT_PRESENT;
                        } else if (index + 1 < section->num_entries)
                                env_alarminfo.next_id =
                                    section->entry[index + 1].handle_name;
                        else
                                env_alarminfo.next_id.name[0] = '\0';
                }
                if (sensor_status == ENVMON_SENSOR_OK) {
                        /*
                         * user correctly identified a ALARM, note its
                         * handle value and request the ALARM status
                         */
                        rmc_alarm.handle = section->entry[index].handle;
                }
                RELEASE_CACHE
                if ((sensor_status == ENVMON_SENSOR_OK) &&
                    (rmclomv_rmc_error ||
                    rmclomv_do_cmd(DP_GET_ALARM_STATE, DP_GET_ALARM_STATE_R,
                    sizeof (rmc_alarm_r), (intptr_t)&rmc_alarm,
                    (intptr_t)&rmc_alarm_r) != 0)) {
                        sensor_status = ENVMON_INACCESSIBLE;
                }
                if ((env_alarminfo.sensor_status = sensor_status) ==
                    ENVMON_SENSOR_OK) {
                        /*
                         * copy results into buffer for user
                         * start with some defaults then override
                         */
                        env_alarminfo.sensor_status = ENVMON_SENSOR_OK;
                        env_alarminfo.alarm_state = ENVMON_ALARM_OFF;

                        if (rmc_alarm_r.alarm_state[0].sensor_status !=
                            DP_SENSOR_DATA_AVAILABLE)
                                env_alarminfo.sensor_status =
                                    ENVMON_INACCESSIBLE;
                        else {
                                dp_alarm_state_t alarmState;
                                alarmState = rmc_alarm_r.alarm_state[0];

                                switch (alarmState.state) {
                                case DP_ALARM_OFF:
                                        break;
                                case DP_ALARM_ON:
                                        env_alarminfo.alarm_state =
                                            ENVMON_ALARM_ON;
                                        break;
                                default:
                                        break;
                                }
                        }
                }

                /*
                 * If rmclomv_rmc_error is set there is no way
                 * that we read information from RSC. Just copy
                 * out an inaccessible environmental.
                 */
                if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE) {
                        env_alarminfo.sensor_status = ENVMON_INACCESSIBLE;
                        env_alarminfo.alarm_state = ENVMON_INACCESSIBLE;
                }

                if (ddi_copyout((caddr_t)&env_alarminfo, (caddr_t)arg,
                    sizeof (envmon_alarm_info_t), mode) != 0)
                        return (EFAULT);
                break;

        case ENVMONIOCSETALARM:
                if ((mode & FWRITE) == 0)
                        return (EACCES);
                if (drv_priv(cred_p) != 0)
                        return (EPERM);
                if (ddi_copyin((caddr_t)arg, (caddr_t)&env_alarmctl,
                    sizeof (envmon_alarm_ctl_t), mode) != 0)
                        return (EFAULT);
                if (env_alarmctl.alarm_state < RMCLOMV_MIN_ALARM_STATE ||
                    env_alarmctl.alarm_state > RMCLOMV_MAX_ALARM_STATE)
                        return (EINVAL);
                /*
                 * Ensure name is properly terminated.
                 */
                env_alarmctl.id.name[ENVMON_MAXNAMELEN - 1] = '\0';

                /* see if we've got ALARM handles cached */
                LOCK_CACHE

                if ((rmclomv_cache_valid == B_FALSE) ||
                    ((section = rmclomv_find_section(rmclomv_cache,
                    RMCLOMV_ALARM_IND)) == NULL) ||
                    (get_sensor_by_name(section, env_alarmctl.id.name,
                    &index) != 0)) {
                        RELEASE_CACHE
                        return (EINVAL);        /* no such ALARM */
                }
                /*
                 * user correctly identified a ALARM, note its handle value
                 */
                rmc_setalarm.handle = section->entry[index].handle;
                RELEASE_CACHE
                rmc_setalarm.state = (rsci8)env_alarmctl.alarm_state;
                retval = rmclomv_do_cmd(DP_SET_ALARM_STATE,
                    DP_SET_ALARM_STATE_R,
                    sizeof (rmc_setalarm_r),
                    (intptr_t)&rmc_setalarm,
                    (intptr_t)&rmc_setalarm_r);

                if (retval != 0) {
                        break;
                }

                if (rmc_setalarm_r.status != 0) {
                        cmn_err(CE_WARN, "ENVMONIOCSETALARM: \"%s\" status: "
                            "0x%x", env_alarmctl.id.name,
                            rmc_setalarm_r.status);
                        return (EIO);
                }
                break;

        case ENVMONIOCCHASSISSERIALNUM:
                retval = rmclomv_do_cmd(DP_GET_SDP_VERSION,
                    DP_GET_SDP_VERSION_R, sizeof (rmc_sdpver_r),
                    (intptr_t)NULL, (intptr_t)&rmc_sdpver_r);

                if (retval != 0) {
                        cmn_err(CE_WARN, "DP_GET_SDP_VERSION failed, ret=%d\n",
                            retval);
                        break;
                } else if (rmc_sdpver_r.version < SDP_RESPONDS_TO_ALL_CMDS) {
                        retval = ENOTSUP;
                        break;
                }
                retval = rmclomv_do_cmd(DP_GET_CHASSIS_SERIALNUM,
                    DP_GET_CHASSIS_SERIALNUM_R, sizeof (rmc_serialnum_r),
                    (intptr_t)NULL, (intptr_t)&rmc_serialnum_r);

                if (retval != 0) {
                        break;
                }
                bcopy(rmc_serialnum_r.chassis_serial_number,
                    chassis.serial_number,
                    sizeof (rmc_serialnum_r.chassis_serial_number));

                if (ddi_copyout((caddr_t)&chassis, (caddr_t)arg,
                    sizeof (chassis), mode) != 0) {
                        return (EFAULT);
                }
                sensor_status = ENVMON_SENSOR_OK;
                break;

        default:
                retval = ENOTSUP;
                break;
        }

        return (retval);
}

/* ARGSUSED */
static void
rmclomv_checkrmc(caddr_t arg)
{
        callb_cpr_t             cprinfo;
        int                     err;
        int                     retries;
        int                     state;
        dp_get_sysinfo_r_t      sysinfo;

        CALLB_CPR_INIT(&cprinfo, &rmclomv_checkrmc_lock, callb_generic_cpr,
            "rmclomv_checkrmc");

        mutex_enter(&rmclomv_checkrmc_lock);
        for (;;) {
                /*
                 * Initial entry to this for loop is made with
                 * rmclomv_checkrmc_sig set to RMCLOMV_PROCESS_NOW. So the
                 * following while loop drops through the first time. A
                 * timeout call is made just before polling the RMC. Its
                 * interrupt routine sustains this loop by injecting additional
                 * state changes and cv events.
                 */
                /*
                 * Wait for someone to tell me to continue.
                 */
                while (rmclomv_checkrmc_sig == RMCLOMV_CHECKRMC_WAIT) {
                        CALLB_CPR_SAFE_BEGIN(&cprinfo);
                        cv_wait(&rmclomv_checkrmc_sig_cv,
                            &rmclomv_checkrmc_lock);
                        CALLB_CPR_SAFE_END(&cprinfo, &rmclomv_checkrmc_lock);
                }

                mutex_exit(&rmclomv_checkrmc_lock);
                /*
                 * mustn't hold same lock as timeout called with
                 * when cancelling timer
                 */
                if (timer_id != 0) {
                        (void) untimeout(timer_id);
                        timer_id = 0;
                }
                mutex_enter(&rmclomv_checkrmc_lock);

                /* RMCLOMV_CHECKRMC_EXITNOW implies signal by _detach(). */
                if (rmclomv_checkrmc_sig == RMCLOMV_CHECKRMC_EXITNOW) {
                        rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_WAIT;

                        /* rmclomv_checkrmc_lock is held at this point! */
                        CALLB_CPR_EXIT(&cprinfo);

                        thread_exit();
                        /* NOTREACHED */
                }

                rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_WAIT;

                /*
                 * If the RMC is not responding, rmclomv_do_cmd() takes a
                 * long time and eventually times out. We conclude that the
                 * RMC is broken if it doesn't respond to a number of polls
                 * made 60 secs apart. So that the rmclomv_do_cmd() time-out
                 * period isn't added to our 60 second timer, make the
                 * timeout() call before calling rmclomv_do_cmd().
                 */
                if (timer_id == 0) {
                        timer_id = timeout(rmclomv_checkrmc_wakeup, NULL,
                            60 * drv_usectohz(1000000));
                }

                mutex_exit(&rmclomv_checkrmc_lock);

                err = rmclomv_do_cmd(DP_GET_SYSINFO, DP_GET_SYSINFO_R,
                    sizeof (sysinfo), (intptr_t)NULL, (intptr_t)&sysinfo);
                if (err == 0) {
                        mutex_enter(&rmclomv_state_lock);
                        state = rmclomv_rmc_state;
                        /* successful poll, reset fail count */
                        rmclomv_rmcfailcount = 0;
                        mutex_exit(&rmclomv_state_lock);

                        if (state != RMCLOMV_RMCSTATE_OK) {
                                rmclomv_refresh_wakeup();
                        }
                }
                if ((err != 0) &&
                    (rmclomv_rmc_error != RMCLOMV_RMCSTATE_DOWNLOAD)) {
                        /*
                         * Failed response or no response from RMC.
                         * Count the failure.
                         * If threshold exceeded, send a DR event.
                         */
                        mutex_enter(&rmclomv_state_lock);
                        retries = rmclomv_rmcfailcount;
                        state = rmclomv_rmc_state;
                        if (retries == RMCLOMV_RMCFAILTHRESHOLD)
                                rmclomv_rmc_state = RMCLOMV_RMCSTATE_FAILED;
                        if (rmclomv_rmcfailcount <= RMCLOMV_RMCFAILTHRESHOLD)
                                rmclomv_rmcfailcount++;
                        mutex_exit(&rmclomv_state_lock);

                        if (retries == RMCLOMV_RMCFAILTHRESHOLD) {
                                cmn_err(CE_WARN, "SC %s responding",
                                    state == RMCLOMV_RMCSTATE_OK ?
                                    "has stopped" : "is not");
                                refresh_name_cache(B_TRUE);
                                rmclomv_dr_data_handler(str_sc, SE_NO_HINT);
                        }
                }

                /*
                 * Re-enter the lock to prepare for another iteration.
                 * We must have the lock here to protect rmclomv_checkrmc_sig.
                 */
                mutex_enter(&rmclomv_checkrmc_lock);
        }
}

static void
rmclomv_checkrmc_start(void)
{
        kthread_t *tp;

        mutex_enter(&rmclomv_checkrmc_lock);

        if (rmclomv_checkrmc_tid == 0) {
                rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_PROCESSNOW;

                tp = thread_create(NULL, 0, rmclomv_checkrmc, NULL, 0,
                    &p0, TS_RUN, maxclsyspri);
                rmclomv_checkrmc_tid = tp->t_did;
        }

        mutex_exit(&rmclomv_checkrmc_lock);
}

static void
rmclomv_checkrmc_destroy(void)
{
        kt_did_t tid;

        mutex_enter(&rmclomv_checkrmc_lock);
        tid = rmclomv_checkrmc_tid;
        if (tid != 0) {
                rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_EXITNOW;
                cv_signal(&rmclomv_checkrmc_sig_cv);
                rmclomv_checkrmc_tid = 0;
        }
        mutex_exit(&rmclomv_checkrmc_lock);

        /*
         * Wait for rmclomv_checkrmc() to finish
         */
        if (tid != 0)
                thread_join(tid);
}

/*ARGSUSED*/
static void
rmclomv_checkrmc_wakeup(void *arg)
{
        mutex_enter(&rmclomv_checkrmc_lock);

        if (rmclomv_checkrmc_sig != RMCLOMV_CHECKRMC_EXITNOW)
                rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_PROCESSNOW;
        cv_signal(&rmclomv_checkrmc_sig_cv);

        mutex_exit(&rmclomv_checkrmc_lock);
}

/* ARGSUSED */
static void
rmclomv_refresh(caddr_t arg)
{
        void                    (*plat_nodename_set_fun)(void);
        sig_state_t             *current_sgn_p;
        callb_cpr_t             cprinfo;
        int                     state;
        int                     tmp_checkrmc_sig;

        CALLB_CPR_INIT(&cprinfo, &rmclomv_refresh_lock, callb_generic_cpr,
            "rmclomv_refresh");

        /*
         * Wait until the rmclomv_checkrmc() thread has had a chance to
         * run its main loop.  This is done so that rmclomv_refresh will
         * only run its main loop once at start of day; otherwise, it may
         * run twice and generate warning messages when redundantly populating
         * its internal cache.
         */
        do {
                delay(drv_usectohz(DELAY_TIME));
                mutex_enter(&rmclomv_checkrmc_lock);
                tmp_checkrmc_sig = rmclomv_checkrmc_sig;
                mutex_exit(&rmclomv_checkrmc_lock);
        } while (tmp_checkrmc_sig != RMCLOMV_CHECKRMC_WAIT);

        mutex_enter(&rmclomv_refresh_lock);
        for (;;) {

                /*
                 * Wait for someone to tell me to continue.
                 */
                while (rmclomv_refresh_sig == RMCLOMV_REFRESH_WAIT) {
                        CALLB_CPR_SAFE_BEGIN(&cprinfo);
                        cv_wait(&rmclomv_refresh_sig_cv, &rmclomv_refresh_lock);
                        CALLB_CPR_SAFE_END(&cprinfo, &rmclomv_refresh_lock);
                }

                /* RMCLOMV_REFRESH_EXITNOW implies signal by _detach(). */
                if (rmclomv_refresh_sig == RMCLOMV_REFRESH_EXITNOW) {
                        rmclomv_refresh_sig = RMCLOMV_REFRESH_WAIT;

                        /* rmclomv_refresh_lock is held at this point! */
                        CALLB_CPR_EXIT(&cprinfo);

                        thread_exit();
                        /* NOTREACHED */
                }

                ASSERT(rmclomv_refresh_sig == RMCLOMV_REFRESH_PROCESSNOW);
                rmclomv_refresh_sig = RMCLOMV_REFRESH_WAIT;

                mutex_exit(&rmclomv_refresh_lock);

                refresh_name_cache(B_FALSE);

                /*
                 * We're not going to access rmclomv_sysinfo_data here,
                 * so there's no point in locking it before reading
                 * rmclomv_sysinfo_valid. Also this avoids holding two
                 * locks at once and the concommitant worry about deadlocks.
                 */
                if (rmclomv_sysinfo_valid) {
                        /*
                         * We've just successfully read the RMC sysinfo
                         * so the RMC must be operational. Update its
                         * state and if it was previously not OK, refresh
                         * nodename, CPU signatures and watchdog settings.
                         */
                        mutex_enter(&rmclomv_state_lock);
                        rmclomv_rmcfailcount = 0;
                        state = rmclomv_rmc_state;
                        rmclomv_rmc_state = RMCLOMV_RMCSTATE_OK;
                        mutex_exit(&rmclomv_state_lock);

                        if (state != RMCLOMV_RMCSTATE_OK) {
                                rmclomv_dr_data_handler(str_sc, SE_NO_HINT);
                                if (state == RMCLOMV_RMCSTATE_FAILED) {
                                        cmn_err(CE_NOTE, "SC recovered");
                                }
                        }

                        if (utsname.nodename[0] != 0) {
                                plat_nodename_set_fun =
                                    (void (*)(void))modgetsymvalue(
                                    "plat_nodename_set", 0);
                                if (plat_nodename_set_fun != NULL)
                                        plat_nodename_set_fun();
                        }

                        current_sgn_p = (sig_state_t *)modgetsymvalue(
                            "current_sgn", 0);

                        /*
                         * Delay before calling CPU_SIGNATURE, to allow
                         * any pending asynchronous communications (i.e.
                         * plat_timesync()) to complete.  This helps to
                         * prevent the situation where the message associated
                         * with the CPU_SIGNATURE state cannot be sent to the
                         * system controller.
                         */
                        if ((current_sgn_p != NULL) &&
                            (current_sgn_p->state_t.sig != 0)) {
                                delay(drv_usectohz(CPU_SIGNATURE_DELAY_TIME));
                                CPU_SIGNATURE(current_sgn_p->state_t.sig,
                                    current_sgn_p->state_t.state,
                                    current_sgn_p->state_t.sub_state, -1);

                                if (!(boothowto & RB_DEBUG)) {
                                        /*
                                         * Delay before calling
                                         * send_watchdog_msg, to allow
                                         * CPU_SIGNATURE() time to
                                         * complete; this increases the
                                         * chances of successfully sending
                                         * the watchdog message to the
                                         * system controller.
                                         */
                                        delay(drv_usectohz(
                                            CPU_SIGNATURE_DELAY_TIME));
                                        send_watchdog_msg(last_watchdog_msg);
                                }
                        }
                }

                /*
                 * update keyswitch value in case it changed while the
                 * RMC was out of action
                 */
                LOCK_CACHE
                if (rmclomv_sysinfo_valid) {
                        real_key_position = rmclomv_sysinfo_data.keyswitch;
                        if ((real_key_position != RMC_KEYSWITCH_POS_UNKNOWN) &&
                            (real_key_position <= RMC_KEYSWITCH_POS_OFF)) {
                                key_position = real_key_position;
                        } else {
                                /* treat unknown key position as locked */
                                key_position = RMC_KEYSWITCH_POS_LOCKED;
                        }
                } else {
                        /* treat unreadable key position as locked */
                        key_position = RMC_KEYSWITCH_POS_LOCKED;
                        real_key_position = RMC_KEYSWITCH_POS_UNKNOWN;
                }
                RELEASE_CACHE

                /*
                 * Re-enter the lock to prepare for another iteration.
                 * We must have the lock here to protect rmclomv_refresh_sig.
                 */
                mutex_enter(&rmclomv_refresh_lock);
        }
}

static void
rmclomv_refresh_start(void)
{
        kthread_t *tp;

        mutex_enter(&rmclomv_refresh_lock);

        if (rmclomv_refresh_tid == 0) {
                rmclomv_refresh_sig = RMCLOMV_REFRESH_PROCESSNOW;

                tp = thread_create(NULL, 0, rmclomv_refresh, NULL, 0,
                    &p0, TS_RUN, maxclsyspri);
                rmclomv_refresh_tid = tp->t_did;
        }

        mutex_exit(&rmclomv_refresh_lock);
}

static void
rmclomv_refresh_destroy(void)
{
        kt_did_t tid;

        mutex_enter(&rmclomv_refresh_lock);
        tid = rmclomv_refresh_tid;
        if (tid != 0) {
                rmclomv_refresh_sig = RMCLOMV_REFRESH_EXITNOW;
                cv_signal(&rmclomv_refresh_sig_cv);
                rmclomv_refresh_tid = 0;
        }
        mutex_exit(&rmclomv_refresh_lock);

        /*
         * Wait for rmclomv_refresh() to finish
         */
        if (tid != 0)
                thread_join(tid);
}

static void
rmclomv_refresh_wakeup(void)
{
        mutex_enter(&rmclomv_refresh_lock);

        if (rmclomv_refresh_sig != RMCLOMV_REFRESH_EXITNOW)
                rmclomv_refresh_sig = RMCLOMV_REFRESH_PROCESSNOW;
        cv_signal(&rmclomv_refresh_sig_cv);

        mutex_exit(&rmclomv_refresh_lock);
}

static void
send_watchdog_msg(int msg)
{
        rmc_comm_msg_t request;
        dp_set_host_watchdog_t watchdog_msg;

        if (rmclomv_watchdog_mode)
                return;

        watchdog_msg.enable = msg;
        request.msg_type = DP_SET_HOST_WATCHDOG;
        request.msg_len = sizeof (watchdog_msg);
        request.msg_buf = (caddr_t)&watchdog_msg;
        (void) rmc_comm_request_nowait(&request, (msg == 1) ?
            RMC_COMM_DREQ_URGENT : 0);
}

/*ARGSUSED*/
static uint_t
rmc_set_watchdog_timer(uint_t timeoutval)
{
        ASSERT(MUTEX_HELD(&tod_lock));

        if ((watchdog_enable == 0) || (watchdog_available == 0)) {
                return (0);
        }

        /*
         * If boothowto has RB_DEBUG set we never want to set the watchdog
         * support on.
         */
        if (boothowto & RB_DEBUG) {
                return (0);
        }

        /*
         * When the watchdog is shut off last_watchdog_msg goes from a
         * 0 to a 1. So we must test to see that last_watchdog_msg is
         * set to 1 indicating that watchdog was shut off and
         * After which we set last_watchdog_msg back to 0 so that we do not
         * run this code
         * again.
         */
        if (last_watchdog_msg == 1) {
                send_watchdog_msg(0);
                last_watchdog_msg = 0;
        }

        pmugpio_watchdog_pat();

        watchdog_activated = 1;

        return (1);
}

static uint_t
rmc_clear_watchdog_timer(void)
{
        ASSERT(MUTEX_HELD(&tod_lock));
        if ((watchdog_activated == 0) || (boothowto & RB_DEBUG))
                return (0);

        send_watchdog_msg(1);
        last_watchdog_msg = 1;
        watchdog_activated = 0;

        return (0);
}

static void
plat_timesync(void *arg)
{
        timestruc_t now;
        todinfo_t tod;
        rmc_comm_msg_t request;
        dp_set_date_time_t set_time_msg;
        int retval;
        timestruc_t ts;
        dp_get_date_time_r_t *date_and_time_info;
        int buffer[DATE_TIME_MSG_SIZE];

        /* Is the system coming up? */
        if (arg != NULL) {
                /* Request the time from the RMC clock. */
                retval = rmclomv_do_cmd(DP_GET_DATE_TIME, DP_GET_DATE_TIME_R,
                    DATE_TIME_MSG_SIZE, (intptr_t)NULL, (intptr_t)&buffer);

                /*
                 * If we were able to get the time lets set the local clock.
                 * The time returned from RMC is in Unix time format.
                 *
                 * If we couldn't get the time we'll accept the drift so as not
                 * to cause congestion on the I2C bus or cause boot
                 * performance regressions.
                 */
                if (retval == RCNOERR) {
                        date_and_time_info = (dp_get_date_time_r_t *)buffer;
                        ts.tv_sec = date_and_time_info->current_datetime;
                        ts.tv_nsec = 0;
                        mutex_enter(&tod_lock);
                        tod_set(ts);
                        set_hrestime(&ts);
                        mutex_exit(&tod_lock);
                }
        }

        gethrestime(&now);
        mutex_enter(&tod_lock);
        tod = utc_to_tod(now.tv_sec);
        mutex_exit(&tod_lock);

        set_time_msg.year       = tod.tod_year;
        set_time_msg.month      = tod.tod_month - 1;
        set_time_msg.day        = tod.tod_day;
        set_time_msg.hour       = tod.tod_hour;
        set_time_msg.minute     = tod.tod_min;
        set_time_msg.second     = tod.tod_sec;

        request.msg_type = DP_SET_DATE_TIME;
        request.msg_len = sizeof (set_time_msg);
        request.msg_buf = (caddr_t)&set_time_msg;

        (void) rmc_comm_request_nowait(&request, 0);

        mutex_enter(&timesync_lock);
        if (timesync_interval != 0)
                timesync_tid = timeout(plat_timesync, NULL, timesync_interval);
        mutex_exit(&timesync_lock);
}

/*
 * Interfaces to get/set alarm relays from outside
 */
int
rmclomv_alarm_get(int alarm_type, int *alarm_state)
{
        rmclomv_cache_section_t *section;
        int                     index;
        uint16_t                sensor_status;
        dp_get_alarm_state_t    u_rmc_alarm;
        dp_get_alarm_state_r_t  u_rmc_alarm_r;

        /* see if we've got ALARM handles cached */
        LOCK_CACHE
        sensor_status = ENVMON_SENSOR_OK;

        if ((rmclomv_cache_valid == B_FALSE) ||
            ((section = rmclomv_find_section(rmclomv_cache,
            RMCLOMV_ALARM_IND)) == NULL)) {
                sensor_status = ENVMON_NOT_PRESENT;
        }
        if (sensor_status == ENVMON_SENSOR_OK) {
                /*
                 * user correctly identified a ALARM, note its
                 * handle value and request the ALARM status
                 */
                index = alarm_type;
                if (index >= section->num_entries)
                        sensor_status = ENVMON_INACCESSIBLE;
                else
                        u_rmc_alarm.handle = section->entry[index].handle;
        }
        RELEASE_CACHE
        if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
            rmclomv_do_cmd(DP_GET_ALARM_STATE, DP_GET_ALARM_STATE_R,
            sizeof (u_rmc_alarm_r), (intptr_t)&u_rmc_alarm,
            (intptr_t)&u_rmc_alarm_r) != 0)) {
                sensor_status = ENVMON_INACCESSIBLE;
        }
        if (sensor_status == ENVMON_SENSOR_OK) {
                /*
                 * copy results into buffer for user
                 * start with some defaults then override
                 */
                *alarm_state = 0;

                if (u_rmc_alarm_r.alarm_state[0].sensor_status !=
                    DP_SENSOR_DATA_AVAILABLE)
                        return (ENXIO);
                else {
                        dp_alarm_state_t alarmState;
                        alarmState = u_rmc_alarm_r.alarm_state[0];

                        switch (alarmState.state) {
                        case DP_ALARM_OFF:
                                break;
                        case DP_ALARM_ON:
                                *alarm_state = 1;
                                break;
                        default:
                                break;
                        }
                }
        } else
                return (ENXIO);

        return (0);
}

int
rmclomv_alarm_set(int alarm_type, int new_state)
{
        rmclomv_cache_section_t *section;
        int                     index;
        uint16_t                sensor_status;
        dp_set_alarm_state_t    u_rmc_setalarm;
        dp_set_alarm_state_r_t  u_rmc_setalarm_r;

        /* see if we've got ALARM handles cached */
        LOCK_CACHE
        sensor_status = ENVMON_SENSOR_OK;

        if ((rmclomv_cache_valid == B_FALSE) ||
            ((section = rmclomv_find_section(rmclomv_cache,
            RMCLOMV_ALARM_IND)) == NULL)) {
                sensor_status = ENVMON_NOT_PRESENT;
        }
        if (sensor_status == ENVMON_SENSOR_OK) {
                /*
                 * user correctly identified a ALARM, note its
                 * handle value and request the ALARM status
                 */
                index = alarm_type;
                if (index >= section->num_entries)
                        sensor_status = ENVMON_INACCESSIBLE;
                else {
                        u_rmc_setalarm.handle = section->entry[index].handle;
                        u_rmc_setalarm.state = new_state;
                }
        }
        RELEASE_CACHE
        if ((sensor_status == ENVMON_SENSOR_OK) &&
            (rmclomv_rmc_error ||
            rmclomv_do_cmd(DP_SET_ALARM_STATE, DP_SET_ALARM_STATE_R,
            sizeof (u_rmc_setalarm_r), (intptr_t)&u_rmc_setalarm,
            (intptr_t)&u_rmc_setalarm_r) != 0)) {
                sensor_status = ENVMON_INACCESSIBLE;
        }

        if (u_rmc_setalarm_r.status != DP_SET_ALARM_OK) {
                return (EIO);
        }

        if (sensor_status != ENVMON_SENSOR_OK) {
                return (ENXIO);
        }

        return (0);
}